Repository: qgindi/LibreAutomate
Branch: master
Commit: 7121bef44741
Files: 768
Total size: 10.8 MB

Directory structure:
gitextract__t3y79t8/

├── .editorconfig
├── .gitattributes
├── .github/
│   └── FUNDING.yml
├── .gitignore
├── Au/
│   ├── Api/
│   │   ├── Api.cs
│   │   ├── Api^kernel32.cs
│   │   ├── Api^user32.cs
│   │   ├── Api_COM.cs
│   │   ├── Api_UIA.cs
│   │   ├── Api_const.cs
│   │   ├── Api_public.cs
│   │   ├── Cpp.cs
│   │   └── WinRT.cs
│   ├── Au.More/
│   │   ├── AppSingleInstance.cs
│   │   ├── BufferedPaint.cs
│   │   ├── CheckListDialog.cs
│   │   ├── ComUtil.cs
│   │   ├── Convert2.cs
│   │   ├── DebugTraceListener.cs
│   │   ├── Dpi.cs
│   │   ├── FastBuffer.cs
│   │   ├── FileOpenSaveDialog.cs
│   │   ├── GdiTextRenderer.cs
│   │   ├── Hash.cs
│   │   ├── HelpUtil.cs
│   │   ├── HttpServerSession.cs
│   │   ├── IconImageCache.cs
│   │   ├── ImageUtil.cs
│   │   ├── KeyToTextConverter.cs
│   │   ├── Math2.cs
│   │   ├── MemoryBitmap.cs
│   │   ├── MemoryUtil.cs
│   │   ├── MenuItemInfo.cs
│   │   ├── MouseCursor.cs
│   │   ├── RecordingUtil.cs
│   │   ├── ResourceUtil.cs
│   │   ├── SecurityUtil.cs
│   │   ├── WaitableTimer.cs
│   │   ├── WinEventHook.cs
│   │   ├── WindowsHook.cs
│   │   └── WinformsControlNames.cs
│   ├── Au.Types/
│   │   ├── ColorInt.cs
│   │   ├── JSettings.cs
│   │   ├── TreeBase.cs
│   │   ├── common.cs
│   │   ├── exceptions.cs
│   │   ├── param types.cs
│   │   ├── structs.cs
│   │   └── unused/
│   │       └── AuClassless.cs
│   ├── Au.cs
│   ├── Au.csproj
│   ├── Ext/
│   │   ├── Bitmap.Resize.cs
│   │   ├── ExtMisc.cs
│   │   ├── ExtWpf.cs
│   │   └── ExtXml.cs
│   ├── Files, data/
│   │   ├── ExplorerFolder.cs
│   │   ├── FileSystemRedirection.cs
│   │   ├── FileTree.cs
│   │   ├── FileWatcher.cs
│   │   ├── Pidl.cs
│   │   ├── TempFile.cs
│   │   ├── filesystem-types.cs
│   │   ├── filesystem.cs
│   │   ├── filesystem.more.cs
│   │   ├── folders.cs
│   │   ├── icon.cs
│   │   ├── pathname.cs
│   │   ├── shortcutFile.cs
│   │   ├── sqlite.cs
│   │   └── sqlite_api.cs
│   ├── GUI/
│   │   ├── EnumUI.cs
│   │   ├── dialog-static.cs
│   │   ├── dialog-types.cs
│   │   ├── dialog-x-obsolete.cs
│   │   ├── dialog.cs
│   │   ├── osd.cs
│   │   ├── popupMenu/
│   │   │   ├── MTBase.cs
│   │   │   ├── pm acc.cs
│   │   │   ├── pm render.cs
│   │   │   ├── pm types.cs
│   │   │   └── popupMenu.cs
│   │   ├── toolbar/
│   │   │   ├── tb acc.cs
│   │   │   ├── tb dialog.cs
│   │   │   ├── tb man.cs
│   │   │   ├── tb render.cs
│   │   │   ├── tb sat.cs
│   │   │   ├── tb types.cs
│   │   │   ├── tb util.cs
│   │   │   └── toolbar.cs
│   │   ├── trayIcon.cs
│   │   ├── wpf-types.cs
│   │   └── wpfBuilder.cs
│   ├── Input/
│   │   ├── RegisteredHotkey.cs
│   │   ├── clipboard.cs
│   │   ├── clipboardData.cs
│   │   ├── inputBlocker.cs
│   │   ├── keys.cs
│   │   ├── keys.more.cs
│   │   ├── keys_static.cs
│   │   ├── keys_types.cs
│   │   ├── keys_util.cs
│   │   ├── miscInfo.cs
│   │   ├── mouse.cs
│   │   └── mouse_types.cs
│   ├── Internal/
│   │   ├── ActCtx_.cs
│   │   ├── ArrayBuilder_.cs
│   │   ├── AssemblyUtil_.cs
│   │   ├── AttachThreadInput_.cs
│   │   ├── Debug_.cs
│   │   ├── GC_.cs
│   │   ├── GDI misc.cs
│   │   ├── Handle_.cs
│   │   ├── ILReader.cs
│   │   ├── IconString_.cs
│   │   ├── Jit_.cs
│   │   ├── LaDebugger_.cs
│   │   ├── LineWriter_.cs
│   │   ├── MiniProgram_.cs
│   │   ├── NamespaceDoc.cs
│   │   ├── NativeFont_.cs
│   │   ├── NativeScrollbar_.cs
│   │   ├── NativeThread_.cs
│   │   ├── PostToThisThread_.cs
│   │   ├── ProcessStarter_.cs
│   │   ├── Ptr_.cs
│   │   ├── Serializer_.cs
│   │   ├── SharedMemory_.cs
│   │   ├── StaTaskScheduler_.cs
│   │   ├── StringBuilder_.cs
│   │   ├── Util_.cs
│   │   ├── misc_.cs
│   │   └── tables.cs
│   ├── Other/
│   │   ├── PrintServer.cs
│   │   ├── ScriptEditor.cs
│   │   ├── internet.cs
│   │   ├── lastError.cs
│   │   ├── opt.cs
│   │   ├── print.cs
│   │   ├── screen.cs
│   │   ├── script+.cs
│   │   └── script.cs
│   ├── Resources/
│   │   ├── AssemblyInfo.cs
│   │   └── red_cross_cursor.cur
│   ├── String/
│   │   ├── ExtString.cs
│   │   ├── SegParser.cs
│   │   ├── StringUtil.cs
│   │   ├── csvTable.cs
│   │   ├── regexp.cs
│   │   ├── regexp_ExtString.cs
│   │   ├── regexp_types.cs
│   │   └── wildcard.cs
│   ├── System/
│   │   ├── CpuUsage.cs
│   │   ├── ProcessMemory.cs
│   │   ├── computer.cs
│   │   ├── consoleProcess.cs
│   │   ├── osVersion.cs
│   │   ├── process.cs
│   │   ├── run.cs
│   │   ├── sound.cs
│   │   └── uacInfo.cs
│   ├── Time/
│   │   ├── WaitLoop.cs
│   │   ├── perf.cs
│   │   ├── timer.cs
│   │   ├── timer2.cs
│   │   ├── wait.cs
│   │   └── wait_for.cs
│   ├── Triggers/
│   │   ├── Trigger.cs
│   │   ├── Triggers.cs
│   │   ├── TriggersListWindow.cs
│   │   ├── Triggers_actions.cs
│   │   ├── Triggers_hooks.cs
│   │   ├── Triggers_util.cs
│   │   └── Types/
│   │       ├── t-autotext.cs
│   │       ├── t-hotkey.cs
│   │       ├── t-mouse.cs
│   │       └── t-window.cs
│   ├── UI objects/
│   │   ├── CaptureScreen.cs
│   │   ├── OcrGoogleCloud.cs
│   │   ├── OcrMicrosoftAzure.cs
│   │   ├── OcrTesseract.cs
│   │   ├── OcrWin10.cs
│   │   ├── elm.cs
│   │   ├── elmFinder.cs
│   │   ├── elm_func.cs
│   │   ├── elm_types.cs
│   │   ├── ocr.cs
│   │   ├── ocrFinder.cs
│   │   ├── ocr_types.cs
│   │   ├── uiimage.cs
│   │   ├── uiimageFinder.cs
│   │   └── uiimage_types.cs
│   ├── resources/
│   │   └── global2.cs
│   ├── wnd/
│   │   ├── WProp.cs
│   │   ├── WTaskbarButton.cs
│   │   ├── WndCopyData.cs
│   │   ├── WndSavedRect.cs
│   │   ├── WndUtil.cs
│   │   ├── inactive/
│   │   │   └── desktop.cs
│   │   ├── wnd.cs
│   │   ├── wndChildFinder.cs
│   │   ├── wndFinder.cs
│   │   ├── wnd_child.cs
│   │   ├── wnd_find.cs
│   │   ├── wnd_fromxy.cs
│   │   ├── wnd_get.cs
│   │   ├── wnd_other.cs
│   │   ├── wnd_private.cs
│   │   └── wnd_wait.cs
│   └── x/
│       └── NuGet.md
├── Au.AppHost/
│   ├── AppHost.cpp
│   ├── Au.AppHost.vcxproj
│   ├── Au.AppHost.vcxproj.filters
│   ├── ResourceHacker.txt
│   └── coreclrhost.h
├── Au.Controls/
│   ├── Au.Controls.cs
│   ├── Au.Controls.csproj
│   ├── KMenuCommands/
│   │   ├── KMenuCommands+.cs
│   │   └── KMenuCommands.cs
│   ├── KPanels/
│   │   ├── FlexStackPanel.cs
│   │   ├── ILeaf.cs
│   │   ├── KPanels.cs
│   │   ├── _Floating.cs
│   │   ├── _Node.cs
│   │   ├── dock.cs
│   │   ├── stack.cs
│   │   └── tab.cs
│   ├── KScintilla/
│   │   ├── KScintilla.cs
│   │   ├── Sci API.cs
│   │   ├── Sci adapter.cs
│   │   ├── Sci loader.cs
│   │   ├── Sci other.cs
│   │   ├── Sci styles.cs
│   │   ├── Sci text.cs
│   │   ├── SciImages.cs
│   │   ├── SciTags.cs
│   │   ├── SciTextBuilder.cs
│   │   └── other/
│   │       └── KSciInfoBox.cs
│   ├── KTreeView/
│   │   ├── KTreeView.cs
│   │   ├── tv-acc.cs
│   │   ├── tv-hh.cs
│   │   ├── tv-misc.cs
│   │   ├── tv-render.cs
│   │   └── tv-types.cs
│   ├── Simple/
│   │   ├── KCheckBox.cs
│   │   ├── KCheckDropdownBox.cs
│   │   ├── KColorPicker.cs
│   │   ├── KDateTime.cs
│   │   ├── KDialogWindow.cs
│   │   ├── KGroupBox.cs
│   │   ├── KHotkeyControl.cs
│   │   ├── KListBoxItemWithImage.cs
│   │   ├── KPasswordBox.cs
│   │   ├── KPopup.cs
│   │   ├── KPopupListBox.cs
│   │   ├── KScreenComboBox.cs
│   │   ├── KTextBox.cs
│   │   └── KWpfMenu.cs
│   ├── Util, Api/
│   │   ├── HwndHostAccessibleBase_.cs
│   │   ├── KApi.cs
│   │   ├── KExtWpf.cs
│   │   └── KImageUtil.cs
│   └── resources/
│       ├── AssemblyInfo.cs
│       ├── Generic.xaml
│       └── XamlResources.cs
├── Au.Editor/
│   ├── App/
│   │   ├── App-resources.xaml
│   │   ├── App.TrayIcon.cs
│   │   ├── App.cs
│   │   ├── AppSettings.cs
│   │   ├── CommandLine.cs
│   │   ├── DOptions.cs
│   │   ├── MainWindow.cs
│   │   └── Menus.cs
│   ├── Au.Editor.cs
│   ├── Au.Editor.csproj
│   ├── Compiler/
│   │   ├── Compiler.cs
│   │   ├── EditorExtension.cs
│   │   ├── ErrBuilder.cs
│   │   ├── MetaComments.cs
│   │   ├── MetaReferences.cs
│   │   ├── RecentTT.cs
│   │   ├── Run task.cs
│   │   ├── TestInternal.cs
│   │   ├── XCompiled.cs
│   │   ├── XPublish.cs
│   │   └── util/
│   │       ├── CompilerUtil.cs
│   │       └── Compiler_resources.cs
│   ├── Debugger/
│   │   ├── PD-stack.cs
│   │   ├── PD-variables.cs
│   │   ├── PD._Debugger.cs
│   │   ├── PD._MiRecord.cs
│   │   ├── PanelBreakpoints.cs
│   │   └── PanelDebug.cs
│   ├── Default/
│   │   ├── Commands.xml
│   │   ├── Layout.xml
│   │   ├── Snippets.xml
│   │   └── Themes/
│   │       ├── Material dark.csv
│   │       ├── One Monokai dark.csv
│   │       └── Visual Studio dark.csv
│   ├── Edit/
│   │   ├── Ci-types.cs
│   │   ├── CiAutocorrect.cs
│   │   ├── CiCompletion.cs
│   │   ├── CiErrors.cs
│   │   ├── CiFind.cs
│   │   ├── CiFindGo.cs
│   │   ├── CiFolding.cs
│   │   ├── CiGoTo.cs
│   │   ├── CiPopupList.cs
│   │   ├── CiPopupText.cs
│   │   ├── CiProjects.cs
│   │   ├── CiQuickInfo.cs
│   │   ├── CiSignature.cs
│   │   ├── CiSnippets.cs
│   │   ├── CiStyling.cs
│   │   ├── CiText.cs
│   │   ├── CiTools.cs
│   │   ├── CiUtil.cs
│   │   ├── CiUtilExt.cs
│   │   ├── CiWinapi.cs
│   │   ├── CiWorkspace.cs
│   │   ├── CodeExporter.cs
│   │   ├── CodeInfo.cs
│   │   ├── EditGoBack.cs
│   │   ├── GenerateCode.cs
│   │   ├── InsertCode.cs
│   │   ├── ModifyCode.cs
│   │   ├── PanelEdit.cs
│   │   ├── Sci-DD.cs
│   │   ├── Sci-TR.cs
│   │   ├── Sci-images.cs
│   │   ├── SciCode.cs
│   │   ├── SciTheme.cs
│   │   └── SciUndo.cs
│   ├── Files/
│   │   ├── DProperties.cs
│   │   ├── FileNode.cs
│   │   ├── Files+.cs
│   │   ├── FilesModel.cs
│   │   ├── FilesView.cs
│   │   ├── Git.cs
│   │   ├── Save.cs
│   │   ├── SyncWithFilesystem.cs
│   │   └── WorkspaceState.cs
│   ├── LibreAutomate.iss
│   ├── Panels/
│   │   ├── PanelBookmarks.cs
│   │   ├── PanelFiles.cs
│   │   ├── PanelFind.cs
│   │   ├── PanelFound.cs
│   │   ├── PanelHelp.cs
│   │   ├── PanelMouse.cs
│   │   ├── PanelOpen.cs
│   │   ├── PanelOutline.cs
│   │   ├── PanelOutput.cs
│   │   ├── PanelRead.cs
│   │   ├── PanelTasks.cs
│   │   └── Panels.cs
│   ├── Properties/
│   │   └── launchSettings.json
│   ├── Test.cs
│   ├── Tools/
│   │   ├── CapturingWithHotkey.cs
│   │   ├── ColorQuantizer.cs
│   │   ├── DCustomize.cs
│   │   ├── DCustomizeContextMenu.cs
│   │   ├── DEnumFiles.cs
│   │   ├── DIcons.cs
│   │   ├── DInputRecorder.cs
│   │   ├── DPortable.cs
│   │   ├── DPwnd.cs
│   │   ├── DSnippets.cs
│   │   ├── DWinapi.cs
│   │   ├── Delm.cs
│   │   ├── Dnuget.cs
│   │   ├── Docr.cs
│   │   ├── Duiimage.cs
│   │   ├── Dwnd.cs
│   │   ├── InfoWindow.cs
│   │   ├── KSciCodeBox.cs
│   │   ├── KSciCodeBoxWnd.cs
│   │   ├── KTextExpressionBox.cs
│   │   ├── KeysWindow.cs
│   │   ├── QuickCapture.cs
│   │   ├── RegexWindow.cs
│   │   ├── Scripting.cs
│   │   ├── TUtil-main-process.cs
│   │   ├── TUtil.cs
│   │   ├── ToolProcess.cs
│   │   └── WindowFindCodeFormatter.cs
│   ├── Triggers and toolbars/
│   │   ├── DCommandline.cs
│   │   ├── DSchedule.cs
│   │   ├── TT-tb.cs
│   │   ├── TT-triggers.cs
│   │   ├── TT._CodeAnalysis.cs
│   │   ├── TriggersAndToolbars.cs
│   │   └── WinScheduler.cs
│   ├── _prePostBuild.cs
│   ├── resources/
│   │   ├── AssemblyInfo.cs
│   │   ├── Au.manifest
│   │   └── ci/
│   │       ├── Class.xaml
│   │       ├── Constant.xaml
│   │       ├── Delegate.xaml
│   │       ├── Enum.xaml
│   │       ├── EnumMember.xaml
│   │       ├── Event.xaml
│   │       ├── ExpandScope.xaml
│   │       ├── ExtensionMethod.xaml
│   │       ├── Field.xaml
│   │       ├── GroupBy.xaml
│   │       ├── Interface.xaml
│   │       ├── Keyword.xaml
│   │       ├── Label.xaml
│   │       ├── LocalMethod.xaml
│   │       ├── LocalVariable.xaml
│   │       ├── Method.xaml
│   │       ├── Namespace.xaml
│   │       ├── Operator.xaml
│   │       ├── OverlayAbstract.xaml
│   │       ├── OverlayInternal.xaml
│   │       ├── OverlayPrivate.xaml
│   │       ├── OverlayProtected.xaml
│   │       ├── OverlayStatic.xaml
│   │       ├── Property.xaml
│   │       ├── Region.xaml
│   │       ├── Snippet.xaml
│   │       ├── Structure.xaml
│   │       └── TypeParameter.xaml
│   ├── xAI/
│   │   ├── AI search.cs
│   │   ├── AiModel.cs
│   │   ├── McpServer.cs
│   │   └── McpTools.cs
│   ├── xMisc/
│   │   ├── EnvVarUpdater.cs
│   │   ├── Pip.cs
│   │   ├── PipIPC.cs
│   │   ├── RegHotkeys.cs
│   │   └── UacDragDrop.cs
│   └── xUtil/
│       ├── Downloader.cs
│       ├── Ed util shared.cs
│       ├── Ed util.cs
│       ├── EdExt.cs
│       ├── EdIcons.cs
│       ├── Libs/
│       │   ├── DiffMatchPatch.cs
│       │   └── EnglishPorter2Stemmer.cs
│       ├── MetaCommentsParser.cs
│       ├── NugetDownloader.cs
│       └── RegexParser.cs
├── Au.sln
├── Cookbook/
│   └── files.xml
├── Cpp/
│   ├── Cpp.cpp
│   ├── Cpp.def
│   ├── Cpp.h
│   ├── Cpp.manifest
│   ├── Cpp.rc
│   ├── Cpp.vcxproj
│   ├── Cpp.vcxproj.filters
│   ├── IAccessible2.h
│   ├── ISimpleDOMDocument.h
│   ├── ISimpleDOMNode.h
│   ├── ISimpleDOMText.h
│   ├── JAB.h
│   ├── MemoryPool.cpp
│   ├── MemoryPool.h
│   ├── Util.cpp
│   ├── acc bridge.cpp
│   ├── acc find.cpp
│   ├── acc func.cpp
│   ├── acc get.cpp
│   ├── acc java.cpp
│   ├── acc uia.cpp
│   ├── acc web.cpp
│   ├── acc workaround.cpp
│   ├── acc.h
│   ├── in-proc.cpp
│   ├── internal.h
│   ├── other.cpp
│   ├── rejected.cpp
│   ├── resource.h
│   ├── stdafx.cpp
│   ├── stdafx.h
│   ├── str.cpp
│   ├── str.h
│   ├── test Uia.cpp
│   ├── test.cpp
│   └── util.h
├── LICENSE.txt
├── Libraries/
│   ├── PCRE/
│   │   ├── PCRE.vcxproj
│   │   ├── PCRE.vcxproj.filters
│   │   ├── config.h
│   │   ├── pcre2.h
│   │   ├── pcre2_auto_possess.c
│   │   ├── pcre2_chartables.c
│   │   ├── pcre2_chkdint.c
│   │   ├── pcre2_compile.c
│   │   ├── pcre2_compile.h
│   │   ├── pcre2_compile_class.c
│   │   ├── pcre2_config.c
│   │   ├── pcre2_context.c
│   │   ├── pcre2_error.c
│   │   ├── pcre2_extuni.c
│   │   ├── pcre2_find_bracket.c
│   │   ├── pcre2_internal.h
│   │   ├── pcre2_intmodedep.h
│   │   ├── pcre2_maketables.c
│   │   ├── pcre2_match.c
│   │   ├── pcre2_match_data.c
│   │   ├── pcre2_newline.c
│   │   ├── pcre2_ord2utf.c
│   │   ├── pcre2_pattern_info.c
│   │   ├── pcre2_script_run.c
│   │   ├── pcre2_serialize.c
│   │   ├── pcre2_string_utils.c
│   │   ├── pcre2_study.c
│   │   ├── pcre2_substring.c
│   │   ├── pcre2_tables.c
│   │   ├── pcre2_ucd.c
│   │   ├── pcre2_ucp.h
│   │   ├── pcre2_ucptables.c
│   │   ├── pcre2_util.h
│   │   ├── pcre2_valid_utf.c
│   │   └── pcre2_xclass.c
│   └── scintilla/
│       ├── .editorconfig
│       ├── include/
│       │   ├── ILexer.h
│       │   ├── ILoader.h
│       │   ├── Sci_Position.h
│       │   ├── Scintilla.iface
│       │   ├── ScintillaCall.h
│       │   ├── ScintillaMessages.h
│       │   ├── ScintillaStructures.h
│       │   ├── ScintillaTypes.h
│       │   ├── ScintillaWidget.h
│       │   └── scintilla.h
│       ├── src/
│       │   ├── AutoComplete.cxx
│       │   ├── AutoComplete.h
│       │   ├── CallTip.cxx
│       │   ├── CallTip.h
│       │   ├── CaseConvert.cxx
│       │   ├── CaseConvert.h
│       │   ├── CaseFolder.cxx
│       │   ├── CaseFolder.h
│       │   ├── CellBuffer.cxx
│       │   ├── CellBuffer.h
│       │   ├── ChangeHistory.cxx
│       │   ├── ChangeHistory.h
│       │   ├── CharClassify.cxx
│       │   ├── CharClassify.h
│       │   ├── CharacterCategoryMap.cxx
│       │   ├── CharacterCategoryMap.h
│       │   ├── CharacterType.cxx
│       │   ├── CharacterType.h
│       │   ├── ContractionState.cxx
│       │   ├── ContractionState.h
│       │   ├── DBCS.cxx
│       │   ├── DBCS.h
│       │   ├── Debugging.h
│       │   ├── Decoration.cxx
│       │   ├── Decoration.h
│       │   ├── Document.cxx
│       │   ├── Document.h
│       │   ├── EditModel.cxx
│       │   ├── EditModel.h
│       │   ├── EditView.cxx
│       │   ├── EditView.h
│       │   ├── Editor.cxx
│       │   ├── Editor.h
│       │   ├── ElapsedPeriod.h
│       │   ├── Geometry.cxx
│       │   ├── Geometry.h
│       │   ├── Indicator.cxx
│       │   ├── Indicator.h
│       │   ├── KeyMap.cxx
│       │   ├── KeyMap.h
│       │   ├── LineMarker.cxx
│       │   ├── LineMarker.h
│       │   ├── MarginView.cxx
│       │   ├── MarginView.h
│       │   ├── Partitioning.h
│       │   ├── PerLine.cxx
│       │   ├── PerLine.h
│       │   ├── Platform.h
│       │   ├── Position.h
│       │   ├── PositionCache.cxx
│       │   ├── PositionCache.h
│       │   ├── RESearch.cxx
│       │   ├── RESearch.h
│       │   ├── RunStyles.cxx
│       │   ├── RunStyles.h
│       │   ├── ScintillaBase.cxx
│       │   ├── ScintillaBase.h
│       │   ├── Selection.cxx
│       │   ├── Selection.h
│       │   ├── SparseVector.h
│       │   ├── SplitVector.h
│       │   ├── Style.cxx
│       │   ├── Style.h
│       │   ├── UndoHistory.cxx
│       │   ├── UndoHistory.h
│       │   ├── UniConversion.cxx
│       │   ├── UniConversion.h
│       │   ├── UniqueString.cxx
│       │   ├── UniqueString.h
│       │   ├── ViewStyle.cxx
│       │   ├── ViewStyle.h
│       │   ├── XPM.cxx
│       │   └── XPM.h
│       ├── version.txt
│       └── win32/
│           ├── HanjaDic.cxx
│           ├── HanjaDic.h
│           ├── ListBox.cxx
│           ├── ListBox.h
│           ├── PlatWin.cxx
│           ├── PlatWin.h
│           ├── ScintRes.rc
│           ├── Scintilla.def
│           ├── Scintilla.vcxproj
│           ├── ScintillaDLL.cxx
│           ├── ScintillaWin.cxx
│           ├── ScintillaWin.h
│           ├── SurfaceD2D.cxx
│           ├── SurfaceD2D.h
│           ├── SurfaceGDI.cxx
│           ├── SurfaceGDI.h
│           └── WinTypes.h
├── Notes.txt
├── Other/
│   ├── Au.DllHost/
│   │   ├── Au.DllHost.vcxproj
│   │   ├── Au.DllHost.vcxproj.filters
│   │   └── DllHost.c
│   ├── Au.Net4/
│   │   ├── App.config
│   │   ├── Au.Net4.csproj
│   │   ├── Net4.cs
│   │   ├── Properties/
│   │   │   └── AssemblyInfo.cs
│   │   └── TypelibConverter.cs
│   ├── BuildEvents/
│   │   ├── Au.TestInternal.cs
│   │   ├── BuildEvents.cs
│   │   ├── BuildEvents.csproj
│   │   ├── GitBinaryFiles.cs
│   │   ├── Readme - Roslyn.txt
│   │   └── Sftp.cs
│   ├── DatabasesEtc/
│   │   ├── DatabasesEtc.csproj
│   │   ├── Icons.cs
│   │   ├── Program.cs
│   │   ├── RefAndDoc.cs
│   │   └── RefTxt.cs
│   └── DocFX/
│       ├── DocFX.csproj
│       └── _doc/
│           ├── .gitignore
│           ├── api/
│           │   ├── .gitignore
│           │   └── index.md
│           ├── articles/
│           │   ├── Caller info parameter.md
│           │   ├── Key names and operators.md
│           │   ├── Library.md
│           │   ├── Output tags.md
│           │   ├── UAC.md
│           │   ├── UI element issues.md
│           │   ├── Wait timeout.md
│           │   ├── Wildcard expression.md
│           │   ├── index.md
│           │   └── toc.yml
│           ├── changes/
│           │   ├── future.md
│           │   ├── old/
│           │   │   ├── v0.1.md
│           │   │   ├── v0.10.md
│           │   │   ├── v0.11.md
│           │   │   ├── v0.12.md
│           │   │   ├── v0.13.md
│           │   │   ├── v0.14.md
│           │   │   ├── v0.15.md
│           │   │   ├── v0.16.md
│           │   │   ├── v0.17.md
│           │   │   ├── v0.18.md
│           │   │   ├── v0.19.md
│           │   │   ├── v0.2.md
│           │   │   ├── v0.3.md
│           │   │   ├── v0.4.md
│           │   │   ├── v0.5.md
│           │   │   ├── v0.6.md
│           │   │   ├── v0.7.md
│           │   │   ├── v0.8.md
│           │   │   ├── v0.9.md
│           │   │   ├── v1.0.md
│           │   │   ├── v1.1.md
│           │   │   ├── v1.2.md
│           │   │   ├── v1.3.md
│           │   │   ├── v1.4.md
│           │   │   ├── v1.5.md
│           │   │   ├── v1.6.md
│           │   │   ├── v1.7.md
│           │   │   ├── v1.8.md
│           │   │   └── v1.9.md
│           │   ├── template.md
│           │   ├── v1.10.md
│           │   ├── v1.11.md
│           │   ├── v1.12.md
│           │   ├── v1.13.md
│           │   ├── v1.14.md
│           │   └── v1.15.md
│           ├── docfx.json
│           ├── editor/
│           │   ├── Application.md
│           │   ├── Class files, projects.md
│           │   ├── Code editor.md
│           │   ├── Command line.md
│           │   ├── Compared with QM.md
│           │   ├── Creating exe programs.md
│           │   ├── Debugger.md
│           │   ├── File properties.md
│           │   ├── Git, backup, sync.md
│           │   ├── Icons.md
│           │   ├── LA and AI.md
│           │   ├── Menu commands.md
│           │   ├── NuGet.md
│           │   ├── PiP session.md
│           │   ├── Portable app.md
│           │   ├── Scripts.md
│           │   ├── Settings.md
│           │   ├── Snippets.md
│           │   └── toc.yml
│           ├── filter.yml
│           ├── index.md
│           ├── md-styles.css
│           ├── misc/
│           │   └── privacy-policy.md
│           ├── template1/
│           │   ├── layout/
│           │   │   └── _master.tmpl
│           │   ├── mod.txt
│           │   ├── partials/
│           │   │   ├── class.header.tmpl.partial
│           │   │   ├── footer.tmpl.partial
│           │   │   ├── logo.tmpl.partial
│           │   │   ├── namespace.tmpl.partial
│           │   │   └── navbar.tmpl.partial
│           │   └── styles/
│           │       ├── main.css
│           │       └── main.js
│           ├── template2/
│           │   └── partials/
│           │       ├── collection.tmpl.partial
│           │       └── item.tmpl.partial
│           └── toc.yml
├── README.md
├── Scripts/
│   ├── @Au docs/
│   │   ├── Au docs.cs
│   │   ├── AuDocs analyze.cs
│   │   ├── AuDocs cookbook.cs
│   │   ├── AuDocs other tasks.cs
│   │   ├── AuDocs text.cs
│   │   ├── AuDocs.cs
│   │   ├── LA docs doc-html.db.cs
│   │   ├── LA docs toc.json.cs
│   │   ├── LA menu doc.cs
│   │   └── Readme.txt
│   ├── @WinAPI converter/
│   │   ├── WinAPI converter.cs
│   │   ├── WinApiConverter+.cs
│   │   └── WinApiConverter.cs
│   ├── AuDocsLib.cs
│   ├── Create NuGet package.cs
│   ├── LA docs for AI/
│   │   ├── AI summaries.cs
│   │   └── Upload AI embeddings.cs
│   ├── Minimal .NET SDK.cs
│   ├── Update version.txt.cs
│   └── old/
│       ├── VS goto.cs
│       └── Windows SDK to C#/
│           ├── @SDK converter/
│           │   ├── Classes.cs
│           │   ├── Constants.cs
│           │   ├── Converter.cs
│           │   ├── Expr.cs
│           │   ├── Functions.cs
│           │   ├── Parameters.cs
│           │   ├── SDK converter.cs
│           │   ├── Tokenize.cs
│           │   ├── Types.cs
│           │   └── Util.cs
│           ├── Readme.txt
│           └── Scripts/
│               ├── SDK append 32-bit diff.cs
│               ├── SDK create database.cs
│               ├── SDK headers.h
│               ├── SDK preprocessor.cs
│               ├── SdkUtil.cs
│               └── once/
│                   ├── SDK get GUID.cs
│                   └── SDK get dll names.cs
├── _/
│   ├── default.exe.manifest
│   ├── dotnet_ref_editor.txt
│   ├── dotnet_ref_task.txt
│   └── gitBinaryRestore.csv
└── global.json

================================================
FILE CONTENTS
================================================

================================================
FILE: .editorconfig
================================================
[*.{cs,vb}]

# IDE0032: Use auto property
dotnet_style_prefer_auto_properties = false:silent

# CA1416: Validate platform compatibility
dotnet_diagnostic.CA1416.severity = none

# CA1806: Do not ignore method results
dotnet_diagnostic.CA1806.severity = silent

# CA2014: Do not use stackalloc in loops
dotnet_diagnostic.CA2014.severity = warning

# CS1573: Parameter has no matching param tag in the XML comment (but other parameters do)
dotnet_diagnostic.CS1573.severity = suggestion

[*]
charset = utf-8

[*.iss]
charset = utf-8-bom


================================================
FILE: .gitattributes
================================================
###############################################################################
# Set default behavior to automatically normalize line endings.
###############################################################################
* text=auto
###############################################################################
# Set the merge driver for project and solution files
#
# Merging from the command prompt will add diff markers to the files if there
# are conflicts (Merging from VS is not affected by the settings below, in VS
# the diff markers are never inserted). Diff markers may cause the following 
# file extensions to fail to load in VS. An alternative would be to treat
# these files as binary and thus will always conflict and require user
# intervention with every merge. To do so, just uncomment the entries below
###############################################################################
#*.sln       merge=binary
#*.csproj    merge=binary
#*.vbproj    merge=binary
#*.vcxproj   merge=binary
#*.vcproj    merge=binary
#*.dbproj    merge=binary
#*.fsproj    merge=binary
#*.lsproj    merge=binary
#*.wixproj   merge=binary
#*.modelproj merge=binary
#*.sqlproj   merge=binary
#*.wwaproj   merge=binary
###############################################################################
# behavior for image files
#
# image files are treated as binary by default.
###############################################################################
#*.jpg   binary
#*.png   binary
#*.gif   binary
###############################################################################
/Libraries/** linguist-vendored
###############################################################################


================================================
FILE: .github/FUNDING.yml
================================================
github: qgindi


================================================
FILE: .gitignore
================================================
## Ignore Visual Studio temporary files, build results, and
## files generated by popular Visual Studio add-ons.

# User-specific files
*.suo
*.user
*.userosscache
*.sln.docstates

# User-specific files (MonoDevelop/Xamarin Studio)
*.userprefs

# Build results
[Dd]ebug/
[Dd]ebugPublic/
[Rr]elease/
[Rr]eleases/
build/
bld/
[Bb]in/
[Oo]bj/

# Visual Studio 2015 cache/options directory
.vs/

# MSTest test Results
[Tt]est[Rr]esult*/
[Bb]uild[Ll]og.*

# NUNIT
*.VisualState.xml
TestResult.xml

# Build Results of an ATL Project
[Dd]ebugPS/
[Rr]eleasePS/
dlldata.c

# DNX
project.lock.json
artifacts/

*_i.c
*_p.c
*_i.h
*.ilk
*.meta
*.obj
*.pch
*.pdb
*.pgc
*.pgd
*.rsp
*.sbr
*.tlb
*.tli
*.tlh
*.tmp
*.tmp_proj
*.log
*.vspscc
*.vssscc
.builds
*.pidb
*.svclog
*.scc

# Chutzpah Test files
_Chutzpah*

# Visual C++ cache files
ipch/
*.aps
*.ncb
*.opensdf
*.sdf
*.cachefile

# Visual Studio profiler
*.psess
*.vsp
*.vspx

# TFS 2012 Local Workspace
$tf/

# Guidance Automation Toolkit
*.gpState

# ReSharper is a .NET coding add-in
_ReSharper*/
*.[Rr]e[Ss]harper
*.DotSettings.user

# JustCode is a .NET coding add-in
.JustCode

# TeamCity is a build add-in
_TeamCity*

# DotCover is a Code Coverage Tool
*.dotCover

# NCrunch
_NCrunch_*
.*crunch*.local.xml

# MightyMoose
*.mm.*
AutoTest.Net/

# Web workbench (sass)
.sass-cache/

# Installshield output folder
[Ee]xpress/

# DocProject is a documentation generator add-in
DocProject/buildhelp/
DocProject/Help/*.HxT
DocProject/Help/*.HxC
DocProject/Help/*.hhc
DocProject/Help/*.hhk
DocProject/Help/*.hhp
DocProject/Help/Html2
DocProject/Help/html

# Click-Once directory
publish/

# Publish Web Output
*.[Pp]ublish.xml
*.azurePubxml
## _TODO: Comment the next line if you want to checkin your
## web deploy settings but do note that will include unencrypted
## passwords
#*.pubxml

*.publishproj

# NuGet Packages
*.nupkg
# The packages folder can be ignored because of Package Restore
**/packages/*
# except build/, which is used as an MSBuild target.
!**/packages/build/
# Uncomment if necessary however generally it will be regenerated when needed
#!**/packages/repositories.config

# Windows Azure Build Output
csx/
*.build.csdef

# Windows Store app package directory
AppPackages/

# Visual Studio cache files
# files ending in .cache can be ignored
*.[Cc]ache
# but keep track of directories ending in .cache
!*.[Cc]ache/

# Others
ClientBin/
[Ss]tyle[Cc]op.*
~$*
*~
*.dbmdl
*.dbproj.schemaview
*.pfx
*.snk
*.publishsettings
node_modules/
orleans.codegen.cs

# RIA/Silverlight projects
Generated_Code/

# Backup & report files from converting an old project file
# to a newer Visual Studio version. Backup files are not needed,
# because we have git ;-)
_UpgradeReport_Files/
Backup*/
UpgradeLog*.XML
UpgradeLog*.htm

# SQL Server files
*.mdf
*.ldf

# Business Intelligence projects
*.rdl.data
*.bim.layout
*.bim_*.settings

# Microsoft Fakes
FakesAssemblies/

# Node.js Tools for Visual Studio
.ntvs_analysis.dat

# Visual Studio 6 build log
*.plg

# Visual Studio 6 workspace options file
*.opt

# LightSwitch generated files
GeneratedArtifacts/
_Pvt_Extensions/
ModelManifest.xml

# Au
/Other/Api/

/Libraries/PCRE/excluded/

/_/*
!/_/Default/
!/_/Templates/
!/_/*.manifest
!/_/dotnet_ref_*.txt
!/_/gitBinaryRestore.csv

!/_/32/
/_/32/*
!/_/32/7za.exe

/_/Default/*
!/_/Default/Workspace/

/_/Default/Workspace/*
!/_/Default/Workspace/files/
!/_/Default/Workspace/files.xml
!/_/Default/Workspace/state.db

/_/Templates/*
!/_/Templates/files/
!/_/Templates/files.xml

/Cookbook/*
!/Cookbook/files/
!/Cookbook/files.xml

*.bak
/Au/global.json
.tools/
/Other/DocFX/_doc/cookbook
/Au.Editor/Panels/PanelRead-WB.cs


================================================
FILE: Au/Api/Api.cs
================================================
//[assembly: DefaultDllImportSearchPaths(DllImportSearchPath.System32|DllImportSearchPath.UserDirectories)]

#pragma warning disable 649, 169 //field never assigned/used

namespace Au.Types;

//[DebuggerStepThrough]
static unsafe partial class Api {
	#region util
	
	/// <summary>
	/// Gets the native size of a struct variable.
	/// Returns <c>Marshal.SizeOf(typeof(T))</c>.
	/// Speed: the same (in Release config) as <c>Marshal.SizeOf(typeof(T))</c>, and 2 times faster than <c>Marshal.SizeOf(v)</c>.
	/// </summary>
	internal static int SizeOf<T>(T v) => Marshal.SizeOf<T>();
	
	/// <summary>
	/// Gets the native size of a type.
	/// Returns <c>Marshal.SizeOf(typeof(T))</c>.
	/// </summary>
	internal static int SizeOf<T>() => Marshal.SizeOf<T>();
	
	/// <summary>
	/// Gets dll module handle (<c>GetModuleHandle</c>) or loads dll (<c>NativeLibrary.TryLoad</c>), and returns unmanaged exported function address (<c>GetProcAddress</c>).
	/// See also: <c>GetDelegate</c>.
	/// </summary>
	internal static IntPtr GetProcAddress(string dllName, string funcName) {
		IntPtr hmod = GetModuleHandle(dllName);
		if (hmod == default && !NativeLibrary.TryLoad(dllName, out hmod)) return default;
		
		return GetProcAddress(hmod, funcName);
	}
	
	/// <summary>
	/// Calls <see cref="GetProcAddress(string, string)"/> (loads dll or gets handle) and <see cref="Marshal.GetDelegateForFunctionPointer{TDelegate}(IntPtr)"/>.
	/// </summary>
	internal static bool GetDelegate<T>(out T deleg, string dllName, string funcName) where T : class {
		IntPtr fa = GetProcAddress(dllName, funcName); if (fa == default) { deleg = null; return false; }
		deleg = Marshal.GetDelegateForFunctionPointer<T>(fa);
		return deleg != null;
	}
	
	/// <summary>
	/// Calls API <see cref="GetProcAddress(IntPtr, string)"/> and <see cref="Marshal.GetDelegateForFunctionPointer{TDelegate}(IntPtr)"/>.
	/// </summary>
	internal static bool GetDelegate<T>(out T deleg, IntPtr hModule, string funcName) where T : class {
		deleg = null;
		IntPtr fa = GetProcAddress(hModule, funcName); if (fa == default) return false;
		deleg = Marshal.GetDelegateForFunctionPointer<T>(fa);
		return deleg != null;
	}
	
	/// <summary>
	/// If <i>o</i> is not <c>null</c>, calls <see cref="Marshal.ReleaseComObject"/>.
	/// </summary>
	internal static void ReleaseComObject<T>(T o) where T : class {
		if (o != null) Marshal.ReleaseComObject(o);
	}
	
	#endregion
	
	#region gdi32
	
	[DllImport("gdi32.dll")] //this and many other GDI functions don't use SetLastError
	internal static extern bool DeleteObject(IntPtr ho);
	
	[DllImport("gdi32.dll")]
	internal static extern IntPtr CreateRectRgn(int x1, int y1, int x2, int y2);
	
	internal const int RGN_AND = 1;
	internal const int RGN_OR = 2;
	internal const int RGN_XOR = 3;
	internal const int RGN_DIFF = 4;
	internal const int RGN_COPY = 5;
	
	[DllImport("gdi32.dll")]
	internal static extern int CombineRgn(IntPtr hrgnDst, IntPtr hrgnSrc1, IntPtr hrgnSrc2, int iMode);
	
	[DllImport("gdi32.dll")]
	internal static extern bool SetRectRgn(IntPtr hrgn, int left, int top, int right, int bottom);
	
	[DllImport("gdi32.dll")]
	internal static extern IntPtr CreateRectRgnIndirect(in RECT lprect);
	
	[DllImport("gdi32.dll")]
	internal static extern bool PtInRegion(IntPtr hrgn, int x, int y);
	
	[DllImport("gdi32.dll")]
	internal static extern IntPtr CreateCompatibleDC(IntPtr hdc);
	
	[DllImport("gdi32.dll")]
	internal static extern bool DeleteDC(IntPtr hdc);
	
	[DllImport("gdi32.dll")]
	internal static extern IntPtr SelectObject(IntPtr hdc, IntPtr h);
	
	[DllImport("gdi32.dll", EntryPoint = "GetObjectW")]
	internal static extern int GetObject(IntPtr h, int c, void* pv);
	
	/// <param name="mode">1 transparent, 2 opaque.</param>
	[DllImport("gdi32.dll")]
	internal static extern int SetBkMode(IntPtr hdc, int mode);
	
	[DllImport("gdi32.dll")]
	internal static extern int SetBkColor(IntPtr hdc, int color);
	
	[DllImport("gdi32.dll", EntryPoint = "TextOutW")]
	internal static extern bool TextOut(IntPtr hdc, int x, int y, string lpString, int c);
	
	[DllImport("gdi32.dll", EntryPoint = "TextOutW")]
	internal static extern bool TextOut(IntPtr hdc, int x, int y, char* lpString, int c);
	
	[DllImport("gdi32.dll", EntryPoint = "ExtTextOutW")]
	internal static extern bool ExtTextOut(IntPtr hdc, int x, int y, uint options, in RECT lprect, char* lpString, int c, int* lpDx = null);
	internal const uint ETO_CLIPPED = 0x4;
	
	[DllImport("gdi32.dll")]
	internal static extern bool MoveToEx(IntPtr hdc, int x, int y, out POINT lppt);
	
	[DllImport("gdi32.dll")]
	internal static extern bool GetCurrentPositionEx(IntPtr hdc, out POINT lppt);
	
	[DllImport("gdi32.dll")]
	internal static extern uint SetTextAlign(IntPtr hdc, uint align);
	
	[DllImport("gdi32.dll")]
	internal static extern int SetTextColor(IntPtr hdc, int color);
	
	[DllImport("gdi32.dll")]
	internal static extern IntPtr CreatePen(int iStyle, int cWidth, int color);
	
	[DllImport("gdi32.dll")]
	internal static extern bool LineTo(IntPtr hdc, int x, int y);
	
	[DllImport("gdi32.dll")] //tested: does not set last error
	internal static extern IntPtr CreateCompatibleBitmap(IntPtr hdc, int cx, int cy);
	
	[DllImport("gdi32.dll")]
	internal static extern int GetDeviceCaps(IntPtr hdc, int index);
	
	[DllImport("gdi32.dll", EntryPoint = "GetTextExtentPoint32W")]
	internal static extern bool GetTextExtentPoint32(IntPtr hdc, string lpString, int c, out SIZE psizl);
	
	[DllImport("gdi32.dll", EntryPoint = "GetTextExtentPoint32W")]
	internal static extern bool GetTextExtentPoint32(IntPtr hdc, char* lpString, int c, out SIZE psizl);
	
	[DllImport("gdi32.dll", EntryPoint = "CreateFontW")]
	internal static extern IntPtr CreateFont(int cHeight, int cWidth = 0, int cEscapement = 0, int cOrientation = 0, int cWeight = 0, int bItalic = 0, int bUnderline = 0, int bStrikeOut = 0, int iCharSet = 0, int iOutPrecision = 0, int iClipPrecision = 0, int iQuality = 0, int iPitchAndFamily = 0, string pszFaceName = null);
	
	[DllImport("gdi32.dll", EntryPoint = "CreateFontIndirectW")]
	internal static extern IntPtr CreateFontIndirect(in LOGFONT lplf);
	
	internal const uint SRCCOPY = 0xCC0020;
	internal const uint CAPTUREBLT = 0x40000000;
	
	[DllImport("gdi32.dll")] //tested: in some cases does not set last error even if returns false
	internal static extern bool BitBlt(IntPtr hdc, int x, int y, int cx, int cy, IntPtr hdcSrc, int x1, int y1, uint rop);
	
	[DllImport("gdi32.dll")]
	internal static extern bool StretchBlt(IntPtr hdcDest, int xDest, int yDest, int wDest, int hDest, IntPtr hdcSrc, int xSrc, int ySrc, int wSrc, int hSrc, uint rop);
	
	[DllImport("gdi32.dll")]
	internal static extern IntPtr CreateDIBSection(IntPtr hdc, in Api.BITMAPINFO pbmi, uint usage, out uint* ppvBits, IntPtr hSection = default, uint offset = 0);
	
	internal struct BITMAPINFOHEADER {
		public int biSize;
		public int biWidth;
		public int biHeight;
		public ushort biPlanes;
		public ushort biBitCount;
		public int biCompression;
		public int biSizeImage;
		public int biXPelsPerMeter;
		public int biYPelsPerMeter;
		public int biClrUsed;
		public int biClrImportant;
	}
	
	/// <summary>
	/// <c>BITMAPINFOHEADER</c> members and 3 uints for color table etc.
	/// </summary>
	internal struct BITMAPINFO {
		public readonly int biSize;
		public int biWidth;
		public int biHeight;
		public ushort biPlanes;
		public ushort biBitCount;
		public int biCompression;
		public int biSizeImage;
		public int biXPelsPerMeter;
		public int biYPelsPerMeter;
		public int biClrUsed;
		public int biClrImportant;
		public fixed uint bmiColors[3]; //info: GetDIBits(DIB_RGB_COLORS) sets 0xFF0000, 0xFF00, 0xFF. Note: with 8-bit colors bitmaps need 256, but this library does not use it.
		
		/// <summary>
		/// Sets <c>biSize=sizeof(BITMAPINFOHEADER)</c>. Note: it is less than <c>sizeof(BITMAPINFO)</c>.
		/// </summary>
		public BITMAPINFO() { biSize = sizeof(BITMAPINFOHEADER); }
		
		/// <summary>
		/// Sets width/height/bitcount/planes fields. Sets <c>biSize=sizeof(BITMAPINFOHEADER)</c>. Note: it is less than <c>sizeof(BITMAPINFO)</c>.
		/// </summary>
		public BITMAPINFO(int width, int height, int bitCount = 32) {
			biSize = sizeof(BITMAPINFOHEADER);
			biWidth = width;
			biHeight = height;
			biBitCount = (ushort)bitCount;
			biPlanes = 1;
		}
		
		//little tested
		///// <summary>
		///// Gets DIB bits of compatible bitmap. Uses API <ms>GetDIBits</ms>. Returns <c>null</c> if failed.
		///// </summary>
		///// <param name="hb">Bitmap handle.</param>
		///// <param name="topDown">Create top-down DIB.</param>
		///// <param name="dc">Eg <see cref="ScreenDC_"/>.</param>
		///// <param name="palColors">Use DIB_PAL_COLORS.</param>
		//public byte[] GetBitmapBits(IntPtr hb, bool topDown, IntPtr dc, bool palColors = false) {
		//	biBitCount = 0; //biBitCount=(ushort)bitCount; //somehow fails if bitCount is 32 and bitmap is 32-bit
		//	if (0 == GetDIBits(dc, hb, 0, 0, null, ref this, palColors ? 1 : 0)) return null;
		//	var r = new byte[biSizeImage];
		//	fixed (byte* p = r) {
		//		int hei = biHeight; if (topDown) biHeight = -hei;
		//		var k = GetDIBits(dc, hb, 0, hei, p, ref this, palColors ? 1 : 0);
		//		biHeight = hei;
		//		if (k == 0) return null;
		//	}
		//	return r;
		//}
	}
	
	[DllImport("gdi32.dll")]
	internal static extern int GetDIBits(IntPtr hdc, IntPtr hbm, int start, int cLines, void* lpvBits, ref BITMAPINFO lpbmi, int usage);
	
	/// <summary>
	/// lpbmi can be <c>BITMAPINFOHEADER</c>/<c>BITMAPV5HEADER</c> or <c>BITMAPCOREHEADER</c>.
	/// </summary>
	[DllImport("gdi32.dll")]
	internal static extern int SetDIBitsToDevice(IntPtr hdc, int xDest, int yDest, int w, int h, int xSrc, int ySrc, int StartScan, int cLines, void* lpvBits, void* lpbmi, uint ColorUse = 0); //DIB_RGB_COLORS
	
	//internal const int WHITE_BRUSH = 0;
	//internal const int LTGRAY_BRUSH = 1;
	//internal const int GRAY_BRUSH = 2;
	//internal const int DKGRAY_BRUSH = 3;
	//internal const int BLACK_BRUSH = 4;
	//internal const int NULL_BRUSH = 5;
	//internal const int HOLLOW_BRUSH = 5;
	//internal const int WHITE_PEN = 6;
	//internal const int BLACK_PEN = 7;
	//internal const int NULL_PEN = 8;
	//internal const int OEM_FIXED_FONT = 10;
	//internal const int ANSI_FIXED_FONT = 11;
	//internal const int ANSI_VAR_FONT = 12;
	//internal const int SYSTEM_FONT = 13;
	//internal const int DEVICE_DEFAULT_FONT = 14;
	//internal const int DEFAULT_PALETTE = 15;
	//internal const int SYSTEM_FIXED_FONT = 16;
	//internal const int DEFAULT_GUI_FONT = 17;
	//internal const int DC_BRUSH = 18;
	//internal const int DC_PEN = 19;
	
	[DllImport("gdi32.dll")]
	internal static extern IntPtr GetStockObject(int i);
	
	[DllImport("gdi32.dll")]
	internal static extern IntPtr CreateSolidBrush(int color);
	
	[DllImport("gdi32.dll")]
	internal static extern int IntersectClipRect(IntPtr hdc, int left, int top, int right, int bottom);
	
	internal struct LOGFONT {
		public int lfHeight;
		public int lfWidth;
		public int lfEscapement;
		public int lfOrientation;
		public int lfWeight;
		public byte lfItalic;
		public byte lfUnderline;
		public byte lfStrikeOut;
		public byte lfCharSet;
		public byte lfOutPrecision;
		public byte lfClipPrecision;
		public byte lfQuality;
		public byte lfPitchAndFamily;
		public fixed char lfFaceName[32];
	}
	
	internal struct NONCLIENTMETRICS {
		public int cbSize;
		public int iBorderWidth;
		public int iScrollWidth;
		public int iScrollHeight;
		public int iCaptionWidth;
		public int iCaptionHeight;
		public LOGFONT lfCaptionFont;
		public int iSmCaptionWidth;
		public int iSmCaptionHeight;
		public LOGFONT lfSmCaptionFont;
		public int iMenuWidth;
		public int iMenuHeight;
		public LOGFONT lfMenuFont;
		public LOGFONT lfStatusFont;
		public LOGFONT lfMessageFont;
		public int iPaddedBorderWidth;
	}
	
	[DllImport("gdi32.dll")] //does not set last error when fails
	internal static extern uint GetPixel(IntPtr hdc, int x, int y);
	
	#endregion
	
	#region advapi32
	
	[DllImport("advapi32.dll")]
	internal static extern int RegSetValueEx(IntPtr hKey, string lpValueName, int Reserved, Microsoft.Win32.RegistryValueKind dwType, void* lpData, int cbData);
	
	[DllImport("advapi32.dll")]
	internal static extern int RegQueryValueEx(IntPtr hKey, string lpValueName, IntPtr Reserved, out Microsoft.Win32.RegistryValueKind dwType, void* lpData, ref int cbData);
	
	internal const uint TOKEN_WRITE = STANDARD_RIGHTS_WRITE | TOKEN_ADJUST_PRIVILEGES | TOKEN_ADJUST_GROUPS | TOKEN_ADJUST_DEFAULT;
	internal const uint TOKEN_SOURCE_LENGTH = 8;
	internal const uint TOKEN_READ = STANDARD_RIGHTS_READ | TOKEN_QUERY;
	internal const uint TOKEN_QUERY_SOURCE = 16;
	internal const uint TOKEN_QUERY = 8;
	internal const uint TOKEN_IMPERSONATE = 4;
	internal const uint TOKEN_EXECUTE = STANDARD_RIGHTS_EXECUTE;
	internal const uint TOKEN_DUPLICATE = 2;
	internal const uint TOKEN_AUDIT_SUCCESS_INCLUDE = 1;
	internal const uint TOKEN_AUDIT_SUCCESS_EXCLUDE = 2;
	internal const uint TOKEN_AUDIT_FAILURE_INCLUDE = 4;
	internal const uint TOKEN_AUDIT_FAILURE_EXCLUDE = 8;
	internal const uint TOKEN_ASSIGN_PRIMARY = 1;
	internal const uint TOKEN_ALL_ACCESS_P = STANDARD_RIGHTS_REQUIRED | TOKEN_ASSIGN_PRIMARY | TOKEN_DUPLICATE | TOKEN_IMPERSONATE | TOKEN_QUERY | TOKEN_QUERY_SOURCE | TOKEN_ADJUST_PRIVILEGES | TOKEN_ADJUST_GROUPS | TOKEN_ADJUST_DEFAULT;
	internal const uint TOKEN_ALL_ACCESS = TOKEN_ALL_ACCESS_P | TOKEN_ADJUST_SESSIONID;
	internal const uint TOKEN_ADJUST_SESSIONID = 256;
	internal const uint TOKEN_ADJUST_PRIVILEGES = 32;
	internal const uint TOKEN_ADJUST_GROUPS = 64;
	internal const uint TOKEN_ADJUST_DEFAULT = 128;
	
	[DllImport("advapi32.dll", SetLastError = true)]
	internal static extern bool OpenProcessToken(IntPtr ProcessHandle, uint DesiredAccess, out Handle_ TokenHandle);
	
	internal enum TOKEN_INFORMATION_CLASS {
		TokenUser = 1,
		TokenGroups,
		TokenPrivileges,
		TokenOwner,
		TokenPrimaryGroup,
		TokenDefaultDacl,
		TokenSource,
		TokenType,
		TokenImpersonationLevel,
		TokenStatistics,
		TokenRestrictedSids,
		TokenSessionId,
		TokenGroupsAndPrivileges,
		TokenSessionReference,
		TokenSandBoxInert,
		TokenAuditPolicy,
		TokenOrigin,
		TokenElevationType,
		TokenLinkedToken,
		TokenElevation,
		TokenHasRestrictions,
		TokenAccessInformation,
		TokenVirtualizationAllowed,
		TokenVirtualizationEnabled,
		TokenIntegrityLevel,
		TokenUIAccess,
		TokenMandatoryPolicy,
		TokenLogonSid,
		//Win8
		TokenIsAppContainer,
		TokenCapabilities,
		TokenAppContainerSid,
		TokenAppContainerNumber,
		TokenUserClaimAttributes,
		TokenDeviceClaimAttributes,
		TokenRestrictedUserClaimAttributes,
		TokenRestrictedDeviceClaimAttributes,
		TokenDeviceGroups,
		TokenRestrictedDeviceGroups,
		TokenSecurityAttributes,
		TokenIsRestricted,
		TokenProcessTrustLevel,
		TokenPrivateNameSpace,
		MaxTokenInfoClass  // MaxTokenInfoClass should always be the last enum
	}
	
	[DllImport("advapi32.dll", SetLastError = true)]
	internal static extern bool GetTokenInformation(HandleRef TokenHandle, TOKEN_INFORMATION_CLASS TokenInformationClass, void* TokenInformation, uint TokenInformationLength, out uint ReturnLength);
	
	[DllImport("advapi32.dll")]
	internal static extern byte* GetSidSubAuthorityCount(IntPtr pSid);
	
	[DllImport("advapi32.dll")]
	internal static extern uint* GetSidSubAuthority(IntPtr pSid, uint nSubAuthority);
	
	internal enum SECURITY_IMPERSONATION_LEVEL {
		SecurityAnonymous,
		SecurityIdentification,
		SecurityImpersonation,
		SecurityDelegation
	}
	
	internal enum TOKEN_TYPE {
		TokenPrimary = 1,
		TokenImpersonation
	}
	
	[DllImport("advapi32.dll", SetLastError = true)]
	internal static extern bool DuplicateTokenEx(IntPtr hExistingToken, uint dwDesiredAccess, SECURITY_ATTRIBUTES lpTokenAttributes, SECURITY_IMPERSONATION_LEVEL ImpersonationLevel, TOKEN_TYPE TokenType, out IntPtr phNewToken);
	
	[DllImport("advapi32.dll", SetLastError = true)]
	internal static extern bool CreateProcessWithTokenW(IntPtr hToken, uint dwLogonFlags, string lpApplicationName, char[] lpCommandLine, uint dwCreationFlags, string lpEnvironment, string lpCurrentDirectory, in STARTUPINFO lpStartupInfo, out PROCESS_INFORMATION lpProcessInformation);
	
	internal struct LUID {
		public uint LowPart;
		public int HighPart;
	}
	
	[DllImport("advapi32.dll", EntryPoint = "LookupPrivilegeValueW", SetLastError = true)]
	internal static extern bool LookupPrivilegeValue(string lpSystemName, string lpName, out LUID lpLuid);
	
	[StructLayout(LayoutKind.Sequential, Pack = 4)]
	internal struct LUID_AND_ATTRIBUTES {
		public LUID Luid;
		public uint Attributes;
	}
	
	internal struct TOKEN_PRIVILEGES {
		public int PrivilegeCount;
		public LUID_AND_ATTRIBUTES Privileges; //[1]
	}
	
	[DllImport("advapi32.dll", SetLastError = true)]
	internal static extern bool AdjustTokenPrivileges(IntPtr TokenHandle, bool DisableAllPrivileges, in TOKEN_PRIVILEGES NewState, uint BufferLength, [Out] TOKEN_PRIVILEGES[] PreviousState, IntPtr ReturnLength);
	
	[StructLayout(LayoutKind.Sequential)]
	internal sealed class SECURITY_ATTRIBUTES : IDisposable {
		public int nLength;
		public void* lpSecurityDescriptor;
		public int bInheritHandle;
		
		/// <summary>
		/// Creates <c>SECURITY_ATTRIBUTES</c> from string security descriptor.
		/// <i>securityDescriptor</i> can be <c>null</c>; then <c>lpSecurityDescriptor</c> will be <c>null</c>.
		/// </summary>
		public SECURITY_ATTRIBUTES(string securityDescriptor) {
			nLength = IntPtr.Size * 3;
			if (securityDescriptor != null && !ConvertStringSecurityDescriptorToSecurityDescriptor(securityDescriptor, 1, out lpSecurityDescriptor)) throw new AuException(0, "SECURITY_ATTRIBUTES");
		}
		
		public void Dispose() {
			if (lpSecurityDescriptor != null) {
				LocalFree(lpSecurityDescriptor);
				lpSecurityDescriptor = null;
			}
		}
		
		~SECURITY_ATTRIBUTES() => Dispose();
		
		/// <summary>
		/// Creates <c>SECURITY_ATTRIBUTES</c> that allows UAC low IL processes to open the kernel object.
		/// </summary>
		public static readonly SECURITY_ATTRIBUTES ForLowIL = new SECURITY_ATTRIBUTES("D:NO_ACCESS_CONTROLS:(ML;;NW;;;LW)");
		
		/// <summary>
		/// Creates <c>SECURITY_ATTRIBUTES</c> that allows UAC medium IL processes to open the pipe.
		/// Like of <c>PipeSecurity</c> that allows <c>ReadWrite</c> for <c>AuthenticatedUserSid</c>.
		/// </summary>
		public static readonly SECURITY_ATTRIBUTES ForPipes = new SECURITY_ATTRIBUTES("D:(A;;0x12019b;;;AU)");
	}
	
	[DllImport("advapi32.dll", EntryPoint = "ConvertStringSecurityDescriptorToSecurityDescriptorW", SetLastError = true)]
	internal static extern bool ConvertStringSecurityDescriptorToSecurityDescriptor(string StringSecurityDescriptor, uint StringSDRevision, out void* SecurityDescriptor, uint* SecurityDescriptorSize = null);
	
	//[DllImport("advapi32.dll", EntryPoint = "ConvertSecurityDescriptorToStringSecurityDescriptorW")]
	//internal static extern bool ConvertSecurityDescriptorToStringSecurityDescriptor(void* SecurityDescriptor, uint RequestedStringSDRevision, uint SecurityInformation, out char* StringSecurityDescriptor, out uint StringSecurityDescriptorLen);
	
	[DllImport("advapi32.dll", EntryPoint = "InitiateSystemShutdownW", SetLastError = true)]
	internal static extern bool InitiateSystemShutdown(string lpMachineName, string lpMessage, int dwTimeout, bool bForceAppsClosed, bool bRebootAfterShutdown);
	
	
	
	
	#endregion
	
	#region shell32
	
	//[DllImport("shell32.dll")]
	//internal static extern bool IsUserAnAdmin();
	
	internal const uint SHGFI_ICON = 0x000000100;     // get icon;
	internal const uint SHGFI_DISPLAYNAME = 0x000000200;     // get display name;
	internal const uint SHGFI_TYPENAME = 0x000000400;     // get type name;
	internal const uint SHGFI_ATTRIBUTES = 0x000000800;     // get attributes;
	internal const uint SHGFI_ICONLOCATION = 0x000001000;     // get icon location;
	internal const uint SHGFI_EXETYPE = 0x000002000;     // return exe type;
	internal const uint SHGFI_SYSICONINDEX = 0x000004000;     // get system icon index;
	internal const uint SHGFI_LINKOVERLAY = 0x000008000;     // put a link overlay on icon;
	internal const uint SHGFI_SELECTED = 0x000010000;     // show icon in selected state;
	internal const uint SHGFI_ATTR_SPECIFIED = 0x000020000;     // get only specified attributes;
	internal const uint SHGFI_LARGEICON = 0x000000000;     // get large icon;
	internal const uint SHGFI_SMALLICON = 0x000000001;     // get small icon;
	internal const uint SHGFI_OPENICON = 0x000000002;     // get open icon;
	internal const uint SHGFI_SHELLICONSIZE = 0x000000004;     // get shell size icon;
	internal const uint SHGFI_PIDL = 0x000000008;     // pszPath is a pidl;
	internal const uint SHGFI_USEFILEATTRIBUTES = 0x000000010;     // use passed dwFileAttribute;
	internal const uint SHGFI_ADDOVERLAYS = 0x000000020;     // apply the appropriate overlays;
	internal const uint SHGFI_OVERLAYINDEX = 0x000000040;     // Get the index of the overlay;
	
	internal struct SHFILEINFO {
		public IntPtr hIcon;
		public int iIcon;
		public uint dwAttributes;
		[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 260)]
		public string szDisplayName;
		[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 80)]
		public string szTypeName;
	}
	
	//[DllImport("shell32.dll", EntryPoint = "SHGetFileInfoW")]
	//internal static extern nint SHGetFileInfo(string pszPath, uint dwFileAttributes, out SHFILEINFO psfi, int cbFileInfo, uint uFlags);
	
	[DllImport("shell32.dll", EntryPoint = "SHGetFileInfoW")]
	static extern nint _SHGetFileInfo(nint pidl, uint dwFileAttributes, out SHFILEINFO psfi, int cbFileInfo, uint uFlags);
	
	internal static nint SHGetFileInfo(nint pidl, out SHFILEINFO psfi, uint uFlags, uint dwFileAttributes = 0) {
		return _SHGetFileInfo(pidl, dwFileAttributes, out psfi, Api.SizeOf<Api.SHFILEINFO>(), uFlags);
	}
	
	internal static nint SHGetFileInfo(string path, out SHFILEINFO psfi, uint uFlags, uint dwFileAttributes = 0) {
		//if (0 != (uFlags & SHGFI_PIDL)) { //not tested
		//	var pidl = Pidl.FromString_(path);
		//	if (pidl == 0) { psfi = default; return 0; }
		//	try { return _SHGetFileInfo(pidl, dwFileAttributes, out psfi, Api.SizeOf<Api.SHFILEINFO>(), uFlags); }
		//	finally { Marshal.FreeCoTaskMem(pidl); }
		//} else {
		fixed (char* p = path) return _SHGetFileInfo((nint)p, dwFileAttributes, out psfi, Api.SizeOf<Api.SHFILEINFO>(), uFlags);
		//}
	}
	
	//[DllImport("shell32.dll")]
	//internal static extern int SHGetDesktopFolder(out IShellFolder ppshf);
	
	[DllImport("shell32.dll")]
	internal static extern int SHParseDisplayName(string pszName, IntPtr pbc, out IntPtr pidl, uint sfgaoIn, uint* psfgaoOut);
	
	[DllImport("shell32.dll")]
	internal static extern int SHGetNameFromIDList(IntPtr pidl, SIGDN sigdnName, out string ppszName);
	
	[DllImport("shell32.dll")]
	internal static extern int SHCreateShellItem(IntPtr pidlParent, IShellFolder psfParent, IntPtr pidl, out IShellItem ppsi);
	//This classic API supports absolute PIDL and parent+relative PIDL.
	//There are 2 newer API - SHCreateItemFromIDList (absoulte) and SHCreateItemWithParent (parent+relative). They can get IShellItem2 too, which is currently not useful here. Same speed.
	
	//[DllImport("shell32.dll")]
	//internal static extern int SHCreateItemFromIDList(IntPtr pidl, in Guid riid, out IShellItem ppv); //or IShellItem2
	
	[DllImport("shell32.dll")]
	internal static extern int SHBindToParent(IntPtr pidl, in Guid riid, out IShellFolder ppv, out IntPtr ppidlLast);
	
	[DllImport("shell32.dll")]
	internal static extern int SHGetPropertyStoreForWindow(wnd hwnd, in Guid riid, out IPropertyStore ppv);
	
	internal static PROPERTYKEY PKEY_AppUserModel_ID = new PROPERTYKEY() { fmtid = new Guid(0x9F4C2855, 0x9F79, 0x4B39, 0xA8, 0xD0, 0xE1, 0xD4, 0x2D, 0xE1, 0xD5, 0xF3), pid = 5 };
	
	[DllImport("shell32.dll")]
	internal static extern char** CommandLineToArgvW(string lpCmdLine, out int pNumArgs);
	
	[DllImport("shell32.dll", EntryPoint = "Shell_NotifyIconW", SetLastError = true)]
	internal static extern bool Shell_NotifyIcon(int dwMessage, in NOTIFYICONDATA lpData);
	
	internal const int NIM_ADD = 0x0;
	internal const int NIM_MODIFY = 0x1;
	internal const int NIM_DELETE = 0x2;
	internal const int NIM_SETFOCUS = 0x3;
	internal const int NIM_SETVERSION = 0x4;
	
	internal const int NOTIFYICON_VERSION_4 = 4;
	
	internal const uint NIF_MESSAGE = 0x1;
	internal const uint NIF_ICON = 0x2;
	internal const uint NIF_TIP = 0x4;
	internal const uint NIF_STATE = 0x8;
	internal const uint NIF_INFO = 0x10;
	internal const uint NIF_GUID = 0x20;
	internal const uint NIF_REALTIME = 0x40;
	internal const uint NIF_SHOWTIP = 0x80;
	
	internal const uint NIS_HIDDEN = 0x1;
	internal const uint NIS_SHAREDICON = 0x2;
	
	internal struct NOTIFYICONDATA {
		/// <summary>
		/// Sets <c>cbSize</c>, <c>hWnd</c> and <c>uFlags</c>.
		/// </summary>
		/// <param name="wNotify"></param>
		/// <param name="nifFlags"></param>
		public NOTIFYICONDATA(wnd wNotify, uint nifFlags = 0) {
			cbSize = Api.SizeOf<Api.NOTIFYICONDATA>();
			hWnd = wNotify;
			uFlags = nifFlags;
		}
		
		public int cbSize;
		public wnd hWnd;
		public int uID;
		public uint uFlags;
		public int uCallbackMessage;
		public IntPtr hIcon;
		[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 128)] public string szTip;
		public uint dwState;
		public uint dwStateMask;
		[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 256)] public string szInfo;
		public int uVersion;
		[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 64)] public string szInfoTitle;
		public uint dwInfoFlags;
		public Guid guidItem;
		public IntPtr hBalloonIcon;
	}
	
	internal const int NIN_SELECT = 0x400;
	internal const int NIN_KEYSELECT = 0x401;
	internal const int NIN_BALLOONSHOW = 0x402;
	internal const int NIN_BALLOONHIDE = 0x403;
	internal const int NIN_BALLOONTIMEOUT = 0x404;
	internal const int NIN_BALLOONUSERCLICK = 0x405;
	internal const int NIN_POPUPOPEN = 0x406;
	internal const int NIN_POPUPCLOSE = 0x407;
	
	[DllImport("shell32.dll")]
	internal static extern int Shell_NotifyIconGetRect(in NOTIFYICONIDENTIFIER identifier, out RECT iconLocation);
	internal struct NOTIFYICONIDENTIFIER {
		public int cbSize;
		public wnd hWnd;
		public int uID;
		public Guid guidItem;
	}
	
	internal struct SHSTOCKICONINFO {
		public int cbSize;
		public IntPtr hIcon;
		public int iSysImageIndex;
		public int iIcon;
		public fixed char szPath[260];
	}
	
	[DllImport("shell32.dll")]
	internal static extern int SHGetStockIconInfo(StockIcon siid, uint uFlags, ref SHSTOCKICONINFO psii);
	
	[DllImport("shell32.dll", EntryPoint = "#6")]
	internal static extern int SHDefExtractIcon(string pszIconFile, int iIndex, uint uFlags, IntPtr* phiconLarge, IntPtr* phiconSmall, int nIconSize);
	
	internal const int SHIL_LARGE = 0;
	internal const int SHIL_SMALL = 1;
	internal const int SHIL_EXTRALARGE = 2;
	//internal const int SHIL_SYSSMALL = 3;
	internal const int SHIL_JUMBO = 4;
	
	//[DllImport("shell32.dll", EntryPoint = "#727")]
	//internal static extern int SHGetImageList(int iImageList, in Guid riid, out IImageList ppvObj);
	[DllImport("shell32.dll", EntryPoint = "#727")]
	internal static extern int SHGetImageList(int iImageList, in Guid riid, out IntPtr ppvObj);
	
	internal const uint SHCNE_RENAMEITEM = 0x1;
	internal const uint SHCNE_CREATE = 0x2;
	internal const uint SHCNE_DELETE = 0x4;
	internal const uint SHCNE_MKDIR = 0x8;
	internal const uint SHCNE_RMDIR = 0x10;
	internal const uint SHCNE_MEDIAINSERTED = 0x20;
	internal const uint SHCNE_MEDIAREMOVED = 0x40;
	internal const uint SHCNE_DRIVEREMOVED = 0x80;
	internal const uint SHCNE_DRIVEADD = 0x100;
	internal const uint SHCNE_NETSHARE = 0x200;
	internal const uint SHCNE_NETUNSHARE = 0x400;
	internal const uint SHCNE_ATTRIBUTES = 0x800;
	internal const uint SHCNE_UPDATEDIR = 0x1000;
	internal const uint SHCNE_UPDATEITEM = 0x2000;
	internal const uint SHCNE_SERVERDISCONNECT = 0x4000;
	internal const uint SHCNE_UPDATEIMAGE = 0x8000;
	internal const uint SHCNE_DRIVEADDGUI = 0x10000;
	internal const uint SHCNE_RENAMEFOLDER = 0x20000;
	internal const uint SHCNE_FREESPACE = 0x40000;
	internal const uint SHCNE_EXTENDED_EVENT = 0x4000000;
	internal const uint SHCNE_ASSOCCHANGED = 0x8000000;
	internal const uint SHCNE_DISKEVENTS = 0x2381F;
	internal const uint SHCNE_GLOBALEVENTS = 0xC0581E0;
	internal const uint SHCNE_ALLEVENTS = 0x7FFFFFFF;
	internal const uint SHCNE_INTERRUPT = 0x80000000;
	
	internal const uint SHCNF_IDLIST = 0x0;
	internal const uint SHCNF_DWORD = 0x3;
	internal const uint SHCNF_PATH = 0x5;
	internal const uint SHCNF_PRINTER = 0x6;
	internal const uint SHCNF_FLUSH = 0x1000;
	internal const uint SHCNF_FLUSHNOWAIT = 0x3000;
	internal const uint SHCNF_NOTIFYRECURSIVE = 0x10000;
	
	[DllImport("shell32.dll")]
	internal static extern void SHChangeNotify(uint wEventId, uint uFlags, string dwItem1, string dwItem2);
	
	internal const uint SEE_MASK_CONNECTNETDRV = 0x80;
	internal const uint SEE_MASK_NOZONECHECKS = 0x800000;
	internal const uint SEE_MASK_UNICODE = 0x4000;
	internal const uint SEE_MASK_FLAG_NO_UI = 0x400;
	internal const uint SEE_MASK_INVOKEIDLIST = 0xC;
	internal const uint SEE_MASK_NOCLOSEPROCESS = 0x40;
	internal const uint SEE_MASK_NOASYNC = 0x100;
	internal const uint SEE_MASK_NO_CONSOLE = 0x8000;
	//internal const uint SEE_MASK_HMONITOR = 0x200000;
	//internal const uint SEE_MASK_WAITFORINPUTIDLE = 0x2000000;
	internal const uint SEE_MASK_FLAG_LOG_USAGE = 0x4000000;
	
	internal struct SHELLEXECUTEINFO {
		public int cbSize;
		public uint fMask;
		public wnd hwnd;
		public string lpVerb;
		public string lpFile;
		public string lpParameters;
		public string lpDirectory;
		public int nShow;
		public IntPtr hInstApp;
		public IntPtr lpIDList;
		public string lpClass;
		public IntPtr hkeyClass;
		public uint dwHotKey;
		public IntPtr hMonitor;
		public Handle_ hProcess;
	}
	
	[DllImport("shell32.dll", EntryPoint = "ShellExecuteExW", SetLastError = true)]
	internal static extern bool ShellExecuteEx(ref SHELLEXECUTEINFO pExecInfo);
	
	[DllImport("shell32.dll")]
	internal static extern int SHOpenFolderAndSelectItems(HandleRef pidlFolder, uint cidl, IntPtr[] apidl, uint dwFlags);
	
	[DllImport("shell32.dll", EntryPoint = "#152")]
	internal static extern int ILGetSize(IntPtr pidl);
	
	[DllImport("shell32.dll", EntryPoint = "#25")]
	internal static extern IntPtr ILCombine(IntPtr pidl1, IntPtr pidl2);
	
	[DllImport("shell32.dll", EntryPoint = "#21")]
	internal static extern bool ILIsEqual(IntPtr pidl1, IntPtr pidl2);
	
	internal const uint FO_MOVE = 0x1;
	internal const uint FO_COPY = 0x2;
	internal const uint FO_DELETE = 0x3;
	internal const uint FO_RENAME = 0x4;
	
	internal const uint FOF_MULTIDESTFILES = 0x1;
	internal const uint FOF_CONFIRMMOUSE = 0x2;
	internal const uint FOF_SILENT = 0x4;
	internal const uint FOF_RENAMEONCOLLISION = 0x8;
	internal const uint FOF_NOCONFIRMATION = 0x10;
	internal const uint FOF_WANTMAPPINGHANDLE = 0x20;
	internal const uint FOF_ALLOWUNDO = 0x40;
	internal const uint FOF_FILESONLY = 0x80;
	internal const uint FOF_SIMPLEPROGRESS = 0x100;
	internal const uint FOF_NOCONFIRMMKDIR = 0x200;
	internal const uint FOF_NOERRORUI = 0x400;
	internal const uint FOF_NOCOPYSECURITYATTRIBS = 0x800;
	internal const uint FOF_NORECURSION = 0x1000;
	internal const uint FOF_NO_CONNECTED_ELEMENTS = 0x2000;
	internal const uint FOF_WANTNUKEWARNING = 0x4000;
	internal const uint FOF_NORECURSEREPARSE = 0x8000;
	internal const uint FOF_NO_UI = 0x614;
	
	internal struct SHFILEOPSTRUCT {
		public wnd hwnd;
		public uint wFunc;
		public string pFrom;
		public string pTo;
		public ushort fFlags;
		
		//workaround for this problem: the 32-bit version of SHFILEOPSTRUCT uses Pack = 1, ie no 2-byte gap after fFlags.
		//	I don't want to use two versions. Then also would need two versions of code that use this struct.
		//	The last two members are not useful, but we need fAnyOperationsAborted. This workaround gets it through a property function.
		//	Update: we don't need fAnyOperationsAborted. We use FOF_SILENT therefore cannot be aborted. And it is unreliable.
		//		But the workaround is tested, on both platformas.
		
#if use_fAnyOperationsAborted
				//public bool fAnyOperationsAborted; //BOOL
				ushort _fAnyOperationsAborted_32, _fAnyOperationsAborted_common, _fAnyOperationsAborted_64;
				public bool fAnyOperationsAborted
				{
					get
					{
						if(_fAnyOperationsAborted_common != 0) return true;
						var v = osVersion.is32BitProcess ? _fAnyOperationsAborted_32 : _fAnyOperationsAborted_64;
						return v != 0;
					}
				}
#else
		private int fAnyOperationsAborted;
#endif
		private IntPtr hNameMappings;
		private string lpszProgressTitle;
		//these are private and not used, because would be at invalid offsets on 32-bit
	}
	
	//internal struct SHFILEOPSTRUCT
	//{
	//	public wnd hwnd;
	//	public uint wFunc;
	//	public string pFrom;
	//	public string pTo;
	//	public ushort fFlags;
	//	public bool fAnyOperationsAborted;
	//	public IntPtr hNameMappings;
	//	public string lpszProgressTitle;
	//}
	
	//[StructLayout(LayoutKind.Sequential, Pack = 1)]
	//internal struct SHFILEOPSTRUCT__32
	//{
	//	public wnd hwnd;
	//	public uint wFunc;
	//	public string pFrom;
	//	public string pTo;
	//	public ushort fFlags;
	//	public bool fAnyOperationsAborted;
	//	public IntPtr hNameMappings;
	//	public string lpszProgressTitle;
	//}
	
	[DllImport("shell32.dll", EntryPoint = "SHFileOperationW")]
	internal static extern int SHFileOperation(in SHFILEOPSTRUCT lpFileOp);
	
	[DllImport("shell32.dll", EntryPoint = "DragQueryFileW")]
	internal static extern int DragQueryFile(IntPtr hDrop, int iFile, char* lpszFile, int cch);
	
	[DllImport("shell32.dll")]
	internal static extern bool IsUserAnAdmin();
	
	[DllImport("shell32.dll", EntryPoint = "SHEmptyRecycleBinW")]
	internal static extern int SHEmptyRecycleBin(wnd hwnd, string pszRootPath, int dwFlags);
	
	
	#endregion
	
	#region shlwapi
	
	[DllImport("shlwapi.dll")]
	static extern int IUnknown_QueryService([MarshalAs(UnmanagedType.IUnknown)] object punk, in Guid guidService, in Guid riid, [MarshalAs(UnmanagedType.IUnknown)] out object ppvOut);
	
	public static bool QueryService<T>(object from, in Guid guidService, out T result) where T : class {
		bool ok = 0 == IUnknown_QueryService(from, guidService, typeof(T).GUID, out var o);
		result = ok ? (T)o : null;
		return ok;
	}
	
	//[DllImport("shlwapi.dll")]
	//internal static extern uint ColorAdjustLuma(uint clrRGB, int n, bool fScale);
	
	[DllImport("shlwapi.dll")]
	internal static extern void ColorRGBToHLS(int clrRGB, out ushort pwHue, out ushort pwLuminance, out ushort pwSaturation);
	
	[DllImport("shlwapi.dll")]
	internal static extern int ColorHLSToRGB(ushort wHue, ushort wLuminance, ushort wSaturation);
	
	[DllImport("shlwapi.dll")]
	internal static extern int PathCreateFromUrlAlloc(string pszIn, out string ppszOut, uint dwFlags = 0);
	
	//internal enum ASSOCSTR
	//{
	//	ASSOCSTR_COMMAND = 1,
	//	ASSOCSTR_EXECUTABLE,
	//	ASSOCSTR_FRIENDLYDOCNAME,
	//	ASSOCSTR_FRIENDLYAPPNAME,
	//	ASSOCSTR_NOOPEN,
	//	ASSOCSTR_SHELLNEWVALUE,
	//	ASSOCSTR_DDECOMMAND,
	//	ASSOCSTR_DDEIFEXEC,
	//	ASSOCSTR_DDEAPPLICATION,
	//	ASSOCSTR_DDETOPIC,
	//	ASSOCSTR_INFOTIP,
	//	ASSOCSTR_QUICKTIP,
	//	ASSOCSTR_TILEINFO,
	//	ASSOCSTR_CONTENTTYPE,
	//	ASSOCSTR_DEFAULTICON,
	//	ASSOCSTR_SHELLEXTENSION,
	//	ASSOCSTR_DROPTARGET,
	//	ASSOCSTR_DELEGATEEXECUTE,
	//	ASSOCSTR_SUPPORTED_URI_PROTOCOLS,
	//	ASSOCSTR_PROGID,
	//	ASSOCSTR_APPID,
	//	ASSOCSTR_APPPUBLISHER,
	//	ASSOCSTR_APPICONREFERENCE,
	//	ASSOCSTR_MAX
	//}
	
	//[DllImport("shlwapi.dll", EntryPoint = "AssocQueryStringW")]
	//internal static extern int AssocQueryString(uint flags, /*ASSOCSTR*/ int str, string pszAssoc, string pszExtra, char[] pszOut, ref int pcchOut);
	
	///// <summary>
	///// Returns executable path of file type.
	///// </summary>
	///// <param name="dotExt"></param>
	//internal static string AssocQueryString(string dotExt/*, ASSOCSTR what = ASSOCSTR.ASSOCSTR_EXECUTABLE*/)
	//{
	//	var b = ApiBuffer_.Char_(300, out var n);
	//	int hr = AssocQueryString(0x20, 2, dotExt, null, b, ref n); //ASSOCF_NOTRUNCATE
	//	if(hr == E_POINTER) hr = AssocQueryString(0x20, 2, dotExt, null, b = ApiBuffer_.Char_(n), ref n);
	//	return hr == 0 ? b.ToString(n) : null;
	//}
	
	
	#endregion
	
	#region comctl32
	
	[DllImport("comctl32.dll")]
	internal static extern IntPtr ImageList_GetIcon(IntPtr himl, int i, uint flags);
	
	[DllImport("comctl32.dll")]
	internal static extern bool ImageList_GetIconSize(IntPtr himl, out int cx, out int cy);
	
	internal const uint TME_LEAVE = 0x2;
	internal const uint TME_NONCLIENT = 0x10;
	internal const uint TME_CANCEL = 0x80000000;
	
	internal struct TRACKMOUSEEVENT {
		public int cbSize;
		public uint dwFlags;
		public wnd hwndTrack;
		public int dwHoverTime;
		
		public TRACKMOUSEEVENT(wnd w, uint flags, int hoverTime = 0) {
			cbSize = sizeof(TRACKMOUSEEVENT);
			hwndTrack = w;
			dwFlags = flags;
			dwHoverTime = hoverTime;
		}
	}
	
	[DllImport("comctl32.dll", EntryPoint = "_TrackMouseEvent")]
	internal static extern bool TrackMouseEvent(ref TRACKMOUSEEVENT lpEventTrack);
	
	/// <summary>
	/// Calls <c>TrackMouseEvent</c> with <c>TME_LEAVE</c>.
	/// </summary>
	/// <param name="w"></param>
	/// <param name="track"><c>true</c> to start, <c>false</c> to cancel.</param>
	internal static bool TrackMouseLeave(wnd w, bool track) {
		var t = new TRACKMOUSEEVENT(w, track ? TME_LEAVE : TME_LEAVE | TME_CANCEL);
		return TrackMouseEvent(ref t);
	}
	
	[DllImport("comctl32.dll", EntryPoint = "#380")]
	internal static extern int LoadIconMetric(IntPtr hinst, nint pszName, int lims, out IntPtr phico);
	
	[DllImport("comctl32.dll", EntryPoint = "#410")]
	internal static extern bool SetWindowSubclass(wnd hWnd, SUBCLASSPROC pfnSubclass, nint uIdSubclass, nint dwRefData = 0);
	
	internal delegate nint SUBCLASSPROC(wnd hWnd, int uMsg, nint wParam, nint lParam, nint uIdSubclass, nint dwRefData);
	
	[DllImport("comctl32.dll", EntryPoint = "#413")]
	internal static extern nint DefSubclassProc(wnd hWnd, int uMsg, nint wParam, nint lParam);
	
	[DllImport("comctl32.dll", EntryPoint = "#412")]
	internal static extern bool RemoveWindowSubclass(wnd hWnd, SUBCLASSPROC pfnSubclass, nint uIdSubclass);
	
	
	
	
	#endregion
	
	#region oleaut32
	
	[DllImport("oleaut32.dll", EntryPoint = "#6")]
	internal static extern void SysFreeString(char* bstrString);
	
	[DllImport("oleaut32.dll", EntryPoint = "#7")]
	internal static extern int SysStringLen(char* pbstr);
	
	[DllImport("oleaut32.dll", EntryPoint = "#4")]
	internal static extern BSTR SysAllocStringLen(string strIn, int len);
	
	[DllImport("oleaut32.dll", EntryPoint = "#2")]
	internal static extern BSTR SysAllocString(char* psz);
	
	[DllImport("oleaut32.dll", EntryPoint = "#147")]
	internal static extern int VariantChangeTypeEx(ref VARIANT pvargDest, in VARIANT pvarSrc, uint lcid, ushort wFlags, VARENUM vt);
	
	[DllImport("oleaut32.dll", EntryPoint = "#9")]
	internal static extern int VariantClear(ref VARIANT pvarg);
	
	[DllImport("oleaut32.dll", EntryPoint = "#35")]
	internal static extern int GetActiveObject(in Guid rclsid, IntPtr pvReserved, [MarshalAs(UnmanagedType.IUnknown)] out object ppunk);
	
	
	
	
	#endregion
	
	#region ole32
	
	[DllImport("ole32.dll")]
	internal static extern int CoCreateInstance(in Guid rclsid, nint pUnkOuter, uint dwClsContext, in Guid riid, [MarshalAs(UnmanagedType.IUnknown)] out object ppv);
	
	[DllImport("ole32.dll")]
	internal static extern int PropVariantClear(ref PROPVARIANT pvar);
	
	//internal enum APTTYPE
	//{
	//	APTTYPE_CURRENT = -1,
	//	APTTYPE_STA,
	//	APTTYPE_MTA,
	//	APTTYPE_NA,
	//	APTTYPE_MAINSTA
	//}
	
	//[DllImport("ole32.dll")]
	//internal static extern int CoGetApartmentType(out APTTYPE pAptType, out int pAptQualifier);
	
	[DllImport("ole32.dll")]
	internal static extern int OleInitialize(IntPtr pvReserved);
	
	[DllImport("ole32.dll")]
	internal static extern void OleUninitialize();
	
	[ComImport, Guid("00000122-0000-0000-C000-000000000046"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
	internal interface IDropTarget {
		void DragEnter(System.Runtime.InteropServices.ComTypes.IDataObject d, int grfKeyState, POINT pt, ref int effect);
		void DragOver(int grfKeyState, POINT pt, ref int effect);
		void DragLeave();
		void Drop(System.Runtime.InteropServices.ComTypes.IDataObject d, int grfKeyState, POINT pt, ref int effect);
	}
	
	[DllImport("ole32.dll")]
	internal static extern int RegisterDragDrop(wnd hwnd, IDropTarget pDropTarget);
	
	[DllImport("ole32.dll")]
	internal static extern int RevokeDragDrop(wnd hwnd);
	
	[DllImport("ole32.dll")]
	internal static extern void ReleaseStgMedium(ref System.Runtime.InteropServices.ComTypes.STGMEDIUM medium);
	
	[DllImport("ole32.dll")]
	internal static extern int CLSIDFromProgID(string lpszProgID, out Guid lpclsid);
	
	#endregion
	
	#region oleacc
	
	[DllImport("oleacc.dll")]
	internal static extern int AccessibleObjectFromWindow(wnd hwnd, EObjid dwId, in Guid riid, [MarshalAs(UnmanagedType.IUnknown)] out object o);
	
	[DllImport("oleacc.dll")]
	internal static extern int AccessibleObjectFromEvent(wnd hwnd, EObjid dwObjectId, int dwChildId, out IntPtr ppacc, out VARIANT pvarChild);
	
	[DllImport("oleacc.dll")]
	internal static extern Handle_ GetProcessHandleFromHwnd(wnd hwnd);
	
	[DllImport("oleacc.dll")]
	internal static extern int CreateStdAccessibleObject(wnd hwnd, EObjid idObject, in Guid riid, out IAccessible ppvObject);
	
	[ComImport, Guid("618736e0-3c3d-11cf-810c-00aa00389b71"), InterfaceType(ComInterfaceType.InterfaceIsDual)]
	internal interface IAccessible {
		IAccessible get_accParent();
		int get_accChildCount();
		[PreserveSig] int get_accChild(VarInt varChild, [MarshalAs(UnmanagedType.IDispatch)] out object ppdispChild);
		string get_accName(VarInt varChild);
		string get_accValue(VarInt varChild);
		string get_accDescription(VarInt varChild);
		VarInt get_accRole(VarInt varChild);
		VarInt get_accState(VarInt varChild);
		string get_accHelp(VarInt varChild);
		int get_accHelpTopic(out string pszHelpFile, VarInt varChild);
		string get_accKeyboardShortcut(VarInt varChild);
		object get_accFocus();
		object get_accSelection();
		string get_accDefaultAction(VarInt varChild);
		void accSelect(ESelect flagsSelect, VarInt varChild);
		void accLocation(out int pxLeft, out int pyTop, out int pcxWidth, out int pcyHeight, VarInt varChild);
		object accNavigate(NAVDIR navDir, VarInt varStart);
		VarInt accHitTest(int xLeft, int yTop);
		void accDoDefaultAction(VarInt varChild);
		void put_accName(VarInt varChild, string szName);
		void put_accValue(VarInt varChild, string szValue);
		
		//NOTE: although some members are obsolete or useless, don't use default implementation, because then exception at run time.
	}
	
#pragma warning disable 169
	internal struct VarInt {
		ushort _vt, _1, _2, _3;
		nint _int, _4;
		public static implicit operator VarInt(int i) => new VarInt { _vt = 3, _int = i + 1 };
		public static implicit operator int(VarInt v) {
			if (v._vt == 3) return (int)v._int - 1;
			Debug_.Print($"VarInt vt={v._vt}, value={v._int}");
			throw new ArgumentException();
		}
	}
#pragma warning restore 169
	
	internal enum NAVDIR { UP = 1, DOWN, LEFT, RIGHT, NEXT, PREVIOUS, FIRSTCHILD, LASTCHILD }
	
	
	#endregion
	
	#region msvcrt
	
	//don't use, because for eg "0xffffffff" returns int.Max instead of -1.
	//[DllImport("msvcrt.dll", EntryPoint = "wcstol", CallingConvention = CallingConvention.Cdecl)]
	//internal static extern int strtoi(char* s, char** endPtr = null, int radix = 0);
	
	//don't use the u API because they return 1 if the value is too big and the string contains '-'.
	//[DllImport("msvcrt.dll", EntryPoint = "wcstoul", CallingConvention = CallingConvention.Cdecl)]
	//internal static extern uint strtoui(char* s, char** endPtr = null, int radix = 0);
	
	[DllImport("msvcrt.dll", EntryPoint = "_wcstoi64", CallingConvention = CallingConvention.Cdecl)]
	internal static extern long strtoi64(char* s, char** endPtr = null, int radix = 0);
	//info: ntdll also has wcstol, wcstoul, _wcstoui64, but not _wcstoi64.
	
	//[DllImport("msvcrt.dll", EntryPoint = "_wcstoui64", CallingConvention = CallingConvention.Cdecl)]
	//internal static extern ulong strtoui64(char* s, char** endPtr = null, int radix = 0);
	
	[DllImport("msvcrt.dll", EntryPoint = "_strtoi64", CallingConvention = CallingConvention.Cdecl)]
	internal static extern long strtoi64(byte* s, byte** endPtr = null, int radix = 0);
	
	//not used
	//[DllImport("msvcrt.dll", EntryPoint = "_strtoui64", CallingConvention = CallingConvention.Cdecl)]
	//internal static extern long strtoui64(byte* s, byte** endPtr = null, int radix = 0);
	
	//This is used when working with char*. With C# strings use ExtString.ToInt32 etc.
	internal static int strtoi(char* s, char** endPtr = null, int radix = 0) {
		return (int)strtoi64(s, endPtr, radix);
	}
	
	//This is used with UTF-8 text.
	internal static int strtoi(byte* s, byte** endPtr = null, int radix = 0) {
		return (int)strtoi64(s, endPtr, radix);
	}
	
#if false //not used, because we have ExtString.ToInt32 etc, which has no overflow problems. But it supports only decimal and hex, not any radix.
	/// <summary>
	/// Converts part of string to <c>int</c>.
	/// Returns the <c>int</c> value.
	/// Returns 0 if the string is <c>null</c>, <c>""</c> or does not begin with a number; then <i>numberEndIndex</i> will be = <i>startIndex</i>.
	/// </summary>
	/// <param name="s">String.</param>
	/// <param name="startIndex">Offset in string where to start parsing.</param>
	/// <param name="numberEndIndex">Receives offset in string where the number part ends.</param>
	/// <param name="radix">If 0, parses the string as hexadecimal number if starts with <c>"0x"</c>, as octal if starts with <c>"0"</c>, else as decimal. Else it can be 2 to 36. Examples: 10 - parse as decimal (don't support <c>"0x"</c> etc); 16 - as hexadecimal (eg returns 26 if string is <c>"1A"</c> or <c>"0x1A"</c>); 2 - as binary (eg returns 5 if string is <c>"101"</c>).</param>
	/// <exception cref="ArgumentOutOfRangeException"><i>startIndex</i> is invalid.</exception>
	internal static int strtoi(string s, int startIndex, out int numberEndIndex, int radix = 0) {
		int R = 0, len = s == null ? 0 : s.Length - startIndex;
		if(len < 0) throw new ArgumentOutOfRangeException("startIndex");
		if(len != 0)
			fixed (char* p = s) {
				char* t = p + startIndex, e = t;
				R = strtoi(t, &e, radix);
				len = (int)(e - t);
			}
		numberEndIndex = startIndex + len;
		return R;
	}

	/// <summary>
	/// Converts part of string to <c>long</c>.
	/// Returns the <c>long</c> value.
	/// Returns 0 if the string is <c>null</c>, <c>""</c> or does not begin with a number; then <i>numberEndIndex</i> will be = <i>startIndex</i>.
	/// </summary>
	/// <param name="s">String.</param>
	/// <param name="startIndex">Offset in string where to start parsing.</param>
	/// <param name="numberEndIndex">Receives offset in string where the number part ends.</param>
	/// <param name="radix">If 0, parses the string as hexadecimal number if starts with <c>"0x"</c>, as octal if starts with <c>"0"</c>, else as decimal. Else it can be 2 to 36. Examples: 10 - parse as decimal (don't support <c>"0x"</c> etc); 16 - as hexadecimal (eg returns 26 if string is <c>"1A"</c> or <c>"0x1A"</c>); 2 - as binary (eg returns 5 if string is <c>"101"</c>).</param>
	/// <exception cref="ArgumentOutOfRangeException"><i>startIndex</i> is invalid.</exception>
	internal static long strtoi64(string s, int startIndex, out int numberEndIndex, int radix = 0) {
		long R = 0;
		int len = s == null ? 0 : s.Length - startIndex;
		if(len < 0) throw new ArgumentOutOfRangeException("startIndex");
		if(len != 0)
			fixed (char* p = s) {
				char* t = p + startIndex, e = t;
				R = strtoi64(t, &e, radix);
				len = (int)(e - t);
			}
		numberEndIndex = startIndex + len;
		return R;
	}

	internal static int strtoi(string s, int startIndex = 0, int radix = 0) {
		return strtoi(s, startIndex, out _, radix);
	}

	internal static long strtoi64(string s, int startIndex = 0, int radix = 0) {
		return strtoi64(s, startIndex, out _, radix);
	}
#endif
	
	[DllImport("msvcrt.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern char* _ltoa(int value, byte* s, int radix);
	
	[DllImport("msvcrt.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern void* memmove(void* to, void* from, nint n);
	
	//[DllImport("msvcrt.dll", CallingConvention = CallingConvention.Cdecl)]
	//internal static extern void* memset(void* ptr, int ch, nint n);
	
	[DllImport("msvcrt.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern int memcmp(void* p1, void* p2, nint count);
	
	
	
	#endregion
	
	#region winmm
	
	[DllImport("winmm.dll")]
	internal static extern uint timeBeginPeriod(uint uPeriod);
	
	[DllImport("winmm.dll")]
	internal static extern uint timeEndPeriod(uint uPeriod);
	
	[DllImport("winmm.dll")]
	internal static extern uint waveOutSetVolume(IntPtr hwo, uint dwVolume);
	
	[DllImport("winmm.dll")]
	internal static extern uint waveOutGetVolume(IntPtr hwo, out uint pdwVolume);
	
	[DllImport("winmm.dll", EntryPoint = "PlaySoundW")]
	internal static extern bool PlaySound(string pszSound, IntPtr hmod, uint fdwSound);
	
	internal const uint SND_FILENAME = 0x20000;
	internal const uint SND_NODEFAULT = 0x2;
	internal const uint SND_SYSTEM = 0x200000;
	internal const uint SND_ASYNC = 0x1;
	internal const uint SND_ALIAS = 0x10000;
	internal const uint SND_APPLICATION = 0x80;
	
	[DllImport("user32.dll")]
	internal static extern bool MessageBeep(uint uType);
	
	[DllImport("kernel32.dll")]
	internal static extern bool Beep(int dwFreq, int dwDuration);
	
	#endregion
	
	#region dwmapi
	
	internal enum DWMWA {
		NCRENDERING_ENABLED = 1,
		NCRENDERING_POLICY,
		TRANSITIONS_FORCEDISABLED,
		ALLOW_NCPAINT,
		CAPTION_BUTTON_BOUNDS,
		NONCLIENT_RTL_LAYOUT,
		FORCE_ICONIC_REPRESENTATION,
		FLIP3D_POLICY,
		EXTENDED_FRAME_BOUNDS,
		HAS_ICONIC_BITMAP,
		DISALLOW_PEEK,
		EXCLUDED_FROM_PEEK,
		CLOAK,
		CLOAKED,
		FREEZE_REPRESENTATION,
		PASSIVE_UPDATE_MODE,
	}
	
	[DllImport("dwmapi.dll")]
	internal static extern int DwmGetWindowAttribute(wnd hwnd, DWMWA dwAttribute, void* pvAttribute, int cbAttribute);
	
	//[DllImport("dwmapi.dll")]
	//internal static extern int DwmSetWindowAttribute(wnd hwnd, DWMWA dwAttribute, void* pvAttribute, int cbAttribute);
	
	//[DllImport("dwmapi.dll")]
	//internal static extern int DwmRegisterThumbnail(wnd hwndDestination, wnd hwndSource, out IntPtr phThumbnailId);
	
	//[DllImport("dwmapi.dll")]
	//internal static extern int DwmUnregisterThumbnail(IntPtr hThumbnailId);
	
	//[DllImport("dwmapi.dll")]
	//internal static extern int DwmQueryThumbnailSourceSize(IntPtr hThumbnail, out SIZE pSize);
	
	//[DllImport("dwmapi.dll")]
	//internal static extern int DwmUpdateThumbnailProperties(IntPtr hThumbnailId, in DWM_THUMBNAIL_PROPERTIES ptnProperties);
	
	//[StructLayout(LayoutKind.Sequential, Pack = 1)]
	//internal struct DWM_THUMBNAIL_PROPERTIES {
	//	public uint dwFlags;
	//	public RECT rcDestination;
	//	public RECT rcSource;
	//	public byte opacity;
	//	public bool fVisible;
	//	public bool fSourceClientAreaOnly;
	//}
	
	//internal const uint DWM_TNP_SOURCECLIENTAREAONLY = 0x10;
	//internal const uint DWM_TNP_RECTDESTINATION = 0x1;
	//internal const uint DWM_TNP_VISIBLE = 0x8;
	//internal const uint DWM_TNP_RECTSOURCE = 0x2;
	
	
	
	
	#endregion
	
	#region uxtheme
	
	[DllImport("uxtheme.dll")]
	static extern IntPtr OpenThemeData(wnd hwnd, string pszClassList);
	
	[DllImport("uxtheme.dll")]
	static extern IntPtr OpenThemeDataForDpi(wnd hwnd, string pszClassList, int dpi);
	
	internal static IntPtr OpenThemeData(wnd hwnd, string classList, int dpi) {
		if (osVersion.minWin10_1703) return OpenThemeDataForDpi(hwnd, classList, dpi);
		return OpenThemeData(hwnd, classList); //never mind: bad on Win8.1 non-primary screen with different DPI than primary if hwnd==0
	}
	
	[DllImport("uxtheme.dll")]
	internal static extern int CloseThemeData(IntPtr hTheme);
	
	[DllImport("uxtheme.dll")]
	internal static extern int GetThemePartSize(IntPtr hTheme, IntPtr hdc, int iPartId, int iStateId, RECT* prc, THEMESIZE eSize, out SIZE psz);
	internal enum THEMESIZE {
		TS_MIN,
		TS_TRUE,
		TS_DRAW
	}
	
	[DllImport("uxtheme.dll")]
	internal static extern int DrawThemeBackground(IntPtr hTheme, IntPtr hdc, int iPartId, int iStateId, in RECT pRect, RECT* pClipRect = null);
	
	//[DllImport("uxtheme.dll")]
	//internal static extern int SetWindowTheme(wnd hwnd, string pszSubAppName, string pszSubIdList);
	
	[DllImport("uxtheme.dll")]
	internal static extern int GetThemeSysColor(IntPtr hTheme, int iColorId);
	
	[DllImport("uxtheme.dll")]
	internal static extern IntPtr GetThemeSysColorBrush(IntPtr hTheme, int iColorId);
	
	[DllImport("uxtheme.dll")]
	internal static extern int BufferedPaintInit();
	
	//[DllImport("uxtheme.dll")]
	//internal static extern int BufferedPaintUnInit();
	
	[DllImport("uxtheme.dll")]
	internal static extern IntPtr BeginBufferedPaint(IntPtr hdcTarget, in RECT prcTarget, BP_BUFFERFORMAT dwFormat, ref BP_PAINTPARAMS pPaintParams, out IntPtr phdc);
	
	[DllImport("uxtheme.dll")]
	internal static extern int EndBufferedPaint(IntPtr hBufferedPaint, bool fUpdateTarget);
	
	internal enum BP_BUFFERFORMAT {
		BPBF_COMPATIBLEBITMAP,
		BPBF_DIB,
		BPBF_TOPDOWNDIB,
		BPBF_TOPDOWNMONODIB
	}
	internal struct BP_PAINTPARAMS {
		public int cbSize;
		public uint dwFlags;
		public RECT* prcExclude;
		//public BLENDFUNCTION* pBlendFunction;
		uint pBlendFunction;
	}
	//internal struct BLENDFUNCTION {
	//	public byte BlendOp;
	//	public byte BlendFlags;
	//	public byte SourceConstantAlpha;
	//	public byte AlphaFormat;
	//}
	
	
	#endregion
	
	#region wtsapi
	
	[DllImport("wtsapi32.dll", SetLastError = true)]
	internal static extern bool WTSTerminateProcess(IntPtr hServer, int ProcessId, int ExitCode);
	
	[DllImport("wtsapi32.dll")]
	internal static extern void WTSFreeMemory(void* pMemory);
	
	[DllImport("wtsapi32.dll", EntryPoint = "WTSQuerySessionInformationW", SetLastError = true)]
	static extern bool _WTSQuerySessionInformation(nint hServer, int SessionId, WTS_INFO_CLASS WTSInfoClass, out char* ppBuffer, out int pBytesReturned);
	
	internal enum WTS_INFO_CLASS {
		WTSInitialProgram,
		WTSApplicationName,
		WTSWorkingDirectory,
		WTSOEMId,
		WTSSessionId,
		WTSUserName,
		WTSWinStationName,
		WTSDomainName,
		WTSConnectState,
		WTSClientBuildNumber,
		WTSClientName,
		WTSClientDirectory,
		WTSClientProductId,
		WTSClientHardwareId,
		WTSClientAddress,
		WTSClientDisplay,
		WTSClientProtocolType,
		WTSIdleTime,
		WTSLogonTime,
		WTSIncomingBytes,
		WTSOutgoingBytes,
		WTSIncomingFrames,
		WTSOutgoingFrames,
		WTSClientInfo,
		WTSSessionInfo,
		WTSSessionInfoEx,
		WTSConfigInfo,
		WTSValidationInfo,
		WTSSessionAddressV4,
		WTSIsRemoteSession
	}
	
	internal static unsafe bool WTSQuerySessionInformation(int sessionId, Api.WTS_INFO_CLASS what, out string r) {
		if (_WTSQuerySessionInformation(0, -1, what, out char* p, out int len)) {
			r = len > 2 ? new(p, 0, len / 2 - 1) : null;
			Api.WTSFreeMemory(p);
			return r != null;
		}
		r = null;
		return false;
	}
	
	internal static unsafe bool WTSQuerySessionInformation<T>(int sessionId, Api.WTS_INFO_CLASS what, out T r) where T : unmanaged {
		if (_WTSQuerySessionInformation(0, -1, what, out char* p, out int len)) {
			Debug_.PrintIf(len != sizeof(T), len.ToS());
			r = len == sizeof(T) ? *(T*)p : default;
			Api.WTSFreeMemory(p);
			return len == sizeof(T);
		}
		r = default;
		return false;
	}
	
	[DllImport("wtsapi32.dll")]
	internal static extern bool WTSGetChildSessionId(out int pSessionId);
	
	
	#endregion
	
	#region ntdll
	
	internal struct RTL_OSVERSIONINFOW {
		public int dwOSVersionInfoSize;
		public uint dwMajorVersion;
		public uint dwMinorVersion;
		public uint dwBuildNumber;
		public uint dwPlatformId;
		public fixed char szCSDVersion[128];
	}
	
	[DllImport("ntdll.dll", ExactSpelling = true)]
	internal static extern int RtlGetVersion(ref RTL_OSVERSIONINFOW lpVersionInformation);
	
	[DllImport("ntdll.dll")]
	internal static extern uint NtQueryTimerResolution(out uint maxi, out uint mini, out uint current);
	//info: NtSetTimerResolution can set min 0.5 ms resolution. timeBeginPeriod min 1.
	
	[DllImport("ntdll.dll")]
	internal static extern void MD5Init(out Hash.MD5Context context);
	
	[DllImport("ntdll.dll")]
	internal static extern void MD5Update(ref Hash.MD5Context context, void* data, int dataLen);
	
	[DllImport("ntdll.dll")]
	internal static extern void MD5Final(ref Hash.MD5Context context);
	
#pragma warning disable 169
	[DllImport("ntdll.dll")]
	internal static extern int NtQueryInformationProcess(IntPtr ProcessHandle, int ProcessInformationClass, void* ProcessInformation, int ProcessInformationLength, out int ReturnLength);
	
	//all structs are same in 64-bit and 32-bit processes
	
	internal record struct PROCESS_BASIC_INFORMATION {
		long Reserved1;
		public long PebBaseAddress;
		long Reserved2_0, Reserved2_1;
		public long UniqueProcessId;
		public long ParentProcessId;
	}
	
	internal struct RTL_USER_PROCESS_PARAMETERS {
		fixed byte Reserved[96];
		public UNICODE_STRING ImagePathName;
		public UNICODE_STRING CommandLine;
	}
	
	internal struct UNICODE_STRING {
		public ushort Length;
		public ushort MaximumLength;
		public char* Buffer;
	}
	
	internal struct SYSTEM_PROCESS_INFORMATION {
		internal uint NextEntryOffset;
		internal uint NumberOfThreads;
		long SpareLi1;
		long SpareLi2;
		long SpareLi3;
		internal long CreateTime;
		internal long UserTime;
		internal long KernelTime;
		
		internal ushort NameLength;   // UNICODE_STRING   
		internal ushort MaximumNameLength;
		internal IntPtr NamePtr;     // This will point into the data block returned by NtQuerySystemInformation
		
		internal int BasePriority;
		internal IntPtr UniqueProcessId;
		internal IntPtr InheritedFromUniqueProcessId;
		internal uint HandleCount;
		internal uint SessionId;
		
		//unused members
	}
#pragma warning restore 169
	
	internal const int STATUS_INFO_LENGTH_MISMATCH = unchecked((int)0xC0000004);
	
	[DllImport("ntdll.dll")]
	internal static extern int NtQuerySystemInformation(int five, SYSTEM_PROCESS_INFORMATION* SystemInformation, int SystemInformationLength, out int ReturnLength);
	
	[DllImport("ntdll.dll")]
	internal static extern int NtSuspendProcess(IntPtr handle);
	
	[DllImport("ntdll.dll")]
	internal static extern int NtResumeProcess(IntPtr handle);
	
	
	
	
	#endregion
	
	#region other
	
	[DllImport("msi.dll", EntryPoint = "#217")]
	internal static extern int MsiGetShortcutTarget(string szShortcutPath, char* szProductCode, char* szFeatureId, char* szComponentCode);
	
	[DllImport("msi.dll", EntryPoint = "#173")]
	internal static extern int MsiGetComponentPath(char* szProduct, char* szComponent, char* lpPathBuf, ref int pcchBuf);
	
	[DllImport("powrprof.dll")]
	internal static extern byte SetSuspendState(byte bHibernate, byte bForce, byte bWakeupEventsDisabled);
	
	[DllImport("powrprof.dll")]
	internal static extern byte IsPwrSuspendAllowed();
	
	//[DllImport("urlmon.dll")]
	//internal static extern int FindMimeFromData(IntPtr pBC, string pwzUrl, byte[] pBuffer, int cbSize, string pwzMimeProposed, uint dwMimeFlags, out string ppwzMimeOut, uint dwReserved);
	
	#endregion
	
	#region struct
	
	internal struct NEWHEADER {
		public ushort wReserved;
		public ushort wResType;
		public ushort wResCount;
	};
	
	[StructLayout(LayoutKind.Sequential, Pack = 2)]
	internal struct ICONDIRENTRY {
		public byte bWidth;
		public byte bHeight;
		public byte bColorCount;
		public byte bReserved;
		public ushort wPlanes;
		public ushort wBitCount;
		public int dwBytesInRes;
		public int dwImageOffset;
	};
	
	#endregion
}


================================================
FILE: Au/Api/Api^kernel32.cs
================================================
namespace Au.Types;

static unsafe partial class Api {
	[DllImport("kernel32.dll", SetLastError = true)] //note: without `SetLastError = true` Marshal.GetLastWin32Error is unaware that we set the code to 0 etc and returns old captured error code
	internal static extern void SetLastError(int errCode);
	
	internal const uint FORMAT_MESSAGE_FROM_SYSTEM = 0x1000;
	internal const uint FORMAT_MESSAGE_ALLOCATE_BUFFER = 0x100;
	internal const uint FORMAT_MESSAGE_IGNORE_INSERTS = 0x200;
	
	[DllImport("kernel32.dll", EntryPoint = "FormatMessageW")]
	internal static extern int FormatMessage(uint dwFlags, IntPtr lpSource, int code, uint dwLanguageId, char** lpBuffer, int nSize, IntPtr Arguments);
	
	[DllImport("kernel32.dll", EntryPoint = "SetDllDirectoryW", SetLastError = true)]
	internal static extern bool SetDllDirectory(string lpPathName);
	
	[SuppressGCTransition] //makes slightly faster. Not faster with [MethodImpl].
	[DllImport("kernel32.dll")]
	internal static extern bool QueryPerformanceCounter(out long lpPerformanceCount);
	
	[DllImport("kernel32.dll")]
	internal static extern bool QueryPerformanceFrequency(out long lpFrequency);
	
	[DllImport("kernel32.dll")]
	internal static extern bool QueryUnbiasedInterruptTime(out long UnbiasedTime);
	
	[DllImport("kernel32.dll")]
	internal static extern long GetTickCount64();
	
	[DllImport("kernel32.dll")]
	internal static extern int GetTickCount();
	
	internal struct SYSTEMTIME {
		public ushort wYear;
		public ushort wMonth;
		public ushort wDayOfWeek;
		public ushort wDay;
		public ushort wHour;
		public ushort wMinute;
		public ushort wSecond;
		public ushort wMilliseconds;
	}
	
	[DllImport("kernel32.dll")]
	internal static extern void GetLocalTime(out SYSTEMTIME lpSystemTime);
	
	[DllImport("kernel32.dll")]
	internal static extern void GetSystemTimeAsFileTime(out long lpSystemTimeAsFileTime);
	
	//[DllImport("kernel32.dll", SetLastError = true)]
	//internal static extern bool GetThreadTimes(IntPtr hThread, out long lpCreationTime, out long lpExitTime, out long lpKernelTime, out long lpUserTime);
	
	[DllImport("kernel32.dll", SetLastError = true)]
	internal static extern bool GetProcessTimes(IntPtr hProcess, out long lpCreationTime, out long lpExitTime, out long lpKernelTime, out long lpUserTime);
	
	[DllImport("kernel32.dll", SetLastError = true)]
	internal static extern bool GetThreadTimes(IntPtr hThread, out long lpCreationTime, out long lpExitTime, out long lpKernelTime, out long lpUserTime);
	
	[DllImport("kernel32.dll", SetLastError = true)]
	internal static extern int GetThreadDescription(IntPtr hThread, out char* ppszThreadDescription);
	
	[DllImport("kernel32.dll", SetLastError = true)]
	internal static extern bool QueryProcessCycleTime(nint ProcessHandle, out long CycleTime);
	
	[DllImport("kernel32.dll", SetLastError = true)]
	internal static extern bool QueryThreadCycleTime(nint ThreadHandle, out long CycleTime);
	
	[DllImport("kernel32.dll")]
	internal static extern bool QueryIdleProcessorCycleTimeEx(ushort Group, ref int BufferLength, long* ProcessorIdleCycleTime);
	
	[DllImport("kernel32.dll")]
	internal static extern ushort GetActiveProcessorGroupCount();
	
	[DllImport("kernel32.dll", SetLastError = true)]
	internal static extern int GetThreadPriority(nint hThread);
	
	[DllImport("kernel32.dll", SetLastError = true)]
	internal static extern bool SetThreadPriority(nint hThread, int nPriority);
	
	internal const int THREAD_PRIORITY_TIME_CRITICAL = 15;
	
	[DllImport("kernel32.dll", EntryPoint = "CreateEventW", SetLastError = true)]
	internal static extern IntPtr CreateEvent2(IntPtr lpEventAttributes, bool bManualReset, bool bInitialState, string lpName);
	
	internal static Handle_ CreateEvent(bool bManualReset)
		=> new(CreateEvent2(default, bManualReset, false, null));
	
	[DllImport("kernel32.dll", EntryPoint = "OpenEventW", SetLastError = true)]
	internal static extern IntPtr OpenEvent(uint dwDesiredAccess, bool bInheritHandle, string lpName);
	
	internal const uint EVENT_MODIFY_STATE = 0x2;
	
	[DllImport("kernel32.dll", SetLastError = true)]
	internal static extern bool SetEvent(IntPtr hEvent);
	
	[DllImport("kernel32.dll", SetLastError = true)]
	internal static extern bool ResetEvent(IntPtr hEvent);
	
	[DllImport("kernel32.dll", SetLastError = true)]
	internal static extern int WaitForSingleObject(IntPtr hHandle, int dwMilliseconds);
	
	//[DllImport("kernel32.dll")]
	//internal static extern int SignalObjectAndWait(IntPtr hObjectToSignal, IntPtr hObjectToWaitOn, int dwMilliseconds, bool bAlertable);
	//note: don't know why, this often is much slower than setevent/waitforsingleobject.
	
	[DllImport("kernel32.dll")] //note: no SetLastError = true
	internal static extern bool CloseHandle(IntPtr hObject);
	
	//currently not used
	//[DllImport("kernel32.dll")] //note: no SetLastError = true
	//internal static extern bool CloseHandle(HandleRef hObject);
	
	[DllImport("kernel32.dll", SetLastError = true)]
	internal static extern bool SetHandleInformation(IntPtr hObject, uint dwMask, uint dwFlags);
	
	[DllImport("kernel32.dll", EntryPoint = "CreateMutexW", SetLastError = true)]
	internal static extern nint CreateMutex(SECURITY_ATTRIBUTES lpMutexAttributes, bool bInitialOwner, string lpName);
	
	[DllImport("kernel32.dll", EntryPoint = "OpenMutexW", SetLastError = true)]
	internal static extern nint OpenMutex(uint dwDesiredAccess, bool bInheritHandle, string lpName);
	
	[DllImport("kernel32.dll", SetLastError = true)]
	internal static extern bool ReleaseMutex(nint hMutex);
	
	/// <summary>
	/// Note: use only for private threads. Not everything works like with <c>Thread.Start</c>. For example .NET does not auto-release COM objects when thread ends.
	/// </summary>
	/// <param name="lpStartAddress"><c>[UnmanagedCallersOnly]</c></param>
	[DllImport("kernel32.dll", SetLastError = true)]
	internal static extern IntPtr CreateThread(nint lpThreadAttributes, nint dwStackSize, delegate* unmanaged<GCHandle, uint> lpStartAddress, GCHandle lpParameter, uint dwCreationFlags, out int lpThreadId);
	
	[DllImport("kernel32.dll")]
	internal static extern IntPtr GetCurrentThread();
	
	[SuppressGCTransition]
	[DllImport("kernel32.dll")]
	internal static extern int GetCurrentThreadId();
	
	[DllImport("kernel32.dll")]
	internal static extern IntPtr GetCurrentProcess();
	
	[SuppressGCTransition]
	[DllImport("kernel32.dll")]
	internal static extern int GetCurrentProcessId();
	
	[DllImport("kernel32.dll", EntryPoint = "QueryFullProcessImageNameW", SetLastError = true)]
	internal static extern bool QueryFullProcessImageName(IntPtr hProcess, bool nativeFormat, char* lpExeName, ref int lpdwSize);
	
	[DllImport("kernel32.dll", SetLastError = true)]
	internal static extern bool TerminateProcess(IntPtr hProcess, int uExitCode);
	
	[DllImport("kernel32.dll")]
	internal static extern void ExitProcess(int uExitCode);
	
	[DllImport("kernel32.dll", SetLastError = true)]
	internal static extern bool IsWow64Process(IntPtr hProcess, out bool Wow64Process);
	
	[DllImport("kernel32.dll", SetLastError = true)]
	internal static extern Handle_ CreateFileMapping(IntPtr hFile, SECURITY_ATTRIBUTES lpFileMappingAttributes, uint flProtect, uint dwMaximumSizeHigh, uint dwMaximumSizeLow, string lpName);
	
	[DllImport("kernel32.dll", EntryPoint = "OpenFileMappingW", SetLastError = true)]
	internal static extern Handle_ OpenFileMapping(uint dwDesiredAccess, bool bInheritHandle, string lpName);
	
	[DllImport("kernel32.dll", SetLastError = true)]
	internal static extern void* MapViewOfFile(IntPtr hFileMappingObject, uint dwDesiredAccess, uint dwFileOffsetHigh, uint dwFileOffsetLow, nint dwNumberOfBytesToMap);
	
	[DllImport("kernel32.dll", SetLastError = true)]
	internal static extern bool UnmapViewOfFile(void* lpBaseAddress);
	
	[DllImport("kernel32.dll", EntryPoint = "GetModuleHandleW", SetLastError = true)]
	internal static extern IntPtr GetModuleHandle(string name);
	
	//Better use NativeLibrary.TryLoad.
	//Dlls loaded by LoadLibrary don't find other used dlls from the same directory if it's not the app directory. Need LoadLibraryEx with LOAD_WITH_ALTERED_SEARCH_PATH, and probably NativeLibrary.TryLoad uses it.
	//[DllImport("kernel32.dll", EntryPoint = "LoadLibraryW", SetLastError = true)]
	//internal static extern IntPtr LoadLibrary(string lpLibFileName);
	
	internal const uint LOAD_LIBRARY_AS_DATAFILE = 0x2;
	
	[DllImport("kernel32.dll", EntryPoint = "LoadLibraryExW", SetLastError = true)]
	internal static extern IntPtr LoadLibraryEx(string lpLibFileName, IntPtr hFile, uint dwFlags);
	
	[DllImport("kernel32.dll")]
	internal static extern bool FreeLibrary(IntPtr hLibModule);
	
	[DllImport("kernel32.dll", BestFitMapping = false, SetLastError = true)]
	internal static extern IntPtr GetProcAddress(IntPtr hModule, [MarshalAs(UnmanagedType.LPStr)] string lpProcName);
	
	internal const uint PROCESS_TERMINATE = 0x0001;
	internal const uint PROCESS_CREATE_THREAD = 0x0002;
	internal const uint PROCESS_SET_SESSIONID = 0x0004;
	internal const uint PROCESS_VM_OPERATION = 0x0008;
	internal const uint PROCESS_VM_READ = 0x0010;
	internal const uint PROCESS_VM_WRITE = 0x0020;
	internal const uint PROCESS_DUP_HANDLE = 0x0040;
	internal const uint PROCESS_CREATE_PROCESS = 0x0080;
	internal const uint PROCESS_SET_QUOTA = 0x0100;
	internal const uint PROCESS_SET_INFORMATION = 0x0200;
	internal const uint PROCESS_QUERY_INFORMATION = 0x0400;
	internal const uint PROCESS_SUSPEND_RESUME = 0x0800;
	internal const uint PROCESS_QUERY_LIMITED_INFORMATION = 0x1000;
	internal const uint PROCESS_ALL_ACCESS = STANDARD_RIGHTS_REQUIRED | SYNCHRONIZE | 0xFFFF;
	internal const uint DELETE = 0x00010000;
	internal const uint READ_CONTROL = 0x00020000;
	internal const uint WRITE_DAC = 0x00040000;
	internal const uint WRITE_OWNER = 0x00080000;
	internal const uint SYNCHRONIZE = 0x00100000;
	internal const uint STANDARD_RIGHTS_REQUIRED = 0x000F0000;
	internal const uint STANDARD_RIGHTS_READ = READ_CONTROL;
	internal const uint STANDARD_RIGHTS_WRITE = READ_CONTROL;
	internal const uint STANDARD_RIGHTS_EXECUTE = READ_CONTROL;
	internal const uint STANDARD_RIGHTS_ALL = 0x001F0000;
	internal const uint TIMER_MODIFY_STATE = 0x2;
	
	[DllImport("kernel32.dll", SetLastError = true)]
	internal static extern Handle_ OpenProcess(uint dwDesiredAccess, bool bInheritHandle, int dwProcessId);
	
	[DllImport("kernel32.dll", EntryPoint = "GetFullPathNameW", SetLastError = true)]
	static extern int _GetFullPathName(string lpFileName, int nBufferLength, char* lpBuffer, char** lpFilePart);
	
	/// <summary>
	/// Calls API <c>GetFullPathName</c>.
	/// Returns <c>false</c> if failed or result is same; then <i>r</i> is <i>s</i>.
	/// <i>r</i> can be same variable as <i>s</i>.
	/// </summary>
	[SkipLocalsInit]
	internal static bool GetFullPathName(string s, out string r) {
		using FastBuffer<char> b = new();
		for (; ; ) if (b.GetString(_GetFullPathName(s, b.n, b.p, null), out r, 0, s)) return (object)r != s;
	}
	
	[DllImport("kernel32.dll", EntryPoint = "GetLongPathNameW", SetLastError = true)]
	static extern int _GetLongPathName(string lpszShortPath, char* lpszLongPath, int cchBuffer);
	
	/// <summary>
	/// Calls API <c>GetFullPathName</c>.
	/// Returns <c>false</c> if failed or result is same; then <i>r</i> is <i>s</i>.
	/// <i>r</i> can be same variable as <i>s</i>.
	/// </summary>
	[SkipLocalsInit]
	internal static bool GetLongPathName(string s, out string r) {
		using FastBuffer<char> b = new();
		for (; ; ) if (b.GetString(_GetLongPathName(s, b.p, b.n), out r, 0, s)) return (object)r != s;
	}
	
	[DllImport("kernel32.dll", EntryPoint = "GetFinalPathNameByHandleW", SetLastError = true)]
	static extern int _GetFinalPathNameByHandle(IntPtr hFile, char* lpszFilePath, int cchFilePath, uint dwFlags);
	
	[SkipLocalsInit]
	internal static bool GetFinalPathNameByHandle(IntPtr h, out string r, uint dwFlags = 0) {
		using FastBuffer<char> b = new();
		for (; ; ) {
			g1: if (b.GetString(_GetFinalPathNameByHandle(h, b.p, b.n, dwFlags), out r, 0)) {
				if (r != null) return r.Length > 0;
				if (0u != (dwFlags & 3u)) { dwFlags &= ~3u; goto g1; } //if VOLUME_NAME_GUID, fails if network path
				return false;
			}
		}
	}
	
	[DllImport("kernel32.dll", SetLastError = true)]
	internal static extern bool ProcessIdToSessionId(int dwProcessId, out int pSessionId);
	
	internal const uint PAGE_NOACCESS = 0x1;
	internal const uint PAGE_READONLY = 0x2;
	internal const uint PAGE_READWRITE = 0x4;
	internal const uint PAGE_WRITECOPY = 0x8;
	internal const uint PAGE_EXECUTE = 0x10;
	internal const uint PAGE_EXECUTE_READ = 0x20;
	internal const uint PAGE_EXECUTE_READWRITE = 0x40;
	internal const uint PAGE_EXECUTE_WRITECOPY = 0x80;
	internal const uint PAGE_GUARD = 0x100;
	internal const uint PAGE_NOCACHE = 0x200;
	internal const uint PAGE_WRITECOMBINE = 0x400;
	
	internal const uint MEM_COMMIT = 0x1000;
	internal const uint MEM_RESERVE = 0x2000;
	internal const uint MEM_DECOMMIT = 0x4000;
	internal const uint MEM_RELEASE = 0x8000;
	internal const uint MEM_RESET = 0x80000;
	internal const uint MEM_TOP_DOWN = 0x100000;
	internal const uint MEM_WRITE_WATCH = 0x200000;
	internal const uint MEM_PHYSICAL = 0x400000;
	internal const uint MEM_RESET_UNDO = 0x1000000;
	internal const uint MEM_LARGE_PAGES = 0x20000000;
	
	[DllImport("kernel32.dll", SetLastError = true)]
	internal static extern void* VirtualAlloc(void* lpAddress, nint dwSize, uint flAllocationType = MEM_COMMIT | MEM_RESERVE, uint flProtect = PAGE_READWRITE);
	//note: with PAGE_EXECUTE_READWRITE writing to the memory first time is much slower.
	
	[DllImport("kernel32.dll")]
	internal static extern bool VirtualFree(void* lpAddress, nint dwSize = 0, uint dwFreeType = MEM_RELEASE);
	
	[DllImport("kernel32.dll", SetLastError = true)]
	internal static extern IntPtr VirtualAllocEx(HandleRef hProcess, IntPtr lpAddress, nint dwSize, uint flAllocationType = MEM_COMMIT | MEM_RESERVE, uint flProtect = PAGE_EXECUTE_READWRITE);
	
	[DllImport("kernel32.dll")]
	internal static extern bool VirtualFreeEx(HandleRef hProcess, IntPtr lpAddress, nint dwSize = 0, uint dwFreeType = MEM_RELEASE);
	
	[DllImport("kernel32.dll", EntryPoint = "GetFileAttributesW", SetLastError = true)]
	internal static extern FileAttributes GetFileAttributes(string lpFileName);
	
	[DllImport("kernel32.dll", EntryPoint = "SetFileAttributesW", SetLastError = true)]
	internal static extern bool SetFileAttributes(string lpFileName, FileAttributes dwFileAttributes);
	
	[StructLayout(LayoutKind.Sequential, Pack = 4)]
	internal struct WIN32_FILE_ATTRIBUTE_DATA {
		public FileAttributes dwFileAttributes;
		public FILETIME ftCreationTime;
		public FILETIME ftLastAccessTime;
		public FILETIME ftLastWriteTime;
		public uint nFileSizeHigh;
		public uint nFileSizeLow;
		public long Size => (long)nFileSizeHigh << 32 | nFileSizeLow;
	}
	
	[DllImport("kernel32.dll", EntryPoint = "GetFileAttributesExW", SetLastError = true)]
	internal static extern bool GetFileAttributesEx(string lpFileName, int zero, out WIN32_FILE_ATTRIBUTE_DATA lpFileInformation);
	
	[DllImport("kernel32.dll", EntryPoint = "SearchPathW", SetLastError = true)]
	static extern int _SearchPath(string lpPath, string lpFileName, string lpExtension, int nBufferLength, char* lpBuffer, char** lpFilePart);
	
	/// <summary>
	/// Calls API <c>SearchPath</c>. Returns full path, or <c>null</c> if not found.
	/// </summary>
	/// <param name="lpPath">Parent directory or <c>null</c>.</param>
	/// <param name="lpFileName"></param>
	/// <param name="lpExtension"><c>null</c> or extension like <c>".ext"</c> to add if <i>lpFileName</i> is without extension.</param>
	[SkipLocalsInit]
	internal static string SearchPath(string lpPath, string lpFileName, string lpExtension = null) {
		using FastBuffer<char> b = new();
		for (; ; ) if (b.GetString(_SearchPath(lpPath, lpFileName, lpExtension, b.n, b.p, null), out var s)) return s;
	}
	
	internal const uint BASE_SEARCH_PATH_ENABLE_SAFE_SEARCHMODE = 0x1;
	internal const uint BASE_SEARCH_PATH_DISABLE_SAFE_SEARCHMODE = 0x10000;
	internal const uint BASE_SEARCH_PATH_PERMANENT = 0x8000;
	
	[DllImport("kernel32.dll")]
	internal static extern bool SetSearchPathMode(uint Flags);
	
	internal const uint SEM_FAILCRITICALERRORS = 0x1;
	internal const uint SEM_NOGPFAULTERRORBOX = 0x2;
	
	[DllImport("kernel32.dll")]
	internal static extern uint SetErrorMode(uint uMode);
	
	//[DllImport("kernel32.dll")]
	//internal static extern uint GetErrorMode();
	
	//[DllImport("kernel32.dll", SetLastError = true)]
	//internal static extern IntPtr LocalAlloc(uint uFlags, nint uBytes);
	
	[DllImport("kernel32.dll")]
	internal static extern IntPtr LocalFree(void* hMem);
	
	[DllImport("kernel32.dll", EntryPoint = "lstrcpynW")]
	internal static extern char* lstrcpyn(char* sTo, string sFrom, int sToBufferLength);
	
	[DllImport("kernel32.dll", SetLastError = true)]
	internal static extern bool Wow64DisableWow64FsRedirection(out IntPtr OldValue);
	
	[DllImport("kernel32.dll")]
	internal static extern bool Wow64RevertWow64FsRedirection(IntPtr OlValue);
	
	[DllImport("kernel32.dll", SetLastError = true)]
	internal static extern bool GetExitCodeProcess(IntPtr hProcess, out int lpExitCode);
	
	[DllImport("kernel32.dll")]
	internal static extern IntPtr GetProcessHeap();
	[DllImport("kernel32.dll")]
	internal static extern void* HeapAlloc(IntPtr hHeap, uint dwFlags, nint dwBytes);
	[DllImport("kernel32.dll")]
	internal static extern void* HeapReAlloc(IntPtr hHeap, uint dwFlags, void* lpMem, nint dwBytes);
	[DllImport("kernel32.dll")]
	internal static extern bool HeapFree(IntPtr hHeap, uint dwFlags, void* lpMem);
	
	internal const int CP_UTF8 = 65001;
	internal const uint MB_ERR_INVALID_CHARS = 0x8;
	internal const uint WC_ERR_INVALID_CHARS = 0x80;
	
	[DllImport("kernel32.dll")]
	internal static extern int MultiByteToWideChar(uint CodePage, uint dwFlags, byte* lpMultiByteStr, int cbMultiByte, char* lpWideCharStr, int cchWideChar);
	
	[DllImport("kernel32.dll")]
	internal static extern int WideCharToMultiByte(uint CodePage, uint dwFlags, char* lpWideCharStr, int cchWideChar, byte* lpMultiByteStr, int cbMultiByte, IntPtr lpDefaultChar = default, int* lpUsedDefaultChar = null);
	
	[Flags]
	internal enum Access : uint { }
	
	internal const Access FILE_READ_DATA = (Access)0x1;
	internal const Access FILE_LIST_DIRECTORY = (Access)0x1;
	internal const Access FILE_WRITE_DATA = (Access)0x2;
	internal const Access FILE_ADD_FILE = (Access)0x2;
	internal const Access FILE_APPEND_DATA = (Access)0x4;
	internal const Access FILE_ADD_SUBDIRECTORY = (Access)0x4;
	internal const Access FILE_CREATE_PIPE_INSTANCE = (Access)0x4;
	internal const Access FILE_READ_EA = (Access)0x8;
	internal const Access FILE_WRITE_EA = (Access)0x10;
	internal const Access FILE_EXECUTE = (Access)0x20;
	internal const Access FILE_TRAVERSE = (Access)0x20;
	internal const Access FILE_DELETE_CHILD = (Access)0x40;
	internal const Access FILE_READ_ATTRIBUTES = (Access)0x80;
	internal const Access FILE_WRITE_ATTRIBUTES = (Access)0x100;
	internal const Access FILE_ALL_ACCESS = (Access)0x1F01FF;
	internal const Access FILE_GENERIC_READ = (Access)0x120089;
	internal const Access FILE_GENERIC_WRITE = (Access)0x120116;
	internal const Access FILE_GENERIC_EXECUTE = (Access)0x1200A0;
	
	internal const Access GENERIC_READ = (Access)0x80000000;
	internal const Access GENERIC_WRITE = (Access)0x40000000;
	
	internal enum CfCreation { }
	
	internal const CfCreation CREATE_NEW = (CfCreation)1;
	internal const CfCreation CREATE_ALWAYS = (CfCreation)2;
	internal const CfCreation OPEN_EXISTING = (CfCreation)3;
	internal const CfCreation OPEN_ALWAYS = (CfCreation)4;
	internal const CfCreation TRUNCATE_EXISTING = (CfCreation)5;
	
	[Flags]
	internal enum CfShare : uint { }
	
	internal const CfShare FILE_SHARE_READ = (CfShare)0x1;
	internal const CfShare FILE_SHARE_WRITE = (CfShare)0x2;
	internal const CfShare FILE_SHARE_DELETE = (CfShare)0x4;
	internal const CfShare FILE_SHARE_ALL = (CfShare)0x7;
	
	//the commented out attributes are not documented for CreateFile
	internal const uint FILE_ATTRIBUTE_READONLY = 0x1;
	internal const uint FILE_ATTRIBUTE_HIDDEN = 0x2;
	internal const uint FILE_ATTRIBUTE_SYSTEM = 0x4;
	//internal const uint FILE_ATTRIBUTE_DIRECTORY = 0x10;
	internal const uint FILE_ATTRIBUTE_ARCHIVE = 0x20;
	//internal const uint FILE_ATTRIBUTE_DEVICE = 0x40;
	internal const uint FILE_ATTRIBUTE_NORMAL = 0x80;
	internal const uint FILE_ATTRIBUTE_TEMPORARY = 0x100;
	//internal const uint FILE_ATTRIBUTE_SPARSE_FILE = 0x200;
	//internal const uint FILE_ATTRIBUTE_REPARSE_POINT = 0x400;
	//internal const uint FILE_ATTRIBUTE_COMPRESSED = 0x800;
	internal const uint FILE_ATTRIBUTE_OFFLINE = 0x1000;
	//internal const uint FILE_ATTRIBUTE_NOT_CONTENT_INDEXED = 0x2000;
	internal const uint FILE_ATTRIBUTE_ENCRYPTED = 0x4000;
	//internal const uint FILE_ATTRIBUTE_INTEGRITY_STREAM = 0x8000;
	//internal const uint FILE_ATTRIBUTE_VIRTUAL = 0x10000;
	//internal const uint FILE_ATTRIBUTE_NO_SCRUB_DATA = 0x20000;
	
	internal const uint FILE_FLAG_WRITE_THROUGH = 0x80000000;
	internal const uint FILE_FLAG_OVERLAPPED = 0x40000000;
	internal const uint FILE_FLAG_NO_BUFFERING = 0x20000000;
	internal const uint FILE_FLAG_RANDOM_ACCESS = 0x10000000;
	internal const uint FILE_FLAG_SEQUENTIAL_SCAN = 0x8000000;
	internal const uint FILE_FLAG_DELETE_ON_CLOSE = 0x4000000;
	internal const uint FILE_FLAG_BACKUP_SEMANTICS = 0x2000000;
	internal const uint FILE_FLAG_POSIX_SEMANTICS = 0x1000000;
	internal const uint FILE_FLAG_SESSION_AWARE = 0x800000;
	internal const uint FILE_FLAG_OPEN_REPARSE_POINT = 0x200000;
	internal const uint FILE_FLAG_OPEN_NO_RECALL = 0x100000;
	internal const uint FILE_FLAG_FIRST_PIPE_INSTANCE = 0x80000;
	internal const uint FILE_FLAG_OPEN_REQUIRING_OPLOCK = 0x40000;
	
	[DllImport("kernel32.dll", EntryPoint = "CreateFileW", SetLastError = true)]
	static extern IntPtr _CreateFile(string lpFileName, Access dwDesiredAccess, CfShare dwShareMode, SECURITY_ATTRIBUTES lpSecurityAttributes, CfCreation creationDisposition, uint dwFlagsAndAttributes, IntPtr hTemplateFile);
	
	internal static Handle_ CreateFile(string lpFileName, Access dwDesiredAccess, CfShare dwShareMode, CfCreation creationDisposition, uint dwFlagsAndAttributes = FILE_ATTRIBUTE_NORMAL, IntPtr hTemplateFile = default, SECURITY_ATTRIBUTES lpSecurityAttributes = null)
		=> new Handle_(_CreateFile(lpFileName, dwDesiredAccess, dwShareMode, lpSecurityAttributes, creationDisposition, dwFlagsAndAttributes, hTemplateFile));
	//note: cannot return Handle_ directly from API because returns -1 if failed. The ctor then makes 0.
	
	//note: not using parameter types SECURITY_ATTRIBUTES and OVERLAPPED* because it makes JIT-compiling much slower in some time-critical places.
	
	[DllImport("kernel32.dll", SetLastError = true)]
	internal static extern bool ReadFile(IntPtr hFile, void* lpBuffer, int nBytesToRead, out int nBytesRead, void* lpOverlapped = null);
	
	internal static bool ReadFileArr(IntPtr hFile, byte[] a, out int nBytesRead, void* lpOverlapped = null) {
		fixed (byte* p = a) return ReadFile(hFile, p, a.Length, out nBytesRead, lpOverlapped);
	}
	
	internal static bool ReadFileArr(IntPtr hFile, out byte[] a, int size, out int nBytesRead, void* lpOverlapped = null) {
		a = new byte[size];
		return ReadFileArr(hFile, a, out nBytesRead, lpOverlapped);
	}
	
	//internal static byte[] ReadFileArr(string file) {
	//	using var h = CreateFile(file, Api.GENERIC_READ, FILE_SHARE_ALL, OPEN_EXISTING);
	//	if (h.Is0 || !GetFileSizeEx(h, out long size) || !ReadFileArr(h, out var a, (int)size, out _)) throw new AuException(0);
	//	return a;
	//}
	
	[DllImport("kernel32.dll", SetLastError = true)]
	internal static extern bool WriteFile(IntPtr hFile, void* lpBuffer, int nBytesToWrite, out int nBytesWritten, void* lpOverlapped = null);
	//note: lpNumberOfBytesWritten can be null only if lpOverlapped is not null.
	
	//note: don't use overloads, because we Jit_.Compile("WriteFile").
	internal static bool WriteFile2(IntPtr hFile, RByte a, out int nBytesWritten) {
		fixed (byte* p = a) return WriteFile(hFile, p, a.Length, out nBytesWritten);
	}
	
	//internal static bool WriteFile2(IntPtr hFile, RByte a, out int nBytesWritten, void* lpOverlapped)
	//{
	//	fixed (byte* p = a) return WriteFile(hFile, p, a.Length, out nBytesWritten, lpOverlapped);
	//}
	
	internal struct OVERLAPPED {
		nint _1, _2;
		int _3, _4;
		public IntPtr hEvent;
	}
	
	[StructLayout(LayoutKind.Sequential, Pack = 4)]
	internal struct BY_HANDLE_FILE_INFORMATION {
		public uint dwFileAttributes;
		public long ftCreationTime;
		public long ftLastAccessTime;
		public long ftLastWriteTime;
		public uint dwVolumeSerialNumber;
		uint _nFileSizeHigh;
		uint _nFileSizeLow;
		public uint nNumberOfLinks;
		uint _nFileIndexHigh;
		uint _nFileIndexLow;
		
		public long FileSize => (long)((ulong)_nFileSizeHigh << 32 | _nFileSizeLow);
		
		public long FileIndex => (long)((ulong)_nFileIndexHigh << 32 | _nFileIndexLow);
	}
	
	[DllImport("kernel32.dll", SetLastError = true)]
	internal static extern bool GetFileInformationByHandle(IntPtr hFile, out BY_HANDLE_FILE_INFORMATION lpFileInformation);
	
	//internal enum FILE_INFO_BY_HANDLE_CLASS
	//{
	//	FileBasicInfo,
	//	FileStandardInfo,
	//	FileNameInfo,
	//	FileRenameInfo,
	//	FileDispositionInfo,
	//	FileAllocationInfo,
	//	FileEndOfFileInfo,
	//	FileStreamInfo,
	//	FileCompressionInfo,
	//	FileAttributeTagInfo,
	//	FileIdBothDirectoryInfo,
	//	FileIdBothDirectoryRestartInfo,
	//	FileIoPriorityHintInfo,
	//	FileRemoteProtocolInfo,
	//	FileFullDirectoryInfo,
	//	FileFullDirectoryRestartInfo,
	//	FileStorageInfo,
	//	FileAlignmentInfo,
	//	FileIdInfo,
	//	FileIdExtdDirectoryInfo,
	//	FileIdExtdDirectoryRestartInfo,
	//	MaximumFileInfoByHandleClass
	//}
	
	//internal struct FILE_BASIC_INFO
	//{
	//	public long CreationTime;
	//	public long LastAccessTime;
	//	public long LastWriteTime;
	//	public long ChangeTime;
	//	public uint FileAttributes;
	//}
	
	//[DllImport("kernel32.dll", SetLastError = true)]
	//internal static extern bool GetFileInformationByHandleEx(IntPtr hFile, int FileInformationClass, void* lpFileInformation, int dwBufferSize);
	
	//[DllImport("kernel32.dll", SetLastError = true)]
	//internal static extern bool SetFileInformationByHandle(IntPtr hFile, int FileInformationClass, void* lpFileInformation, int dwBufferSize);
	
	internal const int FILE_BEGIN = 0;
	internal const int FILE_CURRENT = 1;
	internal const int FILE_END = 2;
	
	[DllImport("kernel32.dll", SetLastError = true)]
	internal static extern bool SetFilePointerEx(IntPtr hFile, long liDistanceToMove, long* lpNewFilePointer, int dwMoveMethod);
	
	[DllImport("kernel32.dll", SetLastError = true)]
	internal static extern bool SetEndOfFile(IntPtr hFile);
	
	[DllImport("kernel32.dll", EntryPoint = "CreateMailslotW", SetLastError = true)]
	static extern IntPtr _CreateMailslot(string lpName, uint nMaxMessageSize, int lReadTimeout, SECURITY_ATTRIBUTES lpSecurityAttributes);
	
	internal static Handle_ CreateMailslot(string lpName, uint nMaxMessageSize, int lReadTimeout, SECURITY_ATTRIBUTES lpSecurityAttributes)
		=> new Handle_(_CreateMailslot(lpName, nMaxMessageSize, lReadTimeout, lpSecurityAttributes));
	//note: cannot return Handle_ directly from API because returns -1 if failed. The ctor then makes 0.
	
	[DllImport("kernel32.dll", SetLastError = true)]
	internal static extern bool GetMailslotInfo(IntPtr hMailslot, uint* lpMaxMessageSize, out int lpNextSize, out int lpMessageCount, int* lpReadTimeout = null);
	
	[DllImport("kernel32.dll")]
	internal static extern int GetApplicationUserModelId(IntPtr hProcess, ref int AppModelIDLength, char* sbAppUserModelID);
	
	[DllImport("kernel32.dll", EntryPoint = "GetEnvironmentVariableW", SetLastError = true)]
	static extern int _GetEnvironmentVariable(string lpName, char* lpBuffer, int nSize);
	
	/// <summary>
	/// Calls API <c>GetEnvironmentVariable</c>.
	/// Returns <c>null</c> if variable not found.
	/// Does not support <c>folders.X</c>.
	/// </summary>
	/// <param name="name">Case-insensitive name. Without <c>%</c>.</param>
	[SkipLocalsInit]
	internal static string GetEnvironmentVariable(string name) {
		using FastBuffer<char> b = new();
		for (; ; ) if (b.GetString(_GetEnvironmentVariable(name, b.p, b.n), out var s)) return s;
	}
	
	/// <summary>
	/// Returns <c>true</c> if environment variable exists.
	/// </summary>
	internal static bool EnvironmentVariableExists(string name) => 0 != _GetEnvironmentVariable(name, null, 0);
	
	[DllImport("kernel32.dll", EntryPoint = "SetEnvironmentVariableW", SetLastError = true)]
	internal static extern bool SetEnvironmentVariable(string lpName, string lpValue);
	
	[DllImport("kernel32.dll", EntryPoint = "ExpandEnvironmentStringsW")]
	static extern int _ExpandEnvironmentStrings(string lpSrc, char* lpDst, int nSize);
	
	/// <summary>
	/// Calls API <c>ExpandEnvironmentStrings</c>.
	/// Returns <c>false</c> if failed or result is same; then <i>r</i> is <i>s</i>.
	/// <i>r</i> can be same variable as <i>s</i>.
	/// </summary>
	[SkipLocalsInit]
	internal static bool ExpandEnvironmentStrings(string s, out string r) {
		using FastBuffer<char> b = new();
		for (; ; ) if (b.GetString(_ExpandEnvironmentStrings(s, b.p, b.n), out r, BSFlags.ReturnsLengthWith0, s)) return (object)r != s;
	}
	
	[DllImport("kernel32.dll", EntryPoint = "GetEnvironmentStringsW")]
	internal static extern char* GetEnvironmentStrings();
	
	[DllImport("kernel32.dll", EntryPoint = "FreeEnvironmentStringsW")]
	internal static extern bool FreeEnvironmentStrings(char* penv);
	
	[DllImport("kernel32.dll", SetLastError = true)]
	internal static extern int GetProcessId(IntPtr Process);
	
	internal struct FILETIME {
		public uint dwLowDateTime;
		public uint dwHighDateTime;
		
		public static implicit operator long(FILETIME ft) => (long)((ulong)ft.dwHighDateTime << 32 | ft.dwLowDateTime);
		public static implicit operator FILETIME(long ft) => new() { dwHighDateTime = (uint)(ft >>> 32), dwLowDateTime = (uint)ft };
	}
	
	internal struct WIN32_FIND_DATA {
		public FileAttributes dwFileAttributes;
		public FILETIME ftCreationTime;
		public FILETIME ftLastAccessTime;
		public FILETIME ftLastWriteTime;
		public uint nFileSizeHigh;
		public uint nFileSizeLow;
		public uint dwReserved0;
		public uint dwReserved1;
		public fixed char cFileName[260];
		public fixed char cAlternateFileName[14];
		
		/// <summary>
		/// Returns <c>cFileName</c> as string, or null if it's <c>".."</c> or <c>"."</c>.
		/// </summary>
		public unsafe string Name {
			get {
				fixed (char* p = cFileName) {
					if (p[0] == '.') {
						if (p[1] == '\0') return null;
						if (p[1] == '.' && p[2] == '\0') return null;
					}
					return new string(p);
				}
			}
		}
		
		/// <summary>
		/// Returns nonzero if this is a NTFS link: 1 symlink, 2 mount, 3 other.
		/// </summary>
		public int IsNtfsLink
			=> dwFileAttributes.Has(FileAttributes.ReparsePoint) && 0 != (dwReserved0 & 0x20000000)
			? dwReserved0 switch { 0xA000000C => 1, 0xA0000003 => 2, _ => 3 }
			: 0;
	}
	
	[DllImport("kernel32.dll", EntryPoint = "FindFirstFileW", SetLastError = true)]
	internal static extern IntPtr FindFirstFile(string lpFileName, out WIN32_FIND_DATA lpFindFileData);
	
	[DllImport("kernel32.dll", EntryPoint = "FindNextFileW", SetLastError = true)]
	internal static extern bool FindNextFile(IntPtr hFindFile, out WIN32_FIND_DATA lpFindFileData);
	
	[DllImport("kernel32.dll")]
	internal static extern bool FindClose(IntPtr hFindFile);
	
#if TEST_FINDFIRSTFILEEX
	internal enum FINDEX_INFO_LEVELS
	{
		FindExInfoStandard,
		FindExInfoBasic,
		FindExInfoMaxInfoLevel
	}

	internal const uint FIND_FIRST_EX_LARGE_FETCH = 0x2;

	[DllImport("kernel32.dll", EntryPoint = "FindFirstFileExW")]
	internal static extern IntPtr FindFirstFileEx(string lpFileName, FINDEX_INFO_LEVELS fInfoLevelId, out WIN32_FIND_DATA lpFindFileData, int fSearchOp, IntPtr lpSearchFilter, uint dwAdditionalFlags);
#endif
	
	internal const uint MOVEFILE_REPLACE_EXISTING = 0x1;
	internal const uint MOVEFILE_COPY_ALLOWED = 0x2;
	internal const uint MOVEFILE_DELAY_UNTIL_REBOOT = 0x4;
	internal const uint MOVEFILE_WRITE_THROUGH = 0x8;
	internal const uint MOVEFILE_CREATE_HARDLINK = 0x10;
	internal const uint MOVEFILE_FAIL_IF_NOT_TRACKABLE = 0x20;
	
	[DllImport("kernel32.dll", EntryPoint = "MoveFileExW", SetLastError = true)]
	internal static extern bool MoveFileEx(string lpExistingFileName, string lpNewFileName, uint dwFlags);
	
	//[DllImport("kernel32.dll", EntryPoint = "CopyFileW", SetLastError = true)]
	//internal static extern bool CopyFile(string lpExistingFileName, string lpNewFileName, bool bFailIfExists);
	
	internal const uint COPY_FILE_FAIL_IF_EXISTS = 0x1;
	internal const uint COPY_FILE_RESTARTABLE = 0x2;
	internal const uint COPY_FILE_OPEN_SOURCE_FOR_WRITE = 0x4;
	internal const uint COPY_FILE_ALLOW_DECRYPTED_DESTINATION = 0x8;
	internal const uint COPY_FILE_COPY_SYMLINK = 0x800;
	internal const uint COPY_FILE_NO_BUFFERING = 0x1000;
	
	[DllImport("kernel32.dll", EntryPoint = "CopyFileExW", SetLastError = true)]
	static extern bool CopyFileEx(string lpExistingFileName, string lpNewFileName, nint lpProgressRoutine, IntPtr lpData, int* pbCancel, uint dwCopyFlags);
	
	internal static bool CopyFileEx(string lpExistingFileName, string lpNewFileName, uint dwCopyFlags) {
		if (!CopyFileEx(lpExistingFileName, lpNewFileName, 0, 0, null, dwCopyFlags)) return false;
		
		//Workaround for: when copying in Vmware virtual PC from host path like @"\\vmware-host\Shared Folders\...", adds Readonly attribute.
		//	Also GetFileAttributes[Ex] for the source adds Readonly. But FindFirstFile[Ex] doesn't.
		if (GetFileAttributes(lpNewFileName) is var a1 && a1.Has(FileAttributes.ReadOnly) && a1 != (FileAttributes)(-1)) {
			var h = FindFirstFile(lpExistingFileName, out var d);
			if (h != -1) {
				FindClose(h);
				if (!d.dwFileAttributes.Has(FileAttributes.ReadOnly)) {
					Debug_.Print("Readonly attribute");
					SetFileAttributes(lpNewFileName, d.dwFileAttributes);
				}
			}
		}
		
		return true;
	}
	
	[DllImport("kernel32.dll", EntryPoint = "DeleteFileW", SetLastError = true)]
	internal static extern bool DeleteFile(string lpFileName);
	
	[DllImport("kernel32.dll", EntryPoint = "RemoveDirectoryW", SetLastError = true)]
	internal static extern bool RemoveDirectory(string lpPathName);
	
	[DllImport("kernel32.dll", EntryPoint = "CreateDirectoryW", SetLastError = true)]
	internal static extern bool CreateDirectory(string lpPathName, IntPtr lpSecurityAttributes); //ref SECURITY_ATTRIBUTES
	
	[DllImport("kernel32.dll", EntryPoint = "CreateDirectoryExW", SetLastError = true)]
	internal static extern bool CreateDirectoryEx(string lpTemplateDirectory, string lpNewDirectory, IntPtr lpSecurityAttributes); //ref SECURITY_ATTRIBUTES
	
	[DllImport("kernel32.dll", EntryPoint = "ReplaceFileW", SetLastError = true)]
	internal static extern bool ReplaceFile(string lpReplacedFileName, string lpReplacementFileName, string lpBackupFileName, uint dwReplaceFlags, IntPtr lpExclude = default, IntPtr lpReserved = default);
	
	[DllImport("kernel32.dll", EntryPoint = "GlobalAddAtomW")]
	internal static extern ushort GlobalAddAtom(string lpString);
	
	[DllImport("kernel32.dll")]
	internal static extern ushort GlobalDeleteAtom(ushort nAtom);
	
	[DllImport("kernel32.dll", SetLastError = true)]
	internal static extern bool ReadProcessMemory(HandleRef hProcess, IntPtr lpBaseAddress, void* lpBuffer, nint nSize, nint* lpNumberOfBytesRead);
	
	[DllImport("kernel32.dll", SetLastError = true)]
	internal static extern bool WriteProcessMemory(HandleRef hProcess, IntPtr lpBaseAddress, void* lpBuffer, nint nSize, nint* lpNumberOfBytesWritten);
	
	[DllImport("kernel32.dll", SetLastError = true)]
	internal extern static IntPtr CreateActCtx(in ACTCTX actctx);
	
	[DllImport("kernel32.dll", SetLastError = true)]
	internal extern static bool ActivateActCtx(IntPtr hActCtx, out IntPtr lpCookie);
	
	[DllImport("kernel32.dll", SetLastError = true)]
	internal extern static bool DeactivateActCtx(int dwFlags, IntPtr lpCookie);
	
	[DllImport("kernel32.dll")]
	internal static extern void ReleaseActCtx(IntPtr hActCtx);
	
	internal const int ACTCTX_FLAG_RESOURCE_NAME_VALID = 0x8;
	internal const int ACTCTX_FLAG_HMODULE_VALID = 0x80;
	
	internal struct ACTCTX {
		public int cbSize;
		public uint dwFlags;
		public string lpSource;
		public ushort wProcessorArchitecture;
		public ushort wLangId;
		public IntPtr lpAssemblyDirectory;
		public IntPtr lpResourceName;
		public IntPtr lpApplicationName;
		public IntPtr hModule;
	}
	
	
	//internal const uint THREAD_TERMINATE = 0x1;
	internal const uint THREAD_SUSPEND_RESUME = 0x2;
	internal const uint THREAD_SET_CONTEXT = 0x10;
	internal const uint THREAD_QUERY_LIMITED_INFORMATION = 0x800;
	internal const uint THREAD_ALL_ACCESS = 0x1FFFFF;
	
	[DllImport("kernel32.dll", SetLastError = true)]
	internal static extern Handle_ OpenThread(uint dwDesiredAccess, bool bInheritHandle, int dwThreadId);
	
	[DllImport("kernel32.dll", SetLastError = true)]
	internal static extern int SuspendThread(IntPtr hThread);
	
	[DllImport("kernel32.dll", SetLastError = true)]
	internal static extern uint ResumeThread(IntPtr hThread);
	
	//[DllImport("kernel32.dll", SetLastError = true)]
	//internal static extern bool TerminateThread(IntPtr hThread, int dwExitCode);
	
	internal const uint GMEM_FIXED = 0x0;
	internal const uint GMEM_MOVEABLE = 0x2;
	internal const uint GMEM_ZEROINIT = 0x40;
	
	[DllImport("kernel32.dll", SetLastError = true)]
	internal static extern IntPtr GlobalAlloc(uint uFlags, nint dwBytes);
	
	[DllImport("kernel32.dll", SetLastError = true)]
	internal static extern IntPtr GlobalFree(IntPtr hMem);
	
	[DllImport("kernel32.dll", SetLastError = true)]
	internal static extern IntPtr GlobalLock(IntPtr hMem);
	
	[DllImport("kernel32.dll", SetLastError = true)]
	internal static extern bool GlobalUnlock(IntPtr hMem);
	
	[DllImport("kernel32.dll", SetLastError = true)]
	internal static extern nint GlobalSize(IntPtr hMem);
	
	[DllImport("kernel32.dll", SetLastError = true)]
	internal static extern bool GetFileSizeEx(IntPtr hFile, out long lpFileSize);
	
	[DllImport("kernel32.dll", SetLastError = true)]
	internal static extern int WaitForMultipleObjectsEx(int nCount, IntPtr* pHandles, bool bWaitAll, int dwMilliseconds, bool bAlertable);
	
	[DllImport("kernel32.dll")]
	internal static extern int SleepEx(int dwMilliseconds, bool bAlertable);
	
	[DllImport("kernel32.dll", EntryPoint = "GetStartupInfoW")]
	internal static extern void GetStartupInfo(out STARTUPINFO lpStartupInfo);
	
	internal struct STARTUPINFO {
		public int cb;
		public IntPtr lpReserved;
		public char* lpDesktop;
		public char* lpTitle;
		public int dwX;
		public int dwY;
		public int dwXSize;
		public int dwYSize;
		public int dwXCountChars;
		public int dwYCountChars;
		public uint dwFillAttribute;
		public uint dwFlags;
		public ushort wShowWindow;
		public ushort cbReserved2;
		public IntPtr lpReserved2;
		public IntPtr hStdInput;
		public IntPtr hStdOutput;
		public IntPtr hStdError;
	}
	
	internal struct STARTUPINFOEX {
		public STARTUPINFO StartupInfo;
		public IntPtr lpAttributeList;
	}
	
	internal struct PROCESS_INFORMATION : IDisposable {
		public Handle_ hProcess;
		public Handle_ hThread;
		public int dwProcessId;
		public int dwThreadId;
		
		public void Dispose() {
			hThread.Dispose();
			hProcess.Dispose();
		}
	}
	
	//CreateProcess flags
	internal const uint CREATE_SUSPENDED = 0x4;
	internal const uint CREATE_NEW_CONSOLE = 0x10;
	internal const uint CREATE_UNICODE_ENVIRONMENT = 0x400;
	internal const uint EXTENDED_STARTUPINFO_PRESENT = 0x80000;
	//STARTUPINFO flags
	internal const uint STARTF_USESHOWWINDOW = 0x1;
	internal const uint STARTF_FORCEOFFFEEDBACK = 0x80;
	internal const uint STARTF_USESTDHANDLES = 0x100;
	
	[DllImport("kernel32.dll", EntryPoint = "CreateProcessW", SetLastError = true)]
	internal static extern bool CreateProcess(string lpApplicationName, char[] lpCommandLine, SECURITY_ATTRIBUTES lpProcessAttributes, SECURITY_ATTRIBUTES lpThreadAttributes, bool bInheritHandles, uint dwCreationFlags, string lpEnvironment, string lpCurrentDirectory, in STARTUPINFO lpStartupInfo, out PROCESS_INFORMATION lpProcessInformation);
	
	[DllImport("advapi32.dll", EntryPoint = "CreateProcessAsUserW", SetLastError = true)]
	internal static extern bool CreateProcessAsUser(IntPtr hToken, string lpApplicationName, char[] lpCommandLine, SECURITY_ATTRIBUTES lpProcessAttributes, SECURITY_ATTRIBUTES lpThreadAttributes, bool bInheritHandles, uint dwCreationFlags, string lpEnvironment, string lpCurrentDirectory, in STARTUPINFO lpStartupInfo, out PROCESS_INFORMATION lpProcessInformation);
	
	[DllImport("kernel32.dll", EntryPoint = "CreateWaitableTimerW", SetLastError = true)]
	internal static extern Handle_ CreateWaitableTimer(SECURITY_ATTRIBUTES lpTimerAttributes, bool bManualReset, string lpTimerName);
	
	[DllImport("kernel32.dll", SetLastError = true)]
	internal static extern bool SetWaitableTimer(IntPtr hTimer, ref long lpDueTime, int lPeriod = 0, IntPtr pfnCompletionRoutine = default, IntPtr lpArgToCompletionRoutine = default, bool fResume = false);
	
	[DllImport("kernel32.dll", EntryPoint = "OpenWaitableTimerW", SetLastError = true)]
	internal static extern Handle_ OpenWaitableTimer(uint dwDesiredAccess, bool bInheritHandle, string lpTimerName);
	
	[DllImport("kernel32.dll", EntryPoint = "GetModuleFileNameW", SetLastError = true)]
	internal static extern int GetModuleFileName(IntPtr hModule, char* lpFilename, int nSize);
	
	internal const uint PIPE_ACCESS_INBOUND = 0x1;
	internal const uint PIPE_ACCESS_OUTBOUND = 0x2;
	internal const uint PIPE_ACCESS_DUPLEX = 0x3;
	internal const uint PIPE_TYPE_MESSAGE = 0x4;
	internal const uint PIPE_READMODE_MESSAGE = 0x2;
	internal const uint PIPE_REJECT_REMOTE_CLIENTS = 0x8;
	
	[DllImport("kernel32.dll", EntryPoint = "CreateNamedPipeW", SetLastError = true)]
	static extern IntPtr _CreateNamedPipe(string lpName, uint dwOpenMode, uint dwPipeMode, uint nMaxInstances, uint nOutBufferSize, uint nInBufferSize, uint nDefaultTimeOut, SECURITY_ATTRIBUTES lpSecurityAttributes);
	
	internal static Handle_ CreateNamedPipe(string lpName, uint dwOpenMode, uint dwPipeMode, uint nMaxInstances, uint nOutBufferSize, uint nInBufferSize, uint nDefaultTimeOut, SECURITY_ATTRIBUTES lpSecurityAttributes)
		=> new Handle_(_CreateNamedPipe(lpName, dwOpenMode, dwPipeMode, nMaxInstances, nOutBufferSize, nInBufferSize, nDefaultTimeOut, lpSecurityAttributes));
	//note: cannot return Handle_ directly from API because returns -1 if failed. The ctor then makes 0.
	
	[DllImport("kernel32.dll", SetLastError = true)]
	internal static extern bool CreatePipe(out Handle_ hReadPipe, out Handle_ hWritePipe, SECURITY_ATTRIBUTES lpPipeAttributes, uint nSize);
	
	[DllImport("kernel32.dll", SetLastError = true)]
	internal static extern bool ConnectNamedPipe(IntPtr hNamedPipe, OVERLAPPED* lpOverlapped);
	
	[DllImport("kernel32.dll", SetLastError = true)]
	internal static extern bool DisconnectNamedPipe(IntPtr hNamedPipe);
	
	[DllImport("kernel32.dll", SetLastError = true)]
	internal static extern bool GetOverlappedResult(IntPtr hFile, ref OVERLAPPED lpOverlapped, out int lpNumberOfBytesTransferred, bool bWait);
	
	[DllImport("kernel32.dll", SetLastError = true)]
	internal static extern bool CancelIo(IntPtr hFile);
	
	[DllImport("kernel32.dll", EntryPoint = "WaitNamedPipeW", SetLastError = true)]
	internal static extern bool WaitNamedPipe(string lpNamedPipeName, int nTimeOut);
	
	//[DllImport("kernel32.dll", EntryPoint = "CallNamedPipeW", SetLastError = true)]
	//internal static extern bool CallNamedPipe(string lpNamedPipeName, void* lpInBuffer, int nInBufferSize, out int lpOutBuffer, int nOutBufferSize, out int lpBytesRead, int nTimeOut);
	
	//[DllImport("kernel32.dll", SetLastError = true)]
	//internal static extern bool GetNamedPipeClientProcessId(IntPtr Pipe, out int ClientProcessId);
	
	[DllImport("kernel32.dll", SetLastError = true)]
	internal static extern bool PeekNamedPipe(IntPtr hNamedPipe, void* lpBuffer, int nBufferSize, out int lpBytesRead, out int lpTotalBytesAvail, IntPtr lpBytesLeftThisMessage = default);
	
	[DllImport("kernel32.dll", SetLastError = true)]
	internal static extern bool AllocConsole();
	
	[DllImport("kernel32.dll", EntryPoint = "OutputDebugStringW")]
	internal static extern void OutputDebugString(string lpOutputString);
	
	[DllImport("kernel32.dll")]
	internal static extern bool SetProcessWorkingSetSize(IntPtr hProcess, nint dwMinimumWorkingSetSize, nint dwMaximumWorkingSetSize);
	
	//internal struct PROCESS_MEMORY_COUNTERS
	//{
	//	public int cb;
	//	public int PageFaultCount;
	//	public nint PeakWorkingSetSize;
	//	public nint WorkingSetSize;
	//	public nint QuotaPeakPagedPoolUsage;
	//	public nint QuotaPagedPoolUsage;
	//	public nint QuotaPeakNonPagedPoolUsage;
	//	public nint QuotaNonPagedPoolUsage;
	//	public nint PagefileUsage;
	//	public nint PeakPagefileUsage;
	//}
	
	//[DllImport("kernel32.dll", EntryPoint = "K32GetProcessMemoryInfo")]
	//internal static extern bool GetProcessMemoryInfo(IntPtr Process, ref PROCESS_MEMORY_COUNTERS ppsmemCounters, int cb);
	
	[DllImport("kernel32.dll", EntryPoint = "FindResourceW", SetLastError = true)]
	public static extern IntPtr FindResource(IntPtr hModule, nint lpName, nint lpType);
	
	internal const int RT_GROUP_ICON = 14;
	
	//internal const int STD_INPUT_HANDLE = -10;
	internal const int STD_OUTPUT_HANDLE = -11;
	
	[DllImport("kernel32.dll")]
	internal static extern nint GetStdHandle(int nStdHandle);
	
	[DllImport("kernel32.dll", SetLastError = true)]
	internal static extern uint GetConsoleOutputCP();
	
	[DllImport("kernel32.dll")]
	internal static extern nint SetUnhandledExceptionFilter(nint _);
	
	[DllImport("kernel32.dll", SetLastError = true)]
	internal static extern uint QueueUserAPC(delegate* unmanaged<GCHandle, void> pfnAPC, IntPtr hThread, GCHandle dwData);
	
	internal delegate void PAPCFUNC(nint Parameter);
	
	[DllImport("kernel32.dll", EntryPoint = "GetDriveTypeW")]
	internal static extern int GetDriveType(string lpRootPathName);
	
	/// <summary>
	/// Use this API instead of <c>Directory.CreateSymbolicLink</c> which has a bug: does not throw exception when fails (eg non-admin).
	/// Note: the API fails if non-admin.
	///		With flag 2 does not fail if enabled developer mode.
	///		It seems can be enabled for non-admin in <c>gpedit.msc</c>; not tested; google for more info.
	///		Somewhere found this info, but it's incorrect: "Windows 11 doesn’t require administrative privileges to create symbolic links".
	/// </summary>
	/// <param name="dwFlags">1 - directory.</param>
	[DllImport("kernel32.dll", EntryPoint = "CreateSymbolicLinkW", SetLastError = true)]
	[return: MarshalAs(UnmanagedType.U1)] //BOOLEAN
	internal static extern bool CreateSymbolicLink(string lpSymlinkFileName, string lpTargetFileName, uint dwFlags);
	
	[DllImport("kernel32.dll")]
	internal static extern int GetACP();
	
	[DllImport("kernel32.dll", SetLastError = true)]
	internal static extern bool DeviceIoControl(IntPtr hDevice, int dwIoControlCode, void* lpInBuffer, int nInBufferSize, void* lpOutBuffer, int nOutBufferSize, out int lpBytesReturned, nint lpOverlapped = 0);
	
	internal const int IOCTL_STORAGE_QUERY_PROPERTY = 0x2D1400;
	
	internal struct STORAGE_PROPERTY_QUERY {
		public int PropertyId;
		public int QueryType;
		public byte AdditionalParameters;
	}
	
	internal struct DEVICE_SEEK_PENALTY_DESCRIPTOR {
		public uint Version;
		public uint Size;
		public byte IncursSeekPenalty;
	}
	
	[DllImport("kernel32.dll", EntryPoint = "GetVolumePathNameW", SetLastError = true)]
	internal static extern bool GetVolumePathName(string lpszFileName, char* lpszVolumePathName, int cchBufferLength);
	
	[DllImport("kernel32.dll", EntryPoint = "GetVolumeNameForVolumeMountPointW", SetLastError = true)]
	internal static extern bool GetVolumeNameForVolumeMountPoint(string lpszVolumeMountPoint, char* lpszVolumeName, int cchBufferLength);
	
	[DllImport("kernel32.dll", EntryPoint = "GetCommandLineW")]
	internal static extern char* GetCommandLine();
	
	[DllImport("kernel32.dll")]
	internal static extern int WTSGetActiveConsoleSessionId();
	
	
	
	
	
	#region undocumented
	
	internal delegate int CheckElevationEnabled(out int pResult);
	
	#endregion
}


================================================
FILE: Au/Api/Api^user32.cs
================================================
namespace Au.Types;

//#pragma warning disable 649 //field never assigned

static unsafe partial class Api {
	[DllImport("user32.dll", EntryPoint = "SendMessageW", SetLastError = true)]
	internal static extern nint SendMessage(wnd hWnd, int msg, nint wParam, nint lParam);
	
	[DllImport("user32.dll", EntryPoint = "SendMessageTimeoutW", SetLastError = true)]
	internal static extern nint SendMessageTimeout(wnd hWnd, int Msg, nint wParam, nint lParam, SMTFlags flags, int uTimeout, out nint lpdwResult);
	
	[DllImport("user32.dll", EntryPoint = "SendNotifyMessageW", SetLastError = true)]
	internal static extern bool SendNotifyMessage(wnd hWnd, int Msg, nint wParam, nint lParam);
	
	[DllImport("user32.dll", EntryPoint = "PostMessageW", SetLastError = true)]
	internal static extern bool PostMessage(wnd hWnd, int Msg, nint wParam, nint lParam);
	
	[DllImport("user32.dll", EntryPoint = "PostThreadMessageW", SetLastError = true)]
	internal static extern bool PostThreadMessage(int idThread, int Msg, nint wParam, nint lParam);
	
	[DllImport("user32.dll", SetLastError = true)]
	static extern nint GetWindowLongW(wnd hWnd, int nIndex);
	
	[DllImport("user32.dll", SetLastError = true)]
	static extern nint GetWindowLongPtrW(wnd hWnd, int nIndex);
	
	//info: 32-bit user32.dll does not have GetWindowLongPtrW etc. In C++, in x86 config it is defined as GetWindowLongW etc.
	internal static nint GetWindowLongPtr(wnd w, int nIndex)
		=> IntPtr.Size == 8 ? GetWindowLongPtrW(w, nIndex) : GetWindowLongW(w, nIndex);
	
	[DllImport("user32.dll", SetLastError = true)]
	static extern nint SetWindowLongW(wnd hWnd, int nIndex, nint dwNewLong);
	
	[DllImport("user32.dll", SetLastError = true)]
	static extern nint SetWindowLongPtrW(wnd hWnd, int nIndex, nint dwNewLong);
	
	internal static nint SetWindowLongPtr(wnd w, int nIndex, nint dwNewLong)
		=> IntPtr.Size == 8 ? SetWindowLongPtrW(w, nIndex, dwNewLong) : SetWindowLongW(w, nIndex, dwNewLong);
	
	[DllImport("user32.dll", SetLastError = true)]
	static extern nint GetClassLongW(wnd hWnd, int nIndex);
	
	[DllImport("user32.dll", SetLastError = true)]
	static extern nint GetClassLongPtrW(wnd hWnd, int nIndex);
	
	internal static nint GetClassLongPtr(wnd w, int nIndex)
		=> IntPtr.Size == 8 ? GetClassLongPtrW(w, nIndex) : GetClassLongW(w, nIndex);
	
	[DllImport("user32.dll", SetLastError = true)]
	static extern nint SetClassLongW(wnd hWnd, int nIndex, nint dwNewLong);
	
	[DllImport("user32.dll", SetLastError = true)]
	static extern nint SetClassLongPtrW(wnd hWnd, int nIndex, nint dwNewLong);
	
	internal static nint SetClassLongPtr(wnd w, int nIndex, nint dwNewLong)
		=> IntPtr.Size == 8 ? SetClassLongPtrW(w, nIndex, dwNewLong) : SetClassLongW(w, nIndex, dwNewLong);
	
	[DllImport("user32.dll", EntryPoint = "GetClassNameW", SetLastError = true)]
	internal static extern int GetClassName(wnd hWnd, char* lpClassName, int nMaxCount);
	
	[DllImport("user32.dll", EntryPoint = "InternalGetWindowText", SetLastError = true)]
	internal static extern int InternalGetWindowText(wnd hWnd, char* pString, int cchMaxCount);
	
	[DllImport("user32.dll")]
	internal static extern bool IsWindow(wnd hWnd);
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern bool IsWindowVisible(wnd hWnd);
	
	internal const int SW_HIDE = 0;
	internal const int SW_SHOWNORMAL = 1;
	internal const int SW_SHOWMINIMIZED = 2;
	internal const int SW_SHOWMAXIMIZED = 3;
	internal const int SW_SHOWNOACTIVATE = 4; //restores min/max window
	internal const int SW_SHOW = 5;
	internal const int SW_MINIMIZE = 6;
	internal const int SW_SHOWMINNOACTIVE = 7;
	internal const int SW_SHOWNA = 8;
	internal const int SW_RESTORE = 9;
	internal const int SW_SHOWDEFAULT = 10;
	internal const int SW_FORCEMINIMIZE = 11;
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern void ShowWindow(wnd hWnd, int SW_X);
	//note: the return value does not say succeeded/failed.
	//	It is non-zero if was visible, 0 if was hidden.
	//	Declared void to avoid programming errors.
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern bool IsWindowEnabled(wnd hWnd);
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern void EnableWindow(wnd hWnd, bool bEnable);
	//note: the returns value does not say succeeded/failed.
	//	It is non-zero if was disabled, 0 if was enabled.
	//	Declared void to avoid programming errors.
	
	[DllImport("user32.dll", EntryPoint = "FindWindowExW", SetLastError = true)]
	internal static extern wnd _FindWindowEx(wnd hWndParent, wnd hWndChildAfter, string lpszClass, string lpszWindow);
	
	internal static wnd FindWindowEx(wnd wParent = default, wnd wAfter = default, string cn = null, string name = null) {
		//Windows 11 bug: FindWindow[Ex] occasionally returns 0 for an existing window.
		//	Second or third call usually succeeds.
		//	More often fails when there is some activity, eg when Visual Studio compiles/launches an app, or when opening/closing Notepad++.
		//	GetLastError 0.
		//	To reproduce, call every 2 ms, eg to find Notepad by classname.
		//	EnumWindows does not fail.
		//	On Win10 never noticed and cannot reproduce.
		//	Maybe FindWindowEx uses an unsafe loop like with GetWindow. When Z order changes, skips part of windows.
		//	FUTURE: remove this workaround when API fixed. Also in wn::FindWndEx.
		if (osVersion.minWin11) {
			for (int i = 5; --i >= 0;) {
				var w = _FindWindowEx(wParent, wAfter, cn, name);
				if (!w.Is0) return w;
			}
			return default;
		} else {
			return _FindWindowEx(wParent, wAfter, cn, name);
		}
	}
	
	internal struct WNDCLASSEX {
		public int cbSize;
		public uint style;
		public IntPtr lpfnWndProc; //not WNDPROC to avoid auto-marshaling where don't need. Use Marshal.GetFunctionPointerForDelegate/GetDelegateForFunctionPointer.
		public int cbClsExtra;
		public int cbWndExtra;
		public IntPtr hInstance;
		public IntPtr hIcon;
		public IntPtr hCursor;
		public nint hbrBackground;
#pragma warning disable 169
		IntPtr lpszMenuName;
#pragma warning restore 169
		public char* lpszClassName; //not string because CLR would call CoTaskMemFree
		public IntPtr hIconSm;
		
		/// <summary>
		/// If ex <c>null</c>, sets arrow cursor and style <c>CS_VREDRAW | CS_HREDRAW</c>.
		/// </summary>
		public WNDCLASSEX(RWCEtc ex) {
			cbSize = sizeof(WNDCLASSEX);
			if (ex == null) {
				hCursor = LoadCursor(default, MCursor.Arrow);
				style = CS_VREDRAW | CS_HREDRAW;
			} else {
				style = ex.style;
				cbClsExtra = ex.cbClsExtra;
				cbWndExtra = ex.cbWndExtra;
				//hInstance = ex.hInstance;
				hIcon = ex.hIcon;
				if (ex.hCursor != default) hCursor = ex.hCursor; else if (ex.mCursor != default) hCursor = LoadCursor(default, ex.mCursor);
				hbrBackground = ex.hbrBackground;
				hIconSm = ex.hIconSm;
			}
		}
	}
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern ushort RegisterClassEx(in WNDCLASSEX lpwcx);
	
	[DllImport("user32.dll", EntryPoint = "GetClassInfoExW", SetLastError = true)]
	internal static extern ushort GetClassInfoEx(IntPtr hInstance, string lpszClass, ref WNDCLASSEX lpwcx);
	
	[DllImport("user32.dll", EntryPoint = "UnregisterClassW", SetLastError = true)]
	internal static extern bool UnregisterClass(string lpClassName, IntPtr hInstance);
	
	[DllImport("user32.dll", EntryPoint = "UnregisterClassW", SetLastError = true)]
	internal static extern bool UnregisterClass(uint classAtom, IntPtr hInstance);
	
	[DllImport("user32.dll", EntryPoint = "CreateWindowExW", SetLastError = true)]
	internal static extern wnd CreateWindowEx(WSE dwExStyle, string lpClassName, string lpWindowName, WS dwStyle, int x, int y, int nWidth, int nHeight, wnd hWndParent = default, nint hMenu = 0, IntPtr hInstance = default, nint lpParam = 0);
	
	internal const int CW_USEDEFAULT = 1 << 31;
	
	[DllImport("user32.dll", EntryPoint = "DefWindowProcW")]
	internal static extern nint DefWindowProc(wnd hWnd, int msg, nint wParam, nint lParam);
	
	[DllImport("user32.dll", EntryPoint = "CallWindowProcW")]
	internal static extern nint CallWindowProc(nint lpPrevWndFunc, wnd hWnd, int Msg, nint wParam, nint lParam);
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern bool DestroyWindow(wnd hWnd);
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern void PostQuitMessage(int nExitCode);
	
	[DllImport("user32.dll", EntryPoint = "GetMessage", SetLastError = true)]
	internal static extern int _GetMessage(out MSG lpMsg, wnd hWnd, int wMsgFilterMin, int wMsgFilterMax);
	
	internal static bool GetMessage(out MSG m, wnd hWnd = default, int wMsgFilterMin = 0, int wMsgFilterMax = 0) {
		int r = _GetMessage(out m, hWnd, wMsgFilterMin, wMsgFilterMax);
		if (r == -1) throw new Win32Exception();
		return r != 0;
	}
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern bool TranslateMessage(in MSG lpMsg);
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern nint DispatchMessage(in MSG lpmsg);
	
	internal const uint PM_NOREMOVE = 0x0;
	internal const uint PM_REMOVE = 0x1;
	internal const uint PM_NOYIELD = 0x2;
	internal const uint PM_QS_SENDMESSAGE = 0x400000;
	internal const uint PM_QS_POSTMESSAGE = 0x980000;
	internal const uint PM_QS_PAINT = 0x200000;
	internal const uint PM_QS_INPUT = 0x1C070000;
	
	[DllImport("user32.dll", EntryPoint = "PeekMessageW", SetLastError = true)]
	internal static extern bool PeekMessage(out MSG lpMsg, wnd hWnd = default, int wMsgFilterMin = 0, int wMsgFilterMax = 0, uint wRemoveMsg = PM_REMOVE);
	
	[DllImport("user32.dll")]
	internal static extern bool WaitMessage();
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern bool ReplyMessage(nint lResult);
	
	internal const int GA_PARENT = 1;
	internal const int GA_ROOT = 2;
	internal const int GA_ROOTOWNER = 3;
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern wnd GetAncestor(wnd hwnd, uint GA_X);
	
	[DllImport("user32.dll")]
	internal static extern wnd GetForegroundWindow();
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern bool SetForegroundWindow(wnd hWnd);
	
	internal const int ASFW_ANY = -1;
	
#if true
	[DllImport("user32.dll", EntryPoint = "AllowSetForegroundWindow", SetLastError = true)]
	static extern bool _AllowSetForegroundWindow(int dwProcessId);
	
	internal static bool AllowSetForegroundWindow(int dwProcessId = ASFW_ANY) {
		return _AllowSetForegroundWindow(ASFW_ANY);
		//Ignore dwProcessId, because AllowSetForegroundWindow doc says:
		//"The process specified by the dwProcessId parameter loses the ability to set the foreground window the next time that either the user generates input, unless the input is directed at that process, or the next time a process calls AllowSetForegroundWindow, unless the same process is specified as in the previous call to AllowSetForegroundWindow."
		//If it's true (not tested), if we call AllowSetForegroundWindow with a process id, we disable setforegroundwindow in all other processes.
	}
#else
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern bool AllowSetForegroundWindow(int dwProcessId = ASFW_ANY);
#endif
	
	internal const uint LSFW_LOCK = 1;
	internal const uint LSFW_UNLOCK = 2;
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern bool LockSetForegroundWindow(uint LSFW_X);
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern wnd SetFocus(wnd hWnd);
	
	[DllImport("user32.dll")]
	internal static extern wnd GetFocus();
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern wnd SetActiveWindow(wnd hWnd);
	
	[DllImport("user32.dll")]
	internal static extern wnd GetActiveWindow();
	
	internal struct WINDOWPOS {
		public wnd hwnd;
		public wnd hwndInsertAfter;
		public int x;
		public int y;
		public int cx;
		public int cy;
		public SWPFlags flags;
	}
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern bool SetWindowPos(wnd hWnd, wnd hWndInsertAfter, int X, int Y, int cx, int cy, SWPFlags swpFlags);
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern IntPtr BeginDeferWindowPos(int nNumWindows);
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern IntPtr DeferWindowPos(IntPtr hWinPosInfo, wnd hWnd, wnd hWndInsertAfter, int x, int y, int cx, int cy, SWPFlags uFlags);
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern bool EndDeferWindowPos(IntPtr hWinPosInfo);
	
	internal struct FLASHWINFO {
		public int cbSize;
		public wnd hwnd;
		public uint dwFlags;
		public int uCount;
		public int dwTimeout;
	}
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern bool FlashWindowEx(ref FLASHWINFO pfwi);
	
	internal const int GW_OWNER = 4;
	internal const int GW_HWNDPREV = 3;
	internal const int GW_HWNDNEXT = 2;
	internal const int GW_HWNDLAST = 1;
	internal const int GW_HWNDFIRST = 0;
	internal const int GW_ENABLEDPOPUP = 6;
	internal const int GW_CHILD = 5;
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern wnd GetWindow(wnd hWnd, int GW_X);
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern wnd GetTopWindow(wnd hWnd);
	
	//rejected. Obsolete, confusing.
	//	Returns owner for top-level windows with WS_POPUP style.
	//	Returns 0 for child windows without WS_CHILD style, eg message-only windows and QM2 toolbar owners.
	//[DllImport("user32.dll", SetLastError = true)]
	//internal static extern wnd GetParent(wnd hWnd);
	
	[DllImport("user32.dll")]
	internal static extern wnd GetDesktopWindow();
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern wnd GetShellWindow();
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern wnd GetLastActivePopup(wnd hWnd);
	
	[DllImport("user32.dll")]
	internal static extern bool IntersectRect(out RECT lprcDst, in RECT lprcSrc1, in RECT lprcSrc2);
	
	[DllImport("user32.dll")]
	internal static extern bool UnionRect(out RECT lprcDst, in RECT lprcSrc1, in RECT lprcSrc2);
	
	/// <summary>
	/// <c>GetPhysicalCursorPos</c>.
	/// </summary>
	/// <remarks>
	/// Gets DPI physical cursor pos, ie always in pixels.
	/// The classic <c>GetCursorPos</c> API behavior is undefined. Sometimes physical, sometimes logical.
	/// Make sure the process is fully DPI-aware.
	/// </remarks>
	[DllImport("user32.dll", EntryPoint = "GetPhysicalCursorPos", SetLastError = true)]
	internal static extern bool GetCursorPos(out POINT lpPoint);
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern bool SetCursorPos(int X, int Y);
	
	[DllImport("user32.dll", EntryPoint = "LoadImageW", SetLastError = true)]
	internal static extern IntPtr LoadImage(IntPtr hInst, string name, int type, int cx, int cy, uint LR_X);
	[DllImport("user32.dll", EntryPoint = "LoadImageW", SetLastError = true)]
	internal static extern IntPtr LoadImage(IntPtr hInst, nint resId, int type, int cx, int cy, uint LR_X);
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern IntPtr CopyImage(IntPtr h, int type, int cx, int cy, uint flags);
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern bool DestroyIcon(IntPtr hIcon);
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern bool GetWindowRect(wnd hWnd, out RECT lpRect);
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern bool GetClientRect(wnd hWnd, out RECT lpRect);
	
	internal const uint WPF_SETMINPOSITION = 0x1;
	internal const uint WPF_RESTORETOMAXIMIZED = 0x2;
	internal const uint WPF_ASYNCWINDOWPLACEMENT = 0x4;
	
	internal struct WINDOWPLACEMENT {
		public int length;
		/// <summary><c>WPF_x</c></summary>
		public uint flags;
		public int showCmd;
		public POINT ptMinPosition;
		public POINT ptMaxPosition;
		public RECT rcNormalPosition;
	}
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern bool GetWindowPlacement(wnd hWnd, ref WINDOWPLACEMENT lpwndpl);
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern bool SetWindowPlacement(wnd hWnd, in WINDOWPLACEMENT lpwndpl);
	
	internal struct WINDOWINFO {
		public int cbSize;
		public RECT rcWindow;
		public RECT rcClient;
		public WS dwStyle;
		public WSE dwExStyle;
		public uint dwWindowStatus;
		public int cxWindowBorders;
		public int cyWindowBorders;
		public ushort atomWindowType;
		public ushort wCreatorVersion;
	}
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern bool GetWindowInfo(wnd hwnd, ref WINDOWINFO pwi);
	
	//[DllImport("user32.dll", SetLastError = true)]
	//internal static extern bool GetTitleBarInfo(wnd hwnd, ref TITLEBARINFO pti);
	
	//internal struct TITLEBARINFO {
	//	public int cbSize;
	//	public RECT r;
	//	public fixed uint rgstate[6];
	//}
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern bool IsZoomed(wnd hWnd);
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern bool IsIconic(wnd hWnd);
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern int GetWindowThreadProcessId(wnd hWnd, int* lpdwProcessId);
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern bool IsWindowUnicode(wnd hWnd);
	
	[DllImport("user32.dll", EntryPoint = "GetPropW", SetLastError = true)]
	internal static extern nint GetProp(wnd hWnd, string lpString);
	
	[DllImport("user32.dll", EntryPoint = "GetPropW", SetLastError = true)]
	//internal static extern nint GetProp(wnd hWnd, [MarshalAs(UnmanagedType.SysInt)] ushort atom); //exception, must be U2
	internal static extern nint GetProp(wnd hWnd, nint atom);
	
	[DllImport("user32.dll", EntryPoint = "SetPropW", SetLastError = true)]
	internal static extern bool SetProp(wnd hWnd, string lpString, nint hData);
	
	[DllImport("user32.dll", EntryPoint = "SetPropW", SetLastError = true)]
	internal static extern bool SetProp(wnd hWnd, nint atom, nint hData);
	
	[DllImport("user32.dll", EntryPoint = "RemovePropW", SetLastError = true)]
	internal static extern nint RemoveProp(wnd hWnd, string lpString);
	
	[DllImport("user32.dll", EntryPoint = "RemovePropW", SetLastError = true)]
	internal static extern nint RemoveProp(wnd hWnd, nint atom);
	
	internal delegate bool PROPENUMPROCEX(wnd hwnd, IntPtr lpszString, nint hData, nint dwData);
	
	[DllImport("user32.dll", EntryPoint = "EnumPropsExW", SetLastError = true)]
	internal static extern int EnumPropsEx(wnd hWnd, PROPENUMPROCEX lpEnumFunc, nint lParam);
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern wnd GetDlgItem(wnd hDlg, int nIDDlgItem);
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern int GetDlgCtrlID(wnd hWnd);
	
	internal delegate int WNDENUMPROC(wnd w, void* p);
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern bool EnumWindows(WNDENUMPROC lpEnumFunc, void* p = null);
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern bool EnumThreadWindows(int dwThreadId, WNDENUMPROC lpEnumFunc, void* p = null);
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern bool EnumChildWindows(wnd hWndParent, WNDENUMPROC lpEnumFunc, void* p = null);
	
	[DllImport("user32.dll", EntryPoint = "RegisterWindowMessageW", SetLastError = true)]
	internal static extern int RegisterWindowMessage(string lpString);
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern bool IsChild(wnd hWndParent, wnd hWnd);
	
	//rejected. As slow as GetAncestor(GA_PARENT).
	//[DllImport("user32.dll", SetLastError = true), Obsolete("Undocumented API")]
	//internal static extern bool IsTopLevelWindow(wnd hWnd);
	
	[DllImport("user32.dll")]
	internal static extern IntPtr MonitorFromPoint(POINT pt, SODefault dwFlags);
	
	[DllImport("user32.dll")]
	internal static extern IntPtr MonitorFromRect(in RECT lprc, SODefault dwFlags);
	
	[DllImport("user32.dll")]
	internal static extern IntPtr MonitorFromWindow(wnd hwnd, SODefault dwFlags);
	
	internal struct MONITORINFO {
		public int cbSize;
		public RECT rcMonitor;
		public RECT rcWork;
		public uint dwFlags;
	}
	
	[DllImport("user32.dll", EntryPoint = "GetMonitorInfoW")]
	static extern bool _GetMonitorInfo(IntPtr hMonitor, ref MONITORINFO lpmi);
	
	internal static bool GetMonitorInfo(IntPtr hMonitor, out MONITORINFO lpmi) {
		lpmi = new MONITORINFO { cbSize = sizeof(MONITORINFO) };
		return _GetMonitorInfo(hMonitor, ref lpmi);
	}
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern bool EnumDisplayMonitors(nint hdc, RECT* lprcClip, delegate* unmanaged<nint, nint, RECT*, nint*, int> lpfnEnum, nint* a);
	
	#region GetSystemMetrics, SystemParametersInfo
	
	internal const int SM_YVIRTUALSCREEN = 77;
	internal const int SM_XVIRTUALSCREEN = 76;
	internal const int SM_TABLETPC = 86;
	internal const int SM_SWAPBUTTON = 23;
	internal const int SM_STARTER = 88;
	internal const int SM_SLOWMACHINE = 73;
	internal const int SM_SHUTTINGDOWN = 8192;
	internal const int SM_SHOWSOUNDS = 70;
	internal const int SM_SERVERR2 = 89;
	internal const int SM_SECURE = 44;
	internal const int SM_SAMEDISPLAYFORMAT = 81;
	internal const int SM_RESERVED4 = 27;
	internal const int SM_RESERVED3 = 26;
	internal const int SM_RESERVED2 = 25;
	internal const int SM_RESERVED1 = 24;
	internal const int SM_REMOTESESSION = 4096;
	internal const int SM_REMOTECONTROL = 8193;
	internal const int SM_PENWINDOWS = 41;
	internal const int SM_NETWORK = 63;
	internal const int SM_MOUSEWHEELPRESENT = 75;
	internal const int SM_MOUSEPRESENT = 19;
	internal const int SM_MIDEASTENABLED = 74;
	internal const int SM_MENUDROPALIGNMENT = 40;
	internal const int SM_MEDIACENTER = 87;
	internal const int SM_IMMENABLED = 82;
	internal const int SM_DEBUG = 22;
	internal const int SM_DBCSENABLED = 42;
	internal const int SM_CYVTHUMB = 9;
	internal const int SM_CYVSCROLL = 20;
	internal const int SM_CYVIRTUALSCREEN = 79;
	internal const int SM_CYSMSIZE = 53;
	internal const int SM_CYSMICON = 50;
	internal const int SM_CYSMCAPTION = 51;
	internal const int SM_CYSIZEFRAME = SM_CYFRAME;
	internal const int SM_CYSIZE = 31;
	internal const int SM_CYSCREEN = 1;
	internal const int SM_CYMINTRACK = 35;
	internal const int SM_CYMINSPACING = 48;
	internal const int SM_CYMINIMIZED = 58;
	internal const int SM_CYMIN = 29;
	internal const int SM_CYMENUSIZE = 55;
	internal const int SM_CYMENUCHECK = 72;
	internal const int SM_CYMENU = 15;
	internal const int SM_CYMAXTRACK = 60;
	internal const int SM_CYMAXIMIZED = 62;
	internal const int SM_CYKANJIWINDOW = 18;
	internal const int SM_CYICONSPACING = 39;
	internal const int SM_CYICON = 12;
	internal const int SM_CYHSCROLL = 3;
	internal const int SM_CYFULLSCREEN = 17;
	internal const int SM_CYFRAME = 33;
	internal const int SM_CYFOCUSBORDER = 84;
	internal const int SM_CYFIXEDFRAME = SM_CYDLGFRAME;
	internal const int SM_CYEDGE = 46;
	internal const int SM_CYDRAG = 69;
	internal const int SM_CYDOUBLECLK = 37;
	internal const int SM_CYDLGFRAME = 8;
	internal const int SM_CYCURSOR = 14;
	internal const int SM_CYCAPTION = 4;
	internal const int SM_CYBORDER = 6;
	internal const int SM_CXVSCROLL = 2;
	internal const int SM_CXVIRTUALSCREEN = 78;
	internal const int SM_CXSMSIZE = 52;
	internal const int SM_CXSMICON = 49;
	internal const int SM_CXSIZEFRAME = SM_CXFRAME;
	internal const int SM_CXSIZE = 30;
	internal const int SM_CXSCREEN = 0;
	internal const int SM_CXMINTRACK = 34;
	internal const int SM_CXMINSPACING = 47;
	internal const int SM_CXMINIMIZED = 57;
	internal const int SM_CXMIN = 28;
	internal const int SM_CXMENUSIZE = 54;
	internal const int SM_CXMENUCHECK = 71;
	internal const int SM_CXMAXTRACK = 59;
	internal const int SM_CXMAXIMIZED = 61;
	internal const int SM_CXICONSPACING = 38;
	internal const int SM_CXICON = 11;
	internal const int SM_CXHTHUMB = 10;
	internal const int SM_CXHSCROLL = 21;
	internal const int SM_CXFULLSCREEN = 16;
	internal const int SM_CXFRAME = 32;
	internal const int SM_CXFOCUSBORDER = 83;
	internal const int SM_CXFIXEDFRAME = SM_CXDLGFRAME;
	internal const int SM_CXEDGE = 45;
	internal const int SM_CXDRAG = 68;
	internal const int SM_CXDOUBLECLK = 36;
	internal const int SM_CXDLGFRAME = 7;
	internal const int SM_CXCURSOR = 13;
	internal const int SM_CXBORDER = 5;
	internal const int SM_CMOUSEBUTTONS = 43;
	internal const int SM_CMONITORS = 80;
	internal const int SM_CMETRICS = 90;
	internal const int SM_CLEANBOOT = 67;
	internal const int SM_CARETBLINKINGENABLED = 8194;
	internal const int SM_ARRANGE = 56;
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern int GetSystemMetrics(int nIndex);
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern int GetSystemMetricsForDpi(int nIndex, int dpi);
	
	internal const int SPI_SETWORKAREA = 47;
	internal const int SPI_SETWHEELSCROLLLINES = 105;
	internal const int SPI_SETUIEFFECTS = 4159;
	internal const int SPI_SETTOOLTIPFADE = 4121;
	internal const int SPI_SETTOOLTIPANIMATION = 4119;
	internal const int SPI_SETTOGGLEKEYS = 53;
	internal const int SPI_SETSTICKYKEYS = 59;
	internal const int SPI_SETSOUNDSENTRY = 65;
	internal const int SPI_SETSNAPTODEFBUTTON = 96;
	internal const int SPI_SETSHOWSOUNDS = 57;
	internal const int SPI_SETSHOWIMEUI = 111;
	internal const int SPI_SETSERIALKEYS = 63;
	internal const int SPI_SETSELECTIONFADE = 4117;
	internal const int SPI_SETSCREENSAVETIMEOUT = 15;
	internal const int SPI_SETSCREENSAVERRUNNING = 97;
	internal const int SPI_SETSCREENSAVEACTIVE = 17;
	internal const int SPI_SETSCREENREADER = 71;
	internal const int SPI_SETPOWEROFFTIMEOUT = 82;
	internal const int SPI_SETPOWEROFFACTIVE = 86;
	internal const int SPI_SETPENWINDOWS = 49;
	internal const int SPI_SETNONCLIENTMETRICS = 42;
	internal const int SPI_SETMOUSEVANISH = 4129;
	internal const int SPI_SETMOUSETRAILS = 93;
	internal const int SPI_SETMOUSESPEED = 113;
	internal const int SPI_SETMOUSESONAR = 4125;
	internal const int SPI_SETMOUSEKEYS = 55;
	internal const int SPI_SETMOUSEHOVERWIDTH = 99;
	internal const int SPI_SETMOUSEHOVERTIME = 103;
	internal const int SPI_SETMOUSEHOVERHEIGHT = 101;
	internal const int SPI_SETMOUSECLICKLOCKTIME = 8201;
	internal const int SPI_SETMOUSECLICKLOCK = 4127;
	internal const int SPI_SETMOUSEBUTTONSWAP = 33;
	internal const int SPI_SETMOUSE = 4;
	internal const int SPI_SETMINIMIZEDMETRICS = 44;
	internal const int SPI_SETMENUUNDERLINES = SPI_SETKEYBOARDCUES;
	internal const int SPI_SETMENUSHOWDELAY = 107;
	internal const int SPI_SETMENUFADE = 4115;
	internal const int SPI_SETMENUDROPALIGNMENT = 28;
	internal const int SPI_SETMENUANIMATION = 4099;
	internal const int SPI_SETLOWPOWERTIMEOUT = 81;
	internal const int SPI_SETLOWPOWERACTIVE = 85;
	internal const int SPI_SETLISTBOXSMOOTHSCROLLING = 4103;
	internal const int SPI_SETLANGTOGGLE = 91;
	internal const int SPI_SETKEYBOARDSPEED = 11;
	internal const int SPI_SETKEYBOARDPREF = 69;
	internal const int SPI_SETKEYBOARDDELAY = 23;
	internal const int SPI_SETKEYBOARDCUES = 4107;
	internal const int SPI_SETICONTITLEWRAP = 26;
	internal const int SPI_SETICONTITLELOGFONT = 34;
	internal const int SPI_SETICONS = 88;
	internal const int SPI_SETICONMETRICS = 46;
	internal const int SPI_SETHOTTRACKING = 4111;
	internal const int SPI_SETHIGHCONTRAST = 67;
	internal const int SPI_SETHANDHELD = 78;
	internal const int SPI_SETGRIDGRANULARITY = 19;
	internal const int SPI_SETGRADIENTCAPTIONS = 4105;
	internal const int SPI_SETFOREGROUNDLOCKTIMEOUT = 8193;
	internal const int SPI_SETFOREGROUNDFLASHCOUNT = 8197;
	internal const int SPI_SETFONTSMOOTHINGTYPE = 8203;
	internal const int SPI_SETFONTSMOOTHINGORIENTATION = 8211;
	internal const int SPI_SETFONTSMOOTHINGCONTRAST = 8205;
	internal const int SPI_SETFONTSMOOTHING = 75;
	internal const int SPI_SETFOCUSBORDERWIDTH = 8207;
	internal const int SPI_SETFOCUSBORDERHEIGHT = 8209;
	internal const int SPI_SETFLATMENU = 4131;
	internal const int SPI_SETFILTERKEYS = 51;
	internal const int SPI_SETFASTTASKSWITCH = 36;
	internal const int SPI_SETDROPSHADOW = 4133;
	internal const int SPI_SETDRAGWIDTH = 76;
	internal const int SPI_SETDRAGHEIGHT = 77;
	internal const int SPI_SETDRAGFULLWINDOWS = 37;
	internal const int SPI_SETDOUBLECLKWIDTH = 29;
	internal const int SPI_SETDOUBLECLKHEIGHT = 30;
	internal const int SPI_SETDOUBLECLICKTIME = 32;
	internal const int SPI_SETDESKWALLPAPER = 20;
	internal const int SPI_SETDESKPATTERN = 21;
	internal const int SPI_SETDEFAULTINPUTLANG = 90;
	internal const int SPI_SETCURSORSHADOW = 4123;
	internal const int SPI_SETCURSORS = 87;
	internal const int SPI_SETCOMBOBOXANIMATION = 4101;
	internal const int SPI_SETCARETWIDTH = 8199;
	internal const int SPI_SETBORDER = 6;
	internal const int SPI_SETBLOCKSENDINPUTRESETS = 4135;
	internal const int SPI_SETBEEP = 2;
	internal const int SPI_SETANIMATION = 73;
	internal const int SPI_SETACTIVEWNDTRKZORDER = 4109;
	internal const int SPI_SETACTIVEWNDTRKTIMEOUT = 8195;
	internal const int SPI_SETACTIVEWINDOWTRACKING = 4097;
	internal const int SPI_SETACCESSTIMEOUT = 61;
	internal const int SPI_LANGDRIVER = 12;
	internal const int SPI_ICONVERTICALSPACING = 24;
	internal const int SPI_ICONHORIZONTALSPACING = 13;
	internal const int SPI_GETWORKAREA = 48;
	internal const int SPI_GETWINDOWSEXTENSION = 92;
	internal const int SPI_GETWHEELSCROLLLINES = 104;
	internal const int SPI_GETUIEFFECTS = 4158;
	internal const int SPI_GETTOOLTIPFADE = 4120;
	internal const int SPI_GETTOOLTIPANIMATION = 4118;
	internal const int SPI_GETTOGGLEKEYS = 52;
	internal const int SPI_GETSTICKYKEYS = 58;
	internal const int SPI_GETSOUNDSENTRY = 64;
	internal const int SPI_GETSNAPTODEFBUTTON = 95;
	internal const int SPI_GETSHOWSOUNDS = 56;
	internal const int SPI_GETSHOWIMEUI = 110;
	internal const int SPI_GETSERIALKEYS = 62;
	internal const int SPI_GETSELECTIONFADE = 4116;
	internal const int SPI_GETSCREENSAVETIMEOUT = 14;
	internal const int SPI_GETSCREENSAVERRUNNING = 114;
	internal const int SPI_GETSCREENSAVEACTIVE = 16;
	internal const int SPI_GETSCREENREADER = 70;
	internal const int SPI_GETPOWEROFFTIMEOUT = 80;
	internal const int SPI_GETPOWEROFFACTIVE = 84;
	internal const int SPI_GETNONCLIENTMETRICS = 41;
	internal const int SPI_GETMOUSEVANISH = 4128;
	internal const int SPI_GETMOUSETRAILS = 94;
	internal const int SPI_GETMOUSESPEED = 112;
	internal const int SPI_GETMOUSESONAR = 4124;
	internal const int SPI_GETMOUSEKEYS = 54;
	internal const int SPI_GETMOUSEHOVERWIDTH = 98;
	internal const int SPI_GETMOUSEHOVERTIME = 102;
	internal const int SPI_GETMOUSEHOVERHEIGHT = 100;
	internal const int SPI_GETMOUSECLICKLOCKTIME = 8200;
	internal const int SPI_GETMOUSECLICKLOCK = 4126;
	internal const int SPI_GETMOUSE = 3;
	internal const int SPI_GETMINIMIZEDMETRICS = 43;
	internal const int SPI_GETMENUUNDERLINES = SPI_GETKEYBOARDCUES;
	internal const int SPI_GETMENUSHOWDELAY = 106;
	internal const int SPI_GETMENUFADE = 4114;
	internal const int SPI_GETMENUDROPALIGNMENT = 27;
	internal const int SPI_GETMENUANIMATION = 4098;
	internal const int SPI_GETLOWPOWERTIMEOUT = 79;
	internal const int SPI_GETLOWPOWERACTIVE = 83;
	internal const int SPI_GETLISTBOXSMOOTHSCROLLING = 4102;
	internal const int SPI_GETKEYBOARDSPEED = 10;
	internal const int SPI_GETKEYBOARDPREF = 68;
	internal const int SPI_GETKEYBOARDDELAY = 22;
	internal const int SPI_GETKEYBOARDCUES = 4106;
	internal const int SPI_GETICONTITLEWRAP = 25;
	internal const int SPI_GETICONTITLELOGFONT = 31;
	internal const int SPI_GETICONMETRICS = 45;
	internal const int SPI_GETHOTTRACKING = 4110;
	internal const int SPI_GETHIGHCONTRAST = 66;
	internal const int SPI_GETGRIDGRANULARITY = 18;
	internal const int SPI_GETGRADIENTCAPTIONS = 4104;
	internal const int SPI_GETFOREGROUNDLOCKTIMEOUT = 8192;
	internal const int SPI_GETFOREGROUNDFLASHCOUNT = 8196;
	internal const int SPI_GETFONTSMOOTHINGTYPE = 8202;
	internal const int SPI_GETFONTSMOOTHINGORIENTATION = 8210;
	internal const int SPI_GETFONTSMOOTHINGCONTRAST = 8204;
	internal const int SPI_GETFONTSMOOTHING = 74;
	internal const int SPI_GETFOCUSBORDERWIDTH = 8206;
	internal const int SPI_GETFOCUSBORDERHEIGHT = 8208;
	internal const int SPI_GETFLATMENU = 4130;
	internal const int SPI_GETFILTERKEYS = 50;
	internal const int SPI_GETFASTTASKSWITCH = 35;
	internal const int SPI_GETDROPSHADOW = 4132;
	internal const int SPI_GETDRAGFULLWINDOWS = 38;
	internal const int SPI_GETDESKWALLPAPER = 115;
	internal const int SPI_GETDEFAULTINPUTLANG = 89;
	internal const int SPI_GETCURSORSHADOW = 4122;
	internal const int SPI_GETCOMBOBOXANIMATION = 4100;
	internal const int SPI_GETCARETWIDTH = 8198;
	internal const int SPI_GETBORDER = 5;
	internal const int SPI_GETBLOCKSENDINPUTRESETS = 4134;
	internal const int SPI_GETBEEP = 1;
	internal const int SPI_GETANIMATION = 72;
	internal const int SPI_GETACTIVEWNDTRKZORDER = 4108;
	internal const int SPI_GETACTIVEWNDTRKTIMEOUT = 8194;
	internal const int SPI_GETACTIVEWINDOWTRACKING = 4096;
	internal const int SPI_GETACCESSTIMEOUT = 60;
	internal const int SPI_GETMOUSEWHEELROUTING = 0x201C;
	
	internal const uint SPIF_UPDATEINIFILE = 0x1;
	internal const uint SPIF_SENDCHANGE = 0x2;
	
	/// <summary>
	/// Gets or sets any value. This is the direct API call.
	/// </summary>
	[DllImport("user32.dll", EntryPoint = "SystemParametersInfoW", SetLastError = true)]
	internal static extern bool SystemParametersInfo(uint uiAction, int uiParam, void* pvParam, uint fWinIni = 0);
	
	/// <summary>
	/// Gets 32-bit integer value. Returns <i>def</i> if failed.
	/// </summary>
	internal static int SystemParametersInfo(uint uiAction, int def) {
		int r = 0;
		return SystemParametersInfo(uiAction, 0, &r) ? r : def;
	}
	
	/// <summary>
	/// Gets <c>BOOL</c> value. Returns <c>false</c> if failed.
	/// </summary>
	internal static bool SystemParametersInfo(uint uiAction) {
		int r = 0;
		return SystemParametersInfo(uiAction, 0, &r) && r != 0;
	}
	
	//internal static bool SystemParametersInfo<T>(uint uiAction, ref T pvParam) where T : unmanaged {
	//	fixed (T* p = &pvParam) return SystemParametersInfo(uiAction, sizeof(T), p, 0);
	//}
	
	/// <summary>
	/// Sets value.
	/// </summary>
	internal static bool SystemParametersInfo(uint uiAction, int uiParam, void* pvParam, bool save, bool notify) {
		uint f = 0;
		if (save) f |= 1; //SPIF_UPDATEINIFILE
		if (notify) f |= 2; //SPIF_SENDCHANGE
		return SystemParametersInfo(uiAction, uiParam, pvParam, f);
	}
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern bool SystemParametersInfoForDpi(uint uiAction, int uiParam, void* pvParam, uint fWinIni, int dpi);
	
	#endregion
	
	/// <summary>
	/// <c>WindowFromPhysicalPoint</c>. On Win8.1+ it is the same as <c>WindowFromPoint</c>.
	/// </summary>
	[DllImport("user32.dll", EntryPoint = "WindowFromPhysicalPoint")]
	internal static extern wnd WindowFromPoint(POINT pt);
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern bool ScreenToClient(wnd hWnd, ref POINT lpPoint);
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern bool ClientToScreen(wnd hWnd, ref POINT lpPoint);
	
	//internal static bool ClientToScreenIgnoreRtl(wnd w, ref POINT p)
	//{
	//	if(!w.HasExStyle(WSE.LAYOUTRTL)) return ClientToScreen(w, ref p);
	//	if(!GetClientRect(w, out var r) || !MapWindowPoints(w, default, ref r, out _)) return false;
	//	p.Offset(r.left, r.top);
	//	return true;
	//}
	
	[DllImport("user32.dll", SetLastError = true)]
	static extern int MapWindowPoints(wnd hWndFrom, wnd hWndTo, void* lpPoints, int cPoints);
	
	internal static bool MapWindowPoints(wnd wFrom, wnd wTo, void* points, int cPoints, out int ret) {
		lastError.clear();
		ret = MapWindowPoints(wFrom, wTo, points, cPoints);
		return ret != 0 ? true : lastError.code == 0;
	}
	
	internal static bool MapWindowPoints(wnd wFrom, wnd wTo, ref RECT r, out int ret) {
		fixed (void* u = &r) return MapWindowPoints(wFrom, wTo, u, 2, out ret);
	}
	
	internal static bool MapWindowPoints(wnd wFrom, wnd wTo, ref POINT p, out int ret) {
		fixed (void* u = &p) return MapWindowPoints(wFrom, wTo, u, 1, out ret);
	}
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern bool GetGUIThreadInfo(int idThread, ref GUITHREADINFO pgui);
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern bool AttachThreadInput(int idAttach, int idAttachTo, bool fAttach);
	
	internal const uint KEYEVENTF_EXTENDEDKEY = 0x1;
	internal const uint KEYEVENTF_KEYUP = 0x2;
	internal const uint KEYEVENTF_UNICODE = 0x4;
	internal const uint KEYEVENTF_SCANCODE = 0x8;
	
	internal struct INPUTK {
		nint _type;
		public ushort wVk;
		public ushort wScan;
		public uint dwFlags;
		public int time;
		public nint dwExtraInfo;
#pragma warning disable 414 //never used
		int _u1, _u2; //need INPUT size
#pragma warning restore 414
		
		public INPUTK(KKey vk, ushort sc, uint flags = 0) {
			_type = INPUT_KEYBOARD; dwExtraInfo = AuExtraInfo;
			wVk = (ushort)vk; wScan = sc; dwFlags = flags;
			time = 0; _u2 = _u1 = 0;
			Debug.Assert(sizeof(INPUTK) == sizeof(INPUTM));
		}
		
		public void Set(KKey vk, ushort sc, uint flags = 0) {
			_type = INPUT_KEYBOARD; dwExtraInfo = AuExtraInfo;
			wVk = (ushort)vk; wScan = sc; dwFlags = flags;
		}
		
		//public void InitCommonFields()
		//{
		//	_type = INPUT_KEYBOARD; dwExtraInfo = AuExtraInfo;
		//}
		
		const int INPUT_KEYBOARD = 1;
	}
	
	[Flags]
	internal enum IMFlags : uint {
		Move = 1,
		LeftDown = 2, LeftUp = 4,
		RightDown = 8, RightUp = 16,
		MiddleDown = 32, MiddleUp = 64,
		XDown = 0x80, XUp = 0x100,
		Wheel = 0x0800, HWheel = 0x01000,
		NoCoalesce = 0x2000,
		VirtualdDesktop = 0x4000,
		Absolute = 0x8000,
		//not API
		X1 = 0x1000000,
		X2 = 0x2000000,
	};
	
	internal struct INPUTM {
		nint _type;
		public int dx;
		public int dy;
		public int mouseData;
		public IMFlags dwFlags;
		public int time;
		public nint dwExtraInfo;
		
		public INPUTM(IMFlags flags, int x = 0, int y = 0, int data = 0) {
			_type = INPUT_MOUSE;
			dx = x; dy = y; dwFlags = flags; mouseData = data;
			time = 0; dwExtraInfo = AuExtraInfo;
		}
		
		const int INPUT_MOUSE = 0;
	}
	
	/// <summary>
	/// Extra info value of key and mouse events sent by functions of this library.
	/// </summary>
	internal const int AuExtraInfo = 0x71427fa5;
	
	[DllImport("user32.dll", SetLastError = true)]
	static extern int SendInput(int cInputs, void* pInputs, int cbSize);
	//tested: Returns 0 when: invalid argument; other desktop active.
	//	Does not return 0 when: UAC (documented); BlockInput; ClipCursor.
	
	/// <exception cref="InputDesktopException"></exception>
	internal static void SendInput(INPUTK* ip, int n = 1, bool dontThrow = false) {
		if (n != SendInput(n, ip, sizeof(INPUTK))) {
			if (!dontThrow) InputDesktopException.ThrowIfBadDesktop("*send keyboard input.");
			//tested: if bad input desktop, GetLastError returns 'access denied'.
			
			//throw new AuException("*send keyboard input."); //rejected. Anyway in most cases cannot detect when fails (because API returns not 0).
			Debug_.Print($"SendInput(key) failed. {lastError.message}");
		}
	}
	
	/// <exception cref="InputDesktopException"></exception>
	internal static void SendInput(INPUTM* ip, int n = 1, bool dontThrow = false) {
		if (n != SendInput(n, ip, sizeof(INPUTM))) {
			if (!dontThrow) InputDesktopException.ThrowIfBadDesktop("*send mouse input.");
			
			//throw new AuException("*send mouse input.");
			Debug_.Print($"SendInput(mouse) failed. {lastError.message}");
		}
	}
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern bool IsHungAppWindow(wnd hwnd);
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern bool SetLayeredWindowAttributes(wnd hwnd, uint crKey, byte bAlpha, uint dwFlags);
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern bool GetLayeredWindowAttributes(wnd hwnd, out uint pcrKey, out byte pbAlpha, out uint pdwFlags);
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern IntPtr CreateIcon(IntPtr hInstance, int nWidth, int nHeight, byte cPlanes, byte cBitsPixel, byte[] lpbANDbits, byte[] lpbXORbits);
	
	[DllImport("user32.dll", EntryPoint = "LoadCursorW", SetLastError = true)]
	internal static extern IntPtr LoadCursor(IntPtr hInstance, MCursor cursorId);
	
	internal delegate void TIMERPROC(wnd param1, int param2, nint param3, uint param4);
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern nint SetTimer(wnd hWnd, nint nIDEvent, int uElapse, TIMERPROC lpTimerFunc);
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern bool KillTimer(wnd hWnd, nint uIDEvent);
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern wnd SetParent(wnd hWndChild, wnd hWndNewParent);
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern bool AdjustWindowRectEx(ref RECT lpRect, WS dwStyle, bool bMenu, WSE dwExStyle);
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern bool AdjustWindowRectExForDpi(ref RECT lpRect, WS dwStyle, bool bMenu, WSE dwExStyle, int dpi);
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern bool ChangeWindowMessageFilter(int message, uint dwFlag);
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern short GetKeyState(int nVirtKey); //not KKey because it is :byte
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern short GetAsyncKeyState(int vKey); //not KKey because it is :byte
	
	internal const uint MOD_ALT = 0x1;
	internal const uint MOD_CONTROL = 0x2;
	internal const uint MOD_SHIFT = 0x4;
	internal const uint MOD_WIN = 0x8;
	internal const uint MOD_NOREPEAT = 0x4000;
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern bool RegisterHotKey(wnd hWnd, int id, uint fsModifiers, KKey vk);
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern bool UnregisterHotKey(wnd hWnd, int id);
	
	internal const uint MWMO_WAITALL = 0x1;
	internal const uint MWMO_ALERTABLE = 0x2;
	internal const uint MWMO_INPUTAVAILABLE = 0x4;
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern int MsgWaitForMultipleObjectsEx(int nCount, IntPtr* pHandles, int dwMilliseconds, uint dwWakeMask, uint MWMO_Flags);
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern bool InvalidateRect(wnd hWnd, RECT* lpRect, bool bErase);
	internal static bool InvalidateRect(wnd hWnd, bool bErase = false) => InvalidateRect(hWnd, null, bErase);
	internal static bool InvalidateRect(wnd hWnd, RECT r, bool bErase = false) => InvalidateRect(hWnd, &r, bErase);
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern bool ValidateRect(wnd hWnd, RECT* lpRect);
	internal static bool ValidateRect(wnd hWnd) => ValidateRect(hWnd, null);
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern bool GetUpdateRect(wnd hWnd, out RECT lpRect, bool bErase);
	
	internal const int ERROR = 0;
	internal const int NULLREGION = 1;
	internal const int SIMPLEREGION = 2;
	internal const int COMPLEXREGION = 3;
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern int GetUpdateRgn(wnd hWnd, IntPtr hRgn, bool bErase);
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern bool InvalidateRgn(wnd hWnd, IntPtr hRgn, bool bErase);
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern bool DragDetect(wnd hwnd, POINT pt);
	
	[DllImport("user32.dll")]
	internal static extern IntPtr GetCursor();
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern IntPtr SetCursor(IntPtr hCursor);
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern wnd SetCapture(wnd hWnd);
	
	[DllImport("user32.dll")]
	internal static extern wnd GetCapture();
	
	[DllImport("user32.dll")]
	internal static extern bool ReleaseCapture();
	
	//[DllImport("user32.dll", EntryPoint = "CharLowerBuffW")]
	//internal static unsafe extern int CharLowerBuff(char* lpsz, int cchLength);
	
	//[DllImport("user32.dll", CallingConvention = CallingConvention.Cdecl)]
	//internal static extern int wsprintfW(char* lpOut1024, string lpFmt, __arglist);
	//note: with __arglist always returns 0. Could instead use void*, but then much work to properly pack arguments.
	
	//tested speed (time %) of various formatting functions, with two int and one string arg, with converting to string:
	//	StringBuilder.Append + int.ToString(CultureInfo.InvariantCulture): 85% - FASTEST
	//	StringBuilder.Append: 100%
	//	StringBuilder.AppendFormat + int.ToString() (avoid int boxing): 140%
	//	StringBuilder.AppendFormat: 150%
	//	$"{var} string": 160% (probably uses StringBuilder)
	//	wsprintfW (user32.dll): 150%
	//	_snwprintf (msvcrt.dll): 500% - SLOWEST
	
	[DllImport("user32.dll", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
	internal static extern int wsprintfA(byte* lpOut1024, string lpFmt, __arglist);
	
	[DllImport("user32.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern int wsprintfW(char* lpOut1024, string lpFmt, __arglist);
	
	internal struct PAINTSTRUCT {
		public IntPtr hdc;
		public bool fErase;
		public RECT rcPaint;
		public bool fRestore;
		public bool fIncUpdate;
		fixed byte rgbReserved[32];
	}
	
	[DllImport("user32.dll")]
	internal static extern IntPtr BeginPaint(wnd hWnd, out PAINTSTRUCT lpPaint);
	
	[DllImport("user32.dll")]
	internal static extern bool EndPaint(wnd hWnd, in PAINTSTRUCT lpPaint);
	
	[DllImport("user32.dll")]
	internal static extern bool UpdateWindow(wnd hWnd);
	
	[DllImport("user32.dll")]
	internal static extern nint GetKeyboardLayout(int idThread);
	
	[DllImport("user32.dll", EntryPoint = "MapVirtualKeyExW")]
	internal static extern uint MapVirtualKeyEx(uint uCode, uint uMapType, nint dwhkl);
	
	[DllImport("user32.dll", EntryPoint = "VkKeyScanExW")]
	internal static extern short VkKeyScanEx(char ch, nint dwhkl);
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern bool OpenClipboard(wnd hWndNewOwner);
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern bool CloseClipboard();
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern bool EmptyClipboard();
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern IntPtr SetClipboardData(int uFormat, IntPtr hMem);
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern IntPtr GetClipboardData(int uFormat);
	
	//[DllImport("user32.dll", SetLastError = true)]
	//internal static extern wnd SetClipboardViewer(wnd hWndNewViewer);
	
	//[DllImport("user32.dll")]
	//internal static extern bool ChangeClipboardChain(wnd hWndRemove, wnd hWndNewNext);
	
	[DllImport("user32.dll")]
	internal static extern wnd GetOpenClipboardWindow();
	
	[DllImport("user32.dll")]
	internal static extern uint GetClipboardSequenceNumber();
	
	[DllImport("user32.dll", EntryPoint = "RegisterClipboardFormatW")]
	internal static extern int RegisterClipboardFormat(string lpszFormat);
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern bool AddClipboardFormatListener(wnd hwnd);
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern bool RemoveClipboardFormatListener(wnd hwnd);
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern int EnumClipboardFormats(int format);
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern bool IsClipboardFormatAvailable(int format);
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern int GetPriorityClipboardFormat(int[] paFormatPriorityList, int cFormats);
	
	[DllImport("user32.dll", EntryPoint = "GetClipboardFormatNameW", SetLastError = true)]
	internal static unsafe extern int GetClipboardFormatName(int format, char* lpszFormatName, int cchMaxCount);
	
	[DllImport("user32.dll")]
	internal static extern int GetDoubleClickTime();
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern bool DrawIconEx(IntPtr hdc, int xLeft, int yTop, IntPtr hIcon, int cxWidth, int cyWidth, int istepIfAniCur = 0, IntPtr hbrFlickerFreeDraw = default, uint diFlags = 3); //DI_NORMAL
	
	internal const uint CURSOR_SHOWING = 0x1;
	
	internal struct CURSORINFO {
		public int cbSize;
		public uint flags;
		public IntPtr hCursor;
		public POINT ptScreenPos;
	}
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern bool GetCursorInfo(ref CURSORINFO pci);
	
	internal struct ICONINFO : IDisposable {
		public bool fIcon;
		public int xHotspot;
		public int yHotspot;
		public IntPtr hbmMask;
		public IntPtr hbmColor;
		
		public ICONINFO(IntPtr hIcon) {
			GetIconInfo(hIcon, out this);
			//never mind if failed. Then hbm members are default, and caller can either check it or simply let other API fail.
		}
		
		public void Dispose() {
			if (hbmMask != default) DeleteObject(hbmMask);
			if (hbmColor != default) DeleteObject(hbmColor);
		}
	}
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern bool GetIconInfo(IntPtr hIcon, out ICONINFO piconinfo);
	//tested: GetIconInfoEx gets resource info only for icons loaded from a module loaded in this process.
	
	internal struct BITMAP {
		public int bmType;
		public int bmWidth;
		public int bmHeight;
		public int bmWidthBytes;
		public ushort bmPlanes;
		public ushort bmBitsPixel;
		public IntPtr bmBits;
	}
	
	internal const int WH_MSGFILTER = -1;
	internal const int WH_KEYBOARD = 2;
	internal const int WH_GETMESSAGE = 3;
	internal const int WH_CALLWNDPROC = 4;
	internal const int WH_CBT = 5;
	//internal const int WH_SYSMSGFILTER = 6; //hook proc must be in dll
	internal const int WH_MOUSE = 7;
	internal const int WH_DEBUG = 9;
	internal const int WH_SHELL = 10;
	internal const int WH_FOREGROUNDIDLE = 11;
	internal const int WH_CALLWNDPROCRET = 12;
	internal const int WH_KEYBOARD_LL = 13;
	internal const int WH_MOUSE_LL = 14;
	
	internal delegate nint HOOKPROC(int code, nint wParam, nint lParam);
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern IntPtr SetWindowsHookEx(int WH_X, HOOKPROC lpfn, IntPtr hMod, int dwThreadId);
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern bool UnhookWindowsHookEx(IntPtr hhk);
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern nint CallNextHookEx(IntPtr hhk, int nCode, nint wParam, nint lParam);
	
	internal const uint LLKHF_EXTENDED = 0x1;
	internal const uint LLKHF_INJECTED = 0x10;
	internal const uint LLKHF_ALTDOWN = 0x20;
	internal const uint LLKHF_UP = 0x80;
	
	internal struct KBDLLHOOKSTRUCT {
		public uint vkCode;
		public uint scanCode;
		public uint flags;
		public int time;
		public nint dwExtraInfo;
		
		public bool IsUp => 0 != (flags & LLKHF_UP);
		
		/// <summary>
		/// <c>true</c> if the event was generated by software.
		/// </summary>
		public bool IsInjected => 0 != (flags & LLKHF_INJECTED);
		
		/// <summary>
		/// <c>true</c> if the event was generated by functions of this library.
		/// </summary>
		public bool IsInjectedByAu => 0 != (flags & LLKHF_INJECTED) && dwExtraInfo == AuExtraInfo;
		//CONSIDER: also add IsInjectedByAuOrQM2. And let QM2 recognize the extra info too. Or let they use the same extra info; probably bad idea.
		
		/// <summary>
		/// The <c>set</c> function adds or removes flag 0x80000000.
		/// The <c>get</c> function returns <c>true</c> if flag 0x80000000 is set.
		/// </summary>
		public bool BlockEvent {
			get => 0 != (flags & 0x80000000);
			set { if (value) flags |= 0x80000000; else flags &= ~0x80000000; }
		}
	}
	
	internal const uint LLMHF_INJECTED = 0x1;
	
	internal struct MSLLHOOKSTRUCT {
		public POINT pt;
		public uint mouseData;
		public uint flags;
		public int time;
		public nint dwExtraInfo;
		
		/// <summary>
		/// <c>true</c> if the event was generated by software.
		/// </summary>
		public bool IsInjected => 0 != (flags & LLMHF_INJECTED);
		
		/// <summary>
		/// <c>true</c> if the event was generated by functions of this library.
		/// </summary>
		public bool IsInjectedByAu => 0 != (flags & LLMHF_INJECTED) && dwExtraInfo == AuExtraInfo;
		
		/// <summary>
		/// The <c>set</c> function adds or removes flag 0x80000000.
		/// The <c>get</c> function returns <c>true</c> if flag 0x80000000 is set.
		/// </summary>
		public bool BlockEvent {
			get => 0 != (flags & 0x80000000);
			set { if (value) flags |= 0x80000000; else flags &= ~0x80000000; }
		}
	}
	
	internal const int HC_NOREMOVE = 3;
	
	internal delegate void WINEVENTPROC(IntPtr hWinEventHook, EEvent event_, wnd hwnd, EObjid idObject, int idChild, int idEventThread, int dwmsEventTime);
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern IntPtr SetWinEventHook(EEvent eventMin, EEvent eventMax, IntPtr hmodWinEventProc, WINEVENTPROC pfnWinEventProc, int idProcess, int idThread, EHookFlags dwFlags);
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern bool UnhookWinEvent(IntPtr hWinEventHook);
	
	[Flags]
	internal enum AnimationFlags : uint {
		Roll = 0x0000, // Uses a roll animation.
		HorizontalPositive = 0x00001, // Animates the window from left to right. This flag can be used with roll or slide animation.
		HorizontalNegative = 0x00002, // Animates the window from right to left. This flag can be used with roll or slide animation.
		VerticalPositive = 0x00004, // Animates the window from top to bottom. This flag can be used with roll or slide animation.
		VerticalNegative = 0x00008, // Animates the window from bottom to top. This flag can be used with roll or slide animation.
		Center = 0x00010, // Makes the window appear to collapse inward if Hide is used or expand outward if the Hide is not used.
		Hide = 0x10000, // Hides the window. By default, the window is shown.
		Activate = 0x20000, // Activates the window.
		Slide = 0x40000, // Uses a slide animation. By default, roll animation is used.
		Blend = 0x80000, // Uses a fade effect. This flag can be used only with a top-level window.
		Mask = 0xfffff,
	}
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern bool AnimateWindow(wnd hWnd, int dwTime, AnimationFlags dwFlags);
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern bool GetCaretPos(out POINT lpPoint);
	
	internal static bool GetCaretPosInScreen_(out POINT p) => GetCaretPos(out p) && GetFocus().MapClientToScreen(ref p);
	
	[DllImport("user32.dll")]
	internal static extern int ToUnicodeEx(uint wVirtKey, uint wScanCode, byte* lpKeyState, char* pwszBuff, int cchBuff, uint wFlags, IntPtr dwhkl);
	
	internal const uint PW_CLIENTONLY = 0x1;
	internal const uint PW_RENDERFULLCONTENT = 0x2;
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern bool PrintWindow(wnd hwnd, IntPtr hdcBlt, uint nFlags);
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern IntPtr GetDC(wnd hWnd);
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern IntPtr GetWindowDC(wnd hWnd);
	
	[DllImport("user32.dll")] //note: no SetLastError = true
	internal static extern int ReleaseDC(wnd hWnd, IntPtr hDC);
	
	[DllImport("user32.dll")]
	internal static extern int FillRect(IntPtr hDC, in RECT lprc, nint hbr);
	
	[DllImport("user32.dll")]
	internal static extern int FrameRect(IntPtr hDC, in RECT lprc, IntPtr hbr);
	
	internal const uint RDW_INVALIDATE = 0x1;
	internal const uint RDW_ERASE = 0x4;
	internal const uint RDW_ALLCHILDREN = 0x80;
	internal const uint RDW_FRAME = 0x400;
	
	[DllImport("user32.dll")]
	internal static extern bool RedrawWindow(wnd hWnd, RECT* lprcUpdate = null, IntPtr hrgnUpdate = default, uint flags = 0);
	
	/// <param name="flags"><c>Au.Controls.PopupAlignment</c></param>
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern bool CalculatePopupWindowPosition(in POINT anchorPoint, in SIZE windowSize, uint flags, in RECT excludeRect, out RECT popupWindowPosition);
	
	[DllImport("user32.dll")]
	internal static extern int MenuItemFromPoint(wnd hWnd, IntPtr hMenu, POINT ptScreen);
	
	[DllImport("user32.dll")]
	internal static extern int GetMenuItemID(IntPtr hMenu, int nPos);
	
	internal struct MENUITEMINFO {
		public int cbSize;
		public uint fMask;
		public uint fType;
		public uint fState;
		public int wID;
		public IntPtr hSubMenu;
		public IntPtr hbmpChecked;
		public IntPtr hbmpUnchecked;
		public nint dwItemData;
		public char* dwTypeData;
		public int cch;
		public IntPtr hbmpItem;
		
		public MENUITEMINFO(uint miim) {
			cbSize = sizeof(MENUITEMINFO);
			fMask = miim;
		}
	}
	
	[DllImport("user32.dll", EntryPoint = "GetMenuItemInfoW")]
	internal static extern bool GetMenuItemInfo(IntPtr hmenu, int item, bool fByPosition, ref MENUITEMINFO lpmii);
	
	internal const uint MIIM_STRING = 0x40;
	
	[DllImport("user32.dll")]
	internal static extern IntPtr GetSystemMenu(wnd hWnd, bool bRevert);
	
	[DllImport("user32.dll")]
	internal static extern bool EnableMenuItem(IntPtr hMenu, uint uIDEnableItem, uint uEnable);
	
	internal const uint MF_GRAYED = 0x1;
	
	internal const uint SIF_RANGE = 0x1;
	internal const uint SIF_PAGE = 0x2;
	internal const uint SIF_POS = 0x4;
	internal const uint SIF_TRACKPOS = 0x10;
	internal const int SB_LINEUP = 0;
	//internal const int SB_LINELEFT = 0;
	internal const int SB_LINEDOWN = 1;
	//internal const int SB_LINERIGHT = 1;
	internal const int SB_PAGEUP = 2;
	//internal const int SB_PAGELEFT = 2;
	internal const int SB_PAGEDOWN = 3;
	//internal const int SB_PAGERIGHT = 3;
	//internal const int SB_THUMBPOSITION = 4;
	internal const int SB_THUMBTRACK = 5;
	internal const int SB_TOP = 6;
	//internal const int SB_LEFT = 6;
	internal const int SB_BOTTOM = 7;
	//internal const int SB_RIGHT = 7;
	//internal const int SB_ENDSCROLL = 8;
	internal const int SB_HORZ = 0;
	internal const int SB_VERT = 1;
	//internal const int SB_CTL = 2;
	internal const int SB_BOTH = 3;
	
	internal struct SCROLLINFO {
		public int cbSize;
		public uint fMask;
		public int nMin;
		public int nMax;
		public int nPage;
		public int nPos;
		public int nTrackPos;
		
		public SCROLLINFO(uint mask) {
			cbSize = sizeof(SCROLLINFO);
			fMask = mask;
		}
		
		public int Set(wnd w, bool vertical, bool redraw = true)
			=> SetScrollInfo(w, vertical ? SB_VERT : SB_HORZ, this, redraw);
		
		public bool Get(wnd w, bool vertical)
			=> GetScrollInfo(w, vertical ? SB_VERT : SB_HORZ, ref this);
		
		public static SCROLLINFO Get(wnd w, bool vertical, uint mask) {
			SCROLLINFO v = new(mask);
			v.Get(w, vertical);
			return v;
		}
		
		public static int GetTrackPos(wnd w, bool vertical) => Get(w, vertical, SIF_TRACKPOS).nTrackPos;
		
		public static void SetPos(wnd w, bool vertical, int pos, bool redraw = true) {
			new SCROLLINFO(SIF_POS) { nPos = pos }.Set(w, vertical, redraw);
		}
		
		public static void SetRange(wnd w, bool vertical, int max, int page, bool redraw = true) {
			new SCROLLINFO(SIF_RANGE | SIF_PAGE) { nMax = max, nPage = page }.Set(w, vertical, redraw);
		}
	}
	
	[DllImport("user32.dll")]
	internal static extern int SetScrollInfo(wnd hwnd, int nBar, in SCROLLINFO lpsi, bool redraw);
	
	[DllImport("user32.dll")]
	internal static extern bool GetScrollInfo(wnd hwnd, int nBar, ref SCROLLINFO lpsi);
	
	[DllImport("user32.dll")]
	internal static extern bool ShowScrollBar(wnd hWnd, int wBar, bool bShow);
	
	//[DllImport("user32.dll", SetLastError = true)]
	//internal static extern bool GetScrollBarInfo(wnd hwnd, EObjid idObject, ref SCROLLBARINFO psbi);
	
	//internal struct SCROLLBARINFO
	//{
	//	public int cbSize;
	//	public RECT rcScrollBar;
	//	public int dxyLineButton;
	//	public int xyThumbTop;
	//	public int xyThumbBottom;
	//	public int reserved;
	//	//public fixed uint rgstate[6];
	//	public uint stateScrollbar, stateArrowTopRight, statePageUpRight, stateThumb, statePageDownLeft, stateArrowBottomLeft;
	//}
	//internal const uint STATE_SYSTEM_INVISIBLE = 0x8000;
	//internal const uint STATE_SYSTEM_OFFSCREEN = 0x10000;
	//internal const uint STATE_SYSTEM_PRESSED = 0x8;
	//internal const uint STATE_SYSTEM_UNAVAILABLE = 0x1;
	
	[DllImport("user32.dll", EntryPoint = "MessageBoxW")]
	internal static extern int MessageBox(wnd hWnd, string lpText, string lpCaption, uint uType);
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern int GetWindowRgn(wnd hWnd, IntPtr hRgn);
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern int GetDpiForWindow(wnd hWnd);
	
	[DllImport("user32.dll")]
	internal static extern IntPtr GetWindowDpiAwarenessContext(wnd hwnd);
	
	[DllImport("user32.dll")]
	internal static extern Dpi.Awareness GetAwarenessFromDpiAwarenessContext(IntPtr value);
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern nint SetThreadDpiAwarenessContext(nint dpiContext);
	
	[DllImport("shcore.dll")]
	internal static extern int GetDpiForMonitor(IntPtr hmonitor, int dpiType, out int dpiX, out int dpiY);
	
	[DllImport("shcore.dll")]
	internal static extern int GetProcessDpiAwareness(IntPtr hprocess, out Dpi.Awareness value); //Dpi.Awareness is PROCESS_DPI_AWARENESS
	
	[DllImport("user32.dll")]
	internal static extern bool PhysicalToLogicalPointForPerMonitorDPI(wnd hWnd, ref POINT lpPoint);
	
	//[DllImport("user32.dll")]
	//internal static extern bool PhysicalToLogicalPoint(wnd hWnd, ref POINT lpPoint);
	
	//internal static bool PhysicalToLogicalPoint_AnyOS(wnd w, ref POINT p) => osVersion.minWin8_1 ? PhysicalToLogicalPointForPerMonitorDPI(w, ref p) : PhysicalToLogicalPoint(w, ref p);
	
	//[DllImport("user32.dll")]
	//internal static extern bool LogicalToPhysicalPointForPerMonitorDPI(wnd hWnd, ref POINT lpPoint);
	
	[DllImport("user32.dll")]
	internal static extern bool LogicalToPhysicalPoint(wnd hWnd, ref POINT lpPoint);
	
	//internal static bool LogicalToPhysicalPoint_AnyOS(wnd w, ref POINT p) => osVersion.minWin8_1 ? LogicalToPhysicalPointForPerMonitorDPI(w, ref p) : LogicalToPhysicalPoint(w, ref p);
	
	[DllImport("user32.dll")]
	internal static extern int GetSysColor(int nIndex);
	
	[DllImport("user32.dll")]
	internal static extern IntPtr GetSysColorBrush(int nIndex);
	
	//internal struct DRAWTEXTPARAMS
	//{
	//	public int cbSize;
	//	public int iTabLength;
	//	public int iLeftMargin;
	//	public int iRightMargin;
	//	public int uiLengthDrawn;
	//}
	
	//[DllImport("user32.dll", SetLastError = true)]
	//static extern int DrawTextExW(IntPtr hdc, char* lpchText, int cchText, ref RECT lprc, TFFlags format, DRAWTEXTPARAMS* lpdtp);
	
	[DllImport("user32.dll", SetLastError = true)]
	static extern int DrawTextExW(IntPtr hdc, char* lpchText, int cchText, ref RECT lprc, TFFlags format, void* lpdtp);
	
	internal static int DrawText(IntPtr hdc, RStr s, ref RECT lprc, TFFlags format) {
		if (format.Has(TFFlags.MODIFYSTRING)) throw new NotSupportedException("MODIFYSTRING");
		fixed (char* p = s) return DrawTextExW(hdc, p, s.Length, ref lprc, format, null);
		
		//DRAWTEXTPARAMS doc incorrect. Left nad right margin fields are in pixels, not average char widths. Not tested tab width.
	}
	
	internal const WS TTS_ALWAYSTIP = (WS)0x1;
	internal const WS TTS_NOPREFIX = (WS)0x2;
	internal const WS TTS_BALLOON = (WS)0x40;
	internal const int TTM_ACTIVATE = 0x401;
	internal const int TTM_SETMAXTIPWIDTH = 0x418;
	internal const int TTM_ADDTOOL = 0x432;
	internal const int TTM_DELTOOL = 0x433;
	internal const int TTM_RELAYEVENT = 0x407;
	//internal const uint TTF_SUBCLASS = 0x10;
	
	internal struct TTTOOLINFO {
		public int cbSize;
		public uint uFlags;
		public wnd hwnd;
		public nint uId;
		public RECT rect;
		public IntPtr hinst;
		public char* lpszText;
		public nint lParam;
		public void* lpReserved;
	}
	
	[DllImport("user32.dll")]
	internal static extern bool DrawEdge(IntPtr hdc, ref RECT qrc, uint edge, uint grfFlags);
	
	internal const uint EDGE_ETCHED = 0x6;
	internal const uint BF_LEFT = 0x1;
	internal const uint BF_TOP = 0x2;
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern IntPtr GetThreadDesktop(int dwThreadId);
	
	[DllImport("user32.dll", EntryPoint = "GetUserObjectInformationW", SetLastError = true)]
	internal static extern bool GetUserObjectInformation(IntPtr hObj, int nIndex, void* pvInfo, int nLength, out int lpnLengthNeeded);
	
	internal const int UOI_IO = 6;
	//internal const int UOI_NAME = 2;
	
	//[DllImport("user32.dll", SetLastError = true)]
	//internal static extern IntPtr OpenInputDesktop(uint dwFlags, bool fInherit, uint dwDesiredAccess);
	
	//[DllImport("user32.dll")]
	//internal static extern bool CloseDesktop(IntPtr hDesktop);
	
	internal const uint ISMEX_SEND = 0x1;
	internal const uint ISMEX_REPLIED = 0x8;
	
	[DllImport("user32.dll")]
	internal static extern uint InSendMessageEx(nint lpReserved = 0);
	
	public static bool InSendMessageBlocked => (InSendMessageEx() & (ISMEX_SEND | ISMEX_REPLIED)) == ISMEX_SEND;
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern bool ExitWindowsEx(int uFlags, uint dwReason);
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern bool LockWorkStation();
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern nint RegisterSuspendResumeNotification(IntPtr hRecipient, uint Flags);
	
	internal struct DEVICE_NOTIFY_SUBSCRIBE_PARAMETERS {
		public delegate* unmanaged<void*, int, void*, int> Callback;
		public void* Context;
	}
	
	//internal const uint DEVICE_NOTIFY_WINDOW_HANDLE = 0x0;
	//internal const int DEVICE_NOTIFY_CALLBACK = 2;
	
	[DllImport("user32.dll")]
	internal static extern bool UnregisterSuspendResumeNotification(nint Handle);
	
	//internal struct DEVICE_NOTIFY_SUBSCRIBE_PARAMETERS {
	//	public IntPtr Callback; //DEVICE_NOTIFY_CALLBACK_ROUTINE
	//	public nint Context;
	//}
	
	//internal delegate uint DEVICE_NOTIFY_CALLBACK_ROUTINE(nint context, uint type, nint setting);
	
	[DllImport("user32.dll", SetLastError = true)]
	internal static extern bool ClipCursor(RECT* lpRect);
	
	[DllImport("user32.dll")]
	static extern bool GetLastInputInfo(ref LASTINPUTINFO plii);
	
	struct LASTINPUTINFO {
		public int cbSize;
		public uint dwTime;
	}
	
	/// <summary>
	/// Calls API <see cref="GetLastInputInfo"/> and makes the result 64-bit.
	/// </summary>
	internal static long GetLastInputTime() {
		var r = new LASTINPUTINFO { cbSize = 8 };
		if (!GetLastInputInfo(ref r)) return 0;
		return TickCount32To64(r.dwTime);
	}
	
	/// <summary>
	/// Extends a 32-bit tick count (like from many Windows API) into the 64-bit tick count space.
	/// </summary>
	/// <param name="tick32">32-bit time, like from API <c>GetTickCount</c>. Must not be in the future.</param>
	internal static long TickCount32To64(uint tick32) {
		long now64 = Environment.TickCount64;
		long r = (now64 & ~0xffffffffL) | tick32;
		if (r > now64) r -= 0x1_0000_0000L;
		return r;
	}
}



================================================
FILE: Au/Api/Api_COM.cs
================================================
namespace Au.Types;

static unsafe partial class Api {
	internal struct STRRET {
		public uint uType;

		[StructLayout(LayoutKind.Explicit)]
		internal struct TYPE_1 {
			[FieldOffset(0)]
			public char* pOleStr;
			[FieldOffset(0)]
			public uint uOffset;
			[FieldOffset(0)]
			public fixed sbyte cStr[260];
		}
		public TYPE_1 _2;
	}

	//internal static Guid IID_IShellFolder = new Guid(0x000214E6, 0x0000, 0x0000, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46);

	[ComImport, Guid("000214E6-0000-0000-C000-000000000046"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
	internal interface IShellFolder {
		//[PreserveSig] int ParseDisplayName(wnd hwnd, IntPtr pbc, [MarshalAs(UnmanagedType.LPWStr)] string pszDisplayName, uint* pchEaten, out IntPtr ppidl, uint* pdwAttributes);
		//[PreserveSig] int EnumObjects(wnd hwnd, uint grfFlags, out IEnumIDList ppenumIDList);
		//[PreserveSig] int BindToObject(IntPtr pidl, IntPtr pbc, in Guid riid, [MarshalAs(UnmanagedType.IUnknown)] out object ppv);
		//[PreserveSig] int BindToStorage(IntPtr pidl, IntPtr pbc, in Guid riid, [MarshalAs(UnmanagedType.IUnknown)] out object ppv);
		//[PreserveSig] int CompareIDs(nint lParam, IntPtr pidl1, IntPtr pidl2);
		//[PreserveSig] int CreateViewObject(wnd hwndOwner, in Guid riid, out IntPtr ppv);
		//[PreserveSig] int GetAttributesOf(uint cidl, [MarshalAs(UnmanagedType.LPArray)] IntPtr[] apidl, ref uint rgfInOut);
		void _0();
		void _1();
		void _2();
		void _3();
		void _4();
		void _5();
		void _6();
		[PreserveSig] int GetUIObjectOf(wnd hwndOwner, uint cidl, in IntPtr pidl, in Guid riid, nint rgfReserved, [MarshalAs(UnmanagedType.IUnknown)] out object ppv);
		//[PreserveSig] int GetDisplayNameOf(IntPtr pidl, uint uFlags, out STRRET pName);
		//[PreserveSig] int SetNameOf(wnd hwnd, IntPtr pidl, [MarshalAs(UnmanagedType.LPWStr)] string pszName, uint uFlags, out IntPtr ppidlOut);
	}

	internal static bool GetUIObjectOf<T>(this IShellFolder t, IntPtr pidl, out T result) where T : class {
		result = null;
		if (0 != t.GetUIObjectOf(default, 1, pidl, typeof(T).GUID, 0, out var o) || o is not T r) return false;
		result = r;
		return true;
	}

	//internal static Guid IID_IShellItem = new Guid(0x43826D1E, 0xE718, 0x42EE, 0xBC, 0x55, 0xA1, 0xE2, 0x61, 0xC3, 0x7B, 0xFE);

	[ComImport, Guid("43826d1e-e718-42ee-bc55-a1e261c37bfe"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
	internal interface IShellItem {
		//[PreserveSig] int BindToHandler(IntPtr pbc, in Guid bhid, in Guid riid, out IntPtr ppv); //IBindCtx
		//[PreserveSig] int GetParent(out IShellItem ppsi);
		void _0();
		void _1();
		[PreserveSig] int GetDisplayName(SIGDN sigdnName, [MarshalAs(UnmanagedType.LPWStr)] out string ppszName);
		[PreserveSig] int GetAttributes(uint sfgaoMask, out uint psfgaoAttribs);
		//[PreserveSig] int Compare(IShellItem psi, uint hint, out int piOrder);
	}

	//[ComImport, Guid("000214F2-0000-0000-C000-000000000046"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
	//internal interface IEnumIDList {
	//	[PreserveSig] int Next(int celt, [MarshalAs(UnmanagedType.LPArray)][Out] IntPtr[] rgelt, out int pceltFetched);
	//	[PreserveSig] int Skip(int celt);
	//	[PreserveSig] int Reset();
	//	[PreserveSig] int Clone(out IEnumIDList ppenum);
	//}

	[ComImport, Guid("000214fa-0000-0000-c000-000000000046"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
	internal interface IExtractIcon {
		[PreserveSig] int GetIconLocation(uint uFlags, StringBuilder pszIconFile, int cchMax, out int piIndex, out uint pwFlags);
		//[PreserveSig] int Extract([MarshalAs(UnmanagedType.LPWStr)] string pszFile, int nIconIndex, out IntPtr phiconLarge, out IntPtr phiconSmall, uint nIconSize);
	}

	[ComImport, Guid("000214F9-0000-0000-C000-000000000046"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
	internal interface IShellLink {
		[PreserveSig] int GetPath(char* pszFile, int cch, IntPtr pfd = default, uint fFlags = 0);
		[PreserveSig] int GetIDList(out IntPtr ppidl);
		[PreserveSig] int SetIDList(IntPtr pidl);
		[PreserveSig] int GetDescription(char* pszName, int cch);
		[PreserveSig] int SetDescription([MarshalAs(UnmanagedType.LPWStr)] string pszName);
		[PreserveSig] int GetWorkingDirectory(char* pszDir, int cch);
		[PreserveSig] int SetWorkingDirectory([MarshalAs(UnmanagedType.LPWStr)] string pszDir);
		[PreserveSig] int GetArguments(char* pszArgs, int cch);
		[PreserveSig] int SetArguments([MarshalAs(UnmanagedType.LPWStr)] string pszArgs);
		[PreserveSig] int GetHotkey(out ushort pwHotkey);
		[PreserveSig] int SetHotkey(ushort wHotkey);
		[PreserveSig] int GetShowCmd(out int piShowCmd);
		[PreserveSig] int SetShowCmd(int iShowCmd);
		[PreserveSig] int GetIconLocation(char* pszIconPath, int cch, out int piIcon);
		[PreserveSig] int SetIconLocation([MarshalAs(UnmanagedType.LPWStr)] string pszIconPath, int iIcon);
		[PreserveSig] int SetRelativePath([MarshalAs(UnmanagedType.LPWStr)] string pszPathRel, uint dwReserved = 0);
		[PreserveSig] int Resolve(wnd hwnd, uint fFlags);
		[PreserveSig] int SetPath([MarshalAs(UnmanagedType.LPWStr)] string pszFile);

		//info: default string marshaling in COM interfaces is BSTR, but in this interface strings are LPWSTR. Cannot use plain string and char[].
		//	Instead of [MarshalAs(UnmanagedType.LPArray)] [Out] char[] can be just char*. Then also need fixed when calling.
	}

	[ComImport, Guid("00021401-0000-0000-C000-000000000046"), ClassInterface(ClassInterfaceType.None)]
	internal class ShellLink { }

	[ComImport, Guid("0000010b-0000-0000-C000-000000000046"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
	internal interface IPersistFile {
		// IPersist
		[PreserveSig] int GetClassID(out Guid pClassID);
		// IPersistFile
		[PreserveSig] int IsDirty();
		[PreserveSig] int Load([MarshalAs(UnmanagedType.LPWStr)] string pszFileName, uint dwMode);
		[PreserveSig] int Save([MarshalAs(UnmanagedType.LPWStr)] string pszFileName, [MarshalAs(UnmanagedType.Bool)] bool fRemember);
		//[PreserveSig] int SaveCompleted([MarshalAs(UnmanagedType.LPWStr)] string pszFileName);
		//[PreserveSig] int GetCurFile(out IntPtr ppszFileName);
	}

	//see also VARIANT in Struct.cs
	internal struct PROPVARIANT : IDisposable {
		public VARENUM vt; //ushort
		ushort _u1;
		uint _u2;
		public nint value;
		public nint value2;

		/// <summary>
		/// Calls <c>PropVariantClear</c>.
		/// </summary>
		public void Dispose() {
			PropVariantClear(ref this);
		}
	}

	internal struct PROPERTYKEY {
		public Guid fmtid;
		public uint pid;
	}

	internal static Guid IID_IPropertyStore = new Guid(0x886D8EEB, 0x8CF2, 0x4446, 0x8D, 0x02, 0xCD, 0xBA, 0x1D, 0xBD, 0xCF, 0x99);

	[ComImport, Guid("886d8eeb-8cf2-4446-8d02-cdba1dbdcf99"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
	internal interface IPropertyStore {
		[PreserveSig] int GetCount(out int cProps);
		[PreserveSig] int GetAt(int iProp, out PROPERTYKEY pkey);
		[PreserveSig] int GetValue(in PROPERTYKEY key, out PROPVARIANT pv);
		[PreserveSig] int SetValue(in PROPERTYKEY key, ref PROPVARIANT propvar);
		[PreserveSig] int Commit();
	}

	//note: this is used in the lib, even if IImageList isn't.
	internal static Guid IID_IImageList = new Guid(0x46EB5926, 0x582E, 0x4017, 0x9F, 0xDF, 0xE8, 0x99, 0x8D, 0xAA, 0x09, 0x50);

	[ComImport, Guid("a5cd92ff-29be-454c-8d04-d82879fb3f1b"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
	internal interface IVirtualDesktopManager {
		[PreserveSig] int IsWindowOnCurrentVirtualDesktop(wnd topLevelWindow, [MarshalAs(UnmanagedType.Bool)] out bool onCurrentDesktop);
		[PreserveSig] int GetWindowDesktopId(wnd topLevelWindow, out Guid desktopId);
		[PreserveSig] int MoveWindowToDesktop(wnd topLevelWindow, in Guid desktopId);
	}

	[ComImport, Guid("aa509086-5ca9-4c25-8f95-589d3c07b48a"), ClassInterface(ClassInterfaceType.None)]
	internal class VirtualDesktopManager { }
}


================================================
FILE: Au/Api/Api_UIA.cs
================================================
namespace Au.Types;

/// <summary>
/// Wraps some UI Automation API.
/// </summary>
static class UiaUtil {
	public static UiaApi.IUIAutomation Uia => _uia ??= osVersion.minWin8 ? new UiaApi.CUIAutomation8() as UiaApi.IUIAutomation : new UiaApi.CUIAutomation() as UiaApi.IUIAutomation;
	[ThreadStatic] static UiaApi.IUIAutomation _uia;
	
	/// <summary>
	/// Gets UI element from point.
	/// </summary>
	/// <param name="xy">Screen coordinates.</param>
	/// <returns><c>null</c> if failed.</returns>
	public static UiaApi.IUIAutomationElement ElementFromPoint(POINT xy) {
		return 0 == Uia.ElementFromPoint(xy, out var e) ? e : null;
	}
	
	/// <summary>
	/// Gets the focused element.
	/// </summary>
	/// <returns><c>null</c> if failed.</returns>
	public static UiaApi.IUIAutomationElement ElementFocused() {
		return 0 == Uia.GetFocusedElement(out var e) ? e : null;
	}
	
	///// <summary>
	///// Gets the container control of this or nearest ancestor element that can retrieve it.
	///// </summary>
	//public static wnd Hwnd(this UiaApi.IUIAutomationElement t) {
	//	if (0 == t.get_CurrentNativeWindowHandle(out var w) && !w.Is0) return w;
		
	//	if (0 == Uia.get_RawViewWalker(out var walker)) {
	//		while (0 == walker.GetParentElement(t, out var p) && p != null && p != t) {
	//			t = p;
	//			if (0 == t.get_CurrentNativeWindowHandle(out w) && !w.Is0) return w;
	//		}
	//	}
		
	//	return default;
	//}
	
	/// <summary>
	/// Gets caret rectangle in screen from this focused element.
	/// </summary>
	public static bool GetCaretRect(this UiaApi.IUIAutomationElement t, out RECT r) {
		if (0 == t.GetCurrentPattern(UiaApi.UIA_TextPattern2Id, out var o) && o is UiaApi.IUIAutomationTextPattern2 p2) {
			if (0 == p2.GetCaretRange(out bool isActive, out var tr) && tr != null /*&& isActive*/) {
				return tr.GetRect(out r, t);
			}
		}
		if (0 == t.GetCurrentPattern(UiaApi.UIA_TextPatternId, out o) && o is UiaApi.IUIAutomationTextPattern p) {
			if (0 == p.GetSelection(out var ranges) && 0 == ranges.GetElement(0, out var tr)) {
				return tr.GetRect(out r, t, selectionToCaret: true);
			}
		}
		r = default;
		return false;
	}
	
	/// <summary>
	/// Gets rectangle in screen.
	/// </summary>
	public static unsafe bool GetRect(this UiaApi.IUIAutomationTextRange t, out RECT r, UiaApi.IUIAutomationElement e, bool selectionToCaret = false) {
		if (_GetRect(t, out r)) {
			if (selectionToCaret) r.left = r.right - 1;
			return true;
		}
		
		//probably no selection
		
		if (0 == t.ExpandToEnclosingUnit(UiaApi.TextUnit.TextUnit_Character) && _GetRect(t, out r)) {
			r.right = r.left + 1;
			return true;
		}
		
		//probably caret at the end
		
		if (0 == t.MoveEndpointByUnit(UiaApi.TextPatternRangeEndpoint.TextPatternRangeEndpoint_Start, UiaApi.TextUnit.TextUnit_Character, -1, out int m) && m < 0 && _GetRect(t, out r)) {
			//moved to previous line?
			if (0 == t.GetText(2, out var s) && !s.NE() && s[0] is '\r' or '\n' && 0 == t.ExpandToEnclosingUnit(UiaApi.TextUnit.TextUnit_Line) && _GetRect(t, out var r2)) {
				r.Offset(0, r2.Height);
				r.right = (r.left = r2.left) + 1;
			} else {
				r.right = (r.left = r.right) + 1;
			}
			return true;
		}
		
		//probably no text
		
		//get the left edge of e rect
		if (0 == e.get_CurrentBoundingRectangle(out r)) {
			int dpi = Dpi.OfWindow(wnd.active);
			int h = (int)Dpi.Unscale(r.Height, dpi);
			if (h < 111) { //assume it's a single-line edit control
				if (h > 32) r.top = r.bottom - Dpi.Scale(32, dpi); //get the bottom max 32 logical pixels
				r.right = r.left + 1;
				return true;
			}
		}
		
		return false;
		
		static unsafe bool _GetRect(UiaApi.IUIAutomationTextRange t, out RECT r) {
			r = default;
			if (0 != t.GetBoundingRectangles(out var sap) || sap == null) return false;
			uint n = sap->rgsabound.cElements / 4;
			if (n > 0) {
				var p = (double*)sap->pvData + sap->rgsabound.cElements - 4;
				r = new(p[0].ToInt(), p[1].ToInt(), p[2].ToInt(), p[3].ToInt());
			}
			UiaApi.SafeArrayDestroy(sap);
			return n > 0;
		}
	}
	
	public static bool GetCaretRectInPowerShell(out RECT r) {
		//GetGUIThreadInfo and MSAA don't work with PowerShell.
		//	Does not support IUIAutomationTextPattern2.
		//	IUIAutomationTextPattern.GetSelection -> IUIAutomationTextRange.GetBoundingRectangles returns client coord, which may be fixed in the future.
		//	Win+; doesn't work too. But PhraseExpress works. And IME (interesting: temporarily replaces the caret).
		//	I would't care, but this was a user request.
		//Now instead using an undocumented PS feature.
		
		var t = ElementFocused();
		if (t != null && 0 == t.get_CurrentControlType(out var ct) && ct == UiaApi.TypeId.Edit) {
			if (0 == Uia.get_RawViewWalker(out var walker)) {
				UiaApi.IUIAutomationElement e = null;
				while (0 == (e == null ? walker.GetFirstChildElement(t, out e) : walker.GetNextSiblingElement(e, out e)) && e != null) {
					//if (0 == e.get_CurrentControlType(out ct)) print.it(ct);
					//if (0 == e.get_CurrentAutomationId(out var ai)) print.it(ai);
					if (0 == e.get_CurrentAutomationId(out var ai) && ai.Find("Caret", true) >= 0 && 0 == e.get_CurrentControlType(out ct) && ct == UiaApi.TypeId.Custom) {
						if (0 == e.get_CurrentBoundingRectangle(out r)) {
							return true;
						}
					}
				}
				//There are 3 child elements. The first is caret.
				//This is slow. Tested MSAA, but it gets only child element "selection", and cannot get rect when selection empty.
			}
		}
		r = default;
		return false;
	}
	
	///// <summary>
	///// Gets text of <c>TextPattern</c> paragraph from point.
	///// </summary>
	///// <param name="t"></param>
	///// <param name="xy">Screen coordinates.</param>
	///// <returns><c>null</c> if the element does not support <c>TextPattern</c> or if failed.</returns>
	//public static string PatternTextFromPoint(this UiaApi.IUIAutomationElement t, POINT xy) {
	//	if (0 == t.GetCurrentPattern(UiaApi.UIA_TextPatternId, out var o) && o is UiaApi.IUIAutomationTextPattern p) {
	//		if (0 == p.RangeFromPoint(xy, out var tr) && 0 == tr.ExpandToEnclosingUnit(UiaApi.TextUnit.TextUnit_Paragraph)) {
	//			if (0 == tr.GetText(5000, out var s)) return s;
	//		}
	//	}
	//	return null;
	//}
	
	///// <summary>
	///// Gets text of <c>ValuePattern</c>.
	///// </summary>
	///// <param name="t"></param>
	///// <returns><c>null</c> if the element does not support <c>ValuePattern</c> or if failed.</returns>
	//public static string ValueText(this UiaApi.IUIAutomationElement t) {
	//	if (0 == t.GetCurrentPattern(UiaApi.UIA_ValuePatternId, out var o) && o is UiaApi.IUIAutomationValuePattern p) {
	//		if (0 == p.get_CurrentValue(out var s)) return s;
	//	}
	//	return null;
	//}
}

#pragma warning disable 1591, 649, 169

/// <summary>
/// Declarations of some UI Automation API.
/// </summary>
unsafe class UiaApi : NativeApi {
	
	[ComImport, Guid("ff48dba4-60ef-4201-aa87-54103eef594e"), ClassInterface(ClassInterfaceType.None)]
	internal class CUIAutomation { }

	[ComImport, Guid("e22ad333-b25f-460c-83d0-0581107395c9"), ClassInterface(ClassInterfaceType.None)]
	internal class CUIAutomation8 { }
	
	[ComImport, Guid("30cbe57d-d9d0-452a-ab13-7ac5ac4825ee"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
	internal interface IUIAutomation {
		[PreserveSig] int CompareElements(IUIAutomationElement el1, IUIAutomationElement el2, [MarshalAs(UnmanagedType.Bool)] out bool areSame);
		[PreserveSig] int CompareRuntimeIds(SAFEARRAY* runtimeId1, SAFEARRAY* runtimeId2, [MarshalAs(UnmanagedType.Bool)] out bool areSame);
		[PreserveSig] int GetRootElement(out IUIAutomationElement root);
		[PreserveSig] int ElementFromHandle(void* hwnd, out IUIAutomationElement element);
		[PreserveSig] int ElementFromPoint(POINT pt, out IUIAutomationElement element);
		[PreserveSig] int GetFocusedElement(out IUIAutomationElement element);
		[PreserveSig] int GetRootElementBuildCache(IUIAutomationCacheRequest cacheRequest, out IUIAutomationElement root);
		[PreserveSig] int ElementFromHandleBuildCache(void* hwnd, IUIAutomationCacheRequest cacheRequest, out IUIAutomationElement element);
		[PreserveSig] int ElementFromPointBuildCache(POINT pt, IUIAutomationCacheRequest cacheRequest, out IUIAutomationElement element);
		[PreserveSig] int GetFocusedElementBuildCache(IUIAutomationCacheRequest cacheRequest, out IUIAutomationElement element);
		[PreserveSig] int CreateTreeWalker(IUIAutomationCondition pCondition, out IUIAutomationTreeWalker walker);
		[PreserveSig] int get_ControlViewWalker(out IUIAutomationTreeWalker walker);
		[PreserveSig] int get_ContentViewWalker(out IUIAutomationTreeWalker walker);
		[PreserveSig] int get_RawViewWalker(out IUIAutomationTreeWalker walker);
		[PreserveSig] int get_RawViewCondition(out IUIAutomationCondition condition);
		[PreserveSig] int get_ControlViewCondition(out IUIAutomationCondition condition);
		[PreserveSig] int get_ContentViewCondition(out IUIAutomationCondition condition);
		[PreserveSig] int CreateCacheRequest(out IUIAutomationCacheRequest cacheRequest);
		[PreserveSig] int CreateTrueCondition(out IUIAutomationCondition newCondition);
		[PreserveSig] int CreateFalseCondition(out IUIAutomationCondition newCondition);
		[PreserveSig] int CreatePropertyCondition(int propertyId, object value, out IUIAutomationCondition newCondition);
		[PreserveSig] int CreatePropertyConditionEx(int propertyId, object value, PropertyConditionFlags flags, out IUIAutomationCondition newCondition);
		[PreserveSig] int CreateAndCondition(IUIAutomationCondition condition1, IUIAutomationCondition condition2, out IUIAutomationCondition newCondition);
		[PreserveSig] int CreateAndConditionFromArray(SAFEARRAY* conditions, out IUIAutomationCondition newCondition);
		[PreserveSig] int CreateAndConditionFromNativeArray([MarshalAs(UnmanagedType.LPArray)][In] IUIAutomationCondition[] conditions, int conditionCount, out IUIAutomationCondition newCondition);
		[PreserveSig] int CreateOrCondition(IUIAutomationCondition condition1, IUIAutomationCondition condition2, out IUIAutomationCondition newCondition);
		[PreserveSig] int CreateOrConditionFromArray(SAFEARRAY* conditions, out IUIAutomationCondition newCondition);
		[PreserveSig] int CreateOrConditionFromNativeArray([MarshalAs(UnmanagedType.LPArray)][In] IUIAutomationCondition[] conditions, int conditionCount, out IUIAutomationCondition newCondition);
		[PreserveSig] int CreateNotCondition(IUIAutomationCondition condition, out IUIAutomationCondition newCondition);
		[PreserveSig] int AddAutomationEventHandler(int eventId, IUIAutomationElement element, TreeScope scope, IUIAutomationCacheRequest cacheRequest, IUIAutomationEventHandler handler);
		[PreserveSig] int RemoveAutomationEventHandler(int eventId, IUIAutomationElement element, IUIAutomationEventHandler handler);
		[PreserveSig] int AddPropertyChangedEventHandlerNativeArray(IUIAutomationElement element, TreeScope scope, IUIAutomationCacheRequest cacheRequest, IUIAutomationPropertyChangedEventHandler handler, [MarshalAs(UnmanagedType.LPArray)][In] int[] propertyArray, int propertyCount);
		[PreserveSig] int AddPropertyChangedEventHandler(IUIAutomationElement element, TreeScope scope, IUIAutomationCacheRequest cacheRequest, IUIAutomationPropertyChangedEventHandler handler, SAFEARRAY* propertyArray);
		[PreserveSig] int RemovePropertyChangedEventHandler(IUIAutomationElement element, IUIAutomationPropertyChangedEventHandler handler);
		[PreserveSig] int AddStructureChangedEventHandler(IUIAutomationElement element, TreeScope scope, IUIAutomationCacheRequest cacheRequest, IUIAutomationStructureChangedEventHandler handler);
		[PreserveSig] int RemoveStructureChangedEventHandler(IUIAutomationElement element, IUIAutomationStructureChangedEventHandler handler);
		[PreserveSig] int AddFocusChangedEventHandler(IUIAutomationCacheRequest cacheRequest, IUIAutomationFocusChangedEventHandler handler);
		[PreserveSig] int RemoveFocusChangedEventHandler(IUIAutomationFocusChangedEventHandler handler);
		[PreserveSig] int RemoveAllEventHandlers();
		[PreserveSig] int IntNativeArrayToSafeArray([MarshalAs(UnmanagedType.LPArray)][In] int[] array, int arrayCount, out SAFEARRAY* safeArray);
		[PreserveSig] int IntSafeArrayToNativeArray(SAFEARRAY* intArray, out int* array, out int arrayCount);
		[PreserveSig] int RectToVariant(RECT rc, out object var);
		[PreserveSig] int VariantToRect(object var, out RECT rc);
		[PreserveSig] int SafeArrayToRectNativeArray(SAFEARRAY* rects, out RECT* rectArray, out int rectArrayCount);
		[PreserveSig] int CreateProxyFactoryEntry();
		[PreserveSig] int get_ProxyFactoryMapping();
		[PreserveSig] int GetPropertyProgrammaticName(int property, out string name);
		[PreserveSig] int GetPatternProgrammaticName(int pattern, out string name);
		[PreserveSig] int PollForPotentialSupportedPatterns(IUIAutomationElement pElement, out SAFEARRAY* patternIds, out SAFEARRAY* patternNames);
		[PreserveSig] int PollForPotentialSupportedProperties(IUIAutomationElement pElement, out SAFEARRAY* propertyIds, out SAFEARRAY* propertyNames);
		[PreserveSig] int CheckNotSupported(object value, [MarshalAs(UnmanagedType.Bool)] out bool isNotSupported);
		[PreserveSig] int get_ReservedNotSupportedValue([MarshalAs(UnmanagedType.IUnknown)] out object notSupportedValue);
		[PreserveSig] int get_ReservedMixedAttributeValue([MarshalAs(UnmanagedType.IUnknown)] out object mixedAttributeValue);
		[PreserveSig] int ElementFromIAccessible();
		[PreserveSig] int ElementFromIAccessibleBuildCache();
	}
	
	[ComImport, Guid("c270f6b5-5c69-4290-9745-7a7f97169468"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
	internal interface IUIAutomationFocusChangedEventHandler {
		[PreserveSig] int HandleFocusChangedEvent(IUIAutomationElement sender);
	}
	
	[ComImport, Guid("e81d1b4e-11c5-42f8-9754-e7036c79f054"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
	internal interface IUIAutomationStructureChangedEventHandler {
		[PreserveSig] int HandleStructureChangedEvent(IUIAutomationElement sender, StructureChangeType changeType, SAFEARRAY* runtimeId);
	}
	
	[ComImport, Guid("40cd37d4-c756-4b0c-8c6f-bddfeeb13b50"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
	internal interface IUIAutomationPropertyChangedEventHandler {
		[PreserveSig] int HandlePropertyChangedEvent(IUIAutomationElement sender, int propertyId, object newValue);
	}
	
	[ComImport, Guid("146c3c17-f12e-4e22-8c27-f894b9b79c69"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
	internal interface IUIAutomationEventHandler {
		[PreserveSig] int HandleAutomationEvent(IUIAutomationElement sender, int eventId);
	}
	
	[Flags]
	internal enum PropertyConditionFlags : uint {
		PropertyConditionFlags_None,
		PropertyConditionFlags_IgnoreCase,
		PropertyConditionFlags_MatchSubstring
	}
	
	[ComImport, Guid("4042c624-389c-4afc-a630-9df854a541fc"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
	internal interface IUIAutomationTreeWalker {
		[PreserveSig] int GetParentElement(IUIAutomationElement element, out IUIAutomationElement parent);
		[PreserveSig] int GetFirstChildElement(IUIAutomationElement element, out IUIAutomationElement first);
		[PreserveSig] int GetLastChildElement(IUIAutomationElement element, out IUIAutomationElement last);
		[PreserveSig] int GetNextSiblingElement(IUIAutomationElement element, out IUIAutomationElement next);
		[PreserveSig] int GetPreviousSiblingElement(IUIAutomationElement element, out IUIAutomationElement previous);
		[PreserveSig] int NormalizeElement(IUIAutomationElement element, out IUIAutomationElement normalized);
		[PreserveSig] int GetParentElementBuildCache(IUIAutomationElement element, IUIAutomationCacheRequest cacheRequest, out IUIAutomationElement parent);
		[PreserveSig] int GetFirstChildElementBuildCache(IUIAutomationElement element, IUIAutomationCacheRequest cacheRequest, out IUIAutomationElement first);
		[PreserveSig] int GetLastChildElementBuildCache(IUIAutomationElement element, IUIAutomationCacheRequest cacheRequest, out IUIAutomationElement last);
		[PreserveSig] int GetNextSiblingElementBuildCache(IUIAutomationElement element, IUIAutomationCacheRequest cacheRequest, out IUIAutomationElement next);
		[PreserveSig] int GetPreviousSiblingElementBuildCache(IUIAutomationElement element, IUIAutomationCacheRequest cacheRequest, out IUIAutomationElement previous);
		[PreserveSig] int NormalizeElementBuildCache(IUIAutomationElement element, IUIAutomationCacheRequest cacheRequest, out IUIAutomationElement normalized);
		[PreserveSig] int get_Condition(out IUIAutomationCondition condition);
	}
	
	[ComImport, Guid("d22108aa-8ac5-49a5-837b-37bbb3d7591e"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
	internal interface IUIAutomationElement {
		[PreserveSig] int SetFocus();
		[PreserveSig] int GetRuntimeId(out SAFEARRAY* runtimeId);
		[PreserveSig] int FindFirst(TreeScope scope, IUIAutomationCondition condition, out IUIAutomationElement found);
		[PreserveSig] int FindAll(TreeScope scope, IUIAutomationCondition condition, out IUIAutomationElementArray found);
		[PreserveSig] int FindFirstBuildCache(TreeScope scope, IUIAutomationCondition condition, IUIAutomationCacheRequest cacheRequest, out IUIAutomationElement found);
		[PreserveSig] int FindAllBuildCache(TreeScope scope, IUIAutomationCondition condition, IUIAutomationCacheRequest cacheRequest, out IUIAutomationElementArray found);
		[PreserveSig] int BuildUpdatedCache(IUIAutomationCacheRequest cacheRequest, out IUIAutomationElement updatedElement);
		[PreserveSig] int GetCurrentPropertyValue(int propertyId, out object retVal);
		[PreserveSig] int GetCurrentPropertyValueEx(int propertyId, [MarshalAs(UnmanagedType.Bool)] bool ignoreDefaultValue, out object retVal);
		[PreserveSig] int GetCachedPropertyValue(int propertyId, out object retVal);
		[PreserveSig] int GetCachedPropertyValueEx(int propertyId, [MarshalAs(UnmanagedType.Bool)] bool ignoreDefaultValue, out object retVal);
		[PreserveSig] int GetCurrentPatternAs(int patternId, in Guid riid, void** patternObject);
		[PreserveSig] int GetCachedPatternAs(int patternId, in Guid riid, void** patternObject);
		[PreserveSig] int GetCurrentPattern(int patternId, [MarshalAs(UnmanagedType.IUnknown)] out object patternObject);
		[PreserveSig] int GetCachedPattern(int patternId, [MarshalAs(UnmanagedType.IUnknown)] out object patternObject);
		[PreserveSig] int GetCachedParent(out IUIAutomationElement parent);
		[PreserveSig] int GetCachedChildren(out IUIAutomationElementArray children);
		[PreserveSig] int get_CurrentProcessId(out int retVal);
		[PreserveSig] int get_CurrentControlType(out TypeId retVal);
		[PreserveSig] int get_CurrentLocalizedControlType(out string retVal);
		[PreserveSig] int get_CurrentName(out string retVal);
		[PreserveSig] int get_CurrentAcceleratorKey(out string retVal);
		[PreserveSig] int get_CurrentAccessKey(out string retVal);
		[PreserveSig] int get_CurrentHasKeyboardFocus([MarshalAs(UnmanagedType.Bool)] out bool retVal);
		[PreserveSig] int get_CurrentIsKeyboardFocusable([MarshalAs(UnmanagedType.Bool)] out bool retVal);
		[PreserveSig] int get_CurrentIsEnabled([MarshalAs(UnmanagedType.Bool)] out bool retVal);
		[PreserveSig] int get_CurrentAutomationId(out string retVal);
		[PreserveSig] int get_CurrentClassName(out string retVal);
		[PreserveSig] int get_CurrentHelpText(out string retVal);
		[PreserveSig] int get_CurrentCulture(out int retVal);
		[PreserveSig] int get_CurrentIsControlElement([MarshalAs(UnmanagedType.Bool)] out bool retVal);
		[PreserveSig] int get_CurrentIsContentElement([MarshalAs(UnmanagedType.Bool)] out bool retVal);
		[PreserveSig] int get_CurrentIsPassword([MarshalAs(UnmanagedType.Bool)] out bool retVal);
		[PreserveSig] int get_CurrentNativeWindowHandle(out wnd retVal);
		[PreserveSig] int get_CurrentItemType(out string retVal);
		[PreserveSig] int get_CurrentIsOffscreen([MarshalAs(UnmanagedType.Bool)] out bool retVal);
		[PreserveSig] int get_CurrentOrientation(out OrientationType retVal);
		[PreserveSig] int get_CurrentFrameworkId(out string retVal);
		[PreserveSig] int get_CurrentIsRequiredForForm([MarshalAs(UnmanagedType.Bool)] out bool retVal);
		[PreserveSig] int get_CurrentItemStatus(out string retVal);
		[PreserveSig] int get_CurrentBoundingRectangle(out RECT retVal);
		[PreserveSig] int get_CurrentLabeledBy(out IUIAutomationElement retVal);
		[PreserveSig] int get_CurrentAriaRole(out string retVal);
		[PreserveSig] int get_CurrentAriaProperties(out string retVal);
		[PreserveSig] int get_CurrentIsDataValidForForm([MarshalAs(UnmanagedType.Bool)] out bool retVal);
		[PreserveSig] int get_CurrentControllerFor(out IUIAutomationElementArray retVal);
		[PreserveSig] int get_CurrentDescribedBy(out IUIAutomationElementArray retVal);
		[PreserveSig] int get_CurrentFlowsTo(out IUIAutomationElementArray retVal);
		[PreserveSig] int get_CurrentProviderDescription(out string retVal);
		[PreserveSig] int get_CachedProcessId(out int retVal);
		[PreserveSig] int get_CachedControlType(out int retVal);
		[PreserveSig] int get_CachedLocalizedControlType(out string retVal);
		[PreserveSig] int get_CachedName(out string retVal);
		[PreserveSig] int get_CachedAcceleratorKey(out string retVal);
		[PreserveSig] int get_CachedAccessKey(out string retVal);
		[PreserveSig] int get_CachedHasKeyboardFocus([MarshalAs(UnmanagedType.Bool)] out bool retVal);
		[PreserveSig] int get_CachedIsKeyboardFocusable([MarshalAs(UnmanagedType.Bool)] out bool retVal);
		[PreserveSig] int get_CachedIsEnabled([MarshalAs(UnmanagedType.Bool)] out bool retVal);
		[PreserveSig] int get_CachedAutomationId(out string retVal);
		[PreserveSig] int get_CachedClassName(out string retVal);
		[PreserveSig] int get_CachedHelpText(out string retVal);
		[PreserveSig] int get_CachedCulture(out int retVal);
		[PreserveSig] int get_CachedIsControlElement([MarshalAs(UnmanagedType.Bool)] out bool retVal);
		[PreserveSig] int get_CachedIsContentElement([MarshalAs(UnmanagedType.Bool)] out bool retVal);
		[PreserveSig] int get_CachedIsPassword([MarshalAs(UnmanagedType.Bool)] out bool retVal);
		[PreserveSig] int get_CachedNativeWindowHandle(void** retVal);
		[PreserveSig] int get_CachedItemType(out string retVal);
		[PreserveSig] int get_CachedIsOffscreen([MarshalAs(UnmanagedType.Bool)] out bool retVal);
		[PreserveSig] int get_CachedOrientation(out OrientationType retVal);
		[PreserveSig] int get_CachedFrameworkId(out string retVal);
		[PreserveSig] int get_CachedIsRequiredForForm([MarshalAs(UnmanagedType.Bool)] out bool retVal);
		[PreserveSig] int get_CachedItemStatus(out string retVal);
		[PreserveSig] int get_CachedBoundingRectangle(out RECT retVal);
		[PreserveSig] int get_CachedLabeledBy(out IUIAutomationElement retVal);
		[PreserveSig] int get_CachedAriaRole(out string retVal);
		[PreserveSig] int get_CachedAriaProperties(out string retVal);
		[PreserveSig] int get_CachedIsDataValidForForm([MarshalAs(UnmanagedType.Bool)] out bool retVal);
		[PreserveSig] int get_CachedControllerFor(out IUIAutomationElementArray retVal);
		[PreserveSig] int get_CachedDescribedBy(out IUIAutomationElementArray retVal);
		[PreserveSig] int get_CachedFlowsTo(out IUIAutomationElementArray retVal);
		[PreserveSig] int get_CachedProviderDescription(out string retVal);
		[PreserveSig] int GetClickablePoint(out POINT clickable, [MarshalAs(UnmanagedType.Bool)] out bool gotClickable);
	}
	
	internal enum OrientationType {
		OrientationType_None,
		OrientationType_Horizontal,
		OrientationType_Vertical
	}
	
	[ComImport, Guid("b32a92b5-bc25-4078-9c08-d7ee95c48e03"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
	internal interface IUIAutomationCacheRequest {
		[PreserveSig] int AddProperty(int propertyId);
		[PreserveSig] int AddPattern(int patternId);
		[PreserveSig] int Clone(out IUIAutomationCacheRequest clonedRequest);
		[PreserveSig] int get_TreeScope(out TreeScope scope);
		[PreserveSig] int put_TreeScope(TreeScope scope);
		[PreserveSig] int get_TreeFilter(out IUIAutomationCondition filter);
		[PreserveSig] int put_TreeFilter(IUIAutomationCondition filter);
		[PreserveSig] int get_AutomationElementMode(out AutomationElementMode mode);
		[PreserveSig] int put_AutomationElementMode(AutomationElementMode mode);
	}
	
	[ComImport, Guid("14314595-b4bc-4055-95f2-58f2e42c9855"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
	internal interface IUIAutomationElementArray {
		[PreserveSig] int get_Length(out int length);
		[PreserveSig] int GetElement(int index, out IUIAutomationElement element);
	}
	
	[ComImport, Guid("352ffba8-0973-437c-a61f-f64cafd81df9"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
	internal interface IUIAutomationCondition { }
	
	[Flags]
	internal enum TreeScope : uint {
		TreeScope_None,
		TreeScope_Element,
		TreeScope_Children,
		TreeScope_Descendants = 0x4,
		TreeScope_Parent = 0x8,
		TreeScope_Ancestors = 0x10,
		TreeScope_Subtree = 0x7
	}
	
	internal struct SAFEARRAY {
		public ushort cDims;
		public ushort fFeatures;
		public uint cbElements;
		public uint cLocks;
		public void* pvData;
		/*[MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)]*/
		public SAFEARRAYBOUND rgsabound;
	}
	
	internal struct SAFEARRAYBOUND {
		public uint cElements;
		public int lLbound;
	}
	
	internal enum AutomationElementMode {
		AutomationElementMode_None,
		AutomationElementMode_Full
	}
	
	internal enum StructureChangeType {
		StructureChangeType_ChildAdded,
		StructureChangeType_ChildRemoved,
		StructureChangeType_ChildrenInvalidated,
		StructureChangeType_ChildrenBulkAdded,
		StructureChangeType_ChildrenBulkRemoved,
		StructureChangeType_ChildrenReordered
	}
	
	internal enum TypeId {
		Button = 50000,
		Calendar = 50001,
		CheckBox = 50002,
		ComboBox = 50003,
		Edit = 50004,
		Hyperlink = 50005,
		Image = 50006,
		ListItem = 50007,
		List = 50008,
		Menu = 50009,
		MenuBar = 50010,
		MenuItem = 50011,
		ProgressBar = 50012,
		RadioButton = 50013,
		ScrollBar = 50014,
		Slider = 50015,
		Spinner = 50016,
		StatusBar = 50017,
		Tab = 50018,
		TabItem = 50019,
		Text = 50020,
		ToolBar = 50021,
		ToolTip = 50022,
		Tree = 50023,
		TreeItem = 50024,
		Custom = 50025,
		Group = 50026,
		Thumb = 50027,
		DataGrid = 50028,
		DataItem = 50029,
		Document = 50030,
		SplitButton = 50031,
		Window = 50032,
		Pane = 50033,
		Header = 50034,
		HeaderItem = 50035,
		Table = 50036,
		TitleBar = 50037,
		Separator = 50038,
		SemanticZoom = 50039,
		AppBar = 50040,
		CustomLandmark = 80000,
		FormLandmark = 80001,
		MainLandmark = 80002,
		NavigationLandmark = 80003,
		SearchLandmark = 80004,
	}
	
	[DllImport("oleaut32.dll", EntryPoint = "#16", PreserveSig = true)]
	internal static extern int SafeArrayDestroy(SAFEARRAY* psa);
	
	public const int UIA_TextPatternId = 10014;
	internal const int UIA_TextPattern2Id = 10024;
	
	[ComImport, Guid("32eba289-3583-42c9-9c59-3b6d9a1e9b6a"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
	public interface IUIAutomationTextPattern {
		[PreserveSig] int RangeFromPoint(POINT pt, out IUIAutomationTextRange range);
		[PreserveSig] int RangeFromChild(IUIAutomationElement child, out IUIAutomationTextRange range);
		[PreserveSig] int GetSelection(out IUIAutomationTextRangeArray ranges);
		[PreserveSig] int GetVisibleRanges(out IUIAutomationTextRangeArray ranges);
		[PreserveSig] int get_DocumentRange(out IUIAutomationTextRange range);
		[PreserveSig] int get_SupportedTextSelection(out SupportedTextSelection supportedTextSelection);
	}
	
	public enum SupportedTextSelection {
		SupportedTextSelection_None,
		SupportedTextSelection_Single,
		SupportedTextSelection_Multiple
	}
	
	[ComImport, Guid("ce4ae76a-e717-4c98-81ea-47371d028eb6"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
	public interface IUIAutomationTextRangeArray {
		[PreserveSig] int get_Length(out int length);
		[PreserveSig] int GetElement(int index, out IUIAutomationTextRange element);
	}
	
	[ComImport, Guid("a543cc6a-f4ae-494b-8239-c814481187a8"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
	public interface IUIAutomationTextRange {
		[PreserveSig] int Clone(out IUIAutomationTextRange clonedRange);
		[PreserveSig] int Compare(IUIAutomationTextRange range, [MarshalAs(UnmanagedType.Bool)] out bool areSame);
		[PreserveSig] int CompareEndpoints(TextPatternRangeEndpoint srcEndPoint, IUIAutomationTextRange range, TextPatternRangeEndpoint targetEndPoint, out int compValue);
		[PreserveSig] int ExpandToEnclosingUnit(TextUnit textUnit);
		[PreserveSig] int FindAttribute(int attr, object val, [MarshalAs(UnmanagedType.Bool)] bool backward, out IUIAutomationTextRange found);
		[PreserveSig] int FindText(string text, [MarshalAs(UnmanagedType.Bool)] bool backward, [MarshalAs(UnmanagedType.Bool)] bool ignoreCase, out IUIAutomationTextRange found);
		[PreserveSig] int GetAttributeValue(int attr, out object value);
		[PreserveSig] int GetBoundingRectangles(out SAFEARRAY* boundingRects);
		[PreserveSig] int GetEnclosingElement(out IUIAutomationElement enclosingElement);
		[PreserveSig] int GetText(int maxLength, out string text);
		[PreserveSig] int Move(TextUnit unit, int count, out int moved);
		[PreserveSig] int MoveEndpointByUnit(TextPatternRangeEndpoint endpoint, TextUnit unit, int count, out int moved);
		[PreserveSig] int MoveEndpointByRange(TextPatternRangeEndpoint srcEndPoint, IUIAutomationTextRange range, TextPatternRangeEndpoint targetEndPoint);
		[PreserveSig] int Select();
		[PreserveSig] int AddToSelection();
		[PreserveSig] int RemoveFromSelection();
		[PreserveSig] int ScrollIntoView([MarshalAs(UnmanagedType.Bool)] bool alignToTop);
		[PreserveSig] int GetChildren(out IUIAutomationElementArray children);
	}
	
	[ComImport, Guid("506a921a-fcc9-409f-b23b-37eb74106872"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
	internal interface IUIAutomationTextPattern2 : IUIAutomationTextPattern {
		// IUIAutomationTextPattern
		[PreserveSig] new int RangeFromPoint(POINT pt, out IUIAutomationTextRange range);
		[PreserveSig] new int RangeFromChild(IUIAutomationElement child, out IUIAutomationTextRange range);
		[PreserveSig] new int GetSelection(out IUIAutomationTextRangeArray ranges);
		[PreserveSig] new int GetVisibleRanges(out IUIAutomationTextRangeArray ranges);
		[PreserveSig] new int get_DocumentRange(out IUIAutomationTextRange range);
		[PreserveSig] new int get_SupportedTextSelection(out SupportedTextSelection supportedTextSelection);
		// IUIAutomationTextPattern2
		[PreserveSig] int RangeFromAnnotation(IUIAutomationElement annotation, out IUIAutomationTextRange range);
		[PreserveSig] int GetCaretRange([MarshalAs(UnmanagedType.Bool)] out bool isActive, out IUIAutomationTextRange range);
	}
	
	public enum TextUnit {
		TextUnit_Character,
		TextUnit_Format,
		TextUnit_Word,
		TextUnit_Line,
		TextUnit_Paragraph,
		TextUnit_Page,
		TextUnit_Document
	}
	
	public enum TextPatternRangeEndpoint {
		TextPatternRangeEndpoint_Start,
		TextPatternRangeEndpoint_End
	}
}


================================================
FILE: Au/Api/Api_const.cs
================================================
//Windows API constants common to multiple API functions, such as WM_, WS_, errors.

namespace Au.Types;

static unsafe partial class Api
{
	#region Errors

	internal const int S_OK = 0;
	internal const int S_FALSE = 1;
	internal const int ERROR_FILE_NOT_FOUND = 2;
	internal const int ERROR_PATH_NOT_FOUND = 3;
	internal const int ERROR_ACCESS_DENIED = 5;
	internal const int ERROR_INVALID_HANDLE = 6;
	internal const int ERROR_NOT_SAME_DEVICE = 17;
	internal const int ERROR_NO_MORE_FILES = 18;
	internal const int ERROR_NOT_READY = 21;
	internal const int ERROR_SHARING_VIOLATION = 32;
	internal const int ERROR_LOCK_VIOLATION = 33;
	internal const int ERROR_HANDLE_EOF = 38;
	internal const int ERROR_BAD_NETPATH = 53;
	internal const int ERROR_BAD_NET_NAME = 67;
	internal const int ERROR_FILE_EXISTS = 80;
	internal const int ERROR_INVALID_PARAMETER = 87;
	internal const int ERROR_BROKEN_PIPE = 109;
	internal const int ERROR_SEM_TIMEOUT = 121;
	internal const int ERROR_INSUFFICIENT_BUFFER = 122;
	internal const int ERROR_INVALID_NAME = 123;
	internal const int ERROR_DIR_NOT_EMPTY = 145;
	internal const int ERROR_ALREADY_EXISTS = 183;
	internal const int ERROR_MORE_DATA = 234;
	internal const int ERROR_DIRECTORY = 267;
	internal const int ERROR_PIPE_CONNECTED = 535;
	internal const int ERROR_IO_PENDING = 997;
	internal const int ERROR_UNABLE_TO_REMOVE_REPLACED = 1175;
	internal const int ERROR_USER_MAPPED_FILE = 1224;
	internal const int ERROR_PRIVILEGE_NOT_HELD = 1314;
	internal const int ERROR_INVALID_WINDOW_HANDLE = 1400;
	internal const int ERROR_TIMEOUT = 1460;
	internal const int E_NOTIMPL = unchecked((int)0x80004001);
	internal const int E_NOINTERFACE = unchecked((int)0x80004002);
	internal const int E_FAIL = unchecked((int)0x80004005);
	internal const int E_INVALIDARG = unchecked((int)0x80070057);
	internal const int E_ACCESSDENIED = unchecked((int)0x80070005);
	internal const int E_OUTOFMEMORY = unchecked((int)0x8007000E);
	internal const int DISP_E_MEMBERNOTFOUND = unchecked((int)0x80020003);
	internal const int REGDB_E_CLASSNOTREG = unchecked((int)0x80040154);
	internal const int RPC_E_SERVER_CANTMARSHAL_DATA = unchecked((int)0x8001000D);
	internal const int E_POINTER = unchecked((int)0x80004003);

	#endregion

	#region WM_

	internal const int WM_NULL = 0;
	internal const int WM_CREATE = 0x0001;
	internal const int WM_DESTROY = 0x0002;
	internal const int WM_MOVE = 0x0003;
	internal const int WM_SIZE = 0x0005;
	internal const int WM_ACTIVATE = 0x0006;
	internal const int WM_SETFOCUS = 0x0007;
	internal const int WM_KILLFOCUS = 0x0008;
	internal const int WM_ENABLE = 0x000A;
	internal const int WM_SETREDRAW = 0x000B;
	internal const int WM_SETTEXT = 0x000C;
	internal const int WM_GETTEXT = 0x000D;
	internal const int WM_GETTEXTLENGTH = 0x000E;
	internal const int WM_PAINT = 0x000F;
	internal const int WM_CLOSE = 0x0010;
	internal const int WM_QUERYENDSESSION = 0x0011;
	internal const int WM_QUERYOPEN = 0x0013;
	internal const int WM_ENDSESSION = 0x0016;
	internal const int WM_QUIT = 0x0012;
	internal const int WM_ERASEBKGND = 0x0014;
	internal const int WM_SYSCOLORCHANGE = 0x0015;
	internal const int WM_SHOWWINDOW = 0x0018;
	internal const int WM_SETTINGCHANGE = 0x001A;
	internal const int WM_DEVMODECHANGE = 0x001B;
	internal const int WM_ACTIVATEAPP = 0x001C;
	internal const int WM_FONTCHANGE = 0x001D;
	internal const int WM_TIMECHANGE = 0x001E;
	internal const int WM_CANCELMODE = 0x001F;
	internal const int WM_SETCURSOR = 0x0020;
	internal const int WM_MOUSEACTIVATE = 0x0021;
	internal const int WM_CHILDACTIVATE = 0x0022;
	internal const int WM_QUEUESYNC = 0x0023;
	internal const int WM_GETMINMAXINFO = 0x0024;
	internal const int WM_PAINTICON = 0x0026;
	internal const int WM_ICONERASEBKGND = 0x0027;
	internal const int WM_NEXTDLGCTL = 0x0028;
	internal const int WM_SPOOLERSTATUS = 0x002A;
	internal const int WM_DRAWITEM = 0x002B;
	internal const int WM_MEASUREITEM = 0x002C;
	internal const int WM_DELETEITEM = 0x002D;
	internal const int WM_VKEYTOITEM = 0x002E;
	internal const int WM_CHARTOITEM = 0x002F;
	internal const int WM_SETFONT = 0x0030;
	internal const int WM_GETFONT = 0x0031;
	internal const int WM_SETHOTKEY = 0x0032;
	internal const int WM_GETHOTKEY = 0x0033;
	internal const int WM_QUERYDRAGICON = 0x0037;
	internal const int WM_COMPAREITEM = 0x0039;
	internal const int WM_GETOBJECT = 0x003D;
	internal const int WM_COMPACTING = 0x0041;
	internal const int WM_WINDOWPOSCHANGING = 0x0046;
	internal const int WM_WINDOWPOSCHANGED = 0x0047;
	internal const int WM_COPYDATA = 0x004A;
	internal const int WM_CANCELJOURNAL = 0x004B;
	internal const int WM_NOTIFY = 0x004E;
	internal const int WM_INPUTLANGCHANGEREQUEST = 0x0050;
	internal const int WM_INPUTLANGCHANGE = 0x0051;
	internal const int WM_TCARD = 0x0052;
	internal const int WM_HELP = 0x0053;
	internal const int WM_USERCHANGED = 0x0054;
	internal const int WM_NOTIFYFORMAT = 0x0055;
	internal const int WM_CONTEXTMENU = 0x007B;
	internal const int WM_STYLECHANGING = 0x007C;
	internal const int WM_STYLECHANGED = 0x007D;
	internal const int WM_DISPLAYCHANGE = 0x007E;
	internal const int WM_GETICON = 0x007F;
	internal const int WM_SETICON = 0x0080;
	internal const int WM_NCCREATE = 0x0081;
	internal const int WM_NCDESTROY = 0x0082;
	internal const int WM_NCCALCSIZE = 0x0083;
	internal const int WM_NCHITTEST = 0x0084;
	internal const int WM_NCPAINT = 0x0085;
	internal const int WM_NCACTIVATE = 0x0086;
	internal const int WM_GETDLGCODE = 0x0087;
	internal const int WM_SYNCPAINT = 0x0088;
	internal const int WM_NCMOUSEMOVE = 0x00A0;
	internal const int WM_NCLBUTTONDOWN = 0x00A1;
	internal const int WM_NCLBUTTONUP = 0x00A2;
	internal const int WM_NCLBUTTONDBLCLK = 0x00A3;
	internal const int WM_NCRBUTTONDOWN = 0x00A4;
	internal const int WM_NCRBUTTONUP = 0x00A5;
	internal const int WM_NCRBUTTONDBLCLK = 0x00A6;
	internal const int WM_NCMBUTTONDOWN = 0x00A7;
	internal const int WM_NCMBUTTONUP = 0x00A8;
	internal const int WM_NCMBUTTONDBLCLK = 0x00A9;
	internal const int WM_NCXBUTTONDOWN = 0x00AB;
	internal const int WM_NCXBUTTONUP = 0x00AC;
	internal const int WM_NCXBUTTONDBLCLK = 0x00AD;
	internal const int WM_INPUT_DEVICE_CHANGE = 0x00FE;
	internal const int WM_INPUT = 0x00FF;
	internal const int WM_KEYDOWN = 0x0100;
	internal const int WM_KEYUP = 0x0101;
	internal const int WM_CHAR = 0x0102;
	internal const int WM_DEADCHAR = 0x0103;
	internal const int WM_SYSKEYDOWN = 0x0104;
	internal const int WM_SYSKEYUP = 0x0105;
	internal const int WM_SYSCHAR = 0x0106;
	internal const int WM_SYSDEADCHAR = 0x0107;
	internal const int WM_UNICHAR = 0x0109;
	internal const int WM_IME_STARTCOMPOSITION = 0x010D;
	internal const int WM_IME_ENDCOMPOSITION = 0x010E;
	internal const int WM_IME_COMPOSITION = 0x010F;
	internal const int WM_INITDIALOG = 0x0110;
	internal const int WM_COMMAND = 0x0111;
	internal const int WM_SYSCOMMAND = 0x0112;
	internal const int WM_TIMER = 0x0113;
	internal const int WM_HSCROLL = 0x0114;
	internal const int WM_VSCROLL = 0x0115;
	internal const int WM_INITMENU = 0x0116;
	internal const int WM_INITMENUPOPUP = 0x0117;
	internal const int WM_MENUSELECT = 0x011F;
	internal const int WM_MENUCHAR = 0x0120;
	internal const int WM_ENTERIDLE = 0x0121;
	internal const int WM_MENURBUTTONUP = 0x0122;
	internal const int WM_MENUDRAG = 0x0123;
	internal const int WM_MENUGETOBJECT = 0x0124;
	internal const int WM_UNINITMENUPOPUP = 0x0125;
	internal const int WM_MENUCOMMAND = 0x0126;
	internal const int WM_CHANGEUISTATE = 0x0127;
	internal const int WM_UPDATEUISTATE = 0x0128;
	internal const int WM_QUERYUISTATE = 0x0129;
	internal const int WM_CTLCOLORMSGBOX = 0x0132;
	internal const int WM_CTLCOLOREDIT = 0x0133;
	internal const int WM_CTLCOLORLISTBOX = 0x0134;
	internal const int WM_CTLCOLORBTN = 0x0135;
	internal const int WM_CTLCOLORDLG = 0x0136;
	internal const int WM_CTLCOLORSCROLLBAR = 0x0137;
	internal const int WM_CTLCOLORSTATIC = 0x0138;
	internal const int WM_MOUSEFIRST = 0x0200;
	internal const int WM_MOUSEMOVE = 0x0200;
	internal const int WM_LBUTTONDOWN = 0x0201;
	internal const int WM_LBUTTONUP = 0x0202;
	internal const int WM_LBUTTONDBLCLK = 0x0203;
	internal const int WM_RBUTTONDOWN = 0x0204;
	internal const int WM_RBUTTONUP = 0x0205;
	internal const int WM_RBUTTONDBLCLK = 0x0206;
	internal const int WM_MBUTTONDOWN = 0x0207;
	internal const int WM_MBUTTONUP = 0x0208;
	internal const int WM_MBUTTONDBLCLK = 0x0209;
	internal const int WM_MOUSEWHEEL = 0x020A;
	internal const int WM_XBUTTONDOWN = 0x020B;
	internal const int WM_XBUTTONUP = 0x020C;
	internal const int WM_XBUTTONDBLCLK = 0x020D;
	internal const int WM_MOUSEHWHEEL = 0x020E;
	internal const int WM_MOUSELAST = 0x020E;
	internal const int WM_PARENTNOTIFY = 0x0210;
	internal const int WM_ENTERMENULOOP = 0x0211;
	internal const int WM_EXITMENULOOP = 0x0212;
	internal const int WM_NEXTMENU = 0x0213;
	internal const int WM_SIZING = 0x0214;
	internal const int WM_CAPTURECHANGED = 0x0215;
	internal const int WM_MOVING = 0x0216;
	internal const int WM_POWERBROADCAST = 0x0218;
	internal const int WM_DEVICECHANGE = 0x0219;
	internal const int WM_MDICREATE = 0x0220;
	internal const int WM_MDIDESTROY = 0x0221;
	internal const int WM_MDIACTIVATE = 0x0222;
	internal const int WM_MDIRESTORE = 0x0223;
	internal const int WM_MDINEXT = 0x0224;
	internal const int WM_MDIMAXIMIZE = 0x0225;
	internal const int WM_MDITILE = 0x0226;
	internal const int WM_MDICASCADE = 0x0227;
	internal const int WM_MDIICONARRANGE = 0x0228;
	internal const int WM_MDIGETACTIVE = 0x0229;
	internal const int WM_MDISETMENU = 0x0230;
	internal const int WM_ENTERSIZEMOVE = 0x0231;
	internal const int WM_EXITSIZEMOVE = 0x0232;
	internal const int WM_DROPFILES = 0x0233;
	internal const int WM_MDIREFRESHMENU = 0x0234;
	internal const int WM_IME_SETCONTEXT = 0x0281;
	internal const int WM_IME_NOTIFY = 0x0282;
	internal const int WM_IME_CONTROL = 0x0283;
	internal const int WM_IME_COMPOSITIONFULL = 0x0284;
	internal const int WM_IME_SELECT = 0x0285;
	internal const int WM_IME_CHAR = 0x0286;
	internal const int WM_IME_REQUEST = 0x0288;
	internal const int WM_IME_KEYDOWN = 0x0290;
	internal const int WM_IME_KEYUP = 0x0291;
	internal const int WM_MOUSEHOVER = 0x02A1;
	internal const int WM_MOUSELEAVE = 0x02A3;
	internal const int WM_NCMOUSEHOVER = 0x02A0;
	internal const int WM_NCMOUSELEAVE = 0x02A2;
	internal const int WM_WTSSESSION_CHANGE = 0x02B1;
	internal const int WM_DPICHANGED = 0x2E0;
	internal const int WM_DPICHANGED_BEFOREPARENT = 0x2E2;
	internal const int WM_DPICHANGED_AFTERPARENT = 0x02E3;
	internal const int WM_GETDPISCALEDSIZE = 0x02E4;
	internal const int WM_CUT = 0x0300;
	internal const int WM_COPY = 0x0301;
	internal const int WM_PASTE = 0x0302;
	internal const int WM_CLEAR = 0x0303;
	internal const int WM_UNDO = 0x0304;
	internal const int WM_RENDERFORMAT = 0x0305;
	internal const int WM_RENDERALLFORMATS = 0x0306;
	internal const int WM_DESTROYCLIPBOARD = 0x0307;
	internal const int WM_DRAWCLIPBOARD = 0x0308;
	internal const int WM_PAINTCLIPBOARD = 0x0309;
	internal const int WM_VSCROLLCLIPBOARD = 0x030A;
	internal const int WM_SIZECLIPBOARD = 0x030B;
	internal const int WM_ASKCBFORMATNAME = 0x030C;
	internal const int WM_CHANGECBCHAIN = 0x030D;
	internal const int WM_HSCROLLCLIPBOARD = 0x030E;
	internal const int WM_QUERYNEWPALETTE = 0x030F;
	internal const int WM_PALETTEISCHANGING = 0x0310;
	internal const int WM_PALETTECHANGED = 0x0311;
	internal const int WM_HOTKEY = 0x0312;
	internal const int WM_PRINT = 0x0317;
	internal const int WM_PRINTCLIENT = 0x0318;
	internal const int WM_APPCOMMAND = 0x0319;
	internal const int WM_THEMECHANGED = 0x031A;
	internal const int WM_CLIPBOARDUPDATE = 0x031D;
	internal const int WM_DWMCOMPOSITIONCHANGED = 0x031E;
	internal const int WM_DWMNCRENDERINGCHANGED = 0x031F;
	internal const int WM_DWMCOLORIZATIONCOLORCHANGED = 0x0320;
	internal const int WM_DWMWINDOWMAXIMIZEDCHANGE = 0x0321;
	internal const int WM_GETTITLEBARINFOEX = 0x033F;
	internal const int WM_APP = 0x8000;
	internal const int WM_USER = 0x0400;

	internal const int WM_CPL_LAUNCH = WM_USER + 0x1000;
	internal const int WM_CPL_LAUNCHED = WM_USER + 0x1001;
	internal const int WM_SYSTIMER = 0x118;
	internal const int WM_HSHELL_ACCESSIBILITYSTATE = 11;
	internal const int WM_HSHELL_ACTIVATESHELLWINDOW = 3;
	internal const int WM_HSHELL_APPCOMMAND = 12;
	internal const int WM_HSHELL_GETMINRECT = 5;
	internal const int WM_HSHELL_LANGUAGE = 8;
	internal const int WM_HSHELL_REDRAW = 6;
	internal const int WM_HSHELL_TASKMAN = 7;
	internal const int WM_HSHELL_WINDOWCREATED = 1;
	internal const int WM_HSHELL_WINDOWDESTROYED = 2;
	internal const int WM_HSHELL_WINDOWACTIVATED = 4;
	internal const int WM_HSHELL_WINDOWREPLACED = 13;

	internal const int WM_REFLECT = 0x2000;

	#endregion

	#region control styles, messages etc

	//ES_, EM_, EN_
	internal const WS ES_MULTILINE = (WS)0x4;
	internal const WS ES_PASSWORD = (WS)0x20;
	internal const WS ES_AUTOVSCROLL = (WS)0x40;
	internal const WS ES_AUTOHSCROLL = (WS)0x80;
	internal const WS ES_WANTRETURN = (WS)0x1000;
	internal const WS ES_NUMBER = (WS)0x2000;

	internal const int EM_SETSEL = 0xB1;
	internal const int EM_SETCUEBANNER = 0x1501;

	//CBS_, CB_, CBN_
	internal const WS CBS_SIMPLE = (WS)1;
	internal const WS CBS_DROPDOWN = (WS)2;
	internal const WS CBS_DROPDOWNLIST = (WS)3;
	internal const WS CBS_AUTOHSCROLL = (WS)0x40;

	internal const int CB_INSERTSTRING = 330;
	internal const int CB_SETCUEBANNER = 0x1703;

	internal const int MN_GETHMENU = 0x1E1;

	#endregion

	#region CS_

	internal const uint CS_VREDRAW = 0x1;
	internal const uint CS_HREDRAW = 0x2;
	internal const uint CS_DBLCLKS = 0x8;
	internal const uint CS_OWNDC = 0x20;
	internal const uint CS_CLASSDC = 0x40;
	internal const uint CS_PARENTDC = 0x80;
	internal const uint CS_NOCLOSE = 0x200;
	internal const uint CS_SAVEBITS = 0x800;
	internal const uint CS_BYTEALIGNCLIENT = 0x1000;
	internal const uint CS_BYTEALIGNWINDOW = 0x2000;
	internal const uint CS_GLOBALCLASS = 0x4000;
	internal const uint CS_IME = 0x10000;
	internal const uint CS_DROPSHADOW = 0x20000;

	#endregion

	#region HT (hit-test)

	internal const int HTERROR = -2;
	internal const int HTTRANSPARENT = -1;
	internal const int HTNOWHERE = 0;
	internal const int HTCLIENT = 1;
	internal const int HTCAPTION = 2;
	internal const int HTSYSMENU = 3;
	internal const int HTSIZE = 4;
	internal const int HTMENU = 5;
	internal const int HTHSCROLL = 6;
	internal const int HTVSCROLL = 7;
	internal const int HTMINBUTTON = 8;
	internal const int HTMAXBUTTON = 9;
	internal const int HTLEFT = 10;
	internal const int HTRIGHT = 11;
	internal const int HTTOP = 12;
	internal const int HTTOPLEFT = 13;
	internal const int HTTOPRIGHT = 14;
	internal const int HTBOTTOM = 15;
	internal const int HTBOTTOMLEFT = 16;
	internal const int HTBOTTOMRIGHT = 17;
	internal const int HTBORDER = 18;
	internal const int HTOBJECT = 19;
	internal const int HTCLOSE = 20;
	internal const int HTHELP = 21;
	internal const int HTSIZEFIRST = HTLEFT;
	internal const int HTSIZELAST = HTBOTTOMRIGHT;

	#endregion

	#region SC_
	internal const int SC_SIZE = 0xF000;
	internal const int SC_MOVE = 0xF010;
	internal const int SC_MINIMIZE = 0xF020;
	internal const int SC_MAXIMIZE = 0xF030;
	internal const int SC_NEXTWINDOW = 0xF040;
	internal const int SC_PREVWINDOW = 0xF050;
	internal const int SC_CLOSE = 0xF060;
	internal const int SC_VSCROLL = 0xF070;
	internal const int SC_HSCROLL = 0xF080;
	internal const int SC_MOUSEMENU = 0xF090;
	internal const int SC_KEYMENU = 0xF100;
	internal const int SC_ARRANGE = 0xF110;
	internal const int SC_RESTORE = 0xF120;
	internal const int SC_TASKLIST = 0xF130;
	internal const int SC_SCREENSAVE = 0xF140;
	internal const int SC_HOTKEY = 0xF150;
	internal const int SC_DEFAULT = 0xF160;
	internal const int SC_MONITORPOWER = 0xF170;
	internal const int SC_CONTEXTHELP = 0xF180;
	internal const int SC_SEPARATOR = 0xF00F;
	#endregion

	#region COLOR_

	internal const int COLOR_SCROLLBAR = 0;
	internal const int COLOR_BACKGROUND = 1;
	internal const int COLOR_ACTIVECAPTION = 2;
	internal const int COLOR_INACTIVECAPTION = 3;
	internal const int COLOR_MENU = 4;
	internal const int COLOR_WINDOW = 5;
	internal const int COLOR_WINDOWFRAME = 6;
	internal const int COLOR_MENUTEXT = 7;
	internal const int COLOR_WINDOWTEXT = 8;
	internal const int COLOR_CAPTIONTEXT = 9;
	internal const int COLOR_ACTIVEBORDER = 10;
	internal const int COLOR_INACTIVEBORDER = 11;
	internal const int COLOR_APPWORKSPACE = 12;
	internal const int COLOR_HIGHLIGHT = 13;
	internal const int COLOR_HIGHLIGHTTEXT = 14;
	internal const int COLOR_BTNFACE = 15;
	internal const int COLOR_BTNSHADOW = 16;
	internal const int COLOR_GRAYTEXT = 17;
	internal const int COLOR_BTNTEXT = 18;
	internal const int COLOR_INACTIVECAPTIONTEXT = 19;
	internal const int COLOR_BTNHIGHLIGHT = 20;
	internal const int COLOR_3DDKSHADOW = 21;
	internal const int COLOR_3DLIGHT = 22;
	internal const int COLOR_INFOTEXT = 23;
	internal const int COLOR_INFOBK = 24;
	internal const int COLOR_HOTLIGHT = 26;
	internal const int COLOR_GRADIENTACTIVECAPTION = 27;
	internal const int COLOR_GRADIENTINACTIVECAPTION = 28;
	internal const int COLOR_MENUHILIGHT = 29;
	internal const int COLOR_MENUBAR = 30;
	internal const int COLOR_DESKTOP = 1;
	internal const int COLOR_3DFACE = 15;
	internal const int COLOR_3DSHADOW = 16;
	internal const int COLOR_3DHIGHLIGHT = 20;
	internal const int COLOR_3DHILIGHT = 20;
	internal const int COLOR_BTNHILIGHT = 20;

	#endregion

	#region QS_

	internal const uint QS_KEY = 0x1;
	internal const uint QS_MOUSEMOVE = 0x2;
	internal const uint QS_MOUSEBUTTON = 0x4;
	internal const uint QS_POSTMESSAGE = 0x8;
	internal const uint QS_TIMER = 0x10;
	internal const uint QS_PAINT = 0x20;
	internal const uint QS_SENDMESSAGE = 0x40;
	internal const uint QS_HOTKEY = 0x80;
	internal const uint QS_ALLPOSTMESSAGE = 0x100;
	internal const uint QS_RAWINPUT = 0x400;
	internal const uint QS_TOUCH = 0x800;
	internal const uint QS_POINTER = 0x1000;
	internal const uint QS_MOUSE = 0x6;
	internal const uint QS_INPUT = 0x1C07;
	internal const uint QS_ALLEVENTS = 0x1CBF;
	internal const uint QS_ALLINPUT = 0x1CFF;

	#endregion

	#region WAIT_

	internal const int WAIT_FAILED = -1;
	internal const int WAIT_OBJECT_0 = 0x0;
	internal const int WAIT_ABANDONED = 0x80;
	internal const int WAIT_ABANDONED_0 = 0x80;
	internal const int WAIT_IO_COMPLETION = 0xC0;
	internal const int WAIT_TIMEOUT = 0x102;

	#endregion

	#region LR_, IMAGE_

	internal const int IMAGE_BITMAP = 0;
	internal const int IMAGE_ICON = 1;
	internal const int IMAGE_CURSOR = 2;
	internal const uint LR_MONOCHROME = 0x1;
	internal const uint LR_COLOR = 0x2;
	internal const uint LR_COPYRETURNORG = 0x4;
	internal const uint LR_COPYDELETEORG = 0x8;
	internal const uint LR_LOADFROMFILE = 0x10;
	internal const uint LR_LOADTRANSPARENT = 0x20;
	internal const uint LR_DEFAULTSIZE = 0x40;
	internal const uint LR_VGACOLOR = 0x80;
	internal const uint LR_LOADMAP3DCOLORS = 0x1000;
	internal const uint LR_CREATEDIBSECTION = 0x2000;
	internal const uint LR_COPYFROMRESOURCE = 0x4000;
	internal const uint LR_SHARED = 0x8000;

	#endregion

	#region SFGAO_

	internal const uint SFGAO_CANCOPY = 1;
	internal const uint SFGAO_CANMOVE = 2;
	internal const uint SFGAO_CANLINK = 4;
	internal const uint SFGAO_STORAGE = 0x00000008;
	internal const uint SFGAO_CANRENAME = 0x00000010;
	internal const uint SFGAO_CANDELETE = 0x00000020;
	internal const uint SFGAO_HASPROPSHEET = 0x00000040;
	internal const uint SFGAO_DROPTARGET = 0x00000100;
	internal const uint SFGAO_CAPABILITYMASK = 0x00000177;
	internal const uint SFGAO_SYSTEM = 0x00001000;
	internal const uint SFGAO_ENCRYPTED = 0x00002000;
	internal const uint SFGAO_ISSLOW = 0x00004000;
	internal const uint SFGAO_GHOSTED = 0x00008000;
	internal const uint SFGAO_LINK = 0x00010000;
	internal const uint SFGAO_SHARE = 0x00020000;
	internal const uint SFGAO_READONLY = 0x00040000;
	internal const uint SFGAO_HIDDEN = 0x00080000;
	internal const uint SFGAO_DISPLAYATTRMASK = 0x000FC000;
	internal const uint SFGAO_FILESYSANCESTOR = 0x10000000;
	internal const uint SFGAO_FOLDER = 0x20000000;
	internal const uint SFGAO_FILESYSTEM = 0x40000000;
	internal const uint SFGAO_HASSUBFOLDER = 0x80000000;
	internal const uint SFGAO_CONTENTSMASK = 0x80000000;
	internal const uint SFGAO_VALIDATE = 0x01000000;
	internal const uint SFGAO_REMOVABLE = 0x02000000;
	internal const uint SFGAO_COMPRESSED = 0x04000000;
	internal const uint SFGAO_BROWSABLE = 0x08000000;
	internal const uint SFGAO_NONENUMERATED = 0x00100000;
	internal const uint SFGAO_NEWCONTENT = 0x00200000;
	internal const uint SFGAO_CANMONIKER = 0x00400000;
	internal const uint SFGAO_HASSTORAGE = 0x00400000;
	internal const uint SFGAO_STREAM = 0x00400000;
	internal const uint SFGAO_STORAGEANCESTOR = 0x00800000;
	internal const uint SFGAO_STORAGECAPMASK = 0x70C50008;
	internal const uint SFGAO_PKEYSFGAOMASK = 0x81044000;

	#endregion

	#region STGM_

	internal const uint STGM_DIRECT = 0x0;
	internal const uint STGM_TRANSACTED = 0x10000;
	internal const uint STGM_SIMPLE = 0x8000000;
	internal const uint STGM_READ = 0x0;
	internal const uint STGM_WRITE = 0x1;
	internal const uint STGM_READWRITE = 0x2;
	internal const uint STGM_SHARE_DENY_NONE = 0x40;
	internal const uint STGM_SHARE_DENY_READ = 0x30;
	internal const uint STGM_SHARE_DENY_WRITE = 0x20;
	internal const uint STGM_SHARE_EXCLUSIVE = 0x10;
	internal const uint STGM_PRIORITY = 0x40000;
	internal const uint STGM_DELETEONRELEASE = 0x4000000;
	internal const uint STGM_NOSCRATCH = 0x100000;
	internal const uint STGM_CREATE = 0x1000;
	internal const uint STGM_CONVERT = 0x20000;
	internal const uint STGM_FAILIFTHERE = 0x0;
	internal const uint STGM_NOSNAPSHOT = 0x200000;
	internal const uint STGM_DIRECT_SWMR = 0x400000;

	#endregion

	#region MA_
	internal const int MA_ACTIVATE = 1;
	internal const int MA_ACTIVATEANDEAT = 2;
	internal const int MA_NOACTIVATE = 3;
	internal const int MA_NOACTIVATEANDEAT = 4;
	#endregion

	#region MK_

	internal const int MK_LBUTTON = 0x1;
	internal const int MK_RBUTTON = 0x2;
	internal const int MK_SHIFT = 0x4;
	internal const int MK_CONTROL = 0x8;
	internal const int MK_MBUTTON = 0x10;

	#endregion

	#region CF_

	internal const int CF_TEXT = 1;
	internal const int CF_BITMAP = 2;
	internal const int CF_METAFILEPICT = 3;
	internal const int CF_SYLK = 4;
	internal const int CF_DIF = 5;
	internal const int CF_TIFF = 6;
	internal const int CF_OEMTEXT = 7;
	internal const int CF_DIB = 8;
	internal const int CF_PALETTE = 9;
	//internal const int CF_PENDATA = 10; //obsolete
	internal const int CF_RIFF = 11;
	internal const int CF_WAVE = 12;
	internal const int CF_UNICODETEXT = 13;
	internal const int CF_ENHMETAFILE = 14;
	internal const int CF_HDROP = 15;
	internal const int CF_LOCALE = 16;
	internal const int CF_DIBV5 = 17;
	internal const int CF_MAX = 18;
	//internal const int CF_OWNERDISPLAY = 0x80; //these are rare and not supported by this library
	//internal const int CF_DSPTEXT = 0x81;
	//internal const int CF_DSPBITMAP = 0x82;
	//internal const int CF_DSPMETAFILEPICT = 0x83;
	//internal const int CF_DSPENHMETAFILE = 0x8E;
	//internal const int CF_PRIVATEFIRST = 0x200;
	//internal const int CF_PRIVATELAST = 0x2FF;
	//internal const int CF_GDIOBJFIRST = 0x300;
	//internal const int CF_GDIOBJLAST = 0x3FF;

	#endregion

	#region misc

	internal const int IDI_APPLICATION = 32512;
	internal const int PBT_APMSUSPEND = 0x4;

	#endregion






	#region ENUM

	[Flags]
	internal enum VARENUM : ushort
	{
		VT_EMPTY,
		VT_NULL,
		VT_I2,
		VT_I4,
		VT_R4,
		VT_R8,
		VT_CY,
		VT_DATE,
		VT_BSTR,
		VT_DISPATCH,
		VT_ERROR,
		VT_BOOL,
		VT_VARIANT,
		VT_UNKNOWN,
		VT_DECIMAL,
		VT_I1 = 16,
		VT_UI1,
		VT_UI2,
		VT_UI4,
		VT_I8,
		VT_UI8,
		VT_INT,
		VT_UINT,
		VT_VOID,
		VT_HRESULT,
		VT_PTR,
		VT_SAFEARRAY,
		VT_CARRAY,
		VT_USERDEFINED,
		VT_LPSTR,
		VT_LPWSTR,
		VT_RECORD = 36,
		VT_INT_PTR,
		VT_UINT_PTR,
		VT_FILETIME = 64,
		VT_BLOB,
		VT_STREAM,
		VT_STORAGE,
		VT_STREAMED_OBJECT,
		VT_STORED_OBJECT,
		VT_BLOB_OBJECT,
		VT_CF,
		VT_CLSID,
		VT_VERSIONED_STREAM,
		VT_BSTR_BLOB = 0xFFF,
		VT_VECTOR,
		VT_ARRAY = 0x2000,
		VT_BYREF = 0x4000,
		VT_RESERVED = 0x8000,
		VT_ILLEGAL = 0xFFFF,
		VT_ILLEGALMASKED = 0xFFF,
		VT_TYPEMASK = 0xFFF
	}

	#endregion

	#region strings

	internal const string string_IES = "Internet Explorer_Server";


	#endregion
}


================================================
FILE: Au/Api/Api_public.cs
================================================
#pragma warning disable 649, 169 //field never assigned/used
#pragma warning disable 1591 //missing XML documentation

namespace Au.Types;

/// <summary>
/// Window styles.
/// </summary>
/// <remarks>
/// Reference: <ms>Window Styles</ms>.
/// Here names are without prefix <c>WS_</c>. For example, instead of <c>WS_BORDER</c> use <c>WS.BORDER</c>. Not included constants that are 0 (eg <c>WS_TILED</c>) or are duplicate (eg <c>WS_SIZEBOX</c> is same as <c>WS_THICKFRAME</c>) or consist of multiple other constants (eg <c>WS_TILEDWINDOW</c>).
/// </remarks>
[Flags]
public enum WS : uint {
	POPUP = 0x80000000,
	CHILD = 0x40000000,
	MINIMIZE = 0x20000000,
	VISIBLE = 0x10000000,
	DISABLED = 0x08000000,
	CLIPSIBLINGS = 0x04000000,
	CLIPCHILDREN = 0x02000000,
	MAXIMIZE = 0x01000000,
	BORDER = 0x00800000,
	DLGFRAME = 0x00400000,
	VSCROLL = 0x00200000,
	HSCROLL = 0x00100000,
	SYSMENU = 0x00080000,
	THICKFRAME = 0x00040000,
	MINIMIZEBOX = 0x00020000,
	GROUP = 0x00020000,
	MAXIMIZEBOX = 0x00010000,
	TABSTOP = 0x00010000,
	CAPTION = BORDER | DLGFRAME,
	//these can cause bugs and confusion because consist of several styles. Not useful in C#, because used only to create native windows.
	//OVERLAPPEDWINDOW = CAPTION | SYSMENU | THICKFRAME | MINIMIZEBOX | MAXIMIZEBOX,
	//POPUPWINDOW = POPUP | BORDER | SYSMENU,
}

/// <summary>
/// Window extended styles.
/// </summary>
/// <remarks>
/// Reference: <ms>Extended Window Styles</ms>.
/// Here names are without prefix <c>WS_EX_</c>. For example, instead of <c>WS_EX_TOOLWINDOW</c> use <c>WSE.TOOLWINDOW</c>. Not included constants that are 0 (eg <c>WS_EX_LEFT</c>).
/// </remarks>
[Flags]
public enum WSE : uint {
	DLGMODALFRAME = 0x00000001,
	NOPARENTNOTIFY = 0x00000004,
	TOPMOST = 0x00000008,
	ACCEPTFILES = 0x00000010,
	TRANSPARENT = 0x00000020,
	MDICHILD = 0x00000040,
	TOOLWINDOW = 0x00000080,
	WINDOWEDGE = 0x00000100,
	CLIENTEDGE = 0x00000200,
	CONTEXTHELP = 0x00000400,
	//LEFT = 0x00000000,
	RIGHT = 0x00001000,
	//LTRREADING = 0x00000000,
	RTLREADING = 0x00002000,
	//RIGHTSCROLLBAR = 0x00000000,
	LEFTSCROLLBAR = 0x00004000,
	CONTROLPARENT = 0x00010000,
	STATICEDGE = 0x00020000,
	APPWINDOW = 0x00040000,
	LAYERED = 0x00080000,
	NOINHERITLAYOUT = 0x00100000,
	NOREDIRECTIONBITMAP = 0x00200000,
	LAYOUTRTL = 0x00400000,
	COMPOSITED = 0x02000000,
	NOACTIVATE = 0x08000000,
}

/// <summary>API <ms>MSG</ms></summary>
public struct MSG //WinMSG
{
	public wnd hwnd;
	public int message;
	public nint wParam;
	public nint lParam;
	public int time;
	public POINT pt;

	public override string ToString() {
		WndUtil.PrintMsg(out string s, this, new() { Indent = false, Number = false });
		return s;
	}

	public static implicit operator MSG(in System.Windows.Forms.Message m)
		=> new MSG { hwnd = (wnd)m.HWnd, message = m.Msg, wParam = m.WParam, lParam = m.LParam };

	public static implicit operator MSG(in System.Windows.Interop.MSG m)
		=> new MSG { hwnd = (wnd)m.hwnd, message = m.message, wParam = m.wParam, lParam = m.lParam, time = m.time, pt = (m.pt_x, m.pt_y) };
}

/// <summary><see cref="GUITHREADINFO"/> flags.</summary>
[Flags]
public enum GTIFlags {
	CARETBLINKING = 0x1,
	INMOVESIZE = 0x2,
	INMENUMODE = 0x4,
	SYSTEMMENUMODE = 0x8,
	POPUPMENUMODE = 0x10,
}

/// <summary>API <ms>GUITHREADINFO</ms></summary>
public struct GUITHREADINFO {
	public int cbSize;
	public GTIFlags flags;
	public wnd hwndActive;
	public wnd hwndFocus;
	public wnd hwndCapture;
	public wnd hwndMenuOwner;
	public wnd hwndMoveSize;
	public wnd hwndCaret;
	public RECT rcCaret;
}

/// <summary>API <ms>CREATESTRUCT</ms></summary>
public unsafe struct CREATESTRUCT {
	public nint lpCreateParams;
	public IntPtr hInstance;
	public nint hMenu;
	public wnd hwndParent;
	public int cy;
	public int cx;
	public int y;
	public int x;
	public WS style;
	public char* lpszName;
	public char* lpszClass;
	public WSE dwExStyle;

	public RStr Name => lpszName == default ? default
		: new RStr(lpszName, Ptr_.Length(lpszName));
	//public string Name => lpszName == default ? null : new string(lpszName);

	/// <summary>
	/// If <c>lpszClass</c> is atom, returns string with <c>#</c> prefix and atom value, like <c>"#32770"</c>.
	/// </summary>
	public RStr ClassName => (nuint)lpszClass < 0x10000 ? "#" + ((int)lpszClass).ToS()
		: new RStr(lpszClass, Ptr_.Length(lpszClass));
	//public string ClassName => (nuint)lpszClass < 0x10000 ? "#" + ((int)lpszClass).ToS() : new string(lpszClass);

	//tested and documented: CBT hook can change only x y cx cy.
}

/// <summary>API <ms>SIGDN</ms></summary>
public enum SIGDN : uint {
	NORMALDISPLAY,
	PARENTRELATIVEPARSING = 0x80018001,
	DESKTOPABSOLUTEPARSING = 0x80028000,
	PARENTRELATIVEEDITING = 0x80031001,
	DESKTOPABSOLUTEEDITING = 0x8004C000,
	FILESYSPATH = 0x80058000,
	URL = 0x80068000,
	PARENTRELATIVEFORADDRESSBAR = 0x8007C001,
	PARENTRELATIVE = 0x80080001,
	PARENTRELATIVEFORUI = 0x80094001
}

/// <summary>API <ms>SetWindowPos</ms> flags. Can be used with <see cref="wnd.SetWindowPos"/>.</summary>
[Flags]
public enum SWPFlags : uint {
	NOSIZE = 0x1,
	NOMOVE = 0x2,
	NOZORDER = 0x4,
	NOREDRAW = 0x8,
	NOACTIVATE = 0x10,
	FRAMECHANGED = 0x20,
	SHOWWINDOW = 0x40,
	HIDEWINDOW = 0x80,
	NOCOPYBITS = 0x100,
	NOOWNERZORDER = 0x200,
	NOSENDCHANGING = 0x400,
	_NOCLIENTSIZE = 0x800,
	_NOCLIENTMOVE = 0x1000,
	DEFERERASE = 0x2000,
	ASYNCWINDOWPOS = 0x4000,
	_STATECHANGED = 0x8000,
	//_10000000 = 0x10000000,
	_KNOWNFLAGS = 0xffff,

	//the undocumented flags would break ToString() if not defined
}

/// <summary>
/// Special window handle values. Can be used with <see cref="wnd.SetWindowPos"/>.
/// See API <ms>SetWindowPos</ms>.
/// </summary>
public enum SpecHWND {
	TOP = 0,
	BOTTOM = 1,
	TOPMOST = -1,
	NOTOPMOST = -2,
	MESSAGE = -3,
	BROADCAST = 0xffff,
}

/// <summary>
/// Window long constants. Used with <see cref="wnd.GetWindowLong"/> and <see cref="wnd.SetWindowLong"/>.
/// See API <ms>GetWindowLong</ms>. See also API <ms>SetWindowSubclass</ms>.
/// </summary>
public static class GWL {
	public const int WNDPROC = -4;
	public const int USERDATA = -21;
	public const int STYLE = -16;
	public const int ID = -12;
	public const int HWNDPARENT = -8;
	public const int HINSTANCE = -6;
	public const int EXSTYLE = -20;
	//info: also there are GWLP_, but their values are the same.

	public static class DWL {
		public static readonly int MSGRESULT = 0;
		public static readonly int DLGPROC = IntPtr.Size;
		public static readonly int USER = IntPtr.Size * 2;
	}
}

/// <summary>
/// Window class long constants. Used with <see cref="WndUtil.GetClassLong"/>.
/// See API <ms>WNDCLASSEX</ms>, <ms>GetClassLong</ms>.
/// </summary>
public static class GCL {
	public const int ATOM = -32;
	public const int WNDPROC = -24;
	public const int STYLE = -26;
	public const int MENUNAME = -8;
	public const int HMODULE = -16;
	public const int HICONSM = -34;
	public const int HICON = -14;
	public const int HCURSOR = -12;
	public const int HBRBACKGROUND = -10;
	public const int CBWNDEXTRA = -18;
	public const int CBCLSEXTRA = -20;
	//info: also there are GCLP_, but their values are the same.
}

/// <summary>API <ms>WNDPROC</ms></summary>
public delegate nint WNDPROC(wnd w, int msg, nint wp, nint lp);

/// <summary>API <ms>SendMessageTimeout</ms> flags. Used with <see cref="wnd.SendTimeout"/>.</summary>
[Flags]
public enum SMTFlags : uint {
	BLOCK = 0x0001,
	ABORTIFHUNG = 0x0002,
	NOTIMEOUTIFNOTHUNG = 0x0008,
	ERRORONEXIT = 0x0020,
}

/// <summary>API <ms>DrawTextEx</ms> format flags.</summary>
[Flags]
public enum TFFlags {
	CENTER = 0x1,
	RIGHT = 0x2,
	VCENTER = 0x4,
	BOTTOM = 0x8,
	WORDBREAK = 0x10,
	SINGLELINE = 0x20,
	EXPANDTABS = 0x40,
	TABSTOP = 0x80,
	NOCLIP = 0x100,
	EXTERNALLEADING = 0x200,
	CALCRECT = 0x400,
	NOPREFIX = 0x800,
	INTERNAL = 0x1000,
	EDITCONTROL = 0x2000,
	PATH_ELLIPSIS = 0x4000,
	END_ELLIPSIS = 0x8000,
	MODIFYSTRING = 0x10000,
	RTLREADING = 0x20000,
	WORD_ELLIPSIS = 0x40000,
	NOFULLWIDTHCHARBREAK = 0x80000,
	HIDEPREFIX = 0x100000,
	PREFIXONLY = 0x200000
}


================================================
FILE: Au/Api/Cpp.cs
================================================
using static Au.Types.GWL;

namespace Au.Types;

[DebuggerStepThrough]
static unsafe partial class Cpp {
	static List<(string dll, nint h)> _dlls = [];

	static Cpp() {
		LoadAuNativeDll("AuCpp.dll");

		Cpp_SetHelperCallback(&_HelperCallback); //note: not in elm ctor. Eg by the elm tool not via elm. Fast.
	}

	/// <summary>
	/// Loads correct 64/32/ARM64 version of a private native dll. Then <c>[DllImport]</c> will use it.
	/// Used for Au dlls (AuCpp) and LA dlls (Scintilla).
	/// </summary>
	/// <param name="fileName">Dll file name like <c>"name.dll"</c>.</param>
	/// <returns>Handle.</returns>
	/// <exception cref="DllNotFoundException"></exception>
	/// <remarks>
	/// Searches in:
	/// - subfolder <c>64</c> or <c>32</c> or <c>64\ARM</c> of the <c>Au.dll</c> folder.
	/// - calls <c>NativeLibrary.TryLoad</c>, which works like simple <c>[DllImport]</c>, eg may use info from <c>deps.json</c>.
	/// - subfolder <c>64</c> etc of folder specified in environment variable <c>Au.Path</c>. For example the dll is unavailable if used in an assembly (managed dll) loaded in a nonstandard environment, eg VS forms designer or VS C# Interactive (then <c>folders.ThisApp</c> is <c>"C:\Program Files (x86)\Microsoft Visual Studio\..."</c>). Workaround: set environment variable <c>Au.Path</c> = the main Au directory and restart Windows.
	/// </remarks>
	public static nint LoadAuNativeDll(string fileName) {
		//Debug.Assert(default == Api.GetModuleHandle(fileName)); //no, asserts if cpp dll is injected by acc
		
		nint h = 0;
		string rel = (RuntimeInformation.ProcessArchitecture switch { Architecture.X86 => @"32\", Architecture.Arm64 => @"64\ARM\", _ => @"64\" }) + fileName;
		//rejected: use standard NuGet "runtimes" folder instead. I did not find info whether it can be used.

		//Au.dll dir + rel
		var asm = typeof(Cpp).Assembly;
		if (asm.Location is [_, ..] s1) {
			s1 = s1[..(s1.LastIndexOf('\\') + 1)] + rel;
			if (NativeLibrary.TryLoad(s1, out h)) return h;
		}

		//like [DllImport]. It uses NATIVE_DLL_SEARCH_DIRECTORIES, which was built at startup by our AppHost or from deps.json.
		//	Also finds in temp dir when <PublishSingleFile>+<IncludeNativeLibrariesForSelfExtract>.
		if (NativeLibrary.TryLoad(fileName, asm, null, out h)) return h;

		//environment variable + rel
		if (Environment.GetEnvironmentVariable("Au.Path") is string s2)
			if (NativeLibrary.TryLoad(pathname.combine(s2, rel), out h)) return h;

		throw new DllNotFoundException(fileName + " not found");
	}

	internal struct Cpp_Acc {
		public IntPtr acc;
		public int elem;
		public elm.Misc_ misc;

		public Cpp_Acc(IntPtr iacc, int elem_) { acc = iacc; elem = elem_; misc = default; }
		public Cpp_Acc(elm e) { acc = e._iacc; elem = e._elem; misc = e._misc; }
		public static implicit operator Cpp_Acc(elm e) => new(e);
	}

	internal delegate int Cpp_AccFindCallbackT(Cpp_Acc a, RECT* r);

	internal struct Cpp_AccFindParams {
		string _role, _name, _prop;
		int _roleLength, _nameLength, _propLength;
		public EFFlags flags;
		public int skip;
		char _resultProp; //elmFinder.RProp
		int _flags2;

		public Cpp_AccFindParams(string role, string name, string prop, EFFlags flags, int skip, char resultProp) {
			if (role != null) { _role = role; _roleLength = role.Length; }
			if (name != null) { _name = name; _nameLength = name.Length; }
			if (prop != null) { _prop = prop; _propLength = prop.Length; }
			this.flags = flags;
			this.skip = skip;
			_resultProp = resultProp;
		}

		/// <summary>
		/// Parses role. Enables Chrome acc if need.
		/// </summary>
		public void RolePrefix(wnd w) {
			if (_roleLength < 4) return;
			int i = _role.IndexOf(':'); if (i < 3) return;
			_flags2 = Cpp_AccRolePrefix(_role, i, w);
			if (_flags2 != 0) {
				_roleLength -= ++i;
				_role = _roleLength > 0 ? _role[i..] : null;
			}
		}
	}

	[DllImport("AuCpp.dll", CallingConvention = CallingConvention.Cdecl)]
	static extern int Cpp_AccRolePrefix(string s, int len, wnd w);

	[DllImport("AuCpp.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern EError Cpp_AccFind(wnd w, Cpp_Acc* aParent, Cpp_AccFindParams ap, Cpp_AccFindCallbackT also, out Cpp_Acc aResult, [MarshalAs(UnmanagedType.BStr)] out string sResult, bool getRects = false);

	internal enum EError {
		NotFound = 0x1001, //UI element not found. With FindAll - no errors. This is actually not an error.
		InvalidParameter = 0x1002, //invalid parameter, for example wildcard expression (or regular expression in it)
		WindowClosed = 0x1003, //the specified window handle is invalid or the window was destroyed while injecting
	}

	internal static bool IsCppError(int hr) {
		return hr >= (int)EError.NotFound && hr <= (int)EError.WindowClosed;
	}

	/// <summary>
	/// flags: 1 not inproc, 2 get only name.
	/// </summary>
	[DllImport("AuCpp.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern int Cpp_AccFromWindow(int flags, wnd w, EObjid objId, out Cpp_Acc aResult, out BSTR sResult);

	internal delegate EXYFlags Cpp_AccFromPointCallbackT(EXYFlags flags, wnd wFP, wnd wTL);

	[DllImport("AuCpp.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern int Cpp_AccFromPoint(POINT p, EXYFlags flags, Cpp_AccFromPointCallbackT callback, out Cpp_Acc aResult);

	[DllImport("AuCpp.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern int Cpp_AccGetFocused(wnd w, EFocusedFlags flags, out Cpp_Acc aResult);

	//These are called from elm class functions like Cpp.Cpp_Func(this, ...); GC.KeepAlive(this);.
	//We can use 'this' because Cpp_Acc has an implicit conversion from elm operator.
	//Need GC.KeepAlive(this) everywhere. Else GC can collect the elm (and release _iacc) while in the Cpp func.
	//Alternatively could make the Cpp parameter 'const Cpp_Acc&', and pass elm directly. But I don't like it.

	[DllImport("AuCpp.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern int Cpp_AccNavigate(Cpp_Acc aFrom, string navig, out Cpp_Acc aResult);

	[DllImport("AuCpp.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern int Cpp_AccGetStringProp(Cpp_Acc a, char prop, out BSTR sResult);

	[DllImport("AuCpp.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern int Cpp_AccWeb(Cpp_Acc a, string what, out BSTR sResult);

	[DllImport("AuCpp.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern int Cpp_AccGetRect(Cpp_Acc a, out RECT r);

	[DllImport("AuCpp.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern int Cpp_AccGetRole(Cpp_Acc a, out ERole roleInt, out BSTR roleStr);

	[DllImport("AuCpp.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern int Cpp_AccGetInt(Cpp_Acc a, char what, out int R);

	[DllImport("AuCpp.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern int Cpp_AccAction(Cpp_Acc a, char action = 'a', [MarshalAs(UnmanagedType.BStr)] string param = null);

	[DllImport("AuCpp.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern int Cpp_AccSelect(Cpp_Acc a, ESelect flagsSelect);

	[DllImport("AuCpp.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern int Cpp_AccGetSelection(Cpp_Acc a, out BSTR sResult);

	[DllImport("AuCpp.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern int Cpp_AccGetProps(Cpp_Acc a, string props, out BSTR sResult);

	/// <param name="flags">1 - wait less.</param>
	[DllImport("AuCpp.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern void Cpp_Unload(uint flags);

#if DEBUG
	internal static void DebugUnload() {
		GC.Collect();
		GC.WaitForPendingFinalizers();
		Cpp_Unload(0);
	}

//	[DllImport("AuCpp.dll", CallingConvention = CallingConvention.Cdecl)]
//	internal static extern IInterface Cpp_GetInterface();

//	[ComImport, Guid("3AB5235E-2768-47A2-909A-B5852A9D1868"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
//	internal interface IInterface {
//		[PreserveSig] int Add(int a, int b);
//		//int Prop { set; get; }
//		//[return: MarshalAs(UnmanagedType.Bool)] bool Prop { set; get; }
//		//bool Prop { [return: MarshalAs(UnmanagedType.Bool)] set; [return: MarshalAs(UnmanagedType.Bool)] get; }
//		//[property: MarshalAs(UnmanagedType.Bool)] bool Prop { set; get; }

//		void put_Prop([MarshalAs(UnmanagedType.Bool)] bool r);
//		[return: MarshalAs(UnmanagedType.Bool)] bool get_Prop();

//		//void put_Prop2([MarshalAs(UnmanagedType.LPStr)] string r);
//		//[return: MarshalAs(UnmanagedType.LPStr)] string get_Prop2();
//		//[return: MarshalAs(UnmanagedType.IUnknown)] object Prop2 { get; set; }
//		//object Prop2 { [return: MarshalAs(UnmanagedType.IUnknown)] get; set; }

//#if false
//		void put_Prop2([MarshalAs(UnmanagedType.IUnknown)] object r);
//		[return: MarshalAs(UnmanagedType.IUnknown)] object get_Prop2();
//#else
//		void put_Prop2(IUnknown r);
//		IUnknown get_Prop2();

//		[ComImport, Guid("00000000-0000-0000-c000-000000000046"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
//		internal interface IUnknown { }
//#endif
//	}
#endif

	[DllImport("AuCpp.dll", CallingConvention = CallingConvention.Cdecl)]
	static extern void Cpp_SetHelperCallback(delegate* unmanaged<int, wnd, int> callback);

	[UnmanagedCallersOnly]
	static int _HelperCallback(int action, wnd w) {
		if (action == 1) { //AccEnableChrome asks to detect whether the command line contains --force-renderer-accessibility. If yes, will not try to enable acc.
			if (process.getCommandLine(w.ProcessId, removeProgram: true) is string s) {
				if (s.Contains("--force-renderer-accessibility")) return 1;
				//print.warning("To use UI elements in web pages, start browser with command line --force-renderer-accessibility. Without it the code may fail sometimes or stop working in the future.");
			}
		} else if (action == 2) { //AccEnableChrome failed
			print.warning("To use UI elements in web pages, start browser with command line --force-renderer-accessibility.");
		}
		return 0;
	}

	// OTHER

	[DllImport("AuCpp.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern IntPtr Cpp_ModuleHandle();

	[DllImport("AuCpp.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern char* Cpp_LowercaseTable();

	[DllImport("AuCpp.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern IntPtr Cpp_Clipboard(IntPtr hh);

	[DllImport("AuCpp.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern bool Cpp_ShellExec(in Api.SHELLEXECUTEINFO x, out int pid, out int injectError, out int execError);

	[DllImport("AuCpp.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern nint Cpp_AccWorkaround(Api.IAccessible a, nint wParam, ref nint obj);

	[DllImport("AuCpp.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern void Cpp_UEF(bool on);

	[DllImport("AuCpp.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern void Cpp_InactiveWindowWorkaround(bool on);

	/// <returns>0 failed, 1 x86, 2 x64, 3 arm64</returns>
	[DllImport("AuCpp.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern int Cpp_GetProcessArchitecture(int pid);

	// TEST

#if DEBUG

	[DllImport("AuCpp.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern void Cpp_Test();

	//[DllImport("AuCpp.dll", CallingConvention = CallingConvention.Cdecl)]
	//internal static extern void Cpp_TestWildex(string s, string w);

	//[DllImport("AuCpp.dll", CallingConvention = CallingConvention.Cdecl)]
	//internal static extern int Cpp_TestInt(int a);

	//[DllImport("AuCpp.dll", CallingConvention = CallingConvention.Cdecl)]
	//internal static extern int Cpp_TestString(string a, int b, int c);

	//[ComImport, Guid("3426CF3C-F7C2-4322-A292-463DB8729B54"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
	//internal interface ICppTest
	//{
	//	[PreserveSig] int TestInt(int a, int b, int c);
	//	[PreserveSig] int TestString([MarshalAs(UnmanagedType.LPWStr)] string a, int b, int c);
	//	[PreserveSig] int TestBSTR(string a, int b, int c);
	//}

	//[DllImport("AuCpp.dll", CallingConvention = CallingConvention.Cdecl)]
	//internal static extern ICppTest Cpp_Interface();


	//[ComImport, Guid("57017F56-E7CA-4A7B-A8F8-2AE36077F50D"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
	//internal interface IThreadExitEvent
	//{
	//	[PreserveSig] int Unsubscribe();
	//}

	//[DllImport("AuCpp.dll", CallingConvention = CallingConvention.Cdecl)]
	//internal static extern IThreadExitEvent Cpp_ThreadExitEvent(IntPtr callback);

	//[DllImport("AuCpp.dll", CallingConvention = CallingConvention.Cdecl)]
	//internal static extern void Cpp_ThreadExitEvent2(IntPtr callback);
#endif
}


================================================
FILE: Au/Api/WinRT.cs
================================================
//WinRT common API and utils. Others are in files where used.

//This library does not use C#/WinRT (Microsoft.Windows.SDK.NET.dll and WinRT.Runtime.dll).
//Would be easier, but it has problems:
//	- Adds 2 files, 22 MB.
//	- OCR: if once used in a STA thread, then does not work in MTA threads.
//	- OCR: slower.

namespace Au.Types;

#pragma warning disable 649, 169 //field never assigned/used
static unsafe partial class WinRT {
	[DllImport("combase.dll", PreserveSig = true)]
	internal static extern int WindowsCreateString(string s, int length, out IntPtr hstring);
	
	[DllImport("combase.dll", PreserveSig = true)]
	internal static extern int WindowsDeleteString(IntPtr hstring);
	
	[DllImport("combase.dll")]
	internal static extern char* WindowsGetStringRawBuffer(IntPtr hstring, out int length);
	
	//probably don't need. Always returns 1 (already initialized) when called with current apartment state.
	//[DllImport("combase.dll", PreserveSig = true)]
	//internal static extern int RoInitialize(int initType);
	
	[DllImport("combase.dll", PreserveSig = true)]
	internal static extern int RoGetActivationFactory(IntPtr activatableClassId, in Guid iid, out IntPtr factory);
	
	internal static T Create<T>(string progId) where T : struct {
		using var hs = new _Hstring(progId);
		HR(RoGetActivationFactory(hs, typeof(T).GUID, out var r));
		return Unsafe.As<IntPtr, T>(ref r);
	}
	//rejected: use static factories. Now fast.
	
	internal static void HR(int hr) {
		if (hr < 0) throw Marshal.GetExceptionForHR(hr);
	}
	
	internal static T As<T>(IntPtr ip) where T : unmanaged {
		Debug.Assert(sizeof(T) == sizeof(IntPtr));
		return Unsafe.As<IntPtr, T>(ref ip);
	}
	
	/// <summary>
	/// A COM interface pointer.
	/// </summary>
	internal struct IUnknown : IDisposable {
		IntPtr _u;
		
		IUnknown(IntPtr iunknown) { _u = iunknown; }
		
		public void Dispose() {
			if (_u != default) { Marshal.Release(_u); _u = default; }
		}

		public bool IsNull => _u == default;
		
		int _QI(Type type, out IntPtr r) {
#if NET9_0_OR_GREATER //changed ref -> in
			return Marshal.QueryInterface(_u, type.GUID, out r);
#else
			var guid = type.GUID;
			return Marshal.QueryInterface(_u, ref guid, out r);
#endif
		}

		/// <summary>
		/// Calls <c>QueryInterface</c>. Throws exception if failed.
		/// </summary>
		public T QI<T>() where T : unmanaged {
			HR(_QI(typeof(T), out var r));
			return As<T>(r);
		}
		
		/// <summary>
		/// Calls <c>QueryInterface</c>. Returns <c>false</c> if failed.
		/// </summary>
		public bool QI<T>(out T r) where T : unmanaged {
			bool ok = 0 == _QI(typeof(T), out var v);
			r = ok ? As<T>(v) : default;
			return ok;
		}
		
		/// <summary>
		/// Gets COM interface function at index <i>i</i> in vtbl.
		/// </summary>
		public nint this[int i] => (*(nint**)_u)[i];
		
		public static implicit operator IUnknown(IntPtr p) => new(p);
		
		public static implicit operator IntPtr(IUnknown p) => p._u;
		
		public override string ToString() => _u.ToString();
		
		/// <summary>
		/// Calls a 0-param function that returns <c>HSTRING</c>.
		/// </summary>
		/// <param name="i">Interface function index in vtbl.</param>
		public string GetString(int i) {
			using var s1 = new _Hstring(_GetPtr(i));
			return s1.ToString();
		}
		
		IntPtr _GetPtr(int i) {
			HR(((delegate* unmanaged[Stdcall]<IntPtr, out IntPtr, int>)this[i])(_u, out var r));
			return r;
		}
		
		/// <summary>
		/// Calls a 0-param function with a pointer-size return type (COM pointer, etc).
		/// </summary>
		/// <param name="i">Interface function index in vtbl.</param>
		public T GetPtr<T>(int i) where T : unmanaged => As<T>(_GetPtr(i));
		
		//when calling: System.BadImageFormatException: Bad element type in SizeOf.
		//public IntPtr GetPtr<T1>(int i, T1 p1) where T1 : unmanaged {
		//	HR(((delegate* unmanaged[Stdcall]<IntPtr, T1, out IntPtr, int>)this[i])(_u, p1, out var r));
		//	return r;
		//}
		
		/// <summary>
		/// <c>QI(IClosable).Close()</c>
		/// </summary>
		public void Close() {
			using var c = QI<IClosable>();
			c.Close();
		}
	}
	
	internal interface IComPtr : IDisposable {  }
	
	internal struct IVectorView<T> : IComPtr where T : unmanaged {
		IUnknown _u; public IUnknown U => _u;
		public void Dispose() => _u.Dispose();
		
		IntPtr _GetAt(int i) {
			HR(((delegate* unmanaged[Stdcall]<IntPtr, int, out IntPtr, int>)_u[6])(_u, i, out var r));
			return r;
		}
		
		public T this[int i] => As<T>(_GetAt(i));
		
		public int Size {
			get {
				HR(((delegate* unmanaged[Stdcall]<IntPtr, out int, int>)_u[7])(_u, out int r));
				return r;
			}
		}
		
		public IEnumerable<T> Items(bool disposeItems = true) {
			for (int i = 0, n = Size; i < n; i++) {
				var v = _GetAt(i);
				yield return As<T>(v);
				if (disposeItems) Marshal.Release(v);
			}
		}
	}
	
#if true
	internal struct IAsyncOperation : IComPtr {
		IUnknown _u; public IUnknown U => _u;
		public void Dispose() => _u.Dispose();
		
		public T Await<T>(bool dispose = true) where T : unmanaged {
			try {
				using (var ai = _u.QI<IAsyncInfo>()) {
					for (int i = 4; ; i++) {
						var status = ai.Status;
						//print.it(status, i / 4);
						if (status == AsyncStatus.Completed) break;
						if (status != AsyncStatus.Started) throw new AuException();
						wait.ms(i / 4);
					}
				}
				
				return _u.GetPtr<T>(8); //GetResults
			}
			finally { if (dispose) Dispose(); }
		}
		
		[Guid("00000036-0000-0000-C000-000000000046")]
		struct IAsyncInfo : IComPtr {
		IUnknown _u; public IUnknown U => _u;
		public void Dispose() => _u.Dispose();
			
			public AsyncStatus Status {
				get {
					HR(((delegate* unmanaged[Stdcall]<IntPtr, out AsyncStatus, int>)_u[7])(_u, out var r));
					return r;
				}
			}
		}
		
		enum AsyncStatus { Canceled = 2, Completed = 1, Error = 3, Started = 0 }
	}
#else //tried to use Completed callback, unsuccessfully
		internal struct IAsyncOperation : IComPtr {
			IUnknown _u; public IUnknown U => _u;
			public void Dispose() => _u.Dispose();
			
			public T Await<T>(bool dispose = true) where T : unmanaged {
				try {
					//static void _Handler(IAsyncOperation ai, AsyncStatus status) { print.it("completed"); }
					//delegate*<IntPtr, int, void> p1 = &_Handler;
					//HR(((delegate* unmanaged[Stdcall]<IntPtr, void*, int>)_u[6])(_u, p1)); //put_Completed
					
					var del = new AsyncOperationCompletedHandler(static (IAsyncOperation ai, AsyncStatus status) => { print.it("completed"); });
					HR(((delegate* unmanaged[Stdcall]<IntPtr, AsyncOperationCompletedHandler, int>)_u[6])(_u, del)); //put_Completed
					
					dialog.show("");
					GC.KeepAlive(del);
					
					return _u.GetPtr<T>(8); //GetResults
				}
				finally { if (dispose) Dispose(); }
			}
			
			enum AsyncStatus { Canceled = 2, Completed = 1, Error = 3, Started = 0 }
			
			delegate void AsyncOperationCompletedHandler(IAsyncOperation ao, AsyncStatus status);
		}
#endif
	
	[Guid("30d5a829-7fa4-4026-83bb-d75bae4ea99e")]
	internal struct IClosable : IComPtr {
		IUnknown _u; public IUnknown U => _u;
		public void Dispose() => _u.Dispose();
		
		public void Close() {
			HR(((delegate* unmanaged[Stdcall]<IntPtr, int>)_u[6])(_u));
		}
	}
	
	unsafe class _Hstring : IDisposable {
		IntPtr _h;
		
		public _Hstring(IntPtr hstring) {
			_h = hstring;
		}
		
		public _Hstring(string s) {
			WindowsCreateString(s, s.Lenn(), out _h);
		}
		
		public void Dispose() {
			if (_h != default) {
				WindowsDeleteString(_h);
				_h = default;
			}
			GC.SuppressFinalize(this);
		}
		
		~_Hstring() {
			if (_h != default) WindowsDeleteString(_h);
		}
		
		//public static implicit operator _Hstring(string s) => new(s);
		public static implicit operator IntPtr(_Hstring s) => s._h;
		public static implicit operator string(_Hstring s) => s.ToString();
		
		public override string ToString() {
			if (_h == default) return null;
			char* p = WindowsGetStringRawBuffer(_h, out int len);
			return new(p, 0, len);
		}
	}
}


================================================
FILE: Au/Au.More/AppSingleInstance.cs
================================================
namespace Au.More;

/// <summary>
/// Implements "single instance process" feature.
/// </summary>
/// <example>
/// <code><![CDATA[
/// /*/ role exeProgram; ifRunning run; /*/
/// if (script.testing) args = ["test", "args"];
/// 
/// if (AppSingleInstance.AlreadyRunning("unique-mutex-name", args)) {
/// 	print.it("already running");
/// 	return;
/// }
/// 
/// var b = new wpfBuilder("Window").WinSize(400);
/// b.R.AddOkCancel();
/// b.End();
/// AppSingleInstance.Notified += a => {
/// 	print.it("AppSingleInstance.Notified", a);
/// 	b.Window.Activate();
/// };
/// if (!b.ShowDialog()) return;
/// ]]></code>
/// </example>
/// <summary>
/// Implements "single instance process" feature.
/// </summary>
/// <seealso cref="script.single"/>
public static class AppSingleInstance {
	static Mutex _mutex;
	static wnd _wNotify;
	
	/// <summary>
	/// Detects whether a process of this app is already running.
	/// </summary>
	/// <param name="mutex">A unique string to use for mutex name (see <see cref="Mutex(bool, string, out bool)"/>). If prefix <c>@"Global\"</c> used, detects processes in all user sessions.</param>
	/// <param name="notifyArgs">
	/// If not <c>null</c>:
	/// <br/>• If already running, sends it to that process, which receives it in <see cref="Notified"/> event.
	/// <br/>• Else enables <see cref="Notified"/> event in this process.
	/// </param>
	/// <param name="waitMS">Milliseconds to wait until this process can run. No timeout if -1.</param>
	/// <returns>True if already running.</returns>
	/// <exception cref="InvalidOperationException">This function already called.</exception>
	/// <exception cref="Exception">Exceptions of <see cref="Mutex(bool, string, out bool)"/>.</exception>
	public static bool AlreadyRunning(string mutex, IEnumerable<string> notifyArgs = null, int waitMS = 0) {
		var m = new Mutex(true, mutex, out bool createdNew);
		if (null != Interlocked.CompareExchange(ref _mutex, m, null)) { m.Dispose(); throw new InvalidOperationException(); }
		
		if (!createdNew && waitMS != 0) {
			try { createdNew = m.WaitOne(waitMS); }
			catch (AbandonedMutexException) { createdNew = true; }
		}
		
		if (notifyArgs != null) {
			if (createdNew) {
				WndUtil.RegisterWindowClass(mutex, _WndProc);
				_wNotify = WndUtil.CreateMessageOnlyWindow(mutex, "AppSingleInstance");
				WndCopyData.EnableReceivingWM_COPYDATA();
			} else {
				var w = wnd.findFast("AppSingleInstance", mutex, messageOnly: true);
				if (!w.Is0) WndCopyData.Send<char>(w, 1, string.Join('\0', notifyArgs));
			}
		}
		
		return !createdNew;
	}
	
	static nint _WndProc(wnd w, int msg, nint wp, nint lp) {
		if (msg == Api.WM_COPYDATA) {
			var x = new WndCopyData(lp);
			if (x.DataId == 1) {
				Notified?.Invoke(x.GetString().Split('\0'));
			}
		}
		return Api.DefWindowProc(w, msg, wp, lp);
	}
	
	/// <summary>
	/// When <see cref="AlreadyRunning"/> in new process detected that this process is running.
	/// Receives <i>notifyArgs</i> passed to it.
	/// </summary>
	/// <remarks>
	/// To enable this event, call <see cref="AlreadyRunning"/> with non-<c>null</c> <i>notifyArgs</i>. The event handler runs in the same thread. The thread must dispatch Windows messages (for example show a window or dialog, or call <see cref="wait.doEvents(int)"/>).
	/// </remarks>
	public static event Action<string[]> Notified;
}


================================================
FILE: Au/Au.More/BufferedPaint.cs
================================================
namespace Au.More;

/// <summary>
/// Wraps buffered paint API <ms>BeginBufferedPaint</ms> etc.
/// Must be disposed locally, like in the example.
/// </summary>
/// <example>
/// <code><![CDATA[
/// case WM_PAINT:
/// 	using (BufferedPaint bp = new(w, true)) { ... }
/// 	return default;
/// ]]></code>
/// </example>
public struct BufferedPaint : IDisposable {
	//rejected. Users often will forget it. Better init automatically.
	///// <summary>
	///// Calls API <ms>BufferedPaintInit</ms>.
	///// </summary>
	//public static void Init() { Api.BufferedPaintInit(); } //fast
	
	///// <summary>
	///// Calls API <ms>BufferedPaintUnInit</ms>.
	///// </summary>
	//public static void Uninit() { Api.BufferedPaintUnInit(); }
	
	[ThreadStatic] static bool s_inited;
	//never mind: should BufferedPaintUnInit before thread exits.
	//	Not very important. Usually a process has single UI thread. Tested: 10000 threads without BufferedPaintUnInit don't leak much.
	//	To detect thread exit could use eg FlsAlloc(callback)+FlsSetValue, or unmanaged dll thread detach.
	//		But it can be dangerous (too late, eg C# thread variables are already cleared).
	
	wnd _w;
	IntPtr _dcn, _dcb;
	bool _wmPaint;
	Api.PAINTSTRUCT _ps;
	IntPtr _hb;
	RECT _r;
	
	/// <summary>
	/// Gets non-buffered DC with API <ms>BeginPaint</ms> or <ms>GetDC</ms>. Then gets buffered DC with API <ms>BeginBufferedPaint</ms> for entire client area or rectangle <i>r</i>.
	/// </summary>
	/// <param name="w"></param>
	/// <param name="wmPaint">Use API <c>BeginPaint</c>/<c>EndPaint</c>. If <c>false</c>, uses <c>GetDC</c>/<c>ReleaseDC</c>.</param>
	/// <param name="r">Part of client area.</param>
	public unsafe BufferedPaint(wnd w, bool wmPaint, RECT? r = null) {
		if (!s_inited) s_inited = 0 == Api.BufferedPaintInit();
		
		_w = w;
		if (_wmPaint = wmPaint) {
			_dcn = Api.BeginPaint(w, out _ps);
		} else {
			_dcn = Api.GetDC(_w);
		}
		
		_r = r ?? _w.ClientRect;
		Api.BP_PAINTPARAMS pp = new() { cbSize = sizeof(Api.BP_PAINTPARAMS) };
		//var ru = wmPaint ? _ps.rcPaint : _r; //the buffer bitmap is smaller when rcPaint smaller, but in most cases don't need to change painting code, although GetViewportOrgEx etc get 0 offsets of the buffer DC. However problem with brush alignment.
		_hb = Api.BeginBufferedPaint(_dcn, _r, Api.BP_BUFFERFORMAT.BPBF_TOPDOWNDIB, ref pp, out _dcb); //BPBF_COMPATIBLEBITMAP slower //tested: works with 16 and 8 bit colors too
		Debug_.PrintIf(_hb == default && !_r.NoArea, $"BeginBufferedPaint, {_r}");
		if (_hb == default) _dcb = _dcn;
	}
	
	/// <summary>
	/// Calls API <ms>EndBufferedPaint</ms> and <ms>EndPaint</ms> or <ms>ReleaseDC</ms>.
	/// </summary>
	public void Dispose() {
		if (_dcn == default) return;
		if (_hb != default) Api.EndBufferedPaint(_hb, true);
		if (_wmPaint) Api.EndPaint(_w, _ps); else Api.ReleaseDC(_w, _dcn);
		_dcn = default;
	}
	
	/// <summary>
	/// Gets window DC.
	/// </summary>
	public IntPtr NonBufferedDC => _dcn;
	
	/// <summary>
	/// Gets the buffered DC. Returns <see cref="NonBufferedDC"/> if API <ms>BeginBufferedPaint</ms> failed.
	/// </summary>
	public IntPtr DC => _dcb;
	
	/// <summary>
	/// Gets client area rectangle or rectangle passed to constructor.
	/// </summary>
	public RECT Rect => _r;
	
	/// <summary>
	/// Gets bounding rectangle of the update region in client area rectangle.
	/// </summary>
	public RECT UpdateRect {
		get {
			if (_wmPaint) return _ps.rcPaint;
			Api.GetUpdateRect(_w, out var r, false);
			return r;
		}
	}
}


================================================
FILE: Au/Au.More/CheckListDialog.cs
================================================
using System.Windows;
using System.Windows.Controls;
using System.Collections;

namespace Au.More;

/// <summary>
/// Dialog with list of check boxes.
/// </summary>
/// <seealso cref="EnumUI{TEnum}"/>
/// <example>
/// <code><![CDATA[
/// string[] a = ["one", "two"];
/// var d = new CheckListDialog("Info.");
/// d.Add(a);
/// d.Add("three", true);
/// d.Add("four");
/// if (!d.ShowDialog()) return;
/// print.it(d.ResultBits, d.ResultIndices, d.ResultItems);
/// ]]></code>
/// </example>
public class CheckListDialog {
	wpfBuilder _b;
	TextBlock _text;
	ListBox _lb;
	List<CheckBox> _ac = new();
	
	/// <summary>
	/// Creates <see cref="Builder"/>, sets some window properties, optionally sets static text.
	/// </summary>
	/// <param name="text">Text above the list. Can be <c>null</c>. See also <see cref="FormatText"/>.</param>
	/// <param name="title">Window name. If <c>null</c>, uses <see cref="dialog.options.defaultTitle"/>.</param>
	public CheckListDialog(string text = null, string title = null) {
		_b = new wpfBuilder(title ?? dialog.options.defaultTitle)
			.WinProperties(resizeMode: ResizeMode.NoResize)
			.Width(250..600);
		_b.R.Add(out _text, text).Wrap(TextWrapping.Wrap);
		if (text == null) _text.Visibility = Visibility.Collapsed;
	}
	
	/// <summary>
	/// Adds a checkbox.
	/// </summary>
	/// <returns>The checkbox.</returns>
	public CheckBox Add(string text, bool check = false, string tooltip = null) {
		if (_lb == null) _b.R.Add(out _lb).Height(..550);
		
		//var content = UseAccessKey ? text : text?.Replace("_", "__");
		var content = text?.Replace("_", "__");
		CheckBox c = new() { Content = content, Tag = text, IsChecked = check, ToolTip = tooltip };
		_ac.Add(c);
		_lb.Items.Add(c);
		return c;
	}
	
	/// <summary>
	/// Adds multiple checkboxes.
	/// </summary>
	/// <param name="items">Array, <c>List</c>, etc containing text strings for checkboxes.</param>
	/// <param name="check">Whether to check all checkboxes.</param>
	public void Add(IEnumerable<string> items, bool check = false) {
		foreach (var v in items) Add(v, check);
	}
	
	///// <summary>
	///// Character <c>'_'</c> in checkbox text isn't displayed. Instead the next character toggles the checkbox when pressed with <c>Alt</c>. For literal <c>"_"</c> use <c>"__"</c>.
	///// </summary>
	//public bool UseAccessKey { get; set; }
	
	/// <summary>
	/// Sets formatted text, like <see cref="wpfBuilder.FormatText(wpfBuilder.InterpolatedString)"/>.
	/// </summary>
	/// <inheritdoc cref="wpfBuilder.formatTextOf" path="//param|//exception"/>
	public void FormatText(wpfBuilder.InterpolatedString text) {
		wpfBuilder.formatTextOf(_text, text);
		_text.Visibility = Visibility.Visible;
	}
	
	/// <summary>
	/// Changes text of <b>OK</b> and <b>Cancel</b> buttons.
	/// </summary>
	public void SetButtons(string ok = "OK", string cancel = "Cancel") {
		_ok = ok;
		_cancel = cancel;
	}
	string _ok, _cancel;
	
	/// <summary>
	/// Gets the <see cref="wpfBuilder"/> that builds the dialog.
	/// You can use it to add more controls, change window properties, etc; see example.
	/// </summary>
	/// <example>
	/// <code><![CDATA[
	/// using System.Windows.Controls;
	/// string[] a = ["one", "two"];
	/// var d = new CheckListDialog("Info.");
	/// d.Add(a);
	/// d.Builder.R.Add("Input", out TextBox tInput);
	/// if (!d.ShowDialog()) return;
	/// print.it(d.ResultBits, d.ResultIndices, d.ResultItems, tInput.Text);
	/// ]]></code>
	/// </example>
	public wpfBuilder Builder => _b;
	
	/// <summary>
	/// Adds <b>OK</b>/<b>Cancel</b> buttons, shows dialog, sets result properties.
	/// </summary>
	/// <param name="owner">
	/// Owner window, or an element in it.
	/// If used, sets <see cref="Window.ShowInTaskbar"/> = <c>false</c>. Else sets <see cref="Window.Topmost"/> = <c>true</c>, unless <see cref="dialog.options.topmostIfNoOwnerWindow"/> is <c>false</c> or the active window belongs to this process.
	/// </param>
	/// <returns><c>true</c> if pressed <b>OK</b>.</returns>
	public bool ShowDialog(DependencyObject owner = null) {
		_b.R.AddOkCancel(_ok ?? "OK", _cancel ?? "Cancel");
		_b.End();
		
		var w = _b.Window;
		if (owner != null) w.ShowInTaskbar = false;
		else if (dialog.options.topmostIfNoOwnerWindow && !wnd.active.IsOfThisProcess) w.Topmost = true;
		
		if (!_b.ShowDialog(owner)) return false;
		
		BitArray ba = new(_ac.Count);
		int n = 0;
		for (int i = 0; i < ba.Length; i++) if (ba[i] = _ac[i].IsChecked == true) n++;
		ResultIndices = new int[n];
		for (int i = 0, j = 0; i < ba.Length; i++) if (ba[i]) ResultIndices[j++] = i;
		ResultItems = new string[n];
		for (int i = 0, j = 0; i < ba.Length; i++) if (ba[i]) ResultItems[j++] = _ac[i].Tag as string;
		ResultBits = ba;
		
		return true;
	}
	
	/// <summary>
	/// Gets a bit array where elements represent checkbox states (<c>true</c> if checked).
	/// This property is set by <see cref="ShowDialog"/>.
	/// </summary>
	public BitArray ResultBits { get; private set; }
	
	/// <summary>
	/// Gets 0-based indices of checked items.
	/// This property is set by <see cref="ShowDialog"/>.
	/// </summary>
	public int[] ResultIndices { get; private set; }
	
	/// <summary>
	/// Gets strings of checked items.
	/// This property is set by <see cref="ShowDialog"/>.
	/// </summary>
	/// <example>
	/// <code><![CDATA[
	/// List<string> a = ["one", "two"];
	/// var d = new CheckListDialog("Info.");
	/// d.Add(a);
	/// if (!d.ShowDialog() || !d.ResultItems.Any()) return;
	/// a = d.ResultItems.ToList();
	/// ]]></code>
	/// </example>
	public string[] ResultItems { get; private set; }
}


================================================
FILE: Au/Au.More/ComUtil.cs
================================================
namespace Au.More;

/// <summary>
/// COM utility functions.
/// </summary>
public static class ComUtil {
	/// <summary>
	/// Gets a COM object existing in other process and registered in ROT.
	/// </summary>
	/// <param name="progID">ProgID of the COM class. Example: <c>"Excel.Application"</c>.</param>
	/// <param name="dontThrow">If fails, don't throw exception but return <c>null</c>.</param>
	/// <exception cref="COMException">
	/// <br/>• <i>progID</i> not found in the registry. Probably it is incorrect, or the program isn't installed.
	/// <br/>• An object of this type currently is unavailable. Probably the program is not running, or running with a different UAC integrity level.
	/// </exception>
	/// <remarks>
	/// Calls API <ms>GetActiveObject</ms>.
	///
	/// This process must have the same [](xref:uac) integrity level as the target process (of the COM object). In script <b>Properties</b> select <b>uac user</b>.
	/// </remarks>
	/// <seealso cref="Marshal.BindToMoniker(string)"/>
	/// <example>
	/// <code><![CDATA[
	/// /*/ uac user; com Outlook 9.6 #ed6988d3.dll; /*/
	/// using Outlook = Microsoft.Office.Interop.Outlook;
	/// var app = (Outlook.Application)ComUtil.GetActiveObject("Outlook.Application");
	/// print.it(app.ActiveExplorer().CurrentFolder.Name);
	/// ]]></code>
	/// </example>
	public static object GetActiveObject(string progID, bool dontThrow = false) {
		int hr = Api.CLSIDFromProgID(progID, out var clsid);
		if (hr < 0) return dontThrow ? null : throw Marshal.GetExceptionForHR(hr);
		return GetActiveObject(clsid, dontThrow);
	}

	/// <exception cref="COMException">An object of this type currently is unavailable. Probably its program is not running, or running with a different UAC integrity level.</exception>
	public static object GetActiveObject(in Guid clsid, bool dontThrow = false) {
		int hr = Api.GetActiveObject(clsid, default, out var r);
		if (hr < 0) return dontThrow ? null : throw Marshal.GetExceptionForHR(hr);
		return r;
	}

	/// <summary>
	/// Gets COM object from a window using API <ms>AccessibleObjectFromWindow</ms><c>(OBJID_NATIVEOM, IID_IDispatch</c>).
	/// </summary>
	/// <param name="w">Window or control.</param>
	/// <param name="cnChild">Child window class name. Format: [wildcard expression](xref:wildcard_expression). If used, gets COM object from the first found child or descendant window where it succeeds. If <c>null</c>, gets COM object from <i>w</i>.</param>
	/// <param name="dontThrow">If fails to get COM object, don't throw exception but return <c>null</c>.</param>
	/// <exception cref="AuWndException"><i>w</i> 0 or invalid.</exception>
	/// <exception cref="AuException">Failed.</exception>
	/// <example>
	/// Microsoft Excel.
	/// <code><![CDATA[
	/// /*/ com Excel 1.9 #9fdf46bf.dll; /*/
	/// using Excel = Microsoft.Office.Interop.Excel;
	/// var w = wnd.find(0, null, "XLMAIN", "EXCEL.EXE");
	/// Excel.Workbook book = ((Excel.Window)ComUtil.GetWindowObject(w, "EXCEL7")).Parent;
	/// print.it(book.Name);
	/// ]]></code>
	/// Microsoft Word.
	/// <code><![CDATA[
	/// /*/ com Word 8.7 #6a6b0205.dll; /*/
	/// using Word = Microsoft.Office.Interop.Word;
	/// var w = wnd.find(0, null, "OpusApp", "WINWORD.EXE");
	/// Word.Document doc = ((Word.Window)ComUtil.GetWindowObject(w, "_WwG")).Parent;
	/// print.it(doc.Name);
	/// ]]></code>
	/// Microsoft PowerPoint.
	/// <code><![CDATA[
	/// /*/ com PowerPoint 2.12 #fdf81915.dll; /*/
	/// using PowerPoint = Microsoft.Office.Interop.PowerPoint;
	/// var w = wnd.find(0, "*PowerPoint", null, "POWERPNT.EXE");
	/// PowerPoint.Presentation doc = ((PowerPoint.DocumentWindow)ComUtil.GetWindowObject(w, "**m mdiClass||paneClassDC")).Parent;
	/// print.it(doc.Name);
	/// ]]></code>
	/// Microsoft Access.
	/// <code><![CDATA[
	/// /*/ com Access 9.0 #cdda93ea.dll; /*/
	/// using Access = Microsoft.Office.Interop.Access;
	/// var w = wnd.find(0, null, "OMain", "MSACCESS.EXE");
	/// Access.Application app = (Access.Application)ComUtil.GetWindowObject(w);
	/// print.it(app.CurrentProject.Name);
	/// ]]></code>
	/// To get COM object from Microsoft Outlook or Publisher, use <see cref="GetActiveObject(string, bool)"/>.
	/// </example>
	public static object GetWindowObject(wnd w, string cnChild = null, bool dontThrow = false) {
		w.ThrowIfInvalid();
		if (cnChild != null) {
			foreach (var c in w.ChildAll(cn: cnChild)) {
				if (0 == Api.AccessibleObjectFromWindow(c, EObjid.NATIVEOM, IID_IDispatch, out var o)) return o;
			}
		} else {
			if (0 == Api.AccessibleObjectFromWindow(w, EObjid.NATIVEOM, IID_IDispatch, out var o)) return o;
		}
		if (!dontThrow) throw new AuException($"*get COM object from window {w}");
		return null;
	}
	static readonly Guid IID_IDispatch = new("00020400-0000-0000-C000-000000000046");

	/// <summary>
	/// Creates COM object using ProgID.
	/// </summary>
	/// <param name="progID">The programmatic identifier (ProgID) of the COM type.</param>
	/// <exception cref="Exception"></exception>
	/// <remarks>
	/// Use this function when you don't have the COM interface definition or the interop assembly. Else use code like <c>var x = new InterfaceType();</c> or <c>var x = new CoclassType() as InterfaceType</c>.
	/// </remarks>
	/// <example>
	/// <code><![CDATA[
	/// dynamic app = ComUtil.CreateObject("Excel.Application");
	/// app.Visible = true;
	/// 3.s();
	/// app.Quit();
	/// ]]></code>
	/// </example>
	public static object CreateObject(string progID) {
		return Activator.CreateInstance(Type.GetTypeFromProgID(progID, throwOnError: true));
	}

	/// <summary>
	/// Creates COM object using CLSID.
	/// </summary>
	/// <exception cref="Exception"></exception>
	public static object CreateObject(in Guid clsid) {
		return Activator.CreateInstance(Type.GetTypeFromCLSID(clsid, throwOnError: true));
	}

	/// <summary>
	/// Default value for optional parameters of type <ms>VARIANT</ms> (<c>object</c> in C#) of COM functions.
	/// The same as <see cref="System.Reflection.Missing.Value"/>.
	/// </summary>
	public static readonly System.Reflection.Missing Missing = System.Reflection.Missing.Value;
}


================================================
FILE: Au/Au.More/Convert2.cs
================================================
using System.IO.Compression;
using System.Security.Cryptography;

namespace Au.More;

/// <summary>
/// Data conversion functions. Compression, encryption, hex encoding, etc.
/// </summary>
public static unsafe class Convert2 {
	#region hex

	/// <summary>
	/// Converts data in <c>byte[]</c> or other memory to hex-encoded string.
	/// </summary>
	/// <param name="data">Data. See also: <see cref="MemoryMarshal.AsBytes"/>, <see cref="CollectionsMarshal.AsSpan"/>.</param>
	/// <param name="upperCase">Let the hex string contain A-F, not a-f.</param>
	/// <remarks>
	/// The result string length is 2 <c>*</c> data length.
	/// Often it's better to use <see cref="Convert.ToBase64String"/>, then result is 4/3 of data length. But cannot use Base64 in file names and URLs because it is case-sensitive and may contain character <c>'/'</c>. Both functions are fast.
	/// </remarks>
	public static string HexEncode(RByte data, bool upperCase = false) {
		fixed (byte* p = data) {
			return HexEncode(p, data.Length, upperCase);
		}
	}

	/// <summary>
	/// Converts binary data in any memory to hex-encoded string.
	/// </summary>
	/// <param name="data">The data. Can be any valid memory of specified size, for example a struct address.</param>
	/// <param name="size">data memory size (bytes).</param>
	/// <inheritdoc cref="HexEncode(ReadOnlySpan{byte}, bool)"/>
	public static string HexEncode(void* data, int size, bool upperCase = false) {
		int u = (upperCase ? 'A' : 'a') - 10;
		var bytes = (byte*)data;
		string R = new('\0', size * 2);
		fixed (char* cp = R) {
			int* p = (int*)cp;
			for (int i = 0; i < size; i++) {
				int b = bytes[i];
				int t = b & 0xf; t += t < 10 ? '0' : u;
				b >>= 4; b += b < 10 ? '0' : u;
				p[i] = t << 16 | b;
			}
		}
		return R;

		//tested: ~50% of time takes string allocation.
		//tested: with string.Create same speed.
	}

	/// <summary>
	/// Converts a struct variable to hex-encoded string.
	/// </summary>
	/// <param name="x">Variable.</param>
	/// <inheritdoc cref="HexEncode(ReadOnlySpan{byte}, bool)"/>
	public static string HexEncode<T>(T x, bool upperCase = false) where T : unmanaged
		=> HexEncode(&x, sizeof(T), upperCase);

	/// <summary>
	/// Converts hex-encoded string to binary data.
	/// </summary>
	/// <param name="encoded">String or <c>char[]</c> or span of string/array/memory containing hex encoded data.</param>
	/// <remarks>
	/// Skips spaces and other non-hex-digit characters. Example: <c>"01 23 46 67"</c> is the same as <c>"01234667"</c>.
	/// The number of hex digit characters should be divisible by 2, else the last character is ignored.
	/// </remarks>
	[SkipLocalsInit]
	public static byte[] HexDecode(RStr encoded) {
		using FastBuffer<byte> b = new(encoded.Length / 2);
		int n = HexDecode(encoded, b.p, b.n);
		var r = new byte[n];
		Marshal.Copy((IntPtr)b.p, r, 0, n);
		return r;
	}

	/// <summary>
	/// Converts hex-encoded string to binary data. Writes to caller's memory buffer.
	/// </summary>
	/// <returns>The number of bytes written in <i>decoded</i> memory. It is equal or less than <c>Math.Min(bufferSize, encoded.Length/2)</c>.</returns>
	/// <param name="decoded">Memory buffer for result.</param>
	/// <param name="bufferSize">Max number of bytes that can be written to the <i>decoded</i> memory buffer.</param>
	/// <inheritdoc cref="HexDecode(ReadOnlySpan{char})"/>
	public static int HexDecode(RStr encoded, void* decoded, int bufferSize) {
		if (encoded.Length == 0) return 0;
		var t = Tables_.Hex;
		byte* r = (byte*)decoded, rTo = r + bufferSize;
		uint k = 1;
		for (int i = 0; i < encoded.Length; i++) {
			uint c = (uint)(encoded[i] - '0'); if (c >= 55) continue;
			c = t[c]; if (c == 0xFF) continue;
			k <<= 4;
			k |= c;
			if (0 != (k & 0x100)) {
				if (r >= rTo) break;
				*r++ = (byte)k;
				k = 1;
			}
		}

		return (int)(r - (byte*)decoded);

		//speed: slightly slower than Base64Decode for the same binary data size.
	}

	/// <summary>
	/// Converts hex-encoded string to a struct variable.
	/// </summary>
	/// <returns><c>false</c> if decoded size != <c>sizeof(T)</c>.</returns>
	/// <param name="decoded">The result variable.</param>
	/// <inheritdoc cref="HexDecode(ReadOnlySpan{char})"/>
	public static bool HexDecode<T>(RStr encoded, out T decoded) where T : unmanaged {
		T t;
		if (HexDecode(encoded, &t, sizeof(T)) != sizeof(T)) { decoded = default; return false; }
		decoded = t;
		return true;
	}

	#endregion

	#region compress

	/// <summary>
	/// Compresses data. Uses <see cref="DeflateStream"/>.
	/// </summary>
	/// <param name="data">Data. See also: <see cref="MemoryMarshal.AsBytes"/>, <see cref="CollectionsMarshal.AsSpan"/>.</param>
	/// <exception cref="Exception">Exceptions of <see cref="DeflateStream"/>.</exception>
	public static byte[] DeflateCompress(RByte data) {
		using var m = new MemoryStream();
		using (var x = new DeflateStream(m, CompressionLevel.Optimal)) x.Write(data); //note: must dispose before ToArray
		return m.ToArray();
		//tested: GZipStream same compression but adds 18 bytes header. DeflateStream does not add any header.
		//tested: bz2 and 7z compression isn't much better with single 15 kb bmp file.
	}

	/// <summary>
	/// Decompresses data. Uses <see cref="DeflateStream"/>.
	/// </summary>
	/// <returns>Decompressed data.</returns>
	/// <param name="compressed">Compressed data.</param>
	/// <exception cref="Exception">Exceptions of <see cref="DeflateStream"/>.</exception>
	public static byte[] DeflateDecompress(RByte compressed) {
		using var m = new MemoryStream();
		DeflateDecompress(compressed, m);
		return m.ToArray();
	}

	/// <summary>
	/// Decompresses data to a caller-provided memory stream. Uses <see cref="DeflateStream"/>.
	/// </summary>
	/// <param name="compressed">Compressed data.</param>
	/// <param name="decompressed">Stream for decompressed data.</param>
	/// <exception cref="Exception">Exceptions of <see cref="DeflateStream"/>.</exception>
	public static void DeflateDecompress(RByte compressed, Stream decompressed) {
		fixed (byte* p = compressed) {
			using var m = new UnmanagedMemoryStream(p, compressed.Length);
			using var x = new DeflateStream(m, CompressionMode.Decompress);
			x.CopyTo(decompressed);
		}

		//note: cannot deflateStream.Read directly to array because its Length etc are not supported.
		//note: also cannot use decompressedStream.GetBuffer because it can be bigger.
	}

	/// <summary>
	/// Compresses data. Uses <see cref="GZipStream"/>.
	/// </summary>
	/// <param name="data">Data. See also: <see cref="MemoryMarshal.AsBytes"/>, <see cref="CollectionsMarshal.AsSpan"/>.</param>
	/// <exception cref="Exception">Exceptions of <see cref="GZipStream"/>.</exception>
	public static byte[] GzipCompress(RByte data) {
		using var m = new MemoryStream();
		using (var x = new GZipStream(m, CompressionLevel.Optimal)) x.Write(data);
		return m.ToArray();
	}

	/// <summary>
	/// Decompresses data. Uses <see cref="GZipStream"/>.
	/// </summary>
	/// <returns>Decompressed data.</returns>
	/// <param name="compressed">Compressed data.</param>
	/// <exception cref="Exception">Exceptions of <see cref="GZipStream"/>.</exception>
	public static byte[] GzipDecompress(RByte compressed) {
		using var m = new MemoryStream();
		GzipDecompress(compressed, m);
		return m.ToArray();
	}

	/// <summary>
	/// Decompresses data to a caller-provided memory stream. Uses <see cref="GZipStream"/>.
	/// </summary>
	/// <param name="compressed">Compressed data.</param>
	/// <param name="decompressed">Stream for decompressed data.</param>
	/// <exception cref="Exception">Exceptions of <see cref="GZipStream"/>.</exception>
	public static void GzipDecompress(RByte compressed, Stream decompressed) {
		fixed (byte* p = compressed) {
			using var m = new UnmanagedMemoryStream(p, compressed.Length);
			using var x = new GZipStream(m, CompressionMode.Decompress);
			x.CopyTo(decompressed);
		}
	}

	/// <summary>
	/// Compresses data. Uses <see cref="BrotliEncoder"/>.
	/// </summary>
	/// <param name="data">Data. See also: <see cref="MemoryMarshal.AsBytes"/>, <see cref="CollectionsMarshal.AsSpan"/>.</param>
	/// <param name="level">Compression level, 0 (no compression) to 11 (maximal compression). Default 6. Bigger levels don't make much smaller but can make much slower.</param>
	/// <exception cref="ArgumentOutOfRangeException">Invalid <i>level</i>.</exception>
	/// <exception cref="OutOfMemoryException"></exception>
	/// <exception cref="AuException"><see cref="BrotliEncoder.TryCompress"/> failed.</exception>
	public static unsafe byte[] BrotliCompress(RByte data, int level = 6) {
		int n = BrotliEncoder.GetMaxCompressedLength(data.Length)
			+ data.Length / 1000 + 1000; //GetMaxCompressedLength returns too small value, and TryCompress fails when data is already compressed
		var b = MemoryUtil.Alloc(n);
		try {
			if (!BrotliEncoder.TryCompress(data, new(b, n), out n, level, 22)) throw new AuException();
			return new Span<byte>(b, n).ToArray();
		}
		finally { MemoryUtil.Free(b); }
	}

	/// <summary>
	/// Decompresses data. Uses <see cref="BrotliDecoder"/>.
	/// </summary>
	/// <returns>Decompressed data.</returns>
	/// <param name="compressed">Compressed data.</param>
	/// <exception cref="ArgumentException">Invalid data.</exception>
	/// <exception cref="OutOfMemoryException"></exception>
	public static unsafe byte[] BrotliDecompress(RByte compressed) {
		int n = checked(compressed.Length * 4 + 8000);
		for (int i = 0; i < 3; i++) if (n < 512_000) n *= 2;
		//print.it(compressed.Length, n, n/compressed.Length); //usually ~ 80 KB
		for (; ; n = checked(n * 2)) {
			byte* b = MemoryUtil.Alloc(n);
			try {
				if (BrotliDecoder.TryDecompress(compressed, new(b, n), out int nw)) return new Span<byte>(b, nw).ToArray();
				if (nw == 0) throw new ArgumentException("cannot decompress this data");
				//print.it(n);
			}
			finally { MemoryUtil.Free(b); }
		}
	}

	#endregion

	#region encrypt

	/// <summary>
	/// AES-encrypts a <c>byte[]</c> or string. Returns <c>byte[]</c>.
	/// </summary>
	/// <param name="data">Data to encrypt. Can be <c>byte[]</c> or string.</param>
	/// <param name="key">Encryption key. Can be non-empty string (eg a password) or <c>byte[]</c> of length 16 (eg a password hash).</param>
	/// <returns>Encrypted data. The first 16 bytes is initialization vector (not secret).</returns>
	/// <exception cref="ArgumentException"></exception>
	/// <exception cref="CryptographicException"></exception>
	public static byte[] AesEncryptB(object data, object key) {
		Not_.Null(data, key);
		var enc = AesEncryptB(data, key, out var iv);
		var r = new byte[enc.Length + iv.Length];
		iv.CopyTo(r, 0);
		enc.CopyTo(r, iv.Length);
		return r;
	}

	/// <summary>
	/// AES-encrypts a <c>byte[]</c> or string. Returns <c>byte[]</c>.
	/// </summary>
	/// <param name="data">Data to encrypt. Can be <c>byte[]</c> or string.</param>
	/// <param name="key">Encryption key. Can be non-empty string (eg a password) or <c>byte[]</c> of length 16 (eg a password hash).</param>
	/// <param name="IV">Receives an initialization vector. The function generates a random value. Use it with decrypt functions. Don't need to keep it in secret.</param>
	/// <returns>Encrypted data.</returns>
	/// <exception cref="ArgumentException"></exception>
	/// <exception cref="CryptographicException"></exception>
	public static byte[] AesEncryptB(object data, object key, out byte[] IV) {
		Not_.Null(data, key);
		var d = data switch { byte[] b => b, string s => Encoding.UTF8.GetBytes(s), _ => throw new ArgumentException("Expected byte[] or string", "data") };
		using var aes = Aes.Create();
		using var x = aes.CreateEncryptor(_Key(key), IV = aes.IV);
		return x.TransformFinalBlock(d, 0, d.Length);
	}

	/// <summary>
	/// AES-encrypts a <c>byte[]</c> or string.
	/// Calls <see cref="AesEncryptB(object, object)"/> and converts the returned <c>byte[]</c> to Base64 string.
	/// </summary>
	/// <example>
	/// <code><![CDATA[
	/// var data = "Encryption example.";
	/// var key = "password";
	/// var enc = Convert2.AesEncryptS(data, key);
	/// print.it(enc);
	/// var dec = Convert2.AesDecryptS(enc, key);
	/// print.it(dec);
	/// ]]></code>
	/// </example>
	/// <inheritdoc cref="AesEncryptB(object, object)"/>
	public static string AesEncryptS(object data, object key) {
		Not_.Null(data, key);
		return Convert.ToBase64String(AesEncryptB(data, key));
	}

	/// <summary>
	/// AES-encrypts a <c>byte[]</c> or string.
	/// Calls <see cref="AesEncryptB(object, object, out byte[])"/> and converts the returned <c>byte[]</c> to Base64 string.
	/// </summary>
	/// <inheritdoc cref="AesEncryptB(object, object, out byte[])"/>
	public static string AesEncryptS(object data, object key, out byte[] IV) {
		Not_.Null(data, key);
		return Convert.ToBase64String(AesEncryptB(data, key, out IV));
	}

	/// <summary>
	/// AES-decrypts data. Returns <c>byte[]</c>.
	/// </summary>
	/// <param name="data">Encryped data as <c>byte[]</c> or Base64 string.</param>
	/// <param name="key">Encryption key. Can be non-empty string (eg a password) or <c>byte[]</c> of length 16 (eg a password hash).</param>
	/// <param name="IV">If used <c>AesEncryptX</c> that returns an initialization vector, pass it here.</param>
	/// <exception cref="ArgumentException"></exception>
	/// <exception cref="CryptographicException"></exception>
	public static byte[] AesDecryptB(object data, object key, byte[] IV = null) {
		Not_.Null(data, key);
		var d = data switch { byte[] b => b, string s => Convert.FromBase64String(s), _ => throw new ArgumentException("Expected byte[] or string", "data") };
		using var aes = Aes.Create();
		using var x = aes.CreateDecryptor(_Key(key), IV ?? d[..16]);
		var (from, len) = IV != null ? (0, d.Length) : (16, d.Length - 16);
		return x.TransformFinalBlock(d, from, len);
	}

	/// <summary>
	/// AES-decrypts data.
	/// Calls <see cref="AesDecryptB(object, object, byte[])"/> and converts the returned <c>byte[]</c> to string.
	/// </summary>
	/// <inheritdoc cref="AesDecryptB(object, object, byte[])"/>
	public static string AesDecryptS(object data, object key, byte[] IV = null) {
		Not_.Null(data, key);
		return Encoding.UTF8.GetString(AesDecryptB(data, key, IV));
	}

	static byte[] _Key(object key) {
		switch (key) {
		case byte[] b:
			if (b.Length != 16) throw new ArgumentException("Expected length 16", "key");
			return b;
		case string s:
			if (s.Length == 0) throw new ArgumentException("Empty string", "key");
			return Hash.MD5(s).ToArray();
		}
		throw new ArgumentException("Expected byte[] or string", "key");
	}

	#endregion

	#region utf8

	/// <summary>
	/// Converts string to UTF-8 <c>byte[]</c>. Can append <c>"\0"</c> (default) or some other string.
	/// </summary>
	/// <param name="chars">String or <c>char[]</c> or span of string/array/memory.</param>
	/// <param name="append">A string to append, or <c>null</c>. For example <c>"\0"</c> (default) or <c>"\r\n"</c>. Must contain only ASCII characters.</param>
	/// <exception cref="ArgumentException"><i>append</i> contains non-ASCII characters.</exception>
	public static byte[] Utf8Encode(RStr chars, string append = "\0") {
		int n = Encoding.UTF8.GetByteCount(chars);
		int nAppend = append.Lenn();
		var r = new byte[n + nAppend];
		int nn = Encoding.UTF8.GetBytes(chars, r);
		Debug.Assert(nn == n);
		if (nAppend > 0 && !(nAppend == 1 && append[0] == '\0')) {
			foreach (char c in append) {
				if (c > 127) throw new ArgumentException("append must be ASCII");
				r[nn++] = (byte)c;
			}
		}
		return r;

		//speed: faster than WideCharToMultiByte. Same as System.Text.Unicode.Utf8.FromUtf16.
	}

	/// <summary>
	/// Converts <c>'\0'</c>-terminated UTF-8 string to C# string (UTF-16).
	/// </summary>
	/// <param name="utf8">UTF-8 string. If <c>null</c>, returns <c>null</c>.</param>
	/// <remarks>
	/// Finds <c>'\0'</c> and calls <see cref="Encoding.GetString"/>. Don't use this function when UTF-8 string length is known; call <c>Encoding.UTF8.GetString</c> directly.
	/// </remarks>
	public static string Utf8Decode(byte* utf8) => utf8 == null ? null : Encoding.UTF8.GetString(utf8, Ptr_.Length(utf8));

	/// <summary>
	/// Converts string to UTF-8. If non-ASCII, gets UTF-8 character offsets.
	/// </summary>
	/// <returns>
	/// Tuple:
	/// <br/>• <c>text</c> - <c>Encoding.UTF8.GetBytes(s)</c>.
	/// <br/>• <c>offsets</c> - <c>null</c> if <i>s</i> is ASCII. Else UTF-8 character offsets for each <i>s</i> character plus at <c>s.Length</c>.
	/// </returns>
	internal static (byte[] text, int[] offsets) Utf8EncodeAndGetOffsets_(RStr s, bool append0 = false) {
		var s2 = Utf8Encode(s, append0 ? "\0" : ""); //always creates valid UTF-8. Replaces invalid UTF-16 chars.
		int len2 = s2.Length; if (append0) len2--;
		if (len2 == s.Length) return (s2, null); //ASCII

		var a = new int[s.Length + 1];
		int i8 = 0, i16 = 0;
		while (i8 < len2) {
			a[i16++] = i8;
			int c = s2[i8];
			if (c < 0xC0) i8++;
			else if (c < 0xE0) i8 += 2;
			else if (c < 0xF0) i8 += 3;
			else { a[i16++] = i8; i8 += 4; }
		}
		Debug.Assert(i8 == len2);
		Debug.Assert(i16 == s.Length);
		a[i16] = i8;
		return (s2, a);
	}

	#endregion

	#region base64 (rejected)

	///// <summary>
	///// Gets Base64 encoded string length for non-encoded length.
	///// It is <c>(length + 2) / 3 * 4</c>.
	///// </summary>
	//public static int Base64EncodeLength(int length) => checked((length + 2) / 3 * 4);

	///// <summary>
	///// Gets decoded data length from Base64 encoded string length, assuming there are no newlines and other whitespace characters.
	///// It is <c>(int)(len * 3L / 4)</c> minus the number of padding <c>'='</c> characters (max 2).
	///// </summary>
	//public static int Base64DecodeLength(RStr encoded) {
	//	int len = encoded.Length;
	//	if (len == 0) return 0;
	//	int r = (int)(len * 3L / 4);
	//	if (0 == (len & 3)) {
	//		if (encoded[len - 1] == '=') {
	//			r--;
	//			if (encoded[len - 2] == '=') r--;
	//		}
	//	}
	//	return r;
	//}

	//currently not used in this lib. Not tested speed.
	///// <summary>
	///// Converts string span containing Base64 encoded data to <c>byte[]</c>.
	///// </summary>
	///// <param name="encoded">String or <c>char[]</c> or span of string/array/memory containing Base64 encoded data.</param>
	///// <param name="result"></param>
	///// <returns><c>false</c> if failed.</returns>
	///// <remarks>
	///// Uses <see cref="Convert.TryFromBase64Chars"/>.
	///// </remarks>
	//public static bool TryBase64Decode(RStr encoded, out byte[] result) {
	//	result = null;
	//	encoded = encoded.Trim();
	//	//todo: calc length: skip whitespace. Maybe bool parameter. Or use FastBuffer and copy, like in HexDecode.
	//	var a = new byte[Base64DecodeLength(encoded)];
	//	if (!Convert.TryFromBase64Chars(encoded, a, out int len)) return false;
	//	if (len != a.Length) {
	//		Debug_.Print($"{a.Length} {len}");
	//		a = a.AsSpan(0, len).ToArray();
	//	}
	//	result = a;
	//	return true;
	//}

	//rejected: URL-safe Base64.
	//	Not used in this lib.
	//	Cannot be used in file names because case-sensitive.
	//	If somebody wants URL-safe Base64, it's easy/fast to replace unsafe characters. Nobody would find and use these functions.

	///// <summary>
	///// Converts <c>byte[]</c> or other memory to Base64 encoded string that can be used in URL.
	///// </summary>
	///// <param name="data">Data to encode.</param>
	///// <remarks>Like <see cref="Convert.ToBase64String(byte[])"/>, but instead of <c>'/'</c> and <c>'+'</c> uses <c>'_'</c> and <c>'-'</c>.</remarks>
	//public static string Base64UrlEncode(RByte data) {
	//	fixed (byte* p = data) return Base64UrlEncode(p, data.Length);

	//	//speed: same as Convert.ToBase64String
	//}

	///// <summary>
	///// Converts binary data stored in any memory to Base64 encoded string that can be used in URL.
	///// </summary>
	///// <param name="data">Data to encode.</param>
	///// <param name="length">Number of bytes to encode.</param>
	///// <remarks>Instead of <c>'/'</c> and <c>'+'</c> uses <c>'_'</c> and <c>'-'</c>.</remarks>
	//public static string Base64UrlEncode(void* data, int length) {
	//	var ip = (IntPtr)data;
	//	return string.Create(Base64EncodeLength(length), (ip, length), static (span, tu) => {
	//		Convert.TryToBase64Chars(new RByte((byte*)tu.ip, tu.length), span, out _);
	//		for (int i = 0; i < span.Length; i++) {
	//			switch (span[i]) { case '/': span[i] = '_'; break; case '+': span[i] = '-'; break; }
	//		}
	//	});
	//}

	///// <summary>
	///// Converts a struct variable to Base64 encoded string that can be used in URL.
	///// </summary>
	///// <param name="x">Variable.</param>
	///// <remarks>Instead of <c>'/'</c> and <c>'+'</c> uses <c>'_'</c> and <c>'-'</c>.</remarks>
	//public static string Base64UrlEncode<T>(T x) where T : unmanaged {
	//	return Base64UrlEncode(&x, sizeof(T));
	//}

	//static void _Base64_Replace(RStr encoded, char[] a) {
	//	for (int i = 0; i < encoded.Length; i++) {
	//		char c = encoded[i];
	//		a[i] = c switch { '_' => '/', '-' => '+', _ => c, };
	//	}
	//}

	///// <summary>
	///// Converts string containing Base64 encoded data to <c>byte[]</c>. Supports standard encoding and URL-safe encoding.
	///// </summary>
	///// <param name="encoded">String or <c>char[]</c> or span of string/array/memory containing Base64 encoded data.</param>
	///// <remarks>Like <see cref="Convert.FromBase64String(string)"/>, but the string can contain <c>'_'</c> and <c>'-'</c> instead of <c>'/'</c> and <c>'+'</c>.</remarks>
	///// <exception cref="Exception">Exceptions of <see cref="Convert.FromBase64CharArray"/>.</exception>
	//public static byte[] Base64UrlDecode(RStr encoded) {
	//	char[] a = ArrayPool<char>.Shared.Rent(encoded.Length);
	//	try {
	//		_Base64_Replace(encoded, a);
	//		return Convert.FromBase64CharArray(a, 0, encoded.Length);
	//	}
	//	finally { ArrayPool<char>.Shared.Return(a); }
	//	//never mind: almost 2 times slower than Convert.FromBase64CharArray.
	//	//	Normally this func is used with short strings and not with many strings in loop.
	//	//	ArrayPool isn't as fast as should be. And copying to new array takes time.
	//}

	///// <summary>
	///// Converts string containing Base64 encoded data to bytes and stores in memory of a <c>Span</c> variable. Supports standard encoding and URL-safe encoding.
	///// Returns <c>false</c> if the encoded string is invalid or the buffer is too small.
	///// </summary>
	///// <param name="encoded">String or <c>char[]</c> or span of string/array/memory containing Base64 encoded data.</param>
	///// <param name="decoded">Memory buffer for the result.</param>
	///// <param name="decodedLength"></param>
	///// <remarks>The string can contain <c>'_'</c> and <c>'-'</c> instead of <c>'/'</c> and <c>'+'</c>.</remarks>
	//public static bool Base64UrlDecode(RStr encoded, Span<byte> decoded, out int decodedLength) {
	//	char[] a = ArrayPool<char>.Shared.Rent(encoded.Length);
	//	try {
	//		_Base64_Replace(encoded, a);
	//		return Convert.TryFromBase64Chars(new RStr(a, 0, encoded.Length), decoded, out decodedLength);
	//	}
	//	finally { ArrayPool<char>.Shared.Return(a); }
	//}

	///// <summary>
	///// Converts string containing Base64 encoded data to bytes and stores in any memory. Supports standard encoding and URL-safe encoding.
	///// Returns <c>false</c> if the encoded string is invalid or the buffer is too small.
	///// </summary>
	///// <param name="encoded">String or <c>char[]</c> or span of string/array/memory containing Base64 encoded data.</param>
	///// <param name="decoded">Memory buffer for the result.</param>
	///// <param name="bufferSize">The max number of bytes that can be written to the <i>decoded</i> memory buffer.</param>
	///// <param name="decodedLength">Receives the number of bytes written to the <i>decoded</i> memory buffer.</param>
	///// <remarks>The string can contain <c>'_'</c> and <c>'-'</c> instead of <c>'/'</c> and <c>'+'</c>.</remarks>
	//public static bool Base64UrlDecode(RStr encoded, void* decoded, int bufferSize, out int decodedLength) {
	//	return Base64UrlDecode(encoded, new Span<byte>(decoded, bufferSize), out decodedLength);
	//}

	///// <summary>
	///// Converts string containing Base64 encoded data to a struct variable. Supports standard encoding and URL-safe encoding.
	///// Returns <c>false</c> if the encoded string is invalid or decoded size != <c>sizeof(T)</c>.
	///// </summary>
	///// <param name="encoded">String or <c>char[]</c> or span of string/array/memory containing Base64 encoded data.</param>
	///// <param name="decoded">The result variable.</param>
	///// <remarks>The string can contain <c>'_'</c> and <c>'-'</c> instead of <c>'/'</c> and <c>'+'</c>.</remarks>
	//public static bool Base64UrlDecode<T>(RStr encoded, out T decoded) where T : unmanaged {
	//	T t;
	//	if (!Base64UrlDecode(encoded, &t, sizeof(T), out int n) || n != sizeof(T)) { decoded = default; return false; }
	//	decoded = t;
	//	return true;
	//}

	#endregion
}


================================================
FILE: Au/Au.More/DebugTraceListener.cs
================================================
namespace Au.More;

/// <summary>
/// Replaces the default trace listener with a listener that shows a message box on a failed assertion.
/// </summary>
/// <remarks>
/// The new trace listener overrides the <see cref="DefaultTraceListener.Fail(string?, string?)"/> method.
/// On failed assertion (<see cref="Debug.Assert"/>, <see cref="Trace.Assert"/>, <see cref="Debug.Fail"/>, <see cref="Trace.Fail"/>) it shows a message box with buttons <b>Exit</b> <b>Debug</b> <b>Ignore</b>, unless debugger is attached or <see cref="DefaultTraceListener.AssertUiEnabled"/> is <c>false</c>.
/// </remarks>
public class DebugTraceListener : DefaultTraceListener {
	/// <summary>
	/// Replaces default trace listener.
	/// </summary>
	/// <param name="usePrint">Also set <see cref="print.redirectDebugOutput"/> = <c>true</c>.</param>
	//[Conditional("DEBUG"), Conditional("TRACE")] //no, in most cases this is called by this library, not directly by the app
	public static void Setup(bool usePrint) {
		if (!s_setup) {
			s_setup = true;
			Trace.Listeners.Remove("Default"); //remove DefaultTraceListener. It calls Environment.FailFast which shows message box "Unknown hard error".
			Trace.Listeners.Add(new DebugTraceListener());
		}
		print.redirectDebugOutput = usePrint;
	}
	static bool s_setup;

	///
	public override void Fail(string message, string detailMessage) {
		var s = message;
		if (s.NE()) s = detailMessage; else if (!detailMessage.NE()) s = message + "\r\n" + detailMessage;
		if (!s.NE()) s += "\r\n";

		string st = new StackTrace(2, true).ToString(), st1 = null;
		if (st.RxMatch(@"(?m)^\s+at (?!System\.Diagnostics\.)", 0, out RXGroup g)) {
			st = st[g.Start..];
			st1 = st.Lines(true)[0];
		}

		var s2 = "---- Debug assertion failed ----\r\n" + s + st;
		Trace.WriteLine(s2);
		if (!(print.redirectDebugOutput && print.qm2.use)) print.qm2.write(s2);

		if (Debugger.IsAttached) {
			Debugger.Break();
		} else {
			if (!AssertUiEnabled) return; //like default listener

			s = $"{s}{st1}\n\nProcess id: {process.thisProcessId}";
			
			//int r = dialog.showWarning("Debug assertion failed", s, "1 Exit|2 Ignore|3 script.debug|4 Debugger.Launch", expandedText: st); //no. Need to block all messages in this thread, to prevent reentering this or executing code somewhere else.
			//int r = Task.Run(() => dialog.showWarning("Debug assertion failed", s, "1 Exit|2 Ignore|3 script.debug|4 Debugger.Launch", expandedText: st)).Result; //no. It seems .NET adds messages (eg WM_TIMER) to a queue, and finally reposts all.
			int r = 0;
			var thread = run.thread(() => { r = dialog.showWarning("Debug assertion failed", s, "1 Exit|2 Ignore|3 script.debug|4 Debugger.Launch", expandedText: st); });
			do 100.ms(); while (thread.IsAlive);
			
			if (r == 1) Api.ExitProcess(-1);
			if (r == 2) return;
			if (r == 4) Debugger.Launch();
			else {
				script.debug();
				Debugger.Break();
			}
		}
	}
}


================================================
FILE: Au/Au.More/Dpi.cs
================================================
namespace Au.More {
	/// <summary>
	/// Functions for high-DPI screen support.
	/// </summary>
	/// <remarks>
	/// To find DPI % on Windows 10 and 11: <b>Settings > System > Display > Scale and layout</b>. If not 100%, it means high DPI.
	/// 
	/// This program must be per-monitor-DPI-aware. Else results are undefined.
	/// </remarks>
	public static class Dpi {
		/// <summary>
		/// Gets DPI of the primary screen at the time this process started.
		/// </summary>
		public static int System {
			get {
				if (_systemDPI == 0) {
					using var dcs = new ScreenDC_();
					_systemDPI = Api.GetDeviceCaps(dcs, 90); //LOGPIXELSY

					//could use GetDpiForSystem instead (Windows 10 1607).
					//	Normally the same result (tested), but probably not if thread awareness context is Unaware (not tested).
				}
				return _systemDPI;
			}
		}
		static int _systemDPI;

		/// <summary>
		/// Gets the DPI of a window, as used in the window's process. It never changes for that window instance.
		/// </summary>
		/// <returns>If failed, returns the system DPI (<see cref="System"/>).</returns>
		/// <param name="w">A top-level window or control. Can belong to any process.</param>
		/// <param name="supportWin81">
		/// If <c>true</c>, works on Windows 8.1 and later; however on Windows 8.1 slower and less reliable.
		/// If <c>false</c> (default), works on Windows 10 1607 and later.
		/// </param>
		/// <remarks>
		/// The result depends on the DPI awareness of the window:
		/// - per-monitor-DPI-aware - usually DPI of the windows's screen.
		/// - system aware - system DPI (DPI of the primary screen).
		/// - unaware - 96.
		/// 
		/// The result also depends on the Windows version:
		/// - Works best on Windows 10 1607 and later. Uses API <ms>GetDpiForWindow</ms>.
		/// - On Windows 8.1 works if <i>supportWin81</i> <c>true</c>. If <c>false</c> (default), returns <see cref="System"/>.
		/// - On Windows 7 and 8.0 always returns <see cref="System"/>, because there are no Windows API. Most apps are system-DPI-aware and the result is correct; for unaware apps the result is incorrect. These Windows versions don't support per-monitor DPI.
		/// </remarks>
		public static int OfWindow(wnd w, bool supportWin81 = false) {
			if (!osVersion.minWin8_1) return System;
			int R = 0;
			if (!w.Is0) {
				if (osVersion.minWin10_1607) R = Api.GetDpiForWindow(w);
				else if (supportWin81) {
					var v = WindowDpiAwareness(w); //info: quickly returns Awareness.PerMonitor if w.IsOfThisProcess
					if (v == Awareness.Unaware) R = 96;
					else if (v == Awareness.PerMonitor)
						if (0 != Api.GetDpiForMonitor(Api.MonitorFromWindow(w.Window, SODefault.Nearest), 0, out R, out _)) R = 0;
				}
			}
			return R != 0 ? R : System;
		}

		/// <summary>
		/// Returns <c>OfWindow(w.Hwnd())</c>.
		/// </summary>
		/// <param name="w">A Winforms window or control.</param>
		public static int OfWindow(System.Windows.Forms.Control w) => OfWindow(w.Hwnd());
		//rejected: supportWin81

		/// <summary>
		/// Returns <c>OfWindow(w.Hwnd())</c>.
		/// </summary>
		/// <param name="w">A WPF window or element.</param>
		public static int OfWindow(System.Windows.DependencyObject w) => OfWindow(w.Hwnd());

		/// <summary>
		/// Gets DPI of a screen.
		/// </summary>
		/// <returns><see cref="System"/> if fails or if not supported on this Windows version.</returns>
		/// <param name="hMonitor">Native screen handle (<c>HMONITOR</c>).</param>
		/// <param name="supportWin81">Support Windows 8.1 and later. If <c>false</c> (default), supports Windows 10 1607 and later.</param>
		/// <remarks>
		/// Uses API <ms>GetDpiForMonitor</ms>.
		/// </remarks>
		/// <seealso cref="screen.Dpi"/>
		public static int OfScreen(IntPtr hMonitor, bool supportWin81 = false) {
			bool os = supportWin81 ? osVersion.minWin8_1 : osVersion.minWin10_1607;
			return os && 0 == Api.GetDpiForMonitor(hMonitor, 0, out int R, out _) ? R : System;
		}

		/////
		//public static int OfScreen(screen s, bool supportWin81 = false) => OfScreen(s.Now, supportWin81);

		/// <summary>
		/// Scales <c>int</c> if the specified DPI isn't 96 (100%).
		/// </summary>
		public static int Scale(int i, DpiOf dpiOf) => Math2.MulDiv(i, dpiOf, 96);

		//no. Eg also would be used for uint, long... Or name eg ScaleD. Or add double extension method.
		///// <summary>
		///// Scales <c>int</c> if the specified DPI isn't 96 (100%).
		///// </summary>
		//public static int Scale(double i, DpiOf dpiOf) => (i*(int)dpiOf/96).ToInt();

		/// <summary>
		/// Unscales <c>int</c> if the specified DPI isn't 96 (100%).
		/// </summary>
		public static double Unscale(int i, DpiOf dpiOf) => i * (96d / dpiOf);
		//Unscaling sometimes useful with WPF. Unscale to double, not int, else result often incorrect.

		/// <summary>
		/// Scales <see cref="SIZE"/> if the specified DPI isn't 96 (100%).
		/// </summary>
		public static SIZE Scale(SIZE z, DpiOf dpiOf) {
			int dpi = dpiOf;
			z.width = Math2.MulDiv(z.width, dpi, 96);
			z.height = Math2.MulDiv(z.height, dpi, 96);
			return z;
		}

		/// <summary>
		/// Scales <see cref="System.Windows.Size"/> if the specified DPI isn't 96 (100%).
		/// </summary>
		public static SIZE Scale(System.Windows.Size z, DpiOf dpiOf) {
			double f = (int)dpiOf / 96d;
			z.Width *= f;
			z.Height *= f;
			return new(z.Width.ToInt(), z.Height.ToInt());
		}

		/// <summary>
		/// Unscales <see cref="SIZE"/> if the specified DPI isn't 96 (100%).
		/// </summary>
		public static System.Windows.Size Unscale(SIZE z, DpiOf dpiOf) {
			double f = 96d / dpiOf;
			return new(z.width * f, z.height * f);
		}

		/// <summary>
		/// Scales <see cref="RECT"/> if the specified DPI isn't 96 (100%).
		/// </summary>
		public static RECT Scale(RECT r, DpiOf dpiOf) {
			int dpi = dpiOf;
			r.left = Math2.MulDiv(r.left, dpi, 96);
			r.top = Math2.MulDiv(r.top, dpi, 96);
			r.right = Math2.MulDiv(r.right, dpi, 96);
			r.bottom = Math2.MulDiv(r.bottom, dpi, 96);
			return r;
		}

		/// <summary>
		/// Unscales <see cref="RECT"/> if the specified DPI isn't 96 (100%).
		/// </summary>
		public static System.Windows.Rect Unscale(RECT r, DpiOf dpiOf) {
			double f = 96d / dpiOf;
			return new(r.left * f, r.top * f, r.Width * f, r.Height * f);
		}

		/// <summary>
		/// Calls API <ms>GetSystemMetricsForDpi</ms> if available, else <ms>GetSystemMetrics</ms>.
		/// </summary>
		public static int GetSystemMetrics(int nIndex, DpiOf dpiOf)
			=> osVersion.minWin10_1607
			? Api.GetSystemMetricsForDpi(nIndex, dpiOf)
			: Api.GetSystemMetrics(nIndex);

		/// <summary>
		/// Calls API <ms>SystemParametersInfoForDpi</ms> if available, else <ms>SystemParametersInfo</ms>.
		/// Use only with <i>uiAction</i> = <ms>SPI_GETICONTITLELOGFONT</ms>, <ms>SPI_GETICONMETRICS</ms>, <ms>SPI_GETNONCLIENTMETRICS</ms>.
		/// </summary>
		public static unsafe bool SystemParametersInfo(uint uiAction, int uiParam, void* pvParam, DpiOf dpiOf)
			=> osVersion.minWin10_1607
			? Api.SystemParametersInfoForDpi(uiAction, uiParam, pvParam, 0, dpiOf)
			: Api.SystemParametersInfo(uiAction, uiParam, pvParam);

		/// <summary>
		/// Calls API <ms>AdjustWindowRectExForDpi</ms> if available, else <ms>AdjustWindowRectEx</ms>.
		/// </summary>
		/// <remarks>
		/// Also adds scrollbar width or/and height if need.
		/// </remarks>
		public static bool AdjustWindowRectEx(DpiOf dpiOf, ref RECT r, WS style, WSE exStyle, bool hasMenu = false) {
			int dpi = dpiOf;
			bool ok = osVersion.minWin10_1607
				? Api.AdjustWindowRectExForDpi(ref r, style, hasMenu, exStyle, dpi)
				: Api.AdjustWindowRectEx(ref r, style, hasMenu, exStyle);
			if (ok) {
				if (style.Has(WS.VSCROLL)) r.Width += ScrollbarV_(dpi);
				if (style.Has(WS.HSCROLL)) r.Width += ScrollbarH_(dpi);
			}
			return ok;
		}

		internal static int ScrollbarV_(int dpi) => GetSystemMetrics(Api.SM_CXVSCROLL, dpi);
		internal static int ScrollbarH_(int dpi) => GetSystemMetrics(Api.SM_CYHSCROLL, dpi);

		/// <summary>
		/// DPI awareness of a window or process.
		/// </summary>
		public enum Awareness { //== DPI_AWARENESS == PROCESS_DPI_AWARENESS
			///
			Invalid = -1,
			///
			Unaware,
			///
			System,
			///
			PerMonitor
		}

		/// <summary>
		/// Gets DPI awareness of a window.
		/// </summary>
		/// <returns><see cref="Awareness.Invalid"/> if failed.</returns>
		/// <param name="w">A top-level window or control. Can belong to any process.</param>
		/// <remarks>
		/// Works best on Windows 10 1607 and later; uses API <ms>GetWindowDpiAwarenessContext</ms>.
		/// On Windows 8.1 returns <see cref="Awareness.PerMonitor"/> if <i>w</i> is of this process; else uses API <ms>GetProcessDpiAwareness</ms>, which is slower and less reliable.
		/// On Windows 7 and 8.0 always returns <see cref="Awareness.System"/>, because there are no Windows API.
		/// </remarks>
		public static Awareness WindowDpiAwareness(wnd w) {
			if (osVersion.minWin10_1607) {
				return Api.GetAwarenessFromDpiAwarenessContext(Api.GetWindowDpiAwarenessContext(w));
			} else if (osVersion.minWin8_1) {
				if (w.IsOfThisProcess) return Awareness.PerMonitor;
				using var hp = Handle_.OpenProcess(w);
				return (!hp.Is0 && 0 == Api.GetProcessDpiAwareness(hp, out var a)) ? a : Awareness.Invalid;
			} else {
				return Awareness.System;
				//could use, IsWindowVirtualized (except if of this process), but slow and unreliable.
			}
		}

		/// <summary>
		/// Detects whether the window is DPI-scaled/virtualized.
		/// </summary>
		/// <returns><c>false</c> if not DPI-scaled/virtualized or if fails to detect or if invalid window handle.</returns>
		/// <param name="w">A top-level window or control. Can belong to any process.</param>
		/// <remarks>
		/// Such windows are a little blurry (entire client area).
		/// 
		/// OS scales a window when it is on a high-DPI screen, depending on the DPI awareness of the window:
		/// - Unaware - always.
		/// - System - if the screen DPI is not equal to the system DPI of that process (which usually is of the primary screen, but not always).
		/// 
		/// Such windows have various problems for automation apps:
		/// - Often difficult or impossible to get correct rectangles of UI elements (and therefore cannot click etc) or get correct UI element from point. It depends on used API (UIA, MSAA, JAB), inproc/notinproc, OS version and application.
		/// - On Windows 7 and 8.0 cannot easily get correct rectangles of such windows and their controls. This library ignores it, because would be too much work to apply workarounds in so many places and just for legacy OS versions (it has been fixed in Windows 8.1).
		/// - If with <see cref="uiimage"/> want to use window pixels, need to capture image from window pixels, not from screen pixels.
		/// 
		/// This function is not completely reliable. And not very fast. This process must be per-monitor-DPI-aware.
		/// </remarks>
		public static bool IsWindowVirtualized(wnd w) {
			if (GetScalingInfo_(w, out bool scaled, out _, out _)) return scaled;
			return IsWindowVirtualizedLegacy_(w);

			//note: child windows can have different DPI awareness (minWin10_1607). See GetWindowDpiHostingBehavior. Not tested, not seen.

			//Also tested detecting with GDI. GDI functions return logical (not DPI-scaled) offsets/rectangles/etc. Works, but much slower.
		}

		/// <summary>
		/// On Win10+ returns <see cref="IsWindowVirtualized"/>. Else <c>false</c>.
		/// </summary>
		internal static bool IsWindowVirtualizedWin10_(wnd w) => osVersion.minWin10_1607 && IsWindowVirtualized(w);

		/// <summary>
		/// If possible, gets whether the window is DPI-scaled/virtualized, and gets physical and logical rects if scaled.
		/// Returns <c>false</c> if <c>!osVersion.minWin10_1607</c> or if cannot get that info.
		/// Gets that info in a fast and reliable way.
		/// </summary>
		internal static bool GetScalingInfo_(wnd w, out bool scaled, out RECT rPhysical, out RECT rLogical) {
			scaled = false; rPhysical = default; rLogical = default;
			if (!osVersion.minWin10_1607) return false;
			var awareness = WindowDpiAwareness(w); //fast on Win10
			if (awareness is Awareness.System or Awareness.Unaware) { //tested: unaware-gdi-scaled same as unaware
				if (awareness == Awareness.System && Api.GetDpiForWindow(w) != System) { /*fast*/
					//Cannot get rLogical. It's rare and temporary, ie when the user recently changed DPI of the primary screen.
					//Even if this func isn't used to get rects, without this fast code could be unreliable.
					Debug_.Print("w System DPI != our System DPI");
					return false;
				}
				for (; ; ) {
					RECT r1 = w.Rect, r2, r3; //note: with ClientRect 4 times faster, but unreliable if small rect. Now fast enough.
					bool rectWorkaround = false;
					using (var u = new AwarenessContext(awareness == Awareness.System ? -2 : -1)) {
						if (Api.GetAwarenessFromDpiAwarenessContext(u.Previous_) != Awareness.PerMonitor) { /*fast*/
							//cannot get rPhysical. But let's set PM awareness and get it. Works even if this process is Unaware.
							rectWorkaround = _GetRect(w, out r1);
							Debug_.Print("bad DPI awareness of this thread; workaround " + (rectWorkaround ? "OK" : "failed"));
							if (!rectWorkaround) return false; //unlikely. Then the caller probably will call the legacy func, it works with any DPI awareness.
						}
						r2 = w.Rect;
						if (r2 == r1) break;
					}
					if (!rectWorkaround) r3 = w.Rect; else _GetRect(w, out r3);
					if (r3 != r1) continue; //moved, resized or closed between Rect and Rect
					scaled = true;
					rPhysical = r1;
					rLogical = r2;
					break;
				}

				static bool _GetRect(wnd w, out RECT r) {
					using (var u2 = new AwarenessContext(-4)) { //per-monitor-v2
						if (u2.Previous_ == 0) { r = default; return false; } //API failed. Unlikely. Works even if this process is Unaware.
						r = w.Rect;
					}
					return true;
				}
			}
			return true;
		}

		internal static bool IsWindowVirtualizedLegacy_(wnd w) {
			//less reliable if control.
			//	LogicalToPhysicalPoint fails if not in top-level window rect.
			//	It seems PhysicalToLogicalPointForPerMonitorDPI doesn't fail, but it fails if not in that screen.
			w = w.Window;

			RECT rPrev = default;
			for (int i = 0; i < 5; i++) {
				if (!Api.GetWindowRect(w, out var r)) break; //Win10 1 mcs hot, 20 cold, old OS fast
				if (r != rPrev) { i = 0; rPrev = r; } //moved or resized
				POINT p = new(r.CenterX, r.CenterY); //p must be inside the window
				if (i == 1) p.y = r.bottom - 1; else if (i == 2) p.y = r.top; else if (i == 3) p.x = r.right - 1; else if (i == 4) p.x = r.left; //and p must be in correct screen, which is unknown and therefore we use this code to guess. Normally succeeds at i==0, but may fail when the window is more than in 1 screen.
				POINT k = p;
				if (osVersion.minWin8_1 ? Api.PhysicalToLogicalPointForPerMonitorDPI(w, ref p) : Api.LogicalToPhysicalPoint(w, ref p)) { //Win10 3 mcs hot, old OS fast

					//API bug: may scale the point although the window isn't scaled. Never mind.
					//	When window's center is between 2 screens and at the same time half of the window is offscreen. The area is several pixels wide.
					//if (p != k) print.it(k, p);

					if (p != k) return true;
					break;
				}
			}
			return false;
			//tested: the API works with hidden and off-screen top-level windows too. Minimized windows are off-screen.
			//tested: works even if this process is DPI System or Unaware. Tested on Win10.
			//speed on Win10 when not PM-aware: 4 mcs hot, 40 mcs cold. All API much faster on old OS (tested on Vmware).
		}

		//No. In some cases (window positions) screen.of(w) does not match scaling. Not much faster.
		//public static bool IsWindowVirtualized2(wnd w) {
		//	if (osVersion.minWin10_1607) {
		//		if (WindowDpiAwareness(w) is Awareness.PerMonitor or Awareness.Invalid) return false; //fast on Win10; slow on Win8.1, unavailable on Win7/8. Other API very slow on Win10, much faster on old OS (Vmware).
		//		w = w.Window; if (w.Is0) return false; //0.6 mcs hot
		//		var m = screen.of(w);
		//		int d1 = m.Dpi, d2 = OfWindow(w);
		//		//if (d1 == d2) print.it(d1);
		//		if (d1 == d2) return false;
		//		return w.IsAlive;
		//	} else {
		//		//same as now
		//		return false;
		//	}
		//}

		/// <summary>
		/// Can be used to temporarily change thread's DPI awareness context with API <ms>SetThreadDpiAwarenessContext</ms>.
		/// Does nothing if the API is unavailable (added in Windows 10 version 1607).
		/// </summary>
		/// <remarks>
		/// Programs that use this library should use manifest with <c>dpiAwareness = PerMonitorV2</c> and <c>dpiAware = True/PM</c>. Then default DPI awareness context is <ms>DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2</ms>.
		/// </remarks>
		/// <example>
		/// <code><![CDATA[
		/// using var dac = new Dpi.AwarenessContext(-1);
		/// ]]></code>
		/// </example>
		public struct AwarenessContext : IDisposable {
			nint _dac;

			/// <summary>
			/// If <see cref="Available"/>, calls API <ms>SetThreadDpiAwarenessContext</ms>.
			/// </summary>
			/// <param name="dpiContext">One of <ms>DPI_AWARENESS_CONTEXT</ms> constants: -1 <c>unaware</c>, -2 <c>system</c>, -3 <c>per-monitor</c>, -4 <c>per-monitor-v2</c>, -5 <c>unaware-gdiscaled</c>. Or a <ms>DPI_AWARENESS_CONTEXT</ms> handle.</param>
			public AwarenessContext(nint dpiContext) {
				_dac = osVersion.minWin10_1607 ? Api.SetThreadDpiAwarenessContext(dpiContext) : default;
			}
			//rejected: enum dpiContext.

			/// <summary>
			/// If <see cref="Available"/>, calls API <ms>GetWindowDpiAwarenessContext</ms> and <ms>SetThreadDpiAwarenessContext</ms>. Sets the awareness context of this thread equal to that of the window.
			/// </summary>
			public AwarenessContext(wnd w) : this(Available ? Api.GetWindowDpiAwarenessContext(w) : 0) { }

			/// <summary>
			/// Restores previous DPI awareness context.
			/// </summary>
			public void Dispose() {
				if (_dac == default) return;
				Api.SetThreadDpiAwarenessContext(_dac);
				_dac = default;
			}

			///
			internal nint Previous_ => _dac;

			/// <summary>
			/// Returns <c>true</c> if thread DPI awareness contexts are available on this Windows version (Windows 10 1607 and later).
			/// </summary>
			public static bool Available => osVersion.minWin10_1607;

			/////
			//public const nint DPI_AWARENESS_CONTEXT_UNAWARE = -1;
			/////
			//public const nint DPI_AWARENESS_CONTEXT_SYSTEM_AWARE = -2;
			/////
			//public const nint DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE = -3;
			/////
			//public const nint DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2 = -4;
			/////
			//public const nint DPI_AWARENESS_CONTEXT_UNAWARE_GDISCALED = -5;
		}
	}
}

namespace Au.Types {
	/// <summary>
	/// Used for <i>dpiOf</i> parameter of functions. Allows to pass either a DPI value or an object from which gets DPI (window, screen etc).
	/// </summary>
	/// <remarks>
	/// Has implicit conversions from:
	/// <br/>• <c>int</c> - DPI.
	/// <br/>• <see cref="wnd"/> - gets DPI of the window.
	/// <br/>• <c>IntPtr</c> or <c>nint</c> - (screen handle) gets DPI of the screen.
	/// <br/>• <see cref="POINT"/> - gets DPI of the screen that contains the point.
	/// <br/>• <see cref="RECT"/> - gets DPI of screen that contains the rectangle.
	/// <br/>• <see cref="System.Windows.Forms.Control"/> - gets DPI of the winforms control.
	/// <br/>• <see cref="System.Windows.DependencyObject"/> - gets DPI of the WPF element.
	/// 
	/// The conversion operators set the <see cref="Dpi"/> property and the function can use it.
	/// </remarks>
	public struct DpiOf {
		readonly int _dpi;

		///
		public DpiOf(int dpi) { _dpi = dpi; }

		/// <exception cref="AuWndException">Invalid window handle.</exception>
		public DpiOf(wnd w) {
			w.ThrowIfInvalid();
			_dpi = More.Dpi.OfWindow(w);
		}
		//rejected: parameter supportWin81. Rarely used. Can use Dpi functions when need.

		/// <exception cref="ArgumentNullException"></exception>
		/// <exception cref="AuWndException">Invalid window handle.</exception>
		public DpiOf(System.Windows.Forms.Control c) : this(Not_.NullRet(c).Hwnd()) { }

		/// <exception cref="ArgumentNullException"></exception>
		/// <exception cref="AuWndException">Invalid window handle.</exception>
		public DpiOf(System.Windows.DependencyObject c) : this(Not_.NullRet(c).Hwnd()) { }

		///
		public DpiOf(IntPtr hMonitor) { _dpi = More.Dpi.OfScreen(hMonitor); }

		///
		public DpiOf(POINT screenOf) : this(screen.of(screenOf).Handle) { }

		///
		public DpiOf(RECT screenOf) : this(screen.of(screenOf).Handle) { }

		///
		public static implicit operator DpiOf(int dpi) => new(dpi);

		/// <exception cref="AuWndException">Invalid window handle.</exception>
		public static implicit operator DpiOf(wnd w) => new(w);

		/// <exception cref="ArgumentNullException"></exception>
		/// <exception cref="AuWndException">Invalid window handle.</exception>
		public static implicit operator DpiOf(System.Windows.Forms.Control c) => new(c);

		/// <exception cref="ArgumentNullException"></exception>
		/// <exception cref="AuWndException">Invalid window handle.</exception>
		public static implicit operator DpiOf(System.Windows.DependencyObject c) => new(c);

		///
		public static implicit operator DpiOf(IntPtr hMonitor) => new(hMonitor);

		///
		public static implicit operator DpiOf(POINT screenOf) => new(screenOf);

		///
		public static implicit operator DpiOf(RECT screenOf) => new(screenOf);

		///
		public int Dpi => _dpi;

		///
		public static implicit operator int(DpiOf d) => d._dpi;
	}
}

================================================
FILE: Au/Au.More/FastBuffer.cs
================================================
namespace Au.More {
	/// <summary>
	/// Memory buffer on stack with ability to expand and use heap memory.
	/// Can be used for calling Windows API or building arrays.
	/// Must be used with <c>[SkipLocalsInit]</c> attribute; add it to the caller function or class.
	/// </summary>
	/// <example>
	/// <code><![CDATA[
	/// print.it(api.GetEnvironmentVariable("temp"));
	/// 
	/// unsafe class api : NativeApi {
	/// 	[DllImport("kernel32.dll", EntryPoint = "GetEnvironmentVariableW", SetLastError = true)]
	/// 	static extern int _GetEnvironmentVariable(string lpName, char* lpBuffer, int nSize);
	/// 
	/// 	[SkipLocalsInit]
	/// 	internal static string GetEnvironmentVariable(string name) {
	/// 		using FastBuffer<char> b = new();
	/// 		for (; ; ) if (b.GetString(_GetEnvironmentVariable(name, b.p, b.n), out var s)) return s;
	/// 	}
	/// }
	/// ]]></code>
	/// </example>
	[StructLayout(LayoutKind.Sequential, Size = 16 + StackSize + 16)] //16 for other fields + 16 for safety
	public unsafe ref struct FastBuffer<T> where T : unmanaged {
		T* _p; //buffer pointer (on stack or native heap)
		int _n; //buffer length (count of T elements)
		bool _free; //if false, buffer is on stack in this variable (_p=&_stack). If true, buffer is allocated with MemoryUtil.Alloc.
		long _stack; //start of buffer of StackSize size

		/// <summary>
		/// A <see cref="FastBuffer{T}"/> variable contains a field of this size. It is a memory buffer on stack.
		/// It is a byte count and does not depend on <c>T</c>. To get count of <c>T</c> elements on stack: <c>StackSize/sizeof(T)</c>.
		/// </summary>
		public const int StackSize = 2048;
		//const int StackSize = 16; //test More() and GetString()

		//Also tested:
		//	1. Struct of normal size, when caller passes stackalloc'ed Span<T>. Slow in Debug. And more caling code.
		//	2. See the commented out Buffer_.
		//	3. Callback. Good: easy to use, less calling code, don't need [SkipLocalsInit]. Bad: problem with captured variables (garbage, slow); slower in any case.
		//	4. foreach. Nothing good.

		/// <summary>
		/// Memory buffer pointer.
		/// </summary>
		public T* p => _p;

		/// <summary>
		/// Returns memory buffer pointer (<see cref="p"/>).
		/// </summary>
		public static implicit operator T*(in FastBuffer<T> b) => b._p;

		/// <summary>
		/// Gets reference to <c>p[i]</c>. Does not check bounds.
		/// </summary>
		public ref T this[int i] => ref _p[i];

		/// <summary>
		/// Memory buffer length as number of elements of type <c>T</c>.
		/// </summary>
		public int n => _n;

		/// <summary>
		/// Allocates first buffer of default size. It is on stack (in this variable), and its length is <c>StackSize/sizeof(T)</c> elements of type <c>T</c> (2048 bytes or 1024 chars or 512 ints...).
		/// </summary>
		public FastBuffer() {
			//With this overload slightly faster. Also, the int overload is confusing when need buffer of default size.

			_stack = 0;
			fixed (long* t = &_stack) { _p = (T*)t; }
			//_p = (T*)Unsafe.AsPointer(ref _stack); //slower in Debug, same speed in Release
			_n = StackSize / sizeof(T);
			_free = false;
		}

		/// <summary>
		/// Allocates first buffer of specified size.
		/// </summary>
		/// <param name="n">
		/// Buffer length (number of elements of type <c>T</c>).
		/// If <c>&lt;= StackSize/sizeof(T)</c>, the buffer contains<c> StackSize/sizeof(T)</c> elements on stack (in this variable); it is 2048 bytes or 1024 chars or 512 ints... Else allocates native memory (much slower).
		/// </param>
		public FastBuffer(int n) {
			_stack = 0;
			int nStack = StackSize / sizeof(T);
			if (_free = n > nStack) {
				_p = MemoryUtil.Alloc<T>(n + 1); //+1 for safety
				_n = n;
			} else {
				_n = nStack;
				fixed (long* t = &_stack) { _p = (T*)t; }
				//_p = (T*)Unsafe.AsPointer(ref _stack);
			}

			//rejected: for medium-size buffers use ArrayPool.
			//	It is usually much faster than MemoryUtil, but getting pinned pointer from array is slow.
			//	To get pinned pointer, I know 3 ways.
			//		1. fixed(...){...}. Here cannot be used.
			//		2. GCHandle. Makes 3 times slower than just ArrayPool Rent/Return. Then MemoryUtil is only 50% slower. With this buffer size it does not matter.
			//		3. Memory<T>/MemoryHandle. Same speed as GCHandle. MemoryHandle is bigger and managed.
			//	Tested: MemoryPool is slower than ArrayPool and creates garbage.

			//tested: heap memory allocation becomes much slower starting from 1 MB. Then virtual memory is several times faster (else much slower). But with this buffer size it does not matter.
		}

		/// <summary>
		/// Allocates new bigger buffer of specified length. Frees old buffer if need.
		/// </summary>
		/// <param name="n">Number of elements of type <c>T</c>.</param>
		/// <param name="preserve">Copy previous buffer contents to the new buffer.</param>
		/// <exception cref="ArgumentException"><i>n</i> &lt;= current buffer length.</exception>
		public void More(int n, bool preserve = false) {
			if (_n == 0) throw new ArgumentNullException(null, "No buffer. Use another constructor."); //with many API would still work, but very slow
			if (n <= _n) throw new ArgumentException("n <= this.n");
			if (!preserve) {
				Dispose();
				_p = MemoryUtil.Alloc<T>(n + 1); //+1 for safety
			} else if (_free) {
				MemoryUtil.ReAlloc<T>(ref _p, n + 1);
			} else {
				var p = MemoryUtil.Alloc<T>(n + 1);
				MemoryUtil.Copy(_p, p, _n * sizeof(T));
				_p = p;
			}
			_n = n;
			_free = true;
		}

		/// <summary>
		/// Allocates new bigger buffer of at least <c>n*2</c> length. Frees old buffer if need.
		/// </summary>
		/// <param name="preserve">Copy previous buffer contents to the new buffer.</param>
		public void More(bool preserve = false) => More(Math.Max(checked(_n * 2), 0x4000 / sizeof(T)), preserve); //16 KB = StackSize * 8

		/// <summary>
		/// Frees allocated memory if need.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Dispose() {
			if (_free) { MemoryUtil.Free(_p); _p = null; _n = 0; }
		}

		/// <summary>
		/// Gets API result as string, or allocates bigger buffer if old buffer was too small.
		/// This function can be used when <c>T</c> is <c>char</c>.
		/// </summary>
		/// <param name="r">The return value of the called Windows API function, if it returns string length or required buffer length. Or you can call <see cref="FindStringLength"/>.</param>
		/// <param name="s">Receives the result string if succeeded, else <i>sDefault</i> (default <c>null</c>).</param>
		/// <param name="flags">
		/// Use if the API function isn't like this:
		/// <br/>• If succeeds, returns string length without the terminating <c>'\0'</c> character.
		/// <br/>• If buffer too small, returns required buffer length.
		/// <br/>• If fails, returns 0.
		/// </param>
		/// <param name="sDefault">Set <i>s</i> = this string if buffer too small or <i>r</i> &lt; 1 or if the retrieved string == this string (avoid creating new string).</param>
		/// <returns>
		/// If <i>r</i> > <see cref="n"/>, calls <c>More(r);</c> and returns <c>false</c>.
		/// Else creates new string of <i>r</i> length and returns <c>true</c>.
		/// </returns>
		public bool GetString(int r, out string s, BSFlags flags = 0, string sDefault = null) {
			if (sizeof(T) != 2) throw new InvalidOperationException(); //cannot use extension method that would be added only to FastBuffer<char>. See GetString2 comments below.
			s = sDefault;

			if (r >= _n - 1) {
				if (0 != (flags & BSFlags.Truncates)) {
					if (r >= (0 != (flags & BSFlags.ReturnsLengthWith0) ? _n : _n - 1)) {
						More();
						return false;
					}
				} else if (r > _n) {
					More(r);
					return false;
				}
			}

			if (r > 0) {
				if (0 != (flags & BSFlags.ReturnsLengthWith0)) r--;
				if (sDefault == null || !new Span<char>(_p, r).SequenceEqual(sDefault)) s = new string((char*)_p, 0, r);
			}

			return true;
		}

		/// <summary>
		/// Finds length of <c>'\0'</c>-terminated UTF-16 string in buffer and converts to C# string.
		/// This function can be used when <c>T</c> is <c>char</c>. Use when length is unknown.
		/// </summary>
		/// <remarks>
		/// If there is no <c>'\0'</c> character, gets whole buffer, and the string probably is truncated.
		/// </remarks>
		public string GetStringFindLength() {
			return new((char*)_p, 0, FindStringLength());
		}

		/// <summary>
		/// Finds length of <c>'\0'</c>-terminated <c>char</c> string in buffer.
		/// Returns <see cref="n"/> if there is no <c>'\0'</c> character.
		/// </summary>
		public int FindStringLength() {
			if (sizeof(T) != 2) throw new InvalidOperationException();
			return Ptr_.Length((char*)_p, _n);
		}

		/// <summary>
		/// Finds length of <c>'\0'</c>-terminated <c>byte</c> string in buffer.
		/// Returns <see cref="n"/> if there is no <c>'\0'</c> character.
		/// </summary>
		public int FindByteStringLength() {
			if (sizeof(T) != 1) throw new InvalidOperationException();
			return Ptr_.Length((byte*)_p, _n);
		}
	}
}

namespace Au.Types {
	//error CS1657: Cannot use 'b' as a ref or out value because it is a 'using variable'.
	//If in, compiles, but very slow. Probably copies t because calls More() which isn't readonly.
	//public static partial class ExtAu
	//{
	//	public static unsafe bool GetString2(this ref FastBuffer<char> t, int r, out string s, BSFlags flags = 0, string sDefault = null) {
	//		...
	//	}
	//}

	/// <summary>
	/// Flags for <see cref="FastBuffer{T}.GetString"/>.
	/// </summary>
	[Flags]
	public enum BSFlags {
		/// <summary>
		/// If buffer too small, the API gets part of string instead of returning required buffer length.
		/// </summary>
		Truncates = 1,

		/// <summary>
		/// The API returns string length including the terminating <c>'\0'</c> character.
		/// </summary>
		ReturnsLengthWith0 = 2,
	}
}

//rejected. Maybe 5% faster, but not so easy to use. Need more code, and easy to forget something. Also VS warning if: for(var p = stackalloc ...).
///// <summary>
///// Allocates and frees native memory buffers for calling Windows API and other functions.
///// Used when need to retry when the primary stackalloc'ed buffer was too small.
///// </summary>
///// <example>
///// <code><![CDATA[
///// [SkipLocalsInit]
///// unsafe static string CurDir() {
///// 	using Buffer_<char> b = new(); int n, r;
///// 	for (var p = stackalloc char[n = 1024]; ; p = b.Alloc(n = r)) {
///// 		r = api.GetCurrentDirectory(n, p);
///// 		if(r < n) return r > 0 ? new(p, 0, r) : null;
///// 	}
///// }
///// 
///// [SkipLocalsInit]
///// unsafe static string WinText(wnd w) {
///// 	using Buffer_<char> b = new(); int n, r;
///// 	for (var p = stackalloc char[n = 1024]; ; p = b.Alloc(checked(n *= 2))) {
///// 		r = api.InternalGetWindowText(w, p, n);
///// 		if (r < n - 1) return new string(p, 0, r);
///// 	}
///// }
///// ]]></code>
///// </example>
//unsafe ref struct Buffer_<T> where T : unmanaged
//{
//	T* _p;

//	/// <summary>
//	/// Allocates n elements of type T of native memory. Frees old memory.
//	/// </summary>
//	public T* Alloc(int n) {
//		if (_p != null) { var p = _p; _p = null; MemoryUtil.Free(p); }
//		return _p = MemoryUtil.Alloc<T>(n);
//	}

//	/// <summary>
//	/// Frees allocated memory.
//	/// </summary>
//	public void Dispose() {
//		if (_p != null) { var p = _p; _p = null; MemoryUtil.Free(p); }
//	}
//}


================================================
FILE: Au/Au.More/FileOpenSaveDialog.cs
================================================
namespace Au.More {
	/// <summary>
	/// Shows standard "Open", "Save As" or "Select Folder" dialog to select a file or folder.
	/// </summary>
	/// <remarks>
	/// This class exists because the similar .NET classes have these problems:
	/// - May disable the <see cref="AppDomain.UnhandledException"/> event.
	/// - As owner window they support only <c>Window</c> or <c>Form</c>. This class also supports window handles.
	/// - They support only filesystem items.
	/// - There is no option to not add the selected file to recent files that are displayed in the context menu of the taskbar button etc.
	/// - The WPF class does not have a client GUID property.
	/// 
	/// There are 2 main dialog types - open (<see cref="ShowOpen"/>) and save (<see cref="ShowSave"/>). All other functions of this class (properties, etc) are common to opening and saving.
	/// </remarks>
	/// <example>
	/// <code><![CDATA[
	/// var d = new FileOpenSaveDialog { FileTypes = "Text files|*.txt|All files|*.*" };
	/// if(d.ShowOpen(out string s)) print.it(s);
	/// ]]></code>
	/// </example>
	public class FileOpenSaveDialog {
		readonly string _clientGuid;
		readonly bool _clearClientData;

		/// <param name="clientGuid">A GUID used to save the recently used folder path and other data of this dialog. Optional. See <ms>IFileDialog.SetClientGuid</ms>.</param>
		/// <param name="clearClientData">Clear the recently used folder path and other data of this dialog.</param>
		public FileOpenSaveDialog(string clientGuid = null, bool clearClientData = false) {
			_clientGuid = clientGuid;
			_clearClientData = clearClientData;
		}

		/// <summary>
		/// Options common to all dialog types. Rarely used.
		/// </summary>
		public FOSFlags CommonFlags { get; set; }

		/// <summary>
		/// List of file types, like with <see cref="Microsoft.Win32.FileDialog.Filter"/>.
		/// Example: <c>"Text files|*.txt|Office files|*.doc;*.xls|All files|*.*"</c>
		/// </summary>
		public Strings FileTypes { get; set; }

		/// <summary>
		/// 1-based index of the selected file type (see <see cref="FileTypes"/>).
		/// </summary>
		public int FileTypeIndex { get; set; }

		/// <summary>
		/// Default extension to add to file names.
		/// Must be like <c>"txt"</c>, not like <c>".txt"</c>.
		/// If <c>null</c> (default), gets from <see cref="FileTypes"/>; set <c>""</c> to prevent it.
		/// </summary>
		public string DefaultExt { get; set; }

		/// <summary>
		/// Initial folder for the first time. Later is used the recently used folder instead.
		/// </summary>
		public string InitFolderFirstTime { get; set; }

		/// <summary>
		/// Initial folder to use now.
		/// In most cases it's recommended to use <see cref="InitFolderFirstTime"/> instead.
		/// </summary>
		/// <example>
		/// <code><![CDATA[
		/// d.InitFolderNow = @"C:\Test";
		/// d.InitFolderNow = /* This PC */ ":: 14001f50e04fd020ea3a6910a2d808002b30309d";
		/// ]]></code>
		/// </example>
		public string InitFolderNow { get; set; }

		/// <summary>
		/// Sets the initial file name text in the edit box.
		/// </summary>
		public string FileNameText { private get; set; }

		/// <summary>
		/// Sets the file name edit box label.
		/// </summary>
		public string FileNameLabel { private get; set; }

		/// <summary>
		/// Sets the <b>OK</b> button label.
		/// </summary>
		public string OkButtonLabel { private get; set; }

		/// <summary>
		/// Sets the dialog window name.
		/// </summary>
		public string Title { private get; set; }

		object _Show(bool save, _Api.FOS f, AnyWnd owner, string saveFile = null) {
			var w = owner.Hwnd;
			if (w.Is0) {
				w = wnd.active;
				if (!w.IsOfThisThread) w = default;
			}

			var d = (_Api.IFileDialog)Activator.CreateInstance(Type.GetTypeFromCLSID(save ? _Api.CLSID_FileSaveDialog : _Api.CLSID_FileOpenDialog));

			if (_clientGuid != null) d.SetClientGuid(new(_clientGuid));
			if (_clearClientData) d.ClearClientData();

			f |= (_Api.FOS)CommonFlags ^ (_Api.FOS.FOS_DONTADDTORECENT | _Api.FOS.FOS_PATHMUSTEXIST); //print.it(f);
			d.SetOptions(f);

			var defExt = DefaultExt;
			var ft = FileTypes.Value == null ? null : FileTypes.ToArray();
			if (ft != null) {
				int n = ft.Length / 2, i = FileTypeIndex;
				d.SetFileTypes(n, ft);
				if (i > 0) d.SetFileTypeIndex(i--);
				if (defExt == null && (uint)i < n) ft[i * 2 + 1].RxMatch(@"^\*\.([^*?;]+)", 1, out defExt);
			}
			if (!defExt.NE()) d.SetDefaultExtension(defExt);
			if (InitFolderFirstTime != null && _ShellItemFromString(InitFolderFirstTime, out var si1)) d.SetDefaultFolder(si1);
			if (InitFolderNow != null && _ShellItemFromString(InitFolderNow, out var si2)) d.SetFolder(si2);
			if (FileNameText != null) d.SetFileName(FileNameText);
			if (FileNameLabel != null) d.SetFileNameLabel(FileNameLabel);
			if (OkButtonLabel != null) d.SetOkButtonLabel(OkButtonLabel);
			if (Title != null) d.SetTitle(Title);

			if (saveFile != null && d is _Api.IFileSaveDialog sd && _ShellItemFromString(saveFile, out var si3)) sd.SetSaveAsItem(si3);

			//if (0!=d.Show(w)) return null;

			//API bug: after d.Show stops working AppDomain.UnhandledException event.
			//	Same with .NET wrappers; same when the native API called in C++; same with API GetOpenFileName.
			//	The API removes the .NET's unhandled exception filter and sets null filter. Need to restore it.
			//	AppModuleInit_ auto-restores, but in some apps it isn't called.
			//	Fixed in Win11.
			var uef = Api.SetUnhandledExceptionFilter(0);
			Api.SetUnhandledExceptionFilter(uef);
			try { if (0 != d.Show(w)) return null; }
			finally { Api.SetUnhandledExceptionFilter(uef); }

			if (ft != null) FileTypeIndex = d.GetFileTypeIndex();
			//FileNameText=d.GetFileName(); //fails here. And not useful.

			if (!f.Has(_Api.FOS.FOS_ALLOWMULTISELECT)) return _ShellItemToString(d.GetResult());
			var r = ((_Api.IFileOpenDialog)d).GetResults();
			var a = new string[r.GetCount()];
			for (int i = 0; i < a.Length; i++) a[i] = _ShellItemToString(r.GetItemAt(i));
			return a;
		}

		object _ShowOpen(AnyWnd owner = default, bool multiSelect = false, bool selectFolder = false, bool onlyFilesystem = true, bool fileMustExist = true, bool previewPane = false) {
			//default FOS_NOCHANGEDIR, FOS_PATHMUSTEXIST, FOS_FILEMUSTEXIST
			var f = _Api.FOS.FOS_NOCHANGEDIR;
			if (multiSelect) f |= _Api.FOS.FOS_ALLOWMULTISELECT;
			if (selectFolder) f |= _Api.FOS.FOS_PICKFOLDERS;
			if (onlyFilesystem) f |= _Api.FOS.FOS_FORCEFILESYSTEM; else f |= _Api.FOS.FOS_ALLNONSTORAGEITEMS;
			if (fileMustExist) f |= _Api.FOS.FOS_FILEMUSTEXIST;
			if (previewPane) f |= _Api.FOS.FOS_FORCEPREVIEWPANEON;

			return _Show(false, f, owner);
		}

		/// <summary>
		/// Shows "Open" or "Select Folder" dialog that allows to select single item.
		/// </summary>
		/// <param name="result">Full path of the selected file.</param>
		/// <param name="owner">Owner window. Optional.</param>
		/// <param name="selectFolder">Select folders, not files.</param>
		/// <param name="onlyFilesystem">The dialog allows to select only file system items (files, folders), not other shell items or URLs. Default <c>true</c>. If <c>false</c>, other shell items are returned like <c>":: ITEMIDLIST"</c>; see <see cref="Pidl"/>.</param>
		/// <param name="fileMustExist">The dialog can return only existing items. Default <c>true</c>.</param>
		/// <param name="previewPane">Display the preview pane.</param>
		/// <returns><c>true</c> on <b>OK</b>, <c>false</c> on <b>Cancel</b> or error.</returns>
		public bool ShowOpen(out string result, AnyWnd owner = default, bool selectFolder = false, bool onlyFilesystem = true, bool fileMustExist = true, bool previewPane = false) {
			result = _ShowOpen(owner, false, selectFolder, onlyFilesystem, fileMustExist, previewPane) as string;
			return result != null;
		}

		/// <summary>
		/// Shows "Open" or "Select Folder" dialog that allows to select multiple items.
		/// </summary>
		/// <param name="result">Full paths of the selected files.</param>
		/// <inheritdoc cref="ShowOpen(out string, AnyWnd, bool, bool, bool, bool)"/>
		public bool ShowOpen(out string[] result, AnyWnd owner = default, bool selectFolder = false, bool onlyFilesystem = true, bool fileMustExist = true, bool previewPane = false) {
			result = _ShowOpen(owner, true, selectFolder, onlyFilesystem, fileMustExist, previewPane) as string[];
			return result != null;
		}

		/// <summary>
		/// Shows "Save As" dialog.
		/// </summary>
		/// <param name="result">Full path of the selected file.</param>
		/// <param name="owner">Owner window. Optional.</param>
		/// <param name="overwritePrompt">If the selected file already exists, show a message box. Default <c>true</c>.</param>
		/// <param name="initFile">The initially selected file. Its name is displayed in the file name edit box, and the containing folder is opened. This would generally be used when the application is saving a file that already exists. For new files use <see cref="FileNameText"/>.</param>
		/// <returns><c>true</c> on <b>OK</b>, <c>false</c> on <b>Cancel</b> or error.</returns>
		public bool ShowSave(out string result, AnyWnd owner = default, bool overwritePrompt = true, string initFile = null) {
			//default FOS_OVERWRITEPROMPT, FOS_NOCHANGEDIR, FOS_PATHMUSTEXIST, FOS_NOREADONLYRETURN
			var f = _Api.FOS.FOS_NOCHANGEDIR;
			if (overwritePrompt) f |= _Api.FOS.FOS_OVERWRITEPROMPT;
			/*if(!overwriteReadonly)*/
			f |= _Api.FOS.FOS_NOREADONLYRETURN; //always works like with this flag

			//if(createPrompt) f|=_Api.FOS.FOS_CREATEPROMPT; //does not work. The .NET wrapper shows messagebox explicitly.
			//if(!testCreate) f|=_Api.FOS.FOS_NOTESTFILECREATE; //not important, not tested
			//if(strictFileTypes) f|=_Api.FOS.FOS_STRICTFILETYPES; //does not work

			result = _Show(true, f, owner, initFile) as string;
			return result != null;
		}

		static string _ShellItemToString(_Api.IShellItem r) {
			//if(!f.Has(_Api.FOS.FOS_FORCEFILESYSTEM)) {
			//	var k=r.GetAttributes(0xffffffff);
			//	if(0==(k&_Api.SFGAO_FILESYSTEM)) {
			//		print.it(k);
			//	}
			//}

			var s = r.GetDisplayName(SIGDN.FILESYSPATH | SIGDN.URL); //info: for a non-FS item, even with SIGDN.FILESYSPATH gets string like "::{GUID}"
			return Pidl.ClsidToItemidlist_(s);
		}

		static bool _ShellItemFromString(string path, out _Api.IShellItem si) {
			if (path.Starts(":: ")) {
				var p = Pidl.FromString(path); if (p == null) { si = null; return false; }
				return 0 == _Api.SHCreateItemFromIDList(p.UnsafePtr, typeof(_Api.IShellItem).GUID, out si);
			} else {
				return 0 == _Api.SHCreateItemFromParsingName(path, default, typeof(_Api.IShellItem).GUID, out si);
			}
		}

		unsafe class _Api {
			internal static Guid CLSID_FileOpenDialog = new(0xDC1C5A9C, 0xE88A, 0x4DDE, 0xA5, 0xA1, 0x60, 0xF8, 0x2A, 0x20, 0xAE, 0xF7);

			internal static Guid CLSID_FileSaveDialog = new(0xC0B4E2F3, 0xBA21, 0x4773, 0x8D, 0xBA, 0x33, 0x5E, 0xC9, 0x46, 0xEB, 0x8B);

			[ComImport, Guid("d57c7288-d4ad-4768-be02-9d969532d960"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
			internal interface IFileOpenDialog : IFileDialog {
				//IModalWindow
				[PreserveSig] new int Show(wnd hwndOwner);
				//IFileDialog
				new void SetFileTypes(int cFileTypes, [MarshalAs(UnmanagedType.LPArray)][In] string[] rgFilterSpec);
				new void SetFileTypeIndex(int iFileType);
				new int GetFileTypeIndex();
				[PreserveSig] new int Advise(/*IFileDialogEvents pfde, out uint pdwCookie*/);
				[PreserveSig] new int Unadvise(uint dwCookie);
				new void SetOptions(_Api.FOS fos);
				new _Api.FOS GetOptions();
				new void SetDefaultFolder(IShellItem psi);
				new void SetFolder(IShellItem psi);
				new IShellItem GetFolder();
				new IShellItem GetCurrentSelection();
				new void SetFileName([MarshalAs(UnmanagedType.LPWStr)] string pszName);
				[return: MarshalAs(UnmanagedType.LPWStr)] new string GetFileName();
				new void SetTitle([MarshalAs(UnmanagedType.LPWStr)] string pszTitle);
				new void SetOkButtonLabel([MarshalAs(UnmanagedType.LPWStr)] string pszText);
				new void SetFileNameLabel([MarshalAs(UnmanagedType.LPWStr)] string pszLabel);
				new IShellItem GetResult();
				[PreserveSig] new int AddPlace(/*IShellItem psi, FDAP fdap*/);
				new void SetDefaultExtension([MarshalAs(UnmanagedType.LPWStr)] string pszDefaultExtension);
				[PreserveSig] new int Close(int hr);
				new void SetClientGuid(in Guid guid);
				new void ClearClientData();
				[PreserveSig] new int SetFilter(/*IShellItemFilter pFilter*/);
				//IFileOpenDialog
				IShellItemArray GetResults();
				IShellItemArray GetSelectedItems();
			}

			[ComImport, Guid("84bccd23-5fde-4cdb-aea4-af64b83d78ab"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
			internal interface IFileSaveDialog : IFileDialog {
				//IModalWindow
				[PreserveSig] new int Show(wnd hwndOwner);
				//IFileDialog
				new void SetFileTypes(int cFileTypes, [MarshalAs(UnmanagedType.LPArray)][In] string[] rgFilterSpec);
				new void SetFileTypeIndex(int iFileType);
				new int GetFileTypeIndex();
				[PreserveSig] new int Advise(/*IFileDialogEvents pfde, out uint pdwCookie*/);
				[PreserveSig] new int Unadvise(uint dwCookie);
				new void SetOptions(_Api.FOS fos);
				new _Api.FOS GetOptions();
				new void SetDefaultFolder(IShellItem psi);
				new void SetFolder(IShellItem psi);
				new IShellItem GetFolder();
				new IShellItem GetCurrentSelection();
				new void SetFileName([MarshalAs(UnmanagedType.LPWStr)] string pszName);
				[return: MarshalAs(UnmanagedType.LPWStr)] new string GetFileName();
				new void SetTitle([MarshalAs(UnmanagedType.LPWStr)] string pszTitle);
				new void SetOkButtonLabel([MarshalAs(UnmanagedType.LPWStr)] string pszText);
				new void SetFileNameLabel([MarshalAs(UnmanagedType.LPWStr)] string pszLabel);
				new IShellItem GetResult();
				[PreserveSig] new int AddPlace(/*IShellItem psi, FDAP fdap*/);
				new void SetDefaultExtension([MarshalAs(UnmanagedType.LPWStr)] string pszDefaultExtension);
				[PreserveSig] new int Close(int hr);
				new void SetClientGuid(in Guid guid);
				new void ClearClientData();
				[PreserveSig] new int SetFilter(/*IShellItemFilter pFilter*/);
				//IFileSaveDialog
				void SetSaveAsItem(IShellItem psi);
				[PreserveSig] int SetProperties(/*IPropertyStore pStore*/);
				[PreserveSig] int SetCollectedProperties(/*IPropertyDescriptionList pList, [MarshalAs(UnmanagedType.Bool)] bool fAppendDefault*/);
				[PreserveSig] int GetProperties(/*out IPropertyStore ppStore*/);
				[PreserveSig] int ApplyProperties(/*IShellItem psi, IPropertyStore pStore, wnd hwnd, IFileOperationProgressSink pSink*/);
			}

			[ComImport, Guid("42f85136-db7e-439c-85f1-e4075d135fc8"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
			internal interface IFileDialog {
				//IModalWindow
				[PreserveSig] int Show(wnd hwndOwner);
				//IFileDialog
				void SetFileTypes(int cFileTypes, [MarshalAs(UnmanagedType.LPArray)][In] string[] rgFilterSpec);
				void SetFileTypeIndex(int iFileType);
				int GetFileTypeIndex();
				[PreserveSig] int Advise(/*IFileDialogEvents pfde, out uint pdwCookie*/);
				[PreserveSig] int Unadvise(uint dwCookie);
				void SetOptions(_Api.FOS fos);
				_Api.FOS GetOptions();
				void SetDefaultFolder(IShellItem psi);
				void SetFolder(IShellItem psi);
				IShellItem GetFolder();
				IShellItem GetCurrentSelection();
				void SetFileName([MarshalAs(UnmanagedType.LPWStr)] string pszName);
				[return: MarshalAs(UnmanagedType.LPWStr)] string GetFileName();
				void SetTitle([MarshalAs(UnmanagedType.LPWStr)] string pszTitle);
				void SetOkButtonLabel([MarshalAs(UnmanagedType.LPWStr)] string pszText);
				void SetFileNameLabel([MarshalAs(UnmanagedType.LPWStr)] string pszLabel);
				IShellItem GetResult();
				[PreserveSig] int AddPlace(/*IShellItem psi, FDAP fdap*/);
				void SetDefaultExtension([MarshalAs(UnmanagedType.LPWStr)] string pszDefaultExtension);
				[PreserveSig] int Close(int hr);
				void SetClientGuid(in Guid guid);
				void ClearClientData();
				[PreserveSig] int SetFilter(/*IShellItemFilter pFilter*/);
			}

			[ComImport, Guid("43826d1e-e718-42ee-bc55-a1e261c37bfe"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
			internal interface IShellItem {
				[PreserveSig] int BindToHandler(IntPtr pbc, in Guid bhid, in Guid riid, void** ppv);
				[PreserveSig] int GetParent(out IShellItem ppsi);
				[return: MarshalAs(UnmanagedType.LPWStr)] string GetDisplayName(SIGDN sigdnName);
				uint GetAttributes(uint sfgaoMask);
				[PreserveSig] int Compare(IShellItem psi, uint hint, out int piOrder);
			}

			[ComImport, Guid("b63ea76d-1f85-456f-a19c-48159efa858b"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
			internal interface IShellItemArray {
				[PreserveSig] int BindToHandler(/*IntPtr pbc, in Guid bhid, in Guid riid, void** ppvOut*/);
				[PreserveSig] int GetPropertyStore(/*GETPROPERTYSTOREFLAGS flags, in Guid riid, void** ppv*/);
				[PreserveSig] int GetPropertyDescriptionList(/*in PROPERTYKEY keyType, in Guid riid, void** ppv*/);
				[PreserveSig] int GetAttributes(/*SIATTRIBFLAGS AttribFlags, uint sfgaoMask, out uint psfgaoAttribs*/);
				int GetCount();
				IShellItem GetItemAt(int dwIndex);
				[PreserveSig] int EnumItems(/*out IEnumShellItems ppenumShellItems*/);
			}

			[Flags]
			internal enum FOS : uint {
				FOS_OVERWRITEPROMPT = 0x2,
				FOS_STRICTFILETYPES = 0x4,
				FOS_NOCHANGEDIR = 0x8,
				FOS_PICKFOLDERS = 0x20,
				FOS_FORCEFILESYSTEM = 0x40,
				FOS_ALLNONSTORAGEITEMS = 0x80,
				FOS_NOVALIDATE = 0x100,
				FOS_ALLOWMULTISELECT = 0x200,
				FOS_PATHMUSTEXIST = 0x800,
				FOS_FILEMUSTEXIST = 0x1000,
				FOS_CREATEPROMPT = 0x2000,
				FOS_SHAREAWARE = 0x4000,
				FOS_NOREADONLYRETURN = 0x8000,
				FOS_NOTESTFILECREATE = 0x10000,
				FOS_HIDEMRUPLACES = 0x20000,
				FOS_HIDEPINNEDPLACES = 0x40000,
				FOS_NODEREFERENCELINKS = 0x100000,
				FOS_OKBUTTONNEEDSINTERACTION = 0x200000,
				FOS_DONTADDTORECENT = 0x2000000,
				FOS_FORCESHOWHIDDEN = 0x10000000,
				FOS_DEFAULTNOMINIMODE = 0x20000000,
				FOS_FORCEPREVIEWPANEON = 0x40000000,
				FOS_SUPPORTSTREAMABLEITEMS = 0x80000000
			}

			[DllImport("shell32.dll", PreserveSig = true)]
			internal static extern int SHCreateItemFromParsingName(string pszPath, IntPtr pbc, in Guid riid, out IShellItem ppv);

			[DllImport("shell32.dll", PreserveSig = true)]
			internal static extern int SHCreateItemFromIDList(IntPtr pidl, in Guid riid, out IShellItem ppv);
		}
	}
}

namespace Au.Types {
	/// <summary>
	/// <see cref="FileOpenSaveDialog.CommonFlags"/>.
	/// </summary>
	[Flags]
	public enum FOSFlags : uint //the values are like in FOS, some xored
	{
		/// <summary>Add the selected file to recent documents. See API <ms>SHAddToRecentDocs</ms>.</summary>
		AddToRecent = 0x2000000,

		/// <summary>Do not check for situations that would prevent an application from opening the selected file, such as sharing violations or access denied errors.</summary>
		NoValidateAccess = 0x100,

		///// <summary>The user can enter a path that does not exist, like <c>C:\does not exist\file.txt</c>.</summary>
		//NoValidatePath = 0x800, //does not work. Always validates.

		/// <summary>Shortcuts should not be treated as their target items, allowing an application to open a <c>.lnk</c> file.</summary>
		NoDereferenceLinks = 0x100000,

		/// <summary>Show hidden and system items.</summary>
		ShowHidden = 0x10000000,
	}
}


================================================
FILE: Au/Au.More/GdiTextRenderer.cs
================================================
//FUTURE: support columns. Maybe use \t of specified widths.

namespace Au.More;
#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member

/// <summary>
/// Draws text using fastest GDI API such as <ms>TextOut</ms> and standard UI font.
/// Can easily draw string parts with different colors/styles without measuring.
/// Must be disposed.
/// </summary>
public unsafe class GdiTextRenderer : IDisposable {
	IntPtr _dc, _oldFont;
	uint _oldAlign;
	int _color, _oldColor;
	int _dpi;
	bool _releaseDC;
	
	/// <summary>Object created with this ctor can draw and measure.</summary>
	/// <param name="hdc">Device context handle. <c>Dispose</c> will not release it.</param>
	/// <param name="dpi"></param>
	public GdiTextRenderer(IntPtr hdc, int dpi) {
		_dpi = dpi;
		_dc = hdc;
		_oldFont = Api.SelectObject(_dc, NativeFont_.RegularCached(_dpi));
		_oldAlign = 0xffffffff;
		Api.SetBkMode(_dc, 1);
		_oldColor = Api.SetTextColor(_dc, _color = 0);
	}
	
	/// <summary>Object created with this ctor can measure only. Uses screen DC.</summary>
	public GdiTextRenderer(int dpi) {
		_dpi = dpi;
		_releaseDC = true;
		_dc = Api.GetDC(default);
		_oldFont = Api.SelectObject(_dc, NativeFont_.RegularCached(_dpi));
	}
	
	public void Dispose() {
		if (_dc != default) {
			Api.SelectObject(_dc, _oldFont);
			if (_releaseDC) Api.ReleaseDC(default, _dc);
			else {
				if (_oldAlign != 0xffffffff) Api.SetTextAlign(_dc, _oldAlign);
				if (_oldColor != _color) Api.SetTextColor(_dc, _oldColor);
			}
			_dc = default;
		}
		//never mind: we don't restore the old current position. Nobody later would draw at current position without movetoex. As well as bkmode.
	}
	
	/// <summary>
	/// Sets the current drawing position of the DC.
	/// Returns previous position.
	/// </summary>
	public POINT MoveTo(int x, int y) {
		Api.MoveToEx(_dc, x, y, out var p);
		return p;
	}
	
	/// <summary>
	/// Gets the current drawing position of the DC.
	/// </summary>
	public POINT GetCurrentPosition() {
		Api.GetCurrentPositionEx(_dc, out var p);
		return p;
	}
	
	/// <summary>
	/// Sets non-bold font.
	/// </summary>
	public void FontNormal() => Api.SelectObject(_dc, NativeFont_.RegularCached(_dpi));
	
	/// <summary>
	/// Sets bold font.
	/// </summary>
	public void FontBold() => Api.SelectObject(_dc, NativeFont_.BoldCached(_dpi));
	
	//public void FontItalic() => Api.SelectObject(_dc, NativeFont_.ItalicCached(_dpi));
	
	//public void FontBoldItalic() => Api.SelectObject(_dc, NativeFont_.BoldItalicCached(_dpi));
	
	/// <summary>
	/// Draws text at the current drawing position of the DC, and updates it.
	/// </summary>
	/// <param name="color">Text color <c>0xBBGGRR</c>.</param>
	/// <param name="backColor">Background color <c>0xBBGGRR</c>. Transparent if <c>null</c>.</param>
	public void DrawText(string s, int color = 0, Range? range = null, int? backColor = null) {
		var (from, len) = range.GetOffsetAndLength(s.Lenn()); if (len == 0) return;
		if (_oldAlign == 0xffffffff) _oldAlign = Api.SetTextAlign(_dc, 1); //TA_UPDATECP
		_DrawText(s, 0, 0, color, from, len, backColor);
	}
	
	/// <summary>
	/// Draws text at specified position. Does not use/update the current drawing position of the DC.
	/// </summary>
	/// <param name="color">Text color <c>0xBBGGRR</c>.</param>
	/// <param name="backColor">Background color <c>0xBBGGRR</c>. Transparent if <c>null</c>.</param>
	public void DrawText(string s, POINT p, int color = 0, Range? range = null, int? backColor = null) {
		var (from, len) = range.GetOffsetAndLength(s.Lenn()); if (len == 0) return;
		if (_oldAlign != 0xffffffff) { Api.SetTextAlign(_dc, _oldAlign); _oldAlign = 0xffffffff; }
		_DrawText(s, p.x, p.y, color, from, len, backColor);
	}
	
	/// <summary>
	/// Draws text clipped in specified rectangle. Does not use/update the current drawing position of the DC.
	/// </summary>
	/// <param name="color">Text color <c>0xBBGGRR</c>.</param>
	/// <param name="backColor">Background color <c>0xBBGGRR</c>. Transparent if <c>null</c>.</param>
	public void DrawText(string s, in RECT r, int color = 0, Range? range = null, int? backColor = null) {
		var (from, len) = range.GetOffsetAndLength(s.Lenn()); if (len == 0) return;
		if (_oldAlign != 0xffffffff) { Api.SetTextAlign(_dc, _oldAlign); _oldAlign = 0xffffffff; }
		_DrawText(s, r, color, from, len, backColor);
	}
	
	//[Ext]TextOut fails if >= 1024 * 64.
	//	On Win7 and 8.1 depends on text width (ushort.MaxValue?). Eg fails if > ~2900 'W'.
	//	ExtTextOut doc: "This value may not exceed 8192.".
	static int _LimitLength(int len) => Math.Min(len, osVersion.minWin10 ? 1024 * 64 - 1 : 4000);
	
	unsafe void _DrawText(string s, int x, int y, int color, int from, int len, int? backColor) {
		if (color != _color) Api.SetTextColor(_dc, _color = color);
		using var bc = new _BackColor(_dc, backColor);
		fixed (char* p = s) Api.TextOut(_dc, x, y, p + from, _LimitLength(len));
	}
	
	unsafe void _DrawText(string s, in RECT r, int color, int from, int len, int? backColor) {
		if (color != _color) Api.SetTextColor(_dc, _color = color);
		using var bc = new _BackColor(_dc, backColor);
		fixed (char* p = s) Api.ExtTextOut(_dc, r.left, r.top, Api.ETO_CLIPPED, r, p + from, _LimitLength(len));
	}
	
	public SIZE MeasureText(string s, Range? range = null) {
		var (from, len) = range.GetOffsetAndLength(s.Lenn()); if (len == 0) return default;
		fixed (char* p = s) {
			Api.GetTextExtentPoint32(_dc, p + from, _LimitLength(len), out var z);
			return z;
		}
	}
	
	ref struct _BackColor {
		int _oldColor, _oldMode;
		IntPtr _dc;
		
		public _BackColor(IntPtr dc, int? color) {
			if (color != null) {
				_dc = dc;
				_oldMode = Api.SetBkMode(_dc, 2);
				_oldColor = Api.SetBkColor(_dc, color.Value);
			}
		}
		
		public void Dispose() {
			if (_dc != default) {
				Api.SetBkColor(_dc, _oldColor);
				Api.SetBkMode(_dc, _oldMode);
			}
		}
	}
}


================================================
FILE: Au/Au.More/Hash.cs
================================================
using System.Security.Cryptography;
using System.Buffers.Text;

namespace Au.More;

/// <summary>
/// Data hash functions.
/// </summary>
[EditorBrowsable(EditorBrowsableState.Never)] //obsolete as public, but still used internally. Created before the easy and fast .NET hash classes existed.
public static unsafe class Hash {
	#region FNV1
	
	/// <summary>
	/// 32-bit FNV-1 hash.
	/// Useful for fast hash table and checksum use, not cryptography. Similar to CRC32; faster but creates more collisions.
	/// </summary>
	public static int Fnv1(RStr data) {
		if (data.IsNull()) return 0;
		
		uint hash = 2166136261;
		for (int i = 0; i < data.Length; i++)
			hash = (hash * 16777619) ^ data[i];
		return (int)hash;
	}
	
	/// <inheritdoc cref="Fnv1(RStr)"/>
	public static int Fnv1(char* data, int lengthChars) => Fnv1(new RStr(data, lengthChars));
	
	/// <param name="data">Data. See also: <see cref="MemoryMarshal.AsBytes"/>, <see cref="CollectionsMarshal.AsSpan"/>.</param>
	/// <inheritdoc cref="Fnv1(RStr)"/>
	public static int Fnv1(RByte data) {
		if (data.IsNull()) return 0;
		
		uint hash = 2166136261;
		for (int i = 0; i < data.Length; i++)
			hash = (hash * 16777619) ^ data[i];
		return (int)hash;
	}
	
	/// <inheritdoc cref="Fnv1(RStr)"/>
	public static int Fnv1(byte* data, int lengthBytes) => Fnv1(new RByte(data, lengthBytes));
	
	/// <inheritdoc cref="Fnv1(RStr)"/>
	public static int Fnv1<T>(T data) where T : unmanaged
			=> Fnv1((byte*)&data, sizeof(T));
	
	/// <summary>
	/// 64-bit FNV-1 hash.
	/// </summary>
	public static long Fnv1Long(RStr data) {
		if (data.IsNull()) return 0;
		
		ulong hash = 14695981039346656037;
		for (int i = 0; i < data.Length; i++)
			hash = (hash * 1099511628211) ^ data[i];
		return (long)hash;
	}
	
	/// <summary>
	/// 64-bit FNV-1 hash.
	/// </summary>
	public static long Fnv1Long(char* data, int lengthChars) => Fnv1(new RStr(data, lengthChars));
	
	/// <summary>
	/// 64-bit FNV-1 hash.
	/// </summary>
	/// <param name="data">Data. See also: <see cref="MemoryMarshal.AsBytes"/>, <see cref="CollectionsMarshal.AsSpan"/>.</param>
	public static long Fnv1Long(RByte data) {
		if (data.IsNull()) return 0;
		
		ulong hash = 14695981039346656037;
		for (int i = 0; i < data.Length; i++)
			hash = (hash * 1099511628211) ^ data[i];
		return (long)hash;
	}
	
	/// <summary>
	/// 64-bit FNV-1 hash.
	/// </summary>
	public static long Fnv1Long(byte* data, int lengthBytes) => Fnv1(new RByte(data, lengthBytes));
	
	/// <summary>
	/// 64-bit FNV-1 hash.
	/// </summary>
	public static long Fnv1Long<T>(T data) where T : unmanaged
			=> Fnv1Long((byte*)&data, sizeof(T));
	
	/// <summary>
	/// FNV-1 hash, modified to make faster with long strings (then takes every n-th character).
	/// </summary>
	[Obsolete] //unused
	public static int Fast(char* data, int lengthChars) {
		if (data == null) return 0;
		
		//Also we take the last 1-2 characters (in the second loop), because often there are several strings like Chrome_WidgetWin_0, Chrome_WidgetWin_1...
		//Also we hash uints, not chars, unless the string is very short.
		//Tested speed with 400 unique strings (window/control names/classnames/programnames). The time was 7 mcs. For single call 17 ns.
		
		uint hash = 2166136261;
		int i = 0;
		
		if (lengthChars > 8) {
			int lc = lengthChars--;
			lengthChars /= 2; //we'll has uints, not chars
			int every = lengthChars / 8 + 1;
			
			for (; i < lengthChars; i += every)
				hash = (hash * 16777619) ^ ((uint*)data)[i];
			
			i = lengthChars * 2;
			lengthChars = lc;
		}
		
		for (; i < lengthChars; i++)
			hash = (hash * 16777619) ^ data[i];
		
		return (int)hash;
	}
	
	/// <summary>
	/// FNV-1 hash, modified to make faster with long strings (then takes every n-th character).
	/// </summary>
	/// <param name="s">String. Can be <c>null</c>.</param>
	[Obsolete] //unused
	public static int Fast(RStr s) {
		fixed (char* p = s) return Fast(p, s.Length);
	}
	
	#endregion
	
	#region MD5
	
	/// <summary>
	/// Computes MD5 hash of data.
	/// Call an <see cref="Add"/> method one or more times. Finally use <see cref="Hash"/> to get result.
	/// </summary>
	[StructLayout(LayoutKind.Explicit)]
	public struct MD5Context { //MD5_CTX + _state
		[FieldOffset(88)] MD5Result _result;
		[FieldOffset(104)] long _state; //1 inited/added, 2 finalled
		
		/// <summary>
		/// <c>true</c> if no data was added.
		/// </summary>
		public bool IsEmpty => _state == 0;
		
		/// <summary>Adds data.</summary>
		/// <exception cref="ArgumentOutOfRangeException"><i>size</i> &lt; 0.</exception>
		/// <exception cref="ArgumentNullException"><i>data</i> is <c>null</c> and <i>size</i> > 0.</exception>
		public void Add(void* data, int size) {
			if (size < 0) throw new ArgumentOutOfRangeException();
			if (size > 0) Not_.Null(data); //allow null if size 0. Eg 'fixed' gets null pointer if the span or array is empty.
			if (_state != 1) { Api.MD5Init(out this); _state = 1; }
			if (size > 0) Api.MD5Update(ref this, data, size);
		}
		
		/// <summary>Adds data.</summary>
		public void Add<T>(T data) where T : unmanaged
			=> Add(&data, sizeof(T));
		
		/// <summary>Adds data.</summary>
		/// <param name="data">Data. See also: <see cref="MemoryMarshal.AsBytes"/>, <see cref="CollectionsMarshal.AsSpan"/>.</param>
		public void Add(RByte data) {
			fixed (byte* p = data) Add(p, data.Length); //note: p null if data empty
		}
		
		/// <summary>Adds string converted to UTF-8.</summary>
		/// <exception cref="ArgumentNullException"><i>data</i> is <c>null</c>.</exception>
		public void Add(string data) => Add(Encoding.UTF8.GetBytes(data));
		
		//CONSIDER: alloc on stack to avoid garbage. This func works, but not faster.
		//[SkipLocalsInit]
		//public void Add2(string data) {
		//	if (data.Length < 3000) {
		//		Span<byte> p = stackalloc byte[data.Length * 3];
		//		int n = Encoding.UTF8.GetBytes(data, p);
		//		//print.it(n);
		//		Add(p[..n]);
		//	} else {
		//		Add(Encoding.UTF8.GetBytes(data));
		//	}
		//}
		
		//rejected. Better use unsafe address, then will not need to copy data.
		///// <summary>Adds data.</summary>
		//public void Add<T>(T data) where T: unmanaged
		//{
		//	Add(&data, sizeof(T));
		//}
		
		/// <summary>
		/// Computes final hash of datas added with an <see cref="Add"/> method.
		/// </summary>
		/// <exception cref="InvalidOperationException"><c>Add</c> was not called.</exception>
		/// <remarks>
		/// Resets state, so that if <c>Add</c> called again, it will start adding new datas.
		/// </remarks>
		public MD5Result Hash {
			get {
				if (_state != 2) {
					if (_state != 1) throw new InvalidOperationException();
					Api.MD5Final(ref this);
					_state = 2;
				}
				return _result;
			}
		}
	}
	
	/// <summary>
	/// Result of <see cref="MD5Context.Hash"/>.
	/// It is 16 bytes stored in 2 <c>long</c> fields <c>r1</c> and <c>r2</c>.
	/// If need, can be converted to <c>byte[]</c> with <see cref="MD5Result.ToArray"/> or to hex string with <see cref="MD5Result.ToString"/>.
	/// </summary>
	public record struct MD5Result {
#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
		public readonly long r1, r2;
		
		public MD5Result(long r1, long r2) { this.r1 = r1; this.r2 = r2; }
#pragma warning restore CS1591 // Missing XML comment for publicly visible type or member
		
		/// <summary>
		/// Converts this to <c>byte[]</c> of length 16.
		/// </summary>
		public byte[] ToArray() {
			var r = new byte[16];
			fixed (byte* p = r) {
				*(long*)p = r1;
				*(long*)(p + 8) = r2;
			}
			return r;
		}
		
		/// <summary>
		/// Converts this to hex string.
		/// </summary>
		public override string ToString() => Convert2.HexEncode(this);
		
		/// <summary>
		/// Creates <see cref="MD5Result"/> from hex string returned by <see cref="ToString"/>.
		/// </summary>
		/// <returns><c>false</c> if <i>encoded</i> is invalid.</returns>
		public static bool FromString(RStr encoded, out MD5Result r) => Convert2.HexDecode(encoded, out r);
		
#if NET9_0_OR_GREATER
		/// <summary>
		/// Converts this to Base64url string (URL-safe Base64).
		/// </summary>
		public string ToStringBase64Url() => Base64Url.EncodeToString(_AsSpan());
		
		/// <summary>
		/// Creates <see cref="MD5Result"/> from string returned by <see cref="ToStringBase64Url"/>.
		/// </summary>
		public static bool FromStringBase64Url(RStr encoded, out MD5Result r) {
			r = default;
			return Base64Url.TryDecodeFromChars(encoded, r._AsSpan(), out _);
		}
		
		Span<byte> _AsSpan() => MemoryMarshal.AsBytes(MemoryMarshal.CreateSpan(ref this, 1));
#endif
	}
	
	/// <summary>
	/// Computes MD5 hash of data.
	/// Uses <see cref="MD5Context"/>.
	/// </summary>
	/// <param name="data">Data. See also: <see cref="MemoryMarshal.AsBytes"/>, <see cref="CollectionsMarshal.AsSpan"/>.</param>
	public static MD5Result MD5(RByte data) {
		MD5Context md = default;
		md.Add(data);
		return md.Hash;
	}
	
	//rejected. Problems with overload resolution and implicit conversion Span to ReadOnlySpan. Not so often used. Then would need the same everywhere. Instead added doc.
	///// <summary>
	///// Computes MD5 hash of data.
	///// Uses <see cref="MD5Context"/>.
	///// </summary>
	//public static MD5Result MD5<T>(ReadOnlySpan<T> data) where T : unmanaged
	//	=> MD5(MemoryMarshal.AsBytes(data));
	
	/// <summary>
	/// Computes MD5 hash of string converted to UTF-8.
	/// Uses <see cref="MD5Context"/>.
	/// </summary>
	public static MD5Result MD5(string data) {
		MD5Context md = default;
		md.Add(data);
		return md.Hash;
	}
	
	/// <summary>
	/// Computes MD5 hash of data. Returns result as hex or base64 string.
	/// Uses <see cref="MD5Context"/>.
	/// </summary>
	/// <param name="data">Data. See also: <see cref="MemoryMarshal.AsBytes"/>, <see cref="CollectionsMarshal.AsSpan"/>.</param>
	/// <param name="base64"></param>
	public static string MD5(RByte data, bool base64) {
		var h = MD5(data);
		return base64 ? Convert.ToBase64String(new RByte((byte*)&h, 16)) : h.ToString();
	}
	
	///// <summary>
	///// Computes MD5 hash of data. Returns result as hex or base64 string.
	///// Uses <see cref="MD5Context"/>.
	///// </summary>
	//public static string MD5<T>(ReadOnlySpan<T> data, bool base64) where T : unmanaged
	//	=> MD5(MemoryMarshal.AsBytes(data), base64);
	
	/// <summary>
	/// Computes MD5 hash of string converted to UTF-8. Returns result as hex or base64 string.
	/// Uses <see cref="MD5Context"/>.
	/// </summary>
	public static string MD5(string data, bool base64) {
		var h = MD5(data);
		return base64 ? Convert.ToBase64String(new RByte((byte*)&h, 16)) : h.ToString();
	}
	
	#endregion
	
	#region other
	
	/// <summary>
	/// Computes data hash using the specified cryptographic algorithm.
	/// </summary>
	/// <param name="data">Data. See also: <see cref="MemoryMarshal.AsBytes"/>, <see cref="CollectionsMarshal.AsSpan"/>.</param>
	/// <param name="algorithm">Algorithm name, eg <c>"SHA256"</c>. See <see cref="CryptoConfig"/>.</param>
	public static byte[] Crypto(RByte data, string algorithm) {
		using var x = (HashAlgorithm)CryptoConfig.CreateFromName(algorithm);
		var r = new byte[x.HashSize / 8];
		x.TryComputeHash(data, r, out _);
		return r;
	}
	
	/// <summary>
	/// Computes hash of string converted to UTF-8, using the specified cryptographic algorithm.
	/// </summary>
	/// <param name="data"></param>
	/// <param name="algorithm">Algorithm name, eg <c>"SHA256"</c>. See <see cref="CryptoConfig"/>.</param>
	public static byte[] Crypto(string data, string algorithm)
		=> Crypto(Encoding.UTF8.GetBytes(data), algorithm);
	
	/// <summary>
	/// Computes data hash using the specified cryptographic algorithm. Returns result as hex or base64 string.
	/// </summary>
	/// <param name="data">Data. See also: <see cref="MemoryMarshal.AsBytes"/>, <see cref="CollectionsMarshal.AsSpan"/>.</param>
	/// <param name="algorithm">Algorithm name, eg <c>"SHA256"</c>. See <see cref="CryptoConfig"/>.</param>
	/// <param name="base64"></param>
	public static string Crypto(RByte data, string algorithm, bool base64) {
		var b = Crypto(data, algorithm);
		return base64 ? Convert.ToBase64String(b) : Convert2.HexEncode(b);
	}
	
	/// <summary>
	/// Computes hash of string converted to UTF-8, using the specified cryptographic algorithm. Returns result as hex or base64 string.
	/// </summary>
	/// <param name="data"></param>
	/// <param name="algorithm">Algorithm name, eg <c>"SHA256"</c>. See <see cref="CryptoConfig"/>.</param>
	/// <param name="base64"></param>
	public static string Crypto(string data, string algorithm, bool base64) {
		var b = Crypto(data, algorithm);
		return base64 ? Convert.ToBase64String(b) : Convert2.HexEncode(b);
	}
	
	#endregion
	
}


================================================
FILE: Au/Au.More/HelpUtil.cs
================================================
namespace Au.More;

/// <summary>
/// Static functions to open a help topic etc.
/// </summary>
public static class HelpUtil {
	/// <summary>
	/// Opens a LibreAutomate help topic.
	/// </summary>
	/// <param name="topic">Topic file name, like <c>"wnd.find"</c> or <c>"Au.Types.RECT"</c> or <c>"articles/Wildcard expression"</c>.</param>
	public static void AuHelp(string topic) {
#pragma warning disable CS0612 //Type or member is obsolete
		var url = AuHelpUrl(topic);
#pragma warning restore CS0612 //Type or member is obsolete
		if (AuHelpEvent_ is { } e) {
			var k = new AuHelpEventArgs_ { Url = url };
			e(k);
			if (k.Cancel) return;
			url = k.Url;
		}
		run.itSafe(url);
	}
	
	/// <summary>
	/// Gets URL of a LibreAutomate help topic.
	/// </summary>
	/// <param name="topic">Topic file name, like <c>"wnd.find"</c> or <c>"Au.Types.RECT"</c> or <c>"articles/Wildcard expression"</c>.</param>
	public static string AuHelpUrl(string topic) {
		string fragment = null;
		int i = topic.IndexOf('#');
		if (i >= 0) {
			fragment = topic[i..];
			topic = topic[..i];
		}
		
		if (topic.Ends(".this[]")) topic = topic.ReplaceAt(^7.., ".Item");
		else if (topic.Ends(".this")) topic = topic.ReplaceAt(^5.., ".Item");
		else if (topic.Ends("[]")) topic = topic.ReplaceAt(^2.., ".Item");
		else if (topic.Contains("timer")) topic = topic.RxReplace(@"\btimer2?\.(after|every)\b\K", "_1"); //the filename has this suffix because of the instance method After/Every
		
		var url = AuHelpBaseUrl;
		if (!url.Ends('/')) url += "/";
		if (!topic.NE()) url = url
				+ (topic.Contains('/') ? null : (topic.Starts("Au.") ? "api/" : "api/Au."))
				+ topic
				+ (topic.Ends(".html") || topic.Ends('/') ? null : ".html")
				+ fragment;
		return url;
	}
	
	/// <summary>
	/// <c>s.Starts(false, "Au.", "articles/", "editor/", "cookbook/", "api/") > 0</c>
	/// </summary>
	internal static bool IsAuHelp_(string s) => s.Starts(false, "Au.", "articles/", "editor/", "cookbook/", "api/") > 0;
	
	/// <summary>
	/// URL of the LibreAutomate documentation website: <c>"https://www.libreautomate.com/"</c>.
	/// </summary>
	public static string AuHelpBaseUrl => "https://www.libreautomate.com/";

	internal static event Action<AuHelpEventArgs_> AuHelpEvent_;
	
	internal class AuHelpEventArgs_ : CancelEventArgs {
		public string Url { get; set; }
	}
}


================================================
FILE: Au/Au.More/HttpServerSession.cs
================================================
using System.Net;
using System.Net.Sockets;
using System.Text.Json;

namespace Au.More {
	/// <summary>
	/// Simple HTTP 1.1 server. Can be used for communicating between two scripts or apps on local network, internet or same computer. Also can receive requests from web browsers etc.
	/// </summary>
	/// <remarks>
	/// To receive HTTP messages, create a class with base <c>HttpServerSession</c> and add function <see cref="MessageReceived"/>. Example in <see cref="Listen"/>.
	/// </remarks>
	public abstract class HttpServerSession {
		/// <summary>
		/// Simple HTTP 1.1 server.
		/// </summary>
		/// <param name="port">TCP port. Default 4455. If 0, uses the first available port in the dynamic/private ports range (49152-65535); you can use the <i>started</i> callback to discover it.</param>
		/// <param name="ip">A local IPv4 or IPv6 address, like <c>"127.0.0.1"</c> or <c>"[::1]"</c>. If <c>null</c> (default), uses <see cref="IPAddress.IPv6Any"/> and dual mode (supports IPv6 and IPv4 connections).</param>
		/// <param name="started">Called when the server started (after <see cref="TcpListener.Start()"/>).</param>
		/// <exception cref="Exception">Exceptions of <see cref="TcpListener"/> functions. Unlikely.</exception>
		/// <remarks>
		/// Runs all the time and listens for new TCP client connections. For each connected client starts new thread, creates new object of your <see cref="HttpServerSession"/>-based type, and calls <see cref="Run"/>, which calls <see cref="MessageReceived"/>. Supports keep-alive. Multiple sessions can run simultaneously.
		///
		///	Uses <see cref="TcpListener"/>, not <see cref="HttpListener"/>, therefore don't need administrator privileges, <c>netsh</c> and opening ports in firewall. Just the standard firewall dialog first time.
		///
		/// The HTTP server is accessible from local network computers. Usually not accessible from the internet. To make accessible from the internet, you can use ngrok or similar software. This server does not support https (secure connections), but ngrok makes internet connections secure.
		/// 
		/// The Windows Firewall shows a dialog when the app uses a HTTP server the first time, unless <i>ip</i> is <c>"127.0.0.1"</c>.
		/// </remarks>
		/// <example>
		/// HTTP server.
		/// <code><![CDATA[
		/// HttpServerSession.Listen<MyHttpSession>();
		/// 
		/// class MyHttpSession : HttpServerSession {
		/// 	//protected override void Run() {
		/// 	//	print.it($"Session started. Client IP: {ClientIP}");
		/// 	//	base.Run();
		/// 	//	print.it("Session ended");
		/// 	//}
		/// 	
		/// 	protected override void MessageReceived(HSMessage m, HSResponse r) {
		/// 		//Auth((u, p) => p == "password206474");
		/// 		
		/// 		print.it(m.Method, m.TargetPath, m.UrlParameters, m.Headers, m.ContentText);
		/// 		
		/// 		string response = "RESPONSE";
		/// 		r.SetContent(response);
		/// 		//or
		/// 		//r.Content = response.ToUTF8();
		/// 		//r.Headers.Add("Content-Type", "text/plain; charset=utf-8");
		/// 	}
		/// }
		/// ]]></code>
		/// HTTP client.
		/// <code><![CDATA[
		/// var res = internet.http.Get("http://127.0.0.1:4455/file.txt?a=1&b=2"/*, auth: "user:pw"*/).Text(); //from same computer
		/// //var res = internet.http.Get("http://ComputerName:4455/file.txt?a=1&b=2"/*, auth: "user:pw"*/).Text(); //from local network
		/// //var res = internet.http.Get("https://1111-11-111-11-111.ngrok-free.app/file.txt?a=1&b=2"/*, auth: "user:pw"*/).Text(); //from internet through ngrok
		/// print.it(res);
		/// ]]></code>
		/// </example>
		public static void Listen<TSession>(int port = 4455, string ip = null, Action<TcpListener> started = null) where TSession : HttpServerSession, new() {
			var server = ip == null
				? TcpListener.Create(port) //IPAddress.IPv6Any, dual mode (supports IPv6 and IPv4 connections); shows Firewall popup.
				: new(IPAddress.Parse(ip), port); //no Firewall popup if "127.0.0.1" or "[::1]", but then no dual mode; `server.Server.DualMode=true` fails.
			
			server.Start();
			started?.Invoke(server);
			try {
				for (; ; ) {
					var client = server.AcceptTcpClient();
					run.thread(() => {
						new TSession()._Run(client);
						Interlocked.Decrement(ref s_nThreads);
					}).Name = "Au.HttpServerSession";
					Interlocked.Increment(ref s_nThreads);
					while (s_nThreads >= (osVersion.is32BitProcess ? 200 : 2000)) 200.ms();
				}
			}
			finally {
				server.Stop();
			}
		}
		static int s_nThreads;
		
		TcpClient _client;
		NetworkStream _ns;
		HSMessage _message; //current message
		
		/// <summary>
		/// Gets the <see cref="TcpClient"/> object of this session.
		/// </summary>
		protected TcpClient Client => _client;
		
		/// <summary>
		/// Gets the IP address of the client.
		/// </summary>
		protected IPAddress ClientIP => ((System.Net.IPEndPoint)_client.Client.RemoteEndPoint).Address;
		
		/// <summary>
		/// Print warning when something fails. This is for debug.
		/// </summary>
		protected bool Verbose { get; set; }
		
		/// <summary>
		/// Keep-alive timeout, in milliseconds. Default 10000.
		/// </summary>
		protected int KeepAliveTimeout { get; set; } = 10_000;
		
		/// <summary>
		/// Called when the server receives a HTTP request message.
		/// </summary>
		/// <param name="m">Contains request info and content.</param>
		/// <param name="r">Allows to set response info and content.</param>
		/// <remarks>
		///	Not called if failed to read the message.
		/// 
		/// The server uses try/catch when calling this. Prints unhandled exceptions if <see cref="Verbose"/> <c>true</c>. On unhandled exception sends error 500 (<c>InternalServerError</c>) and closes the connection.
		/// </remarks>
		protected abstract void MessageReceived(HSMessage m, HSResponse r);
		
		/// <summary>
		/// Performs basic authentication. If fails (either the client did not use basic authentication or <i>auth</i> returned <c>false</c>), throws exception. The client will receive error 401 (Unauthorized) and can retry.
		/// </summary>
		/// <param name="auth">Callback function. Receives the user name and password. Returns <c>true</c> to continue or <c>false</c> to fail.</param>
		/// <remarks>
		/// After successful authentication does not repeat it again when the client sends more messages in this session.
		/// </remarks>
		/// <example><see cref="HttpServerSession"/></example>
		protected void Auth(Func<string, string, bool> auth) {
			if (_auth != true) {
				_auth = _message.Headers.TryGetValue("Authorization", out var s)
					&& s.Split2_(' ', out var s1, out var s2, 5, 1)
					&& s1.Eqi("Basic")
					&& Convert.FromBase64String(s2).ToStringUTF8().Split2_(':', out s1, out s2, 0, 0)
					&& auth(s1, s2);
				if (_auth == false) throw new UnauthorizedAccessException();
			}
		}
		bool? _auth;
		
		void _Run(TcpClient client) {
			_client = client;
			_client.ReceiveTimeout = 30_000; //tested: throws when the socked receives 0 bytes in this time. It's not the total time of a Read.
			_client.SendTimeout = 30_000; //it seems this is how long the socket waits until previous chunk is sent. We send in max 64 KB chunks.
			try { Run(); }
			catch (Exception e1) {
				if (Verbose) print.warning(e1, "HttpServerSession: ");
			}
			_client.Close();
		}
		
		/// <summary>
		/// Executes the session: reads requests, calls your <see cref="MessageReceived"/>, writes responses, implements keep-alive.
		/// </summary>
		/// <remarks>
		/// The server uses try/catch when calling this. Prints unhandled exceptions if <see cref="Verbose"/> <c>true</c>. On unhandled exception closes the connection.
		/// </remarks>
		[SkipLocalsInit]
		protected virtual void Run() {
			_ns = _client.GetStream();
			g1:
			HttpStatusCode status;
			try {
				status = _ReadRequest();
			}
			catch (HttpReadException_ eh) {
				status = eh.status;
			}
			if (status == HttpReader_.Disconnected) return;
			
			HSResponse response = new() { Status = status };
			
			if (status == HttpStatusCode.OK) {
				try { MessageReceived(_message, response); }
				catch (UnauthorizedAccessException) when (_auth == false) {
					_auth = null;
					response.Status = HttpStatusCode.Unauthorized;
					response.Headers["WWW-Authenticate"] = "Basic";
				}
				catch (Exception e1) {
					if (Verbose) print.warning(e1, "HttpServerSession: ");
					if (response.Status == HttpStatusCode.OK) response.Status = HttpStatusCode.InternalServerError;
				}
			}
			
			bool keepAlive = KeepAliveTimeout > 0 && status == HttpStatusCode.OK && !(_message.Headers.TryGetValue("Connection", out var v1) && v1.Eqi("close"));
			if (!keepAlive) response.Headers["Connection"] = "close";
			
			_WriteResponse(response);
			_message = null;
			
			if (keepAlive) {
				if (_ns.Socket.Poll(Math.Min(KeepAliveTimeout, int.MaxValue / 1000) * 1000, SelectMode.SelectRead) && _ns.DataAvailable) goto g1; //else timeout or closed or error
			} else if (status != HttpStatusCode.OK) {
				//Cannot close until the client writes all data and reads the response. Else instead of response it may receive error 'connection reset'.
				//	On error often not all request bytes are read. And the size of this message is unknown.
				//	Read all remaining request bytes until the client closes connection.
				//		Client should close when it reads the response, because: 1. It's an error. 2. We send 'Connection: close'.
				//	tested: _ns.Socket.LingerState does not work.
				//	not tested (because this code works well): _ns.Close(timeout);.
				_client.ReceiveTimeout = 10_000; //if client never closes, we'll get timeout exception
				Span<byte> b = stackalloc byte[0x4000];
				while (_ns.Read(b) != 0) {  }
			}
		}
		
		void _WriteResponse(HSResponse r) {
			r.Headers.TryAdd("Date", DateTime.UtcNow.ToString("R"));
			r.Headers.TryAdd("Server", "Au");
			
			byte[] content = r.Content;
			bool hasContent = !content.NE_();
			if (hasContent) {
				//r.Headers.TryAdd("Content-Type", "Content-Type: text/plain; charset=utf-8"); //no. Server cannot guess. The HTML default is application/octet-stream.
				
				//compress
				if (content.Length > 1000 && _message.Headers.TryGetValue("Accept-Encoding", out var ae) && !r.Headers.ContainsKey("Content-Encoding")) {
					var h = ae.Lower().Split(new char[] { ',', ';' }, StringSplitOptions.TrimEntries); //use ';' to split items like "br;q=1.0", and ignore q
					var (content2, s2) =
						h.Contains("br") ? (Convert2.BrotliCompress(content), "br")
						: h.Contains("gzip") ? (Convert2.GzipCompress(content), "gzip")
						: h.Contains("deflate") ? (Convert2.DeflateCompress(content), "deflate")
						: (content, null);
					if (content2.Length < content.Length) {
						content = content2;
						r.Headers["Content-Encoding"] = s2;
					}
				}
			}
			r.Headers["Content-Length"] = content.Lenn_().ToS(); //if no content, set 0, else client may wait even if there is empty line
			
			int bs = 50 + r.Reason.Lenn() + r.Headers.Sum(o => o.Key.Length + o.Value.Length + 4);
			using (var w = new StreamWriter(_ns, Encoding.Latin1, bs, leaveOpen: true)) {
				w.Write($"HTTP/1.1 {(int)r.Status} {r.Status}");
				if (!r.Reason.NE()) w.Write(", " + r.Reason);
				w.WriteLine();
				
				foreach (var (k, v) in r.Headers) w.WriteLine(k + ": " + v);
				w.WriteLine();
			}
			
			if (hasContent) {
				//perf.first();
				//_ns.Write(content); //does not wait until client reads all data. Usually returns after ~1 ms regardless of size etc.
				for (int i = 0; i < content.Length;) {
					int n = Math.Min(0x10000, content.Length - i);
					_ns.Write(content, i, n); //waits if previous buffer still not sent
					i += n;
				}
				//perf.nw();
			}
		}
		
		[SkipLocalsInit]
		unsafe HttpStatusCode _ReadRequest() {
			_message = new();
			HttpReader_ reader = new(_ns);
			
			//read the request line
			{
				string s; do s = reader.ReadLine(); while (s.Length == 0);
				if (!s.RxMatch(@"^(GET|HEAD|POST|PUT|DELETE|CONNECT|OPTIONS|TRACE|PATCH) (.+) HTTP/(\d\.\d)$", out RXMatch m)) return HttpStatusCode.BadRequest;
				if (m[3].Value is not ("1.1" or "1.0")) return HttpStatusCode.HttpVersionNotSupported;
				_message.Method = m[1].Value;
				_message.RawTarget = s = m[2].Value;
				int i = s.IndexOf('?');
				if (i >= 0) {
					_message.UrlParameters = HSMessage.ParseUrlParameters_(s.AsSpan(i + 1));
					s = s[..i];
				}
				_message.TargetPath = WebUtility.UrlDecode(s);
			}
			
			//read headers
			var headers = _message.Headers;
			reader.ReadHeaders(headers);
			
			//read content
			_message.Content = reader.ReadContent(headers);
			
			//print.it("Target", message.RawTarget, message.TargetPath, message.UrlParameters);
			//print.it("Headers", message.Headers);
			//print.it("Content", message.ContentText);
			
			return HttpStatusCode.OK;
		}
	}
	
	/// <summary>
	/// Reads an HTTP request or response message.
	/// All functions may throw <see cref="HttpReadException_"/> and exceptions of <c>NetworkStream.Read</c>.
	/// The class was designed to read request, therefore throws exceptions such as <c>BadRequest</c>, but can be used to read response too.
	/// Uses 16 KB of stack. Consider <c>[SkipLocalsInit]</c>.
	/// </summary>
	unsafe ref struct HttpReader_ {
		readonly NetworkStream _ns;
		Span<byte> _b, _line;
		int _n; //current buffered bytes
		int _pos; //current position in _b (0.._n)
		const int c_bsize = 0x4000; //16 K
		fixed byte __b[c_bsize];
		
		public const HttpStatusCode Disconnected = 0;
		
		public HttpReader_(NetworkStream ns) {
			_ns = ns;
			fixed (byte* p = __b) _b = new(p, c_bsize);
		}
		
		void _Buffer() {
			if (_n > 0) {
				_b = _b.Slice(_n);
				if (_b.IsEmpty) {
					if (_line.Length == c_bsize) throw new HttpReadException_(HttpStatusCode.RequestHeaderFieldsTooLarge);
					fixed (byte* p = __b) _b = new(p, c_bsize);
					_line.CopyTo(_b);
					int ll = _line.Length;
					_line = _b;
					_b = _b.Slice(ll);
				}
				_pos = 0;
			}
			_n = _ns.Read(_b);
			if (_n == 0) throw new HttpReadException_(Disconnected);
		}
		
		//note: would be simpler with _ns.ReadByte(), but it is slow. Therefore we _ns.Read() chunks into __b, and then read bytes from there.
		int _ReadByte() {
			if (_pos == _n) _Buffer();
			return _b[_pos++];
		}
		
		public string ReadLine() {
			_line = _b.Slice(_pos);
			for (int len = 0; ; len++) {
				int c = _ReadByte();
				if (c is 10 or 13) {
					_ReadRN(c);
					return Encoding.Latin1.GetString(_line.Slice(0, len));
				}
			}
		}
		
		void _ReadRN(int c) {
			if (c == 10) return;
			if (c == 13 && _ReadByte() == 10) return;
			throw new HttpReadException_(HttpStatusCode.BadRequest);
		}
		
		public void ReadRN() {
			_line = _b.Slice(_pos);
			_ReadRN(_ReadByte());
		}
		
		public byte[] Read(int length) {
			var a = GC.AllocateUninitializedArray<byte>(length);
			Span<byte> span = a;
			
			//at first read from _b
			int n = _n - _pos;
			if (n > 0) {
				n = Math.Min(n, length);
				_b.Slice(_pos, n).CopyTo(a);
				_pos += n;
				span = span.Slice(n);
			}
			
			//then read from _ns, if did not read all from _b
			while (!span.IsEmpty) {
				n = _ns.Read(span);
				if (n == 0) throw new HttpReadException_(Disconnected);
				span = span.Slice(n);
			}
			
			return a;
		}
		
		/// <summary>
		/// Reads headers until empty line.
		/// </summary>
		/// <param name="headers">The function adds headers here.</param>
		public void ReadHeaders(Dictionary<string, string> headers) {
			string header = null;
			for (; ; ) {
				var s = ReadLine();
				if (s.Length == 0) break;
				if (s[0] is ' ' or '\t') {
					if (header == null) throw new HttpReadException_(HttpStatusCode.BadRequest);
					header = string.Concat(header, " ", s.AsSpan(1));
				} else {
					_Header();
					header = s;
				}
			}
			_Header();
			
			void _Header() {
				if (header != null) {
					int i = header.IndexOf(':'); if (i <= 0 || header[i - 1] <= ' ') throw new HttpReadException_(HttpStatusCode.BadRequest);
					var k = header[..i];
					var v = header.AsSpan(i + 1).Trim().ToString();
					if (!headers.TryAdd(k, v)) headers[k] += ", " + v;
				}
			}
		}
		
		/// <summary>
		/// Reads content and trailing headers.
		/// </summary>
		/// <param name="headers">The function gets content length etc from here. Also reads trailing headers here.</param>
		/// <returns><c>null</c> if <i>headers</i> don't contain content-length or transfer-encoding.</returns>
		public byte[] ReadContent(Dictionary<string, string> headers) {
			byte[] content = null;
			
			//get content info etc from headers
			int contentLength = 0;
			bool chunked = false, trailer = false;
			foreach (var (k, v) in headers) {
				if (k.Eqi("Content-Length")) contentLength = v.ToInt();
				else if (k.Eqi("Transfer-Encoding")) {
					if (v.Eq("chunked")) chunked = true;
					else throw new HttpReadException_(HttpStatusCode.NotImplemented, k);
				} else if (k.Eqi("Trailer")) trailer = true;
			}
			
			//read content
			if (chunked || contentLength > 0) {
				if (chunked) {
					List<byte[]> chunks = new();
					for (; ; ) {
						var s = ReadLine();
						if (!s.ToInt(out int len, flags: STIFlags.IsHexWithout0x | STIFlags.DontSkipSpaces)) throw new HttpReadException_(HttpStatusCode.BadRequest);
						if (len == 0) break;
						chunks.Add(Read(len));
						ReadRN();
					}
					
					if (chunks.Count > 0) {
						byte[] ac = chunks[0];
						if (chunks.Count > 1) {
							ac = new byte[chunks.Sum(o => o.Length)];
							int i = 0;
							foreach (var a in chunks) { a.CopyTo(ac, i); i += a.Length; }
						}
						content = ac;
					}
					
					if (trailer) { //headers after content
						ReadHeaders(headers);
					} else {
						ReadRN();
					}
				} else {
					content = Read(contentLength);
				}
			}
			
			return content;
		}
	}
	
	class HttpReadException_ : Exception {
		public HttpReadException_(HttpStatusCode status, string message = null) : base(message) { this.status = status; }
		public readonly HttpStatusCode status;
	}
}

namespace Au.Types {
	/// <summary>
	/// See <see cref="HttpServerSession.MessageReceived"/>.
	/// </summary>
	public class HSMessage {
		/// <summary>
		/// Method, like <c>"GET"</c> or <c>"POST"</c>.
		/// </summary>
		public string Method { get; internal set; }
		
		/// <summary>
		/// Target, like <c>"/file.html"</c> or <c>"/file.html?a=1&amp;b=2"</c> or <c>"/"</c>. May be URL-encoded.
		/// </summary>
		public string RawTarget { get; internal set; }
		
		/// <summary>
		/// Target without URL parameters, like <c>"/file.html"</c> or <c>"/"</c>. Not URL-encoded.
		/// </summary>
		public string TargetPath { get; internal set; }
		
		/// <summary>
		/// URL parameters (query string). Not URL-encoded.
		/// </summary>
		/// <value><c>null</c> if there are no URL parameters.</value>
		public Dictionary<string, string> UrlParameters { get; internal set; }
		
		/// <summary>
		/// Headers. Case-insensitive.
		/// </summary>
		public Dictionary<string, string> Headers { get; } = new(StringComparer.OrdinalIgnoreCase);
		
		/// <summary>
		/// Raw content. For example POST data as UTF-8 text or binary.
		/// </summary>
		/// <value><c>null</c> if the message is without content.</value>
		public byte[] Content { get; internal set; }
		
		/// <summary>
		/// <c>Content-Type</c> header info.
		/// </summary>
		/// <value><c>null</c> if <c>Content-Type</c> header is missing or invalid.</value>
		public HSContentType ContentType => _contentType ??= HSContentType.Create(Headers);
		HSContentType _contentType;
		
		/// <summary>
		/// <see cref="Content"/> converted to text.
		/// </summary>
		/// <value><c>null</c> if there is no content.</value>
		/// <remarks>If text encoding unspecified, uses UTF-8; if specified invalid, uses ASCII.</remarks>
		public string Text => _contentText ??= Content == null ? null : (ContentType?.Encoding ?? Encoding.UTF8).GetString(Content);
		string _contentText;
		
		/// <summary>
		/// JSON-deserializes <see cref="Content"/> to object of type <c>T</c>.
		/// </summary>
		/// <returns><c>default(T)</c> if the request does not have body data.</returns>
		/// <exception cref="Exception">Exceptions of <see cref="JsonSerializer.Deserialize{TValue}(Stream, JsonSerializerOptions?)"/>.</exception>
		public T Json<T>() => Content == null ? default : JsonSerializer.Deserialize<T>(Content, InternetUtil_.JsonSerializerOptions);
		
		/// <summary>
		/// JSON-deserializes <see cref="Content"/> to object of specified type.
		/// </summary>
		/// <returns><c>null</c> if the request does not have body data.</returns>
		/// <exception cref="Exception">Exceptions of <see cref="JsonSerializer.Deserialize(Stream, Type, JsonSerializerOptions?)"/>.</exception>
		public object Json(Type type) => Content == null ? default : JsonSerializer.Deserialize(Content, type, InternetUtil_.JsonSerializerOptions);
		
		/// <summary>
		/// Keys/values from POST content with <c>Content-Type: application/x-www-form-urlencoded</c>.
		/// </summary>
		/// <value><c>null</c> if the message has no content of this type.</value>
		public Dictionary<string, string> Urlencoded {
			get {
				if (_contentUrlParameters == null && Content != null && Headers.TryGetValue("Content-Type", out var v) && v.Starts("application/x-www-form-urlencoded", true)) {
					_contentUrlParameters = ParseUrlParameters_(Encoding.Latin1.GetString(Content));
				}
				return _contentUrlParameters;
			}
		}
		Dictionary<string, string> _contentUrlParameters;
		
		internal static Dictionary<string, string> ParseUrlParameters_(RStr s) {
			Dictionary<string, string> d = null;
			for (int i = 0, j; i < s.Length; i = j + 1) {
				int q = -1;
				for (j = i; j < s.Length && s[j] != '&'; j++) if (s[j] == '=' && q < 0) q = j;
				if (q > 0) (d ??= new())[WebUtility.UrlDecode(s.Slice(i, q - i).ToString())] = WebUtility.UrlDecode(s.Slice(++q, j - q).ToString());
			}
			return d;
		}
		
		/// <summary>
		/// Parts of multipart content. For example of POST content with <c>Content-Type: multipart/form-data</c>.
		/// </summary>
		/// <value><c>null</c> if the message has no multipart content.</value>
		public Dictionary<string, HSContentPart> Multipart {
			get {
				if (_contentParts == null && Content != null && Headers.TryGetValue("Content-Type", out var v) && v.Starts("multipart/", true)) {
					_contentParts = _GetContentMultipart();
				}
				return _contentParts;
			}
		}
		Dictionary<string, HSContentPart> _contentParts;
		
		Dictionary<string, HSContentPart> _GetContentMultipart() {
			if (Content == null || ContentType?.Boundary is not string sb || Content.Length < sb.Length * 2 + 8) return null;
			//print.it($"'{Content.ToStringUTF8()}'");
			Dictionary<string, HSContentPart> a = null;
			//need to parse bytes, not string, because part bodies can be binary or use various encodings
			RByte k = Content, b = Encoding.Latin1.GetBytes("--" + sb), b0 = b.Slice(2);
			if (!_FindBound(k, b, 0, out int startBound, out int endBound, out bool last)) return null;
			for (int index = 0; !last;) {
				int startPart = endBound;
				if (!_FindBound(k, b, startPart, out startBound, out endBound, out last)) return null;
				var part = k.Slice(startPart, startBound - startPart);
				//print.it($"<<{part.ToStringUTF8()}>>");
				int i = 0;
				if (!part.StartsWith("\r\n"u8)) {
					i = part.IndexOf("\r\n\r\n"u8) + 2; if (i < 2) continue;
				}
				var dh = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
				if (i != 0) {
					var sh = Encoding.Latin1.GetString(part.Slice(0, i - 2)).RxReplace(@"\n\h", " ");
					foreach (var v in sh.Lines(true)) {
						if (v.Split2_(':', out var s1, out var s2, 1, 0)) dh[s1] = s2;
					}
				}
				HSContentPart p = new(index++, dh, part.Slice(i + 2).ToArray());
				(a ??= new())[p.Name] = p;
			}
			return a;
			
			static bool _FindBound(RByte k, RByte b, int i, out int start, out int end, out bool last) {
				start = end = 0; last = false;
				for (; i < k.Length; i = end) {
					int j = k.Slice(i).IndexOf(b);
					if (j < 0) break;
					start = i + j;
					end = start + b.Length + 2;
					if (end > k.Length) break;
					if (start == 0 || (start >= 2 && k[start - 1] == '\n' && k[start - 2] == '\r')) {
						if (start >= 2) start -= 2;
						if (k[end - 1] == '\n' && k[end - 2] == '\r') return true;
						if (k[end - 1] == '-' && k[end - 2] == '-') { last = true; return true; }
					}
				}
				return false;
			}
		}
	}
	
	/// <summary>
	/// Contains a single part of a multipart POST data.
	/// </summary>
	/// <param name="Index">0-based index of this part in the list of parts.</param>
	/// <param name="Headers">Headers of this part.</param>
	/// <param name="Content">Raw content of this part. For example UTF-8 text.</param>
	public record class HSContentPart(int Index, Dictionary<string, string> Headers, byte[] Content) {
		/// <inheritdoc cref="HSMessage.ContentType"/>
		public HSContentType ContentType => _contentType ??= HSContentType.Create(Headers);
		HSContentType _contentType;
		
		/// <summary>
		/// <see cref="Content"/> converted to text.
		/// </summary>
		/// <value><c>null</c> if there is no content.</value>
		/// <remarks>If text encoding unspecified, uses UTF-8; if specified invalid, uses ASCII.</remarks>
		public string Text => _contentText ??= Content == null ? null : (ContentType?.Encoding ?? Encoding.UTF8).GetString(Content);
		string _contentText;
		
		System.Net.Mime.ContentDisposition _ContentDisposition() {
			if (_contentDisposition == null && Headers.TryGetValue("Content-Disposition", out var s)) try { _contentDisposition = new(s); } catch {  }
			return _contentDisposition;
		}
		System.Net.Mime.ContentDisposition _contentDisposition;
		
		/// <summary>
		/// Gets name from <c>Content-Disposition</c> header.
		/// </summary>
		/// <value>If <c>Content-Disposition</c> header or name is missing, returns <c>Index.ToS()</c>.</value>
		/// <remarks>
		///	Decodes <c>"=?utf-8?B?base64?="</c>.
		/// </remarks>
		public string Name => _name ??= _DecodeMime(_ContentDisposition()?.Parameters["name"] ?? Index.ToS());
		string _name;
		
		/// <summary>
		/// Gets filename from <c>Content-Disposition</c> header.
		/// </summary>
		/// <value><c>null</c> if <c>Content-Disposition</c> header or filename is missing.</value>
		/// <remarks>
		///	Decodes <c>"utf-8''urlencoded"</c> or <c>"=?utf-8?B?base64?="</c>.
		/// </remarks>
		public string FileName {
			get {
				if (_fileName == null && _ContentDisposition() is { } cd) {
					if (cd.Parameters["filename*"] is string s && s.Starts("utf-8''")) { //never mind: can be "any-charset'language'"
						try { _fileName = WebUtility.UrlDecode(s[7..]); } catch {  }
					}
					_fileName ??= _DecodeMime(cd.Parameters["filename"]);
				}
				return _fileName;
			}
		}
		string _fileName;
		
		static string _DecodeMime(string s) {
			if (s != null && s.Starts("=?utf-8?B?", true) && s.Ends("?=")) {
				try { return Convert.FromBase64String(s[10..^2]).ToStringUTF8(); } catch {  }
			}
			return s;
		}
	}
	
	/// <summary>
	/// Contains properties of HTTP <c>Content-Type</c> header.
	/// See <see cref="HSMessage.ContentType"/>.
	/// </summary>
	public class HSContentType {
		/// <summary>
		/// Creates from <c>Content-Type</c> header.
		/// </summary>
		/// <value><c>null</c> if <c>Content-Type</c> header is missing or invalid.</value>
		public static HSContentType Create(Dictionary<string, string> headers) {
			if (headers.TryGetValue("Content-Type", out var s)) {
				try { return new(new(s)); }
				catch {  }
			}
			return null;
		}
		
		HSContentType(System.Net.Mime.ContentType t) {
			MediaType = t.MediaType;
			Boundary = t.Boundary;
			Charset = t.CharSet;
			Encoding = _GetEncoding(t);
		}
		
		///
		public string MediaType { get; }
		
		/// <summary>
		/// Returns the boundary parameter without double quotes, or <c>null</c> if not specified.
		/// </summary>
		public string Boundary { get; }
		
		/// <summary>
		/// Returns the <c>charset</c> parameter, or <c>null</c> if not specified.
		/// </summary>
		public string Charset { get; }
		
		/// <summary>
		/// Gets text encoding.
		/// </summary>
		/// <value>Returns:
		/// <br/>• <c>null</c> if multipart content (<see cref="Boundary"/> not <c>null</c>).
		/// <br/>• UTF-8 if <c>charset</c> is <c>utf-8</c> or not specified.
		/// <br/>• <c>Encoding</c> that matches <c>charset</c>.
		/// <br/>• ASCII if <c>charset</c> is invalid.
		/// </value>
		public Encoding Encoding { get; }
		
		Encoding _GetEncoding(System.Net.Mime.ContentType t) {
			var s = Charset;
			if (s == null) return t.Boundary != null ? null : Encoding.UTF8;
			if (s.Eqi("utf-8")) return Encoding.UTF8;
			if (s.Eqi("us-ascii")) return Encoding.ASCII;
			if (s.Eqi("iso-8859-1")) return Encoding.Latin1;
			return StringUtil.GetEncoding(s) ?? Encoding.ASCII;
		}
	}
	
	/// <summary>
	/// See <see cref="HttpServerSession.MessageReceived"/>.
	/// </summary>
	public class HSResponse {
		/// <summary>
		/// Response status code. Initially <b>OK</b>.
		/// </summary>
		public HttpStatusCode Status { get; set; }
		
		/// <summary>
		/// Response reason phrase. Initially <c>null</c>.
		/// </summary>
		public string Reason { get; set; }
		
		/// <summary>
		/// Response headers. Initially empty.
		/// The server later may add <c>Date</c>, <c>Server</c>, <c>Content-Encoding</c>, <c>Content-Length</c>.
		/// </summary>
		public Dictionary<string, string> Headers { get; } = new(StringComparer.OrdinalIgnoreCase);
		
		/// <summary>
		/// Raw response content.
		/// </summary>
		/// <example>
		/// <code><![CDATA[
		/// r.Content = text.ToUTF8();
		/// ]]></code>
		/// </example>
		/// <remarks>
		/// The server may send this data compressed (it depends on headers etc).
		/// </remarks>
		public byte[] Content { get; set; }
		
		/// <summary>
		/// Sets response content text.
		/// </summary>
		/// <param name="content">Sets <see cref="Content"/>: <c>Content = content.ToUTF8();</c>.</param>
		/// <param name="contentType">If not <c>null</c>, sets <c>Content-Type</c> header.</param>
		public void SetContentText(string content, string contentType = "text/plain; charset=utf-8") {
			Content = content?.ToUTF8();
			if (contentType != null) Headers["Content-Type"] = contentType;
		}
		
		/// <summary>
		/// JSON-serializes object of type <c>T</c>, and sets <see cref="Content"/>. Also sets <c>Content-Type</c> header.
		/// </summary>
		/// <param name="obj">Object of type <c>T</c>.</param>
		/// <param name="contentType">If not <c>null</c>, sets <c>Content-Type</c> header.</param>
		/// <exception cref="Exception">Exceptions of <see cref="JsonSerializer.SerializeToUtf8Bytes{TValue}(TValue, JsonSerializerOptions?)"/>.</exception>
		public void SetContentJson<T>(T obj, string contentType = "application/json; charset=utf-8") {
			Content = JsonSerializer.SerializeToUtf8Bytes(obj, InternetUtil_.JsonSerializerOptions);
			if (contentType != null) Headers["Content-Type"] = contentType;
		}
		
		/// <summary>
		/// JSON-serializes object of specified type, and sets <see cref="Content"/>. Also sets <c>Content-Type</c> header.
		/// </summary>
		/// <param name="obj">Object.</param>
		/// <param name="type"><i>obj</i> type.</param>
		/// <param name="contentType">If not <c>null</c>, sets <c>Content-Type</c> header.</param>
		/// <exception cref="Exception">Exceptions of <see cref="JsonSerializer.SerializeToUtf8Bytes{TValue}(TValue, JsonSerializerOptions?)"/>.</exception>
		public void SetContentJson<T>(object obj, Type type, string contentType = "application/json; charset=utf-8") {
			Content = JsonSerializer.SerializeToUtf8Bytes(obj, type, InternetUtil_.JsonSerializerOptions);
			if (contentType != null) Headers["Content-Type"] = contentType;
		}
	}
	
	static class InternetUtil_ {
		static readonly Lazy<JsonSerializerOptions> s_defaultSerializerOptions = new(() => new(JsonSerializerDefaults.Web));
		
		public static JsonSerializerOptions JsonSerializerOptions => s_defaultSerializerOptions.Value;
	}
}


================================================
FILE: Au/Au.More/IconImageCache.cs
================================================
//TODO2: 2025-11: often the main floating toolbar expands slowly. 2025-12: fast again.

using System.Drawing;
using Microsoft.Win32;

namespace Au.More;

/// <summary>
/// Gets images as <see cref="Bitmap"/> of same logical size to be displayed as icons. Can get file icons or load images from files etc.
/// </summary>
/// <remarks>
/// Uses memory cache and optionally file cache to avoid loading same image multiple times. Getting images from cache is much faster.
///
/// <c>Bitmap</c> objects retrieved by this class are stored in memory cache. Don't dispose them before disposing the <c>IconImageCache</c> object. Usually don't need to dispose these <c>Bitmap</c> objects explicitly (GC will do it).
/// 
/// Thread-safe.
/// </remarks>
public sealed class IconImageCache : IDisposable {
	record class _DpiImages {
		readonly IconImageCache _cache;
		public readonly int dpi;
		public readonly string indexFile;
		public Dictionary<string, Hash.MD5Result> dNameHash; //index file data
		public readonly Dictionary<string, Bitmap> dNameBitmap = new(); //memory cache
		public readonly Dictionary<Hash.MD5Result, Bitmap> dHashBitmap = new(); //let all identical images share single Bitmap object
		
		//info: dictionary string keys are case-sensitive. We have not only paths but also base64 MD5. For paths we call Lower.
		
		public _DpiImages(IconImageCache cache, int dpi) {
			_cache = cache;
			this.dpi = dpi;
			if (_cache._dir is string s) indexFile = s + "\\" + dpi.ToS() + ".dpi";
		}
		
		/// <summary>
		/// If the index file for this DPI still not loaded, loads it into <c>dNameHash</c>.
		/// </summary>
		public void LoadIndexFile() {
			if (dNameHash == null && filesystem.exists(indexFile, useRawPath: true)) {
				try {
					bool save = false;
					Dictionary<string, Hash.MD5Result> d = new(StringComparer.OrdinalIgnoreCase);
					filesystem.waitIfLocked(() => {
						var fs = File.OpenRead(indexFile);
						using var br = new BinaryReader(fs);
						for (var len = fs.Length; fs.Position < len;) {
							var imageKey = br.ReadString();
							Hash.MD5Result hash = new(br.ReadInt64(), br.ReadInt64());
							ref var r = ref d.GetValueRefOrAddDefault_(imageKey, out bool exists);
							r = hash;
							if (exists) save = true; //save without duplicates. Keep the newest hash.
						}
					});
					dNameHash = d;
					if (save) _SaveIndex();
				}
				catch (Exception e1) { Debug_.Print(e1); }
			}
			dNameHash ??= new();
		}
		
		void _SaveIndex() {
			//print.it("<><c red>SaveIndex<>");
			filesystem.waitIfLocked(() => {
				var fs = File.Create(indexFile);
				using var bw = new BinaryWriter(fs);
				foreach (var v in dNameHash) {
					bw.Write(v.Key);
					bw.Write(v.Value.r1);
					bw.Write(v.Value.r2);
				}
			});
		}
		
		public void AppendToIndexFile(string imageKey, Hash.MD5Result hash) {
			filesystem.waitIfLocked(() => {
				var fs = File.Open(indexFile, FileMode.Append);
				using var bw = new BinaryWriter(fs);
				bw.Write(imageKey);
				bw.Write(hash.r1);
				bw.Write(hash.r2);
			});
		}
	}
	
	readonly string _dir;
	readonly List<_DpiImages> _aDpi = new(); //for each used DPI
	readonly int _imageSize;
	bool _disposed, _onceUsedFiles;
	readonly HashSet<string> _extDynamicIcon = new();
	
	static List<WeakReference<IconImageCache>> s_caches = new();
	
	/// <param name="imageSize">Width and height of images. Min 16, max 256.</param>
	/// <param name="directory">Path of cache directory. If <c>null</c>, will be used only memory cache.</param>
	/// <exception cref="ArgumentException">Not full path.</exception>
	public IconImageCache(int imageSize = 16, string directory = null) {
		if (imageSize < 16 || imageSize > 256) throw new ArgumentOutOfRangeException(nameof(imageSize));
		_imageSize = imageSize;
		//directory = null; //test memory-only cache
		if (directory != null) _dir = pathname.normalize(directory);
		
		lock (s_caches) s_caches.Add(new(this));
		
		//_InitNotifyWindow();
		script.GetAuxThread_(); //ensure the aux thread is running. It calls ClearAll_ when receives message "clear image caches".
	}
	
	/// <summary>
	/// Width and height of images.
	/// </summary>
	public int ImageSize => _imageSize;
	
	//public string CacheDirectory => _dir;
	
	/// <summary>
	/// Common cache for icons of size 16. Used by menus, toolbars and editor.
	/// </summary>
	/// <remarks>
	/// Uses cache directory <c>folders.ThisAppDataLocal + "iconCache"</c>.
	/// </remarks>
	public static IconImageCache Common => CommonOfSize(16);
	
	/// <summary>
	/// Common cache for icons of given size. Used by menus and toolbars if custom <see cref="MTBase.ImageSize"/>.
	/// </summary>
	/// <param name="imageSize">Width and height of images. Min 16, max 256.</param>
	public static IconImageCache CommonOfSize(int imageSize) {
		if (imageSize < 16 || imageSize > 256) throw new ArgumentOutOfRangeException(nameof(imageSize));
		return s_commonDict.GetOrAdd(imageSize, o => new(o, folders.ThisAppDataLocal + "iconCache" + (o == 16 ? "" : o.ToS())));
	}
	static ConcurrentDictionary<int, IconImageCache> s_commonDict = new();
	//rejected: if this is a portable app in a removable drive, use only memory cache (dir=null). Maybe only if folders.ThisAppDataLocal is in a fixed drive.
	//	Cannot reliably detect whether this app is portable. And whether the app (or user) wants to use the file cache.
	//	Eg this app may be in an external SSD drive, but external SSD drives are detected as fixed, and impossible to know whether it is used as a portable app.
	//	Instead, if this is a portable app and does not want to write in other drives, let it set folders.ThisAppDataLocal. And portable LA does it (as well as script processes started from it).
	
	/// <summary>
	/// Gets image from cache or file etc.
	/// </summary>
	/// <param name="imageSource">File path, or resource path that starts with <c>"resources/"</c> or has prefix <c>"resource:"</c>, or icon name like <c>"*Pack.Icon color"</c>, etc. See <i>isImage</i> parameter.</param>
	/// <param name="dpi">DPI of window that will display the image. See <see cref="Dpi"/>.</param>
	/// <param name="isImage">
	/// <c>false</c> - get file/folder/filetype/url/etc icon with <see cref="icon.of"/>. If <i>imageSource</i> is relative path of a <c>.cs</c> file, gets its custom icon as image; returns <c>null</c> if no custom icon or if editor isn't running.
	/// <c>true</c> - load image from xaml/png/etc file, database, resource or string with <see cref="ImageUtil.LoadGdipBitmap"/> or <see cref="ImageUtil.LoadWpfImageElement"/>. Can be icon name like <c>"*Pack.Icon color"</c> (see menu <b>Tools > Icons</b>).
	/// 
	/// To detect whether a string is an image, call <see cref="ImageUtil.HasImageOrResourcePrefix"/>; if it returns <c>true</c>, it is image.
	/// </param>
	/// <param name="onException">Action to call when fails to load image. If <c>null</c>, then silently returns <c>null</c>. Parameters are image source string and exception.</param>
	public unsafe Bitmap Get(string imageSource, int dpi, bool isImage, Action<string, Exception> onException = null) {
		//print.it(imageSource, isImage);
		if (_disposed) throw new ObjectDisposedException(nameof(IconImageCache));
		bool isXaml = isImage && (imageSource.Starts('<') || imageSource.Ends(".xaml", true));
		bool isStore = !isImage && imageSource.Starts(@"shell:AppsFolder\"); //compare case-sensitive. Then users can pass eg "shell:appsFolder..." to display white icons in blue background.
		bool ofWorkspaceFile = false;
		if (!isImage && !isStore && imageSource.Ends(".cs", true) && !pathname.isFullPath(imageSource, orEnvVar: true)) { //eg `script.run(@"x.cs");`
			imageSource = ScriptEditor.GetIcon(imageSource, EGetIcon.PathToIconName);
			if (imageSource == null) return null;
			isImage = ofWorkspaceFile = true;
			//rejected: use Dictionary<imageSource, iconName> to avoid frequent GetIcon for same imageSource. In LA process fast, elsewhere not too slow.
			//rejected: Move this code to the caller that needs it (MTBase).
		}
		bool isIconName = isImage && !isXaml && imageSource.Starts('*');
		if (isIconName) {
			isXaml = true;
			imageSource = IconString_.NormalizeColor(imageSource); //color can be "normal|highContrast"
		}
		if (!isXaml && !isStore) dpi = 96; //will scale when drawing, it's fast and not so bad. Tested scaling with Lanczos3 etc filters, but the result for icons isn't better.
		string imageKey = imageSource;
		if (!isIconName) {
			if ((isXaml && imageKey.Starts('<')) || (isImage && ImageUtil.HasImageStringPrefix(imageKey))) imageKey = Hash.MD5(imageSource, base64: true);
			else imageKey = imageKey.Lower();
		}
		bool isIco = !isImage && !isStore && imageKey.Ends(".ico");
		
		lock (this) {
			//get _DpiImages for dpi
			_DpiImages dd;
			foreach (var v in _aDpi) if (v.dpi == dpi) { dd = v; goto g1; }
			_aDpi.Add(dd = new _DpiImages(this, dpi));
			g1:
			
			if (dd.dNameBitmap.TryGetValue(imageKey, out var b)) return b;
			
			//print.it(imageSource, isImage);
			//using var p1 = perf.local();
			
			//bool useHash = !isImage && !isIco;
			bool useHash = isImage ? isIconName : !isIco; //use file cache for *icon too
			
			//use file cache for *icon too.
			//	Because:
			//		Loads XAML icon slowly first time (~100 ms; not measured after reboot), even in LA, and even later loads slower than from the cache file.
			//		Non-WPF process uses much more memory (because loads WPF), eg 14 -> 28 MB.
			//	Bad: when trying to find icons, users try many icons, colors, sizes. Then the cache is full of garbage.
			//		TODO3: remove from cache if not using anymore. Or add only if frequently using.
			//FUTURE: to make loading XAML icons faster etc, try Windows.UI.Xaml.Markup.XamlReader.Load. Use Microsoft.Windows.SDK.NET.dll, or directly COM if possible. When the library will not support Win7/8.
			
			bool useFile = _dir != null && useHash;
			if (useFile) {
				try {
					if (!_onceUsedFiles) {
						_onceUsedFiles = true;
						var fe = filesystem.exists(_dir);
						if (fe.File) filesystem.delete(_dir); //fbc (was .db file)
						if (!fe.Directory) filesystem.createDirectory(_dir);
						_InitFiles();
					}
					
					dd.LoadIndexFile();
					
					bool useExt = false; g2:
					if (dd.dNameHash.TryGetValue(imageKey, out var hash)) {
						if (dd.dHashBitmap.TryGetValue(hash, out var bb)) return bb;
						var path = _dir + "\\" + hash.ToString() + ".png";
						try {
							//b = (Bitmap)Image.FromFile(path); //no, locks file
							using (var stream = File.OpenRead(path)) b = (Bitmap)Image.FromStream(stream);
							dd.dNameBitmap[imageKey] = b;
							dd.dHashBitmap[hash] = b;
							return b;
						}
						catch (Exception e1) { Debug_.PrintIf(filesystem.exists(path), e1); }
					} else if (!useExt && !isImage && !isStore && !imageKey.Ends(".exe") && !imageKey.Ends(".lnk") && pathname.isFullPath(imageSource) && filesystem.exists(imageSource, useRawPath: true).File) {
						var ext = pathname.getExtension(imageKey);
						bool noExt = ext.Length == 0;
						if (noExt) ext = ".#"; //will get the icon of unknown file types
						if (dd.dNameBitmap.TryGetValue(ext, out var b1)) return b1;
						if (!_extDynamicIcon.Contains(ext)) {
							if (!noExt && _DynamicIcon(ext)) _extDynamicIcon.Add(ext); else { imageKey = imageSource = ext; useExt = true; goto g2; }
						}
					}
				}
				catch (Exception e1) { print.warning(e1); useFile = false; } //failed to create _dir
			}
			//p1.Next('C');
			
			try {
				//long t1 = perf.mcs;
				if (!isImage) {
					b = isStore ? icon.winStoreAppImage(imageSource, Dpi.Scale(_imageSize, dpi)) : null;
					b ??= icon.of(imageSource, _imageSize)?.ToGdipBitmap();
				} else {
					if (isIconName) {
						imageSource = ScriptEditor.GetIcon_(imageSource, EGetIcon.IconNameToXaml, skipResources: ofWorkspaceFile);
						//p1.Next('X');
						if (imageSource == null) return null;
					}
					if (isXaml) b = ImageUtil.LoadGdipBitmapFromXaml(imageSource, dpi, (_imageSize, _imageSize));
					else b = ImageUtil.LoadGdipBitmap(imageSource);
				}
				//if (useFile) useFile = perf.mcs - t1 > 1000; //reduces the index file size in worst cases, but makes significantly slower later
			}
			catch (Exception ex) {
				if (onException != null) onException(imageSource, ex);
				//else print.warning("IconImageCache.Get() failed. " + ex.ToStringWithoutStack()); //no. Often prints while editing text if editor shows images in text.
			}
			//p1.Next('L');
			
			if (b != null && (isImage ? useFile : !isIco)) {
				try {
					var ms = new MemoryStream();
					b.Save(ms, System.Drawing.Imaging.ImageFormat.Png); //~200 mcs. It's fast if compared with icon.of etc and saving.
					var hash = Hash.MD5(ms.GetBuffer().AsSpan(0, (int)ms.Position));
					
					ref var br = ref dd.dHashBitmap.GetValueRefOrAddDefault_(hash, out bool exists);
					if (!exists) br = b; else { b.Dispose(); b = br; }
					
					if (useFile) {
						//p1.Next();
						if (!exists) {
							//print.it("<><c green>save<>");
							filesystem.waitIfLocked(() => {
								using var fs = File.Create($@"{_dir}\{hash.ToString()}.png");
								fs.Write(ms.GetBuffer().AsSpan(0, (int)ms.Position));
							});
						}
						dd.dNameHash[imageKey] = hash;
						//p1.Next();
						dd.AppendToIndexFile(imageKey, hash);
					}
				}
				catch (Exception e1) { Debug_.Print(e1); }
			}
			
			dd.dNameBitmap[imageKey] = b;
			return b;
		}
		
		//rejected: Don't cache if non-literal (non-interned) string. Caller may generate many random strings, eg icon colors. Impossible to detect reliably.
		
		static bool _DynamicIcon(string ext) {
			if (Registry.GetValue(@"HKEY_CLASSES_ROOT\" + ext, "", null) is string s1) {
				//if (Registry.GetValue(@"HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\FileExts\" + ext + @"\UserChoice", "ProgId", null) is string s2) return _DI(s2); //it seems Windows ignores this when looking for icon handler or %1
				if (_DI(s1)) return true;
			}
			return false;
			
			static bool _DI(string progid)
				=> Registry.GetValue(@"HKEY_CLASSES_ROOT\" + progid + @"\ShellEx\IconHandler", "", null) is string
				|| Registry.GetValue(@"HKEY_CLASSES_ROOT\" + progid + @"\DefaultIcon", "", null) is "\"%1\"" or "%1"; //exe, ico, cur, ani
		}
	}
	
	void _InitFiles() {
		if (_dir == null) return;
		
		//delete cache files if changed OS/.NET/Au version
		var verPath = _dir + @"\version.txt";
		try {
			var sNew = osVersion.onaString;
			if (filesystem.exists(verPath, useRawPath: true)) {
				var sOld = filesystem.loadText(verPath);
				if (sNew == sOld) return;
				_ClearFiles();
			}
			filesystem.saveText(verPath, sNew);
		}
		catch (Exception e1) { Debug_.Print(e1); }
	}
	
	/// <summary>
	/// Removes images from memory cache (but does not dispose) and makes this object unusable.
	/// Optional.
	/// </summary>
	public void Dispose() {
		_disposed = true;
		_aDpi.Clear();
		_Dispose();
		GC.SuppressFinalize(this);
	}
	
	///
	~IconImageCache() { /*print.it("~IconImageCache");*/ _Dispose(); }
	
	void _Dispose() {
		lock (s_caches) {
			for (int i = s_caches.Count; --i >= 0;) {
				if (!s_caches[i].TryGetTarget(out var v) || v == this) s_caches.RemoveAt(i);
			}
		}
	}
	
	/// <summary>
	/// Clears the cache (removes images from memory cache and file cache).
	/// </summary>
	/// <param name="redrawWindows">Redraw (asynchronously) all visible windows of this process.</param>
	public void Clear(bool redrawWindows = false) {
		if (_disposed) throw new ObjectDisposedException(nameof(IconImageCache));
		if (_Clear() && redrawWindows) _RedrawWindowsOfThisProcess();
	}
	
	bool _Clear() {
		lock (this) {
			if (_disposed) return false;
			_aDpi.Clear();
			_extDynamicIcon.Clear();
		}
		_ClearFiles();
		Cleared?.Invoke();
		return true;
	}
	
	/// <summary>
	/// When the cache cleared.
	/// </summary>
	public event Action Cleared;
	
	void _ClearFiles() => _ClearFiles(_dir);
	
	static void _ClearFiles(string dir) {
		if (dir == null || !filesystem.exists(dir, true).Directory) return;
		try {
			bool deletedAll = true;
			foreach (var v in Directory.GetFiles(dir, "*.dpi")) deletedAll &= Api.DeleteFile(v);
			if (deletedAll) {
				foreach (var v in Directory.GetFiles(dir, "*.png")) deletedAll &= Api.DeleteFile(v);
				if (deletedAll && !dir.Ends(@"\iconCache", true) && Api.DeleteFile(dir + @"\version.txt")) Api.RemoveDirectory(dir);
			}
		}
		catch (Exception e1) { Debug_.Print(e1); }
	}
	
	static unsafe void _RedrawWindowsOfThisProcess() {
		foreach (var w in wnd.findAll(of: WOwner.Process(process.thisProcessId), flags: WFlags.CloakedToo))
			Api.RedrawWindow(w, flags: Api.RDW_INVALIDATE | Api.RDW_ALLCHILDREN);
	}
	
	/// <summary>
	/// Clears caches of all <see cref="IconImageCache"/> instances of this or all processes. Redraws (asynchronously) all visible windows of these processes.
	/// </summary>
	/// <param name="allProcesses">Clear in all processes of this user session.</param>
	public static void ClearAll(bool allProcesses = true) {
		ClearAll_();
		if (allProcesses) {
			//if called in LA process (eg menu Tools > Update icons), clear the cache dir of scripts.
			//	Without it would clear only if some script processes already used the cache.
			if (script.role == SRole.EditorExtension && Common._dir is string s1) {
				Debug.Assert(s1.Ends(@"\iconCache"));
				s1 = s1.ReplaceAt(^9.., "_script");
				//clear caches of all image sizes
				var a = filesystem.enumDirectories(s1, "iconCache*").ToArray();
				foreach (var f in a) {
					_ClearFiles(f.FullPath);
				}
			}
			
			for (var w = wnd.findFast(null, script.c_auxWndClassName, true); !w.Is0; w = wnd.findFast(null, script.c_auxWndClassName, true, w))
				if (!w.IsOfThisProcess) w.SendNotify(script.c_msg_IconImageCache_ClearAll);
		}
	}
	
	internal static void ClearAll_() {
		List<IconImageCache> a = new();
		lock (s_caches) foreach (var c in s_caches) if (c.TryGetTarget(out var v)) a.Add(v);
		bool redrawWindows = false;
		foreach (var v in a) redrawWindows |= v._Clear();
		if (redrawWindows) _RedrawWindowsOfThisProcess();
	}
	
	//static int s_auxInited;
	
	//static void _InitNotifyWindow() {
	//	//if (0 == Interlocked.Exchange(ref s_auxInited, 1)) {
	//	//	var t = script.GetAuxThread_();
	//	//	t.QueueAPC(_InitAuxThread);
	//	//}
	
	//	//static void _InitAuxThread() {
	//	//	//rejected. Assoc may be changed frequently. The cache probably even does not contain icons of those file types.
	//	//	//	Anyway cannot auto-clear if changed while cache not running.
	//	//	//	Also cannot auto-clear when icons changed not because of a changed assoc. Eg changed .exe icon, edited .ico, changed .lnk icon.
	//	//	//using var pidl = Pidl.FromString(":: ");
	//	//	//var e = new api.SHChangeNotifyEntry { pidl = pidl.UnsafePtr, fRecursive = true };
	//	//	//Api.SHChangeNotifyRegister(script.AuxWnd_, api.SHCNRF_ShellLevel, api.SHCNE_ASSOCCHANGED, script.c_msg_IconImageCache_ClearAll, 1, e);
	//	//	////undocumented: is it important to call SHChangeNotifyDeregister when this process ends?
	//	//}
	//}
}


================================================
FILE: Au/Au.More/ImageUtil.cs
================================================
using System.Windows;
using System.Windows.Markup;
using System.Windows.Controls;
using System.Windows.Media;
using System.Windows.Media.Imaging;

namespace Au.More;

/// <summary>
/// Loads WPF and GDI+ images from file, resource or string.
/// </summary>
/// <seealso cref="ResourceUtil"/>
public static partial class ImageUtil {
	/// <summary>
	/// Returns <c>true</c> if string starts with <c>"image:"</c>.
	/// </summary>
	public static bool HasImageStringPrefix(string s) => s.Starts("image:");
	
	/// <summary>
	/// Returns <c>true</c> if string starts with <c>"resource:"</c>, <c>"resources/"</c>, <c>"image:"</c> (Base64 encoded image), <c>"imagefile:"</c> (file path), <c>"*"</c> (XAML icon name) or <c>"&lt;"</c> (possibly XAML image).
	/// </summary>
	public static bool HasImageOrResourcePrefix(string s) => s.Starts('*') || s.Starts('<') || s.Starts("image:") || s.Starts("imagefile:") || ResourceUtil.HasResourcePrefix(s);
	
	/// <summary>
	/// Loads image file data as stream from Base64 string.
	/// </summary>
	/// <param name="s">Base64 encoded image string with prefix <c>"image:"</c>.</param>
	/// <exception cref="ArgumentException">String does not start with <c>"image:"</c> or is invalid Base64.</exception>
	/// <exception cref="Exception"><see cref="Convert2.BrotliDecompress"/> exceptions (when compressed <c>.bmp</c>).</exception>
	public static MemoryStream LoadImageStreamFromString(string s) {
		if (!HasImageStringPrefix(s)) throw new ArgumentException("String must start with \"image:\".");
		int start = 6; while (start < s.Length && s[start] <= ' ') start++; //can be eg "image:\r\n..."
		bool compressedBmp = s.Eq(start, "WkJN");
		if (compressedBmp) start += 4;
		int n = (int)((s.Length - start) * 3L / 4);
		var b = new byte[n];
		if (!Convert.TryFromBase64Chars(s.AsSpan(start), b, out n)) throw new ArgumentException("Invalid Base64 string");
		if (!compressedBmp) return new MemoryStream(b, 0, n, false);
		return new MemoryStream(Convert2.BrotliDecompress(b.AsSpan(0, n)), false);
	}
	
	/// <summary>
	/// Loads GDI+ image from Base64 string.
	/// </summary>
	/// <param name="s">Base64 encoded image string with prefix <c>"image:"</c>.</param>
	/// <exception cref="Exception">Exceptions of <see cref="LoadImageStreamFromString"/> and <see cref="System.Drawing.Bitmap(Stream)"/>.</exception>
	static System.Drawing.Bitmap _LoadGdipBitmapFromString(string s)
		=> new(LoadImageStreamFromString(s));
	
	/// <summary>
	/// Loads WPF image from Base64 string.
	/// </summary>
	/// <param name="s">Base64 encoded image string with prefix <c>"image:"</c>.</param>
	/// <exception cref="Exception">Exceptions of <see cref="LoadImageStreamFromString"/> and <see cref="BitmapFrame.Create(Stream)"/>.</exception>
	static BitmapFrame _LoadWpfImageFromString(string s)
		=> BitmapFrame.Create(LoadImageStreamFromString(s));
	
	//not used in library
	///// <summary>
	///// Calls <see cref="LoadGdipBitmapFromString"/> and handles exceptions. On exception returns <c>null</c> and optionally prints a warning.
	///// </summary>
	//public static System.Drawing.Bitmap TryLoadGdipBitmapFromString(string s, bool warning) {
	//	try { return LoadGdipBitmapFromString(s); }
	//	catch (Exception ex) { if (warning) print.warning(ex.ToStringWithoutStack()); }
	//	return null;
	//}
	
	///// <summary>
	///// Calls <see cref="LoadWpfImageFromString"/> and handles exceptions. On exception returns <c>null</c> and optionally prints warning.
	///// </summary>
	//public static BitmapFrame TryLoadWpfImageFromString(string s, bool warning) {
	//	try { return LoadWpfImageFromString(s); }
	//	catch (Exception ex) { if (warning) print.warning(ex.ToStringWithoutStack()); }
	//	return null;
	//}
	
	/// <summary>
	/// Loads GDI+ image from file, resource or string.
	/// </summary>
	/// <param name="image">
	/// Can be:
	/// <br/>• file path. Can have prefix <c>"imagefile:"</c>.
	/// <br/>• resource path that starts with <c>"resources/"</c> or has prefix <c>"resource:"</c> (<see cref="ResourceUtil.GetGdipBitmap"/>)
	/// <br/>• Base64 encoded image string with prefix <c>"image:"</c>.
	/// </param>
	/// <param name="xaml">If not <c>null</c>, supports XAML images. See <see cref="LoadGdipBitmapFromXaml"/>.</param>
	/// <exception cref="Exception">Depending on <i>image</i> string format, exceptions of <see cref="File.OpenRead(string)"/>, <see cref="System.Drawing.Bitmap(Stream)"/>, etc.</exception>
	public static System.Drawing.Bitmap LoadGdipBitmap(string image, (int dpi, SIZE? size)? xaml = null) {
		if (HasImageStringPrefix(image))
			return _LoadGdipBitmapFromString(image);
		if (xaml != null && (image.Starts('<') || image.Ends(".xaml", true)))
			return LoadGdipBitmapFromXaml(image, xaml.Value.dpi, xaml.Value.size);
		if (ResourceUtil.HasResourcePrefix(image))
			return ResourceUtil.GetGdipBitmap(image);
		if (image.Starts("imagefile:")) image = image[10..];
		image = pathname.normalize(image, folders.ThisAppImages);
		//return new(image); //no, the file remains locked until the Bitmap is disposed (documented, tested)
		using var fs = File.OpenRead(image);
		return new(fs);
	}
	
	/// <summary>
	/// Loads WPF image or icon from file, resource or string.
	/// </summary>
	/// <param name="image">
	/// Can be:
	/// <br/>• file path. Can have prefix <c>"imagefile:"</c>.
	/// <br/>• resource path that starts with <c>"resources/"</c> or has prefix <c>"resource:"</c> (<see cref="ResourceUtil.GetWpfImage"/>)
	/// <br/>• Base64 encoded image string with prefix <c>"image:"</c>.
	/// </param>
	/// <exception cref="Exception"></exception>
	public static BitmapFrame LoadWpfImage(string image) {
		if (HasImageStringPrefix(image)) return _LoadWpfImageFromString(image);
		if (ResourceUtil.HasResourcePrefix(image)) return ResourceUtil.GetWpfImage(image);
		if (image.Starts("imagefile:")) image = image[10..];
		image = pathname.normalize(image, folders.ThisAppImages, flags: PNFlags.CanBeUrlOrShell); //CanBeUrlOrShell: support "pack:"
		return BitmapFrame.Create(new Uri(image));
		//rejected: support XAML and "*iconName". Possible but not easy. Probably would be blurred when autoscaled.
	}
	
	/// <summary>
	/// Loads WPF image element from file, resource or string. Supports xaml, png and other image formats supported by WPF.
	/// </summary>
	/// <param name="image">
	/// Can be:
	/// <br/>• file path. Can be <c>.xaml</c>, <c>.png</c> etc. Supports environment variables etc, see <see cref="pathname.expand"/>. Can have prefix <c>"imagefile:"</c>.
	/// <br/>• resource path that starts with <c>"resources/"</c> or has prefix <c>"resource:"</c>. This function calls <see cref="ResourceUtil.GetXamlObject"/> if ends with <c>".xaml"</c>, else <see cref="ResourceUtil.GetWpfImage"/>.
	/// <br/>• Base64 encoded image with prefix <c>"image:"</c>. See <see cref="LoadImageStreamFromString"/>.
	/// <br/>• XAML string that starts with <c>"&lt;"</c>. For example from the <b>Icons</b> tool of LibreAutomate.
	/// <br/>• XAML icon name like <c>"*Pack.Icon color"</c> or <c>"*Pack.Icon color @size"</c> or <c>"*Pack1.Icon1 color1; *Pack2.Icon2 color2 %8,8,,"</c>. More info in Remarks.
	/// </param>
	/// <returns>
	/// If <i>image</i> is XAML icon name or starts with <c>"&lt;"</c> or ends with <c>".xaml"</c> (case-insensitive), returns new WPF element of type specified by the XAML root element (uses <see cref="XamlReader"/>). Else returns <see cref="Image"/> with <c>Source</c> = <see cref="BitmapFrame"/> (uses <see cref="LoadWpfImage"/>).
	/// </returns>
	/// <remarks>
	/// <i>image</i> can be an XAML icon name from the <b>Icons</b> tool of LibreAutomate (LA), like <c>"*Pack.Icon color"</c>. Full format: <c>"[*&lt;library&gt;]*pack.name[ color][ @size][ %margin][;more icons]"</c>. Here parts enclosed in <c>[]</c> are optional. The color, size and margin parts can be in any order.
	/// <br/>• color - <c>#RRGGBB</c> or color name (WPF). If 2 colors like <c>"#008000|#00FF00"</c>, the second color is for high contrast dark theme. If omitted, will use the system color of control text. Also can be like <c>"#008000|"</c> to use control text only for dark contrast theme, or <c>"|#00FF00"</c> for vice versa.
	/// <br/>• size - icon size 1 to 16, like <c>"*Pack.Icon blue @12"</c>. Can be used to make the displayed icon smaller or in some cases less blurry. It is the logical width and height of the icon rendered at the center of a box of logical size 16x16. To make icon bigger, instead set properties <c>Width</c> and <c>Height</c> of the returned element; or <see cref="MTBase.ImageSize"/> for a toolbar or menu.
	/// <br/>• margin - icon margins inside a box of logical size 16x16. Format: <c>%left,top,right,bottom,stretch,snap</c>. All parts are optional. Examples: <c>"*Pack.Icon blue %,,8,8"</c>, <c>"*Pack.Icon blue %8,8"</c>, <c>"*Pack.Icon blue %4,,4,,f"</c>. The stretch part can be <c>f</c> (fill) or <c>m</c> (move); default is uniform. The snap part can be <c>p</c> (sets <c>SnapsToDevicePixels=True</c>). Can be used either margin or size, not both.
	/// <br/>• more icons - can be specified multiple icons separated by semicolon, like <c>"*Pack1.Icon1 color1; *Pack2.Icon2 color2"</c>. It allows to create multi-color icons (for example a "filled" icon of one color + an "outline" icon of another color) or to add a small overlay icon (eg to indicate disabled state) at a corner (use margin).
	/// <br/>• library - name of assembly containing the resource. If omitted, uses <see cref="Assembly.GetEntryAssembly"/>.
	/// <br/>The LA compiler finds icon strings anywhere in code, gets their XAML from the database, and adds the XAML to the assembly as a string resource (see <b>Properties > Resource > Options</b>). This function gets the XAML from resources (<see cref="ResourceUtil.GetString"/>). If fails, then tries to get XAML from database, and fails if LA isn't running. Uses <see cref="ScriptEditor.GetIcon"/>.
	/// </remarks>
	/// <exception cref="Exception"></exception>
	public static FrameworkElement LoadWpfImageElement(string image) {
		if (image.Starts('*')) {
			image = ScriptEditor.GetIcon(image, EGetIcon.IconNameToXaml) ?? throw new AuException("*get icon " + image);
		}
		if (image.Starts('<')) return (FrameworkElement)XamlReader.Parse(image);
		if (image.Ends(".xaml", true)) {
			if (ResourceUtil.HasResourcePrefix(image)) return (FrameworkElement)ResourceUtil.GetXamlObject(image);
			if (image.Starts("imagefile:")) image = image[10..];
			using var stream = File.OpenRead(image);
			return (FrameworkElement)XamlReader.Load(stream);
		} else {
			var bf = LoadWpfImage(image);
			return new Image { Source = bf };
		}
		//Could set UseLayoutRounding=true as a workaround for blurry images, but often it does not work and have to be set on parent element.
		//	Then does not work even if wrapped eg in a Border with UseLayoutRounding.
	}
	
	/// <summary>
	/// Loads GDI+ image from WPF XAML file or string.
	/// </summary>
	/// <param name="image">XAML file, resource or string. See <see cref="LoadWpfImageElement"/>.</param>
	/// <param name="dpi">DPI of window that will display the image.</param>
	/// <param name="size">Final image size in logical pixels (not DPI-scaled). If <c>null</c>, uses element's <c>DesiredSize</c> property, max 1024x1024.</param>
	/// <returns>New <c>Bitmap</c>. Note: its pixel format is <c>Format32bppPArgb</c> (premultiplied ARGB).</returns>
	/// <exception cref="Exception"></exception>
	/// <remarks>
	/// Calls <see cref="LoadWpfImageElement"/> and <see cref="ConvertWpfImageElementToGdipBitmap"/>.
	/// Don't use the <c>Tag</c> property of the bitmap. It keeps bitmap data.
	/// </remarks>
	[MethodImpl(MethodImplOptions.NoInlining)]
	public static System.Drawing.Bitmap LoadGdipBitmapFromXaml(string image, int dpi, SIZE? size = null) {
		var e = LoadWpfImageElement(image);
		//s_cwt.Add(e, new());
		return ConvertWpfImageElementToGdipBitmap(e, dpi, size);
	}
	
	/// <summary>
	/// Converts WPF image element to GDI+ image.
	/// </summary>
	/// <param name="e">For example <see cref="Viewbox"/>.</param>
	/// <param name="dpi">DPI of window that will display the image.</param>
	/// <param name="size">
	/// Final image size in logical pixels (not DPI-scaled).
	/// If <c>null</c>, uses element's <c>DesiredSize</c> property, max 1024x1024.
	/// If not <c>null</c>, sets element's <c>Width</c> and <c>Height</c>; the element should not be used in UI.
	/// </param>
	/// <returns>New <c>Bitmap</c>. Note: its pixel format is <c>Format32bppPArgb</c> (premultiplied ARGB).</returns>
	public static unsafe System.Drawing.Bitmap ConvertWpfImageElementToGdipBitmap(FrameworkElement e, int dpi, SIZE? size = null) {
		bool measured = e.IsMeasureValid;
		if (size != null) {
			measured = false;
			e.Width = size.Value.width;
			e.Height = size.Value.height;
		}
		if (!measured) e.Measure(new Size(double.PositiveInfinity, double.PositiveInfinity));
		bool arranged = measured && e.IsArrangeValid;
		if (!arranged) e.Arrange(new Rect(e.DesiredSize));
		if (!arranged) e.UpdateLayout(); //prevent memory leak
		if (size == null) {
			var z = e.DesiredSize; //if using RenderSize or ActualX, if element height!=width, draws in wrong place, clipped
			size = new(Math.Min(1024d, z.Width).ToInt(), Math.Min(1024d, z.Height).ToInt());
		}
		var (wid, hei) = Dpi.Scale(size.Value, dpi);
		var rtb = new RenderTargetBitmap(wid, hei, dpi, dpi, PixelFormats.Pbgra32);
		//var rtb = t_rtb ??= new RenderTargetBitmap(wid, hei, dpi, dpi, PixelFormats.Pbgra32); rtb.Clear(); //not better
		//note: if Bgra32, throws exception "'Bgra32' PixelFormat is not supported for this operation".
		rtb.Render(e);
		int stride = wid * 4, msize = hei * stride;
		var b = new System.Drawing.Bitmap(wid, hei, System.Drawing.Imaging.PixelFormat.Format32bppPArgb);
		using var d = b.Data(System.Drawing.Imaging.ImageLockMode.ReadWrite);
		rtb.CopyPixels(new(0, 0, wid, hei), d.Scan0, msize, stride);
		b.SetResolution(dpi, dpi);
		return b;
		//tested: GC OK. Don't need GC_.AddObjectMemoryPressure. WPF makes enough garbage to trigger GC when need.
	}
	
	/// <summary>
	/// Converts WPF image element to native icon file data.
	/// </summary>
	/// <param name="stream">Stream to write icon file data. Writes from start.</param>
	/// <param name="e">Image element. See <see cref="LoadWpfImageElement"/>.</param>
	/// <param name="sizes">Sizes of icon images to add. For example 16, 24, 32, 48, 64. Sizes can be 1 to 256 inclusive.</param>
	/// <exception cref="ArgumentOutOfRangeException">An invalid size.</exception>
	/// <exception cref="Exception"></exception>
	internal static unsafe void ConvertWpfImageElementToIcon_(Stream stream, FrameworkElement e, int[] sizes) {
		stream.Position = Math2.AlignUp(sizeof(Api.NEWHEADER) + sizeof(Api.ICONDIRENTRY) * sizes.Length, 4);
		var a = stackalloc Api.ICONDIRENTRY[sizes.Length];
		for (int i = 0; i < sizes.Length; i++) {
			int size = sizes[i];
			if (size < 1 || size > 256) throw new ArgumentOutOfRangeException();
			using var b = ImageUtil.ConvertWpfImageElementToGdipBitmap(e, 96, (size, size));
			int pos = (int)stream.Position;
			b.Save(stream, System.Drawing.Imaging.ImageFormat.Png);
			byte bsize = (byte)(size == 256 ? 0 : checked((byte)size));
			a[i] = new Api.ICONDIRENTRY { bWidth = bsize, bHeight = bsize, wBitCount = 32, dwBytesInRes = (int)stream.Position - pos, dwImageOffset = pos };
		}
		var posEnd = stream.Position;
		stream.Position = 0;
		var h = new Api.NEWHEADER { wResType = 1, wResCount = (ushort)sizes.Length };
		stream.Write(new(&h, sizeof(Api.NEWHEADER)));
		stream.Write(new(a, sizeof(Api.ICONDIRENTRY) * sizes.Length));
		stream.Position = posEnd;
	}
	
	/// <summary>
	/// Converts WPF image element to native icon file.
	/// </summary>
	/// <inheritdoc cref="ConvertWpfImageElementToIcon_(Stream, FrameworkElement, int[])"/>
	internal static void ConvertWpfImageElementToIcon_(string icoFile, FrameworkElement e, int[] sizes) {
		icoFile = pathname.NormalizeMinimally_(icoFile);
		using var stream = File.OpenWrite(icoFile);
		ConvertWpfImageElementToIcon_(stream, e, sizes);
	}
	
	/// <summary>
	/// Converts XAML icon to GDI+ icon.
	/// </summary>
	/// <param name="s">Icon name or XAML etc. See <see cref="ImageUtil.LoadWpfImageElement"/>.</param>
	/// <param name="size"></param>
	/// <returns>If fails, prints warning and returns null.</returns>
	internal static System.Drawing.Icon XamlIconToGdipIcon_(string s, int size) {
		try {
			var e = ImageUtil.LoadWpfImageElement(s);
			var ms = new MemoryStream();
			ImageUtil.ConvertWpfImageElementToIcon_(ms, e, [size]);
			ms.Position = 0;
			return new System.Drawing.Icon(ms);
		}
		catch (Exception ex) { print.warning(ex); return null; }
	}
}


================================================
FILE: Au/Au.More/KeyToTextConverter.cs
================================================
namespace Au.More;

/// <summary>
/// Converts virtual-key codes to text characters.
/// </summary>
/// <remarks>
/// To record user input, can be used <see cref="WindowsHook.Keyboard(Action{HookData.Keyboard}, bool, bool)"/>.
/// When recording user input, use same <c>KeyToTextConverter</c> variable for all keys.
/// </remarks>
public class KeyToTextConverter
{
	(KKey vk, KMod mod, uint sc, nint hkl) _deadKey;

	/// <summary>
	/// Converts a virtual-key code to text.
	/// </summary>
	/// <param name="text">Receives text. Can be 1 character <i>c</i>, or string <i>s</i> with 2 or more characters. Receives default if this function returns <c>false</c> or if the key is a dead key.</param>
	/// <param name="vk">Virtual-key code.</param>
	/// <param name="sc">Scan code.</param>
	/// <param name="mod">Modifier keys (<c>Shift</c> etc). See <see cref="keys.getMod(KMod)"/>.</param>
	/// <param name="threadId">Thread id of the focused or active window. Need for keyboard layout. If 0, uses this thread.</param>
	/// <returns><c>true</c> if it's a text key or dead key.</returns>
	public unsafe bool Convert(out (char c, string s) text, KKey vk, uint sc, KMod mod, int threadId) {
		text = default;
		if (vk == KKey.Packet) {
			text.c = (char)sc;
		} else {
			if (!IsPossiblyChar_(mod, vk)) return false;

			var hkl = Api.GetKeyboardLayout(threadId);
			var ks = stackalloc byte[256];
			_SetKS(mod);
			var c = stackalloc char[8];
			bool win10 = osVersion.minWin10_1607; //the API resets dead key etc, but on new OS flag 4 prevents it
			int n = Api.ToUnicodeEx((uint)vk, sc, ks, c, 8, win10 ? 4u : 0u, hkl);
			if (n == 1 && c[0] < ' ') {
				Debug_.Print($"{(int)c[0]}, {c[0]}");
				if (c[0] == '\r') c[n++] = '\n'; else if (c[0] is not ('\t' or '\n')) n = 0;
			}
			if (n == 1) text.c = c[0]; else if (n > 0) text.s = new(c, 0, n);
			if (!win10) { //if need, set dead key again
				if (_deadKey.vk != 0 && _deadKey.hkl == hkl) {
					_SetKS(_deadKey.mod);
					Api.ToUnicodeEx((uint)_deadKey.vk, _deadKey.sc, ks, c, 8, 0, hkl);
					_deadKey.vk = 0;
				} else if (n < 0) {
					_deadKey = (vk, mod, sc, hkl);
					Api.ToUnicodeEx((uint)vk, sc, ks, c, 8, 0, hkl);
				}
			}
			if (n == 0) return false; //non-char key

			void _SetKS(KMod m) {
				ks[(int)KKey.Shift] = (byte)((0 != (m & KMod.Shift)) ? 0x80 : 0);
				ks[(int)KKey.Ctrl] = (byte)((0 != (m & KMod.Ctrl)) ? 0x80 : 0);
				ks[(int)KKey.Alt] = (byte)((0 != (m & KMod.Alt)) ? 0x80 : 0);
				//ks[(int)KKey.Win] = (byte)((0 != (m & KMod.Win)) ? 0x80 : 0);
				ks[(int)KKey.CapsLock] = (byte)(keys.isCapsLock ? 1 : 0); //don't need this for num lock
			}
		}
		return true;

		//Notes:
		//1. Does not work with eg Chinese input method.
		//2. Catches everything that would later be changed by the app, or by a next hook, etc.
		//3. Don't know how to get Alt+numpad characters. Ignore them.
		//	On Alt up could call tounicodeex with sc with flag 0x8000. It gets the char, but resets keyboard state, and the char is not typed.
		//4. In console windows does not work with Unicode characters.

		//if(MapVirtualKeyEx(vk, MAPVK_VK_TO_CHAR, hkl)&0x80000000) { print.it("DEAD"); return -1; } //this cannot be used because resets dead key
	}

	/// <summary>
	/// Clears internal fields such as dead key state.
	/// </summary>
	public void Clear() {
		_deadKey = default;
	}

	/// <summary>
	/// Returns <c>true</c> if the key + modifiers could generate a character, including <c>Enter</c> and <c>Tab</c> but not other control characters.
	/// </summary>
	internal static bool IsPossiblyChar_(KMod m, KKey k) {
		if (m.Has(KMod.Win) || (m & ~KMod.Shift) == KMod.Ctrl || m == (KMod.Alt | KMod.Shift)) return false;
		if (k is KKey.Back or KKey.Escape) return false;
		return true;
	}
}


================================================
FILE: Au/Au.More/Math2.cs
================================================
namespace Au.More;

/// <summary>
/// Simple calculation functions.
/// </summary>
//[DebuggerStepThrough]
public static class Math2 {
	/// <summary>
	/// Creates <c>uint</c> by placing <c>(ushort)loWord</c> in bits 1-16 and <c>(ushort)hiWord</c> in bits 17-32.
	/// Like C macro <c>MAKELONG</c>, <c>MAKEWPARAM</c>, <c>MAKELPARAM</c>, <c>MAKELRESULT</c>.
	/// </summary>
	/// <returns>The return value is of type <c>nint</c>. It can be used with Windows message API as <i>lParam</i> or <i>wParam</i> or return value.</returns>
	public static nint MakeLparam(int loWord, int hiWord) => MakeLparam((uint)loWord, (uint)hiWord);
	//Returns nint, because usually used as sendmessage etc parameter. If uint, would need to explicitly cast to nint. If somebody casts to int, the result may be incorrect, ie negative.
	
	//Why named MakeLparam, MakeWord, LoWord, HiWord:
	//	1. Like C macros MAKELPARAM/MAKEWORD/LOWORD/HIWORD.
	//	2. MakeLparam used mostly as lParam of sendmessage etc.
	
	/// <inheritdoc cref="MakeLparam(int, int)"/>
	public static nint MakeLparam(uint loWord, uint hiWord) => (nint)(((hiWord & 0xffff) << 16) | (loWord & 0xffff));
	
	/// <summary>
	/// Creates <c>uint</c> by placing <c>(ushort)p.x</c> in bits 1-16 and <c>(ushort)p.y</c> in bits 17-32.
	/// Like C macro <c>MAKELONG</c>, <c>MAKEWPARAM</c>, <c>MAKELPARAM</c>, <c>MAKELRESULT</c>.
	/// </summary>
	/// <returns>The return value is of type <c>nint</c>. It can be used with Windows message API as <i>lParam</i> or <i>wParam</i> or return value.</returns>
	public static nint MakeLparam(POINT p) => MakeLparam((uint)p.x, (uint)p.y);
	
	/// <summary>
	/// Creates <c>ushort</c> by placing <c>(byte)loByte</c> in bits 1-8 and <c>(byte)hiByte</c> in bits 9-16.
	/// Like C macro <c>MAKEWORD</c>.
	/// </summary>
	public static ushort MakeWord(int loByte, int hiByte) => MakeWord((uint)loByte, (uint)hiByte);
	
	/// <inheritdoc cref="MakeWord(int, int)"/>
	public static ushort MakeWord(uint loByte, uint hiByte) => (ushort)(((hiByte & 0xff) << 8) | (loByte & 0xff));
	
	/// <summary>
	/// Gets bits 1-16 as <c>ushort</c>.
	/// Like C macro <c>LOWORD</c>.
	/// </summary>
	/// <remarks>
	/// The parameter is interpreted as <c>uint</c>. The parameter type <c>nint</c> allows to avoid explicit cast from <c>int</c> and <c>IntPtr</c>.
	/// </remarks>
	public static ushort LoWord(nint x) => (ushort)((uint)x & 0xFFFF);
	
	/// <summary>
	/// Gets bits 17-32 as <c>ushort</c>.
	/// Like C macro <c>HIWORD</c>.
	/// </summary>
	/// <inheritdoc cref="LoWord(nint)"/>
	public static ushort HiWord(nint x) => (ushort)((uint)x >> 16);
	
	/// <summary>
	/// Gets bits 1-16 as <c>short</c>.
	/// Like C macro <c>GET_X_LPARAM</c>.
	/// </summary>
	/// <inheritdoc cref="LoWord(nint)"/>
	public static short LoShort(nint x) => (short)((uint)x & 0xFFFF);
	
	/// <summary>
	/// Gets bits 17-32 as <c>short</c>.
	/// Like C macro <c>GET_Y_LPARAM</c>.
	/// </summary>
	/// <inheritdoc cref="LoWord(nint)"/>
	public static short HiShort(nint x) => (short)((uint)x >> 16);
	
	/// <summary>
	/// Gets bits 1-8 as <c>byte</c>.
	/// Like C macro <c>LOBYTE</c>.
	/// </summary>
	public static byte LoByte(ushort x) => (byte)((uint)x & 0xFF);
	
	/// <summary>
	/// Gets bits 9-16 as <c>byte</c>.
	/// Like C macro <c>HIBYTE</c>.
	/// </summary>
	public static byte HiByte(ushort x) => (byte)((uint)x >> 8);
	
	/// <summary>
	/// Converts <c>nint</c> containing x and y coordinates to <see cref="POINT"/>.
	/// </summary>
	public static POINT NintToPOINT(nint xy) => new(LoShort(xy), HiShort(xy));
	
	/// <summary>
	/// Returns <c>number * multiply / divide</c>.
	/// Multiplies without overflow and rounds up or down to the nearest integer.
	/// </summary>
	/// <exception cref="OverflowException"></exception>
	/// <exception cref="DivideByZeroException"></exception>
	public static int MulDiv(int number, int multiply, int divide) {
		if (divide == multiply) return number;
		long r = (long)number * multiply;
		int d = divide / 2; if (r < 0 == divide < 0) r += d; else r -= d; //round
		return checked((int)(r / divide));
		
		//This code produces the same results as API MulDiv. Tested with millions of random and edge values. Faster.
		//The only difference, API does not support int.MinValue.
	}
	//public static int MulDiv(int number, int multiply, int divide) => Api.MulDiv(number, multiply, divide);
	
	/// <summary>
	/// Calculates how many % of <i>whole</i> is <i>part</i>: <c>100L * part / whole</c>.
	/// </summary>
	/// <param name="whole"></param>
	/// <param name="part"></param>
	/// <param name="canRoundUp">Round down or up. If <c>false</c> (default), can only round down.</param>
	/// <exception cref="OverflowException"></exception>
	public static int PercentFromValue(int whole, int part, bool canRoundUp = false)
		=> whole == default ? default : (canRoundUp ? MulDiv(100, part, whole) : checked((int)(100L * part / whole)));
	
	/// <summary>
	/// Calculates how many % of <i>whole</i> is <i>part</i>: <c>100 * part / whole</c>.
	/// </summary>
	public static double PercentFromValue(double whole, double part)
		=> whole == default ? default : (100.0 * part / whole);
	
	/// <summary>
	/// Returns <i>percent</i> % of <i>whole</i>: <c>(long)whole * percent / 100</c>.
	/// </summary>
	/// <param name="whole"></param>
	/// <param name="percent"></param>
	/// <param name="canRoundUp">Use <see cref="MulDiv"/>, which can round down or up. If <c>false</c> (default), can only round down.</param>
	/// <exception cref="OverflowException"></exception>
	public static int PercentToValue(int whole, int percent, bool canRoundUp = false)
		=> canRoundUp ? MulDiv(whole, percent, 100) : checked((int)((long)whole * percent / 100L));
	
	/// <summary>
	/// Returns <i>percent</i> % of <i>whole</i>: <c>whole * percent / 100</c>.
	/// </summary>
	public static double PercentToValue(double whole, double percent)
		=> whole * percent / 100.0;
	
	/// <summary>
	/// If <i>value</i> is divisible by <i>alignment</i>, returns <i>value</i>. Else returns the nearest bigger number that is divisible by <i>alignment</i>.
	/// </summary>
	/// <param name="value">An integer value.</param>
	/// <param name="alignment">Alignment. Must be a power of two (2, 4, 8, 16...).</param>
	/// <remarks>
	/// For example if <i>alignment</i> is 4, returns 4 if <i>value</i> is 1-4, returns 8 if <i>value</i> is 5-8, returns 12 if <i>value</i> is 9-10, and so on.
	/// </remarks>
	/// <example>
	/// <code><![CDATA[
	/// for (int i = 0; i <= 20; i++) print.it(i, Math2.AlignUp(i, 4));
	/// ]]></code>
	/// </example>
	public static int AlignUp(int value, uint alignment) => (int)AlignUp((uint)value, alignment);
	
	/// <inheritdoc cref="AlignUp(int, uint)"/>
	public static uint AlignUp(uint value, uint alignment) => (value + (alignment - 1)) & ~(alignment - 1);
	//shorter: (value + --alignment) & ~alignment. But possibly less optimized. Now (alignment - 1) and ~(alignment - 1) usually are constants.
	
	/// <summary>
	/// Swaps values of two variables: <c>T t = a; a = b; b = t;</c>
	/// </summary>
	public static void Swap<T>(ref T a, ref T b) {
		T t = a; a = b; b = t;
	}
	
	/// <summary>
	/// Swaps two ranges of bits.
	/// </summary>
	/// <param name="value"></param>
	/// <param name="i">Position of first range of bits.</param>
	/// <param name="j">Position of second range of bits.</param>
	/// <param name="n">Number of bits in each range.</param>
	public static int SwapBits(int value, int i, int j, int n) => (int)SwapBits((uint)value, i, j, n);
	
	/// <summary>
	/// Swaps two ranges of bits.
	/// </summary>
	/// <param name="value"></param>
	/// <param name="i">Position of first range of bits.</param>
	/// <param name="j">Position of second range of bits.</param>
	/// <param name="n">Number of bits in each range.</param>
	public static uint SwapBits(uint value, int i, int j, int n) {
		// http://graphics.stanford.edu/~seander/bithacks.html#SwappingBitsXOR
		uint x = ((value >> i) ^ (value >> j)) & ((1U << n) - 1); // XOR temporary
		return value ^ ((x << i) | (x << j));
	}
	
	//rejected. Too simple and does not save any code. Also would need generic, for enum too.
	///// <summary>
	///// Clears <i>oldFlags</i> bits specified in <i>mask</i> and adds <i>newFlags</i> bits specified in <i>mask</i>.
	///// </summary>
	//int SetFlagsMasked(int oldFlags, int newFlags, int mask) => (oldFlags&~mask) | (newFlags&mask);
	
	/// <summary>
	/// Calculates angle degrees from coordinates x and y.
	/// </summary>
	public static double AngleFromXY(int x, int y) => Math.Atan2(y, x) * (180 / Math.PI);
	
	/// <summary>
	/// Calculates distance between two points.
	/// </summary>
	public static double Distance(POINT p1, POINT p2) {
		if (p1.y == p2.y) return Math.Abs(p2.x - p1.x); //horizontal line
		if (p1.x == p2.x) return Math.Abs(p2.y - p1.y); //vertical line
		
		long dx = p2.x - p1.x, dy = p2.y - p1.y;
		return Math.Sqrt(dx * dx + dy * dy);
	}
	
	/// <summary>
	/// Calculates distance between rectangle and point.
	/// </summary>
	/// <returns>If the point is outside, returns the nearest distance, else 0.</returns>
	public static double Distance(RECT r, POINT p) {
		r.Normalize(swap: true);
		if (r.Contains(p)) return 0;
		int x = p.x < r.left ? r.left : (p.x > r.right ? r.right : p.x);
		int y = p.y < r.top ? r.top : (p.y > r.bottom ? r.bottom : p.y);
		return Distance((x, y), p);
	}
}


================================================
FILE: Au/Au.More/MemoryBitmap.cs
================================================
namespace Au.More;

/// <summary>
/// Creates and manages native bitmap handle and memory DC (GDI device context).
/// The bitmap is selected in the DC.
/// </summary>
public class MemoryBitmap : IDisposable {
	IntPtr _dc, _bm, _oldbm;
	bool _disposed;

	/// <summary>
	/// DC handle.
	/// </summary>
	public IntPtr Hdc => _dc;

	/// <summary>
	/// Bitmap handle.
	/// </summary>
	public IntPtr Hbitmap => _bm;

	/// <summary>
	/// Does nothing. Later you can call <see cref="Create"/> or <see cref="Attach"/>.
	/// </summary>
	public MemoryBitmap() { }

	/// <summary>
	/// Calls <see cref="Create"/>.
	/// </summary>
	/// <exception cref="ArgumentException"><i>width</i> or <i>height</i> is less than 1.</exception>
	/// <exception cref="AuException">Failed. Probably there is not enough memory for bitmap of specified size (need <c>with*height*4</c> bytes).</exception>
	public MemoryBitmap(int width, int height) {
		if (width <= 0 || height <= 0) throw new ArgumentException();
		if (!Create(width, height)) throw new AuException("*create memory bitmap of specified size");
	}

	//rejected: not obvious, whether it attaches or copies. Also, attaching is rarely used.
	///// <summary>
	///// Calls <see cref="Attach"/>.
	///// </summary>
	//public MemoryBitmap(IntPtr hBitmap)
	//{
	//	Attach(hBitmap);
	//}

	///
	protected virtual void Dispose(bool disposing) {
		if (_disposed) return;
		_disposed = true;
		Delete();
	}

	/// <summary>
	/// Deletes the bitmap and DC.
	/// </summary>
	public void Dispose() {
		Dispose(true);
		GC.SuppressFinalize(this);
	}

	///
	~MemoryBitmap() => Dispose(false);
	//Calls DeleteDC. MSDN says that ReleaseDC must be called from the same thread. But does not say it about DeleteDC and others.
	//	Tested: DeleteDC returns true in finalizer (other thread).

	/// <summary>
	/// Deletes the bitmap and DC.
	/// </summary>
	public void Delete() {
		if (_dc == default) return;
		if (_bm != default) {
			Api.SelectObject(_dc, _oldbm);
			Api.DeleteObject(_bm);
			_bm = default;
		}
		Api.DeleteDC(_dc);
		_dc = default;
	}

	/// <summary>
	/// Creates new memory DC and bitmap of specified size and selects it into the DC.
	/// </summary>
	/// <returns><c>false</c> if failed. In any case deletes previous bitmap and DC.</returns>
	/// <param name="width">Width, pixels. Must be > 0.</param>
	/// <param name="height">Height, pixels. Must be > 0.</param>
	public bool Create(int width, int height) {
		if (_disposed) throw new ObjectDisposedException(nameof(MemoryBitmap));
		using var dcs = new ScreenDC_();
		Attach(Api.CreateCompatibleBitmap(dcs, width, height));
		return _bm != default;
	}

	/// <summary>
	/// Sets this variable to manage an existing bitmap.
	/// Selects the bitmap into a memory DC.
	/// Deletes previous bitmap and DC.
	/// </summary>
	/// <param name="hBitmap">Native bitmap handle.</param>
	public void Attach(IntPtr hBitmap) {
		if (_disposed) throw new ObjectDisposedException(nameof(MemoryBitmap));
		Delete();
		if (hBitmap != default) {
			_dc = Api.CreateCompatibleDC(default);
			_oldbm = Api.SelectObject(_dc, _bm = hBitmap);
		}
	}

	/// <summary>
	/// Deletes memory DC, clears this variable and returns its bitmap (native bitmap handle).
	/// The returned bitmap is not selected into a DC. Will need to delete it with API <ms>DeleteObject</ms>.
	/// </summary>
	public IntPtr Detach() {
		IntPtr bret = _bm;
		if (_bm != default) {
			Api.SelectObject(_dc, _oldbm);
			Api.DeleteDC(_dc);
			_dc = default; _bm = default;
		}
		return bret;
	}
}


================================================
FILE: Au/Au.More/MemoryUtil.cs
================================================
namespace Au.More;

/// <summary>
/// Allocates memory from native heap of this process using heap API.
/// Also has more functions to work with memory: copy, move, virtual alloc.
/// </summary>
/// <remarks>
/// Uses the common heap of this process, API <ms>GetProcessHeap</ms>.
/// </remarks>
public static unsafe class MemoryUtil {
	static IntPtr _processHeap = Api.GetProcessHeap();
	
	/// <summary>
	/// Allocates new memory block and returns its address.
	/// </summary>
	/// <param name="size">Byte count.</param>
	/// <param name="zeroInit">Set all bytes = 0.</param>
	/// <exception cref="OutOfMemoryException">Failed. Probably <i>size</i> is too big.</exception>
	/// <remarks>
	/// Calls API <ms>HeapAlloc</ms>.
	/// The memory is unmanaged and will not be freed automatically. Always call <see cref="Free"/> when done. Call <see cref="ReAlloc"/> or <see cref="FreeAlloc"/> if need to resize.
	/// </remarks>
	public static byte* Alloc(nint size, bool zeroInit = false)
		=> _ReAllocBytes(null, size, zeroInit);
	
	/// <param name="count">Count of elements of type <c>T</c>.</param>
	/// <inheritdoc cref="Alloc(nint, bool)"/>
	public static T* Alloc<T>(nint count, bool zeroInit = false) where T : unmanaged
		=> (T*)_ReAllocBytes(null, count * sizeof(T), zeroInit);
	
	//Rejected. With the above overload the calling code is easier to read. Not so often used.
	//public static void Alloc<T>(out T* mem, nint count, bool zeroInit = false) where T : unmanaged
	//	=> mem = (T*)_ReAllocBytes(null, count * sizeof(T), zeroInit);
	
	static byte* _ReAllocBytes(void* mem, nint size, bool zeroInit = false) {
		uint flag = zeroInit ? 8u : 0u;
		for (int i = 0; i < 5; i++) {
			if (i > 0) {
				GC.Collect();
				GC.WaitForPendingFinalizers();
				Thread.Sleep(i * 100);
			}
			void* r;
			if (mem == null) r = Api.HeapAlloc(_processHeap, flag, size);
			else r = Api.HeapReAlloc(_processHeap, flag, mem, size);
			if (r != null) return (byte*)r;
		}
		throw new OutOfMemoryException();
		
		//note: don't need GC.AddMemoryPressure.
		//	Native memory usually is used for temporary buffers etc and is soon released eg with try/finally.
		//	Marshal.AllocHGlobal does not do it too.
	}
	
	/// <summary>
	/// Reallocates a memory block to make it bigger or smaller.
	/// </summary>
	/// <param name="mem">Input: old memory address; if <c>null</c>, allocates new memory like <see cref="Alloc{T}"/>. Output: new memory address. Unchanged if exception.</param>
	/// <param name="count">New count of elements of type <c>T</c>.</param>
	/// <param name="zeroInit">When size is growing, set all added bytes = 0.</param>
	/// <exception cref="OutOfMemoryException">Failed. Probably <i>count</i> is too big.</exception>
	/// <remarks>
	/// Calls API <ms>HeapReAlloc</ms> or <ms>HeapAlloc</ms>.
	/// Preserves data in <c>Math.Min(oldCount, newCount)</c> elements of old memory (copies from old memory if need).
	/// The memory is unmanaged and will not be freed automatically. Always call <see cref="Free"/> when done. Call <c>ReAlloc</c> or <see cref="FreeAlloc"/> if need to resize.
	/// </remarks>
	public static void ReAlloc<T>(ref T* mem, nint count, bool zeroInit = false) where T : unmanaged
		=> mem = (T*)_ReAllocBytes(mem, count * sizeof(T), zeroInit);
	
	/// <summary>
	/// Frees a memory block.
	/// Does nothing if <i>mem</i> is <c>null</c>.
	/// </summary>
	/// <remarks>
	/// Calls API <ms>HeapFree</ms>.
	/// </remarks>
	public static void Free(void* mem) {
		if (mem != null) Api.HeapFree(_processHeap, 0, mem);
	}
	
	/// <summary>
	/// Frees a memory block (if not <c>null</c>) and allocates new.
	/// </summary>
	/// <param name="mem">Input: old memory address or <c>null</c>. Output: new memory address; <c>null</c> if exception (it prevents freeing twice).</param>
	/// <param name="count">New count of elements of type <c>T</c>.</param>
	/// <param name="zeroInit">Set all bytes = 0.</param>
	/// <exception cref="OutOfMemoryException">Failed. Probably <i>count</i> is too big.</exception>
	/// <remarks>
	/// At first sets <i>mem</i> = <c>null</c>, to avoid double <see cref="Free"/> if this function throws exception. Then calls <see cref="Free"/> and <see cref="Alloc"/>.
	/// </remarks>
	public static void FreeAlloc<T>(ref T* mem, nint count, bool zeroInit = false) where T : unmanaged {
		var m = mem; mem = null;
		Free(m);
		mem = Alloc<T>(count, zeroInit);
	}
	
	/// <summary>
	/// Allocates new virtual memory block with API <ms>VirtualAlloc</ms> and returns its address: <c>VirtualAlloc(default, size, MEM_COMMIT|MEM_RESERVE, PAGE_READWRITE)</c>.
	/// </summary>
	/// <param name="size">Byte count.</param>
	/// <exception cref="OutOfMemoryException">Failed. Probably <i>size</i> is too big.</exception>
	/// <remarks>
	/// Faster than managed and <see cref="Alloc"/> when memory size is large, more than 1 MB; else slower.
	/// The memory is initialized to zero (all bytes 0).
	/// </remarks>
	public static byte* VirtualAlloc(nint size) {
		for (int i = 0; i < 5; i++) {
			if (i > 0) {
				GC.Collect();
				GC.WaitForPendingFinalizers();
				Thread.Sleep(i * 100);
			}
			var r = (byte*)Api.VirtualAlloc(default, size, Api.MEM_COMMIT | Api.MEM_RESERVE, Api.PAGE_READWRITE);
			if (r != null) return r;
		}
		throw new OutOfMemoryException();
		
		//note: don't need GC.AddMemoryPressure.
		//	Native memory usually is used for temporary buffers etc and is soon released eg with try/finally.
		//	Marshal.AllocHGlobal does not do it too.
	}
	
	/// <summary>
	/// Frees a memory block allocated with <see cref="VirtualAlloc"/>.
	/// Does nothing if <i>mem</i> is <c>null</c>.
	/// </summary>
	public static void VirtualFree(void* mem) {
		if (mem != null) Api.VirtualFree(mem);
	}
	
	/// <summary>
	/// Copies memory with <see cref="Buffer.MemoryCopy"/>.
	/// </summary>
	/// <remarks>
	/// If some part of memory blocks overlaps, this function is much slower than <see cref="Move"/>. Else same speed or slightly faster.
	/// </remarks>
	public static void Copy(void* from, void* to, nint size) => Buffer.MemoryCopy(from, to, size, size);
	//speed Buffer.MemoryCopy vs memcpy, non-overlapped: same if small, slightly faster if big.
	//speed Span.CopyTo vs Buffer.MemoryCopy: same if non-overlapped, slower if overlapped.
	
	/// <summary>
	/// Copies memory with API <ms>memmove</ms>.
	/// </summary>
	/// <remarks>
	/// If some part of memory blocks overlaps, this function is much faster than <see cref="Copy"/>. Else same speed or slightly slower.
	/// </remarks>
	public static void Move(void* from, void* to, nint size) => Api.memmove(to, from, size);
}


================================================
FILE: Au/Au.More/MenuItemInfo.cs
================================================
namespace Au.More
{
	/// <summary>
	/// Gets item id, text and other info of a classic menu.
	/// </summary>
	public class MenuItemInfo
	{
		IntPtr _hm;
		int _id;
		bool _isSystem;
		wnd _ow;

		private MenuItemInfo() { }

		/// <summary>
		/// Gets info of a menu item from point.
		/// </summary>
		/// <returns><c>null</c> if failed, eg the point is not in the menu or the window is hung.</returns>
		/// <param name="pScreen">Point in screen coordinates.</param>
		/// <param name="w">Popup menu window, class name <c>"#32768"</c>.</param>
		/// <param name="msTimeout">Timeout (ms) to use when the window is busy or hung.</param>
		public static MenuItemInfo FromXY(POINT pScreen, wnd w, int msTimeout = 5000) {
			if (!w.SendTimeout(msTimeout, out var hm, Api.MN_GETHMENU)) return null;
			int i = Api.MenuItemFromPoint(default, hm, pScreen); if (i == -1) return null;
			i = Api.GetMenuItemID(hm, i); if (i == -1 || i == 0) return null;
			return new MenuItemInfo { _hm = hm, _id = i };
		}

		/// <summary>
		/// Gets info of a menu item from mouse.
		/// </summary>
		/// <returns><c>null</c> if failed, eg the point is not in a menu or the window is hung.</returns>
		/// <param name="msTimeout">Timeout (ms) to use when the window is busy or hung.</param>
		public static MenuItemInfo FromXY(int msTimeout = 5000) {
			var p = mouse.xy;
			var w = wnd.fromXY(p, WXYFlags.Raw);
			if (!w.ClassNameIs("#32768")) return null;
			return FromXY(p, w, msTimeout);
		}

		/// <summary>
		/// Gets the popup menu handle.
		/// </summary>
		public IntPtr MenuHandle => _hm;

		/// <summary>
		/// Gets menu item id.
		/// </summary>
		public int ItemId => _id;

		/// <summary>
		/// Gets the owner window of the popup menu.
		/// </summary>
		public wnd OwnerWindow => _OwnerSystem().ow;

		/// <summary>
		/// <c>true</c> if it is a system menu, eg when right-clicked the title bar of a window.
		/// </summary>
		public bool IsSystem => _OwnerSystem().sys;

		(wnd ow, bool sys) _OwnerSystem() {
			if (_ow.Is0 && miscInfo.getGUIThreadInfo(out var g)) {
				_ow = g.hwndMenuOwner;
				_isSystem = g.flags.Has(GTIFlags.SYSTEMMENUMODE);
			}
			return (_ow, _isSystem);
		}

		/// <summary>
		/// Gets menu item text.
		/// </summary>
		/// <returns><c>null</c> if failed.</returns>
		/// <param name="removeHotkey">If contains <c>'\t'</c> character, get substring before it.</param>
		/// <param name="removeAmp">Call <see cref="StringUtil.RemoveUnderlineChar"/>.</param>
		public string GetText(bool removeHotkey, bool removeAmp) => GetText(_hm, _id, false, removeHotkey, removeAmp);

		/// <summary>
		/// Gets menu item text.
		/// </summary>
		/// <returns><c>null</c> if failed.</returns>
		/// <param name="menuHandle"></param>
		/// <param name="id"></param>
		/// <param name="byIndex">id is 0-based index. For example you can use it to get text of a submenu-item, because such items usually don't have id.</param>
		/// <param name="removeHotkey">If contains <c>'\t'</c> character, get substring before it.</param>
		/// <param name="removeAmp">Call <see cref="StringUtil.RemoveUnderlineChar"/>.</param>
		[SkipLocalsInit]
		public static unsafe string GetText(IntPtr menuHandle, int id, bool byIndex, bool removeHotkey, bool removeAmp) {
			var mi = new Api.MENUITEMINFO(Api.MIIM_STRING);
			if (!Api.GetMenuItemInfo(menuHandle, id, byIndex, ref mi)) return null; //get required buffer size
			if (mi.cch == 0) return "";
			using FastBuffer<char> b = new(mi.cch + 1);
			mi.cch = b.n;
			mi.dwTypeData = b.p;
			if (!Api.GetMenuItemInfo(menuHandle, id, byIndex, ref mi)) return null;
			var s = b.GetStringFindLength();
			if (removeHotkey) { int i = s.IndexOf('\t'); if (i >= 0) s = s[..i]; }
			if (removeAmp) s = StringUtil.RemoveUnderlineChar(s);
			return s;
		}
	}
}


================================================
FILE: Au/Au.More/MouseCursor.cs
================================================
namespace Au.More;

/// <summary>
/// Helps to load cursors, etc. Contains native cursor handle.
/// </summary>
/// <remarks>
/// To load cursors for winforms can be used <see cref="System.Windows.Forms.Cursor"/> constructors, but they don't support colors, ani cursors and custom size.
/// Don't use this class to load cursors for WPF. Its <c>Cursor</c> class loads cursors correctly.
/// </remarks>
public class MouseCursor {
	IntPtr _handle;
	
	//rejected: use HandleCollector like with icon. Unlikely somebody will use many cursors or even find this class.
	
	/// <summary>
	/// Sets native cursor handle.
	/// The cursor will be destroyed when disposing this variable or when converting to object of other type.
	/// </summary>
	public MouseCursor(IntPtr hcursor) { _handle = hcursor; }
	
	/// <summary>
	/// Destroys native cursor handle.
	/// </summary>
	public void Dispose() {
		if (_handle != default) { Api.DestroyIcon(_handle); _handle = default; }
	}
	
	///
	~MouseCursor() => Dispose();
	
	/// <summary>
	/// Gets native cursor handle.
	/// </summary>
	public IntPtr Handle => _handle;
	
	///// <summary>
	///// Gets native cursor handle.
	///// </summary>
	//public static implicit operator IntPtr(MouseCursor cursor) => cursor._handle;
	
	/// <summary>
	/// Loads cursor from file.
	/// </summary>
	/// <returns><c>default(MouseCursor)</c> if failed.</returns>
	/// <param name="file"><c>.cur</c> or <c>.ani</c> file. If not full path, uses <see cref="folders.ThisAppImages"/>.</param>
	/// <param name="size">Width and height. If 0, uses system default size, which depends on DPI.</param>
	public static MouseCursor Load(string file, int size = 0) {
		file = pathname.normalize(file, folders.ThisAppImages);
		if (file == null) return null;
		uint fl = Api.LR_LOADFROMFILE; if (size == 0) fl |= Api.LR_DEFAULTSIZE;
		return new MouseCursor(Api.LoadImage(default, file, Api.IMAGE_CURSOR, size, size, fl));
	}
	
	/// <summary>
	/// Creates cursor from cursor file data in memory, for example from a managed resource.
	/// </summary>
	/// <returns><c>default(MouseCursor)</c> if failed.</returns>
	/// <param name="cursorData">Data of <c>.cur</c> or <c>.ani</c> file.</param>
	/// <param name="size">Width and height. If 0, uses system default size, which depends on DPI.</param>
	/// <remarks>
	/// This function creates/deletes a temporary file, because there is no good API to load cursor from memory.
	/// </remarks>
	public static MouseCursor Load(byte[] cursorData, int size = 0) {
		using var tf = new TempFile();
		File.WriteAllBytes(tf, cursorData);
		return Load(tf, size);
		
		//If want to avoid temp file, can use:
		//	1. CreateIconFromResourceEx.
		//		But quite much unsafe code (at first need to find cursor offset (of size) and set hotspot), less reliable (may fail for some .ani files), in some cases works not as well (may get wrong-size cursor).
		//		The code moved to the Unused project.
		//	2. CreateIconIndirect. Not tested. No ani. Need to find cursor offset (of size).
		//WPF Cursor ctor uses temp file too.
	}
	
	/// <summary>
	/// Creates <see cref="System.Windows.Forms.Cursor"/> object that shares native cursor handle with this object.
	/// </summary>
	/// <returns><c>null</c> if <see cref="Handle"/> is <c>default(IntPtr)</c>.</returns>
	public System.Windows.Forms.Cursor ToGdipCursor() {
		if (_handle == default) return null;
		var R = new System.Windows.Forms.Cursor(_handle);
		s_cwt.Add(R, this);
		return R;
	}
	static readonly ConditionalWeakTable<System.Windows.Forms.Cursor, MouseCursor> s_cwt = new();
	
	//rejected. Don't need. WPF can load from file or stream. Loads correctly.
	///// <summary>
	///// Creates WPF <c>Cursor</c> object from this native cursor.
	///// </summary>
	///// <returns><c>null</c> if <c>Handle</c> is <c>default(IntPtr)</c>.</returns>
	///// <param name="destroyCursor">If <c>true</c> (default), the returned variable owns the unmanaged cursor and destroys it when disposing. If <c>false</c>, the returned variable just uses the cursor handle and will not destroy; later will need to dispose this variable.</param>
	//public System.Windows.Input.Cursor ToWpfCursor(bool destroyCursor = true) {
	//	if (_handle == default) return null;
	//	var R = System.Windows.Interop.CursorInteropHelper.Create(new _CursorHandle(_handle, destroyCursor));
	//	if (destroyCursor) _handle = default;
	//	return R;
	//}
	
	//class _CursorHandle : SafeHandleZeroOrMinusOneIsInvalid
	//{
	//	public _CursorHandle(IntPtr handle, bool ownsHandle) : base(ownsHandle) { base.handle = handle; }
	
	//	protected override bool ReleaseHandle() => Api.DestroyCursor(handle);
	//}
	
	/// <summary>
	/// Calculates 64-bit FNV1 hash of cursor's mask bitmap.
	/// </summary>
	/// <returns>0 if failed.</returns>
	public static unsafe long Hash(IntPtr hCursor) {
		using Api.ICONINFO ii = new(hCursor);
		var hb = Api.CopyImage(ii.hbmMask, Api.IMAGE_BITMAP, 0, 0, Api.LR_COPYDELETEORG | Api.LR_CREATEDIBSECTION);
		long R = 0; Api.BITMAP b;
		if (0 != Api.GetObject(hb, sizeof(Api.BITMAP), &b) && b.bmBits != default)
			R = More.Hash.Fnv1Long((byte*)b.bmBits, b.bmHeight * b.bmWidthBytes);
		return R;
	}
	
	///// <summary>
	///// Calculates 64-bit FNV1 hash of cursor's mask bitmap.
	///// </summary>
	///// <returns>0 if failed.</returns>
	//public unsafe long Hash() => Hash(_handle);
	
	/// <summary>
	/// Gets current global mouse cursor.
	/// </summary>
	/// <returns><c>false</c> if cursor is hidden.</returns>
	/// <param name="cursor">Receives native handle. Don't destroy.</param>
	public static bool GetCurrentVisibleCursor(out IntPtr cursor) {
		Api.CURSORINFO ci = default; ci.cbSize = Api.SizeOf(ci);
		if (Api.GetCursorInfo(ref ci) && ci.hCursor != default && 0 != (ci.flags & Api.CURSOR_SHOWING)) { cursor = ci.hCursor; return true; }
		cursor = default; return false;
	}
	
	/// <summary>
	/// Workaround for brief "wait" cursor when mouse enters a window of current thread first time.
	/// Reason: default thread's cursor is "wait". OS shows it before the first <c>WM_SETCURSOR</c> sets correct cursor.
	/// Call eg on <c>WM_CREATE</c>.
	/// </summary>
	internal static void SetArrowCursor_() {
		var h = Api.LoadCursor(default, MCursor.Arrow);
		if (Api.GetCursor() != h) Api.SetCursor(h);
	}
}


================================================
FILE: Au/Au.More/RecordingUtil.cs
================================================
namespace Au.More
{
	/// <summary>
	/// Functions for keyboard/mouse/etc recorder tools.
	/// </summary>
	public static partial class RecordingUtil
	{
		/// <summary>
		/// Converts multiple recorded mouse movements to string for <see cref="mouse.moveBy(string, double)"/>.
		/// </summary>
		/// <param name="recorded">
		/// List of x y distances from previous.
		/// The first distance is from mouse position before the first movement; at run time it will be distance from <see cref="mouse.lastXY"/>.
		/// To create <c>uint</c> value from distance <i>dx</i> <i>dy</i> use <see cref="Math2.MakeLparam"/> and cast to <c>uint</c>.
		/// </param>
		/// <param name="withSleepTimes">
		/// <i>recorded</i> also contains sleep times (milliseconds) alternating with distances.
		/// It must start with a sleep time. Example: <c>{time1, dist1, time2, dist2}</c>. Another example: <c>{time1, dist1, time2, dist2, time3}</c>. This is invalid: <c>{dist1, time1, dist2, time2}</c>.
		/// </param>
		public static string MouseToString(IEnumerable<uint> recorded, bool withSleepTimes) {
			var a = new List<byte>();

			byte flags = 0;
			if (withSleepTimes) flags |= 1;
			a.Add(flags);

			int pdx = 0, pdy = 0;
			bool isSleep = withSleepTimes;
			foreach (var u in recorded) {
				int v, nbytes = 4;
				if (isSleep) {
					v = (int)Math.Min(u, 0x3fffffff);
					if (v > 3) v--; //_SendMove usually takes 0.5-1.5 ms
					if (v <= 1 << 6) nbytes = 1;
					else if (v <= 1 << 14) nbytes = 2;
					else if (v <= 1 << 22) nbytes = 3;

					//print.it($"nbytes={nbytes}    sleep={v}");
					//never mind: ~90% is 7. Removing it would make almost 2 times smaller string. But need much more code. Or compress (see comment below).
				} else {
					//info: to make more compact, we write not distances (dx dy) but distance changes (x y).
					int dx = Math2.LoShort((nint)u), x = dx - pdx; pdx = dx;
					int dy = Math2.HiShort((nint)u), y = dy - pdy; pdy = dy;

					if (x >= -4 && x < 4 && y >= -4 && y < 4) nbytes = 1; //3+3+2=8 bits, 90%
					else if (x >= -64 && x < 64 && y >= -64 && y < 64) nbytes = 2; //7+7+2=16 bits, ~10%
					else if (x >= -1024 && x < 1024 && y >= -1024 && y < 1024) nbytes = 3; //11+11+2=24 bits, ~0%

					int shift = nbytes * 4 - 1, mask = (1 << shift) - 1;
					v = (x & mask) | ((y & mask) << shift);

					//print.it($"dx={dx} dy={dy}    x={x} y={y}    nbytes={nbytes}    v=0x{v:X}");
				}
				v <<= 2; v |= (nbytes - 1);
				for (; nbytes != 0; nbytes--, v >>= 8) a.Add((byte)v);
				isSleep ^= withSleepTimes;
			}

			//rejected: by default compresses to ~80% (20% smaller). When withSleepTimes, to ~50%, but never mind, rarely used.
			//print.it(a.Count, Convert2.Compress(a.ToArray()).Length);

			return Convert.ToBase64String(a.ToArray());
		}
	}
}


================================================
FILE: Au/Au.More/ResourceUtil.cs
================================================
using System.Resources;
using System.Windows.Media.Imaging;
using System.Windows.Markup;
using System.Windows;
using System.Windows.Controls;

namespace Au.More;

/// <summary>
/// Gets managed resources from a .NET assembly.
/// </summary>
/// <remarks>
/// Internally uses <see cref="ResourceManager"/>. Uses <see cref="CultureInfo.InvariantCulture"/>.
///
/// Loads resources from managed resource <c>"AssemblyName.g.resources"</c>. To add such resource files in Visual Studio, set file build action = <c>Resource</c>. Don't use <c>.resx</c> files and the <b>Resources</b> page in <b>Project Properties</b>.
///
/// By default loads resources from the app entry assembly. In script with role <c>miniProgram</c> - from the script's assembly. To specify another loaded assembly, use prefix like <c>"&lt;AssemblyName&gt;"</c> or <c>"*&lt;AssemblyName&gt;"</c>.
///
/// The resource name argument can optionally start with <c>"resource:"</c>.
///
/// Does not use caching. Creates new object even when loading the resource not the first time.
/// </remarks>
public static class ResourceUtil {
	/// <summary>
	/// Gets resource of any type.
	/// </summary>
	/// <param name="name">Resource name, like <c>"file.txt"</c> or <c>"sub/file.txt"</c>. More info: <see cref="ResourceUtil"/>.</param>
	/// <exception cref="FileNotFoundException">Cannot find assembly or resource.</exception>
	/// <exception cref="InvalidOperationException">The resource is of different type. This function does not convert.</exception>
	/// <exception cref="Exception">Other exceptions that may be thrown by used .NET functions.</exception>
	public static T Get<T>(string name) {
		var o = _GetObject(ref name);
		if (o is T r) return r;
		throw new InvalidOperationException($"Resource '{name}' is not {typeof(T).Name}; it is {o.GetType().Name}.");
	}
	
	/// <summary>
	/// Gets stream.
	/// </summary>
	/// <param name="name">Resource name, like <c>"file.png"</c> or <c>"sub/file.png"</c>. More info: <see cref="ResourceUtil"/>.</param>
	/// <exception cref="FileNotFoundException">Cannot find assembly or resource.</exception>
	/// <exception cref="InvalidOperationException">The resource type is not stream.</exception>
	/// <exception cref="Exception">Other exceptions that may be thrown by used .NET functions.</exception>
	/// <remarks>
	/// Don't need to dispose the stream.
	/// </remarks>
	public static UnmanagedMemoryStream GetStream(string name) {
		//if (name.Starts("pack:")) return _Pack(name); //rejected
		return Get<UnmanagedMemoryStream>(name);
	}
	
	/// <summary>
	/// Gets string.
	/// </summary>
	/// <param name="name">Resource name, like <c>"myString"</c> or <c>"file.txt"</c> or <c>"sub/file.txt"</c>. More info: <see cref="ResourceUtil"/>.</param>
	/// <exception cref="FileNotFoundException">Cannot find assembly or resource.</exception>
	/// <exception cref="InvalidOperationException">Unsupported resource type.</exception>
	/// <exception cref="Exception">Other exceptions that may be thrown by used .NET functions.</exception>
	/// <remarks>
	/// Supports resources of type <c>string</c>, <c>byte[]</c> (UTF-8), stream (UTF-8).
	/// </remarks>
	public static string GetString(string name) {
		var o = _GetObject(ref name);
		switch (o) {
		case string s: return s;
		case byte[] a: return Encoding.UTF8.GetString(a);
		case UnmanagedMemoryStream m: return new StreamReader(m, Encoding.UTF8).ReadToEnd();
		}
		throw new InvalidOperationException($"Resource '{name}' is not string, byte[] or stream; it is {o.GetType().Name}.");
	}
	
	internal static string TryGetString_(string name) => _TryGetObject(ref name) as string;
	
	/// <summary>
	/// Gets <c>byte[]</c>.
	/// </summary>
	/// <param name="name">Resource name, like <c>"file.txt"</c> or <c>"sub/file.txt"</c>. More info: <see cref="ResourceUtil"/>.</param>
	/// <exception cref="FileNotFoundException">Cannot find assembly or resource.</exception>
	/// <exception cref="InvalidOperationException">Unsupported resource type.</exception>
	/// <exception cref="Exception">Other exceptions that may be thrown by used .NET functions.</exception>
	/// <remarks>
	/// Supports resources of type <c>byte[]</c>, <c>string</c> (gets UTF-8 bytes), stream.
	/// </remarks>
	public static byte[] GetBytes(string name) {
		var o = _GetObject(ref name);
		switch (o) {
		case byte[] a: return a;
		case string s: return Encoding.UTF8.GetBytes(s);
		case UnmanagedMemoryStream m:
			var b = new byte[m.Length];
			m.Read(b);
			return b;
		}
		throw new InvalidOperationException($"Resource '{name}' is not byte[], string or stream; it is {o.GetType().Name}.");
	}
	
	/// <summary>
	/// Gets GDI+ image.
	/// </summary>
	/// <param name="name">Resource name, like <c>"file.png"</c> or <c>"sub/file.png"</c>. More info: <see cref="ResourceUtil"/>.</param>
	/// <exception cref="FileNotFoundException">Cannot find assembly or resource.</exception>
	/// <exception cref="InvalidOperationException">The resource type is not stream.</exception>
	/// <exception cref="Exception">Other exceptions that may be thrown by used .NET functions.</exception>
	public static System.Drawing.Bitmap GetGdipBitmap(string name) {
		return new System.Drawing.Bitmap(GetStream(name));
	}
	
	//rejected. Too simple and rare.
	///// <summary>
	///// Gets GDI+ icon.
	///// </summary>
	///// <param name="name">Resource name, like <c>"file.ico"</c> or <c>"sub/file.ico"</c>. More info: <see cref="ResourceUtil"/>.</param>
	///// <exception cref="FileNotFoundException">Cannot find assembly or resource.</exception>
	///// <exception cref="InvalidOperationException">The resource type is not stream.</exception>
	///// <exception cref="Exception">Other exceptions that may be thrown by used .NET functions.</exception>
	//public static System.Drawing.Icon GetGdipIcon(string name) {
	//	return new System.Drawing.Icon(GetStream(name));
	//}
	
	/// <summary>
	/// Gets WPF image or icon that can be used as <c>ImageSource</c>.
	/// </summary>
	/// <param name="name">Resource name, like <c>"file.png"</c> or <c>"sub/file.png"</c>. More info: <see cref="ResourceUtil"/>.</param>
	/// <exception cref="FileNotFoundException">Cannot find assembly or resource.</exception>
	/// <exception cref="InvalidOperationException">The resource type is not stream.</exception>
	/// <exception cref="Exception">Other exceptions that may be thrown by used .NET functions.</exception>
	public static BitmapFrame GetWpfImage(string name) {
		return BitmapFrame.Create(GetStream(name));
	}
	
	/// <summary>
	/// Gets WPF object from XAML resource, for example image.
	/// </summary>
	/// <returns>An object of type of the XAML root object, for example <see cref="Viewbox"/> if <see cref="Image"/>.</returns>
	/// <param name="name">Resource name, like <c>"file.xaml"</c> or <c>"sub/file.xaml"</c>. More info: <see cref="ResourceUtil"/>.</param>
	/// <exception cref="FileNotFoundException">Cannot find assembly or resource.</exception>
	/// <exception cref="InvalidOperationException">The resource type is not stream.</exception>
	/// <exception cref="Exception">Other exceptions that may be thrown by used .NET functions.</exception>
	public static object GetXamlObject(string name) {
		return XamlReader.Load(GetStream(name));
	}
	
	/// <summary>
	/// Gets WPF image element from XAML or other image resource.
	/// </summary>
	/// <param name="name">Resource name, like <c>"file.png"</c> or <c>"sub/file.xaml"</c>. More info: <see cref="ResourceUtil"/>.</param>
	/// <exception cref="FileNotFoundException">Cannot find assembly or resource.</exception>
	/// <exception cref="InvalidOperationException">The resource type is not stream.</exception>
	/// <exception cref="Exception">Other exceptions that may be thrown by used .NET functions.</exception>
	/// <remarks>
	/// If <i>name</i> ends with <c>".xaml"</c> (case-insensitive), calls <see cref="GetXamlObject"/>. Else returns <see cref="Image"/> with <c>Source</c> = <see cref="GetWpfImage"/>.
	/// </remarks>
	public static FrameworkElement GetWpfImageElement(string name) {
		if (name.Ends(".xaml", true)) return (FrameworkElement)GetXamlObject(name);
		return new Image { Source = GetWpfImage(name) };
	}
	
	//probably not useful
	///// <summary>
	///// Gets WPF image as <c>BitmapImage</c>.
	///// </summary>
	///// <param name="name">Resource name, like <c>"file.png"</c> or <c>"sub/file.png"</c>. More info: <see cref="ResourceUtil"/>.</param>
	///// <exception cref="FileNotFoundException">Cannot find assembly or resource.</exception>
	///// <exception cref="InvalidOperationException">The resource type is not stream.</exception>
	///// <exception cref="Exception">Other exceptions that may be thrown by used .NET functions.</exception>
	//public static BitmapImage GetWpfBitmapImage(string name) {
	//	var st = GetStream(name);
	//	var bi = new BitmapImage();
	//	bi.BeginInit();
	//	bi.CacheOption = BitmapCacheOption.OnLoad;
	//	bi.StreamSource = st;
	//	bi.EndInit();
	//	return bi;
	//}
	
	/// <summary>
	/// Returns <c>true</c> if string starts with <c>"resource:"</c> or <c>"resources/"</c>.
	/// </summary>
	public static bool HasResourcePrefix(string s) {
		return s.Starts("resource:") || s.Starts("resources/")/* || s.Starts("pack:")*/;
	}
	
	//[MethodImpl(MethodImplOptions.NoInlining)] //avoid loading WPF dlls if no "pack:"
	//static UnmanagedMemoryStream _Pack(string name) {
	//	if (script.role == SRole.MiniProgram && !name.Contains(";component/") && name.Starts("pack://application:,,,/")) name = name.Insert(23, script.name + ";component/");
	//	if (Application.Current == null) new Application();
	//	return Application.GetResourceStream(new Uri(name)).Stream as UnmanagedMemoryStream;
	//}
	
	static object _GetObject(ref string name)
		=> _TryGetObject(ref name) ?? throw new FileNotFoundException($"Cannot find resource '{name}'.");
	
	static object _TryGetObject(ref string name) {
		var rs = _RS(ref name, true);
		if (rs == null) return null;
		var r = rs.GetObject(name);
		if (r == null) r = rs.GetObject(name.Lower());
		return r;
	}
	
	static ResourceSet _RS(ref string name, bool noThrow = false) {
		if (name.Starts("resource:")) name = name[9..];
		string asmName = "";
		if (name is ['<', ..] or ['*', '<', ..]) {
			int i = name[0] == '*' ? 2 : 1;
			int j = name.IndexOf('>', i);
			if (j >= i) {
				asmName = name[i..j];
				name = name[++j..];
			}
		}
		
		lock (s_dict) {
			if (!s_dict.TryGetValue(asmName, out var rs)) {
				var asm = asmName.Length == 0 ? AssemblyUtil_.GetEntryAssembly() : _FindAssembly(asmName);
				if (asm == null) return noThrow ? null : throw new FileNotFoundException($"Cannot find loaded resource assembly '{asmName}'.");
				var rm = new ResourceManager(asm.GetName().Name + ".g", asm);
				rs = rm.GetResourceSet(CultureInfo.InvariantCulture, true, false);
				if (rs == null) return noThrow ? null : throw new FileNotFoundException($"Cannot find resources in assembly '{asmName}'.");
				s_dict.Add(asmName, rs);
			}
			return rs;
		}
	}
	
	static readonly Dictionary<string, ResourceSet> s_dict = new(StringComparer.OrdinalIgnoreCase);
	
	static Assembly _FindAssembly(string name) {
		foreach (var v in AppDomain.CurrentDomain.GetAssemblies()) if (v.GetName().Name.Eqi(name)) return v;
		return null;
	}
}


================================================
FILE: Au/Au.More/SecurityUtil.cs
================================================
namespace Au.More
{
	/// <summary>
	/// Security-related functions, such as enabling privileges.
	/// </summary>
	public static class SecurityUtil
	{
		/// <summary>
		/// Enables or disables a privilege for this process.
		/// </summary>
		/// <returns><c>false</c> if failed. Supports <see cref="lastError"/>.</returns>
		public static bool SetPrivilege(string privilegeName, bool enable, string computer = null) {
			bool ok = false;
			var p = new Api.TOKEN_PRIVILEGES { PrivilegeCount = 1, Privileges = new Api.LUID_AND_ATTRIBUTES { Attributes = enable ? 2u : 0 } }; //SE_PRIVILEGE_ENABLED
			if (Api.LookupPrivilegeValue(computer, privilegeName, out p.Privileges.Luid)) {
				Api.OpenProcessToken(Api.GetCurrentProcess(), Api.TOKEN_ADJUST_PRIVILEGES, out Handle_ hToken);
				Api.AdjustTokenPrivileges(hToken, false, p, 0, null, default);
				ok = 0 == lastError.code;
				hToken.Dispose();
			}
			return ok;
		}
	}
}


================================================
FILE: Au/Au.More/WaitableTimer.cs
================================================
namespace Au.More;

/// <summary>
/// Wraps a waitable timer handle.
/// </summary>
/// <remarks>
/// More info: API <ms>CreateWaitableTimer</ms>.
/// </remarks>
public class WaitableTimer : WaitHandle {
	WaitableTimer(IntPtr h) => SafeWaitHandle = new Microsoft.Win32.SafeHandles.SafeWaitHandle(h, true);

	/// <summary>
	/// Calls API <ms>CreateWaitableTimer</ms> and creates a <see cref="WaitableTimer"/> object that wraps the timer handle.
	/// </summary>
	/// <param name="manualReset"></param>
	/// <param name="timerName">Timer name. If a timer with this name already exists, opens it if possible. If <c>null</c>, creates unnamed timer.</param>
	/// <exception cref="AuException">Failed. For example, a non-timer kernel object with this name already exists.</exception>
	public static WaitableTimer Create(bool manualReset = false, string timerName = null) {
		var h = Api.CreateWaitableTimer(Api.SECURITY_ATTRIBUTES.ForLowIL, manualReset, timerName);
		if (h.Is0) throw new AuException(0, "*create timer");
		return new WaitableTimer(h);
	}

	/// <summary>
	/// Calls API <ms>OpenWaitableTimer</ms> and creates a <see cref="WaitableTimer"/> object that wraps the timer handle.
	/// </summary>
	/// <param name="timerName">Timer name. Fails if it does not exist; to open-or-create use <see cref="Create"/>.</param>
	/// <param name="access">See <ms>Synchronization Object Security and Access Rights</ms>. The default value <c>TIMER_MODIFY_STATE|SYNCHRONIZE</c> allows to set and wait.</param>
	/// <param name="inheritHandle"></param>
	/// <param name="noException">If fails, return <c>null</c>, don't throw exception. Supports <see cref="lastError"/>.</param>
	/// <exception cref="AuException">Failed. For example, the timer does not exist.</exception>
	public static WaitableTimer Open(string timerName, uint access = Api.TIMER_MODIFY_STATE | Api.SYNCHRONIZE, bool inheritHandle = false, bool noException = false) {
		var h = Api.OpenWaitableTimer(access, inheritHandle, timerName);
		if (h.Is0) {
			var e = lastError.code;
			if (noException) {
				lastError.code = e;
				return null;
			}
			throw new AuException(e, "*open timer");
		}
		return new WaitableTimer(h);
	}

	/// <summary>
	/// Calls API <ms>SetWaitableTimer</ms>.
	/// </summary>
	/// <returns><c>false</c> if failed. Supports <see cref="lastError"/>.</returns>
	/// <param name="dueTime">
	/// The time after which the state of the timer is to be set to signaled. It is relative time (from now).
	/// If positive, in milliseconds. If negative, in 100 nanosecond intervals (microseconds <c>*</c> 10), see <ms>FILETIME</ms>.
	/// Also can be 0, to set minimal time.</param>
	/// <param name="period">The period of the timer, in milliseconds. If 0, the timer is signaled once. If greater than 0, the timer is periodic.</param>
	/// <exception cref="OverflowException"><c>dueTime*10000</c> is greater than <see cref="long.MaxValue"/>.</exception>
	public bool Set(long dueTime, int period = 0) {
		if (dueTime > 0) dueTime = -checked(dueTime * 10000);
		return Api.SetWaitableTimer(this.SafeWaitHandle.DangerousGetHandle(), ref dueTime, period, default, default, false);
	}

	/// <summary>
	/// Calls API <ms>SetWaitableTimer</ms>.
	/// </summary>
	/// <returns><c>false</c> if failed. Supports <see cref="lastError"/>.</returns>
	/// <param name="dueTime">The UTC date/time at which the state of the timer is to be set to signaled.</param>
	/// <param name="period">The period of the timer, in milliseconds. If 0, the timer is signaled once. If greater than 0, the timer is periodic.</param>
	public bool SetAbsolute(DateTime dueTime, int period = 0) {
		var t = dueTime.ToFileTimeUtc();
		return Api.SetWaitableTimer(this.SafeWaitHandle.DangerousGetHandle(), ref t, period, default, default, false);
	}
}


================================================
FILE: Au/Au.More/WinEventHook.cs
================================================
namespace Au.More {
	/// <summary>
	/// Helps with UI element event hooks. See API <ms>SetWinEventHook</ms>.
	/// </summary>
	/// <remarks>
	/// The thread that uses hooks must process Windows messages. For example have a window/dialog/messagebox, or use a "wait-for" function that dispatches messages or has such option (see <see cref="Seconds.DoEvents"/>).
	/// 
	/// <note type="important">The variable should be disposed when don't need, or at least unhooked, either explicitly (call <see cref="Dispose"/> or <see cref="Unhook"/> in same thread) or with <c>using</c>. Can do it in hook procedure.</note>
	/// </remarks>
	/// <example>
	/// <code><![CDATA[
	/// bool stop = false;
	/// using var hook = new WinEventHook(EEvent.SYSTEM_FOREGROUND, 0, x => {
	/// 	print.it(x.event_, x.w);
	/// 	var e = x.GetElm();
	/// 	print.it(e);
	/// 	if(x.w.ClassNameIs("Shell_TrayWnd")) stop = true;
	/// });
	/// dialog.show("hook");
	/// //or
	/// //wait.doEventsUntil(-10, () => stop); //wait max 10 s for activated taskbar
	/// //print.it("the end");
	/// ]]></code>
	/// </example>
	[DebuggerStepThrough]
	public sealed class WinEventHook : IDisposable {
		IntPtr[] _a;
		Api.WINEVENTPROC _proc1; //our intermediate hook proc that calls _proc2
		Action<HookData.WinEvent> _proc2; //caller's hook proc
		[ThreadStatic] static List<WinEventHook> t_antiGC;
		
		/// <summary>
		/// Sets a hook for an event or a range of events.
		/// </summary>
		/// <param name="eventMin">The lowest event constant value in the range of events. Can be <see cref="EEvent.MIN"/> to indicate the lowest possible event value. Events reference: <ms>SetWinEventHook</ms>. Value 0 is ignored.</param>
		/// <param name="eventMax">The highest event constant value in the range of events. Can be <see cref="EEvent.MAX"/> to indicate the highest possible event value. If 0, uses <i>eventMin</i>.</param>
		/// <param name="hookProc">The hook procedure (function that handles hook events).</param>
		/// <param name="idProcess">The id of the process from which the hook function receives events. If 0 - all processes on the current desktop.</param>
		/// <param name="idThread">The native id of the thread from which the hook function receives events. If 0 - all threads.</param>
		/// <param name="flags"></param>
		/// <exception cref="AuException">Failed.</exception>
		/// <example>See <see cref="WinEventHook"/>.</example>
		public WinEventHook(EEvent eventMin, EEvent eventMax, Action<HookData.WinEvent> hookProc, int idProcess = 0, int idThread = 0, EHookFlags flags = 0) {
			Not_.Null(hookProc);
			_proc1 = _HookProc;
			Hook(eventMin, eventMax, idProcess, idThread, flags);
			_proc2 = hookProc;
			(t_antiGC ??= new()).Add(this);
		}
		
		/// <summary>
		/// Sets multiple hooks.
		/// </summary>
		/// <param name="events">Events. Reference: API <ms>SetWinEventHook</ms>. Elements with value 0 are ignored.</param>
		/// <inheritdoc cref="WinEventHook(EEvent, EEvent, Action{HookData.WinEvent}, int, int, EHookFlags)"/>
		public WinEventHook(EEvent[] events, Action<HookData.WinEvent> hookProc, int idProcess = 0, int idThread = 0, EHookFlags flags = 0) {
			Not_.Null(hookProc);
			_proc1 = _HookProc;
			Hook(events, idProcess, idThread, flags);
			_proc2 = hookProc;
			(t_antiGC ??= new()).Add(this);
		}
		
		/// <exception cref="InvalidOperationException">Hooks are already set and <see cref="Unhook"/> not called.</exception>
		/// <inheritdoc cref="WinEventHook(EEvent, EEvent, Action{HookData.WinEvent}, int, int, EHookFlags)"/>
		public void Hook(EEvent eventMin, EEvent eventMax = 0, int idProcess = 0, int idThread = 0, EHookFlags flags = 0) {
			_Throw1();
			_a = new IntPtr[1];
			_SetHook(0, eventMin, eventMax, idProcess, idThread, flags);
		}
		
		/// <exception cref="InvalidOperationException">Hooks are already set and <see cref="Unhook"/> not called.</exception>
		/// <inheritdoc cref="WinEventHook(EEvent[], Action{HookData.WinEvent}, int, int, EHookFlags)"/>
		public void Hook(EEvent[] events, int idProcess = 0, int idThread = 0, EHookFlags flags = 0) {
			_Throw1();
			_a = new IntPtr[events.Length];
			for (int i = 0; i < events.Length; i++) _SetHook(i, events[i], 0, idProcess, idThread, flags);
		}
		
		void _SetHook(int i, EEvent eMin, EEvent eMax, int idProcess, int idThread, EHookFlags flags) {
			if (eMin == 0) return;
			if (eMax == 0) eMax = eMin;
			var hh = Api.SetWinEventHook(eMin, eMax, default, _proc1, idProcess, idThread, flags);
			if (hh == default) {
				var ec = lastError.code;
				Unhook();
				throw new AuException(ec, "*set hook for " + eMin.ToString());
			}
			_a[i] = hh;
		}
		
		void _Throw1() {
			if (_a != null) throw new InvalidOperationException();
			if (_proc1 == null) throw new ObjectDisposedException(nameof(WinEventHook));
		}
		
		/// <summary>
		/// Adds a hook for an event or a range of events.
		/// </summary>
		/// <returns>An <c>int</c> value greater than 0 that can be used with <see cref="Remove"/>.</returns>
		/// <remarks>
		/// Parameters are the same as of the constructor, but values can be different.
		/// 
		/// This function together with <see cref="Remove"/> can be used to temporarily add/remove one or more hooks while using the same <see cref="WinEventHook"/> variable and hook procedure. Don't need to call <see cref="Unhook"/> before.
		/// </remarks>
		/// <inheritdoc cref="WinEventHook(EEvent, EEvent, Action{HookData.WinEvent}, int, int, EHookFlags)"/>
		public int Add(EEvent eventMin, EEvent eventMax = 0, int idProcess = 0, int idThread = 0, EHookFlags flags = 0) {
			if (_proc1 == null) throw new ObjectDisposedException(nameof(WinEventHook));
			int i = 0;
			if (_a == null) {
				_a = new IntPtr[1];
			} else {
				for (; i < _a.Length; i++) if (_a[i] == default) goto g1;
				Array.Resize(ref _a, i + 1);
			}
			g1:
			_SetHook(i, eventMin, eventMax, idProcess, idThread, flags);
			return i + 1;
		}
		
		/// <summary>
		/// Removes a hook added by <see cref="Add"/>.
		/// </summary>
		/// <param name="addedId">A return value of <see cref="Add"/>.</param>
		/// <exception cref="ArgumentException"></exception>
		public void Remove(int addedId) {
			addedId--;
			if (_a == null || (uint)addedId >= _a.Length || _a[addedId] == default) throw new ArgumentException();
			if (!Api.UnhookWinEvent(_a[addedId])) print.warning("Failed to unhook WinEventHook.");
			_a[addedId] = default;
		}
		
		///// <summary>
		///// True if hooks are set.
		///// </summary>
		//public bool Installed => _a != null;
		
		/// <summary>
		/// Removes all hooks.
		/// </summary>
		/// <remarks>
		/// Does nothing if already removed or wasn't set.
		/// Must be called from the same thread that sets the hook.
		/// </remarks>
		public void Unhook() {
			if (_a != null) {
				foreach (var hh in _a) {
					if (hh == default) continue;
					if (!Api.UnhookWinEvent(hh)) print.warning("WinEventHook.Unhook() failed.");
				}
				_a = null;
			}
		}
		
		/// <summary>
		/// Calls <see cref="Unhook"/>.
		/// </summary>
		public void Dispose() {
			Unhook();
			_proc1 = null;
			t_antiGC.Remove(this);
			GC.SuppressFinalize(this);
		}
		
		/// <summary>
		/// Prints a warning if the variable is not disposed. Cannot dispose in finalizer.
		/// </summary>
		~WinEventHook() {
			//MSDN: UnhookWinEvent fails if called from a thread different from the call that corresponds to SetWinEventHook.
			if (_a != null) print.warning("Non-disposed WinEventHook variable.");
		}
		
		void _HookProc(IntPtr hHook, EEvent ev, wnd w, EObjid idObject, int idChild, int thread, int time) {
			try {
				_proc2(new HookData.WinEvent(this, ev, w, idObject, idChild, thread, time));
			}
			catch (Exception ex) { WindowsHook.OnException_(ex); }
		}
	}
}

namespace Au.Types {
	public static partial class HookData {
		/// <summary>
		/// Hook data for the hook procedure set by <see cref="WinEventHook"/>.
		/// More info: API <ms>WinEventProc</ms>.
		/// </summary>
		public unsafe struct WinEvent {
			/// <summary>The caller object of your hook procedure. For example can be used to unhook.</summary>
			public readonly WinEventHook hook;
			
			/// <summary>API <ms>WinEventProc</ms></summary>
			public readonly EEvent event_;
			
			/// <summary>API <ms>WinEventProc</ms></summary>
			public readonly wnd w;
			
			/// <summary>API <ms>WinEventProc</ms></summary>
			public readonly EObjid idObject;
			
			/// <summary>API <ms>WinEventProc</ms></summary>
			public readonly int idChild;
			
			/// <summary>API <ms>WinEventProc</ms></summary>
			public readonly int thread;
			
			/// <summary>API <ms>WinEventProc</ms></summary>
			public readonly int time;
			
			internal WinEvent(WinEventHook hook, EEvent event_, wnd hwnd, EObjid idObject, int idChild, int thread, int time) {
				this.hook = hook;
				this.event_ = event_;
				this.w = hwnd;
				this.idObject = idObject;
				this.idChild = idChild;
				this.thread = thread;
				this.time = time;
			}
			
			/// <summary>
			/// Calls <see cref="elm.fromEvent"/>.
			/// </summary>
			public elm GetElm() {
				return elm.fromEvent(w, idObject, idChild);
			}
		}
	}
}


================================================
FILE: Au/Au.More/WindowsHook.cs
================================================
namespace Au.More {
	/// <summary>
	/// Wraps API <ms>SetWindowsHookEx</ms>.
	/// </summary>
	/// <remarks>
	/// Hooks are used to receive notifications about various system events. Keyboard and mouse input, window messages, various window events.
	/// 
	/// Threads that use hooks must process Windows messages. For example have a window/dialog/messagebox, or use a "wait-for" function that dispatches messages or has such option (see <see cref="Seconds.DoEvents"/>).
	/// 
	/// <note type="important">The variable should be disposed when don't need, or at least unhooked, either explicitly (call <see cref="Dispose"/> or <see cref="Unhook"/> in same thread) or with <c>using</c>. Can do it in hook procedure.</note>
	/// 
	/// <note type="warning">Avoid many hooks. Each low-level keyboard or mouse hook makes the computer slower, even if the hook procedure is fast. On each input event (key down, key up, mouse move, click, wheel) Windows sends a message to your thread.</note>
	/// 
	/// To receive hook events is used a callback function, aka hook procedure. Hook procedures of some hook types can block some events (call <see cref="HookData.Keyboard.BlockEvent"/> or return <c>true</c>). Blocked events are not sent to apps and older hooks.
	/// 
	/// Delegates of hook procedures are protected from GC until called <see cref="Dispose"/> or until the thread ends, even of unreferenced <c>WindowsHook</c> variables.
	/// 
	/// UI element functions may fail in hook procedures of low-level keyboard and mouse hooks. Workarounds exist.
	/// 
	/// Exists an alternative way to monitor keyboard or mouse events - raw input API. Good: less overhead; can detect from which device the input event came. Bad: cannot block events; incompatible with low-level keyboard hooks. This library does not have functions to make the API easier to use.
	/// </remarks>
	[DebuggerStepThrough]
	public sealed class WindowsHook : IDisposable {
		IntPtr _hh; //HHOOK
		readonly Api.HOOKPROC _proc1; //our intermediate dispatcher hook proc that calls _proc2
		Delegate _proc2; //caller's hook proc
		readonly string _hookTypeString; //"Keyboard" etc
		readonly int _hookType; //Api.WH_
		readonly bool _ignoreAuInjected;
		[ThreadStatic] static List<WindowsHook> t_antiGC;

		/// <summary>
		/// Sets a low-level keyboard hook (<ms>WH_KEYBOARD_LL</ms>).
		/// See API <ms>SetWindowsHookEx</ms>.
		/// </summary>
		/// <returns>New <see cref="WindowsHook"/> object that manages the hook.</returns>
		/// <param name="hookProc">
		/// The hook procedure (function that handles hook events).
		/// Must return as soon as possible. More info: <see cref="LowLevelHooksTimeout"/>.
		/// If calls <see cref="HookData.Keyboard.BlockEvent"/> or <see cref="HookData.ReplyMessage"/><c>(true)</c>, the event is not sent to apps and other hooks.
		/// Event data cannot be modified.
		/// <para>NOTE: When the hook procedure returns, the parameter variable becomes invalid and unsafe to use. If you need the data for later use, copy its properties and not whole variable.</para>
		/// </param>
		/// <param name="ignoreAuInjected">Don't call the hook procedure for events sent by functions of this library. Default <c>true</c>.</param>
		/// <param name="setNow">Set hook now. Default <c>true</c>.</param>
		/// <exception cref="AuException">Failed.</exception>
		/// <example>
		/// <code><![CDATA[
		/// var stop = false;
		/// using var hook = WindowsHook.Keyboard(x => {
		/// 	print.it(x);
		/// 	if(x.vkCode == KKey.Escape) { stop = true; x.BlockEvent(); }
		/// });
		/// dialog.show("hook");
		/// //or
		/// //wait.doEventsUntil(-10, () => stop); //wait max 10 s for Esc key
		/// //print.it("the end");
		/// ]]></code>
		/// </example>
		public static WindowsHook Keyboard(Action<HookData.Keyboard> hookProc, bool ignoreAuInjected = true, bool setNow = true)
			=> new(Api.WH_KEYBOARD_LL, hookProc, setNow, 0, ignoreAuInjected);

		/// <summary>
		/// Sets a low-level mouse hook (<ms>WH_MOUSE_LL</ms>).
		/// See API <ms>SetWindowsHookEx</ms>.
		/// </summary>
		/// <returns>New <see cref="WindowsHook"/> object that manages the hook.</returns>
		/// <param name="hookProc">
		/// The hook procedure (function that handles hook events).
		/// Must return as soon as possible. More info: <see cref="LowLevelHooksTimeout"/>.
		/// If calls <see cref="HookData.Mouse.BlockEvent"/> or <see cref="HookData.ReplyMessage"/><c>(true)</c>, the event is not sent to apps and other hooks.
		/// Event data cannot be modified.
		/// <para>NOTE: When the hook procedure returns, the parameter variable becomes invalid and unsafe to use. If you need the data for later use, copy its properties and not whole variable.</para>
		/// </param>
		/// <param name="ignoreAuInjected">Don't call the hook procedure for events sent by functions of this library. Default <c>true</c>.</param>
		/// <param name="setNow">Set hook now. Default <c>true</c>.</param>
		/// <exception cref="AuException">Failed.</exception>
		/// <example>
		/// <code><![CDATA[
		/// var stop = false;
		/// using var hook = WindowsHook.Mouse(x => {
		/// 	print.it(x);
		/// 	if(x.Event == HookData.MouseEvent.RightButton) { stop = x.IsButtonUp; x.BlockEvent(); }
		/// });
		/// dialog.show("hook");
		/// //or
		/// //wait.doEventsUntil(-10, () => stop); //wait max 10 s for right-click
		/// //print.it("the end");
		/// ]]></code>
		/// </example>
		public static WindowsHook Mouse(Action<HookData.Mouse> hookProc, bool ignoreAuInjected = true, bool setNow = true)
			=> new(Api.WH_MOUSE_LL, hookProc, setNow, 0, ignoreAuInjected);

		internal static WindowsHook MouseRaw_(Func<nint, nint, bool> hookProc, bool ignoreAuInjected = true, bool setNow = true)
			=> new(Api.WH_MOUSE_LL, hookProc, setNow, 0, ignoreAuInjected, "Mouse");

		/// <summary>
		/// Sets a <ms>WH_CBT</ms> hook for a thread of this process.
		/// See API <ms>SetWindowsHookEx</ms>.
		/// </summary>
		/// <returns>New <see cref="WindowsHook"/> object that manages the hook.</returns>
		/// <param name="hookProc">
		/// Hook procedure (function that handles hook events).
		/// Must return as soon as possible.
		/// If returns <c>true</c>, the event is canceled. For some events you can modify some fields of event data.
		/// <para>NOTE: When the hook procedure returns, the parameter variable becomes invalid and unsafe to use. If you need the data for later use, copy its properties and not the variable.</para>
		/// </param>
		/// <param name="threadId">Native thread id, or 0 for this thread. The thread must belong to this process.</param>
		/// <param name="setNow">Set hook now. Default <c>true</c>.</param>
		/// <exception cref="AuException">Failed.</exception>
		/// <example>
		/// <code><![CDATA[
		/// using var hook = WindowsHook.ThreadCbt(x => {
		/// 	print.it(x.code);
		/// 	switch(x.code) {
		/// 	case HookData.CbtEvent.ACTIVATE:
		/// 		print.it(x.Hwnd);
		/// 		break;
		/// 	case HookData.CbtEvent.CREATEWND:
		/// 		var c=x.CreationInfo->lpcs;
		/// 		print.it(x.Hwnd, c->x, c->lpszName);
		/// 		c->x=500;
		/// 		break;
		/// 	}
		/// 	return false;
		/// });
		/// dialog.showOkCancel("hook");
		/// //new Form().ShowDialog(); //to test MINMAX
		/// ]]></code>
		/// </example>
		public static WindowsHook ThreadCbt(Func<HookData.ThreadCbt, bool> hookProc, int threadId = 0, bool setNow = true)
			=> new(Api.WH_CBT, hookProc, setNow, threadId);

		/// <summary>
		/// Sets a <ms>WH_GETMESSAGE</ms> hook for a thread of this process.
		/// See API <ms>SetWindowsHookEx</ms>.
		/// </summary>
		/// <returns>New <see cref="WindowsHook"/> object that manages the hook.</returns>
		/// <param name="hookProc">
		/// The hook procedure (function that handles hook events).
		/// Must return as soon as possible.
		/// The event cannot be canceled. As a workaround, you can set <c>msg->message=0</c>. Also can modify other fields.
		/// <para>NOTE: When the hook procedure returns, the pointer field of the parameter variable becomes invalid and unsafe to use.</para>
		/// </param>
		/// <param name="threadId">Native thread id, or 0 for this thread. The thread must belong to this process.</param>
		/// <param name="setNow">Set hook now. Default <c>true</c>.</param>
		/// <exception cref="AuException">Failed.</exception>
		/// <example>
		/// <code><![CDATA[
		/// using var hook = WindowsHook.ThreadGetMessage(x => {
		/// 	print.it(x.msg->ToString(), x.PM_NOREMOVE);
		/// });
		/// dialog.show("hook");
		/// ]]></code>
		/// </example>
		public static WindowsHook ThreadGetMessage(Action<HookData.ThreadGetMessage> hookProc, int threadId = 0, bool setNow = true)
			=> new(Api.WH_GETMESSAGE, hookProc, setNow, threadId);

		/// <summary>
		/// Sets a <ms>WH_GETMESSAGE</ms> hook for a thread of this process.
		/// See API <ms>SetWindowsHookEx</ms>.
		/// </summary>
		/// <returns>New <see cref="WindowsHook"/> object that manages the hook.</returns>
		/// <param name="hookProc">
		/// The hook procedure (function that handles hook events).
		/// Must return as soon as possible.
		/// If returns <c>true</c>, the event is canceled.
		/// </param>
		/// <param name="threadId">Native thread id, or 0 for this thread. The thread must belong to this process.</param>
		/// <param name="setNow">Set hook now. Default <c>true</c>.</param>
		/// <exception cref="AuException">Failed.</exception>
		/// <example>
		/// <code><![CDATA[
		/// using var hook = WindowsHook.ThreadKeyboard(x => {
		/// 	print.it(x.key, 0 != (x.lParam & 0x80000000) ? "up" : "", x.lParam, x.PM_NOREMOVE);
		/// 	return false;
		/// });
		/// dialog.show("hook");
		/// ]]></code>
		/// </example>
		public static WindowsHook ThreadKeyboard(Func<HookData.ThreadKeyboard, bool> hookProc, int threadId = 0, bool setNow = true)
			=> new(Api.WH_KEYBOARD, hookProc, setNow, threadId);

		/// <summary>
		/// Sets a <ms>WH_MOUSE</ms> hook for a thread of this process.
		/// See API <ms>SetWindowsHookEx</ms>.
		/// </summary>
		/// <returns>New <see cref="WindowsHook"/> object that manages the hook.</returns>
		/// <param name="hookProc">
		/// The hook procedure (function that handles hook events).
		/// Must return as soon as possible.
		/// If returns <c>true</c>, the event is canceled.
		/// <para>NOTE: When the hook procedure returns, the pointer field of the parameter variable becomes invalid and unsafe to use.</para>
		/// </param>
		/// <param name="threadId">Native thread id, or 0 for this thread. The thread must belong to this process.</param>
		/// <param name="setNow">Set hook now. Default <c>true</c>.</param>
		/// <exception cref="AuException">Failed.</exception>
		/// <example>
		/// <code><![CDATA[
		/// using var hook = WindowsHook.ThreadMouse(x => {
		/// 	print.it(x.message, x.m->pt, x.m->hwnd, x.PM_NOREMOVE);
		/// 	return false;
		/// });
		/// dialog.show("hook");
		/// ]]></code>
		/// </example>
		public static WindowsHook ThreadMouse(Func<HookData.ThreadMouse, bool> hookProc, int threadId = 0, bool setNow = true)
			=> new(Api.WH_MOUSE, hookProc, setNow, threadId);

		/// <summary>
		/// Sets a <ms>WH_CALLWNDPROC</ms> hook for a thread of this process.
		/// See API <ms>SetWindowsHookEx</ms>.
		/// </summary>
		/// <returns>A new <see cref="WindowsHook"/> object that manages the hook.</returns>
		/// <param name="hookProc">
		/// The hook procedure (function that handles hook events).
		/// Must return as soon as possible.
		/// The event cannot be canceled or modified.
		/// <para>NOTE: When the hook procedure returns, the pointer field of the parameter variable becomes invalid and unsafe to use.</para>
		/// </param>
		/// <param name="threadId">Native thread id, or 0 for this thread. The thread must belong to this process.</param>
		/// <param name="setNow">Set hook now. Default <c>true</c>.</param>
		/// <exception cref="AuException">Failed.</exception>
		/// <example>
		/// <code><![CDATA[
		/// using var hook = WindowsHook.ThreadCallWndProc(x => {
		/// 	ref var m = ref *x.msg;
		/// 	WndUtil.PrintMsg(out var s, m.hwnd, m.message, m.wParam, m.lParam);
		/// 	print.it(s, x.sentByOtherThread);
		/// });
		/// dialog.show("hook");
		/// ]]></code>
		/// </example>
		public static WindowsHook ThreadCallWndProc(Action<HookData.ThreadCallWndProc> hookProc, int threadId = 0, bool setNow = true)
			=> new(Api.WH_CALLWNDPROC, hookProc, setNow, threadId);

		/// <summary>
		/// Sets a <ms>WH_CALLWNDPROCRET</ms> hook for a thread of this process.
		/// See API <ms>SetWindowsHookEx</ms>.
		/// </summary>
		/// <inheritdoc cref="ThreadCallWndProc"/>
		public static WindowsHook ThreadCallWndProcRet(Action<HookData.ThreadCallWndProcRet> hookProc, int threadId = 0, bool setNow = true)
			=> new(Api.WH_CALLWNDPROCRET, hookProc, setNow, threadId);

		WindowsHook(int hookType, Delegate hookProc, bool setNow, int tid, bool ignoreAuInjected = false, [CallerMemberName] string m_ = null) {
			Not_.Null(hookProc);
			_proc2 = hookProc;
			_hookType = hookType;
			_hookTypeString = m_;
			_ignoreAuInjected = ignoreAuInjected;
			if (hookType is Api.WH_KEYBOARD_LL or Api.WH_MOUSE_LL) {
				_proc1 = _HookProcLL;
				//JIT-compile our hook proc and some functions it may call. OS gives us only 300 ms by default.
				if (!s_jit1) {
					s_jit1 = true;
					Jit_.Compile(typeof(WindowsHook), nameof(_HookProcLL));
					_ = perf.ms;
					_ = keys.KeyTypes_.IsMod(KKey.Shift) && _DontBlockMod;
				}
			} else {
				_proc1 = _HookProc;
			}
			if (setNow) Hook(tid);
			(t_antiGC ??= new()).Add(this);
		}
		static bool s_jit1;

		/// <summary>
		/// Sets the hook.
		/// </summary>
		/// <param name="threadId">If the hook type is a thread hook - thread id, or 0 for current thread. Else not used and must be 0.</param>
		/// <exception cref="AuException">Failed.</exception>
		/// <exception cref="InvalidOperationException">The hook is already set.</exception>
		/// <exception cref="ArgumentException"><i>threadId</i> not 0 and the hook type is not a thread hook.</exception>
		/// <remarks>
		/// Usually don't need to call this function, because the <c>WindowsHook</c> static methods that return a new <c>WindowsHook</c> object by default call it.
		/// </remarks>
		public void Hook(int threadId = 0) {
			if (_proc2 == null) throw new ObjectDisposedException(nameof(WindowsHook));
			if (_hh != default) throw new InvalidOperationException("The hook is already set.");
			if (_hookType is Api.WH_KEYBOARD_LL or Api.WH_MOUSE_LL) {
				if (threadId != 0) throw new ArgumentException("threadId must be 0");
			} else if (threadId == 0) {
				threadId = Api.GetCurrentThreadId();
			}
			_hh = Api.SetWindowsHookEx(_hookType, _proc1, default, threadId);
			if (_hh == default) throw new AuException(0, "*set hook");
		}

		/// <summary>
		/// Removes the hook.
		/// </summary>
		/// <remarks>
		/// Does nothing if already removed or wasn't set.
		/// Later you can call <see cref="Hook"/> to set hook again.
		/// Note: call <see cref="Dispose"/> instead if will not need to hook again.
		/// </remarks>
		public void Unhook() {
			if (_hh != default) {
				_Restore_UnhookOld();
				bool ok = Api.UnhookWindowsHookEx(_hh);
				if (!ok) print.warning($"WindowsHook.Unhook() failed ({_hookTypeString}). {lastError.message}");
				_hh = default;
			}
		}

		/// <summary>
		/// Rehooks this low-level keyboard or mouse hook.
		/// </summary>
		/// <remarks>
		/// Low level hooks may be occasionally disabled by the OS or other hooks. Workaround - call this function eg every 10 s in same thread. For example use <see cref="timer"/>. Don't call too frequently, eg every 1 s.
		/// This function unhooks current hook and sets new hook. Ensures that no events are missed or duplicate during it.
		/// </remarks>
		/// <exception cref="InvalidOperationException">The hook type isn't low-level keyboard or mouse.</exception>
		public void Restore() {
			if (_hookType is not (Api.WH_KEYBOARD_LL or Api.WH_MOUSE_LL)) throw new InvalidOperationException();
			if (_proc2 == null) throw new ObjectDisposedException(nameof(WindowsHook));
			if (_hookType is Api.WH_KEYBOARD_LL && DontRestoreKeyboardHooks_) return;

			//If we simply unhook/hook here, some events are missed.
			//	Restoring usually takes 0.2 - 0.5 ms. And it seems the new hook starts working with a delay.
			//	If restoring every 10 s, could miss maybe 1/10000 triggers.
			//	Tested: when restoring every 15 ms, missed 3/50 triggers.
			//	Solution: unhook the old hook after several ms. To avoid duplicate events, unhook it in the hook proc too.
#if false
			if (_hh != default) Api.UnhookWindowsHookEx(_hh);
			_hh = Api.SetWindowsHookEx(_hookType, _proc1, default, 0);
			if (_hh == default) throw new AuException(0, "*set hook");
#else
			_Restore_UnhookOld();
			var hh = Api.SetWindowsHookEx(_hookType, _proc1, default, 0);
			if (hh != default) {
				if (_hh != default) timer.after(10, _ => _Restore_UnhookOld());
				_oldHook = _hh;
				_hh = hh;
			} else {
				Debug_.Print("failed");
			}
#endif
		}
		IntPtr _oldHook;
		
		/// <summary>
		/// Can be used to temporarily disable <see cref="Restore"/> of all keyboard hooks in all processes.
		/// For example when a hotkey control is focused.
		/// </summary>
		/// <remarks>
		/// <c>Restore</c> is disabled when the number of <c>=true</c> calls is greater than the number of <c>=false</c> calls. 
		/// </remarks>
		internal static unsafe bool DontRestoreKeyboardHooks_ {
			get => SharedMemory_.Ptr->winHook.dontRestoreKeyboardHooks > 0;
			set => Interlocked.Add(ref SharedMemory_.Ptr->winHook.dontRestoreKeyboardHooks, value ? 1 : -1);
		}

		void _Restore_UnhookOld() {
			if (_oldHook != default) {
				bool ok = Api.UnhookWindowsHookEx(_oldHook);
				_oldHook = default;
				Debug_.PrintIf(!ok, "failed to unhook old");
			}
		}

		/// <summary>
		/// Returns <c>true</c> if the hook is set.
		/// </summary>
		public bool IsSet => _hh != default;

		///// <summary>
		///// Disable warning "Non-disposed WindowsHook variable".
		///// </summary>
		//public bool NoWarningNondisposed { get; set; }

		/// <summary>
		/// Calls <see cref="Unhook"/> and disposes this object.
		/// </summary>
		public void Dispose() {
			Unhook();
			_proc2 = null;
			t_antiGC.Remove(this);
			GC.SuppressFinalize(this);
		}

		/// <summary>
		/// Prints a warning if the variable is not disposed. Cannot dispose in finalizer.
		/// </summary>
		~WindowsHook() {
			//unhooking in finalizer thread makes no sense. Must unhook in same thread, else fails.
			if (_hh != default) print.warning($"Non-disposed WindowsHook ({_hookTypeString}) variable.");
			//ok if unhooked but not disposed. If we are here, the thread ended and therefore don't need to remove this from t_antiGC.
		}

		unsafe nint _HookProc(int code, nint wParam, nint lParam) {
			if (code >= 0) {
				try {
					bool eat = false;

					switch (_proc2) {
					case Func<HookData.ThreadCbt, bool> p:
						eat = p(new HookData.ThreadCbt(this, code, wParam, lParam));
						break;
					case Action<HookData.ThreadGetMessage> p:
						p(new HookData.ThreadGetMessage(this, wParam, lParam));
						break;
					case Func<HookData.ThreadKeyboard, bool> p:
						eat = p(new HookData.ThreadKeyboard(this, code, wParam, lParam));
						break;
					case Func<HookData.ThreadMouse, bool> p:
						eat = p(new HookData.ThreadMouse(this, code, wParam, lParam));
						break;
					case Action<HookData.ThreadCallWndProc> p:
						p(new HookData.ThreadCallWndProc(this, wParam, lParam));
						break;
					case Action<HookData.ThreadCallWndProcRet> p:
						p(new HookData.ThreadCallWndProcRet(this, wParam, lParam));
						break;
					}

					if (eat) return 1;
				}
				catch (Exception ex) { OnException_(ex); }
			}

			return Api.CallNextHookEx(default, code, wParam, lParam);
		}

		unsafe nint _HookProcLL(int code, nint wParam, nint lParam) {
			_Restore_UnhookOld();
			if (code >= 0) {
				try {
					//using var p1 = perf.local();
					bool eat = false;
					long t1 = 0;
					Action<HookData.Mouse> pm1;
					Func<nint, nint, bool> pm2;

					switch (_proc2) {
					case Action<HookData.Keyboard> p:
						var kll = (Api.KBDLLHOOKSTRUCT*)lParam;
						var vk = (KKey)kll->vkCode;
						if (kll->IsInjected) {
							if (kll->IsInjectedByAu) {
								if (kll->vkCode == 0) goto gr; //used to enable activating windows
								if (!kll->IsUp) Triggers.AutotextTriggers.ResetEverywhere = true;
								if (_ignoreAuInjected) goto gr;
							}
							if (vk == KKey.MouseX2 && kll->dwExtraInfo == 1354291109) goto gr; //QM2 sync code
						} else {
							//When keys.Internal_.ReleaseModAndCapsLock sends Shift to turn off CapsLock,
							//	hooks receive a non-injected LShift down, CapsLock down/up and injected LShift up.
							//	Our triggers would recover, but cannot auto-repeat. Better don't call the hookproc.
							if ((vk == KKey.CapsLock || vk == KKey.LShift) && _ignoreAuInjected && _IgnoreLShiftCaps) goto gr;

							//Test how our triggers recover when a modifier down or up event is lost. Or when triggers started while a modifier is down.
							//if(keys.isScrollLock) {
							//	//if(vk == KKey.LCtrl && !kll->IsUp) { print.it("lost Ctrl down"); goto gr; }
							//	if(vk == KKey.LCtrl && kll->IsUp) { print.it("lost Ctrl up"); goto gr; }
							//}
						}
						//if (keys.KeyTypes_.IsMod(vk) && _DontBlockMod) goto gr; //old version, creates problems
						t1 = perf.ms;
						//p1.Next();
						p(new HookData.Keyboard(this, lParam)); //info: wParam is message, but it is not useful, everything is in lParam
						if (eat = kll->BlockEvent) {
							kll->BlockEvent = false;
							if (keys.KeyTypes_.IsMod(vk) && _DontBlockMod && kll->IsUp) eat = false;
						}
						break;
					case Action<HookData.Mouse> p:
						pm1 = p; pm2 = null;
						gm1:
						var mll = (Api.MSLLHOOKSTRUCT*)lParam;
						switch ((int)wParam) {
						case Api.WM_LBUTTONDOWN: case Api.WM_RBUTTONDOWN: Triggers.AutotextTriggers.ResetEverywhere = true; break;
						}
						if (_ignoreAuInjected && mll->IsInjectedByAu) goto gr;

						//API bug workaround. In DPI-scaled windows on click mhsLL->pt is logical, although on move/wheel is physical. Must be always physical.
						//At first noticed only on Win10. But then noticed the same on Win7, although used to be correct. OK on Win8.1. Maybe depends on some other conditions, eg UAC IL, DPI, multimonitor.
						//Now it seems the bug is fixed on Win10. Found on SO: "Microsoft fixed it in 10.0.14393"; it is version 1607, August 2, 2016; but I cannot confirm it.
						//The wrong coords are the same as GetCursorPos. Only GetPhysicalCursorPos does not lie. Api.GetCursorPos is mapped to GetPhysicalCursorPos.
						//Note: on WM_MOUSEMOVE Get[Physical]CursorPos returns previous coords. On other messages same as hook.
						if (wParam != Api.WM_MOUSEMOVE /*&& osVersion.winVer < osVersion.win10*/) Api.GetCursorPos(out mll->pt);

						t1 = perf.ms;
						if (pm2 != null) {
							eat = pm2(wParam, lParam);
						} else {
							pm1(new HookData.Mouse(this, wParam, lParam));
							if (eat = mll->BlockEvent) mll->BlockEvent = false;
						}
						break;
					case Func<nint, nint, bool> p: //raw mouse
						pm2 = p; pm1 = null;
						goto gm1;
					}

					//Prevent Windows disabling the low-level key/mouse hook.
					//	Hook proc must return in HKEY_CURRENT_USER\Control Panel\Desktop:LowLevelHooksTimeout ms.
					//		Default 300. On Win10 max 1000 (bigger registry value is ignored and used 1000).
					//	On timeout Windows:
					//		1. Does not wait more. Passes the message to the next hook etc, and we cannot return 1 to block it.
					//		2. Kills the hook after several such cases. Usually 6 keys or 11 mouse events.
					//		3. Makes the hook useless: next times does not wait for it, and we cannot return 1 to block the event.
					//	Somehow does not apply 2 and 3 to some apps, eg C# apps created by Visual Studio, although applies to those created not by VS. I did not find why.
					if (t1 != 0 && (t1 = perf.ms - t1) > 200 && !Debugger.IsAttached) {
						if (t1 > LowLevelHooksTimeout - 50) {
							var s1 = _hookType == Api.WH_KEYBOARD_LL ? "key" : "mouse";
							var s2 = eat ? $" On timeout the {s1} message is passed to the active window, other hooks, etc." : null;
							//print.warning($"Possible hook timeout. Hook procedure time: {t1} ms. LowLevelHooksTimeout: {LowLevelHooksTimeout} ms.{s2}"); //too slow first time
							//print.it($"Warning: Possible hook timeout. Hook procedure time: {t1} ms. LowLevelHooksTimeout: {LowLevelHooksTimeout} ms.{s2}\r\n{new StackTrace(0, false)}"); //first Write() JIT 30 ms
							ThreadPool.QueueUserWorkItem(s3 => print.it(s3), $"Warning: Possible hook timeout. Hook procedure time: {t1} ms. LowLevelHooksTimeout: {LowLevelHooksTimeout} ms.{s2}\r\n{new StackTrace(0, false)}"); //fast if with false. But async print can be confusing.
						}
						//FUTURE: print warning if t1 is >25 frequently. Unhook and don't rehook if >LowLevelHooksTimeout frequently.

						Unhook();
						_hh = Api.SetWindowsHookEx(_hookType, _proc1, default, 0);
					}

					if (eat) return 1;
				}
				catch (Exception ex) { OnException_(ex); }
			}
			gr:
			return Api.CallNextHookEx(default, code, wParam, lParam);
		}

		/// <summary>
		/// Gets the max time in milliseconds allowed by Windows for low-level keyboard and mouse hook procedures.
		/// </summary>
		/// <remarks>
		/// Gets registry value <c>HKEY_CURRENT_USER\Control Panel\Desktop:LowLevelHooksTimeout</c>. If it is missing, returns 300; it is the default value used by Windows. If greater than 1000, returns 1000, because Windows 10 ignores bigger values.
		/// 
		/// If a hook procedure takes more time, Windows does not wait. Then its return value is ignored, and the event is passed to other apps, hooks, etc. After several such cases Windows may fully or partially disable the hook. This class detects such cases; then restores the hook and prints a warning. If the warning is rare, you can ignore it. If frequent, it means your hook procedure is too slow.
		/// 
		/// Callback functions of keyboard and mouse triggers are called in a hook procedure, therefore must be as fast as possible. More info: <see cref="Triggers.TriggerFuncs"/>.
		/// 
		/// More info: <ms>registry LowLevelHooksTimeout</ms>.
		/// 
		/// Note: After changing the timeout in registry, it is not applied immediately. Need to log off/on.
		/// </remarks>
		public static int LowLevelHooksTimeout {
			get {
				if (s_lowLevelHooksTimeout == 0) {
					//default 300, tested on Win10 and 7
					//max 1000 on Win10. On Win7 more. Not tested on Win8. On Win7/8 may be changed by a Windows update.
					s_lowLevelHooksTimeout =
						Microsoft.Win32.Registry.GetValue(@"HKEY_CURRENT_USER\Control Panel\Desktop", "LowLevelHooksTimeout", null) is int v
						? (int)Math.Min(1000u, (uint)v)
						: 300;
				}
				return s_lowLevelHooksTimeout;
			}
			internal set {
				int v = Math.Clamp(value, 0, 5000);
				Microsoft.Win32.Registry.SetValue(@"HKEY_CURRENT_USER\Control Panel\Desktop", "LowLevelHooksTimeout", v);
				s_lowLevelHooksTimeout = v;
			}
		}
		static int s_lowLevelHooksTimeout;

		internal static void OnException_(Exception e) {
			print.warning("Unhandled exception in hook procedure. " + e.ToString(), -1);
		}

		[StructLayout(LayoutKind.Sequential, Size = 32)] //note: this struct is in shared memory. Size must be same in all library versions.
		internal struct SharedMemoryData_ {
			public long dontBlockModUntil, dontBlocLShiftCapsUntil;
			public int dontRestoreKeyboardHooks;
			//12 bytes reserved
		}

		/// <summary>
		/// Let other hooks (in all processes) don't block modifier key up events for <i>timeMS</i> milliseconds. If 0 - restore.
		/// Used by mouse triggers waiting for mod keys released, to prevent inputblockers blocking mod up events, eg when sending keys/text.
		/// Returns the timeout time (<c>Environment.TickCount64 + timeMS</c>) or 0.
		/// </summary>
		internal unsafe long DontBlockModInOtherHooks_(long timeMS) {
			_ignoreModExceptThisHook = timeMS > 0;
			var r = _ignoreModExceptThisHook ? Environment.TickCount64 + timeMS : 0;
			SharedMemory_.Ptr->winHook.dontBlockModUntil = r;
			return r;
		}

		unsafe bool _DontBlockMod => SharedMemory_.Ptr->winHook.dontBlockModUntil > Environment.TickCount64 && !_ignoreModExceptThisHook;
		bool _ignoreModExceptThisHook;

		/// <summary>
		/// Let all hooks (in all processes) ignore <c>LShift</c> and <c>CapsLock</c> for <i>timeMS</i> milliseconds. If 0 - restore.
		/// Returns the timeout time (<c>Environment.TickCount64 + timeMS</c>) or 0.
		/// Used when turning off <c>CapsLock</c> with <c>Shift</c>.
		/// </summary>
		internal static unsafe long IgnoreLShiftCaps_(long timeMS) {
			var r = timeMS > 0 ? Environment.TickCount64 + timeMS : 0;
			SharedMemory_.Ptr->winHook.dontBlocLShiftCapsUntil = r;
			return r;
		}

		static unsafe bool _IgnoreLShiftCaps => SharedMemory_.Ptr->winHook.dontBlocLShiftCapsUntil > Environment.TickCount64;
	}
}

namespace Au.Types {
	/// <summary>
	/// Contains types of hook data for hook procedures set by <see cref="WindowsHook"/> and <see cref="WinEventHook"/>.
	/// </summary>
	public static partial class HookData {
		/// <summary>
		/// Event data for the hook procedure set by <see cref="WindowsHook.Keyboard"/>.
		/// More info: API <ms>LowLevelKeyboardProc</ms>.
		/// </summary>
		public unsafe struct Keyboard {
			/// <summary>The caller object of your hook procedure. For example can be used to unhook.</summary>
			public readonly WindowsHook hook;

			readonly Api.KBDLLHOOKSTRUCT* _x;

			internal Keyboard(WindowsHook hook, nint lParam) {
				this.hook = hook;
				_x = (Api.KBDLLHOOKSTRUCT*)lParam;
			}

			/// <summary>
			/// Call this function to steal this event from other hooks and apps.
			/// </summary>
			public void BlockEvent() => _x->BlockEvent = true;

			/// <summary>
			/// Is extended key.
			/// </summary>
			public bool IsExtended => 0 != (_x->flags & Api.LLKHF_EXTENDED);

			/// <summary>
			/// <c>true</c> if the event was generated by API such as <ms>SendInput</ms>.
			/// <c>false</c> if the event was generated by the keyboard.
			/// </summary>
			public bool IsInjected => 0 != (_x->flags & Api.LLKHF_INJECTED);

			/// <summary>
			/// <c>true</c> if the event was generated by functions of this library.
			/// </summary>
			public bool IsInjectedByAu => 0 != (_x->flags & Api.LLKHF_INJECTED) && _x->dwExtraInfo == Api.AuExtraInfo;

			/// <summary>
			/// Key <c>Alt</c> is pressed.
			/// </summary>
			public bool IsAlt => 0 != (_x->flags & Api.LLKHF_ALTDOWN);

			/// <summary>
			/// Is key-up event.
			/// </summary>
			public bool IsUp => 0 != (_x->flags & Api.LLKHF_UP);

			/// <summary>
			/// If the key is a modifier key (<c>Shift</c>, <c>Ctrl</c>, <c>Alt</c>, <c>Win</c>), returns the modifier flag. Else returns 0.
			/// </summary>
			public KMod Mod => keys.Internal_.KeyToMod((KKey)_x->vkCode);

			/// <summary>
			/// If <see cref="vkCode"/> is a left or right modifier key code (<c>LShift</c>, <c>LCtrl</c>, <c>LAlt</c>, <c>RShift</c>, <c>RCtrl</c>, <c>RAlt</c>, <c>RWin</c>), returns the common modifier key code (<c>Shift</c>, <c>Ctrl</c>, <c>Alt</c>, <c>Win</c>). Else returns <see cref="vkCode"/>.
			/// </summary>
			public KKey Key {
				get {
					var vk = (KKey)_x->vkCode;
					switch (vk) {
					case KKey.LShift: case KKey.RShift: return KKey.Shift;
					case KKey.LCtrl: case KKey.RCtrl: return KKey.Ctrl;
					case KKey.LAlt: case KKey.RAlt: return KKey.Alt;
					case KKey.RWin: return KKey.Win;
					}
					return vk;
				}
			}

			/// <summary>
			/// Returns <c>true</c> if <i>key</i> == <see cref="vkCode"/> or <i>key</i> is <c>Shift</c>, <c>Ctrl</c>, <c>Alt</c> or <c>Win</c> and <see cref="vkCode"/> is <c>LShift</c>/<c>RShift</c>, <c>LCtrl</c>/<c>RCtrl</c>, <c>LAlt</c>/<c>RAlt</c> or <c>RWin</c>.
			/// </summary>
			public bool IsKey(KKey key) {
				var vk = (KKey)_x->vkCode;
				if (key == vk) return true;
				switch (key) {
				case KKey.Shift: return vk == KKey.LShift || vk == KKey.RShift;
				case KKey.Ctrl: return vk == KKey.LCtrl || vk == KKey.RCtrl;
				case KKey.Alt: return vk == KKey.LAlt || vk == KKey.RAlt;
				case KKey.Win: return vk == KKey.RWin;
				}
				return false;
			}

			/// <summary>
			/// Converts flags to API <ms>SendInput</ms> flags <c>KEYEVENTF_KEYUP</c> and <c>KEYEVENTF_EXTENDEDKEY</c>.
			/// </summary>
			internal byte SendInputFlags_ {
				get {
					uint f = 0;
					if (IsUp) f |= Api.KEYEVENTF_KEYUP;
					if (IsExtended) f |= Api.KEYEVENTF_EXTENDEDKEY;
					return (byte)f;
				}
			}

			///
			public override string ToString() {
				return $"{vkCode.ToString()} {(IsUp ? "up" : "")}{(IsInjected ? " (injected)" : "")}";
			}

			/// <summary>API <ms>KBDLLHOOKSTRUCT</ms></summary>
			public KKey vkCode => (KKey)_x->vkCode;
			/// <summary>API <ms>KBDLLHOOKSTRUCT</ms></summary>
			public uint scanCode => _x->scanCode;
			/// <summary>API <ms>KBDLLHOOKSTRUCT</ms></summary>
			public uint flags => _x->flags;
			/// <summary>API <ms>KBDLLHOOKSTRUCT</ms></summary>
			public int time => _x->time;
			/// <summary>API <ms>KBDLLHOOKSTRUCT</ms></summary>
			public nint dwExtraInfo => _x->dwExtraInfo;

			internal Api.KBDLLHOOKSTRUCT* NativeStructPtr_ => _x;
		}

		/// <summary>
		/// Extra info value used by functions of this library that generate keyboard events. Low-level hooks receive it in <c>dwExtraInfo</c>.
		/// </summary>
		public const int AuExtraInfo = Api.AuExtraInfo;

		/// <summary>
		/// Hook data for the hook procedure set by <see cref="WindowsHook.Mouse"/>.
		/// More info: API <ms>LowLevelMouseProc</ms>.
		/// </summary>
		public unsafe struct Mouse {
			/// <summary>The caller object of your hook procedure. For example can be used to unhook.</summary>
			public readonly WindowsHook hook;

			readonly Api.MSLLHOOKSTRUCT* _x;
			readonly MouseEvent _event;

			internal Mouse(WindowsHook hook, nint wParam, nint lParam) {
				this.hook = hook;
				var p = (Api.MSLLHOOKSTRUCT*)lParam;
				_x = p;
				int e = (int)wParam;
				switch (e) {
				case Api.WM_MOUSEMOVE: IsMove = true; break;
				case Api.WM_LBUTTONDOWN: case Api.WM_RBUTTONDOWN: case Api.WM_MBUTTONDOWN: IsButtonDown = true; break;
				case Api.WM_LBUTTONUP: case Api.WM_RBUTTONUP: case Api.WM_MBUTTONUP: e--; IsButtonUp = true; break;
				case Api.WM_XBUTTONUP: e--; IsButtonUp = true; goto g1;
				case Api.WM_XBUTTONDOWN:
					IsButtonDown = true;
					g1:
					switch (p->mouseData >> 16) { case 1: e |= 0x1000; break; case 2: e |= 0x2000; break; }
					break;
				case Api.WM_MOUSEWHEEL:
				case Api.WM_MOUSEHWHEEL:
					IsWheel = true;
					int wheel = (short)(p->mouseData >> 16);
					if (wheel > 0) e |= 0x1000; else if (wheel < 0) e |= 0x2000;
					WheelValue = wheel;
					break;
				}
				_event = (MouseEvent)e;
			}

			/// <summary>
			/// Call this function to steal this event from other hooks and apps.
			/// </summary>
			public void BlockEvent() => _x->BlockEvent = true;

			/// <summary>
			/// What event it is (button, move, wheel).
			/// </summary>
			public MouseEvent Event => _event;

			/// <summary>
			/// Is mouse-move event.
			/// </summary>
			public bool IsMove { get; }

			/// <summary>
			/// Is button-down event.
			/// </summary>
			public bool IsButtonDown { get; }

			/// <summary>
			/// Is button-up event.
			/// </summary>
			public bool IsButtonUp { get; }

			/// <summary>
			/// Is button event (down or up).
			/// </summary>
			public bool IsButton => IsButtonDown | IsButtonUp;

			/// <summary>
			/// Converts <see cref="Event"/> to <see cref="MButton"/>.
			/// </summary>
			/// <value><c>Left</c>, <c>Right</c>, <c>Middle</c>, <c>X1</c>, <c>X2</c> or 0. The down/up/double flags not used.</value>
			public MButton Button {
				get {
					return _event switch {
						MouseEvent.LeftButton => MButton.Left,
						MouseEvent.RightButton => MButton.Right,
						MouseEvent.MiddleButton => MButton.Middle,
						MouseEvent.X1Button => MButton.X1,
						MouseEvent.X2Button => MButton.X2,
						_ => 0,
					};
				}
			}

			/// <summary>
			/// Is wheel event.
			/// </summary>
			public bool IsWheel { get; }

			/// <summary>
			/// <c>true</c> if the event was generated by API such as <ms>SendInput</ms>.
			/// <c>false</c> if the event was generated by the mouse.
			/// </summary>
			public bool IsInjected => 0 != (flags & Api.LLMHF_INJECTED);

			/// <summary>
			/// <c>true</c> if the event was generated by functions of this library.
			/// </summary>
			public bool IsInjectedByAu => IsInjected && dwExtraInfo == Api.AuExtraInfo;

			/// <summary>
			/// Wheel rotation amount, 120 for 1 full tick. Negative if backward.
			/// Usually 120 or -120, but some devices or software may produce smaller or bigger values.
			/// </summary>
			public int WheelValue { get; }

			///
			public override string ToString() {
				var ud = ""; if (IsButtonDown) ud = "down"; else if (IsButtonUp) ud = "up";
				return $"{Event.ToString()} {ud} {pt.ToString()}{(IsInjected ? " (injected)" : "")}";
			}

			/// <summary>API <ms>MSLLHOOKSTRUCT</ms></summary>
			public POINT pt => _x->pt;
			/// <summary>API <ms>MSLLHOOKSTRUCT</ms></summary>
			public uint mouseData => _x->mouseData;
			/// <summary>API <ms>MSLLHOOKSTRUCT</ms></summary>
			public uint flags => _x->flags;
			/// <summary>API <ms>MSLLHOOKSTRUCT</ms></summary>
			public int time => _x->time;
			/// <summary>API <ms>MSLLHOOKSTRUCT</ms></summary>
			public nint dwExtraInfo => _x->dwExtraInfo;

			internal Api.MSLLHOOKSTRUCT* NativeStructPtr_ => _x;
		}

		/// <summary>
		/// Mouse hook event types. See <see cref="Mouse.Event"/>.
		/// </summary>
		public enum MouseEvent {
#pragma warning disable 1591 //no XML doc
			Move = 0x0200, //WM_MOUSEMOVE
			LeftButton = 0x0201, //WM_LBUTTONDOWN
			RightButton = 0x0204, //WM_RBUTTONDOWN
			MiddleButton = 0x0207, //WM_MBUTTONDOWN
			X1Button = 0x120B, //WM_XBUTTONDOWN | 0x1000
			X2Button = 0x220B, //WM_XBUTTONDOWN | 0x2000
			WheelForward = 0x120A, //WM_WHEEL | 0x1000
			WheelBackward = 0x220A, //WM_WHEEL | 0x2000
			WheelRight = 0x120E, //WM_HWHEEL | 0x1000
			WheelLeft = 0x220E, //WM_HWHEEL | 0x2000
#pragma warning restore 1591
		}

		/// <summary>
		/// Hook data for the hook procedure set by <see cref="WindowsHook.ThreadCbt"/>.
		/// More info: API <ms>CBTProc</ms>.
		/// </summary>
		public struct ThreadCbt {
			/// <summary>The caller object of your hook procedure. For example can be used to unhook.</summary>
			public readonly WindowsHook hook;

			/// <summary>API <ms>CBTProc</ms></summary>
			public readonly CbtEvent code;

			/// <summary>API <ms>CBTProc</ms></summary>
			public readonly nint wParam;

			/// <summary>API <ms>CBTProc</ms></summary>
			public readonly nint lParam;

			/// <summary>Window handle.</summary>
			public wnd Hwnd => code switch { CbtEvent.ACTIVATE or CbtEvent.CREATEWND or CbtEvent.DESTROYWND or CbtEvent.MINMAX or CbtEvent.MOVESIZE or CbtEvent.SETFOCUS => (wnd)wParam, _ => default };

			internal ThreadCbt(WindowsHook hook, int code, nint wParam, nint lParam) {
				this.hook = hook;
				this.code = (CbtEvent)code;
				this.wParam = wParam;
				this.lParam = lParam;
			}

			/// <summary>
			/// Gets <see cref="CbtEvent.ACTIVATE"/> event info.
			/// </summary>
			/// <exception cref="InvalidOperationException"><see cref="code"/> is not <see cref="CbtEvent.ACTIVATE"/>.</exception>
			public unsafe CBTACTIVATESTRUCT* ActivationInfo => code == CbtEvent.ACTIVATE ? (CBTACTIVATESTRUCT*)lParam : throw new InvalidOperationException();

			/// <summary>
			/// API <ms>CBTACTIVATESTRUCT</ms>.
			/// </summary>
			public struct CBTACTIVATESTRUCT {
				///
				public bool fMouse;
				///
				public wnd hWndActive;
			}

			/// <summary>
			/// Gets <see cref="CbtEvent.CREATEWND"/> event info.
			/// You can modify <c>x</c>, <c>y</c>, <c>cx</c>, <c>cy</c>, and <c>hwndInsertAfter</c>.
			/// </summary>
			/// <exception cref="InvalidOperationException"><see cref="code"/> is not <see cref="CbtEvent.CREATEWND"/>.</exception>
			public unsafe CBT_CREATEWND* CreationInfo => code == CbtEvent.CREATEWND ? (CBT_CREATEWND*)lParam : throw new InvalidOperationException();

			/// <summary>
			/// API <ms>CBT_CREATEWND</ms>.
			/// </summary>
			public unsafe struct CBT_CREATEWND {
				///
				public CREATESTRUCT* lpcs;
				///
				public wnd hwndInsertAfter;
			}

			//rejected. Rarely used or too simple.
			///// <summary>
			///// Gets <see cref="CbtEvent.CLICKSKIPPED"/> event info. Returns the mouse message.
			///// </summary>
			///// <param name="m"><ms>MOUSEHOOKSTRUCT</ms>.</param>
			///// <exception cref="InvalidOperationException"><see cref="code"/> is not <c>CbtEvent.CLICKSKIPPED</c>.</exception>
			//public unsafe uint MouseInfo(out MOUSEHOOKSTRUCT* m) {
			//	if (code != CbtEvent.CLICKSKIPPED) throw new InvalidOperationException();
			//	m = (MOUSEHOOKSTRUCT*)lParam;
			//	return (uint)wParam;
			//}

			///// <summary>
			///// Gets <see cref="CbtEvent.KEYSKIPPED"/> event info. Returns the key code.
			///// </summary>
			///// <param name="lParam"><i>lParam</i> of the key message. Specifies the repeat count, scan code, etc. See API <ms>WM_KEYDOWN</ms>.</param>
			///// <exception cref="InvalidOperationException"><see cref="code"/> is not <c>CbtEvent.KEYSKIPPED</c>.</exception>
			//public KKey KeyInfo(out uint lParam) {
			//	if (code != CbtEvent.KEYSKIPPED) throw new InvalidOperationException();
			//	lParam = (uint)this.lParam;
			//	return (KKey)(uint)wParam;
			//}

			///// <summary>
			///// Gets <see cref="CbtEvent.SETFOCUS"/> event info. Returns the window handle.
			///// </summary>
			///// <param name="wLostFocus">The previously focused window, or <c>default(wnd)</c>.</param>
			///// <exception cref="InvalidOperationException"><see cref="code"/> is not <c>CbtEvent.SETFOCUS</c>.</exception>
			//public wnd FocusInfo(out wnd wLostFocus) {
			//	if (code != CbtEvent.SETFOCUS) throw new InvalidOperationException();
			//	wLostFocus = (wnd)lParam;
			//	return (wnd)wParam;
			//}

			///// <summary>
			///// Gets <see cref="CbtEvent.MOVESIZE"/> event info.
			///// </summary>
			///// <exception cref="InvalidOperationException"><see cref="code"/> is not <c>CbtEvent.MOVESIZE</c>.</exception>
			//public unsafe RECT* MoveSizeInfo => code == CbtEvent.MOVESIZE ? (RECT*)lParam : throw new InvalidOperationException();

			///// <summary>
			///// Gets <see cref="CbtEvent.MINMAX"/> event info.
			///// Returns the new show state. See API <ms>ShowWindow</ms>. Minimized 6, maximized 3, restored 9.
			///// </summary>
			///// <exception cref="InvalidOperationException"><see cref="code"/> is not <c>CbtEvent.MINMAX</c>.</exception>
			//public int MinMaxInfo => code == CbtEvent.MINMAX ? (int)lParam & 0xffff : throw new InvalidOperationException();
		}

		/// <summary>
		/// CBT hook event types. Used with <see cref="ThreadCbt"/>.
		/// More info: API <ms>CBTProc</ms>.
		/// </summary>
		public enum CbtEvent {
#pragma warning disable 1591 //no XML doc
			MOVESIZE = 0,
			MINMAX = 1,
			//QS = 2,
			CREATEWND = 3,
			DESTROYWND = 4,
			ACTIVATE = 5,
			CLICKSKIPPED = 6,
			KEYSKIPPED = 7,
			SYSCOMMAND = 8,
			SETFOCUS = 9,
#pragma warning restore 1591
		}

		/// <summary>
		/// Hook data for the hook procedure set by <see cref="WindowsHook.ThreadGetMessage"/>.
		/// More info: API <ms>GetMsgProc</ms>.
		/// </summary>
		public unsafe struct ThreadGetMessage {
			/// <summary>The caller object of your hook procedure. For example can be used to unhook.</summary>
			public readonly WindowsHook hook;

			/// <summary>
			/// The message has not been removed from the queue, because called API <ms>PeekMessage</ms> with flag <c>PM_NOREMOVE</c>.
			/// </summary>
			public readonly bool PM_NOREMOVE;

			/// <summary>
			/// Message parameters.
			/// API <ms>MSG</ms>.
			/// </summary>
			public readonly MSG* msg;

			internal ThreadGetMessage(WindowsHook hook, nint wParam, nint lParam) {
				this.hook = hook;
				PM_NOREMOVE = (uint)wParam == Api.PM_NOREMOVE;
				msg = (MSG*)lParam;
			}
		}

		/// <summary>
		/// Hook data for the hook procedure set by <see cref="WindowsHook.ThreadKeyboard"/>.
		/// More info: API <ms>KeyboardProc</ms>.
		/// </summary>
		public struct ThreadKeyboard {
			/// <summary>The caller object of your hook procedure. For example can be used to unhook.</summary>
			public readonly WindowsHook hook;

			/// <summary>
			/// The message has not been removed from the queue, because called API <ms>PeekMessage</ms> with flag <c>PM_NOREMOVE</c>.
			/// </summary>
			public readonly bool PM_NOREMOVE;

			/// <summary>
			/// The key code.
			/// </summary>
			public readonly KKey key;

			/// <summary>
			/// <i>lParam</i> of the key message. Specifies the key state, scan code, etc. See API <ms>KeyboardProc</ms>.
			/// </summary>
			public readonly uint lParam;

			/// <summary>
			/// Is key-up event.
			/// </summary>
			public bool IsUp => 0 != (lParam & 0x80000000);

			internal ThreadKeyboard(WindowsHook hook, int code, nint wParam, nint lParam) {
				this.hook = hook;
				PM_NOREMOVE = code == Api.HC_NOREMOVE;
				key = (KKey)(uint)wParam;
				this.lParam = (uint)lParam;
			}
		}

		/// <summary>
		/// Hook data for the hook procedure set by <see cref="WindowsHook.ThreadMouse"/>.
		/// More info: API <ms>MouseProc</ms>.
		/// </summary>
		public unsafe struct ThreadMouse {
			/// <summary>The caller object of your hook procedure. For example can be used to unhook.</summary>
			public readonly WindowsHook hook;

			/// <summary>
			/// The message has not been removed from the queue, because called API <ms>PeekMessage</ms> with flag <c>PM_NOREMOVE</c>.
			/// </summary>
			public readonly bool PM_NOREMOVE;

			/// <summary>
			/// The mouse message, for example <ms>WM_MOUSEMOVE</ms>.
			/// </summary>
			public readonly uint message;

			/// <summary>
			/// More info about the mouse message.
			/// API <ms>MOUSEHOOKSTRUCT</ms>.
			/// </summary>
			public readonly MOUSEHOOKSTRUCT* m;

			internal ThreadMouse(WindowsHook hook, int code, nint wParam, nint lParam) {
				this.hook = hook;
				PM_NOREMOVE = code == Api.HC_NOREMOVE;
				message = (uint)wParam;
				m = (MOUSEHOOKSTRUCT*)lParam;
			}
		}

#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
		/// <summary>API <ms>MOUSEHOOKSTRUCT</ms></summary>
		public struct MOUSEHOOKSTRUCT {
			public POINT pt;
			public wnd hwnd;
			public int wHitTestCode;
			public nint dwExtraInfo;
		}

		/// <summary>API <ms>CWPSTRUCT</ms></summary>
		public struct CWPSTRUCT {
			public nint lParam;
			public nint wParam;
			public int message;
			public wnd hwnd;
		}

		/// <summary>API <ms>CWPRETSTRUCT</ms></summary>
		public struct CWPRETSTRUCT {
			public nint lResult;
			public nint lParam;
			public nint wParam;
			public int message;
			public wnd hwnd;
		}
#pragma warning restore CS1591 // Missing XML comment for publicly visible type or member

		/// <summary>
		/// Hook data for the hook procedure set by <see cref="WindowsHook.ThreadCallWndProc"/>.
		/// More info: API <ms>CallWndProc</ms>.
		/// </summary>
		public unsafe struct ThreadCallWndProc {
			/// <summary>The caller object of your hook procedure. For example can be used to unhook.</summary>
			public readonly WindowsHook hook;

			/// <summary>
			/// True if the message was sent by another thread.
			/// </summary>
			public readonly bool sentByOtherThread; //note: incorrect info in MSDN

			/// <summary>
			/// Message parameters.
			/// API <ms>CWPSTRUCT</ms>.
			/// </summary>
			public readonly CWPSTRUCT* msg;

			internal ThreadCallWndProc(WindowsHook hook, nint wParam, nint lParam) {
				this.hook = hook;
				sentByOtherThread = 0 != wParam;
				msg = (CWPSTRUCT*)lParam;
			}
		}

		/// <summary>
		/// Hook data for the hook procedure set by <see cref="WindowsHook.ThreadCallWndProcRet"/>.
		/// More info: API <ms>CallWndRetProc</ms>.
		/// </summary>
		public unsafe struct ThreadCallWndProcRet {
			/// <summary>The caller object of your hook procedure. For example can be used to unhook.</summary>
			public readonly WindowsHook hook;

			/// <summary>
			/// True if the message was sent by another thread.
			/// </summary>
			public readonly bool sentByOtherThread; //note: incorrect info in MSDN

			/// <summary>
			/// Message parameters and the return value.
			/// API <ms>CWPRETSTRUCT</ms>.
			/// </summary>
			public readonly CWPRETSTRUCT* msg;

			internal ThreadCallWndProcRet(WindowsHook hook, nint wParam, nint lParam) {
				this.hook = hook;
				sentByOtherThread = 0 != wParam;
				msg = (CWPRETSTRUCT*)lParam;
			}
		}

		/// <summary>
		/// Calls API API <ms>ReplyMessage</ms>, which allows to use <see cref="elm"/> and COM in the hook procedure.
		/// </summary>
		/// <param name="cancelEvent">
		/// Don't notify the target window about the event, and don't call other hook procedures.
		/// This value is used instead of the return value of the hook procedure, which is ignored.
		/// </param>
		/// <remarks>
		/// It can be used as a workaround for this problem: in low-level hook procedure some functions don't work with some windows. For example cannot get a UI element or use a COM object. Error/exception "An outgoing call cannot be made since the application is dispatching an input-synchronous call (0x8001010D)".
		/// </remarks>
		public static void ReplyMessage(bool cancelEvent) => Api.ReplyMessage(cancelEvent ? 1 : 0);
	}
}


================================================
FILE: Au/Au.More/WinformsControlNames.cs
================================================
namespace Au.More;

/// <summary>
/// Gets programming names of .NET Windows Forms controls.
/// </summary>
/// <remarks>
/// Usually each control has a unique name. It's the <see cref="System.Windows.Forms.Control.Name"/> property. Useful to identify controls without a classic name/text.
/// The control id of these controls is not useful, it is not constant.
/// </remarks>
public sealed class WinformsControlNames : IDisposable {
	ProcessMemory _pm;
	wnd _w;
	
	///
	public void Dispose() {
		if (_pm != null) { _pm.Dispose(); _pm = null; }
		GC.SuppressFinalize(this);
	}
	
	static readonly int WM_GETCONTROLNAME = Api.RegisterWindowMessage("WM_GETCONTROLNAME");
	
	/// <summary>
	/// Prepares to get control names.
	/// </summary>
	/// <param name="w">Any top-level or child window of that process.</param>
	/// <exception cref="AuWndException"><i>w</i> invalid.</exception>
	/// <exception cref="AuException">Failed to allocate process memory (see <see cref="ProcessMemory"/>) needed to get control names, usually because of [](xref:uac).</exception>
	public WinformsControlNames(wnd w) {
		_pm = new ProcessMemory(w, 4096); //throws
		_w = w;
	}
	
	/// <summary>
	/// Gets control name.
	/// </summary>
	/// <returns><c>null</c> if failed or the name is empty.</returns>
	/// <param name="c">The control. Can be a top-level window too. Must be of the same process as the window specified in the constructor.</param>
	public string GetControlName(wnd c) {
		if (_pm == null) return null;
		if (!IsWinformsControl(c)) return null;
		if (!c.SendTimeout(5000, out var R, WM_GETCONTROLNAME, 4096, _pm.Mem) || (int)R < 1) return null;
		int len = (int)R - 1;
		if (len == 0) return "";
		return _pm.ReadCharString(len);
	}
	
	/// <summary>
	/// Returns <c>true</c> if window class name starts with <c>"WindowsForms"</c>.
	/// Usually it means that we can get Windows Forms control name of <i>w</i> and its child controls.
	/// </summary>
	/// <param name="w">The window. Can be top-level or control.</param>
	public static bool IsWinformsControl(wnd w) {
		return w.ClassNameIs("WindowsForms*");
	}
	
	/// <summary>
	/// Gets the programming name of a Windows Forms control.
	/// </summary>
	/// <returns><c>null</c> if it is not a Windows Forms control or if failed.</returns>
	/// <param name="c">The control. Can be top-level window too.</param>
	/// <remarks>
	/// This function is easy to use and does not throw exceptions. However, when you need names of multiple controls of a single window, better create a <see cref="WinformsControlNames"/> instance (once) and for each control call its <c>GetControlName</c> method, it will be faster.</remarks>
	public static string GetSingleControlName(wnd c) {
		if (!IsWinformsControl(c)) return null;
		try {
			using (var x = new WinformsControlNames(c)) return x.GetControlName(c);
		}
		catch { }
		return null;
	}
	
	//Don't use this cached version, it does not make significantly faster. Also, keeping process handle in such a way is not good, would need to use other thread to close it after some time.
	///// <summary>
	///// Gets programming name of a Windows Forms control.
	///// Returns <c>null</c> if it is not a Windows Forms control or if failed.
	///// </summary>
	///// <param name="c">The control. Can be top-level window too.</param>
	///// <remarks>When need to get control names repeatedly or quite often, this function can be faster than creating <see cref="WinformsControlNames"/> instance each time and calling its <c>GetControlName</c> method, because this function remembers the last used process etc. Also it is easier to use and does not throw exceptions.</remarks>
	//public static string GetSingleControlName(wnd c)
	//{
	//	if(!IsWinformsControl(c)) return null;
	//	uint pid = c.ProcessId; if(pid == 0) return null;
	//	lock (_prevLock) {
	//		if(pid != _prevPID || perf.ms - _prevTime > 1000) {
	//			if(_prev != null) { _prev.Dispose(); _prev = null; }
	//			try { _prev = new WinformsControlNames(c); } catch { }
	//			//print.it("new");
	//		} //else print.it("cached");
	//		_prevPID = pid; _prevTime = perf.ms;
	//		if(_prev == null) return null;
	//		return _prev.GetControlName(c);
	//	}
	//}
	//static WinformsControlNames _prev; static uint _prevPID; static long _prevTime; static object _prevLock = new object(); //cache
}


================================================
FILE: Au/Au.Types/ColorInt.cs
================================================
using System.Drawing;
using System.Text.Json.Serialization;

namespace Au.Types;

//rejected: /// <completionlist cref="Color"/>

/// <summary>
/// Color, as <c>int</c> in <c>0xAARRGGBB</c> format.
/// Can convert from/to <see cref="Color"/>, <see cref="System.Windows.Media.Color"/>, <c>int</c> (<c>0xAARRGGBB</c>), Windows <c>COLORREF</c> (<c>0xBBGGRR</c>), string.
/// </summary>
public record struct ColorInt {
	/// <summary>
	/// Color value in <c>0xAARRGGBB</c> format.
	/// </summary>
	[JsonInclude]
	public int argb;
	
	/// <param name="colorARGB">Color value in <c>0xAARRGGBB</c> or <c>0xRRGGBB</c> format.</param>
	/// <param name="makeOpaque">Set alpha = 0xFF. If <c>null</c> (default), sets alpha = 0xFF if it is 0 in <i>colorBGR</i>.</param>
	public ColorInt(int colorARGB, bool? makeOpaque = null) {
		if (makeOpaque == true || (makeOpaque == null && (colorARGB & ~0xFFFFFF) == 0)) colorARGB |= 0xFF << 24;
		argb = colorARGB;
	}
	
	/// <param name="colorARGB">Color value in <c>0xAARRGGBB</c> or <c>0xRRGGBB</c> format.</param>
	/// <param name="makeOpaque">Set alpha = 0xFF. If <c>null</c> (default), sets alpha = 0xFF if it is 0 in <i>colorBGR</i>.</param>
	public ColorInt(uint colorARGB, bool? makeOpaque) : this((int)colorARGB, makeOpaque) { }
	
	/// <summary>
	/// Converts from an <c>int</c> color value in <c>0xRRGGBB</c> or <c>0xAARRGGBB</c> format.
	/// Sets alpha = 0xFF if it is 0 in <i>color</i>.
	/// </summary>
	//[Obsolete] //to find all references
	public static implicit operator ColorInt(int color) => new(color);
	
	/// <summary>
	/// Converts from an <c>uint</c> color value in <c>0xRRGGBB</c> or <c>0xAARRGGBB</c> format.
	/// Sets alpha = 0xFF if it is 0 in <i>color</i>.
	/// </summary>
	//[Obsolete] //to find all references
	public static implicit operator ColorInt(uint color) => new((int)color);
	
	/// <summary>
	/// Converts from <see cref="Color"/>.
	/// </summary>
	public static implicit operator ColorInt(Color color) => new(color.ToArgb(), false);
	
	/// <summary>
	/// Converts from <see cref="System.Windows.Media.Color"/>.
	/// </summary>
	public static implicit operator ColorInt(System.Windows.Media.Color color)
		=> new((color.A << 24) | (color.R << 16) | (color.G << 8) | color.B, false);
	
	/// <summary>
	/// Converts from a color name (<see cref="Color.FromName(string)"/>) or string <c>"0xRRGGBB"</c> or <c>"#RRGGBB"</c>.
	/// </summary>
	/// <remarks>
	/// If <i>s</i> is a hex number that contains 6 or less hex digits, makes opaque (alpha 0xFF).
	/// If <i>s</i> is <c>null</c> or invalid, sets <c>c.argb = 0</c> and returns <c>false</c>.
	/// </remarks>
	public static bool FromString(string s, out ColorInt c) {
		c.argb = 0;
		if (s == null || s.Length < 2) return false;
		if (s[0] == '0' && s[1] == 'x') {
			c.argb = s.ToInt(0, out int end);
			if (end < 3) return false;
			if (end <= 8) c.argb |= unchecked((int)0xFF000000);
		} else if (s[0] == '#') {
			c.argb = s.ToInt(1, out int end, STIFlags.IsHexWithout0x);
			if (end < 2) return false;
			if (end <= 7) c.argb |= unchecked((int)0xFF000000);
		} else {
			c.argb = Color.FromName(s).ToArgb();
			if (c.argb == 0) return false; //invalid is 0, black is 0xFF000000
		}
		return true;
	}
	
	/// <summary>
	/// Converts from Windows native <c>COLORREF</c> (<c>0xBBGGRR</c> to <c>0xAARRGGBB</c>).
	/// </summary>
	/// <param name="colorBGR">Color in <c>0xBBGGRR</c> format.</param>
	/// <param name="makeOpaque">Set alpha = 0xFF. If <c>null</c> (default), sets alpha = 0xFF if it is 0 in <i>colorBGR</i>.</param>
	public static ColorInt FromBGR(int colorBGR, bool? makeOpaque = null) => new(SwapRB(colorBGR), makeOpaque);
	
	/// <summary>
	/// Converts to Windows native <c>COLORREF</c> (<c>0xBBGGRR</c> from <c>0xAARRGGBB</c>).
	/// </summary>
	/// <returns>color in <c>COLORREF</c> format. Does not modify this variable.</returns>
	/// <param name="zeroAlpha">Set the alpha byte = 0.</param>
	public int ToBGR(bool zeroAlpha = true) {
		var r = SwapRB(argb);
		if (zeroAlpha) r &= 0xFFFFFF;
		return r;
	}
	
	//rejected. Easy to create bugs when actually need BGR. Let use ToBGR() when need BGR, or argb field when need ARGB.
	///// <summary>Returns <c>c.argb</c>.</summary>
	//public static explicit operator int(ColorInt c) => c.argb;
	
	///// <summary>Returns <c>(uint)c.argb</c>.</summary>
	//public static explicit operator uint(ColorInt c) => (uint)c.argb;
	
	/// <summary>Converts to <see cref="Color"/>.</summary>
	public static explicit operator Color(ColorInt c) => Color.FromArgb(c.argb);
	
	/// <summary>Converts to <see cref="System.Windows.Media.Color"/>.</summary>
	public static explicit operator System.Windows.Media.Color(ColorInt c) {
		uint k = (uint)c.argb;
		return System.Windows.Media.Color.FromArgb((byte)(k >> 24), (byte)(k >> 16), (byte)(k >> 8), (byte)k);
	}
	
	internal static System.Windows.Media.Color WpfColor_(int rgb)
		=> System.Windows.Media.Color.FromRgb((byte)(rgb >> 16), (byte)(rgb >> 8), (byte)rgb);
	
	internal static System.Windows.Media.SolidColorBrush WpfBrush_(int rgb)
		=> new(WpfColor_(rgb));
	
	///// <summary>
	///// <c>FromBGR(GetSysColor)</c>.
	///// </summary>
	//internal static ColorInt FromSysColor_(int colorIndex) => FromBGR(Api.GetSysColor(colorIndex), true);
	
	///
	public override string ToString() => "#" + argb.ToString("X8");
	
	/// <summary>
	/// Converts color from ARGB (<c>0xAARRGGBB</c>) to ABGR (<c>0xAABBGGRR</c>) or vice versa (swaps the red and blue bytes).
	/// ARGB is used in .NET, GDI+ and HTML/CSS.
	/// ABGR is used by most Windows API; aka <c>COLORREF</c>.
	/// </summary>
	public static int SwapRB(int color) => (color & unchecked((int)0xff00ff00)) | (color << 16 & 0xff0000) | (color >> 16 & 0xff);
	
	/// <inheritdoc cref="SwapRB(int)"/>
	public static uint SwapRB(uint color) => (color & 0xff00ff00) | (color << 16 & 0xff0000) | (color >> 16 & 0xff);
	
	//rejected. Unclear usage. Instead let users call ToHLS, change L how they want, and call FromHLS.
	///// <summary>
	///// Changes color's luminance (makes darker or brighter).
	///// Returns new color. Does not modify this variable.
	///// </summary>
	///// <param name="n">The luminance in units of 0.1 percent of the range (which depends on <i>totalRange</i>). Can be from -1000 to 1000.</param>
	///// <param name="totalRange">If <c>true</c>, <i>n</i> is in whole luminance range (from minimal to maximal possible). If <c>false</c>, <i>n</i> is in the range from current luminance of the color to the maximal (if n positive) or minimal (if n negative) luminance.</param>
	///// <remarks>
	///// Calls API <ms>ColorAdjustLuma</ms>.
	///// Does not change hue and saturation. Does not use alpha.
	///// </remarks>
	//internal ColorInt AdjustLuminance(int n, bool totalRange = false) {
	//	uint u = (uint)argb;
	//	u = Api.ColorAdjustLuma(u & 0xffffff, n, !totalRange) | (u & 0xFF000000);
	//	return new((int)u, false);
	//	//tested: with SwapRB the same.
	//}
	
	/// <summary>
	/// Converts from hue-luminance-saturation (HLS).
	/// </summary>
	/// <param name="H">Hue, 0 to 240.</param>
	/// <param name="L">Luminance, 0 to 240.</param>
	/// <param name="S">Saturation, 0 to 240.</param>
	/// <param name="bgr">Return color in <c>0xBBGGRR</c> format. If <c>false</c>, <c>0xRRGGBB</c>.</param>
	/// <returns>Color in <c>0xRRGGBB</c> or <c>0xBBGGRR</c> format, depending on <i>bgr</i>. Alpha 0.</returns>
	public static int FromHLS(int H, int L, int S, bool bgr) {
		if (S == 0) { //ColorHLSToRGB bug: returns 0 if S 0
			int i = L * 255 / 240;
			return i | (i << 8) | (i << 16);
		}
		int color = Api.ColorHLSToRGB((ushort)H, (ushort)L, (ushort)S);
		if (!bgr) color = SwapRB(color);
		return color;
	}
	
	/// <summary>
	/// Converts to hue-luminance-saturation (HLS).
	/// </summary>
	/// <param name="color">Color in <c>0xRRGGBB</c> or <c>0xBBGGRR</c> format, depending on <i>bgr</i>. Ignores alpha.</param>
	/// <param name="bgr"><i>color</i> is in <c>0xBBGGRR</c> format. If <c>false</c>, <c>0xRRGGBB</c>.</param>
	/// <returns>Hue, luminance and saturation. All 0 to 240.</returns>
	public static (int H, int L, int S) ToHLS(int color, bool bgr) {
		if (!bgr) color = SwapRB(color);
		Api.ColorRGBToHLS(color, out var H, out var L, out var S);
		return (H, L, S);
	}
	
	/// <summary>
	/// Calculates color's perceived brightness.
	/// </summary>
	/// <returns>0 to 1.</returns>
	/// <param name="color">Color in <c>0xRRGGBB</c> or <c>0xBBGGRR</c> format, depending on <i>bgr</i>. Ignores alpha.</param>
	/// <param name="bgr"><i>color</i> is in <c>0xBBGGRR</c> format. If <c>false</c>, <c>0xRRGGBB</c>.</param>
	/// <remarks>
	/// Unlike <see cref="ToHLS"/> and <see cref="Color.GetBrightness"/>, this function uses different weights for red, green and blue components.
	/// Ignores alpha.
	/// </remarks>
	public static float GetPerceivedBrightness(int color, bool bgr) {
		uint u = (uint)color;
		if (bgr) u = SwapRB(u);
		uint R = u >> 16 & 0xff, G = u >> 8 & 0xff, B = u & 0xff;
		return (float)(Math.Sqrt(R * R * .299 + G * G * .587 + B * B * .114) / 255);
	}
	
	//same result as ColorAdjustLuma. Probably slower.
	//internal static int SetLuminance(int color, bool bgr, double percent, bool totalRange) {
	//	var (H, L, S) = ToHLS(color, bgr);
	//	L = (int)Math2.PercentToValue(totalRange ? 240 : L, percent);
	//	return (int)((uint)FromHLS(H, Math.Clamp(L, 0, 240), S, bgr) | (color & 0xFF000000));
	//}
}


================================================
FILE: Au/Au.Types/JSettings.cs
================================================
using System.Text.Json;
using System.Text.Json.Serialization;

namespace Au.Types;

/// <summary>
/// Base of record classes that contain various settings as public fields or properties. Loads and lazily auto-saves from/to a JSON file.
/// </summary>
/// <remarks>
/// All functions are thread-safe.
/// </remarks>
/// <example>
/// <code><![CDATA[
/// MySettings sett = MySettings.Load(); //in a class you would use a static field or property, but this example uses a local variable for simplicity
/// 
/// print.it(sett.i);
/// sett.i++;
/// 
/// if (dialog.showInput(out string s, "example", editText: sett.s)) {
/// 	sett.s = s;
/// 	
/// 	print.it("old array:", sett.a);
/// 	if ((!sett.a.Contains(s))) sett.a = sett.a.InsertAt(-1, s);
/// 	
/// 	print.it("old dictionary:", sett.d);
/// 	sett.d[s] = DateTime.Now;
/// }
/// 
/// 
/// record class MySettings : JSettings {
/// 	public static readonly string File = folders.ThisAppDocuments + @"MySettings.json";
/// 
/// 	public static MySettings Load() => Load<MySettings>(File);
/// 	
/// 	// examples of settings
/// 	public int i;
/// 	public string s = "default";
/// 	public string[] a = [];
/// 	public Dictionary<string, DateTime> d = new();
/// }
/// ]]></code>
/// </example>
public abstract record class JSettings : IDisposable {
	string _file;
	bool _loadedFile;
	byte[] _old;
	JsonSerializerOptions _jsOpt;
	readonly object _lock = new();
	
	static readonly List<JSettings> s_list = new();
	static int s_loadedOnce;
	
	/// <summary>
	/// Loads a JSON file and deserializes to an object of type <c>T</c>, or creates a new object of type <c>T</c>.
	/// </summary>
	/// <returns>Object of type <c>T</c>. Either deserialized from file or new object with default values.</returns>
	/// <param name="file">Full path of <c>.json</c> file. If <c>null</c>, does not load and will not save.</param>
	/// <param name="useDefault">Use default settings. Don't load from <i>file</i>. Delete <i>file</i> if exists.</param>
	/// <param name="useDefaultOnError">What to do if failed to load or parse the file: <c>true</c> (default) - backup (rename) the file and use default settings; <c>false</c> - throw exception (for example <see cref="JsonException"/> if invalid JSON); <c>null</c> - show dialog with options to exit or use default settings.</param>
	/// <param name="jsOpt">Options for deserializing and serializing. If <c>null</c>, uses <see cref="SerializerOptions"/>.</param>
	/// <exception cref="ArgumentException">Not full path.</exception>
	/// <exception cref="NotSupportedException">Field type not supported by <see cref="JsonSerializer"/>.</exception>
	protected static T Load<T>(string file, bool useDefault = false, bool? useDefaultOnError = true, JsonSerializerOptions jsOpt = null) where T : JSettings
		=> (T)_Load(file, typeof(T), useDefault, useDefaultOnError, jsOpt);
	
	static JSettings _Load(string file, Type type, bool useDefault, bool? useDefaultOnError, JsonSerializerOptions jsOpt) {
		if (file == null) return Activator.CreateInstance(type) as JSettings;
		
		jsOpt ??= SerializerOptions;
		
		JSettings R = null;
		file = pathname.normalize(file);
		if (filesystem.exists(file, true)) {
			try {
				if (useDefault) {
					filesystem.delete(file);
				} else {
					//using var p1 = perf.local(); //first time ~40 ms (similar hot and cold)
					var b = filesystem.loadBytes(file);
					//p1.Next('f');
					R = JsonSerializer.Deserialize(b, type, jsOpt) as JSettings;
					//p1.Next('d');
					R._loadedFile = true;
				}
			}
			catch (Exception ex) when (ex is not NotSupportedException) {
				if (!useDefault) {
					if (useDefaultOnError == false) throw;
					if (useDefaultOnError == true) {
						string backup = file + ".backup";
						filesystem.move(file, backup, FIfExists.Delete); //note: don't try/catch
						print.it($"<>Failed to load settings from {file}. Will use default settings.\r\n\t<\a>{ex.ToStringWithoutStack()}</\a>\r\n\tBackup: <explore>{backup}<>");
					} else {
						if (!Environment.UserInteractive) throw;
						int button = dialog.show("Failed to load settings",
							new($"{ex.ToStringWithoutStack()}\n\n<a>{file}</a>", o => { run.selectInExplorer(file); }),
							"1 Exit|2 Backup (rename) the file and use default settings",
							flags: DFlags.CommandLinks,
							icon: DIcon.Error);
						if (button == 1) Environment.Exit(1);
						else if (filesystem.exists(file)) filesystem.move(file, file + ".backup", FIfExists.Delete);
					}
				}
			}
		}
		
		R ??= Activator.CreateInstance(type) as JSettings;
		
		R._Ctor2(file, jsOpt);
		
		//autosave
		if (Interlocked.Exchange(ref s_loadedOnce, 1) == 0) {
			run.thread(() => {
				for (; ; ) {
					Thread.Sleep(2000);
					//Debug_.MemorySetAnchor();
					_SaveAllIfNeed(true);
					//Debug_.MemoryPrint(); //editor ~6 KB
				}
			}, sta: false).Name = "Au.JSettings";
			
			process.thisProcessExit += _ => { //info: .NET does not call finalizers when process exits
				FileWatcher.DisposeAll_();
				_SaveAllIfNeed(false);
				s_list.Clear();
			};
		}
		
		lock (s_list) s_list.Add(R);
		
		return R;
		
		static void _SaveAllIfNeed(bool timer) {
			JSettings[] a; //can't lock both s_list and _lock (possible deadlock)
			lock (s_list) { a = s_list.ToArray(); }
			
			foreach (var v in a) {
				if (v.NoAutoSave) continue;
				if (timer && v.NoAutoSaveTimer) continue;
				v.SaveIfNeed();
			}
		}
	}
	
	void _Ctor2(string file, JsonSerializerOptions jsOpt) {
		_file = file;
		_jsOpt = jsOpt;
		_old = JsonSerializer.SerializeToUtf8Bytes(this, GetType(), _jsOpt);
	}
	
	/// <summary>
	/// Saves now if need, and releases used resources. In the future will not save or reload.
	/// Don't need to call if the settings are used until process exit.
	/// </summary>
	public void Dispose() {
		Dispose(true);
		//no finalizer. Users can call Dispose, but usually settings objects live until process exit.
	}
	
	///
	protected virtual void Dispose(bool disposing) {
		lock (s_list) if (!s_list.Remove(this)) return; //note: not inside `lock (_lock)` (possible deadlock)
		
		lock (_lock) {
			_watcher?.Dispose();
			_watcher = null;
			_modifiedExternally = null;
			if (!NoAutoSave) SaveIfNeed();
			_file = null;
		}
	}
	
	//repeated serialization speed with same options ~50 times better, eg 15000 -> 300 mcs cold. It's documented. Can be shared by multiple types.
	static readonly Lazy<JsonSerializerOptions> s_jsOptions = new(() => new() {
		AllowTrailingCommas = true,
		DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull,
		Encoder = System.Text.Encodings.Web.JavaScriptEncoder.UnsafeRelaxedJsonEscaping,
		IncludeFields = true,
		IgnoreReadOnlyFields = true,
		IgnoreReadOnlyProperties = true,
		WriteIndented = true,
	});
	
	/// <summary>
	/// Default deserialization and serialization options.
	/// </summary>
	/// <value>
	/// <code><![CDATA[
	/// 	AllowTrailingCommas = true,
	/// 	DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull,
	/// 	Encoder = JavaScriptEncoder.UnsafeRelaxedJsonEscaping,
	/// 	IncludeFields = true,
	/// 	IgnoreReadOnlyFields = true,
	/// 	IgnoreReadOnlyProperties = true,
	/// 	WriteIndented = true,
	/// ]]></code>
	/// </value>
	public static JsonSerializerOptions SerializerOptions => s_jsOptions.Value;
	
	/// <summary>
	/// <c>true</c> if settings were loaded from file.
	/// </summary>
	/// <remarks>
	/// Returns <c>false</c> if <see cref="Load"/> did not find the file (the settings were not saved) or failed to load/parse or parameter <i>useDefault</i> = <c>true</c> or parameter <i>file</i> = <c>null</c>.
	/// </remarks>
	[JsonIgnore]
	public bool LoadedFile => _loadedFile;
	
	/// <summary>
	/// Don't automatically call <see cref="SaveIfNeed"/>.
	/// If <c>false</c> (default), calls every 2 s (unless <see cref="NoAutoSaveTimer"/> <c>true</c>); also when disposing and when the process exits.
	/// </summary>
	protected bool NoAutoSave { get; set; }
	
	/// <summary>
	/// Don't call <see cref="SaveIfNeed"/> every 2 s.
	/// Default <c>false</c>.
	/// </summary>
	protected bool NoAutoSaveTimer { get; set; }
	
	/// <summary>
	/// Saves now if need.
	/// Call this when you want to save changed settings immediately; else the changes are auto-saved after max 2 s. See also <see cref="NoAutoSave"/> and <see cref="NoAutoSaveTimer"/>.
	/// </summary>
	public void SaveIfNeed() {
		lock (_lock) {
			if (_file is null) return;
			bool save = false;
			try {
				var b = JsonSerializer.SerializeToUtf8Bytes(this, GetType(), _jsOpt);
				save = !b.AsSpan().SequenceEqual(_old);
				if (save) {
					_watcher?.Paused = true;
					filesystem.saveBytes(_file, b);
					_old = b;
				}
			}
			catch (Exception ex) { print.it($"Failed to save settings to '{_file}'. {ex}"); }
			finally { if (save) _watcher?.Paused = false; }
		}
	}
	
	/// <summary>
	/// When detected that the settings file was externally modified or deleted (for example by another process of your program).
	/// </summary>
	/// <remarks>
	/// Your event handler can call <see cref="Reload"/>.
	/// 
	/// Runs in a thread pool thread.
	/// </remarks>
	/// <exception cref="NotSupportedException">Multiple <see cref="JSettings"/> objects in this process use the same file.</exception>
	public event Action ModifiedExternally {
		add {
			lock (_lock) {
				if (_file is null) return;
				_modifiedExternally += value ?? throw null;
				_watcher ??= FileWatcher.Watch(_file, _modifiedExternally);
			}
		}
		remove {
			lock (_lock) {
				_modifiedExternally -= value;
				if (_modifiedExternally == null) { _watcher?.Dispose(); _watcher = null; }
			}
		}
	}
	
	event Action _modifiedExternally;
	FileWatcher _watcher;
	
	/// <summary>
	/// Reloads settings from the file.
	/// </summary>
	/// <param name="newSettings">
	/// Receives a new settings object that inherits the behavior of this object but contains updated values of fields defined in the derived class. If the file does not exist, the fields have default values.
	/// If failed, receives this object (unchanged).
	/// </param>
	/// <returns><c>false</c> if failed.</returns>
	/// <remarks>
	/// Disposes this object. Does not change field values in it. It will no longer be tracked (e.g., for auto-save); tracking continues with the new object.
	/// </remarks>
	/// <example>
	/// Run this 2 times to test how a process of your app auto-reloads settings changed by another process of your app.
	/// <code><![CDATA[
	/// /*/ ifRunning run; /*/
	/// 
	/// var sett = Settings.Load();
	/// sett.ModifiedExternally += () => {
	/// 	if (!sett.Reload(out sett)) return;
	/// 	print.it($"ModifiedExternally. This process: {process.thisProcessId}. {sett}");
	/// };
	/// 
	/// var b = new wpfBuilder("JSettings example").WinSize(300).Columns(-1, -1, -1);
	/// b.R.AddButton("Print", _ => { print.it(sett); });
	/// b.AddButton("one++", _ => { sett.one++; sett.SaveIfNeed(); });
	/// b.AddButton("two++", _ => { sett.two++; sett.SaveIfNeed(); });
	/// b.Window.Topmost = true;
	/// b.ShowDialog();
	/// 
	/// record Settings : JSettings {
	/// 	public static Settings Load() => Load<Settings>(@"C:\Test\JSettings.json");
	/// 	
	/// #pragma warning disable CS0649
	/// 	public int one;
	/// 	public int two = 100;
	/// }
	/// ]]></code>
	/// </example>
	public bool Reload<T>(out T newSettings) where T : JSettings {
		bool ok = _Reload(out var js);
		newSettings = js as T;
		return ok;
	}
	
	bool _Reload(out JSettings newSettings) {
		newSettings = this;
		JSettings R;
		
		lock (_lock) {
			if (_file is null) {
				print.warning($"JSettings.Reload called for a disposed or momory-only settings object");
				return false;
			}
			
			try {
				if (filesystem.exists(_file, true)) {
					var b = filesystem.loadBytes(_file);
					R = JsonSerializer.Deserialize(b, GetType(), _jsOpt) as JSettings;
					R._loadedFile = true;
				} else {
					R = Activator.CreateInstance(GetType()) as JSettings;
				}
			}
			catch (Exception ex) {
				print.warning($"Failed to reload settings from '{_file}'. {ex}", -1);
				return false;
			}
			
			R._Ctor2(_file, _jsOpt);
			R.NoAutoSave = NoAutoSave;
			R.NoAutoSaveTimer = NoAutoSaveTimer;
			R._watcher = _watcher; _watcher = null;
			R._modifiedExternally = _modifiedExternally; _modifiedExternally = null;
			_file = null;
		}
		
		lock (s_list) { s_list[s_list.IndexOf(this)] = R; } //note: not inside `lock (_lock)` (possible deadlock)
		newSettings = R;
		return true;
	}
}


================================================
FILE: Au/Au.Types/TreeBase.cs
================================================
using System.Xml;

namespace Au.Types;

/// <summary>
/// Base class for tree classes.
/// The tree can be loaded/saved as XML.
/// </summary>
/// <remarks>
/// Implemented in the same way as <see cref="System.Xml.Linq.XContainer"/>.
/// </remarks>
/// <example>
/// Shows how to declare a <c>TreeBase</c>-derived class, load tree of nodes from an XML file, find descendant nodes, save the tree to an XML file.
/// <code><![CDATA[
/// using System.Xml;
/// 
/// class MyTree : TreeBase<MyTree> {
/// 	public string Name { get; set; }
/// 	public int Id { get; private set; }
/// 	public bool IsFolder { get; private set; }
/// 
/// 	public MyTree(string name, int id, bool isFolder) { Name = name; Id = id; IsFolder = isFolder; }
/// 
/// 	//XML element -> MyTree object
/// 	MyTree(XmlReader x, MyTree parent)
/// 	{
/// 		if(parent == null) { //the root XML element
/// 			if(x.Name != "example") throw new ArgumentException("XML root element must be 'example'");
/// 			IsFolder = true;
/// 		} else {
/// 			switch(x.Name) {
/// 			case "e": break;
/// 			case "f": IsFolder = true; break;
/// 			default: throw new ArgumentException("XML element must be 'e' or 'f'");
/// 			}
/// #if true //two ways of reading attributes
/// 			Name = x["name"];
/// 			Id = x["id"].ToInt();
/// #else
/// 			while(x.MoveToNextAttribute()) {
/// 				var v = x.Value;
/// 				switch(x.Name) {
/// 				case "name": Name = v; break;
/// 				case "id": Id = v.ToInt(); break;
/// 				}
/// 			}
/// #endif
/// 			if(Name.NE()) throw new ArgumentException("no 'name' attribute in XML");
/// 			if(Id == 0) throw new ArgumentException("no 'id' attribute in XML");
/// 		}
/// 	}
/// 
/// 	public static MyTree Load(string file) => XmlLoad(file, (x, p) => new MyTree(x, p));
/// 
/// 	public void Save(string file) => XmlSave(file, (x, n) => n._XmlWrite(x));
/// 
/// 	//MyTree object -> XML element
/// 	void _XmlWrite(XmlWriter x)
/// 	{
/// 		if(Parent == null) {
/// 			x.WriteStartElement("example");
/// 		} else {
/// 			x.WriteStartElement(IsFolder ? "f" : "e");
/// 			x.WriteAttributeString("name", Name);
/// 			x.WriteAttributeString("id", Id.ToString());
/// 		}
/// 	}
/// 
/// 	public override string ToString() => $"{new string(' ', Level)}{(IsFolder ? 'f' : 'e')} {Name} ({Id})";
/// }
/// 
/// static void TNodeExample() {
/// 	/*
/// 	<example>
/// 	  <e name="one" id="1" />
/// 	  <f name="two" id="112">
/// 		<e name="three" id="113" />
/// 		<e name="four" id="114" />
/// 		<f name="five" id="120">
/// 		  <e name="six" id="121" />
/// 		  <e name="seven" id="122" />
/// 		</f>
/// 	  </f>
/// 	  <f name="eight" id="217" />
/// 	  <e name="ten" id="144" />
/// 	</example>
/// 	*/
/// 
/// 	var x = MyTree.Load(@"C:\test\example.xml");
/// 	foreach(MyTree n in x.Descendants(true)) print.it(n);
/// 	//print.it(x.Descendants().FirstOrDefault(k => k.Name == "seven")); //find a descendant
/// 	//print.it(x.Descendants().Where(k => k.Level > 2)); //find some descendants
/// 	x.Save(@"C:\test\example2.xml");
/// }
/// ]]></code>
/// </example>
public abstract class TreeBase<T> where T : TreeBase<T> {
	T _next;
	T _parent;
	T _lastChild;

	#region properties

	/// <summary>
	/// Returns the parent node. Can be <c>null</c>.
	/// </summary>
	public T Parent => _parent;

	/// <summary>
	/// Returns the root ancestor node. Its <see cref="Parent"/> is <c>null</c>.
	/// Returns this node if its <c>Parent</c> is <c>null</c>.
	/// </summary>
	public T RootAncestor {
		get {
			var p = this as T;
			while (p._parent != null) p = p._parent;
			return p;
		}
	}

	/// <summary>
	/// Gets the number of ancestors (parent, its parent and so on).
	/// </summary>
	public int Level {
		get {
			int R = 0;
			for (var p = _parent; p != null; p = p._parent) R++;
			return R;
		}
	}

	/// <summary>
	/// Returns <c>true</c> if this node is a descendant of node <i>n</i>.
	/// </summary>
	/// <param name="n">Can be <c>null</c>.</param>
	public bool IsDescendantOf(T n) {
		for (var p = _parent; p != null; p = p._parent) if (p == n) return true;
		return false;
	}

	/// <summary>
	/// Returns <c>true</c> if this node is a descendant of nearest ancestor node for which <i>predicate</i> returns <c>true</c>.
	/// </summary>
	public bool IsDescendantOf(Func<T, bool> predicate) {
		for (var p = _parent; p != null; p = p._parent) if (predicate(p)) return true;
		return false;
	}

	/// <summary>
	/// Returns <c>true</c> if this node is an ancestor of node <i>n</i>.
	/// </summary>
	/// <param name="n">Can be <c>null</c>.</param>
	public bool IsAncestorOf(T n) => n?.IsDescendantOf(this as T) ?? false;

	/// <summary>
	/// Returns <c>true</c> if <see cref="Parent"/> is not <c>null</c>.
	/// </summary>
	public bool HasParent => _parent != null;

	/// <summary>
	/// Returns <c>true</c> if this node has child nodes.
	/// </summary>
	public bool HasChildren => _lastChild != null;

	/// <summary>
	/// Gets the last child node, or <c>null</c> if none.
	/// </summary>
	public T LastChild => _lastChild;

	/// <summary>
	/// Gets the first child node, or <c>null</c> if none.
	/// </summary>
	public T FirstChild => _lastChild?._next;

	/// <summary>
	/// Gets next sibling node, or <c>null</c> if none.
	/// </summary>
	public T Next => _parent == null || this == _parent._lastChild ? null : _next;

	/// <summary>
	/// Gets previous sibling node, or <c>null</c> if none.
	/// </summary>
	/// <remarks>
	/// Can be slow if there are many siblings. This class does not have a "previous" field and therefore has to walk the linked list of siblings.
	/// </remarks>
	public T Previous {
		get {
			if (_parent == null) return null;
			T n = _parent._lastChild._next;
			Debug.Assert(n != null);
			T p = null;
			while (n != this) {
				p = n;
				n = n._next;
			}
			return p;
		}
	}

	/// <summary>
	/// Returns 0-based index of this node in parent.
	/// Returns -1 if no parent.
	/// </summary>
	/// <remarks>
	/// Can be slow if there are many siblings. This class does not have an "index" field and therefore has to walk the linked list of siblings.
	/// </remarks>
	public int Index {
		get {
			var p = _parent;
			if (p != null) {
				var n = p._lastChild;
				for (int i = 0; ; i++) {
					n = n._next;
					if (n == this) return i;
				}
			}
			return -1;
		}
	}

	#endregion

	#region methods

	void _AddCommon(T n) {
		if (n == null || n._parent != null || n == RootAncestor) throw new ArgumentException();
		n._parent = this as T;
	}

	/// <summary>
	/// Adds node <i>n</i> to this node as a child.
	/// </summary>
	/// <param name="n"></param>
	/// <param name="first">Insert <i>n</i> as the first child node. If <c>false</c> (default), appends to the end.</param>
	/// <exception cref="ArgumentException"><i>n</i> is <c>null</c>, or has parent (need to <see cref="Remove"/> at first), or is this node, or an ancestor of this node.</exception>
	public void AddChild(T n, bool first = false) {
		_AddCommon(n);
		if (_lastChild == null) { //our first child!
			n._next = n; //n now is LastChild and FirstChild
		} else {
			n._next = _lastChild._next; //_next of _lastChild is FirstChild
			_lastChild._next = n;
			if (first) return;
		}
		_lastChild = n;
	}

	/// <summary>
	/// Inserts node <i>n</i> before or after this node as a sibling.
	/// </summary>
	/// <param name="n"></param>
	/// <param name="after">Insert <i>n</i> after this node. If <c>false</c> (default), inserts before this node.</param>
	/// <exception cref="ArgumentException">See <see cref="AddChild"/>.</exception>
	/// <exception cref="InvalidOperationException">This node does not have parent (<see cref="Parent"/> is <c>null</c>).</exception>
	public void AddSibling(T n, bool after) {
		if (_parent == null) throw new InvalidOperationException("no parent");
		_parent._Insert(n, this as T, after);
	}

	void _Insert(T n, T anchor, bool after) {
		if (after && anchor == _lastChild) { //after last child
			AddChild(n);
		} else if (!after && anchor == _lastChild._next) { //before first child
			AddChild(n, true);
		} else {
			_AddCommon(n);
			T prev, next;
			if (after) { prev = anchor; next = anchor._next; } else { prev = anchor.Previous; next = anchor; }
			n._next = next;
			prev._next = n;
		}
	}

	/// <summary>
	/// Removes this node from its parent.
	/// </summary>
	/// <remarks>
	/// After removing, the <see cref="Parent"/> property is <c>null</c>.
	/// Does nothing if <c>Parent</c> is <c>null</c>.
	/// </remarks>
	public void Remove() => _parent?._Remove(this as T);

	void _Remove(T n) {
		Debug.Assert(n?._parent == this);

		T p = _lastChild;
		while (p._next != n) p = p._next;
		if (p == n) {
			_lastChild = null;
		} else {
			if (_lastChild == n) _lastChild = p;
			p._next = n._next;
		}
		n._parent = null;
		n._next = null;
	}

	/// <summary>
	/// Gets ancestor nodes. The order is from this node towards the root node.
	/// </summary>
	/// <param name="andSelf">Include this node.</param>
	/// <param name="noRoot">Don't include <see cref="RootAncestor"/>.</param>
	public IEnumerable<T> Ancestors(bool andSelf = false, bool noRoot = false) {
		var n = andSelf ? this as T : _parent;
		while (n != null) {
			if (noRoot && n._parent == null) break;
			yield return n;
			n = n._parent;
		}
	}

	/// <summary>
	/// Gets ancestor nodes. The order is from the root node towards this node.
	/// </summary>
	/// <param name="andSelf">Include this node. Default <c>false</c>.</param>
	/// <param name="noRoot">Don't include <see cref="RootAncestor"/>.</param>
	public T[] AncestorsFromRoot(bool andSelf = false, bool noRoot = false) {
		T nFrom = andSelf ? this as T : _parent;
		//count
		int len = 0;
		for (var n = nFrom; n != null; n = n._parent) {
			if (noRoot && n._parent == null) break;
			len++;
		}
		//array
		if (len == 0) return [];
		var a = new T[len];
		for (var n = nFrom; len > 0; n = n._parent) a[--len] = n;
		return a;

		//info: can use LINQ Reverse, but this func makes less garbage.
	}

	/// <summary>
	/// Gets all direct child nodes.
	/// </summary>
	/// <param name="andSelf">Include this node. Default <c>false</c>.</param>
	public IEnumerable<T> Children(bool andSelf = false) {
		if (andSelf) yield return this as T;
		if (_lastChild != null) {
			var n = _lastChild;
			do {
				n = n._next;
				yield return n;
			} while (n != _lastChild);
		}
	}

	/// <summary>
	/// Gets number of direct child nodes.
	/// </summary>
	public int Count {
		get {
			int r = 0;
			if (_lastChild != null) {
				var n = _lastChild;
				do { r++; } while ((n = n._next) != _lastChild);
			}
			return r;
		}
	}

	/// <summary>
	/// Gets all descendant nodes (direct children, their children and so on).
	/// </summary>
	/// <param name="andSelf">Include this node. Default <c>false</c>.</param>
	/// <param name="stepInto">If not <c>null</c>, called for each descendant node that has children. Let it return <c>false</c> to skip descendants of that node.</param>
	public IEnumerable<T> Descendants(bool andSelf = false, Func<T, bool> stepInto = null) {
		var n = this as T;
		if (andSelf) yield return n;
		while (true) {
			T last = n._lastChild;
			if (last != null && !(stepInto is {  } si && n != this && !si(n))) {
				n = last._next;
			} else {
				while (n != null && n != this && n == n._parent._lastChild) n = n._parent;
				if (n == null || n == this) break;
				n = n._next;
			}
			yield return n;
		}
	}

	#endregion

	#region XML

	/// <summary>
	/// Used with <see cref="XmlLoad"/>
	/// </summary>
	protected delegate T XmlNodeReader(XmlReader x, T parent);

	/// <summary>
	/// Used with <see cref="XmlSave"/>
	/// </summary>
	protected delegate void XmlNodeWriter(XmlWriter x, T node);

	/// <summary>
	/// Loads XML file and creates tree of nodes from it.
	/// </summary>
	/// <returns>the root node.</returns>
	/// <param name="file">XML file. Must be full path. Can contain environment variables etc, see <see cref="pathname.expand"/>.</param>
	/// <param name="nodeReader">Callback function that reads current XML element and creates/returns new node. See example.</param>
	/// <exception cref="ArgumentException">Not full path.</exception>
	/// <exception cref="Exception">Exceptions of <see cref="XmlReader.Create(string)"/>.</exception>
	/// <exception cref="XmlException">An error occurred while parsing the XML.</exception>
	/// <example><see cref="TreeBase{T}"/></example>
	protected static T XmlLoad(string file, XmlNodeReader nodeReader) {
		file = pathname.NormalizeMinimally_(file);
		var xs = new XmlReaderSettings() { IgnoreComments = true, IgnoreProcessingInstructions = true, IgnoreWhitespace = true };
		using var r = filesystem.waitIfLocked(() => XmlReader.Create(file, xs));
		return XmlLoad(r, nodeReader);
	}

	/// <summary>
	/// Reads XML and creates tree of nodes.
	/// </summary>
	/// <returns>the root node.</returns>
	/// <param name="x"></param>
	/// <param name="nodeReader">Callback function that reads current XML element and creates/returns new node.</param>
	/// <exception cref="XmlException">An error occurred while parsing the XML.</exception>
	/// <example><see cref="TreeBase{T}"/></example>
	protected static T XmlLoad(XmlReader x, XmlNodeReader nodeReader) {
		Not_.Null(x, nodeReader);
		T root = null, parent = null;
		while (x.Read()) {
			var nodeType = x.NodeType;
			if (nodeType == XmlNodeType.Element) {
				var n = nodeReader(x, parent);
				if (root == null) root = n;
				else parent.AddChild(n);
				x.MoveToElement();
				if (!x.IsEmptyElement) parent = n;
			} else if (nodeType == XmlNodeType.EndElement) {
				if (parent == null) break;
				if (parent == root) break;
				parent = parent._parent;
			}
		}
		return root;
	}

	/// <summary>
	/// Saves tree of nodes (this and descendants) to an XML file.
	/// </summary>
	/// <param name="file">XML file. Must be full path. Can contain environment variables etc, see <see cref="pathname.expand"/>.</param>
	/// <param name="nodeWriter">Callback function that writes node's XML start element (see <see cref="XmlWriter.WriteStartElement(string)"/>) and attributes (see <see cref="XmlWriter.WriteAttributeString(string, string)"/>). Must not write children and end element. Also should not write value, unless your reader knows how to read it.</param>
	/// <param name="sett">XML formatting settings. Optional.</param>
	/// <param name="children">If not <c>null</c>, writes these nodes as if they were children of this node.</param>
	/// <exception cref="ArgumentException">Not full path.</exception>
	/// <exception cref="Exception">Exceptions of <see cref="XmlWriter.Create(string)"/> and other <see cref="XmlWriter"/> methods.</exception>
	/// <remarks>
	/// Uses <see cref="filesystem.save"/>. It ensures that existing file data is not damaged on exception etc.
	/// </remarks>
	/// <example><see cref="TreeBase{T}"/></example>
	protected void XmlSave(string file, XmlNodeWriter nodeWriter, XmlWriterSettings sett = null, IEnumerable<T> children = null) {
		file = pathname.NormalizeMinimally_(file);
		sett ??= new XmlWriterSettings() { OmitXmlDeclaration = true, Indent = true, IndentChars = "  " };
		filesystem.save(file, temp => {
			using var x = XmlWriter.Create(temp, sett);
			XmlSave(x, nodeWriter, children);
		});
	}

	/// <summary>
	/// Writes tree of nodes (this and descendants) to an <see cref="XmlWriter"/>.
	/// </summary>
	/// <exception cref="Exception">Exceptions of <see cref="XmlWriter"/> methods.</exception>
	/// <example><see cref="TreeBase{T}"/></example>
	/// <inheritdoc cref="XmlSave(string, XmlNodeWriter, XmlWriterSettings, IEnumerable{T})" path="/param"/>
	protected void XmlSave(XmlWriter x, XmlNodeWriter nodeWriter, IEnumerable<T> children = null) {
		Not_.Null(x, nodeWriter);
		x.WriteStartDocument();
		if (children == null) {
			_XmlWrite(x, nodeWriter);
		} else {
			nodeWriter(x, this as T);
			foreach (var n in children) n._XmlWrite(x, nodeWriter);
			x.WriteEndElement();
		}
		x.WriteEndDocument();
	}

	void _XmlWrite(XmlWriter x, XmlNodeWriter nodeWriter) {
		nodeWriter(x, this as T);
		if (_lastChild != null) {
			var c = _lastChild;
			do {
				c = c._next;
				c._XmlWrite(x, nodeWriter);
			} while (c != _lastChild);
		}
		x.WriteEndElement();
	}

	#endregion
}


================================================
FILE: Au/Au.Types/common.cs
================================================
using System.Diagnostics.CodeAnalysis;
using static Au.More.Serializer_;

namespace Au.Types {
	/// <summary>
	/// In DocFX-generated help files removes documentation and auto-generated links in TOC and class pages. For it is used filter.yml.
	/// </summary>
	[EditorBrowsable(EditorBrowsableState.Never), AttributeUsage(AttributeTargets.All)]
	public sealed class NoDoc : Attribute { }
	//tested: the DocFX /// <exclude /> removes the member from the compilation, not just prevents creating the doc article. Then may be error; don't use it. See https://dotnet.github.io/docfx/docs/dotnet-api-docs.html
	
	/// <summary>
	/// If a class is derived from this class, editor adds undeclared Windows API to its completion list.
	/// </summary>
	public abstract class NativeApi {
		//Or for it could use an attribute. But this base class easily solves 2 problems:
		//	1. In 'new' expression does not show completion list (with types from winapi DB) if the winapi class still does not have types inside. Because the completion service then returns null. Now it is solved, because this class has nested types.
		//	2. If class with attributes is after top-level statements, code info often does not work when typing directly above it. Works better if without attributes.
		//FUTURE: Also add attribute. Then can specify an alternative DB or text file with declarations. Maybe also some settings.
		//	But use this class as base too, like now. Eg could add protected util functions. Could use this class as both (base and attribute), but Attribute has static members.
		
#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
		
		/// <summary>
		/// Can be used in structures as flexible array member (the last field, defined like <c>Type[1] name;</c> in C).
		/// </summary>
		public struct FlexibleArray<T> where T : unmanaged {
			T _0;
			
			public ref T this[int index] {
				[UnscopedRef]
				[MethodImpl(MethodImplOptions.AggressiveInlining)]
				get => ref Unsafe.Add(ref _0, index);
			}
			
			[UnscopedRef]
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public Span<T> AsSpan(int length) {
				return MemoryMarshal.CreateSpan(ref _0, length);
			}
		}
		
		/// <summary>
		/// Windows API <c>BOOL</c>, with implicit conversions to/from C# <c>bool</c>.
		/// </summary>
		public readonly record struct BOOL {
			public readonly int IntValue;
			
			public BOOL(bool b) { IntValue = b ? 1 : 0; }
			public static implicit operator bool(BOOL b) => b.IntValue != 0;
			public static implicit operator BOOL(bool b) => new(b);
			public override string ToString() => IntValue == 0 ? "False" : "True";
		}
#pragma warning restore CS1591 // Missing XML comment for publicly visible type or member
	}
	
	/// <summary>
	/// Invokes specified action (calls callback function) at the end of <c>using(...) { ... }</c>.
	/// Usually returned by functions. Example: <see cref="opt.scope.mouse"/>.
	/// </summary>
	public struct UsingEndAction : IDisposable {
		readonly Action _a;
		
		/// <summary>Sets action to be invoked when disposing this variable.</summary>
		public UsingEndAction(Action a) => _a = a;
		
		/// <summary>Invokes the action if not <c>null</c>.</summary>
		public void Dispose() => _a?.Invoke();
	}
	
	/// <summary>
	/// Used with <see cref="ParamStringAttribute"/> to specify string parameter format.
	/// </summary>
	public enum PSFormat {
		///
		None,
		
		/// <summary>
		/// Keys. See <see cref="keys.send(KKeysEtc[])"/>.
		/// </summary>
		Keys,
		
		/// <summary>
		/// [Wildcard expression](xref:wildcard_expression).
		/// </summary>
		Wildex,
		
		/// <summary>
		/// PCRE regular expression.
		/// </summary>
		Regexp,
		
		/// <summary>
		/// PCRE regular expression replacement string.
		/// </summary>
		RegexpReplacement,
		
		/// <summary>
		/// .NET regular expression.
		/// </summary>
		NetRegex,
		
		/// <summary>
		/// Hotkey, except triggers.
		/// </summary>
		Hotkey,
		
		/// <summary>
		/// Hotkey trigger.
		/// </summary>
		HotkeyTrigger,
		
		/// <summary>
		/// Trigger modifiers without key.
		/// </summary>
		TriggerMod,
		
		/// <summary>
		/// Name or path of a script or class file in current workspace.
		/// </summary>
		CodeFile,
		
		/// <summary>
		/// Name or path of any file or folder in current workspace.
		/// </summary>
		FileInWorkspace,
	}
	
	/// <summary>
	/// A function parameter with this attribute is a string of the specified format, for example regular expression.
	/// Code editors should help to create correct string arguments: provide tools or reference, show errors.
	/// </summary>
	[AttributeUsage(AttributeTargets.Parameter /*| AttributeTargets.Field | AttributeTargets.Property*/, AllowMultiple = false)]
	public sealed class ParamStringAttribute : Attribute {
		//info: now .NET has similar attribute StringSyntaxAttribute. It was added later.
		
		///
		public ParamStringAttribute(PSFormat format) => Format = format;
		
		///
		public PSFormat Format { get; set; }
	}
	
	///// <summary>
	///// Specifies whether to set, add or remove flags.
	///// </summary>
	//public enum SetAddRemove
	//{
	//	/// <summary>Set flags = the specified value.</summary>
	//	Set = 0,
	//	/// <summary>Add the specified flags, don't change others.</summary>
	//	Add = 1,
	//	/// <summary>Remove the specified flags, don't change others.</summary>
	//	Remove = 2,
	//	/// <summary>Toggle the specified flags, don't change others.</summary>
	//	Xor = 3,
	//}
}

namespace System.Runtime.CompilerServices //the attribute must be in this namespace
{
	///
	[NoDoc]
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	public class IgnoresAccessChecksToAttribute : Attribute {
		///
		public IgnoresAccessChecksToAttribute(string assemblyName) { AssemblyName = assemblyName; }
		///
		public string AssemblyName { get; }
	}
}


================================================
FILE: Au/Au.Types/exceptions.cs
================================================
namespace Au.Types {
	/// <summary>
	/// The base exception class used in this library.
	/// Thrown when something fails and there is no better exception type for that failure.
	/// </summary>
	/// <remarks>
	/// Some constructors support Windows API error code. Then <see cref="Message"/> will contain its error description.
	/// If the string passed to the constructor starts with <c>"*"</c>, replaces the <c>"*"</c> with <c>"Failed to "</c>. If does not end with <c>"."</c>, appends <c>"."</c>.
	/// </remarks>
	public class AuException : Exception {
		/// <summary>
		/// Sets <see cref="Message"/> = <i>message</i> (default <c>"Failed."</c>).
		/// Sets <see cref="NativeErrorCode"/> = 0.
		/// </summary>
		public AuException(string message = "Failed.", Exception innerException = null) : base(message, innerException) { }

		/// <summary>
		/// Sets <see cref="NativeErrorCode"/> = <c>(errorCode != 0) ? errorCode : lastError.code</c>.
		/// Sets <see cref="Message"/> = <c>message + " " + lastError.messageFor(NativeErrorCode)</c>.
		/// </summary>
		public AuException(int errorCode, string message = "Failed.", Exception innerException = null) : base(message, innerException) {
			NativeErrorCode = (errorCode != 0) ? errorCode : lastError.code;
		}

		/// <summary>Gets the Windows API error code.</summary>
		public int NativeErrorCode { get; protected set; }

		/// <summary>Gets error message.</summary>
		public override string Message => FormattedMessage ?? FormatMessage();

		/// <summary>String created by <see cref="FormatMessage"/>, which should be called by the <see cref="Message"/> override if <c>null</c>. Initially <c>null</c>.</summary>
		protected string FormattedMessage;

		/// <summary>
		/// Formats error message. Sets and returns <see cref="FormattedMessage"/>.
		/// </summary>
		/// <remarks>
		/// As base text, uses the text passed to the constructor (default <c>"Failed."</c>).
		/// If it starts with <c>"*"</c>, replaces the <c>"*"</c> with <c>"Failed to "</c>.
		/// If it ends with <c>"*"</c>, replaces the <c>"*"</c> with <i>commonPostfix</i> if it is not empty.
		/// If then the message does not end with <c>"."</c>, appends <c>"."</c>.
		/// If <i>appendMessage</i> is <c>null</c>, uses <c>lastError.messageFor(NativeErrorCode)</c> if <see cref="NativeErrorCode"/> not 0.
		/// If then <i>appendMessage</i> is not empty, appends <c>" " + appendMessage</c>.
		/// Also appends <c>InnerException.Message</c> in new tab-indented line if <see cref="Exception.InnerException"/> is not <c>null</c>.
		/// </remarks>
		protected string FormatMessage(string appendMessage = null, string commonPostfix = null) {
			var m = base.Message;

			if (!m.NE()) {
				if (m[0] == '*') m = "Failed to " + m[1..];
				if (!commonPostfix.NE() && m[^1] == '*') m = m[..^1] + commonPostfix;
				if (!m.Ends('.')) m += ".";
			}

			if (appendMessage == null && NativeErrorCode != 0) appendMessage = lastError.messageFor(NativeErrorCode);

			if (!appendMessage.NE()) m = m + " " + appendMessage;

			if (InnerException != null) m = m + "\r\n\t" + InnerException.Message;

			return FormattedMessage = m;
		}

		/// <summary>
		/// If <i>errorCode</i> is not 0, throws <see cref="AuException"/> that includes the code and its message.
		/// More info: <see cref="FormatMessage"/>.
		/// </summary>
		/// <param name="errorCode">Windows API error code or <c>HRESULT</c>.</param>
		/// <param name="message">Main message. The message of the error code will be appended to it.</param>
		public static void ThrowIfHresultNot0(int errorCode, string message = null) {
			if (errorCode != 0) throw new AuException(errorCode, message);
		}

		/// <summary>
		/// If <i>errorCode</i> is less than 0, throws <see cref="AuException"/> that includes the code and its message.
		/// More info: <see cref="FormatMessage"/>.
		/// </summary>
		/// <param name="errorCode">Windows API error code or <c>HRESULT</c>.</param>
		/// <param name="message">Main message. The message of the error code will be appended to it.</param>
		public static void ThrowIfHresultNegative(int errorCode, string message = null) {
			if (errorCode < 0) throw new AuException(errorCode, message);
		}
	}

	/// <summary>
	/// Exception thrown mostly by <see cref="wnd"/> functions.
	/// </summary>
	/// <remarks>
	/// Some constructors support Windows API error code. Then <see cref="Message"/> also will contain its error description.
	/// If error code <c>ERROR_INVALID_WINDOW_HANDLE</c>, <see cref="Message"/> also depends on whether the window handle is 0.
	/// If parameter <i>errorCode</i> is 0 or not used: if the window handle is invalid, uses <c>ERROR_INVALID_WINDOW_HANDLE</c>.
	/// If the string passed to the constructor starts with <c>"*"</c>, replaces the <c>"*"</c> with <c>"Failed to "</c>. If ends with <c>"*"</c>, replaces the <c>"*"</c> with <c>" window."</c>. If does not end with <c>"."</c>, appends <c>"."</c>.
	/// </remarks>
	public class AuWndException : AuException {
		const string _errStr_0Handle = "The window handle is 0. Usually it means 'window not found'.";
		const string _errStr_InvalidHandle = "Invalid window handle. Usually it means 'the window was closed'.";

		/// <summary>
		/// Sets <see cref="Message"/> = <i>message</i> (default <c>"Failed."</c>).
		/// Sets <see cref="AuException.NativeErrorCode"/> = <c>w.IsAlive ? 0 : ERROR_INVALID_WINDOW_HANDLE</c>.
		/// </summary>
		public AuWndException(wnd w, string message = "Failed.", Exception innerException = null)
			: base(message, innerException) { Window = w; NativeErrorCode = _Code(0, w); }

		/// <summary>
		/// Sets <see cref="AuException.NativeErrorCode"/> = <c>(errorCode != 0) ? errorCode : (w.IsAlive ? lastError.code : ERROR_INVALID_WINDOW_HANDLE)</c>.
		/// Sets <see cref="Message"/> = <c>message + " " + lastError.messageFor(NativeErrorCode)</c>.
		/// </summary>
		public AuWndException(wnd w, int errorCode, string message = "Failed.", Exception innerException = null)
			: base(_Code(errorCode, w), message, innerException) { Window = w; }

		static int _Code(int code, wnd w) {
			if (code != 0 || w.IsAlive) return code;
			return Api.ERROR_INVALID_WINDOW_HANDLE;
		}

		/// <summary>Gets the window passed to the constructor.</summary>
		public wnd Window { get; }

		/// <summary>Gets error message.</summary>
		public override string Message {
			get {
				if (FormattedMessage == null) {
					string m;
					if (Window.Is0) m = _errStr_0Handle;
					else if (NativeErrorCode == Api.ERROR_INVALID_WINDOW_HANDLE) m = _errStr_InvalidHandle;
					else m = null; //will append lastError.messageFor(NativeErrorCode) if NativeErrorCode not 0, or InnerException.Message if it is not null.
					FormatMessage(m, " window.");
				}
				return FormattedMessage;
			}
		}
	}

	/// <summary>
	/// Functions that search for an object can throw this exception when not found.
	/// </summary>
	public class NotFoundException : Exception {
		/// <summary>
		/// Sets <c>Message = "Not found."</c>.
		/// </summary>
		public NotFoundException() : base("Not found.") { }

		/// <summary>
		/// Sets <c>Message = message</c>.
		/// </summary>
		public NotFoundException(string message) : base(message) { }
	}

	///// <summary>
	///// Exception thrown when a callback function returns an invalid value.
	///// </summary>
	//public class BadCallbackException : Exception {
	//	/// <summary>
	//	/// Sets <c>Message = "The callback function returned an invalid value."</c>.
	//	/// </summary>
	//	public BadCallbackException() : base("The callback function returned an invalid value.") { }

	//	/// <summary>
	//	/// Sets <c>Message = message</c>.
	//	/// </summary>
	//	public BadCallbackException(string message) : base(message) { }
	//}

	/// <summary>
	/// This exception is thrown when current thread is not on the input desktop and therefore cannot use mouse, keyboard, clipboard and window functions. 
	/// For example when PC locked (<c>Win+L</c>), screen saver, UAC consent, <c>Ctrl+Alt+Delete</c> or not in the active user session.
	/// </summary>
	/// <seealso cref="miscInfo.isInputDesktop"/>
	public class InputDesktopException : AuException {
		/// <param name="message">Message text before the standard message text of this exception.</param>
		public InputDesktopException(string message = null)
			: base(message.NE() ? c_message : message + (message.Ends('.') ? " " : ". ") + c_message) { }

		const string c_message = "The main input desktop is inactive; mouse, keyboard, clipboard and UI functions are disabled.";

		/// <summary>
		/// Calls <see cref="miscInfo.isInputDesktop"/>. If it returns <c>false</c>, throws <see cref="InputDesktopException"/>.
		/// </summary>
		/// <param name="message">Message text before the standard message text of this exception.</param>
		/// <exception cref="InputDesktopException"></exception>
		public static void ThrowIfBadDesktop(string message = null, bool detectLocked = false) {
			if (!miscInfo.isInputDesktop(detectLocked)) throw new InputDesktopException(message);
		}
	}
}

namespace Au.Types {
	static partial class ExtMisc {
		/// <summary>
		/// Returns string containing exception type name and message.
		/// </summary>
		public static string ToStringWithoutStack(this Exception t) {
			return t.GetType().Name + ", " + t.Message;
		}
	}
}


================================================
FILE: Au/Au.Types/param types.cs
================================================
namespace Au.Types;

#if false //test docfx preprocessing
/// <summary>
/// Sum.
/// two
/// </summary>
/// <param name="A">A.</param>
/// <param name="B">B.</param>
public record class PublicRecord(int A, int B);

record class InternalRecord_ {
	public int A { get; set; }
	public int B { get; set; }
}

record class InternalRecord2_(int A, int B) {
	public int C { get; set; }
}

record class InternalRecord3_(int A, int B);

public class NormalClass {

	record class _Record4(int A, int B) {
		public int C { get; set; }
	}

	/// <summary>
	/// Sum.
	/// </summary>
	/// <param name="i">Param.</param>
	public void Meth(int i) { }
}
#endif



/// <summary>
/// Contains x or y coordinate in screen or some other rectangle that can be specified in various ways: normal, reverse, fraction, center, max.
/// Used for parameters of functions like <see cref="mouse.move"/>, <see cref="wnd.Move"/>.
/// </summary>
/// <remarks>
/// To specify a normal coordinate (the origin is the left or top edge), assign an <c>int</c> value (implicit conversion from <c>int</c> to <c>Coord</c>).
/// To specify a reverse coordinate (the origin is the right or bottom edge), use <see cref="Reverse"/> or a "from end" index like <c>^1</c>. It is towards the left or top edge, unless negative. Or use <see cref="Max"/> or <see cref="MaxInside"/>.
/// To specify a "fraction of the rectangle" coordinate, use <see cref="Fraction"/> or a value of type float like <c>.5f</c>. Or use <see cref="Center"/>.
/// The meaning of <c>default(Coord)</c> depends on function where used. Many functions interpret it as center (same as <c>Coord.Center</c> or <c>.5f</c>).
/// Also there are functions to convert <c>Coord</c> to normal coordinates.
/// </remarks>
/// <example>
/// <code><![CDATA[
/// mouse.move(100, 100); //left edge + 100, top edge + 100
/// mouse.move(Coord.Reverse(100), 100); //right edge - 100, top edge + 100
/// mouse.move(100, ^100); //left edge + 100, bottom edge - 100
/// mouse.move(Coord.Fraction(.33), .9f); //left edge + 1/3 of the screen rectangle, top edge + 9/10
/// mouse.move(Coord.Center, Coord.MaxInside); //x in center (left edge + 1/2), y by the bottom edge inside (Coord.Max would be outside)
/// mouse.move(Coord.Reverse(-100), 1.1f); //right edge + 100, bottom edge + 0.1 of the rectangle
/// 
/// var w = wnd.find(1, "Untitled - Notepad", "Notepad");
/// w.Move(.5f, 100, .5f, ^200); //x = center, y = 100, width = half of screen, height = screen height - 200
/// ]]></code>
/// </example>
public record struct Coord {
	//Use single long field that packs int and CoordType.
	//If 2 fields (int and CoordType), 64-bit compiler creates huge calling code.
	//This version is good in 32-bit, very good in 64-bit. Even better than packing in single int (30 bits value and 2 bits type).
	//Don't use struct or union with both int and float fields. It creates slow and huge calling code.
	readonly long _v;
	
	/// <summary>
	/// Value type.
	/// </summary>
	public CoordType Type => (CoordType)(_v >> 32);
	
	/// <summary>
	/// Non-fraction value.
	/// </summary>
	public int Value => (int)_v;
	
	/// <summary>
	/// Fraction value.
	/// </summary>
	public unsafe float FractionValue => BitConverter.Int32BitsToSingle((int)_v);
	
	/// <summary>
	/// Returns <c>true</c> if <c>Type == CoordType.None</c> (no value assigned).
	/// </summary>
	public bool IsEmpty => Type == CoordType.None;
	
	Coord(CoordType type, int value) { _v = ((long)type << 32) | (uint)value; }
	//info: if type and value are constants, compiler knows the final value and does not use the << and | operators in the compiled code.
	
	/// <summary>
	/// Creates <see cref="Coord"/> of <c>Normal</c> type.
	/// </summary>
	//[MethodImpl(MethodImplOptions.NoInlining)] //makes bigger/slower
	public static implicit operator Coord(int v) => new(CoordType.Normal, v);
	
	/// <summary>
	/// Creates <see cref="Coord"/> of <c>Normal</c> or <c>Reverse</c> type. Reverse if the index is from end, like <c>^1</c>.
	/// </summary>
	public static implicit operator Coord(Index v) => new(v.IsFromEnd ? CoordType.Reverse : CoordType.Normal, v.Value);
	
	/// <summary>
	/// Creates <see cref="Coord"/> of <c>Fraction</c> type.
	/// </summary>
	public static implicit operator Coord(float v) => new(CoordType.Fraction, BitConverter.SingleToInt32Bits(v));
	
	//these would create Fraction
	///
	[Obsolete("The value must be of type int or float.", error: true), NoDoc]
	public static implicit operator Coord(uint f) => default;
	///
	[Obsolete("The value must be of type int or float.", error: true), NoDoc]
	public static implicit operator Coord(long f) => default;
	///
	[Obsolete("The value must be of type int or float.", error: true), NoDoc]
	public static implicit operator Coord(ulong f) => default;
	//tested: compiler does not allow to assign nint.
	
	/// <summary>
	/// Creates <see cref="Coord"/> of <c>Reverse</c> type.
	/// Value 0 is at the right or bottom, and does not belong to the rectangle. Positive values are towards left or top.
	/// </summary>
	/// <remarks>
	/// Instead can be use "from end" index, for example argument <c>Coord.Reverse(1)</c> can be replaced with <c>^1</c>.
	/// </remarks>
	public static Coord Reverse(int v) => new(CoordType.Reverse, v);
	
	/// <summary>
	/// Creates <see cref="Coord"/> of <c>Fraction</c> type.
	/// Value 0 is the left or top of the rectangle. Value 1.0 is the right or bottom of the rectangle. Values &lt;0 and >=1.0 are outside of the rectangle.
	/// </summary>
	/// <remarks>
	/// Instead can be used implicit conversion from <c>float</c>, for example argument <c>Coord.Fraction(.5)</c> can be replaced with <c>.5f</c>.
	/// </remarks>
	public static unsafe Coord Fraction(double v) => (float)v;
	
	/// <summary>
	/// Returns <c>Fraction(0.5)</c>.
	/// </summary>
	/// <seealso cref="Fraction"/>
	public static Coord Center => .5f;
	
	/// <summary>
	/// Returns <c>Reverse(0)</c>. Same as <c>^0</c>.
	/// This point will be outside of the rectangle. See also <see cref="MaxInside"/>.
	/// </summary>
	/// <seealso cref="Reverse"/>
	public static Coord Max => Reverse(0);
	
	/// <summary>
	/// Returns <c>Reverse(1)</c>. Same as <c>^1</c>.
	/// This point will be inside of the rectangle, at the very right or bottom, assuming the rectangle is not empty.
	/// </summary>
	/// <seealso cref="Reverse"/>
	public static Coord MaxInside => Reverse(1);
	
	//rejected: this could be used like Coord.Max + 1. Too limited usage.
	//public static Coord operator +(Coord c, int i) { return ...; }
	
	static bool _NeedRect(Coord x, Coord y) {
		return (x.Type > CoordType.Normal) || (y.Type > CoordType.Normal);
	}
	
	/// <summary>
	/// Converts fractional/reverse coordinate to normal coordinate in a range.
	/// </summary>
	/// <param name="start">Start of range.</param>
	/// <param name="end">End of range.</param>
	public int NormalizeInRange(int start, int end) {
		return Type switch {
			CoordType.Normal => start + Value,
			CoordType.Reverse => end - Value,
			CoordType.Fraction => start + (int)((end - start) * FractionValue),
			_ => 0,
		};
	}
	
	/// <summary>
	/// Converts fractional/reverse coordinates to normal coordinates in a rectangle.
	/// </summary>
	/// <param name="x">X coordinate relative to <i>r</i>.</param>
	/// <param name="y">Y coordinate relative to <i>r</i>.</param>
	/// <param name="r">The rectangle.</param>
	/// <param name="widthHeight">Use only width and height of <i>r</i>. If <c>false</c> (default), the function adds <i>r</i> offset (left and top).</param>
	/// <param name="centerIfEmpty">If <i>x</i> or <i>y</i> is <c>default</c>, use <see cref="Coord.Center"/>. Not used with <i>widthHeight</i>.</param>
	public static POINT NormalizeInRect(Coord x, Coord y, RECT r, bool widthHeight = false, bool centerIfEmpty = false) {
		if (widthHeight) r.Move(0, 0);
		else if (centerIfEmpty) {
			if (x.IsEmpty) x = Center;
			if (y.IsEmpty) y = Center;
		}
		return (x.NormalizeInRange(r.left, r.right), y.NormalizeInRange(r.top, r.bottom));
	}
	
	/// <summary>
	/// Returns normal coordinates relative to the client area of a window. Converts fractional/reverse coordinates etc.
	/// </summary>
	/// <param name="x">X coordinate relative to the client area of <i>w</i>.</param>
	/// <param name="y">Y coordinate relative to the client area of <i>w</i>.</param>
	/// <param name="w">The window.</param>
	/// <param name="nonClient"><i>x</i> <i>y</i> are relative to the entire <i>w</i> rectangle, not to its client area.</param>
	/// <param name="centerIfEmpty">If <i>x</i> or <i>y</i> is <c>default</c>, use <see cref="Coord.Center"/>.</param>
	public static POINT NormalizeInWindow(Coord x, Coord y, wnd w, bool nonClient = false, bool centerIfEmpty = false) {
		//info: don't need widthHeight parameter because client area left/top are 0. With non-client don't need in this library and probably not useful. But if need, caller can explicitly offset the rect before calling this func.
		
		if (centerIfEmpty) {
			if (x.IsEmpty) x = Center;
			if (y.IsEmpty) y = Center;
		}
		POINT p = default;
		if (!x.IsEmpty || !y.IsEmpty) {
			RECT r;
			if (nonClient) {
				w.GetRectIn(w, out r);
			} else if (_NeedRect(x, y)) {
				r = w.ClientRect;
			} else r = default;
			p.x = x.NormalizeInRange(r.left, r.right);
			p.y = y.NormalizeInRange(r.top, r.bottom);
		}
		return p;
	}
	
	/// <summary>
	/// Returns normal coordinates relative to the primary screen. Converts fractional/reverse coordinates etc.
	/// </summary>
	/// <param name="x">X coordinate relative to the specified screen (<c>default</c> - primary).</param>
	/// <param name="y">Y coordinate relative to the specified screen (<c>default</c> - primary).</param>
	/// <param name="workArea"><i>x</i> <i>y</i> are relative to the work area.</param>
	/// <param name="screen">If used, <i>x</i> <i>y</i> are relative to this screen. Default - primary screen. Example: <c>screen.index(1)</c>.</param>
	/// <param name="widthHeight">Use only width and height of the screen rectangle. If <c>false</c>, the function adds its offset (left and top, which can be nonzero if using the work area or a non-primary screen).</param>
	/// <param name="centerIfEmpty">If <i>x</i> or <i>y</i> is <c>default</c>, use <see cref="Coord.Center"/>.</param>
	public static POINT Normalize(Coord x, Coord y, bool workArea = false, screen screen = default, bool widthHeight = false, bool centerIfEmpty = false) {
		if (centerIfEmpty) {
			if (x.IsEmpty) x = Center;
			if (y.IsEmpty) y = Center;
		}
		POINT p = default;
		if (!x.IsEmpty || !y.IsEmpty) {
			RECT r;
			if (workArea || !screen.IsEmpty || _NeedRect(x, y)) {
				r = screen.GetRect(workArea);
				if (widthHeight) r.Move(0, 0);
			} else r = default;
			p.x = x.NormalizeInRange(r.left, r.right);
			p.y = y.NormalizeInRange(r.top, r.bottom);
		}
		return p;
	}
	
	///
	public override string ToString() {
		switch (Type) {
		case CoordType.Normal: return Value.ToString() + ", Normal";
		case CoordType.Reverse: return Value.ToString() + ", Reverse";
		case CoordType.Fraction: return FractionValue.ToS() + ", Fraction";
		default: return "default";
		}
	}
}

/// <summary>
/// <see cref="Coord"/> variable value type.
/// </summary>
public enum CoordType {
	/// <summary>
	/// No value. The variable is <c>default(Coord)</c>.
	/// </summary>
	None,
	
	/// <summary>
	/// <see cref="Coord.Value"/> is pixel offset from left or top of a rectangle.
	/// </summary>
	Normal,
	
	/// <summary>
	/// <see cref="Coord.Value"/> is pixel offset from right or bottom of a rectangle, towards left or top.
	/// </summary>
	Reverse,
	
	/// <summary>
	/// <see cref="Coord.FractionValue"/> is fraction of a rectangle, where 0.0 is left or top, and 1.0 is right or bottom (outside of the rectangle).
	/// </summary>
	Fraction,
}

/// <summary>
/// Can be used to specify coordinates for various popup windows, like <c>new PopupXY(x, y)</c>, <c>(x, y)</c>, <c>PopupXY.In(rectangle)</c>, <c>PopupXY.Mouse</c>.
/// </summary>
public class PopupXY {
#pragma warning disable 1591 //XML doc
	public Coord x, y;
	public screen screen;
	public bool workArea;
	public bool inRect;
	public RECT rect;
#pragma warning restore 1591 //XML doc
	
	/// <summary>
	/// Sets position and/or screen.
	/// </summary>
	/// <param name="x">X relative to the screen or work area. Default - center.</param>
	/// <param name="y">X relative to the screen or work area. Default - center.</param>
	/// <param name="workArea"><i>x y</i> are relative to the work area of the screen.</param>
	/// <param name="screen">Can be used to specify a screen. Default - primary. Example: <c>screen.index(1)</c>.</param>
	/// <remarks>
	/// Also there is are implicit conversions from tuple (x, y) and <see cref="POINT"/>. Instead of <c>new PopupXY(x, y)</c> you can use <c>(x, y)</c>. Instead of <c>new PopupXY(p.x, p.y, false)</c> you can use <c>p</c> or <c>(POINT)p</c> .
	/// </remarks>
	public PopupXY(Coord x = default, Coord y = default, bool workArea = true, screen screen = default) {
		this.x = x; this.y = y; this.workArea = workArea; this.screen = screen;
	}
	
	/// <summary>
	/// Creates new <see cref="PopupXY"/> that specifies position in a rectangle. For example of the owner window.
	/// </summary>
	/// <param name="r">Rectangle relative to the primary screen.</param>
	/// <param name="x">X relative to the rectangle. Default - center.</param>
	/// <param name="y">Y relative to the rectangle. Default - center.</param>
	public static PopupXY In(RECT r, Coord x = default, Coord y = default) => new(x, y) { inRect = true, rect = r };
	
	/// <summary>
	/// Creates new <see cref="PopupXY"/> that specifies position relative to the work area of the primary screen.
	/// </summary>
	public static implicit operator PopupXY((Coord x, Coord y) p) => new(p.x, p.y, true);
	
	/// <summary>Creates new <see cref="PopupXY"/> that specifies position relative to the primary screen (not to the work area).</summary>
	public static implicit operator PopupXY(POINT p) => new(p.x, p.y, false);
	//info: this conversion can be used with PopupXY.Mouse.
	
	//public bool IsRawXY => !inRect && screen.IsNull && workArea == false && x.Type == Coord.CoordType.Normal && y.Type == Coord.CoordType.Normal;
	
	/// <summary>
	/// Gets point coordinates below mouse cursor, for showing a tooltip-like popup.
	/// </summary>
	public static POINT Mouse {
		get {
			var p = mouse.xy;
			
			var scr = screen.of(p);
			var rs = scr.Rect;
			int dy = Dpi.Scale(100, scr.Dpi);
			if (rs.bottom - p.y < dy) return (p.x, p.y - dy);
			
			int cy = Dpi.GetSystemMetrics(Api.SM_CYCURSOR, p);
			if (MouseCursor.GetCurrentVisibleCursor(out var c) && Api.GetIconInfo(c, out var u)) {
				if (u.hbmColor != default) Api.DeleteObject(u.hbmColor);
				Api.DeleteObject(u.hbmMask);
				
				//print.it(u.xHotspot, u.yHotspot);
				p.y += cy - u.yHotspot - 1; //not perfect, but better than just to add SM_CYCURSOR or some constant value.
				return p;
			}
			return (p.x, p.y + cy - 5);
		}
	}
	
	/// <summary>
	/// Gets <see cref="screen.Now"/> if not empty, else screen that contains the specified point.
	/// </summary>
	public screen GetScreen() {
		if (!screen.IsEmpty) return screen.Now;
		POINT p = inRect ? Coord.NormalizeInRect(x, y, rect, centerIfEmpty: true) : Coord.Normalize(x, y, workArea);
		return screen.of(p);
	}
}

/// <summary>
/// Used for parameters of functions that need a window handle as <see cref="wnd"/> but also accept a WPF window/element, winforms form/control and <c>IntPtr</c>.
/// </summary>
/// <remarks>
/// Has implicit conversions from:
/// <br/>• <see cref="System.Windows.DependencyObject"/> - WPF window or element.
/// <br/>• <see cref="System.Windows.Forms.Control"/> - <c>Form</c> or control.
/// <br/>• <c>IntPtr</c> or <c>nint</c> - window handle.
/// </remarks>
public struct AnyWnd {
	readonly object _o;
	AnyWnd(object o) { _o = o; }
	
	/// <summary>Assignment of a value of type <see cref="wnd"/>.</summary>
	public static implicit operator AnyWnd(wnd w) => new(w);
	
	/// <summary>Assignment of a window handle as <c>IntPtr</c>.</summary>
	public static implicit operator AnyWnd(IntPtr hwnd) => new((wnd)hwnd);
	
	/// <summary>Assignment of a value of type <see cref="System.Windows.Forms.Control"/> (<c>Form</c> or any control class).</summary>
	public static implicit operator AnyWnd(System.Windows.Forms.Control c) => new(c);
	
	/// <summary>Assignment of a value of type <c>System.Windows.DependencyObject</c> (WPF window or control).</summary>
	public static implicit operator AnyWnd(System.Windows.DependencyObject c) => c != null ? new AnyWnd(new object[] { c }) : default;
	
	/// <summary>
	/// Gets the window or control handle as <see cref="wnd"/>.
	/// </summary>
	/// <value><c>default(wnd)</c> if not assigned.</value>
	public wnd Hwnd => wnd.Internal_.FromObject(_o);
	
	/// <summary>
	/// <c>true</c> if this is <c>default(AnyWnd)</c>.
	/// </summary>
	public bool IsEmpty => _o == null;
}

/// <summary>
/// Used for function parameters to specify multiple strings.
/// Contains a string like <c>"One|Two|Three"</c> or <c>string[]</c> or <c>List&lt;string&gt;</c>. Has implicit conversions from these types. Can be assigned collection initializer like <c>["a", "b"]</c>.
/// </summary>
[CollectionBuilder(typeof(Strings), "Create")]
public struct Strings : IEnumerable<string> {
	readonly object _o;
	Strings(object o) { _o = o; }
	
	///
	public Strings(params string[] a) { _o = a; }
	
	///
	public static implicit operator Strings(string s) => new((object)s);
	
	///
	public static implicit operator Strings(string[] e) => new(e);
	
	///
	public static implicit operator Strings(List<string> e) => new(e);
	
	/// <summary>
	/// The raw value.
	/// </summary>
	public object Value => _o;
	
	/// <summary>
	/// Converts the value to <c>string[]</c>.
	/// Note: don't modify array elements. If the caller passed an array, this function returns it, not a copy.
	/// </summary>
	public string[] ToArray() {
		return _o switch {
			string[] a => a,
			string s => s.Split('|'),
			List<string> a => a.ToArray(),
			_ => [], //null
		};
	}
	
#region support collection expression
	
	//IEnumerable<string>
	
	IEnumerator<string> IEnumerable<string>.GetEnumerator() => ToArray().AsEnumerable().GetEnumerator();
	
	//IEnumerable
	
	IEnumerator IEnumerable.GetEnumerator() => ToArray().GetEnumerator();
	
	/// <summary>
	/// Returns <c>new(span.ToArray())</c>.
	/// </summary>
	public static Strings Create(ReadOnlySpan<string> span) => new(span.ToArray());
	
#endregion
}

/// <summary>
/// Font name, size and style.
/// If <c>Name</c> not set, will be used standard GUI font; then <c>Size</c> can be 0 to use size of standard GUI font.
/// On high-DPI screen the font size will be scaled.
/// </summary>
public record class FontNSS(int Size = 0, string Name = null, bool Bold = false, bool Italic = false) {
	/// <summary>
	/// Creates font.
	/// </summary>
	/// <param name="dpi">DPI for scaling.</param>
	internal NativeFont_ CreateFont(DpiOf dpi) {
		if (Name == null) return new(dpi, Bold, Italic, Size);
		return new(dpi, Name, Size, Bold, Italic);
	}
}


================================================
FILE: Au/Au.Types/structs.cs
================================================
using System.Drawing;
using System.Text.Json.Serialization;

namespace Au.Types {
	/// <summary>
	/// Point coordinates x y.
	/// </summary>
	public record struct POINT {
#pragma warning disable 1591, 3008 //XML doc, CLS-compliant
		[JsonInclude]
		public int x, y;
		
		public POINT(int x, int y) { this.x = x; this.y = y; }
		
		public static implicit operator POINT((int x, int y) t) => new(t.x, t.y);
		
		public static implicit operator POINT(Point p) => new(p.X, p.Y);
		
		public static implicit operator Point(POINT p) => new(p.x, p.y);
		
		public static implicit operator PointF(POINT p) => new(p.x, p.y);
		
		public static implicit operator System.Windows.Point(POINT p) => new(p.x, p.y);
		
		/// <param name="p"></param>
		/// <param name="round">Can round up, for example 1.7 to 2.</param>
		/// <exception cref="OverflowException"></exception>
		public static POINT From(PointF p, bool round)
			=> new(round ? p.X.ToInt() : checked((int)p.X), round ? p.Y.ToInt() : checked((int)p.Y));
		
		/// <param name="p"></param>
		/// <param name="round">Can round up, for example 1.7 to 2.</param>
		/// <exception cref="OverflowException"></exception>
		public static POINT From(System.Windows.Point p, bool round)
			=> new(round ? p.X.ToInt() : checked((int)p.X), round ? p.Y.ToInt() : checked((int)p.Y));
		
		//rejected
		///// <summary>Specifies position relative to the primary screen or its work area. Calls <see cref="Coord.Normalize"/> with <i>centerIfEmpty</i> <c>true</c>.</summary>
		//public static implicit operator POINT((Coord x, Coord y, bool workArea) t) => _Coord(t.x, t.y, t.workArea, default);
		///// <summary>Specifies position relative to the specified screen or its work area. Calls <see cref="Coord.Normalize"/> with <i>centerIfEmpty</i> <c>true</c>.</summary>
		//public static implicit operator POINT((Coord x, Coord y, screen screen, bool workArea) t) => _Coord(t.x, t.y, t.workArea, t.screen);
		///// <summary>Specifies position in the specified rectangle which is relative to the primary screen. Calls <see cref="Coord.NormalizeInRect"/> with <i>centerIfEmpty</i> <c>true</c>.</summary>
		//public static implicit operator POINT((RECT r, Coord x, Coord y) t) => Coord.NormalizeInRect(t.x, t.y, t.r, centerIfEmpty: true);
		//static POINT _Coord(Coord x, Coord y, bool workArea, screen screen) => Coord.Normalize(x, y, workArea, screen, centerIfEmpty: true);
		
		//maybe in the future
		///// <summary>
		///// Converts <see cref="Coord"/> coordinates into real coordinates.
		///// Calls <see cref="Coord.Normalize"/> with <i>centerIfEmpty</i> <c>true</c>.
		///// </summary>
		//public static POINT Normalize(Coord x, Coord y, bool workArea = false, screen screen = default)
		//	=> Coord.Normalize(x, y, workArea, screen, centerIfEmpty: true);
		
		//public static POINT NormalizeIn(RECT r, Coord x = default, Coord y = default)
		//	=> Coord.NormalizeInRect(x, y, r, centerIfEmpty: true);
		
		/// <summary><c>this.x += x; this.y += y;</c></summary>
		public void Offset(int x, int y) { this.x += x; this.y += y; }
		
		/// <summary>Returns <c>new POINT(p.x + d.x, p.y + d.y)</c>.</summary>
		public static POINT operator +(POINT p, (int x, int y) d) => new(p.x + d.x, p.y + d.y);
		
		public void Deconstruct(out int x, out int y) { x = this.x; y = this.y; }
		
		public override string ToString() => $"{{{x.ToS()}, {y.ToS()}}}";
#pragma warning restore 1591 //XML doc
	}
	
	/// <summary>
	/// Width and height.
	/// </summary>
	public record struct SIZE {
#pragma warning disable 1591, 3008 //XML doc, CLS-compliant
		[JsonInclude]
		public int width, height;
		
		public SIZE(int width, int height) { this.width = width; this.height = height; }
		
		public static implicit operator SIZE((int width, int height) t) => new(t.width, t.height);
		
		public static implicit operator SIZE(Size z) => new(z.Width, z.Height);
		
		public static implicit operator Size(SIZE z) => new(z.width, z.height);
		
		public static implicit operator SizeF(SIZE z) => new(z.width, z.height);
		
		public static implicit operator System.Windows.Size(SIZE z) => new(z.width, z.height);
		
		/// <param name="z"></param>
		/// <param name="round">Can round up, for example 1.7 to 2.</param>
		/// <exception cref="OverflowException"></exception>
		public static SIZE From(SizeF z, bool round)
			=> new(round ? z.Width.ToInt() : checked((int)z.Width), round ? z.Height.ToInt() : checked((int)z.Height));
		
		/// <param name="z"></param>
		/// <param name="round">Can round up, for example 1.7 to 2.</param>
		/// <exception cref="OverflowException"></exception>
		public static SIZE From(System.Windows.Size z, bool round)
			=> new(round ? z.Width.ToInt() : checked((int)z.Width), round ? z.Height.ToInt() : checked((int)z.Height));
		
		/// <summary>Returns <c>new SIZE(z.width + d.x, z.height + d.y)</c>.</summary>
		public static SIZE operator +(SIZE z, (int x, int y) d) => new(z.width + d.x, z.height + d.y);
		
		public void Deconstruct(out int width, out int height) { width = this.width; height = this.height; }
		
		public override string ToString() => $"{{{width.ToS()}, {height.ToS()}}}";
#pragma warning restore 1591 //XML doc
	}
	
	/// <summary>
	/// Rectangle coordinates left top right bottom.
	/// </summary>
	/// <remarks>
	/// This type can be used with Windows API functions. The .NET <c>Rectangle</c> etc can't, because their fields are different.
	/// Has conversions from/to <see cref="Rectangle"/>.
	/// </remarks>
	public record struct RECT {
#pragma warning disable 1591, 3008 //XML doc, CLS-compliant
		[JsonInclude]
		public int left, top;
		public int right, bottom;
		
		/// <summary>
		/// Sets all fields.
		/// </summary>
		/// <remarks>
		/// Sets <c>right = left + width; bottom = top + height;</c>. To specify right/bottom instead of width/height, use <see cref="FromLTRB"/> instead.
		/// </remarks>
		[JsonConstructor] //without it JSON deserializer sets incorrect Width/Height because does it before setting left/right
		public RECT(int left, int top, int width, int height) {
			this.left = left; this.top = top;
			right = left + width; bottom = top + height;
		}
		
		/// <summary>
		/// Creates <see cref="RECT"/> with specified <c>left</c>, <c>top</c>, <c>right</c> and <c>bottom</c>.
		/// </summary>
		public static RECT FromLTRB(int left, int top, int right, int bottom)
			=> new() { left = left, top = top, right = right, bottom = bottom };
		
		/// <summary>
		/// Converts from tuple (left, top, width, height).
		/// </summary>
		public static implicit operator RECT((int L, int T, int W, int H) t) => new(t.L, t.T, t.W, t.H);
		
		public static implicit operator RECT(Rectangle r) => new(r.Left, r.Top, r.Width, r.Height);
		
		public static implicit operator Rectangle(RECT r) => new(r.left, r.top, r.Width, r.Height);
		
		public static implicit operator RectangleF(RECT r) => new(r.left, r.top, r.Width, r.Height);
		
		public static implicit operator System.Windows.Rect(RECT r) => new(r.left, r.top, r.Width, r.Height);
		
		/// <param name="r"></param>
		/// <param name="round">Can round up, for example 1.7 to 2.</param>
		/// <exception cref="OverflowException"></exception>
		public static RECT From(RectangleF r, bool round) {
			if (round) return new(r.Left.ToInt(), r.Top.ToInt(), r.Width.ToInt(), r.Height.ToInt());
			checked { return new((int)r.Left, (int)r.Top, (int)r.Width, (int)r.Height); }
		}
		
		/// <param name="r"></param>
		/// <param name="round">Can round up, for example 1.7 to 2.</param>
		/// <exception cref="OverflowException"></exception>
		public static RECT From(System.Windows.Rect r, bool round) {
			if (round) return new(r.Left.ToInt(), r.Top.ToInt(), r.Width.ToInt(), r.Height.ToInt());
			checked { return new((int)r.Left, (int)r.Top, (int)r.Width, (int)r.Height); }
		}
		
		//rejected. Rare.
		///// <summary>
		///// Sets fields like constructor <see cref="RECT(int,int,int,int)"/>.
		///// </summary>
		//public void Set(int left, int top, int rightOrWidth, int bottomOrHeight, bool useWidthHeight = true) {
		//	this.left = left; this.top = top;
		//	right = rightOrWidth; bottom = bottomOrHeight;
		//	if (useWidthHeight) { right += left; bottom += top; }
		//}
		
		/// <summary>
		/// Returns <c>true</c> if all fields == 0.
		/// </summary>
		public bool Is0 => left == 0 && top == 0 && right == 0 && bottom == 0;
		
		/// <summary>
		/// Returns <c>true</c> if the rectangle area is empty or invalid: <c>right&lt;=left || bottom&lt;=top;</c>
		/// </summary>
		public bool NoArea => right <= left || bottom <= top;
		
		/// <summary>
		/// Gets or sets width.
		/// </summary>
		public int Width { get => right - left; set { right = left + value; } }
		
		/// <summary>
		/// Gets or sets height.
		/// </summary>
		public int Height { get => bottom - top; set { bottom = top + value; } }
		
		/// <summary>
		/// Returns <c>new POINT(left, top)</c>.
		/// </summary>
		public POINT XY => new(left, top);
		
		/// <summary>
		/// Returns <c>new SIZE(Width, Height)</c>.
		/// </summary>
		public SIZE Size => new(Width, Height);
		
		/// <summary>
		/// Gets horizontal center.
		/// </summary>
		public int CenterX => left + (right - left) / 2;
		//public int CenterX => (int)(((long)left + right) / 2);
		
		/// <summary>
		/// Gets vertical center.
		/// </summary>
		public int CenterY => top + (bottom - top) / 2;
		//public int CenterY => (int)(((long)top + bottom) / 2);

		/// <summary>
		/// Returns width multiplied by height: <c>Math.Abs((long)Width * Height)</c>.
		/// </summary>
		internal long Area_ => Math.Abs((long)Width * Height);
		
		/// <summary>
		/// Returns <c>true</c> if this rectangle contains the specified point.
		/// </summary>
		public bool Contains(int x, int y) => x >= left && x < right && y >= top && y < bottom;
		
		/// <summary>
		/// Returns <c>true</c> if this rectangle contains the specified point.
		/// </summary>
		public bool Contains(POINT p) => Contains(p.x, p.y);
		
		/// <summary>
		/// Returns <c>true</c> if this rectangle contains entire specified rectangle.
		/// </summary>
		public bool Contains(RECT r2) => r2.left >= left && r2.top >= top && r2.right <= right && r2.bottom <= bottom;
		
		/// <summary>
		/// Makes this rectangle bigger or smaller: <c>left-=dx; right+=dx; top-=dy; bottom+=dy;</c>
		/// Use negative <i>dx</i>/<i>dy</i> to make the rectangle smaller. Note: too big negative <i>dx</i>/<i>dy</i> can make it invalid (<c>right &lt; left</c> or <c>bottom &lt; top</c>).
		/// </summary>
		public void Inflate(int dx, int dy) { left -= dx; right += dx; top -= dy; bottom += dy; }
		
		/// <summary>
		/// Replaces this rectangle with the intersection of itself and the specified rectangle.
		/// If the rectangles don't intersect, makes this variable empty.
		/// </summary>
		/// <returns><c>true</c> if the rectangles intersect.</returns>
		public bool Intersect(RECT r2) => Api.IntersectRect(out this, this, r2);
		
		/// <summary>
		/// Returns the intersection rectangle of two rectangles.
		/// If they don't intersect, returns empty rectangle.
		/// </summary>
		public static RECT Intersect(RECT r1, RECT r2) { Api.IntersectRect(out RECT r, r1, r2); return r; }
		
		/// <summary>
		/// Returns <c>true</c> if this rectangle and another rectangle intersect.
		/// </summary>
		public bool IntersectsWith(RECT r2) => Api.IntersectRect(out _, this, r2);
		
		/// <summary>
		/// Moves this rectangle by the specified offsets: <c>left+=dx; right+=dx; top+=dy; bottom+=dy;</c>
		/// Negative <i>dx</i> moves to the left. Negative <i>dy</i> moves up.
		/// </summary>
		public void Offset(int dx, int dy) { left += dx; right += dx; top += dy; bottom += dy; }
		
		/// <summary>
		/// Moves this rectangle so that <c>left</c>=<i>x</i> and <c>right</c>=<i>y</i>. Does not change <see cref="Width"/> and <see cref="Height"/>.
		/// </summary>
		public void Move(int x, int y) => Offset(x - left, y - top);
		
		/// <summary>
		/// Replaces this rectangle with the union of itself and the specified rectangle.
		/// Union is the smallest rectangle that contains two full rectangles.
		/// </summary>
		/// <remarks>
		/// If either rectangle is empty (<see cref="Width"/> or <see cref="Height"/> is &lt;=0), the result is another rectangle. If both empty - empty rectangle.
		/// </remarks>
		/// <returns><c>true</c> if finally this rectangle is not empty.</returns>
		public bool Union(RECT r2) => Api.UnionRect(out this, this, r2);
		
		/// <summary>
		/// Returns the union of two rectangles.
		/// Union is the smallest rectangle that contains two full rectangles.
		/// </summary>
		/// <remarks>
		/// If either rectangle is empty (<see cref="Width"/> or <see cref="Height"/> is &lt;=0), the result is another rectangle. If both empty - empty rectangle.
		/// </remarks>
		public static RECT Union(RECT r1, RECT r2) { Api.UnionRect(out RECT r, r1, r2); return r; }
		
		/// <summary>
		/// If <c>width</c> or <c>height</c> are negative, modifies this rectangle so that they would not be negative.
		/// </summary>
		/// <param name="swap"><c>true</c> - swap <c>right</c>/<c>left</c>, <c>bottom</c>/<c>top</c>; <c>false</c> - set <c>right</c> = <c>left</c>, <c>bottom</c> = <c>top</c>.</param>
		public void Normalize(bool swap) {
			if (right < left) { if (swap) Math2.Swap(ref left, ref right); else right = left; }
			if (bottom < top) { if (swap) Math2.Swap(ref top, ref bottom); else bottom = top; }
		}
		
		/// <summary>
		/// Moves this rectangle to the specified coordinates in the specified screen, and ensures that whole rectangle is in screen.
		/// Final rectangle coordinates are relative to the primary screen.
		/// </summary>
		/// <param name="x">X coordinate in the specified screen. If <c>default</c> - center. Examples: <c>10</c>, <c>^10</c> (reverse), <c>.5f</c> (fraction).</param>
		/// <param name="y">Y coordinate in the specified screen. If <c>default</c> - center.</param>
		/// <param name="screen">Use this screen. If <c>default</c>, uses the primary screen. Example: <c>screen.index(1)</c>.</param>
		/// <param name="workArea">Use the work area, not whole screen. Default <c>true</c>.</param>
		/// <param name="ensureInScreen">If part of rectangle is not in screen, move and/or resize it so that entire rectangle would be in screen. Default <c>true</c>.</param>
		/// <remarks>
		/// This function can be used to calculate new window location before creating it. If window already exists, use <see cref="wnd.MoveInScreen"/>.
		/// </remarks>
		public void MoveInScreen(Coord x, Coord y, screen screen = default, bool workArea = true, bool ensureInScreen = true) {
			wnd.Internal_.MoveRectInScreen(false, ref this, x, y, screen, workArea, ensureInScreen);
		}
		
		/// <summary>
		/// Moves this rectangle to the specified coordinates in another rectangle <i>r</i>.
		/// </summary>
		/// <param name="r">Another rectangle.</param>
		/// <param name="x">X coordinate relative to <i>r</i>. Default - center. Examples: <c>10</c>, <c>^10</c> (reverse), <c>.5f</c> (fraction).</param>
		/// <param name="y">Y coordinate relative to <i>r</i>. Default - center.</param>
		/// <param name="ensureInRect">If part of rectangle is not in <i>r</i>, move and/or resize it so that entire rectangle would be in <i>r</i>.</param>
		public void MoveInRect(RECT r, Coord x = default, Coord y = default, bool ensureInRect = false) {
			wnd.Internal_.MoveRectInRect(ref this, x, y, r, ensureInRect);
		}
		
		/// <summary>
		/// Adjusts this rectangle to ensure that whole rectangle is in screen.
		/// Initial and final rectangle coordinates are relative to the primary screen.
		/// </summary>
		/// <param name="screen">Use this screen (see <see cref="screen"/>). If <c>default</c>, uses screen of the rectangle (or nearest).</param>
		/// <param name="workArea">Use the work area, not whole screen. Default <c>true</c>.</param>
		/// <remarks>
		/// This function can be used to calculate new window location before creating it. If window already exists, use <see cref="wnd.EnsureInScreen"/>.
		/// </remarks>
		public void EnsureInScreen(screen screen = default, bool workArea = true) {
			wnd.Internal_.MoveRectInScreen(true, ref this, default, default, screen, workArea, true);
		}
		
		/// <summary>
		/// Returns <c>true</c> if all fields of <i>r1</i> and <i>r2</i> are equal or almost equal with max difference +- <i>maxDiff</i>.
		/// </summary>
		internal static bool EqualFuzzy_(RECT r1, RECT r2, int maxDiff) {
			if (Math.Abs(r1.left - r2.left) > maxDiff) return false;
			if (Math.Abs(r1.top - r2.top) > maxDiff) return false;
			if (Math.Abs(r1.right - r2.right) > maxDiff) return false;
			if (Math.Abs(r1.bottom - r2.bottom) > maxDiff) return false;
			return true;
		}
		
		/// <summary>
		/// Converts to string <c>"{L=left T=top W=width H=height}"</c>.
		/// </summary>
		/// <seealso cref="TryParse"/>
		public override string ToString() {
			return $"{{L={left.ToS()} T={top.ToS()} W={Width.ToS()} H={Height.ToS()}}}";
			//note: don't change the format. Some functions parse it, eg TryParse and acc in C++.
			
			//don't need R B. Rarely useful, just makes more difficult to read W H.
			//return $"{{L={left} T={top} R={right} B={bottom}  W={Width} H={Height}}}";
		}
		
		/// <summary>
		/// Converts to string <c>"left top width height"</c>.
		/// </summary>
		/// <seealso cref="TryParse"/>
		public string ToStringSimple() {
			return $"{left.ToS()} {top.ToS()} {Width.ToS()} {Height.ToS()}";
		}
		
		/// <summary>
		/// Formats string from <see cref="RECT"/> main fields and properties.
		/// </summary>
		/// <param name="format">
		/// <see cref="StringBuilder.AppendFormat"/> format string. Example: <c>"({0}, {1}, {4}, {5})"</c>.
		/// This function passes to <c>AppendFormat</c> 6 values in this order: <c>left</c>, <c>top</c>, <c>right</c>, <c>bottom</c>, <c>Width</c>, <c>Height</c>.
		/// </param>
		public string ToStringFormat(string format) {
			using (new StringBuilder_(out var b)) {
				b.AppendFormat(format, left.ToS(), top.ToS(), right.ToS(), bottom.ToS(), Width.ToS(), Height.ToS());
				return b.ToString();
			}
		}
		
		/// <summary>
		/// Converts string to <see cref="RECT"/>.
		/// </summary>
		/// <returns><c>false</c> if invalid string format.</returns>
		/// <param name="s">String in format <c>"{L=left T=top W=width H=height}"</c> (<see cref="ToString"/>) or <c>"left top width height"</c> (<see cref="ToStringSimple"/>).</param>
		/// <param name="r"></param>
		public static bool TryParse(string s, out RECT r) {
			r = default;
			bool ok;
			if (s.Starts('{')) {
				ok = s.Eq(1, "L=") && s.ToInt(out r.left, 3, out int e)
					&& s.Eq(e, " T=") && s.ToInt(out r.top, e + 3, out e)
					&& s.Eq(e, " W=") && s.ToInt(out r.right, e + 3, out e)
					&& s.Eq(e, " H=") && s.ToInt(out r.bottom, e + 3, out e)
					&& s.Length == e + 1 && s[e] == '}';
				//tested: regex @"^\{L=(-?\d+) T=(-?\d+) W=(-?\d+) H=(-?\d+)\}$" 9 times slower.
			} else {
				ok = s.ToInt(out r.left, 0, out int e) && s.ToInt(out r.top, e, out e) && s.ToInt(out r.right, e, out e) && s.ToInt(out r.bottom, e);
			}
			if (ok) {
				r.right += r.left;
				r.bottom += r.top;
			}
			return ok;
		}
#pragma warning restore 1591 //XML doc
	}

	/// <summary>
	/// Struct with fields <c>int start</c> and <c>int end</c>.
	/// </summary>
	public record struct StartEnd {
		///
		public int start;
		///
		public int end;

		///
		public StartEnd(int start, int end) { this.start = start; this.end = end; }

		/// <summary>
		/// Returns <c>end - start</c>.
		/// </summary>
		public int Length => end - start;

		/// <summary>
		/// Converts this to <see cref="Range"/>.
		/// Can be used to get substring, like <c>s[x.Range]</c> instead of <c>s[x.start..x.end]</c>.
		/// </summary>
		public Range Range => start..end;

		///
		public static implicit operator Range(StartEnd s) => s.start..s.end;
		
		/// <exception cref="ArgumentException">The start or end of the range is from the end.</exception>
		public static implicit operator StartEnd(Range r) {
			if (r.Start.IsFromEnd || r.End.IsFromEnd) throw new ArgumentException();
			return new(r.Start.Value, r.End.Value);
		}

		/// <summary>
		/// Gets string span.
		/// </summary>
		[Obsolete, EditorBrowsable(EditorBrowsableState.Never)] //rarely used; easy with string.AsSpan; precedes `start` in intellisense.
		public RStr Span(string s) => s.AsSpan(start, end - start);

		///
		public override string ToString() => $"({start}, {end})";
	}
	
	internal unsafe struct VARIANT : IDisposable {
		public Api.VARENUM vt; //ushort
		ushort _u1;
		uint _u2;
		public nint value;
		public nint value2;
		//note: cannot use FieldOffset because of different 32/64 bit size
		
		public VARIANT(int x) { vt = Api.VARENUM.VT_I4; value = x; }
		public VARIANT(string x) { vt = Api.VARENUM.VT_BSTR; value = Marshal.StringToBSTR(x); }
		
		public static implicit operator VARIANT(int x) => new(x);
		public static implicit operator VARIANT(string x) => new(x);
		
		public int ValueInt { get { Debug.Assert(vt == Api.VARENUM.VT_I4); return (int)value; } }
		public BSTR ValueBstr { get { Debug.Assert(vt == Api.VARENUM.VT_BSTR); return BSTR.AttachBSTR((char*)value); } }
		
		/// <summary>
		/// Calls <ms>VariantClear</ms>.
		/// </summary>
		public void Dispose() {
			_Clear();
		}
		
		void _Clear() {
			if (vt >= Api.VARENUM.VT_BSTR) Api.VariantClear(ref this);
			else vt = 0; //info: VariantClear just sets vt=0 and does not clear other members
		}
		
		/// <summary>
		/// Converts to string.
		/// </summary>
		public override string ToString() {
			return _ToString();
		}
		
		string _ToString() {
			switch (vt) {
			case Api.VARENUM.VT_BSTR: return value == default ? null : ValueBstr.ToString();
			case Api.VARENUM.VT_I4: return value.ToString();
			case 0: case Api.VARENUM.VT_NULL: return null;
			}
			VARIANT v2 = default;
			uint lcid = 0x409; //invariant
			switch (vt & (Api.VARENUM)0xff) { case Api.VARENUM.VT_DATE: case Api.VARENUM.VT_DISPATCH: lcid = 0x400; break; } //LOCALE_USER_DEFAULT
			if (0 != Api.VariantChangeTypeEx(ref v2, this, lcid, 2, Api.VARENUM.VT_BSTR)) return null; //2 VARIANT_ALPHABOOL
			return v2.value == default ? null : v2.ValueBstr.ToStringAndDispose();
		}
		
		/// <summary>
		/// Converts to string.
		/// Disposes this <c>VARIANT</c>.
		/// </summary>
		public string ToStringAndDispose() {
			var r = _ToString();
			Dispose();
			return r;
		}
	}
	
	internal unsafe struct BSTR : IDisposable {
		char* _p;
		
		BSTR(char* p) => _p = p;
		
		public static explicit operator BSTR(string s) => new((char*)Marshal.StringToBSTR(s));
		public static explicit operator nint(BSTR b) => (nint)b._p;
		
		public static BSTR AttachBSTR(char* bstr) => new(bstr);
		
		public static BSTR CopyFrom(char* anyString) => anyString == null ? default : Api.SysAllocString(anyString);
		
		public static BSTR Alloc(int len) => Api.SysAllocStringLen(null, len);
		
		public char* Ptr => _p;
		
		/// <summary>
		/// Returns <c>true</c> if the string is <c>null</c>.
		/// </summary>
		public bool Is0 => _p == null;
		
		public int Length => _p == null ? 0 : Api.SysStringLen(_p);
		
		/// <summary>
		/// Unsafe.
		/// </summary>
		public char this[int i] => _p[i];
		
		/// <summary>
		/// Converts to string.
		/// Does not dispose.
		/// </summary>
		public override string ToString() {
			var p = _p; if (p == null) return null;
			return Marshal.PtrToStringBSTR((IntPtr)_p);
		}
		
		/// <summary>
		/// Converts to string and disposes.
		/// </summary>
		public string ToStringAndDispose() {
			var p = _p; if (p == null) return null;
			int len = Api.SysStringLen(p);
			
			//rejected:
			//Some objects can return BSTR containing '\0's. Then probably the rest of string is garbage. I never noticed this but saw comments. Better allow '\0's, because in some cases it can be valid string. When invalid, it will not harm too much.
			//int len2 = Ptr_.Length(p, len); Debug_.PrintIf(len2 != len, "BSTR with '\\0'"); len = len2;
			
			string r = len == 0 ? "" : new string(p, 0, len);
			Dispose();
			return r;
		}
		
		public void Dispose() {
			var t = _p;
			if (t != null) {
				_p = null;
				Api.SysFreeString(t);
			}
		}
	}
	
}


================================================
FILE: Au/Au.Types/unused/AuClassless.cs
================================================
//rejected
//namespace Au.Types
//{
//	/// <summary>
//	/// Contains functions of this library that can be called without a class, like <c>Function()</c> instead of <c>Class.Function()</c>.
//	/// In file global.cs: <c>global using static Au.Types.AuClassless;</c>.
//	/// Currently empty. Reserved for the future.
//	/// </summary>
//	public static class AuClassless
//	{
//		//public static void TestClassless() { }
//	}
//}


================================================
FILE: Au/Au.cs
================================================
/*/
role classLibrary;
define IDE_LA,AU,NO_GLOBAL,NO_DEFAULT_CHARSET_UNICODE;
noWarnings 419,649;
preBuild ..\@Au.Editor\_prePostBuild.cs;
outputPath %folders.Workspace%\dll;
miscFlags 1;
noRef *\Au.dll;
resource resources\red_cross_cursor.cur /path;
/*/

//Using outputPath %folders.Workspace%\dll; instead of outputPath %folders.Workspace%\..\Au.Editor; because the compiler would replace Au.dll with the older version.
//	_prePostBuild will copy Au.dll to Au.Editor.


================================================
FILE: Au/Au.csproj
================================================
<Project Sdk="Microsoft.NET.Sdk">

	<PropertyGroup>
		<TargetFramework>net10.0-windows</TargetFramework>
		<UseWindowsForms>true</UseWindowsForms>
		<UseWpf>true</UseWpf>
		<GenerateAssemblyInfo>false</GenerateAssemblyInfo>
		<AssemblyName>Au</AssemblyName>
		<RootNamespace>Au</RootNamespace>
		<SignAssembly>true</SignAssembly>
		<AssemblyOriginatorKeyFile>..\Au.snk</AssemblyOriginatorKeyFile>
		<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
		<DocumentationFile>bin\Au.xml</DocumentationFile>
		<NoWarn>419;8981</NoWarn>
		<LangVersion>preview</LangVersion>
		<NoDefaultLaunchSettingsFile>true</NoDefaultLaunchSettingsFile>
		<NoWin32Manifest>true</NoWin32Manifest>
		<ProduceReferenceAssembly>False</ProduceReferenceAssembly>
		<NuGetAudit>False</NuGetAudit>
		<Platforms>AnyCPU</Platforms>
	</PropertyGroup>

	<!-- NuGet package. -->
	<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">
		<Version>1.1.6</Version>
		<!--
		To create NuGet package is used script "Create NuGet package".
		Notes if creating manually:
			Update <Version>.
			For NuGet package need multiple target frameworks. But it makes compilation slow.
			Workaround - temporarily use different TargetFrameworks when creating NuGet package.
			Possible problem: error when building after changing TargetFrameworks. Missing target framework in the assets json file.
				Workaround: delete obj folder.
			Possible problem: VS may not build for multiple frameworks soon after editing this file.
				Make sure the output files have correct date. Build again if need.
		-->
		
		<PackageId>LibreAutomate</PackageId>
		<Title>LibreAutomate</Title>
		<Authors>didgeridoo</Authors>
		<Product>LibreAutomate</Product>
		<Description>LibreAutomate is an automation library for Windows. Mostly desktop and web UI automation. To get the most of it, install the LibreAutomate app.</Description>
		<Copyright>Copyright (c) Gintaras Didžgalvis 2025</Copyright>
		<PackageProjectUrl>https://www.libreautomate.com</PackageProjectUrl>
		<PackageIcon>Icon-128.png</PackageIcon>
		<PackageReadmeFile>NuGet.md</PackageReadmeFile>
		<RepositoryUrl>https://github.com/qgindi/LibreAutomate</RepositoryUrl>
		<RepositoryType>git</RepositoryType>
		<PackageTags>UI automation;automate;windows;desktop;web;UI;hotkey;autotext;trigger;toolbar;keys;mouse;keyboard;clipboard;send;task</PackageTags>
		<PackageLicenseExpression>MIT</PackageLicenseExpression>
		<GeneratePackageOnBuild>False</GeneratePackageOnBuild>
	</PropertyGroup>
	<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
	  <DebugType>portable</DebugType>
	  <DefineConstants>$(DefineConstants);AU</DefineConstants>
	</PropertyGroup>
	<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">
	  <DebugType>portable</DebugType>
	  <DefineConstants>$(DefineConstants);AU</DefineConstants>
	</PropertyGroup>

	<ItemGroup>
		<None Remove="resources\red_cross_cursor.cur" />
	</ItemGroup>

	<ItemGroup>
		<Resource Include="resources\red_cross_cursor.cur" />
	</ItemGroup>

	<ItemGroup>
		<None Include="x\Icon-128.png" Pack="true" PackagePath="\" />
		<None Include="x\NuGet.md" Pack="true" PackagePath="\" />
	</ItemGroup>

	<ItemGroup>
		<Compile Remove="Au.cs" />
	</ItemGroup>

</Project>


================================================
FILE: Au/Ext/Bitmap.Resize.cs
================================================
//The main code is from FreeImage sources.

using System.Drawing;
using System.Drawing.Imaging;

namespace Au.Types;

/// <summary>
/// Used with <see cref="ExtMisc.Resize"/>
/// </summary>
public enum BRFilter {
	/// <summary>Produces sharper image (less blurry) than <c>Graphics.DrawImage</c> with <c>InterpolationMode.HighQualityBicubic</c>.</summary>
	Lanczos3,

	/// <summary>Produces slightly sharper image (less blurry) than <c>Graphics.DrawImage</c> with <c>InterpolationMode.HighQualityBicubic</c>.</summary>
	CatmullRom,

	/// <summary>Produces image similar to <c>Graphics.DrawImage</c> with <c>InterpolationMode.HighQualityBicubic</c>.</summary>
	Bicubic
}

public static partial class ExtMisc {
	/// <summary>
	/// Resizes this image.
	/// </summary>
	/// <returns>Resized image (new object). Returns this image if new width and height would be the same as of this image.</returns>
	/// <param name="b"></param>
	/// <param name="width">New width.</param>
	/// <param name="height">New height. If <i>width</i> or <i>height</i> is 0, calculates it (preserves aspect ratio).</param>
	/// <param name="filter"></param>
	/// <param name="dispose">When resized, call <c>Dispose</c> for this object.</param>
	/// <param name="premultiplied">
	/// Let the resized bitmap have <c>PixelFormat</c> = <c>Format32bppPArgb</c>. It prevents distortions at transparent-opaque boundaries.
	/// If <c>false</c>: if this bitmap has <c>Format32bppArgb</c> or <c>Format32bppPArgb</c>, does not change, else <c>PixelFormat.Format32bppArgb</c>.
	/// </param>
	/// <exception cref="ArgumentException">Unsupported <c>PixelFormat</c>.</exception>
	public static unsafe Bitmap Resize(this Bitmap b, int width, int height, BRFilter filter, bool dispose, bool premultiplied = false) {
		int wid1 = b.Width, hei1 = b.Height;
		if (width < 1) width = Math.Max(1, Math2.MulDiv(wid1, height, hei1));
		if (height < 1) height = Math.Max(1, Math2.MulDiv(hei1, width, wid1));
		if (width == wid1 && height == hei1) return b;

		var pf = b.PixelFormat;
		if (pf == PixelFormat.Format32bppPArgb) premultiplied = true;
		else if (premultiplied) pf = PixelFormat.Format32bppPArgb;
		else if(pf is not (PixelFormat.Format32bppArgb or PixelFormat.Format32bppRgb)) pf = PixelFormat.Format32bppArgb;

		var r = new Bitmap(width, height, pf);
		var d1 = b.LockBits(new(0, 0, wid1, hei1), ImageLockMode.ReadOnly, pf);
		var d2 = r.LockBits(new(0, 0, width, height), ImageLockMode.ReadWrite, pf);
		try {
			_FreeImage.Resize((byte*)d1.Scan0, wid1, hei1, (byte*)d2.Scan0, width, height, filter, premultiplied);
		}
		finally {
			b.UnlockBits(d1);
			r.UnlockBits(d2);
		}

		if (dispose) b.Dispose();
		return r;
	}

	/// <inheritdoc cref="Resize(Bitmap, int, int, BRFilter, bool, bool)"/>
	/// <param name="factor">Scaling factor. For example 2 to make 2 times bigger, or 0.5 to make 2 times smaller.</param>
	public static Bitmap Resize(this Bitmap b, double factor, BRFilter filter, bool dispose, bool premultiplied = false) {
		if (factor == 1) return b;
		var z = b.Size;
		int wid = (z.Width * factor).ToInt(), hei = (z.Height * factor).ToInt();
		if (wid == z.Width && hei == z.Height) return b;
		return Resize(b, wid, hei, filter, dispose, premultiplied);
	}

	static unsafe class _FreeImage {
		internal static void Resize(byte* src, int srcWidth, int srcHeight, byte* dst, int dstWidth, int dstHeight, BRFilter filter, bool premultiplied) {
			_Filter filt = filter switch {
				BRFilter.Lanczos3 => new _FilterLanczos3(),
				BRFilter.CatmullRom => new _FilterCatmullRom(),
				BRFilter.Bicubic => new _FilterBicubic(),
				_ => null
			};

			byte* tmp;

			if (dstWidth <= srcWidth) {
				// xy filtering

				if (srcWidth != dstWidth) {
					// source and destination widths are different so, we must
					// filter horizontally
					if (srcHeight != dstHeight) {
						// source and destination heights are also different so, we need
						// a temporary image
						tmp = MemoryUtil.Alloc(dstWidth * srcHeight * 4);
					} else {
						// source and destination heights are equal so, we can directly
						// factor into destination image (second filter method will not
						// be invoked)
						tmp = dst;
					}

					// factor source image horizontally into temporary (or destination) image
					_horizontalFilter(src, srcHeight, srcWidth, tmp, dstWidth, filt, premultiplied);
				} else {
					// source and destination widths are equal so, just copy the
					// image pointer
					tmp = src;
				}

				if (srcHeight != dstHeight) {
					// source and destination heights are different so, factor
					// temporary (or source) image vertically into destination image
					_verticalFilter(tmp, dstWidth, srcHeight, dst, dstHeight, filt, premultiplied);
				}
			} else {
				// yx filtering

				if (srcHeight != dstHeight) {
					// source and destination heights are different so, we must
					// filter vertically
					if (srcWidth != dstWidth) {
						// source and destination widths are also different so, we need
						// a temporary image
						tmp = MemoryUtil.Alloc(srcWidth * dstHeight * 4);
					} else {
						// source and destination widths are equal so, we can directly
						// factor into destination image (second filter method will not
						// be invoked)
						tmp = dst;
					}

					// factor source image vertically into temporary (or destination) image
					_verticalFilter(src, srcWidth, srcHeight, tmp, dstHeight, filt, premultiplied);
				} else {
					// source and destination heights are equal so, just copy the
					// image pointer
					tmp = src;
				}

				if (srcWidth != dstWidth) {
					// source and destination heights are different so, factor
					// temporary (or source) image horizontally into destination image
					_horizontalFilter(tmp, dstHeight, srcWidth, dst, dstWidth, filt, premultiplied);
				}
			}

			// free temporary image, if not pointing to either src or dst
			if (tmp != src && tmp != dst) MemoryUtil.Free(tmp);
		}

		const int FI_RGBA_RED = 2, FI_RGBA_GREEN = 1, FI_RGBA_BLUE = 0, FI_RGBA_ALPHA = 3;

		static void _horizontalFilter(byte* src, int height, int srcWidth, byte* dst, int dstWidth, _Filter filter, bool premultiplied) {
			// allocate and calculate the contributions
			_WeightsTable weightsTable = new(filter, dstWidth, srcWidth);

			// step through rows
			for (int y = 0; y < height; y++) {
				// factor each row
				byte* src_bits = src + srcWidth * 4 * y;
				byte* dst_bits = dst + dstWidth * 4 * y;

				for (int x = 0; x < dstWidth; x++) {
					// loop through row
					int iLeft = weightsTable.getLeftBoundary(x);
					int iLimit = weightsTable.getRightBoundary(x) - iLeft;
					byte* pixel = src_bits + iLeft * 4;
					double r = 0, g = 0, b = 0, a = 0;

					for (int i = 0; i < iLimit; i++) {
						// scan between boundaries
						// accumulate weighted effect of each neighboring pixel
						double weight = weightsTable.getWeight(x, i);
						r += (weight * pixel[FI_RGBA_RED]);
						g += (weight * pixel[FI_RGBA_GREEN]);
						b += (weight * pixel[FI_RGBA_BLUE]);
						a += (weight * pixel[FI_RGBA_ALPHA]);
						pixel += 4;
					}

					// clamp and place result in destination pixel
					int ai = Math.Clamp((int)(a + 0.5), 0, 0xFF);
					dst_bits[FI_RGBA_ALPHA] = (byte)ai;
					if (!premultiplied) ai = 0xFF; //else colors cannot be > alpha
					dst_bits[FI_RGBA_RED] = (byte)Math.Clamp((int)(r + 0.5), 0, ai);
					dst_bits[FI_RGBA_GREEN] = (byte)Math.Clamp((int)(g + 0.5), 0, ai);
					dst_bits[FI_RGBA_BLUE] = (byte)Math.Clamp((int)(b + 0.5), 0, ai);
					dst_bits += 4;
				}
			}
		}

		static void _verticalFilter(byte* src, int width, int srcHeight, byte* dst, int dstHeight, _Filter filter, bool premultiplied) {
			// allocate and calculate the contributions
			_WeightsTable weightsTable = new(filter, dstHeight, srcHeight);

			// step through columns
			byte* src_base = src;
			byte* dst_base = dst;
			int src_pitch = width * 4;
			int dst_pitch = src_pitch;

			for (int x = 0; x < width; x++) {
				// work on column x in dst
				int index = x * 4;
				byte* dst_bits = dst_base + index;

				// factor each column
				for (int y = 0; y < dstHeight; y++) {
					// loop through column
					int iLeft = weightsTable.getLeftBoundary(y);
					int iLimit = weightsTable.getRightBoundary(y) - iLeft;
					byte* src_bits = src_base + iLeft * src_pitch + index;
					double r = 0, g = 0, b = 0, a = 0;

					for (int i = 0; i < iLimit; i++) {
						// scan between boundaries
						// accumulate weighted effect of each neighboring pixel
						double weight = weightsTable.getWeight(y, i);
						r += (weight * src_bits[FI_RGBA_RED]);
						g += (weight * src_bits[FI_RGBA_GREEN]);
						b += (weight * src_bits[FI_RGBA_BLUE]);
						a += (weight * src_bits[FI_RGBA_ALPHA]);
						src_bits += src_pitch;
					}

					// clamp and place result in destination pixel
					int ai = Math.Clamp((int)(a + 0.5), 0, 0xFF);
					dst_bits[FI_RGBA_ALPHA] = (byte)ai;
					if (!premultiplied) ai = 0xFF; //else colors cannot be > alpha
					dst_bits[FI_RGBA_RED] = (byte)Math.Clamp((int)(r + 0.5), 0, ai);
					dst_bits[FI_RGBA_GREEN] = (byte)Math.Clamp((int)(g + 0.5), 0, ai);
					dst_bits[FI_RGBA_BLUE] = (byte)Math.Clamp((int)(b + 0.5), 0, ai);
					dst_bits += dst_pitch;
				}
			}
		}

		struct _WeightsTable {
			_Contribution[] _table;
			int _windowSize;
			int _lineLength;

			public _WeightsTable(_Filter filter, int uDstSize, int uSrcSize) {
				double dWidth;
				double dFScale;
				double dFilterWidth = filter.width;

				// factor factor
				double dScale = (double)uDstSize / uSrcSize;

				if (dScale < 1.0) {
					// minification
					dWidth = dFilterWidth / dScale;
					dFScale = dScale;
				} else {
					// magnification
					dWidth = dFilterWidth;
					dFScale = 1.0;
				}

				// allocate a new line contributions structure
				//
				// window size is the number of sampled pixels
				_windowSize = 2 * (int)Math.Ceiling(dWidth) + 1;
				// length of dst line (no. of rows / cols) 
				_lineLength = uDstSize;

				// allocate list of contributions 
				_table = new _Contribution[_lineLength];
				for (int u = 0; u < _lineLength; u++) {
					// allocate contributions for every pixel
					_table[u].Weights = new double[_windowSize];
				}

				// offset for discrete to continuous coordinate conversion
				double dOffset = 0.5 / dScale;

				for (int u = 0; u < _lineLength; u++) {
					// scan through line of contributions

					// inverse mapping (discrete dst 'u' to continous src 'dCenter')
					double dCenter = u / dScale + dOffset;

					// find the significant edge points that affect the pixel
					int iLeft = Math.Max(0, (int)(dCenter - dWidth + 0.5));
					int iRight = Math.Min((int)(dCenter + dWidth + 0.5), uSrcSize);

					_table[u].Left = iLeft;
					_table[u].Right = iRight;

					double dTotalWeight = 0;  // sum of weights (initialized to zero)
					for (int iSrc = iLeft; iSrc < iRight; iSrc++) {
						// calculate weights
						double weight = dFScale * filter.Filter(dFScale * (iSrc + 0.5 - dCenter));
						_table[u].Weights[iSrc - iLeft] = weight;
						dTotalWeight += weight;
					}
					if ((dTotalWeight > 0) && (dTotalWeight != 1)) {
						// normalize weight of neighbouring points
						for (int iSrc = iLeft; iSrc < iRight; iSrc++) {
							// normalize point
							_table[u].Weights[iSrc - iLeft] /= dTotalWeight;
						}
					}

					// simplify the filter, discarding null weights at the right
					{
						int iTrailing = iRight - iLeft - 1;
						while (_table[u].Weights[iTrailing] == 0) {
							_table[u].Right--;
							iTrailing--;
							if (_table[u].Right == _table[u].Left) {
								break;
							}
						}

					}

				} // next dst pixel
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public double getWeight(int dst_pos, int src_pos) {
				return _table[dst_pos].Weights[src_pos];
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public int getLeftBoundary(int dst_pos) {
				return _table[dst_pos].Left;
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public int getRightBoundary(int dst_pos) {
				return _table[dst_pos].Right;
			}

			struct _Contribution {
				public double[] Weights;
				public int Left, Right;
			}
		}

#if true
		abstract class _Filter {
			public abstract double width { get; }

			public abstract double Filter(double dVal);
		}

		class _FilterLanczos3 : _Filter {
			public override double width => 3;

			public override double Filter(double dVal) {
				dVal = Math.Abs(dVal);
				if (dVal < width) {
					return (_sinc(dVal) * _sinc(dVal / width));
				}
				return 0;
			}

			static double _sinc(double value) {
				if (value != 0) {
					value *= Math.PI;
					return (Math.Sin(value) / value);
				}
				return 1;
			}
		}

		class _FilterCatmullRom : _Filter {
			public override double width => 2;

			public override double Filter(double dVal) {
				if (dVal < -2) return 0;
				if (dVal < -1) return (0.5 * (4 + dVal * (8 + dVal * (5 + dVal))));
				if (dVal < 0) return (0.5 * (2 + dVal * dVal * (-5 - 3 * dVal)));
				if (dVal < 1) return (0.5 * (2 + dVal * dVal * (-5 + 3 * dVal)));
				if (dVal < 2) return (0.5 * (4 + dVal * (-8 + dVal * (5 - dVal))));
				return 0;
			}
		}

		class _FilterBicubic : _Filter {
			readonly double p0, p2, p3;
			readonly double q0, q1, q2, q3;

			public _FilterBicubic() {
				double b = 1 / 3d, c = b;
				p0 = (6 - 2 * b) / 6;
				p2 = (-18 + 12 * b + 6 * c) / 6;
				p3 = (12 - 9 * b - 6 * c) / 6;
				q0 = (8 * b + 24 * c) / 6;
				q1 = (-12 * b - 48 * c) / 6;
				q2 = (6 * b + 30 * c) / 6;
				q3 = (-b - 6 * c) / 6;
			}

			public override double width => 2;

			public override double Filter(double dVal) {
				dVal = Math.Abs(dVal);
				if (dVal < 1)
					return (p0 + dVal * dVal * (p2 + dVal * p3));
				if (dVal < 2)
					return (q0 + dVal * (q1 + dVal * (q2 + dVal * q3)));
				return 0;
			}
		}
#else
		class _Filter {
			public readonly double width = 3;

			public double Filter(double dVal) {
				dVal = Math.Abs(dVal);
				if (dVal < width) {
					return (_sinc(dVal) * _sinc(dVal / width));
				}
				return 0;
			}

			static double _sinc(double value) {
				if (value != 0) {
					value *= Math.PI;
					return (Math.Sin(value) / value);
				}
				return 1;
			}
		}
#endif
	}
}


================================================
FILE: Au/Ext/ExtMisc.cs
================================================
//note: be careful when adding functions to this class. Eg something may load winforms dlls although it seems not used.

using System.Drawing;
using System.Drawing.Imaging;
using Microsoft.Win32;

namespace Au.Types;

/// <summary>
/// Adds extension methods for some .NET types.
/// </summary>
[DebuggerStepThrough]
public static unsafe partial class ExtMisc {
	#region value types
	
	/// <summary>
	/// Converts to <c>int</c> with rounding.
	/// Calls <see cref="Convert.ToInt32(double)"/>.
	/// </summary>
	/// <exception cref="OverflowException"></exception>
	public static int ToInt(this double t) => Convert.ToInt32(t);
	
	/// <summary>
	/// Converts to <c>int</c> with rounding.
	/// Calls <see cref="Convert.ToInt32(float)"/>.
	/// </summary>
	/// <exception cref="OverflowException"></exception>
	public static int ToInt(this float t) => Convert.ToInt32(t);
	
	/// <summary>
	/// Converts to <c>int</c> with rounding.
	/// Calls <see cref="Convert.ToInt32(decimal)"/>.
	/// </summary>
	/// <exception cref="OverflowException"></exception>
	public static int ToInt(this decimal t) => Convert.ToInt32(t);
	
	//rejected. Too simple, and nobody would find and use.
	///// <summary>
	///// Converts to <c>int</c>.
	///// Can be used like <c>0xff123456.ToInt()</c> instead of <c>unchecked((int)0xff123456)</c>.
	///// </summary>
	//public static int ToInt(this uint t) => unchecked((int)t);
	
	///// <summary>
	///// Converts to <c>Color</c>.
	///// Can be used like <c>0xff123456.ToColor_()</c> instead of <c>Color.FromArgb(unchecked((int)0xff123456))</c>.
	///// </summary>
	///// <param name="t"></param>
	///// <param name="makeOpaque">Add 0xff000000.</param>
	//internal static Color ToColor_(this uint t, bool makeOpaque = true)
	//	=> Color.FromArgb(unchecked((int)(t | (makeOpaque ? 0xff000000 : 0))));
	
	/// <summary>
	/// Converts to <c>Color</c>. Makes opaque (alpha 0xff).
	/// Can be used like <c>0x123456.ToColor_()</c> instead of <c>Color.FromArgb(unchecked((int)0xff123456))</c>.
	/// </summary>
	internal static Color ToColor_(this int t, bool bgr = false) {
		if (bgr) t = ColorInt.SwapRB(t);
		return Color.FromArgb(unchecked(0xff << 24 | t));
	}
	
	/// <summary>
	/// Converts <c>double</c> to <c>string</c>.
	/// Uses invariant culture, therefore decimal point is always <c>'.'</c>, not <c>','</c> etc.
	/// Calls <see cref="double.ToString(string, IFormatProvider)"/>.
	/// </summary>
	public static string ToS(this double t, string format = null) {
		return t.ToString(format, NumberFormatInfo.InvariantInfo);
	}
	
	/// <summary>
	/// Converts <c>float</c> to <c>string</c>.
	/// Uses invariant culture, therefore decimal point is always <c>'.'</c>, not <c>','</c> etc.
	/// Calls <see cref="float.ToString(string, IFormatProvider)"/>.
	/// </summary>
	public static string ToS(this float t, string format = null) {
		return t.ToString(format, NumberFormatInfo.InvariantInfo);
	}
	
	/// <summary>
	/// Converts <c>decimal</c> to <c>string</c>.
	/// Uses invariant culture, therefore decimal point is always <c>'.'</c>, not <c>','</c> etc.
	/// Calls <see cref="decimal.ToString(string, IFormatProvider)"/>.
	/// </summary>
	public static string ToS(this decimal t, string format = null) {
		return t.ToString(format, NumberFormatInfo.InvariantInfo);
	}
	
	/// <summary>
	/// Converts <c>int</c> to <c>string</c>.
	/// Uses invariant culture, therefore minus sign is always ASCII <c>'-',</c> not <c>'−'</c> etc.
	/// Calls <see cref="int.ToString(string, IFormatProvider)"/>.
	/// </summary>
	public static string ToS(this int t, string format = null) {
		return t.ToString(format, NumberFormatInfo.InvariantInfo);
	}
	
	/// <summary>
	/// Converts <c>long</c> to <c>string</c>.
	/// Uses invariant culture, therefore minus sign is always ASCII <c>'-'</c>, not <c>'−'</c> etc.
	/// Calls <see cref="double.ToString(string, IFormatProvider)"/>.
	/// </summary>
	public static string ToS(this long t, string format = null) {
		return t.ToString(format, NumberFormatInfo.InvariantInfo);
	}
	
	/// <summary>
	/// Converts <c>nint</c> to <c>string</c>.
	/// Uses invariant culture, therefore minus sign is always ASCII <c>'-'</c>, not <c>'−'</c> etc.
	/// Calls <see cref="IntPtr.ToString(string, IFormatProvider)"/>.
	/// </summary>
	public static string ToS(this nint t, string format = null) {
		return t.ToString(format, NumberFormatInfo.InvariantInfo);
	}
	//cref not nint.ToString because DocFX does not support it.
	
	/// <summary>
	/// Returns <c><![CDATA[(this >= min && this <= max) ? this : defaultValue]]></c>.
	/// </summary>
    internal static int EnsureValid_(this int t, int min, int max, int defaultValue = 0)
        => (t >= min && t <= max) ? t : defaultValue;
	
	//rare
	///// <summary>
	///// Returns <c>true</c> if <c>t.Width &lt;= 0 || t.Height &lt;= 0</c>.
	///// Note: <c>Rectangle.IsEmpty</c> returns <c>true</c> only when all fields are 0.
	///// </summary>
	//[MethodImpl(MethodImplOptions.AggressiveInlining)]
	//public static bool NoArea(this Rectangle t) {
	//	return t.Width <= 0 || t.Height <= 0;
	//}
	
	/// <summary>
	/// Calls <see cref="Range.GetOffsetAndLength"/> and returns start and end instead of start and length.
	/// </summary>
	/// <param name="t"></param>
	/// <param name="length"></param>
	/// <exception cref="ArgumentOutOfRangeException"></exception>
	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	public static (int start, int end) GetStartEnd(this Range t, int length) {
		var v = t.GetOffsetAndLength(length);
		return (v.Offset, v.Offset + v.Length);
	}
	
	/// <summary>
	/// If this is <c>null</c>, returns <c>(0, length)</c>. Else calls <see cref="Range.GetOffsetAndLength"/> and returns start and end instead of start and length.
	/// </summary>
	/// <param name="t"></param>
	/// <param name="length"></param>
	/// <exception cref="ArgumentOutOfRangeException"></exception>
	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	public static (int start, int end) GetStartEnd(this Range? t, int length)
		=> t?.GetStartEnd(length) ?? (0, length);
	
	/// <summary>
	/// If this is <c>null</c>, returns <c>(0, length)</c>. Else calls <see cref="Range.GetOffsetAndLength"/>.
	/// </summary>
	/// <param name="t"></param>
	/// <param name="length"></param>
	/// <exception cref="ArgumentOutOfRangeException"></exception>
	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	public static (int Offset, int Length) GetOffsetAndLength(this Range? t, int length)
		=> t?.GetOffsetAndLength(length) ?? (0, length);
	
	/// <summary>
	/// Returns <c>true</c> if null pointer.
	/// </summary>
	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	public static bool IsNull<T>(this ReadOnlySpan<T> t) => t == ReadOnlySpan<T>.Empty;
	
	//currently not used. Creates shorter string than ToString.
	///// <summary>
	///// Converts this <c>Guid</c> to Base64 string.
	///// </summary>
	//public static string ToBase64(this Guid t) => Convert.ToBase64String(new RByte((byte*)&t, sizeof(Guid)));
	
	//rejected: too simple. We have print.it(uint), also can use $"0x{t:X}" or "0x" + t.ToString("X").
	///// <summary>
	///// Converts <c>int</c> to hexadecimal string like <c>"0x3A"</c>.
	///// </summary>
	//public static string ToHex(this int t)
	//{
	//	return "0x" + t.ToString("X");
	//}
	
	#endregion
	
	#region enum
	
	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	static long _ToLong<T>(T v) where T : unmanaged, Enum {
		if (sizeof(T) == 4) return *(int*)&v;
		if (sizeof(T) == 8) return *(long*)&v;
		if (sizeof(T) == 2) return *(short*)&v;
		return *(byte*)&v;
		//Compiler removes the if(sizeof(T) == n) and code that is unused with that size, because sizeof(T) is const.
		//Faster than with switch(sizeof(T)). It seems the switch code is considered too big to be inlined.
	}
	
	//same. Was faster when tested in the past.
	//[MethodImpl(MethodImplOptions.AggressiveInlining)]
	//static long _ToLong2<T>(T v) where T : unmanaged, Enum
	//{
	//	if(sizeof(T) == 4) return Unsafe.As<T, int>(ref v);
	//	if(sizeof(T) == 8) return Unsafe.As<T, long>(ref v);
	//	if(sizeof(T) == 2) return Unsafe.As<T, short>(ref v);
	//	return Unsafe.As<T, byte>(ref v);
	//}
	
	/// <summary>
	/// Returns <c>true</c> if this enum variable has all flag bits specified in <i>flag</i>.
	/// </summary>
	/// <param name="t"></param>
	/// <param name="flag">One or more flags.</param>
	/// <remarks>
	/// The same as code <c>(t &amp; flag) == flag</c> or <see cref="Enum.HasFlag"/>.
	/// </remarks>
	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	public static bool Has<T>(this T t, T flag) where T : unmanaged, Enum {
#if false //Enum.HasFlag used to be slow, but now compiler for it creates the same code as with operator
			return t.HasFlag(flag);
			//However cannot use this because of JIT compiler bug: in some cases Has returns true when no flag.
			//Noticed it in TriggerActionThreads.Run in finally{} of actionWrapper, code o.flags.Has(TOFlags.Single).
			//It was elusive, difficult to debug, only in Release, and only after some time/times, when tiered JIT fully optimizes.
			//When Has returned true, print.it showed that flags is 0.
			//No bug if HasFlag called directly, not in extension method.
#elif true //slightly slower than Enum.HasFlag and code as with operator
		var m = _ToLong(flag);
		return (_ToLong(t) & m) == m;
#else //slower
			switch(sizeof(T)) {
			case 4: {
				var a = Unsafe.As<T, uint>(ref t);
				var b = Unsafe.As<T, uint>(ref flag);
				return (a & b) == b;
			}
			case 8: {
				var a = Unsafe.As<T, ulong>(ref t);
				var b = Unsafe.As<T, ulong>(ref flag);
				return (a & b) == b;
			}
			case 2: {
				var a = Unsafe.As<T, ushort>(ref t);
				var b = Unsafe.As<T, ushort>(ref flag);
				return (a & b) == b;
			}
			default: {
				var a = Unsafe.As<T, byte>(ref t);
				var b = Unsafe.As<T, byte>(ref flag);
				return (a & b) == b;
			}
			}
			//compiler removes the switch/case, because sizeof(T) is const
#endif
	}
	
	/// <summary>
	/// Returns <c>true</c> if this enum variable has one or more flag bits specified in <i>flags</i>.
	/// </summary>
	/// <param name="t"></param>
	/// <param name="flags">One or more flags.</param>
	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	public static bool HasAny<T>(this T t, T flags) where T : unmanaged, Enum {
		return (_ToLong(t) & _ToLong(flags)) != 0;
	}
	
	//slower
	//[MethodImpl(MethodImplOptions.AggressiveInlining)]
	//public static bool HasAny5<T>(this T t, T flags) where T : unmanaged, Enum
	//{
	//	if(sizeof(T) == 4) return (*(int*)&t & *(int*)&flags) != 0;
	//	if(sizeof(T) == 8) return (*(long*)&t & *(long*)&flags) != 0;
	//	if(sizeof(T) == 2) return (*(short*)&t & *(short*)&flags) != 0;
	//	return (*(byte*)&t & *(byte*)&flags) != 0;
	//}
	
	/// <summary>
	/// Adds or removes a flag or flags.
	/// </summary>
	/// <param name="t"></param>
	/// <param name="flag">One or more flags to add or remove.</param>
	/// <param name="add">If <c>true</c>, adds flag, else removes flag.</param>
	[MethodImpl(MethodImplOptions.AggressiveOptimization)]
	public static void SetFlag<T>(ref this T t, T flag, bool add) where T : unmanaged, Enum {
		long a = _ToLong(t), b = _ToLong(flag);
		if (add) a |= b; else a &= ~b;
		t = *(T*)&a;
	}
	
	/// <summary>
	/// Adds or removes a flag or flags.
	/// </summary>
	/// <param name="flag">Flag(s) to add or remove.</param>
	/// <param name="add">If <c>true</c>, adds the flag(s) (<c>t |= flag</c>), else removes (<c>t &amp;= ~flag</c>).</param>
	internal static void SetFlag_(this ref int t, int flag, bool add) {
		if (add) t |= flag; else t &= ~flag;
	}
	
	/// <inheritdoc cref="SetFlag_(ref int, int, bool)"/>
	internal static void SetFlag_(this ref uint t, uint flag, bool set) {
		if (set) t |= flag; else t &= ~flag;
	}
	
	/// <inheritdoc cref="SetFlag_(ref int, int, bool)"/>
	internal static void SetFlag_(this ref ushort t, ushort flag, bool set) {
		if (set) t |= flag; else t = (ushort)(t & ~flag);
	}
	
	/// <inheritdoc cref="SetFlag_(ref int, int, bool)"/>
	internal static void SetFlag_(this ref byte t, byte flag, bool set) {
		if (set) t |= flag; else t = (byte)(t & ~flag);
	}
	
	#endregion
	
	#region char
	
	/// <summary>
	/// Returns <c>true</c> if character is ASCII <c>'0'</c> to <c>'9'</c>.
	/// </summary>
	public static bool IsAsciiDigit(this char c) => char.IsAsciiDigit(c);
	
	/// <summary>
	/// Returns <c>true</c> if character is ASCII <c>'A'</c> to <c>'Z'</c> or <c>'a'</c> to <c>'z'</c>.
	/// </summary>
	//public static bool IsAsciiAlpha(this char c) => (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z');
	public static bool IsAsciiAlpha(this char c) => char.IsAsciiLetter(c);
	
	/// <summary>
	/// Returns <c>true</c> if character is ASCII <c>'A'</c> to <c>'Z'</c> or <c>'a'</c> to <c>'z'</c> or <c>'0'</c> to <c>'9'</c>.
	/// </summary>
	public static bool IsAsciiAlphaDigit(this char c) => char.IsAsciiLetterOrDigit(c);
	
	#endregion
	
	#region array
	
	/// <summary>
	/// Creates a copy of this array with one or more removed elements.
	/// </summary>
	/// <typeparam name="T"></typeparam>
	/// <param name="t"></param>
	/// <param name="index"></param>
	/// <param name="count"></param>
	/// <exception cref="ArgumentOutOfRangeException"></exception>
	public static T[] RemoveAt<T>(this T[] t, int index, int count = 1) {
		if ((uint)index > t.Length || count < 0 || index + count > t.Length) throw new ArgumentOutOfRangeException();
		int n = t.Length - count;
		if (n == 0) return [];
		var r = new T[n];
		for (int i = 0; i < index; i++) r[i] = t[i];
		for (int i = index; i < n; i++) r[i] = t[i + count];
		return r;
	}
	
	/// <summary>
	/// Creates a copy of this array with one inserted element.
	/// </summary>
	/// <typeparam name="T"></typeparam>
	/// <param name="t"></param>
	/// <param name="index">Where to insert. If -1, adds to the end.</param>
	/// <param name="value"></param>
	/// <exception cref="ArgumentOutOfRangeException"></exception>
	public static T[] InsertAt<T>(this T[] t, int index, T value = default) {
		if (index == -1) index = t.Length; else if ((uint)index > t.Length) throw new ArgumentOutOfRangeException();
		var r = new T[t.Length + 1];
		for (int i = 0; i < index; i++) r[i] = t[i];
		for (int i = index; i < t.Length; i++) r[i + 1] = t[i];
		r[index] = value;
		return r;
	}
	
	/// <summary>
	/// Creates a copy of this array with several inserted elements.
	/// </summary>
	/// <typeparam name="T"></typeparam>
	/// <param name="t"></param>
	/// <param name="index">Where to insert. If -1, adds to the end.</param>
	/// <param name="values"></param>
	/// <exception cref="ArgumentOutOfRangeException"></exception>
	public static T[] InsertAt<T>(this T[] t, int index, params ReadOnlySpan<T> values) {
		if (index == -1) index = t.Length; else if ((uint)index > t.Length) throw new ArgumentOutOfRangeException();
		int n = values.Length; if (n == 0) return t;
		
		var r = new T[t.Length + n];
		for (int i = 0; i < index; i++) r[i] = t[i];
		for (int i = index; i < t.Length; i++) r[i + n] = t[i];
		for (int i = 0; i < n; i++) r[i + index] = values[i];
		return r;
	}
	
	#endregion
	
	#region IEnumerable
	
	/// <summary>
	/// Removes items based on a predicate. For example, all items that have certain value.
	/// </summary>
	/// <typeparam name="TKey"></typeparam>
	/// <typeparam name="TValue"></typeparam>
	/// <param name="t"></param>
	/// <param name="predicate"></param>
	public static void RemoveWhere<TKey, TValue>(this Dictionary<TKey, TValue> t, Func<KeyValuePair<TKey, TValue>, bool> predicate) {
		foreach (var k in t.Where(predicate).Select(kv => kv.Key).ToArray()) { t.Remove(k); }
	}
	
	/// <summary>
	/// Gets a reference to a <c>TValue</c> in this dictionary, adding a new entry with a default value if the key does not exist.
	/// This extension method just calls <see cref="CollectionsMarshal.GetValueRefOrAddDefault"/>.
	/// </summary>
	/// <inheritdoc cref="CollectionsMarshal.GetValueRefOrAddDefault"/>
	/// <example>
	/// <code><![CDATA[
	/// var d = new Dictionary<string, int>();
	/// for (int i = 0; i < 3; i++) {
	/// 	ref var r = ref d.GetValueRefOrAddDefault("a", out bool exists);
	/// 	print.it(exists);
	/// 	if(!exists) r = 100; else r++;
	/// }
	/// print.it(d);
	/// ]]></code>
	/// </example>
	internal static ref TValue GetValueRefOrAddDefault_<TKey, TValue>(this Dictionary<TKey, TValue> t, TKey key, out bool exists) {
#pragma warning disable 9088 //weird and undocumented: "This returns a parameter by reference 'exists' but it is scoped to the current method"
		return ref CollectionsMarshal.GetValueRefOrAddDefault(t, key, out exists);
	}
	
	/// <summary>
	/// Gets a reference to a <c>TValue</c> in this dictionary. If the key does not exist, sets <i>exists</i> = <c>false</c> and returns a reference <c>null</c>.
	/// This extension method just calls <see cref="CollectionsMarshal.GetValueRefOrNullRef"/> and <see cref="Unsafe.IsNullRef"/>.
	/// </summary>
	/// <param name="exists">Receives <c>true</c> if the key exists.</param>
	/// <inheritdoc cref="CollectionsMarshal.GetValueRefOrNullRef"/>
	internal static ref TValue GetValueRefOrNullRef_<TKey, TValue>(this Dictionary<TKey, TValue> t, TKey key, out bool exists) {
		ref TValue r = ref CollectionsMarshal.GetValueRefOrNullRef(t, key);
		exists = !Unsafe.IsNullRef(ref r);
		return ref r;
	}
	
	/// <inheritdoc cref="CollectionsMarshal.AsSpan"/>
	public static Span<T> AsSpan<T>(this List<T> t)
		=> CollectionsMarshal.AsSpan(t);
	
	/// <summary>
	/// Gets a reference to an item.
	/// List items must not be added or removed while it is in use.
	/// </summary>
	/// <typeparam name="T"></typeparam>
	/// <param name="i">Item index.</param>
	public static ref T Ref<T>(this List<T> t, int i)
		=> ref CollectionsMarshal.AsSpan(t)[i];
	
	/// <summary>
	/// Adds key/value to dictionary. If the key already exists, adds the value to the same key as <c>List</c> item and returns the <c>List</c>; else returns <c>null</c>.
	/// </summary>
	/// <exception cref="ArgumentException">key/value already exists.</exception>
	internal static List<TValue> MultiAdd_<TKey, TValue>(this Dictionary<TKey, object> t, TKey k, TValue v) where TValue : class {
		if (t.TryAdd(k, v)) return null;
		var o = t[k];
		if (o is List<TValue> a) {
			if (!a.Contains(v)) { a.Add(v); return a; }
		} else {
			var g = o as TValue;
			if (g == null && o != null) throw new ArgumentException("bad type");
			if (v != g) { t[k] = a = new List<TValue> { g, v }; return a; }
		}
		throw new ArgumentException("key/value already exists");
	}
	
	/// <summary>
	/// If dictionary contains key <i>k</i> that contains value <i>v</i> (as single value or in <c>List</c>), removes the value (and key if it was single value) and returns <c>true</c>.
	/// </summary>
	internal static bool MultiRemove_<TKey, TValue>(this Dictionary<TKey, object> t, TKey k, TValue v) where TValue : class {
		if (!t.TryGetValue(k, out var o)) return false;
		if (o is List<TValue> a) {
			if (!a.Remove(v)) return false;
			if (a.Count == 1) t[k] = a[0];
		} else {
			var g = o as TValue;
			if (g == null && o != null) throw new ArgumentException("bad type");
			if (v != g) return false;
			t.Remove(k);
		}
		return true;
	}
	
	/// <summary>
	/// If dictionary contains key <i>k</i>, gets its value (<i>v</i>) or list of values (<i>a</i>) and returns <c>true</c>.
	/// </summary>
	/// <param name="t"></param>
	/// <param name="k"></param>
	/// <param name="v">Receives single value, or <c>null</c> if the key has multiple values.</param>
	/// <param name="a">Receives multiple values, or <c>null</c> if the key has single value.</param>
	internal static bool MultiGet_<TKey, TValue>(this Dictionary<TKey, object> t, TKey k, out TValue v, out List<TValue> a) where TValue : class {
		bool r = t.TryGetValue(k, out var o);
		v = o as TValue;
		a = o as List<TValue>;
		if (v == null && a == null && o != null) throw new ArgumentException("bad type");
		return r;
	}

#if true
	/// <summary>
	/// Returns <c>Length</c>, or 0 if <c>null</c>.
	/// </summary>
	internal static int Lenn_<T>(this T[] t) => t?.Length ?? 0;
	//internal static int Lenn_(this System.Collections.ICollection t) => t?.Count ?? 0; //slower, as well as Array
	
	/// <summary>
	/// Returns <c>Count</c>, or 0 if <c>null</c>.
	/// </summary>
	internal static int Lenn_<T>(this List<T> t) => t?.Count ?? 0;
	
	/// <summary>
	/// Returns <c>true</c> if <c>null</c> or <c>Length</c> == 0.
	/// </summary>
	internal static bool NE_<T>(this T[] t) => (t?.Length ?? 0) == 0;
	
	/// <summary>
	/// Returns <c>true</c> if <c>null</c> or <c>Count</c> == 0.
	/// </summary>
	internal static bool NE_<T>(this List<T> t) => (t?.Count ?? 0) == 0;
#else //still too early to use `extension` in this library. Eg then the XML file contains duplicate names (then exception in _DocumentationProvider.Create). Probably DocFX would not get it too.
	extension<T>(T[] t) { //with System.Collections.ICollection slower, as well as Array
		/// <summary>
		/// Returns <c>Length</c>, or 0 if <c>null</c>.
		/// </summary>
		internal int Lenn_ => t?.Length ?? 0;
		
		/// <summary>
		/// Returns <c>true</c> if <c>null</c> or <c>Length</c> == 0.
		/// </summary>
		internal bool NE_ => (t?.Length ?? 0) == 0;
	}
	
	extension<T>(List<T> t) {
		/// <summary>
		/// Returns <c>Count</c>, or 0 if <c>null</c>.
		/// </summary>
		internal int Lenn_ => t?.Count ?? 0;
		
		/// <summary>
		/// Returns <c>true</c> if <c>null</c> or <c>Count</c> == 0.
		/// </summary>
		internal bool NE_ => (t?.Count ?? 0) == 0;
	}
#endif

	/// <summary>
	/// Efficiently recursively gets descendants of this tree.
	/// <see href="https://stackoverflow.com/a/30441479/2547338"/>
	/// </summary>
	/// <typeparam name="T"></typeparam>
	/// <param name="t"></param>
	/// <param name="childSelector"></param>
	internal static IEnumerable<T> Descendants_<T>(this IEnumerable<T> t, Func<T, IEnumerable<T>> childSelector) {
		var stack = new Stack<IEnumerator<T>>();
		var enumerator = t.GetEnumerator();
		
		try {
			while (true) {
				if (enumerator.MoveNext()) {
					T element = enumerator.Current;
					yield return element;
					
					var e = childSelector(element)?.GetEnumerator();
					if (e != null) {
						stack.Push(enumerator);
						enumerator = e;
					}
				} else if (stack.Count > 0) {
					enumerator.Dispose();
					enumerator = stack.Pop();
				} else {
					yield break;
				}
			}
		}
		finally {
			enumerator.Dispose();
			
			while (stack.Count > 0) // Clean up in case of an exception.
			{
				enumerator = stack.Pop();
				enumerator.Dispose();
			}
		}
	}
	
	/// <summary>
	/// Efficiently recursively gets descendants of this tree.
	/// <see href="https://stackoverflow.com/a/30441479/2547338"/>
	/// </summary>
	/// <param name="t"></param>
	/// <param name="childSelector"></param>
	internal static System.Collections.IEnumerable Descendants_(this System.Collections.IEnumerable t, Func<object, System.Collections.IEnumerable> childSelector) {
		var stack = new Stack<System.Collections.IEnumerator>();
		var enumerator = t.GetEnumerator();
		
		while (true) {
			if (enumerator.MoveNext()) {
				object element = enumerator.Current;
				yield return element;
				
				var e = childSelector(element)?.GetEnumerator();
				if (e != null) {
					stack.Push(enumerator);
					enumerator = e;
				}
			} else if (stack.Count > 0) {
				enumerator = stack.Pop();
			} else {
				yield break;
			}
		}
	}
	
#endregion
	
	#region StringBuilder
	
	/// <summary>
	/// Appends string as new correctly formatted sentence.
	/// </summary>
	/// <returns>this.</returns>
	/// <param name="t"></param>
	/// <param name="s"></param>
	/// <param name="noUcase">Don't make the first character uppercase.</param>
	/// <remarks>
	/// If <i>s</i> is <c>null</c> or <c>""</c>, does nothing.
	/// If this is not empty, appends space.
	/// If <i>s</i> starts with a lowercase character, makes it uppercase, unless this ends with a character other than <c>'.'</c>.
	/// Appends <c>'.'</c> if <i>s</i> does not end with <c>'.'</c>, <c>';'</c>, <c>':'</c>, <c>','</c>, <c>'!'</c> or <c>'?'</c>.
	/// </remarks>
	public static StringBuilder AppendSentence(this StringBuilder t, string s, bool noUcase = false) {
		if (!s.NE()) {
			bool makeUcase = !noUcase && Char.IsLower(s[0]);
			if (t.Length > 0) {
				if (makeUcase && t[^1] != '.') makeUcase = false;
				t.Append(' ');
			}
			if (makeUcase) { t.Append(Char.ToUpper(s[0])).Append(s, 1, s.Length - 1); } else t.Append(s);
			switch (s[^1]) {
			case '.': case ';': case ':': case ',': case '!': case '?': break;
			default: t.Append('.'); break;
			}
		}
		return t;
	}
	
	#endregion
	
	#region winforms
	
	/// <summary>
	/// Gets window handle as <see cref="wnd"/>.
	/// </summary>
	/// <param name="t">A <c>Control</c> or <c>Form</c> etc. Cannot be <c>null</c>.</param>
	/// <param name="create">
	/// Create handle if still not created. Default <c>false</c> (return <c>default(wnd)</c>).
	/// Unlike <see cref="System.Windows.Forms.Control.CreateControl"/>, creates handle even if invisible. Does not create child control handles.
	/// </param>
	/// <remarks>
	/// Should be called in control's thread. Calls <see cref="System.Windows.Forms.Control.IsHandleCreated"/> and <see cref="System.Windows.Forms.Control.Handle"/>.
	/// </remarks>
	public static wnd Hwnd(this System.Windows.Forms.Control t, bool create = false)
		=> create || t.IsHandleCreated ? new wnd(t.Handle) : default;
	
	#endregion
	
	#region System.Drawing
	
	/// <summary>
	/// Draws inset or outset rectangle.
	/// </summary>
	/// <param name="t"></param>
	/// <param name="pen">Pen with integer width and default alignment.</param>
	/// <param name="r"></param>
	/// <param name="outset">Draw outset.</param>
	/// <remarks>
	/// Calls <see cref="Graphics.DrawRectangle"/> with arguments corrected so that it draws inside or outside <i>r</i>. Does not use <see cref="System.Drawing.Drawing2D.PenAlignment"/>, it is unreliable.
	/// </remarks>
	public static void DrawRectangleInset(this Graphics t, Pen pen, RECT r, bool outset = false) {
		if (r.NoArea) return;
		//pen.Alignment = PenAlignment.Inset; //no. Eg ignored if 1 pixel width.
		//	MSDN: "A Pen that has its alignment set to Inset will yield unreliable results, sometimes drawing in the inset position and sometimes in the centered position.".
		var r0 = r;
		int w = (int)pen.Width, d = w / 2;
		r.left += d; r.top += d;
		r.right -= d = w - d; r.bottom -= d;
		if (outset) r.Inflate(w, w);
		if (!r.NoArea) {
			t.DrawRectangle(pen, r);
		} else { //DrawRectangle does not draw if width or height 0, even if pen alignment is Outset
			t.FillRectangle(pen.Brush, r0); //never mind dash style etc
		}
	}
	
	/// <summary>
	/// Draws inset rectangle of specified pen color and width.
	/// </summary>
	/// <remarks>
	/// Creates pen and calls other overload.
	/// </remarks>
	public static void DrawRectangleInset(this Graphics t, Color penColor, int penWidth, RECT r, bool outset = false) {
		using var pen = new Pen(penColor, penWidth);
		DrawRectangleInset(t, pen, r, outset);
	}
	
	/// <summary>
	/// Creates solid brush and calls <see cref="Graphics.FillRectangle"/>.
	/// </summary>
	public static void FillRectangle(this Graphics t, Color color, RECT r) {
		using var brush = new SolidBrush(color);
		t.FillRectangle(brush, r);
	}
	
	/// <summary>
	/// Calls <c>b.LockBits</c> in ctor and <c>b.UnlockBits</c> in <c>Dispose</c>.
	/// </summary>
	internal struct BitmapData_ : IDisposable {
		Bitmap _b;
		BitmapData _d;
		
		public BitmapData_(Bitmap b, ImageLockMode mode, PixelFormat? pf = null) {
			_b = b;
			_d = _b.LockBits(new(default, b.Size), mode, pf ?? _b.PixelFormat);
		}
		
		public BitmapData_(Bitmap b, Rectangle r, ImageLockMode mode, PixelFormat? pf = null) {
			_b = b;
			_d = _b.LockBits(r, mode, pf ?? _b.PixelFormat);
		}
		
		public void Dispose() {
			_b?.UnlockBits(_d);
			_b = null;
			_d = null;
		}
		
		public int Width => _d.Width;
		public int Height => _d.Height;
		public int Stride => _d.Stride;
		public PixelFormat PixelFormat => _d.PixelFormat;
		public IntPtr Scan0 => _d.Scan0;
	}
	
	/// <summary>
	/// Creates a <c>BitmapData_</c> object that calls <c>b.LockBits</c> in ctor and <c>b.UnlockBits</c> in <c>Dispose</c>.
	/// </summary>
	/// <param name="pf">If <c>null</c>, uses <c>b.PixelFormat</c>.</param>
	internal static BitmapData_ Data(this Bitmap b, ImageLockMode mode, PixelFormat? pf = null)
		=> new BitmapData_(b, mode, pf);
	
	/// <summary>
	/// Creates a <c>BitmapData_</c> object that calls <c>b.LockBits</c> in ctor and <c>b.UnlockBits</c> in <c>Dispose</c>.
	/// </summary>
	/// <param name="pf">If <c>null</c>, uses <c>b.PixelFormat</c>.</param>
	internal static BitmapData_ Data(this Bitmap b, Rectangle r, ImageLockMode mode, PixelFormat? pf = null)
		=> new BitmapData_(b, r, mode, pf);
	
	#endregion
	
	#region other
	
	/// <summary>
	/// Gets a value from a subkey of this registry key.
	/// </summary>
	/// <param name="t"></param>
	/// <param name="subkey">The name or relative path of the subkey.</param>
	/// <param name="name">The name of the value to retrieve.</param>
	/// <param name="defaultValue">The value to return if <i>subkey</i> or <i>name</i> does not exist.</param>
	/// <param name="options"></param>
	/// <returns>The value associated with <i>name</i>, or <i>defaultValue</i> if <i>subkey</i> or <i>name</i> not found.</returns>
	/// <exception cref="Exception">Exceptions of <see cref="RegistryKey.OpenSubKey(string)"/> and <see cref="RegistryKey.GetValue(string?, object?, RegistryValueOptions)"/>.</exception>
	/// <remarks>
	/// Calls <see cref="RegistryKey.OpenSubKey(string)"/> and <see cref="RegistryKey.GetValue(string?, object?, RegistryValueOptions)"/>.
	/// </remarks>
	public static object GetValue2(this RegistryKey t, string subkey, string name, object defaultValue = null, RegistryValueOptions options = default) {
		using var k = t.OpenSubKey(subkey);
		if (k == null) return defaultValue;
		return k.GetValue(name, defaultValue, options);
		
		//tested: RegGetValue same speed.
	}
	
	/// <summary>
	/// <c>=> t.GetAwaiter().GetResult();</c>
	/// </summary>
	internal static T Result_<T>(this Task<T> t) => t.GetAwaiter().GetResult();
	
	#endregion
}


================================================
FILE: Au/Ext/ExtWpf.cs
================================================
using System.Windows;
using System.Windows.Controls.Primitives;
using System.Windows.Interop;
using System.Windows.Controls;
using System.Windows.Media;
using System.Windows.Threading;
using System.Windows.Data;
using System.Windows.Automation;
using System.Windows.Automation.Peers;
using System.Windows.Automation.Provider;
using System.Windows.Input;

namespace Au.Types;

/// <summary>
/// Adds extension methods for some WPF classes.
/// </summary>
public static class ExtWpf {
	/// <summary>
	/// Gets native window handle of this <see cref="Window"/> or <see cref="Popup"/>, or container window handle of this child object.
	/// </summary>
	/// <returns><c>default(wnd)</c> if:
	/// <br/>• called before creating or after closing real window;
	/// <br/>• failed;
	/// <br/>• <i>t</i> is <c>null</c>.</returns>
	/// <param name="t"></param>
	public static wnd Hwnd(this DependencyObject t) {
		bool isPopup = false;
		switch (t) {
		case null: return default;
		case Window w: return (wnd)new WindowInteropHelper(w).Handle; //FromDependencyObject works too, but this is usually slightly faster
		case Popup p: t = p.Child; if (t == null) return default; isPopup = true; break; //FromVisual(Popup) returns null, FromDependencyObject too
		}
		if (PresentationSource.FromDependencyObject(t) is HwndSource hs) return (wnd)hs.Handle;
		if (isPopup) return default;
		return Hwnd(LogicalTreeHelper.GetParent(t));
	}
	//rejected: notPopup. Not useful.
	///// <summary>
	///// Gets window handle of this <c>Window</c>, <c>Popup</c> or container window handle of this child object.
	///// Returns <c>default(wnd)</c> if: called before creating real window; failed; <i>t</i> is <c>null</c>.
	///// </summary>
	///// <param name="t"></param>
	///// <param name="notPopup">If this is <c>Popup</c> or in a <c>Popup</c>, get handle of popup's owner <c>Window</c>.</param>
	//public static wnd Hwnd(this DependencyObject t, bool notPopup = false)
	//{
	//	switch(t) {
	//	case null: return default;
	//	case Window w: return (wnd)new WindowInteropHelper(w).Handle; //FromDependencyObject works too, but this is usually slightly faster
	//	case Popup p when !notPopup: t = p.Child; if(t == null) return default; break; //FromVisual(Popup) returns null; or maybe owner window, not tested.
	//	}
	//	if(notPopup) {
	//		var w = Window.GetWindow(t); if(w == null) return default; //if Popup or in Popup, gets owner WIndow
	//		return (wnd)new WindowInteropHelper(w).Handle;
	//	}
	//	if(PresentationSource.FromDependencyObject(t) is HwndSource hs) return (wnd)hs.Handle;
	//	return default;
	//}
	
	/// <summary>
	/// Gets <c>IWin32Window</c> of this window for <c>System.Windows.Forms</c> functions like <c>Form.ShowDialog</c> and <c>ColorDialog.ShowDialog</c>.
	/// </summary>
	public static System.Windows.Forms.IWin32Window FormOwner(this Window t) {
		var nw = new System.Windows.Forms.NativeWindow();
		nw.AssignHandle(t.Hwnd().Handle);
		return nw;
	}
	
	/// <summary>
	/// Enumerates visual descendant objects, including parts of composite controls, and calls callback function <i>f</i> for each.
	/// When <i>f</i> returns <c>true</c>, stops and returns that object. Returns <c>null</c> if <i>f</i> does not return <c>true</c>.
	/// </summary>
	public static DependencyObject FindVisualDescendant(this DependencyObject t, Func<DependencyObject, bool> f, bool orSelf = false) {
		if (orSelf && f(t)) return t;
		for (int i = 0, n = VisualTreeHelper.GetChildrenCount(t); i < n; i++) {
			var v = VisualTreeHelper.GetChild(t, i);
			if (f(v)) return v;
			v = FindVisualDescendant(v, f);
			if (v != null) return v;
		}
		return null;
	}
	
	/// <summary>
	/// Enumerates visual descendant objects, including parts of composite controls.
	/// </summary>
	public static IEnumerable<DependencyObject> VisualDescendants(this DependencyObject t) {
		for (int i = 0, n = VisualTreeHelper.GetChildrenCount(t); i < n; i++) {
			var v = VisualTreeHelper.GetChild(t, i);
			yield return v;
			foreach (var k in VisualDescendants(v)) yield return k;
			//TODO3: now creates much garbage if tree is big.
			//	See https://stackoverflow.com/a/30441479/2547338.
			//	See ExtMisc.Descendants. But it cannot be used here because VisualTreeHelper does not give an IEnumerable.
		}
	}
	
	/// <summary>
	/// Enumerates logical descendant objects, including parts of composite controls.
	/// </summary>
	public static IEnumerable LogicalDescendants(this DependencyObject t) {
		//foreach (var v in LogicalTreeHelper.GetChildren(t)) {
		//	yield return v;
		//	if (v is DependencyObject d)
		//		foreach (var k in LogicalDescendants(d)) yield return k;
		//}
		return LogicalTreeHelper.GetChildren(t).Descendants_(o => o is DependencyObject d ? LogicalTreeHelper.GetChildren(d) : null);
	}
	
	/// <summary>
	/// Gets visual ancestors (<see cref="VisualTreeHelper.GetParent"/>).
	/// </summary>
	/// <param name="t"></param>
	/// <param name="andThis">Include this object.</param>
	/// <param name="last">Last ancestor to get.</param>
	public static IEnumerable<DependencyObject> VisualAncestors(this DependencyObject t, bool andThis = false, object last = null) {
		for (var v = t; v != null; v = VisualTreeHelper.GetParent(v)) {
			if (!andThis) { andThis = true; continue; }
			yield return v;
			if (v == last) yield break;
		}
	}
	
	/// <summary>
	/// Calls callback function <i>f</i> for each visual ancestor (<see cref="VisualTreeHelper.GetParent"/>), and returns the ancestor for which <i>f</i> returns <c>true</c>.
	/// Also can return <i>last</i> or <c>null</c>.
	/// </summary>
	/// <param name="t"></param>
	/// <param name="andThis">Include this object.</param>
	/// <param name="f"></param>
	/// <param name="last">When found this ancestor, stop and return <i>last</i> if <i>andLast</i> <c>true</c> or <c>null</c> if <c>false</c>.</param>
	/// <param name="andLast">If <i>last</i> found, return <i>last</i> instead of <c>null</c>.</param>
	/// <seealso cref="ItemsControl.ContainerFromElement"/>
	public static DependencyObject FindVisualAncestor(this DependencyObject t, bool andThis, Func<DependencyObject, bool> f, object last, bool andLast) {
		for (var v = t; v != null; v = VisualTreeHelper.GetParent(v)) {
			if (!andThis) { andThis = true; continue; }
			if (f(v)) return v;
			if (v == last) return andLast ? v : null;
		}
		return null;
	}
	
	/// <summary>
	/// Returns the nearest visual ancestor (<see cref="VisualTreeHelper.GetParent"/>) of type <i>T</i>.
	/// Also can return <i>last</i> or <c>null</c>.
	/// </summary>
	/// <param name="t"></param>
	/// <param name="andThis">Include this object.</param>
	/// <param name="last">When found this ancestor, stop and return <i>last</i> if <i>andLast</i> <c>true</c> or <c>null</c> if <c>false</c>.</param>
	/// <param name="andLast">If <i>last</i> found, return <i>last</i> instead of <c>null</c>.</param>
	/// <seealso cref="ItemsControl.ContainerFromElement"/>
	public static DependencyObject FindVisualAncestor<T>(this DependencyObject t, bool andThis, object last, bool andLast) where T : DependencyObject {
		for (var v = t; v != null; v = VisualTreeHelper.GetParent(v)) {
			if (!andThis) { andThis = true; continue; }
			if (v is T r1) return r1;
			if (v == last) return andLast ? v : null;
		}
		return null;
	}
	
	/// <summary>
	/// Gets rectangle of this element in screen coordinates.
	/// </summary>
	/// <returns><c>default(RECT)</c> if this is an invisible element (but not <see cref="Window"/>) or if fails.</returns>
	public static RECT RectInScreen(this FrameworkElement t) {
		if (t is Window w) return w.Hwnd().Rect; //else would be incorrect: x/y of client area, width/height of window
		if (t.IsVisible) {
			try {
				Point p1 = t.PointToScreen(default), p2 = t.PointToScreen(new Point(t.ActualWidth, t.ActualHeight));
				return RECT.FromLTRB(p1.X.ToInt(), p1.Y.ToInt(), p2.X.ToInt(), p2.Y.ToInt());
			}
			catch (Exception e1) { Debug_.Print(e1); }
		}
		return default;
	}

	/// <summary>
	/// Sets <see cref="Visibility"/> = <c>Hidden</c> or <c>Visible</c>.
	/// </summary>
	internal static void Hide_(this UIElement t, bool hide) {
		t.Visibility = hide ? Visibility.Hidden : Visibility.Visible;
	}

	/// <summary>
	/// Sets <see cref="Visibility"/> = <c>Collapsed</c> or <c>Visible</c>.
	/// </summary>
	internal static void Collapse_(this UIElement t, bool collapse) {
		t.Visibility = collapse ? Visibility.Collapsed : Visibility.Visible;
	}
	
	/// <summary>
	/// Sets UI Automation name.
	/// </summary>
	public static void UiaSetName(this DependencyObject t, string name) {
		System.Windows.Automation.AutomationProperties.SetName(t, name);
	}
	
	//rejected, FBC. Looks not good. Better .IsChecked == true.
	/// <summary>
	/// Returns <c>true</c> if <c>IsChecked == true</c>.
	/// </summary>
	[EditorBrowsable(EditorBrowsableState.Never)]
	//[Obsolete("use code IsChecked == true")]
	public static bool True(this CheckBox t) => t.IsChecked == true;
	
#if true
	//TODO3: does not work if this is called in ctor and caller sets Title afterwards.
	static unsafe void _Move(Window t, int x, int y, in RECT r, bool andSize) {
		var wstate = t.WindowState;
		if (t.IsLoaded) {
			var w = t.Hwnd();
			if (w.Is0) throw new ObjectDisposedException("Window");
			if (wstate != WindowState.Normal) t.WindowState = WindowState.Normal;
			if (andSize) w.MoveL(r); else w.MoveL(x, y);
		} else {
			//tested: don't need this for Popup. Its PlacementRectangle can use physical pixels.
			
			t.WindowStartupLocation = WindowStartupLocation.Manual;
			if (wstate == WindowState.Minimized) t.ShowActivated = false;
			
			bool maxInactive = wstate is WindowState.Maximized && !t.ShowActivated;
			if (maxInactive) t.WindowState = WindowState.Normal; //WPF would throw exception, although it's easy to create maximized inactive window with CreateWindowEx
			
			WindowsHook.ThreadCbt(k => {
				if (k.code == HookData.CbtEvent.CREATEWND) {
					var c = k.CreationInfo->lpcs;
					if (!c->style.Has(WS.CHILD)) {
						var name = c->Name;
						if (name.Length > 25 && name.StartsWith("m8KFOuCJOUmjziONcXEi3A ")) {
							k.hook.Dispose();
							
							var s = name[23..].ToString();
							if (name[^1] == ';') {
								c->x = s.ToInt(0, out int e); c->y = s.ToInt(e);
							} else if (RECT.TryParse(s, out var r)) {
								c->x = r.left; c->y = r.top; c->cx = r.Width; c->cy = r.Height;
							}
						}
					}
				} else { //didn't detect the window? Because unhooks when detects.
					Debug_.Print($"{k.code} {k.Hwnd}");
					//Debug_.PrintIf(k.code != HookData.CbtEvent.SETFOCUS, $"{k.code} {k.Hwnd}"); //sometimes SETFOCUS before CREATEWND, and it is bad
				}
				return false;
			});
			
			t.Left = double.NaN;
			t.Top = double.NaN;
			if (andSize) {
				t.Width = double.NaN;
				t.Height = double.NaN;
			}
			
			//temporarily change Title. I didn't find other ways to recognize the window in the hook proc. Also in title we can pass r or x y.
			string title = t.Title, s;
			if (andSize) s = "m8KFOuCJOUmjziONcXEi3A " + r.ToStringSimple(); else s = $"m8KFOuCJOUmjziONcXEi3A {x} {y};";
			t.Title = s;
			//Need to restore Title ASAP.
			//	In CBT hook cannot change window name in any way.
			//	The first opportunity is WM_CREATE, it's before WPF events, but cannot set Title property there.
			//	The sequence of .NET events depends on Window properties etc:
			//		Default: IsVisibleChanged, HwndSource.AddSourceChangedHandler, SourceInitialized, Loaded. And several unreliable events inbetween.
			//		SizeToContent: IsVisibleChanged, HwndSource.AddSourceChangedHandler, Loaded, SourceInitialized.
			//		WindowInteropHelper(w).EnsureHandle(): SourceInitialized (before ShowX), IsVisibleChanged, HwndSource.AddSourceChangedHandler, Loaded.
			//		Window without controls: Initialized, ....
			SourceChangedEventHandler eh = null;
			eh = (_, _) => {
				HwndSource.RemoveSourceChangedHandler(t, eh);
				t.Title = title;
				//if (wstate == WindowState.Normal && !t.ShowActivated) t.Hwnd().ZorderTop(); //it seems don't need it
				
				if (maxInactive) t.Loaded += (_, _) => _MaximizeNoActivate(t.Hwnd());
			};
			HwndSource.AddSourceChangedHandler(t, eh);
			
			static void _MaximizeNoActivate(wnd w) {
				//HACK
				w.GetWindowPlacement_(out var p, false); //without this, later restored rect is like max
				w.SetStyle(WS.MAXIMIZE, WSFlags.Add);
				var r = screen.of(w).WorkArea;
				w.SetWindowPos(SWPFlags.FRAMECHANGED | SWPFlags.NOACTIVATE | SWPFlags.NOZORDER, r.left, r.top, r.Width, r.Height);
				//p.showCmd = 3; w.SetWindowPlacement_(ref p, false);
#if DEBUG
				w.GetWindowPlacement_(out var p2, false);
				Debug_.PrintIf(p2.rcNormalPosition != p.rcNormalPosition || p2.showCmd != 3);
#endif
			}
		}
	}
#elif true //does not change Title, but I don't like creating window handle before showing window
	static void _Move(Window t, int x, int y, in RECT r, bool andSize) {
		var wstate=t.WindowState;
		if(wstate!=WindowState.Normal) t.WindowState=WindowState.Normal;
		if(t.IsLoaded) {
			var w=t.Hwnd();
			if(w.Is0) throw new ObjectDisposedException("Window");
			if(andSize) w.MoveL(r); else w.MoveL(x, y);
		} else {
			var scrn=screen.of(new POINT(x, y));
			var si=scrn.GetInfo();
			var rs=si.workArea;
		
			if(andSize) {
				x=r.left; y=r.top;
				var stc=t.SizeToContent;
				if(stc!=SizeToContent.WidthAndHeight) {
					double f=96d/scrn.Dpi;
					if(!stc.Has(SizeToContent.Width)) t.Width=r.Width*f;
					if(!stc.Has(SizeToContent.Height)) t.Height=r.Height*f;
				}
			}
		
			t.WindowStartupLocation=WindowStartupLocation.Manual;
			t.Left=double.NaN; t.Top=double.NaN;
			t.Loaded+=(_,_)=> {
				var w=t.Hwnd();
				var rw=w.Rect;
				x=Math.Clamp(x, rs.left, Math.Max(rs.right-rw.Width, rs.left));
				y=Math.Clamp(y, rs.top, Math.Max(rs.bottom-rw.Height, rs.top));
				w.MoveL(x, y);
			
				if(wstate!=WindowState.Normal) {
					if(wstate==WindowState.Maximized) t.SizeToContent=SizeToContent.Manual;
					t.WindowState=wstate;
				} else if(!t.ShowActivated) {
					w.ZorderTop();
				}
			};
		
			if(!si.isPrimary) {
				using var h=WindowsHook.ThreadCbt(d=> {
					if(d.code== HookData.CbtEvent.CREATEWND) unsafe {
						var w=d.CreationInfo(out var c, out _);
						if(c->style!=0 && !c->style.Has(WS.CHILD)) { //note: this does not work if ShowInTaskbar = false. Then WPF creates a "Hidden Window" before, even if owner specified.
							print.it(c->x, c->y, c->cx, c->cy, c->hwndParent, c->style, c->lpszClass, c->lpszName);
			//				d.hook.Unhook();
							c->x=rs.left; c->y=rs.top;
							//the hook receives 2 windows. At first the true window and then some other HwndWrapper* with 0 x y cx cy style parent. The second is never visibe.
							//We use the 'c->style!=0' to ignore it. The real window always has some styles. There is no 100% reliable and clean way to recognize the real window.
							//Don't unhook, because future .NET versions may create more windows, maybe some before the real window. Or in some conditions.
						}
					}
					return false;
				});

				new WindowInteropHelper(t).EnsureHandle();
			}
		}
	}
#else //does not work well when maximized, per-monitor DPI, etc
	static void _Move(Window t, int x, int y, in RECT r, bool andSize) {
		var wstate = t.WindowState;
		if (wstate != WindowState.Normal) t.WindowState = WindowState.Normal;
		if (t.IsLoaded) {
			var w = t.Hwnd();
			if (w.Is0) throw new ObjectDisposedException("Window");
			if (andSize) w.MoveL(r); else w.MoveL(x, y);
		} else {
			//tested: don't need this for Popup. Its PlacementRectangle uses physical pixels.

			if (andSize) {
				x = r.left; y = r.top;
				var stc = t.SizeToContent;
				if (stc != SizeToContent.WidthAndHeight) {
					double f = 96d / screen.of(x, y).Dpi;
					if (!stc.Has(SizeToContent.Width)) t.Width = r.Width * f;
					if (!stc.Has(SizeToContent.Height)) t.Height = r.Height * f;
				}
			}

			t.WindowStartupLocation = WindowStartupLocation.Manual;
			t.Left = double.NaN; t.Top = double.NaN; //default location, somewhere near top-left of primary screen or owner's screen
			if (wstate == WindowState.Minimized) t.ShowActivated = false;

			t.SourceInitialized += (_, _) => {
				var w = t.Hwnd();
				var v = screen.of(x, y).Info;
				var rs = v.workArea;
				if (!v.isPrimary) {
					using var h = WindowsHook.ThreadCbt(k => k.code == HookData.CbtEvent.ACTIVATE); //workaround for WPF bug: activates window when DPI changes
					w.MoveL(rs.left, rs.top); //let DPI-scale
				}
				var rw = w.Rect;
				x = Math.Clamp(x, rs.left, Math.Max(rs.right - rw.Width, rs.left));
				y = Math.Clamp(y, rs.top, Math.Max(rs.bottom - rw.Height, rs.top));
				w.MoveL(x, y);
				//speed: when moving to a screen with different DPI, total time is same.

				if (wstate != WindowState.Normal) {
					if (wstate == WindowState.Maximized) t.SizeToContent = SizeToContent.Manual;
					t.WindowState = wstate;
				} else if (!t.ShowActivated) {
					w.ZorderTop();
				}
			};
		}
	}
#endif
	
	/// <summary>
	/// Sets window startup location before showing it first time. Also can move already loaded window.
	/// </summary>
	/// <param name="t"></param>
	/// <param name="x">X coordinate in screen. Physical pixels.</param>
	/// <param name="y">Y coordinate in screen. Physical pixels.</param>
	/// <remarks>
	/// The unit is physical pixels. WPF provides <c>Left</c> and <c>Top</c> properties, but the unit is logical pixels, therefore cannot set exact location on high DPI screens, especially if there are multiple screens with different DPI.
	/// 
	/// If the window is already loaded, just ensures it is not maximized/minimized and calls <see cref="wnd.MoveL"/>.
	/// 
	/// Else sets window location for normal state (not minimized/maximized). Temporarily changes <c>Title</c>. Clears <c>WindowStartupLocation</c>, <c>Left</c>, <c>Top</c>. Clears <c>ShowActivated</c> if minimized. Does not change <c>SizeToContent</c>.
	/// </remarks>
	public static void SetXY(this Window t, int x, int y) => _Move(t, x, y, default, false);
	
	/// <summary>
	/// Sets window startup rectangle (location and size) before showing it first time. Also can move/resize already loaded window.
	/// </summary>
	/// <param name="t"></param>
	/// <param name="r">Rectangle in screen. Physical pixels.</param>
	/// <remarks>
	/// The unit is physical pixels. WPF provides <c>Left</c>, <c>Top</c>, <c>Width</c> and <c>Height</c> properties, but the unit is logical pixels, therefore cannot set exact rectangle on high DPI screens, especially if there are multiple screens with different DPI.
	/// 
	/// If the window is already loaded, just ensures it is not maximized/minimized and calls <see cref="wnd.MoveL"/>.
	/// 
	/// Else sets window rectangle for normal state (not minimized/maximized). Temporarily changes <c>Title</c>. Clears <c>WindowStartupLocation</c>, <c>Left</c>, <c>Top</c>, <c>Width</c>, <c>Height</c>. Clears <c>ShowActivated</c> if minimized. Does not change <c>SizeToContent</c>.
	/// </remarks>
	public static void SetRect(this Window t, RECT r) => _Move(t, 0, 0, r, true);
	
	/// <summary>
	/// Inserts row and adjusts row indices of children that are in other rows.
	/// </summary>
	public static void InsertRow(this Grid t, int index, RowDefinition d) {
		_GridShift(t, true, index, 1);
		t.RowDefinitions.Insert(index, d);
	}
	
	/// <summary>
	/// Inserts column and adjusts column indices of children that are in other columns.
	/// </summary>
	public static void InsertColumn(this Grid t, int index, ColumnDefinition d) {
		_GridShift(t, false, index, 1);
		t.ColumnDefinitions.Insert(index, d);
	}
	
	/// <summary>
	/// Removes row and adjusts row indices of children that are in other rows.
	/// </summary>
	/// <param name="t"></param>
	/// <param name="index"></param>
	/// <param name="removeChildren">Remove children that are in that row.</param>
	public static void RemoveRow(this Grid t, int index, bool removeChildren) {
		if (removeChildren) _GridRemoveRowColChildren(t, true, index);
		t.RowDefinitions.RemoveAt(index);
		_GridShift(t, true, index, -1);
	}
	
	/// <summary>
	/// Removes column and adjusts column indices of children that are in other columns.
	/// </summary>
	/// <param name="t"></param>
	/// <param name="index"></param>
	/// <param name="removeChildren">Remove children that are in that column.</param>
	public static void RemoveColumn(this Grid t, int index, bool removeChildren) {
		if (removeChildren) _GridRemoveRowColChildren(t, false, index);
		t.ColumnDefinitions.RemoveAt(index);
		_GridShift(t, false, index, -1);
	}
	
	/// <summary>
	/// Removes a child element and its row from this grid. Adjusts row indices of children that are in other rows.
	/// </summary>
	/// <param name="t"></param>
	/// <param name="e"></param>
	/// <param name="removeOtherElements">Also remove other elements that are in that row.</param>
	public static void RemoveRow(this Grid t, UIElement e, bool removeOtherElements) {
		int i = Grid.GetRow(e);
		_GridRemoveChild(t, e);
		RemoveRow(t, i, removeOtherElements);
	}
	
	/// <summary>
	/// Removes a child element and its column from this grid. Adjusts column indices of children that are in other columns.
	/// </summary>
	/// <param name="t"></param>
	/// <param name="e"></param>
	/// <param name="removeOtherElements">Also remove other elements that are in that column.</param>
	public static void RemoveColumn(this Grid t, UIElement e, bool removeOtherElements) {
		int i = Grid.GetColumn(e);
		_GridRemoveChild(t, e);
		RemoveColumn(t, i, removeOtherElements);
	}
	
	static void _GridShift(Grid g, bool rows, int startIndex, int shift) {
		if (startIndex >= (rows ? g.RowDefinitions.Count : g.ColumnDefinitions.Count)) return;
		foreach (UIElement e in g.Children) {
			int k = rows ? Grid.GetRow(e) : Grid.GetColumn(e);
			if (k < startIndex) continue;
			k += shift;
			if (rows) Grid.SetRow(e, k); else Grid.SetColumn(e, k);
		}
	}
	
	static void _GridRemoveRowColChildren(Grid g, bool row, int index) {
		var cc = g.Children;
		for (int i = cc.Count; --i >= 0;) {
			var e = cc[i];
			int rc = row ? Grid.GetRow(e) : Grid.GetColumn(e);
			if (rc == index) _GridRemoveChild(g, e);
		}
	}
	
	static void _GridRemoveChild(Grid g, UIElement e) {
		g.Children.Remove(e);
		Grid.SetRow(e, 0);
		Grid.SetColumn(e, 0);
	}
	
	/// <summary>
	/// Adds a child element in specified row/column.
	/// </summary>
	public static void AddChild(this Grid g, UIElement e, int row, int column, int rowSpan = 1, int columnSpan = 1) {
		Grid.SetRow(e, row);
		Grid.SetColumn(e, column);
		if (rowSpan > 1) Grid.SetRowSpan(e, rowSpan);
		if (columnSpan > 1) Grid.SetColumnSpan(e, columnSpan);
		g.Children.Add(e);
	}
	
	/// <summary>
	/// Adds one or more columns. Like <see cref="wpfBuilder.Columns"/>, but does not clear existing columns.
	/// </summary>
	/// <inheritdoc cref="wpfBuilder.Columns" path="/param"/>
	public static void AddColumns(this Grid g, params WBGridLength[] widths) {
		foreach (var v in widths) g.ColumnDefinitions.Add(v.Column);
	}
	
	/// <summary>
	/// Adds one or more rows. Like <see cref="wpfBuilder.Row"/>.
	/// </summary>
	/// <param name="heights"><inheritdoc cref="wpfBuilder.Row" path="/param[@name='height']/node()"/></param>
	public static void AddRows(this Grid g, params WBGridLength[] heights) {
		foreach (var v in heights) g.RowDefinitions.Add(v.Row);
	}
	
	/// <summary>
	/// Gets the <c>Text</c> property. Returns <c>null</c> if it is <c>""</c>.
	/// </summary>
	public static string TextOrNull(this TextBox t) => t.Text.NullIfEmpty_();
	
	/// <summary>
	/// Workaround for WPF bug: on DPI change tries to activate window.
	/// Call on <c>WM_DPICHANED</c> message or in <c>OnDpiChanged</c> override.
	/// </summary>
	public static void DpiChangedWorkaround(this Window t) => _DCW(t.Dispatcher, t.Hwnd());
	
	/// <summary>
	/// Workaround for WPF bug: on DPI change tries to activate window.
	/// Call on <c>WM_DPICHANED</c> message or in <c>OnDpiChanged</c> override. Only if top-level window.
	/// </summary>
	public static void DpiChangedWorkaround(this HwndSource t) => _DCW(t.Dispatcher, (wnd)t.Handle);
	
	static void _DCW(Dispatcher d, wnd w) {
		if (wnd.active != w) {
			bool wasVisible = w.IsVisible; //allow to activate when opening window in non-primary screen
			var h = WindowsHook.ThreadCbt(k => k.code == HookData.CbtEvent.ACTIVATE && (wnd)k.wParam == w && (wasVisible || !w.IsVisible));
			d.InvokeAsync(() => h.Dispose());
		}
	}
	
	/// <returns><c>true</c> if in <c>ShowDialog</c>, <c>false</c> if not, <c>null</c> if failed (uses reflection).</returns>
	internal static bool? IsModal_(this Window t) {
		try {
			var f = typeof(Window).GetField("_showingAsDialog", BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.NonPublic);
			return (bool)f.GetValue(t);
		}
		catch {
			Debug_.Print("_showingAsDialog");
			return null;
		}
	}
	
	/// <summary>
	/// Hides the grip and/or overflow controls in this toolbar.
	/// Call before the toolbar is loaded.
	/// </summary>
	/// <param name="t"></param>
	/// <param name="hideGrip">Hide grip. Sets <c>SetIsLocked</c> <c>true</c>.</param>
	/// <param name="hideOverflow">Hides the overflow button while it is disabled.</param>
	/// <exception cref="InvalidOperationException">Loaded.</exception>
	public static void HideGripAndOverflow(this ToolBar t, bool hideGrip = true, bool hideOverflow = true) {
		if (hideGrip) ToolBarTray.SetIsLocked(t, true);
		if (hideOverflow) {
			if (t.IsLoaded) throw new InvalidOperationException("loaded");
			SizeChangedEventHandler h = null;
			h = (_, _) => {
				t.SizeChanged -= h;
				if (t.Template.FindName("OverflowButton", t) is ButtonBase ob) {
					ob.SetBinding(
						UIElement.VisibilityProperty,
						new Binding("IsEnabled") {
							RelativeSource = RelativeSource.Self,
							Converter = new BooleanToVisibilityConverter()
						});
				}
			};
			t.SizeChanged += h;
			//note: in Loaded event handler randomly does not work. Somehow t still does not have the overflow button.
		}
	}
	
	internal static wpfBuilder AddToolBar_(this wpfBuilder t, out ToolBarTray tt, out ToolBar tb, bool vertical = false, bool hideOverflow = false, bool controlBrush = false) {
		tt = new ToolBarTray { IsLocked = true };
		if (vertical) tt.Orientation = Orientation.Vertical;
		tb = new ToolBar();
		if (controlBrush) {
			tt.Background = SystemColors.ControlBrush;
			tb.Background = SystemColors.ControlBrush;
		}
		KeyboardNavigation.SetTabNavigation(tb, KeyboardNavigationMode.Once);
		tt.ToolBars.Add(tb);
		if (hideOverflow) tb.HideGripAndOverflow(false);
		t.Add(tt);
		return t;
	}
	
	/// <summary>
	/// Calls <see cref="IInvokeProvider.Invoke"/>, which sends a request to click the button.
	/// Note: it's async; more info in Remarks.
	/// </summary>
	/// <exception cref="ElementNotEnabledException"></exception>
	/// <remarks>
	/// It is async (does not wait until finished). The button click event is raised after this function returns.
	/// 
	/// Does not click if the button is disabled.
	/// 
	/// Another way: <c>button.RaiseEvent(new RoutedEventArgs(Button.ClickEvent));</c>. It is sync, ignores disabled state, and ignores <see cref="ButtonBase.Command"/>.
	/// </remarks>
	public static void UiaClick(this Button t) { //tested: does not work with CheckBox
		if (UIElementAutomationPeer.CreatePeerForElement(t)?.GetPattern(PatternInterface.Invoke) is IInvokeProvider ip) ip.Invoke();
	}
	
	/// <summary>
	/// Shows the window in [preview mode](xref:code_editor).
	/// </summary>
	/// <param name="t"></param>
	/// <exception cref="InvalidOperationException">Called not in preview mode.</exception>
	/// <remarks>
	/// Changes some window properties (owner window, location, activation, etc), terminates previous preview process, calls <see cref="Window.ShowDialog"/>. If closed, calls <see cref="Environment.Exit"/>.
	/// 
	/// If called not in preview mode, calls <see cref="Environment.Exit"/>.
	/// </remarks>
	public static void Preview(this Window t) {
		wnd wMain = ScriptEditor.MainWindow(); if (wMain.Is0) Environment.Exit(0);
		if (!Environment.CommandLine.RxMatch(@" WPF_PREVIEW (-?\d+) (-?\d+)$", out var m)) Environment.Exit(0);
		int pid = m[1].Value.ToInt();
		m[2].Value.ToInt(out long time);
		
		t.Title = "WPF preview";
		t.ShowActivated = false;
		t.WindowStartupLocation = WindowStartupLocation.Manual;
		t.WindowState = WindowState.Normal;
		t.ShowInTaskbar = true;
		t.Topmost = true;
		
		t.Loaded += (_, _) => {
			var w = t.Hwnd();
			//unsafe { int BOOL = 1; Api.DwmSetWindowAttribute(w, Api.DWMWINDOWATTRIBUTE.DWMWA_TRANSITIONS_FORCEDISABLED, &BOOL, 0); } //does not disable the inflate/deflate animation; and don't need, with it even better
			
			//move to App.Settings.wpfpreview_xy or to the right side of the primary screen
			if ((int)ScriptEditor.WndMsg_.Send(Api.WM_USER, 3) is int xy && xy != 0) {
				var p = Math2.NintToPOINT(xy);
				w.MoveL(p.x, p.y);
				w.EnsureInScreen();
			} else {
				w.MoveInScreen(^1, .5f);
			}
			
			//_TerminatePrevious(); pid = 0; //async less flickering, especially when no animations, eg toolwindow
			t.Dispatcher.InvokeAsync(() => { _TerminatePrevious(); pid = 0; }, DispatcherPriority.ApplicationIdle);
			
			//rejected. See the commented out workaround below. Instead set Topmost = true and ShowInTaskbar = true.
			//	The workaround may not always work, eg for other windows.
			//	Also noticed other anomalies, eg in some cases OS activates wrong window when this window closed.
			//if (!WndUtil.SetOwnerWindow(w, wMain)) w.ZorderTopmost();
			
			var hs = PresentationSource.FromVisual(t) as HwndSource;
			hs.AddHook(_WndProc);
			nint _WndProc(nint hwnd, int msg, nint wp, nint lp, ref bool handled) {
				var w = (wnd)hwnd;
				switch (msg) {
				//case Api.WM_NCLBUTTONDOWN or Api.WM_NCRBUTTONDOWN: //the window is already active
				//case Api.WM_LBUTTONDOWN or Api.WM_RBUTTONDOWN or Api.WM_MBUTTONDOWN: //for checkboxes etc
				//	Task.Run(() => { var p = mouse.xy; Api.SetCursorPos(p.x, p.y); });
				//	//workaround for: if using SetOwnerWindow:
				//	//	When the window is inactive, on click nonclient (eg to close), the window hangs until mouse moved.
				//	//	Similar happens after clicking a checkbox ~30 times. Maybe other controls too.
				//	break;
				case Api.WM_EXITSIZEMOVE:
					//save wpfpreview_xy
					if (!(w.IsMinimized || w.IsMaximized)) {
						var r = w.Rect; if (r.left == 0 && r.top == 0) r.top++;
						ScriptEditor.WndMsg_.Send(Api.WM_USER, 4, Math2.MakeLparam(r.left, r.top));
					}
					break;
				}
				return 0;
			}
		};
		
		try {
			t.ShowDialog();
		}
		finally {
			_TerminatePrevious();
			Environment.Exit(0);
		}
		
		void _TerminatePrevious() {
			if (pid == 0) return;
			if (process.getTimes(pid, out long tc, out _) && tc <= time) {
				//print.it("terminate", pid, time, tc);
				process.terminate(pid);
			} else {
				//print.it("bad");
				//if previous task failed before calling this func, this wasn't called and therefore an even older task may be running. Close its window.
				foreach (var w in wnd.findAll("WPF preview", "HwndWrapper[*", "Au.Task-*.exe")) {
					if (!w.IsOfThisProcess) w.Close(noWait: true);
				}
			}
		}
	}
}


================================================
FILE: Au/Ext/ExtXml.cs
================================================

using System.Xml.Linq;
using System.Xml;

namespace Au.Types {
	/// <summary>
	/// Adds extension methods for <see cref="XElement"/> and <see cref="XDocument"/>.
	/// </summary>
	public static class ExtXml {
		/// <summary>
		/// Gets XML attribute value.
		/// If the attribute does not exist, returns <c>null</c>.
		/// If the attribute value is empty, returns <c>""</c>.
		/// </summary>
		public static string Attr(this XElement t, XName name) {
			return t.Attribute(name)?.Value;
		}
		
		/// <summary>
		/// Gets XML attribute value.
		/// If the attribute does not exist, returns <i>defaultValue</i>.
		/// If the attribute value is empty, returns <c>""</c>.
		/// </summary>
		public static string Attr(this XElement t, XName name, string defaultValue) {
			var x = t.Attribute(name);
			return x != null ? x.Value : defaultValue;
		}
		
		/// <summary>
		/// Gets XML attribute value.
		/// If the attribute does not exist, sets <i>value</i> = <c>null</c> and returns <c>false</c>.
		/// </summary>
		public static bool Attr(this XElement t, out string value, XName name) {
			value = t.Attribute(name)?.Value;
			return value != null;
		}
		
		/// <summary>
		/// Gets attribute value converted to <c>int</c> number.
		/// If the attribute does not exist, returns <i>defaultValue</i>.
		/// If the attribute value is empty or does not begin with a valid number, returns 0.
		/// </summary>
		public static int Attr(this XElement t, XName name, int defaultValue) {
			var x = t.Attribute(name);
			return x != null ? x.Value.ToInt() : defaultValue;
		}
		
		/// <summary>
		/// Gets attribute value converted to <c>int</c> number.
		/// If the attribute does not exist, sets <i>value</i> = 0 and returns <c>false</c>.
		/// If the attribute value is empty or does not begin with a valid number, sets <i>value</i> = 0 and returns <c>true</c>.
		/// </summary>
		public static bool Attr(this XElement t, out int value, XName name) {
			var x = t.Attribute(name);
			if (x == null) { value = 0; return false; }
			value = x.Value.ToInt();
			return true;
		}
		
		/// <summary>
		/// Gets attribute value converted to <c>long</c> number.
		/// If the attribute does not exist, sets <i>value</i> = 0 and returns <c>false</c>.
		/// If the attribute value is empty or does not begin with a valid number, sets <i>value</i> = 0 and returns <c>true</c>.
		/// </summary>
		public static bool Attr(this XElement t, out long value, XName name) {
			var x = t.Attribute(name);
			if (x == null) { value = 0; return false; }
			x.Value.ToInt(out value);
			return true;
		}
		
		/// <summary>
		/// Gets attribute value converted to double number.
		/// If the attribute does not exist, sets <i>value</i> = 0 and returns <c>false</c>.
		/// If the attribute value is empty or is not a valid number, sets <i>value</i> = 0 and returns <c>true</c>.
		/// </summary>
		public static bool Attr(this XElement t, out double value, XName name) {
			var x = t.Attribute(name);
			if (x == null) { value = 0d; return false; }
			x.Value.ToNumber(out value);
			return true;
		}
		
		/// <summary>
		/// Gets attribute value converted to float number.
		/// If the attribute does not exist, sets <i>value</i> = 0 and returns <c>false</c>.
		/// If the attribute value is empty or is not a valid number, sets <i>value</i> = 0 and returns <c>true</c>.
		/// </summary>
		public static bool Attr(this XElement t, out float value, XName name) {
			var x = t.Attribute(name);
			if (x == null) { value = 0f; return false; }
			x.Value.ToNumber(out value);
			return true;
		}
		
		/// <summary>
		/// Gets attribute value as enum type <c>T</c>.
		/// If the attribute does not exist, sets <i>value</i> = <c>default</c> and returns <c>false</c>.
		/// If the attribute value is not a valid enum member name, sets <i>value</i> = <i>default</i> and returns <c>true</c>.
		/// </summary>
		public static bool Attr<T>(this XElement t, out T value, XName name) where T : unmanaged, Enum {
			var x = t.Attribute(name);
			if (x == null) { value = default; return false; }
			Enum.TryParse(x.Value, out value);
			return true;
		}
		
		/// <summary>
		/// Returns <c>true</c> if this element has the specified attribute.
		/// </summary>
		public static bool HasAttr(this XElement t, XName name) {
			return t.Attribute(name) != null;
		}
		
		/// <summary>
		/// Gets the first found descendant element.
		/// </summary>
		/// <returns><c>null</c> if not found.</returns>
		public static XElement Desc(this XElement t, XName name) {
			return t.Descendants(name).FirstOrDefault();
		}
		
		/// <summary>
		/// Finds the first descendant element that has the specified attribute or value.
		/// </summary>
		/// <returns><c>null</c> if not found.</returns>
		/// <param name="t"></param>
		/// <param name="name">Element name. If <c>null</c>, can be any name.</param>
		/// <param name="attributeName">Attribute name. If <c>null</c>, uses the <c>Value</c> property of the element.</param>
		/// <param name="attributeValue">Attribute value (or <c>Value</c>). If <c>null</c>, can be any value.</param>
		/// <param name="ignoreCase">Case-insensitive <i>attributeValue</i>.</param>
		public static XElement Desc(this XElement t, XName name, XName attributeName, string attributeValue = null, bool ignoreCase = false) {
			foreach (var el in (name != null) ? t.Descendants(name) : t.Descendants()) {
				if (_CmpAttrOrValue(el, attributeName, attributeValue, ignoreCase)) return el;
			}
			return null;
			
			//speed: several times faster than XPathSelectElement
		}
		
		/// <summary>
		/// Finds all descendant elements that have the specified attribute or value.
		/// </summary>
		/// <returns><c>null</c> if not found.</returns>
		/// <param name="t"></param>
		/// <param name="name">Element name. If <c>null</c>, can be any name.</param>
		/// <param name="attributeName">Attribute name. If <c>null</c>, uses the <c>Value</c> property of the element.</param>
		/// <param name="attributeValue">Attribute value (or <c>Value</c>). If <c>null</c>, can be any value.</param>
		/// <param name="ignoreCase">Case-insensitive <i>attributeValue</i>.</param>
		public static IEnumerable<XElement> Descs(this XElement t, XName name, XName attributeName, string attributeValue = null, bool ignoreCase = false) {
			foreach (var el in (name != null) ? t.Descendants(name) : t.Descendants()) {
				if (_CmpAttrOrValue(el, attributeName, attributeValue, ignoreCase)) yield return el;
			}
		}
		
		/// <summary>
		/// Gets the first found direct child element that has the specified attribute or value.
		/// </summary>
		/// <returns><c>null</c> if not found.</returns>
		/// <param name="t"></param>
		/// <param name="name">Element name. If <c>null</c>, can be any name.</param>
		/// <param name="attributeName">Attribute name. If <c>null</c>, uses the <c>Value</c> property of the element.</param>
		/// <param name="attributeValue">Attribute value (or <c>Value</c>). If <c>null</c>, can be any value.</param>
		/// <param name="ignoreCase">Case-insensitive <i>attributeValue</i>.</param>
		public static XElement Elem(this XElement t, XName name, XName attributeName, string attributeValue = null, bool ignoreCase = false) {
			foreach (var el in (name != null) ? t.Elements(name) : t.Elements()) {
				if (_CmpAttrOrValue(el, attributeName, attributeValue, ignoreCase)) return el;
			}
			return null;
		}
		
		/// <summary>
		/// Gets all direct child elements that have the specified attribute or value.
		/// </summary>
		/// <returns><c>null</c> if not found.</returns>
		/// <param name="t"></param>
		/// <param name="name">Element name. If <c>null</c>, can be any name.</param>
		/// <param name="attributeName">Attribute name. If <c>null</c>, uses the <c>Value</c> property of the element.</param>
		/// <param name="attributeValue">Attribute value (or <c>Value</c>). If <c>null</c>, can be any value.</param>
		/// <param name="ignoreCase">Case-insensitive <i>attributeValue</i>.</param>
		public static IEnumerable<XElement> Elems(this XElement t, XName name, XName attributeName, string attributeValue = null, bool ignoreCase = false) {
			foreach (var el in (name != null) ? t.Elements(name) : t.Elements()) {
				if (_CmpAttrOrValue(el, attributeName, attributeValue, ignoreCase)) yield return el;
			}
		}
		
		static bool _CmpAttrOrValue(XElement el, XName attributeName, string attributeValue = null, bool ignoreCase = false) {
			if (attributeName != null) {
				var a = el.Attribute(attributeName); if (a == null) return false;
				if (attributeValue != null && !a.Value.Eq(attributeValue, ignoreCase)) return false;
			} else {
				if (attributeValue != null && !el.Value.Eq(attributeValue, ignoreCase)) return false;
			}
			return true;
		}
		
		/// <summary>
		/// Gets the first found direct child element. If not found, adds new empty child element.
		/// </summary>
		/// <returns>The found or added element.</returns>
		public static XElement ElemOrAdd(this XElement t, XName name) {
			var e = t.Element(name);
			if (e == null) t.Add(e = new XElement(name));
			return e;
		}
		
		/// <summary>
		/// Gets the first found direct child element that has the specified attribute. If not found, adds new child element with the attribute.
		/// More info: <see cref="Elem"/>
		/// </summary>
		/// <returns>The found or added element.</returns>
		public static XElement ElemOrAdd(this XElement t, XName name, XName attributeName, string attributeValue = null, bool ignoreCase = false) {
			var e = t.Elem(name, attributeName, attributeValue, ignoreCase);
			if (e == null) t.Add(e = new XElement(name, new XAttribute(attributeName, attributeValue)));
			return e;
		}
		
		/// <summary>
		/// Returns previous sibling element or <c>null</c>.
		/// </summary>
		public static XElement PrevElem(this XElement t) {
			for (XNode n = t.PreviousNode; n != null; n = n.PreviousNode) {
				if (n is XElement e) return e;
			}
			return null;
		}
		
		/// <summary>
		/// Returns next sibling element or <c>null</c>.
		/// </summary>
		public static XElement NextElem(this XElement t) {
			for (XNode n = t.NextNode; n != null; n = n.NextNode) {
				if (n is XElement e) return e;
			}
			return null;
		}
		
		/// <summary>
		/// Saves XML to a file in a safer way.
		/// Uses <see cref="XElement.Save(string, SaveOptions)"/> and <see cref="filesystem.save"/>.
		/// </summary>
		/// <exception cref="Exception">Exceptions of <see cref="XElement.Save"/> and <see cref="filesystem.save"/>.</exception>
		public static void SaveElem(this XElement t, string file, bool backup = false, SaveOptions? options = default) {
			filesystem.save(file, temp => {
				if (options.HasValue) t.Save(temp, options.Value); else t.Save(temp);
			}, backup);
		}
		
		/// <summary>
		/// Saves XML to a file in a safer way.
		/// Uses <see cref="XDocument.Save(string)"/> and <see cref="filesystem.save"/>
		/// </summary>
		/// <exception cref="Exception">Exceptions of <see cref="XDocument.Save"/> and <see cref="filesystem.save"/>.</exception>
		public static void SaveDoc(this XDocument t, string file, bool backup = false, SaveOptions? options = default) {
			filesystem.save(file, temp => {
				if (options.HasValue) t.Save(temp, options.Value); else t.Save(temp);
			}, backup);
		}
	}
}

namespace Au.More {
	/// <summary>
	/// Loads <see cref="XElement"/> and <see cref="XDocument"/> in a safer way.
	/// </summary>
	public static class XmlUtil {
		/// <summary>
		/// Loads XML file in a safer way.
		/// Uses <see cref="XElement.Load(XmlReader, LoadOptions)"/> and <see cref="filesystem.waitIfLocked"/>.
		/// </summary>
		/// <param name="file">
		/// File. Must be full path. Can contain environment variables etc, see <see cref="pathname.expand"/>.
		/// If starts with <c>'&lt;'</c>, loads from XML string instead.
		/// </param>
		/// <param name="options"></param>
		/// <exception cref="ArgumentException">Not full path.</exception>
		/// <exception cref="Exception">Exceptions of <see cref="XElement.Load"/>.</exception>
		/// <remarks>
		/// Unlike <see cref="XElement.Load(string, LoadOptions)"/>, does not replace <c>\r\n</c> with <c>\n</c>.
		/// </remarks>
		public static XElement LoadElem(string file, LoadOptions options = default)
			=> _Load(file, options, false) as XElement;
		
		/// <summary>
		/// Loads XML file with a namespace.
		/// </summary>
		/// <param name="ns">Receives the default namespace. Use it to get elements, like <c>var x2 = x1.Element(ns + "name")</c>.</param>
		/// <inheritdoc cref="LoadElem(string, LoadOptions)"/>
		public static XElement LoadElem(out XNamespace ns, string file, LoadOptions options = default) {
			var r = _Load(file, options, false) as XElement;
			ns = r.Name.Namespace;
			return r;
		}
		
		/// <summary>
		/// If XML file exists, loads it (calls <see cref="LoadElem"/>), else creates new element or returns <c>null</c>.
		/// </summary>
		/// <param name="file"></param>
		/// <param name="elemName">Element name to use if <i>file</i> does not exist. If <c>null</c>, returns <c>null</c> if <i>file</i> does not exist.</param>
		/// <param name="options"></param>
		/// <exception cref="ArgumentException">Not full path.</exception>
		/// <exception cref="Exception">Exceptions of <see cref="XElement.Load"/>.</exception>
		public static XElement LoadElemIfExists(string file, string elemName = null, LoadOptions options = default) {
			if (!filesystem.exists(file)) return elemName == null ? null : new(elemName);
			return _Load(file, options, false) as XElement;
		}
		
		/// <summary>
		/// Loads XML file in a safer way.
		/// Uses <see cref="XDocument.Load(XmlReader, LoadOptions)"/> and <see cref="filesystem.waitIfLocked"/>.
		/// </summary>
		/// <param name="file">
		/// File. Must be full path. Can contain environment variables etc, see <see cref="pathname.expand"/>.
		/// If starts with <c>'&lt;'</c>, loads from XML string instead.
		/// </param>
		/// <param name="options"></param>
		/// <exception cref="ArgumentException">Not full path.</exception>
		/// <exception cref="Exception">Exceptions of <see cref="XDocument.Load"/>.</exception>
		/// <remarks>
		/// Unlike <see cref="XDocument.Load(string, LoadOptions)"/>, does not replace <c>\r\n</c> with <c>\n</c>.
		/// </remarks>
		public static XDocument LoadDoc(string file, LoadOptions options = default)
			=> _Load(file, options, true) as XDocument;
		
		static XContainer _Load(string file, LoadOptions options, bool doc) {
			if (file.Starts('<')) return _Load2(file, options, doc, true);
			file = pathname.NormalizeMinimally_(file);
			return filesystem.waitIfLocked(() => _Load2(file, options, doc, false));
			
			static XContainer _Load2(string file, LoadOptions options, bool doc, bool isString) {
				using var r = isString ? new XmlTextReader(new StringReader(file)) : new XmlTextReader(file); //to preserve \r\n
				if (0 == (options & LoadOptions.PreserveWhitespace)) r.WhitespaceHandling = WhitespaceHandling.Significant; //to save correctly formatted. Default of XElement.Load(string).
				return doc ? (XContainer)XDocument.Load(r, options) : XElement.Load(r, options);
			}
		}
	}
}

================================================
FILE: Au/Files, data/ExplorerFolder.cs
================================================
namespace Au.More;

/// <summary>
/// File Explorer folder window functions.
/// </summary>
public class ExplorerFolder {
	api.IWebBrowser2 _b;
	wnd _w, _cTab;
	
	/// <summary>
	/// Creates <see cref="ExplorerFolder"/> for a folder window.
	/// </summary>
	/// <returns><c>null</c> if failed.</returns>
	/// <param name="w">A folder window.</param>
	/// <param name="tab">Tab name (wildcard expression). If null (default), uses the current tab.</param>
	/// <exception cref="AuWndException"><i>w</i> invalid.</exception>
	public static ExplorerFolder Of(wnd w, string tab = null) {
		w.ThrowIfInvalid();
		wnd cTab = w.Child(tab, "ShellTabWindowClass");
		if (tab != null && cTab.Is0) return null;
		var b = _GetIWebBrowser(w, cTab);
		return b == null ? null : new() { _b = b, _w = w, _cTab = cTab };
	}
	
	static api.IWebBrowser2 _GetIWebBrowser(wnd w, wnd cTab) {
		foreach (var b in _EnumShellWindows()) {
			try {
				if ((wnd)b.HWND == w) {
					if (!cTab.Is0 && _GetIShellBrowser(b, out var sb)) {
						bool ok = 0 == sb.GetWindow(out var c) && c == cTab;
						Marshal.ReleaseComObject(sb);
						if (!ok) continue;
					}
					return b;
				}
				Marshal.ReleaseComObject(b);
			}
			catch (COMException) { /*print.warning(b.LocationURL);*/ } //about:blank
		}
		return null;
	}
	
	static IEnumerable<api.IWebBrowser2> _EnumShellWindows() {
		//var sw = new _Api.ShellWindows() as _Api.IShellWindows; //4 times slower than in C++. CoCreateInstance 3 times slower.
		if (0 != Api.CoCreateInstance(new("9BA05972-F6A8-11CF-A442-00A0C90A8F39"), 0, 4, typeof(api.IShellWindows).GUID, out var o)) throw new AuException();
		var sw = o as api.IShellWindows;
		for (int i = 0, n = sw.Count(); i < n; i++) {
			yield return sw.Item(i) as api.IWebBrowser2;
		}
		Marshal.ReleaseComObject(sw);
	}
	
	static bool _GetIShellBrowser(api.IWebBrowser2 b, out api.IShellBrowser sb) => Api.QueryService(b, api.SID_STopLevelBrowser, out sb);
	
	/// <summary>
	/// Creates <see cref="ExplorerFolder"/> for all folder windows.
	/// </summary>
	/// <param name="onlyFilesystem">Skip folders that don't have a filesystem path, such as Control Panel and Recycle Bin.</param>
	/// <param name="tabsOf">Need only tabs of this window.</param>
	public static ExplorerFolder[] All(bool onlyFilesystem = false, wnd tabsOf = default) {
		var a = new List<ExplorerFolder>();
		foreach (var b in _EnumShellWindows()) {
			try {
				var s = b.LocationURL;
				if (s.NE()) {
					if (onlyFilesystem) continue;
				} else {
					if (!s.Starts("file:///")) continue; //skip IE etc
				}
				
				wnd w = (wnd)b.HWND, c = default;
				if (!tabsOf.Is0 && w != tabsOf) continue;
				if (_GetIShellBrowser(b, out var sb)) sb.GetWindow(out c);
				
				a.Add(new() { _b = b, _w = w, _cTab = c });
			}
			catch (COMException) { /*print.warning(b.LocationURL);*/ } //about:blank
		}
		return a.ToArray();
	}
	
	/// <summary>
	/// Calls <see cref="GetFolderPath"/>.
	/// </summary>
	public override string ToString() => GetFolderPath();

	/// <summary>
	/// Gets <c>IWebBrowser2</c> interface pointer.
	/// </summary>
	public object ComObject => _b;
	
	/// <summary>
	/// Gets window handle.
	/// </summary>
	public wnd Hwnd => _w;
	
	/// <summary>
	/// Gets tab control handle.
	/// </summary>
	public wnd HwndTab => _cTab;
	
	/// <summary>
	/// Gets folder path.
	/// For non-filesystem folder gets string like <c>":: ITEMIDLIST"</c>; see <see cref="Pidl"/>.
	/// </summary>
	/// <returns><c>null</c> if failed.</returns>
	public string GetFolderPath() {
		var s = _b.LocationURL;
		if (!s.NE()) {
			if (!s.Starts("file:///")) return null;
			if (0 != Api.PathCreateFromUrlAlloc(s, out var r)) return null; //note: .NET urldecoding functions produce invalid string if there are urlencoded non-ASCII characters
			return r;
		} else { //non-filesystem?
			if (_GetIShellBrowser(_b, out var sb)) {
				if (0 == sb.QueryActiveShellView(out var v1) && v1 is api.IFolderView2 f) {
					var p = new Pidl(f.GetFolder(typeof(api.IPersistFolder2).GUID).GetCurFolder());
					return p.ToString();
				}
			}
			return null;
		}
	}
	
	/// <summary>
	/// Gets paths of selected items.
	/// </summary>
	/// <returns>Array containing 0 or more items.</returns>
	/// <remarks>
	/// For non-file-system items gets <c>":: ITEMIDLIST"</c>; see <see cref="Pidl"/>.
	/// </remarks>
	public string[] GetSelectedItems() {
		var d = _b.Document as api.ShellFolderView;
		var items = d?.SelectedItems();
		if (items == null) return [];
		int n = items.Count;
		var a = new List<string>(n);
		for (int i = 0; i < n; i++) {
			try {
				var s = items.Item(i)?.Path;
				if (!s.NE()) a.Add(Pidl.ClsidToItemidlist_(s));
			}
			catch { }
			//once: no selection, but items.Count returned 1, and items.Item(i) returned null. Could not reproduce after select-unselect.
		}
		return a.ToArray();
	}
	
	/// <summary>
	/// Opens a folder in this window/tab.
	/// </summary>
	/// <param name="folder">Folder path or <c>":: ITEMIDLIST"</c>. Or <c>":back"</c>, <c>":forward"</c>, <c>":up"</c>.</param>
	/// <exception cref="Exception">Failed.</exception>
	public void Open(string folder) {
		if (!_GetIShellBrowser(_b, out var sb)) throw new AuException();
		var flag = folder switch { ":back" => api.SBSP_NAVIGATEBACK, ":forward" => api.SBSP_NAVIGATEFORWARD, ":up" => api.SBSP_PARENT, _ => 0u };
		if (flag != 0) {
			sb.BrowseObject(0, flag | api.SBSP_SAMEBROWSER);
		} else {
			using var pidl = Pidl.FromString(folder, throwIfFailed: true);
			sb.BrowseObject(pidl.UnsafePtr, api.SBSP_SAMEBROWSER);
		}
		30.ms();
		while (_b.Busy != 0) 10.ms();
	}
	
	/// <summary>
	/// Adds new tab in a folder window.
	/// </summary>
	/// <param name="w">A folder window.</param>
	/// <param name="folder">If not null, calls <see cref="Open"/>.</param>
	/// <returns><see cref="ExplorerFolder"/> for the new tab.</returns>
	/// <exception cref="Exception">Failed.</exception>
	/// <remarks>
	/// To create new tab, activates the window and sends keys <c>Ctrl+T</c>.
	/// </remarks>
	public static ExplorerFolder NewTab(wnd w, string folder = null) {
		_ThrowIfNoMultipleTabs();
		w.Activate();
		var c1 = w.Child(cn: "ShellTabWindowClass");
		keys.send("Ctrl+T");
		30.ms();
		wait.until(5, () => w.Child(cn: "ShellTabWindowClass") != c1);
		
		var r = ExplorerFolder.Of(w);
		if (folder != null) r.Open(@"C:\Test");
		return r;
		
		//Alternative.
		//	Bad: undocumented, found only in https://stackoverflow.com/a/78502949/26641797
		//	Good: don't need to activate window.
		//	Same: async too. Need to wait.
		//c1.Send(api.WM_COMMAND, 0xA21B);
	}
	
	/// <summary>
	/// Makes this tab visible.
	/// </summary>
	/// <exception cref="Exception">Failed.</exception>
	public void SwitchToTab() {
		_ThrowIfNoMultipleTabs();
		var s = _cTab.Name;
		var c = _w.ChildFast("", "Microsoft.UI.Content.DesktopChildSiteBridge");
		Debug_.PrintIf(c.Is0);
		if (c.Is0) c = _w;
		var a = c.Elm["PAGETAB", s].FindAll();
		if (a.Length == 0) throw new AuException();
		if (a.Length == 1) {
			a[0].Invoke();
			Debug_.PrintIf(_w.ChildFast(null, "ShellTabWindowClass") != _cTab);
		} else {
			foreach (var e in a) {
				e.Invoke();
				if (_w.ChildFast(null, "ShellTabWindowClass") == _cTab) break;
			}
		}
	}
	
	static void _ThrowIfNoMultipleTabs() {
		if (!osVersion.minWin11_22H2) throw new InvalidOperationException("Multiple tabs not supported in this Windows version.");
	}
	
	//rejected: InvokeVerbOnSelection. Too limited. Verbs unknown. Many commands can be invoked with hotkeys.
	
	class api : NativeApi {
		[ComImport, Guid("85CB6900-4D95-11CF-960C-0080C7F4EE85")]
		internal interface IShellWindows {
			int Count();
			[return: MarshalAs(UnmanagedType.IDispatch)] object Item(object index);
		}
		
		[ComImport, Guid("d30c1661-cdaf-11d0-8a3e-00c04fc9e26e"), InterfaceType(ComInterfaceType.InterfaceIsIDispatch)]
		internal interface IWebBrowser2 {
			object Document { get; }
			//string Path { get; } //always C:\WINDOWS\
			string LocationURL { get; }
			long HWND { get; }
			short Busy { get; }
			short Visible { get; }
		}
		
		[ComImport, Guid("29EC8E6C-46D3-411f-BAAA-611A6C9CAC66"), InterfaceType(ComInterfaceType.InterfaceIsIDispatch)]
		internal interface ShellFolderView {
			FolderItems SelectedItems();
		}
		
		[ComImport, Guid("744129E0-CBE5-11CE-8350-444553540000"), InterfaceType(ComInterfaceType.InterfaceIsIDispatch)]
		internal interface FolderItems {
			int Count { get; }
			FolderItem Item(object index);
		}
		
		[ComImport, Guid("FAC32C80-CBE4-11CE-8350-444553540000"), InterfaceType(ComInterfaceType.InterfaceIsIDispatch)]
		internal interface FolderItem {
			string Path { get; }
		}
		
		internal static readonly Guid SID_STopLevelBrowser = new(0x4C96BE40, 0x915C, 0x11CF, 0x99, 0xD3, 0x00, 0xAA, 0x00, 0x4A, 0xE8, 0x37);
		
		[ComImport, Guid("000214E2-0000-0000-C000-000000000046"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
		internal interface IShellBrowser {
			[PreserveSig] int GetWindow(out wnd phwnd);
			void _2();
			void _3();
			void _4();
			void _5();
			void _6();
			void _7();
			void _8();
			void BrowseObject(nint pidl, uint wFlags);
			void _a();
			void _b();
			void _c();
			[PreserveSig] int QueryActiveShellView([MarshalAs(UnmanagedType.IUnknown)] out object ppshv);
		}
		
		[ComImport, Guid("1AC3D9F0-175C-11d1-95BE-00609797EA4F"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
		internal interface IPersistFolder2 {
			void _1();
			void _2();
			IntPtr GetCurFolder();
		}
		
		[ComImport, Guid("1af3a467-214f-4298-908e-06b03e0b39f9"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
		internal interface IFolderView2 {
			void _1();
			void _2();
			IPersistFolder2 GetFolder(in Guid riid);
		}
		
		internal const uint SBSP_SAMEBROWSER = 0x1;
		internal const uint SBSP_NAVIGATEBACK = 0x4000;
		internal const uint SBSP_NAVIGATEFORWARD = 0x8000;
		internal const uint SBSP_PARENT = 0x2000;
	}
}


================================================
FILE: Au/Files, data/FileSystemRedirection.cs
================================================
namespace Au.More;

/// <summary>
/// File system redirection functions. Can temporarily disable redirection, to allow this 32-bit process access the 64-bit System32 directory.
/// Example: <c>using (FileSystemRedirection r1 = new()) { r1.Disable(); ... }</c>.
/// </summary>
public struct FileSystemRedirection : IDisposable {
	bool _redirected;
	IntPtr _redirValue;

	/// <summary>
	/// Calls <see cref="Revert"/>.
	/// </summary>
	public void Dispose() {
		Revert();
	}

	/// <summary>
	/// If <see cref="osVersion.is32BitProcessAnd64BitOS"/>, calls API <ms>Wow64DisableWow64FsRedirection</ms>, which disables file system redirection.
	/// </summary>
	/// <remarks>
	/// The caller can call this without checking OS and process bitness. This function checks it and it is fast.
	/// 
	/// Always call <see cref="Revert"/> or <see cref="Dispose"/>, for example use <c>finally</c> or <c>using</c> statement. Not calling it is more dangerous than a memory leak. It is not called by GC.
	/// </remarks>
	public void Disable() {
		if (osVersion.is32BitProcessAnd64BitOS)
			_redirected = Api.Wow64DisableWow64FsRedirection(out _redirValue);
	}

	/// <summary>
	/// If redirected, calls API <ms>Wow64RevertWow64FsRedirection</ms>.
	/// </summary>
	public void Revert() {
		if (_redirected)
			_redirected = !Api.Wow64RevertWow64FsRedirection(_redirValue);
	}

	/// <summary>
	/// Returns <c>true</c> if <see cref="osVersion.is32BitProcessAnd64BitOS"/> is <c>true</c> and path starts with <see cref="folders.System"/>.
	/// Most such paths are redirected, therefore you may want to disable redirection with this class.
	/// </summary>
	/// <param name="path">Normalized path. This function does not normalize. Also it is unaware of <c>@"\\?\"</c>.</param>
	public static bool IsSystem64PathIn32BitProcess(string path) {
		return 0 != _IsSystem64PathIn32BitProcess(path);
	}

	static int _IsSystem64PathIn32BitProcess(string path) {
		if (!osVersion.is32BitProcessAnd64BitOS) return 0;
		string sysDir = folders.System;
		if (!path.Starts(sysDir, true)) return 0;
		int len = sysDir.Length;
		if (path.Length > len && !pathname.IsSepChar_(path[len])) return 0;
		return len;
	}

	/// <summary>
	/// If <see cref="osVersion.is32BitProcessAnd64BitOS"/> is <c>true</c> and <i>path</i> starts with <see cref="folders.System"/>, replaces that path part with <see cref="folders.SystemX64"/>.
	/// It disables redirection to <see cref="folders.SystemX86"/> for that path.
	/// </summary>
	/// <param name="path">Normalized path. This function does not normalize. Also it is unaware of <c>@"\\?\"</c>.</param>
	/// <param name="ifExistsOnlyThere">Don't replace <i>path</i> if the file or directory exists in the redirected folder or does not exist in the non-redirected folder.</param>
	public static string GetNonRedirectedSystemPath(string path, bool ifExistsOnlyThere = false) {
		int i = _IsSystem64PathIn32BitProcess(path);
		if (i == 0) return path;
		if (ifExistsOnlyThere && filesystem.exists(path)) return path;
		var s = path.ReplaceAt(0, i, folders.SystemX64);
		if (ifExistsOnlyThere && !filesystem.exists(s)) return path;
		return s;
	}
}


================================================
FILE: Au/Files, data/FileTree.cs
================================================
namespace Au.More;

/// <summary>
/// Contains file infos of this and descendant folders and files retrieved by <see cref="filesystem.enumerate"/>.
/// Can print a formatted list of descendant sizes.
/// </summary>
public class FileTree : TreeBase<FileTree> {
	FEFile _f;
	
	FileTree(FEFile f) {
		if (f != null) {
			_f = f;
			Size = f.Size;
		}
	}
	
	/// <summary>
	/// Gets the info retrieved by <see cref="filesystem.enumerate"/>.
	/// </summary>
	public FEFile Info => _f;
	
	/// <summary>
	/// Filename.
	/// </summary>
	public string Name => _f.Name;
	
	/// <summary>
	/// Full path.
	/// </summary>
	public string Path => _f.FullPath;
	
	/// <inheritdoc cref="FEFile.IsDirectory"/>
	public bool IsDirectory => _f.IsDirectory;
	
	/// <summary>
	/// Gets the file size. If directory, it's the sum of all descendant file sizes.
	/// </summary>
	public long Size { get; private set; }
	
	/// <summary>
	/// Calls <see cref="filesystem.enumerate"/> and creates a tree of descendants.
	/// </summary>
	/// <param name="path">Folder path.</param>
	/// <param name="onlyDirectories">Don't include files.</param>
	/// <param name="minSize">Don't include smaller files and directories. The unit is bytes.</param>
	/// <param name="ignoreInaccessible">If cannot access some descendant directories, ignore them and don't throw exception. Default <c>true</c>.</param>
	/// <param name="recurseNtfsLinks">Enumerate target directories of NTFS links, such as symbolic links and mount points.</param>
	/// <param name="dirFilter">Called for each descendant directory. If returns <c>false</c>, that directory with descendants is not included. But its size contributes to ancestor sizes anyway.</param>
	/// <param name="fileFilter">Called for each descendant file. If returns <c>false</c>, that file is not included. But its size contributes to ancestor sizes anyway.</param>
	/// <returns>The root of the tree. You can use its descendants and <see cref="Size"/>. Don't use <see cref="Info"/>, <see cref="Name"/>, <see cref="Path"/> and <see cref="IsDirectory"/>.</returns>
	/// <exception cref="Exception">Exceptions of <see cref="filesystem.enumerate"/>.</exception>
	public static FileTree Create(string path, bool onlyDirectories = false, long minSize = 0, bool ignoreInaccessible = true, bool recurseNtfsLinks = false, Func<FEFile, bool> dirFilter = null, Func<FEFile, bool> fileFilter = null) {
		var flags = ignoreInaccessible ? FEFlags.IgnoreInaccessible : 0;
		if (recurseNtfsLinks) flags |= FEFlags.RecurseNtfsLinks;
		
		FileTree root = new(null);
		_Dir(path, root, 0, false, flags);
		return root;
		
		void _Dir(string path, FileTree x, int level, bool skipDescendants, FEFlags flags) {
			foreach (var f in filesystem.enumerate(path, flags)) {
				f.Level = level;
				if (f.IsDirectory) {
					bool skip = skipDescendants || (dirFilter != null && !dirFilter(f));
					var y = new FileTree(f);
					_Dir(f.FullPath, y, level + 1, skip, flags | FEFlags.UseRawPath);
					x.Size += y.Size;
					if (!skip && y.Size >= minSize) x.AddChild(y);
				} else {
					x.Size += f.Size;
					bool skip = skipDescendants || onlyDirectories || f.Size < minSize || (fileFilter != null && !fileFilter(f));
					if (!skip) x.AddChild(new(f));
				}
			}
		}
	}
	
	/// <summary>
	/// Appends to a <see cref="StringBuilder"/> a list of sizes and names of descendants, formatted for <see cref="print.it(string)"/>, without a header.
	/// </summary>
	public void PrintSizes(StringBuilder b) {
		_Dir(this, 0);
		
		void _Dir(FileTree x, int level) {
			foreach (var y in x.Children().OrderByDescending(o => o.Size)) {
				b.Append('\t', level);
				var k = y.Size / MB;
				b.AppendFormat(k == 0 ? "0       " : k < .001 ? "<0.001  " : k < .1 ? "{0,-7:0.###} " : k < 1 ? "{0,-7:0.##} " : k < 10 ? "{0,-7:0.#} " : "{0,-7:0.} ", k);
				if (y.IsDirectory) {
					b.AppendFormat("<explore {0}>{1}<>", y.Path, y.Name);
					if (y.HasChildren) {
						b.AppendLine("    <fold>");
						_Dir(y, level + 1);
						b.Length -= 2;
						b.Append("</fold>");
					}
				} else {
					b.AppendFormat("<explore {0}>{1}<>  (file)", y.Path, y.Name);
				}
				b.AppendLine();
			}
		}
	}
	
	const double MB = 1048576;
	
	/// <summary>
	/// Formats and prints a list of sizes and names of folder's descendant folders and optionally files, with a header.
	/// </summary>
	/// <param name="minSizeMB">Don't include smaller files and directories. The unit is MB.</param>
	/// <inheritdoc cref="Create"/>
	public static void PrintSizes(string path, bool onlyDirectories = false, double minSizeMB = 0, bool ignoreInaccessible = true, bool recurseNtfsLinks = false, Func<FEFile, bool> dirFilter = null, Func<FEFile, bool> fileFilter = null) {
		var t = Create(path, onlyDirectories, (long)(minSizeMB * MB), ignoreInaccessible, recurseNtfsLinks, dirFilter, fileFilter);
		
		var b = new StringBuilder("<><lc #C0E0A0>Sizes (MB) of folders");
		if (!onlyDirectories) b.Append(" and files");
		b.Append($" in <link>{path}<>");
		if (minSizeMB > 0) b.Append($". Skipped sizes < {minSizeMB} MB.");
		b.AppendLine("<>");
		
		t.PrintSizes(b);
		print.it(b);
	}
}


================================================
FILE: Au/Files, data/FileWatcher.cs
================================================
namespace Au.More;

/// <summary>
/// Watches a file for external changes. An external change is when another process writes, creates, deletes, moves or renames the file.
/// </summary>
/// <remarks>
/// All functions are thread-safe.
/// </remarks>
/// <example>
/// <code><![CDATA[
/// /*/ ifRunning run; /*/
/// 
/// var c = new C();
/// c.Load(@"C:\Test\FileWatcher.xml");
/// c.ModifyAndSave();
/// dialog.show("Testing FileWatcher");
/// 
/// class C {
/// 	string _file;
/// 	XElement _x;
/// 	FileWatcher _watcher;
/// 	
/// 	public void Load(string file) {
/// 		_file = file;
/// 		if (filesystem.exists(_file)) {
/// 			_x = XElement.Load(_file);
/// 		} else {
/// 			_x = XElement.Parse("""<a>example</a>""");
/// 		}
/// 		_watcher ??= FileWatcher.Watch(_file, _OnExternalChange);
/// 	}
/// 	
/// 	void _OnExternalChange() {
/// 		_x = XElement.Load(_file);
/// 		print.it("external change", _x);
/// 	}
/// 	
/// 	public void ModifyAndSave() {
/// 		_x.Value = Random.Shared.Next().ToString();
/// 		
/// 		_watcher?.Paused = true;
/// 		try { _x.Save(_file); }
/// 		finally { _watcher?.Paused = false; }
/// 	}
/// }
/// ]]></code>
/// </example>
public sealed class FileWatcher : IDisposable {
	readonly object _dirWatcher;
	readonly string _file;
	Action _action;
	CancellationTokenSource _cts;
	long _timestamp;
	readonly object _lock = new();
	
	static _Watchers s_watchers = new();
	
	FileWatcher(object dirWatcher, string file, Action action) {
		_dirWatcher = dirWatcher;
		_file = file;
		_action = action;
		_SetTimestamp();
	}
	
	/// <summary>
	/// Stops watching.
	/// </summary>
	/// <remarks>
	/// Don't need to ever call this, unless you want to stop watching before the process exits.
	/// </remarks>
	public void Dispose() {
		DisposeNoRemove_();
		s_watchers.Remove(this);
	}
	
	internal void DisposeNoRemove_() {
		_action = null;
		lock (_lock) {
			_cts?.Dispose();
			_cts = null;
		}
	}
	
	void _SetTimestamp() {
		filesystem.GetTime_(_file, out _timestamp);
	}
	
	/// <summary>
	/// When your app writes, creates, deletes, moves or renames the file, it must set this property = <c>true</c> during the file operation. It helps to distinguish internal and external changes. Example: <see cref="FileWatcher"/>.
	/// </summary>
	public bool Paused {
		get => field;
		set {
			if (value == field) return;
			field = value;
			if (!field && _action != null) _SetTimestamp();
		}
	}
	
	void _Event(FileSystemEventArgs e) {
		//print.it(e.ChangeType, e.Name);
		if (Paused || _action is null) return;
		
		try {
			lock (_lock) {
				_cts?.Cancel();
				_cts?.Dispose();
				_cts = new();
				
				_ = Task.Delay(100, _cts.Token).ContinueWith(t => { //to cancel previous duplicate events
					try {
						if (t.IsCanceled) return;
						bool exists = filesystem.GetProp_(_file, out var p);
						bool deleted = e.ChangeType == WatcherChangeTypes.Deleted && !exists;
						if (deleted) {
							_timestamp = 0;
						} else {
							Debug_.PrintIf(!exists); if (!exists) return; //maybe temporarily deleted; we should get 'deleted' notification afterwards
							Debug_.PrintIf(p.size == 0); if (p.size == 0) return; //eg VSCode saves like this: opens, clears, closes; then opens writes closes. Normally the first notification is canceled, but.
							if (p.time == _timestamp) return;
							_timestamp = p.time;
						}
						//print.it(e.ChangeType, e.Name);
						_action?.Invoke();
					}
					catch (Exception ex) { Debug_.Print(ex); }
				}, TaskScheduler.Default);
			}
		}
		catch (Exception ex) { Debug_.Print(ex); } //eg _cts disposed
	}
	
	/// <summary>
	/// Starts watching a file for external changes. An external change is when another process writes, creates, deletes, moves or renames the file.
	/// </summary>
	/// <param name="file">Full path of a file, without environment variables.</param>
	/// <param name="onExternalChange">
	/// Called when detected that the file was changed externally.
	/// Important: when your app writes, creates, deletes, moves or renames the file, it must set <see cref="Paused"/> = <c>true</c> during the file operation.
	/// Runs in a thread pool thread.
	/// </param>
	/// <returns>
	/// A new <see cref="FileWatcher"/> instance used to manage the watcher.
	/// Don't need to dispose it, unless you want to stop watching before the process exits.
	/// Returns <c>null</c> and prints a warning if the watcher could not be created (for example the directory does not exist).
	/// </returns>
	/// <exception cref="NotSupportedException">
	/// Thrown if this method has already been called for the same file without a corresponding call to <see cref="Dispose"/>.
	/// If multiple notification handlers are needed, combine them into the <i>onExternalChange</i> delegate.
	/// </exception>
	/// <example><see cref="FileWatcher"/></example>
	public static FileWatcher Watch(string file, Action onExternalChange)
		=> s_watchers.Add(file ?? throw new ArgumentNullException(), onExternalChange ?? throw new ArgumentNullException());
	
	internal static void DisposeAll_() { s_watchers.DisposeAll(); }
	
	class _Watchers {
		class _DirectoryWatcher : FileSystemWatcher {
			public readonly Dictionary<string, FileWatcher> dFiles = new(StringComparer.OrdinalIgnoreCase);
			
			public _DirectoryWatcher(string dir) : base(dir) { }
		}
		
		readonly List<_DirectoryWatcher> _a = [];
		
		public FileWatcher Add(string file, Action modifiedExternally) {
			lock (this) {
				var dir = pathname.getDirectory(file);
				_DirectoryWatcher dw = null; foreach (var v in _a) if (v.Path.Eqi(dir)) { dw = v; break; }
				if (dw is null) {
					try {
						dw = new(dir) { NotifyFilter = NotifyFilters.FileName | NotifyFilters.LastWrite };
						dw.Deleted += _Event;
						dw.Created += _Event;
						dw.Changed += _Event;
						dw.Renamed += _Event;
						dw.EnableRaisingEvents = true;
						_a.Add(dw);
					}
					catch (Exception ex) { //eg directory does not exist
						dw?.Dispose();
						print.warning($"Cannot watch '{file}'. {ex}");
						return null;
					}
				}
				
				FileWatcher f = new(dw, file, modifiedExternally);
				if (!dw.dFiles.TryAdd(pathname.getName(file), f)) throw new NotSupportedException($"A FileWatcher for '{file}' already exists");
				
				return f;
			}
			
			static void _Event(object sender, FileSystemEventArgs e) {
				var dw = sender as _DirectoryWatcher;
				if (dw.dFiles.TryGetValue(e.Name, out var f)) f._Event(e);
			}
		}
		
		public void Remove(FileWatcher f) {
			lock (this) {
				var dw = f._dirWatcher as _DirectoryWatcher;
				dw.dFiles.Remove(pathname.getName(f._file));
				if (dw.dFiles.Count == 0) {
					_a.Remove(dw);
					dw.Dispose();
				}
			}
		}
		
		public void DisposeAll() {
			lock (this) {
				foreach (var dw in _a) {
					dw.Dispose();
					foreach (var f in dw.dFiles.Values) f.DisposeNoRemove_();
					dw.dFiles.Clear();
				}
				_a.Clear();
			}
		}
		
		public _Watchers() {
			//It's better to dispose/stop everything on process exit as soon as possible, to avoid invoking ModifiedExternally while/after clients execute process.thisProcessExit etc handlers.
			System.Runtime.Loader.AssemblyLoadContext.Default.Unloading += c => DisposeAll(); //before thisProcessExit/ProcessExit. Not on unhandled exception.
			AppDomain.CurrentDomain.UnhandledException += (_, _) => DisposeAll(); //never mind: maybe not the first event handler. Unlikely something bad can happen. If using JSettings, its process.thisProcessExit calls DisposeAll before saving all.
		}
	}
}


================================================
FILE: Au/Files, data/Pidl.cs
================================================
namespace Au.Types;

/// <summary>
/// Manages an <ms>ITEMIDLIST</ms> structure that is used to identify files and other shell objects instead of a file-system path.
/// </summary>
/// <remarks>
/// Wraps an <c>ITEMIDLIST*</c>, also known as <i>PIDL</i> or <c>LPITEMIDLIST</c>.
/// 
/// When calling native shell API, virtual objects can be identified only by <c>ITEMIDLIST*</c>. Some API also support "parsing name", which may look like <c>"::{CLSID-1}\::{CLSID-2}"</c>. File-system objects can be identified by path as well as by <c>ITEMIDLIST*</c>. URLs can be identified by URL as well as by <c>ITEMIDLIST*</c>.
/// 
/// The <c>ITEMIDLIST</c> structure is in unmanaged memory. You can dispose <c>Pidl</c> variables, or GC will do it later. Always dispose if creating many.
/// 
/// This class has only <c>ITEMIDLIST</c> functions that are used in this library. Look for other functions on the Internet. Many of them are named with IL prefix, like <c>ILClone</c>, <c>ILGetSize</c>, <c>ILFindLastID</c>.
/// </remarks>
public unsafe class Pidl : IDisposable {
	IntPtr _pidl;
	
	/// <summary>
	/// Gets the <c>ITEMIDLIST*</c>.
	/// </summary>
	/// <remarks>
	/// The <c>ITEMIDLIST</c> memory is managed by this variable and will be freed when disposing or GC-collecting it. Use <see cref="GC.KeepAlive"/> where need.
	/// </remarks>
	public IntPtr UnsafePtr => _pidl;
	
	/// <summary>
	/// Gets the <c>ITEMIDLIST*</c>.
	/// </summary>
	/// <remarks>
	/// Use to pass to API where the parameter type is <see cref="System.Runtime.InteropServices.HandleRef"/>. It is safer than <see cref="UnsafePtr"/> because ensures that this variable will not be GC-collected during API call even if not referenced after the call.
	/// </remarks>
	public HandleRef HandleRef => new HandleRef(this, _pidl);
	
	/// <summary>
	/// Returns <c>true</c> if the <c>ITEMIDLIST*</c> is <c>null</c>.
	/// </summary>
	public bool IsNull => _pidl == default;
	
	/// <summary>
	/// Assigns an <c>ITEMIDLIST</c> to this variable.
	/// </summary>
	/// <param name="pidl">
	/// <c>ITEMIDLIST*</c>.
	/// It can be created by any API that creates <c>ITEMIDLIST</c>. They allocate the memory with API <ms>CoTaskMemAlloc</ms>. This variable will finally free it with <see cref="Marshal.FreeCoTaskMem"/> which calls API <ms>CoTaskMemFree</ms>.
	/// </param>
	public Pidl(IntPtr pidl) => _pidl = pidl;
	
	/// <summary>
	/// Combines two <c>ITEMIDLIST</c> (parent and child) and assigns the result to this variable.
	/// </summary>
	/// <param name="pidlAbsolute">Absolute <c>ITEMIDLIST*</c> (parent folder).</param>
	/// <param name="pidlRelative">Relative <c>ITEMIDLIST*</c> (child object).</param>
	/// <remarks>
	/// Does not free <i>pidlAbsolute</i> and <i>pidlRelative</i>.
	/// </remarks>
	public Pidl(IntPtr pidlAbsolute, IntPtr pidlRelative) => _pidl = Api.ILCombine(pidlAbsolute, pidlRelative);
	
	/// <summary>
	/// Frees the <c>ITEMIDLIST</c> with <see cref="Marshal.FreeCoTaskMem"/> and clears this variable.
	/// </summary>
	public void Dispose() {
		Dispose(true);
		GC.SuppressFinalize(this);
	}
	
	///
	protected virtual void Dispose(bool disposing) {
		if (_pidl != default) {
			Marshal.FreeCoTaskMem(_pidl);
			_pidl = default;
		}
	}
	
	///
	~Pidl() { Dispose(false); }
	
	/// <summary>
	/// Gets the <c>ITEMIDLIST</c> and clears this variable so that it cannot be used and will not free the <c>ITEMIDLIST</c> memory. To free it use <see cref="Marshal.FreeCoTaskMem"/>.
	/// </summary>
	public IntPtr Detach() {
		var R = _pidl;
		_pidl = default;
		return R;
	}
	
	/// <summary>
	/// Converts string to <c>ITEMIDLIST</c> and creates new <see cref="Pidl"/> variable that holds it.
	/// </summary>
	/// <returns><c>null</c> if failed.</returns>
	/// <param name="s">A file-system path or URL or shell object parsing name (see <see cref="ToShellString"/>) or <c>":: ITEMIDLIST"</c> (see <see cref="ToHexString"/>). Supports environment variables (see <see cref="pathname.expand"/>).</param>
	/// <param name="throwIfFailed">Throw exception if failed.</param>
	/// <exception cref="AuException">Failed, and <i>throwIfFailed</i> is <c>true</c>. Probably invalid <i>s</i>.</exception>
	/// <remarks>
	/// Calls <ms>SHParseDisplayName</ms>, except when string is <c>":: ITEMIDLIST"</c>.
	/// If <c>":: ITEMIDLIST"</c>, does not check whether the shell object exists.
	/// </remarks>
	public static Pidl FromString(string s, bool throwIfFailed = false) {
		IntPtr R = FromString_(s, throwIfFailed);
		return (R == default) ? null : new Pidl(R);
	}
	
	/// <summary>
	/// The same as <see cref="FromString"/>, but returns unmanaged <c>ITEMIDLIST*</c>.
	/// Later need to free it with <c>Marshal.FreeCoTaskMem</c>.
	/// </summary>
	/// <param name="s"></param>
	/// <param name="throwIfFailed">If failed: <c>true</c> - throw <see cref="AuException"/>; <c>false</c> - return 0.</param>
	internal static IntPtr FromString_(string s, bool throwIfFailed = false) {
		IntPtr R;
		s = _Normalize(s);
		if (s.Starts(":: ")) {
			var span = s.AsSpan(3);
			int n = span.Length / 2;
			R = Marshal.AllocCoTaskMem(n + 2);
			byte* b = (byte*)R;
			n = Convert2.HexDecode(span, b, n);
			b[n] = b[n + 1] = 0;
		} else { //file-system path or URL or shell object parsing name
			var hr = Api.SHParseDisplayName(s, default, out R, 0, null);
			if (hr != 0) {
				if (throwIfFailed) throw new AuException(hr);
				return default;
			}
		}
		return R;
	}
	
	/// <summary>
	/// The same as <see cref="pathname.normalize"/><c>(CanBeUrlOrShell|DontPrefixLongPath)</c>, but ignores non-full path (returns <i>s</i>).
	/// </summary>
	/// <param name="s">File-system path or URL or <c>"::..."</c>.</param>
	static string _Normalize(string s) {
		s = pathname.expand(s);
		if (!pathname.isFullPath(s)) return s; //note: not EEV. Need to expand to ":: " etc, and EEV would not do it.
		return pathname.Normalize_(s, PNFlags.DontPrefixLongPath, true);
	}
	
	/// <summary>
	/// Converts the <c>ITEMIDLIST</c> to file path or URL or shell object parsing name or display name, depending on <i>stringType</i>.
	/// </summary>
	/// <returns>Returns <c>null</c> if this variable does not have an <c>ITEMIDLIST</c> (eg disposed or detached). If failed, returns <c>null</c> or throws exception.</returns>
	/// <param name="stringType">
	/// String format. API <ms>SIGDN</ms>.
	/// Often used:
	/// <br/>• <c>SIGDN.NORMALDISPLAY</c> - returns object name without path. It is best to display in UI but cannot be parsed to create <c>ITEMIDLIST</c> again.
	/// <br/>• <c>SIGDN.FILESYSPATH</c> - returns path if the <c>ITEMIDLIST</c> identifies a file system object (file or directory). Else returns <c>null</c>.
	/// <br/>• <c>SIGDN.URL</c> - if URL, returns URL. If file system object, returns its path like <c>"file:///C:/a/b.txt"</c>. Else returns <c>null</c>.
	/// <br/>• <c>SIGDN.DESKTOPABSOLUTEPARSING</c> - returns path (if file system object) or URL (if URL) or shell object parsing name (if virtual object eg Control Panel). Note: not all returned parsing names can actually be parsed to create <c>ITEMIDLIST</c> again, therefore usually it's better to use <see cref="ToString"/> instead.
	/// </param>
	/// <param name="throwIfFailed">If failed, throw <see cref="AuException"/>.</param>
	/// <exception cref="AuException">Failed, and <i>throwIfFailed</i> is <c>true</c>.</exception>
	/// <remarks>
	/// Calls <ms>SHGetNameFromIDList</ms>.
	/// </remarks>
	public string ToShellString(SIGDN stringType, bool throwIfFailed = false) {
		var R = ToShellString(_pidl, stringType, throwIfFailed);
		GC.KeepAlive(this);
		return R;
	}
	
	/// <summary>
	/// Converts an <c>ITEMIDLIST</c> to file path or URL or shell object parsing name or display name, depending on <i>stringType</i>.
	/// </summary>
	/// <returns>Returns <c>null</c> if <i>pidl</i> is <c>default(IntPtr)</c>. If failed, returns <c>null</c> or throws exception.</returns>
	/// <inheritdoc cref="ToShellString(SIGDN, bool)"/>
	public static string ToShellString(IntPtr pidl, SIGDN stringType, bool throwIfFailed = false) {
		if (pidl == default) return null;
		var hr = Api.SHGetNameFromIDList(pidl, stringType, out string R);
		if (hr == 0) return R;
		if (throwIfFailed) throw new AuException(hr);
		return null;
	}
	
	/// <summary>
	/// Converts the <c>ITEMIDLIST</c> to string.
	/// If it identifies an existing file-system object (file or directory), returns path. If URL, returns URL. Else returns <c>":: ITEMIDLIST"</c> (see <see cref="ToHexString"/>).
	/// </summary>
	/// <returns><c>null</c> if this variable does not have an <c>ITEMIDLIST</c> (eg disposed or detached).</returns>
	public override string ToString() {
		var R = ToString(_pidl);
		GC.KeepAlive(this);
		return R;
	}
	
#if true
	/// <summary>
	/// This overload uses an <c>ITEMIDLIST*</c> that is not stored in a <see cref="Pidl"/> variable.
	/// </summary>
	public static string ToString(IntPtr pidl) {
		if (pidl == default) return null;
		Api.IShellItem si = null;
		try {
			if (0 == Api.SHCreateShellItem(default, null, pidl, out si)) {
				//if(0 == Api.SHCreateItemFromIDList(pidl, Api.IID_IShellItem, out si)) { //same speed
				//if(si.GetAttributes(0xffffffff, out uint attr)>=0) print.it(attr);
				if (si.GetAttributes(Api.SFGAO_BROWSABLE | Api.SFGAO_FILESYSTEM, out uint attr) >= 0 && attr != 0) {
					var f = (0 != (attr & Api.SFGAO_FILESYSTEM)) ? SIGDN.FILESYSPATH : SIGDN.URL;
					if (0 == si.GetDisplayName(f, out var R)) return R;
				}
			}
		}
		finally { Api.ReleaseComObject(si); }
		return ToHexString(pidl);
	}
	//this version is 40% slower with non-virtual objects (why?), but with virtual objects same speed as SIGDN_DESKTOPABSOLUTEPARSING.
	//The fastest (update: actually not) version would be to call ToShellString_(SIGDN_DESKTOPABSOLUTEPARSING), and then call ToHexString if it returns not a path or URL. But it is unreliable, because can return string in any format, eg "Microsoft.WindowsCalculator_8wekyb3d8bbwe!App".
#elif false
			//this version works, but with virtual objects 2 times slower than SIGDN_DESKTOPABSOLUTEPARSING (which already is very slow with virtual).
			public static string ToString(IntPtr pidl)
			{
				if(pidl == default) return null;
				var R = ToShellString(pidl, SIGDN.FILESYSPATH);
				if(R == null) R = ToShellString(pidl, SIGDN.URL);
				if(R == null) R = ToHexString(pidl);
				return R;
			}
#elif true
			//this version works, but with virtual objects 30% slower. Also 30% slower for non-virtual objects (why?).
			public static string ToString(IntPtr pidl)
			{
				if(pidl == default) return null;

				Api.IShellItem si = null;
				try {
					if(0 == Api.SHCreateShellItem(default, null, pidl, out si)) {
						string R = null;
						if(0 == si.GetDisplayName(SIGDN.FILESYSPATH, out R)) return R;
						if(0 == si.GetDisplayName(SIGDN.URL, out R)) return R;
					}
				}
				finally { Api.ReleaseComObject(si); }
				return ToHexString(pidl);
			}
#else
			//SHGetPathFromIDList also slow.
			//SHBindToObject cannot get ishellitem.
#endif
	
	/// <summary>
	/// Returns string <c>":: ITEMIDLIST"</c>.
	/// Returns <c>null</c> if this variable does not have an <c>ITEMIDLIST</c> (eg disposed or detached).
	/// </summary>
	/// <remarks>
	/// The string can be used with some functions of this library, mostly of classes <see cref="filesystem"/>, <see cref="Pidl"/> and <see cref="icon"/>. Cannot be used with native and .NET functions.
	/// </remarks>
	public string ToHexString() {
		var R = ToHexString(_pidl);
		GC.KeepAlive(this);
		return R;
	}
	
	/// <summary>
	/// Returns string <c>":: ITEMIDLIST"</c>.
	/// This overload uses an <c>ITEMIDLIST*</c> that is not stored in a <see cref="Pidl"/> variable.
	/// </summary>
	public static string ToHexString(IntPtr pidl) {
		if (pidl == default) return null;
		int n = Api.ILGetSize(pidl) - 2; //API gets size with the terminating '\0' (2 bytes)
		if (n < 0) return null;
		if (n == 0) return ":: "; //shell root - Desktop
		return ":: " + Convert2.HexEncode((void*)pidl, n);
	}
	//rejected: use base64 <c>ITEMIDLIST</c>. Shorter, but cannot easily split, for example in folders.UnexpandPath.
	
	/// <summary>
	/// If <i>s</i> starts with <c>"::{"</c>, converts to <c>":: ITEMIDLIST"</c>. Else returns <i>s</i>.
	/// </summary>
	internal static string ClsidToItemidlist_(string s) {
		if (s != null && s.Starts("::{")) {
			using var pidl = FromString(s);
			if (pidl != null) return pidl.ToString();
		}
		return s;
	}
	
	/// <summary>
	/// Returns <c>true</c> if <c>ITEMIDLIST</c> values are equal.
	/// </summary>
	public bool ValueEquals(IntPtr pidl) => Api.ILIsEqual(_pidl, pidl);
}


================================================
FILE: Au/Files, data/TempFile.cs
================================================
namespace Au.More;

/// <summary>
/// Creates unique name for a temporary file and later auto-deletes the file.
/// </summary>
/// <remarks>
/// Use code like in the example to auto-delete the temporary file if exists. Or call <see cref="Dispose"/>. Else this class does not delete the file.
/// </remarks>
/// <example>
/// <code><![CDATA[
/// using (var f = new TempFile()) {
/// 	print.it(f);
/// 	filesystem.saveText(f, "DATA");
/// 	print.it(filesystem.loadText(f));
/// } //now auto-deletes the file
/// ]]></code>
/// </example>
public sealed class TempFile : IDisposable {
	readonly string _file;

	/// <summary>
	/// Creates full path string with a unique filename (GUID) for a temporary file.
	/// </summary>
	/// <param name="ext">Filename extension with dot. Default: <c>".tmp"</c>. Can be <c>null</c>.</param>
	/// <param name="directory">Parent directory. If <c>null</c> (default), uses <see cref="folders.ThisAppTemp"/>. The function creates the directory if does not exist.</param>
	/// <exception cref="ArgumentException"><i>directory</i> not full path.</exception>
	/// <exception cref="AuException">Failed to create directory.</exception>
	public TempFile(string ext = ".tmp", string directory = null) {
		filesystem.createDirectory(directory ??= folders.ThisAppTemp);
		_file = pathname.combine(directory, Guid.NewGuid().ToString()) + ext;
	}

	/// <summary>
	/// Deletes the file if exists.
	/// </summary>
	/// <remarks>
	/// Does not throw exception if fails to delete.
	/// </remarks>
	public void Dispose() { filesystem.delete(_file, FDFlags.CanFail); }

	/// <summary>
	/// Gets the file path.
	/// </summary>
	public string File => _file;

	/// <summary>
	/// Returns the file path.
	/// </summary>
	public static implicit operator string(TempFile f) => f._file;

	/// <summary>
	/// Returns the file path.
	/// </summary>
	public override string ToString() => _file;
}


================================================
FILE: Au/Files, data/filesystem-types.cs
================================================

namespace Au.Types;

/// <summary>
/// File system entry type - file, directory, NTFS link, whether it exists and is accessible.
/// The enum value <c>NotFound</c> is 0; <c>AccessDenied</c> is negative <c>((int)0x80000000)</c>; other values are greater than 0.
/// </summary>
internal enum FileIs_ {
	/// <summary>Does not exist.</summary>
	NotFound = 0,

	/// <summary>Is file, and not NTFS link.</summary>
	File = 1,

	/// <summary>Is directory, and not NTFS link.</summary>
	Directory = 2,

	/// <summary>Is NTFS link to file.</summary>
	NtfsLinkFile = 5,

	/// <summary>Is NTFS link to directory.</summary>
	NtfsLinkDirectory = 6,

	/// <summary>Exists but this process cannot access it and get attributes.</summary>
	AccessDenied = int.MinValue,
}

/// <summary>
/// Contains file or directory attributes. Tells whether it exists, is directory, readonly, hidden, system, NTFS link.
/// See <see cref="filesystem.exists"/>.
/// </summary>
public struct FAttr {
	readonly FileAttributes _a;
	readonly bool _exists, _unknown, _ntfsLink;

	/// <param name="attributes">Attributes, or 0 if does not exist or can't get attributes.</param>
	/// <param name="exists">True if exists and can get attributes. False if does not exist. <c>null</c> if exists but can't get attributes.</param>
	/// <param name="ntfsLink">Is a NTFS link, such as symbolic link or mount point.</param>
	internal FAttr(FileAttributes attributes, bool? exists, bool ntfsLink) {
		_a = attributes;
		_exists = exists == true;
		_unknown = exists == null;
		_ntfsLink = ntfsLink;
	}

	/// <summary>
	/// Returns file or directory attributes. Returns 0 if <see cref="Exists"/> <c>false</c>.
	/// </summary>
	public FileAttributes Attributes => _a;

	/// <summary>
	/// Returns <see cref="Exists"/>.
	/// </summary>
	public static implicit operator bool(FAttr fa) => fa.Exists;

	/// <summary>
	/// Returns 0 if !<see cref="Exists"/>, 1 if <see cref="File"/>, 2 if <see cref="Directory"/>. Can be used with switch.
	/// </summary>
	public static implicit operator int(FAttr fa) => !fa.Exists ? 0 : (fa.Directory ? 2 : 1);

	/// <summary>
	/// Exists and is accessible (<see cref="Unknown"/> <c>false</c>).
	/// See also <see cref="File"/>, <see cref="Directory"/>.
	/// </summary>
	public bool Exists => _exists;

	/// <summary>
	/// Exists but this process cannot access it and get attributes (error "access denied"). Then other <c>bool</c> properties return <c>false</c>.
	/// </summary>
	public bool Unknown => _unknown;

	/// <summary>
	/// Is file (not directory), or NTFS link to a file (if <see cref="IsNtfsLink"/> <c>true</c>).
	/// </summary>
	public bool File => 0 == (_a & FileAttributes.Directory) && _exists;

	/// <summary>
	/// Is directory, or NTFS link to a directory (if <see cref="IsNtfsLink"/> <c>true</c>).
	/// </summary>
	public bool Directory => 0 != (_a & FileAttributes.Directory);

	/// <summary>
	/// It is a NTFS link, such as symbolic link, junction or mount point. Don't confuse with shell links (shortcuts).
	/// If <see cref="File"/> <c>true</c>, the target is a file. If <see cref="Directory"/> <c>true</c>, the target is a directory.
	/// </summary>
	public bool IsNtfsLink => _ntfsLink;

	/// <summary>
	/// Has <see cref="FileAttributes.ReadOnly"/>.
	/// </summary>
	public bool IsReadonly => 0 != (_a & FileAttributes.ReadOnly);

	/// <summary>
	/// Has <see cref="FileAttributes.Hidden"/>.
	/// </summary>
	public bool IsHidden => 0 != (_a & FileAttributes.Hidden);

	/// <summary>
	/// Has <see cref="FileAttributes.System"/>.
	/// </summary>
	public bool IsSystem => 0 != (_a & FileAttributes.System);

	///
	public override string ToString() {
		return Unknown ? "unknown" : (Exists ? $"{{ Directory={Directory}, IsNtfsLink={IsNtfsLink}, Attributes={Attributes} }}" : "doesn't exist");
	}
}

/// <summary>
/// Flags for <see cref="filesystem.getAttributes"/> and some other functions.
/// </summary>
[Flags]
public enum FAFlags {
	///<summary>Pass path to the API as it is, without any normalizing and validating.</summary>
	UseRawPath = 1,

	///<summary>
	///If failed, return <c>false</c> and don't throw exception.
	///Then, if you need error info, you can use <see cref="lastError"/>. If the file/directory does not exist, it will return <ms>ERROR_FILE_NOT_FOUND</ms> or <c>ERROR_PATH_NOT_FOUND</c> or <c>ERROR_NOT_READY</c>.
	///If failed and the native error code is <c>ERROR_ACCESS_DENIED</c> or <c>ERROR_SHARING_VIOLATION</c>, the returned attributes will be <c>(FileAttributes)(-1)</c>. The file probably exists but is protected so that this process cannot access and use it. Else attributes will be 0.
	///</summary>
	DontThrow = 2,
}

/// <summary>
/// File or directory properties. Used with <see cref="filesystem.getProperties"/>.
/// </summary>
public record struct FileProperties {
	///
	public FileAttributes Attributes { get; set; }

	///<summary>File size. For directories it is usually 0.</summary>
	public long Size { get; set; }

	///
	public DateTime LastWriteTimeUtc { get; set; }

	///
	public DateTime CreationTimeUtc { get; set; }

	///<summary>Note: this is unreliable. The operating system may not record this time automatically.</summary>
	public DateTime LastAccessTimeUtc { get; set; }

	/// <summary>
	/// It is a NTFS link, such as symbolic link or mount point. Don't confuse with shell links (shortcuts).
	/// </summary>
	public bool IsNtfsLink { get; set; }
}

/// <summary>
/// flags for <see cref="filesystem.enumerate"/>.
/// </summary>
[Flags]
public enum FEFlags {
	/// <summary>
	/// Enumerate all descendants, not only direct children. Also known as "recurse subdirectories".
	/// </summary>
	AllDescendants = 1,

	/// <summary>
	/// Also enumerate target directories of NTFS links, such as symbolic links and mount points. Use with <c>AllDescendants</c>.
	/// </summary>
	RecurseNtfsLinks = 2,

	/// <summary>
	/// Skip files and subdirectories that have <c>Hidden</c> attribute.
	/// </summary>
	SkipHidden = 4,

	/// <summary>
	/// Skip files and subdirectories that have <c>Hidden</c> and <c>System</c> attributes (both).
	/// These files/directories usually are created and used only by the operating system. Drives usually have several such directories. Another example - thumbnail cache files.
	/// Without this flag the function skips only these hidden-system root directories when enumerating a drive: <c>$Recycle.Bin</c>, <c>System Volume Information</c>, <c>Recovery</c>. If you want to include them too, use network path of the drive, for example <c>@"\\localhost\D$\"</c> for <c>D</c> drive.
	/// </summary>
	SkipHiddenSystem = 8, //note: must match FCFlags

	/// <summary>
	/// If fails to get the contents of the directory or a subdirectory because of its security settings, assume that the [sub]directory is empty.
	/// Without this flag then throws exception or calls <i>errorHandler</i>.
	/// </summary>
	IgnoreInaccessible = 0x10, //note: must match FCFlags

	/// <summary>
	/// Get only files and not subdirectories.
	/// Note: the <i>dirFilter</i> callback function is called just to ask whether to include children.
	/// </summary>
	OnlyFiles = 0x20,

	/// <summary>
	/// Don't call <see cref="pathname.normalize"/> and don't throw exception for non-full path.
	/// </summary>
	UseRawPath = 0x40,

	/// <summary>
	/// Let <see cref="FEFile.Name"/> be path relative to the specified directory path. Like <c>@"\name.txt"</c> or <c>@"\subdirectory\name.txt"</c> instead of <c>"name.txt"</c>.
	/// </summary>
	NeedRelativePaths = 0x80,

	//rejected. Rarely used. Can use FileSystemRedirection, it's public.
	///// <summary>
	///// Temporarily disable file system redirection in this thread of this 32-bit process running on 64-bit Windows.
	///// Then you can enumerate the 64-bit System32 folder in your 32-bit process.
	///// Uses API <ms>Wow64DisableWow64FsRedirection</ms>.
	///// For vice versa (in 64-bit process enumerate the 32-bit System folder), instead use path <c>folders.SystemX86</c>.
	///// </summary>
	//DisableRedirection = 0x100,
}

/// <summary>
/// flags for <see cref="filesystem.copy"/> and some other similar functions.
/// Used only when copying directory.
/// </summary>
[Flags]
public enum FCFlags {
	//note: these values must match the corresponding FEFlags values.

	/// <summary>
	/// Skip descendant files and directories that have <c>Hidden</c> and <c>System</c> attributes (both).
	/// They usually are created and used only by the operating system. Drives usually have several such directories. Another example - thumbnail cache files.
	/// They often are protected and would fail to copy, ruining whole copy operation.
	/// Without this flag the function skips only these hidden-system root directories when enumerating a drive: <c>$Recycle.Bin</c>, <c>System Volume Information</c>, <c>Recovery</c>.
	/// </summary>
	SkipHiddenSystem = 8,

	/// <summary>
	/// If fails to get the contents of the directory or a subdirectory because of its security settings, don't throw exception but assume that the [sub]directory is empty.
	/// </summary>
	IgnoreInaccessible = 0x10,

	/// <summary>
	/// Don't create subdirectories that after applying all filters would be empty.
	/// </summary>
	NoEmptyDirectories = 0x10000,
}

/// <summary>
/// flags for <see cref="filesystem.delete"/>.
/// </summary>
[Flags]
public enum FDFlags {
	/// <summary>
	/// Send to the Recycle Bin. If not possible, delete anyway, unless used <c>CanFail</c>.
	/// Why could be not possible: 1. The file is in a removable drive (most removables don't have a recycle bin). 2. The file is too large. 3. The path is too long. 4. The Recycle Bin is not used on that drive (it can be set in the Recycle Bin Properties dialog). 5. This process is non-UI-interactive, eg a service. 6. Unknown reasons.
	/// Note: it is much slower. To delete multiple, use <see cref="filesystem.delete(IEnumerable{string}, FDFlags)"/>.
	/// </summary>
	RecycleBin = 1,

	/// <summary>
	/// If fails to delete, don't wait/retry and don't throw exception.
	/// </summary>
	CanFail = 2,

	//rejected. Rarely useful. Maybe in the future.
	///// <summary>
	///// Fail if has read-only attribute.
	///// </summary>
	//ReadonlyFail = 4,
}

/// <summary>
/// Contains name and other main properties of a file or subdirectory retrieved by <see cref="filesystem.enumerate"/>.
/// The values are not changed after creating the variable.
/// </summary>
public class FEFile {
	internal FEFile(string name, string fullPath, in Api.WIN32_FIND_DATA d, int level) {
		Name = name; FullPath = fullPath;
		Attributes = d.dwFileAttributes;
		Size = (long)d.nFileSizeHigh << 32 | d.nFileSizeLow;
		LastWriteTimeUtc = DateTime.FromFileTimeUtc(d.ftLastWriteTime); //fast, sizeof 8
		CreationTimeUtc = DateTime.FromFileTimeUtc(d.ftCreationTime);
		_level = (short)level;
		ReparseTag = d.dwReserved0;
	}

	/// <summary>
	/// Gets file name. Or relative path if used <see cref="FEFlags.NeedRelativePaths"/>.
	/// </summary>
	public string Name { get; }

	/// <summary>
	/// Gets full path.
	/// </summary>
	public string FullPath { get; }

	/// <summary>
	/// Gets filename extension. Returns <c>""</c> if directory.
	/// </summary>
	public string Extension => IsDirectory ? "" : pathname.getExtension(Name); //note: if null for directory, then OrderBy throws exception

	/// <summary>
	/// Returns file size. For directories it is usually 0.
	/// </summary>
	public long Size { get; }

	///
	public DateTime LastWriteTimeUtc { get; }

	///
	public DateTime CreationTimeUtc { get; }

	///
	public FileAttributes Attributes { get; }

	/// <summary>
	/// It is a directory. Or a NTFS link to a directory (see <see cref="IsNtfsLink"/>).
	/// </summary>
	public bool IsDirectory { get { return (Attributes & FileAttributes.Directory) != 0; } }

	/// <summary>
	/// Descendant level.
	/// 0 if direct child of the directory (<i>directoryPath</i>), 1 if child of child, and so on.
	/// </summary>
	public int Level {
		get => _level;
		internal set { _level = (short)value; }
	}
	short _level;

	/// <summary>
	/// It is a NTFS link, such as symbolic link or mount point. Don't confuse with shell links (shortcuts).
	/// </summary>
	public bool IsNtfsLink => Attributes.Has(FileAttributes.ReparsePoint) && 0 != (ReparseTag & 0x20000000);

	/// <summary>
	/// <ms>WIN32_FIND_DATA</ms><c>.dwReserved0</c>.
	/// </summary>
	public uint ReparseTag { get; }

	/// <summary>
	/// Returns <see cref="FullPath"/>.
	/// </summary>
	public override string ToString() => FullPath;

	//This could be more dangerous than useful.
	///// <summary>
	///// Returns <c>FullPath</c>.
	///// </summary>
	//public static implicit operator string(FEFile f) { return f?.FullPath; }
}

/// <summary>
/// What to do if the destination directory contains a file or directory with the same name as the source file or directory when copying, moving or renaming.
/// </summary>
/// <remarks>
/// Used with <see cref="filesystem.copy"/>, <see cref="filesystem.move"/> and similar functions.
/// When renaming or moving, if the destination is the same as the source, these options are ignored and the destination is simply renamed. For example when renaming <c>"file.txt"</c> to <c>"FILE.TXT"</c>.
/// </remarks>
public enum FIfExists {
	/// <summary>Throw exception. Default.</summary>
	Fail,

	/// <summary>Delete destination.</summary>
	Delete,

	/// <summary>Rename (backup) destination.</summary>
	RenameExisting,

	/// <summary>
	/// If destination directory exists, merge the source directory into it, replacing existing files.
	/// If destination file exists, deletes it.
	/// If destination directory exists and source is file, fails.
	/// </summary>
	MergeDirectory,

	/// <summary>Copy/move with a different name.</summary>
	RenameNew,

#if not_implemented
	/// <summary>Display a dialog asking the user what to do.</summary>
	Ask,
#endif
}

/// <summary>
/// Used with <see cref="filesystem.more.getFinalPath"/>
/// </summary>
public enum FPFormat {
	/// <summary>
	/// With long-path prefix (<c>"\\?\"</c> or <c>"\\?\UNC\"</c>) if path length > <see cref="pathname.maxDirectoryPathLength"/>. This is default.
	/// </summary>
	PrefixIfLong,

	/// <summary>
	/// Always with long-path prefix (<c>"\\?\"</c> or <c>"\\?\UNC\"</c>).
	/// </summary>
	PrefixAlways,

	/// <summary>
	/// Without long-path prefix, even if the path is very long.
	/// </summary>
	PrefixNever,

	/// <summary>
	/// With volume GUID (API <ms>GetFinalPathNameByHandle</ms> flag <c>VOLUME_NAME_GUID</c>).
	/// If it fails (eg network path), gets path with prefix, like <c>PrefixAlways</c>.
	/// </summary>
	VolumeGuid
}

/// <summary>
/// See <see cref="filesystem.more.comparePaths"/>.
/// </summary>
public enum CPResult {
	/// <summary>
	/// The paths are unrelated.
	/// Example: <c>pathA: @"C:\Dir1\File1.txt"</c>, <c>pathB: @"C:\Dir2\File1.txt"</c>.
	/// </summary>
	None,

	/// <summary>
	/// Both paths are of the same file or directory.
	/// Example: <c>pathA: @"C:\Dir1\File1.txt"</c>, <c>pathB: @"C:\Dir2\..\Dir1\File1.txt"</c>.
	/// </summary>
	Same,

	/// <summary>
	/// <i>pathA</i> is of a directory that contains file or directory specified by <i>pathB</i>.
	/// Example: <c>pathA: @"C:\Dir1"</c>, <c>pathB: @"C:\Dir1\Dir2\File1.txt"</c>.
	/// </summary>
	AContainsB,

	/// <summary>
	/// <i>pathB</i> is of a directory that contains file or directory specified by <i>pathA</i>.
	/// Example: <c>pathA: @"C:\Dir1\Dir2\File1.txt"</c>, <c>pathB: @"C:\Dir1"</c>.
	/// </summary>
	BContainsA,

	/// <summary>
	/// Failed. Probably one (or both) of specified files does not exist.
	/// The function supports <see cref="lastError"/>.
	/// </summary>
	Failed,
}

/// <summary>
/// See <see cref="filesystem.more.getFileId"/>.
/// </summary>
public record struct FileId(int VolumeSerialNumber, long FileIndex);

/// <summary>
/// See <see cref="filesystem.more.createSymbolicLink"/>
/// </summary>
public enum CSLink {
	/// <summary>Symbolic link to file.</summary>
	File,

	/// <summary>Symbolic link to directory.</summary>
	Directory,

	/// <summary>
	/// Junction to directory.
	/// 
	/// Usually junctions work like symbolic links, but there are differences when creating them:
	/// <br/>• Don't need admin privileges to create.
	/// <br/>• Target must be full path. Fails if relative path.
	/// <br/>• Target must be on this computer. Fails if on a network computer.
	/// <br/>• Target must be directory. Fails if file.
	///
	/// Some programs interpret junctions differently. For example git adds the target directory.
	/// </summary>
	Junction,

	/// <summary>
	/// Junction to local directory or symbolic link to network directory.
	/// </summary>
	JunctionOrSymlink,
}

================================================
FILE: Au/Files, data/filesystem.cs
================================================

//#define TEST_FINDFIRSTFILEEX

using Microsoft.Win32;

namespace Au;

/// <summary>
/// File and directory functions. Copy, move, delete, find, get properties, enumerate, create directory, load/save, etc.
/// </summary>
/// <remarks>
/// Also you can use .NET file system classes, such as <see cref="File"/> and <see cref="Directory"/> in <c>System.IO</c> namespace. In the past they were too limited and unsafe to use, for example no long paths, too many exceptions, difficult to recursively enumerate directories containing protected items. Later improved, but this class still has something they don't, for example environment variables in path, safe load/save. This class does not have low-level functions to open/read/write files.
/// 
/// Most functions support only full path. Most of them throw <see cref="ArgumentException"/> if passed a filename or relative path, ie in "current directory". Using current directory is unsafe.
/// Most functions support extended-length paths (longer than 259). Such local paths should have <c>@"\\?\"</c> prefix, like <c>@"\\?\C:\..."</c>. Such network path should be like <c>@"\\?\UNC\server\share\..."</c>. See <see cref="pathname.prefixLongPath"/>, <see cref="pathname.prefixLongPathIfNeed"/>. Many functions support long paths even without prefix.
/// 
/// Disk drives like <c>@"C:\"</c> or <c>"C:"</c> are directories too.
/// </remarks>
public static partial class filesystem {
	#region exists, attributes, properties
	
	/// <summary>
	/// Contains the write/create times, size and attributes of a file or directory.
	/// The equality method and operators compare only <see cref="time"/>, <see cref="size"/> and attributes <c>Directory</c> and <c>ReparsePoint</c>; not <see cref="timeCreated"/>.
	/// </summary>
	/// <param name="time">The last write time UTC as FILETIME.</param>
	/// <param name="size">0 if directory.</param>
	/// <param name="attr"></param>
	/// <param name="timeCreated">The creation time UTC as FILETIME.</param>
	internal record struct Prop_(long time, long size, FileAttributes attr, long timeCreated) {
		public bool Equals(Prop_ p) => p.time == time && p.size == size && (p.attr & (FileAttributes.Directory | FileAttributes.ReparsePoint)) == (attr & (FileAttributes.Directory | FileAttributes.ReparsePoint));
		
		public override int GetHashCode() => time.GetHashCode();
		
		public DateTime TimeAsDateTime => DateTime.FromFileTimeUtc(time);
	}
	
	/// <summary>
	/// Gets the last write time, size and attributes of a file or directory.
	/// </summary>
	/// <param name="path">Full path. The function just asserts full path and calls <see cref="pathname.prefixLongPathIfNeed"/>.</param>
	/// <param name="prop"></param>
	/// <returns><c>false</c> if does not exist or access denied. No exceptions.</returns>
	internal static unsafe bool GetProp_(string path, out Prop_ prop) {
		Debug.Assert(pathname.isFullPath(path));
		prop = default;
		path = pathname.prefixLongPathIfNeed(path);
		if (!Api.GetFileAttributesEx(path, 0, out var d)) {
			if (!_GetAttributesOnError(path, FAFlags.DontThrow, out _, out _, &d)) return false;
		}
		prop = new(d.ftLastWriteTime, d.Size, d.dwFileAttributes, d.ftCreationTime);
		return true;
	}
	
	/// <summary>
	/// Gets the last write time of a file or directory.
	/// </summary>
	/// <param name="path">Full path. The function just asserts full path and calls <see cref="pathname.prefixLongPathIfNeed"/>.</param>
	/// <param name="time">Time UTC as <c>FILETIME</c>.</param>
	/// <returns><c>false</c> if does not exist or access denied. No exceptions.</returns>
	internal static bool GetTime_(string path, out long time) {
		bool ok = GetProp_(path, out var p);
		time = p.time;
		return ok;
	}
	
	/// <summary>
	/// Gets file or directory attributes, size and times.
	/// </summary>
	/// <returns><c>false</c> if the file/directory does not exist.</returns>
	/// <param name="path">Full path. Supports <c>@"\.."</c> etc. If flag <c>UseRawPath</c> not used, supports environment variables (see <see cref="pathname.expand"/>).</param>
	/// <param name="properties">Receives properties.</param>
	/// <param name="flags"></param>
	/// <exception cref="ArgumentException">Not full path (when not used flag <c>UseRawPath</c>).</exception>
	/// <exception cref="AuException">The file/directory exists but failed to get its properties. Not thrown if used flag <c>DontThrow</c>.</exception>
	/// <remarks>
	/// Calls API <ms>GetFileAttributesEx</ms>. Supports <see cref="lastError"/> (useful with flag <c>DontThrow</c>).
	/// For NTFS links, gets properties of the link, not of its target.
	/// You can also get most of these properties with <see cref="enumerate"/>.
	/// </remarks>
	public static unsafe bool getProperties(string path, out FileProperties properties, FAFlags flags = 0) {
		properties = new();
		if (0 == (flags & FAFlags.UseRawPath)) path = pathname.NormalizeMinimally_(path); //the API supports .. etc
		if (!Api.GetFileAttributesEx(path, 0, out var d)) {
			if (!_GetAttributesOnError(path, flags, out _, out _, &d)) return false;
		}
		properties.Attributes = d.dwFileAttributes;
		properties.Size = d.Size;
		properties.LastWriteTimeUtc = DateTime.FromFileTimeUtc(d.ftLastWriteTime);
		properties.CreationTimeUtc = DateTime.FromFileTimeUtc(d.ftCreationTime);
		properties.LastAccessTimeUtc = DateTime.FromFileTimeUtc(d.ftLastAccessTime);
		if (d.dwFileAttributes.Has(FileAttributes.ReparsePoint)) properties.IsNtfsLink = 0 != IsNtfsLink_(path);
		return true;
	}
	
	/// <summary>
	/// Gets file or directory attributes.
	/// </summary>
	/// <returns><c>false</c> if the file/directory does not exist.</returns>
	/// <param name="path">Full path. Supports <c>@"\.."</c> etc. If flag <c>UseRawPath</c> not used, supports environment variables (see <see cref="pathname.expand"/>).</param>
	/// <param name="attributes">Receives attributes, or 0 if failed.</param>
	/// <param name="flags"></param>
	/// <exception cref="ArgumentException">Not full path (when not used flag <c>UseRawPath</c>).</exception>
	/// <exception cref="AuException">Failed. Not thrown if used flag <c>DontThrow</c>.</exception>
	/// <remarks>
	/// Calls API <ms>GetFileAttributes</ms>. Supports <see cref="lastError"/> (useful with flag <c>DontThrow</c>).
	/// For NTFS links, gets attributes of the link, not of its target.
	/// </remarks>
	public static unsafe bool getAttributes(string path, out FileAttributes attributes, FAFlags flags = 0) {
		if (0 == (flags & FAFlags.UseRawPath)) path = pathname.NormalizeMinimally_(path); //the API supports .. etc
		var a = Api.GetFileAttributes(path);
		if (a == (FileAttributes)(-1)) return _GetAttributesOnError(path, flags, out attributes, out _);
		attributes = a;
		return true;
	}
	
	static unsafe bool _GetAttributesOnError(string path, FAFlags flags, out FileAttributes attr, out bool ntfsLink, Api.WIN32_FILE_ATTRIBUTE_DATA* p = null) {
		attr = 0; ntfsLink = false;
		var ec = lastError.code;
		switch (ec) {
		case Api.ERROR_FILE_NOT_FOUND or Api.ERROR_PATH_NOT_FOUND or Api.ERROR_NOT_READY: //note: no ERROR_BAD_NETPATH. Let's print, it can help to debug caller code.
			return false;
		case Api.ERROR_SHARING_VIOLATION: //eg c:\pagefile.sys. GetFileAttributes fails, but FindFirstFile succeeds.
		case Api.ERROR_ACCESS_DENIED: //probably in a protected directory. Then FindFirstFile fails, but try anyway. Or a file marked for deletion.
			var d = new Api.WIN32_FIND_DATA();
			var hfind = Api.FindFirstFile(path, out d);
			if (hfind != -1) {
				Api.FindClose(hfind);
				attr = d.dwFileAttributes;
				if (p != null) {
					p->dwFileAttributes = d.dwFileAttributes;
					p->nFileSizeHigh = d.nFileSizeHigh;
					p->nFileSizeLow = d.nFileSizeLow;
					p->ftCreationTime = d.ftCreationTime;
					p->ftLastAccessTime = d.ftLastAccessTime;
					p->ftLastWriteTime = d.ftLastWriteTime;
				}
				ntfsLink = 0 != d.IsNtfsLink;
				return true;
			}
			lastError.code = ec;
			attr = (FileAttributes)(-1);
			break;
		default:
			Debug_.Print(lastError.messageFor(ec));
			break;
		}
		if (0 != (flags & FAFlags.DontThrow)) return false;
		throw new AuException(ec, $"*get file attributes: '{path}'");
	}
	
	/// <summary>
	/// Gets attributes.
	/// Returns <c>false</c> if INVALID_FILE_ATTRIBUTES or if relative path. No exceptions.
	/// </summary>
	static unsafe bool _GetAttributes(string path, out FileAttributes attr, out bool ntfsLink, bool useRawPath) {
		if (!useRawPath) path = pathname.NormalizeMinimally_(path, throwIfNotFullPath: false);
		//note: NormalizeMinimally_ does not remove \ at the end. The API succeeds if "C:\x\dir\" but fails if "C:\x\file\" (it's good).
		
		attr = Api.GetFileAttributes(path);
		if (attr != (FileAttributes)(-1)) ntfsLink = attr.Has(FileAttributes.ReparsePoint) && 0 != IsNtfsLink_(path);
		else if (!_GetAttributesOnError(path, FAFlags.DontThrow, out attr, out ntfsLink)) return false;
		
		if (!useRawPath && !pathname.isFullPath(path)) { lastError.code = Api.ERROR_FILE_NOT_FOUND; return false; }
		return true;
	}
	
	/// <summary>
	/// Sets file or directory attributes.
	/// </summary>
	/// <returns><c>false</c> if the file/directory does not exist.</returns>
	/// <param name="path">Full path. Supports <c>@"\.."</c> etc. If flag <c>UseRawPath</c> not used, supports environment variables (see <see cref="pathname.expand"/>).</param>
	/// <param name="attributes">Attributes to set, add or remove.</param>
	/// <param name="add"><c>null</c> (default) - set; <c>true</c> - add; <c>false</c> - remove.</param>
	/// <param name="flags"></param>
	/// <exception cref="ArgumentException">Not full path (when not used flag <c>UseRawPath</c>).</exception>
	/// <exception cref="AuException">Failed. Not thrown if used flag <c>DontThrow</c>.</exception>
	/// <remarks>
	/// Calls API <ms>SetFileAttributes</ms>.
	/// For NTFS links, sets attributes of the link, not of its target.
	/// </remarks>
	public static unsafe bool setAttributes(string path, FileAttributes attributes, bool? add = null, FAFlags flags = 0) {
		if (0 == (flags & FAFlags.UseRawPath)) path = pathname.NormalizeMinimally_(path); //the API supports .. etc
		var a = attributes;
		if (add != null) {
			var v = Api.GetFileAttributes(path);
			if (add.Value) a = v | attributes; else a = v & ~attributes;
			if (a == attributes) return true;
		}
		if (Api.SetFileAttributes(path, a)) return true;
		if (0 != (flags & FAFlags.DontThrow)) return false;
		throw new AuException(0, $"*set file attributes: '{path}'");
	}
	
	/// <summary>
	/// Calls API <c>FindFirstFile</c> to determine whether <i>path</i> is a NTFS link, such as symbolic link or mount point.
	/// </summary>
	/// <param name="path">Raw path (does not normalize).</param>
	/// <returns>-1 failed, 0 no, 1 symlink, 2 mount, 3 other.</returns>
	internal static int IsNtfsLink_(string path) {
		var hfind = Api.FindFirstFile(path, out var fd);
		if (hfind == -1) return -1;
		int R = fd.IsNtfsLink;
		Api.FindClose(hfind);
		return R;
	}
	
	/// <summary>
	/// Gets file or directory attributes as <see cref="FAttr"/> that tells whether it exists, is directory, readonly, hidden, system, NTFS link. See examples.
	/// </summary>
	/// <param name="path">Full path. Supports <c>@"\.."</c> etc. If <i>useRawPath</i> is <c>false</c> (default), supports environment variables (see <see cref="pathname.expand"/>). Can be <c>null</c>.</param>
	/// <param name="useRawPath">Pass <i>path</i> to the API as it is, without any normalizing and full-path checking.</param>
	/// <remarks>
	/// Supports <see cref="lastError"/>. If you need exception when fails, instead call <see cref="getAttributes"/>.
	/// Always use full path. If not full path: if <i>useRawPath</i> is <c>false</c> (default), can't find the file; if <i>useRawPath</i> is <c>true</c>, searches in "current directory".
	/// For NTFS links gets attributes of the link, not of the target; does not care whether its target exists.
	/// </remarks>
	/// <example>
	/// <code><![CDATA[
	/// var path = @"C:\Test\test.txt";
	/// if (filesystem.exists(path)) print.it("exists");
	/// if (filesystem.exists(path).File) print.it("exists as file");
	/// if (filesystem.exists(path).Directory) print.it("exists as directory");
	/// if (filesystem.exists(path) is FAttr { File: true, IsReadonly: false }) print.it("exists as file and isn't readonly");
	/// switch (filesystem.exists(path)) {
	/// case 0: print.it("doesn't exist"); break;
	/// case 1: print.it("file"); break;
	/// case 2: print.it("directory"); break;
	/// }
	/// ]]></code>
	/// </example>
	public static FAttr exists(string path, bool useRawPath = false) {
		if (_GetAttributes(path, out var a, out bool ntfsLink, useRawPath)) return new(a, true, ntfsLink);
		return new(0, (a == (FileAttributes)(-1)) ? null : false, false);
	}
	
	/// <summary>
	/// Gets file system entry type - file, directory, NTFS link, whether it exists and is accessible.
	/// Returns <c>NotFound</c> (0) if does not exist. Returns <c>AccessDenied</c> (&lt; 0) if exists but this process cannot access it and get attributes.
	/// Calls API <ms>GetFileAttributes</ms>.
	/// </summary>
	/// <param name="path">Full path. Supports <c>@"\.."</c> etc. If <i>useRawPath</i> is <c>false</c> (default), supports environment variables (see <see cref="pathname.expand"/>). Can be <c>null</c>.</param>
	/// <param name="useRawPath">Pass path to the API as it is, without any normalizing and full-path checking.</param>
	/// <remarks>
	/// Supports <see cref="lastError"/>. If you need exception when fails, instead call <see cref="getAttributes"/>.
	/// Always use full path. If path is not full: if <i>useRawPath</i> is <c>false</c> (default) returns <c>NotFound</c>; if <i>useRawPath</i> is <c>true</c>, searches in "current directory".
	/// </remarks>
	internal static unsafe FileIs_ ExistsAs_(string path, bool useRawPath = false) {
		if (!_GetAttributes(path, out var a, out bool ntfsLink, useRawPath)) {
			return (a == (FileAttributes)(-1)) ? FileIs_.AccessDenied : FileIs_.NotFound;
		}
		var R = a.Has(FileAttributes.Directory) ? FileIs_.Directory : FileIs_.File;
		if (ntfsLink) R |= (FileIs_)4;
		return R;
	}
	
	#endregion
	
	#region enumerate, search
	
	/// <summary>
	/// Finds file or directory and returns full path.
	/// </summary>
	/// <returns><c>null</c> if not found.</returns>
	/// <remarks>
	/// If the <i>path</i> argument is full path, calls <see cref="exists"/> and returns normalized path if exists, <c>null</c> if not.
	/// Else searches in these places:
	/// 1. <i>dirs</i>, if used.
	/// 2. <see cref="folders.ThisApp"/>.
	/// 3. Calls API <ms>SearchPath</ms>, which searches in the process directory, Windows system directories, current directory, <c>PATH</c> environment variable. The search order depends on API <ms>SetSearchPathMode</ms> or registry settings.
	/// 4. If <i>path</i> ends with <c>".exe"</c>, tries to get path from registry "App Paths" keys.
	/// </remarks>
	/// <param name="path">Full or relative path or just filename with extension. Supports network paths too.</param>
	/// <param name="dirs">0 or more directories where to search.</param>
	public static unsafe string searchPath(string path, params string[] dirs) {
		if (path.NE()) return null;
		
		if (pathname.isFullPathExpand(path, out string s, strict: false)) {
			if (exists(s)) return pathname.Normalize_(s, noExpandEV: true);
			return null;
		}
		
		if (dirs != null) {
			foreach (var d in dirs) {
				if (!pathname.isFullPathExpand(d, out s)) continue;
				s = pathname.combine(s, path);
				if (exists(s)) return pathname.Normalize_(s, noExpandEV: true);
			}
		}
		
		s = folders.ThisApp + path;
		if (exists(s)) return pathname.Normalize_(s, noExpandEV: true);
		
		if ((s = Api.SearchPath(null, path)) != null) return s;
		
		if (path.Ends(".exe", true) && path.FindAny(@"\/") < 0) {
			try {
				s = Registry.GetValue(@"HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\App Paths\" + path, "", null) as string
					?? Registry.GetValue(@"HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\App Paths\" + path, "", null) as string;
				if (s != null) {
					s = _PreparePath(s.Trim('"'));
					if (exists(s, true)) return s;
				}
			}
			catch (Exception ex) { Debug_.Print(ex); }
		}
		
		//maybe PATH env var changed since this or parent process started
		//rejected. LA updates at startup an on WM_SETTINGCHANGE, and that's enough.
		//if (more.UpdatePathEnvVar_())
		//	if ((s = Api.SearchPath(null, path)) != null) return s;
		
		return null;
	}
	//TODO2: add overload with flags to ignore current directory etc.
	
	/// <summary>
	/// Gets names and other info of files and subdirectories in the specified directory.
	/// </summary>
	/// <returns>An enumerable collection of <see cref="FEFile"/> objects.</returns>
	/// <param name="directoryPath">Full path of the directory.</param>
	/// <param name="flags"></param>
	/// <param name="fileFilter">
	/// Callback function that is called for each file (but not subdirectory). Let it return <c>true</c> to include the file in results.
	/// Example: <c>f => f.Name.Ends(".png", true)</c>.
	/// </param>
	/// <param name="dirFilter">
	/// Callback function that is called for each subdirectory. Let it return flags: 1 - include the directory in results; 2 - include its children in results.
	/// The return value overrides flags <see cref="FEFlags.OnlyFiles"/> and <see cref="FEFlags.AllDescendants"/>.
	/// Example: <c>d => d.Name.Eqi("Debug") ? 0 : 3</c>.
	/// </param>
	/// <param name="errorHandler">
	/// Callback function that is called when fails to get children of a subdirectory, when using flag <see cref="FEFlags.AllDescendants"/>.
	/// Receives the subdirectory path. Can call <see cref="lastError.code"/> and throw an exception. If does not throw, the enumeration continues as if the directory is empty.
	/// If <i>errorHandler</i> not used, then <see cref="enumerate"/> throws exception. See also: flag <see cref="FEFlags.IgnoreInaccessible"/>.
	/// </param>
	/// <exception cref="ArgumentException"><i>directoryPath</i> is invalid path or not full path.</exception>
	/// <exception cref="DirectoryNotFoundException"><i>directoryPath</i> directory does not exist.</exception>
	/// <exception cref="AuException">Failed to get children of <i>directoryPath</i> or of a subdirectory.</exception>
	/// <remarks>
	/// Uses API <ms>FindFirstFile</ms>.
	/// 
	/// By default gets only direct children. Use flag <see cref="FEFlags.AllDescendants"/> to get all descendants.
	/// 
	/// The paths that this function gets are normalized, ie may not start with exact <i>directoryPath</i> string. Expanded environment variables (see <see cref="pathname.expand"/>), <c>".."</c>, DOS path etc. Paths longer than <see cref="pathname.maxDirectoryPathLength"/> have <c>@"\\?\"</c> prefix (see <see cref="pathname.prefixLongPathIfNeed"/>).
	/// 
	/// For NTFS links (symbolic links, mount points) gets link info, not target info.
	/// 
	/// These errors are ignored:
	/// 1. Missing target directory of a NTFS link.
	/// 2. If used flag <see cref="FEFlags.IgnoreInaccessible"/> - access denied.
	/// 
	/// When an error is ignored, the function works as if that [sub]directory is empty; does not throw exception and does not call <i>errorHandler</i>.
	/// 
	/// Enumeration of a subdirectory starts immediately after the subdirectory itself is retrieved.
	/// </remarks>
	public static IEnumerable<FEFile> enumerate(string directoryPath, FEFlags flags = 0,
		Func<FEFile, bool> fileFilter = null,
		Func<FEFile, int> dirFilter = null,
		Action<string> errorHandler = null
		) {
		//tested 2021-04-30: much faster than Directory.EnumerateX in .NET 5. Faster JIT, and then > 2 times faster.
		//tested 2022-01-31: ~20% slower than Directory.EnumerateX in .NET 6. Not tested JIT. Never mind.
		//tested 2025-06-20: ~1% slower than Directory.EnumerateX in .NET 9.
		//	It seems .NET uses undocumented API NtQueryDirectoryFile.
		//rejected: in this func use .NET FileSystemEnumerable.
		//	Good: faster; familiar types.
		//	Bad: something we need is missing or difficult to return or need a workaround. Eg easily detect NTFS links, get relative path, prevent recursion to NTFS link target.
		
		//TODO2: stuck at ~340000 files when recursively enumerating C:\ProgramData\Microsoft\Windows\Containers\Layers.
		//	Even can't end the task process normally (access denied error).
		//	Actually it just becomes very slow, and maybe would complete if I waited long enough. 
		//	Directory.EnumerateFileSystemEntries stuck at ~61000 files.
		//	The TreeSize app at first it seems stuck too, but after long time completes and reports 752000 files.
		
		string path = directoryPath;
		if (0 == (flags & FEFlags.UseRawPath)) path = _PreparePath(path);
		path = path.RemoveSuffix('\\');
		
		var d = new Api.WIN32_FIND_DATA();
		IntPtr hfind = default;
		var stack = new Stack<_EDStackEntry>();
		bool isFirst = true;
		FileAttributes attr = 0;
		int basePathLength = path.Length;
		//var redir = new FileSystemRedirection();
		
		try {
			//if (0 != (flags & FEFlags.DisableRedirection)) redir.Disable();
			
			for (; ; ) {
				if (isFirst) {
					isFirst = false;
					var path2 = ((path.Length <= pathname.maxDirectoryPathLength - 2) ? path : pathname.prefixLongPath(path)) + @"\*";
#if TEST_FINDFIRSTFILEEX
					hfind = Api.FindFirstFileEx(path2, Api.FINDEX_INFO_LEVELS.FindExInfoBasic, out d, 0, default, 0);
					//speed: FindFirstFileEx 0-2 % slower. FindExInfoBasic makes 0-2% faster. FIND_FIRST_EX_LARGE_FETCH makes 1-50% slower.
#else
					hfind = Api.FindFirstFile(path2, out d);
#endif
					if (hfind == -1) {
						hfind = default;
						var ec = lastError.code;
						//print.it(ec, lastError.messageFor(ec), path);
						bool itsOK = false;
						switch (ec) {
						case Api.ERROR_FILE_NOT_FOUND:
						case Api.ERROR_NO_MORE_FILES:
						case Api.ERROR_NOT_READY:
							//rare, because most directories have "." and "..".
							//FindFirstFileEx sets ERROR_NO_MORE_FILES for some.
							//FindFirstFile could set ERROR_FILE_NOT_FOUND (documented), but was never in my tests.
							//ERROR_NOT_READY when trying to access an ejected CD/DVD drive etc.
							itsOK = true;
							break;
						case Api.ERROR_ACCESS_DENIED:
							itsOK = 0 != (flags & FEFlags.IgnoreInaccessible);
							break;
						case Api.ERROR_PATH_NOT_FOUND: //the directory not found, or NTFS link target directory is missing
						case Api.ERROR_DIRECTORY: //it is file, not directory. Error text is "The directory name is invalid".
						case Api.ERROR_BAD_NETPATH: //eg \\COMPUTER\MissingFolder
							if (stack.Count == 0 && !exists(path, true).Directory)
								throw new DirectoryNotFoundException($"Directory not found: '{path}'. {lastError.messageFor(ec)}");
							//itsOK = (attr & Api.FILE_ATTRIBUTE_REPARSE_POINT) != 0;
							itsOK = true; //or maybe the subdirectory was deleted after we retrieved it
							break;
						case Api.ERROR_INVALID_NAME: //eg contains invalid characters
						case Api.ERROR_BAD_NET_NAME: //eg \\COMPUTER
							if (stack.Count == 0)
								throw new ArgumentException(lastError.messageFor(ec));
							itsOK = true;
							break;
						}
						if (!itsOK) {
							if (errorHandler == null || stack.Count == 0) throw new AuException(ec, $"*enumerate directory '{path}'");
							Api.SetLastError(ec); //the above code possibly changed it, although currently it doesn't
							errorHandler(path);
						}
					}
				} else {
					if (!Api.FindNextFile(hfind, out d)) {
						Debug.Assert(lastError.code == Api.ERROR_NO_MORE_FILES);
						Api.FindClose(hfind);
						hfind = default;
					}
				}
				
				if (hfind == default) {
					if (stack.Count == 0) break;
					var t = stack.Pop();
					hfind = t.hfind; path = t.path;
					continue;
				}
				
				var name = d.Name;
				if (name == null) continue; //".", ".."
				attr = d.dwFileAttributes;
				bool isDir = (attr & FileAttributes.Directory) != 0;
				
				if ((flags & FEFlags.SkipHidden) != 0 && (attr & FileAttributes.Hidden) != 0) continue;
				const FileAttributes hidSys = FileAttributes.Hidden | FileAttributes.System;
				if ((attr & hidSys) == hidSys) {
					if ((flags & FEFlags.SkipHiddenSystem) != 0) continue;
					//skip Recycle Bin etc. It is useless, prevents copying drives, etc.
					if (isDir && path.Ends(':')) {
						if (name.Eqi("$Recycle.Bin")) continue;
						if (name.Eqi("System Volume Information")) continue;
						if (name.Eqi("Recovery")) continue;
					}
				}
				
				var fullPath = path + @"\" + name;
				if (0 != (flags & FEFlags.NeedRelativePaths)) name = fullPath[basePathLength..];
				
				//prepend @"\\?\" etc if need. Don't change fullPath length, because then would be difficult to get relative path.
				var fp2 = pathname.prefixLongPathIfNeed(fullPath);
				
				var r = new FEFile(name, fp2, d, stack.Count); //never mind, don't need for dirs if no dirFilter and is flag OnlyFiles
				
				if (isDir) {
					int inc = dirFilter != null ? dirFilter(r) : (flags.Has(FEFlags.OnlyFiles) ? 0 : 1) | (flags.Has(FEFlags.AllDescendants) ? 2 : 0);
					if (0 != (1 & inc)) yield return r;
					if (0 == (2 & inc)) continue;
					if (!flags.Has(FEFlags.RecurseNtfsLinks) && 0 != d.IsNtfsLink) continue;
					
					stack.Push(new _EDStackEntry() { hfind = hfind, path = path });
					hfind = default; path = fullPath;
					isFirst = true;
				} else {
					if (fileFilter == null || fileFilter(r)) yield return r;
				}
			}
		}
		finally {
			if (hfind != default) Api.FindClose(hfind);
			while (stack.Count > 0) Api.FindClose(stack.Pop().hfind);
			
			//redir.Revert();
		}
	}
	
	struct _EDStackEntry { internal IntPtr hfind; internal string path; }
	
	/// <summary>
	/// Gets names and other info of matching files in the specified directory.
	/// </summary>
	/// <param name="directoryPath">Full path of the directory.</param>
	/// <param name="pattern">
	/// File name pattern. Format: [wildcard expression](xref:wildcard_expression). Used only for files, not for subdirectories. Can be <c>null</c>.
	/// Examples:
	/// <br/>• <c>"*.png"</c> (only png files),
	/// <br/>• <c>"**m *.png||*.bmp"</c> (only png and bmp files),
	/// <br/>• <c>"**nm *.png||*.bmp"</c> (all files except png and bmp),
	/// <br/>• <c>@"**r \.html?$"</c> (regular expression that matches <c>.htm</c> and <c>.html</c> files).
	/// </param>
	/// <param name="flags">Flags. The function also adds flag <c>OnlyFiles</c>.</param>
	/// <exception cref="ArgumentException">
	/// <i>directoryPath</i> is invalid path or not full path.
	/// Invalid <i>pattern</i> (<c>"**options "</c> or regular expression).
	/// </exception>
	/// <exception cref="DirectoryNotFoundException"><i>directoryPath</i> directory does not exist.</exception>
	/// <exception cref="AuException">Failed to get children of <i>directoryPath</i> or of a subdirectory.</exception>
	/// <inheritdoc cref="enumerate(string, FEFlags, Func{FEFile, bool}, Func{FEFile, int}, Action{string})"/>
	public static IEnumerable<FEFile> enumFiles(string directoryPath, string pattern = null, FEFlags flags = 0) {
		flags |= FEFlags.OnlyFiles;
		if (pattern == null) return enumerate(directoryPath, flags);
		wildex w = pattern;
		return enumerate(directoryPath, flags, f => w.Match(f.Name));
	}
	
	/// <summary>
	/// Gets names and other info of matching subdirectories in the specified directory.
	/// </summary>
	/// <param name="directoryPath">Full path of the directory.</param>
	/// <param name="pattern">
	/// Directory name pattern. Format: [wildcard expression](xref:wildcard_expression). Can be <c>null</c>.
	/// </param>
	/// <param name="flags"></param>
	/// <exception cref="ArgumentException">
	/// <i>directoryPath</i> is invalid path or not full path.
	/// Invalid <i>pattern</i> (<c>"**options "</c> or regular expression).
	/// </exception>
	/// <exception cref="DirectoryNotFoundException"><i>directoryPath</i> directory does not exist.</exception>
	/// <exception cref="AuException">Failed to get children of <i>directoryPath</i> or of a subdirectory.</exception>
	/// <inheritdoc cref="enumerate(string, FEFlags, Func{FEFile, bool}, Func{FEFile, int}, Action{string})"/>
	public static IEnumerable<FEFile> enumDirectories(string directoryPath, string pattern = null, FEFlags flags = 0) {
		if (pattern == null) return filesystem.enumerate(directoryPath, flags, _ => false);
		wildex w = pattern;
		int enumChildren = flags.Has(FEFlags.AllDescendants) ? 2 : 0;
		return filesystem.enumerate(directoryPath, flags, _ => false, d => (w.Match(d.Name) ? 1 : 0) | enumChildren);
	}
	
	#endregion
	
	#region move, copy, rename, delete
	
	enum _FileOp { Rename, Move, Copy, }
	
	static unsafe void _FileOperation(_FileOp op, bool into, string path1, string path2, FIfExists ifExists,
		FCFlags copyFlags = 0, Func<FEFile, bool> copyFileFilter = null, Func<FEFile, int> copyDirFilter = null
		) {
		string opName = (op == _FileOp.Rename) ? "rename" : ((op == _FileOp.Move) ? "move" : "copy");
		path1 = _PreparePath(path1);
		var type1 = ExistsAs_(path1, true);
		if (type1 <= 0) throw new FileNotFoundException($"Failed to {opName}. File not found: '{path1}'");
		
		if (op == _FileOp.Rename) {
			op = _FileOp.Move;
			if (pathname.isInvalidName(path2)) throw new ArgumentException($"Invalid filename: '{path2}'");
			path2 = pathname.Combine_(_RemoveFilename(path1), path2);
		} else {
			string path2Parent;
			if (into) {
				path2Parent = _PreparePath(path2);
				path2 = pathname.Combine_(path2Parent, _GetFilename(path1));
			} else {
				path2 = _PreparePath(path2);
				path2Parent = _RemoveFilename(path2, true);
			}
			if (path2Parent != null) {
				try { _CreateDirectory(path2Parent, pathIsPrepared: true); }
				catch (Exception ex) { throw new AuException($"*create directory: '{path2Parent}'", ex); }
			}
		}
		
		bool ok = false, copy = op == _FileOp.Copy, deleteSource = false, mergeDirectory = false;
		var del = new _SafeDeleteExistingDirectory();
		try {
			if (ifExists == FIfExists.MergeDirectory && type1 != FileIs_.Directory) ifExists = FIfExists.Fail;
			
			if (ifExists == FIfExists.Fail) {
				//API will fail if exists. We don't use API flags 'replace existing'.
			} else {
				//Delete, RenameExisting, MergeDirectory
				//bool deleted = false;
				var existsAs = ExistsAs_(path2, true);
				bool existsAsDir = existsAs is FileIs_.Directory or FileIs_.NtfsLinkDirectory;
				switch (existsAs) {
				case FileIs_.NotFound:
					//deleted = true;
					break;
				case FileIs_.AccessDenied:
					break;
				default:
					if (more.isSameFile(path1, path2, useSymlink: true)) {
						//eg renaming "file.txt" to "FILE.txt"
						Debug_.Print("same file");
						//deleted = true;
						//copy will fail, move will succeed
					} else if (ifExists == FIfExists.RenameNew) {
						path2 = pathname.makeUnique(path2, existsAsDir);
					} else if (ifExists == FIfExists.MergeDirectory && existsAsDir) {
						if (type1 is FileIs_.Directory or FileIs_.NtfsLinkDirectory) {
							//deleted = true;
							mergeDirectory = true;
							if (!copy) { copy = true; deleteSource = true; }
						} // else API will fail. We refuse to replace a directory with a file.
					} else if (ifExists == FIfExists.RenameExisting || existsAs == FileIs_.Directory) {
						//deleted = 
						del.Rename(path2, ifExists == FIfExists.RenameExisting);
						//Rename to a temp name. Finally delete if ok (if !RenameExisting), undo if failed.
						//It also solves this problem: if we delete the directory now, need to ensure that it does not delete the source directory, which is quite difficult.
					} else {
						//deleted = 0 ==
						_DeleteL(path2, existsAs == FileIs_.NtfsLinkDirectory);
					}
					break;
				}
				//if(!deleted) throw new AuException(Api.ERROR_FILE_EXISTS, $"*{opName}"); //don't need, later API will fail
			}
			
			if (!copy) {
				//note: don't use MOVEFILE_COPY_ALLOWED, because then moving directory to another drive fails with ERROR_ACCESS_DENIED and we don't know that the reason is different drive
				if (ok = Api.MoveFileEx(path1, path2, 0)) return;
				if (lastError.code == Api.ERROR_NOT_SAME_DEVICE) {
					copy = true;
					deleteSource = true;
				}
			}
			
			if (copy) {
				if (type1 == FileIs_.Directory) {
					try {
						_CopyDirectory(path1, path2, mergeDirectory, copyFlags, copyFileFilter, copyDirFilter);
						ok = true;
					}
					catch (Exception ex) when (op != _FileOp.Copy) {
						throw new AuException($"*{opName} '{path1}' to '{path2}'", ex);
					}
				} else {
					if (type1 == FileIs_.NtfsLinkDirectory)
						ok = Api.CreateDirectoryEx(path1, path2, default);
					else
						ok = Api.CopyFileEx(path1, path2, Api.COPY_FILE_FAIL_IF_EXISTS | Api.COPY_FILE_COPY_SYMLINK);
				}
			}
			
			if (!ok) throw new AuException(0, $"*{opName} '{path1}' to '{path2}'");
			
			if (deleteSource) {
				try {
					_Delete(path1);
				}
				catch (Exception ex) {
					if (!path1.Ends(':')) //moving drive contents. Deleted contents but cannot delete drive.
						print.warning($"Failed to delete '{path1}' after copying it to another drive. {ex.Message}");
					//throw new AuException("*move", ex); //don't. MoveFileEx also succeeds even if fails to delete source.
				}
			}
		}
		finally {
			//dialog.show();
			del.Finally(ok);
		}
	}
	
	//note: if merge, the destination directory must exist
	static unsafe void _CopyDirectory(string path1, string path2, bool merge, FCFlags copyFlags,
		Func<FEFile, bool> fileFilter, Func<FEFile, int> dirFilter
		) {
		//FUTURE: add progressInterface parameter. Create a default interface implementation class that supports progress dialog and/or progress in taskbar button. Or instead create a ShellCopy function.
		//FUTURE: maybe add errorHandler parameter. Call it here when fails to copy, and also pass to Enumerate which calls it when fails to enum.
		
		//use intermediate array, and get it before creating path2 directory. It requires more memory, but is safer. Without it, eg bad things happen when copying a directory into itself.
		var edFlags = FEFlags.AllDescendants | FEFlags.NeedRelativePaths | FEFlags.UseRawPath | (FEFlags)copyFlags;
		var a = enumerate(path1, edFlags, fileFilter, dirFilter).ToArray();
		
		if (copyFlags.Has(FCFlags.NoEmptyDirectories)) {
			for (int i = a.Length; --i >= 0;) {
				var f = a[i];
				if (!f.IsDirectory) continue;
				if (i < a.Length - 1 && a[i + 1] is FEFile ff) {
					if (ff.Name.Starts(f.Name) && ff.Name.Eq(f.Name.Length, '\\')) continue;
				}
				a[i] = null;
			}
		}
		
		bool ok = false;
		string s1 = null, s2 = null;
		if (!merge) {
			if (!path1.Ends(@":\")) ok = Api.CreateDirectoryEx(path1, path2, default);
			if (!ok) ok = Api.CreateDirectory(path2, default);
			if (!ok) goto ge;
		}
		
		string prevParentDir = null;
		foreach (var f in a) {
			if (f == null) continue;
			s1 = f.FullPath; s2 = pathname.prefixLongPathIfNeed(path2 + f.Name);
			//print.it(s2);
			
			//create intermediate dirs if need, eg if dirFilter returned 2 (don't include the dir but include its children)
			//TODO3: CreateDirectoryEx
			if (f.Level > 0 && (fileFilter != null || dirFilter != null)) {
				int ifn = _FindFilename(s2) - 1;
				if (prevParentDir == null || !s2.AsSpan(0, ifn).Eq(prevParentDir)) { //optimize to avoid this code for each file
					prevParentDir = s2[..ifn];
					_CreateDirectory(prevParentDir, pathIsPrepared: true);
				}
			}
			
			if (f.IsDirectory) {
				if (merge) switch (exists(s2, true)) {
					case 2: continue; //never mind: check NTFS link mismatch
					case 1: _DeleteL(s2, false); break;
					}
				
				ok = Api.CreateDirectoryEx(s1, s2, default);
				if (!ok && !f.IsNtfsLink) ok = Api.CreateDirectory(s2, default);
			} else {
				if (merge && getAttributes(s2, out var attr, FAFlags.DontThrow | FAFlags.UseRawPath)) {
					const FileAttributes badAttr = FileAttributes.ReadOnly | FileAttributes.Hidden;
					if (0 != (attr & FileAttributes.Directory)) _Delete(s2);
					else if (0 != (attr & badAttr)) Api.SetFileAttributes(s2, attr & ~badAttr);
				}
				
				uint fl = Api.COPY_FILE_COPY_SYMLINK; if (!merge) fl |= Api.COPY_FILE_FAIL_IF_EXISTS;
				ok = Api.CopyFileEx(s1, s2, fl);
			}
			if (!ok) {
				if (f.IsNtfsLink) {
					//To create or copy NTFS links, need SeCreateSymbolicLinkPrivilege privilege.
					//Admins have it, else this process cannot get it.
					//Debug_.Print($"failed to copy NTFS link '{s1}'. It's OK, skipped it. Error: {lastError.messageFor()}");
					continue;
				}
				if (0 != (copyFlags & FCFlags.IgnoreInaccessible)) {
					if (lastError.code == Api.ERROR_ACCESS_DENIED) continue;
				}
				goto ge;
			}
		}
		return;
		ge:
		string se = $"*copy directory '{path1}' to '{path2}'";
		if (s1 != null) se += $" ('{s1}' to '{s2}')";
		throw new AuException(0, se);
		//never mind: wrong API error code if path1 and path2 is the same directory.
	}
	
	struct _SafeDeleteExistingDirectory {
		string _oldPath, _tempPath;
		bool _dontDelete;
		
		/// <summary>
		/// note: path must be normalized.
		/// </summary>
		internal bool Rename(string path, bool dontDelete = false) {
			if (path.Length > pathname.maxDirectoryPathLength - 10) path = pathname.prefixLongPath(path);
			string tempPath = null;
			int iFN = _FindFilename(path);
			string s1 = path[..iFN] + "old", s2 = " " + path[iFN..];
			for (int i = 1; ; i++) {
				tempPath = s1 + i + s2;
				if (!exists(tempPath, true)) break;
			}
			if (!Api.MoveFileEx(path, tempPath, 0)) return false;
			_oldPath = path; _tempPath = tempPath; _dontDelete = dontDelete;
			return true;
		}
		
		internal bool Finally(bool succeeded) {
			if (_tempPath == null) return true;
			if (!succeeded) {
				if (!Api.MoveFileEx(_tempPath, _oldPath, 0)) return false;
			} else if (!_dontDelete) {
				try { _Delete(_tempPath); } catch { return false; }
			}
			_oldPath = _tempPath = null;
			return true;
		}
	}
	
	/// <summary>
	/// Renames file or directory.
	/// </summary>
	/// <param name="path">Full path.</param>
	/// <param name="newName">New name without path. Example: <c>"name.txt"</c>.</param>
	/// <param name="ifExists"></param>
	/// <exception cref="ArgumentException">
	/// - <i>path</i> is not full path (see <see cref="pathname.isFullPath"/>).
	/// - <i>newName</i> is invalid filename.
	/// </exception>
	/// <exception cref="FileNotFoundException"><i>path</i> not found.</exception>
	/// <exception cref="AuException">Failed.</exception>
	/// <remarks>
	/// Uses API <ms>MoveFileEx</ms>.
	/// </remarks>
	public static void rename(string path, string newName, FIfExists ifExists = FIfExists.Fail) {
		_FileOperation(_FileOp.Rename, false, path, newName, ifExists);
	}
	
	/// <summary>
	/// Moves (changes path of) file or directory.
	/// </summary>
	/// <param name="path">Full path.</param>
	/// <param name="newPath">
	/// New full path.
	/// <para>NOTE: It is not the new parent directory. See <see cref="moveTo"/>.</para>
	/// </param>
	/// <param name="ifExists"></param>
	/// <exception cref="ArgumentException"><i>path</i> or <i>newPath</i> is not full path (see <see cref="pathname.isFullPath"/>).</exception>
	/// <exception cref="FileNotFoundException"><i>path</i> not found.</exception>
	/// <exception cref="AuException">Failed.</exception>
	/// <remarks>
	/// In most cases uses API <ms>MoveFileEx</ms>. It's fast, because don't need to copy files.
	/// In these cases copies/deletes: destination is on another drive; need to merge directories.
	/// When need to copy, does not copy security properties; sets default.
	/// Creates the destination directory if does not exist (see <see cref="createDirectory"/>).
	/// If <i>path</i> and <i>newPath</i> share the same parent directory, just renames the file.
	/// </remarks>
	public static void move(string path, string newPath, FIfExists ifExists = FIfExists.Fail) {
		_FileOperation(_FileOp.Move, false, path, newPath, ifExists);
	}
	
	/// <summary>
	/// Moves file or directory into another directory.
	/// </summary>
	/// <param name="path">Full path.</param>
	/// <param name="newDirectory">Full path of the new parent directory.</param>
	/// <param name="ifExists"></param>
	/// <exception cref="ArgumentException">
	/// - <i>path</i> or <i>newDirectory</i> is not full path (see <see cref="pathname.isFullPath"/>).
	/// - <i>path</i> is drive. To move drive content, use <see cref="move"/>.
	/// </exception>
	/// <exception cref="FileNotFoundException"><i>path</i> not found.</exception>
	/// <exception cref="AuException">Failed.</exception>
	/// <remarks>
	/// In most cases uses API <ms>MoveFileEx</ms>. It's fast, because don't need to copy files.
	/// In these cases copies/deletes: destination is on another drive; need to merge directories.
	/// When need to copy, does not copy security properties; sets default.
	/// Creates the destination directory if does not exist (see <see cref="createDirectory"/>).
	/// </remarks>
	public static void moveTo(string path, string newDirectory, FIfExists ifExists = FIfExists.Fail) {
		_FileOperation(_FileOp.Move, true, path, newDirectory, ifExists);
	}
	
	/// <summary>
	/// Copies file or directory.
	/// </summary>
	/// <param name="path">Full path.</param>
	/// <param name="newPath">
	/// Full path of the destination.
	/// <para>NOTE: It is not the new parent directory. See <see cref="copyTo"/>.</para>
	/// </param>
	/// <param name="ifExists"></param>
	/// <param name="copyFlags">Options used when copying directory.</param>
	/// <param name="fileFilter">Callback function that decides which files to copy when copying directory. See <see cref="enumerate(string, FEFlags, Func{FEFile, bool}, Func{FEFile, int}, Action{string})"/>. Note: this function uses <see cref="FEFlags.NeedRelativePaths"/>.</param>
	/// <param name="dirFilter">Callback function that decides which subdirectories to copy when copying directory. See <see cref="enumerate(string, FEFlags, Func{FEFile, bool}, Func{FEFile, int}, Action{string})"/>. Note: this function uses <see cref="FEFlags.NeedRelativePaths"/>.</param>
	/// <exception cref="ArgumentException"><i>path</i> or <i>newPath</i> is not full path (see <see cref="pathname.isFullPath"/>).</exception>
	/// <exception cref="FileNotFoundException"><i>path</i> not found.</exception>
	/// <exception cref="AuException">Failed.</exception>
	/// <remarks>
	/// Uses API <ms>CopyFileEx</ms> and <ms>CreateDirectoryEx</ms>.
	/// On Windows 7 does not copy security properties; sets default.
	/// Does not copy symbolic links (silently skips, no exception) if this process is not running as administrator.
	/// Creates the destination directory if does not exist (see <see cref="createDirectory"/>).
	/// </remarks>
	public static void copy(string path, string newPath, FIfExists ifExists = FIfExists.Fail,
		FCFlags copyFlags = 0, Func<FEFile, bool> fileFilter = null, Func<FEFile, int> dirFilter = null
		) {
		_FileOperation(_FileOp.Copy, false, path, newPath, ifExists, copyFlags, fileFilter, dirFilter);
	}
	
	/// <summary>
	/// Copies file or directory into another directory.
	/// </summary>
	/// <param name="newDirectory">Full path of the new parent directory.</param>
	/// <exception cref="ArgumentException">
	/// - <i>path</i> or <i>newDirectory</i> is not full path (see <see cref="pathname.isFullPath"/>).
	/// - <i>path</i> is drive. To copy drive content, use <see cref="copy"/>.
	/// </exception>
	/// <exception cref="FileNotFoundException"><i>path</i> not found.</exception>
	/// <exception cref="AuException">Failed.</exception>
	/// <inheritdoc cref="copy"/>
	public static void copyTo(string path, string newDirectory, FIfExists ifExists = FIfExists.Fail,
		FCFlags copyFlags = 0, Func<FEFile, bool> fileFilter = null, Func<FEFile, int> dirFilter = null
		) {
		_FileOperation(_FileOp.Copy, true, path, newDirectory, ifExists, copyFlags, fileFilter, dirFilter);
	}
	
	/// <summary>
	/// Deletes file or directory if exists.
	/// </summary>
	/// <returns><c>true</c> if deleted, <c>false</c> if failed (with flag <c>CanFail</c>), <c>null</c> if did not exist.</returns>
	/// <param name="path">Full path.</param>
	/// <param name="flags"></param>
	/// <exception cref="ArgumentException"><i>path</i> is not full path (see <see cref="pathname.isFullPath"/>).</exception>
	/// <exception cref="AuException">Failed.</exception>
	/// <remarks>
	/// Does nothing if it does not exist (no exception).
	/// If directory, also deletes all its files and subdirectories. If fails to delete some, tries to delete as many as possible.
	/// Deletes read-only files too.
	/// Does not show any message boxes etc (confirmation, error, UAC consent, progress).
	/// 
	/// Some reasons why this function can fail:
	/// 1. The file is open (in any process). Or a file in the directory is open.
	/// 2. This process does not have security permissions to access or delete the file or directory or some of its descendants.
	/// 3. The directory is (or contains) the "current directory" (in any process).
	/// </remarks>
	public static bool? delete(string path, FDFlags flags = 0)
		=> _Delete(_PreparePath(path), flags);
	
	/// <summary>
	/// Deletes multiple files or/and directories.
	/// </summary>
	/// <returns><c>true</c> if deleted all, <c>false</c> if failed to delete all or some (with flag <c>CanFail</c>), <c>null</c> if none existed.</returns>
	/// <param name="paths">string array, <c>List</c> or other collection. Full paths.</param>
	/// <param name="flags"></param>
	/// <exception cref="ArgumentException"><i>path</i> is not full path (see <see cref="pathname.isFullPath"/>).</exception>
	/// <exception cref="AggregateException">Failed to delete all or some items. The exception object contains one <see cref="AuException"/> for each failed-to-delete item.</exception>
	/// <remarks>
	/// This overload is faster when using Recycle Bin.
	/// If fails to delete some items specified in the list, deletes as many as possible.
	/// </remarks>
	public static bool? delete(IEnumerable<string> paths, FDFlags flags = 0) {
		if (flags.Has(FDFlags.RecycleBin)) {
			var a = new List<string>();
			foreach (var v in paths) {
				var s = _PreparePath(v);
				if (exists(s, true)) a.Add(s);
			}
			if (a.Count == 0) return null;
			if (_DeleteShell(null, true, a)) return true;
			Debug_.Print("_DeleteShell failed");
			//if (flags.Has(FDFlags.CanFail)) return false; //no, the shell API does not try to delete other items if fails to delete some
			//flags &= ~FDFlags.RecycleBin; //no
		}
		
		bool? R = null;
		if (flags.Has(FDFlags.CanFail)) {
			foreach (var v in paths) {
				switch (delete(v, flags)) {
				case true: R ??= true; break;
				case false: R = false; break;
				}
			}
			return R;
		} else {
			List<Exception> ae = null;
			foreach (var v in paths) {
				try { if (delete(v, flags) == true) R = true; }
				catch (AuException e1) { (ae ??= new()).Add(e1); }
			}
			return ae == null ? R : throw new AggregateException("Failed to delete.", ae);
		}
	}
	
	/// <summary>
	/// note: path must be normalized.
	/// </summary>
	static bool? _Delete(string path, FDFlags flags = 0) {
		bool canFail = flags.Has(FDFlags.CanFail);
		
		var type = ExistsAs_(path, true);
		if (type == FileIs_.NotFound) return null;
		if (type == FileIs_.AccessDenied) return canFail ? false : throw new AuException(0, $"*delete '{path}'");
		
		if (flags.Has(FDFlags.RecycleBin)) {
			if (_DeleteShell(path, true)) return true;
			if (canFail) return false;
			Debug_.Print("_DeleteShell failed");
		}
		
		int ec = 0;
		if (type == FileIs_.Directory) {
			var a = enumerate(path, FEFlags.AllDescendants | FEFlags.UseRawPath | FEFlags.IgnoreInaccessible).ToArray();
			//print.it(a);
			for (int i = a.Length; --i >= 0;) { //directories always are before their files, and will be empty when deleting in reverse
				var f = a[i];
				var at = f.Attributes;
				if (at.Has(FileAttributes.ReadOnly)) Api.SetFileAttributes(path, at & ~FileAttributes.ReadOnly);
				_DeleteL(f.FullPath, f.IsDirectory, canFail); //delete as many as possible
			}
			ec = _DeleteL(path, true, canFail);
			if (ec == 0) {
				//notify shell. Else, if it was open in Explorer, it shows an error message box.
				//Info: .NET does not notify; SHFileOperation does.
				ShellNotify_(Api.SHCNE_RMDIR, path);
				return true;
			}
			if (!canFail) {
				Debug_.Print("Using _DeleteShell.");
				if (_DeleteShell(path, false)) return true;
			}
		} else {
			ec = _DeleteL(path, type == FileIs_.NtfsLinkDirectory, canFail);
			if (ec == 0) return true;
		}
		
		if (exists(path, true)) return canFail ? false : throw new AuException(ec, $"*delete '{path}'");
		
		//info:
		//RemoveDirectory fails if not empty.
		//Directory.Delete fails if a descendant is read-only, etc.
		//Also both fail if a [now deleted] subfolder containing files was open in Explorer. Workaround: sleep/retry.
		//_DeleteShell usually does not have these problems. But it is very slow.
		//But all fail if it is current directory in any process. If in current process, _DeleteShell succeeds; it makes current directory = its parent.
		return true;
	}
	
	static int _DeleteL(string path, bool dir, bool canFail = false) {
		//print.it(dir, path);
		if (dir ? Api.RemoveDirectory(path) : Api.DeleteFile(path)) return 0;
		var ec = lastError.code;
		if (ec == Api.ERROR_ACCESS_DENIED) {
			var a = Api.GetFileAttributes(path);
			if (a != (FileAttributes)(-1) && 0 != (a & FileAttributes.ReadOnly)) {
				Api.SetFileAttributes(path, a & ~FileAttributes.ReadOnly);
				if (dir ? Api.RemoveDirectory(path) : Api.DeleteFile(path)) return 0;
				ec = lastError.code;
			}
		}
		if (!canFail) {
			for (int i = 1; (ec is Api.ERROR_SHARING_VIOLATION or Api.ERROR_LOCK_VIOLATION or Api.ERROR_DIR_NOT_EMPTY) && i <= 50; i++) {
				//ERROR_DIR_NOT_EMPTY: see comments above about Explorer. Also fails in other cases, eg when a file was opened in a web browser.
				Debug_.PrintIf(i > 1, (ec == Api.ERROR_DIR_NOT_EMPTY ? "ERROR_DIR_NOT_EMPTY when empty. Retry " : "ERROR_SHARING_VIOLATION. Retry ") + i.ToString());
				Thread.Sleep(15);
				if (dir ? Api.RemoveDirectory(path) : Api.DeleteFile(path)) return 0;
				ec = lastError.code;
			}
		}
		if (ec is Api.ERROR_FILE_NOT_FOUND or Api.ERROR_PATH_NOT_FOUND) return 0;
		Debug_.Print("_DeleteL failed. " + lastError.messageFor(ec) + "  " + path
			+ (dir ? ("   Children: " + string.Join(" | ", enumerate(path).Select(f => f.Name))) : null));
		return ec;
		
		//never mind: .NET also calls DeleteVolumeMountPoint if it is a mount point. Somehow only for recursed dirs.
		//	But I did not find in MSDN doc that need to do it before calling removedirectory. I think OS should unmount automatically.
		//	Tested on Win10, works without unmounting explicitly. Even Explorer updates its current folder without notification.
	}
	
	static bool _DeleteShell(string path, bool recycle, List<string> a = null) {
		if (a != null) path = string.Join("\0", a);
		if (wildex.hasWildcardChars(path)) throw new ArgumentException("*? not supported.");
		var x = new Api.SHFILEOPSTRUCT() { wFunc = Api.FO_DELETE };
		uint f = Api.FOF_NO_UI; //info: FOF_NO_UI includes 4 flags - noerrorui, silent, noconfirm, noconfirmmkdir
		if (recycle) f |= Api.FOF_ALLOWUNDO; else f |= Api.FOF_NO_CONNECTED_ELEMENTS;
		x.fFlags = (ushort)f;
		x.pFrom = path + "\0";
		x.hwnd = wnd.getwnd.root;
		
		//Call SHFileOperation in another thread. Because it pumps messages, including WM_PAINT and WM_TIMER, which causes random bugs. Also it's better to always call it in a STA thread.
		//	However .NET wait methods pump messages too, although less. To reproduce, try to delete eg 10 files.
		//int r = Api.SHFileOperation(x);
		//int r = Task.Run(() => Api.SHFileOperation(x)).Result_(); //slower
		//int r = Task.Factory.StartNew(() => Api.SHFileOperation(x), default, 0, StaTaskScheduler_.Default).Result_();
		//run.thread(() => { Api.SHFileOperation(x); }).Join();
		
		using var wh = run.thread(out _, out _, () => { try { Api.SHFileOperation(x); } catch (Exception ex) { Debug_.Print(ex); } });
		wait.forHandle(0, 0, wh.DangerousGetHandle());
		
		//if(r != 0 || x.fAnyOperationsAborted) return false; //do not use fAnyOperationsAborted, it can be true even if finished to delete. Also, I guess it cannot be aborted because there is no UI, because we use FOF_SILENT to avoid deactivating the active window even when the UI is not displayed.
		//if(r != 0) return false; //after all, I don't trust this too
		//in some cases API returns 0 but does not delete. For example when path too long.
		if (a == null) {
			if (exists(path, true)) return false;
		} else {
			foreach (var v in a) if (exists(v, true)) return false;
		}
		return true;
		
		//Also tested IFileOperation, but it is even slower.
		
		//Unsuccessfully tried to add flag 'if cannot use Recycle Bin, show a Yes|No message box and delete or fail'.
		//	FOF_WANTNUKEWARNING does not work as it should, eg is ignored when the file is in a flash drive.
		//	It works only without FOF_NOCONFIRMATION, but then always shows confirmation if not disabled in RB Properties.
	}
	
	/// <summary>
	/// Creates new directory if does not exists.
	/// If need, creates missing parent/ancestor directories.
	/// </summary>
	/// <returns><c>true</c> if created new directory, <c>false</c> if the directory already exists. Throws exception if failed.</returns>
	/// <param name="path">Path of new directory.</param>
	/// <param name="templateDirectory">Optional path of a template directory from which to copy some properties. See API <ms>CreateDirectoryEx</ms>.</param>
	/// <exception cref="ArgumentException">Not full path.</exception>
	/// <exception cref="AuException">Failed.</exception>
	/// <remarks>
	/// If the directory already exists, this function does nothing, and returns <c>false</c>.
	/// Else, at first it creates missing parent/ancestor directories, then creates the specified directory.
	/// To create the specified directory, calls API <ms>CreateDirectory</ms> or <ms>CreateDirectoryEx</ms> (if <i>templateDirectory</i> is not <c>null</c>).
	/// </remarks>
	public static bool createDirectory(string path, string templateDirectory = null) {
		return _CreateDirectory(path, templateDirectory: templateDirectory);
	}
	
	/// <summary>
	/// Creates parent directory for a new file, if does not exist.
	/// The same as <see cref="createDirectory"/>, just removes filename from <i>filePath</i>.
	/// </summary>
	/// <returns><c>true</c> if created new directory, <c>false</c> if the directory already exists. Throws exception if failed.</returns>
	/// <param name="filePath">Path of new file.</param>
	/// <exception cref="ArgumentException">Not full path. No filename.</exception>
	/// <exception cref="AuException">Failed.</exception>
	/// <example>
	/// <code><![CDATA[
	/// string path = @"D:\Test\new\test.txt";
	/// filesystem.createDirectoryFor(path);
	/// File.WriteAllText(path, "text"); //would fail if directory @"D:\Test\new" does not exist
	/// ]]></code>
	/// </example>
	public static bool createDirectoryFor(string filePath) {
		filePath = _PreparePath(filePath);
		var path = _RemoveFilename(filePath);
		return _CreateDirectory(path, pathIsPrepared: true);
	}
	
	/// <summary>
	/// Same as <see cref="createDirectoryFor"/>, but <i>filePath</i> must be prepared (<c>_PreparePath</c> or normalize).
	/// </summary>
	static bool _createDirectoryForPrepared(string filePath) {
		var path = _RemoveFilename(filePath);
		return _CreateDirectory(path, pathIsPrepared: true);
	}
	
	static bool _CreateDirectory(string path, bool pathIsPrepared = false, string templateDirectory = null) {
		if (exists(path, pathIsPrepared).Directory) return false;
		if (!pathIsPrepared) path = _PreparePath(path);
		if (templateDirectory != null) templateDirectory = _PreparePath(templateDirectory);
		
		var stack = new Stack<string>();
		var s = path;
		do {
			stack.Push(s);
			s = _RemoveFilename(s, true);
			if (s == null) throw new AuException($@"*create directory '{path}'. Drive not found.");
		} while (!exists(s, true).Directory);
		
		while (stack.Count > 0) {
			s = stack.Pop();
			int retry = 0;
			g1:
			bool ok = (templateDirectory == null || stack.Count > 0)
				? Api.CreateDirectory(s, default)
				: Api.CreateDirectoryEx(templateDirectory, s, default);
			if (!ok) {
				int ec = lastError.code;
				if (ec == Api.ERROR_ALREADY_EXISTS) continue;
				if (ec == Api.ERROR_ACCESS_DENIED && ++retry < 5) { Thread.Sleep(15); goto g1; } //sometimes access denied briefly, eg immediately after deleting the folder while its parent is open in Explorer. Now could not reproduce on Win10.
				throw new AuException(0, $@"*create directory '{path}'");
			}
		}
		return true;
	}
	
	internal static void ShellNotify_(uint @event, string path, string path2 = null) {
		//ThreadPool.QueueUserWorkItem(_ => Api.SHChangeNotify(@event, Api.SHCNF_PATH, path, path2)); //no, this process may end soon
		Api.SHChangeNotify(@event, Api.SHCNF_PATH, path, path2);
		//TODO3: test speed. If slow, use threadpool and the process exit event.
	}
	
	/// <summary>
	/// The same as <c>pathname.normalize(path)</c>.
	/// Expands environment variables, throws <c>ArgumentException</c> if not full path, normalizes, etc.
	/// </summary>
	/// <exception cref="ArgumentException">Not full path.</exception>
	static string _PreparePath(string path) {
		if (!pathname.isFullPathExpand(ref path)) throw new ArgumentException($"Not full path: '{path}'.");
		return pathname.Normalize_(path, noExpandEV: true);
	}
	
	/// <summary>
	/// Finds filename, eg <c>@"b.txt"</c> in <c>@"c:\a\b.txt"</c>.
	/// </summary>
	/// <exception cref="ArgumentException"><c>'\\'</c> not found or is at the end. If <i>noException</i>, instead returns -1.</exception>
	static int _FindFilename(string path, bool noException = false) {
		int R = path.FindLastAny(@"\/");
		if (R < 0 || R == path.Length - 1) {
			if (noException) return -1;
			throw new ArgumentException($"No filename in path: '{path}'.");
		}
		return R + 1;
	}
	
	/// <summary>
	/// Removes filename, eg <c>@"c:\a\b.txt"</c> -> <c>@"c:\a"</c>.
	/// </summary>
	/// <exception cref="ArgumentException"><c>'\\'</c> not found or is at the end. If <i>noException</i>, instead returns <c>null</c>.</exception>
	static string _RemoveFilename(string path, bool noException = false) {
		int i = _FindFilename(path, noException); if (i < 0) return null;
		return path[..--i];
	}
	
	/// <summary>
	/// Gets filename, eg <c>@"c:\a\b.txt"</c> -> <c>@"b.txt"</c>.
	/// </summary>
	/// <exception cref="ArgumentException"><c>'\\'</c> not found or is at the end. If <i>noException</i>, instead returns <c>null</c>.</exception>
	static string _GetFilename(string path, bool noException = false) {
		int i = _FindFilename(path, noException); if (i < 0) return null;
		return path[i..];
	}
	#endregion
	
	#region load, save
	
	/// <summary>
	/// This function can be used to safely open a file that may be temporarily locked (used by another process or thread). Waits while the file is locked.
	/// </summary>
	/// <returns>The return value of the lambda <i>f</i>.</returns>
	/// <param name="f">Lambda that calls a function that creates, opens or opens/reads/closes a file.</param>
	/// <param name="millisecondsTimeout">Wait max this number of milliseconds. Can be <see cref="Timeout.Infinite"/> (-1).</param>
	/// <exception cref="ArgumentOutOfRangeException"><i>millisecondsTimeout</i> less than -1.</exception>
	/// <exception cref="Exception">Exceptions thrown by the called function.</exception>
	/// <remarks>
	/// Calls the lambda and handles <see cref="IOException"/>. If the exception indicates that the file is locked, waits and retries in loop.
	/// </remarks>
	/// <example>
	/// <code><![CDATA[
	/// var s1 = File.ReadAllText(file); //unsafe. Exception if the file is locked.
	/// 
	/// var s2 = filesystem.waitIfLocked(() => File.ReadAllText(file)); //safe. Waits while the file is locked.
	/// 
	/// using(var f = filesystem.waitIfLocked(() => File.OpenText(file))) { //safe. Waits while the file is locked.
	/// 	var s3 = f.ReadToEnd();
	/// }
	/// 
	/// using(var f = filesystem.waitIfLocked(() => File.Create(file))) { //safe. Waits while the file is locked.
	/// 	f.WriteByte(1);
	/// }
	/// ]]></code>
	/// </example>
	public static T waitIfLocked<T>(Func<T> f, int millisecondsTimeout = 2000) {
		var w = new _LockedWaiter(millisecondsTimeout);
		g1:
		try { return f(); }
		catch (IOException e) when (w.ExceptionFilter(e)) { w.Sleep(); goto g1; }
	}
	
	/// <returns></returns>
	/// <example>
	/// <code><![CDATA[
	/// File.WriteAllText(file, "TEXT"); //unsafe. Exception if the file is locked.
	/// 
	/// filesystem.waitIfLocked(() => File.WriteAllText(file, "TEXT")); //safe. Waits while the file is locked.
	/// ]]></code>
	/// </example>
	/// <inheritdoc cref="waitIfLocked{T}(Func{T}, int)"/>
	public static void waitIfLocked(Action f, int millisecondsTimeout = 2000) {
		var w = new _LockedWaiter(millisecondsTimeout);
		g1:
		try { f(); }
		catch (IOException e) when (w.ExceptionFilter(e)) { w.Sleep(); goto g1; }
	}
	
	struct _LockedWaiter {
		int _timeout;
		long _t0;
		
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public _LockedWaiter(int millisecondsTimeout) {
			if (millisecondsTimeout < -1) throw new ArgumentOutOfRangeException();
			_timeout = millisecondsTimeout;
			_t0 = perf.ms;
		}
		
		public bool ExceptionFilter(IOException e) => ExceptionFilter(e.HResult & 0xffff);
		
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public bool ExceptionFilter(int ec) {
			//print.it((uint)ec);
			switch (ec) {
			case Api.ERROR_SHARING_VIOLATION:
			case Api.ERROR_LOCK_VIOLATION:
			case Api.ERROR_USER_MAPPED_FILE:
			case Api.ERROR_UNABLE_TO_REMOVE_REPLACED: //ReplaceFile or File.Replace
				return _timeout < 0 || perf.ms - _t0 < _timeout;
			default: return false;
			}
		}
		
		public void Sleep() => Thread.Sleep(15);
	}
	
	/// <summary>
	/// Loads text file in a safer way.
	/// Uses <see cref="File.ReadAllText"/> and <see cref="waitIfLocked{T}(Func{T}, int)"/>.
	/// </summary>
	/// <param name="file">File. Must be full path. Can contain environment variables etc, see <see cref="pathname.expand"/>.</param>
	/// <param name="encoding">Text encoding in file (if there is no BOM). Default UTF-8.</param>
	/// <param name="lockedWaitMS">If cannot open the file because it is opened by another process etc, wait max this number of milliseconds. Can be <see cref="Timeout.Infinite"/> (-1).</param>
	/// <param name="missingWaitMS">If the file initially does not exist, wait max this number of milliseconds until exists. Can be <see cref="Timeout.Infinite"/> (-1).</param>
	/// <exception cref="ArgumentException">Not full path.</exception>
	/// <exception cref="ArgumentOutOfRangeException">A timeout is less than -1.</exception>
	/// <exception cref="TimeoutException"><i>missingWaitMS</i> is > 0 and the file still does not exist after waiting.</exception>
	/// <exception cref="Exception">Exceptions of <see cref="File.ReadAllText"/>.</exception>
	public static string loadText(string file, Encoding encoding = null, int lockedWaitMS = 2000, int missingWaitMS = 0) {
		file = _LoadIntro(file, missingWaitMS);
		return waitIfLocked(() => encoding == null ? File.ReadAllText(file) : File.ReadAllText(file, encoding), lockedWaitMS);
	}
	
	static string _LoadIntro(string file, int ms) {
		file = pathname.NormalizeMinimally_(file);
		if (ms != 0) {
			double t = ms > 0 ? ms / 1000d : ms == -1 ? 0d : throw new ArgumentOutOfRangeException();
			wait.until(t, () => exists(file, useRawPath: true));
		}
		return file;
	}
	
	/// <summary>
	/// Loads file in a safer way.
	/// Uses <see cref="File.ReadAllBytes(string)"/> and <see cref="waitIfLocked{T}(Func{T}, int)"/>.
	/// </summary>
	/// <param name="file">File. Must be full path. Can contain environment variables etc, see <see cref="pathname.expand"/>.</param>
	/// <param name="lockedWaitMS">If cannot open the file because it is opened by another process etc, wait max this number of milliseconds. Can be <see cref="Timeout.Infinite"/> (-1).</param>
	/// <param name="missingWaitMS">If the file initially does not exist, wait max this number of milliseconds until exists. Can be <see cref="Timeout.Infinite"/> (-1).</param>
	/// <exception cref="ArgumentException">Not full path.</exception>
	/// <exception cref="ArgumentOutOfRangeException">A timeout is less than -1.</exception>
	/// <exception cref="TimeoutException"><i>missingWaitMS</i> is > 0 and the file still does not exist after waiting.</exception>
	/// <exception cref="Exception">Exceptions of <see cref="File.ReadAllBytes(string)"/>.</exception>
	public static byte[] loadBytes(string file, int lockedWaitMS = 2000, int missingWaitMS = 0) {
		file = _LoadIntro(file, missingWaitMS);
		return waitIfLocked(() => File.ReadAllBytes(file), lockedWaitMS);
	}
	
	/// <summary>
	/// Loads file in a safer way.
	/// Uses <see cref="File.OpenRead(string)"/> and <see cref="waitIfLocked{T}(Func{T}, int)"/>.
	/// </summary>
	/// <param name="file">File. Must be full path. Can contain environment variables etc, see <see cref="pathname.expand"/>.</param>
	/// <param name="lockedWaitMS">If cannot open the file because it is opened by another process etc, wait max this number of milliseconds. Can be <see cref="Timeout.Infinite"/> (-1).</param>
	/// <param name="missingWaitMS">If the file initially does not exist, wait max this number of milliseconds until exists. Can be <see cref="Timeout.Infinite"/> (-1).</param>
	/// <exception cref="ArgumentException">Not full path.</exception>
	/// <exception cref="ArgumentOutOfRangeException">A timeout is less than -1.</exception>
	/// <exception cref="TimeoutException"><i>missingWaitMS</i> is > 0 and the file still does not exist after waiting.</exception>
	/// <exception cref="Exception">Exceptions of <see cref="File.OpenRead(string)"/>.</exception>
	public static FileStream loadStream(string file, int lockedWaitMS = 2000, int missingWaitMS = 0) {
		file = _LoadIntro(file, missingWaitMS);
		return waitIfLocked(() => File.OpenRead(file), lockedWaitMS);
	}
	
	/// <summary>
	/// Writes any data to a file in a safe way, using a callback function.
	/// </summary>
	/// <param name="file">
	/// File. Must be full path. Can contain environment variables etc, see <see cref="pathname.expand"/>.
	/// If the file exists, this function overwrites it. If the directory does not exist, this function creates it.
	/// </param>
	/// <param name="writer">
	/// Callback function (lambda etc) that creates/writes/closes a temporary file. Its parameter is the full path of the temporary file, which normally does not exist.
	/// May be called multiple times, because this function retries if the file is locked or if the directory does not exist (if <i>writer</i> throws <see cref="DirectoryNotFoundException"/> exception).
	/// </param>
	/// <param name="backup">Create backup file named <i>file</i> + <c>"~backup"</c>.</param>
	/// <param name="tempDirectory">
	/// Directory for backup file and temporary file. If <c>null</c> or <c>""</c> - <i>file</i>'s directory. Can contain environment variables etc.
	/// Must be in the same drive as <i>file</i>. If the directory does not exist, this function creates it.</param>
	/// <param name="lockedWaitMS">If cannot open the file because it is opened by another process etc, wait max this number of milliseconds. Can be <see cref="Timeout.Infinite"/> (-1).</param>
	/// <exception cref="ArgumentException">Invalid <i>file</i> (eg not full path) or <i>lockedWaitMS</i> (less than -1).</exception>
	/// <exception cref="IOException">Failed to replace file.</exception>
	/// <exception cref="Exception">Exceptions of the function that actually writes data.</exception>
	/// <remarks>
	/// The file-write functions provided by .NET and Windows API are less reliable, because:
	/// 1. Fails if the file is temporarily open by another process or thread without sharing.
	/// 2. Can corrupt file data. If this thread, process, PC or disk dies while writing, may write only part of data or just make empty file. Usually it happens when PC is turned off incorrectly.
	/// 
	/// To protect from 1, this functions waits/retries if the file is temporarily open/locked, like <see cref="waitIfLocked"/>.
	/// To protect from 2, this function writes to a temporary file and renames/replaces the specified file using API <ms>ReplaceFile</ms>. Although not completely atomic, it ensures that file data is not corrupt; if cannot write all data, does not change existing file data.
	/// Also this function auto-creates directory if does not exist.
	/// 
	/// This function is slower. Speed can be important when saving many files.
	/// </remarks>
	public static void save(string file, Action<string> writer, bool backup = false, string tempDirectory = null, int lockedWaitMS = 2000) {
		Not_.Null(writer);
		_Save(file, writer, backup, tempDirectory, lockedWaitMS);
	}
	
	/// <summary>
	/// Writes text to a file in a safe way (like <see cref="save"/>), using <see cref="File.WriteAllText"/>.
	/// </summary>
	/// <param name="text">Text to write.</param>
	/// <param name="encoding">Text encoding in file. Default is UTF-8 without BOM.</param>
	/// <inheritdoc cref="save"/>
	public static void saveText(string file, string text, bool backup = false, string tempDirectory = null, int lockedWaitMS = 2000, Encoding encoding = null) {
		_Save(file, text ?? "", backup, tempDirectory, lockedWaitMS, encoding);
	}
	
	/// <summary>
	/// Writes data to a file in a safe way (like <see cref="save"/>), using <see cref="File.WriteAllBytes"/>.
	/// </summary>
	/// <param name="bytes">Data to write.</param>
	/// <inheritdoc cref="save"/>
	public static void saveBytes(string file, byte[] bytes, bool backup = false, string tempDirectory = null, int lockedWaitMS = 2000) {
		Not_.Null(bytes);
		_Save(file, bytes, backup, tempDirectory, lockedWaitMS);
	}
	//TODO2: ReadOnlySpan.
	
	static void _Save(string file, object data, bool backup, string tempDirectory, int lockedWaitMS, Encoding encoding = null) {
		file = _PreparePath(file);
		
		string s1 = file;
		if (!tempDirectory.NE()) {
			s1 = _PreparePath(tempDirectory);
			_CreateDirectory(s1, pathIsPrepared: true);
			s1 = pathname.combine(s1, pathname.getName(file));
		}
		
		_createDirectoryForPrepared(file);
		
		string temp = s1 + "~temp~";
		string back = s1 + "~backup~"; //always use the backup parameter, then ERROR_UNABLE_TO_REMOVE_REPLACED is far not so frequent, etc
		
		var w = new _LockedWaiter(lockedWaitMS);
		g1:
		try {
			switch (data) {
			case string text:
				//File.WriteAllText(temp, text, encoding ?? Encoding.UTF8); //no, it saves with BOM
				if (encoding != null) File.WriteAllText(temp, text, encoding);
				else File.WriteAllText(temp, text);
				break;
			case byte[] bytes:
				File.WriteAllBytes(temp, bytes);
				break;
			case Action<string> func:
				func(temp);
				break;
			}
		}
		catch (IOException e) when (w.ExceptionFilter(e)) { w.Sleep(); goto g1; }
		
		w = new _LockedWaiter(lockedWaitMS);
		g2:
		string es = null;
		if (exists(file, true).File) {
			if (!Api.ReplaceFile(file, temp, back, 6)) es = "save"; //random ERROR_UNABLE_TO_REMOVE_REPLACED; _LockedWaiter knows it
			else if (backup) ShellNotify_(Api.SHCNE_RENAMEITEM, temp, file); //without it Explorer shows 2 files with filename of temp
			else if (!Api.DeleteFile(back)) Debug_.PrintNativeError(); //maybe should wait/retry if failed, but never noticed
		} else {
			if (!Api.MoveFileEx(temp, file, Api.MOVEFILE_REPLACE_EXISTING)) es = "create";
		}
		if (es != null) {
			int ec = lastError.code;
			if (w.ExceptionFilter(ec)) { w.Sleep(); goto g2; }
			throw new IOException($"Failed to {es} file '{file}'. {lastError.messageFor(ec)}", ec);
		}
	}
	
	#endregion
}


================================================
FILE: Au/Files, data/filesystem.more.cs
================================================
namespace Au;

partial class filesystem {
	/// <summary>
	/// Miscellaneous rarely used file/directory functions.
	/// </summary>
	public static partial class more {
		/// <summary>
		/// Returns <c>true</c> if two paths are of the same existing file, regardless of path format etc.
		/// </summary>
		/// <param name="path1">Path of a file or directory. Supports environment variables (see <see cref="pathname.expand"/>) and paths relative to current directory.</param>
		/// <param name="path2">Path of a file or directory. Supports environment variables (see <see cref="pathname.expand"/>) and paths relative to current directory.</param>
		/// <param name="useSymlink">If a path is of a symbolic link, use the link. If <c>false</c>, uses its target; for example, returns <c>false</c> if the target doesn't exist.</param>
		/// <exception cref="ArgumentException">Not full path.</exception>
		/// <seealso cref="comparePaths(string, string, bool, bool)"/>
		public static bool isSameFile(string path1, string path2, bool useSymlink = false) {
			using var h1 = _OpenFileHandleForFileInfo(path1, useSymlink); if (h1.Is0) return false;
			using var h2 = _OpenFileHandleForFileInfo(path2, useSymlink); if (h2.Is0) return false;
			return Api.GetFileInformationByHandle(h1, out var k1)
				&& Api.GetFileInformationByHandle(h2, out var k2)
				&& k1.FileIndex == k2.FileIndex && k1.dwVolumeSerialNumber == k2.dwVolumeSerialNumber;
		}

		/// <summary>
		/// Gets <see cref="FileId"/> of a file or directory.
		/// </summary>
		/// <returns><c>false</c> if failed. Supports <see cref="lastError"/>.</returns>
		/// <param name="path">Path of a file or directory. Supports environment variables (see <see cref="pathname.expand"/>) and paths relative to current directory.</param>
		/// <param name="fileId"></param>
		/// <param name="ofSymlink">If <i>path</i> is of a symbolic link, get <see cref="FileId"/> of the link, not of its target.</param>
		/// <exception cref="ArgumentException">Not full path.</exception>
		/// <remarks>
		/// Calls API <ms>GetFileInformationByHandle</ms>.
		/// 
		/// A file id can be used to uniquely identify a file or directory regardless of path format.
		/// 
		/// Note: later the function can get a different id for the same path. For example after deleting the file and then creating new file at the same path (some apps save files in this way). You may want to use <see cref="getFinalPath"/> instead.
		/// </remarks>
		public static unsafe bool getFileId(string path, out FileId fileId, bool ofSymlink = false) {
			using var h = _OpenFileHandleForFileInfo(path, ofSymlink);
			if (h.Is0 || !Api.GetFileInformationByHandle(h, out var k)) { fileId = default; return false; }
			fileId = new((int)k.dwVolumeSerialNumber, k.FileIndex);
			return true;
		}

		static Handle_ _OpenFileHandleForFileInfo(string path, bool ofSymlink = false) {
			path = pathname.NormalizeMinimally_(path, throwIfNotFullPath: false);
			return Api.CreateFile(path, 0, Api.FILE_SHARE_ALL, Api.OPEN_EXISTING, ofSymlink ? Api.FILE_FLAG_BACKUP_SEMANTICS | Api.FILE_FLAG_OPEN_REPARSE_POINT : Api.FILE_FLAG_BACKUP_SEMANTICS);
			//info: need FILE_FLAG_BACKUP_SEMANTICS for directories. Ignored for files.
		}

		/// <summary>
		/// Gets full normalized path of an existing file or directory or symbolic link target.
		/// </summary>
		/// <returns><c>false</c> if failed. For example if the path does not point to an existing file or directory. Supports <see cref="lastError"/>.</returns>
		/// <param name="path">Full or relative path. Supports environment variables (see <see cref="pathname.expand"/>).</param>
		/// <param name="result">Receives full path, or <c>null</c> if failed.</param>
		/// <param name="ofSymlink">If <i>path</i> is of a symbolic link, get final path of the link, not of its target.</param>
		/// <param name="format">Result format.</param>
		/// <exception cref="ArgumentException">Not full path.</exception>
		/// <remarks>
		/// Calls API <ms>GetFinalPathNameByHandle</ms>.
		/// 
		/// Unlike <see cref="pathname.normalize"/>, this function works with existing files and directories, not any strings.
		/// </remarks>
		/// <seealso cref="shortcutFile.getTarget(string)"/>
		public static bool getFinalPath(string path, out string result, bool ofSymlink = false, FPFormat format = FPFormat.PrefixIfLong) {
			result = null;
			using var h = _OpenFileHandleForFileInfo(path, ofSymlink);
			if (h.Is0 || !Api.GetFinalPathNameByHandle(h, out var s, format == FPFormat.VolumeGuid ? 1u : 0u)) return false;
			if (format == FPFormat.PrefixNever || (format == FPFormat.PrefixIfLong && s.Length <= pathname.maxDirectoryPathLength))
				s = pathname.unprefixLongPath(s);
			result = s;
			return true;

			//never mind: does not change the root if it is like @"\\ThisComputer\share" or @"\\ThisComputer\C$" or @"\\127.0.0.1\c$" or @"\\LOCALHOST\c$" and it is the same as "C:\".
			//	Tested: getFileId returns the same value for all these.
		}

		/// <summary>
		/// Compares final paths of two existing files or directories to determine equality or relationship.
		/// </summary>
		/// <param name="pathA">Full or relative path of an existing file or directory, in any format. Supports environment variables (see <see cref="pathname.expand"/>).</param>
		/// <param name="pathB">Full or relative path of an existing file or directory, in any format. Supports environment variables (see <see cref="pathname.expand"/>).</param>
		/// <param name="ofSymlinkA">If <i>pathA</i> is of a symbolic link, get final path of the link, not of its target.</param>
		/// <param name="ofSymlinkB">If <i>pathB</i> is of a symbolic link, get final path of the link, not of its target.</param>
		/// <exception cref="ArgumentException">Not full path.</exception>
		/// <remarks>
		/// Before comparing, calls <see cref="getFinalPath"/>, therefore paths can have any format.
		/// Example: <c>@"C:\Test\"</c> and <c>@"C:\A\..\Test"</c> are equal.
		/// Example: <c>@"C:\Test\file.txt"</c> and <c>"file.txt"</c> are equal if the file is in <c>@"C:\Test</c> and <c>@"C:\Test</c> is current directory.
		/// Example: <c>@"C:\Temp\file.txt"</c> and <c>"%TEMP%\file.txt"</c> are equal if <c>TEMP</c> is an environment variable = <c>@"C:\Temp</c>.
		/// </remarks>
		/// <seealso cref="isSameFile(string, string, bool)"/>
		public static CPResult comparePaths(string pathA, string pathB, bool ofSymlinkA = false, bool ofSymlinkB = false)
			=> comparePaths(ref pathA, ref pathB, ofSymlinkA, ofSymlinkB);

		/// <summary>
		/// Compares final paths of two existing files or directories to determine equality or relationship.
		/// Also gets final paths (see <see cref="getFinalPath"/>).
		/// </summary>
		/// <inheritdoc cref="comparePaths(string, string, bool, bool)"/>
		public static CPResult comparePaths(ref string pathA, ref string pathB, bool ofSymlinkA = false, bool ofSymlinkB = false) {
			if (!getFinalPath(pathA, out pathA, ofSymlinkA, FPFormat.PrefixAlways)) return CPResult.Failed;
			if (!getFinalPath(pathB, out pathB, ofSymlinkB, FPFormat.PrefixAlways)) return CPResult.Failed;
			//print.it(pathA, pathB);
			if (pathA.Eqi(pathB)) return CPResult.Same;
			if (pathA.Length < pathB.Length && pathB.Starts(pathA, true) && (pathB[pathA.Length] == '\\' || pathA.Ends('\\'))) return CPResult.AContainsB;
			if (pathB.Length < pathA.Length && pathA.Starts(pathB, true) && (pathA[pathB.Length] == '\\' || pathB.Ends('\\'))) return CPResult.BContainsA;
			return CPResult.None;
		}

		/// <summary>
		/// Calls <see cref="enumerate"/> and returns the sum of all descendant file sizes.
		/// With default flags, it includes sizes of all descendant files, in this directory and all subdirectories except in inaccessible [sub]directories.
		/// </summary>
		/// <param name="path">Full path.</param>
		/// <param name="flags"><see cref="enumerate"/> flags.</param>
		/// <exception cref="Exception">Exceptions of <see cref="enumerate"/>. By default no exceptions if used full path and the directory exists.</exception>
		/// <remarks>
		/// This function is slow if the directory is large.
		/// Don't use this function for files (throws exception) and drives (instead use <see cref="DriveInfo"/>, it's fast and includes sizes of Recycle Bin and other protected hidden system directories).
		/// </remarks>
		public static long calculateDirectorySize(string path, FEFlags flags = FEFlags.AllDescendants | FEFlags.IgnoreInaccessible) {
			return enumerate(path, flags).Sum(f => f.Size);
		}

		/// <summary>
		/// Empties the Recycle Bin.
		/// </summary>
		/// <param name="drive">If not <c>null</c>, empties the Recycle Bin on this drive only. Example: <c>"D:"</c>.</param>
		/// <param name="progressUI">Show progress dialog if slow. Default <c>true</c>.</param>
		public static void emptyRecycleBin(string drive = null, bool progressUI = false) {
			Api.SHEmptyRecycleBin(default, drive, progressUI ? 1 : 7);
		}

		/// <summary>
		/// Creates a NTFS symbolic link or junction.
		/// </summary>
		/// <param name="linkPath">Full path of the link. Supports environment variables etc.</param>
		/// <param name="targetPath">If <i>type</i> is <c>Junction</c>, must be full path. Else can be either full path or path relative to the parent directory of the link. If starts with an environment variable, the function expands it before creating the link.</param>
		/// <param name="type"></param>
		/// <param name="elevate">If fails to create symbolic link because this process does not have admin rights, run <c>cmd.exe mklink</c> as administrator. Will show a dialog and UAC consent. Not used if type is <c>Junction</c>, because don't need admin rights to create junctions.</param>
		/// <param name="deleteOld">If <i>linkPath</i> already exists as a symbolic link or junction or empty directory, replace it.</param>
		/// <remarks>
		/// Some reasons why this function can fail:
		/// - The link already exists. Solution: use <c>deleteOld: true</c>.
		/// - This process is running not as administrator. Solution: use <i>type</i> <c>Junction</c> or <c>elevate: true</c>. To create symbolic links without admin rights, in Windows Settings enable developer mode.
		/// - The file system format is not NTFS. For example FAT32 in USB drive.
		/// 
		/// More info: <google>CreateSymbolicLink, mklink, NTFS symbolic links, junctions</google>.
		/// </remarks>
		/// <exception cref="ArgumentException">Not full path.</exception>
		/// <exception cref="AuException">Failed.</exception>
		public static void createSymbolicLink(string linkPath, string targetPath, CSLink type, bool elevate = false, bool deleteOld = false) {
			linkPath = pathname.normalize(linkPath);
			if (type is CSLink.Junction) {
				targetPath = pathname.normalize(targetPath); //junctions don't support relative path
			} else { //symlinks support relative path
				targetPath = targetPath.Replace('/', '\\'); //rumors: the link may not work if with /
			}

			string trueLinkPath = null;
			try {
				if (exists(linkPath, useRawPath: true) is var e && e) {
					bool ok = deleteOld && (e.IsNtfsLink || (e.Directory && Api.RemoveDirectory(linkPath))); //info: remove empty dir because eg Explorer does not copy links, but istead creates empty dir
					if (!ok) throw new AuException(Api.ERROR_ALREADY_EXISTS, "*to create symbolic link.");
					trueLinkPath = linkPath;
					linkPath = pathname.makeUnique(linkPath, true);
				} else createDirectoryFor(linkPath);

				if (type is CSLink.Junction or CSLink.JunctionOrSymlink) {
					var r = run.console(out string s, "cmd.exe", $"""/u /c "mklink /d /j "{linkPath}" "{targetPath}" """, encoding: Encoding.Unicode); //tested: UTF-16 on Win11 and Win7
					if (r == 0) return;
					if (!(type == CSLink.JunctionOrSymlink && s.Starts("Local volumes are required"))) throw new AuException("*to create junction. " + s.Trim());
				}

				uint fl = type == CSLink.File ? 0u : 1u; //SYMBOLIC_LINK_FLAG_DIRECTORY
				if (osVersion.minWin10_1703) fl |= 2u; //SYMBOLIC_LINK_FLAG_ALLOW_UNPRIVILEGED_CREATE
				if (Api.CreateSymbolicLink(linkPath, targetPath, fl)) return;

				int ec = lastError.code;
				if (ec == Api.ERROR_PRIVILEGE_NOT_HELD && elevate && !uacInfo.isAdmin) {
					if (dialog.showOkCancel("Create symbolic link", "Administrator rights required.\n\nTo create without admin rights, in Windows Settings enable developer mode.", icon: DIcon.Shield)) {
						using var tf = new TempFile();
						var d = type == CSLink.File ? null : "/d ";
						var cl = $"""/u /c "mklink {d}"{linkPath}" "{targetPath}" 2>"{tf}" """; //redirects stderr to temp file
						var r = run.it(folders.System + "cmd.exe", cl, RFlags.Admin | RFlags.WaitForExit, new() { WindowState = ProcessWindowStyle.Hidden });
						if (r.ProcessExitCode == 0) return;
						string s = null; try { s = loadText(tf, encoding: Encoding.Unicode).Trim(); } catch { }
						throw new AuException("*to create symbolic link. " + s);
					}
				}
				throw new AuException(ec, "*to create symbolic link.");
			}
			finally { if (trueLinkPath != null && filesystem.exists(linkPath)) move(linkPath, trueLinkPath, FIfExists.Delete); }
		}

		/// <summary>
		/// Detects whether the path is on a SSD drive.
		/// </summary>
		/// <param name="path">Any path. The function uses just the drive part. Can be just <c>"C:"</c>. Fails if a network path.</param>
		/// <returns><c>true</c> if succeeded and the path is on a SSD drive.</returns>
		/// <remarks>
		/// Unreliable. For SSD drives usually returns true. For other drives usually fails and returns false.
		/// </remarks>
		internal unsafe static bool IsOnSSD_(string path) {
			try {
				if (path.Starts(@"\\?\")) path = path[4..];
				var di = new DriveInfo(path);
				if (!(di.DriveType is DriveType.Fixed or DriveType.Removable) || !di.IsReady) return false;

				var b = stackalloc char[300];
				if (!Api.GetVolumeNameForVolumeMountPoint(di.Name, b, 300)) return false;
				path = new(Ptr_.ToRSpan(b).TrimEnd('\\'));
			}
			catch { return false; }

			using var h = Api.CreateFile(path, 0, Api.FILE_SHARE_READ | Api.FILE_SHARE_WRITE, Api.OPEN_EXISTING, Api.FILE_FLAG_BACKUP_SEMANTICS);
			if (h.Is0) return false;
			var query = new Api.STORAGE_PROPERTY_QUERY { PropertyId = 7 };
			Api.DEVICE_SEEK_PENALTY_DESCRIPTOR spt = default;
			bool r = Api.DeviceIoControl(h, Api.IOCTL_STORAGE_QUERY_PROPERTY, &query, sizeof(Api.STORAGE_PROPERTY_QUERY), &spt, sizeof(Api.DEVICE_SEEK_PENALTY_DESCRIPTOR), out _);
			return r && spt.IncursSeekPenalty == 0;
		}

		#region garbage

#if false //currently not used
		/// <summary>
		/// Gets HKEY_CLASSES_ROOT registry key of file type or protocol.
		/// The key usually contains subkeys <c>shell</c>, <c>DefaultIcon</c>, sometimes <c>shellex</c> and more.
		/// For example, for <c>".txt"</c> can return <c>"txtfile"</c>, for <c>".cs"</c> - <c>"VisualStudio.cs.14.0"</c>.
		/// Looks in <c>HKEY_CURRENT_USER\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\FileExts</c> and in <c>HKEY_CLASSES_ROOT</c>.
		/// Returns <c>null</c> if the type/protocol is not registered.
		/// Returns <c>null</c> if <i>fileType</i> does not end with <c>".extension"</c> and does not start with <c>"protocol:"</c>; also if starts with <c>"shell:"</c>.
		/// </summary>
		/// <param name="fileType">
		/// File type extension like <c>".txt"</c> or protocol like <c>"http:"</c>.
		/// Can be full path or URL; the function gets extension or protocol from the string.
		/// Can start with <c>%environment variable%</c>.
		/// </param>
		/// <param name="isFileType">Don't parse <i>fileType</i>, it does not contain full path or URL or environment variables. It is <c>".ext"</c> or <c>"protocol:"</c>.</param>
		/// <param name="isURL"><i>fileType</i> is URL or protocol like <c>"http:"</c>. Used only if <c>isFileType == true</c>, ie it is protocol.</param>
		internal static string getFileTypeOrProtocolRegistryKey(string fileType, bool isFileType, bool isURL)
		{
			if(!isFileType) fileType = GetExtensionOrProtocol(fileType, out isURL);
			else if(isURL) fileType = fileType.RemoveSuffix(1); //"proto:" -> "proto"
			if(fileType.NE()) return null;

			string userChoiceKey = @"SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\FileExts\" + fileType + @"\UserChoice";
			if(Registry.GetValue(userChoiceKey, "ProgId", null) is string s1) return s1;
			if(isURL) return fileType;
			if(Registry.ClassesRoot.GetValue(fileType, null) is string s2) return s2;
			return null;

			//note: IQueryAssociations.GetKey is very slow.
		}

		/// <summary>
		/// Gets file path extension like <c>".txt"</c> or URL protocol like <c>"http"</c>.
		/// Returns <c>null</c> if path does not end with <c>".extension"</c> and does not start with <c>"protocol:"</c>; also if starts with <c>"shell:"</c>.
		/// </summary>
		/// <param name="path">File path or URL. Can be just extension like <c>".txt"</c> or protocol like <c>"http:"</c>.</param>
		/// <param name="isProtocol">Receives <c>true</c> if URL or protocol.</param>
		internal static string GetExtensionOrProtocol(string path, out bool isProtocol)
		{
			isProtocol = false;
			if(path.NE()) return null;
			if(!PathIsExtension(path)) {
				int i = path.IndexOf(':');
				if(i > 1) {
					path = path[..i]; //protocol
					if(path == "shell") return null; //eg "shell:AppsFolder\Microsoft.WindowsCalculator_8wekyb3d8bbwe!App"
					isProtocol = true;
				} else {
					path = pathname.getExtension(path);
					if(path.NE()) return null;
				}
			}
			return path;
		}
#endif

#if false
	//this is ~300 times slower than filesystem.move. SHFileOperation too. Use only for files or other shell items in virtual folders. Unfinished.
	public static void renameFileOrDirectory(string path, string newName)
	{
		perf.first();
		if(pathname.isInvalidName(newName)) throw new ArgumentException("Invalid filename.", nameof(newName));
		path = _PreparePath(path, nameof(path));

		perf.next();
		var si = _ShellItem(path, "*rename");
		perf.next();
		var fo = new api.FileOperation() as api.IFileOperation;
		perf.next();
		try {
			fo.SetOperationFlags(4); //FOF_SILENT. Without it shows a hidden dialog that becomes the active window.
			AuException.ThrowIfFailed(fo.RenameItem(si, newName, null), "*rename");
			perf.next();
			AuException.ThrowIfFailed(fo.PerformOperations(), "*rename");
			perf.next();
		}
		finally {
			Api.ReleaseComObject(fo);
			Api.ReleaseComObject(si);
		}
		perf.nw();
	}

	static api.IShellItem _ShellItem(string path, string errMsg)
	{
		var pidl = More.PidlFromString(path, true);
		try {
			var guid = typeof(api.IShellItem).GUID;
			AuException.ThrowIfFailed(api.SHCreateItemFromIDList(pidl, guid, out var R), errMsg);
			return R;
		}
		finally { Marshal.FreeCoTaskMem(pidl); }
	}

	static class api
	{
		[DllImport("shell32.dll", PreserveSig = true)]
		internal static extern int SHCreateItemFromIDList(IntPtr pidl, in Guid riid, out IShellItem ppv);

		[ComImport, Guid("3ad05575-8857-4850-9277-11b85bdb8e09"), ClassInterface(ClassInterfaceType.None)]
		internal class FileOperation { }

		[ComImport, Guid("947aab5f-0a5c-4c13-b4d6-4bf7836fc9f8"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
		internal interface IFileOperation
		{
			[PreserveSig] int Advise(IFileOperationProgressSink pfops, out uint pdwCookie);
			[PreserveSig] int Unadvise(uint dwCookie);
			[PreserveSig] int SetOperationFlags(uint dwOperationFlags);
			[PreserveSig] int SetProgressMessage([MarshalAs(UnmanagedType.LPWStr)] string pszMessage);
			[PreserveSig] int SetProgressDialog(IOperationsProgressDialog popd);
			[PreserveSig] int SetProperties(IntPtr pproparray); //IPropertyChangeArray
			[PreserveSig] int SetOwnerWindow(wnd hwndOwner);
			[PreserveSig] int ApplyPropertiesToItem(IShellItem psiItem);
			[PreserveSig] int ApplyPropertiesToItems([MarshalAs(UnmanagedType.IUnknown)] Object punkItems);
			[PreserveSig] int RenameItem(IShellItem psiItem, [MarshalAs(UnmanagedType.LPWStr)] string pszNewName, IFileOperationProgressSink pfopsItem);
			[PreserveSig] int RenameItems([MarshalAs(UnmanagedType.IUnknown)] Object pUnkItems, [MarshalAs(UnmanagedType.LPWStr)] string pszNewName);
			[PreserveSig] int MoveItem(IShellItem psiItem, IShellItem psiDestinationFolder, [MarshalAs(UnmanagedType.LPWStr)] string pszNewName, IFileOperationProgressSink pfopsItem);
			[PreserveSig] int MoveItems([MarshalAs(UnmanagedType.IUnknown)] Object punkItems, IShellItem psiDestinationFolder);
			[PreserveSig] int CopyItem(IShellItem psiItem, IShellItem psiDestinationFolder, [MarshalAs(UnmanagedType.LPWStr)] string pszCopyName, IFileOperationProgressSink pfopsItem);
			[PreserveSig] int CopyItems([MarshalAs(UnmanagedType.IUnknown)] Object punkItems, IShellItem psiDestinationFolder);
			[PreserveSig] int DeleteItem(IShellItem psiItem, IFileOperationProgressSink pfopsItem);
			[PreserveSig] int DeleteItems([MarshalAs(UnmanagedType.IUnknown)] Object punkItems);
			[PreserveSig] int NewItem(IShellItem psiDestinationFolder, uint dwFileAttributes, [MarshalAs(UnmanagedType.LPWStr)] string pszName, [MarshalAs(UnmanagedType.LPWStr)] string pszTemplateName, IFileOperationProgressSink pfopsItem);
			[PreserveSig] int PerformOperations();
			[PreserveSig] int GetAnyOperationsAborted([MarshalAs(UnmanagedType.Bool)] out bool pfAnyOperationsAborted);
		}

		[ComImport, Guid("04b0f1a7-9490-44bc-96e1-4296a31252e2"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
		internal interface IFileOperationProgressSink
		{
			[PreserveSig] int StartOperations();
			[PreserveSig] int FinishOperations(int hrResult);
			[PreserveSig] int PreRenameItem(uint dwFlags, IShellItem psiItem, [MarshalAs(UnmanagedType.LPWStr)] string pszNewName);
			[PreserveSig] int PostRenameItem(uint dwFlags, IShellItem psiItem, [MarshalAs(UnmanagedType.LPWStr)] string pszNewName, int hrRename, IShellItem psiNewlyCreated);
			[PreserveSig] int PreMoveItem(uint dwFlags, IShellItem psiItem, IShellItem psiDestinationFolder, [MarshalAs(UnmanagedType.LPWStr)] string pszNewName);
			[PreserveSig] int PostMoveItem(uint dwFlags, IShellItem psiItem, IShellItem psiDestinationFolder, [MarshalAs(UnmanagedType.LPWStr)] string pszNewName, int hrMove, IShellItem psiNewlyCreated);
			[PreserveSig] int PreCopyItem(uint dwFlags, IShellItem psiItem, IShellItem psiDestinationFolder, [MarshalAs(UnmanagedType.LPWStr)] string pszNewName);
			[PreserveSig] int PostCopyItem(uint dwFlags, IShellItem psiItem, IShellItem psiDestinationFolder, [MarshalAs(UnmanagedType.LPWStr)] string pszNewName, int hrCopy, IShellItem psiNewlyCreated);
			[PreserveSig] int PreDeleteItem(uint dwFlags, IShellItem psiItem);
			[PreserveSig] int PostDeleteItem(uint dwFlags, IShellItem psiItem, int hrDelete, IShellItem psiNewlyCreated);
			[PreserveSig] int PreNewItem(uint dwFlags, IShellItem psiDestinationFolder, [MarshalAs(UnmanagedType.LPWStr)] string pszNewName);
			[PreserveSig] int PostNewItem(uint dwFlags, IShellItem psiDestinationFolder, [MarshalAs(UnmanagedType.LPWStr)] string pszNewName, [MarshalAs(UnmanagedType.LPWStr)] string pszTemplateName, uint dwFileAttributes, int hrNew, IShellItem psiNewItem);
			[PreserveSig] int UpdateProgress(uint iWorkTotal, uint iWorkSoFar);
			[PreserveSig] int ResetTimer();
			[PreserveSig] int PauseTimer();
			[PreserveSig] int ResumeTimer();
		}

		[ComImport, Guid("0C9FB851-E5C9-43EB-A370-F0677B13874C"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
		internal interface IOperationsProgressDialog
		{
			[PreserveSig] int StartProgressDialog(wnd hwndOwner, uint flags);
			[PreserveSig] int StopProgressDialog();
			[PreserveSig] int SetOperation(SPACTION action);
			[PreserveSig] int SetMode(uint mode);
			[PreserveSig] int UpdateProgress(ulong ullPointsCurrent, ulong ullPointsTotal, ulong ullSizeCurrent, ulong ullSizeTotal, ulong ullItemsCurrent, ulong ullItemsTotal);
			[PreserveSig] int UpdateLocations(IShellItem psiSource, IShellItem psiTarget, IShellItem psiItem);
			[PreserveSig] int ResetTimer();
			[PreserveSig] int PauseTimer();
			[PreserveSig] int ResumeTimer();
			[PreserveSig] int GetMilliseconds(out ulong pullElapsed, out ulong pullRemaining);
			[PreserveSig] int GetOperationStatus(out PDOPSTATUS popstatus);
		}

		internal enum SPACTION
		{
			SPACTION_NONE,
			SPACTION_MOVING,
			SPACTION_COPYING,
			SPACTION_RECYCLING,
			SPACTION_APPLYINGATTRIBS,
			SPACTION_DOWNLOADING,
			SPACTION_SEARCHING_INTERNET,
			SPACTION_CALCULATING,
			SPACTION_UPLOADING,
			SPACTION_SEARCHING_FILES,
			SPACTION_DELETING,
			SPACTION_RENAMING,
			SPACTION_FORMATTING,
			SPACTION_COPY_MOVING
		}

		internal enum PDOPSTATUS
		{
			PDOPS_RUNNING = 1,
			PDOPS_PAUSED,
			PDOPS_CANCELLED,
			PDOPS_STOPPED,
			PDOPS_ERRORS
		}


	}
#endif

		//rejected: unreliable. Uses registry, where many mimes are incorrect and nonconstant.
		//	Use System.Web.MimeMapping.GetMimeMapping. It uses a hardcoded list, although too small.
		///// <summary>
		///// Gets file's MIME content type, like <c>"text/html"</c> or <c>"image/png"</c>.
		///// Returns <c>false</c> if cannot detect it.
		///// </summary>
		///// <param name="file">File name or path or URL or just extension like <c>".txt"</c>. If <i>canAnalyseData</i> is <c>true</c>, must be full path of a file, and the file must exist and can be opened to read; else the function uses just <c>.extension</c>, and the file may exist or not.</param>
		///// <param name="contentType">Result.</param>
		///// <param name="canAnalyseData">If cannot detect from file extension, try to detect from file data.</param>
		///// <exception cref="ArgumentException">Not full path. Only if <i>canAnalyseData</i> is <c>true</c>.</exception>
		///// <exception cref="Exception">Exceptions of <see cref="File.ReadAllBytes"/>. Only if <i>canAnalyseData</i> is <c>true</c>.</exception>
		///// <remarks>
		///// Uses API <ms>FindMimeFromData</ms>.
		///// </remarks>
		//public static bool getMimeContentType(string file, out string contentType, bool canAnalyseData = false)
		//{
		//	if(file.Ends(".cur", true)) { contentType = "image/x-icon"; return true; } //registered without MIME or with text/plain

		//	int hr = Api.FindMimeFromData(default, file, null, 0, null, 0, out contentType, 0);
		//	if(hr != 0 && canAnalyseData) {
		//		file = pathname.normalize(file);
		//		using(var stream = File.OpenRead(file)) {
		//			var data = new byte[256];
		//			int n = stream.Read(data, 0, 256);
		//			hr = Api.FindMimeFromData(default, null, data, n, null, 0, out contentType, 0);
		//		}
		//	}
		//	return hr == 0;
		//	//note: the returned unmanaged string is freed with CoTaskMemFree, which uses HeapFree(GetProcessHeap).
		//	//	In MSDN it is documented incorrectly: "should be freed with the operator delete function".
		//	//	To discover it, call HeapSize(GetProcessHeap) before and after CoTaskMemFree. It returns -1 when called after.
		//}

		#endregion
	}
}


================================================
FILE: Au/Files, data/folders.cs
================================================
#pragma warning disable 1591 //missing XML documentation

namespace Au {
	/// <summary>
	/// Gets known/special folder paths (Desktop, Temp, etc).
	/// </summary>
	/// <remarks>
	/// Most functions return <see cref="FolderPath"/>, not <c>string</c>. It is implicitly convertible to <c>string</c>. Its operator <c>+</c> appends a filename or relative path string, with <c>\</c> separator if need. Example:
	/// 
	/// <code><![CDATA[string s = folders.Desktop + "file.txt"; //C:\Users\Name\Desktop\file.txt]]></code>
	/// 
	/// If a function cannot get folder path, the return value contains <c>null</c> string. Then the <c>+</c> operator would throw <see cref="ArgumentException"/>.
	///
	/// Some folders are known only on newer Windows versions or only on some computers. Some functions have a suffix like <c>_Win8</c> which means that the folder is unavailable on older Windows.
	/// Some known folders, although supported and registered, may be still not created.
	/// 
	/// Some folders are virtual, for example Control Panel. They don't have a file system path, but can be identified by a data structure <ms>ITEMIDLIST</ms>. Functions of the nested class <see cref="shell"/> return it as <see cref="Pidl"/> or string <c>":: ITEMIDLIST"</c> that can be used with some functions of this library (<see cref="run.it"/>, <see cref="icon.of"/>, <see cref="icon.ofPidl(Pidl, int)"/>) but not with .NET functions.
	///
	/// Most functions use Windows "Known Folders" API, such as <ms>SHGetKnownFolderPath</ms>.
	/// The list of Windows predefined known folders: <ms>KNOWNFOLDERID</ms>.
	/// Names of folders specific to current process have prefix <c>This</c>, like <c>ThisApp</c>.
	/// 
	/// Some paths depend on the bitness (32 or 64 bit) of the OS and this process.
	/// <table>
	/// <tr>
	/// <td>32-bit Windows</td>
	/// <td>
	/// <c>System</c>, <c>SystemX86</c>, <c>SystemX64</c>: <c>@"C:\WINDOWS\system32"</c>
	/// <br/><c>ProgramFiles</c>, <c>ProgramFilesX86</c>, <c>ProgramFilesX64</c>: <c>@"C:\Program Files"</c>
	/// <br/><c>ProgramFilesCommon</c>, <c>ProgramFilesCommonX86</c>, <c>ProgramFilesCommonX64</c>: <c>@"C:\Program Files\Common Files"</c>
	/// </td>
	/// </tr>
	/// <tr>
	/// <td>64-bit Windows, 64-bit process</td>
	/// <td>
	/// <c>System</c>, <c>SystemX64</c>: <c>@"C:\WINDOWS\system32"</c>
	/// <br/><c>SystemX86</c>: <c>@"C:\WINDOWS\SysWOW64"</c>
	/// <br/><c>ProgramFiles</c>, <c>ProgramFilesX64</c>: <c>@"C:\Program Files"</c>
	/// <br/><c>ProgramFilesX86</c>: <c>@"C:\Program Files (x86)"</c>
	/// <br/><c>ProgramFilesCommon</c>, <c>ProgramFilesCommonX64</c>: <c>@"C:\Program Files\Common Files"</c>
	/// <br/><c>ProgramFilesCommonX86</c>: <c>@"C:\Program Files (x86)\Common Files"</c>
	/// </td>
	/// </tr>
	/// <tr>
	/// <td>64-bit Windows, 32-bit process</td>
	/// <td>
	/// <c>System</c>: <c>@"C:\WINDOWS\system32"</c>. However the OS in most cases redirects this path to <c>@"C:\WINDOWS\SysWOW64"</c>.
	/// <br/><c>SystemX86</c>: <c>@"C:\WINDOWS\SysWOW64"</c>
	/// <br/><c>SystemX64</c>: <c>@"C:\WINDOWS\Sysnative"</c>. The OS redirects it to the true <c>@"C:\WINDOWS\system32"</c>. It is a special path, not in Explorer.
	/// <br/><c>ProgramFiles</c>, <c>ProgramFilesX86</c>: <c>@"C:\Program Files (x86)"</c>
	/// <br/><c>ProgramFilesX64</c>: <c>@"C:\Program Files"</c>
	/// <br/><c>ProgramFilesCommon</c>, <c>ProgramFilesCommonX86</c>: <c>@"C:\Program Files (x86)\Common Files"</c>
	/// <br/><c>ProgramFilesCommonX64</c>: <c>@"C:\Program Files\Common Files"</c>
	/// </td>
	/// </tr>
	/// </table>
	/// </remarks>
	public static class folders {
		#region generated by macro "Auto create special folders class from KNOWNFOLDERID"
		
		public static FolderPath AccountPictures_Win8 => _Get(0x008ca0b1, 0x55b44c56, 0xb8a84de4, 0xb299d3be);
		public static FolderPath AdminTools => _Get(0x724EF170, 0xA42D4FEF, 0x9F26B60E, 0x846FBA4F);
		public static FolderPath ApplicationShortcuts_Win8 => _Get(0xA3918781, 0xE5F24890, 0xB3D9A7E5, 0x4332328C);
		public static FolderPath CameraRoll_Win81 => _Get(0xAB5FB87B, 0x7CE24F83, 0x915D5508, 0x46C9537B);
		public static FolderPath CDBurning => _Get(0x9E52AB10, 0xF80D49DF, 0xACB84330, 0xF5687855);
		public static FolderPath CommonAdminTools => _Get(0xD0384E7D, 0xBAC34797, 0x8F14CBA2, 0x29B392B5);
		public static FolderPath CommonOEMLinks => _Get(0xC1BAE2D0, 0x10DF4334, 0xBEDD7AA2, 0x0B227A9D);
		public static FolderPath CommonPrograms => _Get(0x0139D44E, 0x6AFE49F2, 0x86903DAF, 0xCAE6FFB8);
		public static FolderPath CommonStartMenu => _Get(0xA4115719, 0xD62E491D, 0xAA7CE74B, 0x8BE3B067);
		public static FolderPath CommonStartup => _Get(0x82A5EA35, 0xD9CD47C5, 0x9629E15D, 0x2F714E6E);
		public static FolderPath CommonTemplates => _Get(0xB94237E7, 0x57AC4347, 0x9151B08C, 0x6C32D1F7);
		public static FolderPath Contacts => _Get(0x56784854, 0xC6CB462b, 0x816988E3, 0x50ACB882);
		public static FolderPath Cookies => _Get(0x2B0F765D, 0xC0E94171, 0x908E08A6, 0x11B84FF6);
		public static FolderPath Desktop => _Get(0xB4BFCC3A, 0xDB2C424C, 0xB0297FE9, 0x9A87C641);
		public static FolderPath DeviceMetadataStore => _Get(0x5CE4A5E9, 0xE4EB479D, 0xB89F130C, 0x02886155);
		public static FolderPath Documents => _Get(0xFDD39AD0, 0x238F46AF, 0xADB46C85, 0x480369C7);
		public static FolderPath DocumentsLibrary => _Get(0x7B0DB17D, 0x9CD24A93, 0x973346CC, 0x89022E7C);
		public static FolderPath Downloads => _Get(0x374DE290, 0x123F4565, 0x916439C4, 0x925E467B);
		public static FolderPath Favorites => _Get(0x1777F761, 0x68AD4D8A, 0x87BD30B7, 0x59FA33DD);
		public static FolderPath Fonts => _Get(0xFD228CB7, 0xAE114AE3, 0x864C16F3, 0x910AB8FE);
		public static FolderPath GameTasks => _Get(0x054FAE61, 0x4DD84787, 0x80B60902, 0x20C4B700);
		public static FolderPath History => _Get(0xD9DC8A3B, 0xB784432E, 0xA7815A11, 0x30A75963);
		public static FolderPath ImplicitAppShortcuts => _Get(0xBCB5256F, 0x79F64CEE, 0xB725DC34, 0xE402FD46);
		public static FolderPath InternetCache => _Get(0x352481E8, 0x33BE4251, 0xBA856007, 0xCAEDCF9D);
		public static FolderPath Libraries => _Get(0x1B3EA5DC, 0xB5874786, 0xB4EFBD1D, 0xC332AEAE);
		public static FolderPath Links => _Get(0xbfb9d5e0, 0xc6a9404c, 0xb2b2ae6d, 0xb6af4968);
		public static FolderPath LocalAppData => _Get(0xF1B32785, 0x6FBA4FCF, 0x9D557B8E, 0x7F157091);
		public static FolderPath LocalAppDataLow => _Get(0xA520A1A4, 0x17804FF6, 0xBD181673, 0x43C5AF16);
		public static FolderPath LocalizedResourcesDir => _Get(0x2A00375E, 0x224C49DE, 0xB8D1440D, 0xF7EF3DDC);
		public static FolderPath Music => _Get(0x4BD8D571, 0x6D1948D3, 0xBE974222, 0x20080E43);
		public static FolderPath MusicLibrary => _Get(0x2112AB0A, 0xC86A4FFE, 0xA3680DE9, 0x6E47012E);
		public static FolderPath NetHood => _Get(0xC5ABBF53, 0xE17F4121, 0x89008662, 0x6FC2C973);
		public static FolderPath OriginalImages => _Get(0x2C36C0AA, 0x58124b87, 0xBFD04CD0, 0xDFB19B39);
		public static FolderPath PhotoAlbums => _Get(0x69D2CF90, 0xFC334FB7, 0x9A0CEBB0, 0xF0FCB43C);
		public static FolderPath PicturesLibrary => _Get(0xA990AE9F, 0xA03B4E80, 0x94BC9912, 0xD7504104);
		public static FolderPath Pictures => _Get(0x33E28130, 0x4E1E4676, 0x835A9839, 0x5C3BC3BB);
		public static FolderPath Playlists => _Get(0xDE92C1C7, 0x837F4F69, 0xA3BB86E6, 0x31204A23);
		public static FolderPath PrintHood => _Get(0x9274BD8D, 0xCFD141C3, 0xB35EB13F, 0x55A758F4);
		public static FolderPath Profile => _Get(0x5E6C858F, 0x0E224760, 0x9AFEEA33, 0x17B67173);
		public static FolderPath ProgramData => _Get(0x62AB5D82, 0xFDC14DC3, 0xA9DD070D, 0x1D495D97);
		/// <summary>More info in class help.</summary>
		public static FolderPath ProgramFiles => new(__ProgramFiles ??= _ProgramFiles);
		static string __ProgramFiles;
		static FolderPath _ProgramFiles => _Get(0x905e63b6, 0xc1bf494e, 0xb29c65b7, 0x32d3d21a);
		//broken static FolderPath ProgramFilesX64 => _Get(0x6D809377, 0x6AF0444b, 0x8957A377, 0x3F02200E);
		/// <summary>More info in class help.</summary>
		public static FolderPath ProgramFilesX86 => new(__ProgramFilesX86 ??= _ProgramFilesX86);
		static string __ProgramFilesX86;
		static FolderPath _ProgramFilesX86 => _Get(0x7C5A40EF, 0xA0FB4BFC, 0x874AC0F2, 0xE0B9FA8E);
		/// <summary>More info in class help.</summary>
		public static FolderPath ProgramFilesCommon => _Get(0xF7F1ED05, 0x9F6D47A2, 0xAAAE29D3, 0x17C6F066);
		//broken static FolderPath ProgramFilesCommonX64 => _Get(0x6365D5A7, 0x0F0D45E5, 0x87F60DA5, 0x6B6A4F7D);
		/// <summary>More info in class help.</summary>
		public static FolderPath ProgramFilesCommonX86 => _Get(0xDE974D24, 0xD9C64D3E, 0xBF91F445, 0x5120B917);
		public static FolderPath Programs => _Get(0xA77F5D77, 0x2E2B44C3, 0xA6A2ABA6, 0x01054A51);
		public static FolderPath Public => _Get(0xDFDF76A2, 0xC82A4D63, 0x906A5644, 0xAC457385);
		public static FolderPath PublicDesktop => _Get(0xC4AA340D, 0xF20F4863, 0xAFEFF87E, 0xF2E6BA25);
		public static FolderPath PublicDocuments => _Get(0xED4824AF, 0xDCE445A8, 0x81E2FC79, 0x65083634);
		public static FolderPath PublicDownloads => _Get(0x3D644C9B, 0x1FB84f30, 0x9B45F670, 0x235F79C0);
		public static FolderPath PublicGameTasks => _Get(0xDEBF2536, 0xE1A84c59, 0xB6A24145, 0x86476AEA);
		public static FolderPath PublicLibraries => _Get(0x48DAF80B, 0xE6CF4F4E, 0xB8000E69, 0xD84EE384);
		public static FolderPath PublicMusic => _Get(0x3214FAB5, 0x97574298, 0xBB6192A9, 0xDEAA44FF);
		public static FolderPath PublicPictures => _Get(0xB6EBFB86, 0x6907413C, 0x9AF74FC2, 0xABF07CC5);
		public static FolderPath PublicRingtones => _Get(0xE555AB60, 0x153B4D17, 0x9F04A5FE, 0x99FC15EC);
		public static FolderPath PublicUserTiles_Win8 => _Get(0x0482af6c, 0x08f14c34, 0x8c90e17e, 0xc98b1e17);
		public static FolderPath PublicVideos => _Get(0x2400183A, 0x618549FB, 0xA2D84A39, 0x2A602BA3);
		public static FolderPath QuickLaunch => _Get(0x52a4f021, 0x7b7548a9, 0x9f6b4b87, 0xa210bc8f);
		public static FolderPath Recent => _Get(0xAE50C081, 0xEBD2438A, 0x86558A09, 0x2E34987A);
		public static FolderPath RecordedTV => _Get(0x1A6FDBA2, 0xF42D4358, 0xA798B74D, 0x745926C5);
		public static FolderPath ResourceDir => _Get(0x8AD10C31, 0x2ADB4296, 0xA8F7E470, 0x1232C972);
		public static FolderPath Ringtones => _Get(0xC870044B, 0xF49E4126, 0xA9C3B52A, 0x1FF411E8);
		public static FolderPath RoamingAppData => _Get(0x3EB685DB, 0x65F94CF6, 0xA03AE3EF, 0x65729F3D);
		public static FolderPath RoamedTileImages_Win8 => _Get(0xAAA8D5A5, 0xF1D64259, 0xBAA878E7, 0xEF60835E);
		public static FolderPath RoamingTiles_Win8 => _Get(0x00BCFC5A, 0xED944e48, 0x96A13F62, 0x17F21990);
		public static FolderPath SampleMusic => _Get(0xB250C668, 0xF57D4EE1, 0xA63C290E, 0xE7D1AA1F);
		public static FolderPath SamplePictures => _Get(0xC4900540, 0x23794C75, 0x844B64E6, 0xFAF8716B);
		public static FolderPath SamplePlaylists => _Get(0x15CA69B3, 0x30EE49C1, 0xACE16B5E, 0xC372AFB5);
		public static FolderPath SampleVideos => _Get(0x859EAD94, 0x2E8548AD, 0xA71A0969, 0xCB56A6CD);
		public static FolderPath SavedGames => _Get(0x4C5C32FF, 0xBB9D43b0, 0xB5B42D72, 0xE54EAAA4);
		public static FolderPath SavedPictures => _Get(0x3B193882, 0xD3AD4eab, 0x965A6982, 0x9D1FB59F);
		public static FolderPath SavedPicturesLibrary => _Get(0xE25B5812, 0xBE884bd9, 0x94B02923, 0x3477B6C3);
		public static FolderPath SavedSearches => _Get(0x7d1d3a04, 0xdebb4115, 0x95cf2f29, 0xda2920da);
		public static FolderPath Screenshots_Win8 => _Get(0xb7bede81, 0xdf944682, 0xa7d857a5, 0x2620b86f);
		public static FolderPath SearchHistory_Win81 => _Get(0x0D4C3DB6, 0x03A3462F, 0xA0E60892, 0x4C41B5D4);
		public static FolderPath SearchTemplates_Win81 => _Get(0x7E636BFE, 0xDFA94D5E, 0xB456D7B3, 0x9851D8A9);
		public static FolderPath SendTo => _Get(0x8983036C, 0x27C0404B, 0x8F08102D, 0x10DCFD74);
		public static FolderPath SidebarDefaultParts => _Get(0x7B396E54, 0x9EC54300, 0xBE0A2482, 0xEBAE1A26);
		public static FolderPath SidebarParts => _Get(0xA75D362E, 0x50FC4fb7, 0xAC2CA8BE, 0xAA314493);
		public static FolderPath SkyDrive_Win81 => _Get(0xA52BBA46, 0xE9E1435f, 0xB3D928DA, 0xA648C0F6);
		public static FolderPath SkyDriveCameraRoll_Win81 => _Get(0x767E6811, 0x49CB4273, 0x87C220F3, 0x55E1085B);
		public static FolderPath SkyDriveDocuments_Win81 => _Get(0x24D89E24, 0x2F194534, 0x9DDE6A66, 0x71FBB8FE);
		public static FolderPath SkyDrivePictures_Win81 => _Get(0x339719B5, 0x8C474894, 0x94C2D8F7, 0x7ADD44A6);
		public static FolderPath StartMenu => _Get(0x625B53C3, 0xAB484EC1, 0xBA1FA1EF, 0x4146FC19);
		public static FolderPath Startup => _Get(0xB97D20BB, 0xF46A4C97, 0xBA105E36, 0x08430854);
		/// <summary>More info in class help.</summary>
		public static FolderPath System => new(__System ??= _System);
		static string __System;
		static FolderPath _System => _Get(0x1AC14E77, 0x02E74E5D, 0xB7442EB1, 0xAE5198B7);
		/// <summary>More info in class help.</summary>
		public static FolderPath SystemX86 => _Get(0xD65231B0, 0xB2F14857, 0xA4CEA8E7, 0xC6EA7D27);
		public static FolderPath Templates => _Get(0xA63293E8, 0x664E48DB, 0xA079DF75, 0x9E0509F7);
		public static FolderPath TreeProperties => _Get(0x9E3995AB, 0x1F9C4F13, 0xB82748B2, 0x4B6C7174);
		public static FolderPath UserProfiles => _Get(0x0762D272, 0xC50A4BB0, 0xA382697D, 0xCD729B80);
		public static FolderPath UserProgramFiles => _Get(0x5CD7AEE2, 0x22194A67, 0xB85D6C9C, 0xE15660CB);
		public static FolderPath UserProgramFilesCommon => _Get(0xBCBD3057, 0xCA5C4622, 0xB42DBC56, 0xDB0AE516);
		public static FolderPath Videos => _Get(0x18989B1D, 0x99B5455B, 0x841CAB7C, 0x74E4DDFC);
		public static FolderPath VideosLibrary => _Get(0x491E922F, 0x56434AF4, 0xA7EB4E7A, 0x138D8174);
		public static FolderPath Windows => new(__Windows ??= _Windows);
		static string __Windows;
		static FolderPath _Windows => _Get(0xF38BF404, 0x1D4342F2, 0x930567DE, 0x0B28FC23);
		
		/// <summary>
		/// Gets <ms>ITEMIDLIST</ms> of known/special virtual folders (eg Control Panel), as string like <c>":: 12345678..."</c> or as <see cref="Pidl"/>.
		/// </summary>
		public static class shell {
			public static FolderPath AddNewPrograms => _GetV(0xde61d971, 0x5ebc4f02, 0xa3a96c82, 0x895e5c04);
			public static FolderPath Apps_Win8 => _GetV(0x1e87508d, 0x89c242f0, 0x8a7e645a, 0x0f50ca58);
			public static FolderPath AppUpdates => _GetV(0xa305ce99, 0xf527492b, 0x8b1a7e76, 0xfa98d6e4);
			public static FolderPath ChangeRemovePrograms => _GetV(0xdf7266ac, 0x92744867, 0x8d553bd6, 0x61de872d);
			public static FolderPath Computer => _GetV(0x0AC0837C, 0xBBF8452A, 0x850D79D0, 0x8E667CA7);
			public static FolderPath Conflict => _GetV(0x4bfefb45, 0x347d4006, 0xa5beac0c, 0xb0567192);
			public static FolderPath Connections => _GetV(0x6F0CD92B, 0x2E9745D1, 0x88FFB0D1, 0x86B8DEDD);
			public static FolderPath ControlPanel => _GetV(0x82A74AEB, 0xAEB4465C, 0xA014D097, 0xEE346D63);
			public static FolderPath Games => _GetV(0xCAC52C1A, 0xB53D4edc, 0x92D76B2E, 0x8AC19434);
			public static FolderPath HomeGroup => _GetV(0x52528A6B, 0xB9E34ADD, 0xB60D588C, 0x2DBA842D);
			public static FolderPath HomeGroupCurrentUser_Win8 => _GetV(0x9B74B6A3, 0x0DFD4f11, 0x9E785F78, 0x00F2E772);
			public static FolderPath Internet => _GetV(0x4D9F7874, 0x4E0C4904, 0x967B40B0, 0xD20C3E4B);
			public static FolderPath Network => _GetV(0xD20BEEC4, 0x5CA84905, 0xAE3BBF25, 0x1EA09B53);
			public static FolderPath Printers => _GetV(0x76FC4E2D, 0xD6AD4519, 0xA66337BD, 0x56068185);
			public static FolderPath RecycleBin => _GetV(0xB7534046, 0x3ECB4C18, 0xBE4E64CD, 0x4CB7D6AC);
			public static FolderPath SEARCH_CSC => _GetV(0xee32e446, 0x31ca4aba, 0x814fa5eb, 0xd2fd6d5e);
			public static FolderPath SearchHome => _GetV(0x190337d1, 0xb8ca4121, 0xa6396d47, 0x2d16972a);
			public static FolderPath SEARCH_MAPI => _GetV(0x98ec0e18, 0x20984d44, 0x86446697, 0x9315a281);
			public static FolderPath SyncManager => _GetV(0x43668BF8, 0xC14E49B2, 0x97C97477, 0x84D784B7);
			public static FolderPath SyncResults => _GetV(0x289a9a43, 0xbe444057, 0xa41b587a, 0x76d7e7f9);
			public static FolderPath SyncSetup => _GetV(0x0F214138, 0xB1D34a90, 0xBBA927CB, 0xC0C5389A);
			public static FolderPath UsersFiles => _GetV(0xf3ce0f7c, 0x49014acc, 0x8648d5d4, 0x4b04ef8f);
			public static FolderPath UsersLibraries => _GetV(0xA302545D, 0xDEFF464b, 0xABE861C8, 0x648D939B);
			
			public static Pidl pidlAddNewPrograms => _GetVI(0xde61d971, 0x5ebc4f02, 0xa3a96c82, 0x895e5c04);
			public static Pidl pidlApps_Win8 => _GetVI(0x1e87508d, 0x89c242f0, 0x8a7e645a, 0x0f50ca58);
			public static Pidl pidlAppUpdates => _GetVI(0xa305ce99, 0xf527492b, 0x8b1a7e76, 0xfa98d6e4);
			public static Pidl pidlChangeRemovePrograms => _GetVI(0xdf7266ac, 0x92744867, 0x8d553bd6, 0x61de872d);
			public static Pidl pidlComputer => _GetVI(0x0AC0837C, 0xBBF8452A, 0x850D79D0, 0x8E667CA7);
			public static Pidl pidlConflict => _GetVI(0x4bfefb45, 0x347d4006, 0xa5beac0c, 0xb0567192);
			public static Pidl pidlConnections => _GetVI(0x6F0CD92B, 0x2E9745D1, 0x88FFB0D1, 0x86B8DEDD);
			public static Pidl pidlControlPanel => _GetVI(0x82A74AEB, 0xAEB4465C, 0xA014D097, 0xEE346D63);
			public static Pidl pidlGames => _GetVI(0xCAC52C1A, 0xB53D4edc, 0x92D76B2E, 0x8AC19434);
			public static Pidl pidlHomeGroup => _GetVI(0x52528A6B, 0xB9E34ADD, 0xB60D588C, 0x2DBA842D);
			public static Pidl pidlHomeGroupCurrentUser_Win8 => _GetVI(0x9B74B6A3, 0x0DFD4f11, 0x9E785F78, 0x00F2E772);
			public static Pidl pidlInternet => _GetVI(0x4D9F7874, 0x4E0C4904, 0x967B40B0, 0xD20C3E4B);
			public static Pidl pidlNetwork => _GetVI(0xD20BEEC4, 0x5CA84905, 0xAE3BBF25, 0x1EA09B53);
			public static Pidl pidlPrinters => _GetVI(0x76FC4E2D, 0xD6AD4519, 0xA66337BD, 0x56068185);
			public static Pidl pidlRecycleBin => _GetVI(0xB7534046, 0x3ECB4C18, 0xBE4E64CD, 0x4CB7D6AC);
			public static Pidl pidlSEARCH_CSC => _GetVI(0xee32e446, 0x31ca4aba, 0x814fa5eb, 0xd2fd6d5e);
			public static Pidl pidlSearchHome => _GetVI(0x190337d1, 0xb8ca4121, 0xa6396d47, 0x2d16972a);
			public static Pidl pidlSEARCH_MAPI => _GetVI(0x98ec0e18, 0x20984d44, 0x86446697, 0x9315a281);
			public static Pidl pidlSyncManager => _GetVI(0x43668BF8, 0xC14E49B2, 0x97C97477, 0x84D784B7);
			public static Pidl pidlSyncResults => _GetVI(0x289a9a43, 0xbe444057, 0xa41b587a, 0x76d7e7f9);
			public static Pidl pidlSyncSetup => _GetVI(0x0F214138, 0xB1D34a90, 0xBBA927CB, 0xC0C5389A);
			public static Pidl pidlUsersFiles => _GetVI(0xf3ce0f7c, 0x49014acc, 0x8648d5d4, 0x4b04ef8f);
			public static Pidl pidlUsersLibraries => _GetVI(0xA302545D, 0xDEFF464b, 0xABE861C8, 0x648D939B);
		}
		
		#endregion
		
		#region other paths
		
		/// <summary>
		/// Temp folder (temporary files) of this user account.
		/// </summary>
		public static FolderPath Temp => new(__temp ??= Path.GetTempPath().TrimEnd('\\'));
		static string __temp;
		
		/// <summary>
		/// Folder containing assemblies of this app.
		/// </summary>
		/// <remarks>
		/// Uses <see cref="AppContext.BaseDirectory"/>.
		/// </remarks>
		/// <seealso cref="process.thisExePath"/>
		public static FolderPath ThisApp => new(__thisApp ??= ThisAppBS.TrimEnd('\\'));
		static string __thisApp;
		
		/// <summary>
		/// <see cref="ThisApp"/> with appended backslash character.
		/// </summary>
		/// <remarks>
		/// Uses <see cref="AppContext.BaseDirectory"/>.
		/// </remarks>
		public static string ThisAppBS => __thisAppBS ??= AppContext.BaseDirectory; //info: AppDomain.CurrentDomain.BaseDirectory calls it
		static string __thisAppBS;
		//Can change: AppDomain.CurrentDomain.SetData("APP_CONTEXT_BASE_DIRECTORY", "C:\\");
		
		#region set auto/once
		
		/// <summary>
		/// Don't auto-create folders when accessing <see cref="ThisAppDocuments"/>, <see cref="ThisAppTemp"/>, <see cref="ThisAppDataLocal"/> or <see cref="ThisAppDataRoaming"/> in this thread.
		/// </summary>
		/// <remarks>
		/// Normally this is used temporarily, then restored (set = <c>false</c>).
		/// </remarks>
		public static bool noAutoCreate {
			get => _noAutoCreate;
			set { _noAutoCreate = value; }
		}
		[ThreadStatic] static bool _noAutoCreate;
		
		static readonly object _lock = new();
		
		static string _SetAuto(ref string propVar, string value, bool create) {
			lock (_lock) {
				if (propVar == null) {
					if (create && !_noAutoCreate) filesystem.createDirectory(value);
					propVar = value;
				}
			}
			return propVar;
		}
		
		static void _SetOnce(ref string propVar, string value, bool create, [CallerMemberName] string m_ = null) {
			lock (_lock) {
				if (propVar != null) {
#if DEBUG
					if (!Debugger.IsAttached) //debugger may get the property. Then _SetAuto sets default value.
#endif
						throw new InvalidOperationException("folders." + m_ + " is already set.");
				}
				if (create && !_noAutoCreate) filesystem.createDirectory(value);
				propVar = value;
			}
		}
		
		static string _DefThisApp(string baseDir, string portableSubdir, bool warning = false) {
			bool ee = script.role == SRole.EditorExtension;
			
			if (ScriptEditor.IsPortable) return PortableData_ + "\\" + portableSubdir + (ee ? null : @"\_script");
			
			return baseDir + (ee ? @"\LibreAutomate" : @"\LibreAutomate\_script");
		}
		
		internal static string PortableData_ => __portableData ??= GetPortableDataDir_(Editor.Path);
		static string __portableData;
		
		static internal string GetPortableDataDir_(string appPath) {
			var s = appPath + @"\data";
			//if (filesystem.exists(s, true).File) return pathname.normalize(filesystem.loadText(s), appPath);
			return s;
		}
		
		#endregion
		
		/// <summary>
		/// Gets or sets path of folder "temporary files of this application".
		/// </summary>
		/// <exception cref="InvalidOperationException">Thrown by the <c>set</c> function if this property is already set.</exception>
		/// <remarks>
		/// Default path depends on script role (<see cref="script.role"/> and portable mode (<see cref="ScriptEditor.IsPortable"/>):
		/// - <c>miniProgram</c> and <c>exeProgram</c> - <c>folders.Temp + @"LibreAutomate\_script"</c>. Or <c>folders.Temp + "Au"</c>, if exists (for backward compatibility).
		/// - <c>editorExtension</c> - <c>folders.Temp + "LibreAutomate"</c>. Cannot be changed.
		/// - Portable <c>miniProgram</c> and <c>exeProgram</c> - <c>folders.ThisApp + @"data\temp\_script"</c>. Note: <c>exeProgram</c> launched not from editor isn't portable.
		/// - Portable <c>editorExtension</c> - <c>folders.ThisApp + @"data\temp"</c>. Cannot be changed.
		/// 
		/// The <c>set</c> function does not change system settings. It just remembers a string that will be later returned by the <c>get</c> function in this process.
		/// Creates the folder if does not exist when <c>set</c> or <c>get</c> function called first time in this process, unless <see cref="noAutoCreate"/> <c>true</c>.
		/// </remarks>
		public static FolderPath ThisAppTemp {
			get => new(__thisAppTemp ?? _SetAuto(ref __thisAppTemp, _DefThisApp(Temp, "temp"), create: true));
			set => _SetOnce(ref __thisAppTemp, value, create: true);
		}
		static string __thisAppTemp;
		
		/// <summary>
		/// Gets or sets path of folder "user document files of this application".
		/// </summary>
		/// <exception cref="InvalidOperationException">Thrown by the <c>set</c> function if this property is already set.</exception>
		/// <remarks>
		/// Default path depends on script role (<see cref="script.role"/>) and portable mode (<see cref="ScriptEditor.IsPortable"/>):
		/// - <c>miniProgram</c> and <c>exeProgram</c> - <c>folders.Documents + @"LibreAutomate\_script"</c>. Or <c>folders.Documents + "Au"</c>, if exists (for backward compatibility).
		/// - <c>editorExtension</c> - <c>folders.Documents + "LibreAutomate"</c>. Cannot be changed.
		/// - Portable <c>miniProgram</c> and <c>exeProgram</c> - <c>folders.ThisApp + @"data\doc\_script"</c>. Note: <c>exeProgram</c> launched not from editor isn't portable.
		/// - Portable <c>editorExtension</c> - <c>folders.ThisApp + @"data\doc"</c>. Cannot be changed.
		/// 
		/// The <c>set</c> function does not change system settings. It just remembers a string that will be later returned by the <c>get</c> function in this process.
		/// Creates the folder if does not exist when <c>set</c> or <c>get</c> function called first time in this process, unless <see cref="noAutoCreate"/> <c>true</c>.
		/// </remarks>
		public static FolderPath ThisAppDocuments {
			get => new(__thisAppDocuments ?? _SetAuto(ref __thisAppDocuments, _DefThisApp(Documents, "doc", warning: true), create: true));
			set => _SetOnce(ref __thisAppDocuments, value, create: true);
		}
		static string __thisAppDocuments;
		
		/// <summary>
		/// Gets or sets path of folder "local (non-roaming) private files of this application of this user account".
		/// </summary>
		/// <exception cref="InvalidOperationException">Thrown by the <c>set</c> function if this property is already set.</exception>
		/// <remarks>
		/// Default path depends on script role (<see cref="script.role"/> and portable mode (<see cref="ScriptEditor.IsPortable"/>):
		/// - <c>miniProgram</c> and <c>exeProgram</c> - <c>folders.LocalAppData + @"LibreAutomate\_script"</c>. Or <c>folders.LocalAppData + "Au"</c>, if exists (for backward compatibility).
		/// - <c>editorExtension</c> - <c>folders.LocalAppData + "LibreAutomate"</c>. Cannot be changed.
		/// - Portable <c>miniProgram</c> and <c>exeProgram</c> - <c>folders.ThisApp + @"data\appLocal\_script"</c>. Note: <c>exeProgram</c> launched not from editor isn't portable.
		/// - Portable <c>editorExtension</c> - <c>folders.ThisApp + @"data\appLocal"</c>. Cannot be changed.
		/// 
		/// The <c>set</c> function does not change system settings. It just remembers a string that will be later returned by the <c>get</c> function in this process.
		/// Creates the folder if does not exist when <c>set</c> or <c>get</c> function called first time in this process, unless <see cref="noAutoCreate"/> <c>true</c>.
		/// </remarks>
		public static FolderPath ThisAppDataLocal {
			get => new(__thisAppDataLocal ?? _SetAuto(ref __thisAppDataLocal, _DefThisApp(LocalAppData, "appLocal", warning: true), create: true));
			set => _SetOnce(ref __thisAppDataLocal, value, create: true);
		}
		static string __thisAppDataLocal;
		
		/// <summary>
		/// Gets or sets path of folder "roaming private files of this application of this user account".
		/// </summary>
		/// <exception cref="InvalidOperationException">Thrown by the <c>set</c> function if this property is already set.</exception>
		/// <remarks>
		/// Default path depends on script role (<see cref="script.role"/> and portable mode (<see cref="ScriptEditor.IsPortable"/>):
		/// - <c>miniProgram</c> and <c>exeProgram</c> - <c>folders.RoamingAppData + @"LibreAutomate\_script"</c>. Or <c>folders.RoamingAppData + "Au"</c>, if exists (for backward compatibility).
		/// - <c>editorExtension</c> - <c>folders.RoamingAppData + "LibreAutomate"</c>. Cannot be changed.
		/// - Portable <c>miniProgram</c> and <c>exeProgram</c> - <c>folders.ThisApp + @"data\appRoaming\_script"</c>. Note: <c>exeProgram</c> launched not from editor isn't portable.
		/// - Portable <c>editorExtension</c> - <c>folders.ThisApp + @"data\appRoaming"</c>. Cannot be changed.
		/// 
		/// The <c>set</c> function does not change system settings. It just remembers a string that will be later returned by the <c>get</c> function in this process.
		/// Creates the folder if does not exist when <c>set</c> or <c>get</c> function called first time in this process, unless <see cref="noAutoCreate"/> <c>true</c>.
		/// </remarks>
		public static FolderPath ThisAppDataRoaming {
			get => new(__thisAppDataRoaming ?? _SetAuto(ref __thisAppDataRoaming, _DefThisApp(RoamingAppData, "appRoaming"), create: true));
			set => _SetOnce(ref __thisAppDataRoaming, value, create: true);
		}
		static string __thisAppDataRoaming;
		
		[EditorBrowsable(EditorBrowsableState.Never)] //renamed
		[Obsolete("This is an alias for ThisAppDataRoaming.")]
		public static FolderPath ThisAppData {
			get => ThisAppDataRoaming;
			set => ThisAppDataRoaming = value;
		} //info: unexpandPath ignores ThisAppX.
		
		/// <summary>
		/// Gets or sets path of folder "common (all users) private files of this application".
		/// </summary>
		/// <exception cref="InvalidOperationException">Thrown by the <c>set</c> function if this property is already set.</exception>
		/// <remarks>
		/// Default path depends on script role (<see cref="script.role"/> and portable mode (<see cref="ScriptEditor.IsPortable"/>):
		/// - <c>miniProgram</c> and <c>exeProgram</c> - <c>folders.ProgramData + @"LibreAutomate\_script"</c>. Or <c>folders.ProgramData + "Au"</c>, if exists (for backward compatibility).
		/// - <c>editorExtension</c> - <c>folders.ProgramData + "LibreAutomate"</c>. Cannot be changed.
		/// - Portable <c>miniProgram</c> and <c>exeProgram</c> - <c>folders.ThisApp + @"data\appCommon\_script"</c>. Note: <c>exeProgram</c> launched not from editor isn't portable.
		/// - Portable <c>editorExtension</c> - <c>folders.ThisApp + @"data\appCommon"</c>. Cannot be changed.
		/// 
		/// The <c>set</c> function does not change system settings. It just remembers a string that will be later returned by the <c>get</c> function in this process.
		/// This function does not auto-create the folder; usually it is created when installing the application; the script editor does not use and does not install it.
		/// Note: the <c>ProgramData</c> folder has special security permissions. Programs running not as administrator usually cannot write there, unless your installer changed folder security permissions.
		/// </remarks>
		public static FolderPath ThisAppDataCommon {
			get => new(__thisAppDataCommon ?? _SetAuto(ref __thisAppDataCommon, _DefThisApp(ProgramData, "appCommon"), create: false));
			set => _SetOnce(ref __thisAppDataCommon, value, create: false);
		}
		static string __thisAppDataCommon;
		
		/// <summary>
		/// Gets or sets path of folder "images of this application".
		/// </summary>
		/// <exception cref="InvalidOperationException">Thrown by the <c>set</c> function if this property is already set.</exception>
		/// <remarks>
		/// Default is <c>ThisAppBS + "Images"</c>.
		/// 
		/// Used by functions of these classes: <see cref="icon"/>, <see cref="popupMenu"/>, <see cref="toolbar"/>, <see cref="uiimage"/>, possibly some other.
		/// This function does not auto-create the folder; usually it is created when installing the application; the script editor does not use and does not install it.
		/// </remarks>
		public static FolderPath ThisAppImages {
			get => new(__thisAppImages ?? _SetAuto(ref __thisAppImages, ThisAppBS + "Images", create: false));
			set => _SetOnce(ref __thisAppImages, value, create: false);
		}
		static string __thisAppImages;
		
		/// <summary>
		/// Gets the root directory of this application, like <c>@"C:\"</c> or <c>@"\\server\share\"</c>.
		/// </summary>
		/// <remarks>
		/// See <see cref="Path.GetPathRoot"/>.
		/// </remarks>
		public static string ThisAppDriveBS => __thisAppDrive ??= pathname.GetRootBS_(ThisAppBS);
		static string __thisAppDrive;
		//public static FolderPath ThisAppDrive => new(__thisAppDrive ??= Path.GetPathRoot(ThisAppBS));
		
		/// <summary>
		/// Gets folder of the script editor.
		/// Available in the script editor process and in scripts launched from it. Elsewhere <c>null</c>.
		/// </summary>
		public static FolderPath Editor { get; internal set; }
		
		/// <summary>
		/// Gets folder of current workspace.
		/// Available in the script editor process and in scripts launched from it. Elsewhere <c>null</c>.
		/// </summary>
		public static FolderPath Workspace {
			get => __workspace;
			internal set { __workspace = value; WorkspaceDriveBS = pathname.GetRootBS_(value); }
		}
		static FolderPath __workspace;
		
		/// <summary>
		/// Gets the root directory of <see cref="Workspace"/>, like <c>@"C:\"</c> or <c>@"\\server\share\"</c>.
		/// </summary>
		/// <remarks>
		/// See <see cref="Path.GetPathRoot"/>.
		/// </remarks>
		public static string WorkspaceDriveBS { get; private set; }
		
		//CONSIDER:
		//public static FolderPath ThisLibrarySettings { get => field ??= ThisAppDataRoaming; set; }
		
#if !DEBUG //fbc
		/// <summary>
		/// Gets drive type (fixed, removable, network, etc) of <see cref="ThisAppDriveBS"/>.
		/// </summary>
		[EditorBrowsable(EditorBrowsableState.Never)] //more annoying than useful. Intellisense selects it when the user types "thisApp". And maybe this class isn't the best place for it. Probably users will not look for such function here or somewhere in this library; they'll use DriveInfo. In any case, this is not very useful because: 1. Detects external SSD as Fixed; 2. The removable drive (SSD or not) may be used either as portable or always with the same computer.
		public static DriveType thisAppDriveType => __driveTypeApp ??= __GetDriveType(ThisAppDriveBS);
		static DriveType? __driveTypeApp;
		
		/// <summary>
		/// Gets drive type (fixed, removable, network, etc) of <see cref="WorkspaceDriveBS"/>.
		/// </summary>
		[EditorBrowsable(EditorBrowsableState.Never)]
		public static DriveType workspaceDriveType => __GetDriveType(WorkspaceDriveBS);
		
		//note: don't use this func with any paths. It is for the above 2 funcs only.
		static DriveType __GetDriveType(string path) {
			path = pathname.unprefixLongPath(path);
			if (path.Starts(@"\\")) return DriveType.Network; //GetDriveType does not support it. DriveInfo throws exception.
			return (DriveType)Api.GetDriveType(path);
		}
#endif
		
		/// <summary>
		/// Gets folder path of the caller source code file.
		/// </summary>
		/// <param name="f_">[](xref:caller_info)</param>
		/// <seealso cref="CallerFilePathAttribute"/>
		/// <seealso cref="script.sourcePath(string)"/>
		public static FolderPath sourceCode([CallerFilePath] string f_ = null) => new(pathname.getDirectory(f_));
		
		/// <summary>
		/// Gets folder path of the main source code file of this program or of a library.
		/// </summary>
		/// <param name="asm">An assembly compiled by LibreAutomate. If <c>null</c>, uses <see cref="Assembly.GetEntryAssembly"/>.</param>
		/// <seealso cref="script.sourcePath(bool, Assembly)"/>
		public static FolderPath sourceCodeMain(Assembly asm = null) => new(pathname.getDirectory(script.sourcePath(false, asm)));
		
		/// <summary>
		/// Gets non-redirected path of the System32 folder.
		/// </summary>
		/// <remarks>
		/// If this process is 32-bit and OS is 64-bit, when it uses the <see cref="System"/> folder path (<c>@"C:\WINDOWS\system32"</c>), the OS in most cases redirects it to <c>@"C:\Windows\SysWOW64"</c>, which contains 32-bit versions of program files. Use SystemX64 when you want to avoid the redirection and access the true System32 folder which on 64-bit OS contains 64-bit program files.
		/// More info in class help.
		/// </remarks>
		/// <seealso cref="FileSystemRedirection"/>
		/// <seealso cref="osVersion.is32BitProcessAnd64BitOS"/>
		public static FolderPath SystemX64 => new(__SystemX64 ??= osVersion.is32BitProcessAnd64BitOS ? Windows + "Sysnative" : System);
		static string __SystemX64;
		
		/// <summary>More info in class help.</summary>
		public static FolderPath ProgramFilesX64 => new(__ProgramFilesX64 ??= osVersion.is32BitProcessAnd64BitOS ? envVar("ProgramW6432") : ProgramFiles);
		static string __ProgramFilesX64;
		
		/// <summary>More info in class help.</summary>
		public static FolderPath ProgramFilesCommonX64 => new(__ProgramFilesCommonX64 ??= osVersion.is32BitProcessAnd64BitOS ? envVar("CommonProgramW6432") : ProgramFilesCommon);
		static string __ProgramFilesCommonX64;
		//The normal retrieving method for these folders is broken. Fails even on 64-bit OS if process is 32-bit.
		
		/// <summary>
		/// Gets .NET runtime folder, like <c>C:\Program Files\dotnet\shared\Microsoft.NETCore.App\8.0.6</c>.
		/// </summary>
		public static FolderPath NetRuntime => new(__netRuntime ??= NetRuntimeBS.TrimEnd('\\'));
		static string __netRuntime;
		
		/// <summary>
		/// Gets .NET runtime folder with <c>'\\'</c> at the end, like <c>C:\Program Files\dotnet\shared\Microsoft.NETCore.App\8.0.6\</c>.
		/// </summary>
		public static string NetRuntimeBS => __netRuntimeBS ??= RuntimeEnvironment.GetRuntimeDirectory();
		static string __netRuntimeBS;
		
		/// <summary>
		/// Gets .NET runtime desktop folder, like <c>C:\Program Files\dotnet\shared\Microsoft.WindowsDesktop.App\8.0.6</c>.
		/// </summary>
		public static FolderPath NetRuntimeDesktop => new(__netRuntimeDesktop ??= NetRuntimeDesktopBS.TrimEnd('\\'));
		static string __netRuntimeDesktop;
		
		/// <summary>
		/// Gets .NET runtime desktop folder with <c>'\\'</c> at the end, like <c>C:\Program Files\dotnet\shared\Microsoft.WindowsDesktop.App\8.0.6\</c>.
		/// </summary>
		public static string NetRuntimeDesktopBS => __netRuntimeDesktopBS ??= _NetRuntimeDesktopBS();
		static string __netRuntimeDesktopBS;
		
		static string _NetRuntimeDesktopBS() {
			var s = typeof(Accessibility.IAccessible).Assembly.Location;
			if (s.NE()) return NetRuntimeBS; //single-file app
			s = pathname.getDirectory(s, withSeparator: true);
			Debug.Assert(s != NetRuntimeBS || s.Starts(ThisAppBS));
			return s;
			//note: cannot get NetRuntimeDesktopBS from NetRuntimeBS.
			//	Can be different version, eg Microsoft.NETCore.App\8.0.0-rc.1.23419.4 and Microsoft.WindowsDesktop.App\8.0.0-rc.1.23420.5.
		}
		
		/// <summary>
		/// Gets CD/DVD drive path, like <c>@"D:\"</c>.
		/// </summary>
		/// <returns><c>null</c> if unavailable.</returns>
		public static FolderPath CdDvdDrive {
			get {
				foreach (var di in DriveInfo.GetDrives()) {
					if (di.DriveType == DriveType.CDRom) return new(di.Name);
				}
				return default;
			}
		}
		
		/// <summary>Calls <see cref="removableDrive(int)"/>(0).</summary>
		public static FolderPath RemovableDrive0 => removableDrive(0);
		/// <summary>Calls <see cref="removableDrive(int)"/>(1).</summary>
		public static FolderPath RemovableDrive1 => removableDrive(1);
		/// <summary>Calls <see cref="removableDrive(int)"/>(2).</summary>
		public static FolderPath RemovableDrive2 => removableDrive(2);
		/// <summary>Calls <see cref="removableDrive(int)"/>(3).</summary>
		public static FolderPath RemovableDrive3 => removableDrive(3);
		
		/// <summary>
		/// Gets removable/external/USB drive path, like <c>@"F:\"</c>.
		/// </summary>
		/// <returns><c>null</c> if unavailable.</returns>
		/// <param name="driveIndex">0-based removable drive index.</param>
		/// <remarks>
		/// Calls <see cref="DriveInfo.GetDrives"/> and counts drives of type <see cref="DriveType.Removable"/>.
		/// </remarks>
		public static FolderPath removableDrive(int driveIndex = 0) {
			foreach (DriveInfo di in DriveInfo.GetDrives()) {
				if (di.DriveType == DriveType.Removable && driveIndex-- == 0) return new(di.Name);
			}
			return default;
		}
		
		/// <summary>
		/// Gets removable/external/USB drive name (like <c>@"F:\"</c>) by its volume label.
		/// </summary>
		/// <returns><c>null</c> if unavailable.</returns>
		/// <param name="volumeLabel">Volume label. You can see it in drive <b>Properties</b> dialog; it is not the drive name that is displayed in File Explorer.</param>
		public static FolderPath removableDrive(string volumeLabel) {
			foreach (DriveInfo di in DriveInfo.GetDrives()) {
				if (di.DriveType == DriveType.Removable) {
					string v = null; try { v = di.VolumeLabel; } catch { continue; }
					if (!v.Eqi(volumeLabel)) continue;
					return new(di.Name);
				}
			}
			return default;
		}
		
		/// <summary>
		/// Gets the value of an environment variable in current process.
		/// </summary>
		/// <returns><c>null</c> if variable not found.</returns>
		/// <seealso cref="Environment.GetEnvironmentVariable"/>
		/// <seealso cref="Environment.SetEnvironmentVariable"/>
		/// <seealso cref="pathname.expand"/>
		public static FolderPath envVar(string envVar) => new(Api.GetEnvironmentVariable(envVar));
		
		#endregion
		
		#region private functions
		
		//Gets non-virtual known folder path from KNOWNFOLDERID specified with 4 uints.
		static FolderPath _Get(uint a, uint b, uint c, uint d) {
			//info: we don't use caching. It seems the API use caching internally.
			//tested: with IKnownFolder much slower.
			
			var guid = new _Api.KNOWNFOLDERID(a, b, c, d);
			if (0 != _Api.SHGetKnownFolderPath(guid, _Api.KNOWN_FOLDER_FLAG.KF_FLAG_DONT_VERIFY, default, out string R)) R = null;
			return new(R);
		}
		
		//Gets virtual known folder ITEMIDLIST from KNOWNFOLDERID specified with 4 uints.
		static Pidl _GetVI(uint a, uint b, uint c, uint d) {
			var guid = new _Api.KNOWNFOLDERID(a, b, c, d);
			if (0 != _Api.SHGetKnownFolderIDList(guid, _Api.KNOWN_FOLDER_FLAG.KF_FLAG_DONT_VERIFY, default, out IntPtr pidl)) return null;
			return new Pidl(pidl);
		}
		
		//Gets virtual known folder ITEMIDLIST from KNOWNFOLDERID specified with 4 uints.
		//Returns string ":: ITEMIDLIST".
		static FolderPath _GetV(uint a, uint b, uint c, uint d) {
			using var pidl = _GetVI(a, b, c, d); //never mind: could do it without creating new Pidl
			return new(pidl?.ToHexString());
		}
		
		#endregion
		
		#region API
		
		static class _Api {
			//GUID that can be inited with 4 uints.
			internal struct KNOWNFOLDERID {
				uint _a; ushort _b, _c; byte _d, _e, _f, _g, _h, _i, _j, _k;
				
				public KNOWNFOLDERID(uint a, uint b, uint c, uint d) {
					_a = a;
					_b = (ushort)(b >> 16);
					_c = (ushort)b;
					_d = (byte)(c >> 24);
					_e = (byte)(c >> 16);
					_f = (byte)(c >> 8);
					_g = (byte)c;
					_h = (byte)(d >> 24);
					_i = (byte)(d >> 16);
					_j = (byte)(d >> 8);
					_k = (byte)d;
				}
			}
			
			[DllImport("shell32.dll")]
			internal static extern int SHGetKnownFolderPath(in KNOWNFOLDERID rfid, KNOWN_FOLDER_FLAG dwFlags, IntPtr hToken, out string ppszPath);
			
			[DllImport("shell32.dll")]
			internal static extern int SHGetKnownFolderIDList(in KNOWNFOLDERID rfid, KNOWN_FOLDER_FLAG dwFlags, IntPtr hToken, out IntPtr ppidl);
			
			[Flags]
			internal enum KNOWN_FOLDER_FLAG : uint {
				KF_FLAG_SIMPLE_IDLIST = 0x00000100,
				KF_FLAG_NOT_PARENT_RELATIVE = 0x00000200,
				KF_FLAG_DEFAULT_PATH = 0x00000400,
				KF_FLAG_INIT = 0x00000800,
				KF_FLAG_NO_ALIAS = 0x00001000,
				KF_FLAG_DONT_UNEXPAND = 0x00002000,
				KF_FLAG_DONT_VERIFY = 0x00004000,
				KF_FLAG_CREATE = 0x00008000,
				KF_FLAG_NO_APPCONTAINER_REDIRECTION = 0x00010000,
				KF_FLAG_ALIAS_ONLY = 0x80000000
			}
			
			internal enum KF_DEFINITION_FLAGS {
				KFDF_LOCAL_REDIRECT_ONLY = 0x2,
				KFDF_ROAMABLE = 0x4,
				KFDF_PRECREATE = 0x8,
				KFDF_STREAM = 0x10,
				KFDF_PUBLISHEXPANDEDPATH = 0x20
			}
			
#pragma warning disable CS0649 //field never assigned
			internal struct KNOWNFOLDER_DEFINITION {
				public KF_CATEGORY category;
				public string pszName;
				public string pszDescription;
				public Guid fidParent;
				public string pszRelativePath;
				public string pszParsingName;
				public string pszToolTip;
				public string pszLocalizedName;
				public string pszIcon;
				public string pszSecurity;
				public uint dwAttributes;
				public KF_DEFINITION_FLAGS kfdFlags;
				public Guid ftidType;
			}
#pragma warning restore CS0649 //field never assigned
			
			internal enum FFFP_MODE {
				FFFP_EXACTMATCH,
				FFFP_NEARESTPARENTMATCH
			}
			
			[ComImport, Guid("8BE2D872-86AA-4d47-B776-32CCA40C7018"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
			internal unsafe interface IKnownFolderManager {
				[PreserveSig] int FolderIdFromCsidl(int nCsidl, out Guid pfid);
				[PreserveSig] int FolderIdToCsidl(in Guid rfid, out int pnCsidl);
				[PreserveSig] int GetFolderIds(out Guid* ppKFId, out int pCount);
				[PreserveSig] int GetFolder(in Guid rfid, out IKnownFolder ppkf);
				[PreserveSig] int GetFolderByName([In, MarshalAs(UnmanagedType.LPWStr)] string pszCanonicalName, out IKnownFolder ppkf);
				//[PreserveSig] int RegisterFolder(in Guid rfid, in KNOWNFOLDER_DEFINITION pKFD);
				//[PreserveSig] int UnregisterFolder(in Guid rfid);
				//[PreserveSig] int FindFolderFromPath([In, MarshalAs(UnmanagedType.LPWStr)] string pszPath, FFFP_MODE mode, out IKnownFolder ppkf);
				//[PreserveSig] int FindFolderFromIDList(IntPtr pidl, out IKnownFolder ppkf);
				//[PreserveSig] int Redirect(in Guid rfid, wnd hwnd, uint flags, [In, MarshalAs(UnmanagedType.LPWStr)] string pszTargetPath, uint cFolders, [MarshalAs(UnmanagedType.LPArray)] [In] Guid[] pExclusion, char** ppszError);
			}
			
			[ComImport, Guid("4df0c730-df9d-4ae3-9153-aa6b82e9795a"), ClassInterface(ClassInterfaceType.None)]
			internal class KnownFolderManager { }
			
			internal enum KF_CATEGORY {
				KF_CATEGORY_VIRTUAL = 1,
				KF_CATEGORY_FIXED = 2,
				KF_CATEGORY_COMMON = 3,
				KF_CATEGORY_PERUSER = 4
			}
			
			[ComImport, Guid("3AA7AF7E-9B36-420c-A8E3-F77D4674A488"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
			internal unsafe interface IKnownFolder {
				[PreserveSig] int GetId(out Guid pkfid);
				[PreserveSig] int GetCategory(out KF_CATEGORY pCategory);
				[PreserveSig] int GetShellItem(uint dwFlags, in Guid riid, void** ppv);
				[PreserveSig] int GetPath(uint dwFlags, [MarshalAs(UnmanagedType.LPWStr)] out string ppszPath); //tested: .NET correctly calls CoTaskMemFree
				[PreserveSig] int SetPath(uint dwFlags, [In, MarshalAs(UnmanagedType.LPWStr)] string pszPath);
				[PreserveSig] int GetIDList(uint dwFlags, out IntPtr ppidl);
				[PreserveSig] int GetFolderType(out Guid pftid);
				[PreserveSig] int GetRedirectionCapabilities(out uint pCapabilities);
				[PreserveSig] int GetFolderDefinition(out KNOWNFOLDER_DEFINITION pKFD);
			}
		}
		
		#endregion
		
		#region public methods
		
		/// <summary>
		/// Gets canonical names and paths of all known folders, including custom known folders registered by applications.
		/// These names can be used with <see cref="getFolder"/>.
		/// </summary>
		/// <remarks>
		/// Paths of virtual and unavailable folders are returned as <c><![CDATA["<virtual>"]]></c> and <c><![CDATA["<unavailable>"]]></c>.
		/// </remarks>
		public static unsafe Dictionary<string, string> getKnownFolders() {
			var dict = new Dictionary<string, string>();
			
			var man = new _Api.KnownFolderManager() as _Api.IKnownFolderManager;
			Guid* gp = null;
			try {
				if (man.GetFolderIds(out gp, out int nIds) != 0) return null;
				for (int i = 0; i < nIds; i++) {
					_Api.IKnownFolder kf = null;
					try {
						if (man.GetFolder(gp[i], out kf) != 0) continue;
						if (kf.GetFolderDefinition(out var fd) != 0) continue;
						string path = null;
						if (fd.category == _Api.KF_CATEGORY.KF_CATEGORY_VIRTUAL) {
							path = "<virtual>";
						} else {
							if (kf.GetPath(0, out path) != 0) path = "<unavailable>";
						}
						dict.Add(fd.pszName, path);
						//tested: .NET correctly frees struct strings. Don't need FreeKnownFolderDefinitionFields, which is an inline function that calls CoTaskMemFree.
					}
					catch { }
					finally { Api.ReleaseComObject(kf); }
				}
			}
			catch {
				dict = null;
			}
			finally {
				Marshal.FreeCoTaskMem((IntPtr)gp);
				Api.ReleaseComObject(man);
			}
			return dict;
		}
		
		/// <summary>
		/// Gets path of a known folder by its name.
		/// </summary>
		/// <returns><c>null</c> if unavailable.</returns>
		/// <param name="folderName">
		/// Can be:
		/// <br/>• name of a property of this class, like <c>"Documents"</c>, <c>"Temp"</c>, <c>"ThisApp"</c>. The property must return <see cref="FolderPath"/> or <c>string</c>.
		/// <br/>• name of a property of the nested class <see cref="shell"/>, like <c>"shell.ControlPanel"</c>. Gets <c>":: ITEMIDLIST"</c>.
		/// <br/>• known folder canonical name. See <see cref="getKnownFolders"/>. If has prefix <c>"shell."</c>, gets <c>":: ITEMIDLIST"</c>. Much slower, but allows to get paths of folders registered by applications.
		/// </param>
		/// <seealso cref="pathname.expand"/>
		public static FolderPath getFolder(string folderName) {
			if (folderName.NE()) return default;
			bool isVirtual = folderName.Starts("shell.");
			if (isVirtual) folderName = folderName[6..];
			
			//properties of this class
			Type ty = isVirtual ? typeof(shell) : typeof(folders);
			switch (ty.GetProperty(folderName)?.GetValue(null)) {
			case FolderPath fp: return fp;
			case string fp: return new(fp);
			}
			//Using reflection is not the fastest way, but simplest, cannot make bugs, and don't need maintenance. Fast enough.
			
			//default and custom registered known folders by canonical name
			string R = null;
			_Api.IKnownFolderManager man = null; _Api.IKnownFolder kf = null;
			try {
				man = (_Api.IKnownFolderManager)new _Api.KnownFolderManager();
				if (man.GetFolderByName(folderName, out kf) != 0) return default;
				if (isVirtual) {
					if (0 != kf.GetIDList(0, out IntPtr pidl)) return default;
					R = Pidl.ToHexString(pidl);
					Marshal.FreeCoTaskMem(pidl);
				} else {
					if (0 != kf.GetPath(0, out R)) return default;
					R = pathname.expand(R);
				}
				//tested: works in MTA apartment too. And all props.
			}
			catch { }
			finally {
				Api.ReleaseComObject(kf);
				Api.ReleaseComObject(man);
			}
			
			return new(R);
			
			//speed:
			//	The get-property code is 2 times slower than calling properties directly.
			//	The IKnownFolderManager code is 90 times slower than the get-property code.
		}
		
		#endregion
		
		//DON'T: public static class VirtualNAME that returns parsing name, eg "::{CLSID}\...".
		//	Good: native/.NET shellexecute supports it.
		//	Bad: native/.NET shellexecute supports only some. Almost nothing works in a 32-bit process on 64-bit OS; then even cannot convert the string to ITEMIDLIST. Some parsing names have other formats and the API gets wrong parsing names.
		
		//DON'T: The + operator returns FolderPath. Then folders.Desktop + subfolder + file would return "desktop\subfolder\file". Probably not good.
		//CONSIDER: operator / instead of +. Then could do things like 'folders.x / "subfolder" / "file"' and 'f /= "append"'.
		
		/// <summary>
		/// If string starts with a known/special folder path, gets folder name + relative path and returns <c>true</c>.
		/// For example if string is <c>"C:\Windows\System32\notepad.exe"</c>, gets <c>"folders.System"</c> and <c>"notepad.exe"</c>.
		/// </summary>
		/// <param name="path">Any string. Can be <c>null</c>. Case-insensitive. Supports <c>":: ITEMIDLIST"</c> (see <see cref="Pidl.ToHexString"/>).</param>
		/// <param name="folder">Receives special folder string like <c>"folders.System"</c>.</param>
		/// <param name="name">Receives filename or relative path in the folder.</param>
		/// <remarks>
		/// Quite slow first time in process, eg 50 ms, because gets all folder paths. Later uses cached paths.
		/// </remarks>
		/// <seealso cref="pathname.expand"/>
		public static bool unexpandPath(string path, out string folder, out string name) {
			var p = path; folder = name = null;
			if (!p.NE()) {
				p = p.Lower();
				if (p.Starts(":: ")) {
					foreach (var v in _upv.Value) {
						int n = v.path.Length;
						if (p.Starts(v.path)) {
							folder = "folders.shell." + v.name;
							name = path[n..];
							return true;
						}
					}
				} else {
					p = p.Replace('/', '\\');
					foreach (var v in _up.Value) {
						int n = v.path.Length;
						if (p.Starts(v.path) && (p.Length == n || p[n] == '\\')) {
							folder = "folders." + v.name;
							if (p.Length > n) n++;
							name = path[n..];
							return true;
						}
					}
					
					if (ScriptEditor.IsPortable && path.Starts(ThisAppDriveBS, true)) {
						folder = "folders.ThisAppDriveBS";
						name = path[ThisAppDriveBS.Length..];
						return true;
					}
				}
			}
			return false;
		}
		
		/// <summary>
		/// If string starts with a known/special folder path, replaces that part with <c>%folders.FolderName%</c>. Else returns unchanged string.
		/// For example if string is <c>"C:\Windows\System32\notepad.exe"</c>, returns <c>"%folders.System%\notepad.exe"</c>.
		/// </summary>
		/// <param name="path">Any string. Can be <c>null</c>. Case-insensitive. Supports <c>":: ITEMIDLIST"</c> (see <see cref="Pidl.ToHexString"/>).</param>
		public static string unexpandPath(string path) {
			if (unexpandPath(path, out var s1, out var s2)) path = s2.NE() ? $@"%{s1}%" : $@"%{s1}%\{s2}";
			return path;
		}
		
		static readonly Lazy<List<(string path, string name)>> _up = new(() => {
			var a = new List<(string path, string name)>(120); //105
			lock (_lock) {
				var nac = noAutoCreate;
				noAutoCreate = true;
				foreach (var pi in typeof(folders).GetProperties()) {
					if (pi.PropertyType == typeof(FolderPath)
						&& !pi.Name.Starts("ThisApp") //different in processes
						&& pi.GetValue(null) is FolderPath fp) {
						var s = fp.Path;
						if (!s.NE()) a.Add((s.Lower(), pi.Name));
					}
				}
				noAutoCreate = nac;
			}
			a.Sort((s1, s2) => {
				var r = s2.path.Length - s1.path.Length; //prefer longer path, eg C:\A\B to C:\A
				if (r == 0) { //prefer shorter name, eg System to SystemX64
					r = string.CompareOrdinal(s1.path, s2.path); //sorting does not work without this
					if (r == 0 && s1.path == s2.path) r = s1.name.Length - s2.name.Length;
				}
				return r;
			});
			return a;
		});
		
		static readonly Lazy<List<(string path, string name)>> _upv = new(() => {
			var a = new List<(string path, string name)>(30); //22
			foreach (var pi in typeof(folders.shell).GetProperties()) {
				if (pi.PropertyType == typeof(FolderPath) && pi.GetValue(null) is FolderPath fp) {
					var s = fp.Path;
					//print.it(pi.Name, s);
					if (!s.NE()) a.Add((s, pi.Name));
				}
			}
			return a.OrderByDescending(o => o.path.Length).ToList();
		});
		
		/// <summary>
		/// If <i>path</i> starts with one of specified folder paths, replaces that part with the replacements string. Else returns unchanged string.
		/// </summary>
		/// <param name="path">Any string. Can be <c>null</c>. Case-insensitive.</param>
		/// <param name="list">Folder paths and replacement strings.</param>
		/// <example>
		/// <code><![CDATA[
		/// var s = folders.Documents + "file.txt";
		/// //var s = folders.Temp + "file.txt";
		/// print.it(s);
		/// print.it(folders.unexpandPath(s, (folders.Temp, "%temp%"), (folders.Documents, "%folders.Documents%")));
		/// ]]></code>
		/// </example>
		public static string unexpandPath(string path, params (string folder, string replacement)[] list) {
			path = path.Replace('/', '\\');
			foreach (var (f_, repl) in list) {
				var f = f_.Replace('/', '\\');
				if (path.Starts(f, true)) {
					int len = f.Length;
					if (path.Length == len) return repl;
					if (path[len] is not ('\\' or '/') && f[^1] is not ('\\' or '/')) continue;
					return string.Concat(repl, path.AsSpan(len));
				}
			}
			return path;
		}
	}
}

namespace Au.Types {
	/// <summary>
	/// Most functions of <see cref="folders"/> class return a value of this type.
	/// Contains folder path (string) and has operator <c>+</c> to append a string with backslash if need. Has implicit conversions from/to string.
	/// </summary>
	public struct FolderPath {
		readonly string _path;
		public FolderPath(string path) { _path = path; }
		
		public static explicit operator FolderPath(string path) => new(path); //not implicit. Example: var s = "STRING " + folders.ThisApp; // converts "STRING " to FolderPath and result is @"STRING \C:\path"
		public static implicit operator string(FolderPath f) => f._path;
		
		/// <summary>
		/// Returns <see cref="Path"/>.
		/// </summary>
		public override string ToString() => _path;
		
		/// <summary>
		/// Returns the path string. For some folders it can be <c>null</c>.
		/// </summary>
		public string Path => _path;
		
		/// <summary>
		/// Returns the path string. If it is <c>null</c>, throws <see cref="InvalidOperationException"/>.
		/// </summary>
		/// <exception cref="InvalidOperationException"></exception>
		public string PathOrThrow => _path ?? throw new InvalidOperationException("the special folder path is null");
		
		/// <summary>
		/// Returns <c>true</c> if the path is <c>null</c>.
		/// </summary>
		public bool IsNull => _path == null;
		
		/// <summary>
		/// Calls <see cref="pathname.combine"/>.
		/// Example: <c>string s = folders.Desktop + "file.txt";</c>
		/// </summary>
		/// <exception cref="ArgumentException"><i>fp</i> is empty.</exception>
		public static string operator +(FolderPath fp, string append) {
			if (fp._path.NE()) throw new ArgumentException("No folder path.");
			return pathname.combine(fp._path, append);
		}
	}
}


================================================
FILE: Au/Files, data/icon.cs
================================================
using System.Drawing;
using System.Reflection.Emit;

namespace Au {
	/// <summary>
	/// Gets icons from/of files etc. Contains native icon handle.
	/// </summary>
	/// <remarks>
	/// Native icons must be destroyed. An <c>icon</c> variable destroys its native icon when disposing. To dispose, call <see cref="Dispose"/> or use <c>using</c> statement. Or use functions like <see cref="ToGdipBitmap"/>, <see cref="ToWpfImage"/>; by default they dispose the <see cref="icon"/> variable. It's OK to not dispose if you use few icons; GC will do it.
	/// </remarks>
	public class icon : IDisposable { //rejected: base SafeHandle.
		IntPtr _handle;
		
		/// <summary>
		/// Sets native icon handle.
		/// The icon will be destroyed when disposing this variable or when converting to object of other type.
		/// </summary>
		public icon(IntPtr hicon) {
			Debug_.PrintIf(hicon == default, "hicon == default");
			
			//Don't allow to exceed the process handle limit when the program does not dispose them. Default limits are 10000, but min 200.
			//Icons are USER objects. They also usually create 3 GDI objects (bitmaps?). So a process can have max ~3300 icons by default.
			if (hicon != default) { GC_.UserHandleCollector.Add(); GC_.GdiHandleCollector.Add(); GC_.GdiHandleCollector.Add(); GC_.GdiHandleCollector.Add(); }
			//rejected: Add property for native icon ownership or methods for refcounting.
			//	Usually a process uses few icons. If many, the programmer knows the importance of disposing icons; or HandleCollector helps.
			
			_handle = hicon;
		}
		
		//FUTURE: FromGdipIcon, FromStream.
		
		static icon _New(IntPtr hi) => hi != default ? new(hi) : null;
		
		/// <summary>
		/// Destroys native icon handle.
		/// </summary>
		public void Dispose() {
			Dispose(true);
			GC.SuppressFinalize(this); //never mind: actually this should be in Detach, but then intellisense gives 2 notes
		}
		
		///
		protected virtual void Dispose(bool disposing) {
			var h = Detach();
			if (h != default) Api.DestroyIcon(h);
		}
		
		///
		~icon() { Dispose(false); }
		
		/// <summary>
		/// Clears this variable and returns its native icon handle.
		/// </summary>
		public IntPtr Detach() {
			var h = _handle;
			if (_handle != default) {
				_handle = default;
				GC_.UserHandleCollector.Remove(); GC_.GdiHandleCollector.Remove(); GC_.GdiHandleCollector.Remove(); GC_.GdiHandleCollector.Remove();
			}
			return h;
		}
		
		/// <summary>
		/// Gets native icon handle.
		/// </summary>
		public IntPtr Handle => _handle;
		
		/// <summary>
		/// Gets native icon handle.
		/// </summary>
		public static implicit operator IntPtr(icon i) => i?._handle ?? default;
		
		/// <summary>
		/// Gets icon that can be displayed for a file, folder, shell object, URL or file type.
		/// </summary>
		/// <returns><c>null</c> if failed.</returns>
		/// <param name="file">
		/// Can be:
		/// <br/>• Path of any file or folder. Supports environment variables. If not full path, uses <see cref="folders.ThisAppImages"/> and <see cref="filesystem.searchPath"/>.
		/// <br/>• Any shell object, like <c>":: ITEMIDLIST"</c>, <c>@"::{CLSID-1}\::{CLSID-2}"</c>, <c>@"shell:AppsFolder\WinStoreAppId"</c>.
		/// <br/>• File type like <c>".txt"</c>, or protocol like <c>"http:"</c>. Use <c>"."</c> to get folder icon.
		/// <br/>• Path with icon resource index or negative id, like <c>"c:\file.dll,4"</c>, <c>"c:\file.exe,-4"</c>.
		/// <br/>• URL.
		/// </param>
		/// <param name="size">Icon width and height. Default 16.</param>
		/// <param name="flags"></param>
		/// <remarks>
		/// <c>ITEMIDLIST</c> can be of any file, folder, URL or a non-filesystem shell object. See <see cref="Pidl.ToHexString"/>.
		/// </remarks>
		public static icon of(string file, int size = 16, IconGetFlags flags = 0) {
			using var ds = new _DebugSpeed(file);
			return _OfFile(file, _NormalizeIconSizeArgument(size), flags);
		}
		
		static icon _OfFile(string file, int size = 16, IconGetFlags flags = 0) {
			if (file.NE()) return null;
			file = pathname.expand(file, strict: false);
			return _GetFileIcon(file, size, flags);
		}
		
		/// <summary>
		/// Gets icon of a file or other shell object specified as <c>ITEMIDLIST</c>.
		/// </summary>
		/// <returns><c>null</c> if failed.</returns>
		/// <param name="pidl"><c>ITEMIDLIST</c>.</param>
		/// <param name="size">Icon width and height. Default 16.</param>
		public static icon ofPidl(Pidl pidl, int size = 16) {
			using var ds = new _DebugSpeed(pidl);
			return _OfPidl(pidl, _NormalizeIconSizeArgument(size));
		}
		
		static icon _OfPidl(Pidl pidl, int size) {
			if (pidl?.IsNull ?? true) return null;
			return _GetShellIcon(true, null, pidl, size);
		}
		
		static icon _GetFileIcon(string file, int size, IconGetFlags flags) {
			int index = 0;
			bool extractFromFile = false, isFileType = false, isURL = false, isShellPath = false, isPath = true;
			//bool getDefaultIfFails = 0!=(flags&IconGetFlags.DefaultIfFails);
			
			bool searchPath = 0 == (flags & IconGetFlags.DontSearch);
			
			if (0 == (flags & IconGetFlags.LiteralPath)) {
				//is ".ext" or "protocol:"?
				isFileType = pathname.IsExtension_(file) || (isURL = pathname.IsProtocol_(file));
				if (!isFileType) isURL = pathname.isUrl(file);
				if (isFileType || isURL || (isShellPath = file[0] == ':')) isPath = false;
				if (isPath) {
					//get icon index from "path,index" and remove ",index"
					extractFromFile = parsePathIndex(file, out file, out index);
					
					if (!searchPath) {
						if (!pathname.isFullPath(file)) file = folders.ThisAppImages + file;
						file = pathname.Normalize_(file, PNFlags.DontPrefixLongPath, noExpandEV: true);
					}
				}
			}
			
			if (isPath) {
				if (searchPath) {
					file = filesystem.searchPath(file, folders.ThisAppImages);
					if (file == null) return null; //ignore getDefaultIfFails
				}
				file = pathname.unprefixLongPath(file);
			}
			
			if (isPath /*&& (extractFromFile || 0==(flags&IconGetFlags.Shell))*/) {
				int ext = 0;
				if (!extractFromFile && file.Length > 4) ext = file.Ends(true, ".ico", ".exe", ".scr"/*, ".cur", ".ani"*/);
				if (extractFromFile || ext > 0) {
					var v = _Load(file, size, index);
					if (v != null || extractFromFile) return v;
					switch (filesystem.exists(file, true)) {
					case 0:
						return null;
					case 1:
						return stock(ext is 2 or 3 ? StockIcon.APPLICATION : StockIcon.DOCNOASSOC, size);
						//case 2: //folder name ends with .ico etc
					}
				} else if (file.Ends(".lnk", true)) {
					var v = _GetLnkIcon(file, size);
					if (v != null) return v;
					//print.it("_GetLnkIcon failed", file);
				}
				
				//note: here we don't cache icons.
				//Fast enough for where we use this. OS file buffers remain in memory for some time.
				//Where need, should instead use imagelists or some external cache that saves eg full toolbar bitmap.
				//SHGetFileInfo has its own cache. In some cases it makes faster (except first time in process), but using it to get all icons is much slower.
			}
			
			bool isExt = isFileType && !isURL;
			
			//Can use this code to avoid slow shell API if possible.
			//In some test cases can make ~2 times faster (with thread pool), especially in MTA thread.
			//But now, after other optimizations applied, in real life makes faster just 10-20%.
#if false
			//if(0==(flags&IconGetFlags.Shell)){
			string progId = isShellPath ? null : filesystem.more.getFileTypeOrProtocolRegistryKey(file, isFileType, isURL);

			RegistryKey rk = (progId == null) ? null : ARegistry.Open(progId, Registry.ClassesRoot);
			//print.it(file, progId, isFileType, isURL, rk != null);

			if(rk == null) {
				//Unregistered file type/protocol, no extension, folder, ::{CLSID}, shell:AppsFolder\WinStoreAppId, or no progId key in HKCR
				//print.it(@"unregistered", file, progId);
				if(progId != null) goto gr; //the file type is known, but no progid key in HKCR. Let shell API figure out. Rare.
				if(isExt || (isPath && filesystem.exists(file).File)) return Stock(StockIcon.DOCNOASSOC, size);
				goto gr;
			}

			//Registered file type/protocol.
			using(rk) {
				if(ARegistry.KeyExists(@"ShellEx\IconHandler", rk)) {
					//print.it(@"handler", file);
					goto gr;
				}

				string si;
				if(ARegistry.GetString(out si, "", @"DefaultIcon", rk) && si.Length > 0) {
					//print.it("registry: DefaultIcon", file, si);
					if(si[0] == '@') si = null; //eg @{Microsoft.Windows.Photos_16.622.13140.0_x64__8wekyb3d8bbwe?ms-resource://Microsoft.Windows.Photos/Files/Assets/PhotosLogoExtensions.png}
					else ParseIconLocation(ref si, out index);
				} else if(ARegistry.GetString(out si, "", @"shell\open\command", rk) && si.Length > 0) {
					//print.it(@"registry: shell\open\command", file, si);
					var a = si.SegSplit((si[0] == '"') ? "\"" : " ", StringSplitOptions.RemoveEmptyEntries);
					si = (a.Length == 0) ? null : a[0];
					if(si.Ends("rundll32.exe", true)) si = null;
				} else {
					si = null;
					//print.it("registry: no", file);
					//Usually shell API somehow gets si.
					//For example also looks in .ext > PerceivedType > HKCR\SystemFileAssociations.
					//We can use AssocQueryString(ASSOCSTR_DEFAULTICON), but it is slow and not always gets correct si.
				}

				//if(si != null) print.it(file, si);

				if(si == "%1") {
					//print.it(file);
					if(isPath) si = file;
					else si = null;
				}

				if(si != null) {
					si = pathname.expand(si);
					if(!pathname.isFullPath(si)) si = folders.System + si;
					vat v = _Load(si, size, index);
					if(v != null) return v;
				}
			}
			//}
			gr:
#endif
			return _GetShellIcon(!isExt, file, null, size);
		}
		
		//usePidl - if pidl not null/IsNull, use pidl, else convert file to PIDL. If false, pidl must be null.
		static icon _GetShellIcon(bool usePidl, string file, Pidl pidl, int size, bool freePidl = false) {
			//info:
			//	We support everything that can have icon - path, URL, protocol (eg "http:"), file extension (eg ".txt"), shell item parsing name (eg "::{CLSID}"), "shell:AppsFolder\WinStoreAppId".
			//	We call PidlFromString here and pass it to SHGetFileInfo. It makes faster when using thread pool, because multiple threads can call PidlFromString (slow) simultaneously.
			//	PidlFromString does not support file extension. SHGetFileInfo does not support URL and protocol, unless used PIDL.
			//	SHGetFileInfo gets the most correct icons, but only of standard sizes, which also depends on DPI and don't know what.
			//	IExtractIcon for some types fails or gets wrong icon. Even cannot use it to get correct-size icons, because for most file types it uses system imagelists, which are DPI-dependent.
			//	SHMapPIDLToSystemImageListIndex+SHGetImageList also is not better.
			
			//FUTURE: make faster "shell:...". Now eg 100 ms for Settings first time (50 ms Pidl.FromString_ and 50 ms SHGetFileInfo).
			//	Alternatives (not tested): https://stackoverflow.com/questions/32122679/getting-icon-of-modern-windows-app-from-a-desktop-application
			//	Not a big problem when using caching.
			//	Also some icons have incorrect background, eg Calculator.
			
			var pidl2 = pidl?.UnsafePtr ?? default;
			if (usePidl) {
				if (pidl2 == default) {
					pidl2 = Pidl.FromString_(file);
					if (pidl2 == default) usePidl = false; else freePidl = true;
				}
			}
			
			if (!usePidl) {
				Debug.Assert(pidl2 == default && file != null);
				pidl2 = Marshal.StringToCoTaskMemUni(file);
				freePidl = true;
			}
			
			if (pidl2 == default) return null;
			
			//This is faster but fails with some files etc, randomly with others.
			//It means that shell API and/or extensions are not thread-safe, even if can run in MTA.
			//return _GetShellIcon2(pidl2, size, usePidl);
			
			icon R;
			try {
				if (Thread.CurrentThread.GetApartmentState() == ApartmentState.STA) {
					R = _GetShellIcon2(usePidl, pidl2, size);
				} else {
					//tested: switching thread does not make slower. The speed depends mostly on locking, because then thread pool threads must wait.
#if true
					R = Task.Factory.StartNew(() => _GetShellIcon2(usePidl, pidl2, size), default, 0, StaTaskScheduler_.Default).Result_();
#else //old code, uses ThreadPoolSTA_
					using var work = ThreadPoolSTA_.CreateWork(null, o => { R = _GetShellIcon2(usePidl, pidl2, size); });
					work.Submit();
					work.Wait();
#endif
				}
			}
			finally { if (freePidl) Marshal.FreeCoTaskMem(pidl2); }
			GC.KeepAlive(pidl);
			return R;
		}
		
		static icon _GetShellIcon2(bool isPidl, IntPtr pidl, int size) {
			IntPtr il = default; int index = -1, ilIndex, realSize;
			
			if (size < (realSize = 16) * 5 / 4) ilIndex = Api.SHIL_SMALL;
			else if (size < (realSize = 32) * 5 / 4) ilIndex = Api.SHIL_LARGE;
			else if (size < 256) {
				ilIndex = Api.SHIL_EXTRALARGE; realSize = 48;
				//info: cannot resize from 256 because GetIcon(SHIL_JUMBO) gives 48 icon if 256 icon unavailable. Getting real icon size is either impossible or quite difficult and slow (not tested).
			} else { ilIndex = Api.SHIL_JUMBO; realSize = 256; }
			
			using var dac = new Dpi.AwarenessContext(-1); //unaware
			
			//Need to lock this part, or randomly fails with some file types.
			lock ("TK6Z4XiSxkGSfC14/or5Mw") {
				try {
					uint fl = Api.SHGFI_SYSICONINDEX | Api.SHGFI_SHELLICONSIZE;
					if (ilIndex == Api.SHIL_SMALL) fl |= Api.SHGFI_SMALLICON;
					if (isPidl) fl |= Api.SHGFI_PIDL; else fl |= Api.SHGFI_USEFILEATTRIBUTES;
					il = Api.SHGetFileInfo(pidl, out var x, fl);
					if (il != default) index = x.iIcon;
					//Marshal.Release(il); //undocumented, but without it IImageList refcount grows. Probably it's ok, because it is static, never deleted until process exits.
				}
				catch { Debug_.Print("exception"); }
				//Shell extensions may throw.
				//By default .NET does not allow to handle eg access violation exceptions.
				//	Previously we would add [HandleProcessCorruptedStateExceptions], but Core ignores it.
				//	Now our AppHost sets environment variable COMPlus_legacyCorruptedStateExceptionsPolicy=1 before loading runtime.
				//	Or could move the API call to the C++ dll.
			}
			if (index < 0) return null;
			
			//note: Getting icon from imagelist must be in STA thread too, else fails with some file types.
			//tested: This part works without locking. Using another lock here makes slower.
			
			try {
				if (ilIndex == Api.SHIL_SMALL || ilIndex == Api.SHIL_LARGE || _GetShellImageList(ilIndex, out il)) {
					//print.it(il, Debug_.GetComObjRefCount(il));
					var hi = Api.ImageList_GetIcon(il, index, 0);
					if (hi != default) {
						if (size != realSize) {
							//print.it(size, realSize, index, file);
							hi = Api.CopyImage(hi, Api.IMAGE_ICON, size, size, Api.LR_COPYDELETEORG | Api.LR_COPYRETURNORG);
							//never mind if fails, it's too rare.
							//TODO3: test LR_COPYFROMRESOURCE.
						}
						return _New(hi);
					}
				}
			}
			catch (Exception e) { Debug_.Print(e); }
			//finally { if(il != default) Marshal.Release(il); }
			return null;
			
			static bool _GetShellImageList(int ilIndex, out IntPtr R) {
				lock ("vK6Z4XiSxkGSfC14/or5Mw") { //the API fails if called simultaneously by multiple threads
					if (0 == Api.SHGetImageList(ilIndex, Api.IID_IImageList, out R)) return true;
				}
				Debug.Assert(false);
				return false;
			}
		}
		
		//Gets shortcut (.lnk) icon.
		//Much faster than other shell API.
		//Also gets correct icon where iextracticon fails and/or shgetfileinfo gets blank document icon, don't know why.
		//Usually fails only when target does not exist. Then iextracticon also fails, and shgetfileinfo gets blank document icon.
		//If fails, returns null. No exceptions.
		static icon _GetLnkIcon(string file, int size) {
			try {
				using var x = shortcutFile.open(file);
				var s = x.GetIconLocation(out int ii); if (s != null) return _Load(s, size, ii);
				s = x.TargetPathRawMSI; if (s != null) return _OfFile(s, size, IconGetFlags.DontSearch);
				//print.it("need IDList", file);
				using (var pidl = x.TargetPidl) return _OfPidl(pidl, size);
			}
			catch { return null; }
		}
		
		/// <summary>
		/// Extracts icon directly from file.
		/// </summary>
		/// <returns><c>null</c> if failed.</returns>
		/// <param name="file"><c>.ico</c>, <c>.exe</c>, <c>.dll</c> or other file that contains one or more icons. Also supports cursor files - <c>.cur</c>, <c>.ani</c>. Must be full path, without icon index. Supports environment variables (see <see cref="pathname.expand"/>).</param>
		/// <param name="size">Icon width and height. Default 16.</param>
		/// <param name="index">Icon index or negative icon resource id in the <c>.exe</c>/<c>.dll</c> file.</param>
		public static icon load(string file, int size = 16, int index = 0) {
			using var ds = new _DebugSpeed(file);
			return _Load(file, _NormalizeIconSizeArgument(size), index);
		}
		
		static unsafe icon _Load(string file, int size, int index) {
			//We use SHDefExtractIcon because of better quality resizing (although several times slower) which matches shell and imagelist resizing.
			//With .ico it matches LoadImage speed (without resizing). PrivateExtractIcons is slightly slower.
			
			if (file.NE()) return null;
			IntPtr hi = default;
			int hr = Api.SHDefExtractIcon(file, index, 0, &hi, null, size);
			return hr == 0 ? _New(hi) : null;
			
			//if(Api.PrivateExtractIcons(file, index, size, size, out R, default, 1, 0) != 1) return null;
			
			//SHOULDOO: test LoadIconWithScaleDown. If .ico or negative index. But maybe SHDefExtractIcon uses it, that is why better quality.
		}
		
		/// <summary>
		/// Gets a shell stock icon.
		/// </summary>
		/// <returns><c>null</c> if failed.</returns>
		/// <param name="id">Shell stock icon id.</param>
		/// <param name="size">Icon width and height. Default 16.</param>
		public static unsafe icon stock(StockIcon id, int size = 16) {
			if (!GetStockIconLocation_(id, out var path, out int index)) return null;
			return load(path, size, index);
			//note: don't cache, because of the quota of handles a process can have. Maybe only exe and document icons; maybe also folder and open folder.
			
			//tested: always gets 32x32 icon: Api.LoadImage(default, 32516, Api.IMAGE_ICON, 16, 16, Api.LR_SHARED); //OIC_INFORMATION
		}
		
		internal static unsafe bool GetStockIconLocation_(StockIcon id, out string path, out int index) {
			var x = new Api.SHSTOCKICONINFO(); x.cbSize = Api.SizeOf(x);
			if (0 == Api.SHGetStockIconInfo(id, 0, ref x)) {
				path = new string(x.szPath);
				index = x.iIcon;
				return true;
			} else {
				path = null;
				index = 0;
				return false;
			}
		}
		
		/// <summary>
		/// Gets icon from unmanaged resources of this program.
		/// </summary>
		/// <returns><c>null</c> if not found.</returns>
		/// <param name="size">Icon width and height. Default 16.</param>
		/// <param name="resourceId">Native resource id. Default <ms>IDI_APPLICATION</ms> (C# compilers add app icon with this id).</param>
		/// <remarks>
		/// If role <c>miniProgram</c> (default), at first looks in main assembly (<c>.dll</c>); if not found there, looks in <c>.exe</c> file. Else only in <c>.exe</c> file.
		/// 
		/// The icon is cached and protected from destroying. Don't need to destroy it, and not error to do it.
		/// </remarks>
		public static icon ofThisApp(int size = 16, int resourceId = Api.IDI_APPLICATION) {
			var hm = GetAppIconModuleHandle_(resourceId);
			return FromModuleHandle_(hm, size, resourceId);
			
			//This is not 100% reliable because the icon id 32512 (IDI_APPLICATION) is undocumented.
			//I could not find a .NET method to get icon directly from native resources of assembly.
			//Could use the resource emumeration API...
			//info: MSDN lies that with LR_SHARED gets a cached icon regardless of size argument. Caches each size separately. Tested on Win 10, 7, XP.
			
			//TEST: LoadIconWithScaleDown.
		}
		
		internal static icon FromModuleHandle_(IntPtr hm, int size = 16, int resourceId = Api.IDI_APPLICATION) {
			if (hm == default) return null;
			size = _NormalizeIconSizeArgument(size);
			return _New(Api.LoadImage(hm, resourceId, Api.IMAGE_ICON, size, size, Api.LR_SHARED));
		}
		
		
		/// <summary>
		/// Gets icon of tray icon size from unmanaged resources of this program or system.
		/// </summary>
		/// <param name="resourceId">Native resource id. Default <ms>IDI_APPLICATION</ms> (C# compilers add app icon with this id).</param>
		/// <remarks>
		/// Calls API <ms>LoadIconMetric</ms>.
		/// 
		/// The icon can be in main assembly (if role <c>miniProgram</c>) or in the program file (<c>.exe</c>). If not found, loads standard icon, see API <ms>LoadIconMetric</ms>.
		/// </remarks>
		public static icon trayIcon(int resourceId = Api.IDI_APPLICATION/*, bool big = false*/) {
#if true
			IntPtr hi = default; int hr = 1;
			if (script.role == SRole.MiniProgram) hr = Api.LoadIconMetric(Api.GetModuleHandle(AssemblyUtil_.GetEntryAssembly().Location), resourceId, 0, out hi);
			if (hr != 0) hr = Api.LoadIconMetric(Api.GetModuleHandle(null), resourceId, 0, out hi);
			if (hr != 0) hr = Api.LoadIconMetric(default, resourceId, 0, out hi);
			return hr == 0 ? _New(hi) : null;
#else //10% slower
			var h = GetAppIconModuleHandle_();
			return 0 == Api.LoadIconMetric(h, resourceId, /*big ? 1 :*/ 0, out var hi) ? new(hi) : null;
#endif
			//can load big icon too, but not very useful.
		}
		
		/// <summary>
		/// Loads icon of tray icon size from <c>.ico</c> file.
		/// </summary>
		/// <returns><c>null</c> if not found.</returns>
		/// <remarks>
		/// Calls API <ms>LoadIconMetric</ms>.
		/// </remarks>
		public static unsafe icon trayIcon(string icoFile) {
			fixed (char* p = icoFile) return 0 == Api.LoadIconMetric(default, (nint)p, 0, out var hi) ? _New(hi) : null;
			//LoadIconMetric bug: does not load large icon from ico file.
		}
		
		/// <summary>
		/// Gets native module handle of exe or dll that contains specified icon. Returns default if no icon.
		/// If role <c>miniProgram</c>, at first looks in main assembly (<c>.dll</c>).
		/// </summary>
		internal static IntPtr GetAppIconModuleHandle_(int resourceId) {
			if (script.role == SRole.MiniProgram) {
				var h1 = Api.GetModuleHandle(AssemblyUtil_.GetEntryAssembly().Location);
				if (default != Api.FindResource(h1, resourceId, Api.RT_GROUP_ICON)) return h1;
			}
			var h2 = Api.GetModuleHandle(null);
			if (default != Api.FindResource(h2, resourceId, Api.RT_GROUP_ICON)) return h2;
			return default;
		}
		
		/// <summary>
		/// Gets icon that is displayed in window title bar and in taskbar button.
		/// </summary>
		/// <returns><c>null</c> if failed.</returns>
		/// <param name="w">A top-level window of any process.</param>
		/// <param name="size">Icon width and height. Default 16.</param>
		public static icon ofWindow(wnd w, int size = 16) {
			//int size = Api.GetSystemMetrics(big ? Api.SM_CXICON : Api.SM_CXSMICON);
			
			//support Windows Store apps
			var appId = WndUtil.GetWindowsStoreAppId(w, prependShellAppsFolder: true);
			if (appId != null) {
				var v = of(appId, size, IconGetFlags.DontSearch);
				if (v != null) return v;
			}
			
			bool big = size >= 24; //TODO3: make high-DPI-aware. How?
			bool ok = w.SendTimeout(2000, out nint R, Api.WM_GETICON, big ? 1 : 0);
			if (R == 0 && ok) w.SendTimeout(2000, out R, Api.WM_GETICON, big ? 0 : 1);
			if (R == 0) R = WndUtil.GetClassLong(w, big ? GCL.HICON : GCL.HICONSM);
			if (R == 0) R = WndUtil.GetClassLong(w, big ? GCL.HICONSM : GCL.HICON);
			//tested this code with DPI 125%. Small icon of most windows match DPI (20), some 16, some 24.
			//tested: undocumented API InternalGetWindowIcon does not get icon of winstore app.
			
			//Copy, because will DestroyIcon, also it resizes if need.
			if (R != 0) R = Api.CopyImage(R, Api.IMAGE_ICON, size, size, 0);
			return _New(R);
		}
		
		/// <summary>
		/// Sends <ms>WM_SETICON</ms> message.
		/// </summary>
		/// <param name="w"></param>
		/// <param name="big"><c>ICON_BIG</c>.</param>
		public void SetWindowIcon(wnd w, bool big) {
			w.Send(Api.WM_SETICON, big ? 1 : 0, _handle);
		}
		
		/// <summary>
		/// Creates icon at run time.
		/// </summary>
		/// <param name="width"></param>
		/// <param name="height"></param>
		/// <param name="drawCallback">Called to draw icon. If <c>null</c>, the icon will be completely transparent.</param>
		public static icon create(int width, int height, Action<Graphics> drawCallback = null) {
			IntPtr hi;
			if (drawCallback != null) {
				using var b = new Bitmap(width, height);
				using var g = Graphics.FromImage(b);
				g.Clear(Color.Transparent); //optional, new bitmaps are transparent, but it is undocumented, and eg .NET Bitmap.MakeTransparent does it
				drawCallback(g);
				hi = b.GetHicon();
			} else {
				int nb = Math2.AlignUp(width, 32) / 8 * height;
				var aAnd = new byte[nb]; for (int i = 0; i < nb; i++) aAnd[i] = 0xff;
				var aXor = new byte[nb];
				hi = Api.CreateIcon(default, width, height, 1, 1, aAnd, aXor);
				
				//speed: ~20 mcs. About 10 times faster than above. Faster than CopyImage etc.
			}
			return _New(hi);
		}
		
		/// <summary>
		/// Creates <see cref="System.Drawing.Icon"/> object that shares native icon handle with this object.
		/// </summary>
		/// <returns><c>null</c> if <see cref="Handle"/> is <c>default(IntPtr)</c>.</returns>
		public Icon ToGdipIcon() {
			if (_handle == default) return null;
			var R = Icon.FromHandle(_handle);
			s_cwt.Add(R, this);
			return R;
		}
		static readonly ConditionalWeakTable<Icon, icon> s_cwt = new();
		
		/// <summary>
		/// Converts native icon to GDI+ bitmap object.
		/// </summary>
		/// <returns><c>null</c> if <see cref="Handle"/> is <c>default(IntPtr)</c> or if fails to convert.</returns>
		/// <param name="destroyIcon">
		/// If <c>true</c> (default), destroys the native icon object; also clears this variable and don't need to dispose it.
		/// If <c>false</c>, later will need to dispose this variable.
		/// </param>
		public Bitmap ToGdipBitmap(bool destroyIcon = true) {
			if (_handle != default) {
				using var ic = Icon.FromHandle(_handle);
				try { return ic.ToBitmap(); }
				catch (Exception e) { print.warning("ToGdipBitmap() failed. " + e.ToString(), -1); }
				finally { if (destroyIcon) Dispose(); }
			}
			return null;
			//note: don't use Bitmap.FromHicon. It just calls GdipCreateBitmapFromHICON which does not support alpha etc.
			//FUTURE: look for a faster way.
		}
		
		/// <summary>
		/// Converts native icon to WPF image object.
		/// </summary>
		/// <returns><c>null</c> if <see cref="Handle"/> is <c>default(IntPtr)</c> or if fails to convert.</returns>
		/// <param name="destroyIcon">
		/// If <c>true</c> (default), destroys the native icon object; also clears this variable and don't need to dispose it.
		/// If <c>false</c>, later will need to dispose this variable.
		/// </param>
		/// <remarks>
		/// The image is not suitable for WPF window icon. Instead use <see cref="SetWindowIcon"/> or WPF image loading functions.
		/// </remarks>
		public System.Windows.Media.Imaging.BitmapSource ToWpfImage(bool destroyIcon = true) {
			if (_handle != default) {
				try { return System.Windows.Interop.Imaging.CreateBitmapSourceFromHIcon(_handle, default, default); }
				catch (Exception e) { print.warning("ToWpfImage() failed. " + e.ToString(), -1); }
				finally { if (destroyIcon) Dispose(); }
			}
			return null;
			
			//why not suitable for WPF window icon:
			//1. Shadows in alpha area. As a workaround could get icon bits and call BitmapFrame.Create(), but
			//2. For window need 2 icons - small and big.
			//See script "HICON to ImageSource".
		}
		
		/// <summary>
		/// Gets icon size.
		/// </summary>
		/// <returns><c>default(SIZE)</c> if failed.</returns>
		public unsafe SIZE Size {
			get {
				if (_handle != default) {
					using Api.ICONINFO ii = new(_handle);
					Api.BITMAP b = default;
					bool hasColors = ii.hbmColor != default;
					Api.GetObject(hasColors ? ii.hbmColor : ii.hbmMask, sizeof(Api.BITMAP), &b);
					return new(b.bmWidth, hasColors ? b.bmHeight : b.bmHeight / 2);
				}
				return default;
			}
		}
		
		/// <summary>
		/// Parses icon location string.
		/// </summary>
		/// <returns><c>true</c> if it includes icon index or resource id.</returns>
		/// <param name="s">
		/// Icon location. Can be <c>"path,index"</c> or <c>"path,-id"</c> or just path.
		/// Supports path enclosed in <c>""</c> like <c>"\"path\",index"</c>, and spaces between comma and index like <c>"path, index"</c>.
		/// </param>
		/// <param name="path">Receives path without index and without <c>""</c>. Can be the same variable as <i>s</i>.</param>
		/// <param name="index">Receives index/id or 0.</param>
		public static bool parsePathIndex(string s, out string path, out int index) {
			path = s; index = 0;
			if (s.NE()) return false;
			if (s[0] == '"') path = s = s.Replace("\"", ""); //can be eg "path",index
			if (s.Length < 3) return false;
			if (!s[^1].IsAsciiDigit()) return false;
			int i = s.LastIndexOf(','); if (i < 1) return false;
			index = s.ToInt(i + 1, out int e); if (e != s.Length) return false;
			path = s[..i];
			return true;
			
			//note: API PathParseIconLocation has bugs. Eg splits "path,5moreText". Or from "path, 5" removes ", 5" and returns 0.
		}
		
		static int _NormalizeIconSizeArgument(int size) {
			if (size == 0) return 16;
			return (uint)size <= 256 ? size : throw new ArgumentOutOfRangeException("size", "Must be 0 - 256");
		}
		
		//rejected. Not per-monitor-DPI-aware, etc. Better use 16 etc and then auto-scale.
		///// <summary>
		///// Gets size of small icons displayed in UI.
		///// Depends on DPI; 16 when DPI 100%.
		///// </summary>
		//public static int sizeSmall => Dpi.OfThisProcess / 6; //eg 96/6=16
		
		///// <summary>
		///// Gets size of large icons displayed in UI.
		///// Depends on DPI; 32 when DPI 100%.
		///// </summary>
		//public static int sizeLarge => Dpi.OfThisProcess / 3;
		
		//static int _SizeExtraLarge => Dpi.OfThisProcess / 2;
		
		//tested: shell imagelist icon sizes match these.
		//note: don't use GetSystemMetrics(SM_CXSMICON/SM_CXICON). They are for other purposes, eg window title bar, tray icon. On Win7 they can be different because can be changed in Control Panel. Used by SystemInformation.SmallIconSize etc.
		
		/// <summary>
		/// If not 0, "get icon" functions of this class will print (in editor's output) their execution time in milliseconds when it >= this value.
		/// </summary>
		/// <remarks>
		/// Icons are mostly used in toolbars and menus. Getting icons of some files can be slow. For example if antivirus program scans the file. Toolbars and menus that use slow icons may start with a noticeable delay. Use this property to find too slow icons. Then you can replace them with fast icons, for example <c>.ico</c> files.
		/// </remarks>
		public static int debugSpeed { get; set; }
		
		struct _DebugSpeed : IDisposable {
			long _time;
			object _file; //string or Pidl
			
			public _DebugSpeed(object file) {
				if (debugSpeed > 0) {
					_file = file;
					_time = perf.ms;
				} else {
					_time = 0;
					_file = null;
				}
				//TODO3: implement global icon cache here. File-based.
			}
			
			public void Dispose() {
				if (_time != 0) {
					long t = perf.ms - _time;
					if (t >= debugSpeed) {
						//if (_file is Pidl p) _file = p.ToShellString(SIGDN.NORMALDISPLAY);
						print.it($"icon.debugSpeed: {t} ms, {_file}");
					}
				}
			}
		}
		
		/// <summary>
		/// Gets icon path from code that contains string like <c>@"c:\windows\system32\notepad.exe"</c> or <c>@"%folders.System%\notepad.exe"</c> or URL/shell.
		/// Also supports code patterns like <c>folders.System + "notepad.exe"</c> or <c>folders.shell.RecycleBin</c>.
		/// </summary>
		/// <returns><c>null</c> if no such string/pattern.</returns>
		/// <param name="mi"></param>
		/// <param name="cs">The string is <c>.cs</c> filename or relative path, but not full path.</param>
		internal static string ExtractIconPathFromCode_(MethodInfo mi, out bool cs) {
			//support code pattern like 'folders.System + "notepad.exe"'.
			//	Opcodes: call(folders.System), ldstr("notepad.exe"), FolderPath.op_Addition.
			//also code pattern like 'folders.System' or 'folders.shell.RecycleBin'.
			//	Opcodes: call(folders.System), FolderPath.op_Implicit(FolderPath to string).
			//also code pattern like 'run.itSafe("notepad.exe")'.
			//print.it(mi.Name);
			
			cs = false;
			var il = mi.GetMethodBody().GetILAsByteArray();
			if (il.Length > 100) return null;
			
			int i = 0, patternStart = -1; MethodInfo f1 = null; string filename = null, filename2 = null;
			try {
				var reader = new ILReader(mi, il);
				foreach (var instruction in reader.Instructions) {
					if (++i > 100) break;
					var op = instruction.Op;
					//print.it(op);
					if (op == OpCodes.Nop) {
						i--;
					} else if (op == OpCodes.Ldstr) {
						var s = instruction.Data as string;
						//print.it(s);
						//print.it(i, patternStart);
						if (i == patternStart + 1) filename = s;
						else {
							if (pathname.isFullPathExpand(ref s)) return s; //eg run.it(@"%folders.System%\notepad.exe");
							if (pathname.IsShellPathOrUrl_(s)) return s;
							filename = null; patternStart = -1;
							if (i == 1) filename2 = s;
						}
					} else if (op == OpCodes.Call && instruction.Data is MethodInfo f && f.IsStatic) {
						//print.it(f, f.DeclaringType, f.Name, f.MemberType, f.ReturnType, f.GetParameters().Length);
						var dt = f.DeclaringType;
						if (dt == typeof(folders) || dt == typeof(folders.shell)) {
							if (f.ReturnType == typeof(FolderPath) && f.GetParameters().Length == 0) {
								//print.it(1);
								f1 = f;
								patternStart = i;
							}
						} else if (dt == typeof(FolderPath)) {
							if (i == patternStart + 2 && f.Name == "op_Addition") {
								//print.it(2);
								var fp = (FolderPath)f1.Invoke(null, null);
								if (fp.Path == null) return null;
								return fp + filename;
							} else if (i == patternStart + 1 && f.Name == "op_Implicit" && f.ReturnType == typeof(string)) {
								//print.it(3);
								return (FolderPath)f1.Invoke(null, null);
							}
							//} else if (dt == typeof(script)) {
							//	print.it(filename);
						}
					}
				}
				if (filename2 != null) {
					if (filename2.Ends(".exe", true)) return filesystem.searchPath(filename2);
					if (cs = filename2.Ends(".cs", true) && !pathname.isFullPath(filename2, orEnvVar: true)) return filename2;
				}
			}
			catch (Exception ex) { Debug_.Print(ex); }
			return null;
		}
		
		/// <summary>
		/// Gets image of a Windows Store App.
		/// </summary>
		/// <returns><c>Bitmap</c> object, or <c>null</c> if failed. Its size may be != <i>size</i>; let the caller scale it when drawing.</returns>
		/// <param name="shellString">String like <c>@"shell:AppsFolder\Microsoft.WindowsCalculator_8wekyb3d8bbwe!App"</c>.</param>
		/// <param name="size">Desired width and height.</param>
		public static Bitmap winStoreAppImage(string shellString, int size = 16) {
			using var idl = Pidl.FromString(shellString); if (idl == null) return null; //the slowest part, > 90%
			return winStoreAppImage(idl, size);
		}
		
		/// <summary>
		/// Gets image of a Windows Store App. This overload accepts a <see cref="Pidl"/> instead of a shell string.
		/// </summary>
		/// <returns><c>Bitmap</c> object, or <c>null</c> if failed. Its size may be != <i>size</i>; let the caller scale it when drawing.</returns>
		public static Bitmap winStoreAppImage(Pidl pidl, int size = 16) {
			var path = _GetWinStoreAppImagePath(pidl, size); if (path == null) return null;
			//var r = Image.FromFile(path) as Bitmap; //no, locks file
			using var stream = File.OpenRead(path);
			var r = Image.FromStream(stream) as Bitmap;
			r?.SetResolution(96, 96);
			return r;
		}
		
		static string _GetWinStoreAppImagePath(Pidl pidl, int size = 16) {
			if (0 != Api.SHBindToParent(pidl.UnsafePtr, typeof(Api.IShellFolder).GUID, out var isf, out var idItem)) return null;
			if (!isf.GetUIObjectOf(idItem, out Api.IExtractIcon extract)) return null;
			var sb = new StringBuilder(1000);
			if (0 != extract.GetIconLocation(0, sb, sb.Capacity, out int index, out uint rflags)) return null;
			var loc = sb.ToString();
			//print.it(loc);
			if (loc.Ends(".png")) return loc; //Win 8.0, 8.1
			Debug_.PrintIf(!loc.Ends(".png-100"), loc);
			int ipng = loc.LastIndexOf(".png", StringComparison.OrdinalIgnoreCase); if (ipng < 0) return null;
			loc = loc[..ipng];
			if (!_GetPngPathFromIconLoc(out string path)) return null;
			return path;
			
			bool _GetPngPathFromIconLoc(out string path) {
				path = null;
				var dir = pathname.getDirectory(loc);
				if (!filesystem.exists(dir).Directory) return false;
				var a1 = Directory.GetFiles(dir, pathname.getName(loc) + "*.png");
				int nTargetsize = 0, nScale = 0;
				for (int i = 0; i < a1.Length; i++) {
					var v = a1[i];
					if (v.Find("contrast-", loc.Length, true) >= 0) a1[i] = null;
					else if (v.Find("targetsize-", loc.Length, true) >= 0) nTargetsize++;
					else if (v.Find("scale-", loc.Length, true) >= 0) nScale++;
				}
				if (nTargetsize == 0 && nScale == 0) {
					path = a1.FirstOrDefault(o => o.Eqi(loc));
					loc += ".png";
					return path != null;
				}
				var a = new (string path, string q, int size)[nTargetsize > 0 ? nTargetsize : nScale];
				int j = 0;
				foreach (var v in a1) {
					if (v == null) continue;
					int i = v.Find(nTargetsize > 0 ? "targetsize-" : "scale-", loc.Length, true); if (i < 0) continue;
					int z = v.ToInt(i + (nTargetsize > 0 ? 11 : 6));
					if (nTargetsize == 0) z = Math2.MulDiv(z, 16, 100); //assume eg scale-100 == targetsize-16
					a[j++] = (v, v[loc.Length..^4], z);
				}
				//foreach (var k in a) print.it("\t" + k.q, k.size);
				int bestSize = int.MaxValue, maxSmallerSize = 0;
				foreach (var v in a) if (v.size == size) { bestSize = size; break; } else if (v.size > size) bestSize = Math.Min(bestSize, v.size); else maxSmallerSize = Math.Max(maxSmallerSize, v.size);
				if (bestSize == int.MaxValue) bestSize = maxSmallerSize;
				//print.it(bestSize);
				foreach (var v in a) if (v.size == bestSize && v.q.Find("altform-lightunplated", true) >= 0) { path = v.path; return true; }
				//foreach (var v in a) if(v.size==bestSize && v.q.Find("altform-unplated", true)>=0 && v.q.Find("theme-light", true)>=0) { path=v.path; return true; }
				//foreach (var v in a) if(v.size==bestSize && v.q.Find("theme-light", true)>=0) { path=v.path; return true; }
				foreach (var v in a) if (v.size == bestSize && v.q.Find("altform-unplated", true) >= 0) { path = v.path; return true; }
				foreach (var v in a) if (v.size == bestSize) { path = v.path; return true; }
				return false;
			}
		}
	}
}

namespace Au.Types {
	/// <summary>
	/// Flags for <see cref="icon.of"/> and similar functions.
	/// </summary>
	[Flags]
	public enum IconGetFlags {
		/// <summary>
		/// The <i>file</i> argument is literal full path. Don't parse <c>"path,index"</c>, don't support <c>".ext"</c> (file type icon), don't make fully-qualified, etc.
		/// </summary>
		LiteralPath = 1,
		
		/// <summary>
		/// Don't call <see cref="filesystem.searchPath"/>.
		/// </summary>
		DontSearch = 2,
		
#if false
		/// Use shell API for all file types, including exe and ico.
		Shell=8, //rejected because SHGetFileInfo does not get exe icon with shield overlay

		/// <summary>
		/// If file does not exist or fails to get its icon, get common icon for that file type, or default document icon if cannot get common icon.
		/// </summary>
		DefaultIfFails = 16, //rejected. Now for exe/ico/etc is like with shell API: if file exists, gets default icon (exe or document), else returns <c>default(IntPtr)</c>.
#endif
	}
	
#pragma warning disable 1591 //missing XML documentation
	/// <summary>See <see cref="icon.stock"/>, <ms>SHSTOCKICONID</ms>.</summary>
	public enum StockIcon {
		DOCNOASSOC,
		DOCASSOC,
		APPLICATION,
		FOLDER,
		FOLDEROPEN,
		DRIVE525,
		DRIVE35,
		DRIVEREMOVE,
		DRIVEFIXED,
		DRIVENET,
		DRIVENETDISABLED,
		DRIVECD,
		DRIVERAM,
		WORLD,
		SERVER = 15,
		PRINTER,
		MYNETWORK,
		FIND = 22,
		HELP,
		SHARE = 28,
		LINK,
		SLOWFILE,
		RECYCLER,
		RECYCLERFULL,
		MEDIACDAUDIO = 40,
		LOCK = 47,
		AUTOLIST = 49,
		PRINTERNET,
		SERVERSHARE,
		PRINTERFAX,
		PRINTERFAXNET,
		PRINTERFILE,
		STACK,
		MEDIASVCD,
		STUFFEDFOLDER,
		DRIVEUNKNOWN,
		DRIVEDVD,
		MEDIADVD,
		MEDIADVDRAM,
		MEDIADVDRW,
		MEDIADVDR,
		MEDIADVDROM,
		MEDIACDAUDIOPLUS,
		MEDIACDRW,
		MEDIACDR,
		MEDIACDBURN,
		MEDIABLANKCD,
		MEDIACDROM,
		AUDIOFILES,
		IMAGEFILES,
		VIDEOFILES,
		MIXEDFILES,
		FOLDERBACK,
		FOLDERFRONT,
		SHIELD,
		WARNING,
		INFO,
		ERROR,
		KEY,
		SOFTWARE,
		RENAME,
		DELETE,
		MEDIAAUDIODVD,
		MEDIAMOVIEDVD,
		MEDIAENHANCEDCD,
		MEDIAENHANCEDDVD,
		MEDIAHDDVD,
		MEDIABLURAY,
		MEDIAVCD,
		MEDIADVDPLUSR,
		MEDIADVDPLUSRW,
		DESKTOPPC,
		MOBILEPC,
		USERS,
		MEDIASMARTMEDIA,
		MEDIACOMPACTFLASH,
		DEVICECELLPHONE,
		DEVICECAMERA,
		DEVICEVIDEOCAMERA,
		DEVICEAUDIOPLAYER,
		NETWORKCONNECT,
		INTERNET,
		ZIPFILE,
		SETTINGS,
		DRIVEHDDVD = 132,
		DRIVEBD,
		MEDIAHDDVDROM,
		MEDIAHDDVDR,
		MEDIAHDDVDRAM,
		MEDIABDROM,
		MEDIABDR,
		MEDIABDRE,
		CLUSTEREDDRIVE,
		MAX_ICONS = 181
	}
#pragma warning restore 1591
}


================================================
FILE: Au/Files, data/pathname.cs
================================================
//tested: System.IO.Path functions improved in Core.
//	No exceptions if path contains invalid characters. Although the exceptions are still documented in MSDN.
//	Support long paths and file streams.
//	Faster, etc.

namespace Au {
	/// <summary>
	/// File path string functions. Parse, combine, make full, make unique, make valid, expand variables, etc.
	/// </summary>
	/// <remarks>
	/// Most functions of this class work with strings and don't access the file system. Several functions query file system info.
	/// 
	/// Functions of this class don't throw exceptions when path is invalid (path format, invalid characters). Only <see cref="normalize"/> throws exception if not full path.
	/// 
	/// Also you can use .NET class <see cref="Path"/>. In its documentation you'll find more info about paths.
	/// </remarks>
	public static unsafe class pathname { //BAD: why pathname? Better would be eg filepath.
		/// <summary>
		/// If <i>path</i> starts with <c>"%"</c> or <c>"\"%"</c>, expands environment variables enclosed in <c>%</c>, else just returns <i>path</i>.
		/// Also supports known folder names, like <c>"%folders.Documents%"</c>. More info in Remarks.
		/// </summary>
		/// <param name="path">Any string. Can be <c>null</c>.</param>
		/// <param name="strict">
		/// What to do if <i>path</i> looks like starts with and environment variable or known folder but the variable/folder does not exist:
		/// <br/>• <c>true</c> - throw <see cref="ArgumentException"/>;
		/// <br/>• <c>false</c> - return unexpanded path;
		/// <br/>• <c>null</c> (default) - call <see cref="print.warning"/> and return unexpanded path.
		/// </param>
		/// <remarks>
		/// Supports known folder names. See <see cref="folders"/>.
		/// Example: <c>@"%folders.Documents%\file.txt"</c>.
		/// Example: <c>@"%folders.shell.ControlPanel%" //gets ":: ITEMIDLIST"</c>.
		/// Usually known folders are used like <c>string path = folders.Documents + "file.txt"</c>. However it cannot be used when you want to store paths in text files, registry, etc. Then this feature is useful.
		/// To get known folder path, this function calls <see cref="folders.getFolder"/>.
		/// 
		/// This function is called by many functions of classes <see cref="pathname"/>, <see cref="filesystem"/>, <see cref="icon"/>, some others, therefore all they support environment variables and known folders in path string.
		/// </remarks>
		/// <seealso cref="Environment.ExpandEnvironmentVariables"/>
		/// <seealso cref="Environment.GetEnvironmentVariable"/>
		/// <seealso cref="Environment.SetEnvironmentVariable"/>
		public static string expand(string path, bool? strict = null) {
			var s = path;
			if (s.Lenn() < 3) return s;
			if (s[0] != '%') {
				if (s[0] == '"' && s[1] == '%') return "\"" + expand(s[1..], strict);
				return s;
			}
			int i = s.IndexOf('%', 2); if (i < 0) return s;
			//return Environment.ExpandEnvironmentVariables(s); //5 times slower

			//support known folders, like @"%folders.Documents%\...".
			//	rejected: without "folders", like @"%%.Documents%\...". If need really short, can set and use environment variables.
			//if ((i > 10 && s.Starts("%folders.")) || (i > 4 && s.Starts("%%"))) {
			//	var prop = s[(s[1] == '%' ? 2 : 10)..i];
			if (i > 10 && s.Starts("%folders.")) {
				var prop = s[9..i];
				var k = folders.getFolder(prop);
				if (k != null) {
					s = s[++i..];
					string ks = k.Path; if (ks.Starts(":: ")) return ks + s; //don't need \
					return k + s; //add \ if need
				}
				//throw new AuException("folders does not have property " + prop);
			}

			if (!Api.ExpandEnvironmentStrings(s, out s)) {
				var err = "Failed to expand path: " + s;
				if (strict == true) throw new ArgumentException(err);
				if (strict != false) print.warning(err);
				return s;
			}
			return expand(s, strict); //can be %envVar2% in envVar1 value
		}

		/// <summary>
		/// Returns <c>true</c> if the string is full path, like <c>@"C:\a\b.txt"</c> or <c>@"C:"</c> or <c>@"\\server\share\..."</c>:
		/// </summary>
		/// <param name="path">Any string. Can be <c>null</c>.</param>
		/// <param name="orEnvVar">Also return <c>true</c> if starts with <c>"%environmentVariable%"</c> or <c>"%folders.Folder%"</c>. Note: this function does not check whether the variable/folder exists; for it use <see cref="isFullPathExpand"/> instead.</param>
		/// <remarks>
		/// Returns <c>true</c> if <i>path</i> matches one of these wildcard patterns:
		/// - <c>@"?:\*"</c> - local path, like <c>@"C:\a\b.txt"</c>. Here <c>?</c> is A-Z, a-z.
		/// - <c>@"?:"</c> - drive name, like <c>@"C:"</c>. Here <c>?</c> is A-Z, a-z.
		/// - <c>@"\\*"</c> - network path, like <c>@"\\server\share\..."</c>. Or has prefix <c>@"\\?\"</c>.
		/// 
		/// Supports <c>'/'</c> characters too.
		/// 
		/// Supports only file-system paths. Returns <c>false</c> if <i>path</i> is URL (<see cref="isUrl"/>) or starts with <c>"::"</c>.
		/// </remarks>
		public static bool isFullPath(RStr path, bool orEnvVar = false) {
			int len = path.Length;
			if (len >= 2) {
				if (path[1] == ':' && path[0].IsAsciiAlpha()) {
					return len == 2 || IsSepChar_(path[2]);
					//info: returns false if eg "c:abc" which means "abc" in current directory of drive "c:"
				}
				switch (path[0]) {
				case '\\' or '/':
					return IsSepChar_(path[1]);
				case '%' when orEnvVar:
					return path[1..].IndexOf('%') > 1;
				}
			}
			return false;
		}

		/// <summary>
		/// Expands environment variables and calls/returns <see cref="isFullPath"/>.
		/// </summary>
		/// <returns><c>true</c> if the string is full path, like <c>@"C:\a\b.txt"</c> or <c>@"C:"</c> or <c>@"\\server\share\..."</c>.</returns>
		/// <param name="path">
		/// Any string. Can be <c>null</c>.
		/// If starts with <c>'%'</c> character, calls <see cref="expand"/> and then <see cref="isFullPath"/> with expanded environment variables. If it returns <c>true</c>, replaces the passed variable with the expanded path string.
		/// </param>
		/// <param name="strict"><inheritdoc cref="expand(string, bool?)" path="/param[@name='strict']/node()"/></param>
		/// <remarks>
		/// Returns <c>true</c> if <i>path</i> matches one of these wildcard patterns:
		/// - <c>@"?:\*"</c> - local path, like <c>@"C:\a\b.txt"</c>. Here <c>?</c> is A-Z, a-z.
		/// - <c>@"?:"</c> - drive name, like <c>@"C:"</c>. Here <c>?</c> is A-Z, a-z.
		/// - <c>@"\\*"</c> - network path, like <c>@"\\server\share\..."</c>. Or has prefix <c>@"\\?\"</c>.
		/// 
		/// Supports <c>'/'</c> characters too.
		/// Supports only file-system paths. Returns <c>false</c> if <i>path</i> is URL (<see cref="isUrl"/>) or starts with <c>"::"</c>.
		/// </remarks>
		public static bool isFullPathExpand(ref string path, bool? strict = null) => isFullPathExpand(path, out path, strict);
		
		/// <param name="path">
		/// Any string. Can be <c>null</c>.
		/// If starts with <c>'%'</c> character, calls <see cref="expand"/> and then <see cref="isFullPath"/> with expanded environment variables. If it returns <c>true</c>, sets <i>path2</i> = the expanded path string.
		/// </param>
		/// <param name="path2">Receives the final path.</param>
		/// <inheritdoc cref="isFullPathExpand(ref string, bool?)"/>
		public static bool isFullPathExpand(string path, out string path2, bool? strict = null) {
			var s = path2 = path;
			if (s.Lenn() < 2) return false;
			if (s[0] != '%') return isFullPath(s);
			s = expand(s, strict);
			if (s[0] == '%') return false;
			if (!isFullPath(s)) return false;
			path2 = s;
			return true;
		}

		/// <summary>
		/// Gets the length of the drive or network folder part in <i>path</i>, like <c>@"C:\"</c>, <c>@"\\server\share\"</c>, <c>@"\\?\C:\"</c>, <c>@"\\?\UNC\server\share\"</c>, etc.
		/// </summary>
		/// <param name="path">Full path or any string. Can be <c>null</c>. Should not be <c>@"%environmentVariable%\..."</c>.</param>
		/// <remarks>
		/// See <see cref="Path.GetPathRoot"/>.
		/// </remarks>
		public static int getRootLength(RStr path) {
			int i = Path.GetPathRoot(path).Length; //Span, no alloc
			if (i > 0 && i < path.Length && !IsSepChar_(path[i - 1]) && IsSepChar_(path[i])) i++; //@"\\server\share" -> @"\\server\share\"
			return i;
		}

		/// <summary>
		/// Calls <c>Path.GetPathRoot</c>. If no <c>'\\'</c> or <c>'/'</c> at the end, appends <c>"\\"</c>.
		/// Tested: <c>Path.GetPathRoot</c> returns network path like <c>@"\\server\share"</c>. API <c>PathSkipRoot</c> returns with <c>'\\'</c>.
		/// </summary>
		internal static string GetRootBS_(string s) {
			s = Path.GetPathRoot(s);
			if (!Path.EndsInDirectorySeparator(s)) s += "\\";
			return s;
		}

		/// <summary>
		/// Gets the length of the URL protocol name (also known as URI scheme) in string, including <c>':'</c>.
		/// If the string does not start with a protocol name, returns 0.
		/// </summary>
		/// <param name="s">A URL or path or any string. Can be <c>null</c>.</param>
		/// <remarks>
		/// URL examples: <c>"http:"</c> (returns 5), <c>"http://www.x.com"</c> (returns 5), <c>"file:///path"</c> (returns 5), <c>"shell:etc"</c> (returns 6).
		/// 
		/// The protocol can be unknown. The function just checks string format, which is an ASCII alpha character followed by one or more ASCII alpha-numeric, <c>'.'</c>, <c>'-'</c>, <c>'+'</c> characters, followed by <c>':'</c> character.
		/// </remarks>
		public static int getUrlProtocolLength(RStr s) {
			int len = s.Length;
			if (len > 2 && s[0].IsAsciiAlpha() && s[1] != ':') {
				for (int i = 1; i < len; i++) {
					var c = s[i];
					if (c == ':') return i + 1;
					if (!(c.IsAsciiAlphaDigit() || c == '.' || c == '-' || c == '+')) break;
				}
			}
			return 0;
			//info: API PathIsURL lies, like most shlwapi.dll functions.
		}

		/// <summary>
		/// Returns <c>true</c> if the string starts with a URL protocol name (existing or not) and <c>':'</c> character.
		/// Calls <see cref="getUrlProtocolLength"/> and returns <c>true</c> if it's not 0.
		/// </summary>
		/// <param name="s">A URL or path or any string. Can be <c>null</c>.</param>
		/// <remarks>
		/// URL examples: <c>"http:"</c>, <c>"http://www.x.com"</c>, <c>"file:///path"</c>, <c>"shell:etc"</c>.
		/// </remarks>
		public static bool isUrl(RStr s) {
			return 0 != getUrlProtocolLength(s);
		}

		/// <summary>
		/// Combines two path parts using character <c>'\\'</c>. For example directory path and file name.
		/// </summary>
		/// <param name="s1">First part. Usually a directory.</param>
		/// <param name="s2">Second part. Usually a filename or relative path.</param>
		/// <param name="s2CanBeFullPath"><i>s2</i> can be full path. If it is, ignore <i>s1</i> and return <i>s2</i> with expanded environment variables. If <c>false</c> (default), simply combines <i>s1</i> and <i>s2</i>.</param>
		/// <param name="prefixLongPath">Call <see cref="prefixLongPathIfNeed"/> which may prepend <c>@"\\?\"</c> if the result path is very long. Default <c>true</c>.</param>
		/// <remarks>
		/// If <i>s1</i> and <i>s2</i> are <c>null</c> or <c>""</c>, returns <c>""</c>. Else if <i>s1</i> is <c>null</c> or <c>""</c>, returns <i>s2</i>. Else if <i>s2</i> is <c>null</c> or <c>""</c>, returns <i>s1</i>.
		/// Does not expand environment variables. For it use <see cref="expand"/> before, or <see cref="normalize"/> instead. Path that starts with an environment variable here is considered not full path.
		/// Similar to <see cref="Path.Combine"/>. Main differences: has some options; supports <c>null</c> arguments.
		/// </remarks>
		/// <seealso cref="normalize"/>
		public static string combine(string s1, string s2, bool s2CanBeFullPath = false, bool prefixLongPath = true) {
			string r;
			if (s1.NE()) r = s2 ?? "";
			else if (s2.NE()) r = s1 ?? "";
			else if (s2CanBeFullPath && isFullPath(s2)) r = s2;
			else {
				int k = 0;
				if (IsSepChar_(s1[^1])) k |= 1;
				if (IsSepChar_(s2[0])) k |= 2;
				switch (k) {
				case 0: r = s1 + @"\" + s2; break;
				case 3: r = s1 + s2[1..]; break;
				default: r = s1 + s2; break;
				}
			}
			if (prefixLongPath) r = prefixLongPathIfNeed(r);
			return r;
		}

		/// <summary>
		/// Combines two path parts.
		/// Unlike <see cref="combine"/>, fails if some part is empty or <c>@"\"</c> or if <i>s2</i> is <c>@"\\"</c>. Also does not check <i>s2</i> full path.
		/// If fails, throws exception or returns <c>null</c> (if <i>noException</i>).
		/// </summary>
		/// <exception cref="ArgumentException"></exception>
		internal static string Combine_(string s1, string s2, bool noException = false) {
			if (!s1.NE() && !s2.NE()) {
				int k = 0;
				if (IsSepChar_(s1[^1])) {
					if (s1.Length == 1) goto ge;
					k |= 1;
				}
				if (IsSepChar_(s2[0])) {
					if (s2.Length == 1 || IsSepChar_(s2[1])) goto ge;
					k |= 2;
				}
				var r = k switch {
					0 => s1 + @"\" + s2,
					3 => s1 + s2[1..],
					_ => s1 + s2,
				};
				return prefixLongPathIfNeed(r);
			}
			ge:
			if (noException) return null;
			throw new ArgumentException("Empty filename or path.");
		}

		/// <summary>
		/// Returns <c>true</c> if character <c>c is '\\' or '/'</c>.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static bool IsSepChar_(char c) { return c is '\\' or '/'; }

		/// <summary>
		/// Returns <c>true</c> if <i>s</i> starts with <c>"\\"</c>. Supports <c>'/'</c>.
		/// </summary>
		/// <param name="s">Can be <c>null</c>.</param>
		internal static bool StartsWithTwoSlash_(string s) => s.Lenn() >= 2 && IsSepChar_(s[0]) && IsSepChar_(s[1]);

		///// <summary>
		///// Returns <c>true</c> if ends with <c>'\\'</c> or <c>'/'</c>.
		///// </summary>
		//internal static bool EndsWithSep_(RStr s) { return s.Length > 0 && s[^1] is '\\' or '/'; }

		/// <summary>
		/// Returns <c>true</c> if ends with <c>':'</c> preceded by a drive letter, like <c>"C:"</c> or <c>"more\C:"</c>, but not like <c>"moreC:"</c>.
		/// </summary>
		static bool _EndsWithDriveWithoutSep(RStr s) {
			int i = s.Length - 1;
			if (i < 1 || s[i] != ':') return false;
			if (!s[--i].IsAsciiAlpha()) return false;
			if (i > 0 && !IsSepChar_(s[i - 1])) return false;
			return true;
		}

		/// <summary>
		/// If <i>s</i> is like <c>"C:"</c>, returns <c>"C:\"</c>, else returns <i>s</i>.
		/// </summary>
		static string _AddSepToDrive(string s) => _EndsWithDriveWithoutSep(s) ? s + "\\" : s;

		/// <summary>
		/// Makes normal full path from path that can contain special substrings etc.
		/// </summary>
		/// <param name="path">Any path.</param>
		/// <param name="defaultParentDirectory">If <i>path</i> is not full path, combine it with <i>defaultParentDirectory</i> to make full path.</param>
		/// <param name="flags"></param>
		/// <exception cref="ArgumentException"><i>path</i> is not full path, and <i>defaultParentDirectory</i> is not used or does not make it full path.</exception>
		/// <remarks>
		/// The sequence of actions:
		/// 1. If <i>path</i> starts with <c>'%'</c> character, expands environment variables and special folder names. See <see cref="expand"/>.
		/// 2. If <i>path</i> is not full path but looks like URL, and used flag <c>CanBeUrl</c>, returns <i>path</i>.
		/// 3. If <i>path</i> is not full path, and <i>defaultParentDirectory</i> is not <c>null</c>/<c>""</c>, combines <i>path</i> with <c>expand(defaultParentDirectory)</c>.
		/// 4. If <i>path</i> is not full path, throws exception.
		/// 5. If <i>path</i> is like <c>"C:"</c> makes like <c>"C:\"</c>.
		/// 6. Calls API <ms>GetFullPathName</ms>. It replaces <c>'/'</c> with <c>'\\'</c>, replaces multiple <c>'\\'</c> with single (where need), processes <c>@"\.."</c> etc, trims spaces, etc.
		/// 7. If no flag <c>DontExpandDosPath</c>, if <i>path</i> looks like a short DOS path version (contains <c>'~'</c> etc), calls API <ms>GetLongPathName</ms>. It converts short DOS path to normal path, if possible, for example <c>@"c:\progra~1"</c> to <c>@"c:\program files"</c>. It is slow. It converts path only if the file exists.
		/// 8. If no flag <c>DontRemoveEndSeparator</c>, and string ends with <c>'\\'</c> character, and length > 4, removes the <c>'\\'</c>, unless then it would be a path to an existing file (not directory).
		/// 9. If no flag <c>DontPrefixLongPath</c>, calls <see cref="prefixLongPathIfNeed"/>, which adds <c>@"\\?\"</c> etc prefix if path is very long.
		/// 
		/// Similar to <see cref="Path.GetFullPath"/>. Main differences: this function expands environment variables, does not support relative paths (unless used <i>defaultParentDirectory</i>), trims <c>'\\'</c> at the end if need.
		/// </remarks>
		/// <seealso cref="filesystem.more.getFinalPath"/>
		public static string normalize(string path, string defaultParentDirectory = null, PNFlags flags = 0) {
			if (!isFullPathExpand(ref path)) {
				if (0 != (flags & PNFlags.CanBeUrlOrShell)) if (IsShellPathOrUrl_(path)) return path;
				if (defaultParentDirectory.NE()) goto ge;
				path = Combine_(expand(defaultParentDirectory), path);
				if (!isFullPath(path)) goto ge;
			}

			return Normalize_(path, flags, noExpandEV: true);
			ge:
			throw new ArgumentException($"Not full path: '{path}'.");
		}

		/// <summary>
		/// Same as <see cref="normalize"/>, but skips full-path checking.
		/// <i>s</i> should be full path. If not full and not <c>null</c>/<c>""</c>, combines with current directory.
		/// </summary>
		internal static string Normalize_(string s, PNFlags flags = 0, bool noExpandEV = false) {
			if (!s.NE()) {
				if (!noExpandEV) s = expand(s);
				Debug_.PrintIf(IsShellPathOrUrl_(s), s);

				s = _AddSepToDrive(s); //API would append current directory

				//note: although slower, call GetFullPathName always, not just when contains @"..\" etc.
				//	Because it does many things (see Normalize doc), not all documented.
				//	We still ~2 times faster than Path.GetFullPath (tested before Core).
				Api.GetFullPathName(s, out s);

				if (0 == (flags & PNFlags.DontExpandDosPath) && IsPossiblyDos_(s)) s = ExpandDosPath_(s);

				if (0 == (flags & PNFlags.DontRemoveEndSeparator) && IsSepChar_(s[^1]) && s.Length > 4) {
					var s2 = s[..^1];
					if (Api.GetFileAttributes(s2).Has(FileAttributes.Directory)) s = s2; //if does not exist as file
				}

				if (0 == (flags & PNFlags.DontPrefixLongPath)) s = prefixLongPathIfNeed(s);
			}
			return s;
		}

		/// <summary>
		/// Prepares path for passing to API and .NET functions that support <c>".."</c>, DOS path etc.
		/// Calls expand, <c>_AddSepToDrive</c>, <see cref="prefixLongPathIfNeed"/>. By default throws exception if <c>!isFullPath(path)</c>.
		/// </summary>
		/// <exception cref="ArgumentException">Not full path (only if <i>throwIfNotFullPath</i> is <c>true</c>).</exception>
		internal static string NormalizeMinimally_(string path, bool throwIfNotFullPath = true) {
			var s = expand(path);
			Debug_.PrintIf(IsShellPathOrUrl_(s), s);
			if (throwIfNotFullPath && !isFullPath(s)) throw new ArgumentException($"Not full path: '{path}'.");
			s = _AddSepToDrive(s);
			s = prefixLongPathIfNeed(s);
			return s;
		}

		/// <summary>
		/// Calls API <c>GetLongPathName</c>.
		/// Does not check whether <i>s</i> contains <c>'~'</c> character etc. Note: the API is slow.
		/// </summary>
		/// <param name="s">Can be <c>null</c>.</param>
		internal static string ExpandDosPath_(string s) {
			if (!s.NE()) Api.GetLongPathName(s, out s);
			return s;
			//CONSIDER: the API fails if the file does not exist.
			//	Workaround: if filename does not contain '~', pass only the part that contains.
		}

		/// <summary>
		/// Returns <c>true</c> if <i>s</i> looks like a DOS filename or path.
		/// Examples: <c>"abcde~12"</c>, <c>"abcde~12.txt"</c>, <c>@"c:\path\abcde~12.txt"</c>, <c>"c:\abcde~12\path"</c>.
		/// </summary>
		/// <param name="s">Can be <c>null</c>.</param>
		internal static bool IsPossiblyDos_(string s) {
			//print.it(s);
			if (s != null && s.Length >= 8) {
				for (int i = 0; (i = s.IndexOf('~', i + 1)) > 0;) {
					int j = i + 1, k = 0;
					for (; k < 6 && j < s.Length; k++, j++) if (!s[j].IsAsciiDigit()) break;
					if (k == 0) continue;
					char c = j < s.Length ? s[j] : '\\';
					if (c == '\\' || c == '/' || (c == '.' && j == s.Length - 4)) {
						for (j = i; j > 0; j--) {
							c = s[j - 1]; if (c == '\\' || c == '/') break;
						}
						if (j == i - (7 - k)) return true;
					}
				}
			}
			return false;
		}

		/// <summary>
		/// Returns <c>true</c> if starts with <c>"::"</c>.
		/// </summary>
		/// <param name="s">Can be <c>null</c>.</param>
		internal static bool IsShellPath_(RStr s) {
			return s.Length >= 2 && s[0] == ':' && s[1] == ':';
		}

		/// <summary>
		/// Returns <c>true</c> if <c>IsShellPath_(s) || isUrl(s)</c>.
		/// </summary>
		/// <param name="s">Can be <c>null</c>.</param>
		internal static bool IsShellPathOrUrl_(RStr s) => IsShellPath_(s) || isUrl(s);

		/// <summary>
		/// If <i>path</i> is full path (see <see cref="isFullPath"/>) and does not start with <c>@"\\?\"</c>, prepends <c>@"\\?\"</c>.
		/// If <i>path</i> is network path (like <c>@"\\computer\folder\..."</c>), makes like <c>@"\\?\UNC\computer\folder\..."</c>.
		/// </summary>
		/// <param name="path">
		/// Path. Can be <c>null</c>.
		/// Must not start with <c>"%environmentVariable%"</c>. This function does not expand it. See <see cref="expand"/>.
		/// </param>
		/// <remarks>
		/// Windows API kernel functions support extended-length paths, ie longer than 259 characters. But the path must have this prefix. Windows API shell functions don't support it.
		/// </remarks>
		public static string prefixLongPath(string path) {
			var s = path;
			if (isFullPath(s) && 0 == _GetPrefixLength(s)) {
				if (s.Length >= 2 && IsSepChar_(s[0]) && IsSepChar_(s[1])) s = s.ReplaceAt(0, 2, @"\\?\UNC\");
				else s = @"\\?\" + s;
			}
			return s;
		}

		/// <summary>
		/// Calls <see cref="prefixLongPath"/> if <i>path</i> is longer than <see cref="maxDirectoryPathLength"/> (247).
		/// </summary>
		/// <param name="path">
		/// Path. Can be <c>null</c>.
		/// Must not start with <c>"%environmentVariable%"</c>. This function does not expand it. See <see cref="expand"/>.
		/// </param>
		public static string prefixLongPathIfNeed(string path) {
			if (path.Lenn() > maxDirectoryPathLength) path = prefixLongPath(path);
			return path;

			//info: MaxDirectoryPathLength is max length supported by API CreateDirectory.
		}

		/// <summary>
		/// If <i>path</i> starts with <c>@"\\?\"</c> prefix, removes it.
		/// If <i>path</i> starts with <c>@"\\?\UNC\"</c> prefix, removes <c>@"?\UNC\"</c>.
		/// </summary>
		/// <param name="path">
		/// Path. Can be <c>null</c>.
		/// Must not start with <c>"%environmentVariable%"</c>. This function does not expand it. See <see cref="expand"/>.
		/// </param>
		public static string unprefixLongPath(string path) {
			if (!path.NE()) {
				switch (_GetPrefixLength(path)) {
				case 4: return path[4..];
				case 8: return path.Remove(2, 6);
				}
			}
			return path;
		}

		/// <summary>
		/// If <i>s</i> starts with <c>@"\\?\UNC\"</c>, returns 8.
		/// Else if starts with <c>@"\\?\"</c>, returns 4.
		/// Else returns 0.
		/// </summary>
		/// <param name="s">Can be <c>null</c>.</param>
		static int _GetPrefixLength(RStr s) {
			int len = s.Length;
			if (len >= 4 && s[2] == '?' && IsSepChar_(s[0]) && IsSepChar_(s[1]) && IsSepChar_(s[3])) {
				if (len >= 8 && IsSepChar_(s[7]) && s[4..7].Eqi("UNC")) return 8;
				return 4;
			}
			return 0;
		}

		/// <summary>
		/// Maximal file (not directory) path length supported by all functions (native, .NET and this library).
		/// For longer paths need <c>@"\\?\"</c> prefix. It is supported by most native kernel API (but not shell API) and most functions of this library and .NET.
		/// </summary>
		public const int maxFilePathLength = 259;

		/// <summary>
		/// Maximal directory path length supported by all functions (native, .NET and this library).
		/// For longer paths need <c>@"\\?\"</c> prefix. It is supported by most native kernel API (but not shell API) and most functions of this library and .NET.
		/// </summary>
		public const int maxDirectoryPathLength = 247;

		/// <summary>
		/// Replaces characters that cannot be used in file names.
		/// </summary>
		/// <param name="name">Initial filename.</param>
		/// <param name="invalidCharReplacement">A string that will replace each invalid character. Default <c>"-"</c>.</param>
		/// <remarks>
		/// Also corrects other forms of invalid or problematic filename: trims spaces and other blank characters; replaces <c>"."</c> at the end; prepends <c>"@"</c> if a reserved name like <c>"CON"</c> or <c>"CON.txt"</c>; returns <c>"-"</c> if <i>name</i> is <c>null</c>/empty/whitespace.
		/// Usually returns valid filename, however it can be too long (itself or when combined with a directory path).
		/// </remarks>
		public static string correctName(string name, string invalidCharReplacement = "-") {
			if (name == null || (name = name.Trim()).Length == 0) return invalidCharReplacement;
			name = _rxInvalidFN1.Replace(name, invalidCharReplacement).Trim();
			if (_rxInvalidFN2.IsMatch(name)) name = "@" + name;
			return name;
		}

		static regexp _rxInvalidFN1 = new(@"\.$|[\\/|<>?*:""\x00-\x1f]");
		static regexp _rxInvalidFN2 = new(@"(?i)^(CON|PRN|AUX|NUL|COM\d|LPT\d)(\.|$)");

		/// <summary>
		/// Returns <c>true</c> if name cannot be used for a file name, eg contains <c>'\\'</c> etc characters or is empty.
		/// More info: <see cref="correctName"/>.
		/// </summary>
		/// <param name="name">Any string. Example: <c>"name.txt"</c>. Can be <c>null</c>.</param>
		public static bool isInvalidName(string name) {
			if (name == null || (name = name.Trim()).Length == 0) return true;
			return _rxInvalidFN1.IsMatch(name) || _rxInvalidFN2.IsMatch(name);
		}

		/// <summary>
		/// Returns <c>true</c> if character <i>c</i> is invalid in file names (the filename part).
		/// </summary>
		public static bool isInvalidNameChar(char c)
			=> c is < ' ' or '"' or '<' or '>' or '|' or '*' or '?' or ':' or '\\' or '/';

		/// <summary>
		/// Returns <c>true</c> if character <i>c</i> is invalid in file paths.
		/// </summary>
		public static bool isInvalidPathChar(char c)
			=> c is < ' ' or '"' or '<' or '>' or '|' or '*' or '?';

		/// <summary>
		/// Gets filename from <i>path</i>. Does not remove extension.
		/// </summary>
		/// <returns>Returns <c>""</c> if there is no filename. Returns <c>null</c> if <i>path</i> is <c>null</c>.</returns>
		/// <param name="path">Path or filename. Can be <c>null</c>.</param>
		/// <remarks>
		/// Similar to <see cref="Path.GetFileName"/>. Some differences: if ends with <c>'\\'</c> or <c>'/'</c>, gets part before it, eg <c>"B"</c> from <c>@"C:\A\B\"</c>.
		/// 
		/// Supports separators <c>'\\'</c> and <c>'/'</c>.
		/// Also supports URL and shell parsing names like <c>@"::{CLSID-1}\0\::{CLSID-2}"</c>.
		/// 
		/// Examples:
		/// 
		/// | <i>path</i> | result
		/// | -
		/// | <c>@"C:\A\B\file.txt"</c> | <c>"file.txt"</c>
		/// | <c>"file.txt"</c> | <c>"file.txt"</c>
		/// | <c>"file"</c> | <c>"file"</c>
		/// | <c>@"C:\A\B"</c> | <c>"B"</c>
		/// | <c>@"C:\A\B\"</c> | <c>"B"</c>
		/// | <c>@"C:\A\/B\/"</c> | <c>"B"</c>
		/// | <c>@"C:\"</c> | <c>""</c>
		/// | <c>@"C:"</c> | <c>""</c>
		/// | <c>@"\\network\share"</c> | <c>"share"</c>
		/// | <c>@"C:\aa\file.txt:alt.stream"</c> | <c>"file.txt:alt.stream"</c>
		/// | <c>"http://a.b.c"</c> | <c>"a.b.c"</c>
		/// | <c>"::{A}\::{B}"</c> | <c>"::{B}"</c>
		/// | <c>""</c> | <c>""</c>
		/// | <c>null</c> | <c>null</c>
		/// </remarks>
		public static string getName(string path) {
			return _GetPathPart(path, _PathPart.NameWithExt);
		}

		/// <summary>
		/// Gets filename without extension.
		/// </summary>
		/// <returns>Returns <c>""</c> if there is no filename. Returns <c>null</c> if <i>path</i> is <c>null</c>.</returns>
		/// <param name="path">Path or filename (then just removes extension). Can be <c>null</c>.</param>
		/// <remarks>
		/// The same as <see cref="getName"/>, just removes extension.
		/// Similar to <see cref="Path.GetFileNameWithoutExtension"/>. Some differences: if ends with <c>'\\'</c> or <c>'/'</c>, gets part before it, eg <c>"B"</c> from <c>@"C:\A\B\"</c>.
		/// 
		/// Supports separators <c>'\\'</c> and <c>'/'</c>.
		/// Also supports URL and shell parsing names like <c>@"::{CLSID-1}\0\::{CLSID-2}"</c>.
		/// 
		/// Examples:
		/// 
		/// | <i>path</i> | result
		/// | -
		/// | <c>@"C:\A\B\file.txt"</c> | <c>"file"</c>
		/// | <c>"file.txt"</c> | <c>"file"</c>
		/// | <c>"file"</c> | <c>"file"</c>
		/// | <c>@"C:\A\B"</c> | <c>"B"</c>
		/// | <c>@"C:\A\B\"</c> | <c>"B"</c>
		/// | <c>@"C:\A\B.B\"</c> | <c>"B.B"</c>
		/// | <c>@"C:\aa\file.txt:alt.stream"</c> | <c>"file.txt:alt"</c>
		/// | <c>"http://a.b.c"</c> | <c>"a.b"</c>
		/// </remarks>
		public static string getNameNoExt(string path) {
			return _GetPathPart(path, _PathPart.NameWithoutExt);
		}

		/// <summary>
		/// Gets filename extension, like <c>".txt"</c>.
		/// </summary>
		/// <returns>Returns <c>""</c> if there is no extension. Returns <c>null</c> if <i>path</i> is <c>null</c>.</returns>
		/// <param name="path">Path or filename. Can be <c>null</c>.</param>
		/// <remarks>
		/// Supports separators <c>'\\'</c> and <c>'/'</c>.
		/// </remarks>
		public static string getExtension(string path) {
			return _GetPathPart(path, _PathPart.Ext);
		}

		/// <summary>
		/// Gets filename extension and path part without the extension.
		/// More info: <see cref="getExtension(string)"/>.
		/// </summary>
		/// <param name="path">Path or filename. Can be <c>null</c>.</param>
		/// <param name="pathWithoutExtension">Receives path part without the extension. Can be the same variable as <i>path</i>.</param>
		public static string getExtension(string path, out string pathWithoutExtension) {
			var ext = getExtension(path);
			if (ext != null && ext.Length > 0) pathWithoutExtension = path[..^ext.Length];
			else pathWithoutExtension = path;
			return ext;
		}

		/// <summary>
		/// Finds filename extension, like <c>".txt"</c>.
		/// </summary>
		/// <returns>Index of <c>'.'</c> character, or -1 if there is no extension.</returns>
		/// <param name="path">Path or filename. Can be <c>null</c>.</param>
		public static int findExtension(RStr path) {
			int i;
			for (i = path.Length; --i >= 0;) {
				switch (path[i]) {
				case '.': return i;
				case '\\': case '/': /*case ':':*/ return -1;
				}
			}
			return i;
		}

		/// <summary>
		/// Removes filename part from <i>path</i>.
		/// By default also removes separator (<c>'\\'</c> or <c>'/'</c>) if it is not after drive name (eg <c>"C:"</c>).
		/// </summary>
		/// <returns>Returns <c>""</c> if the string is a filename. Returns <c>null</c> if the string is <c>null</c> or a root (like <c>@"C:\"</c> or <c>"C:"</c> or <c>@"\\server\share"</c> or <c>"http:"</c>).</returns>
		/// <param name="path">Path or filename. Can be <c>null</c>.</param>
		/// <param name="withSeparator">Don't remove separator character(s) (<c>'\\'</c> or <c>'/'</c>). See examples.</param>
		/// <remarks>
		/// Similar to <see cref="Path.GetDirectoryName"/>. Some differences: skips <c>'\\'</c> or <c>'/'</c> at the end (eg from <c>@"C:\A\B\"</c> gets <c>@"C:\A"</c>, not <c>@"C:\A\B"</c>); does not replace <c>'/'</c> with <c>'\\'</c>.
		/// 
		/// Parses raw string. You may want to <see cref="normalize"/> it at first.
		/// 
		/// Supports separators <c>'\\'</c> and <c>'/'</c>.
		/// Also supports URL and shell parsing names like <c>@"::{CLSID-1}\0\::{CLSID-2}"</c>.
		/// 
		/// Examples:
		/// 
		/// | <i>path</i> | result
		/// | -
		/// | <c>@"C:\A\B\file.txt"</c> | <c>@"C:\A\B"</c>
		/// | <c>"file.txt"</c> | <c>""</c>
		/// | <c>@"C:\A\B\"</c> | <c>@"C:\A"</c>
		/// | <c>@"C:\A\/B\/"</c> | <c>@"C:\A"</c>
		/// | <c>@"C:\"</c> | <c>null</c>
		/// | <c>@"\\network\share"</c> | <c>null</c>
		/// | <c>"http:"</c> | <c>null</c>
		/// | <c>@"C:\aa\file.txt:alt.stream"</c> | <c>"C:\aa"</c>
		/// | <c>"http://a.b.c"</c> | <c>"http:"</c>
		/// | <c>"::{A}\::{B}"</c> | <c>"::{A}"</c>
		/// | <c>""</c> | <c>""</c>
		/// | <c>null</c> | <c>null</c>
		/// 
		/// Examples when <i>withSeparator</i> <c>true</c>:
		/// 
		/// | <i>path</i> | result
		/// | -
		/// | <c>@"C:\A\B"</c> | <c>@"C:\A\"</c> (not <c>@"C:\A"</c>)
		/// | <c>"http://x.y"</c> | <c>"http://"</c> (not <c>"http:"</c>)
		/// </remarks>
		public static string getDirectory(string path, bool withSeparator = false) {
			return _GetPathPart(path, _PathPart.Dir, withSeparator);
		}

		enum _PathPart { Dir, NameWithExt, NameWithoutExt, Ext, };

		static string _GetPathPart(string s, _PathPart what, bool withSeparator = false) {
			if (s == null) return null;
			int len = s.Length, i, iExt = -1;

			//rtrim '\\' and '/' etc
			for (i = len; i > 0 && IsSepChar_(s[i - 1]); i--) {
				if (what == _PathPart.Ext) return "";
				if (what == _PathPart.NameWithoutExt) what = _PathPart.NameWithExt;
			}
			len = i;

			//if ends with ":" or @":\", it is either drive or URL root or invalid
			if (len > 0 && s[len - 1] == ':' && !IsShellPath_(s)) return (what == _PathPart.Dir) ? null : "";

			//find '\\' or '/'. Also '.' if need.
			//Note: we don't split at ':', which could be used for alt stream or URL port or in shell parsing name as non-separator. This library does not support paths like "C:relative path".
			while (--i >= 0) {
				char c = s[i];
				if (c == '.') {
					if (what < _PathPart.NameWithoutExt) continue;
					if (iExt < 0) iExt = i;
					if (what == _PathPart.Ext) break;
				} else if (c == '\\' || c == '/') {
					break;
				}
			}
			if (iExt >= 0 && iExt == len - 1) iExt = -1; //eg ends with ".."
			if (what == _PathPart.NameWithoutExt && iExt < 0) what = _PathPart.NameWithExt;

			switch (what) {
			case _PathPart.Ext:
				if (iExt >= 0) return s[iExt..];
				break;
			case _PathPart.NameWithExt:
				len -= ++i; if (len == 0) return "";
				return s.Substring(i, len);
			case _PathPart.NameWithoutExt:
				i++;
				return s[i..iExt];
			case _PathPart.Dir:
				//skip multiple separators
				if (!withSeparator && i > 0) {
					for (; i > 0; i--) { var c = s[i - 1]; if (!(c == '\\' || c == '/')) break; }
					if (i == 0) return null;
				}
				if (i > 0) {
					//returns null if i is in root
					int j = getRootLength(s); if (j > 0 && IsSepChar_(s[j - 1])) j--;
					if (i < j) return null;

					if (withSeparator || _EndsWithDriveWithoutSep(s.AsSpan(0, i))) i++;
					return s[..i];
				}
				break;
			}
			return "";
		}

		/// <summary>
		/// Returns <c>true</c> if <i>s</i> is like <c>".ext"</c> and the ext part does not contain characters <c>.\\/:</c> and does not start/end with whitespace.
		/// </summary>
		/// <param name="s">Can be <c>null</c>.</param>
		internal static bool IsExtension_(RStr s) {
			if (s.Length < 2 || s[0] != '.') return false;
			for (int i = 1; i < s.Length; i++) {
				switch (s[i]) {
				case '.' or '\\' or '/' or ':': return false;
				case <= ' ' when i == 1 || i == s.Length - 1: return false;
				}
			}
			return true;
		}

		/// <summary>
		/// Returns <c>true</c> if <i>s</i> is like <c>"protocol:"</c> and not like <c>"c:"</c> or <c>"protocol:more"</c>.
		/// </summary>
		/// <param name="s">Can be <c>null</c>.</param>
		internal static bool IsProtocol_(RStr s) {
			return s.Length > 2 && s[^1] == ':' && getUrlProtocolLength(s) == s.Length;
		}

		/// <summary>
		/// Creates path with unique filename for a new file or directory. 
		/// If the specified path is of an existing file or directory, returns path where the filename part is modified like <c>"file 2.txt"</c>, <c>"file 3.txt"</c> etc. Else returns unchanged <i>path</i>.
		/// </summary>
		/// <param name="path">Suggested full path.</param>
		/// <param name="isDirectory">The path is for a directory. The number is always appended at the very end, not before <c>.extension</c>.</param>
		public static string makeUnique(string path, bool isDirectory) {
			if (!filesystem.exists(path)) return path;
			string ext = isDirectory ? null : getExtension(path, out path);
			for (int i = 2; ; i++) {
				var s = path + " " + i + ext;
				if (!filesystem.exists(s)) return s;
			}
		}
	}
}

namespace Au.Types {
	/// <summary>
	/// Flags for <see cref="pathname.normalize"/>.
	/// </summary>
	[Flags]
	public enum PNFlags {
		/// <summary>Don't call API <ms>GetLongPathName</ms>.</summary>
		DontExpandDosPath = 1,

		/// <summary>Don't call <see cref="pathname.prefixLongPathIfNeed"/>.</summary>
		DontPrefixLongPath = 2,

		/// <summary>Don't remove <c>\</c> character at the end.</summary>
		DontRemoveEndSeparator = 4,

		/// <summary>If path is not a file-system path but looks like URL (eg <c>"http:..."</c> or <c>"file:..."</c>) or starts with <c>"::"</c>, don't throw exception and don't process more (only expand environment variables).</summary>
		CanBeUrlOrShell = 8,
	}
}


================================================
FILE: Au/Files, data/shortcutFile.cs
================================================
namespace Au {
	/// <summary>
	/// Creates shell shortcuts (<c>.lnk</c> files) and gets shortcut properties.
	/// </summary>
	public unsafe sealed class shortcutFile : IDisposable {
		Api.IShellLink _isl;
		Api.IPersistFile _ipf;
		string _lnkPath;
		bool _isOpen;
		bool _changedHotkey;

		/// <summary>
		/// Releases internally used COM objects (<c>IShellLink</c>, <c>IPersistFile</c>).
		/// </summary>
		public void Dispose() {
			if (_isl != null) {
				Api.ReleaseComObject(_ipf); _ipf = null;
				Api.ReleaseComObject(_isl); _isl = null;
			}
		}

		/// <summary>
		/// Returns the internally used <c>IShellLink</c> COM interface.
		/// </summary>
		internal Api.IShellLink IShellLink => _isl;
		//This could be public, but then need to make IShellLink public. It is defined in a non-standard way. Never mind, it is not important.

		shortcutFile(string lnkPath, uint mode) {
			_isl = new Api.ShellLink() as Api.IShellLink;
			_ipf = _isl as Api.IPersistFile;
			_lnkPath = pathname.normalize(lnkPath);
			if (mode != Api.STGM_WRITE && (mode == Api.STGM_READ || filesystem.exists(_lnkPath).File)) {
				AuException.ThrowIfHresultNot0(_ipf.Load(_lnkPath, mode), "*open");
				_isOpen = true;
			}
		}

		/// <summary>
		/// Opens a shortcut file (<c>.lnk</c>) for getting shortcut properties.
		/// </summary>
		/// <param name="lnkPath">Shortcut file (<c>.lnk</c>) path.</param>
		/// <exception cref="ArgumentException">Not full path.</exception>
		/// <exception cref="AuException">Failed to open <c>.lnk</c> file.</exception>
		public static shortcutFile open(string lnkPath) {
			return new shortcutFile(lnkPath, Api.STGM_READ);
		}

		/// <summary>
		/// Creates a new <see cref="shortcutFile"/> instance that can be used to create or replace a shortcut file.
		/// </summary>
		/// <param name="lnkPath">Shortcut file (<c>.lnk</c>) path.</param>
		/// <exception cref="ArgumentException">Not full path.</exception>
		/// <remarks>
		/// You can set properties and finally call <see cref="Save"/>.
		/// If the shortcut file already exists, <c>Save</c> replaces it.
		/// </remarks>
		public static shortcutFile create(string lnkPath) {
			return new shortcutFile(lnkPath, Api.STGM_WRITE);
		}

		/// <summary>
		/// Creates a new <see cref="shortcutFile"/> instance that can be used to create or modify a shortcut file.
		/// </summary>
		/// <param name="lnkPath">Shortcut file (<c>.lnk</c>) path.</param>
		/// <exception cref="ArgumentException">Not full path.</exception>
		/// <exception cref="AuException">Failed to open existing <c>.lnk</c> file.</exception>
		/// <remarks>
		/// Exception if file exists but cannot open it for read-write access.
		/// You can get and set properties and finally call <see cref="Save"/>.
		/// If the shortcut file already exists, <c>Save</c> updates it.
		/// </remarks>
		public static shortcutFile openOrCreate(string lnkPath) {
			return new shortcutFile(lnkPath, Api.STGM_READWRITE);
		}

		/// <summary>
		/// Saves to the shortcut file (<c>.lnk</c>).
		/// </summary>
		/// <exception cref="AuException">Failed to save.</exception>
		/// <remarks>
		/// Creates parent folder if need.
		/// </remarks>
		public void Save() {
			if (_changedHotkey && !_isOpen && filesystem.exists(_lnkPath).File) _UnregisterHotkey(_lnkPath);

			filesystem.createDirectoryFor(_lnkPath);
			AuException.ThrowIfHresultNot0(_ipf.Save(_lnkPath, true), "*save");
		}

		/// <summary>
		/// Gets or sets shortcut target path.
		/// </summary>
		/// <value><c>null</c> if target isn't a file system object, eg Control Panel or URL.</value>
		/// <remarks>The <c>get</c> function gets path with expanded environment variables. If possible, it corrects the target of MSI shortcuts and 64-bit Program Files shortcuts where <c>IShellLink.GetPath</c> lies.</remarks>
		/// <exception cref="AuException">The <c>set</c> function failed.</exception>
		/// <exception cref="ArgumentException">The <c>set</c> function allows max length 259.</exception>
		public string TargetPath {
			get => _CorrectPath(_GetString(_WhatString.Path), true);
			set { AuException.ThrowIfHresultNot0(_isl.SetPath(_Max259(value))); }
		}

		/// <summary>
		/// Gets shortcut target path and does not correct wrong MSI shortcut target.
		/// </summary>
		public string TargetPathRawMSI {
			get => _CorrectPath(_GetString(_WhatString.Path));
		}

		/// <summary>
		/// Gets or sets a non-file-system target (eg Control Panel) through its <ms>ITEMIDLIST</ms>.
		/// </summary>
		/// <remarks>
		/// Also can be used for any target type, but gets raw value, for example MSI shortcut target is incorrect.
		/// Most but not all shortcuts have this property; the <c>get</c> function returns <c>null</c> if the shortcut does not have it.
		/// </remarks>
		/// <exception cref="AuException">The <c>set</c> function failed.</exception>
		public Pidl TargetPidl {
			get => (0 == _isl.GetIDList(out var pidl)) ? new Pidl(pidl) : null;
			set { AuException.ThrowIfHresultNot0(_isl.SetIDList(value?.UnsafePtr ?? default)); GC.KeepAlive(value); }
		}

		/// <summary>
		/// Gets or sets a URL target.
		/// Note: it is a <c>.lnk</c> shortcut, not a <c>.url</c> shortcut.
		/// </summary>
		/// <value>The <c>get</c> function returns string <c>"file:///..."</c> if target is a file.</value>
		/// <exception cref="AuException">The <c>set</c> function failed.</exception>
		public string TargetURL {
			get {
				if (0 != _isl.GetIDList(out var pidl)) return null;
				try { return Pidl.ToShellString(pidl, SIGDN.URL); }
				finally { Marshal.FreeCoTaskMem(pidl); }
			}
			set {
				TargetAnyType = value;
			}
		}

		/// <summary>
		/// Gets or sets target of any type - file/folder, URL, virtual shell object (see <see cref="Pidl"/>).
		/// The string can be used with <see cref="run.it"/>.
		/// </summary>
		/// <exception cref="AuException">The <c>set</c> function failed.</exception>
		public string TargetAnyType {
			get {
				var R = TargetPath; if (R != null) return R; //support MSI etc
				if (0 != _isl.GetIDList(out var pidl)) return null;
				try { return Pidl.ToString(pidl); } finally { Marshal.FreeCoTaskMem(pidl); }
			}
			set {
				var pidl = Pidl.FromString_(value, true);
				try { AuException.ThrowIfHresultNot0(_isl.SetIDList(pidl)); } finally { Marshal.FreeCoTaskMem(pidl); }
			}
		}

		/// <summary>
		/// Gets custom icon file path and icon index.
		/// </summary>
		/// <returns><c>null</c> if the shortcut does not have a custom icon (then you see its target icon).</returns>
		/// <param name="iconIndex">Receives 0 or icon index or negative icon resource id.</param>
		[SkipLocalsInit]
		public string GetIconLocation(out int iconIndex) {
			var b = stackalloc char[1024];
			if (0 != _isl.GetIconLocation(b, 1024, out iconIndex)) return null;
			return _CorrectPath(new(b));
		}

		/// <summary>
		/// Sets icon file path and icon index.
		/// </summary>
		/// <param name="path"></param>
		/// <param name="iconIndex">0 or icon index or negative icon resource id.</param>
		/// <exception cref="AuException"/>
		/// <exception cref="ArgumentException">Max length 259.</exception>
		public void SetIconLocation(string path, int iconIndex = 0) {
			AuException.ThrowIfHresultNot0(_isl.SetIconLocation(_Max259(path), iconIndex));
		}

		/// <summary>
		/// Gets or sets the working directory path.
		/// </summary>
		/// <exception cref="AuException">The <c>set</c> function failed.</exception>
		/// <exception cref="ArgumentException">The <c>set</c> function allows max length 259.</exception>
		public string WorkingDirectory {
			get => _CorrectPath(_GetString(_WhatString.WorkingDirectory));
			set { AuException.ThrowIfHresultNot0(_isl.SetWorkingDirectory(_Max259(value))); } //see Description comments
		}

		/// <summary>
		/// Throws if <i>s</i> longer than 259.
		/// <c>SetPath</c> then would throw without error description. <c>SetIconLocation</c> would limit to 260. <c>SetWorkingDirectory</c> and <c>SetDescription</c> succeed but corrupt the <c>.lnk</c> file. <c>SetArguments</c> OK. Others not tested, rare, never mind.
		/// </summary>
		static string _Max259(string s) => s.Lenn() <= 259 ? s : throw new ArgumentException("max length 259");

		/// <summary>
		/// Gets or sets the command-line arguments.
		/// </summary>
		/// <exception cref="AuException">The <c>set</c> function failed.</exception>
		public string Arguments {
			get => _GetString(_WhatString.Arguments);
			set { AuException.ThrowIfHresultNot0(_isl.SetArguments(value)); }
		}

		/// <summary>
		/// Gets or sets the description text (comment).
		/// </summary>
		/// <exception cref="AuException">The <c>set</c> function failed.</exception>
		/// <exception cref="ArgumentException">The <c>set</c> function allows max length 259.</exception>
		public string Description {
			get => _GetString(_WhatString.Description);
			set { AuException.ThrowIfHresultNot0(_isl.SetDescription(_Max259(value))); }
		}

		/// <summary>
		/// Gets or sets hotkey.
		/// </summary>
		/// <exception cref="ArgumentException">The value for the <c>set</c> function includes <c>Win</c>.</exception>
		/// <exception cref="AuException">The <c>set</c> function failed.</exception>
		public (KMod, KKey) Hotkey {
			get {
				if (0 != _isl.GetHotkey(out ushort k2)) return default;
				uint k = k2;
				return ((KMod)(k >> 8 & 7), (KKey)(k & 0xFF));
			}
			set {
				var (m, k) = value;
				if (0 != (m & ~(KMod.Ctrl | KMod.Alt | KMod.Shift))) throw new ArgumentException("Win not supported");
				AuException.ThrowIfHresultNot0(_isl.SetHotkey(Math2.MakeWord((uint)k, (uint)m)));
				_changedHotkey = true;
			}
		}

		/// <summary>
		/// Gets or sets the window show state.
		/// Most programs ignore it.
		/// </summary>
		/// <value>1 (normal, default), 2 (minimized) or 3 (maximized).</value>
		/// <exception cref="AuException">The <c>set</c> function failed.</exception>
		public int ShowState {
			get => (0 == _isl.GetShowCmd(out var R)) ? R : Api.SW_SHOWNORMAL;
			set { AuException.ThrowIfHresultNot0(_isl.SetShowCmd(value)); }
		}

		//Not implemented wrappers for these IShellLink methods:
		//SetRelativePath, Resolve - not useful.
		//All are easy to call through the IShellLink property.

		#region public static

		/// <summary>
		/// Gets shortcut target path. It also can be a URL or a <ms>ITEMIDLIST</ms> string (see <see cref="Pidl"/>) of a virtual shell object.
		/// Uses <see cref="open"/> and <see cref="TargetAnyType"/>.
		/// </summary>
		/// <param name="lnkPath">Shortcut file (<c>.lnk</c>) path.</param>
		/// <exception cref="AuException">Failed to open.</exception>
		public static string getTarget(string lnkPath) {
			return open(lnkPath).TargetAnyType;
		}

		/// <summary>
		/// If shortcut file exists, unregisters its hotkey and deletes it.
		/// </summary>
		/// <param name="lnkPath"><c>.lnk</c> file path.</param>
		/// <exception cref="AuException">Failed to unregister hotkey.</exception>
		/// <exception cref="Exception">Exceptions of <see cref="filesystem.delete(string, FDFlags)"/>.</exception>
		public static void delete(string lnkPath) {
			if (!filesystem.exists(lnkPath).File) return;
			_UnregisterHotkey(lnkPath);
			filesystem.delete(lnkPath);
		}

		#endregion

		#region private

		/// <exception cref="AuException">Failed to open or save.</exception>
		static void _UnregisterHotkey(string lnkPath) {
			Debug.Assert(filesystem.exists(lnkPath).File);
			using var x = openOrCreate(lnkPath);
			var k = x.Hotkey;
			if (k != default) {
				x.Hotkey = default;
				x.Save();
			}
		}

		enum _WhatString { Path, Arguments, WorkingDirectory, Description }

		[SkipLocalsInit]
		string _GetString(_WhatString what) {
			using FastBuffer<char> b = new();
			for (; ; ) {
				int hr = 1;
				switch (what) {
				case _WhatString.Path: hr = _isl.GetPath(b.p, b.n); break;
				case _WhatString.Arguments: hr = _isl.GetArguments(b.p, b.n); break;
				case _WhatString.WorkingDirectory: hr = _isl.GetWorkingDirectory(b.p, b.n); break;
				case _WhatString.Description: hr = _isl.GetDescription(b.p, b.n); break;
				}
				if (hr != 0) return null;
				if (b.GetString(b.FindStringLength(), out var s, BSFlags.Truncates)) return s;
			}
		}

		string _CorrectPath(string R, bool fixMSI = false) {
			if (R.NE()) return null;

			if (!fixMSI) {
				R = pathname.expand(R);
			} else if (R.Find(@"\Installer\{") > 0) {
				//For MSI shortcuts GetPath gets like "C:\WINDOWS\Installer\{90110409-6000-11D3-8CFE-0150048383C9}\accicons.exe".
				var product = stackalloc char[40];
				var component = stackalloc char[40];
				if (0 != Api.MsiGetShortcutTarget(_lnkPath, product, null, component)) return null;
				//note: for some shortcuts MsiGetShortcutTarget gets empty component. Then MsiGetComponentPath fails.
				//	On my PC was 1 such shortcut - Microsoft Office Excel Viewer.lnk in start menu.
				//	Could not find a workaround.

				int na = 1024; var b = stackalloc char[na];
				int hr = Api.MsiGetComponentPath(product, component, b, ref na);
				if (hr < 0) return null; //eg not installed, just advertised
				if (na == 0) return null;
				R = new(b, 0, na);
				//note: can be a registry key instead of file path. No such shortcuts on my PC.
			}

			//GetPath problem: replaces "c:\program files" with "c:\program files (x86)".
			//These don't help: SLGP_RAWPATH, GetIDList, disabled redirection.
			//GetWorkingDirectory and GetIconLocation get raw path, and envronment variables such as %ProgramFiles% are expanded to (x86) in 32-bit process.
			if (osVersion.is32BitProcessAnd64BitOS) {
				if (_pf == null) { string s = folders.ProgramFilesX86; _pf = s + "\\"; }
				if (R.Starts(_pf, true) && !filesystem.exists(R)) {
					var s2 = R.Remove(_pf.Length - 7, 6);
					if (filesystem.exists(s2)) R = s2;
					//info: "C:\\Program Files (x86)\\" in English, "C:\\Programme (x86)\\" in German etc.
					//never mind: System32 folder also has similar problem, because of redirection.
					//note: ShellExecuteEx also has this problem.
				}
			}

			return R;
		}
		static string _pf;

		#endregion
	}
}


================================================
FILE: Au/Files, data/sqlite.cs
================================================
namespace Au {
	/// <summary>
	/// A SQLite database connection.
	/// Creates/opens/closes database file or in-memory database. Executes SQL, etc.
	/// </summary>
	/// <remarks>
	/// This class wraps a SQLite API object <c>sqlite3*</c> and related <c>sqlite3_x</c> functions. They are documented in the SQLite website.
	/// 
	/// To correctly close the database file, at first need to dispose all child objects, such as <see cref="sqliteStatement"/>, then dispose the <c>sqlite</c> object. To dispose a static <c>sqlite</c> variable, you may want to use <see cref="process.thisProcessExit"/> event. Although this class has a finalizer that disposes the object (closes database), you should always dispose explicitly. Finalizers don't run on process exit.
	/// </remarks>
	/// <seealso cref="sqliteStatement"/>
	/// <example>
	/// <code><![CDATA[
	/// //open database file
	/// using var db = new sqlite(@"C:\test\sqlite.db");
	/// //create table
	/// db.Execute("CREATE TABLE IF NOT EXISTS test(id INTEGER PRIMARY KEY, name TEXT, x INT, guid BLOB, array BLOB)");
	/// 
	/// //add 2 rows of data
	/// using(var trans = db.Transaction()) { //optional, but makes much faster when making multiple changes, and ensures that all or none of these changes are written to the database
	/// 	using(var p = db.Statement("INSERT OR REPLACE INTO test VALUES(?, ?, :x, ?, ?)")) {
	/// 		//assume we want to add values of these variables to the database table
	/// 		int id = 1; string name = "TEXT"; long x = -10; Guid guid = Guid.NewGuid(); int[] arr = new int[] { 1, 2, 3 };
	/// 		//add first row
	/// 		p.Bind(1, id);
	/// 		p.Bind(2, name).BindStruct(4, guid).Bind(5, arr);
	/// 		p.Bind(":x", x);
	/// 		p.Step();
	/// 		//add second row
	/// 		p.Reset().Bind(1, 2).Bind(":x", 123456789012345).Step(); //unbound columns are null
	/// 	}
	/// 	//update single row
	/// 	db.Execute("UPDATE test SET name=?2 WHERE id=?1", 2, "two");
	/// 	//write all this to database
	/// 	trans.Commit();
	/// }
	/// 
	/// //get data
	/// using(var p = db.Statement("SELECT * FROM test")) {
	/// 	while(p.Step()) { //for each row of results
	/// 		print.it(p.GetInt(0), p.GetText(1), p.GetLong(2));
	/// 		print.it(p.GetStruct<Guid>("guid"));
	/// 		print.it(p.GetArray<int>("array"));
	/// 		print.it("----");
	/// 	}
	/// }
	/// //get single value
	/// if(db.Get(out string s1, "SELECT name FROM test WHERE id=?", 1)) print.it(s1); else print.it("not found");
	/// if(db.Get(out int i1, "PRAGMA page_size")) print.it(i1);
	/// ]]></code>
	/// </example>
	public unsafe class sqlite : IDisposable {
		IntPtr _db;
		
		/// <summary>
		/// Opens or creates a database file.
		/// </summary>
		/// <param name="file">
		/// Database file. Can be:
		/// <br/>• Full path. Supports environment variables etc, see <see cref="pathname.expand"/>
		/// <br/>• <c>":memory:"</c> - create a private, temporary in-memory database.
		/// <br/>• <c>""</c> - create a private, temporary on-disk database.
		/// <br/>• Starts with <c>"file:"</c> - see <google>sqlite3_open_v2</google>.
		/// </param>
		/// <param name="flags"><google>sqlite3_open_v2</google> flags. Default: read-write, create file if does not exist (and parent directory).</param>
		/// <param name="sql">
		/// SQL to execute. For example, one or more <c>;</c>-separated <c>PRAGMA</c> statements to configure the database connection. Or even <c>"CREATE TABLE IF NOT EXISTS ..."</c>.
		/// This function also always executes <c>"PRAGMA foreign_keys=ON;PRAGMA secure_delete=ON;"</c>.
		/// </param>
		/// <exception cref="ArgumentException">Not full path.</exception>
		/// <exception cref="SLException">Failed to open database or execute <i>sql</i>.</exception>
		/// <remarks>
		/// Calls <google>sqlite3_open_v2</google>.
		/// 
		/// Sets busy timeout 2000 ms.
		/// 
		/// <note>If a variable of this class is used by multiple threads, use <c>lock(variable) {  }</c> where need.</note>
		/// </remarks>
		public sqlite(string file, SLFlags flags = SLFlags.ReadWriteCreate, string sql = null) {
			Debug.Assert(Assembly.GetCallingAssembly() != typeof(sqlite).Assembly); //don't use sqlite in Au
			
			bool isSpec = file != null && (file.Length == 0 || file == ":memory:" || file.Starts("file:"));
			if (!isSpec) {
				file = pathname.normalize(file);
				if (flags.Has(SLFlags.SQLITE_OPEN_CREATE) && !filesystem.exists(file, true).File) filesystem.createDirectoryFor(file);
			}
			var r = SLApi.sqlite3_open_v2(Convert2.Utf8Encode(file), ref _db, flags, null);
			if (r != 0) {
				Dispose();
				throw new SLException(r, "sqlite3_open " + file);
			}
			SLApi.sqlite3_busy_timeout(_db, 2000);
			Execute("PRAGMA foreign_keys=ON;PRAGMA secure_delete=ON;" + sql);
		}
		
		///
		protected virtual void Dispose(bool disposing) {
			if (_db != default) {
				var r = SLApi.sqlite3_close_v2(_db);
				Debug.Assert(r == 0); SLUtil_.Warn(r, "sqlite3_close");
				_db = default;
			}
		}
		
		/// <summary>
		/// Calls <sqlite>sqlite3_close_v2</sqlite>.
		/// If fails, prints a warning.
		/// </summary>
		public void Dispose() {
			Dispose(true);
			GC.SuppressFinalize(this);
		}
		
		///
		~sqlite() => Dispose(false);
		
		/// <summary><c>sqlite3*</c></summary>
		public static implicit operator IntPtr(sqlite c) => c._db;
		
		/// <summary><c>sqlite3*</c></summary>
		public IntPtr Handle => _db;
		
		/// <summary>
		/// Calls <sqlite>sqlite3_exec</sqlite> to execute one or more SQL statements that don't return data.
		/// </summary>
		/// <param name="sql">SQL statement, or several <c>;</c>-separated statements.</param>
		/// <exception cref="SLException">Failed to execute <i>sql</i>.</exception>
		public void Execute(string sql) {
			var b = Convert2.Utf8Encode(sql);
			byte* es = null; //gets better error text than sqlite3_errstr; sqlite3_errmsg gets nothing after sqlite3_exec.
			var r = SLApi.sqlite3_exec(_db, b, default, default, &es);
			if (r != 0) throw new SLException(r, "sqlite3_exec", SLUtil_.ToStringAndFree(es));
		}
		
		/// <summary>
		/// Executes single SQL statement that does not return data. Binds values.
		/// </summary>
		/// <param name="sql">Single SQL statement.</param>
		/// <param name="bind">
		/// Values that will replace <c>?</c> characters in <i>sql</i>.
		/// Read about SQL parameters in SQLite website. Supported types: <see cref="sqliteStatement.BindAll"/>. Example: <see cref="sqlite"/>.
		/// </param>
		/// <exception cref="SLException">Failed.</exception>
		/// <exception cref="NotSupportedException"><i>sql</i> contains more than single SQL statement.</exception>
		public void Execute(string sql, params object[] bind) {
			using var p = Statement(sql, bind);
			p.Step();
		}
		
		/// <summary>
		/// Executes single SQL statement that does not return data. To bind values calls callback function.
		/// </summary>
		/// <param name="sql">Single SQL statement.</param>
		/// <param name="bind">
		/// Callback function that should bind (<see cref="sqliteStatement.Bind"/>) values to <c>?</c> characters in <i>sql</i>.
		/// Read about SQL parameters in SQLite website.
		/// </param>
		/// <exception cref="SLException">Failed.</exception>
		/// <exception cref="NotSupportedException"><i>sql</i> contains more than single SQL statement.</exception>
		public void Execute(string sql, Action<sqliteStatement> bind) {
			using var p = Statement(sql);
			bind(p);
			p.Step();
		}
		
		/// <summary>
		/// Returns <c>new sqliteStatement(this, sql)</c>.
		/// </summary>
		/// <param name="sql">Single SQL statement. This function does not execute it.</param>
		/// <seealso cref="sqliteStatement"/>
		/// <inheritdoc cref="sqliteStatement(sqlite, string, bool)"/>
		public sqliteStatement Statement(string sql) => new sqliteStatement(this, sql);
		
		/// <summary>
		/// Returns <c>new sqliteStatement(this, sql).BindAll(bind)</c>.
		/// </summary>
		/// <param name="sql">Single SQL statement. This function does not execute it.</param>
		/// <param name="bind">
		/// Values that will replace <c>?</c> characters in <i>sql</i>. Optional.
		/// Read about SQL parameters in SQLite website. Supported types: <see cref="sqliteStatement.BindAll"/>. Example: <see cref="sqlite"/>.
		/// </param>
		/// <exception cref="NotSupportedException">
		/// - <i>sql</i> contains more than single SQL statement.
		/// - A <i>bind</i> value is of an unsupported type.
		/// </exception>
		/// <seealso cref="sqliteStatement"/>
		/// <seealso cref="sqliteStatement.BindAll"/>
		/// <inheritdoc cref="sqliteStatement(sqlite, string, bool)"/>
		/// <inheritdoc cref="sqliteStatement.BindAll" path="/param"/>
		public sqliteStatement Statement(string sql, params object[] bind) => new sqliteStatement(this, sql).BindAll(bind);
		
		#region get
		
		/// <summary>
		/// Executes single SQL statement and gets single value.
		/// </summary>
		/// <returns><c>false</c> if the statement returned no data.</returns>
		/// <param name="value">Receives data.</param>
		/// <exception cref="SLException">Failed.</exception>
		/// <exception cref="NotSupportedException"><i>sql</i> contains more than single SQL statement.</exception>
		/// <remarks>
		/// Also can be used to get <c>uint</c>, <c>short</c>, <c>ushort</c>, <c>byte</c>, <c>sbyte</c>, enum. Will need to cast from <c>int</c>.
		/// </remarks>
		/// <inheritdoc cref="Execute(string, object[])" path="/param"/>
		public bool Get(out int value, string sql, params object[] bind) {
			using var p = Statement(sql, bind);
			bool R = p.Step();
			value = R ? p.GetInt(0) : default;
			return R;
		}
		
		/// <remarks>
		/// Also can be used to get <c>ulong</c>, 64-bit enum, maybe <see cref="DateTime"/>.
		/// </remarks>
		/// <inheritdoc cref="Get(out int, string, object[])"/>
		public bool Get(out long value, string sql, params object[] bind) {
			using var p = Statement(sql, bind);
			bool R = p.Step();
			value = R ? p.GetLong(0) : default;
			return R;
		}
		
		///// <remarks></remarks>
		///// <inheritdoc cref="Get(out int, string, object[])"/>
		//public bool Get(out DateTime value, bool convertToLocal, string sql, params object[] bind)
		//{
		//	using var p = Prepare(sql, bind);
		//	bool R = p.Step();
		//	value = R ? p.GetDateTime(0, convertToLocal) : default;
		//	return R;
		//}
		
		/// <remarks></remarks>
		/// <inheritdoc cref="Get(out int, string, object[])"/>
		public bool Get(out bool value, string sql, params object[] bind) {
			using var p = Statement(sql, bind);
			bool R = p.Step();
			value = R ? p.GetBool(0) : default;
			return R;
		}
		
		/// <remarks>
		/// Also can be used to get <c>float</c>.
		/// </remarks>
		/// <inheritdoc cref="Get(out int, string, object[])"/>
		public bool Get(out double value, string sql, params object[] bind) {
			using var p = Statement(sql, bind);
			bool R = p.Step();
			value = R ? p.GetDouble(0) : default;
			return R;
		}
		
		/// <remarks></remarks>
		/// <inheritdoc cref="Get(out int, string, object[])"/>
		public bool Get(out string value, string sql, params object[] bind) {
			using var p = Statement(sql, bind);
			bool R = p.Step();
			value = R ? p.GetText(0) : default;
			return R;
		}
		
		/// <remarks></remarks>
		/// <inheritdoc cref="Get(out int, string, object[])"/>
		public bool Get<T>(out T[] value, string sql, params object[] bind) where T : unmanaged {
			using var p = Statement(sql, bind);
			bool R = p.Step();
			value = R ? p.GetArray<T>(0) : default;
			return R;
		}
		
		/// <remarks></remarks>
		/// <inheritdoc cref="Get(out int, string, object[])"/>
		public bool Get<T>(out List<T> value, string sql, params object[] bind) where T : unmanaged {
			using var p = Statement(sql, bind);
			bool R = p.Step();
			value = R ? p.GetList<T>(0) : default;
			return R;
		}
		
		//note: can't add overload to get ReadOnlySpan<T>, because it becomes invalid when the func returns.
		
		/// <remarks>
		/// Can be used to get various value types, for example <c>decimal</c>, <see cref="Guid"/>, <see cref="RECT"/>.
		/// </remarks>
		/// <inheritdoc cref="Get(out int, string, object[])"/>
		public bool GetStruct<T>(out T value, string sql, params object[] bind) where T : unmanaged {
			using var p = Statement(sql, bind);
			bool R = p.Step();
			value = R ? p.GetStruct<T>(0) : default;
			return R;
		}
		
		/// <summary>
		/// Executes single SQL statement and returns <c>true</c> if it returns at least one row of data.
		/// </summary>
		/// <remarks>This function is similar to the <c>GetX</c> functions, but it does not retrieve the data.</remarks>
		/// <inheritdoc cref="Get(out int, string, object[])" path="//param|//exception"/>
		public bool Any(string sql, params object[] bind) {
			using var p = Statement(sql, bind);
			return p.Step();
		}
		
		#endregion
		
		/// <summary>
		/// Calls <sqlite>sqlite3_last_insert_rowid</sqlite>.
		/// </summary>
		public long LastInsertRowid => SLApi.sqlite3_last_insert_rowid(_db);
		
		/// <summary>
		/// Calls <sqlite>sqlite3_changes</sqlite>.
		/// </summary>
		public int Changes => SLApi.sqlite3_changes(_db);
		
		/// <summary>
		/// Calls <sqlite>sqlite3_get_autocommit</sqlite>.
		/// </summary>
		public bool IsInTransaction => 0 == SLApi.sqlite3_get_autocommit(_db);
		
		/// <summary>
		/// Returns <c>new SLTransaction(this, sql, sqlOfDispose)</c>.
		/// See <see cref="SLTransaction(sqlite, string, string)"/>.
		/// </summary>
		/// <inheritdoc cref="SLTransaction(sqlite, string, string)"/>
		public SLTransaction Transaction(string sql = "BEGIN", string sqlOfDispose = "ROLLBACK")
			=> new SLTransaction(this, sql, sqlOfDispose);
		
		/// <summary>
		/// Returns <c>true</c> if the table exists.
		/// </summary>
		/// <param name="table">Table name.</param>
		/// <remarks>
		/// This function is slower than <c>"CREATE TABLE IF NOT EXISTS..."</c>.
		/// </remarks>
		public bool TableExists(string table) {
			return Any("SELECT 1 FROM sqlite_master WHERE type='table' AND name=?", table);
		}
		
		#region util
		
		/// <summary>
		/// Returns <c>true</c> if default database text encoding is not UTF-8.
		/// </summary>
		internal bool IsUtf16 {
			get {
				if (__isUtf16 == 0) {
					var t = _RawGetText("PRAGMA encoding") ?? "";
					__isUtf16 = (byte)(t.Starts("UTF-16") ? 2 : 1);
				}
				return __isUtf16 == 2;
			}
		}
		byte __isUtf16; //0 not queried, 1 utf8 or failed, 2 utf16
		
		string _RawGetText(string sql) {
			string r = null;
			fixed (char* p = sql) {
				IntPtr x = default;
				if (0 == SLApi.sqlite3_prepare16_v3(_db, p, -1, 0, ref x, null)) {
					var e = SLApi.sqlite3_step(x);
					Debug.Assert(e == SLError.Row || e == SLError.Done);
					if (e == SLError.Row) r = Convert2.Utf8Decode(SLApi.sqlite3_column_text(x, 0));
					SLApi.sqlite3_finalize(x);
				}
			}
			return r;
		}
		
		#endregion
	}
	
	/// <summary>
	/// Creates and executes a SQLite prepared statement.
	/// </summary>
	/// <remarks>
	/// This class wraps a SQLite API object <sqlite>sqlite3_stmt*</sqlite> and related <c>sqlite3_x</c> functions. They are documented perfectly in the SQLite website.
	/// More info and example: <see cref="sqlite"/>.
	/// <note type="important">A variable of this class can be used by multiple threads, but not simultaneously. Use <c>lock(database) {  }</c> where need.</note>
	/// </remarks>
	public unsafe class sqliteStatement : IDisposable {
		sqlite _db;
		IntPtr _st;
		
		/// <summary>
		/// Calls <sqlite>sqlite3_prepare16_v3</sqlite>.
		/// </summary>
		/// <param name="db"></param>
		/// <param name="sql">Single SQL statement.</param>
		/// <param name="persistent">Use flag <c>SQLITE_PREPARE_PERSISTENT</c>.</param>
		/// <exception cref="SLException">Failed.</exception>
		/// <exception cref="NotSupportedException"><i>sql</i> contains more than single SQL statement.</exception>
		public sqliteStatement(sqlite db, string sql, bool persistent = false) {
			Not_.Null(db);
			_db = db;
			int flags = persistent ? 1 : 0; //SQLITE_PREPARE_PERSISTENT
			fixed (char* p = sql) {
				char* tail = null;
				_Err(SLApi.sqlite3_prepare16_v3(db, p, sql.Length * 2, flags, ref _st, &tail), "sqlite3_prepare");
				if (tail != null && tail - p != sql.Length) throw new NotSupportedException("sql contains more than single SQL statement");
			}
		}
		
		///
		protected virtual void Dispose(bool disposing) {
			if (_st != default) {
				//note: don't throw, because sqlite3_finalize can return error of previous sqlite3_step etc
				SLApi.sqlite3_finalize(_st);
				_st = default;
			}
		}
		
		/// <summary>
		/// Calls <sqlite>sqlite3_finalize</sqlite>.
		/// </summary>
		public void Dispose() {
			Dispose(true);
			GC.SuppressFinalize(this);
		}
		
		///
		~sqliteStatement() => Dispose(false);
		
		/// <summary><c>sqlite3_stmt*</c></summary>
		public static implicit operator IntPtr(sqliteStatement s) => s._st;
		
		/// <summary><c>sqlite3_stmt*</c></summary>
		public IntPtr Handle => _st;
		
		/// <summary>
		/// The database connection.
		/// </summary>
		public sqlite DB => _db;
		
		/// <summary>
		/// Calls <sqlite>sqlite3_step</sqlite>, and returns <c>true</c> if results data available (<sqlite>sqlite3_step</sqlite> returned <c>SQLITE_ROW</c>).
		/// </summary>
		/// <exception cref="SLException">Failed.</exception>
		public bool Step() {
			var r = SLApi.sqlite3_step(_st);
			if (r == SLError.Row) return true;
			if (r != SLError.Done) _Err(r, "sqlite3_step");
			return false;
		}
		
		/// <summary>
		/// Calls <sqlite>sqlite3_reset</sqlite> and/or <sqlite>sqlite3_clear_bindings</sqlite>.
		/// </summary>
		/// <returns>this.</returns>
		/// <param name="resetStatement">Call <sqlite>sqlite3_reset</sqlite>. Default <c>true</c>.</param>
		/// <param name="clearBindings">Call <sqlite>sqlite3_clear_bindings</sqlite>. Default <c>true</c>.</param>
		public sqliteStatement Reset(bool resetStatement = true, bool clearBindings = true) {
			//note: don't throw, because sqlite3_reset can return error of previous sqlite3_step
			if (resetStatement) SLApi.sqlite3_reset(_st);
			if (clearBindings) SLApi.sqlite3_clear_bindings(_st);
			return this;
		}
		
		#region bind
		
		int _B(SLIndexOrName p) {
			if (p.name == null) return p.index;
			int r = SLApi.sqlite3_bind_parameter_index(_st, Convert2.Utf8Encode(p.name));
			if (r == 0) throw new SLException($"Parameter '{p.name}' does not exist in the SQL statement.");
			return r;
		}
		
		/// <summary>Calls <sqlite>sqlite3_bind_int</sqlite>.</summary>
		/// <returns>this.</returns>
		/// <param name="sqlParam">Parameter name or 1-based index.</param>
		/// <exception cref="SLException">Failed.</exception>
		public sqliteStatement Bind(SLIndexOrName sqlParam, int value)
			=> _Err(SLApi.sqlite3_bind_int(_st, _B(sqlParam), value), "sqlite3_bind_int");
		
		/// <summary>Calls <sqlite>sqlite3_bind_int</sqlite>.</summary>
		/// <returns>this.</returns>
		/// <param name="sqlParam">Parameter name or 1-based index.</param>
		/// <exception cref="SLException">Failed.</exception>
		public sqliteStatement Bind(SLIndexOrName sqlParam, uint value)
			=> Bind(sqlParam, (int)value);
		
		/// <summary>Calls <sqlite>sqlite3_bind_int64</sqlite>.</summary>
		/// <returns>this.</returns>
		/// <param name="sqlParam">Parameter name or 1-based index.</param>
		/// <exception cref="SLException">Failed.</exception>
		public sqliteStatement Bind(SLIndexOrName sqlParam, long value)
			=> _Err(SLApi.sqlite3_bind_int64(_st, _B(sqlParam), value), "sqlite3_bind_int64");
		
		/// <summary>Calls <sqlite>sqlite3_bind_int64</sqlite>.</summary>
		/// <returns>this.</returns>
		/// <param name="sqlParam">Parameter name or 1-based index.</param>
		/// <exception cref="SLException">Failed.</exception>
		public sqliteStatement Bind(SLIndexOrName sqlParam, ulong value)
			=> Bind(sqlParam, (long)value);
		
		/// <summary>Calls <google>sqlite3_bind_int</google> (0 or 1).</summary>
		/// <returns>this.</returns>
		/// <param name="sqlParam">Parameter name or 1-based index.</param>
		/// <exception cref="SLException">Failed.</exception>
		public sqliteStatement Bind(SLIndexOrName sqlParam, bool value)
			=> Bind(sqlParam, value ? 1 : 0);
		
		/// <summary>Binds an enum value as <c>int</c> or <c>long</c>. Calls <sqlite>sqlite3_bind_int</sqlite> or <sqlite>sqlite3_bind_int64</sqlite>.</summary>
		/// <returns>this.</returns>
		/// <param name="sqlParam">Parameter name or 1-based index.</param>
		/// <exception cref="SLException">Failed.</exception>
		[MethodImpl(MethodImplOptions.NoInlining)] //ensure that value is copied to the parameter, because must not be smaller than int
		public sqliteStatement Bind<T>(SLIndexOrName sqlParam, T value) where T : unmanaged, Enum
			=> Bind(sqlParam, sizeof(T) == 8 ? *(long*)&value : *(int*)&value);
		
		/// <summary>Calls <sqlite>sqlite3_bind_double</sqlite>.</summary>
		/// <returns>this.</returns>
		/// <param name="sqlParam">Parameter name or 1-based index.</param>
		/// <exception cref="SLException">Failed.</exception>
		public sqliteStatement Bind(SLIndexOrName sqlParam, double value)
			=> _Err(SLApi.sqlite3_bind_double(_st, _B(sqlParam), value), "sqlite3_bind_double");
		
		/// <summary>Calls <sqlite>sqlite3_bind_text16</sqlite>.</summary>
		/// <returns>this.</returns>
		/// <param name="sqlParam">Parameter name or 1-based index.</param>
		/// <exception cref="SLException">Failed.</exception>
		public sqliteStatement Bind(SLIndexOrName sqlParam, string value)
			=> _Err(SLApi.sqlite3_bind_text16(_st, _B(sqlParam), value, (value?.Length ?? 0) * 2), "sqlite3_bind_text16");
		
		/// <summary>Calls <sqlite>sqlite3_bind_blob64</sqlite>.</summary>
		/// <returns>this.</returns>
		/// <param name="sqlParam">Parameter name or 1-based index.</param>
		/// <exception cref="SLException">Failed.</exception>
		public sqliteStatement Bind(SLIndexOrName sqlParam, void* blob, long nBytes)
			=> _Err(SLApi.sqlite3_bind_blob64(_st, _B(sqlParam), blob, nBytes), "sqlite3_bind_blob64");
		
		sqliteStatement _Bind(SLIndexOrName sqlParam, RByte blob) {
			fixed (byte* p = blob) return Bind(sqlParam, p, blob.Length);
		}
		
		/// <summary>Calls <sqlite>sqlite3_bind_blob64</sqlite>.</summary>
		/// <returns>this.</returns>
		/// <param name="sqlParam">Parameter name or 1-based index.</param>
		/// <exception cref="SLException">Failed.</exception>
		public sqliteStatement Bind<T>(SLIndexOrName sqlParam, ReadOnlySpan<T> blob) where T : unmanaged
			=> _Bind(sqlParam, MemoryMarshal.AsBytes(blob));
		
		/// <summary>Calls <sqlite>sqlite3_bind_blob64</sqlite>.</summary>
		/// <returns>this.</returns>
		/// <param name="sqlParam">Parameter name or 1-based index.</param>
		/// <exception cref="SLException">Failed.</exception>
		public sqliteStatement Bind<T>(SLIndexOrName sqlParam, Span<T> blob) where T : unmanaged
			=> _Bind(sqlParam, MemoryMarshal.AsBytes(blob));
		
		/// <summary>Calls <sqlite>sqlite3_bind_blob64</sqlite>.</summary>
		/// <returns>this.</returns>
		/// <param name="sqlParam">Parameter name or 1-based index.</param>
		/// <exception cref="SLException">Failed.</exception>
		public sqliteStatement Bind<T>(SLIndexOrName sqlParam, T[] array) where T : unmanaged
			=> Bind(sqlParam, array.AsSpan());
		
		/// <summary>Calls <sqlite>sqlite3_bind_blob64</sqlite>.</summary>
		/// <returns>this.</returns>
		/// <param name="sqlParam">Parameter name or 1-based index.</param>
		/// <exception cref="SLException">Failed.</exception>
		public sqliteStatement Bind<T>(SLIndexOrName sqlParam, List<T> list) where T : unmanaged
			=> Bind(sqlParam, CollectionsMarshal.AsSpan(list));
		
		/// <summary>Binds a value as blob. Calls <sqlite>sqlite3_bind_blob64</sqlite>.</summary>
		/// <returns>this.</returns>
		/// <param name="sqlParam">Parameter name or 1-based index.</param>
		/// <exception cref="SLException">Failed.</exception>
		/// <remarks>Can be any value type that does not contain fields of reference types. Examples: <see cref="Guid"/>, <see cref="POINT"/>, <c>int</c>, <c>decimal</c>.</remarks>
		public sqliteStatement BindStruct<T>(SLIndexOrName sqlParam, T value) where T : unmanaged
			=> Bind(sqlParam, &value, sizeof(T));
		
		/// <summary>Calls <sqlite>sqlite3_bind_null</sqlite>.</summary>
		/// <returns>this.</returns>
		/// <param name="sqlParam">Parameter name or 1-based index.</param>
		/// <exception cref="SLException">Failed.</exception>
		/// <remarks>Usually don't need to call this function. Unset parameter values are null. The <c>Bind</c> functions set null too if the value is null.</remarks>
		public sqliteStatement BindNull(SLIndexOrName sqlParam)
			=> _Err(SLApi.sqlite3_bind_null(_st, _B(sqlParam)), "sqlite3_bind_null");
		
		//rejected. 1. Currently we don't have a Blob class. 2. Can do in SQL: zeroblob(nBytes).
		///// <summary>Calls <sqlite>sqlite3_bind_zeroblob</sqlite>.</summary>
		///// <returns>this.</returns>
		///// <exception cref="SLException">Failed.</exception>
		//public Statement BindZeroBlob(SLIndexOrName sqlParam, int nBytes)
		//	=> _Err(SLApi.sqlite3_bind_zeroblob(_st, _B(sqlParam), nBytes), "sqlite3_bind_zeroblob");
		
		//rejected. DateTime can be stored in many ways. Let users decide how they want to store it, and explicitly convert to long, string, etc.
		///// <summary>Calls <c>sqlite3_bind_int64(value.ToBinary())</c>.</summary>
		///// <returns>this.</returns>
		///// <exception cref="SLException">Failed.</exception>
		//public Statement Bind(SLIndexOrName sqlParam, DateTime value, bool convertToUtc = false)
		//	=> Bind(sqlParam, (convertToUtc ? value.ToUniversalTime() : value).ToBinary());
		
		/// <summary>
		/// Used by <see cref="BindAll"/>.
		/// </summary>
		internal void BindObject(int i, object v) {
			int k;
			switch (v) {
			case null: BindNull(i); break;
			case int x: k = x; goto gi;
			case uint x: k = (int)x; goto gi;
			case bool x: k = x ? 1 : 0; goto gi;
			case long x: Bind(i, x); break;
			case ulong x: Bind(i, x); break;
			case double x: Bind(i, x); break;
			case float x: Bind(i, x); break;
			case string x: Bind(i, x); break;
			case byte x: k = x; goto gi;
			case sbyte x: k = x; goto gi;
			case short x: k = x; goto gi;
			case ushort x: k = x; goto gi;
			case decimal x: Bind(i, &x, sizeof(decimal)); break;
			case Guid x: Bind(i, &x, sizeof(Guid)); break;
			case Enum x:
				switch (x.GetTypeCode()) {
				case TypeCode.Int64: case TypeCode.UInt64: Bind(i, Convert.ToInt64(v)); break;
				default: k = Convert.ToInt32(v); goto gi;
				}
				break;
			case Array a:
				//never mind: should throw if managed type. Same for List.
				//	It seems .NET does not have a function to check it.
				//	Slow workarounds: https://stackoverflow.com/questions/53968920/how-do-i-check-if-a-type-fits-the-unmanaged-constraint-in-c
				fixed (byte* p = Unsafe.As<byte[]>(a)) Bind(i, p, Buffer.ByteLength(a));
				break;
			//case System.Collections.IList a:
			//	//Can get data pointer and number of elements:
			//	//	var span = CollectionsMarshal.AsSpan(Unsafe.As<List<byte>>(a)).
			//	//But how to get element type size in a safe/fast/clean way?
			//	//	This works, but unsafe etc: Marshal.SizeOf(a.GetType().GetGenericArguments()[0])
			//	//	This does not work: MemoryMarshal.AsBytes(span).
			//	//Or can get array through reflection, but slow and unsafe: var v=a.GetType().GetField("_items", BindingFlags.NonPublic|BindingFlags.Instance).GetValue(i) as Array;
			//	//Or can convert to List<T> with 'dynamic', but first time it adds 72 ms delay (hot CPU).
			//	break;
			default:
				//never mind: this func does not support other types supported by other BindX functions. Quite difficult.
				var t = v.GetType();
				throw new NotSupportedException(t.Name);
				//case DateTime x: Bind(i, x); break;
			}
			return;
			gi: Bind(i, k);
		}
		
		/// <summary>
		/// Binds multiple values of any supported types.
		/// </summary>
		/// <returns>this.</returns>
		/// <param name="values">
		/// Values that will replace <c>?</c> characters in SQL.
		/// Read about SQL parameters in SQLite website. Example: <see cref="sqlite"/>.
		/// Supported types:
		/// <br/>• <c>int</c>, <c>uint</c>, <c>byte</c>, <c>sbyte</c>, <c>short</c>, <c>ushort</c> - calls <sqlite>sqlite3_bind_int</sqlite>.
		/// <br/>• <c>bool</c> - calls <sqlite>sqlite3_bind_int</sqlite> (0 or 1).
		/// <br/>• <c>long</c>, <c>ulong</c> - calls <sqlite>sqlite3_bind_int64</sqlite>.
		/// <br/>• <c>double</c>, <c>float</c> - calls <sqlite>sqlite3_bind_double</sqlite>.
		/// <br/>• <c>string</c> - calls <sqlite>sqlite3_bind_text16</sqlite>.
		/// <br/>• <c>decimal</c> - calls <sqlite>sqlite3_bind_blob64</sqlite>.
		/// <br/>• <c>Guid</c> - calls <sqlite>sqlite3_bind_blob64</sqlite>.
		/// <br/>• <c>Array</c> - calls <sqlite>sqlite3_bind_blob64</sqlite>.
		/// <br/>• An <c>enum</c> type - calls <sqlite>sqlite3_bind_int</sqlite> or <sqlite>sqlite3_bind_int64</sqlite>.
		/// </param>
		/// <exception cref="NotSupportedException">A value is of an unsupported type.</exception>
		/// <exception cref="SLException">Failed.</exception>
		/// <remarks>
		/// For each parameter calls a <c>sqlite3_bind_x</c> function depending on type. Uses index 1, 2 and so on.
		/// This function is an alternative to calling <c>BindX</c> functions for each parameter. However it supports less types and adds boxing overhead.
		/// Does not call <sqlite>sqlite3_reset</sqlite> and <sqlite>sqlite3_clear_bindings</sqlite>. If need, call <see cref="Reset"/> before.
		/// </remarks>
		public sqliteStatement BindAll(params object[] values) {
			if (values != null)
				for (int i = 0; i < values.Length;) {
					object v = values[i];
					BindObject(++i, v);
				}
			return this;
		}
		
		#endregion
		
		#region get
		
		int _C(SLIndexOrName p) {
			if (p.name == null) return p.index;
			int r = ColumnIndex(p.name);
			if (r < 0) throw new SLException($"Column '{p.name}' does not exist in query results.");
			return r;
		}
		
		/// <summary>
		/// Calls <google>sqlite3_column_int</google>.
		/// </summary>
		/// <param name="column">Column name of 0-based index in results.</param>
		/// <exception cref="SLException">The column does not exist in query results.</exception>
		/// <remarks>
		/// Use this function to get integer values of size 4, 2 or 1 bytes: <c>int</c>, <c>uint</c>, <c>short</c>, <c>ushort</c>, <c>byte</c>, <c>sbyte</c>, enum.
		/// </remarks>
		public int GetInt(SLIndexOrName column) {
			int r = SLApi.sqlite3_column_int(_st, _C(column));
			if (r == 0) _WarnGet();
			return r;
		}
		
		/// <summary>
		/// Calls <google>sqlite3_column_int64</google>.
		/// </summary>
		/// <param name="column">Column name of 0-based index in results.</param>
		/// <exception cref="SLException">The column does not exist in query results.</exception>
		/// <remarks>
		/// Use this function to get integer values of size 8 bytes: <c>long</c>, <c>ulong</c>, 64-bit enum, maybe <see cref="DateTime"/>.
		/// </remarks>
		public long GetLong(SLIndexOrName column) {
			long r = SLApi.sqlite3_column_int64(_st, _C(column));
			if (r == 0) _WarnGet();
			return r;
		}
		
		/// <summary>
		/// Calls <google>sqlite3_column_int64</google> and returns <c>true</c> if the value is not 0.
		/// </summary>
		/// <param name="column">Column name of 0-based index in results.</param>
		/// <exception cref="SLException">The column does not exist in query results.</exception>
		public bool GetBool(SLIndexOrName column) => GetLong(column) != 0;
		
		///// <summary>
		///// Calls <c>DateTime.FromBinary(sqlite3_column_int64(column))</c>.
		///// </summary>
		///// <param name="column">Column name of 0-based index in results.</param>
		///// <param name="convertToLocal">If the value in database is stored as UTC, convert to local.</param>
		///// <exception cref="ArgumentException">The value in database is not in the valid DateTime range.</exception>
		///// <seealso cref="Bind(int, DateTime, bool)"/>
		//public DateTime GetDateTime(SLIndexOrName column, bool convertToLocal = false)
		//{
		//	var r = DateTime.FromBinary(GetLong(column)); //info: it's OK if 0/null
		//	if(convertToLocal && r.Kind == DateTimeKind.Utc) r = r.ToLocalTime();
		//	return r;
		//}
		
		/// <summary>
		/// Calls <google>sqlite3_column_double</google>.
		/// </summary>
		/// <param name="column">Column name of 0-based index in results.</param>
		/// <exception cref="SLException">The column does not exist in query results.</exception>
		public double GetDouble(SLIndexOrName column) {
			double r = SLApi.sqlite3_column_double(_st, _C(column));
			if (r == 0) _WarnGet();
			return r;
		}
		
		/// <summary>
		/// Calls <google>sqlite3_column_text</google>.
		/// </summary>
		/// <param name="column">Column name of 0-based index in results.</param>
		/// <exception cref="SLException">The column does not exist in query results.</exception>
		public string GetText(SLIndexOrName column) {
			int icol = _C(column);
			if (_db.IsUtf16) { //both these codes would work, but with long strings can be significantly slower if SQLite has to convert text encoding
				char* t = SLApi.sqlite3_column_text16(_st, icol);
				if (t != null) return new string(t, 0, SLApi.sqlite3_column_bytes16(_st, icol));
			} else {
				byte* t = SLApi.sqlite3_column_text(_st, icol);
				if (t != null) return Encoding.UTF8.GetString(t, SLApi.sqlite3_column_bytes(_st, icol));
			}
			_WarnGet();
			return null;
		}
		
		/// <summary>
		/// Calls <google>sqlite3_column_blob</google>.
		/// </summary>
		/// <returns>The returned memory is managed by SQLite and will become invalid when calling other SQLite functions afterwards. For zero-length BLOB returns <c>null</c>.</returns>
		/// <param name="column">Column name of 0-based index in results.</param>
		/// <param name="nBytes">Blob size.</param>
		/// <exception cref="SLException">The column does not exist in query results.</exception>
		public byte* GetBlob(SLIndexOrName column, out int nBytes) {
			int icol = _C(column);
			var r = (byte*)SLApi.sqlite3_column_blob(_st, icol);
			if (r == null) { nBytes = 0; _WarnGet(); } else nBytes = SLApi.sqlite3_column_bytes(_st, icol);
			return r;
		}
		
		/// <summary>
		/// Calls <google>sqlite3_column_blob</google>.
		/// </summary>
		/// <returns>The returned memory is managed by SQLite and will become invalid when calling other SQLite functions afterwards.</returns>
		/// <param name="column">Column name of 0-based index in results.</param>
		/// <exception cref="SLException">The column does not exist in query results.</exception>
		public RByte GetBlob(SLIndexOrName column) {
			var p = GetBlob(column, out int n);
			return new(p, n);
		}
		
		/// <summary>
		/// Calls <google>sqlite3_column_blob</google>.
		/// </summary>
		/// <returns>The returned memory is managed by SQLite and will become invalid when calling other SQLite functions afterwards.</returns>
		/// <param name="column">Column name of 0-based index in results.</param>
		/// <exception cref="SLException">The column does not exist in query results.</exception>
		public ReadOnlySpan<T> GetBlob<T>(SLIndexOrName column) where T : unmanaged {
			var p = GetBlob(column, out int n);
			return new(p, n / sizeof(T));
		}
		
		/// <summary>
		/// Calls <google>sqlite3_column_blob</google> and creates array.
		/// </summary>
		/// <param name="column">Column name of 0-based index in results.</param>
		/// <exception cref="SLException">The column does not exist in query results.</exception>
		public T[] GetArray<T>(SLIndexOrName column) where T : unmanaged {
			var t = GetBlob(column, out int nb);
			if (t == null) return null;
			if (nb == 0) return [];
			int size = sizeof(T);
			int ne = nb / size; nb = ne * size;
			var r = new T[ne];
			fixed (T* p = r) MemoryUtil.Copy(t, p, nb);
			return r;
		}
		
		/// <summary>
		/// Calls <google>sqlite3_column_blob</google> and creates <c>List&lt;T&gt;</c>.
		/// </summary>
		/// <param name="column">Column name of 0-based index in results.</param>
		/// <exception cref="SLException">The column does not exist in query results.</exception>
		public List<T> GetList<T>(SLIndexOrName column) where T : unmanaged {
			var t = (T*)GetBlob(column, out int nb);
			if (t == null) return null;
			int ne = nb / sizeof(T);
			var r = new List<T>(ne);
			for (int i = 0; i < ne; i++) r.Add(t[i]);
			return r;
		}
		
		/// <summary>
		/// Calls <google>sqlite3_column_blob</google> and creates a variable of any value type that does not have fields of reference types.
		/// </summary>
		/// <param name="column">Column name of 0-based index in results.</param>
		/// <exception cref="SLException">The column does not exist in query results.</exception>
		public T GetStruct<T>(SLIndexOrName column) where T : unmanaged {
			var t = (T*)GetBlob(column, out int nb);
			T r = default;
			if (t != null && nb == sizeof(T)) MemoryUtil.Copy(t, &r, nb);
			return r;
		}
		
		/// <summary>
		/// Calls <sqlite>sqlite3_column_count</sqlite>.
		/// </summary>
		public int ColumnCount => SLApi.sqlite3_column_count(_st);
		
		/// <summary>
		/// Calls <sqlite>sqlite3_column_name</sqlite>.
		/// </summary>
		public string ColumnName(int index) => Convert2.Utf8Decode(SLApi.sqlite3_column_name(_st, index));
		
		/// <summary>
		/// Finds column by name in results.
		/// </summary>
		/// <returns>0-based index, or -1 if not found.</returns>
		/// <param name="name">Column name in results, as returned by <sqlite>sqlite3_column_name</sqlite>. Case-sensitive.</param>
		[SkipLocalsInit]
		public int ColumnIndex(string name) {
			int n = ColumnCount;
			if (n > 0 && !name.NE() && !name.Contains('\0')) {
				Span<byte> sa = stackalloc byte[name.Length * 3];
				var bname = sa[..Encoding.UTF8.GetBytes(name, sa)];
				for (int i = 0; i < n; i++) {
					byte* b = SLApi.sqlite3_column_name(_st, i);
					if (*b == bname[0] && MemoryMarshal.CreateReadOnlySpanFromNullTerminated(b).SequenceEqual(bname)) return i;
				}
			}
			return -1;
		}
		
		#endregion
		
		#region util
		
		[DebuggerStepThrough]
		sqliteStatement _Err(SLError r, string func) {
			if (r != 0 && r != SLError.Row) throw new SLException(r, _db, func);
			return this;
		}
		
		//rejected: not thread-safe. Other .NET wrappers ignore it too.
		//void _Err(string func)
		//{
		//	var r = SLApi.sqlite3_errcode(_db);
		//	if(r != 0 && r != SLError.Row) throw new SLException(r, _db, func);
		//}
		
		/// <summary>
		/// Called by <c>GetX</c> functions when <c>sqlite3_column_x</c> returns <c>null</c>/0.
		/// Shows warning if <sqlite>sqlite3_errcode</sqlite> is not 0 or Row.
		/// Does not throw exception because it is not thread-safe.
		/// </summary>
		void _WarnGet([CallerMemberName] string m_ = null) {
			var r = SLApi.sqlite3_errcode(_db);
			if (r != 0 && r != SLError.Row) SLUtil_.Warn(r, m_, "Note: it may be a false positive if this database connection is used by multiple threads simultaneously without locking.");
		}
		
		#endregion
	}
}

namespace Au.Types {
	/// <summary>
	/// A SQLite transaction or savepoint. The main purpose is to automatically rollback if not explicitly committed.
	/// Usage: <c>using(var trans = new SLTransaction(db)) { ... trans.Commit(); }</c>
	/// </summary>
	public sealed class SLTransaction : IDisposable {
		sqlite _db;
		
		/// <summary>
		/// Begins a SQLite transaction and prepares for automatic rollback if not explicitly committed.
		/// Usage: <c>using(var trans = new SLTransaction(db)) { ... trans.Commit(); }</c>
		/// </summary>
		/// <param name="db"></param>
		/// <param name="sql">SQL to execute now. Default <c>"BEGIN"</c>. For nested transaction use <c>"SAVEPOINT name"</c>.</param>
		/// <param name="sqlOfDispose">
		/// SQL to execute when disposing the <see cref="SLTransaction"/> variable if not called <see cref="Commit"/> or <see cref="Rollback"/>.
		/// Default <c>"ROLLBACK"</c>. For nested transaction use <c>"ROLLBACK TO name"</c>.
		/// See also: <see cref="SqlOfDispose"/>.
		/// </param>
		/// <exception cref="SLException">Failed to execute <i>sql</i>.</exception>
		public SLTransaction(sqlite db, string sql = "BEGIN", string sqlOfDispose = "ROLLBACK") {
			Not_.Null(db);
			db.Execute(sql);
			_db = db;
			SqlOfDispose = sqlOfDispose;
		}
		
		/// <summary>
		/// Calls <see cref="Rollback"/> if not called <see cref="Commit"/> or <see cref="Rollback"/>.
		/// </summary>
		/// <exception cref="SLException">Failed to execute <see cref="SqlOfDispose"/>.</exception>
		public void Dispose() {
			if (_db != null) Rollback(SqlOfDispose);
		}
		
		///
		~SLTransaction() {
			if (_db != null) print.warning($"Non-disposed SLTransaction variable.");
		}
		
		/// <summary>
		/// Executes a rollback SQL (if in transaction) and disables <see cref="Dispose"/>.
		/// Usually don't need to call this function explicitly. It is implicitly called when disposing this variable if the transaction was not committed.
		/// </summary>
		/// <param name="sql">SQL to execute. Default: <see cref="SqlOfDispose"/>.</param>
		/// <exception cref="SLException">Failed to execute <i>sql</i>.</exception>
		public void Rollback(string sql = null) {
			if (_db == null) throw new InvalidOperationException();
			if (sql == null) sql = SqlOfDispose;
			//if(ErrorMessage!=null) print.it(ErrorMessage);
			if (_db.IsInTransaction) //in some cases sqlite rolls back on error
				_db.Execute(sql);
			_db = null;
		}
		
		/// <summary>
		/// Executes a commit SQL and disables <see cref="Dispose"/>.
		/// </summary>
		/// <param name="sql">SQL to execute. Default <c>"COMMIT"</c>. For nested transaction use <c>"RELEASE name"</c>.</param>
		/// <exception cref="SLException">Failed to execute <i>sql</i>.</exception>
		public void Commit(string sql = "COMMIT") {
			if (_db == null) throw new InvalidOperationException();
			_db.Execute(sql);
			_db = null;
		}
		
		/// <summary>
		/// Gets or sets SQL to execute when disposing this variable if not called <see cref="Commit"/> or <see cref="Rollback"/>.
		/// Initially = parameter <c>sqlOfDispose</c> of constructor.
		/// </summary>
		public string SqlOfDispose { get; set; }
		
		//public string ErrorMessage { get; set; }
	}
	
	/// <summary>
	/// Used for parameter types of some <see cref="sqliteStatement"/> functions.
	/// Has implicit conversions from <c>int</c> and <c>string</c>. If <c>int</c>, the value is interpreted as index. If <c>string</c> - as name.
	/// </summary>
	public struct SLIndexOrName {
#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
		public int index;
		public string name;
		SLIndexOrName(int index) { this.index = index; this.name = null; }
		SLIndexOrName(string name) { this.index = 0; this.name = name; }
		public static implicit operator SLIndexOrName(int index) => new(index);
		public static implicit operator SLIndexOrName(string name) => new(name);
#pragma warning restore CS1591
	}
	
	/// <summary>
	/// Exception thrown by <see cref="sqlite"/>, <see cref="sqliteStatement"/> and related types.
	/// </summary>
	public class SLException : Exception {
#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
		public SLException(string message) : base(message) { }
		
		internal SLException(SLError r, string prefix = null, string suffix = null)
			: base(SLUtil_.Concat(prefix, SLApi.Errstr(r), suffix)) {
			Debug.Assert(r != 0 && r != SLError.Done && r != SLError.Row);
			ErrorCode = r;
		}
		
		internal SLException(SLError r, IntPtr db, string prefix = null)
			: base(SLUtil_.Concat(prefix, r, db)) {
			Debug.Assert(r != 0 && r != SLError.Done && r != SLError.Row);
			ErrorCode = r;
		}
#pragma warning restore CS1591
		
		/// <summary>
		/// The called SQLite API function returned this error code.
		/// </summary>
		public SLError ErrorCode { get; private set; }
	}
}

namespace Au.More {
	internal static unsafe class SLUtil_ {
		internal static string ToStringAndFree(byte* utf8) {
			var r = Convert2.Utf8Decode(utf8);
			SLApi.sqlite3_free(utf8);
			return r;
		}
		
		//currently not used
		//internal static void Err(SLError r, sqlite db, string func)
		//{
		//	if(r != 0) throw new SLException(r, db, func);
		//}
		
		internal static void Warn(SLError r, string func, string suffix = null) {
			if (r != 0) print.warning(SLUtil_.Concat(func, SLApi.Errstr(r), suffix));
		}
		
		internal static string Concat(string s1, string s2, string s3) {
			using (new StringBuilder_(out var b)) {
				_Append(s1); _Append(s2); if (s3 != s2) _Append(s3);
				return b.ToString();
				
				void _Append(string s) => b.AppendSentence(s, s?.Starts("sqlite3_") ?? false); //avoid uppercase for function names
			}
		}
		
		internal static string Concat(string s1, SLError r, IntPtr db)
			=> Concat(s1, SLApi.Errstr(r), SLApi.sqlite3_errcode(db) == 0 ? null : SLApi.Errmsg(db));
	}
	
}

================================================
FILE: Au/Files, data/sqlite_api.cs
================================================
using System.IO.Compression;

namespace Au.Types;

#region enum

//Most of these declarations are from System.Data.SQLite library. Modified.

/// <summary>
/// Flags for <see cref="sqlite"/> constructor.
/// </summary>
[Flags]
public enum SLFlags {
	/// <summary>Default flags. <sqlite>SQLITE_OPEN_READWRITE</sqlite> and <sqlite>SQLITE_OPEN_CREATE</sqlite>.</summary>
	ReadWriteCreate = SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE,
	
#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
	SQLITE_OPEN_READONLY = 0x1,
	SQLITE_OPEN_READWRITE = 0x2,
	SQLITE_OPEN_CREATE = 0x4,
	SQLITE_OPEN_URI = 0x40,
	SQLITE_OPEN_NOMUTEX = 0x8000,
	SQLITE_OPEN_FULLMUTEX = 0x10000,
	SQLITE_OPEN_SHAREDCACHE = 0x20000,
	SQLITE_OPEN_PRIVATECACHE = 0x40000,
#pragma warning restore CS1591
}

/// <summary>
/// SQLite API error codes. Also two success codes - Row and Done.
/// </summary>
public enum SLError {
	/// <summary>
	/// Successful result
	/// </summary>
	Ok /* 0 */,
	/// <summary>
	/// SQL error or missing database
	/// </summary>
	Error /* 1 */,
	/// <summary>
	/// Internal logic error in SQLite
	/// </summary>
	Internal /* 2 */,
	/// <summary>
	/// Access permission denied
	/// </summary>
	Perm /* 3 */,
	/// <summary>
	/// Callback routine requested an abort
	/// </summary>
	Abort /* 4 */,
	/// <summary>
	/// The database file is locked
	/// </summary>
	Busy /* 5 */,
	/// <summary>
	/// A table in the database is locked
	/// </summary>
	Locked /* 6 */,
	/// <summary>
	/// A malloc() failed
	/// </summary>
	NoMem /* 7 */,
	/// <summary>
	/// Attempt to write a readonly database
	/// </summary>
	ReadOnly /* 8 */,
	/// <summary>
	/// Operation terminated by <c>sqlite3_interrupt</c>
	/// </summary>
	Interrupt /* 9 */,
	/// <summary>
	/// Some kind of disk I/O error occurred
	/// </summary>
	IoErr /* 10 */,
	/// <summary>
	/// The database disk image is malformed
	/// </summary>
	Corrupt /* 11 */,
	/// <summary>
	/// Unknown opcode in <c>sqlite3_file_control</c>
	/// </summary>
	NotFound /* 12 */,
	/// <summary>
	/// Insertion failed because database is full
	/// </summary>
	Full /* 13 */,
	/// <summary>
	/// Unable to open the database file
	/// </summary>
	CantOpen /* 14 */,
	/// <summary>
	/// Database lock protocol error
	/// </summary>
	Protocol /* 15 */,
	/// <summary>
	/// Database is empty
	/// </summary>
	Empty /* 16 */,
	/// <summary>
	/// The database schema changed
	/// </summary>
	Schema /* 17 */,
	/// <summary>
	/// String or BLOB exceeds size limit
	/// </summary>
	TooBig /* 18 */,
	/// <summary>
	/// Abort due to constraint violation
	/// </summary>
	Constraint /* 19 */,
	/// <summary>
	/// Data type mismatch
	/// </summary>
	Mismatch /* 20 */,
	/// <summary>
	/// Library used incorrectly
	/// </summary>
	Misuse /* 21 */,
	/// <summary>
	/// Uses OS features not supported on host
	/// </summary>
	NoLfs /* 22 */,
	/// <summary>
	/// Authorization denied
	/// </summary>
	Auth /* 23 */,
	/// <summary>
	/// Auxiliary database format error
	/// </summary>
	Format /* 24 */,
	/// <summary>
	/// 2nd parameter to <c>sqlite3_bind</c> out of range
	/// </summary>
	Range /* 25 */,
	/// <summary>
	/// File opened that is not a database file
	/// </summary>
	NotADb /* 26 */,
	/// <summary>
	/// Notifications from <c>sqlite3_log</c>
	/// </summary>
	Notice /* 27 */,
	/// <summary>
	/// Warnings from <c>sqlite3_log</c>
	/// </summary>
	Warning /* 28 */,
	/// <summary>
	/// <c>sqlite3_step</c> has another row ready
	/// </summary>
	Row = 100,
	/// <summary>
	/// <c>sqlite3_step</c> has finished executing
	/// </summary>
	Done /* 101 */,
	///// <summary>
	///// Used to mask off extended result codes
	///// </summary>
	//NonExtendedMask = 0xFF,
	
#if false
	/////////////////////////////////////////////////////////////////////////
	// BEGIN EXTENDED RESULT CODES
	/////////////////////////////////////////////////////////////////////////

	/// <summary>
	/// A collation sequence was referenced by a schema and it cannot be
	/// found.
	/// </summary>
	Error_Missing_CollSeq = (Error | (1 << 8)),
	/// <summary>
	/// An internal operation failed and it may succeed if retried.
	/// </summary>
	Error_Retry = (Error | (2 << 8)),
	/// <summary>
	/// A file read operation failed.
	/// </summary>
	IoErr_Read = (IoErr | (1 << 8)),
	/// <summary>
	/// A file read operation returned less data than requested.
	/// </summary>
	IoErr_Short_Read = (IoErr | (2 << 8)),
	/// <summary>
	/// A file write operation failed.
	/// </summary>
	IoErr_Write = (IoErr | (3 << 8)),
	/// <summary>
	/// A file synchronization operation failed.
	/// </summary>
	IoErr_Fsync = (IoErr | (4 << 8)),
	/// <summary>
	/// A directory synchronization operation failed.
	/// </summary>
	IoErr_Dir_Fsync = (IoErr | (5 << 8)),
	/// <summary>
	/// A file truncate operation failed.
	/// </summary>
	IoErr_Truncate = (IoErr | (6 << 8)),
	/// <summary>
	/// A file metadata operation failed.
	/// </summary>
	IoErr_Fstat = (IoErr | (7 << 8)),
	/// <summary>
	/// A file unlock operation failed.
	/// </summary>
	IoErr_Unlock = (IoErr | (8 << 8)),
	/// <summary>
	/// A file lock operation failed.
	/// </summary>
	IoErr_RdLock = (IoErr | (9 << 8)),
	/// <summary>
	/// A file delete operation failed.
	/// </summary>
	IoErr_Delete = (IoErr | (10 << 8)),
	/// <summary>
	/// Not currently used.
	/// </summary>
	IoErr_Blocked = (IoErr | (11 << 8)),
	/// <summary>
	/// Out-of-memory during a file operation.
	/// </summary>
	IoErr_NoMem = (IoErr | (12 << 8)),
	/// <summary>
	/// A file existence/status operation failed.
	/// </summary>
	IoErr_Access = (IoErr | (13 << 8)),
	/// <summary>
	/// A check for a reserved lock failed.
	/// </summary>
	IoErr_CheckReservedLock = (IoErr | (14 << 8)),
	/// <summary>
	/// A file lock operation failed.
	/// </summary>
	IoErr_Lock = (IoErr | (15 << 8)),
	/// <summary>
	/// A file close operation failed.
	/// </summary>
	IoErr_Close = (IoErr | (16 << 8)),
	/// <summary>
	/// A directory close operation failed.
	/// </summary>
	IoErr_Dir_Close = (IoErr | (17 << 8)),
	/// <summary>
	/// A shared memory open operation failed.
	/// </summary>
	IoErr_ShmOpen = (IoErr | (18 << 8)),
	/// <summary>
	/// A shared memory size operation failed.
	/// </summary>
	IoErr_ShmSize = (IoErr | (19 << 8)),
	/// <summary>
	/// A shared memory lock operation failed.
	/// </summary>
	IoErr_ShmLock = (IoErr | (20 << 8)),
	/// <summary>
	/// A shared memory map operation failed.
	/// </summary>
	IoErr_ShmMap = (IoErr | (21 << 8)),
	/// <summary>
	/// A file seek operation failed.
	/// </summary>
	IoErr_Seek = (IoErr | (22 << 8)),
	/// <summary>
	/// A file delete operation failed because it does not exist.
	/// </summary>
	IoErr_Delete_NoEnt = (IoErr | (23 << 8)),
	/// <summary>
	/// A file memory mapping operation failed.
	/// </summary>
	IoErr_Mmap = (IoErr | (24 << 8)),
	/// <summary>
	/// The temporary directory path could not be obtained.
	/// </summary>
	IoErr_GetTempPath = (IoErr | (25 << 8)),
	/// <summary>
	/// A path string conversion operation failed.
	/// </summary>
	IoErr_ConvPath = (IoErr | (26 << 8)),
	/// <summary>
	/// Reserved.
	/// </summary>
	IoErr_VNode = (IoErr | (27 << 8)),
	/// <summary>
	/// An attempt to authenticate failed.
	/// </summary>
	IoErr_Auth = (IoErr | (28 << 8)),
	/// <summary>
	/// An attempt to begin a file system transaction failed.
	/// </summary>
	IoErr_Begin_Atomic = (IoErr | (29 << 8)),
	/// <summary>
	/// An attempt to commit a file system transaction failed.
	/// </summary>
	IoErr_Commit_Atomic = (IoErr | (30 << 8)),
	/// <summary>
	/// An attempt to rollback a file system transaction failed.
	/// </summary>
	IoErr_Rollback_Atomic = (IoErr | (31 << 8)),
	/// <summary>
	/// A database table is locked in shared-cache mode.
	/// </summary>
	Locked_SharedCache = (Locked | (1 << 8)),
	/// <summary>
	/// A virtual table in the database is locked.
	/// </summary>
	Locked_Vtab = (Locked | (2 << 8)),
	/// <summary>
	/// A database file is locked due to a recovery operation.
	/// </summary>
	Busy_Recovery = (Busy | (1 << 8)),
	/// <summary>
	/// A database file is locked due to snapshot semantics.
	/// </summary>
	Busy_Snapshot = (Busy | (2 << 8)),
	/// <summary>
	/// A database file cannot be opened because no temporary directory is available.
	/// </summary>
	CantOpen_NoTempDir = (CantOpen | (1 << 8)),
	/// <summary>
	/// A database file cannot be opened because its path represents a directory.
	/// </summary>
	CantOpen_IsDir = (CantOpen | (2 << 8)),
	/// <summary>
	/// A database file cannot be opened because its full path could not be obtained.
	/// </summary>
	CantOpen_FullPath = (CantOpen | (3 << 8)),
	/// <summary>
	/// A database file cannot be opened because a path string conversion operation failed.
	/// </summary>
	CantOpen_ConvPath = (CantOpen | (4 << 8)),
	/// <summary>
	/// A virtual table is malformed.
	/// </summary>
	Corrupt_Vtab = (Corrupt | (1 << 8)),
	/// <summary>
	/// A required sequence table is missing or corrupt.
	/// </summary>
	Corrupt_Sequence = (Corrupt | (2 << 8)),
	/// <summary>
	/// A database file is read-only due to a recovery operation.
	/// </summary>
	ReadOnly_Recovery = (ReadOnly | (1 << 8)),
	/// <summary>
	/// A database file is read-only because a lock could not be obtained.
	/// </summary>
	ReadOnly_CantLock = (ReadOnly | (2 << 8)),
	/// <summary>
	/// A database file is read-only because it needs rollback processing.
	/// </summary>
	ReadOnly_Rollback = (ReadOnly | (3 << 8)),
	/// <summary>
	/// A database file is read-only because it was moved while open.
	/// </summary>
	ReadOnly_DbMoved = (ReadOnly | (4 << 8)),
	/// <summary>
	/// The shared-memory file is read-only and it should be read-write.
	/// </summary>
	ReadOnly_CantInit = (ReadOnly | (5 << 8)),
	/// <summary>
	/// Unable to create journal file because the directory is read-only.
	/// </summary>
	ReadOnly_Directory = (ReadOnly | (6 << 8)),
	/// <summary>
	/// An operation is being aborted due to rollback processing.
	/// </summary>
	Abort_Rollback = (Abort | (2 << 8)),
	/// <summary>
	/// A <c>CHECK</c> constraint failed.
	/// </summary>
	Constraint_Check = (Constraint | (1 << 8)),
	/// <summary>
	/// A commit hook produced a unsuccessful return code.
	/// </summary>
	Constraint_CommitHook = (Constraint | (2 << 8)),
	/// <summary>
	/// A <c>FOREIGN KEY</c> constraint failed.
	/// </summary>
	Constraint_ForeignKey = (Constraint | (3 << 8)),
	/// <summary>
	/// Not currently used.
	/// </summary>
	Constraint_Function = (Constraint | (4 << 8)),
	/// <summary>
	/// A <c>NOT NULL</c> constraint failed.
	/// </summary>
	Constraint_NotNull = (Constraint | (5 << 8)),
	/// <summary>
	/// A <c>PRIMARY KEY</c> constraint failed.
	/// </summary>
	Constraint_PrimaryKey = (Constraint | (6 << 8)),
	/// <summary>
	/// The <c>RAISE</c> function was used by a trigger-program.
	/// </summary>
	Constraint_Trigger = (Constraint | (7 << 8)),
	/// <summary>
	/// A <c>UNIQUE</c> constraint failed.
	/// </summary>
	Constraint_Unique = (Constraint | (8 << 8)),
	/// <summary>
	/// Not currently used.
	/// </summary>
	Constraint_Vtab = (Constraint | (9 << 8)),
	/// <summary>
	/// A <c>ROWID</c> constraint failed.
	/// </summary>
	Constraint_RowId = (Constraint | (10 << 8)),
	/// <summary>
	/// Frames were recovered from the WAL log file.
	/// </summary>
	Notice_Recover_Wal = (Notice | (1 << 8)),
	/// <summary>
	/// Pages were recovered from the journal file.
	/// </summary>
	Notice_Recover_Rollback = (Notice | (2 << 8)),
	/// <summary>
	/// An automatic index was created to process a query.
	/// </summary>
	Warning_AutoIndex = (Warning | (1 << 8)),
	/// <summary>
	/// User authentication failed.
	/// </summary>
	Auth_User = (Auth | (1 << 8)),
	/// <summary>
	/// Success.  Prevents the extension from unloading until the process
	/// terminates.
	/// </summary>
	Ok_Load_Permanently = (Ok | (1 << 8))
#endif
}

#if false
	// These are the options to the internal sqlite3_config call.
internal enum Config
{
	SQLITE_CONFIG_NONE = 0, // nil
	SQLITE_CONFIG_SINGLETHREAD = 1, // nil
	SQLITE_CONFIG_MULTITHREAD = 2, // nil
	SQLITE_CONFIG_SERIALIZED = 3, // nil
	SQLITE_CONFIG_MALLOC = 4, // sqlite3_mem_methods*
	SQLITE_CONFIG_GETMALLOC = 5, // sqlite3_mem_methods*
	SQLITE_CONFIG_SCRATCH = 6, // void*, int sz, int N
	SQLITE_CONFIG_PAGECACHE = 7, // void*, int sz, int N
	SQLITE_CONFIG_HEAP = 8, // void*, int nByte, int min
	SQLITE_CONFIG_MEMSTATUS = 9, // boolean
	SQLITE_CONFIG_MUTEX = 10, // sqlite3_mutex_methods*
	SQLITE_CONFIG_GETMUTEX = 11, // sqlite3_mutex_methods*
								 // previously SQLITE_CONFIG_CHUNKALLOC 12 which is now unused
	SQLITE_CONFIG_LOOKASIDE = 13, // int int
	SQLITE_CONFIG_PCACHE = 14, // sqlite3_pcache_methods*
	SQLITE_CONFIG_GETPCACHE = 15, // sqlite3_pcache_methods*
	SQLITE_CONFIG_LOG = 16, // xFunc, void*
	SQLITE_CONFIG_URI = 17, // int
	SQLITE_CONFIG_PCACHE2 = 18, // sqlite3_pcache_methods2*
	SQLITE_CONFIG_GETPCACHE2 = 19, // sqlite3_pcache_methods2*
	SQLITE_CONFIG_COVERING_INDEX_SCAN = 20, // int
	SQLITE_CONFIG_SQLLOG = 21, // xSqllog, void*
	SQLITE_CONFIG_MMAP_SIZE = 22, // sqlite3_int64, sqlite3_int64
	SQLITE_CONFIG_WIN32_HEAPSIZE = 23, // int nByte
	SQLITE_CONFIG_PCACHE_HDRSZ = 24, // int *psz
	SQLITE_CONFIG_PMASZ = 25 // unsigned int szPma
}

internal enum ConfigDb
{
	/// <summary>
	/// This value represents an unknown (or invalid) option, do not use it.
	/// </summary>
	SQLITE_DBCONFIG_NONE = 0, // nil

	/// <summary>
	/// This option is used to change the name of the "main" database
	/// schema.  The sole argument is a pointer to a constant UTF-8 string
	/// which will become the new schema name in place of "main".
	/// </summary>
	SQLITE_DBCONFIG_MAINDBNAME = 1000, // char*

	/// <summary>
	/// This option is used to configure the lookaside memory allocator.
	/// The value must be an array with three elements.  The second element
	/// must be an <see cref="Int32" /> containing the size of each buffer
	/// slot.  The third element must be an <see cref="Int32" /> containing
	/// the number of slots.  The first element must be an <see cref="IntPtr" />
	/// that points to a native memory buffer of bytes equal to or greater
	/// than the product of the second and third element values.
	/// </summary>
	SQLITE_DBCONFIG_LOOKASIDE = 1001, // void* int int

	/// <summary>
	/// This option is used to enable or disable the enforcement of
	/// foreign key constraints.
	/// </summary>
	SQLITE_DBCONFIG_ENABLE_FKEY = 1002, // int int*

	/// <summary>
	/// This option is used to enable or disable triggers.
	/// </summary>
	SQLITE_DBCONFIG_ENABLE_TRIGGER = 1003, // int int*

	/// <summary>
	/// This option is used to enable or disable the two-argument version
	/// of the <c>fts3_tokenizer</c> function which is part of the FTS3 full-text
	/// search engine extension.
	/// </summary>
	SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER = 1004, // int int*

	/// <summary>
	/// This option is used to enable or disable the loading of extensions.
	/// </summary>
	SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION = 1005, // int int*

	/// <summary>
	/// This option is used to enable or disable the automatic checkpointing
	/// when a WAL database is closed.
	/// </summary>
	SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE = 1006, // int int*

	/// <summary>
	/// This option is used to enable or disable the query planner stability
	/// guarantee (QPSG).
	/// </summary>
	SQLITE_DBCONFIG_ENABLE_QPSG = 1007, // int int*

	/// <summary>
	/// This option is used to enable or disable the extra <c>EXPLAIN QUERY PLAN</c>
	/// output for trigger programs.
	/// </summary>
	SQLITE_DBCONFIG_TRIGGER_EQP = 1008, // int int*

	/// <summary>
	/// This option is used as part of the process to reset a database back
	/// to an empty state.  Because resetting a database is destructive and
	/// irreversible, the process requires the use of this obscure flag and
	/// multiple steps to help ensure that it does not happen by accident.
	/// </summary>
	SQLITE_DBCONFIG_RESET_DATABASE = 1009 // int int*
}

internal enum TypeAffinity
{
	/// <summary>
	/// All integers in SQLite default to Int64
	/// </summary>
	Int64 = 1,
	/// <summary>
	/// All floating point numbers in SQLite default to double
	/// </summary>
	Double = 2,
	/// <summary>
	/// The default data type of SQLite is text
	/// </summary>
	Text = 3,
	/// <summary>
	/// Typically blob types are only seen when returned from a function
	/// </summary>
	Blob = 4,
	/// <summary>
	/// Null types can be returned from functions
	/// </summary>
	Null = 5,
}
#endif

#endregion

#region functions

internal static unsafe class SLApi {
	const string SQLITE_DLL = "winsqlite3.dll";
	
	static SLApi() {
		//Windows 10 and 11 have winsqlite3.dll. On other OS download from www.sqlite.org.
		if (!NativeLibrary.TryLoad(SQLITE_DLL, out _)) _LoadDownloaded();
		
		static void _LoadDownloaded() {
			string path = folders.ThisAppDataLocal; if (path.Ends(@"\_script", true)) path = path[..^8];
			path += $@"\download\{SQLITE_DLL}";
			//print.it(path, filesystem.exists(path));
			if (!filesystem.exists(path)) {
				gRetry:
				try {
					_Download(path);
				}
				catch (Exception ex) {
					int r = dialog.showError("Failed to download missing files", $"Your OS does not have this file: {SQLITE_DLL}.\r\nThis program tried to download it from www.sqlite.org, but failed.", "1 Retry|0 Cancel", expandedText: ex.ToString());
					if (r == 1) goto gRetry;
					Environment.Exit(0);
				}
			}
			NativeLibrary.Load(path);
			
			static void _Download(string path) {
				//Get the download URL of the last sqlite version for this OS. This way is documented in https://www.sqlite.org/download.html.
				var html = internet.http_.Get("https://www.sqlite.org/download.html").Text();
				//print.it(html);
				if (!html.RxMatch(@"(?s)<!-- Download product data for scripts to read\s+(.+)\s+-->", 1, out string csv)) throw new AuException();
				//print.it(csv);
				var x = csvTable.parse(csv);
				string s = $"sqlite-dll-win-{RuntimeInformation.ProcessArchitecture.ToString().Lower()}";
				string url = x.Rows.First(o => o[2].Contains(s, StringComparison.OrdinalIgnoreCase))[2];
				url = "https://www.sqlite.org/" + url;
				//print.it(url);
				
				//Download and extract.
				var bytes = internet.http_.Get(url).Bytes();
				using var za = new ZipArchive(new MemoryStream(bytes), ZipArchiveMode.Read);
				var e = za.GetEntry("sqlite3.dll");
				filesystem.createDirectoryFor(path);
				e.ExtractToFile(path, true);
			}
		}
	}
	
	[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	internal static extern SLError sqlite3_close_v2(IntPtr db);
	
	//[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	//internal static extern SLError sqlite3_create_function(IntPtr db, byte[] strName, int nArgs, int nType, IntPtr pvUser, SQLiteCallback func, SQLiteCallback fstep, SQLiteFinalCallback ffinal);
	
	[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	internal static extern SLError sqlite3_finalize(IntPtr stmt);
	
	//[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	//internal static extern SLError sqlite3_backup_finish(IntPtr backup);
	
	[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	internal static extern SLError sqlite3_reset(IntPtr stmt);
	
	[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	internal static extern byte* sqlite3_bind_parameter_name(IntPtr stmt, int index);
	
	//[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	//internal static extern byte* sqlite3_column_database_name(IntPtr stmt, int index);
	
	//[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	//internal static extern byte* sqlite3_column_decltype(IntPtr stmt, int index);
	
	[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	internal static extern byte* sqlite3_column_name(IntPtr stmt, int index);
	
	//[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	//internal static extern byte* sqlite3_column_origin_name(IntPtr stmt, int index);
	
	//[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	//internal static extern byte* sqlite3_column_table_name(IntPtr stmt, int index);
	
	[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	internal static extern byte* sqlite3_column_text(IntPtr stmt, int index);
	
	[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	internal static extern char* sqlite3_column_text16(IntPtr stmt, int index);
	
	[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	internal static extern byte* sqlite3_errmsg(IntPtr db);
	
	internal static string Errmsg(IntPtr db) => Convert2.Utf8Decode(sqlite3_errmsg(db));
	
	[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	internal static extern SLError sqlite3_prepare16_v3(IntPtr db, char* sql, int nBytes, int prepFlags, ref IntPtr stmt, char** ptrRemain);
	
	//[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	//internal static extern SLError sqlite3_table_column_metadata(IntPtr db, byte[] dbName, byte[] tblName, byte[] colName, byte** ptrDataType, byte** ptrCollSeq, ref int notNull, ref int primaryKey, ref int autoInc);
	
	//[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	//internal static extern byte* sqlite3_value_text(IntPtr p);
	
	//[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	//internal static extern byte* sqlite3_libversion();
	
	//[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	//internal static extern int sqlite3_libversion_number();
	
	//[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	//internal static extern byte* sqlite3_sourceid();
	
	//[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	//internal static extern int sqlite3_compileoption_used(byte[] zOptName);
	
	//[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	//internal static extern byte* sqlite3_compileoption_get(int N);
	
	//[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	//internal static extern SLError sqlite3_enable_shared_cache(int enable);
	
	//[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	//internal static extern SLError sqlite3_enable_load_extension(IntPtr db, int enable);
	
	//[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	//internal static extern SLError sqlite3_load_extension(IntPtr db, byte[] fileName, byte[] procName, byte** pError);
	
	//[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	//internal static extern SLError sqlite3_overload_function(IntPtr db, byte[] zName, int nArgs);
	
	//[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	//internal static extern SLError sqlite3_win32_set_directory16(uint type, string value);
	
	//[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	//internal static extern SLError sqlite3_win32_reset_heap();
	
	//[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	//internal static extern SLError sqlite3_win32_compact_heap(ref uint largest);
	
	//[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	//internal static extern void* sqlite3_malloc(int n);
	
	//[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	//internal static extern void* sqlite3_malloc64(ulong n);
	
	//[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	//internal static extern void* sqlite3_realloc(void* p, int n);
	
	//[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	//internal static extern void* sqlite3_realloc64(void* p, ulong n);
	
	//[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	//internal static extern ulong sqlite3_msize(void* p);
	
	[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	internal static extern void sqlite3_free(void* p);
	
	[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	internal static extern SLError sqlite3_open_v2(byte[] filename, ref IntPtr db, SLFlags flags, byte[] vfsName);
	
	//[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	//internal static extern void sqlite3_interrupt(IntPtr db);
	
	[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	internal static extern long sqlite3_last_insert_rowid(IntPtr db);
	
	[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	internal static extern int sqlite3_changes(IntPtr db);
	
	//[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	//internal static extern long sqlite3_memory_used();
	
	//[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	//internal static extern long sqlite3_memory_highwater(int resetFlag);
	
	//[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	//internal static extern SLError sqlite3_shutdown();
	
	[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	internal static extern SLError sqlite3_busy_timeout(IntPtr db, int ms);
	
	[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	internal static extern SLError sqlite3_clear_bindings(IntPtr stmt);
	
	[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	static extern SLError sqlite3_bind_blob64(IntPtr stmt, int index, void* value, long nSize, nint nTransient);
	
	internal static SLError sqlite3_bind_blob64(IntPtr stmt, int index, void* value, long nSize)
		=> sqlite3_bind_blob64(stmt, index, value, nSize, -1); //SQLITE_TRANSIENT //FUTURE: somehow avoid copying if large data. Eg if array or List, can use callback and GCHandle.
	
	[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	internal static extern SLError sqlite3_bind_double(IntPtr stmt, int index, double value);
	
	[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	internal static extern SLError sqlite3_bind_int(IntPtr stmt, int index, int value);
	
	[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	internal static extern SLError sqlite3_bind_int64(IntPtr stmt, int index, long value);
	
	[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	internal static extern SLError sqlite3_bind_null(IntPtr stmt, int index);
	
	[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	static extern SLError sqlite3_bind_text16(IntPtr stmt, int index, string value, int nlen, nint nTransient);
	
	internal static SLError sqlite3_bind_text16(IntPtr stmt, int index, string value, int nlen)
		=> sqlite3_bind_text16(stmt, index, value, nlen, -1); //SQLITE_TRANSIENT
	
	//[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	//internal static extern SLError sqlite3_bind_zeroblob(IntPtr stmt, int index, int n);
	
	//[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	//internal static extern int sqlite3_bind_parameter_count(IntPtr stmt);
	
	[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	internal static extern int sqlite3_bind_parameter_index(IntPtr stmt, byte[] strName);
	
	[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	internal static extern int sqlite3_column_count(IntPtr stmt);
	
	[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	internal static extern SLError sqlite3_step(IntPtr stmt);
	
	//[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	//internal static extern int sqlite3_stmt_readonly(IntPtr stmt);
	
	[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	internal static extern double sqlite3_column_double(IntPtr stmt, int index);
	
	[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	internal static extern int sqlite3_column_int(IntPtr stmt, int index);
	
	[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	internal static extern long sqlite3_column_int64(IntPtr stmt, int index);
	
	[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	internal static extern void* sqlite3_column_blob(IntPtr stmt, int index);
	
	[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	internal static extern int sqlite3_column_bytes(IntPtr stmt, int index);
	
	[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	internal static extern int sqlite3_column_bytes16(IntPtr stmt, int index);
	
	//[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	//internal static extern TypeAffinity sqlite3_column_type(IntPtr stmt, int index);
	
	//[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	//internal static extern SLError sqlite3_create_collation(IntPtr db, byte[] strName, int nType, IntPtr pvUser, SQLiteCollation func);
	
	//[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	//internal static extern void* sqlite3_value_blob(IntPtr p);
	
	//[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	//internal static extern int sqlite3_value_bytes(IntPtr p);
	
	//[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	//internal static extern int sqlite3_value_bytes16(IntPtr p);
	
	//[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	//internal static extern double sqlite3_value_double(IntPtr p);
	
	//[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	//internal static extern int sqlite3_value_int(IntPtr p);
	
	//[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	//internal static extern long sqlite3_value_int64(IntPtr p);
	
	//[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	//internal static extern TypeAffinity sqlite3_value_type(IntPtr p);
	
	//[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	//internal static extern void sqlite3_result_blob(IntPtr context, byte[] value, int nSize, IntPtr pvReserved);
	
	//[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	//internal static extern void sqlite3_result_double(IntPtr context, double value);
	
	//[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	//internal static extern void sqlite3_result_error(IntPtr context, byte[] strErr, int nLen);
	
	//[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	//internal static extern void sqlite3_result_error_code(IntPtr context, SLError value);
	
	//[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	//internal static extern void sqlite3_result_error_toobig(IntPtr context);
	
	//[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	//internal static extern void sqlite3_result_error_nomem(IntPtr context);
	
	//[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	//internal static extern void sqlite3_result_value(IntPtr context, IntPtr value);
	
	//[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	//internal static extern void sqlite3_result_zeroblob(IntPtr context, int nLen);
	
	//[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	//internal static extern void sqlite3_result_int(IntPtr context, int value);
	
	//[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	//internal static extern void sqlite3_result_int64(IntPtr context, long value);
	
	//[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	//internal static extern void sqlite3_result_null(IntPtr context);
	
	//[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	//internal static extern IntPtr sqlite3_aggregate_context(IntPtr context, int nBytes);
	
	//[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	//internal static extern void sqlite3_result_error16(IntPtr context, string strName, int nLen);
	
	//[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	//internal static extern void sqlite3_result_text16(IntPtr context, string strName, int nLen, IntPtr pvReserved);
	
	//[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	//internal static extern void sqlite3_progress_handler(IntPtr db, int ops, SQLiteProgressCallback func, IntPtr pvUser);
	
	//[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	//internal static extern IntPtr sqlite3_set_authorizer(IntPtr db, SQLiteAuthorizerCallback func, IntPtr pvUser);
	
	//[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	//internal static extern IntPtr sqlite3_update_hook(IntPtr db, SQLiteUpdateCallback func, IntPtr pvUser);
	
	//[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	//internal static extern IntPtr sqlite3_commit_hook(IntPtr db, SQLiteCommitCallback func, IntPtr pvUser);
	
	//[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	//internal static extern IntPtr sqlite3_trace(IntPtr db, SQLiteTraceCallback func, IntPtr pvUser);
	
	//[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	//internal static extern IntPtr sqlite3_trace_v2(IntPtr db, SQLiteTraceFlags mask, SQLiteTraceCallback2 func, IntPtr pvUser);
	
	// Since sqlite3_config() takes a variable argument list, we have to overload declarations
	// for all possible calls that we want to use.
	//[DllImport(SQLITE_DLL, EntryPoint = "sqlite3_config", CallingConvention = CallingConvention.Cdecl)]
	//internal static extern SLError sqlite3_config_none(Config op);
	
	//[DllImport(SQLITE_DLL, EntryPoint = "sqlite3_config", CallingConvention = CallingConvention.Cdecl)]
	//internal static extern SLError sqlite3_config_int(Config op, int value);
	
	////[DllImport(SQLITE_DLL, EntryPoint = "sqlite3_config", CallingConvention = CallingConvention.Cdecl)]
	////internal static extern SLError sqlite3_config_log(Config op, SQLiteLogCallback func, IntPtr pvUser);
	
	//[DllImport(SQLITE_DLL, EntryPoint = "sqlite3_db_config", CallingConvention = CallingConvention.Cdecl)]
	//internal static extern SLError sqlite3_db_config_charptr(IntPtr db, ConfigDb op, IntPtr charPtr);
	
	//[DllImport(SQLITE_DLL, EntryPoint = "sqlite3_db_config", CallingConvention = CallingConvention.Cdecl)]
	//internal static extern SLError sqlite3_db_config_int_refint(IntPtr db, ConfigDb op, int value, ref int result);
	
	//[DllImport(SQLITE_DLL, EntryPoint = "sqlite3_db_config", CallingConvention = CallingConvention.Cdecl)]
	//internal static extern SLError sqlite3_db_config_intptr_two_ints(IntPtr db, ConfigDb op, IntPtr ptr, int int0, int int1);
	
	//[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	//internal static extern SLError sqlite3_db_status(IntPtr db, SQLiteStatusOpsEnum op, ref int current, ref int highwater, int resetFlag);
	
	//[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	//internal static extern IntPtr sqlite3_rollback_hook(IntPtr db, SQLiteRollbackCallback func, IntPtr pvUser);
	
	//[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	//internal static extern IntPtr sqlite3_db_handle(IntPtr stmt);
	
	//[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	//internal static extern SLError sqlite3_db_release_memory(IntPtr db);
	
	//[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	//internal static extern IntPtr sqlite3_db_filename(IntPtr db, byte[] dbName);
	
	//[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	//internal static extern int sqlite3_db_readonly(IntPtr db, IntPtr dbName);
	
	//[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	//internal static extern IntPtr sqlite3_next_stmt(IntPtr db, IntPtr stmt);
	
	[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	internal static extern SLError sqlite3_exec(IntPtr db, byte[] strSql, IntPtr pvCallback, IntPtr pvParam, byte** errMsg);
	
	//[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	//internal static extern int sqlite3_release_memory(int nBytes);
	
	[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	internal static extern int sqlite3_get_autocommit(IntPtr db);
	
	//[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	//internal static extern SLError sqlite3_extended_result_codes(IntPtr db, int onoff);
	
	[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	internal static extern SLError sqlite3_errcode(IntPtr db);
	
	//[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	//internal static extern SLError sqlite3_extended_errcode(IntPtr db);
	
	[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	internal static extern byte* sqlite3_errstr(SLError rc);
	
	internal static string Errstr(SLError r) => Convert2.Utf8Decode(sqlite3_errstr(r));
	
	//[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	//internal static extern void sqlite3_log(SLError iErrCode, byte[] zFormat);
	
	//[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	//internal static extern SLError sqlite3_file_control(IntPtr db, byte[] zDbName, int op, IntPtr pArg);
	
	//[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	//internal static extern IntPtr sqlite3_backup_init(IntPtr destDb, byte[] zDestName, IntPtr sourceDb, byte[] zSourceName);
	
	//[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	//internal static extern SLError sqlite3_backup_step(IntPtr backup, int nPage);
	
	//[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	//internal static extern int sqlite3_backup_remaining(IntPtr backup);
	
	//[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	//internal static extern int sqlite3_backup_pagecount(IntPtr backup);
	
	//[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	//internal static extern SLError sqlite3_blob_close(IntPtr blob);
	
	//[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	//internal static extern int sqlite3_blob_bytes(IntPtr blob);
	
	//[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	//internal static extern SLError sqlite3_blob_open(IntPtr db, byte[] dbName, byte[] tblName, byte[] colName, long rowId, int flags, ref IntPtr ptrBlob);
	
	//[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	//internal static extern SLError sqlite3_blob_read(IntPtr blob, [MarshalAs(UnmanagedType.LPArray)] byte[] buffer, int count, int offset);
	
	//[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	//internal static extern SLError sqlite3_blob_reopen(IntPtr blob, long rowId);
	
	//[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	//internal static extern SLError sqlite3_blob_write(IntPtr blob, [MarshalAs(UnmanagedType.LPArray)] byte[] buffer, int count, int offset);
	
	//[DllImport(SQLITE_DLL, CallingConvention = CallingConvention.Cdecl)]
	//internal static extern SLError sqlite3_declare_vtab(IntPtr db, byte[] zSQL);
	
}

#endregion


================================================
FILE: Au/GUI/EnumUI.cs
================================================
using System.Windows;
using System.Windows.Controls;
using System.Windows.Controls.Primitives;
namespace Au.More;

/// <summary>
/// Add enum members to a <see cref="popupMenu"/> menu or WPF control.
/// </summary>
public class EnumUI<TEnum> where TEnum : unmanaged, Enum {
	(TEnum e, object c, string text, string tt)[] _a;
	Selector _cb;
	bool _isFlags;
	
	/// <summary>
	/// Adds enum members to a <see cref="popupMenu"/> menu as checkbox-items (if it's a <c>[Flags]</c> enum) or radio-items.
	/// </summary>
	/// <param name="m"></param>
	/// <param name="init">Initial value.</param>
	/// <param name="items">Enum members and their text/tooltip. Optional. Text can be: <c>null</c>, <c>"text"</c>, <c>"text|tooltip"</c>, <c>"|tooltip"</c>.</param>
	/// <param name="sort">Sort by name.</param>
	/// <example>
	/// <code><![CDATA[
	/// var m = new popupMenu();
	/// var f = new EnumUI<KMod>(m, KMod.Ctrl|KMod.Alt); //a [Flags] enum
	/// m.Separator();
	/// var e = new EnumUI<DayOfWeek>(m, DateTime.Today.DayOfWeek); //a non-[Flags] enum
	/// m.Show();
	/// print.it(f.Result);
	/// print.it(e.Result);
	/// ]]></code>
	/// </example>
	/// <seealso cref="popupMenu.AddEnum{TEnum}"/>
	public EnumUI(popupMenu m, TEnum init = default, (TEnum value, string text)[] items = null, bool sort = false) {
		Not_.Null(m);
		_isFlags = typeof(TEnum).IsDefined(typeof(FlagsAttribute), false);
		bool cns = m.CheckDontClose; if (_isFlags) m.CheckDontClose = true;
		_InitArray(items, sort);
		for (int i = 0; i < _a.Length; i++) {
			var (e, _, text, tt) = _a[i];
			var mi = _isFlags
				? m.AddCheck(text, init.HasFlag(e))
				: m.AddRadio(text, init.Equals(e));
			mi.Tooltip = tt;
			_a[i].c = mi;
		}
		if (_isFlags) m.CheckDontClose = cns;
	}
	
	void _InitArray((TEnum value, string text)[] items, bool sort) {
		if (items != null) {
			_a = new (TEnum e, object c, string text, string tt)[items.Length];
			for (int i = 0; i < _a.Length; i++) {
				var (v, text) = items[i];
				_a[i].e = v;
				if (text != null) {
					int j = text.IndexOf('|');
					if (j >= 0) {
						_a[i].tt = text[(j + 1)..];
						text = j == 0 ? null : text[..j];
					}
				}
				_a[i].text = text ?? v.ToString();
				if (sort) _a = _a.OrderBy(o => o.text).ToArray();
			}
		} else {
			IEnumerable<TEnum> e = Enum.GetValues<TEnum>();
			if (_isFlags) e = e.Where(o => !EqualityComparer<TEnum>.Default.Equals(o, default));
			var ee = e.Select(o => (o, (object)null, text: o.ToString(), (string)null));
			if (sort) ee = ee.OrderBy(o => o.text);
			_a = ee.ToArray();
		}
	}
	
	/// <summary>
	/// Adds members of a <c>[Flags]</c> enum as checkboxes to a WPF panel.
	/// </summary>
	/// <param name="container"><see cref="StackPanel"/>, <see cref="WrapPanel"/> or <see cref="Grid"/>. If <c>Grid</c> without columns, adds 2 columns.</param>
	/// <param name="init">Initial value.</param>
	/// <param name="items">Enum members and their text/tooltip. Optional. Text can be: <c>null</c>, <c>"text"</c>, <c>"text|tooltip"</c>, <c>"|tooltip"</c>.</param>
	/// <param name="sort">Sort by name.</param>
	/// <example>
	/// With <see cref="wpfBuilder"/>.
	/// <code><![CDATA[
	/// b.R.StartStack(vertical: true);
	/// var e = new EnumUI<KMod>(b.Panel, KMod.Ctrl|KMod.Alt);
	/// b.End();
	/// ...
	/// print.it(e.Result);
	/// ]]></code>
	/// </example>
	/// <seealso cref="wpfBuilder.AddEnum"/>
	public EnumUI(Panel container, TEnum init = default, (TEnum value, string text)[] items = null, bool sort = false) {
		Not_.Null(container);
		_isFlags = true;
		_InitArray(items, sort);
		
		int nCol = 0;
		if (container is Grid g1) {
			nCol = g1.ColumnDefinitions.Count;
			if (nCol == 0) {
				nCol = 2;
				g1.AddColumns(0, -1);
			}
		}
		
		Thickness margin = container is StackPanel { Orientation: Orientation.Vertical } ? new(2) : new(2, 2, 12, 2);
		for (int i = 0, row = -1; i < _a.Length; i++) {
			var (e, _, text, tt) = _a[i];
			var c = new CheckBox {
				Content = text,
				ToolTip = tt,
				IsChecked = init.HasFlag(e),
				Margin = margin,
				HorizontalAlignment = HorizontalAlignment.Stretch
			};
			_a[i].c = c;
			container.Children.Add(c);
			
			if (nCol > 0) {
				int col = i % nCol;
				if (col == 0) { row++; ((Grid)container).RowDefinitions.Add(new() { Height = new() }); }
				Grid.SetColumn(c, col);
				Grid.SetRow(c, row);
			}
		}
	}
	
	/// <summary>
	/// Adds members of a non-<c>[Flags]</c> enum to a WPF <see cref="Selector"/> control, for example <see cref="ComboBox"/>.
	/// </summary>
	/// <param name="container"></param>
	/// <param name="init">Initial value.</param>
	/// <param name="items">Enum members and their text/tooltip. Optional. Text can be: <c>null</c>, <c>"text"</c>, <c>"text|tooltip"</c>, <c>"|tooltip"</c>.</param>
	/// <param name="sort">Sort by name.</param>
	/// <example>
	/// <code><![CDATA[
	/// b.R.Add("Dock", out ComboBox cb1);
	/// var e = new EnumUI<Dock>(cb1);
	/// ...
	/// print.it(e.Result);
	/// ]]></code>
	/// </example>
	public EnumUI(Selector container, TEnum init = default, (TEnum value, string text)[] items = null, bool sort = false) {
		Not_.Null(container);
		_cb = container;
		_InitArray(items, sort);
		int iSel = -1;
		for (int i = 0; i < _a.Length; i++) {
			var (e, _, text, tt) = _a[i];
			ListBoxItem k = container is ComboBox ? new ComboBoxItem() : new ListBoxItem();
			k.Content = text;
			k.ToolTip = tt;
			_cb.Items.Add(k);
			if (iSel < 0 && init.Equals(e)) iSel = i;
		}
		if (iSel >= 0) _cb.SelectedIndex = iSel;
	}
	
	/// <summary>
	/// Gets enum value from checked/selected menu items or WPF elements.
	/// </summary>
	public TEnum Result {
		get {
			TEnum r = default;
			if (_cb != null) {
				int i = _cb.SelectedIndex;
				if (i >= 0) r = _a[i].e;
			} else {
				for (int i = 0; i < _a.Length; i++) {
					var (e, c, _, _) = _a[i];
					switch (c) {
					case PMItem mi:
						if (!mi.IsChecked) continue;
						break;
					case CheckBox ch:
						if (ch.IsChecked != true) continue;
						break;
					}
					if (_isFlags) {
						ExtMisc.SetFlag(ref r, e, true);
					} else {
						r = e;
						break;
					}
				}
			}
			return r;
		}
	}
}


================================================
FILE: Au/GUI/dialog-static.cs
================================================
namespace Au;

public partial class dialog {
	#region Show
	
	/// <summary>
	/// Shows dialog.
	/// </summary>
	/// <returns>Selected button id.</returns>
	/// <param name="text1">Heading text.</param>
	/// <param name="text2">Message text. Can be string, or string with links like <c><![CDATA[new("Text <a>link</a> text.", e => { print.it("link"); })]]></c>.</param>
	/// <param name="buttons">
	/// List of button names or <c>"id name"</c>. Examples: <c>"OK|Cancel"</c>, <c>"1 Yes|2 No"</c>, <c><![CDATA["1 &Save|2 Do&n't Save|0 Cancel"]]></c>, <c>["1 One", "2 Two"]</c>.
	/// Can contain common buttons (named <b>OK</b>, <b>Yes</b>, <b>No</b>, <b>Retry</b>, <b>Cancel</b>, <b>Close</b>) and/or custom buttons (any other names).
	/// This first in the list button will be focused (aka <i>default button</i>).
	/// More info: <see cref="Buttons"/>.
	/// </param>
	/// <param name="flags"></param>
	/// <param name="icon"></param>
	/// <param name="owner">Owner window. See <see cref="OwnerWindow"/>.</param>
	/// <param name="expandedText">Text in expander control. Can be string, or string with links like <c><![CDATA[new("Text <a>link</a> text.", e => { print.it("link"); })]]></c>.</param>
	/// <param name="footer">Text at the bottom of the dialog. Can be string, or string with links like <c><![CDATA[new("Text <a>link</a> text.", e => { print.it("link"); })]]></c>. Icon can be specified like <c>"i|Text"</c>, where <c>i</c> is: <c>x</c> error, <c>!</c> warning, <c>i</c> info, <c>v</c> shield, <c>a</c> app.</param>
	/// <param name="title">Title bar text. If omitted, <c>null</c> or <c>""</c>, uses <see cref="options.defaultTitle"/>.</param>
	/// <param name="controls">Can be used to add more controls and later get their values: checkbox, radio buttons, text input.</param>
	/// <param name="x">X position in screen. Default - screen center. Examples: <c>10</c>, <c>^10</c> (reverse), <c>.5f</c> (fraction).</param>
	/// <param name="y">Y position in screen. Default - screen center.</param>
	/// <param name="screen">See <see cref="InScreen"/>. Examples: <c>screen.ofMouse</c>, <c>screen.at.left()</c>.</param>
	/// <param name="secondsTimeout">If not 0, after this time (seconds) auto-close the dialog and return <see cref="Timeout"/>.</param>
	/// <remarks>
	/// Tip: Use named arguments. Example: <c>dialog.show("Text", icon: DIcon.Info, title: "Title")</c> .
	/// 
	/// This function allows you to use many dialog features, but not all. Alternatively you can create a <see cref="dialog"/> class instance, set properties and call <see cref="ShowDialog"/>. Example in <see cref="dialog"/> class help.
	/// </remarks>
	/// <example>
	/// <code><![CDATA[
	/// if(1 != dialog.show("Continue?", null, "1 OK|2 Cancel", icon: DIcon.Info)) return;
	/// print.it("OK");
	/// 
	/// switch (dialog.show("Save changes?", "More info.", "1 Save|2 Don't Save|0 Cancel")) {
	/// case 1: print.it("save"); break;
	/// case 2: print.it("don't"); break;
	/// default: print.it("cancel"); break;
	/// }
	/// ]]></code>
	/// 
	/// <code><![CDATA[
	/// var con = new DControls { Checkbox = "Check", RadioButtons = "1 One|2 Two|3 Three", EditType = DEdit.Combo, EditText = "zero", ComboItems = ["one", "two"] };
	/// var r = dialog.show("Main text", "More text.", "1 OK|2 Cancel", expandedText: "Expanded text", controls: con, secondsTimeout: 30);
	/// print.it(r, con.IsChecked, con.RadioId, con.EditText);
	/// switch(r) {
	/// case 1: print.it("OK"); break;
	/// case dialog.Timeout: print.it("timeout"); break;
	/// default: print.it("Cancel"); break;
	/// }
	/// ]]></code>
	/// </example>
	/// <exception cref="Win32Exception">Failed to show dialog. Unlikely.</exception>
	public static int show(
		string text1 = null, DText text2 = null, Strings buttons = default, DFlags flags = 0, DIcon icon = 0, AnyWnd owner = default,
		DText expandedText = null, DText footer = null, string title = null, DControls controls = null,
		Coord x = default, Coord y = default, screen screen = default, int secondsTimeout = 0
		) {
		var d = new dialog(text1, text2, buttons, flags, icon, owner,
			expandedText, footer, title, controls,
			x, y, screen, secondsTimeout);
		return d.ShowDialog();
	}
	
	/// <summary>
	/// Shows dialog with <see cref="DIcon.Info"/> icon.
	/// </summary>
	/// <remarks>Calls <see cref="show"/>.</remarks>
	/// <example></example>
	/// <inheritdoc cref="show"/>
	public static int showInfo(string text1 = null, DText text2 = null, Strings buttons = default, DFlags flags = 0, AnyWnd owner = default,
		DText expandedText = null, string title = null, int secondsTimeout = 0)
		=> show(text1, text2, buttons, flags, DIcon.Info, owner, expandedText, title: title, secondsTimeout: secondsTimeout);
	
	/// <summary>
	/// Shows dialog with <see cref="DIcon.Warning"/> icon.
	/// </summary>
	/// <remarks>Calls <see cref="show"/>.</remarks>
	/// <example></example>
	/// <inheritdoc cref="show"/>
	public static int showWarning(string text1 = null, DText text2 = null, Strings buttons = default, DFlags flags = 0, AnyWnd owner = default,
		DText expandedText = null, string title = null, int secondsTimeout = 0)
		=> show(text1, text2, buttons, flags, DIcon.Warning, owner, expandedText, title: title, secondsTimeout: secondsTimeout);
	
	/// <summary>
	/// Shows dialog with <see cref="DIcon.Error"/> icon.
	/// </summary>
	/// <remarks>Calls <see cref="show"/>.</remarks>
	/// <example></example>
	/// <inheritdoc cref="show"/>
	public static int showError(string text1 = null, DText text2 = null, Strings buttons = default, DFlags flags = 0, AnyWnd owner = default,
		DText expandedText = null, string title = null, int secondsTimeout = 0)
		=> show(text1, text2, buttons, flags, DIcon.Error, owner, expandedText, title: title, secondsTimeout: secondsTimeout);
	
	/// <summary>
	/// Shows dialog with <b>OK</b> and <b>Cancel</b> buttons.
	/// </summary>
	/// <returns><c>true</c> if selected <b>OK</b>.</returns>
	/// <remarks>Calls <see cref="show"/>.</remarks>
	/// <example></example>
	/// <inheritdoc cref="show"/>
	public static bool showOkCancel(string text1 = null, DText text2 = null, DFlags flags = 0, DIcon icon = 0, AnyWnd owner = default,
		DText expandedText = null, string title = null, int secondsTimeout = 0)
		=> 1 == show(text1, text2, "OK|Cancel", flags, icon, owner, expandedText, title: title, secondsTimeout: secondsTimeout);
	
	/// <summary>
	/// Shows dialog with <b>Yes</b> and <b>No</b> buttons.
	/// </summary>
	/// <returns><c>true</c> if selected <b>Yes</b>.</returns>
	/// <remarks>Calls <see cref="show"/>.</remarks>
	/// <example></example>
	/// <inheritdoc cref="show"/>
	public static bool showYesNo(string text1 = null, DText text2 = null, DFlags flags = 0, DIcon icon = 0, AnyWnd owner = default,
		DText expandedText = null, string title = null, int secondsTimeout = 0)
		=> 1 == show(text1, text2, "Yes|No", flags, icon, owner, expandedText, title: title, secondsTimeout: secondsTimeout);
	
	#endregion Show
	
	#region ShowInput
	
	/// <summary>
	/// Shows dialog with a text edit field and gets that text.
	/// </summary>
	/// <returns><c>true</c> if selected <b>OK</b> (or a custom button with id 1).</returns>
	/// <param name="s">Variable that receives the text.</param>
	/// <param name="text1">Heading text.</param>
	/// <param name="text2">Message test (above the edit field).</param>
	/// <param name="editType">Edit field type. It can be simple text (default), multiline, number, password or combo box.</param>
	/// <param name="editText">Initial edit field text.</param>
	/// <param name="comboItems">Combo box items used when <i>editType</i> is <see cref="DEdit.Combo"/>.</param>
	/// <param name="flags"></param>
	/// <param name="owner">Owner window. See <see cref="OwnerWindow"/>.</param>
	/// <param name="expandedText">Text in expander control.</param>
	/// <param name="footer">Text at the bottom of the dialog. Icon can be specified like <c>"i|Text"</c>, where <c>i</c> is: <c>x</c> error, <c>!</c> warning, <c>i</c> info, <c>v</c> shield, <c>a</c> app.</param>
	/// <param name="title">Title bar text. If omitted, <c>null</c> or <c>""</c>, uses <see cref="options.defaultTitle"/>.</param>
	/// <param name="controls">Can be used to add more controls and later get their values: checkbox, radio buttons.</param>
	/// <param name="x">X position in screen. Default - screen center. Examples: <c>10</c>, <c>^10</c> (reverse), <c>.5f</c> (fraction).</param>
	/// <param name="y">Y position in screen. Default - screen center.</param>
	/// <param name="screen">See <see cref="InScreen"/>. Examples: <c>screen.ofMouse</c>, <c>screen.index(1)</c>.</param>
	/// <param name="secondsTimeout">If not 0, after this time (seconds) auto-close the dialog and return <see cref="Timeout"/>.</param>
	/// <param name="buttons">
	/// Buttons. List of names or <c>"id name"</c>. Example: <c>"1 OK|2 Cancel|10 Browse..."</c>. See <see cref="Buttons"/>.
	/// Note: this function returns <c>true</c> only when clicked button with id 1.
	/// Usually custom buttons are used with <i>onButtonClick</i> function, which for example can get button id or disable closing the dialog.
	/// </param>
	/// <param name="onButtonClick">A button-clicked event handler function. See examples.</param>
	/// <remarks>
	/// This function allows you to use many dialog features, but not all. Alternatively you can create a <see cref="dialog"/> class instance, call <see cref="Edit"/> or use the <i>controls</i> parameter, set other properties and call <see cref="ShowDialog"/>.
	/// </remarks>
	/// <example>
	/// Simple.
	/// <code><![CDATA[
	/// string s;
	/// if(!dialog.showInput(out s, "Example")) return;
	/// print.it(s);
	/// 
	/// if(!dialog.showInput(out var s2, "Example")) return;
	/// print.it(s2);
	/// ]]></code>
	/// 
	/// With checkbox.
	/// <code><![CDATA[
	/// var con = new DControls { Checkbox = "Check" };
	/// if(!dialog.showInput(out var s, "Example", "Comments.", controls: con)) return;
	/// print.it(s, con.IsChecked);
	/// ]]></code>
	/// 
	/// With <i>onButtonClick</i> function.
	/// <code><![CDATA[
	/// int r = 0;
	/// dialog.showInput(out string s, "Example", buttons: "OK|Cancel|Later", onButtonClick: e => r = e.Button);
	/// print.it(r);
	/// 
	/// if(!dialog.showInput(out string s, "Example", flags: DFlags.CommandLinks, buttons: "OK|Cancel|10 Set text", onButtonClick: e => {
	/// 	if(e.Button == 10) { e.EditText = "text"; e.DontCloseDialog = true; }
	/// })) return;
	/// 
	/// if(!dialog.showInput(out string s2, "Example", "Try to click OK while text is empty.", onButtonClick: e => {
	/// 	if(e.Button == 1 && e.EditText.NE()) {
	/// 		dialog.show("Text cannot be empty.", owner: e.hwnd);
	/// 		e.d.EditControl.Focus();
	/// 		e.DontCloseDialog = true;
	/// 	}
	/// })) return;
	/// ]]></code>
	/// </example>
	/// <exception cref="Win32Exception">Failed to show dialog.</exception>
	public static bool showInput(out string s,
		string text1 = null, DText text2 = null,
		DEdit editType = DEdit.Text, string editText = null, Strings comboItems = default,
		DFlags flags = 0, AnyWnd owner = default,
		DText expandedText = null, DText footer = null, string title = null, DControls controls = null,
		Coord x = default, Coord y = default, screen screen = default, int secondsTimeout = 0,
		string buttons = "1 OK|2 Cancel", Action<DEventArgs> onButtonClick = null
		) {
		if (buttons.NE()) buttons = "1 OK|2 Cancel";
		var d = new dialog(text1, text2, buttons, flags, 0, owner, expandedText, footer, title, controls, x, y, screen, secondsTimeout);
		
		d.Edit(editType != 0 ? editType : DEdit.Text, editText, comboItems);
		if (onButtonClick != null) d.ButtonClicked += onButtonClick;
		
		bool r = 1 == d.ShowDialog();
		s = r ? d._controls.EditText : null;
		return r;
	}
	
	/// <summary>
	/// Shows dialog with a number edit field and gets that number.
	/// </summary>
	/// <returns><c>true</c> if selected <b>OK</b>.</returns>
	/// <param name="i">Variable that receives the number.</param>
	/// <param name="text1">Heading text.</param>
	/// <param name="text2">Message text (above the edit field).</param>
	/// <param name="editText">Initial edit field text.</param>
	/// <param name="flags"></param>
	/// <param name="owner">Owner window. See <see cref="OwnerWindow"/>.</param>
	/// <remarks>
	/// Calls <see cref="showInput"/> and converts string to <c>int</c>.
	/// </remarks>
	/// <example>
	/// <code><![CDATA[
	/// int i;
	/// if(!dialog.showInputNumber(out i, "Example")) return;
	/// print.it(i);
	/// ]]></code>
	/// </example>
	/// <exception cref="Win32Exception">Failed to show dialog.</exception>
	public static bool showInputNumber(out int i,
		string text1 = null, DText text2 = null, int? editText = null,
		DFlags flags = 0, AnyWnd owner = default
		) {
		i = 0;
		if (!showInput(out string s, text1, text2, DEdit.Number, editText?.ToString(), default, flags, owner)) return false;
		i = s.ToInt();
		return true;
	}
	
	#endregion ShowInput
	
	#region ShowList
	
	/// <summary>
	/// Shows dialog with a list of command-link buttons, and returns 1-based button index or 0.
	/// </summary>
	/// <returns>1-based index of the selected button. Returns 0 if clicked the <b>X</b> (close window) button or pressed <c>Esc</c>.</returns>
	/// <param name="list">List items (buttons). Can be like <c>"One|Two|Three"</c> or <c>new("One", "Two", "Three")</c> or string array or <c>List</c>. See <see cref="Buttons"/>.</param>
	/// <param name="text1">Heading text.</param>
	/// <param name="text2">Message text.</param>
	/// <param name="flags"></param>
	/// <param name="owner">Owner window. See <see cref="OwnerWindow"/>.</param>
	/// <param name="expandedText">Text in expander control.</param>
	/// <param name="footer">Text at the bottom of the dialog. Icon can be specified like <c>"i|Text"</c>, where <c>i</c> is: <c>x</c> error, <c>!</c> warning, <c>i</c> info, <c>v</c> shield, <c>a</c> app.</param>
	/// <param name="title">Title bar text. If omitted, <c>null</c> or <c>""</c>, uses <see cref="options.defaultTitle"/>.</param>
	/// <param name="controls">Can be used to add more controls and later get their values: checkbox, radio buttons, text input.</param>
	/// <param name="x">X position in screen. Default - screen center. Examples: <c>10</c>, <c>^10</c> (reverse), <c>.5f</c> (fraction).</param>
	/// <param name="y">Y position in screen. Default - screen center.</param>
	/// <param name="screen">See <see cref="InScreen"/>. Examples: <c>screen.ofMouse</c>, <c>screen.index(1)</c>.</param>
	/// <param name="secondsTimeout">If not 0, after this time (seconds) auto-close the dialog and return <see cref="Timeout"/>.</param>
	/// <remarks>
	/// This function allows you to use most of the dialog features, but not all. Alternatively you can create a <see cref="dialog"/> class instance, set properties and call <see cref="ShowDialog"/>. Example in <see cref="dialog"/> class help.
	/// </remarks>
	/// <example>
	/// <code><![CDATA[
	/// int r = dialog.showList("One|Two|Three", "Example", y: -1, secondsTimeout: 15);
	/// if(r <= 0) return; //X/Esc or timeout
	/// print.it(r);
	/// ]]></code>
	/// </example>
	/// <exception cref="Win32Exception">Failed to show dialog.</exception>
	/// <seealso cref="popupMenu.showSimple"/>
	public static int showList(
		Strings list, string text1 = null, DText text2 = null, DFlags flags = 0, AnyWnd owner = default,
		DText expandedText = null, DText footer = null, string title = null, DControls controls = null,
		Coord x = default, Coord y = default, screen screen = default, int secondsTimeout = 0
		) {
		return new dialog(text1, text2, default, flags | DFlags.XCancel | DFlags.ExpandDown, 0, owner,
			expandedText, footer, title, controls,
			x, y, screen, secondsTimeout)
			.ButtonsList(list)
			.ShowDialog();
	}
	
	#endregion ShowList
	
	#region ShowProgress
	
	/// <summary>
	/// Shows dialog with progress bar.
	/// Creates dialog in new thread and returns without waiting until it is closed.
	/// </summary>
	/// <returns>Variable that can be used to communicate with the dialog using these methods and properties: <see cref="IsOpen"/>, <see cref="ThreadWaitForClosed"/>, <see cref="Result"/> (when closed), <see cref="Controls"/> (when closed), <see cref="DialogWindow"/>, <see cref="Send"/>; through the <c>Send</c> property you can set progress, modify controls and close the dialog (see example).</returns>
	/// <param name="marquee">Let the progress bar animate without indicating a percent of work done.</param>
	/// <remarks>
	/// This function allows you to use most of the dialog features, but not all. Alternatively you can create a <see cref="dialog"/> class instance, set properties and call <see cref="ShowDialogNoWait"/>.
	/// </remarks>
	/// <example>
	/// <code><![CDATA[
	/// var pd = dialog.showProgress(false, "Working", buttons: "1 Stop", y: -1);
	/// for(int i = 1; i <= 100; i++) {
	/// 	if(!pd.IsOpen) { print.it(pd.Result); break; } //if the user closed the dialog
	/// 	pd.Send.Progress(i); //don't need this if marquee
	/// 	50.ms(); //do something in the loop
	/// }
	/// pd.Send.Close();
	/// ]]></code>
	/// </example>
	/// <inheritdoc cref="show"/>
	public static dialog showProgress(bool marquee,
		string text1 = null, DText text2 = null, string buttons = "0 Cancel", DFlags flags = 0, AnyWnd owner = default,
		DText expandedText = null, DText footer = null, string title = null, DControls controls = null,
		Coord x = default, Coord y = default, screen screen = default, int secondsTimeout = 0
	) {
		if (buttons.NE()) buttons = "0 Cancel";
		
		var d = new dialog(text1, text2, buttons, flags, 0, owner,
			expandedText, footer, title, controls,
			x, y, screen, secondsTimeout);
		
		d.Progress(true, marquee);
		
		d.ShowDialogNoWait();
		
		return d;
	}
	
	#endregion ShowProgress
	
	#region ShowNoWait
	
	/// <summary>
	/// Shows dialog like <see cref="show"/> but does not wait.
	/// Creates dialog in other thread and returns without waiting until it is closed.
	/// </summary>
	/// <returns>Variable that can be used to communicate with the dialog using these methods and properties: <see cref="IsOpen"/>, <see cref="ThreadWaitForClosed"/>, <see cref="Result"/> (when closed), <see cref="Controls"/> (when closed), <see cref="DialogWindow"/>, <see cref="Send"/>; through the <c>Send</c> property you can modify controls and close the dialog (see example).</returns>
	/// <remarks>
	/// This function allows you to use most of the dialog features, but not all. Alternatively you can create a <see cref="dialog"/> class instance, set properties and call <see cref="ShowDialogNoWait"/>.
	/// </remarks>
	/// <example>
	/// <code><![CDATA[
	/// dialog.showNoWait("Simple example");
	/// 
	/// var d = dialog.showNoWait("Another example", "text", "1 OK|2 Cancel", y: -1, secondsTimeout: 30);
	/// 2.s(); //do something while the dialog is open
	/// d.Send.ChangeText2("new text", false);
	/// 2.s(); //do something while the dialog is open
	/// d.ThreadWaitForClosed(); print.it(d.Result); //wait until the dialog is closed and get result. Optional, just an example.
	/// ]]></code>
	/// </example>
	/// <inheritdoc cref="show"/>
	public static dialog showNoWait(
		string text1 = null, DText text2 = null, Strings buttons = default, DFlags flags = 0, DIcon icon = 0, AnyWnd owner = default,
		DText expandedText = null, DText footer = null, string title = null, DControls controls = null,
		Coord x = default, Coord y = default, screen screen = default, int secondsTimeout = 0
		) {
		var d = new dialog(text1, text2, buttons, flags, icon, owner,
			expandedText, footer, title, controls,
			x, y, screen, secondsTimeout);
		d.ShowDialogNoWait();
		return d;
	}
	
	#endregion ShowNoWait
}


================================================
FILE: Au/GUI/dialog-types.cs
================================================
#pragma warning disable 649 //unused fields in API structs

namespace Au.Types {
	/// <summary>
	/// Text for <see cref="dialog"/> functions. Supports links. Has implicit conversion from string.
	/// </summary>
	/// <param name="text">Text. Links can be specified like <c><![CDATA["Text <a>link</a> text."]]></c>.</param>
	/// <param name="links">Link click handlers like <c>e => { print.it("link"); }</c>.</param>
	public record class DText(string text, params Action<DEventArgs>[] links) {
		/// <summary>
		/// Implicit conversion from string.
		/// </summary>
		/// <returns><c>null</c> if the string is <c>null</c>.</returns>
		public static implicit operator DText(string s) => s == null ? null : new(s, null);
	}
	
#pragma warning disable 1591 //missing XML documentation
	/// <summary>
	/// Standard icons for <see cref="dialog"/> functions.
	/// </summary>
	public enum DIcon {
		Warning = 0xffff,
		Error = 0xfffe,
		Info = 0xfffd,
		Shield = 0xfffc,
		
		//these are undocumented but used in .NET TaskDialogStandardIcon. But why need?
		//ShieldBlueBar = ushort.MaxValue - 4,
		//ShieldGrayBar = ushort.MaxValue - 8,
		//ShieldWarningYellowBar = ushort.MaxValue - 5,
		//ShieldErrorRedBar = ushort.MaxValue - 6,
		//ShieldSuccessGreenBar = ushort.MaxValue - 7,
		
		/// <summary>
		/// Use <ms>IDI_APPLICATION</ms> icon from unmanaged resources of this program file or main assembly.
		/// If there are no icons - default program icon.
		/// C# compilers add app icon with this id. The <see cref="DIcon.App"/> value is = <ms>IDI_APPLICATION</ms> (32512).
		/// If this program file contains multiple native icons in range <c>DIcon.App</c> to 0xf000, you can specify them like <c>DIcon.App+1</c>.
		/// </summary>
		App = Api.IDI_APPLICATION
	}
	
	/// <summary>
	/// Text edit field type for <see cref="dialog.showInput"/>, <see cref="dialog.Edit"/>, etc.
	/// </summary>
	public enum DEdit {
		None, Text, Multiline, Password, Number, Combo
	}
#pragma warning restore 1591 //missing XML documentation
	
	/// <summary>
	/// Flags for <see cref="dialog"/> functions.
	/// </summary>
	[Flags]
	public enum DFlags {
		/// <summary>
		/// Display custom buttons as a column of command-links, not as a row of classic buttons.
		/// Command links can have multi-line text. The first line has bigger font.
		/// More info about custom buttons: <see cref="dialog.Buttons"/>.
		/// </summary>
		CommandLinks = 1,
		
		/// <summary>
		/// Show expanded text in footer.
		/// </summary>
		ExpandDown = 1 << 1,
		
		/// <summary>
		/// Call <see cref="dialog.Wider"/> with <i>width</i> 700.
		/// </summary>
		Wider = 1 << 2,
		
		/// <summary>
		/// Allow to cancel even if there is no <b>Cancel</b> button.
		/// It adds <b>X</b> (Close) button to the title bar, and also allows to close the dialog with the <c>Esc</c> key.
		/// When the dialog is closed with the <b>X</b> button or <c>Esc</c>, the returned result button id is 0 if there is no <c>Cancel</c> button; else the same as when clicked the <c>Cancel</c> button.
		/// </summary>
		XCancel = 1 << 3,
		
		/// <summary>
		/// Show the dialog in the center of the owner window.
		/// </summary>
		CenterOwner = 1 << 4,
		
		/// <summary>
		/// Show the dialog at the mouse position. 
		/// </summary>
		CenterMouse = 1 << 5,
		
		/// <summary>
		/// x y are raw coordinates relative to the primary screen.
		/// More info: <see cref="dialog.XY"/>, <see cref="dialog.InScreen"/>. 
		/// </summary>
		RawXY = 1 << 6,
		
		/// <summary>
		/// Add <b>Minimize</b> button to the title bar.
		/// This flag is ignored if owner window specified.
		/// </summary>
		MinimizeButton = 1 << 7,
		
		/// <summary>
		/// Make the dialog a topmost window (always on top of other windows), regardless of <see cref="dialog.options.topmostIfNoOwnerWindow"/> etc.
		/// 
		/// If neither <c>Topmost</c> nor <c>NoTopmost</c> are set, makes topmost if both these are true: no owner window, <see cref="dialog.options.topmostIfNoOwnerWindow"/> is <c>true</c> (default).
		/// </summary>
		Topmost = 1 << 8,
		
		/// <summary>
		/// Don't make the dialog a topmost window, regardless of <see cref="dialog.options.topmostIfNoOwnerWindow"/> etc.
		/// </summary>
		NoTopmost = 1 << 9,
		
		//NoTaskbarButton = , //not so useful
		//NeverActivate = , //don't know how to implement. TDF_NO_SET_FOREGROUND does not work. LockSetForegroundWindow does not work if we can activate windows. HCBT_ACTIVATE can prevent activating but does not prevent deactivating.
		//AlwaysActivate = , //Don't use. Always allow. Because after AllowActivate (which is also used by Activate etc) always activates dialogs regardless of anything. As well as in uiAccess process.
	}
	
	/// <summary>
	/// Used with <see cref="dialog.show"/> and similar functions to add more controls and get their final values.
	/// </summary>
	public class DControls {
		/// <summary>
		/// If not <c>null</c>, adds checkbox with this text.
		/// </summary>
		public string Checkbox { get; set; }
		
		/// <summary>
		/// Sets initial and gets final checkbox value (<c>true</c> if checked).
		/// </summary>
		public bool IsChecked { get; set; }
		
		/// <summary>
		/// Adds radio buttons.
		/// A list of strings <c>"id text"</c> separated by <c>|</c>, like <c>"1 One|2 Two|3 Three"</c>.
		/// </summary>
		public Strings RadioButtons { get; set; }
		
		/// <summary>
		/// Sets initial and gets final checked radio button. It is button id (as specified in <see cref="RadioButtons"/>), not index.
		/// See <see cref="dialog.RadioButtons"/>.
		/// </summary>
		public int RadioId { get; set; }
		
		/// <summary>
		/// Adds a text edit control.
		/// Note: then the dialog cannot have a progress bar.
		/// </summary>
		public DEdit EditType { get; set; }
		
		/// <summary>
		/// Sets initial and gets final text edit control value.
		/// </summary>
		public string EditText { get; set; }
		
		/// <summary>
		/// Sets combo box list items used when <see cref="EditType"/> is <see cref="DEdit.Combo"/>.
		/// </summary>
		public Strings ComboItems { get; set; }
	}
	
	/// <summary>
	/// Arguments for <see cref="dialog"/> event handlers.
	/// </summary>
	/// <param name="d">The dialog.</param>
	/// <param name="hwnd">The dialog window.</param>
	/// <param name="message">See <ms>task dialog notifications</ms>.</param>
	/// <param name="wParam">See <ms>task dialog notifications</ms>.</param>
	/// <param name="Button">In a <see cref="dialog.ButtonClicked"/> event handler - button id.</param>
	/// <param name="TimerTimeMS">In a <see cref="dialog.Timer"/> event handler - timer time in milliseconds. The handler can set <c>returnValue</c> = 1 to reset this.</param>
	/// <param name="LinkHref">In an <see cref="dialog.HyperlinkClicked"/> event handler - the <c>href</c> attribute.</param>
	/// <remarks>
	/// To return a non-zero value from the callback function, assign the value to the <c>returnValue</c> field.
	/// More info: <ms>TaskDialogCallbackProc</ms>.
	/// </remarks>
	public record class DEventArgs(dialog d, wnd hwnd, DNative.TDN message, nint wParam, int Button, int TimerTimeMS, string LinkHref) {
		///
		public int returnValue;
		
		/// <summary>
		/// Your <see cref="dialog.ButtonClicked"/> event handler function can use this to prevent closing the dialog.
		/// </summary>
		public bool DontCloseDialog { set { returnValue = value ? 1 : 0; } }
		
		/// <summary>
		/// Gets or sets edit field text.
		/// </summary>
		public string EditText {
			get => d.EditControl.ControlText;
			set { d.EditControl.SetText(value); }
		}
	}
	
	/// <summary>
	/// Can be used through <see cref="dialog.Send"/>, to interact with dialog while it is open.
	/// </summary>
	/// <remarks>
	/// Example (in an event handler): <c>e.d.Close();</c>
	/// </remarks>
	public class DSend {
		volatile dialog _tdo;
		
		internal DSend(dialog tdo) { _tdo = tdo; }
		internal void Clear_() { _tdo = null; }
		
		/// <summary>
		/// Sends a message to the dialog.
		/// </summary>
		/// <remarks>
		/// Call this method while the dialog is open, eg in an event handler.
		/// Example (in an event handler): <c>e.d.Send.Message(DNative.TDM.CLICK_VERIFICATION, 1);</c>
		/// Also there are several other functions to send some messages: change text, close dialog, enable/disable buttons, update progress.
		/// Reference: <ms>task dialog messages</ms>.
		/// <c>NAVIGATE_PAGE</c> not supported.
		/// </remarks>
		public int Message(DNative.TDM message, nint wParam = 0, nint lParam = 0) {
			return _tdo?.SendMessage_(message, wParam, lParam) ?? 0;
		}
		
		void _SetText(bool resizeDialog, DNative.TDE partId, string text) {
			_tdo?.SetText_(resizeDialog, partId, text);
		}
		
		/// <summary>
		/// Changes the main big-font text.
		/// </summary>
		/// <remarks>
		/// Call this method while the dialog is open, eg in an event handler.
		/// </remarks>
		public void ChangeText1(string text, bool resizeDialog) {
			_SetText(resizeDialog, DNative.TDE.MAIN_INSTRUCTION, text);
		}
		
		/// <summary>
		/// Changes the main small-font text.
		/// </summary>
		/// <remarks>
		/// Call this method while the dialog is open, eg in an event handler.
		/// </remarks>
		public void ChangeText2(string text, bool resizeDialog) {
			_SetText(resizeDialog, DNative.TDE.CONTENT, text);
		}
		
		/// <summary>
		/// Changes the footer text.
		/// </summary>
		/// <remarks>
		/// Call this method while the dialog is open, eg in an event handler.
		/// </remarks>
		public void ChangeFooterText(string text, bool resizeDialog) {
			_SetText(resizeDialog, DNative.TDE.FOOTER, text);
		}
		
		/// <summary>
		/// Changes the expanded area text.
		/// </summary>
		/// <remarks>
		/// Call this method while the dialog is open, eg in an event handler.
		/// </remarks>
		public void ChangeExpandedText(string text, bool resizeDialog) {
			_SetText(resizeDialog, DNative.TDE.EXPANDED_INFORMATION, text);
		}
		
#if false //currently not implemented
		/// <summary>
		/// Applies new properties to the dialog while it is already open.
		/// Call this method while the dialog is open, eg in an event handler, after setting new properties.
		/// Sends message <c>DNative.TDM.NAVIGATE_PAGE</c>.
		/// </summary>
		public void Reconstruct()
		{
			var td = _tdo; if(td == null) return;
			_ApiSendMessageTASKDIALOGCONFIG(_dlg, (uint)DNative.TDM.NAVIGATE_PAGE, 0, ref td._c);
		}

		[DllImport("user32.dll", EntryPoint = "SendMessageW")]
		static extern nint _ApiSendMessageTASKDIALOGCONFIG(wnd hWnd, uint msg, nint wParam, in TASKDIALOGCONFIG c);
#endif
		/// <summary>
		/// Clicks a button. Normally it closes the dialog.
		/// </summary>
		/// <param name="buttonId">A button id or some other number that will be returned by <see cref="dialog.ShowDialog"/>.</param>
		/// <remarks>
		/// Call this method while the dialog is open, eg in an event handler.
		/// Sends message <see cref="DNative.TDM.CLICK_BUTTON"/>.
		/// </remarks>
		public bool Close(int buttonId = 0) {
			return 0 != Message(DNative.TDM.CLICK_BUTTON, buttonId);
		}
		
		/// <summary>
		/// Enables or disables a button.
		/// </summary>
		/// <remarks>
		/// Call this method while the dialog is open, eg in an event handler.
		/// Example: <c>d.Created += e => { e.d.Send.EnableButton(4, false); };</c>
		/// Sends message <see cref="DNative.TDM.ENABLE_BUTTON"/>.
		/// </remarks>
		public void EnableButton(int buttonId, bool enable) {
			Message(DNative.TDM.ENABLE_BUTTON, buttonId, enable ? 1 : 0);
		}
		
		/// <summary>
		/// Sets progress bar value, 0 to 100.
		/// </summary>
		/// <remarks>
		/// Call this method while the dialog is open, eg in an event handler.
		/// Sends message <see cref="DNative.TDM.SET_PROGRESS_BAR_POS"/>.
		/// </remarks>
		public int Progress(int percent) {
			if (percent < 100) Message(DNative.TDM.SET_PROGRESS_BAR_POS, percent + 1); //workaround for the progress bar control lag. https://stackoverflow.com/questions/5332616/disabling-net-progressbar-animation-when-changing-value
			return Message(DNative.TDM.SET_PROGRESS_BAR_POS, percent);
		}
	}
	
	#region public WinAPI
	
#pragma warning disable 1591 //missing XML documentation
	/// <summary>
	/// Rarely used constants for Windows API used by <see cref="dialog"/>.
	/// </summary>
	/// <remarks>
	/// Constants are in enums. Enum name is constant prefix. Enum members are without prefix. For example for <c>TDM_CLICK_BUTTON</c> use <c>DNative.TDM.CLICK_BUTTON</c>.
	/// </remarks>
	public static class DNative {
		/// <summary>
		/// Messages that your <see cref="dialog"/> event handler can send to the dialog.
		/// </summary>
		public enum TDM {
			NAVIGATE_PAGE = Api.WM_USER + 101,
			CLICK_BUTTON = Api.WM_USER + 102, // wParam = button id
			SET_MARQUEE_PROGRESS_BAR = Api.WM_USER + 103, // wParam = 0 (nonMarque) wParam != 0 (Marquee)
			SET_PROGRESS_BAR_STATE = Api.WM_USER + 104, // wParam = new progress state (0, 1 or 2)
			SET_PROGRESS_BAR_RANGE = Api.WM_USER + 105, // lParam = Math2.MakeLparam(min, max)
			SET_PROGRESS_BAR_POS = Api.WM_USER + 106, // wParam = new position
			SET_PROGRESS_BAR_MARQUEE = Api.WM_USER + 107, // wParam = 0 (stop marquee), wParam != 0 (start marquee), lParam = speed (milliseconds between repaints)
			SET_ELEMENT_TEXT = Api.WM_USER + 108, // wParam = element (enum DNative.TDE), lParam = new element text (string)
			CLICK_RADIO_BUTTON = Api.WM_USER + 110, // wParam = radio button id
			ENABLE_BUTTON = Api.WM_USER + 111, // wParam = button id, lParam = 0 (disable), lParam != 0 (enable)
			ENABLE_RADIO_BUTTON = Api.WM_USER + 112, // wParam = radio button id, lParam = 0 (disable), lParam != 0 (enable)
			CLICK_VERIFICATION = Api.WM_USER + 113, // wParam = 0 (unchecked), 1 (checked), lParam = 1 (set key focus)
			UPDATE_ELEMENT_TEXT = Api.WM_USER + 114, // wParam = element (enum DNative.TDE), lParam = new element text (string)
			SET_BUTTON_ELEVATION_REQUIRED_STATE = Api.WM_USER + 115, // wParam = button id, lParam = 0 (elevation not required), lParam != 0 (elevation required)
			UPDATE_ICON = Api.WM_USER + 116  // wParam = icon element (enum DNative.TDIE), lParam = new icon (icon handle or DIcon)
		}
		
		/// <summary>
		/// Notification messages that your <see cref="dialog"/> event handler receives.
		/// </summary>
		public enum TDN : uint {
			CREATED = 0,
			NAVIGATED = 1,
			BUTTON_CLICKED = 2,
			HYPERLINK_CLICKED = 3,
			TIMER = 4,
			DESTROYED = 5,
			RADIO_BUTTON_CLICKED = 6,
			DIALOG_CONSTRUCTED = 7,
			VERIFICATION_CLICKED = 8,
			HELP = 9,
			EXPANDO_BUTTON_CLICKED = 10
		}
		
		/// <summary>
		/// Constants for <see cref="DNative.TDM.SET_ELEMENT_TEXT"/> and <see cref="DNative.TDM.UPDATE_ELEMENT_TEXT"/> messages used with <see cref="dialog"/>.
		/// </summary>
		public enum TDE {
			CONTENT,
			EXPANDED_INFORMATION,
			FOOTER,
			MAIN_INSTRUCTION
		}
		
		/// <summary>
		/// Constants for <see cref="DNative.TDM.UPDATE_ICON"/> message used with <see cref="dialog"/>.
		/// </summary>
		public enum TDIE {
			ICON_MAIN,
			ICON_FOOTER
		}
	}
#pragma warning restore 1591 //missing XML documentation
	
	#endregion public WinAPI
	
}

namespace Au {
	public partial class dialog {
		#region private WinAPI
		
		delegate int _TaskDialogIndirectDelegate(in TASKDIALOGCONFIG c, out int pnButton, out int pnRadioButton, out int pChecked);
		static readonly _TaskDialogIndirectDelegate TaskDialogIndirect = _GetTaskDialogIndirect();
		
		static _TaskDialogIndirectDelegate _GetTaskDialogIndirect() {
			//Activate manifest that tells to use comctl32.dll version 6. The API is unavailable in version 5.
			//Need this if the host app does not have such manifest, eg if uses the default manifest added by Visual Studio.
			using (ActCtx_.Activate()) {
				//don't use DllImport, because it uses v5 comctl32.dll if it is already loaded.
				Api.GetDelegate(out _TaskDialogIndirectDelegate R, "comctl32.dll", "TaskDialogIndirect");
				return R;
			}
		}
		
		//TASKDIALOGCONFIG flags.
		[Flags]
		enum _TDF {
			ENABLE_HYPERLINKS = 0x0001,
			USE_HICON_MAIN = 0x0002,
			USE_HICON_FOOTER = 0x0004,
			ALLOW_DIALOG_CANCELLATION = 0x0008,
			USE_COMMAND_LINKS = 0x0010,
			USE_COMMAND_LINKS_NO_ICON = 0x0020,
			EXPAND_FOOTER_AREA = 0x0040,
			EXPANDED_BY_DEFAULT = 0x0080,
			VERIFICATION_FLAG_CHECKED = 0x0100,
			SHOW_PROGRESS_BAR = 0x0200,
			SHOW_MARQUEE_PROGRESS_BAR = 0x0400,
			CALLBACK_TIMER = 0x0800,
			POSITION_RELATIVE_TO_WINDOW = 0x1000,
			RTL_LAYOUT = 0x2000,
			NO_DEFAULT_RADIO_BUTTON = 0x4000,
			CAN_BE_MINIMIZED = 0x8000,
			//NO_SET_FOREGROUND = 0x00010000, //Win8, does not work
			SIZE_TO_CONTENT = 0x1000000,
		}
		
		//TASKDIALOGCONFIG buttons.
		[Flags]
		enum _TDCBF {
			OK = 1, Yes = 2, No = 4, Cancel = 8, Retry = 0x10, Close = 0x20,
		}
		
		[StructLayout(LayoutKind.Sequential, Pack = 1)]
		unsafe struct TASKDIALOG_BUTTON {
			public int id;
			public char* text;
		}
		
		[StructLayout(LayoutKind.Sequential, Pack = 1)]
		unsafe struct TASKDIALOGCONFIG {
			public int cbSize;
			public wnd hwndParent;
			public IntPtr hInstance;
			public _TDF dwFlags;
			public _TDCBF dwCommonButtons;
			public string pszWindowTitle;
			public IntPtr hMainIcon;
			public string pszMainInstruction;
			public string pszContent;
			public int cButtons;
			public TASKDIALOG_BUTTON* pButtons;
			public int nDefaultButton;
			public int cRadioButtons;
			public TASKDIALOG_BUTTON* pRadioButtons;
			public int nDefaultRadioButton;
			public string pszVerificationText;
			public string pszExpandedInformation;
			public string pszExpandedControlText;
			public string pszCollapsedControlText;
			public IntPtr hFooterIcon;
			public string pszFooter;
			public TaskDialogCallbackProc pfCallback;
			public IntPtr lpCallbackData;
			public int cxWidth;
		}
		
		delegate int TaskDialogCallbackProc(wnd hwnd, DNative.TDN notification, nint wParam, nint lParam, IntPtr data);
		
		#endregion private WinAPI
	}
}


================================================
FILE: Au/GUI/dialog-x-obsolete.cs
================================================
//info: the "x" in filename is for DocFX to correctly resolve links (changes file processing order).

#if !DEBUG && NET9_0_OR_GREATER
namespace Au;

public partial class dialog {
	/// <remarks>This overload is obsolete. For text with links now use <see cref="DText"/> instead of string + <i>onLinkClick</i>.</remarks>
	/// <inheritdoc cref="show(string, DText, Strings, DFlags, DIcon, AnyWnd, DText, DText, string, DControls, Coord, Coord, screen, int)" path="/param"/>
	[EditorBrowsable(EditorBrowsableState.Never)]
	[OverloadResolutionPriority(-1)]
	public dialog(
		string text1 = null, string text2 = null, Strings buttons = default, DFlags flags = 0, DIcon icon = 0, AnyWnd owner = default,
		string expandedText = null, string footer = null, string title = null, DControls controls = null,
		int defaultButton = 0, Coord x = default, Coord y = default, screen screen = default, int secondsTimeout = 0, Action<DEventArgs> onLinkClick = null
		) : this(text1, text2, buttons, flags, icon, owner, expandedText, footer, title, controls, x, y, screen, secondsTimeout) {
		if (defaultButton != 0) Default(defaultButton);
		if (onLinkClick != null) HyperlinkClicked += onLinkClick;
	}
	
	/// <remarks>This overload is obsolete. For text with links now use <see cref="DText"/> instead of string + <i>onLinkClick</i>.</remarks>
	/// <inheritdoc cref="show(string, DText, Strings, DFlags, DIcon, AnyWnd, DText, DText, string, DControls, Coord, Coord, screen, int)"/>
	[EditorBrowsable(EditorBrowsableState.Never)]
	[OverloadResolutionPriority(-1)]
	public static int show(
		string text1 = null, string text2 = null, Strings buttons = default, DFlags flags = 0, DIcon icon = 0, AnyWnd owner = default,
		string expandedText = null, string footer = null, string title = null, DControls controls = null,
		int defaultButton = 0, Coord x = default, Coord y = default, screen screen = default, int secondsTimeout = 0, Action<DEventArgs> onLinkClick = null
		) {
		var d = new dialog(text1, text2, buttons, flags, icon, owner,
			expandedText, footer, title, controls,
			defaultButton, x, y, screen, secondsTimeout, onLinkClick);
		return d.ShowDialog();
	}
	
	/// <remarks>This overload is obsolete. For text with links now use <see cref="DText"/> instead of string + <i>onLinkClick</i>.</remarks>
	/// <inheritdoc cref="showInput(out string, string, DText, DEdit, string, Strings, DFlags, AnyWnd, DText, DText, string, DControls, Coord, Coord, screen, int, string, Action{DEventArgs})"/>
	[EditorBrowsable(EditorBrowsableState.Never)]
	[OverloadResolutionPriority(-1)]
	public static bool showInput(out string s,
		string text1 = null, string text2 = null,
		DEdit editType = DEdit.Text, string editText = null, Strings comboItems = default,
		DFlags flags = 0, AnyWnd owner = default,
		string expandedText = null, string footer = null, string title = null, DControls controls = null,
		Coord x = default, Coord y = default, screen screen = default, int secondsTimeout = 0, Action<DEventArgs> onLinkClick = null,
		string buttons = "1 OK|2 Cancel", Action<DEventArgs> onButtonClick = null
		) {
		if (buttons.NE()) buttons = "1 OK|2 Cancel";
		var d = new dialog(text1, text2, buttons, flags, 0, owner, expandedText, footer, title, controls, 0, x, y, screen, secondsTimeout, onLinkClick);
		
		d.Edit(editType != 0 ? editType : DEdit.Text, editText, comboItems);
		if (onButtonClick != null) d.ButtonClicked += onButtonClick;
		
		bool r = 1 == d.ShowDialog();
		s = r ? d._controls.EditText : null;
		return r;
	}
	
	/// <remarks>This overload is obsolete. For text with links now use <see cref="DText"/> instead of string + <i>onLinkClick</i>.</remarks>
	/// <inheritdoc cref="showList(Strings, string, DText, DFlags, AnyWnd, DText, DText, string, DControls, Coord, Coord, screen, int)"/>
	[EditorBrowsable(EditorBrowsableState.Never)]
	[OverloadResolutionPriority(-1)]
	public static int showList(
		Strings list, string text1 = null, string text2 = null, DFlags flags = 0, AnyWnd owner = default,
		string expandedText = null, string footer = null, string title = null, DControls controls = null,
		int defaultButton = 0, Coord x = default, Coord y = default, screen screen = default, int secondsTimeout = 0,
		Action<DEventArgs> onLinkClick = null
		) {
		var d = new dialog(text1, text2, default, flags | DFlags.XCancel | DFlags.ExpandDown, 0, owner,
			expandedText, footer, title, controls,
			defaultButton, x, y, screen, secondsTimeout, onLinkClick);
		d.ButtonsList(list);
		return d.ShowDialog();
	}
	
	/// <remarks>This overload is obsolete. For text with links now use <see cref="DText"/> instead of string + <i>onLinkClick</i>.</remarks>
	/// <inheritdoc cref="showProgress(bool, string, DText, string, DFlags, AnyWnd, DText, DText, string, DControls, Coord, Coord, screen, int)"/>
	[EditorBrowsable(EditorBrowsableState.Never)]
	[OverloadResolutionPriority(-1)]
	public static dialog showProgress(bool marquee,
		string text1 = null, string text2 = null, string buttons = "0 Cancel", DFlags flags = 0, AnyWnd owner = default,
		string expandedText = null, string footer = null, string title = null, DControls controls = null,
		Coord x = default, Coord y = default, screen screen = default, int secondsTimeout = 0, Action<DEventArgs> onLinkClick = null
	) {
		if (buttons.NE()) buttons = "0 Cancel";
		
		var d = new dialog(text1, text2, buttons, flags, 0, owner,
			expandedText, footer, title, controls,
			0, x, y, screen, secondsTimeout, onLinkClick);
		
		d.Progress(true, marquee);
		
		d.ShowDialogNoWait();
		
		return d;
	}
	
	/// <remarks>This overload is obsolete. For text with links now use <see cref="DText"/> instead of string + <i>onLinkClick</i>.</remarks>
	/// <inheritdoc cref="showNoWait(string, DText, Strings, DFlags, DIcon, AnyWnd, DText, DText, string, DControls, Coord, Coord, screen, int)"/>
	[EditorBrowsable(EditorBrowsableState.Never)]
	[OverloadResolutionPriority(-1)]
	public static dialog showNoWait(
		string text1 = null, string text2 = null, Strings buttons = default, DFlags flags = 0, DIcon icon = 0, AnyWnd owner = default,
		string expandedText = null, string footer = null, string title = null, DControls controls = null,
		int defaultButton = 0, Coord x = default, Coord y = default, screen screen = default, int secondsTimeout = 0, Action<DEventArgs> onLinkClick = null
		) {
		var d = new dialog(text1, text2, buttons, flags, icon, owner,
			expandedText, footer, title, controls,
			defaultButton, x, y, screen, secondsTimeout, onLinkClick);
		d.ShowDialogNoWait();
		return d;
	}
	
	/// <inheritdoc cref="Title"/>
	[EditorBrowsable(EditorBrowsableState.Never)]
	public void SetTitleBarText(string title) { Title(title); }
	
	/// <summary>
	/// Sets text.
	/// </summary>
	/// <param name="text1">Heading text.</param>
	/// <param name="text2">Message text.</param>
	[EditorBrowsable(EditorBrowsableState.Never)]
	public void SetText(string text1 = null, string text2 = null) {
		_c.pszMainInstruction = text1;
		_c.pszContent = text2;
	}
	
	///<inheritdoc cref="Icon(DIcon)"/>
	[EditorBrowsable(EditorBrowsableState.Never)]
	public void SetIcon(DIcon icon) => Icon(icon);

	///<inheritdoc cref="Icon(object)"/>
	[EditorBrowsable(EditorBrowsableState.Never)]
	public void SetIcon(object icon) => Icon(icon);
	
	///<inheritdoc cref="Buttons"/>
	[EditorBrowsable(EditorBrowsableState.Never)]
	public void SetButtons(Strings buttons, bool asCommandLinks = false, Strings customButtons = default) {
		Buttons(buttons, asCommandLinks).ButtonsList(customButtons, asCommandLinks);
	}
	
	/// <summary>
	/// Specifies which button responds to the <c>Enter</c> key.
	/// If 0 or not set, auto-selects.
	/// </summary>
	/// <value>Button id.</value>
	[EditorBrowsable(EditorBrowsableState.Never)]
	public int DefaultButton { set { Default(value); } }
	
	///<inheritdoc cref="RadioButtons"/>
	[EditorBrowsable(EditorBrowsableState.Never)]
	public void SetRadioButtons(Strings buttons, int defaultId = 0) => RadioButtons(buttons, defaultId);
	
	///<inheritdoc cref="Checkbox"/>
	[EditorBrowsable(EditorBrowsableState.Never)]
	public void SetCheckbox(string text, bool check = false) => Checkbox(text, check);
	
	///<inheritdoc cref="ExpandedText"/>
	[EditorBrowsable(EditorBrowsableState.Never)]
	public void SetExpandedText(string text, bool showInFooter = false) => ExpandedText(text, showInFooter);
	
	///<inheritdoc cref="Expander"/>
	[EditorBrowsable(EditorBrowsableState.Never)]
	public void SetExpandControl(bool defaultExpanded, string collapsedText = null, string expandedText = null)
		=> Expander(defaultExpanded, collapsedText, expandedText);
	
	/// <summary>
	/// Adds text and common icon at the bottom of the dialog.
	/// </summary>
	/// <param name="text">Text, optionally preceded by an icon character and <c>|</c>, like <c>"i|Text"</c>. Icons: <c>x</c> error, <c>!</c> warning, <c>i</c> info, <c>v</c> shield, <c>a</c> app.</param>
	[EditorBrowsable(EditorBrowsableState.Never)]
	public void SetFooter(string text) => _SetFooter(text);
	
	/// <summary>
	/// Adds text and common icon at the bottom of the dialog.
	/// </summary>
	/// <param name="text">Text.</param>
	/// <param name="icon"></param>
	[EditorBrowsable(EditorBrowsableState.Never)]
	public void SetFooter(string text, DIcon icon) => FooterText(text).FooterIcon(icon);
	
	/// <summary>
	/// Adds text and custom icon at the bottom of the dialog.
	/// </summary>
	/// <inheritdoc cref="Icon(object)" path="/param"/>
	[EditorBrowsable(EditorBrowsableState.Never)]
	public void SetFooter(string text, object icon) => FooterText(text).FooterIcon(icon);
	
	///<inheritdoc cref="EditControl"/>
	[EditorBrowsable(EditorBrowsableState.Never)]
	public void SetEditControl(DEdit editType, string editText = null, Strings comboItems = default)
		=> Edit(editType, editText, comboItems);
	
	/// <summary>
	/// Makes the dialog wider.
	/// </summary>
	[EditorBrowsable(EditorBrowsableState.Never)]
	public int Width { set { _c.cxWidth = value / 2; } }
	
	///<inheritdoc cref="OwnerWindow"/>
	[EditorBrowsable(EditorBrowsableState.Never)]
	public void SetOwnerWindow(AnyWnd owner, bool ownerCenter = false, bool dontDisable = false)
		=> OwnerWindow(owner, ownerCenter, dontDisable);
	
	///<inheritdoc cref="XY"/>
	[EditorBrowsable(EditorBrowsableState.Never)]
	public void SetXY(Coord x, Coord y, bool rawXY = false) => XY(x, y, rawXY);
	
	/// <summary>
	/// Sets a timeout to close the dialog after <i>closeAfterS</i> seconds. Then <see cref="ShowDialog"/> returns <see cref="Timeout"/>.
	/// </summary>
	[EditorBrowsable(EditorBrowsableState.Never)]
	public void SetTimeout(int closeAfterS, string timeoutActionText = null, bool noInfo = false)
		=> CloseAfter(closeAfterS, timeoutActionText, noInfo);
}
#endif


================================================
FILE: Au/GUI/dialog.cs
================================================
//rejected: by default show dialog in screen of mouse, like with <c>dialog.options.defaultScreen = screen.ofMouse;</c>.
//	Some Windows etc dialogs do it, and for me it's probably better. Eg Explorer's Properties even is at mouse position (top-left corner).
//rejected: dialog.showCheckboxes. See Cookbook > Dialog - enum check-list, select.

namespace Au;

/// <summary>
/// Standard dialogs to show information or get user input.
/// </summary>
/// <remarks>
/// You can use static functions like <see cref="show"/> (less code) or create class instances.
/// 
/// Uses task dialog API <ms>TaskDialogIndirect</ms>.
/// 
/// Cannot be used in services. Instead use <see cref="System.Windows.Forms.MessageBox.Show"/> with option <c>ServiceNotification</c> or <c>DefaultDesktopOnly</c>, or API <ms>MessageBox</ms> with corresponding flags, or API <ms>WTSSendMessage</ms>.
/// </remarks>
/// <example>
/// Simple examples.
/// <code><![CDATA[
/// dialog.show("Example", "Message.);
/// 
/// if(!dialog.showYesNo("Continue?", "More info.")) return;
/// 
/// switch(dialog.show("Save?", "More info.", "1 Save|2 Don't save|0 Cancel")) {
/// case 1: print.it("save"); break;
/// case 2: print.it("don't"); break;
/// default: print.it("cancel"); break;
/// }
/// 
/// if(!dialog.showInput(out string s, "Example")) return;
/// print.it(s);
/// ]]></code>
/// 
/// This example creates a class instance, sets properties, shows dialog, uses events, uses result.
/// <code><![CDATA[
/// var d = new dialog("Example", "Message.");
/// d.Buttons("1 OK|2 Cancel|3 Custom|4 Custom2", asCommandLinks: true)
/// 	.Icon(DIcon.Warning)
/// 	.ExpandedText("Expanded info.", true)
/// 	.Checkbox("Check")
/// 	.RadioButtons("1 r1|2 r2")
/// 	.CloseAfter(30, "OK");
/// d.ButtonClicked += e => { print.it(e.Button); if(e.Button == 4) e.DontCloseDialog = true; };
/// d.Progress();
/// d.Timer += e => { e.d.Send.Progress(e.TimerTimeMS / 100); };
/// var r = d.ShowDialog();
/// print.it(r, d.Controls.IsChecked, d.Controls.RadioId);
/// switch(r) { case 1: print.it("OK"); break; case dialog.Timeout: print.it("timeout"); break; }
/// ]]></code>
/// </example>
public partial class dialog {
	#region static options
	
	/// <summary>
	/// Default options used by <see cref="dialog"/> class functions.
	/// </summary>
	public static class options {
		/// <summary>
		/// Default title bar text.
		/// Default value - <see cref="script.name"/>. In exe it is exe file name like <c>"Example.exe"</c>.
		/// </summary>
		public static string defaultTitle {
			get => _defaultTitle ?? script.name;
			set { _defaultTitle = value; }
		}
		static string _defaultTitle;
		
		/// <summary>
		/// Right-to-left layout.
		/// </summary>
		public static bool rtlLayout { get; set; }
		
		/// <summary>
		/// If there is no owner window, let the dialog be always on top of most other windows.
		/// Default <c>true</c>.
		/// </summary>
		/// <seealso cref="DFlags"/>
		public static bool topmostIfNoOwnerWindow { get; set; } = true;
		
		/// <summary>
		/// Show dialogs on this screen when screen is not explicitly specified (<see cref="InScreen"/> or parameter <i>screen</i>) and there is no owner window.
		/// The <see cref="screen"/> must be lazy or empty.
		/// </summary>
		/// <exception cref="ArgumentException"><see cref="screen"/> with <c>Handle</c>. Must be lazy or empty.</exception>
		/// <example>
		/// <code><![CDATA[
		/// dialog.options.defaultScreen = screen.ofActiveWindow;
		/// dialog.options.defaultScreen = screen.ofMouse;
		/// dialog.options.defaultScreen = screen.at.left(lazy: true);
		/// dialog.options.defaultScreen = screen.index(1, lazy: true);
		/// ]]></code>
		/// </example>
		public static screen defaultScreen {
			get => _defaultScreen;
			set => _defaultScreen = value.ThrowIfWithHandle_;
		}
		static screen _defaultScreen;
		
		/// <summary>
		/// If icon not specified, use <see cref="DIcon.App"/>.
		/// </summary>
		public static bool useAppIcon { get; set; }
		
		/// <summary>
		/// If owner window not specified (see <see cref="OwnerWindow"/>), use the active or top window of current thread as owner window (disable it, etc).
		/// </summary>
		public static bool autoOwnerWindow { get; set; }
		
		/// <summary>
		/// Timeout text format string. See <see cref="CloseAfter(int, string, bool)"/>.
		/// </summary>
		/// <remarks>
		/// Default: <c>"{0} s until this dialog closes, unless clicked.\nTimeout action: {1}."</c>.
		/// Use placeholder <c>{0}</c> for seconds (in the first line) and <c>{1}</c> for timeout action (in the second line). 
		/// </remarks>
		public static string timeoutTextFormat { get; set; } = c_defaultTimeoutTextFormat;
		
		internal const string c_defaultTimeoutTextFormat = "{0} s until this dialog closes, unless clicked.\nTimeout action: {1}.";
	}
	
	#endregion static options
	
	TASKDIALOGCONFIG _c;
	DFlags _flags;
	
	dialog(DFlags flags) {
		_c.cbSize = Api.SizeOf(_c);
		_flags = flags;
		RtlLayout = options.rtlLayout;
	}
	
	/// <summary>
	/// Initializes a new <see cref="dialog"/> instance and sets main properties.
	/// </summary>
	/// <inheritdoc cref="show" path="/param"/>
	public dialog(
		string text1 = null, DText text2 = null, Strings buttons = default, DFlags flags = 0, DIcon icon = 0, AnyWnd owner = default,
		DText expandedText = null, DText footer = null, string title = null, DControls controls = null,
		Coord x = default, Coord y = default, screen screen = default, int secondsTimeout = 0
		) : this(flags) {
		Text1(text1);
		Text2(text2);
		Icon(icon);
		Buttons(buttons, 0 != (flags & DFlags.CommandLinks));
		if (controls != null) {
			_controls = controls;
			if (controls.Checkbox != null) Checkbox(controls.Checkbox, controls.IsChecked);
			if (controls.RadioButtons.Value != null) RadioButtons(controls.RadioButtons, controls.RadioId);
		}
		OwnerWindow(owner, 0 != (flags & DFlags.CenterOwner));
		XY(x, y, 0 != (flags & DFlags.RawXY));
		InScreen(screen);
		CloseAfter(secondsTimeout);
		ExpandedText(expandedText, 0 != (flags & DFlags.ExpandDown));
		_SetFooter(footer);
		Title(title);
		if (flags.Has(DFlags.Wider)) Wider(700);
		CanBeMinimized = flags.Has(DFlags.MinimizeButton);
		if (flags.Has(DFlags.Topmost)) Topmost = true; else if (flags.Has(DFlags.NoTopmost)) Topmost = false;
	}
	
	#region set properties
	
	void _SetFlag(_TDF flag, bool on) {
		if (on) _c.dwFlags |= flag; else _c.dwFlags &= ~flag;
	}
	
	bool _HasFlag(_TDF flag) {
		return (_c.dwFlags & flag) != 0;
	}
	
	/// <summary>
	/// Sets title bar text.
	/// If not set, will use <see cref="options.defaultTitle"/>.
	/// </summary>
	public dialog Title(string title) {
		_c.pszWindowTitle = title.NE() ? options.defaultTitle : title; //info: if "", API uses "ProcessName.exe".
		return this;
	}
	
	/// <summary>
	/// Sets heading text.
	/// </summary>
	/// <param name="text">Text. Can be <c>null</c>.</param>
	public dialog Text1(string text) {
		_c.pszMainInstruction = text;
		return this;
	}
	
	/// <summary>
	/// Sets message text.
	/// </summary>
	/// <param name="text">Text. Can be string, or string with links like <c><![CDATA[new("Text <a>link</a> text.", e => { print.it("link"); })]]></c>, or <c>null</c>.</param>
	public dialog Text2(DText text) {
		_c.pszContent = _DTextGetText(text, 0);
		return this;
	}
	
	string _DTextGetText(DText t, int caller) {
		if (t is null || t.text.NE()) return null;
		if (t.links.NE_()) return t.text;
		
		(_links ??= [[], [], []])[caller] = t.links; //replace old items in _links
		
		int i = 0;
		return t.text.RxReplace(@"<a\K(?=>.+?</a>)", m => {
			if (i == t.links.Length) return "";
			return $" href=\"{c_guidLink};{caller};{i++}\"";
		});
	}
	const string c_guidLink = "37de6377cf1c43a2a6eb9a7945fca3c0";
	Action<DEventArgs>[][] _links;
	
	bool _DTextLinkClicked(string href) {
		if (_links != null && href is { Length: > 35 } s && s.Starts(c_guidLink) && s.ToInt(out int caller, 33) && (uint)caller < 3 && s.ToInt(out int i, 35) && (uint)i < _links[caller].Length) {
			_links[caller][i]?.Invoke(new(this, _dlg, DNative.TDN.HYPERLINK_CLICKED, 0, 0, 0, null));
			return true;
		}
		return false;
	}
	
	/// <summary>
	/// Sets common icon.
	/// </summary>
	/// <remarks>
	/// The value also can be a native icon group resource id (cast to <see cref="DIcon"/>), in range 1 to 0xf000.
	/// </remarks>
	public dialog Icon(DIcon icon) {
		_c.hMainIcon = (nint)icon;
		_iconGC = null;
		return this;
	}
	
	/// <summary>
	/// Sets custom icon.
	/// </summary>
	/// <param name="icon">Can be:
	/// <br/>• <see cref="icon"/>.
	/// <br/>• <see cref="System.Drawing.Icon"/>.
	/// <br/>• <c>IntPtr</c> - native icon handle.
	/// <br/>• <see cref="System.Drawing.Bitmap"/>.
	/// <br/>• string - XAML image, eg copied from the <b>Icons</b> tool. See <see cref="ImageUtil.LoadGdipBitmapFromXaml"/>.
	/// </param>
	/// <remarks>
	/// The icon should be of logical size 32 or 16.
	/// </remarks>
	public dialog Icon(object icon) {
		_iconGC = icon; //will set when showing dialog, because may need screen DPI
		_c.hMainIcon = 0;
		return this;
		//tested: displays original-size 32 and 16 icons, but shrinks bigger icons to 32.
	}
	object _iconGC; //GC
	
	#region buttons
	
	const int c_idOK = 1;
	const int c_idCancel = 2;
	const int c_idRetry = 4;
	const int c_idYes = 6;
	const int c_idNo = 7;
	const int c_idClose = 8;
	const int c_idTimeout = int.MinValue;
	
	/// <summary>
	/// The return value of <c>ShowX</c> functions on timeout.
	/// </summary>
	public const int Timeout = int.MinValue;
	
	_Buttons _buttons;
	
	struct _Buttons {
		List<(int id, string s)> _customButtons, _radioButtons;
		
		int _defaultButtonUserId;
		bool _isDefaultButtonSet;
		public int DefaultButtonUserId { get => _defaultButtonUserId; set { _defaultButtonUserId = value; _isDefaultButtonSet = true; } }
		
		bool _hasXButton;
		
		public _TDCBF SetButtons(Strings buttons, Strings customButtons) {
			_customButtons = null;
			_mapIdUserNative = null;
			_defaultButtonUserId = 0;
			_isDefaultButtonSet = false;
			
			switch (customButtons.Value) {
			case string s:
				_ParseButtons(s, true);
				break;
			case IEnumerable<string> e:
				int id = 0;
				foreach (var v in e) {
					string s = _ParseSingleString(v, ref id, true);
					(_customButtons ??= new()).Add((id, s));
				}
				DefaultButtonUserId = 1;
				break;
			}
			
			return _ParseButtons(buttons, false);
		}
		
		_TDCBF _ParseButtons(Strings buttons, bool onlyCustom) {
			var ba = buttons.ToArray(); if (ba.NE_()) return 0;
			
			_TDCBF commonButtons = 0;
			int id = 0, nextNativeId = 100;
			
			foreach (var v in ba) {
				string s = _ParseSingleString(v, ref id, onlyCustom);
				
				int nativeId = 0;
				if (!onlyCustom) {
					switch (s) {
					case "OK": commonButtons |= _TDCBF.OK; nativeId = c_idOK; break;
					case "Yes": commonButtons |= _TDCBF.Yes; nativeId = c_idYes; break;
					case "No": commonButtons |= _TDCBF.No; nativeId = c_idNo; break;
					case "Cancel": commonButtons |= _TDCBF.Cancel; nativeId = c_idCancel; break;
					case "Retry": commonButtons |= _TDCBF.Retry; nativeId = c_idRetry; break;
					case "Close": commonButtons |= _TDCBF.Close; nativeId = c_idClose; break;
					}
				}
				
				if (nativeId == 0) { //custom button
					(_customButtons ??= new()).Add((id, s));
					if (id < 0) nativeId = nextNativeId++; //need to map, because native ids of positive user ids are minus user ids
				}
				if (nativeId != 0) (_mapIdUserNative ??= new()).Add((id, nativeId));
				
				if (!_isDefaultButtonSet) DefaultButtonUserId = id;
			}
			
			return commonButtons;
		}
		
		static string _ParseSingleString(string s, ref int id, bool dontSplit) {
			if (!dontSplit && StringUtil.ParseIntAndString(s, out var i, out string r)) id = i; else { r = s; id++; }
			r = r.Trim("\r\n"); //API does not like newline at start, etc
			if (r.Length == 0) r = " "; //else API exception
			else r = r.Replace("\r\n", "\n"); //API adds 2 newlines for \r\n. Only for custom buttons, not for other controls/parts.
			return r;
		}
		
		public void SetRadioButtons(Strings buttons) {
			_radioButtons = null;
			var ba = buttons.ToArray(); if (ba.NE_()) return;
			
			_radioButtons = new();
			int id = 0;
			foreach (var v in ba) {
				string s = _ParseSingleString(v, ref id, false);
				_radioButtons.Add((id, s));
			}
		}
		
		List<(int userId, int nativeId)> _mapIdUserNative;
		
		public int MapIdUserToNative(int userId) {
			if (userId == c_idTimeout) return userId; //0x80000000
			if (_mapIdUserNative != null) { //common buttons, and custom buttons with negative user id
				foreach (var v in _mapIdUserNative) if (v.userId == userId) return v.nativeId;
			}
			return -userId; //custom button with positive user id
		}
		
		public int MapIdNativeToUser(int nativeId) {
			if (nativeId == c_idTimeout) return nativeId; //0x80000000
			if (nativeId <= 0) return -nativeId; //custom button with positive user id
			if (_mapIdUserNative != null) { //common buttons, and custom buttons with negative user id
				foreach (var v in _mapIdUserNative) if (v.nativeId == nativeId) return v.userId;
			}
			if (nativeId == c_idOK) return nativeId; //single OK button auto-added when no buttons specified
			Debug.Assert(nativeId == c_idCancel && _hasXButton);
			return 0;
		}
		
		/// <summary>
		/// Sets <c>c.pButtons</c>, <c>c.cButtons</c>, <c>c.pRadioButtons</c> and <c>c.cRadioButtons</c>.
		/// Later call <c>MarshalFreeButtons</c>.
		/// </summary>
		public unsafe void MarshalButtons(ref TASKDIALOGCONFIG c) {
			c.pButtons = _MarshalButtons(false, out c.cButtons);
			c.pRadioButtons = _MarshalButtons(true, out c.cRadioButtons);
			
			_hasXButton = ((c.dwFlags & _TDF.ALLOW_DIALOG_CANCELLATION) != 0);
		}
		
		/// <summary>
		/// Frees memory allocated by <c>MarshalButtons</c> and sets the <i>c</i> members to <c>null</c>/0.
		/// </summary>
		public unsafe void MarshalFreeButtons(ref TASKDIALOGCONFIG c) {
			MemoryUtil.Free(c.pButtons);
			MemoryUtil.Free(c.pRadioButtons);
			c.pButtons = null; c.pRadioButtons = null;
			c.cButtons = 0; c.cRadioButtons = 0;
		}
		
		unsafe TASKDIALOG_BUTTON* _MarshalButtons(bool radio, out int nButtons) {
			var a = radio ? _radioButtons : _customButtons;
			int n = a == null ? 0 : a.Count;
			nButtons = n;
			if (n == 0) return null;
			int nba = n * sizeof(TASKDIALOG_BUTTON), nb = nba;
			foreach (var v in a) nb += (v.s.Length + 1) * 2;
			var r = (TASKDIALOG_BUTTON*)MemoryUtil.Alloc(nb);
			char* s = (char*)((byte*)r + nba);
			for (int i = 0; i < n; i++) {
				var v = a[i];
				r[i].id = radio ? v.id : MapIdUserToNative(v.id);
				int len = v.s.Length + 1;
				r[i].text = Api.lstrcpyn(s, v.s, len);
				s += len;
			}
			return r;
		}
	}
	
	/// <summary>
	/// Sets buttons.
	/// </summary>
	/// <param name="buttons">
	/// List of button names or <c>"id name"</c>. Examples: <c>"OK|Cancel"</c>, <c>"1 Yes|2 No"</c>, <c><![CDATA["1 &Save|2 Do&n't Save|0 Cancel"]]></c>, <c>["1 One", "2 Two"]</c>.
	/// Can contain common buttons (named <b>OK</b>, <b>Yes</b>, <b>No</b>, <b>Retry</b>, <b>Cancel</b>, <b>Close</b>) and/or custom buttons (any other names).
	/// This first in the list button will be focused (aka <i>default button</i>).
	/// More info in Remarks.
	/// </param>
	/// <param name="asCommandLinks">The style of custom buttons. If <c>false</c> - row of classic buttons. If <c>true</c> - column of command-link buttons that can have multiline text.</param>
	/// <remarks>
	/// If buttons not set, the dialog will have <b>OK</b> button, id 1.
	/// 
	/// Missing ids are auto-generated, for example <c>"OK|Cancel|100 Custom1|Custom2"</c> is the same as <c>"1 OK|2 Cancel|100 Custom1|101 Custom2"</c>.
	/// 
	/// The first in the list button is the default button, ie is focused and therefore responds to the <c>Enter</c> key. For example, <c>"2 No|1 Yes"</c> adds <b>Yes</b> and <b>No</b> buttons and makes <b>No</b> default.
	/// 
	/// To create keyboard shortcuts, use <c>&amp;</c> character in custom button labels. Use <c>&amp;&amp;</c> for literal <c>&amp;</c>. Example: <c><![CDATA["1 &Tuesday[]2 T&hursday[]3 Saturday && Sunday"]]></c>.
	/// 
	/// Trims newlines around ids and labels. For example, <c>"\r\n1 One\r\n|\r\n2\r\nTwo\r\n\r\n"</c> is the same as <c>"1 One|2 Two"</c>.
	/// 
	/// There are 6 <i>common buttons</i>: <b>OK</b>, <b>Yes</b>, <b>No</b>, <b>Retry</b>, <b>Cancel</b>, <b>Close</b>. Buttons that have other names are <i>custom buttons</i>.
	/// How common buttons are different:
	/// 1. The button style is not affected by <i>asCommandLinks</i> or <see cref="DFlags.CommandLinks"/>.
	/// 2. They have keyboard shortcuts that cannot be changed. Inserting <c>&amp;</c> in a label makes it a custom button.
	/// 3. Button <b>Cancel</b> can be selected with the <c>Esc</c> key. It also adds <b>X</b> (Close) button in title bar, which selects <b>Cancel</b>.
	/// 4. Always displayed in standard order (eg <b>Yes</b> <b>No</b>, never <b>No</b> <b>Yes</b>). But you can for example use <c>"2 No|1 Yes"</c> to set default button = <b>No</b>.
	/// 5. The displayed button label is localized, ie different when the Windows UI language is not English.
	/// </remarks>
	public dialog Buttons(Strings buttons = default, bool asCommandLinks = false) {
		_btn.buttons = buttons;
		_btn.commandLinks = asCommandLinks;
		return this;
	}
	
	/// <summary>
	/// Sets custom buttons to be displayed as a list.
	/// </summary>
	/// <param name="buttons">
	/// List of button names. Can be string like <c>"One|Two|..."</c> or <c>string[]</c> or <c>List&lt;string&gt;</c>.
	/// Button ids will be 1, 2, ... . Default button will be 1, unless changed with <see cref="Default"/>.
	/// Unlike <see cref="Buttons"/>, this function does not allow to specify button ids; also all specified buttons will be custom buttons, even if named like <c>"OK"</c>.
	/// </param>
	/// <param name="asCommandLinks">The style of custom buttons. If <c>false</c> - row of classic buttons. If <c>true</c> - column of command-link buttons that can have multiline text.</param>
	/// <remarks>
	/// You can call <see cref="Buttons"/> too, to add common buttons (like <b>OK</b>, <b>Cancel</b>); use negative button ids. Both functions set the style (classic or command link) of custom buttons; wins the one called last.
	/// </remarks>
	public dialog ButtonsList(Strings buttons = default, bool asCommandLinks = true) {
		_btn.list = buttons;
		_btn.commandLinks = asCommandLinks;
		return this;
	}
	
	(Strings buttons, Strings list, bool commandLinks, int idDefault) _btn;
	
	/// <summary>
	/// Sets default button. It responds to the <c>Enter</c> key.
	/// </summary>
	/// <param name="id">Button id. If 0 - the first button in the list.</param>
	public dialog Default(int id) {
		_btn.idDefault = id;
		return this;
	}
	
	/// <summary>
	/// Adds radio buttons.
	/// </summary>
	/// <param name="buttons">A list of strings <c>"id text"</c> separated by <c>|</c>, like <c>"1 One|2 Two|3 Three"</c>.</param>
	/// <param name="idDefault">Check the radio button that has this id. If omitted or 0, checks the first. If negative, does not check.</param>
	/// <remarks>
	/// To get selected radio button id after closing the dialog, use <see cref="Controls"/>.
	/// </remarks>
	public dialog RadioButtons(Strings buttons, int idDefault = 0) {
		_controls ??= new();
		_controls.RadioButtons = buttons;
		_controls.RadioId = idDefault;
		return this;
	}
	
	#endregion buttons
	
	/// <summary>
	/// Adds check box (if <i>text</i> is not <c>null</c>/empty).
	/// </summary>
	/// <remarks>
	/// To get check box state after closing the dialog, use <see cref="Controls"/>.
	/// </remarks>
	public dialog Checkbox(string text, bool check = false) {
		_controls ??= new();
		_controls.Checkbox = text;
		_controls.IsChecked = check;
		return this;
	}
	
	/// <summary>
	/// Adds text in expander control.
	/// </summary>
	/// <param name="showInFooter">Show the text at the bottom of the dialog.</param>
	/// <inheritdoc cref="Text2" path="/param"/>
	public dialog ExpandedText(DText text, bool showInFooter = false) {
		string s = _DTextGetText(text, 1);
		_SetFlag(_TDF.EXPAND_FOOTER_AREA, showInFooter);
		_c.pszExpandedInformation = s;
		return this;
	}
	
	/// <summary>
	/// Set properties of the expander control that shows and hides text added by <see cref="ExpandedText"/>.
	/// </summary>
	/// <param name="expand"></param>
	/// <param name="collapsedText"></param>
	/// <param name="expandedText"></param>
	public dialog Expander(bool expand, string collapsedText = null, string expandedText = null) {
		_SetFlag(_TDF.EXPANDED_BY_DEFAULT, expand);
		_c.pszCollapsedControlText = collapsedText;
		_c.pszExpandedControlText = expandedText;
		return this;
	}
	
	/// <summary>
	/// Adds footer text.
	/// </summary>
	/// <inheritdoc cref="Text2" path="/param"/>
	public dialog FooterText(DText text) {
		_footerText = _DTextGetText(text, 2);
		return this;
	}
	string _footerText;
	
	/// <summary>
	/// Adds footer icon.
	/// </summary>
	/// <remarks>
	/// The value also can be a native icon group resource id (cast to <see cref="DIcon"/>), in range 1 to 0xf000.
	/// </remarks>
	public dialog FooterIcon(DIcon icon) {
		_c.hFooterIcon = (nint)icon;
		_iconFooterGC = null;
		return this;
	}
	
	/// <summary>
	/// Sets footer icon.
	/// </summary>
	/// <inheritdoc cref="Icon(object)" path="/param"/>
	/// <remarks>
	/// The icon should be of logical size 16.
	/// </remarks>
	public dialog FooterIcon(object icon) {
		_iconFooterGC = icon; //will set when showing dialog, because may need screen DPI
		_c.hFooterIcon = 0;
		return this;
	}
	object _iconFooterGC; //GC
	
	//Used by ctor. Supports string with icon, like "i|Info".
	void _SetFooter(DText text) {
		var s = _DTextGetText(text, 2);
		if (s?.Eq(1, '|') ?? false) {
			FooterIcon(s[0] switch { 'x' => DIcon.Error, '!' => DIcon.Warning, 'i' => DIcon.Info, 'v' => DIcon.Shield, 'a' => DIcon.App, _ => 0 });
			s = s[2..];
		}
		_footerText = s;
	}
	
	/// <summary>
	/// Adds Edit or ComboBox control.
	/// </summary>
	/// <param name="editType">Control type/style.</param>
	/// <param name="editText">Initial edit field text.</param>
	/// <param name="comboItems">Combo box items used when <i>editType</i> is <see cref="DEdit.Combo"/>.</param>
	/// <remarks>
	/// To get control text after closing the dialog, use <see cref="Controls"/>.
	/// 
	/// Dialogs with an input field cannot have a progress bar.
	/// </remarks>
	public dialog Edit(DEdit editType, string editText = null, Strings comboItems = default) {
		_controls ??= new();
		_controls.EditType = editType;
		_controls.EditText = editText;
		_controls.ComboItems = comboItems;
		return this;
	}
	
	/// <summary>
	/// Makes the dialog wider.
	/// </summary>
	/// <param name="width">
	/// Width of the dialog's client area, in logical pixels. The actual width depends on the screen DPI.
	/// If the value is less than default width, will be used default width.
	/// </param>
	/// <seealso cref="DFlags.Wider"/>
	public dialog Wider(int width) {
		_c.cxWidth = width / 2;
		return this;
	}
	
	/// <summary>
	/// Sets owner window.
	/// </summary>
	/// <param name="owner">Owner window, or one of its child/descendant controls. Can be <see cref="wnd"/>, WPF window or element, winforms window or control. Can be <c>null</c>.</param>
	/// <param name="ownerCenter">Show the dialog in the center of the owner window.</param>
	/// <param name="dontDisable">Don't disable the owner window. If <c>false</c>, disables if it belongs to this thread.</param>
	/// <remarks>
	/// The owner window will be disabled, and this dialog will be on top of it.
	/// This window will be in owner's screen, if screen was not explicitly specified (see <see cref="InScreen"/>). <see cref="dialog.options.defaultScreen"/> is ignored.
	/// </remarks>
	/// <seealso cref="options.autoOwnerWindow"/>
	public dialog OwnerWindow(AnyWnd owner, bool ownerCenter = false, bool dontDisable = false) {
		_c.hwndParent = owner.IsEmpty ? default : owner.Hwnd.Window;
		_SetFlag(_TDF.POSITION_RELATIVE_TO_WINDOW, ownerCenter);
		_enableOwner = dontDisable;
		return this;
	}
	bool _enableOwner;
	
	/// <summary>
	/// Sets dialog position in screen.
	/// </summary>
	/// <param name="x">X position in screen. If <c>default</c> - screen center. Examples: <c>10</c>, <c>^10</c> (reverse), <c>.5f</c> (fraction).</param>
	/// <param name="y">Y position in screen. If <c>default</c> - screen center.</param>
	/// <param name="rawXY"><i>x y</i> are relative to the primary screen (ignore <see cref="InScreen"/> etc).</param>
	/// <seealso cref="InScreen"/>
	public dialog XY(Coord x, Coord y, bool rawXY = false) {
		_x = x; _y = y;
		_rawXY = rawXY && (!_x.IsEmpty || !_y.IsEmpty);
		return this;
	}
	Coord _x, _y; bool _rawXY;
	
	/// <summary>
	/// Sets the screen (display monitor) where to show the dialog in multi-screen environment.
	/// </summary>
	/// <remarks>
	/// If not set, will be used owner window's screen or <see cref="options.defaultScreen"/>.
	/// More info: <see cref="screen"/>, <see cref="wnd.MoveInScreen"/>.
	/// </remarks>
	public dialog InScreen(screen screen) {
		Screen = screen;
		return this;
	}
	
	/// <summary>
	/// Sets to automatically close the dialog after <i>timeoutS</i> seconds. Then <see cref="ShowDialog"/> returns <see cref="Timeout"/>.
	/// </summary>
	/// <param name="timeoutS">Timeout in seconds.</param>
	/// <param name="timeoutAction">Short text to display what will happen on timeout. For example button name. See <see cref="options.timeoutTextFormat"/>.</param>
	/// <param name="noInfo">Don't display the timeout information in the footer.</param>
	public dialog CloseAfter(int timeoutS, string timeoutAction = null, bool noInfo = false) {
		_timeoutS = timeoutS;
		_timeoutActionText = timeoutAction;
		_timeoutNoInfo = noInfo;
		return this;
	}
	int _timeoutS; bool _timeoutActive, _timeoutNoInfo; string _timeoutActionText;
	
	/// <summary>
	/// Sets progress bar.
	/// </summary>
	/// <param name="show">Whether to show progress bar.</param>
	/// <param name="marquee">Show just an animation that does not indicate a progress.</param>
	/// <remarks>
	/// To start or stop the marquee animation, use code like this when the dialog is visible: <c>d.Send.Message(DNative.TDM.SET_PROGRESS_BAR_MARQUEE, 1);</c>.
	/// To set progress, use <see cref="DSend.Progress(int)"/> when the dialog is visible. Example in <see cref="showProgress"/>.
	/// </remarks>
	public dialog Progress(bool show, bool marquee = false) {
		ProgressBar = show && !marquee;
		ProgressBarMarquee = show && marquee;
		return this;
	}
	
	#endregion set properties
	
	#region old hidden non-fluent set properties
	
	///<inheritdoc cref="InScreen"/>
	[EditorBrowsable(EditorBrowsableState.Never)]
	public screen Screen { set; get; }
	
	/// <summary>
	/// Show progress bar.
	/// </summary>
	[EditorBrowsable(EditorBrowsableState.Never)]
	public bool ProgressBar { set; get; }
	
	/// <summary>
	/// Show progress bar that does not indicate which part of the work is already done.
	/// </summary>
	[EditorBrowsable(EditorBrowsableState.Never)]
	public bool ProgressBarMarquee { set; get; }
	
	/// <summary>
	/// Right-to left layout.
	/// Default = <see cref="dialog.options.rtlLayout"/>.
	/// </summary>
	[EditorBrowsable(EditorBrowsableState.Never)] //use options.rtlLayout instead
	public bool RtlLayout { set; get; }
	
	/// <summary>
	/// Add <b>Minimize</b> button to the title bar.
	/// </summary>
	[EditorBrowsable(EditorBrowsableState.Never)] //use DFlags.MinimizeButton instead
	public bool CanBeMinimized { set; get; }
	
	/// <summary>
	/// Makes the dialog window topmost or non-topmost.
	/// </summary>
	/// <value>
	/// <c>true</c> - set topmost style when creating the dialog.
	/// <c>false</c> - don't set.
	/// <c>null</c> (default) - topmost if both these are true: no owner window, <see cref="dialog.options.topmostIfNoOwnerWindow"/> is <c>true</c> (default).
	/// </value>
	[EditorBrowsable(EditorBrowsableState.Never)]
	public bool? Topmost { set; get; }
	
	#endregion
	
	wnd _dlg;
	int _threadIdInShow;
	bool _locked;
	
	/// <summary>
	/// Shows the dialog.
	/// Call this method after setting text and other properties.
	/// </summary>
	/// <returns>Selected button id.</returns>
	/// <exception cref="Win32Exception">Failed to show dialog. Unlikely.</exception>
	public unsafe int ShowDialog() {
		//info: named ShowDialog, not Show, to not confuse with the static Show() which is used almost everywhere in documentation.
		
		_result = 0;
		_isClosed = false;
		
		Title(_c.pszWindowTitle); //if not set, sets default
		_EditControlInitBeforeShowDialog(); //don't reorder, must be before flags
		
		if (_c.hwndParent.Is0 && options.autoOwnerWindow) {
			var wa = wnd.thisThread.active;
			if (wa.Is0) wa = wnd.getwnd.TopThreadWindow_(onlyVisible: true, nonPopup: true);
			_c.hwndParent = wa; //info: MessageBox.Show also does it, but it also disables all thread windows
		}
		if (_c.hwndParent.IsAlive) {
			if (!_enableOwner && !_c.hwndParent.IsOfThisThread) _enableOwner = true;
			if (_enableOwner && !_c.hwndParent.IsEnabled(false)) _enableOwner = false;
		}
		
		_SetPos(true); //get screen
		
		_SetFlag(_TDF.SIZE_TO_CONTENT, true); //can make max 50% wider
		_SetFlag(_TDF.ALLOW_DIALOG_CANCELLATION, _flags.Has(DFlags.XCancel));
		_SetFlag(_TDF.RTL_LAYOUT, RtlLayout);
		_SetFlag(_TDF.CAN_BE_MINIMIZED, CanBeMinimized);
		_SetFlag(_TDF.SHOW_PROGRESS_BAR, ProgressBar);
		_SetFlag(_TDF.SHOW_MARQUEE_PROGRESS_BAR, ProgressBarMarquee);
		_SetFlag(_TDF.ENABLE_HYPERLINKS, _links != null || HyperlinkClicked != null);
		_SetFlag(_TDF.CALLBACK_TIMER, (_timeoutS > 0 || Timer != null));
		
		_c.dwCommonButtons = _buttons.SetButtons(_btn.buttons, _btn.list);
		_SetFlag(_TDF.USE_COMMAND_LINKS, _btn.commandLinks);
		_c.nDefaultButton = _buttons.MapIdUserToNative(_btn.idDefault != 0 ? _btn.idDefault : _buttons.DefaultButtonUserId);
		
		if (_controls != null) {
			_c.pszVerificationText = _controls.Checkbox;
			_SetFlag(_TDF.VERIFICATION_FLAG_CHECKED, _controls.IsChecked);
			
			_buttons.SetRadioButtons(_controls.RadioButtons);
			_c.nDefaultRadioButton = _controls.RadioId;
			_SetFlag(_TDF.NO_DEFAULT_RADIO_BUTTON, _controls.RadioId < 0);
		}
		
		_timeoutActive = _timeoutS > 0;
		_c.pszFooter = _timeoutActive && !_timeoutNoInfo ? _TimeoutFooterText(_timeoutS) : _footerText;
		
		screen screenForIcons = default;
		if (_iconGC != null) _c.hMainIcon = _IconHandle(_iconGC, false); else if (_c.hMainIcon == 0 && options.useAppIcon) _c.hMainIcon = (nint)DIcon.App;
		if (_iconFooterGC != null) _c.hFooterIcon = _IconHandle(_iconFooterGC, true);
		_SetFlag(_TDF.USE_HICON_MAIN, _c.hMainIcon != 0 && _iconGC != null);
		_SetFlag(_TDF.USE_HICON_FOOTER, _c.hFooterIcon != 0 && _iconFooterGC != null);
		
		IntPtr _IconHandle(object o, bool small) {
			if (o is string s) {
				int k = small ? 16 : 32;
				if (screenForIcons.IsEmpty) screenForIcons = _GetScreenBeforeShow();
				k = Dpi.Scale(k, screenForIcons.Dpi);
				o = ImageUtil.XamlIconToGdipIcon_(s, k);
			}
			return o switch {
				icon a => a.Handle,
				System.Drawing.Icon a => a.Handle,
				System.Drawing.Bitmap a => new icon(a.GetHicon()),
				IntPtr a => a,
				_ => 0
			};
		}
		
		if (_iconGC == null && (long)_c.hMainIcon is >= 1 and < 0xf000) _c.hInstance = icon.GetAppIconModuleHandle_((int)_c.hMainIcon);
		else if (_iconFooterGC == null && (long)_c.hFooterIcon is >= 1 and < 0xf000) _c.hInstance = icon.GetAppIconModuleHandle_((int)_c.hFooterIcon);
		//info: DIcon.App is IDI_APPLICATION (32512).
		//Although MSDN does not mention that IDI_APPLICATION can be used when hInstance is NULL, it works. Even works for many other undocumented system resource ids, eg 100.
		//For App icon we could instead use icon handle, but then the small icon for the title bar and taskbar button can be distorted because shrinked from the big icon. Now extracts small icon from resources.
		
		_c.pfCallback = _CallbackProc;
		
		int rNativeButton = 0, rRadioButton = 0, rIsChecked = 0, hr = 0;
		WindowsHook hook = null;
		
		try {
			_threadIdInShow = Environment.CurrentManagedThreadId;
			
			_buttons.MarshalButtons(ref _c);
			if (_c.pButtons == null) _SetFlag(_TDF.USE_COMMAND_LINKS | _TDF.USE_COMMAND_LINKS_NO_ICON, false); //avoid exception
			
			if (_timeoutActive) { //Need mouse/key messages to stop countdown on click or key.
				hook = WindowsHook.ThreadGetMessage(_HookProc);
			}
			
			wnd.Internal_.EnableActivate(true);
			
			//TaskDialog[Indirect] API bug: If called simultaneously by 2 threads, often fails and returns an unknown error code 0x800403E9.
			//Known workarounds:
			//	1. Lock. Unlock on first callback message. Now used.
			//	2. Retry. Now used only for other unexpected errors, eg out-of-memory.
			_LockUnlock(true);
			
			for (int i = 0; i < 10; i++) { //see the API bug workaround comment
				hr = _CallTDI(out rNativeButton, out rRadioButton, out rIsChecked);
				
				//if(hr != 0) print.it("0x" + hr.ToString("X"), !_dlg.Is0);
				if (hr == 0 //succeeded
					|| hr == Api.E_INVALIDARG //will never succeed
					|| hr == unchecked((int)0x8007057A) //invalid cursor handle (custom icon disposed)
					|| !_dlg.Is0 //_dlg is set if our callback function was called; then don't retry, because the dialog was possibly shown, and only then error.
					) break;
				Thread.Sleep(30);
			}
			
			if (hr == 0) {
				_result = _buttons.MapIdNativeToUser(rNativeButton);
				if (_controls != null) {
					_controls.IsChecked = rIsChecked != 0;
					_controls.RadioId = rRadioButton;
				}
				
				WndUtil.WaitForAnActiveWindow(doEvents: true);
			}
		}
		finally {
			_LockUnlock(false);
			
			//Normally the dialog now is destroyed and _dlg now is 0, because _SetClosed called on the destroy message.
			//But on exception it is not called and the dialog is still alive and visible.
			//Therefore Windows shows its annoying "stopped working" UI (cannot reproduce it now with Core).
			//To avoid it, destroy the dialog now. Also to avoid possible memory leaks etc.
			if (!_dlg.Is0) Api.DestroyWindow(_dlg);
			
			_SetClosed();
			_threadIdInShow = 0;
			hook?.Dispose();
			_buttons.MarshalFreeButtons(ref _c);
		}
		
		if (hr != 0) throw new Win32Exception(hr);
		
		return _result;
	}
	
	int _CallTDI(out int pnButton, out int pnRadioButton, out int pChecked) {
		//#if DEBUG
		//			//Debug_.PrintIf("1" != Environment.GetEnvironmentVariable("COMPlus_legacyCorruptedStateExceptionsPolicy"), "no env var COMPlus_legacyCorruptedStateExceptionsPolicy=1");
		//			pnButton = pnRadioButton = pChecked = 0;
		//			try {
		//#endif
		return TaskDialogIndirect(in _c, out pnButton, out pnRadioButton, out pChecked);
		//#if DEBUG
		//			}
		//			catch (Exception e) {
		//				throw new Win32Exception("_CallTDI: " + e.ToStringWithoutStack()); //note: not just throw;, and don't add inner exception
		//			}
		
		//			//The API throws 'access violation' exception if some value is invalid (eg unknown flags in dwCommonButtons) or it does not like something.
		//			//By default .NET does not allow to handle eg access violation exceptions.
		//			//	Previously we would add [HandleProcessCorruptedStateExceptions], but Core ignores it.
		//			//	Now our AppHost sets environment variable COMPlus_legacyCorruptedStateExceptionsPolicy=1 before loading runtime.
		//			//	Or could move the API call to the C++ dll.
		//#endif
	}
	
	void _LockUnlock(bool on) {
		var obj = "/0p4oSiwoE+7Saqf30udQQ";
		if (on) {
			Debug.Assert(!_locked);
			_locked = false;
			Monitor.Enter(obj, ref _locked);
		} else if (_locked) {
			Monitor.Exit(obj);
			_locked = false;
		}
	}
	
	//Called twice:
	//	1. Before showing dialog, to get screen while the dialog still isn't the active window if need. On TDN.CREATED screen.ofActiveWindow would be bad.
	//	2. On TDN.CREATED, to move dialog if need.
	void _SetPos(bool before) {
		if (before) _screenForMove = default;
		if (_HasFlag(_TDF.POSITION_RELATIVE_TO_WINDOW)) return;
		if (_flags.Has(DFlags.CenterMouse)) {
			if (!before) {
				var p = mouse.xy;
				var scrn = screen.of(p);
				if (screen.of(_dlg).Handle != scrn.Handle) _dlg.MoveL_(scrn.Rect.XY); //resize if different DPI
				var r = _dlg.Rect;
				r.Move(p.x - r.Width / 2, p.y - 20);
				r.EnsureInScreen(scrn);
				_dlg.MoveL(r.left, r.top);
			}
		} else if (!_rawXY) {
			if (before) {
				_screenForMove = Screen;
				if (_screenForMove.IsEmpty && _c.hwndParent.Is0) _screenForMove = options.defaultScreen;
				if (_screenForMove.LazyFunc != null) _screenForMove = _screenForMove.Now;
			} else if (!_x.IsEmpty || !_y.IsEmpty || !_screenForMove.IsEmpty) {
				_dlg.MoveInScreen(_x, _y, _screenForMove);
			}
		} else if (!before) {
			_dlg.Move(_x, _y);
			_dlg.EnsureInScreen();
		}
	}
	screen _screenForMove;
	
	//To get DPI for icons.
	screen _GetScreenBeforeShow() {
		if (!_screenForMove.IsEmpty) return _screenForMove;
		if (Api.GetSystemMetrics(Api.SM_CMONITORS) > 1) {
			if (_HasFlag(_TDF.POSITION_RELATIVE_TO_WINDOW)) return screen.of(_c.hwndParent); //ownerCenter
			if (_flags.Has(DFlags.CenterMouse)) return screen.of(mouse.xy);
			if (_rawXY) return screen.of(Coord.Normalize(_x, _y, centerIfEmpty: true));
			if (!_c.hwndParent.Is0) return screen.of(_c.hwndParent);
		}
		return screen.primary;
	}
	
	int _CallbackProc(wnd w, DNative.TDN message, nint wParam, nint lParam, IntPtr data) {
		Action<DEventArgs> e = null;
		int R = 0, button = 0, timerTime = 0;
		string linkHref = null;
		
		//print.it(message);
		switch (message) {
		case DNative.TDN.DIALOG_CONSTRUCTED:
			_LockUnlock(false);
			Send = new DSend(this); //note: must be before setting _dlg, because another thread may call if(d.IsOpen) d.Send.Message(..).
			_dlg = w;
			break;
		case DNative.TDN.DESTROYED:
			//print.it(w.IsAlive); //valid
			e = Destroyed;
			break;
		case DNative.TDN.CREATED:
			if (_enableOwner) _c.hwndParent.Enable(true);
			_SetPos(false);
			
			if (Topmost ?? (_c.hwndParent.Is0 && options.topmostIfNoOwnerWindow)) w.ZorderTopmost();
			
			//w.SetStyleAdd(WS.THICKFRAME); //does not work
			
			if (_IsEdit) _EditControlCreate();
			else if (ProgressBarMarquee) Send.Message(DNative.TDM.SET_PROGRESS_BAR_MARQUEE, 1);
			
			//if(FlagKeyboardShortcutsVisible) w.Post(Api.WM_UPDATEUISTATE, 0x30002); //rejected. Don't need too many rarely used features.
			
			//fix API bug: dialog window is hidden if process STARTUPINFO specifies hidden window
			timer.after(1, _ => _dlg.ShowL(true)); //use timer because at this time still invisible always
			
			e = Created;
			break;
		case DNative.TDN.TIMER:
			timerTime = (int)wParam;
			if (_timeoutActive) {
				int timeElapsed = timerTime / 1000;
				if (timeElapsed < _timeoutS) {
					if (!_timeoutNoInfo) Send.ChangeFooterText(_TimeoutFooterText(_timeoutS - timeElapsed - 1), false);
				} else {
					_timeoutActive = false;
					Send.Close(c_idTimeout);
				}
			}
			
			e = Timer;
			break;
		case DNative.TDN.BUTTON_CLICKED:
			e = ButtonClicked;
			button = _buttons.MapIdNativeToUser((int)wParam);
			break;
		case DNative.TDN.HYPERLINK_CLICKED:
			linkHref = Marshal.PtrToStringUni(lParam);
			if (_DTextLinkClicked(linkHref)) return 0;
			e = HyperlinkClicked;
			break;
		case DNative.TDN.HELP:
			e = HelpF1;
			break;
		default:
			e = OtherEvents;
			break;
		}
		
		if (_IsEdit) _EditControlOnMessage(message);
		
		if (e != null) {
			var ed = new DEventArgs(this, _dlg, message, wParam, button, timerTime, linkHref);
			e(ed);
			R = ed.returnValue;
		}
		
		if (message == DNative.TDN.DESTROYED) _SetClosed();
		
		return R;
	}
	
	/// <summary>
	/// After the dialog has been created and before it is displayed.
	/// </summary>
	public event Action<DEventArgs> Created;
	
	/// <summary>
	/// When the dialog is closed and its window handle is no longer valid.
	/// </summary>
	public event Action<DEventArgs> Destroyed;
	
	/// <summary>
	/// Every 200 ms.
	/// </summary>
	/// <example>
	/// <code><![CDATA[
	/// var d = new dialog("test");
	/// d.Timer += e => { print.it(e.TimerTimeMS); };
	/// d.ShowDialog();
	/// ]]></code>
	/// </example>
	public event Action<DEventArgs> Timer;
	
	/// <summary>
	/// When the user selects a button.
	/// </summary>
	/// <example>
	/// <code><![CDATA[
	/// var d = new dialog("test", buttons: "1 Can close|2 Can't close");
	/// d.ButtonClicked += e => { print.it(e.Button); e.DontCloseDialog = e.Button == 2; };
	/// d.ShowDialog();
	/// ]]></code>
	/// </example>
	public event Action<DEventArgs> ButtonClicked;
	
	/// <summary>
	/// When the user clicks a hyperlink in the dialog text.
	/// </summary>
	/// <example>
	/// <code><![CDATA[
	/// var d = new dialog("test", "Text with <a href=\"link data\">links</a>.");
	/// d.HyperlinkClicked += e => { print.it(e.LinkHref); };
	/// d.ShowDialog();
	/// ]]></code>
	/// </example>
	public event Action<DEventArgs> HyperlinkClicked;
	
	/// <summary>
	/// When the user presses <c>F1</c>.
	/// </summary>
	/// <example>
	/// <code><![CDATA[
	/// var d = new dialog("test", "Some info.", footer: "Press F1 for more info.");
	/// d.HelpF1 += e => { run.it("https://www.google.com/search?q=more+info"); };
	/// d.ShowDialog();
	/// ]]></code>
	/// </example>
	public event Action<DEventArgs> HelpF1;
	
	/// <summary>
	/// Events other than <see cref="Created"/>, <see cref="Destroyed"/>, <see cref="Timer"/>, <see cref="ButtonClicked"/>, <see cref="HyperlinkClicked"/>, <see cref="HelpF1"/>. See API <ms>TaskDialogCallbackProc</ms>.
	/// </summary>
	public event Action<DEventArgs> OtherEvents;
	
	#region async etc
	
	/// <summary>
	/// Shows the dialog in new thread and returns without waiting until it is closed.
	/// </summary>
	/// <remarks>
	/// Calls <see cref="ThreadWaitForOpen"/>, therefore the dialog is already open when this function returns.
	/// More info: <see cref="showNoWait"/>
	/// </remarks>
	/// <exception cref="Win32Exception">Failed to show dialog. Unlikely.</exception>
	public void ShowDialogNoWait() {
		Exception ex = null;
		Task.Run(() => { try { ShowDialog(); } catch (Exception e) { ex = e; } });
		if (!ThreadWaitForOpen()) throw ex ?? new Win32Exception(0);
	}
	
	/// <summary>
	/// Selected button id. The same as the <see cref="ShowDialog"/> return value.
	/// </summary>
	/// <remarks>
	/// If the result is still unavailable (the dialog still not closed):
	/// - If called from the same thread that called <see cref="ShowDialog"/>, returns 0.
	/// - If called from another thread, waits until the dialog is closed.
	/// 
	/// Note: <see cref="ShowDialogNoWait"/> calls <see cref="ShowDialog"/> in another thread.
	/// </remarks>
	public int Result {
		get {
			if (!_WaitWhileInShow()) return 0;
			return _result;
		}
	}
	int _result;
	
	/// <summary>
	/// After closing the dialog contains values of checkbox, radio buttons and/or text edit control.
	/// <c>null</c> if no controls.
	/// </summary>
	public DControls Controls => _controls;
	DControls _controls;
	
	bool _WaitWhileInShow() {
		if (_threadIdInShow != 0) {
			if (_threadIdInShow == Environment.CurrentManagedThreadId) return false;
			while (_threadIdInShow != 0) Thread.Sleep(15);
		}
		return true;
	}
	
	/// <summary>
	/// Can be used by other threads to wait until the dialog is open.
	/// </summary>
	/// <returns>
	/// <br/>• <c>true</c> - the dialog is open and you can send messages to it.
	/// <br/>• <c>false</c> - the dialog is already closed or failed to show.
	/// </returns>
	public bool ThreadWaitForOpen() {
		_AssertIsOtherThread();
		while (!IsOpen) {
			if (_isClosed) return false;
			wait.doEvents(15); //need 2-3 loops if 15. Without doEvents hangs if a form is the dialog owner.
		}
		return true;
	}
	
	/// <summary>
	/// Can be used by other threads to wait until the dialog is closed.
	/// </summary>
	public void ThreadWaitForClosed() {
		_AssertIsOtherThread();
		while (!_isClosed) {
			Thread.Sleep(30);
		}
		_WaitWhileInShow();
	}
	
	void _AssertIsOtherThread() {
		if (_threadIdInShow != 0 && _threadIdInShow == Environment.CurrentManagedThreadId)
			throw new AuException("wrong thread");
	}
	
	/// <summary>
	/// Returns <c>true</c> if the dialog is open and your code can send messages to it.
	/// </summary>
	public bool IsOpen => !_dlg.Is0;
	
	void _SetClosed() {
		_isClosed = true;
		if (_dlg.Is0) return;
		_dlg = default;
		Send.Clear_();
	}
	bool _isClosed;
	
	#endregion async etc
	
	#region send messages
	
	/// <summary>
	/// Gets dialog window handle as <see cref="wnd"/>.
	/// </summary>
	/// <returns><c>default(wnd)</c> if the dialog is not open.</returns>
	public wnd DialogWindow => _dlg;
	
	/// <summary>
	/// Allows to modify dialog controls while it is open, and close the dialog.
	/// </summary>
	/// <remarks>
	/// Example: <c>d.Send.Close();</c> .
	/// Example: <c>d.Send.ChangeText2("new text", false);</c> .
	/// Example: <c>d.Send.Message(DNative.TDM.CLICK_VERIFICATION, 1);</c> .
	/// 
	/// Can be used only while the dialog is open. Before showing the dialog returns <c>null</c>. After closing the dialog the returned variable is deactivated; its method calls are ignored.
	/// Can be used in dialog event handlers. Also can be used in another thread, for example with <see cref="showNoWait"/> and <see cref="showProgress"/>.
	/// </remarks>
	public DSend Send { get; private set; }
	
	//called by DSend
	internal int SendMessage_(DNative.TDM message, nint wParam = 0, nint lParam = 0) {
		switch (message) {
		case DNative.TDM.CLICK_BUTTON:
		case DNative.TDM.ENABLE_BUTTON:
		case DNative.TDM.SET_BUTTON_ELEVATION_REQUIRED_STATE:
			wParam = _buttons.MapIdUserToNative((int)wParam);
			break;
		}
		
		return (int)_dlg.Send((int)message, wParam, lParam);
	}
	
	//called by DSend
	internal void SetText_(bool resizeDialog, DNative.TDE partId, string text) {
		if (partId == DNative.TDE.CONTENT && (_controls?.EditType ?? default) == DEdit.Multiline) {
			text = _c.pszContent = text + c_multilineString;
		}
		
		_dlg.Send((int)(resizeDialog ? DNative.TDM.SET_ELEMENT_TEXT : DNative.TDM.UPDATE_ELEMENT_TEXT), (int)partId, text ?? "");
		//info: null does not change text.
		
		if (_IsEdit) _EditControlUpdateAsync(!resizeDialog);
		//info: sometimes even UPDATE_ELEMENT_TEXT sends our control to the bottom of the Z order.
	}
	
	#endregion send messages
	
	#region hookProc, timeoutText
	
	//Disables timeout on click or key.
	unsafe void _HookProc(HookData.ThreadGetMessage d) {
		switch (d.msg->message) {
		case Api.WM_LBUTTONDOWN:
		case Api.WM_NCLBUTTONDOWN:
		case Api.WM_RBUTTONDOWN:
		case Api.WM_NCRBUTTONDOWN:
		case Api.WM_KEYDOWN:
		case Api.WM_SYSKEYDOWN:
			if (_timeoutActive && d.msg->hwnd.Window == _dlg) {
				_timeoutActive = false;
				Send.ChangeFooterText(_footerText, false);
			}
			break;
		}
	}
	
	string _TimeoutFooterText(int timeLeft) {
		var format = options.timeoutTextFormat;
		if (format.NE()) return _footerText;
		if (_timeoutActionText.NE()) format = format.Lines()[0];
		using (new StringBuilder_(out var b)) {
			b.AppendFormat(format, timeLeft, _timeoutActionText);
			if (!_footerText.NE()) b.Append('\n').Append(_footerText);
			return b.ToString();
		}
	}
	
	#endregion hookProc, timeoutText
	
	#region Edit control
	
	//never mind: our edit control disappears when moving the dialog to a screen with different DPI
	
	bool _IsEdit => _controls != null && _controls.EditType != DEdit.None;
	
	void _EditControlInitBeforeShowDialog() {
		if (!_IsEdit) return;
		ProgressBarMarquee = true;
		ProgressBar = false;
		_c.pszContent ??= "";
		if (_c.pszExpandedInformation != null && _controls.EditType == DEdit.Multiline) _SetFlag(_TDF.EXPAND_FOOTER_AREA, true);
	}
	
	void _EditControlUpdate(bool onlyZorder = false) {
		if (_editWnd.Is0) return;
		if (!onlyZorder) {
			_EditControlGetPlace(out RECT r);
			_editParent.MoveL(r);
			_editWnd.MoveL(0, 0, r.Width, r.Height);
		}
		_editParent.ZorderTopRaw_();
	}
	
	void _EditControlUpdateAsync(bool onlyZorder = false) {
		_editParent.Post(Api.WM_APP + 111, onlyZorder ? 1 : 0);
	}
	
	//to reserve space for multiline Edit control we append this to text2
	const string c_multilineString = "\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n ";
	
	wnd _EditControlGetPlace(out RECT r) {
		wnd parent = _dlg; //don't use the DirectUIHWND control for it, it can create problems
		
		//create or get cached font and calculate control height
		_editFont = NativeFont_.RegularCached(Dpi.OfWindow(parent));
		//tested: on Win8.1 API isn't PM-DPI-aware.
		
		//We'll hide the progress bar control and create our Edit control in its place.
		wnd prog = parent.Child(cn: "msctls_progress32", flags: WCFlags.HiddenToo);
		prog.GetRectIn(parent, out r);
		
		if (_controls.EditType == DEdit.Multiline) {
			int top = r.top;
			if (!_c.pszContent.Ends(c_multilineString)) {
				_c.pszContent += c_multilineString;
				_dlg.Send((int)DNative.TDM.SET_ELEMENT_TEXT, (int)DNative.TDE.CONTENT, _c.pszContent);
				prog.GetRectIn(parent, out r); //used to calculate Edit control height: after changing text, prog is moved down, and we know its previous location...
			}
			if (_editMultilineHeight == 0) { _editMultilineHeight = r.bottom - top; } else top = r.bottom - _editMultilineHeight;
			r.top = top;
		} else {
			r.top = r.bottom - (_editFont.HeightOnScreen + 8);
		}
		
		prog.ShowL(false);
		return parent;
	}
	int _editMultilineHeight;
	
	void _EditControlCreate() {
		wnd parent = _EditControlGetPlace(out RECT r);
		
		//Create an intermediate "#32770" to be direct parent of the Edit control.
		//It is safer (the dialog will not receive Edit notifications) and helps to solve Tab/Esc problems.
		var pStyle = WS.CHILD | WS.VISIBLE | WS.CLIPCHILDREN | WS.CLIPSIBLINGS; //don't need WS_TABSTOP
		var pExStyle = WSE.NOPARENTNOTIFY; //not WSE.CONTROLPARENT
		_editParent = WndUtil.CreateWindow("#32770", null, pStyle, pExStyle, r.left, r.top, r.Width, r.Height, parent);
		Api.SetWindowLongPtr(_editParent, GWL.DWL.DLGPROC, Marshal.GetFunctionPointerForDelegate(_editControlParentProcHolder = _EditControlParentProc));
		
		//Create Edit or ComboBox control.
		string cn = "Edit";
		var style = WS.CHILD | WS.VISIBLE; //don't need WS_TABSTOP
		switch (_controls.EditType) {
		case DEdit.Text: style |= Api.ES_AUTOHSCROLL; break;
		case DEdit.Password: style |= Api.ES_PASSWORD | Api.ES_AUTOHSCROLL; break;
		case DEdit.Number: style |= Api.ES_NUMBER | Api.ES_AUTOHSCROLL; break;
		case DEdit.Multiline: style |= Api.ES_MULTILINE | Api.ES_AUTOVSCROLL | Api.ES_WANTRETURN | WS.VSCROLL; break;
		case DEdit.Combo: style |= Api.CBS_DROPDOWN | Api.CBS_AUTOHSCROLL | WS.VSCROLL; cn = "ComboBox"; break;
		}
		_editWnd = WndUtil.CreateWindow(cn, null, style, WSE.CLIENTEDGE, 0, 0, r.Width, r.Height, _editParent);
		WndUtil.SetFont(_editWnd, _editFont);
		
		//Init the control.
		_editWnd.SetText(_controls.EditText);
		if (_controls.EditType == DEdit.Combo) {
			if (_controls.ComboItems.Value != null) {
				foreach (var s in _controls.ComboItems.ToArray()) _editWnd.Send(Api.CB_INSERTSTRING, -1, s);
			}
			RECT cbr = _editWnd.Rect;
			_editParent.ResizeL(cbr.Width, cbr.Height); //because ComboBox resizes itself
		} else {
			_editWnd.Send(Api.EM_SETSEL, 0, -1);
		}
		_editParent.ZorderTopRaw_();
		Api.SetFocus(_editWnd);
	}
	
	void _EditControlOnMessage(DNative.TDN message) {
		switch (message) {
		case DNative.TDN.BUTTON_CLICKED:
			_controls.EditText = _editWnd.ControlText;
			break;
		case DNative.TDN.EXPANDO_BUTTON_CLICKED:
		case DNative.TDN.NAVIGATED:
			_EditControlUpdateAsync(); //when expando clicked, sync does not work even with doevents
			break;
		}
	}
	
	/// <summary>
	/// Gets edit control handle as <see cref="wnd"/>.
	/// </summary>
	public wnd EditControl => _editWnd;
	wnd _editWnd, _editParent;
	NativeFont_ _editFont;
	
	//Dlgproc of our intermediate #32770 control, the parent of out Edit control.
	nint _EditControlParentProc(wnd w, int msg, nint wParam, nint lParam) {
		switch (msg) {
		case Api.WM_SETFOCUS: //enables Tab when in single-line Edit control
			Api.SetFocus(_dlg.ChildFast(null, "DirectUIHWND"));
			return 1;
		case Api.WM_NEXTDLGCTL: //enables Tab when in multi-line Edit control
			Api.SetFocus(_dlg.ChildFast(null, "DirectUIHWND"));
			return 1;
		case Api.WM_CLOSE: //enables Esc when in edit control
			_dlg.Send(msg);
			return 1;
		case Api.WM_APP + 111: //async update edit control pos
			_EditControlUpdate(wParam != 0);
			return 1;
		}
		return 0;
		//BAD: Alt+key doesn't work when the edit control is focused.
		//	https://github.com/qgindi/LibreAutomate/issues/28
		//	Also we receive 500 pairs of WM_GETDLGCODE + WM_GETTEXT.
		//	To fix this, probably would need a getmsg hook. It could detect the event and focus a button. Too expensive.
	}
	WNDPROC _editControlParentProcHolder;
	
	#endregion Edit control
}


================================================
FILE: Au/GUI/osd.cs
================================================
using System.Drawing;

namespace Au.Types {
	/// <summary>
	/// Transparent window that can be used for on-screen display. Derived classes on it can draw non-transparent text, rectangle, image, anything.
	/// </summary>
	public abstract class OsdWindow : IDisposable {
		wnd _w;
		
		/// <summary>Destroys the OSD window.</summary>
		protected virtual void Dispose(bool disposing) {
			if (_w.Is0) return;
			Api.ShowWindow(_w, 0);
			_TopmostWorkaroundUndo();
			var w = _w; _w = default;
			if (!Api.DestroyWindow(w)) w.Post(Api.WM_CLOSE);
		}
		
		/// <summary>Destroys the OSD window.</summary>
		public void Dispose() => Dispose(true);
		
		/// <summary>Destroys the OSD window.</summary>
		public void Close() => Dispose(true);
		
		/// <summary>OSD window handle or <c>default(wnd)</c>.</summary>
		public wnd Hwnd => _w;
		
		/// <summary>
		/// Returns <c>true</c> if the OSD window is created.
		/// </summary>
		protected bool IsHandleCreated => !_w.Is0;
		
		/// <summary>
		/// Redraws the OSD window immediately.
		/// Does nothing it is not created or not visible.
		/// </summary>
		protected void Redraw() {
			if (!Visible) return;
			Api.InvalidateRect(_w);
			Api.UpdateWindow(_w);
		}
		
		/// <summary>
		/// Sets to redraw the OSD window later.
		/// Does nothing it is not created or not visible.
		/// </summary>
		protected void Invalidate() {
			if (!Visible) return;
			Api.InvalidateRect(_w);
		}
		
		/// <summary>
		/// Gets or sets the opacity of the OSD window, from 0 to 1.
		/// If 1, completely opaque. If 0, pixels of <see cref="TransparentColor"/> are transparent, others opaque. If between 0 and 1, partially transparent.
		/// </summary>
		/// <value>Default is 1. Default in <see cref="osdRect"/> is 0.</value>
		/// <remarks>
		/// This property can be changed after creating OSD window.
		/// </remarks>
		public double Opacity {
			get => _opacity;
			set {
				var v = Math.Min(Math.Max(value, 0.0), 1.0);
				if (v == _opacity) return;
				bool was0 = _opacity == 0;
				_opacity = v;
				if (!IsHandleCreated) return;
				_SetOpacity();
				if ((v == 0) != was0) Redraw();
			}
		}
		double _opacity = 1d;
		
		void _SetOpacity() {
			if (_opacity > 0) Api.SetLayeredWindowAttributes(_w, 0, (byte)(uint)(_opacity * 255), 2);
			else Api.SetLayeredWindowAttributes(_w, (uint)TransparentColor.ToBGR(), 0, 1);
			
			//never mind: when resizing an alpha-transparent window by moving the top-left corner, the opposite corner shakes.
			//	It's a Windows problem, and I could not find a workaround.
		}
		
		/// <summary>
		/// Gets or sets transparent color, default 0xF5F4F5. Pixels of this color will be transparent, unless <see cref="Opacity"/> is not 0.
		/// </summary>
		/// <remarks>
		/// This property cannot be changed after creating OSD window.
		/// Note: when used for transparent text, text edges are blended with this color, and it can become visible if the color is not chosen carefully.
		/// </remarks>
		public ColorInt TransparentColor { get; set; } = 0xF5F4F5;
		
		/// <summary>
		/// Gets or sets OSD window size and position in screen.
		/// </summary>
		/// <remarks>
		/// This property can be changed after creating OSD window.
		/// </remarks>
		public virtual RECT Rect {
			get => _r;
			set {
				if (value == _r) return;
				_r = value;
				if (IsHandleCreated) {
					_w.SetWindowPos(SWPFlags.NOACTIVATE, _r.left, _r.top, _r.Width, _r.Height, SpecHWND.TOPMOST);
					_TopmostWorkaroundApply();
				}
			}
		}
		RECT _r;
		
		/// <summary>
		/// Gets or sets whether the OSD window is visible.
		/// The <c>set</c> function calls <see cref="Show"/> (it creates OSD window if need) or <see cref="Hide"/> (it does not destroy the OSD window).
		/// </summary>
		public bool Visible {
			get => _w.IsVisible;
			set { if (value) Show(); else Hide(); } //note: if overridden, calls the override func
		}
		
		/// <summary>
		/// Shows the OSD window. Creates if need.
		/// </summary>
		/// <remarks>
		/// In any case, also moves the window to the top of the Z order.
		/// </remarks>
		public virtual void Show() {
			if (Visible) {
				_w.ZorderTopmost();
				_TopmostWorkaroundApply();
			} else {
				if (_w.Is0) _CreateWindow();
				_w.ShowL(true);
				_w.ZorderTopmost();
				_TopmostWorkaroundApply();
				Api.UpdateWindow(_w);
			}
		}
		
		/// <summary>
		/// Hides the OSD window. Does not destroy; use <see cref="Close"/> or <see cref="Dispose"/> for it.
		/// Does nothing if not created or not visible.
		/// </summary>
		public virtual void Hide() {
			if (!Visible) return;
			_w.ShowL(false);
		}
		
		void _CreateWindow() {
			//register window class if need. Need another class if shadow.
			string cn; byte regMask;
			if (Shadow) { cn = "Au.OSD2"; regMask = 2; } else { cn = "Au.OSD"; regMask = 1; }
			if ((s_isWinClassRegistered & regMask) == 0) {
				var ce = new RWCEtc() { style = Api.CS_HREDRAW | Api.CS_VREDRAW, mCursor = MCursor.Arrow };
				if (Shadow) ce.style |= Api.CS_DROPSHADOW;
				WndUtil.RegisterWindowClass(cn, null, ce);
				s_isWinClassRegistered |= regMask;
			}
			
			var es = WSE.TOOLWINDOW | WSE.TOPMOST | WSE.LAYERED | WSE.TRANSPARENT | WSE.NOACTIVATE;
			if (ClickToClose) es &= ~WSE.TRANSPARENT;
			_w = WndUtil.CreateWindow(WndProc, true, cn, Name, WS.POPUP, es); //note: don't set rect here: can be painting problems when resizing
			_SetOpacity();
			if (!_r.Is0) _w.SetWindowPos(SWPFlags.NOACTIVATE, _r.left, _r.top, _r.Width, _r.Height, SpecHWND.TOPMOST);
		}
		static byte s_isWinClassRegistered;
		
		/// <summary>
		/// Called when the OSD window receives a message.
		/// If your derived class overrides this function, it must call <c>base.WndProc</c> and return its return value, except when don't need default processing.
		/// </summary>
		protected virtual nint WndProc(wnd w, int message, nint wParam, nint lParam) {
			switch (message) {
			case Api.WM_NCDESTROY:
				Api.PostMessage(default, 0, 0, 0); //stop waiting for a message. Never mind: not always need it.
				Closed?.Invoke(this, EventArgs.Empty);
				_w = default;
				break;
			case Api.WM_ERASEBKGND:
				return 1;
			case Api.WM_PAINT:
				using (var bp = new BufferedPaint(w, true)) {
					var dc = bp.DC;
					using var g = Graphics.FromHdc(dc);
					if (_opacity == 0) g.Clear((Color)TransparentColor);
					OnPaint(dc, g, bp.Rect);
				}
				return default;
			case Api.WM_MOUSEACTIVATE:
				return Api.MA_NOACTIVATE;
			case Api.WM_LBUTTONUP or Api.WM_RBUTTONUP or Api.WM_MBUTTONUP:
				Clicked?.Invoke(this, message switch { Api.WM_LBUTTONUP => MButton.Left, Api.WM_RBUTTONUP => MButton.Right, _ => MButton.Middle });
				if (ClickToClose) w.Post(Api.WM_CLOSE);
				break;
			}
			
			return Api.DefWindowProc(w, message, wParam, lParam);
		}

		///
		public event EventHandler Closed;

		///
		public event EventHandler<MButton> Clicked;
		
		/// <summary>
		/// Called when the OSD window must be drawn or redrawn.
		/// Derived classes should override this function and draw anything. Don't need to call <c>base.OnPaint</c> of <see cref="OsdWindow"/>, it does nothing.
		/// </summary>
		/// <remarks>
		/// If <see cref="Opacity"/> is 0 (default), <i>g</i> is filled with <see cref="TransparentColor"/>. Pixels of this color will be transparent. The base class draws only non-transparent areas.
		/// </remarks>
		protected virtual void OnPaint(IntPtr dc, Graphics g, RECT r) {
		}
		
		/// <summary>
		/// If <c>true</c>, the OSD window will have shadow.
		/// </summary>
		/// <remarks>
		/// This property cannot be changed after creating OSD window.
		/// </remarks>
		protected bool Shadow { get; set; }
		
		/// <summary>
		/// If <c>true</c>, the OSD window receive mouse messages. Only completely transparent areas don't. The user can click to close the OSD (left, right or middle button).
		/// </summary>
		/// <remarks>
		/// This property cannot be changed after creating OSD window.
		/// </remarks>
		protected bool ClickToClose { get; set; }
		
		/// <summary>
		/// OSD window name. Optional, default <c>null</c>.
		/// </summary>
		/// <remarks>
		/// This text is invisible. Can be used to find OSD window. The class name is <c>"Au.OSD"</c>; if with shadow - <c>"Au.OSD2"</c>.
		/// This property cannot be changed after creating OSD window.
		/// </remarks>
		public string Name { get; set; }
		
		/// <summary>
		/// Closes all OSD windows of this process.
		/// </summary>
		/// <param name="name">If not <c>null</c>, closes only OSD windows whose <see cref="Name"/> matches this [wildcard expression](xref:wildcard_expression).</param>
		public static void closeAll([ParamString(PSFormat.Wildex)] string name = null) {
			foreach (var w in wnd.findAll(name, "**m Au.OSD||Au.OSD2", WOwner.Process(Api.GetCurrentProcessId()))) w.Post(Api.WM_CLOSE);
		}
		
		#region topmost workaround
		
		//Workaround for: our topmost window is below some other topmost windows (Win8+).
		//	Window examples:
		//	A. Windows Start menu, search, TaskListThumbnailWnd.
		//	B. uiAccess apps, eg on-screen keyboard, Inspect, NVDA, QM2 uiAccess.
		//	C. Probably Win8 Store apps.
		//	Known workarounds:
		//	1. Temporarily make the window non-topmost. But it fails for A and probably C. Fails always if this process is not admin.
		//	2. Temporarily set partially transparent. But it is useful only for on-screen rect. Not useful for menus and toolbars. Fails if not admin. Fails with WPF windows.
		//	3. Set window region. Too crazy. Tested, does not work with eg OSK, although works with eg Notepad.
		//	4. Run tools in uiAccess processes. Too crazy and limited.
		
		internal bool TopmostWorkaround_ { get; set; }
		
		void _TopmostWorkaroundApply() {
			if (!TopmostWorkaround_ || !osVersion.minWin10) return; //never mind: on Win8 not tested. Would be bad to make full-screen windows transparent.
			var w = wnd.fromXY(new(_r.CenterX, _r.CenterY), WXYFlags.NeedWindow);
			bool apply = false;
			lock (s_twList) {
				List<OsdWindow> aosd = null;
				foreach (var v in s_twList) if (v.w == w) { if (v.a.Contains(this)) return; aosd = v.a; break; }
				if (w.HasExStyle(WSE.TOPMOST)) {
					RECT r = w.Rect; r.Inflate(10, 10);
					if (r.Width > _r.Width && r.Height > _r.Height) {
						if (!_w.ZorderIsAbove(w)) {
							if (apply = aosd == null) s_twList.Add((w, new() { this }));
							else aosd.Add(this);
							//print.it(apply, w);
						}
					}
				}
				if (apply && s_twTimer == null) {
					s_twTimer = new(_ => {
						List<wnd> aw = null;
						lock (s_twList) {
							foreach (var (w, _) in s_twList) {
								//print.it(w.GetTransparency(out var op, out var col), op, col);
								if (!w.GetTransparency(out var op, out var col) || op == null || op.Value > 200) {
									if (w.IsAlive) (aw ??= new()).Add(w);
								}
							}
						}
						if (aw != null) foreach (var w in aw) w.SetTransparency(true, 200, noException: true);
					});
					s_twTimer.Every(1000);
				}
			}
			if (apply) w.SetTransparency(true, 200, noException: true);
		}
		
		void _TopmostWorkaroundUndo() {
			if (!TopmostWorkaround_ || !osVersion.minWin10) return;
			List<wnd> aw = null;
			lock (s_twList) {
				for (int i = s_twList.Count; --i >= 0;) {
					var (w, a) = s_twList[i];
					if (a.Remove(this) && a.Count == 0) {
						s_twList.RemoveAt(i);
						if (w.IsAlive) (aw ??= new()).Add(w);
					}
				}
				if (s_twList.Count == 0 && s_twTimer != null) {
					s_twTimer.Stop();
					s_twTimer = null;
				}
			}
			if (aw != null) foreach (var w in aw) w.SetTransparency(!true, 255, noException: true);
		}
		
		static List<(wnd w, List<OsdWindow> a)> s_twList = new();
		static timer2 s_twTimer;
		
		#endregion
	}
	
	/// <summary>
	/// Used by <see cref="osdRect.SetRects"/>.
	/// </summary>
	/// <param name="Placement">Label placement relative to rectangle: <c>'L'</c> (left), <c>'R'</c> (right), <c>'T'</c> (top), <c>'B'</c> (bottom) or <c>'I'</c> (inside). Default: <c>'L'</c>.</param>
	public record class ORLabelOptions(char Placement, ColorInt? BackgroundColor = null, ColorInt? TextColor = null) {
		///
		public static implicit operator ORLabelOptions(char placement) => new(placement);
	}
}

namespace Au {
	/// <summary>
	/// Shows a mouse-transparent rectangle on screen. Just visible outline, or filled but partially transparent.
	/// </summary>
	/// <remarks>
	/// Creates a temporary partially transparent window, and draws rectangle in it. Can draw multiple rectangles.
	/// </remarks>
	/// <example>
	/// <code><![CDATA[
	/// using (var x = new osdRect()) {
	/// 	x.Rect = (300, 300, 100, 100);
	/// 	x.Color = System.Drawing.Color.SlateBlue;
	/// 	x.Thickness = 4;
	/// 	x.Show();
	/// 	for (int i = 0; i < 5; i++) {
	/// 		250.ms();
	/// 		x.Visible = !x.Visible;
	/// 	}
	/// }
	/// ]]></code>
	/// </example>
	public class osdRect : OsdWindow {
		///
		public osdRect() {
			Opacity = 0d;
		}
		
		/// <summary>
		/// Gets or sets rectangle color.
		/// </summary>
		/// <remarks>
		/// This property can be changed after creating OSD window.
		/// </remarks>
		/// <example>
		/// <code><![CDATA[
		/// x.Color = 0xFF0000; //red
		/// x.Color = System.Drawing.Color.Orange;
		/// ]]></code>
		/// </example>
		public ColorInt Color {
			get => _color;
			set { if (value != _color) { _color = value; Redraw(); } }
		}
		ColorInt _color = 0; //=0 adds alpha 0xFF
		
		/// <summary>
		/// Gets or sets rectangle frame width.
		/// Used only if <see cref="OsdWindow.Opacity"/> is 0 (default).
		/// </summary>
		/// <remarks>
		/// This property can be changed after creating OSD window.
		/// </remarks>
		public int Thickness {
			get => _thickness;
			set { if (value != _thickness) { _thickness = value; Redraw(); } }
		}
		int _thickness = 3;
		
		/// <summary>
		/// Called when the OSD window must be drawn or redrawn. Draws rectangle. More info: <see cref="OsdWindow.OnPaint"/>.
		/// </summary>
		protected override void OnPaint(IntPtr dc, Graphics g, RECT ra) {
			if (_rects == null) {
				if (Opacity > 0) {
					g.Clear((Color)_color);
				} else {
					g.DrawRectangleInset((Color)_color, _thickness, ra);
				}
			} else if (_rects.Length >= 0) {
				if (Opacity > 0) g.Clear((Color)TransparentColor);
				using var tr = _hasLabels ? new GdiTextRenderer(dc, Dpi.OfWindow(Hwnd)) : null;
				for (int i = 0; i < _rects.Length; i++) {
					var r = _rects[i].r; r.Offset(-Rect.left, -Rect.top);
					g.DrawRectangleInset((Color)Color, Thickness, r);
					if (_hasLabels) {
						var s = _rects[i].s;
						var z = tr.MeasureText(s);
						int pad = z.height / 2;
						z.width += pad;
						int x = _labelOptions.Placement switch { 'L' => r.left - z.width - 1, 'R' => r.right, 'I' => r.left + Thickness + 1, _ => r.left };
						int y = _labelOptions.Placement switch { 'T' => r.top - z.height - 1, 'B' => r.bottom, 'I' => r.top + Thickness + 1, _ => r.top };
						if (x < 0) { x = 0; if (z.width >= r.left) z.width = r.left - 1; }
						RECT rr = new(x, y, z.width, z.height);
						if (_labelOptions.BackgroundColor != null) g.FillRectangle((Color)_labelOptions.BackgroundColor.Value, rr); else g.FillRectangle(Brushes.PaleGoldenrod, rr);
						g.DrawRectangle(Pens.DarkGray, rr);
						rr.Inflate(-pad / 2, 0);
						tr.DrawText(s, rr, _labelOptions.TextColor?.ToBGR() ?? 0x404040);
					}
				}
			}
		}
		
		(RECT r, string s)[] _rects;
		bool _hasLabels;
		ORLabelOptions _labelOptions;
		
		/// <summary>
		/// Sets to draw multiple rectangles.
		/// </summary>
		/// <param name="rects">Rectangles.</param>
		/// <param name="indexLabels">Draw labels. The label text is the rectangle index in <i>rects</i>.</param>
		/// <param name="labelOptions">Label options. If <c>char</c> - label placement relative to rectangle: <c>'L'</c> (left), <c>'R'</c> (right), <c>'T'</c> (top), <c>'B'</c> (bottom) or <c>'I'</c> (inside). Default: <c>'L'</c>.</param>
		/// <remarks>
		/// If this function called, will draw multiple rectangles instead of single (unless <i>rects</i> is <c>null</c>). <c>Opacity</c> should be 0 (default).
		/// </remarks>
		public void SetRects(IEnumerable<RECT> rects, bool indexLabels = false, ORLabelOptions labelOptions = null) {
			SetRects(indexLabels ? rects?.Select((r, i) => (r, i.ToS())) : rects?.Select(r => (r, (string)null)), labelOptions);
		}
		
		/// <summary>
		/// Sets to draw multiple rectangles with labels.
		/// </summary>
		/// <param name="rects">Rectangles with label text. The text should be short, single line, else may draw clipped.</param>
		/// <inheritdoc cref="SetRects(IEnumerable{RECT}, bool, ORLabelOptions)"/>
		public void SetRects(IEnumerable<(RECT r, string s)> rects, ORLabelOptions labelOptions = null) {
			if (rects == null) {
				_rects = null;
				Rect = default;
			} else {
				_rects = rects.ToArray();
				var r = RECT.FromLTRB(_rects.Min(o => o.r.left), _rects.Min(o => o.r.top), _rects.Max(o => o.r.right), _rects.Max(o => o.r.bottom));
				if (_hasLabels = _rects.Any(o => o.s != null)) {
					int ii = screen.of(r).Dpi;
					r.Inflate(ii * 2, ii / 4);
				}
				Rect = r;
				_labelOptions = labelOptions ?? new('L');
				Redraw();
			}
		}
	}
	
	/// <summary>
	/// Shows text on screen, like a tooltip or with transparent background.
	/// </summary>
	/// <remarks>
	/// Creates a temporary partially transparent window, and draws text in it.
	/// Most properties cannot be changed after creating OSD window.
	/// </remarks>
	public class osdText : OsdWindow {
		NativeFont_ _font;
		
		///
		protected override void Dispose(bool disposing) {
			base.Dispose(disposing);
			_font?.Dispose(); _font = null;
		}
		
		/// <summary>
		/// Coordinates.
		/// Default: <c>null</c> (screen center).
		/// </summary>
		/// <remarks>
		/// Not used if <see cref="Rect"/> is set.
		/// This property can be changed after creating OSD window.
		/// </remarks>
		/// <example>
		/// <code><![CDATA[
		/// var m = new osdText { Text = "Text" };
		/// m.XY = new(Coord.Center, Coord.Max); //bottom-center of the work area of the primary screen
		/// m.Show();
		/// ]]></code>
		/// </example>
		public PopupXY XY {
			get => _xy;
			set {
				_xy = value;
				if (value != null) _rectIsSet = false;
				if (IsHandleCreated) base.Rect = Measure();
			}
		}
		PopupXY _xy;
		
		/// <summary>
		/// Gets or sets OSD window size and position in screen.
		/// </summary>
		/// <remarks>
		/// Normally don't need to use this property. If not used, the OSD window size depends on text etc, and position on <see cref="XY"/>.
		/// This property can be changed after creating OSD window.
		/// </remarks>
		/// <seealso cref="Measure"/>
		public override RECT Rect {
			get => base.Rect;
			set { _rectIsSet = true; base.Rect = value; }
		}
		bool _rectIsSet;
		
		void _ResizeOrInvalidate() {
			if (ResizeWhenContentChanged) base.Rect = Measure(); //info: invalidates if resized, because of the CS_ styles
			Invalidate();
		}
		
		/// <summary>
		/// When changing text, resize/move the OSD window if need.
		/// Default: <c>false</c>.
		/// </summary>
		public bool ResizeWhenContentChanged { get; set; }
		
		/// <summary>
		/// Text in OSD window.
		/// </summary>
		/// <remarks>
		/// This property can be changed after creating OSD window; then the window is not moved/resized, unless <see cref="ResizeWhenContentChanged"/> is <c>true</c>.
		/// </remarks>
		public string Text {
			get => _text;
			set { if (value != _text) { _text = value; _ResizeOrInvalidate(); } }
		}
		string _text;
		
		/// <summary>
		/// Font.
		/// Default: <see cref="defaultSmallFont"/>.
		/// </summary>
		/// <remarks>
		/// This property cannot be changed after creating OSD window.
		/// </remarks>
		public FontNSS Font { get; set; }
		
		/// <summary>
		/// Text color.
		/// Default: <see cref="defaultTextColor"/>.
		/// </summary>
		/// <remarks>
		/// This property can be changed after creating OSD window.
		/// </remarks>
		public ColorInt TextColor {
			get => _textColor;
			set { if (value != _textColor) { _textColor = value; Invalidate(); } }
		}
		ColorInt _textColor;
		
		/// <summary>
		/// Background color.
		/// Default: <see cref="defaultBackColor"/>.
		/// </summary>
		/// <remarks>
		/// This property can be changed after creating OSD window.
		/// Not used for completely transparent OSD.
		/// </remarks>
		public ColorInt BackColor {
			get => _backColor;
			set { if (value != _backColor) { _backColor = value; Invalidate(); } }
		}
		ColorInt _backColor;
		
		/// <summary>
		/// Border color.
		/// Default: <see cref="defaultBorderColor"/>.
		/// </summary>
		/// <remarks>
		/// This property can be changed after creating OSD window.
		/// No border if <see cref="OsdWindow.Opacity"/>==0 or <c>BorderColor</c>==<see cref="BackColor"/>.
		/// </remarks>
		public ColorInt BorderColor {
			get => _borderColor;
			set { if (value != _borderColor) { _borderColor = value; Invalidate(); } }
		}
		private ColorInt _borderColor;
		
		/// <summary>
		/// Background image.
		/// </summary>
		/// <remarks>
		/// This property cannot be changed after creating OSD window.
		/// </remarks>
		public Image BackgroundImage { get; set; }
		
		//public ImageLayout BackgroundImageLayout { get; set; } //FUTURE
		
		/// <summary>
		/// When used <see cref="BackgroundImage"/>, the OSD window has the same size as the image, plus borders.
		/// Else OSD window size is calculated from sizes of text and icon. Then image is displayed scaled or clipped if need.
		/// </summary>
		/// <remarks>
		/// This property cannot be changed after creating OSD window.
		/// </remarks>
		public bool IsOfImageSize { get; set; }
		
		/// <summary>
		/// Maximal text width.
		/// Default: 0 - no limit (depends on screen width etc).
		/// </summary>
		/// <remarks>
		/// This property cannot be changed after creating OSD window.
		/// </remarks>
		public int WrapWidth { get; set; }
		
		/// <summary>
		/// Gets or sets text format flags.
		/// Default: <c>TFFlags.NOPREFIX | TFFlags.WORDBREAK | TFFlags.EXPANDTABS</c>.
		/// </summary>
		/// <remarks>
		/// This property cannot be changed after creating OSD window.
		/// </remarks>
		public TFFlags TextFormatFlags { get; set; } = TFFlags.NOPREFIX | TFFlags.WORDBREAK | TFFlags.EXPANDTABS;
		
		/// <summary>
		/// Icon or image at the left. Any size.
		/// </summary>
		/// <remarks>
		/// For example <c>System.Drawing.SystemIcons.Information</c> or <c>icon.stock(StockIcon.INFO)</c> or <c>ImageUtil.LoadGdipBitmapFromXaml("XAML copied from the Icons tool. You can edit, Width, Height and Fill (color).", screen.primary.Dpi)</c>.
		/// 
		/// This property cannot be changed after creating OSD window.
		/// </remarks>
		/// <value><see cref="icon"/>, <see cref="System.Drawing.Icon"/> or <see cref="System.Drawing.Image"/>.</value>
		public object Icon { get; set; }
		SIZE _iconSize;
		
		/// <summary>
		/// If <c>true</c>, the OSD window will have shadow.
		/// </summary>
		/// <remarks>
		/// This property cannot be changed after creating OSD window.
		/// Window shadows can be disabled. See <ms>SPI_SETDROPSHADOW</ms>.
		/// </remarks>
		public new bool Shadow { get => base.Shadow; set => base.Shadow = value; }
		
		/// <summary>
		/// If <c>true</c>, the OSD window receive mouse messages. Only completely transparent areas don't. The user can click to close the OSD (left, right or middle button).
		/// </summary>
		/// <remarks>
		/// This property cannot be changed after creating OSD window.
		/// </remarks>
		public new bool ClickToClose { get => base.ClickToClose; set => base.ClickToClose = value; }
		
		/// <summary>
		/// See <see cref="OsdMode"/>.
		/// </summary>
		/// <remarks>
		/// This property cannot be changed after creating OSD window.
		/// </remarks>
		public OsdMode ShowMode { get; set; }
		
		//CONSIDER: public AnyWnd Owner { get; set; }
		
		///
		public osdText() {
			Font = defaultSmallFont;
			_textColor = defaultTextColor;
			_backColor = defaultBackColor;
			_borderColor = defaultBorderColor;
		}
		
		/// <summary>
		/// Shows the OSD window. Creates if need.
		/// By default does not wait; the window will be closed after <see cref="SecondsTimeout"/>.
		/// </summary>
		/// <remarks>
		/// Depending on <see cref="ShowMode"/>, creates the OSD window in this or new thread.
		/// If the OSD window is already created, just shows it if hidden. Many properties can be changed only before creating OSD window; call <see cref="OsdWindow.Close"/> if need.
		/// </remarks>
		public override void Show() {
			if (!Hwnd.Is0) {
				base.Show();
				return;
			}
			bool thisThread = false, wait = false;
			switch (ShowMode) {
			case OsdMode.Auto: thisThread = process.thisThreadHasMessageLoop(); break;
			case OsdMode.ThisThread: thisThread = true; break;
			case OsdMode.Wait: thisThread = wait = true; break;
			}
			if (thisThread) {
				_Show(wait);
			} else {
				//Task.Run(() => ShowWait()); //works too, but cannot use StrongThread
				run.thread(() => _Show(true), ShowMode == OsdMode.WeakThread).Name = "Au.osdText";
				Au.wait.until(30, () => IsHandleCreated);
				
				//CONSIDER: make smaller timeout when main thread ended if OsdShowMode.Auto
			}
		}
		
		void _Show(bool sync) {
			if (!_rectIsSet) base.Rect = Measure();
			
			base.Show();
			_SetCloseTimer();
			if (sync) wait.doEventsUntil(0, () => !IsHandleCreated);
		}
		
		void _SetCloseTimer() {
			int t = SecondsTimeout;
			if (t == 0) t = Math.Min(Text.Lenn(), 1000) / 10 + 3; //calc time from text length
			
			if (t > 0) Api.SetTimer(Hwnd, 1, Math.Min(t, int.MaxValue / 1000) * 1000, null);
			else Api.KillTimer(Hwnd, 1);
		}
		
		/// <summary>
		/// Close the OSD window after this time, seconds.
		/// If 0 (default), depends on text length. Can be <see cref="Timeout.Infinite"/> (-1).
		/// </summary>
		public int SecondsTimeout {
			get => _secondsTimeout;
			set {
				_secondsTimeout = value;
				if (IsHandleCreated) Hwnd.SendNotify(Api.WM_USER + 100);
			}
		}
		int _secondsTimeout;
		
#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
		protected override nint WndProc(wnd w, int message, nint wParam, nint lParam) {
			switch (message) {
			case Api.WM_TIMER when wParam == 1:
				Close();
				return 0;
			case Api.WM_USER + 100:
				_SetCloseTimer();
				return 0;
			}
			
			return base.WndProc(w, message, wParam, lParam);
		}
#pragma warning restore CS1591 // Missing XML comment for publicly visible type or member
		
		/// <summary>
		/// Draws OSD text etc.
		/// </summary>
		protected override void OnPaint(IntPtr dc, Graphics g, RECT r) {
			//print.it(Api.GetCurrentThreadId());
			if (Opacity != 0) {
				g.Clear((Color)BackColor); //else OsdWindow cleared with TransparentColor
				
				if (BorderColor != BackColor) { //border
					g.DrawRectangleInset((Color)BorderColor, 1, r);
					r.Inflate(-1, -1);
				}
			}
			
			if (BackgroundImage != null) {
				g.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.HighQualityBicubic;
				g.DrawImageUnscaledAndClipped(BackgroundImage, r); //info: if image smaller - scales; if bigger - clips.
			}
			
			_EnsureFontAndMargin(Dpi.OfWindow(Hwnd)); //eg if Measure not called because Rect is set
			
			r.Inflate(-_margin, -_margin);
			if (Font.Italic) r.Width += _margin / 2; //avoid clipping part of last char
			
			if (_iconSize != default) {
				int x = r.left + c_iconPadding, y = r.top + c_iconPadding;
				if (Icon is Image im) {
					g.DrawImageUnscaled(im, x, y);
				} else {
					var hi = Icon switch { icon k => k.Handle, Icon k => k.Handle, _ => default };
					Api.DrawIconEx(dc, x, y, hi, 0, 0);
				}
				r.left += _iconSize.width + c_iconPadding * 2;
			}
			
			if (!Text.NE()) {
				Api.SetTextColor(dc, TextColor.ToBGR());
				Api.SetBkMode(dc, 1);
				var tff = TextFormatFlags; if (WrapWidth > 0) tff |= TFFlags.WORDBREAK;
				using var soFont = new GdiSelectObject_(dc, _font);
				RECT rt = r;
				Api.DrawText(dc, Text, ref rt, tff);
			}
		}
		
		const int c_iconPadding = 5;
		int _margin;
		
		void _EnsureFontAndMargin(int dpi) {
			if (Text.NE()) {
				_margin = 0;
			} else if (_font == null) {
				var f = Font ?? defaultSmallFont;
				_font = f.CreateFont(dpi);
				_margin = Dpi.Scale(Math.Max(f.Size / 3, 3), dpi);
			}
		}
		
		/// <summary>
		/// Calculates OSD window size and position.
		/// Can be called before showing OSD.
		/// </summary>
		public RECT Measure() {
			Size z = default;
			if (IsOfImageSize && BackgroundImage != null) {
				z = BackgroundImage.Size;
			} else {
				Size zi = default;
				if (Icon != null) {
					switch (Icon) {
					case icon k: zi = k.Size; break;
					case Icon k: zi = k.Size; break;
					case Image k: zi = k.Size; break;
					}
					_iconSize = zi;
					if (zi != default) { zi.Width += c_iconPadding * 2; zi.Height += c_iconPadding * 2; }
				}
				
				var scrn = XY?.GetScreen() ?? defaultScreen.Now;
				int dpi = scrn.Dpi;
				_margin = 0;
				if (!Text.NE()) {
					_font?.Dispose(); _font = null;
					_EnsureFontAndMargin(dpi);
					var tff = TextFormatFlags;
					int maxWidth = scrn.WorkArea.Width - zi.Width - 10;
					int ww = WrapWidth; if (ww > 0) { maxWidth = Math.Min(maxWidth, ww); tff |= TFFlags.WORDBREAK; }
					using var dc = new FontDC_(_font);
					z = dc.MeasureDT(Text, tff, maxWidth);
				}
				
				z.Width += zi.Width;
				z.Height = Math.Max(z.Height, zi.Height);
				
				z.Width += _margin * 2; z.Height += _margin * 2;
			}
			
			if (Opacity != 0 && BorderColor != BackColor) { //border
				z.Width += 2; z.Height += 2;
			}
			
			RECT r = new(0, 0, z.Width, z.Height);
			//print.it(r);
			
			if (XY != null) {
				if (XY.inRect) r.MoveInRect(XY.rect, XY.x, XY.y, ensureInRect: false);
				else r.MoveInScreen(XY.x, XY.y, XY.screen, XY.workArea, ensureInScreen: false);
				r.EnsureInScreen(workArea: XY.workArea);
			} else {
				r.MoveInScreen(Coord.Center, Coord.Center, defaultScreen, workArea: true, ensureInScreen: true);
			}
			
			return r;
		}
		
		#region public static
		
		/// <summary>
		/// Shows a tooltip-like OSD window with text and optionally icon.
		/// </summary>
		/// <param name="text">Text in OSD window.<br/>Sets <see cref="Text"/>.</param>
		/// <param name="secondsTimeout"><inheritdoc cref="SecondsTimeout" path="/summary/node()"/>Sets <see cref="SecondsTimeout"/>.</param>
		/// <param name="xy"><inheritdoc cref="XY" path="/summary/node()"/>Sets <see cref="XY"/>.</param>
		/// <param name="icon"><inheritdoc cref="Icon" path="/summary/node()"/>Sets <see cref="Icon"/>.</param>
		/// <param name="textColor"><inheritdoc cref="TextColor" path="/summary/node()"/>Sets <see cref="TextColor"/>.</param>
		/// <param name="backColor"><inheritdoc cref="BackColor" path="/summary/node()"/>Sets <see cref="BackColor"/>.</param>
		/// <param name="font"><inheritdoc cref="Font" path="/summary/node()"/>Sets <see cref="Font"/>.</param>
		/// <param name="name">OSD window name.<br/>Sets <see cref="OsdWindow.Name"/>.</param>
		/// <param name="showMode">Sets <see cref="ShowMode"/>.</param>
		/// <param name="dontShow">Don't call <see cref="Show"/>. The caller can use the return value to set some other properties and call <c>Show</c>.</param>
		/// <returns>Returns an <see cref="osdText"/> object that can be used to change properties or close the OSD window.</returns>
		/// <remarks>
		/// Also sets these properties: <see cref="ClickToClose"/>=<c>true</c>, <see cref="Shadow"/>=<c>true</c>.
		/// </remarks>
		public static osdText showText(string text,
			int secondsTimeout = 0, PopupXY xy = null,
			object icon = null, ColorInt? textColor = null, ColorInt? backColor = null, FontNSS font = null,
			string name = null, OsdMode showMode = default, bool dontShow = false) {
			var o = new osdText {
				_text = text,
				SecondsTimeout = secondsTimeout,
				_xy = xy,
				Icon = icon,
				_textColor = textColor ?? defaultTextColor,
				_backColor = backColor ?? defaultBackColor,
				Font = font ?? defaultSmallFont,
				Name = name,
				ShowMode = showMode,
				ClickToClose = true,
				Shadow = true
			};
			
			if (!dontShow) o.Show();
			return o;
		}
		
		/// <summary>
		/// Shows a big-font text with transparent background.
		/// </summary>
		/// <param name="color">Sets <see cref="TextColor"/>. Default: <see cref="defaultTransparentTextColor"/>.</param>
		/// <param name="font">Sets <see cref="Font"/>. Default: <see cref="defaultBigFont"/>.</param>
		/// <remarks>
		/// Also sets these properties: <see cref="OsdWindow.Opacity"/>=0.
		/// </remarks>
		/// <inheritdoc cref="showText(string, int, PopupXY, object, ColorInt?, ColorInt?, FontNSS, string, OsdMode, bool)"/>
		public static osdText showTransparentText(string text,
			int secondsTimeout = 0, PopupXY xy = null,
			ColorInt? color = null, FontNSS font = null,
			string name = null, OsdMode showMode = default, bool dontShow = false) {
			var o = new osdText {
				_text = text,
				SecondsTimeout = secondsTimeout,
				_xy = xy,
				_textColor = color ?? defaultTransparentTextColor,
				Font = font ?? s_bigFont,
				Name = name,
				ShowMode = showMode,
				Opacity = 0d
			};
			
			if (!dontShow) o.Show();
			return o;
		}
		
		/// <summary>
		/// Shows on-screen image.
		/// </summary>
		/// <param name="image">Sets <see cref="BackgroundImage"/>.</param>
		/// <remarks>
		/// Also sets these properties: <see cref="IsOfImageSize"/>=<c>true</c>, <see cref="OsdWindow.Opacity"/>=0, <see cref="ClickToClose"/>=<c>true</c>.
		/// </remarks>
		/// <inheritdoc cref="showText(string, int, PopupXY, object, ColorInt?, ColorInt?, FontNSS, string, OsdMode, bool)"/>
		public static osdText showImage(Image image,
			int secondsTimeout = 0, PopupXY xy = null,
			string name = null, OsdMode showMode = default, bool dontShow = false) {
			var o = new osdText {
				BackgroundImage = image,
				SecondsTimeout = secondsTimeout,
				_xy = xy,
				Name = name,
				ShowMode = showMode,
				IsOfImageSize = true,
				Opacity = 0d,
				ClickToClose = true
			};
			o._backColor = o.TransparentColor;
			
			if (!dontShow) o.Show();
			return o;
		}
		
		/// <summary>Default font for <see cref="showText"/> and <see cref="osdText"/>. Default: standard GUI font (usually <c>Segoe UI</c>), size 12.</summary>
		/// <exception cref="ArgumentNullException"></exception>
		public static FontNSS defaultSmallFont { get => s_smallFont; set => s_smallFont = value ?? throw new ArgumentNullException(); }
		static FontNSS s_smallFont = new(12);
		
		/// <summary>Default font for <see cref="showTransparentText"/>. Default: standard GUI font (usually <c>Segoe UI</c>), size 24.</summary>
		/// <exception cref="ArgumentNullException"></exception>
		public static FontNSS defaultBigFont { get => s_bigFont; set => s_bigFont = value ?? throw new ArgumentNullException(); }
		static FontNSS s_bigFont = new(24);
		
		/// <summary>Default text color for <see cref="showText"/> and <see cref="osdText"/>. Default: 0x(dark gray).</summary>
		public static ColorInt defaultTextColor { get; set; } = 0x404040;
		
		/// <summary>Default border color for <see cref="showText"/> and <see cref="osdText"/>. Default: 0x404040 (dark gray).</summary>
		public static ColorInt defaultBorderColor { get; set; } = 0x404040;
		
		/// <summary>Default background color for <see cref="showText"/> and <see cref="osdText"/>. Default: 0xFFFFF0 (light yellow).</summary>
		public static ColorInt defaultBackColor { get; set; } = 0xFFFFF0;
		
		/// <summary>Default text color for <see cref="showTransparentText"/>. Default: <c>0x8A2BE2</c> (<c>Color.BlueViolet</c>).</summary>
		public static ColorInt defaultTransparentTextColor { get; set; } = 0x8A2BE2;
		
		/// <summary>
		/// Default screen when <see cref="XY"/> is not set.
		/// The <see cref="screen"/> must be lazy or empty.
		/// </summary>
		/// <exception cref="ArgumentException"><see cref="screen"/> with <c>Handle</c>. Must be lazy (with <see cref="screen.LazyFunc"/>) or empty.</exception>
		/// <example>
		/// <code><![CDATA[
		/// osdText.defaultScreen = screen.index(1, lazy: true);
		/// ]]></code>
		/// </example>
		public static screen defaultScreen {
			get => _defaultScreen;
			set => _defaultScreen = value.ThrowIfWithHandle_;
		}
		static screen _defaultScreen;
		
		#endregion
	}
}

namespace Au.Types {
	/// <summary>
	/// Whether <see cref="osdText.Show"/> waits or shows the OSD window in this or new thread.
	/// </summary>
	/// <remarks>
	/// If this thread has windows, any value can be used, but usually <c>Auto</c> (default) or <c>ThisThread</c> is the best.
	/// </remarks>
	public enum OsdMode {
		/// <summary>Depends on <see cref="process.thisThreadHasMessageLoop"/>. If it is <c>true</c>, uses <c>ThisThread</c>, else <c>StrongThread</c>. Does not wait.</summary>
		Auto,
		
		/// <summary>
		/// Show the OSD window in this thread and don't wait.
		/// This thread must must be a UI thread (with windows etc).
		/// </summary>
		ThisThread,
		
		/// <summary>Show the OSD window in new thread and don't wait. Set <see cref="Thread.IsBackground"/>=<c>true</c>, so that the OSD is closed when other threads of this app end.</summary>
		WeakThread,
		
		/// <summary>Show the OSD window in new thread and don't wait. Set <see cref="Thread.IsBackground"/>=<c>false</c>, so that the OSD is not closed when other threads of this app end.</summary>
		StrongThread,
		
		/// <summary>
		/// Show the OSD window in this thread and wait until it disappears.
		/// Waits <see cref="osdText.SecondsTimeout"/> seconds. While waiting, dispatches messages etc; see <see cref="wait.doEvents(int)"/>.
		/// </summary>
		Wait,
	}
}

================================================
FILE: Au/GUI/popupMenu/MTBase.cs
================================================
using System.Drawing;

namespace Au.Types;

/// <summary>
/// Base class of <see cref="popupMenu"/> and <see cref="toolbar"/>.
/// </summary>
/// <remarks>
/// <i>image</i> argument of "add item" functions can be:
/// - icon name, like <c>"*Pack.Icon color"</c> (you can get it from the <b>Icons</b> tool). See <see cref="ImageUtil.LoadWpfImageElement"/>.
/// - file/folder path (string) - the "show" function calls <see cref="icon.of"/> to get its icon. It also supports file type icons like <c>".txt"</c>, etc.
/// - file path with prefix <c>"imagefile:"</c> or resource path that starts with <c>"resources/"</c> or has prefix <c>"resource:"</c> - the "show" function loads <c>.png</c> or <c>.xaml</c> image file or resource.
/// - string with prefix <c>"image:"</c> - Base64 encoded image file. Can be created with the <b>Find image</b> tool.
/// - <see cref="FolderPath"/> - same as folder path string.
/// - <see cref="Image"/> - image.
/// - <see cref="icon"/> - icon. The "add item" function disposes it.
/// - <see cref="StockIcon"/> - the "show" function calls <see cref="icon.stock"/>.
/// - <c>null</c> - if <see cref="ExtractIconPathFromCode"/> <c>true</c>, the "show" function tries to extract a file path from action code; then calls <see cref="icon.of"/>. Else no image.
/// - string <c>""</c> - no image, even if <see cref="ExtractIconPathFromCode"/> <c>true</c>.
/// 
/// Item images should be of size 16x16 (small icon size). If high DPI, will scale images automatically, which makes them slightly blurred. To avoid scaling, can be used XAML images, but then slower.
/// 
/// Images are loaded on demand, when showing the menu or submenu etc. If fails to load, prints warning (<see cref="print.warning"/>).
/// 
/// For icon/image files use full path, unless they are in <see cref="folders.ThisAppImages"/>
/// 
/// To add an image resource in Visual Studio, use build action <b>Resource</b> for the image file.
/// </remarks>
public abstract partial class MTBase {
	private protected readonly string _name;
	private protected readonly string _sourceFile;
	private protected readonly int _sourceLine;
	private protected readonly int _threadId;
	private protected wnd _w;
	private protected int _dpi;
	(wnd tt, MTItem item, RECT rect) _tt;
	
	private protected MTBase() {
		_threadId = Api.GetCurrentThreadId();
	}
	
	private protected MTBase(string name, string f_, int l_, string m_ = null) : this() {
		if (name == null && !m_.NE())
			if (m_[0] is not ('<' or '.')) name = m_; //<Main>$, .ctor
		_name = name;
		_sourceFile = f_;
		_sourceLine = l_;
	}
	
	private protected virtual void _WmNccreate(wnd w) {
		_w = w;
		MouseCursor.SetArrowCursor_(); //workaround for: briefly shows "wait" cursor when entering mouse first time in process
	}
	
	private protected virtual void _WmNcdestroy() {
		_w = default;
		_tt = default;
		if (_stdAO != null) {
			Marshal.ReleaseComObject(_stdAO);
			_stdAO = null;
		}
	}
	
	/// <summary>
	/// Extract file path or script path from item action code (for example <see cref="run.it"/> or <see cref="script.run"/> argument) and use icon of that file or script.
	/// This property is applied to items added afterwards; submenus inherit it.
	/// </summary>
	/// <value>Default: <see cref="toolbar"/> <c>true</c>, <see cref="popupMenu"/> with <i>name</i> <c>true</c>, <see cref="popupMenu"/> without <i>name</i> <c>false</c>.</value>
	/// <remarks>
	/// Gets path from code that contains a string like <c>@"c:\windows\system32\notepad.exe"</c> or <c>@"%folders.System%\notepad.exe"</c> or URL/shell or <c>@"\folder\script.cs"</c>.
	/// Also supports code patterns like <c>folders.System + "notepad.exe"</c>, <c>folders.shell.RecycleBin</c>.
	/// 
	/// If extracts path, also in the context menu adds item <b>Find file</b> which selects the file in Explorer or <b>Open script</b> which opens the script in editor.
	/// </remarks>
	public bool ExtractIconPathFromCode { get; set; }
	
	/// <summary>
	/// Execute item actions asynchronously in new threads.
	/// This property is applied to items added afterwards; submenus inherit it.
	/// </summary>
	/// <value>Default: <see cref="toolbar"/> <c>true</c>, <see cref="popupMenu"/> <c>false</c>.</value>
	/// <remarks>
	/// If current thread is a UI thread (has windows etc) or has triggers or hooks, and item action functions execute some long automations etc in current thread, current thread probably is hung during that time. Set this property = <c>true</c> to avoid it.
	/// </remarks>
	public bool ActionThread { get; set; }
	
	/// <summary>
	/// Whether to handle exceptions in item action code. If <c>false</c> (default), handles exceptions and on exception calls <see cref="print.warning"/>.
	/// This property is applied to items added afterwards; submenus inherit it.
	/// </summary>
	/// <value>Default: <see cref="toolbar"/> <c>false</c>, <see cref="popupMenu"/> <c>false</c>.</value>
	public bool ActionException { get; set; }
	
	/// <summary>
	/// If an item has file path, show it in tooltip.
	/// This property is applied to items added afterwards; submenus inherit it.
	/// </summary>
	/// <value>Default: <see cref="toolbar"/> <c>false</c>, <see cref="popupMenu"/> <c>false</c>.</value>
	public bool PathInTooltip { get; set; }
	
	/// <summary>
	/// Width and height of images. Default 16, valid 16-256.
	/// </summary>
	public int ImageSize { get; set; } = 16;
	
	private protected IconImageCache _ImageCache => field ??= IconImageCache.CommonOfSize(ImageSize);
	
	private protected void _CopyProps(MTBase m) {
		m.ImageSize = ImageSize;
		m.ActionException = ActionException;
		m.ActionThread = ActionThread;
		m.ExtractIconPathFromCode = ExtractIconPathFromCode;
		m.PathInTooltip = PathInTooltip;
	}
	
	private protected string _SourceLink(MTItem x, string text) => x.sourceFile == null ? null : $"<open {x.sourceFile}|{x.sourceLine}>{text}<>";
	
	private protected bool _IsOtherThread => _threadId != Api.GetCurrentThreadId();
	
	internal void _ThreadTrap() {
		if (_threadId != Api.GetCurrentThreadId()) throw new InvalidOperationException("Wrong thread.");
	}
	
	/// <summary>
	/// Converts <c>x.image</c> (object containing string, <c>Image</c>, etc or <c>null</c>) to <c>Image</c>. Extracts icon path from code if need. Returns default if will extract async.
	/// </summary>
	private protected (Image image, bool dispose) _GetImage(MTItem x) {
		Image im = null; bool dontDispose = false;
		
		if (x.extractIconPath == 1) { //extract path always, not only when x.image==null, or we would not have path for other purposes
			x.file = icon.ExtractIconPathFromCode_(x.clicked.Method, out bool cs);
			if (x.file != null) {
				x.image ??= x.file;
				x.extractIconPath = (byte)(cs ? 4 : 2);
			} else x.extractIconPath = 3;
		}
		
		switch (x.image) {
		case Image g:
			im = g;
			dontDispose = true;
			break;
		case string s when s.Length > 0:
			try {
				dontDispose = true;
				bool isImage = ImageUtil.HasImageOrResourcePrefix(s);
				im = _ImageCache.Get(s, _dpi, isImage, _OnException);
				if (im == null && isImage) _OnException(s, null);
			}
			catch (Exception e1) { _OnException(null, e1); }
			
			void _OnException(string s, Exception e) {
				print.it($"<>Failed to load image. {e?.ToStringWithoutStack().TrimEnd('.') ?? s}. {_SourceLink(x, "Edit")}");
			}
			break;
		case StockIcon si:
			im = icon.stock(si)?.ToGdipBitmap();
			break;
		}
		return (im, im != null && !dontDispose);
	}
	
	private protected string _GetFullTooltip(MTItem b) {
		var s = b.Tooltip;
		if (this is toolbar tb) {
			var v = b as TBItem;
			if (!(tb.DisplayText || v.textAlways)) {
				if (s.NE()) s = v.Text;
				else if (!v.Text.NE()) s = b.Text + "\n" + s;
			}
		}
		if (b.pathInTooltip) {
			var sf = b.File;
			if (!(sf.NE() || sf.Starts("::") || sf.Starts("shell:"))) s = s.NE() ? sf : s + "\n" + sf;
		}
		return s;
	}
	
	private protected unsafe void _SetTooltip(MTItem b, RECT r, nint lParam, int submenuDelay = -1) {
		string s = _GetFullTooltip(b);
		bool setTT = !s.NE() && b != _tt.item;
		if (!setTT && (setTT = _tt.item != null && _tt.item.rect != _tt.rect)) b = _tt.item; //update tooltip tool rect
		if (setTT) {
			_tt.rect = r;
			_tt.item = b;
			if (!_tt.tt.IsAlive) {
				_tt.tt = Api.CreateWindowEx(WSE.TOPMOST | WSE.TRANSPARENT, "tooltips_class32", null, Api.TTS_ALWAYSTIP | Api.TTS_NOPREFIX, 0, 0, 0, 0, _w);
				_tt.tt.Send(Api.TTM_ACTIVATE, 1);
				_tt.tt.Send(Api.TTM_SETMAXTIPWIDTH, 0, screen.of(_w).WorkArea.Width / 3);
			}
			
			if (b is PMItem) { //ensure the tooltip is above submenu in Z order
				_tt.tt.ZorderTopRaw_();
				if (submenuDelay > 0) submenuDelay += 100;
				_tt.tt.Send(0x403, 3, submenuDelay > (int)_tt.tt.Send(0x415, 3) ? submenuDelay : -1); //TTM_SETDELAYTIME,TTM_GETDELAYTIME,TTDT_INITIAL
			}
			
			fixed (char* ps = s) {
				var g = new Api.TTTOOLINFO { cbSize = sizeof(Api.TTTOOLINFO), hwnd = _w, uId = 1, lpszText = ps, rect = r };
				_tt.tt.Send(Api.TTM_DELTOOL, 0, &g);
				_tt.tt.Send(Api.TTM_ADDTOOL, 0, &g);
			}
		} else {
			if (b != _tt.item) _HideTooltip();
		}
		
		if (_tt.item != null) {
			var v = new MSG { hwnd = _w, message = Api.WM_MOUSEMOVE, lParam = lParam };
			_tt.tt.Send(Api.TTM_RELAYEVENT, 0, &v);
		}
	}
	
	private protected unsafe void _HideTooltip() {
		if (_tt.item != null) {
			_tt.item = null;
			var g = new Api.TTTOOLINFO { cbSize = sizeof(Api.TTTOOLINFO), hwnd = _w, uId = 1 };
			_tt.tt.Send(Api.TTM_DELTOOL, 0, &g);
		}
	}
}

/// <summary>
/// Base of <see cref="PMItem"/> etc.
/// </summary>
public abstract class MTItem {
	internal Delegate clicked;
	internal object image;
	/// <summary>1 if need to extract, 2 if already extracted (the image field is the path), 3 if failed to extract, 4 if extracted <c>"script.cs"</c></summary>
	internal byte extractIconPath; //from MTBase.ExtractIconPathFromCode
	internal bool actionThread; //from MTBase.ActionThread
	internal bool actionException; //from MTBase.ActionException
	internal bool pathInTooltip; //from MTBase.PathInTooltip
	internal int sourceLine;
	internal string sourceFile;
	internal string file;
	internal RECT rect;
	internal Image image2;
	
	internal bool HasImage_ => image2 != null;
	
	/// <summary>
	/// Item text.
	/// </summary>
	public string Text { get; set; }
	
	/// <summary>
	/// Item tooltip.
	/// </summary>
	public string Tooltip { get; set; }
	
	/// <summary>
	/// Any value. Not used by this library.
	/// </summary>
	public object Tag { get; set; }
	
	///
	public ColorInt TextColor { get; set; }
	
	/// <summary>
	/// Gets file or script path extracted from item action code (see <see cref="MTBase.ExtractIconPathFromCode"/>) or sets path as it would be extracted.
	/// </summary>
	/// <remarks>
	/// Can be used to set file or script path when it cannot be extracted from action code.
	/// When you set this property, the menu/toolbar item uses icon of the specified file, and its context menu contains <b>Find file</b> or <b>Open script</b>.
	/// </remarks>
	public string File {
		get => file;
		set {
			file = value;
			if (file == null) {
				extractIconPath = 3;
			} else {
				image ??= file;
				bool cs = file.Ends(".cs", true) && !pathname.isFullPath(file, orEnvVar: true);
				extractIconPath = (byte)(cs ? 4 : 2);
			}
		}
	}
	
	internal void GoToFile_() {
		if (file.NE()) return;
		if (extractIconPath == 2) run.selectInExplorer(file);
		else ScriptEditor.Open(file);
	}
	
	internal static (bool edit, bool go, string goText) CanEditOrGoToFile_(string sourceFile, MTItem item) {
		if (sourceFile != null) {
			if (ScriptEditor.Available) {
				if (item?.file == null) return (true, false, null);
				return (true, true, item.extractIconPath == 2 ? "Find file" : "Open script");
			} else if (item?.extractIconPath == 2) {
				return (false, true, "Find file");
			}
		}
		return default;
	}
	
	/// <summary>
	/// Call when adding menu/toolbar item.
	/// Sets text and tooltip (from text). Sets <c>clicked</c>, <c>image</c> and <c>sourceLine</c> fields.
	/// Sets <c>extractIconPath</c>, <c>actionThread</c> and <c>actionException</c> fields from <i>mt</i> properties.
	/// </summary>
	internal void Set_(MTBase mt, string text, Delegate click, MTImage im, int l_, string f_) {
		if (!text.NE()) {
			var mi = this as PMItem;
			bool rawText = mi?.rawText ?? false;
			int i = text.IndexOf('\0');
			if (i < 0 && !rawText) i = text.IndexOf('|');
			if (i >= 0) {
				var v = _Split(text, i);
				text = v.Item1;
				Tooltip = v.Item2;
			}
			int len = text.Lenn();
			if (len > 0 && text[^1] == '\a') {
				text = text[..^1]; //remove for menu too, because user may move items from toolbar to menu and forget to remove '\a'
				len--;
				if (this is TBItem ti) ti.textAlways = true; //note: textAlways of groups is already true
			}
			if (mi != null && !rawText && len > 1) {
				i = text.IndexOf('\t', 1);
				if (i > 0) {
					var v = _Split(text, i);
					text = v.Item1;
					mi.Hotkey = v.Item2;
				}
			}
			if (!text.NE()) Text = text;
			
			static (string, string) _Split(string s, int i) {
				int j = i + 1; if (s.Eq(j, ' ')) j++;
				return (i > 0 ? s[..i] : null, j < s.Length ? s[j..] : null);
			}
		}
		
		image = im.Value;
		if (image is icon ic) { image = ic.ToGdipBitmap(); image ??= ""; } //DestroyIcon now; don't extract from code.
		
		clicked = click;
		sourceLine = l_;
		sourceFile = f_;
		
		extractIconPath = (byte)((mt.ExtractIconPathFromCode && clicked is not (null or Action<popupMenu> or Func<popupMenu>)) ? 1 : 0);
		actionThread = mt.ActionThread;
		actionException = mt.ActionException;
		pathInTooltip = mt.PathInTooltip;
	}
	
	///
	public override string ToString() => Text;
}

/// <summary>
/// Used for menu/toolbar function parameters to specify an image in different ways (file path, <see cref="Image"/> object, etc).
/// </summary>
/// <remarks>
/// Has implicit conversions from string, <see cref="Image"/>, <see cref="icon"/>, <see cref="StockIcon"/>, <see cref="FolderPath"/>.
/// More info: <see cref="MTBase"/>.
/// </remarks>
public struct MTImage {
	readonly object _o;
	MTImage(object o) { _o = o; }
	
	///
	public static implicit operator MTImage(string pathEtc) => new(pathEtc);
	///
	public static implicit operator MTImage(Image image) => new(image);
	///
	public static implicit operator MTImage(icon icon) => new(icon);
	///
	public static implicit operator MTImage(StockIcon icon) => new(icon);
	///
	public static implicit operator MTImage(FolderPath path) => new((string)path);
	
	/// <summary>
	/// Gets the raw value stored in this variable. Can be <c>string</c>, <see cref="Image"/>, <see cref="icon"/>, <see cref="StockIcon"/> or <c>null</c>.
	/// </summary>
	public object Value => _o;
}


================================================
FILE: Au/GUI/popupMenu/pm acc.cs
================================================

using IAccessible = Au.Types.Api.IAccessible;
using VarInt = Au.Types.Api.VarInt;
using NAVDIR = Au.Types.Api.NAVDIR;

namespace Au.Types {
	[ComVisible(true)]
	partial class MTBase {
		private protected bool _WmGetobject(nint wParam, nint lParam, out nint result) {
			result = default;
			var oid = (EObjid)lParam;
			if (oid != EObjid.CLIENT) return false;
			result = Cpp.Cpp_AccWorkaround((IAccessible)this, wParam, ref _accWorkaround);
			return true;
		}
		nint _accWorkaround;

		///
		~MTBase() { if (_accWorkaround != 0) Cpp.Cpp_AccWorkaround(null, 0, ref _accWorkaround); }

		private protected IAccessible _StdAO {
			get {
				if (_stdAO == null) Api.CreateStdAccessibleObject(_w, EObjid.CLIENT, typeof(IAccessible).GUID, out _stdAO);
				return _stdAO;
			}
		}
		IAccessible _stdAO;
	}
}

namespace Au {
	[ComVisible(true)]
	partial class popupMenu : IAccessible {
		IAccessible IAccessible.get_accParent() => _StdAO.get_accParent();

		int IAccessible.get_accChildCount() => _a.Count;

		int IAccessible.get_accChild(VarInt varChild, out object ppdispChild) { ppdispChild = null; return 1; }

		string IAccessible.get_accName(VarInt varChild)
			=> !_B(varChild, out var b) ? _name : (b.rawText ? b.Text : StringUtil.RemoveUnderlineChar(b.Text));

		string IAccessible.get_accValue(VarInt varChild) => null;

		string IAccessible.get_accDescription(VarInt varChild) => _B(varChild, out _) ? null : "Popup menu";

		VarInt IAccessible.get_accRole(VarInt varChild) {
			var r = !_B(varChild, out var b) ? ERole.MENUPOPUP : (b.IsSeparator ? ERole.SEPARATOR : ERole.MENUITEM);
			return (int)r - 1;
		}

		VarInt IAccessible.get_accState(VarInt varChild) {
			EState r = 0;
			if (!_w.IsEnabled()) r |= EState.DISABLED;
			if (!_B(varChild, out var b)) {
				if (!_w.IsVisible) r |= EState.INVISIBLE;
			} else {
				if (b.IsDisabled) r |= EState.DISABLED;
				if (FocusedItem == b) r |= EState.FOCUSED | EState.HOTTRACKED;
				if (b.IsChecked) r |= EState.CHECKED;
				if (b.IsSubmenu) r |= EState.HASPOPUP;
				//TODO3: if offscreen, r |= EState.INVISIBLE | EState.OFFSCREEN;
			}
			return (int)r - 1;
		}

		string IAccessible.get_accHelp(VarInt varChild) => _B(varChild, out var b) ? _GetFullTooltip(b) : null;

		int IAccessible.get_accHelpTopic(out string pszHelpFile, VarInt varChild) => throw new NotImplementedException();

		string IAccessible.get_accKeyboardShortcut(VarInt varChild) {
			if (_B(varChild, out var b) && !b.rawText) {
				var s = b.Text;
				int i = StringUtil.FindUnderlineChar(s);
				if (i >= 0) return s[i].ToString();
			}
			return null;
		}

		object IAccessible.get_accFocus() => null;

		object IAccessible.get_accSelection() => null;

		string IAccessible.get_accDefaultAction(VarInt varChild)
			=> !_B(varChild, out var b) || b.IsDisabled ? null : b.IsSubmenu ? "Open" : "Execute";

		void IAccessible.accSelect(ESelect flagsSelect, VarInt varChild) => throw new NotImplementedException();

		void IAccessible.accLocation(out int pxLeft, out int pyTop, out int pcxWidth, out int pcyHeight, VarInt varChild) {
			if (!_B(varChild, out var b)) {
				_StdAO.accLocation(out pxLeft, out pyTop, out pcxWidth, out pcyHeight, varChild);
			} else {
				var r = _ItemRect(b, inScreen: true);
				pxLeft = r.left; pyTop = r.top; pcxWidth = r.Width; pcyHeight = r.Height;
			}
		}

		object IAccessible.accNavigate(NAVDIR navDir, VarInt varStart) {
			int i = varStart;
			if (navDir == NAVDIR.FIRSTCHILD || navDir == NAVDIR.LASTCHILD) {
				if (i == -1) return navDir == NAVDIR.FIRSTCHILD ? 1 : _a.Count;
			} else {
				if (i == -1) return _StdAO.accNavigate(navDir, varStart);
				switch (navDir) {
				case NAVDIR.PREVIOUS:
					if (i > 0) return i;
					break;
				case NAVDIR.NEXT:
					if (++i < _a.Count) return i + 1;
					break;
				}
			}
			return null;
		}

		VarInt IAccessible.accHitTest(int xLeft, int yTop) {
			POINT p = new(xLeft, yTop); _w.MapScreenToClient(ref p);
			if (!_w.ClientRect.Contains(p)) return _StdAO.accHitTest(xLeft, yTop);
			return _HitTest(p);
		}

		void IAccessible.accDoDefaultAction(VarInt varChild) {
			if (!_B(varChild, out var b) || b.IsDisabled) return;
			_w.Post(Api.WM_USER + 50, (int)varChild);
		}

		void IAccessible.put_accName(VarInt varChild, string szName) => throw new NotImplementedException();

		void IAccessible.put_accValue(VarInt varChild, string szValue) => throw new NotImplementedException();

		bool _B(VarInt varChild, out PMItem b) {
			int i = varChild;
			if (i == -1) { b = null; return false; }
			b = _a[i]; return true;
		}
	}
}

================================================
FILE: Au/GUI/popupMenu/pm render.cs
================================================
using System.Drawing;
using System.Drawing.Drawing2D;

namespace Au;

public unsafe partial class popupMenu {
	/// <summary>
	/// Sets some metrics, for example item padding.
	/// </summary>
	/// <seealso cref="defaultMetrics"/>
	public PMMetrics Metrics { get; set; }
	
	/// <summary>
	/// Sets or gets default metrics.
	/// </summary>
	/// <seealso cref="Metrics"/>
	public static PMMetrics defaultMetrics {
		get => s_defaultMetrics ??= new();
		set { s_defaultMetrics = value; }
	}
	static PMMetrics s_defaultMetrics;
	
	/// <summary>
	/// Sets or gets font.
	/// </summary>
	public FontNSS Font { get; set; }
	
	/// <summary>
	/// Sets or gets default font.
	/// </summary>
	public static FontNSS defaultFont { get; set; }
	
	NativeFont_ _GetFont(bool bold = false) {
		var font = Font ?? defaultFont;
		if (font == null) return bold ? NativeFont_.BoldCached(_dpi) : NativeFont_.RegularCached(_dpi);
		if (!bold) return _font ??= font.CreateFont(_dpi);
		return _fontBold ??= (font with { Bold = true }).CreateFont(_dpi);
	}
	NativeFont_ _font, _fontBold; //disposing in _WmNcdestroy or ~NativeFont_
	
	_Metrics _met;
	
	class _Metrics : IDisposable {
		public bool hasImages, hasSubmenus, hasSeparators, hasHotkeys, checkInImageColumn;
		public int border, paddingY, paddingLeft, paddingRight, textPaddingX, textPaddingY, image, check, check2, submenu, submenuMargin, separator, sepLine;
		public SIZE sizeCheck, sizeSubmenu;
		public IntPtr theme;
		public int xTextEnd, xHotkeyStart;
		
		public void Dispose() {
			if (theme != default) {
				Api.CloseThemeData(theme);
				theme = default;
			}
			GC.SuppressFinalize(this);
		}
		
		~_Metrics() => Dispose();
		
		public _Metrics(popupMenu m) {
			bool hasCheck = false;
			foreach (var b in m._a) {
				if (b.IsSeparator) hasSeparators = true;
				else {
					if (b.HasImage_) hasImages = true;
					if (b.checkType > 0) hasCheck = true;
					if (b.IsSubmenu) hasSubmenus = true;
					if (b.Hotkey != null) hasHotkeys = true;
				}
			}
			if (hasCheck && hasImages) {
				checkInImageColumn = true;
				foreach (var b in m._a) if (b.checkType > 0 && b.HasImage_) { checkInImageColumn = false; break; }
			}
			
			var k = m.Metrics;
			if (k == null) {
				for (var p = m._sub.parent; p != null; p = p._sub.parent) if ((k = p.Metrics) != null) break;
			}
			k ??= defaultMetrics;
			
			int dpi = m._dpi;
			border = dpi / 96;
			paddingY = Dpi.Scale(k.ItemPaddingY, dpi);
			paddingLeft = Dpi.Scale(k.ItemPaddingLeft, dpi);
			paddingRight = Dpi.Scale(k.ItemPaddingRight, dpi);
			textPaddingX = Dpi.Scale(8, dpi);
			textPaddingY = Dpi.Scale(1, dpi);
			if (hasImages) image = Dpi.Scale(m.ImageSize, dpi);
			if (hasCheck) check = Dpi.Scale(18, dpi);
			if (hasSubmenus) submenu = Dpi.Scale(16, dpi);
			separator = Dpi.Scale(8, dpi);
			sepLine = 2;
			
			theme = Api.OpenThemeData(m._w, "Menu", dpi);
			if (theme != default) {
				using var dc = new ScreenDC_();
				if (hasSubmenus) {
					Api.GetThemePartSize(theme, dc, 16, 1, null, Api.THEMESIZE.TS_TRUE, out sizeSubmenu);
					submenu = Math.Max(submenu, sizeSubmenu.width + submenu / 4);
				}
				if (hasCheck) {
					Api.GetThemePartSize(theme, dc, 11, 1, null, Api.THEMESIZE.TS_TRUE, out sizeCheck);
					check = Math.Max(check, sizeCheck.width + 2);
				}
				if (hasSeparators && 0 == Api.GetThemePartSize(theme, dc, 15, 0, null, Api.THEMESIZE.TS_TRUE, out var z)) sepLine = z.height;
			}
			
			if (checkInImageColumn) { check2 = check; check = 0; }
			
			submenuMargin = hasHotkeys ? 0 : submenu;
		}
	}
	
	SIZE _Measure(int maxWidth) {
		SIZE R = default;
		
		_met?.Dispose();
		_met = new _Metrics(this);
		
		int buttonPlusX = (_met.border + _met.textPaddingX) * 2 + _met.check + _met.image + _met.submenu + _met.submenuMargin + _met.paddingLeft + _met.paddingRight;
		int maxTextWidth = maxWidth - buttonPlusX;
		
		var font = _GetFont();
		using var dc = new FontDC_(font);
		int textHeight = dc.MeasureEP(" ").height;
		
		int maxHotkey = 0;
		if (_met.hasHotkeys) {
			foreach (var b in _a) {
				if (b.Hotkey == null) continue;
				int wid = dc.MeasureDT(b.Hotkey, c_tffHotkey).width;
				maxHotkey = Math.Max(maxHotkey, Math.Min(wid, maxTextWidth / 2));
			}
		}
		int hotkeyPlus = textHeight * 3 / 2; //space between text and hotkey
		if (maxHotkey > 0) maxTextWidth -= maxHotkey += hotkeyPlus;
		
		int y = 0;
		for (int i = 0; i < _a.Count; i++) {
			//note: to support multiline, wrap, underlines and tabs we have to use DrawText, not TextOut.
			//	DrawText(DT_CALCRECT) is slow. Very slow compared with GetTextExtentPoint32. Eg 100-300 ms for 1000 items. Depends on text length.
			var b = _a[i];
			SIZE z;
			if (b.IsSeparator) {
				z = new(0, _met.separator);
			} else {
				var s = b.Text;
				if (!s.NE()) {
					if (b.FontBold) Api.SelectObject(dc, _GetFont(true));
					z = dc.MeasureDT(s, _TfFlags(b), maxTextWidth);
					z.width = Math.Min(z.width, maxTextWidth);
					if (b.FontBold) Api.SelectObject(dc, font);
					_met.xTextEnd = Math.Max(_met.xTextEnd, z.width);
					z.width += buttonPlusX;
					b.textHeight = z.height;
				} else z = new(0, textHeight);
				z.height = Math.Max(z.height + _met.textPaddingY * 2 + 1, _met.image + _met.image / 16 * 2) + (_met.border + _met.paddingY) * 2;
			}
			b.rect = new(0, y, z.width, z.height);
			y += z.height;
			R.width = Math.Max(R.width, z.width);
			R.height = Math.Max(R.height, y);
		}
		
		if (maxHotkey > 0) {
			R.width += maxHotkey;
			_met.xHotkeyStart = _met.xTextEnd + hotkeyPlus;
		}
		foreach (var b in _a) b.rect.right = R.width;
		
		return R;
	}
	
	TFFlags _TfFlags(PMItem b) {
		var f = c_tff; if (b.rawText) f |= TFFlags.NOPREFIX; else if (!_flags.Has(PMFlags.Underline)) f |= TFFlags.HIDEPREFIX;
		return f;
	}
	const TFFlags c_tff = TFFlags.EXPANDTABS | TFFlags.WORDBREAK /*| TFFlags.PATH_ELLIPSIS*/;
	const TFFlags c_tffHotkey = TFFlags.NOPREFIX | TFFlags.SINGLELINE | TFFlags.VCENTER;
	
	void _Render(IntPtr dc, RECT rUpdate) {
		using (var menuBrush = GdiObject_.SysColorBrush(_met.theme, Api.COLOR_BTNFACE)) menuBrush.BrushFill(dc, rUpdate);
		
		using var g = _met.hasImages ? Graphics.FromHdc(dc) : null;
		if (g != null) {
			g.InterpolationMode = InterpolationMode.HighQualityBicubic;
		}
		var font = _GetFont();
		using var soFont = new GdiSelectObject_(dc, font);
		Api.SetBkMode(dc, 1);
		int textColor = Api.GetThemeSysColor(_met.theme, Api.COLOR_BTNTEXT),
			textColorDisabled = Api.GetThemeSysColor(_met.theme, Api.COLOR_GRAYTEXT);
		
		rUpdate.Offset(0, _scroll.Offset);
		for (int i = _scroll.Pos; i < _a.Count; i++) {
			var b = _a[i];
			
			if (b.rect.bottom <= rUpdate.top) continue;
			if (b.rect.top >= rUpdate.bottom) break;
			
			var r = _ItemRect(b);
			
			if (b.IsSeparator) {
				r.Inflate(-_met.textPaddingX / 4, 0);
				//r.left+=_met.check+_met.image;
				r.top += (r.Height - _met.sepLine) / 2;
				r.Height = _met.sepLine;
				if (_met.theme != default) Api.DrawThemeBackground(_met.theme, dc, 15, 0, r);
				else Api.DrawEdge(dc, ref r, Api.EDGE_ETCHED, Api.BF_TOP);
			} else {
				if (b.BackgroundColor != default)
					using (var brush = GdiObject_.ColorBrush(b.BackgroundColor)) brush.BrushFill(dc, r);
				if (i == _iHot) {
					if ((textColor == 0 || b.TextColor != default) && b.BackgroundColor == default)
						using (var brush = GdiObject_.ColorBrush(0xC0DCF3)) brush.BrushFill(dc, r);
					using (var brush = GdiObject_.ColorBrush(0x90C8F6)) brush.BrushRect(dc, r);
				}
				
				r.Inflate(-_met.border, -_met.border - _met.paddingY);
				r.left += _met.paddingLeft; r.right -= _met.paddingRight;
				var r2 = r;
				
				r.left += _met.check;
				
				if (b.HasImage_) {
					try { g.DrawImage(b.image2, r.left + _met.textPaddingY, r.top + (r.Height - _met.image) / 2, _met.image, _met.image); }
					catch (Exception ex) { Debug_.Print(ex); }
				}
				
				r.left += _met.image + _met.textPaddingX; r.right -= _met.textPaddingX + _met.submenu + _met.submenuMargin;
				r.top += _met.textPaddingY; r.bottom -= _met.textPaddingY;
				
				if (b.Hotkey != null) {
					Api.SetTextColor(dc, textColorDisabled);
					var rr = r; rr.left += _met.xHotkeyStart;
					Api.DrawText(dc, b.Hotkey, ref rr, c_tffHotkey);
				}
				
				Api.SetTextColor(dc, b.TextColor != default ? b.TextColor.ToBGR() : (b.IsDisabled ? textColorDisabled : textColor));
				if (!b.Text.NE()) {
					if (b.FontBold) Api.SelectObject(dc, _GetFont(true));
					r.Width = _met.xTextEnd;
					var rr = r; rr.Offset(0, (r.Height - b.textHeight) / 2); //vcenter
					Api.DrawText(dc, b.Text, ref rr, _TfFlags(b));
					if (b.FontBold) Api.SelectObject(dc, font);
				}
				
				if (b.IsSubmenu) {
					_DrawControl(_met.sizeSubmenu, 16, b.IsDisabled ? 2 : 1, "➜", r2.right - _met.submenu, r.top, _met.submenu, r.Height);
				}
				if (b.IsChecked) {
					_DrawControl(_met.sizeCheck, 11, b.checkType == 1 ? (b.IsDisabled ? 2 : 1) : (b.IsDisabled ? 4 : 3), b.checkType == 1 ? "✔" : "●", r2.left, r.top, Math.Max(_met.check, _met.check2), r.Height);
				}
				
				void _DrawControl(SIZE z, int part, int state, string c, int x, int y, int width, int height) {
					if (_met.theme != default && z != default) {
						RECT r = new(x, r2.top + (r2.Height - z.height) / 2, z.width, z.height); //vcenter
						Api.DrawThemeBackground(_met.theme, dc, part, state, r);
					} else {
						RECT r = new(x, y, width, height);
						Api.DrawText(dc, c, ref r, TFFlags.CENTER | TFFlags.VCENTER | TFFlags.SINGLELINE | TFFlags.NOCLIP);
						//cannot use DrawFrameControl(DFC_MENU, DFCS_MENUARROW etc), it draws with white background and small when high DPI
					}
				}
			}
		}
	}
	
	void _WmNcpaint() {
		using var dc = new WindowDC_(Api.GetWindowDC(_w), _w);
		RECT r = new(0, 0, _size.window.width, _size.window.height);
		using var brushBorder = GdiObject_.SysColorBrush(_met.theme, Api.COLOR_BTNSHADOW);
		using var brushPadding = GdiObject_.SysColorBrush(_met.theme, Api.COLOR_BTNFACE);
		for (int i = 0; i < _size.border; i++) {
			Api.FrameRect(dc, r, i == 0 ? brushBorder : brushPadding);
			r.Inflate(-1, -1);
		}
	}
	
	internal void Invalidate_(PMItem k = null) {
		_ThreadTrap();
		if (_w.Is0) return;
		if (k != null) Api.InvalidateRect(_w, _ItemRect(k));
		else Api.InvalidateRect(_w);
	}
	
	void _Invalidate(int i) => Invalidate_(_a[i]);
	
	void _Images() {
		foreach (var v in _a) {
			v.image2 = _GetImage(v).image;
		}
	}
	
	//not used
	//internal void ChangeImage_(PMItem ti, Bitmap b) {
	//	ti.image2 = b;
	//	_Invalidate(ti);
	//}
}


================================================
FILE: Au/GUI/popupMenu/pm types.cs
================================================

namespace Au.Types;

/// <summary>
/// Represents a menu item in <see cref="popupMenu"/>.
/// </summary>
/// <remarks>
/// Most properties cannot be changed while the menu is open. Can be changed <see cref="MTItem.Tag"/>, <see cref="MTItem.Tooltip"/>, <see cref="IsChecked"/> and <see cref="IsDisabled"/>.
/// </remarks>
public class PMItem : MTItem {
	readonly popupMenu _m;
	internal byte checkType; //1 checkbox, 2 radio
	internal bool checkDontClose;
	internal bool rawText;
	internal int textHeight;
	
	internal PMItem(popupMenu m, bool isDisabled, bool isChecked = false) {
		_m = m;
		_isDisabled = isDisabled;
		_isChecked = isChecked;
		checkDontClose = m.CheckDontClose;
		rawText = m.RawText;
	}
	
	/// <summary>Gets item action.</summary>
	public Action<PMItem> Clicked => base.clicked as Action<PMItem>;
	
	/// <summary>Gets or sets menu item id.</summary>
	public int Id { get; set; }
	
	/// <summary><c>true</c> if is a submenu-item.</summary>
	public bool IsSubmenu { get; init; }
	
	/// <summary><c>true</c> if is a separator.</summary>
	public bool IsSeparator { get; init; }
	
	/// <summary>
	/// Gets or sets disabled state.
	/// </summary>
	public bool IsDisabled {
		get => _isDisabled || IsSeparator;
		set {
			if (value != _isDisabled && !IsSeparator) {
				_isDisabled = value;
				_m.Invalidate_(this);
			}
		}
	}
	bool _isDisabled;
	
	/// <summary>
	/// Gets or sets checked state.
	/// </summary>
	/// <exception cref="InvalidOperationException">The <c>set</c> function throws this exception if the item isn't checkable. Use <see cref="popupMenu.AddCheck"/> or <see cref="popupMenu.AddRadio"/>.</exception>
	public bool IsChecked {
		get => _isChecked;
		set {
			if (checkType == 0) throw new InvalidOperationException();
			if (value != _isChecked) {
				_isChecked = value;
				_m.Invalidate_(this);
			}
		}
	}
	bool _isChecked;
	
	/// <summary>Gets or sets whether to use bold font.</summary>
	public bool FontBold { get; set; }
	
	/// <summary>Gets or sets background color.</summary>
	public ColorInt BackgroundColor { get; set; }
	
	/// <summary>
	/// Hotkey display text.
	/// </summary>
	public string Hotkey { get; set; }
	
	/// <summary>
	/// Invokes <see cref="Clicked"/> if not <c>null</c>.
	/// Handles exceptions if need. Invokes in new thread if need.
	/// </summary>
	internal void InvokeAction_() {
		if (clicked is Action<PMItem> action) {
			if (actionThread) run.thread(() => _Invoke(), background: false); else _Invoke();
			void _Invoke() {
				try { action(this); }
				catch (Exception ex) when (!this.actionException) { print.warning(ex); }
			}
		}
	}
}

/// <summary>
/// Flags for <see cref="popupMenu"/> <c>ShowX</c> methods.
/// </summary>
/// <remarks>
/// The <c>AlignX</c> flags are for API <ms>TrackPopupMenuEx</ms>.
/// </remarks>
[Flags]
public enum PMFlags {
	/// <summary>Show by the caret (text cursor) position. If not possible, use flag <c>WindowCenter</c> or <c>ScreenCenter</c> or <i>xy</i> or mouse position.</summary>
	ByCaret = 0x1000000,
	
	/// <summary>Show in the center of the screen that contains the mouse pointer.</summary>
	ScreenCenter = 0x2000000,
	
	/// <summary>Show in the center of the active window.</summary>
	WindowCenter = 0x4000000,
	
	/// <summary>Underline characters preceded by <c>&amp;</c>, regardless of Windows settings. More info: <see cref="StringUtil.RemoveUnderlineChar"/>.</summary>
	Underline = 0x8000000,
	
	//TPM_ flags
	
	/// <summary>Horizontally align the menu so that the show position would be in its center.</summary>
	AlignCenterH = 0x4,
	
	/// <summary>Horizontally align the menu so that the show position would be at its right side.</summary>
	AlignRight = 0x8,
	
	/// <summary>Vertically align the menu so that the show position would be in its center.</summary>
	AlignCenterV = 0x10,
	
	/// <summary>Vertically align the menu so that the show position would be at its bottom.</summary>
	AlignBottom = 0x20,
	
	/// <summary>Show at the bottom or top of <i>excludeRect</i>, not at the right/left.</summary>
	AlignRectBottomTop = 0x40,
}

/// <summary>
/// Used with <see cref="popupMenu.KeyboardHook"/>.
/// </summary>
public enum PMKHook {
	/// <summary>Process the key event as usually.</summary>
	Default,
	
	/// <summary>Close the menu.</summary>
	Close,
	
	/// <summary>Do nothing.</summary>
	None,
	
	/// <summary>Execute the focused item and close the menu.</summary>
	ExecuteFocused,
}

/// <summary>
/// Used with <see cref="popupMenu.Metrics"/> and <see cref="popupMenu.defaultMetrics"/>.
/// </summary>
/// <remarks>
/// All values are in logical pixels (1 pixel when DPI is 100%).
/// </remarks>
public record class PMMetrics(int ItemPaddingY = 0, int ItemPaddingLeft = 0, int ItemPaddingRight = 0);


================================================
FILE: Au/GUI/popupMenu/popupMenu.cs
================================================
//TODO3: winevents EEvent.SYSTEM_MENUSTART, EEvent.SYSTEM_MENUEND, EEvent.SYSTEM_MENUPOPUPSTART, EEvent.SYSTEM_MENUPOPUPEND

namespace Au;

/// <summary>
/// Popup menu.
/// </summary>
/// <remarks>
/// Can be used everywhere: in automation scripts, WPF apps, other apps, etc.
/// Also can be used as a popup list and supports many items with scrollbar.
/// 
/// Menu item text can include hotkey after <c>'\t'</c> character and/or tooltip after <c>'|'</c> or <c>'\0'</c> character. Examples: <c>"Text\t Hotkey"</c>, <c>"Text|Tooltip"</c>, <c>"Text\t Hotkey\0 Tooltip"</c>. Character with prefix <c>&amp;</c> (eg <c>'A'</c> in <c>"Save &amp;As"</c>) will be underlined (depends on Windows settings and <see cref="PMFlags"/>) and can be used to select the item with keyboard.
/// 
/// Keyboard, mouse:
/// - <c>Enter</c>, <c>Tab</c>, <c>Space</c> - close the menu and execute the focused item. Or show the submenu.
/// - <c>Esc</c> - close the menu or current submenu.
/// - <c>Left</c> - close current submenu.
/// - <c>Right</c> - open submenu.
/// - <c>Down</c>, <c>Up</c>, <c>PageDown</c>, <c>PageUp</c>, <c>End</c>, <c>Home</c> - focus other item.
/// - underlined menu item character - close the menu and execute the item. Or show the submenu. See <see cref="PMFlags.Underline"/>.
/// - <c>Alt</c>, <c>Win</c>, <c>F10</c>, <c>Apps</c>, <c>Back</c> - close menus.
/// - click outside - close the menu.
/// - middle click - close the menu.
/// - right click - show context menu (if used constructor with parameters).
/// 
/// While a menu is open, it captures many keyboard keys, even when its thread isn't the foreground thread.
/// 
/// Not thread-safe. All functions must be called in same thread, unless documented otherwise.
/// </remarks>
/// <example>
/// <code><![CDATA[
/// var m = new popupMenu("example");
/// m["One"] = o => print.it(o);
/// m["Two\0Tooltip", image: icon.stock(StockIcon.DELETE)] = o => { print.it(o); dialog.show(o.ToString()); };
/// m.Submenu("Submenu", m => {
/// 	m["Three"] = o => print.it(o);
/// 	m["Four"] = o => print.it(o);
/// });
/// m["notepad"] = o => run.itSafe(folders.System + "notepad.exe");
/// m.Show();
/// ]]></code>
/// </example>
public unsafe partial class popupMenu : MTBase {
	readonly List<PMItem> _a = new();
	int _lastId; //to auto-generate item ids
	bool _addedNewItems;
	(SIZE window, SIZE client, int border) _size;
	NativeScrollbar_ _scroll;
	(popupMenu child, popupMenu parent, PMItem item, timer timer) _sub;
	(POINT p, bool track, bool left, bool right, bool middle) _mouse;
	int _iHot = -1;
	PMFlags _flags;
	PMItem _result;
	
	static popupMenu() {
		WndUtil.RegisterWindowClass("Au.popupMenu", etc: new() { style = Api.CS_HREDRAW | Api.CS_VREDRAW | Api.CS_DROPSHADOW, mCursor = MCursor.Arrow });
	}
	
	/// <summary>
	/// Use this constructor for various context menus of your app.
	/// </summary>
	/// <remarks>
	/// Users cannot right-click a menu item and open/select it in editor.
	/// </remarks>
	public popupMenu() { }
	
	/// <summary>
	/// Use this constructor in scripts.
	/// </summary>
	/// <param name="name">Menu name. Must be a unique valid filename. Currently not used. Can be <c>null</c>.</param>
	/// <param name="f_">[](xref:caller_info)</param>
	/// <param name="l_">[](xref:caller_info)</param>
	/// <remarks>
	/// This overload sets <see cref="MTBase.ExtractIconPathFromCode"/> = <c>true</c>.
	/// 
	/// Users can right-click an item to open/select it in editor, unless <i>f_</i> is explicitly set = <c>null</c>.
	/// </remarks>
	public popupMenu(string name, [CallerFilePath] string f_ = null, [CallerLineNumber] int l_ = 0) : base(name, f_, l_) {
		ExtractIconPathFromCode = true;
	}
	
	#region add
	
	PMItem _Add(PMItem mi, string text, MTImage image, int l_, string f_, Delegate click = null) {
		_ThreadTrap();
		_OpenTrap("cannot add items while the menu is open. To add to submenu, use the submenu variable.");
		if (!mi.IsSeparator) mi.Set_(this, text, click, image, l_, _sourceFile == null ? null : f_);
		_a.Add(mi);
		_addedNewItems = true;
		Last = mi;
		return mi;
	}
	
	/// <summary>
	/// Adds menu item with explicitly specified id.
	/// </summary>
	/// <param name="id">Item id that <see cref="Show"/> will return if clicked this item.</param>
	/// <param name="text">Item text. Can include hotkey, tooltip and underlined character, like <c>"Te&amp;xt\t Hotkey\0 Tooltip"</c>; more info: <see cref="popupMenu"/>.</param>
	/// <param name="image">Item image. Read here: <see cref="MTBase"/>.</param>
	/// <param name="disable">Disabled state.</param>
	/// <param name="l_">[](xref:caller_info)</param>
	/// <param name="f_">[](xref:caller_info)</param>
	public PMItem Add(int id, string text, MTImage image = default, bool disable = false, [CallerLineNumber] int l_ = 0, [CallerFilePath] string f_ = null)
		=> _Add(new PMItem(this, disable) { Id = _lastId = id }, text, image, l_, f_);
	
	/// <summary>
	/// Adds menu item with auto-generated id.
	/// </summary>
	/// <param name="text">Item text. Can include hotkey, tooltip and underlined character, like <c>"Te&amp;xt\t Hotkey\0 Tooltip"</c>; more info: <see cref="popupMenu"/>.</param>
	/// <param name="image">Item image. Read here: <see cref="MTBase"/>.</param>
	/// <param name="disable">Disabled state.</param>
	/// <param name="l_">[](xref:caller_info)</param>
	/// <param name="f_">[](xref:caller_info)</param>
	/// <remarks>
	/// Assigns id = the last specified or auto-generated id + 1. If not using explicitly specified ids, auto-generated ids are 1, 2, 3... Submenu-items, separators and items with action don't auto-generate ids.
	/// </remarks>
	public PMItem Add(string text, MTImage image = default, bool disable = false, [CallerLineNumber] int l_ = 0, [CallerFilePath] string f_ = null)
		=> _Add(new PMItem(this, disable) { Id = ++_lastId }, text, image, l_, f_);
	
	/// <summary>
	/// Adds menu item with action (callback function) that is executed on click.
	/// </summary>
	/// <param name="text">Item text. Can include hotkey, tooltip and underlined character, like <c>"Te&amp;xt\t Hotkey\0 Tooltip"</c>; more info: <see cref="popupMenu"/>.</param>
	/// <param name="click">Action executed on click.</param>
	/// <param name="image">Item image. Read here: <see cref="MTBase"/>.</param>
	/// <param name="disable">Disabled state.</param>
	/// <param name="l_">[](xref:caller_info)</param>
	/// <param name="f_">[](xref:caller_info)</param>
	/// <remarks>
	/// This function is the same as the indexer. The difference is, <c>Add</c> returns <see cref="PMItem"/> object of the added item. When using the indexer, to access the item use <see cref="Last"/>. These codes are the same: <c>var v=m.Add("text", o=>{});"</c> and <c>m["text"]=o=>{}; var v=m.Last;</c>.
	/// </remarks>
	public PMItem Add(string text, Action<PMItem> click, MTImage image = default, bool disable = false, [CallerLineNumber] int l_ = 0, [CallerFilePath] string f_ = null)
		=> _Add(new PMItem(this, disable), text, image, l_, f_, click);
	
	/// <summary>
	/// Adds menu item with action (callback function) that is executed on click.
	/// </summary>
	/// <param name="text">Item text. Can include hotkey, tooltip and underlined character, like <c>"Te&amp;xt\t Hotkey\0 Tooltip"</c>; more info: <see cref="popupMenu"/>.</param>
	/// <param name="image">Item image. Read here: <see cref="MTBase"/>.</param>
	/// <param name="disable">Disabled state.</param>
	/// <param name="l_">[](xref:caller_info)</param>
	/// <param name="f_">[](xref:caller_info)</param>
	/// <value>Action executed on click. Can be <c>null</c>.</value>
	/// <remarks>
	/// This function is the same as <see cref="Add(string, Action{PMItem}, MTImage, bool, int, string)"/>. The difference is, <c>Add</c> returns <see cref="PMItem"/> object of the added item. When using the indexer, to access the item use <see cref="Last"/>. These codes are the same: <c>var v=m.Add("text", o=>{});"</c> and <c>m["text"]=o=>{}; var v=m.Last;</c>.
	/// </remarks>
	public Action<PMItem> this[string text, MTImage image = default, bool disable = false, [CallerLineNumber] int l_ = 0, [CallerFilePath] string f_ = null] {
		set { Add(text, value, image, disable, l_, f_); }
	}
	
	/// <summary>
	/// Adds menu item to be used as a checkbox.
	/// </summary>
	/// <param name="text">Item text. Can include hotkey, tooltip and underlined character, like <c>"Te&amp;xt\t Hotkey\0 Tooltip"</c>; more info: <see cref="popupMenu"/>.</param>
	/// <param name="check">Checked state.</param>
	/// <param name="click">Action executed on click.</param>
	/// <param name="disable">Disabled state.</param>
	/// <param name="image">Item image. Read here: <see cref="MTBase"/>.</param>
	/// <param name="l_">[](xref:caller_info)</param>
	/// <param name="f_">[](xref:caller_info)</param>
	/// <remarks>
	/// When clicked, <see cref="PMItem.IsChecked"/> state is changed.
	/// </remarks>
	public PMItem AddCheck(string text, bool check = false, Action<PMItem> click = null, bool disable = false, MTImage image = default, [CallerLineNumber] int l_ = 0, [CallerFilePath] string f_ = null)
		=> _Add(new PMItem(this, disable, check) { checkType = 1 }, text, image, l_, f_, click);
	
	/// <summary>
	/// Adds menu item to be used as a radio button in a group of such items.
	/// </summary>
	/// <param name="text">Item text. Can include hotkey, tooltip and underlined character, like <c>"Te&amp;xt\t Hotkey\0 Tooltip"</c>; more info: <see cref="popupMenu"/>.</param>
	/// <param name="check">Checked state.</param>
	/// <param name="click">Action executed on click.</param>
	/// <param name="disable">Disabled state.</param>
	/// <param name="image">Item image. Read here: <see cref="MTBase"/>.</param>
	/// <param name="l_">[](xref:caller_info)</param>
	/// <param name="f_">[](xref:caller_info)</param>
	/// <remarks>
	/// When clicked an unchecked radio item, its <see cref="PMItem.IsChecked"/> state becomes <c>true</c>; <c>IsChecked</c> of other group items become <c>false</c>.
	/// </remarks>
	public PMItem AddRadio(string text, bool check = false, Action<PMItem> click = null, bool disable = false, MTImage image = default, [CallerLineNumber] int l_ = 0, [CallerFilePath] string f_ = null)
		=> _Add(new PMItem(this, disable, check) { checkType = 2 }, text, image, l_, f_, click);
	
	/// <summary>
	/// Adds menu item that opens a submenu.
	/// Used like <c>m.Submenu("Example", m => { /* add submenu items */ });</c>.
	/// </summary>
	/// <param name="text">Item text. Can include hotkey, tooltip and underlined character, like <c>"Te&amp;xt\t Hotkey\0 Tooltip"</c>; more info: <see cref="popupMenu"/>.</param>
	/// <param name="opening">Action called whenever opening the submenu and should add items to it.</param>
	/// <param name="image">Item image. Read here: <see cref="MTBase"/>.</param>
	/// <param name="disable">Disabled state.</param>
	/// <param name="l_">[](xref:caller_info)</param>
	/// <param name="f_">[](xref:caller_info)</param>
	/// <remarks>
	/// The submenu is other <see cref="popupMenu"/> object. It inherits many properties of this menu; see property documentation.
	/// </remarks>
	/// <example>
	/// <code><![CDATA[
	/// m.Submenu("Example", m => {
	/// 	m["A"] = o => { print.it(o); };
	/// 	m["B"] = o => { print.it(o); };
	/// });
	/// ]]></code>
	/// This code shows dynamically created menu of files in a folder and subfolders. Subfolder files are retrieved when opening the submenu.
	/// <code><![CDATA[
	/// var m=new popupMenu();
	/// _Dir(m, new DirectoryInfo(@"C:\"));
	/// m.Show();
	/// 
	/// static void _Dir(popupMenu m, DirectoryInfo dir) {
	/// 	foreach (var v in dir.EnumerateFileSystemInfos()) {
	/// 		if(v.Attributes.Has(FileAttributes.System|FileAttributes.Hidden)) continue;
	/// 		if(v.Attributes.Has(FileAttributes.Directory)) {
	/// 			m.Submenu(v.Name, m=> _Dir(m, v as DirectoryInfo));
	/// 		} else {
	/// 			m[v.Name]=o=>print.it(v.FullName);
	/// 		}
	/// 		m.Last.File = v.FullName;
	/// 	}
	/// }
	/// ]]></code>
	/// </example>
	public PMItem Submenu(string text, Action<popupMenu> opening, MTImage image = default, bool disable = false, [CallerLineNumber] int l_ = 0, [CallerFilePath] string f_ = null)
		=> _Add(new PMItem(this, disable) { IsSubmenu = true }, text, image, l_, f_, opening);
	
	/// <summary>
	/// Adds menu item that opens a reusable submenu.
	/// </summary>
	/// <param name="text">Item text. Can include hotkey, tooltip and underlined character, like <c>"Te&amp;xt\t Hotkey\0 Tooltip"</c>; more info: <see cref="popupMenu"/>.</param>
	/// <param name="opening">Func called whenever opening the submenu and should return the submenu object. Can return <c>null</c>.</param>
	/// <param name="image">Item image. Read here: <see cref="MTBase"/>.</param>
	/// <param name="disable">Disabled state.</param>
	/// <param name="l_">[](xref:caller_info)</param>
	/// <param name="f_">[](xref:caller_info)</param>
	/// <remarks>
	/// The caller creates the submenu (creates the <see cref="popupMenu"/> object and adds items) and can reuse it many times. Other overload does not allow to create <see cref="popupMenu"/> and reuse same object.
	/// The submenu does not inherit properties of this menu.
	/// </remarks>
	/// <example>
	/// <code><![CDATA[
	/// var m2 = new popupMenu(); m2.AddCheck("C1"); m2.AddCheck("C2");
	/// m.Submenu("Submenu", () => m2);
	/// ]]></code>
	/// </example>
	public PMItem Submenu(string text, Func<popupMenu> opening, MTImage image = default, bool disable = false, [CallerLineNumber] int l_ = 0, [CallerFilePath] string f_ = null)
		=> _Add(new PMItem(this, disable) { IsSubmenu = true }, text, image, l_, f_, opening);
	
	/// <summary>
	/// Adds separator.
	/// </summary>
	public void Separator()
		=> _Add(new PMItem(this, isDisabled: true) { IsSeparator = true }, null, default, 0, null);
	
	/// <summary>
	/// Gets the last added menu item.
	/// </summary>
	public PMItem Last { get; private set; }
	
	/// <summary>
	/// Gets added items, except separators and items in submenus.
	/// </summary>
	/// <remarks>
	/// Allows to set properties of multiple items in single place instead of after each "add item" code line.
	/// 
	/// Does not get items in submenus. Submenus are separate <see cref="popupMenu"/> objects and you can use their <c>Items</c> property.
	/// </remarks>
	public IEnumerable<PMItem> Items {
		get {
			_ThreadTrap();
			foreach (var v in _a) {
				if (!v.IsSeparator) yield return v;
			}
		}
	}
	
	/// <summary>
	/// Gets added items and separators, except items in submenus.
	/// </summary>
	public IReadOnlyList<PMItem> ItemsAndSeparators {
		get {
			_ThreadTrap();
			return _a;
		}
	}
	
	/// <summary>
	/// Don't use: <c>&amp;</c> character for keyboard shortcut; tab character for hotkey; <c>|</c> character for tooltip (but use <c>\0</c>).
	/// This property is applied to items added afterwards; submenus inherit it.
	/// </summary>
	public bool RawText { get; set; }
	
	/// <summary>
	/// Adds enum members as checkbox-items (if it's a <c>[Flags]</c> enum) or radio-items.
	/// </summary>
	/// <returns>Object for getting result later. See <see cref="EnumUI{TEnum}.Result"/>.</returns>
	/// <param name="init">Initial value.</param>
	/// <param name="items">Enum members and their text/tooltip. Optional. Text can be: <c>null</c>, <c>"text"</c>, <c>"text|tooltip"</c>, <c>"|tooltip"</c>.</param>
	[EditorBrowsable(EditorBrowsableState.Never)] //obsolete. Too simple. Added EnumUI examples in cookbook.
	public EnumUI<TEnum> AddEnum<TEnum>(TEnum init = default, (TEnum value, string text)[] items = null) where TEnum : unmanaged, Enum {
		return new EnumUI<TEnum>(this, init, items);
	}
	
	#endregion
	
	#region show, close
	
	/// <summary>
	/// Shows the menu and waits until closed.
	/// </summary>
	/// <returns>
	/// id of the selected item, or 0 if canceled.
	/// See also: <see cref="Result"/>.
	/// </returns>
	/// <param name="flags"></param>
	/// <param name="xy">Menu position in screen. If <c>null</c> (default), uses mouse position by default. It depends on <i>flags</i>.</param>
	/// <param name="excludeRect">The menu should not overlap this rectangle in screen.</param>
	/// <param name="owner">Owner window. The menu will be automatically closed when destroying its owner window.</param>
	/// <exception cref="InvalidOperationException">The menu is open or is submenu.</exception>
	public int Show(PMFlags flags = 0, POINT? xy = null, RECT? excludeRect = null, AnyWnd owner = default) {
		_ThreadTrap();
		_OpenTrap("this menu is already open");
		if (_sub.parent != null) throw new InvalidOperationException("this is a submenu");
		if (_a.Count == 0) return 0;
		
		Api.ReleaseCapture(); //winforms still capturing on MouseClick etc, and menu would be like disabled
		
		if (!flags.Has(PMFlags.Underline)) if (0 != Api.SystemParametersInfo(Api.SPI_GETKEYBOARDCUES, 0)) flags |= PMFlags.Underline;
		
		_Show(flags, xy, excludeRect, owner.Hwnd);
		
		int R = 0;
		
		WindowsHook hKey = null, hMouse = null;
		timer timer = null;
		try {
			var wFore = wnd.active;
			bool foreground = wFore.IsOfThisThread;
			
			//to close with mouse use timer. Mouse hook may not work because of UAC.
			int mouseState = _GetMouseState();
			timer = new(t => { //close if mouse clicked a non-menu window or if activated another window
				int ms = _GetMouseState();
				bool clicked = ms != mouseState;
				mouseState = ms;
				if (clicked) _CloseIfClickedNotMenu(wnd.fromMouse(WXYFlags.Raw));
				else if (wnd.active != wFore) Close();
			});
			timer.Every(30);
			
			static int _GetMouseState() =>
				(keys.gui.getKeyState(KKey.MouseLeft) & 0x1)
				| ((keys.gui.getKeyState(KKey.MouseRight) & 0x1) << 1)
				| ((keys.gui.getKeyState(KKey.MouseMiddle) & 0x1) << 2)
				;
			//note: use only toggled state. Pressed state may change to "no" when mouse is already in a non-menu window although was in a menu window at the time of the mouse event.
			//note: in some cases toggled state may not change when clicked. Eg when clicked a taskbar button that activates another window. Then helps if (wnd.active!=wFore) Close();.
			
			void _CloseIfClickedNotMenu(wnd w) {
				//if(!w.Get.Owners(andThisWindow: true).Contains(_w)) Close(); //no, user may want nested root menus, although it is rare
				if (!_IsMenuWindow(w)) Close();
			}
			
			bool _IsMenuWindow(wnd w) => w == _w || w.ClassNameIs("Au.popupMenu");
			
			if (!foreground) {
				//never mind: hooks don't work if the active window has higher UAC IL. Then use timer and mouse/Esc toggle state.
				hKey = WindowsHook.Keyboard(h => {
					var k = h.Key;
					if (KeyboardHook != null && !h.IsUp) {
						switch (KeyboardHook(this, h)) {
						case PMKHook.None: return;
						case PMKHook.Close:
							_w.Post(Api.WM_CLOSE);
							return;
						case PMKHook.ExecuteFocused when FocusedItem != null:
							_w.Post(Api.WM_USER + 50, _a.IndexOf(FocusedItem));
							h.BlockEvent();
							return;
						}
					}
#if true
					if (!_IsCancelKey(k)) {
						if (_IsPassKey(k)) return;
						h.BlockEvent();
					}
					if (!h.IsUp) _w.Post(Api.WM_KEYDOWN, (int)k, 0); //else _w.Post(Api.WM_KEYUP, (int)k, 0xC0000001);
#else //unfinished. The idea was to call TranslateMessage, and if then PeekMessage gets wm_char...
					if(_IsCancelKey(k)) {
						_w.Post(Api.WM_CLOSE);
						return;
					}
					if (!h.IsUp) {
						var ok=Api.TranslateMessage(new() { hwnd = _w, message = Api.WM_KEYDOWN, wParam = (int)k });
						//print.it(ok);
						if(Api.PeekMessage(out var v, _w, Api.WM_CHAR, Api.WM_CHAR, Api.PM_NOREMOVE)) print.it("peek", v);
					}
#endif
				});
				
				//If the active app is showing a menu, it captures the mouse.
				//	If this menu is there, a click goes to that app instead of this menu.
				//	Workaround: mouse hook. We cannot SetCapture in this background thread.
				if (_IsCapturingMouse()) {
					hMouse = WindowsHook.Mouse(h => {
						if (h.IsInjected) return;
						if (!_IsCapturingMouse()) {
							h.hook.Unhook();
							return;
						}
						//tested: mouse move and wheel works without this.
						if (h.IsButton && h.Button is MButton.Left or MButton.Right or MButton.Middle) {
							var p = mouse.xy;
							var w = wnd.fromXY(p, WXYFlags.Raw);
							if (!_IsMenuWindow(w)) return;
							h.BlockEvent();
							int m = h.Button switch { MButton.Left => Api.WM_LBUTTONDOWN, MButton.Right => Api.WM_RBUTTONDOWN, _ => Api.WM_MBUTTONDOWN };
							if (h.IsButtonUp) m++;
							w.MapScreenToClient(ref p);
							w.Post(m, 0, Math2.MakeLparam(p));
						}
					});
				}
				
				static bool _IsCapturingMouse() => miscInfo.getGUIThreadInfo(out var g) && !g.hwndCapture.Is0;
			}
			
			//var pmo = new PrintMsgOptions(Api.WM_TIMER, Api.WM_MOUSEMOVE, Api.WM_NCMOUSEMOVE, Api.WM_PAINT, 0x138a /*SC_WORK_IDLE*/, Api.WM_USER, int.MinValue) { WindowProperties = true };
			//print.it("in");
			_MessageLoop();
			//print.it("out");
			void _MessageLoop() {
				do {
					for (; ; ) {
						if (_w.Is0) return;
						if (!Api.PeekMessage(out var m, default, 0, 0, Api.PM_NOREMOVE)) break;
						if (m.message == Api.WM_QUIT) return; //let outer loop get the message (tested)
						bool handled = false;
						if (m.message is Api.WM_LBUTTONDOWN or Api.WM_RBUTTONDOWN or Api.WM_MBUTTONDOWN or Api.WM_NCLBUTTONDOWN or Api.WM_NCRBUTTONDOWN or Api.WM_NCMBUTTONDOWN) {
							_CloseIfClickedNotMenu(m.hwnd);
							if (_w.Is0) return; //let outer loop get the message
						} else if (m.message is Api.WM_KEYDOWN or Api.WM_SYSKEYDOWN) {
							handled = _WmKeydown(m);
							if (!handled && _w.Is0) return; //let outer loop get the message. Used for keys that close the menu but must be passed to the app, eg Alt. If Esc, handled is true.
						}
						if (!Api.PeekMessage(out m)) break;
						if (handled) continue;
						//WndUtil.PrintMsg(m, pmo);
						if (m.message == Api.WM_CHAR) {
							_TopMenu()._WmChar((char)m.wParam);
							continue;
						}
						Api.TranslateMessage(m);
						Api.DispatchMessage(m);
					}
				}
				while (Api.WaitMessage());
				//why this strange loop?
				//	If the click or keydown closed the menu and wants to pass the message to the app, before passing it need to exit the loop, else bad things may happen.
				//	Or could use GetMessage + PostMessage, but it is probably more dirty; need to repost all queued messages, to avoid eg lbuttondown after lbuttonup.
			}
		}
		finally {
			hKey?.Dispose();
			hMouse?.Dispose();
			timer?.Stop();
			if (!_w.Is0) Api.DestroyWindow(_w);
		}
		
		var b = _result;
		if (b != null) {
			b.InvokeAction_();
			R = b.Id;
		}
		
		return R;
	}
	
	/// <summary>
	/// Returns <c>true</c> if the menu window is open.
	/// </summary>
	public bool IsOpen => !_w.Is0;
	
	/// <summary>
	/// After closing the menu gets the selected item, or <c>null</c> if canceled.
	/// </summary>
	public PMItem Result => _result;
	
	void _OpenTrap(string error = null) {
		if (IsOpen) throw new InvalidOperationException(error);
	}
	
	void _ShowSubmenu(PMItem b, bool focusFirst = false, popupMenu m = null) {
		if (b == _sub.item) return;
		_sub.child?.Close();
		
		bool contextMenu = m != null;
		if (!contextMenu) {
			if (b.clicked == null) return;
			if (b.clicked is Action<popupMenu> menu) {
				m = b.sourceFile == null ? new() : new popupMenu(null, b.sourceFile, b.sourceLine);
				base._CopyProps(m);
				m.CheckDontClose = CheckDontClose;
				m.RawText = RawText;
				menu(m);
			} else if (b.clicked is Func<popupMenu> func) {
				m = func();
			}
			if (m == null || m._a.Count == 0) return;
		}
		
		_sub.child = m;
		_sub.item = b;
		m._sub.parent = this;
		if (focusFirst && m._iHot < 0) m._iHot = 0;
		
		if (contextMenu) {
			m._Show(0, null, null, _w);
		} else {
			var r = _ItemRect(b, inScreen: true);
			r.Inflate(-_size.border, _size.border);
			
			m._Show(_flags & ~(PMFlags)0xffffff, new(r.right, r.top), r, _w);
		}
	}
	
	void _Show(PMFlags flags, POINT? xy, RECT? excludeRect, wnd owner) {
		if (_a.Count == 0) return;
		
		_result = null;
		_flags = flags;
		
		RECT cr = default;
		bool byCaret = flags.Has(PMFlags.ByCaret);
		if (byCaret) {
			if (caretRectFunc is {  } crf) {
				var r1 = crf();
				if (r1 is null) byCaret = false; else cr = r1.Value;
			} else byCaret = miscInfo.getTextCursorRect(out cr, out _);
		}
		POINT p = byCaret ? new(cr.left, cr.bottom) : xy ?? mouse.xy;
		
		var scrn = screen.of(p);
		_dpi = scrn.Dpi;
		var rs = scrn.WorkArea;
		rs.Inflate(-8, -8);
		
		if (byCaret) {
			if (excludeRect == null) {
				cr.Inflate(50, 1);
				excludeRect = cr;
				flags |= PMFlags.AlignRectBottomTop;
			}
		} else {
			if (flags.Has(PMFlags.WindowCenter) && wnd.active is wnd wa && wa.GetRect(out var rw)) {
				p = new(rw.CenterX, rw.CenterY);
				flags |= PMFlags.AlignCenterH | PMFlags.AlignCenterV;
			} else if (flags.Has(PMFlags.ScreenCenter)) {
				p = new(rs.CenterX, rs.CenterY);
				flags |= PMFlags.AlignCenterH | PMFlags.AlignCenterV;
			} else if (excludeRect == null && !flags.HasAny(PMFlags.AlignCenterH | PMFlags.AlignCenterV)) {
				excludeRect = new(p.x, p.y, 1, 1);
			}
		}
		
		if (_addedNewItems) {
			_addedNewItems = false;
			_Images();
		}
		
		_scroll = new(true, i => _a[i].rect.top, i => _a[i].rect.bottom);
		
		WS style = WS.POPUP | WS.DLGFRAME; //3-pixel frame
		WSE estyle = WSE.TOOLWINDOW | WSE.NOACTIVATE | WSE.TOPMOST;
		SIZE z = _Measure(rs.Width * 19 / 20);
		
		bool needScroll = z.height > rs.Height;
		if (needScroll) {
			z.height = rs.Height;
			style |= WS.VSCROLL;
		}
		
		if (byCaret && !flags.HasAny(PMFlags.AlignRight | PMFlags.AlignCenterH))
			p.x = Math.Max(p.x - _met.image - _met.check - _met.paddingLeft - _met.textPaddingX - 3, rs.left);
		
		RECT r = new(0, 0, z.width, z.height);
		Dpi.AdjustWindowRectEx(_dpi, ref r, style, estyle);
		_size.window = r.Size; _size.client = z; _size.border = -r.top;
		Api.CalculatePopupWindowPosition(p, r.Size, (uint)flags & 0xffffff, excludeRect.GetValueOrDefault(), out r);
		
		if (r.bottom > rs.bottom && r.top > rs.top - 4) r.Move(r.left, r.top - 4); //let the bottom edge not touch the bottom edge of the screen
		
		_w = WndUtil.CreateWindow(_WndProc, true, "Au.popupMenu", null, style, estyle, r.left, r.top, r.Width, r.Height, owner);
		_SetScrollbar(needScroll);
		
		_w.ShowL(true);
		
		_mouse.p = _w.MouseClientXY;
	}
	
	/// <summary>
	/// Closes the menu and its submenus.
	/// </summary>
	/// <param name="ancestorsToo">If this is a submenu, close the root menu with all submenus.</param>
	/// <remarks>
	/// Can be called from any thread.
	/// Does nothing if not open.
	/// </remarks>
	public void Close(bool ancestorsToo = false) {
		if (!IsOpen) return;
		if (_IsOtherThread) {
			_w.Post(Api.WM_CLOSE, ancestorsToo ? 1 : 0);
		} else {
			var w = _w;
			if (ancestorsToo) {
				for (var pm = _sub.parent; pm != null; pm = pm._sub.parent) {
					w = pm._w;
					pm._result = _result;
				}
			}
			Api.DestroyWindow(w);
		}
	}
	
	private protected override void _WmNcdestroy() {
		//print.it("destroy", _name);
		_sub.timer?.Stop();
		var pa = _sub.parent;
		if (pa != null) {
			pa._sub.child = null;
			pa._sub.item = null;
		} else {
			_w.Post(0);
		}
		_met?.Dispose(); _met = null;
		_font?.Dispose(); _font = null;
		_fontBold?.Dispose(); _fontBold = null;
		_scroll = null;
		_sub = default;
		_size = default;
		_mouse = default;
		_iHot = -1;
		base._WmNcdestroy();
	}
	
	#endregion
	
	nint _WndProc(wnd w, int msg, nint wParam, nint lParam) {
		//var pmo = new PrintMsgOptions(Api.WM_NCHITTEST, Api.WM_SETCURSOR, Api.WM_MOUSEMOVE, Api.WM_NCMOUSEMOVE, 0x10c1);
		//if (WndUtil.PrintMsg(out string s, w, msg, wParam, lParam, pmo)) print.it("<><c green>" + s + "<>");
		//WndUtil.PrintMsg(w, msg, wParam, lParam);
		
		if (_scroll.WndProc(w, msg, wParam, lParam)) return default;
		
		switch (msg) {
		case Api.WM_NCCREATE:
			_WmNccreate(w);
			break;
		case Api.WM_NCDESTROY:
			_WmNcdestroy();
			break;
		case Api.WM_CLOSE:
			Close(ancestorsToo: 0 != (wParam & 1));
			return default;
		//case Api.WM_THEMECHANGED: //don't need for a menu window
		//	_z?.Dispose();
		//	_z = new _Metrics(this);
		//	Api.InvalidateRect(w);
		//	break;
		case Api.WM_ERASEBKGND:
			return default;
		case Api.WM_PAINT:
			using (var bp = new BufferedPaint(w, true)) _Render(bp.DC, bp.UpdateRect);
			return default;
		case Api.WM_MOUSEACTIVATE:
			return Api.MA_NOACTIVATE;
		case Api.WM_MOUSEMOVE:
			_WmMousemove(lParam, fake: false);
			return default;
		case Api.WM_MOUSELEAVE:
			_WmMouseleave();
			return default;
		case >= Api.WM_LBUTTONDOWN and <= Api.WM_MBUTTONUP:
			_WmMousebutton(msg, lParam);
			return default;
		case Api.WM_GETOBJECT:
			if (_WmGetobject(wParam, lParam, out var r1)) return r1;
			break;
		case Api.WM_USER + 50: //posted by acc dodefaultaction or PMKHook.ExecuteFocused
			if (IsOpen) {
				int i = (int)wParam;
				if ((uint)i < _a.Count) _Click(i);
			}
			return default;
		}
		
		var R = Api.DefWindowProc(w, msg, wParam, lParam);
		
		switch (msg) {
		case Api.WM_NCPAINT:
			_WmNcpaint();
			break;
		}
		
		return R;
	}
	
	void _SetScrollbar(bool needScroll) {
		if (needScroll) {
			_scroll.SetRange(_a.Count);
			
			_scroll.PosChanged += (sb, part) => {
				_sub.child?.Close();
				
				int pos = _scroll.Pos;
				Api.InvalidateRect(_w);
				
				if (part <= -2) { //if mouse wheel, update hot item, submenu, tooltip
					var p = _w.MouseClientXY;
					if (_w.ClientRect.Contains(p)) _WmMousemove(Math2.MakeLparam(p), fake: true);
				}
			};
			_scroll.Visible = true;
		} else {
			_scroll.NItems = _a.Count;
		}
	}
	
	int _HitTest(POINT p, bool failIfDisabled = false) {
		p.y += _scroll.Offset;
		for (int i = 0; i < _a.Count; i++) {
			if (_a[i].rect.Contains(p)) return (failIfDisabled && _a[i].IsDisabled) ? -1 : i;
		}
		return -1;
	}
	
	RECT _ItemRect(PMItem k, bool inScreen = false) {
		var r = k.rect;
		r.Offset(0, -_scroll.Offset);
		if (inScreen) _w.MapClientToScreen(ref r);
		return r;
	}
	
	void _WmMousemove(nint lParam, bool fake) {
		var p = Math2.NintToPOINT(lParam);
		
		//prevent selecting item when mouse position does not change. It would interfere with keyboard navigation.
		if (!fake && p == _mouse.p) return; _mouse.p = p;
		
		int i = _HitTest(p, failIfDisabled: true);
		if (i != _iHot) {
			_SetHotItem(i);
			if (i >= 0) {
				var b = _a[i];
				int submenuDelay = _SubmenuTimer(b.IsSubmenu ? b : null);
				_SetTooltip(b, _ItemRect(b), lParam, submenuDelay);
			} else {
				_HideTooltip();
				_SubmenuTimer();
			}
		}
		
		if (_iHot >= 0 != _mouse.track) _mouse.track = Api.TrackMouseLeave(_w, _iHot >= 0) && _iHot >= 0;
		
		_sub.parent?._SubmenuMouseMove();
	}
	
	int _SubmenuTimer(PMItem item = null) {
		if (item == null && _sub.child == null) return 0;
		
		_sub.timer ??= new(t => {
			if (t.Tag is PMItem mi) {
				if (FocusedItem == mi) _ShowSubmenu(mi);
			} else if (_sub.child != null && !_sub.child._w.Rect.Contains(mouse.xy)) {
				_sub.child.Close();
			}
		});
		int R = Api.SystemParametersInfo(Api.SPI_GETMENUSHOWDELAY, 400);
		_sub.timer.Tag = item;
		_sub.timer.After(R);
		return R;
	}
	
	void _SubmenuMouseMove() {
		if (FocusedItem != _sub.item) {
			_SetHotItem(_a.IndexOf(_sub.item));
			_sub.timer.Stop();
		}
	}
	
	void _WmMouseleave() {
		_mouse.track = false;
		if (_iHot < 0) return;
		if (_sub.child?._w.Rect.Contains(mouse.xy) ?? false) return;
		_SetHotItem(-1);
		_SubmenuTimer();
	}
	
	void _WmMousebutton(int msg, nint lParam) {
		switch (msg) {
		case Api.WM_LBUTTONDOWN: _mouse.left = true; return;
		case Api.WM_LBUTTONUP: if (!_mouse.left) return; _mouse.left = false; break;
		case Api.WM_RBUTTONDOWN: _mouse.right = true; return;
		case Api.WM_RBUTTONUP: if (!_mouse.right) return; _mouse.right = false; break;
		case Api.WM_MBUTTONDOWN: _mouse.middle = true; return;
		case Api.WM_MBUTTONUP: if (_mouse.middle) Close(ancestorsToo: true); return;
		default: return;
		}
		var p = Math2.NintToPOINT(lParam);
		int i = _HitTest(p);
		if (i < 0) return;
		if (msg == Api.WM_LBUTTONUP) _Click(i);
		else _ContextMenu(_a[i]);
	}
	
	void _Click(int i, bool keyboard = false) {
		var b = _a[i];
		if (b.IsDisabled) return;
		
		if (b.checkType > 0) {
			if (b.checkType == 1) {
				b.IsChecked ^= true;
			} else if (!b.IsChecked) {
				for (int j = i; --j >= 0 && _Uncheck(j);) { }
				for (int j = i; ++j < _a.Count && _Uncheck(j);) { }
				b.IsChecked = true;
				
				bool _Uncheck(int j) {
					var v = _a[j];
					if (v.checkType != 2) return false;
					v.IsChecked = false;
					return true;
				}
			}
			if (b.checkDontClose) {
				b.InvokeAction_();
				return;
			}
		}
		
		if (b.IsSubmenu) {
			if (keyboard) _SetHotItem(i, ensureVisible: true);
			_ShowSubmenu(b, focusFirst: keyboard);
		} else {
			_result = b;
			Close(ancestorsToo: true);
		}
	}
	
	/// <summary>
	/// Don't close menu when clicked a checkbox or radio item.
	/// This property is applied to items added afterwards; submenus inherit it.
	/// </summary>
	public bool CheckDontClose { get; set; }
	
	void _ContextMenu(PMItem b) {
		if (b.IsSeparator) return;
		var (canEdit, canGo, goText) = MTItem.CanEditOrGoToFile_(b.sourceFile, b);
		if (canEdit || canGo) {
			var m = new popupMenu();
			if (canEdit) m["Edit menu item"] = _ => ScriptEditor.Open(b.sourceFile, b.sourceLine);
			if (canGo) m[goText] = _ => b.GoToFile_();
			_ShowSubmenu(b, m: m);
		}
	}
	
	popupMenu _TopMenu() {
		var m = this; while (m._sub.child != null) m = m._sub.child;
		return m;
	}
	
	bool _TopHot(out (popupMenu m, int i, PMItem b) r) {
		var m = this; while (m._sub.child != null) m = m._sub.child;
		int i = m._iHot;
		r = (m, i, i < 0 ? null : m._a[i]);
		return i >= 0;
	}
	
	/// <summary>
	/// Gets or sets the focused menu item.
	/// </summary>
	/// <remarks>
	/// The focused item visually shows the menu item that would be executed if clicked or pressed <c>Enter</c>, <c>Tab</c> or <c>Space</c> key. It changes when the user moves the mouse or presses navigation keys (arrows, <c>End</c>, <c>Home</c>, <c>PageDown</c>, <c>PageUp</c>).
	/// This property can be set before showing the menu or when it is open.
	/// </remarks>
	public PMItem FocusedItem {
		get => _iHot >= 0 ? _a[_iHot] : null;
		set {
			_ThreadTrap();
			int i = -1;
			if (value != null) {
				i = _a.IndexOf(value);
				if (i < 0) throw new ArgumentException();
			}
			if (_w.Is0) {
				_iHot = i;
			} else {
				_SetHotItem(i, ensureVisible: true);
			}
		}
	}
	
	void _SetHotItem(int i, bool ensureVisible = false) {
		if (i != _iHot) {
			if (_iHot >= 0) _Invalidate(_iHot);
			if ((_iHot = i) >= 0) _Invalidate(_iHot);
		}
		if (ensureVisible && i >= 0) {
			int pos = _scroll.Pos, y = _scroll.Offset, hei = _size.client.height;
			var r = _a[i].rect;
			if (r.top < y) {
				while (pos > 0 && r.top < y) y -= _a[--pos].rect.Height;
			} else if (r.bottom > y + hei) {
				while (pos < _scroll.Max && r.bottom > y + hei) y += _a[++pos].rect.Height;
			} else return;
			_scroll.Pos = pos;
		}
	}
	
	bool _WmKeydown(in MSG msg) { //called for root menu
		KKey k = (KKey)(int)msg.wParam;
		if (_IsCancelKey(k)) {
			Close();
			return false;
		} else if (_IsOkKey(k)) {
			if (_TopHot(out var v)) v.m._Click(v.i, keyboard: true);
		} else if (k == KKey.Escape) {
			_TopMenu().Close();
		} else if (k == KKey.Left) {
			var m = _TopMenu();
			if (m != this) m.Close();
		} else if (k == KKey.Right) {
			if (_TopHot(out var v) && v.b.IsSubmenu && !v.b.IsDisabled) v.m._ShowSubmenu(v.b, focusFirst: true);
		} else if (k is KKey.Down or KKey.Up or KKey.PageDown or KKey.PageUp or KKey.End or KKey.Home) {
			_TopMenu()._KeyNavigate(k);
		} else if (_IsPassKey(k)) {
			return false;
		} else { //eg a char key. Translate to get wm_char (we'll eat it), but eat this wm_keydown.
			Api.TranslateMessage(msg);
		}
		return true;
	}
	
	void _KeyNavigate(KKey k) { //called for top menu
		int i = _scroll.KeyNavigate(_iHot, k); if (i == _iHot) return;
		while ((uint)i < _a.Count && _a[i].IsSeparator) i += k is KKey.Home or KKey.Down or KKey.PageDown ? 1 : -1;
		_SetHotItem(Math.Clamp(i, 0, _a.Count - 1), ensureVisible: true);
	}
	
	void _WmChar(char c) { //called for top menu
		if (c <= ' ') return;
		char cl = char.ToLowerInvariant(c), cu = char.ToUpperInvariant(c);
		int iUnderlined = -1; List<int> aUnderlined = null;
		for (int i = 0; i < _a.Count; i++) {
			var v = _a[i];
			if (v.rawText || v.IsDisabled) continue;
			string s = v.Text;
			int j = StringUtil.FindUnderlineChar(s);
			if (j >= 0 && (s[j] == cu || s[j] == cl)) {
				if (iUnderlined < 0) iUnderlined = i;
				else (aUnderlined ??= new() { iUnderlined }).Add(i);
			}
		}
		if (aUnderlined != null) {
			int fi = 0;
			if (_iHot >= 0) {
				for (int i = 0; i < aUnderlined.Count; i++) if (aUnderlined[i] > _iHot) { fi = i; break; }
			}
			FocusedItem = _a[aUnderlined[fi]];
		} else if (iUnderlined >= 0) {
			_Click(iUnderlined, keyboard: true);
		}
	}
	
	static bool _IsOkKey(KKey k) => k is KKey.Enter or KKey.Tab or KKey.Space;
	static bool _IsCancelKey(KKey k) => k is KKey.Alt or KKey.Win or KKey.RWin or KKey.F10 or KKey.Apps or KKey.Back;
	static bool _IsPassKey(KKey k)
		=> k is KKey.Ctrl or KKey.Shift or KKey.CapsLock or KKey.NumLock or KKey.ScrollLock
		or KKey.PrintScreen or KKey.Pause or KKey.Insert
		or (>= KKey.F1 and <= KKey.F24) || keys.isMod(KMod.Ctrl | KMod.Alt | KMod.Win);
	
	/// <summary>
	/// Creates and shows a simple popup menu. Without images, actions, submenus. Returns item id or 0.
	/// </summary>
	/// <returns>id of the selected item when closed, or 0 if canceled.</returns>
	/// <param name="items">
	/// Menu items, like <c>"One|Two|Three"</c> or <c>new("One", "Two", "Three")</c> or string array or <c>List</c>.
	/// Item id can be optionally specified like <c>"1 One|2 Two|3 Three"</c>, unless <i>rawText</i> <c>true</c>. If missing, uses id of previous non-separator item + 1. Example: <c>"One|Two|100 Three Four"</c> (1|2|100|101).
	/// For separators use <c>null</c> or empty strings: <c>"One|Two||Three|Four"</c>.
	/// </param>
	/// <param name="flags"></param>
	/// <param name="xy">Menu position in screen. If <c>null</c> (default), uses mouse position by default. It depends on <i>flags</i>.</param>
	/// <param name="excludeRect">The menu should not overlap this rectangle in screen.</param>
	/// <param name="owner">Owner window. The menu will be automatically closed when destroying its owner window.</param>
	/// <param name="rawText">Don't parse id from text.</param>
	/// <remarks>
	/// Adds menu items and calls <see cref="Show"/>. Returns when the menu closes. All parameters except <i>items</i> are the same as in <see cref="Show"/>.
	/// </remarks>
	/// <seealso cref="dialog.showList"/>
	public static int showSimple(Strings items, PMFlags flags = 0, POINT? xy = null, RECT? excludeRect = null, AnyWnd owner = default, bool rawText = false) {
		var a = items.ToArray();
		var m = new popupMenu();
		foreach (var v in a) {
			var s = v;
			if (s.NE()) {
				m.Separator();
			} else {
				if (!rawText && s.ToInt(out int id, 0, out int end)) {
					if (s.Eq(end, ' ')) end++;
					s = s[end..];
					m.Add(id, s);
				} else {
					m.Add(s);
				}
			}
		}
		return m.Show(flags, xy, excludeRect, owner);
	}
	
	/// <summary>
	/// Gets or sets callback function that decides how to respond to pressed keys (default, close, ignore, block).
	/// </summary>
	/// <remarks>
	/// The function is called on each key down event while the menu is open. Only if current thread is not in the foreground.
	/// To block a key, call <see cref="HookData.Keyboard.BlockEvent"/>.
	/// The function must be as fast as possible.
	/// </remarks>
	public Func<popupMenu, HookData.Keyboard, PMKHook> KeyboardHook { get; set; }
	
	/// <summary>
	/// Sets a user-defined "get caret rectangle" function.
	/// </summary>
	/// <value>Default: null; calls <see cref="miscInfo.getTextCursorRect"/>.</value>
	/// <remarks>
	/// The callback function is called by <see cref="Show"/> when <i>flags</i> includes <see cref="PMFlags.ByCaret"/>. Also used by <see cref="Au.Triggers.AutotextTriggerArgs.Menu"/>.
	/// Let it return a rectangle in screen, or null if failed. For example, it can call <see cref="miscInfo.getTextCursorRect"/>; if it fails, use an alternative way to get caret rectangle or preferred menu location.
	/// </remarks>
	public static Func<RECT?> caretRectFunc { get; set; }
}


================================================
FILE: Au/GUI/toolbar/tb acc.cs
================================================
using IAccessible = Au.Types.Api.IAccessible;
using VarInt = Au.Types.Api.VarInt;
using NAVDIR = Au.Types.Api.NAVDIR;

namespace Au;

[ComVisible(true)]
partial class toolbar : IAccessible {
	IAccessible IAccessible.get_accParent() => _StdAO.get_accParent();

	int IAccessible.get_accChildCount() => _a.Count;

	int IAccessible.get_accChild(VarInt varChild, out object ppdispChild) { ppdispChild = null; return 1; }

	string IAccessible.get_accName(VarInt varChild) => _B(varChild, out var b) ? (b.Text ?? b.Tooltip) : _name;

	string IAccessible.get_accValue(VarInt varChild) => null;

	string IAccessible.get_accDescription(VarInt varChild) => _B(varChild, out _) ? null : "Floating toolbar";

	VarInt IAccessible.get_accRole(VarInt varChild) {
		Debug_.PrintIf(Api.GetCurrentThreadId() != _w.ThreadId, "thread");
		var r = !_B(varChild, out var b)
			? ERole.TOOLBAR
			: b.ItemType switch {
				TBItemType.Separator => ERole.SEPARATOR,
				TBItemType.Group => ERole.GROUPING,
				TBItemType.Menu => ERole.BUTTONMENU,
				_ => ERole.BUTTON
			};
		return (int)r - 1;
	}

	VarInt IAccessible.get_accState(VarInt varChild) {
		EState r = 0;
		if (!_w.IsEnabled()) r |= EState.DISABLED;
		if (!_B(varChild, out var b)) {
			if (!_w.IsVisible) r |= EState.INVISIBLE;
		} else {
			if (b.IsSeparatorOrGroup_) r |= EState.DISABLED;
			if (b.IsMenu_) r |= EState.HASPOPUP;
			//TODO3: if offscreen, r |= EState.INVISIBLE | EState.OFFSCREEN;
			//no: EState.HOTTRACKED;
		}
		return (int)r - 1;
	}

	string IAccessible.get_accHelp(VarInt varChild) => _B(varChild, out var b) ? _GetFullTooltip(b) : null;

	int IAccessible.get_accHelpTopic(out string pszHelpFile, VarInt varChild) => throw new NotImplementedException();

	string IAccessible.get_accKeyboardShortcut(VarInt varChild) => null;

	object IAccessible.get_accFocus() => null;

	object IAccessible.get_accSelection() => null;

	string IAccessible.get_accDefaultAction(VarInt varChild)
		=> !_B(varChild, out var b) || b.IsSeparatorOrGroup_ ? null : b.IsMenu_ ? "Open" : "Execute";

	void IAccessible.accSelect(ESelect flagsSelect, VarInt varChild) => throw new NotImplementedException();

	void IAccessible.accLocation(out int pxLeft, out int pyTop, out int pcxWidth, out int pcyHeight, VarInt varChild) {
		if (!_B(varChild, out var b)) {
			_StdAO.accLocation(out pxLeft, out pyTop, out pcxWidth, out pcyHeight, varChild);
		} else {
			var r = b.rect; _w.MapClientToScreen(ref r);
			pxLeft = r.left; pyTop = r.top; pcxWidth = r.Width; pcyHeight = r.Height;
		}
	}

	object IAccessible.accNavigate(NAVDIR navDir, VarInt varStart) {
		int i = varStart;
		var a = _a;
		if (navDir == NAVDIR.FIRSTCHILD || navDir == NAVDIR.LASTCHILD) {
			if (i == -1) return navDir == NAVDIR.FIRSTCHILD ? 1 : a.Count;
		} else {
			if (i == -1) return _StdAO.accNavigate(navDir, varStart);
			switch (navDir) {
			case NAVDIR.PREVIOUS:
				if (i > 0) return i;
				break;
			case NAVDIR.NEXT:
				if (++i < a.Count) return i + 1;
				break;
			}
		}
		return null;
	}

	VarInt IAccessible.accHitTest(int xLeft, int yTop) {
		POINT p = new(xLeft, yTop); _w.MapScreenToClient(ref p);
		if (!_w.ClientRect.Contains(p)) return _StdAO.accHitTest(xLeft, yTop);
		return _HitTest(p);
	}

	void IAccessible.accDoDefaultAction(VarInt varChild) {
		if (!_B(varChild, out var b) || b.IsSeparatorOrGroup_) return;
		_w.Post(Api.WM_USER + 50, (int)varChild);
	}

	void IAccessible.put_accName(VarInt varChild, string szName) { }

	void IAccessible.put_accValue(VarInt varChild, string szValue) { }

	bool _B(VarInt varChild, out TBItem b) {
		int i = varChild;
		if (i == -1) { b = null; return false; }
		b = _a[i]; return true;
	}
}

================================================
FILE: Au/GUI/toolbar/tb dialog.cs
================================================
//TODO2: sometimes the first time shows the window with several s delay. Can't repro, even after reboot. Possibly more likely after hibernation. The slow code is `new Form();` (even without setting properties).

using System.Windows.Forms;

namespace Au;

public partial class toolbar {
	[ThreadStatic] static Form s_listWindow;
	
	/// <summary>
	/// Creates a window with a list of toolbars of this thread. Can be used to find lost toolbars.
	/// </summary>
	/// <param name="show">Show the window now, non-modal. If a window shown by this function already exists in this thread - activate it.</param>
	public static Form toolbarsDialog(bool show = true) {
		if (show && s_listWindow != null) {
			s_listWindow.Hwnd().ActivateL(true);
			return s_listWindow;
		}
		
		var f = new Form {
			Text = "Active toolbars",
			Size = new(330, 330),
			AutoScaleMode = AutoScaleMode.Dpi,
			StartPosition = FormStartPosition.CenterScreen,
			Icon = icon.ofThisApp()?.ToGdipIcon()
		};
		f.Load += (_, _) => { f.Hwnd().ActivateL(); };
		
		var lv = new ListView {
			Dock = DockStyle.Fill,
			View = View.List,
			BorderStyle = BorderStyle.None,
			MultiSelect = false,
			ContextMenuStrip = new()
		};
		f.Controls.Add(lv);
		
		var osdr = new osdRect { Color = 0xff0000, Thickness = 12 };
		osdText osdt = null;
		ListViewItem _osdItem = null;
		
		var atb = _Manager._atb;
		(toolbar tb, bool sat)[] patb = atb.Select(o => (o, o.Satellite?.IsOpen ?? false)).ToArray();
		var timer1 = timer.every(250, _ => {
			bool changed = atb.Count != patb.Length;
			if (!changed) {
				for (int i = 0; i < atb.Count; i++) {
					if (atb[i] != patb[i].tb || (atb[i].Satellite?.IsOpen ?? false) != patb[i].sat) { changed = true; break; }
				}
			}
			if (changed) {
				_HideRect();
				patb = atb.Select(o => (o, o.Satellite?.IsOpen ?? false)).ToArray();
				_FillList();
			}
		});
		
		f.FormClosed += (_, _) => {
			if (show) s_listWindow = null;
			osdr.Dispose();
			timer1.Stop();
		};
		
		_FillList();
		
		void _FillList() {
			lv.Items.Clear();
			foreach (var tb in _Manager._atb) {
				_Add(tb);
				if (tb.Satellite is { } sat && sat.IsOpen) _Add(sat);
			}
			void _Add(toolbar tb) {
				lv.Items.Add(tb.ToString()).Tag = tb;
			}
		}
		
		lv.MouseMove += (_, _) => { //note: MouseHover not always works
			var p = mouse.xy;
			lv.Hwnd().MapScreenToClient(ref p);
			var v = lv.HitTest(p).Item;
			if (v == _osdItem) return;
			if (v != null) {
				var tb = v.Tag as toolbar;
				if (tb.IsOpen) {
					var w = tb._w;
					var r = w.Rect;
					if (screen.isInAnyScreen(r)) {
						r.Inflate(10, 10);
						osdr.Rect = r;
						osdr.Show();
					} else {
						osdt = osdText.showText($"The toolbar is offscreen. Right-click to move.\nRectangle: {r}", xy: PopupXY.Mouse);
					}
					v.Selected = true;
					v.Focused = true;
					_osdItem = v;
				} else {
					_HideRect();
					_FillList();
				}
			} else {
				_HideRect();
			}
		};
		lv.MouseLeave += (_, _) => _HideRect();
		
		void _HideRect() {
			if (_osdItem != null) {
				_osdItem = null;
				osdr.Hide();
				osdt?.Dispose(); osdt = null;
			}
		}
		
		lv.ItemActivate += (_, _) => {
			_Edit(lv.FocusedItem.Tag as toolbar);
		};
		
		void _Edit(toolbar tb) {
			ScriptEditor.Open(tb._sourceFile, tb._sourceLine);
			timer.after(100, _ => f.Hwnd().ZorderTop());
		}
		
		lv.ContextMenuStrip.Opening += (_, e) => {
			e.Cancel = true;
			if (lv.SelectedItems.Count == 0) return;
			_HideRect();
			var tb = lv.FocusedItem.Tag as toolbar;
			var w = f.Hwnd();
			var m = new popupMenu();
			m["Edit\tD-click"] = o => _Edit(tb);
			m["Move here"] = o => {
				if (!tb.IsOpen) return;
				var w = tb._w;
				if (!w.IsVisible && !dialog.showOkCancel("Hidden", "Move this hidden toolbar?", owner: w)) return;
				w.MoveL_(mouse.xy);
				if (!w.ZorderIsAbove(w)) w.ZorderAbove(w);
			};
			m.Show(owner: w);
		};
		
		if (show) f.Show();
		return s_listWindow = f;
	}
}


================================================
FILE: Au/GUI/toolbar/tb man.cs
================================================
namespace Au;

public partial class toolbar {
	class _OwnerWindow {
		public readonly List<toolbar> a = [];
		public readonly wnd w;
		public bool visible;
		bool _updatedOnce;
		RECT _rect, _clientRect;
		SIZE _prevSize, _prevClientSize;
		//public readonly int thread;
		
		public _OwnerWindow(wnd w) {
			this.w = w;
			//thread = w.ThreadId;
		}
		
		public void AddTB(toolbar tb) {
			a.Add(tb);
			tb._ow = this;
		}
		
		public (bool visible, bool dead) IsVisible() {
			lastError.clear();
			if (!w.IsVisible) return (false, lastError.code != 0);
			return (!w.IsMinimized && !w.IsCloaked, false);
			//speed: IsCloaked now on Win10 quite fast, faster than GetRect
		}
		
		public bool UpdateRect(out bool changed) {
			changed = false;
			
			//if a toolbar has MaximizedWindowTopPlus, calculate how many physical pixels to add to the top of the window rect or client rect
			int? mtpw = null, mtpc = null;
			foreach (var tb in a) {
				if (tb._oc != null || tb._os != null) continue;
				if (tb.MaximizedWindowTopPlus != 0 && w.IsMaximized) {
					ref int? mtp = ref tb._followClientArea ? ref mtpc : ref mtpw;
					if (mtp != null) print.warning("When multiple toolbars attached to the same window, set MaximizedWindowTopPlus once (for any toolbar), not for all toolbars.");
					else mtp = tb._Scale(tb.MaximizedWindowTopPlus, true);
				}
			}
			
			int have = 0;
			foreach (var tb in a) {
				if (tb._oc != null || tb._os != null) continue;
				if (tb._followClientArea) {
					if (0 != (have & 2)) continue;
					if (!w.GetClientRect(out var r, inScreen: true)) return false;
					r.top += mtpc.GetValueOrDefault();
					if (r != _clientRect) {
						_prevClientSize = (_clientRect.Width, _clientRect.Height);
						_clientRect = r;
						changed = true;
					}
					have |= 2;
				} else {
					if (0 != (have & 1)) continue;
					if (!w.GetRect(out var r)) return false;
					r.top += mtpw.GetValueOrDefault();
					if (r != _rect) {
						_prevSize = (_rect.Width, _rect.Height);
						_rect = r;
						changed = true;
					}
					have |= 1;
				}
				if (have == 3) break;
			}
			if (!_updatedOnce) _updatedOnce = changed = true;
			return true;
		}
		
		public (RECT r, SIZE size) GetCachedRectAndPrevSize(toolbar tb)
			=> (tb._followClientArea ? _clientRect : _rect, tb._followClientArea ? _prevClientSize : _prevSize);
	}
	
	class _OwnerControl {
		public readonly wnd c;
		public readonly ITBOwnerObject oo;
		public RECT cachedRect;
		public SIZE prevSize;
		bool _updatedOnce;
		
		public _OwnerControl(wnd control, ITBOwnerObject ioo) {
			c = control;
			oo = ioo;
		}
		
		public (bool visible, bool dead) IsVisible(bool parentVisible = true) {
			if (!c.Is0) {
				lastError.clear();
				if (!c.IsVisible) return (false, lastError.code != 0);
				if (!parentVisible || c.IsMinimized) return default; //never mind: ancestors controls may be minimized
			}
			if (oo != null) {
				if (!oo.IsAlive) return (false, true);
				if (!oo.IsVisible) return default;
			}
			return (true, false);
		}
		
		public bool UpdateRect(out bool changed) {
			bool ok = oo != null ? oo.GetRect(out RECT r) : c.GetRect(out r);
			if (changed = ok && r != cachedRect) {
				prevSize = (cachedRect.Width, cachedRect.Height);
				cachedRect = r;
			}
			if (!_updatedOnce) _updatedOnce = changed = true;
			return ok;
		}
	}
	
	class _OwnerScreen {
		public _OwnerScreen(toolbar tb, screen scrn) {
			_tb = tb;
			_scrn = (_isAuto = scrn.IsEmpty) ? screen.of(_tb._sett.screenx, _tb._sett.screeny) : scrn.Now;
			UpdateRect(out _);
		}
		
		toolbar _tb;
		screen _scrn;
		bool _isAuto;
		public RECT cachedRect;
		public SIZE prevSize;
		
#if DEBUG
		public screen Screen {
			get {
				Debug_.PrintIf(!_scrn.IsAlive, "screen not alive");
				return _scrn;
			}
		}
#else
		public screen Screen => _scrn;
#endif
		
		//public bool IsAuto => _isAuto;
		
		public bool UpdateRect(out bool changed) {
			RECT r = _scrn.Rect;
			if (changed = r != cachedRect && !r.Is0) {
				prevSize = (cachedRect.Width, cachedRect.Height);
				cachedRect = r;
			}
			return true;
		}
		
		//called from _WmWindowPosChanged
		public void UpdateIfAutoScreen() {
			if (!_isAuto) return;
			var r = screen.of(_tb._w).Rect;
			int x = 0, y = 0; if (r.left != 0 || r.top != 0) { x = r.CenterX; y = r.CenterY; }
			if (x != _tb._sett.screenx || y != _tb._sett.screeny) {
				_scrn = screen.of(_tb._sett.screenx = x, _tb._sett.screeny = y);
				UpdateRect(out _);
			}
		}
		
		//Called on WM_DISPLAYCHANGE. If screen detached, sets _scrn = 0. When reattached, sets _scrn = new screen handle.
		public bool IsScreenInvalid() {
			if (!_scrn.IsAlive) {
				//Debug_.Print($"CloseIfScreenInvalid, {_tb.Name}, {screen.of(_tb._w, SODefault.Zero)}");
				
				_scrn = screen.of(new POINT(cachedRect.CenterX, cachedRect.CenterY), SODefault.Zero);
				return _scrn.Handle == default;
			}
			return false;
		}
	}
	
	_OwnerWindow _ow; //not null if owned
	_OwnerControl _oc; //not null if owned by a control or other object (ITBOwnerObject)
	_OwnerScreen _os; //not null if not owned or if anchor has flag Screen
	bool _followClientArea;
	
	[ThreadStatic] static _TBManager t_man;
	static _TBManager _Manager => t_man ??= new();
	
	class _TBManager {
		internal readonly List<toolbar> _atb = [];
		readonly List<_OwnerWindow> _aow = [];
		timer _timer;
		int _timerPeriod;
		WinEventHook _hook;
		int _tempHook;
		bool _inHook;
		
		public void Add(toolbar tb, wnd w, wnd c, ITBOwnerObject ioo) {
			bool isOwned = !w.Is0;
			if (isOwned) {
				if (!_FindOW(w, out var ow)) _aow.Add(ow = new _OwnerWindow(w));
				ow.AddTB(tb);
				if (!c.Is0 || ioo != null) tb._oc = new _OwnerControl(c, ioo);
			}
			
			_atb.Add(tb);
			
			if (_hook == null) {
				_hook = new WinEventHook([
					0, EEvent.OBJECT_REORDER,
					EEvent.OBJECT_CLOAKED, EEvent.OBJECT_UNCLOAKED,
					EEvent.SYSTEM_MOVESIZESTART, EEvent.SYSTEM_MOVESIZEEND,
					EEvent.SYSTEM_MINIMIZESTART, EEvent.SYSTEM_MINIMIZEEND,
					],
					_Hook,
					flags: EHookFlags.SKIPOWNTHREAD);
				_timer = new timer(_Timer);
			}
			
			tb._hide = TBHide.Owner;
			if (isOwned) {
				_SetTimer(250);
			} else {
				if (!_timer.IsRunning) _SetTimer(250);
				tb._FollowRect();
				//tb._Zorder();
				tb._SetVisible(true, TBHide.Owner);
			}
		}
		
		public void Remove(toolbar tb) {
			_atb.Remove(tb);
			var ow = tb._ow;
			if (ow != null) {
				ow.a.Remove(tb);
				if (ow.a.Count == 0) _aow.Remove(ow);
			}
		}
		
		void _SetTimer(int period) {
			_timer.Every(_timerPeriod = period);
		}
		
		void _Timer(timer t) {
			if (_timerPeriod != 250) _SetTimer(250);
			
			//remove closed toolbars and their owners if need. Now don't need because toolbars call Remove when closing.
			//for(int i = _atb.Count; --i >= 0;) {
			//	var tb = _atb[i];
			//	if(tb._closed) Remove(tb);
			//}
			
			//move/close/hide/show owned toolbars together with their owners
			for (int i = _aow.Count; --i >= 0;) {
				var ow = _aow[i];
				if (!_FollowOwner(ow)) {
					for (int j = ow.a.Count; --j >= 0;) {
						var tb = ow.a[j];
						tb.Close();
						bool rem1 = _atb.Remove(tb); Debug_.PrintIf(rem1, "");
					}
					bool rem2 = _aow.Remove(ow); Debug_.PrintIf(rem2, "");
					//actually don't need these two Remove, because tb.Close calls Remove. Just don't use RemoveAt and foreach.
				}
			}
			
			//occasionally may fail to zorder a toolbar. Retry several times.
			for (int i = _atb.Count; --i >= 0;) {
				var v = _atb[i];
				if (v._zorderRetry > 0) v._ZorderOwned();
			}
			
			_ZorderTimer();
			
			_ManageFullScreen();
		}
		
		//long _reorderTime;
		void _Hook(HookData.WinEvent d) {
			//print.it(d.event_, d.idObject, d.idChild, d.thread, d.w);
			if (d.w.Is0 || d.idObject != (d.event_ == EEvent.OBJECT_REORDER ? EObjid.CLIENT : EObjid.WINDOW) || d.idChild != 0) return;
			switch (d.event_) {
			case EEvent.OBJECT_REORDER when d.w == wnd.getwnd.root: //the hook does not give the window, only its thread id
				_Zorder();
				break;
			case EEvent.SYSTEM_MOVESIZESTART when _tempHook == 0:
				if (_FindOW(d.w, out _)) _tempHook = _hook.Add(EEvent.OBJECT_LOCATIONCHANGE, flags: EHookFlags.SKIPOWNTHREAD);
				break;
			case EEvent.SYSTEM_MOVESIZEEND when _tempHook != 0:
				_hook.Remove(_tempHook);
				_tempHook = 0;
				break;
			case EEvent.OBJECT_LOCATIONCHANGE:
			case EEvent.OBJECT_CLOAKED:
			case EEvent.OBJECT_UNCLOAKED:
			case EEvent.SYSTEM_MINIMIZESTART:
				//Debug_.PrintIf(_inHook, "_inHook"); //it's ok
				if (!_inHook && _FindOW(d.w, out _OwnerWindow ow)) {
					//prevent reenter.
					//	The ITBOwnerObject may retrieve sent messages, eg when getting acc rect.
					//	It's ok if hook missed. We'll call it on timer or next OBJECT_LOCATIONCHANGE.
					_inHook = true;
					try { _FollowOwner(ow); }
					finally { _inHook = false; }
				}
				break;
			case EEvent.SYSTEM_MINIMIZEEND:
				if (_FindOW(d.w, out _)) _SetTimer(150);
				break;
			}
			
			//SYSTEM_MOVESIZESTART and SYSTEM_MOVESIZEEND temporarily add/remove OBJECT_LOCATIONCHANGE to move toolbars with the owner window.
			//	Cannot make OBJECT_LOCATIONCHANGE always active, because it is called frequently, on each cursor position change etc.
			//	There are no other not-in-process hooks to detect moved windows. For CBT hook need 2 processes - 64bit and 32bit.
			
			//OBJECT_REORDER keeps toolbars above their owner windows in the Z order.
			//	Easier would be to make the owner natively owner. But then problems:
			//	1. If this process is admin, the owner's process cannot receive drag&drop from other non-admin processes. Don't know why, probably it is a Windows bug.
			//	2. Fails if owner's process is a Store app. Also probaby if higher UAC IL.
			//	3. In some cases possible various anomalies, for example wrong Z order of windows after closing the owner window.
			//	4. All unknown and future things like those.
			//	In QM some of these problems were solved by adding a child window to the owner window and making it the native owner of the toolbar. But then other problems, eg DPI-scaling.
			
			//PROBLEM: OBJECT_REORDER makes creating windows slower.
			//	For example, combobox controls send OBJECT_REORDER when adding items. Two for each item that would be visible in the drop-down list.
			//	Tested: standard dialog box with 12 comboboxes, each with 30 such items. We receive ~720 OBJECT_REORDER.
			//		If there are 4 processes with 1 OBJECT_REORDER hook, dialog startup time increases 50%, from 360 to 540 ms.
			//Other used hooks aren't called frequently. Except OBJECT_LOCATIONCHANGE, but it is temporary.
		}
		
		bool _FindOW(wnd owner, out _OwnerWindow ow) {
			foreach (var v in _aow) if (v.w == owner) { ow = v; return true; }
			ow = null; return false;
		}
		
		bool _FollowOwner(_OwnerWindow ow) {
			var (visibleW, dead) = ow.IsVisible();
			if (dead) return false;
			
			bool changedRectW = false;
			if (visibleW) visibleW = ow.UpdateRect(out changedRectW);
			ow.visible = visibleW;
			
			for (int i = ow.a.Count; --i >= 0;) {
				bool visible, changedRect;
				var tb = ow.a[i];
				var oc = tb._oc;
				if (oc == null) {
					visible = visibleW;
					changedRect = changedRectW;
				} else {
					(visible, dead) = oc.IsVisible(visibleW);
					if (dead) {
						tb.Close();
						ow.a.RemoveAt(i);
						continue;
					}
					if (visible) visible = oc.UpdateRect(out changedRect); else changedRect = false;
				}
				bool changedVisible = visible == tb._hide.Has(TBHide.Owner);
				if (visible && (changedRect || changedVisible)) { // || changedVisible is for new toolbars, but it's ok to call for old too
					tb._FollowRect(true);
				}
				if (changedVisible) {
					tb._SetVisible(visible, TBHide.Owner);
					if (visible) tb._ZorderOwned();
				}
			}
			
			return true;
		}
		
		void _ManageFullScreen(toolbar tb = null) {
			if (tb?.MiscFlags.Has(TBFlags.HideWhenFullScreen) ?? _atb.Any(o => o.MiscFlags.Has(TBFlags.HideWhenFullScreen))) {
				var w = wnd.active;
				bool isFS = w.IsFullScreen_(out var scrn);
				if (tb != null) tb._ManageFullScreen(isFS, w, scrn);
				else foreach (var v in _atb) if (v.MiscFlags.Has(TBFlags.HideWhenFullScreen)) v._ManageFullScreen(isFS, w, scrn);
			}
		}
		
		//EEvent.OBJECT_REORDER
		void _Zorder() {
			for (int i = _atb.Count; --i >= 0;) {
				var tb = _atb[i];
				if (tb.IsOwned) tb._ZorderOwned();
				else if (_zorderDelay < 1) _zorderDelay = 2;
			}
#if false
			//This version of zordering owned toolbars is faster but unreliable.
			//	1. For console windows getwindowthreadprocessid gives wrong thread id. Hook receives the correct id.
			//	2. When clicked client area of a Store app, hook receives thread id of the child control. It is different than that of the main host window.
			//	3. All unknown and future things like those.
			foreach(var v in _aow) {
				if(v.thread != d.idThread) continue;
				foreach(var tb in v.a) tb._ZorderOwned();
			}
#endif
		}
		int _zorderDelay;
		
		void _ZorderTimer() {
			//250-500 ms after EEvent.OBJECT_REORDER
			if (_zorderDelay < 1 || --_zorderDelay > 0) return;
			
			//Ensure the toolbar is on top of the primary taskbar. Or ontop of the active window if the primary taskbar is behind it.
			//	Not on top of all topmost windows. Would cover tooltips etc, fight with sibling toolbars, etc.
			var taskbar = s_taskbar.FindFast(null, "Shell_TrayWnd", false); //of the primary screen
			var active = wnd.active;
			var w = !active.Is0 && active != taskbar && (taskbar.Is0 || !taskbar.ZorderIsAbove(active) && !active.IsOfThisProcess) ? active : taskbar;
			if (w.Is0) return;
			for (int i = _atb.Count; --i >= 0;) {
				var v = _atb[i];
				if (v.IsOwned) continue;
				var tb = v.Hwnd;
				if (!tb.ZorderIsAbove(w) && w.IsVisible) {
					if (w.IsTopmost) {
						tb.ZorderL_(w, before: true);
					} else if (!tb.IsTopmost) {
						tb.ZorderL_(SpecHWND.TOPMOST);
					} else {
						//Windows 11 bug: sometimes, when activated a non-topmost window, it becomes on top of topmost windows, eg of taskbars and unowned toolbars.
						//	Afterwards activating other normal windows makes them on top of topmost windows too.
						//	Impossible to reproduce, it happens randomly, once in several days or weeks.
						Debug_.Print($"toolbar behind the active non-topmost window: {w}");
						
						//workaround 1. Sometimes works. Fails if w is "Caret Listener Shim Window"; then 2 fails too.
						tb.ZorderL_(SpecHWND.NOTOPMOST);
						tb.ZorderL_(SpecHWND.TOPMOST);
						if (!tb.ZorderIsAbove(w)) {
							Debug_.Print("Workaround 1 failed.");
							
							//workaround 2. Not much tested here, but `w1.ZorderL_(w2); w2.ZorderL_(w1);` works elsewhere.
							tb.ZorderL_(w, before: true); //may not work, although returns true. ZorderL_ gets previous window, and it may be HWND_TOP (0). SWP(HWND_TOP) does nothing if tb is behind the active non-topmost window (w).
							if (!tb.ZorderIsAbove(w)) { //workaround
								tb.ZorderL_(w);
								w.ZorderL_(tb);
								Debug_.PrintIf(!tb.ZorderIsAbove(w), $"Workaround 2 failed.");
							}
							tb.ZorderL_(SpecHWND.TOPMOST);
						}
					}
				}
			}
		}
		static wnd.Cached_ s_taskbar;
	}
	
	void _ZorderOwned() {
		Debug.Assert(IsOwned);
		if (IsOwned && _ow.visible) {
			wnd wt = _w, wo = _ow.w;
			
			//Some windows, eg UiPath, have an owned "shadow frame" window that may cover toolbar parts that aren't entirely inside the owner window's rect.
			//	Toolbars should detect such windows and zorder above them. Can't just blindly zorder above the topmost owned.
			//	But detecting can be difficult/slow/unreliable. Need to get all owned windows or all thread windows, etc.
			//	Never mind. Let users don't move toolbars to such places where they may be covered.
			//if (_zorderedOnce && wo.IsActive) {
			//	var w2 = wo.Get.EnabledOwned(); //may be not that window, eg a tooltip
			//	//print.it("eo", w2);
			//	if (!w2.Is0 && w2.Rect.Contains(wo.Rect)) wo = w2;
			//}
			//print.it(wo);
			
			if (!_zordered || !wt.ZorderIsAbove(wo)) {
				_zordered = wt.ZorderAbove(wo) || !wo.IsAlive;
				if (!_zordered) {
					var ec = lastError.code;
					if (wt.ZorderIsAbove(wo)) {
						_zordered = true;
					} else if (
#if !DEBUG
						_zorderRetry == 1 //the last retry
#else
						_zorderRetry > 0 //any retry. It's OK if sometimes fails first time, brobably then it's a bad time to zorder.
#endif
						) {
						var es = ec == Api.ERROR_ACCESS_DENIED && wo.UacAccessDenied ? "This process should run as admin, or owner's process not as admin." : lastError.messageFor(ec);
						print.warning($"Failed to Z-order toolbar '{_name}' above owner window. {es}");
					}
				}
			} else if (wt.IsTopmost && !wo.IsTopmost) {
				wt.ZorderAbove(wo);
			}
			
			if (_zordered) _zorderRetry = 0; else if (_zorderRetry == 0) _zorderRetry = 5; else _zorderRetry--;
			
			//never mind: when clicked owner's title bar, we receive 2 hook events and need to ZorderAbove 2 times. Speed is OK, but flickers more often.
			//	When we ZorderAbove on mouse down, Windows also zorders the window on mouse up, and then we receive second event.
			//	Possible workarounds:
			//	1. Temporarily make wt nativaly owned by _ow.w. Restore after 500 ms. But fails with higher UAC IL windows and appstore windows.
			//	2. Temporarily make wt topmost. Restore after 500 ms. But Windows makes it difficult and possibly unreliable.
		}
	}
	bool _zordered;
	byte _zorderRetry;
	
	void _ManageFullScreen(bool isFS, wnd wFore, screen scrn) {
		if (_inMoveSize) return;
		bool hide;
		if (!isFS) hide = false;
		else if (IsOwned) hide = OwnerWindow == wFore;
		else hide = screen.of(_w, SODefault.Zero) == scrn;
		
		_SetVisible(!hide, TBHide.FullScreen);
	}
	
	void _FollowRect(bool onFollowOwner = false) {
		if (_inMoveSize) return;
		if (onFollowOwner && Anchor.OfScreen() && _followedOnce) return;
		if (!onFollowOwner && _hide.Has(TBHide.Owner) && IsOwned && OwnerWindow.IsMinimized) return;
		
		bool dpiChanged = _os == null && _SetDpi();
		//print.it(dpiChanged, OwnerWindow);
		
		var (r, prevSize) = _GetCachedOwnerRect();
		//print.it(r, Anchor, _xy, Size);
		
		var swp = SWPFlags.NOZORDER | SWPFlags.NOOWNERZORDER | SWPFlags.NOACTIVATE;
		var bounds = _w.Rect;
		int x, y, cx = bounds.Width, cy = bounds.Height;
		
		if (Anchor.HasLeft()) {
			x = (Anchor.OppositeX() ? r.right : r.left) + _Scale(_offsets.Left, true);
			if (Anchor.HasRight() && (!_followedOnce || r.Width != prevSize.width)) {
				if (_preferSize) _offsets.Right = _Unscale(r.right - x - cx, true);
				else cx = Math.Max(r.right - _Scale(_offsets.Right, true) - x, 2); //_WmWindowPosChanging will limit min max if need
			}
		} else {
			Debug.Assert(Anchor.HasRight());
			x = (Anchor.OppositeX() ? r.left : r.right) - _Scale(_offsets.Right, true) - cx;
		}
		if (Anchor.HasTop()) {
			y = (Anchor.OppositeY() ? r.bottom : r.top) + _Scale(_offsets.Top, true);
			if (Anchor.HasBottom() && (!_followedOnce || r.Height != prevSize.height)) {
				if (_preferSize) _offsets.Bottom = _Unscale(r.bottom - y - cy, true);
				else cy = Math.Max(r.bottom - _Scale(_offsets.Bottom, true) - y, 2);
			}
		} else {
			Debug.Assert(Anchor.HasBottom());
			y = (Anchor.OppositeY() ? r.top : r.bottom) - _Scale(_offsets.Bottom, true) - cy;
		}
		
		if (_preferSize) {
			_preferSize = false;
			_sett.offsets = _offsets;
		}
		
		if (x == bounds.left && y == bounds.top) swp |= SWPFlags.NOMOVE;
		if (cx == bounds.Width && cy == bounds.Height) swp |= SWPFlags.NOSIZE;
		if (!swp.Has(SWPFlags.NOMOVE | SWPFlags.NOSIZE)) {
			_ignorePosChanged = (byte)(dpiChanged ? 2 : 1);
			_w.SetWindowPos(swp, x, y, cx, cy);
			_ignorePosChanged = 0;
		}
		
		bool followedOnce = _followedOnce;
		_followedOnce = true;
		
		if (dpiChanged) {
			_AutoSizeNowIfIsOpen(measureText: true);
		}
		
		if (!followedOnce && _os != null) {
			var sc = screen.of(_w, SODefault.Zero);
			if (sc != _os.Screen) {
				_w.EnsureInScreen(_os.Screen, workArea: !_w.IsTopmost);
			}
		}
	}
	bool _followedOnce;
	byte _ignorePosChanged;
	bool _preferSize;
	
	void _WmWindowPosChanging(ref Api.WINDOWPOS wp) {
		//uncomment if using properties MinimumSize and MaximumSize.
		
		if (!_created) return;
		////print.it(this, wp.flags);
		
		//if(!wp.flags.Has(SWPFlags.NOSIZE)) {
		//	SIZE min = _GetMinSize();
		//	if(wp.cx < min.width) wp.cx = min.width;
		//	if(wp.cy < min.height) wp.cy = min.height;
		//	SIZE max = _Scale(MaximumSize);
		//	if(max.width > 0) wp.cx = Math.Min(wp.cx, Math.Max(max.width, min.width));
		//	if(max.height > 0) wp.cy = Math.Min(wp.cy, Math.Max(max.height, min.height));
		//}
		//
		//SIZE _GetMinSize()
		//{
		//	int k = Border < TBBorder.ThreeD ? 1 : WndUtil.BorderWidth(_w);//?
		//	k *= 2;
		//	var ms = _Scale(MinimumSize);
		//	return (Math.Max(k, ms.Width), Math.Max(k, ms.Height));
		//}
		
		//don't allow to move the satellite away from the planet.
		//	Only when _inMoveSize. In other cases can create problems, eg when DPI changes.
		if (!wp.flags.Has(SWPFlags.NOMOVE) && _IsSatellite && _inMoveSize) {
			RECT r = _satPlanet._w.Rect, rs = _w.Rect;
			if (wp.cx == rs.Width && wp.cy == rs.Height) { //only when moving. When resizing, it could collapse the toolbar; will snap finally.
				if (wp.x > r.right) wp.x = r.right; else wp.x = Math.Max(wp.x, r.left - wp.cx);
				if (wp.y > r.bottom) wp.y = r.bottom; else wp.y = Math.Max(wp.y, r.top - wp.cy);
			}
		}
	}
	
	void _WmWindowPosChanged(in Api.WINDOWPOS wp) {
		if (!_created) return;
		if (!wp.flags.Has(SWPFlags.NOMOVE | SWPFlags.NOSIZE) && _ignorePosChanged < 2) {
			bool resized = !wp.flags.Has(SWPFlags.NOSIZE);
			if (_ignorePosChanged == 0) {
				if (_os != null) {
					if (_os.IsScreenInvalid()) return;
					_os.UpdateIfAutoScreen();
				}
				_UpdateOffsets(wp.x, wp.y, wp.cx, wp.cy); //tested: if SWP_NOMOVE or SWP_NOSIZE, wp contains current values
			} else {
				if (resized && !_inMoveSize) _sett.size = _Unscale(_w.ClientRect.Size);
			}
			if (resized) {
				/*SIZE z=*/
				_Measure(_w.ClientRect.Width); //rewrap buttons etc
				
				//if(AutoSize && _ignorePosChanged && z.height!=wp.cy && Anchor is TBAnchor.TopLR or TBAnchor.BottomLR && Layout==TBLayout.HorizontalWrap) _Resize(z);//rejected
			}
			_SatFollow();
		}
		if (wp.flags.Has(SWPFlags.HIDEWINDOW)) {
			_SatHide();
		}
	}
	
	void _UpdateOffsets(int x, int y, int cx, int cy) {
		var (r, _) = _GetCachedOwnerRect();
		//print.it(x, y, cx, cy, r);
		if (Anchor.HasLeft()) _offsets.Left = _Unscale(x - (Anchor.OppositeX() ? r.right : r.left), true);
		if (Anchor.HasRight()) _offsets.Right = _Unscale((Anchor.OppositeX() ? r.left : r.right) - x - cx, true);
		if (Anchor.HasTop()) _offsets.Top = _Unscale(y - (Anchor.OppositeY() ? r.bottom : r.top), true);
		if (Anchor.HasBottom()) _offsets.Bottom = _Unscale((Anchor.OppositeY() ? r.top : r.bottom) - y - cy, true);
		if (!_inMoveSize) {
			_sett.offsets = _offsets;
			_sett.size = _Unscale(_w.ClientRect.Size);
		}
	}
	
	void _SetInMoveSize(bool start) {
		_inMoveSize = start;
		if (!start) {
			_sett.offsets = _offsets;
			var z = _Unscale(_w.ClientRect.Size);
			if (z != _sett.size) {
				_sett.size = z;
				_sett.wrapWidth = z.Width - _BorderPadding(unscaled: true) * 2 + 2;
				if (AutoSize) _AutoSizeNowIfIsOpen();
			}
		}
	}
	bool _inMoveSize;
	
	/// <summary>
	/// Gets the cached rectangle of the owner window, screen, control, etc.
	/// If is owned and anchor has flag <c>Screen</c>, the rectangle is of toolbar's screen.
	/// Also gets previous size.
	/// The values are cached by <c>UpdateRect</c> of <c>_OwnerWindow</c> etc.
	/// </summary>
	(RECT r, SIZE prevSize) _GetCachedOwnerRect() {
		if (_os != null) return (_os.cachedRect, _os.prevSize);
		if (_oc != null) return (_oc.cachedRect, _oc.prevSize);
		return _ow.GetCachedRectAndPrevSize(this);
	}
	
	unsafe nint _WmGetDpiScaledSize(nint wParam, nint lParam) {
		//a quick and not perfect workaround for: on DPI change sometimes incorrect wrap/autosize
		if (_os != null && AutoSize && Layout == TBLayout.HorizontalWrap && _inMoveSize) {
			ref var z = ref *(SIZE*)lParam;
			int dpi = (int)wParam;
			z.width = Math2.MulDiv(z.width, dpi, _dpi);
			z.height = Math2.MulDiv(z.height, dpi, _dpi);
			z.width += dpi / 8;
			return 1;
		}
		return 0;
	}
	
	unsafe void _WmDpiChanged(nint wParam, nint lParam) {
		if (_os != null && Math2.LoShort(wParam) != _dpi) {
			timer.after(1, _ => { //workaround for Win11 bug: when moving the toolbar to another screen, often WM_DPICHANGED received when the window is still in old screen
				_os.UpdateIfAutoScreen();
				if (!_SetDpi()) return;
				_Images(true);
				_MeasureText();
				if (_inMoveSize && lParam != 0) { //cannot autosize now, or something bad may happen, eg nested wm_dpichanged until stack overflow
					_w.MoveL(*(RECT*)lParam);
				} else {
					if (DpiScaling.offsets == true) _FollowRect(); //update offsets if script wants so
					_AutoSizeNowIfIsOpen();
				}
			});
		}
	}
	
	void _WmDisplayChange() {
		if (_os != null) {
			if (_os.IsScreenInvalid()) return;
			
			timer.after(200, _ => {
				if (_os == null || _closed) return;
				
				//workaround for Win11 bug: WS_EX_TOOLWINDOW windows don't receive WM_DPICHANGED when screen DPI changes
				var dpi = _os.Screen.Dpi;
				if (dpi != _dpi) _WmDpiChanged(dpi, 0);
				
				_os.UpdateRect(out bool changed);
				if (changed) _FollowRect();
			});
		} else if (osVersion.minWin8_1) {
			//If owner's screen DPI changed, update toolbar's DPI/size/offsets. Need it for pm-dpi-aware windows that don't change rect when DPI changed.
			
			//WM_DISPLAYCHANGE doc: "when the display resolution has changed". Also when changed DPI, although undocumented. Tested on Win8.1 too.
			//	wm_dpichanged isn't good for it. We need DPI of owner, not of toolbar.
			//	Also we receive wm_settingchanged(SPI_SETLOGICALDPIOVERRIDE), but can't trust it. SPI_SETLOGICALDPIOVERRIDE's documentation is "Do not use.". No on Win8.1.
			
			//Wait until owner's DPI updated. If owner is pm-dpi-aware, its DPI is updated at random times, maybe after several s.
			int i = 15, oldDpi = _dpi;
			timer.every(1000, t => {
				if (--i > 0 && _dpi == oldDpi && !_closed && !_hide.Has(TBHide.Owner)) {
					if (screen.of(OwnerWindow).Dpi == oldDpi) return;
					//print.it("DPI changed", _dpi, Dpi.OfWindow(OwnerWindow, true));
					_FollowRect();
				}
				//print.it("stop");
				t.Stop();
				//tested: if pm-dpi-aware window is minimized, its dpi changes when restored. Not if hidden.
			});
		}
	}
}

//TODO3: now toolbars are lost too often.
//	Eg after removing autohide.


================================================
FILE: Au/GUI/toolbar/tb render.cs
================================================
using System.Drawing;
using System.Drawing.Drawing2D;

namespace Au;

public partial class toolbar {
	/// <summary>
	/// Border style.
	/// Default <see cref="TBBorder.Width2"/>.
	/// </summary>
	/// <remarks>
	/// This property is in the context menu and is saved.
	/// </remarks>
	public TBBorder Border {
		get => _sett.border;
		set {
			_ThreadTrap();
			if (value == _sett.border) return;
			if (IsOpen) {
				RECT r = _w.ClientRectInScreen;
				var bp1 = _BorderPadding();
				_sett.border = value;
				var bpDiff = _BorderPadding() - bp1;
				if (bpDiff != 0) { r.Inflate(bpDiff, bpDiff); r.Normalize(false); }
				const WS mask = WS.CAPTION | WS.THICKFRAME | WS.SYSMENU;
				WS s1 = _w.Style, s2 = _BorderStyle(value);
				if (s2 != (s1 & mask)) _w.SetStyle(s1 = ((s1 & ~mask) | s2));
				Dpi.AdjustWindowRectEx(r, ref r, s1, _w.ExStyle);
				_w.MoveL(r, SWPFlags.FRAMECHANGED | SWPFlags.HIDEWINDOW);
				if (bpDiff != 0) _Measure(); //update button rectangles
				_w.ShowL(true);
			} else {
				_sett.border = value;
			}
			
		}
	}
	
	/// <summary>
	/// Layout of buttons (horizontal, vertical).
	/// </summary>
	/// <remarks>
	/// This property is in the context menu and is saved.
	/// </remarks>
	public TBLayout Layout {
		get => _sett.layout;
		set {
			_ThreadTrap();
			if (value != _sett.layout) {
				_sett.layout = value;
				_AutoSizeNowIfIsOpen();
			}
		}
	}
	
	/// <summary>
	/// Display button text. Default <c>true</c>. If <c>false</c>, displays text in tooltips, and only displays first 2 characters for buttons without image.
	/// </summary>
	/// <remarks>
	/// A button can override this property:
	/// - To never display text, let its text be empty, like <c>""</c> or <c>"|Tooltip"</c>.
	/// - To always display text, append <c>"\a"</c>, like <c>"Text\a"</c> or <c>"Text\a|Tooltip"</c>.
	/// </remarks>
	public bool DisplayText {
		get => _sett.dispText;
		set {
			_ThreadTrap();
			if (value != _sett.dispText) {
				_sett.dispText = value;
				_AutoSizeNowIfIsOpen(measureText: true);
			}
		}
	}
	
	/// <summary>
	/// Font properties.
	/// </summary>
	/// <remarks>
	/// Cannot be changed after showing toolbar window.
	/// </remarks>
	public FontNSS Font {
		get => _font ??= new();
		set { _font = value; }
	}
	FontNSS _font;
	
	/// <summary>
	/// Text color.
	/// If <c>default</c>, uses system color.
	/// </summary>
	public ColorInt TextColor {
		get => _textColor;
		set {
			_textColor = value;
			_Invalidate();
		}
	}
	ColorInt _textColor;
	
	/// <summary>
	/// Background color or brush.
	/// </summary>
	/// <value>Can be <see cref="Color"/>, <see cref="ColorInt"/>, <c>int</c> (color <c>0xRRGGBB</c>) or <see cref="Brush"/>. If <c>null</c> (default), uses system color.</value>
	public object Background {
		get => _background;
		set {
			if (value is not (null or Brush or Color or ColorInt or int)) throw new ArgumentException();
			_background = value;
			_Invalidate();
		}
	}
	object _background;
	
	/// <summary>
	/// Border color when <see cref="Border"/> is <see cref="TBBorder.Width1"/> ... <see cref="TBBorder.Width4"/>.
	/// If <c>default</c>, uses system color.
	/// </summary>
	public ColorInt BorderColor {
		get => _borderColor;
		set {
			_borderColor = value;
			_Invalidate();
		}
	}
	ColorInt _borderColor;
	
	/// <summary>
	/// Don't display the default image (dot or triangle).
	/// </summary>
	public bool NoDefaultImage { get; set; }
	
	/// <summary>
	/// Sets some metrics of this toolbar, for example button padding.
	/// </summary>
	/// <remarks>
	/// Cannot be changed after showing toolbar window.
	/// </remarks>
	/// <example>
	/// <code><![CDATA[
	/// t.Metrics = new(4, 2);
	/// ]]></code>
	/// </example>
	/// <seealso cref="defaultMetrics"/>
	public TBMetrics Metrics { get; set; }
	
	/// <summary>
	/// Sets default metrics of toolbars.
	/// </summary>
	/// <seealso cref="Metrics"/>
	public static TBMetrics defaultMetrics {
		get => s_defaultMetrics ??= new();
		set { s_defaultMetrics = value; }
	}
	static TBMetrics s_defaultMetrics;
	
	void _Images(bool onDpiChanged) {
		foreach (var v in _a) {
			if (onDpiChanged) {
				if (v.image2 == null || v.image is not string) continue;
				//will either find/return same bitmap in cache, or create new bitmap from XAML, or return found old XAML bitmap created for other DPI.
				//note: will not reload non-XAML images, eg those created from native icons. They will be drawn DPI-scaled, slightly blurry.
			}
			//var old = v.image2;
			v.image2 = _GetImage(v).image;
			//if (onDpiChanged) print.it(old == v.image2);
			if (!_hasCachedImages && !onDpiChanged && v.image2 != null && v.image is string s && s.Length > 0) _hasCachedImages = true;
		}
		if (_hasCachedImages) _ImageCache.Cleared += _UpdateCachedImages;
	}
	bool _hasCachedImages;
	
	void _UpdateCachedImages() {
		foreach (var v in _a) {
			if (v.image2 != null && v.image is string s && s.Length > 0) {
				if (_GetImage(v).image is { } b) v.image2 = b;
			}
		}
	}
	
	//not used
	//internal void ChangeImage_(TBItem ti, Bitmap b) {
	//	if (_closed) return;
	//	ti.image2 = b;
	//	_Invalidate(ti);
	//}
	
	const TFFlags c_tff = TFFlags.NOPREFIX | TFFlags.EXPANDTABS;
	
	void _MeasureText() {
		NativeFont_ font = null;
		FontDC_ dc = null;
		try {
			foreach (var b in _a) {
				int len = _TextDispLen(b);
				if (len != 0) {
					dc ??= new FontDC_(font = Font.CreateFont(_dpi));
					b.textSize = dc.MeasureDT(b.Text.AsSpan(0, len), c_tff);
					b.textSize.height++;
				} else {
					b.textSize = default;
				}
			}
		}
		finally {
			dc?.Dispose();
			font?.Dispose();
		}
	}
	
	int _TextDispLen(TBItem b) {
		var s = b.Text;
		if (s.NE()) return 0;
		if (DisplayText || b.textAlways) return s.Length;
		if (b.HasImage_) return 0;
		return Math.Min(s.Length, 2); //info: 2 is ok for surrogate
	}
	
	struct _Metrics {
		public int bBorder, bPaddingX, bPaddingY, tbBorder, tbPadding, textPaddingR, textPaddingY, image, dot, triangle, imagePaddingX;
		
		public _Metrics(toolbar tb) {
			var k = tb.Metrics ?? defaultMetrics;
			int dpi = tb._dpi;
			bBorder = dpi / 96;
			bPaddingX = Dpi.Scale(k.ButtonPaddingX, dpi);
			bPaddingY = Dpi.Scale(k.ButtonPaddingY, dpi);
			tbPadding = tb._BorderPadding();
			tbBorder = tbPadding > 0 ? bBorder : 0;
			textPaddingR = Dpi.Scale(4, dpi);
			textPaddingY = Dpi.Scale(1, dpi);
			image = Dpi.Scale(tb.ImageSize, dpi);
			if (!tb.NoDefaultImage) {
				dot = tb.ImageSize / 3;
				triangle = tb.ImageSize / 2;
			} else dot = triangle = 0;
			imagePaddingX = Dpi.Scale(2, dpi);
			
			//tbBorder += 1; //test border thickness
			//bBorder += 1;
		}
		
		public int ImageEtc(TBItem b, bool vert) => b.HasImage_ ? image : (dot == 0 ? 0 : (vert ? image : (b.IsMenu_ ? triangle : dot)));
	}
	
	/// <summary>
	/// Measures toolbar size and sets button rectangles.
	/// Returns size of client area.
	/// </summary>
	SIZE _Measure(int? width = null) {
		//print.it("measure");
		SIZE R = default;
		bool autoSize = AutoSize && _a.Count > 0;
		bool vert = Layout == TBLayout.Vertical;
		var m = new _Metrics(this);
		int tbp = m.tbPadding,
			buttonPlusX = (m.bBorder + m.bPaddingX + m.imagePaddingX) * 2,
			buttonPlusY = (m.bBorder + m.bPaddingY + m.textPaddingY) * 2;
		
		int ww = int.MaxValue;
		if (width != null) ww = width.Value - tbp * 2;
		else if (!autoSize) ww = _Scale(_sett.size.Width, false) - tbp * 2;
		else if (AutoSizeWrapWidth > 0) ww = _Scale(AutoSizeWrapWidth, false);
		//ww = Math.Max(ww, m.image); //no, then can't have thin vertical screen edge toolbars
		
		for (int i = 0, x = 0, y = 0; i < _a.Count; i++) {
			var b = _a[i];
			SIZE z;
			if (b.IsGroup_ || (b.IsSeparator_ && vert)) {
				_NewRow();
				if (b.Text.NE()) z = new(2, 2 + m.imagePaddingX * 2);
				else z = new(b.textSize.width + m.image * 2, b.textSize.height + m.imagePaddingX * 2);
			} else {
				if (b.IsSeparator_) {
					z = new(2 + m.imagePaddingX * 2, _a[i - 1].rect.Height);
				} else {
					z = new(buttonPlusX + m.ImageEtc(b, vert),
						m.image + m.bPaddingY * 2 + m.bBorder * 4); //m.bBorder*4 for borders and image padding
					if (b.textSize.width > 0) {
						z.width += b.textSize.width + m.textPaddingR;
						z.height = Math.Max(z.height, b.textSize.height + buttonPlusY);
					}
				}
				if (!vert) if (x + z.width > ww && x > 0) _NewRow();
			}
			b.rect = new(x, y, z.width, z.height);
			b.rect.right = Math.Min(b.rect.right, ww);
			x += z.width;
			R.width = Math.Max(R.width, x);
			R.height = Math.Max(R.height, b.rect.bottom);
			if (vert || b.IsGroup_) _NewRow();
			
			void _NewRow() { x = 0; y = R.height; }
		}
		
		if (autoSize) {
			R.width = Math.Min(R.width, ww) + tbp * 2;
			R.height += tbp * 2;
		} else {
			R = new(ww + tbp * 2, _Scale(_sett.size.Height, false));
		}
		//print.it(R);
		
		foreach (var b in _a) {
			b.rect.Offset(tbp, tbp);
			if (vert || b.IsGroup_) b.rect.right = R.width - tbp;
		}
		
		return R;
	}
	
	void _WmPaint(IntPtr dc, Graphics g, RECT rClient, RECT rUpdate) {
		switch (Background) {
		case Brush bb: g.FillRectangle(bb, rUpdate); break;
		case Color bc: g.Clear(bc); break;
		case ColorInt bc: g.Clear((Color)bc); break;
		case int bc: g.Clear(bc.ToColor_()); break;
		default: g.Clear(SystemColors.Control); break;
		}
		
		var m = new _Metrics(this);
		bool vert = Layout == TBLayout.Vertical;
		
		Brush brushDot = null, brushTriangle = null;
		NativeFont_ font = null; IntPtr oldFont = default;
		int groupTextX = 0;
		int sysTextColor = Api.GetSysColor(Api.COLOR_BTNTEXT);
		try {
			for (int i = 0; i < _a.Count; i++) {
				var b = _a[i];
				if (!b.rect.IntersectsWith(rUpdate)) continue;
				
				//g.DrawRectangleInset(Pens.BlueViolet, b.rect);
				
				int textColor = b.TextColor != default ? b.TextColor.ToBGR() : (TextColor != default ? TextColor.ToBGR() : sysTextColor);
				
				int xImage = b.rect.left + m.bBorder + m.bPaddingX + m.imagePaddingX;
				
				if (b.IsSeparator_ && !vert) {
					var r = b.rect; r.Inflate(-m.imagePaddingX, -m.imagePaddingX - m.bBorder);
					Api.DrawEdge(dc, ref r, Api.EDGE_ETCHED, Api.BF_LEFT);
				} else if (b.IsSeparatorOrGroup_) {
					int pad = m.tbPadding + m.imagePaddingX;
					RECT r = new(pad, b.rect.CenterY - 1, rClient.Width - pad * 2, 2);
					if (b.Text.NE()) {
						Api.DrawEdge(dc, ref r, Api.EDGE_ETCHED, Api.BF_TOP);
					} else {
						int len = (r.Width - b.textSize.width) / 2 - m.textPaddingR; //length of left and right (from text) parts
						if (len > 0) {
							r.left = r.right - len;
							Api.DrawEdge(dc, ref r, Api.EDGE_ETCHED, Api.BF_TOP); //right
							r.left = pad; r.right = pad + len;
							Api.DrawEdge(dc, ref r, Api.EDGE_ETCHED, Api.BF_TOP); //left
							groupTextX = r.right + m.textPaddingR;
						} else groupTextX = pad;
					}
				} else {
					if (i == _iHot || i == _iClick) {
						if (!_noHotClick && (textColor == 0 || TextColor != default || b.TextColor != default))
							g.FillRectangle((i == _iClick ? 0xC0DCF3 : 0xD8E6F2).ToColor_(), b.rect);
						g.DrawRectangleInset((i == _iClick ? 0x90C8F6 : 0xC0DCF3).ToColor_(), m.bBorder, b.rect);
					}
					
					int x = xImage, y = b.rect.top;
					if (!b.HasImage_) {
						if (m.dot > 0) {
							g.SmoothingMode = SmoothingMode.HighQuality;
							y += (b.rect.Height - m.dot) / 2;
							if (vert) x += m.image / 4;
							if (b.IsMenu_) {
								y += m.triangle / 6;
								if (vert) x -= m.triangle / 8;
								brushTriangle ??= new SolidBrush(Color.YellowGreen);
								g.FillPolygon(brushTriangle, new Point[] { new(x, y), new(x + m.triangle, y), new(x + m.triangle / 2, y + m.triangle / 2) });
							} else {
								brushDot ??= new SolidBrush(Color.SkyBlue);
								g.FillEllipse(brushDot, x, y, m.dot, m.dot);
							}
							g.SmoothingMode = SmoothingMode.None;
						}
					} else if (b.image2 != null) {
						try { g.DrawImage(b.image2, x, y + (b.rect.Height - m.image) / 2, m.image, m.image); }
						catch (Exception ex) { Debug_.Print(ex); }
					}
				}
				
				if (b.textSize.width > 0) {
					if (font == null) {
						font = Font.CreateFont(_dpi);
						oldFont = Api.SelectObject(dc, font.Handle);
						Api.SetBkMode(dc, 1);
					}
					Api.SetTextColor(dc, textColor);
					
					RECT r = new(b.IsGroup_ ? groupTextX : xImage + m.ImageEtc(b, vert) + m.imagePaddingX, b.rect.top + (b.rect.Height - b.textSize.height) / 2, b.textSize.width, b.rect.Height);
					r.right = Math.Min(r.right, b.rect.right - m.bBorder * 2);
					
					Api.DrawText(dc, b.Text.AsSpan(0, _TextDispLen(b)), ref r, c_tff);
				}
			}
		}
		finally {
			brushDot?.Dispose();
			brushTriangle?.Dispose();
			if (font != null) {
				Api.SelectObject(dc, oldFont);
				font.Dispose();
			}
		}
		
		if (m.tbBorder > 0) {
			g.DrawRectangleInset(BorderColor != default ? (Color)BorderColor : SystemColors.ControlDark, m.tbBorder, rClient);
		}
	}
}


================================================
FILE: Au/GUI/toolbar/tb sat.cs
================================================
using Au.Triggers;

namespace Au;

public partial class toolbar {
	toolbar _satellite;
	toolbar _satPlanet;
	bool _satVisible;
	int _satAnimation;
	timer _satTimer;
	timer _satAnimationTimer;
	screen _screenAHSE;

	/// <summary>
	/// A toolbar attached to this toolbar. Can be <c>null</c>.
	/// </summary>
	/// <exception cref="InvalidOperationException">The <c>set</c> function throws this exception if the satellite toolbar was attached to another toolbar or was shown as non-satellite toolbar.</exception>
	/// <remarks>
	/// The satellite toolbar is shown when mouse enters its owner toolbar and hidden when mouse leaves it and its owner. Like an "auto hide" feature.
	/// A toolbar can have multiple satellite toolbars at different times. A satellite toolbar can be attached/detached multiple times to the same toolbar.
	/// </remarks>
	public toolbar Satellite {
		get => _satellite;
		set {
			_ThreadTrap();
			if (value != _satellite) {
				if (value == null) {
					_SatHide();
					_satellite = null;
					//and don't clear _satPlanet etc
				} else {
					if (_closed || value._closed) throw new ObjectDisposedException(nameof(toolbar));
					var p = value._satPlanet; if (p != this) { if (p != null || value._created) throw new InvalidOperationException(); }
					_satellite = value;
					_satellite._satPlanet = this;
				}
			}
		}
	}

	/// <summary>
	/// If this is a satellite toolbar (<see cref="Satellite"/>), gets its owner toolbar. Else <c>null</c>.
	/// </summary>
	public toolbar SatelliteOwner => _satPlanet;

	bool _IsSatellite => _satPlanet != null;

	toolbar _SatPlanetOrThis => _satPlanet ?? this;

	void _SatMouse() {
		if (_satellite == null || _satVisible) return;
		_satVisible = true;

		//print.it("show");
		if (!_satellite._created) {
			var owner = _w;
			_satellite._CreateWindow(true, owner, isSatelite: true);
			_satellite._ow = new _OwnerWindow(owner);
			_satellite._ow.a.Add(_satellite);
		}
		_SatFollow();
		_SatShowHide(true, animate: true);

		_satTimer ??= new timer(_SatTimer);
		_satTimer.Every(100);
	}

	void _SatTimer(timer _) {
		Debug.Assert(IsOpen);
		if (_inMoveSize || _satellite._inMoveSize) return;

		POINT p = mouse.xy;
		int dist = Dpi.Scale(30, _dpi);
		var wa = wnd.active;

		RECT ru = default;
		if (_MouseIsIn(this) || _MouseIsIn(_satellite)) return;
		if (ru.Contains(p)) return;
		if (miscInfo.getGUIThreadInfo(out var g, Api.GetCurrentThreadId()) && g.flags.Has(GTIFlags.INMENUMODE)) return;

		bool _MouseIsIn(toolbar tb) {
			var w = tb._w;
			if (w == wa) return true;
			var r = w.Rect;
			r.Inflate(dist, dist);
			if (r.Contains(p.x, p.y)) return true;
			ru.Union(r);
			return false;
		}

		_SatHide(animate: true);
	}

	void _SatDestroying() {
		if (_IsSatellite) _satPlanet.Satellite = null;
		Debug_.PrintIf(_satellite != null && _satellite.IsOpen, "_satellite");
		//When destroying planet, OS at first destroys satellites (owned windows).
	}

	//Hides _satellite and stops _satTimer.
	void _SatHide(bool animate = false/*, [CallerMemberName] string cmn=null*/) {
		if (_satellite == null) return;
		//print.it("hide", cmn, _satVisible);
		if (_satVisible) {
			_satVisible = false;
			_satTimer.Stop();
			_SatShowHide(false, animate);
		} else if (!animate && (_satAnimationTimer?.IsRunning ?? false)) {
			_SatShowHide(false, false);
		}
	}

	//Shows or hides _satellite and manages animation.
	void _SatShowHide(bool show, bool animate) {
		if (!animate || _satellite._transparency != default) {
			var w = _satellite._w;
			if (show != w.IsVisible) _satellite._SetVisibleL(show);
			if (_satellite._transparency == default) w.SetTransparency(false);
			_satAnimationTimer?.Stop();
			_satAnimation = 0;
			return;
		}

		_satAnimationTimer ??= new timer(_ => {
			_satAnimation += _satVisible ? 64 : -32;
			bool stop; if (_satVisible) { if (stop = _satAnimation >= 255) _satAnimation = 255; } else { if (stop = _satAnimation <= 0) _satAnimation = 0; }
			if (stop) {
				_satAnimationTimer.Stop();
				if (_satAnimation == 0) _satellite._SetVisibleL(false);
			}
			if (_satellite._transparency == default) _satellite._w.SetTransparency(!stop, _satAnimation);
		});
		_satAnimationTimer.Now();
		_satAnimationTimer.Every(30);

		if (show) _satellite._SetVisibleL(true);
	}

	void _SatFollow() {
		if (!_satVisible) return;
		if (!_satellite._ow.UpdateRect(out bool changed) || !changed) return;
		_satellite._FollowRect(onFollowOwner: true);
	}

	#region auto-hide owner toolbars

	/// <summary>
	/// Creates a new toolbar and sets its <see cref="Satellite"/> = this.
	/// </summary>
	/// <returns>The new toolbar.</returns>
	/// <param name="ctorFlags"><see cref="toolbar"/> constructor flags.</param>
	/// <param name="f_">[](xref:caller_info)</param>
	/// <param name="l_">[](xref:caller_info)</param>
	/// <exception cref="InvalidOperationException">This toolbar was attached to another toolbar or was shown as non-satellite toolbar.</exception>
	/// <remarks>
	/// Sets toolbar name = <c>this.Name + "^"</c>.
	/// If this already is a satellite toolbar, just returns its owner.
	/// </remarks>
	public toolbar AutoHide(TBCtor ctorFlags = 0, [CallerFilePath] string f_ = null, [CallerLineNumber] int l_ = 0) {
		_ThreadTrap();
		if (_satPlanet == null) {
			_satPlanet = new toolbar(this.Name + "^", ctorFlags, f_, l_) { Satellite = this };
			if (_satPlanet.FirstTime) {
				_satPlanet.Size = new(20, 20);
			}
			_satPlanet.AutoSize = false;
		}
		return _satPlanet;
	}

	/// <summary>
	/// Creates a new toolbar and sets its <see cref="Satellite"/> = this. Sets properties for showing at a screen edge.
	/// </summary>
	/// <returns>The new toolbar.</returns>
	/// <param name="mta">Mouse edge trigger arguments.</param>
	/// <param name="rangeStart"><i>rangeStart</i> and <i>rangeEnd</i> can be used to specify a smaller range of the edge part. For example, you can create 2 toolbars there: one with 0, .5f, other with .5f, 1f.</param>
	/// <param name="rangeEnd"></param>
	/// <param name="thickness">The visible thickness. Pixels.</param>
	/// <param name="ctorFlags"><see cref="toolbar"/> constructor flags.</param>
	/// <param name="f_">[](xref:caller_info)</param>
	/// <param name="l_">[](xref:caller_info)</param>
	public toolbar AutoHideScreenEdge(MouseTriggerArgs mta, Coord rangeStart = default, Coord rangeEnd = default, int thickness = 1, TBCtor ctorFlags = 0, [CallerFilePath] string f_ = null, [CallerLineNumber] int l_ = 0) {
		Not_.Null(mta);
		if (mta.Trigger.Kind != TMKind.Edge) throw new ArgumentException("Not an edge trigger.");
		return AutoHideScreenEdge(mta.Trigger.Edge, mta.Trigger.Screen, rangeStart, rangeEnd, thickness, ctorFlags, f_, l_);
	}

	/// <param name="edge">Screen edge/part.</param>
	/// <param name="scrn">Screen. Default: primary.</param>
	/// <inheritdoc cref="AutoHideScreenEdge(MouseTriggerArgs, Coord, Coord, int, TBCtor, string, int)"/>
	public toolbar AutoHideScreenEdge(TMEdge edge, screen scrn = default, Coord rangeStart = default, Coord rangeEnd = default, int thickness = 1, TBCtor ctorFlags = 0, [CallerFilePath] string f_ = null, [CallerLineNumber] int l_ = 0) {
		_ThreadTrap();
		var sh = scrn.Now;
		var rs = sh.Rect;

		var se = edge.ToString(); char se0 = se[0];
		bool vertical = se0 == 'L' || se0 == 'R';

		TBAnchor anchor = TBAnchor.TopLeft;
		RECT k = default;
		if (thickness <= 0) thickness = 1;
		int offscreen = thickness == 1 ? 1 : 0;
		switch (se0) {
		case 'T': k.top = -offscreen; break;
		case 'R': k.right = -offscreen; anchor = TBAnchor.TopRight; break;
		case 'B': k.bottom = -offscreen; anchor = TBAnchor.BottomLeft; break;
		case 'L': k.left = -offscreen; break;
		}
		int x25 = rs.Width / 4, y25 = rs.Height / 4;
		bool reverse = false;
		switch (edge) {
		case TMEdge.TopInCenter50: k.left = x25; break;
		case TMEdge.TopInRight25: anchor = TBAnchor.TopRight; reverse = true; break;
		case TMEdge.RightInCenter50: k.top = y25; break;
		case TMEdge.RightInBottom25: anchor = TBAnchor.BottomRight; reverse = true; break;
		case TMEdge.BottomInCenter50: k.left = x25; break;
		case TMEdge.BottomInRight25: anchor = TBAnchor.BottomRight; reverse = true; break;
		case TMEdge.LeftInCenter50: k.top = y25; break;
		case TMEdge.LeftInBottom25: anchor = TBAnchor.BottomLeft; reverse = true; break;
		}

		int edgeLength = vertical ? rs.Height : rs.Width; if (se.Contains("25")) edgeLength /= 4; else if (se.Contains("50")) edgeLength /= 2;
		int move = rangeStart.IsEmpty ? 0 : rangeStart.NormalizeInRange(0, edgeLength);
		int length = rangeEnd.IsEmpty ? edgeLength : Math.Max(0, rangeEnd.NormalizeInRange(0, edgeLength) - move);
		if (vertical) {
			if (reverse) k.bottom = edgeLength - length - move; else k.top += move;
		} else {
			if (reverse) k.right = edgeLength - length - move; else k.left += move;
		}

		var planet = AutoHide(ctorFlags, f_, l_);
		planet._screenAHSE = sh;
		if (planet.FirstTime || vertical != (planet.Size.Height > planet.Size.Width)) {
			SIZE z1 = vertical ? new(thickness + offscreen, length) : new(length, thickness + offscreen);
			//planet.Size = Dpi.Unscale(z1, sh.Handle); //no, such toolbars aren't DPI-sceled by default
			planet.Size = z1;
		}
		if (planet.FirstTime) {
			planet.Sizable = false;
		}
		planet.Anchor = anchor;
		planet.Offsets = new(k.left, k.top, k.right, k.bottom);
		planet.Border = TBBorder.Width1;
		planet.NoContextMenu = TBNoMenu.Anchor | TBNoMenu.Border | TBNoMenu.Layout | TBNoMenu.AutoSize;

		this.Anchor = anchor | (vertical ? TBAnchor.OppositeEdgeX : TBAnchor.OppositeEdgeY);
		this.NoContextMenu = TBNoMenu.Anchor;

		return planet;
	}

	#endregion

}


================================================
FILE: Au/GUI/toolbar/tb types.cs
================================================
namespace Au.Types;

/// <summary>
/// Represents a button or separator in <see cref="toolbar"/>.
/// </summary>
/// <remarks>
/// Most properties cannot be changed while the toolbar is open. Can be changed <see cref="MTItem.Tag"/>, <see cref="MTItem.Tooltip"/>.
/// </remarks>
public class TBItem : MTItem {
	readonly toolbar _tb;
	internal SIZE textSize;
	internal readonly TBItemType type;
	internal bool textAlways;
	internal popupMenu menu;
	
	internal TBItem(toolbar tb, TBItemType type) {
		_tb = tb;
		this.type = type;
		textAlways = type == TBItemType.Group;
	}
	
	internal bool IsSeparator_ => type == TBItemType.Separator;
	internal bool IsGroup_ => type == TBItemType.Group;
	internal bool IsMenu_ => type == TBItemType.Menu;
	internal bool IsSeparatorOrGroup_ => type is TBItemType.Separator or TBItemType.Group;
	
	///
	public TBItemType ItemType => type;
	
	/// <summary>Gets button action.</summary>
	public Action<TBItem> Clicked => base.clicked as Action<TBItem>;
	
	/// <summary>
	/// Button text.
	/// </summary>
	/// <remarks>
	/// Changing button text at run time resizes the button and toolbar.
	/// </remarks>
	public new string Text {
		get => base.Text;
		set {
			_tb._ThreadTrap();
			if (value != base.Text) {
				base.Text = value;
				_tb._AutoSizeNowIfIsOpen(measureText: true);
			}
		}
	}
}

/// <summary>
/// Used with <see cref="TBItem.ItemType"/>.
/// </summary>
public enum TBItemType : byte {
#pragma warning disable 1591 //doc
	Button,
	Menu,
	Separator,
	Group,
#pragma warning restore
}

/// <summary>
/// Used with <see cref="toolbar.MiscFlags"/>.
/// </summary>
[Flags]
public enum TBFlags {
	/// <summary>
	/// Activate the owner window when the toolbar clicked. Default.
	/// </summary>
	ActivateOwnerWindow = 1,
	
	/// <summary>
	/// Hide the toolbar when a full-screen window is active. Default.
	/// </summary>
	HideWhenFullScreen = 2,
	
	//rejected: use SHQueryUserNotificationState to detect also presentation mode etc. Too slow, eg 1300 mcs, which is 100-500 times slower than wnd.isFullScreen.
	//	HideWhenFullScreenActive
	//	HideWhenFullScreenRunning (QUNS_BUSY) (in primary screen only)
	//	HideWhenPresentation (QUNS_PRESENTATION_MODE)
	//	HideWhenD3DFullScreen (QUNS_RUNNING_D3D_FULL_SCREEN). I guess it is for games. Not tested.
	//	But problem: no QUNS_BUSY if fullscreen in non-primary screen.
	//	Also found this comment (not tested): "It also only works when the Explorer shell is running."
}

/// <summary>
/// Used with <see cref="toolbar.Border"/>.
/// </summary>
public enum TBBorder {
	//note: don't reorder.
	
	/// <summary>No border.</summary>
	None,
	
	/// <summary>1 pixel border.</summary>
	Width1,
	
	/// <summary>1 pixel border + 1 pixel padding.</summary>
	Width2,
	
	/// <summary>1 pixel border + 2 pixels padding.</summary>
	Width3,
	
	/// <summary>1 pixel border + 3 pixels padding.</summary>
	Width4,
	
	/// <summary>3D border.</summary>
	ThreeD,
	
	/// <summary>Standard window border.</summary>
	Thick,
	
	/// <summary>Title bar and standard window border.</summary>
	Caption,
	
	/// <summary>Title bar, <b>X</b> button and standard window border.</summary>
	CaptionX,
}

/// <summary>
/// Used with <see cref="toolbar.Anchor"/>.
/// </summary>
public enum TBAnchor {
	//top 1, bottom 2, left 4, right 8
	
	/// <summary>
	/// Anchors are top and left edges. Default.
	/// </summary>
	TopLeft = 1 | 4,
	
	/// <summary>
	/// Anchors are top and right edges.
	/// </summary>
	TopRight = 1 | 8,
	
	/// <summary>
	/// Anchors are bottom and left edges.
	/// </summary>
	BottomLeft = 2 | 4,
	
	/// <summary>
	/// Anchors are bottom and right edges.
	/// </summary>
	BottomRight = 2 | 8,
	
	/// <summary>
	/// Anchors are top, left and right edges. The toolbar is resized horizontally when resizing its owner.
	/// </summary>
	TopLR = 1 | 4 | 8,
	
	/// <summary>
	/// Anchors are bottom, left and right edges. The toolbar is resized horizontally when resizing its owner.
	/// </summary>
	BottomLR = 2 | 4 | 8,
	
	/// <summary>
	/// Anchors are left, top and bottom edges. The toolbar is resized vertically when resizing its owner.
	/// </summary>
	LeftTB = 4 | 1 | 2,
	
	/// <summary>
	/// Anchors are right, top and bottom edges. The toolbar is resized vertically when resizing its owner.
	/// </summary>
	RightTB = 8 | 1 | 2,
	
	/// <summary>
	/// Anchors are all edges. The toolbar is resized when resizing its owner.
	/// </summary>
	All = 15,
	
	/// <summary>
	/// Use owner's opposite left/right edge than specified. In other words, attach toolbar's left edge to owner's right edge or vice versa.
	/// This flag is for toolbars that normally are outside of the owner rectangle (at the left or right).
	/// This flag cannot be used with <c>TopLR</c>, <c>BottomLR</c>, <c>All</c>.
	/// </summary>
	OppositeEdgeX = 32,
	
	/// <summary>
	/// Use owner's opposite top/bottom edge than specified. In other words, attach toolbar's top edge to owner's bottom edge or vice versa.
	/// This flag is for toolbars that normally are outside of the owner rectangle (above or below).
	/// This flag cannot be used with <c>LeftTB</c>, <c>RightTB</c>, <c>All</c>.
	/// </summary>
	OppositeEdgeY = 64,
	
	/// <summary>
	/// Anchor is screen, not owner window. Don't move the toolbar together with its owner window.
	/// </summary>
	Screen = 128,
}

static partial class TBExt_ {
	internal static bool HasTop(this TBAnchor a) => 0 != ((int)a & 1);
	internal static bool HasBottom(this TBAnchor a) => 0 != ((int)a & 2);
	internal static bool HasLeft(this TBAnchor a) => 0 != ((int)a & 4);
	internal static bool HasRight(this TBAnchor a) => 0 != ((int)a & 8);
	internal static bool OppositeX(this TBAnchor a) => 0 != ((int)a & 32);
	internal static bool OppositeY(this TBAnchor a) => 0 != ((int)a & 64);
	internal static bool OfScreen(this TBAnchor a) => 0 != ((int)a & 128);
	internal static TBAnchor WithoutFlags(this TBAnchor a) => a & TBAnchor.All;
}

//rejected. Instead use System.Windows.Size. It loads 1 assembly in 1.5 ms and does not add much process memory.
//public record struct SizeD
//{
//	[System.Text.Json.Serialization.JsonInclude]
//	public double width;
//	[System.Text.Json.Serialization.JsonInclude]
//	public double height;

//	public SizeD(double width, double height) { this.width = width; this.height = height; }
//}

/// <summary>
/// Used with <see cref="toolbar.Offsets"/>.
/// </summary>
public record struct TBOffsets {
	/// <summary>
	/// Horizontal distance from the owner's left edge (right if <see cref="TBAnchor.OppositeEdgeX"/>) to the toolbar's left edge.
	/// </summary>
	public double Left { get; set; }
	
	/// <summary>
	/// Vertical distance from the owner's top edge (bottom if <see cref="TBAnchor.OppositeEdgeY"/>) to the toolbar's top edge.
	/// </summary>
	public double Top { get; set; }
	
	/// <summary>
	/// Horizontal distance from the toolbar's right edge to the owner's right edge (left if <see cref="TBAnchor.OppositeEdgeX"/>).
	/// </summary>
	public double Right { get; set; }
	
	/// <summary>
	/// Vertical distance from the toolbar's bottom edge to the owner's bottom edge (top if <see cref="TBAnchor.OppositeEdgeY"/>).
	/// </summary>
	public double Bottom { get; set; }
	
	/// <summary>
	/// Sets all properties.
	/// </summary>
	public TBOffsets(double left, double top, double right, double bottom) {
		Left = left; Top = top; Right = right; Bottom = bottom;
	}
}

/// <summary>
/// Reasons to hide a toolbar. Used with <see cref="toolbar.Hide"/>.
/// </summary>
[Flags]
public enum TBHide {
	/// <summary>Owner window is hidden, minimized, etc.</summary>
	Owner = 1,
	
	/// <summary>A full-screen window is active. See flag <see cref="TBFlags.HideWhenFullScreen"/>.</summary>
	FullScreen = 2,
	
	//Satellite = 128, //no, _SetVisible and this enum aren't used with satellites
	
	/// <summary>This and bigger flag values can be used by callers for any purpose. Value 0x10000.</summary>
	User = 0x10000,
}

/// <summary>
/// Used with <see cref="toolbar.Layout"/>.
/// </summary>
public enum TBLayout {
	/// <summary>Default layout. Buttons are in single row. Wrapped when exceeds maximal row width. More rows can be added with <see cref="toolbar.Group"/>.</summary>
	HorizontalWrap,
	
	/// <summary>Buttons are in single column, like in a popup menu. Separators are horizontal.</summary>
	Vertical, //TODO3: if some buttons don't fit, add overflow drop-down menu. Or scrollbar; or add VerticalScroll.
	
	//	/// <summary>Buttons are in single row. When it exceeds maximal row width, buttons are moved to a drop-down menu. More rows can be added with <see cref="toolbar.Group"/>.</summary>
	//	Horizontal,//TODO3
}

/// <summary>
/// Used with <see cref="toolbar.NoContextMenu"/>.
/// </summary>
[Flags]
public enum TBNoMenu {
#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
	Menu = 1,
	Edit = 1 << 1,
	Anchor = 1 << 2,
	Layout = 1 << 3,
	Border = 1 << 4,
	Sizable = 1 << 5,
	AutoSize = 1 << 6,
	MiscFlags = 1 << 7,
	Toolbars = 1 << 8,
	Help = 1 << 9,
	Close = 1 << 10,
	File = 1 << 11,
	Text = 1 << 12,
#pragma warning restore CS1591 // Missing XML comment for publicly visible type or member
}

/// <summary>
/// Flags for <see cref="toolbar"/> constructor.
/// </summary>
[Flags]
public enum TBCtor {
	/// <summary>
	/// Don't load saved settings. Delete the settings file of the toolbar, if exists.
	/// </summary>
	ResetSettings = 1,
	
	/// <summary>
	/// Don't load and save settings. No file will be created or opened.
	/// </summary>
	DontSaveSettings = 2,
}

/// <summary>
/// Used with <see cref="toolbar.DpiScaling"/>.
/// </summary>
public struct TBScaling {
	///
	public TBScaling(bool? size, bool? offsets) { this.size = size; this.offsets = offsets; }
	
	/// <summary>
	/// Scale toolbar size and related properties.
	/// If default (<c>null</c>), scales size, except of empty toolbars created by <see cref="toolbar.AutoHideScreenEdge"/>.
	/// </summary>
	public bool? size;
	
	/// <summary>
	/// Scale toolbar offsets. See <see cref="toolbar.Offsets"/>.
	/// If default (<c>null</c>), scales offsets, except when anchor is screen (not window etc).
	/// </summary>
	public bool? offsets;
}

/// <summary>
/// Used with <see cref="toolbar.Metrics"/> and <see cref="toolbar.defaultMetrics"/>.
/// </summary>
/// <param name="ButtonPaddingX">Button padding left and right.</param>
/// <param name="ButtonPaddingY">Button padding top and bottom.</param>
/// <remarks>
/// All values are in logical pixels (1 pixel when DPI is 100%).
/// </remarks>
public record class TBMetrics(int ButtonPaddingX = 0, int ButtonPaddingY = 0);

/// <summary>
/// Used with <see cref="toolbar.Show(wnd, ITBOwnerObject)"/>.
/// </summary>
/// <remarks>
/// Allows a toolbar to follow an object in the owner window, for example a UI element or image. Or to hide in certain conditions.
/// Define a class that implements this interface. Create a variable of that class and pass it to <see cref="toolbar.Show(wnd, ITBOwnerObject)"/>.
/// The interface functions are called every 250 ms, sometimes more frequently. Not called when the owner window is invisible or cloaked or minimized.
/// </remarks>
public interface ITBOwnerObject {
	/// <summary>
	/// Returns <c>false</c> to close the toolbar.
	/// </summary>
	/// <remarks>
	/// Not called if the owner window is invisible or cloaked or minimized.
	/// The default implementation returns <c>true</c>.
	/// </remarks>
	bool IsAlive => true;
	
	/// <summary>
	/// Returns <c>false</c> to hide the toolbar temporarily.
	/// </summary>
	/// <remarks>
	/// Not called if the owner window is invisible or cloaked or minimized.
	/// The default implementation returns <c>true</c>.
	/// </remarks>
	bool IsVisible => true;
	
	/// <summary>
	/// Gets object rectangle.
	/// </summary>
	/// <returns><c>false</c> if failed.</returns>
	/// <param name="r">Rectangle in screen coordinates.</param>
	/// <remarks>
	/// Not called if the owner window is invisible or cloaked or minimized or if <see cref="IsVisible"/> returned <c>false</c>.
	/// </remarks>
	bool GetRect(out RECT r);
}

================================================
FILE: Au/GUI/toolbar/tb util.cs
================================================
namespace Au;

public partial class toolbar {
#if DEBUG
	/// <summary>
	/// This is a debug-only function. Returns the caller method name. Use like <c>print.it(caller(), ...)</c>.
	/// </summary>
	static string caller([CallerMemberName] string m_ = null) => m_;
#endif

	bool _SetDpi() {
		Debug.Assert(_os != null || !OwnerWindow.Is0);
		return _SetDpi(_os != null ? _os.Screen.Dpi : screen.of(OwnerWindow).Dpi);
	}
	
	bool _SetDpi(int dpi) {
		if (dpi == _dpi) return false;
		_dpi = dpi;
		_dpiF = _dpi / 96d;
		return true;
	}

	bool _NeedScaling(bool offsets) {
		if (_dpi == 96) return false;
		if (offsets) return DpiScaling.offsets ?? _os == null;
		return DpiScaling.size ?? _screenAHSE.IsEmpty;
	}

	int _Scale(double d, bool offsets) {
		if (_NeedScaling(offsets)) d *= _dpiF;
		return d.ToInt();
	}

	double _Unscale(int i, bool offsets) => _NeedScaling(offsets) ? i / _dpiF : i;

	SIZE _Scale(System.Windows.Size z) => _NeedScaling(false) ? Dpi.Scale(z, _dpi) : SIZE.From(z, true);

	System.Windows.Size _Unscale(SIZE z) => _NeedScaling(false) ? Dpi.Unscale(z, _dpi) : z;

	//System.Windows.Size _Unscale(int width, int height) => _Unscale(new SIZE(width, height));

	static double _Limit(double d) {
		if (double.IsNaN(d)) throw new ArgumentException();
		const int c_max = 2_000_000; //for max *1024 DPI scaling
		return Math.Clamp(d, -c_max, c_max);
	}

	/// <summary>
	/// Measures, resizes and invalidates the toolbar now if need.
	/// </summary>
	internal void _AutoSizeNowIfIsOpen(bool measureText = false) {
		if (!IsOpen) return;
		if (measureText) _MeasureText();
		_Resize(_Measure());
		Api.InvalidateRect(_w);
	}

	void _Resize(SIZE clientSize/*, bool ignoreAnchor=false*/) {
		var r = new RECT(0, 0, clientSize.width, clientSize.height);
		Dpi.AdjustWindowRectEx(_dpi, ref r, _w.Style, _w.ExStyle);
		int cx = r.Width, cy = r.Height;
		var a = Anchor.WithoutFlags();
		if (/*ignoreAnchor ||*/ a == TBAnchor.All) {
			_w.ResizeL(cx, cy);
		} else {
			var rw = _w.Rect;
			int dx = cx - rw.Width, dy = cy - rw.Height;
			if (!a.HasLeft()) rw.left -= dx; else if (!a.HasRight()) rw.right += dx;
			if (!a.HasTop()) rw.top -= dy; else if (!a.HasBottom()) rw.bottom += dy;
			_w.MoveL(rw);
		}
	}

	void _Invalidate(TBItem ti = null) {
		_ThreadTrap();
		if (!IsOpen) return;
		if (ti != null) Api.InvalidateRect(_w, ti.rect);
		else Api.InvalidateRect(_w);
	}

	void _Invalidate(int i) => _Invalidate(_a[i]);

	static WS _BorderStyle(TBBorder b) => b switch {
		TBBorder.ThreeD => WS.DLGFRAME,
		TBBorder.Thick => WS.THICKFRAME,
		TBBorder.Caption => WS.CAPTION | WS.THICKFRAME,
		TBBorder.CaptionX => WS.CAPTION | WS.THICKFRAME | WS.SYSMENU,
		_ => 0
	};

	/// <summary>
	/// Returns DPI-scaled border thickness in client area. Returns 0 if <i>b</i> is not <c>TBBorder.Width1</c> ... <c>TBBorder.Width4</c>.
	/// </summary>
	static int _BorderPadding(TBBorder b, int dpi) => b >= TBBorder.Width1 && b <= TBBorder.Width4 ? Dpi.Scale((int)b, dpi) : 0;

	/// <summary>
	/// Returns DPI-scaled border thickness in client area. Returns 0 if <i>b</i> is not <c>TBBorder.Width1</c> ... <c>TBBorder.Width4</c>.
	/// </summary>
	int _BorderPadding(TBBorder? b = null, bool unscaled = false) => _BorderPadding(b ?? Border, unscaled ? 96 : _dpi);

	static TBAnchor _GetInvalidAnchorFlags(TBAnchor anchor) {
		return anchor.WithoutFlags() switch {
			TBAnchor.TopLeft or TBAnchor.TopRight or TBAnchor.BottomLeft or TBAnchor.BottomRight => 0,
			TBAnchor.TopLR or TBAnchor.BottomLR => TBAnchor.OppositeEdgeX,
			TBAnchor.LeftTB or TBAnchor.RightTB => TBAnchor.OppositeEdgeY,
			_ => TBAnchor.OppositeEdgeX | TBAnchor.OppositeEdgeY,
		};
	}

	void _CreatedTrap(string error = null) {
		if (_created) throw new InvalidOperationException(error);
	}
}

================================================
FILE: Au/GUI/toolbar/toolbar.cs
================================================
using Au.Triggers;

namespace Au;

//rejected: warn if using common controls version 5. Eg tooltips don't work. The same with menus.
//	Too many problems: 1. How to warn? Message box? 2. Need to also warn if no supported OS, DPI awareness, etc. Load/parse manifest in module initializer? 3. Maybe the app does not want to use these features (eg high DPI). 4. Maybe not possible to use correct manifest, eg when used in a scripting app. 5. Etc.
//	Never mind. The required manifest is documented.

/// <summary>
/// Floating toolbar.
/// Can be attached to windows of other programs.
/// </summary>
/// <remarks>
/// To create toolbar code can be used menu <b>TT > New toolbar</b>.
/// 
/// Not thread-safe. All functions must be called from the same thread that created the <see cref="toolbar"/> object, except where documented otherwise. Note: item actions by default run in other threads; see <see cref="MTBase.ActionThread"/>.
/// </remarks>
public partial class toolbar : MTBase {
	record class _Settings : JSettings {
		public static _Settings Load(string file, bool useDefault) => Load<_Settings>(file, useDefault);
		
		public TBAnchor anchor = TBAnchor.TopLeft;
		public TBLayout layout;
		public TBBorder border = TBBorder.Width2;
		public bool dispText = true, sizable = true, autoSize = true;
		public TBFlags miscFlags = TBFlags.HideWhenFullScreen | TBFlags.ActivateOwnerWindow;
		public System.Windows.Size size = new(150, 24);
		public double wrapWidth;
		public TBOffsets offsets; // = new(150, 5, 7, 7);
		public int screenx, screeny;
	}
	
	readonly _Settings _sett;
	readonly List<TBItem> _a = new();
	bool _created;
	bool _closed;
	bool _topmost; //no owner, or owner is topmost
	double _dpiF; //DPI scaling factor, eg 1.5 for 144 dpi
	
	static int s_treadId;
	
	/// <param name="name">
	/// Toolbar name. Must be valid filename.
	/// Used for: toolbar window name, settings file name, <see cref="find"/>, some other functions.
	/// If <c>null</c>, uses the caller function's name if available, else exception.
	/// </param>
	/// <param name="flags"></param>
	/// <param name="f_">[](xref:caller_info)</param>
	/// <param name="l_">[](xref:caller_info)</param>
	/// <param name="m_">[](xref:caller_info)</param>
	/// <param name="settingsFile"><c>null</c> or full path of the settings file of this toolbar.</param>
	/// <exception cref="ArgumentException">Invalid <i>name</i>.</exception>
	/// <remarks>
	/// Each toolbar has a settings file, where are saved its position, size and context menu settings. This function reads the file if exists, ie if settings changed in the past. See <see cref="getSettingsFilePath"/>. If fails, prints a warning and uses default settings.
	/// 
	/// Sets properties:
	/// - <see cref="MTBase.ActionThread"/> = <c>true</c>.
	/// - <see cref="MTBase.ExtractIconPathFromCode"/> = <c>true</c>.
	/// </remarks>
	public toolbar(string name = null, TBCtor flags = 0,
		[CallerFilePath] string f_ = null, [CallerLineNumber] int l_ = 0, [CallerMemberName] string m_ = null, string settingsFile = null)
		: base(name, f_, l_, m_) {
		
		if (s_treadId == 0) s_treadId = _threadId; else if (_threadId != s_treadId) print.warning("All toolbars should be in single thread. Multiple threads use more CPU. If using triggers, insert this code before adding toolbar triggers: <code>Triggers.Options.ThreadOfTriggers();</code> or <code>Triggers.Options.ThreadThis();</code>");
		
		settingsFile = flags.Has(TBCtor.DontSaveSettings) ? null : (settingsFile ?? getSettingsFilePath(_name));
		_sett = _Settings.Load(settingsFile, flags.Has(TBCtor.ResetSettings));
		
		_offsets = _sett.offsets; //TODO3: don't use saved offsets if this toolbar was free and now is owned or vice versa. Because the position is irrelevent and may be far/offscreen. It usually happens when testing.
		
		ActionThread = true;
		ExtractIconPathFromCode = true;
	}
	
	/// <summary>
	/// Gets the toolbar window.
	/// </summary>
	public wnd Hwnd => _w;
	
	/// <summary>
	/// Returns <c>true</c> if the toolbar is open. False if closed or <see cref="Show"/> still not called.
	/// </summary>
	public bool IsOpen => _created && !_closed;
	
	/// <summary>
	/// Gets the name of the toolbar.
	/// </summary>
	public string Name => _name;
	
	///
	public override string ToString() => _IsSatellite ? "    " + Name : Name; //the indentation is for the list in the Active toolbars dialog
	
	/// <summary>
	/// True if this toolbar started with default settings. False if loaded saved settings from file.
	/// </summary>
	/// <seealso cref="getSettingsFilePath"/>
	/// <seealso cref="TBCtor"/>
	public bool FirstTime => !_sett.LoadedFile;
	
	#region static functions
	
	/// <summary>
	/// Gets full path of toolbar's settings file. The file may exist or not.
	/// </summary>
	/// <param name="toolbarName">Toolbar name. If this string is a full path, returns this string.</param>
	/// <remarks>
	/// Path: <c>folders.Workspace + $@"\.toolbars\{toolbarName}.json"</c>. If <see cref="folders.Workspace"/> is <c>null</c>, uses <see cref="folders.ThisAppDataRoaming"/>.
	/// </remarks>
	public static string getSettingsFilePath(string toolbarName) {
		if (toolbarName.NE()) throw new ArgumentException("Empty name");
		if (pathname.isFullPath(toolbarName)) return toolbarName;
		string s = folders.Workspace.Path;
		if (s != null) return s + @"\.toolbars\" + toolbarName + ".json";
		s = s_settingsDir;
		if (s == null) {
			s = folders.ThisAppDataRoaming + ".toolbars";
			if (!filesystem.exists(s).Directory) { //fbc. Previously was folders.ThisAppDocuments, but a library should not create directories there.
				bool nac = folders.noAutoCreate;
				folders.noAutoCreate = true;
				var s2 = folders.ThisAppDocuments + ".toolbars";
				folders.noAutoCreate = nac;
				if (filesystem.exists(s2).Directory) s = s2;
			}
			s_settingsDir = s += @"\";
		}
		return s + toolbarName + ".json";
	}
	static string s_settingsDir;
	
	/// <summary>
	/// Finds an open toolbar by <see cref="Name"/>.
	/// </summary>
	/// <returns><c>null</c> if not found or closed or never shown (<see cref="Show"/> not called).</returns>
	/// <remarks>
	/// Finds only toolbars created in the same script and thread.
	/// 
	/// Does not find satellite toolbars. Use this code: <c>toolbar.find("owner toolbar").Satellite</c>
	/// </remarks>
	public static toolbar find(string name) => _Manager._atb.Find(o => o.Name == name);
	
	internal static void TriggerActionEndedInToolbarUnfriendlyThread_() {
		if (_Manager._atb.Count > 0)
			print.warning("Toolbars in wrong thread. Insert this code before adding toolbar triggers: <code>Triggers.Options.ThreadOfTriggers();</code> or <code>Triggers.Options.ThreadThis();</code>", -1);
	}
	
	#endregion
	
	#region add item
	
	void _Add(TBItem item, string text, Delegate click, MTImage image, int l_, string f_) {
		_ThreadTrap();
		_CreatedTrap(_closed ? null : "cannot add items while the toolbar is open. To add to submenu, use the submenu variable.");
		item.Set_(this, text, click, image, l_, _sourceFile == null ? null : f_);
		_a.Add(item);
		Last = item;
	}
	
	/// <summary>
	/// Adds button.
	/// Same as <see cref="this[string, MTImage, int, string]"/>.
	/// </summary>
	/// <param name="text">Text. Or <c>"Text|Tooltip"</c>, or <c>"|Tooltip"</c>, or <c>"Text|"</c>. Separator can be <c>"|"</c> or <c>"\0 "</c> (then <c>"|"</c> isn't a separator). To always display text regardless of <see cref="DisplayText"/>, append <c>"\a"</c>, like <c>"Text\a"</c> or <c>"Text\a|Tooltip"</c>.</param>
	/// <param name="click">Action called when the button clicked.</param>
	/// <param name="image">Image. Read here: <see cref="MTBase"/>.</param>
	/// <param name="l_">[](xref:caller_info)</param>
	/// <param name="f_">[](xref:caller_info)</param>
	/// <remarks>
	/// More properties can be specified later (set properties of the returned <see cref="TBItem"/> or use <see cref="Items"/>) or before (<see cref="MTBase.ActionThread"/>, <see cref="MTBase.ActionException"/>, <see cref="MTBase.ExtractIconPathFromCode"/>, <see cref="MTBase.PathInTooltip"/>).
	/// </remarks>
	public TBItem Add(string text, Action<TBItem> click, MTImage image = default, [CallerLineNumber] int l_ = 0, [CallerFilePath] string f_ = null) {
		var item = new TBItem(this, TBItemType.Button);
		_Add(item, text, click, image, l_, f_);
		return item;
	}
	
	/// <summary>
	/// Adds button.
	/// Same as <see cref="Add(string, Action{TBItem}, MTImage, int, string)"/>.
	/// </summary>
	/// <value>Action called when the button clicked.</value>
	/// <remarks>
	/// More properties can be specified later (set properties of <see cref="Last"/> <see cref="TBItem"/> or use <see cref="Items"/>) or before (<see cref="MTBase.ActionThread"/>, <see cref="MTBase.ActionException"/>, <see cref="MTBase.ExtractIconPathFromCode"/>, <see cref="MTBase.PathInTooltip"/>).
	/// </remarks>
	/// <example>
	/// These two are the same.
	/// <code><![CDATA[
	/// tb.Add("Example", o => print.it(o));
	/// tb["Example"] = o => print.it(o);
	/// ]]></code>
	/// These four are the same.
	/// <code><![CDATA[
	/// var b = tb.Add("Example", o => print.it(o)); b.Tooltip="tt";
	/// tb.Add("Example", o => print.it(o)).Tooltip="tt";
	/// tb["Example"] = o => print.it(o); var b=tb.Last; b.Tooltip="tt";
	/// tb["Example"] = o => print.it(o); tb.Last.Tooltip="tt";
	/// ]]></code>
	/// </example>
	/// <inheritdoc cref="Add(string, Action{TBItem}, MTImage, int, string)"/>
	public Action<TBItem> this[string text, MTImage image = default, [CallerLineNumber] int l_ = 0, [CallerFilePath] string f_ = null] {
		set { Add(text, value, image, l_, f_); }
	}
	
	//CONSIDER: AddCheck, AddRadio.
	
	/// <summary>
	/// Adds button with drop-down menu.
	/// </summary>
	/// <param name="menu">Action that adds menu items. Called whenever the button clicked.</param>
	/// <remarks>
	/// The submenu is a <see cref="popupMenu"/> object. It inherits these properties of this toolbar: <see cref="MTBase.ExtractIconPathFromCode"/>, <see cref="MTBase.ActionException"/>, <see cref="MTBase.ActionThread"/>, <see cref="MTBase.PathInTooltip"/>.
	/// </remarks>
	/// <example>
	/// <code><![CDATA[
	/// tb.Menu("Menu", m => {
	/// 	m["M1"]=o=>print.it(o);
	/// 	m["M2"]=o=>print.it(o);
	/// });
	/// ]]></code>
	/// </example>
	/// <inheritdoc cref="Add(string, Action{TBItem}, MTImage, int, string)"/>
	public TBItem Menu(string text, Action<popupMenu> menu, MTImage image = default, [CallerLineNumber] int l_ = 0, [CallerFilePath] string f_ = null) {
		var item = new TBItem(this, TBItemType.Menu);
		_Add(item, text, menu, image, l_, f_);
		return item;
	}
	
	/// <summary>
	/// Adds button with drop-down menu.
	/// </summary>
	/// <param name="menu">Func that returns the menu. Called whenever the button clicked.</param>
	/// <remarks>
	/// The caller creates the menu (creates the <see cref="popupMenu"/> object and adds items) and can reuse it many times. Other overload does not allow to create <see cref="popupMenu"/> and reuse same object.
	/// The submenu does not inherit properties of this toolbar.
	/// </remarks>
	/// <example>
	/// <code><![CDATA[
	/// var m = new popupMenu(); m.AddCheck("C1"); m.AddCheck("C2");
	/// t.Menu("Menu", () => m);
	/// ]]></code>
	/// </example>
	/// <inheritdoc cref="Add(string, Action{TBItem}, MTImage, int, string)"/>
	public TBItem Menu(string text, Func<popupMenu> menu, MTImage image = default, [CallerLineNumber] int l_ = 0, [CallerFilePath] string f_ = null) {
		var item = new TBItem(this, TBItemType.Menu);
		_Add(item, text, menu, image, l_, f_);
		return item;
	}
	
	/// <summary>
	/// Adds new vertical separator. Horizontal if vertical toolbar.
	/// </summary>
	public TBItem Separator() {
		int i = _a.Count - 1;
		if (i < 0 || _a[i].IsGroup_) throw new InvalidOperationException("first item is separator");
		var item = new TBItem(this, TBItemType.Separator);
		_Add(item, null, null, default, 0, null);
		return item;
	}
	
	/// <summary>
	/// Adds new horizontal separator, optionally with text.
	/// </summary>
	/// <param name="text">Text. Or <c>"Text|Tooltip"</c>, or <c>"|Tooltip"</c>, or <c>"Text|"</c>. Separator can be <c>"|"</c> or <c>"\0 "</c> (then <c>"|"</c> isn't a separator).</param>
	public TBItem Group(string text = null) {
		var item = new TBItem(this, TBItemType.Group);
		_Add(item, text, null, default, 0, null);
		return item;
	}
	
	/// <summary>
	/// Gets the last added item.
	/// </summary>
	public TBItem Last { get; private set; }
	
	/// <summary>
	/// Gets added buttons.
	/// </summary>
	/// <remarks>
	/// Allows to set properties of multiple buttons in single place instead of after each "add button" code line.
	/// Skips separators and groups.
	/// </remarks>
	public IEnumerable<TBItem> Items {
		get {
			_ThreadTrap();
			foreach (var v in _a) {
				if (!v.IsSeparatorOrGroup_) yield return v;
			}
		}
	}
	
	#endregion
	
	#region show, close, owner
	
	/// <summary>
	/// Shows the toolbar.
	/// </summary>
	/// <param name="screen">
	/// Attach to this screen. For example a screen index (0 the primary, 1 the first non-primary, and so on). Example: <c>screen.index(1)</c>.
	/// If not specified, the toolbar will be attached to the screen where it is now or where will be moved later.
	/// Don't use this parameter if this toolbar was created by <see cref="AutoHideScreenEdge"/>, because then screen is already known.
	/// </param>
	/// <exception cref="ArgumentException">The toolbar was created by <see cref="AutoHideScreenEdge"/>, and now screen specified again.</exception>
	/// <exception cref="InvalidOperationException"><c>Show</c> already called.</exception>
	/// <remarks>
	/// The toolbar will be moved when the screen moved or resized.
	/// </remarks>
	public void Show(screen screen = default) {
		if (!_screenAHSE.IsEmpty) { if (screen.IsEmpty) screen = _screenAHSE; else throw new ArgumentException(); }
		_Show(false, default, null, screen);
	}
	
	/// <summary>
	/// Shows the toolbar and attaches to a window.
	/// </summary>
	/// <param name="ownerWindow">Window or control. Can belong to any process.</param>
	/// <param name="clientArea">Let the toolbar position be relative to the client area of the window.</param>
	/// <exception cref="InvalidOperationException"><c>Show</c> already called.</exception>
	/// <exception cref="ArgumentException"><i>ownerWindow</i> is 0.</exception>
	/// <remarks>
	/// The toolbar will be above the window in the Z order; moved when the window moved or resized; hidden when the window hidden, cloaked or minimized; destroyed when the window destroyed.
	/// </remarks>
	public void Show(wnd ownerWindow, bool clientArea = false) {
		_followClientArea = clientArea;
		_Show(true, ownerWindow, null, _screenAHSE);
	}
	
	/// <summary>
	/// Shows the toolbar and attaches to an object in a window.
	/// </summary>
	/// <param name="ownerWindow">Window that contains the object. Can be control. Can belong to any process.</param>
	/// <param name="oo">A variable of a user-defined class that implements <see cref="ITBOwnerObject"/> interface. It provides object location, visibility, etc.</param>
	/// <exception cref="InvalidOperationException"><c>Show</c> already called.</exception>
	/// <exception cref="ArgumentException"><i>ownerWindow</i> is 0.</exception>
	/// <remarks>
	/// The toolbar will be above the window in the Z order; moved when the object or window moved or resized; hidden when the object or window hidden, cloaked or minimized; destroyed when the object or window destroyed.
	/// </remarks>
	public void Show(wnd ownerWindow, ITBOwnerObject oo) => _Show(true, ownerWindow, oo, default);
	
	/// <summary>
	/// Shows the toolbar.
	/// If <i>ta</i> is <see cref="WindowTriggerArgs"/>, attaches the toolbar to the trigger window.
	/// Else if <i>ta</i> != <c>null</c>, calls <see cref="TriggerArgs.DisableTriggerUntilClosed(toolbar)"/>.
	/// </summary>
	public void Show(TriggerArgs ta) {
		if (ta is WindowTriggerArgs wta) {
			Show(wta.Window);
		} else {
			Show();
			ta?.DisableTriggerUntilClosed(this);
		}
	}
	
	//used for normal toolbars, not for satellite toolbars
	void _Show(bool owned, wnd owner, ITBOwnerObject oo, screen screen) {
		_ThreadTrap();
		_CreatedTrap("this toolbar is already open");
		
		wnd c = default;
		if (owned) {
			if (owner.Is0) throw new ArgumentException();
			var w = owner.Window; if (w.Is0) return;
			if (w != owner) { c = owner; owner = w; }
			if (!_screenAHSE.IsEmpty) _sett.anchor |= TBAnchor.Screen;
		}
		
		_CreateWindow(owned, owner, screen);
		_Manager.Add(this, owner, c, oo);
	}
	
	//used for normal and satellite toolbars
	void _CreateWindow(bool owned, wnd owner, screen screen = default, bool isSatelite = false) {
		_topmost = !owned || owner.IsTopmost;
		if (!owned || Anchor.OfScreen()) _os = new _OwnerScreen(this, screen); else screen = screen.of(owner);
		
		_RegisterWinclass();
		if (_os != null) _SetDpi(); else _SetDpi(screen.Dpi); //OwnerWindow still not set
		_Images(false);
		_MeasureText();
		var size = _Measure();
		var style = WS.POPUP | WS.CLIPCHILDREN | _BorderStyle(_sett.border);
		var estyle = WSE.TOOLWINDOW | WSE.NOACTIVATE;
		if (_topmost) estyle |= WSE.TOPMOST;
		var r = screen.Rect; //create in center of screen, to minimize possibility of DPI change when setting final position
		r = new(r.CenterX - size.width / 2, r.CenterY - size.height / 2, size.width, size.height);
		Dpi.AdjustWindowRectEx(_dpi, ref r, style, estyle);
		WndUtil.CreateWindow(_WndProc, true, "Au.toolbar", _name, style, estyle, r.left, r.top, r.Width, r.Height, isSatelite ? owner : default);
		_created = true;
	}
	
	/// <summary>
	/// Destroys the toolbar window.
	/// </summary>
	/// <remarks>
	/// Can be called from any thread.
	/// Does nothing if not open.
	/// </remarks>
	public void Close() {
		if (_w.Is0) return;
		if (_IsOtherThread) _w.Post(Api.WM_CLOSE); else Api.DestroyWindow(_w);
		if (_hasCachedImages) _ImageCache.Cleared -= _UpdateCachedImages;
	}
	
	/// <summary>
	/// When the toolbar window destroyed.
	/// </summary>
	public event Action Closed;
	
	private protected override void _WmNcdestroy() {
		_closed = true;
		_Manager.Remove(this);
		_SatDestroying();
		_sett.Dispose();
		base._WmNcdestroy();
		Closed?.Invoke();
	}
	
	/// <summary>
	/// Adds or removes a reason to temporarily hide the toolbar. The toolbar is hidden if at least one reason exists. See also <see cref="Close"/>.
	/// </summary>
	/// <param name="hide"><c>true</c> to hide (add <i>reason</i>), <c>false</c> to show (remove <i>reason</i>).</param>
	/// <param name="reason">A user-defined reason to hide/unhide. Can be <see cref="TBHide.User"/> or a bigger value, eg <c>(TBHide)0x20000</c>, <c>(TBHide)0x40000</c>.</param>
	/// <exception cref="InvalidOperationException">
	/// - The toolbar was never shown (<see cref="Show"/> not called).
	/// - It is a satellite toolbar.
	/// - Wrong thread. Must be called from the same thread that created the toolbar. See <see cref="MTBase.ActionThread"/>.
	/// </exception>
	/// <exception cref="ArgumentOutOfRangeException"><i>reason</i> is less than <see cref="TBHide.User"/>.</exception>
	/// <remarks>
	/// Toolbars are automatically hidden when the owner window is hidden, minimized, etc. This function can be used to hide toolbars for other reasons.
	/// </remarks>
	public void Hide(bool hide, TBHide reason) {
		_ThreadTrap();
		if (!_created || _IsSatellite) throw new InvalidOperationException();
		if (0 != ((int)reason & 0xffff)) throw new ArgumentOutOfRangeException();
		_SetVisible(!hide, reason);
	}
	
	/// <summary>
	/// Gets current reasons why the toolbar is hidden. Returns 0 if not hidden.
	/// </summary>
	/// <remarks>
	/// Not used with satellite toolbars.
	/// </remarks>
	public TBHide Hidden => _hide;
	
	void _SetVisible(bool show, TBHide reason) {
		//print.it(show, reason);
		if (show) {
			if (_hide == 0) return;
			_hide &= ~reason;
			if (_hide != 0) return;
		} else {
			var h = _hide;
			_hide |= reason;
			if (h != 0) return;
		}
		_SetVisibleL(show);
	}
	TBHide _hide;
	
	void _SetVisibleL(bool show) => _w.ShowL(show);
	
	/// <summary>
	/// Returns <c>true</c> if the toolbar is attached to a window or an object in a window.
	/// </summary>
	public bool IsOwned => _ow != null;
	
	/// <summary>
	/// Returns the owner top-level window.
	/// Returns <c>default(wnd)</c> if the toolbar is not owned. See <see cref="IsOwned"/>.
	/// </summary>
	public wnd OwnerWindow => _ow?.w ?? default;
	
	#endregion
	
	#region wndproc, context menu
	
	static void _RegisterWinclass() {
		if (0 == Interlocked.Exchange(ref s_winclassRegistered, 1)) {
			WndUtil.RegisterWindowClass("Au.toolbar"/*, etc: new() { style = Api.CS_HREDRAW | Api.CS_VREDRAW, mCursor = MCursor.Arrow }*/);
		}
	}
	static int s_winclassRegistered;
	
	unsafe nint _WndProc(wnd w, int msg, nint wParam, nint lParam) {
		//WndUtil.PrintMsg(w, msg, wParam, lParam);
		bool activatedOwner = false;
		
		switch (msg) {
		case Api.WM_LBUTTONDOWN or Api.WM_RBUTTONDOWN or Api.WM_MBUTTONDOWN:
			var tb1 = _SatPlanetOrThis;
			if (tb1.IsOwned && tb1.MiscFlags.Has(TBFlags.ActivateOwnerWindow)) {
				var wo = tb1.OwnerWindow;
				if (!wo.IsActive) activatedOwner = wo.ActivateL();
			}
			break;
		case Api.WM_MOUSEMOVE or Api.WM_NCMOUSEMOVE:
			_SatMouse();
			break;
		}
		
		switch (msg) {
		case Api.WM_NCCREATE:
			_WmNccreate(w);
			if (_transparency != default) _w.SetTransparency(true, _transparency.opacity, _transparency.colorKey);
			break;
		case Api.WM_NCDESTROY:
			_WmNcdestroy();
			//PROBLEM: not called if thread ends without closing the toolbar window.
			//	Then saves settings only on process exit. Not if process terminated.
			//	In most cases it isn't a problem because saves settings every 2 s (IIRC).
			break;
		case Api.WM_ERASEBKGND:
			return 0;
		case Api.WM_PAINT:
			using (BufferedPaint bp = new(w, true)) {
				var dc = bp.DC;
				using var g = System.Drawing.Graphics.FromHdc(dc);
				g.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.HighQualityBicubic;
				_WmPaint(dc, g, bp.Rect, bp.UpdateRect);
			}
			return 0;
		case Api.WM_MOUSEACTIVATE:
			return Api.MA_NOACTIVATE;
		case Api.WM_MOUSEMOVE:
			_WmMousemove(lParam);
			return 0;
		case Api.WM_MOUSELEAVE:
			_WmMouseleave();
			return 0;
		case Api.WM_LBUTTONDOWN:
			_WmMouselbuttondown(lParam, activatedOwner);
			return 0;
		case Api.WM_CONTEXTMENU or Api.WM_NCRBUTTONUP:
			_WmContextmenu();
			break;
		case Api.WM_NCHITTEST:
			if (_WmNchittest(lParam, out int hitTest)) return hitTest; //returns a hittest code to move or resize if need
			break;
		case Api.WM_NCLBUTTONDOWN:
			int ht = (int)wParam;
			if (ht == Api.HTCAPTION || (ht >= Api.HTSIZEFIRST && ht <= Api.HTSIZELAST)) {
				//workaround for: Windows tries to activate this window when moving or sizing it, unless this process is not allowed to activate windows.
				//	This window then may not become the foreground window, but it receives wm_activateapp, wm_activate, wm_setfocus, and is moved to the top of Z order.
				//	tested: LockSetForegroundWindow does not work.
				//	This code better would be under WM_SYSCOMMAND, but then works only when sizing. When moving, activates before WM_SYSCOMMAND.
				using (WindowsHook.ThreadCbt(d => d.code == HookData.CbtEvent.ACTIVATE)) {
					//also let arrow keys move/resize by 1 pixel.
					//	In active window Ctrl+arrow work automatically, but toolbars aren't active.
					//	Never mind: does not work if active window has higher UAC IL. Even with Ctrl.
					using var k1 = new RegisteredHotkey(); k1.Register(100, KKey.Left, _w);
					using var k2 = new RegisteredHotkey(); k2.Register(101, KKey.Right, _w);
					using var k3 = new RegisteredHotkey(); k3.Register(102, KKey.Up, _w);
					using var k4 = new RegisteredHotkey(); k4.Register(103, KKey.Down, _w);
					
					Api.DefWindowProc(w, msg, wParam, lParam);
				}
				return 0;
			}
			break;
		case Api.WM_ENTERSIZEMOVE:
			_SetInMoveSize(true);
			break;
		case Api.WM_EXITSIZEMOVE:
			_SetInMoveSize(false);
			break;
		case Api.WM_WINDOWPOSCHANGING:
			_WmWindowPosChanging(ref *(Api.WINDOWPOS*)lParam);
			break;
		case RegisteredHotkey.WM_HOTKEY:
			int hkid = (int)wParam - 100;
			if (hkid >= 0 && hkid <= 3) {
				POINT p = mouse.xy;
				Api.SetCursorPos(p.x + hkid switch { 0 => -1, 1 => 1, _ => 0 }, p.y + hkid switch { 2 => -1, 3 => 1, _ => 0 });
				return 0;
			}
			break;
		case Api.WM_GETOBJECT:
			if (_WmGetobject(wParam, lParam, out var r1)) return r1;
			break;
		case Api.WM_USER + 50: //posted by acc dodefaultaction
			if (!_closed) {
				int i = (int)wParam;
				if ((uint)i < _a.Count) _Click(i, false);
			}
			return 0;
		case Api.WM_USER + 51:
			_toolbarsDialog();
			[MethodImpl(MethodImplOptions.NoInlining)] //don't load System.Windows.Forms assembly
			static void _toolbarsDialog() => toolbarsDialog();
			return 0;
		}
		
		var R = Api.DefWindowProc(w, msg, wParam, lParam);
		
		switch (msg) {
		case Api.WM_WINDOWPOSCHANGED:
			_WmWindowPosChanged(in *(Api.WINDOWPOS*)lParam);
			break;
		case Api.WM_GETDPISCALEDSIZE:
			return _WmGetDpiScaledSize(wParam, lParam);
		case Api.WM_DPICHANGED:
			_WmDpiChanged(wParam, lParam);
			break;
		case Api.WM_DISPLAYCHANGE:
			_WmDisplayChange();
			break;
			//case Api.WM_SETTINGCHANGE:
			//	_WmSettingChange(wParam, lParam);
			//	break;
		}
		
		return R;
	}
	
	#endregion
	
	#region input, context menu
	
	int _HitTest(POINT p) {
		for (int i = 0; i < _a.Count; i++) {
			if (_a[i].rect.Contains(p)) return i;
		}
		return -1;
	}
	
	unsafe void _WmMousemove(nint lParam) {
		if (_iClick < 0) {
			var p = Math2.NintToPOINT(lParam);
			int i = _HitTest(p);
			if (i != _iHot) {
				if (_iHot >= 0) _Invalidate(_iHot);
				if ((_iHot = i) >= 0) {
					_Invalidate(_iHot);
					var b = _a[i];
					_SetTooltip(b, b.rect, lParam);
				}
			}
			if (_iHot >= 0 != _trackMouseEvent) _trackMouseEvent = Api.TrackMouseLeave(_w, _iHot >= 0) && _iHot >= 0;
		}
	}
	int _iHot = -1, _iClick = -1;
	bool _trackMouseEvent, _noHotClick;
	
	void _WmMouseleave() {
		_trackMouseEvent = false;
		if (_iHot >= 0) { _Invalidate(_iHot); _iHot = -1; }
	}
	
	void _WmMouselbuttondown(nint lParam, bool activatedOwner) {
		var mod = keys.gui.getMod();
		if (mod == 0) { //click button
			var p = Math2.NintToPOINT(lParam);
			int i = _HitTest(p);
			if (i < 0) return;
			
			if (activatedOwner && _a[i].IsMenu_) { //let manager process OBJECT_REORDER. And let owner process WM_ACTIVATE. Else the menu sometimes disappears.
				timer.after(50, _ => { if (IsOpen) _Click(i, true); });
			} else {
				_Click(i, true);
			}
			
			//} else if(mod==KMod.Shift) { //move toolbar
			//	var p=mouse.xy;
			//	DragDropUtil.SimpleDragDrop(_w, MButtons.Left, d => {
			//		if (d.Msg.message != Api.WM_MOUSEMOVE) return;
			//		var v=mouse.xy; if(v==p) return;
			//		int dx=v.x-p.x, dy=v.y-p.y;
			//		p=v;
			//		var r=_w.Rect;
			//		_w.MoveL(r.left+dx, r.top+dy);
			//	});
		}
	}
	int _menuClosedIndex; long _menuClosedTime;
	
	void _Click(int i, bool real) {
		var b = _a[i];
		if (b.clicked == null) return;
		if (b.IsMenu_) {
			if (i == _menuClosedIndex && perf.ms - _menuClosedTime < 100) return;
			popupMenu m = null;
			if (b.clicked is Action<popupMenu> menu) {
				m = new popupMenu(null, NoContextMenu.Has(TBNoMenu.Edit) ? null : b.sourceFile, b.sourceLine);
				_CopyProps(m);
				menu(m);
			} else if (b.clicked is Func<popupMenu> func) {
				m = func();
			}
			if (m == null) return;
			
			var r = b.rect; _w.MapClientToScreen(ref r);
			m.Show(PMFlags.AlignRectBottomTop, new(r.left, r.bottom), r, owner: _w);
			_menuClosedIndex = i; _menuClosedTime = perf.ms;
			//info: before wm_lbuttondown the menu is already closed and its message loop ended. Previous Show returns before new Show.
		} else {
			if (real) {
				bool ok = false;
				try {
					_Invalidate(_iClick = i);
					ok = WndUtil.DragLoop(_w, MButtons.Left, d => {
						if (d.msg.message != Api.WM_MOUSEMOVE) return;
						int j = _HitTest(Math2.NintToPOINT(d.msg.lParam));
						if ((j == i) == _noHotClick) {
							_noHotClick ^= true;
							_Invalidate(i);
						}
					}) && !_noHotClick;
				}
				finally {
					_iClick = -1; _noHotClick = false;
					_Invalidate(i);
				}
				if (!ok) return;
			}
			//print.it("click", b);
			if (b.actionThread) run.thread(() => _ExecItem(), background: false); //thread start speed: 250 mcs
			else _ExecItem();
			void _ExecItem() {
				var action = b.clicked as Action<TBItem>;
				try { action(b); }
				catch (Exception ex) when (!b.actionException) { print.warning(ex); }
			}
		}
	}
	
	void _WmContextmenu() {
		var no = NoContextMenu;
		if (no.Has(TBNoMenu.Menu)) return;
		if (_a.Count == 0 && _satellite != null) no |= TBNoMenu.Layout | TBNoMenu.AutoSize | TBNoMenu.Text;
		
		var p = _w.MouseClientXY;
		int i = _HitTest(p);
		var item = i < 0 ? null : _a[i];
		
		var m = new popupMenu();
		
		if (!no.Has(TBNoMenu.Edit | TBNoMenu.File)) {
			string sf; int sl; if (item != null) { sf = item.sourceFile; sl = item.sourceLine; } else { sf = _sourceFile; sl = _sourceLine; }
			var (canEdit, canGo, goText) = MTItem.CanEditOrGoToFile_(sf, item);
			if (!no.Has(TBNoMenu.Edit) && canEdit) m["Edit toolbar"] = o => ScriptEditor.Open(sf, sl);
			if (!no.Has(TBNoMenu.File) && canGo) m[goText] = o => item.GoToFile_();
		}
		if (!no.Has(TBNoMenu.Close)) m.Add("Close", o => _SatPlanetOrThis.Close());
		if (m.Last != null) m.Separator();
		
		if (!no.Has(TBNoMenu.Anchor)) {
			m.Submenu("Anchor", m => {
				_AddAnchor(TBAnchor.TopLeft);
				_AddAnchor(TBAnchor.TopRight);
				_AddAnchor(TBAnchor.BottomLeft);
				_AddAnchor(TBAnchor.BottomRight);
				_AddAnchor(TBAnchor.TopLR);
				_AddAnchor(TBAnchor.BottomLR);
				_AddAnchor(TBAnchor.LeftTB);
				_AddAnchor(TBAnchor.RightTB);
				_AddAnchor(TBAnchor.All);
				m.Separator();
				_AddAnchor(TBAnchor.OppositeEdgeX);
				_AddAnchor(TBAnchor.OppositeEdgeY);
				if (IsOwned) _AddAnchor(TBAnchor.Screen);
				
				void _AddAnchor(TBAnchor an) {
					var k = an <= TBAnchor.All
						? m.AddRadio(an.ToString(), Anchor.WithoutFlags() == an, _ => Anchor = (Anchor & ~TBAnchor.All) | an)
						: m.AddCheck(an.ToString(), Anchor.Has(an), _ => Anchor ^= an, disable: _GetInvalidAnchorFlags(Anchor).Has(an));
					if (_IsSatellite) k.Tooltip = "Note: You may want to set anchor of the owner toolbar instead. Anchor of this auto-hide toolbar is relative to the owner toolbar.";
				}
			});
		}
		if (!no.Has(TBNoMenu.Layout)) {
			m.Submenu("Layout", m => {
				_AddLayout(TBLayout.HorizontalWrap);
				_AddLayout(TBLayout.Vertical);
				//_AddLayout(TBLayout.Horizontal);
				
				void _AddLayout(TBLayout tl) {
					m.AddRadio(tl.ToString(), tl == Layout, _ => Layout = tl);
				}
			});
		}
		if (!no.Has(TBNoMenu.Border)) {
			m.Submenu("Border", m => {
				_AddBorder(TBBorder.None);
				_AddBorder(TBBorder.Width1);
				_AddBorder(TBBorder.Width2);
				_AddBorder(TBBorder.Width3);
				_AddBorder(TBBorder.Width4);
				_AddBorder(TBBorder.ThreeD);
				_AddBorder(TBBorder.Thick);
				_AddBorder(TBBorder.Caption);
				_AddBorder(TBBorder.CaptionX);
				
				void _AddBorder(TBBorder b) {
					m.AddRadio(b.ToString(), b == Border, _ => Border = b);
				}
			});
		}
		if (!no.Has(TBNoMenu.Sizable | TBNoMenu.AutoSize | TBNoMenu.Text | TBNoMenu.MiscFlags)) {
			m.Submenu("More", m => {
				if (!no.Has(TBNoMenu.Sizable)) m.AddCheck("Sizable", Sizable, _ => Sizable ^= true);
				if (!no.Has(TBNoMenu.AutoSize)) m.AddCheck("Auto-size", AutoSize, _ => AutoSize ^= true);
				if (!no.Has(TBNoMenu.Text)) m.AddCheck("Display text", DisplayText, _ => DisplayText ^= true);
				if (!no.Has(TBNoMenu.MiscFlags)) {
					_AddFlag(TBFlags.HideWhenFullScreen);
					if (_SatPlanetOrThis.IsOwned) _AddFlag(TBFlags.ActivateOwnerWindow);
					
					void _AddFlag(TBFlags f) {
						var tb = _SatPlanetOrThis;
						m.AddCheck(_EnumToString(f), tb.MiscFlags.Has(f), _ => tb.MiscFlags ^= f);
					}
					
					static string _EnumToString(Enum e) {
						var s = e.ToString().RxReplace(@"(?<=[^A-Z])[A-Z]", m => " " + m.Value.Lower());
						//s = s.Replace("Dont", "Don't");
						return s;
					}
				}
			});
		}
		
		if (!no.Has(TBNoMenu.Toolbars | TBNoMenu.Help) && m.Last != null && !m.Last.IsSeparator) m.Separator();
		if (!no.Has(TBNoMenu.Toolbars)) m.Add("Toolbars", o => toolbarsDialog());
		if (!no.Has(TBNoMenu.Help)) m["How to"] = _ => dialog.showInfo("How to",
@"Move toolbar: Shift+drag.

Resize toolbar: drag border. Cannot resize if in context menu is unchecked or unavailable More > Sizable; or if checked Border > None.

Move or resize precisely: start to move or resize but don't move the mouse. Instead release Shift and press arrow keys. Finally release the mouse button.
");
		
		if (m.Last != null) m.Show();
	}
	
	bool _WmNchittest(nint xy, out int ht) {
		ht = 0;
		if (keys.gui.getMod() == KMod.Shift) { //move
			ht = Api.HTCAPTION;
		} else { //resize?
			if (Border == TBBorder.None || (!Sizable && Border < TBBorder.Thick)) return false;
			var (x, y) = Math2.NintToPOINT(xy);
			if (Sizable) {
				_w.GetWindowInfo_(out var k);
				RECT r = k.rcWindow;
				int b = Border >= TBBorder.ThreeD ? k.cxWindowBorders : (_a.Count > 0 ? _BorderPadding() : Dpi.Scale(6, _dpi)); //make bigger if no buttons. Eg if auto-hide-at-screen-edge, border 1 is difficult to resize.
				int bx = Math.Min(b, r.Width / 2), by = Math.Min(b, r.Height / 2);
				if (bx == 0) bx = 1;
				if (by == 0) by = 1;
				//print.it(bx, by);
				int x1 = r.left + bx, x2 = --r.right - bx, y1 = r.top + by, y2 = --r.bottom - by;
				if (r.Width > bx * 8 && r.Height > by * 8) { //if toolbar isn't small, in corners allow to resize both width and height at the same time
					if (x < x1) ht = y < y1 ? Api.HTTOPLEFT : (y > y2 ? Api.HTBOTTOMLEFT : Api.HTLEFT);
					else if (x > x2) ht = y < y1 ? Api.HTTOPRIGHT : (y > y2 ? Api.HTBOTTOMRIGHT : Api.HTRIGHT);
					else if (y < y1) ht = Api.HTTOP;
					else if (y > y2) ht = Api.HTBOTTOM;
					else return false;
				} else if (r.Width >= r.Height) { //in corners prefer width
					if (x < x1) ht = Api.HTLEFT;
					else if (x > x2) ht = Api.HTRIGHT;
					else if (y < y1) ht = Api.HTTOP;
					else if (y > y2) ht = Api.HTBOTTOM;
					else return false;
				} else { //in corners prefer height
					if (y < y1) ht = Api.HTTOP;
					else if (y > y2) ht = Api.HTBOTTOM;
					else if (x < x1) ht = Api.HTLEFT;
					else if (x > x2) ht = Api.HTRIGHT;
					else return false;
				}
			} else { //disable resizing if border is natively sizable
				if (Border < TBBorder.Thick) return false;
				_w.GetWindowInfo_(out var k);
				k.rcWindow.Inflate(-k.cxWindowBorders, -k.cyWindowBorders);
				if (k.rcWindow.Contains(x, y)) return false;
				ht = Api.HTBORDER;
			}
		}
		return true;
	}
	
	#endregion
	
	#region properties
	
	/// <summary>
	/// Whether to DPI-scale toolbar size and offsets.
	/// Default: scale size; scale offsets if anchor is not screen.
	/// </summary>
	/// <remarks>
	/// The unit of measurement of <see cref="Size"/>, <see cref="Offsets"/> and some other properties depends on whether scaling is used for that property. If scaling is used, the unit is logical pixels; it is 1/96 inch regardless of screen DPI. If scaling not used, the unit is physical pixels. Screen DPI can be changed in Windows Settings; when it is 100%, logical and physical pixels are equal.
	/// </remarks>
	public TBScaling DpiScaling { get; set; }
	
	/// <summary>
	/// Toolbar width and height without non-client area when <see cref="AutoSize"/> <c>false</c>.
	/// </summary>
	/// <remarks>
	/// Non-client area is border and title bar when <see cref="Border"/> is <c>ThreeD</c>, <c>Thick</c>, <c>Caption</c> or <c>CaptionX</c>.
	/// 
	/// The unit of measurement depends on <see cref="DpiScaling"/>.
	/// 
	/// This property is updated when resizing the toolbar. It is saved.
	/// </remarks>
	/// <example>
	/// <code><![CDATA[
	/// t.Size = new(300, 40);
	/// ]]></code>
	/// </example>
	public System.Windows.Size Size {
		get => _sett.size;
		set {
			_ThreadTrap();
			if (value != _sett.size) {
				value = new(_Limit(value.Width), _Limit(value.Height));
				_sett.size = value;
				if (IsOpen && !AutoSize) _Resize(_Scale(value));
			}
			if (!_followedOnce) _preferSize = true;
		}
	}
	
	/// <summary>
	/// Whether the border can be used to resize the toolbar.
	/// Default <c>true</c>.
	/// </summary>
	/// <remarks>
	/// This property is in the context menu and is saved.
	/// </remarks>
	public bool Sizable {
		get => _sett.sizable;
		set => _sett.sizable = value;
	}
	
	/// <summary>
	/// Automatically resize the toolbar to make all buttons visible.
	/// Default <c>true</c>.
	/// </summary>
	/// <remarks>
	/// This property is in the context menu and is saved.
	/// </remarks>
	public bool AutoSize {
		get => _sett.autoSize;
		set {
			_ThreadTrap();
			if (value != _sett.autoSize) {
				_sett.autoSize = value;
				_AutoSizeNowIfIsOpen();
			}
		}
	}
	
	/// <summary>
	/// When <see cref="AutoSize"/> is <c>true</c>, this is the preferred width at which buttons are moved to the next row. Unlimited if 0.
	/// </summary>
	/// <remarks>
	/// The unit of measurement depends on <see cref="DpiScaling"/>.
	/// 
	/// This property is updated when the user resizes the toolbar while <see cref="AutoSize"/> is <c>true</c>. It is saved.
	/// 
	/// If layout of this toolbar is vertical, just sets max width.
	/// </remarks>
	public double AutoSizeWrapWidth {
		get => _sett.wrapWidth;
		set {
			_ThreadTrap();
			value = value > 0 ? _Limit(value) : 0;
			if (value != _sett.wrapWidth) {
				_sett.wrapWidth = value;
				_AutoSizeNowIfIsOpen();
			}
		}
	}
	
	/// <summary>
	/// Specifies to which owner's edges the toolbar keeps constant distance when moving or resizing the owner.
	/// </summary>
	/// <remarks>
	/// The owner can be a window, screen, control or other object. It is specified when calling <see cref="Show"/>.
	/// This property is in the context menu and is saved.
	/// </remarks>
	/// <seealso cref="Offsets"/>
	public TBAnchor Anchor {
		get => _sett.anchor;
		set {
			_ThreadTrap();
			value &= ~_GetInvalidAnchorFlags(value);
			if (value.WithoutFlags() == 0) value |= TBAnchor.TopLeft;
			if (value == _sett.anchor) return;
			var prev = _sett.anchor;
			_sett.anchor = value;
			if (IsOwned) {
				_os = value.OfScreen() ? new _OwnerScreen(this, default) : null; //follow toolbar's screen
				if (prev.OfScreen() && _followedOnce) {
					if (_oc != null) _oc.UpdateRect(out _); else _ow.UpdateRect(out _);
				}
			}
			if (_followedOnce) {
				var r = _w.Rect;
				_UpdateOffsets(r.left, r.top, r.Width, r.Height);
			}
		}
	}
	
	/// <summary>
	/// Specifies distances between edges of the toolbar and edges of its owner, depending on <see cref="Anchor"/>.
	/// </summary>
	/// <remarks>
	/// Owner is specified when calling <see cref="Show"/>. It can be a window, screen, control or other object.
	/// 
	/// The <see cref="TBOffsets"/> type has 4 properties - <c>Top</c>, <c>Bottom</c>, <c>Left</c> and <c>Right</c>, but used are only those included in <see cref="Anchor"/>. For example, if <c>Anchor</c> is <c>TopLeft</c>, used are only <c>Top</c> and <c>Left</c>.
	/// 
	/// The unit of measurement depends on <see cref="DpiScaling"/> and whether anchor is screen.
	/// 
	/// This property is updated when moving or resizing the toolbar. It is saved.
	/// </remarks>
	/// <example>
	/// <code><![CDATA[
	/// t.Offsets = new(150, 5, 0, 0);
	/// ]]></code>
	/// </example>
	public TBOffsets Offsets {
		get => _offsets;
		set {
			_ThreadTrap();
			_preferSize = false;
			if (value == _offsets) return;
			_sett.offsets = _offsets = value;
			if (_followedOnce) _FollowRect();
		}
	}
	TBOffsets _offsets;
	
	/// <summary>
	/// Number of pixels to add to the top of the retrieved rectangle of the owner window when it is maximized. That is, move this toolbar slightly down (if positive) or up (if negative).
	/// </summary>
	/// <remarks>
	/// When you create a toolbar attached to a window, and the anchor is at the top, test whether it is in visually the same vertical position (relative to UI elements of the window) when the window is maximized and when not maximized. On some windows it will be in a different position, and it is not what you want. Reason: some windows, when maximized, draw their UI elements in a different vertical position than when not maximized. It's impossible to reliably correct it automatically. To correct it, set this property before calling <see cref="toolbar.Show(wnd, bool)"/> or <see cref="toolbar.Show(TriggerArgs)"/>. With most such windows, the good value is 6.7 or 7.5. With some windows may need a negative value.
	/// 
	/// By default the value is logical pixels; that is, will be scaled depending on DPI.
	/// 
	/// If the owner window has multiple attached toolbars and all they run in the same thread, set this property for one of them, not for all. It will adjust the vertical position of all them.
	/// 
	/// With some windows can be used another way to correct the vertical position: call <see cref="toolbar.Show(wnd, bool)"/> with <c>clientArea: true</c>.
	/// 
	/// If neither way works, use <see cref="toolbar.Show(wnd, ITBOwnerObject)"/> (you'll need to create a class that implements <see cref="ITBOwnerObject"/>). For example, to move the toolbar to a different position when the window is in full-screen mode.
	/// </remarks>
	public double MaximizedWindowTopPlus { get; set; }
	
	//rejected. Would be rarely used, unless default 0. Avoid default limitations like this. We have a dialog to find lost toolbars.
	//public int MaxDistanceFromOwner { get; set; } = int.MaxValue;
	
	//rejected
	//public bool HideTextIfSmall { get; set; } //like ribbon UI
	
	/// <summary>
	/// Miscellaneous options.
	/// </summary>
	/// <remarks>
	/// This property is in the context menu (submenu <b>More</b>) and is saved.
	/// </remarks>
	public TBFlags MiscFlags {
		get => _sett.miscFlags;
		set {
			_sett.miscFlags = value;
		}
	}
	
	/// <summary>
	/// Opacity and transparent color.
	/// </summary>
	/// <seealso cref="wnd.SetTransparency(bool, int?, ColorInt?, bool)"/>
	/// <example>
	/// <code><![CDATA[
	/// t.Transparency = (64, null);
	/// ]]></code>
	/// </example>
	public (int? opacity, ColorInt? colorKey) Transparency {
		get => _transparency;
		set {
			if (value != _transparency) {
				_transparency = value;
				if (_created) _w.SetTransparency(value != default, value.opacity, value.colorKey);
			}
		}
	}
	(int? opacity, ColorInt? colorKey) _transparency;
	
	/// <summary>
	/// Gets or sets flags to hide some context menu items or menu itself.
	/// </summary>
	public TBNoMenu NoContextMenu { get; set; }
	
	#endregion
}


================================================
FILE: Au/GUI/trayIcon.cs
================================================
namespace Au {
	/// <summary>
	/// Shows tray icon.
	/// </summary>
	/// <remarks>
	/// Wraps API <ms>Shell_NotifyIconW</ms>, <ms>NOTIFYICONDATAW</ms>. More info there.
	/// 
	/// This thread must dispatch messages.
	/// 
	/// Can be used by multiple threads (eg one thread adds tray icon and other thread later changes its tooltip).
	/// 
	/// Creates a hidden window that receives tray icon events (click etc).
	/// </remarks>
	public class trayIcon : IDisposable {
		readonly int _id;
		readonly bool _disposeOnExit;
		wnd _w;
		
		//rejected. Various problems, eg the program file cannot be moved. Unclear documentation.
		//	Guid _guid;
		
		static trayIcon() {
			s_msgTaskbarCreated = WndUtil.RegisterMessage("TaskbarCreated", uacEnable: true);
			WndUtil.RegisterWindowClass("trayIcon");
		}
		static int s_msgTaskbarCreated;
		
		/// <summary>
		/// Tray icon notification message.
		/// </summary>
		protected const int MsgNotify = Api.WM_USER + 145;
		
		/// <param name="id">An id that helps Windows to distinguish multiple tray icons added by same program. Use 0, 1, 2, ... or all 0.</param>
		/// <param name="disposeOnExit">
		/// Remove tray icon when process exits (<see cref="process.thisProcessExit"/>).
		/// Note: can't remove if the process terminated or called <see cref="Environment.FailFast"/> or API <ms>ExitProcess</ms>.
		/// </param>
		public trayIcon(int id = 0, bool disposeOnExit = true) {
			_disposeOnExit = disposeOnExit;
			_id = Hash.Fnv1(script.name) + id;
			///// <param name="guid">A GUID that identifies the tray icon.</param>
			//_guid=guid;
		}
		
		/// <summary>
		/// Removes tray icon and disposes other resources.
		/// </summary>
		public void Dispose() { Dispose(true); }
		
		///
		protected virtual void Dispose(bool disposing) { _Delete(disposing: true); }
		
		void _Delete(bool disposing = false) {
			lock (this) {
				if (_visible) {
					Api.Shell_NotifyIcon(Api.NIM_DELETE, _NewND());
					_visible = false;
				}
				if (disposing && !_w.Is0) {
					if (!Api.DestroyWindow(_w)) _w.Post(Api.WM_CLOSE);
					_w = default;
				}
			}
		}
		
		/// <summary>
		/// Gets or sets whether the tray icon is visible.
		/// </summary>
		/// <exception cref="InvalidOperationException">Icon not set.</exception>
		public bool Visible {
			get => _visible;
			set {
				lock (this) {
					if (value != _visible) {
						if (value && _icon == null) throw new InvalidOperationException("Icon not set"); //but allow ShowNotification without icon. This is to prevent using slow code like new trayIcon() { Visible=true, Icon=... }.
						if (value) _Update();
						else _Delete();
					}
				}
			}
		}
		bool _visible;
		
		/// <summary>
		/// Gets or sets icon.
		/// </summary>
		/// <remarks>
		/// To display nice icon at any DPI, the icon should be loaded with <see cref="icon.trayIcon"/> or API <ms>LoadIconMetric</ms>, either from a native resource in your app or from an <c>.ico</c> file, which should contain icons of sizes 16, 32 and also recommended 20, 24.
		/// </remarks>
		public icon Icon {
			get => _icon;
			set {
				lock (this) {
					if (value != _icon) {
						_icon = value;
						if (_visible) _Update(icon: true);
					}
				}
			}
		}
		icon _icon;
		
		/// <summary>
		/// Gets or sets tooltip text.
		/// </summary>
		/// <remarks>
		/// Max length of displayed tooltip text is 127.
		/// </remarks>
		public string Tooltip {
			get => _tooltip;
			set {
				lock (this) {
					if (value != _tooltip) {
						_tooltip = value;
						if (_visible) _Update(tooltip: true);
					}
				}
			}
		}
		string _tooltip;
		
		Api.NOTIFYICONDATA _NewND(uint nifFlags = 0, bool setTT = false) {
			var d = new Api.NOTIFYICONDATA(_w, nifFlags) { uID = _id, uCallbackMessage = MsgNotify, uVersion = Api.NOTIFYICON_VERSION_4 };
			//if (_guid!=default) { d.uFlags|=Api.NIF_GUID; d.guidItem=_guid; }
			if (!_customPopup) d.uFlags |= Api.NIF_SHOWTIP;
			if (setTT) {
				d.uFlags |= Api.NIF_TIP;
				d.szTip = _customPopup ? " " : _tooltip?.Limit(127);
			}
			return d;
		}
		
		bool _Update(bool icon = false, bool tooltip = false, _Notification n = null, bool taskbarCreated = false) {
			if (script.Exiting_) return false;
			lock (this) {
				if (_w.Is0) {
					if (_disposeOnExit) process.thisProcessExit += _ => _Delete();
					_w = WndUtil.CreateWindow(WndProc, true, "trayIcon", script.name, WS.POPUP, WSE.NOACTIVATE);
				}
				
				if (taskbarCreated) _visible = false;
				
				if (!_visible) { icon = _icon != null; tooltip = !_tooltip.NE(); }
				var d = _NewND(Api.NIF_MESSAGE, setTT: tooltip || _customPopup);
				if (icon) { d.uFlags |= Api.NIF_ICON; d.hIcon = _icon; }
				
				if (n != null) {
					d.uFlags |= Api.NIF_INFO;
					if (n.flags.Has(TINFlags.Realtime)) d.uFlags |= Api.NIF_REALTIME;
					d.dwInfoFlags = (uint)(n.flags & ~TINFlags.Realtime);
					if (n.icon != null) { d.dwInfoFlags |= 0x24; d.hBalloonIcon = n.icon; } //user icon, large
					d.szInfoTitle = n.title?.Limit(63);
					d.szInfo = n.text?.Limit(255);
					//if(!_visible) if(_icon==null && _tooltip.NE()) { d.uFlags|=Api.NIF_STATE; d.dwState=d.dwStateMask=1; } //hidden icon. But then no notification.
				}
				
				int nim = _visible ? Api.NIM_MODIFY : Api.NIM_ADD;
				bool ok = Api.Shell_NotifyIcon(nim, d);
				if (!ok && 4 == (d.dwInfoFlags & 15)) {
					//fails if size of custom icon of notification != XM_CXSMICON (if no NIIF_LARGE_ICON) or < SM_CXICON (if NIIF_LARGE_ICON).
					//	tested: Even if now taskbar DPI is different (changed since this process started), need icon of these sizes (they didn't change since this process started).
					//	Workaround: Remove the user icon flag and print warning.
					//tested: Win7 displays XM_CXSMICON or SM_CXICON depending on NIIF_LARGE_ICON. Win8.1 too. Win10 displays SM_CXICON*1.5 regardless of NIIF_LARGE_ICON.
					d.dwInfoFlags &= ~15u;
					ok = Api.Shell_NotifyIcon(nim, d);
					if (ok) print.warning("Custom icon size must be >= trayIcon.notificationIconSize");
				}
				if (!_visible) {
					if (ok || taskbarCreated) ok = Api.Shell_NotifyIcon(Api.NIM_SETVERSION, d);
					_visible = true;
					//note: Shell_NotifyIcon(NIM_ADD) fails if already added, eg when "TaskbarCreated" message received when taskbar DPI changed.
					//note: Win10 sets last error, but Win7 doesn't.
				}
				//if(!ok) print.it("Shell_NotifyIcon: ", lastError.message);
				return ok;
			}
		}
		
		/// <summary>
		/// Shows temporary notification window by the tray icon.
		/// </summary>
		/// <param name="title">Title, max 63 characters.</param>
		/// <param name="text">Text, max 255 characters.</param>
		/// <param name="flags">Standard icon and other flags.</param>
		/// <param name="icon">Custom icon. Important: use icon of size returned by <see cref="notificationIconSize"/>.</param>
		/// <remarks>
		/// If the tray icon isn't visible, makes it visible.
		/// 
		/// No more than one notification at a time can be displayed. If an application attempts to display a notification when one is already being displayed, the new notification is queued and displayed when the older notification goes away.
		/// 
		/// Users may choose to not show notifications, depending on various conditions. Look in Windows <b>Settings > System > Notifications</b>.
		/// </remarks>
		public void ShowNotification(string title, string text, TINFlags flags = 0, icon icon = default) {
			if (!_Update(n: new(title, text, flags, icon))) print.warning("ShowNotification() failed. " + lastError.message);
		}
		
		record class _Notification(string title, string text, TINFlags flags, icon icon);
		
		/// <summary>
		/// Hides notification.
		/// </summary>
		public void HideNotification() {
			lock (this) {
				if (_visible) Api.Shell_NotifyIcon(Api.NIM_MODIFY, _NewND(Api.NIF_INFO));
			}
		}
		
		/// <summary>
		/// Gets icon size for <see cref="ShowNotification"/>.
		/// </summary>
		public static int notificationIconSize {
			get {
				int r = Api.GetSystemMetrics(Api.SM_CXICON);
				if (osVersion.minWin10) r = r * 3 / 2;
				return r;
			}
		}
		
		/// <summary>
		/// Activates taskbar and makes the tray icon focused for keyboard.
		/// </summary>
		/// <remarks>
		/// If the tray icon is in hidden overflow area, makes the area button focused.
		/// </remarks>
		public void Focus() {
			lock (this) {
				Api.Shell_NotifyIcon(Api.NIM_SETFOCUS, _NewND());
			}
		}
		
		/// <summary>
		/// Together with <see cref="Hwnd"/> identifies this tray icon.
		/// </summary>
		protected int Id => _id;
		
		/// <summary>
		/// A hidden window automatically created for this tray icon to receive its notifications.
		/// </summary>
		protected internal wnd Hwnd => _w;
		
		/// <summary>
		/// Window procedure of the hidden window that receives tray icon notifications (<see cref="MsgNotify"/>) in version 4 format.
		/// If you override it, call the base function.
		/// </summary>
		protected virtual nint WndProc(wnd w, int msg, nint wParam, nint lParam) {
			if (_visible) {
				if (msg == MsgNotify) {
					int m = Math2.LoWord(lParam); POINT p = Math2.NintToPOINT(wParam);
					//if(m!=Api.WM_MOUSEMOVE) print.it(m, p);
					Message?.Invoke(new(m, p));
					switch (m) {
					case Api.WM_CONTEXTMENU:
						RightClick?.Invoke(new(m, p));
						break;
					case Api.NIN_SELECT: //mouse click or double click. After WM_LBUTTONUP.
					case Api.NIN_KEYSELECT: //Space, Enter (never mind bug: 2 NIN_KEYSELECT on Enter), DoDefaultAction
						Click?.Invoke(new(m, p));
						break;
					case Api.WM_MBUTTONUP:
						MiddleClick?.Invoke(new(m, p));
						break;
					case Api.NIN_BALLOONUSERCLICK:
						NotificationClick?.Invoke(new(m, p));
						break;
					case Api.NIN_POPUPOPEN: //tested: on Win10 only if no NIF_SHOWTIP, but on Win7 always
						if (_customPopup) _popupOpen?.Invoke(new(m, p));
						break;
					case Api.NIN_POPUPCLOSE:
						if (_customPopup) PopupClose?.Invoke(new(m, p));
						break;
					}
				} else if (msg == s_msgTaskbarCreated) { //explorer restarted or taskbar DPI changed
					_Update(taskbarCreated: true);
				}
			}
			
			var R = Api.DefWindowProc(w, msg, wParam, lParam);
			
			if (msg == Api.WM_NCDESTROY) {
				_Delete();
			}
			
			return R;
		}
		
		/// <summary>
		/// When received any message from the tray icon.
		/// </summary>
		/// <remarks>
		/// Receives mouse messages, <c>NIN_</c> messages and some other. See <ms>Shell_NotifyIconW</ms>.
		/// </remarks>
		public event Action<TIEventArgs> Message;
		
		/// <summary>
		/// When default action should be invoked (on click, <c>Space</c>/<c>Enter</c>, automation/accessibility API).
		/// </summary>
		/// <remarks>
		/// If clicked, the parameter contains message <c>NIN_SELECT</c> (1024) and mouse coordinates. Else <c>NIN_KEYSELECT</c> (1025) and top-left of the tray icon.
		/// On double click there are two <c>Click</c> events. To distinguish click and double click events, use <see cref="Message"/> instead.
		/// </remarks>
		public event Action<TIEventArgs> Click;
		
		/// <summary>
		/// When a context menu should be shown (on right click or <c>Apps</c> key).
		/// </summary>
		public event Action<TIEventArgs> RightClick;
		
		/// <summary>
		/// When the tray icon clicked with the middle button.
		/// </summary>
		[Obsolete("Does not work on Windows 11.")]
		public event Action<TIEventArgs> MiddleClick;
		
		/// <summary>
		/// When clicked the notification window.
		/// </summary>
		public event Action<TIEventArgs> NotificationClick;
		
		/// <summary>
		/// When it's time to close custom tooltip etc shown on <see cref="PopupOpen"/>.
		/// </summary>
		public event Action<TIEventArgs> PopupClose;
		
		/// <summary>
		/// When it's time to open custom tooltip or some temporary popup window.
		/// If this event is used, does not show standard tooltip.
		/// </summary>
		public event Action<TIEventArgs> PopupOpen {
			add => _SetPopupOpen(true, value);
			remove => _SetPopupOpen(false, value);
		}
		
		event Action<TIEventArgs> _popupOpen;
		bool _customPopup;
		
		void _SetPopupOpen(bool add, Action<TIEventArgs> a) {
			if (add) _popupOpen += a; else _popupOpen -= a;
			bool customPopup = _popupOpen != null;
			if (customPopup != _customPopup) {
				_customPopup = customPopup;
				if (_visible) Api.Shell_NotifyIcon(Api.NIM_MODIFY, _NewND(setTT: true));
			}
		}
		
		/// <summary>
		/// Gets tray icon rectangle in screen.
		/// </summary>
		/// <returns><c>false</c> if failed, for example if the icon is in hidden overflow area. Supports <see cref="lastError"/>.</returns>
		public unsafe bool GetRect(out RECT r) {
			var x = new Api.NOTIFYICONIDENTIFIER { cbSize = sizeof(Api.NOTIFYICONIDENTIFIER), hWnd = _w, uID = _id };
			//if (_guid!=default) x.guidItem=_guid;
			int hr = Api.Shell_NotifyIconGetRect(x, out r);
			if (hr == 0) return true;
			lastError.code = hr;
			return false;
		}
		
		//	public bool GetPopupRect(int width, int height) {
		//		if(!_visible) return false;
		//		//what if hidden in overflow area? Then should not show popup. Then OS does not show notifications.
		//		//CalculatePopupWindowPosition
		//	}
	}
}

namespace Au.Types {
	/// <summary>
	/// Flags for <see cref="trayIcon.ShowNotification"/>. See <c>NIIF_</c> flags of API <ms>NOTIFYICONDATAW</ms>.
	/// </summary>
	[Flags]
	public enum TINFlags {
#pragma warning disable 1591 //no doc
		InfoIcon = 1,
		WarningIcon,
		ErrorIcon,
		//UserIcon,
		NoSound = 0x10,
		//LargeIcon=0x20,
		//RespectQuietTime=0x80,
#pragma warning restore
		
		/// <summary>
		/// Flag <c>NIF_REALTIME</c>.
		/// </summary>
		Realtime = 0x10000000,
	}
	
#pragma warning disable 1591
	public record class TIEventArgs(int Message, POINT XY);
#pragma warning restore
	
}

================================================
FILE: Au/GUI/wpf-types.cs
================================================
using System.Windows;
using System.Windows.Controls;
using System.Windows.Controls.Primitives;
using System.Windows.Input;
using System.Windows.Documents;
using System.Windows.Media;

namespace Au.Types {
	
	/// <summary>
	/// Used with <see cref="wpfBuilder"/> constructor to specify the type of the root panel.
	/// </summary>
	public enum WBPanelType {
		///
		Grid,
		///
		Canvas,
		///
		Dock,
		///
		VerticalStack,
		///
		HorizontalStack,
	}
	
	/// <summary>
	/// Flags for obsolete <see cref="wpfBuilder.Add"/> overloads.
	/// </summary>
	[Flags]
	[EditorBrowsable(EditorBrowsableState.Never)]
	public enum WBAdd {
		/// <summary>
		/// Add as child of <see cref="wpfBuilder.Last"/>, which can be of type (or base type):
		/// <br/>• <see cref="ContentControl"/>. Adds as its <see cref="ContentControl.Content"/> property. For example you can add a <c>CheckBox</c> in a <c>Button</c>.
		/// <br/>• <see cref="Decorator"/>, for example <see cref="Border"/>. Adds as its <see cref="Decorator.Child"/> property.
		/// </summary>
		ChildOfLast = 1,
		
		/// <summary>
		/// Don't adjust properties of the element, except margin. By default it adjusts padding, alignment, etc, and properties specified in <see cref="wpfBuilder.Options"/>.
		/// </summary>
		DontSetProperties = 2,
	}
	
	/// <summary>
	/// Used with <see cref="wpfBuilder"/> functions for width/height parameters. Allows to specify minimal and/or maximal values too.
	/// </summary>
	/// <remarks>
	/// Has implicit conversions from <c>double</c>, <see cref="Range"/> and tuple <c>(double length, Range minMax)</c>.
	/// To specify width or height, pass an <c>int</c> or <c>double</c> value, like <c>100</c> or <c>15.25</c>.
	/// To specify minimal value, pass a range like <c>100..</c>.
	/// To specify maximal value, pass a range like <c>..100</c>.
	/// To specify minimal and maximal values, pass a range like <c>100..500</c>.
	/// To specify width or height and minimal or/and maximal values, pass a tuple like <c>(100, 50..)</c> or <c>(100, ..200)</c> or <c>(100, 50..200)</c>.
	/// </remarks>
	public struct WBLength {
		double _v;
		Range _r;
		
		WBLength(double v, Range r) {
			if (r.Start.IsFromEnd || (r.End.IsFromEnd && r.End.Value != 0)) throw new ArgumentException();
			_v = v; _r = r;
		}
		
		///
		public static implicit operator WBLength(double v) => new WBLength { _v = v, _r = .. };
		
		///
		public static implicit operator WBLength(Range v) => new WBLength(double.NaN, v);
		
		///
		public static implicit operator WBLength((double length, Range minMax) v) => new WBLength(v.length, v.minMax);
		
		/// <summary>
		/// Gets the width or height value. Returns <c>false</c> if not set.
		/// </summary>
		public bool GetLength(out double value) {
			value = _v;
			return !double.IsNaN(_v);
		}
		
		/// <summary>
		/// Gets the minimal value. Returns <c>false</c> if not set.
		/// </summary>
		public bool GetMin(out int value) {
			value = _r.Start.Value;
			return value > 0;
		}
		
		/// <summary>
		/// Gets the maximal value. Returns <c>false</c> if not set.
		/// </summary>
		public bool GetMax(out int value) {
			value = _r.End.Value;
			return !_r.End.IsFromEnd;
		}
		
		/// <summary>
		/// Sets <c>Width</c> or <c>Height</c> or/and <c>MinWidth</c>/<c>MinHeight</c> or/and <c>MaxWidth</c>/<c>MaxHeight</c> of the <see cref="FrameworkElement"/>.
		/// </summary>
		/// <param name="e">Element.</param>
		/// <param name="height">Set <c>Height</c>. If <c>false</c>, sets <c>Width</c>.</param>
		public void ApplyTo(FrameworkElement e, bool height) {
			if (GetLength(out double d)) { if (height) e.Height = d; else e.Width = d; }
			if (GetMin(out int i)) { if (height) e.MinHeight = i; else e.MinWidth = i; }
			if (GetMax(out i)) { if (height) e.MaxHeight = i; else e.MaxWidth = i; }
		}
	}
	
	/// <summary>
	/// Used with <see cref="wpfBuilder"/> functions to specify width/height of columns and rows. Allows to specify minimal and/or maximal values too.
	/// </summary>
	/// <remarks>
	/// Like <see cref="WBLength"/>, but has functions to create <see cref="ColumnDefinition"/> and <see cref="RowDefinition"/>. Also has implicit conversion from these types.
	/// </remarks>
	public struct WBGridLength {
		double _v;
		Range _r;
		DefinitionBase _def;
		
		WBGridLength(double v, Range r) {
			if (r.Start.IsFromEnd || (r.End.IsFromEnd && r.End.Value != 0)) throw new ArgumentException();
			_v = v; _r = r; _def = null;
		}
		
		///
		public static implicit operator WBGridLength(double v) => new WBGridLength { _v = v, _r = .. };
		
		///
		public static implicit operator WBGridLength((double length, Range minMax) v) => new WBGridLength(v.length, v.minMax);
		
		///
		public static implicit operator WBGridLength(Range v) => new WBGridLength(-1, v);
		
		///
		public static implicit operator WBGridLength(DefinitionBase v) => new WBGridLength { _def = v };
		
		/// <summary>
		/// Creates column definition object from assigned width or/and min/max width values. Or just returns the assigned or previously created object.
		/// </summary>
		public ColumnDefinition Column {
			get {
				if (_def is ColumnDefinition d) return d;
				d = new ColumnDefinition { Width = _GridLength(_v) };
				if (_r.Start.Value > 0) d.MinWidth = _r.Start.Value;
				if (!_r.End.IsFromEnd) d.MaxWidth = _r.End.Value;
				_def = d;
				return d;
			}
		}
		
		/// <summary>
		/// Creates row definition object from assigned height or/and min/max height values. Or just returns the assigned or previously created object.
		/// </summary>
		public RowDefinition Row {
			get {
				if (_def is RowDefinition d) return d;
				d = new RowDefinition { Height = _GridLength(_v) };
				if (_r.Start.Value > 0) d.MinHeight = _r.Start.Value;
				if (!_r.End.IsFromEnd) d.MaxHeight = _r.End.Value;
				_def = d;
				return d;
			}
		}
		
		GridLength _GridLength(double d) {
			if (d > 0) return new GridLength(d, GridUnitType.Pixel);
			if (d < 0) return new GridLength(-d, GridUnitType.Star);
			return new GridLength();
		}
	}
	
	/// <summary>
	/// Arguments for <see cref="wpfBuilder.AlsoAll"/> callback function.
	/// </summary>
	public class WBAlsoAllArgs {
		/// <summary>
		/// Gets 0-based column index of last added control, or -1 if not in grid.
		/// </summary>
		public int Column { get; internal set; }
		
		/// <summary>
		/// Gets 0-based row index of last added control, or -1 if not in grid.
		/// </summary>
		public int Row { get; internal set; }
	}
	
	/// <summary>
	/// Arguments for <see cref="wpfBuilder.AddButton"/> callback function.
	/// </summary>
	public class WBButtonClickArgs : CancelEventArgs {
		/// <summary>
		/// Gets the button.
		/// </summary>
		public Button Button { get; internal set; }
		
		/// <summary>
		/// Gets the window.
		/// </summary>
		public Window Window { get; internal set; }
	}
	
	/// <summary>
	/// Flags for <see cref="wpfBuilder.AddButton"/>.
	/// </summary>
	[Flags]
	public enum WBBFlags {
		/// <summary>It is <b>OK</b> button (<see cref="Button.IsDefault"/>, closes window, validates, <see cref="wpfBuilder.OkApply"/> event).</summary>
		OK = 1,
		
		/// <summary>It is <b>Cancel</b> button (<see cref="Button.IsCancel"/>, closes window).</summary>
		Cancel = 2,
		
		/// <summary>It is <b>Apply</b> button (size like <b>OK</b>/<b>Cancel</b>, validates, <see cref="wpfBuilder.OkApply"/> event).</summary>
		Apply = 4,
		
		/// <summary>Perform validation like <b>OK</b> and <b>Apply</b> buttons.</summary>
		Validate = 8,
	}
	
	/// <summary>
	/// Obsolete.
	/// Can be used with <see cref="wpfBuilder.Text"/> to add a hyperlink.
	/// </summary>
	[EditorBrowsable(EditorBrowsableState.Never)] //obsolete
	public class WBLink {
		///
		public Hyperlink Hlink { get; }
		
		WBLink(string text, bool bold) {
			Run run = new(text);
			Hlink = new(bold ? new Bold(run) : run);
		}
		
		/// <summary>
		/// Sets link text and action.
		/// </summary>
		public WBLink(string text, Action action, bool bold = false) : this(text, bold) {
			Hlink.Click += (o, e) => action();
		}
		
		/// <summary>
		/// Sets link text and action.
		/// </summary>
		/// <param name="text">Link text.</param>
		/// <param name="action">Action to execute on click.</param>
		/// <param name="bold">Bold font.</param>
		public WBLink(string text, Action<Hyperlink> action, bool bold = false) : this(text, bold) {
			Hlink.Click += (o, e) => action(o as Hyperlink);
		}
		
		/// <summary>
		/// Sets link text and target URL or file etc.
		/// On click will call <see cref="run.itSafe"/>.
		/// </summary>
		/// <param name="text">Link text.</param>
		/// <param name="urlOrPath">URL or path for <see cref="run.itSafe"/>. If <c>null</c>, uses <i>text</i>.</param>
		/// <param name="args"><i>args</i> for <see cref="run.itSafe"/>.</param>
		/// <param name="bold">Bold font.</param>
		public WBLink(string text, string urlOrPath = null, string args = null, bool bold = false) : this(text, _ => run.itSafe(urlOrPath ?? text, args)) { }
	}
}

namespace Au.More {
	//rejected. Unsafe etc. For example, when assigning to object, uses CheckBool whereas the user may expect bool.
	//	/// <summary>
	//	/// <see cref="CheckBox"/> that can be used like bool.
	//	/// For example instead of <c>if(c.IsChecked == true)</c> can be used <c>if(c)</c>.
	//	/// </summary>
	//	public class CheckBool : CheckBox
	//	{
	//		///
	//		public CheckBool()
	//		{
	//			this.SetResourceReference(StyleProperty, typeof(CheckBox));
	//		}
	//
	//		/// <summary>
	//		/// Returns true if <see cref="ToggleButton.IsChecked"/> == true.
	//		/// </summary>
	//		public static implicit operator bool(CheckBool c) => c.IsChecked.GetValueOrDefault();
	//	}
	
	
	/// <summary>
	/// Grid splitter control. Based on <see cref="GridSplitter"/>, changes its behavior.
	/// </summary>
	/// <remarks>
	/// Try this class when <see cref="GridSplitter"/> does not work as you want.
	/// 
	/// Limitations (bad or good):
	/// - Splitters must be on own rows/columns. Throws exception if <c>ResizeBehavior</c> is not <c>PreviousAndNext</c> (which is default).
	/// - Throws exception is there are star-sized splitter rows.
	/// - Does not resize auto-sized rows/columns. Only pixel-sized and star-sized.
	/// - With <c>UseLayoutRounding</c> may flicker when resizing, especially when high DPI.
	/// </remarks>
	public class GridSplitter2 : GridSplitter {
		static GridSplitter2() {
			EventManager.RegisterClassHandler(typeof(GridSplitter2), Thumb.DragStartedEvent, new DragStartedEventHandler(_OnDragStarted));
			EventManager.RegisterClassHandler(typeof(GridSplitter2), Thumb.DragCompletedEvent, new DragCompletedEventHandler(_OnDragCompleted));
			EventManager.RegisterClassHandler(typeof(GridSplitter2), Thumb.DragDeltaEvent, new DragDeltaEventHandler(_OnDragDelta));
		}
		
		///
		public GridSplitter2() {
			ResizeBehavior = GridResizeBehavior.PreviousAndNext;
			SnapsToDevicePixels = true;
			Focusable = false;
		}
		
		static void _OnDragStarted(object sender, DragStartedEventArgs e) => (sender as GridSplitter2)._OnDragStarted(e);
		
		void _OnDragStarted(DragStartedEventArgs e) {
			if (!ShowsPreview) e.Handled = true;
			if (!_Init()) base.CancelDrag();
		}
		
		static void _OnDragCompleted(object sender, DragCompletedEventArgs e) => (sender as GridSplitter2)._OnDragCompleted(e);
		
		void _OnDragCompleted(DragCompletedEventArgs e) {
			if (!ShowsPreview) e.Handled = true; //else somehow GridSplitter does not resize, just removes the adorner
			if (_a == null) return; //two events if called CancelDrag
			if (!e.Canceled) _MoveSplitter();
			_a = null;
		}
		
		static void _OnDragDelta(object sender, DragDeltaEventArgs e) => (sender as GridSplitter2)._OnDragDelta(e);
		
		void _OnDragDelta(DragDeltaEventArgs e) {
			_delta = _isVertical ? e.HorizontalChange : e.VerticalChange;
			var di = DragIncrement; _delta = Math.Round(_delta / di) * di;
			if (ShowsPreview) return;
			e.Handled = true;
			if (_working) return; _working = true; //avoid too much CPU and delayed repainting of hwndhosts
			Dispatcher.InvokeAsync(() => _working = false, System.Windows.Threading.DispatcherPriority.ApplicationIdle);
			_MoveSplitter();
		}
		bool _working;
		
		///
		protected override void OnKeyDown(KeyEventArgs e) {
			if (e.Key == Key.Up || e.Key == Key.Down || e.Key == Key.Left || e.Key == Key.Right) {
				e.Handled = true;
				if (!_Init()) return;
				_delta = KeyboardIncrement * ((e.Key == Key.Up || e.Key == Key.Right) ? -1 : 1);
				if (_isVertical && FlowDirection == FlowDirection.RightToLeft) _delta = -_delta;
				_MoveSplitter();
				_a = null;
			} else if (e.Key == Key.Escape && _a != null) {
				e.Handled = true;
				CancelDrag();
			}
		}
		
		bool _Init(Key key = default) {
			_a = null;
			_isVertical = _IsVertical();
			if (key != default && _isVertical != (key == Key.Left || key == Key.Right)) return false;
			//_resizeBehavior=_GetResizeBehavior(_isVertical);
			if (_GetResizeBehavior(_isVertical) != GridResizeBehavior.PreviousAndNext) throw new NotSupportedException("ResizeBehavior must be PreviousAndNext.");
			_delta = 0;
			_grid = Parent as Grid;
			_a = new List<_RowCol>();
			_index = 0;
			var splitters = _grid.Children.OfType<GridSplitter2>()
				.Where(o => o._IsVertical() == _isVertical)
				.Select(o => _IndexInGrid(o)).ToArray();
			int index = _IndexInGrid(this);
			for (int i = 0, n = (_isVertical ? _grid.ColumnDefinitions.Count : _grid.RowDefinitions.Count); i < n; i++) {
				var v = new _RowCol(_isVertical ? (DefinitionBase)_grid.ColumnDefinitions[i] : _grid.RowDefinitions[i]);
				if (splitters.Contains(i)) {
					if (v.IsStar) throw new InvalidOperationException("Splitter row/column cannot be star-sized.");
					if (i == index) _index = _a.Count;
				} else {
					if (v.Unit == GridUnitType.Auto) continue;
					if (v.IsStar) v.SetSize(v.ActualSize);
					_a.Add(v);
				}
			}
			if (_index == 0 || _index == _a.Count) { //no resizable items before or after
				_a = null;
				return false;
			}
			return true;
		}
		
		Grid _grid;
		bool _isVertical;
		//	GridResizeBehavior _resizeBehavior;
		List<_RowCol> _a; //resizable rows/columns, ie those without splitters and not auto-sized
		int _index; //index of first _a item after this splitter
		double _delta;
		
		void _MoveSplitter() {
			if (_a == null || _delta == 0) return;
			
			_Side before = default, after = default;
			
			//resize multiple star-sized items at that side?
			if (ResizeNearest || Keyboard.Modifiers == ModifierKeys.Control) {
				before.single = after.single = true;
			} else {
				int stars = 0; //flags: 1 stars before, 2 stars after
				for (int i = 0; i < _a.Count; i++) if (_a[i].IsStar) stars |= i < _index ? 1 : 2;
				before.single = _index == 1 || 0 == (stars & 1) || _a[_index - 1].ActualSize < 4 || (stars == 3 && !_a[_index - 1].IsStar); //without the last || subexpression would be impossible to resize fixed-sized items if there are star-sized items at both sides
				after.single = _index == _a.Count - 1 || 0 == (stars & 2) || _a[_index].ActualSize < 4 || (stars == 3 && !_a[_index].IsStar);
			}
			
			for (int i = 0; i < _a.Count; i++) {
				if (!_IsResizable(i)) continue;
				if (i < _index) before.Add(_a[i]); else after.Add(_a[i]);
			}
			
			double v1 = Math.Clamp(before.size + _delta, before.min, before.max), v2 = Math.Clamp(after.size - _delta, after.min, after.max);
			_delta = 0;
			if (v1 == before.min || v1 == before.max) v2 = before.size + after.size - v1; else if (v2 == after.min || v2 == after.max) v1 = before.size + after.size - v2;
			
			_ResizeSide(before, true, v1);
			_ResizeSide(after, false, v2);
			
			void _ResizeSide(_Side side, bool isBefore, double size) {
				if (side.single) {
					_a[_index - (isBefore ? 1 : 0)].SetSize(size);
				} else {
					for (int i = isBefore ? 0 : _index, to = isBefore ? _index : _a.Count; i < to; i++) {
						if (!_IsResizable(i)) continue;
						var v = _a[i];
						var k = size * v.ActualSize; if (side.size > 0.1) k /= side.size; else k = 0.1;
						v.SetSize(k);
					}
				}
			}
			
			bool _IsResizable(int index) {
				if (index < _index) return before.single ? index == _index - 1 : _a[index].IsStar;
				return after.single ? index == _index : _a[index].IsStar;
			}
		}
		
		struct _Side {
			public double size, min, max;
			public bool single;
			public int stars;
			
			public void Add(_RowCol v) {
				size += v.ActualSize;
				min += v.Min;
				double x = v.Max;
				if (max != double.PositiveInfinity) { if (x == double.PositiveInfinity) max = x; else max += x; }
				if (!single && v.IsStar) stars++;
			}
		}
		
		/// <summary>
		/// Always resize only the nearest resizable row/column at each side.
		/// If <c>false</c> (default), may resize multiple star-sized rows/columns, unless with <c>Ctrl</c> key.
		/// </summary>
		public bool ResizeNearest { get; set; }
		
		#region util
		
		bool _IsVertical() { //see code of GridSplitter.GetEffectiveResizeDirection. The algorithm is documented.
			var dir = this.ResizeDirection;
			if (dir != GridResizeDirection.Auto) return dir == GridResizeDirection.Columns;
			if (this.HorizontalAlignment != HorizontalAlignment.Stretch) return true;
			if (this.VerticalAlignment != VerticalAlignment.Stretch) return false;
			return this.ActualWidth <= this.ActualHeight;
		}
		
		GridResizeBehavior _GetResizeBehavior(bool vertical) { //see code of GridSplitter.GetEffectiveResizeBehavior
			var r = ResizeBehavior;
			if (r == GridResizeBehavior.BasedOnAlignment) {
				if (vertical) r = HorizontalAlignment switch {
					HorizontalAlignment.Left => GridResizeBehavior.PreviousAndCurrent,
					HorizontalAlignment.Right => GridResizeBehavior.CurrentAndNext,
					_ => GridResizeBehavior.PreviousAndNext,
				};
				else r = VerticalAlignment switch {
					VerticalAlignment.Top => GridResizeBehavior.PreviousAndCurrent,
					VerticalAlignment.Bottom => GridResizeBehavior.CurrentAndNext,
					_ => GridResizeBehavior.PreviousAndNext,
				};
			}
			return r;
		}
		
		int _IndexInGrid(UIElement e) => _isVertical ? Grid.GetColumn(e) : Grid.GetRow(e);
		
		class _RowCol {
			RowDefinition _row;
			ColumnDefinition _col;
			
			public _RowCol(DefinitionBase def) {
				_row = def as RowDefinition;
				_col = def as ColumnDefinition;
				Min = _row?.MinHeight ?? _col.MinWidth;
				Max = _row?.MaxHeight ?? _col.MaxWidth;
				Unit = DefSizeGL.GridUnitType;
			}
			
			public double ActualSize => _row?.ActualHeight ?? _col.ActualWidth;
			
			public double DefSize {
				get => _row?.Height.Value ?? _col.Width.Value;
				//			set { DefSizeGL = new GridLength(value, Unit); }
			}
			
			GridLength DefSizeGL {
				get => _row?.Height ?? _col.Width;
				//			set { if(_row!=null) _row.Height=value; else _col.Width=value; }
			}
			
			public void SetSize(double size) {
				var z = new GridLength(size, Unit);
				if (_row != null) _row.Height = z; else _col.Width = z;
			}
			
			public GridUnitType Unit { get; private set; }
			
			public bool IsStar => Unit == GridUnitType.Star;
			
			public double Min { get; private set; }
			
			public double Max { get; private set; }
		}
		
		#endregion
	}
	
	/// <summary>
	/// Adorner that draws watermark/hint/cue text over the adorned control (<see cref="TextBox"/> etc).
	/// </summary>
	public class WatermarkAdorner : Adorner {
		string _text;
		Control _c;
		TextBox _tCB;
		
		/// <summary>
		/// Initializes and adds this adorner to the <see cref="AdornerLayer"/> found by <see cref="AdornerLayer.GetAdornerLayer"/>.
		/// </summary>
		/// <param name="c">The control.</param>
		/// <param name="text">Watermark text.</param>
		/// <remarks>
		/// In some kinds of windows it may not work unless a parent or ancestor of the control is an <see cref="AdornerDecorator"/>.
		/// </remarks>
		public WatermarkAdorner(Control c, string text) : base(c) {
			_c = c;
			_text = text;
			IsHitTestVisible = false;
			if (AdornerLayer.GetAdornerLayer(c) is { } layer) layer.Add(this);
			else c.Loaded += (_, _) => { AdornerLayer.GetAdornerLayer(c)?.Add(this); }; //the Window or some ancestor element usually has an AdornerLayer in its template, which now probably still not applied
		}
		
		/// <summary>
		/// Gets or sets watermark text.
		/// </summary>
		public string Text {
			get => _text;
			set {
				if (value != _text) {
					_text = value;
					InvalidateVisual();
				}
			}
		}
		
		/// <summary>
		/// Sets events to show/hide the adorner depending on control text.
		/// The control must be <see cref="TextBox"/>, <see cref="PasswordBox"/> or editable <see cref="ComboBox"/>.
		/// </summary>
		public void SetAdornerVisibility() {
			if (_c is TextBox t) {
				_VisibilityT(t);
			} else if (_c is PasswordBox p) {
				_VisibilityP(p);
			} else {
				if (_c.IsLoaded) _OfChildTB();
				else _c.Loaded += (_, _) => { _OfChildTB(); };
				
				void _OfChildTB() { if (_c.FindVisualDescendant(o => o is TextBox) is TextBox t2) _VisibilityT(_tCB = t2); }
			}
			
			void _VisibilityT(TextBox t) {
				Visibility = t.Text.NE() ? Visibility.Visible : Visibility.Hidden;
				t.TextChanged += (_, _) => { Visibility = t.Text.NE() ? Visibility.Visible : Visibility.Hidden; };
			}
			
			void _VisibilityP(PasswordBox t) {
				Visibility = t.Password.NE() ? Visibility.Visible : Visibility.Hidden;
				t.PasswordChanged += (_, _) => { Visibility = t.Password.NE() ? Visibility.Visible : Visibility.Hidden; };
			}
		}
		
		///
		protected override void OnRender(DrawingContext dc) {
			if (_text.NE()) return;
			var tf = new Typeface(_c.FontFamily, _c.FontStyle, _c.FontWeight, _c.FontStretch);
			var ft = new FormattedText(_text, CultureInfo.CurrentCulture, FlowDirection.LeftToRight, tf, _c.FontSize, Brushes.DarkGray, 96);
			Thickness bt = _c.BorderThickness, pad = _c.Padding;
			Point p = new(bt.Left + pad.Left + 2, bt.Top + pad.Top);
			var z = _c.RenderSize;
			double w = z.Width - bt.Right - pad.Right - 2, h = z.Height - bt.Bottom - pad.Bottom;
			if (_tCB != null) w = _tCB.RenderSize.Width;
			if (w < 4 || h < 4) return;
			dc.PushClip(new RectangleGeometry(new(0, 0, w, h)));
			dc.DrawText(ft, p);
			dc.Pop();
		}
	}
}


================================================
FILE: Au/GUI/wpfBuilder.cs
================================================
using System.Windows;
using System.Windows.Controls;
using System.Windows.Controls.Primitives;
using System.Windows.Documents;
using System.Windows.Media;
using System.Windows.Data;
using System.Windows.Input;
using System.Xml.Linq;
//for <see>
using C = System.Windows.Controls;
using W = System.Windows;
using D = System.Windows.Documents;

//never mind: on Win7 text of all WPF checkboxes too low by 1 pixel. Not only of wpfBuilder.

namespace Au;

#pragma warning disable WPF0001 //enable ThemeMode

/// <summary>
/// With this class you can create windows with controls, for example for data input.
/// </summary>
/// <remarks>
/// This class uses WPF (Windows Presentation Foundation). Creates window at run time. No designer. No WPF and XAML knowledge required, unless you want something advanced.
/// 
/// To start, use snippet <c>wpfDialogSnippet</c> or menu <b>File > New > Dialogs</b>. Also look in Cookbook.
/// 
/// Most functions return <c>this</c>, to enable method chaining, aka fluent interface, like with <see cref="StringBuilder"/>. See example.
/// 
/// A <c>wpfBuilder</c> object can be used to create whole window or some window part, for example a tab page.
/// 
/// The size/position unit in WPF is about 1/96 inch, regardless of screen DPI. For example, if DPI is 96 (100%), 1 unit = 1 physical pixel; if 150% - 1.5 pixel; if 200% - 2 pixels. WPF windows are DPI-scaled automatically when need. Your program's manifest should contain <c>dpiAware=true/PM</c> and <c>dpiAwareness=PerMonitorV2</c>; it is default for scripts/programs created with the script editor of this library.
/// 
/// Note: WPF starts slowly and uses much memory. It is normal if to show the first window in process takes 500-1000 ms and the process uses 30 MB of memory, whereas WinForms takes 250 ms / 10 MB and native takes 50 ms / 2 MB. However WinForms becomes slower than WPF if there are more than 100 controls in window. This library uses WPF because it is the most powerful and works well with high DPI screens.
/// 
/// WPF has many control types, for example <see cref="Button"/>, <see cref="CheckBox"/>, <see cref="TextBox"/>, <see cref="ComboBox"/>, <see cref="Label"/>. Most are in namespaces <c>System.Windows.Controls</c> and <c>System.Windows.Controls.Primitives</c>. Also on the internet you can find many libraries containing WPF controls and themes. For example, search for <i>github awesome dotnet C#</i>. Many libraries are open-source, and most can be found in GitHub (source, info and sometimes compiled files). Compiled files usually can be found in <see href="https://www.nuget.org/"/> as packages. Use menu <b>Tools > NuGet</b>.
/// 
/// By default don't need XAML. When need, you can load XAML strings and files with <see cref="System.Windows.Markup.XamlReader"/>.
/// </remarks>
/// <example>
/// Dialog window with several controls for data input.
/// <code><![CDATA[
/// var b = new wpfBuilder("Example").WinSize(400); //create Window object with Grid control; set window width 400
/// b.R.Add("Text", out TextBox text1).Focus(); //add label and text box control in first row
/// b.R.Add("Combo", out ComboBox combo1).Items("One|Two|Three"); //in second row add label and combo box control with items
/// b.R.Add(out CheckBox c1, "Check"); //in third row add check box control
/// b.R.AddOkCancel(); //finally add standard OK and Cancel buttons
/// b.End();
/// if (!b.ShowDialog()) return; //show the dialog and wait until closed; return if closed not with OK button
/// print.it(text1.Text, combo1.SelectedIndex, c1.IsChecked == true); //get user input from control variables
/// ]]></code>
/// </example>
public class wpfBuilder {
	//readonly FrameworkElement _container; //now used only in ctor
	readonly Window _window; //= _container or null
	_PanelBase _p; //current grid/stack/dock/canvas panel, either root or nested
	
	class _PanelBase {
		protected readonly wpfBuilder _b;
		public readonly _PanelBase parent;
		public readonly Panel panel;
		FrameworkElement _lastAdded, _lastAdded2;
		public bool ended;
		
		public _PanelBase(wpfBuilder b, Panel p) {
			_b = b;
			parent = b._p;
			_lastAdded = panel = p;
		}
		
		public virtual void BeforeAdd(bool childOfLast) {
			if (ended) throw new InvalidOperationException("Cannot add after End()");
			if (childOfLast && _lastAdded == panel) throw new ArgumentException("Cannot add as child. The last element is panel.");
		}
		
		public virtual void Add(FrameworkElement c) {
			SetLastAdded(c);
			panel.Children.Add(c);
		}
		
		public virtual void End() { ended = true; }
		
		public FrameworkElement LastAdded => _lastAdded;
		
		public FrameworkElement LastAdded2 => _lastAdded2;
		
		public void SetLastAdded(FrameworkElement e) {
			if (_lastAdded != panel) _lastAdded2 = _lastAdded;
			_lastAdded = e;
		}
		
		public FrameworkElement LastDirect {
			get {
				if (_lastAdded == panel) {
					Debug_.Print("lastAdded == panel");
					return null;
				}
				for (var c = _lastAdded; ;) {
					var pa = c.Parent as FrameworkElement;
					if (pa == panel) return c;
					c = pa;
				}
			}
		}
	}
	
	class _Canvas : _PanelBase {
		public _Canvas(wpfBuilder b, Canvas c = null) : base(b, c ?? new Canvas()) {
			panel.HorizontalAlignment = HorizontalAlignment.Left;
			panel.VerticalAlignment = VerticalAlignment.Top;
		}
	}
	
	class _DockPanel : _PanelBase {
		public _DockPanel(wpfBuilder b) : base(b, new DockPanel()) {
		}
	}
	
	class _StackPanel : _PanelBase {
		public _StackPanel(wpfBuilder b, bool vertical) : base(b, new StackPanel { Orientation = vertical ? Orientation.Vertical : Orientation.Horizontal }) {
		}
	}
	
	class _Grid : _PanelBase {
		readonly Grid _grid; //same as panel, just to avoid casting everywhere
		int _row = -1, _col;
		bool _isSpan;
		double? _andWidth;
		
		public _Grid(wpfBuilder b, Grid g = null) : base(b, g ?? new Grid()) {
			_grid = panel as Grid;
			if (gridLines) _grid.ShowGridLines = true;
		}
		
		public void Row(WBGridLength height) {
			if (_andWidth != null) throw new InvalidOperationException("And().Row()");
			if (_row >= 0) {
				_SetLastSpan();
				_col = 0;
			} else if (_grid.ColumnDefinitions.Count == 0) {
				_grid.ColumnDefinitions.Add(new ColumnDefinition { Width = new GridLength(0, GridUnitType.Auto) });
				_grid.ColumnDefinitions.Add(new ColumnDefinition());
			}
			_row++;
			_grid.RowDefinitions.Add(height.Row);
		}
		
		public override void BeforeAdd(bool childOfLast) {
			base.BeforeAdd(childOfLast);
			if (childOfLast) return;
			if (_row < 0 || _col >= _grid.ColumnDefinitions.Count) Row(0);
			_isSpan = false;
		}
		
		public override void Add(FrameworkElement c) {
			if (_andWidth != null) {
				var width = _andWidth.Value; _andWidth = null;
				if (width < 0) {
					var m = c.Margin;
					m.Left += -width + 3;
					c.Margin = m;
				} else if (width > 0) {
					c.Width = width;
					c.HorizontalAlignment = HorizontalAlignment.Right;
				}
				var last = LastDirect;
				Grid.SetColumn(c, Grid.GetColumn(last));
				Grid.SetColumnSpan(c, Grid.GetColumnSpan(last));
				_isSpan = true;
			} else {
				Grid.SetColumn(c, _col);
			}
			_col++;
			Grid.SetRow(c, _row);
			base.Add(c);
		}
		
		public void And(double width) {
			if (_col == 0 || _andWidth != null || LastAdded == panel) throw new InvalidOperationException("And()");
			var c = LastDirect;
			if (width < 0) {
				c.Width = -width;
				c.HorizontalAlignment = HorizontalAlignment.Left;
			} else if (width > 0) {
				var m = c.Margin;
				m.Right += width + 3;
				c.Margin = m;
			}
			_andWidth = width;
			_col--;
		}
		
		public void Span(int span) {
			if (_col == 0) throw new InvalidOperationException("Span() at row start");
			int cc = _grid.ColumnDefinitions.Count;
			_col--;
			if (span != 0) { //if 0, will add 2 controls in 1 cell
				if (span < 0 || _col + span > cc) span = cc - _col;
				Grid.SetColumnSpan(LastDirect, span);
				_col += span;
			}
			_isSpan = true;
		}
		
		//If not all row cells filled, let the last control span all remaining cells, unless its span specified explicitly.
		void _SetLastSpan() {
			if (!_isSpan && _row >= 0 && _col > 0) {
				int n = _grid.ColumnDefinitions.Count - _col;
				if (n > 0) Grid.SetColumnSpan(LastDirect, n + 1);
			}
			_isSpan = false;
		}
		
		public void Skip(int span = 1) {
			BeforeAdd(false);
			_col += span;
			_isSpan = true;
		}
		
		public override void End() {
			base.End();
			_SetLastSpan();
		}
		
		public (int column, int row) NextCell => (_col, _row);
	}
	
	#region current panel
	
	/// <summary>
	/// Ends adding controls etc to the window or nested panel (<see cref="StartGrid"/> etc).
	/// </summary>
	/// <remarks>
	/// Always call this method to end a nested panel. For root panel it is optional if using <see cref="ShowDialog"/>.
	/// </remarks>
	public wpfBuilder End() {
		if (!_p.ended) {
			_p.End();
			if (_p.parent != null) {
				_p = _p.parent;
			} else {
#if NET9_0_OR_GREATER
				if (_unGray && _window is { } w && w.ThemeMode != ThemeMode.None && w.Background == SystemColors.ControlBrush) w.Background = null;
#endif
			}
		}
		return this;
	}
	
	/// <summary>
	/// Sets column count and widths of current grid.
	/// </summary>
	/// <param name="widths">
	/// Column widths.
	/// An argument can be:
	/// <br/>• <c>int</c> or <c>double</c> - <see cref="ColumnDefinition.Width"/>. Value 0 means auto-size. Negative value is star-width, ie fraction of total width of star-sized columns. Examples: <c>50</c>, <c>-0.5</c>.
	/// <br/>• <see cref="Range"/> - <see cref="ColumnDefinition.MinWidth"/> and/or <see cref="ColumnDefinition.MaxWidth"/>. Sets width value = -1 (star-sized). Examples: <c>50..150</c>, <c>50..</c> or <c>..150</c>.
	/// <br/>• tuple <c>(double value, Range minMax)</c> - width and min/max widths. Example: <c>(-2, 50..)</c>.
	/// <br/>• <see cref="ColumnDefinition"/>.
	/// </param>
	/// <exception cref="InvalidOperationException">Columns() in non-grid panel or after an <c>Add</c> function.</exception>
	/// <remarks>
	/// If this function not called, the table has 2 columns like <c>.Columns(0, -1)</c>.
	/// 
	/// If there are star-sized columns, should be set width of the grid or of its container. Call <see cref="Width"/> or <see cref="Size"/> or <see cref="WinSize"/>. But if the grid is in a cell of another grid, usually it's better to set column width of that grid to a non-zero value, ie let it be not auto-sized.
	/// </remarks>
	public wpfBuilder Columns(params WBGridLength[] widths) {
		var g = Last as Grid ?? throw new InvalidOperationException("Columns() in wrong place");
		g.ColumnDefinitions.Clear();
		foreach (var v in widths) g.ColumnDefinitions.Add(v.Column);
		return this;
	}
	
	/// <summary>
	/// Starts new row in current grid.
	/// </summary>
	/// <param name="height">
	/// Row height. Can be:
	/// <br/>• <c>int</c> or <c>double</c> - <see cref="RowDefinition.Height"/>. Value 0 means auto-size. Negative value is star-width, ie fraction of total height of star-sized rows. Examples: <c>50</c>, <c>-0.5</c>.
	/// <br/>• <see cref="Range"/> - <see cref="RowDefinition.MinHeight"/> and/or <see cref="RowDefinition.MaxHeight"/>. Sets height value = -1 (star-sized). Examples: <c>50..150</c>, <c>50..</c> or <c>..150</c>.
	/// <br/>• tuple <c>(double value, Range minMax)</c> - height and min/max heights. Example: <c>(-2, 50..200)</c>.
	/// <br/>• <see cref="RowDefinition"/>.
	/// </param>
	/// <exception cref="InvalidOperationException">In non-grid panel.</exception>
	/// <remarks>
	/// Calling this function is optional, except when not all cells of previous row are explicitly filled.
	/// 
	/// If there are star-sized rows, grid height should be defined. Call <see cref="Height"/> or <see cref="Size"/>. But if the grid is in a cell of another grid, usually it's better to set row height of that grid to a non-zero value, ie let it be not auto-sized.
	/// </remarks>
	public wpfBuilder Row(WBGridLength height) {
		if (_p.ended) throw new InvalidOperationException("Row() after End()");
		var g = _p as _Grid ?? throw new InvalidOperationException("Row() in non-grid panel");
		g.Row(height);
		return this;
	}
	
	/// <summary>
	/// Starts new auto-sized row in current grid. The same as <c>Row(0)</c>. See <see cref="Row"/>.
	/// </summary>
	/// <exception cref="InvalidOperationException">In non-grid panel.</exception>
	public wpfBuilder R => Row(0);
	
	#endregion
	
	#region ctors, window
	
	//	static readonly DependencyProperty _wpfBuilderProperty = DependencyProperty.RegisterAttached("_wpfBuilder", typeof(wpfBuilder), typeof(Panel));
	static ConditionalWeakTable<Panel, wpfBuilder> s_cwt = new();
	//which is better? Both fast.
	
	/// <summary>
	/// This constructor creates <see cref="W.Window"/> object with panel of specified type (default is <see cref="Grid"/>).
	/// </summary>
	/// <param name="windowTitle">Window title bar text.</param>
	/// <param name="panelType">Panel type. Default is <see cref="Grid"/>. Later you also can add nested panels of various types with <c>StartX</c> functions.</param>
	public wpfBuilder(string windowTitle, WBPanelType panelType = WBPanelType.Grid) {
		/*_container=*/
		_window = new Window() { Title = windowTitle };
		_AddRootPanel(_window, false, panelType, true);
	}
	
	/// <summary>
	/// This constructor creates panel of specified type (default is <see cref="Grid"/>) and optionally adds to a container.
	/// </summary>
	/// <param name="container">
	/// Window or some other element that will contain the panel. Should be empty, unless the type supports multiple direct child elements. Can be <c>null</c>.
	/// If the type (or base type) is <see cref="ContentControl"/> (<see cref="W.Window"/>, <see cref="TabItem"/>, <see cref="ToolTip"/>, etc), <see cref="Popup"/> or <see cref="Decorator"/> (eg <c>Border</c>), this function adds the panel to it. If <i>container</i> is <c>null</c> or an element of some other type, need to explicitly add the panel to it, like <c>container.Child = b.Panel;</c> or <c>container.Children.Add(b.Panel);</c> or <c>b.Tooltip(btt.Panel);</c> or <c>hwndSource.RootVisual = btt.Panel;</c> (the code depends on <i>container</i> type).
	/// </param>
	/// <param name="panelType">Panel type. Default is <see cref="Grid"/>. Later you also can add nested panels of various types with <c>StartX</c> functions.</param>
	/// <param name="setProperties">
	/// Set some container's properties like other overload does. Default <c>true</c>. Currently sets these properties, and only if <i>container</i> is of type <c>Window</c>:
	/// <br/>• <see cref="Window.SizeToContent"/>, except when <i>container</i> is <c>Canvas</c> or has properties <c>Width</c> and/or <c>Height</c> set.
	/// <br/>• <c>SnapsToDevicePixels</c> = <c>true</c>.
	/// <br/>• <c>WindowStartupLocation</c> = <c>Center</c>.
	/// <br/>• <c>Topmost</c> and <c>Background</c> depending on static properties <see cref="winTopmost"/> and <see cref="winWhite"/>.
	/// </param>
	public wpfBuilder(FrameworkElement container = null, WBPanelType panelType = WBPanelType.Grid, bool setProperties = true) {
		//_container=container; // ?? throw new ArgumentNullException("container"); //can be null
		_window = container as Window;
		_AddRootPanel(container, true, panelType, setProperties);
	}
	
	void _AddRootPanel(FrameworkElement container, bool externalContainer, WBPanelType panelType, bool setProperties) {
		_p = panelType switch {
			WBPanelType.Grid => new _Grid(this),
			WBPanelType.Canvas => new _Canvas(this),
			WBPanelType.Dock => new _DockPanel(this),
			WBPanelType.HorizontalStack => new _StackPanel(this, false),
			WBPanelType.VerticalStack => new _StackPanel(this, true),
			_ => throw new InvalidEnumArgumentException()
		};
		if (_window != null) _p.panel.Margin = new(3);
		switch (container) {
		case ContentControl c: c.Content = _p.panel; break;
		case Popup c: c.Child = _p.panel; break;
		case Decorator c: c.Child = _p.panel; break;
			//rejected. Rare. Let users add explicitly, like container.Child = b.Panel.
			//		case Panel c: c.Children.Add(_p.panel); break;
			//		case ItemsControl c: c.Items.Add(_p.panel); break;
			//		case TextBlock c: c.Inlines.Add(_p.panel); break;
			//		default: throw new NotSupportedException("Unsupported container type");
		}
		if (setProperties) {
			if (_window != null) {
				if (panelType != WBPanelType.Canvas) {
					if (externalContainer) {
						_window.SizeToContent = (double.IsNaN(_window.Width) ? SizeToContent.Width : 0) | (double.IsNaN(_window.Height) ? SizeToContent.Height : 0);
					} else {
						_window.SizeToContent = SizeToContent.WidthAndHeight;
					}
				}
				_window.SnapsToDevicePixels = true; //workaround for black line at bottom, for example when there is single CheckBox in Grid.
				//_window.UseLayoutRounding=true; //not here. Makes many controls bigger by 1 pixel when resizing window with grid, etc. Maybe OK if in _Add (for each non-panel element).
				if (_window.WindowStartupLocation == default) _window.WindowStartupLocation = WindowStartupLocation.CenterScreen;
				if (winTopmost) _window.Topmost = true;
				if (!winWhite) {
					_window.Background = SystemColors.ControlBrush;
					_unGray = true;
					
					//rejected: remove this background brush when _window.ThemeMode property changed. Slow. Instead remove in End(), if _unGray still true.
					//#if NET9_0_OR_GREATER
					//					DependencyPropertyDescriptor.FromProperty(Window.OverridesDefaultStyleProperty, typeof(Window)).AddValueChanged(_window, static (o, _) => {
					//						if (o is Window w && w.ThemeMode != ThemeMode.None && w.Background == SystemColors.ControlBrush) w.Background = null;
					//					});
					//#endif
				}
			}
		}
		s_cwt.Add(_p.panel, this);
		
		if (script.role == SRole.MiniProgram && _window != null) Loaded += () => { }; //set custom icon if need
	}
#pragma warning disable CS0414 //when compiling for nuget .NET 8
	bool _unGray;
#pragma warning restore CS0414
	
	/// <summary>
	/// Shows the window and waits until closed.
	/// </summary>
	/// <param name="owner">Owner window or element. Sets <see cref="Window.Owner"/>.</param>
	/// <exception cref="InvalidOperationException">
	/// - Container is not of type <c>Window</c>.
	/// - Missing <see cref="End"/> for a panel added with a <c>StartX</c> function.
	/// </exception>
	/// <remarks>
	/// Calls <see cref="End"/>, sets <see cref="Window.Owner"/> and calls <see cref="Window.ShowDialog"/>.
	/// You can instead call these functions directly. Or call <see cref="Window.Show"/> to show as non-modal window, ie don't wait. Or add <see cref="Panel"/> to some container window or other element, etc.
	/// </remarks>
	public bool ShowDialog(DependencyObject owner = null) {
		_ThrowIfNotWindow();
		if (_IsNested) throw new InvalidOperationException("Missing End() for a StartX() panel");
		End();
		//if (script.isWpfPreview) _window.Preview(); //no
		
		_window.Owner = owner == null ? null : owner as Window ?? Window.GetWindow(owner);
		//TODO3: try to support AnyWnd. Why WPF here supports only Window and not Popup or HwndSource?
		
		return true == _window.ShowDialog();
	}
	
	/// <summary>
	/// Sets window width and/or height or/and min/max width/height.
	/// </summary>
	/// <param name="width">Width or/and min/max width.</param>
	/// <param name="height">Height or/and min/max height.</param>
	/// <exception cref="InvalidOperationException">
	/// - Container is not of type <c>Window</c>.
	/// - Cannot be after the last <see cref="End"/>.
	/// - Cannot be after <see cref="WinRect"/> or <see cref="WinSaved"/>.
	/// </exception>
	/// <remarks>
	/// Use WPF logical device-independent units, not physical pixels.
	/// </remarks>
	/// <seealso cref="WinRect"/>
	/// <seealso cref="WinSaved"/>
	public wpfBuilder WinSize(WBLength? width = null, WBLength? height = null) {
		_ThrowIfNotWindow();
		_ThrowIfWasWinRect();
		if (_IsWindowEnded) throw new InvalidOperationException("WinSize() cannot be after last End()"); //although currently could be anywhere
		var u = _window.SizeToContent;
		if (width != null) { var v = width.Value; v.ApplyTo(_window, false); u &= ~SizeToContent.Width; }
		if (height != null) { var v = height.Value; v.ApplyTo(_window, true); u &= ~SizeToContent.Height; }
		_window.SizeToContent = u;
		return this;
	}
	
	void _ThrowIfWasWinRectXY([CallerMemberName] string m_ = null) {
		if (_wasWinXY != 0) throw new InvalidOperationException(m_ + " cannot be after WinXY, WinRect or WinSaved.");
	}
	void _ThrowIfWasWinRect([CallerMemberName] string m_ = null) {
		if (_wasWinXY == 2) throw new InvalidOperationException(m_ + " cannot be after WinRect or WinSaved.");
	}
	byte _wasWinXY; //1 xy, 2 rect
	
	/// <summary>
	/// Sets window location.
	/// </summary>
	/// <param name="x">X coordinate in screen. Physical pixels.</param>
	/// <param name="y">Y coordinate in screen. Physical pixels.</param>
	/// <exception cref="InvalidOperationException">
	/// - Container is not of type <c>Window</c>.
	/// - Cannot be after <see cref="WinXY"/>, <see cref="WinRect"/> or <see cref="WinSaved"/>.
	/// </exception>
	/// <remarks>
	/// With this function use physical pixels, not WPF logical device-independent units.
	/// Call this function before showing the window. Don't change location/size-related window properties after that.
	/// Calls <see cref="ExtWpf.SetXY"/>.
	/// </remarks>
	/// <seealso cref="WinSaved"/>
	public wpfBuilder WinXY(int x, int y) {
		_ThrowIfNotWindow();
		_ThrowIfWasWinRectXY(); _wasWinXY = 1;
		_window.SetXY(x, y);
		return this;
	}
	
	/// <summary>
	/// Sets window rectangle (location and size).
	/// </summary>
	/// <param name="r">Rectangle in screen. Physical pixels.</param>
	/// <exception cref="InvalidOperationException">
	/// - Container is not of type <c>Window</c>.
	/// - Cannot be after <see cref="WinXY"/>, <see cref="WinRect"/> or <see cref="WinSaved"/>.
	/// </exception>
	/// <remarks>
	/// With this function use physical pixels, not WPF logical device-independent units.
	/// Call this function before showing the window. Don't change location/size-related window properties after that.
	/// Calls <see cref="ExtWpf.SetRect"/>.
	/// </remarks>
	/// <seealso cref="WinSaved"/>
	public wpfBuilder WinRect(RECT r) {
		_ThrowIfNotWindow();
		_ThrowIfWasWinRectXY(); _wasWinXY = 2;
		_window.SetRect(r);
		return this;
	}
	
	/// <summary>
	/// Saves window xy/size/state when closing and restores when opening.
	/// </summary>
	/// <param name="saved">String that the <i>save</i> action received previously. Can be <c>null</c> or <c>""</c>, usually first time (still not saved).</param>
	/// <param name="save">Called when closing the window. Receives string containing window xy/size/state. Can save it in registry, file, anywhere.</param>
	/// <exception cref="InvalidOperationException">
	/// - Container is not of type <c>Window</c>.
	/// - Cannot be after <see cref="WinXY"/>, <see cref="WinRect"/> or <see cref="WinSaved"/>.
	/// - Window is loaded.
	/// </exception>
	/// <remarks>
	/// Calls <see cref="WndSavedRect.Restore"/>.
	/// Call this function before showing the window. Don't change location/size-related window properties after that.
	/// If you use <see cref="WinSize"/>, call it before. It is used if size is still not saved. The same if you set window position or state.
	/// </remarks>
	/// <example>
	/// <code><![CDATA[
	/// string rk = @"HKEY_CURRENT_USER\Software\Au\Test", rv = "winSR";
	/// var b = new wpfBuilder("Window").WinSize(300);
	/// b.Row(0).Add("Text", out TextBox _);
	/// b.R.AddOkCancel();
	/// b.WinSaved(Microsoft.Win32.Registry.GetValue(rk, rv, null) as string, o => Microsoft.Win32.Registry.SetValue(rk, rv, o));
	/// b.End();
	/// ]]></code>
	/// </example>
	public wpfBuilder WinSaved(string saved, Action<string> save) {
		_ThrowIfNotWindow();
		_ThrowIfWasWinRectXY(); _wasWinXY = 2;
		WndSavedRect.Restore(_window, saved, save);
		return this;
	}
	
	/// <summary>
	/// Changes various window properties.
	/// </summary>
	/// <param name="startLocation">Sets <see cref="WindowStartupLocation"/>.</param>
	/// <param name="resizeMode">Sets <see cref="Window.ResizeMode"/>.</param>
	/// <param name="showActivated">Sets <see cref="Window.ShowActivated"/>.</param>
	/// <param name="showInTaskbar">Sets <see cref="Window.ShowInTaskbar"/>.</param>
	/// <param name="topmost">Sets <see cref="Window.Topmost"/>.</param>
	/// <param name="state">Sets <see cref="Window.WindowState"/>.</param>
	/// <param name="style">Sets <see cref="Window.WindowStyle"/>.</param>
	/// <param name="icon">Sets <see cref="Window.Icon"/>. Example: <c>.WinProperties(icon: BitmapFrame.Create(new Uri(@"d:\icons\file.ico")))</c>.</param>
	/// <param name="whiteBackground">Set background color: <c>true</c> <see cref="SystemColors.WindowBrush"/> (white), <c>false</c> <see cref="SystemColors.ControlBrush"/> (gray). See also <see cref="winWhite"/>, <see cref="Brush"/>.</param>
	/// <exception cref="InvalidOperationException">
	/// - Container is not of type <c>Window</c>.
	/// - <i>startLocation</i> or <i>state</i> used after <see cref="WinXY"/>, <see cref="WinRect"/> or <see cref="WinSaved"/>.
	/// </exception>
	/// <remarks>
	/// The function uses only non-<c>null</c> parameters.
	/// Or you can change <see cref="Window"/> properties directly, for example <c>b.Window.Topmost = true;</c>.
	/// </remarks>
	public wpfBuilder WinProperties(WindowStartupLocation? startLocation = null, ResizeMode? resizeMode = null, bool? showActivated = null, bool? showInTaskbar = null, bool? topmost = null, WindowState? state = null, WindowStyle? style = null, ImageSource icon = null, bool? whiteBackground = null) {
		_ThrowIfNotWindow();
		if (startLocation.HasValue) { _ThrowIfWasWinRectXY("WinProperties(startLocation)"); _window.WindowStartupLocation = startLocation.Value; }
		if (resizeMode.HasValue) _window.ResizeMode = resizeMode.Value;
		if (showActivated.HasValue) _window.ShowActivated = showActivated.Value;
		if (showInTaskbar.HasValue) _window.ShowInTaskbar = showInTaskbar.Value;
		if (topmost.HasValue) _window.Topmost = topmost.Value;
		if (state.HasValue) { _ThrowIfWasWinRectXY("WinProperties(state)"); _window.WindowState = state.Value; }
		if (style.HasValue) _window.WindowStyle = style.Value;
		if (whiteBackground.HasValue) { _window.Background = whiteBackground.Value ? SystemColors.WindowBrush : SystemColors.ControlBrush; _unGray = false; }
		if (icon != null) _window.Icon = icon;
		return this;
	}
	
	#endregion
	
	#region properties, events
	
	/// <summary>
	/// Gets the top-level window.
	/// </summary>
	/// <returns><c>null</c> if container is not of type <c>Window</c>.</returns>
	public Window Window => _window;
	
	/// <summary>
	/// Gets current <see cref="Grid"/> or <see cref="StackPanel"/> or etc.
	/// </summary>
	public Panel Panel => _p.panel;
	
	/// <summary>
	/// Gets the last child or descendant element added in current panel. Before that returns current panel.
	/// </summary>
	/// <remarks>
	/// The "set properties of last element" functions set properties of this element.
	/// </remarks>
	public FrameworkElement Last => _p.LastAdded;
	
	/// <summary>
	/// Gets the child or descendant element added in current panel before adding <see cref="Last"/>. Can be <c>null</c>.
	/// </summary>
	/// <remarks>
	/// For example, after calling an <c>Add</c> overload that adds 2 elements (the first is <see cref="Label"/>), this property returns the <see cref="Label"/>.
	/// </remarks>
	public FrameworkElement Last2 => _p.LastAdded2;
	
	//	not useful
	//	/// <summary>
	//	/// Gets the last direct child element added in current panel. Before that returns current panel or its parent <see cref="GroupBox"/>.
	//	/// </summary>
	//	public FrameworkElement LastDirect => _p.LastDirect;
	
	/// <summary>
	/// When root panel loaded and visible. Once.
	/// </summary>
	/// <remarks>
	/// If the panel is in a <see cref="TabControl"/>, this event is fired when the tab page is selected/loaded first time.
	/// When this event is fired, handles of visible <see cref="System.Windows.Interop.HwndHost"/>-based controls are already created.
	/// </remarks>
	public event Action Loaded {
		add {
			if (!_loadedEvent2) { _loadedEvent2 = true; Panel.Loaded += _Panel_Loaded; }
			_loadedEvent += value;
		}
		remove {
			_loadedEvent -= value;
		}
	}
	Action _loadedEvent;
	bool _loadedEvent2;
	
	private void _Panel_Loaded(object sender, RoutedEventArgs e) {
		var p = sender as Panel;
		if (!p.IsVisible) return;
		p.Loaded -= _Panel_Loaded;
		
		//if role miniProgram, use assembly icon instead of apphost icon
		if (script.role == SRole.MiniProgram && _window != null && _window.Icon == null) {
			var hm = Api.GetModuleHandle(Assembly.GetEntryAssembly().Location);
			if (default != Api.FindResource(hm, Api.IDI_APPLICATION, Api.RT_GROUP_ICON)) {
				var w = _window.Hwnd();
				icon.FromModuleHandle_(hm, Dpi.Scale(16, w))?.SetWindowIcon(w, false);
				icon.FromModuleHandle_(hm, Dpi.Scale(32, w))?.SetWindowIcon(w, true);
			}
		}
		
		_loadedEvent?.Invoke();
	}
	
	/// <summary>
	/// When clicked <b>OK</b> or <b>Apply</b> button.
	/// </summary>
	/// <remarks>
	/// <see cref="Button.IsDefault"/> is <c>true</c> if it is <b>OK</b> button.
	/// The parameter's property <b>Cancel</b> can be used to prevent closing the window.
	/// </remarks>
	public event Action<WBButtonClickArgs> OkApply;
	
	#endregion
	
	#region static
	
	/// <summary>
	/// <see cref="Grid.ShowGridLines"/> of grid panels created afterwards.
	/// To be used at design time only.
	/// </summary>
	public static bool gridLines { get; set; }
	
	/// <summary>
	/// <see cref="Window.Topmost"/> of windows created afterwards.
	/// Usually used at design time only, to make always on top of editor window.
	/// </summary>
	public static bool winTopmost { get; set; }
	
	/// <summary>
	/// If <c>true</c>, <c>wpfBuilder</c> constructors used afterwards will not change the window background color.
	/// </summary>
	/// <remarks>
	/// If <c>true</c>, <c>wpfBuilder</c> constructors don't change the background color; then the color depends on theme.
	/// If <c>false</c> constructors set standard color of dialog windows, usually light gray.
	/// Default value depends on application's theme and usually is <c>true</c> if using a custom theme.
	/// </remarks>
	public static bool winWhite { get => s_winWhite ?? (_GetThemed() != _Themed.None); set { s_winWhite = value; } }
	static bool? s_winWhite;
	
	//	/// <summary>
	//	/// Default modifyPadding option value. See <see cref="Options"/>.
	//	/// </summary>
	//	public static bool modifyPadding { get; set; }
	
	#endregion
	
	#region add
	
	/// <summary>
	/// Changes some options for elements added afterwards.
	/// </summary>
	/// <param name="modifyPadding">Let <c>Add</c> adjust the <c>Padding</c> property of some controls to align content better when using default theme. Default value of this option depends on application's theme.</param>
	/// <param name="rightAlignLabels">Right-align <see cref="Label"/> controls in grid cells.</param>
	/// <param name="margin">Default margin of elements. If not set, default margin is 3 in all sides. Default margin of nested panels is 0; this option is not used.</param>
	/// <param name="showToolTipOnKeyboardFocus">Show tooltips when the tooltip owner element receives the keyboard focus when using keys to focus controls or open the window. If <c>true</c>, it can be set separately for each tooltip or owner element with <see cref="ToolTip.ShowsToolTipOnKeyboardFocus"/> or <see cref="ToolTipService.SetShowsToolTipOnKeyboardFocus(DependencyObject, bool?)"/>.</param>
	/// <param name="bindLabelVisibility">Let <see cref="LabeledBy"/> and an <c>Add</c> overload that adds 2 elements (the first is <see cref="Label"/>) bind the <c>Visibility</c> property of the label to that of the last added element, to automatically hide/show the label together with the element. Also binds <c>IsEnabled</c> if it is <see cref="Label"/> or <see cref="TextBlock"/>.</param>
	public wpfBuilder Options(bool? modifyPadding = null, bool? rightAlignLabels = null, Thickness? margin = null, bool? showToolTipOnKeyboardFocus = null, bool? bindLabelVisibility = null) {
		if (modifyPadding != null) _opt_modifyPadding = modifyPadding.Value;
		if (rightAlignLabels != null) _opt_rightAlignLabels = rightAlignLabels.Value;
		if (margin != null) _opt_margin = margin.Value;
		if (showToolTipOnKeyboardFocus != null) _opt_showToolTipOnKeyboardFocus = showToolTipOnKeyboardFocus.Value;
		if (bindLabelVisibility != null) _opt_bindLabelVisibility = bindLabelVisibility.Value;
		return this;
	}
	bool? _opt_modifyPadding;
	bool _opt_rightAlignLabels;
	Thickness _opt_margin = new(3);
	//string _opt_radioGroup; //rejected. Radio buttons have problems with high DPI and should not be used. Or can put groups in panels.
	//	double _opt_checkMargin=3; //rejected
	bool _opt_showToolTipOnKeyboardFocus;
	bool _opt_bindLabelVisibility;
	
	bool? _ModifyPadding => _opt_modifyPadding == false ? false : _IsThemed switch { _Themed.Wpf => null, _Themed.Other => _opt_modifyPadding == true, _ => true };
	
	void _Add(FrameworkElement e, object text, bool raw = false) {
		bool childOfLast = _child; _child = false;
		if (!raw) {
			if (e is Control c) {
				//rejected: modify padding etc through XAML. Not better than this.
				//rejected: use _opt_modifyPadding only if font Segoe UI. Tested with several fonts.
				switch (c) {
				case Label:
					switch (_ModifyPadding) {
					case true: c.Padding = new(1, 2, 1, 1); break; //default 5
					case null: c.Padding = new(1); c.VerticalAlignment = VerticalAlignment.Center; break;
					}
					if (_opt_rightAlignLabels) c.HorizontalAlignment = HorizontalAlignment.Right;
					break;
				case TextBox:
				case PasswordBox:
					if (_ModifyPadding == true) c.Padding = new(2, 1, 1, 2); //default padding 0, height 18
					break;
				case Button:
					if (text is string && _ModifyPadding == true) c.Padding = new(5, 1, 5, 2); //default 1
					break;
				case ToggleButton:
					c.HorizontalAlignment = HorizontalAlignment.Left; //default stretch
					c.VerticalAlignment = VerticalAlignment.Center; //default top. Note: VerticalContentAlignment bad on Win7.
					
					//partial workaround for squint CheckBox/RadioButton when High DPI.
					//	Without it, check mark size/alignment is different depending on control's xy.
					//	With it at least all controls are equal, either bad (eg DPI 125%) or good (DPI 150%).
					//	When bad, normal CheckBox check mark now still looks good. Only third state and RadioButtons look bad, but it is better than when controls look differently.
					//	But now at 150% DPI draws thick border.
					//c.UseLayoutRounding=true;
					//c.SnapsToDevicePixels=true; //does not help
					break;
				case ComboBox cb:
					//Change padding because default Windows font Segoe UI is badly centered vertically. Too big space above text, and too big control height.
					//Tested: changed padding isn't the reason of different control heights or/and arrows when high DPI.
					if (cb.IsEditable) {
						if (_ModifyPadding == true) c.Padding = new(2, 1, 2, 2); //default (2)
					} else {
						if (_ModifyPadding == true) c.Padding = new(5, 2, 4, 3); //default (6,3,5,3)
					}
					break;
				}
			} else if (e is Image) {
				e.UseLayoutRounding = true; //workaround for blurred images
			}
			
			//workaround for:
			//	1. Blurred images in some cases.
			//	2. High DPI: Different height of controls of same class, eg TextBox, ComboBox.
			//	3. High DPI: Different height/shape/alignment of control parts, eg CheckBox/RadioButton check mark and ComboBox arrow.
			//	Bad: on DPI 150% makes control borders 2-pixel.
			//	Rejected. Thick border is very noticeable, especially TabControl. Different control sizes, v check mark and v arrow aren't so noticeable. Radio buttons and null checkboxes rarely used. Most my tested WPF programs don't use this.
			//			e.UseLayoutRounding=true;
			//			e.SnapsToDevicePixels=true; //does not help
			
			if (text != null) {
				switch (e) {
				case HeaderedContentControl u: u.Header = text; break; //GroupBox, Expander
				case HeaderedItemsControl u: u.Header = text; break;
				case ContentControl u: u.Content = text; break; //Label, buttons, etc
				case TextBox u: u.Text = text.ToString(); break;
				case PasswordBox u: u.Password = text.ToString(); break;
				case ComboBox u: u.Text = text.ToString(); break;
				case TextBlock u: u.Text = text.ToString(); break;
				case RichTextBox u: u.AppendText(text.ToString()); break;
				//default: throw new NotSupportedException($"Add() cannot set text/content of {e.GetType().Name}.");
				default:
					if (!_PropGetSet<string>.TryCreate(e, "Text", out var pgs)) throw new NotSupportedException($"Add() cannot set text/content of {e.GetType().Name}.");
					pgs.Set(text.ToString());
					break;
				}
			}
		}
		if (!(childOfLast || e is GridSplitter)) e.Margin = _opt_margin;
		
		_AddToParent(e, childOfLast);
		if (_alsoAll != null) {
			_alsoAllArgs ??= new WBAlsoAllArgs();
			if (_p is _Grid g) {
				var v = g.NextCell;
				_alsoAllArgs.Column = v.column - 1;
				_alsoAllArgs.Row = v.row;
			} else {
				_alsoAllArgs.Column = _alsoAllArgs.Row = -1;
			}
			_alsoAll(this, _alsoAllArgs);
		}
	}
	
	void _AddToParent(FrameworkElement e, bool childOfLast) {
		if (childOfLast) { //info: BeforeAdd throws exception if Last is panel
			switch (Last) {
			case ContentControl d: d.Content = e; break;
			case Decorator d: d.Child = e; break;
			//case Panel d: d.Children.Add(e); break; //no, cannot add multiple items because Last becomes the added child
			default: throw new NotSupportedException($"Cannot add child to {Last.GetType().Name}.");
			}
			_p.SetLastAdded(e);
		} else {
			_p.Add(e);
		}
	}
	
	/// <summary>
	/// Sets option for the next <c>Add</c> call to add the element as a child or content of the last added element (<see cref="Last"/>), which must be a <see cref="Decorator"/> (for example <see cref="C.Border"/> or <see cref="AdornerDecorator"/>) or <see cref="ContentControl"/> (for example <see cref="Button"/>). Also will not change the <c>Margin</c> property.
	/// </summary>
	/// <exception cref="NotSupportedException">The last added element is not of a supported type.</exception>
	/// <remarks>
	/// Also applies to functions that call <c>Add</c>, for example <c>AddButton</c>. Does not affect the obsolete hidden <c>Add</c> overloads with parameter <i>flags</i>.
	/// </remarks>
	/// <example>
	/// <code><![CDATA[
	/// b.R.Add<Border>().Border(Brushes.Green).Child().Add(out TextBlock t1, "Text").Margin("L3R3");
	/// ]]></code>
	/// </example>
	public wpfBuilder Child() {
		if (!(Last is ContentControl or Decorator)) throw new NotSupportedException($"Cannot add child to {Last.GetType().Name}.");
		_child = true;
		return this;
	}
	bool _child;
	
	/// <summary>
	/// Adds an existing element.
	/// </summary>
	/// <param name="element"></param>
	/// <param name="raw">Don't change element properties, except margin. If <c>false</c> (default), works like other <c>Add</c> overloads: for some element types sets padding, alignment, properties specified in <see cref="wpfBuilder.Options"/>, etc.</param>
	/// <seealso cref="And"/>
	/// <seealso cref="Child"/>
	/// <seealso cref="Options"/>
	/// <seealso cref="AlsoAll"/>
	public wpfBuilder Add(FrameworkElement element, bool raw = false) {
		_p.BeforeAdd(_child);
		_Add(element, null, raw);
		return this;
	}
	
	/// <summary>
	/// Creates and adds element of type <i>T</i> (control etc of any type).
	/// </summary>
	/// <param name="variable">
	/// Receives element's variable. The function creates element of variable's type. You can use the variable to set element's properties before showing window or/and to get value after.
	/// Examples: <c>.Add(out CheckBox c1, "Text")</c>, <c>.Add(out _textBox1)</c>. If don't need a variable: <c>.Add(out Label _, "Text")</c> or <c>.Add&lt;Label>("Text")</c>.
	/// </param>
	/// <param name="text">
	/// Text, header or other content. Supported element types (or base types):
	/// <br/>• <see cref="TextBox"/> - sets <c>Text</c> property.
	/// <br/>• <see cref="ComboBox"/> - sets <c>Text</c> property (see also <see cref="Items"/>).
	/// <br/>• <see cref="PasswordBox"/> - sets <c>Password</c> property.
	/// <br/>• <see cref="TextBlock"/> - sets <c>Text</c> property (see also <see cref="FormatText"/> and <see cref="formattedText"/>).
	/// <br/>• <see cref="HeaderedContentControl"/>, <see cref="HeaderedItemsControl"/> - sets <c>Header</c> property (see also <see cref="FormatText"/> and <see cref="formattedText"/>).
	/// <br/>• <see cref="ContentControl"/> - sets <c>Content</c> property (can be string, other element, etc) (see also <see cref="FormatText"/> and <see cref="formattedText"/>).
	/// <br/>• <see cref="RichTextBox"/> - calls <c>AppendText</c> (see also <see cref="LoadFile"/>).
	/// <br/>• Other element types that have <c>Text</c> property.
	/// </param>
	/// <exception cref="NotSupportedException">The function does not support non-<c>null</c> <i>text</i> for this element type.</exception>
	/// <seealso cref="And"/>
	/// <seealso cref="Child"/>
	/// <seealso cref="Options"/>
	/// <seealso cref="AlsoAll"/>
	public wpfBuilder Add<T>(out T variable, object text = null) where T : FrameworkElement, new() {
		_p.BeforeAdd(_child);
		variable = new T();
		_Add(variable, text);
		return this;
	}
	
	/// <summary>
	/// Creates and adds element of type <i>T</i> (any type). This overload can be used when don't need element's variable.
	/// </summary>
	/// <param name="text">Text, header or other content. More info - see other overload.</param>
	/// <exception cref="NotSupportedException">The function does not support non-<c>null</c> <i>text</i> for this element type.</exception>
	/// <seealso cref="And"/>
	/// <seealso cref="Child"/>
	/// <seealso cref="Options"/>
	/// <seealso cref="AlsoAll"/>
	public wpfBuilder Add<T>(object text = null) where T : FrameworkElement, new()
		=> Add(out T _, text);
	
	/// <summary>
	/// Adds 2 elements: <see cref="Label"/> and element of type <i>T</i> (control etc of any type).
	/// </summary>
	/// <param name="label">Label text. Usually string or <see cref="TextBlock"/>. Example: <c>new TextBlock() { TextWrapping = TextWrapping.Wrap, Text = "long text" }</c>.</param>
	/// <param name="variable">Variable of second element. More info - see other overload.</param>
	/// <param name="text">Text, header or other content of second element. More info - see other overload.</param>
	/// <param name="row2">If not <c>null</c>, after adding first element calls <see cref="Row"/> with this argument.</param>
	/// <exception cref="NotSupportedException">If the function does not support non-<c>null</c> <i>text</i> for this element type.</exception>
	/// <remarks>
	/// Finally calls <see cref="LabeledBy"/>; it sets <see cref="Label.Target"/>, calls <see cref="System.Windows.Automation.AutomationProperties.SetLabeledBy"/> and applies the <i>bindLabelVisibility</i> option (see <see cref="Options"/>).
	/// </remarks>
	public wpfBuilder Add<T>(object label, out T variable, object text = null, WBGridLength? row2 = null) where T : FrameworkElement, new() {
		if (_child) throw new InvalidOperationException();
		Add(out Label var1, label);
		if (row2 != null) Row(row2.Value);
		Add(out variable, text);
		return this.LabeledBy(var1);
	}
	
	/// <summary>
	/// Adds 2 elements: <see cref="Label"/> and an existing element (control etc of any type).
	/// </summary>
	/// <inheritdoc cref="Add{T}(object, out T, object, WBGridLength?)"/>
	public wpfBuilder Add(object label, FrameworkElement element, WBGridLength? row2 = null) {
		if (_child) throw new InvalidOperationException();
		Add(out Label var1, label);
		if (row2 != null) Row(row2.Value);
		Add(element);
		return this.LabeledBy(var1);
	}
	
#if !DEBUG && NET9_0_OR_GREATER
#pragma warning disable CS1591 //Missing XML comment for publicly visible type or member
	//[Obsolete("Instead of flags use: b.Child().Add(...)")]
	[EditorBrowsable(EditorBrowsableState.Never)]
	public wpfBuilder Add(FrameworkElement element, WBAdd flags) {
		_p.BeforeAdd(_child = flags.Has(WBAdd.ChildOfLast));
		_Add(element, null, flags.Has(WBAdd.DontSetProperties));
		return this;
	}
	
	//[Obsolete("Instead of flags use: b.Child().Add(...)")]
	[EditorBrowsable(EditorBrowsableState.Never)]
	[OverloadResolutionPriority(-1)]
	public wpfBuilder Add<T>(out T variable, object text = null, WBAdd flags = 0) where T : FrameworkElement, new() {
		_p.BeforeAdd(_child = flags.Has(WBAdd.ChildOfLast));
		variable = new T();
		_Add(variable, text, flags.Has(WBAdd.DontSetProperties));
		return this;
	}
	
	//[Obsolete("Instead of flags use: b.Child().Add(...)")]
	[EditorBrowsable(EditorBrowsableState.Never)]
	//[OverloadResolutionPriority(-1)] //no, then woul choose Add<T>(out T variable, object text = null)
	public wpfBuilder Add<T>(out T variable, WBAdd flags) where T : FrameworkElement, new()
		=> Add(out variable, null, flags);
	
	//[Obsolete("Instead of flags use: b.Child().Add(...)")]
	[EditorBrowsable(EditorBrowsableState.Never)]
	[OverloadResolutionPriority(-1)]
	public wpfBuilder Add<T>(object text = null, WBAdd flags = 0) where T : FrameworkElement, new()
		=> Add(out T _, text, flags);
	
	[EditorBrowsable(EditorBrowsableState.Never)]
	[Obsolete] //Too many overloads, confusing. Instead can use Last2 or LabeledBy.
	public wpfBuilder Add<T1, T2>(out T1 var1, object text1, out T2 var2, object text2 = null, WBGridLength? row2 = null) where T1 : FrameworkElement, new() where T2 : FrameworkElement, new() {
		Add(out var1, text1);
		if (row2 != null) Row(row2.Value);
		Add(out var2, text2); //note: no flags
		return this.LabeledBy(var1);
	}
#pragma warning restore CS1591
#endif
	
	/// <summary>
	/// Adds button with <see cref="ButtonBase.Click"/> event handler.
	/// </summary>
	/// <param name="variable">Receives button's variable.</param>
	/// <param name="text">Text/content (<see cref="ContentControl.Content"/>).</param>
	/// <param name="click">Action to call when the button clicked. Its parameter's property <c>Cancel</c> can be used to prevent closing the window when clicked this <b>OK</b> button. Not called if validation fails.</param>
	/// <param name="flags"></param>
	/// <remarks>
	/// If <i>flags</i> contains <c>OK</c> or <c>Apply</c> or <c>Validate</c> and this window contains elements for which was called <see cref="Validation"/>, on click performs validation; if fails, does not call the <i>click</i> action and does not close the window.
	/// </remarks>
	public wpfBuilder AddButton(out Button variable, object text, Action<WBButtonClickArgs> click, WBBFlags flags = 0/*, Action<WBButtonClickArgs> clickSplit = null*/) {
		Add(out variable, text);
		var c = variable;
		if (flags.Has(WBBFlags.OK)) c.IsDefault = true;
		if (flags.Has(WBBFlags.Cancel)) c.IsCancel = true;
		if (flags.HasAny(WBBFlags.OK | WBBFlags.Cancel | WBBFlags.Apply)) { c.MinWidth = 70; c.MinHeight = 21; }
		if (click != null || flags.HasAny(WBBFlags.OK | WBBFlags.Cancel | WBBFlags.Apply | WBBFlags.Validate)) {
			c.Click += (_, _) => {
				var w = _FindWindow(c);
				if (flags.HasAny(WBBFlags.OK | WBBFlags.Apply | WBBFlags.Validate) && !_Validate(w, c)) return;
				bool needEvent = flags.HasAny(WBBFlags.OK | WBBFlags.Apply) && OkApply != null;
				var e = (needEvent || click != null) ? new WBButtonClickArgs { Button = c, Window = w } : null;
				if (needEvent) {
					OkApply(e);
					if (e.Cancel) return;
				}
				if (click != null) {
					click(e);
					if (e.Cancel) return;
				}
				if (flags.Has(WBBFlags.OK)) {
					bool modal = w.IsModal_() != false;
					if (modal) {
						try { w.DialogResult = true; }
						catch (InvalidOperationException) { modal = false; } //failed to detect modal?
					}
					if (!modal) w.Close();
				} else if (flags.Has(WBBFlags.Cancel)) {
					w.Close(); //info: IsCancel ignored if nonmodal
				}
			};
		}
		//if(clickSplit!=null) c.ClickSplit+=clickSplit;
		//FUTURE: split-button.
		return this;
	}
	//	/// <param name="clickSplit">
	//	/// If not null, creates split-button. Action to call when the arrow part clicked. Example:
	//	/// <br/><c>b => { int mi = popupMenu.showSimple("1 One|2 Two", b, (0, b.Height)); }</c>
	//	/// </param>
	
	/// <inheritdoc cref="AddButton(out Button, object, Action{WBButtonClickArgs}, WBBFlags)"/>
	public wpfBuilder AddButton(object text, Action<WBButtonClickArgs> click, WBBFlags flags = 0/*, Action<WBButtonClickArgs> clickSplit = null*/) {
		return AddButton(out _, text, click, flags);
	}
	
	/// <summary>
	/// Adds button that closes the window and sets <see cref="ResultButton"/>.
	/// </summary>
	/// <param name="text">Text/content (<see cref="ContentControl.Content"/>).</param>
	/// <param name="result"><see cref="ResultButton"/> value when clicked this button.</param>
	/// <remarks>
	/// When clicked, sets <see cref="ResultButton"/> = <i>result</i>, closes the window, and <see cref="ShowDialog"/> returns <c>true</c>.
	/// </remarks>
	public wpfBuilder AddButton(object text, int result/*, Action<WBButtonClickArgs> clickSplit = null*/) {
		Add(out Button c, text);
		c.Click += (_, _) => { _resultButton = result; _FindWindow(c).DialogResult = true; };
		//if(clickSplit!=null) c.ClickSplit+=clickSplit;
		return this;
	}
	//	/// <param name="clickSplit">
	//	/// If not null, creates split-button. Action to call when the arrow part clicked. Example:
	//	/// <br/><c>b => { int mi = popupMenu.showSimple("1 One|2 Two", b, (0, b.Height)); }</c>
	//	/// </param>
	
	/// <summary>
	/// If the window closed with an <see cref="AddButton(object, int)"/> button, returns its <i>result</i>. Else returns 0.
	/// Note: if the button is in a tab page, use the <see cref="wpfBuilder"/> variable of that page.
	/// </summary>
	public int ResultButton => _resultButton;
	int _resultButton;
	
	/// <summary>
	/// Adds <b>OK</b> and/or <b>Cancel</b> and/or <b>Apply</b> buttons.
	/// </summary>
	/// <param name="ok">Text of <b>OK</b> button. If <c>null</c>, does not add the button.</param>
	/// <param name="cancel">Text of <b>Cancel</b> button. If <c>null</c>, does not add the button.</param>
	/// <param name="apply">Text of <b>Apply</b> button. If <c>null</c>, does not add the button.</param>
	/// <param name="stackPanel">Add a right-bottom aligned <see cref="StackPanel"/> that contains the buttons. See <see cref="StartOkCancel"/>. If <c>null</c> (default), adds if not already in a stack panel, except when there is 1 button.</param>
	/// <remarks>
	/// Sets properties of <b>OK</b>/<b>Cancel</b> buttons so that click and <c>Enter</c>/<c>Esc</c> close the window; then <see cref="ShowDialog"/> returns <c>true</c> on <b>OK</b>, <c>false</c> on <b>Cancel</b>.
	/// See also event <see cref="OkApply"/>.
	/// </remarks>
	public wpfBuilder AddOkCancel(string ok = "OK", string cancel = "Cancel", string apply = null, bool? stackPanel = null)
		=> AddOkCancel(out _, out _, out _, ok, cancel, apply, stackPanel);
	
	/// <param name="bOK">Variable of <b>OK</b> button.</param>
	/// <param name="bCancel">Variable of <b>Cancel</b> button.</param>
	/// <param name="bApply">Variable of <b>Apply</b> button.</param>
	/// <inheritdoc cref="AddOkCancel(string, string, string, bool?)"/>
	public wpfBuilder AddOkCancel(out Button bOK, out Button bCancel, out Button bApply, string ok = "OK", string cancel = "Cancel", string apply = null, bool? stackPanel = null) {
		int n = 0; if (ok != null) n++; if (cancel != null) n++;
		if (n == 0) throw new ArgumentNullException();
		bool stack = stackPanel ?? (n > 1 && !(_p is _StackPanel));
		if (stack) StartOkCancel();
		if (ok != null) AddButton(out bOK, ok, null, WBBFlags.OK); else bOK = null;
		if (cancel != null) AddButton(out bCancel, cancel, null, WBBFlags.Cancel); else bCancel = null;
		if (apply != null) AddButton(out bApply, apply, null, WBBFlags.Apply); else bApply = null;
		if (stack) End();
		return this;
	}
	
	/// <summary>
	/// Adds <see cref="Separator"/> control.
	/// </summary>
	/// <param name="vertical">If <c>true</c>, adds vertical separator. If <c>false</c>, horizontal. If <c>null</c> (default), adds vertical if in horizontal stack panel, else adds horizontal.</param>
	/// <remarks>
	/// In <see cref="Canvas"/> panel separator's default size is 1x1. Need to set size, like <c>.AddSeparator().XY(0, 50, 100, 1)</c>.
	/// </remarks>
	public wpfBuilder AddSeparator(bool? vertical = null) {
		Add(out Separator c);
		if (vertical ?? (_p.panel is StackPanel p && p.Orientation == Orientation.Horizontal)) {
			c.Style = _style_VertSep ??= c.FindResource(ToolBar.SeparatorStyleKey) as Style;
		}
		c.UseLayoutRounding = true; //workaround: separators of different thickness when high DPI
		return this;
	}
	Style _style_VertSep;
	
	/// <summary>
	/// Adds enum members as <see cref="StackPanel"/> with checkboxes (if it's a <c>[Flags]</c> enum) or <see cref="ComboBox"/> control.
	/// </summary>
	/// <param name="e">Variable for getting result later. See <see cref="EnumUI{TEnum}.Result"/>.</param>
	/// <param name="init">Initial value.</param>
	/// <param name="items">Enum members and their text/tooltip. Optional. Text can be: <c>null</c>, <c>"text"</c>, <c>"text|tooltip"</c>, <c>"|tooltip"</c>.</param>
	/// <param name="label">If not <c>null</c>, adds a <see cref="GroupBox"/> or <see cref="Label"/> control with this label. If it's a <c>[Flags]</c> enum, adds <see cref="GroupBox"/> as parent of checkboxes, else adds <see cref="Label"/> before the <see cref="ComboBox"/> (uses 2 grid cells).</param>
	/// <param name="vertical">Vertical stack. Default <c>true</c>.</param>
	[EditorBrowsable(EditorBrowsableState.Never)] //obsolete. Not flexible enough (eg users may want Grid, not StackPanel), etc. Added EnumUI examples in cookbook.
	public wpfBuilder AddEnum<TEnum>(out EnumUI<TEnum> e, TEnum init = default, (TEnum value, string text)[] items = null, string label = null, bool vertical = true) where TEnum : unmanaged, Enum {
		if (typeof(TEnum).IsDefined(typeof(FlagsAttribute), false)) {
			if (label != null) StartStack<GroupBox>(label, vertical: vertical);
			else StartStack(vertical: vertical);
			e = new EnumUI<TEnum>(Panel, init, items);
			End();
		} else {
			ComboBox cb;
			if (label != null) Add(label, out cb);
			else Add(out cb);
			e = new EnumUI<TEnum>(cb, init, items);
		}
		return this;
	}
	
	/// <summary>
	/// Adds one or more empty cells in current row of current grid.
	/// </summary>
	/// <param name="span">Column count.</param>
	/// <exception cref="InvalidOperationException">In non-grid panel.</exception>
	/// <remarks>
	/// Actually just changes column index where next element will be added.
	/// </remarks>
	public wpfBuilder Skip(int span = 1) {
		if (span < 0) throw new ArgumentException();
		var g = _p as _Grid ?? throw new InvalidOperationException("Skip() in non-grid panel");
		g.Skip(span);
		return this;
	}
	
	/// <summary>
	/// Sets to add next element in the same grid cell as previous element.
	/// </summary>
	/// <param name="width">Width of next element. If negative - width of previous element. Also it adds to the corresponding margin of other element. If 0, simply adds in the same place as previous element.</param>
	/// <exception cref="InvalidOperationException">In non-grid panel or in a wrong place.</exception>
	/// <remarks>
	/// Can be used to add 2 elements in 1 cell as a cheaper and more concise way than with a <c>StartX</c> function.
	/// Next element will inherit column index and span of previous element but won't inherit row span.
	/// </remarks>
	/// <example>
	/// <code><![CDATA[
	/// b.Add("File", out TextBox _).And(70).AddButton("Browse...", null);
	/// ]]></code>
	/// </example>
	public wpfBuilder And(double width) {
		var g = _p as _Grid ?? throw new InvalidOperationException("And() in non-grid panel");
		g.And(width);
		return this;
	}
	
	#endregion
	
	#region set common properties of last added element
	
	/// <summary>
	/// Sets column span of the last added element.
	/// </summary>
	/// <param name="columns">Column count. If -1 or too many, will span all remaining columns in current row. If 0, will share 1 column with next element added in current row; to set element positions use <see cref="Margin"/>, <see cref="Width"/> and <see cref="Align"/>; see also <see cref="And"/>.</param>
	/// <exception cref="InvalidOperationException">In non-grid panel.</exception>
	public wpfBuilder Span(int columns) {
		_ParentOfLastAsOrThrow<_Grid>().Span(columns);
		return this;
	}
	
	/// <summary>
	/// Sets row span of the last added element.
	/// </summary>
	/// <param name="rows">Row count.</param>
	/// <exception cref="InvalidOperationException">In non-grid panel.</exception>
	/// <remarks>
	/// In next row(s) use <see cref="Skip"/> to skip cells occupied by this element.
	/// Often it's better to add a nested panel instead. See <see cref="StartGrid"/>.
	/// </remarks>
	public wpfBuilder SpanRows(int rows) {
		var c = _ParentOfLastAsOrThrow<_Grid>().LastDirect;
		Grid.SetRowSpan(c, rows);
		return this;
	}
	
	//rejected
	///// <summary>
	///// Calls your callback function.
	///// </summary>
	///// <param name="action"></param>
	//public wpfBuilder Also(Action<wpfBuilder> action) {
	//	action(this);
	//	return this;
	//}
	
	/// <summary>
	/// Sets callback function to be called by <c>AddX</c> functions for each element added afterwards. Not called by <c>StartX</c> functions for panels.
	/// </summary>
	/// <param name="action">Callback function or <c>null</c>.</param>
	/// <example>
	/// <code><![CDATA[
	/// b.AlsoAll((b, e) => {
	/// 	if(b.Last is CheckBox c) { c.IsChecked = true; b.Margin("t1 b1"); }
	/// });
	/// ]]></code>
	/// </example>
	public wpfBuilder AlsoAll(Action<wpfBuilder, WBAlsoAllArgs> action) {
		_alsoAll = action;
		return this;
	}
	Action<wpfBuilder, WBAlsoAllArgs> _alsoAll;
	WBAlsoAllArgs _alsoAllArgs;
	
	/// <summary>
	/// Sets width and height of the last added element. Optionally sets alignment.
	/// </summary>
	/// <param name="width">Width or/and min/max width.</param>
	/// <param name="height">Height or/and min/max height.</param>
	/// <param name="alignX">Horizontal alignment. If not <c>null</c>, calls <see cref="Align(string, string)"/>.</param>
	/// <param name="alignY">Vertical alignment.</param>
	/// <exception cref="ArgumentException">Invalid alignment string.</exception>
	public wpfBuilder Size(WBLength width, WBLength height, string alignX = null, string alignY = null) {
		var c = Last;
		width.ApplyTo(c, false);
		height.ApplyTo(c, true);
		if (alignX != null || alignY != null) Align(alignX, alignY);
		return this;
	}
	
	/// <summary>
	/// Sets width of the last added element. Optionally sets alignment.
	/// </summary>
	/// <param name="width">Width or/and min/max width.</param>
	/// <param name="alignX">Horizontal alignment. If not <c>null</c>, calls <see cref="Align(string, string)"/>.</param>
	/// <exception cref="ArgumentException">Invalid alignment string.</exception>
	public wpfBuilder Width(WBLength width, string alignX = null) {
		width.ApplyTo(Last, false);
		if (alignX != null) Align(alignX);
		return this;
	}
	
	/// <summary>
	/// Sets height of the last added element. Optionally sets alignment.
	/// </summary>
	/// <param name="height">Height or/and min/max height.</param>
	/// <param name="alignY">Vertical alignment. If not <c>null</c>, calls <see cref="Align(string, string)"/>.</param>
	/// <exception cref="ArgumentException">Invalid alignment string.</exception>
	public wpfBuilder Height(WBLength height, string alignY = null) {
		height.ApplyTo(Last, true);
		if (alignY != null) Align(null, alignY);
		return this;
	}
	
	/// <summary>
	/// Sets position of the last added element in <see cref="Canvas"/> panel. Optionally sets size.
	/// </summary>
	/// <param name="x"></param>
	/// <param name="y"></param>
	/// <param name="width">Width or/and min/max width.</param>
	/// <param name="height">Height or/and min/max height.</param>
	/// <exception cref="InvalidOperationException">Current panel is not <see cref="Canvas"/>.</exception>
	/// <remarks>
	/// Only in <see cref="Canvas"/> panel you can set position explicitly. In other panel types it is set automatically and can be adjusted with <see cref="Margin"/>, <see cref="Align"/>, container's <see cref="AlignContent"/>, etc.
	/// </remarks>
	public wpfBuilder XY(double x, double y, WBLength? width = null, WBLength? height = null) {
		var c = _ParentOfLastAsOrThrow<_Canvas>().LastDirect;
		Canvas.SetLeft(c, x);
		Canvas.SetTop(c, y);
		width?.ApplyTo(c, false);
		height?.ApplyTo(c, true);
		return this;
	}
	
	/// <summary>
	/// Docks the last added element in <see cref="DockPanel"/>.
	/// </summary>
	/// <param name="dock"></param>
	/// <exception cref="InvalidOperationException">Current panel is not <see cref="DockPanel"/>.</exception>
	public wpfBuilder Dock(Dock dock) {
		var c = _ParentOfLastAsOrThrow<_DockPanel>().LastDirect;
		DockPanel.SetDock(c, dock);
		return this;
	}
	
	/// <summary>
	/// Sets horizontal and/or vertical alignment of the last added element.
	/// </summary>
	/// <param name="x">Horizontal alignment.</param>
	/// <param name="y">Vertical alignment.</param>
	/// <exception cref="InvalidOperationException">Current panel is <see cref="Canvas"/>.</exception>
	public wpfBuilder Align(HorizontalAlignment? x = null, VerticalAlignment? y = null) {
		var c = Last;
		if (c.Parent is Canvas) throw new InvalidOperationException("Align() in Canvas panel.");
		if (x != null) c.HorizontalAlignment = x.Value;
		if (y != null) c.VerticalAlignment = y.Value;
		return this;
	}
	
	/// <summary>
	/// Sets horizontal and/or vertical alignment of the last added element.
	/// </summary>
	/// <param name="x">Horizontal alignment. String that starts with one of these letters, uppercase or lowercase: <c>L</c> (left), <c>R</c> (right), <c>C</c> (center), <c>S</c> (stretch).</param>
	/// <param name="y">Vertical alignment. String that starts with one of these letters, uppercase or lowercase: <c>T</c> (top), <c>B</c> (bottom), <c>C</c> (center), <c>S</c> (stretch).</param>
	/// <exception cref="InvalidOperationException">Current panel is <see cref="Canvas"/>.</exception>
	/// <exception cref="ArgumentException">Invalid alignment string.</exception>
	public wpfBuilder Align(string x = null, string y = null) => Align(_AlignmentFromStringX(x), _AlignmentFromStringY(y));
	
	HorizontalAlignment? _AlignmentFromStringX(string s, [CallerMemberName] string m_ = null)
		=> s.NE() ? default(HorizontalAlignment?) : (char.ToUpperInvariant(s[0]) switch { 'L' => HorizontalAlignment.Left, 'C' => HorizontalAlignment.Center, 'R' => HorizontalAlignment.Right, 'S' => HorizontalAlignment.Stretch, _ => throw new ArgumentException(m_ + "(x)") });
	
	VerticalAlignment? _AlignmentFromStringY(string s, [CallerMemberName] string m_ = null)
		=> s.NE() ? default(VerticalAlignment?) : (char.ToUpperInvariant(s[0]) switch { 'T' => VerticalAlignment.Top, 'C' => VerticalAlignment.Center, 'B' => VerticalAlignment.Bottom, 'S' => VerticalAlignment.Stretch, _ => throw new ArgumentException(m_ + "(y)") });
	
	/// <summary>
	/// Sets content alignment of the last added element.
	/// </summary>
	/// <param name="x">Horizontal alignment.</param>
	/// <param name="y">Vertical alignment.</param>
	/// <exception cref="InvalidOperationException">The last added element is not <see cref="Control"/>.</exception>
	public wpfBuilder AlignContent(HorizontalAlignment? x = null, VerticalAlignment? y = null) {
		var c = _LastAsControlOrThrow();
		if (x != null) c.HorizontalContentAlignment = x.Value;
		if (y != null) c.VerticalContentAlignment = y.Value;
		return this;
	}
	
	/// <summary>
	/// Sets content alignment of the last added element.
	/// </summary>
	/// <param name="x">Horizontal alignment. String like with <see cref="Align(string, string)"/>.</param>
	/// <param name="y">Vertical alignment.</param>
	/// <exception cref="InvalidOperationException">The last added element is not <see cref="Control"/>.</exception>
	/// <exception cref="ArgumentException">Invalid alignment string.</exception>
	public wpfBuilder AlignContent(string x = null, string y = null) => AlignContent(_AlignmentFromStringX(x), _AlignmentFromStringY(y));
	
	/// <summary>
	/// Sets margin of the last added element.
	/// </summary>
	public wpfBuilder Margin(Thickness margin) {
		Last.Margin = margin;
		return this;
	}
	
	/// <summary>
	/// Sets margin of the last added element.
	/// </summary>
	public wpfBuilder Margin(double? left = null, double? top = null, double? right = null, double? bottom = null) {
		var c = Last;
		var p = c.Margin;
		left ??= p.Left;
		top ??= p.Top;
		right ??= p.Right;
		bottom ??= p.Bottom;
		c.Margin = new(left.Value, top.Value, right.Value, bottom.Value);
		return this;
	}
	
	/// <summary>
	/// Sets margin of the last added element.
	/// </summary>
	/// <param name="margin">
	/// String containing uppercase or lowercase letters for margin sides (<c>L</c>, <c>T</c>, <c>R</c>, <c>B</c>) optionally followed by a number (default 0) and optionally separated by spaces. Or just single number, to set all sides equal.
	/// Examples: <c>"tb"</c> (top 0, bottom 0), <c>"L5 R15"</c> (left 5, right 15), <c>"2"</c> (all sides 2).
	/// </param>
	/// <exception cref="ArgumentException">Invalid string.</exception>
	public wpfBuilder Margin(string margin) {
		var c = Last;
		var m = c.Margin;
		_ThicknessFromString(ref m, margin);
		c.Margin = m;
		return this;
	}
	
	static void _ThicknessFromString(ref Thickness t, string s, [CallerMemberName] string m_ = null) {
		if (s.NE()) return;
		if (s.ToInt(out int v1, 0, out int e1) && e1 == s.Length) {
			t = new(v1);
			return;
		}
		
		for (int i = 0; i < s.Length; i++) {
			var c = s[i]; if (c == ' ') continue;
			int v = s.ToInt(i + 1, out int end); if (end > 0) i = end - 1; //never mind: should be double. Currently we don't have a function that can recognize and convert part of string to double.
			switch (c) {
			case 't': case 'T': t.Top = v; break;
			case 'b': case 'B': t.Bottom = v; break;
			case 'l': case 'L': t.Left = v; break;
			case 'r': case 'R': t.Right = v; break;
			default: throw new ArgumentException(m_ + "()");
			}
		}
	}
	
	/// <summary>
	/// Sets padding of the last added control.
	/// </summary>
	/// <exception cref="InvalidOperationException">The last added element does not have <c>Padding</c> property.</exception>
	public wpfBuilder Padding(Thickness thickness) {
		new _PropGetSet<Thickness>(Last, "Padding").Set(thickness);
		return this;
	}
	
	/// <summary>
	/// Sets padding of the last added control.
	/// </summary>
	/// <exception cref="InvalidOperationException">The last added element does not have <c>Padding</c> property.</exception>
	public wpfBuilder Padding(double? left = null, double? top = null, double? right = null, double? bottom = null) {
		var c = new _PropGetSet<Thickness>(Last, "Padding");
		var p = c.Get;
		left ??= p.Left;
		top ??= p.Top;
		right ??= p.Right;
		bottom ??= p.Bottom;
		c.Set(new(left.Value, top.Value, right.Value, bottom.Value));
		return this;
	}
	
	/// <summary>
	/// Sets padding of the last added control.
	/// </summary>
	/// <param name="padding">
	/// String containing uppercase or lowercase letters for padding sides (<c>L</c>, <c>T</c>, <c>R</c>, <c>B</c>) optionally followed by a number (default 0) and optionally separated by spaces. Or just single number, to set all sides equal.
	/// Examples: <c>"tb"</c> (top 0, bottom 0), <c>"L5 R15"</c> (left 5, right 15), <c>"2"</c> (all sides 2).
	/// </param>
	/// <exception cref="InvalidOperationException">The last added element does not have <c>Padding</c> property.</exception>
	/// <exception cref="ArgumentException">Invalid string.</exception>
	public wpfBuilder Padding(string padding) {
		var c = new _PropGetSet<Thickness>(Last, "Padding");
		var p = c.Get;
		_ThicknessFromString(ref p, padding);
		c.Set(p);
		return this;
	}
	
	/// <summary>
	/// Sets <see cref="UIElement.IsEnabled"/> of the last added element.
	/// </summary>
	/// <param name="disabled">If <c>true</c> (default), sets <c>IsEnabled</c> = <c>false</c>, else sets <c>IsEnabled</c> = true.</param>
	public wpfBuilder Disabled(bool disabled = true) {
		Last.IsEnabled = !disabled;
		return this;
	}
	
	/// <summary>
	/// Sets <see cref="UIElement.Visibility"/> of the last added element.
	/// </summary>
	/// <param name="hidden">If <c>true</c> (default), sets <see cref="Visibility"/> <c>Hiden</c>; if <c>false</c> - <c>Visible</c>; if <c>null</c> - <c>Collapsed</c>.</param>
	public wpfBuilder Hidden(bool? hidden = true) {
		Last.Visibility = hidden switch { true => Visibility.Hidden, false => Visibility.Visible, _ => Visibility.Collapsed };
		return this;
	}
	
	/// <summary>
	/// Sets tooltip text/content/object of the last added element. See <see cref="FrameworkElement.ToolTip"/>.
	/// </summary>
	/// <param name="tooltip">Tooltip text (string), or tooltip content element, or <see cref="ToolTip"/> object.</param>
	/// <example>
	/// Text box with simple tooltip.
	/// <code><![CDATA[
	/// b.R.Add("Example", out TextBox _).Tooltip("Tooltip text");
	/// ]]></code>
	/// Tooltip with content created by another <see cref="wpfBuilder"/>.
	/// <code><![CDATA[
	/// //tooltip content
	/// var btt = new wpfBuilder()
	/// 	.R.Add<Image>().Image(icon.stock(StockIcon.INFO).ToWpfImage())
	/// 	.R.Add<TextBlock>().Text("Some ", "<b>text", ".")
	/// 	.End();
	/// //dialog
	/// var b = new wpfBuilder("Window").WinSize(300);
	/// b.R.AddButton("Example", null).Tooltip(btt.Panel);
	/// b.R.AddOkCancel();
	/// b.End();
	/// if (!b.ShowDialog()) return;
	/// ]]></code>
	/// </example>
	public wpfBuilder Tooltip(object tooltip) {
		Last.ToolTip = tooltip;
		if (!_opt_showToolTipOnKeyboardFocus) ToolTipService.SetShowsToolTipOnKeyboardFocus(Last, false);
		return this;
	}
	//FUTURE: make easier to create tooltip content, eg Inlines of TextBlock. Would be good to create on demand.
	//FUTURE: hyperlinks in tooltip. Now does not work because tooltip closes when mouse leaves the element.
	
	/// <summary>
	/// Sets UI Automation name of the last added element.
	/// </summary>
	public wpfBuilder UiaName(string name) {
		Last.UiaSetName(name);
		return this;
	}
	
	/// <summary>
	/// Sets background and/or foreground brush (color, gradient, etc) of the last added element.
	/// </summary>
	/// <param name="background">Background brush. See <see cref="Brushes"/>, <see cref="SystemColors"/>. Descendants usually inherit this property.</param>
	/// <param name="foreground">Foreground brush. Usually sets text color. Descendants usually override this property.</param>
	/// <exception cref="NotSupportedException">Last added element must be <see cref="Control"/>, <see cref="Panel"/>, <see cref="Border"/> or <see cref="TextBlock"/>. With <i>foreground</i> only <see cref="Control"/> or <see cref="TextBlock"/>.</exception>
	/// <example>
	/// <code><![CDATA[
	/// b.R.Add<Label>("Example1").Brush(Brushes.Cornsilk, Brushes.Green).Border(Brushes.BlueViolet, 1);
	/// b.R.Add<Label>("Example2").Brush(new LinearGradientBrush(Colors.Chocolate, Colors.White, 0));
	/// ]]></code>
	/// </example>
	public wpfBuilder Brush(Brush background = null, Brush foreground = null) { //named not Colors because: 1. Can set other brush than color, eg gradient. 2. Rarely used and in autocompletion lists is above Columns.
		var last = Last;
		if (foreground != null) {
			new _PropGetSet<Brush>(Last, "Foreground").Set(foreground);
		}
		if (background != null) {
			if (last == _p.panel && !_IsNested && _window != null) last = _window;
			new _PropGetSet<Brush>(Last, "Background").Set(background);
		}
		return this;
	}
	
	/// <summary>
	/// Sets background and/or foreground color of the last added element.
	/// </summary>
	/// <exception cref="NotSupportedException">Last added element must be <see cref="Control"/>, <see cref="Panel"/>, <see cref="Border"/> or <see cref="TextBlock"/>. With <i>foreground</i> only <see cref="Control"/> or <see cref="TextBlock"/>.</exception>
	public wpfBuilder Brush(ColorInt? background = null, ColorInt? foreground = null)
		=> Brush(background == null ? null : new SolidColorBrush((Color)background.Value), foreground == null ? null : new SolidColorBrush((Color)foreground.Value));
	
	/// <summary>
	/// Sets border properties of the last added element, which can be <see cref="Border"/> or a <see cref="Control"/>-derived class.
	/// </summary>
	/// <param name="color">Border color brush. If <c>null</c>, uses <see cref="SystemColors.ActiveBorderBrush"/>.</param>
	/// <param name="thickness">Border thickness. Ignored if <i>thickness2</i> not <c>null</c>.</param>
	/// <param name="padding">Sets the <c>Padding</c> property.</param>
	/// <param name="cornerRadius">Sets <see cref="Border.CornerRadius"/>. If used, the last added element must be <see cref="C.Border"/>.</param>
	/// <param name="thickness2">Border thickness to use instead of <i>thickness</i>. Allows to set non-uniform thickness.</param>
	/// <exception cref="NotSupportedException">Last added element must be <see cref="Control"/> or <see cref="C.Border"/>. With <i>cornerRadius</i> only <see cref="C.Border"/>.</exception>
	/// <example>
	/// <code><![CDATA[
	/// b.R.Add<Label>("Example1").Border(Brushes.BlueViolet, 1, new(5)).Brush(Brushes.Cornsilk, Brushes.Green);
	/// b.R.Add<Border>().Border(Brushes.Blue, 2, cornerRadius: 3).Child().Add<Label>("Example2");
	/// ]]></code>
	/// </example>
	public wpfBuilder Border(Brush color = null, double thickness = 1d, Thickness? padding = null, double? cornerRadius = null, Thickness? thickness2 = null) {
		color ??= SystemColors.ActiveBorderBrush;
		switch (Last) {
		case Control c:
			if (cornerRadius != null) throw new NotSupportedException("Border(): Last added must be Border, or cornerRadius null");
			c.BorderBrush = color;
			c.BorderThickness = thickness2 ?? new(thickness);
			if (padding != null) c.Padding = padding.Value;
			break;
		case Border c:
			c.BorderBrush = color;
			c.BorderThickness = thickness2 ?? new(thickness);
			if (padding != null) c.Padding = padding.Value;
			if (cornerRadius != null) c.CornerRadius = new CornerRadius(cornerRadius.Value);
			break;
		default: throw new NotSupportedException("Border(): Last added must be Control or Border");
		}
		return this;
		//tested: there are no other useful types that have these properties.
	}
	
	/// <param name="color">Border color.</param>
	/// <inheritdoc cref="Border(Brush, double, Thickness?, double?, Thickness?)"/>
	public wpfBuilder Border(ColorInt color, double thickness = 1d, Thickness? padding = null, double? cornerRadius = null, Thickness? thickness2 = null)
		=> Border(new SolidColorBrush((Color)color), thickness, padding, cornerRadius, thickness2);
	
	/// <summary>
	/// Sets font properties of the last added element and its descendants.
	/// </summary>
	/// <param name="name">If not <c>null</c>, sets font name. Can be multiple fonts separated by commas.</param>
	/// <param name="size">If not <c>null</c>, sets font size.</param>
	/// <param name="bold">If not <c>null</c>, sets font bold or not.</param>
	/// <param name="italic">If not <c>null</c>, sets font italic or not.</param>
	public wpfBuilder Font(string name = null, double? size = null, bool? bold = null, bool? italic = null) {
		var c = Last;
		if (name != null) TextElement.SetFontFamily(c, new FontFamily(name));
		if (size != null) TextElement.SetFontSize(c, size.Value);
		if (bold != null) TextElement.SetFontWeight(c, bold == true ? FontWeights.Bold : FontWeights.Normal);
		if (italic != null) TextElement.SetFontStyle(c, italic == true ? FontStyles.Italic : FontStyles.Normal);
		return this;
		//rejected: FontStretch? stretch=null. Rarely used. Most fonts don't support.
		
		//not sure is this is OK or should set font properties for each supporting class separately.
	}
	
	/// <summary>
	/// Sets <c>TextWrapping</c> property of the last added element.
	/// Supports <see cref="TextBlock"/>, <see cref="TextBox"/> and <see cref="AccessText"/>.
	/// </summary>
	public wpfBuilder Wrap(TextWrapping wrapping) {
		switch (Last) {
		case TextBlock t: t.TextWrapping = wrapping; break;
		case TextBox t: t.TextWrapping = wrapping; break;
		case AccessText t: t.TextWrapping = wrapping; break;
		default: throw new NotSupportedException("Wrap(): Last added must be TextBlock, TextBox or AccessText");
		}
		return this;
	}
	
	/// <summary>
	/// Sets <c>TextWrapping</c> property of the last added element = <see cref="TextWrapping.Wrap"/> if <c>true</c> (default), else or <see cref="TextWrapping.NoWrap"/>.
	/// Supports <see cref="TextBlock"/>, <see cref="TextBox"/> and <see cref="AccessText"/>.
	/// </summary>
	public wpfBuilder Wrap(bool wrap = true) => Wrap(wrap ? TextWrapping.Wrap : TextWrapping.NoWrap);
	
	/// <summary>
	/// Attempts to set focus to the last added element when it'll become visible.
	/// </summary>
	public wpfBuilder Focus() {
		Last.Focus();
		return this;
	}
	
	/// <summary>
	/// Sets <c>Tag</c> property of the last added element.
	/// </summary>
	public wpfBuilder Tag(object tag) {
		Last.Tag = tag;
		return this;
	}
	
	/// <summary>
	/// Sets <see cref="FrameworkElement.DataContext"/> property of the last added element.
	/// Then with <see cref="Bind"/> of this and descendant elements don't need to specify data source object because it is set by this function.
	/// </summary>
	/// <param name="source">Data source object.</param>
	public wpfBuilder BindingContext(object source) {
		Last.DataContext = source;
		return this;
	}
	
	/// <summary>
	/// Calls <see cref="FrameworkElement.SetBinding(DependencyProperty, string)"/> of the last added element.
	/// </summary>
	/// <param name="property">Element's dependency property, for example <c>TextBox.TextProperty</c>.</param>
	/// <param name="path">Source property name or path, for example <c>nameof(MyData.Property)</c>. Source object should be set with <see cref="BindingContext"/>.</param>
	public wpfBuilder Bind(DependencyProperty property, string path) {
		Last.SetBinding(property, path);
		return this;
	}
	
	/// <summary>
	/// Calls <see cref="FrameworkElement.SetBinding(DependencyProperty, BindingBase)"/> of the last added element.
	/// </summary>
	/// <param name="property">Element's dependency property, for example <c>TextBox.TextProperty</c>.</param>
	/// <param name="binding">A binding object, for example <c>new Binding(nameof(MyData.Property))</c> or <c>new Binding(nameof(MyData.Property)) { Source = dataObject }</c>. In the first case, source object should be set with <see cref="BindingContext"/>.</param>
	public wpfBuilder Bind(DependencyProperty property, BindingBase binding) {
		Last.SetBinding(property, binding);
		return this;
	}
	
	/// <summary>
	/// Calls <see cref="FrameworkElement.SetBinding(DependencyProperty, BindingBase)"/> of the last added element and gets its return value.
	/// </summary>
	/// <param name="property">Element's dependency property, for example <c>TextBox.TextProperty</c>.</param>
	/// <param name="binding">A binding object.</param>
	/// <param name="r">The return value of <c>SetBinding</c>.</param>
	public wpfBuilder Bind(DependencyProperty property, BindingBase binding, out BindingExpressionBase r) {
		r = Last.SetBinding(property, binding);
		return this;
	}
	
	/// <summary>
	/// Calls <see cref="FrameworkElement.SetBinding(DependencyProperty, BindingBase)"/> of the last added element. Creates <see cref="Binding"/> that uses <i>source</i> and <i>path</i>.
	/// </summary>
	/// <param name="property">Element's dependency property, for example <c>TextBox.TextProperty</c>.</param>
	/// <param name="source">Data source object.</param>
	/// <param name="path">Source property name or path, for example <c>nameof(MyData.Property)</c>.</param>
	public wpfBuilder Bind(DependencyProperty property, object source, string path) {
		var binding = new Binding(path) { Source = source };
		Last.SetBinding(property, binding);
		return this;
	}
	
	/// <summary>
	/// Sets a validation callback function for the last added element.
	/// </summary>
	/// <param name="func">Function that returns an error string if element's value is invalid, else returns <c>null</c>.</param>
	/// <param name="linkClick">If not null, called on error link click. For example can be used to make the element visible.</param>
	/// <remarks>
	/// The callback function will be called when clicked button <b>OK</b> or <b>Apply</b> or a button added with flag <see cref="WBBFlags.Validate"/>.
	/// If it returns a non-<c>null</c> string, the window stays open and button's <i>click</i> callback not called. The string is displayed in a tooltip.
	/// </remarks>
	/// <example>
	/// <code><![CDATA[
	/// var b = new wpfBuilder("Window").WinSize(300);
	/// b.R.Add("Name", out TextBox tName)
	/// 	.Validation(o => string.IsNullOrWhiteSpace(tName.Text) ? "Name cannot be empty" : null);
	/// b.R.Add("Count", out TextBox tCount)
	/// 	.Validation(o => int.TryParse(tCount.Text, out int i1) && i1 >= 0 && i1 <= 100 ? null : "Count must be 0-100");
	/// b.R.AddOkCancel();
	/// b.End();
	/// if (!b.ShowDialog()) return;
	/// print.it(tName.Text, tCount.Text.ToInt());
	/// ]]></code>
	/// </example>
	public wpfBuilder Validation(Func<FrameworkElement, string> func, Action<FrameworkElement> linkClick = null/*, DependencyProperty property=null*/)
		=> Validation(Last, func, linkClick);
	
	/// <summary>
	/// Sets a validation callback function for an element.
	/// </summary>
	/// <inheritdoc cref="Validation(Func{FrameworkElement, string}, Action{FrameworkElement})"/>
	/// <example/>
	public wpfBuilder Validation(FrameworkElement e, Func<FrameworkElement, string> func, Action<FrameworkElement> linkClick = null/*, DependencyProperty property=null*/) {
		//validate on click of OK or some other button. Often eg text fields initially are empty and must be filled.
		(_validations ??= new List<_Validation>()).Add(new(e, func, linkClick));
		return this;
		//rejected: also validate on lost focus or changed property value.
	}
	
	record class _Validation(FrameworkElement e, Func<FrameworkElement, string> func, Action<FrameworkElement> linkClick);
	
	List<_Validation> _validations;
	
	bool _Validate(Window w, Button b) {
		ToolTip tt = null;
		TextBlock tb = null;
		foreach (var gb in _GetAllWpfBuilders(w)) { //find all wpfBuilder used to build this window
			if (gb._validations == null) continue;
			foreach (var (e, func, linkClick) in gb._validations) {
				var s = func(e); if (s == null) continue;
				if (tb == null) tb = new TextBlock(); else tb.Inlines.Add(new LineBreak());
				var h = new Hyperlink(new Run(s));
				h.Click += (o, y) => {
					if (!e.IsVisible && _FindAncestorTabItem(e, out var ti)) ti.IsSelected = true;
					linkClick?.Invoke(e);
					if (e.IsVisible) {
						timer.after(1, _ => { //else does not focus etc if was in hidden tab page
							try {
								e.BringIntoView();
								e.Focus();
								_RedBorderAdorner.AddTo(e, true);
								tt.Closed += (_, _) => { _RedBorderAdorner.AddTo(e, false); };
							}
							catch { }
							//catch(Exception e1) { print.it(e1); }
						});
					}
				};
				tb.Inlines.Add(h);
			}
		}
		if (tb == null) return true;
		tt = new ToolTip { Content = tb, StaysOpen = false, PlacementTarget = b, Placement = PlacementMode.Bottom };
		//var tt=new Popup { Child=tb, StaysOpen=false, PlacementTarget=b, Placement= PlacementMode.Bottom }; //works, but black etc
		tt.IsOpen = true;
		//never mind: could add eg red rectangle, like WPF does on binding validation error. Not easy.
		return false;
	}
	
	static List<wpfBuilder> _GetAllWpfBuilders(DependencyObject root) {
		var a = new List<wpfBuilder>();
		_Enum(root, 0);
		void _Enum(DependencyObject parent, int level) {
			foreach (var o in LogicalTreeHelper.GetChildren(parent).OfType<DependencyObject>()) {
				//print.it(new string(' ', level) + o);
				if (o is Panel p && s_cwt.TryGetValue(p, out var gb)) a.Add(gb);
				_Enum(o, level + 1);
			}
		}
		return a;
	}
	
	static bool _FindAncestorTabItem(DependencyObject e, out TabItem ti) {
		ti = null;
		for (; ; )
		{
			switch (e = LogicalTreeHelper.GetParent(e)) {
			case null: return false;
			case TabItem t: ti = t; return true;
			}
		}
	}
	
	class _RedBorderAdorner : Adorner {
		public _RedBorderAdorner(UIElement adornedElement) : base(adornedElement) { }
		
		protected override void OnRender(DrawingContext drawingContext) {
			var adornedElementRect = new Rect(AdornedElement.RenderSize);
			var pen = new Pen(Brushes.Red, 2);
			drawingContext.DrawRectangle(null, pen, adornedElementRect);
		}
		
		public static void AddTo(FrameworkElement e, bool add) {
			if (AdornerLayer.GetAdornerLayer(e) is { } layer) {
				if (add) {
					layer.Add(new _RedBorderAdorner(e));
				} else {
					if (layer.GetAdorners(e)?.OfType<_RedBorderAdorner>().FirstOrDefault() is { } k) layer.Remove(k);
				}
			}
		}
	}
	
	/// <summary>
	/// Sets <see cref="FrameworkElement.Name"/> of the last added element.
	/// </summary>
	/// <param name="name">Name. Must start with a letter or <c>_</c>, and contain only letters, digits and <c>_</c>.</param>
	/// <param name="andUia">Also set UI Automation name (<see cref="UiaName"/>).</param>
	/// <exception cref="ArgumentException">Invalid name.</exception>
	/// <remarks>
	/// The <c>Name</c> property can be used to identify the element in code. It also sets the UIA <c>AutomationId</c> (regardless of <i>andUia</i>). It isn't displayed in UI.
	/// </remarks>
	public wpfBuilder Name(string name, bool andUia = false) {
		Last.Name = name;
		if (andUia) UiaName(name);
		return this;
	}
	
	/// <summary>
	/// Makes an element behave as a label of the last added element (<see cref="Last"/>).
	/// </summary>
	/// <param name="label">The label element. Usually <see cref="Label"/> or <see cref="TextBlock"/>, but can be any element.</param>
	/// <param name="bindVisibility">If <c>true</c>, binds <c>Visibility</c> of <i>label</i> to that of the labeled element. If <c>false</c>, does not bind. If <c>null</c> (default), binds if the <i>bindLabelVisibility</i> option is true (see <see cref="Options"/>). If binds <c>Visibility</c>, also binds <c>IsEnabled</c> if <i>label</i> is <see cref="Label"/> or <see cref="TextBlock"/>.</param>
	/// <remarks>
	/// Sets <i>label</i>'s <see cref="Label.Target"/> if it's <see cref="Label"/>. Calls <see cref="System.Windows.Automation.AutomationProperties.SetLabeledBy"/>.
	/// </remarks>
	public wpfBuilder LabeledBy(FrameworkElement label, bool? bindVisibility = null) {
		var e = Last;
		System.Windows.Automation.AutomationProperties.SetLabeledBy(e, label);
		if (label is Label la) la.Target = e;
		if (bindVisibility ?? _opt_bindLabelVisibility) {
			label?.SetBinding(UIElement.VisibilityProperty, new Binding("Visibility") { Source = e, Mode = BindingMode.OneWay });
			if (label is Label or TextBlock) label.SetBinding(UIElement.IsEnabledProperty, new Binding("IsEnabled") { Source = e, Mode = BindingMode.OneWay });
		}
		return this;
	}
	
	/// <summary>
	/// Makes <see cref="Last2"/> behave as a label of <see cref="Last"/>.
	/// </summary>
	/// <inheritdoc cref="LabeledBy(FrameworkElement, bool?)"/>
	public wpfBuilder LabeledBy(bool? bindVisibility = null) => LabeledBy(Last2, bindVisibility);
	
	/// <summary>
	/// Sets watermark/hint/cue text of the last added <see cref="TextBox"/>, <see cref="PasswordBox"/> or editable <see cref="ComboBox"/> control.
	/// The text is visible only when the control text is empty.
	/// </summary>
	/// <param name="text">Watermark text.</param>
	/// <remarks>
	/// In some kinds of windows it may not work unless a parent or ancestor of the control is an <see cref="AdornerDecorator"/> (like in the example).
	/// </remarks>
	/// <exception cref="NotSupportedException">The last added element isn't <see cref="TextBox"/>, <see cref="PasswordBox"/> or editable <see cref="ComboBox"/> control.</exception>
	/// <example>
	/// <code><![CDATA[
	/// b.R.Add<AdornerDecorator>().Child().Add(out TextBox text1).Watermark("Water");
	/// ]]></code>
	/// More examples in Cookbook.
	/// </example>
	public wpfBuilder Watermark(string text) => Watermark(out _, text);
	
	/// <param name="adorner">Receives the adorner. It can be used to change watermark text later.</param>
	/// <inheritdoc cref="Watermark(string)"/>
	public wpfBuilder Watermark(out WatermarkAdorner adorner, string text) {
		var c = Last as Control;
		if (!(c is TextBox or PasswordBox or ComboBox { IsEditable: true })) throw new NotSupportedException("Watermark(): Last added must be TextBox, PasswordBox or editable ComboBox");
		adorner = new WatermarkAdorner(c, text);
		adorner.SetAdornerVisibility();
		return this;
	}
	
	#endregion
	
	#region set type-specific properties of last added element
	
	/// <summary>
	/// Sets <see cref="ToggleButton.IsChecked"/> and <see cref="ToggleButton.IsThreeState"/> of the last added check box or radio button.
	/// </summary>
	/// <param name="check"></param>
	/// <param name="threeState"></param>
	/// <exception cref="NotSupportedException">The last added element is not <see cref="ToggleButton"/>.</exception>
	public wpfBuilder Checked(bool? check = true, bool threeState = false) {
		var c = Last as ToggleButton ?? throw new NotSupportedException("Checked(): Last added element must be CheckBox or RadioButton");
		c.IsThreeState = threeState;
		c.IsChecked = check;
		return this;
	}
	
	/// <summary>
	/// Sets <see cref="ToggleButton.IsChecked"/> of the specified <see cref="RadioButton"/>.
	/// </summary>
	/// <param name="check"></param>
	/// <param name="control"></param>
	/// <remarks>
	/// Unlike other similar functions, does not use <see cref="Last"/>.
	/// </remarks>
	public wpfBuilder Checked(bool check, RadioButton control) {
		control.IsChecked = check;
		return this;
	}
	
	/// <summary>
	/// Sets <see cref="TextBoxBase.IsReadOnly"/> or <see cref="ComboBox.IsReadOnly"/> of the last added text box or editable combo box.
	/// </summary>
	/// <param name="readOnly"></param>
	/// <param name="caretVisible">Sets <see cref="TextBoxBase.IsReadOnlyCaretVisible"/>. Not used with <see cref="ComboBox"/>.</param>
	/// <exception cref="NotSupportedException">The last added element is not <see cref="TextBoxBase"/> or <see cref="ComboBox"/>.</exception>
	public wpfBuilder Readonly(bool readOnly = true, bool caretVisible = false) { //rejected: , bool caretVisible=false. Not useful.
		switch (Last) {
		case TextBoxBase c:
			c.IsReadOnly = readOnly;
			c.IsReadOnlyCaretVisible = caretVisible;
			break;
		case ComboBox c:
			c.IsReadOnly = readOnly;
			break;
		default: throw new NotSupportedException("Readonly(): Last added must be TextBox, RichTextBox or ComboBox");
		}
		return this;
	}
	
	/// <summary>
	/// Makes the last added <see cref="TextBox"/> multiline.
	/// </summary>
	/// <param name="height">If not <c>null</c>, sets height or/and min/max height.</param>
	/// <param name="wrap">Sets <see cref="TextBox.TextWrapping"/>.</param>
	/// <exception cref="NotSupportedException">The last added element is not <see cref="TextBox"/>.</exception>
	public wpfBuilder Multiline(WBLength? height = null, TextWrapping wrap = TextWrapping.WrapWithOverflow) {
		var c = Last as TextBox ?? throw new NotSupportedException("Multiline(): Last added must be TextBox");
		c.AcceptsReturn = true;
		c.TextWrapping = wrap;
		c.VerticalScrollBarVisibility = ScrollBarVisibility.Auto;
		c.HorizontalScrollBarVisibility = ScrollBarVisibility.Auto;
		height?.ApplyTo(c, true);
		return this;
	}
	
	/// <summary>
	/// Makes the last added <see cref="ComboBox"/> editable.
	/// </summary>
	/// <exception cref="NotSupportedException">The last added element is not <see cref="ComboBox"/>.</exception>
	public wpfBuilder Editable() {
		var c = Last as ComboBox ?? throw new NotSupportedException("Editable(): Last added must be ComboBox");
		c.IsEditable = true;
		if (_ModifyPadding == true) c.Padding = new(2, 1, 2, 2); //default (2) or set by _Add() for non-editable
		return this;
	}
	
	/// <summary>
	/// Splits string and ads substrings as items to the last added <see cref="ItemsControl"/> (<see cref="ComboBox"/>, etc).
	/// </summary>
	/// <param name="items">String like <c>"One|Two|Three"</c>.</param>
	/// <exception cref="NotSupportedException">The last added element is not <see cref="ItemsControl"/>.</exception>
	/// <remarks>
	/// If it is a non-editable <see cref="ComboBox"/>, selects the first item. See also <see cref="Select"/>.
	/// </remarks>
	public wpfBuilder Items(string items) => _Items(items.Split('|'), null);
	
	/// <summary>
	/// Adds items of any type to the last added <see cref="ItemsControl"/> (<see cref="ComboBox"/>, etc).
	/// </summary>
	/// <param name="items">Items of any type (<c>string</c>, WPF element).</param>
	/// <exception cref="NotSupportedException">The last added element is not <see cref="ItemsControl"/>.</exception>
	/// <remarks>
	/// If it is a non-editable <see cref="ComboBox"/>, selects the first item. See also <see cref="Select"/>.
	/// </remarks>
	public wpfBuilder Items(params object[] items) => _Items(items, null);
	
	wpfBuilder _Items(object[] a, IEnumerable e) {
		var ic = Last as ItemsControl ?? throw new NotSupportedException("Items(): Last added must be ItemsControl, for example ComboBox");
		ic.ItemsSource = null;
		if (a != null) {
			ic.Items.Clear();
			foreach (var v in a) ic.Items.Add(v);
		} else if (e != null) {
			ic.ItemsSource = e;
		}
		if (Last is ComboBox cb && !cb.IsEditable && cb.HasItems) cb.SelectedIndex = 0;
		return this;
	}
	
	/// <summary>
	/// Adds items as <see cref="IEnumerable"/> to the last added <see cref="ItemsControl"/> (<see cref="ComboBox"/>, etc), with "lazy" option.
	/// </summary>
	/// <param name="items">An <see cref="IEnumerable"/> that contains items (eg array, <see cref="List{T}"/>) or generates items (eg returned from a yield-return function).</param>
	/// <param name="lazy">Retrieve items when (if) showing the dropdown part of the <see cref="ComboBox"/> first time.</param>
	/// <exception cref="NotSupportedException">
	/// - The last added element is not <see cref="ItemsControl"/>.
	/// - <i>lazy</i> is <c>true</c> and the last added element is not <see cref="ComboBox"/>.
	/// </exception>
	public wpfBuilder Items(IEnumerable items, bool lazy = false) => lazy ? Items(true, o => o.ItemsSource = items) : _Items(null, items);
	
	/// <summary>
	/// Sets callback function that should add items to the last added <see cref="ComboBox"/> later.
	/// </summary>
	/// <param name="once">Call the function once. If <c>false</c>, calls on each drop down.</param>
	/// <param name="onDropDown">Callback function that should add items. Called before showing the dropdown part of the <see cref="ComboBox"/>. Don't need to clear old items.</param>
	/// <exception cref="NotSupportedException">The last added element is not <see cref="ComboBox"/>.</exception>
	public wpfBuilder Items(bool once, Action<ComboBox> onDropDown) {
		var c = Last as ComboBox ?? throw new NotSupportedException("Items(): Last added must be ComboBox");
		EventHandler d = null;
		d = (_, _) => {
			if (once) c.DropDownOpened -= d;
			if (c.ItemsSource != null) c.ItemsSource = null; else c.Items.Clear();
			onDropDown(c);
		};
		c.DropDownOpened += d;
		return this;
	}
	
	/// <summary>
	/// Selects an item of the last added <see cref="Selector"/> (<see cref="ComboBox"/>, etc).
	/// </summary>
	/// <param name="index">0-based item index</param>
	/// <exception cref="NotSupportedException">The last added element is not <see cref="Selector"/>.</exception>
	/// <seealso cref="Items"/>
	public wpfBuilder Select(int index) {
		var c = Last as Selector ?? throw new NotSupportedException("Items(): Last added must be Selector, for example ComboBox or ListBox");
		c.SelectedIndex = index;
		return this;
	}
	
	/// <summary>
	/// Selects an item of the last added <see cref="Selector"/> (<see cref="ComboBox"/>, etc).
	/// </summary>
	/// <param name="item">An added item.</param>
	/// <exception cref="NotSupportedException">The last added element is not <see cref="Selector"/>.</exception>
	/// <seealso cref="Items"/>
	public wpfBuilder Select(object item) {
		var c = Last as Selector ?? throw new NotSupportedException("Items(): Last added must be Selector, for example ComboBox or ListBox");
		c.SelectedItem = item;
		return this;
	}
	
	/// <summary>
	/// Obsolete. Use <see cref="FormatText"/>.
	/// Adds inlines to the last added <see cref="TextBlock"/>.
	/// </summary>
	/// <param name="inlines">
	/// Arguments of type:
	/// <br/>• string like <c>"&lt;b>text"</c>, <c>"&lt;i>text"</c> or <c>"&lt;u>text"</c> adds inline of type <c>Bold</c>, <c>Italic</c> or <c>Underline</c>.
	/// <br/>• string like <c>"&lt;a>text"</c> adds <see cref="Hyperlink"/>. Next argument of type <c>Action</c> or <c>Action&lt;Hyperlink&gt;</c> sets its action.
	/// <br/>• other string - plain text.
	/// <br/>• <see cref="WBLink"/> adds a hyperlink.
	/// <br/>• <see cref="Inline"/> of any type, eg <c>Run</c>, <c>Bold</c>, <c>Hyperlink</c>.
	/// <br/>• <see cref="UIElement"/>.
	/// </param>
	/// <exception cref="NotSupportedException">The last added element is not <c>TextBlock</c>.</exception>
	/// <exception cref="ArgumentException">Unsupported argument type.</exception>
	/// <example>
	/// <code><![CDATA[
	/// b.R.Add<TextBlock>().Text(
	/// 	"Text ", "<b>bold ", "\n",
	/// 	new WBLink("libreautomate", "https://www.libreautomate.com"), ", ",
	/// 	new WBLink("Action", _ => print.it("click"), bold: true), "\n",
	/// 	new Run("color") { Foreground = Brushes.Blue, Background = Brushes.Cornsilk, FontSize = 20 }, "\n",
	/// 	"controls", new TextBox() { MinWidth = 100, Height = 20, Margin = new(3) }, new CheckBox() { Content = "Check" }, "\n",
	/// 	"image", ImageUtil.LoadWpfImageElement("*PixelartIcons.Notes #0060F0")
	/// 	);
	/// ]]></code>
	/// </example>
	[EditorBrowsable(EditorBrowsableState.Never)] //obsolete
	public wpfBuilder Text(params object[] inlines) {
		var c = Last as TextBlock ?? throw new NotSupportedException("Text(): Last added must be TextBlock");
		var k = c.Inlines;
		k.Clear();
		Hyperlink link = null;
		foreach (var v in inlines) {
			Inline n = null; int i;
			switch (v) {
			case WBLink x:
				n = x.Hlink;
				break;
			case Hyperlink x:
				n = link = x;
				break;
			case Inline x:
				n = x;
				break;
			case Action x when link != null: //<a> fbc
				link.Click += (o, e) => x();
				continue;
			case Action<Hyperlink> x when link != null: //<a> fbc
				link.Click += (o, e) => x(o as Hyperlink);
				continue;
			case UIElement x:
				n = new InlineUIContainer(x) { BaselineAlignment = BaselineAlignment.Center };
				break;
			case string x:
				if (x.Starts('<') && (i = x.Starts(false, "<a>", "<b>", "<i>", "<u>")) > 0) {
					var run = new Run(x[3..]);
					switch (i) {
					case 1: n = link = new Hyperlink(run); break;
					case 2: n = new Bold(run); break;
					case 3: n = new Italic(run); break;
					case 4: n = new Underline(run); break;
					}
				} else {
					k.Add(x);
					continue;
				}
				break;
			default: throw new ArgumentException("Text(): unsupported argument type");
			}
			k.Add(n);
		}
		return this;
	}
	
	/// <summary>
	/// Adds inlines (text, formatted text, hyperlinks, images, etc) to the last added <see cref="TextBlock"/> etc.
	/// </summary>
	/// <param name="text">
	/// Interpolated string (like <c>$"string"</c>) with tags etc. The format is XML without root element.
	/// <para>
	/// These tags add inlines of these types:
	/// <br/>• <c>&lt;b>text&lt;/b></c> - <see cref="Bold"/>.
	/// <br/>• <c>&lt;i>text&lt;/i></c> - <see cref="Italic"/>.
	/// <br/>• <c>&lt;u>text&lt;/u></c> - <see cref="Underline"/>.
	/// <br/>• <c>&lt;s>text&lt;/s></c> - <see cref="D.Span"/>.
	/// <br/>• <c>&lt;s {Span}>text&lt;/s></c> - <see cref="D.Span"/> or a <see cref="D.Span"/>-based type. The function adds <c>text</c> to its <c>Inlines</c> collection.
	/// <br/>• <c>&lt;a {Action or Action&lt;Hyperlink>}>text&lt;/a></c> - <see cref="Hyperlink"/> that calls the action.
	/// <br/>• <c>&lt;a href='URL or path etc'>text&lt;/a></c> - <see cref="Hyperlink"/> that calls <see cref="run.itSafe"/>.
	/// </para>
	/// <para>
	/// Tags can have these attributes, like <c>&lt;s c='red' FontSize = '20'>text&lt;/s></c>:
	/// <br/>• <c>c</c> or <c>Foreground</c> - text color, like <c>'red'</c> or <c>'#AARRGGBB'</c> or <c>'#RRGGBB'</c> or <c>'#ARGB'</c> or <c>'#RGB'</c>.
	/// <br/>• <c>b</c> or <c>Background</c> - background color.
	/// <br/>• <c>FontFamily</c> - font name, like <c>'Consolas'</c>.
	/// <br/>• <c>FontSize</c> - font size, like <c>'20'</c>.
	/// <br/>• <c>ToolTip</c> - tooltip text.
	/// </para>
	/// <para>
	/// WPF elements of these types can be inserted without tags:
	/// <br/>• <c>{Inline}</c> - any inline, eg <see cref="Run"/>. See also <c>&lt;s {Span}>text&lt;/s></c>.
	/// <br/>• <c>{UIElement}</c> - a WPF element, eg <see cref="CheckBox"/> or <see cref="C.Image"/>.
	/// <br/>• <c>{ImageSource}</c> - adds <see cref="C.Image"/>.
	/// <br/>• <c>{IEnumerable&lt;Inline>}</c> - adds multiple <see cref="Inline"/>.
	/// </para>
	/// XML special characters must be escaped:
	/// <br/>• <c>&lt;</c> - <c>&amp;lt;</c>.
	/// <br/>• <c>&amp;</c> - <c>&amp;amp;</c>.
	/// <br/>• <c>'</c>, <c>"</c> - <c>&amp;apos;</c> in <c>'attribute'</c> or <c>&amp;quot;</c> in <c>"attribute"</c>.
	/// <para>
	/// </para>
	/// The <c>text</c> in above examples can contain nested tags and elements.
	/// The <c>&lt;a></c> tag creates an image hyperlink if <c>text</c> is <c>{image}</c>, where image is a <see cref="UIElement"/> with image (see <see cref="ImageUtil.LoadWpfImageElement"/>) or <see cref="ImageSource"/> (see <see cref="ImageUtil.LoadWpfImage"/>, <see cref="icon.ToWpfImage"/>).
	/// </param>
	/// <exception cref="NotSupportedException">Unsupported type of the last added element. Or supported type but non-empty <c>Content</c> and <c>Header</c> (read Remarks).</exception>
	/// <exception cref="ArgumentException">Unknown <c>&lt;tag></c> or unsupported <c>{object}</c> type.</exception>
	/// <exception cref="InvalidOperationException">The same <c>{Span}</c> or <c>{Inline}</c> object in multiple places.</exception>
	/// <exception cref="FormatException">Invalid color attribute.</exception>
	/// <exception cref="Exception">Exceptions of <see cref="XElement.Parse"/>.</exception>
	/// <remarks>
	/// The last added element can be of type:
	/// <br/>• <see cref="TextBlock"/> - the function adds inlines to its <c>Inlines</c> collection.
	/// <br/>• <see cref="ContentControl"/> (eg <see cref="Label"/> or <see cref="Button"/>) - creates new <see cref="TextBlock"/> with inlines and sets its <c>Content</c> property if it is <c>null</c>. If <see cref="HeaderedContentControl"/> (eg <see cref="GroupBox"/>) and its <c>Header</c> property is <c>null</c>, sets <c>Header</c> instead.
	/// <br/>• <see cref="Panel"/> whose <c>Parent</c> is <see cref="HeaderedContentControl"/> (eg <c>b.StartGrid&lt;GroupBox>(null).FormatText($"...")</c>) - uses the <see cref="HeaderedContentControl"/> like the above.
	///
	/// For elements other than the last added use <see cref="formatTextOf(object, InterpolatedString)"/> or <see cref="formattedText(InterpolatedString)"/>.
	///
	/// To load images can be used <see cref="ImageUtil.LoadWpfImageElement"/> and <see cref="ImageUtil.LoadWpfImage"/>.
	/// </remarks>
	/// <example>
	/// <code><![CDATA[
	/// b.R.Add<TextBlock>().FormatText($"""
	/// Text <b>bold</b> <i>italic <u>underline</u>.</i>
	/// <s c='GreenYellow' b='Black' FontFamily='Consolas' FontSize='20'>attributes</s>
	/// <s {new Span() { Foreground = Brushes.Red, Background = new LinearGradientBrush(Colors.GreenYellow, Colors.Transparent, 90) }}>Span object, <b>bold</b></s>
	/// <a href='https://www.example.com'>example.com</a> <b><a href='notepad.exe'>Notepad</a></b>
	/// <a {() => { print.it("click"); }}>click</a> <a {(Hyperlink h) => { print.it("click once"); h.IsEnabled = false; }}>click once</a>
	/// <a {() => { print.it("click"); }} ToolTip='image hyperlink'>{ImageUtil.LoadWpfImageElement("*Entypo.HelpWithCircle #008EEE @14")}</a>
	/// {new Run("Run object") { Foreground = Brushes.Blue, Background = Brushes.Goldenrod, FontSize = 20 }}
	/// Image {ImageUtil.LoadWpfImageElement("*PixelartIcons.Notes #0060F0")}<!-- or ImageUtil.LoadWpfImage(@"C:\Test\image.png") -->
	/// Controls {new TextBox() { MinWidth = 100, Height = 20, Margin = new(3) }} {new CheckBox() { Content = "Check" }}
	/// """);
	/// ]]></code>
	/// Build interpolated string at run time.
	/// <code><![CDATA[
	/// wpfBuilder.InterpolatedString s = new();
	/// s.AppendLiteral("Text <b>bold</b> <a ");
	/// s.AppendFormatted(() => { print.it("click"); });
	/// s.AppendLiteral(">link</a>.");
	/// b.R.Add<TextBlock>().FormatText(s);
	/// ]]></code>
	/// </example>
	public wpfBuilder FormatText(InterpolatedString text) {
		var s = text.GetFormattedText();
		_FormatText(Last, s, text.aObj);
		return this;
	}
	
	//rejected: overload `FormatText(string text)` that supports only tags where don't need {object}.
	
	/// <summary>
	/// Adds inlines (text, formatted text, hyperlinks, images, etc) to the specified <see cref="TextBlock"/> etc.
	/// </summary>
	/// <param name="obj">Object of type <see cref="TextBlock"/>, <see cref="ContentControl"/> or <see cref="InlineCollection"/>. More info in <see cref="FormatText(InterpolatedString)"/> remarks.</param>
	/// <exception cref="NotSupportedException">Unsupported <i>obj</i> type or non-empty <c>Content</c>/<c>Header</c>.</exception>
	/// <exception cref="ArgumentException">Unknown <c>&lt;tag></c> or unsupported <c>{object}</c> type.</exception>
	/// <exception cref="InvalidOperationException">The same <c>{Span}</c> or <c>{Inline}</c> object in multiple places.</exception>
	/// <exception cref="FormatException">Invalid color attribute.</exception>
	/// <exception cref="Exception">Exceptions of <see cref="XElement.Parse"/>.</exception>
	/// <inheritdoc cref="FormatText(InterpolatedString)" path="/param"/>
	public static void formatTextOf(object obj, InterpolatedString text) {
		var s = text.GetFormattedText();
		_FormatText(obj, s, text.aObj);
	}
	
	/// <summary>
	/// Creates new <see cref="TextBlock"/> and adds inlines like <see cref="FormatText(InterpolatedString)"/>.
	/// </summary>
	/// <exception cref="ArgumentException">Unknown <c>&lt;tag></c> or unsupported <c>{object}</c> type.</exception>
	/// <exception cref="InvalidOperationException">The same <c>{Span}</c> or <c>{Inline}</c> object in multiple places.</exception>
	/// <exception cref="FormatException">Invalid color attribute.</exception>
	/// <exception cref="Exception">Exceptions of <see cref="XElement.Parse"/>.</exception>
	/// <inheritdoc cref="FormatText(InterpolatedString)" path="/param"/>
	/// <example>
	/// <code><![CDATA[
	/// b.R.Add(wpfBuilder.formattedText($"<b>Label</b>"), out TextBox _);
	/// b.R.AddButton(_TextWithIcon("Button", "*PixelartIcons.Notes #0060F0"), _ => { print.it("Button clicked"); });
	/// 
	/// static TextBlock _TextWithIcon(string text, string icon) {
	/// 	var e = ImageUtil.LoadWpfImageElement(icon);
	/// 	e.Margin = new(0, 0, 4, 0);
	/// 	return wpfBuilder.formattedText($"{e}{text}");
	/// }
	/// ]]></code>
	/// </example>
	public static TextBlock formattedText(InterpolatedString text) {
		var e = new TextBlock();
		var s = text.GetFormattedText();
		_FormatText(e, s, text.aObj);
		return e;
	}
	
	static void _FormatText(object obj, string text, List<object> a) {
		//print.it(text, a);
		InlineCollection ic;
		g1:
		switch (obj) {
		case TextBlock k: ic = k.Inlines; break;
		case HeaderedContentControl k: k.Header = obj = new TextBlock(); goto g1;
		case ContentControl k: k.Content = obj = new TextBlock(); goto g1;
		case Panel k when k.Parent is HeaderedContentControl p1: obj = p1; goto g1; //eg b.StartGrid<GroupBox>(null).FormatText($"...")
		case InlineCollection k: ic = k; break;
		default: throw new NotSupportedException("Format(): unsupported element type");
		}
		ic.Clear();
		
		var xr = XElement.Parse("<x>" + text + "</x>", LoadOptions.PreserveWhitespace);
		_Enum(ic, xr);
		
		void _Enum(InlineCollection ic, XElement xp) {
			for (var xn = xp.FirstNode; xn != null; xn = xn.NextNode) {
				if (xn is XElement xe) _Element(xe);
				else if (xn is XText xt) _Text(xt); //also XCData
			}
			
			void _Element(XElement x) {
				Span r = null;
				Hyperlink h = null;
				var tag = x.Name.LocalName;
				switch (tag) {
				case "b": r = new Bold(); break;
				case "i": r = new Italic(); break;
				case "u": r = new Underline(); break;
				case "s":
					if (_GetAttrObj() is object o) { //<s {Span}>...</s>
						r = o as Span ?? throw new ArgumentException("Expected <s {Span}>");
						if (r.Parent != null) throw new InvalidOperationException("Reused {Span} object");
					} else { //<s attributes}>...</s>
						r = new();
					}
					break;
				case "a":
					h = new Hyperlink();
					r = h;
					if (x.Attr("href") is string href) { //<a href='...'>
						h.Click += (_, _) => run.itSafe(href);
					} else { //<a {Action}>
						switch (_GetAttrObj()) {
						case Action g: h.Click += (_, _) => g(); break;
						case Action<Hyperlink> g: h.Click += (_, _) => g(h); break;
						default: throw new ArgumentException("Expected <a {Action}> or <a href='...'>");
						}
					}
					break;
				default: throw new ArgumentException($"Unknown tag <{tag}>");
				}
				
				foreach (var at in x.Attributes()) {
					var v = at.Value;
					switch (at.Name.LocalName) {
					case "c" or "Foreground": r.Foreground = _Brush(v); break;
					case "b" or "Background": r.Background = _Brush(v); break;
					case "FontFamily": r.FontFamily = new(v); break;
					case "FontSize": if (v.ToNumber(out double fsize)) r.FontSize = fsize; break;
					case "ToolTip": r.ToolTip = v; break;
					}
				}
				
				ic.Add(r);
				if (h == null || !_HyperlinkImage(x, h))
					_Enum(r.Inlines, x);
				
				object _GetAttrObj() => a != null && x.Attr("_a") is string s && s.Starts(c_mark2) && s.ToInt(out int i1, c_mark2.Length) ? a[i1] : null;
				static Brush _Brush(string v) => new SolidColorBrush((Color)ColorConverter.ConvertFromString(v));
			}
			
			void _Text(XText x) {
				var s = x.Value;
				if (a != null) {
					int from = 0;
					for (; from < s.Length; from++) {
						int m = s.Find(c_mark, from);
						if (m < 0) break;
						if (m > from) ic.Add(s[from..m]);
						if (s.ToInt(out int i, m + c_mark.Length, out from)) {
							var k = a[i];
							g2:
							switch (k) {
							case Inline e:
								if (e.Parent != null) throw new InvalidOperationException("Reused {Inline} object");
								ic.Add(e);
								break;
							case UIElement e:
								ic.Add(new InlineUIContainer(e) { BaselineAlignment = BaselineAlignment.Center });
								break;
							case ImageSource e:
								k = new Image { Source = e, Stretch = Stretch.None };
								goto g2;
							case IEnumerable<Inline> e:
								ic.AddRange(e);
								break;
							default: throw new ArgumentException($"Unexpected element type {a[i]}");
							}
						}
					}
					if (from < s.Length) ic.Add(s[from..]);
				} else ic.Add(s);
			}
		}
		
		bool _HyperlinkImage(XElement x, Hyperlink h) {
			if (x.FirstNode is XText xt && xt.NextNode == null && xt.Value is string s && s.Starts(c_mark) && s.ToInt(out int i, c_mark.Length, out int end) && end == s.Length - 1) {
				UIElement eImg = a[i] switch {
					UIElement e => e,
					ImageSource e => new Image { Source = e, Stretch = Stretch.None },
					_ => null
				};
				if (eImg == null) return false;
				
				Border border = new() { //workaround for: image's transparent areas are not hittest-sensitive. InlineUIContainer.Background does not fix it.
					Child = eImg,
					Background = Brushes.Transparent,
					Padding = new(0, 2, 0, 0)
				};
				InlineUIContainer uc = new(border) { BaselineAlignment = BaselineAlignment.Center };
				h.Inlines.Add(uc);
				h.TextDecorations = null;
				return true;
			}
			return false;
		}
	}
	
	const string c_mark = "_a='≡∫∫≡", c_mark2 = "≡∫∫≡"; //start of mark. Full mark is like "_a='≡∫∫≡0'", where 0 is aObj index. With this format, can be used as an XML attribute, as well as in XML text.
	
#pragma warning disable 1591 //no XML doc
	[InterpolatedStringHandler, NoDoc]
	public ref struct InterpolatedString {
		DefaultInterpolatedStringHandler _f;
		internal List<object> aObj;
		
		public InterpolatedString(int literalLength, int formattedCount) {
			_f = new(literalLength, formattedCount);
		}
		
		public InterpolatedString(int literalLength, int formattedCount, IFormatProvider provider) {
			_f = new(literalLength, formattedCount, provider);
		}
		
		public InterpolatedString(int literalLength, int formattedCount, IFormatProvider provider, Span<char> initialBuffer) {
			_f = new(literalLength, formattedCount, provider, initialBuffer);
		}
		
		public void AppendLiteral(string value)
			 => _f.AppendLiteral(value);
		
		public void AppendFormatted(string value)
			=> _f.AppendFormatted(value);
		
		public void AppendFormatted<T>(T value) {
			if (value is Delegate or DependencyObject or IEnumerable<Inline>) {
				aObj ??= new();
				_f.AppendLiteral(c_mark);
				_f.AppendLiteral(aObj.Count.ToS());
				_f.AppendLiteral("'");
				aObj.Add(value);
			} else _f.AppendFormatted(value);
		}
		
		public void AppendFormatted<T>(T value, int alignment)
			 => _f.AppendFormatted(value, alignment);
		
		public void AppendFormatted<T>(T value, string format) {
			_f.AppendFormatted(value, format);
		}
		
		public void AppendFormatted<T>(T value, int alignment, string format) {
			_f.AppendFormatted(value, alignment, format);
		}
		
		public void AppendFormatted(RStr value)
			=> _f.AppendFormatted(value);
		
		public void AppendFormatted(RStr value, int alignment = 0, string format = null)
			=> _f.AppendFormatted(value, alignment, format);
		
		public void AppendFormatted(string value, int alignment = 0, string format = null)
			=> _f.AppendFormatted(value, alignment, format);
		
		public void AppendFormatted(object value, int alignment = 0, string format = null)
			=> _f.AppendFormatted(value, alignment, format);
		
		public string GetFormattedText() => _f.ToStringAndClear();
	}
#pragma warning restore 1591
	
	/// <summary>
	/// Loads a web page or RTF text from a file or URL into the last added element.
	/// </summary>
	/// <param name="source">File or URL to load. Supported element types and sources:
	/// <see cref="WebBrowser"/>, <see cref="Frame"/> - URL or file path.
	/// <see cref="RichTextBox"/> - path of a local <c>.rtf</c> file.
	/// </param>
	/// <exception cref="NotSupportedException">
	/// - Unsupported element type.
	/// - <see cref="RichTextBox"/> <i>source</i> does not end with <c>".rtf"</c>.
	/// </exception>
	/// <remarks>
	/// If fails to load, prints warning. See <see cref="print.warning"/>.
	/// </remarks>
	public wpfBuilder LoadFile(string source) {
		var c = Last;
		bool bad = false;
		try {
			source = _UriNormalize(source);
			switch (c) {
			case WebBrowser u: u.Source = new Uri(source); break;
			case Frame u: u.Source = new Uri(source); break;
			case RichTextBox u when source.Ends(".rtf", true):
				using (var fs = File.OpenRead(source)) { u.Selection.Load(fs, DataFormats.Rtf); }
				//also supports DataFormats.Text,Xaml,XamlPackage. If need HTML, download and try HtmlToXamlConverter. See https://www.codeproject.com/Articles/1097390/Displaying-HTML-in-a-WPF-RichTextBox
				break;
			default: bad = true; break;
			}
		}
		catch (Exception ex) { print.warning("LoadFile() failed. " + ex.ToString(), -1); }
		if (bad) throw new NotSupportedException("LoadFile(): Unsupported type of element or source.");
		return this;
	}
	
	/// <summary>
	/// Loads image into the last added <see cref="C.Image"/>.
	/// </summary>
	/// <param name="source">Sets <see cref="Image.Source"/>.</param>
	/// <param name="stretch">Sets <see cref="Image.Stretch"/>.</param>
	/// <param name="stretchDirection">Sets <see cref="Image.StretchDirection"/>.</param>
	/// <exception cref="NotSupportedException">The last added element is not <see cref="C.Image"/>.</exception>
	/// <remarks>
	/// To load vector images from XAML, don't use <see cref="C.Image"/> control and this function. Instead create control from XAML, for example with <see cref="ImageUtil.LoadWpfImageElement"/>, and add it with <see cref="Add(FrameworkElement, bool)"/>.
	/// </remarks>
	/// <seealso cref="icon.ToWpfImage"/>
	/// <seealso cref="ImageUtil"/>
	public wpfBuilder Image(ImageSource source, Stretch stretch = Stretch.None, StretchDirection stretchDirection = StretchDirection.DownOnly)
		 => _Image(source, null, stretch, stretchDirection);
	
	wpfBuilder _Image(ImageSource source, string file, Stretch stretch, StretchDirection stretchDirection) {
		var c = Last as Image ?? throw new NotSupportedException("Image(): Last added must be Image");
		if (file != null) {
			//try { source = new BitmapImage(_Uri(file)); }
			try { source = ImageUtil.LoadWpfImage(file); }
			catch (Exception ex) { print.warning("Image() failed. " + ex.ToString(), -1); }
		}
		c.Stretch = stretch; //default Uniform
		c.StretchDirection = stretchDirection; //default Both
		c.Source = source;
		return this;
	}
	
	/// <summary>
	/// Loads image from a file or URL into the last added <see cref="C.Image"/>.
	/// </summary>
	/// <param name="source">File path etc. See <see cref="ImageUtil.LoadWpfImage"/>. Sets <see cref="Image.Source"/>.</param>
	/// <param name="stretch">Sets <see cref="Image.Stretch"/>.</param>
	/// <param name="stretchDirection">Sets <see cref="Image.StretchDirection"/>.</param>
	/// <exception cref="NotSupportedException">The last added element is not <see cref="C.Image"/>.</exception>
	/// <remarks>
	/// If fails to load, prints warning. See <see cref="print.warning"/>.
	/// </remarks>
	public wpfBuilder Image(string source, Stretch stretch = Stretch.None, StretchDirection stretchDirection = StretchDirection.DownOnly)
		=> _Image(null, source, stretch, stretchDirection);
	
	/// <summary>
	/// Sets vertical or horizontal splitter properties of the last added <see cref="GridSplitter"/>.
	/// </summary>
	/// <param name="vertical">If <c>true</c>, resizes columns, else rows.</param>
	/// <param name="span">How many rows spans vertical splitter, or how many columns spans horizontal splitter. Can be more than row/column count.</param>
	/// <param name="thickness">Width of vertical splitter or height of horizontal. If <c>double.NaN</c>, sets alignment "stretch", else "center".</param>
	/// <exception cref="NotSupportedException">The last added element is not <see cref="GridSplitter"/>.</exception>
	/// <example>
	/// Vertical splitter.
	/// <code><![CDATA[
	/// var b = new wpfBuilder("Window").WinSize(400)
	/// 	.Columns(30.., 0, -1) //the middle column is for splitter; the 30 is minimal width
	/// 	.R.Add(out TextBox _)
	/// 	.Add<GridSplitter>().Splitter(true, 2).Brush(Brushes.Orange) //add splitter in the middle column
	/// 	.Add(out TextBox _)
	/// 	.R.Add(out TextBox _).Skip().Add(out TextBox _) //skip the splitter's column
	/// 	.R.AddOkCancel()
	/// 	.End();
	/// if (!b.ShowDialog()) return;
	/// ]]></code>
	/// Horizontal splitter.
	/// <code><![CDATA[
	/// var b = new wpfBuilder("Window").WinSize(300, 300)
	/// 	.Row(27..).Add("Row", out TextBox _)
	/// 	.Add<GridSplitter>().Splitter(false, 2).Brush(Brushes.Orange)
	/// 	.Row(-1).Add("Row", out TextBox _)
	/// 	.R.AddOkCancel()
	/// 	.End();
	/// if (!b.ShowDialog()) return;
	/// ]]></code>
	/// </example>
	public wpfBuilder Splitter(bool vertical, int span = 1, double thickness = 4) {
		var g = _ParentOfLastAsOrThrow<_Grid>();
		var c = Last as GridSplitter ?? throw new NotSupportedException("Splitter(): Last added must be GridSplitter");
		if (vertical) {
			c.HorizontalAlignment = double.IsNaN(thickness) ? HorizontalAlignment.Stretch : HorizontalAlignment.Center;
			c.VerticalAlignment = VerticalAlignment.Stretch;
			c.ResizeDirection = GridResizeDirection.Columns;
			c.Width = thickness;
			if (span != 1) Grid.SetRowSpan(c, span);
		} else {
			c.HorizontalAlignment = HorizontalAlignment.Stretch;
			c.VerticalAlignment = double.IsNaN(thickness) ? VerticalAlignment.Stretch : VerticalAlignment.Center;
			c.ResizeDirection = GridResizeDirection.Rows;
			c.Height = thickness;
			if (span != 1) g.Span(span);
		}
		c.ResizeBehavior = GridResizeBehavior.PreviousAndNext;
		return this;
	}
	
	//FUTURE: need a numeric input control. This code is for WinForms NumericUpDown.
	//	public wpfBuilder Number(decimal? value = null, decimal? min = null, decimal? max=null, decimal? increment=null, int? decimalPlaces=null, bool? thousandsSeparator=null, bool? hex =null) {
	//		var c = Last as NumericUpDown ?? throw new NotSupportedException("Number(): Last added must be NumericUpDown");
	//		if(min!=null) c.Minimum=min.Value;
	//		if(max!=null) c.Maximum=max.Value;
	//		if(increment!=null) c.Increment=increment.Value;
	//		if(decimalPlaces!=null) c.DecimalPlaces=decimalPlaces.Value;
	//		if(thousandsSeparator!=null) c.ThousandsSeparator=thousandsSeparator.Value;
	//		if(hex!=null) c.Hexadecimal=hex.Value;
	//		if(value!=null) c.Value=value.Value; else c.Text=null;
	//		return this;
	//	}
	
	#endregion
	
	#region nested panel
	
	wpfBuilder _Start(_PanelBase p, bool childOfLast) {
		_p.BeforeAdd(childOfLast);
		_AddToParent(p.panel, childOfLast);
		_p = p;
		return this;
	}
	
	wpfBuilder _Start<T>(_PanelBase p, out T container, object header) where T : HeaderedContentControl, new() {
		Add(out container, header);
		container.Content = p.panel;
		if (container is GroupBox) p.panel.Margin = new(0, 2, 0, 0);
		_p = p;
		return this;
	}
	
	
	/// <summary>
	/// Adds <see cref="Grid"/> panel (table) that will contain elements added with <see cref="Add"/> etc. Finally call <see cref="End"/> to return to current panel.
	/// </summary>
	/// <param name="childOfLast">Add as a child or content of the last added element (<see cref="Last"/>), which must be a <see cref="Decorator"/> (for example <see cref="C.Border"/> or <see cref="AdornerDecorator"/>) or <see cref="ContentControl"/> (for example <see cref="Button"/>).</param>
	/// <remarks>
	/// How <see cref="Last"/> changes: after calling this function it is the grid (<see cref="Panel"/>); after adding an element it is the element; finally, after calling <see cref="End"/> it is the grid if <i>childOfLast</i> <c>false</c>, else its parent. The same with all <c>StartX</c> functions.
	/// </remarks>
	public wpfBuilder StartGrid(bool childOfLast = false)
		=> _Start(new _Grid(this), childOfLast);
	
	/// <summary>
	/// Adds a headered content control (<see cref="GroupBox"/>, <see cref="Expander"/>, etc) with child <see cref="Grid"/> panel (table) that will contain elements added with <see cref="Add"/> etc. Finally call <see cref="End"/> to return to current panel.
	/// </summary>
	/// <param name="header">Header text/content.</param>
	/// <remarks>
	/// How <see cref="Last"/> changes: after calling this function it is the grid (<see cref="Panel"/>); after adding an element it is the element; finally, after calling <see cref="End"/> it is the content control (grid's parent). The same with all <c>StartX</c> functions.
	/// </remarks>
	/// <example>
	/// <code><![CDATA[
	/// b.StartGrid<GroupBox>("Group");
	/// ]]></code>
	/// </example>
	public wpfBuilder StartGrid<T>(object header) where T : HeaderedContentControl, new()
		=> _Start(new _Grid(this), out T _, header);
	
	/// <param name="container">Receives the content control's variable. The function creates new control of the type.</param>
	/// <example>
	/// <code><![CDATA[
	/// b.StartGrid(out Expander g, "Expander"); g.IsExpanded=true;
	/// ]]></code>
	/// </example>
	/// <inheritdoc cref="StartGrid{T}(object)"/>
	public wpfBuilder StartGrid<T>(out T container, object header) where T : HeaderedContentControl, new()
		=> _Start(new _Grid(this), out container, header);
	
	
	
	/// <summary>
	/// Adds <see cref="Canvas"/> panel that will contain elements added with <see cref="Add"/> etc. Finally call <see cref="End"/> to return to current panel.
	/// </summary>
	/// <param name="childOfLast"><inheritdoc cref="StartGrid(bool)" path="/param[@name='childOfLast']/node()"/></param>
	/// <remarks>
	/// For each added control call <see cref="XY"/> or use indexer like <c>[x, y]</c> or <c>[x, y, width, height]</c>.
	/// </remarks>
	public wpfBuilder StartCanvas(bool childOfLast = false)
		=> _Start(new _Canvas(this), childOfLast);
	
	/// <summary>
	/// Adds a headered content control (<see cref="GroupBox"/>, <see cref="Expander"/>, etc) with child <see cref="Canvas"/> panel that will contain elements added with <see cref="Add"/> etc. Finally call <see cref="End"/> to return to current panel.
	/// </summary>
	/// <param name="header">Header text/content.</param>
	public wpfBuilder StartCanvas<T>(object header) where T : HeaderedContentControl, new()
		=> _Start(new _Canvas(this), out T _, header);
	
	/// <param name="container">Receives the content control's variable. The function creates new control of the type.</param>
	/// <inheritdoc cref="StartCanvas{T}(object)"/>
	public wpfBuilder StartCanvas<T>(out T container, object header) where T : HeaderedContentControl, new()
		=> _Start(new _Canvas(this), out container, header);
	
	
	/// <summary>
	/// Adds <see cref="DockPanel"/> panel that will contain elements added with <see cref="Add"/> etc. Finally call <see cref="End"/> to return to current panel.
	/// </summary>
	/// <param name="childOfLast"><inheritdoc cref="StartGrid(bool)" path="/param[@name='childOfLast']/node()"/></param>
	/// <remarks>
	/// For added elements call <see cref="Dock"/>, maybe except for the last element that fills remaining space.
	/// </remarks>
	public wpfBuilder StartDock(bool childOfLast = false)
		=> _Start(new _DockPanel(this), childOfLast);
	
	/// <summary>
	/// Adds a headered content control (<see cref="GroupBox"/>, <see cref="Expander"/>, etc) with child <see cref="DockPanel"/> panel that will contain elements added with <see cref="Add"/> etc. Finally call <see cref="End"/> to return to current panel.
	/// </summary>
	/// <param name="header">Header text/content.</param>
	public wpfBuilder StartDock<T>(object header) where T : HeaderedContentControl, new()
		=> _Start(new _DockPanel(this), out T _, header);
	
	/// <param name="container">Receives the content control's variable. The function creates new control of the type.</param>
	/// <inheritdoc cref="StartDock{T}(object)"/>
	public wpfBuilder StartDock<T>(out T container, object header) where T : HeaderedContentControl, new()
		=> _Start(new _DockPanel(this), out container, header);
	
	
	/// <summary>
	/// Adds <see cref="StackPanel"/> panel that will contain elements added with <see cref="Add"/> etc. Finally call <see cref="End"/> to return to current panel.
	/// </summary>
	/// <param name="vertical"></param>
	/// <param name="childOfLast"><inheritdoc cref="StartGrid(bool)" path="/param[@name='childOfLast']/node()"/></param>
	public wpfBuilder StartStack(bool vertical = false, bool childOfLast = false)
		=> _Start(new _StackPanel(this, vertical), childOfLast);
	
	/// <summary>
	/// Adds a headered content control (<see cref="GroupBox"/>, <see cref="Expander"/>, etc) with child <see cref="StackPanel"/> panel that will contain elements added with <see cref="Add"/> etc. Finally call <see cref="End"/> to return to current panel.
	/// </summary>
	/// <param name="header">Header text/content.</param>
	/// <param name="vertical"></param>
	public wpfBuilder StartStack<T>(object header, bool vertical = false) where T : HeaderedContentControl, new()
		=> _Start(new _StackPanel(this, vertical), out T _, header);
	
	/// <param name="container">Receives the content control's variable. The function creates new control of the type.</param>
	/// <inheritdoc cref="StartStack{T}(object, bool)"/>
	public wpfBuilder StartStack<T>(out T container, object header, bool vertical = false) where T : HeaderedContentControl, new()
		=> _Start(new _StackPanel(this, vertical), out container, header);
	
	
	/// <summary>
	/// Adds panel of any type. It will contain elements added with <see cref="Add"/> etc. Finally call <see cref="End"/> to return to current panel.
	/// </summary>
	/// <param name="panel">New panel of any type (<see cref="Grid"/>, <see cref="WrapPanel"/>, etc). For <see cref="Grid"/> and <see cref="Canvas"/> this function sets some panel properties to make everything work like with other <c>StartX</c> functions.</param>
	/// <param name="childOfLast"><inheritdoc cref="StartGrid(bool)" path="/param[@name='childOfLast']/node()"/></param>
	public wpfBuilder StartPanel(Panel panel, bool childOfLast = false)
		=> _Start(_StartPanel(panel), childOfLast);
	
	/// <summary>
	/// Adds a headered content control (<see cref="GroupBox"/>, <see cref="Expander"/>, etc) with child panel of any type. The panel will contain elements added with <see cref="Add"/> etc. Finally call <see cref="End"/> to return to current panel.
	/// </summary>
	/// <param name="panel">New panel of any type (<see cref="Grid"/>, <see cref="WrapPanel"/>, etc). For <see cref="Grid"/> and <see cref="Canvas"/> this function sets some panel properties to make everything work like with other <c>StartX</c> functions.</param>
	/// <typeparam name="TContainer">Any <see cref="HeaderedContentControl"/>-based type.</typeparam>
	/// <param name="header">Header text/content.</param>
	public wpfBuilder StartPanel<TContainer>(Panel panel, object header)
		where TContainer : HeaderedContentControl, new()
		=> _Start(_StartPanel(panel), out TContainer _, header);
	
	_PanelBase _StartPanel(Panel panel) {
		return panel switch {
			null => throw new ArgumentNullException(),
			Grid g => new _Grid(this, g),
			Canvas c => new _Canvas(this, c),
			_ => new _PanelBase(this, panel)
		};
	}
	
	
	/// <summary>
	/// Adds right-bottom-aligned horizontal stack panel (<see cref="StartStack"/>) for adding <b>OK</b>, <b>Cancel</b> and more buttons.
	/// When don't need more buttons, use just <see cref="AddOkCancel"/>.
	/// </summary>
	/// <example>
	/// <code><![CDATA[
	/// b.StartOkCancel().AddOkCancel().AddButton("Help", _ => {  }).Width(70).End();
	/// ]]></code>
	/// </example>
	public wpfBuilder StartOkCancel() {
		var pa = _p;
		StartStack();
		if (pa is not _Canvas) {
			_p.panel.HorizontalAlignment = HorizontalAlignment.Right;
			_p.panel.VerticalAlignment = VerticalAlignment.Bottom;
			_p.panel.Margin = new(0, 2, 0, 0);
		}
		return this;
	}
	
	#endregion
	
	#region util
	
	bool _IsNested => _p.parent != null;
	
	bool _IsWindowEnded => _p.ended && _p.parent == null;
	
	Window _FindWindow(DependencyObject c) => _window ?? Window.GetWindow(c); //CONSIDER: support top-level HwndSource window
	
	Window _GetOrFindWindow() => _window ?? Window.GetWindow(_p.panel);
	
	void _ThrowIfNotWindow([CallerMemberName] string m_ = null) {
		if (_window == null) throw new InvalidOperationException(m_ + "(): Container is not Window");
	}
	
	Control _LastAsControlOrThrow([CallerMemberName] string m_ = null) => (Last as Control) ?? throw new InvalidOperationException(m_ + "(): Last added element is not Control");
	
	_PanelBase _ParentOfLast => ReferenceEquals(Last, _p.panel) ? _p.parent : _p;
	
	T _ParentOfLastAsOrThrow<T>([CallerMemberName] string m_ = null) where T : _PanelBase {
		return _ParentOfLast is T t ? t : throw new InvalidOperationException($"{m_}() not in {typeof(T).Name[1..]} panel.");
	}
	
	//	void _ThrowIfParentOfLastIs<TControl>([CallerMemberName] string caller = null) where TControl : Panel {
	//		if(Last.Parent is TControl) throw new InvalidOperationException($"{caller}() in {typeof(TControl).Name} panel.");
	//	}
	
	static string _UriNormalize(string source) => pathname.normalize(source, flags: PNFlags.CanBeUrlOrShell);
	
	//static Uri _Uri(string source) => new Uri(_UriNormalize(source));
	
	/// <summary>
	/// Detects whether the application or window is using a theme.
	/// </summary>
	static _Themed _GetThemed(wpfBuilder b = null) {
		var a = Application.Current;
#if NET9_0_OR_GREATER
		if (a != null && a.ThemeMode != ThemeMode.None) return _Themed.Wpf;
		if (b?._GetOrFindWindow() is { } w && w.ThemeMode != ThemeMode.None) return _Themed.Wpf;
#endif
		if (a != null && a.Resources.MergedDictionaries.Count > 0) return _Themed.Other;
		return 0;
	}
	enum _Themed : byte { None, Wpf, Other }
	
	_Themed _IsThemed => _isThemed ??= _GetThemed(this);
	_Themed? _isThemed;
	
	/// <summary>
	/// Gets or sets a property of an element of any type that has the property.
	/// </summary>
	struct _PropGetSet<T> {
		FrameworkElement _e;
		PropertyInfo _p;
		
		public _PropGetSet(FrameworkElement e, string prop, [CallerMemberName] string m_ = null) {
			_e = e;
			_p = e.GetType().GetProperty(prop, typeof(T)) ?? throw new InvalidOperationException(m_ + $"(): Last added element does not have {prop} property");
		}
		
		/// <summary>
		/// Like ctor but does not throw.
		/// </summary>
		/// <returns><c>false</c> if failed.</returns>
		public static bool TryCreate(FrameworkElement e, string prop, out _PropGetSet<T> r) {
			var p = e.GetType().GetProperty(prop, typeof(T));
			if (p == null) { r = default; return false; }
			r = new() { _e = e, _p = p };
			return true;
		}
		
		public T Get => (T)_p.GetValue(_e);
		
		public void Set(T value) { _p.SetValue(_e, value); }
	}
	
	#endregion
}


================================================
FILE: Au/Input/RegisteredHotkey.cs
================================================
namespace Au.More;

/// <summary>
/// Registers a hotkey using API <ms>RegisterHotKey</ms>. Unregisters when disposing.
/// </summary>
/// <remarks>
/// Can be used as a lightweight alternative to hotkey triggers.
/// 
/// The variable must be disposed, either explicitly (call <see cref="Dispose"/> or <see cref="Unregister"/>) or with <c>using</c>.
/// </remarks>
/// <example>
/// <code><![CDATA[
/// using System.Windows;
/// using System.Windows.Interop;
/// 
/// new DialogClass().ShowDialog();
/// 
/// class DialogClass : Window {
/// 	RegisteredHotkey _hk1, _hk2;
/// 	
/// 	public DialogClass() {
/// 		Title = "Hotkeys";
/// 		var b = new wpfBuilder(this).WinSize(250);
/// 		b.R.AddOkCancel();
/// 		b.End();
/// 	}
/// 
/// 	protected override void OnSourceInitialized(EventArgs e) {
/// 		base.OnSourceInitialized(e);
/// 		var hs = PresentationSource.FromVisual(this) as HwndSource;
/// 		hs.AddHook(_WndProc);
/// 		bool r1 = _hk1.Register(1, "Ctrl+Alt+F10", this);
/// 		bool r2 = _hk2.Register(2, (KMod.Ctrl | KMod.Shift, KKey.D), this); //Ctrl+Shift+D
/// 		print.it(r1, r2);
/// 	}
/// 
/// 	protected override void OnClosed(EventArgs e) {
/// 		base.OnClosed(e);
/// 		_hk1.Unregister();
/// 		_hk2.Unregister();
/// 	}
/// 
/// 	IntPtr _WndProc(IntPtr hwnd, int msg, IntPtr wParam, IntPtr lParam, ref bool handled) {
/// 		if (msg == RegisteredHotkey.WM_HOTKEY) print.it(wParam);
/// 
/// 		return default;
/// 	}
/// }
/// ]]></code>
/// </example>
/// <seealso cref="keys.waitForHotkey(Seconds, KHotkey, bool)"/>
public struct RegisteredHotkey : IDisposable {
	wnd _w;
	int? _id;
	
	///// <summary>The hotkey.</summary>
	//public KHotkey Hotkey { get; private set; }
	
	/// <summary>
	/// Registers a hotkey using API <ms>RegisterHotKey</ms>.
	/// </summary>
	/// <returns><c>false</c> if failed. Supports <see cref="lastError"/>.</returns>
	/// <param name="id">Hotkey id. Must be 0 to 0xBFFF or value returned by API <ms>GlobalAddAtom</ms>. It will be <i>wParam</i> of the <ms>WM_HOTKEY</ms> message.</param>
	/// <param name="hotkey">Hotkey. Can be: string like <c>"Ctrl+Shift+Alt+Win+K"</c>, tuple <c>(KMod, KKey)</c>, enum <see cref="KKey"/>, enum <c>Keys</c>, struct <see cref="KHotkey"/>.</param>
	/// <param name="window">Window/form that will receive the <ms>WM_HOTKEY</ms> message. Must be of this thread. If default, the message must be retrieved in the message loop of this thread.</param>
	///	<param name="noRepeat">Add flag <ms>MOD_NOREPEAT</ms>.</param>
	/// <exception cref="ArgumentException">Error in hotkey string.</exception>
	/// <exception cref="InvalidOperationException">This variable already registered a hotkey.</exception>
	/// <remarks>
	/// Fails if the hotkey is currently registered by this or another application or used by Windows. Also if <c>F12</c>.
	/// <note>Most single-key and <c>Shift+key</c> hotkeys don't work when the active window has higher UAC integrity level (eg admin) than this process. Media keys may work.</note>
	/// A single variable cannot register multiple hotkeys simultaneously. Use multiple variables, for example array.
	/// </remarks>
	/// <seealso cref="keys.waitForHotkey"/>
	public bool Register(int id, [ParamString(PSFormat.Hotkey)] KHotkey hotkey, AnyWnd window = default, bool noRepeat = false) {
		if (_id != null) throw new InvalidOperationException("This variable already registered a hotkey. Use multiple variables or call Unregister.");
		var w = window.Hwnd;
		var (mod, key) = Normalize_(hotkey);
		if (noRepeat) mod |= Api.MOD_NOREPEAT;
		if (!Api.RegisterHotKey(w, id, mod, key)) return false;
		_w = w; _id = id;
		//Hotkey = hotkey;
		return true;
	}
	
	internal static (uint mod, KKey key) Normalize_(KHotkey hotkey) {
		var (mod, key) = hotkey;
		if (key == KKey.Pause && mod.Has(KMod.Ctrl)) key = KKey.Break;
		//if(key == KKey.NumPad5 && mod.Has(KMod.Shift)) key = KKey.Clear; //Shift+numpad don't work
		return (Math2.SwapBits((uint)mod, 0, 2, 1), key);
	}
	
	/// <summary>
	/// Unregisters the hotkey.
	/// </summary>
	/// <remarks>
	/// Called implicitly when disposing this variable.
	/// Must be called from the same thread as when registering, and the window must be still alive.
	/// If fails, calls <see cref="print.warning"/>.
	/// </remarks>
	public void Unregister() {
		if (_id != null) {
			if (!Api.UnregisterHotKey(_w, _id.Value)) {
				var es = lastError.message;
				print.warning($"Failed to unregister hotkey, id={_id.Value}. {es}");
				return;
			}
			_id = null;
			_w = default;
			//Hotkey = default;
		}
	}
	
	/// <summary>
	/// Calls <see cref="Unregister"/>.
	/// </summary>
	public void Dispose() => Unregister();
	
	//~RegisteredHotkey() => Unregister(); //makes no sense. Called from wrong thread and when the window is already destroyed.
	
	/// <summary>
	/// This message is posted to the window or to the thread's message loop.
	/// More info: <ms>WM_HOTKEY</ms>.
	/// </summary>
	public const int WM_HOTKEY = Api.WM_HOTKEY;
}


================================================
FILE: Au/Input/clipboard.cs
================================================
namespace Au;

/// <summary>
/// Clipboard functions. Copy, paste, get and set clipboard text and other data.
/// </summary>
/// <remarks>
/// This class is similar to the .NET <see cref="System.Windows.Forms.Clipboard"/> class, which uses OLE API, works only in STA threads and does not work well in automation scripts. This class uses non-OLE API and works well in automation scripts and any threads.
/// 
/// To set/get clipboard data of non-text formats, use class <see cref="clipboardData"/>; to paste, use it with <see cref="pasteData"/>; to copy (get from the active app), use it with <see cref="copyData{T}(Func{T}, bool, OKey, KHotkey, int)"/>.
/// 
/// Don't copy/paste in windows of own thread. Call it from another thread. Example in <see cref="keys.send"/>.
/// </remarks>
public static class clipboard {
	/// <summary>
	/// Clears the clipboard.
	/// </summary>
	/// <exception cref="AuException">Failed to open clipboard (after 10 s of wait/retry).</exception>
	public static void clear() {
		using (new OpenClipboard_(false)) EmptyClipboard_();
	}
	
	internal static void EmptyClipboard_() {
		if (!Api.EmptyClipboard()) Debug.Assert(false);
	}
	
	/// <summary>
	/// Gets or sets clipboard text.
	/// </summary>
	/// <value><c>null</c> if there is no text.</value>
	/// <exception cref="AuException">Failed to open clipboard (after 10 s of wait/retry) or set clipboard data.</exception>
	/// <exception cref="OutOfMemoryException">The <c>set</c> function failed to allocate memory.</exception>
	/// <remarks>
	/// The <c>get</c> function calls <see cref="clipboardData.getText"/>.
	/// 
	/// Gets/sets only data of text format. For other formats (files, HTML, image, etc) use <see cref="clipboardData"/> class.
	/// </remarks>
	public static string text {
		get => clipboardData.getText();
		set {
			using (new OpenClipboard_(true)) {
				EmptyClipboard_();
				if (value != null) clipboardData.SetText_(value);
			}
		}
	}
	
	//Sets text (string) or multi-format data (Data). Clipboard must be open.
	static void _SetClipboard(object data, bool renderLater) {
		switch (data) {
		case clipboardData d:
			d.SetOpenClipboard(renderLater);
			break;
		case string s:
			if (renderLater) Api.SetClipboardData(Api.CF_UNICODETEXT, default);
			else clipboardData.SetText_(s);
			break;
		}
	}
	
	/// <summary>
	/// Calls API <c>SetClipboardData("Clipboard Viewer Ignore")</c>. Clipboard must be open.
	/// Then clipboard manager/viewer/etc programs that are aware of this convention don't try to get our clipboard data while we are pasting.
	/// Tested apps that support it: Ditto, Clipdiary. Other 5 tested apps don't. Windows 10 Clipboard History doesn't.
	/// </summary>
	static void _SetClipboardData_ClipboardViewerIgnore() {
		Api.SetClipboardData(ClipFormats.ClipboardViewerIgnore, Api.GlobalAlloc(Api.GMEM_MOVEABLE | Api.GMEM_ZEROINIT, 1));
		//tested: hMem cannot be default(IntPtr) or 0 bytes.
	}
	
	/// <summary>
	/// Gets the selected text from the focused app using the clipboard.
	/// </summary>
	/// <param name="cut">Use <c>Ctrl+X</c>.</param>
	/// <param name="options">
	/// Options. If <c>null</c> (default), uses <see cref="opt.key"/>.
	/// Uses <see cref="OKey.RestoreClipboard"/>, <see cref="OKey.KeySpeedClipboard"/>, <see cref="OKey.NoBlockInput"/>. Does not use <see cref="OKey.Hook"/>.
	/// </param>
	/// <param name="hotkey">Keys to use instead of <c>Ctrl+C</c> or <c>Ctrl+X</c>. Example: <c>hotkey: "Ctrl+Shift+C"</c>. Overrides <i>cut</i>.</param>
	/// <param name="timeoutMS">Max time to wait until the focused app sets clipboard data, in milliseconds. If 0 (default), the timeout is 3000 ms. The function waits up to 10 times longer if the window is hung.</param>
	/// <exception cref="AuException">Failed. Fails if there is no focused window or if it does not set clipboard data.</exception>
	/// <exception cref="InputDesktopException"></exception>
	/// <remarks>
	/// Also can get file paths, as multiline text.
	/// 
	/// Sends keys <c>Ctrl+C</c>, waits until the focused app sets clipboard data, gets it, finally restores clipboard data.
	/// Fails if the focused app does not set clipboard text or file paths, for example if there is no selected text/files.
	/// Works with console windows too, even if they don't support <c>Ctrl+C</c>.
	/// </remarks>
	public static string copy(bool cut = false, OKey options = null, [ParamString(PSFormat.Hotkey)] KHotkey hotkey = default, int timeoutMS = 0) {
		return _Copy(cut, hotkey, options, timeoutMS);
		//rejected: 'format' parameter. Not useful.
	}
	
	/// <summary>
	/// Calls <see cref="copy"/> and handles exceptions.
	/// </summary>
	/// <returns>Returns <c>false</c> if failed.</returns>
	/// <param name="text">Receives the copied text.</param>
	/// <param name="timeout">Max time to wait until the focused app sets clipboard data, in milliseconds. The function waits up to 10 times longer if the window is hung.</param>
	/// <param name="warning">Call <see cref="print.warning"/>.</param>
	/// <param name="osd">Call <see cref="osdText.showTransparentText"/> with text <c>"Failed to copy text"</c>.</param>
	/// <inheritdoc cref="copy" path="//param|//remarks"/>
	public static bool tryCopy(out string text, int timeout, bool warning = false, bool osd = false, OKey options = null, [ParamString(PSFormat.Hotkey)] KHotkey hotkey = default) {
		try {
			text = _Copy(false, hotkey, options, Math.Max(timeout, 25));
			return true;
		}
		catch (Exception e1) {
			if (warning) print.warning(e1);
			if (osd) osdText.showTransparentText("Failed to copy text");
			text = null;
			return false;
		}
	}
	
	/// <summary>
	/// Calls <see cref="copy"/> and handles exceptions.
	/// </summary>
	/// <returns>Returns <c>false</c> if failed.</returns>
	/// <param name="text">Receives the copied text.</param>
	/// <param name="warning">Call <see cref="print.warning"/>. Default <c>true</c>.</param>
	/// <param name="osd">Call <see cref="osdText.showTransparentText"/> with text <c>"Failed to copy text"</c>. Default <c>true</c>.</param>
	/// <inheritdoc cref="copy" path="//param|//remarks"/>
	[EditorBrowsable(EditorBrowsableState.Never)] //obsolete. Not optimal parameters.
	public static bool tryCopy(out string text, bool cut = false, OKey options = null, bool warning = true, bool osd = true, [ParamString(PSFormat.Hotkey)] KHotkey hotkey = default, int timeoutMS = 0) {
		try {
			text = _Copy(cut, hotkey, options, timeoutMS);
			return true;
		}
		catch (Exception e1) {
			if (warning) print.warning(e1);
			if (osd) osdText.showTransparentText("Failed to copy text");
			text = null;
			return false;
		}
	}
	
	/// <summary>
	/// Gets data of any formats from the focused app using the clipboard and a callback function.
	/// </summary>
	/// <returns>The return value of <i>callback</i>.</returns>
	/// <param name="callback">Callback function. It can get clipboard data of any formats. It can use any clipboard functions, for example <see cref="clipboardData"/> or <see cref="System.Windows.Forms.Clipboard"/>. Don't call copy/paste functions.</param>
	/// <remarks>
	/// Sends keys <c>Ctrl+C</c>, waits until the focused app sets clipboard data, calls the callback function that gets it, finally restores clipboard data.
	/// Fails if the focused app does not set clipboard data.
	/// Works with console windows too, even if they don't support <c>Ctrl+C</c>.
	/// </remarks>
	/// <example>
	/// <code><![CDATA[
	/// var image = clipboard.copyData(() => clipboardData.getImage());
	/// 
	/// var (text, files) = clipboard.copyData(() => (clipboardData.getText(), clipboardData.getFiles()));
	/// ]]></code>
	/// </example>
	/// <inheritdoc cref="copy"/>
	public static T copyData<T>(Func<T> callback, bool cut = false, OKey options = null, [ParamString(PSFormat.Hotkey)] KHotkey hotkey = default, int timeoutMS = 0) {
		Not_.Null(callback);
		T r = default;
		_Copy(cut, hotkey, options, timeoutMS, () => { r = callback(); });
		return r;
	}
	
	///
	[EditorBrowsable(EditorBrowsableState.Never)] //obsolete
	public static void copyData(Action callback, bool cut = false, OKey options = null, KHotkey hotkey = default) {
		Not_.Null(callback);
		_Copy(cut, hotkey, options, 0, callback);
	}
	
	static string _Copy(bool cut, KHotkey hotkey, OKey options, int timeoutMS, Action callback = null) {
		string R = null;
		var optk = options ?? opt.key;
		bool restore = optk.RestoreClipboard;
		_ClipboardListener listener = null;
		_DisableClipboardHistory disableCH = default;
		var bi = new inputBlocker() { ResendBlockedKeys = true };
		var oc = new OpenClipboard_(createOwner: true, noOpenNow: !restore);
		try {
			if (!optk.NoBlockInput) bi.Start(BIEvents.Keys);
			keys.Internal_.ReleaseModAndDisableModMenu();
			
			disableCH.Disable(); //fast
			
			var save = new _SaveRestore();
			if (restore) {
				save.Save();
				oc.Close(false); //close clipboard; don't destroy our clipboard owner window
			}
			
			wnd wFocus = keys.Internal_.GetWndFocusedOrActive(requireFocus: true);
			listener = new _ClipboardListener(false, null, oc.WndClipOwner, wFocus);
			
			if (!Api.AddClipboardFormatListener(oc.WndClipOwner)) throw new AuException();
			var ctrlC = new keys.Internal_.SendCopyPaste();
			try {
				if (wFocus.IsConsole) {
					wFocus.Post(Api.WM_SYSCOMMAND, 65520);
					//system menu &Edit > &Copy; tested on all OS; Windows 10 supports Ctrl+C, but it may be disabled.
				} else {
					if (hotkey.Key == 0) hotkey = new(KMod.Ctrl, cut ? KKey.X : KKey.C);
					ctrlC.Press(hotkey, optk, wFocus);
				}
				
				//wait until the app sets clipboard text
				listener.Wait(ref ctrlC, timeoutMS);
			}
			finally {
				ctrlC.Release();
				Api.RemoveClipboardFormatListener(oc.WndClipOwner);
			}
			
			wFocus.SendTimeout(500, out _, 0); //workaround: in SharpDevelop and ILSpy (both WPF), API GetClipboardData takes ~1 s. Need to sleep min 10 ms or send message.
			
			if (callback != null) {
				callback();
				if (restore) oc.Reopen();
			} else {
				oc.Reopen();
				R = clipboardData.GetText_(0);
			}
			
			if (restore) save.Restore();
		}
		finally {
			oc.Dispose();
			bi.Dispose();
			disableCH.Restore();
		}
		GC.KeepAlive(listener);
		if (R == null && callback == null) throw new AuException("*copy text"); //no text in the clipboard. Probably not a text control; if text control but empty selection, usually throws in Wait, not here, because the target app then does not use the clipboard.
		return R;
	}
	
	/// <summary>
	/// Pastes text or HTML into the focused app using the clipboard.
	/// </summary>
	/// <param name="text">Text. Can be <c>null</c> if <i>html</i> used.</param>
	/// <param name="html">
	/// HTML. Can be full HTML or fragment. See <see cref="clipboardData.AddHtml"/>. Can be <c>null</c>.
	/// Can be specified only <i>text</i> or only <i>html</i> or both. If both, will paste <i>html</i> in apps that support it, elsewhere <i>text</i>. If only <i>html</i>, in apps that don't support HTML will paste <i>html</i> as text.
	/// </param>
	/// <param name="options">
	/// Options. If <c>null</c> (default), uses <see cref="opt.key"/>.
	/// Uses <see cref="OKey.PasteSleep"/>, <see cref="OKey.RestoreClipboard"/>, <see cref="OKey.PasteWorkaround"/>, <see cref="OKey.KeySpeedClipboard"/>, <see cref="OKey.NoBlockInput"/>, <see cref="OKey.Hook"/>.
	/// </param>
	/// <param name="hotkey">Keys to use instead of <c>Ctrl+V</c>. Example: <c>hotkey: "Ctrl+Shift+V"</c>.</param>
	/// <param name="timeoutMS">Max time to wait until the focused app gets clipboard data, in milliseconds. If 0 (default), the timeout is 3000 ms. The function waits up to 10 times longer if the window is hung.</param>
	/// <exception cref="AuException">Failed. Fails if there is no focused window or if it does not get clipboard data.</exception>
	/// <exception cref="InputDesktopException"></exception>
	/// <remarks>
	/// Sets clipboard data, sends keys <c>Ctrl+V</c>, waits until the focused app gets clipboard data, finally restores clipboard data.
	/// Fails if nothing gets clipboard data in several seconds.
	/// Works with console windows too, even if they don't support <c>Ctrl+V</c>.
	/// 
	/// A clipboard viewer/manager program can make this function slower and less reliable, unless it supports <see cref="ClipFormats.ClipboardViewerIgnore"/> or gets clipboard data with a delay.
	/// Possible problems with some virtual PC programs. Either pasting does not work in their windows, or they use a hidden clipboard viewer that makes this function slower and less reliable.
	/// </remarks>
	/// <seealso cref="keys.sendt"/>
	/// <example>
	/// <code><![CDATA[
	/// clipboard.paste("Example\r\n");
	/// ]]></code>
	/// </example>
	public static void paste(string text, string html = null, OKey options = null, [ParamString(PSFormat.Hotkey)] KHotkey hotkey = default, int timeoutMS = 0) {
		if (text.NE() && html.NE()) return;
		object data = text;
		if (html != null) data = new clipboardData().AddHtml(html).AddText(text ?? html);
		_Paste(data, options, hotkey, timeoutMS);
	}
	//problem: fails to paste in VMware player. Could add an option to not sync, but fails anyway because VMware gets clipboard with a big delay.
	//TODO2: add a tip here in doc or in cookbook: To create HTML you can use an online HTML editor, for example https://html-online.com/.
	
	/// <summary>
	/// Calls <see cref="paste"/> and handles exceptions.
	/// </summary>
	/// <returns>Returns <c>false</c> if failed.</returns>
	/// <param name="timeout">Max time to wait until the focused app gets clipboard data, in milliseconds. The function waits up to 10 times longer if the window is hung.</param>
	/// <param name="warning">Call <see cref="print.warning"/>.</param>
	/// <param name="osd">Call <see cref="osdText.showTransparentText"/> with text <c>"Failed to paste text"</c>.</param>
	/// <inheritdoc cref="paste" path="//param|//remarks"/>
	public static bool tryPaste(string text, int timeout, bool warning = false, bool osd = false, string html = null, OKey options = null, [ParamString(PSFormat.Hotkey)] KHotkey hotkey = default) {
		try {
			paste(text, html, options, hotkey, Math.Max(timeout, 25));
			return true;
		}
		catch (Exception e1) {
			if (warning) print.warning(e1);
			if (osd) osdText.showTransparentText("Failed to paste text");
			return false;
		}
	}
	
	/// <summary>
	/// Calls <see cref="paste"/> and handles exceptions.
	/// </summary>
	/// <returns>Returns <c>false</c> if failed.</returns>
	/// <param name="warning">Call <see cref="print.warning"/>. Default <c>true</c>.</param>
	/// <param name="osd">Call <see cref="osdText.showTransparentText"/> with text <c>"Failed to paste text"</c>. Default <c>true</c>.</param>
	/// <inheritdoc cref="paste" path="//param|//remarks"/>
	[EditorBrowsable(EditorBrowsableState.Never)] //obsolete. Not optimal parameters.
	public static bool tryPaste(string text, string html = null, OKey options = null, bool warning = true, bool osd = true, [ParamString(PSFormat.Hotkey)] KHotkey hotkey = default, int timeoutMS = 0) {
		try {
			paste(text, html, options, hotkey, timeoutMS);
			return true;
		}
		catch (Exception e1) {
			if (warning) print.warning(e1);
			if (osd) osdText.showTransparentText("Failed to paste text");
			return false;
		}
	}
	
	/// <summary>
	/// Pastes data added to a <see cref="clipboardData"/> variable into the focused app using the clipboard.
	/// </summary>
	/// <example>
	/// Paste data of two formats: HTML and text.
	/// <code><![CDATA[
	/// clipboard.pasteData(new clipboardData().AddHtml("<b>text</b>").AddText("text"));
	/// ]]></code>
	/// </example>
	/// <inheritdoc cref="paste"/>
	public static void pasteData(clipboardData data, OKey options = null, [ParamString(PSFormat.Hotkey)] KHotkey hotkey = default, int timeoutMS = 0) {
		Not_.Null(data);
		_Paste(data, options, hotkey, timeoutMS);
	}
	
	//rejected. Should use some UI-created/saved data containing all three formats.
	//public static void pasteRichText(string text, string rtf, string html = null, OKey options = null)
	//{
	//	var a = new List<(int, object)>();
	//	if(!text.NE()) a.Add((0, text));
	//	if(!rtf.NE()) a.Add((Lib.RtfFormat, rtf));
	//	if(!html.NE()) a.Add((Lib.HtmlFormat, html));
	//	if(a.Count == 0) return;
	//	_Paste(a, options);
	//}
	
	static void _Paste(object data, OKey options, KHotkey hotkey, int timeoutMS) {
		var wFocus = keys.Internal_.GetWndFocusedOrActive(requireFocus: true);
		var optk = options ?? opt.key;
		using (var bi = new inputBlocker { ResendBlockedKeys = true }) {
			if (!optk.NoBlockInput) bi.Start(BIEvents.Keys);
			keys.Internal_.ReleaseModAndDisableModMenu();
			optk = optk.GetHookOptionsOrThis_(wFocus);
			Paste_(data, optk, wFocus, hotkey, timeoutMS);
		}
	}
	
	/// <summary>
	/// Used by <see cref="clipboard"/> and <see cref="keys"/>.
	/// The caller should block user input (if need), release modifier keys, get <i>optk</i>/<i>wFocus</i>, sleep finally (if need).
	/// </summary>
	/// <param name="data">string or <see cref="clipboardData"/>.</param>
	internal static void Paste_(object data, OKey optk, wnd wFocus, KHotkey hotkey = default, int timeoutMS = 0) {
		bool isConsole = wFocus.IsConsole;
		List<KKey> andKeys = null;
		
		if (optk.PasteWorkaround && data is string s && !isConsole) {
			var s2 = s.TrimEnd("\r\n\t ");
			if (s2 != s) {
				andKeys = new List<KKey>();
				for (int i = s2.Length; i < s.Length; i++) {
					char ch = s[i];
					if (ch == '\n') { if (i > 0 && s[i - 1] == '\r') continue; ch = '\r'; }
					andKeys.Add((KKey)ch);
				}
				if (s2.Length == 0) {
					keys.Internal_.SendCopyPaste.AndSendKeys(andKeys, optk);
					return;
				}
				data = s2;
			}
		}
		
		bool sync = true; //CONSIDER: option to turn off, depending on window.
		_ClipboardListener listener = null;
		_DisableClipboardHistory disableCH = default;
		var oc = new OpenClipboard_(true);
		bool restore = optk.RestoreClipboard;
		_SaveRestore save = default;
		try {
			disableCH.Disable(); //fast
			
			if (restore) save.Save();
			
			EmptyClipboard_();
			_SetClipboardData_ClipboardViewerIgnore();
			_SetClipboard(data, renderLater: sync);
			oc.Close(false); //close clipboard; don't destroy our clipboard owner window
			if (sync) listener = new _ClipboardListener(true, data, oc.WndClipOwner, wFocus);
			//info:
			//	oc ctor creates a temporary message-only clipboard owner window. Its wndproc initially is DefWindowProc.
			//	listener ctor subclasses it. Its wndproc receives WM_RENDERFORMAT which sets clipboard data etc.
			
			//PasteSync_?.Start(new(wFocus, optk, data));
			
			var ctrlV = new keys.Internal_.SendCopyPaste();
			try {
				if (isConsole) {
					wFocus.Post(Api.WM_SYSCOMMAND, 65521);
					//system menu &Edit > &Paste; tested on all OS; Windows 10 supports Ctrl+V, but it can be disabled.
				} else {
					if (hotkey.Key == 0) hotkey = new(KMod.Ctrl, KKey.V);
					ctrlV.Press(hotkey, optk, wFocus, andKeys: andKeys);
				}
				
				//wait until the app gets clipboard data
				if (sync) {
					listener.Wait(ref ctrlV, timeoutMS);
					if (listener.FailedToSetData != null) throw new AuException(listener.FailedToSetData.Message);
					if (listener.IsBadWindow) sync = false;
				}
				
				keys.Internal_.Sleep(optk.KeySpeedClipboard);
				//rejected: subtract the time already waited in listener.Wait.
				//never mind: if too long, in some apps may autorepeat, eg BlueStacks after 500 ms. Rare.
			}
			finally {
				ctrlV.Release();
			}
			
			wFocus.SendTimeout(1000, out _, 0, flags: 0); //can help with some apps, but many apps eg browsers are async
			
			int sleep = optk.PasteSleep; if (!sync && sleep < 500) sleep = (sleep + 500) / 2;
			keys.Internal_.Sleep(sleep);
			
			//PasteSync_?.End();
		}
		finally {
			if (restore && save.IsSaved) {
				if (oc.Reopen(true)) save.Restore();
			}
			oc.Dispose();
			disableCH.Restore();
		}
		GC.KeepAlive(listener);
	}
	
	//internal static IPasteSync_ PasteSync_ { get; set; }
	//internal interface IPasteSync_ {
	//	void Start(PasteSyncArgs_ p);
	//	void End();
	//}
	//internal record class PasteSyncArgs_(wnd wFocus, OKey optk, object data);
	
	/// <summary>
	/// Waits until the target app gets (when pasting) or sets (when copying) clipboard text.
	/// For it subclasses our clipboard owner window and uses clipboard messages. Does not unsubclass.
	/// </summary>
	class _ClipboardListener : WaitVariable_ {
		bool _paste; //true if used for paste, false if for copy
		object _data; //string or Data. null if !_paste.
		WNDPROC _wndProc;
		//wnd _wPrevClipViewer;
		wnd _wFocus;
		
		/// <summary>
		/// The clipboard message has been received. Probably the target window responded to the <c>Ctrl+C</c> or <c>Ctrl+V</c>.
		/// When pasting, it is unreliable because of clipboard viewers/managers/etc. The caller also must check <c>IsBadWindow</c>.
		/// </summary>
		public bool Success => waitVar;
		
		/// <summary>
		/// When pasting, <c>true</c> if probably not the target process retrieved clipboard data. Probably a clipboard viewer/manager/etc.
		/// Not used when copying.
		/// </summary>
		public bool IsBadWindow;
		
		/// <summary>
		/// Exception thrown/caught when failed to set clipboard data.
		/// </summary>
		public Exception FailedToSetData;
		
		/// <summary>
		/// Subclasses <i>clipOwner</i>.
		/// </summary>
		/// <param name="paste"><c>true</c> if used for paste, <c>false</c> if for copy.</param>
		/// <param name="data">If used for paste, can be string containing Unicode text or <c>int</c>/<c>string</c> dictionary containing clipboard format/data.</param>
		/// <param name="clipOwner">Our clipboard owner window.</param>
		/// <param name="wFocus">The target control or window.</param>
		public _ClipboardListener(bool paste, object data, wnd clipOwner, wnd wFocus) {
			_paste = paste;
			_data = data;
			_wndProc = _WndProc;
			_wFocus = wFocus;
			WndUtil.SubclassUnsafe_(clipOwner, _wndProc);
			
			//rejected: use SetClipboardViewer to block clipboard managers/viewers/etc. This was used in QM2.
			//	Nowadays most such programs don't use SetClipboardViewer. They use AddClipboardFormatListener+WM_CLIPBOARDUPDATE.
			//	known apps that have clipboard viewer installed with SetClipboardViewer:
			//		OpenOffice, LibreOffice: tested Writer, Calc.
			//		VLC: after first Paste.
			//_wPrevClipViewer = Api.SetClipboardViewer(clipOwner);
			//print.it(_wPrevClipViewer);
		}
		
		/// <summary>
		/// Waits until the target app gets (when pasting) or sets (when copying) clipboard text.
		/// Throws <see cref="AuException"/> on timeout (default 3 s normally, 28 s if the target window is hung).
		/// </summary>
		/// <param name="ctrlKey">The variable that was used to send <c>Ctrl+V</c> or <c>Ctrl+C</c>. This function may call <c>Release</c> to avoid too long <c>Ctrl</c> down.</param>
		public void Wait(ref keys.Internal_.SendCopyPaste ctrlKey, int timeoutMS = 0) {
			//print.it(Success); //on Paste often already true, because SendInput dispatches sent messages
			int n = 6, t = 500; //max 3 s (6*500 ms). If hung, max 28 s.
			if (timeoutMS > 0) { n = (timeoutMS + 500 - 1) / 500; t = timeoutMS / n; }
			while (!Success) {
				wait.Wait_(t, WHFlags.DoEvents, stopVar: this);
				if (Success) break;
				if (--n == 0) throw new AuException(_paste ? "*paste" : "*copy");
				ctrlKey.Release();
				//is hung?
				_wFocus.SendTimeout(t * 10, out _, 0, flags: 0);
			}
		}
		
		nint _WndProc(wnd w, int message, nint wParam, nint lParam) {
			//WndUtil.PrintMsg(w, message, wParam, lParam);
			
			switch (message) {
			//case Api.WM_DESTROY:
			//	Api.ChangeClipboardChain(w, _wPrevClipViewer);
			//	break;
			case Api.WM_RENDERFORMAT:
				if (_paste && !Success) {
					IsBadWindow = !_IsTargetWindow();
					
					//note: need to set clipboard data even if bad window.
					//	Else the clipboard program may retry in loop. Eg Ditto. Then often pasting fails.
					//	If IsBadWindow, we'll then sleep briefly.
					//	Good clipboard programs get clipboard data with a delay. Therefore usually they don't interfere, unless the target app is very slow.
					//		Eg Windows Clipboard History 200 ms. Eg Ditto default is 100 ms and can be changed.
					//	Also, after setting clipboard data we cannot wait for good window, because we'll not receive second WM_RENDERFORMAT.
					
					try { _SetClipboard(_data, false); }
					catch (Exception ex) { FailedToSetData = ex; } //cannot throw in wndproc, will throw later
					waitVar = true;
				}
				return 0;
			case Api.WM_CLIPBOARDUPDATE:
				//posted, not sent. Once, not for each format. Added in WinVista. QM2 used SetClipboardViewer/WM_DRAWCLIPBOARD.
				if (!_paste) waitVar = true;
				return 0;
			}
			
			return Api.DefWindowProc(w, message, wParam, lParam);
			
			//Returns false if probably not the target app reads from the clipboard. Probably a clipboard viewer/manager/etc.
			bool _IsTargetWindow() {
				wnd wOC = Api.GetOpenClipboardWindow();
				
				//int color = 0; if(wOC != _wFocus) color = wOC.ProcessId == _wFocus.ProcessId ? 0xFF0000 : 0xFF;
				//print.it($"<><c {color}>{wOC}</c>");
				
				if (wOC == _wFocus) return true;
				if (wOC.Is0) return true; //tested: none of tested apps calls OpenClipboard(0)
				if (wOC.ProcessId == _wFocus.ProcessId) return true; //often classnamed "CLIPBRDWNDCLASS". Some clipboard managers too, eg Ditto.
				if (osVersion.minWin10 && 0 != _wFocus.Window.IsUwpApp) {
					var prog = wOC.ProgramName;
					if (prog.Eqi("svchost.exe")) return true;
					//if (prog.Eqi("RuntimeBroker.exe")) return true; //used to be Store apps
					//tested: no problems on Win8.1
				}
				//tested: WinUI3 (cn "WinUIDesktopWin32WindowClass"): wOC != _wFocus, but same process.
				
				//CONSIDER: option to return true for user-known windows, eg using a callback. Print warning that includes wOC info.
				
				Debug_.Print(wOC.ToString());
				return false;
				
				//BlueStacks problems:
				//	Uses an aggressive viewer. Always debugprints while it is running, even when other apps are active.
				//	Sometimes pastes old text, usually after starting BlueStacks or after some time of not using it.
				//		With or without clipboard restoring.
				//		Then starts to work correctly always. Difficult to debug.
				//		KeySpeedClipboard=100 usually helps, but sometimes even 300 does not help.
			}
		}
	}
	
	/// <summary>
	/// Opens and closes clipboard using API <c>OpenClipboard</c> and <c>CloseClipboard</c>.
	/// Constructor tries to open for 10 s, then throws <see cref="AuException"/>.
	/// If the <i>createOwner</i> parameter is <c>true</c>, creates temporary message-only clipboard owner window.
	/// If the <i>noOpenNow</i> parameter is <c>true</c>, does not open, only creates owner if need.
	/// <c>Dispose</c> closes clipboard and destroys the owner window.
	/// </summary>
	internal struct OpenClipboard_ : IDisposable {
		bool _isOpen;
		wnd _w;
		
		public wnd WndClipOwner => _w;
		
		public OpenClipboard_(bool createOwner, bool noOpenNow = false) {
			_isOpen = false;
			_w = default;
			if (createOwner) {
				_w = WndUtil.CreateWindowDWP_(messageOnly: true);
				//MSDN says, SetClipboardData fails if OpenClipboard called with 0 hwnd. It doesn't, but better use hwnd.
			}
			if (!noOpenNow) Reopen();
		}
		
		/// <summary>
		/// Opens again.
		/// Must be closed.
		/// Owner window should be not destroyed; does not create again.
		/// </summary>
		/// <param name="noThrow">If fails, return <c>false</c>, no exception. Also then waits 1 s instead of 10 s.</param>
		/// <exception cref="AuException">Failed to open.</exception>
		public bool Reopen(bool noThrow = false) {
			Debug.Assert(!_isOpen);
			var loop = new WaitLoop(new(noThrow ? -1 : -10) { Period = 1 });
			while (!Api.OpenClipboard(_w)) {
				int ec = lastError.code;
				if (!loop.Sleep()) {
					Dispose();
					if (noThrow) return false;
					throw new AuException(ec, "*open clipboard");
				}
			}
			_isOpen = true;
			return true;
		}
		
		public void Close(bool destroyOwnerWindow) {
			if (_isOpen) {
				Api.CloseClipboard();
				_isOpen = false;
			}
			if (destroyOwnerWindow && !_w.Is0) {
				Api.DestroyWindow(_w);
				_w = default;
			}
		}
		
		public void Dispose() => Close(true);
	}
	
	/// <summary>
	/// Saves and restores clipboard data.
	/// Clipboard must be open. Don't need to call <c>EmptyClipboard</c> before <c>Restore</c>.
	/// </summary>
	struct _SaveRestore {
		Dictionary<int, byte[]> _data;
		
		public void Save(bool debug = false) {
			var p1 = new perf.Instance(); //will need if debug==true. Don't delete the perf statements, they are used by a public function.
			bool allFormats = OKey.RestoreClipboardAllFormats || debug;
			string[] exceptFormats = OKey.RestoreClipboardExceptFormats;
			
			for (int format = 0; 0 != (format = Api.EnumClipboardFormats(format));) {
				bool skip = false; string name = null;
				if (!allFormats) {
					skip = format != Api.CF_UNICODETEXT;
				} else {
					//standard, private
					if (format < Api.CF_MAX) { //standard
						switch (format) {
						case Api.CF_OEMTEXT: //synthesized from other text formats
						case Api.CF_BITMAP: //synthesized from DIB formats
						case Api.CF_PALETTE: //rare, never mind
							skip = true;
							break;
						case Api.CF_METAFILEPICT:
						case Api.CF_ENHMETAFILE:
							skip = true; //never mind, maybe in the future
							break;
						}
					} else if (format < 0xC000) { //CF_OWNERDISPLAY, DSP, GDI, private
						skip = true; //never mind. Not auto-freed, etc. Rare.
					} //else registered
					
					if (!skip && exceptFormats != null && exceptFormats.Length != 0) {
						name = ClipFormats.GetName(format);
						foreach (string s in exceptFormats) if (s.Eqi(name)) { skip = true; break; }
					}
				}
				
				if (debug) {
					name ??= ClipFormats.GetName(format);
					if (skip) print.it($"{name,-62}  restore=False");
					else p1.First();
					//note: we don't call GetClipboardData for formats in exceptFormats, because the conditions must be like when really saving. Time of GetClipboardData(format2) may depend on whether called GetClipboardData(format1).
				}
				if (skip) continue;
				
				var data = Api.GetClipboardData(format);
				
				int size = (data == default) ? 0 : (int)Api.GlobalSize(data);
				if (size == 0 || size > 10 * 1024 * 1024) skip = true;
				//If data == default, probably the target app did SetClipboardData(NULL) but did not render data on WM_RENDERFORMAT.
				//	If we try to save/restore, we'll receive WM_RENDERFORMAT too. It can be dangerous.
				
				if (debug) {
					p1.Next();
					print.it($"{name,-32}  time={p1.TimeTotal,-8}  size={size,-8}  restore={!skip}");
					continue;
				}
				if (skip) continue;
				
				var b = Api.GlobalLock(data);
				Debug.Assert(b != default); if (b == default) continue;
				try {
					_data ??= new Dictionary<int, byte[]>();
					var a = new byte[size];
					Marshal.Copy(b, a, 0, size);
					_data.Add(format, a);
				}
				finally { Api.GlobalUnlock(data); }
			}
		}
		
		public void Restore() {
			if (_data == null) return;
			EmptyClipboard_();
			foreach (var v in _data) {
				var a = v.Value;
				var h = Api.GlobalAlloc(Api.GMEM_MOVEABLE, a.Length);
				var b = Api.GlobalLock(h);
				if (b != default) {
					try { Marshal.Copy(a, 0, b, a.Length); } finally { Api.GlobalUnlock(h); }
					if (default == Api.SetClipboardData(v.Key, h)) b = default;
				}
				Debug.Assert(b != default);
				if (b == default) Api.GlobalFree(h);
			}
		}
		
		public bool IsSaved => _data != null;
	}
	
	/// <summary>
	/// Temporarily disables Windows 10 Clipboard History.
	/// Note: before disabling, we must open clipboard, else Clipboard History could be suspended while it has clipboard open.
	/// </summary>
	struct _DisableClipboardHistory {
		//Pasting is unreliable with Windows 10 Clipboard History (CH).
		//Sometimes does not paste because OpenClipboard fails in the target app, because then CH has it open.
		//Then also _IsTargetWindow debugprints. Often just debugprints and waits briefly, but pasting works.
		//CH is enabled by default. Can be disabled in Settings > System > Clipboard.
		//If enabled, CH opens clipboard and gets text after 200 ms, and then repeats every several ms, total ~15 times and 50 ms.
		//	When the target app fails to OpenClipboard, Paste_ waits briefly and the script continues. We receive WM_RENDERFORMAT because CH gets text.
		//If disabled, CH still opens clipboard after 200 ms, total 1-3 times.
		//	When the target app fails to OpenClipboard, Paste_ waits and fails, because does not receive WM_RENDERFORMAT. It seems CH does not get text.
		//Possible workarounds, maybe untested or unreliable or too crazy:
		//	Hook posted messages (in C++ dll) and block WM_CLIPBOARDUPDATE.
		//		Now using.
		//		Simple and fast if using only 64-bit hook.
		//		Less reliable because the message is posted async and can arrive after we remove hook. Never noticed, even with Task.Delay(1).
		//		Does not work if our process is 32-bit. Also does not block viewers of different bitness processes. Never mind, it's rare and not so important.
		//		Blocks CH when this process isn't admin too.
		//		Blocks most other 64-bit clipboard viewers too.
		//	Temporarily SuspendThread. Tested, simple, fast, reliable.
		//		Find all "CLIPBRDWNDCLASS" message-only windows and suspend their threads.
		//		The service process is in user session and not admin.
		//		But then cannot copy/paste in winstore apps, eg Calculator and Stickynotes.
		//	Temporarily stop service "Clipboard User Service_xxxxxxx". Tested. Disables CH completely.
		//		Would be simple and fast, but need to find service name, it is with random suffix.
		//		But need to run as admin.
		//		When pasting, OS autotarts it again after 400-500 ms.
		//		Pausing fails, but can stop/start.
		//		OS does not allow to set startup type "Disabled". And auto-starts when eg the Settings page opened.
		//	Inject a dll into the target process and hook OpenClipboard, let it wait until succeeds. Too crazy.
		//	Send WM_CLOSE to the CH clipboard window (wOC). Tested, works, but too crazy.
		//	Temporarily RemoveClipboardFormatListener. Does not work.
		//Plus there are other OS parts that use clipboard viewers.
		//	Eg the Settings app in the Clipboard page opens/gets text after 500 ms, usually 2 times.
		//	Note: these workarounds may not help while the Clipboard page is open. Then eg pasting often fails because the target app cannot open clipboard.
		//Tested with Ditto too.
		//	Without workaround sometimes fails because the target app cannot open clipboard.
		//	With this workaround (hook) never fails.
		
#if true
		IntPtr _hh;
		//static int s_nhooks; //test how many hooks when eg pasting in loop with small sleep
		
		public void Disable() {
			//if (!osVersion.minWin10_1809 || osVersion.Is32BitProcessAnd64BitOS) return; //no, let's block clipboard viewers on all OS
			if (osVersion.is32BitProcessAnd64BitOS) return;
			//if (keys.isScrollLock) return;
			_hh = Cpp.Cpp_Clipboard(default);
			Debug.Assert(_hh != default);
			//print.it(++s_nhooks); //max 8 when all delays removed in script. Max 4-5 with default options. Max 3-4 with 10.ms() in loop.
		}
		
		public void Restore() {
			if (_hh == default) return;
			var hh = _hh; _hh = default;
			//remove hook later, when all posted WM_CLIPBOARDUPDATE probably are received.
			//	In my quick tests it always worked reliably, even with delay 1 ms. But I did not test with many clipboard viewers and in stress conditions.
			Task.Delay(100).ContinueWith(_ => { Cpp.Cpp_Clipboard(hh); /*s_nhooks--;*/ }); //info: if this process ends sooner, OS removes the hook
		}
#else
		List<Handle_> _a;

		public void Disable() {
			if (!osVersion.minWin10_1809) return;
			for (wnd w = default; ;) {
				w = wnd.findFast(null, "CLIPBRDWNDCLASS", true, w); if (w.Is0) break;
				int tid = w.GetThreadProcessId(out int pid); if (tid == 0) continue;
				if (!process.getName(pid, noSlowAPI: true).Eqi("svchost.exe")) continue;
				var ht = Api.OpenThread(Api.THREAD_SUSPEND_RESUME, false, tid); if (ht.Is0) continue;
				if (Api.SuspendThread(ht) < 0) { ht.Dispose(); continue; }
				_a ??= new List<Handle_>();
				_a.Add(ht);
			}
			Debug_.PrintIf(_a == null, "no suspended threads");
		}

		public void Restore() {
			if (_a == null) return;
			foreach (var ht in _a) {
				Api.ResumeThread(ht);
				ht.Dispose();
			}
		}
#endif
	}
	
	internal static void PrintClipboard_() {
		print.it("---- Clipboard ----");
		using var oc = new OpenClipboard_(true);
		Api.GetClipboardData(0); //JIT
		var save = new _SaveRestore();
		save.Save(true);
	}
}


================================================
FILE: Au/Input/clipboardData.cs
================================================

//#define SUPPORT_RAW_HANDLE

using System.Drawing;
using System.Drawing.Imaging;

namespace Au {
	/// <summary>
	/// Sets or gets clipboard data in multiple formats.
	/// </summary>
	/// <remarks>
	/// The <c>AddX</c> functions add data to the variable (not to the clipboard). Then <see cref="SetClipboard"/> copies the added data to the clipboard. Also you can use the variable with <see cref="clipboard.pasteData"/>.
	/// The static <c>GetX</c> functions get data directly from the clipboard.
	/// </remarks>
	/// <example>
	/// Get bitmap image from clipboard.
	/// <code><![CDATA[
	/// var image = clipboardData.getImage();
	/// if(image == null) print.it("no image in clipboard"); else print.it(image.Size);
	/// ]]></code>
	/// Set clipboard data in two formats: text and image.
	/// <code><![CDATA[
	/// new clipboardData().AddText("text").AddImage(Image.FromFile(@"C:\file.png")).SetClipboard();
	/// ]]></code>
	/// Paste data of two formats: HTML and text.
	/// <code><![CDATA[
	/// clipboard.pasteData(new clipboardData().AddHtml("<b>text</b>").AddText("text"));
	/// ]]></code>
	/// Copy data in two formats: HTML and text.
	/// <code><![CDATA[
	/// string html = null, text = null;
	/// clipboard.copyData(() => { html = clipboardData.getHtml(); text = clipboardData.getText(); });
	/// print.it(html); print.it(text);
	/// ]]></code>
	/// </example>
	public class clipboardData {
		struct _Data { public object data; public int format; }
		List<_Data> _a = new();

		#region add

		static void _CheckFormat(int format, bool minimalCheckFormat = false) {
			bool badFormat = false;
			if (format <= 0 || format > 0xffff) badFormat = true;
			else if (format < 0xC000 && !minimalCheckFormat) {
				if (format >= Api.CF_MAX) badFormat = true; //rare. Most are either not GlobalAlloc'ed or not auto-freed.
				else badFormat = format == Api.CF_BITMAP || format == Api.CF_PALETTE || format == Api.CF_METAFILEPICT || format == Api.CF_ENHMETAFILE; //not GlobalAlloc'ed
			}
			if (badFormat) throw new ArgumentException("Invalid format id.");
		}

		clipboardData _Add(object data, int format, bool minimalCheckFormat = false) {
			Not_.Null(data);
			_CheckFormat(format, minimalCheckFormat);

			_a.Add(new _Data() { data = data, format = format });
			return this;
		}

		/// <summary>
		/// Adds text.
		/// </summary>
		/// <returns>this.</returns>
		/// <param name="text">Text.</param>
		/// <param name="format">
		/// Clipboard format id. Default: <see cref="ClipFormats.Text"/> (<ms>CF_UNICODETEXT</ms>).
		/// Text encoding depends on <i>format</i>; default UTF-16. See <see cref="ClipFormats.Register"/>.
		/// </param>
		/// <exception cref="ArgumentNullException"></exception>
		/// <exception cref="ArgumentException">Invalid <i>format</i>.</exception>
		/// <exception cref="Exception">Exceptions of <see cref="Encoding.GetBytes(string)"/>, which is called if encoding is not UTF-16.</exception>
		public clipboardData AddText(string text, int format = ClipFormats.Text) {
			Encoding enc = ClipFormats.GetTextEncoding_(format, out _);
			if (enc == null) return _Add(text, format == 0 ? Api.CF_UNICODETEXT : format);
			return _Add(enc.GetBytes(text).InsertAt(-1), format);
		}

		/// <summary>
		/// Adds data of any format as <c>byte[]</c>.
		/// </summary>
		/// <returns>this.</returns>
		/// <param name="data"><c>byte[]</c> containing data.</param>
		/// <param name="format">Clipboard format id. See <see cref="ClipFormats.Register"/>.</param>
		/// <exception cref="ArgumentNullException"></exception>
		/// <exception cref="ArgumentException">Invalid <i>format</i>. Supported are all registered formats and standard formats <c>&lt;CF_MAX</c> except GDI handles.</exception>
		public clipboardData AddBinary(byte[] data, int format) {
			return _Add(data, format);
		}

		//rejected: rarely used, difficult to use, creates problems. If somebody needs it, can use API.
#if SUPPORT_RAW_HANDLE
			/// <summary>
			/// Adds data of any format as raw clipboard object handle.
			/// </summary>
			/// <returns>this.</returns>
			/// <param name="handle">Any handle supported by API <ms>SetClipboardData</ms>. The type depends on format. For most formats, after setting clipboard data the handle is owned and freed by Windows.</param>
			/// <param name="format">Clipboard format id. See <see cref="RegisterClipboardFormat"/>.</param>
			/// <exception cref="ArgumentNullException"></exception>
			/// <exception cref="ArgumentException">Invalid format.</exception>
			/// <remarks>
			/// The same handle cannot be added to the clipboard twice. To avoid it, "set clipboard" functions remove handles from the variable.
			/// </remarks>
			public Data AddHandle(IntPtr handle, int format)
			{
				return _Add(handle != default ? (object)handle : null, format, minimalCheckFormat: true);
			}
#endif

		/// <summary>
		/// Adds image.
		/// Uses clipboard format <see cref="ClipFormats.Png"/> and/or <see cref="ClipFormats.Image"/> (<ms>CF_BITMAP</ms>).
		/// </summary>
		/// <returns>this.</returns>
		/// <param name="image">Image. Must be <see cref="Bitmap"/>, else exception.</param>
		/// <param name="png">
		/// Use PNG format (it supports transparency):
		/// <br/>• <c>false</c> - no, only <c>CF_BITMAP</c>.
		/// <br/>• <c>true</c> - yes, only PNG.
		/// <br/>• <c>null</c> (default) - add PNG and <c>CF_BITMAP</c>.
		/// </param>
		/// <exception cref="ArgumentNullException"></exception>
		public clipboardData AddImage(Image image, bool? png = null) {
			var b = (Bitmap)image;
			if (png != false) {
				var ms = new MemoryStream();
				b.Save(ms, ImageFormat.Png);
				_Add(ms.ToArray(), ClipFormats.Png, minimalCheckFormat: true);
			}
			if (png != true) {
				_Add(b, Api.CF_BITMAP, minimalCheckFormat: true);
			}
			return this;
		}

		/// <summary>
		/// Adds HTML text. Uses clipboard format <see cref="ClipFormats.Html"/> (<c>"HTML Format"</c>).
		/// </summary>
		/// <returns>this.</returns>
		/// <param name="html">Full HTML or HTML fragment. If full HTML, a fragment in it can be optionally specified. See examples.</param>
		/// <exception cref="ArgumentNullException"></exception>
		/// <example>
		/// <code><![CDATA[
		/// d.AddHtml("<i>italy</i>");
		/// d.AddHtml("<html><body><i>italy</i></body></html>");
		/// d.AddHtml("<html><body><!--StartFragment--><i>italy</i><!--EndFragment--></body></html>");
		/// ]]></code>
		/// </example>
		public clipboardData AddHtml(string html) {
			return AddBinary(CreateHtmlFormatData_(html), ClipFormats.Html);
			//note: don't support UTF-16 string of HTML format (starts with "Version:"). UTF8 conversion problems.
		}

		/// <summary>
		/// Adds list of files to copy/paste. Uses clipboard format <see cref="ClipFormats.Files"/> (<ms>CF_HDROP</ms>).
		/// </summary>
		/// <returns>this.</returns>
		/// <param name="files">One or more file paths.</param>
		/// <exception cref="ArgumentNullException"></exception>
		public clipboardData AddFiles(params string[] files) {
			Not_.Null(files);
			var b = new StringBuilder("\x14\0\0\0\0\0\0\0\x1\0"); //struct DROPFILES
			foreach (var s in files) { b.Append(s); b.Append('\0'); }
			return _Add(b.ToString(), Api.CF_HDROP, false);
		}

		/// <summary>
		/// Copies the added data of all formats to the clipboard.
		/// </summary>
		/// <exception cref="AuException">Failed to open clipboard (after 10 s of wait/retry) or set clipboard data.</exception>
		/// <exception cref="OutOfMemoryException">Failed to allocate memory for clipboard data.</exception>
		/// <remarks>
		/// Calls API <ms>OpenClipboard</ms>, <ms>EmptyClipboard</ms>, <ms>SetClipboardData</ms> and <ms>CloseClipboard</ms>.
		/// </remarks>
		public void SetClipboard() {
			using (new clipboard.OpenClipboard_(true)) {
				clipboard.EmptyClipboard_();
				SetOpenClipboard();
			}
		}

		/// <summary>
		/// Copies the added data of all formats to the clipboard which is open/owned by this thread.
		/// </summary>
		/// <param name="renderLater">Call API <ms>SetClipboardData</ms>: <c>SetClipboardData(format, default)</c>. When/if some app will try to get clipboard data, the first time your clipboard owner window will receive <ms>WM_RENDERFORMAT</ms> message and should call <c>SetOpenClipboard(false);</c>.</param>
		/// <param name="format">Copy data only of this format. If 0 (default), of all formats.</param>
		/// <exception cref="OutOfMemoryException">Failed to allocate memory for clipboard data.</exception>
		/// <exception cref="AuException">Failed to set clipboard data.</exception>
		/// <remarks>
		/// This function is similar to <see cref="SetClipboard"/>. It calls API <ms>SetClipboardData</ms> and does not call <ms>OpenClipboard</ms>, <ms>EmptyClipboard</ms>, <ms>CloseClipboard</ms>. The clipboard must be open and owned by a window of this thread.
		/// </remarks>
		public void SetOpenClipboard(bool renderLater = false, int format = 0) {
			for (int i = 0; i < _a.Count; i++) {
				var v = _a[i];
				if (format != 0 && v.format != format) continue;
				if (renderLater) {
					lastError.clear();
					Api.SetClipboardData(v.format, default);
					int ec = lastError.code; if (ec != 0) throw new AuException(ec, "*set clipboard data");
				} else _SetClipboard(v.format, v.data);
			}
#if SUPPORT_RAW_HANDLE
				//remove caller-added handles, to avoid using the same handle twice
				if(renderLater) return;
				for(int i = _a.Count; --i >= 0;) {
					var v = _a[i];
					if(format != 0 && v.format != format) continue;
					if(v.data is IntPtr) _a.RemoveAt(i);
				}
#endif
		}

		static unsafe void _SetClipboard(int format, object data) {
			IntPtr h = default;
			switch (data) {
			case string s:
				fixed (char* p = s) h = _CopyToHmem(p, (s.Length + 1) * 2);
				break;
			case byte[] b:
				fixed (byte* p = b) h = _CopyToHmem(p, b.Length);
				break;
#if SUPPORT_RAW_HANDLE
				case IntPtr ip:
					h = ip;
					break;
#endif
			case Bitmap bmp:
				h = bmp.GetHbitmap();
				var h2 = Api.CopyImage(h, 0, 0, 0, Api.LR_COPYDELETEORG); //DIB to compatible bitmap
				if (h2 == default) goto ge;
				h = h2;
				break;
			}
			Debug.Assert(h != default);
			if (default != Api.SetClipboardData(format, h)) return;
			ge:
			int ec = lastError.code;
			if (data is Bitmap) Api.DeleteObject(h); else Api.GlobalFree(h);
			throw new AuException(ec, "*set clipboard data");
		}

		static unsafe IntPtr _CopyToHmem(void* p, int size) {
			var h = Api.GlobalAlloc(Api.GMEM_MOVEABLE, size); if (h == default) goto ge;
			var v = (byte*)Api.GlobalLock(h); if (v == null) { Api.GlobalFree(h); goto ge; }
			try { MemoryUtil.Copy(p, v, size); } finally { Api.GlobalUnlock(h); }
			return h;
			ge: throw new OutOfMemoryException();
		}

		/// <summary>
		/// Copies Unicode text to the clipboard without open/empty/close.
		/// </summary>
		internal static void SetText_(string text) {
			Debug.Assert(text != null);
			_SetClipboard(Api.CF_UNICODETEXT, text);
		}

		/// <summary>
		/// Converts HTML string to <c>byte[]</c> containing data in clipboard format <c>"HTML Format"</c>.
		/// </summary>
		/// <param name="html">Full HTML or HTML fragment. If full HTML, a fragment in it can be optionally specified. See examples.</param>
		/// <exception cref="ArgumentNullException"></exception>
		/// <example>
		/// HTML examples.
		/// <code><![CDATA[
		/// "<i>italy</i>"
		/// "<html><body><i>italy</i></body></html>"
		/// "<html><body><!--StartFragment--><i>italy</i><!--EndFragment--></body></html>"
		/// ]]></code>
		/// </example>
		internal static unsafe byte[] CreateHtmlFormatData_(string html) {
			Not_.Null(html);
			var b = new StringBuilder(c_headerTemplate);
			//find "<body>...</body>" and "<!--StartFragment-->...<!--EndFragment-->" in it
			int isb = -1, ieb = -1, isf = -1, ief = -1; //start/end of inner body and fragment
			if (html.RxMatch(@"<body\b.*?>", 0, out RXGroup body) && (ieb = html.Find("</body>", body.End)) >= 0) {
				isb = body.End;
				isf = html.Find(c_startFragment, isb..ieb, true);
				if (isf >= 0) {
					isf += c_startFragment.Length;
					ief = html.Find(c_endFragment, isf..ieb, true);
				}
			}
			//print.it($"{isb} {ieb}  {isf} {ief}");
			if (ieb < 0) { //no "<body>...</body>"
				b.Append("<html><body>").Append(c_startFragment).Append(html).Append(c_endFragment).Append("</body></html>");
				isf = 12 + c_startFragment.Length;
				ief = isf + Encoding.UTF8.GetByteCount(html);
			} else {
				if (ief < 0) { //"...<body>...</body>..."
					b.Append(html, 0, isb).Append(c_startFragment).Append(html, isb, ieb - isb)
						.Append(c_endFragment).Append(html, ieb, html.Length - ieb);
					isf = isb + c_startFragment.Length;
					ief = ieb + c_startFragment.Length;
				} else { //"...<body>...<!--StartFragment-->...<!--EndFragment-->...</body>..."
					b.Append(html);
					isb = isf; ieb = ief; //reuse these vars to calc UTF8 lengths
				}
				//correct isf/ief if html part lengths are different in UTF8
				if (!html.IsAscii()) {
					fixed (char* p = html) {
						int lenDiff1 = Encoding.UTF8.GetByteCount(p, isb) - isb;
						int lenDiff2 = Encoding.UTF8.GetByteCount(p + isb, ieb - isb) - (ieb - isb);
						isf += lenDiff1;
						ief += lenDiff1 + lenDiff2;
					}
				}
			}
			//print.it($"{isf} {ief}");
			isf += c_headerTemplate.Length; ief += c_headerTemplate.Length;

			b.Append('\0');
			var a = Encoding.UTF8.GetBytes(b.ToString());
			_SetNum(a.Length - 1, 53);
			_SetNum(isf, 79);
			_SetNum(ief, 103);

			//print.it(Encoding.UTF8.GetString(a));
			return a;

			void _SetNum(int num, int i) {
				for (; num != 0; num /= 10) a[--i] = (byte)('0' + num % 10);
			}
		}
		const string c_startFragment = "<!--StartFragment-->";
		const string c_endFragment = "<!--EndFragment-->";
		const string c_headerTemplate = @"Version:0.9
StartHTML:0000000105
EndHTML:0000000000
StartFragment:0000000000
EndFragment:0000000000
";

		#endregion

		#region get

		struct _GlobalLock : IDisposable {
			IntPtr _hmem;

			public _GlobalLock(IntPtr hmem, out IntPtr mem, out int size) {
				mem = Api.GlobalLock(hmem);
				if (mem == default) { _hmem = default; size = 0; return; }
				size = (int)Api.GlobalSize(_hmem = hmem);
			}

			public void Dispose() {
				Api.GlobalUnlock(_hmem);
			}
		}

		/// <summary>
		/// Gets clipboard text without open/close.
		/// If format is 0, tries <c>CF_UNICODETEXT</c> and <c>CF_HDROP</c>.
		/// </summary>
		internal static unsafe string GetText_(int format) {
			IntPtr h = default;
			if (format == 0) {
				h = Api.GetClipboardData(Api.CF_UNICODETEXT);
				if (h == default) format = Api.CF_HDROP;
			}
			if (format == 0) format = Api.CF_UNICODETEXT;
			else {
				h = Api.GetClipboardData(format); if (h == default) return null;
				if (format == Api.CF_HDROP) return string.Join("\r\n", HdropToFiles_(h));
			}

			using (new _GlobalLock(h, out var mem, out int len)) {
				if (mem == default) return null;
				var s = (char*)mem; var b = (byte*)s;

				Encoding enc = ClipFormats.GetTextEncoding_(format, out bool unknown);
				if (unknown) {
					if ((len & 1) != 0 || Ptr_.Length(b, len) > len - 2) enc = Encoding.Default; //autodetect  //never mind: it is UTF-8, not ANSI. Rarely used, especially with non-ASCII text.
				}

				if (enc == null) {
					len /= 2; while (len > 0 && s[len - 1] == '\0') len--;
					return new string(s, 0, len);
				} else {
					//most apps add single '\0' at the end. Some don't add. Some add many, eg Dreamweaver. Trim all.
					int charLen = enc.GetByteCount("\0");
					switch (charLen) {
					case 1:
						while (len > 0 && b[len - 1] == '\0') len--;
						break;
					case 2:
						for (int k = len / 2; k > 0 && s[k - 1] == '\0'; k--) len -= 2;
						break;
					case 4:
						var ip = (int*)s; for (int k = len / 4; k > 0 && ip[k - 1] == '\0'; k--) len -= 4;
						break;
					}
					return enc.GetString(b, len);
					//note: don't parse HTML format here. Let caller use GetHtml or parse itself.
				}
			}
		}

		/// <summary>
		/// Gets text from the clipboard.
		/// </summary>
		/// <returns><c>null</c> if there is no text.</returns>
		/// <param name="format">
		/// Clipboard format id. Default: <see cref="ClipFormats.Text"/> (<ms>CF_UNICODETEXT</ms>).
		/// If 0, tries to get text (<see cref="ClipFormats.Text"/>) or file paths (<see cref="ClipFormats.Files"/>; returns multiline text).
		/// Text encoding depends on <i>format</i>; default UTF-16. See <see cref="ClipFormats.Register"/>.
		/// </param>
		/// <exception cref="AuException">Failed to open clipboard (after 10 s of wait/retry).</exception>
		public static string getText(int format = ClipFormats.Text) {
			using (new clipboard.OpenClipboard_(false)) {
				return GetText_(format);
			}
		}

		/// <summary>
		/// Gets clipboard data of any format as <c>byte[]</c>.
		/// </summary>
		/// <returns><c>null</c> if there is no data of this format.</returns>
		/// <exception cref="ArgumentException">Invalid <i>format</i>. Supported are all registered formats and standard formats <c>&lt;CF_MAX</c> except GDI handles.</exception>
		/// <exception cref="AuException">Failed to open clipboard (after 10 s of wait/retry).</exception>
		public static byte[] getBinary(int format) {
			_CheckFormat(format);
			using (new clipboard.OpenClipboard_(false)) {
				var h = Api.GetClipboardData(format); if (h == default) return null;
				using (new _GlobalLock(h, out var mem, out int len)) {
					if (mem == default) return null;
					var b = new byte[len];
					Marshal.Copy(mem, b, 0, len);
					return b;
				}
			}
		}

		/// <summary>
		/// Gets clipboard data of any format without copying to array. Uses a callback function.
		/// </summary>
		/// <param name="get">Callback function that receives data. The clipboard is open until it returns. The data is read-only.</param>
		/// <returns>The return value of the callback function. Returns <c>default(T)</c> if there is no data of this format.</returns>
		/// <inheritdoc cref="getBinary(int)"/>
		public static T getBinary<T>(int format, Func<IntPtr, int, T> get) {
			_CheckFormat(format);
			using (new clipboard.OpenClipboard_(false)) {
				return _GetBinary(format, get);
			}
		}

		static T _GetBinary<T>(int format, Func<IntPtr, int, T> get) {
			var h = Api.GetClipboardData(format);
			if (h != default) {
				using (new _GlobalLock(h, out var mem, out int len)) {
					if (mem != default) return get(mem, len); //.NET does not allow Func<ReadOnlySpan<byte>, T>
				}
			}
			return default;
		}

#if SUPPORT_RAW_HANDLE
			public static IntPtr GetHandle(int format)
			{
				_CheckFormat(format, minimalCheckFormat: true);
				using(new OpenClipboard_(false)) {
					return Api.GetClipboardData(format);
				}
			}
#endif

		/// <summary>
		/// Gets image from the clipboard.
		/// Uses clipboard format <see cref="ClipFormats.Png"/> or <see cref="ClipFormats.Image"/> (<ms>CF_BITMAP</ms>).
		/// </summary>
		/// <returns><c>null</c> if there is no data of this format.</returns>
		/// <param name="png">
		/// Use PNG format (it supports transparency):
		/// <br/>• <c>false</c> - no, only <c>CF_BITMAP</c>.
		/// <br/>• <c>true</c> - yes, only PNG.
		/// <br/>• <c>null</c> (default) - yes, but get <c>CF_BITMAP</c> if there is no PNG.
		/// </param>
		/// <exception cref="AuException">Failed to open clipboard (after 10 s of wait/retry).</exception>
		/// <exception cref="Exception">Exceptions of <see cref="Image.FromHbitmap"/> or <see cref="Image.FromStream"/>.</exception>
		public static unsafe Bitmap getImage(bool? png = null) {
			using (new clipboard.OpenClipboard_(false)) {
				if (png != false && _GetBinary(ClipFormats.Png, static (mem, len) => {
					using var ms = new UnmanagedMemoryStream((byte*)mem, len);
					return Image.FromStream(ms);
				}) is Bitmap b1) return b1;

				if (png != true) {
					var h = Api.GetClipboardData(Api.CF_BITMAP);
					if (h != default) {
						using var b = Image.FromHbitmap(h, Api.GetClipboardData(Api.CF_PALETTE)); //bottom-up 32Rgb (GDI)
						return b?.Clone(new(default, b.Size), PixelFormat.Format32bppArgb) as Bitmap; //top-down 32Argb (GDI+)
					}
				}
				return null;
			}
		}

		/// <summary>
		/// Gets HTML text from the clipboard. Uses clipboard format <see cref="ClipFormats.Html"/> (<c>"HTML Format"</c>).
		/// </summary>
		/// <returns><c>null</c> if there is no data of this format or if failed to parse it.</returns>
		/// <exception cref="AuException">Failed to open clipboard (after 10 s of wait/retry).</exception>
		public static string getHtml() => getHtml(out _, out _, out _);

		/// <param name="fragmentStart">Fragment start index in the returned string.</param>
		/// <param name="fragmentLength">Fragment length.</param>
		/// <param name="sourceURL">Source URL, or <c>null</c> if unavailable.</param>
		/// <inheritdoc cref="getHtml()"/>
		public static string getHtml(out int fragmentStart, out int fragmentLength, out string sourceURL) {
			return ParseHtmlFormatData_(getBinary(ClipFormats.Html), out fragmentStart, out fragmentLength, out sourceURL);
		}

		internal static string ParseHtmlFormatData_(byte[] b, out int fragmentStart, out int fragmentLength, out string sourceURL) {
			//print.it(s);
			fragmentStart = fragmentLength = 0; sourceURL = null;
			if (b == null) return null;
			string s = Encoding.UTF8.GetString(b);

			int ish = s.Find("StartHTML:", true);
			int ieh = s.Find("EndHTML:", true);
			int isf = s.Find("StartFragment:", true);
			int ief = s.Find("EndFragment:", true);
			if (ish < 0 || ieh < 0 || isf < 0 || ief < 0) return null;
			isf = s.ToInt(isf + 14); if (isf < 0) return null;
			ief = s.ToInt(ief + 12); if (ief < isf) return null;
			ish = s.ToInt(ish + 10); if (ish < 0) ish = isf; else if (ish > isf) return null;
			ieh = s.ToInt(ieh + 8); if (ieh < 0) ieh = ief; else if (ieh < ief) return null;

			if (s.Length != b.Length) {
				if (ieh > b.Length) return null;
				_CorrectOffset(ref isf);
				_CorrectOffset(ref ief);
				_CorrectOffset(ref ish);
				_CorrectOffset(ref ieh);
			} else if (ieh > s.Length) return null;
			//print.it(ish, ieh, isf, ief);

			int isu = s.Find("SourceURL:", true), ieu;
			if (isu >= 0 && (ieu = s.FindAny("\r\n", (isu += 10)..)) >= 0) sourceURL = s[isu..ieu];

			fragmentStart = isf - ish; fragmentLength = ief - isf;
			return s[ish..ieh];

			void _CorrectOffset(ref int i) {
				i = Encoding.UTF8.GetCharCount(b, 0, i);
			}
		}

		/// <summary>
		/// Gets file paths from the clipboard. Uses clipboard format <see cref="ClipFormats.Files"/> (<ms>CF_HDROP</ms>).
		/// </summary>
		/// <returns><c>null</c> if there is no data of this format.</returns>
		/// <exception cref="AuException">Failed to open clipboard (after 10 s of wait/retry).</exception>
		public static string[] getFiles() {
			using (new clipboard.OpenClipboard_(false)) {
				var h = Api.GetClipboardData(Api.CF_HDROP); if (h == default) return null;
				return HdropToFiles_(h);
			}
		}

		/// <summary>
		/// Gets file paths from <c>HDROP</c>.
		/// </summary>
		/// <returns>Array of zero or more non-<c>null</c> elements.</returns>
		internal static unsafe string[] HdropToFiles_(IntPtr hdrop) {
			int n = Api.DragQueryFile(hdrop, -1, null, 0);
			var a = new string[n];
			var b = stackalloc char[500];
			for (int i = 0; i < n; i++) {
				int len = Api.DragQueryFile(hdrop, i, b, 500);
				a[i] = new string(b, 0, len);
			}
			return a;
		}

		#endregion

		#region contains

		/// <summary>
		/// Returns <c>true</c> if the clipboard contains data of the specified format.
		/// </summary>
		/// <param name="format">Clipboard format id. See <see cref="ClipFormats"/>.</param>
		/// <remarks>Calls API <ms>IsClipboardFormatAvailable</ms>.</remarks>
		public static bool contains(int format) {
			return Api.IsClipboardFormatAvailable(format);
		}

		/// <summary>
		/// Returns the first of the specified formats that is in the clipboard.
		/// Returns 0 if the clipboard is empty. Returns -1 if the clipboard contains data but not in any of the specified formats.
		/// </summary>
		/// <param name="formats">Clipboard format ids. See <see cref="ClipFormats"/>.</param>
		/// <remarks>Calls API <ms>GetPriorityClipboardFormat</ms>.</remarks>
		public static int contains(params int[] formats) {
			return Api.GetPriorityClipboardFormat(formats, formats.Length);
		}

		#endregion

		//CONSIDER: EnumFormats, OnClipboardChanged
	}
}

namespace Au.Types {
	/// <summary>
	/// Some clipboard format ids.
	/// These and other standard and registered format ids can be used with <see cref="clipboardData"/> class functions.
	/// </summary>
	public static class ClipFormats {
		/// <summary>The text format. Standard, API constant <ms>CF_UNICODETEXT</ms>. The default format of <see cref="clipboardData"/> add/get text functions.</summary>
		public const int Text = Api.CF_UNICODETEXT;

		/// <summary>The image format. Standard, API constant <ms>CF_BITMAP</ms>. Used by <see cref="clipboardData"/> add/get image functions.</summary>
		public const int Image = Api.CF_BITMAP;

		/// <summary>The file-list format. Standard, API constant <ms>CF_HDROP</ms>. Used by <see cref="clipboardData"/> add/get files functions.</summary>
		public const int Files = Api.CF_HDROP;

		/// <summary>The HTML format. Registered, name <c>"HTML Format"</c>. Used by <see cref="clipboardData"/> add/get HTML functions.</summary>
		public static int Html { get; } = Api.RegisterClipboardFormat("HTML Format");

		/// <summary>The PNG format. Registered, name <c>"PNG"</c>. Used by <see cref="clipboardData"/> add/get image functions.</summary>
		public static int Png { get; } = Api.RegisterClipboardFormat("PNG");

		/// <summary>Registered format <c>"Shell IDList Array"</c>.</summary>
		internal static int ShellIDListArray_ { get; } = Api.RegisterClipboardFormat("Shell IDList Array");

		/// <summary>Registered format <c>"FileGroupDescriptorW"</c>.</summary>
		internal static int FileGroupDescriptorW_ { get; } = Api.RegisterClipboardFormat("FileGroupDescriptorW");

		/// <summary>
		/// Registered format <c>"Clipboard Viewer Ignore"</c>.
		/// </summary>
		/// <remarks>
		/// Some clipboard viewer/manager programs don't try to get clipboard data if this format is present. For example Ditto, Clipdiary.
		/// The copy/paste functions of this library add this format to the clipboard to avoid displaying the temporary text/data in these programs, which also could make the paste function slower and less reliable.
		/// </remarks>
		public static int ClipboardViewerIgnore { get; } = Api.RegisterClipboardFormat("Clipboard Viewer Ignore");

		/// <summary>
		/// Registers a clipboard format and returns its id. If already registered, just returns id.
		/// </summary>
		/// <param name="name">Format name.</param>
		/// <param name="textEncoding">Text encoding, if it's a text format. Used by <see cref="clipboardData.getText"/>, <see cref="clipboardData.AddText"/> and functions that call them. For example <see cref="Encoding.UTF8"/>. If <c>null</c>, text of unknown formats is considered Unicode UTF-16 (no encoding/decoding needed).</param>
		/// <remarks>Calls API <ms>RegisterClipboardFormat</ms>.</remarks>
		public static int Register(string name, Encoding textEncoding = null) {
			var R = Api.RegisterClipboardFormat(name);
			if (textEncoding != null && R != 0 && R != Html) s_textEncoding[R] = textEncoding;
			return R;
		}

		static readonly ConcurrentDictionary<int, Encoding> s_textEncoding = new();

		/// <summary>
		/// Gets text encoding for format.
		/// Returns <c>null</c> if UTF-16 or if the format is unknown and not in <c>s_textEncoding</c>.
		/// </summary>
		internal static Encoding GetTextEncoding_(int format, out bool unknown) {
			unknown = false;
			if (format is 0 or Api.CF_UNICODETEXT or Api.CF_HDROP) return null;
			if (format < Api.CF_MAX) return Encoding.Default; //never mind: it is UTF-8, not ANSI. Rarely used, especially with non-ASCII text.
			if (format == Html) return Encoding.UTF8;
			if (s_textEncoding.TryGetValue(format, out var enc)) return enc == Encoding.Unicode ? null : enc;
			unknown = true;
			return null;
		}

		/// <summary>
		/// Gets clipboard format name.
		/// </summary>
		/// <param name="format">A registered or standard clipboard format. If standard, returns string like <c>"CF_BITMAP"</c>.</param>
		/// <param name="orNull">Return <c>null</c> if <i>format</i> is unknown. If <c>false</c>, returns <i>format</i> as string.</param>
		/// <remarks>
		/// Calls API <ms>GetClipboardFormatName</ms>. Although undocumented, it also can get other strings from the same system atom table, for example registered Windows message names and window class names.
		/// </remarks>
		[SkipLocalsInit]
		public static unsafe string GetName(int format, bool orNull = false) {
			//registered
			if (format >= 0xC000 && format <= 0xffff) {
				var b = stackalloc char[300];
				int len = Api.GetClipboardFormatName(format, b, 300);
				if (len > 0) return new string(b, 0, len);
			}
			//standard
			var s = format switch { Api.CF_TEXT => "CF_TEXT", Api.CF_BITMAP => "CF_BITMAP", Api.CF_METAFILEPICT => "CF_METAFILEPICT", Api.CF_SYLK => "CF_SYLK", Api.CF_DIF => "CF_DIF", Api.CF_TIFF => "CF_TIFF", Api.CF_OEMTEXT => "CF_OEMTEXT", Api.CF_DIB => "CF_DIB", Api.CF_PALETTE => "CF_PALETTE", Api.CF_RIFF => "CF_RIFF", Api.CF_WAVE => "CF_WAVE", Api.CF_UNICODETEXT => "CF_UNICODETEXT", Api.CF_ENHMETAFILE => "CF_ENHMETAFILE", Api.CF_HDROP => "CF_HDROP", Api.CF_LOCALE => "CF_LOCALE", Api.CF_DIBV5 => "CF_DIBV5", _ => null };
			return s ?? (orNull ? null : format.ToS());
		}

		/// <summary>
		/// Gets formats currently in the clipboard.
		/// </summary>
		/// <example>
		/// <code><![CDATA[
		/// foreach (var f in ClipFormats.EnumClipboard()) {
		/// 	print.it(ClipFormats.GetName(f));
		/// }
		/// ]]></code>
		/// </example>
		public static IEnumerable<int> EnumClipboard() {
			using var oc = new clipboard.OpenClipboard_(true);
			for (int format = 0; 0 != (format = Api.EnumClipboardFormats(format));) {
				yield return format;
			}
		}
	}
}


================================================
FILE: Au/Input/inputBlocker.cs
================================================
namespace Au {
	/// <summary>
	/// Blocks keyboard and/or mouse input events from reaching applications.
	/// </summary>
	/// <remarks>
	/// Uses keyboard and/or mouse hooks. Does not use API <ms>BlockInput</ms>, it does not work on current Windows versions.
	/// Blocks hardware-generated events and software-generated events, except generated by functions of this library.
	/// Functions of this library that send keys or text use this class internally, to block user-pressed keys and resend them afterwards (see <see cref="ResendBlockedKeys"/>).
	/// Does not block:
	/// - In windows of the same thread that started blocking. For example, if your script shows a message box, the user can click its buttons.
	/// - In windows of higher [](xref:uac) integrity level (IL) processes, unless this process has uiAccess IL.
	/// - In special desktops/screens, such as when you press <c>Ctrl+Alt+Delete</c> or launch an admin program that requires UAC elevation. See also <see cref="ResumeAfterCtrlAltDelete"/>.
	/// - Some Windows hotkeys, such as <c>Ctrl+Alt+Delete</c> and <c>Win+L</c>.
	/// - Keyboard hooks don't work in windows of this process if this process uses direct input or raw input API.
	/// 
	/// To stop blocking, can be used <c>using</c>, like in the example. Or <c>try</c> with <c>finally</c> code that calls <see cref="Dispose"/> or <see cref="Stop"/>. Also automatically stops when this thread ends. Users can stop with <c>Ctrl+Alt+Delete</c>.
	/// </remarks>
	/// <example>
	/// <code><![CDATA[
	/// using(new inputBlocker(BIEvents.All)) {
	/// 	print.it("blocked");
	/// 	5.s();
	/// }
	/// print.it("not blocked");
	/// ]]></code>
	/// </example>
	public sealed unsafe class inputBlocker : IDisposable {
		Handle_ _syncEvent, _stopEvent;
		Handle_ _threadHandle;
		keys _blockedKeys;
		long _startTime;
		BIEvents _block;
		int _threadId;
		bool _disposed;
		bool _discardBlockedKeys;
		
		//note: don't use API BlockInput because:
		//	UAC. Fails if our process has Medium IL.
		//	Too limited, eg cannot block only keys or only mouse.
		
		/// <summary>
		/// This constructor does nothing (does not call <see cref="Start"/>).
		/// </summary>
		public inputBlocker() { }
		
		/// <summary>
		/// This constructor calls <see cref="Start"/>.
		/// </summary>
		/// <exception cref="ArgumentException"><i>what</i> is 0.</exception>
		public inputBlocker(BIEvents what) {
			Start(what);
		}
		
		/// <summary>
		/// Starts blocking.
		/// </summary>
		/// <exception cref="ArgumentException"><i>what</i> is 0.</exception>
		/// <exception cref="InvalidOperationException">Already started.</exception>
		public void Start(BIEvents what) {
			if (_disposed) throw new ObjectDisposedException(nameof(inputBlocker));
			if (_block != 0) throw new InvalidOperationException();
			if (!what.HasAny(BIEvents.All)) throw new ArgumentException();
			
			_block = what;
			_startTime = Environment.TickCount64;
			
			_syncEvent = Api.CreateEvent(false);
			_stopEvent = Api.CreateEvent(false);
			_threadHandle = Api.OpenThread(Api.SYNCHRONIZE, false, _threadId = Api.GetCurrentThreadId());
			
			ThreadPool.QueueUserWorkItem(_this => (_this as inputBlocker)._ThreadProc(), this);
			//TODO3: what if thread pool is very busy? Eg if scripts use it incorrectly. Maybe better have own internal pool.
			
			Api.WaitForSingleObject(_syncEvent, Timeout.Infinite);
			GC.KeepAlive(this);
		}
		
		/// <summary>
		/// Calls <see cref="Stop"/>.
		/// </summary>
		public void Dispose() {
			if (!_disposed) {
				_disposed = true;
				Stop();
				GC.SuppressFinalize(this);
			}
		}
		
		///
		~inputBlocker() => _CloseHandles();
		
		void _CloseHandles() {
			if (!_syncEvent.Is0) {
				_syncEvent.Dispose();
				_stopEvent.Dispose();
				_threadHandle.Dispose();
			}
		}
		
		/// <summary>
		/// Stops blocking.
		/// Plays back blocked keys if need. See <see cref="ResendBlockedKeys"/>.
		/// Does nothing if currently is not blocking.
		/// </summary>
		/// <param name="discardBlockedKeys">Do not play back blocked key-down events recorded because of <see cref="ResendBlockedKeys"/>.</param>
		public void Stop(bool discardBlockedKeys = false) {
			if (_block == 0) return;
			_block = 0;
			_discardBlockedKeys = discardBlockedKeys;
			Api.SetEvent(_stopEvent);
			Api.WaitForSingleObject(_syncEvent, Timeout.Infinite);
			_CloseHandles();
		}
		
		const int c_maxResendTime = 10000;
		
		void _ThreadProc() {
			WindowsHook hk = null, hm = null; WinEventHook hwe = null;
			try {
				try {
					if (_block.Has(BIEvents.Keys))
						hk = WindowsHook.Keyboard(_keyHookProc ??= _KeyHookProc);
					if (_block.HasAny(BIEvents.MouseClicks | BIEvents.MouseMoving))
						hm = WindowsHook.Mouse(_mouseHookProc ??= _MouseHookProc);
				}
				catch (AuException e1) { Debug_.Print(e1); _block = 0; return; } //failed to hook
				
				//This prevents occassional inserting a foreign key after the first our-script-pressed key.
				//To reproduce, let our script send small series of chars in loop, and simultaneously a foreign script send other chars.
				wait.doEvents();
				
				//print.it("started");
				Api.SetEvent(_syncEvent);
				
				//the hook detects Ctrl+Alt+Del, Win+L, UAC consent, etc. SystemEvents.SessionSwitch only Win+L.
				try { hwe = new WinEventHook(EEvent.SYSTEM_DESKTOPSWITCH, 0, _winEventProc ??= _WinEventProc); }
				catch (AuException e1) { Debug_.Print(e1); } //failed to hook
				
				wait.Wait_(-1, WHFlags.DoEvents, new IntPtr[] { _stopEvent, _threadHandle });
				
				if (_blockedKeys != null) {
					bool onlyUp = _discardBlockedKeys || Environment.TickCount64 - _startTime > c_maxResendTime;
					_blockedKeys.SendBlocked_(onlyUp);
				}
				//print.it("ended");
			}
			finally {
				_blockedKeys = null;
				hk?.Dispose();
				hm?.Dispose();
				hwe?.Dispose();
				Api.SetEvent(_syncEvent);
			}
			GC.KeepAlive(this);
		}
		
		Action<HookData.Keyboard> _keyHookProc;
		Action<HookData.Mouse> _mouseHookProc;
		Action<HookData.WinEvent> _winEventProc;
		
		void _KeyHookProc(HookData.Keyboard x) {
			if (_DontBlock(x.IsInjected, x.dwExtraInfo, x.vkCode)) {
				//print.it("ok", x.vkCode, !x.IsUp);
				return;
			}
			//print.it(message, x.vkCode);
			
			//if(x.vkCode == KKey.Delete && !x.IsUp) {
			//	//Could detect Ctrl+Alt+Del here. But SetWinEventHook(SYSTEM_DESKTOPSWITCH) is better.
			//}
			
			if (ResendBlockedKeys && Environment.TickCount64 - _startTime < c_maxResendTime) {
				//If Shift is set to turn off CapsLock, on Shift the hook receives LShift down and CapsLock down/up with no 'injected' flag, even if the Shift was pressed by a script.
				//If we resend them, the hook catches the resent keys, and the resent LShift creates an infinite loop (actually for 10 s, see c_maxResendTime).
				//Workaround: don't resend these keys if isCapsLock and the system setting is active.
				//Also SendBlocked_ prevents such infinite loop in any case.
				bool no = false;
				if (x.vkCode == KKey.CapsLock || (x.vkCode == KKey.LShift && !x.IsUp)) {
					no = keys.isCapsLock && keys.IsCapsLockShiftOff_();
				}
				
				if (!no) {
					_blockedKeys ??= new keys(null);
					//print.it("blocked", x.vkCode, !x.IsUp, x.IsInjected);
					_blockedKeys.AddRaw_(x.vkCode, (ushort)x.scanCode, x.SendInputFlags_);
				}
			}
			x.BlockEvent();
		}
		
		void _MouseHookProc(HookData.Mouse x) {
			bool isMMove = x.Event == HookData.MouseEvent.Move;
			switch (_block & (BIEvents.MouseClicks | BIEvents.MouseMoving)) {
			case BIEvents.MouseClicks | BIEvents.MouseMoving: break;
			case BIEvents.MouseClicks: if (isMMove) return; break;
			case BIEvents.MouseMoving: if (!isMMove) return; break;
			}
			if (!_DontBlock(x.IsInjected, x.dwExtraInfo, 0, isMMove)) x.BlockEvent();
		}
		
		bool _DontBlock(bool isInjected, nint extraInfo, KKey vk = 0, bool isMMove = false) {
			if (_pause) return true;
			if (isInjected) {
				//if(DontBlockInjected || (extraInfo != default && extraInfo == DontBlockInjectedExtraInfo)) return true;
				if (DontBlockInjected) return true;
			}
			wnd w;
			if (vk != 0) {
				//var a = DontBlockKeys;
				//if(a != null) foreach(var k in a) if(vk == k) return true;
				w = wnd.active;
			} else {
				w = isMMove ? wnd.active : wnd.fromMouse();
				//note: don't use hook's pt, because of a bug in some OS versions.
				//note: for wheel it's better to use FromMouse.
			}
			if (w.ThreadId == _threadId) return true;
			return false;
		}
		
		void _WinEventProc(HookData.WinEvent x) {
			//the hook is called before and after Ctrl+Alt+Del screen. Only idEventThread different.
			//	GetForegroundWindow returns 0. WTSGetActiveConsoleSessionId returns main session.
			
			//print.it("desktop switch"); //return;
			
			_startTime = 0; //don't resend Ctrl+Alt+Del and other blocked keys
			if (!ResumeAfterCtrlAltDelete)
				ThreadPool.QueueUserWorkItem(_this => (_this as inputBlocker).Stop(), this);
		}
		
		/// <summary>
		/// Continue blocking when returned from a special screen where blocking is disabled: <c>Ctrl+Alt+Delete</c>, [](xref:uac) consent, etc.
		/// </summary>
		public bool ResumeAfterCtrlAltDelete { get; set; }
		
		/// <summary>
		/// Record blocked keys, and play back when stopped blocking.
		/// </summary>
		/// <remarks>
		/// Will not play back if: 1. The blocking time is > 10 seconds; then plays back only key-up events. 2. Detected <c>Ctrl+Alt+Delete</c>, [](xref:uac) consent or some other special screen. 3. Called <see cref="Pause"/>.
		/// </remarks>
		public bool ResendBlockedKeys { get; set; }
		
		/// <summary>
		/// Don't block software-generated key/mouse events.
		/// If <c>false</c> (default), only events generated by functions of this library are not blocked.
		/// </summary>
		public bool DontBlockInjected { get; set; }
		
		//rejected. Will be added later if need. Maybe a callback instead.
		///// <summary>
		///// Don't block software-generated key/mouse events if this extra info value was set when calling API <ms>SendInput</ms>.
		///// </summary>
		///// <remarks>
		///// Regardless of the property value, events generated by functions of this library are never blocked.
		///// </remarks>
		//public nint DontBlockInjectedExtraInfo { get; set; }
		
		///// <summary>
		///// Don't block these keys.
		///// </summary>
		///// <remarks>
		///// For modifier keys use the left/right key code: <c>LCtrl</c>, <c>RCtrl</c>, <c>LShift</c>, <c>RShift</c>, <c>LAlt</c>, <c>RAlt</c>, <c>Win</c>, <c>RWin</c>.
		///// </remarks>
		//public static KKey[] DontBlockKeys { get; set; }
		
		/// <summary>
		/// Gets or sets whether the blocking is paused.
		/// </summary>
		/// <remarks>
		/// The <c>set</c> function is much faster than <see cref="Stop"/>/<see cref="Start"/>. Does not remove hooks etc. Discards blocked keys.
		/// </remarks>
		public bool Pause {
			get => _pause;
			set {
				_pause = value;
				_startTime = 0; //don't resend blocked keys
			}
		}
		bool _pause;
	}
}

namespace Au.Types {
	/// <summary>
	/// Used with <see cref="inputBlocker"/> class to specify what user input types to block (keys, mouse).
	/// </summary>
	[Flags]
	public enum BIEvents {
		/// <summary>
		/// Do not block.
		/// </summary>
		None,
		
		/// <summary>
		/// Block keys. Except if generated by functions of this library.
		/// </summary>
		Keys = 1,
		
		/// <summary>
		/// Block mouse clicks and wheel. Except if generated by functions of this library.
		/// </summary>
		MouseClicks = 2,
		
		/// <summary>
		/// Block mouse moving. Except if generated by functions of this library.
		/// </summary>
		MouseMoving = 4,
		
		/// <summary>
		/// Block keys, mouse clicks, wheel and mouse moving. Except if generated by functions of this library.
		/// This flag combines all other non-zero flags.
		/// </summary>
		All = 7,
	}
	
	
}


================================================
FILE: Au/Input/keys.cs
================================================
//TODO3: on exception release modifiers.

namespace Au;

/// <summary>
/// Keyboard functions. Send virtual keystrokes and text to the active window, get key state, wait for key.
/// </summary>
/// <remarks>
/// The main function is <see cref="send"/>. Most documentation is there. See also <see cref="sendt"/>. These functions use <see cref="opt.key"/>. Alternatively can be used <c>keys</c> variables, see <see cref="keys(OKey)"/>.
/// </remarks>
/// <example>
/// <code><![CDATA[
/// keys.send("Ctrl+Shift+Left"); //press Ctrl+Shift+Left
/// 
/// opt.key.KeySpeed = 300; //set options for static functions
/// keys.send("Ctrl+A Del Tab*3", "!text", "Enter", 500); //press Ctrl+A, Del, Tab 3 times, send text, Enter, wait 500 ms
/// 
/// keys.sendt("text\r\n"); //send text that ends with newline
/// ]]></code>
/// </example>
public partial class keys {
	/// <param name="cloneOptions">Options to be copied to <see cref="Options"/> of this variable. Usually <c>opt.key</c> (current ambient options) or <c>null</c> (default options).</param>
	/// <example>
	/// <code><![CDATA[
	/// var k = new keys(null);
	/// k.Options.KeySpeed = 50;
	/// k.AddKeys("Tab // Space").AddRepeat(3).AddText("text").AddKey(KKey.Enter).AddSleep(500);
	/// k.SendNow(); //sends and clears the variable
	/// k.Add("Tab // Space*3", "!text", KKey.Enter, 500); //the same as the above k.AddKeys... line
	/// for(int i = 0; i < 5; i++) k.SendNow(true); //does not clear the variable
	/// ]]></code>
	/// </example>
	public keys(OKey cloneOptions) { Options = new OKey(cloneOptions); }

	/// <summary>
	/// Options used by this variable.
	/// </summary>
	public OKey Options { get; }

	//KEYEVENTF_ flags for API SendInput.
	[Flags]
	enum _KFlags : byte {
		Extended = 1,
		Up = 2,
		Unicode = 4,
		Scancode = 8,
	};

	//_KEvent type - key, text, sleep, etc.
	enum _KType : byte {
		KeyEvent, //send key down or up event, depending on _KFlags.Up. In _KEvent used vk and scan.
		KeyPair, //send key down and up events. In _KEvent used vk and scan.
		Char, //send character using keys. In _KEvent used ch.
		Text, //send text. In _KEvent used data, it is _data or _data element index.
		Callback, //call callback function. In _KEvent used data, it is _data or _data element index.
		Repeat, //repeat previous key. In _KEvent used repeat.
		Sleep, //sleep. In _KEvent used sleep.
	}

	[StructLayout(LayoutKind.Explicit)]
	struct _KEvent {
		[FieldOffset(0)] internal KKey vk; //byte
		[FieldOffset(1)] byte _flags; //_KFlags in 0x0F and _KType in 0xF0
		[FieldOffset(2)] internal ushort scan; //scan code if IsKey
		[FieldOffset(2)] internal ushort data; //_data or _data index if IsText or IsCallback
		[FieldOffset(2)] internal ushort repeat; //repeat count if IsRepeat
		[FieldOffset(2)] internal ushort sleep; //milliseconds if IsSleep
		[FieldOffset(2)] internal ushort ch; //character if IsChar

		//Event type KeyEvent or KeyPair.
		internal _KEvent(bool pair, KKey vk, _KFlags siFlags, ushort scan = 0) {
			this.vk = vk;
			var f = (byte)siFlags; if (pair) f |= 16; _flags = f;
			this.scan = scan;
		}

		//Event of any type except KeyEvent and KeyPair.
		internal _KEvent(_KType type, ushort data) {
			Debug.Assert(type > _KType.KeyPair);
			_flags = (byte)((byte)type << 4);
			this.data = data;
		}

		internal _KType Type => (_KType)(_flags >> 4);
		internal bool IsPair => Type is _KType.KeyPair;
		internal bool IsKey => Type <= _KType.KeyPair;
		internal bool IsChar => Type == _KType.Char;
		internal bool IsKeyOrChar => Type <= _KType.Char;
		internal bool IsText => Type == _KType.Text;
		internal bool IsCallback => Type == _KType.Callback;
		internal bool IsRepeat => Type == _KType.Repeat;
		internal bool IsSleep => Type == _KType.Sleep;
		internal bool IsUp => 0 != (_flags & 2);
		internal _KFlags SIFlags => (_KFlags)(_flags & 15);
		internal void MakeDown() => _flags &= 9;
		internal void MakeUp() => _flags = (byte)((_flags & 9) | 2);

#if DEBUG
		public override string ToString() {
			if (IsText) { Debug.Assert(SIFlags == 0); return $"text " + data; }
			if (IsCallback) { Debug.Assert(SIFlags == 0); return $"callback " + data; }
			if (IsSleep) { Debug.Assert(SIFlags == 0); return "sleep " + sleep; }
			if (IsRepeat) { Debug.Assert(SIFlags == 0); return "repeat " + repeat; }
			if (IsChar) { Debug.Assert(SIFlags == 0); return "char " + ch; }
			return $"{vk,-12} scan={scan,-4} flags={_flags}";
		}
#endif
	}

	//This struct is used to separate parsing-only fields from other fields.
	struct _KParsingState {
		public Stack<_KEvent> mod; //pushed on "+" or "+(". Then popped on key not preceded by +, and also in Send().
		public bool paren; //we are between "+(" and ")"
		public bool plus; //we are between "+" and key or text
	}

	//This struct is used to separate sending-only fields from other fields.
	struct _KSendingState {
		public wnd wFocus;
		public OKey options;

		public void Clear() {
			wFocus = default;
		}
	}

	readonly List<_KEvent> _a = new(); //all key events and elements for each text/callback/repeat/sleep
	object _data; //text and callback parts. If there is 1 such part, it is string or Action; else it is List<object>.
	_KParsingState _pstate; //parsing state
	_KSendingState _sstate; //sending state
	bool _sending; //while sending, don't allow to add or send
	bool? _antiCapsLock;

	/// <summary>
	/// Adds keystrokes to the internal collection. They will be sent by <see cref="SendNow"/>.
	/// </summary>
	/// <returns>This.</returns>
	/// <param name="keys_">
	/// [Key names and operators](xref:key_names), like with <see cref="send"/>. Can be <c>null</c> or <c>""</c>.
	/// Example: <c>"Tab Ctrl+V Alt+(E P) Left*3 Space a , 5 #5"</c>.
	/// If has prefix <c>"!"</c> or <c>"%"</c>, calls <see cref="AddText(string, string)"/>; use <c>"!"</c> for text, <c>"%"</c> for HTML.
	/// </param>
	/// <exception cref="ArgumentException">Error in <i>keys_</i> string, for example an unknown key name.</exception>
	public keys AddKeys([ParamString(PSFormat.Keys)] string keys_) {
		_ThrowIfSending();
		var k = keys_;
		if (k.NE()) return this;
		if (k[0] == '!') return AddText(k[1..]);
		if (k[0] == '%') return AddText(null, k[1..]);
		int i = 0, len = 0;
		foreach (var g in _SplitKeysString(k)) {
			//print.it($"<><c #C000>{g.Value}</c>"); //continue;
			i = g.Start; len = g.Length;
			char c = k[i]; _KEvent e;
			switch (c) {
			case '*':
				if (len == 1 || _a.Count == 0) goto ge;
				e = _a[^1];
				char cLast = k[i + len - 1];
				switch (cLast) {
				case 'n': //down
				case 'p': //up
					if (e.IsPair) {
						//make the last key down-only or up-only
						if (cLast == 'p') e.MakeUp(); else e.MakeDown();
						_a[^1] = e;
					} else if (cLast == 'p' && _FindLastKey(out e)) {
						//allow eg Key("A*down*3*up") or Key("A*down", 500, "*up")
						e.MakeUp();
						_a.Add(e);
					} else goto ge;
					break;
				default: //repeat
					if (!e.IsKeyOrChar) goto ge;
					AddRepeat(k.ToInt(i + 1));
					break;
				}
				break;
			case '+':
				if (_pstate.paren || _a.Count == 0) goto ge;
				e = _a[^1];
				if (!e.IsPair) goto ge;
				e.MakeDown();
				_a[^1] = e;
				e.MakeUp();
				_pstate.mod ??= new Stack<_KEvent>();
				_pstate.mod.Push(e);
				if (len > 1) _pstate.paren = true; //"*("
				else _pstate.plus = true;
				break;
			case ')':
				if (!_pstate.paren) goto ge;
				_pstate.paren = false;
				_AddModUp();
				break;
			case '_' when len == 2:
				AddChar(k[i + 1]);
				break;
			case '^':
				if (_pstate.paren) goto ge;
				if (++i == g.End) break;
				if (g.End - i == 1 || _pstate.plus) {
					while (i < g.End) AddChar(k[i++]);
				} else { //avoid eg Shift up/down between AB
					_AddTextAndHow(k[i..], OKeyText.KeysOrChar, true);
				}
				break;
			//case '!': //rejected. Too many rules. Better slightly longer code than 2 ways to do the same.
			//	AddText(k[++i..]);
			//	break;
			default:
				//rejected: if non-ASCII, use AddChar. Why to add yet another rule for something rarely used.
				var vk = _KeynameToKey(k, i, len);
				if (vk == 0) goto ge;
				AddKey(vk);
				//print.it(vk);
				break;
			}
		}
		return this;
		ge: throw _ArgumentException_ErrorInKeysString(k, i, len);

		bool _FindLastKey(out _KEvent e) {
			for (int j = _a.Count; --j >= 0;) {
				var t = _a[j];
				if (t.IsKey) { e = t; return true; }
			}
			e = default; return false;
		}
	}

	//Adds mod up events if need: if _parsing.mod is not empty and + is not active and ( is not active.
	void _AddModUp() {
		if (!_pstate.plus && !_pstate.paren && _pstate.mod != null) {
			while (_pstate.mod.Count != 0) _a.Add(_pstate.mod.Pop());
		}
	}

	//Adds key or other event. Calls _ModUp(). Not used fo sleep and repeat.
	keys _AddKEvent(_KEvent e) {
		_AddModUp();
		_pstate.plus = false;
		_a.Add(e);
		return this;
	}

	/// <summary>
	/// Adds single key, specified as <see cref="KKey"/>, to the internal collection. It will be sent by <see cref="SendNow"/>.
	/// </summary>
	/// <returns>This.</returns>
	/// <param name="key">Virtual-key code, like <c>KKey.Tab</c> or <c>(KKey)200</c>. Valid values are 1-255.</param>
	/// <param name="down"><c>true</c> - key down; <c>false</c> - key up; <c>null</c> (default) - key down-up.</param>
	/// <exception cref="ArgumentException">Invalid <i>key</i> (0).</exception>
	public keys AddKey(KKey key, bool? down = null) {
		_ThrowIfSending();
		if (key == 0) throw new ArgumentException("Invalid value.", nameof(key));

		_KFlags f = 0;
		if (down == false) f |= _KFlags.Up;
		if (KeyTypes_.IsExtended(key)) f |= _KFlags.Extended;

		return _AddKEvent(new _KEvent(down == null, key, f));
	}

	/// <summary>
	/// Adds single key to the internal collection. Allows to specify scan code and whether it is an extended key. It will be sent by <see cref="SendNow"/>.
	/// </summary>
	/// <returns>This.</returns>
	/// <param name="key">Virtual-key code, like <c>KKey.Tab</c> or <c>(KKey)200</c>. Valid values are 1-255. Can be 0.</param>
	/// <param name="scanCode">Scan code of the physical key. Scan code values are 1-127, but this function allows 1-0xffff. Can be 0.</param>
	/// <param name="extendedKey"><c>true</c> if the key is an extended key.</param>
	/// <param name="down"><c>true</c> - key down; <c>false</c> - key up; <c>null</c> (default) - key down-up.</param>
	/// <exception cref="ArgumentException">Invalid scan code.</exception>
	public keys AddKey(KKey key, ushort scanCode, bool extendedKey, bool? down = null) {
		_ThrowIfSending();
		_KFlags f = 0;
		if (key == 0) f = _KFlags.Scancode;
		else {
			//don't: if extendedKey false, set true if need. Don't do it because this func is 'raw'.
		}

		if (down == false) f |= _KFlags.Up;
		if (extendedKey) f |= _KFlags.Extended;

		return _AddKEvent(new _KEvent(down == null, key, f, scanCode));
	}

	/// <summary>
	/// Adds single character to the internal collection. It will be sent like text with option <see cref="OKeyText.KeysOrChar"/>.
	/// </summary>
	/// <returns>This.</returns>
	public keys AddChar(char c) {
		_ThrowIfSending();
		return _AddKEvent(new _KEvent(_KType.Char, c));
	}


	/// <summary>
	/// Adds key down or up event.
	/// </summary>
	/// <param name="vk"></param>
	/// <param name="scan"></param>
	/// <param name="siFlags"><c>SendInput</c> flags.</param>
	internal keys AddRaw_(KKey vk, ushort scan, byte siFlags) {
		_ThrowIfSending();
		return _AddKEvent(new _KEvent(false, vk, (_KFlags)(siFlags & 0xf), scan));
	}

	/// <summary>
	/// Sends key events added by <c>AddRaw_</c> (called by <see cref="inputBlocker"/>).
	/// Simply calls <c>Api.SendInput</c>. No options, no sleep, etc. No exceptions.
	/// If new events added while sending, sends them too, until there are no new events added.
	/// </summary>
	/// <param name="onlyUp">Send only "up" events.</param>
	internal unsafe void SendBlocked_(bool onlyUp) {
		for (int ii = 0; ii < 5; ii++) {
			int n = 0;
			var a = new Api.INPUTK[_a.Count];
			for (int i = 0; i < _a.Count; i++) {
				var k = _a[i];
				if (onlyUp && !k.IsUp) continue;
				a[n++].Set(k.vk, k.scan, (uint)k.SIFlags);
			}
			_a.Clear();
			if (n == 0) return;
			fixed (Api.INPUTK* p = a) Api.SendInput(p, n, dontThrow: true);
			//wait.doEvents(); //sometimes catches one more event, but not necessary

			if (_a.Count == 0) break;
			Debug_.PrintIf(ii == 4, "loop?");
			//The hook proc is called while in SendInput. If we don't retry, new blocked keys are lost.
			//	But don't retry forever, because in some cases OS injects keys and the hook receives them not marked as injected, eg on Shift if it is set to turn off CapsLock.
		}
	}

	/// <summary>
	/// Adds text or HTML. It will be sent by <see cref="SendNow"/>.
	/// </summary>
	/// <returns>This.</returns>
	/// <remarks>
	/// To send text can use keys, characters or clipboard, depending on <see cref="opt.key"/> and text. If <i>html</i> not <c>null</c>, uses clipboard.
	/// </remarks>
	/// <inheritdoc cref="sendt" path="/param"/>
	public keys AddText(string text, string html = null) {
		_ThrowIfSending();
		if (!html.NE()) {
			var data = new clipboardData().AddHtml(html).AddText(text ?? html);
			var ke = new _KEvent(_KType.Text, _SetData(data));
			_AddKEvent(ke);
		} else if (!text.NE()) {
			var ke = new _KEvent(_KType.Text, _SetData(text));
			_AddKEvent(ke);
		}
		return this;
	}

	/// <summary>
	/// Adds text with explicitly specified sending method (keys, characters or paste).
	/// </summary>
	/// <returns>This.</returns>
	/// <param name="text">Text. Can be <c>null</c>.</param>
	/// <param name="how">Overrides <see cref="OKey.TextHow"/>.</param>
	public keys AddText(string text, OKeyText how) {
		_ThrowIfSending();
		_AddTextAndHow(text, how, false);
		return this;
	}

	void _AddTextAndHow(string text, OKeyText how, bool keysArg) {
		if (!text.NE()) {
			int flags = (int)how | 0x80; if (keysArg) flags |= 0x40;
			var ke = new _KEvent(_KType.Text, _SetData(text)) { vk = (KKey)flags };
			_AddKEvent(ke);
		}
	}

	/// <summary>
	/// Adds clipboard data, for example several formats. It will be pasted by <see cref="SendNow"/>.
	/// </summary>
	/// <returns>This.</returns>
	/// <param name="cd">Clipboard data.</param>
	public keys AddClipboardData(clipboardData cd) {
		Not_.Null(cd);
		_ThrowIfSending();
		_AddKEvent(new _KEvent(_KType.Text, _SetData(cd)));
		return this;
	}

	//Adds text (string) or clipboardData or callback (Action) to _data.
	ushort _SetData(object x) {
		int i;
		if (_data == null) {
			i = 0;
			_data = x;
		} else if (_data is List<object> a) {
			i = a.Count;
			a.Add(x);
		} else {
			i = 1;
			_data = new List<object>() { _data, x };
		}
		return checked((ushort)i);
	}

	//Gets text (string) or clipboardData or callback (Action) from _data.
	object _GetData(ushort i) {
		if (_data is List<object> a) return a[i];
		return _data;
	}

	/// <summary>
	/// Adds a callback function.
	/// </summary>
	/// <returns>This.</returns>
	/// <param name="a"></param>
	/// <remarks>
	/// The callback function will be called by <see cref="SendNow"/> and can do anything except sending keys and copy/paste.
	/// </remarks>
	public keys AddAction(Action a) {
		Not_.Null(a);
		_ThrowIfSending();
		return _AddKEvent(new _KEvent(_KType.Callback, _SetData(a)));
	}

	/// <summary>
	/// Adds the repeat operator. Then <see cref="SendNow"/> will send the last added key or character <i>count</i> times.
	/// </summary>
	/// <returns>This.</returns>
	/// <param name="count">The repeat count.</param>
	/// <exception cref="ArgumentOutOfRangeException"><i>count</i> >10000 or &lt;0.</exception>
	/// <exception cref="ArgumentException">The last added item is not a key or single character.</exception>
	public keys AddRepeat(int count) {
		_ThrowIfSending();
		if ((uint)count > 10000) throw new ArgumentOutOfRangeException(nameof(count), "Max repeat count is 10000.");
		int i = _a.Count; if (i == 0 || !_a[i - 1].IsKeyOrChar) throw new ArgumentException("No key to repeat.");
		_a.Add(new _KEvent(_KType.Repeat, (ushort)count));
		return this;
	}

	/// <summary>
	/// Adds a short pause. Then <see cref="SendNow"/> will sleep (wait).
	/// </summary>
	/// <returns>This.</returns>
	/// <param name="timeMS">Time to sleep, milliseconds.</param>
	/// <exception cref="ArgumentOutOfRangeException"><i>timeMS</i> >10000 (1 minute) or &lt;0.</exception>
	public keys AddSleep(int timeMS) {
		_ThrowIfSending();
		if ((uint)timeMS > 10000) throw new ArgumentOutOfRangeException(nameof(timeMS), "Max sleep time is 10000.");
		_a.Add(new _KEvent(_KType.Sleep, (ushort)timeMS));
		return this;
	}

	/// <summary>
	/// Adds keystrokes, text, sleep and other events to the internal collection. They will be sent/executed by <see cref="SendNow"/>.
	/// </summary>
	/// <returns>This.</returns>
	/// <inheritdoc cref="keys.send" path="/param"/>
	public keys Add([ParamString(PSFormat.Keys)] params KKeysEtc[] keysEtc) {
		_ThrowIfSending();
		if (keysEtc != null) {
			for (int i = 0; i < keysEtc.Length; i++) {
				var o = keysEtc[i].Value ?? "";
				switch (o) {
				case string s:
					AddKeys(s);
					break;
				case clipboardData cd:
					AddClipboardData(cd);
					break;
				case KKey k:
					AddKey(k);
					break;
				case char c:
					AddChar(c);
					break;
				case int ms:
					AddSleep(ms);
					break;
				case Action g:
					AddAction(g);
					break;
				case KKeyScan t:
					AddKey(t.vk, t.scanCode, t.extendedKey);
					break;
				}
			}
		}
		return this;
	}

	/// <summary>
	/// Sends keys, text and executes other events added with the <c>AddX</c> functions.
	/// </summary>
	/// <param name="canSendAgain">Don't clear the internal collection. If <c>true</c>, this function then can be called again (eg in loop) to send/execute the same keys etc. If <c>false</c> (default), clears the added keys etc; then you can call <c>AddX</c> functions and <c>SendNow</c> again.</param>
	/// <exception cref="ArgumentException"><i>canSendAgain</i> is <c>true</c> and <i>keys_</i> end with <c>+</c> or <c>(</c>.</exception>
	/// <exception cref="AuException">Failed. For example there is no focused window when sending text.</exception>
	/// <exception cref="InputDesktopException"></exception>
	public void SendNow(bool canSendAgain = false) {
		//note: the "Now" in the name is just to make it different from the static function send(). If named Send, problems with DocFX etc.

		_ThrowIfSending();
		if (_a.Count == 0) return;
		if (canSendAgain) {
			if (_pstate.paren || _pstate.plus) throw new ArgumentException("canSendAgain cannot be true if keys_ ends with + or (");
		}

		//print.it("-- _parsing.mod --");
		//print.it(_parsing.mod);

		_AddModUp(); //add mod-up events if need, eg Ctrl-up after "Ctrl+A"

		//print.it("-- _a --");
		//print.it(_a);

		//perf.first();
		int sleepFinally = 0;
		var bi = new inputBlocker() { ResendBlockedKeys = true };
		try {
			_sending = true;
			_antiCapsLock = Options.NoCapsOff || !isCapsLock ? false : null;
			//print.it("{");
			if (!Options.NoBlockInput) bi.Start(BIEvents.Keys);
			if (!Options.NoModOff) Internal_.ReleaseModAndDisableModMenu();
			//perf.next();
			for (int i = 0; i < _a.Count; i++) {
				var k = _a[i];
				switch (k.Type) {
				case _KType.Sleep:
					if (i == _a.Count - 1) sleepFinally = k.sleep;
					else Internal_.Sleep(k.sleep);
					break;
				case _KType.Repeat:
					Debug.Assert(i > 0 && _a[i - 1].IsKeyOrChar);
					break;
				case _KType.Callback:
					(_GetData(k.data) as Action)();
					break;
				case _KType.Char:
					_SendChar(k, i);
					break;
				case _KType.Text:
					_SendText(k);
					break;
				default:
					_SendKey(k, i);
					break;
				}
			}
			//perf.next();
			sleepFinally += GetOptionsAndWndFocused_(getWndAlways: false).optk.SleepFinally;
		}
		finally {
			if (_antiCapsLock == true && !isCapsLock) Internal_.SendKey(KKey.CapsLock);
			_antiCapsLock = null;
			_sending = false;
			bi.Dispose();
			//perf.nw();
			//print.it("}");

			//if canSendAgain, can be used like: AddX(); for(...) Send();
			//else can be used like: AddX(); Send(); AddX(); Send();
			if (!canSendAgain) {
				_a.Clear();
				_data = null;
				_sstate.Clear();
				//and don't clear _pstate
			}
		}

		if (sleepFinally > 0) Internal_.Sleep(sleepFinally);

		//_SyncWait();
		//CONSIDER: instead of SleepFinally use TimeSyncFinally, default 100 ms. Eg send a sync key and wait max TimeSyncFinally ms.
		//	Don't sync after each (or some) sent key. Usually it does not make sense. The final sync/sleep is useful if next statement is not an input function.
		//Sync problems:
		//	Tried many ways, nothing is good enough. The test code now is in the "Unused" project.
		//	The best would be non-LL keyboard hook that sets event when receives our sent special key-up. Especially when combined with 'get thread CPU usage' while waiting for the event. However these hooks don't work eg in Store apps.
		//Better add a Sync function (keys.sync) or/and special key name, let users do it explicitly where need.
	}

#if !DEBUG
	/// <summary>
	/// Deprecated. Use <see cref="SendNow"/>.
	/// </summary>
	[EditorBrowsable(EditorBrowsableState.Never)]
	public void Send(bool canSendAgain = false) => SendNow(canSendAgain);
#endif

	unsafe void _SendKey(_KEvent k, int i) {
		bool needScanCode = k.scan == 0 && !k.SIFlags.HasAny(_KFlags.Scancode | _KFlags.Unicode);
		var (optk, wFocus) = GetOptionsAndWndFocused_(getWndAlways: needScanCode);
		if (needScanCode) {
			var hkl = Api.GetKeyboardLayout(wFocus.ThreadId); //most layouts have the same standard scancodes, but eg dvorak different
			k.scan = Internal_.VkToSc(k.vk, hkl);
		}

		if (_antiCapsLock == null
			&& !k.SIFlags.Has(_KFlags.Unicode)
			&& k.vk is (>= KKey.A and <= KKey.Z) or (>= KKey.D0 and <= KKey.D9) or (>= KKey.OemSemicolon and <= KKey.OemTilde) or (>= KKey.OemOpenBrackets and <= KKey.OemQuotes)
			//CONSIDER: not if with a modifier
			) _AntiCapsLock();

		bool isLast = i == _a.Count - 1;
		_SendKey2(k, isLast ? default : _a[i + 1], isLast, optk);
	}

	//Caller should set k.scan; this func doesn't.
	unsafe static void _SendKey2(_KEvent k, _KEvent kNext, bool isLast, OKey optk) {
		var ki = new Api.INPUTK(k.vk, k.scan, (uint)k.SIFlags);

		int count = 1, sleep = optk.KeySpeed;
		if (isLast) {
			if (!k.IsPair) sleep = Internal_.LimitSleepTime(sleep) - optk.SleepFinally;
		} else {
			if (kNext.IsRepeat) count = kNext.repeat;
			else if (!k.IsPair) {
				//If this is pair, sleep between down and up, and don't sleep after up.
				//Else if repeat, sleep always.
				//Else in most cases don't need to sleep. In some cases need, but can limit the time.
				//	For example, in Ctrl+C normally would not need to sleep after Ctrl down and Ctrl up.
				//	However some apps/controls then may not work. Maybe they process mod and nonmod keys somehow async.
				//	For example, Ctrl+C in IE address bar often does not work if there is no sleep after Ctrl down. Always works if 1 ms.

				sleep = Internal_.LimitSleepTime(sleep);
				if (kNext.IsKey) {
					bool thisMod = KeyTypes_.IsMod(k.vk), nextMod = KeyTypes_.IsMod(kNext.vk);
					if (!k.IsUp) {
						if (kNext.IsUp) sleep = optk.KeySpeed;
						else if (thisMod == nextMod) sleep = 0;
					} else {
						if (!thisMod || nextMod) sleep = 0;
					}
				} else if (kNext.IsSleep) sleep -= kNext.sleep;
			}
		}
		if (sleep < 0) sleep = 0;

		//var s = (k.vk).ToString();
		//if (k.IsPair) print.it($"{s}<{sleep}>");
		//else { var ud = k.IsUp ? '-' : '+'; if (sleep > 0) print.it($"{s}{ud} {sleep}"); else print.it($"{s}{ud}"); }

		for (int r = 0; r < count; r++) {
			//perf.first();
			Api.SendInput(&ki);
			//perf.next();
			if (sleep > 0) {
				Internal_.Sleep(sleep);
			}
			if (k.IsPair) {
				ki.dwFlags |= Api.KEYEVENTF_KEYUP;
				Api.SendInput(&ki);
				ki.dwFlags &= ~Api.KEYEVENTF_KEYUP;
			}
			//perf.nw();
			//speed: min 400 mcs for each event. Often > 1000. Does not depend on whether all events sent by single SendInput call.
		}
	}

	unsafe void _SendChar(_KEvent ke, int i) {
		var (optk, wFocus) = GetOptionsAndWndFocused_(getWndAlways: true, requireFocus: true);
		nint hkl = Api.GetKeyboardLayout(wFocus.ThreadId);
		if (_antiCapsLock == null) _AntiCapsLock();
		int count = 1; if (i < _a.Count - 1 && _a[i + 1].IsRepeat) count = _a[i + 1].repeat;
		int speed = optk.KeySpeed; if (count > 4) speed = Math.Min(speed, optk.TextSpeed + 2);
		KMod prevMod = 0;
		try {
			_SendChar2((char)ke.ch, OKeyText.KeysOrChar, speed, count, hkl, ref prevMod, false); //note: don't use optk.TextShiftEnter
		}
		finally {
			Internal_.ModPressRelease(false, prevMod);
		}
	}

	static unsafe void _SendChar2(char c, OKeyText textHow, int sleep, int count, nint hkl, ref KMod prevMod, bool shiftEnter) {
		KKey vk = 0; KMod mod = 0;
		if (c is '\n' or '\r') { //many apps don't support these as VK_PACKET
			vk = KKey.Enter;
			if (shiftEnter) mod = KMod.Shift;
		} else if (c is ' ' or '\t') { //some apps don't support these as VK_PACKET
			vk = (KKey)c;
		} else if (textHow != OKeyText.Characters) {
			(vk, mod) = _CharToKey(c, hkl);
			//print.it(c, vk, mod, (ushort)km);
		}

		if (vk == 0) { //use vk_packet
			if (prevMod != 0) { Internal_.ModPressRelease(false, prevMod); prevMod = 0; }

			//note: need key-up event for VK_PACKET too.
			//	Known controls that need it: Qt edit controls; Office 2003 'type question' field.
		} else if (mod != prevMod) {
			var md = mod ^ prevMod;
			if (0 != (md & KMod.Ctrl)) Internal_.SendCtrl(0 != (mod & KMod.Ctrl));
			if (0 != (md & KMod.Alt)) Internal_.SendAlt(0 != (mod & KMod.Alt));
			if (0 != (md & KMod.Shift)) Internal_.SendShift(0 != (mod & KMod.Shift));
			prevMod = mod;
			if (sleep > 0) Internal_.Sleep(Internal_.LimitSleepTime(sleep)); //need for apps that process mod-nonmod keys async
		}

		var ki = new _INPUTKEY2(vk, vk == 0 ? c : Internal_.VkToSc(vk, hkl), vk == 0 ? Api.KEYEVENTF_UNICODE : 0);
		for (int r = 0; r < count; r++) {
			Api.SendInput(&ki.k0, sleep > 0 ? 1 : 2);
			if (sleep > 0) {
				Internal_.Sleep(sleep);
				Api.SendInput(&ki.k1, 1);
			}
		}
		//rejected: try to synchronize somehow. To work better with slow and badly synchronized apps.
		//1. SendTimeout(WM_NULL). Although makes slower, usually does not make sync.
		//2. Sleep if the process uses CPU eg >50% of time. Tooo slow, even with Notepad. Tried GetProcessTimes and QueryProcessCycleTime (precise).
		//Eg UWP input processing is so slow and chaotic, impossible to sync.
		//rejected: option to sleep 1 ms every n-th char (eg use float 0...1 or negative value). Nothing good.
	}

	static (KKey vk, KMod mod) _CharToKey(char c, nint hkl) {
		short km = Api.VkKeyScanEx(c, hkl); //note: call for non-ASCII char too; depending on keyboard layout it can succeed
		if (0 != (km & 0xf800)) return default; //-1 if failed, mod flag 8 Hankaku key, 16/32 reserved for driver
		return ((KKey)(km & 0xff), (KMod)(km >> 8));
	}

	unsafe void _SendText(_KEvent ke) {
		var (optk, wFocus) = GetOptionsAndWndFocused_(getWndAlways: true, requireFocus: true);
		object data = _GetData(ke.data); //string or clipboardData
		string s = data as string;

		OKeyText textHow; int flags = (byte)ke.vk;
		bool textHowSpecified = 0 != (flags & 0x80); //"^text" or AddText(string, OKeyText)
		if (textHowSpecified) textHow = (OKeyText)(flags & 0xf);
		else if (s != null && s.Length < optk.PasteLength) textHow = optk.TextHow;
		else textHow = OKeyText.Paste;

		if (textHow != OKeyText.Paste) {
			//use paste if there are Unicode surrogate pairs, because some apps/controls/frameworks don't support surrogates with WM_PACKET.
			//known apps that support: standard Edit and RichEdit controls, Chrome, Firefox, IE, WPF, WinForms, new Scintilla, Dreamweaver, LibreOffice.
			//known apps that don't: Office 2003, OpenOffice, old Scintilla.
			//known apps that don't if 0 sleep: QT edit controls in VirtualBox.
			//known apps that don't support these chars even when pasting: Java (tested the old and new frameworks).
			//tested: the same if SendInput(arrayOfAllChars).
			for (int i = 0; i < s.Length; i++) if ((s[i] & 0xf800) == 0xd800) { textHow = OKeyText.Paste; break; }
		}

		nint hkl = 0;
		if (textHow is OKeyText.KeysOrChar or OKeyText.KeysOrPaste) {
			hkl = Api.GetKeyboardLayout(wFocus.ThreadId);
			if (textHow == OKeyText.KeysOrPaste) {
				foreach (char c in s) {
					if (c is '\r' or '\n') continue;
					if (_CharToKey(c, hkl).vk == default) { textHow = OKeyText.Paste; break; }
				}
			}
		}
		//print.it(optk.TextHow, textHow);

		if (textHow == OKeyText.Paste) {
			Pasting?.Invoke(this, new PastingEventArgs { Text = s, Options = optk, WndFocus = wFocus });
			clipboard.Paste_(data, optk, wFocus);
			return;
		}

		if (_antiCapsLock == null && textHow is OKeyText.KeysOrChar or OKeyText.KeysOrPaste) _AntiCapsLock();

		KMod prevMod = 0;
		int sleep = 0 != (flags & 0x40) ? optk.KeySpeed : optk.TextSpeed; //0x40 if ^text

		try {
			for (int i = 0; i < s.Length; i++) {
				char c = s[i];

				if (c == '\r' && s.Eq(i + 1, '\n')) continue; //\r\n -> \n -> key Enter

				_SendChar2(c, textHow, sleep, 1, hkl, ref prevMod, textHowSpecified ? false : optk.TextShiftEnter);
			}
		}
		finally {
			Internal_.ModPressRelease(false, prevMod);
		}

		//rejected: throw if changed the focused window.
		//	Possible false positives, because everything is async.
	}

	void _AntiCapsLock(/*OKey optk*/) {
		//if (/*&& !optk.NoCapsOff*/) {
		if (!isCapsLock) {
			_antiCapsLock = false;
			return;
		}
		if (isPressed(KKey.CapsLock)) Internal_.SendKey(KKey.CapsLock, false); //never mind: in this case later may not restore CapsLock because of auto-repeat
		Internal_.SendKey(KKey.CapsLock, true);
		bool ok = isPressed(KKey.CapsLock); //the send can fail because of UAC or the Windows setting
		Internal_.SendKey(KKey.CapsLock, false);
		//note: don't call isCapsLock again here. It is unreliable because GetKeyState is sync.
		//	Eg in some cases ignores the new key state until this UI thread removes all messages from queue.
		if (!ok && IsCapsLockShiftOff_()) {
			//Shift is set to turn off CapsLock in Settings > Time & Language > Language > Keyboard > Input method > Hot keys.
			WindowsHook.IgnoreLShiftCaps_(2000);
			Internal_.SendKey(KKey.Shift);
			WindowsHook.IgnoreLShiftCaps_(0);

			//note: need IgnoreLShiftCaps_, because when we send Shift, the BlockInput hook receives these events:
			//Left Shift down, not injected //!!
			//Caps Lock down, not injected
			//Caps Lock up, not injected
			//Left Shift up, injected

			//speed: often ~15 ms. Without Shift max 5 ms.
		}
		_antiCapsLock = true;
		//}

		//note: don't make _restoreCapsLock false if still isCapsLock true, because isCapsLock unreliable.
		//	If SendKey(CapsLock) did not work now, it probably will not work afterwards.

		//CONSIDER: remove this feature, or set non-default.
		//	Instead, when sending text as keys, if CapsLock, invert Shift. Eg PAD uses this.
		//	But what then should do when sending keys (not text)? Probably should ignore CapsLock.
		//	Probably safer with CapsLock off. Eg some target apps may interpret text differently when with an unexpected Shift.
	}

	/// <summary>
	/// Returns <c>true</c> if <c>Shift</c> is set to turn off <c>CapsLock</c> (system setting).
	/// </summary>
	internal static bool IsCapsLockShiftOff_() => s_isCapsLockShiftOff ??= Microsoft.Win32.Registry.GetValue(@"HKEY_CURRENT_USER\Keyboard Layout", "Attributes", 0) is int r1 && 0 != (r1 & 0x10000);
	static bool? s_isCapsLockShiftOff;

	/// <summary>
	/// Before pasting text through clipboard.
	/// </summary>
	public event EventHandler<PastingEventArgs> Pasting;
}


================================================
FILE: Au/Input/keys.more.cs
================================================
namespace Au;

partial class keys {
	/// <summary>
	/// Miscellaneous rarely used keyboard-related functions.
	/// </summary>
	public static partial class more {
		/// <summary>
		/// Converts key name to <see cref="KKey"/>.
		/// </summary>
		/// <returns>0 if unknown key name.</returns>
		/// <param name="keyName">[Key name](xref:key_names).</param>
		public static KKey parseKeyName(string keyName) {
			keyName ??= "";
			return _KeynameToKey(keyName, 0, keyName.Length);
		}
		
		/// <summary>
		/// Calls <see cref="parseKeyName"/> and throws <see cref="ArgumentException"/> if invalid key string.
		/// </summary>
		internal static KKey ParseKeyNameThrow_(string keyName) {
			var k = parseKeyName(keyName);
			if (k == 0) throw new ArgumentException("Unknown key name or error in key string.");
			return k;
		}
		
		/// <summary>
		/// Converts key name to <see cref="KKey"/>.
		/// </summary>
		/// <returns>0 if unknown key name.</returns>
		/// <param name="s">String containing [key name](xref:key_names).</param>
		/// <param name="startIndex">Key name start index in <i>s</i>.</param>
		/// <param name="length">Key name length.</param>
		/// <exception cref="ArgumentOutOfRangeException">Invalid <i>startIndex</i> or <i>length</i>.</exception>
		public static KKey parseKeyName(string s, int startIndex, int length) {
			s ??= "";
			if ((uint)startIndex > s.Length || (uint)length > s.Length - startIndex) throw new ArgumentOutOfRangeException();
			return _KeynameToKey(s, startIndex, length);
		}
		
		/// <summary>
		/// Converts keys string to <see cref="KKey"/> array.
		/// </summary>
		/// <param name="keys_">String containing one or more [key names](xref:key_names). Operators are not supported.</param>
		/// <exception cref="ArgumentException">Error in <i>keys_</i> string.</exception>
		public static KKey[] parseKeysString(string keys_) {
			var a = new List<KKey>();
			foreach (var g in _SplitKeysString(keys_ ?? "")) {
				KKey k = _KeynameToKey(keys_, g.Start, g.Length);
				if (k == 0) throw _ArgumentException_ErrorInKeysString(keys_, g.Start, g.Length);
				a.Add(k);
			}
			return a.ToArray();
		}
		
		/// <summary>
		/// Converts hotkey string like <c>"Ctrl+A"</c> to <see cref="KKey"/> and <see cref="KMod"/>.
		/// </summary>
		/// <returns><c>false</c> if the string is invalid.</returns>
		/// <remarks>
		/// For example, if <i>s</i> is <c>"Ctrl+Left"</c>, sets <c>mod = KMod.Ctrl</c>, <c>key = KKey.Left</c>.
		/// 
		/// [Key names](xref:key_names) are like with <see cref="keys.send"/>.
		/// 
		/// Must be single non-modifier key, preceded by zero or more of modifier keys <c>Ctrl</c>, <c>Shift</c>, <c>Alt</c>, <c>Win</c>, all joined with <c>+</c>.
		/// Valid hotkey examples: <c>"A"</c>, <c>"a"</c>, <c>"7"</c>, <c>"F12"</c>, <c>"."</c>, <c>"End"</c>, <c>"Ctrl+D"</c>, <c>"Ctrl+Alt+Shift+Win+Left"</c>, <c>" Ctrl + U "</c>.
		/// Invalid hotkey examples: <c>null</c>, <c>""</c>, <c>"A+B"</c>, <c>"Ctrl+A+K"</c>, <c>"A+Ctrl"</c>, <c>"Ctrl+Shift"</c>, <c>"Ctrl+"</c>, <c>"NoSuchKey"</c>, <c>"tab"</c>.
		/// </remarks>
		public static bool parseHotkeyString(string s, out KMod mod, out KKey key) {
			key = 0; mod = 0;
			if (s == null) return false;
			int i = 0;
			foreach (var g in _SplitKeysString(s)) {
				if (key != 0) return false;
				if ((i++ & 1) == 0) {
					KKey k = _KeynameToKey(s, g.Start, g.Length);
					if (k == 0) return false;
					var m = Internal_.KeyToMod(k);
					if (m != 0) {
						if ((m & mod) != 0) return false;
						mod |= m;
					} else key = k;
				} else if (g.Length != 1 || s[g.Start] != '+') return false;
			}
			return key != 0 && key != KKey.Packet;
		}
		
		/// <summary>
		/// Converts hotkey string like <c>"Ctrl+A"</c> to winforms <see cref="System.Windows.Forms.Keys"/>.
		/// </summary>
		/// <remarks>
		/// For example, if <i>s</i> is <c>"Ctrl+Left"</c>, sets <c>hotkey = Keys.Control | Keys.Left</c>.
		/// </remarks>
		/// <returns><c>false</c> if the string is invalid or contains <c>"Win"</c>.</returns>
		public static bool parseHotkeyString(string s, out System.Windows.Forms.Keys hotkey) {
			if (!parseHotkeyString(s, out var m, out var k)) { hotkey = 0; return false; }
			hotkey = KModToWinforms(m) | (System.Windows.Forms.Keys)k;
			if (m.Has(KMod.Win)) return false;
			return true;
			//return Enum.IsDefined(typeof(System.Windows.Forms.Keys), (System.Windows.Forms.Keys)k); //not too slow
			//tested: enum Keys has all KKey values + some extinct.
		}
		
		/// <summary>
		/// Converts hotkey string like <c>"Ctrl+A"</c> to WPF <see cref="System.Windows.Input.ModifierKeys"/> and <see cref="System.Windows.Input.Key"/> or <see cref="System.Windows.Input.MouseAction"/>.
		/// </summary>
		/// <remarks>
		/// For example, if <i>s</i> is <c>"Ctrl+Left"</c>, sets <c>mod = ModifierKeys.Control</c> and <c>key = Key.Left</c>.
		/// 
		/// Supported mouse button strings: <c>"Click"</c>, <c>"D-click"</c>, <c>"R-click"</c>, <c>"M-click"</c>, <c>"Wheel"</c>. Example: <c>"Ctrl+R-click"</c>. The first character of a mouse word is case-insensitive.
		/// </remarks>
		/// <returns><c>false</c> if the string is invalid or contains incorrectly specified mouse buttons.</returns>
		public static bool parseHotkeyString(string s, out System.Windows.Input.ModifierKeys mod, out System.Windows.Input.Key key, out System.Windows.Input.MouseAction mouse) {
			mod = 0; key = 0; mouse = 0;
			if (s.Ends("lick") || s.Ends("heel")) {
				int i = s.LastIndexOf('+') + 1;
				var v = s.AsSpan(i); var co = StringComparison.OrdinalIgnoreCase;
				if (v.Equals("Click", co)) mouse = System.Windows.Input.MouseAction.LeftClick;
				else if (v.Equals("D-click", co)) mouse = System.Windows.Input.MouseAction.LeftDoubleClick;
				else if (v.Equals("R-click", co)) mouse = System.Windows.Input.MouseAction.RightClick;
				else if (v.Equals("M-click", co)) mouse = System.Windows.Input.MouseAction.MiddleClick;
				else if (v.Equals("Wheel", co)) mouse = System.Windows.Input.MouseAction.WheelClick;
				if (mouse != default) {
					if (i == 0) return true;
					s = s.ReplaceAt(i.., "A"); //replace the mouse word with a key name, else can't parse
				}
			}
			if (!parseHotkeyString(s, out var m, out var k)) return false;
			mod = KModToWpf(m);
			return mouse != default || (key = KKeyToWpf(k)) != default;
			//tested: enum Key has all KKey values except mouse buttons and packet.
		}
		
		/// <summary>
		/// Parses hotkey trigger string or mouse trigger modifiers string.
		/// Like <see cref="parseHotkeyString"/>, but supports "any mod" (like <c>"Shift?+K"</c> or <c>"?+K"</c>) and <i>noKey</i>.
		/// </summary>
		/// <param name="s"></param>
		/// <param name="mod"></param>
		/// <param name="modAny"></param>
		/// <param name="key"></param>
		/// <param name="noKey">Modifiers only. If <c>true</c>, <i>s</i> must be <c>"modifiers"</c> or <c>null</c>/<c>""</c>. If <c>false</c>, <i>s</i> must be <c>"key"</c> or <c>"modifiers+key"</c>.</param>
		public static bool parseTriggerString(string s, out KMod mod, out KMod modAny, out KKey key, bool noKey) {
			key = 0; mod = 0; modAny = 0;
			if (s.NE()) return noKey;
			int i = 0; bool ignore = false;
			foreach (var g in _SplitKeysString(s)) {
				if (ignore) { ignore = false; continue; }
				if (key != 0) return false;
				if ((i++ & 1) == 0) {
					KKey k = _KeynameToKey(s, g.Start, g.Length);
					if (k == 0) return false;
					var m = Internal_.KeyToMod(k);
					if (m != 0) {
						if ((m & (mod | modAny)) != 0) return false;
						if (ignore = g.End < s.Length && s[g.End] == '?') modAny |= m; //eg "Shift?+K"
						else mod |= m;
					} else {
						if (i == 1 && g.Length == 1 && s[g.Start] == '?') modAny = (KMod)15; //eg "?+K"
						else key = k;
					}
				} else if (g.Length != 1 || s[g.Start] != '+') return false;
			}
			if (noKey) return (mod | modAny) != 0 && key == 0;
			return key != 0;
		}
		
		/// <summary>
		/// Formats hotkey string like <c>"Ctrl+Shift+K"</c>.
		/// </summary>
		/// <param name="b">Append to this <c>StringBuilder</c>.</param>
		/// <param name="mod"></param>
		/// <param name="key"></param>
		public static void hotkeyToString(StringBuilder b, KMod mod, KKey key) {
			if (mod.Has(KMod.Ctrl)) b.Append("Ctrl+");
			if (mod.Has(KMod.Alt)) b.Append("Alt+");
			if (mod.Has(KMod.Shift)) b.Append("Shift+");
			if (mod.Has(KMod.Win)) b.Append("Win+");
			b.Append(keyToString(key)).ToString();
		}
		
		/// <summary>
		/// Formats hotkey string like <c>"Ctrl+Shift+K"</c>.
		/// </summary>
		public static string hotkeyToString(KMod mod, KKey key) {
			if (mod == 0) return keyToString(key);
			using (new StringBuilder_(out var b)) {
				hotkeyToString(b, mod, key);
				return b.ToString();
			}
		}
		
		/// <summary>
		/// Gets [key name](xref:key_names) that can be used in keys strings with <see cref="keys.send"/> etc.
		/// </summary>
		public static string keyToString(KKey key) => c_keyNames[(int)key] ?? ("VK" + (int)key);
		
		static readonly string[] c_keyNames = {
	"",
	"MouseLeft",
	"MouseRight",
	"Break",
	"MouseMiddle",
	"MouseX1",
	"MouseX2",
	null,
	"Back",
	"Tab",
	null,
	null,
	"Clear",
	"Enter",
	null,
	null,
	"Shift",
	"Ctrl",
	"Alt",
	"Pause",
	"CapsLock",
	"IMEKanaMode",
	null,
	"IMEJunjaMode",
	"IMEFinalMode",
	"IMEKanjiMode",
	null,
	"Esc",
	"IMEConvert",
	"IMENonconvert",
	"IMEAccept",
	"IMEModeChange",
	"Space",
	"PgUp",
	"PgDn",
	"End",
	"Home",
	"Left",
	"Up",
	"Right",
	"Down",
	null,
	null,
	null,
	"PrtSc",
	"Ins",
	"Del",
	null,
	"0",
	"1",
	"2",
	"3",
	"4",
	"5",
	"6",
	"7",
	"8",
	"9",
	null,
	null,
	null,
	null,
	null,
	null,
	null,
	"A",
	"B",
	"C",
	"D",
	"E",
	"F",
	"G",
	"H",
	"I",
	"J",
	"K",
	"L",
	"M",
	"N",
	"O",
	"P",
	"Q",
	"R",
	"S",
	"T",
	"U",
	"V",
	"W",
	"X",
	"Y",
	"Z",
	"Win",
	"RWin",
	"Apps",
	null,
	"Sleep",
	"#0",
	"#1",
	"#2",
	"#3",
	"#4",
	"#5",
	"#6",
	"#7",
	"#8",
	"#9",
	"#*",
	"#+",
	null,
	"#-",
	"#.",
	"#/",
	"F1",
	"F2",
	"F3",
	"F4",
	"F5",
	"F6",
	"F7",
	"F8",
	"F9",
	"F10",
	"F11",
	"F12",
	"F13",
	"F14",
	"F15",
	"F16",
	"F17",
	"F18",
	"F19",
	"F20",
	"F21",
	"F22",
	"F23",
	"F24",
	null,
	null,
	null,
	null,
	null,
	null,
	null,
	null,
	"NumLock",
	"ScrollLock",
	null,
	null,
	null,
	null,
	null,
	null,
	null,
	null,
	null,
	null,
	null,
	null,
	null,
	null,
	"LShift",
	"RShift",
	"LCtrl",
	"RCtrl",
	"LAlt",
	"RAlt",
	"BrowserBack",
	"BrowserForward",
	"BrowserRefresh",
	"BrowserStop",
	"BrowserSearch",
	"BrowserFavorites",
	"BrowserHome",
	"VolumeMute",
	"VolumeDown",
	"VolumeUp",
	"MediaNextTrack",
	"MediaPrevTrack",
	"MediaStop",
	"MediaPlayPause",
	"LaunchMail",
	"LaunchMediaSelect",
	"LaunchApp1",
	"LaunchApp2",
	null,
	null,
	";",
	"=",
	",",
	"-",
	".",
	"/",
	"`",
	null,
	null,
	null,
	null,
	null,
	null,
	null,
	null,
	null,
	null,
	null,
	null,
	null,
	null,
	null,
	null,
	null,
	null,
	null,
	null,
	null,
	null,
	null,
	null,
	null,
	null,
	"[",
	"|",
	"]",
	"'",
	null,
	null,
	null,
	null,
	null,
	null,
	"IMEProcessKey",
	null,
	"Packet",
	null,
	null,
	null,
	null,
	null,
	null,
	null,
	null,
	null,
	null,
	null,
	null,
	null,
	null,
	null,
	null,
	null,
	null,
	null,
	null,
	null,
	null,
	null,
	null,
};
		//this script creates the array:
		/*
print.clear();
var b=new StringBuilder("static readonly string[] c_keyNames = {");
for (int i = 0; i < 256; i++) {
var k=(KKey)i;
var s=k switch {
	0 => "",
	>= KKey.D0 and <= KKey.D9 => ((char)k).ToString(),
	>= KKey.NumPad0 and <= KKey.NumPad9 => "#" + ((char)(k-KKey.NumPad0+'0')).ToString(),
	KKey.OemMinus => "-",
	KKey.OemPlus => "=",
	KKey.OemTilde => "`",
	KKey.OemOpenBrackets => "[",
	KKey.OemCloseBrackets => "]",
	KKey.OemPipe => "|",
	KKey.OemSemicolon => ";",
	KKey.OemQuotes => "'",
	KKey.OemComma => ",",
	KKey.OemPeriod => ".",
	KKey.OemQuestion => "/",
	KKey.Decimal => "#.",
	KKey.Add => "#+",
	KKey.Divide => "#/",
	KKey.Multiply => "#*",
	KKey.Subtract => "#-",
	KKey.Escape => "Esc",
	KKey.PageUp => "PgUp",
	KKey.PageDown => "PgDn",
	KKey.PrintScreen => "PrtSc",
	KKey.Insert => "Ins",
	KKey.Delete => "Del",
	_ => Enum.IsDefined<KKey>(k) ? k.ToString() : null
};
//	print.it(k, s);
b.Append("\r\n\t");
if(s==null) b.Append("null"); else b.Append('"').Append(s).Append('"');
b.Append(',');
}
b.Append("\r\n};");
print.it(b.ToString());
		*/
		
		/// <summary>
		/// Converts modifier key flags from <c>KMod</c> to winforms <c>Keys</c>.
		/// </summary>
		/// <remarks>
		/// For <c>Win</c> returns flag <c>(Keys)0x80000</c>.
		/// </remarks>
		public static System.Windows.Forms.Keys KModToWinforms(KMod mod) => (System.Windows.Forms.Keys)((int)mod << 16);
		
		/// <summary>
		/// Converts modifier key flags from winforms <c>Keys</c> to <c>KMod</c>.
		/// </summary>
		/// <remarks>
		/// For <c>Win</c> can be used flag <c>(Keys)0x80000</c>.
		/// </remarks>
		public static KMod KModFromWinforms(System.Windows.Forms.Keys mod) => (KMod)((int)mod >> 16);
		
		/// <summary>
		/// Converts modifier key flags from <c>KMod</c> to WPF <c>ModifierKeys</c>.
		/// </summary>
		public static System.Windows.Input.ModifierKeys KModToWpf(KMod mod) => (System.Windows.Input.ModifierKeys)_SwapMod((int)mod);
		
		/// <summary>
		/// Converts modifier key flags from WPF <c>ModifierKeys</c> to <c>KMod</c>.
		/// </summary>
		public static KMod KModFromWpf(System.Windows.Input.ModifierKeys mod) => (KMod)_SwapMod((int)mod);
		
		static int _SwapMod(int m) => (m & 0b1010) | (m << 2 & 4) | (m >> 2 & 1);
		
		/// <summary>
		/// Converts key from <c>KKey</c> to WPF <c>Key</c>.
		/// </summary>
		public static System.Windows.Input.Key KKeyToWpf(KKey k) => System.Windows.Input.KeyInterop.KeyFromVirtualKey((int)k);
		
		/// <summary>
		/// Converts key from WPF <c>Key</c> to <c>KKey</c>.
		/// </summary>
		public static KKey KKeyFromWpf(System.Windows.Input.Key k) => (KKey)System.Windows.Input.KeyInterop.VirtualKeyFromKey(k);
		
		/// <summary>
		/// Sends single key.
		/// </summary>
		/// <param name="k">Virtual-key code.</param>
		/// <param name="down"><c>true</c> down, <c>false</c> up, <c>null</c> down and up.</param>
		/// <param name="hkl">
		/// Keyboard layout handle for scan code. See API <ms>GetKeyboardLayout</ms>.
		/// If 0 (default), uses keyboard layout of this thread; don't use 0 for keys whose scancode depends on keyboard layout.
		/// If -1, uses keyboard layout of the focused or active window.
		/// </param>
		/// <param name="extra">An "extra info" value that can be used for example by keyboard hooks to recognize the key sender. If <c>null</c> (default), uses the same value as other functions of this library.</param>
		/// <param name="dontThrow">Don't throw exception.</param>
		/// <remarks>
		/// This is a low-level function. Does nothing more (sleep, block input, etc). Does not use <see cref="opt"/> options. Just gets missing info (scan code etc) and calls API <ms>SendInput</ms>.
		/// </remarks>
		/// <exception cref="InputDesktopException"></exception>
		public static void sendKey(KKey k, bool? down = null, nint hkl = 0, int? extra = null, bool dontThrow = false)
			=> Internal_.SendKey(k, down, hkl, extra, dontThrow);
		
		//FUTURE: RemapKeyboardKeys. See QM2.
		
	}
}


================================================
FILE: Au/Input/keys_static.cs
================================================
namespace Au;

public partial class keys {
	#region get key state

	/// <summary>
	/// Gets key states for using in UI code (winforms, WPF, etc).
	/// </summary>
	/// <remarks>
	/// Use functions of this class in user interface code (winforms, WPF, etc). In other code (automation scripts, etc) usually it's better to use functions of <see cref="keys"/> class.
	/// 
	/// In Windows there are two API to get key state - <ms>GetKeyState</ms> and <ms>GetAsyncKeyState</ms>.
	/// 
	/// API <ms>GetAsyncKeyState</ms> is used by class <see cref="keys"/> and not by this class (<c>keys.gui</c>). When physical key state changes (pressed/released), <c>GetAsyncKeyState</c> sees the change immediately. It is good in automation scripts, but not good in UI code because the state is not synchronized with the message queue.
	/// 
	/// This class (<c>keys.gui</c>) uses API <ms>GetKeyState</ms>. In the foreground thread (of the active window), it sees key state changes not immediately but after the thread reads key messages from its queue. It is good in UI threads. In background threads this API usually works like <c>GetAsyncKeyState</c>, but it depends on API <ms>AttachThreadInput</ms> and in some cases is less reliable, for example may be unaware of keys pressed before the thread started.
	/// 
	/// The key state returned by these API is not always the same as of the physical keyboard. There is no API to get real physical state. Some cases when it is different:
	/// 1. The key is pressed or released by software, such as the <see cref="send"/> function of this library.
	/// 2. The key is blocked by a low-level hook. For example, hotkey triggers of this library use hooks.
	/// 3. The foreground window belongs to a process with higher UAC integrity level.
	/// 
	/// Also there is API <ms>GetKeyboardState</ms>. It gets states of all keys in single call. Works like <ms>GetKeyState</ms>.
	/// </remarks>
	public static class gui {
		//rejected: instead of class keys.gui add property keys.isUIThread. If true, let its functions work like now keys.gui.

		/// <summary>
		/// Calls API <ms>GetKeyState</ms> and returns its return value.
		/// </summary>
		/// <remarks>
		/// If returns &lt; 0, the key is pressed. If the low-order bit is 1, the key is toggled; it works only with <c>CapsLock</c>, <c>NumLock</c>, <c>ScrollLock</c> and several other keys, as well as mouse buttons.
		/// Can be used for mouse buttons too, for example <c>keys.gui.getKeyState(KKey.MouseLeft)</c>. When mouse left and right buttons are swapped, gets logical state, not physical.
		/// </remarks>
		public static short getKeyState(KKey key) => Api.GetKeyState((int)key);

		/// <summary>
		/// Returns <c>true</c> if the specified key or mouse button is pressed.
		/// </summary>
		/// <remarks>
		/// Can be used for mouse buttons too. Example: <c>keys.gui.isPressed(KKey.MouseLeft)</c>. When mouse left and right buttons are swapped, gets logical state, not physical.
		/// </remarks>
		public static bool isPressed(KKey key) => getKeyState(key) < 0;

		/// <summary>
		/// Returns <c>true</c> if the specified key or mouse button is toggled.
		/// </summary>
		/// <remarks>
		/// Works only with <c>CapsLock</c>, <c>NumLock</c>, <c>ScrollLock</c> and several other keys, as well as mouse buttons.
		/// </remarks>
		public static bool isToggled(KKey key) => 0 != (getKeyState(key) & 1);

		/// <summary>
		/// Returns <c>true</c> if the <c>Alt</c> key is pressed.
		/// </summary>
		public static bool isAlt => isPressed(KKey.Alt);

		/// <summary>
		/// Returns <c>true</c> if the <c>Ctrl</c> key is pressed.
		/// </summary>
		public static bool isCtrl => isPressed(KKey.Ctrl);

		/// <summary>
		/// Returns <c>true</c> if the <c>Shift</c> key is pressed.
		/// </summary>
		public static bool isShift => isPressed(KKey.Shift);

		/// <summary>
		/// Returns <c>true</c> if the <c>Win</c> key is pressed.
		/// </summary>
		public static bool isWin => isPressed(KKey.Win) || isPressed(KKey.RWin);

		/// <summary>
		/// Returns <c>true</c> if some modifier keys are pressed.
		/// </summary>
		/// <param name="mod">Return <c>true</c> if some of these keys are pressed. Default: <c>Ctrl</c>, <c>Shift</c> or <c>Alt</c>.</param>
		/// <remarks>
		/// By default does not check the <c>Win</c> key, as it is not used in UI, but you can include it in <i>mod</i> if need.
		/// </remarks>
		public static bool isMod(KMod mod = KMod.Ctrl | KMod.Shift | KMod.Alt) {
			if (0 != (mod & KMod.Ctrl) && isCtrl) return true;
			if (0 != (mod & KMod.Shift) && isShift) return true;
			if (0 != (mod & KMod.Alt) && isAlt) return true;
			if (0 != (mod & KMod.Win) && isWin) return true;
			return false;
		}

		/// <summary>
		/// Gets flags indicating which modifier keys are pressed.
		/// </summary>
		/// <param name="mod">Check only these keys. Default: <c>Ctrl</c>, <c>Shift</c>, <c>Alt</c>.</param>
		/// <remarks>
		/// By default does not check the <c>Win</c> key, as it is not used in UI, but you can include it in <i>mod</i> if need.
		/// </remarks>
		public static KMod getMod(KMod mod = KMod.Ctrl | KMod.Shift | KMod.Alt) {
			KMod R = 0;
			if (0 != (mod & KMod.Ctrl) && isCtrl) R |= KMod.Ctrl;
			if (0 != (mod & KMod.Shift) && isShift) R |= KMod.Shift;
			if (0 != (mod & KMod.Alt) && isAlt) R |= KMod.Alt;
			if (0 != (mod & KMod.Win) && isWin) R |= KMod.Win;
			return R;
		}

		/// <summary>
		/// Returns <c>true</c> if the <c>CapsLock</c> key is toggled.
		/// </summary>
		/// <remarks>
		/// The same as <see cref="keys.isCapsLock"/>.
		/// </remarks>
		public static bool isCapsLock => isToggled(KKey.CapsLock);

		/// <summary>
		/// Returns <c>true</c> if the <c>NumLock</c> key is toggled.
		/// </summary>
		/// <remarks>
		/// The same as <see cref="keys.isNumLock"/>.
		/// </remarks>
		public static bool isNumLock => isToggled(KKey.NumLock);

		/// <summary>
		/// Returns <c>true</c> if the <c>ScrollLock</c> key is toggled.
		/// </summary>
		/// <remarks>
		/// The same as <see cref="keys.isScrollLock"/>.
		/// </remarks>
		public static bool isScrollLock => isToggled(KKey.ScrollLock);
	}

	/// <summary>
	/// Returns <c>true</c> if the specified key or mouse button is pressed.
	/// In UI code use <see cref="keys.gui"/> instead.
	/// </summary>
	/// <remarks>
	/// Uses API <ms>GetAsyncKeyState</ms>.
	/// </remarks>
	public static bool isPressed(KKey key) {
		if ((key == KKey.MouseLeft || key == KKey.MouseRight) && 0 != Api.GetSystemMetrics(Api.SM_SWAPBUTTON)) key = (KKey)((int)key ^ 3); //makes this func 3 times slower, eg 2 -> 6 mcs when cold CPU. But much faster when called next time without a delay; for example mouse.isPressed(Left|Right) is not slower than mouse.isPressed(Left), although calls this func 2 times.
		return Api.GetAsyncKeyState((int)key) < 0;
	}

	/// <summary>
	/// Returns <c>true</c> if the <c>Alt</c> key is pressed. Calls <see cref="isPressed"/>.
	/// In UI code use <see cref="keys.gui"/> instead.
	/// </summary>
	public static bool isAlt => isPressed(KKey.Alt);

	/// <summary>
	/// Returns <c>true</c> if the <c>Ctrl</c> key is pressed. Calls <see cref="isPressed"/>.
	/// In UI code use <see cref="keys.gui"/> instead.
	/// </summary>
	public static bool isCtrl => isPressed(KKey.Ctrl);

	/// <summary>
	/// Returns <c>true</c> if the <c>Shift</c> key is pressed. Calls <see cref="isPressed"/>.
	/// In UI code use <see cref="keys.gui"/> instead.
	/// </summary>
	public static bool isShift => isPressed(KKey.Shift);

	/// <summary>
	/// Returns <c>true</c> if the <c>Win</c> key is pressed. Calls <see cref="isPressed"/>.
	/// In UI code use <see cref="keys.gui"/> instead.
	/// </summary>
	public static bool isWin => isPressed(KKey.Win) || isPressed(KKey.RWin);

	/// <summary>
	/// Returns <c>true</c> if some modifier keys are pressed: <c>Ctrl</c>, <c>Shift</c>, <c>Alt</c>, <c>Win</c>. Calls <see cref="isPressed"/>.
	/// In UI code use <see cref="keys.gui"/> instead.
	/// </summary>
	/// <param name="mod">Return <c>true</c> if some of these keys are pressed. Default - any.</param>
	/// <seealso cref="waitForNoModifierKeys"/>
	public static bool isMod(KMod mod = KMod.Ctrl | KMod.Shift | KMod.Alt | KMod.Win) {
		if (0 != (mod & KMod.Ctrl) && isCtrl) return true;
		if (0 != (mod & KMod.Shift) && isShift) return true;
		if (0 != (mod & KMod.Alt) && isAlt) return true;
		if (0 != (mod & KMod.Win) && isWin) return true;
		return false;
	}

	/// <summary>
	/// Gets flags indicating which modifier keys are pressed: <c>Ctrl</c>, <c>Shift</c>, <c>Alt</c>, <c>Win</c>. Calls <see cref="isPressed"/>.
	/// In UI code use <see cref="keys.gui"/> instead.
	/// </summary>
	/// <param name="mod">Check only these keys. Default - all four.</param>
	public static KMod getMod(KMod mod = KMod.Ctrl | KMod.Shift | KMod.Alt | KMod.Win) {
		KMod R = 0;
		if (0 != (mod & KMod.Ctrl) && isCtrl) R |= KMod.Ctrl;
		if (0 != (mod & KMod.Shift) && isShift) R |= KMod.Shift;
		if (0 != (mod & KMod.Alt) && isAlt) R |= KMod.Alt;
		if (0 != (mod & KMod.Win) && isWin) R |= KMod.Win;
		return R;
	}

	/// <summary>
	/// Returns <c>true</c> if the <c>CapsLock</c> key is toggled.
	/// </summary>
	public static bool isCapsLock => gui.isCapsLock;

	/// <summary>
	/// Returns <c>true</c> if the <c>NumLock</c> key is toggled.
	/// </summary>
	public static bool isNumLock => gui.isNumLock;

	/// <summary>
	/// Returns <c>true</c> if the <c>ScrollLock</c> key is toggled.
	/// </summary>
	public static bool isScrollLock => gui.isScrollLock;

	#endregion

	#region wait

	/// <summary>
	/// Waits while some modifier keys (<c>Ctrl</c>, <c>Shift</c>, <c>Alt</c>, <c>Win</c>) are pressed. See <see cref="isMod"/>.
	/// </summary>
	/// <param name="timeout">Timeout, seconds. Can be 0 (infinite), >0 (exception) or &lt;0 (no exception). More info: [](xref:wait_timeout).</param>
	/// <param name="mod">Check only these keys. Default: all.</param>
	/// <returns>Returns <c>true</c>. On timeout returns <c>false</c> if <i>timeout</i> is negative; else exception.</returns>
	/// <exception cref="TimeoutException"><i>timeout</i> time has expired (if > 0).</exception>
	public static bool waitForNoModifierKeys(Seconds timeout = default, KMod mod = KMod.Ctrl | KMod.Shift | KMod.Alt | KMod.Win) {
		return waitForNoModifierKeysAndMouseButtons(timeout, mod, 0);
	}

	/// <summary>
	/// Waits while some modifier keys (<c>Ctrl</c>, <c>Shift</c>, <c>Alt</c>, <c>Win</c>) or mouse buttons are pressed.
	/// </summary>
	/// <param name="timeout">Timeout, seconds. Can be 0 (infinite), >0 (exception) or &lt;0 (no exception). More info: [](xref:wait_timeout). Default 0.</param>
	/// <param name="mod">Check only these keys. Default: all.</param>
	/// <param name="buttons">Check only these buttons. Default: all.</param>
	/// <returns>Returns <c>true</c>. On timeout returns <c>false</c> if <i>timeout</i> is negative; else exception.</returns>
	/// <exception cref="TimeoutException"><i>timeout</i> time has expired (if > 0).</exception>
	/// <seealso cref="isMod"/>
	/// <seealso cref="mouse.isPressed"/>
	/// <seealso cref="mouse.waitForNoButtonsPressed"/>
	public static bool waitForNoModifierKeysAndMouseButtons(Seconds timeout = default, KMod mod = KMod.Ctrl | KMod.Shift | KMod.Alt | KMod.Win, MButtons buttons = MButtons.Left | MButtons.Right | MButtons.Middle | MButtons.X1 | MButtons.X2) {
		var loop = new WaitLoop(timeout);
		for (; ; ) {
			if (!isMod(mod) && !mouse.isPressed(buttons)) return true;
			if (!loop.Sleep()) return false;
		}
	}

	/// <summary>
	/// Waits while the specified keys or/and mouse buttons are pressed.
	/// </summary>
	/// <param name="timeout">Timeout, seconds. Can be 0 (infinite), >0 (exception) or &lt;0 (no exception). More info: [](xref:wait_timeout).</param>
	/// <param name="keys_">One or more keys or/and mouse buttons. Waits until all are released.</param>
	/// <returns>Returns <c>true</c>. On timeout returns <c>false</c> if <i>timeout</i> is negative; else exception.</returns>
	/// <exception cref="TimeoutException"><i>timeout</i> time has expired (if > 0).</exception>
	public static bool waitForReleased(Seconds timeout, params KKey[] keys_) {
		return wait.until(timeout, () => {
			foreach (var k in keys_) if (isPressed(k)) return false;
			return true;
		});
	}

	/// <summary>
	/// Waits while the specified keys are pressed.
	/// </summary>
	/// <param name="timeout">Timeout, seconds. Can be 0 (infinite), >0 (exception) or &lt;0 (no exception). More info: [](xref:wait_timeout).</param>
	/// <param name="keys_">One or more [keys](xref:key_names) without operators. Waits until all are released.</param>
	/// <returns>Returns <c>true</c>. On timeout returns <c>false</c> if <i>timeout</i> is negative; else exception.</returns>
	/// <exception cref="ArgumentException">Error in <i>keys_</i> string.</exception>
	/// <exception cref="TimeoutException"><i>timeout</i> time has expired (if > 0).</exception>
	public static bool waitForReleased(Seconds timeout, string keys_) {
		return waitForReleased(timeout, more.parseKeysString(keys_));
	}

	/// <summary>
	/// Waits for key-down or key-up event of the specified key.
	/// </summary>
	/// <returns>Returns <c>true</c>. On timeout returns <c>false</c> if <i>timeout</i> is negative; else exception.</returns>
	/// <param name="timeout">Timeout, seconds. Can be 0 (infinite), >0 (exception) or &lt;0 (no exception). More info: [](xref:wait_timeout).</param>
	/// <param name="key">Wait for this key.</param>
	/// <param name="up">Wait for key-up event.</param>
	/// <param name="block">Make the event invisible to other apps. If <i>up</i> is <c>true</c>, makes the down event invisible too, if it comes while waiting for the up event.</param>
	/// <exception cref="ArgumentException"><i>key</i> is 0.</exception>
	/// <exception cref="TimeoutException"><i>timeout</i> time has expired (if > 0).</exception>
	/// <remarks>
	/// Waits for key event, not for key state.
	/// Uses low-level keyboard hook. Can wait for any single key. See also <see cref="waitForHotkey"/>.
	/// Ignores key events injected by functions of this library.
	/// </remarks>
	/// <example>
	/// <code><![CDATA[
	/// keys.waitForKey(0, KKey.Ctrl, up: false, block: true);
	/// print.it("Ctrl");
	/// ]]></code>
	/// </example>
	public static bool waitForKey(Seconds timeout, KKey key, bool up = false, bool block = false) {
		if (key == 0) throw new ArgumentException();
		return 0 != _WaitForKey(timeout, key, up, block);
	}

	/// <param name="key">Wait for this key. A single-key string. See [key names](xref:key_names).</param>
	/// <exception cref="ArgumentException">Invalid <i>key</i> string.</exception>
	/// <example>
	/// <code><![CDATA[
	/// keys.waitForKey(0, "Ctrl", up: false, block: true);
	/// print.it("Ctrl");
	/// ]]></code>
	/// </example>
	/// <inheritdoc cref="waitForKey(Seconds, KKey, bool, bool)"/>
	public static bool waitForKey(Seconds timeout, string key, bool up = false, bool block = false) {
		return 0 != _WaitForKey(timeout, more.ParseKeyNameThrow_(key), up, block);
	}

	/// <summary>
	/// Waits for key-down or key-up event of any key, and gets the key code.
	/// </summary>
	/// <returns>
	/// Returns the key code. On timeout returns 0 if <i>timeout</i> is negative; else exception.
	/// For modifier keys returns the left or right key code, for example <c>LCtrl</c>/<c>RCtrl</c>, not <c>Ctrl</c>.
	/// </returns>
	/// <exception cref="TimeoutException"><i>timeout</i> time has expired (if > 0).</exception>
	/// <example>
	/// <code><![CDATA[
	/// var key = keys.waitForKey(0, up: true, block: true);
	/// print.it(key);
	/// ]]></code>
	/// </example>
	/// <inheritdoc cref="waitForKey(Seconds, KKey, bool, bool)" path="/param"/>
	public static KKey waitForKey(Seconds timeout, bool up = false, bool block = false) {
		return _WaitForKey(timeout, 0, up, block);
	}

	static KKey _WaitForKey(Seconds timeout, KKey key, bool up, bool block) {
		//TODO3: if up and block: don't block if was down when starting to wait. Also in the Mouse func.

		KKey R = 0;
		using (WindowsHook.Keyboard(x => {
			if (key != 0 && !x.IsKey(key)) return;
			if (x.IsUp != up) {
				if (up && block) { //key down when waiting for up. If block, now block down too.
					if (key == 0) key = x.vkCode;
					x.BlockEvent();
				}
				return;
			}
			R = x.vkCode; //info: for mod keys returns left/right
			if (block) x.BlockEvent();
		})) wait.doEventsUntil(timeout, () => R != 0);

		return R;
	}

	/// <summary>
	/// Waits for keyboard events using callback function.
	/// </summary>
	/// <returns>
	/// Returns the key code. On timeout returns 0 if <i>timeout</i> is negative; else exception.
	/// For modifier keys returns the left or right key code, for example <c>LCtrl</c>/<c>RCtrl</c>, not <c>Ctrl</c>.
	/// </returns>
	/// <param name="timeout">Timeout, seconds. Can be 0 (infinite), >0 (exception) or &lt;0 (no exception). More info: [](xref:wait_timeout).</param>
	/// <param name="f">Callback function that receives key down and up events. Let it return <c>true</c> to stop waiting.</param>
	/// <param name="block">Make the key down event invisible to other apps (when the callback function returns <c>true</c>).</param>
	/// <remarks>
	/// Waits for key event, not for key state.
	/// Uses low-level keyboard hook.
	/// Ignores key events injected by functions of this library.
	/// </remarks>
	/// <example>
	/// Wait for <c>F3</c> or <c>Esc</c>.
	/// <code><![CDATA[
	/// var k = keys.waitForKeys(0, k => !k.IsUp && k.Key is KKey.F3 or KKey.Escape, block: true);
	/// print.it(k);
	/// ]]></code>
	/// </example>
	public static KKey waitForKeys(Seconds timeout, Func<HookData.Keyboard, bool> f, bool block = false) {
		KKey R = 0;
		using (WindowsHook.Keyboard(x => {
			if (!f(x)) return;
			R = x.vkCode; //info: for mod keys returns left/right
			if (block && !x.IsUp) x.BlockEvent();
		})) wait.doEventsUntil(timeout, () => R != 0);

		return R;
	}
	//CONSIDER: Same for mouse.

	/// <summary>
	/// Registers a temporary hotkey and waits for it.
	/// </summary>
	/// <param name="timeout">Timeout, seconds. Can be 0 (infinite), >0 (exception) or &lt;0 (no exception). More info: [](xref:wait_timeout).</param>
	/// <param name="hotkey">Hotkey. Can be: string like <c>"Ctrl+Shift+Alt+Win+K"</c>, tuple <c>(KMod, KKey)</c>, enum <see cref="KKey"/>, enum <c>Keys</c>, struct <see cref="KHotkey"/>.</param>
	/// <param name="waitModReleased">Also wait until hotkey modifier keys released.</param>
	/// <returns>Returns <c>true</c>. On timeout returns <c>false</c> if <i>timeout</i> is negative; else exception.</returns>
	/// <exception cref="ArgumentException">Error in hotkey string.</exception>
	/// <exception cref="AuException">Failed to register hotkey.</exception>
	/// <exception cref="TimeoutException"><i>timeout</i> time has expired (if > 0).</exception>
	/// <remarks>
	/// Uses <see cref="RegisteredHotkey"/> (API <ms>RegisterHotKey</ms>).
	/// Fails if the hotkey is currently registered by this or another application or used by Windows.
	/// <note>Most single-key and <c>Shift+key</c> hotkeys don't work when the active window has higher UAC integrity level than this process. Media keys may work.</note>
	/// </remarks>
	/// <example>
	/// <code><![CDATA[
	/// keys.waitForHotkey(0, "F11");
	/// keys.waitForHotkey(0, KKey.F11);
	/// keys.waitForHotkey(0, "Shift+A", true);
	/// keys.waitForHotkey(0, (KMod.Ctrl | KMod.Shift, KKey.P)); //Ctrl+Shift+P
	/// keys.waitForHotkey(5, "Ctrl+Win+K"); //exception after 5 s
	/// if(!keys.waitForHotkey(-5, "Left")) print.it("timeout"); //returns false after 5 s
	/// ]]></code>
	/// </example>
	public static bool waitForHotkey(Seconds timeout, [ParamString(PSFormat.Hotkey)] KHotkey hotkey, bool waitModReleased = false) {
		if (s_atomWFH == 0) s_atomWFH = Api.GlobalAddAtom("Au.WaitForHotkey");
		using (RegisteredHotkey rhk = default) {
			if (!rhk.Register(s_atomWFH, hotkey)) throw new AuException(0, "*register hotkey");
			if (!wait.forPostedMessage(timeout, (ref MSG m) => m.message == Api.WM_HOTKEY && m.wParam == s_atomWFH)) return false;
		}
		
		if (waitModReleased) waitForNoModifierKeys(0, hotkey.Mod);
		
		return true;
	}
	static ushort s_atomWFH;
	
	/// <summary>
	/// Sets a temporary keyboard hook and waits for a hotkey.
	/// </summary>
	/// <param name="timeout">Timeout, seconds. Can be 0 (infinite), >0 (exception) or &lt;0 (no exception). More info: [](xref:wait_timeout).</param>
	/// <param name="hotkeys">One or more hotkeys. Examples: <c>["Ctrl+M"]</c>, <c>["Win+M", "Ctrl+Shift+Left"]</c>.</param>
	/// <param name="block">Make the key down event of the non-modifier key invisible to other apps. Default <c>true</c>.</param>
	/// <param name="waitModReleased">Also wait until hotkey modifier keys released.</param>
	/// <returns>1-based index of the element in the array of hotkeys. On timeout returns 0 (if <i>timeout</i> negative; else exception).</returns>
	/// <exception cref="TimeoutException"></exception>
	/// <remarks>
	/// Uses <see cref="keys.waitForKeys"/>.
	/// Works even if the hotkey is used by Windows (except <c>Win+L</c> and <c>Ctrl+Alt+Del</c>) or an app as a hotkey or trigger.
	/// <note>Does not work when the active window has higher UAC integrity level than this process.</note>
	/// </remarks>
	/// <example>
	/// <code><![CDATA[
	/// int i = keys.waitForHotkeys(-10, ["Win+Left", "Win+Right"]);
	/// print.it(i);
	/// ]]></code>
	/// </example>
	public static int waitForHotkeys(Seconds timeout, [ParamString(PSFormat.Hotkey)] KHotkey[] hotkeys, bool block = true, bool waitModReleased = false) {
		int R = 0;
		keys.waitForKeys(timeout, k => {
			if (!k.IsUp && k.Mod == 0) {
				var mod = keys.getMod();
				for (int i = 0; i < hotkeys.Length; i++) {
					if (k.Key == hotkeys[i].Key && mod == hotkeys[i].Mod) {
						R = i + 1;
						return true;
					}
				}
			}
			return false;
		}, block);
		
		if (waitModReleased && R > 0) keys.waitForNoModifierKeys(0, hotkeys[R - 1].Mod);
		
		return R;
	}

	#endregion

	/// <summary>
	/// Generates virtual keystrokes (keys, text).
	/// </summary>
	/// <param name="keysEtc">
	/// Arguments of these types:
	/// <br/>• string - [key names and operators](xref:key_names), like <c>"Enter A Ctrl+A"</c>.\
	/// Tool: in <c>""</c> string press <c>Ctrl+Space</c>.
	/// <br/>• string with prefix <c>"!"</c> - literal text.\
	/// Example: <c>var p = "pass"; keys.send("!user", "Tab", "!" + p, "Enter");</c>
	/// <br/>• string with prefix <c>"%"</c> - HTML to paste. Full or fragment.
	/// <br/>• <see cref="clipboardData"/> - clipboard data to paste.
	/// <br/>• <see cref="KKey"/> - a single key.\
	/// Example: <c>keys.send("Shift+", KKey.Left, "*3");</c> is the same as <c>keys.send("Shift+Left*3");</c>
	/// <br/>• <c>int</c> - sleep milliseconds. Max 10000.\
	/// Example: <c>keys.send("Left", 500, "Right");</c>
	/// <br/>• <see cref="Action"/> - callback function.\
	/// Example: <c>Action click = () => mouse.click(); keys.send("Shift+", click);</c>
	/// <br/>• <see cref="KKeyScan"/> - a single key, specified using scan code and/or virtual-key code and extended-key flag.\
	/// Example: <c>keys.send(new KKeyScan(0x3B, false)); //key F1</c>\
	/// Example: <c>keys.send(new KKeyScan(KKey.Enter, true)); //numpad Enter</c>
	/// <br/>• <c>char</c> - a single character. Like text with <see cref="OKeyText.KeysOrChar"/> or operator <c>^</c>.
	/// </param>
	/// <exception cref="ArgumentException">An invalid value, for example an unknown key name.</exception>
	/// <exception cref="AuException">Failed. When sending text, fails if there is no focused window.</exception>
	/// <exception cref="InputDesktopException"></exception>
	/// <remarks>
	/// String syntax: [key names and operators](xref:key_names).
	/// 
	/// Uses <see cref="opt.key"/>:
	/// <table>
	/// <tr>
	/// <th>Option</th>
	/// <th>Default</th>
	/// <th>Changed</th>
	/// </tr>
	/// <tr>
	/// <td><see cref="OKey.NoBlockInput"/></td>
	/// <td><c>false</c>.
	/// Blocks user-pressed keys. Sends them afterwards.
	/// <br/>If the last argument is "sleep", stops blocking before executing it; else stops blocking after executing all arguments.</td>
	/// <td><c>true</c>.
	/// Does not block user-pressed keys.</td>
	/// </tr>
	/// <tr>
	/// <td><see cref="OKey.NoCapsOff"/></td>
	/// <td><c>false</c>.
	/// If the <c>CapsLock</c> key is toggled, untoggles it temporarily (presses it before and after).</td>
	/// <td><c>true</c>.
	/// Does not touch the <c>CapsLock</c> key.
	/// <br/>Alphabetic keys of "keys" arguments can depend on <c>CapsLock</c>. Text of "text" arguments doesn't depend on <c>CapsLock</c>, unless <see cref="OKey.TextHow"/> is <c>KeysX</c>.</td>
	/// </tr>
	/// <tr>
	/// <td><see cref="OKey.NoModOff"/></td>
	/// <td><c>false</c>.
	/// Releases modifier keys (<c>Alt</c>, <c>Ctrl</c>, <c>Shift</c>, <c>Win</c>).
	/// <br/>Does it only at the start; later they cannot interfere, unless <see cref="OKey.NoBlockInput"/> is <c>true</c>.</td>
	/// <td><c>true</c>.
	/// Does not touch modifier keys.</td>
	/// </tr>
	/// <tr>
	/// <td><see cref="OKey.TextSpeed"/></td>
	/// <td>0 ms.</td>
	/// <td>0 - 1000.
	/// Changes the speed for "text" arguments.</td>
	/// </tr>
	/// <tr>
	/// <td><see cref="OKey.KeySpeed"/></td>
	/// <td>2 ms.</td>
	/// <td>0 - 1000.
	/// Changes the speed for "keys" arguments.</td>
	/// </tr>
	/// <tr>
	/// <td><see cref="OKey.KeySpeedClipboard"/></td>
	/// <td>5 ms.</td>
	/// <td>0 - 1000.
	/// Changes the speed of <c>Ctrl+V</c> keys when pasting text or HTML using clipboard.</td>
	/// </tr>
	/// <tr>
	/// <td><see cref="OKey.SleepFinally"/></td>
	/// <td>10 ms.</td>
	/// <td>0 - 10000.
	/// <br/>Tip: to sleep finally, also can be used code like this: <c>keys.send("keys", 1000);</c>.</td>
	/// </tr>
	/// <tr>
	/// <td><see cref="OKey.TextHow"/></td>
	/// <td><see cref="OKeyText.Characters"/>.</td>
	/// <td><c>KeysOrChar</c>, <c>KeysOrPaste</c> or <c>Paste</c>.</td>
	/// </tr>
	/// <tr>
	/// <td><see cref="OKey.TextShiftEnter"/></td>
	/// <td><c>false</c>.</td>
	/// <td><c>true</c>. When sending text, instead of <c>Enter</c> send <c>Shift+Enter</c>.</td>
	/// </tr>
	/// <tr>
	/// <td><see cref="OKey.PasteLength"/></td>
	/// <td>200.
	/// <br/>This option is used for "text" arguments. If text length >= this value, uses clipboard.</td>
	/// <td>>=0.</td>
	/// </tr>
	/// <tr>
	/// <td><see cref="OKey.PasteWorkaround"/></td>
	/// <td><c>false</c>.
	/// <br/>This option is used for "text" arguments when using clipboard.
	/// </td>
	/// <td><c>true</c>.</td>
	/// </tr>
	/// <tr>
	/// <td><see cref="OKey.RestoreClipboard"/></td>
	/// <td><c>true</c>.
	/// Restore clipboard data (by default only text).
	/// <br/>This option is used for "text" and "HTML" arguments when using clipboard.</td>
	/// <td><c>false</c>.
	/// Don't restore clipboard data.</td>
	/// </tr>
	/// <tr>
	/// <td><see cref="OKey.Hook"/></td>
	/// <td><c>null</c>.</td>
	/// <td>Callback function that can modify options depending on active window etc.</td>
	/// </tr>
	/// </table>
	/// 
	/// This function does not wait until the target app receives and processes sent keystrokes and text; there is no reliable way to know it. It just adds small delays depending on options (<see cref="OKey.SleepFinally"/> etc). If need, change options or add "sleep" arguments or wait after calling this function. Sending text through the clipboard normally does not have these problems.
	/// 
	/// Don't use this function to automate windows of own thread. Call it from another thread. See example with async/await.
	/// 
	/// Administrator and uiAccess processes don't receive keystrokes sent by standard user processes. See [](xref:uac).
	/// 
	/// Mouse button codes/names (eg <see cref="KKey.MouseLeft"/>) cannot be used to click. Instead use callback, like in the "Ctrl+click" example.
	/// 
	/// You can use a <see cref="keys"/> variable instead of this function. Example: <c>new keys(null).Add("keys", "!text").SendNow();</c>. More examples in <see cref="keys(OKey)"/> topic.
	/// 
	/// This function calls <see cref="Add(KKeysEtc[])"/>, which calls these functions depending on argument type: <see cref="AddKeys"/>, <see cref="AddText"/>, <see cref="AddChar"/>, <see cref="AddClipboardData"/>, <see cref="AddKey(KKey, bool?)"/>, <see cref="AddKey(KKey, ushort, bool, bool?)"/>, <see cref="AddSleep"/>, <see cref="AddAction"/>. Then calls <see cref="SendNow"/>.
	/// 
	/// Uses API <ms>SendInput</ms>.
	/// </remarks>
	/// <example>
	/// <code><![CDATA[
	/// //Press key Enter.
	/// keys.send("Enter");
	/// 
	/// //Press keys Ctrl+A.
	/// keys.send("Ctrl+A");
	/// 
	/// //Ctrl+Alt+Shift+Win+A.
	/// keys.send("Ctrl+Alt+Shift+Win+A");
	/// 
	/// //Alt down, E, P, Alt up.
	/// keys.send("Alt+(E P)");
	/// 
	/// //Alt down, E, P, Alt up.
	/// keys.send("Alt*down E P Alt*up");
	/// 
	/// //Send text "Example".
	/// keys.send("!Example");
	/// keys.sendt("Example"); //same
	/// 
	/// //Press key End, key Backspace 3 times, send text "Text".
	/// keys.send("End Back*3", "!Text");
	/// 
	/// //Press Tab n times, send text "user", press Tab, send text "password", press Enter.
	/// int n = 5; string pw = "password";
	/// keys.send($"Tab*{n}", "!user", "Tab", "!" + pw, "Enter");
	/// 
	/// //Press Ctrl+V, wait 500 ms, press Enter.
	/// keys.send("Ctrl+V", 500, "Enter");
	/// 
	/// //F2, Ctrl+K, Left 3 times, Space, A, comma, 5, numpad 5, BrowserBack.
	/// keys.send("F2 Ctrl+K Left*3 Space a , 5 #5", KKey.BrowserBack);
	/// 
	/// //Shift down, A 3 times, Shift up.
	/// keys.send("Shift+A*3");
	/// 
	/// //Shift down, A 3 times, Shift up.
	/// keys.send("Shift+", KKey.A, "*3");
	/// 
	/// //Shift down, A, wait 500 ms, B, Shift up.
	/// keys.send("Shift+(", KKey.A, 500, KKey.B, ")");
	/// 
	/// //Send keys and text slowly.
	/// opt.key.KeySpeed = opt.key.TextSpeed = 50;
	/// keys.send("keys Shift+: Space 123456789 Space 123456789 ,Space", "!text: 123456789 123456789\n");
	/// 
	/// //Ctrl+click
	/// Action click = () => mouse.click();
	/// keys.send("Ctrl+", click);
	/// 
	/// //Ctrl+click
	/// keys.send("Ctrl+", new Action(() => mouse.click()));
	/// ]]></code>
	/// Show window and send keys/text to it when button clicked.
	/// <code><![CDATA[
	/// var b = new wpfBuilder("Window").WinSize(250);
	/// b.R.AddButton("Keys", async _ => {
	/// 	//keys.send("Tab", "!text", 2000, "Esc"); //no
	/// 	await Task.Run(() => { keys.send("Tab", "!text", 2000, "Esc"); }); //use other thread
	/// });
	/// b.R.Add("Text", out TextBox text1);
	/// b.R.AddOkCancel();
	/// b.End();
	/// if (!b.ShowDialog()) return;
	/// ]]></code>
	/// </example>
	public static void send([ParamString(PSFormat.Keys)] params KKeysEtc[] keysEtc) {
		new keys(opt.key).Add(keysEtc).SendNow();
	}
	//CONSIDER: move most of Remarks to Articles. Also make the param doc smaller, and move the big list to Remarks.

	/// <summary>
	/// Generates virtual keystrokes. Like <see cref="send"/>, but without reliability features: delays, user input blocking, resetting modifiers/<c>CapsLock</c>.
	/// </summary>
	/// <remarks>
	/// Ignores <see cref="opt.key"/> and instead uses default options with these changes:
	/// - <c>SleepFinally</c> = 0.
	/// - <c>KeySpeed</c> = 0.
	/// - <c>NoBlockInput</c> = <c>true</c>.
	/// - <c>NoCapsOff</c> = <c>true</c>.
	/// - <c>NoModOff</c> = <c>true</c>.
	/// </remarks>
	/// <seealso cref="more.sendKey"/>
	/// <inheritdoc cref="keys.send" path="//param|//exception"/>
	public static void sendL([ParamString(PSFormat.Keys)] params KKeysEtc[] keysEtc) {
		var o = new OKey() { KeySpeed = 0, NoBlockInput = true, NoCapsOff = true, NoModOff = true, SleepFinally = 0 };
		new keys(o).Add(keysEtc).SendNow();
	}

	/// <summary>
	/// Sends text to the active window, using virtual keystrokes or clipboard.
	/// </summary>
	/// <param name="text">Text. Can be <c>null</c>.</param>
	/// <param name="html">
	/// HTML. Can be full HTML or fragment. See <see cref="clipboardData.AddHtml"/>.
	/// Can be specified only <i>text</i> or only <i>html</i> or both. If both, will paste <i>html</i> in apps that support it, elsewhere <i>text</i>. If only <i>html</i>, in apps that don't support HTML will paste <i>html</i> as text.
	/// </param>
	/// <exception cref="AuException">Failed. Fails if there is no focused window.</exception>
	/// <exception cref="InputDesktopException"></exception>
	/// <remarks>
	/// Calls <see cref="AddText(string, string)"/> and <see cref="SendNow"/>.
	/// To send text can use keys, characters or clipboard, depending on <see cref="opt.key"/> and text. If <i>html</i> not <c>null</c>, uses clipboard.
	/// </remarks>
	/// <seealso cref="clipboard.paste"/>
	/// <example>
	/// <code><![CDATA[
	/// keys.sendt("Text.\r\n");
	/// ]]></code>
	/// Or use function <see cref="send"/> and prefix <c>"!"</c>. For HTML use prefix <c>"%"</c>.
	/// <code><![CDATA[
	/// keys.send("!Send this text and press key", "Enter");
	/// keys.send("%<b>bold</b> <i>italic</i>", "Enter");
	/// ]]></code>
	/// </example>
	public static void sendt(string text, string html = null) {
		new keys(opt.key).AddText(text, html).SendNow();
	}
}

//FUTURE: instead of QM2 AutoPassword: FocusPasswordField(); keys.send("!password", "Shift+Tab", "user", "Enter");
//public static void FocusPasswordField()


================================================
FILE: Au/Input/keys_types.cs
================================================
namespace Au.Types;

#pragma warning disable 1591 //missing doc

/// <summary>
/// Modifier keys as flags.
/// </summary>
/// <seealso cref="keys.more.KModToWinforms"/>
/// <seealso cref="keys.more.KModFromWinforms"/>
/// <seealso cref="KKey"/>
[Flags]
public enum KMod : byte {
	Shift = 1,
	Ctrl = 2,
	Alt = 4,
	Win = 8,
}

/// <summary>
/// Virtual-key codes.
/// </summary>
/// <remarks>
/// The values are the same as the native <c>VK_</c> constants. Also the same as in the <see cref="System.Windows.Forms.Keys"/> enum, but not as in the WPF <c>Key</c> enum.
/// Rare and obsolete keys are not included. You can use <c>Keys</c> like <c>(KKey)Keys.Attn</c> or <c>VK_</c> constant values like <c>(KKey)200</c>.
/// </remarks>
/// <seealso cref="KMod"/>
public enum KKey : byte {
	MouseLeft = 0x01,
	MouseRight = 0x02,
	///<summary><c>Ctrl+Pause</c>.</summary>
	Break = 0x03,
	MouseMiddle = 0x04,
	MouseX1 = 0x05,
	MouseX2 = 0x06,
	Back = 0x08,
	Tab = 0x09,
	///<summary><c>Shift+NumPad5</c>, or <c>NumPad5</c> when <c>NumLock</c> off.</summary>
	Clear = 0x0C,
	Enter = 0x0D,
	Shift = 0x10,
	Ctrl = 0x11,
	Alt = 0x12,
	Pause = 0x13,
	CapsLock = 0x14,
	IMEKanaMode = 0x15,
	IMEHangulMode = 0x15,
	IMEJunjaMode = 0x17,
	IMEFinalMode = 0x18,
	IMEHanjaMode = 0x19,
	IMEKanjiMode = 0x19,
	Escape = 0x1B,
	IMEConvert = 0x1C,
	IMENonconvert = 0x1D,
	IMEAccept = 0x1E,
	IMEModeChange = 0x1F,
	Space = 0x20,
	PageUp = 0x21,
	PageDown = 0x22,
	End = 0x23,
	Home = 0x24,
	Left = 0x25,
	Up = 0x26,
	Right = 0x27,
	Down = 0x28,
	//Select = 0x29,
	//Print = 0x2A,
	//Execute= 0x2B,
	PrintScreen = 0x2C,
	Insert = 0x2D,
	Delete = 0x2E,
	//Help = 0x2F,
	///<summary>The 0 <c>)</c> key.</summary>
	D0 = 0x30,
	///<summary>The 1 <c>!</c> key.</summary>
	D1 = 0x31,
	///<summary>The 2 <c>@</c> key.</summary>
	D2 = 0x32,
	///<summary>The 3 <c>#</c> key.</summary>
	D3 = 0x33,
	///<summary>The 4 <c>$</c> key.</summary>
	D4 = 0x34,
	///<summary>The 5 <c>%</c> key.</summary>
	D5 = 0x35,
	///<summary>The 6 <c>^</c> key.</summary>
	D6 = 0x36,
	///<summary>The 7 <c>&amp;</c> key.</summary>
	D7 = 0x37,
	///<summary>The 8 <c>*</c> key.</summary>
	D8 = 0x38,
	///<summary>The 9 <c>(</c> key.</summary>
	D9 = 0x39,
	A = 0x41,
	B = 0x42,
	C = 0x43,
	D = 0x44,
	E = 0x45,
	F = 0x46,
	G = 0x47,
	H = 0x48,
	I = 0x49,
	J = 0x4A,
	K = 0x4B,
	L = 0x4C,
	M = 0x4D,
	N = 0x4E,
	O = 0x4F,
	P = 0x50,
	Q = 0x51,
	R = 0x52,
	S = 0x53,
	T = 0x54,
	U = 0x55,
	V = 0x56,
	W = 0x57,
	X = 0x58,
	Y = 0x59,
	Z = 0x5A,
	///<summary>The left <c>Win</c> key.</summary>
	Win = 0x5B,
	///<summary>The right <c>Win</c> key.</summary>
	RWin = 0x5C,
	///<summary>The <c>Application/Menu</c> key.</summary>
	Apps = 0x5D,
	Sleep = 0x5F,
	NumPad0 = 0x60,
	NumPad1 = 0x61,
	NumPad2 = 0x62,
	NumPad3 = 0x63,
	NumPad4 = 0x64,
	NumPad5 = 0x65,
	NumPad6 = 0x66,
	NumPad7 = 0x67,
	NumPad8 = 0x68,
	NumPad9 = 0x69,
	///<summary>The numpad <c>*</c> key.</summary>
	Multiply = 0x6A,
	///<summary>The numpad <c>+</c> key.</summary>
	Add = 0x6B,
	//Separator = 0x6C,
	///<summary>The numpad <c>-</c> key.</summary>
	Subtract = 0x6D,
	///<summary>The numpad <c>.</c> key.</summary>
	Decimal = 0x6E,
	///<summary>The numpad <c>/</c> key.</summary>
	Divide = 0x6F,
	F1 = 0x70,
	F2 = 0x71,
	F3 = 0x72,
	F4 = 0x73,
	F5 = 0x74,
	F6 = 0x75,
	F7 = 0x76,
	F8 = 0x77,
	F9 = 0x78,
	F10 = 0x79,
	F11 = 0x7A,
	F12 = 0x7B,
	F13 = 0x7C,
	F14 = 0x7D,
	F15 = 0x7E,
	F16 = 0x7F,
	F17 = 0x80,
	F18 = 0x81,
	F19 = 0x82,
	F20 = 0x83,
	F21 = 0x84,
	F22 = 0x85,
	F23 = 0x86,
	F24 = 0x87,
	//VK_NAVIGATION_VIEW ... VK_NAVIGATION_CANCEL
	NumLock = 0x90,
	ScrollLock = 0x91,
	//VK_OEM_NEC_EQUAL ... VK_OEM_FJ_ROYA
	///<summary>The left <c>Shift</c> key.</summary>
	LShift = 0xA0,
	///<summary>The right <c>Shift</c> key.</summary>
	RShift = 0xA1,
	///<summary>The left <c>Ctrl</c> key.</summary>
	LCtrl = 0xA2,
	///<summary>The right <c>Ctrl</c> key.</summary>
	RCtrl = 0xA3,
	///<summary>The left <c>Alt</c> key.</summary>
	LAlt = 0xA4,
	///<summary>The right <c>Alt</c> key.</summary>
	RAlt = 0xA5,
	BrowserBack = 0xA6,
	BrowserForward = 0xA7,
	BrowserRefresh = 0xA8,
	BrowserStop = 0xA9,
	BrowserSearch = 0xAA,
	BrowserFavorites = 0xAB,
	BrowserHome = 0xAC,
	VolumeMute = 0xAD,
	VolumeDown = 0xAE,
	VolumeUp = 0xAF,
	MediaNextTrack = 0xB0,
	MediaPrevTrack = 0xB1,
	MediaStop = 0xB2,
	MediaPlayPause = 0xB3,
	LaunchMail = 0xB4,
	LaunchMediaSelect = 0xB5,
	LaunchApp1 = 0xB6,
	LaunchApp2 = 0xB7,
	OemSemicolon = 0xBA,
	OemPlus = 0xBB,
	OemComma = 0xBC,
	OemMinus = 0xBD,
	OemPeriod = 0xBE,
	OemQuestion = 0xBF,
	OemTilde = 0xC0,
	//VK_GAMEPAD_A ... VK_GAMEPAD_RIGHT_THUMBSTICK_LEFT
	OemOpenBrackets = 0xDB,
	OemPipe = 0xDC,
	OemCloseBrackets = 0xDD,
	OemQuotes = 0xDE,
	//VK_OEM_8 ... VK_ICO_00
	IMEProcessKey = 0xE5,
	//VK_ICO_CLEAR
	///<summary><ms>VK_PACKET</ms>. Not a key.</summary>
	Packet = 0xE7,
	//VK_OEM_RESET ... VK_OEM_BACKTAB
	//Attn = 0xF6,
	//Crsel = 0xF7,
	//Exsel = 0xF8,
	//EraseEof = 0xF9,
	//Play = 0xFA,
	//Zoom = 0xFB,
	//NoName = 0xFC,
	//Pa1 = 0xFD,
	//OemClear = 0xFE,
}

/// <summary>
/// Virtual-key code, scan code and extended-key flag for <see cref="keys.send"/> and similar functions.
/// </summary>
/// <example>
/// This script prints properties of pressed keys.
/// <code><![CDATA[
/// using var hook = WindowsHook.Keyboard(k=> {
/// 	if(!k.IsUp) print.it(k.Key, k.vkCode, k.scanCode, k.IsExtended);
/// }, ignoreAuInjected: false);
/// dialog.show("Hook");
/// ]]></code>
/// </example>
public struct KKeyScan {
	public KKey vk;
	public bool extendedKey;
	public ushort scanCode;

	public KKeyScan(KKey vk, ushort scanCode, bool extendedKey) { this.vk = vk; this.scanCode = scanCode; this.extendedKey = extendedKey; }

	public KKeyScan(ushort scanCode, bool extendedKey) { vk = 0; this.scanCode = scanCode; this.extendedKey = extendedKey; }

	public KKeyScan(KKey vk, bool extendedKey) { this.vk = vk; this.scanCode = 0; this.extendedKey = extendedKey; }
}

/// <summary>
/// Parameter type of <see cref="keys.send"/> and similar functions.
/// Has implicit conversions from <c>string</c>, <see cref="clipboardData"/>, <see cref="KKey"/>, <see cref="KKeyScan"/>, <c>char</c>, <c>int</c> (sleep time) and <see cref="Action"/>.
/// </summary>
public struct KKeysEtc {
	readonly object _o;
	KKeysEtc(object o) { _o = o; }

	public KKeysEtc(Action a) { _o = a; } //allows 'new(() => {})' instead of 'new Action(() => {})'

	public object Value => _o;

	public static implicit operator KKeysEtc(string s) => new(s);
	public static implicit operator KKeysEtc(clipboardData cd) => new(cd);
	public static implicit operator KKeysEtc(KKey k) => new(k);
	public static implicit operator KKeysEtc(KKeyScan t) => new(t);
	public static implicit operator KKeysEtc(char c) => new(c);
	public static implicit operator KKeysEtc(int ms) => new(ms);
	public static implicit operator KKeysEtc(Action a) => new(a);
}

/// <summary>
/// <see cref="keys.Pasting"/> event data.
/// </summary>
public class PastingEventArgs : EventArgs {
	///
	public string Text { get; init; }
	///
	public OKey Options { get; init; }
	///
	public wnd WndFocus { get; init; }
}

#pragma warning restore 1591

/// <summary>
/// Defines a hotkey as <see cref="KMod"/> and <see cref="KKey"/>.
/// Has implicit conversion operators from string like <c>"Ctrl+Shift+K"</c>, tuple <c>(KMod, KKey)</c>, enum <see cref="KKey"/>, enum <c>Keys</c>.
/// </summary>
public struct KHotkey {
	/// <summary>
	/// Modifier keys (flags).
	/// </summary>
	public KMod Mod { get; set; }

	/// <summary>
	/// Key without modifier keys.
	/// </summary>
	public KKey Key { get; set; }

	///
	public KHotkey(KMod mod, KKey key) { Mod = mod; Key = key; }

	/// <summary>Implicit conversion from string like <c>"Ctrl+Shift+K"</c>.</summary>
	/// <exception cref="ArgumentException">Error in hotkey.</exception>
	public static implicit operator KHotkey(string hotkey) {
		if (!keys.more.parseHotkeyString(hotkey, out var mod, out var key)) throw new ArgumentException("Error in hotkey.");
		return new KHotkey(mod, key);
	}

	/// <summary>Implicit conversion from tuple <c>(KMod, KKey)</c>.</summary>
	public static implicit operator KHotkey((KMod, KKey) hotkey) => new KHotkey(hotkey.Item1, hotkey.Item2);

	/// <summary>Implicit conversion from <see cref="KKey"/> (hotkey without modifiers).</summary>
	public static implicit operator KHotkey(KKey key) => new KHotkey(0, key);

	/// <summary>Implicit conversion from <see cref="System.Windows.Forms.Keys"/> like <c>Keys.Ctrl|Keys.B</c>.</summary>
	public static implicit operator KHotkey(System.Windows.Forms.Keys hotkey) => new KHotkey(keys.more.KModFromWinforms(hotkey), (KKey)(byte)hotkey);

	/// <summary>Explicit conversion to <see cref="System.Windows.Forms.Keys"/>.</summary>
	public static explicit operator System.Windows.Forms.Keys(KHotkey hk) => keys.more.KModToWinforms(hk.Mod) | (System.Windows.Forms.Keys)hk.Key;

	/// <summary>Allows to get properties of a <see cref="KHotkey"/> variable like <c>var (mod, key) = hotkey;</c></summary>
	public void Deconstruct(out KMod mod, out KKey key) { mod = Mod; key = Key; }

	///
	public override string ToString() => keys.more.hotkeyToString(Mod, Key);
}


================================================
FILE: Au/Input/keys_util.cs
================================================
namespace Au;

public partial class keys {
	/// <summary>
	/// Converts part of string to <see cref="KKey"/>.
	/// The substring should contain single key name, eg <c>"Esc"</c>, <c>"A"</c>, <c>"="</c>.
	/// Returns 0 if invalid key name.
	/// </summary>
	static unsafe KKey _KeynameToKey(string s, int i, int len) {
		//print.it(s, i, len);
		if (len < 1) return 0;
		
		char c = s[i];
		
		//character keys, like K, 9, -
		if (len == 1) {
			return c switch {
				>= 'a' and <= 'z' => (KKey)(c - 32),
				>= 'A' and <= 'Z' => (KKey)c,
				>= '0' and <= '9' => (KKey)c,
				'-' => KKey.OemMinus,
				'=' => KKey.OemPlus,
				'`' or '~' => KKey.OemTilde,
				'[' or '{' => KKey.OemOpenBrackets,
				']' or '}' => KKey.OemCloseBrackets,
				'\\' or '|' => KKey.OemPipe,
				';' or ':' => KKey.OemSemicolon,
				'\'' or '"' => KKey.OemQuotes,
				',' or '<' => KKey.OemComma,
				'.' or '>' => KKey.OemPeriod,
				'/' or '?' => KKey.OemQuestion,
				_ => 0,
			};
			
			//special
			//+ //eg Ctrl+A
			//* //*nTimes, *down, *up
			//( //eg Alt+(A F)
			//)
			//# //numpad keys, eg #5, #*
			//_ //character
			//^ //characters
			
			//reserved
			//! @ $ % &
		}
		
		//numpad keys
		if (c == '#') {
			if (len != 2) return 0;
			c = s[i + 1];
			return c switch {
				>= '0' and <= '9' => (KKey)(c - '0' + (int)KKey.NumPad0),
				'.' => KKey.Decimal,
				'+' => KKey.Add,
				'/' => KKey.Divide,
				'*' => KKey.Multiply,
				'-' => KKey.Subtract,
				_ => 0,
			};
		}
		
		//F keys
		if (c == 'F' && s[i + 1].IsAsciiDigit()) {
			int n = s.ToInt(i + 1, out int e, STIFlags.NoHex);
			if (n > 0 && n <= 24 && e == i + len) return (KKey)(0x6F + n);
		}
		
		//named keys
		//names start with an uppercase letter and must have at least 2 other anycase letters, except: Up, AltG (RAl), PageU (PgU), PageD (PgD), some alternative names (PU, PD, PB, PS, HM, SL, CL, NL, BS).
		KKey k = 0;
		char c1 = char.ToLowerInvariant(s[i + 1]), //note: Tables_.LowerCase would make startup slow
			c2 = len > 2 ? char.ToLowerInvariant(s[i + 2]) : ' ',
			c3 = len > 3 ? char.ToLowerInvariant(s[i + 3]) : ' ',
			c4 = len > 4 ? char.ToLowerInvariant(s[i + 4]) : ' ';
		uint u = (uint)c1 << 16 | c2;
		switch (c) {
		case 'A':
			if (_U('l', 't')) k = c3 == 'g' ? KKey.RAlt : KKey.Alt;
			else if (_U('p', 'p')) k = KKey.Apps;
			break;
		case 'B':
			if (_U('a', 'c') || _U('s', ' ')) k = KKey.Back;
			break;
		case 'C':
			if (_U('t', 'r')) k = KKey.Ctrl;
			else if (_U('a', 'p') || _U('l', ' ')) k = KKey.CapsLock;
			break;
		case 'D':
			if (_U('e', 'l')) k = KKey.Delete;
			else if (_U('o', 'w')) k = KKey.Down;
			break;
		case 'E':
			if (_U('n', 't')) k = KKey.Enter;
			else if (_U('n', 'd')) k = KKey.End;
			else if (_U('s', 'c')) k = KKey.Escape;
			break;
		case 'H':
			if (_U('o', 'm') || _U('m', ' ')) k = KKey.Home;
			break;
		case 'I':
			if (_U('n', 's')) k = KKey.Insert;
			break;
		case 'L':
			if (_U('e', 'f')) k = KKey.Left;
			//don't need LShift etc
			break;
		case 'M':
			if (_U('e', 'n')) k = KKey.Apps;
			break;
		case 'N':
			if (_U('u', 'm') || _U('l', ' ')) k = KKey.NumLock;
			//for NumEnter use keys.send((KKey.Enter, 0, true))
			break;
		case 'P':
			if (_U('a', 'g') && c3 == 'e') k = c4 == 'u' ? KKey.PageUp : (c4 == 'd' ? KKey.PageDown : 0);
			else if (_U('g', 'u') || _U('u', ' ')) k = KKey.PageUp;
			else if (_U('g', 'd') || _U('d', ' ')) k = KKey.PageDown;
			else if (_U('a', 'u') || _U('b', ' ')) k = KKey.Pause;
			else if (_U('r', 'i') || _U('r', 't') || _U('s', ' ')) k = KKey.PrintScreen;
			break;
		case 'R':
			if (_U('i', 'g')) k = KKey.Right;
			else if (_U('a', 'l')) k = KKey.RAlt;
			else if (_U('c', 't')) k = KKey.RCtrl;
			else if (_U('s', 'h')) k = KKey.RShift;
			else if (_U('w', 'i')) k = KKey.RWin;
			break;
		case 'S':
			if (_U('h', 'i')) k = KKey.Shift;
			else if (_U('p', 'a')) k = KKey.Space;
			else if (_U('c', 'r') || _U('l', ' ')) k = KKey.ScrollLock;
			//SysRq not used on Windows
			break;
		case 'T':
			if (_U('a', 'b')) k = KKey.Tab;
			break;
		case 'U':
			if (c1 == 'p') k = KKey.Up;
			break;
		case 'V':
			if (c1 == 'k') {
				int v = s.ToInt(i + 2, out int end, STIFlags.DontSkipSpaces);
				if (end != i + len || (uint)v > 255) v = 0;
				return (KKey)v;
			}
			break;
		case 'W':
			if (_U('i', 'n')) k = KKey.Win;
			break;
		}
		if (k != 0) {
			for (int i2 = i + len; i < i2; i++) if (!s[i].IsAsciiAlpha()) return 0;
			return k;
		}
		
		if (c >= 'A' && c <= 'Z') {
			var s1 = s.Substring(i, len);
#if false
			if(Enum.TryParse(s1, true, out KKey r1)) return r1;
			//if(Enum.TryParse(s1, true, out System.Windows.Forms.Keys r2) && (uint)r2 <= 0xff) return (KKey)r2;
#else //20-50 times faster and less garbage. Good JIT speed.
			return _FindKeyInEnums(s1);
#endif
		}
		return 0;
		
		bool _U(char cc1, char cc2) { return u == ((uint)cc1 << 16 | cc2); }
	}
	
	static IEnumerable<RXGroup> _SplitKeysString(string keys_) =>
		(s_rxKeys ??= new regexp(@"(?s)[A-Z][[:alnum:]]*|#\S|\*\s*(?:\d+|down|up)\b|\+\s*\(|_.|\^.+|\S"))
		.FindAllG(keys_ ?? "", 0);
	//KeyName | #n | *r | *down | *up | +( | _char | ^chars | nonspace char
	static regexp s_rxKeys;
	
	static System.Collections.Hashtable s_htEnum; //with Dictionary much slower JIT
	[MethodImpl(MethodImplOptions.NoInlining)]
	static KKey _FindKeyInEnums(string key) {
		if (s_htEnum == null) {
			var t = new System.Collections.Hashtable(160 /*220*/, StringComparer.OrdinalIgnoreCase);
			var a1 = typeof(KKey).GetFields();
			for (int j = 1; j < a1.Length; j++) { //note: start from 1 to skip the default value__, it gives exception
				t.Add(a1[j].Name, a1[j].GetRawConstantValue());
			}
			
			//rejected. Better avoid loading Forms dll. All useful keys are in KKey. For others can use virtual-key codes.
			//var a2 = typeof(System.Windows.Forms.Keys).GetFields();
			//for(int j = 4; j < a2.Length; j++) { //skip value__, KeyCode, Modifiers, None
			//	var v = a2[j];
			//	//print.it(v.Name);
			//	if(t.ContainsKey(v.Name)) continue;
			//	var k = v.GetRawConstantValue();
			//	if((uint)(int)k >= 0xff) continue;
			//	print.it(v.Name, j);
			//	t.Add(v.Name, k);
			//}
			
			//print.it(a1.Length, /*a2.Length,*/ t.Count); //216 with Keys enum, 156 without
			s_htEnum = t;
		}
		var r = s_htEnum[key];
		if (r == null) return 0;
		if (r is byte) return (KKey)(byte)r;
		return (KKey)(int)r;
		//note: GetRawConstantValue gets byte for KKey, int for Keys. GetValue(null) gets of enum type.
	}
	
	static ArgumentException _ArgumentException_ErrorInKeysString(string keys_, int i, int len) {
		int end = i + len;
		return new ArgumentException($"Error in keys string: {keys_[..i]}■{keys_[i..end]}■{keys_[end..]}");
		//tested: all fonts on Win7 have ■.
	}
	
	/// <summary>
	/// Internal static functions.
	/// </summary>
	internal static class Internal_ {
		/// <summary>
		/// Calls <see cref="wait.doEvents(int)"/>.
		/// </summary>
		internal static void Sleep(int ms) {
			if (ms > 0) wait.doEventsPrecise_(ms);
			
			//see comments in mouse._Sleep.
		}
		
		/// <summary>
		/// If <c>t > 10</c>, returns <c>(t / 4 + 8)</c>.
		/// </summary>
		internal static int LimitSleepTime(int t) => t <= 10 ? t : (t / 4 + 8);
		
		/// <summary>
		/// If <i>k</i> is <c>Shift</c>, <c>Ctrl</c>, <c>Alt</c> or <c>Win</c> or their left/right versions, returns it as modifier flag, eg <c>KMod.Shift</c>.
		/// Else returns 0.
		/// </summary>
		internal static KMod KeyToMod(KKey k) {
			return k switch {
				KKey.Shift or KKey.LShift or KKey.RShift => KMod.Shift,
				KKey.Ctrl or KKey.LCtrl or KKey.RCtrl => KMod.Ctrl,
				KKey.Alt or KKey.LAlt or KKey.RAlt => KMod.Alt,
				KKey.Win or KKey.RWin => KMod.Win,
				_ => 0,
			};
		}
		
		/// <summary>
		/// Gets scan code from virtual-key code.
		/// </summary>
		/// <param name="vk"></param>
		/// <param name="hkl">Keyboard layout. If 0, uses of current thread. If -1, uses current focus/active thread.</param>
		internal static ushort VkToSc(KKey vk, nint hkl = 0) {
			if (hkl == 0) hkl = Api.GetKeyboardLayout(0);
			else if (hkl == -1) {
				var w = wnd.focused; if (w.Is0) w = wnd.active;
				hkl = Api.GetKeyboardLayout(w.ThreadId);
			}
			
			uint sc = Api.MapVirtualKeyEx((uint)vk, 0, hkl); //MAPVK_VK_TO_VSC
			
			//fix Windows bugs
			if (vk == KKey.PrintScreen && sc == 0x54) sc = 0x37;
			if (vk == KKey.Pause && sc == 0) sc = 0x45;
			
			return (ushort)sc;
			
			//tested: LCtrl, RCtrl etc are correctly sent, although MSDN does not mention that SendInput supports it.
		}
		
		/// <summary>
		/// Sends one key event.
		/// Just calls API <c>SendInput</c> with raw parameters.
		/// </summary>
		/// <exception cref="InputDesktopException"></exception>
		internal static unsafe void SendKeyEventRaw(KKey vk, ushort scan, uint flags, int? extra = null, bool dontThrow = false) {
			var ki = new Api.INPUTK(vk, scan, flags);
			if (extra != null) ki.dwExtraInfo = extra.Value;
			Api.SendInput(&ki, dontThrow: dontThrow);
		}
		
		/// <inheritdoc cref="more.sendKey"/>
		internal static void SendKey(KKey k, bool? down = null, nint hkl = 0, int? extra = null, bool dontThrow = false) {
			uint f = 0;
			if (KeyTypes_.IsExtended(k)) f |= Api.KEYEVENTF_EXTENDEDKEY;
			ushort scan = VkToSc(k, hkl);
			
			if (down != false) SendKeyEventRaw(k, scan, f, extra, dontThrow);
			if (down != true) SendKeyEventRaw(k, scan, f | Api.KEYEVENTF_KEYUP, extra, dontThrow);
		}
		
		/// <inheritdoc cref="SendKeyEventRaw"/>
		internal static void SendCtrl(bool down) => SendKeyEventRaw(KKey.Ctrl, 0x1D, down ? 0 : Api.KEYEVENTF_KEYUP);
		
		/// <inheritdoc cref="SendKeyEventRaw"/>
		internal static void SendAlt(bool down) => SendKeyEventRaw(KKey.Alt, 0x38, down ? 0 : Api.KEYEVENTF_KEYUP);
		
		/// <inheritdoc cref="SendKeyEventRaw"/>
		internal static void SendShift(bool down) => SendKeyEventRaw(KKey.Shift, 0x2A, down ? 0 : Api.KEYEVENTF_KEYUP);
		
		/// <inheritdoc cref="SendKeyEventRaw"/>
		internal static void SendRCtrlUp() => SendKeyEventRaw(KKey.Ctrl, 0x1D, Api.KEYEVENTF_KEYUP | Api.KEYEVENTF_EXTENDEDKEY);
		
		/// <inheritdoc cref="SendKeyEventRaw"/>
		internal static void SendRAltUp() => SendKeyEventRaw(KKey.Alt, 0x38, Api.KEYEVENTF_KEYUP | Api.KEYEVENTF_EXTENDEDKEY);
		
		/// <inheritdoc cref="SendKeyEventRaw"/>
		internal static void SendRShiftUp() => SendKeyEventRaw(KKey.Shift, 0x36, Api.KEYEVENTF_KEYUP);
		
		/// <summary>
		/// Presses or releases one or more modifier keys.
		/// Sends in this order: <c>Ctrl</c>, <c>Alt</c>, <c>Shift</c>, <c>Win</c>.
		/// </summary>
		/// <param name="press"></param>
		/// <param name="mod">Modifier keys. Does nothing if 0.</param>
		/// <exception cref="InputDesktopException"></exception>
		internal static unsafe void ModPressRelease(bool press, KMod mod) {
			if (mod == 0) return;
			var a = stackalloc Api.INPUTK[4];
			int n = 0; uint f = press ? 0 : Api.KEYEVENTF_KEYUP;
			if (0 != (mod & KMod.Ctrl)) a[n++].Set(KKey.Ctrl, 0x1D, f);
			if (0 != (mod & KMod.Alt)) a[n++].Set(KKey.Alt, 0x38, f);
			if (0 != (mod & KMod.Shift)) a[n++].Set(KKey.Shift, 0x2A, f);
			if (0 != (mod & KMod.Win)) a[n++].Set(KKey.Win, 0x5B, f);
			Api.SendInput(a, n);
		}
		
		/// <summary>
		/// Releases modifier keys if pressed.
		/// May also press-release some other keys to avoid menu mode etc.
		/// Does not use options, sleep, blockinput, etc.
		/// </summary>
		/// <exception cref="InputDesktopException"></exception>
		internal static void ReleaseModAndDisableModMenu(bool dontThrow = false) {
			if (dontThrow) {
				try { ReleaseModAndDisableModMenu(); }
				catch (Exception ex) { Debug_.Print(ex); }
				return;
			}
			
			int m = 0;
			if (isPressed(KKey.LShift)) m |= 1;
			if (isPressed(KKey.RShift)) m |= 0x10;
			if (isPressed(KKey.LCtrl)) m |= 2;
			if (isPressed(KKey.RCtrl)) m |= 0x20;
			if (isPressed(KKey.LAlt)) m |= 4;
			if (isPressed(KKey.RAlt)) m |= 0x40;
			if (isPressed(KKey.Win)) m |= 8;
			if (isPressed(KKey.RWin)) m |= 0x80;
			if (m == 0) return;
			
			//if Alt or Win pressed without Ctrl, send Ctrl to avoid menu mode or Start menu.
			//	For Alt works Ctrl-up, but maybe not everywhere. For Win need Ctrl-down-up.
			if (0 != (m & 0xCC) && 0 == (m & 0x22)) {
				SendCtrl(true);
				m |= 2;
			}
			
			//prevent invoking something when pressed-released only modifier keys.
			//	Examples: switch keyboard layout on Ctrl+Alt or Ctrl+Shift; invoke QTranslate on two Ctrl; MS Office ad on Ctrl+Alt+Shift+Win.
			//	The vk is unassigned. Tested: vk 0 does not work.
			SendKeyEventRaw((KKey)0xD8, 0, Api.KEYEVENTF_KEYUP);
			
			if (0 != (m & 2)) SendCtrl(false);
			if (0 != (m & 0x20)) SendRCtrlUp();
			if (0 != (m & 1)) SendShift(false);
			if (0 != (m & 0x10)) SendRShiftUp();
			if (0 != (m & 4)) SendAlt(false);
			if (0 != (m & 0x40)) SendRAltUp();
			if (0 != (m & 8)) SendKey(KKey.Win, false);
			if (0 != (m & 0x80)) SendKey(KKey.RWin, false);
		}
		
		/// <summary>
		/// Sends <c>Ctrl+V</c> or <c>Ctrl+C</c> or <c>Ctrl+X</c>, and/or optionally one or more keys.
		/// Caller gets <i>optk</i> and <i>wFocus</i> with <c>GetOptionsAndWndFocused_</c> (it may want to know some options too).
		/// Caller calls <c>Press</c>, waits until the target app gets clipboard data, then calls <c>Release</c>.
		/// </summary>
		internal unsafe struct SendCopyPaste {
			KHotkey _hk;
			ushort _scan;
			OKey _opt;
			List<KKey> _andKeys;
			
			/// <summary>
			/// Presses <c>Ctrl+key</c>. Does not release.
			/// If <i>andKeys</i> used, <c>Release</c> will press/release them.
			/// </summary>
			/// <exception cref="InputDesktopException"></exception>
			public void Press(KHotkey hk, OKey optk, wnd wFocus, List<KKey> andKeys = null) {
				_hk = hk;
				_scan = VkToSc(_hk.Key, Api.GetKeyboardLayout(wFocus.ThreadId));
				_opt = optk;
				_andKeys = andKeys;
				
				if (_hk.Mod.Has(KMod.Ctrl)) SendCtrl(true);
				if (_hk.Mod.Has(KMod.Alt)) SendAlt(true);
				if (_hk.Mod.Has(KMod.Shift)) SendShift(true);
				Internal_.Sleep(_opt.KeySpeedClipboard); //eg need 100 ms for BlueStacks
				SendKeyEventRaw(_hk.Key, _scan, 0);
			}
			
			/// <summary>
			/// Releases keys.
			/// Does nothing if already released.
			/// </summary>
			/// <exception cref="InputDesktopException"></exception>
			public void Release() {
				if (_hk.Key == 0) return;
				var vk = _hk.Key; _hk.Key = 0;
				
				SendKeyEventRaw(vk, _scan, Api.KEYEVENTF_KEYUP);
				if (_hk.Mod.Has(KMod.Shift)) SendShift(false);
				if (_hk.Mod.Has(KMod.Alt)) SendAlt(false);
				if (_hk.Mod.Has(KMod.Ctrl)) SendCtrl(false);
				if (_andKeys != null) AndSendKeys(_andKeys, _opt);
			}
			
			/// <summary>
			/// Sends one or more keys.
			/// Not used for keys whose scancode can depend on keyboard layout. To get scancode, uses keyboard layout of current thread.
			/// </summary>
			/// <exception cref="InputDesktopException"></exception>
			public static void AndSendKeys(List<KKey> keys_, OKey optk) {
				foreach (var k in keys_) {
					var f = KeyTypes_.IsExtended(k) ? _KFlags.Extended : default;
					var e = new _KEvent(true, k, f, VkToSc(k));
					_SendKey2(e, default, true, optk);
				}
			}
		}
		
		/// <summary>
		/// Gets focused or active window. Waits for it max 20-40 ms (820 ms if <i>requireFocus</i>). On timeout returns default (throws exception if <i>requireFocus</i>).
		/// </summary>
		/// <param name="requireFocus">Wait for focused (and not just active) window longer, and throw exception on timeout. Used for clipboard copy/paste and send text.</param>
		/// <exception cref="AuException">No focused window when <i>requireFocus</i>.</exception>
		/// <exception cref="InputDesktopException"></exception>
		internal static wnd GetWndFocusedOrActive(bool requireFocus) {
			for (int i = 0; i < (requireFocus ? 100 : 20); i++) {
				miscInfo.getGUIThreadInfo(out var g);
				//print.it(i, g.hwndFocus, g.hwndActive);
				if (!g.hwndFocus.Is0) return g.hwndFocus;
				if (!requireFocus && !g.hwndActive.Is0) return g.hwndActive;
				wait.ms(i < 20 ? 1 : 10);
			}
			InputDesktopException.ThrowIfBadDesktop();
			if (requireFocus) throw new AuException("There is no focused window"); //TODO3: test various windows and data types, maybe somewhere could work without focus
			return default;
			
			//note: the purpose of this wait is not synchronization. It just makes getting the focused/active window more reliable.
			//	Cannot wait for a focused window. Users must program it explicitly.
			//	When creating or activating a window, often there is no focus for 200 ms or more. Eg when opening the Save As dialog.
			//	Also, focus is optional.
			//	Anyway, waiting for focus would not make more reliable, because keys are processed asynchronously.
			//	Usually the active window is OK. We use it to get keyboard layout and/or to avoid calling Hook too frequently.
			//	This func waits for active window max 20-40 ms. When switching apps, usually there is no active window for 1-5 ms.
		}
	}
	
	/// <summary>
	/// Returns:
	/// - <i>optk</i> - <c>OKey</c> of this variable or <c>OKey</c> cloned from this variable and possibly modified by <c>Hook</c>.
	/// - <i>wFocus</i> - the focused or active window.
	/// </summary>
	/// <param name="getWndAlways">if <c>false</c>, the caller does not need <i>wFocus</i>. Then <i>wFocus</i> will be <c>default(wnd)</c> if <c>Hook</c> is <c>null</c>.</param>
	/// <param name="requireFocus">Wait for focused (and not just active) window longer, and throw exception on timeout. Used for clipboard copy/paste and send text.</param>
	/// <exception cref="AuException">No focused window when <i>requireFocus</i>.</exception>
	/// <exception cref="InputDesktopException"></exception>
	internal (OKey optk, wnd wFocus) GetOptionsAndWndFocused_(bool getWndAlways, bool requireFocus = false) {
		if (Options.Hook == null && !getWndAlways) return (Options, default);
		var w = Internal_.GetWndFocusedOrActive(requireFocus);
		return (GetOptions_(w), w);
	}
	
	/// <summary>
	/// Returns <c>OKey</c> of this variable or <c>OKey</c> cloned from this variable and possibly modified by <c>Hook</c>.
	/// </summary>
	/// <param name="wFocus">the focused or active window. The function uses it to avoid frequent calling of <c>Hook</c>. If you don't have it, use <c>GetOptionsAndWndFocused_</c> instead.</param>
	internal OKey GetOptions_(wnd wFocus) {
		var call = Options.Hook;
		if (call == null || wFocus.Is0) return Options;
		if (wFocus != _sstate.wFocus) {
			_sstate.wFocus = wFocus;
			if (_sstate.options == null) _sstate.options = new OKey(Options); else _sstate.options.CopyOrDefault_(Options);
			call(new OKeyHookData(_sstate.options, wFocus));
		}
		return _sstate.options;
	}
	
	void _ThrowIfSending() {
		if (_sending) throw new InvalidOperationException();
	}
	
	internal static class KeyTypes_ {
		[Flags]
		enum _KT : byte {
			Mod = 1,
			Extended = 2,
			Mouse = 4,
			GksReliable = 8,
		}
		
		/// <summary>
		/// <c>Ctrl</c>, <c>LCtrl</c>, etc.
		/// </summary>
		public static bool IsMod(KKey vk) => 0 != (_b[(byte)vk] & _KT.Mod);
		
		public static bool IsExtended(KKey vk) => 0 != (_b[(byte)vk] & _KT.Extended);
		
		public static bool IsMouse(KKey vk) => 0 != (_b[(byte)vk] & _KT.Mouse);
		
		/// <summary>
		/// API <c>GetKeyState</c> always works.
		/// For other keys returns 0 if pressed or toggled before starting current thread.
		/// Modifiers (left/right too), lock keys, mouse, some other.
		/// </summary>
		public static bool IsGetKeyStateReliable(KKey vk) => 0 != (_b[(byte)vk] & _KT.GksReliable);
		
		/// <summary>
		/// The same as <see cref="IsGetKeyStateReliable"/>.
		/// </summary>
		public static bool IsToggleable(KKey vk) => 0 != (_b[(byte)vk] & _KT.GksReliable);
		
		static _KT[] _b;
		
		static KeyTypes_() {
			_b = new _KT[256];
			
			_b[1] = _b[2] = _b[4] = _b[5] = _b[6]
				= _KT.Mouse | _KT.GksReliable;
			
			_b[16] = _b[17] = _b[18] = _b[(int)KKey.LShift] = _b[(int)KKey.RShift] = _b[(int)KKey.LCtrl] = _b[(int)KKey.LAlt]
				= _KT.Mod | _KT.GksReliable;
			
			_b[(int)KKey.PageUp] = _b[(int)KKey.PageDown] = _b[(int)KKey.End] = _b[(int)KKey.Home]
				= _b[(int)KKey.Left] = _b[(int)KKey.Up] = _b[(int)KKey.Right] = _b[(int)KKey.Down]
				= _b[(int)KKey.PrintScreen] = _b[(int)KKey.Insert] = _b[(int)KKey.Delete]
				= _b[(int)KKey.Sleep] = _b[(int)KKey.Apps] = _b[(int)KKey.Divide] = _b[(int)KKey.Break]
				= _KT.Extended;
			//and more, but undocumented, and cannot test. There is no API to get extended keys. MapVirtualKeyEx can get only of 50% keys.
			
			_b[(int)KKey.CapsLock] = _b[(int)KKey.ScrollLock]
				= _b[(int)KKey.Back] = _b[(int)KKey.Tab] = _b[(int)KKey.Enter] = _b[(int)KKey.Escape]
				= _KT.GksReliable; //also Home and maybe more
			
			_b[(int)KKey.NumLock]
				= _KT.Extended | _KT.GksReliable;
			
			_b[(int)KKey.Win] = _b[(int)KKey.RWin] = _b[(int)KKey.RCtrl] = _b[(int)KKey.RAlt]
				= _KT.Mod | _KT.Extended | _KT.GksReliable;
			
			for (int i = (int)KKey.BrowserBack; i <= (int)KKey.LaunchApp2; i++) _b[i] = _KT.Extended; //media/browser/launchapp keys
			
			//for(int i = 1; i < 256; i++) print.it((KKey)i, _b[i]);
		}
	}
	
	struct _INPUTKEY2 {
		public Api.INPUTK k0, k1;
		
		public _INPUTKEY2(KKey vk, ushort sc, uint flags = 0) {
			k0 = new Api.INPUTK(vk, sc, flags);
			k1 = new Api.INPUTK(vk, sc, flags | Api.KEYEVENTF_KEYUP);
		}
	}
}


================================================
FILE: Au/Input/miscInfo.cs
================================================
namespace Au;

/// <summary>
/// Contains functions to get miscellaneous info not found in other classes of this library and .NET.
/// </summary>
/// <seealso cref="osVersion"/>
/// <seealso cref="folders"/>
/// <seealso cref="process"/>
/// <seealso cref="screen"/>
/// <seealso cref="script"/>
/// <seealso cref="perf"/>
/// <seealso cref="uacInfo"/>
/// <seealso cref="Dpi"/>
/// <seealso cref="Environment"/>
/// <seealso cref="System.Windows.Forms.SystemInformation"/>
/// <seealso cref="System.Windows.SystemParameters"/>
public static class miscInfo {
	/// <summary>
	/// Calls API <ms>GetGUIThreadInfo</ms>. It gets info about mouse capturing, menu mode, move/size mode, focus, caret, etc.
	/// </summary>
	/// <param name="g">API <ms>GUITHREADINFO</ms>.</param>
	/// <param name="idThread">Thread id. If 0 - the foreground (active window) thread. See <see cref="process.thisThreadId"/>, <see cref="wnd.ThreadId"/>.</param>
	public static unsafe bool getGUIThreadInfo(out GUITHREADINFO g, int idThread = 0) {
		g = new GUITHREADINFO { cbSize = sizeof(GUITHREADINFO) };
		return Api.GetGUIThreadInfo(idThread, ref g);
	}
	
	/// <summary>
	/// Gets caret rectangle.
	/// </summary>
	/// <returns><c>false</c> if failed.</returns>
	/// <param name="r">Receives the rectangle, in screen coordinates.</param>
	/// <param name="w">Receives the caret owner control or the focused control.</param>
	/// <param name="orMouse">If fails, get mouse pointer coordinates.</param>
	/// <remarks>
	/// Some apps use non-standard caret; then may fail.
	/// </remarks>
	public static bool getTextCursorRect(out RECT r, out wnd w, bool orMouse = false) {
		//rejected. Too few controls support it.
		///// <param name="preferSelection">Get text selection rectangle if possible.</param>
		
		if (getGUIThreadInfo(out var g)) {
			if (!g.hwndCaret.Is0) {
				if (g.rcCaret.bottom <= g.rcCaret.top) g.rcCaret.bottom = g.rcCaret.top + 16;
				r = g.rcCaret;
				g.hwndCaret.MapClientToScreen(ref r);
				w = g.hwndCaret;
				return true;
			}
			
			if (!g.hwndFocus.Is0) {
				w = g.hwndFocus;
				try {
					var e = elm.fromWindow(g.hwndFocus, EObjid.CARET, EWFlags.NoThrow | EWFlags.NotInProc);
					if (e?.GetRect(out r) == true) return true;
					
					if (g.hwndFocus.ClassNameIs("HwndWrapper[powershell_ise.exe;*")) {
						if (UiaUtil.GetCaretRectInPowerShell(out r)) return true;
					} else if (UiaUtil.ElementFocused() is { } ef) {
						if (ef.GetCaretRect(out r)) return true;
					}
					
					//GetGUIThreadInfo and MSAA don't work with winstore, winui3, Windows Terminal.
					//Most winstore and winui3 apps support IUIAutomationTextPattern2, and it gives correct caret rect.
					//Terminal supports only IUIAutomationTextPattern, and it gives correct caret rect when there is no selection.
					//Bad: some apps give client coordinates (bug, eg PowerShell). We can convert to screen easily, but can't know the coordinate type in unknown apps.
					//Win+; works well with all tested winstore apps and terminal, although some apps don't support even IUIAutomationTextPattern. What API it uses?
					//IME works everywhere. What API it uses?
					//PhraseExpress doesn't work.
				}
				catch (Exception e1) { Debug_.Print(e1); }
			}
		}
		
		if (orMouse) {
			Api.GetCursorPos(out var p);
			r = new RECT(p.x, p.y, 0, 16);
		} else r = default;
		
		w = default;
		return false;
		
		//note: in Word, after changing caret pos, GetGUIThreadInfo and MSAA get pos 0 0. After 0.5 s gets correct. After typing always correct.
	}
	
	/// <summary>
	/// Returns <c>true</c> if current thread is on the input desktop and therefore can use mouse, keyboard, clipboard and window functions.
	/// </summary>
	/// <param name="detectLocked">Return <c>false</c> if the active window is a full-screen window of <c>LockApp.exe</c> on Windows 10+. For example when computer has been locked but still not displaying the password field. Slower.</param>
	/// <remarks>
	/// Usually this app is running on default desktop. Examples of other desktops: the <c>Ctrl+Alt+Delete</c> screen, the PC locked screen, screen saver, UAC consent, custom desktops. If one of these is active, this process cannot use many mouse, keyboard, clipboard and window functions. They either throw exception or do nothing.
	/// </remarks>
	/// <seealso cref="InputDesktopException"/>
	public static unsafe bool isInputDesktop(bool detectLocked = false) {
		var w = wnd.active;
		if (w.Is0) { //tested: last error code 0
			int i = 0;
			if (!Api.GetUserObjectInformation(Api.GetThreadDesktop(Api.GetCurrentThreadId()), Api.UOI_IO, &i, 4, out _)) return true; //slow
			return i != 0;
			//also tested several default screensavers on Win10 and 7. Goes through this branch. When closed, works like when locked (goes through other branch until next input).
		} else {
			if (detectLocked && osVersion.minWin10) {
				var rw = w.Rect;
				if (rw.left == 0 && rw.top == 0) {
					var rs = screen.primary.Rect;
					if (rw == rs) {
						var s = w.ProgramName;
						if (s.Eqi("LockApp.exe")) return false;
					}
				}
			}
			return true;
			//info: in lock screen SHQueryUserNotificationState returns QUNS_NOT_PRESENT.
			//	Also documented but not tested: screen saver.
			//	tested: QUNS_ACCEPTS_NOTIFICATIONS (normal) when Ctrl+Alt+Delete.
			//	However it is too slow, eg 1300 mcs.
		}
	}
	
	//public static unsafe string GetInputDesktopName() {
	//	var hd = Api.OpenInputDesktop(0, false, Api.GENERIC_READ); //error "Access is denied" when this process is admin. Need SYSTEM.
	//	//if (hd == default) throw new AuException(0);
	//	if (hd == default) return null;
	//	string s = null;
	//	var p = stackalloc char[300];
	//	if (Api.GetUserObjectInformation(hd, Api.UOI_NAME, p, 600, out int len) && len >= 4) s = new(p, 0, len / 2 - 1);
	//	Api.CloseDesktop(hd);
	//	return s;
	//}
	
	/// <summary>
	/// Returns <c>true</c> if this process is running in a child session (aka Picture-in-Picture).
	/// </summary>
	public static unsafe bool isChildSession {
		get {
			if (!s_isChildSession.HasValue) {
				bool yes = false;
				if (osVersion.minWin8) {
					var psid = process.thisProcessSessionId;
					if (psid > 1) {
						int csid = Api.WTSGetActiveConsoleSessionId();
						if (csid != -1 && psid != csid) {
							if (Api.WTSQuerySessionInformation(-1, Api.WTS_INFO_CLASS.WTSIsRemoteSession, out bool isRemote) && isRemote) {
								if (Api.WTSQuerySessionInformation(-1, Api.WTS_INFO_CLASS.WTSWinStationName, out string s1)) {
									yes = !s1.Starts("RDP-");
								}
							}
						}
					}
				}
				s_isChildSession = yes;
			}
			return s_isChildSession.Value;
		}
	}
	static bool? s_isChildSession;
}


================================================
FILE: Au/Input/mouse.cs
================================================
//TODO3: test how mouse moves through non-screen area between screens A and C when screen B is in between.
//	QM2 has problems crossing non-screen corners at default speed. Au works well.

namespace Au;

/// <summary>
/// Mouse functions.
/// </summary>
/// <remarks>
/// Should not be used to click windows of own thread. It may work or not. If need, use another thread. Example in <see cref="keys.send"/>.
/// </remarks>
public static class mouse {
	/// <summary>
	/// Gets cursor (mouse pointer) position.
	/// </summary>
	/// <example>
	/// <code><![CDATA[
	/// var p = mouse.xy;
	/// print.it(p.x, p.y);
	/// 
	/// var (x, y) = mouse.xy;
	/// print.it(x, y);
	/// ]]></code>
	/// <code><![CDATA[
	/// POINT mousePos = mouse.xy;
	/// mouse.moveBy(20, 50);
	/// POINT mousePos2 = mouse.xy;
	/// 
	/// double dist = Math2.Distance(mousePos2, mousePos);
	/// print.it(dist, (int)dist, dist.ToInt(), mousePos2.x - mousePos.x, mousePos2.y - mousePos.y);
	/// ]]></code>
	/// </example>
	public static POINT xy { get { Api.GetCursorPos(out var p); return p; } }
	
	static void _Move(POINT p, bool fast) {
		bool relaxed = opt.mouse.Relaxed, willFail = false;
		
		if (!screen.isInAnyScreen(p)) {
			if (!relaxed) throw new ArgumentOutOfRangeException(null, "Cannot mouse-move. This x y is not in screen. " + p.ToString());
			willFail = true;
		}
		
		if (!fast) _MoveSlowTo(p);
		
		POINT p0 = xy;
		//bool retry = false; g1:
		bool ok = false;
		for (int i = 0, n = relaxed ? 3 : 10; i < n; i++) {
			//perf.first();
			_SendMove(p);
			//info: now xy is still not updated in ~10% cases.
			//	In my tests was always updated after sleeping 0 or 1 ms.
			//	But the user etc also can move the mouse at the same time. Then the i loop always helps.
			//perf.next();
			int j = 0;
			for (; ; j++) {
				var pNow = xy;
				ok = (pNow == p);
				if (ok || pNow != p0 || j > 3) break;
				wait.ms(j); //0+1+2+3
			}
			//perf.nw();
			//print.it(j, i);
			if (ok || willFail) break;
			//note: don't put the _Sleep(7) here
			
			//Accidentally this is also a workaround for SendInput bug:
			//	When moving to other screen, moves to a wrong place if new x or y is outside of rect of old screen.
			//	To reproduce:
			//		Let now mouse is in second screen, and try to move to 0 0 (primary screen).
			//		Case 1: Let second screen is at the bottom and its left is eg 300. Single SendInput will move to 300 0.
			//		Case 2: Let second screen is at the right and its top is eg 300. Will move x to the right of the primary screen.
			//	Tested only on Win10.
			//	Workaround: call SendInput twice.
		}
		if (!ok && !relaxed) {
			var es = $"*mouse-move to this x y in screen. " + p.ToString();
			wnd.active.UacCheckAndThrow_(es + ". The active"); //it's a mystery for users. API SendInput fails even if the point is not in the window.
			//rejected: wnd.getwnd.root.ActivateL()
			InputDesktopException.ThrowIfBadDesktop(es);
			throw new AuException(es);
			//known reasons:
			//	Active window of higher UAC IL.
			//	BlockInput, hook, some script etc that blocks mouse movement or restores mouse position.
			//	ClipCursor.
		}
		s_prevMousePos.last = p;
		
		_Sleep(opt.mouse.MoveSleepFinally);
	}
	
	static void _MoveSlowTo(POINT p) {
		bool drag = t_pressedButtons != 0;
		int speed = opt.mouse.MoveSpeed;
		if (drag) speed++; else if (speed == 0) return; //need at least 1 intermediate point, else some apps don't drag or don't select text etc
		var p1 = mouse.xy; //the start point; p is the end point
		int x2 = p.x - p1.x, y2 = p.y - p1.y; //x and y distances
		bool xNeg, yNeg; if (xNeg = x2 < 0) x2 = -x2; if (yNeg = y2 < 0) y2 = -y2; //make code easier
		double dist = Math.Sqrt(x2 * x2 + y2 * y2); if (dist < 4) return;
		double angle = Math.Atan2(y2, x2);
		var (sin, cos) = Math.SinCos(angle);
		double speed2 = speed / 10.0;
		
		for (double z = 0; ;) {
			bool startDragSlowly = drag && z < Math.Min(20, dist); //some apps refuse to drag if too fast
			double d = ((startDragSlowly ? z : dist - z) / 10 + 1) / speed2; //the speed depends on the distance, and is decreasing; increasing while startDragSlowly
			if (d > dist / 2) d = dist / 2; else if (d < 2) d = 2; //need at least 1 intermediate point; don't need too many points
			z += d;
			int x = (z * cos).ToInt(), y = (z * sin).ToInt();
			
			//make the line smoother. Converting double to int creates ugly bumps etc.
			//	Usually don't need it, but in some cases it may be better.
			//	Try to add 1 to x or/and y and use it if then the angle difference is smaller.
			int xPlus = 0, yPlus = 0; double anDiff = 4;
			for (int i = 0; i < 2; i++) {
				for (int j = 0; j < 2; j++) {
					double ad = Math.Abs(Math.Atan2(y + j, x + i) - angle);
					if (ad < anDiff) { anDiff = ad; xPlus = i; yPlus = j; }
				}
			}
			if (xPlus > 0 || yPlus > 0) {
				x += xPlus; y += yPlus;
				z = Math.Sqrt(x * x + y * y);
			}
			
			if (dist - z < .5) break;
			
			_SendMove(new(p1.x + (xNeg ? -x : x), p1.y + (yNeg ? -y : y)));
			_Sleep(7 + (speed - 1) / 10); //7-8 is the natural max WM_MOUSEMOVE period, even when the system timer period is 15.625 (default).
		}
	}
	
	/// <summary>
	/// Moves the cursor (mouse pointer) to the position <i>x y</i> relative to window <i>w</i>.
	/// </summary>
	/// <returns>Cursor position in screen coordinates.</returns>
	/// <param name="w">Window or control.</param>
	/// <param name="x">X coordinate relative to the client area of <i>w</i>. Default - center. Examples: <c>10</c>, <c>^10</c> (reverse), <c>.5f</c> (fraction).</param>
	/// <param name="y">Y coordinate relative to the client area of <i>w</i>. Default - center.</param>
	/// <param name="nonClient"><i>x y</i> are relative to the window rectangle.</param>
	/// <exception cref="AuWndException">
	/// - Invalid window.
	/// - The window is hidden. No exception if just cloaked, for example in another desktop; then on click will activate, which usually uncloaks. No exception if <i>w</i> is a control.
	/// - Other window-related failures.
	/// </exception>
	/// <inheritdoc cref="move(POINT)" path="//exception|//remarks"/>
	public static POINT move(wnd w, Coord x = default, Coord y = default, bool nonClient = false) {
		WaitForNoButtonsPressed_();
		w.ThrowIfInvalid();
		var wTL = w.Window;
		if (!wTL.IsVisible) throw new AuWndException(wTL, "Cannot mouse-move. The window is invisible"); //should make visible? Probably not. If cloaked because in an inactive virtual desktop etc, Click activates and it usually uncloaks.
		if (wTL.IsMinimized) { wTL.ShowNotMinimized(1); _Sleep(500); } //never mind: if w is a control...
		var p = Coord.NormalizeInWindow(x, y, w, nonClient, centerIfEmpty: true);
		if (!w.MapClientToScreen(ref p)) w.ThrowUseNative();
		_Move(p, fast: false);
		return p;
	}
	
	/// <summary>
	/// Moves the cursor (mouse pointer) to the position <i>x y</i> relative to UI object <i>obj</i>.
	/// </summary>
	/// <param name="obj">Can be <see cref="wnd"/>, <see cref="elm"/>, <see cref="uiimage"/>, <see cref="screen"/>, <see cref="RECT"/> in screen, <see cref="RECT"/> in window, <see cref="lastXY"/> (<c>true</c>), <see cref="xy"/> (<c>false</c>)</param>
	/// <param name="x">X coordinate relative to <i>obj</i>. Default - center. Examples: <c>10</c>, <c>^10</c> (reverse), <c>.5f</c> (fraction).</param>
	/// <param name="y">Y coordinate relative to <i>obj</i>. Default - center.</param>
	/// <inheritdoc cref="move(POINT)" path="//exception|//remarks"/>
	/// <exception cref="Exception">Other exceptions. Depends on <i>obj</i> type.</exception>
	public static void move(MObject obj, Coord x = default, Coord y = default) {
		switch (obj.Value) {
		case wnd w:
			move(w, x, y);
			break;
		case elm e:
			e.MouseMove(x, y);
			break;
		case uiimage u:
			u.MouseMove(x, y);
			break;
		case RECT r:
			move(Coord.NormalizeInRect(x, y, r, centerIfEmpty: true));
			break;
		case (wnd w, RECT r):
			var p = Coord.NormalizeInRect(x, y, r, centerIfEmpty: true);
			move(w, p.x, p.y);
			break;
		case (wnd w, bool nonClient):
			move(w, x, y, nonClient);
			break;
		case (screen s, bool workArea):
			move(Coord.Normalize(x, y, workArea, s, centerIfEmpty: true));
			break;
		case bool useLastXY:
			move(_CoordToRelativeXY(x, y, useLastXY));
			break;
		case null: //default(MObject)
			move(x, y);
			break;
		}
	}
	
	static POINT _CoordToRelativeXY(Coord x, Coord y, bool useLastXY) {
		var p = useLastXY ? lastXY : xy;
		if (x.Type is CoordType.Normal or CoordType.None) p.x += x.Value; else throw new ArgumentException(null, "x");
		if (y.Type is CoordType.Normal or CoordType.None) p.y += y.Value; else throw new ArgumentException(null, "y");
		return p;
	}
	
	/// <summary>
	/// Moves the cursor (mouse pointer) to the specified position in screen.
	/// </summary>
	/// <returns>Normalized cursor position.</returns>
	/// <param name="x">X coordinate. Examples: <c>10</c>, <c>^10</c> (reverse), <c>.5f</c> (fraction).</param>
	/// <param name="y">Y coordinate.</param>
	/// <inheritdoc cref="move(POINT)" path="//exception|//remarks"/>
	public static POINT move(Coord x, Coord y) {
		WaitForNoButtonsPressed_();
		var p = Coord.Normalize(x, y);
		_Move(p, fast: false);
		return p;
	}
	//rejected: parameters bool workArea = false, screen screen = default. Rarely used. Can use the POINT overload and Coord.Normalize.
	
	/// <summary>
	/// Moves the cursor (mouse pointer) to the specified position in screen.
	/// </summary>
	/// <param name="p">
	/// Coordinates.
	/// Tip: To specify coordinates relative to the right, bottom, work area or a non-primary screen, use <see cref="Coord.Normalize"/>, like in the example.
	/// </param>
	/// <exception cref="ArgumentOutOfRangeException">The position is not in screen. No exception if option <c>Relaxed</c> is <c>true</c> (then moves to a screen edge).</exception>
	/// <exception cref="AuException">
	/// Failed to move the cursor to that position. Some reasons:
	/// - The active window belongs to a process of higher [](xref:uac) integrity level.
	/// - Another thread blocks or modifies mouse input (API <ms>BlockInput</ms>, mouse hooks, frequent API <ms>SendInput</ms> etc).
	/// - Some application called API <ms>ClipCursor</ms>. No exception if option <c>Relaxed</c> is <c>true</c> (then final cursor position is undefined).
	/// </exception>
	/// <exception cref="InputDesktopException"></exception>
	/// <remarks>
	/// Uses <see cref="opt.mouse"/>: <see cref="OMouse.MoveSpeed"/>, <see cref="OMouse.MoveSleepFinally"/>, <see cref="OMouse.Relaxed"/>.
	/// </remarks>
	/// <example>
	/// Save-restore mouse position.
	/// <code><![CDATA[
	/// var p = mouse.xy;
	/// //...
	/// mouse.move(p);
	/// ]]></code>
	/// Use coordinates in the first non-primary screen.
	/// <code><![CDATA[
	/// mouse.move(Coord.Normalize(10, ^10, screen: screen.index(1))); //10 from left, 10 from bottom
	/// ]]></code>
	/// </example>
	public static void move(POINT p) {
		WaitForNoButtonsPressed_();
		_Move(p, fast: false);
	}
	
	/// <summary>
	/// Remembers current mouse cursor position to be later restored with <see cref="restore"/>.
	/// </summary>
	public static void save() {
		if (s_prevMousePos is { } v) v.first = xy; else s_prevMousePos = new();
	}
	
	/// <summary>
	/// Moves the mouse cursor where it was at the time of the last <see cref="save"/>. If it was not called - of the first "mouse move" or "mouse click" function call. Does nothing if these functions were not called.
	/// </summary>
	/// <remarks>
	/// Uses <see cref="opt.mouse"/>: <see cref="OMouse.MoveSleepFinally"/>, <see cref="OMouse.Relaxed"/>.
	/// </remarks>
	/// <inheritdoc cref="move(POINT)" path="/exception"/>
	public static void restore() {
		if (s_prevMousePos is { first: var p }) {
			WaitForNoButtonsPressed_();
			_Move(p, fast: true);
		}
	}
	
	class _PrevMousePos {
		public POINT first, last;
		public _PrevMousePos() { first = last = xy; }
		public _PrevMousePos(POINT p) { first = last = p; }
	}
	static _PrevMousePos s_prevMousePos;
	
	/// <summary>
	/// Mouse cursor position of the most recent successful "mouse move" or "mouse click" function call.
	/// If such functions are still not called, returns <see cref="xy"/>.
	/// </summary>
	public static POINT lastXY => s_prevMousePos?.last ?? xy;
	
	//rejected. MoveRelative usually is better. If need, can use code: Move(mouse.xy.x+dx, mouse.xy.y+dy).
	//public static void MoveFromCurrent(int dx, int dy)
	//{
	//	var p = XY;
	//	p.Offset(dx, dy);
	//	Move(p);
	//}
	
	/// <summary>
	/// Moves the cursor (mouse pointer) relative to <see cref="lastXY"/> or <see cref="xy"/>.
	/// </summary>
	/// <returns>Final cursor position in screen.</returns>
	/// <param name="dx">X offset from <c>lastXY.x</c> or <c>xy.x</c>.</param>
	/// <param name="dy">Y offset from <c>lastXY.y</c> or <c>xy.y</c>.</param>
	/// <param name="useLastXY">If <c>true</c> (default), moves relative to <see cref="lastXY"/>, else relative to <see cref="xy"/>.</param>
	/// <inheritdoc cref="move(POINT)" path="//exception|//remarks"/>
	public static POINT moveBy(int dx, int dy, bool useLastXY = true) {
		WaitForNoButtonsPressed_();
		var p = useLastXY ? lastXY : xy;
		p.x += dx; p.y += dy;
		_Move(p, fast: false);
		return p;
	}
	
	/// <summary>
	/// Moves the cursor (mouse pointer) relative to <see cref="lastXY"/>. Uses multiple x y offsets.
	/// </summary>
	/// <returns>Final cursor position in screen.</returns>
	/// <param name="offsets">String containing multiple x y offsets. Created by a mouse recorder tool with <see cref="RecordingUtil.MouseToString"/>.</param>
	/// <param name="speedFactor">Speed factor. For example, 0.5 makes 2 times faster.</param>
	/// <exception cref="FormatException">Invalid Base64 string.</exception>
	/// <exception cref="ArgumentException">The string is not compatible with this library version (recorded with a newer version and has additional options).</exception>
	/// <inheritdoc cref="move(POINT)" path="/exception"/>
	/// <remarks>
	/// Uses <see cref="opt.mouse"/>: <see cref="OMouse.Relaxed"/> (only for the last movement; always relaxed in intermediate movements).
	/// </remarks>
	public static POINT moveBy(string offsets, double speedFactor = 1.0) {
		WaitForNoButtonsPressed_();
		
		var a = Convert.FromBase64String(offsets);
		
		byte flags = a[0];
		const int knownFlags = 1; if ((flags & knownFlags) != flags) throw new ArgumentException("Unknown string version");
		bool withSleepTimes = 0 != (flags & 1);
		bool isSleep = withSleepTimes;
		
		var p = lastXY;
		int pdx = 0, pdy = 0;
		
		for (int i = 1; i < a.Length;) {
			if (i > 1 && (isSleep || !withSleepTimes)) {
				_SendMove(p);
				if (!withSleepTimes) _Sleep((7 * speedFactor).ToInt());
			}
			
			int v = a[i++], nbytes = (v & 3) + 1;
			for (int j = 1; j < nbytes; j++) v |= a[i++] << j * 8;
			v = (int)((uint)v >> 2);
			if (isSleep) {
				//print.it($"nbytes={nbytes}    sleep={v}");
				
				_Sleep((v * speedFactor).ToInt());
			} else {
				int shift = nbytes * 4 - 1, mask = (1 << shift) - 1;
				int x = v & mask, y = (v >> shift) & mask;
				shift = 32 - shift; x <<= shift; x >>= shift; y <<= shift; y >>= shift; //sign-extend
				int dx = pdx + x; pdx = dx;
				int dy = pdy + y; pdy = dy;
				
				//print.it($"dx={dx} dy={dy}    x={x} y={y}    nbytes={nbytes}    v=0x{v:X}");
				
				p.x += dx; p.y += dy;
			}
			isSleep ^= withSleepTimes;
		}
		_Move(p, fast: true);
		return p;
	}
	
	/// <summary>
	/// Sends single mouse movement event.
	/// x y are normal absolute coordinates.
	/// </summary>
	static void _SendMove(POINT p) {
		s_prevMousePos ??= new(); //sets .first=.last=mouse.xy
		_SendRaw(Api.IMFlags.Move, p.x, p.y);
	}
	
	/// <summary>
	/// Sends single mouse button down or up event.
	/// Does not use the action flags of button.
	/// Applies <c>SM_SWAPBUTTON</c>.
	/// Also moves to <i>p</i> in the same API <c>SendInput</c> call.
	/// </summary>
	internal static void SendButton_(MButton button, bool down, POINT p) {
		//CONSIDER: release user-pressed modifier keys, like keys class does.
		//CONSIDER: block user input, like keys class does.
		
		Api.IMFlags f; MButtons mb;
		switch (button & (MButton.Left | MButton.Right | MButton.Middle | MButton.X1 | MButton.X2)) {
		case 0: //allow 0 for left. Example: wnd.find(...).MouseClick(x, y, MButton.DoubleClick)
		case MButton.Left: f = down ? Api.IMFlags.LeftDown : Api.IMFlags.LeftUp; mb = MButtons.Left; break;
		case MButton.Right: f = down ? Api.IMFlags.RightDown : Api.IMFlags.RightUp; mb = MButtons.Right; break;
		case MButton.Middle: f = down ? Api.IMFlags.MiddleDown : Api.IMFlags.MiddleUp; mb = MButtons.Middle; break;
		case MButton.X1: f = down ? Api.IMFlags.XDown | Api.IMFlags.X1 : Api.IMFlags.XUp | Api.IMFlags.X1; mb = MButtons.X1; break;
		case MButton.X2: f = down ? Api.IMFlags.XDown | Api.IMFlags.X2 : Api.IMFlags.XUp | Api.IMFlags.X2; mb = MButtons.X2; break;
		default: throw new ArgumentException("Several buttons specified", nameof(button)); //rejected: InvalidEnumArgumentException. It's in System.ComponentModel namespace.
		}
		
		//maybe mouse left/right buttons are swapped
		if (0 != (button & (MButton.Left | MButton.Right)) && 0 != Api.GetSystemMetrics(Api.SM_SWAPBUTTON))
			f ^= down ? Api.IMFlags.LeftDown | Api.IMFlags.RightDown : Api.IMFlags.LeftUp | Api.IMFlags.RightUp;
		
		//If this is a Click(x y), the sequence of sent events is like: move, sleep, down, sleep, up. Even Click() sleeps between down and up.
		//During the sleep the user can move the mouse. Correct it now if need.
		//tested: if don't need to move, mouse messages are not sent. Hooks not tested. In some cases are sent one or more mouse messages but it depends on other things.
		//Alternatively could temporarily block user input, but it is not good. Need a hook (UAC disables Api.BlockInput), etc. Better let scripts do it explicitly. If script contains several mouse/keys statements, it's better to block input once for all.
		f |= Api.IMFlags.Move;
		
		//normally don't need this, but this is a workaround for the SendInput bug with multiple screens
		if (p != xy) _SendRaw(Api.IMFlags.Move, p.x, p.y);
		
		_SendRaw(f, p.x, p.y);
		
		if (down) t_pressedButtons |= mb; else t_pressedButtons &= ~mb;
	}
	
	/// <summary>
	/// Calls <c>Api.SendInput</c> to send single mouse movement or/and button down or up or wheel event.
	/// Converts <i>x</i>, <i>y</i> as need for <c>MOUSEINPUT</c>.
	/// For X buttons use <c>Api.IMFlag.XDown|Api.IMFlag.X1</c> etc.
	/// If <c>Api.IMFlag.Move</c>, adds <c>Api.IMFlag.Absolute</c>.
	/// </summary>
	static unsafe void _SendRaw(Api.IMFlags flags, int x = 0, int y = 0, int wheel = 0) {
		if (0 != (flags & Api.IMFlags.Move)) {
			flags |= Api.IMFlags.Absolute;
			var psr = screen.primary.Rect;
			x = (int)((((long)x << 16) + (x >= 0 ? 0x8000 : -0x8000)) / psr.Width);
			y = (int)((((long)y << 16) + (y >= 0 ? 0x8000 : -0x8000)) / psr.Height);
		}
		
		int mouseData;
		if (0 != (flags & (Api.IMFlags.XDown | Api.IMFlags.XUp))) {
			mouseData = (int)((uint)flags >> 24);
			flags &= (Api.IMFlags)0xffffff;
		} else mouseData = wheel;
		
		var k = new Api.INPUTM(flags, x, y, mouseData);
		Api.SendInput(&k);
	}
	
	static void _Sleep(int ms) {
		wait.doEventsPrecise_(ms);
		
		//note: always doevents, even if window from point is not of our thread. Because:
		//	Cannot always reliably detect what window will receive the message and what then happens.
		//	There is not much sense to avoid doevents. If no message loop, it is fast and safe; else the script author should use another thread or expect anything.
		//	API SendInput dispatches sent messages anyway.
		//	_Click shows warning if window of this thread.
		
		//FUTURE: sync better, especially finally.
	}
	
	[ThreadStatic] static MButtons t_pressedButtons;
	
	static void _Click(MButton button, POINT p, wnd w = default) {
		if (w.Is0) w = Api.WindowFromPoint(p);
		bool windowOfThisThread = w.IsOfThisThread;
		if (windowOfThisThread) print.warning("Click(window of own thread) may not work. Use another thread.");
		//Sending a click to a window of own thread often does not work.
		//Reason 1: often the window on down event enters a message loop that waits for up event. But then this func cannot send the up event because it is in the loop (if it does doevents).
		//	Known workarounds:
		//	1 (applied). Don't sleepdoevents between sending down and up events.
		//	2. Let this func send the click from another thread, and sleepdoevents until that thread finishes the click.
		//Reason 2: if this func called from a click handler, OS does not send more mouse events.
		//	Known workarounds:
		//	1. (applied): show warning. Let the user modify the script: either don't click own windows or click from another thread.
		
		int sleep = opt.mouse.ClickSpeed;
		
		switch (button & (MButton.Down | MButton.Up | MButton.DoubleClick)) {
		case MButton.DoubleClick:
			sleep = Math.Min(sleep, Api.GetDoubleClickTime() / 4);
			//info: default double-click time is 500. Control Panel can set 200-900. API can set 1.
			//info: to detect double-click, some apps use time between down and down (that is why /4), others between up and down.
			
			SendButton_(button, true, p);
			if (!windowOfThisThread) _Sleep(sleep);
			SendButton_(button, false, p);
			if (!windowOfThisThread) _Sleep(sleep);
			goto case 0;
		case 0: //click
			SendButton_(button, true, p);
			if (!windowOfThisThread) _Sleep(sleep);
			SendButton_(button, false, p);
			break;
		case MButton.Down:
			SendButton_(button, true, p);
			break;
		case MButton.Up:
			SendButton_(button, false, p);
			break;
		default: throw new ArgumentException("Incompatible flags: Down, Up, DoubleClick", nameof(button));
		}
		_Sleep(sleep + opt.mouse.ClickSleepFinally);
		
		//rejected: detect click failures (UAC, BlockInput, hooks).
		//	Difficult. Cannot detect reliably. SendInput returns true.
		//	Eg when blocked by UAC, GetKeyState shows changed toggle state. Then probably hooks also called, did not test.
	}
	
	/// <summary>
	/// Clicks, double-clicks, presses or releases a mouse button at position <i>x y</i> relative to window <i>w</i>.
	/// </summary>
	/// <returns>The return value can be used to auto-release the pressed button. Example: <see cref="MRelease"/>.</returns>
	/// <param name="button">Button and action. Default: left click.</param>
	/// <exception cref="ArgumentException">Invalid <i>button</i> flags (multiple buttons or actions specified).</exception>
	/// <inheritdoc cref="click(wnd, Coord, Coord, bool)"/>
	/// <example>
	/// <code><![CDATA[
	/// mouse.clickEx(MButton.Middle, w1, 695, 110);
	/// mouse.clickEx(MButton.Right | MButton.Down, w1, 695, 110);
	/// mouse.clickEx(MButton.Right | MButton.Up, w1, 695, 110);
	/// ]]></code>
	/// </example>
	public static MRelease clickEx(MButton button, wnd w, Coord x = default, Coord y = default, bool nonClient = false) {
		POINT p = move(w, x, y, nonClient);
		
		//Make sure will click w, not another window.
		var action = button & (MButton.Down | MButton.Up | MButton.DoubleClick);
		if (action != MButton.Up && !opt.mouse.Relaxed) { //allow to release anywhere, eg it could be a drag-drop
			var wTL = w.Window;
			bool bad = !wTL.Rect.Contains(p);
			if (!bad) {
				if (!_CheckWindowFromPoint()) {
					//Debug_.Print("need to activate");
					//info: activating brings to the Z top and also uncloaks
					if (!wTL.IsEnabled(false)) bad = true; //probably an owned modal dialog disabled the window
					else if (wTL.ThreadId == wnd.getwnd.shellWindow.ThreadId) bad = true; //desktop
					else if (wTL.IsActive) wTL.ZorderTop(); //can be below another window in the same topmost/normal Z order, although it is rare.
					else bad = !wTL.Activate_(wnd.Internal_.ActivateFlags.NoThrowIfInvalid | wnd.Internal_.ActivateFlags.IgnoreIfNoActivateStyleEtc | wnd.Internal_.ActivateFlags.NoGetWindow);
					
					//rejected: if wTL is desktop, minimize windows. Scripts should not have a reason to click desktop. If need, they can minimize windows explicitly.
					//CONSIDER: activate always, because some controls don't respond when clicked while the window is inactive. But there is a risk to activate a window that does not want to be activated on click, even if we don't activate windows that have noactivate style. Probably better let the script author insert Activate before Click when need.
					//CONSIDER: what if the window is hung?
					
					if (!bad) bad = !_CheckWindowFromPoint();
				} else if (!wTL.IsActive && !wTL.IsNoActivateStyle_()) {
					//activate window, because some windows/controls have this nasty feature:
					//	If window inactive, the first click just activates the window but does not execute the click action.
					//	Example: ribbon controls.
					//	Usually on WM_MOUSEACTIVATE they return MA_ACTIVATEANDEAT. We could send the message to detect it, but it's dirty and dangerous, eg some windows try to activate or focus self.
					//	In any case, activating could make more reliable. In QM2 it worked well, don't remember any problems.
					wTL.ActivateL();
					wTL.MinimalSleepIfOtherThread_();
				}
			}
			if (bad) throw new AuWndException(wTL, "Cannot click. The point is not in the window");
			
			bool _CheckWindowFromPoint() {
				var wfp = wnd.fromXY(p, WXYFlags.NeedWindow);
				if (wfp == wTL) return true;
				//forgive if same thread and no title bar. Eg a tooltip that disappears and relays the click to its owner window. But not if wTL is disabled.
				if (wTL.IsEnabled(false) && wfp.ThreadId == wTL.ThreadId && !wfp.HasStyle(WS.CAPTION)) return true;
				return false;
			}
		}
		
		_Click(button, p, w);
		return button;
	}
	
	/// <summary>
	/// Clicks, double-clicks, presses or releases a mouse button at position <i>x y</i> relative to UI object <i>obj</i>.
	/// </summary>
	/// <param name="button">Button and action. Default: left click.</param>
	/// <param name="obj">Can be <see cref="wnd"/>, <see cref="elm"/> (<see cref="elm.MouseClick"/>), <see cref="uiimage"/> (<see cref="uiimage.MouseClick"/>), <see cref="screen"/>, <see cref="RECT"/> in screen, <see cref="RECT"/> in window, <see cref="lastXY"/> (<c>true</c>), <see cref="xy"/> (<c>false</c>).</param>
	/// <param name="x">X coordinate relative to <i>obj</i>. Default - center. Examples: <c>10</c>, <c>^10</c> (reverse), <c>.5f</c> (fraction).</param>
	/// <param name="y">Y coordinate relative to <i>obj</i>. Default - center.</param>
	/// <example></example>
	/// <inheritdoc cref="clickEx(MButton, wnd, Coord, Coord, bool)"/>
	/// <exception cref="Exception">Other exceptions. Depends on <i>obj</i> type.</exception>
	public static MRelease clickEx(MButton button, MObject obj, Coord x = default, Coord y = default) {
		switch (obj.Value) {
		case wnd w:
			return clickEx(button, w, x, y);
		case elm e:
			return e.MouseClick(x, y, button);
		case uiimage u:
			return u.MouseClick(x, y, button);
		case RECT r:
			return mouse.clickEx(button, Coord.NormalizeInRect(x, y, r, centerIfEmpty: true));
		case (wnd w, RECT r):
			var p = Coord.NormalizeInRect(x, y, r, centerIfEmpty: true);
			return mouse.clickEx(button, w, p.x, p.y);
		case (wnd w, bool nonClient):
			return mouse.clickEx(button, w, x, y, nonClient);
		case (screen s, bool workArea):
			return mouse.clickEx(button, Coord.Normalize(x, y, workArea, s, centerIfEmpty: true));
		case bool useLastXY:
			return mouse.clickEx(button, _CoordToRelativeXY(x, y, useLastXY));
		case null: //default(MObject)
			return clickEx(button, x, y);
		}
		return default; //never
	}
	
	/// <summary>
	/// Clicks, double-clicks, presses or releases a mouse button at the specified position in screen.
	/// </summary>
	/// <returns>The return value can be used to auto-release the pressed button. Example: <see cref="MRelease"/>.</returns>
	/// <param name="button">Button and action. Default: left click.</param>
	/// <exception cref="ArgumentException">Invalid <i>button</i> flags (multiple buttons or actions specified).</exception>
	/// <inheritdoc cref="click(Coord, Coord)"/>
	public static MRelease clickEx(MButton button, Coord x, Coord y) {
		POINT p = move(x, y);
		_Click(button, p);
		return button;
	}
	
	/// <param name="p">
	/// Coordinates.
	/// Tip: To specify coordinates relative to the right, bottom, work area or a non-primary screen, use <see cref="Coord.Normalize"/>, like in the example.
	/// </param>
	/// <inheritdoc cref="clickEx(MButton, Coord, Coord)"/>
	/// <example>
	/// Click at 100 200.
	/// <code><![CDATA[
	/// mouse.clickEx(MButton.Left, (100, 200));
	/// ]]></code>
	/// 
	/// Right-click at 50 from left and 100 from bottom of the work area.
	/// <code><![CDATA[
	/// mouse.clickEx(MButton.Right, Coord.Normalize(50, ^100, workArea: true));
	/// ]]></code>
	/// </example>
	public static MRelease clickEx(MButton button, POINT p) {
		move(p);
		_Click(button, p);
		return button;
	}
	
	/// <summary>
	/// Clicks, double-clicks, presses or releases a mouse button.
	/// By default does not move the mouse cursor.
	/// </summary>
	/// <returns>The return value can be used to auto-release the pressed button. Example: <see cref="MRelease"/>.</returns>
	/// <param name="button">Button and action. Default: left click.</param>
	/// <param name="useLastXY">
	/// Use <see cref="lastXY"/>. It is the mouse cursor position set by the most recent "mouse move" or "mouse click" function. Use this option for reliability.
	/// Example: <c>mouse.move(100, 100); mouse.clickEx(..., true);</c>. The click is always at 100 100, even if somebody changes cursor position between <c>mouse.move</c> sets it and <c>mouse.clickEx</c> uses it. In such case this option atomically moves the cursor to <see cref="lastXY"/>. This movement is instant and does not use <see cref="opt"/>.
	/// If <c>false</c> (default), clicks at the current cursor position (does not move it).
	/// </param>
	/// <exception cref="ArgumentException">Invalid <i>button</i> flags (multiple buttons or actions specified).</exception>
	/// <exception cref="Exception">If <i>lastXY</i> <c>true</c> and need to move the cursor - exceptions of <see cref="move(POINT)"/>.</exception>
	/// <exception cref="InputDesktopException"></exception>
	/// <remarks>
	/// Uses <see cref="opt.mouse"/>: <see cref="OMouse.ClickSpeed"/>, <see cref="OMouse.ClickSleepFinally"/> and maybe those used by <see cref="move(POINT)"/>.
	/// </remarks>
	public static MRelease clickEx(MButton button = MButton.Left, bool useLastXY = false) {
		POINT p;
		if (useLastXY) p = lastXY;
		else {
			p = xy;
			if (s_prevMousePos is { } v) v.last = p; else s_prevMousePos = new(p); //sets .first=.last=p
		}
		_Click(button, p);
		return button;
	}
	
	/// <summary>
	/// Left button click at position <i>x y</i> relative to window <i>w</i>.
	/// </summary>
	/// <param name="w">Window or control.</param>
	/// <param name="x">X coordinate relative to the client area of <i>w</i>. Default - center. Examples: <c>10</c>, <c>^10</c> (reverse), <c>.5f</c> (fraction).</param>
	/// <param name="y">Y coordinate relative to the client area of <i>w</i>. Default - center.</param>
	/// <param name="nonClient">The specified position is relative to the window rectangle, not to its client area.</param>
	/// <exception cref="AuWndException">
	/// - The specified position is not in the window (read more in Remarks).
	/// - Invalid window.
	/// - The window is hidden. No exception if just cloaked, for example in another desktop; then on click will activate, which usually uncloaks. No exception if <i>w</i> is a control.
	/// - Other window-related failures.
	/// </exception>
	/// <inheritdoc cref="move(POINT)" path="/exception"/>
	/// <remarks>
	/// To move the mouse cursor, calls <see cref="move(wnd, Coord, Coord, bool)"/>.
	/// If after moving the cursor it is not in the window (or a window of its thread), activates the window (or its top-level parent window). Throws exception if then <i>x y</i> is still not in the window. Skips all this when just releasing button or if option <c>Relaxed</c> is <c>true</c>. If <i>w</i> is a control, <i>x y</i> can be somewhere else in its top-level parent window.
	/// 
	/// Uses <see cref="opt.mouse"/>: <see cref="OMouse.MoveSpeed"/>, <see cref="OMouse.MoveSleepFinally"/> (between moving and clicking), <see cref="OMouse.ClickSpeed"/>, <see cref="OMouse.ClickSleepFinally"/>, <see cref="OMouse.Relaxed"/>.
	/// </remarks>
	public static void click(wnd w, Coord x = default, Coord y = default, bool nonClient = false) {
		clickEx(MButton.Left, w, x, y, nonClient);
	}
	
	/// <summary>
	/// Left button click at position <i>x y</i>.
	/// </summary>
	/// <param name="x">X coordinate in the screen. Examples: <c>10</c>, <c>^10</c> (reverse), <c>.5f</c> (fraction).</param>
	/// <param name="y">Y coordinate in the screen.</param>
	/// <inheritdoc cref="move(POINT)" path="/exception"/>
	/// <remarks>
	/// Uses <see cref="opt.mouse"/>: <see cref="OMouse.ClickSpeed"/>, <see cref="OMouse.ClickSleepFinally"/> and those used by <see cref="move(POINT)"/>.
	/// </remarks>
	public static void click(Coord x, Coord y) {
		//note: most Click functions don't have a workArea and screen parameter. It is rarely used. For reliability better use the overloads that use window coordinates.
		
		clickEx(MButton.Left, x, y);
	}
	
	/// <summary>
	/// Left button click.
	/// </summary>
	/// <param name="useLastXY">Use <see cref="lastXY"/>, not current cursor position. More info: <see cref="clickEx(MButton, bool)"/>.</param>
	/// <exception cref="Exception">If <i>lastXY</i> <c>true</c> and need to move the cursor - exceptions of <see cref="move(POINT)"/>.</exception>
	/// <exception cref="InputDesktopException"></exception>
	/// <remarks>
	/// Uses <see cref="opt.mouse"/>: <see cref="OMouse.ClickSpeed"/>, <see cref="OMouse.ClickSleepFinally"/> and maybe those used by <see cref="move(POINT)"/>.
	/// </remarks>
	public static void click(bool useLastXY = false) {
		clickEx(MButton.Left, useLastXY);
	}
	
	/// <summary>
	/// Right button click at position <i>x y</i> relative to window <i>w</i>.
	/// </summary>
	/// <inheritdoc cref="click(wnd, Coord, Coord, bool)"/>
	public static void rightClick(wnd w, Coord x = default, Coord y = default, bool nonClient = false) {
		clickEx(MButton.Right, w, x, y, nonClient);
	}
	
	/// <summary>
	/// Right button click at position <i>x y</i>.
	/// </summary>
	/// <inheritdoc cref="click(Coord, Coord)"/>
	public static void rightClick(Coord x, Coord y) {
		clickEx(MButton.Right, x, y);
	}
	
	/// <summary>
	/// Right button click.
	/// </summary>
	/// <inheritdoc cref="click(bool)"/>
	public static void rightClick(bool useLastXY = false) {
		clickEx(MButton.Right, useLastXY);
	}
	
	/// <summary>
	/// Left button double click at position <i>x y</i> relative to window <i>w</i>.
	/// </summary>
	/// <inheritdoc cref="click(wnd, Coord, Coord, bool)"/>
	public static void doubleClick(wnd w, Coord x = default, Coord y = default, bool nonClient = false) {
		clickEx(MButton.Left | MButton.DoubleClick, w, x, y, nonClient);
	}
	
	/// <summary>
	/// Left button double click at position <i>x y</i>.
	/// </summary>
	/// <inheritdoc cref="click(Coord, Coord)"/>
	public static void doubleClick(Coord x, Coord y) {
		clickEx(MButton.Left | MButton.DoubleClick, x, y);
	}
	
	/// <summary>
	/// Left button double click.
	/// </summary>
	/// <inheritdoc cref="click(bool)"/>
	public static void doubleClick(bool useLastXY = false) {
		clickEx(MButton.Left | MButton.DoubleClick, useLastXY);
	}
	
	/// <summary>
	/// Left down (press and don't release) at position <i>x y</i> relative to window <i>w</i>.
	/// </summary>
	/// <returns>The return value can be used to auto-release the pressed button. Example: <see cref="MRelease"/>.</returns>
	/// <inheritdoc cref="click(wnd, Coord, Coord, bool)"/>
	public static MRelease leftDown(wnd w, Coord x = default, Coord y = default, bool nonClient = false) {
		return clickEx(MButton.Left | MButton.Down, w, x, y, nonClient);
	}
	
	/// <summary>
	/// Left button down (press and don't release) at position <i>x y</i>.
	/// </summary>
	/// <returns>The return value can be used to auto-release the pressed button. Example: <see cref="MRelease"/>.</returns>
	/// <inheritdoc cref="click(Coord, Coord)"/>
	public static MRelease leftDown(Coord x, Coord y) {
		return clickEx(MButton.Left | MButton.Down, x, y);
	}
	
	/// <summary>
	/// Left button down (press and don't release).
	/// </summary>
	/// <returns>The return value can be used to auto-release the pressed button. Example: <see cref="MRelease"/>.</returns>
	/// <inheritdoc cref="click(bool)"/>
	public static MRelease leftDown(bool useLastXY = false) {
		return clickEx(MButton.Left | MButton.Down, useLastXY);
	}
	
	/// <summary>
	/// Left button up (release pressed button) at position <i>x y</i> relative to window <i>w</i>.
	/// </summary>
	/// <inheritdoc cref="click(wnd, Coord, Coord, bool)"/>
	public static void leftUp(wnd w, Coord x = default, Coord y = default, bool nonClient = false) {
		clickEx(MButton.Left | MButton.Up, w, x, y, nonClient);
	}
	
	/// <summary>
	/// Left button up (release pressed button) at position <i>x y</i>.
	/// </summary>
	/// <inheritdoc cref="click(Coord, Coord)"/>
	public static void leftUp(Coord x, Coord y) {
		clickEx(MButton.Left | MButton.Up, x, y);
	}
	
	/// <summary>
	/// Left button up (release pressed button).
	/// </summary>
	/// <inheritdoc cref="click(bool)"/>
	public static void leftUp(bool useLastXY = false) {
		clickEx(MButton.Left | MButton.Up, useLastXY);
	}
	
	/// <summary>
	/// Right button down (press and don't release) at position <i>x y</i> relative to window <i>w</i>.
	/// </summary>
	/// <returns>The return value can be used to auto-release the pressed button. Example: <see cref="MRelease"/>.</returns>
	/// <inheritdoc cref="click(wnd, Coord, Coord, bool)"/>
	public static MRelease rightDown(wnd w, Coord x = default, Coord y = default, bool nonClient = false) {
		return clickEx(MButton.Right | MButton.Down, w, x, y, nonClient);
	}
	
	/// <summary>
	/// Right button down (press and don't release) at position <i>x y</i>.
	/// </summary>
	/// <returns>The return value can be used to auto-release the pressed button. Example: <see cref="MRelease"/>.</returns>
	/// <inheritdoc cref="click(Coord, Coord)"/>
	public static MRelease rightDown(Coord x, Coord y) {
		return clickEx(MButton.Right | MButton.Down, x, y);
	}
	
	/// <summary>
	/// Right button down (press and don't release).
	/// </summary>
	/// <returns>The return value can be used to auto-release the pressed button. Example: <see cref="MRelease"/>.</returns>
	/// <inheritdoc cref="click(bool)"/>
	public static MRelease rightDown(bool useLastXY = false) {
		return clickEx(MButton.Right | MButton.Down, useLastXY);
	}
	
	/// <summary>
	/// Right button up (release pressed button) at position <i>x y</i> relative to window <i>w</i>.
	/// </summary>
	/// <inheritdoc cref="click(wnd, Coord, Coord, bool)"/>
	public static void rightUp(wnd w, Coord x = default, Coord y = default, bool nonClient = false) {
		clickEx(MButton.Right | MButton.Up, w, x, y, nonClient);
	}
	
	/// <summary>
	/// Right button up (release pressed button) at position <i>x y</i>.
	/// </summary>
	/// <inheritdoc cref="click(Coord, Coord)"/>
	public static void rightUp(Coord x, Coord y) {
		clickEx(MButton.Right | MButton.Up, x, y);
	}
	
	/// <summary>
	/// Right button up (release pressed button).
	/// </summary>
	/// <inheritdoc cref="click(bool)"/>
	public static void rightUp(bool useLastXY = false) {
		clickEx(MButton.Right | MButton.Up, useLastXY);
	}
	
	/// <summary>
	/// Mouse wheel forward or backward.
	/// </summary>
	/// <param name="ticks">Number of wheel ticks forward (positive) or backward (negative).</param>
	/// <param name="horizontal">Horizontal wheel.</param>
	/// <remarks>
	/// Uses <see cref="opt.mouse"/>: <see cref="OMouse.ClickSleepFinally"/>.
	/// </remarks>
	/// <exception cref="InputDesktopException"></exception>
	public static void wheel(double ticks, bool horizontal = false) {
		bool neg = ticks < 0; if (neg) ticks = -ticks;
		ticks *= 120;
		while (ticks > 0) {
			short t = (short)(ticks < 30000 ? Math.Ceiling(ticks) : 30000); //max 250 full ticks
			_SendRaw(horizontal ? Api.IMFlags.HWheel : Api.IMFlags.Wheel, 0, 0, neg ? -t : t);
			ticks -= t;
		}
		_Sleep(opt.mouse.ClickSleepFinally);
	}
	
	//rejected. Not so often used. It's easy to move(); wheel().
	///// <summary>
	///// Mouse move and wheel.
	///// </summary>
	//public static void wheel(Coord x, Coord y, double ticks, bool horizontal = false) {
	//	move(x, y);
	//	wheel(ticks, horizontal);
	//}
	
	///// <summary>
	///// Mouse move and wheel.
	///// </summary>
	//public static void wheel(wnd w, Coord x, Coord y, double ticks, bool horizontal = false) {
	//	move(w, x, y);
	//	wheel(ticks, horizontal);
	//}
	
	/// <summary>
	/// Presses a mouse button in object <i>o1</i>, moves the mouse cursor to object <i>o2</i> and releases the button.
	/// </summary>
	/// <param name="o1">UI object (window, UI element, etc) where to press the mouse button.</param>
	/// <param name="o2">UI object where to release the mouse button.</param>
	/// <param name="x1">X offset in <i>o1</i> rectangle. Default: center.</param>
	/// <param name="y1">Y offset in <i>o1</i> rectangle. Default: center.</param>
	/// <param name="x2">X offset in <i>o2</i> rectangle. Default: center.</param>
	/// <param name="y2">Y offset in <i>o2</i> rectangle. Default: center.</param>
	/// <param name="button">Mouse button. Default: left.</param>
	/// <param name="mod">Modifier keys (<c>Ctrl</c> etc).</param>
	/// <param name="sleep">Wait this number of milliseconds after pressing the mouse button.</param>
	/// <param name="speed">The drag speed. See <see cref="OMouse.MoveSpeed"/>.</param>
	/// <inheritdoc cref="clickEx(MButton, MObject, Coord, Coord)" path="/exception"/>
	public static void drag(MObject o1, MObject o2, Coord x1 = default, Coord y1 = default, Coord x2 = default, Coord y2 = default, MButton button = MButton.Left, KMod mod = 0, int sleep = 0, int speed = 5) {
		if (o2.Value is bool useLastXY) { //get mouse position before moving to o1
			var p = _CoordToRelativeXY(x2, y2, useLastXY);
			o2 = default; x2 = p.x; y2 = p.y;
		}
		_Drag(o1, x1, y1, button, mod, sleep, speed, () => move(o2, x2, y2));
	}
	
	/// <summary>
	/// Presses a mouse button in object <i>obj</i>, moves the mouse cursor by offset <i>dx</i> <i>dy</i> and releases the button.
	/// </summary>
	/// <param name="obj">UI object (window, UI element, etc) where to press the mouse button.</param>
	/// <param name="x">X offset in <i>obj</i> rectangle. Default: center.</param>
	/// <param name="y">Y offset in <i>obj</i> rectangle. Default: center.</param>
	/// <param name="dx">X offset from the start position.</param>
	/// <param name="dy">Y offset from the start position.</param>
	/// <param name="button">Mouse button. Default: left.</param>
	/// <param name="mod">Modifier keys (<c>Ctrl</c> etc).</param>
	/// <param name="sleep">Wait this number of milliseconds after pressing the mouse button.</param>
	/// <param name="speed">The drag speed. See <see cref="OMouse.MoveSpeed"/>.</param>
	/// <inheritdoc cref="clickEx(MButton, MObject, Coord, Coord)" path="/exception"/>
	public static void drag(MObject obj, Coord x, Coord y, int dx, int dy, MButton button = MButton.Left, KMod mod = 0, int sleep = 0, int speed = 5) {
		_Drag(obj, x, y, button, mod, sleep, speed, () => moveBy(dx, dy));
	}
	
	/// <summary>
	/// Presses a mouse button in object <i>obj</i>, moves the mouse cursor using multiple recorded offsets and releases the button.
	/// </summary>
	/// <param name="obj">UI object (window, UI element, etc) where to press the mouse button.</param>
	/// <param name="x">X offset in <i>obj</i> rectangle. Default: center.</param>
	/// <param name="y">Y offset in <i>obj</i> rectangle. Default: center.</param>
	/// <param name="offsets">String containing multiple x y offsets from the start position. See <see cref="moveBy(string, double)"/>.</param>
	/// <param name="button">Mouse button. Default: left.</param>
	/// <param name="mod">Modifier keys (<c>Ctrl</c> etc).</param>
	/// <param name="sleep">Wait this number of milliseconds after pressing the mouse button.</param>
	/// <inheritdoc cref="clickEx(MButton, MObject, Coord, Coord)" path="/exception"/>
	public static void drag(MObject obj, Coord x, Coord y, string offsets, MButton button = MButton.Left, KMod mod = 0, int sleep = 0) {
		_Drag(obj, x, y, button, mod, sleep, 0, () => moveBy(offsets));
	}
	
	static void _Drag(MObject from, Coord x1, Coord y1, MButton button, KMod mod, int sleep, int speed, Action action) {
		if (button == 0) button = MButton.Left; else if (button != (button & (MButton.Left | MButton.Right | MButton.Middle | MButton.X1 | MButton.X2))) throw new ArgumentException(null, nameof(button));
		if ((uint)sleep >= 10000) throw new ArgumentException(null, nameof(sleep));
		if ((uint)speed >= 10000) throw new ArgumentException(null, nameof(speed));
		int speed0 = opt.mouse.MoveSpeed;
		bool isMod = false, isButton = false;
		try {
			clickEx(button | MButton.Down, from, x1, y1);
			isButton = true;
			
			if (sleep > 0) wait.ms(sleep);
			
			_SendMod(true); //note: after button down. If before, it could eg Ctrl+select multiple objects instead of one.
			isMod = true;
			
			opt.mouse.MoveSpeed = speed;
			
			action();
		}
		finally {
			if (isButton) clickEx(button | MButton.Up, useLastXY: true);
			opt.mouse.MoveSpeed = speed0;
			if (isMod) _SendMod(false);
		}
		
		void _SendMod(bool down) {
			if (mod == 0) return;
			var k = new keys(opt.key);
			if (mod.Has(KMod.Ctrl)) k.AddKey(KKey.Ctrl, down);
			if (mod.Has(KMod.Shift)) k.AddKey(KKey.Shift, down);
			if (mod.Has(KMod.Alt)) k.AddKey(KKey.Alt, down);
			if (mod.Has(KMod.Win)) k.AddKey(KKey.Win, down);
			k.SendNow(); //and sleeps opt.key.SleepFinally (default 10)
		}
	}
	
	//not used
	///// <summary>
	///// Releases mouse buttons pressed by this thread (<c>t_pressedButtons</c>).
	///// </summary>
	///// <param name="p">If not <c>null</c>, and XY is different, moves to this point. Used for reliability.</param>
	//static void _ReleaseButtons(POINT? p = null)
	//{
	//	var b = t_pressedButtons;
	//	if(0 != (b & MButtons.Left)) _Click(MButton.Left | MButton.Up, p);
	//	if(0 != (b & MButtons.Right)) _Click(MButton.Right | MButton.Up, p);
	//	if(0 != (b & MButtons.Middle)) _Click(MButton.Middle | MButton.Up, p);
	//	if(0 != (b & MButtons.X1)) _Click(MButton.X1 | MButton.Up, p);
	//	if(0 != (b & MButtons.X2)) _Click(MButton.X2 | MButton.Up, p);
	//}
	//rejected: finally release script-pressed buttons, especially on exception. Instead let use code: using(mouse.leftDown(...)), it auto-releases pressed button.
	
	/// <summary>
	/// Returns <c>true</c> if some mouse buttons are pressed.
	/// </summary>
	/// <param name="buttons">Return <c>true</c> if some of these buttons are down. Default: any.</param>
	/// <remarks>
	/// Uses API <ms>GetAsyncKeyState</ms>.
	/// When processing user input in UI code (forms, WPF), instead use class <see cref="keys.gui"/> or .NET functions. They use API <ms>GetKeyState</ms>.
	/// When mouse left and right buttons are swapped, gets logical state, not physical.
	/// </remarks>
	/// <seealso cref="waitForNoButtonsPressed"/>
	public static bool isPressed(MButtons buttons = MButtons.Left | MButtons.Right | MButtons.Middle | MButtons.X1 | MButtons.X2) {
		if (0 != (buttons & MButtons.Left) && keys.isPressed(KKey.MouseLeft)) return true;
		if (0 != (buttons & MButtons.Right) && keys.isPressed(KKey.MouseRight)) return true;
		if (0 != (buttons & MButtons.Middle) && keys.isPressed(KKey.MouseMiddle)) return true;
		if (0 != (buttons & MButtons.X1) && keys.isPressed(KKey.MouseX1)) return true;
		if (0 != (buttons & MButtons.X2) && keys.isPressed(KKey.MouseX2)) return true;
		return false;
	}
	
	//rejected: not useful.
	///// <summary>
	///// Returns a value indicating which mouse buttons are pressed.
	///// </summary>
	///// <param name="buttons">Check only these buttons. Default: all.</param>
	///// <remarks>See <see cref="IsPressed"/>.</remarks>
	//public static MButtons buttons(MButtons buttons = MButtons.Left | MButtons.Right | MButtons.Middle | MButtons.X1 | MButtons.X2)
	//{
	//	MButtons R = 0;
	//	if(0 != (buttons & MButtons.Left) && keys.isKey(KKey.MouseLeft)) R |= MButtons.Left;
	//	if(0 != (buttons & MButtons.Right) && keys.isKey(KKey.MouseRight)) R |= MButtons.Right;
	//	if(0 != (buttons & MButtons.Middle) && keys.isKey(KKey.MouseMiddle)) R |= MButtons.Middle;
	//	if(0 != (buttons & MButtons.X1) && keys.isKey(KKey.MouseX1)) return R |= MButtons.X1;
	//	if(0 != (buttons & MButtons.X2) && keys.isKey(KKey.MouseX2)) return R |= MButtons.X2;
	//	return R;
	//}
	
	//rejected: rarely used. Can use IsPressed.
	///// <summary>
	///// Returns <c>true</c> if the left mouse button is pressed.
	///// </summary>
	///// <remarks>See <see cref="IsPressed"/>.</remarks>
	//public static bool isLeft => keys.isPressed(KKey.MouseLeft);
	
	///// <summary>
	///// Returns <c>true</c> if the right mouse button is pressed.
	///// </summary>
	///// <remarks>See <see cref="IsPressed"/>.</remarks>
	//public static bool isRight => keys.isPressed(KKey.MouseRight);
	
	/// <summary>
	/// Waits while some mouse buttons are pressed. See <see cref="isPressed"/>.
	/// </summary>
	/// <param name="timeout">Timeout, seconds. Can be 0 (infinite), >0 (exception) or &lt;0 (no exception). More info: [](xref:wait_timeout). Default 0.</param>
	/// <param name="buttons">Wait only for these buttons. Default - all.</param>
	/// <returns>Returns <c>true</c>. On timeout returns <c>false</c> if <i>timeout</i> is negative; else exception.</returns>
	/// <exception cref="TimeoutException"><i>timeout</i> time has expired (if > 0).</exception>
	/// <seealso cref="keys.waitForNoModifierKeysAndMouseButtons"/>
	public static bool waitForNoButtonsPressed(Seconds timeout = default, MButtons buttons = MButtons.Left | MButtons.Right | MButtons.Middle | MButtons.X1 | MButtons.X2) {
		return keys.waitForNoModifierKeysAndMouseButtons(timeout, 0, buttons);
	}
	
	/// <summary>
	/// Waits while some buttons are pressed, except those pressed by a <see cref="mouse"/> class function in this thread.
	/// Does nothing if option <c>Relaxed</c> is <c>true</c>.
	/// </summary>
	internal static void WaitForNoButtonsPressed_() {
		//not public, because we have WaitForNoButtonsPressed, which is unaware about script-pressed buttons, and don't need this awareness because the script author knows what is pressed by that script
		
		if (opt.mouse.Relaxed) return;
		var mb = (MButtons.Left | MButtons.Right | MButtons.Middle | MButtons.X1 | MButtons.X2) & ~t_pressedButtons;
		if (waitForNoButtonsPressed(-2, mb)) return; //initially was 5 s, but users don't wait so long, and then wonder why it does not work. It's documented in OMouse.Relaxed.
		print.warning("The mouse-move function waits because a mouse button is pressed by the user. This is to prevent unintended drag-and-drop. To disable this in the script: <code>opt.mouse.Relaxed = true;</code>");
		waitForNoButtonsPressed(0, mb);
	}
	
	/// <summary>
	/// Waits for button-down or button-up event of the specified mouse button or buttons.
	/// </summary>
	/// <returns>Returns <c>true</c>. On timeout returns <c>false</c> if <i>timeout</i> is negative; else exception.</returns>
	/// <param name="timeout">Timeout, seconds. Can be 0 (infinite), >0 (exception) or &lt;0 (no exception). More info: [](xref:wait_timeout).</param>
	/// <param name="button">Mouse button. If several buttons specified, waits for any of them.</param>
	/// <param name="up">Wait for button-up event.</param>
	/// <param name="block">Make the event invisible to other apps. If <i>up</i> is <c>true</c>, makes the down event invisible too, if it comes while waiting for the up event.</param>
	/// <exception cref="ArgumentException"><i>button</i> is 0.</exception>
	/// <exception cref="TimeoutException"><i>timeout</i> time has expired (if > 0).</exception>
	/// <remarks>
	/// Unlike <see cref="waitForNoButtonsPressed"/>, waits for down or up event, not for button state.
	/// Uses low-level mouse hook.
	/// Ignores mouse events injected by functions of this library.
	/// </remarks>
	/// <example>
	/// <code><![CDATA[
	/// mouse.waitForClick(0, MButtons.Left, up: true, block: false);
	/// print.it("click");
	/// ]]></code>
	/// </example>
	public static bool waitForClick(Seconds timeout, MButtons button, bool up = false, bool block = false) {
		if (button == 0) throw new ArgumentException();
		return 0 != _WaitForClick(timeout, button, up, block);
	}
	
	/// <summary>
	/// Waits for button-down or button-up event of any mouse button, and gets the button code.
	/// </summary>
	/// <returns>Returns the button code. On timeout returns 0 if <i>timeout</i> is negative; else exception.</returns>
	/// <exception cref="TimeoutException"><i>timeout</i> time has expired (if > 0).</exception>
	/// <example>
	/// <code><![CDATA[
	/// var button = mouse.waitForClick(0, up: true, block: true);
	/// print.it(button);
	/// ]]></code>
	/// </example>
	/// <inheritdoc cref="waitForClick(Seconds, MButtons, bool, bool)" path="/param"/>
	public static MButtons waitForClick(Seconds timeout, bool up = false, bool block = false) {
		return _WaitForClick(timeout, 0, up, block);
	}
	
	static MButtons _WaitForClick(Seconds timeout, MButtons button, bool up, bool block) {
		//info: this and related functions use similar code as keys._WaitForKey.
		
		MButtons R = 0;
		using (WindowsHook.Mouse(x => {
			MButtons b = 0;
			switch (x.Event) {
			case HookData.MouseEvent.LeftButton: b = MButtons.Left; break;
			case HookData.MouseEvent.RightButton: b = MButtons.Right; break;
			case HookData.MouseEvent.MiddleButton: b = MButtons.Middle; break;
			case HookData.MouseEvent.X1Button: b = MButtons.X1; break;
			case HookData.MouseEvent.X2Button: b = MButtons.X2; break;
			}
			if (b == 0) return;
			if (button != 0 && !button.Has(b)) return;
			if (x.IsButtonUp != up) {
				if (up && block) { //button down when we are waiting for up. If block, now block down too.
					if (button == 0) button = b;
					x.BlockEvent();
				}
				return;
			}
			R = b;
			if (block) x.BlockEvent();
		})) wait.doEventsUntil(timeout, () => R != 0);
		
		return R;
	}
	//FUTURE:
	//	waitForWheel(Seconds timeout, bool? forward, bool block = false)
	//	waitForMouseMove, waitForMouseStop.
	//	In QM2 these functions were created because somebody asked, but I don't use.
	
	/// <summary>
	/// Waits for a standard mouse cursor (pointer) visible.
	/// </summary>
	/// <param name="timeout">Timeout, seconds. Can be 0 (infinite), >0 (exception) or &lt;0 (no exception). More info: [](xref:wait_timeout).</param>
	/// <param name="cursor">Id of a standard cursor.</param>
	/// <param name="not">Wait until this cursor disappears.</param>
	/// <returns>Returns <c>true</c>. On timeout returns <c>false</c> if <i>timeout</i> is negative; else exception.</returns>
	/// <exception cref="TimeoutException"><i>timeout</i> time has expired (if > 0).</exception>
	public static bool waitForCursor(Seconds timeout, MCursor cursor, bool not = false) {
		IntPtr hcur = Api.LoadCursor(default, cursor);
		if (hcur == default) throw new AuException(0, "*load cursor");
		
		return wait.until(timeout, () => (MouseCursor.GetCurrentVisibleCursor(out var c) && c == hcur) ^ not);
	}
	
	/// <summary>
	/// Waits for a nonstandard mouse cursor (pointer) visible.
	/// </summary>
	/// <param name="timeout">Timeout, seconds. Can be 0 (infinite), >0 (exception) or &lt;0 (no exception). More info: [](xref:wait_timeout).</param>
	/// <param name="cursorHash">Cursor hash, as returned by <see cref="MouseCursor.Hash"/>.</param>
	/// <param name="not">Wait until this cursor disappears.</param>
	/// <returns>Returns <c>true</c>. On timeout returns <c>false</c> if <i>timeout</i> is negative; else exception.</returns>
	/// <exception cref="TimeoutException"><i>timeout</i> time has expired (if > 0).</exception>
	public static bool waitForCursor(Seconds timeout, long cursorHash, bool not = false) {
		if (cursorHash == 0) throw new ArgumentException();
		return wait.until(timeout, () => (MouseCursor.GetCurrentVisibleCursor(out var c) && MouseCursor.Hash(c) == cursorHash) ^ not);
	}
	//TODO2: example. Cookbook contains example, but no info how to get the hash (MouseCursor.GetCurrentVisibleCursor + MouseCursor.Hash). Maybe even need a tool.
	//TODO2: wait for any in list.
	
	/// <summary>
	/// Posts mouse-click messages to the window.
	/// </summary>
	/// <param name="w">Window or control.</param>
	/// <param name="x">X coordinate in <i>w</i> client area or <i>rect</i>. Default - center. Examples: <c>10</c>, <c>^10</c> (reverse), <c>.5f</c> (fraction).</param>
	/// <param name="y">Y coordinate in <i>w</i> client area or <i>rect</i>. Default - center.</param>
	/// <param name="button">Can specify the left (default), right or middle button. Also flag for double-click, press or release.</param>
	/// <param name="rect">A rectangle in <i>w</i> client area. If <c>null</c> (default), <i>x y</i> are relative to the client area.</param>
	/// <exception cref="AuWndException">Invalid window.</exception>
	/// <exception cref="ArgumentException">Unsupported button specified.</exception>
	/// <remarks>
	/// Does not move the mouse.
	/// Does not wait until the target application finishes processing the message.
	/// Works not with all windows.
	/// </remarks>
	public static void postClick(wnd w, Coord x = default, Coord y = default, MButton button = MButton.Left, RECT? rect = null) {
		RECT r;
		if (rect != null) {
			r = rect.Value;
			w.ThrowIfInvalid();
		} else {
			if (!w.GetClientRect(out r)) w.ThrowUseNative();
		}
		PostClick_(w, r, x, y, button);
	}
	
	internal static void PostClick_(wnd w, RECT r, Coord x = default, Coord y = default, MButton button = MButton.Left) {
		MButton mask = MButton.Down | MButton.Up | MButton.DoubleClick, b = button & ~mask, dud = button & mask;
		if (b == 0) b = MButton.Left;
		int m = b switch {
			MButton.Left => Api.WM_LBUTTONDOWN,
			MButton.Right => Api.WM_RBUTTONDOWN,
			MButton.Middle => Api.WM_MBUTTONDOWN,
			_ => throw new ArgumentException("supported buttons: left, right, middle")
		};
		if (dud is not (0 or MButton.Down or MButton.Up or MButton.DoubleClick)) throw new ArgumentException();
		
		POINT point = Coord.NormalizeInRect(x, y, r, centerIfEmpty: true);
		
		//if the control is mouse-transparent, use its ancestor. Example: the color selection controls in the classic color dialog.
		if (w.HasStyle(WS.CHILD)) {
			var w2 = w; var ps = point; w.MapClientToScreen(ref ps);
			while (!w2.Is0 && Api.HTTRANSPARENT == w2.Send(Api.WM_NCHITTEST, 0, Math2.MakeLparam(ps))) w2 = w2.Get.DirectParent;
			if (w2 != w && !w2.Is0) { w.MapClientToClientOf(w2, ref point); w = w2; }
		}
		
		using var workaround = new ButtonPostClickWorkaround_(w);
		
		nint xy = Math2.MakeLparam(point);
		nint mk = 0; if (keys.isCtrl) mk |= Api.MK_CONTROL; if (keys.isShift) mk |= Api.MK_SHIFT;
		nint mk1 = mk; if (dud != MButton.Up) mk1 |= b switch { MButton.Left => Api.MK_LBUTTON, MButton.Right => Api.MK_RBUTTON, _ => Api.MK_MBUTTON };
		if (dud != MButton.Up) w.Post(m, mk1, xy);
		if (dud != MButton.Down) {
			w.Post(Api.WM_MOUSEMOVE, mk1, xy);
			w.Post(m + 1, mk, xy);
		}
		if (dud == MButton.DoubleClick) {
			w.Post(m + 2, mk1, xy);
			w.Post(m + 1, mk, xy);
		}
		//_MinimalSleep(); //don't need. Eg elm.Invoke() does not wait too.
		
		//never mind: support nonclient (WM_NCRBUTTONDOWN etc)
	}
	
	/// <summary>
	/// Workaround for the documented <c>BM_CLICK</c>/<c>WM_LBUTTONDOWN</c> bug of classic button controls: randomly fails if inactive window.
	/// If <i>c</i> is a button in a dialog box, posts <c>WM_ACTIVATE</c> messages to the dialog box.
	/// </summary>
	internal ref struct ButtonPostClickWorkaround_ {
		readonly wnd _w;
		
		public ButtonPostClickWorkaround_(wnd c) {
			//this func is fast, but slower is elm.wndcontainer (to get c) and JIT
			_w = default;
			var w = c.Window; //not c.DirectParent. Eg in taskdialog it is not #32770. The postclick/invoke worked without this workaround in all tested top-level non-#32770 windows, with or without an intermediate #32770.
			if (w != c && !w.IsActive && w.ClassNameIs("#32770") && c.CommonControlType == WControlType.Button) {
				w.Post(Api.WM_ACTIVATE, 1);
				_w = w;
			}
		}
		
		public void Dispose() {
			if (!_w.Is0) _w.Post(Api.WM_ACTIVATE);
		}
	}
}


================================================
FILE: Au/Input/mouse_types.cs
================================================
namespace Au.Types;

/// <summary>
/// <i>button</i> parameter type for <see cref="mouse.clickEx(MButton, bool)"/> and similar functions.
/// </summary>
/// <remarks>
/// There are two groups of values:
/// 1. Button (<c>Left</c>, <c>Right</c>, <c>Middle</c>, <c>X1</c>, <c>X2</c>). Default or 0: <c>Left</c>.
/// 2. Action (<c>Down</c>, <c>Up</c>, <c>DoubleClick</c>). Default: click.
/// 
/// Multiple values from the same group cannot be combined. For example <c>Left|Right</c> is invalid.
/// Values from different groups can be combined. For example <c>Right|Down</c>.
/// </remarks>
[Flags]
public enum MButton {
	/// <summary>The left button.</summary>
	Left = 1,
	
	/// <summary>The right button.</summary>
	Right = 2,
	
	/// <summary>The middle button.</summary>
	Middle = 4,
	
	/// <summary>The 4-th button.</summary>
	X1 = 8,
	
	/// <summary>The 5-th button.</summary>
	X2 = 16,
	
	//rejected: not necessary. Can be confusing.
	///// <summary>
	///// Click (press and release).
	///// This is default. Value 0.
	///// </summary>
	//Click = 0,
	
	/// <summary>(flag) Press and don't release.</summary>
	Down = 32,
	
	/// <summary>(flag) Don't press, only release.</summary>
	Up = 64,
	
	/// <summary>(flag) Double-click.</summary>
	DoubleClick = 128,
}

/// <summary>
/// Flags for mouse buttons.
/// Used with functions that check mouse button states (pressed or not).
/// </summary>
/// <remarks>
/// The values are the same as <see cref="System.Windows.Forms.MouseButtons"/>, therefore can be cast to/from.
/// </remarks>
[Flags]
public enum MButtons {
	/// <summary>The left button.</summary>
	Left = 0x00100000,
	
	/// <summary>The right button.</summary>
	Right = 0x00200000,
	
	/// <summary>The middle button.</summary>
	Middle = 0x00400000,
	
	/// <summary>The 4-th button.</summary>
	X1 = 0x00800000,
	
	/// <summary>The 5-th button.</summary>
	X2 = 0x01000000,
}

/// <summary>
/// At the end of <c>using(...) { ... }</c> block releases mouse buttons pressed by the function that returned this variable. See example.
/// </summary>
/// <example>
/// Drag and drop: start at x=8 y=8, move 20 pixels down, drop.
/// <code><![CDATA[
/// using(mouse.leftDown(w, 8, 8)) mouse.moveBy(0, 20); //the button is auto-released when the 'using' code block ends
/// ]]></code>
/// </example>
public struct MRelease : IDisposable {
	MButton _buttons;
	///
	public static implicit operator MRelease(MButton b) => new MRelease() { _buttons = b };
	
	/// <summary>
	/// Releases mouse buttons pressed by the function that returned this variable.
	/// </summary>
	public void Dispose() {
		if (0 == (_buttons & MButton.Down)) return;
		if (0 != (_buttons & MButton.Left)) mouse.clickEx(MButton.Left | MButton.Up, true);
		if (0 != (_buttons & MButton.Right)) mouse.clickEx(MButton.Right | MButton.Up, true);
		if (0 != (_buttons & MButton.Middle)) mouse.clickEx(MButton.Middle | MButton.Up, true);
		if (0 != (_buttons & MButton.X1)) mouse.clickEx(MButton.X1 | MButton.Up, true);
		if (0 != (_buttons & MButton.X2)) mouse.clickEx(MButton.X2 | MButton.Up, true);
	}
}

/// <summary>
/// Standard cursor ids.
/// Used with <see cref="mouse.waitForCursor(Seconds, MCursor, bool)"/>.
/// </summary>
public enum MCursor {
	/// <summary>Standard arrow.</summary>
	Arrow = 32512,
	
	/// <summary>I-beam (text editing).</summary>
	IBeam = 32513,
	
	/// <summary>Hourglass.</summary>
	Wait = 32514,
	
	/// <summary>Crosshair.</summary>
	Cross = 32515,
	
	/// <summary>Vertical arrow.</summary>
	UpArrow = 32516,
	
	/// <summary>Double-pointed arrow pointing northwest and southeast.</summary>
	SizeNWSE = 32642,
	
	/// <summary>Double-pointed arrow pointing northeast and southwest.</summary>
	SizeNESW = 32643,
	
	/// <summary>Double-pointed arrow pointing west and east.</summary>
	SizeWE = 32644,
	
	/// <summary>Double-pointed arrow pointing north and south.</summary>
	SizeNS = 32645,
	
	/// <summary>Four-pointed arrow pointing north, south, east, and west.</summary>
	SizeAll = 32646,
	
	/// <summary>Slashed circle.</summary>
	No = 32648,
	
	/// <summary>Hand.</summary>
	Hand = 32649,
	
	/// <summary>Standard arrow and small hourglass.</summary>
	AppStarting = 32650,
	
	/// <summary>Arrow and question mark.</summary>
	Help = 32651,
}

/// <summary>
/// This type is used for parameters of <see cref="mouse"/> functions that accept multiple types of UI objects (window, UI element, screen, etc).
/// </summary>
/// <remarks>
/// Has implicit conversions from <see cref="wnd"/>, <see cref="elm"/>, <see cref="uiimage"/>, <see cref="screen"/>, <see cref="RECT"/> and <c>bool</c> (relative coordinates).
/// Also has static functions to specify more parameters.
/// </remarks>
public struct MObject {
	object _o;
	MObject(object o) => _o = o;
	
	///
	public object Value => _o;
	
	/// <summary>
	/// Allows to specify coordinates in the client area of a window or control.
	/// </summary>
	/// <exception cref="AuWndException">The window handle is 0.</exception>
	/// <seealso cref="Window(wnd, bool)"/>
	public static implicit operator MObject(wnd w) { w.ThrowIf0(); return new(w); }
	
	/// <summary>
	/// Allows to specify coordinates in the rectangle of a UI element.
	/// </summary>
	/// <exception cref="ArgumentNullException"/>
	public static implicit operator MObject(elm e) => new(Not_.NullRet(e));
	
	/// <summary>
	/// Allows to specify coordinates in the rectangle of an image found in a window etc.
	/// </summary>
	/// <exception cref="ArgumentNullException"/>
	public static implicit operator MObject(uiimage i) => new(Not_.NullRet(i));
	
	/// <summary>
	/// Allows to specify coordinates in a rectangle anywhere on screen.
	/// </summary>
	/// <seealso cref="RectInWindow(wnd, RECT)"/>
	public static implicit operator MObject(RECT r) => new(r);
	
	/// <summary>
	/// Allows to specify coordinates in a screen.
	/// </summary>
	/// <seealso cref="Screen(screen, bool)"/>
	public static implicit operator MObject(screen s) => new((s, false));
	
	/// <summary>
	/// Allows to specify coordinates relative to <see cref="mouse.xy"/> or <see cref="mouse.lastXY"/>.
	/// </summary>
	public static implicit operator MObject(bool useLastXY) => new(useLastXY);
	
	/// <summary>
	/// Allows to specify coordinates in a screen, either in the work area or in entire rectangle.
	/// </summary>
	/// <example>
	/// <code><![CDATA[
	/// mouse.move(MObject.Screen(screen.primary, true), ^10, ^10); //near the bottom-right corner of the work area of the primary screen
	/// ]]></code>
	/// </example>
	public static MObject Screen(screen s, bool workArea) => new((s, workArea));
	
	/// <summary>
	/// Allows to specify coordinates in a window or control, either in the client area or in entire rectangle.
	/// </summary>
	/// <exception cref="AuWndException">The window handle is 0.</exception>
	public static MObject Window(wnd w, bool nonClient) { w.ThrowIf0(); return new((w, true)); }
	
	/// <summary>
	/// Allows to specify coordinates in a rectangle in the client area of a window or control.
	/// </summary>
	/// <exception cref="AuWndException">The window handle is 0.</exception>
	public static MObject RectInWindow(wnd w, RECT r) { w.ThrowIf0(); return new((w, r)); }
}


================================================
FILE: Au/Internal/ActCtx_.cs
================================================
namespace Au.More;

/// <summary>
/// Activates our manifest which tells to use <c>comctl32.dll</c> version 6.
/// The manifest is embedded in this dll, resource id 2.
/// </summary>
internal sealed class ActCtx_ : IDisposable {
	IntPtr _cookie;
	
	public static ActCtx_ Activate() {
		if (s_actCtx.Handle == default || !Api.ActivateActCtx(s_actCtx.Handle, out var cookie)) return default;
		return new ActCtx_() { _cookie = cookie };
	}
	
	public void Dispose() {
		if (_cookie != default) {
			Api.DeactivateActCtx(0, _cookie);
			_cookie = default;
		}
	}
	
	static _ActCtx s_actCtx = new _ActCtx();
	
	class _ActCtx {
		public IntPtr Handle;
		
		public _ActCtx() {
			Api.ACTCTX a = default;
			a.cbSize = Api.SizeOf<Api.ACTCTX>();
#if true //the manifest is in AuCpp.dll
			a.dwFlags = Api.ACTCTX_FLAG_RESOURCE_NAME_VALID | Api.ACTCTX_FLAG_HMODULE_VALID;
			a.hModule = Cpp.Cpp_ModuleHandle();
#else //old code. The manifest was in Au.dll. If <PublishSingleFile>, Location returns "".
				a.dwFlags = Api.ACTCTX_FLAG_RESOURCE_NAME_VALID;
				a.lpSource = Assembly.GetExecutingAssembly().Location;
#endif
			a.lpResourceName = (IntPtr)2;
			
			var h = Api.CreateActCtx(a);
			if (h != (IntPtr)(-1)) Handle = h;
		}
		
		~_ActCtx() {
			if (Handle != default) {
				Api.ReleaseActCtx(Handle);
				Handle = default;
			}
		}
	}
}


================================================
FILE: Au/Internal/ArrayBuilder_.cs
================================================
//CONSIDER: System.Buffers.ArrayPool<T>.

namespace Au.More;

/// <summary>
/// Like <c>List</c> or <c>StringBuilder</c>, used as a temporary variable-size array to create final fixed-size array.
/// To avoid much garbage (and many reallocations when growing), uses native memory heap. See <see cref="MemoryUtil"/>.
/// Must be explicitly disposed to free the native memory. Does not have a finalizer because is struct (to avoid garbage).
/// Does not support reference types. Does not call <c>T.Dispose</c>.
/// </summary>
//[DebuggerStepThrough]
internal unsafe struct ArrayBuilder_<T> : IDisposable where T : unmanaged {
	T* _p;
	int _len, _cap;
	
	static int s_minCap;
	
	static ArrayBuilder_() {
		var r = 16384 / sizeof(T); //above 16384 the memory allocation API become >=2 times slower
		if (r > 500) r = 500; else if (r < 8) r = 8;
		s_minCap = r;
		
		//info: 500 is optimal for getting all top-level windows (and invisible) as ArrayBuilder_<wnd>.
		//	Normally there are 200-400 windows on my PC, rarely > 500.
	}
	
	public void Dispose() => Free();
	
	/// <summary>
	/// Gets array memory address (address of element 0).
	/// </summary>
	public T* Ptr => _p;
	
	/// <summary>
	/// Gets the number of elements.
	/// </summary>
	public int Count => _len;
	
	/// <summary>
	/// Gets the number of bytes in the array (<c>Count*sizeof(T)</c>).
	/// </summary>
	public int ByteCount => _len * sizeof(T);
	
	/// <summary>
	/// Gets or sets the total number of elements (not bytes) the internal memory can hold without resizing.
	/// </summary>
	/// <exception cref="ArgumentOutOfRangeException">(the <c>set</c> function) value less than <c>Count</c>. Instead use <c>ReAlloc</c> or <c>Free</c>.</exception>
	public int Capacity {
		get => _cap;
		set {
			if (value != _cap) {
				if (value < _len) throw new ArgumentOutOfRangeException();
				MemoryUtil.ReAlloc(ref _p, value);
				_cap = value;
			}
		}
	}
	
	/// <summary>
	/// Allocates count elements. Sets <c>Count=count</c>.
	/// Frees previously allocated memory.
	/// Returns memory address (address of element 0).
	/// </summary>
	/// <param name="count">Element count.</param>
	/// <param name="zeroInit">Set all bytes = 0. If <c>false</c>, the memory is uninitialized, ie random byte values. Default <c>true</c>. Slower when <c>true</c>.</param>
	/// <param name="noExtra">Set <c>Capacity</c> = count. If <c>false</c>, allocates more if count is less than the minimal capacity for this type.</param>
	public T* Alloc(int count, bool zeroInit = true, bool noExtra = false) {
		if (_cap != 0) Free();
		int cap = count; if (cap < s_minCap && !noExtra) cap = s_minCap;
		_p = MemoryUtil.Alloc<T>(cap, zeroInit);
		_cap = cap; _len = count;
		return _p;
	}
	
	/// <summary>
	/// Adds or removes elements at the end. Sets <c>Count=count</c>.
	/// Preserves <c>Math.Min(Count, count)</c> existing elements.
	/// Returns memory address (address of element 0).
	/// </summary>
	/// <param name="count">New element count.</param>
	/// <param name="zeroInit">Set all added bytes = 0. If <c>false</c>, the added memory is uninitialized, ie random byte values. Default <c>true</c>. Slower when <c>true</c>.</param>
	/// <param name="noExtra">Set <c>Capacity = count</c>. If <c>false</c>, allocates more if count is less than the minimal capacity for this type.</param>
	/// <remarks>
	/// The new memory usually is at a new location. The preserved elements are copied there.
	/// Sets <c>Count=count</c>. To allocate more memory without changing <c>Count</c>, change <c>Capacity</c> instead.
	/// </remarks>
	public T* ReAlloc(int count, bool zeroInit = true, bool noExtra = false) {
		int cap = count; if (cap < s_minCap && !noExtra) cap = s_minCap;
		MemoryUtil.ReAlloc(ref _p, cap, zeroInit);
		_cap = cap; _len = count;
		return _p;
	}
	
	/// <summary>
	/// Frees memory. Sets <c>Count</c> and <c>Capacity</c> = 0.
	/// </summary>
	public void Free() {
		if (_cap == 0) return;
		_len = _cap = 0;
		var p = _p; _p = null;
		MemoryUtil.Free(p);
	}
	
	/// <summary>
	/// Adds one element.
	/// The same as <c>Add</c>, but uses <c>in</c>. Use to avoid copying values of big types.
	/// </summary>
	public void AddR(in T value) {
		if (_len == _cap) _EnsureCapacity();
		_p[_len++] = value;
	}
	
	/// <summary>
	/// Adds one element.
	/// </summary>
	public void Add(T value) {
		if (_len == _cap) _EnsureCapacity();
		_p[_len++] = value;
	}
	
	/// <summary>
	/// Adds one zero-inited element and returns its reference.
	/// </summary>
	public ref T Add() {
		if (_len == _cap) _EnsureCapacity();
		ref T r = ref _p[_len];
		r = default;
		_len++;
		return ref r;
	}
	
	/// <summary>
	/// <c>Capacity = Math.Max(_cap * 2, s_minCap)</c>.
	/// </summary>
	void _EnsureCapacity() {
		Capacity = Math.Max(_cap * 2, s_minCap);
	}
	
	/// <summary>
	/// Gets element reference.
	/// </summary>
	/// <param name="i">Element index.</param>
	/// <exception cref="IndexOutOfRangeException"></exception>
	public ref T this[int i] {
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get {
			if ((uint)i >= (uint)_len) _ThrowBadIndex();
			return ref _p[i];
		}
	}
	
	[MethodImpl(MethodImplOptions.NoInlining)]
	static void _ThrowBadIndex() {
		throw new IndexOutOfRangeException();
	}
	
	/// <summary>
	/// Copies elements to a new managed array.
	/// </summary>
	public T[] ToArray() {
		if (_len == 0) return [];
		var r = new T[_len];
		for (int i = 0; i < r.Length; i++) r[i] = _p[i];
		return r;
	}
}


================================================
FILE: Au/Internal/AssemblyUtil_.cs
================================================
using System.Runtime.Loader;

namespace Au.More;

/// <summary>
/// Assembly functions.
/// </summary>
internal static class AssemblyUtil_ {
	public static Assembly GetEntryAssembly() {
		var r = Assembly.GetEntryAssembly();
		if (r == null) {
			//info: null in miniProgram on AssemblyLoadContext.Default.Resolving event when the script is like:
			//	'class Program : SomeType { static Main() { } }' where SomeType is the assembly being resolved.

			//Debug_.Print("Assembly.GetEntryAssembly null");
			if (script.role == SRole.MiniProgram) {
				var s = "~" + script.name;
				foreach (var v in AssemblyLoadContext.Default.Assemblies) if (v.GetName().Name == s) return v;
			}
		}
		return r;
	}

	/// <summary>
	/// Returns <c>true</c> if the build configuration of the assembly is Debug. Returns <c>false</c> if Release (optimized).
	/// </summary>
	/// <remarks>
	/// Returns <c>true</c> if the assembly has <see cref="DebuggableAttribute"/> and its <c>IsJITTrackingEnabled</c> is <c>true</c>.
	/// </remarks>
	public static bool IsDebug(Assembly a) => a?.GetCustomAttribute<DebuggableAttribute>()?.IsJITTrackingEnabled ?? false;
	//IsJITTrackingEnabled depends on config, but not 100% reliable, eg may be changed explicitly in source code (maybe IsJITOptimizerDisabled too).
	//IsJITOptimizerDisabled depends on 'Optimize code' checkbox in project Properties, regardless of config.
	//note: GetEntryAssembly returns null in func called by host through coreclr_create_delegate.

	/// <summary>
	/// Returns flags for loaded assemblies: 1 <c>System.Windows.Forms</c>, 2 <c>WindowsBase</c> (WPF).
	/// </summary>
	internal static int IsLoadedWinformsWpf() {
		if (s_isLoadedWinformsWpf == 0) {
			lock ("zjm5R47f7UOmgyHUVZaf1w") {
				if (s_isLoadedWinformsWpf == 0) {
					var ad = AppDomain.CurrentDomain;
					var a = ad.GetAssemblies();
					foreach (var v in a) {
						_FlagFromName(v);
						if (s_isLoadedWinformsWpf == 3) return 3;
					}
					ad.AssemblyLoad += (_, x) => _FlagFromName(x.LoadedAssembly);
					s_isLoadedWinformsWpf |= 0x100;
				}
			}
		}

		return s_isLoadedWinformsWpf & 3;

		void _FlagFromName(Assembly a) {
			string s = a.FullName; //fast, cached. GetName can be slow because not cached.
			if (0 == (s_isLoadedWinformsWpf & 1) && s.Starts("System.Windows.Forms,")) s_isLoadedWinformsWpf |= 1;
			else if (0 == (s_isLoadedWinformsWpf & 2) && s.Starts("WindowsBase,")) s_isLoadedWinformsWpf |= 2;
		}
	}
	static volatile int s_isLoadedWinformsWpf;
}


================================================
FILE: Au/Internal/AttachThreadInput_.cs
================================================
namespace Au.More;

/// <summary>
/// Calls API <ms>AttachThreadInput</ms> to attach/detach thread input.
/// Constructor attaches thread input of this thread to that of the specified thread. <c>Dispose</c> detaches.
/// </summary>
internal struct AttachThreadInput_ : IDisposable {
	int _tidThis, _tidAttach;
	
	/// <summary>
	/// Attaches thread input of this thread to that of the specified thread.
	/// </summary>
	public AttachThreadInput_(int idThreadAttachTo, out bool succeeded) {
		_tidThis = Api.GetCurrentThreadId();
		succeeded = Api.AttachThreadInput(_tidThis, idThreadAttachTo, true);
		_tidAttach = succeeded ? idThreadAttachTo : 0;
	}
	
	/// <summary>
	/// Detaches thread input.
	/// </summary>
	public void Dispose() {
		if (_tidAttach != 0) {
			Api.AttachThreadInput(_tidThis, _tidAttach, false);
			_tidAttach = 0;
		}
	}
	
	/// <summary>
	/// Returns <c>true</c> if <c>AttachThreadInput</c> succeeded and this variable is not disposed.
	/// </summary>
	public bool IsAttached => _tidAttach != 0;
}


================================================
FILE: Au/Internal/Debug_.cs
================================================
namespace Au.More;

/// <summary>
/// Functions useful to debug code.
/// </summary>
/// <remarks>
/// The <c>Debug_.PrintX</c> functions write to the same output as <see cref="print.it"/>, not to the trace listeners like <see cref="Debug.Print(string)"/> etc do. Also they add caller's name, file and line number.
/// Functions <c>Print</c>, <c>PrintIf</c>, <c>PrintFunc</c> and <c>Dialog</c> work only if <c>DEBUG</c> is defined, which normally is when the caller project is in Debug configuration. Else they are not called, and arguments not evaluated at run time. This is because they have <c>[ConditionalAttribute("DEBUG")]</c>.
/// Note: when used in a library, the above functions depend on <c>DEBUG</c> of the library project and not on <c>DEBUG</c> of the consumer project of the library. For example, the library may be in Release configuration even if its consumer project is in Debug configuration. If your library wants to show some info only if its consumer project is in Debug config, instead you can use code like <c>if(opt.warnings.Verbose) print.warning("text");</c>; see <see cref="print.warning"/>, <see cref="OWarnings.Verbose"/>.
/// </remarks>
internal static class Debug_ {
	static void _Print(object text, string f_, int l_, string m_) {
		string s = print.util.toString(text), fname = pathname.getName(f_), st;
		int i = s.Find("\r\n   at ");
		if (i >= 0) { st = s[(i + 2)..]; s = s[..i]; } else st = new StackTrace(2, true).ToString();
		s = $"<>Debug: {m_} ({fname}:{l_}):  {s} <fold>\r\n{st}</fold>";
		_Print2(s);
	}
	
	static void _Print2(object o) {
		string s = o?.ToString();
		if (UseQM2) print.qm2.write(s); else print.it(s);
	}
	
	internal static bool UseQM2;
	
	/// <summary>
	/// Calls <see cref="print.it"/> to show some debug info. Also shows current function name/file/line.
	/// Works only if <c>DEBUG</c> is defined. Read more in class help.
	/// The 3 optional arguments are not used explicitly.
	/// Text can contain output tags.
	/// </summary>
	[Conditional("DEBUG")]
	public static void Print(object text, [CallerFilePath] string f_ = null, [CallerLineNumber] int l_ = 0, [CallerMemberName] string m_ = null)
		=> _Print(text, f_, l_, m_);
	
	/// <summary>
	/// If condition is <c>true</c>, calls <see cref="print.it"/> to show some debug info. Also shows current function name/file/line.
	/// Works only if <c>DEBUG</c> is defined. Read more in class help.
	/// If <i>text</i> <c>null</c>, uses <c>[CallerArgumentExpression("condition")]</c>. Other optional parameters are not used explicitly.
	/// If text starts with <c>"&lt;&gt;"</c>, it can contain output tags.
	/// </summary>
	[Conditional("DEBUG")]
	public static void PrintIf(bool condition, object text = null, [CallerFilePath] string f_ = null, [CallerLineNumber] int l_ = 0, [CallerMemberName] string m_ = null, [CallerArgumentExpression("condition")] string ae_ = null) {
		if (condition) _Print(text ?? ae_, f_, l_, m_);
	}
	
	/// <summary>
	/// Calls <see cref="print.it"/> with current function name.
	/// Works only if <c>DEBUG</c> is defined. Read more in class help.
	/// The optional argument is not used explicitly.
	/// </summary>
	[Conditional("DEBUG")]
	public static void PrintFunc([CallerMemberName] string m_ = null)
		=> _Print2(m_);
	
	/// <summary>
	/// If <c>DEBUG</c> defined, prints <c>lastError.message</c>. Only if condition <c>true</c> (default).
	/// </summary>
	[Conditional("DEBUG")]
	public static void PrintNativeError(bool condition = true, [CallerFilePath] string f_ = null, [CallerLineNumber] int l_ = 0, [CallerMemberName] string m_ = null) {
		if (condition) _Print(lastError.message, f_, l_, m_);
	}
	
	/// <summary>
	/// If <c>DEBUG</c> defined, prints <c>lastError.messageFor(code)</c>.
	/// </summary>
	[Conditional("DEBUG")]
	public static void PrintNativeError(int code, [CallerFilePath] string f_ = null, [CallerLineNumber] int l_ = 0, [CallerMemberName] string m_ = null)
		=> _Print(lastError.messageFor(code), f_, l_, m_);
	
	/// <summary>
	/// Calls <see cref="dialog.show"/> to show some debug info.
	/// Works only if <c>DEBUG</c> is defined. Read more in class help.
	/// The 3 optional arguments are not used explicitly.
	/// </summary>
	[Conditional("DEBUG")]
	public static void Dialog(object text, [CallerFilePath] string f_ = null, [CallerLineNumber] int l_ = 0, [CallerMemberName] string m_ = null) {
		string s = print.util.toString(text);
		dialog.show("Debug", s, flags: DFlags.ExpandDown, expandedText: $"{m_} ({pathname.getName(f_)}:{l_})");
	}
	
	//rejected: use if(opt.warnings.Verbose) dialog.showWarning(...). It adds stack trace.
	///// <summary>
	///// If <c>opt.warnings.Verbose</c>, calls <see cref="dialog.show"/> with text and stack trace.
	///// Read more in class help.
	///// </summary>
	//[MethodImpl(MethodImplOptions.NoInlining)]
	//public static void DialogOpt(string text)
	//{
	//	if(!opt.warnings.Verbose) return;
	//	var x = new StackTrace(1, true);
	//	dialog.show("Debug", text, flags: DFlags.ExpandDown | DFlags.Wider, expandedText: x.ToString());
	//}
	
	//rejected: Not used in this library. Not useful for debug because don't show the stack trace. Instead use print.warning; it supports prefix "Debug: ", "Note: ", "Info :"; it also supports disabling warnings etc.
	///// <summary>
	///// If <c>opt.warnings.Verbose</c>, calls <see cref="print.it(string)"/>.
	///// Read more in class help.
	///// </summary>
	//public static void PrintOpt(string text)
	//{
	//	if(opt.warnings.Verbose) _Print("Debug: " + text);
	//}
	
	//rejected: Don't need multiple warning functions. Now print.warning does not show more than 1 warning/second if opt.warnings.Verbose is false.
	///// <summary>
	///// If <c>opt.warnings.Verbose</c>, calls <see cref="print.warning"/>.
	///// Read more in class help.
	///// </summary>
	//[MethodImpl(MethodImplOptions.NoInlining)]
	//public static void WarningOpt(string text)
	//{
	//	if(opt.warnings.Verbose) print.warning(text, 1);
	//}
	
	/// <summary>
	/// Checks flags and throws <see cref="ArgumentException"/> if some flags are invalid. The error message includes valid flag names.
	/// </summary>
	/// <param name="flags">Flags to check.</param>
	/// <param name="goodFlags">Valid flags.</param>
	/// <remarks>
	/// Can be used in functions that have an enum flags parameter but not all passed flags are valid for that function or object state.
	/// Does nothing if <c>!opt.warnings.Verbose</c>.
	/// When flags are valid, this function is fast.
	/// </remarks>
	public static unsafe void CheckFlagsOpt<T>(T flags, T goodFlags) where T : unmanaged, Enum {
		//FUTURE: if this is really often useful, make it public. If not used - remove.
		
		Debug.Assert(sizeof(T) == 4);
		int a = *(int*)&flags;
		int b = *(int*)&goodFlags;
		if (a != (a & b)) _CheckFlagsOpt(typeof(T), b);
	}
	
	[MethodImpl(MethodImplOptions.NoInlining)]
	static void _CheckFlagsOpt(Type t, int goodFlags) {
		if (!opt.warnings.Verbose) return;
		if (!t.IsEnum) throw new ArgumentException("Bad type.");
		var s = new StringBuilder("Invalid flags. Only these flags can be used: "); bool added = false;
		for (int i = 1; i != 0; i <<= 1) {
			if (0 == (i & goodFlags)) continue;
			if (added) s.Append(", "); else added = true;
			s.Append(t.GetEnumName(i));
		}
		s.Append('.');
		//print.warning(s.ToString(), 1);
		throw new ArgumentException(s.ToString());
	}
	
	/// <summary>
	/// Returns <c>true</c> if using Debug configuration of <c>Au.dll</c>.
	/// </summary>
	public static bool IsAuDebugConfiguration {
		get {
#if DEBUG
			return true;
#else
			return false;
#endif
		}
	}
	
	//CONSIDER: move the MemoryX functions to perf as public.
	
	/// <summary>
	/// Calls <c>Marshal.AddRef(obj)</c>, then calls/returns <c>Marshal.Release(obj)</c>.
	/// </summary>
	public static int GetComObjRefCount(IntPtr obj) {
		Marshal.AddRef(obj);
		return Marshal.Release(obj);
	}
	
	/// <summary>
	/// Returns managed memory size as formatted string. Uses <c>GC.GetTotalMemory</c>.
	/// </summary>
	/// <param name="fromAnchor">Get the difference from previous call to <c>MemorySetAnchor_</c>.</param>
	public static string MemoryGet(bool fromAnchor = true) {
		var mem = GC.GetTotalMemory(false);
		//if(s_mem0 == 0) s_mem0 = mem;
		if (fromAnchor) mem -= s_mem0;
		return (mem / 1024d / 1024d).ToS("F3");
	}
	static long s_mem0;
	
	/// <summary>
	/// Prints managed memory size. Uses <c>GC.GetTotalMemory</c>.
	/// </summary>
	/// <param name="fromAnchor">Get the difference from previous call to <c>MemorySetAnchor_</c>.</param>
	public static void MemoryPrint(bool fromAnchor = true) => _Print2(MemoryGet(fromAnchor));
	
	/// <summary>
	/// Memorizes current managed memory size, so that next call to another <c>MemoryX</c> function with <i>fromAnchor</i>=<c>true</c> (default) will get memory size difference from current memory size.
	/// </summary>
	public static void MemorySetAnchor() { s_mem0 = GC.GetTotalMemory(false); }
	
	///// <summary>
	///// Temporarily suspends GC collections if possible. Restores in <c>Dispose</c>.
	///// </summary>
	//public struct NoGcRegion : IDisposable {
	//	bool _restore, _print;
		
	//	/// <summary>
	//	/// Suspends GC collections if possible.
	//	/// Does nothing in 32-bit process.
	//	/// </summary>
	//	/// <param name="memSize">Recommended 100_000_000. Still works if 200_000_000, but fails if 300_000_000. Not tested in 32-bit process.</param>
	//	/// <param name="print">Let <c>Dispose</c> print size of managed memory added since ctor.</param>
	//	public NoGcRegion(long memSize, bool print = true) {
	//		_restore = false;
	//		_print = print;
	//		if (osVersion.is32BitProcess) return;
	//		if (_print) Debug_.MemorySetAnchor_();
	//		//print.it(System.Runtime.GCSettings.LatencyMode);
	//		try { _restore = GC.TryStartNoGCRegion(memSize); }
	//		catch (InvalidOperationException ex) { Debug_.Print(ex); }
	//	}
		
	//	/// <summary>
	//	/// Restores suspended GC collections.
	//	/// </summary>
	//	public void Dispose() {
	//		if (_restore) {
	//			_restore = false;
	//			//print.it(System.Runtime.GCSettings.LatencyMode == System.Runtime.GCLatencyMode.NoGCRegion);
	//			//if(System.Runtime.GCSettings.LatencyMode == System.Runtime.GCLatencyMode.NoGCRegion) GC.EndNoGCRegion();
	//			try { GC.EndNoGCRegion(); } //note: need to call even if not in nogc region (then exception); else TryStartNoGCRegion will throw exception.
	//			catch (InvalidOperationException ex) { Debug_.Print(ex); }
	//			if (_print) Debug_.MemoryPrint_();
	//			ThreadPool.QueueUserWorkItem(_ => GC.Collect());
	//		}
	//	}
	//}
	
	/// <summary>
	/// Prints assemblies already loaded or/and loaded in the future.
	/// </summary>
	public static void PrintLoadedAssemblies(bool now, bool future, bool stackTrace = false) {
		if (now) {
			var a = AppDomain.CurrentDomain.GetAssemblies();
			_Print2("-- now --");
			foreach (var v in a) _Print2("# " + v.FullName);
		}
		if (future) {
			if (stackTrace) new StackTrace(1, true); //load assemblies used by stack trace
			_Print2("-- future --");
			AppDomain.CurrentDomain.AssemblyLoad += (object sender, AssemblyLoadEventArgs e) => {
				_Print2("# " + e.LoadedAssembly.FullName);
				if (stackTrace) _Print2(new StackTrace(1, true));
			};
			//var stack = new Stack<string>();
		}
	}
}


================================================
FILE: Au/Internal/GC_.cs
================================================
namespace Au.More {
	/// <summary>
	/// <see cref="GC"/> extensions.
	/// </summary>
	static class GC_ {
		static readonly ConditionalWeakTable<object, _Remover> s_table = new();

		/// <summary>
		/// Calls <see cref="GC.AddMemoryPressure"/>. Later, when object <i>obj</i> is garbage-collected, will call <see cref="GC.RemoveMemoryPressure"/>.
		/// </summary>
		/// <param name="obj">An object of any type.</param>
		/// <param name="size">Unmanaged memory size. It is passed to <c>GC.AddMemoryPressure</c> and <c>GC.RemoveMemoryPressure</c>.</param>
		public static void AddObjectMemoryPressure(object obj, long size) {
			GC.AddMemoryPressure(size);
			s_table.Add(obj, new _Remover(size));
		}

		class _Remover {
			readonly long _size;

			public _Remover(long size) {
				_size = size;
			}

			~_Remover() {
				//print.it("removed " + _size);
				GC.RemoveMemoryPressure(_size);
			}
		}

		/// <summary>
		/// Provides a static <see cref="HandleCollector"/> for USER handles, created with this code: <c>new("Au.User", 300, 3000);</c>.
		/// </summary>
		/// <remarks>
		/// OS refuses to create more USER objects than the process quota. Normally it is 10000, but can be min 200. It is set in registry.
		/// </remarks>
		public static HandleCollector UserHandleCollector { get; } = new("Au.User", 300, 3000);

		/// <summary>
		/// Provides a static <see cref="HandleCollector"/> for GDI handles, created with this code: <c>new("Au.GDI", 300, 3000);</c>.
		/// </summary>
		/// <remarks>
		/// OS refuses to create more GDI objects than the process quota. Normally it is 10000, but can be min 200. It is set in registry.
		/// </remarks>
		public static HandleCollector GdiHandleCollector { get; } = new("Au.GDI", 300, 3000);

		//The above HandleCollectors are used by icon.
		//Tested, works well. But if threshold 100 or 200, GC become too frequent sometimes.
		//Default limit for USER and GDI objects is 10000, min 200.
		//Alternatively could use GC.AddMemoryPressure/GC.RemoveMemoryPressure.
		//	If we add 40000 bytes/icon and GC starts working when pressure is 4 MB, then the number of icons is ~100 and GDI handles ~300.
		//	Problem: the GC threshold for unmanaged memory pressure is unknown, undocumented and changing.
		//		Test results: used to be ~100 KB (why so small?), but now in .NET5 4MB (3MB in 32-bit process).
		//		For managed memory it is 2 MB.
		//		Could instead allocate managed array of this size and keep in a field.
		//			Info: System.Drawing.Icon objects loaded from file or stream keep icon memory in private readonly byte[]? _iconData.
		//				That is why it triggers GC quite soon. But eg Clone doesn't clone that memory and it can be dangerous.
		//Don't care about icon memory size.
	}
}


================================================
FILE: Au/Internal/GDI misc.cs
================================================
namespace Au.More;

/// <summary>
/// Helps to get and release screen DC with <c>using</c>.
/// Uses API GetDC and ReleaseDC.
/// </summary>
struct ScreenDC_ : IDisposable {
	IntPtr _dc;

	public ScreenDC_() => _dc = Api.GetDC(default);

	public static implicit operator IntPtr(ScreenDC_ dc) => dc._dc;

	public void Dispose() {
		if (_dc != default) {
			Api.ReleaseDC(default, _dc);
			_dc = default;
		}
	}
}

/// <summary>
/// Helps to get and release window DC with <c>using</c>.
/// Uses API GetDC and ReleaseDC.
/// </summary>
struct WindowDC_ : IDisposable {
	IntPtr _dc;
	wnd _w;

	public WindowDC_(IntPtr dc, wnd w) { _dc = dc; _w = w; }

	public WindowDC_(wnd w) => _dc = Api.GetDC(_w = w);

	public static implicit operator IntPtr(WindowDC_ dc) => dc._dc;

	public bool Is0 => _dc == default;

	public void Dispose() {
		if (_dc != default) {
			Api.ReleaseDC(_w, _dc);
			_dc = default;
		}
	}
}

/// <summary>
/// Helps to create and delete compatible DC (memory DC) with <c>using</c>.
/// Uses API CreateCompatibleDC and DeleteDC.
/// </summary>
class MemoryDC_ : IDisposable {
	protected IntPtr _dc;

	/// <summary>
	/// Creates memory DC compatible with screen.
	/// </summary>
	public MemoryDC_() : this(default) { }

	public MemoryDC_(IntPtr dc) => _dc = Api.CreateCompatibleDC(dc);

	public static implicit operator IntPtr(MemoryDC_ dc) => dc._dc;

	public bool Is0 => _dc == default;

	public void Dispose() => Dispose(true);

	protected virtual void Dispose(bool disposing) {
		if (_dc != default) {
			Api.DeleteDC(_dc);
			_dc = default;
		}
	}
}

/// <summary>
/// Memory DC with selected font.
/// Can be used for font measurement.
/// </summary>
sealed class FontDC_ : MemoryDC_ {
	IntPtr _oldFont;

	/// <summary>
	/// Selects specified font.
	/// The <c>Dispose</c> method will select it out but will not destroy it.
	/// </summary>
	/// <param name="font"></param>
	public FontDC_(IntPtr font) {
		_oldFont = Api.SelectObject(_dc, font);
	}

	/// <summary>
	/// Selects standard UI font for specified DPI.
	/// </summary>
	/// <param name="dpi"></param>
	public FontDC_(DpiOf dpi) : this(NativeFont_.RegularCached(dpi)) { }

	protected override void Dispose(bool disposing) {
		if (_oldFont != default) {
			Api.SelectObject(_dc, _oldFont);
			_oldFont = default;
		}
		base.Dispose(disposing);
	}

	/// <summary>
	/// Measures text with API <ms>GetTextExtentPoint32</ms>.
	/// Should be single line without tabs. For drawing with API <ms>TextOut</ms> or <ms>ExtTextOut</ms>.
	/// </summary>
	public SIZE MeasureEP(string s) {
		Api.GetTextExtentPoint32(_dc, s, s.Length, out var z);
		return z;
	}

	/// <summary>
	/// Measures text with API <ms>DrawTextEx</ms>.
	/// Can be multiline. For drawing with API <ms>DrawTextEx</ms>.
	/// </summary>
	public SIZE MeasureDT(RStr s, TFFlags format, int wrapWidth = 0) {
		if (s.Length == 0) return default;
		RECT r = new(0, 0, wrapWidth, 0);
		Api.DrawText(_dc, s, ref r, format | TFFlags.CALCRECT);
		return new(r.Width + 1, r.Height);
		//When drawing, may cut 1 pixel at the right, eg if text ends with T. Workaround: now add 1.
	}
}

struct GdiObject_ : IDisposable {
	IntPtr _h;

	public IntPtr Handle => _h;

	public GdiObject_(IntPtr handle) {
		_h = handle;
	}

	public void Dispose() {
		Api.DeleteObject(_h);
		_h = default;
	}

	public static implicit operator IntPtr(GdiObject_ g) => g._h;

	/// <summary>
	/// Calls API <c>CreateSolidBrush</c>.
	/// </summary>
	/// <param name="color"><c>0xRRGGBB</c>.</param>
	public static GdiObject_ ColorBrush(ColorInt color) {
		return new(Api.CreateSolidBrush(color.ToBGR()));
	}

	/// <summary>
	/// Calls API <c>GetThemeSysColorBrush</c>.
	/// </summary>
	/// <param name="hTheme">Theme handle. If default, gets non-themed color.</param>
	/// <param name="colorIndex">API <c>COLOR_x</c>.</param>
	public static GdiObject_ SysColorBrush(IntPtr hTheme, int colorIndex) {
		return new(Api.GetThemeSysColorBrush(hTheme, colorIndex));
	}

	public void BrushFill(IntPtr dc, RECT r) {
		Api.FillRect(dc, r, _h);
	}

	public void BrushRect(IntPtr dc, RECT r) {
		Api.FrameRect(dc, r, _h);
	}
}

struct GdiPen_ : IDisposable {
	IntPtr _pen;

	public IntPtr Handle => _pen;

	public GdiPen_(int color, int width = 1, int style = 0) {
		_pen = Api.CreatePen(style, width, color);
	}

	public void Dispose() {
		Api.DeleteObject(_pen);
		_pen = default;
	}

	/// <summary>
	/// Draws line and returns previous "current position".
	/// Don't need to select pen into DC.
	/// </summary>
	public POINT DrawLine(IntPtr dc, POINT start, POINT end) {
		var old = Api.SelectObject(dc, _pen); //fast
		Api.MoveToEx(dc, start.x, start.y, out var p); //fast
		Api.LineTo(dc, end.x, end.y);
		Api.SelectObject(dc, old); //fast
		return p;
	}
}

struct GdiSelectObject_ : IDisposable {
	IntPtr _dc, _old;

	public GdiSelectObject_(IntPtr dc, IntPtr obj) {
		_old = Api.SelectObject(_dc = dc, obj);
	}

	public void Dispose() {
		Api.SelectObject(_dc, _old);
		_dc = default;
	}
}


================================================
FILE: Au/Internal/Handle_.cs
================================================

using Microsoft.Win32.SafeHandles;

namespace Au.More;

/// <summary>
/// Manages a kernel handle.
/// Must be disposed.
/// Has static functions to open process handle.
/// </summary>
internal struct Handle_ : IDisposable {
	IntPtr _h;
	
	/// <summary>
	/// Attaches a kernel handle to this new variable.
	/// No exception when handle is invalid.
	/// If handle == -1, sets 0.
	/// </summary>
	/// <param name="handle"></param>
	public Handle_(nint handle) { _h = handle == -1 ? default : handle; }
	
	//public static explicit operator Handle_(IntPtr p) => new Handle_(p); //no
	
	public static implicit operator IntPtr(Handle_ p) => p._h;
	
	/// <summary>
	/// <c>_h == default</c>.
	/// Info: <c>_h</c> never is -1.
	/// </summary>
	public bool Is0 => _h == default;
	
	/// <summary>
	/// <c>if (!Is0) { Api.CloseHandle(_h); _h = default; }</c>
	/// </summary>
	public void Dispose() {
		if (!Is0) { Api.CloseHandle(_h); _h = default; }
	}
	
	/// <summary>
	/// Opens process handle.
	/// Calls API <c>OpenProcess</c>.
	/// </summary>
	/// <returns>default if failed. Supports <see cref="lastError"/>.</returns>
	/// <param name="processId">Process id.</param>
	/// <param name="desiredAccess">Desired access (<c>Api.PROCESS_</c>), as in API <c>OpenProcess</c> documentation.</param>
	public static Handle_ OpenProcess(int processId, uint desiredAccess = Api.PROCESS_QUERY_LIMITED_INFORMATION) {
		if (processId == 0) { lastError.code = Api.ERROR_INVALID_PARAMETER; return default; }
		return _OpenProcess(processId, desiredAccess);
	}
	
	/// <summary>
	/// Opens window's process handle.
	/// This overload is more powerful: if API <c>OpenProcess</c> fails, it tries API <c>GetProcessHandleFromHwnd</c>, which can open higher integrity level processes, but only if current process is uiAccess and <i>desiredAccess</i> includes only <c>PROCESS_DUP_HANDLE</c>, <c>PROCESS_VM_OPERATION</c>, <c>PROCESS_VM_READ</c>, <c>PROCESS_VM_WRITE</c>, <c>SYNCHRONIZE</c>.
	/// </summary>
	/// <returns>default if failed. Supports <see cref="lastError"/>.</returns>
	/// <param name="w"></param>
	/// <param name="desiredAccess">Desired access (<c>Api.PROCESS_</c>), as in API <c>OpenProcess</c> documentation.</param>
	public static Handle_ OpenProcess(wnd w, uint desiredAccess = Api.PROCESS_QUERY_LIMITED_INFORMATION) {
		int pid = w.ProcessId; if (pid == 0) return default;
		return _OpenProcess(pid, desiredAccess, w);
	}
	
	static Handle_ _OpenProcess(int processId, uint desiredAccess = Api.PROCESS_QUERY_LIMITED_INFORMATION, wnd processWindow = default) {
		Handle_ R = Api.OpenProcess(desiredAccess, false, processId);
		if (R.Is0 && !processWindow.Is0 && 0 == (desiredAccess & ~(Api.PROCESS_DUP_HANDLE | Api.PROCESS_VM_OPERATION | Api.PROCESS_VM_READ | Api.PROCESS_VM_WRITE | Api.SYNCHRONIZE))) {
			int e = lastError.code;
			if (uacInfo.ofThisProcess.IsUIAccess) R = Api.GetProcessHandleFromHwnd(processWindow);
			if (R.Is0) Api.SetLastError(e);
		}
		return R;
	}
}

/// <summary>
/// Kernel handle that is derived from <c>WaitHandle</c>.
/// When don't need to wait, use <see cref="Handle_"/>, it's more lightweight and has more creation methods.
/// </summary>
internal class WaitHandle_ : WaitHandle {
	public WaitHandle_(IntPtr nativeHandle, bool ownsHandle) {
		base.SafeWaitHandle = new SafeWaitHandle(nativeHandle, ownsHandle);
	}
	
	/// <summary>
	/// Opens process handle.
	/// Returns <c>null</c> if failed.
	/// </summary>
	/// <param name="pid"></param>
	/// <param name="desiredAccess"></param>
	public static WaitHandle_ FromProcessId(int pid, uint desiredAccess) {
		try {
			var hp = Handle_.OpenProcess(pid, desiredAccess);
			if (!hp.Is0) return new WaitHandle_(hp, true);
		}
		catch (Exception ex) { Debug_.Print(ex); }
		return null;
	}
}


================================================
FILE: Au/Internal/ILReader.cs
================================================

//https://stackoverflow.com/questions/14243284/how-can-i-retrieve-string-literals-using-reflection

//#define FULL

using System.Reflection.Emit;

namespace Au.More;

[StructLayout(LayoutKind.Sequential)]
internal struct ILInstruction {
	private readonly OpCode operationCode; // 40.  56-64.  The entire structure is very big.  maybe do array lookup for opcode instead.
	
	private readonly byte[] instructionRawData;
	
	private readonly object instructionData;
	
	private readonly int instructionAddress;
	
	private readonly int index;
	
	internal ILInstruction(OpCode code, byte[] instructionRawData, int instructionAddress, object instructionData, int index) {
		this.operationCode = code;
		this.instructionRawData = instructionRawData;
		this.instructionAddress = instructionAddress;
		this.instructionData = instructionData;
		this.index = index;
	}
	
	public OpCode Op {
		get {
			return this.operationCode;
		}
	}
	
	/// <summary>
	/// Gets the raw data.
	/// </summary>
	public byte[] RawData {
		get {
			return this.instructionRawData;
		}
	}
	
	/// <summary>
	/// Gets the data.
	/// </summary>
	public object Data {
		get {
			return this.instructionData;
		}
	}
	
	/// <summary>
	/// Gets the address of the instruction.
	/// </summary>
	public int Address {
		get {
			return this.instructionAddress;
		}
	}
	
	/// <summary>
	/// Gets the index of the instruction.
	/// </summary>
	/// <value>
	/// The index of the instruction.
	/// </value>
	public int InstructionIndex {
		get {
			return this.index;
		}
	}
	
	/// <summary>
	/// Gets the value as integer
	/// </summary>
	/// <value>The data value.</value>
	public int DataValue {
		get {
			int value = 0;
			if (this.Data != null) {
				if (this.Data is byte) {
					value = (byte)this.Data;
				} else if (this.Data is short) {
					value = (short)this.Data;
				} else if (this.Data is int) {
					value = (int)this.Data;
				}
			}
			
			return value;
		}
	}
	
	/// <summary>
	/// Gets the length of the instructions and operands.
	/// </summary>
	/// <value>The length.</value>
	public int Length {
		get {
			return this.Op.Size + (this.RawData == null ? 0 : this.RawData.Length);
		}
	}
	
#if DEBUG
	/// <summary>
	/// Returns a <see cref="System.String"/> that represents this instance.
	/// </summary>
	/// <returns>
	/// A <see cref="System.String"/> that represents this instance.
	/// </returns>
	public override string ToString() {
		StringBuilder builder = new StringBuilder();
		builder.AppendFormat("0x{0:x4} {1,-10}", this.Address, this.Op.Name);
		
		if (this.Data != null) {
			builder.Append(this.Data.ToString());
		}
		
		if (this.RawData != null && this.RawData.Length > 0) {
			builder.Append(" [0x");
			for (int i = this.RawData.Length; --i >= 0;) {
				builder.Append(this.RawData[i].ToString("x2", System.Globalization.CultureInfo.InvariantCulture));
			}
			
			builder.Append(']');
		}
		
		return builder.ToString();
	}
#endif
}

/// <summary>
/// Reads IL instructions from a byte stream.
/// </summary>
/// <remarks>Allows generated code to be viewed without debugger or enabled debug assemblies.</remarks>
internal sealed class ILReader {
	/// <summary>
	/// The _instruction lookup.
	/// </summary>
	private static readonly Lazy<Dictionary<short, OpCode>> instructionLookup = new Lazy<Dictionary<short, OpCode>>(ILReader.GetLookupTable, System.Threading.LazyThreadSafetyMode.ExecutionAndPublication);
	
	/// <summary>
	/// The IL reader provider.
	/// </summary>
	private IILReaderProvider intermediateLanguageProvider;
	
	/// <summary>
	/// Initializes a new instance of the <see cref="ILReader"/> class.
	/// </summary>
	public ILReader(MethodInfo method, byte[] il = null) {
		//au: il added because the caller itself gets IL array and does nothing if it's too big to disassemble. To avoid getting IL 2 times.
		
		if (method == null) {
			throw new ArgumentNullException("method");
		}
		
		this.intermediateLanguageProvider = ILReader.CreateILReaderProvider(method, il);
	}
	
	/// <summary>
	/// Gets the instructions.
	/// </summary>
	/// <value>The instructions.</value>
	public IEnumerable<ILInstruction> Instructions {
		get {
			byte[] instructionBytes = this.intermediateLanguageProvider.GetMethodBody();
			int instructionIndex = 0, startAddress;
			for (int position = 0; position < instructionBytes.Length;) {
				startAddress = position;
				short operationData = instructionBytes[position];
				if (IsInstructionPrefix(operationData)) {
					operationData = (short)((operationData << 8) | instructionBytes[++position]);
				}
				
				position++;
				
				OpCode code;
				if (!instructionLookup.Value.TryGetValue(operationData, out code)) {
					throw new InvalidProgramException(string.Format("0x{0:X2} is not a valid op code.", operationData));
				}
				
				int dataSize = GetSize(code.OperandType);
				byte[] data = new byte[dataSize];
				Buffer.BlockCopy(instructionBytes, position, data, 0, dataSize);
				object objData = this.GetData(code, data);
				position += dataSize;
				
				if (code.OperandType == OperandType.InlineSwitch) {
					dataSize = (int)objData;
					int[] labels = new int[dataSize];
					for (int index = 0; index < labels.Length; index++) {
						labels[index] = BitConverter.ToInt32(instructionBytes, position);
						position += 4;
					}
					
					objData = labels;
				}
				
				yield return new ILInstruction(code, data, startAddress, objData, instructionIndex);
				instructionIndex++;
			}
		}
	}
	
	
	private static IILReaderProvider CreateILReaderProvider(MethodInfo methodInfo, byte[] il = null) {
#if FULL
		IILReaderProvider reader = DynamicILReaderProvider.Create(methodInfo, il);
		if(reader != null) {
			return reader;
		}
#endif
		return new ILReaderProvider(methodInfo, il);
	}
	
	/// <summary>
	/// Checks to see if the IL instruction is a prefix indicating the length of the instruction is two bytes long.
	/// </summary>
	/// <param name="value">The IL instruction as a byte.</param>
	/// <remarks>IL instructions can either be 1 or 2 bytes.</remarks>
	/// <returns>True if this IL instruction is a prefix indicating the instruction is two bytes long.</returns>
	private static bool IsInstructionPrefix(short value) {
		return ((value & OpCodes.Prefix1.Value) == OpCodes.Prefix1.Value) || ((value & OpCodes.Prefix2.Value) == OpCodes.Prefix2.Value)
			|| ((value & OpCodes.Prefix3.Value) == OpCodes.Prefix3.Value) || ((value & OpCodes.Prefix4.Value) == OpCodes.Prefix4.Value)
			|| ((value & OpCodes.Prefix5.Value) == OpCodes.Prefix5.Value) || ((value & OpCodes.Prefix6.Value) == OpCodes.Prefix6.Value)
			|| ((value & OpCodes.Prefix7.Value) == OpCodes.Prefix7.Value) || ((value & OpCodes.Prefixref.Value) == OpCodes.Prefixref.Value);
	}
	
	/// <summary>
	/// The get lookup table.
	/// </summary>
	/// <returns>
	/// A dictionary of IL instructions.
	/// </returns>
	private static Dictionary<short, OpCode> GetLookupTable() {
		// Might be better to do an array lookup.  Use a seperate arrary for instructions without a prefix and array for each prefix.
		Dictionary<short, OpCode> lookupTable = new Dictionary<short, OpCode>();
		FieldInfo[] fields = typeof(OpCodes).GetFields(BindingFlags.Static | BindingFlags.Public);
		foreach (FieldInfo field in fields) {
			OpCode code = (OpCode)field.GetValue(null);
			lookupTable.Add(code.Value, code);
		}
		
		return lookupTable;
	}
	
	/// <summary>
	/// Gets the size of a operand.
	/// </summary>
	/// <param name="operandType">Defines the type of operand.</param>
	/// <returns>The size in bytes of the operand type.</returns>
	private static int GetSize(OperandType operandType) {
		switch (operandType) {
		case OperandType.InlineNone:
			return 0;
		case OperandType.ShortInlineBrTarget:
		case OperandType.ShortInlineI:
		case OperandType.ShortInlineVar:
			return 1;
		case OperandType.InlineVar:
			return 2;
		case OperandType.InlineBrTarget:
		case OperandType.InlineField:
		case OperandType.InlineI:
		case OperandType.InlineMethod:
		case OperandType.InlineSig:
		case OperandType.InlineString:
		case OperandType.InlineSwitch:
		case OperandType.InlineTok:
		case OperandType.InlineType:
		case OperandType.ShortInlineR:
			return 4;
		case OperandType.InlineI8:
		case OperandType.InlineR:
			return 8;
		default:
			return 0;
		}
	}
	
	private object GetData(OpCode code, byte[] rawData) {
		object data = null;
		switch (code.OperandType) {
		case OperandType.InlineField:
			data = this.intermediateLanguageProvider.ResolveField(BitConverter.ToInt32(rawData, 0));
			break;
		case OperandType.InlineSwitch:
			data = BitConverter.ToInt32(rawData, 0);
			
			break;
		case OperandType.InlineBrTarget:
		case OperandType.InlineI:
			data = BitConverter.ToInt32(rawData, 0);
			break;
		case OperandType.InlineI8:
			data = BitConverter.ToInt64(rawData, 0);
			break;
		case OperandType.InlineMethod:
			data = this.intermediateLanguageProvider.ResolveMethod(BitConverter.ToInt32(rawData, 0));
			break;
		case OperandType.InlineR:
			data = BitConverter.ToDouble(rawData, 0);
			break;
		case OperandType.InlineSig:
			data = this.intermediateLanguageProvider.ResolveSignature(BitConverter.ToInt32(rawData, 0));
			break;
		case OperandType.InlineString:
			data = this.intermediateLanguageProvider.ResolveString(BitConverter.ToInt32(rawData, 0));
			break;
		case OperandType.InlineTok:
		case OperandType.InlineType:
			data = this.intermediateLanguageProvider.ResolveType(BitConverter.ToInt32(rawData, 0));
			break;
		case OperandType.InlineVar:
			data = BitConverter.ToInt16(rawData, 0);
			break;
		case OperandType.ShortInlineVar:
		case OperandType.ShortInlineI:
		case OperandType.ShortInlineBrTarget:
			data = rawData[0];
			break;
		case OperandType.ShortInlineR:
			data = BitConverter.ToSingle(rawData, 0);
			break;
		}
		
		return data;
	}
	
	interface IILReaderProvider {
		byte[] GetMethodBody();
		
		FieldInfo ResolveField(int metadataToken);
		MemberInfo ResolveMember(int metadataToken);
		
		MethodBase ResolveMethod(int metadataToken);
		byte[] ResolveSignature(int metadataToken);
		
		string ResolveString(int metadataToken);
		Type ResolveType(int metadataToken);
	}
	
	class ILReaderProvider : IILReaderProvider {
		byte[] _il;
		
		public ILReaderProvider(MethodInfo method, byte[] il = null) {
			_il = il;
			this.Method = method;
			this.MethodBody = method.GetMethodBody();
			this.MethodModule = method.Module;
		}
		
		public MethodInfo Method { get; private set; }
		
		public MethodBody MethodBody { get; private set; }
		
		public Module MethodModule { get; private set; }
		
		public byte[] GetMethodBody() {
			return _il ??= this.MethodBody.GetILAsByteArray();
		}
		
		public FieldInfo ResolveField(int metadataToken) {
			return this.MethodModule.ResolveField(metadataToken);
		}
		
		public MemberInfo ResolveMember(int metadataToken) {
			return this.MethodModule.ResolveMember(metadataToken);
		}
		
		public MethodBase ResolveMethod(int metadataToken) {
			return this.MethodModule.ResolveMethod(metadataToken);
		}
		
		public byte[] ResolveSignature(int metadataToken) {
			return this.MethodModule.ResolveSignature(metadataToken);
		}
		
		public string ResolveString(int metadataToken) {
			return this.MethodModule.ResolveString(metadataToken);
		}
		
		public Type ResolveType(int metadataToken) {
			return this.MethodModule.ResolveType(metadataToken);
		}
	}
	
#if FULL
	class DynamicILReaderProvider :IILReaderProvider
	{
		public const int TypeRidPrefix = 0x02000000;

		public const int MethodRidPrefix = 0x06000000;

		public const int FieldRidPrefix = 0x04000000;

		public static readonly Type RuntimeDynamicMethodType;

		private static readonly FieldInfo fileLengthField = typeof(ILGenerator).GetField("m_length", BindingFlags.NonPublic | BindingFlags.Instance);

		private static readonly FieldInfo IntermediateLanguageBytesField = typeof(ILGenerator).GetField("m_ILStream", BindingFlags.NonPublic | BindingFlags.Instance);

		private static readonly MethodInfo bakeByteArrayMethod = typeof(ILGenerator).GetMethod("BakeByteArray", BindingFlags.NonPublic | BindingFlags.Instance);

		private static readonly PropertyInfo dynamicScopeIndexor;

		private static readonly FieldInfo dynamicScopeField;

		private static readonly Type genericMethodInfoType;

		private static readonly FieldInfo genericMethodHandleField;

		private static readonly FieldInfo genericMethodContextField;

		private static readonly Type varArgMethodType;

		private static readonly FieldInfo varArgMethodMethod;

		private static readonly Type genericFieldInfoType;

		private static readonly FieldInfo genericFieldInfoHandle;

		private static readonly FieldInfo genericFieldInfoContext;

		private static readonly FieldInfo ownerField;

		private object dynamicScope;

		private ILGenerator generator;

		static DynamicILReaderProvider()
		{
			BindingFlags bindingFlags = BindingFlags.NonPublic | BindingFlags.Instance;
			dynamicScopeIndexor = Type.GetType("System.Reflection.Emit.DynamicScope").GetProperty("Item", bindingFlags);
			dynamicScopeField = Type.GetType("System.Reflection.Emit.DynamicILGenerator").GetField("m_scope", bindingFlags);

			varArgMethodType = Type.GetType("System.Reflection.Emit.VarArgMethod");
			varArgMethodMethod = varArgMethodType.GetField("m_method", bindingFlags);

			genericMethodInfoType = Type.GetType("System.Reflection.Emit.GenericMethodInfo");
			genericMethodHandleField = genericMethodInfoType.GetField("m_methodHandle", bindingFlags);
			genericMethodContextField = genericMethodInfoType.GetField("m_context", bindingFlags);

			genericFieldInfoType = Type.GetType("System.Reflection.Emit.GenericFieldInfo", false);
			if(genericFieldInfoType != null) {
				genericFieldInfoHandle = genericFieldInfoType.GetField("m_fieldHandle", bindingFlags);
				genericFieldInfoContext = genericFieldInfoType.GetField("m_context", bindingFlags);
			} else {
				genericFieldInfoHandle = genericFieldInfoContext = null;
			}

			RuntimeDynamicMethodType = typeof(DynamicMethod).GetNestedType("RTDynamicMethod", BindingFlags.NonPublic);
			ownerField = RuntimeDynamicMethodType.GetField("m_owner", bindingFlags);
		}

		private DynamicILReaderProvider(DynamicMethod method)
		{
			this.Method = method;
			this.generator = method.GetILGenerator();
			this.dynamicScope = dynamicScopeField.GetValue(this.generator);
		}

		public DynamicMethod Method { get; private set; }

		internal object this[int token]
		{
			get
			{
				return dynamicScopeIndexor.GetValue(this.dynamicScope, new object[] { token });
			}
		}

		public static DynamicILReaderProvider Create(MethodInfo method)
		{
			if(method == null) {
				throw new ArgumentNullException("method");
			}

			DynamicMethod dynamicMethod = method as DynamicMethod;
			if(dynamicMethod != null) {
				return new DynamicILReaderProvider(dynamicMethod);
			}

			Type methodType = method.GetType();
			if(RuntimeDynamicMethodType.IsAssignableFrom(methodType)) {
				return new DynamicILReaderProvider(ownerField.GetValue(method) as DynamicMethod);
			}

			return null;
		}

		public byte[] GetMethodBody()
		{
			byte[] data = null;
			ILGenerator ilgen = this.Method.GetILGenerator();

			try {
				data = (byte[])bakeByteArrayMethod.Invoke(ilgen, null) ?? new byte[0];
			}
			catch(TargetInvocationException) {
				int length = (int)fileLengthField.GetValue(ilgen);
				data = new byte[length];
				Array.Copy((byte[])IntermediateLanguageBytesField.GetValue(ilgen), data, length);
			}

			return data;
		}

		public FieldInfo ResolveField(int metadataToken)
		{
			object tokenValue = this[metadataToken];
			if(tokenValue is RuntimeFieldHandle) {
				return FieldInfo.GetFieldFromHandle((RuntimeFieldHandle)tokenValue);
			}

			if(tokenValue.GetType() == DynamicILReaderProvider.genericFieldInfoType) {
				return FieldInfo.GetFieldFromHandle(
					(RuntimeFieldHandle)genericFieldInfoHandle.GetValue(tokenValue),
					(RuntimeTypeHandle)genericFieldInfoContext.GetValue(tokenValue));
			}

			return null;
		}

		public MemberInfo ResolveMember(int metadataToken)
		{
			if((metadataToken & TypeRidPrefix) != 0) {
				return this.ResolveType(metadataToken);
			}

			if((metadataToken & MethodRidPrefix) != 0) {
				return this.ResolveMethod(metadataToken);
			}

			if((metadataToken & FieldRidPrefix) != 0) {
				return this.ResolveField(metadataToken);
			}

			return null;
		}

		public MethodBase ResolveMethod(int metadataToken)
		{
			object tokenValue = this[metadataToken];
			DynamicMethod dynamicMethod = tokenValue as DynamicMethod;
			if(dynamicMethod != null) {
				return dynamicMethod;
			}

			if(tokenValue is RuntimeMethodHandle) {
				return MethodBase.GetMethodFromHandle((RuntimeMethodHandle)this[metadataToken]);
			}

			if(tokenValue.GetType() == DynamicILReaderProvider.genericFieldInfoType) {
				return MethodBase.GetMethodFromHandle(
					(RuntimeMethodHandle)genericMethodHandleField.GetValue(tokenValue),
					(RuntimeTypeHandle)genericMethodContextField.GetValue(tokenValue));
			}

			if(tokenValue.GetType() == DynamicILReaderProvider.varArgMethodType) {
				return DynamicILReaderProvider.varArgMethodMethod.GetValue(tokenValue) as MethodInfo;
			}

			return null;
		}

		public byte[] ResolveSignature(int metadataToken)
		{
			return this[metadataToken] as byte[];
		}
		public string ResolveString(int metadataToken)
		{
			return this[metadataToken] as string;
		}

		public Type ResolveType(int metadataToken)
		{
			return Type.GetTypeFromHandle((RuntimeTypeHandle)this[metadataToken]);
		}
	}
#endif
}


================================================
FILE: Au/Internal/IconString_.cs
================================================
using System.Windows;
using System.Windows.Media;

namespace Au.More;

/// <summary>
/// Parses XAML icon strings like <c>"*Pack.Name color"</c>.
/// </summary>
record struct IconString_ {
	public readonly string pack, name, color;
	public readonly int size, end;
	public readonly Thickness margin;
	public readonly char stretch;
	public readonly bool snapPixels;
	
	public bool HasValue => name != null;
	public bool HasSize => size is > 0 and <= 16;
	public bool HasMargin => margin != default;
	
	IconString_(RStr s) {
		if (!Detect(s, out var d)) return;
		pack = s[d.pack.Range].ToString();
		name = s[d.name.Range].ToString();
		
		int k = d.name.end;
		end = s.IndexOf(k, ';'); if (end < 0) end = s.Length;
		
		if (s.Eq(k, ' ')) {
			s = s[++k..end];
			Span<Range> a1 = stackalloc Range[3], a2 = stackalloc Range[6];
			foreach (var v in a1[..s.Split(a1, ' ')]) {
				int i = v.Start.Value, j = v.End.Value;
				if (j == i) continue;
				var c = s[i++];
				if (c is '#' or '|' || c.IsAsciiAlpha()) color = s[v].ToString();
				else if (c == '@') size = s[i..].ToInt_();
				else if (c == '%') { //margin
					int n = 0;
					var m = s[i..j];
					foreach (var u in a2[..m.Split(a2, ',')]) {
						n++;
						if (u.End.Value == u.Start.Value) continue;
						if (n == 6) {
							snapPixels = m[u][0] == 'p';
						} else if (n == 5) {
							stretch = m[u][0]; if (!(stretch is 'f' or 'm')) stretch = default;
						} else if (double.TryParse(m[u], CultureInfo.InvariantCulture, out var g)) {
							switch (n) { case 1: margin.Left = g; break; case 2: margin.Top = g; break; case 3: margin.Right = g; break; case 4: margin.Bottom = g; break; }
						}
					}
				}
			}
		}
		//note: don't use `MemoryExtensions.SpanSplitEnumerator<char> RStr.Split<char>(char separator)`. Easier to use, but: 1. Not in .NET 8. 2. 5-10 times slower.
	}
	
	/// <summary>
	/// Parses single-icon string. Format: <c>"[*&lt;library&gt;]*pack.name[ color][ @size][ %margin]"</c>.
	/// </summary>
	/// <returns>false if bad format.</returns>
	public static bool Parse(RStr s, out IconString_ r) {
		r = new(s);
		return r.HasValue;
	}
	
	/// <summary>
	/// Parses single-or-multi-icon string. Format: <c>"[*&lt;library&gt;]*pack.name[ color][ @size][ %margin][;more icons]"</c>.
	/// </summary>
	/// <returns>null if bad format.</returns>
	public static IconString_[] ParseAll(string icon) {
		List<IconString_> a = null;
		for (RStr s = icon; Parse(s, out var r); s = s[(r.end + 1)..].TrimStart()) {
			(a ??= new()).Add(r);
			if (r.end == s.Length || s[r.end] != ';') break;
		}
		return a?.ToArray();
	}
	
	/// <summary>
	/// Returns true if <i>s</i> starts with <c>"*pack.name"</c> or <c>"*&lt;library&gt;*pack.name"</c>.
	/// </summary>
	public static bool Detect(RStr s, out (StartEnd pack, StartEnd name) r) {
		r = default;
		if (s.Length < 8 || s[0] != '*' || !s.Contains('.')) return false;
		Span<StartEnd> a = stackalloc StartEnd[3];
		if (!s_rxDetect.Match(s, a)) return false;
		r = (a[1], a[2]);
		return true;
	}
	static regexp s_rxDetect = new regexp(@"^\*(?:<.+?>\*)?([[:alpha:]]\w+)\.(\w\w+)");
	
	/// <summary>
	/// Our compiler (_CreateManagedResources) adds XAML of icons to resources from literal strings. This function gets the XAML.
	/// </summary>
	/// <param name="icon"></param>
	/// <returns>null if failed.</returns>
	public static string GetXamlFromResources(string icon) {
		//print.it("\r\n----", icon);
		if (DetectAndRemoveParametersForResources(icon, out string icon2) && ResourceUtil.TryGetString_(icon2) is string xaml) {
			//print.it(xaml);
			var a = ParseAll(icon);
			if (!XamlSetColorSizeMargin(ref xaml, a)) return null;
			//print.it(xaml);
			return xaml;
		} else {
			Debug_.Print(icon);
			return null;
		}
	}
	
	static regexp s_rxPath = new regexp(@"<Path (.+?)/?>");
	static regexp s_rxAttr = new(@" (?:Fill|Stroke|Width|Height|Margin|Stretch|SnapsToDevicePixels)=""[^""]*");
	
	/// <summary>
	/// In XAML sets color, size and margin specified in parsed icons.
	/// </summary>
	/// <param name="xaml">XAML with as many <i>Path</i> as <i>a</i> elements.</param>
	/// <param name="a">Parsed icons.</param>
	/// <returns>false if found errors etc.</returns>
	public static bool XamlSetColorSizeMargin(ref string xaml, IconString_[] a) {
		using var b_ = new StringBuilder_(out var b, xaml.Length / 10 * 11 + 100);
		int appendFrom = 0, i = 0;
		bool anyHasSizeOrMargin = a.Any(o => o.HasSize || o.HasMargin);
		
		foreach (var gp in s_rxPath.FindAllG(xaml, 1)) { //for each <Path ...>
			if (i == a.Length) return false;
			var x = a[i++];
			bool hasSize = x.HasSize, hasMargin = x.HasMargin, xamlHasSizeOrMargin = false;
			foreach (var ga in s_rxAttr.FindAllG(xaml, 0, gp.Start..gp.End)) { //for each attribute
				int attr = ga.Start + 1;
				if (xaml[attr] is 'F' or 'S') {
					string sVal;
					if (xaml[attr + 1] == 'n') { //SnapsToDevicePixels
						if (hasSize || x.snapPixels) sVal = "True"; else continue;
					} else if (xaml[attr + 3] == 'e') { //Stretch
						if (x.stretch is 'f' or 'm') sVal = x.stretch is 'f' ? "Fill" : "UniformToFill"; else continue;
					} else {
						sVal = NormalizeColor(x.color);
					}
					b.Append(xaml, appendFrom, xaml.IndexOf('"', attr) + 1 - appendFrom).Append(sVal);
					appendFrom = ga.End;
				} else {
					xamlHasSizeOrMargin = true;
					if (hasSize || hasMargin) {
						print.warning($"@size and %margin not supported for this icon: *{x.pack}.{x.name}", -1);
						return false;
					}
				}
			}
			if (hasSize || hasMargin || (anyHasSizeOrMargin && !xamlHasSizeOrMargin)) {
				b.Append(xaml, appendFrom, gp.End - appendFrom);
				appendFrom = gp.End;
				if (hasSize) {
					if (hasMargin) { print.warning($"Error in icon *{x.pack}.{x.name}: use @size or %margin, not both.", -1); return false; }
					b.AppendFormat(" Width=\"{0}\" Height=\"{0}\" Margin=\"{1}\"", x.size, ((16 - x.size) / 2.0).ToS());
				} else if (hasMargin) {
					double wid = 16 - x.margin.Left - x.margin.Right, hei = 16 - x.margin.Top - x.margin.Bottom;
					if (wid <= 0 || hei <= 0) { print.warning($"Error in icon *{x.pack}.{x.name}: margins left+right and top+bottom must be < 16.", -1); return false; }
					b.AppendFormat(" Width=\"{0}\" Height=\"{1}\" Margin=\"{2}\"", wid.ToS(), hei.ToS(), x.margin.ToString());
				} else {
					//if like "icon1;icon2", and some icons have specified size or margin, and some others don't, some icons may be rendered very small, depending on others.
					//	Don't know why. Workaround: specify Width/Height for all.
					b.Append(" Width=\"16\" Height=\"16\"");
				}
			}
		}
		b.Append(xaml, appendFrom, xaml.Length - appendFrom);
		xaml = b.ToString();
		return true;
	}
	
	/// <summary>
	/// If <i>s</i> is or contains <c>"color|color2"</c>, removes <c>"|color2"</c> or <c>"color|"</c> depending on <see cref="WpfUtil_.IsHighContrastDark"/>.
	/// If then (or initially) <i>s</i> is empty, returns <c>SystemColors.ControlTextColor</c>.
	/// </summary>
	public static string NormalizeColor(string s) {
		int i = s?.IndexOf('|') ?? -1;
		if (i >= 0) {
			bool dark = WpfUtil_.IsHighContrastDark;
			using (new StringBuilder_(out var b)) {
				int appendFrom = 0;
				do {
					int j = i + 1;
					if (dark) {
						while (i > 0 && s[i - 1] != ' ') i--;
					} else {
						while (j < s.Length && !(s[j] is ' ' or ';')) j++;
					}
					b.Append(s, appendFrom, i - appendFrom);
					i = s.IndexOf('|', j);
					appendFrom = j;
				} while (i > 0);
				b.Append(s, appendFrom, s.Length - appendFrom);
				s = b.ToString();
			}
		}
		if (s.NE()) s = SystemColors.ControlTextColor.ToString();
		return s;
	}
	
	/// <summary>
	/// If <i>s</i> is an icon string, removes parameters and returns true.
	/// <br/>Example1: <c>"*Pack.Name color"</c> -> <c>"*Pack.Name"</c>.
	/// <br/>Example2: <c><![CDATA["*<assembly>*Pack.Name1 color; *Pack.Name2 color margin;"]]></c> -> <c>"*Pack.Name1;Pack.Name2"</c>.
	/// </summary>
	public static bool DetectAndRemoveParametersForResources(RStr s, out string result) {
		StringBuilder b = null;
		while (Detect(s, out var d)) {
			if (b == null) b = new(); else b.Append(';');
			b.Append('*').Append(s[d.pack.Range]).Append('.').Append(s[d.name.Range]);
			int semi = s.IndexOf(d.name.end, ';'); if (semi < 0) break;
			s = s[++semi..].TrimStart();
		}
		return (result = b?.ToString()) != null;
	}
}


================================================
FILE: Au/Internal/Jit_.cs
================================================
namespace Au.More;

/// <summary>
/// JIT-compiles methods.
/// </summary>
static class Jit_ {
	const BindingFlags c_bindingFlags = BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.DeclaredOnly;
	
	/// <summary>
	/// JIT-compiles method.
	/// Uses <see cref="RuntimeHelpers.PrepareMethod"/>.
	/// </summary>
	/// <param name="type">Type containing the method.</param>
	/// <param name="method">Method name.</param>
	/// <exception cref="ArgumentException">Method does not exist.</exception>
	/// <exception cref="AmbiguousMatchException">Multiple overloads exist.</exception>
	public static void Compile(Type type, string method) {
		var m = type.GetMethod(method, c_bindingFlags);
		if (m == null) throw new ArgumentException($"Method {type.Name}.{method} does not exist.");
		RuntimeHelpers.PrepareMethod(m.MethodHandle);
		//tested: maybe MethodHandle.GetFunctionPointer can be used to detect whether the method is jited and assembly ngened.
		//	Call GetFunctionPointer before and after PrepareMethod. If was not jited, the second call returns a different value.
		//	Undocumented, therefore unreliable.
	}
	
	//rejected. Don't JIT-compile overloads.
	///// <summary>
	///// JIT-compiles a method overload.
	///// Uses <c>RuntimeHelpers.PrepareMethod</c>.
	///// </summary>
	///// <param name="type">Type containing the method.</param>
	///// <param name="method">Method name.</param>
	///// <param name="paramTypes">Types of parameters of this overload.</param>
	///// <exception cref="ArgumentException">Method does not exist.</exception>
	///// <exception cref="AmbiguousMatchException">Multiple overloads exist that match <i>paramTypes</i>.</exception>
	//public static void Compile(Type type, string method, params Type[] paramTypes)
	//{
	//	var m = type.GetMethod(method, c_bindingFlags, null, paramTypes, null);
	//	if(m == null) throw new ArgumentException($"Method {type.Name}.{method} does not exist.");
	//	RuntimeHelpers.PrepareMethod(m.MethodHandle);
	//	//tested: MethodHandle.GetFunctionPointer cannot be used to detect whether the method is jited.
	//	//	Tried to find a faster way to detect whether the assembly is ngened.
	//}
	
	/// <summary>
	/// JIT-compiles multiple methods of same type.
	/// Uses <see cref="RuntimeHelpers.PrepareMethod"/>.
	/// </summary>
	/// <param name="type">Type containing the methods.</param>
	/// <param name="methods">Method names.</param>
	/// <exception cref="ArgumentException">Method does not exist.</exception>
	public static void Compile(Type type, params string[] methods) {
		foreach (var v in methods) Compile(type, v);
	}
}


================================================
FILE: Au/Internal/LaDebugger_.cs
================================================
namespace Au.More;

class LaDebugger_ {
	//Called by netcoredbg as a breakpoint condition when specified Message.
	static bool Logpoint(bool condition, string s, string link) {
		if (condition) print.it($"<><lc #f8f8d0><open {link}><c #40B000>♦<><> {s}<>");
		return false;
	}
	
	//Same problems as with LaDebugger_<T>. Also fails if struct.
	//static string Print<T>(T t) {
	//	var s = print.util.toString(t).Limit(1_000_000);
	//	return Convert.ToBase64String(Encoding.UTF8.GetBytes(s)); 
	//}
}

//Functions called by netcoredbg -var-create to get a value in the print.it format.
//netcoredbg does not support cast to object etc. This is the only way that works.
//Fails if array.
//Fails if ref struct.
//Garbage if object or dynamic.
class LaDebugger_<T> {
	static string Print(T t) => _Print(t, false);
	static string PrintCompact(T t) => _Print(t, true);
	
	static string _Print(T t, bool compact) {
		var s = print.util.toString(t, compact).Limit(1_000_000);
		return Convert.ToBase64String(Encoding.UTF8.GetBytes(s));
	}
	
	//static string PrintArray(T[] a) => "OK"; //fails too
}


================================================
FILE: Au/Internal/LineWriter_.cs
================================================
namespace Au.More;

/// <summary>
/// <see cref="TextWriter"/> optimized for writing full lines.
/// </summary>
/// <remarks>
/// Derived class must override <see cref="WriteLineNow"/>. Don't need to override <c>Write</c>/<c>WriteLine</c>.
/// If <c>Write</c> called with text that does not end with <c>'\n'</c>, just accumulates the text in this variable.
/// When called <c>WriteLine</c> or <c>Flush</c> or <c>Write</c> with text that ends with <c>'\n'</c>, calls <see cref="WriteLineNow"/> of the derived class.
/// </remarks>
internal abstract class LineWriter_ : TextWriter {
	StringBuilder _b;
	
	/// <summary>
	/// Returns <c>Encoding.Unicode</c>.
	/// </summary>
	public override Encoding Encoding => Encoding.Unicode;
	
	/// <summary>
	/// If <i>value</i> is <c>'\n'</c>, writes accumulated text as full line and clears accumulated text, else just appends <i>value</i> to the accumulated text.
	/// </summary>
	public override void Write(char value) {
		//qm2.write((int)value, value);
		if (value == '\n') {
			WriteLine();
		} else {
			(_b ??= new StringBuilder()).Append(value);
		}
		base.Write(value);
	}
	
	/// <summary>
	/// If <i>value</i> ends with <c>'\n'</c>, writes line (accumulated text + <i>value</i>) and clears accumulated text, else just appends <i>value</i> to the accumulated text.
	/// </summary>
	public override void Write(string value) {
		//qm2.write($"'{value}'");
		//qm2.write("Write", $"'{value}'", value.ToCharArray());
		if (value.NE()) return;
		if (value.Ends('\n')) {
			WriteLine(value[..^(value.Ends("\r\n") ? 2 : 1)]);
		} else {
			(_b ??= new StringBuilder()).Append(value);
		}
	}
	
	/// <summary>
	/// If this variable contains accumulated text, writes it as full line and clears it. Else writes empty line.
	/// </summary>
	public override void WriteLine() {
		WriteLineNow(_PrependBuilder(null));
	}
	
	/// <summary>
	/// Writes line (accumulated text + <i>value</i>) and clears accumulated text.
	/// </summary>
	public override void WriteLine(string value) {
		//qm2.write("WriteLine", $"'{value}'", value.ToCharArray());
		WriteLineNow(_PrependBuilder(value));
	}
	
	string _PrependBuilder(string value) {
		if (_b != null && _b.Length > 0) {
			value = _b.ToString() + value;
			_b.Clear();
		}
		return value;
	}
	
	/// <summary>
	/// If this variable contains accumulated text, writes it as full line and clears it.
	/// </summary>
	public override void Flush() {
		var s = _PrependBuilder(null);
		if (!s.NE()) WriteLineNow(s);
	}
	
	/// <summary>
	/// Called to write full line.
	/// </summary>
	/// <param name="s">Line text. Does not end with line break characters.</param>
	protected abstract void WriteLineNow(string s);
}


================================================
FILE: Au/Internal/MiniProgram_.cs
================================================
//PROBLEM: slow startup.
//A minimal script starts in 70-100 ms cold, 40 hot (old PC, tested long time ago). Now on new PC starts in 37 ms.
//Workaround for role miniProgram:
//	Preload task process. Let it wait for next task. While waiting, it also can JIT etc.
//	Then starts in 12/4 ms (cold/hot). With script.setup 15/5. That was an old test, now should be slower. Now on new PC 10/6 and 12/8.
//	Except first time. Also not faster if several scripts are started without a delay. Never mind.
//	This is implemented in this class and in Au.AppHost (just ~10 code lines added in 1 place).
//Not using this workaround since v1.1, unless meta startFaster true (undocumented). Because:
//	Sometimes something does not work well (see problems below).
//	Since this was invented, .NET process startup became faster (faster JIT etc). Also computers faster. The delay now is barely noticeable.
//FUTURE: if this workaround is sometimes useful, make meta startFaster public. Else remove the preloading code.

//PROBLEM when preloaded: miniProgram windows start inactive, behind one or more windows. Unless they activate self, like dialog.
//	It does not depend on the foreground lock setting/API. The setting/API just enable SetForegroundWindow, but most windows don't call it.
//	Workaround: use CBT hook. It receives HCBT_ACTIVATE even when the window does not become the foreground window.
//		On HCBT_ACTIVATE, async-call SetForegroundWindow. Also, editor calls AllowSetForegroundWindow before starting task.

//PROBLEM when preloaded: when miniProgram starts a console program, occasionally its window is inactive, although on top of other windows.
//	To reproduce: run miniProgram script: `run.it("cmd.exe", flags: RFlags.InheritAdmin)`. If starts active, wait at least 30 s and run again.
//	Never noticed it on Windows 10, only on Windows 11.
//	Workaround: after `run.it` wait a while, eg `1.s();`, because it happens only if this process exits immediately.

//PROBLEM when preloaded: inherits old environment variables.

//PROBLEM when preloaded: the preloaded processes may be confusing, even for me sometimes.

//PROBLEM: although Main() starts fast, but the process ends slowly, because of .NET.
//	Eg if starting an empty script every <50 ms, sometimes cannot start.

//Smaller problem: .NET creates many threads. No workaround.

/*
//To test task startup speed, use script "task startup speed.cs":

300.ms(); //give time to preload new task process
for (int i = 0; i < 5; i++) {
//	perf.cpu();
	var t=perf.ms.ToString();
	script.run(@"miniProgram.cs", t);
//	script.run(@"exeProgram.cs", t);
	600.ms(); //give time for the process to exit
}

//miniProgram.cs and exeProgram.cs:

print.it(perf.ms-Int64.Parse(args[0]));
*/

using System.Runtime.Loader;

namespace Au.More;

/// <summary>
/// Prepares to quickly start and execute a script with role <c>miniProgram</c> in this preloaded task process. Or starts/executes in this non-preloaded process.
/// </summary>
static unsafe class MiniProgram_ {
	struct _TaskInit {
		public IntPtr asmFile;
		public IntPtr* args;
		public int nArgs;
	}
	
	/// <summary>
	/// Called by apphost.
	/// </summary>
	[MethodImpl(MethodImplOptions.NoOptimization)]
	static void Init(nint pn, out _TaskInit r) {
		r = default;
		string pipeName = new((char*)pn);
		
		script.role = SRole.MiniProgram;
		
		process.ThisThreadSetComApartment_(ApartmentState.STA); //1.5 ms
		
		script.AppModuleInit_(auCompiler: true); //3 ms
		
		//rejected. Now this is implemented in editor. To detect when failed uses process exit code. Never mind exception text, it is not very useful.
		//process.thisProcessExit += e => { //0.9 ms
		//	if (s_started != 0) print.TaskEvent_(e == null ? "TE" : "TF " + e.ToStringWithoutStack(), s_started);
		//};
		
#if true
		if (!Api.WaitNamedPipe(pipeName, -1)) return;
#else
//rejected: JIT some functions in other thread. Now everything much faster than with old .NET.
//	Speed of p1: with this 3500, without 6000 (slow Deserialize JIT).

		for (int i = 0; ; i++) {
			if (Api.WaitNamedPipe(pipeName, i == 1 ? -1 : 25)) break;
			if (Marshal.GetLastWin32Error() != Api.ERROR_SEM_TIMEOUT) return;
			if (i == 1) break;

			//rejected: ProfileOptimization. Now everything is JIT-ed and is as fast as can be.

			run.thread(() => {
				//using var p2 = perf.local();

				//JIT
				Jit_.Compile(typeof(Serializer_), "Deserialize");
				//tested: now Api functions fast, don't JIT.
				//p2.Next();
				Jit_.Compile(typeof(script), nameof(script.setup), "_AuxThread");
				//p2.Next();

				//Thread.Sleep(20);
				//p2.Next();
				//"Au".ToLowerInvariant(); //15-40 ms //now <1 ms

				//if need to preload some assemblies, use code like this. But now .NET loads assemblies fast, not like in old framework.
				//_ = typeof(TypeFromAssembly).Assembly;
			}, sta: false);
		}
#endif
		
		//Debug_.PrintLoadedAssemblies(true, true);
		
		//using var p1 = perf.local();
		using var pipe = Api.CreateFile(pipeName, Api.GENERIC_READ, 0, Api.OPEN_EXISTING, 0);
		if (pipe.Is0) { Debug_.PrintNativeError(); return; }
		//p1.Next();
		int size; if (!Api.ReadFile(pipe, &size, 4, out int nr, default) || nr != 4) return;
		if (!Api.ReadFileArr(pipe, out var b, size, out nr) || nr != size) return;
		//p1.Next();
		var a = Serializer_.Deserialize(b);
		//p1.Next('d');
		var flags = (MPFlags)(int)a[2];
		
		r.asmFile = Marshal.StringToCoTaskMemUTF8(a[1]);
		//p1.Next();
		string[] args = a[3];
		if (!args.NE_()) {
			r.nArgs = args.Length;
			r.args = (IntPtr*)Marshal.AllocHGlobal(args.Length * sizeof(IntPtr));
			for (int i = 0; i < args.Length; i++) r.args[i] = Marshal.StringToCoTaskMemUTF8(args[i]);
		}
		//p1.Next();
		
		script.s_idMainFile = (uint)(int)a[6];
		script.s_wndEditorMsg = (wnd)(int)a[8];
		script.s_wrPipeName = a[4];
		
		if (0 != (flags & MPFlags.FromEditor)) script.testing = true;
		if (0 != (flags & MPFlags.IsPortable)) ScriptEditor.IsPortable = true;
		
		folders.Editor = new(folders.ThisApp);
		folders.Workspace = new(a[5]);
		
		if (0 != (flags & MPFlags.RefPaths))
			AssemblyLoadContext.Default.Resolving += (alc, an)
				=> ResolveAssemblyFromRefPathsAttribute_(alc, an, AssemblyUtil_.GetEntryAssembly());
		
		if (0 != (flags & MPFlags.NativePaths))
			AssemblyLoadContext.Default.ResolvingUnmanagedDll += (_, dll)
				=> ResolveUnmanagedDllFromNativePathsAttribute_(dll, AssemblyUtil_.GetEntryAssembly());
		
		if (0 != (flags & MPFlags.MTA))
			process.ThisThreadSetComApartment_(ApartmentState.MTA);
		
		if (0 != (flags & MPFlags.Console)) {
			Api.AllocConsole();
		} else {
			if (0 != (flags & MPFlags.RedirectConsole)) RedirectConsole_();
			//Compiler adds this flag if the script uses System.Console assembly.
			//Else new users would not know how to test code examples with Console.WriteLine found on the internet.
		}
		
		//p1.Next();
		script.Starting_(a[0], a[7], preloaded: 0 != (flags & MPFlags.Preloaded));
		
		//Api.QueryPerformanceCounter(out s_started);
		//print.TaskEvent_("TS", s_started);
	}
	
	//for assemblies used in miniProgram and editorExtension scripts
	internal static Assembly ResolveAssemblyFromRefPathsAttribute_(AssemblyLoadContext alc, AssemblyName an, Assembly scriptAssembly) {
		//print.it("managed", an);
		//note: don't cache GetCustomAttribute/split results. It's many times faster than LoadFromAssemblyPath and JIT.
		var attr = scriptAssembly.GetCustomAttribute<RefPathsAttribute>();
		if (attr != null) {
			string name = an.Name;
			foreach (var v in attr.Paths.Split('|')) {
				//print.it(v);
				int iName = v.Length - name.Length - 4;
				if (iName <= 0 || v[iName - 1] != '\\' || !v.Eq(iName, name, true)) continue;
				if (!filesystem.exists(v).File) continue;
				return alc.LoadFromAssemblyPath_(v);
			}
		}
		return null;
	}
	
	internal static Assembly LoadFromAssemblyPath_(this AssemblyLoadContext t, string path) {
		try { return t.LoadFromAssemblyPath(path); }
		catch { }
		//catch (FileLoadException e1) {
		//	Debug_.Print("alc.LoadFromAssemblyPath failed. Will retry with s_alc. " + e1);
		//}
		//If the assembly has the same name as one of TPA assemblies (probably it's a newer version),
		//	the above LoadFromAssemblyPath ignores the path and tries to load the TPA assembly, and fails.
		//	Workaround: Then try to load to another AssemblyLoadContext.
		//return Assembly.LoadFile(path); //works, but better use the same context for all
		s_alc ??= new("Resolving");
		return s_alc.LoadFromAssemblyPath(path);
	}
	static AssemblyLoadContext s_alc;
	
	//for assemblies used in miniProgram and editorExtension scripts
	internal static IntPtr ResolveUnmanagedDllFromNativePathsAttribute_(string name, Assembly scriptAssembly) {
		var attr = scriptAssembly.GetCustomAttribute<NativePathsAttribute>();
		if (attr != null) {
			if (!name.Ends(".dll", true)) name += ".dll";
			foreach (var v in attr.Paths.Split('|')) {
				//print.it(v);
				if (!v.Ends(name, true) || !v.Eq(v.Length - name.Length - 1, '\\')) continue;
				if (NativeLibrary.TryLoad(v, out var h)) return h;
			}
		}
		return default;
	}
	
	/// <summary>
	/// Used by <c>exeProgram</c>.
	/// </summary>
	/// <param name="rootDir">Directory that may contain subdir <c>"runtimes"</c>.</param>
	internal static void ResolveNugetRuntimes_(string rootDir) {
		var runtimesDir = pathname.combine(rootDir, "runtimes");
		if (!filesystem.exists(runtimesDir).Directory) return;
		
		//This code is similar as in Compiler._GetDllPaths:_AddGroup. There we get paths from XML, here from filesystem.
		
		int verPC = osVersion.minWin10 ? 100 : osVersion.minWin8_1 ? 81 : osVersion.minWin8 ? 80 : 70; //don't need Win11
		
		var flags = FEFlags.AllDescendants | FEFlags.IgnoreInaccessible | FEFlags.NeedRelativePaths | FEFlags.UseRawPath;
		List<(FEFile f, int ver)> aNet = [], aNative = [];
		foreach (var f in filesystem.enumFiles(runtimesDir, "*.dll", flags)) {
			var s = f.Name;
			if (!s.Starts(@"\win", true) || s.Length < 10) continue;
			
			int i = 4, verDll = 0;
			if (s[i] is >= '0' and <= '9') {
				verDll = s.ToInt(i, out i);
				if (verDll != 81) verDll *= 10;
				if (verDll > verPC) continue;
			}
			
			if (s[i] == '-') {
				string arch = RuntimeInformation.ProcessArchitecture switch { Architecture.X86 => @"-x86\", Architecture.Arm64 => @"-arm64\", _ => @"-x64\" };
				if (!s.Eq(i, arch, true)) continue;
				i += arch.Length;
			} else if (s[i++] != '\\') {
				continue;
			}
			
			var a = s.Eq(i, @"native\", true) ? aNative : aNet;
			a.Add((f, verDll));
		}
		
		var dr = _Do(aNet);
		var dn = _Do(aNative);
		
		static Dictionary<string, string> _Do(List<(FEFile f, int ver)> a) {
			if (a.Count == 0) return null;
			Dictionary<string, string> d = null;
			foreach (var group in a.ToLookup(o => pathname.getNameNoExt(o.f.Name), StringComparer.OrdinalIgnoreCase)) {
				//print.it($"<><c blue>{group.Key}<>");
				
				int verBest = -1;
				string sBest = null;
				foreach (var (f, verDll) in group) {
					if (verDll > verBest) {
						verBest = verDll;
						sBest = f.FullPath;
					}
				}
				
				if (sBest != null) {
					//print.it(sBest);
					d ??= new(StringComparer.OrdinalIgnoreCase);
					d[group.Key] = sBest;
				}
			}
			
			return d;
		}
		
		if (dr != null) AssemblyLoadContext.Default.Resolving += (alc, an) => {
			if (!dr.TryGetValue(an.Name, out var path)) return null;
			return alc.LoadFromAssemblyPath_(path);
		};
		if (dn != null) AssemblyLoadContext.Default.ResolvingUnmanagedDll += (_, name) => {
			if (name.Ends(".dll", true)) name = name[..^4];
			if (!dn.TryGetValue(name, out var path)) return default;
			if (!NativeLibrary.TryLoad(path, out var r)) return default;
			return r;
		};
	}
	
	[Flags]
	public enum MPFlags {
		/// <summary>Has <c>[RefPaths]</c> attribute. It is when using meta <c>r</c> or <c>nuget</c>.</summary>
		RefPaths = 1,
		
		/// <summary><c>Main</c> with <c>[MTAThread]</c>.</summary>
		MTA = 2,
		
		/// <summary>Has meta <c>console</c> true.</summary>
		Console = 4,
		
		/// <summary>Uses <c>System.Console</c> assembly.</summary>
		RedirectConsole = 8,
		
		/// <summary>Has <c>[NativePaths]</c> attribute. It is when using NuGet packages with native dlls.</summary>
		NativePaths = 16,
		
		/// <summary>Started from editor with the <b>Run</b> button or menu command. Used for <see cref="script.testing"/>.</summary>
		FromEditor = 32,
		
		/// <summary>Started from portable editor.</summary>
		IsPortable = 64,
		
		/// <summary>Using a preloaded process.</summary>
		Preloaded = 128,
		
		//Config = 256, //meta hasConfig
	}
	
	class _ConsoleReader : TextReader {
		public override string ReadLine() {
			if (!dialog.showInput(out string s, "", "Console.ReadLine", screen: screen.ofActiveWindow)) s = "";
			return s;
		}
		
		public override int Read() {
			var s = _read;
			if (s.NE()) {
				if (!dialog.showInput(out s, "", "Console.Read", screen: screen.ofActiveWindow) || s == "") return -1;
			}
			char c = s[0];
			_read = s[1..];
			return (int)c;
		}
		
		string _read;
	}
	
	internal static void RedirectConsole_() {
		print.redirectConsoleOutput = true;
		Console.SetIn(new _ConsoleReader());
	}
}

================================================
FILE: Au/Internal/NamespaceDoc.cs
================================================

//These are not supported by DocFX, but used for code info.
//rejected. Now code info for namespaces does not work.

//namespace Au
//{
//	/// <summary>
//	/// Main classes of the automation library, except triggers.
//	/// </summary>
//	[CompilerGenerated]
//	class NamespaceDoc
//	{
//	}
//}

//namespace Au.Types
//{
//	/// <summary>
//	/// Types of function parameters, exceptions, etc used in the automation library.
//	/// </summary>
//	[CompilerGenerated]
//	class NamespaceDoc
//	{
//	}
//}

//namespace Au.Triggers
//{
//	/// <summary>
//	/// Triggers: hotkeys, autotext, mouse, window.
//	/// </summary>
//	[CompilerGenerated]
//	class NamespaceDoc
//	{
//	}
//}

//namespace Au.More
//{
//	/// <summary>
//	/// Rarely used classes of the automation library.
//	/// </summary>
//	[CompilerGenerated]
//	class NamespaceDoc
//	{
//	}
//}


================================================
FILE: Au/Internal/NativeFont_.cs
================================================
namespace Au.More;

/// <summary>
/// Creates and manages native font handle.
/// </summary>
internal sealed class NativeFont_ : IDisposable {
	IntPtr _h;
	public IntPtr Handle => _h;

	public NativeFont_(IntPtr handle) { _h = handle; }

	public static implicit operator IntPtr(NativeFont_ f) => f?._h ?? default;

	~NativeFont_() { _Dispose(); }
	public void Dispose() { _Dispose(); GC.SuppressFinalize(this); }
	void _Dispose() {
		if (_h != default) { Api.DeleteObject(_h); _h = default; }
	}

	public NativeFont_(int dpi, string name, int height, bool bold = false, bool italic = false) {
		_h = Api.CreateFont(
			-Math2.MulDiv(height, dpi, 72),
			cWeight: bold ? 700 : 0, //FW_BOLD
			bItalic: italic ? 1 : 0,
			//bUnderline: underline ? 1 : 0,
			//bStrikeOut: strikeout ? 1 : 0,
			iCharSet: 1,
			pszFaceName: name);
	}

	public unsafe NativeFont_(int dpi, bool bold, bool italic, int height = 0) {
		Api.LOGFONT m = default;
		Dpi.SystemParametersInfo(Api.SPI_GETICONTITLELOGFONT, sizeof(Api.LOGFONT), &m, dpi);
		if (bold) m.lfWeight = 700;
		if (italic) m.lfItalic = 1;
		if (height != 0) m.lfHeight = -Math2.MulDiv(height, dpi, 72);
		_h = Api.CreateFontIndirect(m);
	}

	public int HeightOnScreen {
		get {
			if (_heightOnScreen == 0) {
				using var dc = new FontDC_(_h);
				_heightOnScreen = dc.MeasureEP("A").height;
			}
			return _heightOnScreen;
		}
	}
	int _heightOnScreen;

	//flags: loword dpi, 0x10000 bold, 0x20000 italic
	static unsafe NativeFont_ _CreateCached(int flags) {
		int dpi = flags & 0xffff;
		bool bold = 0 != (flags & 0x10000), italic = 0 != (flags & 0x20000);
		//if (0 != (flags & 0x100000)) return new NativeFont_(dpi, "Verdana", 9, bold, italic);
		return new NativeFont_(dpi, bold, italic);
	}

	static readonly ConcurrentDictionary<int, NativeFont_> _d = new();

	/// <summary>
	/// Cached standard font used by most windows and controls.
	/// Usually it is <c>Segoe UI</c> 9.
	/// </summary>
	internal static NativeFont_ RegularCached(int dpi) => _d.GetOrAdd(dpi, i => _CreateCached(i));

	/// <summary>
	/// Cached standard bold font used by most windows and controls.
	/// </summary>
	internal static NativeFont_ BoldCached(int dpi) => _d.GetOrAdd(dpi | 0x10000, i => _CreateCached(i));
}

//currently not used
///// <summary>
///// Provides various versions of standard UI font.
///// Per-monitor DPI-aware.
///// </summary>
///// <remarks>
///// The properties return non-cached <c>Font</c> objects. It's safe to dispose them. It's OK to not dispose (GC will do; GDI+ fonts don't use much unmanaged memory).
///// </remarks>
//internal static class Fonts_
//{
//	//info: we don't return cached Font objects, because we cannot protect them from disposing. The Font class is sealed.
//	//	SystemFonts too, always creates new object.
//	//	But eg Brushes and SystemBrushes use cached object. It is not protected from disposing (would be exception later).

//	/// <summary>
//	/// Standard font used by most windows and controls.
//	/// Usually it is <c>Segoe UI</c> 9.
//	/// </summary>
//	public static Font Regular(int dpi) => Font.FromHfont(NativeFont_.RegularCached(dpi));

//	/// <summary>
//	/// Bold version of <see cref="Regular"/> font.
//	/// </summary>
//	public static Font Bold(int dpi) => Font.FromHfont(NativeFont_.BoldCached(dpi));
//}


================================================
FILE: Au/Internal/NativeScrollbar_.cs
================================================
namespace Au.More;

/// <summary>
/// Manages native vertical or horizontal scrollbar of a window.
/// </summary>
internal /*abstract*/ class NativeScrollbar_ {
	readonly bool _vertical;
	readonly Func<int, int> _itemStart, _itemEnd;
	wnd _w;
	int _pos, _max, _nItems, _offset;
	
	public NativeScrollbar_(bool vertical, Func<int, int> itemStart, Func<int, int> itemEnd) {
		_vertical = vertical;
		_itemStart = itemStart;
		_itemEnd = itemEnd;
	}
	//public NativeScrollbar_(bool vertical) {
	//	_vertical = vertical;
	//}
	
	public bool Visible {
		get => _visible;
		set => _Show(value, true);
	}
	bool _visible;
	
	void _Show(bool show, bool api) {
		if (_visible != show) {
			_visible = show;
			if (!show) {
				if (_pos != 0 && !_w.Is0) Api.SCROLLINFO.SetPos(_w, _vertical, 0, false);
				_pos = _max = _offset = 0;
			}
			if (api && !_w.Is0) Api.ShowScrollBar(_w, _vertical ? Api.SB_VERT : Api.SB_HORZ, show);
		}
	}
	
	/// <summary>
	/// If need, shows or hides vertical and/or horizontal scrollbar of same window.
	/// When need to show or hide both, this function is 2 times faster than calling <see cref="Visible"/> separately.
	/// </summary>
	public static void ShowVH(NativeScrollbar_ vert, bool showV, NativeScrollbar_ horz, bool showH) {
		Debug.Assert(vert._w == horz._w && vert._vertical && !horz._vertical);
		if (showV == vert.Visible && showH == horz.Visible) return;
		bool dif = showV != showH;
		vert._Show(showV, dif);
		horz._Show(showH, dif);
		if (!dif) Api.ShowScrollBar(vert._w, Api.SB_BOTH, showV); //2 times faster and 2 times less messages, except wm_paint
	}
	
	//public void SetRange(int max, int page) {
	//	_max = max;
	//	_pos = Math.Min(_pos, max);
	//	Api.SCROLLINFO.SetRange(_w, _vertical, max + page - 1, page, true);
	//}
	
	//protected abstract int ItemStart(int i);
	//protected abstract int ItemEnd(int i);
	
	public void SetRange(int nItems) {
		_max = 0;
		_nItems = nItems;
		if (nItems > 1) {
			var rc = _w.ClientRect;
			int to = _itemEnd(_nItems - 1) - (_vertical ? rc.Height : rc.Width);
			for (int i = _nItems; --i >= 0;) { //how many items in the last page?
				if (_itemStart(i) < to) { _max = i + 1; break; }
			}
		}
		_SetPos(_pos);
		Api.SCROLLINFO.SetRange(_w, _vertical, _nItems - 1, _nItems - _max, true);
	}
	
	bool _SetPos(int pos) {
		pos = Math.Clamp(pos, 0, _max);
		if (pos == _pos) return false;
		_pos = pos;
		_offset = _pos == 0 ? 0 : _itemStart(_pos);
		return true;
	}
	
	void _Scroll(int pos, int part) {
		if (!_SetPos(pos)) return;
		Api.SCROLLINFO.SetPos(_w, _vertical, _pos, true);
		PosChanged?.Invoke(this, part);
	}
	
	/// <summary>
	/// Gets current scroll position (index of top visible item).
	/// Setter sets scroll position, clamped 0-Max. Does not invalidate the control.
	/// </summary>
	public int Pos {
		get => _pos;
		set => _Scroll(value, -1);
	}
	
	public int Offset => _offset;
	
	/// <summary>
	/// Gets max scroll position. Returns 0 if no scrollbar.
	/// </summary>
	public int Max => _max;
	
	/// <summary>
	/// Gets or sets item count.
	/// Use setter to set item count when there is no scrollbar; asserts <c>!_visible</c>.
	/// </summary>
	public int NItems {
		get => _nItems;
		set {
			Debug.Assert(!_visible);
			_nItems = value;
		}
	}
	
	/// <summary>
	/// When scrollbar position changed.
	/// The <c>int</c> parameter is event source: if scrollbar, it is one of <c>Api.SB_</c> constants; if <see cref="Pos"/>, it is -1; if wheel, it is -2 if down, -3 if up.
	/// </summary>
	public event Action<NativeScrollbar_, int> PosChanged;
	
	public bool WndProc(wnd w, int msg, nint wParam, nint lParam) {
		_w = w;
		switch (msg) {
		case Api.WM_NCDESTROY:
			_w = default;
			break;
		case Api.WM_VSCROLL when _vertical:
		case Api.WM_HSCROLL when !_vertical:
			_WmScroll(Math2.LoWord(wParam));
			return true;
		case Api.WM_MOUSEWHEEL:
			_WmScroll(Math2.HiShort(wParam) < 0 ? -2 : -3);
			return true;
		}
		return false;
	}
	
	void _WmScroll(int part) {
		if (!_visible) return;
		int pos = _pos;
		switch (part) {
		case Api.SB_THUMBTRACK:
			pos = Api.SCROLLINFO.GetTrackPos(_w, _vertical);
			break;
		case Api.SB_LINEDOWN: pos++; break;
		case Api.SB_LINEUP: pos--; break;
		case Api.SB_PAGEDOWN or Api.SB_PAGEUP:
			var rc = _w.ClientRect;
			int clientSize = _vertical ? rc.Height : rc.Width;
			if (part == Api.SB_PAGEDOWN) {
				for (int to = _offset + clientSize; pos < _nItems && _itemEnd(pos) <= to;) pos++;
			} else {
				for (int to = _offset - clientSize; pos >= 0 && _itemStart(pos) >= to;) pos--;
				pos++;
			}
			break;
		case Api.SB_TOP: pos = 0; break;
		case Api.SB_BOTTOM: pos = _max; break;
		case -2 or -3:
			int k = Api.SystemParametersInfo(Api.SPI_GETWHEELSCROLLLINES, 3);
			pos += part == -2 ? k : -k;
			break;
		default: return;
		}
		_Scroll(pos, part);
	}
	
	/// <summary>
	/// Calculates new focused item index when pressed key <c>Down</c>, <c>Up</c>, <c>PageDown</c>, <c>PageUp</c>, <c>End</c> or <c>Home</c>.
	/// </summary>
	/// <param name="i">Current focused item index. Can be -1.</param>
	/// <param name="k"></param>
	/// <remarks>
	/// This scrollbar must be vertical. Asserts.
	/// Returns unchanged <i>i</i> (even if -1) if <i>k</i> isn't a navigation key or if cannot change focused item.
	/// Works like standard list controls.
	/// </remarks>
	public int KeyNavigate(int i, KKey k) {
		Debug.Assert(_vertical);
		if (!_vertical || _nItems == 0) return i;
		switch (k) {
		case KKey.Home: i = 0; break;
		case KKey.End: i = int.MaxValue; break;
		case KKey.Down: i++; break;
		case KKey.Up: if (i < 0) i = int.MaxValue; else i--; break;
		case KKey.PageDown when i < _nItems - 1:
		case KKey.PageUp when i > 0:
			int clientHeight = _w.ClientRect.Height;
			if (k == KKey.PageDown) {
				int to = _offset + clientHeight;
				if (_itemEnd(i + 1) > to) to = _itemStart(i + 1) + clientHeight;
				while (i + 1 < _nItems && _itemEnd(i + 1) <= to) i++;
			} else {
				int to = _offset;
				if (i == _pos) to -= clientHeight;
				while (i - 1 >= 0 && _itemStart(i - 1) >= to) i--;
			}
			break;
		default: return i;
		}
		
		return Math.Clamp(i, 0, _nItems - 1);
	}
}


================================================
FILE: Au/Internal/NativeThread_.cs
================================================
namespace Au.More;

/// <summary>
/// Represents a thread created using API <c>CreateThread</c>.
/// Use when need thread handle/id ASAP, or to call APC easier.
/// </summary>
unsafe class NativeThread_ {
	nint _handle;
	int _tid;
	bool _sta, _threadInited;
	Action _proc;
	nint _initEvent; //much faster than with ManualResetEvent or ManualResetEventSlim

	~NativeThread_() {
		Api.CloseHandle(_handle);
		if (_initEvent != 0) Api.CloseHandle(_initEvent);
	}

	/// <summary>
	/// Starts new background thread using API <c>CreateThread</c>.
	/// <para>Note: in thread proc use <see cref="OfThisThread"/>, not a static field inited like <c>s_thread = new NativeThread_(...);</c>, because <i>s_thread</i> may be still null.</para>
	/// </summary>
	/// <param name="proc">Thread procedure.</param>
	/// <param name="sta">Set <c>ApartmentState.STA</c>.</param>
	/// <param name="waitInited">Wait now until the thread procedure calls <see cref="ThreadInited"/>.</param>
	public NativeThread_(Action proc, bool sta = true, bool waitInited = false) {
		_proc = proc;
		_sta = sta;
		if (waitInited) _initEvent = Api.CreateEvent2(default, true, false, null);
		_handle = Api.CreateThread(default, 0, &_Thread, GCHandle.Alloc(this), 0, out _tid);
		if (waitInited) {
			Api.WaitForSingleObject(_initEvent, -1);
			Api.CloseHandle(_initEvent);
			_initEvent = 0;
		}
	}

	/// <summary>
	/// Gets thread handle.
	/// The finalizer closes the handle. The object is not garbage-collected while the thread procedure is running.
	/// </summary>
	public nint Handle => _handle;

	/// <summary>
	/// Gets thread id.
	/// </summary>
	public nint Id => _tid;

	public static NativeThread_ OfThisThread => t_ofThisThread;
	[ThreadStatic] static NativeThread_ t_ofThisThread;

	[UnmanagedCallersOnly]
	static uint _Thread(GCHandle param) {
		var t = param.Target as NativeThread_;
		param.Free();
		t_ofThisThread = t;
		if (t._sta) Thread.CurrentThread.SetApartmentState(ApartmentState.STA);
		t._proc();
		return 0;
	}

	/// <summary>
	/// The thread procedure must call this when finished thread initialization and going to run an alertable message loop.
	/// If constructor was called with <i>waitInited</i> <c>true</c>, it will return (stop waiting).
	/// If actions were queued, executes them now.
	/// Example: <c>NativeThread_.OfThisThread.ThreadInited();</c>
	/// Note: don't use code like <c>s_thread.ThreadInited();</c>, because <i>s_thread</i> (inited like <c>s_thread = new NativeThread_(...);</c>) may be still null.
	/// </summary>
	public void ThreadInited() {
		if (_initEvent != 0) Api.SetEvent(_initEvent);
		_threadInited = true;
		if (t_queue is { } q) {
			t_queue = null;
			q.Invoke();
		}
	}

	public void QueueAPC(Action a) {
		Api.QueueUserAPC(&_Apc, _handle, GCHandle.Alloc(a));
	}
	
	[ThreadStatic] static Action t_queue;
	
	[UnmanagedCallersOnly]
	static void _Apc(GCHandle param) {
		var a = param.Target as Action;
		param.Free();
		if (t_ofThisThread is {  } t && t._threadInited) a(); else t_queue += a;
	}

	public static void AlertableMessageLoop() {
		for (; ; ) {
			var k = Api.MsgWaitForMultipleObjectsEx(0, null, -1, Api.QS_ALLINPUT, Api.MWMO_ALERTABLE | Api.MWMO_INPUTAVAILABLE);
			if (k == 0) {
				if (!wait.doEvents()) break;
			} else if (k != Api.WAIT_IO_COMPLETION) {
				Debug_.Print(k);
				break;
			}
		}
	}
}


================================================
FILE: Au/Internal/PostToThisThread_.cs
================================================
namespace Au.More;

/// <summary>
/// Executes actions in same UI thread as ctor.
/// Use <see cref="OfThisThread"/>. Cannot create more instances.
/// </summary>
class PostToThisThread_ {
	readonly wnd _w;
	readonly Queue<Action> _q = new();
	
	PostToThisThread_() {
		_w = WndUtil.CreateWindowDWP_(messageOnly: true, t_wp = _WndProc);
		ManagedThreadId = Environment.CurrentManagedThreadId;
	}
	
	public static PostToThisThread_ OfThisThread => t_default ??= new();
	[ThreadStatic] static PostToThisThread_ t_default;
	[ThreadStatic] static WNDPROC t_wp;
	
	public int ManagedThreadId { get; }
	
	public void Post(Action a) {
		bool post;
		lock (this) {
			post = _q.Count == 0;
			_q.Enqueue(a);
		}
		if (post) _w.Post(Api.WM_USER);
	}
	
	nint _WndProc(wnd w, int message, nint wParam, nint lParam) {
		switch (message) {
		case Api.WM_USER:
			//print.it(_q.Count);
			object o;
			lock (this) {
				o = _q.Count switch { 0 => null, 1 => _q.Dequeue(), _ => _q.ToArray() };
				_q.Clear();
			}
			switch (o) {
			case Action a:
				a();
				break;
			case Action[] a:
				foreach (var f in a) f();
				break;
			}
			return default;
		}
		
		return Api.DefWindowProc(w, message, wParam, lParam);
	}
}


================================================
FILE: Au/Internal/ProcessStarter_.cs
================================================
using Microsoft.Win32.SafeHandles;

namespace Au.More;

unsafe struct ProcessStarter_ {
	public char[] cl;
	public Api.STARTUPINFO si;
	public uint flags;
	public string curDir;
	public string envVar;
	string _exe; //for errors only
	
	/// <summary>
	/// Prepares parameters for API <ms>CreateProcess</ms> and similar.
	/// </summary>
	/// <param name="exe">
	/// Full path of program file. If not full path, uses <see cref="folders.ThisApp"/>. Uses <see cref="pathname.normalize"/>.
	/// If <i>rawExe</i> <c>true</c>, does not use <c>Normalize</c>/<c>ThisApp</c>.
	/// </param>
	/// <param name="args"><c>null</c> or command line arguments.</param>
	/// <param name="curDir">
	/// Initial current directory of the new process.
	/// - If <c>null</c>, uses <c>Directory.GetCurrentDirectory()</c>.
	/// - Else if <i>rawCurDir</i>==<c>true</c>, uses raw <i>curDir</i> value.
	/// - Else if <c>""</c>, calls <c>pathname.getDirectory(exe)</c>.
	/// - Else calls <see cref="pathname.expand"/>.
	/// </param>
	/// <param name="envVar"><c>null</c> or environment variables to pass to the new process together with variables of this process. Format: <c>"var1=value1\0var2=value2\0"</c>. If ends with <c>"\0\0"</c>, will pass only these variables.</param>
	/// <param name="rawExe">Don't normalize <i>exe</i>.</param>
	/// <param name="rawCurDir">Don't normalize <i>curDir</i>.</param>
	public ProcessStarter_(string exe, string args = null, string curDir = null, string envVar = null, bool rawExe = false, bool rawCurDir = false) {
		if (!rawExe) exe = pathname.normalize(exe, folders.ThisApp, PNFlags.DontExpandDosPath | PNFlags.DontPrefixLongPath);
		_exe = exe;
		cl = (args == null ? ("\"" + exe + "\"" + "\0") : ("\"" + exe + "\" " + args + "\0")).ToCharArray();
		if (curDir == null) this.curDir = Directory.GetCurrentDirectory(); //if null passed to CreateProcessWithTokenW, the new process does not inherit current directory of this process
		else this.curDir = rawCurDir ? curDir : (curDir.Length == 0 ? pathname.getDirectory(exe) : pathname.expand(curDir));
		
		si.cb = Api.SizeOf<Api.STARTUPINFO>();
		si.dwFlags = Api.STARTF_FORCEOFFFEEDBACK;
		
		flags = Api.CREATE_UNICODE_ENVIRONMENT;
		
		if (envVar != null && !envVar.Ends("\0\0")) {
			var es = Api.GetEnvironmentStrings();
			int len1; for (var k = es; ; k++) if (k[0] == 0 && k[1] == 0) { len1 = (int)(k - es) + 2; break; }
			int len2 = envVar.Length;
			var t = new string('\0', len1 + len2);
			fixed (char* p = t) {
				MemoryUtil.Copy(es, p, --len1 * 2);
				for (int i = 0; i < envVar.Length; i++) p[len1 + i] = envVar[i];
			}
			this.envVar = t;
			Api.FreeEnvironmentStrings(es);
		} else this.envVar = null;
	}
	
	/// <summary>
	/// Starts process using API <c>CreateProcess</c> or <c>CreateProcessAsUser</c>, without the feedback hourglass cursor.
	/// </summary>
	/// <param name="pi">Receives <c>CreateProcessX</c> results. Will need to close handles in <i>pi</i>, eg <c>pi.Dispose</c>.</param>
	/// <param name="inheritUiaccess">If this process has UAC integrity level uiAccess, let the new process inherit it.</param>
	/// <param name="inheritHandles">API parameter <i>bInheritHandles</i>.</param>
	public bool StartL(out Api.PROCESS_INFORMATION pi, bool inheritUiaccess = false, bool inheritHandles = false) {
		if (inheritUiaccess && Api.OpenProcessToken(Api.GetCurrentProcess(), Api.TOKEN_QUERY | Api.TOKEN_DUPLICATE | Api.TOKEN_ASSIGN_PRIMARY, out Handle_ hToken)) {
			using (hToken) return Api.CreateProcessAsUser(hToken, null, cl, null, null, inheritHandles, flags, envVar, curDir, si, out pi);
		} else {
			return Api.CreateProcess(null, cl, null, null, inheritHandles, flags, envVar, curDir, si, out pi);
		}
	}
	
	/// <summary>
	/// Starts process using API <c>CreateProcess</c> or <c>CreateProcessAsUser</c>, without the feedback hourglass cursor.
	/// </summary>
	/// <param name="need">Which field to set in <c>Result</c>.</param>
	/// <param name="inheritUiaccess">If this process has UAC integrity level uiAccess, let the new process inherit it.</param>
	/// <exception cref="AuException">Failed.</exception>
	public Result Start(Result.Need need = 0, bool inheritUiaccess = false) {
		bool suspended = need == Result.Need.NetProcess && !_NetProcessObject.IsFast, resetSuspendedFlag = false;
		if (suspended && 0 == (flags & Api.CREATE_SUSPENDED)) { flags |= Api.CREATE_SUSPENDED; resetSuspendedFlag = true; }
		bool ok = StartL(out var pi, inheritUiaccess);
		if (resetSuspendedFlag) flags &= ~Api.CREATE_SUSPENDED;
		if (!ok) throw new AuException(0, $"*start process '{_exe}'");
		return new Result(pi, need, suspended);
	}
	
	/// <summary>
	/// Starts UAC Medium integrity level (IL) process from this admin process.
	/// </summary>
	/// <param name="need">Which field to set in <c>Result</c>.</param>
	/// <exception cref="AuException">Failed.</exception>
	/// <remarks>
	/// Actually the process will have the same IL and user session as the shell process (normally explorer).
	/// Fails if there is no shell process (API <c>GetShellWindow</c> fails) for more than 2 s from calling this func.
	/// Asserts and fails if this is not admin/system process. Caller should at first call <see cref="uacInfo.isAdmin"/> or <see cref="uacInfo.IntegrityLevel"/>.
	/// </remarks>
	public Result StartUserIL(Result.Need need = 0) {
		if (s_userToken == null) {
			Debug.Assert(uacInfo.isAdmin); //else cannot set privilege
			if (!SecurityUtil.SetPrivilege("SeIncreaseQuotaPrivilege", true)) goto ge;
			
			//perf.first();
#if false //works, but slow, eg 60 ms, even if we don't create task everytime
			var s = $"\"{folders.ThisAppBS}{(osVersion.is32BitProcess ? "32" : "64")}\\AuCpp.dll\",Cpp_RunDll";
			Au.WinTaskScheduler.Scheduler.CreateTaskToRunProgramOnDemand("Au", "rundll32", false, folders.System + "rundll32.exe", s);
			//Au.WinTaskScheduler.Scheduler.CreateTaskToRunProgramOnDemand("Au", "rundll32", false, folders.System + "notepad.exe"); //slow too
			//perf.next();
			int pid = Au.WinTaskScheduler.Scheduler.RunTask("Au", "rundll32");
			//perf.next();
			//print.it(pid);
			var hUserProcess = Handle_.OpenProcess(pid);
			//print.it((IntPtr)hUserProcess);
			if(hUserProcess.Is0) goto ge;
#else
			bool retry = false;
			g1:
			var w = Api.GetShellWindow();
			if (w.Is0) { //if Explorer process killed or crashed, wait until it restarts
				if (!wait.until(2, () => !Api.GetShellWindow().Is0)) throw new AuException($"*start process '{_exe}' as user. There is no shell process.");
				500.ms();
				w = Api.GetShellWindow();
			}
			
			var hUserProcess = Handle_.OpenProcess(w);
			if (hUserProcess.Is0) {
				if (retry) goto ge;
				retry = true; 500.ms(); goto g1;
			}
			
			//two other ways:
			//1. Enum processes and find one that has Medium IL. Unreliable, eg its token may be modified.
			//2. Start a service process. Let it start a Medium IL process like in QM2. Because LocalSystem can get token with WTSQueryUserToken.
			//tested: does not work with GetTokenInformation(TokenLinkedToken). Even if would work, in non-admin session it is wrong token.
#endif
			//perf.nw();
			
			using (hUserProcess) {
				if (Api.OpenProcessToken(hUserProcess, Api.TOKEN_DUPLICATE, out Handle_ hShellToken)) {
					using (hShellToken) {
						const uint access = Api.TOKEN_QUERY | Api.TOKEN_ASSIGN_PRIMARY | Api.TOKEN_DUPLICATE | Api.TOKEN_ADJUST_DEFAULT | Api.TOKEN_ADJUST_SESSIONID;
						if (Api.DuplicateTokenEx(hShellToken, access, null, Api.SECURITY_IMPERSONATION_LEVEL.SecurityImpersonation, Api.TOKEN_TYPE.TokenPrimary, out var userToken))
							s_userToken = new SafeAccessTokenHandle(userToken);
					}
				}
			}
			if (s_userToken == null) goto ge;
		}
		
		bool suspended = need == Result.Need.NetProcess && !_NetProcessObject.IsFast, resetSuspendedFlag = false;
		if (suspended && 0 == (flags & Api.CREATE_SUSPENDED)) { flags |= Api.CREATE_SUSPENDED; resetSuspendedFlag = true; }
		bool ok = Api.CreateProcessWithTokenW(s_userToken.DangerousGetHandle(), 0, null, cl, flags, envVar, curDir, si, out var pi);
		if (resetSuspendedFlag) flags &= ~Api.CREATE_SUSPENDED;
		if (!ok) goto ge;
		return new Result(pi, need, suspended);
		
		ge: throw new AuException(0, $"*start process '{_exe}' as user");
	}
	static SafeAccessTokenHandle s_userToken;
	
	/// <summary>
	/// Results of <see cref="ProcessStarter_"/> functions.
	/// </summary>
	public class Result {
		/// <summary>
		/// Which field to set.
		/// </summary>
		public enum Need {
			None,
			//NativeHandle,
			WaitHandle,
			NetProcess,
		}
		
		public int pid;
		public WaitHandle waitHandle;
		public Process netProcess;
		
		internal Result(in Api.PROCESS_INFORMATION pi, Need need, bool suspended) {
			pid = pi.dwProcessId;
			switch (need) {
			case Need.NetProcess:
				netProcess = _NetProcessObject.Create(pi, suspended: suspended);
				break;
			case Need.WaitHandle:
				pi.hThread.Dispose();
				waitHandle = new WaitHandle_(pi.hProcess, true);
				break;
			default:
				pi.Dispose();
				break;
			}
		}
	}
	
	/// <summary>
	/// Creates new .NET Process object with attached handle and/or id.
	/// </summary>
	static class _NetProcessObject //FUTURE: remove if unused
	{
		/// <summary>
		/// Returns <c>true</c> if can create such object in a fast/reliable way. Else <see cref="Create"/> will use <c>Process.GetProcessById</c>.
		/// It depends on .NET framework version, because uses private methods of Process class through reflection.
		/// </summary>
		public static bool IsFast { get; } = _CanSetHandleId();
		
		public static bool _CanSetHandleId() {
			const BindingFlags flags = BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.InvokeMethod;
			s_mi1 = typeof(Process).GetMethod("SetProcessHandle", flags);
			s_mi2 = typeof(Process).GetMethod("SetProcessId", flags);
			if (s_mi1 != null && s_mi2 != null) return true;
			Debug.Assert(false);
			return false;
		}
		static MethodInfo s_mi1, s_mi2;
		
		/// <summary>
		/// Creates new .NET Process object with attached handle and/or id.
		/// Can be specified both handle and id, or one of them (then .NET will open process or get id from handle when need).
		/// </summary>
		public static Process Create(IntPtr handle, int id) {
			if (!IsFast) {
				if (id == 0) id = process.processIdFromHandle(handle);
				return Process.GetProcessById(id); //3 ms, much garbage, gets all processes, can throw
			}
			
			var p = new Process();
			var o = new object[1];
			if (handle != default) {
				o[0] = new SafeProcessHandle(handle, true);
				s_mi1.Invoke(p, o);
			}
			if (id != 0) {
				o[0] = id;
				s_mi2.Invoke(p, o);
			}
			return p;
		}
		
		/// <summary>
		/// Creates new .NET Process object with attached handle and id.
		/// Closes thread handle. If suspended, resumes thread.
		/// </summary>
		public static Process Create(in Api.PROCESS_INFORMATION pi, bool suspended) {
			try {
				return Create(pi.hProcess, pi.dwProcessId);
			}
			finally {
				if (suspended) Api.ResumeThread(pi.hThread);
				pi.hThread.Dispose();
			}
		}
	}
}


================================================
FILE: Au/Internal/Ptr_.cs
================================================
namespace Au.More;

/// <summary>
/// String functions for unmanaged <c>char*</c> or <c>byte*</c> strings.
/// </summary>
internal static unsafe class Ptr_ {
	#region char*
	
	/// <summary>
	/// Gets span from start to <c>'\0'</c>.
	/// </summary>
	public static RStr ToRSpan(char* p) => MemoryMarshal.CreateReadOnlySpanFromNullTerminated(p);
	
	/// <summary>
	/// Gets the number of characters in <i>p</i> until <c>'\0'</c>.
	/// </summary>
	/// <param name="p"><c>'\0'</c>-terminated string. Can be <c>null</c>.</param>
	public static int Length(char* p) => MemoryMarshal.CreateReadOnlySpanFromNullTerminated(p).Length;
	
	/// <summary>
	/// Gets the number of characters in <i>p</i> until <c>'\0'</c> or <i>max</i>.
	/// </summary>
	/// <param name="p"><c>'\0'</c>-terminated string. Can be null if <i>max</i> is 0.</param>
	/// <param name="max">Max length to scan. Returns <i>max</i> if does not find <c>'\0'</c>.</param>
	public static int Length(char* p, int max) {
		int i = new RStr(p, max).IndexOf('\0');
		return i < 0 ? max : i;
	}
	
	#endregion
	
	#region byte*
	
	/// <summary>
	/// Gets span from start to <c>'\0'</c>.
	/// </summary>
	public static RByte ToRSpan(byte* p) => MemoryMarshal.CreateReadOnlySpanFromNullTerminated(p);
	
	/// <summary>
	/// Gets the number of bytes in <i>p</i> until <c>'\0'</c>.
	/// </summary>
	/// <param name="p"><c>'\0'</c>-terminated string. Can be <c>null</c>.</param>
	public static int Length(byte* p) => MemoryMarshal.CreateReadOnlySpanFromNullTerminated(p).Length;
	
	/// <summary>
	/// Gets the number of bytes in <i>p</i> until <c>'\0'</c> or <i>max</i>.
	/// </summary>
	/// <param name="p"><c>'\0'</c>-terminated string. Can be null if <i>max</i> is 0.</param>
	/// <param name="max">Max length to scan. Returns <i>max</i> if does not find <c>'\0'</c>.</param>
	public static int Length(byte* p, int max) {
		int i = new RByte(p, max).IndexOf((byte)0);
		return i < 0 ? max : i;
	}
	
	#endregion
}


================================================
FILE: Au/Internal/Serializer_.cs
================================================
namespace Au.More;

/// <summary>
/// Binary-serializes and deserializes multiple values of types <c>int</c>, <c>string</c>, <c>string[]</c>, <c>byte[]</c> and <c>null</c>.
/// Used mostly for sending parameters for IPC through pipe etc.
/// Similar to <c>BinaryWriter</c>, but faster and less garbage. Much faster than <c>BinaryFormatter</c>, CSV, etc.
/// Serializes all values into a <c>byte[]</c> in single call. If need to append, use <c>BinaryWriter</c> instead.
/// </summary>
internal static unsafe class Serializer_ {
	/// <summary>
	/// Type of input and output values of <see cref="Serializer_"/> functions.
	/// Has implicit conversions from/to <c>int</c> and <c>string</c>.
	/// </summary>
	public struct Value {
		public object Obj;
		public int Int;
		public VType Type;
		
		Value(int i) { Obj = null; Int = i; Type = VType.Int; }
		Value(object o, VType type) { Obj = o; Int = 0; Type = o != null ? type : VType.Null; }
		
		public static implicit operator Value(int i) => new Value(i);
		public static implicit operator Value(string s) => new Value(s, VType.String);
		public static implicit operator Value(string[] a) => new Value(a, VType.StringArray);
		public static implicit operator Value(byte[] a) => new Value(a, VType.ByteArray);
		
		public static implicit operator int(Value a) => a.Int;
		public static implicit operator string(Value a) => a.Obj as string;
		public static implicit operator string[](Value a) => a.Obj as string[];
		public static implicit operator byte[](Value a) => a.Obj as byte[];
	}
	
	public enum VType { Null, Int, String, StringArray, ByteArray }
	
	/// <summary>
	/// Serializes multiple values of types <c>int</c>, <c>string</c>, <c>string[]</c> and <c>null</c>.
	/// The returned array can be passed to <see cref="Deserialize"/>.
	/// </summary>
	public static byte[] Serialize(params Value[] a) => _Serialize(false, a);
	
	/// <summary>
	/// Serializes multiple values of types <c>int</c>, <c>string</c>, <c>string[]</c> and <c>null</c>.
	/// Unlike <see cref="Serialize"/>, in the first 4 bytes writes the size of data that follows.
	/// Can be used with pipes or other streams where data size is initially unknown: read 4 bytes as <c>int dataSize</c>; <c>var b=new byte[dataSize]</c>, read it, pass <c>b</c> to <see cref="Deserialize"/>. 
	/// </summary>
	public static byte[] SerializeWithSize(params Value[] a) => _Serialize(true, a);
	
	static byte[] _Serialize(bool withSize, Value[] a) {
		int size = 4;
		if (withSize) size += 4;
		for (int i = 0; i < a.Length; i++) {
			size++;
			switch (a[i].Type) {
			case VType.Int: size += 4; break;
			case VType.String: size += 4 + (a[i].Obj as string).Length * 2; break;
			case VType.StringArray:
				int z = 4;
				foreach (var v in a[i].Obj as string[]) z += 4 + v.Lenn() * 2;
				size += z;
				break;
			case VType.ByteArray: size += 4 + (a[i].Obj as byte[]).Length; break;
			}
		}
		var ab = new byte[size];
		fixed (byte* b0 = ab) {
			byte* b = b0;
			if (withSize) { *(int*)b = ab.Length - 4; b += 4; }
			*(int*)b = a.Length; b += 4;
			for (int i = 0; i < a.Length; i++) {
				var ty = a[i].Type;
				*b++ = (byte)ty;
				switch (ty) {
				case VType.Int:
					*(int*)b = a[i].Int;
					b += 4;
					break;
				case VType.String:
					var s = a[i].Obj as string;
					_AddString(s);
					break;
				case VType.StringArray:
					var k = a[i].Obj as string[];
					*(int*)b = k.Length; b += 4;
					foreach (var v in k) {
						if (v != null) _AddString(v);
						else { *(int*)b = -1; b += 4; }
					}
					break;
				case VType.ByteArray:
					var u = a[i].Obj as byte[];
					*(int*)b = u.Length; b += 4;
					u.CopyTo(ab, b - b0);
					b += u.Length;
					break;
				}
			}
			Debug.Assert((b - b0) == size);
			
			void _AddString(string s) {
				*(int*)b = s.Length; b += 4;
				var c = (char*)b;
				for (int j = 0; j < s.Length; j++) c[j] = s[j];
				b += s.Length * 2;
			}
		}
		return ab;
	}
	
	/// <summary>
	/// Deserializes values serialized by <see cref="Serialize"/>.
	/// Returns array of values passed to <c>Serialize</c>.
	/// </summary>
	public static Value[] Deserialize(RByte serialized) {
		fixed (byte* b0 = serialized) {
			byte* b = b0;
			int n = *(int*)b; b += 4;
			var a = new Value[n];
			for (int i = 0; i < n; i++) {
				switch ((VType)(*b++)) {
				case VType.Null:
					break;
				case VType.Int:
					a[i] = *(int*)b; b += 4;
					break;
				case VType.String:
					a[i] = _GetString();
					break;
				case VType.StringArray:
					var k = new string[*(int*)b]; b += 4;
					for (int j = 0; j < k.Length; j++) k[j] = _GetString();
					a[i] = k;
					break;
				case VType.ByteArray:
					int len = *(int*)b; b += 4;
					a[i] = serialized.Slice((int)(b - b0), len).ToArray();
					b += len;
					break;
				default: throw new ArgumentException();
				}
			}
			return a;
			
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			string _GetString() {
				int len = *(int*)b; b += 4;
				if (len == -1) return null;
				var R = new string((char*)b, 0, len);
				b += len * 2;
				return R;
			}
		}
	}
}


================================================
FILE: Au/Internal/SharedMemory_.cs
================================================
namespace Au.More;

/// <summary>
/// Memory shared by all processes using this library.
/// </summary>
[StructLayout(LayoutKind.Sequential, Size = c_size)]
unsafe struct SharedMemory_ {
	#region variables used by our library classes
	//Declare variables used by our library classes.
	//Be careful:
	//1. Some type sizes are different in 32 and 64 bit process.
	//	Solution: Use long and cast to IntPtr etc. For wnd use int.
	//2. The memory may be used by processes that use different library versions.
	//	Solution: In new library versions don't change struct sizes and old members.
	//		Maybe reserve some space for future members. If need more, add new struct.
	//		Use eg [StructLayout(LayoutKind.Sequential, Size = 16)].
	
	//reserve 16 for some header, eg shared memory version.
	[StructLayout(LayoutKind.Sequential, Size = 16)] struct _Header { }
	_Header _h;
	
	internal PrintServer.SharedMemoryData_ outp;
	internal Triggers.ActionTriggers.SharedMemoryData_ triggers;
	internal WindowsHook.SharedMemoryData_ winHook;
	internal perf.Instance perf;
	internal script.SharedMemoryData_ script;
	//internal ScriptEditor.SharedMemoryData_ editor;
	
	//public const int TasksDataSize_ = 0x4000;
	//internal struct TasksData_ { public int size; public fixed byte data[TasksDataSize_]; }
	//internal TasksData_ tasks;
	
	#endregion
	
	const int c_size = 0x200000; //2 MB
	
	static SharedMemory_() {
		Ptr = (SharedMemory_*)Mapping.CreateOrOpen("Au-memory-lib", c_size).Mem;
	}
	
	/// <summary>
	/// Pointer to the shared memory.
	/// </summary>
	public static readonly SharedMemory_* Ptr;
	
	/// <summary>
	/// Gets pointer to the shared memory "return data" buffer.
	/// Used by <see cref="WndCopyData.Return"/>.
	/// </summary>
	public static byte* ReturnDataPtr => (byte*)Ptr + c_size / 2;
	
	/// <summary>
	/// Size of <see cref="ReturnDataPtr"/> buffer, 1 MB.
	/// </summary>
	public const int ReturnDataSize = c_size / 2;
	
	/// <summary>
	/// Shared memory pointer and mapping handle.
	/// </summary>
	public struct Mapping : IDisposable {
		IntPtr _hMapping;
		void* _mem;
		
		public void* Mem => _mem;
		
		/// <summary>
		/// Created new memory. If <c>false</c> - opened existing.
		/// </summary>
		public bool Created { get; }
		
		internal Mapping(IntPtr h, void* m, bool created) {
			_hMapping = h;
			_mem = m;
			Created = created;
		}
		
		public void Dispose() {
			if (_mem != null) { Api.UnmapViewOfFile(_mem); _mem = null; }
			if (_hMapping != default) { Api.CloseHandle(_hMapping); _hMapping = default; }
		}
		
		/// <summary>
		/// Creates named shared memory of specified size. Opens if already exists.
		/// Returns <c>Mapping</c> variable that contains shared memory address in this process.
		/// </summary>
		/// <param name="name">Shared memory name. Case-insensitive.</param>
		/// <param name="size">Shared memory size. Ignored if the shared memory already exists.</param>
		/// <exception cref="AuException">The API failed.</exception>
		/// <remarks>
		/// Calls API <ms>CreateFileMapping</ms> and API <ms>MapViewOfFile</ms>.
		/// The shared memory is alive at least until this process ends or the returned <c>Mapping</c> variable disposed. Other processes can keep the memory alive even after that.
		/// </remarks>
		public static Mapping CreateOrOpen(string name, int size) {
			//CONSIDER: don't use Api.SECURITY_ATTRIBUTES.ForLowIL. Speed with it 2.7 ms, without 1.7 ms.
			//	But then cannot use this library in low IL processes. Probably never used anyway.
			//	Try to move everything to the cpp dll.
			
			var hm = Api.CreateFileMapping((IntPtr)~0, Api.SECURITY_ATTRIBUTES.ForLowIL, Api.PAGE_READWRITE, 0, (uint)size, name);
			if (!hm.Is0) {
				bool created = lastError.code != Api.ERROR_ALREADY_EXISTS;
				var mem = Api.MapViewOfFile(hm, 0x000F001F, 0, 0, 0); //FILE_MAP_ALL_ACCESS
				if (mem != default) return new(hm, mem, created);
				hm.Dispose();
			}
			throw new AuException(0, "*open shared memory");
		}
		
		public static bool TryOpenExisting(string name, out Mapping r) {
			r = default;
			var hm = Api.OpenFileMapping(0x2, false, name); //FILE_MAP_WRITE
			if (hm.Is0) return false;
			var mem = Api.MapViewOfFile(hm, 0x000F001F, 0, 0, 0); //FILE_MAP_ALL_ACCESS
			if (mem == default) { hm.Dispose(); return false; }
			r = new(hm, mem, false);
			return true;
		}
	}
}


================================================
FILE: Au/Internal/StaTaskScheduler_.cs
================================================
//
// Copyright (c) Microsoft. All rights reserved.
// Licensed under the MIT license. See LICENSE.md file in the project root for full license information.
//

namespace Au.More;

/// <summary>Provides a scheduler that uses STA threads.</summary>
sealed class StaTaskScheduler_ : TaskScheduler, IDisposable {
	/// <summary>
	/// Static auto-created <c>StaTaskScheduler_</c> instance with 4 threads.
	/// </summary>
	public static new StaTaskScheduler_ Default => _default.Value;
	readonly static Lazy<StaTaskScheduler_> _default = new Lazy<StaTaskScheduler_>(() => new StaTaskScheduler_(4)); //info: 3-4 is optimal for getting icons
	
	/// <summary>Stores the queued tasks to be executed by our pool of STA threads.</summary>
	private BlockingCollection<Task> _tasks;
	/// <summary>The STA threads used by the scheduler.</summary>
	private readonly List<Thread> _threads;
	
	/// <summary>Initializes a new instance of the <c>StaTaskScheduler</c> class with the specified concurrency level.</summary>
	/// <param name="numberOfThreads">The number of threads that should be created and used by this scheduler.</param>
	public StaTaskScheduler_(int numberOfThreads) {
		// Validate arguments
		if (numberOfThreads < 1) throw new ArgumentOutOfRangeException(nameof(numberOfThreads));
		
		// Initialize the tasks collection
		_tasks = new BlockingCollection<Task>();
		
		// Create the threads to be used by this scheduler
		var a = new List<Thread>(numberOfThreads);
		for (int i = 0; i < numberOfThreads; i++) {
			var thread = new Thread(() => {
				// Continually get the next task and try to execute it.
				// This will continue until the scheduler is disposed and no more tasks remain.
				foreach (var t in _tasks.GetConsumingEnumerable()) {
					TryExecuteTask(t);
				}
			}) { IsBackground = true };
			thread.SetApartmentState(ApartmentState.STA);
			a.Add(thread);
		}
		_threads = a;
		
		// Start all of the threads
		_threads.ForEach(t => t.Start());
	}
	
	/// <summary>Queues a Task to be executed by this scheduler.</summary>
	/// <param name="task">The task to be executed.</param>
	protected override void QueueTask(Task task) =>
		// Push it into the blocking collection of tasks
		_tasks.Add(task);
	
	/// <summary>Provides a list of the scheduled tasks for the debugger to consume.</summary>
	/// <returns>An enumerable of all tasks currently scheduled.</returns>
	protected override IEnumerable<Task> GetScheduledTasks() =>
		// Serialize the contents of the blocking collection of tasks for the debugger
		_tasks.ToArray();
	
	/// <summary>Determines whether a Task may be inlined.</summary>
	/// <param name="task">The task to be executed.</param>
	/// <param name="taskWasPreviouslyQueued">Whether the task was previously queued.</param>
	/// <returns><c>true</c> if the task was successfully inlined; otherwise, <c>false</c>.</returns>
	protected override bool TryExecuteTaskInline(Task task, bool taskWasPreviouslyQueued) =>
		// Try to inline if the current thread is STA
		//Thread.CurrentThread.GetApartmentState() == ApartmentState.STA &&
		//	TryExecuteTask(task);
		false; //important. Never run in thread that calls Task.Wait or Task.Result.
	
	/// <summary>Gets the maximum concurrency level supported by this scheduler.</summary>
	public override int MaximumConcurrencyLevel => _threads.Count;
	
	/// <summary>
	/// Cleans up the scheduler by indicating that no more tasks will be queued.
	/// This method blocks until all threads successfully shutdown.
	/// </summary>
	public void Dispose() {
		if (_tasks != null) {
			// Indicate that no new tasks will be coming in
			_tasks.CompleteAdding();
			
			// Wait for all threads to finish processing tasks
			foreach (var thread in _threads) thread.Join();
			
			// Cleanup
			_tasks.Dispose();
			_tasks = null;
		}
	}
}


================================================
FILE: Au/Internal/StringBuilder_.cs
================================================
namespace Au.More;

/// <summary>
/// Provides a cached reusable instance of <c>StringBuilder</c> per thread. It's an optimization that reduces the number of instances constructed and collected.
/// Used like <c>using(new StringBuilder_(out var b)) { b.Append("example"); var s = b.ToString(); }</c>.
/// </summary>
/// <remarks>
/// This is a modified copy of the .NET internal <c>StringBuilderCache</c> class.
/// </remarks>
internal struct StringBuilder_ : IDisposable {
	StringBuilder _sb;
	
	/// <summary>
	/// The cached <c>StringBuilder</c> has this <c>Capacity</c>. The cache is not used if <i>capacity</i> is bigger.
	/// </summary>
	public const int Capacity = 2000;
	
	[ThreadStatic] private static StringBuilder t_cached;
	
	/// <summary>
	/// Gets a new or cached/cleared <c>StringBuilder</c> of the specified or bigger capacity.
	/// </summary>
	/// <param name="capacity">
	/// Min needed <c>StringBuilder.Capacity</c>. If less than <c>Capacity</c> (2000), uses <c>Capacity</c>. If more than <c>Capacity</c>, does not use the cache.
	/// Use this parameter only when the needed capacity is variable; else either use default if need default or smaller, or don't use <c>StringBuilder_</c> if need bigger.
	/// </param>
	public StringBuilder_(out StringBuilder sb, int capacity = Capacity) {
		if (capacity <= Capacity) {
			capacity = Capacity;
			var b = t_cached;
			if (b != null) {
				t_cached = null;
				b.Clear();
				sb = _sb = b;
				return;
			}
		}
		sb = _sb = new StringBuilder(capacity);
	}
	
	/// <summary>
	/// Releases the <c>StringBuilder</c> to the cache.
	/// </summary>
	public void Dispose() {
		if (_sb.Capacity == Capacity) t_cached = _sb;
		_sb = null;
	}
}


================================================
FILE: Au/Internal/Util_.cs
================================================
using System.Windows;

namespace Au.More;

static unsafe class Not_ {
	//internal static void NullCheck<T>(this T t, string paramName = null) where T : class {
	//	if (t is null) throw new ArgumentNullException(paramName);
	//}
	
	/// <summary>
	/// Same as <c>ArgumentNullException.ThrowIfNull</c>.
	/// It's pity, they removed operator <c>!!</c> from C# 11.
	/// </summary>
	internal static void Null(object o,
		[CallerArgumentExpression("o")] string paramName = null) {
		if (o is null) throw new ArgumentNullException(paramName);
	}
	internal static void Null(object o1, object o2,
		[CallerArgumentExpression("o1")] string paramName1 = null,
		[CallerArgumentExpression("o2")] string paramName2 = null) {
		if (o1 is null) throw new ArgumentNullException(paramName1);
		if (o2 is null) throw new ArgumentNullException(paramName2);
	}
	internal static void Null(object o1, object o2, object o3,
		[CallerArgumentExpression("o1")] string paramName1 = null,
		[CallerArgumentExpression("o2")] string paramName2 = null,
		[CallerArgumentExpression("o3")] string paramName3 = null) {
		if (o1 is null) throw new ArgumentNullException(paramName1);
		if (o2 is null) throw new ArgumentNullException(paramName2);
		if (o3 is null) throw new ArgumentNullException(paramName3);
	}
	internal static void Null(object o1, object o2, object o3, object o4,
		[CallerArgumentExpression("o1")] string paramName1 = null,
		[CallerArgumentExpression("o2")] string paramName2 = null,
		[CallerArgumentExpression("o3")] string paramName3 = null,
		[CallerArgumentExpression("o4")] string paramName4 = null) {
		if (o1 is null) throw new ArgumentNullException(paramName1);
		if (o2 is null) throw new ArgumentNullException(paramName2);
		if (o3 is null) throw new ArgumentNullException(paramName3);
		if (o4 is null) throw new ArgumentNullException(paramName4);
	}
	internal static void Null(void* o,
		[CallerArgumentExpression("o")] string paramName = null) {
		if (o is null) throw new ArgumentNullException(paramName);
	}
	internal static T NullRet<T>(T o,
		[CallerArgumentExpression("o")] string paramName = null) where T : class {
		if (o is null) throw new ArgumentNullException(paramName);
		return o;
	}
}

static class WpfUtil_ {
	/// <summary>
	/// <c>true</c> if <c>SystemParameters.HighContrast</c> and <c>ColorInt.GetPerceivedBrightness(SystemColors.ControlColor)&lt;=0.5</c>.
	/// </summary>
	public static bool IsHighContrastDark {
		get {
			if (!SystemParameters.HighContrast) return false; //fast, cached
			var col = (ColorInt)SystemColors.ControlColor; //fast, cached
			var v = ColorInt.GetPerceivedBrightness(col.argb, false);
			return v <= .5;
		}
	}
}


================================================
FILE: Au/Internal/misc_.cs
================================================
namespace Au.More;

/// <summary>
/// Dictionary with case-insensitive string keys (uses <see cref="StringComparer.OrdinalIgnoreCase"/>).
/// </summary>
/// <remarks>
/// This class can be used instead of <see cref="Dictionary{TKey, TValue}"/>.
/// Unlike <c>Dictionary</c>, keys remain case-insensitive after deserialization (<see cref="System.Text.Json.JsonSerializer"/>, <see cref="JSettings"/> etc).
/// Another way to deserialize case-insensitive dictionaries - <c>JsonObjectCreationHandling.Populate</c> in serialization options or attribute.
/// </remarks>
class DictionaryI_<TValue> : Dictionary<string, TValue> {
	/// <summary>
	/// Calls base constructor with <see cref="StringComparer.OrdinalIgnoreCase"/>.
	/// </summary>
	public DictionaryI_() : base(StringComparer.OrdinalIgnoreCase) { }
	
	/// <summary>
	/// Calls base constructor with <see cref="StringComparer.OrdinalIgnoreCase"/>.
	/// </summary>
	public DictionaryI_(int capacity) : base(capacity, StringComparer.OrdinalIgnoreCase) { }
}


================================================
FILE: Au/Internal/tables.cs
================================================
namespace Au.More
{
	/// <summary>
	/// Lookup tables for various functions of this library.
	/// </summary>
	unsafe static class Tables_
	{
		static Tables_() {
			var t = new byte[55];
			for (int u = 0; u < t.Length; u++) {
				char c = (char)(u + '0');
				if (c >= '0' && c <= '9') t[u] = (byte)u;
				else if (c >= 'A' && c <= 'F') t[u] = (byte)(c - ('A' - 10));
				else if (c >= 'a' && c <= 'f') t[u] = (byte)(c - ('a' - 10));
				else t[u] = 0xFF;
			}
			Hex = t;
		}

		/// <summary>
		/// Table for <see cref="Convert2.HexDecode"/> and co.
		/// </summary>
		public static readonly byte[] Hex;

		/// <summary>
		/// Native-memory <c>char[0x10000]</c> containing lower-case versions of the first 0x10000 characters.
		/// </summary>
		public static char* LowerCase {
			get { var v = _lcTable; if (v == null) _lcTable = v = Cpp.Cpp_LowercaseTable(); return v; } //why operator ??= cannot be used with pointers?
		}
		static char* _lcTable;
		//never mind: this library does not support ucase/lcase chars 0x10000-0x100000 (surrogate pairs).
		//	Tested with IsUpper/IsLower: about 600 such chars exist. ToUpper/ToLower can convert 40 of them. Equals/StartsWith/IndexOf/etc fail.
	}
}


================================================
FILE: Au/Other/PrintServer.cs
================================================
//#define NEED_CALLER //rejected. Too slow and generates much garbage.

/*
Single global server is supported in this user session.
Single local server is supported in this process.

Server does not implement an output window etc. It just collects messages and notifies an output window. Asynchronously.

How global output server/client is implemented:
	Single server and multiple clients.
	Server receives messages sent by clients.
	Clients - processes that send text messages to the server. The server's process also can be client.
	For IPC is used mailslot, waitable timer and shared memory (SM).
	Server:
		Creates mailslot and timer. Sets a bool about it in SM.
		Waits for timer and reads messages from mailslot.
			For better reliability, also checks mailslot periodically.
			If messages available, notifies an output window.
		On exit clears the bool in SM.
	Client, when sending a text message:
		If the SM bool is not set - discards the message, and closes mailslot if was open. Else:
		If not still done, opens mailslot.
		Writes message to mailslot.
		Sets timer if not set. Uses another bool in SM to indicate that the timer is set; server clears it.

How local output server/client is implemented:
	Similar to global. Differences:
	Single server and single client (the same process).
	Uses waitable timer, but not mailslot/SM. Instead of mailslot, adds messages directly to _messages. Instead of SM, uses static variables.

*/

namespace Au.More {
	/// <summary>
	/// Receives messages sent by <see cref="print.it"/>.
	/// </summary>
	/// <remarks>
	/// If server is global, clients can be multiple processes, including this. Else only this process.
	/// Works asynchronously, to make writing messages faster.
	/// When a client writes a message, the message arrives to the server with some delay and is placed in a queue.
	/// You then can get/remove messages from the queue (call <see cref="GetMessage"/>) and display them in a window (for example).
	/// You can be notified about new messages.
	/// 
	/// Recommended setup (see example):
	/// 1. When your application starts, create a <c>PrintServer</c> instance and assign to a static variable. Call <see cref="Start"/>.
	/// 2. When your application creates its output window, call <see cref="SetNotifications"/> to set window/message for notifications.
	/// 3. In window procedure, when received the notification message, get/remove/display all new output messages.
	/// 4. Call <see cref="Stop"/> when closing the window.
	/// </remarks>
	/// <example>
	/// Simple program with output window.
	/// <code><![CDATA[
	/// using System.Windows.Forms;
	/// 
	/// class OutputFormExample : Form {
	/// 	TextBox _tb;
	/// 
	/// 	public OutputFormExample()
	/// 	{
	/// 		_tb = new TextBox();
	/// 		_tb.ReadOnly = true;
	/// 		_tb.Multiline = true;
	/// 		_tb.ScrollBars = ScrollBars.Both;
	/// 		_tb.WordWrap = false;
	/// 		_tb.Dock = DockStyle.Fill;
	/// 		_tb.TabStop = false;
	/// 		this.Controls.Add(_tb);
	/// 	}
	/// 
	/// 	protected override void OnHandleCreated(EventArgs e) {
	/// 		_os.SetNotifications(this.Hwnd(), WM_APP);
	/// 		base.OnHandleCreated(e);
	/// 	}
	/// 
	/// 	protected override void WndProc(ref Message m) {
	/// 		if(m.Msg == WM_APP) _ProcessMessages();
	/// 		base.WndProc(ref m);
	/// 	}
	/// 	
	/// 	internal const int WM_APP = 0x8000;
	/// 
	/// 	void _ProcessMessages()
	/// 	{
	/// 		while(_os.GetMessage(out var m)) {
	/// 			switch(m.Type) {
	/// 			case PrintServerMessageType.Clear:
	/// 				_tb.Clear();
	/// 				break;
	/// 			case PrintServerMessageType.Write:
	/// 				//_tb.AppendText(m.Text);
	/// 				_tb.AppendText($"{DateTime.FromFileTimeUtc(m.TimeUtc).ToLocalTime()}  {m.Caller}  {m.Text}");
	/// 				break;
	/// 			}
	/// 		}
	/// 	}
	/// 
	/// 	static PrintServer _os = new(isGlobal: false);
	/// 
	/// 	[STAThread]
	/// 	static void Main()
	/// 	{
	/// 		_os.Start();
	/// 
	/// 		//test Write and Clear, before and after creating window
	/// 		print.ignoreConsole = true;
	/// 		print.it("test before setting notifications");
	/// 		Task.Run(() => { 1.s(); print.it("test after"); 1.s(); print.clear(); 1.s(); print.it("test after Clear"); });
	/// 
	/// 		Application.Run(new OutputFormExample());
	/// 		_os.Stop();
	/// 	}
	/// }
	/// ]]></code>
	/// </example>
	public unsafe class PrintServer {
		//info:
		//Although global and local servers are implemented quite differently, the interface is almost the same. For this and other reasons I decided to use single class.
		//For local server, the thread and kernel timer would be not necessary. Instead could use just a user timer. But it has some limitations etc.
		
		readonly ConcurrentQueue<PrintServerMessage> _messages = new(); //all received and still not removed messages that were sent by clients when they call print.it etc
		Handle_ _mailslot; //used if global
		WaitableTimer _timer; //used always
		wnd _notifWnd;
		int _notifMsg;
		bool _isStarted;
		readonly bool _isGlobal;
		bool _isLocalTimer;
		
		/// <param name="isGlobal">
		/// If <c>true</c>, will receive output from all processes that don't have local server.
		/// </param>
		public PrintServer(bool isGlobal) => _isGlobal = isGlobal;
		
		/// <summary>
		/// Starts server.
		/// </summary>
		/// <returns><c>false</c> if server already exists (if global - in any process).</returns>
		/// <exception cref="AuException">Failed.</exception>
		public bool Start() {
			lock (this) {
				if (print.s_localServer != null) return false;
				if (_isGlobal) {
					var m = Api.CreateMailslot(MailslotName_, 0, 0, Api.SECURITY_ATTRIBUTES.ForLowIL);
					if (m.Is0) {
						var e = lastError.code;
						if (e == Api.ERROR_ALREADY_EXISTS) return false; //called not first time, or exists in another process
						throw new AuException(e, "*create mailslot");
					}
					
					_mailslot = m;
					_CreateTimerAndThread();
					SM_->isServer = 1;
				} else {
					_CreateTimerAndThread();
				}
				
				print.s_localServer = this; //if global server, will work as local when writes same process
				_isStarted = true;
			}
			return true;
		}
		
		void _CreateTimerAndThread() {
			try {
				if (_isGlobal) _timer = WaitableTimer.Create(false, TimerName_);
				else _timer = WaitableTimer.Create();
				
				run.thread(_Thread, sta: false).Name = "Au.PrintServer";
			}
			catch {
				if (_isGlobal) _mailslot.Dispose();
				_timer?.Close(); _timer = null;
				throw;
			}
		}
		
		/// <summary>
		/// Stops server.
		/// </summary>
		public void Stop() {
			lock (this) {
				if (!_isStarted) return;
				_isStarted = false;
				if (_isGlobal) {
					_mailslot.Dispose();
					SM_->isServer = 0;
				}
				print.s_localServer = null;
				_timer?.Set(0); //break thread loop; use minimal time. //info: the thread will dispose _timer and set=null
			}
		}
		
		/// <summary>
		/// Calls <see cref="Stop"/>.
		/// </summary>
		~PrintServer() => Stop();
		
		/// <summary>
		/// Sets window/message to be notified about server events.
		/// </summary>
		/// <param name="w">Your window that displays output, or any other window. Its window procedure on <i>message</i> should call <see cref="GetMessage"/> until it returns <c>false</c>. See example in class help.</param>
		/// <param name="message">Windows message to send to <i>w</i> when one or more output events are available. For example <ms>WM_USER</ms> or <ms>WM_APP</ms>.</param>
		public void SetNotifications(wnd w, int message) {
			_notifMsg = message;
			_notifWnd = w;
			if (!w.Is0) _timer?.Set(30);
		}
		
		void _Thread() {
			try {
				for (int period = 1000; ;) {
					bool isTimerEvent = _timer.WaitOne(period); //true if timer event, false if timeout
					if (isTimerEvent) {
						if (_isGlobal) SM_->isTimer = 0;
						_isLocalTimer = false;
					}
					
					lock (this) {
						if (!_isStarted) {
							_timer.Dispose(); _timer = null;
							break;
						}
						
						if (_isGlobal) { //read messages from mailslot and add to _messages. Else messages are added directly to _messages.
							while (Api.GetMailslotInfo(_mailslot, null, out int nextSize, out var msgCount) && msgCount > 0) {
								//note: GetMailslotInfo makes Systeminformer show constant 24 B/s I/O total rate. Does not depend on period.
								_ReadMailslotMessage(nextSize);
								if (msgCount == 1) break;
							}
						}
					}
					
					if (!_notifWnd.Is0 && !_messages.IsEmpty) {
						
						//print.qm2.write($"{_messages.Count}, {_ToMB(_memSize)}, {_ToMB(GC.GetTotalMemory(false))}");
						
						if (!_notifWnd.IsAlive) break;
						_notifWnd.Send(_notifMsg);
					}
					
					if (isTimerEvent) period = 50; //check after 50 ms, to avoid 1000 ms delay in case a client did not set timer because SM_->isTimer was still 1 although the timer was already signaled
					else period = 1000; //check every 1000 ms, for full reliability
					
					//Console.WriteLine($"{period}");
				}
			}
			catch (Exception ex) {
				Debug_.Dialog(ex);
			}
		}
		
		[SkipLocalsInit]
		void _ReadMailslotMessage(int size) {
			using FastBuffer<byte> b = new(size + 4); //+4 for "\r\n"
			var p = b.p;
			bool ok = Api.ReadFile(_mailslot, p, size, out var readSize) && readSize == size;
			if (ok) {
				long time = 0; string s = null, caller = null;
				var mtype = (PrintServerMessageType)(*p++);
				switch (mtype) {
				case PrintServerMessageType.Write or PrintServerMessageType.TaskEvent:
					if (size < 10) { ok = false; break; } //type, time(8), lenCaller
					time = *(long*)p; p += 8;
					int lenCaller = *p++;
					if (lenCaller > 0) {
						if (10 + lenCaller * 2 > size) { ok = false; break; }
						caller = new string((char*)p, 0, lenCaller);
						p += lenCaller * 2;
					}
					int len = (size - (int)(p - b.p)) / 2;
					if (!NoNewline && mtype == PrintServerMessageType.Write) {
						char* r = (char*)(b.p + size);
						r[0] = '\r'; r[1] = '\n';
						len += 2;
					}
					s = new string((char*)p, 0, len);
					break;
				case PrintServerMessageType.Clear or PrintServerMessageType.ScrollToTop when size == 1:
					break;
				default:
					ok = false;
					break;
				}
				Debug.Assert(ok);
				if (ok) _AddMessage(new PrintServerMessage(mtype, s, time, caller));
			}
		}
		
		//static string _ToMB(long n) => Math.Round(n / 1048576d, 3).ToS();
		
		/// <summary>
		/// Adds <i>s</i> directly to <c>_messages</c> and sets timer.
		/// If <i>s</i> is <c>null</c>, it is "Clear" command.
		/// Else if <c>!NoNewline</c>, appends <c>"\r\n"</c>.
		/// Used with local server; also with global server when writes the server's process.
		/// </summary>
		internal void LocalWrite_(string s, long time = 0, string caller = null) {
			//Debug.Assert(!_isGlobal);
			if (!NoNewline && s != null) s += "\r\n";
			var m = new PrintServerMessage(s == null ? PrintServerMessageType.Clear : PrintServerMessageType.Write, s, time, caller);
			_AddMessage(m, true);
		}
		
		/// <summary>
		/// Adds action directly to <c>_messages</c> and sets timer.
		/// Used with local server; also with global server when writes the server's process.
		/// </summary>
		internal void LocalAction_(PrintServerMessageType action) {
			//Debug.Assert(!_isGlobal);
			_AddMessage(new(action), true);
		}
		
		void _AddMessage(PrintServerMessage m, bool setTimer = false) {
			//_memSize += _GetMessageMemorySize(m);
			_messages.Enqueue(m);
			if (setTimer && !_isLocalTimer) { _timer?.Set(10); _isLocalTimer = true; }
		}
		
		//static int _GetMessageMemorySize(PrintServerMessage m) => 50 + m.Text.Lenn() * 2;
		//int _memSize;
		
		/// <summary>
		/// Gets next message and removes from the queue.
		/// </summary>
		/// <returns><c>false</c> if there are no messages.</returns>
		/// <remarks>
		/// Messages are added to an internal queue when clients call <see cref="print.it"/> etc. They contain the text, time, etc. This function gets the oldest message and removes it from the queue.
		/// </remarks>
		public bool GetMessage(out PrintServerMessage m) {
			if (!_messages.TryDequeue(out m)) return false;
			//_memSize -= _GetMessageMemorySize(m);
			return true;
		}
		
		/// <summary>
		/// Gets the count of messages in the queue.
		/// </summary>
		public int MessageCount => _messages.Count;
		
		/// <summary>
		/// Let messages don't end with <c>"\r\n"</c>.
		/// </summary>
		/// <remarks>
		/// This can be used for performance, to avoid string copying when using local server. Does not affect performance of global server.
		/// </remarks>
		public bool NoNewline { get; set; }
		
#if NEED_CALLER
		/// <summary>
		/// Let clients provide the caller method of "print" functions.
		/// Note: It makes these methods much slower, especially when thread stack is big. Also generates much garbage. To find caller method is used <see cref="StackTrace"/> class.
		/// See also: <see cref="IntroduceWriterClass"/>.
		/// </summary>
		public bool NeedCallerMethod
		{
			get => _isGlobal ? (SM_->needCaller != 0) : _localNeedCaller;
			set { if(_isGlobal) SM_->needCaller = (byte)(value ? 1 : 0); else _localNeedCaller = value; }
		}
		bool _localNeedCaller;

		internal static bool NeedCallerMethod_
		{
			get { var t = s_localServer; return (t != null) ? t.NeedCallerMethod : SM_->needCaller != 0; }
		}
#endif
		
		/// <summary>
		/// Gets mailslot name like <c>@"\\.\mailslot\Au.print\" + sessionId</c>.
		/// </summary>
		internal static string MailslotName_ {
			get {
				if (_mailslotName == null) {
					_mailslotName = @"\\.\mailslot\Au.print\" + process.thisProcessSessionId.ToString();
				}
				return _mailslotName;
			}
		}
		static string _mailslotName;
		
		/// <summary>
		/// Gets waitable timer name like <c>"timer.Au.print"</c>.
		/// </summary>
		internal static string TimerName_ => "timer.Au.print";
		
		/// <summary>
		/// Shared memory variables. Used with global server only.
		/// </summary>
		[StructLayout(LayoutKind.Sequential, Size = 16)] //note: this struct is in shared memory. Size must be same in all library versions.
		internal struct SharedMemoryData_ {
			public byte isServer, isTimer;
#if NEED_CALLER
				public byte needCaller;
#endif
		}
		internal static SharedMemoryData_* SM_ => &SharedMemory_.Ptr->outp;
	}
}

namespace Au {
	public static partial class print {
		
		[MethodImpl(MethodImplOptions.NoInlining)] //for stack trace
		static void _ServerWrite(string s) {
			Debug.Assert(s != null);
			
			Api.GetSystemTimeAsFileTime(out var time);
			
			string caller = script.name;
#if NEED_CALLER
			if(PrintServer.NeedCallerMethod_) {
				//info: this func always called from directly, which is usually called through Writer, Write. But it is public and can be called directly.
				var k = new StackTrace(2); //skip this func and directly()
				lock(_writerTypes) {
					for(int i = 0, n = k.FrameCount; i < n; i++) {
						var m = k.GetFrame(i).GetMethod();
						var t = m.DeclaringType;
						if(_writerTypes.Contains(t)) continue;
						caller = caller + ":" + t.Name + "." + m.Name;
						break;
					}
				}
				//speed: with 'new StackFrame(i)' usually slower, regardless of stack size. Faster only when 1 loop, maybe 2.
				//info: here we don't optimize caller strings like PrintServer does, because StackTrace creates much more garbage.
			}
#endif
			
			var loc = s_localServer;
			if (loc != null) loc.LocalWrite_(s, time, caller);
			else s_client.WriteLine(s, PrintServerMessageType.Write, caller, time);
		}
		
		static void _ServerAction(PrintServerMessageType action) {
			var loc = s_localServer;
			if (loc == null) s_client.AddAction(action);
			else if (action == PrintServerMessageType.Clear) loc.LocalWrite_(null);
			else loc.LocalAction_(action);
		}
		
		static readonly _ClientOfGlobalServer s_client = new();
		internal static PrintServer s_localServer; //null if we don't have a local server
		
		/// <summary>
		/// Logs start/end/fail events of <c>miniProgram</c> trigger actions.
		/// Editor displays it in the <b>Recent tasks</b> window, not in the output panel.
		/// Could also log other events. For example at first used for task start/end/fail events, but now it is implemented in editor.
		/// </summary>
		internal static void TaskEvent_(string s, long id, string sourceFile = null, int sourceLine = 0) {
			Debug.Assert(script.role == SRole.MiniProgram);
			//if (s == null) s = "\0DNl08ISh30Kbt6ekJV3VvA"; //JIT //now not used
			//else {
			if (sourceFile == null) sourceFile = script.s_idMainFile.ToString(); //task started/ended/failed
			else sourceFile = sourceFile + "\0" + sourceLine.ToS(); //trigger action started/ended/failed
			sourceFile = id.ToS() + "\0" + sourceFile;
			//}
			s_client.WriteLine(s, PrintServerMessageType.TaskEvent, sourceFile);
		}
		
		unsafe class _ClientOfGlobalServer {
			//info: the mailslot/timer are implicitly disposed when process ends.
			
			Handle_ _mailslot;
			WaitableTimer _timer;
			long _sizeWritten;
			
			[SkipLocalsInit]
			public void WriteLine(string s, PrintServerMessageType mtype, string caller = null, long time = 0) {
				if (time == 0) Api.GetSystemTimeAsFileTime(out time);
				
				lock (_lockObj1) {
					if (!_Connect()) return;
					
					int lenS = s.Length, lenCaller = (caller != null) ? Math.Min(caller.Length, 255) : 0;
					int lenAll = 1 + 8 + 1 + lenCaller * 2 + lenS * 2; //type, time, lenCaller, caller, s
					using FastBuffer<byte> b = new(lenAll);
					byte* p = b.p;
					//type
					*p++ = (byte)mtype;
					//time
					*(long*)p = time; p += 8;
					//caller
					*p++ = (byte)lenCaller;
					if (lenCaller != 0) {
						fixed (char* k = caller) MemoryUtil.Copy(k, p, lenCaller * 2);
						p += lenCaller * 2;
					}
					//s
					if (lenS != 0) fixed (char* k = s) MemoryUtil.Copy(k, p, lenS * 2); //s
					
					//if (s == "\0DNl08ISh30Kbt6ekJV3VvA") { //JIT //now not used
					//									   //_SetTimer();
					//	Jit_.Compile(typeof(WaitableTimer), nameof(WaitableTimer.Set));
					//	Jit_.Compile(typeof(Api), nameof(Api.WriteFile), nameof(Api.SetWaitableTimer)); //slow JIT SetWaitableTimer
					//	return;
					//}
					
					g1:
					bool ok = Api.WriteFile(_mailslot, b.p, lenAll, out _);
					if (!ok && _ReopenMailslot()) goto g1;
					
					if (ok) {
						_SetTimer();
						
						//prevent overflow of mailslot and _messages
						_sizeWritten += lenAll;
						if (_sizeWritten > 1_000_000) {
							while (Api.GetFileSizeEx(_mailslot, out _sizeWritten) && _sizeWritten > 300_000) Thread.Sleep(15);
							//note: these numbers are carefully adjusted for best performance etc
						}
					}
				}
			}
			
			public void AddAction(PrintServerMessageType action) {
				lock (_lockObj1) {
					if (!_Connect()) return;
					
					g1:
					byte b = (byte)action;
					bool ok = Api.WriteFile(_mailslot, &b, 1, out _);
					if (!ok && _ReopenMailslot()) goto g1;
					Debug.Assert(ok);
					
					if (ok) _SetTimer();
				}
			}
			
			//If last error says that server's mailslot closed, closes client's mailsot/timer and tries to reopen. If reopened, returns true.
			bool _ReopenMailslot() {
				if (lastError.code == Api.ERROR_HANDLE_EOF) { //server's mailslot closed
					_Close();
					if (_Connect()) return true;
				} else {
					Debug.Assert(false);
				}
				return false;
			}
			
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			void _SetTimer() {
				if (PrintServer.SM_->isTimer == 0) {
					if (_timer.Set(10)) PrintServer.SM_->isTimer = 1;
				}
			}
			
			void _Close() {
				if (!_mailslot.Is0) {
					_mailslot.Dispose();
					_timer.Close(); _timer = null;
				}
			}
			
			bool _Connect() {
				if (PrintServer.SM_->isServer == 0) {
					_Close();
					return false;
				}
				
				if (_mailslot.Is0) {
					_mailslot = CreateFile_(PrintServer.MailslotName_, true);
					if (_mailslot.Is0) return false;
					
					_timer = WaitableTimer.Open(PrintServer.TimerName_, noException: true);
					if (_timer == null) {
						_mailslot.Dispose();
						return false;
					}
				}
				
				return true;
			}
		}
		
#if NEED_CALLER
		static readonly List<Type> _writerTypes = new List<Type>() { typeof(print), typeof(_OutputWriter) };

		/// <summary>
		/// Introduces a class that contain methods designed to write to the output.
		/// Purpose - when server's <see cref="PrintServer.NeedCallerMethod"/> is <c>true</c>, skip methods of this class when searching for the caller method in the call stack.
		/// For example, if you created class <c>PrintColored</c> that contains methods <c>PrintRed</c>, <c>PrintGreen</c> and <c>PrintBlue</c>, you should execute this code in its static constructor: <c>print.introduceWriterClass(typeof(PrintColored));</c>.
		/// Also use this if you redirect output using a writer class that calls directly().
		/// Not used when writing to console or log file.
		/// </summary>
		public static void introduceWriterClass(Type t)
		{
			lock(_writerTypes) {
				if(!_writerTypes.Contains(t)) _writerTypes.Add(t);
			}
		}
#endif
	}
}

namespace Au.Types {
	/// <summary>
	/// See <see cref="PrintServerMessage.Type"/>.
	/// </summary>
	public enum PrintServerMessageType {
		/// <summary>
		/// Add line to the output window.
		/// All <see cref="PrintServerMessage"/> members can be used.
		/// </summary>
		Write,
		
		/// <summary>
		/// Clear the output window.
		/// Only <see cref="PrintServerMessage.Type"/> is used.
		/// </summary>
		Clear,
		
		/// <summary>
		/// Used internally to log events such as start/end of trigger actions.
		/// </summary>
		TaskEvent,
		
		/// <summary>
		/// Scroll the output window to the top.
		/// Only <see cref="PrintServerMessage.Type"/> is used.
		/// </summary>
		ScrollToTop,
	}
	
	/// <summary>
	/// Contains message text and/or related info.
	/// More info: <see cref="PrintServer"/>, <see cref="PrintServer.GetMessage"/>.
	/// </summary>
	public class PrintServerMessage {
		/// <summary>
		/// Message type (write, clear, etc).
		/// </summary>
		public PrintServerMessageType Type { get; }
		
		/// <summary>
		/// Message text.
		/// Used with <see cref="PrintServerMessageType.Write"/>.
		/// </summary>
		public string Text { get; set; }
		
		/// <summary>
		/// Message time in <ms>FILETIME</ms> format, UTC.
		/// Used with <see cref="PrintServerMessageType.Write"/>.
		/// To convert to string: <c>DateTime.FromFileTimeUtc(m.TimeUtc).ToLocalTime().ToString()</c>.
		/// </summary>
		public long TimeUtc { get; }
		
#if NEED_CALLER
		/// <summary>
		/// The <see cref="script.name"/> property value of the process that called <see cref="print.it"/>.
		/// Used with <see cref="PrintServerMessageType.Write"/>.
		/// If <see cref="NeedCallerMethod"/> is <c>true</c>, also includes the caller method. Format: <c>"scriptname:type.method"</c>.
		/// </summary>
		public string Caller { get; }

		internal PrintServerMessage(PrintServerMessageType type, string text, long time, string caller)
		{
			Type = type;
			Text = text;
			TimeUtc = time;
			Caller = caller;
		}
#else
		/// <summary>
		/// The <see cref="script.name"/> property value of the process that called <see cref="print.it"/>.
		/// Used with <see cref="PrintServerMessageType.Write"/>.
		/// </summary>
		public string Caller { get; }
		
		internal PrintServerMessage(PrintServerMessageType type, string text = null, long time = 0, string caller = null) {
			Type = type;
			Text = text;
			TimeUtc = time;
			Caller = caller;
		}
#endif
		
		///
		public override string ToString() {
			//in editor used for output history
			
			if (Type != PrintServerMessageType.Write) return "";
			var k = DateTime.FromFileTimeUtc(TimeUtc).ToLocalTime();
			return $"{k.ToString()}  |  {Caller}\r\n{Text}";
		}
	}
}


================================================
FILE: Au/Other/ScriptEditor.cs
================================================
namespace Au.More;

/// <summary>
/// Contains functions to interact with the script editor, if available.
/// </summary>
/// <remarks>
/// Functions of this class work when editor process is running, even if current process wasn't started from it. To detect whether current process was started from editor, use <see cref="folders.Editor"/> (it is <c>null</c> if not).
/// </remarks>
public static class ScriptEditor {
	/// <summary>
	/// Finds editor's message-only window used with <c>WM_COPYDATA</c> etc.
	/// Uses <see cref="script.s_wndEditorMsg"/> or <see cref="wnd.Cached_"/>.
	/// </summary>
	internal static wnd WndMsg_ {
		get {
			var w = script.s_wndEditorMsg; if (!w.Is0) return w;
			return s_wndMsg.FindFast(null, c_msgWndClassName, true);
		}
	}
	static wnd.Cached_ s_wndMsg, s_wndMain;
	
	/// <summary>
	/// Class name of <see cref="WndMsg_"/> window.
	/// </summary>
	internal const string c_msgWndClassName = "Au.Editor.m3gVxcTJN02pDrHiQ00aSQ";
	
	internal static wnd WndMain_(bool show = false) {
		var w = WndMsg_;
		return w.Is0 ? default : s_wndMain.Get(() => (wnd)w.Send(Api.WM_USER, 0, show ? 1 : 0));
	}
	
	/// <summary>
	/// Returns <c>true</c> if editor is running.
	/// </summary>
	public static bool Available => !WndMsg_.Is0;
	
	/// <summary>
	/// The main editor window.
	/// </summary>
	/// <param name="show">Show the window (if the editor program is running).</param>
	/// <returns><c>default(wnd)</c> if the editor program isn't running or its main window still wasn't visible.</returns>
	public static wnd MainWindow(bool show = false) => WndMain_(show);
	
	/// <summary>
	/// Shows or hides the main editor window.
	/// </summary>
	/// <param name="show">
	/// <br/>• <c>true</c> - show, activate, restore if minimized.
	/// <br/>• <c>false</c> - hide. It does not hide the tray icon.
	/// <br/>• <c>null</c> - toggle.
	/// </param>
	public static void ShowMainWindow(bool? show) {
		var w = WndMsg_;
		if (!w.Is0) w.Send(Api.WM_USER, 1, show switch { true => 1, false => 2, _ => 0 });
	}
	
	/// <summary>
	/// Invokes an editor's menu command.
	/// </summary>
	/// <param name="command">Command name. If <c>""</c> or invalid, prints all names.</param>
	/// <param name="check">If it's a checkbox-item, <c>true</c> checks it, <c>false</c> unchecks, <c>null</c> toggles. Else must be <c>null</c> (default).</param>
	/// <param name="dontWait">Don't wait until the command finishes executing. For example, if it shows a modal dialog, don't wait until it is closed.</param>
	/// <param name="activateWindow">Activate the main window. Default <c>true</c>. Some commands may not work correctly if the window isn't active.</param>
	/// <remarks>
	/// Shows the main window, regardless of <i>activateWindow</i>. Waits while it is disabled or not finished loading, unless script role is <c>editorExtension</c> and it runs in the editor's main thread (then not invoke the command).
	/// Does not invoke the command if the menu item is disabled or if it's a submenu-item.
	/// </remarks>
	public static void InvokeCommand(string command, bool? check = null, bool dontWait = false, bool activateWindow = true) {
		var w = WndMsg_; if (w.Is0) return;
		int flags = check switch { true => 1, false => 2, _ => 0 } | _EditorExtensionFlag;
		if (activateWindow) flags |= 4;
		if (dontWait) flags |= 8;
		g1:
		nint r = WndCopyData.Send<char>(w, 11, command, flags);
		if (r == -1) { _WaitWhileEditorDisabled(); goto g1; }
	}
	
	static int _EditorExtensionFlag => process.IsLaMainThread_ ? 16 : 0;
	
	static void _WaitWhileEditorDisabled() { MainWindow().WaitFor(0, o => o.IsEnabled()); }
	
	/// <summary>
	/// Gets the state of an editor's menu command (checked, disabled).
	/// </summary>
	/// <param name="command">Command name. If <c>""</c> or invalid, prints all names.</param>
	/// <remarks>
	/// Shows the main window. Waits while it is disabled or not finished loading, unless script role is <c>editorExtension</c> and it runs in the editor's main thread (then returns <c>Disabled</c>).
	/// </remarks>
	public static ECommandState GetCommandState(string command) {
		var w = WndMsg_; if (w.Is0) return 0;
		g1:
		nint r = WndCopyData.Send<char>(w, 12, command, _EditorExtensionFlag);
		if (r == -1) { _WaitWhileEditorDisabled(); goto g1; }
		return (ECommandState)r;
	}
	
	/// <summary>
	/// Opens a script or other file. Also can move the text cursor.
	/// Does nothing if editor isn't running.
	/// </summary>
	/// <param name="file">A file in current workspace. Can be full path, or relative path in workspace, or file name with extension (<c>".cs"</c> etc). If folder, selects it.</param>
	/// <param name="line">If not <c>null</c>, goes to this 1-based line index.</param>
	/// <param name="offset">If not <c>null</c>, goes to this 0-based column index in line (if <i>line</i> not <c>null</c>) or to this 0-based position in text (if <i>line</i> <c>null</c>).</param>
	public static void Open([ParamString(PSFormat.FileInWorkspace)] string file, int? line = null, int? offset = null) {
		var w = WndMsg_; if (w.Is0) return;
		Api.AllowSetForegroundWindow(w.ProcessId);
		WndCopyData.Send<char>(w, 4, $"{file}|{line}|{offset}");
	}
	
	///
	[Obsolete("use Open"), EditorBrowsable(EditorBrowsableState.Never)]
	public static void OpenAndGoToLine([ParamString(PSFormat.FileInWorkspace)] string file, int line) => Open(file, line);
	
	/// <summary>
	/// Gets icon string in specified format.
	/// </summary>
	/// <returns>Returns <c>null</c> if editor isn't running or if the file does not exist. Read more in Remarks.</returns>
	/// <param name="file">Script file/folder path etc, or icon name. See <see cref="EGetIcon"/>, <see cref="ImageUtil.LoadWpfImageElement"/>.</param>
	/// <param name="what">The format of input and output strings.</param>
	/// <remarks>
	/// If <i>what</i> is <see cref="EGetIcon.IconNameToXaml"/>, this function tries to get icon XAML from assembly resources (passes <i>file</i> to <see cref="ResourceUtil.GetString"/>, with color removed); if not found - from editor. By default the LibreAutomate compiler finds literal icon-like strings in code and adds icon XAML to assembly resources; see <b>Properties > Resource > Options</b>.
	/// </remarks>
	public static string GetIcon(string file, EGetIcon what) => GetIcon_(file, what, false);
	
	internal static string GetIcon_(string file, EGetIcon what, bool skipResources) {
		if (IconNameToXaml_ is { } intx) return intx(file, what);
		
		if (what == EGetIcon.IconNameToXaml && script.role != SRole.EditorExtension && !skipResources) {
			if (IconString_.GetXamlFromResources(file) is string xaml) return xaml;
		}
		
		var w = WndMsg_; if (w.Is0) return null;
		WndCopyData.SendReceive<char>(w, (int)Math2.MakeLparam(10, (int)what), file, out string r);
		return r;
		//rejected: add option to get serialized Bitmap instead. Now loads XAML in this process. It is 230 ms and +27 MB.
		//	Nothing good if the toolbar etc also uses XAML icons directly, eg for non-script items. And serializing is slow.
		//	Now not actual because of cache.
	}
	
	/// <summary>
	/// Editor sets this. Library uses it to avoid sendmessage when role <c>editorExtension</c>.
	/// </summary>
	internal static Func<string, EGetIcon, string> IconNameToXaml_;
	
	/// <summary>
	/// Returns <c>true</c> if the editor program is installed as [portable](xref:portable).
	/// </summary>
	/// <remarks>
	/// Available in the script editor process and in scripts launched from it. Elsewhere <c>false</c>.
	/// 
	/// If portable, these paths are different:
	/// - <see cref="folders.ThisAppDocuments"/>
	/// - <see cref="folders.ThisAppDataLocal"/>
	/// - <see cref="folders.ThisAppTemp"/>
	/// - <see cref="folders.Editor"/>
	/// - <see cref="folders.Workspace"/>
	/// </remarks>
	public static bool IsPortable { get; internal set; }
	
	/// <summary>
	/// Gets name, text and some info of the currently active file in editor.
	/// </summary>
	/// <param name="needText">Need text too.</param>
	/// <returns><c>null</c> if there are no open files or if failed.</returns>
	public static EFileInfo GetFileInfo(bool needText) => GetFileInfo(null, needText);
	
	/// <summary>
	/// Gets name, text and some info of a file in the current workspace in editor.
	/// </summary>
	/// <param name="file">A file in current workspace. Can be full path, or relative path in workspace, or file name with extension (<c>".cs"</c> etc), or <c>":id"</c>.</param>
	/// <param name="needText">Need text too.</param>
	/// <returns><c>null</c> if the specified file not found or if failed.</returns>
	public static EFileInfo GetFileInfo(string file, bool needText) {
		var w = WndMsg_;
		var flags = needText ? "1" : "0";
		if (!w.Is0 && WndCopyData.SendReceive<char>(w, 14, file != null ? flags + " " + file : flags, out byte[] r)) {
			var x = Serializer_.Deserialize(r);
			string path = x[0];
			return new EFileInfo(pathname.getName(path), path, x[1], (EFileKind)(int)x[2], (uint)(int)x[3], x[4], x[5]);
		}
		return null;
	}
	
	/// <summary>
	/// If a specified class file is currently active in editor, calls a callback function (which can be or call a function in that file) and returns true.
	/// </summary>
	/// <param name="files">
	/// List of tuples <c>(string file, Action action)</c>:
	/// <br/>• <c>file</c> - a class file from current project; must be filename without ".cs" and path.
	/// <br/>• <c>action</c> - a callback function to call if that file is the active file in editor.
	/// </param>
	/// <remarks>
	/// A script project folder can contain one script file at the top, and any number of class files. When you click <b>Run</b>, the code execution starts from the script, even if a class file is currently active in editor. But sometimes you may want to execute just a function in the current class file, and skip script code. The example shows how to do it easily.
	/// </remarks>
	/// <example>
	/// Code at/near the start of the script file of a script project.
	/// <code><![CDATA[
	/// if (script.testing && ScriptEditor.TestCurrentFileInProject(("TaskA", TaskA.Func1), ("TaskB", () => TaskB.Func1(5)))) return;
	/// ]]></code>
	/// File TaskA.cs.
	/// <code><![CDATA[
	/// static class TaskA {
	/// 	public static void Func1() {
	/// 		dialog.show(null, "TaskA");
	/// 	}
	/// }
	/// ]]></code>
	/// File TaskB.cs.
	/// <code><![CDATA[
	/// static class TaskB {
	/// 	public static void Func1(int x) {
	/// 		dialog.show(null, $"TaskB, x={x}");
	/// 	}
	/// }
	/// ]]></code>
	/// </example>
	public static bool TestCurrentFileInProject(params (string file, Action action)[] files) {
		if (GetFileInfo(false) is { } f && f.kind is EFileKind.Class) {
			var s = f.name[..^3];
			foreach (var (n, a) in files) {
				if (n.Eqi(s)) {
					a();
					return true;
				}
			}
		}
		return false;
	}
	
	
	//rejected. Use folders.Editor.
	///// <summary>
	///// Gets some special folders of editor process.
	///// </summary>
	///// <remarks>
	///// Default folders are:
	///// <c>ThisAppDocuments</c> - <c>folders.Documents + "LibreAutomate"</c>.
	///// <c>ThisAppDataLocal</c> - <c>folders.LocalAppData + "LibreAutomate"</c>.
	///// <c>ThisAppTemp</c> - <c>folders.Temp + "LibreAutomate"</c>.
	///// 
	///// Here <i>path</i> is either full path (like <c>C:\folder</c> or <c>%folders.Documents%\folder</c>) or path relative to the program's folder (like <c>ChildFolder</c> or <c>..\SiblingFolder</c>).
	///// </remarks>
	///// <seealso cref="folders.Workspace"/>
	//public static class Folders {
	//	static string _Get(int i) {
	//		if (a == null) {
	//			var w = WndMsg_;
	//			if (!w.Is0) {
	//				WndCopyData.SendReceive<char>(w, 13, null, out string r);
	//				if (!r.NE()) a = r.Split('|');
	//			}
	//			a ??= new string[] { null, null, null };
	//		}
	//		return a[i];
	//	}
	
	//	static string[] a;
	
	//	/// <summary>
	//	/// Gets <see cref="folders.ThisAppDocuments"/> of editor process.
	//	/// </summary>
	//	/// <value>null if failed.</value>
	//	public static FolderPath ThisAppDocuments => new(_Get(0));
	
	//	/// <summary>
	//	/// Gets <see cref="folders.ThisAppDataLocal"/> of editor process.
	//	/// </summary>
	//	/// <value>null if failed.</value>
	//	public static FolderPath ThisAppDataLocal => new(_Get(1));
	
	//	/// <summary>
	//	/// Gets <see cref="folders.ThisAppTemp"/> of editor process.
	//	/// </summary>
	//	/// <value>null if failed.</value>
	//	public static FolderPath ThisAppTemp => new(_Get(2));
	//}
	
	//[StructLayout(LayoutKind.Sequential, Size = 64)] //note: this struct is in shared memory. Size must be same in all library versions.
	//internal struct SharedMemoryData_ {
	//	int _wndEditorMsg, _wndEditorMain;
	
	//	internal wnd wndEditorMsg {
	//		get {
	//			if (_wndEditorMsg != 0) {
	//				var w = (wnd)_wndEditorMsg;
	//				if (w.ClassNameIs(c_msgWndClassName)) return w;
	//				//_wndEditorMsg = 0; //no, unsafe
	//			}
	//			return default;
	//		}
	//		set { _wndEditorMsg = (int)value; }
	//	}
	//	internal wnd wndEditorMain {
	//		get => wndEditorMsg.Is0 ? default : (wnd)_wndEditorMain;
	//		set { _wndEditorMain = (int)value; }
	//	}
	
	//}
}


================================================
FILE: Au/Other/internet.cs
================================================
using System.Net.NetworkInformation;
using System.Net.Http;
using System.Net.Http.Json;
using System.Net.Http.Headers;
using System.Text.Json;
using System.Text.Json.Nodes;
using System.Net;
using System.IO.Compression;

namespace Au {
	/// <summary>
	/// This class, together with <see cref="ExtInternet"/> (extension methods), make easier to use <see cref="HttpClient"/> and other .NET Internet classes for tasks like download, post, ping.
	/// </summary>
	public static class internet {
		/// <summary>
		/// Sends an ICMP echo message to the specified website and returns <c>true</c> if successful. Can be used to check Internet connectivity.
		/// </summary>
		/// <param name="hostNameOrAddress">Domain name like <c>"google.com"</c> or IP like <c>"123.45.67.89"</c>.</param>
		/// <param name="timeout">Timeout in milliseconds.</param>
		/// <remarks>
		/// Not all websites support it.
		/// 
		/// Uses <see cref="Ping"/>.
		/// </remarks>
		public static bool ping(string hostNameOrAddress = "google.com", int timeout = 5000) {
			try {
				using var ping = new Ping();
				var reply = ping.Send(hostNameOrAddress, timeout);
				return reply.Status == IPStatus.Success;
			}
			catch { return false; }
		} //also tested http, but slow etc.
		
		/// <summary>
		/// Sends an ICMP echo message to the specified website and returns <c>true</c> if successful. Gets the roundtrip time.
		/// </summary>
		/// <param name="roundtripTime"><see cref="PingReply.RoundtripTime"/>.</param>
		/// <inheritdoc cref="ping(string, int)"/>
		public static bool ping(out int roundtripTime, string hostNameOrAddress = "google.com", int timeout = 5000) {
			roundtripTime = 0;
			try {
				using var ping = new Ping();
				var reply = ping.Send(hostNameOrAddress, timeout);
				roundtripTime = (int)Math.Min(reply.RoundtripTime, int.MaxValue);
				return reply.Status == IPStatus.Success;
			}
			catch { return false; }
		}
		
		/// <summary>
		/// Gets a static <see cref="HttpClient"/> instance that can be used in scripts to download web pages, post web form data, etc.
		/// </summary>
		/// <remarks>
		/// Creates <see cref="HttpClient"/> only the first time; later just returns it.
		/// 
		/// Sets these properties and default headers:
		/// - <see cref="SocketsHttpHandler.AutomaticDecompression"/> = <c>All</c>.
		/// - <c>User-Agent: Au</c>.
		/// 
		/// <c>internet.http</c> makes easier to discover and use internet get/post/etc functions when using this library. You can instead create an <see cref="HttpClient"/> instance and use its functions in the same way. See the second example. Use the same <c>HttpClient</c> instance when making multiple get/post/etc requests.
		/// </remarks>
		/// <example>
		/// <code><![CDATA[
		/// string s = internet.http.Get("https://httpbin.org/anything").Text();
		/// ]]></code>
		/// Without <c>internet.http</c>.
		/// <code><![CDATA[
		/// using var http = new HttpClient();
		/// http.DefaultRequestHeaders.Add("User-Agent", "Script/1.0");
		/// string s = http.Get("https://httpbin.org/anything").Text();
		/// ]]></code>
		/// Or.
		/// <code><![CDATA[
		/// using var http = new HttpClient() { BaseAddress = new("https://httpbin.org") };
		/// http.DefaultRequestHeaders.Add("User-Agent", "Script/1.0");
		/// string s = http.Get("anything").Text();
		/// ]]></code>
		/// </example>
		public static HttpClient http => _lazyHC.Value; //rejected: public setter
		static Lazy<HttpClient> _lazyHC = new(_CreateHttpClient);
		
		static HttpClient _CreateHttpClient() {
			var h = new SocketsHttpHandler { AutomaticDecompression = DecompressionMethods.All };
			var r = new HttpClient(h);
			r.DefaultRequestHeaders.Add("User-Agent", "Au"); //without it some servers reject requests
			process.thisProcessExit += _ => r.Dispose();
			return r;
			
			//HttpClient does not close the connection after sending a request. It's good. Most servers have keep-alive timeout 5 or 10 s.
			//	Closes when disposing. And maybe when server closes; and maybe after h.PooledConnectionIdleTimeout etc; not tested.
			//	Does not close when sending request to another server. Supports multiple connections at the same time.
			
			//It seems HttpClient.Send etc are thread-safe.
			//	Tested: if several threads send a request to the same URL, are created several connections.
			//	However threads cannot safely change base address, default headers, etc.
			
			//Another possible problem - DNS changes.
			//	By default, idle connections are closed after 1 minute.
			//	For active connections can set h.PooledConnectionLifetime. Never mind.
		}
		
		/// <summary>
		/// Gets a static <see cref="HttpClient"/> instance that can be used in this library.
		/// </summary>
		internal static HttpClient http_ => _lazyHC_.Value;
		static Lazy<HttpClient> _lazyHC_ = new(_CreateHttpClient);
		
		/// <summary>
		/// Creates an <see cref="HttpContent"/> for posting web form fields with functions like <see cref="HttpClient.PostAsync(string?, HttpContent?)"/> and <see cref="ExtInternet.Post"/>.
		/// </summary>
		/// <param name="fields">One or more web form field names and values. See example.</param>
		/// <exception cref="ArgumentException">An empty name.</exception>
		/// <example>
		/// <code><![CDATA[
		/// var content = internet.formContent(("name1", "value1"), ("name2", "value2")).AddFile("name3", @"C:\Test\file.png");
		/// string s = internet.http.Post("https://httpbin.org/anything", content).Text();
		/// ]]></code>
		/// </example>
		public static MultipartFormDataContent formContent(params (string name, object value)[] fields) {
			var m = new MultipartFormDataContent();
			foreach (var (n, v) in fields) m.Add(n, v?.ToString());
			return m;
		}
		//rejected: overload with params string[] fields. Not intuitive, need to learn how to separate names/values. Easy with tuples.
		
		//rejected. Does not support files and does not have significant advantages, just slightly smaller data to send.
		//public static FormUrlEncodedContent formContent2(params (string name, string value)[] fields)
		//	=> new(fields.Select(o=>new KeyValuePair<string, string>(o.Item1, o.Item2)));
		
		/// <summary>
		/// Creates <see cref="HttpContent"/> for posting JSON. It can be used with functions like <see cref="HttpClient.PostAsync(string?, HttpContent?)"/> and <see cref="ExtInternet.Post"/>.
		/// </summary>
		/// <param name="x">JSON string, or <see cref="JsonNode"/> (or a derived type), or object of any type that can be serialized to JSON with <see cref="JsonSerializer"/>.</param>
		/// <param name="options"></param>
		/// <exception cref="Exception">Exceptions of <see cref="JsonContent.Create(object?, Type, MediaTypeHeaderValue?, JsonSerializerOptions?)"/>.</exception>
		/// <returns>
		/// If <i>x</i> is string, creates/returns new <see cref="StringContent"/>.
		/// Else if <i>x</i> is <see cref="JsonNode"/> (or a derived type), calls <see cref="JsonNode.ToJsonString"/> and creates/returns new <see cref="StringContent"/>.
		/// Else if <i>x</i> is <see cref="HttpContent"/> (or a derived type), returns <i>x</i>.
		/// Else calls/returns <see cref="JsonContent.Create(object?, Type, MediaTypeHeaderValue?, JsonSerializerOptions?)"/>.
		/// </returns>
		/// <example>
		/// <code><![CDATA[
		/// var v = new { a = "A", b = true };
		/// string s = internet.http.Post("https://httpbin.org/anything", internet.jsonContent(v)).Text();
		/// ]]></code>
		/// </example>
		public static HttpContent jsonContent(object x, JsonSerializerOptions options = null) {
			return x switch {
				HttpContent c => c,
				string s => new StringContent(s, null, "application/json"),
				JsonNode n => new StringContent(n.ToJsonString(options), null, "application/json"),
				_ => JsonContent.Create(x, x.GetType(), null, options),
			};
		}
		
		/// <summary>
		/// Creates <see cref="HttpRequestMessage"/> for <see cref="HttpClient.Send"/> or <see cref="HttpClient.SendAsync"/> in the same way as the <see cref="HttpClient"/> extension methods of this library (<b>ExtInternet.Get</b>, <b>ExtInternet.Post</b> etc).
		/// </summary>
		/// <param name="method"><c>System.Net.Http.HttpMethod.Post</c> etc.</param>
		/// <inheritdoc cref="ExtInternet.Get(HttpClient, string, bool, IEnumerable{string}, string, Action{HttpRequestMessage})" path="/param"/>
		/// <example>
		/// <code><![CDATA[
		/// using System.Net.Http;
		/// var m = internet.message(HttpMethod.Get, "https://www.example.com");
		/// var r = internet.http.Send(m);
		/// print.it(r.Text());
		/// ]]></code>
		/// </example>
		public static HttpRequestMessage message(HttpMethod method, string url, IEnumerable<string> headers = null, HttpContent content = null, string auth = null)
			=> ExtInternet.HttpMessage_(method, url, headers, auth, null, content);
		
		/// <summary>
		/// Joins a URL address and parameters. Urlencodes parameters.
		/// </summary>
		/// <param name="address">URL part without parameters or with some parameters. The function does not modify it.</param>
		/// <param name="parameters">URL parameters to append, like <c>"name1=value1", "name2=value2"</c>. The function urlencodes them (<see cref="WebUtility.UrlEncode"/>).</param>
		/// <returns>String like <c>"address?name1=value1&amp;name2=value2"</c>.</returns>
		/// <exception cref="ArgumentException">Incorrect format of a parameters string.</exception>
		public static string urlAppend(string address, params string[] parameters) {
			var b = new StringBuilder(address);
			char sep = '?'; if (address != null && address.Contains('?')) sep = '&';
			foreach (var s in parameters) {
				int i = s.IndexOf('='); if (i < 1) throw new ArgumentException("parameters must be like \"name1=value1\", \"name2=value2\"");
				b.Append(sep).Append(WebUtility.UrlEncode(s[..i])).Append('=').Append(WebUtility.UrlEncode(s[++i..]));
				sep = '&';
			}
			return b.ToString();
		}
		//rejected: overload with (string, string)[]. Longer code and no real advantages.
		//rejected: overload with Strings. Unsafe, limited, und unclear how to use correctly.
		//rejected: overload with FormattableString. The user code is less readable, may be even longer, unclear, easy to make bugs. Difficult to prevent encoding the address part. Dubious advantage - can use FormattableString directly for 'url' parameters of functions like 'Get'.
	}
}

namespace Au.Types {
	
	/// <summary>
	/// Extension methods for .NET Internet functions.
	/// </summary>
	public static class ExtInternet {
		/// <summary>
		/// Adds a non-file field.
		/// Uses <see cref="MultipartFormDataContent.Add(HttpContent, string)"/>.
		/// </summary>
		/// <returns>This.</returns>
		/// <exception cref="ArgumentException">See <see cref="MultipartFormDataContent.Add(HttpContent, string)"/>.</exception>
		public static MultipartFormDataContent Add(this MultipartFormDataContent t, string name, string value) {
			t.Add(new StringContent(value), name);
			return t;
		}
		
		/// <summary>
		/// Adds a file field.
		/// Uses <see cref="MultipartFormDataContent.Add(HttpContent, string, string)"/>.
		/// Please read remarks about disposing.
		/// </summary>
		/// <param name="t"></param>
		/// <param name="name">Field name.</param>
		/// <param name="file">File path.</param>
		/// <param name="contentType"><c>Content-Type</c> header, for example <c>"image/png"</c>.</param>
		/// <param name="fileName">Filename. If <c>null</c>, gets from <i>file</i>.</param>
		/// <returns>This.</returns>
		/// <remarks>
		/// Opens the file and stores the stream in this <see cref="MultipartFormDataContent"/> object. Won't auto-close it after uploading. To close files, dispose this <c>MultipartFormDataContent</c> object, for example with <c>using</c> like in the example. Else the file will remain opened/locked until this process exits or until next garbage collection.
		/// </remarks>
		/// <exception cref="ArgumentException">See <see cref="MultipartFormDataContent.Add(HttpContent, string, string)"/>.</exception>
		/// <exception cref="Exception">Exceptions of <see cref="filesystem.loadStream"/>.</exception>
		/// <example>
		/// <code><![CDATA[
		/// using var content = internet.formContent(("name1", "value1"), ("name2", "value2")).AddFile("name3", @"C:\Test\file.png");
		/// string s = internet.http.Post("https://httpbin.org/anything", content).Text();
		/// ]]></code>
		/// </example>
		public static MultipartFormDataContent AddFile(this MultipartFormDataContent t, string name, string file, string contentType = null, string fileName = null) {
			var k = new StreamContent(filesystem.loadStream(file));
			if (contentType != null) k.Headers.ContentType = new MediaTypeHeaderValue(contentType);
			t.Add(k, name, fileName ?? pathname.getName(file));
			return t;
		}
		
		/// <summary>
		/// Adds multiple HTTP request headers.
		/// Uses <see cref="HttpHeaders.Add(string, string?)"/>.
		/// </summary>
		/// <param name="t"></param>
		/// <param name="headers">Headers like <c>"name1: value1", "name2: value2"</c>.</param>
		/// <exception cref="ArgumentException">Incorrect format of a <i>headers</i> string.</exception>
		/// <exception cref="Exception">Exceptions of <see cref="HttpHeaders.Add(string, string?)"/>.</exception>
		public static void AddMany(this HttpRequestHeaders t, params string[] headers) => AddMany(t, (IEnumerable<string>)headers);
		
		/// <inheritdoc cref="AddMany(HttpRequestHeaders, string[])"/>
		public static void AddMany(this HttpRequestHeaders t, IEnumerable<string> headers) {
			foreach (var s in headers) {
				int i = s?.IndexOf(':') ?? -1; if (i < 1) throw new ArgumentException("headers must be like \"name1: value1\", \"name2: value2\"");
				int j = i + 1; while (s.Eq(j, ' ')) j++;
				t.Add(s[..i], s[j..]);
			}
		}
		//rejected: overload with (string, string)[]. Longer code and no real advantages.
		//rejected: overload Strings. Shorter code if can safely uses string, but longer etc if need to use array because values may contain '|'.
		
		#region HttpClient
		
		/// <summary>
		/// Sends a GET request to the specified URL, and gets the response.
		/// </summary>
		/// <param name="t"></param>
		/// <param name="url">URL. To create URL with urlencoded parameters you can use <see cref="internet.urlAppend"/>.</param>
		/// <param name="dontWait">Use <see cref="HttpCompletionOption.ResponseHeadersRead"/>.</param>
		/// <param name="headers">
		/// <c>null</c> or request headers like <c>["name1: value1", "name2: value2"]</c>.
		/// Also you can add headers to <see cref="HttpClient.DefaultRequestHeaders"/>, like <c>internet.http.DefaultRequestHeaders.Add("User-Agent", "Script/1.0");</c>.
		/// </param>
		/// <param name="auth">String like <c>"username:password"</c> for basic authentication. It will be encoded and sent in the <c>Authorization</c> header. For other authentication schemes use the <i>headers</i> parameter instead, like <c>headers: ["Authorization: Bearer token"]</c>.</param>
		/// <param name="also">Can set more properties for the request.</param>
		/// <returns>An <c>HttpResponseMessage</c> object that can be used to get response content (web page HTML, JSON, file, etc), headers etc. To get content use <see cref="Text"/> etc.</returns>
		/// <exception cref="Exception">
		/// Exceptions of <see cref="HttpClient.Send(HttpRequestMessage, HttpCompletionOption)"/>.
		/// If <i>headers</i> used, exceptions of <see cref="AddMany"/>.
		/// </exception>
		/// <exception cref="UriFormatException">Invalid URL format.</exception>
		/// <example>
		/// <code><![CDATA[
		/// string s = internet.http.Get("https://httpbin.org/anything").Text();
		/// ]]></code>
		/// </example>
		public static HttpResponseMessage Get(this HttpClient t, string url, bool dontWait = false, IEnumerable<string> headers = null, string auth = null, Action<HttpRequestMessage> also = null) {
			using var m = HttpMessage_(HttpMethod.Get, url, headers, auth, also);
			return t.Send(m, dontWait ? HttpCompletionOption.ResponseHeadersRead : HttpCompletionOption.ResponseContentRead);
		}
		
		//rejected. It's easy to use .NET methods directly (for those familiar with await). For the same reason rejected CancellationToken parameter of Get etc.
		///// <inheritdoc cref="Get(HttpClient, string, bool, IEnumerable{string}, string, Action{HttpRequestMessage}, CancellationToken)"/>
		//public static Task<HttpResponseMessage> GetAsync(this HttpClient t, string url, bool dontWait = false, IEnumerable<string> headers = null, string auth = null, Action<HttpRequestMessage> also = null, CancellationToken cancel = default) {
		//	using var m = _HttpMessage(HttpMethod.Get, url, headers, auth, also);
		//	return t.SendAsync(m, dontWait ? HttpCompletionOption.ResponseHeadersRead : HttpCompletionOption.ResponseContentRead, cancel);
		//}
		
		internal static HttpRequestMessage HttpMessage_(HttpMethod method, string url, IEnumerable<string> headers, string auth, Action<HttpRequestMessage> also, HttpContent content = null) {
			Not_.Null(url);
			var m = new HttpRequestMessage(method, url);
			if (headers != null) m.Headers.AddMany(headers);
			if (auth != null) m.Headers.Add("Authorization", "Basic " + Convert.ToBase64String(auth.ToUTF8()));
			if (content != null) m.Content = content;
			also?.Invoke(m);
			return m;
		}
		
		//rejected. This could be used with 'also' parameter, and then could remove 'auth' parameter. But this library is mostly for non-programmers, and should make user code as simple as possible.
		///// <summary>
		///// Adds <c>Authorization</c> header for basic authentication.
		///// </summary>
		//public static void Auth(this HttpRequestMessage t, string user, string password) {
		//	t.Headers.Add("Authorization", "Basic " + Convert.ToBase64String($"{user}:{password}".ToUTF8()));
		//}
		
		/// <summary>
		/// Sends a GET request to the specified URL, and gets the response. Handles HTTP errors and exceptions.
		/// </summary>
		/// <param name="t"></param>
		/// <param name="r">Receives <c>HttpResponseMessage</c> object that can be used to get response content (web page HTML, JSON, file, etc), headers etc. See example. Will be <c>null</c> if failed because of an exception.</param>
		/// <param name="url">URL. To create URL with urlencoded parameters you can use <see cref="internet.urlAppend"/>.</param>
		/// <param name="dontWait">Use <see cref="HttpCompletionOption.ResponseHeadersRead"/>.</param>
		/// <param name="printError">If failed, call <see cref="print.warning"/>.</param>
		/// <inheritdoc cref="Get(HttpClient, string, bool, IEnumerable{string}, string, Action{HttpRequestMessage})" path="/param"/>
		/// <returns><c>false</c> if failed.</returns>
		/// <exception cref="UriFormatException">Invalid URL format.</exception>
		/// <exception cref="Exception">If <i>headers</i> used, exceptions of <see cref="AddMany"/>.</exception>
		/// <example>
		/// <code><![CDATA[
		/// if (!internet.http.TryGet(out var r, "https://httpbin.org/anything", printError: true)) return;
		/// print.it(r.Text());
		/// ]]></code>
		/// </example>
		public static bool TryGet(this HttpClient t, out HttpResponseMessage r, string url, bool dontWait = false, IEnumerable<string> headers = null, bool printError = false, string auth = null, Action<HttpRequestMessage> also = null) {
			using var m = HttpMessage_(HttpMethod.Get, url, headers, auth, also);
			try {
				r = t.Send(m, dontWait ? HttpCompletionOption.ResponseHeadersRead : HttpCompletionOption.ResponseContentRead);
				if (r.IsSuccessStatusCode) return true;
				if (printError) {
					var s1 = $"HTTP GET failed. {(int)r.StatusCode} ({r.StatusCode}), {r.ReasonPhrase}";
					if (!dontWait) try { if (r.Text(ignoreError: true) is [_, ..] s2) s1 = s1 + ", " + s2; } catch { }
					print.warning(s1);
				}
			}
			catch (Exception e) {
				r = null;
				if (printError) print.warning($"HTTP GET failed. {e.ToStringWithoutStack()}");
			}
			return false;
		}
		
		/// <summary>
		/// Sends a GET request to the specified URL, and gets the response. Saves the response content (file, web page, etc) in a file.
		/// </summary>
		/// <param name="t"></param>
		/// <param name="url">URL. To create URL with urlencoded parameters you can use <see cref="internet.urlAppend"/>.</param>
		/// <param name="resultFile">File path. The function uses <see cref="pathname.normalize"/>. Creates parent directory if need.</param>
		/// <inheritdoc cref="Get(HttpClient, string, bool, IEnumerable{string}, string, Action{HttpRequestMessage})" path="/param"/>
		/// <returns>An <c>HttpResponseMessage</c> object that contains response headers etc. Rarely used.</returns>
		/// <exception cref="Exception">
		/// Exceptions of <see cref="HttpClient.Send(HttpRequestMessage, HttpCompletionOption)"/> and <see cref="Save"/>.
		/// If <i>headers</i> used, exceptions of <see cref="AddMany"/>.
		/// </exception>
		public static HttpResponseMessage Get(this HttpClient t, string url, string resultFile, IEnumerable<string> headers = null, string auth = null, Action<HttpRequestMessage> also = null) {
			Not_.Null(resultFile);
			var r = Get(t, url, true, headers, auth, also).Save(resultFile);
			r.Dispose();
			return r;
		}
		
		/// <summary>
		/// Sends a POST request to the specified URL, and gets the response.
		/// </summary>
		/// <param name="t"></param>
		/// <param name="url">URL.</param>
		/// <param name="content">Data to post. Usually web form data (see <see cref="internet.formContent"/>) or JSON (see <see cref="internet.jsonContent"/>). Can be <c>null</c>.</param>
		/// <param name="dontWait">Use <see cref="HttpCompletionOption.ResponseHeadersRead"/>.</param>
		/// <inheritdoc cref="Get(HttpClient, string, bool, IEnumerable{string}, string, Action{HttpRequestMessage})" path="/param"/>
		/// <returns>An <c>HttpResponseMessage</c> object that can be used to get response content (web page HTML, JSON, file, etc), headers etc. To get content use <see cref="Text"/> etc.</returns>
		/// <exception cref="Exception">
		/// Exceptions of <see cref="HttpClient.Send(HttpRequestMessage, HttpCompletionOption)"/>.
		/// If <i>headers</i> used, exceptions of <see cref="AddMany"/>.
		/// </exception>
		/// <example>
		/// Post form data.
		/// Note: the <c>using</c> will close the file stream. Don't need it when content does not contain files.
		/// <code><![CDATA[
		/// using var content = internet.formContent(("name1", "value1"), ("name2", "value2")).AddFile("name3", @"C:\Test\file.png");
		/// string s = internet.http.Post("https://httpbin.org/anything", content).Text();
		/// ]]></code>
		/// Post object as JSON.
		/// <code><![CDATA[
		/// var v = new { a = "A", b = true };
		/// string s = internet.http.Post("https://httpbin.org/anything", internet.jsonContent(v)).Text();
		/// print.it(s);
		/// ]]></code>
		/// </example>
		public static HttpResponseMessage Post(this HttpClient t, string url, HttpContent content, IEnumerable<string> headers = null, bool dontWait = false, string auth = null, Action<HttpRequestMessage> also = null) {
			using var m = HttpMessage_(HttpMethod.Post, url, headers, auth, also, content);
			return t.Send(m, dontWait ? HttpCompletionOption.ResponseHeadersRead : HttpCompletionOption.ResponseContentRead);
		}
		//rejected: bool disposeContent = true (auto-close MultipartFormDataContent streams etc).
		//	Users may want to retry etc. Usually this is used in scripts that will exit soon. Usually not so important to close files immediately.
		//rejected. string resultFile = null. It seems POST is rarely used to download files. Also don't need parameter dontWait; HttpClient.PostAsync does not have it too.
		
		/// <summary>
		/// Sends a POST request to the specified URL, and gets the response. Handles HTTP errors and exceptions.
		/// </summary>
		/// <param name="t"></param>
		/// <param name="r">Receives <c>HttpResponseMessage</c> object that can be used to get response content (web page HTML, JSON, file, etc), headers etc. See example. Will be <c>null</c> if failed because of an exception.</param>
		/// <param name="url">URL.</param>
		/// <param name="content">Data to post. Usually web form data (see <see cref="internet.formContent"/>) or JSON (see <see cref="internet.jsonContent"/>). Can be <c>null</c>.</param>
		/// <param name="printError">If failed, call <see cref="print.warning"/>.</param>
		/// <param name="dontWait">Use <see cref="HttpCompletionOption.ResponseHeadersRead"/>.</param>
		/// <inheritdoc cref="Get(HttpClient, string, bool, IEnumerable{string}, string, Action{HttpRequestMessage})" path="/param"/>
		/// <returns><c>false</c> if failed.</returns>
		/// <exception cref="UriFormatException">Invalid URL format.</exception>
		/// <exception cref="Exception">If <i>headers</i> used, exceptions of <see cref="AddMany"/>.</exception>
		/// <example>
		/// Post form data.
		/// <code><![CDATA[
		/// var content = internet.formContent(("name1", "value1"), ("name2", "value2"));
		/// if (!internet.http.TryPost(out var r, "https://httpbin.org/anything", content, printError: true)) return;
		/// print.it(r.Text());
		/// ]]></code>
		/// Post object as JSON.
		/// <code><![CDATA[
		/// var v = new { a = "A", b = true };
		/// if (!internet.http.TryPost(out var r, "https://httpbin.org/anything", internet.jsonContent(v), printError: true)) return;
		/// print.it(r.Text());
		/// ]]></code>
		/// </example>
		public static bool TryPost(this HttpClient t, out HttpResponseMessage r, string url, HttpContent content, IEnumerable<string> headers = null, bool printError = false, bool dontWait = false, string auth = null, Action<HttpRequestMessage> also = null) {
			using var m = HttpMessage_(HttpMethod.Post, url, headers, auth, also, content);
			try {
				r = t.Send(m, dontWait ? HttpCompletionOption.ResponseHeadersRead : HttpCompletionOption.ResponseContentRead);
				if (r.IsSuccessStatusCode) return true;
				if (printError) {
					var s1 = $"HTTP POST failed. {(int)r.StatusCode} ({r.StatusCode}), {r.ReasonPhrase}";
					if (!dontWait) try { if (r.Text(ignoreError: true) is [_, ..] s2) s1 = s1 + ", " + s2; } catch { }
					print.warning(s1);
				}
			}
			catch (Exception e) {
				r = null;
				if (printError) print.warning($"HTTP POST failed. {e.ToStringWithoutStack()}");
			}
			return false;
		}
		
		#endregion
		
		#region HttpResponseMessage
		
		/// <summary>
		/// Gets content text as string. Downloads it if need.
		/// </summary>
		/// <param name="t"></param>
		/// <param name="ignoreError">Don't call <see cref="HttpResponseMessage.EnsureSuccessStatusCode"/>.</param>
		/// <exception cref="HttpRequestException">Failed HTTP request. No exception if <i>ignoreError</i> <c>true</c>.</exception>
		/// <exception cref="Exception">Exceptions of <see cref="HttpContent.ReadAsStringAsync()"/>.</exception>
		public static string Text(this HttpResponseMessage t, bool ignoreError = false) {
			if (!ignoreError) t.EnsureSuccessStatusCode();
			return t.Content.ReadAsStringAsync().Result_();
		}
		
		/// <summary>
		/// Gets content data as <c>byte[]</c>. Downloads it if need. If content is text, the array contains that text, usually UTF-8.
		/// </summary>
		/// <param name="t"></param>
		/// <param name="ignoreError">Don't call <see cref="HttpResponseMessage.EnsureSuccessStatusCode"/>.</param>
		/// <exception cref="HttpRequestException">Failed HTTP request. No exception if <i>ignoreError</i> <c>true</c>.</exception>
		/// <exception cref="Exception">Exceptions of <see cref="HttpContent.ReadAsByteArrayAsync()"/>.</exception>
		public static byte[] Bytes(this HttpResponseMessage t, bool ignoreError = false) {
			if (!ignoreError) t.EnsureSuccessStatusCode();
			return t.Content.ReadAsByteArrayAsync().Result_();
		}
		
		/// <summary>
		/// Parses content, which must be JSON, and returns the root node. Then you can access JSON elements like <c>var y = (string)r["x"]["y"];</c>. Downloads content if need.
		/// Uses <see cref="JsonNode.Parse(ReadOnlySpan{byte}, JsonNodeOptions?, JsonDocumentOptions)"/>.
		/// </summary>
		/// <param name="t"></param>
		/// <param name="ignoreError">Don't call <see cref="HttpResponseMessage.EnsureSuccessStatusCode"/>.</param>
		/// <exception cref="HttpRequestException">Failed HTTP request. No exception if <i>ignoreError</i> <c>true</c>.</exception>
		/// <exception cref="Exception">Exceptions of <see cref="HttpContent.ReadAsByteArrayAsync()"/>.</exception>
		/// <exception cref="JsonException">Failed to parse JSON.</exception>
		public static JsonNode Json(this HttpResponseMessage t, bool ignoreError = false)
			=> JsonNode.Parse(Bytes(t, ignoreError));
		
		/// <summary>
		/// Parses content, which must be JSON. From it creates/returns an object of type <i>T</i>. Downloads content if need.
		/// Uses <see cref="HttpContentJsonExtensions.ReadFromJsonAsync{T}(HttpContent, JsonSerializerOptions?, CancellationToken)"/>.
		/// </summary>
		/// <param name="t"></param>
		/// <exception cref="HttpRequestException">Failed HTTP request.</exception>
		/// <exception cref="Exception">Exceptions of <c>ReadFromJsonAsync</c>.</exception>
		public static T Json<T>(this HttpResponseMessage t)
			=> t.EnsureSuccessStatusCode().Content.ReadFromJsonAsync<T>().Result_();
		
		/// <summary>
		/// Saves content in a file. Downloads if need.
		/// </summary>
		/// <param name="t"></param>
		/// <param name="file">File path. The function uses <see cref="pathname.normalize"/>. Creates parent directory if need.</param>
		/// <returns>This.</returns>
		/// <exception cref="HttpRequestException">Failed HTTP request.</exception>
		/// <exception cref="ArgumentException">Not full path.</exception>
		/// <exception cref="Exception">Exceptions of <see cref="HttpContent.ReadAsStream()"/>, <see cref="File.Create(string)"/> and other used functions.</exception>
		/// <remarks>
		/// By default <see cref="HttpClient"/> downloads content to a memory buffer before returning. To avoid it, use <i>completionOption</i> <see cref="HttpCompletionOption.ResponseHeadersRead"/>, or <see cref="Get(HttpClient, string, bool, IEnumerable{string}, string, Action{HttpRequestMessage})"/> with <i>dontWait</i> <c>true</c>. Then call this function (it will download the file), and finally dispose the <see cref="HttpResponseMessage"/>.
		/// </remarks>
		/// <seealso cref="Get(HttpClient, string, string, IEnumerable{string}, string, Action{HttpRequestMessage})"/>
		public static HttpResponseMessage Save(this HttpResponseMessage t, string file) {
			t.EnsureSuccessStatusCode();
			filesystem.createDirectoryFor(file = pathname.normalize(file));
			using var s1 = t.Content.ReadAsStream();
			using var s2 = File.Create(file);
			_GetDecompressStream(t, s1).CopyTo(s2);
			return t;
			//rejected: decompress in all funcs. Then cannot use ReadAsByteArrayAsync, ReadAsStringAsync, ReadFromJsonAsync<T>.
		}
		
		static Stream _GetDecompressStream(HttpResponseMessage t, Stream s) {
			var ce = t.Content.Headers.ContentEncoding;
			if (ce.Count == 1) {
				switch (ce.First().Lower()) {
				case "br": return new BrotliStream(s, CompressionMode.Decompress);
				case "gzip": return new GZipStream(s, CompressionMode.Decompress);
				case "deflate": return new DeflateStream(s, CompressionMode.Decompress);
				}
			}
			return s;
		}
		
		/// <summary>
		/// Downloads content to stream and provides the progress.
		/// </summary>
		/// <param name="t"></param>
		/// <param name="stream">Writes to this stream.</param>
		/// <param name="progress">Calls this callback function to report the progress. If <c>null</c>, shows standard progress dialog.</param>
		/// <param name="cancel">Can be used to cancel.</param>
		/// <param name="disposeStream">Call <c>stream.Dispose();</c>.</param>
		/// <param name="progressText1">Progress dialog heading text. Default: <c>"Downloading"</c>.</param>
		/// <returns><c>false</c> if canceled.</returns>
		/// <exception cref="HttpRequestException">Failed HTTP request.</exception>
		/// <exception cref="Exception">Other exceptions.</exception>
		/// <remarks>
		/// By default <see cref="HttpClient"/> downloads content to a memory buffer before returning. To avoid it, use <i>completionOption</i> <see cref="HttpCompletionOption.ResponseHeadersRead"/>, or <see cref="Get(HttpClient, string, bool, IEnumerable{string}, string, Action{HttpRequestMessage})"/> with <i>dontWait</i> <c>true</c>. Then call this function (it will download the file), and finally dispose the <see cref="HttpResponseMessage"/>.
		/// 
		/// Cannot provide the progress percentage if the content length is unknown. Top reasons:
		/// - The HTTP server uses chunked transfer encoding.
		/// - The HTTP server uses content compression and the <see cref="HttpClient"/> is configured to automatically decompress (for example <see cref="internet.http"/>). Instead of <c>internet.http</c> create a <see cref="HttpClient"/> and optionally set header <c>"Accept-Encoding: br, gzip, deflate"</c>. This function will decompress.
		/// </remarks>
		public static bool Download(this HttpResponseMessage t, Stream stream, Action<ProgressArgs> progress = null, CancellationToken cancel = default, bool disposeStream = false, string progressText1 = null) {
			dialog pd = null;
			Stream decomp = null;
			try {
				ArgumentNullException.ThrowIfNull(stream, nameof(stream));
				t.EnsureSuccessStatusCode();
				if (cancel.IsCancellationRequested) return false;
				long size = t.Content.Headers.ContentLength ?? 0;
				//print.it(size);
				//print.it(t);
				//BAD: content length is unknown for many files if the HttpClient uses AutomaticDecompression (eg internet.http).
				//	The header is removed, because impossible to know the decompressed length now.
				//BAD: content length is unknown if "Transfer-Encoding: chunked". Eg most webservers use chunked for html files.
				//GOOD: usually web servers don't use "Content-Encoding" and "Transfer-Encoding" for big files that are usually compressed, eg exe, zip, png.
				
				using var s1 = t.Content.ReadAsStream();
				
				string filename = null;
				string _DialogText(long bytes) => $"{filename}\n{bytes / 1048576d:0.#} MB";
				if (progress == null) {
					filename = pathname.getName(t.RequestMessage.RequestUri.AbsolutePath);
					pd = dialog.showProgress(size == 0, progressText1 ?? "Downloading", _DialogText(size));
				}
				
				Stream stream1 = s1, stream2 = stream;
				string ce = t.Content.Headers.ContentEncoding.FirstOrDefault()?.Lower();
				if (ce != null) {
					if (ce is not ("br" or "gzip" or "deflate") || t.Content.Headers.ContentEncoding.Count != 1) throw new NotSupportedException("Content-Encoding");
					if (size > 0 && size < 10_000_000) stream2 = new MemoryStream((int)size); //to display progress we need a temp stream; finally will decompress it to *stream*
					else stream1 = decomp = _DecompStream(ce, s1); //can't display progress. Will decompress directly when reading.
				}
				
				static Stream _DecompStream(string ce, Stream s)
					=> ce switch { "br" => new BrotliStream(s, CompressionMode.Decompress), "gzip" => new GZipStream(s, CompressionMode.Decompress), _ => new DeflateStream(s, CompressionMode.Decompress) };
				
				var b = new byte[16384];
				long have = 0; int n, ppercent = 0, ptime = Environment.TickCount;
				while ((n = stream1.Read(b)) > 0) {
					stream2.Write(b, 0, n);
					if (cancel.IsCancellationRequested) return false;
					have += n;
					int percent = 0, time = 0; bool updateProgress;
					if (size > 0) {
						percent = (int)(have * 100 / size);
						if (updateProgress = percent > ppercent) ppercent = percent;
					} else {
						time = Environment.TickCount;
						if (updateProgress = time - ptime > 200) ptime = time;
					}
					
					if (pd != null) {
						if (!pd.IsOpen) { pd = null; return false; }
						if (updateProgress) {
							if (size > 0) pd.Send.Progress(percent);
							else pd.Send.ChangeText2(_DialogText(have), resizeDialog: false);
						}
					} else {
						if (updateProgress) {
							ProgressArgs pa = new(size, have, percent);
							progress(pa);
							if (pa.Cancel) return false;
						}
						if (cancel.IsCancellationRequested) return false;
					}
				}
				
				if (size == 0) progress?.Invoke(new(have, have, 100));
				
				if (stream2 != stream) {
					stream2.Position = 0;
					decomp = _DecompStream(ce, stream2);
					decomp.CopyTo(stream);
				}
			}
			finally {
				decomp?.Dispose();
				if (disposeStream) stream.Dispose();
				pd?.Send.Close();
			}
			return true;
		}
		
		/// <summary>
		/// Downloads content to file and provides the progress.
		/// </summary>
		/// <param name="file">File path. The function uses <see cref="pathname.normalize"/>. Creates parent directory if need.</param>
		/// <inheritdoc cref="Download(HttpResponseMessage, Stream, Action{ProgressArgs}, CancellationToken, bool, string)"/>
		/// <example>
		/// <code><![CDATA[
		/// if (!internet.http.Get(url, true).Download(zip)) return;
		/// ]]></code>
		/// </example>
		public static bool Download(this HttpResponseMessage t, string file, Action<ProgressArgs> progress = null, CancellationToken cancel = default, string progressText1 = null) {
			t.EnsureSuccessStatusCode();
			filesystem.createDirectoryFor(file = pathname.normalize(file));
			return Download(t, File.Create(file), progress, cancel, disposeStream: true, progressText1);
		}
		
		/// <summary>
		/// The async version of <see cref="Download(HttpResponseMessage, Stream, Action{ProgressArgs}, CancellationToken, bool, string)"/>.
		/// </summary>
		/// <inheritdoc cref="Download(HttpResponseMessage, Stream, Action{ProgressArgs}, CancellationToken, bool, string)"/>
		public static Task<bool> DownloadAsync(this HttpResponseMessage t, Stream stream, Action<ProgressArgs> progress = null, CancellationToken cancel = default, bool disposeStream = false, string progressText1 = null) {
			if (stream == null || !t.IsSuccessStatusCode) {
				if (disposeStream) stream.Dispose();
				ArgumentNullException.ThrowIfNull(stream, nameof(stream));
				t.EnsureSuccessStatusCode();
			}
			if (progress != null && SynchronizationContext.Current is { } ct && ct.GetType() != typeof(SynchronizationContext)) { //call in this thread
				bool canceled = false;
				var progress0 = progress;
				progress = pa => {
					//runs sync in task thread
					if (canceled) { pa.Cancel = true; return; }
					ct.Post(_ => {
						//runs async in caller's thread
						if (canceled) return;
						progress0(pa);
						if (pa.Cancel) canceled = true;
					}, null);
				};
				
				//note: don't use Progress<T>. With default synccontext it calls in random thread pool thread.
				//	This code works like Progress<T> with other synccontexts.
			}
			return Task.Run(() => Download(t, stream, progress, cancel, disposeStream, progressText1));
		}
		
		/// <summary>
		/// The async version of <see cref="Download(HttpResponseMessage, string, Action{ProgressArgs}, CancellationToken, string)"/>.
		/// </summary>
		/// <inheritdoc cref="Download(HttpResponseMessage, string, Action{ProgressArgs}, CancellationToken, string)"/>
		public static Task<bool> DownloadAsync(this HttpResponseMessage t, string file, Action<ProgressArgs> progress = null, CancellationToken cancel = default) {
			t.EnsureSuccessStatusCode();
			filesystem.createDirectoryFor(file = pathname.normalize(file));
			var stream = File.Create(file);
			return DownloadAsync(t, stream, progress, cancel, disposeStream: true);
		}
		
		#endregion
	}
	
	/// <summary>
	/// Arguments for a progress callback function.
	/// </summary>
	/// <param name="Total">The max expected value. Or 0 if unknown.</param>
	/// <param name="Current">The current value.</param>
	/// <param name="Percent"><c>Current * 100 / Total</c>. Or 0 if unknown.</param>
	public record class ProgressArgs(long Total, long Current, int Percent) {
		/// <summary>
		/// The callback function can use this to cancel the operation.
		/// </summary>
		public bool Cancel { get; set; }
	}
}


================================================
FILE: Au/Other/lastError.cs
================================================
namespace Au {
	/// <summary>
	/// Gets, sets or clears the last error code of Windows API. Gets error text.
	/// </summary>
	/// <remarks>
	/// Many Windows API functions, when failed, set an error code. Code 0 means no error. It is stored in an internal thread-specific <c>int</c> variable. But only if the API declaration's <c>DllImport</c> attribute has <c>SetLastError = true</c>.
	/// 
	/// Some functions of this library simply call these API functions and don't throw exception when API fail. For example, most <see cref="wnd"/> property-get functions.
	/// When failed, they return <c>false</c>/0/<c>null</c>/empty. Then you can use <see cref="code"/> to get the error code or <see cref="message"/> to get error text.
	/// 
	/// Most of functions set error code only when failed, and don't clear the old error code when succeeded. Therefore may need to call <see cref="clear"/> before.
	/// 
	/// Windows API error code definitions and documentation are not included in this library. You can look for them in API function documentation on the internet.
	/// </remarks>
	/// <example>
	/// <code><![CDATA[
	/// wnd w = wnd.find("Notepag");
	/// lastError.clear();
	/// bool enabled = w.IsEnabled; //returns true if enabled, false if disabled or failed
	/// if(!enabled && lastError.code != 0) { print.it(lastError.message); return; } //1400, Invalid window handle
	/// print.it(enabled);
	/// ]]></code>
	/// </example>
	public static class lastError {
		/// <summary>
		/// Calls API <ms>SetLastError</ms>(0), which clears the Windows API last error code of this thread.
		/// </summary>
		/// <remarks>
		/// Need it before calling some functions if you want to use <see cref="code"/> or <see cref="message"/>.
		/// The same as <c>lastError.code = 0;</c>.
		/// </remarks>
		public static void clear() => Api.SetLastError(0);
		
		/// <summary>
		/// Gets (<see cref="Marshal.GetLastWin32Error"/>) or sets (API <ms>SetLastError</ms>) the Windows API last error code of this thread.
		/// </summary>
		public static int code {
			get => Marshal.GetLastWin32Error();
			set => Api.SetLastError(value);
		}
		
		/// <summary>
		/// Gets the text message of the Windows API last error code of this thread.
		/// </summary>
		/// <returns><c>null</c> if the code is 0.</returns>
		/// <remarks>
		/// The string always ends with <c>"."</c>.
		/// </remarks>
		public static string message => messageFor(code);
		
		/// <summary>
		/// Gets the text message of a Windows API error code.
		/// </summary>
		/// <returns><c>null</c> if <i>errorCode</i> is 0.</returns>
		/// <remarks>
		/// The string always ends with <c>"."</c>.
		/// </remarks>
		public static unsafe string messageFor(int errorCode) {
			if (errorCode == 0) return null;
			if (errorCode == 1) return "The requested data or action is unavailable. (0x1)."; //or ERROR_INVALID_FUNCTION, but it's rare
			string s = "Unknown exception";
			char* p = null;
			const uint fl = Api.FORMAT_MESSAGE_FROM_SYSTEM | Api.FORMAT_MESSAGE_ALLOCATE_BUFFER | Api.FORMAT_MESSAGE_IGNORE_INSERTS;
			int r = Api.FormatMessage(fl, default, errorCode, 0, &p, 0, default);
			if (p != null) {
				while (r > 0 && p[r - 1] <= ' ') r--;
				if (r > 0) {
					if (p[r - 1] == '.') r--;
					s = new string(p, 0, r);
				}
				Api.LocalFree(p);
			}
			s = (uint)errorCode <= 0xffff ? $"{s} ({errorCode})." : $"{s} (0x{errorCode:X}).";
			return s;
		}
	}
}


================================================
FILE: Au/Other/opt.cs
================================================
namespace Au {
	/// <summary>
	/// Ambient options for some functions of this library.
	/// </summary>
	/// <remarks>
	/// Some frequently used functions of this library have some options (settings). For example <see cref="keys.send"/> allows to change speed, text sending method, etc. Passing options as parameters in each call usually isn't what you want to do in automation scripts. Instead use this class. See examples.
	/// 
	/// To store these options, internally is used <see cref="AsyncLocal{T}"/>. It means that a new task or thread inherits a copy of options of the caller. It can't modify options of the caller or other tasks/threads.
	/// </remarks>
	/// <example>
	/// <code><![CDATA[
	/// opt.key.KeySpeed = 50;
	/// ]]></code>
	/// Set options for trigger actions.
	/// <code><![CDATA[
	/// Triggers.Options.BeforeAction = o => { opt.key.KeySpeed = 50; };
	/// ]]></code>
	/// </example>
	public static class opt {
		/// <summary>
		/// Options for mouse functions (class <see cref="Au.mouse"/> and functions that use it).
		/// </summary>
		/// <example>
		/// <code><![CDATA[
		/// opt.mouse.ClickSpeed = 100;
		/// mouse.click();
		/// ]]></code>
		/// </example>
		public static OMouse mouse => OMouse.Ambient_;
		
		/// <summary>
		/// Options for keyboard and clipboard functions (classes <see cref="keys"/>, <see cref="clipboard"/> and functions that use them).
		/// </summary>
		/// <example>
		/// <code><![CDATA[
		/// opt.key.KeySpeed = 100;
		/// keys.send("Right*10 Ctrl+A");
		/// ]]></code>
		/// Use a <see cref="keys"/> instance.
		/// <code><![CDATA[
		/// var k = new keys(opt.key); //create new keys instance and copy options from opt.key to it
		/// k.Options.KeySpeed = 100; //changes option of k but not of opt.key
		/// k.Add("Right*10 Ctrl+A").SendNow(); //uses options of k
		/// ]]></code>
		/// Set options for trigger actions.
		/// <code><![CDATA[
		/// Triggers.Options.BeforeAction = o => { opt.key.KeySpeed = 50; };
		/// ]]></code>
		/// </example>
		public static OKey key => OKey.Ambient_;
		
		/// <summary>
		/// Options for showing run-time warnings and other info that can be useful to find problems in code at run time.
		/// </summary>
		/// <example>
		/// <code><![CDATA[
		/// opt.warnings.Verbose = false;
		/// print.warning("Example");
		/// print.warning("Example");
		/// ]]></code>
		/// </example>
		public static OWarnings warnings => OWarnings.Ambient_;
		
		/// <summary>
		/// Obsolete. Use <see cref="Seconds"/> instead.
		/// For backward compatibility, wait functions still use <c>opt.wait.DoEvents</c> if <c>Seconds.DoEvents</c> not specified.
		/// </summary>
		[EditorBrowsable(EditorBrowsableState.Never)]
		public static OWait wait => OWait.Ambient_;
		
		/// <summary>
		/// Obsolete.
		/// </summary>
		[Obsolete("Use opt instead. To set options for triggers can be used code like this: Triggers.Options.BeforeAction = o => { opt.key.TextSpeed = 5; opt.mouse.ClickSpeed = 30; };"), EditorBrowsable(EditorBrowsableState.Never)]
		public static class init {
			/// <summary>
			/// Obsolete. Same as <see cref="opt.mouse"/>.
			/// </summary>
			public static OMouse mouse => opt.mouse;
			
			/// <summary>
			/// Obsolete. Same as <see cref="opt.key"/>.
			/// </summary>
			public static OKey key => opt.key;
			
			/// <summary>
			/// Obsolete. Same as <see cref="opt.warnings"/>.
			/// </summary>
			public static OWarnings warnings => opt.warnings;
		}
		
		/// <summary>
		/// Creates temporary scopes for options.
		/// Example: <c>using(opt.scope.key()) { opt.key.KeySpeed=5; ... }</c>.
		/// </summary>
		public static class scope {
			/// <summary>
			/// Creates temporary scope for <see cref="opt.mouse"/> options. See example.
			/// </summary>
			/// <param name="inherit">If <c>true</c> (default), inherit current options. If <c>false</c>, uses default options.</param>
			/// <example>
			/// <code><![CDATA[
			/// print.it(opt.mouse.ClickSpeed);
			/// using(opt.scope.mouse()) {
			/// 	opt.mouse.ClickSpeed = 100;
			/// 	print.it(opt.mouse.ClickSpeed);
			/// } //here restored automatically
			/// print.it(opt.mouse.ClickSpeed);
			/// ]]></code>
			/// </example>
			public static UsingEndAction mouse(bool inherit = true) {
				var old = OMouse.Scope_(inherit);
				return new UsingEndAction(() => OMouse.Ambient_ = old);
			}
			
			/// <summary>
			/// Creates temporary scope for <see cref="opt.key"/> options. See example.
			/// </summary>
			/// <param name="inherit">If <c>true</c> (default), inherit current options. If <c>false</c>, uses default options.</param>
			/// <example>
			/// <code><![CDATA[
			/// print.it(opt.key.KeySpeed);
			/// using(opt.scope.key()) {
			/// 	opt.key.KeySpeed = 5;
			/// 	print.it(opt.key.KeySpeed);
			/// } //here restored automatically
			/// print.it(opt.key.KeySpeed);
			/// ]]></code>
			/// </example>
			public static UsingEndAction key(bool inherit = true) {
				var old = OKey.Scope_(inherit);
				return new UsingEndAction(() => OKey.Ambient_ = old);
			}
			
			/// <summary>
			/// Creates temporary scope for <see cref="opt.warnings"/> options. See example.
			/// </summary>
			/// <param name="inherit">If <c>true</c> (default), inherit current options. If <c>false</c>, uses default options.</param>
			/// <example>
			/// <code><![CDATA[
			/// opt.warnings.Verbose = false;
			/// print.it(opt.warnings.Verbose, opt.warnings.IsDisabled("Test*"));
			/// using(opt.scope.warnings()) {
			/// 	opt.warnings.Verbose = true;
			/// 	opt.warnings.Disable("Test*");
			/// 	print.it(opt.warnings.Verbose, opt.warnings.IsDisabled("Test*"));
			/// } //here restored automatically
			/// print.it(opt.warnings.Verbose, opt.warnings.IsDisabled("Test*"));
			/// ]]></code>
			/// </example>
			public static UsingEndAction warnings(bool inherit = true) {
				var old = OWarnings.Scope_(inherit);
				return new UsingEndAction(() => OWarnings.Ambient_ = old);
			}
			
			///
			[EditorBrowsable(EditorBrowsableState.Never)] //obsolete
			public static UsingEndAction wait(bool inherit = true) {
				var old = OWait.Scope_(inherit);
				return new UsingEndAction(() => OWait.Ambient_ = old);
			}
			
			/// <summary>
			/// Creates temporary scope for all options. See example.
			/// </summary>
			/// <param name="inherit">If <c>true</c> (default), inherit current options. If <c>false</c>, uses default options.</param>
			/// <example>
			/// <code><![CDATA[
			/// print.it(opt.key.KeySpeed, opt.mouse.ClickSpeed);
			/// using(opt.scope.all()) {
			/// 	opt.key.KeySpeed = 5;
			/// 	opt.mouse.ClickSpeed = 50;
			/// 	print.it(opt.key.KeySpeed, opt.mouse.ClickSpeed);
			/// } //here restored automatically
			/// print.it(opt.key.KeySpeed, opt.mouse.ClickSpeed);
			/// ]]></code>
			/// </example>
			public static UsingEndAction all(bool inherit = true/*, int? speed = null*/) {
				var o1 = OMouse.Scope_(inherit);
				var o2 = OKey.Scope_(inherit);
				var o3 = OWarnings.Scope_(inherit);
				var o4 = OWait.Scope_(inherit);
				return new UsingEndAction(() => {
					OMouse.Ambient_ = o1;
					OKey.Ambient_ = o2;
					OWarnings.Ambient_ = o3;
					OWait.Ambient_ = o4;
				});
			}
		}
	}
}

namespace Au.Types {
	/// <summary>
	/// Options for functions of class <see cref="mouse"/>.
	/// </summary>
	/// <remarks>
	/// Total <c>Click(x, y)</c> time is: mouse move + <see cref="MoveSleepFinally"/> + button down + <see cref="ClickSpeed"/> + button up + <see cref="ClickSpeed"/> + <see cref="ClickSleepFinally"/>.
	/// </remarks>
	/// <seealso cref="opt.mouse"/>
	/// <example>
	/// <code><![CDATA[
	/// opt.mouse.MoveSpeed = 30;
	/// ]]></code>
	/// </example>
	public sealed class OMouse {
		int _threadId;
		static AsyncLocal<OMouse> s_ambient = new();
		
		internal static OMouse Ambient_ {
			get {
				var threadId = Environment.CurrentManagedThreadId;
				if (s_ambient.Value is { } v) {
					if (v._threadId != threadId) s_ambient.Value = v = new(v) { _threadId = threadId };
				} else {
					s_ambient.Value = v = new() { _threadId = threadId };
				}
				return v;
			}
			set { Debug.Assert(value?._threadId != 0); s_ambient.Value = value; } //used only to restore scope
		}
		
		internal static OMouse Scope_(bool inherit) {
			var old = s_ambient.Value;
			s_ambient.Value = (old != null && inherit) ? new(old) { _threadId = Environment.CurrentManagedThreadId } : null; //lazy
			return old;
		}
		
		struct _Fields { //makes easier to init, reset or copy fields
			public _Fields() { }
			public int ClickSpeed = 20, MoveSpeed, ClickSleepFinally = 10, MoveSleepFinally = 10;
			public bool Relaxed;
		}
		_Fields _f;
		
		/// <summary>
		/// Initializes this instance with default values or values copied from another instance.
		/// </summary>
		/// <param name="other">If not <c>null</c>, copies its options into this variable.</param>
		internal OMouse(OMouse other = null) //don't need public like OKey
		{
			if (other != null) {
				_f = other._f;
			} else {
				_f = new();
			}
		}
		
		int _Set(int value, int max) {
			if ((uint)value > max) throw new ArgumentOutOfRangeException(null, "Max " + max);
			return value;
		}
		
		/// <summary>
		/// How long to wait (milliseconds) after sending each mouse button down or up event (2 events for click, 4 for double-click).
		/// Default: 20.
		/// </summary>
		/// <value>Valid values: 0 - 1000 (1 s).</value>
		/// <exception cref="ArgumentOutOfRangeException"></exception>
		/// <example>
		/// <code><![CDATA[
		/// opt.mouse.ClickSpeed = 30;
		/// ]]></code>
		/// </example>
		public int ClickSpeed {
			get => _f.ClickSpeed;
			set => _f.ClickSpeed = _Set(value, 1000);
		}
		
		/// <summary>
		/// If not 0, makes mouse movements slower, not instant.
		/// Default: 0.
		/// </summary>
		/// <value>Valid values: 0 (instant) - 10000 (slowest).</value>
		/// <exception cref="ArgumentOutOfRangeException"></exception>
		/// <remarks>
		/// Used by <see cref="mouse.move"/>, <see cref="mouse.click"/> and other functions that generate mouse movement events, except <see cref="mouse.moveBy(string, double)"/>.
		/// It is not milliseconds or some other unit. It adds intermediate mouse movements and small delays when moving the mouse cursor to the specified point. The speed also depends on the distance.
		/// Value 0 (default) does not add intermediate mouse movements. Adds at least 1 if some mouse buttons are pressed. Value 1 adds at least 1 intermediate mouse movement. Values 10-50 are good for visually slow movements.
		/// </remarks>
		/// <example>
		/// <code><![CDATA[
		/// opt.mouse.MoveSpeed = 30;
		/// ]]></code>
		/// </example>
		public int MoveSpeed {
			get => _f.MoveSpeed;
			set => _f.MoveSpeed = _Set(value, 10000);
		}
		
		/// <summary>
		/// How long to wait (milliseconds) before a "mouse click" or "mouse wheel" function returns.
		/// Default: 10.
		/// </summary>
		/// <value>Valid values: 0 - 10000 (10 s).</value>
		/// <exception cref="ArgumentOutOfRangeException"></exception>
		/// <remarks>
		/// The "click" functions also sleep <see cref="ClickSpeed"/> ms after button down and up. Default <c>ClickSpeed</c> is 20, default <c>ClickSleepFinally</c> is 10, therefore default click time without mouse-move is 20+20+10=50.
		/// </remarks>
		/// <example>
		/// <code><![CDATA[
		/// opt.mouse.ClickSpeedFinally = 30;
		/// ]]></code>
		/// </example>
		public int ClickSleepFinally {
			get => _f.ClickSleepFinally;
			set => _f.ClickSleepFinally = _Set(value, 10000);
		}
		
		/// <summary>
		/// How long to wait (milliseconds) after moving the mouse cursor. Used in "move+click" functions too.
		/// Default: 10.
		/// </summary>
		/// <value>Valid values: 0 - 1000 (1 s).</value>
		/// <exception cref="ArgumentOutOfRangeException"></exception>
		/// <remarks>
		/// Used by <see cref="mouse.move"/> (finally), <see cref="mouse.click"/> (between moving and clicking) and other functions that generate mouse movement events.
		/// </remarks>
		/// <example>
		/// <code><![CDATA[
		/// opt.mouse.MoveSpeedFinally = 30;
		/// ]]></code>
		/// </example>
		public int MoveSleepFinally {
			get => _f.MoveSleepFinally;
			set => _f.MoveSleepFinally = _Set(value, 1000);
		}
		
		/// <summary>
		/// Make some functions less strict (throw less exceptions etc).
		/// Default: <c>false</c>.
		/// </summary>
		/// <remarks>
		/// This option is used by these functions:
		/// - <see cref="mouse.move"/>, <see cref="mouse.click"/> and other functions that move the cursor (mouse pointer):\
		///   <c>false</c> - throw exception if cannot move the cursor to the specified x y. For example if the x y is not in screen.\
		///   <c>true</c> - try to move anyway. Don't throw exception, regardless of the final cursor position (which probably will be at a screen edge).
		/// - <see cref="mouse.move"/>, <see cref="mouse.click"/> and other functions that move the cursor (mouse pointer):\
		///   <c>false</c> - before moving the cursor, wait while a mouse button is pressed by the user or another thread. It prevents an unintended drag-drop.\
		///   <c>true</c> - do not wait.
		/// - <see cref="mouse.click"/> and other functions that click or press a mouse button using window coordinates:\
		///   <c>false</c> - don't allow to click in another window. If need, activate the specified window (or its top-level parent). If that does not help, throw exception. However if the window is a control, allow x y anywhere in its top-level parent window.\
		///   <c>true</c> - allow to click in another window. Don't activate the window and don't throw exception.
		/// </remarks>
		/// <example>
		/// <code><![CDATA[
		/// opt.mouse.Relaxed = true;
		/// ]]></code>
		/// </example>
		public bool Relaxed {
			get => _f.Relaxed;
			set => _f.Relaxed = value;
		}
		
		///
		public override string ToString() =>
			$"{{{string.Join(", ", GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance).Select(p => $"{p.Name} = {p.GetValue(this)}"))}}}";
	}
	
	/// <summary>
	/// Options for functions of class <see cref="keys"/>.
	/// Some options also are used with <see cref="clipboard"/> functions that send keys (<c>Ctrl+V</c> etc).
	/// </summary>
	/// <seealso cref="opt.key"/>
	/// <example>
	/// <code><![CDATA[
	/// opt.key.KeySpeed = 50;
	/// ]]></code>
	/// Set options for trigger actions.
	/// <code><![CDATA[
	/// Triggers.Options.BeforeAction = o => { opt.key.KeySpeed = 50; };
	/// ]]></code>
	/// </example>
	public sealed class OKey {
		int _threadId;
		static AsyncLocal<OKey> s_ambient = new();
		
		internal static OKey Ambient_ {
			get {
				var threadId = Environment.CurrentManagedThreadId;
				if (s_ambient.Value is { } v) {
					if (v._threadId != threadId) s_ambient.Value = v = new(v) { _threadId = threadId };
				} else {
					s_ambient.Value = v = new() { _threadId = threadId };
				}
				return v;
			}
			set { Debug.Assert(value?._threadId != 0); s_ambient.Value = value; } //used only to restore scope
		}
		
		internal static OKey Scope_(bool inherit) {
			var old = s_ambient.Value;
			s_ambient.Value = (old != null && inherit) ? new(old) { _threadId = Environment.CurrentManagedThreadId } : null; //lazy
			return old;
		}
		
		/// <summary>
		/// Initializes this instance with default values or values copied from another instance.
		/// </summary>
		/// <param name="cloneOptions">If not <c>null</c>, copies its options into this variable.</param>
		public OKey(OKey cloneOptions = null) {
			CopyOrDefault_(cloneOptions);
		}
		
		/// <summary>
		/// Copies options from <i>o</i>, or sets default if <c>o==null</c>. Like ctor does.
		/// </summary>
		internal void CopyOrDefault_(OKey o) { _f = o?._f ?? new(); }
		
		struct _Fields { //makes easier to init, reset or copy fields
			public _Fields() { }
			public int TextSpeed, KeySpeed = 2, KeySpeedClipboard = 5, SleepFinally = 10, PasteLength = 200, PasteSleep = 100/*, PasteRestoreAfter*/;
			public OKeyText TextHow = OKeyText.Characters;
			public bool TextShiftEnter, PasteWorkaround, RestoreClipboard = true, NoModOff, NoCapsOff, NoBlockInput;
			public Action<OKeyHookData> Hook;
		}
		_Fields _f;
		
		/// <summary>
		/// Returns this variable, or <c>OKey</c> cloned from this variable and possibly modified by <c>Hook</c>.
		/// </summary>
		/// <param name="wFocus">The focused or active window. Use <c>GetWndFocusedOrActive</c>.</param>
		internal OKey GetHookOptionsOrThis_(wnd wFocus) {
			var call = this.Hook;
			if (call == null || wFocus.Is0) return this;
			var R = new OKey(this);
			call(new OKeyHookData(R, wFocus));
			return R;
		}
		
		int _Set(int value, int max) {
			if ((uint)value > max) throw new ArgumentOutOfRangeException(null, "Max " + max);
			return value;
		}
		
		/// <summary>
		/// How long to wait (milliseconds) between pressing and releasing each character key. Used by <see cref="keys.sendt"/>. Also by <see cref="keys.send"/> and similar functions for <c>"!text"</c> arguments.
		/// Default: 0.
		/// </summary>
		/// <value>Valid values: 0 - 1000 (1 second).</value>
		/// <exception cref="ArgumentOutOfRangeException"></exception>
		/// <remarks>
		/// Used only for "text" arguments, not for "keys" arguments. See <see cref="KeySpeed"/>.
		/// </remarks>
		/// <example>
		/// <code><![CDATA[
		/// opt.key.TextSpeed = 50;
		/// ]]></code>
		/// </example>
		public int TextSpeed {
			get => _f.TextSpeed;
			set => _f.TextSpeed = _Set(value, 1000);
		}
		
		/// <summary>
		/// How long to wait (milliseconds) between pressing and releasing each key. Used by <see cref="keys.send"/> and similar functions, except for <c>"!text"</c> arguments.
		/// Default: 2.
		/// </summary>
		/// <value>Valid values: 0 - 1000 (1 second).</value>
		/// <exception cref="ArgumentOutOfRangeException"></exception>
		/// <remarks>
		/// Used only for "keys" arguments, not for "text" arguments. See <see cref="TextSpeed"/>.
		/// </remarks>
		/// <example>
		/// <code><![CDATA[
		/// opt.key.KeySpeed = 50;
		/// ]]></code>
		/// </example>
		public int KeySpeed {
			get => _f.KeySpeed;
			set => _f.KeySpeed = _Set(value, 1000);
		}
		
		/// <summary>
		/// How long to wait (milliseconds) between sending clipboard copy/paste keys. For example, when sending <c>Ctrl+V</c>, waits after <c>Ctrl</c>-down and after <c>V</c>-down.
		/// Default: 5.
		/// </summary>
		/// <value>Valid values: 0 - 1000 (1 second).</value>
		/// <exception cref="ArgumentOutOfRangeException"></exception>
		/// <remarks>
		/// With most apps these delays are not necessary. But with some apps/controls <c>Ctrl+V</c> etc may not work without a delay after <c>Ctrl</c>-down or/and after <c>V</c>-down.
		/// </remarks>
		/// <example>
		/// <code><![CDATA[
		/// opt.key.KeySpeedClipboard = 50;
		/// ]]></code>
		/// </example>
		public int KeySpeedClipboard {
			get => _f.KeySpeedClipboard;
			set => _f.KeySpeedClipboard = _Set(value, 1000);
		}
		
		/// <summary>
		/// How long to wait (milliseconds) before a "send keys or text" function returns.
		/// Default: 10.
		/// </summary>
		/// <value>Valid values: 0 - 10000 (10 seconds).</value>
		/// <exception cref="ArgumentOutOfRangeException"></exception>
		/// <remarks>
		/// Not used by <see cref="clipboard"/> class functions.
		/// </remarks>
		/// <example>
		/// <code><![CDATA[
		/// opt.key.SleepFinally = 50;
		/// ]]></code>
		/// </example>
		public int SleepFinally {
			get => _f.SleepFinally;
			set => _f.SleepFinally = _Set(value, 10000);
		}
		
		/// <summary>
		/// How to send text to the active window (keys, characters or clipboard).
		/// Default: <see cref="OKeyText.Characters"/>.
		/// </summary>
		/// <example>
		/// <code><![CDATA[
		/// opt.key.TextHow = OKeyText.Paste;
		/// ]]></code>
		/// </example>
		public OKeyText TextHow {
			get => _f.TextHow;
			set => _f.TextHow = value;
		}
		
		/// <summary>
		/// When sending text, instead of <c>Enter</c> send <c>Shift+Enter</c>.
		/// Default: false.
		/// </summary>
		/// <remarks>
		/// This option is applied when sending text with <see cref="keys.sendt"/> (like <c>keys.sendt("A\nB")</c>) or with operator <c>!</c> (like <c>keys.send("!A\nB")</c>) or with <see cref="keys.AddText(string, string)"/>. Ignored when using operator <c>^</c>, <c>_</c>, <see cref="keys.AddText(string, OKeyText)"/>, <see cref="keys.AddChar(char)"/>.
		/// </remarks>
		public bool TextShiftEnter {
			get => _f.TextShiftEnter;
			set => _f.TextShiftEnter = value;
		}
		
		/// <summary>
		/// To send text use clipboard (like with <see cref="OKeyText.Paste"/>) if text length is >= this value.
		/// Default: 200.
		/// </summary>
		/// <exception cref="ArgumentOutOfRangeException"></exception>
		/// <example>
		/// <code><![CDATA[
		/// opt.key.PasteLength = 50;
		/// ]]></code>
		/// </example>
		public int PasteLength {
			get => _f.PasteLength;
			set => _f.PasteLength = _Set(value, int.MaxValue);
		}
		
		/// <summary>
		/// When pasting text that ends with space, tab or/and newline characters, remove them and after pasting send them as keys.
		/// Default: <c>false</c>.
		/// </summary>
		/// <remarks>
		/// Some apps trim these characters when pasting.
		/// </remarks>
		/// <example>
		/// <code><![CDATA[
		/// opt.key.PasteWorkaround = true;
		/// ]]></code>
		/// </example>
		public bool PasteWorkaround {
			get => _f.PasteWorkaround;
			set => _f.PasteWorkaround = value;
		}
		
		//rejected: rarely used. Eg can be useful for Python programmers. Let call clipboard.paste() explicitly or set the Paste option eg in hook.
		///// <summary>
		///// To send text use <see cref="OKeyText.Paste"/> if text contains characters <c>'\n'</c> followed by <c>'\t'</c> (tab) or spaces.
		///// </summary>
		///// <remarks>
		///// Some apps auto-indent. This option is a workaround.
		///// </remarks>
		//public bool PasteMultilineIndented { get; set; }
		
		/// <summary>
		/// Whether to restore clipboard data when copying or pasting text.
		/// Default: <c>true</c>.
		/// By default restores only text. See also <see cref="RestoreClipboardAllFormats"/>, <see cref="RestoreClipboardExceptFormats"/>.
		/// </summary>
		/// <example>
		/// <code><![CDATA[
		/// opt.key.RestoreClipboard = true;
		/// ]]></code>
		/// </example>
		/// <example>
		/// <code><![CDATA[
		/// opt.key.RestoreClipboard = false;
		/// ]]></code>
		/// </example>
		public bool RestoreClipboard {
			get => _f.RestoreClipboard;
			set => _f.RestoreClipboard = value;
		}
		
		/// <summary>
		/// How long to wait (milliseconds) after pasting (before restoring clipboard data, if need).
		/// Default: 100.
		/// </summary>
		/// <value>Valid values: 0 - 10000 (10 seconds).</value>
		/// <exception cref="ArgumentOutOfRangeException"></exception>
		/// <remarks>
		/// This is the minimal wait time. Actually may wait longer; it depends on how the active window responds.
		/// </remarks>
		public int PasteSleep {
			get => _f.PasteSleep;
			set => _f.PasteSleep = _Set(value, 10000);
		}
		
		//CONSIDER
		///// <summary>
		///// After pasting (<see cref="clipboard.paste"/> etc), if <see cref="RestoreClipboard"/> <c>true</c>, restore clipboard data later (asynchronously) after this delay (milliseconds).
		///// Default: 0.
		///// </summary>
		///// <value>Valid values: 0 - 10000 (10 seconds).</value>
		///// <exception cref="ArgumentOutOfRangeException"></exception>
		//public int PasteRestoreAfter {
		//	get => _f.PasteRestoreAfter;
		//	set => _f.PasteRestoreAfter = _Set(value, 10000);
		//}
		
		#region static RestoreClipboard options
		
		/// <summary>
		/// When copying or pasting text, restore clipboard data of all formats that are possible to restore.
		/// Default: <c>false</c> - restore only text.
		/// </summary>
		/// <remarks>
		/// Restoring data of all formats set by some apps can be slow or cause problems. More info: <see cref="RestoreClipboardExceptFormats"/>.
		/// 
		/// This property is static, not thread-static. It should be set (if need) at the start of script and not changed later.
		/// </remarks>
		/// <seealso cref="RestoreClipboard"/>
		/// <seealso cref="RestoreClipboardExceptFormats"/>
		/// <example>
		/// <code><![CDATA[
		/// OKey.RestoreClipboardAllFormats = true;
		/// ]]></code>
		/// </example>
		public static bool RestoreClipboardAllFormats { get; set; }
		
		/// <summary>
		/// When copying or pasting text, and <see cref="RestoreClipboardAllFormats"/> is <c>true</c>, do not restore clipboard data of these formats.
		/// Default: <c>null</c>.
		/// </summary>
		/// <remarks>
		/// To restore clipboard data, the copy/paste functions at first get clipboard data. Getting data of some formats set by some apps can be slow (100 ms or more) or cause problems (the app can change something in its window or even show a dialog).
		/// It also depends on whether this is the first time the data is being retrieved. The app can render data on demand, when some app is retrieving it from the clipboard first time; then can be slow etc.
		/// 
		/// You can use function <see cref="PrintClipboard"/> to see format names and get-data times.
		/// 
		/// There are several kinds of clipboard formats - registered, standard, private and display. Only registered formats have string names. For standard formats use API constant names, like <c>"CF_WAVE"</c>. Private, display and metafile formats are never restored.
		/// These formats are never restored: <c>CF_METAFILEPICT</c>, <c>CF_ENHMETAFILE</c>, <c>CF_PALETTE</c>, <c>CF_OWNERDISPLAY</c>, <c>CF_DSPx</c> formats, <c>CF_GDIOBJx</c> formats, <c>CF_PRIVATEx</c> formats. Some other formats too, but they are automatically synthesized from other formats if need. Also does not restore if data size is 0 or > 10 MB.
		/// 
		/// This property is static, not thread-static. It should be set (if need) at the start of script and not changed later.
		/// </remarks>
		/// <seealso cref="RestoreClipboard"/>
		/// <seealso cref="PrintClipboard"/>
		/// <example>
		/// <code><![CDATA[
		/// OKey.RestoreClipboardExceptFormats = ["CF_UNICODETEXT", "HTML Format"];
		/// ]]></code>
		/// </example>
		public static string[] RestoreClipboardExceptFormats { get; set; }
		
		/// <summary>
		/// Writes to the output some info about current clipboard data.
		/// </summary>
		/// <remarks>
		/// Shows this info for each clipboard format: format name, time spent to get data (microseconds), data size (bytes), and whether this format would be restored (depends on <see cref="RestoreClipboardExceptFormats"/>).
		/// <note>Copy something to the clipboard each time before calling this function. Don't use <see cref="clipboard.copy"/> and don't call this function in loop. Else it shows small times.</note>
		/// The time depends on app, etc. More info: <see cref="RestoreClipboardExceptFormats"/>.
		/// </remarks>
		/// <example>
		/// <code><![CDATA[
		/// OKey.PrintClipboard();
		/// ]]></code>
		/// </example>
		public static void PrintClipboard() => clipboard.PrintClipboard_();
		
		#endregion
		
		/// <summary>
		/// When starting to send keys or text, don't release modifier keys.
		/// Default: <c>false</c>.
		/// </summary>
		/// <example>
		/// <code><![CDATA[
		/// opt.key.NoModOff = true;
		/// ]]></code>
		/// </example>
		public bool NoModOff {
			get => _f.NoModOff;
			set => _f.NoModOff = value;
		}
		
		/// <summary>
		/// When starting to send keys or text, don't turn off <c>CapsLock</c>.
		/// Default: <c>false</c>.
		/// </summary>
		/// <example>
		/// <code><![CDATA[
		/// opt.key.NoCapsOff = true;
		/// ]]></code>
		/// </example>
		public bool NoCapsOff {
			get => _f.NoCapsOff;
			set => _f.NoCapsOff = value;
		}
		
		/// <summary>
		/// While sending or pasting keys or text, don't block user-pressed keys.
		/// Default: <c>false</c>.
		/// </summary>
		/// <remarks>
		/// If <c>false</c> (default), user-pressed keys are sent afterwards. If <c>true</c>, user-pressed keys can be mixed with script-pressed keys, which is particularly dangerous when modifier keys are mixed (and combined) with non-modifier keys.
		/// </remarks>
		/// <example>
		/// <code><![CDATA[
		/// opt.key.NoBlockInput = true;
		/// ]]></code>
		/// </example>
		public bool NoBlockInput {
			get => _f.NoBlockInput;
			set => _f.NoBlockInput = value;
		}
		
		/// <summary>
		/// Callback function that can modify options of "send keys or text" functions depending on active window etc.
		/// Default: <c>null</c>.
		/// </summary>
		/// <remarks>
		/// The callback function is called by <see cref="keys.send"/>, <see cref="keys.sendt"/>, <see cref="keys.SendNow"/>, <see cref="clipboard.paste"/> and similar functions. Not called by <see cref="clipboard.copy"/>.
		/// </remarks>
		/// <seealso cref="OKeyHookData"/>
		/// <example>
		/// <code><![CDATA[
		/// opt.key.Hook = k => {
		/// 	print.it(k.w);
		/// 	var w = k.w.Window; //if k.w is a control, get its top-level window
		/// 	var name = w.Name;
		/// 	if (name.Like("* Slow App")) {
		/// 		k.optk.KeySpeed = 50;
		/// 		k.optk.TextSpeed = 50;
		/// 	}
		/// };
		/// 
		/// for (int i = 0; i < 10; i++) {
		/// 	1.s();
		/// 	keys.send("Home");
		/// }
		/// ]]></code>
		/// </example>
		public Action<OKeyHookData> Hook {
			get => _f.Hook;
			set => _f.Hook = value;
		}
		
		///
		public override string ToString() =>
			$"{{{string.Join(", ", GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance).Select(p => $"{p.Name} = {p.GetValue(this)}"))}}}";
	}
	
	/// <summary>
	/// Parameter type of the <see cref="OKey.Hook"/> callback function.
	/// </summary>
	public struct OKeyHookData {
		internal OKeyHookData(OKey optk, wnd w) { this.optk = optk; this.w = w; }
		
		/// <summary>
		/// Options used by the "send keys or text" function. The callback function can modify them, except <c>Hook</c>, <c>NoModOff</c>, <c>NoCapsOff</c>, <c>NoBlockInput</c>.
		/// </summary>
		public readonly OKey optk;
		
		/// <summary>
		/// The focused control. If there is no focused control - the active window. Use <c>w.Window</c> to get top-level window; if <c>w.Window == w</c>, <c>w</c> is the active window, else the focused control. The callback function is not called if there is no active window.
		/// </summary>
		public readonly wnd w;
	}
	
	/// <summary>
	/// How functions send text.
	/// See <see cref="OKey.TextHow"/>.
	/// </summary>
	/// <remarks>
	/// There are three ways to send text to the active app using keys:
	/// - Characters (default) - use special key code <ms>VK_PACKET</ms>. Can send most characters.
	/// - Keys - use virtual-key codes, with <c>Shift</c> etc where need. Can send only characters that can be simply entered with the keyboard using current keyboard layout.
	/// - Paste - use the clipboard and <c>Ctrl+V</c>. Can send any text.
	/// 
	/// Most but not all apps support all three ways.
	/// </remarks>
	public enum OKeyText {
		/// <summary>
		/// Send most text characters using special key code <ms>VK_PACKET</ms>.
		/// This option is default. Few apps don't support it.
		/// For newlines, tab and space sends keys (<c>Enter</c>, <c>Tab</c>, <c>Space</c>), because <c>VK_PACKET</c> often does not work well.
		/// If text contains Unicode characters with Unicode code above 0xffff, clipboard-pastes whole text, because many apps don't support Unicode surrogates sent as <c>WM_PACKET</c> pairs.
		/// </summary>
		Characters,
		//Tested many apps/controls/frameworks. Works almost everywhere.
		//Does not work with Pidgin (GTK), but works eg with Inkscape (GTK too).
		//I guess does not work with many games.
		//In PhraseExpress this is default. Its alternative methods are SendKeys (does not send Unicode chars) and clipboard. It uses clipboard if text is long, default 100. Allows to choose different for specified apps. Does not add any delays between chars; for some apps too fast, eg VirtualBox edit fields when text contains Unicode surrogates.
		
		/// <summary>
		/// Send virtual-key codes, with <c>Shift</c> etc where need.
		/// All apps support it.
		/// If a character cannot be simply typed with the keyboard using current keyboard layout, sends it like with the <c>Characters</c> option.
		/// </summary>
		KeysOrChar,
		
		/// <summary>
		/// Send virtual-key codes, with <c>Shift</c> etc where need.
		/// All apps support it.
		/// If text contains characters that cannot be simply typed with the keyboard using current keyboard layout, clipboard-pastes whole text.
		/// </summary>
		KeysOrPaste,
		
		/// <summary>
		/// Paste text using the clipboard and <c>Ctrl+V</c>.
		/// Few apps don't support it.
		/// This option is recommended for long text, because other ways then are too slow.
		/// Other options are unreliable when text length is more than 4000 and the target app is too slow to process sent characters. Then <see cref="OKey.TextSpeed"/> can help.
		/// Also, other options are unreliable when the target app modifies typed text, for example has such features as auto-complete, auto-indent or auto-correct. However some apps modify even pasted text, for example trim the last newline or space.
		/// When pasting text, previous clipboard data of some formats is lost. Text is restored by default.
		/// </summary>
		Paste,
		
		//rejected: WmPaste. Few windows support it.
		//rejected: WM_CHAR. It isn't sync with keyboard/mouse input. It has sense only if window specified (send to inactive window). Maybe will add a function in the future.
	}
	
	/// <summary>
	/// Options for run-time warnings (<see cref="print.warning"/>).
	/// </summary>
	/// <example>
	/// <code><![CDATA[
	/// opt.warnings.Verbose = false;
	/// ]]></code>
	/// </example>
	public sealed class OWarnings {
		int _threadId;
		static AsyncLocal<OWarnings> s_ambient = new();
		
		internal static OWarnings Ambient_ {
			get {
				var threadId = Environment.CurrentManagedThreadId;
				if (s_ambient.Value is { } v) {
					if (v._threadId != threadId) s_ambient.Value = v = new(v) { _threadId = threadId };
				} else {
					s_ambient.Value = v = new() { _threadId = threadId };
				}
				return v;
			}
			set { Debug.Assert(value?._threadId != 0); s_ambient.Value = value; } //used only to restore scope
		}
		
		internal static OWarnings Scope_(bool inherit) {
			var old = s_ambient.Value;
			s_ambient.Value = (old != null && inherit) ? new(old) { _threadId = Environment.CurrentManagedThreadId } : null; //lazy
			return old;
		}
		
		bool? _verbose;
		List<string> _disabledWarnings;
		
		/// <summary>
		/// Initializes this instance with default values or values copied from another instance.
		/// </summary>
		/// <param name="other">If not <c>null</c>, copies its options into this variable.</param>
		internal OWarnings(OWarnings other = null) {
			if (other != null) {
				_verbose = other._verbose;
				_disabledWarnings = other._disabledWarnings == null ? null : new(other._disabledWarnings);
			}
		}
		
		/// <summary>
		/// If <c>true</c>, some library functions may display more warnings and other info.
		/// </summary>
		/// <remarks>
		/// If not explicitly set, the default value depends on the build configuration of the main assembly: <c>true</c> if Debug, <c>false</c> if Release (<c>optimize true</c>).
		/// </remarks>
		/// <example>
		/// <code><![CDATA[
		/// opt.warnings.Verbose = false;
		/// ]]></code>
		/// </example>
		public bool Verbose {
			get => (_verbose ??= script.isDebug) == true;
			set => _verbose = value;
		}
		
		/// <summary>
		/// Disables one or more run-time warnings.
		/// </summary>
		/// <param name="warningsWild">One or more warnings as case-insensitive wildcard strings. See <see cref="ExtString.Like(string, string, bool)"/>.</param>
		/// <remarks>
		/// Adds the strings to an internal list. When <see cref="print.warning"/> is called, it looks in the list. If finds the warning in the list, does not show the warning.
		/// It's easy to auto-restore warnings with <c>using</c>, like in the second example. Restoring is optional.
		/// </remarks>
		/// <example>
		/// <code><![CDATA[
		/// opt.warnings.Disable("*part of warning 1 text*", "*part of warning 2 text*");
		/// ]]></code>
		/// Temporarily disable all warnings.
		/// <code><![CDATA[
		/// opt.warnings.Verbose = true;
		/// print.warning("one");
		/// using(opt.warnings.Disable("*")) {
		/// 	print.warning("two");
		/// }
		/// print.warning("three");
		/// ]]></code>
		/// </example>
		public UsingEndAction Disable(params string[] warningsWild) {
			_disabledWarnings ??= new List<string>();
			int restoreCount = _disabledWarnings.Count;
			_disabledWarnings.AddRange(warningsWild);
			return new UsingEndAction(() => _disabledWarnings.RemoveRange(restoreCount, _disabledWarnings.Count - restoreCount));
		}
		
		/// <summary>
		/// Returns <c>true</c> if the specified warning text matches a wildcard string added with <see cref="Disable"/>.
		/// </summary>
		/// <param name="text">Warning text. Case-insensitive.</param>
		public bool IsDisabled(string text) {
			string s = text ?? "";
			if (_disabledWarnings is { } a) foreach (var k in a) if (s.Like(k, true)) return true;
			return false;
		}
	}
	
	/// <summary>
	/// Obsolete. Use <see cref="Seconds"/> instead. Some wait functions may still use some <c>OWait</c> properties for backward compatibility.
	/// </summary>
	[EditorBrowsable(EditorBrowsableState.Never)]
	public sealed class OWait {
		int _threadId;
		static AsyncLocal<OWait> s_ambient = new();
		
		internal static OWait Ambient_ {
			get {
				var threadId = Environment.CurrentManagedThreadId;
				if (s_ambient.Value is { } v) {
					if (v._threadId != threadId) s_ambient.Value = v = new(v) { _threadId = threadId };
				} else {
					s_ambient.Value = v = new() { _threadId = threadId };
				}
				return v;
			}
			set { Debug.Assert(value?._threadId != 0); s_ambient.Value = value; } //used only to restore scope
		}
		
		internal static OWait Scope_(bool inherit) {
			var old = s_ambient.Value;
			s_ambient.Value = (old != null && inherit) ? new(old) { _threadId = Environment.CurrentManagedThreadId } : null; //lazy
			return old;
		}
		
		internal OWait() { _period = 10; }
		
		internal OWait(OWait other) { _doEvents = other._doEvents; _period = other._period; }
		
		/// <summary>
		/// Obsolete. Use <see cref="Seconds"/> instead.
		/// </summary>
		public OWait(int? period = null, bool? doEvents = null) {
			_doEvents = doEvents ?? opt.wait._doEvents;
			_period = period ?? opt.wait._period;
		}
		
		/// <summary>
		/// Obsolete. Use <see cref="Seconds"/> instead.
		/// </summary>
		public bool DoEvents {
			get => _doEvents;
			set => _doEvents = value;
		}
		bool _doEvents;
		
		/// <summary>
		/// Obsolete. Used only by obsolete/hidden wait functions. Use <see cref="Seconds"/> instead.
		/// </summary>
		public int Period {
			get => _period;
			set => _period = value;
		}
		int _period;
	}
}


================================================
FILE: Au/Other/print.cs
================================================
using COL = System.Collections;

namespace Au;

/// <summary>
/// Writes text to the output window, console, log file or custom writer.
/// </summary>
[DebuggerStepThrough]
public static partial class print {
	/// <summary>
	/// Returns <c>true</c> if this process is attached to a console.
	/// </summary>
	public static bool isConsoleProcess => Api.GetConsoleOutputCP() != 0; //fast
	
	//public static bool isConsoleProcess => Api.GetStdHandle(Api.STD_INPUT_HANDLE) is not (0 or -1); //no, may be true even if not attached to a console, eg if this non-console program started from cmd/bat on Win7
	
	/// <summary>
	/// Returns <c>true</c> if is writing to console, <c>false</c> if to the output window etc.
	/// </summary>
	/// <remarks>
	/// Does not write to console in these cases:
	/// - <see cref="isConsoleProcess"/> is <c>false</c>.
	/// - <see cref="ignoreConsole"/> is <c>true</c>.
	/// - <see cref="logFile"/> is not <c>null</c>.
	/// - The startup info of this process tells to not show console window and to not redirect the standard output.
	/// </remarks>
	public static bool isWritingToConsole {
		get {
			if (!isConsoleProcess || ignoreConsole || logFile != null) return false;
			if (!_isVisibleConsole.HasValue) {
				Api.GetStartupInfo(out var x);
				_isVisibleConsole = x.hStdOutput != default || 0 == (x.dwFlags & 1) || 0 != x.wShowWindow; //redirected stdout, or visible console window
			}
			return _isVisibleConsole.Value;
		}
	}
	static bool? _isVisibleConsole;
	
	/// <summary>
	/// If <c>true</c>, in console process will not use the console window. Then everything is like in non-console process.
	/// </summary>
	/// <seealso cref="redirectConsoleOutput"/>
	/// <seealso cref="redirectDebugOutput"/>
	public static bool ignoreConsole { get; set; }
	
	/// <summary>
	/// Clears the output window or console text (if <see cref="isWritingToConsole"/>) or log file (if <see cref="logFile"/> not <c>null</c>).
	/// </summary>
	public static void clear() {
		if (logFile != null) {
			_ClearToLogFile();
		} else if (isWritingToConsole) {
			_ConsoleAction(PrintServerMessageType.Clear);
		} else if (qm2.use) {
			qm2.clear();
		} else {
			_ServerAction(PrintServerMessageType.Clear);
		}
	}
	
	/// <summary>
	/// Scrolls the output window or console to the top.
	/// </summary>
	public static void scrollToTop() {
		if (logFile != null) {
		} else if (isWritingToConsole) {
			_ConsoleAction(PrintServerMessageType.ScrollToTop);
		} else if (qm2.use) {
		} else {
			_ServerAction(PrintServerMessageType.ScrollToTop);
		}
	}
	
	[MethodImpl(MethodImplOptions.NoInlining)] //avoid loading System.Console.dll
	static void _ConsoleAction(PrintServerMessageType action) {
		try {
			switch (action) {
			case PrintServerMessageType.Clear:
				//exception if redirected, it is documented.
				//if (!Console.IsOutputRedirected) Console.Clear(); //no, Clear does something more than if(IsOutputRedirected)
				Console.Clear();
				break;
			case PrintServerMessageType.ScrollToTop:
				Console.SetCursorPosition(0, 0);
				break;
			}
		}
		catch { }
	}
	
	/// <summary>
	/// Writes string to the output.
	/// </summary>
	/// <remarks>
	/// Appends newline (<c>"\r\n"</c>), unless text is like <c>"&lt;&gt;text&lt;nonl&gt;"</c>.
	/// 
	/// Can display links, colors, images, etc. More info: [](xref:output_tags).
	/// 
	/// Where the text goes:
	/// - If redirected, to wherever it is redirected. See <see cref="writer"/>.
	/// - Else if using log file (<see cref="logFile"/> not <c>null</c>), writes to the file.
	/// - Else if using console (<see cref="isWritingToConsole"/> returns <c>true</c>), writes to console.
	/// - Else if using local <see cref="PrintServer"/> (in this process), writes to it.
	/// - Else if exists global <see cref="PrintServer"/> (in any process), writes to it.
	/// - Else nowhere.
	/// </remarks>
	public static void it(string value) {
		writer.WriteLine(value);
	}
	
	/// <summary>
	/// Writes value of any type to the output.
	/// </summary>
	/// <param name="value">Value of any type. If <c>null</c>, writes <c>"null"</c>.</param>
	/// <remarks>
	/// If the type is unsigned integer (<c>uint</c>, <c>ulong</c>, <c>ushort</c>, <c>byte</c>, <c>nuint</c>), writes in hexadecimal format with prefix <c>"0x"</c>, unless <see cref="noHex"/> <c>true</c>.
	/// 
	/// This overload is used for all types except: strings, arrays, generic collections. They have own overloads; to use this function need to cast to object.
	/// For <see cref="Span{T}"/> and other ref struct types use <c>print.it(x.ToString());</c>.
	/// </remarks>
	public static void it(object value) {
		it(util.toString(value));
	}
	
	/// <summary>
	/// Writes interpolated string to the output.
	/// </summary>
	/// <param name="value">Interpolated string. Can contain <c>:print</c> format like in the example, to display the value like <see cref="it(object)"/>.</param>
	/// <example>
	/// <code><![CDATA[
	/// int[] a = { 1, 2, 3 };
	/// print.it($"a: {a}"); //a: System.Int32[]
	/// print.it($"a: {a:print}"); //a: { 1, 2, 3 }
	/// ]]></code>
	/// </example>
	public static void it(InterpolatedString value) {
		writer.WriteLine(value.GetFormattedText());
	}
	
	/// <summary>
	/// Writes an array or generic collection to the output.
	/// </summary>
	/// <param name="value">
	/// Array or generic collection of any type.
	/// If <c>null</c>, writes <c>"null"</c>.
	/// The format depends on type:
	/// <br/>• <c>char[]</c> - like string.
	/// <br/>• <c>byte[]</c> - like <c>xx-xx-xx</c>; in hexadecimal, unless <see cref="noHex"/> <c>true</c>.
	/// <br/>• Other - multiple lines.
	/// </param>
	public static void it<T>(IEnumerable<T> value) {
		if (value is char[] or byte[]) print.it(util.toString(value));
		else list("\r\n", value);
	}
	
	/// <summary>
	/// Writes an array or generic collection to the output, as a list of items separated by <i>separator</i>.
	/// </summary>
	/// <param name="value">Array or generic collection of any type. If <c>null</c>, writes <c>"null"</c>.</param>
	public static void list<T>(string separator, IEnumerable<T> value) {
		string s = "null";
		if (value != null)
			using (new StringBuilder_(out var b)) {
				bool once = false;
				foreach (var v in value) {
					if (!once) once = true; else b.Append(separator);
					util.toString(b, v, compact: true);
				}
				s = b.ToString();
			}
		print.it(s);
	}
	
	/// <summary>
	/// Writes multiple arguments of any type to the output, using separator <c>", "</c>.
	/// </summary>
	/// <remarks>
	/// If a value is <c>null</c>, writes <c>"null"</c>.
	/// If a value is unsigned integer (<c>uint</c>, <c>ulong</c>, <c>ushort</c>, <c>byte</c>, <c>nuint</c>), writes in hexadecimal format with prefix <c>"0x"</c>.
	/// </remarks>
	public static void it(object value1, object value2, params object[] more) {
		it(util.toList(", ", value1, value2, more));
	}
	
	/// <summary>
	/// Writes multiple arguments of any type to the output, using <i>separator</i>.
	/// </summary>
	/// <inheritdoc cref="it(object, object, object[])"/>
	public static void list(string separator, object value1, object value2, params object[] more) {
		it(util.toList(separator, value1, value2, more));
	}
	
	/// <summary>
	/// Writes binary data to the output, formatted like in a hex editor.
	/// </summary>
	/// <param name="value"></param>
	/// <param name="columns">The number of bytes in a row.</param>
	public static void it(RByte value, int columns) {
		it(util.toString(value, columns));
	}
	
	/// <summary>
	/// Gets or sets object that actually writes text when is called <see cref="it"/>.
	/// </summary>
	/// <remarks>
	/// If you want to redirect or modify or just monitor output text, use code like in the example. It is known as "output redirection".
	/// Redirection is applied to whole process, not just this thread.
	/// Redirection affects <see cref="it"/>, <see cref="redirectConsoleOutput"/> and <see cref="redirectDebugOutput"/>. It does not affect <see cref="directly"/> and <see cref="clear"/>.
	/// Don't call <see cref="it"/> in method <c>WriteLine</c> of your writer class. It would call itself and create stack overflow. Call <see cref="directly"/>, like in the example.
	/// </remarks>
	/// <example>
	/// <code><![CDATA[
	/// print.writer = new OutputWriterWithTime();
	/// 
	/// print.it("test");
	/// 
	/// class OutputWriterWithTime :TextWriter {
	/// 	public override void WriteLine(string value) { print.directly(DateTime.Now.ToString("T") + ".  " + value); }
	/// 	public override Encoding Encoding => Encoding.Unicode;
	/// }
	/// ]]></code>
	/// </example>
	public static TextWriter writer { get; set; } = new _OutputWriter();
	
	/// <summary>
	/// Our default writer class for the Writer property.
	/// </summary>
	class _OutputWriter : LineWriter_ {
		public override Encoding Encoding => Encoding.Unicode;
		
		protected override void WriteLineNow(string s) => directly(s);
	}
	
	/// <summary>
	/// Same as <see cref="it"/>, but does not pass the string to <see cref="writer"/>.
	/// </summary>
	[MethodImpl(MethodImplOptions.NoInlining)] //for stack trace, used in _WriteToServer
	public static void directly(string value) {
		value ??= "";
		//qm2.write($"'{value}'");
		if (logFile != null) _WriteToLogFile(value);
		else if (isWritingToConsole) _ConsoleWriteLine(value);
		else if (qm2.use) qm2.write(value);
		else _ServerWrite(value);
	}
	
	[MethodImpl(MethodImplOptions.NoInlining)] //avoid loading System.Console.dll
	static void _ConsoleWriteLine(string value) => Console.WriteLine(value);
	
	/// <summary>
	/// Writes a warning text to the output.
	/// By default appends the stack trace.
	/// </summary>
	/// <param name="text">Warning text.</param>
	/// <param name="showStackFromThisFrame">If >= 0, appends the stack trace, skipping this number of frames. Default 0. Does not append if <i>text</i> looks like a stack trace.</param>
	/// <param name="prefix">Text before <i>text</i>. Default <c>"&lt;&gt;Warning: "</c>.</param>
	/// <remarks>
	/// Calls <see cref="print.it"/>.
	/// Does not show more than 1 warning/second, unless <c>opt.warnings.Verbose == true</c> (see <see cref="OWarnings.Verbose"/>).
	/// To disable some warnings, use code <c>opt.warnings.Disable("warning text wildcard");</c> (see <see cref="OWarnings.Disable"/>).
	/// </remarks>
	/// <seealso cref="OWarnings"/>
	[MethodImpl(MethodImplOptions.NoInlining)]
	public static void warning(string text, int showStackFromThisFrame = 0, string prefix = "<>Warning: ") {
		if (opt.warnings.IsDisabled(text)) return;
		
		if (!opt.warnings.Verbose) {
			var t = Api.GetTickCount64();
			if (t - s_warningTime < 1000) return;
			s_warningTime = t;
		}
		
		string s = text ?? "";
		if (showStackFromThisFrame >= 0 && !(s.Contains("\n   at ") && s.RxIsMatch(@"Exception: .*\R   at "))) { //include stack unless text contains stack
			var x = new StackTrace(showStackFromThisFrame + 1, true);
			var st = x.ToString(); var rn = st.Ends('\n') ? "" : "\r\n";
			s = $"{prefix}{s} <fold><\a>\r\n{st}{rn}</\a></fold>";
		} else s = prefix + s;
		
		it(s);
	}
	static long s_warningTime;
	
	/// <summary>
	/// Writes an exception warning to the output.
	/// </summary>
	/// <inheritdoc cref="warning(string, int, string)"/>
	[MethodImpl(MethodImplOptions.NoInlining)]
	public static void warning(Exception e, string prefix = "<>Warning: ") {
		warning(e.ToString(), -1, prefix);
	}
	
	/// <summary>
	/// Let <c>Console.WriteX</c> methods in non-console process write to the same destination as <see cref="it"/>.
	/// </summary>
	/// <remarks>
	/// The default value is <c>true</c> in non-console scripts that use class <see cref="Console"/> and have role <c>miniProgram</c> (default); also <c>exeProgram</c> if started from the script editor. Also in these scripts <c>Console.ReadLine</c> uses <see cref="dialog.showInput"/>.
	/// 
	/// If <c>Console.Write</c> text does not end with <c>'\n'</c> character, it is buffered and not displayed until called again with text ending with <c>'\n'</c> character or until called <c>Console.WriteLine</c>.
	/// 
	/// <c>Console.Clear</c> will not clear output; it will throw exception.
	/// </remarks>
	public static bool redirectConsoleOutput {
		set {
			if (value) {
				if (_prevConsoleOut != null || isConsoleProcess) return;
				_prevConsoleOut = Console.Out;
				Console.SetOut(writer);
			} else if (_prevConsoleOut != null) {
				Console.SetOut(_prevConsoleOut);
				_prevConsoleOut = null;
			}
		}
		get => _prevConsoleOut != null;
	}
	static TextWriter _prevConsoleOut;
	//note: don't call this before AllocConsole. Then can't restore, and IsOutputRedirected always returns true.
	
	/// <summary>
	/// Let <see cref="Debug.Write"/>, <see cref="Trace.Write"/> and similar methods also write to the same destination as <see cref="it"/>.
	/// </summary>
	/// <remarks>
	/// Does not replace existing <c>Debug.Write</c> etc destinations, just add new destination.
	/// 
	/// If <c>Debug.Write</c> etc argument text does not end with <c>'\n'</c> character, it is buffered and not displayed until called again with text ending with <c>'\n'</c> character or until called <c>Debug.WriteLine</c> etc.
	/// 
	/// Tip: To write to the output window even in console process, set <c>print.ignoreConsole=true;</c> before calling this method first time.
	/// </remarks>
	public static bool redirectDebugOutput {
		set {
			if (value) {
				if (_traceListener != null) return;
				//Trace.Listeners.Add(IsWritingToConsole ? (new ConsoleTraceListener()) : (new TextWriterTraceListener(Writer)));
				Trace.Listeners.Add(_traceListener = new TextWriterTraceListener(writer));
				//speed: 5000
			} else if (_traceListener != null) {
				Trace.Listeners.Remove(_traceListener);
				_traceListener = null;
			}
		}
		get => _traceListener != null;
	}
	static TextWriterTraceListener _traceListener;
	
	/// <summary>
	/// Sets log file path.
	/// When set (not <c>null</c>), text passed to <see cref="it"/> will be written to the file.
	/// If value is <c>null</c> - restores default behavior.
	/// </summary>
	/// <remarks>
	/// The first <see cref="it"/> etc call (in this process) creates or opens the file and deletes old content if the file already exists.
	/// 
	/// Also supports mailslots. Use mailslot name, as documented in <ms>CreateMailslot</ms>. Multiple processes can use the same mailslot.
	/// </remarks>
	/// <exception cref="ArgumentException">The <c>set</c> function throws this exception if the value is not full path and not <c>null</c>.</exception>
	public static string logFile {
		get => _logFile;
		set {
			lock (_lockObj1) {
				if (_hFile != null) {
					_hFile.Close();
					_hFile = null;
				}
				if (value != null) {
					_logFile = pathname.normalize(value);
				} else _logFile = null;
			}
		}
		
	}
	static string _logFile;
	static _LogFile _hFile;
	static readonly object _lockObj1 = new();
	
	/// <summary>
	/// If <c>true</c>, will add current local time when using log file (see <see cref="logFile"/>).
	/// </summary>
	public static bool logFileTimestamp { get; set; }
	
	static void _WriteToLogFile(string s) {
		lock (_lockObj1) {
			if (_hFile == null) {
				g1:
				_hFile = _LogFile.Open();
				if (_hFile == null) {
					var e = lastError.code;
					if (e == Api.ERROR_SHARING_VIOLATION) {
						var u = pathname.makeUnique(_logFile, false);
						if (u != _logFile) { _logFile = u; goto g1; }
					}
					var logf = _logFile;
					_logFile = null;
					print.warning($"Failed to create or open log file '{logf}'. {lastError.messageFor(e)}");
					directly(s);
					return;
				}
			}
			_hFile.WriteLine(s);
		}
	}
	
	static void _ClearToLogFile() {
		lock (_lockObj1) {
			if (_hFile == null) {
				try { filesystem.delete(_logFile); } catch { }
			} else {
				_hFile.Clear();
			}
		}
	}
	
	unsafe class _LogFile {
		//info: We don't use StreamWriter. It creates more problems than would make easier.
		//	Eg its finalizer does not write to file. If we try to Close it in our finalizer, it throws 'already disposed'.
		//	Also we don't need such buffering. Better to write to the OS file buffer immediately, it's quite fast.
		
		Handle_ _h;
		string _name;
		
		/// <summary>
		/// Opens <c>logFile</c> file handle for writing.
		/// Uses <c>CREATE_ALWAYS</c>, <c>GENERIC_WRITE</c>, <c>FILE_SHARE_READ</c>.
		/// </summary>
		public static _LogFile Open() {
			var path = logFile;
			var h = CreateFile_(path, false);
			if (h.Is0) return null;
			return new _LogFile() { _h = h, _name = path };
		}
		
		/// <summary>
		/// Writes <c>s + "\r\n"</c> and optionally timestamp.
		/// </summary>
		/// <remarks>
		/// If fails to write to file: Sets <c>logFile</c>=<c>null</c>, which closes file handle. Writes a warning and <i>s</i> to the output window or console.
		/// </remarks>
		[SkipLocalsInit]
		public bool WriteLine(string s) {
			bool ok;
			int n = Encoding.UTF8.GetByteCount(s ??= "") + 1;
			using FastBuffer<byte> b = new(n + 35);
			byte* p = b.p;
			if (logFileTimestamp) {
				Api.GetLocalTime(out var t);
				Api.wsprintfA(p, "%i-%02i-%02i %02i:%02i:%02i.%03i   ", __arglist(t.wYear, t.wMonth, t.wDay, t.wHour, t.wMinute, t.wSecond, t.wMilliseconds));
				int nn = Ptr_.Length(p);
				Encoding.UTF8.GetBytes(s, new Span<byte>(p + nn, n));
				n += nn;
				if (s.Starts("<>")) {
					Api.memmove(p + 2, p, nn);
					p[0] = (byte)'<'; p[1] = (byte)'>';
				}
			} else {
				Encoding.UTF8.GetBytes(s, new Span<byte>(p, n));
			}
			p[n - 1] = 13; p[n++] = 10;
			
			ok = Api.WriteFile(_h, p, n, out _);
			if (!ok) {
				string emsg = lastError.message;
				logFile = null;
				print.warning($"Failed to write to log file '{_name}'. {emsg}");
				directly(s);
				//Debug.Assert(false);
			}
			return ok;
		}
		
		/// <summary>
		/// Sets file size = 0.
		/// </summary>
		public bool Clear() {
			bool ok = Api.SetFilePointerEx(_h, 0, null, Api.FILE_BEGIN) && Api.SetEndOfFile(_h);
			Debug.Assert(ok);
			return ok;
		}
		
		/// <summary>
		/// Closes file handle.
		/// </summary>
		public void Close() => _h.Dispose();
	}
	
	/// <summary>
	/// Calls <c>Api.CreateFile</c> to open file or mailslot.
	/// </summary>
	/// <param name="name">File path or mailslot name.</param>
	/// <param name="openExisting">Use <c>OPEN_EXISTING</c>. If <c>false</c>, uses <c>CREATE_ALWAYS</c>.</param>
	internal static Handle_ CreateFile_(string name, bool openExisting) {
		return Api.CreateFile(name, Api.GENERIC_WRITE, Api.FILE_SHARE_READ, openExisting ? Api.OPEN_EXISTING : Api.CREATE_ALWAYS);
		
		//tested: CREATE_ALWAYS works with mailslot too. Does not erase messages. Undocumented what to use.
	}
	
	///
#if !DEBUG
	[EditorBrowsable(EditorBrowsableState.Never)]
#endif
	public static class qm2 {
		/// <summary>
		/// Sets to use QM2 as the output server.
		/// </summary>
		public static bool use { get; set; }
		
		/// <summary>
		/// Clears QM2 output panel.
		/// </summary>
		public static void clear() => _WriteToQM2(null);
		
		/// <summary>
		/// Writes line to QM2.
		/// </summary>
		public static void write(object o) => _WriteToQM2(o?.ToString() ?? "");
		
		/// <summary>
		/// Writes multiple arguments of any type to the output, using separator <c>", "</c>.
		/// </summary>
		/// <remarks>
		/// If a value is <c>null</c>, writes <c>"null"</c>.
		/// If a value is unsigned integer (<c>uint</c>, <c>ulong</c>, <c>ushort</c>, <c>byte</c>, <c>nuint</c>), writes in hexadecimal format with prefix <c>"0x"</c>.
		/// </remarks>
		public static void write(object value1, object value2, params object[] more) {
			write(util.toList(", ", value1, value2, more));
		}
		
		/// <summary>
		/// The same as <see cref="write"/>, but with <c>[Conditional("DEBUG")]</c>.
		/// </summary>
		[Conditional("DEBUG")]
		public static void writeD(object value1, object value2, params object[] more) {
			write(util.toList(", ", value1, value2, more));
		}
		
		/// <param name="s">If <c>null</c>, clears output.</param>
		static void _WriteToQM2(string s) {
			if (!_hwndQM2.IsAlive) {
				_hwndQM2 = Api.FindWindowEx(cn: "QM_Editor");
				if (_hwndQM2.Is0) return;
			}
			_hwndQM2.Send(Api.WM_SETTEXT, -1, s);
		}
		static wnd _hwndQM2;
	}
	
	/// <summary>
	/// Write unsigned numeric types in decimal format, not hexadecimal.
	/// </summary>
	public static bool noHex { get; set; }
	
	/// <summary>
	/// Some functions used by the <see cref="print"/> class.
	/// </summary>
	public static class util {
		/// <summary>
		/// Converts value of any type to <c>string</c>. Formats it like <see cref="it(object)"/>.
		/// </summary>
		/// <param name="value">Value of any type. If <c>null</c>, returns <c>"null"</c>.</param>
		/// <param name="compact">If <i>value</i> is <see cref="COL.IEnumerable"/> or <see cref="COL.DictionaryEntry"/>, format it like <c>"{ item1, item2 }"</c>.</param>
		public static string toString(object value, bool compact = false) {
			switch (value) {
			case null: return "null";
			case string t: return t;
			case ulong or uint or ushort or byte or nuint when !noHex:
			case COL.IEnumerable when !value.GetType().IsCOMObject: //info: eg Excel.Range and many other Excel interfaces are IEnumerable, and this process crashes, sometimes Excel too
			case COL.DictionaryEntry:
				using (new StringBuilder_(out var b)) {
					toString(b, value, compact);
					return b.ToString();
				}
			default: return value.ToString();
			}
		}
		
		/// <summary>
		/// Appends value of any type to <c>StringBuilder</c>. Formats it like <see cref="it(object)"/>.
		/// </summary>
		/// <inheritdoc cref="toString(object, bool)"/>
		public static void toString(StringBuilder b, object value, bool compact) {
			switch (value) {
			case null: b.Append("null"); break;
			case string s: b.Append(s); break;
			case ulong u: _Unsigned(b, u); break;
			case uint u: _Unsigned(b, u); break;
			case ushort u: _Unsigned(b, u); break;
			case byte u: _Unsigned(b, u); break;
			case nuint u: _Unsigned(b, u); break;
			case char[] a: b.Append(a); break;
			case byte[] a:
				if (noHex) b.AppendJoin('-', a);
				else b.Append(BitConverter.ToString(a));
				break;
			case COL.IEnumerable e when !value.GetType().IsCOMObject:
				if (compact) b.Append("{ ");
				string sep = null;
				foreach (var v in e) {
					if (sep == null) sep = compact ? ", " : "\r\n"; else b.Append(sep);
					toString(b, v, compact);
				}
				if (compact) b.Append(" }");
				break;
			case COL.DictionaryEntry de:
				b.AppendFormat("[{0}, {1}]", de.Key, de.Value);
				break;
			default: b.Append(value); break;
			}
			
			static void _Unsigned(StringBuilder b, ulong u) {
				if (noHex) b.Append(u);
				else b.Append("0x").Append(u.ToString("X"));
			}
		}
		
		/// <summary>
		/// Converts multiple values of any type to <c>string</c> like <see cref="list(string, object, object, object[])"/>.
		/// </summary>
		public static string toList(string sep, object value1, object value2, params object[] more) {
			if (more == null) more = s_oaNull; //workaround for: if the third argument is null, we receive null and not object[] { null }
			else if (more.GetType() != typeof(object[])) more = new object[] { more }; //workaround for: if the third argument is an array, prints its elements without { }. If empty array, prints nothing (even no comma). With this workaround - only if object[], which is rare; and it's good, because may be used in a wrapper function that passes its 'params object[]' parameter here.
			
			using (new StringBuilder_(out var b)) {
				for (int i = 0, n = 2 + more.Length; i < n; i++) {
					if (i > 0) b.Append(sep);
					util.toString(b, i == 0 ? value1 : (i == 1 ? value2 : more[i - 2]), compact: true);
				}
				return b.ToString();
				
				//rejected: escape strings (eg if contains characters "\r\n,\0"):
				//	it can damage formatting tags etc;
				//	the string may be already escaped, eg wnd.ToString or elm.ToString;
				//	we don't know whether the caller wants it;
				//	let the caller escape it if wants, it's easy.
			}
		}
		static readonly object[] s_oaNull = { null };
		
		/// <summary>
		/// Converts binary data to a hexadecimal + characters string, similar to the format used in hex editors.
		/// </summary>
		/// <param name="data"></param>
		/// <param name="columns">The number of bytes in a row.</param>
		public static string toString(ReadOnlySpan<byte> data, int columns) {
			//rejected: , char escapeChar = '.' /// <param name="escapeChar">Character for bytes other than the printable ASCII characters (32-126).</param>
			
			int len = data.Length;
			int rows = (len + columns - 1) / columns;
			var b = new StringBuilder(rows * (columns * 3 + 4 + columns + 2));
			
			for (int i = 0; i < len; i += columns) {
				//hex
				for (int j = 0; j < columns && i + j < len; j++) {
					byte k = data[i + j];
					b.Append(_ToHexChar(k >> 4)).Append(_ToHexChar(k & 0x0F)).Append(' ');
				}
				
				//padding if not enough columns
				for (int j = len - i; j < columns; j++) b.Append("   ");
				
				b.Append("    ");
				
				//text
				for (int j = 0; j < columns && i + j < len; j++) {
					byte k = data[i + j];
					b.Append(k >= 32 && k <= 126 ? (char)k : '.');
				}
				
				b.AppendLine();
			}
			
			return b.ToString();
			
			static char _ToHexChar(int h) => (char)(h < 10 ? h + '0' : h - 10 + 'A');
		}
	}
	
#pragma warning disable 1591 //no XML doc
	/// <summary>
	/// Interpolated string handler that adds <c>:print</c> format. See <see cref="it(InterpolatedString)"/>.
	/// </summary>
	[InterpolatedStringHandler, EditorBrowsable(EditorBrowsableState.Never)]
	public ref struct InterpolatedString {
		DefaultInterpolatedStringHandler _f;
		
		public InterpolatedString(int literalLength, int formattedCount) {
			_f = new(literalLength, formattedCount);
		}
		
		public InterpolatedString(int literalLength, int formattedCount, IFormatProvider provider) {
			_f = new(literalLength, formattedCount, provider);
		}
		
		public InterpolatedString(int literalLength, int formattedCount, IFormatProvider provider, Span<char> initialBuffer) {
			_f = new(literalLength, formattedCount, provider, initialBuffer);
		}
		
		public void AppendLiteral(string value)
			 => _f.AppendLiteral(value);
		
		public void AppendFormatted<T>(T value)
			 => _f.AppendFormatted(value);
		
		public void AppendFormatted<T>(T value, int alignment)
			 => _f.AppendFormatted(value, alignment);
		
		public void AppendFormatted<T>(T value, string format) {
			if (format == "print") _f.AppendLiteral(util.toString(value, compact: true));
			else _f.AppendFormatted(value, format);
		}
		
		public void AppendFormatted<T>(T value, int alignment, string format) {
			if (format == "print") _f.AppendFormatted(util.toString(value, compact: true), alignment);
			else _f.AppendFormatted(value, alignment, format);
		}
		
		public void AppendFormatted(RStr value)
			=> _f.AppendFormatted(value);
		
		public void AppendFormatted(RStr value, int alignment = 0, string format = null)
			=> _f.AppendFormatted(value, alignment, format);
		
		public void AppendFormatted(string value)
			=> _f.AppendFormatted(value);
		
		public void AppendFormatted(string value, int alignment = 0, string format = null)
			=> _f.AppendFormatted(value, alignment, format);
		
		public void AppendFormatted(object value, int alignment = 0, string format = null)
			=> _f.AppendFormatted(value, alignment, format);
		
		public string GetFormattedText() => _f.ToStringAndClear();
	}
}


================================================
FILE: Au/Other/screen.cs
================================================
namespace Au {
	/// <summary>
	/// Represents a screen device. Gets its rectangle etc.
	/// </summary>
	/// <remarks>
	/// A computer can have one or more screens (aka display devices, monitors). One of them is the <i>primary</i> screen; its top-left coordinate is 0 0.
	/// To show or find a window or some object in a particular screen, need to identify the screen somehow. At Windows API level each screen has a unique integer identifier, known as screen handle or <ms>HMONITOR</ms>. But it is a random variable value and therefore cannot be specified directly in script etc. Instead can be used screen index or some object on that screen (window, point, rectangle).
	/// 
	/// A <c>screen</c> variable can contain either a screen handle or a callback function that returns a screen handle. If empty, most functions interpret it as the primary screen.
	/// 
	/// To create <c>screen</c> variables use static functions (like <c>screen.index(1)</c> or <c>screen.primary</c>) or constructors (like <c>new screen(()=>screen.index(1))</c>) or <see cref="at"/>. Then call non-static functions to get screen properties.
	/// 
	/// A screen handle cannot be reliably used for a long time. Screen handles may change when changing the configuration of multiple screens. Consider a "lazy" variable, ie with callback function <see cref="LazyFunc"/>. Then, whenever a function needs a screen handle, it calls the callback function which returns a <c>screen</c> with fresh handle.
	/// </remarks>
	public struct screen : IEquatable<screen> {
		readonly IntPtr _h;
		readonly Func<screen> _func;
		
		/// <summary>
		/// Creates variable with screen handle, aka <ms>HMONITOR</ms>.
		/// </summary>
		public screen(IntPtr handle) { _h = handle; _func = null; }
		
		/// <summary>
		/// Creates "lazy" variable that calls your function to get screen when need.
		/// </summary>
		public screen(Func<screen> f) { _h = default; _func = f; }
		
		/// <summary>
		/// Gets the screen handle, aka <ms>HMONITOR</ms>. Returns <c>default(IntPtr)</c> if it wasn't set; see <see cref="Now"/>.
		/// </summary>
		public IntPtr Handle => _h;
		
		/// <summary>
		/// Gets the callback function that returns <see cref="screen"/> when need. Returns <c>null</c> if it wasn't set.
		/// </summary>
		public Func<screen> LazyFunc => _func;
		
		/// <summary>
		/// Returns <c>true</c> if this variable has no screen handle and no callback function.
		/// </summary>
		public bool IsEmpty => _h == default && _func == null;
		
		IntPtr _Handle() {
			if (_h != default) return _h;
			if (_func != null) return _func()._Handle();
			return primary._h;
		}
		
		/// <summary>
		/// Returns a copy of this variable with <see cref="Handle"/>.
		/// </summary>
		/// <remarks>
		/// If this variable has <see cref="Handle"/>, returns its clone. Else if has <see cref="LazyFunc"/>, calls it. Else gets the primary screen.
		/// </remarks>
		public screen Now => new(_Handle());
		
		/// <summary>
		/// Gets the primary screen.
		/// </summary>
		/// <remarks>
		/// The returned variable has <see cref="Handle"/>. To create lazy variable (with <see cref="LazyFunc"/>), use <c>screen.index(0, lazy: true)</c>.
		/// </remarks>
		public static screen primary => new(Api.MonitorFromWindow(default, SODefault.Primary)); //fast
		
		/// <summary>
		/// Returns a lazy <see cref="screen"/> variable that later will get the screen from the mouse cursor position at that time.
		/// </summary>
		/// <remarks>
		/// If need non-lazy: <c>screen.of(mouse.xy)</c> or <c>screen.ofMouse.Now</c>.
		/// </remarks>
		public static screen ofMouse => new(s_ofMouse);
		
		/// <summary>
		/// Returns a lazy <see cref="screen"/> variable that later will get the screen of the active window at that time.
		/// </summary>
		/// <remarks>
		/// If need non-lazy: <c>screen.of(wnd.active)</c> or <c>screen.ofActiveWindow.Now</c>.
		/// </remarks>
		public static screen ofActiveWindow => new(s_ofActiveWindow);
		
		static readonly Func<screen> s_ofMouse = () => of(mouse.xy);
		static readonly Func<screen> s_ofActiveWindow = () => of(wnd.active);
		
		internal bool IsOfMouse_ => ReferenceEquals(_func, s_ofMouse);
		internal bool IsOfActiveWindow_ => ReferenceEquals(_func, s_ofActiveWindow);
		
		/// <summary>
		/// Gets screen containing the biggest part of the specified window or nearest to it.
		/// </summary>
		/// <param name="w">Window or control. If <c>default(wnd)</c> or invalid, gets the primary screen.</param>
		/// <param name="defaultScreen"></param>
		/// <param name="lazy">
		/// Create variable with <see cref="LazyFunc"/> that later will get screen handle.
		/// Other ways to create lazy:
		/// <br/>• use <see cref="wndFinder"/>. Example: <c>screen.of(new wndFinder("* Notepad"))</c>.
		/// <br/>• use constructor. Example: <c>new screen(() => screen.of(wnd.findFast(cn: "Notepad")))</c>.
		/// </param>
		public static screen of(wnd w, SODefault defaultScreen = SODefault.Nearest, bool lazy = false)
			=> lazy
			? new screen(() => of(w, defaultScreen))
			: new screen(Api.MonitorFromWindow(w, defaultScreen));
		
		/// <summary>
		/// Gets screen containing the biggest part of the specified window or nearest to it.
		/// </summary>
		/// <param name="f">Window finder. If window not found, gets the primary screen.</param>
		/// <param name="defaultScreen"></param>
		/// <param name="lazy">Create variable with <see cref="LazyFunc"/> that later will find window and get screen handle. Default <c>true</c>.</param>
		public static screen of(wndFinder f, SODefault defaultScreen = SODefault.Nearest, bool lazy = true)
			=> lazy
			? new screen(() => of(f, defaultScreen, false))
			: of(f.Find(), defaultScreen);
		
		/// <summary>
		/// Gets screen containing the biggest part of the specified winforms window or control or nearest to it.
		/// </summary>
		/// <param name="c">Window or control. If handle not created, gets the primary screen. Cannot be <c>null</c>.</param>
		/// <param name="defaultScreen"></param>
		/// <param name="lazy">Create variable with <see cref="LazyFunc"/> that later will get screen handle.</param>
		public static screen of(System.Windows.Forms.Control c, SODefault defaultScreen = SODefault.Nearest, bool lazy = false)
			=> lazy
			? new screen(() => of(c, defaultScreen))
			: of(c.Hwnd(), defaultScreen);
		
		/// <summary>
		/// Gets screen containing the biggest part of the specified WPF window or nearest to it.
		/// </summary>
		/// <param name="w">WPF window. If handle not created, gets the primary screen. Cannot be <c>null</c>.</param>
		/// <param name="defaultScreen"></param>
		/// <param name="lazy">Create variable with <see cref="LazyFunc"/> that later will get screen handle.</param>
		public static screen of(System.Windows.Window w, SODefault defaultScreen = SODefault.Nearest, bool lazy = false)
			=> lazy
			? new screen(() => of(w, defaultScreen))
			: of(w.Hwnd(), defaultScreen);
		
		/// <summary>
		/// Gets screen containing the biggest part of the specified WPF element (of its rectangle) or nearest to it.
		/// </summary>
		/// <param name="elem">WPF element. If not loaded, gets the primary screen. Cannot be <c>null</c>.</param>
		/// <param name="defaultScreen"></param>
		/// <param name="lazy">Create variable with <see cref="LazyFunc"/> that later will get screen handle.</param>
		public static screen of(System.Windows.FrameworkElement elem, SODefault defaultScreen = SODefault.Nearest, bool lazy = false)
			=> lazy
			? new screen(() => of(elem, defaultScreen))
			: of(elem.RectInScreen(), defaultScreen);
		
		/// <summary>
		/// Gets screen containing the specified point or nearest to it.
		/// </summary>
		/// <param name="p"></param>
		/// <param name="defaultScreen"></param>
		/// <param name="lazy">Create variable with <see cref="LazyFunc"/> that later will get screen handle.</param>
		public static screen of(POINT p, SODefault defaultScreen = SODefault.Nearest, bool lazy = false)
			=> lazy
			? new screen(() => of(p, defaultScreen))
			: new screen(Api.MonitorFromPoint(p, defaultScreen));
		
		/// <summary>
		/// Gets screen containing the specified point or nearest to it.
		/// </summary>
		/// <param name="x"></param>
		/// <param name="y"></param>
		/// <param name="defaultScreen"></param>
		/// <param name="lazy">Create variable with <see cref="LazyFunc"/> that later will get screen handle.</param>
		public static screen of(int x, int y, SODefault defaultScreen = SODefault.Nearest, bool lazy = false)
			=> lazy
			? new screen(() => of(x, y, defaultScreen))
			: of((x, y), defaultScreen);
		
		/// <summary>
		/// Gets screen containing the biggest part of the specified rectangle or nearest to it.
		/// </summary>
		/// <param name="r"></param>
		/// <param name="defaultScreen"></param>
		/// <param name="lazy">Create variable with <see cref="LazyFunc"/> that later will get screen handle.</param>
		public static screen of(RECT r, SODefault defaultScreen = SODefault.Nearest, bool lazy = false)
			=> lazy
			? new screen(() => of(r, defaultScreen))
			: new screen(Api.MonitorFromRect(r, defaultScreen));
		
		/// <summary>
		/// Gets screens at various positions relative to the primary screen.
		/// </summary>
		public static class at {
			/// <summary>Gets a screen nearest to the top edge of the primary screen.</summary>
			/// <param name="lazy">Create variable with <see cref="LazyFunc"/> that later will get screen handle.</param>
			public static screen top(bool lazy = false) => _S(0, -700, lazy);
			
			/// <summary>Gets a screen nearest to the bottom edge of the primary screen.</summary>
			/// <param name="lazy">Create variable with <see cref="LazyFunc"/> that later will get screen handle.</param>
			public static screen bottom(bool lazy = false) => _S(0, 700, lazy);
			
			/// <summary>Gets a screen nearest to the left edge of the primary screen.</summary>
			/// <param name="lazy">Create variable with <see cref="LazyFunc"/> that later will get screen handle.</param>
			public static screen left(bool lazy = false) => _S(-1000, 0, lazy);
			
			/// <summary>Gets a screen nearest to the right edge of the primary screen.</summary>
			/// <param name="lazy">Create variable with <see cref="LazyFunc"/> that later will get screen handle.</param>
			public static screen right(bool lazy = false) => _S(1000, 0, lazy);
			
			/// <summary>Gets a screen nearest to the top-left corner of the primary screen.</summary>
			/// <param name="lazy">Create variable with <see cref="LazyFunc"/> that later will get screen handle.</param>
			public static screen topLeft(bool lazy = false) => _S(-1000, -700, lazy);
			
			/// <summary>Gets a screen nearest to the top-right corner of the primary screen.</summary>
			/// <param name="lazy">Create variable with <see cref="LazyFunc"/> that later will get screen handle.</param>
			public static screen topRight(bool lazy = false) => _S(1000, -700, lazy);
			
			/// <summary>Gets a screen nearest to the bottom-left corner of the primary screen.</summary>
			/// <param name="lazy">Create variable with <see cref="LazyFunc"/> that later will get screen handle.</param>
			public static screen bottomLeft(bool lazy = false) => _S(-1000, 700, lazy);
			
			/// <summary>Gets a screen nearest to the bottom-right corner of the primary screen.</summary>
			/// <param name="lazy">Create variable with <see cref="LazyFunc"/> that later will get screen handle.</param>
			public static screen bottomRight(bool lazy = false) => _S(1000, 700, lazy);
		}
		
		/// <summary>
		/// Gets screen at (or nearest to) the specified offset from the primary screen (PS).
		/// </summary>
		/// <param name="dx">Horizontal offset. Negative is to the left from the left edge of PS. Positive is to the right from the right edge of PS. Zero is the horizontal center of PS.</param>
		/// <param name="dy">Vertical offset. Negative is up from the top edge of PS. Positive is down from the bottom edge of PS. Zero is the vertical center of PS.</param>
		static screen _S(int dx, int dy, bool lazy) {
			var r = primary.Rect;
			if (dx > 0) dx += r.right; else if (dx == 0) dx = r.CenterX;
			if (dy > 0) dy += r.bottom; else if (dy == 0) dy = r.CenterY;
			return of(dx, dy, lazy: lazy);
		}
		
		/// <summary>
		/// Gets all screens.
		/// </summary>
		/// <remarks>
		/// The order of array elements may be different than in Windows Settings. The primary screen is always at index 0.
		/// The array is not cached. Each time calls API <ms>EnumDisplayMonitors</ms>.
		/// </remarks>
		public static screen[] all => _All();
		
		[SkipLocalsInit]
		internal static unsafe screen[] _All(bool failed = false) {
			var a = stackalloc nint[256];
			a[0] = 1; //array length
			a[1] = Api.MonitorFromWindow(default, SODefault.Primary); //fast
			
			[UnmanagedCallersOnly]
			static int _Enum(nint hmon, nint hdc, RECT* r, nint* a) {
				if (hmon != a[1]) a[++a[0]] = hmon;
				return 1;
			};
			
			if (!Api.EnumDisplayMonitors(default, default, &_Enum, a)) {
				if (failed) throw new AuException("EnumDisplayMonitors failed");
				Debug_.Print("EnumDisplayMonitors");
				//in certain conditions EDM fails.
				//	Where failed, it was used in incorrect code, maybe near stack overflow.
				//	Anyway, then call it in other thread, then works.
				//print.it(lastError.message); //0
				return Task.Run(() => _All(true)).GetAwaiter().GetResult();
			}
			
			nint n = a[0];
			var r = new screen[n];
			for (int i = 0; i < n;) r[i++] = new(a[i]);
			return r;
		}
		
		/// <summary>
		/// Gets screen at the specified index of the <see cref="all"/> array.
		/// </summary>
		/// <param name="index">0-based screen index. Index 0 is the primary screen. If index too big, gets the primary screen.</param>
		/// <param name="lazy">Create variable with <see cref="LazyFunc"/> that later will get screen handle.</param>
		/// <exception cref="ArgumentOutOfRangeException">Negative <i>index</i>.</exception>
		public static screen index(int index, bool lazy = false) {
			if (index < 0) throw new ArgumentOutOfRangeException();
			if (lazy) return new screen(() => screen.index(index));
			if (index > 0) {
				var a = _All();
				if (index < a.Length) return a[index];
				//print.warning("Invalid screen index.");
			}
			return primary;
		}
		//We don't use a cached array that is updated like in Screen class code, eg on SystemEvents.DisplaySettingsChanging (wm_displaychanged).
		//	Then index functions are faster, but less reliable when changing display settings, because the array is updated with a delay.
		//	Now index functions are fast enough. Faster than EnumWindows which is used much more often.
		
		//At first there was an implicit conversion from int that called index()? I don't remember why removed, but probably for a good reason.
		
		/// <summary>
		/// Gets index of this screen in the <see cref="all"/> array.
		/// </summary>
		/// <remarks>
		/// Returns 0 (index of primary screen) if this variable is empty. Returns -1 if the screen handle is invalid; it can happen after changing display settings, but is rare.
		/// </remarks>
		public int ScreenIndex {
			get {
				if (_h == default && _func == null) return 0;
				var h = _Handle();
				var a = _All();
				for (int i = 0; i < a.Length; i++) if (a[i]._h == h) return i;
				return -1;
			}
		}
		
		/// <summary>
		/// Gets screen rectangle and other info.
		/// </summary>
		/// <returns>
		/// Tuple containing:
		/// <br/>• <c>rect</c> - screen rectangle.
		/// <br/>• <c>workArea</c> - work area rectangle.
		/// <br/>• <c>isPrimary</c> - <c>true</c> if it is the primary screen.
		/// <br/>• <c>isAlive</c> - <c>false</c> if the screen handle is invalid; then the function gets info of the primary screen.
		/// </returns>
		/// <remarks>
		/// If this variable holds a callback function, this function calls it to get screen handle. See also <see cref="Now"/>.
		/// </remarks>
		public unsafe (RECT rect, RECT workArea, bool isPrimary, bool isAlive) Info {
			get {
				var h = _func != null ? _Handle() : _h;
				for (int i = h != default ? 0 : 1; i < 10; i++, h = primary._h) { //retry if fails
					if (Api.GetMonitorInfo(h, out var m)) //fast
						return (m.rcMonitor, m.rcWork, 0 != (m.dwFlags & 1), i == 0);
				}
				return default;
			}
		}
		
		/// <summary>
		/// Calls <see cref="Info"/> and returns rectangle of the screen or its work area.
		/// </summary>
		/// <param name="workArea">Get work area rectangle.</param>
		public RECT GetRect(bool workArea = false) {
			var v = Info;
			return workArea ? v.workArea : v.rect;
		}
		
		/// <summary>
		/// Calls <see cref="Info"/> and returns screen rectangle.
		/// </summary>
		public RECT Rect => Info.rect;
		
		/// <summary>
		/// Calls <see cref="Info"/> and returns work area rectangle.
		/// </summary>
		public RECT WorkArea => Info.workArea;
		
		/// <summary>
		/// Gets DPI of this screen.
		/// Calls <see cref="Dpi.OfScreen"/>.
		/// </summary>
		public int Dpi => More.Dpi.OfScreen(_Handle());
		//public int Dpi(bool supportWin81 = false) => More.Dpi.OfScreen(_Handle(), supportWin81); //no, rarely need, don't complicate everything. When need, can use Dpi.OfScreen.
		
		/// <summary>
		/// True if the screen handle is valid.
		/// </summary>
		/// <remarks>
		/// Don't use with variables that hold a callback function. This function does not call it and returns <c>false</c>.
		/// </remarks>
		public unsafe bool IsAlive => _h != default && Api.GetMonitorInfo(_h, out _);
		
		///
		public override string ToString() => _h.ToString() + " " + Rect.ToString();
		
		///
		public override int GetHashCode() => (int)_Handle();
		
		///
		public override bool Equals(object obj) => obj is screen && Equals((screen)obj);
		
		///
		public bool Equals(screen other) => other._Handle() == _Handle();
		
		///
		public static bool operator ==(screen a, screen b) => a.Equals(b);
		///
		public static bool operator !=(screen a, screen b) => !a.Equals(b);
		
		//rejected. GetHashCode gets hmonitor but is undocumented. Rarely used.
		///// <summary>Converts from <see cref="Screen"/>.</summary>
		//public static implicit operator screen(Screen scrn) => new screen((IntPtr)scrn.GetHashCode());
		
		///// <summary>Converts to <see cref="Screen"/>. Returns <c>null</c> if failed.</summary>
		//public static implicit operator Screen(screen scrn) { int h=(int)scrn._Handle(); return Screen.AllScreens.FirstOrDefault(o => o.GetHashCode() == h);
		
		/// <summary>
		/// Returns <c>true</c> if point <i>p</i> is in some screen.
		/// </summary>
		public static bool isInAnyScreen(POINT p) => Api.MonitorFromPoint(p, SODefault.Zero) != default;
		
		/// <summary>
		/// Returns <c>true</c> if rectangle <i>r</i> intersects with some screen.
		/// </summary>
		public static bool isInAnyScreen(RECT r) => Api.MonitorFromRect(r, SODefault.Zero) != default;
		
		/// <summary>
		/// Returns <c>true</c> if rectangle of window <i>w</i> intersects with some screen.
		/// </summary>
		public static bool isInAnyScreen(wnd w) => Api.MonitorFromWindow(w, SODefault.Zero) != default;
		
		/// <summary>
		/// Gets bounding rectangle of all screens.
		/// </summary>
		public static RECT virtualScreen
			=> new(Api.GetSystemMetrics(Api.SM_XVIRTUALSCREEN), Api.GetSystemMetrics(Api.SM_YVIRTUALSCREEN), Api.GetSystemMetrics(Api.SM_CXVIRTUALSCREEN), Api.GetSystemMetrics(Api.SM_CYVIRTUALSCREEN));
		
		//20 times faster, but maybe less reliable
		//public static RECT virtualScreen2 => wnd.getwnd.shellWindow.Rect;
		
		internal screen ThrowIfWithHandle_ => _h == default ? this : throw new ArgumentException("screen with Handle. Must be lazy or empty.");
	}
}

namespace Au.Types {
	/// <summary>
	/// Used with <see cref="screen.of"/> to specify what screen to return if the window/point/etc is not in a screen or if the window handle is invalid etc.
	/// </summary>
	public enum SODefault {
		/// <summary>Create empty variable.</summary>
		Zero, //MONITOR_DEFAULTTONULL
		
		/// <summary>The primary screen.</summary>
		Primary, //MONITOR_DEFAULTTOPRIMARY
		
		/// <summary>The nearest screen. If window handle is invalid - the primary screen.</summary>
		Nearest, //MONITOR_DEFAULTTONEAREST
	}
}


================================================
FILE: Au/Other/script+.cs
================================================
using System.Text.Json;

namespace Au.Types {
	/// <summary>
	/// <see cref="script.role"/>.
	/// </summary>
	public enum SRole {
		/// <summary>
		/// The task runs as normal <c>.exe</c> program.
		/// It can be started from editor or not. It can run on computers where editor not installed.
		/// </summary>
		ExeProgram,
		
		/// <summary>
		/// The task runs in <c>Au.Task-x64.exe</c> or <c>Au.Task-arm.exe</c> process, started from editor.
		/// </summary>
		MiniProgram,
		
		/// <summary>
		/// The task runs in editor process.
		/// </summary>
		EditorExtension,
	}
	
	/// <summary>
	/// Flags for <see cref="script.setup"/> parameter <i>exception</i>. Defines what to do on unhandled exception.
	/// Default is <c>Print</c>, even if <c>script.setup</c> not called (with default compiler only).
	/// </summary>
	[Flags]
	public enum UExcept {
		/// <summary>
		/// Display exception info in output.
		/// </summary>
		Print = 1,
		
		/// <summary>
		/// Show dialog with exception info.
		/// If editor available, the dialog contains links to functions in the call stack. To close the dialog when a link clicked, add flag <c>Print</c>.
		/// </summary>
		Dialog = 2,
	}
	
	/// <summary>
	/// The default compiler adds this attribute to the assembly.
	/// </summary>
	[AttributeUsage(AttributeTargets.Assembly)]
	public sealed class PathInWorkspaceAttribute : Attribute {
		/// <summary>Path of main source file in workspace, like <c>@"\Script1.cs"</c> or <c>@"\Folder1\Script1.cs"</c>.</summary>
		public readonly string Path;
		
		/// <summary>Full path of main source file.</summary>
		public readonly string FilePath;
		
		///
		public PathInWorkspaceAttribute(string path, string filePath) { Path = path; FilePath = filePath; }
	}
	
	/// <summary>
	/// The default compiler adds this attribute to the main assembly if using non-default references (meta <c>r</c> or <c>nuget</c>). Allows to find them at run time. Only if role <c>miniProgram</c> (default) or <c>editorExtension</c>.
	/// </summary>
	[AttributeUsage(AttributeTargets.Assembly)]
	public sealed class RefPathsAttribute : Attribute {
		/// <summary>Dll paths separated with <c>|</c>.</summary>
		public readonly string Paths;
		
		/// <param name="paths">Dll paths separated with <c>|</c>.</param>
		public RefPathsAttribute(string paths) { Paths = paths; }
	}
	
	/// <summary>
	/// The default compiler adds this attribute to the main assembly if using NuGet packages with native dlls. Allows to find the dlls at run time. Only if role <c>miniProgram</c> (default) or <c>editorExtension</c>.
	/// </summary>
	[AttributeUsage(AttributeTargets.Assembly)]
	public sealed class NativePathsAttribute : Attribute {
		/// <summary>Dll paths separated with <c>|</c>.</summary>
		public readonly string Paths;
		
		/// <param name="paths">Dll paths separated with <c>|</c>.</param>
		public NativePathsAttribute(string paths) { Paths = paths; }
	}
	
	/// <summary>
	/// <see cref="ScriptEditor.GetCommandState"/>.
	/// </summary>
	[Flags]
	public enum ECommandState {
		///
		Checked = 1,
		///
		Disabled = 2,
	}
	
	/// <summary>
	/// For <see cref="ScriptEditor.GetIcon"/>.
	/// </summary>
	public enum EGetIcon {
		/// <summary>
		/// Input is a file or folder in current workspace. Can be relative path in workspace (like <c>@"\Folder\File.cs"</c>) or full path or filename.
		/// Output must be icon name, like <c>"*Pack.Icon color"</c>. See <see cref="ImageUtil.LoadWpfImageElement"/>.
		/// </summary>
		PathToIconName,
		
		/// <summary>
		/// Input is a file or folder in current workspace (see <c>PathToIconName</c>).
		/// Output must be icon XAML.
		/// </summary>
		PathToIconXaml,
		
		/// <summary>
		/// Input is icon name, like <c>"*Pack.Icon color"</c>. See <see cref="ImageUtil.LoadWpfImageElement"/>.
		/// Output must be icon XAML.
		/// </summary>
		IconNameToXaml,
		
		//PathToGdipBitmap,
		//IconNameToGdipBitmap,
	}
	
	/// <summary>
	/// See <see cref="ScriptEditor.GetFileInfo"/>.
	/// </summary>
	/// <param name="name">File name, like <c>"File.cs"</c>.</param>
	/// <param name="path">Path in workspace, like <c>@"\Folder\File.cs"</c>.</param>
	/// <param name="text">File text; null if <i>needText</i> false or if failed to get text. If the file is open in editor, it's the editor text, else it's the saved text.</param>
	/// <param name="kind"> </param>
	/// <param name="id">File id.</param>
	/// <param name="filePath">Full path.</param>
	/// <param name="workspace">Path of the workspace folder.</param>
	public record class EFileInfo(string name, string path, string text, EFileKind kind, uint id, string filePath, string workspace);
	
#pragma warning disable CS1591 //Missing XML comment for publicly visible type or member
	/// <summary>
	/// See <see cref="EFileInfo"/>.
	/// </summary>
	public enum EFileKind { Script, Class, Other }
#pragma warning restore CS1591 //Missing XML comment for publicly visible type or member
}

namespace Au.More {
	/// <summary>
	/// Contains compilation info passed to current <c>preBuild</c>/<c>postBuild</c> script.
	/// </summary>
	/// <param name="outputFile">Full path of the output exe or dll file.</param>
	/// <param name="outputPath">Meta comment <c>outputPath</c>.</param>
	/// <param name="source">Path of this C# code file in the workspace.</param>
	/// <param name="role">Meta comment <c>role</c>.</param>
	/// <param name="optimize">Meta comment <c>optimize</c>.</param>
	/// <param name="platform">Meta comment <c>platform</c>.</param>
	/// <param name="preBuild"><c>true</c> if the script used with meta <c>preBuild</c>, <c>false</c> if with <c>postBuild</c>.</param>
	/// <param name="publish"><c>true</c> when publishing.</param>
	/// <example>
	/// <code><![CDATA[
	/// /*/ role editorExtension; /*/
	/// var c = PrePostBuild.Info;
	/// print.it(c);
	/// print.it(c.outputFile);
	/// ]]></code>
	/// </example>
	public record class PrePostBuild(string outputFile, string outputPath, string source, string role, bool optimize, string platform, bool preBuild, bool publish) {
		/// <summary>
		/// Gets compilation info passed to current <c>preBuild</c>/<c>postBuild</c> script.
		/// </summary>
		public static PrePostBuild Info { get; internal set; }
		
		///
		[Obsolete("Use platform."), EditorBrowsable(EditorBrowsableState.Never)]
		public bool bit32 => platform == "x86";
	}
}


================================================
FILE: Au/Other/script.cs
================================================
namespace Au;

/// <summary>
/// Script task functions. Run, get properties, set options, etc.
/// A script task is a running script, except if role <c>editorExtension</c>. Each script task is a separate process.
/// </summary>
/// <seealso cref="process"/>
public static class script {
	#region properties
	
	/// <summary>
	/// Gets the script name, like <c>"Script123"</c>.
	/// </summary>
	/// <remarks>
	/// If role <c>miniProgram</c> (default), returns the script file name without extension.
	/// Else returns <see cref="AppDomain.FriendlyName"/>, like <c>"MainAssemblyName"</c>.
	/// </remarks>
	public static string name {
		get => s_name ??= AppDomain.CurrentDomain.FriendlyName; //info: in framework 4 with ".exe", now without (now it is the entry assembly name)
		internal set { s_name = value; }
	}
	static string s_name;
	
	/// <summary>
	/// Gets the script role (<c>miniProgram</c>, <c>exeProgram</c> or <c>editorExtension</c>).
	/// </summary>
	public static SRole role { get; internal set; }
	
	/// <summary>
	/// Gets path of the caller source code file.
	/// </summary>
	/// <param name="f_">[](xref:caller_info)</param>
	/// <seealso cref="CallerFilePathAttribute"/>
	/// <seealso cref="folders.sourceCode(string)"/>
	public static string sourcePath([CallerFilePath] string f_ = null) => f_;
	
	/// <summary>
	/// Gets path of the main source code file of this program or of a library.
	/// </summary>
	/// <param name="inWorkspace">Get path in the workspace, like <c>@"\Script1.cs"</c> or <c>@"\Folder1\Script1.cs"</c>.</param>
	/// <param name="asm">An assembly compiled by LibreAutomate. If <c>null</c>, uses <see cref="Assembly.GetEntryAssembly"/>.</param>
	/// <returns><c>null</c> if failed.</returns>
	/// <remarks>
	/// When compiling, LibreAutomate adds <see cref="PathInWorkspaceAttribute"/> to the assembly. Then at run time this function gets its value. Returns <c>null</c> if compiled by some other compiler.
	/// </remarks>
	/// <seealso cref="folders.sourceCodeMain(Assembly)"/>
	public static string sourcePath(bool inWorkspace, Assembly asm = null) {
		asm ??= AssemblyUtil_.GetEntryAssembly();
		if (asm?.GetCustomAttribute<PathInWorkspaceAttribute>() is not { } a) return null;
		return inWorkspace ? a.Path : a.FilePath;
	}
	
	/// <summary>
	/// Gets workspace path of the main source code file of this program, like <c>@"\Script1.cs"</c> or <c>@"\Folder1\Script1.cs"</c>.
	/// Calls <see cref="sourcePath(bool, Assembly)"/>.
	/// </summary>
	[EditorBrowsable(EditorBrowsableState.Never)] //replaced with sourcePath. Limited and unclear.
	public static string path => sourcePath(true);
	
	/// <summary>
	/// Returns <c>true</c> if this script task was started from editor with the <b>Run</b> button or menu command.
	/// Always <c>false</c> if role <c>editorExtension</c>.
	/// </summary>
	public static bool testing { get; internal set; }
	
	/// <summary>
	/// Returns <c>true</c> if the build configuration of the main assembly is Debug (default). Returns <c>false</c> if Release (<c>optimize true</c>).
	/// </summary>
	public static bool isDebug => s_debug ??= AssemblyUtil_.IsDebug(AssemblyUtil_.GetEntryAssembly());
	static bool? s_debug;
	//note: GetEntryAssembly returns null in func called by host through coreclr_create_delegate.
	
	/// <summary>
	/// Returns <c>true</c> if running in WPF preview mode.
	/// </summary>
	public static bool isWpfPreview {
		get {
			if (role != SRole.MiniProgram) return false;
			var s = Environment.CommandLine;
			//return s.Contains(" WPF_PREVIEW ") && s.RxIsMatch(@" WPF_PREVIEW (-?\d+) (-?\d+)$"); //slower JIT
			return s.Contains(" WPF_PREVIEW ") && _IsWpfPreview(s);
			
			//[MethodImpl(MethodImplOptions.NoInlining)]
			static bool _IsWpfPreview(string s) => s.RxIsMatch(@" WPF_PREVIEW (-?\d+) (-?\d+)$");
			
			//don't cache. It makes JIT slower. Now fast after JIT.
		}
	}
	
	#endregion
	
	#region AppModuleInit_, setup
	
	/// <summary>
	/// If role <c>miniProgram</c> or <c>exeProgram</c>, default compiler adds module initializer that calls this with <i>auCompiler</i> <c>true</c>.
	/// When compiling single-file exe with <c>dotnet publish</c>, adds module initializer that calls this with <i>auCompiler</i> <c>false</c>.
	/// If using other compiler, called from <c>script.setup</c> with <i>auCompiler</i> <c>false</c>.
	/// </summary>
	[EditorBrowsable(EditorBrowsableState.Never)]
	public static unsafe void AppModuleInit_(bool auCompiler) {
		if (s_appModuleInit) return;
		s_appModuleInit = true;
		
		process.thisProcessCultureIsInvariant = true;
		
		Cpp.Cpp_UEF(true); //2 ms. Loads the C++ dll.
		
		Api.SetErrorMode(Api.SEM_NOGPFAULTERRORBOX | Api.SEM_FAILCRITICALERRORS);
		//SEM_NOGPFAULTERRORBOX disables WER. See also the workaround below. //CONSIDER: add setup parameter enableWER.
		//SEM_FAILCRITICALERRORS disables some error message boxes, eg when removable media not found; MSDN recommends too.
		
		AppDomain.CurrentDomain.UnhandledException += _UnhandledException;
		
		AppDomain.CurrentDomain.ProcessExit += (_, _) => {
			Exiting_ = true;
			Cpp.Cpp_UEF(false);
		};
		
		if (role == SRole.ExeProgram) {
			//set STA thread if Main without [MTAThread]
			if (Thread.CurrentThread.GetApartmentState() != ApartmentState.STA) { //speed: 150 mcs
				if (null == Assembly.GetEntryAssembly().EntryPoint.GetCustomAttribute<MTAThreadAttribute>()) { //1.5 ms
					process.ThisThreadSetComApartment_(ApartmentState.STA); //1.6 ms
				}
			}
			
			int pidEditor = 0;
			if (auCompiler) {
				MiniProgram_.ResolveNugetRuntimes_(AppContext.BaseDirectory);
				
				var cd = Environment.CurrentDirectory;
				const string c_ep = "\\Roslyn\\.exeProgram";
				if (cd.Ends(c_ep, true)) { //started from editor
					Environment.CurrentDirectory = folders.ThisApp;
					
					var p = &SharedMemory_.Ptr->script;
					pidEditor = p->pidEditor;
					s_wndEditorMsg = (wnd)p->hwndMsg;
					s_idMainFile = p->idMainFile;
					if (0 != (p->flags & 2)) script.testing = true;
					if (0 != (p->flags & 4)) ScriptEditor.IsPortable = true;
					if (0 != (p->flags & 8)) s_wrPipeName = p->pipe;
					if (0 != (p->flags & 16)) MiniProgram_.RedirectConsole_();
					folders.Editor = new(cd[..^c_ep.Length]);
					folders.Workspace = new(p->workspace);
					
					var hevent = Api.OpenEvent(Api.EVENT_MODIFY_STATE, false, "Au.event.exeProgram.1");
					if (!Api.SetEvent(hevent)) Environment.Exit(4);
					Api.CloseHandle(hevent);
				}
			}
			
			Starting_(AppDomain.CurrentDomain.FriendlyName, pidEditor);
		}
	}
	static bool s_appModuleInit;
	static UExcept s_setupException = UExcept.Print;
	internal static Exception s_unhandledException; //for process.thisProcessExit
	internal static wnd s_wndEditorMsg;
	
	internal static bool Exiting_ { get; private set; }
	
	[DebuggerNonUserCode]
	static void _UnhandledException(object sender, UnhandledExceptionEventArgs u) {
		if (!u.IsTerminating) return; //never seen, but anyway
		Exiting_ = true;
		Cpp.Cpp_UEF(false);
		var e = (Exception)u.ExceptionObject; //probably non-Exception object is impossible in C#
		s_unhandledException = e;
		if (Debugger.IsAttached) return;
		if (s_setupException.Has(UExcept.Print)) print.it(e);
		if (s_setupException.Has(UExcept.Dialog)) {
			var text = e.ToStringWithoutStack();
			var d = new dialog("Task failed", null, "Close", flags: DFlags.ExpandDown, expandedText: e.ToString());
			if (ScriptEditor.Available) {
				var st = new StackTrace(e, true);
				var b = new StringBuilder(text + "\n");
				for (int i = 0; i < st.FrameCount; i++) {
					var f = st.GetFrame(i);
					if (f.HasSource()) b.Append($"\n<a href=\"{i}\">{f.GetMethod()?.Name}</a> in {pathname.getName(f.GetFileName())}:{f.GetFileLineNumber()}");
				}
				text = b.ToString();
				d.HyperlinkClicked += e => {
					if (s_setupException.Has(UExcept.Print)) e.d.Send.Close();
					var f = st.GetFrame(e.LinkHref.ToInt());
					ScriptEditor.Open(f.GetFileName(), f.GetFileLineNumber(), Math.Max(0, f.GetFileColumnNumber() - 1));
				};
			}
			d.Text2(text);
			d.ShowDialog();
		}
		
		//workaround for .NET bug: randomly changes error mode.
		//	Usually 0x3 -> 0x8001 (removed SEM_NOGPFAULTERRORBOX), sometimes even 0x0. Usually never restores.
		//	Then on unhandled exception starts werfault.exe (with "wait" cursor), and the process exits with 1 s delay, even if WER disabled.
		//	Tested: same in a standard simplest .NET program. But less frequently.
		//	Usually it happens while _AuxThread is starting, often in Cpp_UEF (now removed). Rarely if _AuxThread not used.
		//	Several ms before or after the script code starts.
		//	The bug is in several places in CLR code.
		//		It sets error mode, then executes code without lock and exception handling, then restores (if no exception).
		//		Why it does not use SetThreadErrorMode? Why it uses the obsolete flag SEM_NOOPENFILEERRORBOX? Why it does not check maybe SEM_FAILCRITICALERRORS is already set (as recommended in doc)? Why it does not | the new error mode flags with current flags?
		//	Could move _AuxThread to the C++ dll (not very easy).
		//		Or move most of the _AuxThread startup code to the main thread (making script startup slower).
		//		But it just would make this less frequent.
		//		Anyway, moved Cpp_UEF here. It's better to load the dll sync, not at a random time later.
		//	Never mind. This workaround solves the biggest problem for this library. Maybe future .NET will fix it.
		Api.SetErrorMode(Api.SEM_NOGPFAULTERRORBOX | Api.SEM_FAILCRITICALERRORS);
	}
	
	[StructLayout(LayoutKind.Sequential, Size = 256 + 1024)] //note: this struct is in shared memory. Size must be same in all library versions.
	internal unsafe struct SharedMemoryData_ {
		public int flags; //1 not received (let editor wait), 2 testing, 4 isPortable, 8 has pipe
		public int pidEditor;
		public int hwndMsg;
		public uint idMainFile;
		int _pipeLen;
		fixed char _pipeData[64];
		int _workspaceLen;
		fixed char _workspaceData[1024];
		
		public string pipe {
			get { fixed (char* p = _pipeData) return new(p, 0, _pipeLen); }
			set {
				fixed (char* p = _pipeData) value.AsSpan().CopyTo(new Span<char>(p, 64));
				_pipeLen = value.Length;
			}
		}
		
		public string workspace {
			get { fixed (char* p = _workspaceData) return new(p, 0, _workspaceLen); }
			set {
				fixed (char* p = _workspaceData) value.AsSpan().CopyTo(new Span<char>(p, 1024));
				_workspaceLen = value.Length;
			}
		}
	}
	
	/// <summary>
	/// Adds various features to this script task (running script): tray icon, exit on <c>Ctrl+Alt+Delete</c>, etc.
	/// </summary>
	/// <param name="trayIcon">Add tray icon. See <see cref="trayIcon"/>.</param>
	/// <param name="sleepExit">End this process when computer is going to sleep or hibernate.</param>
	/// <param name="lockExit">
	/// End this process when the active desktop has been switched (PC locked, <c>Ctrl+Alt+Delete</c>, screen saver, etc, except UAC consent).
	/// Then to end this process you can use hotkeys <c>Win+L</c> (lock computer) and <c>Ctrl+Alt+Delete</c>.
	/// Most mouse, keyboard, clipboard and window functions don't work when other desktop is active. Many of them then throw exception, and the script would end anyway.
	/// </param>
	/// <param name="debug">Call <see cref="DebugTraceListener.Setup"/> with <i>usePrint</i> <c>true</c>. It makes <see cref="Debug.Assert"/> etc useful when not debugging.</param>
	/// <param name="exception">What to do on unhandled exception (event <see cref="AppDomain.UnhandledException"/>).</param>
	/// <param name="exitKey">
	/// If not 0, the script task will end when this key pressed. Will call <see cref="Environment.Exit"/>.
	/// Example: <c>exitKey: KKey.MediaStop</c>.
	/// <para>
	/// Recommended keys: media, volume, browser and applaunch keys. They work even when the process of the active window is admin (UAC) and this script isn't. In any case, the key does not work if somewhere used for a global hotkey, trigger, <i>exitKey</i> or <i>pauseKey</i>. Also the key does not work when at that time a modifier key is pressed by a script; it also can be dangerous because may generate a trigger or hotkey used by an app or OS.
	/// </para>
	/// </param>
	/// <param name="pauseKey">
	/// Let <see cref="pause"/> pause/resume when this key pressed. Default: <c>ScrollLock</c> (<c>Fn+S</c>, <c>Fn+K</c> or similar).
	/// If <c>CapsLock</c>, pauses when it is toggled (even if was toggled at startup) and resumes when untoggled.
	/// <para>
	/// <c>ScrollLock</c>, <c>CapsLock</c> and <c>NumLock</c> are the most reliable. Other keys have the same problems as with <i>exitKey</i>.
	/// </para>
	/// </param>
	/// <param name="f_">[](xref:caller_info). Don't use. Or use like <c>f_: null</c> to disable script editing via tray icon.</param>
	/// <exception cref="InvalidOperationException">Already called.</exception>
	/// <remarks>
	/// Tip: in <b>Options > Templates</b> you can set default code for new scripts.
	/// 
	/// If your program was compiled not in LibreAutomate, call this function (maybe with zero arguments) if you want the program behave like if it was compiled with LibreAutomate (invariant culture, <c>STAThread</c>, unhandled exception action).
	/// 
	/// Does nothing if role <c>editorExtension</c> or if running in WPF preview mode.
	/// </remarks>
	public static void setup(bool trayIcon = false, bool sleepExit = false, bool lockExit = false, bool debug = false, UExcept exception = UExcept.Print, KKey exitKey = 0, KKey pauseKey = KKey.ScrollLock, [CallerFilePath] string f_ = null) {
		if (role == SRole.EditorExtension || isWpfPreview) return;
		if (s_setupOnce) throw new InvalidOperationException("script.setup already called");
		s_setupOnce = true;
		
		s_setupException = exception;
		if (!s_appModuleInit) AppModuleInit_(auCompiler: false); //if role miniProgram, called by MiniProgram_.Init; else if default compiler, the call is compiled into code; else called now.
		
		if (debug) DebugTraceListener.Setup(usePrint: true); //info: default false, because slow and rarely used.
		
		s_exitKey = exitKey;
		s_pauseKey = pauseKey;
		s_pauseSetupDone = true;
		
		if (sleepExit || lockExit || exitKey != 0 || pauseKey is not (0 or KKey.CapsLock)) {
			s_sleepExit = sleepExit;
			s_lockExit = lockExit;
			s_exitKey = exitKey;
			s_auxThread.QueueAPC(static () => {
				if (s_sleepExit) {
					if (osVersion.minWin8) {
						//if Modern Standby, need RegisterSuspendResumeNotification to receive WM_POWERBROADCAST.
						//	The API and MS are unavailable on Win7.
						//	The API supports window handle and callback. With handle less problems.
						var h1 = Api.RegisterSuspendResumeNotification(s_auxWnd.Handle, 0);
						process.thisProcessExit += _ => { Api.UnregisterSuspendResumeNotification(h1); };
					} else {
						WndUtil.CreateWindowDWP_(messageOnly: false, t_eocWP = (w, m, wp, lp) => {
							if (m == Api.WM_POWERBROADCAST && wp == Api.PBT_APMSUSPEND) _SleepLockExit(true);
							return Api.DefWindowProc(w, m, wp, lp);
						}); //message-only windows don't receive WM_POWERBROADCAST, unless used RegisterSuspendResumeNotification
					}
				}
				
				if (s_lockExit) {
					new WinEventHook(EEvent.SYSTEM_DESKTOPSWITCH, 0, k => {
						if (miscInfo.isInputDesktop()) return;
						if (process.exists("consent.exe", ofThisSession: true)) return; //UAC
						k.hook.Dispose();
						_SleepLockExit(false);
					});
					//tested: on Win+L works immediately. OS switches desktop 2 times. At first briefly, then makes defaul again, then on key etc switches again to show password field.
				}
				
				if (s_exitKey != 0) {
					if (!_RegisterKey(s_exitKey, 16)) {
						long i1 = 0;
						timer.every(500, t => {
							if (_RegisterKey(s_exitKey, 16)) t.Stop();
							else if (++i1 == 4) print.warning($"{name}: script.setup failed to register the exit key. Will retry.", -1);
						});
					}
				}
				
				if (s_pauseKey is not (0 or KKey.CapsLock)) _PauseSetKey();
			});
		}
		
		if (trayIcon) _TrayIcon(f_: f_);
	}
	static bool s_setupOnce, s_sleepExit, s_lockExit;
	static KKey s_exitKey;
	[ThreadStatic] static WNDPROC t_eocWP;
	
	/// <summary>
	/// Ensures that multiple processes that call this function don't run simultaneously. Like C# <c>lock</c> keyword for threads.
	/// </summary>
	/// <param name="mutex">Mutex name. If another process called this function with this mutex name, this process cannot run, and this function calls <c>Environment.Exit(3);</c>.</param>
	/// <param name="wait">Milliseconds to wait until this process can run. No timeout if -1.</param>
	/// <param name="silent">Don't print <c>"cannot run"</c>.</param>
	/// <param name="ifCantRun">Called if this process cannot run.</param>
	/// <exception cref="InvalidOperationException">This function already called.</exception>
	/// <remarks>
	/// This function is useful when this script has role <c>exeProgram</c> and the compiled program is launched not from the script editor, because then the <c>/*/ ifRunning /*/</c> property is ignored.
	/// </remarks>
	/// <seealso cref="AppSingleInstance"/>
	public static void single(string mutex = "Au-mutex-script.single", int wait = 0, bool silent = false, Action ifCantRun = null) {
		//FUTURE: parameter bool endOther. Like meta ifRunning restart.
		
		var m = Api.CreateMutex(null, false, mutex ?? "Au-mutex-script.single"); //tested: don't need Api.SECURITY_ATTRIBUTES.ForLowIL
		if (default != Interlocked.CompareExchange(ref s_singleMutex, m, default)) { Api.CloseHandle(m); throw new InvalidOperationException(); }
		var r = Api.WaitForSingleObject(s_singleMutex, wait);
		if (r is not (0 or Api.WAIT_ABANDONED)) {
			ifCantRun?.Invoke();
			if (!silent) print.it($"<>Note: script task <open {sourcePath(true)}|||script.single>{name}<> cannot run because a task is running.");
			Environment.Exit(3);
		}
		//never mind: should release mutex.
		//	Cannot release in process exit event. It runs in another thread.
		//	Cannot use UsingEndAction, because then caller code must be like 'using var single = script.single();'.
		//return new(() => Api.ReleaseMutex(s_singleMutex));
	}
	static IntPtr s_singleMutex;
	
	/// <summary>
	/// Low-level version of <see cref="single"/>. No <c>Environment.Exit</c>, no exception, no print. Just <c>CreateMutex</c> and <c>WaitForSingleObject</c>.
	/// </summary>
	/// <returns>false if another process owns the mutex.</returns>
	internal static bool TrySingle_(string mutex, int wait = 0) => Api.WaitForSingleObject(Api.CreateMutex(null, false, mutex), wait) is 0 or Api.WAIT_ABANDONED;
	
	//public static bool single(out nint mutexHandle, string mutexName, int wait = 0) => Api.WaitForSingleObject(mutexHandle = Api.CreateMutex(null, false, mutexName), wait) is 0 or Api.WAIT_ABANDONED;
	
	/// <summary>
	/// Adds standard tray icon.
	/// </summary>
	/// <param name="delay">Delay, milliseconds.</param>
	/// <param name="init">Called before showing the tray icon. Can set its properties and event handlers.</param>
	/// <param name="menu">Called before showing context menu. Can add menu items. Menu item actions must not block messages etc for long time; if need, run in other thread or process (<see cref="script.run"/>).</param>
	/// <param name="f_">[](xref:caller_info). Don't use. Or set = <c>null</c> to disable script editing via the tray icon.</param>
	/// <remarks>
	/// Uses other thread. The <i>init</i> and <i>menu</i> actions run in that thread too. It dispatches messages, therefore they also can set timers (<see cref="timer"/>), create hidden windows, etc. Current thread does not have to dispatch messages.
	/// 
	/// Does nothing if role <c>editorExtension</c>.
	/// </remarks>
	/// <example>
	/// How to change icon and tooltip.
	/// <code><![CDATA[
	/// script.trayIcon(init: t => { t.Icon = icon.stock(StockIcon.HELP); t.Tooltip = "Example"; });
	/// ]]></code>
	/// How to add menu items.
	/// <code><![CDATA[
	/// script.trayIcon(menu: (t, m) => {
	/// 	m["Example"] = o => { dialog.show("Example"); };
	/// 	m["Run another script"] = o => { script.run("Example.cs"); };
	/// });
	/// ]]></code>
	/// </example>
	/// <seealso cref="Au.trayIcon"/>
	public static void trayIcon(int delay = 500, Action<trayIcon> init = null, Action<trayIcon, popupMenu> menu = null, [CallerFilePath] string f_ = null) {
		if (role == SRole.EditorExtension) return;
		if (!s_appModuleInit) AppModuleInit_(auCompiler: false);
		_TrayIcon(delay, init, menu, f_);
	}
	
	static void _TrayIcon(int delay = 500, Action<trayIcon> init = null, Action<trayIcon, popupMenu> menu = null, [CallerFilePath] string f_ = null) {
		s_auxThread.QueueAPC(() => timer.after(delay, _Delayed));
		
		void _Delayed(timer t_) {
			var ti = new trayIcon { Tooltip = script.name };
			init?.Invoke(ti);
			ti.Icon ??= icon.trayIcon();
			bool canEdit = f_ != null && ScriptEditor.Available;
			if (canEdit) ti.Click += _ => ScriptEditor.Open(f_);
			ti.RightClick += e => {
				var m = new popupMenu();
				if (menu != null) {
					menu(ti, m);
					if (m.Last != null && !m.Last.IsSeparator) m.Separator();
				}
				if (canEdit) m["Open script"] = _ => ScriptEditor.Open(f_);
				m["End task"] = _ => Environment.Exit(2);
				if (canEdit) m["End and open"] = _ => { ScriptEditor.Open(f_); Environment.Exit(2); };
				m.Show(PMFlags.AlignCenterH | PMFlags.AlignRectBottomTop, /*excludeRect: ti.GetRect(out var r1) ? r1 : null,*/ owner: ti.Hwnd);
			};
			ti.Visible = true;
		}
	}
	
	#endregion
	
	#region aux thread
	
	internal static unsafe void Starting_(string name, int pidEditor, bool preloaded = false) {
		s_name = name;
		s_auxThread = new(() => _AuxThread(pidEditor, preloaded));
		//using CreateThread because need thread handle ASAP
	}
	static NativeThread_ s_auxThread;
	
	/// <summary>
	/// Gets the aux thread object. Auto-creates (starts thread and does not wait) if used in an app that does not call <c>Starting_</c> at startup (compiled not by LA).
	/// Thread-safe.
	/// </summary>
	internal static NativeThread_ GetAuxThread_() {
		if (s_auxThread != null) return s_auxThread;
		Debug.Assert(role != SRole.MiniProgram);
		lock ("s_auxThread") {
			return s_auxThread ??= new(() => _AuxThread(0, false));
		}
	}
	
	//Auxiliary thread for various tasks:
	//	Exit when editor process terminated or crashed.
	//	Terminate script processes in a less brutal way.
	//	Tray icon.
	//	script.setup(sleepExit, lockExit)
	//	Cpp_InactiveWindowWorkaround for miniProgram.
	//	Can be used for various triggers.
	//	Etc.
	static unsafe void _AuxThread(int pidEditor, bool preloaded) {
		Thread.CurrentThread.Name = "Au.Aux";
		WndUtil.UacEnableMessages(Api.WM_COPYDATA, Api.WM_USER, Api.WM_CLOSE, c_msg_IconImageCache_ClearAll);
		WndUtil.RegisterWindowClass(c_auxWndClassName, _AuxWndProc);
		s_auxWnd = WndUtil.CreateMessageOnlyWindow(c_auxWndClassName, Api.GetCurrentProcessId().ToS());
		
		_MessageLoop(pidEditor, preloaded);
		
		[MethodImpl(MethodImplOptions.NoInlining)] //need fast JIT of the main func, to make s_auxWnd available ASAP
		static void _MessageLoop(int pidEditor, bool preloaded) {
			//pidEditor 0 if exeProgram started not from editor
			var hp = pidEditor == 0 ? default : (IntPtr)Handle_.OpenProcess(pidEditor, Api.SYNCHRONIZE);
			
			//Cpp.Cpp_UEF(true); //moved to AppModuleInit_
			
			if (preloaded) Cpp.Cpp_InactiveWindowWorkaround(true);
			
			NativeThread_.OfThisThread.ThreadInited();
			
			int nh = hp == default ? 0 : 1;
			for (; ; ) {
				var k = Api.MsgWaitForMultipleObjectsEx(nh, &hp, -1, Api.QS_ALLINPUT, Api.MWMO_ALERTABLE | Api.MWMO_INPUTAVAILABLE);
				if (k == nh) {
					if (!wait.doEvents()) break;
				} else if (k == 0) { //editor process terminated or crashed
					_AuxExit();
				} else if (k != Api.WAIT_IO_COMPLETION) {
					Debug_.Print(k);
					break;
				}
			}
		}
	}
	
	/// <summary>
	/// Class name of the auxiliary message-only window.
	/// </summary>
	internal const string c_auxWndClassName = "Au.Task.m3gVxcTJN02pDrHiQ00aSQ";
	
	static unsafe nint _AuxWndProc(wnd w, int message, nint wp, nint lp) {
		switch (message) {
		//case Api.WM_COPYDATA:
		//	return 0;
		//case Api.WM_USER:
		//	return 0;
		case Api.WM_POWERBROADCAST:
			if (s_sleepExit && osVersion.minWin8 && wp == Api.PBT_APMSUSPEND) _SleepLockExit(true);
			break;
		case Api.WM_HOTKEY:
			if (wp is >= 0 and <= 15) {
				s_paused ^= true;
			} else if (wp is >= 16 and <= 31) {
				Environment.Exit(2);
			}
			break;
		case c_msg_IconImageCache_ClearAll:
			IconImageCache.ClearAll_();
			break;
		case Api.WM_SETTEXT when wp != 0:
			try {
				string s = new((char*)lp);
				if (wp == c_msg_wmsettext_UpdateEnvVar) { //sent from LA by EnvVarUpdater on WM_SETTINGCHANGE
					var csv = csvTable.parse(s);
					foreach (var a in csv.Rows) Environment.SetEnvironmentVariable(a[0], a[1]);
				}
			}
			catch (Exception e1) { Debug_.Print(e1); }
			return 0;
		}
		
		var R = Api.DefWindowProc(w, message, wp, lp);
		
		if (message == Api.WM_DESTROY) _AuxExit();
		
		return R;
	}
	
	internal const int c_msg_IconImageCache_ClearAll = Api.WM_USER + 5;
	internal const int c_msg_wmsettext_UpdateEnvVar = -100;
	
	static void _AuxExit() {
		Environment.Exit(1);
		
		//same speed
		//process.thisProcessExitInvoke();
		//Api.ExitProcess(1);
	}
	
	/// <summary>
	/// Gets the message-only window of the aux thread.
	/// Waits if still not created.
	/// </summary>
	internal static wnd AuxWnd_ {
		get {
			if (s_auxWnd.Is0) {
				GetAuxThread_();
				while (s_auxWnd.Is0) {
					Debug_.Print("waiting for s_auxWnd");
					Thread.Sleep(12);
				}
			}
			return s_auxWnd;
		}
	}
	static wnd s_auxWnd;
	
	#endregion
	
	#region run
	
	/// <summary>
	/// Starts executing a script. Does not wait.
	/// </summary>
	/// <param name="script">Script name like <c>"Script5.cs"</c>, or path like <c>@"\Folder\Script5.cs"</c>.</param>
	/// <param name="args">Command line arguments. In the script it will be variable <i>args</i>. Should not contain <c>'\0'</c> characters.</param>
	/// <returns>
	/// Native process id of the task process.
	/// Returns -1 if failed, for example if the script contains errors or cannot run second task instance.
	/// Returns 0 if task start is deferred because the script is running (<c>ifRunning</c> <c>wait</c>/<c>wait_restart</c>).
	/// If role <c>editorExtension</c>, waits until the script ends, then returns 0.
	/// </returns>
	/// <exception cref="FileNotFoundException">Script file not found.</exception>
	/// <exception cref="AuException">Script editor not running.</exception>
	public static int run([ParamString(PSFormat.CodeFile)] string script, params string[] args)
		=> _Run(0, script, args, out _);
	
	/// <summary>
	/// Starts executing a script and waits until the task ends.
	/// </summary>
	/// <returns>The exit code of the task process. See <see cref="Environment.ExitCode"/>.</returns>
	/// <exception cref="FileNotFoundException">Script file not found.</exception>
	/// <exception cref="AuException">Failed to start script task. For example: the script contains errors; cannot start second task instance; script editor not running.</exception>
	/// <inheritdoc cref="run"/>
	public static int runWait([ParamString(PSFormat.CodeFile)] string script, params string[] args)
		=> _Run(1, script, args, out _);
	
	/// <summary>
	/// Starts executing a script, waits until the task ends and then gets <see cref="writeResult"/> text.
	/// </summary>
	/// <param name="results">Receives <see cref="writeResult"/> text.</param>
	/// <returns>The exit code of the task process. See <see cref="Environment.ExitCode"/>.</returns>
	/// <exception cref="FileNotFoundException">Script file not found.</exception>
	/// <exception cref="AuException">Failed to start script task. For example: the script contains errors; cannot start second task instance; script editor not running.</exception>
	/// <inheritdoc cref="run"/>
	public static int runWait(out string results, [ParamString(PSFormat.CodeFile)] string script, params string[] args)
		=> _Run(3, script, args, out results);
	
	/// <summary>
	/// Starts executing a script, waits until the task ends and gets <see cref="writeResult"/> text in real time.
	/// </summary>
	/// <param name="results">Receives <see cref="writeResult"/> output whenever the task calls it.</param>
	/// <returns>The exit code of the task process. See <see cref="Environment.ExitCode"/>.</returns>
	/// <exception cref="FileNotFoundException">Script file not found.</exception>
	/// <exception cref="AuException">Failed to start script task. For example: the script contains errors; cannot start second task instance; script editor not running.</exception>
	/// <inheritdoc cref="run"/>
	public static int runWait(Action<string> results, [ParamString(PSFormat.CodeFile)] string script, params string[] args)
		=> _Run(3, script, args, out _, results);
	
	//mode flags: 1 - wait, 3 - wait and get script.writeResult output, 4 restarting
	static int _Run(int mode, string script, string[] args, out string resultS, Action<string> resultA = null) {
		resultS = null;
		
		var w = ScriptEditor.WndMsg_; if (w.Is0) throw new AuException("Editor process not found.");
		//CONSIDER: run editor program, if installed
		
		bool wait = 0 != (mode & 1), needResult = 0 != (mode & 2);
		using var tr = new _TaskResults();
		if (needResult && !tr.Init()) throw new AuException("*get task results");
		
		var data = Serializer_.Serialize(script, args, tr.pipeName);
		int pid = (int)WndCopyData.Send<byte>(w, 100, data, mode);
		if (pid == 0) pid--; //RunResult_.failed
		
		switch ((RunResult_)pid) {
		case RunResult_.failed:
			return !wait ? -1 : throw new AuException("*start task");
		case RunResult_.notFound:
			throw new FileNotFoundException($"Script '{script}' not found.");
		case RunResult_.deferred: //possible only if !wait
		case RunResult_.editorThread: //the script ran sync and already returned
			return 0;
		}
		
		if (wait) {
			using var hProcess = WaitHandle_.FromProcessId(pid, Api.SYNCHRONIZE | Api.PROCESS_QUERY_LIMITED_INFORMATION);
			if (hProcess == null) throw new AuException("*wait for task");
			
			if (!needResult) hProcess.WaitOne(-1);
			else if (!tr.WaitAndRead(hProcess, resultA)) throw new AuException("*get task result");
			else if (resultA == null) resultS = tr.ResultString;
			
			if (!Api.GetExitCodeProcess(hProcess.SafeWaitHandle.DangerousGetHandle(), out pid)) pid = int.MinValue;
		}
		return pid;
	}
	
	//Called from editor's CommandLine. Almost same as _Run. Does not throw.
	internal static int RunCL_(wnd w, int mode, string script, string[] args, Action<string> resultA, int schedPid = 0) {
		bool wait = 0 != (mode & 1), needResult = 0 != (mode & 2);
		using var tr = new _TaskResults();
		if (needResult && !tr.Init()) return (int)RunResult_.cannotGetResult;
		
		var data = Serializer_.Serialize(script, args, tr.pipeName, schedPid);
		int taskProcessId = (int)WndCopyData.Send<byte>(w, 101, data, mode);
		if (taskProcessId == 0) taskProcessId--; //RunResult_.failed
		
		switch ((RunResult_)taskProcessId) {
		case RunResult_.failed:
		case RunResult_.notFound:
			return taskProcessId;
		case RunResult_.deferred: //possible only if !wait
		case RunResult_.editorThread: //the script ran sync and already returned. Ignore needResult, as it it auto-detected, not explicitly specified.
			return 0;
		}
		
		if (wait) {
			using var hProcess = WaitHandle_.FromProcessId(taskProcessId, Api.SYNCHRONIZE | Api.PROCESS_QUERY_LIMITED_INFORMATION);
			if (hProcess == null) return (int)RunResult_.cannotWait;
			
			if (!needResult) hProcess.WaitOne(-1);
			else if (!tr.WaitAndRead(hProcess, resultA)) return (int)RunResult_.cannotWaitGetResult;
			
			if (!Api.GetExitCodeProcess(hProcess.SafeWaitHandle.DangerousGetHandle(), out taskProcessId)) taskProcessId = int.MinValue;
		}
		return taskProcessId;
	}
	
	internal enum RunResult_ {
		//errors returned by sendmessage(wm_copydata)
		failed = -1, //script contains errors, or cannot run because of ifRunning, or sendmessage(wm_copydata) failed
		notFound = -2, //script not found
		deferred = -3, //script cannot run now, but will run later if don't need to wait. If need to wait, in such case cannot be deferred (then failed).
		editorThread = -4, //role editorExtension
		
		//other errors
		noEditor = -5,
		cannotWait = -6,
		cannotGetResult = -7,
		cannotWaitGetResult = -8,
	}
	
	unsafe struct _TaskResults : IDisposable {
		Handle_ _hPipe;
		public string pipeName;
		string _s;
		StringBuilder _sb;
		
		public bool Init() {
			var tid = Api.GetCurrentThreadId();
			pipeName = @"\\.\pipe\Au.CL-" + tid.ToString(); //will send this string to the task
			_hPipe = Api.CreateNamedPipe(pipeName,
				Api.PIPE_ACCESS_INBOUND | Api.FILE_FLAG_OVERLAPPED, //use async pipe because also need to wait for task process exit
				Api.PIPE_TYPE_MESSAGE | Api.PIPE_READMODE_MESSAGE | Api.PIPE_REJECT_REMOTE_CLIENTS,
				1, 0, 0, 0, Api.SECURITY_ATTRIBUTES.ForPipes);
			return !_hPipe.Is0;
		}
		
		public bool WaitAndRead(WaitHandle hProcess, Action<string> results) {
			bool R = false;
			char* b = null; const int bLen = 7900;
			var ev = new ManualResetEvent(false);
			try {
				var ha = new WaitHandle[2] { ev, hProcess };
				for (bool useSB = false; ; useSB = results == null) {
					var o = new Api.OVERLAPPED { hEvent = ev.SafeWaitHandle.DangerousGetHandle() };
					if (!Api.ConnectNamedPipe(_hPipe, &o)) {
						int e = lastError.code;
						if (e != Api.ERROR_PIPE_CONNECTED) {
							if (e != Api.ERROR_IO_PENDING) break;
							int wr = WaitHandle.WaitAny(ha);
							if (wr != 0) { Api.CancelIo(_hPipe); R = true; break; } //task ended
							if (!Api.GetOverlappedResult(_hPipe, ref o, out _, false)) { Api.DisconnectNamedPipe(_hPipe); break; }
						}
					}
					
					if (b == null) b = (char*)MemoryUtil.Alloc(bLen);
					bool readOK;
					while (((readOK = Api.ReadFile(_hPipe, b, bLen, out int n, null)) || (lastError.code == Api.ERROR_MORE_DATA)) && n > 0) {
						n /= 2;
						if (!readOK) useSB = true;
						if (useSB) { //rare
							_sb ??= new StringBuilder(bLen);
							if (results == null && _s != null) _sb.Append(_s);
							_s = null;
							_sb.Append(b, n);
						} else {
							_s = new string(b, 0, n);
						}
						if (readOK) {
							if (results != null) {
								results(ResultString);
								_sb?.Clear();
							}
							break;
						}
						//note: MSDN says must use OVERLAPPED with ReadFile too, but works without it.
					}
					Api.DisconnectNamedPipe(_hPipe);
					if (!readOK) break;
				}
			}
			finally {
				ev.Dispose();
				MemoryUtil.Free(b);
			}
			return R;
		}
		
		public string ResultString => _s ?? _sb?.ToString();
		
		public void Dispose() => _hPipe.Dispose();
	};
	
	/// <summary>
	/// Writes a string result for the task that called <see cref="runWait(out string, string, string[])"/> or <see cref="runWait(Action{string}, string, string[])"/> to run this task, or for the program that started this task using command line like <c>"Au.Editor.exe *Script5.cs"</c>.
	/// </summary>
	/// <returns><c>false</c> if this task was not started in such a way. Or if failed to write, except when <i>s</i> is <c>null</c>/<c>""</c>.</returns>
	/// <param name="s">A string. This function does not append newline characters.</param>
	/// <remarks>
	/// <see cref="runWait(Action{string}, string, string[])"/> can read the string in real time.
	/// <see cref="runWait(out string, string, string[])"/> gets all strings joined when the task ends.
	/// The program that started this task using command line like <c>"Au.Editor.exe *Script5.cs"</c> can read the string from the redirected standard output in real time, or the string is displayed to its console in real time. The string encoding is UTF-8; if you use a <c>.bat</c> file or <c>cmd.exe</c> and want to get correct Unicode text, execute this before, to change console code page to UTF-8: <c>chcp 65001</c>.
	/// 
	/// Does not work if script role is <c>editorExtension</c>.
	/// </remarks>
#if true
	public static unsafe bool writeResult(string s) {
		if (s_wrPipeName == null) return false;
		if (s.NE()) return true;
		if (Api.WaitNamedPipe(s_wrPipeName, 3000)) { //15 mcs
			using var pipe = Api.CreateFile(s_wrPipeName, Api.GENERIC_WRITE, 0, Api.OPEN_EXISTING, 0); //7 mcs
			if (!pipe.Is0) {
				fixed (char* p = s) if (Api.WriteFile(pipe, p, s.Length * 2, out _)) return true; //17 mcs
			}
		}
		Debug_.PrintNativeError();
		return false;
		//TODO3: optimize. Eg the app may override TextWriter.Write(char) and call this on each char in a string etc.
		//	Now 40 mcs. Console.Write(char) 20 mcs.
	}
	internal static string s_wrPipeName;
#else //does not work
	public static unsafe bool writeResult(string s) {
		if (s_wrPipeName == null) return false;
		if (s.NE()) return true;
		if (s_wrPipe.Is0) {
			if (Api.WaitNamedPipe(s_wrPipeName, 3000)) { //15 mcs
				lock (s_wrPipeName) {
					if (s_wrPipe.Is0) {
						s_wrPipe = Api.CreateFile(s_wrPipeName, Api.GENERIC_WRITE, 0, default, Api.OPEN_EXISTING, 0);
					}
				}
			}
			Debug_.PrintNativeError_(s_wrPipe.Is0);
		}
		if (!s_wrPipe.Is0) {
			fixed (char* p = s)
				if (Api.WriteFile(s_wrPipe, p, s.Length * 2, out _)) return true; //17 mcs
				else Debug_.PrintNativeError_(); //No process is on the other end of the pipe (0xE9)
		}
		return false;
	}
	static string s_wrPipeName;
	static Handle_ s_wrPipe;
#endif
	
	/// <summary>
	/// Starts this script or program again.
	/// </summary>
	/// <param name="args">Command line arguments. Should not contain <c>'\0'</c> characters.</param>
	/// <returns>
	/// Native process id of the new process. Returns -1 if failed.
	/// </returns>
	/// <exception cref="FileNotFoundException">Script file not found.</exception>
	/// <exception cref="InvalidOperationException">This script has role <c>editorExtension</c>.</exception>
	/// <remarks>
	///	Does not end this process. The new process runs simultaneously, like with <c>/*/ ifRunning run; /*/</c>. Let this process exit as it wants, for example return from the main script code.
	///
	/// If this process was started by LibreAutomate, the new process will be started by LibreAutomate too. Else this function simply starts a new instance of this program.
	/// </remarks>
	public static int restart(params string[] args) {
		if (s_idMainFile != 0) return _Run(4, $":{s_idMainFile}", args, out _);
		if (role != SRole.ExeProgram) throw new InvalidOperationException(); //editorExtension
		
		var ps = new ProcessStarter_(process.thisExePath, StringUtil.CommandLineFromArray(args), null, rawExe: true);
		try { return ps.Start(inheritUiaccess: true).pid; }
		catch (Exception e1) { print.warning(e1); return -1; }
	}
	
	internal static uint s_idMainFile;
	
	/// <summary>
	/// Starts executing a script in child session running in picture-in-picture (PiP) window. Does not wait.
	/// </summary>
	/// <param name="script">Script name like <c>"Script5.cs"</c>, or path like <c>@"\Folder\Script5.cs"</c>.</param>
	/// <param name="args">Command line arguments. In the script it will be variable <i>args</i>. Should not contain <c>'\0'</c> characters.</param>
	/// <exception cref="FileNotFoundException">Script file not found.</exception>
	/// <exception cref="AuException">Script editor not running (in this session). No exception if cannot run the script in PiP session.</exception>
	public static void runInPip([ParamString(PSFormat.CodeFile)] string script, params string[] args) {
		var w = ScriptEditor.WndMsg_; if (w.Is0) throw new AuException("Editor process not found.");
		//CONSIDER: run editor program, if installed
		
		var data = Serializer_.Serialize(script, args);
		RunResult_ r = (RunResult_)WndCopyData.Send<byte>(w, 102, data);
		
		switch (r) {
		//case RunResult_.failed:
		//	throw new AuException("*start task in PiP");
		case RunResult_.notFound:
			throw new FileNotFoundException($"Script '{script}' not found.");
		}
	}
	
	/// <summary>
	/// Returns true if this process is running in a child session (aka Picture-in-Picture).
	/// This function is an alias of <see cref="miscInfo.isChildSession"/>.
	/// </summary>
	public static bool isInPip => miscInfo.isChildSession;
	
	#endregion
	
	#region end
	
	/// <summary>
	/// Ends this process.
	/// </summary>
	/// <remarks>
	/// Calls <see cref="Environment.Exit"/>.
	/// 
	/// It executes process exit event handlers. Does not execute <c>finally</c> code blocks. Does not execute GC.
	/// </remarks>
	public static void end() {
		Environment.Exit(0);
	}
	
	/// <summary>
	/// Ends another script process.
	/// </summary>
	/// <param name="processId">Script process id, for example returned by <see cref="script.run"/>.</param>
	/// <returns><c>true</c> if ended, <c>false</c> if failed, <c>null</c> if wasn't running.</returns>
	/// <exception cref="ArgumentException"><i>processId</i> is 0 or id of this process.</exception>
	/// <remarks>
	/// The script process can be started from editor or not.
	/// 
	/// The process executes process exit event handlers. Does not execute <c>finally</c> code blocks and GC.
	/// 
	/// Returns <c>null</c> if <i>processId</i> is invalid (probably because the script is already ended). Returns <c>false</c> if <i>processId</i> is valid but not of a script process (probably the script ended long time ago and the id is reused for another process).
	/// </remarks>
	public static bool? end(int processId) {
		if (processId == 0 || processId == Api.GetCurrentProcessId()) throw new ArgumentException();
		
		using var h = Handle_.OpenProcess(processId, Api.SYNCHRONIZE | Api.PROCESS_TERMINATE); //tested: UAC OK
		if (h.Is0) {
			if (lastError.code == Api.ERROR_INVALID_PARAMETER) return null;
			return false;
		}
		if (Api.WaitForSingleObject(h, 0) == 0) return null;
		
		var w = wait.until(-1d, () => wnd.findFast(processId.ToS(), c_auxWndClassName, messageOnly: true));
		if (w.Is0) return 0 == Api.WaitForSingleObject(h, 1000); //don't terminate, maybe it's not a script process
		w.Post(Api.WM_CLOSE);
		if (0 == Api.WaitForSingleObject(h, 1000)) return true;
		
		if (!Api.TerminateProcess(h, -1))
			return 0 == Api.WaitForSingleObject(h, 500); //TerminateProcess ERROR_ACCESS_DENIED when the process is ending
		Api.WaitForSingleObject(h, 500); //TerminateProcess is async. Usually the process ends after several ms.
		return true;
	}
	
	/// <summary>
	/// Ends all task processes of a script.
	/// </summary>
	/// <param name="name">
	/// Script file name (like <c>"Script43.cs"</c>) or path in workspace (like <c>@"\Folder\Script43.cs"</c>), or full file path.
	/// If <c>""</c>, ends all other processes of this script.
	/// </param>
	/// <returns><c>true</c> if ended, <c>false</c> if failed (probably file not found), <c>null</c> if wasn't running.</returns>
	/// <exception cref="AuException">Editor process not found.</exception>
	/// <remarks>
	/// Can end only script processes started from the editor.
	/// 
	/// The process executes process exit event handlers. Does not execute <c>finally</c> code blocks and GC.
	/// </remarks>
	public static bool? end([ParamString(PSFormat.CodeFile)] string name) {
		var w = ScriptEditor.WndMsg_; if (w.Is0) throw new AuException("Editor process not found.");
		int exceptPid = 0; if (name == "") (name, exceptPid) = ($":{s_idMainFile}", Api.GetCurrentProcessId());
		int r = (int)WndCopyData.Send<char>(w, 5, name, exceptPid);
		return r == 1 ? true : r == 2 ? null : false;
	}
	
	/// <summary>
	/// Returns <c>true</c> if the specified script task is running.
	/// </summary>
	/// <param name="name">Script file name (like <c>"Script43.cs"</c>) or path in workspace (like <c>@"\Folder\Script43.cs"</c>), or full file path.</param>
	public static bool isRunning([ParamString(PSFormat.CodeFile)] string name) {
		var w = ScriptEditor.WndMsg_; if (w.Is0) return false;
		return 0 != WndCopyData.Send<char>(w, 6, name);
	}
	
	/// <summary>
	/// Returns <c>true</c> if the specified script task is running.
	/// </summary>
	/// <param name="processId">Script process id, for example returned by <see cref="script.run"/>.</param>
	/// <exception cref="ArgumentException"><i>processId</i> is 0 or id of this process.</exception>
	/// <remarks>
	/// The script process can be started from editor or not.
	/// </remarks>
	public static bool isRunning(int processId) {
		if (processId == 0 || processId == Api.GetCurrentProcessId()) throw new ArgumentException();
		
		using var h = Handle_.OpenProcess(processId, Api.SYNCHRONIZE);
		if (h.Is0 || Api.WaitForSingleObject(h, 0) == 0) return false;
		
		var w1 = wait.until(-0.5, () => wnd.findFast(processId.ToS(), script.c_auxWndClassName, messageOnly: true));
		return !w1.Is0;
	}
	
	#endregion
	
	#region debug, pause
	
	/// <summary>
	/// Attaches the LibreAutomate's debugger to this process, or waits for a debugger attached to this process.
	/// Does nothing if a debugger is already attached.
	/// </summary>
	/// <param name="showDialog">Show dialog with process name and id. If <c>false</c>, attaches the LA debugger.</param>
	/// <remarks>
	/// When debugger is attached, this function returns and the script continues to run. The step mode begins when the script encounters one of:
	/// - breakpoint (set in the debugger's IDE).
	/// - exception.
	/// - clicked <b>Pause</b> button in IDE.
	/// - <see cref="Debugger.Break"/>, <see cref="Debug.Assert(bool)"/> etc.
	/// 
	/// If <i>showDialog</i> is <c>false</c> and LibreAutomate is running, attaches the LA debugger. Cannot attach if it's busy (debugging).
	/// 
	/// Some other programs that have a .NET debugger:
	/// - Visual Studio. It's the best, but huge (~10 GB). The community edition is free. Use menu <b>Debug > Attach to process</b>.
	/// - Visual Studio Code. It's much smaller. Free.
	/// - JetBrains Rider.
	/// 
	/// <note>If the script process is running as administrator, the debugger process must run as administrator too.</note>
	/// 
	/// <note>When attaching an external debugger (Visual Studio etc), make sure it debugs .NET code, not native code etc.</note>
	/// 
	/// See also [](xref:debugger).
	/// </remarks>
	[DebuggerStepThrough]
	public static void debug(bool showDialog = false) {
		if (Debugger.IsAttached) return;
		if (!showDialog && ScriptEditor.WndMsg_ is var w && !w.Is0) {
			if (0 != w.Send(Api.WM_USER, 30, process.thisProcessId)) {
				if (wait.until(-30, () => Debugger.IsAttached)) return;
			}
			end();
		}
		var d = new dialog("Waiting for debugger to attach", $"{script.name}\nProcess: {process.thisExeName}  {process.thisProcessId}", title: "Attach debugger");
		d.InScreen(screen.ofMouse);
		d.ShowDialogNoWait();
		wait.until(0, () => Debugger.IsAttached);
		d.Send.Close();
		
		//note: don't add Debugger.Break(); in this func. It creates problems.
	}
	
	/// <summary>
	/// If was pressed the pause key, waits until the user presses it again.
	/// </summary>
	/// <param name="text">Text to display in the "Paused script" UI.</param>
	/// <param name="doEvents">Process Windows messages and other events while waiting. For example, windows of this thread can respond, and timers of this thread can run.</param>
	/// <remarks>
	/// The default pause key is <c>ScrollLock</c> (<c>Fn+S</c>, <c>Fn+K</c> or similar). To change, use <see cref="setup"/> parameter <i>pauseKey</i>. If <c>script.setup</c> not called, this function uses <c>ScrollLock</c> but does not pause when called the first time.
	///
	/// A script can be paused only if it calls this function. Pausing at a random place would be dangerous and is not supported. Call this function in places where it is safe to pause, and where it makes sense, for example in a loop that preses keys or mouse buttons. To pause/resume, let the user press the pause key.
	///
	/// If the pause key is <c>CapsLock</c>, waits if it is toggled, even if was toggled when this script started.
	/// </remarks>
	/// <example>
	/// <code><![CDATA[
	/// script.setup(trayIcon: true, pauseKey: KKey.MediaPlayPause);
	/// using var t = osdText.showTransparentText("         ", -1);
	/// for (int i = 0; i < 1000; i++) {
	/// 	script.pause();
	/// 	//script.pause("Next: continue the loop.");
	/// 	t.Text = i.ToS();
	/// 	250.ms();
	/// }
	/// ]]></code>
	/// </example>
	public static void pause(string text = null, bool doEvents = false) {
		if (!s_pauseSetupDone) { //script.setup not called
			s_pauseSetupDone = true;
			s_pauseWhenUntoggled = keys.gui.isToggled(s_pauseKey = KKey.ScrollLock);
			return;
		}
		
		if (paused) {
			var s = $"Paused: {script.name}.";
			if (s_pauseKey != 0) s += $"\nKey: {s_pauseKey}.";
			if (!text.NE()) s += $"\n{text}";
			using var icon = ImageUtil.LoadGdipBitmapFromXaml("<Viewbox Width='32' Height='32' xmlns='http://schemas.microsoft.com/winfx/2006/xaml/presentation'><Path Data='M13,16V8H15V16H13M9,16V8H11V16H9M12,2A10,10 0 0,1 22,12A10,10 0 0,1 12,22A10,10 0 0,1 2,12A10,10 0 0,1 12,2M12,4A8,8 0 0,0 4,12A8,8 0 0,0 12,20A8,8 0 0,0 20,12A8,8 0 0,0 12,4Z' Stretch='Uniform' Fill='#FFD631' UseLayoutRounding='False' SnapsToDevicePixels='False' /></Viewbox>", screen.primary.Dpi);
			using (osdText.showText(s, -1, new(y: ^10), icon, 0xffffff, 0x444444, showMode: OsdMode.WeakThread)) {
				wait.until(new(0) { Period = 2, DoEvents = doEvents }, () => !paused);
			}
		}
	}
	//FUTURE: UI to end task when paused.
	//CONSIDER: add option to save-restore mouse xy, active window, its state.
	//CONSIDER: auto call pause in key/mouse/etc functions if there are no pressed modifier keys and mouse buttons.
	
	/// <summary>
	/// If <c>true</c>, next call to <see cref="pause"/> will wait until <c>false</c>, or already is waiting.
	/// </summary>
	public static bool paused {
		get => s_paused || (_PauseIsLockKey && keys.gui.isToggled(s_pauseKey) != s_pauseWhenUntoggled);
		set { s_paused = value; }
	}
	
	//in aux thread
	static void _PauseSetKey() {
		if (_PauseIsLockKey) {
			s_pauseWhenUntoggled = keys.gui.isToggled(s_pauseKey);
		} else {
			if (!_RegisterKey(s_pauseKey, 0)) {
				//print.warning("script.setup failed to register the pause key. Will use ScrollLock.", -1);
				//s_pauseWhenUntoggled = keys.gui.isToggled(s_pauseKey = KKey.ScrollLock);
				
				long i1 = 0;
				timer.every(500, t => {
					if (_RegisterKey(s_pauseKey, 0)) t.Stop();
					else if (++i1 == 4) print.warning($"{name}: script.setup failed to register the pause key. Will retry.", -1);
				});
			}
		}
	}
	static KKey s_pauseKey;
	static bool s_paused, s_pauseSetupDone, s_pauseWhenUntoggled;
	
	static bool _PauseIsLockKey => s_pauseKey is KKey.ScrollLock or KKey.CapsLock or KKey.NumLock;
	
	#endregion
	
	#region util
	
	static void _SleepLockExit(bool sleep) {
		print.it($"<>Info: task <open {sourcePath(true)}|||script.setup>{name}<> ended because of {(sleep ? "PC sleep" : "switched desktop")} at {DateTime.Now.ToShortTimeString()}.");
		Task.Run(() => Environment.Exit(2));
		//why Task.Run: with RegisterSuspendResumeNotification does not work well in same thread.
	}
	
	static bool _RegisterKey(KKey key, int idBase) {
		return Api.RegisterHotKey(s_auxWnd, idBase, Api.MOD_NOREPEAT, key);
		
		//rejected: try to register all mod combinations. Else does not work if the script pressed a mod key at that time.
		//		for (int i = 0; i < 16; i++) {
		//			var k = key;
		//			if (k == KKey.Pause && 0 != (i & Api.MOD_CONTROL)) k = KKey.Break; //Ctrl+Pause = Break
		//			if (!Api.RegisterHotKey(s_auxWnd, idBase + i, (uint)i | Api.MOD_NOREPEAT, k)) {
		//#if !true
		//				//print.it(i, k, s_auxWnd, lastError.message);
		//				if (k == KKey.Pause && i == 8) continue; //Win+Pause opens something in Windows Settings
		//				while (--i >= 0) Api.UnregisterHotKey(s_auxWnd, idBase + i);
		//				return false;
		//				//any failed to register hotkey would be dangerous, because the user-pressed key combined with script-pressed modifiers would invoke the hotkey in its owner app
		
		//				//Not good. Many keys fail because a hotkey with some modifiers is registered. Eg Esc, arrows, Home. Many are registered by OS with mod Win.
		//				//	Maybe instead just print warning "Failed to register hotkey X. It can be dangerous... Consider using media keys etc instead.". Fail only if cannot register the key without modifiers.
		//				//	Or use LL hook. Then can detect script-pressed keys. But no, it's too heavy; maybe every script will have script.setup with that key.
		//#else
		//				if (i == 0) return false;
		//#endif
		//			}
		//		}
		//		return true;
	}
	
	#endregion
}


================================================
FILE: Au/Resources/AssemblyInfo.cs
================================================

[assembly: AssemblyTitle("Au")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
//more in global2.cs

// The following GUID is for the ID of the typelib if this project is exposed to COM
[assembly: Guid("d3087fac-a12d-4365-a620-7574cd89b17f")]

// Version information for an assembly consists of the following four values:
//
//      Major Version
//      Minor Version 
//      Build Number
//      Revision
//
// You can specify all the values or you can default the Build and Revision Numbers 
// by using the '*' as shown below:
// [assembly: AssemblyVersion("1.0.*")]
//[assembly: AssemblyVersion("1.0.0.*")]
//[assembly: AssemblyVersion("1.0.1.0")] //moved to global2.cs
//rejected: auto increment.
//	Creates more problems and work than is useful. Eg after modifying this project always need to rebuild all exe projects, else fails to load this dll.
//	VS adds 20-300 to the revision at each build. Why not 1? Now ~ 23000. What happens when it becomes the max possible 0xffff?
//	VS does not auto-increment the build number when "1.0.*". Now 7288. Where it gets these values? And does not reset them when I change eg minor.

//[assembly: AssemblyFileVersion("1.0.0.0")]

//This can be used eg to find public/protected _Identifier.
//However most warnings are about uint. We disable them in project Properties: 3001,3002,3003,3009.
//[assembly: CLSCompliant(true)] //rejected. It isn't.

#if IDE_LA
[assembly: InternalsVisibleTo("Au.Editor")]
[assembly: InternalsVisibleTo("Au.Controls")]
#else
[assembly: InternalsVisibleTo("Au.Editor, PublicKey=0024000004800000940000000602000000240000525341310004000001000100095c6b7a0fe60fbe4a77e52dd10a09331ee3c3a7399aa9cc17db8a015647469a19784d5e33a2450a0a49c37bf17c0c3223674f64104eae649ba27c51a90c24989faec87d59217d7850efc8151109bbf9b027b7714fc01788317d2b991b2c2669836a7725e942f76607efde5cdacd8c497a45c5f9673fcf102fdbf92237a524a4")]
[assembly: InternalsVisibleTo("Au.Controls, PublicKey=0024000004800000940000000602000000240000525341310004000001000100095c6b7a0fe60fbe4a77e52dd10a09331ee3c3a7399aa9cc17db8a015647469a19784d5e33a2450a0a49c37bf17c0c3223674f64104eae649ba27c51a90c24989faec87d59217d7850efc8151109bbf9b027b7714fc01788317d2b991b2c2669836a7725e942f76607efde5cdacd8c497a45c5f9673fcf102fdbf92237a524a4")]
#endif

[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/qgindi/LibreAutomate")]


================================================
FILE: Au/String/ExtString.cs
================================================
//FUTURE: now in intellisense RStr methods are mixed with that of string. Many of them are not useful. Maybe .NET 10 or later will add an attribute to clean it up.

using System.Buffers;

namespace Au.Types;

/// <summary>
/// Adds extension methods for <see cref="String"/>.
/// </summary>
/// <remarks>
/// Some .NET <see cref="String"/> methods use <see cref="StringComparison.CurrentCulture"/> by default, while others use ordinal or invariant comparison. It is confusing (difficult to remember), dangerous (easy to make bugs), slower and rarely useful.
/// Microsoft recommends to specify <see cref="StringComparison.Ordinal"/> <see cref="StringComparison.OrdinalIgnoreCase"/>. See <google>Best practices for comparing strings in .NET</google>.
/// This class adds ordinal comparison versions of these methods. Same or similar name, for example <c>Ends</c> for <c>EndsWith</c>.
/// See also <see cref="process.thisProcessCultureIsInvariant"/>.
/// 
/// This class also adds more methods.
/// You also can find string functions in other classes of this library, including <see cref="StringUtil"/>, <see cref="regexp"/>, <see cref="pathname"/>, <see cref="csvTable"/>, <see cref="keys.more"/>, <see cref="Convert2"/>, <see cref="Hash"/>.
/// </remarks>
public static unsafe partial class ExtString {
	/// <summary>
	/// Compares this and other string. Returns <c>true</c> if equal.
	/// </summary>
	/// <param name="t">This string. Can be <c>null</c>.</param>
	/// <param name="s">Other string. Can be <c>null</c>.</param>
	/// <param name="ignoreCase">Case-insensitive.</param>
	/// <remarks>
	/// Uses ordinal comparison (does not depend on current culture/locale).
	/// </remarks>
	/// <seealso cref="Eq(RStr, RStr)"/>
	/// <seealso cref="Eqi(RStr, RStr)"/>
	/// <seealso cref="string.Compare"/>
	/// <seealso cref="string.CompareOrdinal"/>
	public static bool Eq(this string t, string s, bool ignoreCase = false) {
		return ignoreCase ? string.Equals(t, s, StringComparison.OrdinalIgnoreCase) : string.Equals(t, s);
	}

	/// <summary>
	/// Compares this strings with multiple strings.
	/// Returns 1-based index of the matching string, or 0 if none.
	/// </summary>
	/// <param name="t">This string. Can be <c>null</c>.</param>
	/// <param name="ignoreCase">Case-insensitive.</param>
	/// <param name="strings">Other strings. Strings can be <c>null</c>.</param>
	/// <remarks>
	/// Uses ordinal comparison (does not depend on current culture/locale).
	/// </remarks>
	public static int Eq(this string t, bool ignoreCase, params ReadOnlySpan<string> strings) {
		for (int i = 0; i < strings.Length; i++) if (Eq(t, strings[i], ignoreCase)) return i + 1;
		return 0;
	}

	/// <summary>
	/// Compares part of this string with other string. Returns <c>true</c> if equal.
	/// </summary>
	/// <param name="t">This string.</param>
	/// <param name="startIndex">Offset in this string. If invalid, returns <c>false</c>.</param>
	/// <param name="s">Other string.</param>
	/// <param name="ignoreCase">Case-insensitive.</param>
	/// <exception cref="ArgumentNullException"><i>s</i> is <c>null</c>.</exception>
	/// <remarks>
	/// Uses ordinal comparison (does not depend on current culture/locale).
	/// </remarks>
	/// <seealso cref="Eq(RStr, int, RStr, bool)"/>
	/// <seealso cref="string.Compare"/>
	/// <seealso cref="string.CompareOrdinal"/>
	public static bool Eq(this string t, int startIndex, RStr s, bool ignoreCase = false) {
		int nt = t.Length, ns = s.LengthThrowIfNull_();
		if ((uint)startIndex > nt || ns > nt - startIndex) return false;
		var span = t.AsSpan(startIndex, ns);
		if (!ignoreCase) return span.SequenceEqual(s);
		return span.Equals(s, StringComparison.OrdinalIgnoreCase);
		//Faster than string.Compare[Ordinal].
		//With Tables_.LowerCase similar speed. Depends on whether match. 
	}

	/// <summary>
	/// Compares part of this string with multiple strings.
	/// Returns 1-based index of the matching string, or 0 if none.
	/// </summary>
	/// <param name="t">This string.</param>
	/// <param name="startIndex">Offset in this string. If invalid, returns <c>false</c>.</param>
	/// <param name="ignoreCase">Case-insensitive.</param>
	/// <param name="strings">Other strings.</param>
	/// <exception cref="ArgumentNullException">A string in <i>strings</i> is <c>null</c>.</exception>
	/// <remarks>
	/// Uses ordinal comparison (does not depend on current culture/locale).
	/// </remarks>
	public static int Eq(this string t, int startIndex, bool ignoreCase = false, params ReadOnlySpan<string> strings) {
		for (int i = 0; i < strings.Length; i++) if (t.Eq(startIndex, strings[i], ignoreCase)) return i + 1;
		return 0;
	}

	/// <summary>
	/// Compares part of this string with other string. Returns <c>true</c> if equal.
	/// </summary>
	/// <param name="t">This string.</param>
	/// <param name="range">Range of this string. Can return <c>true</c> only if its length <c>== s.Length</c>. If invalid, returns <c>false</c>.</param>
	/// <param name="s">Other string.</param>
	/// <param name="ignoreCase">Case-insensitive.</param>
	/// <exception cref="ArgumentNullException"><i>s</i> is <c>null</c>.</exception>
	/// <remarks>
	/// Uses ordinal comparison (does not depend on current culture/locale).
	/// </remarks>
	/// <seealso cref="Eq(RStr, RStr)"/>
	/// <seealso cref="Eqi(RStr, RStr)"/>
	/// <seealso cref="string.Compare"/>
	/// <seealso cref="string.CompareOrdinal"/>
	public static bool Eq(this string t, Range range, RStr s, bool ignoreCase = false) {
		int nt = t.Length, ns = s.LengthThrowIfNull_();
		int i = range.Start.GetOffset(nt), len = range.End.GetOffset(nt) - i;
		return ns == len && t.Eq(i, s, ignoreCase);
	}

	/// <summary>
	/// Returns <c>true</c> if the specified character is at the specified position in this string.
	/// </summary>
	/// <param name="t">This string.</param>
	/// <param name="index">Offset in this string. If invalid, returns <c>false</c>.</param>
	/// <param name="c">Character.</param>
	public static bool Eq(this string t, int index, char c) {
		if ((uint)index >= t.Length) return false;
		return t[index] == c;
	}

	/// <summary>
	/// Compares this and other string ignoring case (case-insensitive). Returns <c>true</c> if equal.
	/// </summary>
	/// <param name="t">This string. Can be <c>null</c>.</param>
	/// <param name="s">Other string. Can be <c>null</c>.</param>
	/// <remarks>
	/// Uses ordinal comparison (does not depend on current culture/locale).
	/// </remarks>
	public static bool Eqi(this string t, string s) => string.Equals(t, s, StringComparison.OrdinalIgnoreCase);

	//rejected. Not so often used.
	//public static bool Eqi(this string t, int startIndex, string s) => Eq(t, startIndex, s, true);

	/// <summary>
	/// Compares end of this string with other string. Returns <c>true</c> if equal.
	/// </summary>
	/// <param name="t">This string.</param>
	/// <param name="s">Other string.</param>
	/// <param name="ignoreCase">Case-insensitive.</param>
	/// <exception cref="ArgumentNullException"><i>s</i> is <c>null</c>.</exception>
	/// <remarks>
	/// Uses ordinal comparison (does not depend on current culture/locale).
	/// </remarks>
	public static bool Ends(this string t, RStr s, bool ignoreCase = false) {
		int nt = t.Length, ns = s.LengthThrowIfNull_();
		if (ns > nt) return false;
		var span = t.AsSpan(nt - ns);
		if (!ignoreCase) return span.SequenceEqual(s);
		return span.Equals(s, StringComparison.OrdinalIgnoreCase);
		//faster than EndsWith
	}

	/// <summary>
	/// Compares end of this string with multiple strings.
	/// Returns 1-based index of the matching string, or 0 if none.
	/// </summary>
	/// <param name="t">This string.</param>
	/// <param name="ignoreCase">Case-insensitive.</param>
	/// <param name="strings">Other strings.</param>
	/// <exception cref="ArgumentNullException">A string in <i>strings</i> is <c>null</c>.</exception>
	/// <remarks>
	/// Uses ordinal comparison (does not depend on current culture/locale).
	/// </remarks>
	public static int Ends(this string t, bool ignoreCase, params ReadOnlySpan<string> strings) {
		for (int i = 0; i < strings.Length; i++) if (Ends(t, strings[i], ignoreCase)) return i + 1;
		return 0;
	}

	/// <summary>
	/// Returns <c>true</c> if this string ends with the specified character.
	/// </summary>
	/// <param name="t">This string.</param>
	/// <param name="c">Character.</param>
	public static bool Ends(this string t, char c) {
		int i = t.Length - 1;
		return i >= 0 && t[i] == c;
	}

	/// <summary>
	/// Compares beginning of this string with other string. Returns <c>true</c> if equal.
	/// </summary>
	/// <param name="t">This string.</param>
	/// <param name="s">Other string.</param>
	/// <param name="ignoreCase">Case-insensitive.</param>
	/// <exception cref="ArgumentNullException"><i>s</i> is <c>null</c>.</exception>
	/// <remarks>
	/// Uses ordinal comparison (does not depend on current culture/locale).
	/// </remarks>
	public static bool Starts(this string t, RStr s, bool ignoreCase = false) {
		int nt = t.Length, ns = s.LengthThrowIfNull_();
		if (ns > nt) return false;
		var span = t.AsSpan(0, ns);
		if (!ignoreCase) return span.SequenceEqual(s);
		return span.Equals(s, StringComparison.OrdinalIgnoreCase);
		//faster than StartsWith
	}

	/// <summary>
	/// Compares beginning of this string with multiple strings.
	/// Returns 1-based index of the matching string, or 0 if none.
	/// </summary>
	/// <param name="t">This string.</param>
	/// <param name="ignoreCase">Case-insensitive.</param>
	/// <param name="strings">Other strings.</param>
	/// <exception cref="ArgumentNullException">A string in <i>strings</i> is <c>null</c>.</exception>
	/// <remarks>
	/// Uses ordinal comparison (does not depend on current culture/locale).
	/// </remarks>
	public static int Starts(this string t, bool ignoreCase, params ReadOnlySpan<string> strings) {
		for (int i = 0; i < strings.Length; i++) if (Starts(t, strings[i], ignoreCase)) return i + 1;
		return 0;
	}

	/// <summary>
	/// Returns <c>true</c> if this string starts with the specified character.
	/// </summary>
	/// <param name="t">This string.</param>
	/// <param name="c">Character.</param>
	public static bool Starts(this string t, char c) {
		return t.Length > 0 && t[0] == c;
	}

	//Speed test results with text of length 5_260_070 and 'find' text "inheritdoc":
	//IndexOf(Ordinal)							6 ms (depends on 'find' text; can be much faster if starts with a rare character)
	//IndexOf(OrdinalIgnoreCase)				32 ms
	//FindStringOrdinal()						8 ms
	//FindStringOrdinal(true)					32 ms
	//Like("*" + x + "*")						10 ms
	//Like("*" + x + "*", true)					12 ms
	//RxIsMatch(LITERAL)						13 ms
	//RxIsMatch(LITERAL|CASELESS)				19 ms
	//Regex.Match(CultureInvariant)				4 ms (when no regex-special characters or if escaped)
	//Regex.Match(CultureInvariant|IgnoreCase)	9 ms
	//Find2(true)								10 ms

	//Could optimize the case-insensitive Find.
	//	Either use table (like Like), or for very long strings use Regex.
	//	But maybe then result would be different in some cases, not sure.
	//	How if contains Unicode surrogates?
	//	Bad: slower startup, because need to create table or JIT Regex.
	//	Never mind.

	//public static int Find2(this string t, string s, bool ignoreCase = false) {
	//	if (!ignoreCase) return t.IndexOf(s, StringComparison.Ordinal);
	//	int n = t.Length - s.Length;
	//	if (n >= 0) {
	//		if (s.Length == 0) return 0;
	//		var m = Tables_.LowerCase;
	//		char first = m[s[0]];
	//		for (int i = 0; i <= n; i++) {
	//			if (m[t[i]] == first) {
	//				int j = 1; while (j < s.Length && m[t[i + j]] == m[s[j]]) j++;
	//				if (j == s.Length) return i;
	//			}
	//		}
	//	}
	//	return -1;
	//}

	/// <summary>
	/// Finds substring in this string. Returns its 0-based index, or -1 if not found.
	/// </summary>
	/// <param name="t">This string.</param>
	/// <param name="s">Substring to find.</param>
	/// <param name="ignoreCase">Case-insensitive.</param>
	/// <exception cref="ArgumentNullException"><i>s</i> is <c>null</c>.</exception>
	/// <remarks>
	/// Uses ordinal comparison (does not depend on current culture/locale).
	/// </remarks>
	public static int Find(this string t, string s, bool ignoreCase = false) {
		return t.IndexOf(s, ignoreCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal);
	}

	/// <summary>
	/// Finds substring in part of this string. Returns its 0-based index, or -1 if not found.
	/// </summary>
	/// <param name="t">This string.</param>
	/// <param name="s">Substring to find.</param>
	/// <param name="startIndex">The search start index.</param>
	/// <param name="ignoreCase">Case-insensitive.</param>
	/// <exception cref="ArgumentNullException"><i>s</i> is <c>null</c>.</exception>
	/// <exception cref="ArgumentOutOfRangeException">Invalid <i>startIndex</i>.</exception>
	/// <remarks>
	/// Uses ordinal comparison (does not depend on current culture/locale).
	/// </remarks>
	public static int Find(this string t, string s, int startIndex, bool ignoreCase = false) {
		return t.IndexOf(s, startIndex, ignoreCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal);
	}

	/// <summary>
	/// Finds substring in part of this string. Returns its 0-based index, or -1 if not found.
	/// </summary>
	/// <param name="t">This string.</param>
	/// <param name="s">Substring to find.</param>
	/// <param name="range">The search range.</param>
	/// <param name="ignoreCase">Case-insensitive.</param>
	/// <exception cref="ArgumentNullException"><i>s</i> is <c>null</c>.</exception>
	/// <exception cref="ArgumentOutOfRangeException">Invalid <i>range</i>.</exception>
	/// <remarks>
	/// Uses ordinal comparison (does not depend on current culture/locale).
	/// </remarks>
	public static int Find(this string t, string s, Range range, bool ignoreCase = false) {
		var (start, count) = range.GetOffsetAndLength(t.Length);
		return t.IndexOf(s, start, count, ignoreCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal);
	}

	//CONSIDER: make public.
	/// <summary>
	/// Like <see cref="Find(string, string, bool)"/>, but with a predicate.
	/// </summary>
	/// <param name="also">Called for each found substring until returns <c>true</c>. Receives this string and start and end offsets of the substring.</param>
	internal static int Find_(this string t, string s, Func<string, int, int, bool> also, bool ignoreCase = false) {
		for (int i = 0; ; i++) {
			i = t.Find(s, i, ignoreCase);
			if (i < 0) break;
			if (also(t, i, i + s.Length)) return i;
		}
		return -1;
	}

	/// <summary>
	/// Finds the first character specified in <i>chars</i>. Returns its index, or -1 if not found.
	/// </summary>
	/// <param name="t">This string.</param>
	/// <param name="chars">Characters.</param>
	/// <param name="range">The search range.</param>
	/// <exception cref="ArgumentNullException"><i>chars</i> is <c>null</c>.</exception>
	/// <exception cref="ArgumentOutOfRangeException">Invalid <i>range</i>.</exception>
	[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.AggressiveOptimization)] //functions with Range parameter are very slow until fully optimized
	public static int FindAny(this string t, string chars, Range? range = null) {
		var (start, len) = range.GetOffsetAndLength(t.Length);
		int r = t.AsSpan(start, len).IndexOfAny(chars);
		return r < 0 ? r : r + start;
	}

	/// <summary>
	/// Finds the first character not specified in <i>chars</i>. Returns its index, or -1 if not found.
	/// </summary>
	/// <param name="t">This string.</param>
	/// <param name="chars">Characters.</param>
	/// <param name="range">The search range.</param>
	/// <exception cref="ArgumentNullException"><i>chars</i> is <c>null</c>.</exception>
	/// <exception cref="ArgumentOutOfRangeException">Invalid <i>range</i>.</exception>
	[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.AggressiveOptimization)]
	public static int FindNot(this string t, string chars, Range? range = null) {
		var (start, len) = range.GetOffsetAndLength(t.Length);
		int r = t.AsSpan(start, len).IndexOfAnyExcept(chars);
		return r < 0 ? r : r + start;
	}

	/// <summary>
	/// Finds the last character specified in <i>chars</i> (searches right to left). Returns its index, or -1 if not found.
	/// </summary>
	/// <param name="t">This string.</param>
	/// <param name="chars">Characters.</param>
	/// <param name="range">The search range.</param>
	/// <exception cref="ArgumentNullException"><i>chars</i> is <c>null</c>.</exception>
	/// <exception cref="ArgumentOutOfRangeException">Invalid <i>range</i>.</exception>
	[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.AggressiveOptimization)]
	public static int FindLastAny(this string t, string chars, Range? range = null) {
		var (start, len) = range.GetOffsetAndLength(t.Length);
		int r = t.AsSpan(start, len).LastIndexOfAny(chars);
		return r < 0 ? r : r + start;
	}

	/// <summary>
	/// Finds the last character not specified in <i>chars</i> (searches right to left). Returns its index, or -1 if not found.
	/// </summary>
	/// <param name="t">This string.</param>
	/// <param name="chars">Characters.</param>
	/// <param name="range">The search range.</param>
	/// <exception cref="ArgumentNullException"><i>chars</i> is <c>null</c>.</exception>
	/// <exception cref="ArgumentOutOfRangeException">Invalid <i>range</i>.</exception>
	[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.AggressiveOptimization)]
	public static int FindLastNot(this string t, string chars, Range? range = null) {
		var (start, len) = range.GetOffsetAndLength(t.Length);
		int r = t.AsSpan(start, len).LastIndexOfAnyExcept(chars);
		return r < 0 ? r : r + start;
	}

	/// <summary>
	/// Removes specified characters from the start and end of this string.
	/// </summary>
	/// <returns>The result string.</returns>
	/// <param name="t">This string.</param>
	/// <param name="chars">Characters to remove.</param>
	/// <exception cref="ArgumentNullException"><i>chars</i> is <c>null</c>.</exception>
	[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.AggressiveOptimization)]
	public static string Trim(this string t, string chars) {
		var span = t.AsSpan().Trim(chars);
		return span.Length == t.Length ? t : new string(span);
	}

	/// <summary>
	/// Removes specified characters from the start of this string.
	/// </summary>
	/// <returns>The result string.</returns>
	/// <param name="t">This string.</param>
	/// <param name="chars">Characters to remove.</param>
	/// <exception cref="ArgumentNullException"><i>chars</i> is <c>null</c>.</exception>
	[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.AggressiveOptimization)]
	public static string TrimStart(this string t, string chars) {
		var span = t.AsSpan().TrimStart(chars);
		return span.Length == t.Length ? t : new string(span);
	}

	/// <summary>
	/// Removes specified characters from the end of this string.
	/// </summary>
	/// <returns>The result string.</returns>
	/// <param name="t">This string.</param>
	/// <param name="chars">Characters to remove.</param>
	/// <exception cref="ArgumentNullException"><i>chars</i> is <c>null</c>.</exception>
	[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.AggressiveOptimization)]
	public static string TrimEnd(this string t, string chars) {
		var span = t.AsSpan().TrimEnd(chars);
		return span.Length == t.Length ? t : new string(span);
	}

	/// <summary>
	/// Finds whole word. Returns its 0-based index, or -1 if not found.
	/// </summary>
	/// <param name="t">This string.</param>
	/// <param name="s">Substring to find.</param>
	/// <param name="range">The search range.</param>
	/// <param name="ignoreCase">Case-insensitive.</param>
	/// <param name="otherWordChars">Additional word characters. For example <c>"_"</c>.</param>
	/// <param name="isWordChar">Function that returns <c>true</c> for word characters. If <c>null</c>, uses <see cref="char.IsLetterOrDigit"/>.</param>
	/// <exception cref="ArgumentNullException"><i>s</i> is <c>null</c>.</exception>
	/// <exception cref="ArgumentOutOfRangeException">Invalid <i>range</i>.</exception>
	/// <remarks>
	/// If <i>s</i> starts with a word character, finds substring that is not preceded by a word character.
	/// If <i>s</i> ends with a word character, finds substring that is not followed by a word character.
	/// Word characters are those for which <i>isWordChar</i> or <see cref="char.IsLetterOrDigit"/> returns <c>true</c> plus those specified in <i>otherWordChars</i>.
	/// Uses ordinal comparison (does not depend on current culture/locale).
	/// For Unicode surrogates (2-<c>char</c> characters) calls <see cref="char.IsLetterOrDigit(string, int)"/> and ignores <i>isWordChar</i> and <i>otherWordChars</i>.
	/// </remarks>
	public static int FindWord(this string t, string s, Range? range = null, bool ignoreCase = false, string otherWordChars = null, Func<char, bool> isWordChar = null) {
		Not_.Null(s);
		var (start, end) = range.GetStartEnd(t.Length);
		int lens = s.Length;
		if (lens == 0) return 0; //like IndexOf and Find

		bool wordStart = _IsWordChar(s, 0, false),
			wordEnd = _IsWordChar(s, lens - 1, true);

		for (int i = start, iMax = end - lens; i <= iMax; i++) {
			i = t.IndexOf(s, i, end - i, ignoreCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal);
			if (i < 0) break;
			if (wordStart && i > 0 && _IsWordChar(t, i - 1, true)) continue;
			if (wordEnd && i < iMax && _IsWordChar(t, i + lens, false)) continue;
			return i;
		}
		return -1;

		bool _IsWordChar(string s, int i, bool expandLeft) {
			//CONSIDER: use Rune
			char c = s[i];
			if (c >= '\uD800' && c <= '\uDFFF') { //Unicode surrogates
				if (expandLeft) {
					if (char.IsLowSurrogate(s[i])) return i > 0 && char.IsHighSurrogate(s[i - 1]) && char.IsLetterOrDigit(s, i - 1);
				} else {
					if (char.IsHighSurrogate(s[i])) return i < s.Length - 1 && char.IsLowSurrogate(s[i + 1]) && char.IsLetterOrDigit(s, i);
				}
			} else {
				if (isWordChar?.Invoke(c) ?? char.IsLetterOrDigit(c)) return true;
				if (otherWordChars?.Contains(c) ?? false) return true;
			}
			return false;
		}
	}

	/// <summary>
	/// Returns <see cref="string.Length"/>. Returns 0 if this string is <c>null</c>.
	/// </summary>
	/// <param name="t">This string.</param>
	[DebuggerStepThrough]
	public static int Lenn(this string t) => t?.Length ?? 0;

	/// <summary>
	/// Returns <c>true</c> if this string is <c>null</c> or empty (<c>""</c>).
	/// </summary>
	/// <param name="t">This string.</param>
	[DebuggerStepThrough]
	public static bool NE(this string t) => t == null || t.Length == 0;

	/// <summary>
	/// Returns this string, or <c>null</c> if it is <c>""</c> or <c>null</c>.
	/// </summary>
	/// <param name="t">This string.</param>
	[DebuggerStepThrough]
	internal static string NullIfEmpty_(this string t) => t.NE() ? null : t;
	//not public because probably too rarely used.

#if !DEBUG
	/// <summary>
	/// This function can be used with <c>foreach</c> to split this string into substrings as start/end offsets.
	/// </summary>
	/// <param name="t">This string.</param>
	/// <param name="separators">Characters that delimit the substrings. Or one of <see cref="SegSep"/> constants.</param>
	/// <param name="flags"></param>
	/// <param name="range">Part of this string to split.</param>
	/// <example>
	/// <code><![CDATA[
	/// string s = "one * two three ";
	/// foreach(var t in s.Segments(" ")) print.it(s[t.start..t.end]);
	/// foreach(var t in s.Segments(SegSep.Word, SegFlags.NoEmpty)) print.it(s[t.start..t.end]);
	/// ]]></code>
	/// </example>
	[EditorBrowsable(EditorBrowsableState.Never)] //obsolete. Use Split or Lines. They are faster, have "trim" option; the returned array is easier to use and not too expensive. For words use regex.
	public static SegParser Segments(this string t, string separators, SegFlags flags = 0, Range? range = null) {
		return new SegParser(t, separators, flags, range);
	}
#endif
	
	/// <summary>
	/// Splits this string into substrings as start/end offsets.
	/// </summary>
	public static StartEnd[] SplitSE(this string t, Range range, char separator, StringSplitOptions flags = 0) {
		var (start, len) = range.GetOffsetAndLength(t.Length);
		var a = t.AsSpan(start, len).SplitSE(separator, flags);
		return _SplitOffset(a, start);
	}
	
#if !DEBUG
	/// <summary>Alias of <c>SplitSE</c>.</summary>
	[EditorBrowsable(EditorBrowsableState.Never)] //renamed
	public static StartEnd[] Split(this string t, Range range, char separator, StringSplitOptions flags = 0) => SplitSE(t, range, separator, flags);
#endif
	
	/// <summary>
	/// Splits this string into substrings as start/end offsets.
	/// </summary>
	public static StartEnd[] SplitSE(this string t, Range range, string separator, StringSplitOptions flags = 0) {
		var (start, len) = range.GetOffsetAndLength(t.Length);
		var a = t.AsSpan(start, len).SplitSE(separator, flags);
		return _SplitOffset(a, start);
	}
	
#if !DEBUG
	/// <summary>Alias of <c>SplitSE</c>.</summary>
	[EditorBrowsable(EditorBrowsableState.Never)] //renamed
	public static StartEnd[] Split(this string t, Range range, string separator, StringSplitOptions flags = 0) => SplitSE(t, range, separator, flags);
#endif
	
	/// <summary>
	/// Splits this string into substrings as start/end offsets. Can be used multiple separators.
	/// </summary>
	public static StartEnd[] SplitAnySE(this string t, Range range, RStr separators, StringSplitOptions flags = 0) {
		var (start, len) = range.GetOffsetAndLength(t.Length);
		var a = t.AsSpan(start, len).SplitAnySE(separators, flags);
		return _SplitOffset(a, start);
	}
	
#if !DEBUG
	/// <summary>Alias of <c>SplitAnySE</c>.</summary>
	[EditorBrowsable(EditorBrowsableState.Never)] //renamed
	public static StartEnd[] Split(this string t, Range range, StringSplitOptions flags, RStr separators) => SplitAnySE(t, range, separators, flags);
#endif
	
	/// <summary>
	/// Splits this string into substrings as start/end offsets. Can be used multiple separators.
	/// </summary>
	public static StartEnd[] SplitAnySE(this string t, Range range, ReadOnlySpan<string> separators, StringSplitOptions flags = 0) {
		var (start, len) = range.GetOffsetAndLength(t.Length);
		var a = t.AsSpan(start, len).SplitAnySE(separators, flags);
		return _SplitOffset(a, start);
	}
	
#if !DEBUG
	/// <summary>Alias of <c>SplitAnySE</c>.</summary>
	[EditorBrowsable(EditorBrowsableState.Never)] //renamed
	public static StartEnd[] Split(this string t, Range range, StringSplitOptions flags, ReadOnlySpan<string> separators) => SplitAnySE(t, range, separators, flags);
#endif
	
	/// <summary>
	/// Splits this string span into substrings as start/end offsets.
	/// </summary>
	public static StartEnd[] SplitSE(this RStr t, char separator, StringSplitOptions flags = 0)
		=> _Split(t, flags, false, 1, separator).a1;
	
#if !DEBUG
	/// <summary>Alias of <c>SplitSE</c>.</summary>
	[EditorBrowsable(EditorBrowsableState.Never)] //renamed
	public static StartEnd[] Split(this RStr t, char separator, StringSplitOptions flags = 0) => SplitSE(t, separator, flags);
#endif
	
	/// <summary>
	/// Splits this string span into substrings as start/end offsets.
	/// </summary>
	public static StartEnd[] SplitSE(this RStr t, string separator, StringSplitOptions flags = 0)
		=> _Split(t, flags, false, 2, sep23: separator).a1;
	
#if !DEBUG
	/// <summary>Alias of <c>SplitSE</c>.</summary>
	[EditorBrowsable(EditorBrowsableState.Never)] //renamed
	public static StartEnd[] Split(this RStr t, string separator, StringSplitOptions flags = 0) => SplitSE(t, separator, flags);
#endif
	
	/// <summary>
	/// Splits this string span into substrings as start/end offsets. Can be used multiple separators.
	/// </summary>
	public static StartEnd[] SplitAnySE(this RStr t, RStr separators, StringSplitOptions flags = 0)
		=> _Split(t, flags, false, 3, sep23: separators).a1;
	
#if !DEBUG
	/// <summary>Alias of <c>SplitAnySE</c>.</summary>
	[EditorBrowsable(EditorBrowsableState.Never)] //renamed
	public static StartEnd[] SplitAny(this RStr t, RStr separators, StringSplitOptions flags = 0) => SplitAnySE(t, separators, flags);
#endif
	
	/// <summary>
	/// Splits this string span into substrings as start/end offsets. Can be used multiple separators.
	/// </summary>
	public static StartEnd[] SplitAnySE(this RStr t, ReadOnlySpan<string> separators, StringSplitOptions flags = 0)
		=> _Split(t, flags, false, 4, sep4: separators).a1;
	
#if !DEBUG
	/// <summary>Alias of <c>SplitAnySE</c>.</summary>
	[EditorBrowsable(EditorBrowsableState.Never)] //renamed
	public static StartEnd[] SplitAny(this RStr t, ReadOnlySpan<string> separators, StringSplitOptions flags = 0) => SplitAnySE(t, separators, flags);
#endif
	
#if !DEBUG //FUTURE: delete these etc. Hidden in v1.12 2025-05-17.
	/// <summary>
	/// Splits this string span into substrings.
	/// </summary>
	[EditorBrowsable(EditorBrowsableState.Never)] //C# 14 mess
	public static string[] SplitS(this RStr t, char separator, StringSplitOptions flags = 0)
		=> _Split(t, flags, true, 1, separator).a2;
	
	/// <summary>
	/// Splits this string span into substrings.
	/// </summary>
	[EditorBrowsable(EditorBrowsableState.Never)] //C# 14 mess
	public static string[] SplitS(this RStr t, string separator, StringSplitOptions flags = 0)
		=> _Split(t, flags, true, 2, sep23: separator).a2;
	
	/// <summary>
	/// Splits this string span into substrings. Can be used multiple separators.
	/// </summary>
	[EditorBrowsable(EditorBrowsableState.Never)] //C# 14 mess
	public static string[] SplitAnyS(this RStr t, RStr separators, StringSplitOptions flags = 0)
		=> _Split(t, flags, true, 3, sep23: separators).a2;
	
	/// <summary>
	/// Splits this string span into substrings. Can be used multiple separators.
	/// </summary>
	[EditorBrowsable(EditorBrowsableState.Never)] //C# 14 mess
	public static string[] SplitAnyS(this RStr t, ReadOnlySpan<string> separators, StringSplitOptions flags = 0)
		=> _Split(t, flags, true, 4, sep4: separators).a2;
#endif
	
	[SkipLocalsInit]
	static (StartEnd[] a1, string[] a2) _Split(RStr t, StringSplitOptions flags, bool retStr, int sep, char sep1 = default, RStr sep23 = default, ReadOnlySpan<string> sep4 = default) {
		const int na = 100;
		Span<StartEnd> a = stackalloc StartEnd[na];
		Span<Range> a2 = MemoryMarshal.Cast<StartEnd, Range>(a);
		List<StartEnd> list = null;
		for (int add = 0; ;) {
			int n = sep switch { 1 => t.Split(a2, sep1, flags), 2 => t.Split(a2, sep23, flags), 3 => t.SplitAny(a2, sep23, flags), _ => t.SplitAny(a2, sep4, flags) };
			//print.it(n, na);
			if (add > 0) _Offset(a, n, add);
			if (n < na) {
				if (retStr) {
					string[] r;
					if (list != null) {
						r = new string[list.Count + n];
						for (int i = 0; i < list.Count; i++) r[i] = t[list[i].Range].ToString();
						for (int i = 0, j = list.Count; i < n; i++) r[j++] = t[a[i].Range].ToString();
					} else {
						r = new string[n];
						for (int i = 0; i < n; i++) r[i] = t[a[i].Range].ToString();
					}
					return (null, r);
				} else {
					return (list == null ? a[..n].ToArray() : [.. list, .. a[..n]], null);
				}
			}
			int last = a[^1].start;
			t = t[last..];
			add += last;
			(list ??= new(na * 2)).AddRange(a[..^1]);
		}
		
		static void _Offset(Span<StartEnd> ar, int n, int add) {
			foreach (ref var v in ar) {
				v.start += add;
				v.end += add;
			}
		}
	}
	
	static StartEnd[] _SplitOffset(StartEnd[] a, int start) {
		if (start != 0) {
			for (int i = 0; i < a.Length; i++) {
				a[i].start += start;
				a[i].end += start;
			}
		}
		return a;
	}

	/// <summary>
	/// Splits this string into lines.
	/// </summary>
	/// <returns>Array containing lines as strings. Does not include the last empty line, unless <i>preferMore</i> true.</returns>
	/// <param name="t">This string.</param>
	/// <param name="noEmpty">Don't need empty lines.</param>
	/// <param name="preferMore">Add 1 array element if the string ends with a line separator or its length is 0.</param>
	/// <param name="rareNewlines">If <c>false</c> (default), recognizes these newlines: <c>"\r\n"</c>, <c>"\n"</c> and <c>"\r"</c>. If <c>true</c>, also recognizes <c>"\f"</c>, <c>"\x0085"</c>, <c>"\x2028"</c> and <c>"\x2029"</c>.</param>
	/// <seealso cref="StringReader.ReadLine"/>
	public static string[] Lines(this string t, bool noEmpty = false, bool preferMore = false, bool rareNewlines = false)
		=> _Lines(t, noEmpty, preferMore, rareNewlines, true).a2;

	/// <summary>
	/// Splits this string or a range in it into lines as start/end offsets.
	/// </summary>
	/// <returns>Array containing start/end offsets of lines in the string (not in the range). Does not include the last empty line, unless <i>preferMore</i> true.</returns>
	/// <param name="t">This string.</param>
	/// <param name="range">Range of this string. Example: <c>var a = s.Lines(..); //split entire string</c>.</param>
	/// <param name="noEmpty">Don't need empty lines.</param>
	/// <param name="preferMore">Add 1 array element if the string range ends with a line separator or its length is 0.</param>
	/// <param name="rareNewlines">If <c>false</c> (default), recognizes these newlines: <c>"\r\n"</c>, <c>"\n"</c> and <c>"\r"</c>. If <c>true</c>, also recognizes <c>"\f"</c>, <c>"\x0085"</c>, <c>"\x2028"</c> and <c>"\x2029"</c>.</param>
	/// <seealso cref="Lines(ReadOnlySpan{char}, bool, bool, bool)"/>
	public static StartEnd[] Lines(this string t, Range range, bool noEmpty = false, bool preferMore = false, bool rareNewlines = false) {
		var (start, len) = range.GetOffsetAndLength(t.Length);
		var a = t.AsSpan(start, len).Lines(noEmpty, preferMore, rareNewlines);
		return _SplitOffset(a, start);
	}

	/// <summary>
	/// Splits this string into lines as start/end offsets.
	/// </summary>
	/// <returns>Array containing start/end offsets of lines. Does not include the last empty line, unless <i>preferMore</i> true.</returns>
	/// <param name="t">This string.</param>
	/// <param name="noEmpty">Don't need empty lines.</param>
	/// <param name="preferMore">Add 1 array element if the string span ends with a line separator or its length is 0.</param>
	/// <param name="rareNewlines">If <c>false</c> (default), recognizes these newlines: <c>"\r\n"</c>, <c>"\n"</c> and <c>"\r"</c>. If <c>true</c>, also recognizes <c>"\f"</c>, <c>"\x0085"</c>, <c>"\x2028"</c> and <c>"\x2029"</c>.</param>
	public static StartEnd[] Lines(this RStr t, bool noEmpty = false, bool preferMore = false, bool rareNewlines = false)
		=> _Lines(t, noEmpty, preferMore, rareNewlines, false).a1;

	[SkipLocalsInit, MethodImpl(MethodImplOptions.AggressiveOptimization)]
	static (StartEnd[] a1, string[] a2) _Lines(RStr t, bool noEmpty, bool preferMore, bool rareNewlines, bool retStr) {
		using var f = new FastBuffer<StartEnd>();

		var newline = rareNewlines ? s_newlineAll : s_newlineRN;
		int n = 0;
		for (int pos = 0; ;) {
			if (pos == t.Length && !preferMore) break;
			if (n == f.n) f.More(preserve: true);
			var span = t[pos..];
			int len = span.IndexOfAny(newline);
			if (len < 0) {
				f[n++] = new(pos, t.Length);
				break;
			} else {
				if (!(noEmpty && len == 0)) f[n++] = new(pos, pos + len);
				pos += len + 1;
				if (span[len] == '\r' && pos < t.Length && t[pos] == '\n') pos++;
			}
		}

		if (!retStr) return (new Span<StartEnd>(f.p, n).ToArray(), null);

		var a = new string[n];
		for (int i = 0; i < n; i++) a[i] = t[f[i].Range].ToString();
		return (null, a);
	}

	/// <summary>
	/// Returns the number of lines.
	/// </summary>
	/// <param name="t">This string.</param>
	/// <param name="preferMore">Add 1 if the string ends with a line separator or its length is 0.</param>
	/// <param name="range">Part of this string or <c>null</c> (default).</param>
	/// <param name="rareNewlines">If <c>false</c> (default), recognizes these newlines: <c>"\r\n"</c>, <c>"\n"</c> and <c>"\r"</c>. If <c>true</c>, also recognizes <c>"\f"</c>, <c>"\x0085"</c>, <c>"\x2028"</c> and <c>"\x2029"</c>.</param>
	/// <exception cref="ArgumentOutOfRangeException"></exception>
	/// <seealso cref="StringUtil.LineAndColumn"/>
	public static int LineCount(this string t, bool preferMore = false, Range? range = null, bool rareNewlines = false)
		=> LineCount(range is null ? t : t.AsSpan(range.Value), preferMore, rareNewlines);

	/// <inheritdoc cref="LineCount(string, bool, Range?, bool)"/>
	[MethodImpl(MethodImplOptions.AggressiveOptimization)]
	public static int LineCount(this RStr t, bool preferMore = false, bool rareNewlines = false) {
		var newline = rareNewlines ? s_newlineAll : s_newlineRN;
		int n = 0;
		for (int pos = 0; ;) {
			if (pos == t.Length) {
				if (preferMore) n++;
				break;
			}
			n++;
			var span = t[pos..];
			int len = span.IndexOfAny(newline);
			if (len < 0) break;
			pos += len + 1;
			if (span[len] == '\r' && pos < t.Length && t[pos] == '\n') pos++;
		}
		return n;
	}

	static readonly SearchValues<char> s_newlineRN = SearchValues.Create(['\r', '\n']),
		s_newlineAll = SearchValues.Create(['\r', '\n', '\f', '\x85', '\x2028', '\x2029']);

	/// <summary>
	/// Converts this string to lower case.
	/// </summary>
	/// <returns>The result string.</returns>
	/// <param name="t">This string.</param>
	/// <remarks>
	/// Calls <see cref="string.ToLowerInvariant"/>.
	/// </remarks>
	public static string Lower(this string t) => t.ToLowerInvariant();

	/// <summary>
	/// Converts this string to upper case.
	/// </summary>
	/// <returns>The result string.</returns>
	/// <param name="t">This string.</param>
	/// <remarks>
	/// Calls <see cref="string.ToUpperInvariant"/>.
	/// </remarks>
	public static string Upper(this string t) => t.ToUpperInvariant();

	/// <summary>
	/// Converts this string or only the first character to upper case or all words to title case.
	/// </summary>
	/// <returns>The result string.</returns>
	/// <param name="t">This string.</param>
	/// <param name="how"></param>
	/// <param name="culture">Culture, for example <c>CultureInfo.CurrentCulture</c>. If <c>null</c> (default) uses invariant culture.</param>
	public static unsafe string Upper(this string t, SUpper how, CultureInfo culture = null) {
		if (how == SUpper.FirstChar) {
			if (t.Length == 0 || !char.IsLower(t, 0)) return t;
			var r = Rune.GetRuneAt(t, 0);
			r = culture != null ? Rune.ToUpper(r, culture) : Rune.ToUpperInvariant(r);
			int n = r.IsBmp ? 1 : 2;
			var m = new Span<char>(&r, n);
			if (n == 2) r.EncodeToUtf16(m);
			return string.Concat(m, t.AsSpan(n));
		}
		var ti = (culture ?? CultureInfo.InvariantCulture).TextInfo;
		t = t ?? throw new NullReferenceException();
		if (how == SUpper.TitleCase) return ti.ToTitleCase(t);
		return ti.ToUpper(t);
	}

	#region ToNumber

	[MethodImpl(MethodImplOptions.AggressiveOptimization)]
	static long _ToInt(RStr t, int startIndex, out int numberEndIndex, bool toLong, STIFlags flags) {
		numberEndIndex = 0;

		int len = t.Length;
		if ((uint)startIndex > len) throw new ArgumentOutOfRangeException("startIndex");
		int i = startIndex;
		char c;

		//skip spaces
		for (; ; i++) {
			if (i == len) return 0;
			c = t[i];
			if (c > ' ') break;
			if (c == ' ') continue;
			if (c < '\t' || c > '\r') break; //\t \n \v \f \r
		}
		if (i > startIndex && 0 != (flags & STIFlags.DontSkipSpaces)) return 0;

		//skip arabic letter mark etc
		if (c >= '\x61C' && c is '\x61C' or '\x200E' or '\x200F') {
			if (++i == len) return 0;
			c = t[i];
		}

		//skip -+
		bool minus = false;
		if (c is '-' or '−' or '+') {
			if (++i == len) return 0;
			if (c != '+') minus = true;
			c = t[i];
		}

		//is hex?
		bool isHex = false;
		switch (flags & (STIFlags.NoHex | STIFlags.IsHexWithout0x)) {
		case 0:
			if (c == '0' && i <= len - 3)
				if (isHex = t[i + 1] is 'x' or 'X' && t[i + 2] is (>= '0' and <= '9') or (>= 'A' and <= 'F') or (>= 'a' and <= 'f')) i += 2;
			break;
		case STIFlags.IsHexWithout0x:
			isHex = true;
			break;
		}

		//skip '0'
		int i0 = i;
		while (i < len && t[i] == '0') i++;

		long R = 0; //result

		int nDigits = 0;
		if (isHex) {
			int nMaxDigits = toLong ? 16 : 8;
			for (; i < len; i++) {
				int k = _CharHexToDec(t[i]); if (k < 0) break;
				if (++nDigits > nMaxDigits) return 0;
				R = (R << 4) + k;
			}
		} else { //decimal or not a number
			int nMaxDigits = toLong ? 20 : 10;
			for (; i < len; i++) {
				int k = t[i] - '0'; if (k < 0 || k > 9) break;
				R = R * 10 + k;
				//is too long?
				if (++nDigits >= nMaxDigits) {
					if (nDigits > nMaxDigits) return 0;
					if (toLong) {
						if (t.Slice(i + 1 - nDigits).CompareTo("18446744073709551615", StringComparison.Ordinal) > 0) return 0;
					} else {
						if (R > uint.MaxValue) return 0;
					}
				}
			}
		}

		if (i == i0) return 0; //not a number
		numberEndIndex = i;
		return minus ? -R : R;
	}

	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	static int _CharHexToDec(char c) {
		if (c >= '0' && c <= '9') return c - '0';
		if (c >= 'A' && c <= 'F') return c - ('A' - 10);
		if (c >= 'a' && c <= 'f') return c - ('a' - 10);
		return -1;
	}

	/// <summary>
	/// Converts part of this string to <c>int</c> number and gets the number end index.
	/// </summary>
	/// <returns>The number, or 0 if failed to convert.</returns>
	/// <param name="t">This string. Can be <c>null</c>.</param>
	/// <param name="startIndex">Offset in this string where to start parsing.</param>
	/// <param name="numberEndIndex">Receives offset in this string where the number part ends. If fails to convert, receives 0.</param>
	/// <param name="flags"></param>
	/// <exception cref="ArgumentOutOfRangeException"><i>startIndex</i> is less than 0 or greater than string length.</exception>
	/// <remarks>
	/// Fails to convert when string is <c>null</c>, <c>""</c>, does not start with a number or the number is too big.
	/// 
	/// Unlike <see cref="int.Parse"/> and <see cref="Convert.ToInt32"/>:
	/// - The number in string can be followed by more text, like <c>"123text"</c>.
	/// - Has <i>startIndex</i> parameter that allows to get number from middle, like <c>"text123text"</c>.
	/// - Gets the end of the number part.
	/// - No exception when cannot convert.
	/// - The number can be decimal (like <c>"123"</c>) or hexadecimal (like <c>"0x1A"</c>); don't need separate flags for each style.
	/// - Does not depend on current culture. As minus sign recognizes <c>'-'</c> and <c>'−'</c>.
	/// - Faster.
	/// 
	/// The number in string can start with ASCII whitespace (spaces, newlines, etc), like <c>" 5"</c>.
	/// The number in string can be with <c>"-"</c> or <c>"+"</c>, like <c>"-5"</c>, but not like <c>"- 5"</c>.
	/// Fails if the number is greater than +- <see cref="uint.MaxValue"/> (0xffffffff).
	/// The return value becomes negative if the number is greater than <see cref="int.MaxValue"/>, for example <c>"0xffffffff"</c> is -1, but it becomes correct if assigned to <c>uint</c> (need cast).
	/// Does not support non-integer numbers; for example, for <c>"3.5E4"</c> returns 3 and sets <c>numberEndIndex=startIndex+1</c>.
	/// </remarks>
	public static int ToInt(this string t, int startIndex, out int numberEndIndex, STIFlags flags = 0) {
		return (int)_ToInt(t, startIndex, out numberEndIndex, false, flags);
	}

	/// <summary>
	/// Converts part of this string to <c>int</c> number.
	/// </summary>
	/// <remarks></remarks>
	/// <inheritdoc cref="ToInt(string, int, out int, STIFlags)"/>
	public static int ToInt(this string t, int startIndex = 0, STIFlags flags = 0) {
		return (int)_ToInt(t, startIndex, out _, false, flags);
	}

	/// <returns><c>false</c> if failed.</returns>
	/// <param name="result">Receives the result, or 0 if failed.</param>
	/// <remarks></remarks>
	/// <inheritdoc cref="ToInt(string, int, out int, STIFlags)"/>
	public static bool ToInt(this string t, out int result, int startIndex, out int numberEndIndex, STIFlags flags = 0) {
		result = (int)_ToInt(t, startIndex, out numberEndIndex, false, flags);
		return numberEndIndex != 0;
	}

	/// <returns><c>false</c> if failed.</returns>
	/// <param name="result">Receives the result, or 0 if failed.</param>
	/// <remarks></remarks>
	/// <inheritdoc cref="ToInt(string, int, STIFlags)"/>
	public static bool ToInt(this string t, out int result, int startIndex = 0, STIFlags flags = 0)
		=> ToInt(t, out result, startIndex, out _, flags);

	/// <summary>
	/// Converts part of this string to <c>uint</c> number and gets the number end index.
	/// </summary>
	/// <remarks></remarks>
	/// <inheritdoc cref="ToInt(string, out int, int, out int, STIFlags)"/>
	public static bool ToInt(this string t, out uint result, int startIndex, out int numberEndIndex, STIFlags flags = 0) {
		result = (uint)_ToInt(t, startIndex, out numberEndIndex, false, flags);
		return numberEndIndex != 0;
	}

	/// <summary>
	/// Converts part of this string to <c>uint</c> number.
	/// </summary>
	/// <remarks></remarks>
	/// <inheritdoc cref="ToInt(string, out int, int, STIFlags)"/>
	public static bool ToInt(this string t, out uint result, int startIndex = 0, STIFlags flags = 0)
		=> ToInt(t, out result, startIndex, out _, flags);

	/// <summary>
	/// Converts part of this string to <c>long</c> number and gets the number end index.
	/// </summary>
	/// <remarks></remarks>
	/// <inheritdoc cref="ToInt(string, out int, int, out int, STIFlags)"/>
	public static bool ToInt(this string t, out long result, int startIndex, out int numberEndIndex, STIFlags flags = 0) {
		result = _ToInt(t, startIndex, out numberEndIndex, true, flags);
		return numberEndIndex != 0;
	}

	/// <summary>
	/// Converts part of this string to <c>long</c> number.
	/// </summary>
	/// <remarks></remarks>
	/// <inheritdoc cref="ToInt(string, out int, int, STIFlags)"/>
	public static bool ToInt(this string t, out long result, int startIndex = 0, STIFlags flags = 0)
		=> ToInt(t, out result, startIndex, out _, flags);

	/// <summary>
	/// Converts part of this string to <c>ulong</c> number and gets the number end index.
	/// </summary>
	/// <remarks></remarks>
	/// <inheritdoc cref="ToInt(string, out int, int, out int, STIFlags)"/>
	public static bool ToInt(this string t, out ulong result, int startIndex, out int numberEndIndex, STIFlags flags = 0) {
		result = (ulong)_ToInt(t, startIndex, out numberEndIndex, true, flags);
		return numberEndIndex != 0;
	}

	/// <summary>
	/// Converts part of this string to <c>ulong</c> number.
	/// </summary>
	/// <remarks></remarks>
	/// <inheritdoc cref="ToInt(string, out int, int, STIFlags)"/>
	public static bool ToInt(this string t, out ulong result, int startIndex = 0, STIFlags flags = 0)
		=> ToInt(t, out result, startIndex, out _, flags);

	//FUTURE: all `ToInt(this string...)` -> `ToInt(this RStr...)`.
	internal static int ToInt_(this RStr t, STIFlags flags = 0)
		=> (int)_ToInt(t, 0, out _, false, flags);

	internal static bool ToInt_(this RStr t, out int result, out int numberEndIndex, STIFlags flags = 0) {
		result = (int)_ToInt(t, 0, out numberEndIndex, false, flags);
		return numberEndIndex != 0;
	}

	/// <summary>
	/// Converts this string or its part to double number.
	/// </summary>
	/// <returns>The number, or 0 if failed to convert.</returns>
	/// <param name="t">This string. Can be <c>null</c>.</param>
	/// <param name="range">Part of this string or <c>null</c> (default).</param>
	/// <param name="style">The permitted number format in the string.</param>
	/// <exception cref="ArgumentOutOfRangeException">Invalid <i>range</i>.</exception>
	/// <exception cref="ArgumentException">Invalid <i>style</i>.</exception>
	/// <remarks>
	/// Calls <see cref="double.TryParse(RStr, NumberStyles, IFormatProvider, out double)"/> with <see cref="CultureInfo"/> <c>InvariantCulture</c>.
	/// Fails if the string is <c>null</c> or <c>""</c> or isn't a valid floating-point number.
	/// Examples of valid numbers: <c>"12"</c>, <c>" -12.3 "</c>, <c>".12"</c>, <c>"12."</c>, <c>"12E3"</c>, <c>"12.3e-45"</c>, <c>"1,234.5"</c> (with <i>style</i> <c>NumberStyles.Float | NumberStyles.AllowThousands</c>). String like <c>"2text"</c> is invalid, unless <i>range</i> is <c>0..1</c>.
	/// </remarks>
	public static double ToNumber(this string t, Range? range = null, NumberStyles style = NumberStyles.Float) {
		ToNumber(t, out double r, range, style);
		return r;
	}

	/// <returns><c>false</c> if failed.</returns>
	/// <param name="result">Receives the result, or 0 if failed.</param>
	/// <inheritdoc cref="ToNumber(string, Range?, NumberStyles)"/>
	public static bool ToNumber(this string t, out double result, Range? range = null, NumberStyles style = NumberStyles.Float) {
		return double.TryParse(_NumSpan(t, range, out var ci), style, ci, out result);
	}

	/// <summary>
	/// Converts this string or its part to float number.
	/// </summary>
	/// <remarks>
	/// Calls <see cref="float.TryParse(RStr, NumberStyles, IFormatProvider, out float)"/> with <see cref="CultureInfo"/> <c>InvariantCulture</c>.
	/// </remarks>
	/// <inheritdoc cref="ToNumber(string, out double, Range?, NumberStyles)"/>
	public static bool ToNumber(this string t, out float result, Range? range = null, NumberStyles style = NumberStyles.Float) {
		return float.TryParse(_NumSpan(t, range, out var ci), style, ci, out result);
	}

	/// <summary>
	/// Converts this string or its part to <c>int</c> number.
	/// </summary>
	/// <remarks>
	/// Calls <see cref="int.TryParse(RStr, NumberStyles, IFormatProvider, out int)"/> with <see cref="CultureInfo"/> <c>InvariantCulture</c>.
	/// </remarks>
	/// <inheritdoc cref="ToNumber(string, out double, Range?, NumberStyles)"/>
	public static bool ToNumber(this string t, out int result, Range? range = null, NumberStyles style = NumberStyles.Integer) {
		return int.TryParse(_NumSpan(t, range, out var ci), style, ci, out result);

		//note: exception if NumberStyles.Integer | NumberStyles.AllowHexSpecifier.
		//	Can parse either decimal or hex, not any.
		//	Does not support "0x". With AllowHexSpecifier eg "11" is 17, but "0x11" is invalid.
	}

	/// <summary>
	/// Converts this string or its part to <c>uint</c> number.
	/// </summary>
	/// <remarks>
	/// Calls <see cref="uint.TryParse(RStr, NumberStyles, IFormatProvider, out uint)"/> with <see cref="CultureInfo"/> <c>InvariantCulture</c>.
	/// </remarks>
	/// <inheritdoc cref="ToNumber(string, out double, Range?, NumberStyles)"/>
	public static bool ToNumber(this string t, out uint result, Range? range = null, NumberStyles style = NumberStyles.Integer) {
		return uint.TryParse(_NumSpan(t, range, out var ci), style, ci, out result);
	}

	/// <summary>
	/// Converts this string or its part to <c>long</c> number.
	/// </summary>
	/// <remarks>
	/// Calls <see cref="long.TryParse(RStr, NumberStyles, IFormatProvider, out long)"/> with <see cref="CultureInfo"/> <c>InvariantCulture</c>.
	/// </remarks>
	/// <inheritdoc cref="ToNumber(string, out double, Range?, NumberStyles)"/>
	public static bool ToNumber(this string t, out long result, Range? range = null, NumberStyles style = NumberStyles.Integer) {
		return long.TryParse(_NumSpan(t, range, out var ci), style, ci, out result);
	}

	/// <summary>
	/// Converts this string or its part to <c>ulong</c> number.
	/// </summary>
	/// <remarks>
	/// Calls <see cref="ulong.TryParse(RStr, NumberStyles, IFormatProvider, out ulong)"/>. Uses <see cref="CultureInfo.InvariantCulture"/> if the string range contains only ASCII characters, else uses current culture.
	/// </remarks>
	/// <inheritdoc cref="ToNumber(string, out double, Range?, NumberStyles)"/>
	public static bool ToNumber(this string t, out ulong result, Range? range = null, NumberStyles style = NumberStyles.Integer) {
		return ulong.TryParse(_NumSpan(t, range, out var ci), style, ci, out result);
	}

	[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.AggressiveOptimization)]
	static RStr _NumSpan(string t, Range? range, out CultureInfo ci) {
		ci = CultureInfo.InvariantCulture;
		if (t == null) return default;
		var (start, len) = range.GetOffsetAndLength(t.Length);

		//Workaround for .NET 5 preview 7 bug: if current user culture is eg Norvegian or Lithuanian,
		//	'number to/from string' functions use '−' (Unicode minus), not '-' (ASCII hyphen), even if in Control Panel is ASCII hyphen.
		//	Tested: no bug in .NET Core 3.1.
		//Also, in some cultures eg Arabic there are more chars.
		if (!t.AsSpan(start, len).IsAscii()) ci = CultureInfo.CurrentCulture;

		return t.AsSpan(start, len);
	}

	#endregion

	/// <summary>
	/// Inserts other string.
	/// </summary>
	/// <returns>The result string.</returns>
	/// <param name="t">This string.</param>
	/// <param name="startIndex">Offset in this string. Can be from end, like <c>^4</c>.</param>
	/// <param name="s">String to insert.</param>
	/// <exception cref="ArgumentOutOfRangeException">Invalid <i>startIndex</i>.</exception>
	public static string Insert(this string t, Index startIndex, string s) {
		return t.Insert(startIndex.GetOffset(t.Length), s);
	}

	/// <summary>
	/// Replaces part of this string with other string.
	/// </summary>
	/// <returns>The result string.</returns>
	/// <param name="t">This string.</param>
	/// <param name="startIndex">Offset in this string.</param>
	/// <param name="count">Count of characters to replace.</param>
	/// <param name="s">The replacement string.</param>
	/// <exception cref="ArgumentOutOfRangeException">Invalid <i>startIndex</i> or <i>count</i>.</exception>
	public static string ReplaceAt(this string t, int startIndex, int count, string s) {
		int i = startIndex;
		if (count == 0) return t.Insert(i, s);
		return string.Concat(t.AsSpan(0, i), s, t.AsSpan(i + count));
	}

	/// <summary>
	/// Replaces part of this string with other string.
	/// </summary>
	/// <returns>The result string.</returns>
	/// <param name="t">This string.</param>
	/// <param name="range">Part of this string to replace.</param>
	/// <param name="s">The replacement string.</param>
	/// <exception cref="ArgumentOutOfRangeException">Invalid <i>range</i>.</exception>
	public static string ReplaceAt(this string t, Range range, string s) {
		var (i, count) = range.GetOffsetAndLength(t.Length);
		return ReplaceAt(t, i, count, s);
	}

	/// <summary>
	/// Removes part of this string.
	/// </summary>
	/// <returns>The result string.</returns>
	/// <param name="t">This string.</param>
	/// <param name="range">Part of this string to remove.</param>
	/// <exception cref="ArgumentOutOfRangeException">Invalid <i>ranget</i>.</exception>
	public static string Remove(this string t, Range range) {
		var (i, count) = range.GetOffsetAndLength(t.Length);
		return t.Remove(i, count);
	}

	//rejected. Use [..^count].
	///// <summary>
	///// Removes <i>count</i> characters from the end of this string.
	///// </summary>
	///// <returns>The result string.</returns>
	///// <param name="t">This string.</param>
	///// <param name="count">Count of characters to remove.</param>
	///// <exception cref="ArgumentOutOfRangeException"></exception>
	//public static string RemoveSuffix(this string t, int count) => t[^count];

	/// <summary>
	/// Removes <i>suffix</i> string from the end.
	/// </summary>
	/// <returns>The result string. Returns this string if does not end with <i>suffix</i>.</returns>
	/// <param name="t">This string.</param>
	/// <param name="suffix">Substring to remove.</param>
	/// <param name="ignoreCase">Case-insensitive.</param>
	/// <exception cref="ArgumentNullException"><i>suffix</i> is <c>null</c>.</exception>
	public static string RemoveSuffix(this string t, string suffix, bool ignoreCase = false) {
		if (!t.Ends(suffix, ignoreCase)) return t;
		return t[..^suffix.Length];
	}

	/// <summary>
	/// Removes <i>suffix</i> character from the end.
	/// </summary>
	/// <returns>The result string. Returns this string if does not end with <i>suffix</i>.</returns>
	/// <param name="t">This string.</param>
	/// <param name="suffix">Character to remove.</param>
	/// <exception cref="ArgumentNullException"><i>suffix</i> is <c>null</c>.</exception>
	public static string RemoveSuffix(this string t, char suffix) {
		if (!t.Ends(suffix)) return t;
		return t[..^1];
	}

	/// <summary>
	/// If this string is longer than <i>limit</i>, returns its substring 0 to <i>limit</i>-1 with appended <c>'…'</c> character.
	/// Else returns this string.
	/// </summary>
	/// <param name="t">This string.</param>
	/// <param name="limit">Maximal length of the result string. If less than 1, uses 1.</param>
	/// <param name="middle">Let <c>"…"</c> be in the middle. For example it is useful when the string is a file path, to avoid removing the filename.</param>
	/// <param name="lines"><i>limit</i> is lines, not characters.</param>
	public static string Limit(this string t, int limit, bool middle = false, bool lines = false) {
		if (limit < 1) limit = 1;
		if (lines) {
			var a = t.AsSpan().Lines();
			int k = a.Length;
			if (k > limit) {
				limit--; //for "…" line
				if (limit == 0) return t[a[0].Range] + "…";
				if (middle) {
					if (limit == 1) return t[a[0].Range] + "\r\n…";
					int half = limit - limit / 2; //if limit is odd number, prefer more lines at the start
					int half2 = a.Length - (limit - half);
					//if (half2 == a.Length - 1 && a[half2].Length == 0) return t[..a[half].end] + "\r\n…"; //rejected: if ends with newline, prefer more lines at the start than "\r\n…\r\n" at the end
					return t.ReplaceAt(a[half - 1].end..a[half2].start, "\r\n…\r\n");
				} else {
					return t[..a[limit - 1].end] + "\r\n…";
				}
			}
		} else if (t.Length > limit) {
			limit--; //for "…"
			if (middle) {
				int i = _Correct(t, limit / 2);
				int j = _Correct(t, t.Length - (limit - i), 1);
				return t.ReplaceAt(i..j, "…");
			} else {
				limit = _Correct(t, limit);
				return t[..limit] + "…";
			}

			//ensure not in the middle of a surrogate pair or \r\n
			static int _Correct(string s, int i, int d = -1) {
				if (i > 0 && i < s.Length) {
					char c = s[i - 1];
					if ((c == '\r' && s[i] == '\n') || char.IsSurrogatePair(c, s[i])) i += d;
				}
				return i;
			}
		}
		return t;
	}

	/// <summary>
	/// Replaces unsafe characters with C# escape sequences.
	/// If the string contains these characters, replaces and returns new string. Else returns this string.
	/// </summary>
	/// <param name="t">This string.</param>
	/// <param name="limit">If the final string is longer than <i>limit</i>, get its substring 0 to <i>limit</i>-1 with appended <c>'…'</c> character. The enclosing <c>""</c> are not counted.</param>
	/// <param name="quote">Enclose in <c>""</c>.</param>
	/// <remarks>
	/// Replaces these characters: <c>'\\'</c>, <c>'"'</c>, <c>'\t'</c>, <c>'\n'</c>, <c>'\r'</c> and all in range 0-31.
	/// </remarks>
	[MethodImpl(MethodImplOptions.AggressiveOptimization)]
	public static string Escape(this string t, int limit = 0, bool quote = false) {
		int i, len = t.Length;
		if (len == 0) return quote ? "\"\"" : t;

		if (limit > 0) {
			if (len > limit) len = limit - 1; else limit = 0;
		}

		for (i = 0; i < len; i++) {
			var c = t[i];
			if (c < ' ' || c == '\\' || c == '"') goto g1;
			//tested: Unicode line-break chars in most controls don't break lines, therefore don't need to escape
		}
		if (limit > 0) t = Limit(t, limit);
		if (quote) t = "\"" + t + "\"";
		return t;
		g1:
		using (new StringBuilder_(out var b, len + len / 16 + 100)) {
			if (quote) b.Append('"');
			for (i = 0; i < len; i++) {
				var c = t[i];
				if (c < ' ') {
					switch (c) {
					case '\t': b.Append("\\t"); break;
					case '\n': b.Append("\\n"); break;
					case '\r': b.Append("\\r"); break;
					case '\0': b.Append("\\0"); break;
					default: b.Append("\\u").Append(((ushort)c).ToString("x4")); break;
					}
				} else if (c == '\\') b.Append("\\\\");
				else if (c == '"') b.Append("\\\"");
				else b.Append(c);

				if (limit > 0 && b.Length - (quote ? 1 : 0) >= len) break;
			}

			if (limit > 0) b.Append('…');
			if (quote) b.Append('"');
			return b.ToString();
		}
	}

	/// <summary>
	/// Replaces C# escape sequences to characters in this string.
	/// </summary>
	/// <returns><c>false</c> if the string contains an invalid or unsupported escape sequence.</returns>
	/// <param name="t">This string.</param>
	/// <param name="result">Receives the result string. It is this string if there are no escape sequences or if failed.</param>
	/// <remarks>
	/// Supports all escape sequences of <see cref="Escape"/>: <c>\\</c>, <c>\"</c>, <c>\t</c>, <c>\n</c>, <c>\r</c>, <c>\0</c>, <c>\uXXXX</c>.
	/// Does not support <c>\a</c>, <c>\b</c>, <c>\f</c>, <c>\v</c>, <c>\e</c>, <c>\'</c>, <c>\xXXXX</c>, <c>\UXXXXXXXX</c>.
	/// </remarks>
	[MethodImpl(MethodImplOptions.AggressiveOptimization)]
	public static bool Unescape(this string t, out string result) {
		result = t;
		int i = t.IndexOf('\\');
		if (i < 0) return true;

		using (new StringBuilder_(out var b, t.Length)) {
			b.Append(t, 0, i);

			for (; i < t.Length; i++) {
				char c = t[i];
				if (c == '\\') {
					if (++i == t.Length) return false;
					switch (c = t[i]) {
					case '\\': case '"': break;
					case 't': c = '\t'; break;
					case 'n': c = '\n'; break;
					case 'r': c = '\r'; break;
					case '0': c = '\0'; break;
					//case 'a': c = '\a'; break;
					//case 'b': c = '\b'; break;
					//case 'f': c = '\f'; break;
					//case 'v': c = '\v'; break;
					//case 'e': c = '\e'; break;
					//also we don't support U and x
					case 'u':
						if (!_Uni(t, ++i, 4, out int u)) return false;
						c = (char)u;
						i += 3;
						break;
					default: return false;
					}
				}
				b.Append(c);
			}

			result = b.ToString();
			return true;
		}

		static bool _Uni(string t, int i, int maxLen, out int R) {
			R = 0;
			int to = i + maxLen; if (to > t.Length) return false;
			for (; i < to; i++) {
				int k = _CharHexToDec(t[i]); if (k < 0) return false;
				R = (R << 4) + k;
			}
			return true;
		}
	}

	/// <returns>New string if replaced, else this string. Does not replace if the string does not contain escape sequences or if some escape sequences are invalid or unsupported.</returns>
	/// <inheritdoc cref="Unescape(string, out string)"/>
	public static string Unescape(this string t) {
		Unescape(t, out t);
		return t;
	}

	/// <summary>
	/// Reverses this string, like <c>"Abc"</c> -> <c>"cbA"</c>.
	/// </summary>
	/// <returns>The result string.</returns>
	/// <param name="t"></param>
	/// <param name="raw">Ignore <c>char</c> sequences such as Unicode surrogates and grapheme clusters. Faster, but if the string contains these sequences, the result string is incorrect.</param>
	public static unsafe string ReverseString(this string t, bool raw) {
		if (t.Length < 2) return t;
		var r = new string('\0', t.Length);
		fixed (char* p = r) {
			if (raw || t.IsAscii()) {
				for (int i = 0, j = t.Length; i < t.Length; i++) {
					p[--j] = t[i];
				}
			} else {
				var a = StringInfo.ParseCombiningCharacters(t); //speed: same as StringInfo.GetTextElementEnumerator+MoveNext+ElementIndex
				for (int gTo = t.Length, j = 0, i = a.Length; --i >= 0; gTo = a[i]) {
					for (int g = a[i]; g < gTo; g++) p[j++] = t[g];
				}
			}
		}
		return r;

		//tested: string.Create slower.
	}

	/// <summary>
	/// Returns <c>true</c> if does not contain non-ASCII characters.
	/// </summary>
	public static bool IsAscii(this string t) => t.AsSpan().IsAscii();
	//FUTURE: remove this and other functions that in C# 14+ are duplicate or useless.
	
	/// <summary>
	/// Returns <c>true</c> if does not contain non-ASCII characters.
	/// </summary>
	public static bool IsAscii(this RStr t) => !t.ContainsAnyExceptInRange((char)0, (char)127);
	
	/// <summary>
	/// Returns <c>true</c> if does not contain non-ASCII character bytes.
	/// </summary>
	public static bool IsAscii(this RByte t) => !t.ContainsAnyExceptInRange((byte)0, (byte)127);
	
	/// <summary>
	/// Returns <c>true</c> if null pointer.
	/// </summary>
	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	public static bool IsNull(this RStr t) => t == RStr.Empty;
	
	/// <summary>
	/// Returns <c>true</c> if null pointer.
	/// </summary>
	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	public static bool IsNull(this RByte t) => t == RByte.Empty;

	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	internal static int LengthThrowIfNull_(this RStr t) {
		int n = t.Length;
		if (n == 0 && t.IsNull()) throw new ArgumentNullException();
		return n;
	}

	/// <summary>
	/// Returns <c>true</c> if equals to string <i>s</i>, case-sensitive.
	/// </summary>
	/// <param name="t">This span.</param>
	/// <param name="s">Other string. Can be <c>null</c>.</param>
	/// <remarks>
	/// Uses ordinal comparison (does not depend on current culture/locale).
	/// </remarks>
	public static bool Eq(this RStr t, RStr s) => t.Equals(s, StringComparison.Ordinal);

	/// <summary>
	/// Returns <c>true</c> if equals to string <i>s</i>, case-insensitive.
	/// </summary>
	/// <param name="t">This span.</param>
	/// <param name="s">Other string. Can be <c>null</c>.</param>
	/// <remarks>
	/// Uses ordinal comparison (does not depend on current culture/locale).
	/// </remarks>
	public static bool Eqi(this RStr t, RStr s) => t.Equals(s, StringComparison.OrdinalIgnoreCase);

	/// <summary>
	/// Compares part of this span with string <i>s</i>. Returns <c>true</c> if equal.
	/// </summary>
	/// <param name="t">This span.</param>
	/// <param name="startIndex">Offset in this span. If invalid, returns <c>false</c>.</param>
	/// <param name="s">Other string.</param>
	/// <param name="ignoreCase">Case-insensitive.</param>
	/// <exception cref="ArgumentNullException"><i>s</i> is <c>null</c>.</exception>
	/// <remarks>
	/// Uses ordinal comparison (does not depend on current culture/locale).
	/// </remarks>
	public static bool Eq(this RStr t, int startIndex, RStr s, bool ignoreCase = false) {
		int ns = s.LengthThrowIfNull_();
		int to = startIndex + ns, tlen = t.Length;
		if (to > tlen || (uint)startIndex > tlen) return false;
		t = t[startIndex..to];
		if (!ignoreCase) return t.SequenceEqual(s);
		return t.Equals(s, StringComparison.OrdinalIgnoreCase);
	}

	/// <summary>
	/// Returns <c>true</c> if the specified character is at the specified position in this span.
	/// </summary>
	/// <param name="t">This span.</param>
	/// <param name="index">Offset in this span. If invalid, returns <c>false</c>.</param>
	/// <param name="c">Character.</param>
	public static bool Eq(this RStr t, int index, char c) {
		if ((uint)index >= t.Length) return false;
		return t[index] == c;
	}

	/// <summary>
	/// Returns <c>true</c> if starts with string <i>s</i>.
	/// </summary>
	/// <param name="t">This span.</param>
	/// <param name="s">Other string.</param>
	/// <param name="ignoreCase">Case-insensitive.</param>
	/// <remarks>
	/// Uses ordinal comparison (does not depend on current culture/locale).
	/// </remarks>
	public static bool Starts(this RStr t, RStr s, bool ignoreCase = false) => t.StartsWith(s, ignoreCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal);

	/// <summary>
	/// Returns <c>true</c> if starts with string <i>s</i>.
	/// </summary>
	/// <param name="t">This span.</param>
	/// <param name="s">Other string.</param>
	/// <param name="ignoreCase">Case-insensitive.</param>
	/// <remarks>
	/// Uses ordinal comparison (does not depend on current culture/locale).
	/// </remarks>
	public static bool Ends(this RStr t, RStr s, bool ignoreCase = false) => t.EndsWith(s, ignoreCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal);
	
	/// <summary>
	/// Finds character <i>c</i> in this span, starting from <i>startIndex</i>.
	/// </summary>
	/// <returns>Character index in this span, or -1 if not found.</returns>
	/// <exception cref="ArgumentOutOfRangeException"></exception>
	public static int IndexOf(this RStr t, int startIndex, char c) {
		int i = t[startIndex..].IndexOf(c);
		return i < 0 ? i : i + startIndex;
	}

	/// <summary>
	/// Finds character <i>c</i> in <i>range</i> of this span.
	/// </summary>
	/// <returns>Character index in this span, or -1 if not found.</returns>
	/// <exception cref="ArgumentOutOfRangeException"></exception>
	public static int IndexOf(this RStr t, Range range, char c) {
		int i = t[range].IndexOf(c);
		if (i < 0) return i;
		return i + range.Start.GetOffset(t.Length);
	}

	/// <summary>
	/// Finds string <i>s</i> in this span, starting from <i>startIndex</i>.
	/// </summary>
	/// <returns>Character index in this span, or -1 if not found.</returns>
	/// <exception cref="ArgumentOutOfRangeException"></exception>
	/// <exception cref="ArgumentNullException"><i>s</i> is <c>null</c>.</exception>
	public static int IndexOf(this RStr t, int startIndex, RStr s, bool ignoreCase = false) {
		if (s.IsNull()) throw new ArgumentNullException();
		int i = t[startIndex..].IndexOf(s, ignoreCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal);
		return i < 0 ? i : i + startIndex;
	}

	/// <summary>
	/// Finds string <i>s</i> in <i>range</i> of this span.
	/// </summary>
	/// <returns>Character index in this span, or -1 if not found.</returns>
	/// <exception cref="ArgumentOutOfRangeException"></exception>
	/// <exception cref="ArgumentNullException"><i>s</i> is <c>null</c>.</exception>
	public static int IndexOf(this RStr t, Range range, RStr s, bool ignoreCase = false) {
		if (s.IsNull()) throw new ArgumentNullException();
		int i = t[range].IndexOf(s, ignoreCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal);
		if (i < 0) return i;
		return i + range.Start.GetOffset(t.Length);
	}

#if !DEBUG
	/// <summary>
	/// Alias of <c>IndexOfAnyExcept</c>.
	/// </summary>
	[EditorBrowsable(EditorBrowsableState.Never)] //.NET now has IndexOfAnyExcept
	public static int IndexOfNot(this RStr t, string chars) => t.IndexOfAnyExcept(chars);
	
	/// <summary>
	/// Alias of <c>LastIndexOfAnyExcept</c>.
	/// </summary>
	[EditorBrowsable(EditorBrowsableState.Never)] //.NET now has LastIndexOfAnyExcept
	public static int LastIndexOfNot(this RStr t, string chars) => t.LastIndexOfAnyExcept(chars);
#endif

	internal static void CopyTo_(this string t, char* p)
		=> t.AsSpan().CopyTo(new Span<char>(p, t.Length));

	/// <summary>
	/// Converts to UTF-8 (<c>Encoding.UTF8.GetBytes</c>).
	/// </summary>
	public static byte[] ToUTF8(this string t)
		=> Encoding.UTF8.GetBytes(t);

	/// <summary>
	/// Converts to UTF-8.
	/// </summary>
	/// <param name="append0">Return 0-terminated UTF-8 string.</param>
	public static byte[] ToUTF8(this RStr t, bool append0 = false)
		=> Convert2.Utf8Encode(t, append0 ? "\0" : null);

	/// <summary>
	/// Converts to UTF-8.
	/// </summary>
	/// <param name="append0">Return 0-terminated UTF-8 string.</param>
	public static byte[] ToUTF8(this Span<char> t, bool append0 = false)
		=> Convert2.Utf8Encode(t, append0 ? "\0" : null);

	/// <summary>
	/// Converts UTF-8 string to string.
	/// </summary>
	public static string ToStringUTF8(this byte[] t)
		=> Encoding.UTF8.GetString(t);

	/// <summary>
	/// Converts UTF-8 string to string.
	/// </summary>
	public static string ToStringUTF8(this RByte t)
		=> Encoding.UTF8.GetString(t);

	/// <summary>
	/// Converts UTF-8 string to string.
	/// </summary>
	public static string ToStringUTF8(this Span<byte> t)
		=> Encoding.UTF8.GetString(t);

	/// <summary>
	/// Splits this string. Trims, and removes empty.
	/// </summary>
	/// <returns>Array containing 0 or more strings.</returns>
	internal static string[] Split_(this string t, char c) {
		return t.Split(c, StringSplitOptions.TrimEntries | StringSplitOptions.RemoveEmptyEntries);
	}

	/// <summary>
	/// Splits this string and creates <c>HashSet</c>. Trims, and removes empty.
	/// </summary>
	/// <returns><c>HashSet</c> containing 0 or more strings.</returns>
	internal static HashSet<string> SplitHS_(this string t, char c, bool ignoreCase) {
		return t.Split_(c).ToHashSet(ignoreCase ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal);
	}

	/// <summary>
	/// Splits string <i>s</i> into 2 strings.
	/// Tip: there are 2 overloads: for string and for <c>RStr</c>.
	/// </summary>
	/// <param name="t"></param>
	/// <param name="c">Separator character.</param>
	/// <param name="s1">String at the left.</param>
	/// <param name="s2">String at the right.</param>
	/// <param name="minLen1">Minimal <i>s1</i> length.</param>
	/// <param name="minLen2">Minimal <i>s2</i> length.</param>
	/// <returns>Returns <c>false</c> if character <i>c</i> not found or if strings are too short.</returns>
	/// <remarks>
	///	Can be used to split strings like <c>"name=value"</c> or <c>"name: value"</c> or <c>"s1 s2"</c> etc. Trims spaces.
	/// </remarks>
	internal static bool Split2_(this string t, char c, out string s1, out string s2, int minLen1, int minLen2) {
		if (!Split2_(t, c, out RStr k1, out RStr k2, minLen1, minLen2)) {
			s1 = s2 = null;
			return false;
		}
		s1 = k1.ToString();
		s2 = k2.ToString();
		return true;
	}

	/// <inheritdoc cref="Split2_(string, char, out string, out string, int, int)"/>
	internal static bool Split2_(this RStr t, char c, out RStr s1, out RStr s2, int minLen1, int minLen2) {
		t = t.Trim();
		int i = t.IndexOf(c);
		if (i >= 0) {
			s1 = t[..i].TrimEnd();
			s2 = t[++i..].TrimStart();
			if (s1.Length >= minLen1 && s2.Length >= minLen2) return true;
		}
		s1 = default;
		s2 = default;
		return false;
	}

	/// <summary>
	/// If <i>index</i> is in this string, returns character at <i>index</i>. Else <c>'\0'</c>.
	/// </summary>
	internal static char At_(this string t, int index) => (uint)index < t.Length ? t[index] : default;

	/// <summary>
	/// If <i>index</i> is in this string span, returns character at <i>index</i>. Else <c>'\0'</c>.
	/// </summary>
	internal static char At_(this RStr t, int index) => (uint)index < t.Length ? t[index] : default;
}

/// <summary>
/// Flags for <see cref="ExtString.ToInt"/> and similar functions.
/// </summary>
[Flags]
public enum STIFlags {
	/// <summary>
	/// Don't support hexadecimal numbers (numbers with prefix <c>"0x"</c>).
	/// </summary>
	NoHex = 1,

	/// <summary>
	/// The number in string is hexadecimal without a prefix, like <c>"1A"</c>.
	/// </summary>
	IsHexWithout0x = 2,

	/// <summary>
	/// Fail if string starts with a whitespace character.
	/// </summary>
	DontSkipSpaces = 4,
}

/// <summary>
/// Used with <see cref="ExtString.Upper(string, SUpper, CultureInfo)"/>
/// </summary>
public enum SUpper {
	/// <summary>
	/// Convert all characters to upper case.
	/// </summary>
	AllChars,

	/// <summary>
	/// Convert only the first character to upper case.
	/// </summary>
	FirstChar,

	/// <summary>
	/// Convert the first character of each word to upper case and other characters to lower case.
	/// Calls <see cref="TextInfo.ToTitleCase"/>.
	/// </summary>
	TitleCase,
}


================================================
FILE: Au/String/SegParser.cs
================================================
//Modified version of Microsoft.Extensions.Primitives.StringSegment. It is from github; current .NET does not have it, need to get from NuGet.
//Can be used instead of String.Split, especially when you want less garbage. Faster (the github version with StringTokenizer was slower).

#if !DEBUG
namespace Au.More {
	/// <summary>
	/// Splits a string into substrings as start/end offsets or strings.
	/// </summary>
	/// <remarks>
	/// Can be used with <c>foreach</c>. Normally you don't create <c>SegParser</c> instances explicitly; instead use <see cref="ExtString.Segments"/> with <c>foreach</c>.
	/// </remarks>
	[EditorBrowsable(EditorBrowsableState.Never)] //obsolete. See comments in ExtString.Segments.
	public struct SegParser : IEnumerable<StartEnd>, IEnumerator<StartEnd> {
		readonly string _separators;
		readonly string _s;
		readonly int _sStart, _sEnd;
		int _start, _end;
		ushort _sepLength;
		SegFlags _flags;
		
		/// <summary>
		/// Initializes this instance to split a string.
		/// </summary>
		/// <param name="s">The string.</param>
		/// <param name="separators">A string containing characters that delimit substrings. Or one of <see cref="SegSep"/> constants.</param>
		/// <param name="flags"></param>
		/// <param name="range">Part of the string to split.</param>
		public SegParser(string s, string separators, SegFlags flags = 0, Range? range = null) {
			_separators = separators;
			_s = s;
			_sepLength = 1;
			_flags = flags;
			(_sStart, _sEnd) = range.GetStartEnd(s.Length);
			_start = 0;
			_end = _sStart - 1;
		}
		
#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
		public SegParser GetEnumerator() => this;
		
		IEnumerator<StartEnd> IEnumerable<StartEnd>.GetEnumerator() => this;
		
		IEnumerator IEnumerable.GetEnumerator() => this;
		
		public StartEnd Current => new(_start, _end);
		
		object IEnumerator.Current => Current;
		
		[MethodImpl(MethodImplOptions.AggressiveOptimization)]
		public bool MoveNext() {
			gStart:
			int i = _end + _sepLength, to = _sEnd;
			if (i > to) return false;
			_start = i;
			string s = _s, sep = _separators;
			switch (sep.Length) {
			case 1: {
					var c = sep[0];
					for (; i < to; i++) if (s[i] == c) goto g1;
				}
				break;
			case 22:
				if (ReferenceEquals(sep, SegSep.Whitespace)) {
					for (; i < to; i++)
						if (char.IsWhiteSpace(s[i])) goto g1;
				} else if (ReferenceEquals(sep, SegSep.Word)) {
					for (; i < to; i++)
						if (!char.IsLetterOrDigit(s[i])) goto g1;
				} else if (ReferenceEquals(sep, SegSep.Line)) {
					_sepLength = 1;
					for (; i < to; i++) {
						var c = s[i];
						if (c > '\r') continue;
						if (c == '\r') goto g2; else if (c == '\n') goto g1;
					}
					break;
					g2:
					if (i < to - 1 && s[i + 1] == '\n') _sepLength = 2;
					break;
				} else goto default;
				break;
			default: {
					for (; i < to; i++) {
						var c = s[i];
						for (int j = 0; j < sep.Length; j++) if (c == sep[j]) goto g1; //speed: reverse slower
					}
				}
				break;
			}
			g1:
			_end = i;
			if (i == _start && 0 != (_flags & SegFlags.NoEmpty)) goto gStart;
			return true;
		}
		
		void IDisposable.Dispose() {
			//rejected. Normally this variable is not reused because GetEnumerator returns a copy.
			//_end = _sStart - 1;
		}
		
		public void Reset() {
			_end = _sStart - 1;
		}
#pragma warning restore CS1591 // Missing XML comment for publicly visible type or member
		
		/// <summary>
		/// Returns segment values as <c>string[]</c>.
		/// </summary>
		/// <param name="maxCount">The maximal number of substrings to get. If negative (default), gets all. Else if there are more substrings, the last element will contain single substring, unlike with <see cref="String.Split"/>.</param>
		[MethodImpl(MethodImplOptions.AggressiveOptimization)]
		public unsafe string[] ToStringArray(int maxCount = -1) {
			//All this big code is just to make this function as fast as String.Split. Also less garbage.
			//	Simple code is slower when substrings are very short.
			//	With short substrings, the parsing code takes less than half of time. Creating strings and arrays is the slow part.
			
			string100 a1 = new(); //at first use array on stack. When it is filled, use a2. Note: no [SkipLocalsInit], because references are always inited.
			List<string> a2 = null;
			
			int n = 0;
			for (; MoveNext(); n++) { //slightly faster than foreach
				if (maxCount >= 0 && n == maxCount) break;
				var s = _s[_start.._end];
				if (n < c_a1Size) {
					a1[n] = s;
				} else {
					a2 ??= new List<string>(c_a1Size * 2);
					a2.Add(s);
				}
			}
			_end = _sStart - 1; //reset, because this variable can be reused later. never mind: try/finally; it makes slightly slower.
			
			var r = new string[n];
			for (int i = 0, to = Math.Min(n, c_a1Size); i < to; i++) {
				r[i] = a1[i];
				a1[i] = null;
			}
			for (int i = c_a1Size; i < r.Length; i++) {
				r[i] = a2[i - c_a1Size];
			}
			return r;
		}
		
		const int c_a1Size = 50;
		[InlineArray(c_a1Size)]
		struct string100 { string s; }
	}
}

namespace Au.Types {
	/// <summary>
	/// Contains several string constants that can be used with some "split string" functions of this library to specify separators.
	/// </summary>
	[EditorBrowsable(EditorBrowsableState.Never)] //obsolete
	public static class SegSep {
		/// <summary>
		/// Specifies that separators are spaces, tabs, newlines and other characters for which <see cref="char.IsWhiteSpace(char)"/> returns <c>true</c>.
		/// </summary>
		public const string Whitespace = "SSlkGrJUMUutrbSK3s6Crw";
		
		/// <summary>
		/// Specifies that separators are all characters for which <see cref="char.IsLetterOrDigit(char)"/> returns <c>false</c>.
		/// </summary>
		public const string Word = "WWVL0EtrK0ShqYWb4n1CmA";
		
		/// <summary>
		/// Specifies that separators are substrings <c>"\r\n"</c>, as well as single characters <c>'\r'</c> and <c>'\n'</c>.
		/// </summary>
		public const string Line = "LLeg5AWCNkGTZDkWuyEa2g";
		
		//note: all must be of length 22.
	}
	
	/// <summary>
	/// Flags for <see cref="ExtString.Segments"/> and some other functions.
	/// </summary>
	[Flags]
	[EditorBrowsable(EditorBrowsableState.Never)] //obsolete
	public enum SegFlags : byte {
		/// <summary>
		/// Don't return empty substrings.
		/// For example, is string is <c>"one  two "</c> and separators is <c>" "</c>, return <c>{"one", "two"}</c> instead of <c>{"one", "", "two", ""}</c>.
		/// </summary>
		NoEmpty = 1,
	}
}
#endif


================================================
FILE: Au/String/StringUtil.cs
================================================
using System.Text.Json;

namespace Au.More;

/// <summary>
/// Miscellaneous rarely used string functions. Parsing etc.
/// </summary>
public static class StringUtil {
	/// <summary>
	/// Parses a function parameter that can optionally have a <c>"***name "</c> prefix, like <c>"***value xyz"</c>.
	/// </summary>
	/// <returns>0 - <i>s</i> does not start with <c>"***"</c>; <c>i+1</c> - <i>s</i> starts with <c>"***names[i] "</c>; -1 - <i>s</i> is invalid.</returns>
	/// <param name="s">Parameter. If starts with <c>"***"</c> and is valid, receives the <c>"value"</c> part; else unchanged. Can be <c>null</c>.</param>
	/// <param name="names">List of supported <c>"name"</c>.</param>
	/// <remarks>
	/// Used to parse parameters like <i>name</i> of <see cref="wnd.Child"/>.
	/// </remarks>
	internal static int ParseParam3Stars_(ref string s, params ReadOnlySpan<string> names) {
		if (s == null || !s.Starts("***")) return 0;
		for (int i = 0; i < names.Length; i++) {
			var ni = names[i];
			if (s.Length - 3 <= ni.Length || !s.Eq(3, ni)) continue;
			int j = 3 + ni.Length;
			char c = s[j]; if (c != ' ') break;
			s = s[(j + 1)..];
			return i + 1;
		}
		return -1;
	}
	
	/// <summary>
	/// Removes characters used to underline next character when the text is displayed in UI. Replaces two such characters with single.
	/// </summary>
	/// <param name="s">Can be <c>null</c>.</param>
	/// <param name="underlineChar"></param>
	/// <remarks>
	/// Character <c>'&amp;'</c> (in WPF <c>'_'</c>) is used to underline next character in displayed text of dialog controls and menu items. Two such characters are used to display single.
	/// The underline is displayed when using the keyboard with <c>Alt</c> key to select dialog controls and menu items.
	/// </remarks>
	[SkipLocalsInit]
	public static unsafe string RemoveUnderlineChar(string s, char underlineChar = '&') {
		if (s != null && s.Contains(underlineChar)) {
			using FastBuffer<char> b = new(s.Length);
			int j = 0; bool was = false;
			for (int i = 0; i < s.Length; i++) {
				if (s[i] == underlineChar) {
					if (i < s.Length - 1 && s[i + 1] == underlineChar) i++;
					else if (!was) { was = underlineChar == '_'; continue; } //WPF removes only first single _
				}
				b.p[j++] = s[i];
			}
			s = new string(b.p, 0, j);
		}
		return s;
	}
	
	/// <summary>
	/// Finds character used to underline next character when the text is displayed in UI.
	/// </summary>
	/// <returns>Character index, or -1 if not found.</returns>
	/// <param name="s">Can be <c>null</c>.</param>
	/// <param name="underlineChar"></param>
	public static int FindUnderlineChar(string s, char underlineChar = '&') {
		if (s != null) {
			for (int i = 0; i < s.Length; i++) {
				if (s[i] == underlineChar) {
					if (++i < s.Length && s[i] != underlineChar) return i;
				}
			}
		}
		return -1;
	}
	
	/// <summary>
	/// Converts array of command line arguments to string that can be passed to a "start process" function, for example <see cref="run.it"/>, <see cref="Process.Start"/>.
	/// </summary>
	/// <returns><c>null</c> if <i>a</i> is <c>null</c> or empty.</returns>
	/// <param name="a"></param>
	public static string CommandLineFromArray(string[] a) {
		if (a == null || a.Length == 0) return null;
		StringBuilder b = null;
		foreach (var v in a) {
			int esc = 0;
			if (v.NE()) esc = 1; else if (v.Contains('"')) esc = 2; else foreach (var c in v) if (c <= ' ') { esc = 1; break; }
			if (esc == 0 && a.Length == 1) return a[0];
			if (b == null) b = new StringBuilder(); else b.Append(' ');
			if (esc == 0) b.Append(v);
			else {
				b.Append('"');
				var s = v;
				if (esc == 2) {
					if (s.Find(@"\""") < 0) s = s.Replace(@"""", @"\""");
					else s = s.RxReplace(@"(\\*)""", @"$1$1\""");
				}
				if (s.Ends('\\')) s = s.RxReplace(@"(\\+)$", "$1$1");
				b.Append(s).Append('"');
			}
		}
		return b.ToString();
	}
	
	/// <summary>
	/// Parses command line arguments.
	/// Calls API <ms>CommandLineToArgvW</ms>.
	/// </summary>
	/// <returns>Empty array if <i>s</i> is <c>null</c> or <c>""</c>.</returns>
	public static unsafe string[] CommandLineToArray(string s) {
		if (s.NE()) return [];
		char** p = Api.CommandLineToArgvW(s, out int n);
		var a = new string[n];
		for (int i = 0; i < n; i++) a[i] = new string(p[i]);
		Api.LocalFree(p);
		return a;
	}
	
	/// <summary>
	/// If string contains a number at <i>startIndex</i>, gets that number as <c>int</c>, also gets the string part that follows it, and returns <c>true</c>.
	/// </summary>
	/// <param name="s"></param>
	/// <param name="num">Receives the number. Receives 0 if no number.</param>
	/// <param name="tail">Receives the string part that follows the number, or <c>""</c>. Receives <c>null</c> if no number. Can be this variable.</param>
	/// <param name="startIndex">Offset in this string where to start parsing.</param>
	/// <param name="flags"></param>
	/// <remarks>
	/// For example, for string <c>"25text"</c> or <c>"25 text"</c> gets <i>num</i> = <c>25</c>, <i>tail</i> = <c>"text"</c>.
	/// Everything else is the same as with <see cref="ExtString.ToInt(string, int, out int, STIFlags)"/>.
	/// </remarks>
	public static bool ParseIntAndString(string s, out int num, out string tail, int startIndex = 0, STIFlags flags = 0) {
		num = s.ToInt(startIndex, out int end, flags);
		if (end == 0) {
			tail = null;
			return false;
		}
		if (end < s.Length && s[end] == ' ') end++;
		tail = s[end..];
		return true;
	}
	
	/// <summary>
	/// Creates <c>int[]</c> from string containing space-separated numbers, like <c>"4 100 -8 0x10"</c>.
	/// </summary>
	/// <param name="s">Decimal or/and hexadecimal numbers separated by single space. If <c>null</c> or <c>""</c>, returns empty array.</param>
	/// <remarks>
	/// For vice versa use <c>string.Join(" ", array)</c>.
	/// </remarks>
	public static int[] StringToIntArray(string s) {
		if (s.NE()) return [];
		int n = 1; foreach (var v in s) if (v == ' ') n++;
		var a = new int[n];
		a[0] = s.ToInt(0, STIFlags.DontSkipSpaces);
		for (int i = 0, j = 0; j < s.Length;) if (s[j++] == ' ') a[++i] = s.ToInt(j, STIFlags.DontSkipSpaces);
		return a;
	}
	
	/// <summary>
	/// Converts character index in string to line index and character index in that line.
	/// </summary>
	/// <param name="s"></param>
	/// <param name="index">Character index in string <i>s</i>.</param>
	/// <param name="lineIndex">Receives 0-based line index.</param>
	/// <param name="indexInLine">Receives 0-based character index in that line.</param>
	/// <exception cref="ArgumentOutOfRangeException"></exception>
	public static void LineAndColumn(string s, int index, out int lineIndex, out int indexInLine) {
		if ((uint)index > s.Length) throw new ArgumentOutOfRangeException();
		int line = 0, lineStart = 0;
		for (int i = 0; i < index; i++) {
			char c = s[i];
			if (c > '\r') continue;
			if (c != '\n') {
				if (c != '\r') continue;
				if (i < s.Length - 1 && s[i + 1] == '\n') continue;
			}
			
			lineStart = i + 1;
			line++;
		}
		lineIndex = line;
		indexInLine = index - lineStart;
	}
	
	/// <summary>
	/// Converts flags to string where flags are mapped to characters.
	/// </summary>
	/// <remarks>
	/// Don't use ASCII digits for flags, because <see cref="FlagsFromLetters"/> interprets a number-string as the flags value. Any other characters are OK, not only letters.
	/// </remarks>
	public static string FlagsToLetters(int flags, params (int flag, char c)[] map) {
		Span<char> a = stackalloc char[32];
		int len = 0;
		foreach (var (f, c) in map) {
			if (0 != (flags & f)) a[len++] = c;
		}
		return a[..len].ToString();
	}
	
	/// <summary>
	/// Parses flags from string where flags are mapped to characters. See <see cref="FlagsToLetters"/>
	/// </summary>
	/// <remarks>
	/// If the string is a number, interprets it as the flags value. Don't use ASCII digits for flags. Any other characters are OK, not only letters.
	/// </remarks>
	public static int FlagsFromLetters(string s, params (int flag, char c)[] map) {
		int r = 0;
		if (!s.NE() && !s.ToInt(out r)) {
			foreach (var (f, c) in map) {
				if (s.Contains(c)) r |= f;
			}
		}
		return r;
	}
	
	/// <summary>
	/// Calculates the Levenshtein distance between two strings, which tells how much they are different.
	/// </summary>
	/// <remarks>
	/// It is the number of character edits (removals, inserts, replacements) that must occur to get from string <i>s1</i> to string <i>s2</i>.
	/// Can be used to measure similarity and match approximate strings with fuzzy logic.
	/// Uses code and info from <see href="https://www.dotnetperls.com/levenshtein"/>.
	/// </remarks>
	public static int LevenshteinDistance(RStr s1, RStr s2) {
		int n = s1.Length;
		int m = s2.Length;
		
		// Step 1
		if (n == 0) return m;
		if (m == 0) return n;
		
		// Step 2
		int[,] d = new int[n + 1, m + 1];
		for (int i = 0; i <= n; d[i, 0] = i++) { }
		for (int j = 0; j <= m; d[0, j] = j++) { }
		
		// Step 3
		for (int i = 1; i <= n; i++) {
			//Step 4
			for (int j = 1; j <= m; j++) {
				// Step 5
				int cost = (s2[j - 1] == s1[i - 1]) ? 0 : 1;
				
				// Step 6
				d[i, j] = Math.Min(
					Math.Min(d[i - 1, j] + 1, d[i, j - 1] + 1),
					d[i - 1, j - 1] + cost);
			}
		}
		// Step 7
		return d[n, m];
	}
	
	/// <summary>
	/// Returns the number of characters common to the start of each string.
	/// </summary>
	public static int CommonPrefix(RStr s1, RStr s2) {
		int n = Math.Min(s1.Length, s2.Length);
		for (int i = 0; i < n; i++) {
			if (s1[i] != s2[i]) return i;
		}
		return n;
	}
	
	/// <summary>
	/// Returns the number of characters common to the end of each string.
	/// </summary>
	public static int CommonSuffix(RStr s1, RStr s2) {
		int len1 = s1.Length;
		int len2 = s2.Length;
		int n = Math.Min(len1, len2);
		for (int i = 1; i <= n; i++) {
			if (s1[len1 - i] != s2[len2 - i]) return i - 1;
		}
		return n;
	}
	
	/// <summary>
	/// Converts JSON element to multiline indented JSON string.
	/// </summary>
	public static string JsonMultiline(JsonElement json) {
		var so = s_jsOptions.Value;
		return JsonSerializer.Serialize(json, so);
	}
	
	/// <summary>
	/// Converts single-line JSON string to multiline indented JSON string.
	/// </summary>
	public static string JsonMultiline(string json) {
		var so = s_jsOptions.Value;
		var v = JsonSerializer.Deserialize<JsonElement>(json, so);
		return JsonSerializer.Serialize(v, so);
	}
	
	static readonly Lazy<JsonSerializerOptions> s_jsOptions = new(() => new() {
		WriteIndented = true
		//Encoder = JavaScriptEncoder.UnsafeRelaxedJsonEscaping,
	});
	
	internal static JsonSerializerOptions JsonOptions_ => s_jsOptions.Value;
	
	/// <summary>Calls <see cref="Encoding.GetEncoding(string)"/>, and <see cref="Encoding.RegisterProvider"/> if need.</summary>
	/// <returns><c>null</c> if failed.</returns>
	public static Encoding GetEncoding(string name) => _GetEncoding(name ?? throw new ArgumentNullException());
	
	/// <summary>Calls <see cref="Encoding.GetEncoding(int)"/>, and <see cref="Encoding.RegisterProvider"/> if need.</summary>
	/// <param name="codepage">If -1, uses the current Windows ANSI code page (API <ms>GetACP</ms>).</param>
	/// <returns><c>null</c> if failed.</returns>
	public static Encoding GetEncoding(int codepage) => _GetEncoding(null, codepage == -1 ? Api.GetACP() : codepage);
	
	static Encoding _GetEncoding(string name = null, int codepage = 0) {
		g1:
		try { return name != null ? Encoding.GetEncoding(name) : Encoding.GetEncoding(codepage); }
		catch {
			if (Interlocked.CompareExchange(ref s_encodingInited, 1, 0) == 0) {
				Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
				goto g1;
			}
		}
		return null;
	}
	static int s_encodingInited;
}


================================================
FILE: Au/String/csvTable.cs
================================================
namespace Au;

/// <summary>
/// Parses and composes CSV text. CSV table data in memory as a <c>List</c> of string arrays.
/// </summary>
/// <remarks>
/// CSV is a text format used to store a single table of data in human-readable/editable way.
/// It is a list of lines (called rows or records) containing one or more values (called fields or cells) separated by a separator character.
/// 
/// There is no strictly defined CSV standard. This class uses these rules:
/// <br/>• Fields containing separator characters (default <c>','</c>), quote characters (default <c>'"'</c>) and multiple lines are enclosed in quote characters. Example: <c>"ab, cd"</c>.
/// <br/>• Each quote character in such fields is escaped (replaced) with two quote characters. Example: <c>"ab ""cd"" ef"</c>.
/// <br/>• If a field value starts or ends with ASCII space or tab characters, it is enclosed in quote characters. Example: <c>" ab "</c>. Or use parameter <i>trimSpaces</i> <c>false</c> when parsing.
/// <br/>• Rows in CSV text can have different field count. All rows in in-memory CSV table have equal field count.
/// </remarks>
/// <example>
/// <code><![CDATA[
/// var c = new csvTable();
/// c.AddRow("A", "B");
/// c.AddRow("C", "D");
/// var csv = c.ToString();
/// print.it(csv);
/// 
/// var k = csvTable.parse(csv);
/// for (int row = 0; row < k.RowCount; row++) {
/// 	print.it(k[row, 0], k[row, 1]);
/// }
/// ]]></code>
/// </example>
public class csvTable {
	readonly List<string[]> _a;
	
	/// <summary>
	/// Initializes new <see cref="csvTable"/> variable that can be used to add rows.
	/// To create new variables from CSV text, file or dictionary, instead use static functions, for example <see cref="parse"/>.
	/// </summary>
	public csvTable() { _a = new(); }
	
	csvTable(List<string[]> a, int columnCount) { _a = a; _columnCount = columnCount; }
	
	/// <summary>
	/// Gets the internal <c>List</c> containing rows as string arrays.
	/// </summary>
	/// <remarks>
	/// It's not a copy; changing its content will change content of this <see cref="csvTable"/> variable.
	/// You can do anything with the <c>List</c>. For example, sort it, find rows containing certain field values, get/set field values directly, add/remove rows directly.
	/// All row arrays have <c>Length</c> equal to <see cref="ColumnCount"/>, and it must remain so; you can change <c>Length</c>, but then need to call <c>ColumnCount=newLength</c>.
	/// </remarks>
	/// <example>
	/// <code><![CDATA[
	/// x.Rows.Sort((a,b) => string.CompareOrdinal(a[0], b[0]));
	/// ]]></code>
	/// </example>
	public List<string[]> Rows => _a;
	
	/// <summary>
	/// Sets or gets the field separator character used when composing CSV text.
	/// Initially it is <c>','</c>.
	/// </summary>
	public char Separator { get; set; } = ',';
	
	/// <summary>
	/// Sets or gets the quote character used when composing CSV text.
	/// Initially it is <c>'"'</c>.
	/// </summary>
	public char Quote { get; set; } = '"';
	
	/// <summary>
	/// Parses CSV string and creates new <see cref="csvTable"/> variable that contains data in internal <c>List</c> of string arrays.
	/// </summary>
	/// <param name="csv">
	/// CSV text.
	/// If rows in CSV text have different field count, the longest row sets the <see cref="ColumnCount"/> property and lengths of all row arrays; array elements of missing CSV fields will be <c>null</c>.
	/// </param>
	/// <param name="separator">Field separator character used in CSV text. Default <c>','</c>.</param>
	/// <param name="quote">Character used in CSV text to enclose some fields. Default <c>'"'</c>.</param>
	/// <param name="trimSpaces">Ignore ASCII space and tab characters surrounding fields in CSV text. Default <c>true</c>.</param>
	/// <exception cref="FormatException">Invalid CSV, eg contains incorrectly enclosed fields.</exception>
	[MethodImpl(MethodImplOptions.AggressiveOptimization)]
	public static unsafe csvTable parse(string csv, char separator = ',', char quote = '"', bool trimSpaces = true) {
		if (csv.NE()) return new csvTable();
		
		var a = new List<string[]>();
		var tempRow = new List<string>(8);
		string sQuote1 = null, sQuote2 = null;
		
		fixed (char* s0 = csv) {
			char* s = s0, se = s0 + csv.Length;
			int nCol = 0;
			
			for (; s < se; s++) {
				//Read a field.
				string field = "";
				if (trimSpaces) { //ltrim
					while (*s == ' ' || *s == '\t') if (++s == se) goto g1;
				}
				char* f, e; //field beginning and end, not including spaces
				bool hasEscapedQuote = false;
				if (*s == quote) {
					f = ++s;
					bool hasClosingQuote = false;
					while (s < se) {
						if (*s++ == quote) {
							if (s < se && *s == quote) { s++; hasEscapedQuote = true; } //escaped quote
							else { hasClosingQuote = true; break; }
						}
					}
					if (!hasClosingQuote) throw new FormatException($"Invalid CSV format. Cells that start with {quote} must end with {quote}.");
					e = s - 1; //before quote
					if (trimSpaces) { //rtrim
						while (s < se && (*s == ' ' || *s == '\t')) s++;
					}
					if (s < se && !(*s == separator || *s == '\n')) {
						if (*s == '\r' && s < se + 1 && s[1] == '\n') s++;
						else throw new FormatException($"Invalid CSV format. For {quote} in enclosed cells use {quote}{quote}.");
					}
				} else {
					f = s; //field start
					while (s < se && *s != separator && *s != '\n') s++; //skip field, space and \r
					e = s; if (e > f && *e == '\n' && e[-1] == '\r') e--;
					if (trimSpaces) { //rtrim
						while (e > f && (e[-1] == ' ' || e[-1] == '\t')) e--;
					}
				}
				field = new string(f, 0, (int)(e - f)); //field to string
				if (hasEscapedQuote) {
					if (sQuote1 == null) { sQuote1 = new string(quote, 1); sQuote2 = new string(quote, 2); }
					field = field.Replace(sQuote2, sQuote1);
				}
				g1:
				
				//print.it(field);
				
				tempRow.Add(field);
				if (s >= se || *s == '\n') {
					//print.it(a.Count);
					//print.it(tempRow);
					
					a.Add(tempRow.ToArray());
					if (tempRow.Count > nCol) nCol = tempRow.Count;
					tempRow.Clear();
				}
			}
			
			var R = new csvTable(a, 0);
			R.ColumnCount = nCol; //make all rows of equal length and set _columnCount
			return R;
		} //fixed
	}
	
	/// <summary>
	/// Composes CSV text from the internal <c>List</c> of string arrays.
	/// </summary>
	/// <remarks>
	/// Depends on these properties: <see cref="Separator"/> (initially <c>','</c>), <see cref="Quote"/> (initially <c>'"'</c>).
	/// </remarks>
	public override string ToString() {
		if (RowCount == 0 || ColumnCount == 0) return "";
		
		using (new StringBuilder_(out var b)) {
			char quote = Quote;
			string sQuote1 = null, sQuote2 = null;
			
			for (int r = 0; r < _a.Count; r++) {
				for (int c = 0; c < _columnCount; c++) {
					var field = _a[r][c];
					if (!field.NE()) {
						bool hasQuote = field.Contains(quote);
						if (hasQuote || field.Contains(Separator) || field[0] == ' ' || field[^1] == ' ') {
							if (hasQuote) {
								if (sQuote1 == null) { sQuote1 = new string(quote, 1); sQuote2 = new string(quote, 2); }
								field = field.Replace(sQuote1, sQuote2);
							}
							b.Append(quote).Append(field).Append(quote);
						} else b.Append(field);
					}
					if (c < _columnCount - 1) b.Append(Separator);
				}
				b.AppendLine();
			}
			return b.ToString();
		}
	}
	
	/// <summary>
	/// Gets or sets row count.
	/// The <c>get</c> function returns the <c>Count</c> property of the internal <c>List</c> of string arrays.
	/// The <c>set</c> function can add new rows or remove rows at the end.
	/// </summary>
	public int RowCount {
		get => _a.Count;
		set {
			if (value > _a.Count) {
				_a.Capacity = value;
				while (_a.Count < value) _a.Add(_columnCount > 0 ? new string[_columnCount] : null);
			} else if (value < _a.Count) {
				_a.RemoveRange(value, _a.Count - value);
			}
		}
	}
	
	/// <summary>
	/// Gets or sets column count.
	/// The <c>get</c> function returns the length of all string arrays in the internal <c>List</c>.
	/// The <c>set</c> function can add new columns or remove columns at the right.
	/// </summary>
	public int ColumnCount {
		get => _columnCount;
		set {
			if (value <= 0) throw new ArgumentOutOfRangeException();
			//if(value == _columnCount) return;
			for (int r = 0; r < _a.Count; r++) {
				var o = _a[r];
				if (o == null) _a[r] = new string[value];
				else if (o.Length != value) {
					var t = new string[value];
					if (value > _columnCount) o.CopyTo(t, 0);
					else {
						for (int c = 0; c < value; c++) t[c] = o[c];
					}
					_a[r] = t;
				}
			}
			
			_columnCount = value;
		}
	}
	int _columnCount;
	
	/// <summary>
	/// Gets or sets a field.
	/// </summary>
	/// <param name="row">0-based row index. The <c>set</c> function adds new row if negative or equal to <see cref="RowCount"/>.</param>
	/// <param name="column">0-based column index. With the <c>set</c> function it can be >= <see cref="ColumnCount"/> and &lt; 1000; then sets <c>ColumnCount = column + 1</c>.</param>
	/// <exception cref="ArgumentOutOfRangeException"></exception>
	/// <example>
	/// <code><![CDATA[
	/// var c = new csvTable { ColumnCount = 2 };
	/// c[0, 0] = "A1";
	/// c[0, 1] = "A2";
	/// c[1, 0] = "B1";
	/// c[1, 1] = "B2";
	/// print.it(c);
	/// string s = c[0, 0];
	/// print.it(s);
	/// ]]></code>
	/// </example>
	public string this[int row, int column] {
		get {
			if ((uint)column >= _columnCount) throw new ArgumentOutOfRangeException("column");
			if ((uint)row >= RowCount) throw new ArgumentOutOfRangeException("row");
			
			return _a[row][column];
		}
		set {
			//Auto-add columns.
			if (column < 0) column = int.MaxValue;
			if (column >= _columnCount) {
				if (column >= 1000) throw new ArgumentOutOfRangeException("column");
				ColumnCount = column + 1;
			}
			//Auto-add row.
			if (row < 0) row = RowCount;
			if (row >= RowCount) {
				if (row > RowCount) throw new ArgumentOutOfRangeException("row");
				_a.Add(new string[_columnCount]);
			}
			
			_a[row][column] = value;
		}
	}
	
	/// <summary>
	/// Gets or sets a field.
	/// </summary>
	/// <param name="row">0-based row index. Can be from the end; for example <c>^1</c> is the last row. The <c>set</c> function adds new row if <c>^0</c>.</param>
	/// <param name="column">0-based column index. With the <c>set</c> function it can be >= <see cref="ColumnCount"/> and &lt; 1000; then sets <c>ColumnCount = column + 1</c>.</param>
	/// <exception cref="ArgumentOutOfRangeException"></exception>
	public string this[Index row, int column] {
		get => this[row.GetOffset(_a.Count), column];
		set { this[row.GetOffset(_a.Count), column] = value; }
	}
	
	/// <summary>
	/// Gets or sets fields in a row.
	/// </summary>
	/// <param name="row">0-based row index. The <c>set</c> function adds new row if negative or equal to <see cref="RowCount"/>.</param>
	/// <exception cref="ArgumentOutOfRangeException"></exception>
	/// <remarks>
	/// The <c>get</c> function gets the row array. It's not a copy; changing its elements will change content of this <see cref="csvTable"/> variable.
	/// The <c>set</c> function sets the row array. Does not copy the array, unless its <c>Length</c> is less than <see cref="ColumnCount"/>.
	/// </remarks>
	/// <example>
	/// <code><![CDATA[
	/// var c = new csvTable();
	/// c[-1] = ["A", "B"];
	/// c[-1] = ["C", "D"];
	/// print.it(c);
	/// for (int row = 0; row < c.RowCount; row++) {
	/// 	print.it(c[row, 0], c[row, 1]);
	/// }
	/// ]]></code>
	/// </example>
	public string[] this[int row] {
		get {
			if ((uint)row >= RowCount) throw new ArgumentOutOfRangeException();
			
			return _a[row];
		}
		set {
			//Auto-add row.
			if (row < 0) row = RowCount;
			if (row >= RowCount) {
				if (row > RowCount) throw new ArgumentOutOfRangeException();
				_a.Add(null);
			}
			
			var t = value;
			if (value == null || value.Length < _columnCount) {
				//make row length = _columnCount
				t = new string[_columnCount];
				value?.CopyTo(t, 0);
			} else if (value.Length > _columnCount) {
				//auto-add columns
				ColumnCount = value.Length;
			}
			
			_a[row] = t;
		}
	}
	
	/// <summary>
	/// Gets or sets fields in a row.
	/// </summary>
	/// <param name="row">0-based row index. Can be from the end; for example <c>^1</c> is the last row. The <c>set</c> function adds new row if <c>^0</c>.</param>
	/// <exception cref="ArgumentOutOfRangeException"></exception>
	/// <remarks>
	/// The <c>get</c> function gets the row array. It's not a copy; changing its elements will change content of this <see cref="csvTable"/> variable.
	/// The <c>set</c> function sets the row array. Does not copy the array, unless its <c>Length</c> is less than <see cref="ColumnCount"/>.
	/// </remarks>
	public string[] this[Index row] {
		get => this[row.GetOffset(_a.Count)];
		set { this[row.GetOffset(_a.Count)] = value; }
	}
	
	/// <summary>
	/// Adds new row and sets its fields.
	/// </summary>
	/// <param name="fields">Row fields. Can be a string array or multiple string arguments. Does not copy the array, unless its <c>Length</c> is less than <see cref="ColumnCount"/>. Adds new columns if array <c>Length</c> (or the number of string arguments) is greater than <c>ColumnCount</c>.</param>
	/// <exception cref="ArgumentOutOfRangeException"></exception>
	public void AddRow(params string[] fields) => InsertRow(-1, fields);
	
	/// <summary>
	/// Inserts new row and sets its fields.
	/// </summary>
	/// <param name="index">0-based row index. If negative or equal to <see cref="RowCount"/>, adds to the end.</param>
	/// <param name="fields">Row fields. Can be a string array or multiple string arguments. Does not copy the array, unless its <c>Length</c> is less than <see cref="ColumnCount"/>. Adds new columns if array <c>Length</c> (or the number of string arguments) is greater than <c>ColumnCount</c>.</param>
	/// <exception cref="ArgumentOutOfRangeException"></exception>
	public void InsertRow(int index, params string[] fields) {
		if (index < 0) index = RowCount;
		_a.Insert(index, null);
		this[index] = fields;
	}
	
	/// <summary>
	/// Inserts new empty row.
	/// </summary>
	/// <param name="index">0-based row index. If negative or equal to <see cref="RowCount"/>, adds to the end.</param>
	/// <exception cref="ArgumentOutOfRangeException"></exception>
	public void InsertRow(int index) {
		InsertRow(index, null);
	}
	
	/// <summary>
	/// Removes one or more rows.
	/// </summary>
	/// <param name="index">0-based row index.</param>
	/// <param name="count">How many rows to remove, default 1.</param>
	/// <exception cref="ArgumentOutOfRangeException"></exception>
	/// <exception cref="ArgumentException"></exception>
	public void RemoveRow(int index, int count = 1) {
		_a.RemoveRange(index, count);
	}
	
	//FUTURE: implement these. Rarely used. Quite much code.
	//Don't need to implement many others because users can call our _a (the Data property) methods directly.
	//public void MoveRow(int from, int to)
	//{
	
	//}
	
	//public void InsertColumn(int index)
	//{
	
	//}
	
	//public void RemoveColumn(int index)
	//{
	
	//}
	
	/// <summary>
	/// Loads and parses a CSV file.
	/// </summary>
	/// <param name="file">File. Must be full path. Can contain environment variables etc, see <see cref="pathname.expand"/>.</param>
	/// <param name="separator">Field separator character used in CSV text. Default <c>','</c>.</param>
	/// <param name="quote">Character used in CSV text to enclose some fields. Default <c>'"'</c>.</param>
	/// <param name="trimSpaces">Ignore ASCII space and tab characters surrounding fields in CSV text. Default <c>true</c>.</param>
	/// <exception cref="ArgumentException">Not full path.</exception>
	/// <exception cref="Exception">Exceptions of <see cref="File.ReadAllText(string)"/>.</exception>
	/// <exception cref="FormatException">Invalid CSV, eg contains incorrectly enclosed fields.</exception>
	/// <remarks>
	/// Calls <see cref="File.ReadAllText(string)"/> and <see cref="parse"/>. Also uses <see cref="filesystem.waitIfLocked"/>.
	/// </remarks>
	public static csvTable load(string file, char separator = ',', char quote = '"', bool trimSpaces = true) {
		var csv = filesystem.loadText(file);
		return parse(csv, separator, quote, trimSpaces);
	}
	
	/// <summary>
	/// Composes CSV and saves to a file.
	/// </summary>
	/// <param name="file">File. Must be full path. Can contain environment variables etc, see <see cref="pathname.expand"/>. The file can exist or not; this function overwrites it.</param>
	/// <param name="backup">Create backup file named <c>file + "~backup"</c>.</param>
	/// <exception cref="ArgumentException">Not full path.</exception>
	/// <exception cref="Exception">Exceptions of <see cref="File.WriteAllText(string, string)"/>.</exception>
	/// <remarks>
	/// Calls <see cref="ToString"/> and <see cref="File.WriteAllText(string, string)"/>. Also uses <see cref="filesystem.save"/>.
	/// </remarks>
	public void Save(string file, bool backup = false) {
		var csv = ToString();
		filesystem.saveText(file, csv, backup);
	}
	
	/// <summary>
	/// Creates 2-column CSV table from dictionary keys and values of type <c>string</c>.
	/// </summary>
	/// <param name="d"></param>
	/// <exception cref="ArgumentNullException"></exception>
	public static csvTable fromDictionary(Dictionary<string, string> d) {
		Not_.Null(d);
		var a = new List<string[]>(d.Count);
		foreach (var v in d) a.Add(new string[] { v.Key, v.Value });
		return new csvTable(a, 2);
	}
	
	/// <summary>
	/// Creates 2-column CSV table from dictionary keys and values of any type, using a callback function to convert values to <c>string</c>.
	/// </summary>
	/// <param name="d"></param>
	/// <param name="valueToString">Callback function that converts value of type <c>T</c> to <c>string</c>.</param>
	/// <exception cref="ArgumentNullException"></exception>
	public static csvTable fromDictionary<T>(Dictionary<string, T> d, Func<T, string> valueToString) {
		Not_.Null(d, valueToString);
		var a = new List<string[]>(d.Count);
		foreach (var v in d) {
			var t = valueToString(v.Value);
			a.Add(new string[] { v.Key, t });
		}
		return new csvTable(a, 2);
	}
	
	/// <summary>
	/// Creates CSV table of any column count from dictionary keys and values of any type, using a callback function to convert values to cell strings.
	/// </summary>
	/// <param name="d"></param>
	/// <param name="columnCount">CSV column count. Must be 2 or more.</param>
	/// <param name="valueToCells">Callback function that converts value of type <c>T</c> to one or more strings and puts them in row array elements starting from index 1. At index 0 is key.</param>
	/// <exception cref="ArgumentNullException"></exception>
	/// <exception cref="ArgumentOutOfRangeException"><i>columnCount</i> less than 2.</exception>
	public static csvTable fromDictionary<T>(Dictionary<string, T> d, int columnCount, Action<T, string[]> valueToCells) {
		Not_.Null(d, valueToCells);
		if (columnCount < 2) throw new ArgumentOutOfRangeException();
		var a = new List<string[]>(d.Count);
		foreach (var v in d) {
			var t = new string[columnCount];
			t[0] = v.Key;
			valueToCells(v.Value, t);
			a.Add(t);
		}
		return new csvTable(a, columnCount);
	}
	
	/// <summary>
	/// Creates dictionary from this 2-column CSV table.
	/// </summary>
	/// <param name="ignoreCase">Case-insensitive dictionary keys.</param>
	/// <param name="ignoreDuplicates">Don't throw exception if column 0 contains duplicate strings. Replace old value with new value.</param>
	/// <exception cref="InvalidOperationException"><see cref="ColumnCount"/> not 2.</exception>
	/// <exception cref="ArgumentException">Column 0 contains duplicate strings.</exception>
	public Dictionary<string, string> ToDictionary(bool ignoreCase, bool ignoreDuplicates) {
		if (_columnCount != 2) throw new InvalidOperationException("ColumnCount must be 2");
		var d = new Dictionary<string, string>(ignoreCase ? StringComparer.OrdinalIgnoreCase : null);
		foreach (var v in _a) {
			if (ignoreDuplicates) d[v[0]] = v[1];
			else d.Add(v[0], v[1]);
		}
		return d;
	}
	
	/// <summary>
	/// Creates dictionary from this CSV table of any column count, using a callback function to convert cell strings to dictionary values of any type.
	/// </summary>
	/// <param name="ignoreCase">Case-insensitive dictionary keys.</param>
	/// <param name="ignoreDuplicates">Don't throw exception if column 0 contains duplicate strings. Replace old value with new value.</param>
	/// <param name="rowToValue">Callback function that converts one or more cell strings to single value of type <c>T</c>. The array is whole row; element 0 is key, and usually is not used.</param>
	/// <exception cref="ArgumentNullException"></exception>
	/// <exception cref="InvalidOperationException"><see cref="ColumnCount"/> less than 2.</exception>
	/// <exception cref="ArgumentException">Column 0 contains duplicate strings.</exception>
	public Dictionary<string, T> ToDictionary<T>(bool ignoreCase, bool ignoreDuplicates, Func<string[], T> rowToValue) {
		Not_.Null(rowToValue);
		if (_columnCount < 2) throw new InvalidOperationException("ColumnCount must be >= 2");
		var d = new Dictionary<string, T>(ignoreCase ? StringComparer.OrdinalIgnoreCase : null);
		foreach (var v in _a) {
			var t = rowToValue(v);
			if (ignoreDuplicates) d[v[0]] = t;
			else d.Add(v[0], t);
		}
		return d;
	}
	
	//rejected, because: 1. In some cases can fail to resolve overloads. 2. Almost duplicate of the string[] overload.
	///// <summary>
	///// Creates dictionary from this 2-column CSV table, using a callback function to convert cell strings to dictionary values of any type.
	///// </summary>
	///// <param name="ignoreCase">Case-insensitive dictionary keys.</param>
	///// <param name="stringToValue">Callback function that converts cell string to value of type <c>T</c>.</param>
	///// <exception cref="ArgumentNullException"></exception>
	///// <exception cref="InvalidOperationException"><see cref="ColumnCount"/> not 2.</exception>
	///// <exception cref="ArgumentException">Column 0 contains duplicate values.</exception>
	//public Dictionary<string, T> ToDictionary<T>(bool ignoreCase, Func<string, T> stringToValue)
	//{
	//	if(stringToValue == null) throw new ArgumentNullException();
	//	if(_columnCount != 2) throw new InvalidOperationException("ColumnCount must be 2");
	//	var d = new Dictionary<string, T>(ignoreCase ? StringComparer.OrdinalIgnoreCase : null);
	//	foreach(var v in _a) d.Add(v[0], stringToValue(v[1]));
	//	return d;
	//}
	
	/// <summary>
	/// Obsolete, use <see cref="Set"/>.
	/// </summary>
	[EditorBrowsable(EditorBrowsableState.Never)]
	public void SetInt(int row, int column, int value, bool hex = false) {
		this[row, column] = hex ? "0x" + value.ToString("X") : value.ToString();
	}
	
	/// <summary>
	/// Obsolete, use <see cref="Get"/>.
	/// </summary>
	[EditorBrowsable(EditorBrowsableState.Never)]
	public int GetInt(int row, int column) {
		return this[row, column].ToInt();
	}
	
	/// <summary>
	/// Obsolete, use <see cref="Set"/>.
	/// </summary>
	[EditorBrowsable(EditorBrowsableState.Never)]
	public void SetDouble(int row, int column, double value) {
		this[row, column] = value.ToS();
	}
	
	/// <summary>
	/// Obsolete, use <see cref="Get"/>.
	/// </summary>
	[EditorBrowsable(EditorBrowsableState.Never)]
	public double GetDouble(int row, int column) {
		this[row, column].ToNumber(out double R);
		return R;
	}
	
	/// <summary>
	/// Converts a number to string and sets a field.
	/// </summary>
	/// <param name="row">0-based row index. Can be from the end; for example <c>^1</c> is the last row. Adds new row if <c>^0</c>.</param>
	/// <param name="column">0-based column index. If >= <see cref="ColumnCount"/> and &lt; 1000, sets <c>ColumnCount = column + 1</c>.</param>
	/// <param name="value"></param>
	/// <exception cref="ArgumentOutOfRangeException">Invalid <i>row</i> or <i>column</i>.</exception>
	public void Set(Index row, int column, int value) { this[row, column] = value.ToS(); }
	
	/// <summary>
	/// Converts a number to hex string and sets a field.
	/// </summary>
	/// <inheritdoc cref="Set(Index, int, int)"/>
	public void Set(Index row, int column, uint value) { this[row, column] = "0x" + value.ToString("X"); }
	
	/// <inheritdoc cref="Set(Index, int, int)"/>
	public void Set(Index row, int column, long value) { this[row, column] = value.ToS(); }
	
	/// <inheritdoc cref="Set(Index, int, uint)"/>
	public void Set(Index row, int column, ulong value) { this[row, column] = "0x" + value.ToString("X"); }
	
	/// <inheritdoc cref="Set(Index, int, int)"/>
	public void Set(Index row, int column, double value) { this[row, column] = value.ToS(); }
	
	/// <inheritdoc cref="Set(Index, int, int)"/>
	public void Set(Index row, int column, float value) { this[row, column] = value.ToS(); }
	
	/// <summary>
	/// Converts a <c>bool</c> to string <c>"true"</c> or <c>"false"</c> and sets a field.
	/// </summary>
	/// <inheritdoc cref="Set(Index, int, int)"/>
	public void Set(Index row, int column, bool value) { this[row, column] = value ? "true" : "false"; }
	
	/// <summary>
	/// Gets a field value converted to int. See <see cref="ExtString.ToInt(string, out int, int, STIFlags)"/>.
	/// </summary>
	/// <param name="row">0-based row index.</param>
	/// <param name="column">0-based column index.</param>
	/// <param name="value">Receives the result, or 0 if failed.</param>
	/// <returns>False if failed to convert from string.</returns>
	/// <exception cref="ArgumentOutOfRangeException">Invalid <i>row</i> or <i>column</i>.</exception>
	public bool Get(Index row, int column, out int value) => this[row, column].ToInt(out value);
	
	/// <summary>
	/// Gets a field value converted to <c>uint</c>. See <see cref="ExtString.ToInt(string, out uint, int, STIFlags)"/>.
	/// </summary>
	/// <inheritdoc cref="Get(Index, int, out int)"/>
	public bool Get(Index row, int column, out uint value) => this[row, column].ToInt(out value);
	
	/// <summary>
	/// Gets a field value converted to <c>long</c>. See <see cref="ExtString.ToInt(string, out long, int, STIFlags)"/>.
	/// </summary>
	/// <inheritdoc cref="Get(Index, int, out int)"/>
	public bool Get(Index row, int column, out long value) => this[row, column].ToInt(out value);
	
	/// <summary>
	/// Gets a field value converted to <c>ulong</c>. See <see cref="ExtString.ToInt(string, out ulong, int, STIFlags)"/>.
	/// </summary>
	/// <inheritdoc cref="Get(Index, int, out int)"/>
	public bool Get(Index row, int column, out ulong value) => this[row, column].ToInt(out value);
	
	/// <summary>
	/// Gets a field value converted to double. See <see cref="ExtString.ToNumber(string, out double, Range?, NumberStyles)"/>.
	/// </summary>
	/// <inheritdoc cref="Get(Index, int, out int)"/>
	public bool Get(Index row, int column, out double value) => this[row, column].ToNumber(out value);
	
	/// <summary>
	/// Gets a field value converted to float. See <see cref="ExtString.ToNumber(string, out float, Range?, NumberStyles)"/>.
	/// </summary>
	/// <inheritdoc cref="Get(Index, int, out int)"/>
	public bool Get(Index row, int column, out float value) => this[row, column].ToNumber(out value);
	
	/// <summary>
	/// Gets a field value like <c>"true"</c> or <c>"false"</c> converted to <c>bool</c>. Case-insensitive.
	/// </summary>
	/// <inheritdoc cref="Get(Index, int, out int)"/>
	public bool Get(Index row, int column, out bool value) => Boolean.TryParse(this[row, column], out value);
	
	//rejected: ToXml, ToHtml. Could be pasted in Excel, but need special format, difficult to make fully compatible. OpenOffice supports only HTML.
}


================================================
FILE: Au/String/regexp.cs
================================================

using System.Text.RegularExpressions; //for XML doc links

namespace Au;

/// <summary>
/// PCRE regular expression.
/// </summary>
/// <remarks>
/// PCRE is a regular expression library: <see href="https://www.pcre.org/"/>.
/// PCRE regular expression syntax: <see href="https://www.pcre.org/current/doc/html/pcre2pattern.html">full</see>, <see href="https://www.pcre.org/current/doc/html/pcre2syntax.html">short</see>.
/// Some websites with tutorials and info: <see href="https://www.rexegg.com/">rexegg</see>, <see href="https://www.regular-expressions.info/">regular-expressions.info</see>.
/// 
/// This class is an alternative to the .NET <see cref="Regex"/> class. The regular expression syntax is similar. PCRE has some features unavailable in .NET, and vice versa. In most cases PCRE is faster. You can use any of these classes. Functions of <see cref="elm"/> class support only PCRE.
/// 
/// Terms used in this documentation and in names of functions and types:
/// - <i>regular expression</i> - regular expression string. Also known as <i>pattern</i>.
/// - <i>subject string</i> - the string in which to search for the regular expression. Also known as <i>input string</i>.
/// - <i>match</i> - the part (substring) of the subject string that matches the regular expression.
/// - <i>groups</i> - regular expression parts enclosed in <c>()</c>. Except non-capturing parts, like <c>(?:...)</c> and <c>(?options)</c>. Also known as <i>capturing group</i>, <i>capturing subpattern</i>. Often term <i>group</i> also is used for group matches.
/// - <i>group match</i> - the part (substring) of the subject string that matches the group. Also known as <i>captured substring</i>.
/// 
/// This library uses an unmanaged code dll <c>AuCpp.dll</c> that contains PCRE code. This class is a managed wrapper for it. The main PCRE API functions used by this class are <see href="https://www.pcre.org/current/doc/html/pcre2api.html">pcre2_compile and pcre2_match</see>. The <c>regexp</c> constructor calls <c>pcre2_compile</c> and stores the compiled code in the variable. Other <c>regexp</c> functions call <c>pcre2_match</c>. Compiling to native code (JIT) is not supported.
/// 
/// A <c>regexp</c> variable can be used by multiple threads simultaneously.
/// 
/// Also there are several <see cref="String"/> extension methods that use this class. The string variable is the subject string. These methods create and use cached <c>regexp</c> instances for speed. The <c>regexp</c> constructor does not use caching.
/// </remarks>
/// <example>
/// <code><![CDATA[
/// var s = "one two22, three333,four"; //subject string
/// var x = new regexp(@"\b(\w+?)(\d+)\b"); //regular expression
///  
///  print.it("//IsMatch:");
/// print.it(x.IsMatch(s));
///  
///  print.it("//Match:");
/// if(x.Match(s, out var m)) print.it(m.Value, m[1].Value, m[2].Value);
///  
///  print.it("//FindAll with foreach:");
/// foreach(var v in x.FindAll(s)) print.it(v.Value, v[1].Value, v[2].Value);
///  print.it("//FindAll, get only strings of group 2:");
/// print.it(x.FindAll(s, 2));
///  
///  print.it("//Replace:");
/// print.it(x.Replace(s, "'$2$1'"));
///  print.it("//Replace with callback:");
/// print.it(x.Replace(s, o => o.Value.Upper()));
///  print.it("//Replace with callback and ExpandReplacement:");
/// print.it(x.Replace(s, o => { if(o.Length > 5) return o.ExpandReplacement("'$2$1'"); else return o[1].Value; }));
///  
///  print.it("//Split:");
/// print.it(new regexp(@" *, *").Split(s));
/// ]]></code>
///  Examples with <see cref="String"/> extension methods. 
/// <code><![CDATA[
/// var s = "one two22, three333,four"; //subject string
/// var rx = @"\b(\w+?)(\d+)\b"; //regular expression
///  
///  print.it("//RxIsMatch:");
/// print.it(s.RxIsMatch(rx));
///  
///  print.it("//RxMatch:");
/// if(s.RxMatch(rx, out var m)) print.it(m.Value, m[1].Value, m[2].Value);
///  
///  print.it("//RxMatch, get only string:");
/// if(s.RxMatch(rx, 0, out var s0)) print.it(s0);
///  print.it("//RxMatch, get only string of group 1:");
/// if(s.RxMatch(rx, 1, out var s1)) print.it(s1);
///  
///  print.it("//RxFindAll with foreach:");
/// foreach(var v in s.RxFindAll(rx)) print.it(v.Value, v[1].Value, v[2].Value);
///  
///  print.it("//RxFindAll with foreach, get only strings:");
/// foreach(var v in s.RxFindAll(rx, 0)) print.it(v);
///  print.it("//RxFindAll with foreach, get only strings of group 2:");
/// foreach(var v in s.RxFindAll(rx, 2)) print.it(v);
///  
///  print.it("//RxFindAll, get array:");
/// if(s.RxFindAll(rx, out var am)) foreach(var k in am) print.it(k.Value, k[1].Value, k[2].Value);
///  
///  print.it("//RxFindAll, get array of strings:");
/// if(s.RxFindAll(rx, 0, out var av)) print.it(av);
///  print.it("//RxFindAll, get array of group 2 strings:");
/// if(s.RxFindAll(rx, 2, out var ag)) print.it(ag);
///  
///  print.it("//RxReplace:");
/// print.it(s.RxReplace(rx, "'$2$1'"));
///  
///  print.it("//RxReplace with callback:");
/// print.it(s.RxReplace(rx, o => o.Value.Upper()));
///  print.it("//RxReplace with callback and ExpandReplacement:");
/// print.it(s.RxReplace(rx, o => { if(o.Length > 5) return o.ExpandReplacement("'$2$1'"); else return o[1].Value; }));
///  
///  print.it("//RxReplace, get replacement count:");
/// if(0 != s.RxReplace(rx, "'$2$1'", out var s2)) print.it(s2);
///  
///  print.it("//RxReplace with callback, get replacement count:");
/// if(0 != s.RxReplace(rx, o => o.Value.Upper(), out var s3)) print.it(s3);
///  
///  print.it("//RxSplit:");
/// print.it(s.RxSplit(@" *, *"));
/// ]]></code></example>
public unsafe class regexp {
	readonly IntPtr _codeUnsafe; //pcre2_code_16*. Don't pass to PCRE API directly, because then GC can collect this object
	Cpp.PcreCalloutT _pcreCallout; //our callout that calls the user's callout. This field protects the delegates from GC.
	readonly byte _matchFlags; //RXMatchFlags specified in hi byte of ctor flags
	
	internal HandleRef _CodeHR => new HandleRef(this, _codeUnsafe); //pass this to PCRE API
	
	/// <summary>
	/// Compiles regular expression string.
	/// </summary>
	/// <param name="rx">Regular expression. Cannot be <c>null</c>.</param>
	/// <param name="flags">
	/// Options.
	/// Default 0. Flag UTF is implicitly added if <i>rx</i> contains non-ASCII characters and not used flag <c>NEVER_UTF</c>.
	/// </param>
	/// <exception cref="ArgumentNullException"></exception>
	/// <exception cref="ArgumentException">Invalid regular expression. Or failed to compile it for some other reason (unlikely).</exception>
	/// <remarks>
	/// Calls PCRE API function <see href="https://www.pcre.org/current/doc/html/pcre2api.html">pcre2_compile</see>.
	/// 
	/// PCRE regular expression syntax: <see href="https://www.pcre.org/current/doc/html/pcre2pattern.html">full</see>, <see href="https://www.pcre.org/current/doc/html/pcre2syntax.html">short</see>.
	/// 
	/// Examples in class help: <see cref="regexp"/>.
	/// </remarks>
	public regexp([ParamString(PSFormat.Regexp)] string rx, RXFlags flags = 0) {
		Not_.Null(rx);
		_matchFlags = (byte)((ulong)flags >> 56); flags = (RXFlags)((ulong)flags & 0xffffff_ffffffff);
		_codeUnsafe = Cpp.Cpp_RegexCompile(rx, rx.Length, flags, out int codeSize, out BSTR errStr);
		if (_codeUnsafe == default) throw new ArgumentException(errStr.ToStringAndDispose());
		GC.AddMemoryPressure(codeSize);
	}
	
	///
	~regexp() {
		//print.it("dtor");
		if (_codeUnsafe == default) return;
		int codeSize = Cpp.Cpp_RegexDtor(_codeUnsafe);
		GC.RemoveMemoryPressure(codeSize);
	}
	
	/// <summary>
	/// Sets callout callback function.
	/// </summary>
	/// <value>Callback delegate (eg lambda) or <c>null</c>.</value>
	/// <remarks>
	/// Callouts can be used to:
	/// <br/>• Track the matching progress.
	/// <br/>• Get all instances of a group that can match multiple times.
	/// <br/>• Evaluate and reject some matches or match parts.
	/// <br/>• Etc.
	/// The callback function is called by <see cref="IsMatch"/>, <see cref="Match"/>, <see cref="FindAll"/>, <see cref="Replace"/>, <see cref="Split"/> and similar functions, when they reach callout points in regular expression. To insert callout points use <c>(?C)</c>, <c>(?C1)</c>, <c>(?C2)</c>, <c>(?C'name')</c> etc or pass flag <c>AUTO_CALLOUT</c> to the constructor.
	/// More info in PCRE help topic <see href="https://www.pcre.org/current/doc/html/pcre2callout.html">pcre2callout</see>.
	/// See also: <see href="https://www.rexegg.com/pcre-callouts.html"/>
	/// </remarks>
	/// <example>
	/// Track the matching progress.
	/// <code><![CDATA[
	/// var s = "text <a href='url'>link</a> text";
	/// var rx = @"(?C1)<a (?C2)href='.+?'>(?C3)[^<]*(?C4)</a>";
	/// var x = new regexp(rx);
	/// x.Callout = o => { print.it(o.callout_number, o.start_match, o.current_position, s[o.start_match..o.current_position], rx.Substring(o.pattern_position, o.next_item_length)); };
	/// print.it(x.IsMatch(s));
	/// ]]></code>
	/// Track the matching progress with flag <c>AUTO_CALLOUT</c>.
	/// <code><![CDATA[
	/// var s = "one 'two' three";
	/// var rx = @"'(.+?)'";
	/// var x = new regexp(rx, RXFlags.AUTO_CALLOUT);
	/// x.Callout = o => print.it(o.current_position, o.pattern_position, rx.Substring(o.pattern_position, o.next_item_length));
	/// print.it(x.IsMatch(s));
	/// ]]></code>
	/// Get all instances of a group that can match multiple times.
	/// <code><![CDATA[
	/// var s = "BEGIN 111 2222 333 END";
	/// var x = new regexp(@"^(\w+) (?:(\d+) (?C1))+(\w+)$");
	/// var a = new List<string>();
	/// x.Callout = o => a.Add(o.LastGroupValue);
	/// if(!x.Match(s, out var m)) { print.it("no match"); return; }
	/// print.it(m[1]);
	/// print.it(a); //all numbers. m[2] contains only the last number.
	/// print.it(m[3]);
	/// ]]></code>
	/// Evaluate and reject some matches or match parts. This code rejects matches longer than 5.
	/// <code><![CDATA[
	/// var s = "one 123-5 two 12-456 three 1-34 four";
	/// var x = new regexp(@"\b\d+-\d+\b(?C1)");
	/// x.Callout = o => { int len = o.current_position - o.start_match; /*print.it(len);*/ if(len > 5) o.Result = 1; };
	/// print.it(x.FindAll(s, 0));
	/// ]]></code>
	/// </example>
	public Action<RXCalloutData> Callout {
		set {
			lock (this) {
				if (value == null) {
					_pcreCallout = null;
				} else {
					_pcreCallout = (void* calloutBlock, void* param) => {
						var b = new RXCalloutData(calloutBlock);
						value(b);
						return b.Result;
					};
				}
			}
		}
	}
	
	/// <summary>
	/// Finds a named group and returns its 1-based index. Returns -1 if not found.
	/// </summary>
	/// <param name="groupName">
	/// Group name.
	/// In regular expression, to set name of group <c>(text)</c>, use <c>(?&lt;NAME&gt;text)</c>.
	/// </param>
	/// <exception cref="ArgumentNullException"></exception>
	/// <exception cref="ArgumentException">Multiple groups have this name.</exception>
	/// <seealso cref="RXMatch.GroupNumberFromName(string)"/>
	/// <seealso cref="RXMatch.GroupNumberFromName(string, out bool)"/>
	public int GetGroupNumberOf(string groupName) {
		Not_.Null(groupName);
		fixed (char* p = groupName) {
			int R = Cpp.pcre2_substring_nametable_scan(_CodeHR, p, null, null);
			if (R <= 0) {
				if (R == -50) throw new ArgumentException("Multiple groups have name " + groupName); //-50 PCRE2_ERROR_NOUNIQUESUBSTRING
				R = -1;
			}
			return R;
		}
	}
	
	/// <summary>
	/// Returns the highest capture group number in the regular expression. If <c>(?|</c> not used, this is also the total count of capture groups.
	/// </summary>
	public int GetMaxGroupNumber() {
		int R = 0;
		Cpp.pcre2_pattern_info(_CodeHR, Cpp.PCRE2_INFO_.CAPTURECOUNT, &R);
		return R;
	}
	
	//Calls Cpp_RegexMatch and returns its results.
	//Throws if it returns less than -1.
	//m.vec array is thread_local. Next call reallocates/overwrites it, except when called by a callout of the same call.
	//m.mark is set even if no match, if available.
	//s - subject. If null, returns -1.
	//rawFlags - pass flags as is. If false, calls _GetMatchFlags. If true, flags must be result of _GetMatchFlags.
	//group - 0 or group number. Used only to throw if invalid.
	int _PcreMatch(RStr s, int start, RXMatchFlags flags, bool rawFlags, out Cpp.RegexMatch m, bool needM, int group = 0) {
		if (s.IsNull()) { m = default; return -1; } //null
		fixed (char* p = s) {
			if (!rawFlags) flags = _GetMatchFlags(flags);
			int rc = Cpp.Cpp_RegexMatch(_CodeHR, p != null ? p : (char*)&p, s.Length, start, flags, _pcreCallout, out m, needM, out BSTR errStr);
			if (rc < -1) throw new AuException(errStr.ToStringAndDispose());
			if (group != 0 && rc >= 0 && (uint)group >= m.vecCount) throw new ArgumentOutOfRangeException(nameof(group));
			return rc;
			//print.it(rc);
			//info: 0 is partial match, -1 is no match, <-1 is error
		}
	}
	
	//Gets span and returns start.
	//If range is null, sets span = s and returns 0.
	//Else if range is invalid, throws ArgumentOutOfRangeException.
	//Else sets span.Length = range and returns 0. In any case span.Start is 0.
	static int _GetSpan(string s, Range? range, out RStr span) {
		span = s;
		if (!range.HasValue) return 0;
		var (i, end) = range.GetStartEnd(span.Length);
		if (end != span.Length) span = span[..end];
		return i;
	}
	
	static int _GetSpan(ref RStr span, Range? range) {
		if (!range.HasValue) return 0;
		var (i, end) = range.GetStartEnd(span.Length);
		if (end != span.Length) span = span[..end];
		return i;
	}
	
	RXMatchFlags _GetMatchFlags(RXMatchFlags matchFlags, bool throwIfPartial = false) {
		var f = (RXMatchFlags)_matchFlags | matchFlags;
		if (throwIfPartial) {
			if (0 != (f & (RXMatchFlags.PARTIAL_SOFT | RXMatchFlags.PARTIAL_HARD)))
				throw new ArgumentException("This function does not support PARTIAL_ flags.", nameof(matchFlags));
		}
		return f;
	}
	
	/// <summary>
	/// Returns <c>true</c> if string <i>s</i> matches this regular expression.
	/// </summary>
	/// <returns><c>true</c> if full or partial match. Partial match is possible if used a <c>PARTIAL_</c> flag.</returns>
	/// <param name="s">
	/// Subject string.
	/// If <c>null</c>, returns <c>false</c>, even if the regular expression matches empty string.
	/// </param>
	/// <param name="range">
	/// Start and end offsets in the subject string. If <c>null</c> (default), uses whole string.
	/// Examples: <c>i..j</c> (from <c>i</c> to <c>j</c>), <c>i..</c> (from <c>i </c>to the end), <c>..j</c> (from 0 to <c>j</c>).
	/// The subject part before the start index is not ignored if regular expression starts with a lookbehind assertion or anchor, eg <c>^</c> or <c>\b</c> or <c>(?&lt;=...)</c>. Instead of <c>^</c> you can use <c>\G</c> or flag <c>RXFlags.ANCHORED</c>. More info in PCRE documentation topic <see href="https://www.pcre.org/current/doc/html/pcre2api.html">pcre2api</see>, chapter "The string to be matched by pcre2_match()".
	/// The subject part after the end index is always ignored.
	/// </param>
	/// <param name="matchFlags">Options.
	/// The same options also can be set in <see cref="regexp"/> constructor's <i>flags</i>. Constructor's flags and <i>matchFlags</i> are added, which means that <i>matchFlags</i> cannot unset flags set by constructor.
	/// </param>
	/// <exception cref="ArgumentOutOfRangeException">Invalid <i>range</i>.</exception>
	/// <exception cref="AuException">The PCRE API function <c>pcre2_match</c> failed. Unlikely.</exception>
	/// <remarks>
	/// This function is similar to <see cref="Regex.IsMatch(string)"/>.
	/// </remarks>
	/// <example>
	/// <code><![CDATA[
	/// var s = "one two22 three333 four";
	/// var x = new regexp(@"\b(\w+?)(\d+)\b");
	/// print.it(x.IsMatch(s));
	/// ]]></code>
	/// </example>
	public bool IsMatch(string s, Range? range = null, RXMatchFlags matchFlags = 0) {
		int start = _GetSpan(s, range, out var span);
		return _PcreMatch(span, start, matchFlags, rawFlags: false, out _, needM: false) >= 0;
	}
	
	/// <inheritdoc cref="IsMatch(string, Range?, RXMatchFlags)"/>
	public bool IsMatch(RStr s, Range? range = null, RXMatchFlags matchFlags = 0) {
		int start = _GetSpan(ref s, range);
		return _PcreMatch(s, start, matchFlags, rawFlags: false, out _, needM: false) >= 0;
	}
	
	/// <summary>
	/// Returns <c>true</c> if string <i>s</i> matches this regular expression.
	/// Gets match info as <see cref="RXMatch"/>.
	/// </summary>
	/// <returns>
	/// <br/>• If full match, returns <c>true</c>, and <i>result</i> contains the match and all groups that exist in the regular expressions.
	/// <br/>• If partial match, returns <c>true</c>, and <i>result</i> contains the match without groups. Partial match is possible if used a <c>PARTIAL_</c> flag.
	/// <br/>• If no match, returns <c>false</c>, and <i>result</i> normally is <c>null</c>. But if a mark is available, <i>result</i> is an object with two valid properties - <see cref="RXMatch.Exists"/> (<c>false</c>) and <see cref="RXMatch.Mark"/>; other properties have undefined values or throw exception.
	/// </returns>
	/// <param name="result">Receives match info.</param>
	/// <remarks>
	/// This function is similar to <see cref="Regex.Match(string)"/>.
	/// </remarks>
	/// <example>
	/// <code><![CDATA[
	/// var s = "one two22 three333 four";
	/// var x = new regexp(@"\b(\w+?)(\d+)\b");
	/// if(x.Match(s, out var m)) print.it(m.Value, m[1].Value, m[2].Value);
	/// ]]></code>
	/// </example>
	/// <inheritdoc cref="IsMatch"/>
	public bool Match(string s, out RXMatch result, Range? range = null, RXMatchFlags matchFlags = 0) {
		result = null;
		int start = _GetSpan(s, range, out var span);
		int rc = _PcreMatch(span, start, matchFlags, rawFlags: false, out var m, needM: true);
		if (rc >= 0 || m.mark != null) {
			result = new RXMatch(this, s, rc, in m);
		}
		return rc >= 0;
	}
	
	/// <summary>
	/// Returns <c>true</c> if string <i>s</i> matches this regular expression.
	/// Gets whole match or some group, as <see cref="RXGroup"/> (index, length, value).
	/// </summary>
	/// <returns>
	/// <br/>• If full match, returns <c>true</c>, and <i>result</i> contains the match or the specified group.
	/// <br/>• If partial match, returns <c>true</c>. Partial match is possible if used a <c>PARTIAL_</c> flag. Then cannot get groups, therefore <i>group</i> should be 0.
	/// <br/>• If no match, returns <c>false</c>, and <i>result</i> is empty.
	/// </returns>
	/// <param name="s">
	/// Subject string.
	/// If <c>null</c>, returns <c>false</c>, even if the regular expression matches empty string.
	/// </param>
	/// <param name="group">
	/// Group number (1-based index) of result. If 0 - whole match.
	/// See also <see cref="GetGroupNumberOf"/>.
	/// </param>
	/// <exception cref="ArgumentOutOfRangeException">Invalid <i>group</i> or <i>range</i>.</exception>
	/// <exception cref="AuException">The PCRE API function <c>pcre2_match</c> failed. Unlikely.</exception>
	/// <remarks>
	/// This function is a simplified version of <see cref="Match(string, out RXMatch, Range?, RXMatchFlags)"/>.
	/// </remarks>
	/// <example>
	/// <code><![CDATA[
	/// var s = "one two22 three333 four";
	/// var x = new regexp(@"\b(\w+?)(\d+)\b");
	/// if(x.Match(s, 0, out RXGroup g)) print.it(g.Value, g.Start);
	/// ]]></code>
	/// </example>
	/// <inheritdoc cref="Match(string, out RXMatch, Range?, RXMatchFlags)"/>
	public bool Match(string s, int group, out RXGroup result, Range? range = null, RXMatchFlags matchFlags = 0) {
		int start = _GetSpan(s, range, out var span);
		int rc = _PcreMatch(span, start, matchFlags, rawFlags: false, out var m, needM: true, group);
		if (rc < 0) {
			result = default;
			return false;
		}
		result = new RXGroup(s, m.vec[group]);
		return true;
	}
	
	/// <summary>
	/// Returns <c>true</c> if string <i>s</i> matches this regular expression.
	/// Gets whole match or some group, as string.
	/// </summary>
	/// <returns>
	/// <br/>• If full match, returns <c>true</c>, and <i>result</i> contains the value of the match or of the specifed group.
	/// <br/>• If partial match, returns <c>true</c>. Partial match is possible if used a <c>PARTIAL_</c> flag. Then cannot get groups, therefore <i>group</i> should be 0.
	/// <br/>• If no match, returns <c>false</c>, and <i>result</i> is <c>null</c>.
	/// </returns>
	/// <param name="s">
	/// Subject string.
	/// If <c>null</c>, returns <c>false</c>, even if the regular expression matches empty string.
	/// </param>
	/// <param name="result">Receives the match value.</param>
	/// <example>
	/// <code><![CDATA[
	/// var s = "one two22 three333 four";
	/// var x = new regexp(@"\b(\w+?)(\d+)\b");
	/// if(x.Match(s, 0, out string v)) print.it(v);
	/// ]]></code>
	/// </example>
	/// <inheritdoc cref="Match(string, int, out RXGroup, Range?, RXMatchFlags)"/>
	public bool Match(string s, int group, out string result, Range? range = null, RXMatchFlags matchFlags = 0) {
		result = null;
		if (!Match(s, group, out RXGroup g, range, matchFlags)) return false;
		result = g.Value;
		return true;
	}
	
	/// <summary>
	/// Returns <c>true</c> if string span <i>s</i> matches this regular expression.
	/// Gets whole match or some group, as <see cref="StartEnd"/>.
	/// </summary>
	/// <inheritdoc cref="Match(string, int, out RXGroup, Range?, RXMatchFlags)"/>
	public bool Match(RStr s, int group, out StartEnd result, Range? range = null, RXMatchFlags matchFlags = 0) {
		int start = _GetSpan(ref s, range);
		int rc = _PcreMatch(s, start, matchFlags, rawFlags: false, out var m, needM: true, group);
		if (rc < 0) {
			result = default;
			return false;
		}
		result = m.vec[group];
		return true;
	}
	
	/// <summary>
	/// Returns <c>true</c> if string span <i>s</i> matches this regular expression.
	/// Writes match info to caller-allocated memory (array, stackalloc array, etc).
	/// </summary>
	/// <param name="result">Receives match info: main match in <c>result[0]</c> and group matches in other elements. <c>result.Length</c> must be equal to the number of groups + 1. If a group does not exists, the element's <c>start</c> and <c>end</c> are <c>-1</c>.</param>
	/// <exception cref="ArgumentOutOfRangeException">Invalid <i>range</i>.</exception>
	/// <exception cref="AuException">The PCRE API function <c>pcre2_match</c> failed. Unlikely.</exception>
	/// <exception cref="ArgumentException"><i>result</i> array too short.</exception>
	/// <inheritdoc cref="Match(string, out RXMatch, Range?, RXMatchFlags)" path="/param"/>
	public bool Match(RStr s, Span<StartEnd> result, Range? range = null, RXMatchFlags matchFlags = 0) {
		int start = _GetSpan(ref s, range);
		int rc = _PcreMatch(s, start, matchFlags, rawFlags: false, out var m, needM: true);
		if (rc >= 0 || m.mark != null) {
			if (result.Length < m.vecCount) throw new ArgumentException("result array too short");
			new Span<StartEnd>(m.vec, m.vecCount).CopyTo(result);
		}
		return rc >= 0;
	}
	
	///// <inheritdoc cref="Match(string, out RXMatch, Range?, RXMatchFlags)"/>
	///// <param name="result">Receives match info. Its "get string value" functions cannot be used.</param>
	//public bool Match(RStr s, out RXMatch result, Range? range = null, RXMatchFlags matchFlags = 0) {
	//	result = null;
	//	int start = _GetSpan(ref s, range);
	//	int rc = _PcreMatch(s, start, matchFlags, rawFlags: false, out var m, needM: true);
	//	if (rc >= 0 || m.mark != null) {
	//		result = new RXMatch(this, null, rc, in m);
	//	}
	//	return rc >= 0;
	//}
	
	//Used by FindAllX and ReplaceAllX to easily find matches in loop.
	struct _MatchEnum {
		regexp _rx;
		string _subject;
		Cpp.RegexMatch _m;
		RXMatchFlags _matchFlags;
		int _group, _from, _to, _maxCount, _rc;
		public int foundCount;
		
		//Throws if s is null or if invalid start/end or used 'partial' flags.
		public _MatchEnum(regexp rx, string s, int group, Range? range, RXMatchFlags matchFlags, int maxCount = -1) {
			Not_.Null(s);
			(_from, _to) = range.GetStartEnd(s.Length);
			_rx = rx;
			_subject = s;
			_group = group;
			_matchFlags = rx._GetMatchFlags(matchFlags, throwIfPartial: true);
			_maxCount = maxCount;
			foundCount = _rc = 0;
			_m = default;
		}
		
		//Calls Cpp_RegexMatch, remembers its results, increments foundCount if found.
		//Returns false if it returns -1. Throws if it returns < -1. Throws if invalid group.
		//To get results, use properties Match or GroupX. Don't call Next or any other match function before it.
		public bool Next() {
			if (foundCount >= (uint)_maxCount) return false;
			_rc = _rx._PcreMatch(_subject.AsSpan(0, _to), _from, _matchFlags, rawFlags: true, out _m, needM: true, _group);
			if (_rc < 0) return false;
			_SetNextFrom();
			_matchFlags |= RXMatchFlags.NO_UTF_CHECK;
			foundCount++;
			return true;
		}
		
		void _SetNextFrom() {
			var p = _m.vec[0]; //x=start, y=end
			_from = p.end;
			//empty match?
			if (_from <= p.start) {
				if (_from < p.start) throw new ArgumentException(@"This function does not support (?=...\K).");
				if (++_from < _to) {
					var c = _subject[_from];
					if (c == '\n') { //skip \n if inside \r\n
						if (_subject[_from - 1] == '\r') _from++;
					} else if ((c & 0xfc00) == 0xdc00) { //skip the second part of surrogate pair
						if (0 != (_rx._InfoAllOptions & RXFlags.UTF)) _from++;
					}
				}
				if (_from > _to) _maxCount = 0;
			}
		}
		
		public RXMatch Match => new RXMatch(_rx, _subject, _rc, in _m);
		
		public StartEnd GroupR => _m.vec[_group];
		
		public RXGroup GroupG => new(_subject, GroupR);
		
		public string GroupS { get { var r = GroupR; return r.start < 0 ? null : _subject[r.start..r.end]; } }
	}
	
	/// <summary>
	/// Finds all match instances of the regular expression.
	/// </summary>
	/// <returns>A lazy <c>IEnumerable&lt;RXMatch&gt;</c> that can be used with <c>foreach</c>.</returns>
	/// <param name="s">Subject string. Cannot be <c>null</c>.</param>
	/// <exception cref="ArgumentNullException"><i>s</i> is <c>null</c>.</exception>
	/// <exception cref="ArgumentOutOfRangeException">Invalid <i>range</i>.</exception>
	/// <exception cref="ArgumentException">
	/// <br/>• Used a <c>PARTIAL_</c> flag.
	/// <br/>• The regular expression contains <c>(?=...\K)</c>.
	/// </exception>
	/// <exception cref="AuException">The PCRE API function <c>pcre2_match</c> failed. Unlikely.</exception>
	/// <remarks>
	/// This function is similar to <see cref="Regex.Matches(string)"/>.
	/// </remarks>
	/// <example>
	/// <code><![CDATA[
	/// var s = "one two22 three333 four";
	/// var x = new regexp(@"\b(\w+?)(\d+)\b");
	/// foreach(var m in x.FindAll(s)) print.it(m.Value, m[1].Value, m[2].Value);
	/// ]]></code>
	/// </example>
	/// <inheritdoc cref="IsMatch" path="/param"/>
	public IEnumerable<RXMatch> FindAll(string s, Range? range = null, RXMatchFlags matchFlags = 0) {
		var e = new _MatchEnum(this, s, 0, range, matchFlags);
		while (e.Next()) yield return e.Match;
	}
	
	/// <returns>A lazy <c>IEnumerable&lt;string&gt;</c> that can be used with <c>foreach</c>.</returns>
	/// <param name="group">
	/// Group number (1-based index) of results. If 0 - whole match.
	/// See also <see cref="GetGroupNumberOf"/>.
	/// </param>
	/// <exception cref="ArgumentNullException"><i>s</i> is <c>null</c>.</exception>
	/// <exception cref="ArgumentOutOfRangeException">Invalid <i>group</i> or <i>range</i>.</exception>
	/// <exception cref="ArgumentException">
	/// <br/>• Used a <c>PARTIAL_</c> flag.
	/// <br/>• The regular expression contains <c>(?=...\K)</c>.
	/// </exception>
	/// <exception cref="AuException">The PCRE API function <c>pcre2_match</c> failed. Unlikely.</exception>
	/// <example>
	/// <code><![CDATA[
	/// var s = "one two three";
	/// var x = new regexp(@"\b\w+\b");
	/// foreach(var v in x.FindAll(s, 0)) print.it(v);
	/// ]]></code>
	/// </example>
	/// <inheritdoc cref="FindAll(string, Range?, RXMatchFlags)"/>
	public IEnumerable<string> FindAll(string s, int group, Range? range = null, RXMatchFlags matchFlags = 0) {
		var e = new _MatchEnum(this, s, group, range, matchFlags);
		while (e.Next()) yield return e.GroupS;
	}
	
	/// <returns>A lazy <c>IEnumerable&lt;RXGroup&gt;</c> that can be used with <c>foreach</c>.</returns>
	/// <example>
	/// <code><![CDATA[
	/// var s = "one two three";
	/// var x = new regexp(@"\b\w+\b");
	/// foreach(var g in x.FindAllG(s, 0)) print.it(g.Start, g.Value);
	/// ]]></code>
	/// </example>
	/// <inheritdoc cref="FindAll(string, int, Range?, RXMatchFlags)"/>
	public IEnumerable<RXGroup> FindAllG(string s, int group, Range? range = null, RXMatchFlags matchFlags = 0) {
		var e = new _MatchEnum(this, s, group, range, matchFlags);
		while (e.Next()) yield return e.GroupG;
	}
	
	/// <summary>
	/// Finds all match instances of the regular expression. Gets array of <see cref="RXMatch"/>.
	/// </summary>
	/// <returns><c>true</c> if found 1 or more matches.</returns>
	/// <param name="result">Receives all found matches.</param>
	/// <example>
	/// <code><![CDATA[
	/// var s = "one two22 three333 four";
	/// var x = new regexp(@"\b(\w+?)(\d+)\b");
	/// if(!x.FindAll(s, out var a)) { print.it("not found"); return; }
	/// foreach(var m in a) print.it(m.Value, m[1].Value, m[2].Value);
	/// ]]></code>
	/// </example>
	/// <inheritdoc cref="FindAll(string, Range?, RXMatchFlags)"/>
	public bool FindAll(string s, out RXMatch[] result, Range? range = null, RXMatchFlags matchFlags = 0) {
		result = FindAll(s, range, matchFlags).ToArray();
		return result.Length != 0;
	}
	
	/// <summary>
	/// Finds all match instances of the regular expression. Gets array of strings.
	/// </summary>
	/// <returns><c>true</c> if found 1 or more matches.</returns>
	/// <param name="result">Receives all found matches.</param>
	/// <example>
	/// <code><![CDATA[
	/// var s = "one two three";
	/// var x = new regexp(@"\b\w+\b");
	/// if(!x.FindAll(s, 0, out var a)) { print.it("not found"); return; }
	/// foreach(var v in a) print.it(v);
	/// ]]></code>
	/// </example>
	/// <inheritdoc cref="FindAll(string, int, Range?, RXMatchFlags)"/>
	public bool FindAll(string s, int group, out string[] result, Range? range = null, RXMatchFlags matchFlags = 0) {
		result = FindAll(s, group, range, matchFlags).ToArray();
		return result.Length != 0;
	}
	
	/// <summary>
	/// Finds all match instances of the regular expression. Gets array of <see cref="RXGroup"/> (index, length, value).
	/// </summary>
	/// <returns><c>true</c> if found 1 or more matches.</returns>
	/// <param name="result">Receives all found matches.</param>
	/// <example>
	/// <code><![CDATA[
	/// var s = "one two three";
	/// var x = new regexp(@"\b\w+\b");
	/// if(!x.FindAllG(s, 0, out var a)) { print.it("not found"); return; }
	/// foreach(var g in a) print.it(g.Start, g.Value);
	/// ]]></code>
	/// </example>
	/// <inheritdoc cref="FindAll(string, int, Range?, RXMatchFlags)"/>
	public bool FindAllG(string s, int group, out RXGroup[] result, Range? range = null, RXMatchFlags matchFlags = 0) {
		result = FindAllG(s, group, range, matchFlags).ToArray();
		return result.Length != 0;
	}
	
	int _Replace(string s, out string result, string repl, Func<RXMatch, string> replFunc, int maxCount, Range? range, RXMatchFlags matchFlags) {
		StringBuilder b = null;
		StringBuilder_ bCache = default;
		int prevEnd = 0;
		int replType = 0; //0 empty, 1 simple, 2 with $, 3 callback
		
		var e = new _MatchEnum(this, s, 0, range, matchFlags, maxCount);
		while (e.Next()) {
			//init variables
			if (b == null) {
				bCache = new StringBuilder_(out b, s.Length + 100);
				if (replFunc != null) replType = 3; else if (!repl.NE()) replType = repl.IndexOf('$') < 0 ? 1 : 2;
			}
			//append s part before this match
			var p = e.GroupR; //x=start, y=end
			int nBefore = p.start - prevEnd;
			if (nBefore != 0) b.Append(s, prevEnd, nBefore);
			prevEnd = p.end;
			//append replacement
			string re = null;
			if (replType >= 2) {
				var m = e.Match; //FUTURE: optimization: if no callback, use single instance and set fields.
				if (replFunc != null) re = replFunc(m);
				else ExpandReplacement_(m, repl, b);
			} else re = repl;
			if (!re.NE()) b.Append(re);
		}
		
		//append s part after last match
		if (e.foundCount != 0) {
			int nAfter = s.Length - prevEnd;
			if (nAfter > 0) b.Append(s, prevEnd, nAfter);
			result = b.ToString();
			bCache.Dispose();
		} else result = s;
		
		return e.foundCount;
	}
	
	/// <summary>
	/// Finds and replaces all match instances of the regular expression.
	/// </summary>
	/// <returns>The result string.</returns>
	/// <param name="s">Subject string. Cannot be <c>null</c>.</param>
	/// <param name="repl">
	/// Replacement pattern.
	/// Can consist of any combination of literal text and substitutions like <c>$1</c>.
	/// Supports .NET regular expression substitution syntax. See <see cref="Regex.Replace(string, string, int)"/>. Also: replaces <c>$*</c> with the name of the last encountered mark; replaces <c>${+func}</c> etc with the return value of a function registered with <see cref="addReplaceFunc"/>.
	/// </param>
	/// <param name="maxCount">Maximal count of replacements to make. If -1 (default), replaces all.</param>
	/// <exception cref="ArgumentNullException"><i>s</i> is <c>null</c>.</exception>
	/// <exception cref="ArgumentOutOfRangeException">Invalid <i>range</i>.</exception>
	/// <exception cref="ArgumentException">
	/// - Invalid <c>$replacement</c>.
	/// - Used a <c>PARTIAL_</c> flag.
	/// - The regular expression contains <c>(?=...\K)</c>.
	/// </exception>
	/// <exception cref="AuException">The PCRE API function <c>pcre2_match</c> failed. Unlikely.</exception>
	/// <remarks>
	/// This function is similar to <see cref="Regex.Replace(string, string, int)"/>.
	/// </remarks>
	/// <example>
	/// <code><![CDATA[
	/// var s = "one two22 three333 four";
	/// var x = new regexp(@"\b(\w+?)(\d+)\b");
	/// s = x.Replace(s, "'$2$1'");
	/// print.it(s);
	/// ]]></code>
	/// </example>
	/// <inheritdoc cref="IsMatch" path="/param"/>
	public string Replace(string s,
		[ParamString(PSFormat.RegexpReplacement)] string repl = null,
		int maxCount = -1, Range? range = null, RXMatchFlags matchFlags = 0) {
		_Replace(s, out var R, repl, null, maxCount, range, matchFlags);
		return R;
	}
	
	/// <returns>The number of replacements made. Returns the result string through an out parameter.</returns>
	/// <param name="result">The result string. Can be the same variable as the subject string.</param>
	/// <example>
	/// <code><![CDATA[
	/// var s = "one two22 three333 four";
	/// var x = new regexp(@"\b(\w+?)(\d+)\b");
	/// if(0 == x.Replace(s, "'$2$1'", out s)) print.it("not found");
	/// else print.it(s);
	/// ]]></code>
	/// </example>
	/// <inheritdoc cref="Replace(string, string, int, Range?, RXMatchFlags)"/>
	public int Replace(string s,
		[ParamString(PSFormat.RegexpReplacement)] string repl,
		out string result, int maxCount = -1, Range? range = null, RXMatchFlags matchFlags = 0) {
		return _Replace(s, out result, repl, null, maxCount, range, matchFlags);
	}
	
	/// <summary>
	/// Finds and replaces all match instances of the regular expression. Uses a callback function.
	/// </summary>
	/// <param name="replFunc">
	/// Callback function's delegate, eg lambda. Called for each found match. Returns the replacement.
	/// In the callback function you can use <see cref="RXMatch.ExpandReplacement"/>.
	/// </param>
	/// <remarks>
	/// This function is similar to <see cref="Regex.Replace(string, MatchEvaluator, int)"/>.
	/// </remarks>
	/// <example>
	/// <code><![CDATA[
	/// var s = "one two22 three333 four";
	/// var x = new regexp(@"\b(\w+?)(\d+)\b");
	/// s = x.Replace(s, o => o.Value.Upper());
	/// print.it(s);
	/// ]]></code>
	/// </example>
	/// <inheritdoc cref="Replace(string, string, int, Range?, RXMatchFlags)"/>
	public string Replace(string s, Func<RXMatch, string> replFunc, int maxCount = -1, Range? range = null, RXMatchFlags matchFlags = 0) {
		_Replace(s, out var R, null, replFunc, maxCount, range, matchFlags);
		return R;
	}
	
	/// <summary>
	/// Finds and replaces all match instances of the regular expression. Uses a callback function.
	/// </summary>
	/// <param name="replFunc">
	/// Callback function's delegate, eg lambda. Called for each found match. Returns the replacement.
	/// In the callback function you can use <see cref="RXMatch.ExpandReplacement"/>.
	/// </param>
	/// <remarks>
	/// This function is similar to <see cref="Regex.Replace(string, MatchEvaluator, int)"/>.
	/// </remarks>
	/// <example>
	/// <code><![CDATA[
	/// var s = "one two22 three333 four";
	/// var x = new regexp(@"\b(\w+?)(\d+)\b");
	/// if(0 == x.Replace(s, o => o.Value.Upper(), out s)) print.it("not found");
	/// else print.it(s);
	/// ]]></code>
	/// </example>
	/// <inheritdoc cref="Replace(string, string, out string, int, Range?, RXMatchFlags)"/>
	public int Replace(string s, Func<RXMatch, string> replFunc, out string result, int maxCount = -1, Range? range = null, RXMatchFlags matchFlags = 0) {
		return _Replace(s, out result, null, replFunc, maxCount, range, matchFlags);
	}
	
	/// <summary>
	/// Used by <c>_ReplaceAll</c> and <c>RXMatch.ExpandReplacement</c>.
	/// Fully supports .NET regular expression substitution syntax. Also: replaces <c>$*</c> with the name of the last encountered mark; replaces <c>${+func}</c> etc with the return value of a function registered with <see cref="addReplaceFunc"/>.
	/// </summary>
	[MethodImpl(MethodImplOptions.AggressiveOptimization)]
	internal static void ExpandReplacement_(RXMatch m, string repl, StringBuilder b) {
		fixed (char* s0fixed = repl) {
			char* s0 = s0fixed, s = s0, eos = s + repl.Length, e = s; //e is the end of s part added to b
			while (s < eos) {
				if (*s == '$') {
					if (s > e) { b.Append(e, (int)(s - e)); e = s; }
					
					char ch = *++s;
					
					if (ch == '$') { //escaped $
						e = s++;
						continue;
					}
					
					char* s1e = s; //for errors only
					int group = -1;
					if (ch == '{') { //${name} or ${number}
						char* t = ++s; while (t < eos && *t != '}') t++;
						if (t == eos) break;
						ch = *s;
						if (ch == '+') { //${+userFunc} or ${+userFunc(group)} or ${+userFunc(group, param)}
							s++;
							string funcName = null, funcParam = null; int groupNumber = 0;
							if (t[-1] == ')') {
								t--;
								var sArgs = s; while (sArgs < t && *sArgs != '(') sArgs++;
								if (sArgs < t) {
									funcName = new(s, 0, (int)(sArgs - s));
									var sParam = ++sArgs; while (sParam < t && *sParam != ',') sParam++;
									groupNumber = _GetGroup(sArgs, sParam);
									if (groupNumber >= m.GroupCountPlusOne) funcName = null;
									else if (sParam < t) {
										if (*++sParam == ' ') sParam++;
										funcParam = new(sParam, 0, (int)(t - sParam));
									}
								}
								t++;
							} else {
								funcName = new string(s, 0, (int)(t - s));
							}
							if (funcName == null || !s_userReplFuncs.TryGetValue(funcName, out var replFunc)) group = int.MaxValue;
							else b.Append(replFunc(m, groupNumber, funcParam));
						} else group = _GetGroup(s, t);
						
						int _GetGroup(char* start, char* end) {
							if (*start >= '0' && *start <= '9') { //${number}. info: group name cannot start with a digit, then PCRE returns error.
								int i = repl.ToInt((int)(start - s0), out int numEnd, STIFlags.NoHex);
								if (s0 + numEnd == end && i >= 0) return i;
							} else { //${name}
								int i = m.GroupNumberFromName_(start, (int)(end - start), out _); //speed: 40-100 ns
								if (i >= 0) return i;
							}
							return int.MaxValue;
						}
						
						s = t + 1;
					} else if (ch >= '0' && ch <= '9') { //$number
						group = repl.ToInt((int)(s - s0), out int numEnd, STIFlags.NoHex);
						if (numEnd == 0 || group < 0) group = int.MaxValue;
						s = s0 + numEnd;
					} else {
						s++;
						if (ch == '`') { //part before match
							int i = m.Start;
							if (i > 0) b.Append(m.Subject, 0, i);
						} else if (ch == '\'') { //part after match
							var subject = m.Subject;
							int i = m.End, len = subject.Length - i;
							if (len > 0) b.Append(subject, i, len);
						} else if (ch == '&') { //whole match
							group = 0;
						} else if (ch == '+') { //last group
							group = m.GroupCountPlusOne - 1;
						} else if (ch == '_') { //subject
							b.Append(m.Subject);
						} else if (ch == '*') { //last mark
							b.Append(m.Mark);
						} else group = int.MaxValue;
					}
					
					if (group >= 0) {
						//if $invalid, throw exception. Would be harmful to ignore when replacing in multiple files.
						if (group >= m.GroupCountPlusOne) throw new ArgumentException($"Invalid regex replacement: {new string(--s1e, 0, (int)(s - s1e))}");
						
						var g = m[group];
						if (g.Length > 0) b.Append(g.Subject_, g.Start, g.Length);
					}
					
					e = s;
				} else s++;
			}
			
			int tail = (int)(eos - e);
			if (tail > 0) b.Append(e, tail);
		}
	}
	
	/// <summary>
	/// Adds or replaces a function that is called when a regular expression replacement string contains <c>${+name}</c> or <c>${+name(g)}</c> or <c>${+name(g, v)}</c>, where <i>g</i> is group number or name and <i>v</i> is any string.
	/// </summary>
	/// <param name="name">A string used to identify the function. Can contain any characters except <c>'}'</c>, <c>'('</c> and <c>')'</c>.</param>
	/// <param name="replFunc">
	/// Callback function. Called for each found match. Returns the replacement.
	/// Parameters:
	/// <br/>• current match.
	/// <br/>• group number <i>g</i>, if replacement is like <c>${+name(g)}</c> or <c>${+name(g, v)}</c>; else 0.
	/// <br/>• string <i>v</i>, if replacement is like <c>${+name(g, v)}</c>; else <c>null</c>.
	/// 
	/// <para>
	/// In the callback function you can use <see cref="RXMatch.ExpandReplacement"/>.
	/// </para>
	/// </param>
	/// <remarks>
	/// Useful when there is no way to use <see cref="Replace"/> overloads with a <i>replFunc</i> parameter. For example in Find/Replace UI.
	/// </remarks>
	/// <example>
	/// Create new script in editor and add this code. In <b>Properties</b> set role <c>editorExtension</c>. Run.
	/// Then in the <b>Find</b> panel in the replacement field you can use <c>${+Lower}</c>, <c>${+Lower(1)}</c>, <c>${+Lower(2)}</c> etc.
	/// <code><![CDATA[
	/// regexp.addReplaceFunc("Lower", (m, g, v) => m[g].Value.Lower()); //make lowercase
	/// ]]></code>
	/// Another example. Replacement could be like <c>${+mul(1, 10)}</c>.
	/// <code><![CDATA[
	/// regexp.addReplaceFunc("mul", (m, g, v) => (m[g].Value.ToInt() * v.ToInt()).ToString()); //multiply by v
	/// ]]></code>
	/// </example>
	public static void addReplaceFunc(string name, Func<RXMatch, int, string, string> replFunc) {
		s_userReplFuncs[name] = replFunc;
	}
	static ConcurrentDictionary<string, Func<RXMatch, int, string, string>> s_userReplFuncs = new();
	
	//rejected: use pcre2_substitute. Not useful because: we cannot implement RXMatch.ExpandReplacement with it; we have addReplaceFunc.
	
	/// <summary>
	/// Returns an array of substrings that in the subject string are delimited by regular expression matches.
	/// </summary>
	/// <param name="s">Subject string. Cannot be <c>null</c>.</param>
	/// <param name="maxCount">Maximal count of substrings to get. The last substring contains the unsplit remainder of the subject string. If 0 (default) or negative, gets all.</param>
	/// <exception cref="ArgumentNullException"><i>s</i> is <c>null</c>.</exception>
	/// <exception cref="ArgumentOutOfRangeException">Invalid <i>range</i>.</exception>
	/// <exception cref="ArgumentException">
	/// <br/>• Used a <c>PARTIAL_</c> flag.
	/// <br/>• The regular expression contains <c>(?=...\K)</c>.
	/// </exception>
	/// <exception cref="AuException">The PCRE API function <c>pcre2_match</c> failed. Unlikely.</exception>
	/// <remarks>
	/// Element 0 of the returned array is <i>s</i> substring until the first match of the regular expression, element 1 is substring between the first and second match, and so on. If no matches, the array contains single element and it is <i>s</i>.
	/// 
	/// This function is similar to <see cref="Regex.Split(string, int)"/>.
	/// </remarks>
	/// <example>
	/// <code><![CDATA[
	/// var s = "one, two,three , four";
	/// var x = new regexp(@" *, *");
	/// var a = x.Split(s);
	/// for(int i = 0; i < a.Length; i++) print.it(i, a[i]);
	/// ]]></code>
	/// </example>
	/// <inheritdoc cref="IsMatch" path="/param"/>
	public string[] Split(string s, int maxCount = 0, Range? range = null, RXMatchFlags matchFlags = 0) {
		if (maxCount < 0) maxCount = 0;
		if (maxCount != 1) {
			var a = new List<string>();
			int prevEnd = 0;
			var e = new _MatchEnum(this, s, 0, range, matchFlags, maxCount - 1);
			while (e.Next()) {
				var p = e.GroupR;
				a.Add(s[prevEnd..p.start]);
				prevEnd = p.end;
			}
			if (e.foundCount > 0) {
				a.Add(s[prevEnd..]);
				return a.ToArray();
			}
		}
		return new string[] { s };
	}
	
	/// <summary>
	/// Returns <see cref="RXGroup"/> array of substrings delimited by regular expression matches.
	/// </summary>
	/// <example>
	/// <code><![CDATA[
	/// var s = "one, two,three , four";
	/// var x = new regexp(@" *, *");
	/// var a = x.SplitG(s);
	/// foreach(var v in a) print.it(v.Start, v.Value);
	/// ]]></code>
	/// </example>
	/// <inheritdoc cref="Split"/>
	public RXGroup[] SplitG(string s, int maxCount = 0, Range? range = null, RXMatchFlags matchFlags = 0) {
		if (maxCount < 0) maxCount = 0;
		if (maxCount != 1) {
			var a = new List<RXGroup>();
			int prevEnd = 0;
			var e = new _MatchEnum(this, s, 0, range, matchFlags, maxCount - 1);
			while (e.Next()) {
				var p = e.GroupR;
				a.Add(new RXGroup(s, prevEnd, p.start));
				prevEnd = p.end;
			}
			if (e.foundCount > 0) {
				a.Add(new RXGroup(s, prevEnd, s.Length));
				return a.ToArray();
			}
		}
		return new RXGroup[] { new RXGroup(s, 0, s.Length) };
	}
	
	//rejected: probably rarely used. Or need IEnumerable<string> too.
	//public IEnumerable<RXGroup> SplitE(string s, int maxCount = 0, Range? range = null, RXMatchFlags matchFlags = 0)
	//{
	//	if(maxCount< 0) maxCount = 0;
	//	if(maxCount != 1) {
	//		int prevEnd = 0;
	//		var e = new _MatchEnum(this, s, 0, range, matchFlags, maxCount - 1);
	//		while(e.Next()) {
	//			var p = e.GroupP;
	//			yield return new RXGroup(s, prevEnd, p.start);
	//			prevEnd = p.end;
	//		}
	//		if(e.foundCount > 0) {
	//			yield return new RXGroup(s, prevEnd, s.Length);
	//			yield break;
	//		}
	//	}
	//	yield return new RXGroup(s, 0, s.Length);
	//}
	
	//Calls pcre2_pattern_info(ALLOPTIONS), which returns flags passed to the ctor and possibly modified by (*OPTION) and possibly added UTF if contains non-ASCII characters.
	//Actually RXFlags is long, where the high 32 bits is extended options. This func gets only the main options (the low 32 bits).
	RXFlags _InfoAllOptions {
		get {
			RXFlags R;
			Cpp.pcre2_pattern_info(_CodeHR, Cpp.PCRE2_INFO_.ALLOPTIONS, &R);
			return R;
		}
	}
	
	/// <summary>
	/// Encloses string in <c>\Q \E</c> if it contains metacharacters <c>\^$.[|()?*+{</c> or if <i>always</i> == <c>true</c>.
	/// </summary>
	/// <param name="s">Can be <c>null</c>.</param>
	/// <param name="always">Enclose always, even if the string does not contain metacharacters. Should be <c>true</c> if the regular expression in which this string will be used has option "extended", because then whitespace is ignored and <c>#</c> is a special character too.</param>
	/// <remarks>
	/// Such enclosed substring in a regular expression is interpreted as a literal string.
	/// This function also escapes <c>\E</c>, so that it does not end the literal string.
	/// </remarks>
	public static string escapeQE(string s, bool always = false) {
		if (s == null) return s;
		if (always) goto g1;
		for (int i = 0; i < s.Length; i++) {
			char c = s[i];
			if ((c >= '(' && c <= '+') || c == '\\' || c == '.' || c == '?' || c == '{' || c == '[' || c == '|' || c == '$' || c == '^') goto g1;
			//this is slower
			//if(c < 128) {
			//	if(c < 64) {
			//		if(0 != (0b1000000000000000010011110001000000000000000000000000000000000000UL & (1UL << c))) goto g1;
			//	} else {
			//		if(0 != (0b0001100000000000000000000000000001011000000000000000000000000000UL & (1UL << (c - 64)))) goto g1;
			//	}
			//}
		}
		return s;
		g1:
		return @"\Q" + s.Replace(@"\E", @"\E\\E\Q") + @"\E";
	}
}


================================================
FILE: Au/String/regexp_ExtString.cs
================================================
namespace Au.Types;

public static partial class ExtString {
	/// <summary>
	/// Returns <c>true</c> if this string matches PCRE regular expression <i>rx</i>.
	/// </summary>
	/// <param name="t">This string. If <c>null</c>, returns <c>false</c>.</param>
	/// <exception cref="ArgumentException">Invalid regular expression.</exception>
	/// <exception cref="ArgumentOutOfRangeException">Invalid <i>range</i>.</exception>
	/// <exception cref="AuException">Failed (unlikely).</exception>
	/// <remarks>More info and examples: <see cref="regexp"/>.</remarks>
	/// <example></example>
	/// <inheritdoc cref="regexp.IsMatch"/>
	/// <inheritdoc cref="regexp(string, RXFlags)" path="/param"/>
	public static bool RxIsMatch(this string t,
		[ParamString(PSFormat.Regexp)] string rx,
		RXFlags flags = 0, Range? range = null) {
		var x = _cache.AddOrGet(rx, flags);
		return x.IsMatch(t, range);
	}
	
	/// <summary>
	/// Returns <c>true</c> if this string matches PCRE regular expression <i>rx</i>.
	/// Gets match info as <see cref="RXMatch"/>.
	/// </summary>
	/// <param name="t">This string. If <c>null</c>, returns <c>false</c>.</param>
	/// <exception cref="ArgumentOutOfRangeException">Invalid <i>range</i>.</exception>
	/// <exception cref="ArgumentException">Invalid regular expression.</exception>
	/// <exception cref="AuException">Failed (unlikely).</exception>
	/// <remarks>More info and examples: <see cref="regexp"/>.</remarks>
	/// <example></example>
	/// <inheritdoc cref="regexp.Match(string, out RXMatch, Range?, RXMatchFlags)"/>
	/// <inheritdoc cref="regexp(string, RXFlags)" path="/param"/>
	public static bool RxMatch(this string t,
		[ParamString(PSFormat.Regexp)] string rx,
		out RXMatch result, RXFlags flags = 0, Range? range = null) {
		var x = _cache.AddOrGet(rx, flags);
		return x.Match(t, out result, range);
	}
	
	/// <summary>
	/// Returns <c>true</c> if this string matches PCRE regular expression <i>rx</i>.
	/// Gets whole match or some group, as string.
	/// </summary>
	/// <param name="t">This string. If <c>null</c>, returns <c>false</c>.</param>
	/// <exception cref="ArgumentOutOfRangeException">Invalid <i>group</i> or <i>range</i>.</exception>
	/// <exception cref="ArgumentException">Invalid regular expression.</exception>
	/// <exception cref="AuException">Failed (unlikely).</exception>
	/// <remarks>More info and examples: <see cref="regexp"/>.</remarks>
	/// <example></example>
	/// <inheritdoc cref="regexp.Match(string, int, out string, Range?, RXMatchFlags)"/>
	/// <inheritdoc cref="regexp(string, RXFlags)" path="/param"/>
	public static bool RxMatch(this string t,
		[ParamString(PSFormat.Regexp)] string rx,
		int group, out string result, RXFlags flags = 0, Range? range = null) {
		var x = _cache.AddOrGet(rx, flags);
		return x.Match(t, group, out result, range);
	}
	
	/// <summary>
	/// Returns <c>true</c> if this string matches PCRE regular expression <i>rx</i>.
	/// Gets whole match or some group, as index and length.
	/// </summary>
	/// <param name="t">This string. If <c>null</c>, returns <c>false</c>.</param>
	/// <exception cref="ArgumentOutOfRangeException">Invalid <i>group</i> or <i>range</i>.</exception>
	/// <exception cref="ArgumentException">Invalid regular expression.</exception>
	/// <exception cref="AuException">Failed (unlikely).</exception>
	/// <remarks>More info and examples: <see cref="regexp"/>.</remarks>
	/// <example></example>
	/// <inheritdoc cref="regexp.Match(string, int, out RXGroup, Range?, RXMatchFlags)"/>
	/// <inheritdoc cref="regexp(string, RXFlags)" path="/param"/>
	public static bool RxMatch(this string t,
		[ParamString(PSFormat.Regexp)] string rx,
		int group, out RXGroup result, RXFlags flags = 0, Range? range = null) {
		var x = _cache.AddOrGet(rx, flags);
		return x.Match(t, group, out result, range);
	}
	
	/// <summary>
	/// Finds all match instances of PCRE regular expression <i>rx</i>.
	/// </summary>
	/// <param name="t">This string.</param>
	/// <exception cref="ArgumentOutOfRangeException">Invalid <i>range</i>.</exception>
	/// <exception cref="ArgumentException">Invalid regular expression. Or used a <c>PARTIAL_</c> flag.</exception>
	/// <exception cref="AuException">Failed (unlikely).</exception>
	/// <remarks>More info and examples: <see cref="regexp"/>.</remarks>
	/// <example></example>
	/// <inheritdoc cref="regexp.FindAll(string, Range?, RXMatchFlags)"/>
	/// <inheritdoc cref="regexp(string, RXFlags)" path="/param"/>
	public static IEnumerable<RXMatch> RxFindAll(this string t,
		[ParamString(PSFormat.Regexp)] string rx,
		RXFlags flags = 0, Range? range = null) {
		if (t == null) throw new NullReferenceException();
		var x = _cache.AddOrGet(rx, flags);
		return x.FindAll(t, range);
	}
	
	/// <summary>
	/// Finds all match instances of PCRE regular expression <i>rx</i>. Gets array of <see cref="RXMatch"/>.
	/// </summary>
	/// <param name="t">This string.</param>
	/// <exception cref="ArgumentOutOfRangeException">Invalid <i>range</i>.</exception>
	/// <exception cref="ArgumentException">Invalid regular expression. Or used a <c>PARTIAL_</c> flag.</exception>
	/// <exception cref="AuException">Failed (unlikely).</exception>
	/// <remarks>More info and examples: <see cref="regexp"/>.</remarks>
	/// <example></example>
	/// <inheritdoc cref="regexp.FindAll(string, out RXMatch[], Range?, RXMatchFlags)"/>
	/// <inheritdoc cref="regexp(string, RXFlags)" path="/param"/>
	public static bool RxFindAll(this string t,
		[ParamString(PSFormat.Regexp)] string rx,
		out RXMatch[] result, RXFlags flags = 0, Range? range = null) {
		if (t == null) throw new NullReferenceException();
		var x = _cache.AddOrGet(rx, flags);
		return x.FindAll(t, out result, range);
	}
	
	/// <summary>
	/// Finds all match instances of PCRE regular expression <i>rx</i>.
	/// </summary>
	/// <param name="t">This string.</param>
	/// <exception cref="ArgumentOutOfRangeException">Invalid <i>group</i> or <i>range</i>.</exception>
	/// <exception cref="ArgumentException">Invalid regular expression. Or used a <c>PARTIAL_</c> flag.</exception>
	/// <exception cref="AuException">Failed (unlikely).</exception>
	/// <remarks>More info and examples: <see cref="regexp"/>.</remarks>
	/// <example></example>
	/// <inheritdoc cref="regexp.FindAll(string, int, Range?, RXMatchFlags)"/>
	/// <inheritdoc cref="regexp(string, RXFlags)" path="/param"/>
	public static IEnumerable<string> RxFindAll(this string t,
		[ParamString(PSFormat.Regexp)] string rx,
		int group, RXFlags flags = 0, Range? range = null) {
		if (t == null) throw new NullReferenceException();
		var x = _cache.AddOrGet(rx, flags);
		return x.FindAll(t, group, range);
	}
	
	/// <summary>
	/// Finds all match instances of PCRE regular expression <i>rx</i>. Gets array of strings.
	/// </summary>
	/// <param name="t">This string.</param>
	/// <exception cref="ArgumentOutOfRangeException">Invalid <i>group</i> or <i>range</i>.</exception>
	/// <exception cref="ArgumentException">Invalid regular expression. Or used a <c>PARTIAL_</c> flag.</exception>
	/// <exception cref="AuException">Failed (unlikely).</exception>
	/// <remarks>More info and examples: <see cref="regexp"/>.</remarks>
	/// <example></example>
	/// <inheritdoc cref="regexp.FindAll(string, int, out string[], Range?, RXMatchFlags)"/>
	/// <inheritdoc cref="regexp(string, RXFlags)" path="/param"/>
	public static bool RxFindAll(this string t,
		[ParamString(PSFormat.Regexp)] string rx,
		int group, out string[] result, RXFlags flags = 0, Range? range = null) {
		if (t == null) throw new NullReferenceException();
		var x = _cache.AddOrGet(rx, flags);
		return x.FindAll(t, group, out result, range);
	}
	
	//rejected. Rarely used.
	///// <summary>
	///// Finds all match instances of PCRE regular expression <i>rx</i>. Gets array of <see cref="RXGroup"/>.
	///// </summary>
	///// <param name="t">This string.</param>
	///// <exception cref="ArgumentOutOfRangeException">Invalid <i>group</i> or <i>range</i>.</exception>
	///// <exception cref="ArgumentException">Invalid regular expression. Or used a <c>PARTIAL_</c> flag.</exception>
	///// <exception cref="AuException">Failed (unlikely).</exception>
	///// <remarks>More info and examples: <see cref="regexp"/>.</remarks>
	///// <example></example>
	///// <inheritdoc cref="regexp.FindAllG(string, int, out RXGroup[], Range?, RXMatchFlags)"/>
	///// <inheritdoc cref="regexp(string, RXFlags)" path="/param"/>
	//public static bool RxFindAll(this string t,
	//	[ParamString(PSFormat.regexp)] string rx,
	//	int group, out RXGroup[] result, RXFlags flags = 0, Range? range = null) {
	//	if (t == null) throw new NullReferenceException();
	//	var x = _cache.AddOrGet(rx, flags);
	//	return x.FindAllG(t, group, out result, range);
	//}
	
	/// <summary>
	/// Finds and replaces all match instances of PCRE regular expression <i>rx</i>.
	/// </summary>
	/// <param name="t">This string.</param>
	/// <exception cref="ArgumentOutOfRangeException">Invalid <i>range</i>.</exception>
	/// <exception cref="ArgumentException">
	/// - Invalid regular expression.
	/// - Invalid <c>$replacement</c>.
	/// - Used a <c>PARTIAL_</c> flag.
	/// - The regular expression contains <c>(?=...\K)</c>.
	/// </exception>
	/// <exception cref="AuException">Failed (unlikely).</exception>
	/// <remarks>More info and examples: <see cref="regexp"/>.</remarks>
	/// <example></example>
	/// <inheritdoc cref="regexp.Replace(string, string, int, Range?, RXMatchFlags)"/>
	/// <inheritdoc cref="regexp(string, RXFlags)" path="/param"/>
	public static string RxReplace(this string t,
		[ParamString(PSFormat.Regexp)] string rx,
		[ParamString(PSFormat.RegexpReplacement)] string repl,
		int maxCount = -1, RXFlags flags = 0, Range? range = null) {
		if (t == null) throw new NullReferenceException();
		var x = _cache.AddOrGet(rx, flags);
		return x.Replace(t, repl, maxCount, range);
	}
	
	/// <summary>
	/// Finds and replaces all match instances of PCRE regular expression <i>rx</i>.
	/// </summary>
	/// <param name="t">This string.</param>
	/// <exception cref="ArgumentOutOfRangeException">Invalid <i>range</i>.</exception>
	/// <exception cref="ArgumentException">
	/// - Invalid regular expression.
	/// - Invalid <c>$replacement</c>.
	/// - Used a <c>PARTIAL_</c> flag.
	/// - The regular expression contains <c>(?=...\K)</c>.
	/// </exception>
	/// <exception cref="AuException">Failed (unlikely).</exception>
	/// <remarks>More info and examples: <see cref="regexp"/>.</remarks>
	/// <example></example>
	/// <inheritdoc cref="regexp.Replace(string, string, out string, int, Range?, RXMatchFlags)"/>
	/// <inheritdoc cref="regexp(string, RXFlags)" path="/param"/>
	public static int RxReplace(this string t,
		[ParamString(PSFormat.Regexp)] string rx,
		[ParamString(PSFormat.RegexpReplacement)] string repl,
		out string result, int maxCount = -1, RXFlags flags = 0, Range? range = null) {
		if (t == null) throw new NullReferenceException();
		var x = _cache.AddOrGet(rx, flags);
		return x.Replace(t, repl, out result, maxCount, range);
	}
	
	/// <summary>
	/// Finds and replaces all match instances of PCRE regular expression <i>rx</i>. Uses a callback function.
	/// </summary>
	/// <param name="t">This string.</param>
	/// <exception cref="ArgumentOutOfRangeException">Invalid <i>range</i>.</exception>
	/// <exception cref="ArgumentException">
	/// - Invalid regular expression.
	/// - Invalid <c>$replacement</c>.
	/// - Used a <c>PARTIAL_</c> flag.
	/// - The regular expression contains <c>(?=...\K)</c>.
	/// </exception>
	/// <exception cref="AuException">Failed (unlikely).</exception>
	/// <remarks>More info and examples: <see cref="regexp"/>.</remarks>
	/// <example></example>
	/// <inheritdoc cref="regexp.Replace(string, Func{RXMatch, string}, int, Range?, RXMatchFlags)"/>
	/// <inheritdoc cref="regexp(string, RXFlags)" path="/param"/>
	public static string RxReplace(this string t,
		[ParamString(PSFormat.Regexp)] string rx,
		Func<RXMatch, string> replFunc, int maxCount = -1, RXFlags flags = 0, Range? range = null) {
		if (t == null) throw new NullReferenceException();
		var x = _cache.AddOrGet(rx, flags);
		return x.Replace(t, replFunc, maxCount, range);
	}
	
	/// <summary>
	/// Finds and replaces all match instances of PCRE regular expression <i>rx</i>. Uses a callback function.
	/// </summary>
	/// <param name="t">This string.</param>
	/// <exception cref="ArgumentOutOfRangeException">Invalid <i>range</i>.</exception>
	/// <exception cref="ArgumentException">
	/// - Invalid regular expression.
	/// - Invalid <c>$replacement</c>.
	/// - Used a <c>PARTIAL_</c> flag.
	/// - The regular expression contains <c>(?=...\K)</c>.
	/// </exception>
	/// <exception cref="AuException">Failed (unlikely).</exception>
	/// <remarks>More info and examples: <see cref="regexp"/>.</remarks>
	/// <example></example>
	/// <inheritdoc cref="regexp.Replace(string, Func{RXMatch, string}, out string, int, Range?, RXMatchFlags)"/>
	/// <inheritdoc cref="regexp(string, RXFlags)" path="/param"/>
	public static int RxReplace(this string t,
		[ParamString(PSFormat.Regexp)] string rx,
		Func<RXMatch, string> replFunc, out string result, int maxCount = -1, RXFlags flags = 0, Range? range = null) {
		if (t == null) throw new NullReferenceException();
		var x = _cache.AddOrGet(rx, flags);
		return x.Replace(t, replFunc, out result, maxCount, range);
	}
	
	/// <summary>
	/// Returns an array of substrings that in this string are delimited by regular expression matches.
	/// </summary>
	/// <param name="t">This string.</param>
	/// <exception cref="ArgumentOutOfRangeException">Invalid <i>range</i>.</exception>
	/// <exception cref="ArgumentException">Invalid regular expression. Or used a <c>PARTIAL_</c> flag.</exception>
	/// <exception cref="AuException">Failed (unlikely).</exception>
	/// <remarks>More info and examples: <see cref="regexp"/>.</remarks>
	/// <example></example>
	/// <inheritdoc cref="regexp.Split(string, int, Range?, RXMatchFlags)"/>
	/// <inheritdoc cref="regexp(string, RXFlags)" path="/param"/>
	public static string[] RxSplit(this string t,
		[ParamString(PSFormat.Regexp)] string rx,
		int maxCount = 0, RXFlags flags = 0, Range? range = null) {
		if (t == null) throw new NullReferenceException();
		var x = _cache.AddOrGet(rx, flags);
		return x.Split(t, maxCount, range);
	}
	
	static _RegexCache _cache = new();
	
	//Cache of compiled regular expressions.
	//Can make ~10 times faster when the subject string is short.
	//The algorithm is from .NET Regex source code.
	class _RegexCache {
		struct _RXCode {
			public string regex;
			public regexp code; //note: could instead cache only PCRE code (nint), but it makes quite difficult
			public RXFlags flags;
		}
		
		LinkedList<_RXCode> _list = new();
		const int c_maxCount = 15;
		
		/// <summary>
		/// If <i>rx</i>/<i>flags</i> is in the cache, returns the cached code.
		/// Else compiles <i>rx</i>/<i>flags</i>, adds to the cache and returns the code.
		/// </summary>
		/// <param name="rx"></param>
		/// <param name="flags"></param>
		/// <exception cref="ArgumentException">Invalid regular expression. Or failed to compile it for some other reason.</exception>
		public regexp AddOrGet(string rx, RXFlags flags) {
			lock (this) {
				int len = rx.Length;
				for (var x = _list.First; x != null; x = x.Next) {
					var v = x.Value.regex;
					if (v.Length == len && v == rx && x.Value.flags == flags) {
						if (x != _list.First) {
							_list.Remove(x);
							_list.AddFirst(x);
						}
						return x.Value.code;
					}
				}
				{
					var code = new regexp(rx, flags);
					
					var x = new _RXCode() { code = code, regex = rx, flags = flags };
					_list.AddFirst(x);
					if (_list.Count > c_maxCount) _list.RemoveLast();
					//note: now cannot free the PCRE code, because another thread may be using it. GC will do it safely.
					
					return code;
				}
			}
		}
	}
}


================================================
FILE: Au/String/regexp_types.cs
================================================

using System.Text.RegularExpressions; //for XML doc links

namespace Au.Types {
	/// <summary>
	/// Regular expression match info.
	/// Used with <see cref="regexp"/> class functions and <see cref="String"/> extension methods like <see cref="ExtString.RxMatch"/>.
	/// </summary>
	/// <remarks>
	/// Contains info about a regular expression match found in the subject string: index, length, substring, etc.
	/// Also contains an array of group matches, as <see cref="RXGroup"/>. Groups are regular expression parts enclosed in <c>()</c>, except <c>(?...)</c>.
	/// Group matches can be accessed like array elements. Group 0 is whole match. Group 1 is the first group. See examples.
	/// </remarks>
	/// <example>
	/// <code><![CDATA[
	/// var s = "ab cd-45-ef gh";
	/// if(s.RxMatch(@"\b([a-z]+)-(\d+)\b", out RXMatch m))
	/// 	print.it(
	/// 		m.GroupCountPlusOne, //3 (whole match and 2 groups)
	/// 		m.Start, //3, same as m[0].Index
	/// 		m.Value, //"cd-45-ef", same as m[0].Value
	/// 		m[1].Start, //3
	/// 		m[1].Value, //"cd"
	/// 		m[2].Start, //6
	/// 		m[2].Value //"45"
	/// 		);
	/// ]]></code>
	/// A group in the subject string may not exist even if whole match found. Then its <see cref="Exists"/> property is <c>false</c>, <see cref="Start"/> -1, <see cref="Length"/> 0, <see cref="Value"/> <c>null</c>.
	/// <code><![CDATA[
	/// var s = "ab cd--ef gh";
	/// if(s.RxMatch(@"\b([a-z]+)-(\d+)?-([a-z]+)\b", out RXMatch m))
	/// 	print.it(
	/// 		m.GroupCountPlusOne, //4 (whole match and 3 groups)
	/// 		m[2].Exists, //false
	/// 		m[2].Start, //-1
	/// 		m[2].Length, //0
	/// 		m[2].Value //null
	/// 		);
	/// ]]></code>
	/// </example>
	public unsafe class RXMatch {
		internal RXMatch(regexp rx, string subject, int rc, in Cpp.RegexMatch k) {
			Mark = k.Mark;
			if (rc < 0) return;
			Exists = true;
			IsPartial = rc == 0;
			StartNoK = k.indexNoK;
			_rx = rx;
			//_subject = subject;

			var g = _groups = new RXGroup[k.vecCount];
			var v = k.vec;
			for (int i = 0; i < g.Length; i++) {
				g[i] = new RXGroup(subject, v[i]);
			}
		}

		//string readonly _subject;
		readonly regexp _rx;
		readonly RXGroup[] _groups;

		/// <summary>
		/// Gets the subject string in which this match was found.
		/// </summary>
		public string Subject => _groups[0].Subject_;

		/// <summary>
		/// Gets the number of groups in the regular expression, + 1 for the whole match.
		/// </summary>
		public int GroupCountPlusOne => _groups.Length;

		/// <summary>
		/// Gets start offset of the match in the subject string. The same as that of group 0 (<see cref="RXGroup.Start"/>).
		/// </summary>
		public int Start => _groups[0].Start;

		/// <summary>
		/// Gets length of the match in the subject string. The same as that of group 0 (<see cref="RXGroup.Length"/>).
		/// </summary>
		public int Length => _groups[0].Length;

		/// <summary>
		/// Gets end offset of the match in the subject string (<see cref="Start"/> + <see cref="Length"/>). The same as that of group 0 (<see cref="RXGroup.End"/>).
		/// </summary>
		public int End => _groups[0].End;

		/// <summary>
		/// Gets substring of the subject string from <see cref="Start"/> to <see cref="End"/>. The same as that of group 0 (<see cref="RXGroup.Value"/>).
		/// </summary>
		public string Value => _groups[0].Value;

		/// <summary>
		/// Gets span of the subject string from <see cref="Start"/> to <see cref="End"/>. The same as that of group 0 (<see cref="RXGroup.Span"/>).
		/// </summary>
		/// <remarks>
		/// Unlike <see cref="Value"/>, does not create new string.
		/// </remarks>
		public RStr Span => _groups[0].Span;

		/// <summary>
		/// Returns <see cref="RXGroup.ToString"/> of group 0.
		/// </summary>
		public override string ToString() => _groups[0].ToString();

		/// <summary>
		/// Gets substring of the subject string from <see cref="Start"/> to <see cref="End"/>. The same as that of group 0 (<see cref="RXGroup.GetValue_"/>).
		/// </summary>
		/// <remarks>
		/// Use this function instead of <see cref="Value"/> with results of <see cref="regexp"/> functions where subject is <c>ReadOnlySpan</c>.
		/// </remarks>
		/// <param name="subject">Must be the same subject string as passed to the <see cref="regexp"/> function that returned this result.</param>
		internal string GetValue_(RStr subject) => _groups[0].GetValue_(subject);

		/// <summary>
		/// Gets span of the subject string from <see cref="Start"/> to <see cref="End"/>. The same as that of group 0 (<see cref="RXGroup.GetSpan_"/>).
		/// </summary>
		/// <remarks>
		/// Use this function instead of <see cref="Span"/> with results of <see cref="regexp"/> functions where subject is <c>ReadOnlySpan</c>.
		/// </remarks>
		/// <param name="subject">Must be the same subject string as passed to the <see cref="regexp"/> function that returned this result.</param>
		internal RStr GetSpan_(RStr subject) => _groups[0].GetSpan_(subject);

		/// <summary>
		/// Gets start offset of whole match regardless of <c>\K</c>.
		/// When the regular expression contains <c>\K</c>, this is less than <see cref="Start"/>.
		/// </summary>
		public int StartNoK { get; private set; }

		/// <summary>
		/// Gets the name of a found mark, or <c>null</c>.
		/// </summary>
		/// <remarks>
		/// Marks can be inserted in regular expression pattern like <c>(*MARK:name)</c> or <c>(*:name)</c>.
		/// After a full successful match, it is the last mark encountered on the matching path through the pattern. After a "no match" or a partial match, it is the last encountered mark. For example, consider this pattern: <c>"^(*MARK:A)((*MARK:B)a|b)c"</c>. When it matches <c>"bc"</c>, the mark is <c>A</c>. The <c>B</c> mark is "seen" in the first branch of the group, but it is not on the matching path. On the other hand, when this pattern fails to match <c>"bx"</c>, the mark is <c>B</c>.
		/// </remarks>
		public string Mark { get; private set; }

		/// <summary>
		/// Gets the return value of the <see cref="regexp.Match(string, out RXMatch, Range?, RXMatchFlags)"/> call.
		/// </summary>
		/// <remarks>
		/// Can be <c>false</c> only when the function returned <c>false</c> but a mark is available (see <see cref="Mark"/>). Otherwise, when the function returns <c>false</c>, it returns <c>null</c> instead of a <see cref="RXMatch"/> object.
		/// When <c>false</c>, all properties except <see cref="Exists"/> and <see cref="Mark"/> have undefined values or throw exception.
		/// </remarks>
		public bool Exists { get; private set; }

		/// <summary>
		/// Returns <c>true</c> if this match is <see href="https://www.pcre.org/current/doc/html/pcre2partial.html">partial</see>.
		/// Partial match is possible if used a <c>PARTIAL_</c> flag.
		/// </summary>
		public bool IsPartial { get; private set; }

		/// <summary>
		/// Gets group info. Index 0 is whole match. Index 1 is the first group.
		/// </summary>
		/// <param name="group">1-based group index, or 0 for whole match.</param>
		/// <exception cref="IndexOutOfRangeException">Invalid <i>group</i>. Max valid value is <see cref="GroupCountPlusOne"/>.</exception>
		public ref RXGroup this[int group] => ref _groups[group];

		/// <summary>
		/// Gets group info of a named group.
		/// </summary>
		/// <param name="groupName">
		/// Group name.
		/// In regular expression, to set name of group <c>(text)</c>, use <c>(?&lt;NAME&gt;text)</c>.
		/// </param>
		/// <exception cref="ArgumentException">Unknown group name.</exception>
		/// <remarks>
		/// If multiple groups have this name, prefers the first group that matched (<see cref="RXGroup.Exists"/> is <c>true</c>).
		/// </remarks>
		public ref RXGroup this[string groupName] {
			get {
				int i = GroupNumberFromName(groupName);
				if (i < 0) throw new ArgumentException("Unknown group name.");
				return ref _groups[i];
			}
		}

		/// <summary>
		/// Finds a named group and returns its 1-based index. Returns -1 if not found.
		/// </summary>
		/// <param name="groupName">
		/// Group name.
		/// In regular expression, to set name of group <c>(text)</c>, use <c>(?&lt;NAME&gt;text)</c>.
		/// </param>
		/// <exception cref="ArgumentNullException"></exception>
		/// <remarks>
		/// If multiple groups have this name, prefers the first group that matched (<see cref="RXGroup.Exists"/> is <c>true</c>).
		/// </remarks>
		/// <seealso cref="regexp.GetGroupNumberOf"/>
		public int GroupNumberFromName(string groupName) {
			Not_.Null(groupName);
			fixed (char* p = groupName) return GroupNumberFromName_(p, groupName.Length, out _);
		}

		/// <summary>
		/// Finds a named group and returns its 1-based index. Returns -1 if not found.
		/// </summary>
		/// <param name="groupName">
		/// Group name.
		/// In regular expression, to set name of group <c>(text)</c>, use <c>(?&lt;NAME&gt;text)</c>.
		/// </param>
		/// <param name="notUnique">Receives <c>true</c> if multiple groups have this name.</param>
		/// <exception cref="ArgumentNullException"></exception>
		/// <remarks>
		/// If multiple groups have this name, prefers the first group that matched (<see cref="RXGroup.Exists"/> is <c>true</c>).
		/// </remarks>
		/// <seealso cref="regexp.GetGroupNumberOf"/>
		public int GroupNumberFromName(string groupName, out bool notUnique) {
			Not_.Null(groupName);
			fixed (char* p = groupName) return GroupNumberFromName_(p, groupName.Length, out notUnique);
		}

		//Used by regexp.ReplaceAll to avoid repl.Substring.
		internal int GroupNumberFromName_(char* s, int len, out bool notUnique) {
			notUnique = false;
			if (len > 32 || len < 1) return -1;
			int step; ushort* first, last;
			if (s[len] == '\0') {
				step = Cpp.pcre2_substring_nametable_scan(_rx._CodeHR, s, &first, &last);
			} else {
				var p = stackalloc char[33];
				int i; for (i = 0; i < len; i++) p[i] = s[i]; p[i] = '\0';
				step = Cpp.pcre2_substring_nametable_scan(_rx._CodeHR, p, &first, &last);
			}
			if (step <= 0) return -1;
			int R = 0;
			notUnique = last > first;
			for (; first <= last; first += step) {
				int r = *first;
				if (_groups[r].Start >= 0) return r; //return the first that is set
				if (R == 0) R = r; //if none is set, return the first
			}
			return R;
		}

		/// <summary>
		/// Returns expanded version of the specified replacement pattern.
		/// </summary>
		/// <param name="repl">
		/// Replacement pattern.
		/// Can consist of any combination of literal text and substitutions like <c>$1</c>.
		/// Supports .NET regular expression substitution syntax. See <see cref="Regex.Replace(string, string, int)"/>. Also: replaces <c>$*</c> with the name of the last encountered mark; replaces <c>${+func}</c> and <c>${+func(n)}</c> with the return value of a function registered with <see cref="regexp.addReplaceFunc"/>.
		/// </param>
		/// <exception cref="ArgumentException">
		/// - Invalid <c>$replacement</c>.
		/// - Used a <c>PARTIAL_</c> flag.
		/// - The regular expression contains <c>(?=...\K)</c>.
		/// </exception>
		/// <remarks>
		/// Works like <see cref="Match.Result"/>.
		/// See also: <see cref="regexp.Replace(string, string, int, Range?, RXMatchFlags)"/>.
		/// </remarks>
		public string ExpandReplacement(string repl) {
			if (repl.NE()) return repl;
			using (new StringBuilder_(out var b)) {
				regexp.ExpandReplacement_(this, repl, b);
				return b.ToString();
			}
		}
	}

	/// <summary>
	/// Regular expression group match info.
	/// Used with <see cref="RXMatch"/>, <see cref="regexp"/> and some <see cref="String"/> extension methods.
	/// </summary>
	/// <remarks>
	/// Groups are regular expression parts enclosed in <c>()</c>. Except non-capturing parts, like <c>(?:...)</c> and <c>(?options)</c>. A <c>RXGroup</c> variable contains info about a group found in the subject string: index, length, substring.
	/// 
	/// Some groups specified in regular expression may not exist in the subject string even if it matches the regular expression. For example, regular expression <c>"A(\d+)?B"</c> matches string <c>"AB"</c>, but group <c>(\d+)</c> does not exist. Then <see cref="Exists"/> is <c>false</c>, <see cref="Start"/> -1, <see cref="Length"/> 0, <see cref="Value"/> <c>null</c>.
	/// 
	/// When a group matches multiple times, the <c>RXGroup</c> variable contains only the last instance. For example, if subject is <c>"begin 12 345 67 end"</c> and regular expression is <c>(\d+ )+</c>, value of group 1 is <c>"67"</c>. If you need all instances (<c>"12"</c>, <c>"345"</c>, <c>"67"</c>), instead use .NET <see cref="Regex"/> and <see cref="Group.Captures"/>. Also you can get all instances with <see cref="regexp.Callout"/>.
	/// 
	/// Examples and more info: <see cref="RXMatch"/>, <see cref="regexp"/>.
	/// </remarks>
	public struct RXGroup {
		readonly string _subject;
		readonly int _index; //offset in _subject, or -1 if this group does not exist
		readonly int _len; //length, or 0 if this group match does not exist

		internal RXGroup(string subject, int start, int end) {
			_subject = subject;
			_index = start;
			_len = end - start; //note: can be <0 if (?=...\K). It's OK.
		}

		internal RXGroup(string subject, StartEnd r) {
			_subject = subject;
			_index = r.start;
			_len = r.Length; //note: can be <0 if (?=...\K). It's OK.
		}

		internal string Subject_ => _subject;

		/// <summary>
		/// Gets start offset of the group match in the subject string.
		/// </summary>
		public int Start => _index;

		/// <summary>
		/// Gets length of the group match in the subject string.
		/// </summary>
		public int Length => _len;

		/// <summary>
		/// Gets end offset of the group match in the subject string (<see cref="Start"/> + <see cref="Length"/>).
		/// </summary>
		public int End => _index + _len;

		/// <summary>
		/// Returns <c>true</c> if the group exists in the subject string, <c>false</c> if does not exist.
		/// More info in <see cref="RXGroup"/> topic. Example in <see cref="RXMatch"/> topic.
		/// </summary>
		/// <remarks>
		/// Other ways to detect it: if a group does not exist, its <see cref="Start"/> is -1 and <see cref="Value"/> is <c>null</c>.
		/// </remarks>
		public bool Exists => _index >= 0;

		/// <summary>
		/// Gets span of the subject string from <see cref="Start"/> to <see cref="End"/>.
		/// </summary>
		/// <returns><c>default</c> if the group does not exist in the subject string (see <see cref="Exists"/>).</returns>
		/// <remarks>
		/// Unlike <see cref="Value"/>, does not create new string.
		/// </remarks>
		public RStr Span => _len > 0 ? _subject.AsSpan(_index, _len) : (_index < 0 ? default : ""); //_len can be < 0

		/// <summary>
		/// Gets substring of the subject string from <see cref="Start"/> to <see cref="End"/>.
		/// </summary>
		/// <returns><c>null</c> if the group does not exist in the subject string (see <see cref="Exists"/>).</returns>
		/// <remarks>
		/// Creates new string each time. See also <see cref="Span"/>.
		/// </remarks>
		public string Value => _len > 0 ? _subject[_index..End] : (_index < 0 ? null : ""); //_len can be < 0

		/// <summary>
		/// Returns <see cref="Value"/>.
		/// </summary>
		public override string ToString() => Value;
		//public override string ToString() => _subject != null ? Value : $"{_index}..{End}";

		/// <summary>
		/// Gets substring of the subject string from <see cref="Start"/> to <see cref="End"/>.
		/// Returns <c>null</c> if the group does not exist in the subject string (see <see cref="Exists"/>).
		/// </summary>
		/// <remarks>
		/// Use this function instead of <see cref="Value"/> with results of <see cref="regexp"/> functions where subject is <c>ReadOnlySpan</c>.
		/// </remarks>
		/// <param name="subject">Must be the same subject string as passed to the <see cref="regexp"/> function that returned this result.</param>
		internal string GetValue_(RStr subject) => _len > 0 ? subject[_index..End].ToString() : (_index < 0 ? null : "");

		/// <summary>
		/// Gets span of the subject string from <see cref="Start"/> to <see cref="End"/>.
		/// Returns <c>null</c> if the group does not exist in the subject string (see <see cref="Exists"/>).
		/// </summary>
		/// <remarks>
		/// Use this function instead of <see cref="Span"/> with results of <see cref="regexp"/> functions where subject is <c>ReadOnlySpan</c>.
		/// </remarks>
		/// <param name="subject">Must be the same subject string as passed to the <see cref="regexp"/> function that returned this result.</param>
		internal RStr GetSpan_(RStr subject) => _len > 0 ? subject.Slice(_index, _len) : (_index < 0 ? default : "");

		///
		public static implicit operator Range(RXGroup g) => g.Exists ? g.Start..g.End : default;
	}


	#region callout

	/// <summary>
	/// Managed version of PCRE API struct <c>pcre2_callout_block</c>.
	/// When you set <see cref="regexp.Callout"/>, your callout function's parameter is of this type.
	/// </summary>
	/// <remarks>
	/// More info in PCRE help topic <see href="https://www.pcre.org/current/doc/html/pcre2callout.html">pcre2callout</see>.
	/// Most properties are <c>pcre2_callout_block</c> fields as documented in PCRE help. Other properties and methods are easier/safer versions of unsafe fields like <c>offset_vector</c>.
	/// </remarks>
	public unsafe struct RXCalloutData {
#pragma warning disable 649 //field never assigned
		struct pcre2_callout_block {
			public int version;
			public readonly int callout_number, capture_top, capture_last;
			public readonly nint* vec;
			public readonly char* mark, subject;
			public readonly nint subject_length;
			public readonly nint start_match;
			public readonly nint current_position;
			public readonly nint pattern_position;
			public readonly nint next_item_length;
			public readonly nint callout_string_offset;
			public readonly nint callout_string_length;
			public readonly char* callout_string;
			public readonly int callout_flags;
		}
#pragma warning restore 649

		//We use pointer instead of adding pcre2_callout_block fields to this struct. Other ways are not good:
		//	Passing whole block to the final callback by value is slow (104 bytes, tested speed). Also then cannot have Result like now.
		//	With 'in' fast, but then users have to declare lambda parameters like 'in RXCalloutData d'. Now just 'd'.
		pcre2_callout_block* _p;

		/// <summary>
		/// Sets the return value of the callout function, as documented in PCRE help topic <see href="https://www.pcre.org/current/doc/html/pcre2callout.html">pcre2callout</see>.
		/// </summary>
		/// <remarks>
		/// Default 0.
		/// If 1, matching fails at the current point, but the testing of other matching possibilities goes ahead, just as if a lookahead assertion had failed.
		/// If -1 (<c>PCRE2_ERROR_NOMATCH</c>), the match function returns <c>false</c> (no match). Values less tan -2 are PCRE error codes and cause exception.
		/// </remarks>
		public int Result { set => _p->version = value; internal get => _p->version; }

		internal RXCalloutData(void* calloutBlock) {
			_p = (pcre2_callout_block*)calloutBlock;
			Result = 0;
		}

		/// <summary>
		/// Callout number, eg 5 for <c>"(?C5)"</c>.
		/// More info in PCRE help topic <see href="https://www.pcre.org/current/doc/html/pcre2callout.html">pcre2callout</see>.
		/// </summary>
		public int callout_number => _p->callout_number;

		/// <summary>
		/// One more than the number of the highest numbered captured group so far.
		/// More info in PCRE help topic <see href="https://www.pcre.org/current/doc/html/pcre2callout.html">pcre2callout</see>.
		/// </summary>
		public int capture_top => _p->capture_top;

		/// <summary>
		/// The number of the most recently captured group.
		/// More info in PCRE help topic <see href="https://www.pcre.org/current/doc/html/pcre2callout.html">pcre2callout</see>.
		/// </summary>
		public int capture_last => _p->capture_last;

		/// <summary>
		/// Flags.
		/// 1 <c>PCRE2_CALLOUT_STARTMATCH</c>, 2 <c>PCRE2_CALLOUT_BACKTRACK</c>.
		/// More info in PCRE help topic <see href="https://www.pcre.org/current/doc/html/pcre2callout.html">pcre2callout</see>.
		/// </summary>
		public int callout_flags => _p->callout_flags;

		/// <summary>
		/// The offset within the subject string at which the current match attempt started. But depends on <c>\K</c> etc.
		/// More info in PCRE help topic <see href="https://www.pcre.org/current/doc/html/pcre2callout.html">pcre2callout</see>.
		/// </summary>
		public int start_match => (int)_p->start_match;

		/// <summary>
		/// The current offset within the subject string.
		/// </summary>
		public int current_position => (int)_p->current_position;

		/// <summary>
		/// The offset in the regular expression to the next item to be matched.
		/// </summary>
		public int pattern_position => (int)_p->pattern_position;

		/// <summary>
		/// The length of the next item to be processed in the regular expression.
		/// More info in PCRE help topic <see href="https://www.pcre.org/current/doc/html/pcre2callout.html">pcre2callout</see>.
		/// </summary>
		public int next_item_length => (int)_p->next_item_length;

		/// <summary>
		/// The callout string offset in the regular expression. Used with callouts like <c>"(?C'calloutString')"</c>.
		/// More info in PCRE help topic <see href="https://www.pcre.org/current/doc/html/pcre2callout.html">pcre2callout</see>.
		/// </summary>
		public int callout_string_offset => (int)_p->callout_string_offset;

		/// <summary>
		/// The callout string, eg <c>"xyz"</c> for <c>"(?C'xyz')"</c>.
		/// More info in PCRE help topic <see href="https://www.pcre.org/current/doc/html/pcre2callout.html">pcre2callout</see>.
		/// </summary>
		public string callout_string => _p->callout_string == null ? null : new string(_p->callout_string, 0, (int)_p->callout_string_length);

		/// <summary>
		/// The most recently passed <c>(*MARK)</c>, <c>(*PRUNE)</c>, or <c>(*THEN)</c> item in the match, or <c>null</c> if no such items have been passed.
		/// More info in PCRE help topic <see href="https://www.pcre.org/current/doc/html/pcre2callout.html">pcre2callout</see>.
		/// </summary>
		public string mark => _p->mark == null ? null : new string(_p->mark);

		/// <summary>
		/// Gets the start index and length of the specified group in the subject string.
		/// </summary>
		/// <param name="group">Group number (1-based index).</param>
		/// <exception cref="ArgumentOutOfRangeException"><i>group</i> must be > 0 and &lt; <see cref="capture_top"/>.</exception>
		public (int index, int length) Group(int group) {
			if (group <= 0 || group >= _p->capture_top) throw new ArgumentOutOfRangeException(nameof(group), "Must be > 0 and < capture_top.");
			var v = _p->vec;
			int i = (int)v[group *= 2];
			return (i, (int)v[group + 1] - i);
		}

		/// <summary>
		/// Gets the value (substring) of the specified group.
		/// </summary>
		/// <param name="group">Group number (1-based index).</param>
		/// <exception cref="ArgumentOutOfRangeException"><i>group</i> must be > 0 and &lt; <see cref="capture_top"/>.</exception>
		public string GroupValue(int group) {
			var (i, len) = Group(group);
			if (i < 0) return null;
			if (len == 0) return "";
			return new string(_p->subject, i, len);
		}

		/// <summary>
		/// Gets the start index and length of the most recently captured group in the subject string.
		/// </summary>
		public (int index, int length) LastGroup => Group(_p->capture_last);

		/// <summary>
		/// Gets the value (substring) of the most recently captured group.
		/// </summary>
		public string LastGroupValue => GroupValue(_p->capture_last);
	}

	#endregion

#pragma warning disable 1591 //no XML doc
	/// <summary>
	/// Flags for <see cref="regexp"/> constructor.
	/// Documented in PCRE help topic <see href="https://www.pcre.org/current/doc/html/pcre2api.html">pcre2api</see>.
	/// </summary>
	/// <remarks>
	/// Many options also can be specified in regular expression (RE):
	/// - These can be anywhere in RE: <c>(?i)</c> <c>CASELESS</c>, <c>(?m)</c> <c>MULTILINE</c>, <c>(?s)</c> <c>DOTALL</c>, <c>(?n)</c> <c>NO_AUTO_CAPTURE</c>, <c>(?x)</c> <c>EXTENDED</c>, <c>(?xx)</c> <c>EXTENDED_MORE</c>, <c>(?J)</c> <c>DUPNAMES</c>, <c>(?U)</c> <c>UNGREEDY</c>. Can be multiple, like <c>(?ms)</c>. Can be unset, like <c>(?-i)</c>. RE <c>"\Qtext\E"</c> is like RE <c>"text"</c> with flag <c>LITERAL</c>.
	/// - Instead of <c>ANCHORED</c> can be used <c>\G</c> at the start of RE. Or <c>^</c>, except in multiline mode.
	/// - Instead of <c>ENDANCHORED</c> can be used <c>\z</c> at the end of RE. Or <c>$</c>, except in multiline mode.
	/// - Flag UTF is implicitly added if RE contains non-ASCII characters and there is no flag <c>NEVER_UTF</c>.
	/// - These must be at the very start and are named like flags: <c>(*UTF)</c>, <c>(*UCP)</c>, <c>(*NOTEMPTY)</c>, <c>(*NOTEMPTY_ATSTART)</c>, <c>(*NO_AUTO_POSSESS)</c>, <c>(*NO_DOTSTAR_ANCHOR)</c>, <c>(*NO_START_OPT)</c>.
	/// - More info in <see href="https://www.pcre.org/current/doc/html/pcre2pattern.html">PCRE syntax reference</see>.
	/// 
	/// Some of <c>RXFlags</c> flags also exist in <see cref="RXMatchFlags"/>. You can set them either when calling <see cref="regexp"/> constructor or when calling <see cref="regexp"/> functions that have parameter <i>more</i>. You can use different flags for each function call with the same <see cref="regexp"/> variable.
	/// </remarks>
	[Flags]
	public enum RXFlags : ulong {
		/// <summary>Match only at the first position</summary>
		ANCHORED = 0x80000000,

		/// <summary>Pattern can match only at end of subject</summary>
		ENDANCHORED = 0x20000000,

		/// <summary>Do not check the pattern for UTF validity</summary>
		NO_UTF_CHECK = 0x40000000,

		/// <summary>Allow empty classes</summary>
		ALLOW_EMPTY_CLASS = 0x00000001,

		/// <summary>Alternative handling of <c>\u</c>, <c>\U</c>, and <c>\x</c></summary>
		ALT_BSUX = 0x00000002,

		/// <summary>Compile automatic callouts</summary>
		AUTO_CALLOUT = 0x00000004,

		/// <summary>Do caseless matching</summary>
		CASELESS = 0x00000008,

		/// <summary><c>$</c> not to match newline at end</summary>
		DOLLAR_ENDONLY = 0x00000010,

		/// <summary><c>.</c> matches anything including newlines</summary>
		DOTALL = 0x00000020,

		/// <summary>Allow duplicate names for subpatterns</summary>
		DUPNAMES = 0x00000040,

		/// <summary>Ignore white space and <c>#</c> comments</summary>
		EXTENDED = 0x00000080,

		/// <summary>Force matching to be before newline</summary>
		FIRSTLINE = 0x00000100,

		/// <summary>Match unset backreferences</summary>
		MATCH_UNSET_BACKREF = 0x00000200,

		/// <summary><c>^</c> and <c>$</c> match newlines within data</summary>
		MULTILINE = 0x00000400,

		/// <summary>Lock out <c>UCP</c>, e.g. via <c>(*UCP)</c></summary>
		NEVER_UCP = 0x00000800,

		/// <summary>Lock out <c>UTF</c>, e.g. via <c>(*UTF)</c></summary>
		NEVER_UTF = 0x00001000,

		/// <summary>Disable numbered capturing paren-theses (named ones available)</summary>
		NO_AUTO_CAPTURE = 0x00002000,

		/// <summary>Disable auto-possessification</summary>
		NO_AUTO_POSSESS = 0x00004000,

		/// <summary>Disable automatic anchoring for <c>.*</c></summary>
		NO_DOTSTAR_ANCHOR = 0x00008000,

		/// <summary>Disable match-time start optimizations</summary>
		NO_START_OPTIMIZE = 0x00010000,

		/// <summary>Use Unicode properties for <c>\d</c>, <c>\w</c>, etc</summary>
		UCP = 0x00020000,

		/// <summary>Invert greediness of quantifiers</summary>
		UNGREEDY = 0x00040000,

		/// <summary>
		/// Fully support Unicode text (case-insensitivity etc). More info in PCRE documentation topic <see href="https://www.pcre.org/current/doc/html/pcre2unicode.html">pcre2unicode</see>.
		/// This flag is implicitly added if regular expression contains non-ASCII characters and there is no flag <c>NEVER_UTF</c>.
		/// </summary>
		UTF = 0x00080000,

		/// <summary>Lock out the use of <c>\C</c> in patterns</summary>
		NEVER_BACKSLASH_C = 0x00100000,

		/// <summary>Alternative handling of <c>^</c> in multiline mode</summary>
		ALT_CIRCUMFLEX = 0x00200000,

		/// <summary>Process backslashes in verb names</summary>
		ALT_VERBNAMES = 0x00400000,

		//USE_OFFSET_LIMIT = 0x00800000, //used with pcre2_set_offset_limit(), but currently we don't support it

		/// <summary></summary>
		EXTENDED_MORE = 0x01000000,

		/// <summary>Pattern characters are all literal</summary>
		LITERAL = 0x02000000,

		/// <summary>Enable support for matching invalid UTF</summary>
		MATCH_INVALID_UTF = 0x04000000,

		/// <summary>Alternative extended character class syntax</summary>
		ALT_EXTENDED_CLASS = 0x08000000,

		//PCRE2_EXTRA_ flags.

		//EXTRA_ALLOW_SURROGATE_ESCAPES = 0x1L << 32, //not used with UTF-16
		//EXTRA_BAD_ESCAPE_IS_LITERAL = 0x2L << 32, //dangerous

		[EditorBrowsable(EditorBrowsableState.Never)] //bad name
		MATCH_WORD = 0x4L << 32,
		[EditorBrowsable(EditorBrowsableState.Never)] //bad name
		MATCH_LINE = 0x8L << 32,

		/// <summary>Pattern matches "words"</summary>
		EXTRA_MATCH_WORD = 0x4L << 32,

		/// <summary>Pattern matches whole lines</summary>
		EXTRA_MATCH_LINE = 0x8L << 32,

		//EXTRA_ALT_BSUX //noise
		//EXTRA_ALLOW_LOOKAROUND_BSK //fbc

		/// <summary>Disable mixed ASCII/non-ASCII case folding</summary>
		EXTRA_CASELESS_RESTRICT = 0x80L << 32,

		/// <summary><c>\d</c> remains ASCII in UCP mode</summary>
		EXTRA_ASCII_BSD = 0x100L << 32,

		/// <summary><c>\s</c> remains ASCII in UCP mode</summary>
		EXTRA_ASCII_BSS = 0x200L << 32,

		/// <summary><c>\w</c> remains ASCII in UCP mode</summary>
		EXTRA_ASCII_BSW = 0x400L << 32,

		/// <summary>POSIX classes remain ASCII in UCP mode</summary>
		EXTRA_ASCII_POSIX = 0x800L << 32,

		/// <summary><c>[:digit:]</c> and <c>[:xdigit:]</c> POSIX classes remain ASCII in UCP mode</summary>
		EXTRA_ASCII_DIGIT = 0x1000L << 32,

		/// <summary>Disallow callouts in pattern</summary>
		EXTRA_NEVER_CALLOUT = 0x8000L << 32,

		/// <summary>Use Turkish I case folding</summary>
		EXTRA_TURKISH_CASING = 0x10000L << 32,

		//EXTRA_PYTHON_OCTAL
		//EXTRA_NO_BS0 //rare

		//Match API flags. regexp ctor moves them to a field that later is combined with RXMatchFlags when calling the match API.

		/// <summary>Subject string is not the beginning of a line</summary>
		NOTBOL = 0x00000001L << 56, //hi byte of long

		/// <summary>Subject string is not the end of a line</summary>
		NOTEOL = 0x00000002L << 56,

		/// <summary>An empty string is not a valid match</summary>
		NOTEMPTY = 0x00000004L << 56,

		/// <summary>An empty string at the start of the subject is not a valid match</summary>
		NOTEMPTY_ATSTART = 0x00000008L << 56,

		/// <summary>Allow partial soft match. See <see cref="RXMatch.IsPartial"/>.</summary>
		PARTIAL_SOFT = 0x00000010L << 56,

		/// <summary>Allow partial hard match. See <see cref="RXMatch.IsPartial"/>.</summary>
		PARTIAL_HARD = 0x00000020L << 56,
	}

	/// <summary>
	/// Flags for <see cref="regexp"/> class functions.
	/// Documented in PCRE help topic <see href="https://www.pcre.org/current/doc/html/pcre2api.html">pcre2api</see>.
	/// </summary>
	/// <remarks>
	/// These flags also exist in <see cref="RXFlags"/> (<see cref="regexp"/> constructor flags). You can set them either when calling constructor or when calling other functions.
	/// </remarks>
	[Flags]
	public enum RXMatchFlags : uint {
		//These are the same as in RXFlags, and can be used either when compiling or when matching.

		/// <summary>Match only at the first position</summary>
		ANCHORED = 0x80000000,

		/// <summary>Pattern can match only at end of subject</summary>
		ENDANCHORED = 0x20000000,

		/// <summary>Do not check the subject for UTF validity</summary>
		NO_UTF_CHECK = 0x40000000,

		//These are only for matching. Also added to the hi int of RXFlags.

		/// <summary>Subject string is not the beginning of a line</summary>
		NOTBOL = 0x00000001,

		/// <summary>Subject string is not the end of a line</summary>
		NOTEOL = 0x00000002,

		/// <summary>An empty string is not a valid match</summary>
		NOTEMPTY = 0x00000004,

		/// <summary>An empty string at the start of the subject is not a valid match</summary>
		NOTEMPTY_ATSTART = 0x00000008,

		/// <summary>Allow partial soft match. See <see cref="RXMatch.IsPartial"/>.</summary>
		PARTIAL_SOFT = 0x00000010,

		/// <summary>Allow partial hard match. See <see cref="RXMatch.IsPartial"/>.</summary>
		PARTIAL_HARD = 0x00000020,

		//COPY_MATCHED_SUBJECT //this library does not use the PCRE API for wchich would need this
		//DISABLE_RECURSELOOP_CHECK //for PCRE testing
		//NO_JIT
	}
#pragma warning restore 1591

	internal static unsafe partial class Cpp {
		/// <summary>This and related API are documented in the C++ dll project.</summary>
		[DllImport("AuCpp.dll", CallingConvention = CallingConvention.Cdecl)]
		internal static extern nint Cpp_RegexCompile(string rx, nint len, RXFlags flags, out int codeSize, out BSTR errStr);

		[DllImport("AuCpp.dll", CallingConvention = CallingConvention.Cdecl)]
		internal static extern int Cpp_RegexDtor(IntPtr code);

		/// <summary>This and related API are documented in the C++ dll project.</summary>
		internal struct RegexMatch {
			public StartEnd* vec;
			public int vecCount;
			public int indexNoK;
			public char* mark;

			public string Mark => mark == null ? null : new(mark, 0, mark[-1]);
		}

		internal unsafe delegate int PcreCalloutT(void* calloutBlock, void* param);

		/// <summary>This and related API are documented in the C++ dll project.</summary>
		[DllImport("AuCpp.dll", CallingConvention = CallingConvention.Cdecl)]
		internal static extern int Cpp_RegexMatch(HandleRef code, char* s, nint len, nint start, RXMatchFlags flags,
			PcreCalloutT callout, out RegexMatch m, bool needM, out BSTR errStr);
		//note: don't use [MarshalAs(UnmanagedType.BStr)] out string errStr, it makes much slower.

		#region PCRE API

		//internal enum PCRE2_ERROR_
		//{
		//	PARTIAL = 0, //note: the PCRE API value is -2, but our C++ dll API then returns 0
		//	NOMATCH = -1,
		//	CALLOUT = -37,
		//	NOMEMORY = -48,
		//	NOUNIQUESUBSTRING = -50,
		//	//others not useful
		//}

		[DllImport("AuCpp.dll", CallingConvention = CallingConvention.Cdecl)]
		internal static extern int pcre2_pattern_info(HandleRef code, PCRE2_INFO_ what, void* where);

		[DllImport("AuCpp.dll", CallingConvention = CallingConvention.Cdecl)]
		internal static extern int pcre2_substring_nametable_scan(HandleRef code, char* name, ushort** first, ushort** last);

		internal enum PCRE2_INFO_ {
			ALLOPTIONS = 0,
			//ARGOPTIONS = 1,
			//BACKREFMAX = 2,
			//BSR = 3,
			CAPTURECOUNT = 4,
			//FIRSTCODEUNIT = 5,
			//FIRSTCODETYPE = 6,
			//FIRSTBITMAP = 7,
			//HASCRORLF = 8,
			//JCHANGED = 9,
			//JITSIZE = 10,
			//LASTCODEUNIT = 11,
			//LASTCODETYPE = 12,
			//MATCHEMPTY = 13,
			//MATCHLIMIT = 14,
			//MAXLOOKBEHIND = 15,
			//MINLENGTH = 16,
			//NAMECOUNT = 17,
			//NAMEENTRYSIZE = 18,
			//NAMETABLE = 19,
			//NEWLINE = 20,
			//DEPTHLIMIT = 21,
			//SIZE = 22,
			//HASBACKSLASHC = 23,
			//FRAMESIZE = 24,
			//HEAPLIMIT = 25,
		}

		#endregion
	}
}


================================================
FILE: Au/String/wildcard.cs
================================================
using System.Text.RegularExpressions;

namespace Au {
	/// <summary>
	/// Parses and compares [wildcard expression](xref:wildcard_expression).
	/// </summary>
	/// <remarks>
	/// Used in "find" functions. For example in <see cref="wnd.find"/> to compare window name, class name and program.
	/// The "find" function creates a <c>wildex</c> instance (which parses the wildcard expression), then calls <see cref="Match"/> for each item (eg window) to compare some its property text.
	/// </remarks>
	/// <example>
	/// <code><![CDATA[
	/// //This version does not support wildcard expressions.
	/// Document Find1(string name, string date) {
	/// 	return Documents.Find(x => x.Name.Eqi(name) && x.Date.Eqi(date));
	/// }
	/// 
	/// //This version supports wildcard expressions.
	/// //null-string arguments are not compared.
	/// Document Find2(string name, string date) {
	/// 	wildex n = name, d = date; //null if the string is null
	/// 	return Documents.Find(x => (n == null || n.Match(x.Name)) && (d == null || d.Match(x.Date)));
	/// }
	/// 
	/// //Example of calling such function.
	/// //Find item whose name is "example" (case-insensitive) and date starts with "2017-".
	/// var item = x.Find2("example", "2017-*");
	/// ]]></code>
	/// </example>
	public class wildex {
		//note: could be struct, but somehow then slower. Slower instance creation, calling methods, in all cases.
		
		readonly object _o; //string, regexp, Regex or wildex[]. Tested: getting string etc with '_o as string' is fast.
		readonly WXType _type;
		readonly bool _ignoreCase;
		readonly bool _not;
		
		/// <param name="wildcardExpression">
		/// [Wildcard expression](xref:wildcard_expression).
		/// Cannot be <c>null</c> (throws exception).
		/// <c>""</c> will match <c>""</c>.
		/// </param>
		/// <param name="matchCase">Case-sensitive even if there is no <c>**c</c>.</param>
		/// <param name="noException">If <i>wildcardExpression</i> is invalid, don't throw exception; let <see cref="Match(string)"/> always return <c>false</c>.</param>
		/// <exception cref="ArgumentNullException"></exception>
		/// <exception cref="ArgumentException">Invalid <c>"**options "</c> or regular expression.</exception>
		public wildex([ParamString(PSFormat.Wildex)] string wildcardExpression, bool matchCase = false, bool noException = false) {
			Not_.Null(wildcardExpression);
			var s = wildcardExpression;
			try {
				_type = WXType.Wildcard;
				_ignoreCase = !matchCase;
				string split = null;
				
				if (s is ['*', '*', _, ..]) {
					for (int i = 2, j; i < s.Length; i++) {
						switch (s[i]) {
						case ' ':
							s = s[(i + 1)..];
							goto g1;
						case 't' or 'r' or 'R' or 'm' when _type == WXType.Wildcard:
							_type = s[i] switch { 't' => WXType.Text, 'r' => WXType.RegexPcre, 'R' => WXType.RegexNet, _ => WXType.Multi };
							break;
						case 'c':
							_ignoreCase = false;
							break;
						case 'n':
							_not = true;
							break;
						case '(':
							if (s[i - 1] != 'm') goto ge;
							for (j = ++i; j < s.Length; j++) if (s[j] == ')') break;
							if (j == s.Length || j == i) goto ge;
							split = s[i..j];
							i = j;
							break;
						default: goto ge;
						}
					}
					ge:
					throw new ArgumentException("Invalid \"**options \" in wildcard expression.");
					g1:
					switch (_type) {
					case WXType.RegexNet:
						var ro = _ignoreCase ? (RegexOptions.IgnoreCase | RegexOptions.CultureInvariant) : RegexOptions.CultureInvariant;
						_o = new Regex(s, ro);
						return;
					case WXType.RegexPcre:
						_o = new regexp(s, _ignoreCase ? RXFlags.CASELESS : 0);
						return;
					case WXType.Multi:
						var a = s.Split(split ?? "||");
						var multi = new wildex[a.Length];
						for (int i = 0; i < a.Length; i++) multi[i] = new wildex(a[i], !_ignoreCase);
						_o = multi;
						return;
					}
				}
				
				if (_type == WXType.Wildcard && !hasWildcardChars(s)) _type = WXType.Text;
				_o = s;
			}
			catch when (noException) { _type = WXType.Error; }
		}
		
		/// <summary>
		/// Creates new <see cref="wildex"/> from wildcard expression string.
		/// If the string is <c>null</c>, returns <c>null</c>.
		/// </summary>
		/// <param name="wildcardExpression">[Wildcard expression](xref:wildcard_expression). </param>
		/// <exception cref="ArgumentException">Invalid <c>"**options "</c> or regular expression.</exception>
		public static implicit operator wildex([ParamString(PSFormat.Wildex)] string wildcardExpression) {
			if (wildcardExpression == null) return null;
			return new wildex(wildcardExpression);
		}
		
		//rejected: ReadOnlySpan<char>. Then cannot use eg .NET Regex.
		
		/// <summary>
		/// Compares a string with the [wildcard expression](xref:wildcard_expression) used to create this <see cref="wildex"/>. Returns <c>true</c> if they match.
		/// </summary>
		/// <param name="s">String. If <c>null</c>, returns <c>false</c>. If <c>""</c>, returns <c>true</c> if it was <c>""</c> or <c>"*"</c> or a regular expression that matches <c>""</c>.</param>
		public bool Match(string s) {
			if (s == null) return false;
			
			bool R = false;
			switch (_type) {
			case WXType.Wildcard:
				R = s.Like(_o as string, _ignoreCase);
				break;
			case WXType.Text:
				R = s.Eq(_o as string, _ignoreCase);
				break;
			case WXType.RegexPcre:
				R = (_o as regexp).IsMatch(s);
				break;
			case WXType.RegexNet:
				R = (_o as Regex).IsMatch(s);
				break;
			case WXType.Multi:
				var multi = _o as wildex[];
				//[n] parts: all must match (with their option n applied)
				int nNot = 0;
				for (int i = 0; i < multi.Length; i++) {
					var v = multi[i];
					if (v.Not) {
						if (!v.Match(s)) return _not; //!v.Match(s) means 'matches if without option n applied'
						nNot++;
					}
				}
				if (nNot == multi.Length) return !_not; //there are no parts without option n
				
				//non-[n] parts: at least one must match
				for (int i = 0; i < multi.Length; i++) {
					var v = multi[i];
					if (!v.Not && v.Match(s)) return !_not;
				}
				break;
			default: //Error
				return false;
			}
			return R ^ _not;
		}
		
		/// <summary>
		/// Returns the text or wildcard string.
		/// <c>null</c> if <see cref="TextType"/> is not <c>Text</c> or <c>Wildcard</c>.
		/// </summary>
		public string Text => _o as string;
		
		/// <summary>
		/// Returns the <see cref="regexp"/> object created from regular expression string.
		/// <c>null</c> if <see cref="TextType"/> is not <c>RegexPcre</c> (no option <c>r</c>).
		/// </summary>
		public regexp RegexPcre => _o as regexp;
		
		/// <summary>
		/// Gets the <c>Regex</c> object created from regular expression string.
		/// <c>null</c> if <see cref="TextType"/> is not <c>RegexNet</c> (no option <c>R</c>).
		/// </summary>
		public Regex RegexNet => _o as Regex;
		
		/// <summary>
		/// Array of <see cref="wildex"/> variables, one for each part in multi-part text.
		/// <c>null</c> if <see cref="TextType"/> is not <c>Multi</c> (no option <c>m</c>).
		/// </summary>
		public wildex[] MultiArray => _o as wildex[];
		
		/// <summary>
		/// Gets the type of text (wildcard, regex, etc).
		/// </summary>
		public WXType TextType => _type;
		
		/// <summary>
		/// Is case-insensitive?
		/// </summary>
		public bool IgnoreCase => _ignoreCase;
		
		/// <summary>
		/// Has option <c>n</c>?
		/// </summary>
		public bool Not => _not;
		
		///
		public override string ToString() {
			return _o?.ToString();
		}
		
		/// <summary>
		/// Returns <c>true</c> if string contains wildcard characters: <c>'*'</c>, <c>'?'</c>.
		/// </summary>
		/// <param name="s">Can be <c>null</c>.</param>
		public static bool hasWildcardChars(RStr s) {
			foreach (var c in s) if (c is '*' or '?') return true;
			return false;
		}
	}
}

namespace Au.Types {
	public static unsafe partial class ExtString {
		#region Like
		
		/// <summary>
		/// Compares this string with a string that possibly contains wildcard characters.
		/// Returns <c>true</c> if the strings match.
		/// </summary>
		/// <param name="t">This string. If <c>null</c>, returns <c>false</c>. If <c>""</c>, returns <c>true</c> if <i>pattern</i> is <c>""</c> or <c>"*"</c>.</param>
		/// <param name="pattern">String that possibly contains wildcard characters. Cannot be <c>null</c>. If <c>""</c>, returns <c>true</c> if this string is <c>""</c>. If <c>"*"</c>, always returns <c>true</c> except when this string is <c>null</c>.</param>
		/// <param name="ignoreCase">Case-insensitive.</param>
		/// <exception cref="ArgumentNullException"><i>pattern</i> is <c>null</c>.</exception>
		/// <remarks>
		/// Wildcard characters:
		/// 
		/// | Character | Will match | Examples
		/// | -
		/// | <c>*</c> | Zero or more of any characters. | <c>"start*"</c>, <c>"*end"</c>, <c>"*middle*"</c>
		/// | <c>?</c> | Any single character. | <c>"date ????-??-??"</c>
		/// 
		/// There are no escape sequences for <c>*</c> and <c>?</c> characters.
		/// 
		/// Uses ordinal comparison, ie does not depend on current culture.
		/// 
		/// See also: [wildcard expression](xref:wildcard_expression).
		/// </remarks>
		/// <example>
		/// <code><![CDATA[
		/// string s = @"C:\abc\mno.xyz";
		/// if(s.Like(@"C:\abc\mno.xyz")) print.it("matches whole text (no wildcard characters)");
		/// if(s.Like(@"C:\abc\*")) print.it("starts with");
		/// if(s.Like(@"*.xyz")) print.it("ends with");
		/// if(s.Like(@"*mno*")) print.it("contains");
		/// if(s.Like(@"C:\*.xyz")) print.it("starts and ends with");
		/// if(s.Like(@"?:*")) print.it("any character, : and possibly more text");
		/// ]]></code>
		/// </example>
		/// <seealso cref="wildex"/>
#if false //somehow speed depends on dll version. With some versions same as C# code, with some slower. Also depends on string. With shortest strings 50% slower.
		public static bool Like(this string t, string pattern, bool ignoreCase = false)
		{
			if(t == null) return false;
			fixed (char* pt = t, pw = pattern)
				return Cpp.Cpp_StringLike(pt, t.Length, pw, pattern.Length, ignoreCase);
		}
#else
		[MethodImpl(MethodImplOptions.AggressiveOptimization)]
		public static bool Like(this string t, string pattern, bool ignoreCase = false) {
			Not_.Null(pattern);
			int patLen = pattern.Length;
			if (t == null) return false;
			if (patLen == 0) return t.Length == 0;
			if (patLen == 1 && pattern[0] == '*') return true;
			if (t.Length == 0) return false;
			
			fixed (char* str = t, pat = pattern) {
				return _WildcardCmp(str, pat, t.Length, patLen, ignoreCase ? Tables_.LowerCase : null);
			}
			
			//Microsoft.VisualBasic.CompilerServices.Operators.LikeString() supports more wildcard characters etc. Depends on current culture, has bugs, slower 6-250 times.
			//System.IO.Enumeration.FileSystemName.MatchesSimpleExpression supports \escaping. Slower 2 - 100 times.
		}
		
		/// <inheritdoc cref="Like(string, string, bool)" path="//summary|//param|//exception"/>
		[MethodImpl(MethodImplOptions.AggressiveOptimization)]
		public static bool Like(this RStr t, string pattern, bool ignoreCase = false) {
			Not_.Null(pattern);
			int patLen = pattern.Length;
			if (patLen == 0) return t.Length == 0;
			if (patLen == 1 && pattern[0] == '*') return true;
			if (t.Length == 0) return false;
			
			fixed (char* str = t, pat = pattern) {
				return _WildcardCmp(str, pat, t.Length, patLen, ignoreCase ? Tables_.LowerCase : null);
			}
			
			//Microsoft.VisualBasic.CompilerServices.Operators.LikeString() supports more wildcard characters etc. Depends on current culture, has bugs, slower 6-250 times.
			//System.IO.Enumeration.FileSystemName.MatchesSimpleExpression supports \escaping. Slower 2 - 100 times.
		}
		
		[MethodImpl(MethodImplOptions.AggressiveOptimization)]
		static bool _WildcardCmp(char* s, char* w, int lenS, int lenW, char* table) {
			char* se = s + lenS, we = w + lenW;
			
			//find '*' from start. Makes faster in some cases.
			for (; w < we && s < se; w++, s++) {
				char cS = s[0], cW = w[0];
				if (cW == '*') goto g1;
				if (cW == cS || cW == '?') continue;
				if ((table == null) || (table[cW] != table[cS])) return false;
			}
			if (w == we) return s == se; //w ended?
			goto gr; //s ended
			g1:
			
			//find '*' from end. Makes "*text" much faster.
			for (; we > w && se > s; we--, se--) {
				char cS = se[-1], cW = we[-1];
				if (cW == '*') break;
				if (cW == cS || cW == '?') continue;
				if ((table == null) || (table[cW] != table[cS])) return false;
			}
			
			//Algorithm by Alessandro Felice Cantatore, http://xoomer.virgilio.it/acantato/dev/wildcard/wildmatch.html
			//Changes: supports '\0' in string; case-sensitive or not; restructured, in many cases faster.
			
			int i = 0;
			gStar: //info: goto used because C# compiler makes the loop faster when it contains less code
			w += i + 1;
			if (w == we) return true;
			s += i;
			
			for (i = 0; s + i < se; i++) {
				char sW = w[i];
				if (sW == '*') goto gStar;
				if (sW == s[i] || sW == '?') continue;
				if ((table != null) && (table[sW] == table[s[i]])) continue;
				s++; i = -1;
			}
			
			w += i;
			gr:
			while (w < we && *w == '*') w++;
			return w == we;
			
			//info: Could implement escape sequence ** for * and maybe *? for ?.
			//	But it makes code slower etc.
			//	Not so important.
			//	Most users would not know about it.
			//	Usually can use ? for literal * and ?.
			//	Usually can use regular expression if need such precision.
			//	Then cannot use "**options " for wildcard expressions.
			//	Could use other escape sequences, eg [*], [?] and [[], but it makes slower and is more harmful than useful.
			
			//The first two loops are fast, but Eq much faster when !ignoreCase. We cannot use such optimizations that it can.
			//The slowest case is "*substring*", because then the first two loops don't help.
			//	Then similar speed as string.IndexOf(ordinal) and API <ms>FindStringOrdinal</ms>.
			//	Possible optimization, but need to add much code, and makes not much faster, and makes other cases slower, difficult to avoid it.
		}
#endif
		
		/// <summary>
		/// Calls <see cref="Like(string, string, bool)"/> for each wildcard pattern specified in the argument list until it returns <c>true</c>.
		/// Returns 1-based index of the matching pattern, or 0 if none.
		/// </summary>
		/// <param name="t"></param>
		/// <param name="ignoreCase">Case-insensitive.</param>
		/// <param name="patterns">One or more wildcard strings. The strings cannot be <c>null</c>.</param>
		/// <exception cref="ArgumentNullException">A string in <i>patterns</i> is <c>null</c>.</exception>
		public static int Like(this string t, bool ignoreCase = false, params ReadOnlySpan<string> patterns) {
			for (int i = 0; i < patterns.Length; i++) if (t.Like(patterns[i], ignoreCase)) return i + 1;
			return 0;
		}
		
		#endregion Like
	}
	
	//rejected: struct WildexStruct - struct version of wildex class. Moved to the Unused project.
	//	Does not make faster, although in most cases creates less garbage.
	
	/// <summary>
	/// The type of text (wildcard expression) of a <see cref="wildex"/> variable.
	/// </summary>
	public enum WXType : byte {
		/// <summary>
		/// Simple text (option <c>t</c>, or no <c>*?</c> characters and no <c>t</c>, <c>r</c>, <c>R</c> options).
		/// </summary>
		Text,
		
		/// <summary>
		/// Wildcard (has <c>*?</c> characters and no <c>t</c>, <c>r</c>, <c>R</c> options).
		/// <see cref="wildex.Match"/> calls <see cref="ExtString.Like(string, string, bool)"/>.
		/// </summary>
		Wildcard,
		
		/// <summary>
		/// PCRE regular expression (option <c>r</c>).
		/// <see cref="wildex.Match"/> calls <see cref="regexp.IsMatch"/>.
		/// </summary>
		RegexPcre,
		
		/// <summary>
		/// .NET regular expression (option <c>R</c>).
		/// <see cref="wildex.Match"/> calls <see cref="Regex.IsMatch(string)"/>.
		/// </summary>
		RegexNet,
		
		/// <summary>
		/// Multiple parts (option <c>m</c>).
		/// <see cref="wildex.Match"/> calls <c>Match</c> for each part (see <see cref="wildex.MultiArray"/>) and returns <c>true</c> if all negative (option <c>n</c>) parts return <c>true</c> (or there are no such parts) and some positive (no option <c>n</c>) part returns <c>true</c> (or there are no such parts).
		/// If you want to implement a different logic, call <c>Match</c> for each <see cref="wildex.MultiArray"/> element (instead of calling <c>Match</c> for this variable).
		/// </summary>
		Multi,
		
		/// <summary>
		/// The regular expression was invalid, and parameter <i>noException</i> <c>true</c>.
		/// </summary>
		Error,
	}
}


================================================
FILE: Au/System/CpuUsage.cs
================================================
namespace Au.More;

/// <summary>
/// Gets CPU usage.
/// </summary>
/// <remarks>
/// You can use the static functions (easier) or a <c>CpuUsage</c> instance. A <c>CpuUsage</c> instance must be disposed (use <c>using</c>).
/// </remarks>
/// <example>
/// <code><![CDATA[
/// using var u = new CpuUsage(); //all processes
/// //using var u = new CpuUsage(process.getProcessId("Au.Editor.exe")); //single process
/// //using var u = new CpuUsage(process.getProcessIds("chrome.exe")); //all Chrome processes
/// for (; ; ) {
/// 	if (!u.Start()) break;
/// 	Thread.Sleep(500);
/// 	print.it(u.Stop());
/// }
/// ]]></code>
/// </example>
public sealed class CpuUsage : IDisposable {
	bool _ofProcess, _started;
	Handle_ _ph;
	Handle_[] _aph;
	long _mcs, _cycles;
	
	/// <summary>
	/// Use this constructor to get CPU usage of all processes (sum).
	/// </summary>
	public CpuUsage() {
		
	}
	
	/// <summary>
	/// Use this constructor to get CPU usage of a process.
	/// </summary>
	/// <param name="processId">Process id.</param>
	public CpuUsage(int processId) {
		_ofProcess = true;
		_ph = Handle_.OpenProcess(processId);
	}
	
	/// <summary>
	/// Use this constructor to get CPU usage of multiple processes (sum).
	/// </summary>
	/// <param name="processes">Process ids.</param>
	public CpuUsage(IEnumerable<int> processes) {
		_ofProcess = true;
		_aph = processes.Select(o => Handle_.OpenProcess(o)).Where(o => !o.Is0).ToArray();
		if (_aph.Length == 0) _aph = null;
	}
	
	///
	public void Dispose() {
		if (_ofProcess) {
			if (_aph == null) _ph.Dispose();
			else for (int i = 0; i < _aph.Length; i++) _aph[i].Dispose();
		}
		GC.SuppressFinalize(this);
	}
	
	///
	~CpuUsage() { Dispose(); }
	
	/// <summary>
	/// Starts measuring CPU usage.
	/// </summary>
	/// <returns><c>false</c> if <i>processId</i> is invalid.</returns>
	public bool Start() {
		_started = _GetCycles(out _cycles);
		_mcs = perf.mcs;
		return _started;
	}
	
	/// <summary>
	/// Ends measuring CPU usage, and gets result.
	/// Call this after calling <see cref="Start"/> and waiting at least 1 ms. Don't call if <c>Start</c> returned <c>false</c>.
	/// </summary>
	/// <returns>CPU usage 0 to 100 %.</returns>
	/// <exception cref="InvalidOperationException">Called without successful <see cref="Start"/>.</exception>
	public double Stop() {
		if (!_started) throw new InvalidOperationException();
		_started = false;
		
		if (!_GetCycles(out var cycles)) return 0;
		long mcs = perf.mcs - _mcs;
		
		var r = (cycles - _cycles) / _CyclesMcs() / mcs;
		Debug_.PrintIf(r > 1.1);
		r = Math.Min(r, 1);
		r = _ofProcess ? r : 1 - r;
		return Math.Round(r * 100, 2);
	}
	
	bool _GetCycles(out long r) {
		if (!_ofProcess) { r = _QIPCT(); return true; }
		
		if (_aph == null) return Api.QueryProcessCycleTime(_ph, out r); //tested: succeeds and gets cycles even if the process ended, if handle is valid
		
		r = 0;
		for (int i = _aph.Length; --i >= 0;) {
			Api.QueryProcessCycleTime(_aph[i], out var v);
			r += v;
		}
		return true;
		
		[SkipLocalsInit]
		static unsafe long _QIPCT() {
			var a = stackalloc long[64];
			long r = 0;
			for (ushort g = 0, ng = Api.GetActiveProcessorGroupCount(); g < ng; g++) {
				int size = 64 * 8;
				Api.QueryIdleProcessorCycleTimeEx(g, ref size, a);
				for (int i = 0; i < size / 8; i++) r += a[i];
			}
			return r;
		}
	}
	
	//Gets CPU cycles / microsecond * CPU count.
	static double _CyclesMcs() {
		if (s_cycles.timeMeasured == 0) { //JIT-compile
			_ = perf.mcs;
		}
		
		if (Environment.TickCount64 != s_cycles.timeMeasured) {
			nint th = process.thisThreadHandle;
			int tp0 = Api.GetThreadPriority(th);
			Api.SetThreadPriority(th, Api.THREAD_PRIORITY_TIME_CRITICAL);
			try {
				int nCpu = ProcessorCount;
				double r = 0;
				for (int i = 0; i < 3; i++) {
					Api.QueryThreadCycleTime(th, out long t1);
					long mcs = perf.mcs;
					while (perf.mcs < mcs + 300) { }
					Api.QueryThreadCycleTime(th, out long t2);
					mcs = perf.mcs - mcs;
					var v = (double)(t2 - t1) * nCpu / mcs;
					//if(i>0 && Math.Abs(v-r)>1000) print.it($"<><c red>{r}, {v}, {v-r}<>");
					if (v > r) r = v;
				}
				//if (Math.Abs(22436 - r) > 1000) print.it($"<><c red>cycles={r}<>"); //else print.it($"cycles={r}");
				s_cycles = (Environment.TickCount64, r);
			}
			finally { Api.SetThreadPriority(th, tp0); }
		}
		return s_cycles.result;
		
		//To avoid incorrect result when this thread interrupted etc, this func measures 3 times and gets max result. Also sets max thread priority.
	}
	static (long timeMeasured, double result) s_cycles;
	
	/// <summary>
	/// Gets CPU usage of all processes (sum).
	/// </summary>
	/// <param name="duration">How long to measure, milliseconds. Default 10. Min 1. Calls <c>Thread.Sleep(duration);</c>.</param>
	/// <returns>CPU usage 0 to 100 %.</returns>
	public static unsafe double OfAllProcesses(int duration = 10) {
		ArgumentOutOfRangeException.ThrowIfLessThan(duration, 1);
		using var u = new CpuUsage();
		u.Start();
		Thread.Sleep(duration);
		return u.Stop();
	}
	
	/// <summary>
	/// Gets CPU usage of a process.
	/// </summary>
	/// <param name="processId">Process id.</param>
	/// <param name="duration">How long to measure, milliseconds. Default 10. Min 1. Calls <c>Thread.Sleep(duration);</c>.</param>
	/// <returns>CPU usage 0 to 100 %. Returns 0 if <i>processId</i> invalid.</returns>
	public static double OfProcess(int processId, int duration = 10) {
		ArgumentOutOfRangeException.ThrowIfLessThan(duration, 1);
		using var u = new CpuUsage(processId);
		if (!u.Start()) return 0;
		Thread.Sleep(duration);
		return u.Stop();
	}
	
	/// <summary>
	/// Gets CPU usage of multiple processes (sum).
	/// </summary>
	/// <param name="processes">Process ids.</param>
	/// <param name="duration">How long to measure, milliseconds. Default 10. Min 1. Calls <c>Thread.Sleep(duration);</c>.</param>
	/// <returns>CPU usage 0 to 100 %. Returns 0 if all ids invalid.</returns>
	public static double OfProcesses(IEnumerable<int> processes, int duration = 10) {
		ArgumentOutOfRangeException.ThrowIfLessThan(duration, 1);
		using var u = new CpuUsage(processes);
		if (!u.Start()) return 0;
		Thread.Sleep(duration);
		return u.Stop();
	}
	
	/// <summary>
	/// Get the number of logical CPU in the system.
	/// </summary>
	/// <remarks>
	/// Unlike <see cref="Environment.ProcessorCount"/>, does not depend on process affinity etc.
	/// </remarks>
	public static unsafe int ProcessorCount {
		get {
			int r = 0;
			for (ushort g = 0, ng = Api.GetActiveProcessorGroupCount(); g < ng; g++) {
				int n = 0;
				Api.QueryIdleProcessorCycleTimeEx(g, ref n, null);
				r += n / 8;
			}
			return r;
		}
	}
}


================================================
FILE: Au/System/ProcessMemory.cs
================================================
namespace Au.More;

/// <summary>
/// Allocates, writes and reads memory in other process.
/// </summary>
/// <remarks>
/// Must be disposed. Example: <c>using(var pm=new ProcessMemory(...)) { ... }</c>.
/// </remarks>
public unsafe class ProcessMemory : IDisposable {
	Handle_ _hproc;
	HandleRef _HprocHR => new(this, _hproc);
	
	///
	protected virtual void Dispose(bool disposing) {
		if (_hproc.Is0) return;
		if (MemAllocated != default) {
			var mem = MemAllocated; MemAllocated = default;
			if (!Api.VirtualFreeEx(_HprocHR, mem)) print.warning("Failed to free process memory. " + lastError.message);
		}
		Mem = default;
		_hproc.Dispose();
	}
	
	///
	public void Dispose() {
		Dispose(true);
		GC.SuppressFinalize(this);
	}
	
	///
	~ProcessMemory() => Dispose(false);
	
	/// <summary>
	/// Process handle.
	/// Opened with access <c>PROCESS_VM_OPERATION | PROCESS_VM_READ | PROCESS_VM_WRITE</c>.
	/// </summary>
	public IntPtr ProcessHandle => _hproc;
	
	/// <summary>
	/// Address in that process used by the read and write functions.
	/// </summary>
	/// <remarks>
	/// Most read/write functions of this class don't have a parameter "address in that process". Instead they use <c>Mem</c>, which initially is == <see cref="MemAllocated"/>. But you can set <c>Mem</c> = any valid address in that process; usually you do it when no memory is allocated by the constructor (<i>nBytes</i> 0).
	/// The address is invalid in this process.
	/// </remarks>
	public IntPtr Mem { get; set; }
	
	/// <summary>
	/// Address of memory allocated in that process.
	/// </summary>
	/// <remarks>
	/// The constructor allocates memory with API <ms>VirtualAllocEx</ms> if <i>nBytes</i> != 0. Finally <c>Dispose</c> will free it with API <ms>VirtualFreeEx</ms>.
	/// The setter normally isn't used; if you set <c>MemAllocated = default</c>, <c>Dispose</c> will not free the memory.
	/// The address is invalid in this process.
	/// </remarks>
	public IntPtr MemAllocated { get; set; }
	
	void _Alloc(int pid, wnd w, int nBytes, bool noException) {
		string err;
		const uint fl = Api.PROCESS_VM_OPERATION | Api.PROCESS_VM_READ | Api.PROCESS_VM_WRITE;
		_hproc = w.Is0 ? Handle_.OpenProcess(pid, fl) : Handle_.OpenProcess(w, fl);
		if (_hproc.Is0) { err = "Failed to open process handle."; goto ge; }
		
		if (nBytes != 0) {
			Mem = MemAllocated = Api.VirtualAllocEx(_HprocHR, default, nBytes);
			if (MemAllocated == default) { err = "Failed to allocate process memory."; goto ge; }
		}
		return;
		ge:
		if (noException) Dispose();
		else {
			var e = new AuException(0, err);
			Dispose();
			throw e;
		}
	}
	
	/// <summary>
	/// Opens process handle and optionally allocates memory in that process.
	/// </summary>
	/// <param name="processId">Process id.</param>
	/// <param name="nBytes">If not 0, allocates memory of this size in that process.</param>
	/// <param name="noException">Don't throw exceptions. If failed, sets <see cref="ProcessHandle"/> = default.</param>
	/// <exception cref="AuException">Failed to open process handle (usually because of [](xref:uac)) or allocate memory.</exception>
	public ProcessMemory(int processId, int nBytes, bool noException = false) {
		_Alloc(processId, default, nBytes, noException);
	}
	
	/// <summary>
	/// Opens process handle and optionally allocates memory in that process.
	/// </summary>
	/// <param name="w">A window of that process.</param>
	/// <param name="nBytes">If not 0, allocates memory of this size in that process.</param>
	/// <param name="noException">Don't throw exceptions. If failed, sets <see cref="ProcessHandle"/> = default.</param>
	/// <exception cref="AuWndException"><i>w</i> invalid.</exception>
	/// <exception cref="AuException">Failed to open process handle or allocate memory.</exception>
	public ProcessMemory(wnd w, int nBytes, bool noException = false) {
		if (!noException) w.ThrowIfInvalid();
		_Alloc(0, w, nBytes, noException);
	}
	
	/// <summary>
	/// Copies a string from this process to that process (memory address <see cref="Mem"/>).
	/// In that process writes the string as <c>'\0'</c>-terminated <c>char</c> string (UTF-16).
	/// </summary>
	/// <returns><c>false</c> if failed.</returns>
	/// <param name="s">A string in this process.</param>
	/// <param name="offsetBytes">Offset in <see cref="Mem"/>.</param>
	/// <remarks>
	/// In that process is used <c>(s.Length+1)*2</c> bytes of memory (+1 for the <c>'\0'</c>, <c>*</c> 2 because UTF-16 character size is 2 bytes).
	/// </remarks>
	public bool WriteCharString(string s, int offsetBytes = 0) {
		if (Mem == default) return false;
		if (s.NE()) return true;
		fixed (char* p = s) {
			return Api.WriteProcessMemory(_HprocHR, Mem + offsetBytes, p, (s.Length + 1) * 2, null);
		}
	}
	
	/// <summary>
	/// Copies a string from this process to that process (memory address <see cref="Mem"/>).
	/// In that process writes the string as <c>'\0'</c>-terminated <c>byte</c> string.
	/// </summary>
	/// <returns><c>false</c> if failed.</returns>
	/// <param name="s">A string in this process. Normal C# string (UTF-16).</param>
	/// <param name="offsetBytes">Offset in <see cref="Mem"/>.</param>
	/// <param name="enc">Encoding for converting <c>char</c> string to <c>byte</c> string. If <c>null</c>, uses <see cref="Encoding.Default"/> (UTF-8).</param>
	public bool WriteByteString(string s, int offsetBytes = 0, Encoding enc = null) {
		if (Mem == default) return false;
		if (s.NE()) return true;
		enc ??= Encoding.Default;
		var a = enc.GetBytes(s).InsertAt(-1);
		fixed (byte* p = a) {
			return Api.WriteProcessMemory(_HprocHR, Mem + offsetBytes, p, a.Length, null);
		}
	}
	
	[SkipLocalsInit]
	string _ReadString(bool ansiString, int nChars, int offsetBytes, bool findLength, Encoding enc = null) {
		if (Mem == default) return null;
		int n = nChars + 1; if (!ansiString) n *= 2; //bytes with '\0'
		using FastBuffer<byte> b = new(n);
		if (!Api.ReadProcessMemory(_HprocHR, Mem + offsetBytes, b.p, n, null)) return null;
		if (findLength) nChars = ansiString ? Ptr_.Length(b.p, nChars) : Ptr_.Length((char*)b.p, nChars);
		enc ??= Encoding.Default;
		return ansiString ? new((sbyte*)b.p, 0, nChars, enc) : new((char*)b.p, 0, nChars);
	}
	
	/// <summary>
	/// Copies a <c>char</c> string from that process (memory address <see cref="Mem"/>) to this process.
	/// In that process the string must be in Unicode UTF-16 format.
	/// </summary>
	/// <returns>The copied string, or <c>null</c> if failed.</returns>
	/// <param name="length">Number of characters to copy, not including the terminating <c>'\0'</c>. In both processes a character is 2 bytes.</param>
	/// <param name="offsetBytes">Offset in <see cref="Mem"/>.</param>
	/// <param name="findLength">Find string length by searching for <c>'\0'</c> character in <i>length</i> range. If <c>false</c>, the returned string is of <i>length</i> length even if contains <c>'\0'</c> characters.</param>
	public string ReadCharString(int length, int offsetBytes = 0, bool findLength = false) {
		return _ReadString(false, length, offsetBytes, findLength);
	}
	
	/// <summary>
	/// Copies a <c>byte</c> string from that process (memory address <see cref="Mem"/>) to this process.
	/// In that process the string must be array of bytes (not Unicode UTF-16).
	/// </summary>
	/// <returns>The copied string, or <c>null</c> if failed.</returns>
	/// <param name="length">Number bytes to copy, not including the terminating <c>'\0'</c>. In that process a character is 1 or more bytes (depending on encoding). In this process will be 2 bytes (normal C# string).</param>
	/// <param name="offsetBytes">Offset in <see cref="Mem"/>.</param>
	/// <param name="findLength">Find string length by searching for <c>'\0'</c> character in <i>length</i> range.</param>
	/// <param name="enc">Encoding for converting <c>byte</c> string to <c>char</c> string. If <c>null</c>, uses <see cref="Encoding.Default"/> (UTF-8).</param>
	public string ReadByteString(int length, int offsetBytes = 0, bool findLength = false, Encoding enc = null) {
		return _ReadString(true, length, offsetBytes, findLength, enc);
	}
	
	/// <summary>
	/// Copies memory from this process to that process (memory address <see cref="Mem"/>).
	/// </summary>
	/// <returns><c>false</c> if failed.</returns>
	/// <param name="ptrFrom">Address of memory in this process.</param>
	/// <param name="nBytes">Number of bytes to copy.</param>
	/// <param name="offsetBytes">Offset in <see cref="Mem"/>.</param>
	public bool Write(void* ptrFrom, int nBytes, int offsetBytes = 0) {
		if (Mem == default) return false;
		return Api.WriteProcessMemory(_HprocHR, Mem + offsetBytes, ptrFrom, nBytes, null);
	}
	
	/// <summary>
	/// Copies memory from this process to a known address in that process.
	/// </summary>
	/// <returns><c>false</c> if failed.</returns>
	/// <param name="ptrTo">Address of memory in that process.</param>
	/// <param name="ptrFrom">Address of memory in this process.</param>
	/// <param name="nBytes">Number of bytes to copy.</param>
	public bool Write(IntPtr ptrTo, void* ptrFrom, int nBytes) {
		return Api.WriteProcessMemory(_HprocHR, ptrTo, ptrFrom, nBytes, null);
	}
	
	/// <summary>
	/// Copies memory from that process (memory address <see cref="Mem"/>) to this process.
	/// </summary>
	/// <returns><c>false</c> if failed.</returns>
	/// <param name="ptrTo">Address of memory in this process.</param>
	/// <param name="nBytes">Number of bytes to copy.</param>
	/// <param name="offsetBytes">Offset in <see cref="Mem"/>.</param>
	public bool Read(void* ptrTo, int nBytes, int offsetBytes = 0) {
		if (Mem == default) return false;
		return Api.ReadProcessMemory(_HprocHR, Mem + offsetBytes, ptrTo, nBytes, null);
	}
	
	/// <summary>
	/// Copies memory from a known address in that process to this process.
	/// </summary>
	/// <returns><c>false</c> if failed.</returns>
	/// <param name="ptrFrom">Address of memory in that process.</param>
	/// <param name="ptrTo">Address of memory in this process.</param>
	/// <param name="nBytes">Number of bytes to copy.</param>
	public bool Read(IntPtr ptrFrom, void* ptrTo, int nBytes) {
		return Api.ReadProcessMemory(_HprocHR, ptrFrom, ptrTo, nBytes, null);
	}
}


================================================
FILE: Au/System/computer.cs
================================================
//FUTURE: GetCpuUsage.

using Microsoft.Win32;

namespace Au {
	/// <summary>
	/// Computer shutdown etc.
	/// </summary>
	public static unsafe class computer {
		/// <summary>
		/// Gets the number of milliseconds elapsed since Windows startup, not including the time when the computer sleeps or hibernates.
		/// To get time with sleep, use <see cref="Environment.TickCount64"/>.
		/// </summary>
		/// <remarks>
		/// Uses API <ms>QueryUnbiasedInterruptTime</ms>.
		/// Uses the low-resolution system timer. Its period usually is 15.25 ms.
		/// Independent of computer clock time changes.
		/// </remarks>
		public static long tickCountWithoutSleep {
			get {
				if (!Api.QueryUnbiasedInterruptTime(out long t)) return Api.GetTickCount64();
				return t / 10000;
			}
		}

		//public static void setTime(DateTime time) {

		//}

		/// <summary>
		/// Initiates computer shutdown or restart operation.
		/// </summary>
		/// <returns><c>false</c> if failed. Supports <see cref="lastError"/>.</returns>
		/// <param name="restart">Reboot.</param>
		/// <param name="force">Don't allow to cancel. Applications with unsaved changes will be forcibly closed.</param>
		/// <param name="timeoutS">The length of time to display the shutdown dialog box, in seconds.</param>
		/// <param name="message">Display this text in the shutdown dialog box and write to the event log.</param>
		/// <param name="computer">The network name of the computer to be shut down. If <c>null</c> (default), shuts down this computer. If used, this process must be admin.</param>
		/// <remarks>
		/// Calls API <ms>InitiateSystemShutdown</ms>.
		/// </remarks>
		public static bool shutdown(bool restart = false, bool force = false, int timeoutS = 0, string message = null, string computer = null) {
			SecurityUtil.SetPrivilege("SeShutdownPrivilege", true);
			if (!computer.NE()) SecurityUtil.SetPrivilege("SeRemoteShutdownPrivilege", true, computer);
			return Api.InitiateSystemShutdown(computer, message, timeoutS, force, restart);
		}

		/// <summary>
		/// Initiates computer shutdown or restart operation.
		/// </summary>
		/// <returns><c>false</c> if failed. Supports <see cref="lastError"/>.</returns>
		/// <param name="flags"><ms>ExitWindowsEx</ms> parameter <i>uFlags</i>.</param>
		/// <param name="reason"><ms>ExitWindowsEx</ms> parameter <i>dwReason</i>.</param>
		/// <remarks>
		/// Calls API <ms>ExitWindowsEx</ms>.
		/// </remarks>
		public static bool shutdown(int flags, uint reason = 0) {
			SecurityUtil.SetPrivilege("SeShutdownPrivilege", true);
			return Api.ExitWindowsEx(flags, reason);
		}

		/// <summary>
		/// Initiates computer logoff (sign out) operation.
		/// </summary>
		/// <returns><c>false</c> if failed. Supports <see cref="lastError"/>.</returns>
		/// <param name="force">Don't allow to cancel. Applications with unsaved changes will be forcibly closed.</param>
		public static bool logoff(bool force = false) {
			SecurityUtil.SetPrivilege("SeShutdownPrivilege", true);
			return Api.ExitWindowsEx(force ? 4 : 16, 0);
		}

		/// <summary>
		/// Computer sleep, hibernate or monitor off.
		/// </summary>
		/// <returns><c>false</c> if failed. Supports <see cref="lastError"/>.</returns>
		/// <param name="how"></param>
		/// <remarks>
		/// To sleep or hibernate uses API <ms>SetSuspendState</ms>. To turn off display uses <ms>WM_SYSCOMMAND</ms>.
		/// 
		/// The <ms>SetSuspendState</ms> behavior is undefined if the system does not support S1-S3 sleep or S4 hibernate power states. It may fail or use hibernation instead of sleep. About power states: <ms>System Power States</ms>. Available sleep states: <c>run.console("powercfg.exe", "/A");</c>
		/// </remarks>
		public static bool suspend(CSuspend how) {
			if (how == CSuspend.SleepOrDisplay) how = 0 != Api.IsPwrSuspendAllowed() ? CSuspend.Sleep : CSuspend.Display;
			if (how == CSuspend.Display) {
				var w = WndUtil.CreateWindowDWP_(messageOnly: true);
				Api.DefWindowProc(w, Api.WM_SYSCOMMAND, Api.SC_MONITORPOWER, 2);
				Api.DestroyWindow(w);
				return true;
			}
			SecurityUtil.SetPrivilege("SeShutdownPrivilege", true);
			return 0 != Api.SetSuspendState((byte)(how == CSuspend.Hibernate ? 1 : 0), 0, 0);
			//documented: parameter bForce has no effect.
		}

		/// <summary>
		/// Initiates computer lock operation.
		/// </summary>
		/// <returns><c>false</c> if failed. Supports <see cref="lastError"/>.</returns>
		/// <remarks>
		/// Uses API <ms>LockWorkStation</ms>.
		/// </remarks>
		public static bool lockOrSwitchUser() {
			//if (switchUser) return Api.WTSDisconnectSession(default, -1, false); //on Win10 the same as lock
			return Api.LockWorkStation();
		}

		/// <summary>
		/// Returns <c>true</c> if the computer is using battery power.
		/// </summary>
		/// <seealso cref="SystemInformation.PowerStatus"/>
		public static bool isOnBattery => SystemInformation.PowerStatus.PowerLineStatus == System.Windows.Forms.PowerLineStatus.Offline; //first time 4 ms

		//public static bool isOnBattery => System.Windows.SystemParameters.PowerLineStatus == System.Windows.PowerLineStatus.Offline; //first time 21 ms

		//FUTURE: events desktopSwitchEvent, sleepEvent. Like SystemEvents.
		//public static event Action desktopSwitchEvent {
		//	add {

		//	}
		//	remove {

		//	}
		//}

		//public static void waitForDesktop(Seconds timeout, bool normalDesktop) { //normal, UAC, lock, screensaver, etc
		//																			   //using var hook = new WinEventHook(EEvent.SYSTEM_DESKTOPSWITCH);
		//}

		#region suspendResumeEvent

		static Action<PowerModes> _srAction;
		static object _srLock = new();
		static IntPtr _srHandle;

		/// <summary>
		/// When the computer is about to enter a suspended state (sleep or hibernate) or has resumed operation after being suspended.
		/// </summary>
		/// <remarks>
		/// Many system events are available in <see cref="SystemEvents"/> class. For suspend/resume notifications could be used <see cref="SystemEvents.PowerModeChanged"/>, but it does not work on most computers. Use this event instead.
		///
		/// The event handler is executed in other thread. The parameter can be only <c>Resume</c> or <c>Suspend</c>. See API <ms>PBT_APMSUSPEND</ms> and <ms>PBT_APMRESUMESUSPEND</ms>.
		/// </remarks>
		public static event Action<PowerModes> suspendResumeEvent {
			add {
				lock (_srLock) {
					if (osVersion.minWin8) {
						if (_srHandle == default) {
							Api.DEVICE_NOTIFY_SUBSCRIBE_PARAMETERS p = new() { Callback = &_SRCallback };
							_srHandle = Api.RegisterSuspendResumeNotification((IntPtr)(&p), 2);
							if (_srHandle == default) throw new AuException(0);
						}
					} else {
						SystemEvents.PowerModeChanged += _SystemEvents_PowerModeChanged;
					}
					_srAction += value;
				}
			}
			remove {
				lock (_srLock) {
					_srAction -= value;
					if (osVersion.minWin8) {
						if (_srAction == null && _srHandle != default) {
							Api.UnregisterSuspendResumeNotification(_srHandle);
							_srHandle = default;
						}
					} else {
						SystemEvents.PowerModeChanged -= _SystemEvents_PowerModeChanged;
					}
				}

			}
		}

		[UnmanagedCallersOnly]
		static int _SRCallback(void* context, int type, void* setting) {
			if (type is 4 or 7) _srAction?.Invoke(type == 4 ? PowerModes.Suspend : PowerModes.Resume);
			return 0;
		}

		static void _SystemEvents_PowerModeChanged(object sender, PowerModeChangedEventArgs e) {
			if (e.Mode is PowerModes.Suspend or PowerModes.Resume) _srAction?.Invoke(e.Mode);
		}

		#endregion
	}
}

namespace Au.Types {
	/// <summary>
	/// Used with <see cref="computer.suspend"/>.
	/// </summary>
	public enum CSuspend {
		/// <summary>Sleep (power state S1-S3). If these power states unavailable, the function may hibernate instead.</summary>
		Sleep,

		/// <summary>Hibernate.</summary>
		Hibernate,

		/// <summary>Turn off display. It should activate Modern Suspend S0 if available.</summary>
		Display,

		/// <summary>Sleep if power states S1-S3 available, else turn off display (it should activate Modern Suspend S0 if available).</summary>
		SleepOrDisplay,
	}
}

================================================
FILE: Au/System/consoleProcess.cs
================================================
namespace Au;

/// <summary>
/// Runs a console program in hidden mode. Gets its output text and can write input text.
/// </summary>
/// <remarks>
/// Must be disposed. In the example the <c>using</c> statement does it.
/// </remarks>
/// <seealso cref="run.console(Action{string}, string, string, string, Encoding, bool)"/>
/// <example>
/// <code><![CDATA[
/// using var c = new consoleProcess(folders.Workspace + @"exe\console1\console1.exe");
/// //c.Encoding = Console.OutputEncoding;
/// while (c.Read(out var s)) {
/// 	if (c.IsLine) {
/// 		print.it($"<><c green><_>{s}</_><>");
/// 	} else {
/// 		if (s == "User: ") c.Write("A");
/// 		else if (s == "Password: ") c.Write("B");
/// 		//else if (c.Wait()) continue; //let next Read wait for more text and get old + new text. Use this if other prompts are not possible.
/// 		else if (c.Wait(500)) continue; //wait for more text max 500 ms. If received, let next Read get old + new text.
/// 		else if (dialog.showInput(out var s1, null, s)) c.Write(s1);
/// 		//else print.it($"<><c blue><_>{s}</_><><nonl>");
/// 		else throw new OperationCanceledException();
/// 	}
/// }
/// if (c.ExitCode is int ec && ec != 0) throw new Exception($"Failed. Exit code: {ec}");
/// ]]></code>
/// <code><![CDATA[
/// using var c = new consoleProcess("example.exe");
/// c.Prompt("User: ", "A");
/// c.Prompt("Password: ", "B");
/// while (c.Read(out var s)) print.it(s);
/// print.it(c.ExitCode);
/// ]]></code>
/// </example>
public sealed unsafe class consoleProcess : IDisposable {
	Handle_ _hProcess, _hOutRead, _hInWrite;
	Decoder _decoder;
	byte[] _b;
	char[] _c;
	int _n, _i;
	bool _skipN;
	StringBuilder _sb;
	
	/// <summary>
	/// Starts specified console program.
	/// </summary>
	/// <inheritdoc cref="run.console(string, string, string, Encoding)" path="/param"/>
	/// <exception cref="AuException">Failed, for example file not found.</exception>
	public consoleProcess(string exe, string args = null, string curDir = null) {
		//rejected: bool separateError (separete stderr from stdout). Why:
		//	Impossible to make it sync with stdout.
		//	Complicated library code.
		//	Comlicated user code.
		//	Rarely used. And because of the above reasons would be very very rarely used.
		
		exe = run.NormalizeFile_(true, exe, out _, out _);
		var ps = new ProcessStarter_(exe, args, curDir, rawExe: true);
		
		Handle_ hInRead = default, hOutWrite = default/*, hErrWrite = default*/;
		Api.PROCESS_INFORMATION pi = default;
		try {
			var sa = new Api.SECURITY_ATTRIBUTES(null) { bInheritHandle = 1 };
			if (!Api.CreatePipe(out _hOutRead, out hOutWrite, sa, 0)) throw new AuException(0);
			//if (!Api.CreatePipe(out _hErrRead, out hErrWrite, sa, 0)) throw new AuException(0);
			if (!Api.CreatePipe(out hInRead, out _hInWrite, sa, 0)) throw new AuException(0);
			
			Api.SetHandleInformation(_hInWrite, 1, 0); //remove HANDLE_FLAG_INHERIT
			Api.SetHandleInformation(_hOutRead, 1, 0);
			//Api.SetHandleInformation(_hErrRead, 1, 0);
			
			ps.si.dwFlags |= Api.STARTF_USESTDHANDLES | Api.STARTF_USESHOWWINDOW;
			ps.si.hStdInput = hInRead;
			ps.si.hStdOutput = hOutWrite;
			//ps.si.hStdError = hErrWrite;
			ps.si.hStdError = hOutWrite;
			ps.flags |= Api.CREATE_NEW_CONSOLE;
			
			if (!ps.StartL(out pi, inheritHandles: true)) {
				Dispose();
				throw new AuException(0);
			}
			
			_hProcess = pi.hProcess;
			TerminateFinally = true;
			process.thisProcessExit += _OnExit;
		}
		finally {
			hInRead.Dispose();
			hOutWrite.Dispose();
			//hErrWrite.Dispose();
			pi.hThread.Dispose();
			Ended = _hProcess.Is0;
		}
	}
	
	///
	public void Dispose() {
		//print.it(Api.WaitForSingleObject(_hProcess, 0)); //info: all tested processes ended after 0-5 ms after ERROR_BROKEN_PIPE
		if (TerminateFinally && !Ended && Api.WaitForSingleObject(_hProcess, 100) != Api.WAIT_TIMEOUT) TerminateFinally = false;
		_Dispose();
		GC.SuppressFinalize(this);
	}
	
	void _Dispose() {
		if (_hOutRead.Is0) return;
		process.thisProcessExit -= _OnExit;
		if (TerminateFinally && !Ended) TerminateNow();
		_hProcess.Dispose();
		_hInWrite.Dispose();
		_hOutRead.Dispose();
		//_hErrRead.Dispose();
	}
	
	///
	~consoleProcess() {
		print.warning("consoleProcess not disposed", -1);
		_Dispose();
	}
	
	void _OnExit(Exception e) {
		if (TerminateFinally && !Ended) TerminateNow();
	}

	/// <summary>
	/// Closes the standard input stream (stdin), signaling end of input to the process.
	/// </summary>
	/// <remarks>
	/// Some console programs expect you to close stdin after writing all input data (see <see cref="Write"/>). This signals "end of file" (EOF).
	/// </remarks>
	public void EndInput() {
		_hInWrite.Dispose();
	}
	
	/// <summary>
	/// Console's text encoding.
	/// Default is <see cref="Encoding.UTF8"/>.
	/// </summary>
	/// <remarks>
	/// If wrong encoding, the received text may contain garbage. Try <see cref="Console.OutputEncoding"/> or <see cref="Encoding.Unicode"/>.
	/// </remarks>
	public Encoding Encoding {
		get => _encoding ??= Encoding.UTF8;
		set {
			if (value != _encoding) {
				_encoding = value;
				_decoder = null;
			}
		}
	}
	Encoding _encoding;
	
	/// <summary>
	/// Input text encoding for <see cref="Write"/>. If <c>null</c> (default), will use <see cref="Encoding"/>.
	/// </summary>
	public Encoding InputEncoding { get; set; }
	
	/// <summary>
	/// Waits and reads next full line.
	/// </summary>
	/// <param name="s">Receives the text. It does not contain newline characters (<c>'\r'</c>, <c>'\n'</c>).</param>
	/// <returns><c>false</c> if there is no more text to read because the console process ended or is ending.</returns>
	/// <exception cref="AuException">Failed.</exception>
	/// <remarks>
	/// Waits for new text from console, reads it into an internal buffer, and then returns it one full line at a time.
	/// 
	/// To read a prompt (incomplete line that asks for user input), use <see cref="Read"/> instead. This function would just hang waiting for full line ending with newline characters.
	/// </remarks>
	public bool ReadLine(out string s) => _Read(out s, true);
	
	/// <summary>
	/// Waits and reads next full or partial line.
	/// </summary>
	/// <param name="s">Receives the text. It does not contain newline characters (<c>'\r'</c>, <c>'\n'</c>).</param>
	/// <returns><c>false</c> if there is no more text to read because the console process ended or is ending.</returns>
	/// <exception cref="AuException">Failed.</exception>
	/// <remarks>
	/// Waits for new text from console, reads it into an internal buffer, and then returns it one line at a time.
	/// 
	/// Sets <see cref="IsLine"/> = <c>true</c> if the line text in the buffer is terminated with newline characters. Else sets <c>IsLine</c> = <c>false</c>.
	///
	/// When <c>IsLine</c> is <c>false</c>, <i>s</i> text can be either a prompt (incomplete line that asks for user input) or an incomplete line/prompt text (the remainder will be retrieved later). Your script should somehow distinguish it. If it's a known prompt, let it call <see cref="Write"/>. Else call <see cref="Wait"/>. See example.
	///
	/// It's impossible to automatically distinguish a prompt from a partial line or partial prompt. The console program can write line text in parts, possibly with delays in between. Or it can write a prompt text and wait for user input. Also this function may receive line text in parts because of limited buffer size etc.
	/// </remarks>
	/// <inheritdoc cref="consoleProcess" path="/example"/>
	public bool Read(out string s) => _Read(out s, false);
	
	/// <summary>
	/// Returns:
	/// <br/>• 1 - there is data available to read.
	/// <br/>• 0 - no data.
	/// <br/>• -1 - error, eg process ended. Supports <see cref="lastError"/>.
	/// </summary>
	internal int CanReadNow_ => _i < _n ? 1 : !Api.PeekNamedPipe(_hOutRead, null, 0, out _, out int n) ? -1 : n > 0 ? 1 : 0;
	
	internal IntPtr OutputHandle_ => _hOutRead;
	
	bool _ReadPipe() {
		//native console API allows any buffer size when writing, but wrappers usually use small buffer, eg .NET 4-5 KB, msvcrt 5 KB, C++ not tested
		_b ??= new byte[8000];
		_c ??= new char[_b.Length + 10];
		_sb ??= new();
		_n = _i = 0;
		
		for (; ; ) {
			IntPtr hRead = _hOutRead;
			//IsError = hRead == _hErrRead;
			
			if (!Api.ReadFileArr(hRead, _b, out int nr)) return false;
			if (nr > 0) {
				var b = _b.AsSpan(0, nr);
				
				//BOM? Noticed with: robocopy /unicode (UTF-16 BOM followed by ASCII).
				if (b is [0xEF, 0xBB, 0xBF, ..]) b = b[3..]; else if (b is [0xFF, 0xFE, ..]) b = b[2..];
				
				if (_skipN && _b[0] == 10) {
					_skipN = false;
					b = b[1..];
				}
				
				_decoder ??= Encoding.GetDecoder(); //ensures we'll not get partial multibyte chars (UTF8 etc) at buffer end/start
				_n = _decoder.GetChars(b, _c, false);
				if (_n > 0) return true;
			}
		}
	}
	
	bool _Read(out string text, bool needLine, Func<string, bool> prompt = null) {
		text = null;
		if (Ended) return _R(false);
		
		if (_wasReadMore) _wasReadMore = false; else _sb?.Clear();
		
		readPipe:
		if (_i >= _n) {
			if (!_ReadPipe()) return _R(_Ended(ref text));
		}
		
		var k = new Span<char>(_c, _i, _n - _i);
		
		int i = k.IndexOfAny('\n', '\r');
		if (i < 0) {
			_sb.Append(k);
			_n = 0;
			if (!needLine) {
				switch (_PeekWait(30, 1)) {
				case _PWResult.OK: goto readPipe;
				case _PWResult.End: return _R(_Ended(ref text));
				}
				var s1 = _sb.ToString();
				if (prompt != null) {
					if (prompt(s1)) {
						_sb.Clear();
						return _R(_ReturnText(ref text, s1, false));
					}
					if (_PeekWait(5000, 1) == _PWResult.OK) goto readPipe;
					text = s1; //for exception message
					return false;
				} else {
					return _R(_ReturnText(ref text, s1, false));
				}
			}
			goto readPipe;
		}
		
		string s = _sb.Length > 0 ? _sb.Append(k[0..i]).ToString() : k[0..i].ToString();
		if (k[i++] == '\r') {
			if (i == k.Length) _skipN = true;
			else if (k[i] == '\n') i++;
		}
		_i += i;
		
		return _R(_ReturnText(ref text, s, true));
		
		bool _ReturnText(ref string text, string s, bool isLine) {
			text = s;
			IsLine = isLine;
			if (isLine) _sb.Clear();
			return true;
		}
		
		bool _Ended(ref string text) {
			if (lastError.code != Api.ERROR_BROKEN_PIPE) throw new AuException(0);
			Ended = true;
			if (_sb.Length == 0) return false;
			return _ReturnText(ref text, _sb.ToString(), true);
		}
		
		bool _R(bool r, [CallerLineNumber] int l_ = 0) {
			//print.it("return", l_);
			return r;
		}
	}
	
	/// <summary>
	/// Waits for more text and tells next <see cref="Read"/> to get old + new text.
	/// </summary>
	/// <param name="timeout">Timeout, ms. The function returns <c>false</c> if did not receive more text during that time. If -1, returns <c>true</c> without waiting (next <see cref="Read"/> will wait).</param>
	/// <returns><c>true</c> if received more text or if <i>timeout</i> is -1.</returns>
	/// <exception cref="InvalidOperationException"><see cref="IsLine"/> <c>true</c>. Or multiple <see cref="Wait"/> without <see cref="Read"/>.</exception>
	/// <remarks>
	/// If returns <c>true</c>, next <see cref="Read"/> will get the old text + new text. If the console process ends while waiting, next <c>Read</c> will get the old text, and <see cref="IsLine"/> will be <c>true</c>.
	/// </remarks>
	public bool Wait(int timeout = -1) {
		if (IsLine) throw new InvalidOperationException("IsLine true");
		if (_wasReadMore) throw new InvalidOperationException("multiple Wait without Read");
		if (timeout < 0) {
			if (timeout != -1) throw new ArgumentException();
		} else {
			if (_PeekWait(timeout, 15) == _PWResult.Timeout) return false; //let next _Read clear _sb
		}
		return _wasReadMore = true; //let next _Read don't clear _sb but set _wasReadMore = false
	}
	bool _wasReadMore;
	
	/// <summary>
	/// Waits for next prompt (incomplete line that asks for user input). Reads the prompt and all lines before it. Then can write input text and <c>"\n"</c>.
	/// </summary>
	/// <param name="prompt">Prompt text. Format: [wildcard expression](xref:wildcard_expression).</param>
	/// <param name="input">Input text. If <c>""</c>, writes just <c>"\n"</c>. If <c>null</c>, does not write.</param>
	/// <returns>List of lines before the prompt. The last item is the prompt.</returns>
	/// <exception cref="AuException">Next prompt text does not match <i>prompt</i> (after waiting 5 s for full prompt). Or the console process ended. Or failed to write <i>input</i>.</exception>
	/// <example>
	/// <code><![CDATA[
	/// using var c = new consoleProcess("example.exe");
	/// c.Prompt("User: ", "A");
	/// c.Prompt("Password: ", "B");
	/// while (c.Read(out var s)) print.it(s);
	/// ]]></code>
	/// <code><![CDATA[
	/// var a = c.Prompt("User:");
	/// print.it(a);
	/// c.Write(a.Any(o => o.Contains("keyword")) ? "A" : "B");
	/// ]]></code>
	/// <code><![CDATA[
	/// using var c = new consoleProcess("cmd.exe");
	/// var prompt = @"C:\*>";
	/// c.Prompt(prompt, "example.exa");
	/// foreach (var s in c.Prompt(prompt).SkipLast(1)) print.it(s);
	/// c.Write("exit");
	/// ]]></code>
	/// </example>
	public List<string> Prompt(string prompt, string input = null) {
		wildex wild = prompt;
		bool ok = false;
		Func<string, bool> f = s => ok = wild.Match(s);
		List<string> a = new();
		while (!ok) {
			if (!_Read(out var s, false, f))
				throw new AuException(Ended ? $"The console process ended while waiting for prompt \"{prompt}\"." : $"The prompt text does not match \"{prompt}\". It is \"{s}\".");
			a.Add(s);
		}
		if (input != null) Write(input);
		return a;
	}
	
	/// <summary>
	/// Sends text to the console's input. Also sends character <c>'\n'</c> (like key <c>Enter</c>), unless <i>text</i> ends with <c>'\n'</c> or <i>noNL</i> is <c>true</c>.
	/// </summary>
	/// <param name="text"></param>
	/// <param name="noNL">Don't append character <c>'\n'</c> when <i>text</i> does not end with <c>'\n'</c>.</param>
	/// <exception cref="AuException">Failed.</exception>
	public void Write(string text, bool noNL = false) {
		if (!text.NE()) _Write(text);
		if (!noNL && text is not [.., '\n']) _Write("\n");
		
		void _Write(string s) {
			bool ok = Api.WriteFile2(_hInWrite, (InputEncoding ?? _encoding ?? Encoding.UTF8).GetBytes(s), out _);
			if (!ok) throw new AuException(0);
		}
	}
	
	/// <summary>
	/// <see cref="Read"/> sets this property = <c>true</c> if in console output the line text ended with newline characters; <c>false</c> if not.
	/// </summary>
	/// <remarks>
	/// If returns <c>false</c>, the text returned by the last <see cref="Read"/> is either a prompt (incomplete line that asks for user input) or an incomplete line. You can use <see cref="Wait"/> to wait for more text.
	/// </remarks>
	public bool IsLine { get; private set; }
	
	///// <summary>
	///// Returns <c>true</c> if the last <c>ReadX</c> function retrieved text from the standard error stream; <c>false</c> if from the standard output stream.
	///// </summary>
	//public bool IsError { get; private set; }
	
	/// <summary>
	/// Returns <c>true</c> if a <c>ReadX</c> function detected that the console output stream is closed. The process is ended or ending.
	/// </summary>
	public bool Ended { get; private set; }
	
	/// <summary>
	/// Gets the exit code of the console process.
	/// If the process is still running, waits until it exits.
	/// </summary>
	/// <value>If fails, returns <c>int.MinValue</c>.</value>
	public int ExitCode {
		get {
			bool retry = false; g1:
			if (!Api.GetExitCodeProcess(_hProcess, out int r)) return int.MinValue;
			if (r == 259 && !retry && (retry = 0 == Api.WaitForSingleObject(_hProcess, -1))) goto g1; //STILL_ACTIVE
			return r;
		}
	}
	
	/// <summary>
	/// Terminates the console process.
	/// </summary>
	/// <param name="exitCode"></param>
	public void TerminateNow(int exitCode = -1) {
		Api.TerminateProcess(_hProcess, exitCode);
		TerminateFinally = false;
	}
	
	/// <summary>
	/// If the console process is still running when this variable is dying, terminate it.
	/// Default <c>true</c>.
	/// </summary>
	public bool TerminateFinally { get; set; }
	
	_PWResult _PeekWait(int time, int minPeriod, int maxPeriod = 100) {
		for (int period = minPeriod; time > 0;) {
			if (period > 0) {
				period.ms();
				time -= period;
			}
			if (period < maxPeriod) period++;
			if (!Api.PeekNamedPipe(_hOutRead, null, 0, out _, out int nr)) return _PWResult.End;
			if (nr > 0) return _PWResult.OK;
		}
		return _PWResult.Timeout;
	}
	
	enum _PWResult { OK, Timeout, End }
	
	/// <summary>
	/// Reads all console output text until its process ends. Returns that text.
	/// </summary>
	/// <remarks>
	/// Does not parse lines. Does not normalize newline characters.
	/// </remarks>
	/// <exception cref="AuException">Failed.</exception>
	public string ReadAllText() {
		while (_ReadPipe()) _sb.Append(_c, 0, _n);
		if (lastError.code != Api.ERROR_BROKEN_PIPE) throw new AuException(0);
		var s = _sb.ToString();
		_sb.Clear();
		return s;
	}
	
	/// <summary>
	/// Reads all console output text until its process ends. Calls callback function.
	/// </summary>
	/// <param name="output">Called for each text chunk received from console.</param>
	/// <remarks>
	/// Does not parse lines. Does not normalize newline characters.
	/// </remarks>
	/// <exception cref="AuException">Failed.</exception>
	public void ReadAllText(Action<string> output) {
		if (_sb?.Length > 0) {
			var s = _sb.ToString();
			_sb.Clear();
			output(s);
		}
		while (_ReadPipe()) output(new(_c, 0, _n));
		if (lastError.code != Api.ERROR_BROKEN_PIPE) throw new AuException(0);
	}
}


================================================
FILE: Au/System/osVersion.cs
================================================
namespace Au;

/// <summary>
/// Provides Windows version info. Also some info about the current process (eg 32/64 bit) and this library.
/// </summary>
/// <remarks>
/// The Windows version properties return the true Windows version; it does not depend on manifest etc.
/// </remarks>
/// <seealso cref="OperatingSystem"/>
/// <seealso cref="RuntimeInformation"/>
public static unsafe class osVersion {
	static osVersion() {
		Api.RTL_OSVERSIONINFOW x = default; x.dwOSVersionInfoSize = sizeof(Api.RTL_OSVERSIONINFOW);
		Api.RtlGetVersion(ref x); //use this because Environment.OSVersion.Version (GetVersionEx) lies, even if we have correct manifest when is debugger present
		_winver = Math2.MakeWord(_winminor = (int)x.dwMinorVersion, _winmajor = (int)x.dwMajorVersion);
		_winbuild = (int)x.dwBuildNumber;

		_minWin8 = _winver >= win8;
		_minWin8_1 = _winver >= win8_1;
		_minWin10 = _winver >= win10;
		if (_minWin10) _win10build = _winbuild;
		//print.it(_win10build);

		//this is to remind to add new members for new Windows 10/11 versions
		//Debug_.PrintIf(_win10build > 19044, $"{_win10build} {Microsoft.Win32.Registry.GetValue(@"HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion", "DisplayVersion", "failed")}");

		_is32BitOS = sizeof(nint) == 4 && !(Api.IsWow64Process(Api.GetCurrentProcess(), out _isWow64) && _isWow64);
	}

	static readonly int _winmajor, _winminor, _winver, _winbuild, _win10build;
	static readonly bool _minWin8, _minWin8_1, _minWin10;
	static readonly bool _is32BitOS, _isWow64;

	/// <summary>
	/// Gets Windows major version.
	/// </summary>
	public static int winMajor => _winmajor;

	/// <summary>
	/// Gets Windows minor version.
	/// </summary>
	public static int winMinor => _winminor;

	/// <summary>
	/// Gets Windows build number.
	/// For example 14393 for Windows 10 version 1607.
	/// </summary>
	public static int winBuild => _winbuild;

	/// <summary>
	/// Gets Windows major and minor version in single <c>int</c>: Win7 - 0x601; Win8 - 0x602; Win8.1 - 0x603; Win10/11 - 0xA00.
	/// Example: <c>if (osVersion.winVer >= osVersion.win8) ...</c>
	/// </summary>
	public static int winVer => _winver;

	/// <summary>
	/// Windows version major+minor value that can be used with <see cref="winVer"/>.
	/// Example: <c>if (osVersion.winVer >= osVersion.win8) ...</c>
	/// </summary>
	public const int win7 = 0x601, win8 = 0x602, win8_1 = 0x603, win10 = 0xA00;

	/// <summary>
	/// <c>true</c> if Windows 8.0 or later.
	/// </summary>
	public static bool minWin8 => _minWin8;

	/// <summary>
	/// <c>true</c> if Windows 8.1 or later.
	/// </summary>
	public static bool minWin8_1 => _minWin8_1;

	/// <summary>
	/// <c>true</c> if Windows 10 or later.
	/// </summary>
	public static bool minWin10 => _minWin10;

	/// <summary>
	/// <c>true</c> if Windows 10 version 1607 or later.
	/// </summary>
	public static bool minWin10_1607 => _win10build >= 14393;

	/// <summary>
	/// <c>true</c> if Windows 10 version 1703 or later.
	/// </summary>
	public static bool minWin10_1703 => _win10build >= 15063;

	/// <summary>
	/// <c>true</c> if Windows 10 version 1709 or later.
	/// </summary>
	public static bool minWin10_1709 => _win10build >= 16299;

	/// <summary>
	/// <c>true</c> if Windows 10 version 1803 or later.
	/// </summary>
	public static bool minWin10_1803 => _win10build >= 17134;

	/// <summary>
	/// <c>true</c> if Windows 10 version 1809 or later.
	/// </summary>
	public static bool minWin10_1809 => _win10build >= 17763;

	/// <summary>
	/// <c>true</c> if Windows 10 version 1903 or later.
	/// </summary>
	public static bool minWin10_1903 => _win10build >= 18362;

	/// <summary>
	/// <c>true</c> if Windows 10 version 1909 or later.
	/// </summary>
	public static bool minWin10_1909 => _win10build >= 18363;

	/// <summary>
	/// <c>true</c> if Windows 10 version 2004 or later.
	/// </summary>
	public static bool minWin10_2004 => _win10build >= 19041;

	/// <summary>
	/// <c>true</c> if Windows 10 version 20H2 or later.
	/// </summary>
	public static bool minWin10_20H2 => _win10build >= 19042;

	/// <summary>
	/// <c>true</c> if Windows 10 version 21H1 or later.
	/// </summary>
	public static bool minWin10_21H1 => _win10build >= 19043;

	/// <summary>
	/// <c>true</c> if Windows 10 version 21H2 or later.
	/// </summary>
	public static bool minWin10_21H2 => _win10build >= 19044;

	/// <summary>
	/// <c>true</c> if Windows 10 version 22H2 or later.
	/// </summary>
	public static bool minWin10_22H2 => _win10build >= 19045;

	/// <summary>
	/// <c>true</c> if Windows 11 or later.
	/// </summary>
	public static bool minWin11 => _win10build >= 22000;

	/// <summary>
	/// <c>true</c> if Windows 11 version 22H2 or later.
	/// </summary>
	public static bool minWin11_22H2 => _win10build >= 22621;

	/// <summary>
	/// <c>true</c> if Windows 11 version 23H2 or later.
	/// </summary>
	public static bool minWin11_23H2 => _win10build >= 22631;

	/// <summary>
	/// <c>true</c> if Windows 11 version 24H2 or later.
	/// </summary>
	public static bool minWin11_24H2 => _win10build >= 26100;

	/// <summary>
	/// <c>true</c> if Windows 11 version 25H2 or later.
	/// </summary>
	public static bool minWin11_25H2 => _win10build >= 26200;

	/// <summary>
	/// <c>true</c> if this process is ARM64.
	/// </summary>
	/// <value><c>RuntimeInformation.ProcessArchitecture == Architecture.Arm64</c></value>
	public static bool isArm64Process => RuntimeInformation.ProcessArchitecture == Architecture.Arm64;

	/// <summary>
	/// <c>true</c> if Windows ARM64.
	/// </summary>
	/// <value><c>RuntimeInformation.OSArchitecture == Architecture.Arm64</c></value>
	public static bool isArm64OS => RuntimeInformation.OSArchitecture == Architecture.Arm64;

	/// <summary>
	/// <c>true</c> if this process is 32-bit, <c>false</c> if 64-bit (x64 or ARM64).
	/// The same as <c>sizeof(nint) == 4</c>.
	/// </summary>
	public static bool is32BitProcess => sizeof(nint) == 4;

	/// <summary>
	/// <c>true</c> if Windows 32-bit, <c>false</c> if 64-bit (x64 or ARM64).
	/// </summary>
	public static bool is32BitOS => _is32BitOS;

	/// <summary>
	/// Returns <c>true</c> if this process is a 32-bit process running on 64-bit Windows. Also known as WOW64 process.
	/// </summary>
	public static bool is32BitProcessAnd64BitOS => _isWow64;

	/// <summary>
	/// Gets the version string of this library (<c>Au.dll</c>), like <c>"1.2.3"</c>.
	/// </summary>
	/// <remarks>
	/// This function is fast, unlike <c>typeof(osVersion).Assembly.GetName().Version.ToString(3)</c>.
	/// 
	/// LibreAutomate uses <c>Au.dll</c> of the same version as of LibreAutomate.
	/// </remarks>
	public static string thisLibrary => Au_.Version;

	/// <summary>
	/// Gets string containing OS version, .NET version and <c>Au.dll</c> version, like <c>"10.0.22621-64|6.0.8|1.2.3"</c>.
	/// Can be used for example to rebuild various caches when it's changed.
	/// </summary>
	public static string onaString => _environment.Value;
	static readonly Lazy<string> _environment = new(() => $"{_winmajor.ToS()}.{_winminor.ToS()}.{_winbuild.ToS()}-{(_is32BitOS ? "32" : "64")}|{Environment.Version}|{Au_.Version}");
}


================================================
FILE: Au/System/process.cs
================================================
//#define USE_WTS

//FUTURE: GetCpuUsage.

namespace Au {
	/// <summary>
	/// Process functions. Find, enumerate, get basic info, terminate, triggers, etc. Also includes properties and events of current process and thread.
	/// </summary>
	/// <seealso cref="run"/>
	/// <seealso cref="script"/>
	/// <seealso cref="Process"/>
	public static unsafe class process {
		/// <summary>
		/// Gets process executable file name (like <c>"notepad.exe"</c>) or full path.
		/// </summary>
		/// <returns><c>null</c> if failed.</returns>
		/// <param name="processId">Process id.</param>
		/// <param name="fullPath">
		/// Get full path.
		/// Note: Fails to get full path if the process belongs to another user session, unless current process is running as administrator; also fails to get full path of some system processes.
		/// </param>
		/// <param name="noSlowAPI">When the fast API <ms>QueryFullProcessImageName</ms> fails, don't try to use another much slower API <ms>WTSEnumerateProcesses</ms>. Not used if <i>fullPath</i> is <c>true</c>.</param>
		/// <remarks>
		/// This function is much slower than getting window name or class name.
		/// </remarks>
		/// <seealso cref="wnd.ProgramName"/>
		/// <seealso cref="wnd.ProgramPath"/>
		/// <seealso cref="wnd.ProcessId"/>
		public static string getName(int processId, bool fullPath = false, bool noSlowAPI = false) {
			if (processId == 0) return null;
			string R = null;
			
			//var t = perf.mcs;
			//if(s_time != 0) print.it(t - s_time);
			//s_time = t;
			
			using var ph = Handle_.OpenProcess(processId);
			if (!ph.Is0) {
				//In non-admin process fails if the process is of another user session.
				//Also fails for some system processes: nvvsvc, nvxdsync, dwm. For dwm fails even in admin process.
				
				//getting native path is faster, but it gets like "\Device\HarddiskVolume5\Windows\System32\notepad.exe" and I don't know API to convert to normal
				if (_QueryFullProcessImageName(ph, !fullPath, out var s)) {
					R = s;
					if (pathname.IsPossiblyDos_(R)) {
						if (fullPath || _QueryFullProcessImageName(ph, false, out s)) {
							R = pathname.ExpandDosPath_(s);
							if (!fullPath) R = _GetFileName(R);
						}
					}
				}
			} else if (!noSlowAPI && !fullPath) {
				//the slow way. Can get only names, not paths.
				using (var p = new AllProcesses_(false)) {
					for (int i = 0; i < p.Count; i++)
						if (p.Id(i) == processId) {
							R = p.Name(i, cannotOpen: true);
							break;
						}
				}
				//TEST: NtQueryInformationProcess, like in getCommandLine.
			}
			
			return R;
			
			//Would be good to cache process names here. But process id can be reused quickly. Use GetNameCached_ instead.
			//	tested: a process id is reused after creating ~100 processes (and waiting until exits). It takes ~2 s.
			//	The window finder is optimized to call this once for each process and not for each window.
		}
		
		/// <summary>
		/// Same as <c>GetName</c>, but faster when called several times for same window, like <c>if(w.ProgramName=="A" || w.ProgramName=="B")</c>.
		/// </summary>
		internal static string GetNameCached_(wnd w, int processId, bool fullPath = false) {
			if (processId == 0) return null;
			var cache = _LastWndProps.OfThread;
			cache.Begin(w);
			var R = fullPath ? cache.ProgramPath : cache.ProgramName;
			if (R == null) {
				R = getName(processId, fullPath);
				if (fullPath) cache.ProgramPath = R; else cache.ProgramName = R;
			}
			return R;
		}
		
		class _LastWndProps {
			wnd _w;
			long _time;
			internal string ProgramName, ProgramPath;
			
			internal void Begin(wnd w) {
				var t = Api.GetTickCount64();
				if (w != _w || t - _time > 300) { _w = w; ProgramName = ProgramPath = null; }
				_time = t;
			}
			
			[ThreadStatic] static _LastWndProps _ofThread;
			internal static _LastWndProps OfThread => _ofThread ??= new();
		}
		
		[SkipLocalsInit]
		static bool _QueryFullProcessImageName(IntPtr hProcess, bool getFilename, out string s) {
			s = null;
			using FastBuffer<char> b = new();
			for (; ; b.More()) {
				int n = b.n;
				if (Api.QueryFullProcessImageName(hProcess, getFilename, b.p, ref n)) {
					s = getFilename ? _GetFileName(b.p, n) : new string(b.p, 0, n);
					return true;
				}
				if (lastError.code != Api.ERROR_INSUFFICIENT_BUFFER) return false;
			}
		}
		
#if USE_WTS //simple, safe, but ~2 times slower
		struct _AllProcesses :IDisposable
		{
			ProcessInfo_* _p;

			public _AllProcesses(out ProcessInfo_* p, out int count)
			{
				if(WTSEnumerateProcessesW(default, 0, 1, out p, out count)) _p = p; else _p = null;
			}

			public void Dispose()
			{
				if(_p != null) WTSFreeMemory(_p);
			}

			[DllImport("wtsapi32.dll", SetLastError = true)]
			static extern bool WTSEnumerateProcessesW(IntPtr serverHandle, uint reserved, uint version, out ProcessInfo_* ppProcessInfo, out int pCount);

			[DllImport("wtsapi32.dll", SetLastError = false)]
			static extern void WTSFreeMemory(ProcessInfo_* memory);
		}
#else //the .NET Process class uses this. But it creates about 0.4 MB of garbage (last time tested was 0.2 MB).
		internal unsafe struct AllProcesses_ : IDisposable {
			readonly _ProcessInfo* _p;
			readonly int _count;
			static int s_bufferSize = 500_000;
			
			public AllProcesses_(bool ofThisSession) {
				int sessionId = ofThisSession ? thisProcessSessionId : 0;
				Api.SYSTEM_PROCESS_INFORMATION* b = null;
				try {
					for (int na = s_bufferSize; ;) {
						MemoryUtil.FreeAlloc(ref b, na);
						int status = Api.NtQuerySystemInformation(5, b, na, out na);
						//print.it(na); //~300_000, Win10, year 2021
						if (status == 0) { s_bufferSize = na + 100_000; break; }
						if (status != Api.STATUS_INFO_LENGTH_MISMATCH) throw new AuException(status);
					}
					
					int nProcesses = 0, nbNames = 0;
					for (var p = b; ; p = (Api.SYSTEM_PROCESS_INFORMATION*)((byte*)p + p->NextEntryOffset)) {
						if (!ofThisSession || p->SessionId == sessionId) {
							nProcesses++;
							nbNames += p->NameLength; //bytes, not chars
						}
						if (p->NextEntryOffset == 0) break;
					}
					_count = nProcesses;
					_p = (_ProcessInfo*)MemoryUtil.Alloc(nProcesses * sizeof(_ProcessInfo) + nbNames);
					_ProcessInfo* r = _p;
					char* names = (char*)(_p + nProcesses);
					for (var p = b; ; p = (Api.SYSTEM_PROCESS_INFORMATION*)((byte*)p + p->NextEntryOffset)) {
						if (!ofThisSession || p->SessionId == sessionId) {
							r->processID = (int)p->UniqueProcessId;
							r->sessionID = (int)p->SessionId;
							int len = p->NameLength / 2;
							r->nameLen = len;
							if (len > 0) {
								//copy name to _p memory because it's in the huge buffer that will be released in this func
								r->nameOffset = (int)(names - (char*)_p);
								MemoryUtil.Copy((char*)p->NamePtr, names, len * 2);
								names += len;
							} else r->nameOffset = 0; //Idle
							r++;
						}
						if (p->NextEntryOffset == 0) break;
					}
				}
				finally { MemoryUtil.Free(b); }
			}
			
			public void Dispose() {
				MemoryUtil.Free(_p);
			}
			
			public int Count => _count;
			
			//public ProcessInfo this[int i] => new(ProcessName(i), _p[i].processID, _p[i].sessionID); //rejected, could be used where shouldn't, making code slower etc
			public ProcessInfo Info(int i) => new(Name(i), _p[i].processID, _p[i].sessionID);
			
			public int Id(int i) => (uint)i < _count ? _p[i].processID : throw new IndexOutOfRangeException();
			
			public int SessionId(int i) => (uint)i < _count ? _p[i].sessionID : throw new IndexOutOfRangeException();
			
			public string Name(int i, bool cannotOpen = false) => (uint)i < _count ? _p[i].GetName(_p, cannotOpen) : throw new IndexOutOfRangeException();
			
			struct _ProcessInfo {
				public int sessionID;
				public int processID;
				public int nameOffset;
				public int nameLen;
				
				public string GetName(void* p, bool cannotOpen) {
					if (nameOffset == 0) {
						if (processID == 0) return "Idle";
						return null;
					}
					string R = new((char*)p + nameOffset, 0, nameLen);
					if (!cannotOpen && pathname.IsPossiblyDos_(R)) {
						using var ph = Handle_.OpenProcess(processID);
						if (!ph.Is0 && _QueryFullProcessImageName(ph, false, out var s)) {
							R = _GetFileName(pathname.ExpandDosPath_(s));
						}
					}
					return R;
				}
			}
		}
#endif
		
		/// <summary>
		/// Gets basic info of all processes: name, id, session id.
		/// </summary>
		/// <param name="ofThisSession">Get processes only of this user session (skip services etc).</param>
		/// <exception cref="AuException">Failed. Unlikely.</exception>
		public static ProcessInfo[] allProcesses(bool ofThisSession = false) {
			using (var p = new AllProcesses_(ofThisSession)) {
				var a = new ProcessInfo[p.Count];
				for (int i = 0; i < a.Length; i++) a[i] = p.Info(i);
				return a;
			}
		}
		
		/// <summary>
		/// Gets process ids of all processes of the specified program.
		/// </summary>
		/// <returns>Array containing zero or more elements.</returns>
		/// <param name="processName">
		/// Process executable file name, like <c>"notepad.exe"</c>.
		/// String format: [wildcard expression](xref:wildcard_expression).
		/// </param>
		/// <param name="fullPath">
		/// <i>processName</i> is full path.
		/// If <c>null</c>, calls <see cref="pathname.isFullPathExpand(ref string, bool?)"/>.
		/// Note: Fails to get full path if the process belongs to another user session, unless current process is running as administrator; also fails to get full path of some system processes.
		/// </param>
		/// <param name="ofThisSession">Get processes only of this user session.</param>
		/// <exception cref="ArgumentException">
		/// - <i>processName</i> is <c>""</c> or <c>null</c>.
		/// - Invalid wildcard expression (<c>"**options "</c> or regular expression).
		/// </exception>
		public static int[] getProcessIds([ParamString(PSFormat.Wildex)] string processName, bool? fullPath = false, bool ofThisSession = false) {
			List<int> a = null;
			bool fp = _NameOrPath(ref processName, fullPath);
			GetProcessesByName_(ref a, processName, fp, ofThisSession);
			return a?.ToArray() ?? [];
		}
		
		static bool _NameOrPath(ref string processName, bool? fullPath) {
			if (processName.NE()) throw new ArgumentException();
			return fullPath switch {
				false => false,
				true => pathname.isFullPathExpand(ref processName, strict: false) | true,
				_ => pathname.isFullPathExpand(ref processName, strict: false)
			};
		}
		
		/// <summary>
		/// Gets process id of the first found process of the specified program.
		/// </summary>
		/// <returns>0 if not found.</returns>
		/// <inheritdoc cref="getProcessIds"/>
		public static int getProcessId([ParamString(PSFormat.Wildex)] string processName, bool? fullPath = false, bool ofThisSession = false) {
			List<int> a = null;
			bool fp = _NameOrPath(ref processName, fullPath);
			return GetProcessesByName_(ref a, processName, fp, ofThisSession, true);
		}
		
		/// <summary>
		/// Returns <c>true</c> if a process of the specified program is running.
		/// </summary>
		/// <inheritdoc cref="getProcessIds"/>
		public static bool exists([ParamString(PSFormat.Wildex)] string processName, bool? fullPath = false, bool ofThisSession = false)
			=> 0 != getProcessId(processName, fullPath, ofThisSession);
		
		internal static int GetProcessesByName_(ref List<int> a, wildex processName, bool fullPath = false, bool ofThisSession = false, bool first = false) {
			a?.Clear();
			using (var p = new AllProcesses_(ofThisSession)) {
				for (int i = 0; i < p.Count; i++) {
					string s = fullPath ? getName(p.Id(i), true) : p.Name(i);
					if (s != null && processName.Match(s)) {
						int pid = p.Id(i);
						if (first) return pid;
						a ??= new List<int>();
						a.Add(pid);
					}
				}
			}
			return 0;
		}
		
		static string _GetFileName(char* s, int len) {
			if (s == null) return null;
			char* ss = s + len;
			for (; ss > s; ss--) if (ss[-1] == '\\' || ss[-1] == '/') break;
			return new string(ss, 0, len - (int)(ss - s));
		}
		
		static string _GetFileName(string s) {
			fixed (char* p = s) return _GetFileName(p, s.Length);
		}
		
		/// <summary>
		/// Gets version info of process executable file.
		/// </summary>
		/// <returns><c>null</c> if failed.</returns>
		/// <param name="processId">Process id.</param>
		public static FileVersionInfo getVersionInfo(int processId) {
			var s = getName(processId, true);
			if (s != null) {
				try { return FileVersionInfo.GetVersionInfo(s); } catch { }
			}
			return null;
		}
		
		/// <summary>
		/// Gets description of process executable file.
		/// </summary>
		/// <returns><c>null</c> if failed.</returns>
		/// <param name="processId">Process id.</param>
		/// <remarks>
		/// Calls <see cref="getVersionInfo"/> and <see cref="FileVersionInfo.FileDescription"/>.
		/// </remarks>
		public static string getDescription(int processId) => getVersionInfo(processId)?.FileDescription;
		
		/// <summary>
		/// Gets process id from handle (API <ms>GetProcessId</ms>).
		/// </summary>
		/// <returns>0 if failed. Supports <see cref="lastError"/>.</returns>
		/// <param name="processHandle">Process handle.</param>
		public static int processIdFromHandle(IntPtr processHandle) => Api.GetProcessId(processHandle); //fast
		
		//public static Process processObjectFromHandle(IntPtr processHandle)
		//{
		//	int pid = GetProcessId(processHandle);
		//	if(pid == 0) return null;
		//	return Process.GetProcessById(pid); //slow, makes much garbage, at first gets all processes just to throw exception if pid not found...
		//}
		
		/// <summary>
		/// Gets user session id of a process (API <ms>ProcessIdToSessionId</ms>).
		/// </summary>
		/// <returns>Returns -1 if failed. Supports <see cref="lastError"/>.</returns>
		/// <param name="processId">Process id.</param>
		public static int getSessionId(int processId) {
			if (!Api.ProcessIdToSessionId(processId, out var R)) return -1;
			return R;
		}
		
		/// <summary>
		/// Gets process creation and execution times (API <ms>GetProcessTimes</ms>).
		/// </summary>
		/// <returns><c>false</c> if failed. Supports <see cref="lastError"/>.</returns>
		/// <param name="processId">Process id.</param>
		/// <param name="created">Creation time. As absolute <ms>FILETIME</ms>, UTC. If you need <see cref="DateTime"/>, use <see cref="DateTime.FromFileTimeUtc"/>.</param>
		/// <param name="executed">Amount of time spent executing code (using CPU). As <ms>FILETIME</ms>. If you need <see cref="TimeSpan"/>, use <see cref="TimeSpan.FromTicks"/>.</param>
		public static bool getTimes(int processId, out long created, out long executed) {
			created = 0; executed = 0;
			using var ph = Handle_.OpenProcess(processId);
			if (ph.Is0 || !Api.GetProcessTimes(ph, out created, out _, out long tk, out long tu)) return false;
			executed = tk + tu;
			return true;
		}
		
		/// <summary>
		/// Returns <c>true</c> if the process is 32-bit, <c>false</c> if 64-bit.
		/// Also returns <c>false</c> if failed. Supports <see cref="lastError"/>.
		/// </summary>
		/// <remarks>
		/// <note>If you know it is current process, instead use <see cref="osVersion"/> functions or <c>IntPtr.Size==4</c>. This function is much slower.</note>
		/// </remarks>
		/// <seealso cref="RuntimeInformation"/>
		public static bool is32Bit(int processId) {
			bool is32bit = osVersion.is32BitOS;
			if (!is32bit) {
				using var ph = Handle_.OpenProcess(processId);
				if (ph.Is0 || !Api.IsWow64Process(ph, out is32bit)) return false;
			}
			lastError.clear();
			return is32bit;
			
			//info: don't use Process.GetProcessById, it does not have a desiredAccess parameter and fails with higher IL processes.
		}
		
		/// <summary>
		/// Returns <c>true</c> if the process is 32-bit, <c>false</c> if 64-bit.
		/// Also returns <c>false</c> if failed. Supports <see cref="lastError"/>.
		/// </summary>
		public static bool is32Bit(IntPtr processHandle) {
			bool is32bit = osVersion.is32BitOS;
			if (!is32bit) {
				if (!Api.IsWow64Process(processHandle, out is32bit)) return false;
			}
			lastError.clear();
			return is32bit;
		}
		
		//rejected: isArm64, or architecture, or cpuArch. Rarely used.
		
		/// <summary>
		/// Gets the command line string used to start the specified process.
		/// </summary>
		/// <returns><c>null</c> if failed.</returns>
		/// <param name="processId">Process id.</param>
		/// <param name="removeProgram">Remove program path. Return only arguments, or empty string if there is no arguments.</param>
		/// <remarks>
		/// The string starts with program file path or name, often enclosed in <c>""</c>, and may be followed by arguments. Some processes may modify it; then this function gets the modified string.
		/// Fails if the specified process is admin and this process isn't. May fail with some system processes. Fails if this is a 32-bit process.
		/// </remarks>
		public static unsafe string getCommandLine(int processId, bool removeProgram = false) {
			if (osVersion.is32BitProcess) return null; //can't get PEB address of 64-bit processes. Never mind 32-bit OS.
			using var pm = new ProcessMemory(processId, 0, noException: true);
			if (pm.ProcessHandle == default) return null;
			Api.PROCESS_BASIC_INFORMATION pbi = default;
			if (0 == Api.NtQueryInformationProcess(pm.ProcessHandle, 0, &pbi, sizeof(Api.PROCESS_BASIC_INFORMATION), out _)) {
				long upp; Api.RTL_USER_PROCESS_PARAMETERS up;
				if (pm.Read((IntPtr)pbi.PebBaseAddress + 32, &upp, 8) && pm.Read((IntPtr)upp, &up, sizeof(Api.RTL_USER_PROCESS_PARAMETERS))) {
					pm.Mem = (IntPtr)up.CommandLine.Buffer;
					var s = pm.ReadCharString(up.CommandLine.Length / 2)
						?.Trim() //many end with space, usually when without commandline args
						?.Replace('\0', ' '); //sometimes '\0' instead of spaces before args
					if (removeProgram) s = s.RxReplace(@"(?i)^(?:"".+?""|\S+)(?:\s+(.*))?", "$1");
					return s;
				}
			}
			return null;
			
			//speed: ~25 mcs cold. WMI Win32_Process ~50 ms (2000 times slower).
		}
		
		internal static unsafe int GetParentProcessId_() {
			Api.PROCESS_BASIC_INFORMATION pbi = default;
			if (0 != Api.NtQueryInformationProcess(thisProcessHandle, 0, &pbi, sizeof(Api.PROCESS_BASIC_INFORMATION), out _)) return 0;
			return (int)pbi.ParentProcessId;
		}
		
		/// <summary>
		/// Terminates (ends) the specified process.
		/// </summary>
		/// <returns><c>false</c> if failed. Supports <see cref="lastError"/>.</returns>
		/// <param name="processId">Process id.</param>
		/// <param name="exitCode">Process exit code.</param>
		/// <remarks>
		/// Uses API <ms>WTSTerminateProcess</ms> or <ms>TerminateProcess</ms>. They are async; usually the process ends after 2 - 200 ms, depending on program etc.
		/// 
		/// Does not try to end process "softly" (close main window). Unsaved data will be lost.
		/// 
		/// Alternatives: run <c>taskkill.exe</c> or <c>pskill.exe</c> (download). See <see cref="run.console"/>. More info on the internet.
		/// </remarks>
		/// <example>
		/// Restart the shell process (explorer).
		/// <code><![CDATA[
		/// process.terminate(wnd.getwnd.shellWindow.ProcessId, 1);
		/// if (!dialog.showYesNo("Restart explorer?")) return;
		/// run.it(folders.Windows + @"explorer.exe", flags: RFlags.InheritAdmin);
		/// ]]></code>
		/// </example>
		public static bool terminate(int processId, int exitCode = 0) {
			if (Api.WTSTerminateProcess(default, processId, exitCode)) return true;
			if (lastError.code != Api.ERROR_INVALID_PARAMETER) {
				using var h = Handle_.OpenProcess(processId, Api.SYNCHRONIZE | Api.PROCESS_TERMINATE);
				if (!h.Is0) {
					if (!Api.TerminateProcess(h, exitCode))
						return 0 == Api.WaitForSingleObject(h, 500); //ERROR_ACCESS_DENIED when the process is ending
					return true;
				}
			}
			return false;
			//note: TerminateProcess and WTSTerminateProcess are async. Tested programs ended after 3 - 150 ms, depending on program.
		}
		
		/// <summary>
		/// Terminates (ends) all processes of the specified program or programs.
		/// </summary>
		/// <returns>The number of successfully terminated processes.</returns>
		/// <param name="processName">
		/// Process executable file name (like <c>"notepad.exe"</c>) or full path.
		/// String format: [wildcard expression](xref:wildcard_expression).
		/// </param>
		/// <param name="allSessions">Processes of any user session. If <c>false</c> (default), only processes of this user session.</param>
		/// <param name="exitCode">Process exit code.</param>
		/// <exception cref="ArgumentException">
		/// - <i>processName</i> is <c>""</c> or <c>null</c>.
		/// - Invalid wildcard expression (<c>"**options "</c> or regular expression).
		/// </exception>
		public static int terminate(string processName, bool allSessions = false, int exitCode = 0) {
			int n = 0;
			foreach (int pid in getProcessIds(processName, fullPath: null, ofThisSession: !allSessions)) {
				if (terminate(pid, exitCode)) n++;
			}
			return n;
		}
		
		/// <summary>
		/// Suspends or resumes the specified process.
		/// </summary>
		/// <returns><c>false</c> if failed. Supports <see cref="lastError"/>.</returns>
		/// <param name="suspend"><c>true</c> suspend, <c>false</c> resume.</param>
		/// <param name="processId">Process id.</param>
		/// <remarks>
		/// If suspended multiple times, must be resumed the same number of times.
		/// </remarks>
		public static bool suspend(bool suspend, int processId) {
			using var hp = Handle_.OpenProcess(processId, Api.PROCESS_SUSPEND_RESUME);
			if (!hp.Is0) {
				int status = suspend ? Api.NtSuspendProcess(hp) : Api.NtResumeProcess(hp);
				lastError.code = status;
				return status == 0;
			}
			return false;
		}
		
		/// <summary>
		/// Suspends or resumes all processes of the specified program or programs.
		/// </summary>
		/// <returns>The number of successfully suspended/resumed processes.</returns>
		/// <param name="suspend"><c>true</c> suspend, <c>false</c> resume.</param>
		/// <param name="processName">
		/// Process executable file name (like <c>"notepad.exe"</c>) or full path.
		/// String format: [wildcard expression](xref:wildcard_expression).
		/// </param>
		/// <param name="allSessions">Processes of any user session. If <c>false</c> (default), only processes of this user session.</param>
		/// <exception cref="ArgumentException">
		/// - <i>processName</i> is <c>""</c> or <c>null</c>.
		/// - Invalid wildcard expression (<c>"**options "</c> or regular expression).
		/// </exception>
		/// <remarks>
		/// If suspended multiple times, must be resumed the same number of times.
		/// </remarks>
		public static int suspend(bool suspend, string processName, bool allSessions = false) {
			int n = 0;
			foreach (int pid in getProcessIds(processName, fullPath: null, ofThisSession: !allSessions)) {
				if (process.suspend(suspend, pid)) n++;
			}
			return n;
		}
		
		/// <summary>
		/// Waits until the process ends.
		/// </summary>
		/// <returns><c>true</c> when the process ended. On timeout returns <c>false</c> if <i>timeout</i> is negative; else exception.</returns>
		/// <param name="timeout">Timeout, seconds. Can be 0 (infinite), >0 (exception) or &lt;0 (no exception). More info: [](xref:wait_timeout).</param>
		/// <param name="processId">Process id. If invalid but not 0, the function returns <c>true</c> and sets <c>exitCode = int.MinValue</c>; probably the process is already ended.</param>
		/// <param name="exitCode">Receives the exit code.</param>
		/// <exception cref="TimeoutException"><i>timeout</i> time has expired (if > 0).</exception>
		/// <exception cref="AuException">Failed.</exception>
		/// <exception cref="ArgumentException"><i>processId</i> is 0.</exception>
		public static bool waitForExit(Seconds timeout, int processId, out int exitCode) {
			if (processId == 0) throw new ArgumentException("processId 0", nameof(processId));
			using var h = Handle_.OpenProcess(processId, Api.SYNCHRONIZE | Api.PROCESS_QUERY_LIMITED_INFORMATION);
			if (h.Is0) {
				var e = lastError.code;
				if (e == Api.ERROR_INVALID_PARAMETER) { exitCode = int.MinValue; return true; };
				throw new AuException(e);
			}
			exitCode = 0;
			if (0 == wait.forHandle(timeout, 0, h)) return false;
			Api.GetExitCodeProcess(h, out exitCode);
			return true;
		}
		
		/// <summary>
		/// Provides process started/ended triggers in <c>foreach</c> loop. See examples.
		/// </summary>
		/// <returns>
		/// An object that retrieves process trigger info (started/ended, name, id, session id) when used with <c>foreach</c>.
		/// If need more process properties, your code can call <see cref="process"/> class functions with the process id.
		/// </returns>
		/// <param name="started">Trigger events: <c>true</c> - started, <c>false</c> - ended, <c>null</c> (default) - both.</param>
		/// <param name="processName">
		/// Process executable file name, like <c>"notepad.exe"</c>.
		/// String format: [wildcard expression](xref:wildcard_expression).
		/// <c>null</c> matches all.
		/// </param>
		/// <param name="ofThisSession">Watch processes only of this user session.</param>
		/// <param name="period">
		/// The period in milliseconds of retrieving the list of processes for detecting new and ended processes. Default 100, min 10, max 1000.
		/// Smaller = smaller average delay and less missing triggers (when process lifetime is very short) but more CPU usage.
		/// </param>
		/// <exception cref="ArgumentException">Invalid wildcard expression (<c>"**options "</c> or regular expression).</exception>
		/// <example>
		/// <code><![CDATA[
		/// //all started and ended processes
		/// foreach (var v in process.triggers()) {
		/// 	print.it(v);
		/// }
		/// 
		/// //started notepad processes in current user session
		/// foreach (var v in process.triggers(started: <c>true</c>, "notepad.exe", ofThisSession: true)) {
		/// 	print.it(v);
		/// }
		/// ]]></code>
		/// </example>
		public static IEnumerable<ProcessTriggerInfo> triggers(bool? started = null, [ParamString(PSFormat.Wildex)] string processName = null, bool ofThisSession = false, int period = 100) {
			wildex wild = processName;
			period = Math.Clamp(period, 10, 1000) - 2;
			var comparer = new _PiComparer();
			var hs = new HashSet<ProcessInfo>(comparer);
			var ap = allProcesses(ofThisSession);
			for (; ; ) {
				period.ms();
				//Debug_.MemorySetAnchor_();
				//perf.first();
				using (var p = new AllProcesses_(ofThisSession)) {
					//perf.next();
					bool eq = p.Count == ap.Length;
					if (eq) for (int i = 0; i < ap.Length; i++) if (!(eq = ap[i].Id == p.Id(i))) break;
					if (!eq) {
						var a = new ProcessInfo[p.Count];
						for (int i = 0; i < a.Length; i++) a[i] = p.Info(i);
						for (int i = 0; i < 2; i++) {
							ProcessInfo[] a1, a2;
							if (i == 0) {
								if (started == true) continue;
								a1 = a; a2 = ap;
							} else {
								if (started == false) continue;
								a1 = ap; a2 = a;
							}
							hs.Clear(); hs.UnionWith(a1);
							foreach (var v in a2) {
								if (hs.Add(v)) {
									if (wild == null || wild.Match(v.Name))
										yield return new(i == 1, v.Name, v.Id, v.SessionId);
								}
							}
						}
						ap = a;
					}
				}
				//perf.nw();
				//Debug_.MemoryPrint_();
			}
		}
		
		class _PiComparer : IEqualityComparer<ProcessInfo> {
			//public bool Equals(ProcessInfo x, ProcessInfo y) => x.Id == y.Id;
			public bool Equals(ProcessInfo x, ProcessInfo y) => x.Id == y.Id && x.Name == y.Name;
			public int GetHashCode(ProcessInfo obj) => obj.Id;
		}
		
		#region this process
		
		/// <summary>
		/// Gets current process id.
		/// See API <ms>GetCurrentProcessId</ms>.
		/// </summary>
		public static int thisProcessId => Api.GetCurrentProcessId();
		
		/// <summary>
		/// Returns current process handle.
		/// See API <ms>GetCurrentProcess</ms>.
		/// Don't need to close the handle.
		/// </summary>
		public static IntPtr thisProcessHandle => Api.GetCurrentProcess();
		
		//rejected. Too simple and rare.
		///// <summary>
		///// Gets native module handle of the program file of this process.
		///// </summary>
		//public static IntPtr thisExeModuleHandle => Api.GetModuleHandle(null);
		
		/// <summary>
		/// Gets full path of the program file of this process.
		/// </summary>
		[SkipLocalsInit]
		public static unsafe string thisExePath => Environment.ProcessPath;
		
		/// <summary>
		/// Gets file name of the program file of this process, like <c>"name.exe"</c>.
		/// </summary>
		public static string thisExeName => s_exeName ??= pathname.getName(thisExePath);
		static string s_exeName;
		
		/// <summary>
		/// Gets user session id of this process.
		/// </summary>
		public static int thisProcessSessionId => getSessionId(Api.GetCurrentProcessId());
		
		/// <summary>
		/// Gets or sets whether <see cref="CultureInfo.DefaultThreadCurrentCulture"/> and <see cref="CultureInfo.DefaultThreadCurrentUICulture"/> are <see cref="CultureInfo.InvariantCulture"/>.
		/// </summary>
		/// <remarks>
		/// If your app doesn't want to use current culture (default in .NET apps), it can set these properties = <see cref="CultureInfo.InvariantCulture"/> or set this property = <c>true</c>.
		/// It prevents potential bugs when app/script/components don't specify invariant culture in string functions and "number to/from string" functions.
		/// Also, there is a bug in "number to/from string" functions in some .NET versions with some cultures: they use wrong minus sign, not ASCII <c>'-'</c> which is specified in Control Panel.
		/// The default compiler sets this property = <c>true</c>; as well as <see cref="script.setup"/>.
		/// </remarks>
		public static bool thisProcessCultureIsInvariant {
			get {
				var ic = CultureInfo.InvariantCulture;
				return CultureInfo.DefaultThreadCurrentCulture == ic && CultureInfo.DefaultThreadCurrentUICulture == ic;
			}
			set {
				if (value) {
					var ic = CultureInfo.InvariantCulture;
					CultureInfo.DefaultThreadCurrentCulture = ic;
					CultureInfo.DefaultThreadCurrentUICulture = ic;
				} else {
					CultureInfo.DefaultThreadCurrentCulture = null;
					CultureInfo.DefaultThreadCurrentUICulture = null;
				}
			}
		}

		/// <summary>
		/// <c>true</c> in LA main process. LA sets it, except in tools/pip/dragdrop processes.
		/// </summary>
		internal static bool IsLaProcess_;

		/// <summary>
		/// <c>true</c> in main thread of main LA process. LA sets it, except in tools/pip/dragdrop processes. This is a [ThreadStatic] variable.
		/// NOTE: don't use <c>Environment.CurrentManagedThreadId == 1</c>, it's not always 1 in the main thread.
		/// </summary>
		[ThreadStatic]
		internal static bool IsLaMainThread_;
		
		/// <summary>
		/// After <i>afterMS</i> milliseconds invokes GC and calls API <c>SetProcessWorkingSetSize</c>.
		/// </summary>
		internal static void ThisProcessMinimizePhysicalMemory_(int afterMS) {
			Task.Delay(afterMS).ContinueWith(_ => {
				GC.Collect();
				GC.WaitForPendingFinalizers();
				Api.SetProcessWorkingSetSize(Api.GetCurrentProcess(), -1, -1);
			});
		}
		
		//internal static (long WorkingSet, long PageFile) ThisProcessGetMemoryInfo_()
		//{
		//	Api.PROCESS_MEMORY_COUNTERS m = default; m.cb = sizeof(Api.PROCESS_MEMORY_COUNTERS);
		//	Api.GetProcessMemoryInfo(ProcessHandle, ref m, m.cb);
		//	return ((long)m.WorkingSetSize, (long)m.PagefileUsage);
		//}
		
		/// <summary>
		/// Before this process exits, either normally or on unhandled exception.
		/// </summary>
		/// <remarks>
		/// The event handler is called on:
		/// <br/>• <see cref="AppDomain.ProcessExit"/>, with parameter = <c>null</c>.
		/// <br/>• <see cref="AppDomain.UnhandledException"/>, with parameter = the <see cref="Exception"/>.
		/// </remarks>
		public static event Action<Exception> thisProcessExit {
			add {
				if (!_haveEventExit) {
					lock ("AVCyoRcQCkSl+3W8ZTi5oA") {
						if (!_haveEventExit) {
							var d = AppDomain.CurrentDomain;
							d.ProcessExit += _ThisProcessExit;
							d.UnhandledException += _ThisProcessExit; //because ProcessExit is missing on exception
							_haveEventExit = true;
						}
					}
				}
				_eventExit += value;
			}
			remove {
				_eventExit -= value;
			}
		}
		static Action<Exception> _eventExit;
		static bool _haveEventExit;
		
		static void _ThisProcessExit(object sender, EventArgs ea) { //sender: AppDomain on process exit, null on unhandled exception
			Exception e;
			if (ea is UnhandledExceptionEventArgs u) {
				if (!u.IsTerminating) return; //never seen, but anyway
				e = (Exception)u.ExceptionObject; //probably non-Exception object is impossible in C#
			} else {
				e = script.s_unhandledException;
			}
			var k = _eventExit;
			if (k != null) {
				try { _eventExit = null; k(e); }
				catch (Exception e1) { print.qm2.writeD("_ThisProcessExit", e1); }
			}
			thisProcessExitDone_?.Invoke();
		}
		
		internal static event Action thisProcessExitDone_;
		
		/// <summary>
		/// Calls and removes all <see cref="thisProcessExit"/> event handlers.
		/// </summary>
		/// <remarks>
		/// Call this if <see cref="thisProcessExit"/> event handlers don't run because this process is terminated before it. For example when current session is ending (shutdown, restart, logoff); to detect it can be used <c>Application.SessionEnding</c>, <c>Application.OnSessionEnding</c> or <ms>WM_QUERYENDSESSION</ms>.
		/// </remarks>
		public static void thisProcessExitInvoke() {
			var k = _eventExit;
			if (k != null) try { _eventExit = null; k(null); } catch { }
		}
		
		#endregion
		
		#region this thread
		
		/// <summary>
		/// Gets native thread id of this thread (API <ms>GetCurrentThreadId</ms>).
		/// </summary>
		/// <remarks>
		/// It is not the same as <see cref="Environment.CurrentManagedThreadId"/>.
		/// </remarks>
		/// <seealso cref="wnd.ThreadId"/>
		public static int thisThreadId => Api.GetCurrentThreadId();
		//speed: fast, but several times slower than Environment.CurrentManagedThreadId. Caching in a ThreadStatic variable makes even slower.
		
		/// <summary>
		/// Returns native thread handle of this thread (API <ms>GetCurrentThread</ms>).
		/// </summary>
		public static IntPtr thisThreadHandle => Api.GetCurrentThread();
		
		/// <summary>
		/// Returns <c>true</c> if this thread has a .NET message loop (winforms or WPF).
		/// </summary>
		/// <param name="isWPF">Has WPF message loop and no winforms message loop.</param>
		/// <seealso cref="wnd.getwnd.threadWindows"/>
		public static bool thisThreadHasMessageLoop(out bool isWPF) {
			//info: we don't call .NET functions directly to avoid loading assemblies.
			
			isWPF = false;
			int f = AssemblyUtil_.IsLoadedWinformsWpf();
			if (0 != (f & 1) && _HML_Forms()) return true;
			if (0 != (f & 2) && _HML_Wpf()) return isWPF = true;
			return false;
		}
		
		///
		public static bool thisThreadHasMessageLoop() => thisThreadHasMessageLoop(out _);
		
		[MethodImpl(MethodImplOptions.NoInlining)]
		static bool _HML_Forms() => System.Windows.Forms.Application.MessageLoop;
		
		[MethodImpl(MethodImplOptions.NoInlining)]
		static bool _HML_Wpf() {
			if (SynchronizationContext.Current is System.Windows.Threading.DispatcherSynchronizationContext) {
				var d = System.Windows.Threading.Dispatcher.FromThread(Thread.CurrentThread);
				if (d != null) {
					var f = typeof(System.Windows.Threading.Dispatcher).GetField("_frameDepth", BindingFlags.Instance | BindingFlags.NonPublic);
					Debug_.PrintIf(f == null);
					return f == null || f.GetValue(d) is not int i || i > 0;
				}
			}
			return false;
		}
		//static bool _HML_Wpf() => System.Windows.Threading.Dispatcher.FromThread(Thread.CurrentThread) != null; //no. Not null after a loop ends or even after XamlReader.Parse.
		//static bool _HML_Wpf() => SynchronizationContext.Current is System.Windows.Threading.DispatcherSynchronizationContext; //no. True eg in Dispatcher.Invoke callback.
		
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void ThisThreadSetComApartment_(ApartmentState state) {
			var t = Thread.CurrentThread;
			t.TrySetApartmentState(ApartmentState.Unknown);
			t.TrySetApartmentState(state);
			//CONSIDER: use OleInitialize instead of t.TrySetApartmentState(state).
			//	Somehow RegisterDragDrop in UacDragDrop fails if ThisThreadSetComApartment_.
			//	But RDD in SciCode works with this.
			
			//This is undocumented, but works if we set ApartmentState.Unknown at first.
			//With [STAThread] slower, and the process initially used to have +2 threads.
			//Speed when called to set STA at startup: 1.7 ms. If apphost calls OleInitialize, 1.5 ms.
			//tested: OleUninitialize in apphost does not make GetApartmentState return MTA.
		}
		
		#endregion
	}
}

namespace Au.Types {
	/// <summary>
	/// Contains process name (like <c>"notepad.exe"</c>), id and user session id.
	/// </summary>
	public record struct ProcessInfo(string Name, int Id, int SessionId);
	//use record to auto-implement ==, eg for code like var a=process.allProcesses(); 5.s(); print.it(process.allProcesses().Except(a));
	
	/// <summary>
	/// Contains process trigger info retrieved by <see cref="process.triggers"/>.
	/// </summary>
	public record class ProcessTriggerInfo(bool Started, string Name, int Id, int SessionId);
}


================================================
FILE: Au/System/run.cs
================================================
using Microsoft.Win32.SafeHandles;

namespace Au {
	/// <summary>
	/// Execute or open programs, files, folders, web pages, etc, start new threads.
	/// </summary>
	public static class run {
		/// <summary>
		/// Runs/opens a program, document, directory (folder), URL, new email, etc.
		/// </summary>
		/// <returns>Process info (id etc).</returns>
		/// <param name="file">
		/// Examples:
		/// <br/>• <c>@"C:\file.txt"</c>
		/// <br/>• <c>folders.Documents</c>
		/// <br/>• <c>folders.System + "notepad.exe"</c>
		/// <br/>• <c>@"%folders.System%\notepad.exe"</c>
		/// <br/>• <c>@"%TMP%\file.txt"</c>
		/// <br/>• <c>"notepad.exe"</c>
		/// <br/>• <c>@"..\folder\x.exe"</c>
		/// <br/>• <c>"http://a.b.c/d"</c>
		/// <br/>• <c>"file:///path"</c>
		/// <br/>• <c>"mailto:a@b.c"</c>
		/// <br/>• <c>":: ITEMIDLIST"</c>
		/// <br/>• <c>@"shell:::{CLSID}"</c>
		/// <br/>• <c>@"shell:AppsFolder\Microsoft.WindowsCalculator_8wekyb3d8bbwe!App"</c>.
		/// </param>
		/// <param name="args">
		/// Command line arguments.
		/// This function expands environment variables if starts with <c>"%"</c> or <c>"\"%"</c>.
		/// </param>
		/// <param name="flags"></param>
		/// <param name="dirEtc">
		/// Allows to specify more parameters: current directory, verb, etc.
		/// If string, it sets initial current directory for the new process. If <c>""</c>, gets it from <i>file</i>. More info: <see cref="ROptions.CurrentDirectory"/>.
		/// </param>
		/// <exception cref="ArgumentException">Used both <see cref="ROptions.Verb"/> and <see cref="RFlags.Admin"/> and this process isn't admin.</exception>
		/// <exception cref="AuException">Failed. For example, the file does not exist.</exception>
		/// <remarks>
		/// It works like when you double-click a file icon. It may start new process or not. For example it may just activate window if the program is already running.
		/// Uses API <ms>ShellExecuteEx</ms>.
		/// Similar to <see cref="Process.Start(string, string)"/>.
		/// 
		/// The <i>file</i> parameter can be:
		/// - Full path of a file or directory. Examples: <c>@"C:\file.txt"</c>, <c>folders.Documents</c>, <c>folders.System + "notepad.exe"</c>, <c>@"%folders.System%\notepad.exe"</c>.
		/// - Filename of a file or directory, like <c>"notepad.exe"</c>. The function calls <see cref="filesystem.searchPath"/>.
		/// - Path relative to <see cref="folders.ThisApp"/>. Examples: <c>"x.exe"</c>, <c>@"subfolder\x.exe"</c>, <c>@".\subfolder\x.exe"</c>, <c>@"..\another folder\x.exe"</c>.
		/// - URL. Examples: <c>"https://www.example.com"</c>, <c>"file:///path"</c>.
		/// - Email, like <c>"mailto:a@b.c"</c>. Subject, body etc also can be specified, and Google knows how.
		/// - Shell object's <c>ITEMIDLIST</c> like <c>":: ITEMIDLIST"</c>. See <see cref="Pidl.ToHexString"/>, <see cref="folders.shell"/>. Can be used to open virtual folders and items like Control Panel.
		/// - Shell object's parsing name, like <c>@"shell:::{CLSID}"</c> or <c>@"::{CLSID}"</c>. See <see cref="Pidl.ToShellString"/>. Can be used to open virtual folders and items like Control Panel.
		/// - To run a Windows Store App, use <c>@"shell:AppsFolder\WinStoreAppId"</c> format. Example: <c>@"shell:AppsFolder\Microsoft.WindowsCalculator_8wekyb3d8bbwe!App"</c>. To discover the string use hotkey <c>Ctrl+Shift+Q</c> or function <see cref="WndUtil.GetWindowsStoreAppId"/> or Google.
		/// - To open a Windows Settings page can be used <google>ms-settings</google>, like <c>"ms-settings:display"</c>. To open Settings use <c>"ms-settings:"</c>.
		/// 
		/// Supports environment variables, like <c>@"%TMP%\file.txt"</c>. See <see cref="pathname.expand"/>.
		/// 
		/// By default the new process isn't admin even if this process is admin. It's a unique feature of this function. More info: <see cref="RFlags"/>.
		/// 
		/// The new process inherits environment variables of this process only if both processes are admin or non-admin. To ensure it, use flag <see cref="RFlags.InheritAdmin"/> or some other "start process" function (<see cref="Process.Start"/>, <see cref="run.console"/>, Windows API).
		/// </remarks>
		/// <seealso cref="wnd.find"/>
		/// <seealso cref="wnd.findOrRun"/>
		/// <seealso cref="wnd.runAndFind"/>
		/// <example>
		/// Run Notepad and wait for an active Notepad window.
		/// <code><![CDATA[
		/// run.it("notepad.exe");
		/// 1.s();
		/// wnd w = wnd.wait(10, true, "*- Notepad", "Notepad");
		/// ]]></code>
		/// Run Notepad or activate a Notepad window.
		/// <code><![CDATA[
		/// wnd w = wnd.findOrRun("*- Notepad", run: () => run.it("notepad.exe"));
		/// ]]></code>
		/// Run File Explorer and wait for new folder window. Ignores matching windows that already existed.
		/// <code><![CDATA[
		/// var w = wnd.runAndFind(
		/// 	() => run.it(@"explorer.exe"),
		/// 	10, cn: "CabinetWClass");
		/// ]]></code>
		/// </example>
		public static RResult it(string file, string args = null, RFlags flags = 0, ROptions dirEtc = null) {
			Api.SHELLEXECUTEINFO x = default;
			x.cbSize = Api.SizeOf(x);
			x.fMask = Api.SEE_MASK_NOZONECHECKS | Api.SEE_MASK_NOASYNC | Api.SEE_MASK_CONNECTNETDRV | Api.SEE_MASK_UNICODE;
			x.nShow = Api.SW_SHOWNORMAL;
			
			bool curDirFromFile = false;
			var more = dirEtc;
			if (more != null) {
				x.lpVerb = more.Verb;
				if (x.lpVerb != null) x.fMask |= Api.SEE_MASK_INVOKEIDLIST; //makes slower. But verbs are rarely used.
				
				if (more.CurrentDirectory is string cd) {
					if (cd.Length == 0) curDirFromFile = true; else cd = pathname.expand(cd);
					x.lpDirectory = cd;
				}
				
				if (!more.OwnerWindow.IsEmpty) x.hwnd = more.OwnerWindow.Hwnd.Window;
				
				switch (more.WindowState) {
				case ProcessWindowStyle.Hidden: x.nShow = Api.SW_HIDE; break;
				case ProcessWindowStyle.Minimized: x.nShow = Api.SW_SHOWMINIMIZED; break;
				case ProcessWindowStyle.Maximized: x.nShow = Api.SW_SHOWMAXIMIZED; break;
				}
				
				x.fMask &= ~more.FlagsRemove;
				x.fMask |= more.FlagsAdd;
			}
			
			if (flags.Has(RFlags.Admin)) {
				if (x.lpVerb == null || x.lpVerb.Eqi("runas")) x.lpVerb = "runas";
				else if (!uacInfo.isAdmin) throw new ArgumentException("Cannot use Verb with flag Admin, unless this process is admin");
			}
			
			file = NormalizeFile_(false, file, out bool isFullPath, out bool isShellPath);
			Pidl pidl = null;
			if (isShellPath) { //":: ITEMIDLIST" or "::{CLSID}..." (we convert it too because the API does not support many)
				pidl = Pidl.FromString(file); //does not throw
				if (pidl != null) {
					x.lpIDList = pidl.UnsafePtr;
					x.fMask |= Api.SEE_MASK_INVOKEIDLIST;
				} else x.lpFile = file;
			} else {
				x.lpFile = file;
				
				if (curDirFromFile && isFullPath) x.lpDirectory = pathname.getDirectory(file);
			}
			x.lpDirectory ??= Directory.GetCurrentDirectory();
			if (!args.NE()) x.lpParameters = pathname.expand(args);
			
			if (0 == (flags & RFlags.ShowErrorUI)) x.fMask |= Api.SEE_MASK_FLAG_NO_UI;
			if (0 == (flags & RFlags.WaitForExit)) x.fMask |= Api.SEE_MASK_NO_CONSOLE;
			if (0 != (flags & RFlags.MostUsed)) x.fMask |= Api.SEE_MASK_FLAG_LOG_USAGE;
			x.fMask |= Api.SEE_MASK_NOCLOSEPROCESS;
			
			WndUtil.EnableActivate(-1);
			
			bool waitForExit = 0 != (flags & RFlags.WaitForExit);
			bool needHandle = flags.Has(RFlags.NeedProcessHandle);
			
			bool ok = false; int pid = 0, errorCode = 0;
			bool asUser = !flags.HasAny(RFlags.Admin | RFlags.InheritAdmin) && uacInfo.ofThisProcess.Elevation == UacElevation.Full; //info: new process does not inherit uiAccess
			if (asUser) {
				ok = Cpp.Cpp_ShellExec(x, out pid, out int injectError, out int execError);
				if (!ok) {
					if (injectError != 0) {
						print.warning("Failed to run as non-admin.");
						//once in TT process started to always fail. More info in UnmarshalAgentIAccessible().
						asUser = false;
					} else errorCode = execError;
				}
			}
			if (!asUser) {
				ok = Api.ShellExecuteEx(ref x);
				if (!ok) errorCode = lastError.code;
			}
			pidl?.Dispose();
			if (!ok) throw new AuException(errorCode, $"*run '{file}'");
			
			var R = new RResult();
			WaitHandle_ ph = null;
			
			if (needHandle || waitForExit) {
				if (pid != 0) x.hProcess = Handle_.OpenProcess(pid, Api.PROCESS_ALL_ACCESS);
				if (!x.hProcess.Is0) ph = new WaitHandle_(x.hProcess, true);
			}
			
			if (!waitForExit) {
				if (pid != 0) R.ProcessId = pid;
				else if (!x.hProcess.Is0) R.ProcessId = process.processIdFromHandle(x.hProcess);
			}
			
			try {
				Api.AllowSetForegroundWindow();
				
				if (x.lpVerb != null && Thread.CurrentThread.GetApartmentState() == ApartmentState.STA)
					Thread.CurrentThread.Join(50); //need min 5-10 for file Properties. And not Sleep.
				
				if (ph != null) {
					if (waitForExit) {
						ph.WaitOne();
						if (Api.GetExitCodeProcess(x.hProcess, out var exitCode)) R.ProcessExitCode = exitCode;
					}
					if (needHandle) R.ProcessHandle = ph;
				}
			}
			finally {
				if (R.ProcessHandle == null) {
					if (ph != null) ph.Dispose();
					else x.hProcess.Dispose();
				}
			}
			
			return R;
			
			//tested: works well in MTA thread.
			//rejected: in QM2, run also has a 'window' parameter. However it just makes limited, unclear etc, and therefore rarely used. Instead use wnd.findOrRun etc like in the examples.
			//rejected: in QM2, run also has 'autodelay'. Better don't add such hidden things. Let the script decide what to do.
		}
		
		/// <summary>
		/// Calls <see cref="it"/> and handles exceptions.
		/// If <see cref="it"/> throws exception, writes it to the output as warning and returns <c>null</c>.
		/// </summary>
		/// <remarks>
		/// This function is useful when you don't care whether <see cref="it"/> succeeded and don't want to use try/catch.
		/// Handles only exception of type <see cref="AuException"/>. It is thrown when fails, usually when the file does not exist.
		/// </remarks>
		/// <seealso cref="print.warning"/>
		/// <seealso cref="OWarnings.Disable"/>
		/// <seealso cref="wnd.findOrRun"/>
		/// <inheritdoc cref="it" path="/param"/>
		[MethodImpl(MethodImplOptions.NoInlining)] //uses stack
		public static RResult itSafe(string file, string args = null, RFlags flags = 0, ROptions dirEtc = null) {
			try {
				return it(file, args, flags, dirEtc);
			}
			catch (AuException e) {
				print.warning(e);
				return null;
			}
		}
		
		internal static string NormalizeFile_(bool runConsole, string file, out bool isFullPath, out bool isShellPath) {
			isShellPath = isFullPath = false;
			file = pathname.expand(file);
			if (file.NE()) throw new ArgumentException();
			if (runConsole || !(isShellPath = pathname.IsShellPath_(file))) {
				if (isFullPath = pathname.isFullPath(file)) {
					var fl = runConsole ? PNFlags.DontExpandDosPath : PNFlags.DontExpandDosPath | PNFlags.DontPrefixLongPath;
					file = pathname.Normalize_(file, fl, true);
					
					//ShellExecuteEx supports long path prefix for exe but not for documents.
					//Process.Start supports long path prefix, except when the exe is .NET.
					if (!runConsole) file = pathname.unprefixLongPath(file);
					
					if (FileSystemRedirection.IsSystem64PathIn32BitProcess(file) && !filesystem.exists(file)) {
						file = FileSystemRedirection.GetNonRedirectedSystemPath(file);
					}
				} else if (!pathname.isUrl(file)) {
					//ShellExecuteEx searches everywhere except in app folder.
					//Process.Start prefers current directory.
					var s2 = filesystem.searchPath(file);
					if (s2 != null) {
						file = s2;
						isFullPath = true;
					}
				}
			}
			return file;
		}
		
		/// <summary>
		/// Runs a console program in hidden mode, waits until its process ends, and prints its output text.
		/// Writes text lines to the output in real time.
		/// </summary>
		/// <param name="exe">
		/// Path or name of an <c>.exe</c> or <c>.bat</c> file. Can be:
		/// <br/>• Full path. Examples: <c>@"C:\folder\x.exe"</c>, <c>folders.System + "x.exe"</c>, <c>@"%folders.System%\x.exe"</c>.
		/// <br/>• Filename, like <c>"x.exe"</c>. This function calls <see cref="filesystem.searchPath"/>.
		/// <br/>• Path relative to <see cref="folders.ThisApp"/>. Examples: <c>"x.exe"</c>, <c>@"subfolder\x.exe"</c>, <c>@".\subfolder\x.exe"</c>, <c>@"..\folder\x.exe"</c>.
		/// 
		/// <br/>Supports environment variables, like <c>@"%TMP%\x.bat"</c>. See <see cref="pathname.expand"/>.
		/// </param>
		/// <param name="args"><c>null</c> or command line arguments.</param>
		/// <param name="curDir">
		/// Initial current directory of the new process.
		/// <br/>• If <c>null</c>, uses <c>Directory.GetCurrentDirectory()</c>.
		/// <br/>• Else if <c>""</c>, calls <c>pathname.getDirectory(exe)</c>.
		/// <br/>• Else calls <see cref="pathname.expand"/>.
		/// </param>
		/// <param name="encoding">
		/// Console's text encoding.
		/// If <c>null</c> (default), uses <see cref="Encoding.UTF8"/>. If you get garbage text, try <see cref="Console.OutputEncoding"/> or <see cref="Encoding.Unicode"/>.
		/// </param>
		/// <returns>The process exit code. Usually a non-0 value means error.</returns>
		/// <exception cref="AuException">Failed, for example file not found.</exception>
		/// <remarks>
		/// The console window is hidden. The text that would be displayed in it is redirected to this function.
		/// 
		/// Console programs have two output text streams - standard output and standard error. This function gets both. Alternatively use <see cref="Process.Start"/>; it gets the output and error streams separately, and some lines may be received in incorrect order in time.
		/// </remarks>
		/// <example>
		/// <code><![CDATA[
		/// string v = "example";
		/// run.console(@"C:\Test\console.exe", $@"/an ""{v}"" /etc");
		/// ]]></code>
		/// </example>
		public static int console(string exe, string args = null, string curDir = null, Encoding encoding = null) {
			return _RunConsole(print.it, out _, exe, args, curDir, encoding, true);
		}
		
		/// <summary>
		/// Runs a console program in hidden mode, waits until its process ends, and gets its output text.
		/// </summary>
		/// <param name="output">A variable that receives the output text.</param>
		/// <example>
		/// <code><![CDATA[
		/// run.console(out var text, @"C:\Test\console.exe", encoding: Console.OutputEncoding);
		/// print.it(text);
		/// ]]></code>
		/// </example>
		/// <inheritdoc cref="console(string, string, string, Encoding)"/>
		public static int console(out string output, string exe, string args = null, string curDir = null, Encoding encoding = null) {
			var r = _RunConsole(null, out output, exe, args, curDir, encoding, false);
			return r;
		}
		
		/// <summary>
		/// Runs a console program in hidden mode, waits until its process ends, and gets its output text.
		/// Uses a callback function that receives text lines in real time.
		/// </summary>
		/// <param name="output">
		/// Callback function that receives the output text.
		/// Unless <i>rawText</i> <c>true</c>:
		/// <br/>• it isn't called until is retrieved full line with line break characters;
		/// <br/>• it receives single full line at a time, without line break characters.
		/// </param>
		/// <param name="rawText">Call the callback function whenever text is retrieved (don't wait for full line). Pass raw text, in chunks of any size.</param>
		/// <example>
		/// <code><![CDATA[
		/// run.console(s => print.it(s), @"C:\Test\console.exe");
		///
		/// run.console(s => { print.it($"<><_>{s}</_><nonl>"); }, @"C:\Test\console.exe", rawText: true);
		/// ]]></code>
		/// </example>
		/// <seealso cref="consoleProcess"/>
		/// <inheritdoc cref="console(string, string, string, Encoding)"/>
		public static int console(Action<string> output, string exe, string args = null, string curDir = null, Encoding encoding = null, bool rawText = false) {
			return _RunConsole(output, out _, exe, args, curDir, encoding, !rawText);
		}
		
		static unsafe int _RunConsole(Action<string> outAction, out string outStr, string exe, string args, string curDir, Encoding encoding, bool needLines) {
			outStr = null;
			using var c = new consoleProcess(exe, args, curDir) { Encoding = encoding };
			if (needLines) {
				while (c.ReadLine(out var s)) outAction(s);
			} else if (outAction != null) {
				c.ReadAllText(outAction);
			} else {
				outStr = c.ReadAllText();
			}
			return c.ExitCode;
		}
		
		/// <summary>
		/// Opens parent folder in File Explorer (folder window) and selects the file.
		/// </summary>
		/// <returns><c>false</c> if failed, for example if the file does not exist.</returns>
		/// <param name="path">
		/// Full path of a file or directory or other shell object.
		/// Supports <c>@"%environmentVariable%\..."</c> (see <see cref="pathname.expand"/>) and <c>"::..."</c> (see <see cref="Pidl.ToHexString"/>).
		/// </param>
		public static bool selectInExplorer(string path) {
			using var pidl = Pidl.FromString(path);
			if (pidl == null) return false;
			return 0 == Api.SHOpenFolderAndSelectItems(pidl.HandleRef, 0, null, 0);
		}
		
		/// <summary>
		/// Starts new thread: creates new <see cref="Thread"/> object, sets some properties and calls <see cref="Thread.Start"/>.
		/// </summary>
		/// <returns>The <c>Thread</c> variable.</returns>
		/// <param name="threadProc">Thread procedure. Parameter <i>start</i> of <see cref="Thread"/> constructor.</param>
		/// <param name="background">
		/// If <c>true</c> (default), sets <see cref="Thread.IsBackground"/> = <c>true</c>.
		/// The process ends when the main thread and all foreground threads end; background threads then are terminated.
		/// </param>
		/// <param name="sta">If <c>true</c> (default), sets <see cref="ApartmentState.STA"/>.</param>
		/// <exception cref="OutOfMemoryException"></exception>
		public static Thread thread(Action threadProc, bool background = true, bool sta = true) {
			var t = new Thread(threadProc.Invoke);
			if (background) t.IsBackground = true;
			if (sta) t.SetApartmentState(ApartmentState.STA);
			t.Start();
			return t;
		}
		
		/// <summary>
		/// Starts new thread like <see cref="thread(Action, bool, bool)"/> and gets thread handle and native id.
		/// </summary>
		/// <param name="id">Native thread id.</param>
		/// <param name="thread"><c>Thread</c> object.</param>
		/// <param name="init">Called in the new thread before <i>threadProc</i>. This function (<c>run.thread</c>) waits until it returns.</param>
		/// <returns>Thread handle. Don't forget to dispose.</returns>
		/// <inheritdoc cref="thread(Action, bool, bool)"/>
		public static unsafe SafeWaitHandle thread(out int id, out Thread thread, Action threadProc, bool background = true, bool sta = true, Action init = null) {
			SafeWaitHandle h = null; int i = 0;
			using var ev = Api.CreateEvent(false);
			thread = new Thread(() => {
				init?.Invoke();
				h = new(Api.OpenThread(Api.THREAD_ALL_ACCESS, false, i = Api.GetCurrentThreadId()), ownsHandle: true);
				Api.SetEvent(ev);
				threadProc();
			});
			if (background) thread.IsBackground = true;
			if (sta) thread.SetApartmentState(ApartmentState.STA);
			thread.Start();
			Api.WaitForSingleObject(ev, -1);
			id = i;
			return h;
			
			//Almost same speed as other overload when JITed, but first time several times slower, eg 1 -> 2.5 ms.
			//	With CreateThread faster, but it cannot be used in a public function (then some .NET features work differently).
		}
	}
}

namespace Au.Types {
	/// <summary>
	/// Flags for <see cref="run.it"/>.
	/// </summary>
	[Flags]
	public enum RFlags {
		/// <summary>
		/// Show error message box if fails, for example if file not found.
		/// Note: this does not disable exceptions. To avoid exceptions use try/catch or <see cref="run.itSafe"/>.
		/// </summary>
		ShowErrorUI = 1,
		
		/// <summary>
		/// If started new process, wait until it exits.
		/// </summary>
		WaitForExit = 2,
		
		/// <summary>
		/// If started new process, get process handle (<see cref="RResult.ProcessHandle"/>).
		/// </summary>
		NeedProcessHandle = 4,
		
		/// <summary>
		/// Run new process as administrator.
		/// <br/>If this process isn't admin:
		/// <br/>• Shows UAC consent dialog.
		/// <br/>• Uses verb <c>"runas"</c>, therefore other verb cannot be specified.
		/// <br/>• Cannot set current directory for the new process.
		/// <br/>• The new process does not inherit environment variables of this process.
		/// </summary>
		Admin = 8,
		
		/// <summary>
		/// If this process runs as administrator, run new process as administrator too.
		/// <br/>Without this flag, if this process runs as administrator:
		/// <br/>• Starts new process as non-administrator from the shell process (<c>explorer.exe</c>).
		/// <br/>• If it fails (for example if shell process isn't running), calls <see cref="print.warning"/> and starts new process as administrator.
		/// <br/>• The new process does not inherit environment variables of this process.
		/// </summary>
		InheritAdmin = 16,
		
		/// <summary>
		/// Add the app to the "Most used" list in the Start menu if launched often.
		/// </summary>
		MostUsed = 32,
	}
	
	/// <summary>
	/// More parameters for <see cref="run.it"/>.
	/// </summary>
	/// <remarks>
	/// Implicit conversion from <c>string</c> sets <see cref="CurrentDirectory"/>.
	/// </remarks>
	public class ROptions {
		/// <summary>
		/// Sets <see cref="CurrentDirectory"/>.
		/// </summary>
		public static implicit operator ROptions(string curDir) => new ROptions { CurrentDirectory = curDir };
		
		/// <summary>
		/// Initial current directory for the new process.
		/// If <c>null</c> (default), the new process will inherit the current directory of this process.
		/// If <c>""</c>, the function gets parent directory path from the <i>file</i> parameter, if possible (if full path is specified or found); if not possible, same as <c>null</c>.
		/// </summary>
		public string CurrentDirectory;
		
		/// <summary>
		/// File's right-click menu command, also known as verb. For example <c>"edit"</c>, <c>"print"</c>, <c>"properties"</c>.
		/// The default verb is bold in the menu.
		/// Not all menu items will work. Some may have different name than in the menu.
		/// </summary>
		public string Verb;
		
		/// <summary>
		/// Owner window for error message boxes.
		/// Also, new window should be opened on the same screen, but many programs ignore it.
		/// </summary>
		public AnyWnd OwnerWindow;
		
		/// <summary>
		/// Preferred window state.
		/// Many programs ignore it.
		/// </summary>
		public ProcessWindowStyle WindowState;
		
		/// <summary>
		/// Flags to add to <ms>SHELLEXECUTEINFO</ms> field <c>fMask</c>.
		/// Default flags: <c>SEE_MASK_NOZONECHECKS</c>, <c>SEE_MASK_NOASYNC</c>, <c>SEE_MASK_NOCLOSEPROCESS</c>, <c>SEE_MASK_CONNECTNETDRV</c>, <c>SEE_MASK_UNICODE</c>, <c>SEE_MASK_FLAG_NO_UI</c> (if no flag <c>ShowErrorUI</c>), <c>SEE_MASK_NO_CONSOLE</c> (if no flag <c>WaitForExit</c>), <c>SEE_MASK_FLAG_LOG_USAGE</c> (if flag <c>MostUsed</c>); also <c>SEE_MASK_INVOKEIDLIST</c> if need.
		/// </summary>
		public uint FlagsAdd;
		
		/// <summary>
		/// Flags to remove from <ms>SHELLEXECUTEINFO</ms> field <c>fMask</c>.
		/// Default flags: see <see cref="FlagsAdd"/>.
		/// </summary>
		public uint FlagsRemove;
		
		//no. If need, caller can get window and call EnsureInScreen etc.
		//public screen Screen;
		//this either does not work or I could not find a program that uses default window position (does not save/restore)
		//if(!more.Screen.IsNull) { x._14.hMonitor = more.Screen.ToDevice().Handle; x.fMask |= Api.SEE_MASK_HMONITOR; }
	}
	
	/// <summary>
	/// Results of <see cref="run.it"/>.
	/// </summary>
	public class RResult {
		/// <summary>
		/// The exit code of the process.
		/// </summary>
		/// <value>0 if no flag <c>WaitForExit</c> or if cannot wait.</value>
		/// <remarks>
		/// Usually the exit code is 0 or a process-defined error code.
		/// </remarks>
		public int ProcessExitCode { get; internal set; }
		
		/// <summary>
		/// The process id.
		/// </summary>
		/// <value>0 if used flag <c>WaitForExit</c> or if did not start new process (eg opened the document in an existing process) or if cannot get it.</value>
		public int ProcessId { get; internal set; }
		
		/// <summary>
		/// If used flag <c>NeedProcessHandle</c>, contains process handle. Later the <see cref="WaitHandle"/> variable must be disposed.
		/// </summary>
		/// <value><c>null</c> if no flag or if did not start new process (eg opened the document in an existing process) or if cannot get it.</value>
		/// <example>
		/// This code does the same as <c>run.it(@"notepad.exe", flags: SRFlags.WaitForExit);</c>
		/// <code><![CDATA[
		/// var r = run.it(@"notepad.exe", flags: SRFlags.NeedProcessHandle);
		/// using(var h = r.ProcessHandle) h?.WaitOne();
		/// ]]></code>
		/// </example>
		public WaitHandle ProcessHandle { get; internal set; }
		
		/// <summary>
		/// Returns <see cref="ProcessId"/> as string.
		/// </summary>
		public override string ToString() => ProcessId.ToString();
	}
}


================================================
FILE: Au/System/sound.cs
================================================
using Microsoft.Win32;

namespace Au {
	/// <summary>
	/// Plays short sounds and speaks text.
	/// </summary>
	public static class sound {
		/// <summary>
		/// Gets or sets the sound volume of this program. Percent 0-100 of the master volume.
		/// </summary>
		/// <exception cref="ArgumentException"></exception>
		/// <remarks>
		/// Used for speech and <c>.wav</c> files, but not for system sounds.
		/// Sets volume for each program seperately. The program remembers it after restarting. Note: all scripts with role <i>miniProgram</i> (default) run in the same program (<c>Au.Task.exe</c>).
		/// </remarks>
		public static int volume {
			get {
				Api.waveOutGetVolume(default, out var v);
				v &= 0xffff;
				return (int)Math.Round((double)v * 100 / 0xffff);
			}
			set {
				uint v = (uint)value;
				if (v > 100) throw new ArgumentException("Must be 0-100.");
				v = (uint)(0xffff * v / 100);
				Api.waveOutSetVolume(default, v << 16 | v);
			}
		}

		/// <summary>
		/// Plays a custom sound (<c>.wav</c> file).
		/// </summary>
		/// <param name="wavFile"><c>.wav</c> file.</param>
		/// <param name="async">Don't wait until the sound ends. Note: the sound ends when this process exits.</param>
		/// <param name="system">Use the sound volume channel "System Sounds". Then <see cref="volume"/> isn't used.</param>
		public static bool playWav(string wavFile, bool async = false, bool system = false) {
			var s = wavFile.NE() ? null : pathname.expand(wavFile);
			var f = Api.SND_FILENAME | Api.SND_NODEFAULT;
			if (async) f |= Api.SND_ASYNC;
			if (system) f |= Api.SND_SYSTEM;
			return Api.PlaySound(s, default, f);
		}

		/// <summary>
		/// Plays a system event sound.
		/// </summary>
		/// <param name="name">Sound event name. If <c>null</c>, displays all available names.</param>
		/// <param name="async">Don't wait until the sound ends. Note: the sound ends when this process exits.</param>
		/// <param name="system">Use the sound volume channel "System Sounds". Then <see cref="volume"/> isn't used.</param>
		/// <param name="orDefault">Play default sound if the specified sound not found or does not have a <c>.wav</c> file assigned.</param>
		/// <remarks>
		/// Sounds can be changed in the Control Panel's Sound dialog.
		/// </remarks>
		public static bool playEvent(string name, bool async = false, bool system = false, bool orDefault = false) {
			if (name == null) {
				using var k1 = Registry.CurrentUser.OpenSubKey(@"AppEvents\Schemes\Apps\.Default");
				foreach (var s in k1.GetSubKeyNames()) {
					using var k2 = k1.OpenSubKey(s + @"\.Current");
					if (k2?.GetValue("") is string file && file.Length > 0) {
						var label = Registry.GetValue(@"HKEY_CURRENT_USER\AppEvents\EventLabels\" + s, "", null) as string;
						print.it($"{s,-30}   {label,-30}   {file}");
					}
				}
				return false;
			} else {
				uint f = Api.SND_ALIAS;
				//f |= Api.SND_APPLICATION; //doesn't work. Plays only sounds from the ".Default" key, with or without this flag.
				if (!orDefault) f |= Api.SND_NODEFAULT;
				if (async) f |= Api.SND_ASYNC;
				if (system) f |= Api.SND_SYSTEM;
				return Api.PlaySound(name, default, f);
			}
		}

		/// <summary>
		/// Plays the system default sound.
		/// </summary>
		/// <remarks>
		/// Does not wait until the sound ends. The sound can continue even when this process ends.
		/// </remarks>
		public static void playDefault() {
			Api.MessageBeep(0x40);
		}

		/// <summary>
		/// Plays the system error sound.
		/// </summary>
		/// <remarks>
		/// Does not wait until the sound ends. The sound can continue even when this process ends.
		/// </remarks>
		public static void playError() {
			Api.MessageBeep(0x10);
		}

		//other system sounds now are silent or same as default.

		/// <summary>
		/// Generates sound of specified frequency and duration. Waits until it ends.
		/// </summary>
		/// <param name="freq">Frequency, 37-32767 hertz.</param>
		/// <param name="duration">Duration, in milliseconds.</param>
		/// <param name="async">Don't wait. Note: the sound ends when this process exits.</param>
		public static void beep(int freq, int duration, bool async = false) {
			if (async) {
				Task.Run(() => Api.Beep(freq, duration));
			} else {
				Api.Beep(freq, duration);
			}
		}

		/// <summary>
		/// Speaks text.
		/// </summary>
		/// <param name="text">Text to speak. If <c>null</c>, stops speaking.</param>
		/// <param name="async">Don't wait. Note: the sound ends when this process exits.</param>
		/// <param name="voice">
		/// A voice name from <b>Control Panel > Speech > Text to speech</b>. Can be partial, case-insensitive. Example: <c>"Zira"</c>.
		/// If <c>null</c>, uses default voice.
		/// Voice attributes can be specified using string format <c>"voice|reqAttr"</c> or <c>"voice|reqAttr|optAttr"</c>. Here <i>reqAttr</i> and <i>optAttr</i> are arguments for <google>ISpObjectTokenCategory.EnumTokens</google>. Each part can be empty. Example: <c>"|Gender=Female"</c>.
		/// </param>
		/// <param name="rate">Speed adjustment, +- 10.</param>
		/// <param name="volume">Volume, 0-100. See also <see cref="volume"/>.</param>
		/// <seealso cref="SpeakVoice"/>
#if true
		public static void speak(string text, bool async = false, string voice = null, int rate = 0, int volume = 100) {
			lock (s_lock) {
				s_voice?.Stop();
				if (text.NE()) return;

				s_voice ??= new SpeakVoice();
				if (voice != s_sVoice) s_voice.SetVoice_(s_sVoice = voice);
				s_voice.Rate = rate;
				s_voice.Volume = volume;
			}
			s_voice.Speak(text, async);
		}
		static string s_sVoice;
#else //use new SpVoice each time
	public static void speak(string text, bool async = false, string voice = null, int rate = 0, int volume = 100) {
		SpeakVoice v = null;
		lock (s_lock) {
			if (s_voice!=null) {
				s_voice.Dispose();
				s_voice=null;
			}
			if (text.NE()) return;
			
			v = new SpeakVoice(voice);
			if (rate != 0) v.Rate = rate;
			if (volume != 100) v.Volume = volume;
			
			s_voice=v;
		}
		v.Speak(text, async);
		if(!async) {
			lock (s_lock) { if (s_voice==v) { s_voice=null; v.Dispose(); } }
		}
		//else v.EndStream+=(o, e) => print.it("end"); //need to process messages
	}
#endif
		static SpeakVoice s_voice;
		static readonly object s_lock = new();
	}
}

namespace Au.More {
	/// <summary>
	/// Speaks text.
	/// </summary>
	/// <seealso cref="sound.speak"/>
	public class SpeakVoice : IDisposable {
		SAPI.ISpVoice _v;
		
		/// <summary>
		/// Creates a text-to-speech (speech synthesis) voice instance.
		/// </summary>
		/// <param name="voice">A voice name from <b>Control Panel > Speech > Text to speech</b>. Can be partial, case-insensitive. Example: <c>"Zira"</c>. If <c>null</c>, uses default voice.</param>
		public SpeakVoice(string voice = null) {
			_v = new SAPI.SpVoice() as SAPI.ISpVoice;
			GC.AddMemoryPressure(250_000);
			if (voice != null) SetVoice_(voice);
		}
		
		internal void SetVoice_(string voice) {
			if (!voice.NE()) {
				var cat = new SAPI.SpObjectTokenCategory() as SAPI.ISpObjectTokenCategory;
				cat.SetId(SAPI.SPCAT_VOICES, false);
				var a = voice.Split('|');
				voice = a[0];
				var et = cat.EnumTokens(a.Length > 1 && !a[1].NE() ? a[1] : null, a.Length > 2 && !a[2].NE() ? a[2] : null);
				for (int i = 0, n = et.GetCount(); i < n; i++) {
					var v = et.Item(i);
					if (!voice.NE()) {
						if (0 != v.OpenKey("Attributes", out var k)) continue;
						if (0 != k.GetStringValue("Name", out var s)) continue;
						if (s.Find(voice, true) < 0) continue;
					}
					_v.SetVoice(v);
					break;
				}
			} else _v.SetVoice(null);
		}
		
		///
		protected virtual void Dispose(bool disposing) {
			if (_v != null) {
				if (disposing) Marshal.ReleaseComObject(_v); //stops speaking if async
				_v = null;
				GC.RemoveMemoryPressure(250_000);
			}
		}
		
		///
		public void Dispose() {
			Stop();
			Dispose(true);
			GC.SuppressFinalize(this);
		}
		
		///
		~SpeakVoice() {
			//print.it("~");
			Dispose(false);
		}
		
		/// <summary>
		/// Gets or sets the speed adjustment, +- 10.
		/// </summary>
		public int Rate {
			get => _v.GetRate();
			set { _v.SetRate(value); }
		}
		
		/// <summary>
		/// Gets or sets the volume, 0-100. See also <see cref="sound.volume"/>.
		/// </summary>
		public int Volume {
			get => _v.GetVolume();
			set { _v.SetVolume((ushort)value); }
		}
		
		/// <summary>
		/// Pauses speaking.
		/// </summary>
		public void Pause() => _v.Pause();
		
		/// <summary>
		/// Resumes speaking.
		/// </summary>
		public void Resume() => _v.Resume();
		
		/// <summary>
		/// Skips <i>count</i> milliseconds of speech.
		/// </summary>
		/// <param name="count">Forward if positive, else backward.</param>
		public void SkipMilliseconds(int count) => _v.Skip("MILLISECOND", count);
		
		/// <summary>
		/// Skips <i>count</i> sentences of speech.
		/// </summary>
		/// <param name="count">Forward if positive, else backward. If 0, repeats current sentence.</param>
		public void SkipSentence(int count) => _v.Skip("SENTENCE", count);
		
		/// <summary>
		/// Stops speaking.
		/// </summary>
		public void Stop() => SkipSentence(int.MaxValue);
		
		/// <summary>
		/// Returns <c>true</c> if currently is speaking. Returns <c>false</c> if finished or not started.
		/// </summary>
		public bool IsSpeaking => _RunningState() == SAPI.SpeechRunState.SRSEIsSpeaking;
		
		/// <summary>
		/// Returns <c>true</c> if finished speaking.
		/// </summary>
		public bool IsDone => _RunningState() == SAPI.SpeechRunState.SRSEDone;
		
		SAPI.SpeechRunState _RunningState() {
			_v.GetStatus(out var r);
			return r.RunningState;
		}
		
		/// <summary>
		/// Waits until the async speech ends.
		/// </summary>
		/// <param name="msTimeout">Timeout milliseconds, or -1.</param>
		public bool WaitUntilDone(int msTimeout) => 0 == _v.WaitUntilDone(msTimeout);
		
		/// <summary>
		/// Speaks the specified text.
		/// </summary>
		/// <param name="text">Text to speak.</param>
		/// <param name="async">Don't wait. Note: the sound ends when this process exits.</param>
		public void Speak(string text, bool async = false) {
			Speak(text, async ? SVFlags.ASYNC : 0);
		}
		
		/// <summary>
		/// Speaks the specified text.
		/// </summary>
		/// <param name="text">Text to speak.</param>
		/// <param name="flags"></param>
		public void Speak(string text, SVFlags flags) {
			if (flags.Has(SVFlags.IS_FILENAME)) text = pathname.expand(text);
			_v.Speak(text, (uint)flags);
			GC.KeepAlive(this);
			if (flags.Has(SVFlags.ASYNC)) { //protect from GC while speaking
				Task.Run(() => { _v.WaitUntilDone(-1); GC.KeepAlive(this); });
			}
		}
	}
	
	//Easier would be to use the SAPI type library, but it creates problems, eg dotnet pack fails.
	unsafe class SAPI : NativeApi {
		[ComImport, Guid("6C44DF74-72B9-4992-A1EC-EF996E0422D4"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
		internal interface ISpVoice {
			void _0();
			void _1();
			void _2();
			void _3();
			void _4();
			void _5();
			void _6();
			void _7();
			void _8();
			void _9();
			void _a();
			void _b();
			void _c();
			void Pause();
			void Resume();
			void SetVoice(ISpObjectToken pToken);
			void _d();
			int Speak([MarshalAs(UnmanagedType.LPWStr)] string pwcs, uint dwFlags);
			void _e();
			void GetStatus(out SPVOICESTATUS pStatus, nint ppszLastBookmark = 0);
			int Skip([MarshalAs(UnmanagedType.LPWStr)] string pItemType, int lNumItems);
			void _f();
			void _g();
			void _h();
			void _i();
			void SetRate(int RateAdjust);
			int GetRate();
			void SetVolume(ushort usVolume);
			ushort GetVolume();
			[PreserveSig] int WaitUntilDone(int msTimeout);
		}
		
		internal struct SPVOICESTATUS {
			fixed uint _1[3];
			public SpeechRunState RunningState;
			fixed uint _2[9];
		}
		
		[ComImport, Guid("14056589-E16C-11D2-BB90-00C04F8EE6C0"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
		internal interface ISpObjectToken {
			void _0();
			void _1();
			void _2();
			void _3();
			void _4();
			void _5();
			[PreserveSig] int OpenKey([MarshalAs(UnmanagedType.LPWStr)] string pszSubKeyName, out ISpDataKey ppSubKey);
		}
		
		[ComImport, Guid("2D3D3845-39AF-4850-BBF9-40B49780011D"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
		internal interface ISpObjectTokenCategory {
			void _0();
			void _1();
			void _2();
			void _3();
			void _4();
			void _5();
			void _6();
			void _7();
			void _8();
			void _9();
			void _a();
			void _b();
			void SetId([MarshalAs(UnmanagedType.LPWStr)] string pszCategoryId, [MarshalAs(UnmanagedType.Bool)] bool fCreateIfNotExist);
			void _c();
			void _d();
			IEnumSpObjectTokens EnumTokens([MarshalAs(UnmanagedType.LPWStr)] string pzsReqAttribs, [MarshalAs(UnmanagedType.LPWStr)] string pszOptAttribs);
		}
		
		[ComImport, Guid("14056581-E16C-11D2-BB90-00C04F8EE6C0"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
		internal interface ISpDataKey {
			void _0();
			void _1();
			void _2();
			[PreserveSig] int GetStringValue([MarshalAs(UnmanagedType.LPWStr)] string pszValueName, [MarshalAs(UnmanagedType.LPWStr)] out string s);
		}
		
		[ComImport, Guid("06B64F9E-7FDA-11D2-B4F2-00C04F797396"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
		internal interface IEnumSpObjectTokens {
			void _0();
			void _1();
			void _2();
			void _3();
			ISpObjectToken Item(int Index);
			int GetCount();
		}
		
		[ComImport, Guid("96749377-3391-11D2-9EE3-00C04F797396"), ClassInterface(ClassInterfaceType.None)]
		internal class SpVoice { }
		
		internal enum SpeechRunState {
			SRSEDone = 1,
			SRSEIsSpeaking
		}
		
		[ComImport, Guid("A910187F-0C7A-45AC-92CC-59EDAFB77B53"), ClassInterface(ClassInterfaceType.None)]
		internal class SpObjectTokenCategory { }
		
		internal const string SPCAT_VOICES = "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Speech\\Voices";
	}
}

namespace Au.Types {
	/// <summary>
	/// Flags for <see cref="sound.speak"/>. See <ms>SPEAKFLAGS</ms>.
	/// </summary>
	[Flags]
	public enum SVFlags {
#pragma warning disable 1591 //XML doc
		ASYNC = 0x0001,
		PURGEBEFORESPEAK = 0x0002,
		IS_FILENAME = 0x0004,
		IS_XML = 0x0008,
		IS_NOT_XML = 0x0010,
		PERSIST_XML = 0x0020,
		NLP_SPEAK_PUNC = 0x0040,
		PARSE_SAPI = 0x0080,
		PARSE_SSML = 0x0100,
#pragma warning restore
	}
}


================================================
FILE: Au/System/uacInfo.cs
================================================
namespace Au {
	/// <summary>
	/// Gets [](xref:uac) integrity level and other security info of this and other processes.
	/// </summary>
	/// <remarks>
	/// An <c>uacInfo</c> variable contains a process access token handle that is used to get security info. Always dispose <c>uacInfo</c> variables to close the handle.
	/// </remarks>
	public sealed class uacInfo : IDisposable {
		///
		~uacInfo() => _htoken.Dispose();

		///
		public void Dispose() {
			_htoken.Dispose();
			GC.SuppressFinalize(this);
		}

		Handle_ _htoken;
		HandleRef _HtokenHR => new HandleRef(this, _htoken);

		/// <summary>
		/// The access token handle.
		/// </summary>
		/// <remarks>
		/// The handle is managed by this variable and will be closed when disposing or GC-collecting it. Use <see cref="GC.KeepAlive"/> where need.
		/// </remarks>
		public IntPtr UnsafeTokenHandle => _htoken;

		/// <summary>
		/// Returns <c>true</c> if the last called property function failed.
		/// Normally it should never fail. Only <see cref="ofProcess"/> can fail (then it returns <c>null</c>).
		/// </summary>
		public bool Failed { get; private set; }

		/// <summary>
		/// Gets the [](xref:uac) elevation type of the process.
		/// </summary>
		public UacElevation Elevation {
			get {
				if (_haveElevation == 0) {
					unsafe {
						UacElevation elev;
						if (!Api.GetTokenInformation(_HtokenHR, Api.TOKEN_INFORMATION_CLASS.TokenElevationType, &elev, 4, out _)) _haveElevation = 2;
						else {
							_haveElevation = 1;
							_Elevation = elev;
						}
					}
				}
				if (Failed = (_haveElevation == 2)) return UacElevation.Unknown;
				return _Elevation;
			}
		}
		UacElevation _Elevation; byte _haveElevation;

		/// <summary>
		/// Returns <c>true</c> if the process has [](xref:uac) uiAccess property.
		/// A uiAccess process can access/automate all windows of processes running in the same user session.
		/// </summary>
		/// <remarks>
		/// Most processes don't have this property. They cannot access/automate windows of higher integrity level (High, System, uiAccess) processes and Windows 8 store apps. For example, cannot send keys and Windows messages.
		/// Note: High IL (admin) processes also can have this property, therefore <c>IsUIAccess</c> is not the same as <c>IntegrityLevel==IL.UIAccess</c> (<see cref="IntegrityLevel"/> returns <c>UIAccess</c> only for Medium+uiAccess processes; for High+uiAccess processes it returns <c>High</c>). Some Windows API work slightly differently with uiAccess and non-uiAccess admin processes.
		/// This property is rarely useful. Instead use other properties of this class.
		/// </remarks>
		public bool IsUIAccess {
			get {
				if (_haveIsUIAccess == 0) {
					unsafe {
						uint uia;
						if (!Api.GetTokenInformation(_HtokenHR, Api.TOKEN_INFORMATION_CLASS.TokenUIAccess, &uia, 4, out var siz)) _haveIsUIAccess = 2;
						else {
							_haveIsUIAccess = 1;
							_isUIAccess = uia != 0;
						}
					}
				}
				if (Failed = (_haveIsUIAccess == 2)) return false;
				return _isUIAccess;
			}
		}
		bool _isUIAccess; byte _haveIsUIAccess;

		//not very useful. Returns false for ApplicationFrameWindow. Can use wnd.IsWindows10StoreApp.
		///// <summary>
		///// Returns <c>true</c> if the process is a Windows Store app.
		///// </summary>
		//public unsafe bool IsAppContainer
		//{
		//	get
		//	{
		//		if(!osVersion.minWin8) return false;
		//		uint isac;
		//		if(Failed = !Api.GetTokenInformation(_HtokenHR, Api.TOKEN_INFORMATION_CLASS.TokenIsAppContainer, &isac, 4, out var siz)) return false;
		//		return isac != 0;
		//	}
		//}

		static class _Api {
#pragma warning disable 649
			internal struct TOKEN_MANDATORY_LABEL { public IntPtr Sid; public uint Attributes; }
#pragma warning restore 649
			internal const uint SECURITY_MANDATORY_UNTRUSTED_RID = 0x00000000;
			internal const uint SECURITY_MANDATORY_LOW_RID = 0x00001000;
			internal const uint SECURITY_MANDATORY_MEDIUM_RID = 0x00002000;
			internal const uint SECURITY_MANDATORY_MEDIUM_PLUS_RID = SECURITY_MANDATORY_MEDIUM_RID + 0x100;
			internal const uint SECURITY_MANDATORY_HIGH_RID = 0x00003000;
			internal const uint SECURITY_MANDATORY_SYSTEM_RID = 0x00004000;
			internal const uint SECURITY_MANDATORY_PROTECTED_PROCESS_RID = 0x00005000;
		}

		/// <summary>
		/// Gets the [](xref:uac) integrity level (IL) of the process.
		/// </summary>
		/// <remarks>
		/// IL from lowest to highest value: <c>Untrusted</c>, <c>Low</c>, <c>Medium</c>, <c>UIAccess</c>, <c>High</c>, <c>System</c>, <c>Protected</c>, <c>Unknown</c>.
		/// The IL enum member values can be used like <c>if(x.IntegrityLevel > IL.Medium) ...</c> .
		/// If UAC is turned off, most non-service processes on administrator account have High IL; on non-administrator - Medium.
		/// </remarks>
		public UacIL IntegrityLevel => _GetIntegrityLevel();
		UacIL _GetIntegrityLevel() {
			if (_haveIntegrityLevel == 0) {
				unsafe {
					Api.GetTokenInformation(_HtokenHR, Api.TOKEN_INFORMATION_CLASS.TokenIntegrityLevel, null, 0, out var siz);
					if (lastError.code != Api.ERROR_INSUFFICIENT_BUFFER) _haveIntegrityLevel = 2;
					else {
						var b = stackalloc byte[(int)siz];
						var tml = (_Api.TOKEN_MANDATORY_LABEL*)b;
						if (!Api.GetTokenInformation(_HtokenHR, Api.TOKEN_INFORMATION_CLASS.TokenIntegrityLevel, tml, siz, out siz)) _haveIntegrityLevel = 2;
						uint x = *Api.GetSidSubAuthority(tml->Sid, (uint)(*Api.GetSidSubAuthorityCount(tml->Sid) - 1));

						if (x < _Api.SECURITY_MANDATORY_LOW_RID) _integrityLevel = UacIL.Untrusted;
						else if (x < _Api.SECURITY_MANDATORY_MEDIUM_RID) _integrityLevel = UacIL.Low;
						else if (x < _Api.SECURITY_MANDATORY_HIGH_RID) _integrityLevel = UacIL.Medium;
						else if (x < _Api.SECURITY_MANDATORY_SYSTEM_RID) {
							if (IsUIAccess && Elevation != UacElevation.Full) _integrityLevel = UacIL.UIAccess; //fast. Note: don't use if(andUIAccess) here.
							else _integrityLevel = UacIL.High;
						} else if (x < _Api.SECURITY_MANDATORY_PROTECTED_PROCESS_RID) _integrityLevel = UacIL.System;
						else _integrityLevel = UacIL.Protected;
					}
				}
			}
			if (Failed = (_haveIntegrityLevel == 2)) return UacIL.Unknown;
			return _integrityLevel;
		}
		UacIL _integrityLevel; byte _haveIntegrityLevel;

		uacInfo(Handle_ hToken) => _htoken = hToken;

		static uacInfo _Create(IntPtr hProcess) {
			if (!Api.OpenProcessToken(hProcess, Api.TOKEN_QUERY | Api.TOKEN_QUERY_SOURCE, out Handle_ hToken)) return null;
			return new uacInfo(hToken);
		}

		/// <summary>
		/// Opens process access token and creates/returns new <see cref="uacInfo"/> variable that holds it. Then you can use its properties.
		/// </summary>
		/// <returns><c>null</c> if failed. For example fails for services and some other processes if current process is not administrator.</returns>
		/// <param name="processId">Process id. If you have a window, use <see cref="wnd.ProcessId"/>.</param>
		/// <remarks>
		/// To get <see cref="uacInfo"/> of this process, use <see cref="ofThisProcess"/>.
		/// </remarks>
		public static uacInfo ofProcess(int processId) {
			if (processId == 0) return null;
			using var hp = Handle_.OpenProcess(processId);
			if (hp.Is0) return null;
			return _Create(hp);
		}

		/// <summary>
		/// Gets <see cref="uacInfo"/> variable for this process.
		/// </summary>
		public static uacInfo ofThisProcess {
			get {
				if (s_thisProcess == null) {
					s_thisProcess = _Create(Api.GetCurrentProcess());
					Debug.Assert(s_thisProcess != null);
				}
				return s_thisProcess;
			}
		}
		static uacInfo s_thisProcess;

		/// <summary>
		/// Returns <c>true</c> if this process is running as administrator.
		/// </summary>
#if true
		public static bool isAdmin => s_isAdmin ??= Api.IsUserAnAdmin();
#else //too slow, eg 15 ms vs 1 ms
		public static bool IsAdmin {
			get {
				if(!s_isAdmin.HasValue) {
					try {
						WindowsIdentity id = WindowsIdentity.GetCurrent();
						WindowsPrincipal principal = new WindowsPrincipal(id);
						s_isAdmin = principal.IsInRole(WindowsBuiltInRole.Administrator);
					}
					catch { }
				}
				return s_isAdmin.GetValueOrDefault();
			}
		}
#endif
		static bool? s_isAdmin;

		/*
		public struct SID_IDENTIFIER_AUTHORITY
		{
			public byte b0, b1, b2, b3, b4, b5;
		}

		[DllImport("advapi32.dll")]
		internal static extern bool AllocateAndInitializeSid(in SID_IDENTIFIER_AUTHORITY pIdentifierAuthority, byte nSubAuthorityCount, uint nSubAuthority0, uint nSubAuthority1, uint nSubAuthority2, uint nSubAuthority3, uint nSubAuthority4, uint nSubAuthority5, uint nSubAuthority6, uint nSubAuthority7, out IntPtr pSid);

		[DllImport("advapi32.dll")]
		internal static extern bool CheckTokenMembership(IntPtr TokenHandle, IntPtr SidToCheck, out bool IsMember);

		[DllImport("advapi32.dll")]
		internal static extern IntPtr FreeSid(IntPtr pSid);

		public const int SECURITY_BUILTIN_DOMAIN_RID = 32;
		public const int DOMAIN_ALIAS_RID_ADMINS = 544;

		//This is from CheckTokenMembership reference.
		//In QM2 it is very fast, but here quite slow first time, although then becomes the fastest. Advapi32.dll is already loaded, but maybe it loads other dlls.
		//IsUserAnAdmin first time can be slowest. It loads shell32.dll.
		//The .NET principal etc first time usually is fastest, althoug later is slower several times. (old info)
		//All 3 tested on admin and user accounts, also when UAC is turned off, also with System IL.
		public static bool isAdmin
		{
			get
			{
				var NtAuthority = new SID_IDENTIFIER_AUTHORITY() { b5 = 5 }; //SECURITY_NT_AUTHORITY
				IntPtr AdministratorsGroup;
				if(!AllocateAndInitializeSid(NtAuthority, 2,
					SECURITY_BUILTIN_DOMAIN_RID, DOMAIN_ALIAS_RID_ADMINS,
					0, 0, 0, 0, 0, 0,
					out AdministratorsGroup
					))
					return false;
				bool _r;
				if(!CheckTokenMembership(default, AdministratorsGroup, out _r)) _r = false;
				FreeSid(AdministratorsGroup);
				return _r;
			}
		}
		*/

		/// <summary>
		/// Returns <c>true</c> if [](xref:uac) is disabled (turned off) completely (not just disabled UAC consent screen/dialog).
		/// </summary>
		public static bool isUacDisabled {
			get {
				if (!_haveIsUacDisabled) {
					_isUacDisabled = _IsUacDisabled();
					_haveIsUacDisabled = true;
				}
				return _isUacDisabled;
			}
		}

		static bool _isUacDisabled, _haveIsUacDisabled;
		static bool _IsUacDisabled() {
			//if(osVersion.minWin8) return false; //UAC cannot be disabled so easily, but can
			uacInfo x = ofThisProcess;
			switch (x.Elevation) {
			case UacElevation.Full:
			case UacElevation.Limited:
				return false;
			}
			//if(x.IsUIAccess) return false; //uiAccess in non-admin user session. Rare.

			int r = 1;
			try {
				if (!Api.GetDelegate(out Api.CheckElevationEnabled d, "kernel32.dll", "CheckElevationEnabled") || 0 != d(out r)) {
					Debug_.Print("CheckElevationEnabled");
					r = Microsoft.Win32.Registry.GetValue(@"HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\System", "EnableLUA", null) is int v ? v : 1;
				}
			}
			catch (Exception e) { Debug_.Print(e); }
			return r == 0;
		}
	}
}

namespace Au.Types {
	/// <summary>
	/// UAC integrity level.
	/// See <see cref="uacInfo.IntegrityLevel"/>.
	/// </summary>
	public enum UacIL {
		/// <summary>The most limited rights. Rare.</summary>
		Untrusted,

		/// <summary>Very limited rights. Used by web browser tab processes, Windows Store apps.</summary>
		Low,

		/// <summary>Limited rights. Most processes (unless UAC turned off).</summary>
		Medium,

		/// <summary>Medium IL + can access/automate High IL windows (user interface).</summary>
		UIAccess,

		/// <summary>Most rights. Processes that run as administrator.</summary>
		High,

		/// <summary>Almost all rights. Services, some system processes.</summary>
		System,

		/// <summary>Undocumented. Rare.</summary>
		Protected,

		/// <summary>Failed to get IL. Unlikely.</summary>
		Unknown = 100
	}

	/// <summary>
	/// <see cref="uacInfo.Elevation"/>.
	/// </summary>
	public enum UacElevation {
		/// <summary>Failed to get. Normally it never happens.</summary>
		Unknown,

		/// <summary>
		/// Processes in this user session cannot be elevated.
		/// Can be: non-administrator user session (processes have limited rights); service session (processes have all rights); UAC is turned off (most processes have administrator rights).
		/// </summary>
		Default,

		/// <summary>Runs as administrator (<c>High</c> or <c>System</c> integrity level, see <see cref="UacIL"/>), and UAC is not turned off. Also known as "elevated".</summary>
		Full,

		/// <summary>Runs as standard user (<c>Medium</c>, <c>UIAccess</c> or <c>Low</c> integrity level, see <see cref="UacIL"/>) in administrator user session (because of UAC).</summary>
		Limited
	}
}


================================================
FILE: Au/Time/WaitLoop.cs
================================================
namespace Au.More {
	/// <summary>
	/// Can be used to easily implement "wait for" functions with a timeout.
	/// </summary>
	/// <remarks>
	/// See examples. The code works like most "wait for" functions of this library: throws exception when timed out, unless the timeout value is negative.
	/// Similar code is used by <see cref="wait.until"/> and many other "wait for" functions of this library.
	/// </remarks>
	/// <example>
	/// <code><![CDATA[
	/// public static bool WaitForMouseLeftButtonDown(Seconds timeout) {
	/// 	var x = new WaitLoop(timeout);
	/// 	for(; ; ) {
	/// 		if(mouse.isPressed(MButtons.Left)) return true;
	/// 		if(!x.Sleep()) return false;
	/// 	}
	/// }
	/// ]]></code>
	/// The same with <see cref="wait.until"/>.
	/// <code><![CDATA[
	/// static bool WaitForMouseLeftButtonDown2(Seconds timeout) {
	/// 	return wait.until(timeout, () => mouse.isPressed(MButtons.Left));
	/// }
	/// ]]></code>
	/// </example>
	public struct WaitLoop {
		long _timeRemaining, _timePrev;
		bool _hasTimeout, _throw, _doEvents, _precisionIsSet;
		float _step;
		
		/// <summary>
		/// Sets timeout and possibly more wait parameters.
		/// </summary>
		/// <param name="timeout">Timeout in seconds, like <c>3</c> or <c>0.5</c>. Or a <c>Seconds</c> variable containing timeout etc, like <c>new(3, period: 5)</c>. If timeout is 0, will wait indefinitely. If <c>></c> 0, <see cref="Sleep"/> throws <see cref="TimeoutException"/> when timed out. If &lt; 0, <c>Sleep</c> then returns <c>false</c> instead.</param>
		public WaitLoop(Seconds timeout) {
			Period = timeout.Period ?? 10;
			_step = Period / 10f;
			MaxPeriod = timeout.MaxPeriod ?? Period * 50f;
			_doEvents = timeout.DoEvents ?? opt.wait.DoEvents; //use opt.wait fbc
			Cancel = timeout.Cancel;
			
			double t = timeout.Time;
			if (_hasTimeout = !(t is 0d or > 9223372036854775d or < -9223372036854775d)) { //long.MaxValue/1000 = 292_471_208 years
				_throw = t > 0 && !timeout.noException_;
				_timeRemaining = (long)(Math.Abs(t) * 1000d);
				_timePrev = computer.tickCountWithoutSleep;
			}
		}
		
		/// <param name="secondsTimeout">Timeout in seconds. If 0, will wait indefinitely. If <c>></c> 0, <see cref="Sleep"/> throws <see cref="TimeoutException"/> when timed out. If &lt; 0, <c>Sleep</c> then returns <c>false</c> instead.</param>
		/// <param name="options">Options. If <c>null</c>, uses <see cref="opt.wait"/>.</param>
		[Obsolete, EditorBrowsable(EditorBrowsableState.Never)]
		public WaitLoop(double secondsTimeout, OWait options) : this(new(secondsTimeout) { Period = (options ?? opt.wait).Period, DoEvents = (options ?? opt.wait).DoEvents }) { }
		
		/// <summary>
		/// Current period (<see cref="Sleep"/> sleep time). Milliseconds.
		/// Initially it is <see cref="Seconds.Period"/>, or 10 ms if it was <c>null</c>. Then each <see cref="Sleep"/> increments it until <see cref="MaxPeriod"/>.
		/// </summary>
		public float Period { get; set; }
		
		/// <summary>
		/// Maximal period (<see cref="Sleep"/> sleep time). Milliseconds.
		/// Initially it is <see cref="Seconds.MaxPeriod"/>, or <see cref="Period"/> <c>*</c> 50 if it is <c>null</c> (eg <c>10*50=500</c>).
		/// </summary>
		public float MaxPeriod { get; set; }
		
		/// <summary>
		/// Gets or sets the remaining time. Milliseconds.
		/// </summary>
		public long TimeRemaining { get => _timeRemaining; set => _timeRemaining = value; }
		
		/// <summary>
		/// Calls <see cref="IsTimeout"/>. If it returns <c>true</c>, returns <c>false</c>.
		/// Else sleeps <see cref="Period"/> milliseconds, increments <c>Period</c> if it is less than <see cref="MaxPeriod"/>, and returns <c>true</c>.
		/// </summary>
		/// <exception cref="TimeoutException">The timeout time has expired (if > 0).</exception>
		public unsafe bool Sleep() {
			if (IsTimeout()) return false;
			int t = (int)Period;
			
			if (t < 10 && !_precisionIsSet) { //default Period is 10
				_precisionIsSet = true;
				wait.SleepPrecision_.TempSet1();
			}
			
			if (Cancel.CanBeCanceled && t > 100) { //t > 100: avoid creating Cancel.WaitHandle while period is small. By default will create after ~5 s.
				var h = Cancel.WaitHandle.SafeWaitHandle.DangerousGetHandle();
				int r = wait.Wait_(t, _doEvents ? WHFlags.DoEvents : 0, new ReadOnlySpan<IntPtr>(&h, 1));
				if (r == 0) Cancel.ThrowIfCancellationRequested();
				if (r != Api.WAIT_TIMEOUT) throw new AuException(0);
			} else {
				Cancel.ThrowIfCancellationRequested();
				if (_doEvents) {
					wait.doEvents(t);
				} else {
					Thread.Sleep(t);
				}
				Cancel.ThrowIfCancellationRequested();
			}
			
			if (Period < MaxPeriod) Period += _step;
			return true;
		}
		
		/// <summary>
		/// If the timeout time is not expired, returns <c>false</c>.
		/// Else if the timeout was negative, returns <c>true</c>.
		/// Else throws <see cref="TimeoutException"/>.
		/// </summary>
		/// <exception cref="TimeoutException"></exception>
		public bool IsTimeout() {
			if (!_hasTimeout) return false;
			var t = computer.tickCountWithoutSleep;
			_timeRemaining -= t - _timePrev;
			_timePrev = t;
			if (_timeRemaining > 0) return false;
			if (_throw) throw new TimeoutException();
			return true;
		}
		
		/// <summary>
		/// Can be used to cancel the wait operation.
		/// </summary>
		public CancellationToken Cancel { get; set; }
	}
}

namespace Au.Types {
	/// <summary>
	/// Used with wait functions. Contains a wait timeout in seconds, and possibly wait options.
	/// </summary>
	/// <remarks>
	/// Many wait functions of this library internally use <see cref="WaitLoop"/>. They have a timeout parameter of <c>Seconds</c> type which allows to pass timeout and more options to <c>WaitLoop</c> in single parameter. You can pass a <c>Seconds</c> variable, like <c>new(3, period: 5)</c>. If don't need options etc, you can pass just timeout, like <c>3</c> or <c>0.5</c>.
	///
	/// Other wait functions have a timeout parameter of <c>Seconds</c> type but instead of <c>WaitLoop</c> use various hooks, events, Windows wait API, etc. They support only these <c>Seconds</c> properties: <c>Time</c>, <c>Cancel</c>, maybe <c>DoEvents</c>. Some always work like with <c>DoEvents</c> <c>true</c>.
	///
	/// More info: [](xref:wait_timeout).
	/// </remarks>
	/// <example>
	/// <code><![CDATA[
	/// var w = wnd.find(new Seconds(3) { Period = 5, MaxPeriod = 50 }, "Name");
	/// ]]></code>
	/// <code><![CDATA[
	/// var to = new Seconds(0) { MaxPeriod = 50 };
	/// wait.until(to, () => keys.isCtrl );
	/// wait.until(to with { Time = 30 }, () => keys.isCtrl );
	/// ]]></code>
	/// </example>
	public struct Seconds {
		float _time;
		int _period, _maxPeriod;
		byte _doEvents;
		//bool _inited;
		internal bool noException_;
		//Now Unsafe.SizeOf is 24.
		//	Don't use bool? etc. Nullable<T> takes at least 8 bytes if the struct also has a managed-type field.
		
		/// <summary>
		/// Sets timeout.
		/// Example: <c>var w = wnd.find(new Seconds(3) { Period = 5, MaxPeriod = 50 }, "Name");</c>.
		/// </summary>
		/// <param name="time">
		/// Timeout, in seconds.
		/// Negative value means "don't throw exception when timed out".
		/// Value 0 means "wait indefinitely" when used with <c>WaitX</c> functions; with <c>FindX</c> functions it means "don't wait".
		/// More info: [](xref:wait_timeout).
		/// </param>
		public Seconds(double time) {
			_time = (float)time;
			//_inited = true;
		}
		
		///
		public static implicit operator Seconds(double time) => new(time);
		
		/// <summary>
		/// Timeout, in seconds.
		/// Negative value means "don't throw exception when timed out".
		/// Value 0 means "wait indefinitely" when used with <c>WaitX</c> functions; with <c>FindX</c> functions it means "don't wait".
		/// More info: [](xref:wait_timeout).
		/// </summary>
		public double Time {
			get => _time;
			set { _time = (float)value; }
		}
		
		/// <summary>
		/// The sleep time between checking the wait condition periodically. Milliseconds.
		/// If <c>null</c>, will be used a value that usually is best for that wait function, in most cases 10.
		/// </summary>
		/// <remarks>
		/// Most wait functions of this library use <see cref="WaitLoop"/>, which repeatedly checks the wait condition and sleeps (waits) several ms. This property sets the initial sleep time (<see cref="WaitLoop.Period"/>), which then is incremented by <c>Period/10</c> ms in each loop until reaches <see cref="WaitLoop.MaxPeriod"/>, which is <c>Period*50</c> by default.
		/// This property makes the response time shorter or longer. If less than the default value, makes it shorter (faster response), but increases CPU usage; if greater, makes it longer (slower response).
		/// </remarks>
		public int? Period {
			get => _period != 0 ? _period : null;
			set { _period = value.HasValue ? Math.Max(1, value.Value) : 0; }
		}
		
		/// <summary>
		/// Sets <see cref="WaitLoop.MaxPeriod"/>.
		/// If <c>null</c> (default), it will use <c>Period*50</c>.
		/// </summary>
		public int? MaxPeriod {
			get => _maxPeriod != 0 ? _maxPeriod : null;
			set { _maxPeriod = value.HasValue ? Math.Max(1, value.Value) : 0; }
		}
		
		/// <summary>
		/// Use <see cref="wait.doEvents(int)"/> instead of <see cref="wait.ms"/>.
		/// If <c>null</c>, will be used <c>false</c>.
		/// </summary>
		public bool? DoEvents {
			get => _doEvents != 0 ? _doEvents == 1 : null;
			set { _doEvents = value switch { true => 1, false => 2, _ => 0 }; }
		}
		
		/// <summary>
		/// Can be used to cancel the wait operation.
		/// </summary>
		public CancellationToken Cancel { get; set; }
		
		///// <summary>
		///// Returns <c>true</c> if ctor wasn't called.
		///// </summary>
		//internal bool IsNull_ => !_inited;
		
		/// <summary>
		/// Sets <c>noException_ = true</c> and returns <c>Time == 0d</c>.
		/// </summary>
		internal bool Exists_() {
			noException_ = true;
			return _time == 0d;
		}
		
		/// <summary>
		/// If <c>Time &lt; 0</c>, returns <c>false</c>, else throws <see cref="NotFoundException"/>.
		/// </summary>
		internal bool ReturnFalseOrThrowNotFound_() => Time < 0 ? false : throw new NotFoundException();
		//internal T ReturnOrThrowNotFound_<T>(T def) => Time < 0 ? def : throw new NotFoundException();
	}
}


================================================
FILE: Au/Time/perf.cs
================================================
//#define PREPAREMETHOD //now slow anyway. Does not JIT everything.

namespace Au {
	/// <summary>
	/// Code execution time measurement with high precision (API <ms>QueryPerformanceCounter</ms>).
	/// </summary>
	public static unsafe class perf {
		//info: we don't use Stopwatch. It used to load System.dll (before .NET Core, now don't know), which is slow and can make speed measurement incorrect and confusing in some cases.
		
		static readonly double s_freqMCS = Api.QueryPerformanceFrequency(out long f) ? 1_000_000d / f : 0d, s_freqMS = s_freqMCS / 1000d;
		//note: don't use static ctor. Makes some simplest functions much slower.
		
		/// <summary>
		/// Gets the number of microseconds elapsed since Windows startup. Uses the high-resolution system timer (API <ms>QueryPerformanceCounter</ms>).
		/// </summary>
		/// <remarks>
		/// This function is used to measure time differences with 1 microsecond precision, like <c>var t1=perf.mcs; ... var t2=perf.mcs; var diff=t2-t1;</c>.
		/// Independent of computer clock time changes.
		/// See also: <ms>Acquiring high-resolution time stamps</ms>.
		/// </remarks>
		/// <seealso cref="perf"/>
		public static long mcs { get { Api.QueryPerformanceCounter(out var t); return (long)(t * s_freqMCS); } }
		//On current OS and hardware QueryPerformanceCounter is reliable and fast enough.
		//Speed of 1000 calls when cold CPU: PerfMilliseconds 97, WinMillisecondsWithoutSleep 76, WinMilliseconds64/GetTickCount64 12.
		//The double cast/multiply/cast is fast. The API is much much slower. And Math.BigMul is much slower.
		//rejected: make corrections based on GetTickCount64. It makes slower and is not necessary.
		
		/// <summary>
		/// Gets the number of milliseconds elapsed since Windows startup. Uses the high-resolution system timer (API <ms>QueryPerformanceCounter</ms>).
		/// </summary>
		/// <remarks>
		/// This function is used to measure time differences with 1 ms precision, like <c>var t1=perf.ms; ... var t2=perf.ms; var diff=t2-t1;</c>.
		/// The return value equals <see cref="mcs"/>/1000 but is slightly different than of <see cref="Environment.TickCount64"/> and most Windows API. Never compare times returned by different functions.
		/// Independent of computer clock time changes.
		/// </remarks>
		public static long ms { get { Api.QueryPerformanceCounter(out var t); return (long)(t * s_freqMS); } }
		
		/// <summary>
		/// Performs time measurements and stores measurement data.
		/// </summary>
		/// <remarks>
		/// Static functions of <see cref="perf"/> class use a single static variable of this type to perform measurements.
		/// Use a variable of this type instead when you want to have multiple independent measurements. See <see cref="perf.local"/>.
		/// Variables of this type usually are used as local (in single function), but also can be used anywhere (class fields, unmanaged memory).
		/// This type is a struct (value type), and not small (184 bytes). Don't use it as a function parameter without ref. To share a variable between functions use a field in your class.
		/// Don't need to dispose variables of this type. The <see cref="Dispose"/> function just calls <see cref="NW"/>.
		/// </remarks>
		public unsafe struct Instance : IDisposable {
			static Instance() {
				//Prevent JIT delay when calling Next etc
#if PREPAREMETHOD
				Jit_.Compile(typeof(Instance), "Next", "NW", "Dispose");
#if DEBUG //else these methods are inlined
				Jit_.Compile(typeof(perf), "Next", "NW");
#endif
#else
				perf.next(); perf.nw(); perf.first(); //JIT-compiles everything we need. s_enabled prevents calling print.it etc.
				s_enabled = true;
#endif
				
				//JIT speed: 1 ms.
			}
			
#if !PREPAREMETHOD
			readonly static bool s_enabled;
#endif
			const int _nElem = 16;
			
			fixed long _a[_nElem];
			fixed char _aMark[_nElem];
			volatile int _counter;
			bool _incremental;
			int _nMeasurements; //used with incremental to display n measurements and average times
			long _time0;
			
			/// <summary>See <see cref="perf.incremental"/>.</summary>
			/// <example>
			/// <code><![CDATA[
			/// var p1 = new perf.Instance { Incremental = true };
			/// for(int i = 0; i < 5; i++) {
			/// 	Thread.Sleep(100); //not included in the measurement
			/// 	p1.First();
			/// 	Thread.Sleep(30); //will make sum ~150000
			/// 	p1.Next();
			/// 	Thread.Sleep(10); //will make sum ~50000
			/// 	p1.Next();
			/// 	Thread.Sleep(100); //not included in the measurement
			/// }
			/// p1.Write(); //speed:  154317  51060  (205377)
			/// p1.Incremental = false;
			/// ]]></code>
			/// </example>
			public bool Incremental {
				get => _incremental;
				set {
					if (_incremental = value) {
						fixed (long* p = _a) { for (int i = 0; i < _nElem; i++) p[i] = 0; }
						_nMeasurements = 0;
					}
				}
			}
			
			/// <summary><see cref="perf.first()"/></summary>
			public void First() {
#if !PREPAREMETHOD
				if (!s_enabled) return; //called by the static ctor
#endif
				Api.QueryPerformanceCounter(out _time0);
				_counter = 0;
				_nMeasurements++;
			}
			
			//rejected. See comments in static.
			///// <summary>
			///// Calls <see cref="Cpu"/> and <see cref="First()"/>.
			///// </summary>
			//public void First(int timeSpeedUpCPU)
			//{
			//	Cpu(timeSpeedUpCPU);
			//	First();
			//}
			
			/// <summary><see cref="perf.next"/></summary>
			public void Next(char cMark = '\0') {
#if !PREPAREMETHOD
				if (!s_enabled) return; //called by the static ctor
#endif
				int n = _counter; if (n >= _nElem) return;
				_counter++;
				fixed (long* p = _a) {
					Api.QueryPerformanceCounter(out long pc); long t = pc - _time0;
					if (_incremental) p[n] += t; else p[n] = t;
					//fixed (char* c = _aMark) c[n] = cMark;
					char* c = (char*)(p + _nElem); c[n] = cMark;
				}
			}
			
			/// <summary>
			/// Calls <see cref="Next"/> and <see cref="Write"/>.
			/// </summary>
			/// <param name="cMark">A character to add to the results string like <c>"A=150"</c>.</param>
			[MethodImpl(MethodImplOptions.NoInlining)]
			public void NW(char cMark = '\0') { Next(cMark); Write(); }
			
			/// <summary>
			/// Calls <see cref="NW"/>, which calls <see cref="Next"/> and <see cref="Write"/>.
			/// </summary>
			/// <remarks>
			/// Don't need to dispose variables of this type. This function just allows to use <c>using</c> instead of <see cref="NW"/>. See example.
			/// 
			/// If <see cref="Incremental"/>, calls just <see cref="Write"/>.
			/// </remarks>
			/// <example>
			/// <code><![CDATA[
			/// using(var p1 = perf.local()) { //p1.First();
			/// 	1.ms();
			/// 	p1.Next();
			/// 	1.ms();
			/// } //p1.NW();
			/// ]]></code>
			/// </example>
			public void Dispose() {
				if (!_incremental) Next();
				Write();
			}
			//public void Dispose() => NW();
			
			/// <summary>
			/// Formats a string from time values collected by calling <see cref="First"/> and <see cref="Next"/>, and shows it in the output.
			/// The string contains the number of microseconds of each code execution between calling <c>First</c> and each <c>Next</c>.
			/// </summary>
			public void Write() {
#if !PREPAREMETHOD
				if (!s_enabled) return; //called by the static ctor
#endif
				print.it(ToString());
			}
			
			/// <summary>
			/// Formats a string from time values collected by calling <see cref="First"/> and <see cref="Next"/>.
			/// The string contains the number of microseconds of each code execution between calling <c>First</c> and each <c>Next</c>.
			/// </summary>
			public override string ToString() {
				using (new StringBuilder_(out var b)) {
					b.Append("speed:");
					_Results(Math.Min(_counter, _nElem), b, null);
					return b.ToString();
				}
			}
			
			/// <summary>
			/// Return array of time values collected by calling <see cref="First"/> and <see cref="Next"/>.
			/// Each element is the number of microseconds of each code execution between calling <c>First</c> and each <c>Next</c>.
			/// </summary>
			public long[] ToArray() {
				int n = Math.Min(_counter, _nElem);
				var a = new long[n];
				_Results(n, null, a);
				return a;
			}
			
			void _Results(int n, StringBuilder b, long[] a) {
				if (n == 0) return;
				bool average = false; int nMeasurements = 1;
				
				fixed (long* p = _a) fixed (char* c = _aMark) {
					g1:
					double t = 0d, tPrev = 0d;
					for (int i = 0; i < n; i++) {
						t = s_freqMCS * p[i];
						double d = t - tPrev; tPrev = t; //could add 0.5 to round up, but assume that QueryPerformanceCounter call time is 0 - 0.5.
						if (average) d /= nMeasurements;
						long dLong = (long)d;
						if (b != null) {
							b.Append("  ");
							if (c[i] != '\0') b.Append(c[i]).Append('=');
							b.Append(dLong.ToString());
						} else {
							a[i] = dLong;
						}
					}
					if (b == null) return;
					
					if (n > 1) {
						if (average) t /= nMeasurements;
						b.Append("  (").Append((long)t).Append(")");
					}
					
					if (!average && _incremental && (nMeasurements = _nMeasurements) > 1) {
						average = true;
						b.Append(";  measured ").Append(nMeasurements).Append(" times, average");
						goto g1;
					}
				}
			}
			
			/// <summary>
			/// Gets the number of microseconds between <see cref="First"/> and the last <see cref="Next"/>.
			/// </summary>
			public long TimeTotal {
				get {
					int n = _counter;
					if (n == 0) return 0;
					if (n > _nElem) n = _nElem;
					fixed (long* p = _a) { return (long)(s_freqMCS * p[n - 1]); }
				}
			}
		}
		
		/// <summary>
		/// This static variable is used by the static functions.
		/// </summary>
		static Instance s_static;
		//rejected: public. Needed for Serialize. Maybe in the future will be implemented somehow differently.
		
		/// <summary>
		/// Creates and returns new <see cref="Instance"/> variable and calls its <see cref="Instance.First"/>.
		/// </summary>
		public static Instance local() {
			var R = new Instance();
			R.First();
			return R;
		}
		
		/// <summary>
		/// If <c>true</c>, times of each new <c>first next next...</c> measurement are added to previous measurement times.
		/// Finally you can call <see cref="write"/> or <see cref="toString"/> to get the sums.
		/// Usually used to measure code in loops. See example.
		/// </summary>
		/// <example>
		/// <code><![CDATA[
		/// perf.incremental = true;
		/// for(int i = 0; i < 5; i++) {
		/// 	Thread.Sleep(100); //not included in the measurement
		/// 	perf.first();
		/// 	Thread.Sleep(30); //will make sum ~150000
		/// 	perf.next();
		/// 	Thread.Sleep(10); //will make sum ~50000
		/// 	perf.next();
		/// 	Thread.Sleep(100); //not included in the measurement
		/// }
		/// perf.write(); //speed:  154317  51060  (205377)
		/// perf.incremental = false;
		/// ]]></code>
		/// </example>
		public static bool incremental {
			get => s_static.Incremental;
			set => s_static.Incremental = value;
		}
		
		/// <summary>
		/// Stores current time in the first element of an internal array.
		/// </summary>
		public static void first() => s_static.First();
		
		//rejected. Unclear. Can confuse int timeSpeedUpCPU with char cMark.
		///// <summary>
		///// Calls <see cref="Cpu"/> and <see cref="First()"/>.
		///// </summary>
		//public static void first(int timeSpeedUpCPU) => s_static.First(timeSpeedUpCPU);
		
		/// <summary>
		/// Stores current time in next element of an internal array.
		/// </summary>
		/// <remarks>
		/// Don't call <c>next</c> more than 16 times after <see cref="first"/>, because the array size is fixed.
		/// </remarks>
		/// <param name="cMark">A character to mark this time in the results string, like <c>"A=150"</c>.</param>
		public static void next(char cMark = '\0') => s_static.Next(cMark);
		
		/// <summary>
		/// Calls <see cref="next"/> and <see cref="write"/>.
		/// </summary>
		/// <param name="cMark">A character to add to the results string like <c>"A=150"</c>.</param>
		public static void nw(char cMark = '\0') => s_static.NW(cMark);
		
		/// <summary>
		/// Formats a string from time values collected by calling <see cref="first"/> and <see cref="next"/>, and shows it in the output.
		/// The string contains the number of microseconds of each code execution between calling <see cref="first"/> and each <see cref="next"/>.
		/// </summary>
		/// <example>
		/// <code><![CDATA[
		/// perf.first(100);
		/// CODE1;
		/// perf.next();
		/// CODE2;
		/// perf.next();
		/// perf.write(); //speed:  timeOfCODE1  timeOfCODE2  (totalTime)
		/// ]]></code>
		/// </example>
		public static void write() => s_static.Write();
		
		/// <summary>
		/// Formats a string from time values collected by calling <see cref="first"/> and <see cref="next"/>.
		/// The string contains the number of microseconds of each code execution between calling <see cref="first"/> and each <see cref="next"/>.
		/// </summary>
		public static string toString() => s_static.ToString();
		
		/// <summary>
		/// Return array of time values collected by calling <see cref="first"/> and <see cref="next"/>.
		/// Each element is the number of microseconds of each code execution between calling <see cref="first"/> and each <see cref="next"/>.
		/// </summary>
		public static long[] toArray() => s_static.ToArray();
		
		/// <summary>
		/// Gets the number of microseconds between <see cref="first"/> and the last <see cref="next"/>.
		/// </summary>
		public static long timeTotal => s_static.TimeTotal;
		
		/// <summary>
		/// Executes some code in loop for the specified amount of time. It should make CPU to run at full speed.
		/// </summary>
		/// <param name="timeMilliseconds">How long to speed up CPU, milliseconds. The minimal required time probably is about 100 ms, but depends on CPU.</param>
		/// <remarks>
		/// Code speed measurements often are misleading because of variable CPU speed. Most CPU don't run at full speed when not actively used.
		/// 
		/// You can make CPU speed constant in <b>Control Panel > Power Options > ... Advanced > Processor power management > Minimum or maximum power state</b>.
		/// There are programs that show current CPU speed. For example HWMonitor.
		/// </remarks>
		public static void cpu(int timeMilliseconds = 200) {
			int n = 0;
			for (long t0 = mcs; mcs - t0 < timeMilliseconds * 1000L; n++) { }
			//print.it(n);
		}
		
		/// <summary>
		/// Gets a reference to a <see cref="Instance"/> variable in shared memory.
		/// </summary>
		/// <remarks>
		/// The variable can be used by multiple processes, for example to measure process startup time.
		/// Note: slow first time in process, eg 3 ms. It's because need to JIT-compile functions and open shared memory.
		/// </remarks>
		/// <example>
		/// <code><![CDATA[
		/// ref var p = ref perf.shared;
		/// p.First();
		/// //or
		/// perf.shared.First();
		/// ]]></code>
		/// </example>
		public static ref Instance shared => ref SharedMemory_.Ptr->perf;
	}
}


================================================
FILE: Au/Time/timer.cs
================================================
namespace Au;

/// <summary>
/// Timer that calls callback function in same thread, which must have a message loop.
/// </summary>
/// <remarks>
/// Uses API <ms>SetTimer</ms> and <ms>WM_TIMER</ms>.
/// Works only in threads that have a message loop which retrieves/dispatches posted messages. For example threads with windows (except console).
/// Timer action delegates are protected from GC.
/// </remarks>
/// <example>
/// This example sets 3 timers.
/// <code><![CDATA[
/// timer.after(500, _ => print.it("after 500 ms"));
/// timer.every(1000, _ => print.it("every 1000 ms"));
/// var t3 = new timer(_ => print.it("after 3000 ms")); t3.After(3000); //the same as timer.after
/// dialog.show("timer"); //shows a dialog window and waits until closed. The dialog retrieves/dispatches messages in its message loop.
/// ]]></code>
/// </example>
public class timer {
	readonly Action<timer> _action;
	nint _id;
	int _threadId;
	bool _singlePeriod;
	
	//To control object lifetime we use a thread-static Dictionary.
	//Tried GCHandle, but could not find a way to delete object when thread ends.
	//Calling KillTimer when thread ends is optional. Need just to re-enable garbage collection for this object.
	[ThreadStatic] static Dictionary<nint, timer> t_timers;
	
	/// <summary>
	/// Sets callback function.
	/// </summary>
	public timer(Action<timer> timerAction) {
		_action = timerAction;
	}
	//rejected: add overload with hwnd. Or optional parameter. Or another class. Never needed in several years.
	
	/// <summary>
	/// Something to attach to this variable.
	/// </summary>
	public object Tag { get; set; }
	
	/// <summary>
	/// <c>true</c> if the timer is started and not stopped.
	/// Note: single-period timer is automatically stopped before calling the callback function.
	/// </summary>
	public bool IsRunning => _id != default;
	
	/// <summary>
	/// Starts one-time timer. If already started, resets and changes its period.
	/// </summary>
	/// <param name="milliseconds">Time interval after which to call the callback function. The actual minimal interval is 10-20 ms.</param>
	/// <exception cref="ArgumentOutOfRangeException">Negative.</exception>
	/// <exception cref="InvalidOperationException">Called not in the same thread as previously.</exception>
	/// <exception cref="Win32Exception">API <ms>SetTimer</ms> returned 0. Unlikely.</exception>
	/// <remarks>
	/// The timer will be stopped before calling the callback function. The callback function can start it again.
	/// If already started, this function must be called in the same thread as when started.
	/// </remarks>
	public void After(int milliseconds) => _Start(true, milliseconds);
	
	/// <summary>
	/// Starts periodic timer. If already started, resets and changes its period.
	/// </summary>
	/// <param name="milliseconds">Time interval (period) of calling the callback function. The actual minimal period is 10-20 ms.</param>
	/// <exception cref="ArgumentOutOfRangeException">Negative.</exception>
	/// <exception cref="InvalidOperationException">Called not in the same thread as previously.</exception>
	/// <exception cref="Win32Exception">API <ms>SetTimer</ms> returned 0. Unlikely.</exception>
	/// <remarks>
	/// The callback function can stop the timer or restart with different period.
	/// If already started, this function must be called in the same thread as when started.
	/// </remarks>
	public void Every(int milliseconds) => _Start(false, milliseconds);
	
	void _Start(bool singlePeriod, int milliseconds) {
		if (milliseconds < 0) throw new ArgumentOutOfRangeException();
		bool isNew = _id == 0;
		if (!isNew) _ThreadTrap();
		nint r = Api.SetTimer(default, _id, milliseconds, s_timerProc);
		if (r == 0) throw new Win32Exception();
		Debug.Assert(isNew || r == _id);
		_id = r;
		_singlePeriod = singlePeriod;
		if (isNew) {
			_threadId = Environment.CurrentManagedThreadId;
			(t_timers ??= new Dictionary<nint, timer>()).Add(_id, this);
		}
		//print.it($"Start: {_id}  isNew={isNew}  singlePeriod={singlePeriod}  _threadId={_threadId}");
	}
	
	static readonly Api.TIMERPROC s_timerProc = _TimerProc;
	static void _TimerProc(wnd w, int msg, nint idEvent, uint time) {
		//print.it(t_timers.Count, idEvent);
		if (!t_timers.TryGetValue(idEvent, out var t)) {
			//Debug_.Print($"timer id {idEvent} not in t_timers");
			return;
			//It is possible after killing timer.
			//	Normally API KillTimer removes WM_TIMER message from queue (tested), but in some conditions our callback can still be called several times.
			//	For example if multiple messages are retrieved from the OS queue without dispatching each, and then all are dispatched.
			//	Usually we can safely ignore it. But not good if the same timer id is reused for another timer. Tested on Win10: OS does not reuse ids soon.
		}
		if (t._singlePeriod) t.Stop();
		
		try { t._action(t); }
		catch (Exception ex) { print.warning(ex); }
		//info: OS handles exceptions in timer procedure.
	}
	
	/// <summary>
	/// Stops the timer.
	/// </summary>
	/// <exception cref="InvalidOperationException">Called not in the same thread as previously.</exception>
	/// <remarks>
	/// The callback function will not be called after this.
	/// Later you can start the timer again (call <see cref="After"/> or <see cref="Every"/>).
	/// Don't need to call this function for single-period timers. For periodic timers it is optional; the timer stops when the thread ends.
	/// This function must be called in the same thread as <see cref="After"/> or <see cref="Every"/>.
	/// </remarks>
	public void Stop() {
		if (_id != 0) {
			//print.it($"Stop: {_id}          _threadId={_threadId}");
			_ThreadTrap();
			Api.KillTimer(default, _id);
			//tested: KillTimer removes pending WM_TIMER messages from queue. MSDN lies. Tested on Win 10 and 7.
			t_timers.Remove(_id);
			_id = 0;
		}
	}
	
	/// <summary>
	/// Execute the timer action now.
	/// </summary>
	/// <remarks>
	/// Does not change any properties. Just calls the callback function. Does not handle exceptions.
	/// </remarks>
	public void Now() => _action(this);
	
	void _ThreadTrap() {
		bool isSameThread = _threadId == Environment.CurrentManagedThreadId;
		Debug.Assert(isSameThread);
		if (!isSameThread) throw new InvalidOperationException(nameof(timer) + " used in multiple threads.");
		//FUTURE: somehow allow other thread. It is often useful.
	}
	
	//~timer() { print.it("dtor"); } //don't call Stop() here, we are in other thread
	
	static timer _StartNew(bool singlePeriod, int milliseconds, Action<timer> timerAction, object tag = null) {
		var t = new timer(timerAction) { Tag = tag };
		t._Start(singlePeriod, milliseconds);
		return t;
	}
	
	/// <summary>
	/// Creates and starts new one-time timer.
	/// </summary>
	/// <returns>New <see cref="timer"/> object. Usually you don't need it.</returns>
	/// <param name="milliseconds">Time interval after which to call the callback function. The actual minimal interval is 10-20 ms.</param>
	/// <param name="timerAction">Callback function.</param>
	/// <param name="tag">Something to pass to the callback function as <see cref="Tag"/>.</param>
	/// <exception cref="ArgumentOutOfRangeException">Negative.</exception>
	/// <exception cref="Win32Exception">API <ms>SetTimer</ms> returned 0. Unlikely.</exception>
	/// <remarks>
	/// The timer will be stopped before calling the callback function. The callback function can start it again.
	/// The callback function will be called in this thread.
	/// This thread must get/dispatch posted messages, eg call <c>Application.Run</c> or <see cref="dialog.show"/>. The callback function is not called while this thread does not do it.
	/// </remarks>
	public static timer after(int milliseconds, Action<timer> timerAction, object tag = null)
		=> _StartNew(true, milliseconds, timerAction, tag);
	
	/// <summary>
	/// Creates and starts new periodic timer.
	/// </summary>
	/// <returns>New <see cref="timer"/> object that can be used to modify timer properties if you want to do it not in the callback function; usually don't need it.</returns>
	/// <param name="milliseconds">Time interval (period) of calling the callback function. The actual minimal period is 10-20 ms.</param>
	/// <param name="timerAction">Callback function.</param>
	/// <param name="tag">Something to pass to the callback function as <see cref="Tag"/>.</param>
	/// <exception cref="ArgumentOutOfRangeException">Negative.</exception>
	/// <exception cref="Win32Exception">API <ms>SetTimer</ms> returned 0. Unlikely.</exception>
	/// <remarks>
	/// The callback function can stop the timer or restart with different period.
	/// The callback function will be called in this thread.
	/// This thread must get/dispatch posted messages, eg call <c>Application.Run</c> or <see cref="dialog.show"/>. The callback function is not called while this thread does not do it.
	/// </remarks>
	public static timer every(int milliseconds, Action<timer> timerAction, object tag = null)
		=> _StartNew(false, milliseconds, timerAction, tag);
}


================================================
FILE: Au/Time/timer2.cs
================================================
namespace Au;

/// <summary>
/// Timer that calls callback function in other thread (thread pool) and can be used in any thread.
/// </summary>
/// <remarks>
/// Uses <see cref="Timer"/>.
/// Unlike <see cref="timer"/>, the thread that sets the timer does not have to retrieve/dispatch messages.
/// The callback function is called in a random thread of the thread pool, therefore its code is not thread-safe (may need to lock etc).
/// The actual minimal time interval/period is 10-20 ms, because the system timer period usually is 15.25 ms.
/// Timer action delegates are protected from GC.
/// </remarks>
/// <example>
/// This example sets 3 timers.
/// <code><![CDATA[
/// timer2.after(500, _ => print.it("after 500 ms"));
/// timer2.every(1000, _ => print.it("every 1000 ms"));
/// var t3 = new timer2(_ => print.it("after 3000 ms")); t3.After(3000); //the same as timer2.after
/// 5.s();
/// ]]></code>
/// </example>
public class timer2 {
	readonly Timer _tim;
	readonly Action<timer2> _action;
	
	/// <summary>
	/// Sets callback function.
	/// </summary>
	public timer2(Action<timer2> timerAction) {
		_action = timerAction;
		_tim = new Timer(o => {
			var t = o as timer2;
			try { t._action(t); }
			catch (Exception ex) { print.warning(ex); }
		}, this, -1, -1);
		//note: don't pass dueTime/period to Timer ctor. Could call callback before _tim is assigned.
		
		//s_cwt.Add(_tim, new());
		//_tim = null;
	}
	
	//GC can collect either when explicitly stopped or when 'after' timer completes (somehow). Only after the callback returns.
	//~timer2() { print.it("fin"); }
	//static ConditionalWeakTable<Timer, gc> s_cwt=new();
	//class gc { ~gc() { print.it("gc"); } }
	
	/// <summary>
	/// Stops the timer, and by default disposes.
	/// </summary>
	/// <param name="canReuse">Just stop but don't dispose. If <c>false</c> (default), can't use the timer again.</param>
	public void Stop(bool canReuse = false) {
		if (canReuse) _tim.Change(-1, -1);
		else _tim.Dispose();
	}
	
	/// <summary>
	/// Starts one-time timer or changes timeout/period.
	/// </summary>
	/// <param name="milliseconds">Time interval after which to call the callback function. Valid values are 0 - <see cref="uint.MaxValue"/> - 2. If -1, stops without disposing.</param>
	/// <exception cref="ArgumentOutOfRangeException"></exception>
	/// <exception cref="ObjectDisposedException">Called <see cref="Stop"/> (unless <i>canReuse</i> true).</exception>
	/// <remarks>
	/// Calls <see cref="Timer.Change(long, long)"/>.
	/// </remarks>
	public void After(long milliseconds) {
		_tim.Change(milliseconds, -1);
	}
	
	/// <summary>
	/// Starts periodic timer or changes timeout/period.
	/// </summary>
	/// <param name="milliseconds">Time interval (period) of calling the callback function. Valid values are 0 - <see cref="uint.MaxValue"/> - 2.</param>
	/// <param name="firstAfter"><c>null</c> (default) or time interval after which to call the callback function first time. Valid values are 0 - <see cref="uint.MaxValue"/> - 2.</param>
	/// <exception cref="ArgumentOutOfRangeException"></exception>
	/// <exception cref="ObjectDisposedException">Called <see cref="Stop"/> (unless <i>canReuse</i> true).</exception>
	/// <remarks>
	/// Calls <see cref="Timer.Change(long, long)"/>.
	/// </remarks>
	public void Every(long milliseconds, long? firstAfter = null) {
		_tim.Change(firstAfter ?? milliseconds, milliseconds);
	}
	
	/// <summary>
	/// Something to attach to this variable.
	/// </summary>
	public object Tag { get; set; }
	
	/// <summary>
	/// Creates and starts new one-time timer.
	/// </summary>
	/// <param name="milliseconds">Time interval after which to call the callback function. Valid values are 0 - <see cref="uint.MaxValue"/> - 2. If -1, stops without disposing.</param>
	/// <param name="timerAction">Callback function.</param>
	/// <param name="tag">Something to pass to the callback function as <see cref="Tag"/>.</param>
	/// <exception cref="ArgumentOutOfRangeException"></exception>
	/// <remarks>
	/// Calls <see cref="Timer.Change(long, long)"/>.
	/// </remarks>
	public static timer2 after(long milliseconds, Action<timer2> timerAction, object tag = null) {
		var t = new timer2(timerAction) { Tag = tag };
		t.After(milliseconds);
		return t;
	}
	
	/// <summary>
	/// Creates and starts new periodic timer.
	/// </summary>
	/// <param name="milliseconds">Time interval (period) of calling the callback function. Valid values are 0 - <see cref="uint.MaxValue"/> - 2.</param>
	/// <param name="timerAction">Callback function.</param>
	/// <param name="tag">Something to pass to the callback function as <see cref="Tag"/>.</param>
	/// <param name="firstAfter"><c>null</c> (default) or time interval after which to call the callback function first time. Valid values are 0 - <see cref="uint.MaxValue"/> - 2.</param>
	/// <exception cref="ArgumentOutOfRangeException"></exception>
	/// <remarks>
	/// Calls <see cref="Timer.Change(long, long)"/>.
	/// </remarks>
	public static timer2 every(long milliseconds, Action<timer2> timerAction, object tag = null, long? firstAfter = null) {
		var t = new timer2(timerAction) { Tag = tag };
		t.Every(milliseconds, firstAfter);
		return t;
	}
}


================================================
FILE: Au/Time/wait.cs
================================================
namespace Au;

/// <summary>
/// Contains functions to wait for a custom condition, handle, etc, or simply sleep.
/// </summary>
/// <remarks>
/// Specialized "wait for" functions are in other classes, for example <see cref="wnd.wait"/>.
/// 
/// All "wait for" functions have a timeout parameter. It is the maximal time to wait, in seconds. If 0, waits indefinitely. If <c>></c> 0, throws <see cref="TimeoutException"/> when timed out. If &lt; 0, then stops waiting and returns default value of that type (<c>false</c>, etc).
/// 
/// While waiting, most functions by default don't dispatch Windows messages, events, hooks, timers, COM/RPC, etc. For example, if used in a <c>Window</c>/<c>Form</c>/<c>Control</c> event handler, the window would stop responding. Use another thread, for example <c>async</c>/<c>await</c>/<c>Task</c>, like in the example. Or <see cref="Seconds.DoEvents"/>.
/// </remarks>
/// <example>
/// <code><![CDATA[
/// wait.until(0, () => keys.isScrollLock);
/// print.it("ScrollLock now is toggled");
/// ]]></code>
/// Using in a WPF window with async/await.
/// <code><![CDATA[
/// using System.Windows;
/// var b = new wpfBuilder("Window").WinSize(250);
/// b.R.AddButton("Wait", async _ => {
/// 	  print.it("waiting for ScrollLock...");
/// 	  var result = await Task.Run(() => wait.until(-10, () => keys.isScrollLock));
/// 	  print.it(result);
/// });
/// if (!b.ShowDialog()) return;
/// ]]></code>
/// </example>
public static partial class wait {
	/// <summary>
	/// Waits <i>timeMilliseconds</i> milliseconds.
	/// </summary>
	/// <param name="timeMilliseconds">Time to wait, milliseconds. Or <see cref="Timeout.Infinite"/> (-1).</param>
	/// <remarks>
	/// Calls <see cref="Thread.Sleep(int)"/>.
	/// Does not process Windows messages and other events, therefore should not be used in threads with windows, timers, hooks, events or COM, unless <i>timeMilliseconds</i> is small. Supports APC.
	/// If the computer goes to sleep or hibernate during that time, the real time is the specified time + the sleep/hibernate time.
	/// 
	/// Tip: the script editor replaces code like <c>100ms</c> with <c>100.ms();</c> when typing.
	/// </remarks>
	/// <exception cref="ArgumentOutOfRangeException"><i>timeMilliseconds</i> is negative and not -1 (<c>Timeout.Infinite</c>).</exception>
	/// <example>
	/// <code><![CDATA[
	/// wait.ms(500);
	/// 500.ms(); //the same (ms is an extension method)
	/// wait.s(0.5); //the same
	/// ]]></code>
	/// </example>
	public static void ms(this int timeMilliseconds) {
		SleepPrecision_.TempSet1_(timeMilliseconds);
		if (timeMilliseconds < 2000) {
			Thread.Sleep(timeMilliseconds);
		} else { //workaround for Thread.Sleep bug: if there are APC, returns too soon after sleep/hibernate.
			g1:
			long t = computer.tickCountWithoutSleep;
			Thread.Sleep(timeMilliseconds);
			t = timeMilliseconds - (computer.tickCountWithoutSleep - t);
			if (t >= 500) { timeMilliseconds = (int)t; goto g1; }
		}
	}
	
	/// <summary>
	/// Waits <i>timeSeconds</i> seconds.
	/// The same as <see cref="ms"/>, but the time is specified in seconds, not milliseconds.
	/// </summary>
	/// <param name="timeSeconds">Time to wait, seconds.</param>
	/// <exception cref="ArgumentOutOfRangeException"><i>timeSeconds</i> is less than 0 or greater than 2147483 (<see cref="int.MaxValue"/> / 1000, 24.8 days).</exception>
	/// <remarks>
	/// Tip: the script editor replaces code like <c>100ms</c> with <c>100.ms();</c> when typing.
	/// </remarks>
	/// <example>
	/// <code><![CDATA[
	/// wait.s(5);
	/// 5.s(); //the same (s is an extension method)
	/// 5000.ms(); //the same
	/// ]]></code>
	/// </example>
	public static void s(this int timeSeconds) {
		if ((uint)timeSeconds > int.MaxValue / 1000) throw new ArgumentOutOfRangeException();
		ms(timeSeconds * 1000);
	}
	
	/// <summary>
	/// Waits <i>timeSeconds</i> seconds.
	/// The same as <see cref="ms"/>, but the time is specified in seconds, not milliseconds.
	/// </summary>
	/// <param name="timeSeconds">Time to wait, seconds. The smallest value is 0.001 (1 ms).</param>
	/// <exception cref="ArgumentOutOfRangeException"><i>timeSeconds</i> is less than 0 or greater than 2147483 (<see cref="int.MaxValue"/> / 1000, 24.8 days).</exception>
	/// <example>
	/// <code><![CDATA[
	/// wait.s(2.5);
	/// 2500.ms(); //the same
	/// ]]></code>
	/// </example>
	public static void s(this double timeSeconds) {
		double t = timeSeconds * 1000d;
		if (t > int.MaxValue || t < 0) throw new ArgumentOutOfRangeException();
		ms((int)t);
	}
	//Maybe this should not be an extension method.
	//	Code like 0.5.s() looks weird. Better 500.ms(). Rarely need non-integer time when > 1 s.
	//	But: 1. Symmetry. 2. Easier to convert QM code, like 0.5 to 0.5.s(); not 500.ms();.
	
	/// <summary>
	/// Waits <i>timeMS</i> milliseconds. While waiting, retrieves and dispatches Windows messages and other events.
	/// </summary>
	/// <param name="timeMS">Time to wait, milliseconds. Or <see cref="Timeout.Infinite"/> (-1).</param>
	/// <remarks>
	/// Unlike <see cref="ms"/>, this function retrieves and dispatches Windows messages, calls .NET event handlers, hook procedures, timer functions, COM, etc.
	/// This function can be used in threads with windows. However usually there are better ways, for example timer, other thread, <c>async</c>/<c>await</c>/<c>Task</c>.
	/// If <i>timeMS</i> is -1, returns when receives <ms>WM_QUIT</ms> message.
	/// </remarks>
	/// <exception cref="ArgumentOutOfRangeException"><i>timeMS</i> is negative and not -1 (<c>Timeout.Infinite</c>).</exception>
	public static unsafe void doEvents(int timeMS) {
		if (timeMS < -1) throw new ArgumentOutOfRangeException();
		if (timeMS == 0) {
			Api.SleepEx(0, true); //call APC
			doEvents();
		} else {
			using var mp = new MessagePump_();
			for (long time = timeMS, timePrev = 0; ;) {
				if (timeMS > 0) {
					long timeNow = computer.tickCountWithoutSleep;
					if (timePrev > 0) time -= timeNow - timePrev;
					if (time <= 0) return;
					timePrev = timeNow;
				}
				switch (Api.MsgWaitForMultipleObjectsEx(0, null, (int)time, Api.QS_ALLINPUT, Api.MWMO_ALERTABLE | Api.MWMO_INPUTAVAILABLE)) {
				case 0: if (!mp.Pump() && timeMS < 0) return; break;
				case Api.WAIT_TIMEOUT: return;
				case Api.WAIT_IO_COMPLETION: break;
				default: throw new Win32Exception();
				}
			}
		}
		//info: Thread.Sleep is alertable too. One reason I know is Thread.Interrupt; but with doEvents it does not work.
	}
	
	internal struct MessagePump_ : IDisposable {
		int? _quit;
		
		/// <summary>
		/// If <see cref="Pump"/> received <c>WM_QUIT</c>, calls <c>PostQuitMessage</c>, unless detects that it could cause infinite loop.
		/// </summary>
		public void Dispose() {
			if (_quit != null) {
				//prevent infinite loop when eg the caller uses a loop like in doEvents(int) and ignores WM_QUIT
				var stack = new StackTrace(false).FrameCount;
				if (t_doeventsStack == 0 || stack < t_doeventsStack) {
					t_doeventsStack = stack;
					Api.PostQuitMessage(_quit.Value);
				} else {
					print.warning("duplicate WM_QUIT");
				}
				_quit = null;
			}
		}
		[ThreadStatic] static int t_doeventsStack;
		
		/// <summary>
		/// Calls <c>PeekMessage</c>/<c>TranslateMessage</c>/<c>DispatchMessage</c> while there are messages.
		/// </summary>
		/// <returns><c>false</c> if received <c>WM_QUIT</c>.</returns>
		public bool Pump() {
			while (Api.PeekMessage(out var m)) {
				if (m.message == Api.WM_QUIT) { _quit = (int)m.wParam; return false; }
				Api.TranslateMessage(m);
				Api.DispatchMessage(m);
			}
			return true;
		}
		
		/// <summary>
		/// Like <see cref="Pump"/>, but can call a callback function. Used by <see cref="Wait_"/>.
		/// </summary>
		/// <param name="msgCallback">
		/// <c>null</c> or callback function of type:
		/// <br/>• <see cref="WPMCallback"/> - called before dispatching a message. If returns <c>true</c>, not called for other messages. Can modify the <c>MSG</c>. Can set <c>MSG.message</c> = 0 to prevent dispatching it.
		/// <br/>• <c>Func&lt;bool&gt;</c> - called after dispatching all messages.
		/// </param>
		/// <returns><c>true</c> if <i>msgCallback</i> returned <c>true</c>.</returns>
		public bool PumpWithCallback(Delegate msgCallback) {
			bool R = false;
			while (Api.PeekMessage(out var m)) {
				if (msgCallback is WPMCallback callback1) {
					if (callback1(ref m)) { msgCallback = null; R = true; }
					if (m.message == 0) continue;
				}
				if (m.message == Api.WM_QUIT) { _quit = (int)m.wParam; continue; } //now ignore, but finally repost
				Api.TranslateMessage(m);
				Api.DispatchMessage(m);
			}
			if (msgCallback is Func<bool> callback2) R = callback2();
			return R;
		}
		
		//note: never use "dispatch only sent messages". It's dangerous and not useful.
		//	If thread has windows, hangs if we don't get posted messages.
		//	Else PeekMessage usually does not harm.
		
		//note: with PeekMessage don't use |Api.PM_QS_SENDMESSAGE when don't need posted messages.
		//	Then setwineventhook hook does not work. Although setwindowshookex hook works. COM RPC not tested.
	}
	
	/// <summary>
	/// Retrieves and dispatches events and Windows messages from the message queue of this thread.
	/// </summary>
	/// <returns><c>false</c> if received <c>WM_QUIT</c> message.</returns>
	/// <remarks>
	/// Similar to <see cref="System.Windows.Forms.Application.DoEvents"/>, but more lightweight. Uses API functions <ms>PeekMessage</ms>, <ms>TranslateMessage</ms> and <ms>DispatchMessage</ms>.
	/// </remarks>
	public static bool doEvents() {
		using var mp = new MessagePump_();
		return mp.Pump();
	}
	
	/// <summary>
	/// Calls <see cref="SleepPrecision_.TempSet1_"/> and <see cref="doEvents(int)"/>.
	/// </summary>
	internal static unsafe void doEventsPrecise_(int timeMS) {
		SleepPrecision_.TempSet1_(timeMS);
		doEvents(timeMS);
	}
	
	/// <summary>
	/// Temporarily changes the time resolution/precision of <c>Thread.Sleep</c> and some other functions.
	/// </summary>
	/// <remarks>
	/// Uses API <ms>timeBeginPeriod</ms>, which requests a time resolution for various system timers and wait functions. Actually it is the system thread scheduling timer period.
	/// Normal resolution on Windows 7-10 is 15.625 ms. It means that, for example, <c>Thread.Sleep(1);</c> sleeps not 1 but 1-15 ms. If you set resolution 1, it sleeps 1-2 ms.
	/// The new resolution is revoked (<ms>timeEndPeriod</ms>) when disposing the <c>SleepPrecision_</c> variable or when this process ends. See example. See also <see cref="TempSet1"/>.
	/// The resolution is applied to all threads and processes. Other applications can change it too. For example, often web browsers temporarily set resolution 1 ms when opening a web page.
	/// The system uses the smallest period (best resolution) that currently is set by any application. You cannot make it bigger than current value.
	/// <note>It is not recommended to keep small period (high resolution) for a long time. It can be bad for power saving.</note>
	/// Don't need this for <see cref="wait.ms"/> etc and functions that use them. They call <see cref="TempSet1"/> when the sleep time is 1-89 ms.
	/// This does not change the minimal period of timers.
	/// </remarks>
	/// <example>
	/// <code><![CDATA[
	/// _Test("before");
	/// using(new wait.SleepPrecision_(2)) {
	/// 	_Test("in");
	/// }
	/// _Test("after");
	/// 
	/// void _Test(string name) {
	/// 	print.it(name);
	/// 	perf.first();
	/// 	for(int i = 0; i < 8; i++) { Thread.Sleep(1); perf.next(); }
	/// 	perf.write();
	/// }
	/// ]]></code>
	/// </example>
	internal sealed class SleepPrecision_ : IDisposable {
		//info: this class could be public, but probably not useful. wait.ms automatically sets 1 ms period if need.
		
		int _period;
		
		/// <summary>
		/// Calls API <ms>timeBeginPeriod</ms>.
		/// </summary>
		/// <param name="periodMS">
		/// New system timer period, milliseconds.
		/// Should be 1. Other values may stuck and later cannot be made smaller due to bugs in OS or some applications; this bug would impact many functions of this library.
		/// </param>
		/// <exception cref="ArgumentOutOfRangeException"><i>periodMS</i> &lt;= 0.</exception>
		public SleepPrecision_(int periodMS) {
			if (periodMS <= 0) throw new ArgumentOutOfRangeException();
			if (Api.timeBeginPeriod((uint)periodMS) != 0) return;
			//print.it("set");
			_period = periodMS;
			
			//Bug in OS or drivers or some apps:
			//	On my main PC often something briefly sets 0.5 ms resolution.
			//	If at that time this process already has set a resolution of more than 1 ms, then after that time this process cannot change resolution.
			//	It means that if this app eg has set 10 ms resolution, then wait.ms(1) will sleep 10 ms and not the normal 1-2 ms.
			//	Known workaround (but don't use, sometimes does not work, eg cannot end period that was set by another process):
			//		timeBeginPeriod(periodMS);
			//		var r=(int)Current; if(r>periodMS) { timeEndPeriod(periodMS); timeEndPeriod(r); timeBeginPeriod(r); timeBeginPeriod(periodMS); }
		}
		
		/// <summary>
		/// Calls API <ms>timeEndPeriod</ms>.
		/// </summary>
		public void Dispose() {
			_Dispose();
			GC.SuppressFinalize(this);
		}
		
		void _Dispose() {
			if (_period == 0) return;
			//print.it("revoke");
			Api.timeEndPeriod((uint)_period); _period = 0;
		}
		
		///
		~SleepPrecision_() { _Dispose(); }
		
		/// <summary>
		/// Gets current actual system time resolution (period).
		/// </summary>
		/// <returns>The return value usually is between 0.5 and 15.625 milliseconds. Returns 0 if failed.</returns>
		public static float Current {
			get {
				if (0 != Api.NtQueryTimerResolution(out _, out _, out var t)) return 0f;
				return (float)t / 10000;
			}
		}
		
		/// <summary>
		/// Temporarily sets the system wait precision to 1 ms. It will be revoked after the specified time or when this process ends.
		/// If already set, just updates the revoking time.
		/// </summary>
		/// <param name="endAfterMS">Revoke after this time, milliseconds.</param>
		/// <example>
		/// <code><![CDATA[
		/// print.it(wait.SleepPrecision_.Current); //probably 15.625
		/// wait.SleepPrecision_.TempSet1(500);
		/// print.it(wait.SleepPrecision_.Current); //1
		/// Thread.Sleep(600);
		/// print.it(wait.SleepPrecision_.Current); //probably 15.625 again
		/// ]]></code>
		/// </example>
		public static void TempSet1(int endAfterMS = 1111) {
			lock ("2KgpjPxRck+ouUuRC4uBYg") {
				s_TS1_EndTime = computer.tickCountWithoutSleep + endAfterMS;
				if (s_TS1_Obj == null) {
					s_TS1_Obj = new SleepPrecision_(1); //info: instead could call the API directly, but may need to auto-revoke using the finalizer
					ThreadPool.QueueUserWorkItem(endAfterMS2 => {
						Thread.Sleep((int)endAfterMS2); //note: don't use captured variables. It creates new garbage all the time.
						for (; ; ) {
							int t;
							lock ("2KgpjPxRck+ouUuRC4uBYg") {
								t = (int)(s_TS1_EndTime - computer.tickCountWithoutSleep);
								if (t <= 0) {
									s_TS1_Obj.Dispose();
									s_TS1_Obj = null;
									break;
								}
							}
							Thread.Sleep(t);
						}
					}, endAfterMS);
					//performance (old info): single QueueUserWorkItem adds 3 threads, >=2 adds 5. But Thread.Start is too slow etc.
					//QueueUserWorkItem speed first time is similar to Thread.Start, then ~8.
					//Task.Run and Task.Delay are much much slower first time. Single Delay adds 5 threads.
				}
			}
			//tested: Task Manager shows 0% CPU. If we set/revoke period for each Sleep(1) in loop, shows ~0.5% CPU.
		}
		static SleepPrecision_ s_TS1_Obj;
		static long s_TS1_EndTime;
		
		//never mind: finalizer is not called on process exit.
		//	Not a problem, because OS clears our set value (tested). Or we could use process.thisProcessExit event.
		
		/// <summary>
		/// Calls TempSet1 if <i>sleepTimeMS</i> is 1-89.
		/// </summary>
		/// <param name="sleepTimeMS">milliseconds of the caller "sleep" function.</param>
		internal static void TempSet1_(int sleepTimeMS) {
			if (sleepTimeMS is < 90 and > 0) TempSet1(1111);
		}
	}
}


================================================
FILE: Au/Time/wait_for.cs
================================================
namespace Au {
	public static partial class wait {
		/// <summary>
		/// Waits for a user-defined condition. Until the callback function returns a value other than <c>default(T)</c>, for example <c>true</c>.
		/// </summary>
		/// <param name="timeout">Timeout, seconds. Can be 0 (infinite), >0 (exception) or &lt;0 (no exception). More info: [](xref:wait_timeout).</param>
		/// <param name="condition">Callback function (eg lambda). It is called repeatedly, until returns a value other than <c>default(T)</c>. Default period is 10, and can be changed like <c>wait.until(new(5) { Timeout = 100 }, ...)</c>.</param>
		/// <returns>Returns the value returned by the callback function. On timeout returns <c>default(T)</c> if <i>timeout</i> is negative; else exception.</returns>
		/// <exception cref="TimeoutException"></exception>
		/// <example>See <see cref="wait"/>.</example>
		public static T until<T>(Seconds timeout, Func<T> condition) {
			var loop = new WaitLoop(timeout);
			for (; ; ) {
				T r = condition();
				if (!EqualityComparer<T>.Default.Equals(r, default)) return r;
				if (!loop.Sleep()) return r;
			}
		}
		
		/// <summary>
		/// Obsolete. Use <c>wait.until</c>.
		/// Waits for a user-defined condition. Until the callback function returns a value other than <c>default(T)</c>, for example <c>true</c>.
		/// </summary>
		/// <param name="secondsTimeout">Timeout, seconds. Can be 0 (infinite), >0 (exception) or &lt;0 (no exception). More info: [](xref:wait_timeout).</param>
		/// <param name="condition">Callback function (eg lambda). It is called repeatedly, until returns a value other than <c>default(T)</c>. The calling period depends on <i>options</i>.</param>
		/// <param name="options">Options. If <c>null</c>, uses <c>opt.wait</c>.</param>
		/// <returns>Returns the value returned by the callback function. On timeout returns <c>default(T)</c> if <i>secondsTimeout</i> is negative; else exception.</returns>
#if DEBUG
		[Obsolete]
#endif
		[EditorBrowsable(EditorBrowsableState.Never)]
		public static T forCondition<T>(double secondsTimeout, Func<T> condition, OWait options = null) {
#pragma warning disable CS0612 // Type or member is obsolete
			var loop = new WaitLoop(secondsTimeout, options);
#pragma warning restore CS0612 // Type or member is obsolete
			for (; ; ) {
				T r = condition();
				if (!EqualityComparer<T>.Default.Equals(r, default)) return r;
				if (!loop.Sleep()) return r;
			}
		}
		
		/// <summary>
		/// Calls callback function <i>action</i>. If it throws an exception, waits/retries until it does not throw exceptions or until timeout.
		/// </summary>
		/// <param name="timeout">Timeout, seconds. Can be 0 (infinite), >0 (exception) or &lt;0 (no exception). More info: [](xref:wait_timeout).</param>
		/// <param name="action">Callback function (eg lambda). It is called repeatedly, until does not throw an exception. Default period is 10, and can be changed like <c>wait.retry(new(5) { Timeout = 100 }, ...)</c>.</param>
		/// <param name="catchWhen">Called on exception. Return <c>true</c> to handle the exception (and wait/retry). Return <c>false</c> to not handle the exception. If <c>null</c> (default), handles all exceptions.</param>
		/// <returns>Returns <c>true</c> when <i>action</i> succeeded. On timeout returns <c>false</c> if <i>timeout</i> is negative; else exception.</returns>
		/// <exception cref="TimeoutException"></exception>
		/// <example>
		/// This example uses both <c>wait.retry</c> overloads - with parameter <c>Func func</c> and with parameter <c>Action action</c>.
		/// <code><![CDATA[
		/// string file = @"C:\Test\test.txt";
		/// string s = wait.retry(5, () => File.ReadAllText(file));
		/// s = s.Upper();
		/// wait.retry(5, () => { File.WriteAllText(file, s); });
		/// print.it("ok");
		/// ]]></code>
		/// Set the retry period.
		/// <code><![CDATA[
		/// wait.retry(new(5) { Period = 100, MaxPeriod = 1000 }, () => { File.WriteAllText(file, s); });
		/// ]]></code>
		/// Handle only exceptions of some types.
		/// <code><![CDATA[
		/// wait.retry(5, () => { File.WriteAllText(file, s); }, e => e is IOException);
		/// ]]></code>
		/// </example>
		public static bool retry(Seconds timeout, Action action, Func<Exception, bool> catchWhen = null) {
			var loop = new WaitLoop(timeout);
			for (; ; ) {
				try { action(); return true; }
				catch (Exception e) when (catchWhen?.Invoke(e) != false) { }
				if (!loop.Sleep()) return false;
			}
		}
		
		/// <summary>
		/// Calls callback function <i>func</i> and returns its result. If it throws an exception, waits/retries until it does not throw exceptions or until timeout.
		/// </summary>
		/// <param name="timeout">Timeout, seconds. Can be 0 (infinite), >0 (exception) or &lt;0 (no exception). More info: [](xref:wait_timeout).</param>
		/// <param name="func">Callback function (eg lambda). It is called repeatedly, until does not throw an exception. Default period is 10, and can be changed like <c>wait.retry(new(5) { Timeout = 100 }, ...)</c>.</param>
		/// <param name="catchWhen">Called on exception. Return <c>true</c> to handle the exception (and wait/retry). Return <c>false</c> to not handle the exception. If <c>null</c> (default), handles all exceptions.</param>
		/// <returns>Returns the value returned by the callback function. On timeout returns <c>default(T)</c> if <i>timeout</i> is negative; else exception.</returns>
		/// <exception cref="TimeoutException"></exception>
		public static T retry<T>(Seconds timeout, Func<T> func, Func<Exception, bool> catchWhen = null) {
			var loop = new WaitLoop(timeout);
			for (; ; ) {
				try { return func(); }
				catch (Exception e) when (catchWhen?.Invoke(e) != false) { }
				if (!loop.Sleep()) return default;
			}
		}
		
		//rejected. This overload could be useful when need exact try count and period. But probably rarely useful when we have the overloads with Seconds. Maybe in the future, if really useful. Also need Func overload, CancellationToken, max period, doevents option, etc.
		//public static bool retry(int tryCount, int periodMS, Action action, Func<Exception, bool> catchWhen = null) {
		//	ArgumentOutOfRangeException.ThrowIfEqual(tryCount, 0);
		//	ArgumentOutOfRangeException.ThrowIfNegative(periodMS);
		//	bool noThrow = tryCount < 0; if (noThrow) tryCount = -tryCount;
		//	while (tryCount-- > 0) {
		//		try { action(); return true; }
		//		catch (Exception e) when ((tryCount > 0 || noThrow) && catchWhen?.Invoke(e) != false) { }
		//		if (tryCount > 0 && periodMS > 0) Thread.Sleep(periodMS);
		//	}
		//	return false;
		//}
		
		/// <summary>
		/// Waits for a kernel object (event, mutex, etc).
		/// </summary>
		/// <param name="timeout">Timeout, seconds. Can be 0 (infinite), >0 (exception) or &lt;0 (no exception). More info: [](xref:wait_timeout).</param>
		/// <param name="flags"></param>
		/// <param name="handles">One or more handles of kernel objects. Max 63.</param>
		/// <returns>
		/// Returns 1-based index of the first signaled handle. Negative if abandoned mutex.
		/// On timeout returns 0 if <i>timeout</i> is negative; else exception.
		/// </returns>
		/// <exception cref="TimeoutException"><i>timeout</i> time has expired (if > 0).</exception>
		/// <exception cref="AuException">Failed. For example a handle is invalid.</exception>
		/// <remarks>
		/// Uses API <ms>WaitForMultipleObjectsEx</ms> or <ms>MsgWaitForMultipleObjectsEx</ms>. Alertable.
		/// Does not use <see cref="WaitLoop"/>, <see cref="Seconds.Period"/> and <see cref="Seconds.MaxPeriod"/>.
		/// </remarks>
		public static int forHandle(Seconds timeout, WHFlags flags, params ReadOnlySpan<IntPtr> handles) {
			return WaitS_(timeout, flags, handles);
		}
		
		/// <summary>
		/// Waits for <i>handles</i>, or/and <i>msgCallback</i> returning <c>true</c>, or/and <i>stopVar</i> becoming <c>true</c>.
		/// Calls <see cref="Wait_"/>.
		/// </summary>
		/// <returns>
		/// <br/>• 0 if timeout (if <i>timeout</i> &lt; 0),
		/// <br/>• <c>1-handles.Length</c> if signaled,
		/// <br/>• <c>-(1-handles.Length)</c> if abandoned mutex,
		/// <br/>• <c>1+handles.Length</c> if <i>msgCallback</i> returned <c>true</c>,
		/// <br/>• <c>2+handles.Length</c> if stop became <c>true</c>.
		/// </returns>
		internal static int WaitS_(Seconds timeout, WHFlags flags, ReadOnlySpan<IntPtr> handles = default, Delegate msgCallback = null, WaitVariable_ stopVar = null) {
			if (timeout.Period != null || timeout.MaxPeriod != null) print.warning("This wait function does not use Seconds.Period/MaxPeriod.");
			if (flags.Has(WHFlags.DoEvents)) {
				if (timeout.DoEvents != null) print.warning("This wait function does not use Seconds.DoEvents. It always works like if it is true.");
			} else if (timeout.DoEvents == true) flags |= WHFlags.DoEvents;
			
			long timeMS = _TimeoutS2MS(timeout, out bool canThrow);
			
			int r = Wait_(timeMS, flags, handles, msgCallback, stopVar, timeout.Cancel);
			if (r < 0) throw new AuException(0);
			if (r == Api.WAIT_TIMEOUT) {
				if (canThrow) throw new TimeoutException();
				return 0;
			}
			r++; if (r > Api.WAIT_ABANDONED_0) r = -r;
			return r;
		}
		
		static long _TimeoutS2MS(Seconds timeout, out bool canThrow) {
			canThrow = false;
			var t = timeout.Time;
			if (t == 0) return -1;
			if (t < 0) t = -t; else canThrow = true;
			return checked((long)(t * 1000d));
		}
		
		/// <summary>
		/// Waits for <i>handles</i>, or/and <i>msgCallback</i> returning <c>true</c>, or/and <i>stopVar</i> becoming <c>true</c>. Or just sleeps, if <i>handles</i> etc are <c>null</c>/empty.
		/// If flag <c>DoEvents</c>, dispatches received messages etc.
		/// Calls API <ms>WaitForMultipleObjectsEx</ms> or <ms>MsgWaitForMultipleObjectsEx</ms> with <c>QS_ALLINPUT</c>. Alertable.
		/// </summary>
		/// <param name="msgCallback">
		/// Called when dispatching messages. If returns <c>true</c>, stops waiting and returns <c>handles.Length</c>.
		/// 	If it is <c>WPMCallback</c>, calls it before dispatching a posted message.
		/// 	If it is <c>Func{bool}</c>, calls it after dispatching one or more messages.
		/// </param>
		/// <param name="stopVar">When becomes <c>true</c>, stops waiting and returns <c>handles.Length + 1</c>.</param>
		/// <returns>
		/// When a handle becomes signaled, returns its 0-based index. If abandoned mutex, returns 0-based index + <c>WAIT_ABANDONED_0</c> (0x80).
		/// If <c>timeMS>0</c>, waits max <i>timeMS</i> and on timeout returns <c>WAIT_TIMEOUT</c>.
		/// If failed, returns -1. Supports <see cref="lastError"/>.
		/// </returns>
		internal static unsafe int Wait_(long timeMS, WHFlags flags, ReadOnlySpan<IntPtr> handles = default, Delegate msgCallback = null, WaitVariable_ stopVar = null, CancellationToken cancel = default) {
			//rejected. Don't complicate code to implement rarely used features.
			//if (cancel.CanBeCanceled) {
			//	var ch = cancel.WaitHandle.SafeWaitHandle.DangerousGetHandle();
			//	handles = handles == null ? new[] { ch } : handles.InsertAt(-1, ch);
			//}
			
			bool doEvents = flags.Has(WHFlags.DoEvents);
			Debug.Assert(doEvents || (msgCallback == null && stopVar == null));
			int nHandles = handles.Length;
			bool all = flags.Has(WHFlags.All) && nHandles > 1;
			
			using var mp = new MessagePump_();
			fixed (IntPtr* ha = handles) {
				for (long timePrev = 0; ;) {
					cancel.ThrowIfCancellationRequested();
					if (stopVar != null && stopVar.waitVar) return nHandles + 1;
					
					int timeSlice = all && doEvents ? 50 : cancel.CanBeCanceled ? 250 : 5000;
					if (timeMS > 0) {
						long timeNow = computer.tickCountWithoutSleep;
						if (timePrev > 0) timeMS -= timeNow - timePrev;
						if (timeMS <= 0) return Api.WAIT_TIMEOUT;
						if (timeSlice > timeMS) timeSlice = (int)timeMS;
						timePrev = timeNow;
					} else if (timeMS == 0) timeSlice = 0;
					
					int k;
					if (doEvents && !all) {
						k = Api.MsgWaitForMultipleObjectsEx(nHandles, ha, timeSlice, Api.QS_ALLINPUT, Api.MWMO_ALERTABLE | Api.MWMO_INPUTAVAILABLE);
						if (k == nHandles) { //message, COM, hook, etc
							if (mp.PumpWithCallback(msgCallback)) return nHandles;
							continue;
						}
					} else {
						if (nHandles > 0) k = Api.WaitForMultipleObjectsEx(nHandles, ha, all, timeSlice, true);
						else { k = Api.SleepEx(timeSlice, true); if (k == 0) k = Api.WAIT_TIMEOUT; }
						if (doEvents) if (mp.PumpWithCallback(msgCallback)) return nHandles;
					}
					if (k is not (Api.WAIT_TIMEOUT or Api.WAIT_IO_COMPLETION)) return k; //signaled handle, abandoned mutex, WAIT_FAILED (-1)
				}
			}
		}
		
		/// <summary>
		/// Waits for a posted message received by this thread.
		/// </summary>
		/// <param name="timeout">Timeout, seconds. Can be 0 (infinite), >0 (exception) or &lt;0 (no exception). More info: [](xref:wait_timeout).</param>
		/// <param name="callback">Callback function that returns <c>true</c> to stop waiting. More info in Remarks.</param>
		/// <returns>Returns <c>true</c>. On timeout returns <c>false</c> if <i>timeout</i> is negative; else exception.</returns>
		/// <exception cref="TimeoutException"><i>timeout</i> time has expired (if > 0).</exception>
		/// <remarks>
		/// While waiting, dispatches Windows messages etc, like <see cref="doEvents(int)"/>. Before dispatching a posted message, calls the callback function. Stops waiting when it returns <c>true</c>. Does not dispatch the message if the function sets the message field = 0.
		/// Does not use <see cref="WaitLoop"/>, <see cref="Seconds.Period"/>, <see cref="Seconds.MaxPeriod"/> and <see cref="Seconds.DoEvents"/>.
		/// </remarks>
		/// <example>
		/// <code><![CDATA[
		/// timer.after(2000, t => { print.it("timer"); });
		/// wait.forPostedMessage(5, (ref MSG m) => { print.it(m); return m.message == 0x113; }); //WM_TIMER
		/// print.it("finished");
		/// ]]></code>
		/// </example>
		public static bool forPostedMessage(Seconds timeout, WPMCallback callback) {
			return 1 == WaitS_(timeout, WHFlags.DoEvents, msgCallback: callback);
		}
		
		/// <summary>
		/// Waits for a condition to be changed while processing messages or other events received by this thread.
		/// </summary>
		/// <param name="timeout">Timeout, seconds. Can be 0 (infinite), >0 (exception) or &lt;0 (no exception). More info: [](xref:wait_timeout).</param>
		/// <param name="condition">Callback function that returns <c>true</c> to stop waiting. More info in Remarks.</param>
		/// <returns>Returns <c>true</c>. On timeout returns <c>false</c> if <i>timeout</i> is negative; else exception.</returns>
		/// <exception cref="TimeoutException"><i>timeout</i> time has expired (if > 0).</exception>
		/// <remarks>
		/// While waiting, dispatches Windows messages etc, like <see cref="doEvents(int)"/>. After dispatching one or more messages or other events (posted messages, messages sent by other threads, hooks, COM, APC, etc), calls the callback function. Stops waiting when it returns <c>true</c>.
		/// Similar to <see cref="until"/>. Differences: 1. Always dispatches messages etc. 2. Does not call the callback function when there are no messages etc. 3. Does not use <see cref="WaitLoop"/>, <see cref="Seconds.Period"/>, <see cref="Seconds.MaxPeriod"/> and <see cref="Seconds.DoEvents"/>.
		/// </remarks>
		/// <example>
		/// <code><![CDATA[
		/// bool stop = false;
		/// timer.after(2000, t => { print.it("timer"); stop = true; });
		/// wait.doEventsUntil(5, () => stop);
		/// print.it(stop);
		/// ]]></code>
		/// </example>
		public static bool doEventsUntil(Seconds timeout, Func<bool> condition) {
			return 1 == WaitS_(timeout, WHFlags.DoEvents, msgCallback: condition);
		}
		
		/// <summary>
		/// Obsolete. Use <c>wait.doEventsUntil</c>.
		/// </summary>
		/// <inheritdoc cref="doEventsUntil"/>
#if DEBUG
		[Obsolete] //just renamed
#endif
		[EditorBrowsable(EditorBrowsableState.Never)]
		public static bool forMessagesAndCondition(double secondsTimeout, Func<bool> condition) => doEventsUntil(secondsTimeout, condition);
		
		//rejected. Rarely used; type-limited. Let use wait.until.
		//public static bool forVariable(Seconds timeout, in bool variable, OWait options = null) { }
		
		//FUTURE: add misc wait functions implemented using WindowsHook and WinEventHook.
	}
}

namespace Au.Types {
	/// <summary>
	/// Flags for <see cref="wait.forHandle"/>
	/// </summary>
	[Flags]
	public enum WHFlags {
		/// <summary>
		/// Wait until all handles are signaled.
		/// </summary>
		All = 1,
		
		/// <summary>
		/// While waiting, dispatch Windows messages, events, hooks etc. Like <see cref="wait.doEvents(int)"/>.
		/// </summary>
		DoEvents = 2,
	}
	
	/// <summary>
	/// Delegate type for <see cref="wait.forPostedMessage"/>.
	/// </summary>
	/// <param name="m">API <ms>MSG</ms>.</param>
	public delegate bool WPMCallback(ref MSG m);
	
	/// <summary>
	/// Used with <c>Wait_</c> etc instead of <c>ref bool</c>.
	/// </summary>
	internal class WaitVariable_ {
		public bool waitVar;
	}
}

//CONSIDER: in QM2 these functions are created:
//	WaitForFocus, WaitWhileWindowBusy,
//	WaitForFileReady, WaitForChangeInFolder,
//	ChromeWait, FirefoxWait
//	WaitForTime,
//	these are in System: WaitIdle, WaitForThreads,

//CONSIDER: WaitForFocusChanged
//	Eg when showing Open/SaveAs dialog, the file Edit control receives focus after 200 ms. Sending text to it works anyway, but the script fails if then it clicks OK not with keys (eg with elm).


================================================
FILE: Au/Triggers/Trigger.cs
================================================
namespace Au.Triggers;

/// <summary>
/// Base of classes of all action trigger types.
/// </summary>
public abstract class ActionTrigger {
	internal ActionTrigger next; //linked list when eg same hotkey is used in multiple scopes
	internal readonly ActionTriggers triggers;
	internal readonly TOptions options; //Triggers.Options
	readonly TriggerFunc[] _funcAfter, _funcBefore; //Triggers.FuncOf. _funcAfter used by all triggers; _funcBefore - like scope.
	internal readonly Delegate action;
	
	/// <summary>
	/// <c>Triggers.Of.WindowX</c>. Used by hotkey, autotext and mouse triggers.
	/// </summary>
	public TriggerScope Scope { get; }
	
	///
	public string SourceFile { get; }
	
	///
	public int SourceLine { get; }
	
	internal ActionTrigger(ActionTriggers triggers, Delegate action, bool usesWindowScope, (string, int) source) {
		this.SourceFile = source.Item1 ?? throw new ArgumentNullException();
		this.SourceLine = source.Item2;
		this.action = action;
		this.triggers = triggers;
		var to = triggers.options_;
		options = to.Current;
		EnabledAlways = to.EnabledAlways;
		if (usesWindowScope) Scope = triggers.scopes_.Current_;
		var tf = triggers.funcs_;
		_funcBefore = _Func(tf.commonBefore, tf.nextBefore); tf.nextBefore = null;
		_funcAfter = _Func(tf.nextAfter, tf.commonAfter); tf.nextAfter = null;
		
		TriggerFunc[] _Func(TFunc f1, TFunc f2) {
			var f3 = f1 + f2; if (f3 == null) return null;
			var a1 = f3.GetInvocationList();
			var r1 = new TriggerFunc[a1.Length];
			for (int i = 0; i < a1.Length; i++) {
				var f4 = a1[i] as TFunc;
				if (!tf.perfDict.TryGetValue(f4, out var fs)) tf.perfDict[f4] = fs = new TriggerFunc { f = f4 };
				r1[i] = fs;
			}
			return r1;
		}
	}
	
	internal void DictAdd_<TKey>(Dictionary<TKey, ActionTrigger> d, TKey key) {
		if (!d.TryGetValue(key, out var o)) d.Add(key, this);
		else { //append to the linked list
			while (o.next != null) o = o.next;
			o.next = this;
		}
	}
	
	/// <summary>
	/// Called through <see cref="TriggerActionThreads.Run"/> in action thread.
	/// Possibly runs later.
	/// </summary>
	internal abstract void Run_(TriggerArgs args);
	
	/// <summary>
	/// Makes simpler to implement <see cref="Run_"/>.
	/// </summary>
	private protected void RunT_<T>(T args) => (action as Action<T>)(args);
	
	/// <summary>
	/// Returns a trigger type string, like <c>"Hotkey"</c>, <c>"Mouse"</c>, <c>"Window.ActiveNew"</c>.
	/// </summary>
	public abstract string TypeString { get; }
	
	/// <summary>
	/// Returns a string containing trigger parameters.
	/// </summary>
	public abstract string ParamsString { get; }
	
	/// <summary>
	/// Returns <c>TypeString + " " + ParamsString</c>.
	/// </summary>
	public override string ToString() => TypeString + " " + ParamsString;
	
	internal bool MatchScopeWindowAndFunc_(TriggerHookContext thc) {
		try {
			for (int i = 0; i < 3; i++) {
				if (i == 1) {
					if (Scope != null) {
						thc.PerfStart();
						bool ok = Scope.Match(thc.Window, thc);
						thc.PerfEnd(false, ref Scope.perfTime);
						if (!ok) return false;
					}
				} else {
					var af = i == 0 ? _funcBefore : _funcAfter;
					if (af != null) {
						foreach (var v in af) {
							thc.PerfStart();
							bool ok = v.f(thc.args);
							thc.PerfEnd(true, ref v.perfTime);
							if (!ok) return false;
						}
					}
				}
			}
		}
		catch (Exception ex) {
			print.it(ex);
			return false;
		}
		return true;
		
		//never mind: when same scope used several times (probably with different functions),
		//	should compare it once, and don't call 'before' functions again if did not match. Rare.
	}
	
	internal bool CallFunc_(TriggerArgs args) {
#if true
		if (_funcAfter != null) {
			try {
				foreach (var v in _funcAfter) {
					var t1 = perf.ms;
					bool ok = v.f(args);
					var td = perf.ms - t1;
					if (td > 200) print.warning($"Too slow Triggers.FuncOf function of a window trigger. Should be < 10 ms, now {td} ms. Task name: {script.name}.", -1);
					if (!ok) return false;
				}
			}
			catch (Exception ex) {
				print.it(ex);
				return false;
			}
		}
#else
		for(int i = 0; i < 2; i++) {
			var af = i == 0 ? _funcBefore : _funcAfter;
			if(af != null) {
				foreach(var v in af) {
					bool ok = v.f(args);
					if(!ok) return false;
				}
			}
		}
#endif
		return true;
		//TODO3: measure time more intelligently, like in MatchScope, but maybe give more time.
	}
	
	internal bool HasFunc_ => _funcBefore != null || _funcAfter != null;
	
	//probably not useful. Or also need a property for eg HotkeyTriggers in derived classes.
	///// <summary>
	///// The <see cref="ActionTriggers"/> instance to which this trigger belongs.
	///// </summary>
	//public ActionTriggers Triggers => triggers;
	
	/// <summary>
	/// Gets or sets whether this trigger is disabled.
	/// Does not depend on <see cref="ActionTriggers.Disabled"/>, <see cref="ActionTriggers.DisabledEverywhere"/>, <see cref="EnabledAlways"/>.
	/// </summary>
	public bool Disabled { get; set; }
	
	/// <summary>
	/// Returns <c>true</c> if <see cref="Disabled"/>; also if <see cref="ActionTriggers.Disabled"/> or <see cref="ActionTriggers.DisabledEverywhere"/>, unless <see cref="EnabledAlways"/>.
	/// </summary>
	public bool DisabledThisOrAll => Disabled || (!EnabledAlways && (triggers.Disabled | ActionTriggers.DisabledEverywhere));
	
	/// <summary>
	/// Gets or sets whether this trigger ignores <see cref="ActionTriggers.Disabled"/> and <see cref="ActionTriggers.DisabledEverywhere"/>.
	/// </summary>
	/// <remarks>
	/// When adding the trigger, this property is set to the value of <see cref="TriggerOptions.EnabledAlways"/> at that time.
	/// </remarks>
	public bool EnabledAlways { get; set; }
	
	/// <summary>
	/// Starts the action like when its trigger is activated.
	/// </summary>
	/// <param name="args"></param>
	/// <exception cref="InvalidOperationException">Called before or after <see cref="ActionTriggers.Run"/>.</exception>
	/// <remarks>
	/// This function must be called while the main triggers thread is in <see cref="ActionTriggers.Run"/>, for example from another trigger action. It is asynchronous (does not wait).
	/// If called from a trigger action (hotkey etc), make sure this action runs in another thread or can be queued. Else both actions cannot run simultaneously.
	/// </remarks>
	public void RunAction(TriggerArgs args) {
		triggers.ThrowIfNotRunning_();
		if (triggers.IsMainThread) {
			triggers.RunAction_(this, args);
		} else {
			triggers.SendMsg_(false, () => triggers.RunAction_(this, args));
		}
	}
}

/// <summary>
/// Base of trigger action argument classes of all trigger types.
/// </summary>
public abstract class TriggerArgs {
	/// <summary>
	/// Gets the trigger as <see cref="ActionTrigger"/> (the base class of all trigger type classes).
	/// </summary>
	public abstract ActionTrigger TriggerBase { get; }
	
	/// <summary>
	/// Disables the trigger. Enables later when the toolbar is closed.
	/// Use to implement single-instance toolbars.
	/// </summary>
	public void DisableTriggerUntilClosed(toolbar t) {
		TriggerBase.Disabled = true;
		t.Closed += () => TriggerBase.Disabled = false;
	}
}

/// <summary>
/// Allows to specify working windows for multiple triggers of these types: hotkey, autotext, mouse.
/// </summary>
/// <example>
/// Note: the <c>Triggers</c> in examples is a field or property like <c>readonly ActionTriggers Triggers = new();</c>.
/// <code><![CDATA[
/// Triggers.Hotkey["Ctrl+K"] = o => print.it("this trigger works with all windows");
/// Triggers.Of.Window("* Notepad"); //specifies a working window for triggers added afterwards
/// Triggers.Hotkey["Ctrl+F11"] = o => print.it("this trigger works only when a Notepad window is active");
/// Triggers.Hotkey["Ctrl+F12"] = o => print.it("this trigger works only when a Notepad window is active");
/// var chrome = Triggers.Of.Window("* Chrome"); //specifies another working window for triggers added afterwards
/// Triggers.Hotkey["Ctrl+F11"] = o => print.it("this trigger works only when a Chrome window is active");
/// Triggers.Hotkey["Ctrl+F12"] = o => print.it("this trigger works only when a Chrome window is active");
/// Triggers.Of.AllWindows(); //let triggers added afterwards work with all windows
/// Triggers.Mouse[TMEdge.RightInTop25] = o => print.it("this trigger works with all windows");
/// Triggers.Of.Again(chrome); //sets a previously specified working window for triggers added afterwards
/// Triggers.Mouse[TMEdge.RightInBottom25] = o => print.it("this trigger works only when a Chrome window is active");
/// Triggers.Mouse[TMMove.DownUp] = o => print.it("this trigger works only when a Chrome window is active");
/// Triggers.Mouse[TMClick.Middle] = o => print.it("this trigger works only when the mouse is in a Chrome window");
/// Triggers.Mouse[TMWheel.Forward] = o => print.it("this trigger works only when the mouse is in a Chrome window");
/// Triggers.Run();
/// ]]></code>
/// </example>
public class TriggerScopes {
	internal TriggerScopes() { }
	
	internal TriggerScope Current_ { get; private set; }
	
	//rejected. More confusing than useful.
	///// <summary>
	///// Sets the scope that was active before the last call to any "set scope" function.
	///// </summary>
	//public void PreviousScope() => Current = _previous;
	//internal TriggerScope Current_ { get => _current; private set { _previous = _current; _current = value; } }
	//TriggerScope _current, _previous;
	
	/// <summary>
	/// Sets scope "all windows" again. Hotkey, autotext and mouse triggers added afterwards will work with all windows.
	/// </summary>
	/// <remarks>
	/// Example in class help.
	/// </remarks>
	public void AllWindows() => Current_ = null;
	
	/// <summary>
	/// Sets (reuses) a previously specified scope.
	/// </summary>
	/// <remarks>
	/// Example in class help.
	/// </remarks>
	/// <param name="scope">The return value of function <see cref="Window"/>, <see cref="NotWindow"/>, <see cref="Windows"/> or <see cref="NotWindows"/>.</param>
	public void Again(TriggerScope scope) => Current_ = scope;
	
	/// <summary>
	/// Sets scope "only this window". Hotkey, autotext and mouse triggers added afterwards will work only when the specified window is active.
	/// </summary>
	/// <returns>Returns an object that can be later passed to <see cref="Again"/> to reuse this scope.</returns>
	/// <example><see cref="TriggerScopes"/></example>
	/// <inheritdoc cref="wnd.find" path="//param|//exception"/>
	public TriggerScope Window(
		[ParamString(PSFormat.Wildex)] string name = null,
		[ParamString(PSFormat.Wildex)] string cn = null,
		[ParamString(PSFormat.Wildex)] WOwner of = default,
		Func<wnd, bool> also = null, WContains contains = default)
		=> _Window(false, name, cn, of, also, contains);
	
	/// <summary>
	/// Sets scope "not this window". Hotkey, autotext and mouse triggers added afterwards will not work when the specified window is active.
	/// </summary>
	/// <inheritdoc cref="Window(string, string, WOwner, Func{wnd, bool}, WContains)"/>
	public TriggerScope NotWindow(
		[ParamString(PSFormat.Wildex)] string name = null,
		[ParamString(PSFormat.Wildex)] string cn = null,
		[ParamString(PSFormat.Wildex)] WOwner of = default,
		Func<wnd, bool> also = null, WContains contains = default)
		=> _Window(true, name, cn, of, also, contains);
	
	TriggerScope _Window(bool not, string name, string cn, WOwner of, Func<wnd, bool> also, WContains contains)
		=> _Add(not, new wndFinder(name, cn, of, 0, also, contains));
	
	/// <summary>
	/// Sets scope "only this window". Hotkey, autotext and mouse triggers added afterwards will work only when the specified window is active.
	/// </summary>
	/// <returns>Returns an object that can be later passed to <see cref="Again"/> to reuse this scope.</returns>
	public TriggerScope Window(wndFinder f)
		=> _Add(false, f);
	
	/// <summary>
	/// Sets scope "not this window". Hotkey, autotext and mouse triggers added afterwards will not work when the specified window is active.
	/// </summary>
	/// <returns>Returns an object that can be later passed to <see cref="Again"/> to reuse this scope.</returns>
	public TriggerScope NotWindow(wndFinder f)
		=> _Add(true, f);
	
	//rejected. May be used incorrectly. Rare. When really need, can use the 'also' parameter.
	///// <summary>
	///// Sets scope "only this window". Hotkey, autotext and mouse triggers added afterwards will work only when the specified window is active.
	///// </summary>
	///// <returns>Returns an object that can be later passed to <see cref="Again"/> to reuse this scope.</returns>
	///// <exception cref="AuWndException">Invalid window handle.</exception>
	//public TriggerScope Window(wnd w)
	//	=> _Add(false, w);
	
	///// <summary>
	///// Sets scope "not this window". Hotkey, autotext and mouse triggers added afterwards will not work when the specified window is active.
	///// </summary>
	///// <returns>Returns an object that can be later passed to <see cref="Again"/> to reuse this scope.</returns>
	///// <exception cref="AuWndException">Invalid window handle.</exception>
	//public TriggerScope NotWindow(wnd w)
	//	=> _Add(true, w);
	
	/// <summary>
	/// Sets scope "only these windows". Hotkey, autotext and mouse triggers added afterwards will work only when one of the specified windows is active.
	/// </summary>
	/// <returns>Returns an object that can be later passed to <see cref="Again"/> to reuse this scope.</returns>
	/// <param name="any">Specifies windows, like <c>new("Window1"), new("Window2")</c>.</param>
	public TriggerScope Windows(params wndFinder[] any)
		=> _Add(false, any);
	
	/// <summary>
	/// Sets scope "not these windows". Hotkey, autotext and mouse triggers added afterwards will not work when one of the specified windows is active.
	/// </summary>
	/// <returns>Returns an object that can be later passed to <see cref="Again"/> to reuse this scope.</returns>
	/// <param name="any">Specifies windows, like <c>new("Window1"), new("Window2")</c>.</param>
	public TriggerScope NotWindows(params wndFinder[] any)
		=> _Add(true, any);
	
	TriggerScope _Add(bool not, wndFinder f) {
		Not_.Null(f);
		Used_ = true;
		return Current_ = new TriggerScope(f, not);
	}
	
	TriggerScope _Add(bool not, wndFinder[] a) {
		if (a.Length == 1) return _Add(not, a[0]);
		foreach (var v in a) if (v == null) throw new ArgumentNullException();
		Used_ = true;
		return Current_ = new TriggerScope(a, not);
	}
	
	internal bool Used_ { get; private set; }
}

/// <summary>
/// A trigger scope returned by functions like <see cref="TriggerScopes.Window"/> and used with <see cref="TriggerScopes.Again"/>.
/// </summary>
/// <example>See <see cref="TriggerScopes"/>.</example>
public class TriggerScope {
	internal readonly object o; //wndFinder, wndFinder[]
	internal readonly bool not;
	internal int perfTime;
	
	internal TriggerScope(object o, bool not) {
		this.o = o;
		this.not = not;
	}
	
	/// <summary>
	/// Returns <c>true</c> if the window matches this scope.
	/// </summary>
	public bool Match(wnd w, WFCache cache) {
		bool yes = false;
		if (!w.Is0) {
			switch (o) {
			case wndFinder f:
				yes = f.IsMatch(w, cache);
				break;
			case wndFinder[] a:
				foreach (var v in a) {
					if (yes = v.IsMatch(w, cache)) break;
				}
				break;
			}
		}
		return yes ^ not;
	}
}

/// <summary>
/// Allows to define custom scopes/contexts/conditions for triggers.
/// </summary>
/// <remarks>
/// Similar to <see cref="TriggerScopes"/> (code like <c>Triggers.Of.Window(...);</c>), but allows to define any scope/condition/etc, not just the active window.
/// 
/// To define a scope, you create a callback function (CF) that checks some conditions and returns <c>true</c> to allow the trigger action to run or <c>false</c> to not allow. Assign the CF to some property of this class and then add the trigger, like in the examples below. The CF will be assigned to the trigger and called when need.
/// 
/// You may ask: why to use CF when the trigger action (TA) can do the same?
/// 1. CF runs synchronously; if it returns <c>false</c>, the trigger key or mouse button message is passed to other triggers, hooks and apps. TA cannot do it reliably; it runs asynchronously, and the message is already stealed from other apps/triggers/hooks.
/// 2. CF is faster to call. It is simply called in the same thread that processes trigger messages. TA usually runs in another thread.
/// 3. A CF can be assigned to multiple triggers with a single line of code. Don't need to add the same code in all trigger actions.
/// 
/// A trigger can have up to 4 CF delegates and a window scope (<c>Triggers.Of...</c>). They are called in this order: CF assigned through <see cref="FollowingTriggersBeforeWindow"/>, <see cref="NextTriggerBeforeWindow"/>, window scope, <see cref="NextTrigger"/>, <see cref="FollowingTriggers"/>. The <c>NextX</c> properties assign the CF to the next single trigger. The <c>FollowingX</c> properties assign the CF to all following triggers until you assign another CF or <c>null</c>. If several are assigned, the trigger action runs only if all CF return <c>true</c> and the window scope matches. The <c>XBeforeWindow</c> properties are used only with hotkey, autotext and mouse triggers.
/// 
/// All CF must be as fast as possible. Slow CF can make triggers slower (or even all keyboard/mouse input); also may cause warnings and trigger failures. A big problem is the low-level hooks timeout that Windows applies to trigger hooks; see <see cref="More.WindowsHook.LowLevelHooksTimeout"/>. A related problem - slow JIT and loading of assemblies, which can make the CF too slow the first time; in some rare cases may even need to preload assemblies or pre-JIT functions to avoid the timeout warning.
///
/// In CF never use functions that generate keyboard or mouse events or activate windows.
/// </remarks>
/// <example>
/// Note: the <c>Triggers</c> in examples is a field or property like <c>readonly ActionTriggers Triggers = new();</c>.
/// <code><![CDATA[
/// //examples of assigning a callback function (CF) to a single trigger
/// Triggers.FuncOf.NextTrigger = o => keys.isCapsLock; //o => keys.isCapsLock is the callback function (lambda)
/// Triggers.Hotkey["Ctrl+K"] = o => print.it("action: Ctrl+K while CapsLock is on");
/// Triggers.FuncOf.NextTrigger = o => { var v = o as HotkeyTriggerArgs; print.it($"func: mod={v.Mod}"); return mouse.isPressed(MButtons.Left); };
/// Triggers.Hotkey["Ctrl+Shift?+B"] = o => print.it("action: mouse left button + Ctrl+B or Ctrl+Shift+B");
/// 
/// //examples of assigning a CF to multiple triggers
/// Triggers.FuncOf.FollowingTriggers = o => { var v = o as HotkeyTriggerArgs; print.it("func", v); return true; };
/// Triggers.Hotkey["Ctrl+F8"] = o => print.it("action: " + o);
/// Triggers.Hotkey["Ctrl+F9"] = o => print.it("action: " + o);
/// Triggers.FuncOf.FollowingTriggers = null; //stop assigning the CF to triggers added afterwards
/// 
/// //sometimes all work can be done in CF and you don't need the trigger action
/// Triggers.FuncOf.NextTrigger = o => { var v = o as HotkeyTriggerArgs; print.it("func: " + v); return true; };
/// Triggers.Hotkey["Ctrl+F12"] = null;
/// 
/// Triggers.Run();
/// ]]></code>
/// </example>
public class TriggerFuncs {
	internal TriggerFuncs() { }
	
	internal Dictionary<TFunc, TriggerFunc> perfDict = new Dictionary<TFunc, TriggerFunc>();
	
	//internal bool Used_ { get; private set; }
	
	internal TFunc nextAfter, nextBefore, commonAfter, commonBefore;
	
	/// <summary>
	/// Sets callback function for the next added trigger.
	/// Called after evaluating the window scope (if any).
	/// </summary>
	public TFunc NextTrigger {
		get => nextAfter;
		set => nextAfter = _Func(value);
	}
	
	/// <summary>
	/// Sets callback function for the next added trigger (except window triggers).
	/// Called before evaluating the window scope (if any).
	/// </summary>
	public TFunc NextTriggerBeforeWindow {
		get => nextBefore;
		set => nextBefore = _Func(value);
	}
	
	/// <summary>
	/// Sets callback function for triggers added afterwards.
	/// Called after evaluating the window scope (if any).
	/// </summary>
	public TFunc FollowingTriggers {
		get => commonAfter;
		set => commonAfter = _Func(value);
	}
	
	/// <summary>
	/// Sets callback function for triggers added afterwards (except window triggers).
	/// Called before evaluating the window scope (if any).
	/// </summary>
	public TFunc FollowingTriggersBeforeWindow {
		get => commonBefore;
		set => commonBefore = _Func(value);
	}
	
	TFunc _Func(TFunc f) {
		//if(f != null) Used = true;
		return f;
	}
	
	/// <summary>
	/// Clears all properties (sets = <c>null</c>).
	/// </summary>
	public void Reset() {
		nextAfter = null;
		nextBefore = null;
		commonAfter = null;
		commonBefore = null;
	}
}

class TriggerFunc {
	internal TFunc f;
	internal int perfTime;
}

/// <summary>
/// Type of functions used with class <see cref="TriggerFuncs"/> to define custom scope for triggers.
/// </summary>
/// <param name="args">Trigger action arguments. Example: <see cref="TriggerFuncs"/>.</param>
/// <returns>Return <c>true</c> to run the trigger action, or <c>false</c> to not run.</returns>
public delegate bool TFunc(TriggerArgs args);


================================================
FILE: Au/Triggers/Triggers.cs
================================================
namespace Au.Triggers;

/// <summary>
/// The main class of action triggers.
/// </summary>
/// <remarks>
/// This class manages action triggers. Action triggers are used to call functions (aka <i>trigger actions</i>) in a running script in response to events such as hotkey, typed text, mouse action, activated window. To launch scripts are used other ways: manually, at startup, command line, <see cref="script.run"/>, output link.
/// 
/// If your script has a variable, field or property like <c>ActionTriggers Triggers = new();</c>, through it you can access all trigger types (hotkey, window, etc) and add triggers to them.
/// 
/// Code syntax to add an action trigger:
/// <code>Triggers.TriggerType[parameters] = action;</code>
/// Examples:
/// <code><![CDATA[
/// Triggers.Hotkey["Ctrl+K"] = o => print.it(o);
/// Triggers.Hotkey["Ctrl+Shift+K"] = o => {
/// 	print.it("This is a trigger action (lambda function).");
/// 	print.it($"It runs when you press {o}.");
/// };
/// Triggers.Run();
/// ]]></code>
/// 
/// Also you can set options (<see cref="TriggerOptions"/>), window scopes (<see cref="TriggerScopes"/>) and custom scopes (<see cref="TriggerFuncs"/>) for triggers added afterwards.
/// 
/// Finally call <see cref="Run"/> or <see cref="RunThread"/>. It runs all the time and launches trigger actions (functions) when need. Actions run in other thread(s) by default.
/// 
/// To quickly restart the script when editing, click the <b>Run</b> button.
/// 
/// Avoid multiple scripts with triggers. Each running instance uses some CPU. All triggers should be in single script, if possible. It's OK to run additional scripts temporarily, for example to test new triggers without restarting the main script. From trigger actions you can call <see cref="script.run"/> to run other scripts in new process; see example.
/// 
/// Trigger actions may not inherit <see cref="opt"/> options that are set before adding triggers. The example shows how to correctly set <see cref="opt"/> options for multiple actions. Also you can set them in action code. Next action running in the same thread will not inherit <see cref="opt"/> options set by previous action.
/// </remarks>
/// <example>
/// This is a single script with many action triggers.
/// <code><![CDATA[
/// using Au.Triggers;
/// 
/// ActionTriggers Triggers = new();
/// //readonly ActionTriggers Triggers = new(); //or add this field if you'll use triggers in a class
/// 
/// //you can set options for triggers added afterwards
/// Triggers.Options.Thread(0, 500);
/// 
/// //you can use variables if don't want to type "Triggers.Hotkey" etc for each trigger
/// var hk = Triggers.Hotkey;
/// var mouse = Triggers.Mouse;
/// var win = Triggers.Window;
/// var tt = Triggers.Autotext;
/// 
/// //hotkey triggers
/// 
/// hk["Ctrl+K"] = o => print.it(o); //it means: execute code "o => print.it(o)" when I press Ctrl+K
/// hk["Ctrl+Shift+F11"] = o => {
/// 	print.it(o);
/// 	var w1 = wnd.findOrRun("* Notepad", run: () => run.it(folders.System + "notepad.exe"));
/// 	keys.sendt("text");
/// 	w1.Close();
/// };
/// hk["Win+Alt+K"] = o => script.run("Example.cs"); //run another script in new process
/// 
/// //triggers that work only with some windows
/// 
/// Triggers.Of.Window("* Chrome", "Chrome_WidgetWin_1"); //let the following triggers work only when a Chrome window is active
/// hk["Ctrl+F5"] = o => print.it(o, o.Window);
/// hk["Ctrl+F6"] = o => print.it(o, o.Window);
/// 
/// var notepad = Triggers.Of.Window("* Notepad"); //let the following triggers work only when a Notepad window is active
/// hk["Ctrl+F5"] = o => print.it(o, o.Window);
/// hk["Ctrl+F6"] = o => print.it(o, o.Window);
/// 
/// Triggers.Of.AllWindows(); //let the following triggers work with all windows
/// 
/// //mouse triggers
/// 
/// mouse[TMClick.Right, "Ctrl+Shift", TMFlags.ButtonModUp] = o => print.it(o);
/// mouse[TMEdge.RightInCenter50] = o => { print.it(o); dialog.show("Bang!", x: Coord.Max); };
/// mouse[TMMove.LeftRightInCenter50] = o => wnd.switchActiveWindow();
/// 
/// Triggers.FuncOf.NextTrigger = o => keys.isScrollLock; //example of a custom scope (aka context, condition)
/// mouse[TMWheel.Forward] = o => print.it($"{o} while ScrollLock is on");
/// 
/// Triggers.Of.Again(notepad); //let the following triggers work only when a Notepad window is active
/// mouse[TMMove.LeftRightInBottom25] = o => { print.it(o); o.Window.Close(); };
/// Triggers.Of.AllWindows();
/// 
/// //window triggers. Note: window triggers don't depend on Triggers.Of.
/// 
/// win[TWEvent.ActiveNew, "* Notepad", "Notepad"] = o => print.it("opened Notepad window");
/// win[TWEvent.ActiveNew, "Notepad", "#32770", contains: "Do you want to save *"] = o => {
/// 	print.it("opened Notepad's 'Do you want to save' dialog");
/// 	//keys.send("Alt+S"); //click the Save button
/// };
/// 
/// //autotext triggers
/// 
/// tt["los"] = o => o.Replace("Los Angeles");
/// tt["WIndows", TAFlags.MatchCase] = o => o.Replace("Windows");
/// tt.DefaultPostfixType = TAPostfix.None;
/// tt["<b>"] = o => o.Replace("<b>[[|]]</b>");
/// tt["#file"] = o => {
/// 	o.Replace("");
/// 	var fd = new FileOpenSaveDialog();
/// 	if(fd.ShowOpen(out string file)) keys.sendt(file);
/// };
/// tt.DefaultPostfixType = default;
/// 
/// //shorter auto-replace code
/// 
/// var ts = Triggers.Autotext.SimpleReplace;
/// ts["#so"] = "Some text"; //the same as tt["#so"] = o => o.Replace("Some text");
/// ts["#mo"] = "More text";
/// 
/// //how to set opt options for trigger actions
/// 
/// Triggers.Options.BeforeAction = o => { opt.key.TextHow = OKeyText.Paste; }; //sets opt before executing an action
/// ts["#p1"] = "text 1";
/// ts["#p2"] = "text 2";
/// Triggers.Options.BeforeAction = null;
/// 
/// //initial opt for ALL trigger actions also can be set ONCE when adding triggers. Use Triggers.Options.BeforeAction if want to override some options for some trigger actions.
/// 
/// opt.key.TextHow = OKeyText.Paste;
/// //then add all triggers
/// 
/// //how to stop and disable/enable triggers
/// 
/// hk["Ctrl+Alt+Q"] = o => Triggers.Stop(); //let Triggers.Run() end its work and return
/// hk.Last.EnabledAlways = true;
/// 
/// hk["Ctrl+Alt+D"] = o => Triggers.Disabled ^= true; //disable/enable triggers here
/// hk.Last.EnabledAlways = true;
/// 
/// hk["Ctrl+Alt+Win+D"] = o => ActionTriggers.DisabledEverywhere ^= true; //disable/enable triggers in all processes
/// hk.Last.EnabledAlways = true;
/// 
/// hk["Ctrl+F7"] = o => print.it("This trigger can be disabled/enabled with Ctrl+F8.");
/// var t1 = hk.Last;
/// hk["Ctrl+F8"] = o => t1.Disabled ^= true; //disable/enable a trigger
/// 
/// //finally call Triggers.Run(). Without it the triggers won't work.
/// Triggers.Run();
/// //Triggers.Run returns when is called Triggers.Stop (see the "Ctrl+Alt+Q" trigger above).
/// print.it("called Triggers.Stop");
/// ]]></code>
/// </example>
public partial class ActionTriggers {
	readonly ITriggers[] _t;
	ITriggers this[TriggerType e] => _t[(int)e];
	
	/// <summary>
	/// Initializes a new instance of this class.
	/// </summary>
	public ActionTriggers() {
		_t = new ITriggers[4];
		scopes_ = new TriggerScopes();
		funcs_ = new TriggerFuncs();
		options_ = new TriggerOptions();
	}
	
	//public TriggerScopes Of {
	//	get {
	//		if(_test == false){
	//			Debug_.MemorySetAnchor_();
	//			timer.after(500, _ => Debug_.MemoryPrint_());
	//		}
	
	//		var k=new StackFrame(1, true);
	//		//new StackTrace(1, true);
	//		var s = k.GetFileName();
	
	//		//if(_test == false) _s1 = s; else print.it(ReferenceEquals(s, _s1));
	
	//			 _test = true;
	
	//		return scopes;
	//	}
	//}
	//static bool _test;
	//static string _s1;
	
	/// <summary>
	/// Allows to set window scopes (working windows) for triggers.
	/// </summary>
	/// <remarks>Examples: <see cref="TriggerScopes"/>, <see cref="ActionTriggers"/>.</remarks>
	public TriggerScopes Of => scopes_;
	internal readonly TriggerScopes scopes_;
	
	/// <summary>
	/// Allows to set custom scopes/contexts/conditions for triggers.
	/// </summary>
	/// <remarks>More info and examples: <see cref="TriggerFuncs"/>, <see cref="ActionTriggers"/>.</remarks>
	public TriggerFuncs FuncOf => funcs_;
	internal readonly TriggerFuncs funcs_;
	
	/// <summary>
	/// Allows to set some options for multiple triggers and their actions.
	/// </summary>
	/// <remarks>More info and examples: <see cref="TriggerOptions"/>, <see cref="ActionTriggers"/>.</remarks>
	public TriggerOptions Options => options_;
	internal readonly TriggerOptions options_;
	
	/// <summary>
	/// Clears all options (of <see cref="Options"/>, <see cref="Of"/>, <see cref="FuncOf"/>, <see cref="Autotext"/>).
	/// </summary>
	public void ResetOptions() {
		Of.AllWindows();
		FuncOf.Reset();
		Options.Reset();
		Autotext.ResetOptions();
	}
	
	ITriggers _Get(TriggerType e) {
		int i = (int)e;
		var t = _t[i];
		if (t == null) {
			switch (e) {
			case TriggerType.Hotkey: t = new HotkeyTriggers(this); break;
			case TriggerType.Autotext: t = new AutotextTriggers(this); break;
			case TriggerType.Mouse: t = new MouseTriggers(this); break;
			case TriggerType.Window: t = new WindowTriggers(this); break;
			default: Debug.Assert(false); break;
			}
			_t[i] = t;
		}
		return t;
	}
	
	/// <summary>
	/// Hotkey triggers.
	/// </summary>
	/// <example>See <see cref="ActionTriggers"/>.</example>
	public HotkeyTriggers Hotkey => _Get(TriggerType.Hotkey) as HotkeyTriggers;
	
	/// <summary>
	/// Autotext triggers.
	/// </summary>
	/// <example>See <see cref="ActionTriggers"/>.</example>
	public AutotextTriggers Autotext => _Get(TriggerType.Autotext) as AutotextTriggers;
	
	/// <summary>
	/// Mouse triggers.
	/// </summary>
	/// <example>See <see cref="ActionTriggers"/>.</example>
	public MouseTriggers Mouse => _Get(TriggerType.Mouse) as MouseTriggers;
	
	/// <summary>
	/// Window triggers.
	/// </summary>
	/// <example>See <see cref="ActionTriggers"/>.</example>
	public WindowTriggers Window => _Get(TriggerType.Window) as WindowTriggers;
	
	/// <summary>
	/// Makes triggers alive.
	/// </summary>
	/// <remarks>
	/// This function monitors hotkeys, activated windows and other events. When an event matches an added trigger, launches the trigger's action, which runs in other thread by default.
	/// Does not return immediately. Runs until this process is terminated or <see cref="Stop"/> called.
	/// </remarks>
	/// <example>See <see cref="ActionTriggers"/>.</example>
	/// <exception cref="InvalidOperationException">Already running.</exception>
	/// <exception cref="AuException">Something failed.</exception>
	public unsafe void Run() {
		//Debug_.PrintLoadedAssemblies(true, true, true);
		
		ThrowIfRunning_();
		
		//bool haveTriggers = false;
		HooksThread.UsedEvents hookEvents = 0;
		_windowTriggers = null;
		for (int i = 0; i < _t.Length; i++) {
			var t = _t[i];
			if (t == null || !t.HasTriggers) continue;
			//haveTriggers = true;
			switch ((TriggerType)i) {
			case TriggerType.Hotkey: hookEvents |= HooksThread.UsedEvents.Keyboard; break;
			case TriggerType.Autotext: hookEvents |= HooksThread.UsedEvents.Keyboard | HooksThread.UsedEvents.Mouse; break;
			case TriggerType.Mouse: hookEvents |= (t as MouseTriggers).UsedHookEvents_; break;
			case TriggerType.Window: _windowTriggers = t as WindowTriggers; break;
			}
		}
		//print.it(haveTriggers, (uint)llHooks);
		//if(!haveTriggers) return; //no. The message loop may be used for toolbars etc.
		
		if (!s_wasRun) {
			s_wasRun = true;
			WndUtil.RegisterWindowClass(c_cn);
		}
		_wMsg = WndUtil.CreateMessageOnlyWindow(_WndProc, c_cn);
		_mainThreadId = Api.GetCurrentThreadId();
		_winTimerPeriod = 0;
		_winTimerLastTime = 0;
		
		if (hookEvents != 0) {
			//prevent big delay (JIT) later on first LL hook event while hook proc waits
			if (!s_wasKM) {
				s_wasKM = true;
				ThreadPool.QueueUserWorkItem(_ => {
					try {
						//using var p1 = perf.local();
						new wndFinder("*a").IsMatch(wnd.getwnd.root); //if used window scopes etc
						_ = WindowsHook.LowLevelHooksTimeout; //slow JIT of registry functions
						Jit_.Compile(typeof(ActionTriggers), nameof(_WndProc), nameof(_KeyMouseEvent));
						Jit_.Compile(typeof(TriggerHookContext), nameof(TriggerHookContext.InitContext), nameof(TriggerHookContext.PerfEnd), nameof(TriggerHookContext.PerfWarn));
						Jit_.Compile(typeof(ActionTrigger), nameof(ActionTrigger.MatchScopeWindowAndFunc_));
						Jit_.Compile(typeof(HotkeyTriggers), nameof(HotkeyTriggers.HookProc));
						AutotextTriggers.JitCompile();
						MouseTriggers.JitCompile();
					}
					catch (Exception ex) { Debug_.Print(ex); }
				});
			}
			
			_thc = new TriggerHookContext(this);
			
			_ht = new HooksThread(hookEvents, _wMsg);
		}
		
		try {
			_evStop = Api.CreateEvent(false);
			_StartStopAll(true);
			IntPtr h = _evStop;
			_Wait(&h, 1);
		}
		finally {
			if (hookEvents != 0) {
				_ht.Dispose(); _ht = null;
			}
			Api.DestroyWindow(_wMsg); _wMsg = default;
			Stopping?.Invoke(this, EventArgs.Empty);
			_evStop.Dispose();
			_StartStopAll(false);
			_mainThreadId = 0;
			_threads?.Dispose(); _threads = null;
		}
		
		void _StartStopAll(bool start) {
			foreach (var t in _t) {
				if (t?.HasTriggers == true) t.StartStop(start);
			}
		}
	}
	
	/// <summary>
	/// Executes <see cref="Run"/> in new thread and waits like <see cref="wait.doEvents(int)"/>.
	/// </summary>
	public void RunThread() {
		using var th = run.thread(out _, out _, Run);
		wait.forHandle(0, WHFlags.DoEvents, th.DangerousGetHandle());
	}
	
	int _mainThreadId;
	wnd _wMsg;
	HooksThread _ht;
	TriggerHookContext _thc;
	static bool s_wasRun, s_wasKM;
	const string c_cn = "Au.Triggers.Hooks";
	
	nint _WndProc(wnd w, int message, nint wParam, nint lParam) {
		try {
			switch (message) {
			case Api.WM_USER + 1:
				//_ht.Return((int)wParam, false); //test speed without _KeyMouseEvent
				_KeyMouseEvent((int)wParam, (HooksThread.UsedEvents)lParam);
				return 0;
			//case Api.WM_USER + 2: //rejected
			//	ShowTriggersListWindow((int)wParam);
			//	return 0;
			case Api.WM_USER + 10: //run any action
				if(((GCHandle)lParam).Target is Action ac) {
					((GCHandle)lParam).Free();
					ac();
				}
				return 0;
			}
		}
		catch (Exception ex) { Debug_.Print(ex); return default; }
		
		return Api.DefWindowProc(w, message, wParam, lParam);
	}
	
	unsafe void _KeyMouseEvent(int messageId, HooksThread.UsedEvents eventType) {
		//perf.first();
		//perf.next();
		_thc.InitContext();
		//perf.next();
		bool eat = false;
		if (eventType == HooksThread.UsedEvents.Keyboard) {
			//print.it("key");
			if (!_ht.GetKeyData(messageId, out var data)) return;
			var k = new HookData.Keyboard(null, (nint)(&data)); //TODO3: now probably can be simplified, because not using a server
			_thc.InitMod(k);
			if (this[TriggerType.Hotkey] is HotkeyTriggers tk) { //if not null
				eat = tk.HookProc(k, _thc);
			}
			if (!eat /*&& _thc.trigger == null*/ && this[TriggerType.Autotext] is AutotextTriggers ta) {
				ta.HookProc(k, _thc);
			}
		} else if (eventType == HooksThread.UsedEvents.MouseEdgeMove) {
			//print.it("edge/move");
			if (this[TriggerType.Mouse] is MouseTriggers tm) {
				if (!_ht.GetEdgeMoveData(messageId, out var data)) return;
				tm.HookProcEdgeMove(data, _thc);
			}
		} else {
			//print.it("click/wheel");
			if (this[TriggerType.Mouse] is MouseTriggers tm) {
				if (!_ht.GetClickWheelData(messageId, out var data, out int message)) return;
				var k = new HookData.Mouse(null, message, (nint)(&data));
				eat = tm.HookProcClickWheel(k, _thc);
			}
		}
		//perf.next();
		_thc.PerfWarn();
		//perf.next();
		
		//var mem = GC.GetTotalMemory(false);
		//if(mem != _debugMem && _debugMem != 0) print.it(mem - _debugMem);
		//_debugMem = mem;
		
		if (!_ht.Return(messageId, eat)) return;
		//perf.nw();
		if (_thc.trigger != null) RunAction_(_thc.trigger, _thc.args, _thc.muteMod);
	}
	
	//long _debugMem;
	
	internal void RunAction_(ActionTrigger trigger, TriggerArgs args, int muteMod = 0) {
		if (trigger.action != null) {
			_threads ??= new TriggerActionThreads();
			_threads.Run(trigger, args, muteMod);
		} else Debug.Assert(muteMod == 0);
	}
	TriggerActionThreads _threads;
	
	/// <summary>
	/// Stops trigger engines and causes <see cref="Run"/> to return.
	/// </summary>
	/// <remarks>
	/// Does not abort threads of trigger actions that are still running.
	/// </remarks>
	/// <example>
	/// Note: the <c>Triggers</c> in examples is a field or property like <c>readonly ActionTriggers Triggers = new();</c>.
	/// <code><![CDATA[
	/// Triggers.Hotkey["Ctrl+T"] = o => print.it("Ctrl+T");
	/// Triggers.Hotkey["Ctrl+Q"] = o => { print.it("Ctrl+Q (stop)"); Triggers.Stop(); };
	/// Triggers.Hotkey.Last.EnabledAlways = true;
	/// Triggers.Run();
	/// print.it("stopped");
	/// ]]></code>
	/// </example>
	public void Stop() {
		Api.SetEvent(_evStop);
	}
	Handle_ _evStop;
	
	/// <summary>
	/// Occurs before <see cref="Run"/> stops trigger engines and returns.
	/// </summary>
	public event EventHandler Stopping;
	
	/// <summary>
	/// True if executing <see cref="Run"/>.
	/// </summary>
	internal bool Running_ => !_evStop.Is0;
	
	/// <summary>
	/// Throws <see cref="InvalidOperationException"/> if executing <see cref="Run"/>.
	/// </summary>
	internal void ThrowIfRunning_() {
		if (Running_) throw new InvalidOperationException("Must be before or after Run.");
	}
	
	/// <summary>
	/// Throws <see cref="InvalidOperationException"/> if not executing <see cref="Run"/>.
	/// </summary>
	internal void ThrowIfNotRunning_() {
		if (!Running_) throw new InvalidOperationException("Cannot be before or after Run.");
	}
	
	/// <summary>
	/// Throws <see cref="InvalidOperationException"/> if not thread of <see cref="Run"/>.
	/// </summary>
	internal void ThrowIfNotMainThread_() {
		if (!IsMainThread) throw new InvalidOperationException("Must be in thread of Run (for example in a FuncOf function).");
	}
	
	/// <summary>
	/// Returns <i>true</i> in thread of <see cref="Run"/>.
	/// </summary>
	internal bool IsMainThread => Api.GetCurrentThreadId() == _mainThreadId;
	
	/// <summary>
	/// Gets or sets whether triggers of this <see cref="ActionTriggers"/> instance are disabled.
	/// </summary>
	/// <remarks>
	/// Does not depend on <see cref="DisabledEverywhere"/>.
	/// Does not end/pause threads of trigger actions.
	/// </remarks>
	/// <seealso cref="ActionTrigger.EnabledAlways"/>
	/// <seealso cref="TriggerOptions.EnabledAlways"/>
	/// <example>
	/// Note: the <c>Triggers</c> in examples is a field or property like <c>readonly ActionTriggers Triggers = new();</c>.
	/// <code><![CDATA[
	/// Triggers.Hotkey["Ctrl+T"] = o => print.it("Ctrl+T");
	/// Triggers.Hotkey["Ctrl+D"] = o => { print.it("Ctrl+D (disable/enable)"); Triggers.Disabled ^= true; }; //toggle
	/// Triggers.Hotkey.Last.EnabledAlways = true;
	/// Triggers.Run();
	/// ]]></code>
	/// </example>
	public bool Disabled { get; set; }
	
	/// <summary>
	/// Gets or sets whether triggers are disabled in all processes that use this library in this user session.
	/// </summary>
	/// <example>See <see cref="ActionTriggers"/>.</example>
	/// <seealso cref="Disabled"/>
	/// <seealso cref="TriggerOptions.EnabledAlways"/>
	public static unsafe bool DisabledEverywhere {
		get => SharedMemory_.Ptr->triggers.disabled;
		set {
			if (value == DisabledEverywhere) return;
			SharedMemory_.Ptr->triggers.disabled = value;
			var w = ScriptEditor.WndMsg_;
			if (!w.Is0) w.SendNotify(Api.WM_USER, 20); //update tray icon etc
		}
	}
	
	[StructLayout(LayoutKind.Sequential, Size = 16)] //note: this struct is in shared memory. Size must be same in all library versions.
	internal struct SharedMemoryData_ {
		public bool disabled;
		public bool resetAutotext;
	}
	
	/// <summary>
	/// Sends a sync or async message to _wMsg (_WndProc in the triggers thread).
	/// </summary>
	internal void SendMsg_(bool sync, int message, nint wParam = 0, nint lParam = 0) {
		if (sync) _wMsg.Send(message, wParam, lParam);
		else _wMsg.SendNotify(message, wParam, lParam);
	}
	
	/// <summary>
	/// Sends a sync or async message to _wMsg (_WndProc in the triggers thread).
	/// </summary>
	internal void SendMsg_(bool sync, Action a) {
		SendMsg_(sync, Api.WM_USER + 10, 0, (nint)GCHandle.Alloc(a));
	}
	
	unsafe int _Wait(IntPtr* ha, int nh) {
		for (; ; ) {
			int slice = -1;
			if (_winTimerPeriod > 0) {
				long t = perf.ms;
				if (_winTimerLastTime == 0) _winTimerLastTime = t;
				int td = (int)(t - _winTimerLastTime);
				int period = _Period();
				if (td >= period - 5) {
					_winTimerLastTime = t;
					_windowTriggers?.Timer_();
					slice = _Period();
				} else slice = period - td;
				
				int _Period() => _winTimerPeriod / 15 * 15 + 10;
				
				//This code is a variable-frequency timer that uses less CPU than Windows timer.
				//	Never mind: the timer does not work if user code creates a nested message loop in this thread. They should avoid it. It is documented, such functions must return ASAP.
			}
			var k = Api.MsgWaitForMultipleObjectsEx(nh, ha, slice, Api.QS_ALLINPUT, Api.MWMO_ALERTABLE | Api.MWMO_INPUTAVAILABLE);
			if (k == nh) { //message, COM, hook, etc
				if (!wait.doEvents()) return -1;
			} else if (k is not (Api.WAIT_TIMEOUT or Api.WAIT_IO_COMPLETION)) return k; //signaled handle, abandoned mutex, WAIT_FAILED (-1)
		}
	}
	long _winTimerLastTime;
	WindowTriggers _windowTriggers;
	
	internal int WinTimerPeriod_ {
		get => _winTimerPeriod;
		set {
			long t = perf.ms;
			int td = (int)(t - _winTimerLastTime);
			if (td > 10) _winTimerLastTime = t;
			_winTimerPeriod = value;
		}
	}
	int _winTimerPeriod;
}

enum TriggerType {
	Hotkey,
	Autotext,
	Mouse,
	Window,
}

interface ITriggers {
	/// <summary>
	/// Return <c>true</c> if added triggers of this type.
	/// </summary>
	bool HasTriggers { get; }
	
	/// <summary>
	/// Optionally start/stop the trigger engine (hooks etc).
	/// </summary>
	/// <param name="start"></param>
	void StartStop(bool start);
}

class TriggerHookContext : WFCache {
	//internal readonly ActionTriggers triggers;
	wnd _w;
	bool _haveWnd, _mouseWnd; POINT _p;
	
	public TriggerHookContext(ActionTriggers triggers) {
		//this.triggers = triggers;
		_perfList = new _ScopeTime[32];
		base.CacheName = true; //we'll call Clear(onlyName: true) at the start of each event
	}
	
	public wnd Window {
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get {
			if (!_haveWnd) {
				_haveWnd = true;
				_w = _mouseWnd ? wnd.fromXY(_p, WXYFlags.NeedWindow) : wnd.active;
			}
			return _w;
		}
	}
	
	/// <summary>
	/// Trigger/action to run. Set by a hook proc of a trigger engine.
	/// </summary>
	public ActionTrigger trigger;
	
	/// <summary>
	/// Used with <see cref="trigger"/>.
	/// </summary>
	public TriggerArgs args;
	
	/// <summary>
	/// Used with <see cref="trigger"/>.
	/// Can be 0 or one of <c>TriggerActionThreads.c_</c> constants.
	/// </summary>
	public int muteMod;
	
	///// <summary>
	///// This event was processed (not ignored). Set by a hook proc of a trigger engine.
	///// </summary>
	//public bool processed;
	
	/// <summary>
	/// Called before processing each hook event. Clears most properties and fields.
	/// </summary>
	public void InitContext() {
		_w = default; _haveWnd = _mouseWnd = false;
		base.Clear(onlyName: true);
		trigger = null; args = null; muteMod = 0;
		_perfLen = 0;
	}
	
	/// <summary>
	/// Tells to get window (for scope) from the specified point. If not called, will use the active window. In any case, gets window on demand.
	/// </summary>
	public void UseWndFromPoint(POINT p) {
		_mouseWnd = true; _p = p;
	}
	
	struct _ScopeTime {
		public int time_, avgTime;
	}
	
	long _perfTime;
	_ScopeTime[] _perfList; //don't use List<> because its JIT is too slow in time-critical code
	int _perfLen;
	
	public void PerfStart() {
		_perfTime = perf.mcs;
	}
	
	public void PerfEnd(bool isFunc, ref int perfTime) {
		long tLong = perf.mcs - _perfTime;
		int t = (int)Math.Min(tLong, 1_000_000_000);
		
		//calc average time of this scope. Assume the first time is 0.
		if (perfTime != 0) perfTime = Math.Max(1, (int)(((long)perfTime * 7 + t) / 8));
		//print.it($"time={time}, avg={perfTime}");
		
		if (isFunc) t |= unchecked((int)0x80000000);
		if (_perfLen == _perfList.Length) Array.Resize(ref _perfList, _perfList.Length * 2);
		_perfList[_perfLen++] = new _ScopeTime { time_ = t, avgTime = perfTime };
		if (perfTime == 0) perfTime = 1;
	}
	
	public void PerfWarn() {
		if (_perfLen == 0) return;
		long ttTrue = 0, ttCompare = 0;
		for (int i = 0; i < _perfLen; i++) {
			var v = _perfList[i];
			int t = v.time_ & 0x7fffffff, ta;
			ttTrue += t;
			if (v.avgTime == 0) ta = Math.Max(t - 150_000, 0); //first time. Can be slow JIT and assembly loading.
			else ta = Math.Min(t, v.avgTime);
			ttCompare += ta;
		}
		ttCompare /= 1000; ttTrue /= 1000;
		//print.it(ttTrue, ttCompare);
		if (ttCompare <= 25 && (ttTrue < 200 || ttTrue < WindowsHook.LowLevelHooksTimeout - 100)) return;
		var b = new StringBuilder();
		b.AppendFormat("<>Warning: Too slow trigger scope detection (Triggers.Of or Triggers.FuncOf). Time: {0} ms. Task name: {1}. <fold>", ttTrue, script.name);
		for (int i = 0; i < _perfLen; i++) {
			var v = _perfList[i];
			int t = v.time_ & 0x7fffffff;
			b.AppendFormat("\t{0} {1,8}.{2:D3} ms", v.time_ < 0 ? "F" : "W", t / 1000, t % 1000);
			if (v.avgTime > 0) b.AppendFormat(", average {0}.{1:D3} ms", v.avgTime / 1000, v.avgTime % 1000);
			b.AppendLine();
		}
		b.Append("* W - Triggers.Of (window); F - Triggers.FuncOf.</fold>");
		ThreadPool.QueueUserWorkItem(print.it, b.ToString()); //4 ms first time. Async because JIT slow.
	}
	
	/// <summary>
	/// Currently pressed modifier keys. Valid only in hotkey and autotext triggers.
	/// </summary>
	public KMod Mod => _mod;
	
	/// <summary>
	/// Currently pressed left-side modifier keys. Valid only in hotkey and autotext triggers.
	/// </summary>
	public KMod ModL => _modL;
	
	/// <summary>
	/// Currently pressed right-side modifier keys. Valid only in hotkey and autotext triggers.
	/// </summary>
	public KMod ModR => _modR;
	
	/// <summary>
	/// Not 0 if this key event is a modifier key. Valid only in hotkey and autotext triggers.
	/// </summary>
	public KMod ModThis => _modThis;
	
	KMod _mod, _modL, _modR, _modThis;
	long _lastKeyTime;
	
	/// <summary>
	/// Called before processing each keyboard hook event.
	/// Updates <see cref="Mod"/>, <see cref="ModL"/>, <see cref="ModR"/>, <see cref="ModThis"/>. They are used by hotkey and autotext triggers.
	/// </summary>
	public void InitMod(HookData.Keyboard k) {
		KMod modL = 0, modR = 0;
		switch (k.vkCode) {
		case KKey.LCtrl: modL = KMod.Ctrl; break;
		case KKey.LShift: modL = KMod.Shift; break;
		case KKey.LAlt: modL = KMod.Alt; break;
		case KKey.Win: modL = KMod.Win; break;
		case KKey.RCtrl: modR = KMod.Ctrl; break;
		case KKey.RShift: modR = KMod.Shift; break;
		case KKey.RAlt: modR = KMod.Alt; break;
		case KKey.RWin: modR = KMod.Win; break;
		}
		
		if ((_modThis = (modL | modR)) != 0) {
			if (k.IsUp) {
				_modL &= ~modL; _modR &= ~modR;
			} else {
				_modL |= modL; _modR |= modR;
			}
			_mod = _modL | _modR;
		} else if (!k.IsUp) {
			//We cannot trust _mod, because hooks are unreliable. We may not receive some events because of hook timeout, other hooks, OS quirks, etc. Also triggers may start while a modifier key is pressed.
			//And we cannot use keys.isPressed, because our triggers release modifiers. Also Key() etc. Then triggers could not be auto-repeated.
			//We use both. If IsPressed(mod), add mod to _mod. Else remove from _mod after >5 s since the last seen key event. The max auto-repeat delay that you can set in CP is ~1 s.
			TrigUtil.GetModLR(out modL, out modR);
			//Debug_.PrintIf(modL != _modL || modR != _modR, $"KEY={k.vkCode}    modL={modL}  _modL={_modL}    modR={modR}  _modR={_modR}"); //normally should be only when auto-repeating a trigger
			_modL |= modL; _modR |= modR;
			long time = Environment.TickCount64;
			if (time - _lastKeyTime > 5000) {
				_modL &= modL; _modR &= modR;
			}
			_mod = _modL | _modR;
			//print.it(_mod, k.vkCode);
			_lastKeyTime = time;
		}
	}
}


================================================
FILE: Au/Triggers/TriggersListWindow.cs
================================================
using Au.Triggers;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Controls.Primitives;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Markup;
using System.Windows.Threading;
using System.Collections.ObjectModel;
using System.Windows.Data;

namespace Au.Triggers;

public partial class ActionTriggers {
	/// <summary>
	/// Shows a temporary window with a list of currently active triggers for the active window (hotkey, autotext and mouse edge/move triggers) or the mouse window (mouse click/wheel triggers).
	/// </summary>
	/// <param name="triggerType">Which trigger type to select initially: 0 hotkey, 1 autotext, 2 mouse, 3 window, -1 previous.</param>
	/// <remarks>
	/// To determine which triggers are active in the target window, the function uses window scopes specified in code (like <c>Triggers.Of.Window("Window name")</c>). However it ignores code like <c>Triggers.FuncOf...</c>, therefore the list includes triggers deactivated by your <c>FuncOf</c> functions.
	/// </remarks>
	/// <example>
	/// Code in file <c>Hotkey triggers.cs</c>. Calls this function when pressed hotkey <c>Alt+?</c>.
	/// <code><![CDATA[
	/// hk["Alt+?"] = o => Triggers.ShowTriggersListWindow();
	/// ]]></code>
	/// </example>
	public void ShowTriggersListWindow(int triggerType = -1) {
		run.thread(() => TriggersListWindow.Show_(this, triggerType));
		
		//triggers.SendMsg_(false, () => TriggersListWindow.Show_(this, triggerType)); //no. The triggers thread uses a special message loop etc. Possible various anomalies.
	}
	
	internal bool triggersListWindowIsActive_;
}

class TriggersListWindow : Window {
	static TriggersListWindow s_w;
	
	internal static void Show_(ActionTriggers triggers, int triggerType) {
		//single instance
		if (s_w != null) {
			s_w.Dispatcher.InvokeAsync(() => {
				s_w.Hwnd().ActivateL(true);
				if (triggerType is >= 0 and <= 3) {
					s_w._arb[triggerType].IsChecked = true;
				}
			});
			return;
		}
		
		s_w = new(triggers, triggerType);
		s_w.ShowDialog();
		s_w.Dispatcher.InvokeShutdown();
		s_w = null;
	}
	
	ActionTriggers _triggers;
	wnd _wActive, _wMouse;
	POINT _pMouse;
	RadioButton[] _arb;
	ListView _lv;
	ListCollectionView _view;
	
	TriggersListWindow(ActionTriggers triggers, int triggerType) {
		_triggers = triggers;
		if (triggerType is < 0 or > 3) triggerType = Math.Clamp(s_sett.triggerType, 0, 3);
		
		_pMouse = mouse.xy;
		_wMouse = wnd.fromXY(_pMouse, WXYFlags.NeedWindow);
		_wActive = wnd.active;
		
		var a = _GetTriggers();
		
		Title = "Triggers";
		var b = new wpfBuilder(this).WinSize(500, 700);
		b.R.AddToolBar_(out _, out var tb, hideOverflow: true, controlBrush: true).Margin("0");
		b.Add(out TextBox tFilter).Margin("L0").Focus();
		tFilter.PreviewMouseUp += (_, e) => { if (e.ChangedButton == MouseButton.Middle) tFilter.Clear(); };
		
		b.Row(-1).Add(out _lv);
		_lv.SelectionMode = SelectionMode.Single;
		VirtualizingStackPanel.SetVirtualizationMode(_lv, VirtualizationMode.Recycling);
		ScrollViewer.SetHorizontalScrollBarVisibility(_lv, ScrollBarVisibility.Disabled);
		_SetItemTemplate();
		_lv.ItemsSource = a;
		
		_lv.MouseUp += (_, e) => {
			if (e.ChangedButton is MouseButton.Left or MouseButton.Right) {
				if (s_sett.runOn2Click && e.ChangedButton is MouseButton.Left) return;
				if (_lv.ContainerFromElement(e.OriginalSource as DependencyObject) is ListViewItem { Content: _TLItem t } lvi) _Menu(t, lvi, 1);
			}
		};
		_lv.MouseDoubleClick += (_, e) => {
			if (s_sett.runOn2Click && e.ChangedButton is MouseButton.Left) {
				if (_lv.ContainerFromElement(e.OriginalSource as DependencyObject) is ListViewItem { Content: _TLItem t } lvi) _Menu(t, lvi, 2);
			}
		};
		
		_lv.GotKeyboardFocus += (_, _) => {
			Dispatcher.InvokeAsync(() => {
				if (_lv.Items.Count > 0) {
					int i = _lv.SelectedIndex;
					if (i < 0) _lv.SelectedIndex = i = 0;
					_lv.ScrollIntoView(_lv.Items.GetItemAt(i));
					if (_lv.ItemContainerGenerator.ContainerFromIndex(i) is ListViewItem lvi) lvi.Focus();
				}
			});
		};
		
		b.End();
		
		string filter = null;
		_view = (ListCollectionView)CollectionViewSource.GetDefaultView(a);
		_view.Filter = o => {
			if (o is _TLItem t) {
				if (_TriggerTypeToInt(t) != triggerType) return false;
				if (!filter.NE()) {
					if (!(t.trigger.Contains(filter, StringComparison.OrdinalIgnoreCase) || (t.action?.Contains(filter, StringComparison.OrdinalIgnoreCase) ?? false))) return false;
				}
			}
			return true;
		};
		if (s_sett.sort) _view.CustomSort = new _SortComparer();
		
		string[] aTriggersTypeStrings = { "_Hotkey", "_Autotext", "_Mouse", "_Window" };
		_arb = new RadioButton[aTriggersTypeStrings.Length];
		for (int i = 0; i < _arb.Length; i++) {
			tb.Items.Add(_arb[i] = new RadioButton { Content = new AccessText { Text = aTriggersTypeStrings[i] }, Width = 60, Margin = new(0, 0, 3, 0), BorderBrush = SystemColors.ActiveBorderBrush });
			int tt = i;
			_arb[i].Checked += (_, e) => { s_sett.triggerType = triggerType = tt; _view.Refresh(); };
			_arb[i].Focusable = false; //to avoid focusing on access key
		}
		_arb[triggerType].IsChecked = true;
		tFilter.TextChanged += (_, _) => { filter = tFilter.Text; _view.Refresh(); };
		
		SourceInitialized += (_, _) => {
			var w = this.Hwnd();
			w.MoveToScreenCenter(); //workaround for WPF bug: incorrectly centers in a non-primary screen with different DPI
		};
		Loaded += (_, _) => {
			var w = this.Hwnd();
			w.ActivateL();
		};
		Activated += (_, _) => {
			_triggers.triggersListWindowIsActive_ = true;
		};
		Deactivated += (_, _) => {
			_triggers.triggersListWindowIsActive_ = false;
			if (s_sett.autoClose && IsVisible) timer.after(100, _ => {
				if (!wnd.active.IsOfThisThread) Close();
			});
		};
	}
	
	protected override void OnPreviewKeyDown(KeyEventArgs e) {
		switch (e.Key) {
		case Key.Escape: Close(); e.Handled = true; return;
		case Key.Down when Keyboard.FocusedElement is TextBox: _lv.Focus(); e.Handled = true; return;
		case Key.Enter:
			if (e.OriginalSource is ListViewItem { Content: _TLItem t } lvi) {
				_Menu(t, lvi, 0);
			} else {
				_lv.Focus();
				timer.after(1, _ => {
					if (_lv.SelectedItem is _TLItem t && _lv.ItemContainerGenerator.ContainerFromItem(t) is ListViewItem lvi) _Menu(t, lvi, 0);
				});
			}
			e.Handled = true;
			return;
		}
		base.OnPreviewKeyDown(e);
	}
	
	void _Menu(_TLItem t, ListViewItem li, int clickCount) {
		if ((s_sett.runOnEnter && clickCount == 0) || (s_sett.runOn2Click && clickCount == 2)) {
			_RunAction(t);
			return;
		}
		
		var m = new popupMenu { CheckDontClose = true };
		
		m["&Run"] = o => _RunAction(t);
		if (clickCount == 0) m.FocusedItem = m.Last;
		
		m["&Edit"] = o => {
			if (s_sett.autoClose) Close();
			ScriptEditor.Open(t.t.SourceFile, t.t.SourceLine);
		};
		m.Separator();
		m.Submenu("&Settings", m => {
			m.AddCheck("Auto-close this window", s_sett.autoClose, o => { s_sett.autoClose = o.IsChecked; });
			m.Separator();
			m.AddCheck("Run on 2*click", s_sett.runOn2Click, o => { s_sett.runOn2Click = o.IsChecked; });
			m.AddCheck("Run on single Enter", s_sett.runOnEnter, o => { s_sett.runOnEnter = o.IsChecked; });
			m.Separator();
			m.AddCheck("Compact list", s_sett.compact, o => { s_sett.compact = o.IsChecked; _SetItemTemplate(); });
			m.AddCheck("Sort", s_sett.sort, o => { s_sett.sort = o.IsChecked; _view.CustomSort = s_sett.sort ? new _SortComparer() : null; });
			m.AddCheck("Sort hotkeys by modifier", s_sett.sortByMod, o => { s_sett.sortByMod = o.IsChecked; if (s_sett.sort) _view.CustomSort = new _SortComparer(); });
		});
		m["About"] = o => _About();
		
		var r = li.RectInScreen();
		POINT p = clickCount==0 ? new(r.left, r.bottom) : mouse.xy;
		m.Show(PMFlags.Underline | PMFlags.AlignRectBottomTop | (clickCount==0 ? 0 : PMFlags.AlignCenterH), xy: p, excludeRect: r, owner: this);
	}
	
	void _RunAction(_TLItem t) {
		if (s_sett.autoClose) Close();
		wnd ww = default;
		if (t.t is WindowTrigger tw) {
			ww = tw.Finder.Find();
			if (ww.Is0) { dialog.showInfo("Cannot run trigger action", $"Window not found.\n\n{tw.Finder}", flags: DFlags.CenterMouse); return; }
			if (tw.Event is TWEvent.Active or TWEvent.ActiveNew or TWEvent.ActiveOnce || !ww.HasExStyle(WSE.NOACTIVATE)) ww.ActivateL(true);
		} else if (t.t is MouseTrigger { Kind: TMKind.Click or TMKind.Wheel } mt) {
			if (_wMouse == _wActive || wnd.fromXY(_pMouse, WXYFlags.NeedWindow) != _wMouse) _wMouse.ActivateL(true);
		} else {
			_wActive.ActivateL(true);
		}
		if (!s_sett.autoClose && this.Hwnd().IsActive) this.Hwnd().ShowMinimized(1);
		
		timer2.after(200, _ => _RunNow(t.t, ww));
		
		void _RunNow(ActionTrigger t, wnd ww) {
			wnd w, w2; string s2 = null;
			if (t is WindowTrigger tw) {
				w = w2 = ww;
				if (!w.IsVisible) return;
				if (tw.Event is TWEvent.Active or TWEvent.ActiveNew or TWEvent.ActiveOnce && !w.IsActive) (w2, s2) = (default, "active");
			} else {
				if (t is MouseTrigger { Kind: TMKind.Click or TMKind.Wheel } mt) {
					try { mouse.move(_pMouse); 100.ms(); } catch { return; }
					(w, w2, s2) = (_wMouse, wnd.fromXY(_pMouse, WXYFlags.NeedWindow), "mouse");
				} else {
					(w, w2, s2) = (_wActive, wnd.active, "active");
				}
			}
			if (w2 != w) { dialog.showInfo("Cannot run trigger action", $"The {s2} window must be:\n\n{w}", flags: DFlags.CenterMouse); return; }
			TriggerArgs ta = t switch {
				HotkeyTrigger k => new HotkeyTriggerArgs(k, w, 0, 0),
				AutotextTrigger k => new AutotextTriggerArgs(k, w, "", false),
				MouseTrigger k => new MouseTriggerArgs(k, w, 0),
				WindowTrigger k => new WindowTriggerArgs(k, w, 0),
				_ => null
			};
			t.RunAction(ta);
		}
	}
	
	void _SetItemTemplate() {
		_lv.ItemTemplate = (DataTemplate)XamlReader.Parse($$$"""
<DataTemplate xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
	<TextBlock TextWrapping="Wrap" Padding="0,1,0,2">
		<TextBlock.Resources>
			<Style TargetType="Run">
				<Style.Triggers>
					<DataTrigger Binding="{Binding t.Disabled}" Value="True">
						<Setter Property="Foreground" Value="Gray"/>
					</DataTrigger>
					<DataTrigger Binding="{Binding t.Disabled}" Value="False">
						<Setter Property="Foreground" Value="{{{(WpfUtil_.IsHighContrastDark ? "#FFFF2D" : "#0060F0")}}}"/>
					</DataTrigger>
				</Style.Triggers>
			</Style>
		</TextBlock.Resources>
		<Bold><Run Text="{Binding trigger, Mode=OneWay}"/></Bold><Run Text="{Binding options, Mode=OneWay}" Foreground="YellowGreen"/><Run Text="{{{(s_sett.compact ? "" : "&#x0a;")}}}        " Foreground="Black"/><Run Text="{Binding action, Mode=OneWay}" Foreground="{DynamicResource {x:Static SystemColors.WindowTextBrushKey}}"/>
	</TextBlock>
</DataTemplate>
""");
	}
	
	void _About() {
		var s = $"""
The list contains triggers that work in the active window (hotkey, autotext and mouse edge/move triggers) or the mouse window (mouse click/wheel triggers).

Active: {_WndToStr(_wActive)}
Mouse: {_WndToStr(_wMouse)}

Code like `Triggers.Of...` is applied. Code like `Triggers.FuncOf...` is ignored.
""";
		
		dialog.showInfo("About Triggers", s, owner: this);
		
		static string _WndToStr(wnd w) {
			var name = w.Name;
			return name.NE() ? $"cn={w.ClassName}, program={w.ProgramName}" : $"name={name}, program={w.ProgramName}";
		}
	}
	
	ObservableCollection<_TLItem> _GetTriggers() {
		List<_TLItem> a = new();
		List<(string path, string text, int[] lines)> aFiles = new();
		Dictionary<TriggerScope, bool> dScopes = new();
		WFCache wfCache = new() { CacheName = true, NoTimeout = true, IgnoreVisibility = true };
		
		foreach (var t in _triggers.Hotkey) {
			if (!_InScope(t, _wActive)) continue;
			string sTrigger = t.ParamsString, sOptions = null;
			if (t.Flags != 0) {
				sTrigger = sTrigger[..sTrigger.Find(" (")];
				var f1 = t.Flags & (TKFlags.LeftMod | TKFlags.RightMod | TKFlags.Numpad | TKFlags.NumpadNot); //display only flags that are important here
				if (f1 != 0) sOptions = $"    {f1}";
			}
			_Add(t, sTrigger, sOptions);
		}
		
		string postfixKey = _triggers.Autotext.PostfixKey.ToString();
		(string s, TAPostfix pt, string pc) atPrev = default; //optimization: don't build identical options
		foreach (var t in _triggers.Autotext) {
			if (!_InScope(t, _wActive)) continue;
			string sOptions = null;
			if (t.PostfixType == atPrev.pt && t.PostfixChars == atPrev.pc) {
				sOptions = atPrev.s;
			} else {
				if (t.PostfixType != TAPostfix.None) {
					using (new StringBuilder_(out var b)) {
						b.Append("    + ");
						switch (t.PostfixType) {
						case TAPostfix.Key: b.Append(postfixKey); break;
						case TAPostfix.Char: b.Append(t.PostfixChars ?? "char"); break;
						default: b.Append(postfixKey).Append(" or ").Append(t.PostfixChars ?? "char"); break;
						}
						sOptions = b.ToString();
					}
				}
				atPrev = (sOptions, t.PostfixType, t.PostfixChars);
			}
			_Add(t, t.Text, sOptions);
		}
		
		foreach (var t in _triggers.Mouse) {
			if (!_InScope(t, t.Kind is TMKind.Click or TMKind.Wheel ? _wMouse : _wActive)) continue;
			string s = t.ParamsString, sOptions = null;
			if (t.Flags != 0) {
				s = s.RxReplace(@" \(.+?\)", "", 1);
				var f1 = t.Flags & (TMFlags.LeftMod | TMFlags.RightMod); //display only flags that are important here
				if (f1 != 0) sOptions = $"    {f1}";
			}
			_Add(t, s, sOptions);
		}
		
		foreach (var t in _triggers.Window) {
			var s2 = "    " + t.Event.ToString();
			if (t.Later != 0) s2 = s2 + ", later " + t.Later;
			_Add(t, t.ParamsString, s2);
		}
		
		return new(a.OrderBy(o => _TriggerTypeToInt(o)).ThenBy(o => o.fileIndex).ThenBy(o => o.t.SourceLine));
		
		bool _InScope(ActionTrigger t, wnd w) {
			if (t.Scope is { } scope) {
				if (!dScopes.TryGetValue(t.Scope, out bool match)) {
					dScopes[scope] = match = scope.Match(w, wfCache);
				}
				if (!match) return false;
			}
			return true;
		}
		
		void _Add(ActionTrigger t, string sTrigger, string sOptions) {
			var sa = _GetAction(t, out int fileIndex);
			//print.it($"<><open {t.SourceFile}|{t.SourceLine}>{sTrigger}<>  <\a>{sa}</\a>");
			if (t.Disabled) sOptions += "    DISABLED";
			a.Add(new(t, sTrigger, sOptions, sa, fileIndex));
		}
		
		string _GetAction(ActionTrigger t, out int fileIndex) {
			string text, file = t.SourceFile; int[] lines;
			for (fileIndex = aFiles.Count; --fileIndex >= 0;) if (aFiles[fileIndex].path == file) break;
			if (fileIndex < 0) {
				fileIndex = aFiles.Count;
				try { text = filesystem.loadText(file); } catch (Exception) { text = ""; }
				
				//find line offsets once, not for each trigger (slow)
				text = text.ReplaceLineEndings("\n");
				lines = new int[text.AsSpan().Count('\n') + 1];
				for (int j = 1; j < lines.Length; j++) lines[j] = text.IndexOf('\n', lines[j - 1]) + 1;
				
				aFiles.Add((file, text, lines));
			} else {
				text = aFiles[fileIndex].text;
				lines = aFiles[fileIndex].lines;
			}
			
			int sourceLine = t.SourceLine - 1;
			if ((uint)sourceLine < lines.Length) {
				int start = lines[sourceLine], end = sourceLine + 1 < lines.Length ? lines[sourceLine + 1] - 1 : text.Length;
				if (!text.RxMatch(@"\]\s*=\s*(?|\w+\s*=>\s*(.+)|(.+))", 1, out string s, range: start..end)) return null;
				if (s.Ends("\"\"\"")) {
					if (text.RxMatch(@"(?s)\s+(.+?)\R\h*""""""", 1, out string s2, range: end..)) s += s2.RxReplace(@"\R\h*", "    ");
				} else if (t is AutotextTrigger && s.Ends(".Menu(")) {
					if (text.RxMatch(@"(?s)\s+(.+?)\R\h*\);", 1, out string s2, range: end..)) s += s2.RxReplace(@"\R\h*", "    ");
				}
				return s.Limit(200);
			}
			return null;
		}
	}
	
	static int _TriggerTypeToInt(_TLItem t) => t.t switch { HotkeyTrigger => 0, AutotextTrigger => 1, MouseTrigger => 2, _ => 3 };
	
	record _TLItem(ActionTrigger t, string trigger, string options, string action, int fileIndex) {
		public ReadOnlySpan<char> GetSortInfo(out int keyWeight, out int modWeight) {
			if (t is HotkeyTrigger k) {
				int mod = (int)k.modMask ^ 15 | (int)k.modMasked;
				modWeight = (((mod & 2) << 3 | (mod & 4) << 3 | (mod & 1) << 6 | (mod & 8) << 4)) >> 4 | System.Numerics.BitOperations.PopCount((uint)mod) << 4;
				
				int i = trigger.LastIndexOf('+') + 1;
				var s = trigger.AsSpan(i).Trim();
				keyWeight = s.Length > 1 ? 2 : s[0].IsAsciiAlphaDigit() ? 1 : 0;
				
				return s;
			}
			keyWeight = modWeight = 0;
			return trigger;
		}
	}
	
	class _SortComparer : System.Collections.IComparer {
		int System.Collections.IComparer.Compare(object o1, object o2) {
			if (o1 is _TLItem i1 && o2 is _TLItem i2) {
				var s1 = i1.GetSortInfo(out int keyWeight1, out int modWeight1);
				var s2 = i2.GetSortInfo(out int keyWeight2, out int modWeight2);
				if (i1.t is not HotkeyTrigger) return s1.CompareTo(s2, StringComparison.CurrentCultureIgnoreCase);
				if (s_sett.sortByMod) {
					int r = modWeight1 - modWeight2;
					if (r == 0) r = keyWeight1 - keyWeight2;
					if (r == 0) r = s1.CompareTo(s2, StringComparison.CurrentCultureIgnoreCase);
					return r;
				} else {
					int r = keyWeight1 - keyWeight2;
					if (r == 0) r = s1.CompareTo(s2, StringComparison.CurrentCultureIgnoreCase);
					if (r == 0) r = modWeight1 - modWeight2;
					return r;
				}
			}
			return 0;
		}
	}
	
	internal record class _Settings : JSettings {
		public static readonly string File = folders.ThisAppDataRoaming + @"TriggersListWindow settings.json";
		
		public static _Settings Load() => Load<_Settings>(File);
		
		public bool autoClose = true;
		public bool compact;
		public bool sort, sortByMod;
		public bool runOnEnter, runOn2Click;
		public int triggerType;
	}
	
	static readonly _Settings s_sett = _Settings.Load();
}


================================================
FILE: Au/Triggers/Triggers_actions.cs
================================================
namespace Au.Triggers;

class TOptions {
	public Action<TOBAArgs> before;
	public Action<TOBAArgs> after;
	public sbyte thread; //>=0 dedicated or <0 TOThread
	public TOFlags flags;
	public int wait;
	public PostToThisThread_ thisThread;
	
	public TOptions Clone() => this.MemberwiseClone() as TOptions;
}

class TOThread { public const sbyte OfTriggers = -1, New = -2, Pool = -3, This = -4; }

[Flags]
enum TOFlags : byte {
	NoWarning = 1,
	Single = 2,
	//MtaThread = 4,
	//BackgroundThread=8, //rejected. Always background. Foreground makes no sense here. If need, can easily set in code.
}

/// <summary>
/// Allows to set some options for multiple triggers and their actions.
/// </summary>
/// <remarks>
/// You set options through a thread-static property <see cref="ActionTriggers.Options"/>.
/// Changed options are applied to all triggers/actions added afterwards in this thread.
/// </remarks>
/// <example>
/// <code><![CDATA[
/// Triggers.Options.ThreadNew();
/// Triggers.Options.BeforeAction = o => { opt.key.KeySpeed = 10; };
/// Triggers.Hotkey["Ctrl+K"] = o => print.it(opt.key.KeySpeed); //10
/// Triggers.Hotkey["Ctrl+Shift+K"] = o => print.it(opt.key.KeySpeed); //10
/// Triggers.Options.BeforeAction = o => { opt.key.KeySpeed = 20; };
/// Triggers.Hotkey["Ctrl+L"] = o => print.it(opt.key.KeySpeed); //20
/// Triggers.Hotkey["Ctrl+Shift+L"] = o => print.it(opt.key.KeySpeed); //20
/// ]]></code>
/// </example>
public class TriggerOptions {
	TOptions _new, _prev;
	
	TOptions _New() => _new ??= (_prev?.Clone() ?? new TOptions());
	
	/// <summary>
	/// Run actions always in the same dedicated thread that does not end when actions end.
	/// </summary>
	/// <param name="thread">A number that you want to use to identify the thread. Can be 0-127. Default 0.</param>
	/// <param name="wait">Defines when to start an action if an action (other or same) is currently running in this thread. If 0 (default), don't run. If -1 (<c>Timeout.Infinite</c>), run when that action ends (and possibly other queued actions). If > 0, run when that action ends, if it ends within this time from now; the time is in milliseconds.</param>
	/// <param name="noWarning">No warning when cannot start an action because an action is running and <i>wait</i> == 0.</param>
	/// <exception cref="ArgumentOutOfRangeException"></exception>
	/// <remarks>
	/// Multiple actions in same thread cannot run simultaneously. Actions in different threads can run simultaneously.
	/// There is no "end old running action" feature. If need it, use other script. Example: <c>Triggers.Hotkey["Ctrl+M"] = o => script.runWait("Other Script");</c>.
	/// There is no "temporarily pause old running action to run new action" feature. As well as for scripts.
	/// The thread has <see cref="ApartmentState.STA"/>.
	/// There are several <c>ThreadX</c> functions. Only the last called function is active. If none called, it is the same as called this function without arguments.
	/// </remarks>
	public void Thread(int thread = 0, int wait = 0, bool noWarning = false) {
		_New();
		if ((uint)thread > 127) throw new ArgumentOutOfRangeException();
		_new.thread = (sbyte)thread;
		_new.wait = wait >= -1 ? wait : throw new ArgumentOutOfRangeException();
		_new.flags = noWarning ? TOFlags.NoWarning : 0;
	}
	//CONSIDER: make default ifRunningWaitMS = 1000 if it is another action.
	
	/// <summary>
	/// Run trigger actions in the same thread as <see cref="ActionTriggers.Run"/>. Dangerous, rarely used.
	/// </summary>
	/// <remarks>
	/// This should not be used without a good reason. Trigger actions must be programmed carefully, to not interfere with triggers. They must be as fast as possible, else will block triggers, hooks and user input.
	///
	/// Before v0.16 this was named <see cref="ThreadMain"/> and used in the <c>"Triggers and toolbars"</c> script. Problem: blocks hooks etc when need long time to get file icons. Now the script uses <see cref="ThreadThis"/> instead, and calls <c>Triggers.Run</c> in another thread. Your script possibly still uses the old code. You can replace it with the new version, which can be found in menu <b>File > New > Default > Triggers and toolbars</b>.
	/// </remarks>
	public void ThreadOfTriggers() {
		_New();
		_new.thread = TOThread.OfTriggers;
		_new.wait = 0;
		_new.flags = 0;
	}
	
	/// <summary>
	/// Alias of <see cref="ThreadOfTriggers"/>.
	/// </summary>
	[EditorBrowsable(EditorBrowsableState.Never)] //renamed
	public void ThreadMain() => ThreadOfTriggers();
	
	/// <summary>
	/// Run trigger actions in this thread (which called this function).
	/// </summary>
	/// <remarks>
	/// This function can be used only if <see cref="ActionTriggers.Run"/> runs in another thread. This thread must have a message loop (wait and dispatch messages). For it can be used <see cref="ActionTriggers.RunThread"/>.
	///
	/// Trigger actions should be fast, else other trigger actions may be delayed. If a trigger action dispatches messages, other trigger actions can run in the meantime.
	/// 
	/// Can be used to create and show toolbars (<see cref="toolbar"/>). Used in the default <c>"Triggers and toolbars"</c> script since v0.16.
	/// </remarks>
	/// <example>
	/// <code><![CDATA[
	/// print.it(Environment.CurrentManagedThreadId);
	/// ActionTriggers Triggers = new();
	/// Triggers.Options.ThreadThis();
	/// Triggers.Hotkey["F11"] = o => { print.it(Environment.CurrentManagedThreadId); };
	/// Triggers.RunThread();
	/// ]]></code>
	/// </example>
	public void ThreadThis() {
		_New();
		_new.thread = TOThread.This;
		_new.wait = 0;
		_new.flags = 0;
		_new.thisThread = PostToThisThread_.OfThisThread;
	}
	
	/// <summary>
	/// Run trigger actions in new threads.
	/// </summary>
	/// <param name="single">Don't run if this action is already running. If <c>false</c>, multiple action instances can run parallelly in multiple threads.</param>
	/// <remarks>
	/// The action can run simultaneously with other actions. The thread is STA.
	/// </remarks>
	public void ThreadNew(bool single = false) {
		_New();
		_new.thread = TOThread.New;
		_new.wait = 0;
		TOFlags f = 0;
		if (single) f |= TOFlags.Single;
		_new.flags = f;
	}
	
	/// <summary>
	/// Run trigger actions in thread pool threads.
	/// </summary>
	/// <param name="single">Don't run if this action is already running. If <c>false</c>, multiple action instances can run parallelly in multiple threads.</param>
	/// <remarks>
	/// The action can run simultaneously with other actions. May start later if the pool is busy.
	/// You should know how to use thread pool correctly. The action runs in the .NET thread pool through <see cref="Task.Run"/>.
	/// </remarks>
	public void ThreadPool(bool single = false) {
		_New();
		_new.thread = TOThread.Pool;
		_new.wait = 0;
		_new.flags = single ? TOFlags.Single : 0;
	}
	
	/// <summary>
	/// A function to run before the trigger action.
	/// For example, it can set <see cref="opt"/> options.
	/// </summary>
	/// <example>
	/// <code><![CDATA[
	/// Triggers.Options.BeforeAction = o => { opt.key.KeySpeed = 20; opt.key.TextSpeed = 5; };
	/// ]]></code>
	/// </example>
	public Action<TOBAArgs> BeforeAction { set => _New().before = value; }
	
	/// <summary>
	/// A function to run after the trigger action.
	/// For example, it can log exceptions.
	/// </summary>
	/// <example>
	/// <code><![CDATA[
	/// Triggers.Options.AfterAction = o => { if(o.Exception!=null) print.it(o.Exception.Message); else print.it("completed successfully"); };
	/// ]]></code>
	/// </example>
	public Action<TOBAArgs> AfterAction { set => _New().after = value; }
	
	internal TOptions Current {
		get {
			if (_new != null) { _prev = _new; _new = null; }
			return _prev ?? (s_empty ??= new TOptions());
		}
	}
	static TOptions s_empty;
	
	/// <summary>
	/// If <c>true</c>, triggers added afterwards don't depend on <see cref="ActionTriggers.Disabled"/> and <see cref="ActionTriggers.DisabledEverywhere"/>.
	/// This property sets the <see cref="ActionTrigger.EnabledAlways"/> property of triggers added afterwards.
	/// </summary>
	public bool EnabledAlways { get; set; }
	
	/// <summary>
	/// Clears all options.
	/// </summary>
	public void Reset() {
		_new = null;
		_prev = null;
	}
}

/// <summary>
/// Arguments for <see cref="TriggerOptions.BeforeAction"/> and <see cref="TriggerOptions.AfterAction"/>.
/// </summary>
public struct TOBAArgs {
	internal TOBAArgs(TriggerArgs args) {
		ActionArgs = args;
		Exception = null;
	}
	
	/// <summary>
	/// Trigger event info. The same variable as passed to the trigger action.
	/// To access the info, cast to <see cref="HotkeyTriggerArgs"/> etc, depending on trigger type.
	/// </summary>
	public TriggerArgs ActionArgs { get; }
	
	/// <summary>
	/// If action ended with an exception, the exception. Else <c>null</c>.
	/// </summary>
	public Exception Exception { get; internal set; }
}

class TriggerActionThreads {
	public void Run(ActionTrigger trigger, TriggerArgs args, int muteMod) {
		//perf.first();
		Action actionWrapper = () => {
			var o = trigger.options;
			var oldOpt = o.thread is TOThread.New or TOThread.Pool ? default : opt.scope.all(inherit: true);
			try {
				_MuteMod(ref muteMod);
				
				string sTrigger = null; long startTime = 0;
				//perf.next();
				if (script.role == SRole.MiniProgram) {
					sTrigger = trigger.ToString();
					Api.QueryPerformanceCounter(out startTime);
					print.TaskEvent_("AS " + sTrigger, startTime, trigger.SourceFile, trigger.SourceLine);
					//perf.next();
				}
				
				var baArgs = new TOBAArgs(args); //struct
				o.before?.Invoke(baArgs);
				try {
					//perf.nw();
					trigger.Run_(args);
					
					if (sTrigger != null) print.TaskEvent_("AE", startTime, trigger.SourceFile, trigger.SourceLine);
				}
				catch (Exception e1) {
					if (sTrigger != null) print.TaskEvent_("AF", startTime, trigger.SourceFile, trigger.SourceLine);
					
					baArgs.Exception = e1;
					print.it(e1);
				}
				o.after?.Invoke(baArgs);
			}
			catch (Exception e2) {
				print.it(e2);
			}
			finally {
				oldOpt.Dispose();
				if (o.flags.Has(TOFlags.Single)) _d.TryRemove(trigger, out _);
				if (o.thread is not (TOThread.OfTriggers or TOThread.This)) toolbar.TriggerActionEndedInToolbarUnfriendlyThread_();
			}
		};
		//never mind: we should not create actionWrapper if cannot run. But such cases are rare. Fast and small, about 64 bytes.
		
		var opt1 = trigger.options;
		int threadId = opt1.thread;
		if (threadId >= 0) { //dedicated thread
			_Thread h = null; foreach (var v in _a) if (v.id == threadId) { h = v; break; }
			if (h == null) _a.Add(h = new _Thread(threadId));
			if (h.RunAction(actionWrapper, trigger)) return;
		} else if (threadId == TOThread.OfTriggers) {
			actionWrapper();
			return;
			//note: can reenter. Probably it is better than to cancel if already running.
		} else if (threadId == TOThread.This) {
			if (opt1.thisThread.ManagedThreadId == Environment.CurrentManagedThreadId) print.warning("If called ThreadThis, triggers should run in another thread.");
			opt1.thisThread.Post(actionWrapper);
			return;
			//note: can reenter.
		} else {
			bool canRun = true;
			bool single = opt1.flags.Has(TOFlags.Single);
			if (single) {
				_d ??= new();
				if (_d.TryGetValue(trigger, out var tt)) {
					switch (tt) {
					case Thread thread:
						if (thread.IsAlive) canRun = false;
						break;
					case Task task:
						//print.it(task.Status);
						switch (task.Status) {
						case TaskStatus.RanToCompletion: case TaskStatus.Faulted: case TaskStatus.Canceled: break;
						default: canRun = false; break;
						}
						break;
					}
				}
			}
			
			if (canRun) {
				if (threadId == TOThread.New) {
					var thread = new Thread(actionWrapper.Invoke) { IsBackground = true };
					//if (!opt1.flags.Has(TOFlags.MtaThread))
					thread.SetApartmentState(ApartmentState.STA);
					if (single) _d[trigger] = thread;
					try { thread.Start(); }
					catch (OutOfMemoryException) { //too many threads, probably 32-bit process
						if (single) _d.TryRemove(trigger, out _);
						_OutOfMemory();
						//TODO3: before starting thread, warn if there are too many action threads.
						//	In 32-bit process normally fails at ~3000 threads.
						//	Unlikely to fail in 64-bit process, but at ~15000 threads starts to hang temporarily, which causes hook timeout, slow mouse, other anomalies.
					}
				} else { //thread pool
					var task = new Task(actionWrapper);
					if (single) _d[trigger] = task;
					task.Start();
				}
				return;
			}
		}
		
		if (muteMod != 0) ThreadPool.QueueUserWorkItem(_ => _MuteMod(ref muteMod));
	}
	
	public void Dispose() {
		foreach (var v in _a) v.Dispose();
	}
	
	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	static void _OutOfMemory() {
		print.warning("There is not enough memory available to start the trigger action thread.", -1); //info: -1 because would need much memory for stack trace
	}
	
	List<_Thread> _a = new();
	ConcurrentDictionary<ActionTrigger, object> _d;
	
	class _Thread {
		record struct _Action(Action actionWrapper, long time);
		
		AutoResetEvent _event;
		Queue<_Action> _q;
		bool _running;
		bool _disposed;
		public readonly int id;
		
		public _Thread(int id) { this.id = id; }
		
		/// <summary>
		/// Adds the action to the queue and notifies the thread to execute it.
		/// If the thread is busy, returns <c>false</c>; if <i>ifRunning</i>!=0, the action possibly will run later.
		/// </summary>
		public bool RunAction(Action actionWrapper, ActionTrigger trigger) {
			if (_disposed) return false;
			if (_q == null) {
				_q = new Queue<_Action>();
				_event = new(false);
				try {
					run.thread(() => {
						try {
							while (!_disposed && _event.WaitOne()) {
								while (!_disposed) {
									_Action x;
									lock (_q) {
										g1:
										if (_q.Count == 0) { _running = false; break; }
										x = _q.Dequeue();
										if (x.time != 0 && perf.ms > x.time) goto g1;
										_running = true;
									}
									x.actionWrapper();
								}
							}
						}
						finally {
							_event.Dispose(); _event = null;
							_q = null; _running = false; //restart if aborted
							//print.it("thread ended");
						}
					});
				}
				catch (OutOfMemoryException) { //too many threads, probably 32-bit process
					_event.Dispose(); _event = null;
					_OutOfMemory();
				}
			}
			
			bool R = true;
			lock (_q) {
				int ifRunningWaitMS = trigger.options.wait;
				if (_running) {
					if (ifRunningWaitMS == 0) {
						if (!trigger.options.flags.Has(TOFlags.NoWarning))
							print.it($"<>Warning: can't run the trigger action because an action is running in this thread. <open {trigger.SourceFile}|{trigger.SourceLine}>Trigger<>: {trigger}."
								+ " <fold>\tTo run simultaneously or wait, use one of Triggers.Options.ThreadX functions.\r\n\tTo disable this warning: Triggers.Options.Thread(noWarning: true);.</fold>");
						return false;
					}
					R = false;
				} else {
					_running = true;
					//if(ifRunningWaitMS > 0 && ifRunningWaitMS < 1000000000) ifRunningWaitMS += 1000;
				}
				_q.Enqueue(new _Action(actionWrapper, ifRunningWaitMS <= 0 ? 0 : perf.ms + ifRunningWaitMS));
			}
			_event.Set();
			return R;
		}
		
		public void Dispose() {
			if (_disposed) return; _disposed = true;
			_event.Set();
		}
	}
	//This old version uses WaitForSingleObject which blocks COM etc, which may cause problems.
	//	In the above code, WaitOne dispatches COM etc. But still little tested.
	//class _Thread
	//{
	//	struct _Action { public Action actionWrapper; public long time; }
	
	//	Handle_ _event;
	//	Queue<_Action> _q;
	//	bool _running;
	//	bool _disposed;
	//	public readonly int id;
	
	//	public _Thread(int id) { this.id = id; }
	
	//	/// <summary>
	//	/// Adds the action to the queue and notifies the thread to execute it.
	//	/// If the thread is busy, returns false; if ifRunning!=0, the action possibly will run later.
	//	/// </summary>
	//	public bool RunAction(Action actionWrapper, ActionTrigger trigger)
	//	{
	//		if(_disposed) return false;
	//		if(_q == null) {
	//			_q = new Queue<_Action>();
	//			_event = Api.CreateEvent(false);
	//			try {
	//				run.thread(() => {
	//					try {
	//						while(!_disposed && 0 == Api.WaitForSingleObject(_event, -1)) {
	//							while(!_disposed) {
	//								_Action x;
	//								lock(_q) {
	//									g1:
	//									if(_q.Count == 0) { _running = false; break; }
	//									x = _q.Dequeue();
	//									if(x.time != 0 && perf.ms > x.time) goto g1;
	//									_running = true;
	//								}
	//								x.actionWrapper();
	//							}
	//						}
	//					}
	//					finally {
	//						_event.Dispose();
	//						_q = null; _running = false; //restart if aborted
	//													 //print.it("thread ended");
	//					}
	//				});
	//			}
	//			catch(OutOfMemoryException) { //too many threads, probably 32-bit process
	//				_event.Dispose();
	//				_OutOfMemory();
	//			}
	//		}
	
	//		bool R = true;
	//		lock(_q) {
	//			int ifRunningWaitMS = trigger.options.ifRunningWaitMS;
	//			if(_running) {
	//				if(ifRunningWaitMS == 0) {
	//					if(!trigger.options.flags.Has(TOFlags.NoWarning))
	//						print.it("Warning: can't run the trigger action because an action is running in this thread." +
	//							" To run simultaneously or wait, use one of Triggers.Options.ThreadX functions." +
	//							" To disable this warning: Triggers.Options.Thread(noWarning: true);." +
	//							" Trigger: " + trigger);
	//					return false;
	//				}
	//				R = false;
	//			} else {
	//				_running = true;
	//				//if(ifRunningWaitMS > 0 && ifRunningWaitMS < 1000000000) ifRunningWaitMS += 1000;
	//			}
	//			_q.Enqueue(new _Action { actionWrapper = actionWrapper, time = ifRunningWaitMS <= 0 ? 0 : perf.ms + ifRunningWaitMS });
	//		}
	//		Api.SetEvent(_event);
	//		return R;
	//	}
	
	//	public void Dispose()
	//	{
	//		if(_disposed) return; _disposed = true;
	//		Api.SetEvent(_event);
	//	}
	//}
	
	static void _MuteMod(ref int muteMod) {
		switch (Interlocked.Exchange(ref muteMod, 0)) {
		case c_modRelease:
			keys.Internal_.ReleaseModAndDisableModMenu(dontThrow: true);
			break;
		case c_modCtrl:
			keys.Internal_.SendKey(KKey.Ctrl, dontThrow: true); //disable Alt/Win menu
			break;
		}
	}
	
	public const int c_modRelease = 1, c_modCtrl = 2;
}


================================================
FILE: Au/Triggers/Triggers_hooks.cs
================================================
//Key/mouse/autotext triggers use low-level keyboard and mouse hooks. The hooks are in a separate thread, because:
//	1. Safer when user code is slow or incorrect.
//	2. Works well with COM. In LL hook procedure some COM functions fail, eg find elm with some windows.
//		Error "An outgoing call cannot be made since the application is dispatching an input-synchronous call". Like when using SendMessage for IPC.
//		It is important because scripts often use UI elements in scope context functions etc that run in the main thread.

//Low-level key/mouse hooks also have other problems, but not too big:
//	1. UAC. Hooks of non-admin processes don't work when an admin window is active.
//		Workaround: let users don't use triggers in non-admin processes. Editor normally is admin, and by default creates task processes of same UAC IL.
//	2. Scripts may use raw input or directX, and Windows has this bug: then low-level keyboard hook does not work in that process.
//		Workaround: let users run such scripts in separate processes.
//	3. Each LL hook uses CPU on key/mouse events.
//		Workaround: let users put all triggers in single script. But it's OK to use another script temporarily eg for testing.
//		Actually in real conditions even 10 hooks don't use a significant part of CPU compared to CPU used by the target app and OS.
//Rejected: single hook server in editor process. It would mitigate some of these problems. Tested. Much code and little benefit.

//For window triggers we use winevent hooks. They use less CPU for IPC.
//	Tested: renaming a toolwindow with no title bar every 1-2 ms in loop:
//		CPU usage with no winevent hooks is 4%. With 1 hook - 7%. With 10 hooks in different processes - 7%.

namespace Au.Triggers;

/// <summary>
/// Thread containing low-level keyboard and mouse hooks.
/// </summary>
class HooksThread : IDisposable {
	[Flags]
	public enum UsedEvents {
		Keyboard = 1, //Hotkey and Autotext triggers
		Mouse = 2, //Mouse and Autotext triggers. Just sets the hook and resets autotext; to receive events, also add other MouseX flags.
		MouseClick = 0x10, //Mouse click triggers
		MouseWheel = 0x20, //Mouse wheel triggers
		MouseEdgeMove = 0x40, //Mouse edge and move triggers
	}
	
	int _tid;
	UsedEvents _usedEvents;
	wnd _wMsg;
	MouseTriggers.EdgeMoveDetector_ _emDetector;
	Handle_ _eventStartStop = Api.CreateEvent(false);
	
	public HooksThread(UsedEvents usedEvents, wnd wMsg) {
		_usedEvents = usedEvents;
		_wMsg = wMsg;
		run.thread(_Thread, sta: false); //important: not STA, because we use lock, which dispatches sent messages if STA
		Api.WaitForSingleObject(_eventStartStop, -1);
	}
	
	public void Dispose() {
		Api.PostThreadMessage(_tid, Api.WM_QUIT, 0, 0);
		Api.WaitForSingleObject(_eventStartStop, -1);
		_eventStartStop.Dispose();
		_eventSendData.Dispose();
	}
	
	void _Thread() {
		_tid = Api.GetCurrentThreadId();
		
		WindowsHook hookK = null, hookM = null;
		if (_usedEvents.Has(UsedEvents.Keyboard)) {
			hookK = WindowsHook.Keyboard(_KeyboardHookProc); //note: if lambda, very slow JIT on first hook event
		}
		if (_usedEvents.Has(UsedEvents.Mouse)) {
			hookM = WindowsHook.MouseRaw_(_MouseHookProc);
		}
		if (_usedEvents.Has(UsedEvents.MouseEdgeMove)) {
			_emDetector = new MouseTriggers.EdgeMoveDetector_();
		}
		//tested: don't need JIT-compiling.
		
		nint idTimer = (hookK != null || hookM != null) ? Api.SetTimer(default, 0, 10_000, null) : 0;
		
		Api.SetEvent(_eventStartStop);
		
		while (Api.GetMessage(out var m)) {
			if (m.message == Api.WM_TIMER && m.wParam == idTimer) {
				if (Debugger.IsAttached) continue;
				hookK?.Restore();
				hookM?.Restore();
				continue;
			}
			Api.DispatchMessage(m);
		}
		
		//print.it("hooks thread ended");
		hookK?.Dispose();
		hookM?.Dispose();
		_emDetector = null;
		Api.SetEvent(_eventStartStop);
	}
	
	unsafe void _KeyboardHookProc(HookData.Keyboard k) {
		_keyData = *k.NativeStructPtr_;
		if (_Send(UsedEvents.Keyboard)) k.BlockEvent();
	}
	
	unsafe bool _MouseHookProc(nint wParam, nint lParam) {
		int msg = (int)wParam;
		if (msg == Api.WM_MOUSEMOVE) {
			if (_usedEvents.Has(UsedEvents.MouseEdgeMove)) {
				var mll = (Api.MSLLHOOKSTRUCT*)lParam;
				if (_emDetector.Detect(mll->pt)) {
					_emData = _emDetector.result;
					_Send(UsedEvents.MouseEdgeMove);
				}
			}
		} else {
			bool wheel = msg is Api.WM_MOUSEWHEEL or Api.WM_MOUSEHWHEEL;
			if ((_usedEvents.Has(UsedEvents.MouseWheel) && wheel) || (_usedEvents.Has(UsedEvents.MouseClick) && !wheel)) {
				_mouseMessage = (int)wParam;
				_mouseData = *(Api.MSLLHOOKSTRUCT*)lParam;
				return _Send(wheel ? UsedEvents.MouseWheel : UsedEvents.MouseClick);
			}
		}
		return false;
	}
	
	/// <summary>
	/// Sends key/mouse event data (copied to <c>_keyData</c> etc) to the main thread.
	/// Returns <c>true</c> to eat (block, discard) the event.
	/// On 1100 ms timeout returns <c>false</c>.
	/// </summary>
	bool _Send(UsedEvents eventType) {
		//using var p1 = perf.local();
		bool ok = _wMsg.SendNotify(Api.WM_USER + 1, _messageId, (int)eventType);
		bool timeout = Api.WaitForSingleObject(_eventSendData, 1100) == Api.WAIT_TIMEOUT;
		lock (this) {
			if (timeout) timeout = Api.WaitForSingleObject(_eventSendData, 0) == Api.WAIT_TIMEOUT; //other thread may SetEvent between WaitForSingleObject and lock
			_messageId++;
			return _eat && !timeout;
		}
		//info: HookWin._HookProcLL will print warning if > LowLevelHooksTimeout-50. Max LowLevelHooksTimeout is 1000.
	}
	
	//fields for passing key/mouse event data to the main thread and getting its return value
	Handle_ _eventSendData = Api.CreateEvent(false); //sync
	int _messageId; //sync
	bool _eat; //return value
	Api.KBDLLHOOKSTRUCT _keyData;
	Api.MSLLHOOKSTRUCT _mouseData;
	int _mouseMessage;
	MouseTriggers.EdgeMoveDetector_.Result _emData;
	
	/// <summary>
	/// Called by the main thread to resume the hooks thread (<c>_Send</c>) and pass the return value (eat).
	/// Returns <c>false</c> on timeout.
	/// </summary>
	public bool Return(int messageId, bool eat) {
		lock (this) {
			if (messageId != _messageId) return false;
			_eat = eat;
			Api.SetEvent(_eventSendData);
		}
		return true;
	}
	
	/// <summary>
	/// Called by the main thread to get key event data sent by <c>_Send</c>.
	/// Returns <c>false</c> on timeout.
	/// </summary>
	public bool GetKeyData(int messageId, out Api.KBDLLHOOKSTRUCT data) {
		data = _keyData;
		return messageId == _messageId;
	}
	
	/// <summary>
	/// Called by the main thread to get mouse click/wheel event data sent by <c>_Send</c>.
	/// Returns <c>false</c> on timeout.
	/// </summary>
	public bool GetClickWheelData(int messageId, out Api.MSLLHOOKSTRUCT data, out int message) {
		data = _mouseData;
		message = _mouseMessage;
		return messageId == _messageId;
	}
	
	/// <summary>
	/// Called by the main thread to get mouse edge/move event data sent by <c>_Send</c>.
	/// Returns <c>false</c> on timeout.
	/// </summary>
	public bool GetEdgeMoveData(int messageId, out MouseTriggers.EdgeMoveDetector_.Result data) {
		data = _emData;
		return messageId == _messageId;
	}
}


================================================
FILE: Au/Triggers/Triggers_util.cs
================================================
namespace Au.Triggers;

static class TrigUtil {
	/// <summary>
	/// Gets left and right modifiers. Uses <see cref="keys.isPressed"/>.
	/// Returns <c>modL | modR</c>.
	/// </summary>
	public static KMod GetModLR(out KMod modL, out KMod modR) {
		KMod L = 0, R = 0;
		if (keys.isPressed(KKey.LCtrl)) L |= KMod.Ctrl;
		if (keys.isPressed(KKey.LShift)) L |= KMod.Shift;
		if (keys.isPressed(KKey.LAlt)) L |= KMod.Alt;
		if (keys.isPressed(KKey.Win)) L |= KMod.Win;
		if (keys.isPressed(KKey.RCtrl)) R |= KMod.Ctrl;
		if (keys.isPressed(KKey.RShift)) R |= KMod.Shift;
		if (keys.isPressed(KKey.RAlt)) R |= KMod.Alt;
		if (keys.isPressed(KKey.RWin)) R |= KMod.Win;
		modL = L; modR = R;
		return L | R;
	}
}


================================================
FILE: Au/Triggers/Types/t-autotext.cs
================================================
//CONSIDER: trigger type: When pressed CapsLock, eat trigger text. When triggered, turn off CapsLock.
//	To cancel, user can turn off CapsLock.
//	Display typed text in OSD. Allow Backspace.
//	Eg I can use it for tags instead of Alt+B etc.
//	Allow to use instead of CapsLock: ScrollLock, Insert. Or not, because unavailable in many keyboards.
//	Another way: press CapsLock, type text, press CapsLock again (then triggers).

namespace Au.Triggers;

/// <summary>
/// Flags of autotext triggers.
/// </summary>
/// <remarks>
/// To avoid passing flags to each trigger as the <i>flags</i> parameter, use <see cref="AutotextTriggers.DefaultFlags"/>; its initial value is 0, which means: case-insensitive, erase the typed text with <c>Backspace</c>, modify the replacement text depending on the case of the typed text.
/// </remarks>
[Flags]
public enum TAFlags : byte {
	/// <summary>
	/// Case-sensitive.
	/// </summary>
	MatchCase = 1,
	
	/// <summary>
	/// Let <see cref="AutotextTriggerArgs.Replace"/> don't erase the user-typed text.
	/// Without this flag it erases text with the <c>Backspace</c> key or selects with <c>Shift+Left</c>. If <c>Replace</c> not called, text is not erased/selected regardless of this flag.
	/// </summary>
	DontErase = 2,
	
	/// <summary>
	/// Let <see cref="AutotextTriggerArgs.Replace"/> don't modify the replacement text.
	/// <br/>Without <c>ReplaceRaw</c> or <c>MatchCase</c> it:
	/// <br/>• If the first character of the typed text is uppercase, makes the first character of the replacement text uppercase.
	/// <br/>• If all typed text is uppercase, makes the replacement text uppercase.
	/// </summary>
	ReplaceRaw = 4,
	
	/// <summary>
	/// Let <see cref="AutotextTriggerArgs.Replace"/> remove the postfix delimiter character.
	/// </summary>
	RemovePostfix = 8,
	
	/// <summary>
	/// Let <see cref="AutotextTriggerArgs.Replace"/> call <see cref="AutotextTriggerArgs.Confirm"/> and do nothing if it returns <c>false</c>.
	/// </summary>
	Confirm = 16,
	
	/// <summary>
	/// Let <see cref="AutotextTriggerArgs.Replace"/> select text with <c>Shift+Left</c> instead of erasing with <c>Backspace</c>. Except in console windows.
	/// See also <see cref="AutotextTriggerArgs.ShiftLeft"/>.
	/// </summary>
	ShiftLeft = 32,
}

/// <summary>
/// Postfix type of autotext triggers.
/// The trigger action runs only when the user ends the autotext with a postfix character or key, unless postfix type is <c>None</c>.
/// Default: <c>CharOrKey</c>.
/// </summary>
public enum TAPostfix : byte {
	/// <summary>A postfix character (see <c>Char</c>) or key (see <c>Key</c>).</summary>
	CharOrKey,
	
	/// <summary>A postfix character specified in the <i>postfixChars</i> parameter or <see cref="AutotextTriggers.DefaultPostfixChars"/> property. If not specified - any non-word character.</summary>
	Char,
	
	/// <summary>The <c>Ctrl</c> or <c>Shift</c> key. Default is <c>Ctrl</c>. You can change it with <see cref="AutotextTriggers.PostfixKey"/>.</summary>
	Key,
	
	/// <summary>Don't need a postfix. The action runs immediately when the user types the autotext.</summary>
	None,
}

/// <summary>
/// See <see cref="AutotextTriggers.MenuOptions"/>;
/// </summary>
/// <param name="pmFlags"></param>
public record class TAMenuOptions(PMFlags pmFlags = PMFlags.ByCaret);

/// <summary>
/// Represents an autotext trigger.
/// </summary>
public class AutotextTrigger : ActionTrigger {
	readonly string _paramsString;
	internal readonly TAMenuOptions menuOptions;
	
	///
	public string Text { get; }
	
	///
	public TAFlags Flags { get; }
	
	///
	public TAPostfix PostfixType { get; }
	
	///
	public string PostfixChars { get; }
	
	internal AutotextTrigger(ActionTriggers triggers, Action<AutotextTriggerArgs> action, string text, TAFlags flags, TAPostfix postfixType, string postfixChars, TAMenuOptions menuOptions, (string, int) source)
		: base(triggers, action, true, source) {
		Text = text;
		Flags = flags;
		PostfixType = postfixType;
		PostfixChars = postfixChars;
		this.menuOptions = menuOptions;
		
		if (flags == 0 && postfixType == 0 && postfixChars == null) {
			_paramsString = text;
		} else {
			using (new StringBuilder_(out var b)) {
				b.Append(text);
				if (flags != 0) b.Append("  (").Append(flags.ToString()).Append(')');
				if (postfixType != 0) b.Append("  postfixType=").Append(postfixType.ToString());
				if (postfixChars != null) b.Append("  postfixChars=").Append(postfixChars);
				_paramsString = b.ToString();
			}
		}
		//print.it(this);
	}
	
	internal override void Run_(TriggerArgs args) => RunT_(args as AutotextTriggerArgs);
	
	/// <summary>
	/// Returns <c>"Autotext"</c>.
	/// </summary>
	public override string TypeString => "Autotext";
	
	/// <summary>
	/// Returns a string containing trigger parameters.
	/// </summary>
	public override string ParamsString => _paramsString;
}

/// <summary>
/// Autotext triggers.
/// </summary>
/// <example>See <see cref="ActionTriggers"/>.</example>
public class AutotextTriggers : ITriggers, IEnumerable<AutotextTrigger> {
	ActionTriggers _triggers;
	Dictionary<int, ActionTrigger> _d = new();
	
	internal AutotextTriggers(ActionTriggers triggers) {
		_triggers = triggers;
		_simpleReplace = new TASimpleReplace(this);
	}
	
	/// <summary>
	/// Adds an autotext trigger.
	/// </summary>
	/// <param name="text">The action runs when the user types this text and a postfix character or key. By default case-insensitive.</param>
	/// <param name="flags">Options. If omitted or <c>null</c>, uses <see cref="DefaultFlags"/>. Some flags are used by <see cref="AutotextTriggerArgs.Replace"/>.</param>
	/// <param name="postfixType">Postfix type (character, key, any or none). If omitted or <c>null</c>, uses <see cref="DefaultPostfixType"/>; default - a non-word character or the <c>Ctrl</c> key.</param>
	/// <param name="postfixChars">Postfix characters used when postfix type is <c>Char</c> or <c>CharOrKey</c> (default). If omitted or <c>null</c>, uses <see cref="DefaultPostfixChars"/>; default - non-word characters.</param>
	/// <param name="f_">[](xref:caller_info)</param>
	/// <param name="l_">[](xref:caller_info)</param>
	/// <exception cref="ArgumentException">
	/// - Text is empty or too long. Can be 1 - 100 characters.
	/// - Postfix characters contains letters or digits.
	/// </exception>
	/// <exception cref="InvalidOperationException">Cannot add triggers after <see cref="ActionTriggers.Run"/> was called, until it returns.</exception>
	/// <example>See <see cref="ActionTriggers"/>.</example>
	public Action<AutotextTriggerArgs> this[string text, TAFlags? flags = null, TAPostfix? postfixType = null, string postfixChars = null, [CallerFilePath] string f_ = null, [CallerLineNumber] int l_ = 0] {
		set {
			_triggers.ThrowIfRunning_();
			int len = text.Lenn(); if (len < 1 || len > 100) throw new ArgumentException("Text length must be 1 - 100.");
			if (text.Contains('\n')) { text = text.RxReplace(@"\r?\n", "\r"); len = text.Length; }
			TAFlags fl = flags ?? DefaultFlags;
			bool matchCase = 0 != (fl & TAFlags.MatchCase);
			if (!matchCase) text = text.Lower();
			var t = new AutotextTrigger(_triggers, value, text, fl,
				postfixType ?? DefaultPostfixType,
				_CheckPostfixChars(postfixChars) ?? DefaultPostfixChars,
				MenuOptions,
				(f_, l_));
			//create dictionary key from 1-4 last characters lowercase
			int k = 0;
			for (int i = len - 1, j = 0; i >= 0 && j <= 24; i--, j += 8) {
				var c = text[i]; if (matchCase) c = char.ToLowerInvariant(c);
				k |= (byte)c << j;
			}
			//print.it((uint)k);
			t.DictAdd_(_d, k);
			_lastAdded = t;
		}
	}
	
	/// <summary>
	/// Allows to add triggers in a more concise way - assign a string, not a function. The string will replace the user-typed text.
	/// </summary>
	/// <example>
	/// <code><![CDATA[
	/// var ts = Triggers.Autotext.SimpleReplace;
	/// ts["#su"] = "Sunday"; //the same as Triggers.Autotext["#su"] = o => o.Replace("Sunday");
	/// ts["#mo"] = "Monday";
	/// ]]></code>
	/// </example>
	public TASimpleReplace SimpleReplace => _simpleReplace;
	TASimpleReplace _simpleReplace;
	
	#region options
	
	/// <summary>
	/// Default value for the <i>flags</i> parameter used for triggers added afterwards.
	/// </summary>
	public TAFlags DefaultFlags { get; set; }
	
	/// <summary>
	/// Default value for the <i>postfixType</i> parameter used for triggers added afterwards.
	/// </summary>
	public TAPostfix DefaultPostfixType { get; set; }
	
	/// <summary>
	/// Default value for the <i>postfixChars</i> parameter used for triggers added afterwards.
	/// Default: <c>null</c>.
	/// </summary>
	/// <remarks>
	/// If <c>null</c> (default), postfix characters are all except alpha-numeric (see <see cref="char.IsLetterOrDigit"/>).
	/// The value cannot contain alpha-numeric characters (exception) and <see cref="WordCharsPlus"/> characters (triggers will not work).
	/// For <c>Enter</c> use <c>'\r'</c>.
	/// </remarks>
	/// <exception cref="ArgumentException">The value contains letters or digits.</exception>
	public string DefaultPostfixChars {
		get => _defaultPostfixChars;
		set => _defaultPostfixChars = _CheckPostfixChars(value);
	}
	string _defaultPostfixChars;
	
	static string _CheckPostfixChars(string s) {
		if (s.NE()) return null;
		int k = 0;
		for (int i = 0; i < s.Length; i++) {
			char c = s[i];
			if (char.IsLetterOrDigit(c)) throw new ArgumentException("Postfix characters contains letters or digits.");
			if (c == '\r') k |= 1;
			if (c == '\n') k |= 2;
		}
		if (k == 2) print.warning("Postfix characters contains \\n (Ctrl+Enter) but no \\r (Enter).");
		return s;
	}
	
	/// <summary>
	/// The postfix key for all triggers where postfix type is <see cref="TAPostfix.Key"/> or <see cref="TAPostfix.CharOrKey"/> (default).
	/// Can be <c>Ctrl</c> (default), <c>Shift</c>, <c>LCtrl</c>, <c>RCtrl</c>, <c>LShift</c> or <c>RShift</c>.
	/// </summary>
	/// <exception cref="ArgumentException">The value is not <c>Ctrl</c> or <c>Shift</c>.</exception>
	/// <remarks>
	/// This property is applied to all triggers, not just to those added afterwards.
	/// </remarks>
	public KKey PostfixKey {
		get => _postfixKey;
		set {
			var mod = keys.Internal_.KeyToMod(value);
			switch (mod) {
			case KMod.Ctrl: case KMod.Shift: break;
			default: throw new ArgumentException("Must be Ctrl, Shift, LCtrl, RCtrl, LShift or RShift.");
			}
			_postfixMod = mod; _postfixKey = value;
		}
	}
	KKey _postfixKey = KKey.Ctrl;
	KMod _postfixMod = KMod.Ctrl;
	
	/// <summary>
	/// Additional word characters (non-delimiters).
	/// Default: <c>null</c>.
	/// </summary>
	/// <remarks>
	/// By default, only alpha-numeric characters (<see cref="char.IsLetterOrDigit"/> returns <c>true</c>) are considered word characters. You can use this property to add more word characters, for example <c>"_#"</c>.
	/// This is used to avoid activating triggers when a trigger text found inside a word.
	/// This property is applied to all triggers, not just to those added afterwards.
	/// </remarks>
	public string WordCharsPlus { get; set; }
	
	/// <summary>
	/// Options for menus shown by <see cref="AutotextTriggerArgs.Menu"/> and <see cref="AutotextTriggerArgs.Confirm"/>.
	/// Used for triggers added afterwards.
	/// </summary>
	/// <example>
	/// Show menus by the text cursor. If impossible - in the center of the active window.
	/// <code><![CDATA[
	/// tt.MenuOptions = new(PMFlags.ByCaret | PMFlags.WindowCenter);
	/// ]]></code>
	/// </example>
	/// <seealso cref="popupMenu.caretRectFunc"/>
	public TAMenuOptions MenuOptions { get; set; }
	
	/// <summary>
	/// Clears all options that affect autotext triggers created after setting the option: <see cref="DefaultFlags"/>, <see cref="DefaultPostfixType"/>, <see cref="DefaultPostfixChars"/>, <see cref="MenuOptions"/>.
	/// </summary>
	public void ResetOptions() {
		this.DefaultFlags = 0;
		this.DefaultPostfixType = 0;
		this._defaultPostfixChars = null;
		this.MenuOptions = null;
		
		//cannot reset these because they are for all triggers, not only for triggers added afterwards
		//this.PostfixKey = KKey.Ctrl;
		//this.WordCharsPlus = null;
	}
	
	#endregion
	
	/// <summary>
	/// The last added trigger.
	/// </summary>
	public AutotextTrigger Last => _lastAdded;
	AutotextTrigger _lastAdded;
	
	bool ITriggers.HasTriggers => _lastAdded != null;
	
	void ITriggers.StartStop(bool start) {
		this._len = 0;
		this._singlePK = false;
		this._wFocus = default;
		this._deadKey = default;
	}
	
	internal unsafe void HookProc(HookData.Keyboard k, TriggerHookContext thc) {
		Debug.Assert(!k.IsInjectedByAu); //server must ignore
		
		//print.it(k);
		//perf.first();
		
		if (ResetEverywhere) { //set by mouse hooks on click left|right and by keyboard hooks on Au-injected key events. In shared memory.
			ResetEverywhere = false;
			_Reset();
		}
		
		if (k.IsUp) {
			if (_singlePK) {
				_singlePK = false;
				if (_IsPostfixMod(thc.ModThis)) {
					//print.it("< Ctrl up >");
					_Trigger(default, true, _GetFocusedWindow(), thc);
					//goto gReset; //no, resets if triggered, else don't reset
				}
			}
			return;
		}
		
		bool _IsPostfixMod(KMod mod) => mod == _postfixMod && (_postfixKey <= KKey.Ctrl || k.vkCode == _postfixKey) && !k.IsInjected;
		
		var modd = thc.ModThis;
		if (modd != 0) {
			_singlePK = _IsPostfixMod(modd) && thc.Mod == _postfixMod;
			return;
		}
		_singlePK = false;
		
		//TODO3: use KeyToTextConverter.
		if (k.IsAlt && 0 == (thc.Mod & (KMod.Ctrl | KMod.Shift))) goto gReset; //Alt+key without other modifiers. Info: AltGr can add Ctrl, therefore we process it. Info: still not menu mode. Tested: never types a character, except Alt+numpad numbers.
		
		var vk = k.vkCode;
		if (vk >= KKey.PageUp && vk <= KKey.Down) goto gReset; //PageUp, PageDown, End, Home, Left, Up, Right, Down
		
		wnd wFocus = _GetFocusedWindow();
		if (wFocus.Is0) goto gReset;
		
		var c = stackalloc char[8]; int n;
		if (vk == KKey.Packet) {
			c[0] = (char)k.scanCode;
			n = 1;
		} else {
			n = _KeyToChar(c, vk, k.scanCode, wFocus, thc.Mod);
			if (n == 0) { //non-char key
				if (thc.Mod == 0) switch (vk) { case KKey.CapsLock: case KKey.NumLock: case KKey.ScrollLock: case KKey.Insert: case KKey.Delete: return; }
				goto gReset;
			}
			if (n < 0) return; //dead key
		}
		//print.it(n, c[0], c[1]);
		
		for (int i = 0; i < n; i++) _Trigger(c[i], false, wFocus, thc);
		
		return;
		gReset:
		_Reset();
	}
	
	static wnd _GetFocusedWindow() {
		if (!miscInfo.getGUIThreadInfo(out var gt)) return wnd.active;
		if (0 != (gt.flags & (GTIFlags.INMENUMODE | GTIFlags.INMOVESIZE))) return default; //the character will not be typed when showing menu (or just Alt or F10 pressed) or moving/resizing window. Of course this will not work with nonstandard menus, eg in Word, as well as with other controls that don't accept text.
		return gt.hwndFocus; //if no focus, the thread will not receive wm-keydown etc
	}
	
	int _len; //count of valid user-typed characters in _text
	bool _singlePK; //used to detect postfix key (Ctrl or Shift)
	wnd _wFocus; //the focused window/control. Used to reset if focus changed.
	
	void _Reset() {
		_len = 0;
		_singlePK = false;
		//_wFocus = default;
	}
	
	internal static unsafe bool ResetEverywhere {
		get => SharedMemory_.Ptr->triggers.resetAutotext;
		set => SharedMemory_.Ptr->triggers.resetAutotext = value;
	}
	
	unsafe void _Trigger(char c, bool isPK, wnd wFocus, TriggerHookContext thc) {
		//perf.next();
		if (wFocus != _wFocus) {
			_Reset();
			_wFocus = wFocus;
		}
		if (wFocus.Is0) return;
		
		int nc = _len;
		_DetectedPostfix postfixType;
		char postfixChar = default;
		if (isPK) {
			postfixType = _DetectedPostfix.Key;
		} else {
			//print.it((int)c);
			
			if (c < ' ' || c == 127) {
				switch (c) {
				case (char)8: //Backspace
					if (_len > 0) _len--;
					return;
				case '\t':
				case '\r':
				case '\n':
					break;
				default: //Ctrl+C etc generate control characters. Also Esc.
					_Reset();
					return;
					//tested: control codes <32 in most windows don't type characters
					//tested: Ctrl+Backspace (127) in some windows types a rectangle, in others erases previous word
				}
			}
			
			bool isWordChar = _IsWordChar(c);
			postfixType = isWordChar ? _DetectedPostfix.None : _DetectedPostfix.Delim;
			
			const int c_bufLen = 127;
			if (nc >= c_bufLen) { //buffer full. Remove word from beginning.
				int i;
				for (i = 0; i < c_bufLen; i++) if (!_text[i].isWordChar) break;
				if (i == c_bufLen) {
					if (!isWordChar) { _len = 0; return; }
					i = c_bufLen - 20; //remove several first chars. Triggers will not match anyway, because max string lenhth is 100.
				}
				nc = c_bufLen - ++i;
				fixed (_Char* p = _text) Api.memmove(p, p + i, nc * sizeof(_Char));
			}
			
			_text[nc] = new _Char(c, isWordChar);
			_len = nc + 1;
			if (isWordChar) nc++; else postfixChar = c;
			
			//DebugPrintText();
		}
		
		if (nc == 0) return;
		//perf.next();
		g1:
		for (int k = 0, ii = nc - 1, jj = 0; ii >= 0 && jj <= 24; ii--, jj += 8) { //create dictionary key from 1-4 last characters lowercase
			k |= (byte)_text[ii].cLow << jj;
			//print.it((uint)k);
			if (_d.TryGetValue(k, out var v)) {
				AutotextTriggerArgs args = null;
				for (; v != null; v = v.next) {
					var x = v as AutotextTrigger;
					
					var s = x.Text;
					int i = nc - s.Length;
					if (i < 0) continue;
					if (i > 0 && _text[i - 1].isWordChar) continue;
					
					if (0 != (x.Flags & TAFlags.MatchCase)) {
						for (int j = 0; i < nc; i++, j++) if (_text[i].c != s[j]) break;
					} else {
						for (int j = 0; i < nc; i++, j++) if (_text[i].cLow != s[j]) break;
					}
					if (i < nc) continue;
					
					switch (x.PostfixType) {
					case TAPostfix.CharOrKey:
						if (postfixType == _DetectedPostfix.None) continue;
						break;
					case TAPostfix.Char:
						if (postfixType != _DetectedPostfix.Delim) continue;
						break;
					case TAPostfix.Key:
						if (postfixType != _DetectedPostfix.Key) continue;
						break;
					}
					
					if (x.PostfixChars != null && postfixType == _DetectedPostfix.Delim && x.PostfixChars.IndexOf(c) < 0) continue;
					
					if (v.DisabledThisOrAll) continue;
					if (_triggers.triggersListWindowIsActive_) continue;
					
					if (args == null) { //may need for scope callbacks too
						bool hasPChar = postfixType == _DetectedPostfix.Delim;
						int n = s.Length, to = nc; if (hasPChar) { n++; to++; }
						var tt = new string('\0', n);
						i = to - n; fixed (char* p = tt) for (int j = 0; i < to;) p[j++] = _text[i++].c;
						thc.args = args = new AutotextTriggerArgs(x, thc.Window, tt, hasPChar);
					} else args.Trigger = x;
					
					if (!x.MatchScopeWindowAndFunc_(thc)) continue;
					
					_Reset(); //CONSIDER: flag DontReset. If the action generates keyboard events or mouse clicks, our kooks will reset.
					
					thc.trigger = x;
					return;
				}
				
			}
		}
		//maybe there are items where text ends with delim and no postfix
		if (postfixType == _DetectedPostfix.Delim) {
			postfixType = _DetectedPostfix.None;
			postfixChar = '\0';
			nc++;
			goto g1;
		}
		//perf.nw(); //about 90% of time takes _KeyToChar (ToUnicodeEx and GetKeyboardLayout).
	}
	
	unsafe int _KeyToChar(char* c, KKey vk, uint sc, wnd wFocus, KMod mod) {
		var hkl = Api.GetKeyboardLayout(wFocus.ThreadId);
		var ks = stackalloc byte[256];
		_SetKS(mod);
		bool win10 = osVersion.minWin10_1607; //the API resets dead key etc, but on new OS flag 4 prevents it
		int n = Api.ToUnicodeEx((uint)vk, sc, ks, c, 8, win10 ? 4u : 0u, hkl);
		if (!win10) {
			//if need, set dead key again
			var d = stackalloc char[8];
			if (_deadKey.vk != 0 && _deadKey.hkl == hkl) {
				_SetKS(_deadKey.mod);
				Api.ToUnicodeEx((uint)_deadKey.vk, _deadKey.sc, ks, d, 8, 0, hkl);
				_deadKey.vk = 0;
			} else if (n < 0) {
				_deadKey = new(vk, mod, sc, hkl);
				Api.ToUnicodeEx((uint)vk, sc, ks, d, 8, 0, hkl);
			}
		}
		
		void _SetKS(KMod m) {
			ks[(int)KKey.Shift] = (byte)((0 != (m & KMod.Shift)) ? 0x80 : 0);
			ks[(int)KKey.Ctrl] = (byte)((0 != (m & KMod.Ctrl)) ? 0x80 : 0);
			ks[(int)KKey.Alt] = (byte)((0 != (m & KMod.Alt)) ? 0x80 : 0);
			ks[(int)KKey.Win] = (byte)((0 != (m & KMod.Win)) ? 0x80 : 0);
			ks[(int)KKey.CapsLock] = (byte)(keys.isCapsLock ? 1 : 0); //don't need this for num lock
		}
		
		return n;
		
		//info: this works, but:
		//1. Does not work with eg Chinese input method.
		//2. Catches everything that would later be changed by the app, or by a next hook, etc.
		//3. Don't know how to get Alt+numpad characters. Ignore them.
		//	On Alt up could call tounicodeex with sc with flag 0x8000. It gets the char, but resets keyboard state, and the char is not typed.
		//4. In console windows does not work with Unicode characters.
		
		//if(MapVirtualKeyEx(vk, MAPVK_VK_TO_CHAR, hkl)&0x80000000) { print.it("DEAD"); return -1; } //this cannot be used because resets dead key
	}
	
	_DeadKey _deadKey;
	record struct _DeadKey(KKey vk, KMod mod, uint sc, nint hkl);
	
	//User-typed characters. _len characters are valid.
	_Char[] _text = new _Char[128];
	
	struct _Char {
		public char c, cLow;
		public bool isWordChar;
		
		public _Char(char ch, bool isWordChar) {
			c = ch;
			cLow = char.ToLowerInvariant(ch);
			this.isWordChar = isWordChar;
		}
	}
	
	enum _DetectedPostfix { None, Delim, Key }
	
	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	bool _IsWordChar(char c) {
		if (char.IsLetterOrDigit(c)) return true; //speed: 4 times faster than Api.IsCharAlphaNumeric. Tested with a string containing 90% ASCII chars.
		var v = WordCharsPlus;
		return v != null && v.Contains(c);
	}
	
	[Conditional("DEBUG")]
	unsafe void _DebugPrintText() {
		var s = new string(' ', _len);
		fixed (char* p = s) for (int i = 0; i < s.Length; i++) p[i] = _text[i].c;
		print.it(s);
	}
	
	internal static unsafe void JitCompile() {
		Jit_.Compile(typeof(AutotextTriggers), nameof(HookProc), nameof(_Trigger), nameof(_KeyToChar));
	}
	
	/// <summary>
	/// Used by <c>foreach</c> to enumerate added triggers.
	/// </summary>
	public IEnumerator<AutotextTrigger> GetEnumerator() {
		foreach (var kv in _d) {
			for (var v = kv.Value; v != null; v = v.next) {
				var x = v as AutotextTrigger;
				yield return x;
			}
		}
	}
	
	IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
}

/// <summary>
/// Arguments for actions of autotext triggers.
/// You can use functions <see cref="Replace"/> and <see cref="Menu"/> to replace user-typed text.
/// </summary>
public class AutotextTriggerArgs : TriggerArgs {
	///
	public AutotextTrigger Trigger { get; internal set; }
	
	///
	[EditorBrowsable(EditorBrowsableState.Never)]
	public override ActionTrigger TriggerBase => Trigger;
	
	/// <summary>
	/// The active window.
	/// </summary>
	public wnd Window { get; }
	
	/// <summary>
	/// The user-typed text. If <see cref="HasPostfixChar"/>==<c>true</c>, the last character is the postfix delimiter character.
	/// </summary>
	public string Text { get; }
	
	/// <summary>
	/// <c>true</c> if the autotext activated when the user typed a postfix delimiter character. Then it is the last character in <see cref="Text"/>.
	/// </summary>
	public bool HasPostfixChar { get; }
	
	/// <summary>
	/// If <c>true</c>, <see cref="Replace"/> will select text with <c>Shift+Left</c> instead of erasing with <c>Backspace</c>. Except in console windows.
	/// </summary>
	/// <remarks>
	/// Initially <c>true</c> if flag <see cref="TAFlags.ShiftLeft"/> is set. Can be changed by a callback function, for example to use or not use <c>Shift+Left</c> only with some windows.
	/// </remarks>
	public bool ShiftLeft { get; set; }
	
	///
	public AutotextTriggerArgs(AutotextTrigger trigger, wnd w, string text, bool hasPChar) {
		Trigger = trigger;
		Window = w;
		Text = text;
		HasPostfixChar = hasPChar;
		ShiftLeft = trigger.Flags.Has(TAFlags.ShiftLeft);
		
		//print.it($"'{text}'", hasPChar);
	}
	
	///
	public override string ToString() => "Trigger: " + Trigger;
	
	/// <summary>
	/// Replaces the user-typed text with the specified text or/and HTML.
	/// </summary>
	/// <param name="text">
	/// The replacement text. Can be <c>null</c>.
	/// Can contain <c>[[|]]</c> to move the text cursor (caret) there with the <c>Left</c> key; not if <i>html</i> specified.
	/// </param>
	/// <param name="html">
	/// The replacement HTML. Can be full HTML or fragment. See <see cref="clipboardData.AddHtml"/>.
	/// Can be specified only <i>text</i> or only <i>html</i> or both. If both, will paste <i>html</i> in apps that support it, elsewhere <i>text</i>. If only <i>html</i>, in apps that don't support HTML will paste <i>html</i> as text.
	/// </param>
	/// <remarks>
	/// Options for this function can be specified when adding triggers, in the <i>flags</i> parameter. Or before adding triggers, with <see cref="AutotextTriggers.DefaultFlags"/>.
	/// </remarks>
	/// <example>
	/// <code><![CDATA[
	/// Triggers.Autotext["#exa"] = o => o.Replace("<example>[[|]]</example>");
	/// ]]></code>
	/// More examples: <see cref="ActionTriggers"/>.
	/// </example>
	public void Replace(string text, string html = null) {
		if (text == "") text = null;
		if (html == "") html = null;
		_Replace(text, html, null);
	}
	
	/// <summary>
	/// Replaces the user-typed text with the specified text, keys, clipboard data, etc.
	/// </summary>
	/// <remarks>
	/// Options for this function can be specified when adding triggers, in the <i>flags</i> parameter. Or before adding triggers, with <see cref="AutotextTriggers.DefaultFlags"/>. This function uses <see cref="TAFlags.Confirm"/>, <see cref="TAFlags.DontErase"/>, <see cref="TAFlags.ShiftLeft"/>, <see cref="TAFlags.RemovePostfix"/>.
	/// 
	/// If used flag <see cref="TAFlags.Confirm"/>, for label can be used first argument with prefix <c>"!!"</c>; else displays all string arguments.
	/// </remarks>
	/// <inheritdoc cref="keys.send" path="/param"/>
	public void Replace2([ParamString(PSFormat.Keys)] params KKeysEtc[] keysEtc) {
		Not_.Null(keysEtc);
		_Replace(null, null, keysEtc);
	}
	
	void _Replace(string r, string html, KKeysEtc[] ke) {
		bool onlyText = r != null && html == null;
		var flags = this.Trigger.Flags;
		
		string t = this.Text;
		
		int caret = -1;
		if (onlyText) {
			caret = r.Find("[[|]]");
			if (caret >= 0) r = r.Remove(caret, 5);
			
			if (!flags.HasAny(TAFlags.ReplaceRaw | TAFlags.MatchCase)) {
				int len = t.Length; if (this.HasPostfixChar) len--;
				int i; for (i = 0; i < len; i++) if (char.IsLetterOrDigit(t[i])) break; //eg if t is <c>"#abc"</c>, we need a, not #
				if (i < len && char.IsUpper(t[i])) {
					bool allUpper = false; //make r ucase if t contains 0 lcase chars and >=2 ucase chars
					while (++i < len) {
						var uc = char.GetUnicodeCategory(t[i]);
						if (uc == UnicodeCategory.LowercaseLetter) { allUpper = false; break; }
						if (uc == UnicodeCategory.UppercaseLetter) allUpper = true;
					}
					r = r.Upper(allUpper ? SUpper.AllChars : SUpper.FirstChar);
				}
			}
		}
		
		if (flags.Has(TAFlags.Confirm)) {
			string confirmText;
			if (!ke.NE_()) {
				confirmText = null;
				if (ke[0].Value is string s2 && s2.Starts("!!")) {
					confirmText = s2[2..];
					ke = ke.RemoveAt(0);
				} else {
					foreach (var v in ke) if (v.Value is string s1) { if (confirmText != null) confirmText += ", "; confirmText += s1; }
				}
			} else confirmText = r ?? html;
			if (!Confirm(confirmText)) return;
		}
		
		var k = new keys(opt.key);
		var optk = k.Options;
		
		//UWP is very slow. If text is long and fast: 1. Often does not display part of it until next key. 2. Starts to display with a long delay.
		//	WinUI3 even slower, and has problem 2 but not 1. Because of 2 it's better to send text slower.
		wnd ww = this.Window.Window;
		bool uwp = 0 != ww.IsUwpApp || ww.IsWinUI_;
		//bool uwp = keys.isScrollLock;
		if (uwp) {
			optk.TextSpeed = Math.Max(optk.TextSpeed, 10); //default 0
			optk.KeySpeed = Math.Max(optk.KeySpeed, 20); //default 2
			optk.KeySpeedClipboard = Math.Max(optk.KeySpeedClipboard, 30); //default 5
			int n1 = optk.PasteLength - 100; if (n1 > 0) optk.PasteLength = 100 + n1 / 5; //default 200 -> 120
		} else {
			optk.KeySpeed = Math.Clamp(optk.KeySpeed, 2, 20);
			optk.TextSpeed = Math.Min(optk.TextSpeed, 10);
		}
		optk.PasteWorkaround = true;
		//info: later Options.Hook can override these values.
		
		int erase = flags.Has(TAFlags.DontErase) ? (this.HasPostfixChar ? 1 : 0) : t.Length;
		if (erase > 0) {
			bool shiftLeft = this.ShiftLeft && !wnd.active.IsConsole;
			if (shiftLeft) { k.AddKey(KKey.Shift, true); k.AddKey(KKey.Left); } else k.AddKey(KKey.Back);
			if (erase > 1) k.AddRepeat(erase);
			if (shiftLeft) k.AddKey(KKey.Shift, false);
			//note: Back down down ... up does not work with some apps
			
			//some apps have async input and eg don't erase all if too fast.
			//	UWP is the champion. Also noticed in Chrome address bar (rare), Dreamweaver when pasting (1/5 times), etc.
			int sleep = 5 + erase; if (uwp) sleep *= 10;
			k.AddSleep(sleep);
			k.Pasting += (_, _) => wait.ms(sleep * 2);
		} else if (uwp) {
			k.Pasting += (_, _) => wait.ms(50);
		}
		
		KKey pKey = default; char pChar = default;
		if (this.HasPostfixChar && !flags.Has(TAFlags.RemovePostfix)) {
			char ch = t[^1];
			if (ch == ' ' || ch == '\r' || ch == '\t') pKey = (KKey)ch; //avoid trimming of pasted text or pasting '\r'; here VK_ == ch.
			else if (onlyText) r += ch.ToString();
			else pChar = ch;
		}
		
		if (ke != null) k.Add(ke); else k.AddText(r, html);
		
		if (pKey != default) k.AddKey(pKey); else if (pChar != default) k.AddText(pChar.ToString(), OKeyText.KeysOrChar);
		
		if (caret >= 0) {
			int keyLeft = 0;
			for (int i = caret; i < r.Length; keyLeft++) {
				char c = r[i++];
				if (c == '\r') {
					if (i < r.Length && r[i] == '\n') i++;
				} else if (char.IsHighSurrogate(c)) {
					if (i < r.Length && char.IsLowSurrogate(r[i])) i++;
				}
			}
			if (pKey != default || pChar != default) keyLeft++;
			if (keyLeft > 0) {
				k.AddKey(KKey.Left);
				if (keyLeft > 1) k.AddRepeat(keyLeft);
			}
		}
		
		try { k.SendNow(); }
		catch { } //unlikely
	}
	
	/// <summary>
	/// If <see cref="HasPostfixChar"/>==<c>true</c>, sends the postfix character (last character of <see cref="Text"/>) to the active window.
	/// </summary>
	public void SendPostfix() {
		if (this.HasPostfixChar) {
			var k = new keys(opt.key).AddText(this.Text[^1..], OKeyText.KeysOrChar);
			try { k.SendNow(); }
			catch { } //unlikely
		}
		//CONSIDER: AddText -> AddChar. Also in other place. But the speed option is different.
	}
	
	/// <summary>
	/// Shows a 1-item menu below the text cursor (caret) or mouse cursor.
	/// </summary>
	/// <returns>Returns <c>true</c> if the user clicked the item or pressed <c>Enter</c> or <c>Tab</c>.</returns>
	/// <param name="text">Text to display. This function limits it to 300 characters. Default: <c>"Replace"</c>.</param>
	/// <remarks>
	/// This function is used by <see cref="Replace"/> when used flag <see cref="TAFlags.Confirm"/>.
	/// 
	/// The user can close the menu with <c>Enter</c>, <c>Tab</c> or <c>Esc</c>. Other keys close the menu and are passed to the active window.
	/// </remarks>
	/// <seealso cref="AutotextTriggers.MenuOptions"/>
	/// <seealso cref="popupMenu.defaultFont"/>
	/// <seealso cref="popupMenu.defaultMetrics"/>
	/// <example>
	/// Code in file <c>Autotext triggers</c>.
	/// <code><![CDATA[
	/// //var tt = Triggers.Autotext;
	/// tt["con1", TAFlags.Confirm] = o => o.Replace("Flag Confirm");
	/// tt["con2"] = o => { if(o.Confirm("Example")) o.Replace("Function Confirm"); };
	/// ]]></code>
	/// </example>
	public bool Confirm(string text = "Replace") {
		text ??= "Replace";
		var m = new popupMenu { RawText = true };
		m.Add(1, text.Limit(300));
		m.KeyboardHook = (m, g) => {
			if (g.Key is KKey.Enter or KKey.Tab or KKey.Escape) {
				if (g.Key != KKey.Escape) m.FocusedItem = m.Items.First();
				return PMKHook.Default;
			}
			return PMKHook.Close;
		};
		
		return 1 == _ShowMenu(m);
	}
	
	/// <summary>
	/// Creates and shows a menu below the text cursor (caret) or mouse cursor, and calls <see cref="Replace(string, string)"/>.
	/// </summary>
	/// <param name="items">
	/// Menu items. An item can be specified as:
	/// <br/>• string - the replacement text. Also it's the menu item label.
	/// <br/>• <see cref="TAMenuItem"/> - allows to set custom label and the replacement text and/or HTML.
	/// <br/>• <c>null</c> - separator.
	/// <br/>Label can contain tooltip like <c>"Text\0 Tooltip"</c>.
	/// Replacement text can contain <c>[[|]]</c> to move the caret there (see <see cref="AutotextTriggerArgs.Replace"/>).
	/// </param>
	/// <remarks>
	/// Keyboard:
	/// - <c>Esc</c> - close the menu.
	/// - <c>Enter</c>, <c>Tab</c> - select the focused or the first item.
	/// - <c>Down</c>, <c>Up</c>, <c>End</c>, <c>Home</c>, <c>PageDown</c>, <c>PageUp</c> - focus menu items.
	/// - Also to select menu items can type the number characters displayed at the right.
	/// - Other keys close the menu and are passed to the active window.
	/// </remarks>
	/// <seealso cref="AutotextTriggers.MenuOptions"/>
	/// <seealso cref="popupMenu.defaultFont"/>
	/// <seealso cref="popupMenu.defaultMetrics"/>
	/// <example>
	/// Code in file <c>Autotext triggers</c>.
	/// <code><![CDATA[
	/// //var tt = Triggers.Autotext;
	/// tt["m1"] = o => o.Menu([
	/// 	"https://www.example.com",
	/// 	"<tag>[[|]]</tag>",
	/// 	new("Label example", "TEXT1"),
	/// 	null,
	/// 	new("HTML example", "TEXT2", "<b>TEXT2</b>"),
	/// 	new(null, "TEXT3"),
	/// 	]);
	/// ]]></code>
	/// </example>
	public void Menu(params TAMenuItem[] items) {
		if (items.NE_()) return;
		
		var m = new popupMenu(null, Trigger.SourceFile, Trigger.SourceLine) {
			ExtractIconPathFromCode = false,
			RawText = true,
		};
		
		for (int i = 0; i < items.Length; i++) {
			var v = items[i];
			if (v == null) {
				m.Separator();
				continue;
			}
			string lab = v.Label, text = v.Text ?? v.Html;
			if (lab == null) {
				lab = text.Limit(50).RxReplace(@"\R", " ");
				if (v.Text != null) lab = lab.Replace("[[|]]", null);
			}
#if true
			var mi = m.Add(i + 1, lab, f_: Trigger.SourceFile, l_: v.l_ > 0 ? v.l_ : Trigger.SourceLine);
			if (text != lab) mi.Tooltip ??= text;
			//if (i == 0) m.FocusedItem = mi; //then no tooltip
			if (i < 9) mi.Hotkey = (i + 1).ToS();
#else //CONSIDER: option "numbers at left side". User suggestion.
			bool numbersAtLeft = true;
			string lab2 = numbersAtLeft && i < 9 ? $"{(i + 1).ToS()}. {lab}" : lab;
			var mi = m.Add(i + 1, lab2, f_: Trigger.sourceFile, l_: v.l_ > 0 ? v.l_ : Trigger.sourceLine);
			if (text != lab) mi.Tooltip ??= text;
			//if (i == 0) m.FocusedItem = mi; //then no tooltip
			if (!numbersAtLeft && i < 9) mi.Hotkey = (i + 1).ToS();
#endif
		}
		
		KeyToTextConverter kt = null;
		m.KeyboardHook = (m, g) => {
			if (g.Key is KKey.Enter or KKey.Tab) {
				m.FocusedItem ??= m.ItemsAndSeparators[0];
				return PMKHook.Default;
			}
			if (g.Key is KKey.Escape or KKey.Down or KKey.Up or KKey.End or KKey.Home or KKey.PageDown or KKey.PageUp) {
				return PMKHook.Default;
			}
			if (g.Mod != 0) return PMKHook.None;
			kt ??= new();
			if (kt.Convert(out var c, g.vkCode, g.scanCode, keys.getMod(), Window.ThreadId) && c.c is >= '1' and <= '9') {
				int i = c.c - '1';
				if (i >= m.ItemsAndSeparators.Count) return PMKHook.Default; //block
				m.FocusedItem = m.ItemsAndSeparators[i];
				return PMKHook.ExecuteFocused;
			}
			return PMKHook.Close;
		};
		
		int r = _ShowMenu(m) - 1;
		if (r >= 0) Replace(items[r].Text, items[r].Html);
	}
	
	int _ShowMenu(popupMenu m) {
		var mo = Trigger.menuOptions;
		return m.Show(mo?.pmFlags ?? PMFlags.ByCaret);
	}
}

/// <summary>
/// See <see cref="AutotextTriggers.SimpleReplace"/>.
/// </summary>
public class TASimpleReplace {
	AutotextTriggers _host;
	
	internal TASimpleReplace(AutotextTriggers host) {
		_host = host;
	}
	
	/// <summary>
	/// Adds an autotext trigger. Its action calls <see cref="AutotextTriggerArgs.Replace(string, string)"/>.
	/// </summary>
	/// <inheritdoc cref="AutotextTriggers.this[string, TAFlags?, TAPostfix?, string, string, int]"/>
	public string this[string text, TAFlags? flags = null, TAPostfix? postfixType = null, string postfixChars = null, [CallerFilePath] string f_ = null, [CallerLineNumber] int l_ = 0] {
		set {
			_host[text, flags, postfixType, postfixChars, f_, l_] = o => o.Replace(value);
		}
	}
}

/// <summary>
/// Used with <see cref="AutotextTriggerArgs.Menu"/>.
/// </summary>
public class TAMenuItem {
	///
	public string Label { get; set; }
	///
	public string Text { get; set; }
	///
	public string Html { get; set; }
	
	internal int l_;
	
	/// <summary>
	/// Sets menu item label and replacement text.
	/// </summary>
	/// <param name="label">Menu item label. If <c>null</c>, uses <see cref="Text"/>. Can contain tooltip like <c>"Label\0 Tooltip"</c>.</param>
	/// <param name="text">The replacement text. Can be <c>null</c>. Can contain caret placeholder <c>[[|]]</c>. See <see cref="AutotextTriggerArgs.Replace(string, string)"/>.</param>
	/// <param name="html">The replacement HTML. Can be <c>null</c>. See <see cref="AutotextTriggerArgs.Replace(string, string)"/>.</param>
	/// <param name="l_">[](xref:caller_info)</param>
	public TAMenuItem(string label, string text, string html = null, [CallerLineNumber] int l_ = 0) {
		Label = label;
		Text = text;
		Html = html;
		this.l_ = l_;
	}
	
	/// <summary>
	/// Creates <c>TAMenuItem</c> with only <see cref="Text"/>.
	/// </summary>
	public static implicit operator TAMenuItem(string text) => new(null, text, null, 0);
}


================================================
FILE: Au/Triggers/Types/t-hotkey.cs
================================================
//CONSIDER: AltGr generates RAlt+LCtrl. Should then ignore Ctrl?

namespace Au.Triggers;

/// <summary>
/// Flags of hotkey triggers.
/// </summary>
[Flags]
public enum TKFlags {
	/// <summary>
	/// Allow other apps to receive the key down message too.
	/// <br/>Without this flag, other apps usually receive only modifier keys. Also, OS always receives <c>Ctrl+Alt+Delete</c> and some other hotkeys.
	/// <br/>To receive and block key messages is used a low-level hook. Other hooks may receive blocked messages or not, depending on when they were set. 
	/// </summary>
	ShareEvent = 1,
	
	/// <summary>
	/// Run the action when the key and modifier keys are released.
	/// </summary>
	KeyModUp = 2,
	
	/// <summary>
	/// The trigger works only with left-side modifier keys.
	/// </summary>
	LeftMod = 4,
	
	/// <summary>
	/// The trigger works only with right-side modifier keys.
	/// </summary>
	RightMod = 8,
	
	/// <summary>
	/// Don't release modifier keys.
	/// <br/>Without this flag, for example if trigger is <c>["Ctrl+K"]</c>, when the user presses <c>Ctrl</c> and <c>K</c> down, the trigger sends <c>Ctrl</c> key-up event, making the key logically released, although it is still physically pressed. Then modifier keys don't interfere with the action. However functions like <see cref="keys.getMod"/> and <see cref="keys.waitForKey"/> (and any such functions in any app) will not know that the key is physically pressed; there is no API to get physical key state.
	/// <br/>Other flags that prevent releasing modifier keys: <c>KeyUp</c>, <c>ShareEvent</c>. Then don't need this flag.
	/// <br/>Note: Unreleased modifier keys will interfere with mouse functions like <see cref="mouse.click"/>. Will not interfere with keyboard and clipboard functions of this library, because they release modifier keys, unless <c>opt.key.NoModOff</c> is <c>true</c>. Will not interfere with functions that send text, unless <c>opt.key.NoModOff</c> is <c>true</c> and <c>opt.key.TextHow</c> is <c>OKeyText.KeysX</c>.
	/// </summary>
	NoModOff = 16,
	
	/// <summary>
	/// The key must be an "extended key". See <see cref="KKeyScan"/> example code. Don't use this flag with <c>NumpadX</c> flags.
	/// </summary>
	ExtendedYes = 32,
	
	/// <summary>
	/// The key must not be an "extended key". See <see cref="KKeyScan"/> example code. Don't use this flag with <c>NumpadX</c> flags.
	/// </summary>
	ExtendedNo = 64,
	
	/// <summary>
	/// The trigger works only with the key that is on the numeric keypad. This flag can be used with <c>Enter</c>, <c>Home</c>, <c>End</c>, <c>PgUp</c>, <c>PgDown</c>, arrows, <c>Ins</c> and <c>Del</c>.
	/// </summary>
	Numpad = 128,
	
	/// <summary>
	/// The trigger works only with the key that is not on the numeric keypad. This flag can be used with <c>Enter</c>, <c>Home</c>, <c>End</c>, <c>PgUp</c>, <c>PgDown</c>, arrows, <c>Ins</c> and <c>Del</c>.
	/// </summary>
	NumpadNot = 0x100,
}

/// <summary>
/// Represents a hotkey trigger.
/// </summary>
public class HotkeyTrigger : ActionTrigger {
	string _paramsString;
	internal readonly KMod modMasked, modMask;
	
	///
	public TKFlags Flags { get; }
	
	internal HotkeyTrigger(ActionTriggers triggers, Action<HotkeyTriggerArgs> action, KMod mod, KMod modAny, TKFlags flags, string paramsString, (string, int) source)
		: base(triggers, action, true, source) {
		const KMod csaw = KMod.Ctrl | KMod.Shift | KMod.Alt | KMod.Win;
		modMask = ~modAny & csaw;
		modMasked = mod & modMask;
		Flags = flags;
		_paramsString = flags == 0 ? paramsString : paramsString + " (" + flags.ToString() + ")"; //print.it(_paramsString);
	}
	
	internal override void Run_(TriggerArgs args) => RunT_(args as HotkeyTriggerArgs);
	
	/// <summary>
	/// Returns <c>"Hotkey"</c>.
	/// </summary>
	public override string TypeString => "Hotkey";
	
	/// <summary>
	/// Returns a string containing trigger parameters.
	/// </summary>
	public override string ParamsString => _paramsString;
}

/// <summary>
/// Hotkey triggers.
/// </summary>
/// <example>See <see cref="ActionTriggers"/>.</example>
public class HotkeyTriggers : ITriggers, IEnumerable<HotkeyTrigger> {
	ActionTriggers _triggers;
	Dictionary<int, ActionTrigger> _d = new Dictionary<int, ActionTrigger>();
	
	internal HotkeyTriggers(ActionTriggers triggers) {
		_triggers = triggers;
	}
	
	/// <summary>
	/// Adds a hotkey trigger.
	/// </summary>
	/// <param name="hotkey">
	/// A hotkey, like with <see cref="keys.send"/>. See [key names and operators](xref:key_names).
	/// Can contain 0 to 4 modifier keys (<c>Ctrl</c>, <c>Shift</c>, <c>Alt</c>, <c>Win</c>) and 1 non-modifier key.
	/// Examples: <c>"F11"</c>, <c>"Ctrl+K"</c>, <c>"Ctrl+Shift+Alt+Win+A"</c>.
	/// To ignore modifiers: <c>"?+K"</c>. Then the trigger works with any combination of modifiers.
	/// To ignore a modifier: <c>"Ctrl?+K"</c>. Then the trigger works with or without the modifier. More examples: <c>"Ctrl?+Shift?+K"</c>, <c>"Ctrl+Shift?+K"</c>.
	/// </param>
	/// <param name="flags"></param>
	/// <param name="f_">[](xref:caller_info)</param>
	/// <param name="l_">[](xref:caller_info)</param>
	/// <exception cref="ArgumentException">Invalid hotkey string or flags.</exception>
	/// <exception cref="InvalidOperationException">Cannot add triggers after <see cref="ActionTriggers.Run"/> was called, until it returns.</exception>
	/// <example>See <see cref="ActionTriggers"/>.</example>
	public Action<HotkeyTriggerArgs> this[[ParamString(PSFormat.HotkeyTrigger)] string hotkey, TKFlags flags = 0, [CallerFilePath] string f_ = null, [CallerLineNumber] int l_ = 0] {
		set {
			//This could be used instead of [CallerX] parameters, but can be too slow if many triggers. Definitely too slow for menus and toolbars.
			//perf.first();
			//var uu = new StackFrame(1, true); //first time 30 ms, then 30 mcs
			//perf.next();
			//var us = uu.GetFileName(); //0
			//perf.next();
			//var ui = uu.GetFileLineNumber(); //0
			//perf.next();
			//uu = new StackFrame(2, true); //slow too
			//perf.nw();
			////print.it(us, ui);
			////print.it(uu);
			
			if (!keys.more.parseTriggerString(hotkey, out var mod, out var modAny, out var key, false)) throw new ArgumentException("Invalid hotkey string.");
			_Add(value, key, mod, modAny, flags, hotkey, (f_, l_));
		}
	}
	
	/// <summary>
	/// Adds a hotkey trigger.
	/// </summary>
	/// <param name="key"></param>
	/// <param name="modKeys">
	/// Modifier keys. See [key names and operators](xref:key_names).
	/// Examples: <c>"Ctrl"</c>, <c>"Ctrl+Shift+Alt+Win"</c>.
	/// To ignore modifiers: <c>"?"</c>. Then the trigger works with any combination of modifiers.
	/// To ignore a modifier: <c>"Ctrl?"</c>. Then the trigger works with or without the modifier. More examples: <c>"Ctrl?+Shift?"</c>, <c>"Ctrl+Shift?"</c>.
	/// </param>
	/// <param name="flags"></param>
	/// <param name="f_">[](xref:caller_info)</param>
	/// <param name="l_">[](xref:caller_info)</param>
	/// <exception cref="ArgumentException">Invalid <i>modKeys</i> string or <i>flags</i>.</exception>
	/// <exception cref="InvalidOperationException">Cannot add triggers after <see cref="ActionTriggers.Run"/> was called, until it returns.</exception>
	public Action<HotkeyTriggerArgs> this[KKey key, [ParamString(PSFormat.TriggerMod)] string modKeys, TKFlags flags = 0, [CallerFilePath] string f_ = null, [CallerLineNumber] int l_ = 0] {
		set {
			var ps = key.ToString(); if (ps[0].IsAsciiDigit()) ps = "VK" + ps;
			if (!modKeys.NE()) ps = modKeys + "+" + ps;
			
			if (!keys.more.parseTriggerString(modKeys, out var mod, out var modAny, out _, true)) throw new ArgumentException("Invalid modKeys string.");
			_Add(value, key, mod, modAny, flags, ps, (f_, l_));
		}
	}
	
	void _Add(Action<HotkeyTriggerArgs> action, KKey key, KMod mod, KMod modAny, TKFlags flags, string paramsString, (string, int) source) {
		if (mod == 0 && flags.HasAny((TKFlags.LeftMod | TKFlags.RightMod))) throw new ArgumentException("Invalid flags.");
		_triggers.ThrowIfRunning_();
		//actually could safely add triggers while running.
		//	Currently would need just lock(_d) in several places. Also some triggers of this type must be added before starting, else we would not have the hook etc.
		//	But probably not so useful. Makes programming more difficult. If need, can Stop, add triggers, then Run again.
		
		//print.it($"key={key}, mod={mod}, modAny={modAny}");
		var t = new HotkeyTrigger(_triggers, action, mod, modAny, flags, paramsString, source);
		t.DictAdd_(_d, (int)key);
		_lastAdded = t;
	}
	
	/// <summary>
	/// The last added trigger.
	/// </summary>
	public HotkeyTrigger Last => _lastAdded;
	HotkeyTrigger _lastAdded;
	
	bool ITriggers.HasTriggers => _lastAdded != null;
	
	void ITriggers.StartStop(bool start) {
		_UpClear();
		_eatUp = 0;
	}
	
	internal bool HookProc(HookData.Keyboard k, TriggerHookContext thc) {
		//print.it(k.vkCode, !k.IsUp);
		Debug.Assert(!k.IsInjectedByAu); //server must ignore
		
		KKey key = k.vkCode;
		KMod mod = thc.Mod;
		bool up = k.IsUp;
		if (!up) _UpClear();
		
		if (thc.ModThis != 0) {
			if (_upTrigger != null && mod == 0 && _upKey == 0) _UpTriggered(thc);
		} else if (up) {
			if (key == _upKey) {
				_upKey = 0;
				if (_upTrigger != null && mod == 0) _UpTriggered(thc);
			}
			if (key == _eatUp) {
				_eatUp = 0;
				return true;
				//To be safer, could return false if keys.isPressed(_eatUp), but then can interfere with the trigger action.
			}
			//CONSIDER: _upTimeout.
		} else {
			//if(key == _eatUp) _eatUp = 0;
			_eatUp = 0;
			
			if (_d.TryGetValue((int)key, out var v)) {
				HotkeyTriggerArgs args = null;
				for (; v != null; v = v.next) {
					var x = v as HotkeyTrigger;
					if ((mod & x.modMask) != x.modMasked) continue;
					
					if ((x.Flags & (TKFlags.Numpad | TKFlags.NumpadNot)) is TKFlags.Numpad or TKFlags.NumpadNot && key is KKey.Enter or KKey.Home or KKey.End or KKey.PageUp or KKey.PageDown or KKey.Left or KKey.Right or KKey.Up or KKey.Down or KKey.Insert or KKey.Delete) {
						if (k.IsExtended ^ key is KKey.Enter == x.Flags.Has(TKFlags.Numpad)) continue;
					}
					switch (x.Flags & (TKFlags.ExtendedYes | TKFlags.ExtendedNo)) {
					case TKFlags.ExtendedYes: if (!k.IsExtended) continue; break;
					case TKFlags.ExtendedNo: if (k.IsExtended) continue; break;
					}
					
					switch (x.Flags & (TKFlags.LeftMod | TKFlags.RightMod)) {
					case TKFlags.LeftMod: if (thc.ModL != mod) continue; break;
					case TKFlags.RightMod: if (thc.ModR != mod) continue; break;
					}
					
					if (v.DisabledThisOrAll) continue;
					
					if (args == null) thc.args = args = new HotkeyTriggerArgs(x, thc.Window, key, mod); //may need for scope callbacks too
					else args.Trigger = x;
					
					if (!x.MatchScopeWindowAndFunc_(thc)) continue;
					
					if (x.action != null) {
						if (0 != (x.Flags & TKFlags.KeyModUp)) {
							_upTrigger = x;
							_upArgs = args;
							_upKey = key;
						} else {
							thc.trigger = x;
						}
					}
					
					//print.it(key, mod);
					if (0 != (x.Flags & TKFlags.ShareEvent)) return false;
					
					if (thc.trigger == null) { //KeyModUp or action==null
						if (mod is KMod.Alt or KMod.Win or (KMod.Alt | KMod.Win)) {
							//print.it("need Ctrl");
							ThreadPool.QueueUserWorkItem(o => keys.Internal_.SendKey(KKey.Ctrl, dontThrow: true)); //disable Alt/Win menu
						}
					} else if (mod != 0) {
						if (0 == (x.Flags & TKFlags.NoModOff)) thc.muteMod = TriggerActionThreads.c_modRelease;
						else if (mod is KMod.Alt or KMod.Win or (KMod.Alt | KMod.Win)) thc.muteMod = TriggerActionThreads.c_modCtrl;
					}
					
					_eatUp = key;
					return true;
				}
			}
		}
		return false;
	}
	
	HotkeyTrigger _upTrigger;
	HotkeyTriggerArgs _upArgs;
	KKey _upKey;
	KKey _eatUp;
	
	void _UpTriggered(TriggerHookContext thc) {
		thc.args = _upArgs;
		thc.trigger = _upTrigger;
		_UpClear();
	}
	
	void _UpClear() {
		_upTrigger = null;
		_upArgs = null;
		_upKey = 0;
	}
	
	/// <summary>
	/// Used by <c>foreach</c> to enumerate added triggers.
	/// </summary>
	public IEnumerator<HotkeyTrigger> GetEnumerator() {
		foreach (var kv in _d) {
			for (var v = kv.Value; v != null; v = v.next) {
				var x = v as HotkeyTrigger;
				yield return x;
			}
		}
	}
	
	IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
}

/// <summary>
/// Arguments for actions of hotkey triggers.
/// </summary>
public class HotkeyTriggerArgs : TriggerArgs {
	///
	public HotkeyTrigger Trigger { get; internal set; }
	
	///
	[EditorBrowsable(EditorBrowsableState.Never)]
	public override ActionTrigger TriggerBase => Trigger;
	
	/// <summary>
	/// The active window.
	/// </summary>
	public wnd Window { get; }
	
	/// <summary>
	/// The pressed key.
	/// </summary>
	public KKey Key { get; }
	
	/// <summary>
	/// The pressed modifier keys.
	/// </summary>
	/// <remarks>
	/// Can be useful when the trigger ignores modifiers. For example <c>"?+F11"</c> or <c>"Shift?+A"</c>.
	/// </remarks>
	public KMod Mod { get; }
	
	///
	public HotkeyTriggerArgs(HotkeyTrigger trigger, wnd w, KKey key, KMod mod) {
		Trigger = trigger;
		Window = w; Key = key; Mod = mod;
	}
	
	///
	public override string ToString() => "Trigger: " + Trigger;
}


================================================
FILE: Au/Triggers/Types/t-mouse.cs
================================================
namespace Au.Triggers;

/// <summary>
/// Flags of mouse triggers.
/// </summary>
[Flags]
public enum TMFlags : byte {
	/// <summary>
	/// Allow other apps to receive the mouse button or wheel message too.
	/// Used only with the click and wheel triggers.
	/// To receive and block mouse messages is used a low-level hook. Other hooks may receive blocked messages or not, depending on when they were set. 
	/// </summary>
	ShareEvent = 1,
	
	/// <summary>
	/// Run the action when the mouse button and modifier keys are released.
	/// </summary>
	ButtonModUp = 2,
	
	/// <summary>
	/// The trigger works only with left-side modifier keys.
	/// </summary>
	LeftMod = 4,
	
	/// <summary>
	/// The trigger works only with right-side modifier keys.
	/// </summary>
	RightMod = 8,
	
	//rejected. We always mod-off and eat auto-repeated and up events with a temp hook. Because OS does not disable auto-repeating like for hotkeys.
	///// <summary>
	///// Don't release modifier keys.
	///// More info: <see cref="TKFlags.NoModOff"/>.
	///// </summary>
	//NoModOff = 16,
}

/// <summary>
/// Represents a mouse trigger.
/// </summary>
public class MouseTrigger : ActionTrigger {
	readonly string _paramsString;
	readonly byte _data;
	internal readonly KMod modMasked, modMask;
	
	internal MouseTrigger(ActionTriggers triggers, Action<MouseTriggerArgs> action,
		TMKind kind, byte data, KMod mod, KMod modAny, TMFlags flags, screen screen,
		string paramsString, (string, int) source) : base(triggers, action, true, source) {
		const KMod csaw = KMod.Ctrl | KMod.Shift | KMod.Alt | KMod.Win;
		modMask = ~modAny & csaw;
		modMasked = mod & modMask;
		_data = data;
		_paramsString = paramsString;
		Flags = flags;
		Kind = kind;
		Screen = screen;
	}
	
	internal override void Run_(TriggerArgs args) => RunT_(args as MouseTriggerArgs);
	
	/// <summary>
	/// Returns <c>"Mouse"</c>.
	/// </summary>
	public override string TypeString => "Mouse";
	
	/// <summary>
	/// Returns a string containing trigger parameters.
	/// </summary>
	public override string ParamsString => _paramsString;
	
	///
	public TMKind Kind { get; }
	
	///
	public TMClick Button => Kind == TMKind.Click ? (TMClick)_data : default;
	
	///
	public TMWheel Wheel => Kind == TMKind.Wheel ? (TMWheel)_data : default;
	
	///
	public TMEdge Edge => Kind == TMKind.Edge ? (TMEdge)_data : default;
	
	///
	public TMMove Move => Kind == TMKind.Move ? (TMMove)_data : default;
	
	///
	public screen Screen { get; }
	
	///
	public TMFlags Flags { get; }
}

/// <summary>
/// Mouse triggers.
/// </summary>
/// <example> See <see cref="ActionTriggers"/>.</example>
public class MouseTriggers : ITriggers, IEnumerable<MouseTrigger> {
	ActionTriggers _triggers;
	Dictionary<int, ActionTrigger> _d = new Dictionary<int, ActionTrigger>();
	
	internal MouseTriggers(ActionTriggers triggers) {
		_triggers = triggers;
	}
	
	/// <summary>
	/// Adds a mouse click trigger.
	/// </summary>
	/// <param name="button"></param>
	/// <param name="modKeys">
	/// Modifier keys. See [key names and operators](xref:key_names).
	/// Examples: <c>"Ctrl"</c>, <c>"Ctrl+Shift+Alt+Win"</c>.
	/// To ignore modifiers: <c>"?"</c>. Then the trigger works with any combination of modifiers.
	/// To ignore a modifier: <c>"Ctrl?"</c>. Then the trigger works with or without the modifier. More examples: <c>"Ctrl?+Shift?"</c>, <c>"Ctrl+Shift?"</c>.
	/// </param>
	/// <param name="flags"></param>
	/// <param name="f_">[](xref:caller_info)</param>
	/// <param name="l_">[](xref:caller_info)</param>
	/// <exception cref="ArgumentException">Invalid <i>modKeys</i> string or <i>flags</i>.</exception>
	/// <exception cref="InvalidOperationException">Cannot add triggers after <see cref="ActionTriggers.Run"/> was called, until it returns.</exception>
	/// <example>See <see cref="ActionTriggers"/>.</example>
	public Action<MouseTriggerArgs> this[TMClick button, [ParamString(PSFormat.TriggerMod)] string modKeys = null, TMFlags flags = 0, [CallerFilePath] string f_ = null, [CallerLineNumber] int l_ = 0] {
		set {
			_Add(value, TMKind.Click, (byte)button, modKeys, flags, default, button.ToString(), (f_, l_));
		}
	}
	
	/// <summary>
	/// Adds a mouse wheel trigger.
	/// </summary>
	/// <inheritdoc cref="this[TMClick, string, TMFlags, string, int]"/>
	public Action<MouseTriggerArgs> this[TMWheel direction, [ParamString(PSFormat.TriggerMod)] string modKeys = null, TMFlags flags = 0, [CallerFilePath] string f_ = null, [CallerLineNumber] int l_ = 0] {
		set {
			_Add(value, TMKind.Wheel, (byte)direction, modKeys, flags, default, direction.ToString(), (f_, l_));
		}
	}
	
	/// <summary>
	/// Adds a mouse screen edge trigger.
	/// </summary>
	/// <param name="screen">
	/// The trigger will work in this screen (display monitor). Default: the primary screen.
	/// Should be lazy or default; else the function calls <see cref="print.warning"/>.
	/// Examples: <c>screen.at.left(true)</c>, <c>screen.index(1, true)</c>.
	/// If <c>screen.ofMouse</c>, the trigger will work in any screen.
	/// </param>
	/// <param name="a1_">[](xref:caller_info)</param>
	/// <inheritdoc cref="this[TMClick, string, TMFlags, string, int]"/>
	public Action<MouseTriggerArgs> this[TMEdge edge, [ParamString(PSFormat.TriggerMod)] string modKeys = null, TMFlags flags = 0, screen screen = default, [CallerFilePath] string f_ = null, [CallerLineNumber] int l_ = 0, [CallerArgumentExpression("screen")] string a1_ = null] {
		set {
			_Add(value, TMKind.Edge, (byte)edge, modKeys, flags, screen, edge.ToString(), (f_, l_), a1_);
		}
	}
	
	/// <summary>
	/// Adds a mouse move trigger.
	/// </summary>
	/// <inheritdoc cref="this[TMEdge, string, TMFlags, screen, string, int, string]"/>
	public Action<MouseTriggerArgs> this[TMMove move, [ParamString(PSFormat.TriggerMod)] string modKeys = null, TMFlags flags = 0, screen screen = default, [CallerFilePath] string f_ = null, [CallerLineNumber] int l_ = 0, [CallerArgumentExpression("screen")] string a1_ = null] {
		set {
			_Add(value, TMKind.Move, (byte)move, modKeys, flags, screen, move.ToString(), (f_, l_), a1_);
		}
	}
	
	MouseTrigger _Add(Action<MouseTriggerArgs> f, TMKind kind, byte data, string modKeys, TMFlags flags, screen screen, string sData, (string, int) source, string a1_ = null) {
		_triggers.ThrowIfRunning_();
		
		if (screen.Handle != default) print.warning("screen should be lazy or default");
		//CONSIDER: store device id or xy, and repair when handle becomes invalid.
		
		bool noMod = modKeys.NE();
		
		string ps;
		using (new StringBuilder_(out var b)) {
			b.Append(kind.ToString()).Append(' ').Append(sData);
			if (!noMod) b.Append(" + ").Append(modKeys == "?" ? "any" : modKeys);
			if (flags != 0) b.Append(" (").Append(flags.ToString()).Append(')');
			if (kind is TMKind.Edge or TMKind.Move) {
				if (screen.IsEmpty) b.Append(", primary screen");
				else if (screen.IsOfMouse_) b.Append(", any screen");
				else b.Append(", ").Append(a1_);
			}
			ps = b.ToString(); //print.it(ps);
		}
		
		KMod mod = 0, modAny = 0;
		if (noMod) {
			if (flags.HasAny(kind == TMKind.Click ? TMFlags.LeftMod | TMFlags.RightMod : TMFlags.LeftMod | TMFlags.RightMod | TMFlags.ButtonModUp)) throw new ArgumentException("Invalid flags.");
		} else {
			if (!keys.more.parseTriggerString(modKeys, out mod, out modAny, out _, true)) throw new ArgumentException("Invalid modKeys string.");
		}
		var t = new MouseTrigger(_triggers, f, kind, data, mod, modAny, flags, screen, ps, source);
		t.DictAdd_(_d, _DictKey(kind, data));
		_lastAdded = t;
		UsedHookEvents_ |= HooksThread.UsedEvents.Mouse; //just sets the hook
		UsedHookEvents_ |= kind switch {
			TMKind.Click => HooksThread.UsedEvents.MouseClick,
			TMKind.Wheel => HooksThread.UsedEvents.MouseWheel,
			_ => HooksThread.UsedEvents.MouseEdgeMove,
		};
		return t;
	}
	
	static int _DictKey(TMKind kind, byte data) => (data << 8) | (byte)kind;
	
	/// <summary>
	/// The last added trigger.
	/// </summary>
	public MouseTrigger Last => _lastAdded;
	MouseTrigger _lastAdded;
	
	bool ITriggers.HasTriggers => _lastAdded != null;
	
	internal HooksThread.UsedEvents UsedHookEvents_ { get; private set; }
	
	void ITriggers.StartStop(bool start) {
		if (start) {
		} else {
			_ResetUpAndUnhookTempKeybHook();
			_eatUp = 0;
		}
	}
	
	internal bool HookProcClickWheel(HookData.Mouse k, TriggerHookContext thc) {
		//print.it(k.Event, k.pt);
		Debug.Assert(!k.IsInjectedByAu); //server must ignore
		
		TMKind kind;
		byte data;
		
		if (k.IsButton) {
			if (k.IsButtonUp) {
				if (k.Event == _upEvent) {
					_upEvent = 0;
					if (_upMod == 0 && _upTrigger != null) {
						thc.args = _upArgs;
						thc.trigger = _upTrigger;
						_ResetUp();
					}
				}
				if (k.Event == _eatUp) {
					_eatUp = 0;
					return true;
					//To be safer, could return false if mouse.isPressed(k.Button), but then can interfere with the trigger action.
				}
				return false;
				//CONSIDER: _upTimeout.
			}
			if (k.Event == _eatUp) _eatUp = 0;
			
			kind = TMKind.Click;
			var b = k.Event switch {
				HookData.MouseEvent.LeftButton => TMClick.Left,
				HookData.MouseEvent.RightButton => TMClick.Right,
				HookData.MouseEvent.MiddleButton => TMClick.Middle,
				HookData.MouseEvent.X1Button => TMClick.X1,
				_ => TMClick.X2,
			};
			data = (byte)b;
		} else { //wheel
			kind = TMKind.Wheel;
			var b = k.Event switch {
				HookData.MouseEvent.WheelForward => TMWheel.Forward,
				HookData.MouseEvent.WheelBackward => TMWheel.Backward,
				HookData.MouseEvent.WheelLeft => TMWheel.Left,
				_ => TMWheel.Right,
			};
			data = (byte)b;
		}
		
		return _HookProc2(thc, false, kind, k.Event, k.pt, data, 0);
	}
	
	internal void HookProcEdgeMove(EdgeMoveDetector_.Result d, TriggerHookContext thc) //d not in
	{
		TMKind kind;
		byte data, dataAnyPart;
		
		if (d.edgeEvent != 0) {
			kind = TMKind.Edge;
			data = (byte)d.edgeEvent; dataAnyPart = (byte)d.edgeEventAnyPart;
		} else {
			kind = TMKind.Move;
			data = (byte)d.moveEvent; dataAnyPart = (byte)d.moveEventAnyPart;
		}
		
		_HookProc2(thc, true, kind, HookData.MouseEvent.Move, d.pt, data, dataAnyPart);
	}
	
	bool _HookProc2(TriggerHookContext thc, bool isEdgeMove, TMKind kind, HookData.MouseEvent mEvent, POINT pt, byte data, byte dataAnyPart) {
		var mod = TrigUtil.GetModLR(out var modL, out var modR) | _eatMod;
		MouseTriggerArgs args = null;
		g1:
		if (_d.TryGetValue(_DictKey(kind, data), out var v)) {
			if (!isEdgeMove) thc.UseWndFromPoint(pt);
			for (; v != null; v = v.next) {
				var x = v as MouseTrigger;
				if ((mod & x.modMask) != x.modMasked) continue;
				
				switch (x.Flags & (TMFlags.LeftMod | TMFlags.RightMod)) {
				case TMFlags.LeftMod: if (modL != mod) continue; break;
				case TMFlags.RightMod: if (modR != mod) continue; break;
				}
				
				if (isEdgeMove && !x.Screen.IsOfMouse_) {
					var sh = x.Screen.Now;
					if (!sh.Rect.Contains(pt)) continue;
				}
				
				if (v.DisabledThisOrAll) continue;
				
				if (args == null) thc.args = args = new MouseTriggerArgs(x, thc.Window, mod); //may need for scope callbacks too
				else args.Trigger = x;
				
				if (!x.MatchScopeWindowAndFunc_(thc)) continue;
				
				if (x.action == null) {
					_ResetUp();
				} else if (0 != (x.Flags & TMFlags.ButtonModUp) && (mod != 0 || kind == TMKind.Click)) {
					_upTrigger = x;
					_upArgs = args;
					_upEvent = kind == TMKind.Click ? mEvent : 0;
					_upMod = mod;
				} else {
					thc.trigger = x;
					_ResetUp();
				}
				
				_eatMod = mod;
				if (mod != 0) {
					_SetTempKeybHook();
					if (thc.trigger != null) thc.muteMod = TriggerActionThreads.c_modRelease;
					else ThreadPool.QueueUserWorkItem(_ => keys.Internal_.ReleaseModAndDisableModMenu(dontThrow: true));
				}
				
				//print.it(mEvent, pt, mod);
				if (isEdgeMove || 0 != (x.Flags & TMFlags.ShareEvent)) return false;
				if (kind == TMKind.Click) _eatUp = mEvent;
				return true;
			}
		}
		if (dataAnyPart != 0) {
			data = dataAnyPart;
			dataAnyPart = 0;
			goto g1;
		}
		return false;
	}
	
	//these are used to activate trigger when button and modifiers released
	MouseTrigger _upTrigger;
	MouseTriggerArgs _upArgs;
	HookData.MouseEvent _upEvent;
	KMod _upMod;
	//this is used to eat modifier keys, regardless when the trigger is activated
	KMod _eatMod;
	//these are used to eat modifier keys and to activate trigger when modifiers released
	WindowsHook _keyHook;
	long _keyHookTimeout;
	//this is used to eat button-up event, regardless when the trigger is activated
	HookData.MouseEvent _eatUp;
	
	void _ResetUp() {
		_upTrigger = null;
		_upArgs = null;
		_upEvent = 0;
		_upMod = 0;
	}
	
	void _UnhookTempKeybHook() {
		if (_keyHook != null) {
			//print.it(". unhook");
			_keyHook.Unhook();
			_keyHookTimeout = _keyHook.DontBlockModInOtherHooks_(0);
		}
	}
	
	void _ResetUpAndUnhookTempKeybHook() {
		_ResetUp();
		_eatMod = 0;
		_UnhookTempKeybHook();
	}
	
	void _SetTempKeybHook() {
		//print.it(". hook");
		if (_keyHook == null) {
			_keyHook = WindowsHook.Keyboard(k => {
				if (Environment.TickCount64 >= _keyHookTimeout) {
					_ResetUpAndUnhookTempKeybHook();
					Debug_.Print("hook timeout");
				} else {
					var mod = k.Mod;
					if (0 != (mod & _upMod) && k.IsUp) {
						_upMod &= ~mod;
						if (_upMod == 0 && _upEvent == 0 && _upTrigger != null) {
							_triggers.RunAction_(_upTrigger, _upArgs);
							_ResetUp();
						}
					}
					if (0 != (mod & _eatMod)) {
						//print.it(k);
						if (k.IsUp) _eatMod &= ~mod;
						else k.BlockEvent();
					}
					if (0 == (_upMod | _eatMod)) _UnhookTempKeybHook();
				}
			}, setNow: false);
		}
		if (!_keyHook.IsSet) _keyHook.Hook();
		_keyHookTimeout = _keyHook.DontBlockModInOtherHooks_(5000);
	}
	
	internal static void JitCompile() {
		Jit_.Compile(typeof(MouseTriggers), nameof(HookProcClickWheel), nameof(HookProcEdgeMove), nameof(_HookProc2));
		wnd.fromXY(default, WXYFlags.NeedWindow);
	}
	
	/// <summary>
	/// Detects trigger events of types <c>Edge</c> and <c>Move</c>.
	/// </summary>
	/// <remarks>
	/// Used in the hook server, to avoid sending all mouse move events to clients, which would use 2 or more times more CPU, eg 0.9% instead of 0.45%. Tested: raw input uses slightly less CPU.
	/// </remarks>
	internal class EdgeMoveDetector_ {
		int _x, _y; //mouse position. Relative to the primary screen.
		int _xmin, _ymin, _xmax, _ymax; //min and max possible mouse position in current screen. Relative to the primary screen.
		_State _prev;
		int _sens;
		public Result result;
		
		internal struct Result {
			public POINT pt;
			public TMEdge edgeEvent, edgeEventAnyPart;
			public TMMove moveEvent, moveEventAnyPart;
		}
		
		/// <summary>
		/// State data set by previous events.
		/// </summary>
		struct _State {
			public int xx, yy; //previous coords
			public long time; //previous time
			
			//these used for Move events
			public int mx1, my1, mx2, my2;
			public TMMove mDirection;
			public long mTimeout;
			
			//these used for Edge events
			public long eTimeout;
			
#if DEBUG
			//public int debug;
#endif
		}
		
		public bool Detect(POINT pt) {
			//get normal x y. In pt can be outside screen when cursor moved fast and was stopped by a screen edge. Tested: never for click/wheel events.
			//print.it(pt, mouse.xy);
			//var scrn = screen.of(pt); //problem with empty corners between 2 unaligned screens: when mouse tries to quickly diagonally cut such a corner, may activate a wrong trigger
			var scrn = screen.of(mouse.xy); //smaller problem: mouse.xy gets previous coordinates
			var r = scrn.Rect;
			_xmin = r.left; _ymin = r.top; _xmax = r.right - 1; _ymax = r.bottom - 1;
			_x = Math.Clamp(pt.x, _xmin, _xmax);
			_y = Math.Clamp(pt.y, _ymin, _ymax);
			//print.it(pt, _x, _y, r);
			_sens = scrn.Dpi / 4;
			
			result = default;
			result.pt = (_x, _y);
			
			_Detect();
			_prev.xx = _x; _prev.yy = _y;
			
#if DEBUG
			//print.it(++_prev.debug, edgeEvent, moveEvent, (_x, _y));
#endif
			return result.edgeEvent != 0 || result.moveEvent != 0;
		}
		
		void _Detect() {
			if (mouse.isPressed(MButtons.Left | MButtons.Right | MButtons.Middle)) {
				_prev.mDirection = 0;
				return;
			}
			
			int x = _x, y = _y;
			if (x == _prev.xx && y == _prev.yy) { /*print.it("same x y");*/ return; }
			
			long time = perf.ms;
			int dt = (int)(time - _prev.time);
			_prev.time = time;
			if (dt <= 0) return; //never noticed
			
			//print.it((x, y), mouse.xy, time%10000);
			
			if (y == _ymin || y == _ymax || x == _xmin || x == _xmax) {
				_prev.mDirection = 0;
				if (time < _prev.eTimeout) return; //prevent double trigger when OS sometimes gives strange coords if some hook blocks the event
				if (y == _ymin) { //top
					if (_prev.yy <= _ymin) return;
					if (screen.isInAnyScreen((x, y - 1))) return;
					result.edgeEvent = (TMEdge)((int)(result.edgeEventAnyPart = TMEdge.Top) + _PartX(x));
				} else if (y == _ymax) { //bottom
					if (_prev.yy >= _ymax) return;
					if (screen.isInAnyScreen((x, y + 1))) return;
					result.edgeEvent = (TMEdge)((int)(result.edgeEventAnyPart = TMEdge.Bottom) + _PartX(x));
				} else if (x == _xmin) { //left
					if (_prev.xx <= _xmin) return;
					if (screen.isInAnyScreen((x - 1, y))) return;
					result.edgeEvent = (TMEdge)((int)(result.edgeEventAnyPart = TMEdge.Left) + _PartY(y));
				} else /*if(x == _xmax)*/ { //right
					if (_prev.xx >= _xmax) return;
					if (screen.isInAnyScreen((x + 1, y))) return;
					result.edgeEvent = (TMEdge)((int)(result.edgeEventAnyPart = TMEdge.Right) + _PartY(y));
				}
				_prev.eTimeout = time + 100;
			} else {
				if (_prev.mDirection == 0) {
					if (time < _prev.mTimeout) return;
					
					int dx = (x - _prev.xx) * 16 / dt, dy = (y - _prev.yy) * 21 / dt;
					TMMove e = 0;
					if (dx > 0) {
						if (dy > 0) {
							if (dx > dy) {
								if (dx > _sens) e = TMMove.RightLeft;
							} else {
								if (dy > _sens) e = TMMove.DownUp;
							}
						} else {
							if (dx > -dy) {
								if (dx > _sens) e = TMMove.RightLeft;
							} else {
								if (-dy > _sens) e = TMMove.UpDown;
							}
						}
					} else {
						if (dy > 0) {
							if (-dx > dy) {
								if (-dx > _sens) e = TMMove.LeftRight;
							} else {
								if (dy > _sens) e = TMMove.DownUp;
							}
						} else {
							if (-dx > -dy) {
								if (-dx > _sens) e = TMMove.LeftRight;
							} else {
								if (-dy > _sens) e = TMMove.UpDown;
							}
						}
					}
					if (e != 0) {
						//print.it(e);
						_prev.mDirection = e;
						_prev.mTimeout = time + 250;
						_prev.mx1 = _prev.xx; _prev.my1 = _prev.yy; _prev.mx2 = x; _prev.my2 = y;
					}
				} else {
					if (time > _prev.mTimeout) { _prev.mDirection = 0; return; }
					int part = 0;
					var e = _prev.mDirection;
					switch (e) {
					case TMMove.RightLeft:
						if (x < (_prev.mx1 + _prev.mx2) >> 1) {
							_prev.mDirection = 0;
							int dy = (_prev.my1 + _prev.my2) >> 1, dx = (_prev.mx2 - _prev.mx1) >> 2;
							if (Math.Abs(y - dy) > dx || Math.Abs(_prev.my1 - _prev.my2) > dx << 1) break;
							part = _PartY(y);
						} else if (x > _prev.mx2) { _prev.mx2 = x; _prev.my2 = y; }
						break;
					case TMMove.LeftRight:
						if (x > (_prev.mx1 + _prev.mx2) >> 1) {
							_prev.mDirection = 0;
							int dy = (_prev.my1 + _prev.my2) >> 1, dx = (_prev.mx1 - _prev.mx2) >> 2;
							if (Math.Abs(y - dy) > dx || Math.Abs(_prev.my1 - _prev.my2) > dx << 1) break;
							part = _PartY(y);
						} else if (x < _prev.mx2) { _prev.mx2 = x; _prev.my2 = y; }
						break;
					case TMMove.DownUp:
						if (y < (_prev.my1 + _prev.my2) >> 1) {
							_prev.mDirection = 0;
							int dx = (_prev.mx1 + _prev.mx2) >> 1, dy = (_prev.my2 - _prev.my1) >> 2;
							if (Math.Abs(x - dx) > dy || Math.Abs(_prev.mx1 - _prev.mx2) > dy << 1) break;
							part = _PartX(x);
						} else if (y > _prev.my2) { _prev.mx2 = x; _prev.my2 = y; }
						break;
					case TMMove.UpDown:
						if (y > (_prev.my1 + _prev.my2) >> 1) {
							_prev.mDirection = 0;
							int dx = (_prev.mx1 + _prev.mx2) >> 1, dy = (_prev.my1 - _prev.my2) >> 2;
							if (Math.Abs(x - dx) > dy && Math.Abs(_prev.mx1 - _prev.mx2) > dy << 1) break;
							part = _PartX(x);
						} else if (y < _prev.my2) { _prev.mx2 = x; _prev.my2 = y; }
						break;
					}
					if (part != 0) {
						result.moveEventAnyPart = e;
						result.moveEvent = (TMMove)((int)e + part);
					}
				}
			}
		}
		
		int _PartX(int x) {
			int q = (_xmax - _xmin) / 4;
			if (x < _xmin + q) return 2;
			if (x >= _xmax - q) return 3;
			return 1;
		}
		
		int _PartY(int y) {
			int q = (_ymax - _ymin) / 4;
			if (y < _ymin + q) return 2;
			if (y >= _ymax - q) return 3;
			return 1;
		}
		
		///// <summary>
		///// Sensitivity of <see cref="TMMove"/> triggers.
		///// Default: 5. Can be 0 (less sensitive) to 10 (more sensitive).
		///// </summary>
		//public int MoveSensitivity {
		//	get => _sensPublic;
		//	set {
		//		if((uint)value > 10) throw new ArgumentOutOfRangeException(null, "0-10");
		//		_sensPublic = value;
		//		_sens = (int)(Math.Pow(1.414, 14 - value) * 1.3);
		//		print.it(_sens); //29 when _sensPublic 5 (default)
		//	}
		//}
		//int _sensPublic;
	}
	
	/// <summary>
	/// Used by <c>foreach</c> to enumerate added triggers.
	/// </summary>
	public IEnumerator<MouseTrigger> GetEnumerator() {
		foreach (var kv in _d) {
			for (var v = kv.Value; v != null; v = v.next) {
				var x = v as MouseTrigger;
				yield return x;
			}
		}
	}
	
	IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
}

/// <summary>
/// Arguments for actions of mouse triggers.
/// </summary>
public class MouseTriggerArgs : TriggerArgs {
	///
	public MouseTrigger Trigger { get; internal set; }
	
	///
	[EditorBrowsable(EditorBrowsableState.Never)]
	public override ActionTrigger TriggerBase => Trigger;
	
	/// <summary>
	/// The active window (<c>Edge</c> and <c>Move</c> triggers) or the mouse window (<c>Click</c> and <c>Wheel</c> triggers).
	/// </summary>
	public wnd Window { get; }
	
	/// <summary>
	/// The pressed modifier keys.
	/// </summary>
	/// <remarks>
	/// Can be useful when the trigger ignores modifiers. For example <i>modKeys</i> is <c>"?"</c> or <c>"Shift?"</c>.
	/// </remarks>
	public KMod Mod { get; }
	
	///
	public MouseTriggerArgs(MouseTrigger trigger, wnd w, KMod mod) {
		Trigger = trigger;
		Window = w; Mod = mod;
	}
	
	///
	public override string ToString() => "Trigger: " + Trigger;
}

#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member

/// <summary>
/// What kind of mouse triggers.
/// </summary>
public enum TMKind : byte { Click, Wheel, Edge, Move }

/// <summary>
/// Button for mouse click triggers.
/// </summary>
public enum TMClick : byte { Left = 1, Right, Middle, X1, X2 }

/// <summary>
/// Mouse wheel direction for mouse wheel triggers.
/// </summary>
public enum TMWheel : byte { Forward = 1, Backward, Left, Right }

/// <summary>
/// Screen edge for mouse edge triggers.
/// </summary>
/// <remarks>
/// To activate a screen edge trigger, the user touches a screen edge with the mouse pointer.
/// Each screen edge is divided into 3 parts: 1 - center 50%; 2 - left or top 25%; 3 - right or bottom 25%. Constants like <c>TopInCenter50</c> specify an edge and part; the trigger works only in that part of that edge. Constants like <c>Top</c> specify just an edge; the trigger works in all parts of that edge.
/// </remarks>
public enum TMEdge : byte {
	Top = 1, TopInCenter50, TopInLeft25, TopInRight25,
	Bottom, BottomInCenter50, BottomInLeft25, BottomInRight25,
	Left, LeftInCenter50, LeftInTop25, LeftInBottom25,
	Right, RightInCenter50, RightInTop25, RightInBottom25,
}

/// <summary>
/// Mouse movement directions for mouse move triggers.
/// </summary>
/// <remarks>
/// To activate a mouse move trigger, the user quickly moves the mouse pointer to the specified direction and back.
/// The screen is divided into 3 parts: 1 - center 50%; 2 - left or top 25%; 3 - right or bottom 25%. Constants like <c>UpDownInCenter50</c> specify a direction and screen part; the trigger works only in that screen part. Constants like <c>UpDown</c> specify just a direction; the trigger works in whole screen.
/// </remarks>
public enum TMMove : byte {
	RightLeft = 1, RightLeftInCenter50, RightLeftInTop25, RightLeftInBottom25,
	LeftRight, LeftRightInCenter50, LeftRightInTop25, LeftRightInBottom25,
	UpDown, UpDownInCenter50, UpDownInLeft25, UpDownInRight25,
	DownUp, DownUpInCenter50, DownUpInLeft25, DownUpInRight25,
}

//FUTURE: remove.
///
[Obsolete("use code like screen.at.left(true) or screen.index(1, true) or screen.ofMouse"), EditorBrowsable(EditorBrowsableState.Never)]
public static class TMScreen {
	public static screen Primary => default;
	public static screen Any => screen.ofMouse;
	public static screen OfActiveWindow => screen.ofActiveWindow;
	public static screen NonPrimary1 => screen.index(1, true);
	public static screen NonPrimary2 => screen.index(2, true);
	public static screen NonPrimary3 => screen.index(3, true);
	public static screen NonPrimary4 => screen.index(4, true);
	public static screen NonPrimary5 => screen.index(5, true);
}
#pragma warning restore CS1591 // Missing XML comment for publicly visible type or member


================================================
FILE: Au/Triggers/Types/t-window.cs
================================================
namespace Au.Triggers;

/// <summary>
/// Flags of window triggers.
/// </summary>
[Flags]
public enum TWFlags : byte {
	/// <summary>
	/// Run the action when <see cref="ActionTriggers.Run"/> called, if the window then is active (for <c>ActiveOnce</c> etc triggers) or visible (for <c>VisibleOnce</c> etc triggers).
	/// </summary>
	RunAtStartup = 1,
	
	/// <summary>
	/// When using the <i>later</i> parameter, call the currently active <c>Triggers.FuncOf</c> (see <see cref="ActionTriggers.FuncOf"/>) functions on "later" events too.
	/// If the function returns <c>false</c>, the action will not run.
	/// The function runs synchronously in the same thread that called <see cref="ActionTriggers.Run"/>. The action runs asynchronously in another thread, which is slower to start.
	/// As always, <c>Triggers.FuncOf</c> functions must not contain slow code; should take less than 10 ms.
	/// </summary>
	LaterCallFunc = 2,
}

/// <summary>
/// Events for window triggers.
/// </summary>
/// <remarks>
/// Cloaked windows are considered invisible. See <see cref="wnd.IsCloaked"/>.
///
/// The "active" events don't occur if/while the activated window is invisible. To catch invisible windows too, use a <see cref="WinEventHook"/> instead of a trigger. See example.
/// </remarks>
/// <example>
/// How to use a hook instaed of a window trigger. This code can be in the same file as your window triggers.
/// <code><![CDATA[
/// new WinEventHook(EEvent.SYSTEM_FOREGROUND, 0, k => {
/// 	print.it(k.w);
/// 	if (k.w.IsMatch("* Name", "classname")) { print.it("fast code can be here", k.w); };
/// 	//if (k.w.IsMatch("* Name", "classname")) run.thread(() => { print.it("slower code can be here", k.w); });
/// 	//if (k.w.IsMatch("* Name", "classname")) script.run("large code.cs", k.w.Handle.ToS());
/// });
/// ]]></code>
/// </example>
public enum TWEvent {
	/// <summary>
	/// When the specified window becomes active (each time).
	/// </summary>
	Active,
	
	/// <summary>
	/// When the specified window becomes active the first time in the trigger's life.
	/// </summary>
	ActiveOnce,
	
	/// <summary>
	/// When the specified window is created and then becomes active.
	/// The same as <see cref="ActiveOnce"/>, but windows created before calling <see cref="ActionTriggers.Run"/> are ignored.
	/// </summary>
	ActiveNew,
	
	/// <summary>
	/// When the specified window becomes visible (each time).
	/// </summary>
	Visible,
	
	/// <summary>
	/// When the specified window becomes visible the first time in the trigger's life.
	/// </summary>
	VisibleOnce,
	
	/// <summary>
	/// When the specified window is created and then becomes visible.
	/// The same as <see cref="VisibleOnce"/>, but windows created before calling <see cref="ActionTriggers.Run"/> are ignored.
	/// </summary>
	VisibleNew,
}

/// <summary>
/// Window events for the <i>later</i> parameter of window triggers. See <see cref="WindowTriggers.this"/>.
/// </summary>
[Flags]
public enum TWLater : ushort {
	/// <summary>
	/// Name changed.
	/// This event occurs only when the window is active. If name changed while inactive - when afterwards activated.
	/// </summary>
	Name = 1,
	
	/// <summary>
	/// Destroyed (closed).
	/// </summary>
	Destroyed = 2,
	
	/// <summary>
	/// Activated (became the foreground window).
	/// </summary>
	Active = 4,
	
	/// <summary>
	/// Deactivated (lose the foreground window status).
	/// This event also occurs when closing the window, if it was active; then the window possibly is already destroyed, and the handle is invalid.
	/// </summary>
	Inactive = 8,
	
	/// <summary>
	/// Became visible (<see cref="wnd.IsVisible"/> true).
	/// The window can be new or was temporarily hidden.
	/// The window is not actually visible if cloaked, minimized, etc.
	/// </summary>
	Visible = 16,
	
	/// <summary>
	/// Became invisible (<see cref="wnd.IsVisible"/> false).
	/// This event also occurs when closing the window, if it was visible; then the window possibly is already destroyed, and the handle is invalid.
	/// </summary>
	Invisible = 32,
	
	/// <summary>
	/// The window has been cloaked (<see cref="wnd.IsCloaked"/> true).
	/// </summary>
	Cloaked = 64,
	
	/// <summary>
	/// The window has been uncloaked (<see cref="wnd.IsCloaked"/> false).
	/// </summary>
	Uncloaked = 128,
	
	/// <summary>
	/// The window has been minimized.
	/// </summary>
	Minimized = 0x100,
	
	/// <summary>
	/// The window has been restored from the minimized state.
	/// </summary>
	Unminimized = 0x200,
	
	//rejected. Not useful when we don't have notifications for each location change.
	///// <summary>
	///// The user started to move or resize the window.
	///// This event does not occur when maximizing/restoring and when the window is moved/resized not by the user.
	///// </summary>
	//MoveSizeStart = 0x400,
	
	///// <summary>
	///// The user finished (or canceled) to move or resize the window.
	///// This event does not occur when maximizing/restoring and when the window is moved/resized not by the user.
	///// </summary>
	//MoveSizeEnd = 0x800,
	
	//rejected: Location. Use timer or thread-specific EEvent.OBJECT_LOCATIONCHANGE.
	//	Probably it should not be a trigger. If timer, too slow in many cases. If hook, too frequent trigger when drag-moving etc.
	//	If a script wants to track window location, it can easily set WinEventHook(EEvent.OBJECT_LOCATIONCHANGE) instead.
	//rejected: Focus (when eg a child control focused). Use timer or EEvent.OBJECT_FOCUSED.
	//	Rarely used. A script can easily use WinEventHook(EEvent.OBJECT_FOCUSED).
	//rejected: Timer.
}

/// <summary>
/// Represents a window trigger.
/// </summary>
/// <example>
/// <code><![CDATA[
/// Triggers.Window[TWEvent.ActiveNew, "Window name"] = o => print.it(o.Window);
/// var v = Triggers.Window.Last; //v is the new WindowTrigger. Rarely used.
/// ]]></code>
/// </example>
public class WindowTrigger : ActionTrigger {
	string _typeString, _paramsString;
	
	///
	public TWEvent Event { get; }
	///
	public wndFinder Finder { get; }
	///
	public TWFlags Flags { get; }
	///
	public TWLater Later { get; }
	
	internal WindowTrigger(ActionTriggers triggers, Action<WindowTriggerArgs> action, TWEvent ev, wndFinder finder, TWFlags flags, TWLater later, (string, int) source)
		: base(triggers, action, false, source) {
		this.Event = ev;
		this.Finder = finder;
		this.Flags = flags;
		this.Later = later;
	}
	
	internal override void Run_(TriggerArgs args) => RunT_(args as WindowTriggerArgs);
	
	/// <summary>
	/// Returns a trigger type string, like <c>"Window.ActiveNew"</c>.
	/// </summary>
	public override string TypeString => _typeString ??= "Window." + Event;
	
	/// <summary>
	/// Returns a string containing trigger parameters.
	/// </summary>
	public override string ParamsString => _paramsString ??= Finder.ToString();
	
	internal bool IsVisible => Event >= TWEvent.Visible;
	
	internal bool IsOnce => Event is TWEvent.ActiveOnce or TWEvent.VisibleOnce;
	
	internal bool IsNew => Event is TWEvent.ActiveNew or TWEvent.VisibleNew;
	
	internal bool IsAlways => Event is TWEvent.Active or TWEvent.Visible;
}

/// <summary>
/// Window triggers.
/// </summary>
/// <example>
/// Note: the <c>Triggers</c> in examples is a field or property like <c>readonly ActionTriggers Triggers = new();</c>.
/// <code><![CDATA[
/// var wt = Triggers.Window; //wt is a WindowTriggers instance
/// wt[TWEvent.ActiveNew, "Window name"] = o => print.it(o.Window);
/// wt[TWEvent.Visible, "Window2 name"] = o => print.it(o.Window);
/// Triggers.Run();
/// ]]></code>
/// More examples: <see cref="ActionTriggers"/>.
/// </example>
public class WindowTriggers : ITriggers, IEnumerable<WindowTrigger> {
	ActionTriggers _triggers;
	
	internal WindowTriggers(ActionTriggers triggers) {
		_triggers = triggers;
	}
	
	/// <summary>
	/// Adds a window trigger and its action.
	/// </summary>
	/// <param name="winEvent">Trigger event.</param>
	/// <param name="flags">Trigger flags.</param>
	/// <param name="later">
	/// Can optionally specify one or more additional events.
	/// This starts to work when the primary trigger is activated, and works only for that window.
	/// For example, to be notified when the window is closed or renamed, specify <c>later: TWLater.Destroyed | TWLater.Name</c>.
	/// When a "later" event occurs, the trigger action is executed. The <see cref="WindowTriggerArgs.Later"/> property then is that event; it is 0 when it is the primary trigger.
	/// The "later" triggers are not disabled when primary triggers are disabled.
	/// </param>
	/// <param name="f_">[](xref:caller_info)</param>
	/// <param name="l_">[](xref:caller_info)</param>
	/// <exception cref="InvalidOperationException">Cannot add triggers after <see cref="ActionTriggers.Run"/> was called, until it returns.</exception>
	/// <exception cref="ArgumentException">See <see cref="wnd.find"/>.</exception>
	/// <seealso cref="Last"/>
	/// <inheritdoc cref="wnd.find(string, string, WOwner, WFlags, Func{wnd, bool}, WContains)" path="/param"/>
	public Action<WindowTriggerArgs> this[TWEvent winEvent,
			[ParamString(PSFormat.Wildex)] string name = null,
			[ParamString(PSFormat.Wildex)] string cn = null,
			[ParamString(PSFormat.Wildex)] WOwner of = default,
			Func<wnd, bool> also = null,
			WContains contains = default,
			TWFlags flags = 0,
			TWLater later = 0,
			[CallerFilePath] string f_ = null,
			[CallerLineNumber] int l_ = 0
			] {
		set {
			var f = new wndFinder(name, cn, of, 0, also, contains);
			this[winEvent, f, flags, later, f_, l_] = value;
		}
	}
	
	/// <summary>
	/// Adds a window trigger and its action.
	/// </summary>
	/// <exception cref="InvalidOperationException">Cannot add triggers after <see cref="ActionTriggers.Run"/> was called, until it returns.</exception>
	/// <inheritdoc cref="this[TWEvent, string, string, WOwner, Func{wnd, bool}, WContains, TWFlags, TWLater, string, int]" path="/param"/>
	public Action<WindowTriggerArgs> this[TWEvent winEvent, wndFinder f, TWFlags flags = 0, TWLater later = 0, [CallerFilePath] string f_ = null, [CallerLineNumber] int l_ = 0] {
		set {
			_triggers.ThrowIfRunning_();
			if (f.Props.contains.Value is uiimageFinder) print.warning("Window triggers with 'contains image' are unreliable.");
			else if (f.Props.contains.Value is ocrFinder) print.warning("Window triggers with 'contains OCR text' are slow.");
			
			var t = new WindowTrigger(_triggers, value, winEvent, f, flags, later, (f_, l_));
			ref var last = ref _tActive; if (t.IsVisible) last = ref _tVisible;
			if (last == null) {
				last = t;
				last.next = last;
			} else {
				t.next = last.next; //first
				last.next = t;
				last = t;
			}
			_laterEvents |= later;
			_lastAdded = t;
		}
	}
	
	/// <summary>
	/// The last added trigger.
	/// </summary>
	public WindowTrigger Last => _lastAdded;
	WindowTrigger _lastAdded;
	
	bool ITriggers.HasTriggers => _lastAdded != null;
	
	WindowTrigger _tActive, _tVisible; //null or last trigger in linked list
	TWLater _laterEvents, _allEvents;
	bool _usesVisibleArray; //0 != (_allEvents & (TWLater.Visible | TWLater.Invisible))
	
	unsafe void ITriggers.StartStop(bool start) {
		if (start) {
			if (_enumWinProc == null) {
				_enumWinProc = _EnumWinProc;
				_aTriggered.a = new wnd[100];
				_aTriggeredData = new _TriggeredData[100];
				_aVisible.a = new wnd[100];
				_aVisibleOld.a = new wnd[100];
				_hsOld = new HashSet<wnd>(1000);
				_hsSeenActivating = new HashSet<wnd>(50);
				_winPropCache = new WFCache { CacheName = true, NoTimeout = true, IgnoreVisibility = true };
			} else {
				Array.Clear(_aTriggeredData, 0, _aTriggered.len);
				_aTriggered.len = _aVisible.len = 0;
				_hsOld.Clear();
				_hsSeenActivating.Clear();
				_winPropCache.Clear();
			}
			
			_allEvents = _laterEvents | TWLater.Active | TWLater.Name;
			if (_tVisible != null) _allEvents |= TWLater.Visible | TWLater.Uncloaked;
			_usesVisibleArray = 0 != (_allEvents & (TWLater.Visible | TWLater.Invisible));
			
			var ah = new EEvent[5];
			ah[0] = EEvent.SYSTEM_FOREGROUND;
			if (osVersion.minWin8) {
				if (0 != (_allEvents & TWLater.Uncloaked)) ah[1] = EEvent.OBJECT_UNCLOAKED;
				if (0 != (_allEvents & TWLater.Cloaked)) ah[2] = EEvent.OBJECT_CLOAKED;
			}
			if (0 != (_allEvents & TWLater.Minimized)) ah[3] = EEvent.SYSTEM_MINIMIZESTART;
			if (0 != (_allEvents & TWLater.Unminimized)) ah[4] = EEvent.SYSTEM_MINIMIZEEND;
			//if(0 != (_allEvents & TWLater.MoveSizeStart)) ah[5] = EEvent.SYSTEM_MOVESIZESTART;
			//if(0 != (_allEvents & TWLater.MoveSizeEnd)) ah[6] = EEvent.SYSTEM_MOVESIZEEND;
			_hooks = new WinEventHook(ah, _HookProc);
			_hookEventQueue = new Queue<(EEvent, int)>();
			
			_triggers.WinTimerPeriod_ = 250;
			
			Api.IVirtualDesktopManager dm = null;
			Api.EnumWindows((w, param) => {
				if (w.IsVisible) {
					if (_usesVisibleArray) _aVisible.Add(w);
					//skip empty winstore hosts that later probably will be used as new windows. Speed: ~100 mcs, first time ~10 ms.
					if (osVersion.minWin10 && w.HasExStyle(WSE.NOREDIRECTIONBITMAP) && w.IsCloaked && w.ClassNameIs("ApplicationFrameWindow")) {
						//is it a window in an inactive virtual desktop? In both cases it does not have a child Windows.UI.Core.CoreWindow.
						dm ??= new Api.VirtualDesktopManager() as Api.IVirtualDesktopManager;
						if (0 == dm.GetWindowDesktopId(w.Get.RootOwnerOrThis(), out var guid) && guid == default) {
							//print.it(w);
							return 1;
						}
					}
				}
				_hsOld.Add(w);
				return 1;
			});
			Api.ReleaseComObject(dm);
			
			_wActive = default; _nameActive = null;
			
			//run trigers that have flag TWFlags.RunAtStartup
			for (int i = 0; i < _aVisible.len; i++) _Proc(TWLater.Visible, _aVisible.a[i], _ProcCaller.Startup);
			var wa = wnd.active;
			if (!wa.Is0) _Proc(TWLater.Active, wa, _ProcCaller.Startup);
		} else {
			_hooks?.Dispose();
			_hooks = null;
			_hookEventQueue = null;
		}
	}
	
	WinEventHook _hooks;
	Queue<(EEvent, int)> _hookEventQueue;
	WFCache _winPropCache;
	
	struct _TriggeredData {
		public object triggered; //WindowTrigger or List<WindowTrigger>
		public string name; //for Name triggers
	}
	
	_WndArray _aTriggered, _aVisible, _aVisibleOld;
	_TriggeredData[] _aTriggeredData;
	HashSet<wnd> _hs1, _hs2; //to find added and removed visible windows
	HashSet<wnd> _hsOld, _hsSeenActivating;
	wnd _wActive;
	string _nameActive;
	int _timerCounter10;
	
	/// <summary>
	/// Called from the message loop every 250 or less ms.
	/// </summary>
	internal unsafe void Timer_() {
		//bool print = !keys.isNumLock;
		//if(print) print.it(perf.ms % 10000);
		
		int period = _triggers.WinTimerPeriod_;
		if (period < 250) _triggers.WinTimerPeriod_ = Math.Min(period += period / 10 + 1, 250);
		
		//bool verbose = !keys.isNumLock;
		//if(keys.isNumLock) return;
		//perf.first();
		//var a = wnd.getwnd.allWindows(true);
		
		//wnd.getwnd.allWindows(ref _listVisible, true);
		
		//Array.Sort(a);
		
		//using(var a=wnd.Internal_.EnumWindows2(wnd.Internal_.EnumAPI.EnumWindows, true)) {
		
		//}
		
		//if(_aVisibleOld != null) {
		//	//var added = a.Except(_aVisibleOld);
		//	//var removed = _aVisibleOld.Except(a);
		//	//int n1 = added.Count(), n2 = removed.Count();
		
		
		
		//	//if(n1 + n2 > 0) print.it(n1, n2);
		//}
		//_aVisibleOld = a;
		//Debug_.MemoryPrint_();
		
		//bool needEW = false;
		//if(Visible.HasTriggers) needEW = true;
		//else if(Active.HasTriggers) { if(++_timerCounterActiveEW >= 20) { _timerCounterActiveEW = 0; needEW = true; } }
		
		if (_usesVisibleArray) {
			
			//print.it(perf.ms % 10000);
			
			var t1 = _aVisibleOld; _aVisibleOld = _aVisible; _aVisible = t1;
			_aVisible.len = 0;
			Api.EnumWindows(_enumWinProc);
			//perf.next();
			_VisibleAddedRemoved();
			
			//perf.nw();
			//speed with  3 main windows: 200, +IsVisible 270, +IsCloaked 450, +Name-IsCloaked 444
			//speed with 20 main windows (79 visible, 541 total): 320, +IsVisible 430 (CPU 0.05). With 480 CPU 0.06, sometimes 0.05.
			//print.it(n);
			//print.it(_listVisible.Count);
		}
		
		var a = _aTriggered.a;
		for (int i = 0; i < _aTriggered.len; i++) {
			if (!Api.IsWindow(a[i])) {
				_ProcLater(TWLater.Destroyed, a[i], i);
				int last = --_aTriggered.len;
				a[i] = a[last];
				_aTriggeredData[i] = _aTriggeredData[last];
				_aTriggeredData[last] = default;
			}
		}
		
		if (++_timerCounter10 >= 10) { //every 2.5 s
			_timerCounter10 = 0;
			_hsOld.RemoveWhere(o => !Api.IsWindow(o));
			_hsSeenActivating.RemoveWhere(o => !Api.IsWindow(o));
			_winPropCache.Clear();
		}
		
		var w = wnd.active;
		if (w.Is0) {
			if (!_wActive.Is0) _ProcLater(TWLater.Inactive, _wActive);
			_wActive = default; _nameActive = null;
		} else if (w != _wActive) {
			_Proc(TWLater.Active, w);
		} else {
			var name = w.NameTL_;
			if (name != null && name != _nameActive) {
				_nameActive = name;
				_Proc(TWLater.Name, w, name: name);
			}
		}
	}
	
	/// <summary>
	/// Callback of <c>EnumWindows</c> used by <c>Timer_</c> to get visible windows.
	/// </summary>
	Api.WNDENUMPROC _enumWinProc;
	unsafe int _EnumWinProc(wnd w, void* _) {
		if (w.IsVisible) _aVisible.Add(w);
		return 1;
	}
	
	/// <summary>
	/// Called by <c>Timer_</c> when it swaps <c>_aVisible</c> with <c>_aVisibleOld</c> and calls <c>EnumWindows</c> to populate <c>_aVisible</c> with visible windows.
	/// Finds what windows became visible or invisible and runs <c>Visible</c>/<c>Invisible</c> triggers for them.
	/// </summary>
	void _VisibleAddedRemoved() {
		//perf.first();
		wnd[] aNew = _aVisible.a, aOld = _aVisibleOld.a;
		int nNew = _aVisible.len, nOld = _aVisibleOld.len;
		int to = Math.Min(nOld, nNew), diffFrom;
		for (diffFrom = 0; diffFrom < to; diffFrom++) if (aNew[diffFrom] != aOld[diffFrom]) break;
		if (nNew == nOld && diffFrom == nNew) return;
		int diffTo1 = nOld, diffTo2 = nNew;
		while (diffTo1 > 0 && diffTo2 > 0) if (aNew[--diffTo2] != aOld[--diffTo1]) { diffTo1++; diffTo2++; break; }
		//print.it(diffFrom, diffTo1, diffTo2, Math.Max(diffTo1 - diffFrom, diffTo2 - diffFrom));
		int n1 = diffTo1 - diffFrom, n2 = diffTo2 - diffFrom;
		//print.it($"from={diffFrom} to1={diffTo1} to2={diffTo2}    n1={n1} n2={n2}  n1*n2={n1*n2}");
		if (n1 == 0) { //only added
			if (0 != (_allEvents & TWLater.Visible)) {
				for (int i = diffFrom; i < diffTo2; i++) _Added(i);
			}
		} else if (n2 == 0) { //only removed
			if (0 != (_allEvents & TWLater.Invisible)) {
				for (int i = diffFrom; i < diffTo1; i++) _Removed(i);
			}
		} else { //reordered or/and added/removed
			//print.it($"n1={n1} n2={n2}  n1*n2={n1 * n2}");
			//perf.next();
			//TODO3: optimize. Now slow when large array reordered. Eg divide the changed range into two.
			//n1 = n2 = 0;
			if (0 != (_allEvents & TWLater.Invisible)) {
				if (_hs2 == null) _hs2 = new HashSet<wnd>(500); else _hs2.Clear();
				for (int i = diffFrom; i < diffTo2; i++) _hs2.Add(aNew[i]);
				for (int i = diffFrom; i < diffTo1; i++) if (!_hs2.Remove(aOld[i])) _Removed(i);
			}
			if (0 != (_allEvents & TWLater.Visible)) {
				if (_hs1 == null) _hs1 = new HashSet<wnd>(500); else _hs1.Clear();
				for (int i = diffFrom; i < diffTo1; i++) _hs1.Add(aOld[i]);
				for (int i = diffFrom; i < diffTo2; i++) if (!_hs1.Remove(aNew[i])) _Added(i);
			}
			//perf.nw();
		}
		//if(n1 + n2 > 0) print.it($"<><bc yellow>added {n2}, removed {n1}<>");
		
		void _Added(int i) {
			//n2++; //print.it("added", aNew[i]);
			_Proc(TWLater.Visible, aNew[i]);
		}
		
		void _Removed(int i) {
			//n1++; //print.it("removed", aOld[i]);
			_ProcLater(TWLater.Invisible, aOld[i]);
		}
	}
	
	/// <summary>
	/// <c>WinEventHook</c> hook procedure.
	/// </summary>
	/// <param name="k"></param>
	void _HookProc(HookData.WinEvent k) {
		//if(!keys.isNumLock) print.it(k.event_, k.idObject, k.idChild, k.w);
		
		if (k.idObject != EObjid.WINDOW) return;
		if (k.idChild != 0 || k.w.Is0) return;
		
		var event_ = k.event_;
		var w = k.w;
		
		if (w.IsChild) {
			//if(event_ == EEvent.OBJECT_UNCLOAKED) { } //rejected: wait for winstore app host child window
			return;
		}
		
		if (_inProc) {
			_hookEventQueue.Enqueue((event_, (int)w));
			//print.it(_hookEventQueue.Count);
			Debug_.PrintIf(_hookEventQueue.Count > 4, "_hookEventQueue.Count=" + _hookEventQueue.Count);
			return;
		}
		_inProc = true;
		try {
			//wait.doEvents(300); //test queue
			//perf.cpu();
			for (; ; ) {
				TWLater e = 0;
				switch (event_) {
				case EEvent.SYSTEM_FOREGROUND:
					//Debug_.PrintIf(!w.IsActive, $"{perf.ms % 10000}, SYSTEM_FOREGROUND but not active: {w}"); //it is normal. The window either will be active soon (and timer will catch it), or will not be activated (eg prevented by Windows, hooks, etc), or another window became active.
					if (w != _wActive && w.IsActive) e = TWLater.Active;
					break;
				case EEvent.OBJECT_UNCLOAKED: e = TWLater.Uncloaked; break;
				case EEvent.OBJECT_CLOAKED: e = TWLater.Cloaked; break;
				case EEvent.SYSTEM_MINIMIZESTART: e = TWLater.Minimized; break;
				case EEvent.SYSTEM_MINIMIZEEND: e = TWLater.Unminimized; break;
					//case EEvent.SYSTEM_MOVESIZESTART: e = TWLater.MoveSizeStart; break;
					//case EEvent.SYSTEM_MOVESIZEEND: e = TWLater.MoveSizeEnd; break;
				}
				
				if (e != 0) _Proc(e, w, _ProcCaller.Hook);
				
				//Normal timer period is 255. It is optimized for quite small CPU usage and quite good response time.
				//To improve response time, we temporarily set smaller period on SYSTEM_FOREGROUND. Need it when the window is not active too.
				//If activating a new window first time, set period = 15, to quickly catch Visible and Name events.
				//Else set period = 105, for Name events after closing an "Open File" dialog (then usually its owner becomes active and then changes name).
				if (event_ == EEvent.SYSTEM_FOREGROUND) {
					bool fast = _hsSeenActivating.Add(w) && !_hsOld.Contains(w);
					//print.it("fast timer", fast);
					_triggers.WinTimerPeriod_ = fast ? 1 : 100;
				}
				
				if (_hookEventQueue.Count == 0) break;
				var q = _hookEventQueue.Dequeue();
				event_ = q.Item1;
				w = (wnd)q.Item2;
			}
			_inProc = false;
		}
		finally {
			if (_inProc) { _inProc = false; _hookEventQueue.Clear(); } //exception. Unlikely, because we handle script exceptions, except thread abort.
		}
	}
	bool _inProc;
	
	enum _ProcCaller { Timer, Hook, Run, Startup }
	
	/// <summary>
	/// Processes events for main triggers (active, visible) and most "later" triggers.
	/// Called from hook (<c>_HookProc</c>), timer (<c>Timer_</c>), at startup (<c>StartStop</c>) and <c>SimulateActiveNew</c>/<c>SimulateVisibleNew</c>.
	/// </summary>
	void _Proc(TWLater e, wnd w, _ProcCaller caller = _ProcCaller.Timer, string name = null) {
		//e can be:
		//Used for main triggers (Active, Visible) and other triggers:
		//	Active - from SYSTEM_FOREGROUND hook or from timer. Now the window is active and not 0.
		//	Name - from timer, and only when the window is active.
		//	Visible - from timer.
		//	Uncloaked - from OBJECT_UNCLOAKED hook.
		//Used only for other triggers:
		//	Cloaked - from OBJECT_CLOAKED hook.
		//	Minimized from SYSTEM_MINIMIZESTART hook.
		//	Unminimized from SYSTEM_MINIMIZEEND hook.
		//	rejected: MoveSizeStart, MoveSizeEnd.
		Debug.Assert(e == TWLater.Active || e == TWLater.Name || e == TWLater.Visible || e == TWLater.Uncloaked || e == TWLater.Cloaked || e == TWLater.Minimized || e == TWLater.Unminimized/* || e == TWLater.MoveSizeStart || e == TWLater.MoveSizeEnd*/);
		
		bool callerHT = caller == _ProcCaller.Hook || caller == _ProcCaller.Timer;
		
		//Ignore Active if invisible. Triggering while invisible creates more problems than is useful. The timer will call us later.
		//	It makes the trigger slower in many cases. Usually the speed is important when closing unwanted messageboxes etc.
		//	If closed while invisible, the user usually never sees the window. It seems like it would be better, but can create problems:
		//	1. If the trigger uses 'contains', in some windows we cannot find the object because it is still invisible etc; example - TaskDialog windows.
		//	2. If the trigger is not perfectly specified and its action closes wrong windows, the user does not know what is going on.
		//	3. It temporarily deactivates the current window anyway, and often the user is unaware about it.
		if (e == TWLater.Active && callerHT && !w.IsVisibleAndNotCloaked) return;
		//if(e == TWLater.Active && callerHT) { if(!w.IsVisibleAndNotCloaked) { _perf.First(); return; } else if(caller== _ProcCaller.Timer) _perf.NW('A'); }
		
		int iTriggered = _aTriggered.Find(w);
		
		bool detectedVisibleNow = e != TWLater.Visible && _usesVisibleArray && callerHT && w.IsVisible && _aVisible.Find(w) < 0;
		if (detectedVisibleNow) {
			_aVisible.Add(w);
			_ProcLater(TWLater.Visible, w, iTriggered);
		}
		
		bool runActive = false;
		if (e == TWLater.Active) {
			name = w.NameTL_;
			if (callerHT) {
				_ProcLater(TWLater.Name, w, iTriggered, name); //maybe name changed while inactive
				if (!_wActive.Is0) _ProcLater(TWLater.Inactive, _wActive);
			}
			_wActive = w; _nameActive = name;
			if (callerHT) _ProcLater(e, w, iTriggered);
			runActive = _tActive != null;
		} else {
			if (callerHT) _ProcLater(e, w, iTriggered, name);
			switch (e) {
			case TWLater.Name: //from timer, when active window name changed
				runActive = _tActive != null;
				break;
			case TWLater.Visible:
			case TWLater.Uncloaked:
				name = w.NameTL_;
				break;
			default: return;
			}
		}
		
		bool runVisible = _tVisible != null && w.IsVisibleAndNotCloaked;
		if (!(runVisible | runActive)) return;
		
		bool oldWindow = callerHT && _hsOld.Contains(w);
		
		if (_log && callerHT && (_logSkip == null || !_logSkip(w))) {
			if (detectedVisibleNow) _LogEvent(TWLater.Visible, w, caller, oldWindow);
			_LogEvent(e, w, caller, oldWindow);
		}
		
		object triggered = iTriggered >= 0 ? _aTriggeredData[iTriggered].triggered : null, triggeredOld = triggered;
		
		_winPropCache.Begin(w); //info: don't need to call Clear now. Timer calls it every 2.5 s.
		_winPropCache.Name = name;
		
		//perf.first();
		WindowTriggerArgs args = null;
		
		//print.it(runVisible,runActive,w.IsActive, oldWindow);
		
		if (runVisible) _Do(true, runActive && !detectedVisibleNow);
		if (runActive && w.IsActive) _Do(false, e != TWLater.Active);
		
		void _Do(bool visible, bool secondaryEvent) {
			ActionTrigger last = visible ? _tVisible : _tActive, v = last;
			if (last == null) return;
			
			do {
				v = v.next;
				if (v.DisabledThisOrAll) continue;
				var t = v as WindowTrigger;
				
				if (caller == _ProcCaller.Startup && 0 == (t.Flags & TWFlags.RunAtStartup)) continue;
				if (oldWindow && (t.IsNew || secondaryEvent)) continue;
				if (triggered != null && (!t.IsAlways || secondaryEvent)) {
					switch (triggered) {
					case WindowTrigger wt1: if (wt1 == t) continue; break;
					case List<WindowTrigger> awt1: if (awt1.Contains(t)) continue; break;
					}
				}
				
				try {
					if (!t.Finder.IsMatch(w, _winPropCache)) continue;
					
					//rejected: if 'contains' is image and it does not match, wait several seconds until it matches.
					//	Now such triggers sometimes don't work because need more time to show the image.
					//	Rare and too difficult. Cannot wait now. Would need to use timer or threadpool.
				}
				catch (Exception ex) {
					print.it(ex);
					continue;
				}
				
				if (args == null) args = new WindowTriggerArgs(t, w, 0); else args.Trigger = t;
				
				if (!t.CallFunc_(args)) continue; //info: handles exceptions
				
				switch (triggered) {
				case null: triggered = t; break;
				case WindowTrigger wt1: if (wt1 != t) triggered = new List<WindowTrigger> { wt1, t }; break;
				case List<WindowTrigger> awt1: if (!awt1.Contains(t)) awt1.Add(t); break;
				}
				
				//if(!visible && !w.IsActive) break; //no
				
				if (_log) print.it($"<><c red>{t.TypeString}<>");
				
				_triggers.RunAction_(t, args);
			} while (v != last);
			//perf.nw(); //speed ms/triggers when cold CPU: ~1/1000, 10/10000, 50/100000, 130/1000000
		}
		
		if (triggered != triggeredOld) {
			if (iTriggered < 0) {
				iTriggered = _aTriggered.len;
				_aTriggered.Add(w);
				if (iTriggered == _aTriggeredData.Length) Array.Resize(ref _aTriggeredData, iTriggered * 2);
				_aTriggeredData[iTriggered].name = name; //later managed by _Proc2
			}
			_aTriggeredData[iTriggered].triggered = triggered;
		}
	}
	
	/// <summary>
	/// Called to process "later" events from <c>_Proc</c> and timer.
	/// <i>iTriggered</i> is <i>w</i> index in <c>_aTriggered</c>, or -1 if not found, or -2 (default) to let this func find.
	/// </summary>
	void _ProcLater(TWLater e, wnd w, int iTriggered = -2, string name = null) {
		if (0 == (_laterEvents & e)) return;
		if (iTriggered < -1) iTriggered = _aTriggered.Find(w);
		if (iTriggered < 0) return;
		
		if (e == TWLater.Name) { //called in 2 cases: 1. From timer, when name changed. 2. From _Proc on Active event (hook or timer).
			if (name == null || _aTriggeredData[iTriggered].name == name) return;
			_aTriggeredData[iTriggered].name = name;
		}
		
		if (_log) print.it($"\t{perf.ms % 10000,4}, {e,-11}, {w}");
		
		WindowTriggerArgs args = null;
		var triggered = _aTriggeredData[iTriggered].triggered;
		var a = triggered as List<WindowTrigger>;
		int n = a?.Count ?? 1;
		for (int i = 0; i < n; i++) {
			var t = a?[i] ?? (triggered as WindowTrigger);
			if (0 == (t.Later & e)) continue;
			//if(t.DisabledThisOrAll) continue; //no
			if (args == null) args = new WindowTriggerArgs(t, w, e); else args.Trigger = t;
			if (0 != (t.Flags & TWFlags.LaterCallFunc)) {
				if (!t.CallFunc_(args)) continue;
			}
			
			if (_log) print.it($"<><c red>\t{e}<>");
			
			_triggers.RunAction_(t, args);
		}
	}
	
	/// <summary>
	/// Simulates event "activated new window" as if the specified window is that window.
	/// </summary>
	/// <exception cref="InvalidOperationException">Called before or after <see cref="ActionTriggers.Run"/>.</exception>
	/// <remarks>
	/// This function usually is used to run <c>ActiveNew</c> triggers for a window created before calling <see cref="ActionTriggers.Run"/>. Here "run triggers" means "compare window properties etc with those specified in triggers and run actions of triggers that match". Normally such triggers don't run because the window is considered old. This function runs triggers as it was a new window. Triggers like <c>ActiveNew</c> and <c>ActiveOnce</c> will run once, as usually.
	/// This function must be called while the main triggers thread is in <see cref="ActionTriggers.Run"/>, for example from another trigger action. It is asynchronous (does not wait).
	/// If called from a trigger action (hotkey etc), make sure the window trigger action runs in another thread or can be queued. Else both actions cannot run simultaneously. See example.
	/// </remarks>
	/// <example>
	/// Note: the <c>Triggers</c> in examples is a field or property of type <see cref="ActionTriggers"/>.
	/// <code><![CDATA[
	/// Triggers.Options.ThreadNew(true);
	/// Triggers.Window[TWEvent.ActiveNew, "* Notepad"] = o => o.Window.Resize(500, 200);
	/// Triggers.Hotkey["Ctrl+T"] = o => Triggers.Window.SimulateActiveNew(wnd.active);
	/// ]]></code>
	/// </example>
	public void SimulateActiveNew(wnd w) => _SimulateNew(TWLater.Active, w);
	
	/// <summary>
	/// Simulates event "visible new window" as if the specified window is that window.
	/// Similar to <see cref="SimulateActiveNew"/>.
	/// </summary>
	/// <param name="w"></param>
	/// <exception cref="InvalidOperationException">Called before or after <see cref="ActionTriggers.Run"/>.</exception>
	/// <remarks>
	/// Cannot be called before or after <see cref="ActionTriggers.Run"/>.
	/// </remarks>
	public void SimulateVisibleNew(wnd w) => _SimulateNew(TWLater.Visible, w);
	
	void _SimulateNew(TWLater e, wnd w) {
		_triggers.ThrowIfNotRunning_();
		_triggers.SendMsg_(false, () => { if (w.IsAlive) _Proc(e, w, _ProcCaller.Run); });
	}
	
	bool _log;
	Func<wnd, bool> _logSkip;
	
	/// <summary>
	/// Starts or stops to log (write in output) window events that can help to create or debug window triggers.
	/// </summary>
	/// <param name="on">Start (<c>true</c>) or stop.</param>
	/// <param name="skip">An optional callback function that can be used to reduce noise, eg skip tooltip windows. Return <c>true</c> to skip that window.</param>
	/// <remarks>
	/// For primary trigger events is logged this info:
	/// <ol>
	/// <li>Time milliseconds. Shows only the remainder of dividing by 10 seconds, therefore it starts from 0 again when reached 9999 (9 seconds and 999 milliseconds).</li>
	/// <li>Event (see <see cref="TWLater"/>).</li>
	/// <li>Letters for window state etc:
	/// <ul>
	/// <li><c>A</c> - the window is active.</li>
	/// <li><c>H</c> - the window is invisible (!<see cref="wnd.IsVisible"/>).</li>
	/// <li><c>C</c> - the window is cloaked (<see cref="wnd.IsCloaked"/>).</li>
	/// <li><c>O</c> - the window is considered old, ie created before calling <see cref="ActionTriggers.Run"/>.</li>
	/// <li><c>T</c> - the even has been detected using a timer, which means slower response time. Else detected using a hook.</li>
	/// </ul>
	/// </li>
	/// <li>Window (handle, class, name, program, rectangle).</li>
	/// </ol>
	/// 
	/// Colors are used for window event types used for primary triggers: blue if activated; green if became visible; yellow if name changed.
	/// For "later" events is logged time, event and window. Black, tab-indented. Only events that are specified in triggers.
	/// When a trigger is activated, the event type is red.
	/// </remarks>
	/// <example>
	/// <code><![CDATA[
	/// Triggers.Window.LogEvents(true, o => 0 != o.ClassNameIs("*tooltip*", "SysShadow", "#32774", "TaskList*"));
	/// ]]></code>
	/// </example>
	public void LogEvents(bool on, Func<wnd, bool> skip = null) {
		_log = on;
		_logSkip = skip;
	}
	
	/// <summary>
	/// Called by <c>_Proc</c>.
	/// </summary>
	void _LogEvent(TWLater e, wnd w, _ProcCaller caller, bool oldWindow) {
		string col = "0";
		switch (e) {
		case TWLater.Active: col = "0x0000ff"; break;
		case TWLater.Visible: case TWLater.Uncloaked: col = "0x00c000"; break;
		case TWLater.Name: col = "0xC0C000"; break;
		}
		var A = w.IsActive ? "A" : " ";
		var H = w.IsVisible ? " " : "H";
		var C = w.IsCloaked ? "C" : " ";
		var O = oldWindow ? "O" : " ";
		var T = caller == _ProcCaller.Timer ? "T" : " ";
		print.it($"<><c {col}>{perf.ms % 10000,4}, {e,-11}, {A}{H}{C}{O}{T}, {w}</c>");
	}
	
	/// <summary>
	/// For <c>_aTriggered</c>, <c>_aVisible</c> and <c>_aVisibleOld</c> we use resizable array, not <c>List</c>.
	/// We access elements by index in time-critical code. With <c>List</c> it is much slower.
	/// </summary>
	struct _WndArray {
		public wnd[] a;
		public int len;
		
		public void Add(wnd w) {
			if (len == a.Length) Array.Resize(ref a, len * 2);
			a[len++] = w;
		}
		
		public unsafe int Find(wnd w) {
			fixed (wnd* p = a) {
				for (int i = 0, n = len; i < n; i++) if (p[i] == w) return i;
			}
			return -1;
		}
	}
	
	/// <summary>
	/// Used by <c>foreach</c> to enumerate added triggers.
	/// </summary>
	public IEnumerator<WindowTrigger> GetEnumerator() {
		ActionTrigger last, v;
		if (_tActive != null) {
			last = v = _tActive;
			do {
				v = v.next;
				var x = v as WindowTrigger;
				yield return x;
			} while (v != last);
		}
		if (_tVisible != null) {
			last = v = _tVisible;
			do {
				v = v.next;
				var x = v as WindowTrigger;
				yield return x;
			} while (v != last);
		}
	}
	
	IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
}

/// <summary>
/// Arguments for actions of window triggers.
/// </summary>
public class WindowTriggerArgs : TriggerArgs {
	/// <summary>
	/// The trigger.
	/// </summary>
	public WindowTrigger Trigger { get; internal set; }
	
	///
	[EditorBrowsable(EditorBrowsableState.Never)]
	public override ActionTrigger TriggerBase => Trigger;
	
	/// <summary>
	/// The window.
	/// </summary>
	public wnd Window { get; }
	
	/// <summary>
	/// The "later" event, or 0 if it is the primary trigger (<c>ActiveNew</c> etc). See example.
	/// </summary>
	/// <example>
	/// Note: the <c>Triggers</c> in examples is a field or property like <c>readonly ActionTriggers Triggers = new();</c>.
	/// <code><![CDATA[
	/// Triggers.Window[TWEvent.ActiveOnce, "*- Notepad", later: TWLater.Active | TWLater.Inactive] = o => print.it(o.Later, o.Window);
	/// Triggers.Run();
	/// ]]></code>
	/// </example>
	public TWLater Later { get; }
	
	///
	public WindowTriggerArgs(WindowTrigger trigger, wnd w, TWLater later) {
		Trigger = trigger;
		Window = w;
		Later = later;
	}
	
	///
	public override string ToString() => "Trigger: " + Trigger;
	
	/// <summary>
	/// Shows or hides a window-attached toolbar depending on window name.
	/// Use in window trigger action, like in examples.
	/// </summary>
	/// <param name="tbFunc">Toolbar function. Let it create a window-attached toolbar and returns the <see cref="toolbar"/> object.</param>
	/// <param name="windowName">Window name when the toolbar should be visible. String format: [wildcard expression](xref:wildcard_expression).</param>
	/// <exception cref="ArgumentException">Invalid wildcard expression (<c>"**options "</c> or regular expression).</exception>
	/// <remarks>
	/// The trigger must have argument <c>, later: TWLater.Name</c> (see <see cref="TWLater"/>) and match the window with any name.
	/// </remarks>
	/// <example>
	/// Show toolbar <c>Toolbar_Chrome1</c> on a Chrome window when window name starts with <c>"NuGet"</c>.
	/// <code><![CDATA[
	/// Triggers.Window[TWEvent.ActiveOnce, "*Google Chrome", "Chrome_WidgetWin_1", later: TWLater.Name] =
	/// 	ta => ta.ShowToolbarWhenWindowName(Toolbar_Chrome1, "NuGet*");
	/// ]]></code>
	/// Toolbar <c>Toolbar_Chrome1</c> for the above example.
	/// <code><![CDATA[
	/// toolbar Toolbar_Chrome1(WindowTriggerArgs ta) { var t = new toolbar(); /* add buttons */ t.Show(ta); return t; }
	/// ]]></code>
	/// Show Toolbar_A when window name starts with <c>"A -"</c>, Toolbar_B when <c>"B -"</c>, and Toolbar_C always.
	/// <code><![CDATA[
	/// Triggers.Window[TWEvent.ActiveOnce, "*Google Chrome", "Chrome_WidgetWin_1", later: TWLater.Name] = ta => {
	/// 	ta.ShowToolbarWhenWindowName(Toolbar_A, "A -*");
	/// 	ta.ShowToolbarWhenWindowName(Toolbar_B, "B -*");
	/// 	if (ta.Later == 0) Toolbar_C(ta);
	/// };
	/// ]]></code>
	/// </example>
	public void ShowToolbarWhenWindowName(Func<WindowTriggerArgs, toolbar> tbFunc, [ParamString(PSFormat.Wildex)] string windowName) {
		var wild = new wildex(windowName);
		ShowToolbarWhenWindowName(tbFunc, o => wild.Match(o.Name));
	}
	//rejected: shorter syntax. Limited, eg can't use the same trigger for multiple toolbars. Examples:
	//	Triggers.Window[TWEvent.ActiveOnce, "*Google Chrome", "Chrome_WidgetWin_1", whenName: "NuGet*"] = Toolbar_Chrome1;
	//	Triggers.Window.Toolbar(Toolbar_Chrome1, "*Google Chrome", "Chrome_WidgetWin_1", whenName: "NuGet*");
	
	/// <summary>
	/// Shows or hides a window-attached toolbar depending on window name.
	/// Use in window trigger action, like in examples.
	/// </summary>
	/// <param name="tbFunc">Toolbar function. Let it create a window-attached toolbar and returns the <see cref="toolbar"/> object.</param>
	/// <param name="windowName">Callback function that returns <c>true</c> if the toolbar should be visible.</param>
	/// <example>
	/// Show toolbar <c>Toolbar_Chrome2</c> on a Chrome window when web page URL starts with <c>"https://www.youtube.com/"</c>.
	/// <code><![CDATA[
	/// Triggers.Window[TWEvent.ActiveOnce, "*Google Chrome", "Chrome_WidgetWin_1", later: TWLater.Name] = ta => ta.ShowToolbarWhenWindowName(Toolbar_Chrome2, w => {
	/// 	var e = w.Elm["web:DOCUMENT"].Find(-1);
	/// 	return e != null && e.Value.Starts("https://www.youtube.com/");
	/// });
	/// ]]></code>
	/// </example>
	public void ShowToolbarWhenWindowName(Func<WindowTriggerArgs, toolbar> tbFunc, Func<wnd, bool> windowName) {
		var mi = tbFunc.Method;
		(t_mt ??= new()).TryGetValue(mi, out var v);
		if (!windowName(Window)) { v?.Close(); return; }
		if (v != null) return;
		v = tbFunc(this);
		if (v != null) {
			t_mt[mi] = v;
			v.Closed += () => { t_mt.Remove(mi); };
		} else {
			t_mt.Remove(mi);
		}
	}
	
	[ThreadStatic] static Dictionary<MethodInfo, toolbar> t_mt;
}


================================================
FILE: Au/UI objects/CaptureScreen.cs
================================================
using System.Drawing;
using System.Drawing.Imaging;

namespace Au.More {
	/// <summary>
	/// Contains functions and tools to capture image, color, window, rectangle or point from screen.
	/// </summary>
	public static class CaptureScreen {
		#region capture image

		/// <summary>
		/// Creates image from a rectangle of screen pixels.
		/// </summary>
		/// <param name="r">Rectangle in screen.</param>
		/// <exception cref="ArgumentException">Empty rectangle.</exception>
		/// <exception cref="AuException">Failed. Probably there is not enough memory for bitmap of this size (<c>width*height*4</c> bytes).</exception>
		/// <example>
		/// <code><![CDATA[
		/// var file = folders.Temp + "notepad.png";
		/// wnd w = wnd.find("* Notepad");
		/// w.GetRect(out var r, true);
		/// using(var b = CaptureScreen.Image(r)) { b.Save(file); }
		/// run.it(file);
		/// ]]></code>
		/// </example>
		public static Bitmap Image(RECT r) {
			using var c = new CaptureScreenImage();
			c.Capture(r);
			return c.ToBitmap();
		}

		/// <summary>
		/// Creates image from a rectangle of window client area pixels.
		/// </summary>
		/// <param name="w">Window or control.</param>
		/// <param name="r">Rectangle in <i>w</i> client area coordinates. If <c>null</c>, uses <c>w.ClientRect</c>.</param>
		/// <exception cref="AuWndException">Invalid <i>w</i>.</exception>
		/// <exception cref="ArgumentException">The rectangle is empty or does not intersect with the window's client area.</exception>
		/// <exception cref="AuException">Failed. For example there is not enough memory for bitmap of this size (<c>width*height*4</c> bytes).</exception>
		/// <remarks>
		/// If <i>flags</i> contains <c>WindowDC</c> (default) or <c>PrintWindow</c>:
		/// - If the window is partially or completely transparent, captures its non-transparent view.
		/// - If the window is DPI-scaled, captures its non-scaled view. However <i>r</i> must contain scaled coordinates.
		/// </remarks>
		public static Bitmap Image(wnd w, RECT? r = null, CIFlags flags = CIFlags.WindowDC) {
			using var c = new CaptureScreenImage();
			if (!c.Capture(w, r, flags)) return null;
			return c.ToBitmap();
		}

		/// <summary>
		/// Gets pixel colors from a rectangle in screen.
		/// </summary>
		/// <returns>2-dimensional array <c>[row, column]</c> containing pixel colors in <c>0xAARRGGBB</c> format. Alpha <c>0xFF</c>.</returns>
		/// <param name="r">Rectangle in screen.</param>
		/// <exception cref="ArgumentException">Empty rectangle.</exception>
		/// <exception cref="AuException">Failed. Probably there is not enough memory for bitmap of this size (<c>width*height*4</c> bytes).</exception>
		/// <example>
		/// <code><![CDATA[
		/// print.clear();
		/// var a = CaptureScreen.Pixels(new(100, 100, 4, 10));
		/// for(int i = 0, nRows = a.GetLength(0); i < nRows; i++) print.it(a[i,0], a[i,1], a[i,2], a[i,3]);
		/// ]]></code>
		/// </example>
		public static uint[,] Pixels(RECT r) {
			using var c = new CaptureScreenImage();
			c.Capture(r);
			return c.ToArray2D();
		}

		/// <summary>
		/// Gets pixel colors from a rectangle in window client area.
		/// </summary>
		/// <returns>2-dimensional array <c>[row, column]</c> containing pixel colors in <c>0xAARRGGBB</c> format. Alpha <c>0xFF</c>.</returns>
		/// <inheritdoc cref="Image(wnd, RECT?, CIFlags)"/>
		public static uint[,] Pixels(wnd w, RECT? r = null, CIFlags flags = CIFlags.WindowDC) {
			using var c = new CaptureScreenImage();
			if (!c.Capture(w, r, flags)) return null;
			return c.ToArray2D();
		}

		/// <summary>
		/// Gets color of a screen pixel.
		/// </summary>
		/// <param name="p">x y in screen.</param>
		/// <returns>Pixel color in <c>0xAARRGGBB</c> format. Alpha 0xFF. Returns 0 if fails, eg if x y is not in screen.</returns>
		public static unsafe uint Pixel(POINT p) {
			using var dc = new ScreenDC_();
			uint R = Api.GetPixel(dc, p.x, p.y);
			if (R == 0xFFFFFFFF) return 0;
			return ColorInt.SwapRB(R) | 0xFF000000;
		}

		/// <summary>
		/// Gets color of a window pixel.
		/// </summary>
		/// <param name="p">x y in <i>w</i> client area.</param>
		/// <returns>Pixel color in <c>0xAARRGGBB</c> format. Alpha 0xFF.</returns>
		/// <inheritdoc cref="Image(wnd, RECT?, CIFlags)"/>
		public static unsafe uint Pixel(wnd w, POINT p, CIFlags flags = CIFlags.WindowDC) {
			using var c = new CaptureScreenImage();
			if (!c.Capture(w, new(p.x, p.y, 1, 1), flags)) return 0;
			return c.Pixels[0];
		}

		#endregion

		#region capture image UI

		/// <summary>
		/// UI for capturing an image, color or rectangle on screen.
		/// </summary>
		/// <returns><c>false</c> if canceled.</returns>
		/// <param name="result">Receives results.</param>
		/// <param name="flags"></param>
		/// <param name="owner">A window to minimize temporarily.</param>
		/// <param name="wCapture">A window to capture immediately instead of waiting for <c>F3</c> key. Used only with a "get window pixels" flag.</param>
		/// <remarks>
		/// Gets all screen pixels and shows in a full-screen topmost window, where the user can select an area.
		/// 
		/// Cannot capture windows that are always on top of normal topmost windows: 1. Start menu. 2. Topmost windows of UAC uiAccess processes (rare).
		/// </remarks>
		public static bool ImageColorRectUI(out CIUResult result, CIUFlags flags = 0, AnyWnd owner = default, wnd wCapture = default) {
			result = default;

			switch (flags & (CIUFlags.Image | CIUFlags.Color | CIUFlags.Rectangle)) {
			case 0 or CIUFlags.Image or CIUFlags.Color or CIUFlags.Rectangle: break;
			default: throw new ArgumentException();
			}

			List<wnd> amw = new();
			try {
				if (!owner.IsEmpty) {
					if (wCapture.Is0) {
						using (new inputBlocker(BIEvents.MouseClicks)) {
							var w = owner.Hwnd.Get.RootOwnerOrThis();
							if (!w.Is0) {
								w.ShowMinimized(1);
								amw.Add(w);

								//also minimize editor etc if need
								for (int i = 0; i < 7; i++) {
									wait.doEvents(10);
									w = wnd.active;
									if (!w.IsOfThisProcess || w.IsMinimized) break;
									w = w.Get.RootOwnerOrThis();
									w.ShowMinimized(1);
									amw.Add(w);
								}
							}

							wait.doEvents(300); //time for animations
						}
					} else {
						var w = owner.Hwnd;
						if (w.IsMinimized) amw.Add(w);
					}
				}

				bool windowPixels = flags.HasAny(CIUFlags.WindowDC | CIUFlags.PrintWindow);
				g1:
				RECT rs = screen.virtualScreen;
				//RECT rs = screen.primary.Rect; //for testing, to see print output in other screen
				Bitmap bs;
				wnd wTL = default;
				RECT rc = default;
				SIZE size = default;
				var avw = windowPixels ? null : wnd.getwnd.allWindows(onlyVisible: true)
					.Where(o => !(o.IsMinimized || o.IsCloaked))
					.Select(o => (w: o, r: o.ClientRectInScreen)).ToArray();

				if (windowPixels) {
					if (!wCapture.Is0) {
						wTL = wCapture;
						wCapture = default;
					} else {
						if (!_WaitForHotkey("Press F3 to select window from mouse pointer. Or Esc.")) return false;
						wTL = wnd.fromMouse(WXYFlags.NeedWindow);
					}
					rc = wTL.ClientRect;
					using var bw = Image(wTL, rc, flags.ToCIFlags_());
					bs = new Bitmap(rs.Width, rs.Height);
					using var g = Graphics.FromImage(bs);
					g.Clear(Color.Gray);
					wTL.MapClientToScreen(ref rc);
					g.DrawImage(bw, rc.left - rs.left, rc.top - rs.top);
					size = bw.Size;
				} else {
					bs = Image(rs);
				}

				var wui = new _ImageUIWindow();
				switch (wui.Show(bs, flags, rs)) {
				case 1: break;
				case 2:
					if (!windowPixels && !_WaitForHotkey("Press F3 when ready for new screenshot. Or Esc.")) return false;
					goto g1;
				default: return false;
				}

				var r = wui.Result;

				//if the window is DPI-scaled, scale r.rect
				if (windowPixels && (size.width != rc.Width || size.height != rc.Height) && Dpi.AwarenessContext.Available) { //Win10+, to match the unscaling code which can't support older OS
					int dpiw = Dpi.OfWindow(wTL), dpis = screen.of(wTL).Dpi;
					var rr = r.rect;
					r.rect = RECT.FromLTRB(
						rc.left + Math2.MulDiv(rr.left - rc.left, dpis, dpiw),
						rc.top + Math2.MulDiv(rr.top - rc.top, dpis, dpiw),
						rc.left + Math2.MulDiv(rr.right - rc.left, dpis, dpiw),
						rc.top + Math2.MulDiv(rr.bottom - rc.top, dpis, dpiw)
						);
					r.dpiScale = (double)dpis / dpiw;
				} else r.dpiScale = 1;

				r.w = _WindowFromRect(r, wTL);

				//if that window is eg a menu, it probably disappeared. We get correct screenshot, but wrong window.
				//	Workaround: try to detect it and set r.possiblyWrongWindow.
				//	Then the 'find image' tool will prompt the user to capture the window with the 'find window' tool.
				if (windowPixels) r.possiblyWrongWindow = r.w.Window != wTL;
				else if (!r.w.Is0) {
					var w1 = avw.FirstOrDefault(o => o.r.Contains(r.rect)).w;
					if (w1 != r.w.Window) r.possiblyWrongWindow = !w1.IsVisible || w1.IsCloaked || w1.IsMinimized;
				}

				result = r;
			}
			finally {
				if (amw.Count > 0) {
					for (int i = amw.Count; --i >= 0;) try { amw[i].ShowNotMinimized(); } catch { }
					amw[0].ActivateL();
				}
				Api.GetKeyState(1); //let OS update key states. Else the API later may not work eg in wndproc on some messages.
			}
			return true;

			static wnd _WindowFromRect(CIUResult r, wnd wTL) {
				//after closing our window, may need several ms until OS sets correct Z order. Until that may get different w1 and w2.
				Thread.Sleep(25);

				wnd w1, w2;
				var r1 = r.rect;
				if (!wTL.Is0 && wTL.MapScreenToClient(ref r1) && wTL.ClientRect.Contains(r1)) {
					w1 = wTL.ChildFromXY((r1.left, r1.top), WXYCFlags.OrThis);
					w2 = (r.image == null) ? w1 : wTL.ChildFromXY((r1.right - 1, r1.bottom - 1), WXYCFlags.OrThis);
				} else {
					w1 = wnd.fromXY((r.rect.left, r.rect.top));
					w2 = (r.image == null) ? w1 : wnd.fromXY((r.rect.right - 1, r.rect.bottom - 1));
				}

				if (w2 != w1 || !_IsInClientArea(w1)) {
					wnd w3 = w1.Window, w4 = w2.Window;
					w1 = (w4 == w3 && _IsInClientArea(w3)) ? w3 : default;
				}
				return w1;

				bool _IsInClientArea(wnd w) => w.GetClientRect(out var rc, true) && rc.Contains(r.rect);
			}

			static bool _WaitForHotkey(string info) {
				using (osdText.showText(info, Timeout.Infinite)) {
					//try { keys.waitForHotkey(0, KKey.F3); }
					//catch(AuException) { dialog.showError("Failed to register hotkey F3"); return false; }

					return KKey.F3 == keys.waitForKeys(0, k => !k.IsUp && k.Key is KKey.F3 or KKey.Escape, block: true);
				}
			}
		}

		class _ImageUIWindow {
			wnd _w;
			Bitmap _img;
			bool _paintedOnce;
			bool _magnMoved;
			bool _capturing;
			CIUFlags _flags;
			MouseCursor _cursor;
			SIZE _textSize;
			int _dpi;
			int _res;

			public CIUResult Result;

			/// <returns>0 <b>Cancel</b>, 1 <b>OK</b>, 2 <b>Retry</b>.</returns>
			public int Show(Bitmap img, CIUFlags flags, RECT r) {
				_img = img;
				_flags = flags;
				//TODO3: cursor almost invisible on my 200% DPI tablet (somehow transparent). Test on true 200% DPI screen.
				_cursor = MouseCursor.Load(ResourceUtil.GetBytes("<Au>resources/red_cross_cursor.cur"), 32);
				_dpi = screen.primary.Dpi;
				_w = WndUtil.CreateWindow(_WndProc, true, WndUtil.WindowClassDWP_, "Au.CaptureScreen", WS.POPUP | WS.VISIBLE, WSE.TOOLWINDOW | WSE.TOPMOST, r.left, r.top, r.Width, r.Height);
				_w.ActivateL();

				try {
					while (Api.GetMessage(out var m) && m.message != Api.WM_APP) {
						switch (m.message) {
						case Api.WM_KEYDOWN when !_capturing:
							switch ((KKey)(int)m.wParam) {
							case KKey.Escape: return 0;
							case KKey.F3: return 2;
							}
							break;
						case Api.WM_RBUTTONUP when m.hwnd == _w:
							switch (popupMenu.showSimple("1 Retry\tF3|2 Cancel\tEsc", owner: _w)) {
							case 1: return 2;
							case 2: return 0;
							}
							break;
						}
						Api.DispatchMessage(m);
					}
				}
				finally {
					var w = _w; _w = default;
					Api.DestroyWindow(w);
				}
				return _res;
			}

			nint _WndProc(wnd w, int msg, nint wParam, nint lParam) {
				//WndUtil.PrintMsg(w, msg, wParam, lParam);

				switch (msg) {
				case Api.WM_NCDESTROY:
					_img.Dispose();
					_cursor?.Dispose();
					if (_w != default) {
						_w = default;
						_w.Post(Api.WM_APP);
					}
					break;
				case Api.WM_SETCURSOR:
					Api.SetCursor(_cursor.Handle);
					return 1;
				case Api.WM_ERASEBKGND:
					return default;
				case Api.WM_PAINT:
					var dc = Api.BeginPaint(w, out var ps);
					_WmPaint(dc);
					Api.EndPaint(w, ps);
					return default;
				case Api.WM_MOUSEMOVE:
					_WmMousemove(Math2.NintToPOINT(lParam));
					break;
				case Api.WM_LBUTTONDOWN:
					_WmLbuttondown(Math2.NintToPOINT(lParam));
					break;
				}

				return Api.DefWindowProc(w, msg, wParam, lParam);
			}

			unsafe void _WmPaint(IntPtr dc) {
#if true
				using var bd = _img.Data(ImageLockMode.ReadOnly);
				var bi = new Api.BITMAPINFO(bd.Width, -bd.Height);
				Api.SetDIBitsToDevice(dc, 0, 0, bd.Width, bd.Height, 0, 0, 0, bd.Height, (void*)bd.Scan0, &bi);
#else //very slow
				using var g = Graphics.FromHdc(dc);
				g.DrawImageUnscaled(_img, 0, 0);
#endif
				_paintedOnce = true;
			}

			void _WmMousemove(POINT pc) {
				if (!_paintedOnce) return;

				//format text to draw below magnifier
				string text;
				using (new StringBuilder_(out var s)) {
					var ic = _flags & (CIUFlags.Image | CIUFlags.Color | CIUFlags.Rectangle);
					if (ic == 0) ic = CIUFlags.Image | CIUFlags.Color;
					bool canColor = ic.Has(CIUFlags.Color);
					if (canColor) {
						var color = _img.GetPixel(pc.x, pc.y).ToArgb() & 0xffffff;
						s.Append("Color  #").Append(color.ToString("X6")).Append('\n');
					}
					if (ic == CIUFlags.Color) {
						s.Append("Click to capture color.\n");
					} else if (ic == CIUFlags.Rectangle) {
						s.Append("Mouse-drag to capture rectangle.\n");
					} else if (!canColor) {
						s.Append("Mouse-drag to capture image.\n");
					} else {
						s.Append("Mouse-drag to capture image,\nor Ctrl+click to capture color.\n");
					}
					s.Append("More:  right-click"); //"  cancel:  key Esc\n  retry:  key F3 ... F3"
					text = s.ToString();
				}

				var font = NativeFont_.RegularCached(_dpi);
				int magnWH = Dpi.Scale(200, _dpi) / 10 * 10; //width and height of the magnified image without borders etc
				if (_textSize == default) using (var tr = new FontDC_(font)) _textSize = tr.MeasureDT(text, TFFlags.NOPREFIX);
				int width = Math.Max(magnWH, _textSize.width) + 2, height = magnWH + 4 + _textSize.height;
				using var mb = new MemoryBitmap(width, height);
				var dc = mb.Hdc;
				using var wdc = new WindowDC_(_w);

				//draw frames and color background. Also erase magnifier, need when near screen edges.
				Api.FillRect(dc, (0, 0, width, height), Api.GetStockObject(4)); //BLACK_BRUSH

				//copy from captured screen image to magnifier image. Magnify 5 times.
				int k = magnWH / 10;
				Api.StretchBlt(dc, 1, 1, magnWH, magnWH, wdc, pc.x - k, pc.y - k, k * 2, k * 2, Api.SRCCOPY);

				//draw red crosshair
				k = magnWH / 2;
				using (var pen = new GdiPen_(0xff)) {
					pen.DrawLine(dc, (k, 1), (k, magnWH + 1));
					pen.DrawLine(dc, (1, k), (magnWH + 1, k));
				}

				//draw text below magnifier
				var rc = new RECT(1, magnWH + 2, _textSize.width, _textSize.height);
				Api.SetTextColor(dc, 0x32CD9A); //Color.YellowGreen
				Api.SetBkMode(dc, 1);
				var oldFont = Api.SelectObject(dc, font);
				Api.DrawText(dc, text, ref rc, TFFlags.NOPREFIX);
				Api.SelectObject(dc, oldFont);

				//set magninifier position far from cursor
				var pm = new POINT(4, 4); _w.MapScreenToClient(ref pm);
				int xMove = magnWH * 3;
				if (_magnMoved) pm.Offset(xMove, 0);
				var rm = new RECT(pm.x, pm.y, width, height); rm.Inflate(magnWH / 2, magnWH / 2);
				if (rm.Contains(pc)) {
					Api.InvalidateRect(_w, (pm.x, pm.y, width, height));
					_magnMoved ^= true;
					pm.Offset(_magnMoved ? xMove : -xMove, 0);
				}

				Api.BitBlt(wdc, pm.x, pm.y, width, height, dc, 0, 0, Api.SRCCOPY);
			}

			void _WmLbuttondown(POINT p0) {
				if (Result != null) return;

				//bool isAnyShape = false; //rejected. Not useful.
				bool isColor = false;
				var ic = _flags & (CIUFlags.Image | CIUFlags.Color | CIUFlags.Rectangle);
				if (ic == CIUFlags.Color) {
					isColor = true;
				} else {
					var mod = keys.gui.getMod();
					if (mod != 0 && ic == CIUFlags.Rectangle) return;
					switch (mod) {
					case 0: break;
					case KMod.Ctrl when ic == 0: isColor = true; break;
					default: return;
					}
				}

				Result = new CIUResult();
				var r = new RECT(p0.x, p0.y, 0, 0);
				if (isColor) {
					Result.color = (uint)_img.GetPixel(p0.x, p0.y).ToArgb();
					r.right++; r.bottom++;
				} else {
					var pen = Pens.Red;
					bool notFirstMove = false;
					_capturing = true;
					try {
						if (!WndUtil.DragLoop(_w, MButtons.Left, m => {
							if (m.msg.message != Api.WM_MOUSEMOVE) return;
							POINT p = m.msg.pt; _w.MapScreenToClient(ref p);
							using var g = Graphics.FromHwnd(_w.Handle);
							if (notFirstMove) { //erase prev rect
								r.right++; r.bottom++;
								g.DrawImage(_img, r, r, GraphicsUnit.Pixel);
								//FUTURE: prevent flickering. Also don't draw under magnifier.
							} else notFirstMove = true;
							r = RECT.FromLTRB(p0.x, p0.y, p.x, p.y);
							r.Normalize(true);
							g.DrawRectangle(pen, r);
						})) { //Esc key etc
							Api.InvalidateRect(_w);
							return;
						}
					}
					finally { _capturing = false; }

					r.right++; r.bottom++;
					if (r.NoArea) {
						Api.DestroyWindow(_w);
						return;
					}

					if (ic != CIUFlags.Rectangle) {
						Result.image = _img.Clone(r, PixelFormat.Format32bppArgb);
					}

				}
				_w.MapClientToScreen(ref r);
				Result.rect = r;

				if (isColor) { //bad things may happen if this window closed while the mouse button or Ctrl pressed
					for (int i = 200; --i >= 0 && (Api.GetKeyState(1) < 0 || Api.GetKeyState(17) < 0);) wait.doEvents(15);
				}

				_res = 1;
				Api.DestroyWindow(_w);
			}
		}

		#endregion

		#region other

		/// <summary>
		/// UI for capturing a rectangle, point or/and window on screen with <c>Shift</c> key.
		/// </summary>
		/// <returns><c>true</c> if captured, <c>false</c> if pressed <c>Esc</c>.</returns>
		/// <param name="result"></param>
		/// <param name="type"></param>
		/// <param name="rectInClient">Get rectangle in window client area.</param>
		/// <param name="wxyFlags"></param>
		public static unsafe bool RectPointWindowUI(out CRUResult result, CRUType type, bool rectInClient = false, WXYFlags wxyFlags = 0) {
			result = default;
			var wxyFlags2 = wxyFlags & (WXYFlags.NeedWindow | WXYFlags.NeedControl);

			var s = type switch {
				CRUType.Window => "Press Shift to capture %",
				CRUType.Rect => "Shift+mouse move to capture rectangle on screen.",
				CRUType.Point => "Press Shift to capture mouse coordinates.",
				CRUType.WindowAndPoint => "Press Shift to capture mouse coordinates in a %.",
				CRUType.WindowAndRect => "Shift+mouse move to capture rectangle in a %.",
				_ => "Press Shift to capture %.\nOr Shift+mouse move to capture rectangle in a %."
			};
			s = s.Replace("%", wxyFlags2 switch { WXYFlags.NeedWindow => "window", WXYFlags.NeedControl => "control", _ => "window or control" });
			s += "\nOr press Esc to cancel.";
			using var osd = osdText.showText(s, -1);

			wnd w = default, wClip = default;
			bool needWindow = type is not (CRUType.Rect or CRUType.Point);
			if (needWindow) { //draw black rectangle around window or control from mouse
				using var osrw = new osdRect { };
				osrw.Show();
				for (; ; ) {
					wait.doEvents(12);
					if (keys.isPressed(KKey.Escape)) return false;
					w = wnd.fromMouse(wxyFlags);
					osrw.Rect = w.Rect;
					if (keys.isShift) break;
				}
				if (w == default) return false;
			} else {
				for (; ; ) {
					wait.doEvents(12);
					if (keys.isPressed(KKey.Escape)) return false;
					if (keys.isShift) break;
				}
			}

			var p = mouse.xy;
			RECT r = new(p.x, p.y, 0, 0);

			if (type is not (CRUType.Window or CRUType.Point or CRUType.WindowAndPoint)) { //draw red rectangle
				if (needWindow) {
					wClip = wxyFlags2 == WXYFlags.NeedControl ? w : w.Window;
					var rw = rectInClient ? wClip.ClientRectInScreen : wClip.Rect;
					Api.ClipCursor(&rw);
				}

				try {
					using var osrr = new osdRect { Color = 0xff0000, Thickness = 1, Rect = r };
					osrr.Show();
					for (var r1 = r; ;) {
						wait.doEvents(12);
						if (keys.isPressed(KKey.Escape)) return false;
						if (!keys.isShift) break;
						p = mouse.xy;
						r1.right = p.x; r1.bottom = p.y;
						r = r1; r.Normalize(true);
						osrr.Rect = r;
					}
				}
				finally { if (needWindow) Api.ClipCursor(null); }

				if (needWindow && w != wClip) { //if rect spans multiple controls, get top-level window
					var w2 = wnd.fromMouse(wxyFlags);
					if (w2 != w) w = wClip;
				}
			}

			if (needWindow && rectInClient) w.MapScreenToClient(ref r);

			result = new(w, !r.NoArea, r);
			return true;
		}

		#endregion
	}

	/// <summary>
	/// Captures image pixels from screen or window.
	/// </summary>
	/// <remarks>
	/// This class is used by <see cref="CaptureScreen"/>, <see cref="uiimage"/> and <see cref="uiimageFinder"/>. Also you can use it directly. For example it can get pixels directly without copying to a <see cref="Bitmap"/> or array.
	/// 
	/// How to use:
	/// 1. Create variable.
	/// 2. Call <see cref="Capture"/>.
	/// 3. Call other functions to get result in various formats.
	/// 4. If need, repeat 2-3 (for example when waiting for image).
	/// 5. Dispose (important).
	/// 
	/// Pixel format: <c>Format32bppArgb</c>, alpha 0xff.
	/// </remarks>
	/// <example>
	/// <code><![CDATA[
	/// var w = wnd.find("LibreAutomate").Child("document");
	/// 
	/// using var c = new CaptureScreenImage();
	/// if (!c.Capture(w, new(0, 0, 200, 200))) return;
	/// using var b = c.ToBitmap();
	/// 
	/// var f = folders.Temp + "test.png"; b.Save(f); run.it(f);
	/// ]]></code>
	/// </example>
	public unsafe sealed class CaptureScreenImage : IDisposable {
		MemoryBitmap _mb;
		uint* _pixels;
		int _width, _height;
		int _dibWidth, _dibHeight;
		bool _alphaOk;
		//_DwmThumbnail _dwm;

		/// <summary>
		/// Frees image memory.
		/// </summary>
		public void Dispose() {
			_mb?.Dispose(); _mb = null;
			_pixels = null;
			_width = _height = 0;
			//_dwm?.Dispose(); _dwm = null;
		}

		internal void SetExternalData_(uint* pixels, int width, int height) {
			Debug.Assert(_mb == null);
			_pixels = pixels;
			_width = width;
			_height = height;
		}

		/// <summary>
		/// Let <c>Capture</c> don't set alpha = 0xff. Slightly faster. Then pixelformat will be Rgb instead of Argb.
		/// Default <c>false</c>.
		/// </summary>
		internal bool DontSetAlpha_ { get; set; }

		/// <summary>
		/// Captures image from window client area into memory stored in this variable.
		/// </summary>
		/// <param name="w">Window or control.</param>
		/// <param name="r">Rectangle in <i>w</i> client area coordinates. If <c>null</c>, uses <c>w.ClientRect</c>.</param>
		/// <returns><c>false</c> if <i>r</i> empty or not in the client area and used flag <c>Relaxed</c> (else exception).</returns>
		public bool Capture(wnd w, RECT? r = null, CIFlags flags = CIFlags.WindowDC) => _Capture(w.ThrowIf0(), r, flags);

		/// <summary>
		/// Captures image from screen into memory stored in this variable.
		/// </summary>
		/// <param name="relaxed">If <i>r</i> empty, return <c>false</c> instead of exception.</param>
		/// <returns><c>false</c> if <i>r</i> empty and <i>relaxed</i> <c>true</c> (else exception).</returns>
		public bool Capture(RECT r, bool relaxed = false) => _Capture(default, r, flags: relaxed ? CIFlags.Relaxed : 0);

		bool _Capture(wnd w, RECT? rect, CIFlags flags) {
			const CIFlags c_howMask = CIFlags.WindowDC | CIFlags.PrintWindow /*| CIFlags.WindowDwm*/;
			if ((flags & c_howMask) is not (0 or CIFlags.WindowDC or CIFlags.PrintWindow /*or CIFlags.WindowDwm*/)) throw new ArgumentException();
			bool fromWindow = flags.HasAny(c_howMask), printWindow = flags.Has(CIFlags.PrintWindow);
			RECT r = rect ?? default, rc = default;
			if (!w.Is0) {
				//if (flags.Has(CIFlags.WindowDwm)) { //w must be top-level window
				//	var ww = w.Window;
				//	if (ww != w) {
				//		ww.ThrowIf0();
				//		if (rect == null) r = w.ClientRect;
				//		w.MapClientToClientOf(ww, ref r);
				//		rect = r;
				//		w = ww;
				//	}
				//}

				var rc2 = w.ClientRect;
				bool dpiScaled = fromWindow && Dpi.IsWindowVirtualizedWin10_(w);
				using var dac = dpiScaled ? new Dpi.AwarenessContext(w) : default;
				if (!w.GetClientRect(out rc)) w.ThrowUseNative();
				if (rect == null || r == rc2) {
					r = rc;
				} else {
					if (dpiScaled) { //unscale r
						dac.Dispose();
						var ww = w.Window;
						int dpiw = Dpi.OfWindow(ww), dpis = screen.of(ww).Dpi;
						r = RECT.FromLTRB(Math2.MulDiv(r.left, dpiw, dpis), Math2.MulDiv(r.top, dpiw, dpis), Math2.MulDiv(r.right, dpiw, dpis), Math2.MulDiv(r.bottom, dpiw, dpis));
					}
					if (!r.Intersect(rc)) return flags.Has(CIFlags.Relaxed) ? false : throw new ArgumentException("rectangle not in window");
				}

				//if (flags.Has(CIFlags.WindowDwm)) {
				//	_dwm ??= new();
				//	if (!_dwm.Init(w, r, dpiScaled)) return flags.Has(CIFlags.Relaxed) ? false : throw new ArgumentException("rectangle not in window");
				//	w = _dwm.WndThumbnail;
				//}
			}
			if (r.NoArea) return flags.Has(CIFlags.Relaxed) ? false : throw new ArgumentException("empty rectangle");

			int dibWidth = printWindow ? rc.Width : r.Width, dibHeight = printWindow ? rc.Height : r.Height;
			if (_mb == null || dibWidth != _dibWidth || dibHeight != _dibHeight) {
				var bi = new Api.BITMAPINFO(dibWidth, -dibHeight);
				var dib = Api.CreateDIBSection(default, bi, 0, out var pixels);
				if (dib == default) throw new AuException("*create memory bitmap of specified size");
				_pixels = pixels;
				_mb ??= new MemoryBitmap();
				_mb.Attach(dib); //and deletes old bitmap
				_dibWidth = dibWidth;
				_dibHeight = dibHeight;
			}
			_width = r.Width;
			_height = r.Height;

			if (printWindow) { //must capture entire client area
				var pw = Api.PW_CLIENTONLY;
				if (osVersion.minWin8_1) pw |= Api.PW_RENDERFULLCONTENT;
				//PW_RENDERFULLCONTENT is new in Win8.1. Undocumented in MSDN, but defined in h. Then works with windows like Chrome, winstore.
				//	Bug: from some controls randomly gets partially painted image. Eg classic toolbar, treeview.
				//	Rejected: if PrintClient|WindowDC, capture without PW_RENDERFULLCONTENT. Makes no sense.

				if (!Api.PrintWindow(w, _mb.Hdc, pw)) w.ThrowNoNative("*get pixels");
				if (r.left != 0 || r.top != 0 || _width != dibWidth) { //move pixels to the start of the bitmap memory
					for (int y = r.top; y < r.bottom; y++) {
						var spanFrom = new Span<uint>(_pixels + y * dibWidth + r.left, _width);
						var spanTo = new Span<uint>(_pixels + (y - r.top) * _width, _width);
						spanFrom.CopyTo(spanTo);
					}
				}
				//} else if (flags.Has(CIFlags.WindowDwm)) {
				//	if (!Api.PrintWindow(w, _mb.Hdc, Api.PW_CLIENTONLY | Api.PW_RENDERFULLCONTENT)) w.ThrowNoNative("*get pixels");
				//	_alphaOk = true;
				//	return true;
			} else {
				if (!w.Is0 && !fromWindow) {
					w.MapClientToScreen(ref r);
					w = default;
				}
				using var dc = new WindowDC_(w);
				if (dc.Is0) w.ThrowNoNative("*get pixels");
				uint rop = !w.Is0 ? Api.SRCCOPY : Api.SRCCOPY | Api.CAPTUREBLT;
				Api.BitBlt(_mb.Hdc, 0, 0, _width, _height, dc, r.left, r.top, rop); //fails only if a HDC is invalid
			}

			if (_alphaOk = !DontSetAlpha_) {
				byte* p = (byte*)_pixels, pe = p + _width * _height * 4;
				for (p += 3; p < pe; p += 4) *p = 0xff;
			}

			return true;
		}

		/// <summary>
		/// Width of the captured image.
		/// </summary>
		public int Width => _width;

		/// <summary>
		/// Height of the captured image.
		/// </summary>
		public int Height => _height;

		/// <summary>
		/// Pixels of the captured image.
		/// </summary>
		public uint* Pixels => _pixels;

		/// <summary>
		/// Copies pixels of the captured image to new 1D array.
		/// </summary>
		[SkipLocalsInit]
		public uint[] ToArray1D() {
			var a = GC.AllocateUninitializedArray<uint>(_height * _width);
			fixed (uint* p = a) { MemoryUtil.Copy(_pixels, p, _width * _height * 4); }
			return a;
		}

		/// <summary>
		/// Copies pixels of the captured image to new 2D array <c>[row, column]</c>.
		/// </summary>
		public uint[,] ToArray2D() {
			var a = new uint[_height, _width];
			fixed (uint* p = a) { MemoryUtil.Copy(_pixels, p, _width * _height * 4); }
			return a;
		}

		/// <summary>
		/// Creates new <c>Bitmap</c> from pixels of the captured image.
		/// </summary>
		public Bitmap ToBitmap() {
			var b = new Bitmap(_width, _height, _alphaOk ? PixelFormat.Format32bppArgb : PixelFormat.Format32bppRgb);
			GC_.AddObjectMemoryPressure(b, _width * _height * 4);
			using var d = b.Data(new(0, 0, _width, _height), ImageLockMode.ReadWrite);
			MemoryUtil.Copy(_pixels, (uint*)d.Scan0, _width * _height * 4);
			return b;
		}

		//rejected. Unreliable. Not all windows that require PW_RENDERFULLCONTENT have WS_EX_NOREDIRECTIONBITMAP. Eg Chrome on Win8.1.
		//static uint _GetPrintWindowFlags(CIFlags flags, wnd w, RECT r) {
		//	if (!flags.Has(CIFlags.PrintWindow)) return 0;
		//	var f = Api.PW_CLIENTONLY;
		//	if (osVersion.minWin8_1) {
		//		var wtl = w.Window;
		//		if (wtl.HasExStyle(WSE.NOREDIRECTIONBITMAP)) f |= Api.PW_RENDERFULLCONTENT;
		//		else
		//			api.EnumChildWindows(wtl, (c, _) => {
		//				if (c.HasExStyle(WSE.NOREDIRECTIONBITMAP) && (c == w || (c.IsVisible && c.GetRectIn(w, out var rr) && rr.IntersectsWith(r)))) {
		//					f |= Api.PW_RENDERFULLCONTENT;
		//					return false;
		//				}
		//				return true;
		//			}, 0);
		//	}
		//	if (flags.Has(CIFlags.WindowDC) && 0 == (f & Api.PW_RENDERFULLCONTENT)) f = 0;
		//	return f;
		//}
	}
}

namespace Au.Types {
	/// <summary>
	/// Used with <see cref="CaptureScreen"/> functions.
	/// </summary>
	[Flags]
	public enum CIFlags {
		/// <inheritdoc cref="IFFlags.WindowDC"/>
		WindowDC = 1,

		/// <inheritdoc cref="IFFlags.PrintWindow"/>
		PrintWindow = 2,

		///// <inheritdoc cref="IFFlags.WindowDwm"/>
		//WindowDwm = 4,

		//note: the above values must be the same in CIFlags, CIUFlags, IFFlags, OcrFlags.

		/// <summary>
		/// Flag: don't throw exception when the specified rectangle or point does not intersect with the window client area or when the rectangle is empty. Instead return <c>null</c> or 0.
		/// </summary>
		Relaxed = 0x100,

		//rejected. Or would need a tool to capture rect/pont in logical coord.
		///// <summary>
		///// Flag: the specified rectangle or point uses logical (non-scaled) coordinates when the window is DPI-scaled. Used only with flags <c>WindowDC</c> (default) or <c>PrintWindow</c>.
		///// </summary>
		//RectLogical = 0x200,
	}

	static partial class ExtMisc {
		internal static CIFlags ToCIFlags_(this CIUFlags t) => (CIFlags)t & (CIFlags.WindowDC | CIFlags.PrintWindow /*| CIFlags.WindowDwm*/);
		internal static CIFlags ToCIFlags_(this IFFlags t) => (CIFlags)t & (CIFlags.WindowDC | CIFlags.PrintWindow /*| CIFlags.WindowDwm*/);
		internal static CIFlags ToCIFlags_(this OcrFlags t) => (CIFlags)t & (CIFlags.WindowDC | CIFlags.PrintWindow /*| CIFlags.WindowDwm*/);
	}

	/// <summary>
	/// Flags for <see cref="CaptureScreen.ImageColorRectUI"/>.
	/// </summary>
	/// <remarks>
	/// Only one of flags <c>Image</c>, <c>Color</c> and <c>Rectangle</c> can be used. If none, can capture image or color.
	/// </remarks>
	[Flags]
	public enum CIUFlags {
		/// <inheritdoc cref="IFFlags.WindowDC"/>
		WindowDC = 1,

		/// <inheritdoc cref="IFFlags.PrintWindow"/>
		PrintWindow = 2,

		//could not make it work well with "glass" areas.
		///// <inheritdoc cref="IFFlags.WindowDwm"/>
		//WindowDwm = 4,

		//note: the above values must be the same in CIFlags, CIUFlags, IFFlags, OcrFlags.

		/// <summary>Can capture only image, not color.</summary>
		Image = 0x100,

		/// <summary>Can capture only color, not image.</summary>
		Color = 0x200,

		/// <summary>Capture only rectangle, not image/color.</summary>
		Rectangle = 0x400,
	}

#pragma warning disable 1591 //XML doc
	[Flags, Obsolete("Renamed to CIUFlags"), EditorBrowsable(EditorBrowsableState.Never)]
	public enum ICFlags {
		WindowDC = 1,
		PrintWindow = 2,
		Image = 0x100,
		Color = 0x200,
		Rectangle = 0x400,
	}

	[Obsolete("Renamed to CIUResult"), EditorBrowsable(EditorBrowsableState.Never)]
	public class ICResult : CIUResult { }
#pragma warning restore 1591 //XML doc

	/// <summary>
	/// Results of <see cref="CaptureScreen.ImageColorRectUI"/>.
	/// </summary>
	public class CIUResult {
		/// <summary>
		/// Captured image.
		/// <c>null</c> if captured single pixel color or used flag <see cref="CIUFlags.Rectangle"/>.
		/// </summary>
		public Bitmap image;

		/// <summary>
		/// Captured color in <c>0xAARRGGBB</c> format. Alpha 0xFF.
		/// </summary>
		public uint color;

		/// <summary>
		/// Location of the captured image or rectangle, in screen coordinates.
		/// </summary>
		public RECT rect;

		/// <summary>
		/// Window or control containing the captured image or rectangle, if whole image is in its client area.
		/// In some cases may be incorrect, for example if windows moved/opened/closed/etc while capturing.
		/// </summary>
		public wnd w;

		/// <summary>
		/// If used flags to get window pixels and the window is DPI-scaled (smaller when capturing), on Windows 10 and later contains the scale factor. Else 1.
		/// </summary>
		public double dpiScale;

		/// <summary>
		/// If <c>true</c>, most likely <see cref="w"/> is incorrect window, because the window that was there before capturing disappeared while capturing, for example it was a popup menu.
		/// If captured from screen (without flags like <c>WindowDC</c>), <see cref="w"/> may be correct even if this is <c>true</c> (can't detect reliably), else certainly incorrect.
		/// </summary>
		public bool possiblyWrongWindow;
	}

	/// <summary>
	/// <see cref="CaptureScreen.RectPointWindowUI"/> UI type.
	/// </summary>
	public enum CRUType {
		/// <summary>Capture only window.</summary>
		Window,

		/// <summary>Capture only rectangle in screen.</summary>
		Rect,

		/// <summary>Capture rectangle in window.</summary>
		WindowAndRect,

		/// <summary>Capture window and optionally rectangle in it.</summary>
		WindowOrRect,

		/// <summary>Capture only point (coordinates) in screen.</summary>
		Point,

		/// <summary>Capture point in window.</summary>
		WindowAndPoint,
	}

	/// <summary>
	/// <see cref="CaptureScreen.RectPointWindowUI"/> results.
	/// </summary>
	public record struct CRUResult(wnd w, bool hasRect, RECT r);
}


================================================
FILE: Au/UI objects/OcrGoogleCloud.cs
================================================
using System.Drawing;
using System.Text.Json.Nodes;
using System.Net.Http;

namespace Au.More;

/// <summary>
/// This OCR engine uses <see href="https://cloud.google.com/vision/docs/reference/rest/v1/images/annotate">Google Cloud Vision API</see>.
/// </summary>
/// <remarks>
/// Sends image to Google Cloud and gets results. The OCR engine is accurate but much slower than the default engine or Tesseract. Depends on internet connection speed.
/// 
/// To use this engine, need to have a Google Cloud account, enable Vision API and get API key. The service isn't free, but 1000 or so requests/month are free.
/// </remarks>
public class OcrGoogleCloud : IOcrEngine {
	string _apiKey;
	
	/// <param name="apiKey">API key.</param>
	public OcrGoogleCloud(string apiKey) {
		_apiKey = apiKey;
	}
	
	/// <summary>
	/// Feature type, like <c>"TEXT_DETECTION"</c>. Or JSON of <c>features</c> array content, like <c>"""{ "type": "TEXT_DETECTION", "model": "builtin/latest" }"""</c>.
	/// If <c>null</c>, uses <c>"DOCUMENT_TEXT_DETECTION"</c>.
	/// </summary>
	public string Features { get; set; }
	
	/// <summary>
	/// JSON of <c>imageContext</c>, like <c>"""{ "languageHints": [ "ja" ] }"""</c>. Optional.
	/// </summary>
	public string ImageContext { get; set; }
	
	/// <inheritdoc cref="IOcrEngine.DpiScale"/>
	public bool DpiScale { get; set; }
	
	/// <inheritdoc cref="IOcrEngine.Recognize"/>
	/// <exception cref="Exception">Failed.</exception>
	public OcrWord[] Recognize(Bitmap b, bool dispose, double scale) {
		var b0 = b;
		b = IOcrEngine.PrepareBitmap(b, dispose, scale);
		var png = IOcrEngine.GetBitmapPngFileData(b);
		if (dispose || b != b0) b.Dispose();
		
		var url = "https://vision.googleapis.com/v1/images:annotate?key=" + _apiKey;
		
		var feat = Features ?? "DOCUMENT_TEXT_DETECTION";
		if (!feat.Starts('{')) feat = $$"""{ "type": "{{feat}}" }""";
		
		string ic = ImageContext, ic2 = ic.NE() ? null : ",\r\n      \"imageContext\": ";
		
		var requestJson = $$"""
{
  "requests": [
    {
      "features": [
        {{feat}}
      ],
      "image": {
        "content": "{{Convert.ToBase64String(png)}}"
      }{{ic2}}{{ic}}
    }
  ]
}
""";
		
		//perf.first();
		if (!internet.http_.TryPost(out var r, url, internet.jsonContent(requestJson), ["Accept-Encoding: br, gzip, deflate"], dontWait: true))
			throw new AuException(r.Text(true));
		//perf.next();
#if true //can be faster > 10 times. Also we use compression. Together it makes this part 100 times faster than the TryPost.
		var j = _ReadResponse(r);
		//perf.nw();
		return _ParseJson(j["responses"][0], scale);
#else
		var j=r.Json();
		//perf.nw();
		return _ParseJson(j["responses"][0], scale);
#endif
	}
	
	//Reads response until "fullTextAnnotation".
	//Can make the download size smaller > 10 times.
	static unsafe JsonNode _ReadResponse(HttpResponseMessage rm) {
		var find = "\"fullTextAnnotation\":"u8;
		using var ab = new ArrayBuilder_<byte>() { Capacity = 250_000 };
		int have = 0;
		using (var stream = rm.Content.ReadAsStream()) {
			for (; ; ) {
				if (have + 17000 > ab.Capacity) ab.ReAlloc(ab.Capacity * 2);
				int n = stream.Read(new Span<byte>(ab.Ptr + have, ab.Capacity - have - 10));
				if (n == 0) break;
				int old = Math.Min(find.Length, have);
				int i = new RByte(ab.Ptr + have - old, n + old).IndexOf(find);
				if (i > 0) {
					i += have - old;
					while (ab.Ptr[i - 1] is 32 or 9 or 10 or 13 or (byte)',') i--;
					ab.Ptr[i++] = (byte)'}';
					ab.Ptr[i++] = (byte)']';
					ab.Ptr[i++] = (byte)'}';
					have = i;
					break;
				}
				have += n;
			}
		}
		rm.Dispose();
		return JsonNode.Parse(new RByte(ab.Ptr, have));
	}
	
	static OcrWord[] _ParseJson(JsonNode j, double scale) {
		if (j["textAnnotations"]?.AsArray() is not { } ta) return []; //no text detected
		List<OcrWord> a = new();
		string text = null;
		int i = 0;
		foreach (var word in ta) {
			var s = (string)word["description"];
			if (text == null) {
				text = s;
			} else {
				int i2 = text.Find(s, i);
				var sep = text[i..i2]; if (sep == "\n") sep = "\r\n";
				a.Add(new(sep, s, _PolyToRect(word), scale));
				i = i2 + s.Length;
			}
		}
		
		return a.ToArray();
		
		static RECT _PolyToRect(JsonNode n) {
			var a = n["boundingPoly"]["vertices"].AsArray();
			JsonNode tl = a[0], tr = a[1], br = a[2], bl = a[3];
			return IOcrEngine.PolyToRect(tl["x"], tl["y"], tr["x"], tr["y"], br["x"], br["y"], bl["x"], bl["y"]);
		}
	}
}


================================================
FILE: Au/UI objects/OcrMicrosoftAzure.cs
================================================
using System.Drawing;
using System.Text.Json.Nodes;
using System.Net.Http;

namespace Au.More;

/// <summary>
/// This OCR engine uses Microsoft Azure Computer Vision OCR.
/// </summary>
/// <remarks>
/// Sends image to Microsoft Azure and gets results. The OCR engine is accurate but much slower than the default engine or Tesseract, and usually slower than Google Cloud.
/// 
/// To use this engine, need to have a Microsoft Azure account and get API key and endpoint URL. The service isn't free, but 500 or so requests/month are free.
/// </remarks>
public class OcrMicrosoftAzure : IOcrEngine {
	string _endpointUrl, _apiKey;
	
	/// <param name="endpointUrl">Endpoint URL, like <c>"https://xxxx.cognitiveservices.azure.com/"</c>.</param>
	/// <param name="apiKey">API key.</param>
	public OcrMicrosoftAzure(string endpointUrl, string apiKey) {
		if (!endpointUrl.Like("https://*.cognitiveservices.azure.com/")) print.warning("endpointUrl should be like https://xxxx.cognitiveservices.azure.com/");
		_endpointUrl = endpointUrl;
		_apiKey = apiKey;
	}
	
	/// <inheritdoc cref="IOcrEngine.DpiScale"/>
	public bool DpiScale { get; set; }
	
	/// <inheritdoc cref="IOcrEngine.Recognize"/>
	/// <exception cref="Exception">Failed.</exception>
	public OcrWord[] Recognize(Bitmap b, bool dispose, double scale) {
		var b0 = b;
		b = IOcrEngine.PrepareBitmap(b, dispose, scale, 50, 50);
		var png = IOcrEngine.GetBitmapPngFileData(b);
		if (dispose || b != b0) b.Dispose();
		
		var url = $"{_endpointUrl}formrecognizer/documentModels/prebuilt-read:analyze?api-version=2022-08-31"; //&stringIndexType=textElements
		var headers = new[] { "Ocp-Apim-Subscription-Key: " + _apiKey };
		var requestJson = $$"""
{
"base64Source": "{{Convert.ToBase64String(png)}}"
}
""";
		if (!internet.http_.TryPost(out var r, url, internet.jsonContent(requestJson), headers))
			throw new AuException(r.Text(true));
		url = r.Headers.GetValues("Operation-Location").First();
		//perf.next();
		500.ms();
		var j = wait.until(new(90) { Period = 300 }, () => {
			var v = internet.http_.Get(url, headers: headers).Json();
			return (string)v["status"] == "succeeded" ? v : null;
		});
		//perf.nw();
		return _ParseJson(j["analyzeResult"], scale);
	}
	
	static OcrWord[] _ParseJson(JsonNode j, double scale) {
		List<OcrWord> a = new();
		HashSet<int> hs = new();
		int i = 0;
		foreach (var page in j["pages"].AsArray()) {
			foreach (var line in page["lines"].AsArray()) {
				hs.Add((int)line["spans"][0]["offset"]);
			}
			foreach (var word in page["words"].AsArray()) {
				var sep = i++ == 0 ? null : hs.Contains((int)word["span"]["offset"]) ? "\r\n" : " ";
				a.Add(new(sep, (string)word["content"], _PolyToRect(word), scale));
			}
		}
		
		return a.ToArray();
		
		static RECT _PolyToRect(JsonNode n) {
			var a = n["polygon"].AsArray();
			return IOcrEngine.PolyToRect(a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7]);
		}
	}
}


================================================
FILE: Au/UI objects/OcrTesseract.cs
================================================
using Microsoft.Win32;
using System.Drawing;
using System.Drawing.Imaging;

namespace Au.More;

/// <summary>
/// This OCR engine uses <c>tesseract.exe</c> from Tesseract installed on this computer.
/// </summary>
/// <remarks>
/// Slower than <see cref="OcrWin10"/> (the default engine). The accuracy is poor.
/// Supports more languages. You choose what languages to install when you install Tesseract.
/// 
/// <see href="https://github.com/UB-Mannheim/tesseract/wiki">Download Tesseract</see>
/// </remarks>
public class OcrTesseract : IOcrEngine {
	/// <param name="tesseractPath">Full path of Tesseract folder. If <c>null</c>, uses path written in the registry by the installer.</param>
	/// <exception cref="FileNotFoundException"></exception>
	public OcrTesseract(string tesseractPath = null) {
		_tesseractPath = tesseractPath ?? Registry.GetValue(@"HKEY_LOCAL_MACHINE\SOFTWARE\Tesseract-OCR", "Path", null) as string;
		var exe = _tesseractPath + @"\tesseract.exe";
		if (!filesystem.exists(exe).File) throw new FileNotFoundException("tesseract.exe not found. Download/install Tesseract, or set correct tesseractPath argument.");
		_tesseractExe = exe;
	}
	readonly string _tesseractPath, _tesseractExe;

	/// <summary>
	/// One or more of installed languages, like <c>"deu"</c> or <c>"eng+deu"</c>. If <c>null</c> (default), uses <c>"eng"</c>.
	/// </summary>
	public string Language { get; set; }

	/// <summary>
	/// Gets OCR languages that are installed on this computer and can be used for <see cref="Language"/>.
	/// </summary>
	public string[] AvailableLanguages {
		get {
			var a = new List<string>();
			run.console(s => { if (!s.NE() && !s.Ends(':') && !s.Eqi("osd")) a.Add(s); }, _tesseractExe, "--list-langs");
			return a.ToArray();

			//note: can be in subfolders, like "test/deu".
		}
	}

	///// <summary>
	///// Adds command line <c>--psm</c> (page segmentation mode).
	///// Valid values are 0-13, but documented only 3 (default) and 6 (no segmentation).
	///// </summary>
	//public int Psm { get; set; } = 3;

	/// <summary>
	/// Additional command line arguments.
	/// </summary>
	public string CommandLine { get; set; }

	/// <inheritdoc cref="IOcrEngine.DpiScale"/>
	public bool DpiScale { get; set; } = true;

	/// <inheritdoc cref="IOcrEngine.Recognize"/>
	public OcrWord[] Recognize(Bitmap b, bool dispose, double scale) {
		var b0 = b;
		b = IOcrEngine.PrepareBitmap(b, dispose, scale);

		using var temp = new TempFile(".png");
		b.Save(temp, ImageFormat.Png);
		if (dispose || b != b0) b.Dispose();

		var cl = $"\"{temp}\" stdout";
		if (!Language.NE()) cl += $" -l {Language}";
		//if (Psm != 3) cl += $" --psm {Psm}";
		if (!CommandLine.NE()) cl += $" {CommandLine}";
		cl += " quiet tsv"; //must be at the end, else all -x parameters ignored

		if (0 != run.console(out string result, _tesseractExe, cl, encoding: Encoding.UTF8)) throw new AuException(result);

		//print.it(result);

		regexp rx = new(@"^(?:\d+\t){6}(\d+)\t(\d+)\t(\d+)\t(\d+)\t\S+\t(\S.*)$");
		List<OcrWord> a = new();
		string sep = null;
		RECT pr = default;
		foreach (var s in result.Lines()) {
			switch (s[0]) {
			case '4': //line
				if (sep != null) sep = "\r\n";
				break;
			case '5': //word
				if (rx.Match(s, out var m)) { //else text is space
					RECT r = new(m[1].Value.ToInt(), m[2].Value.ToInt(), m[3].Value.ToInt(), m[4].Value.ToInt());

					//break line if big space between words
					if (sep == " " && r.left - pr.right > pr.Height + r.Height) sep = "\r\n";
					pr = r;

					a.Add(new(sep, m[5].Value, r, scale));
					sep = " ";
				}
				break;
			}
		}

		return a.ToArray();
	}
}


================================================
FILE: Au/UI objects/OcrWin10.cs
================================================
using System.Drawing;
using System.Drawing.Imaging;

namespace Au.More {
	/// <summary>
	/// The default OCR engine. Available on Windows 10 and later.
	/// </summary>
	/// <remarks>
	/// Uses the Windows 10/11 OCR engine. It's the fastest. The accuracy is poor.
	/// If need better accuracy, use a cloud OCR engine (<see cref="OcrGoogleCloud"/>, <see cref="OcrMicrosoftAzure"/>).
	/// If need a non-cloud OCR for older Windows, install Tesseract and use <see cref="OcrTesseract"/>. Also it supports more languages.
	/// </remarks>
	public unsafe class OcrWin10 : IOcrEngine {
		/// <exception cref="NotSupportedException">OS version older than Windows 10.</exception>
		public OcrWin10() {
			if (!osVersion.minWin10) throw new NotSupportedException("This OCR engine is available only on Windows 10 and later. Use another engine.");
		}

		/// <summary>
		/// Language, like <c>"en-US"</c>. See <see cref="AvailableLanguages"/>. If <c>null</c> (default), uses the default OCR language of this computer.
		/// </summary>
		/// <remarks>
		/// You can install languages in Windows <b>Settings > Time and language > Language and region</b>. Not all languages are supported.
		/// </remarks>
		public string Language { get; set; }

		/// <summary>
		/// Gets OCR languages that are installed on this computer and can be used for <see cref="Language"/>.
		/// </summary>
		public (string tag, string displayName)[] AvailableLanguages {
			get {
				using var oes = WinRT.IOcrEngineStatics.CreateStatics();
				using var a1 = oes.AvailableRecognizerLanguages;
				var a2 = new (string, string)[a1.Size];
				for (int i = 0; i < a2.Length; i++) {
					using var lang = a1[i];
					a2[i] = (lang.LanguageTag, lang.DisplayName);
				}
				return a2;
			}
		}

		/// <inheritdoc cref="IOcrEngine.DpiScale"/>
		public bool DpiScale { get; set; } = true;

		/// <inheritdoc cref="IOcrEngine.Recognize"/>
		public OcrWord[] Recognize(Bitmap b, bool dispose, double scale) {
			var b0 = b;
			b = IOcrEngine.PrepareBitmap(b, dispose, scale, 50, 50);
			using var sb = WinRT.ISoftwareBitmap.FromBitmap(b);
			if (dispose || b != b0) b.Dispose();

			using var engine = WinRT.IOcrEngine.CreateEngine(Language);
			using var result = engine.RecognizeAsync(sb).Await<WinRT.IOcrResult>();

			var a = new List<OcrWord>();
			string sep = null;
			using var lines = result.Lines;
			foreach (var line in lines.Items()) {
				using var words = line.Words;
				foreach (var word in words.Items()) {
					a.Add(new(sep, word.Text, word.BoundingRect, scale));
					sep = " ";
				}
				sep = "\r\n";
			}

			return a.ToArray();
		}
	}
}

namespace Au.Types {
#pragma warning disable 649, 169 //field never assigned/used
	static unsafe partial class WinRT {
		internal struct IOcrResult : IComPtr {
			IUnknown _u; public IUnknown U => _u;
			public void Dispose() => _u.Dispose();

			public IVectorView<IOcrLine> Lines => _u.GetPtr<IVectorView<IOcrLine>>(6);

			//public string Text => _u.GetString(8);
		}

		internal struct IOcrLine : IComPtr {
			IUnknown _u; public IUnknown U => _u;
			public void Dispose() => _u.Dispose();

			public IVectorView<IOcrWord> Words => _u.GetPtr<IVectorView<IOcrWord>>(6);

			//public string Text => _u.GetString(7);
		}

		internal struct IOcrWord : IComPtr {
			IUnknown _u; public IUnknown U => _u;
			public void Dispose() => _u.Dispose();

			public RECT BoundingRect {
				get {
					HR(((delegate* unmanaged[Stdcall]<IntPtr, out RectangleF, int>)_u[6])(_u, out var r));
					return RECT.From(r, true);
				}
			}

			public string Text => _u.GetString(7);
		}

		[Guid("5BFFA85A-3384-3540-9940-699120D428A8")]
		internal struct IOcrEngineStatics : IComPtr {
			IUnknown _u; public IUnknown U => _u;
			public void Dispose() => _u.Dispose();

			//public int MaxImageDimension { get; }

			public IVectorView<ILanguage> AvailableRecognizerLanguages => _u.GetPtr<IVectorView<ILanguage>>(7);

			//public bool IsLanguageSupported(ILanguage language);

			public IOcrEngine TryCreateFromLanguage(ILanguage language) {
				HR(((delegate* unmanaged[Stdcall]<IntPtr, ILanguage, out IOcrEngine, int>)_u[9])(_u, language, out var r));
				return r;
			}

			public IOcrEngine TryCreateFromUserProfileLanguages() => _u.GetPtr<IOcrEngine>(10);

			public static IOcrEngineStatics CreateStatics() => Create<IOcrEngineStatics>("Windows.Media.Ocr.OcrEngine");
		}

		internal struct IOcrEngine : IComPtr {
			IUnknown _u; public IUnknown U => _u;
			public void Dispose() => _u.Dispose();

			public IAsyncOperation RecognizeAsync(ISoftwareBitmap bitmap) {
				HR(((delegate* unmanaged[Stdcall]<IntPtr, ISoftwareBitmap, out IAsyncOperation, int>)_u[6])(_u, bitmap, out var r));
				return r;
			}

			//public ILanguage RecognizerLanguage { get; }

			public static IOcrEngine CreateEngine(string language = null) {
				using var oes = IOcrEngineStatics.CreateStatics();
				if (language.NE()) return oes.TryCreateFromUserProfileLanguages();
				using var lf = Create<ILanguageFactory>("Windows.Globalization.Language");
				using var lang = lf.CreateLanguage(language);
				return oes.TryCreateFromLanguage(lang);
			}
		}

		[Guid("DF0385DB-672F-4A9D-806E-C2442F343E86")]
		struct ISoftwareBitmapStatics : IComPtr {
			IUnknown _u; public IUnknown U => _u;
			public void Dispose() => _u.Dispose();

			public ISoftwareBitmap CreateCopyFromBuffer(IBuffer source, int width, int height) {
				HR(((delegate* unmanaged[Stdcall]<IntPtr, IBuffer, int, int, int, out ISoftwareBitmap, int>)_u[9])(_u, source, 87, width, height, out var r)); //Bgra8 = 87
				return r;
			}
		}

		internal struct ISoftwareBitmap : IComPtr {
			IUnknown _u; public IUnknown U => _u;
			public void Dispose() => _u.Dispose();

			public static ISoftwareBitmap FromBitmap(Bitmap b) {
				using var d = b.Data(ImageLockMode.ReadOnly, b.PixelFormat == PixelFormat.Format32bppRgb ? PixelFormat.Format32bppRgb : PixelFormat.Format32bppArgb);
				if (d.Stride < 0) throw new ArgumentException();
				using var cbs = Create<ICryptographicBufferStatics>("Windows.Security.Cryptography.CryptographicBuffer");
				using var sbs = Create<ISoftwareBitmapStatics>("Windows.Graphics.Imaging.SoftwareBitmap");
				using var buffer = cbs.CreateFromByteArray(d.Height * d.Stride, (byte*)d.Scan0);
				return sbs.CreateCopyFromBuffer(buffer, d.Width, d.Height);
			}
		}

		[Guid("320B7E22-3CB0-4CDF-8663-1D28910065EB")]
		struct ICryptographicBufferStatics : IComPtr {
			IUnknown _u; public IUnknown U => _u;
			public void Dispose() => _u.Dispose();

			//the easiest way to create IBuffer which is required to create ISoftwareBitmap
			public IBuffer CreateFromByteArray(int size, byte* value) {
				HR(((delegate* unmanaged[Stdcall]<IntPtr, int, byte*, out IBuffer, int>)_u[9])(_u, size, value, out var r));
				return r;
			}
		}

		struct IBuffer : IComPtr {
			IUnknown _u; public IUnknown U => _u;
			public void Dispose() => _u.Dispose();
		}

		internal struct ILanguage : IComPtr {
			IUnknown _u; public IUnknown U => _u;
			public void Dispose() => _u.Dispose();

			public string LanguageTag => _u.GetString(6);
			public string DisplayName => _u.GetString(7);
			//public string NativeName => _u.GetString(8);
			//public string Script => _u.GetString(9);
		}

		[Guid("9B0252AC-0C27-44F8-B792-9793FB66C63E")]
		internal struct ILanguageFactory : IComPtr {
			IUnknown _u; public IUnknown U => _u;
			public void Dispose() => _u.Dispose();

			public ILanguage CreateLanguage(string languageTag) {
				using var s1 = new _Hstring(languageTag);
				HR(((delegate* unmanaged[Stdcall]<IntPtr, IntPtr, out ILanguage, int>)_u[6])(_u, s1, out var r));
				return r;
			}
		}
	}
}


================================================
FILE: Au/UI objects/elm.cs
================================================
namespace Au;

/// <summary>
/// Represents a UI element. Clicks, gets properties, etc.
/// </summary>
/// <remarks>
/// <para>
/// UI elements are user interface (UI) parts that are accessible through programming interfaces (API). For example buttons, links, list items.
/// This class can find them, get properties, click, etc.
/// Web pages and most other windows support UI elements.
/// </para>
/// <para>
/// An <c>elm</c> variable contains a COM interface pointer (<ms>IAccessible</ms> or other) and uses methods of that interface or/and related API.
/// </para>
/// <para>
/// <c>elm</c> functions that get properties don't throw exception when the COM etc method failed (returned an error code of <ms>HRESULT</ms> type).
/// Then they return <c>""</c> (string properties), 0, <c>false</c>, <c>null</c> or empty collection, depending on return type.
/// Applications implement UI elements differently, often with bugs, and their COM interface functions return a variety of error codes.
/// It's impossible to reliably detect whether the error code means an error or the property is merely unavailable.
/// These <c>elm</c> functions also set the last error code of this thread = the return value (<c>HRESULT</c>) of the COM function, and callers can use <see cref="lastError"/> to get it.
/// If <see cref="lastError.code"/> returns 1 (<c>S_FALSE</c>), in most cases it's not an error, just the property is unavailable. On error it will probably be a negative error code.
/// </para>
/// <para>
/// You can dispose <c>elm</c> variables to release the COM object, but it is not necessary (GC will do it later).
/// </para>
/// <para>
/// An <c>elm</c> variable cannot be used in multiple threads. Only <c>Dispose</c> can be called in any thread.
/// </para>
/// <para>
/// UI elements are implemented and live in their applications. This class just communicates with them.
/// [Known UI element issues in various applications](xref:ui_element_issues)
/// </para>
/// </remarks>
/// <example>
/// Click link <c>"Example"</c> in Chrome.
/// <code><![CDATA[
/// var w = wnd.find(0, "* Chrome");
/// var e = w.Elm["web:LINK", "Example"].Find(5);
/// e.Invoke();
/// ]]></code>
/// Click a link, wait for new web page, click a link in it.
/// <code><![CDATA[
/// var w = wnd.find(0, "* Chrome");
/// var e = w.Elm["web:LINK", "Link 1"].Find(5);
/// e.WebInvoke();
/// w.Elm["web:LINK", "Link 2"].Find(5).WebInvoke();
/// ]]></code>
/// </example>
[StructLayout(LayoutKind.Sequential)]
public unsafe sealed partial class elm : IDisposable {
	//FUTURE: elm.more.EnableElmInChromeWebPagesWhenItStarts
	//FUTURE: elm.more.EnableElmInJavaWindows (see JavaEnableJAB in QM2)
	//FUTURE: add functions to marshal to another thread.

	internal struct Misc_ {
		public EMiscFlags flags;
		public byte roleByte; //for optimization. 0 if not set or failed to get. 0xFF (ERole.Custom) if VT_BSTR or not 1-ROLE_MAX.
		public ushort level; //for ToString. 0 if not set.
		
		public void SetRole(ERole role) { this.roleByte = (byte)(role <= 0 || role > ERole.TREEBUTTON ? ERole.Custom : role); }
		public void SetLevel(int level) { this.level = (ushort)Math.Clamp(level, 0, 0xffff); }
	}
	
	internal IntPtr _iacc;
	internal int _elem;
	internal Misc_ _misc;
	//Real elm object memory size with header: 32 bytes on 64-bit.
	//We don't use RCW<IAccessible>, which would add another 32 bytes.
	
	/// <summary>
	/// Creates elm from <c>IAccessible</c> and child id.
	/// By default does not <c>AddRef</c>.
	/// <i>iacc</i> must not be 0.
	/// </summary>
	internal elm(IntPtr iacc, int elem = 0, bool addRef = false) {
		_Set(iacc, elem, default, addRef);
	}
	
	/// <summary>
	/// Creates <see cref="elm"/> from <c>Cpp_Acc</c>.
	/// By default does not <c>AddRef</c>.
	/// <c>x.acc</c> must not be 0.
	/// </summary>
	internal elm(Cpp.Cpp_Acc x, bool addRef = false) {
		_Set(x.acc, x.elem, x.misc, addRef);
	}
	
	/// <summary>
	/// Sets fields.
	/// <c>_iacc</c> must be 0, <i>iacc</i> not 0.
	/// </summary>
	void _Set(IntPtr iacc, int elem = 0, Misc_ misc = default, bool addRef = false) {
		Debug.Assert(_iacc == default);
		Debug.Assert(iacc != default);
		if (addRef) Marshal.AddRef(iacc);
		_iacc = iacc;
		_elem = elem;
		_misc = misc;
		
		int mp = _MemoryPressure;
		GC.AddMemoryPressure(mp);
		//s_dmp += mp; if(s_dmp > DebugMaxMemoryPressure) DebugMaxMemoryPressure = s_dmp;
		//DebugMemorySum += mp;
	}
	
	int _MemoryPressure => _elem == 0 ? c_memoryPressure : c_memoryPressure / 10;
	const int c_memoryPressure = 1000; //assume this is the average UI element memory size in both processes
	
	//internal static int DebugMaxMemoryPressure;
	//static int s_dmp;
	//internal static int DebugMemorySum;
	
	///
	void Dispose(bool disposing) {
		//print.it(disposing);
		if (_iacc != default) {
			var t = _iacc; _iacc = default;
			//perf.first();
			Marshal.Release(t);
			//perf.nw();
			//print.it($"rel: {t}  {Marshal.Release(t)}");
			
			int mp = _MemoryPressure;
			GC.RemoveMemoryPressure(mp);
			//s_dmp -= mp;
		}
		_elem = 0;
		_misc = default;
	}
	
	/// <summary>
	/// Releases COM object and clears this variable.
	/// </summary>
	public void Dispose() {
		Dispose(true);
		GC.SuppressFinalize(this);
	}
	
	///
	~elm() {
#if DEBUG
		//print.it("~elm");
		try { Dispose(false); }
		catch (Exception ex) { print.it(ex); }
#else
		Dispose(false);
#endif
	}
	//TODO2: try: release elm COM objects in process.Exit event. Use weak reference. Or GC.Collect.
	
	//internal void Debug1() {
	//	print.it(_iacc, Debug_.GetComObjRefCount_(_iacc));
	//}
	
	//not used in this library, but sometimes may need it for testing something in scripts.
	internal IntPtr Iacc_ => _iacc;
	
	/// <summary>
	/// Gets or changes simple element id, also known as child id.
	/// </summary>
	/// <remarks>
	/// Most UI elements are not simple elements. Then this property is 0.
	/// Often (but not always) this property is the 1-based item index in parent. For example <c>LISTITEM</c> in <c>LIST</c>.
	/// The <c>set</c> function sometimes can be used as a fast alternative to <see cref="Navigate"/>. It modifies only this variable. It does not check whether the value is valid.
	/// Simple elements cannot have child elements.
	/// </remarks>
	public int Item { get => _elem; set { _misc.roleByte = 0; _elem = value; } }
	
	/// <summary>
	/// Returns some additional info about this variable, such as how the UI element was retrieved (inproc, UIA, Java).
	/// </summary>
	public EMiscFlags MiscFlags => _misc.flags;
	
	/// <summary>
	/// Gets or sets indentation level for <see cref="ToString"/>.
	/// </summary>
	/// <remarks>
	/// When <see cref="elmFinder.Find"/> or similar function finds a UI element, it sets this property of the <see cref="elm"/> variable. If <see cref="fromXY"/> etc, it is 0 (unknown).
	/// When searching in a window, at level 0 are direct children of the <c>WINDOW</c>. When searching in controls (specified class or id), at level 0 is the control. When searching in <see cref="elm"/>, at level 0 are its direct children. When searching in web page (role prefix <c>"web:"</c> etc), at level 0 is the web page (role <c>DOCUMENT</c> or <c>PANE</c>).
	/// </remarks>
	public int Level { get => _misc.level; set => _misc.SetLevel(value); }
	
	/// <summary>
	/// Returns <c>true</c> if this variable is disposed.
	/// </summary>
	bool _Disposed => _iacc == default;
	
	internal void ThrowIfDisposed_() {
		if (_Disposed) throw new ObjectDisposedException(nameof(elm));
		WarnInSendMessage_();
	}
	
	internal static void WarnInSendMessage_() {
		if (Api.InSendMessageBlocked) { //as fast as TickCount64
			long t = Environment.TickCount64;
			if (t - s_wismTime > 500) {
				s_wismTime = t;
				print.warning("elm functions may not work here. This code is called by another thread through SendMessage or is a low-level hook. Try workarounds: call ReplyMessage (Windows API); use an asynchronous way to call the elm function (timer, Dispatcher.InvokeAsync, etc); let that thread instead of SendMessage use an asynchronous function such as PostMessage.");
			}
		}
	}
	static long s_wismTime;
	
	/// <summary>
	/// Gets UI element of window or control. Or some its standard part - client area, titlebar etc.
	/// </summary>
	/// <param name="w">Window or control.</param>
	/// <param name="objid">Window part id. Default <c>EObjid.WINDOW</c>. Also can be a custom id supported by that window, cast <c>int</c> to <c>EObjid</c>.</param>
	/// <param name="flags">Flags.</param>
	/// <exception cref="AuWndException">Invalid window.</exception>
	/// <exception cref="AuException">Failed. For example, window of a higher [](xref:uac) integrity level process.</exception>
	/// <exception cref="ArgumentException"><i>objid</i> is <c>QUERYCLASSNAMEIDX</c> or <c>NATIVEOM</c>.</exception>
	/// <remarks>
	/// Uses API <ms>AccessibleObjectFromWindow</ms>.
	/// </remarks>
	public static elm fromWindow(wnd w, EObjid objid = EObjid.WINDOW, EWFlags flags = 0) {
		WarnInSendMessage_();
		
		bool spec = false;
		switch (objid) {
		case EObjid.QUERYCLASSNAMEIDX: //use WM_GETOBJECT
		case EObjid.NATIVEOM: //use API AccessibleObjectFromWindow
			throw new ArgumentException();
		case EObjid.CARET: //w should be 0
		case EObjid.CURSOR: //w should be 0
		case EObjid.ALERT: //only with AccessibleObjectFromEvent?
		case EObjid.SOUND: //only with AccessibleObjectFromEvent?
			spec = true; flags |= EWFlags.NotInProc;
			break;
		}
		
		var hr = Cpp.Cpp_AccFromWindow(flags.Has(EWFlags.NotInProc) ? 1 : 0, w, objid, out var a, out _);
		if (hr != 0) {
			if (flags.Has(EWFlags.NoThrow)) return null;
			if (spec && w.Is0) throw new AuException();
			w.ThrowIfInvalid();
			_WndThrow(hr, w, "*get UI element from window.");
		}
		return new elm(a);
	}
	
	static void _WndThrow(int hr, wnd w, string es) {
		w.UacCheckAndThrow_(es);
		throw new AuException(hr, es);
	}
	
	/// <summary>
	/// Gets UI element from point.
	/// </summary>
	/// <returns>Returns <c>null</c> if failed. Usually fails if the window is of a higher [](xref:uac) integrity level process. With some windows can fail occasionally.</returns>
	/// <param name="p">
	/// Coordinates.
	/// Tip: To specify coordinates relative to the right, bottom, work area or a non-primary screen, use <see cref="Coord.Normalize"/>, like in the example.
	/// </param>
	/// <param name="flags"></param>
	/// <example>
	/// Get UI element at 100 200.
	/// <code><![CDATA[
	/// var e = elm.fromXY((100, 200));
	/// print.it(e);
	/// ]]></code>
	/// 
	/// Get UI element at 50 from left and 100 from the bottom edge of the work area.
	/// <code><![CDATA[
	/// var e = elm.fromXY(Coord.Normalize(50, ^100, workArea: true));
	/// print.it(e);
	/// ]]></code>
	/// </example>
	public static elm fromXY(POINT p, EXYFlags flags = 0) {
		WarnInSendMessage_();
		return fromXY_(p, flags);
	}
	
	//used by fromXY and Delm
	internal static elm fromXY_(POINT p, EXYFlags flags, Cpp.Cpp_AccFromPointCallbackT callback = null) {
		wnd w = default;
		bool retry = false;
		gRetry:
		
		int hr = Cpp.Cpp_AccFromPoint(p, flags, (flags, wFP, wTL) => {
			w = wFP;
			if (callback is {  } cb) flags = cb(flags, wFP, wTL);
			
			if (osVersion.minWin8_1 ? !flags.Has(EXYFlags.NotInProc) : flags.Has(EXYFlags.UIA)) {
				bool dpiV = Dpi.IsWindowVirtualized(wTL);
				if (dpiV) flags |= Enum_.EXYFlags_DpiScaled;
			}
			return flags;
		}, out var a);
		
		if (hr != 0) return null;
		
		//workaround for Chrome bug. Sometimes DOCUMENT. Eg after scrolling. Also in some pages or page parts, eg LA home page when scrolled to the bottom. Same in all modes except acc notinproc.
		if (!retry && a.misc.roleByte == (byte)ERole.DOCUMENT && w.ClassNameIs("Chrome*")) {
			Marshal.Release(a.acc);
			retry = true;
			goto gRetry;
		}
		
		return new elm(a);
	}
	
	/// <inheritdoc cref="fromXY(POINT, EXYFlags)"/>
	public static elm fromXY(int x, int y, EXYFlags flags = 0) => fromXY(new POINT(x, y), flags);
	
	//rejected: FromXY(Coord, Coord, ...). Coord makes no sense.
	
	/// <summary>
	/// Gets UI element from mouse cursor (pointer) position.
	/// </summary>
	/// <param name="flags"></param>
	/// <exception cref="AuException">Failed. For example, window of a higher [](xref:uac) integrity level process.</exception>
	/// <remarks>
	/// Uses API <ms>AccessibleObjectFromPoint</ms>.
	/// </remarks>
	public static elm fromMouse(EXYFlags flags = 0) {
		return fromXY(mouse.xy, flags);
	}
	
	/// <summary>
	/// Gets the keyboard-focused UI element.
	/// </summary>
	/// <returns><c>null</c> if failed.</returns>
	public static elm focused(EFocusedFlags flags = 0) {
		WarnInSendMessage_();
		
		var w = wnd.focused;
		g1:
		if (w.Is0) return null;
		int hr = Cpp.Cpp_AccGetFocused(w, flags, out var a);
		if (hr != 0) {
			var w2 = wnd.focused;
			if (w2 != w) { w = w2; goto g1; }
			return null;
		}
		return new elm(a);
	}
	
	/// <summary>
	/// Gets the UI element that generated the event that is currently being processed by the callback function used with API <ms>SetWinEventHook</ms> or <see cref="WinEventHook"/>.
	/// </summary>
	/// <returns><c>null</c> if failed. Supports <see cref="lastError"/>.</returns>
	/// <param name="w"></param>
	/// <param name="idObject"></param>
	/// <param name="idChild"></param>
	/// <remarks>
	/// The parameters are of the callback function.
	/// Uses API <ms>AccessibleObjectFromEvent</ms>.
	/// Often fails because the UI element already does not exist, because the callback function is called asynchronously, especially when the event is <c>OBJECT_DESTROY</c>, <c>OBJECT_HIDE</c>, <c>SYSTEM_xEND</c>.
	/// Returns <c>null</c> if failed. Always check the return value, to avoid <see cref="NullReferenceException"/>. An exception in the callback function kills this process.
	/// </remarks>
	public static elm fromEvent(wnd w, EObjid idObject, int idChild) {
		int hr = Api.AccessibleObjectFromEvent(w, idObject, idChild, out var iacc, out var v);
		if (hr == 0 && iacc == default) hr = Api.E_FAIL;
		if (hr != 0) { lastError.code = hr; return null; }
		int elem = v.vt == Api.VARENUM.VT_I4 ? v.ValueInt : 0;
		return new elm(iacc, elem);
	}
	
#if false //rejected: not useful. Maybe in the future.
	/// <summary>
	/// Gets UI element from a COM object of any type that supports it.
	/// </summary>
	/// <returns><c>null</c> if failed.</returns>
	/// <param name="x">Unmanaged COM object.</param>
	/// <remarks>
	/// The COM object type can be <c>IAccessible</c>, <c>IAccessible2</c>, <c>IHTMLElement</c>, <c>ISimpleDOMNode</c> or any other COM interface type that can give <ms>IAccessible</ms> interface pointer through API <ms>IUnknown.QueryInterface</ms> or <ms>IServiceProvider.QueryService</ms>.
	/// For <c>IHTMLElement</c> and <c>ISimpleDOMNode</c> returns <c>null</c> if the HTML element is not an accessible object. Then you can try to get UI element of its parent HTML element, parent's parent and so on, until succeeds.
	/// </remarks>
	public static elm fromComObject(IntPtr x)
	{
		if(x == default) return null;
		if(MarshalUtil.QueryInterface(x, out IntPtr iacc, Api.IID_IAccessible)
			|| MarshalUtil.QueryService(x, out iacc, Api.IID_IAccessible)
			) return new elm(iacc);
		return null;
	}

	/// <summary>
	/// Gets UI element from a COM object of any type that supports it.
	/// Returns <c>null</c> if failed.
	/// </summary>
	/// <param name="x">Managed COM object.</param>
	/// <remarks>
	/// The COM object type can be <c>IAccessible</c>, <c>IAccessible2</c>, <c>IHTMLElement</c>, <c>ISimpleDOMNode</c> or any other COM interface type that can give <ms>IAccessible</ms> interface pointer through API <ms>IUnknown.QueryInterface</ms> or <ms>IServiceProvider.QueryService</ms>.
	/// For <c>IHTMLElement</c> and <c>ISimpleDOMNode</c> returns <c>null</c> if the HTML element is not an accessible object. Then you can try to get UI element of its parent HTML element, parent's parent and so on, until succeeds.
	/// </remarks>
	public static elm fromComObject(object x)
	{
		if(x == null) return null;

		//FUTURE: support UIA. Don't use LegacyIAccessible, it work not with all windows. Instead wrap in UIAccessible.
		//if(x is UIA.IElement e) { //info: IElement2-7 are IElement too
		//	var pat = e.GetCurrentPattern(UIA.PatternId.LegacyIAccessible) as UIA.ILegacyIAccessiblePattern;
		//	x = pat?.GetIAccessible();
		//	if(x == null) return null;
		//}

		var ip = Marshal.GetIUnknownForObject(x);
		if(ip == default) return null;
		try { return FromComObject(ip); }
		finally { Marshal.Release(ip); }
	}
#endif
	
	/// <summary>
	/// Used only for debug.
	/// </summary>
	enum _FuncId { name = 1, value, description, default_action, role, state, rectangle, parent_object, child_object, container_window, child_count, child_objects, help_text, keyboard_shortcut, html, selection, uiaid, uiacn }
	
	/// <summary>
	/// Calls <c>SetLastError</c> and returns <i>hr</i>.
	/// In Debug config also outputs error in red.
	/// If hr looks like not an error but just the property or action is unavailable, changes it to <c>S_FALSE</c> and does not show error. These are: <c>S_FALSE</c>, <c>DISP_E_MEMBERNOTFOUND</c>, <c>E_NOTIMPL</c>.
	/// <c>_FuncId</c> also can be <c>char</c>, like <c>(_FuncId)'n'</c> for name.
	/// </summary>
	int _Hresult(_FuncId funcId, int hr) {
		if (hr != 0) {
			switch (hr) {
			case Api.DISP_E_MEMBERNOTFOUND: case Api.E_NOTIMPL: hr = Api.S_FALSE; break;
			case (int)Cpp.EError.InvalidParameter: throw new ArgumentException("Invalid argument value.");
			default: Debug.Assert(!Cpp.IsCppError(hr)); break;
			}
#if DEBUG
			if (hr != Api.S_FALSE) {
				_DebugPropGet(funcId, hr);
			}
#endif
		}
		lastError.code = hr;
		return hr;
	}
	
#if DEBUG
	void _DebugPropGet(_FuncId funcId, int hr) {
		if (t_debugNoRecurse || _Disposed) return;
		
		if (funcId >= (_FuncId)'A') {
			switch ((char)funcId) {
			case 'R': funcId = _FuncId.role; break;
			case 'n': funcId = _FuncId.name; break;
			case 'v': funcId = _FuncId.value; break;
			case 'd': funcId = _FuncId.description; break;
			case 'h': funcId = _FuncId.help_text; break;
			case 'a': funcId = _FuncId.default_action; break;
			case 'k': funcId = _FuncId.keyboard_shortcut; break;
			case 's': funcId = _FuncId.state; break;
			case 'r': funcId = _FuncId.rectangle; break;
			case 'u': funcId = _FuncId.uiaid; break;
			case 'U': funcId = _FuncId.uiacn; break;
			}
		}
		
		if (hr == Api.E_FAIL && funcId == _FuncId.default_action) return; //many in old VS etc
		t_debugNoRecurse = true;
		try {
			var s = ToString();
			print.it($"<><c #ff>-{funcId}, 0x{hr:X} - {lastError.messageFor(hr)}    {s}</c>");
		}
		finally { t_debugNoRecurse = false; }
	}
	[ThreadStatic] static bool t_debugNoRecurse;
#endif
	
	/// <summary>
	/// Formats string from main properties of this UI element.
	/// </summary>
	/// <remarks>
	/// The string starts with role. Other properties have format like <c>x="value"</c>, where <c>x</c> is a property character like with <see cref="GetProperties"/>; character <c>e</c> is <see cref="Item"/>. HTML attributes have format <c>@name="value"</c>. In string values are used C# escape sequences, for example <c>\r\n</c> for new line.
	/// Indentation depends on <see cref="Level"/>.
	/// </remarks>
	public override string ToString() {
		if (_Disposed) return "<disposed>";
		if (!GetProperties("Rnsvdarw@", out var k)) return "<failed>";
		
		using (new StringBuilder_(out var b)) {
			if (Level > 0) b.Append(' ', Level);
			b.Append(k.Role);
			_Add('n', k.Name);
			if (k.State != 0) _Add('s', k.State.ToString(), '(', ')');
			_Add('v', k.Value);
			_Add('d', k.Description);
			_Add('a', k.DefaultAction);
			if (!k.Rect.Is0) _Add('r', k.Rect.ToString(), '\0', '\0');
			if (Item != 0) b.Append(",  e=").Append(Item);
			foreach (var kv in k.HtmlAttributes) {
				b.Append(",  @").Append(kv.Key).Append('=').Append('"');
				b.Append(kv.Value.Escape(limit: 250)).Append('"');
			}
			_Add('w', k.WndContainer.ClassName ?? "");
			
			void _Add(char name, string value, char q1 = '"', char q2 = '"') {
				if (value.Length == 0) return;
				var t = value; if (q1 == '"') t = t.Escape(limit: 250);
				b.Append(",  ").Append(name).Append('=');
				if (q1 != '\0') b.Append(q1);
				b.Append(t);
				if (q1 != '\0') b.Append(q2);
			}
			
			return b.ToString();
		}
	}
}


================================================
FILE: Au/UI objects/elmFinder.cs
================================================
namespace Au;

/// <summary>
/// Finds UI elements (<see cref="elm"/>). Contains name and other parameters of elements to find.
/// </summary>
/// <example>
/// Find link <c>"Example"</c> in web page, and click. Wait max 5 s. Exception if not found.
/// <code><![CDATA[
/// var w = wnd.find(0, "* Chrome");
/// w.Elm["web:LINK", "Example"].Find(5).Invoke();
/// ]]></code>
/// Find window that contains certain UI element, and get the UI element too.
/// <code><![CDATA[
/// var f = new elmFinder("BUTTON", "Apply"); //or var f = elm.path["BUTTON", "Apply"];
/// wnd w = wnd.find(cn: "#32770", also: t => f.In(t).Exists()); //or t => t.HasElm(f)
/// print.it(w);
/// print.it(f.Result);
/// ]]></code>
/// </example>
public unsafe class elmFinder {
	readonly string _role, _name, _prop, _navig;
	readonly EFFlags _flags;
	readonly int _skip;
	readonly Func<elm, bool> _also;
	Cpp.Cpp_AccFindCallbackT _also2;
	elmFinder _next;
	char _resultProp;
	wnd _wnd;
	elm _elm;

	/// <summary>
	/// The found UI element.
	/// <c>null</c> if not found or if used <see cref="ResultGetProperty"/>.
	/// </summary>
	public elm Result { get; private set; }

	/// <summary>
	/// The requested property of the found UI element, depending on <see cref="ResultGetProperty"/>.
	/// <c>null</c> if: 1. UI element not found. 2. <c>ResultGetProperty</c> not used or is <c>'-'</c>. 3. Failed to get the property.
	/// </summary>
	/// <remarks>
	/// The type depends on the property. Most properties are of type <c>String</c>. Others: <see cref="elm.Rect"/>, <see cref="elm.State"/>, <see cref="elm.WndContainer"/>, <see cref="elm.HtmlAttributes"/>.
	/// </remarks>
	public object ResultProperty { get; private set; }

	/// <summary>
	/// Set this when you need only some property of the UI element (name, etc) and not the UI element itself.
	/// The value is a character like with <see cref="elm.GetProperties"/>, for example <c>'n'</c> for <c>Name</c>. Use <c>'-'</c> if you don't need any property.
	/// </summary>
	/// <exception cref="ArgumentException">Used parameter <i>also</i>, <i>navig</i> or <i>next</i>.</exception>
	public char ResultGetProperty {
		set {
			if (_also != null) throw new ArgumentException("ResultGetProperty cannot be used with parameter 'also'.");
			if (_navig != null) throw new ArgumentException("ResultGetProperty cannot be used with parameter 'navig'.");
			if (_next != null) throw new ArgumentException("ResultGetProperty cannot be used with a path finder.");
			_resultProp = value;
		}
	}

	void _ClearResult() {
		Result = null;
		ResultProperty = null;
	}

	/// <summary>
	/// Stores the specified UI element properties in this object.
	/// </summary>
	/// <inheritdoc cref="this" path="//param|//remarks"/>
	public elmFinder(string role = null,
		[ParamString(PSFormat.Wildex)] string name = null,
		Strings prop = default, EFFlags flags = 0, Func<elm, bool> also = null,
		int skip = 0, string navig = null
		) {
		_role = role;
		_name = name;
		_prop = prop.Value switch { null => null, string s => s.Replace('|', '\0'), _ => string.Join('\0', prop.ToArray()) };
		_flags = flags;
		_also = also;
		_skip = skip >= -1 ? skip : throw new ArgumentOutOfRangeException(nameof(skip));
		_navig = navig;
	}

	internal elmFinder(wnd w, elm e) {
		_wnd = w;
		_elm = e;
		_flags = _EFFlags_Empty;
	}

	const EFFlags _EFFlags_Empty = (EFFlags)0x10000000;

	/// <summary>
	/// Creates an <see cref="elmFinder"/> for finding a UI element. Supports path like <c>var e = w.Elm["ROLE1", "Name1"]["ROLE2", "Name2"].Find();</c>.
	/// </summary>
	/// <returns>The new finder or the first finder in path.</returns>
	/// <param name="role">
	/// UI element role (<see cref="elm.Role"/>), like <c>"LINK"</c>.
	/// Can have prefix <c>"web:"</c>, <c>"firefox:"</c> or <c>"chrome:"</c> which means "search only in web page" and enables Chrome UI elements.
	/// Case-sensitive. Not wildcard. <c>null</c> means "can be any". Cannot be <c>""</c>.
	/// More info in Remarks.
	/// </param>
	/// <param name="name">
	/// UI element name (<see cref="elm.Name"/>).
	/// String format: [wildcard expression](xref:wildcard_expression).
	/// <c>null</c> means "any". <c>""</c> means "empty or unavailable".
	/// </param>
	/// <param name="prop">
	/// Other UI element properties and search settings.
	/// Examples: <c>"value=xxx|@href=yyy"</c>, <c>new("value=xxx", "@href=yyy")</c>.
	/// More info in Remarks.
	/// </param>
	/// <param name="flags"></param>
	/// <param name="also">
	/// Callback function. Called for each matching UI element. Let it return <c>true</c> if this is the wanted UI element.
	/// Example: the UI element must contain point x y: <c>o => o.GetRect(out var r, o.WndTopLevel) &amp;&amp; r.Contains(266, 33)</c>
	/// </param>
	/// <param name="skip">
	/// 0-based index of matching UI element to use. Will skip this number of matching elements.
	/// Value -1 means "any", and can be useful when this finder is intermediate (ie not the last) in a path or when it has <i>navig</i>. If intermediate, will search for next element in all matching intermediate elements. If has <i>navig</i>, will retry with other matching elements if fails to navigate in the first found. It is slower and not so often useful, therefore the default value of this parameter is 0, not -1.
	/// Cannot be used with <see cref="FindAll"/>, unless it is not in the last part of path.
	/// </param>
	/// <param name="navig">If not <c>null</c>, after finding the specified UI element will call <see cref="elm.Navigate"/> with this string and use its result instead of the found element.</param>
	/// <exception cref="ArgumentException"><i>flags</i> contains <c>UIA</c> or <c>ClientArea</c> when appending (only the first finder can have these flags).</exception>
	/// <remarks>
	/// To create code for this function, use tool <b>Find UI element</b>.
	/// 
	/// In [wildcard expression](xref:wildcard_expression) supports PCRE regular expressions (prefix <c>"**r "</c>) but not .NET regular expressions (prefix <c>"**R "</c>). They are similar.
	/// 
	/// When using path like <c>["ROLE1", "Name1"]["ROLE2", "Name2"]["ROLE3", "Name3"]</c>, multiple finders are linked like finder1 -> finder2 -> finder3, so that the chain of finders will find UI element specified by the last finder.
	/// 
	/// More info in <see cref="elm"/> topic.
	/// 
	/// <h5>About the <i>role</i> parameter</h5>
	/// 
	/// Can be standard role (see <see cref="ERole"/>) like <c>"LINK"</c> or custom role like <c>"div"</c>. See <see cref="elm.Role"/>.
	/// 
	/// Can have a prefix:
	/// - <c>"web:"</c> - search only in the visible web page, not in whole window. Example: <c>"web:LINK"</c>.\
	///   Supports Chrome, Firefox, Internet Explorer (IE) and apps that use same code (Edge, Opera...). With other windows, searches in the first found visible UI element that has <c>DOCUMENT</c> role.\
	///   Tip: To search only NOT in web pages, use <i>prop</i> <c>"notin=DOCUMENT"</c> (Chrome, Firefox) or <c>"notin=PANE"</c> (IE).
	/// - <c>"firefox:"</c> - search only in the visible web page of Firefox or Firefox-based web browser. If <i>w</i> window class name starts with <c>"Mozilla"</c>, can be used <c>"web:"</c> instead.
	/// - <c>"chrome:"</c> - search only in the visible web page of Chrome or Chrome-based web browser. If <i>w</i> window class name starts with <c>"Chrome"</c>, can be used <c>"web:"</c> instead.
	/// 
	/// <note>Chrome web page UI elements normally are disabled (don't exist). Use prefix <c>"web:"</c> or <c>"chrome:"</c> to enable.</note>
	/// 
	/// Prefix cannot be used:
	/// - if <i>prop</i> contains <c>"id"</c> or <c>"class"</c>;
	/// - with flags <c>UIA</c>, <c>ClientArea</c>;
	/// - when searching in <see cref="elm"/>.
	/// 
	/// <h5>About the <i>prop</i> parameter</h5>
	/// 
	/// Format: one or more <c>"name=value"</c> strings, like <c>new("key=xxx", "@href=yyy")</c> or <c>"key=xxx|@href=yyy"</c>. Names must match case. Values of most string properties are [wildcard expressions](xref:wildcard_expression).
	/// 
	/// - <c>"class"</c> - search only in child controls that have this class name (see <see cref="wnd.ClassName"/>).\
	///   Cannot be used when searching in a UI element.
	/// - <c>"id"</c> - search only in child controls that have this id (see <see cref="wnd.ControlId"/>). If the value is not a number - Windows Forms control name (see <see cref="wnd.NameWinforms"/>); case-sensitive, not wildcard.\
	///   Cannot be used when searching in a UI element.
	/// - <c>"value"</c> - <see cref="elm.Value"/>.
	/// - <c>"desc"</c> - <see cref="elm.Description"/>.
	/// - <c>"state"</c> - <see cref="elm.State"/>. List of states the UI element must have and/or not have.\
	///   Example: <c>"state=CHECKED, FOCUSABLE, !DISABLED"</c>.\
	///   Example: <c>"state=0x100010, !0x1"</c>.\
	///   Will find UI element that has all states without <c>"!"</c> prefix and does not have any of states with <c>"!"</c> prefix.
	/// - <c>"rect"</c> - <see cref="elm.GetRect(out RECT, bool)"/> with <i>raw</i> <c>true</c>. Can be specified left, top, width and/or height, using <see cref="RECT.ToString"/> format.\
	///   Example: <c>"rect={L=1155 T=1182 W=132 H=13}"</c>.
	///   Example: <c>"rect={W=132 T=1182}"</c>.
	///   The <c>L T</c> coordinates are relative to the primary screen.
	/// - <c>"level"</c> - level (see <see cref="elm.Level"/>) at which the UI element can be found. Can be exact level, or minimal and maximal level separated by space.\
	///   The default value is 0 1000.
	/// - <c>"item"</c> - <see cref="elm.Item"/>.
	/// - <c>"action"</c> - <see cref="elm.DefaultAction"/>.
	/// - <c>"key"</c> - <see cref="elm.KeyboardShortcut"/>.
	/// - <c>"help"</c> - <see cref="elm.Help"/>.
	/// - <c>"uiaid"</c> - <see cref="elm.UiaId"/>.
	/// - <c>"uiacn"</c> - <see cref="elm.UiaCN"/>.
	/// - <c>"url"</c> - URL of the container DOCUMENT in Chromium-based web browser. Used together with role prefix <c>"web:"</c> or <c>"chrome:"</c>. Use when the document is a side panel or developer tools or a special page like Settings. Don't need (but can be used too) when the document is a web page (URL starts with <c>"https:"</c>, <c>"http:"</c> or <c>"file:"</c>).
	/// - <c>"maxcc"</c> - when searching, skip children of UI elements that have more than this number of direct children. Default 10000, min 1, max 1000000.\
	///   It can make faster. It also prevents hanging or crashing when a UI element in the UI element tree has large number of children. For example OpenOffice Calc <c>TABLE</c> has one billion children.
	/// - <c>"notin"</c> - when searching, skip children of UI elements that have these roles. It can make faster.\
	///   Example: <c>"notin=TREE,LIST,TOOLBAR"</c>.\
	///   Roles in the list must be separated with <c>","</c> or <c>", "</c>. Case-sensitive, not wildcard. See also: <see cref="EFFlags.MenuToo"/>.
	/// - <c>"@attr"</c> - <see cref="elm.HtmlAttribute"/>. Here <c>"attr"</c> is any attribute name. Example: <c>"@href=example"</c>.
	/// </remarks>
	/// <seealso cref="elm.path"/>
	/// <seealso cref="Next"/>
	public elmFinder this[string role = null,
		[ParamString(PSFormat.Wildex)] string name = null,
		Strings prop = default, EFFlags flags = 0, Func<elm, bool> also = null,
		int skip = 0, string navig = null
		] {
		get {
			var f = new elmFinder(role, name, prop, flags, also, skip, navig);
			if (_flags == _EFFlags_Empty) { f._wnd = _wnd; f._elm = _elm; return f; }
			_Last().Next = f;
			return this;
		}
	}
	//rejected: default skip = -1. Rarely need.
	//	In some cases could find an unexpected element. Better to not find than to find (and click etc) wrong element.
	//	Instead the tool gives info to try -1 when not found or found wrong element.

	/// <summary>
	/// Gets or sets next finder in path (immediately after this finder).
	/// </summary>
	/// <exception cref="ArgumentException"><i>flags</i> contains <c>UIA</c> or <c>ClientArea</c>.</exception>
	/// <remarks>
	/// The setter creates or modifies a path (a chain of linked finders). Unlike <see cref="this"/>, which appends to the last finder in path, this function appends to this finder.
	/// </remarks>
	public elmFinder Next {
		get => _next;
		set {
			if (_flags.Has(_EFFlags_Empty)) throw new InvalidOperationException();
			if (value != _next) {
				if (value != null) {
					if (value._flags.HasAny(EFFlags.UIA | EFFlags.ClientArea)) throw new ArgumentException("Don't use flags UIA and ClientArea when searching in elm.");
				}
				_next = value;
				_also2 = null;
			}
		}
	}

	elmFinder _Last() {
		var n = this; while (n._next != null) n = n._next;
		return n;
	}

	/// <summary>
	/// Sets or changes window or control where <see cref="Find"/> etc will search.
	/// </summary>
	/// <returns>This.</returns>
	/// <seealso cref="elm.path"/>
	public elmFinder In(wnd w) {
		if (_flags.Has(_EFFlags_Empty)) throw new InvalidOperationException();
		_wnd = w;
		return this;
	}

	/// <summary>
	/// Sets or changes parent UI element where <see cref="Find"/> etc will search.
	/// </summary>
	/// <returns>This.</returns>
	/// <seealso cref="elm.path"/>
	public elmFinder In(elm e) {
		if (_flags.Has(_EFFlags_Empty)) throw new InvalidOperationException();
		_elm = e;
		return this;
	}

	/// <summary>
	/// Finds the first matching descendant UI element in the window or UI element.
	/// </summary>
	/// <returns>If found, returns <see cref="Result"/>, else <c>null</c>.</returns>
	/// <exception cref="ArgumentException">
	/// - <i>role</i> is <c>""</c> or invalid.
	/// - <i>name</i> is invalid wildcard expression (<c>"**options "</c> or regular expression).
	/// - <i>prop</i> contains unknown property names or errors in wildcard expressions.
	/// - <i>navig</i> string is invalid.
	/// - <i>flags</i> has <c>UIA</c> or <c>ClientArea</c> when searching in web page (role prefix <c>"web:"</c> etc) or <see cref="elm"/>.
	/// - <i>role</i> has a prefix (<c>"web:"</c> etc) when searching in <see cref="elm"/>.
	/// - <see cref="elm.Item"/> not 0 when searching in <see cref="elm"/>.
	/// </exception>
	/// <exception cref="AuWndException">Invalid window handle (0 or closed). See also <see cref="In(wnd)"/>.</exception>
	/// <exception cref="AuException">Failed. For example, window of a higher [](xref:uac) integrity level process.</exception>
	/// <remarks>
	/// To create code for this function, use tool <b>Find UI element</b>.
	/// 
	/// More info in <see cref="elm"/> topic.
	/// </remarks>
	/// <example>
	/// Find link <c>"Example"</c> in web page, and click. Wait max 5 s. Throw <see cref="NotFoundException"/> if not found.
	/// <code><![CDATA[
	/// var w = wnd.find(0, "* Chrome");
	/// w.Elm["web:LINK", "Example"].Find(5).Invoke();
	/// ]]></code>
	/// Try to find link <c>"Example"</c> in web page. Return if not found. Click if found.
	/// <code><![CDATA[
	/// var w = wnd.find(0, "* Chrome");
	/// var e = w.Elm["web:LINK", "Example"].Find();
	/// //var e = w.Elm["web:LINK", "Example"].Find(-5); //waits max 5 s
	/// if(e == null) { print.it("not found"); return; }
	/// e.Invoke();
	/// ]]></code>
	/// </example>
	public elm Find() => Exists() ? Result : null;

	/// <summary>
	/// Finds the first matching descendant UI element in the window or UI element. Can wait and throw <see cref="NotFoundException"/>.
	/// </summary>
	/// <returns>If found, returns <see cref="Result"/>. Else throws exception or returns <c>null</c> (if <i>wait</i> negative).</returns>
	/// <param name="wait">The wait timeout, seconds. If 0, does not wait. If negative, does not throw exception when not found.</param>
	/// <exception cref="NotFoundException" />
	/// <inheritdoc cref="Find()" path="/exception"/>
	public elm Find(Seconds wait) => Exists(wait) ? Result : null;

	/// <summary>
	/// Finds the first matching descendant UI element in the window or UI element. Like <see cref="Find"/>, just different return type.
	/// </summary>
	/// <returns>If found, sets <see cref="Result"/> and returns <c>true</c>, else <c>false</c>.</returns>
	/// <inheritdoc cref="Find()" path="/exception"/>
	public bool Exists() => Find_(_elm != null, _wnd, _elm);

	/// <summary>
	/// Finds the first matching descendant UI element in the window or UI element. Can wait and throw <see cref="NotFoundException"/>. Like <see cref="Find(Seconds)"/>, just different return type.
	/// </summary>
	/// <returns>If found, sets <see cref="Result"/> and returns <c>true</c>. Else throws exception or returns <c>false</c> (if <i>wait</i> negative).</returns>
	/// <inheritdoc cref="Find(Seconds)" path="//param|//exception"/>
	public bool Exists(Seconds wait) {
		if (Find_(_elm != null, _wnd, _elm, wait.Exists_() ? null : wait)) return true;
		return wait.ReturnFalseOrThrowNotFound_();
	}

	/// <summary>
	/// Waits for a matching descendant UI element to appear in the window or UI element.
	/// </summary>
	/// <returns>If found, returns <see cref="Result"/>. On timeout returns <c>null</c> if <i>timeout</i> is negative; else exception.</returns>
	/// <param name="timeout">Timeout, seconds. Can be 0 (infinite), >0 (exception) or &lt;0 (no exception). More info: [](xref:wait_timeout).</param>
	/// <exception cref="TimeoutException" />
	/// <remarks>
	/// Same as <see cref="Find(Seconds)"/>, except:
	/// - 0 timeout means infinite.
	/// - on timeout throws <see cref="TimeoutException"/>, not <see cref="NotFoundException"/>.
	/// </remarks>
	/// <inheritdoc cref="Find()" path="/exception"/>
	public elm Wait(Seconds timeout) => Find_(_elm != null, _wnd, _elm, timeout) ? Result : null;

	//CONSIDER: public bool WaitNot(Seconds timeout) => wait.until(timeout, () => !Exists());

	internal bool Find_(bool inElm, wnd w, elm eParent, Seconds? waitS = null, bool isNext = false, bool fromFindAll = false) {
		if (_flags.Has(_EFFlags_Empty) && !fromFindAll) throw new InvalidOperationException();
		if (_flags.Has(EFFlags.UIA | EFFlags.ClientArea)) throw new ArgumentException("Don't use flags UIA and ClientArea together.");
		if (_role != null) {
			if (_role == "") throw new ArgumentException("role cannot be \"\".");
			if (inElm && 0 != _role.Starts(false, "web:", "chrome:", "firefox:")) throw new ArgumentException("Don't use role prefix when searching in elm.");
		}

		Cpp.Cpp_Acc aParent; Cpp.Cpp_Acc* pParent = null;
		EFFlags flags = _flags;
		if (inElm) {
			if (!isNext) {
				if (_flags.HasAny(EFFlags.UIA | EFFlags.ClientArea)) throw new ArgumentException("Don't use flags UIA and ClientArea when searching in elm.");
				if (eParent == null) throw new ArgumentNullException();
				eParent.ThrowIfDisposed_();
				if (eParent.Item != 0) throw new ArgumentException("Item not 0.");
			}
			aParent = new(eParent); pParent = &aParent;
			if (!eParent.MiscFlags.Has(EMiscFlags.InProc)) flags |= EFFlags.NotInProc;
		} else {
			w.ThrowIfInvalid();
			aParent = default;
		}

		elm.WarnInSendMessage_();

		bool inProc = !flags.Has(EFFlags.NotInProc);

		_ClearResult();

		var ap = new Cpp.Cpp_AccFindParams(_role, _name, _prop, flags, Math.Max(0, _skip), _resultProp);

		if (!inElm) ap.RolePrefix(w); //converts role prefix to flags (C++ internal) and may enable Chrome AOs

		//if used skip<0 and path or navig, need to search in all possible paths. For it we use the 'also' callback.
		//FUTURE: optimize. Add part of code to the C++ dll. Now can walk same tree branches multiple times.
		Cpp.Cpp_AccFindCallbackT also = null;
		bool allPaths = _skip < 0 && (_next != null || _navig != null);
		bool findAll = t_findAll?.ContainsKey(this) == true; //in FindAll. This is the last finder in path.
		if (allPaths) {
			also = _also2 ??= (ca, _) => {
				var e = new elm(ca);
				if (!_AlsoNavigNext(ref e)) return 0;
				Result = e;
				return 1;
			};
		} else if (findAll) {
			also = (ca, _) => {
				var e = new elm(ca);
				_AlsoNavigNext(ref e);
				return 0;
			};
		} else {
			if (_also != null) also = _also2 ??= (ca, _) => _also(new elm(ca)) ? 1 : 0;
		}

		Seconds seconds = waitS ?? new(-1);
		seconds.Period ??= inProc ? 10 : 40;
		var loop = new WaitLoop(seconds);
		for (bool doneUAC = false, doneThread = false; ;) {
			var hr = Cpp.Cpp_AccFind(w, pParent, ap, also, out var ca, out string sResult);
			if (findAll) {
				GC.KeepAlive(also);
				if (hr == Cpp.EError.NotFound) return false;
				//else error. Cannot be 0.
			}

			if (hr == 0) {
				switch (_resultProp) {
				case '\0':
					if (!allPaths) {
						var e = new elm(ca);
						if (_AlsoNavigNext(ref e, noAlso: true)) Result = e; else hr = Cpp.EError.NotFound;
					}
					break;
				case 'r' or 'D' or 's' or 'w' or '@':
					if (sResult == null) break;
					unsafe {
						fixed (char* p = sResult) {
							switch (_resultProp) {
							case 'r' or 'D': ResultProperty = *(RECT*)p; break;
							case 's': ResultProperty = *(EState*)p; break;
							case 'w': ResultProperty = (wnd)(*(int*)p); break;
							case '@': ResultProperty = elm.AttributesToDictionary_(p, sResult.Length); break;
							}
						}
					}
					break;
				default:
					ResultProperty = sResult;
					break;
				}
				if (hr == 0) return true;
			}

			if (hr == Cpp.EError.InvalidParameter) throw new ArgumentException(sResult);
			if ((hr == Cpp.EError.WindowClosed) || (!w.Is0 && !w.IsAlive)) return false; //FUTURE: check if a is disconnected etc. Or then never wait.

			if (!doneUAC) {
				doneUAC = true;
				w.UacCheckAndThrow_(); //CONSIDER: don't throw. Maybe show warning.
			}

			//print.it(hr > 0 ? $"hr={hr}" : $"hr={(int)hr:X}");
			if (hr == Cpp.EError.NotFound) {
				if (waitS == null) return false;
			} else {
				Debug.Assert(!Cpp.IsCppError((int)hr));
				if (hr == (Cpp.EError)Api.RPC_E_SERVER_CANTMARSHAL_DATA && !_flags.Has(EFFlags.NotInProc))
					throw new AuException((int)hr, "For this UI element need flag NotInProc");
				throw new AuException((int)hr);
			}

			if (!doneThread) {
				doneThread = true;
				if (!w.Is0 && w.IsOfThisThread) return false;
			}

			if (!loop.Sleep()) return false;
			GC.KeepAlive(eParent);
		}
	}

	bool _AlsoNavigNext(ref elm e, bool noAlso = false) {
		if (!noAlso && _also != null && !_also(e)) return false;
		if (_navig != null) {
			var e2 = e.Navigate(_navig);
			if (e2 == null) return false;
			if (t_navigResult.need) t_navigResult = (true, e, e2);
			e = e2;
		}
		if (_next != null) {
			if (e.Item != 0) return false;
			if (!_next.Find_(true, default, e, isNext: true)) return false;
			e = _next.Result;
		} else if (t_findAll?.TryGetValue(this, out var a) == true) {
			a.Add(e);
			return false;
		}
		return true;
	}

	/// <summary>
	/// Finds all matching descendant UI elements in the window or UI element.
	/// </summary>
	/// <returns>Array of 0 or more elements.</returns>
	/// <example>
	/// <code><![CDATA[
	/// var w = wnd.find(1, "", "Shell_TrayWnd");
	/// print.it("---- buttons ----");
	/// print.it(w.Elm["BUTTON"].FindAll());
	/// print.it("---- all ----");
	/// print.it(w.Elm.FindAll());
	/// print.it("---- all buttons in elm at level 0 ----");
	/// var e = w.Elm["TOOLBAR", "Running applications"].Find();
	/// print.it(e.Elm["BUTTON", prop: "level=0"].FindAll());
	/// print.it("---- all in elm ----");
	/// print.it(e.Elm.FindAll());
	/// ]]></code>
	/// </example>
	/// <remarks>See <see cref="Find"/>.</remarks>
	/// <inheritdoc cref="Find" path="/exception"/>
	public elm[] FindAll() {
		var a = new List<elm>();
		var last = _Last();
		if (last._skip != 0) throw new ArgumentException("FindAll does not support *skip* in the last part of path");
		(t_findAll ??= new()).Add(last, a);
		try { Find_(_elm != null, _wnd, _elm, fromFindAll: true); }
		finally { t_findAll.Remove(last); }
		return a.ToArray();
	}

	//This dictionary is used to temporarily attach the List that collects FindAll results to the elmFinder.
	//	Another way - add a field to elmFinder and somehow make it thread-safe. But elmFinder is immutable.
	[ThreadStatic] static Dictionary<elmFinder, List<elm>> t_findAll;

	internal static List<(elm, RECT)> GetAllWithRect_(wnd w, EFFlags flags) {
		List<(elm, RECT)> a = [];

		Cpp.Cpp_AccFindCallbackT also = (ca, rect) => {
			var e = new elm(ca);
			a.Add((e, *rect));
			return 0;
		};
		
		var ap = new Cpp.Cpp_AccFindParams(null, null, null, flags, 0, default);
		Cpp.Cpp_AccFind(w, null, ap, also, out var ca, out string sResult, getRects: true);
		GC.KeepAlive(also);
		return a;
		
		//TODO2: try async. Let the in-proc code return immediately and later post results.
		//	Alternatively can use CoMarshalInterThreadInterfaceInStream, but it makes ~50% slower if need to marshal all. Maybe can optimize to marshal only some.
		//TODO2: add `elm.MarshalToThisThread`.
		//TODO2: (heavy change) maybe instead of `IAccessible` use a UIA element. Wrap acc in it like now uia in acc.
		//	Why: UIA elements are free-threaded (unlike acc).
		//	Why: maybe then easier to wrap more UIA API.
		//	Or some way to avoid passing COM objects to this process.
	}

	///
	public override string ToString() {
		using (new StringBuilder_(out var b)) {
			for (var n = this; n != null; n = n._next) n._ToString(b);
			return b.ToString();
		}
	}

	void _ToString(StringBuilder b) {
		b.Append('[');
		int n = 0;
		_Add(0, null, _role);
		_Add(1, "name", _name);
		_Add(2, "prop", _prop?.Replace('\0', '|'));
		if (_flags != 0) _Add(3, "flags", _flags.ToString(), false);
		if (_also != null) _Add(4, "also", "...", false);
		if (_skip != 0) _Add(5, "skip", _skip.ToString(), false);
		_Add(6, "navig", _navig);
		b.Append(']');

		void _Add(int i, string name, string value, bool isString = true) {
			if (value == null) return;
			if (n > 0) b.Append(", ");
			if (i > n++) b.Append(name).Append(": ");
			if (isString) value = value.Escape(limit: 50, quote: true);
			b.Append(value);
		}
	}

	[ThreadStatic] internal static (bool need, elm before, elm after) t_navigResult;

	//rejected. Rarely used. Maybe in the future, but different API, maybe ...In(controls).Find(), and move the code into _Find.
	///// <summary>
	///// Finds UI element in the specified control of window <i>w</i>.
	///// </summary>
	///// <returns>If found, returns <see cref="Result"/>, else <c>null</c>.</returns>
	///// <param name="w">Window that contains the control.</param>
	///// <param name="controls">Control properties. This functions searches in all matching controls.</param>
	///// <exception cref="Exception">Exceptions of <see cref="Find(wnd)"/>.</exception>
	///// <remarks>
	///// Functions <c>Find</c> and <c>Exists</c> differ only in their return types.
	///// 
	///// Alternatively you can specify control class name or id in role. How this function is different: 1. Allows to specify more control properties. 2. Works better/faster when the control is of a different process or thread than the parent window; else slightly slower.
	///// </remarks>
	//public elm Find(wnd w, wndChildFinder controls) => Exists(w, controls) ? Result : null;

	///// <returns>If found, sets <see cref="Result"/> and returns <c>true</c>, else <c>false</c>.</returns>
	///// <inheritdoc cref="Find(wnd, wndChildFinder)"/>
	//public bool Exists(wnd w, wndChildFinder controls) {
	//	w.ThrowIfInvalid();
	//	foreach (var c in controls.FindAll(w)) {
	//		try {
	//			if (_Find(false, c, null)) {
	//				controls.Result = c;
	//				return true;
	//			}
	//		}
	//		catch (AuException ex) when (!c.IsAlive) { Debug_.Print(ex); } //don't throw AuWndException/AuException if the window or a control is destroyed while searching, but throw AuException if eg access denied
	//	}
	//	return false;
	//}

	//rejected. Better slightly longer code than unclear and possibly ambiguous code where you have to learn string parsing rules.
	//public static implicit operator elmFinder(string roleNameProp) {
	//	if (roleNameProp.NE()) throw new ArgumentException();
	//	int i = roleNameProp.FindAny(",\0");
	//	if (i < 0) return new(roleNameProp);
	//	var a = roleNameProp.Split(roleNameProp[i], 3);
	//	return new(a[0].Length > 0 ? a[0] : null, a[1], a.Length < 3 ? null : a[2]);
	//}
}

partial class elm {
	/// <summary>
	/// Gets an <see cref="elmFinder"/> for finding UI elements in a window or UI element that can be set later with <see cref="elmFinder.In"/>.
	/// Example: <c>var e = elm.path["ROLE", "Name"].In(w).Find();</c>. Same as <c>var e = w.Elm["ROLE", "Name"].Find();</c>.
	/// Example: <c>var e = elm.path["ROLE1", "Name1"]["ROLE2", "Name2"]["ROLE3", "Name3"].In(w).Find();</c>.
	/// </summary>
	/// <seealso cref="elmFinder.this"/>
	public static elmFinder path { get; } = new(default, null);

	/// <summary>
	/// Gets an <see cref="elmFinder"/> for finding UI elements in this UI element.
	/// Example: <c>var e2 = e1.Elm["ROLE", "Name"].Find();</c>.
	/// Example: <c>var e2 = e1.Elm["ROLE1", "Name1"]["ROLE2", "Name2"]["ROLE3", "Name3"].Find();</c>.
	/// Example: <c>print.it(e.Elm.FindAll());</c>.
	/// </summary>
	public elmFinder Elm => new(default, this);
}

public partial struct wnd {
	/// <summary>
	/// Gets an <see cref="elmFinder"/> for finding UI elements in this window or control.
	/// Example: <c>var e = w.Elm["ROLE", "Name"].Find();</c>.
	/// Example: <c>var e = w.Elm["ROLE1", "Name1"]["ROLE2", "Name2"]["ROLE3", "Name3"].Find();</c>.
	/// Example: <c>print.it(w.Elm.FindAll());</c>.
	/// </summary>
	public elmFinder Elm => new(this, null);

	//public static wndFinder f_(
	//	[ParamString(PSFormat.wildex)] string name = null,
	//	[ParamString(PSFormat.wildex)] string cn = null,
	//	[ParamString(PSFormat.wildex)] WOwner of = default,
	//	WFlags flags = 0, Func<wnd, bool> also = null, WContains contains = default
	//	) => new(name, cn, of, flags, also, contains);

	//public wnd this[
	//	[ParamString(PSFormat.wildex)] string name = null,
	//	[ParamString(PSFormat.wildex)] string cn = null,
	//	int? id = null, WCFlags flags = 0, Func<wnd, bool> also = null, int skip = 0,
	//	] {
	//	get => Child(name, cn, k, also, skip);
	//}
}


================================================
FILE: Au/UI objects/elm_func.cs
================================================
//FUTURE: ChildFromXY. Like wnd.ChildFromXY. Use IAccessible.accHitTest.

namespace Au {
	public unsafe partial class elm {
		/// <summary>
		/// Gets the container window or control of this UI element.
		/// </summary>
		/// <returns><c>default(wnd)</c> if failed. Supports <see cref="lastError"/>.</returns>
		/// <remarks>
		/// All UI elements must support this property, but some have bugs and can fail or return a wrong window.
		/// Uses API <ms>WindowFromAccessibleObject</ms>.
		/// </remarks>
		public wnd WndContainer {
			get {
				ThrowIfDisposed_();
				_Hresult(_FuncId.container_window, _GetWnd(out var w));
				return w;
			}
		}
		
		/// <summary>
		/// Low-level version of <see cref="WndContainer"/>. Does not call <c>ThrowIfDisposed_</c> and <c>_Hresult</c> (<c>lastError</c>).
		/// </summary>
		/// <returns><c>HRESULT</c></returns>
		int _GetWnd(out wnd w) {
			int hr = Cpp.Cpp_AccGetInt(this, 'w', out var i);
			GC.KeepAlive(this);
			w = (wnd)i;
			return hr;
		}
		
		/// <summary>
		/// Gets the top-level window that contains this UI element.
		/// </summary>
		/// <returns><c>default(wnd)</c> if failed. Supports <see cref="lastError"/>.</returns>
		/// <remarks>
		/// All UI elements must support this property, but some have bugs and can return <c>default(wnd)</c>.
		/// Uses API <ms>WindowFromAccessibleObject</ms> and API <ms>GetAncestor</ms>.
		/// </remarks>
		public wnd WndTopLevel => WndContainer.Window;
		//note: named not WndWindow, to avoid using accidentally instead of WndContainer.
		
		/// <summary>
		/// Gets location of this UI element in screen.
		/// </summary>
		/// <returns>Empty rectangle if failed or this property is unavailable. Supports <see cref="lastError"/>.</returns>
		/// <remarks>
		/// Calls <see cref="GetRect(out RECT, bool)"/>.
		/// Most but not all UI elements support this property.
		/// </remarks>
		public RECT Rect { get { GetRect(out var r); return r; } }
		
		internal RECT RectRawDpi_ { get { GetRect(out var r, true); return r; } }
		
		/// <summary>
		/// Gets location of this UI element in screen.
		/// </summary>
		/// <returns><c>false</c> if failed or this property is unavailable. Supports <see cref="lastError"/>.</returns>
		/// <param name="r">Rectangle in screen coordinates.</param>
		/// <param name="raw">
		/// Don't DPI-scale. When the element is in a DPI-scaled/virtualized window (see <see cref="Dpi.IsWindowVirtualized"/>), the raw rectangle may not match the visible rectangle.
		/// This parameter is ignored on Windows 7 and 8.0 or if this element was retrieved not in-process.
		/// </param>
		/// <remarks>
		/// Most but not all UI elements support this property.
		/// </remarks>
		public bool GetRect(out RECT r, bool raw = false) {
			ThrowIfDisposed_();
			if (!raw && MiscFlags.Has(EMiscFlags.InProc) && osVersion.minWin8_1) {
				if (!GetProperties("D", out var p)) { r = default; return false; }
				r = p.Rect;
			} else {
				var hr = _Hresult(_FuncId.rectangle, Cpp.Cpp_AccGetRect(this, out r));
				GC.KeepAlive(this);
				if (hr != 0) return false;
			}
			return true;
		}
		
		/// <summary>
		/// Gets location of this UI element in the client area of window <i>w</i>.
		/// </summary>
		/// <returns><c>false</c> if failed or this property is unavailable. Supports <see cref="lastError"/>.</returns>
		/// <param name="r">Receives rectangle in <i>w</i> client area coordinates.</param>
		/// <param name="w">Window or control.</param>
		/// <param name="intersect">Intersect the rectangle with the <i>w</i> client area, possibly making it smaller or empty.</param>
		/// <remarks>
		/// Most but not all UI elements support this property.
		/// Uses <see cref="GetRect(out RECT, bool)"/> and <see cref="wnd.MapScreenToClient(ref RECT)"/>.
		/// </remarks>
		public bool GetRect(out RECT r, wnd w, bool intersect = false) {
			if (!(GetRect(out r) && w.MapScreenToClient(ref r))) return false;
			if (intersect) r.Intersect(_GetContainerClientRect(w));
			return true;
			
			RECT _GetContainerClientRect(wnd w) {
				var rc = w.ClientRect;
				//if w is a classic listview in report view, exclude header
				if (Item > 0 && RoleInt == ERole.LISTITEM) {
					var h = w.ChildFast(null, "SysHeader32");
					if (h.IsVisible) rc.top = h.Rect.Height;
				}
				return rc;
			}
		}
		
		/// <summary>
		/// Gets role as enum <see cref="ERole"/>.
		/// </summary>
		/// <returns>0 (<c>ERole.None</c>) if failed. Supports <see cref="lastError"/>.</returns>
		/// <remarks>
		/// Most UI elements have a standard role, defined in enum <see cref="ERole"/> (except <c>None</c> and <c>Custom</c>). Some UI elements have a custom role, usually as string; then returns <c>ERole.Custom</c>.
		/// All UI elements must support this property. If failed, probably the <see cref="elm"/> is invalid, for example the window is closed.
		/// </remarks>
		public ERole RoleInt {
			get {
				ThrowIfDisposed_();
				if (_misc.roleByte != 0) return (ERole)_misc.roleByte;
				_Hresult(_FuncId.role, _GetRole(out var role, out _, dontNeedStr: true));
				//Debug_.Print("roleByte 0 -> " + role + ", " + Role); //it's OK in some cases, eg when retrieved not inproc, or after navigating or changing simpleelementid
				return role;
			}
		}
		
		/// <summary>
		/// Like <see cref="RoleInt"/>, but returns 0 if int role not available (does not go to get it).
		/// </summary>
		internal ERole RoleInt_ => (ERole)_misc.roleByte;
		
		/// <summary>
		/// Gets standard or custom role, as string.
		/// </summary>
		/// <returns><c>""</c> if failed. Supports <see cref="lastError"/>.</returns>
		/// <remarks>
		/// Most UI elements have a standard role, defined in enum <see cref="ERole"/> (except <c>None</c> and <c>Custom</c>). Some UI elements have a custom role, usually as string.
		/// For standard roles this function returns enum <see cref="ERole"/> member name. For string roles - the string. For unknown non-string roles - the <c>int</c> value like <c>"0"</c> or <c>"500"</c>.
		/// All UI elements must support this property. If failed, probably the <see cref="elm"/> is invalid, for example the window is closed.
		/// </remarks>
		public string Role {
			get {
				ThrowIfDisposed_();
				var role = (ERole)_misc.roleByte;
				if (role is 0 or ERole.Custom) {
					if (0 != _Hresult(_FuncId.role, _GetRole(out role, out var roleStr, dontNeedStr: false))) return "";
					if (roleStr != null) return roleStr;
				}
				var a = s_roles; uint u = (uint)role;
				return (u < a.Length) ? a[u] : ((int)role).ToString();
			}
		}
		
		static readonly string[] s_roles = { "0", "TITLEBAR", "MENUBAR", "SCROLLBAR", "GRIP", "SOUND", "CURSOR", "CARET", "ALERT", "WINDOW", "CLIENT", "MENUPOPUP", "MENUITEM", "TOOLTIP", "APPLICATION", "DOCUMENT", "PANE", "CHART", "DIALOG", "BORDER", "GROUPING", "SEPARATOR", "TOOLBAR", "STATUSBAR", "TABLE", "COLUMNHEADER", "ROWHEADER", "COLUMN", "ROW", "CELL", "LINK", "HELPBALLOON", "CHARACTER", "LIST", "LISTITEM", "TREE", "TREEITEM", "PAGETAB", "PROPERTYPAGE", "INDICATOR", "IMAGE", "STATICTEXT", "TEXT", "BUTTON", "CHECKBOX", "RADIOBUTTON", "COMBOBOX", "DROPLIST", "PROGRESSBAR", "DIAL", "HOTKEYFIELD", "SLIDER", "SPINBUTTON", "DIAGRAM", "ANIMATION", "EQUATION", "BUTTONDROPDOWN", "BUTTONMENU", "BUTTONDROPDOWNGRID", "WHITESPACE", "PAGETABLIST", "CLOCK", "SPLITBUTTON", "IPADDRESS", "TREEBUTTON" };
		
		//Returns HRESULT.
		int _GetRole(out ERole roleInt, out string roleStr, bool dontNeedStr) {
			roleStr = null;
			Debug.Assert((ERole)_misc.roleByte is 0 or ERole.Custom);
			var hr = Cpp.Cpp_AccGetRole(this, out roleInt, out var b);
			if (hr == 0) {
				if (!b.Is0) {
					roleInt = ERole.Custom;
					if (dontNeedStr) b.Dispose(); else roleStr = b.ToStringAndDispose();
				}
				_misc.SetRole(roleInt);
			}
			return hr;
		}
		
		int _GetState(out EState state) {
			int hr = Cpp.Cpp_AccGetInt(this, 's', out int i);
			GC.KeepAlive(this);
			state = (EState)i;
			return hr;
		}
		
		/// <summary>
		/// Gets UI element state (flags).
		/// </summary>
		/// <returns>0 if failed. Supports <see cref="lastError"/>.</returns>
		/// <example>
		/// <code><![CDATA[
		/// if(e.State.Has(EState.INVISIBLE)) print.it("has state INVISIBLE");
		/// if(e.IsInvisible) print.it("invisible");
		/// ]]></code>
		/// </example>
		public EState State {
			get {
				ThrowIfDisposed_();
				_Hresult(_FuncId.state, _GetState(out var state));
				return state;
			}
		}
		
		/// <summary>Calls <see cref="State"/> and returns <c>true</c> if has state <c>CHECKED</c>.</summary>
		public bool IsChecked => State.Has(EState.CHECKED);
		
		/// <summary>Calls <see cref="State"/> and returns <c>true</c> if has state <c>CHECKED</c>, <c>null</c> if has state <c>MIXED</c>, else <c>false</c>. Use this function with 3-state checkboxes.</summary>
		public bool? IsChecked2 => (State & (EState.CHECKED | EState.MIXED)) switch { EState.CHECKED => true, 0 => false, _ => null };
		
		/// <summary>Calls <see cref="State"/> and returns <c>true</c> if has state <c>UNAVAILABLE</c>.</summary>
		/// <remarks>Does not check whether this UI element is in a disabled parent/ancestor UI element.</remarks>
		public bool IsDisabled => State.Has(EState.DISABLED);
		
		/// <summary>Calls <see cref="State"/> and returns <c>true</c> if has state <c>FOCUSED</c>.</summary>
		public bool IsFocused => State.Has(EState.FOCUSED);
		
		/// <summary>Calls <see cref="State"/> and returns <c>true</c> if has state <c>INVISIBLE</c> and does not have state <c>OFFSCREEN</c>.</summary>
		/// <remarks>
		/// If the UI element has both <c>INVISIBLE</c> and <c>OFFSCREEN</c> states, it is either invisible or just offscreen, depending on application etc. Then this function works like <see cref="elmFinder.Find"/> and similar functions: for most UI elements returns <c>false</c> (is visible), but for UI elements that have these roles returns <c>true</c> (invisible): <c>WINDOW</c>, <c>DOCUMENT</c>, <c>PROPERTYPAGE</c>, <c>GROUPING</c>, <c>ALERT</c>, <c>MENUPOPUP</c>.
		/// Does not check whether this UI element is in an invisible parent/ancestor UI element.
		/// </remarks>
		public bool IsInvisible => IsInvisible_(State);
		
		internal bool IsInvisible_(EState state) {
			if (!state.Has(EState.INVISIBLE)) return false;
			if (!state.Has(EState.OFFSCREEN)) return true;
			switch (RoleInt) {
			case ERole.WINDOW:
			case ERole.DOCUMENT:
			case ERole.PROPERTYPAGE:
			case ERole.GROUPING:
			case ERole.ALERT:
			case ERole.MENUPOPUP:
				return true;
				//note: these roles must be the same as in _IsRoleToSkipIfInvisible in "acc find.cpp"
			}
			return false;
		}
		
		/// <summary>Calls <see cref="State"/> and returns <c>true</c> if has state <c>OFFSCREEN</c>.</summary>
		public bool IsOffscreen => State.Has(EState.OFFSCREEN);
		
		/// <summary>Calls <see cref="State"/> and returns <c>true</c> if has state <c>PROTECTED</c>.</summary>
		/// <remarks>This state is used for password fields.</remarks>
		public bool IsPassword => State.Has(EState.PROTECTED);
		
		/// <summary>Calls <see cref="State"/> and returns <c>true</c> if has state <c>PRESSED</c>.</summary>
		public bool IsPressed => State.Has(EState.PRESSED);
		
		/// <summary>Calls <see cref="State"/> and returns <c>true</c> if has state <c>READONLY</c>.</summary>
		public bool IsReadonly => State.Has(EState.READONLY);
		
		/// <summary>Calls <see cref="State"/> and returns <c>true</c> if has state <c>SELECTED</c>.</summary>
		public bool IsSelected => State.Has(EState.SELECTED);
		
		/// <summary>
		/// Converts <c>BSTR</c> to string and disposes the <c>BSTR</c>.
		/// If hr is not 0, returns <c>""</c> (never <c>null</c>).
		/// </summary>
		static string _BstrToString(int hr, BSTR b) {
			if (hr == 0) return b.ToStringAndDispose() ?? "";
			return "";
		}
		
		string _GetStringProp(char prop) {
			ThrowIfDisposed_();
			int hr = Cpp.Cpp_AccGetStringProp(this, prop, out var b);
			GC.KeepAlive(this);
			var s = _BstrToString(hr, b);
			_Hresult((_FuncId)prop, hr);
			return s;
		}
		
		static string _GetStringPropL(Cpp.Cpp_Acc a, char prop) {
			int hr = Cpp.Cpp_AccGetStringProp(a, prop, out var b);
			return _BstrToString(hr, b);
		}
		
		/// <summary>
		/// Gets name.
		/// </summary>
		/// <returns><c>""</c> if name is unavailable or if failed. Supports <see cref="lastError"/>.</returns>
		/// <remarks>
		/// UI element name usually is its read-only text (eg button text, link text), or its adjacent read-only text (eg text label by this edit box). It usually does not change, therefore can be used to find or identify the UI element.
		/// </remarks>
		public string Name {
			get => _GetStringProp('n');
			
			//note: bug of standard toolbar buttons: fails to get name if all these are true:
			//	This process is 64-bit and the target process is 32-bit.
			//	Button Name property comes from its tooltip.
			//	Found not inproc, eg with flag NotInProc.
		}
		
		/// <summary>
		/// Gets <see cref="Name"/> of window/control <i>w</i>.
		/// Returns <c>null</c> if <i>w</i> invalid. Returns <c>""</c> if failed to get name.
		/// </summary>
		internal static string NameOfWindow_(wnd w) {
			if (!w.IsAlive) return null;
			var hr = Cpp.Cpp_AccFromWindow(1 | 2, w, 0, out _, out var b);
			return _BstrToString(hr, b);
			
			//speed: inproc ~10% faster. But first time slower, especially if process of different bitness.
		}
		
		/// <summary>
		/// Gets or sets value.
		/// </summary>
		/// <exception cref="AuException">Failed to set value.</exception>
		/// <remarks>
		/// Usually it is editable text or some other value that can be changed at run time, therefore in most cases it cannot be used to find or identify the UI element reliably.
		/// The <c>get</c> function returns <c>""</c> if this property is unavailable or if failed. Supports <see cref="lastError"/>.
		/// Most UI elements don't support <c>set</c>.
		/// </remarks>
		public string Value {
			get => _GetStringProp('v');
			set {
				ThrowIfDisposed_();
				AuException.ThrowIfHresultNot0(_InvokeL('v', value));
			}
		}
		
		/// <summary>
		/// Gets description.
		/// </summary>
		/// <returns><c>""</c> if this property is unavailable or if failed. Supports <see cref="lastError"/>.</returns>
		public string Description {
			get => _GetStringProp('d');
		}
		
		/// <summary>
		/// Gets help text.
		/// </summary>
		/// <returns><c>""</c> if this property is unavailable or if failed. Supports <see cref="lastError"/>.</returns>
		public string Help {
			get => _GetStringProp('h');
		}
		
		/// <summary>
		/// Gets the UI Automation <c>AutomationId</c> property.
		/// </summary>
		/// <returns><c>""</c> if this property is unavailable or if failed. Supports <see cref="lastError"/>.</returns>
		/// <remarks>
		/// Only UI elements found with flag <see cref="EFFlags.UIA"/> can have this property.
		/// </remarks>
		public string UiaId {
			get => _GetStringProp('u');
		}
		
		/// <summary>
		/// Gets the UI Automation <c>ClassName</c> property.
		/// </summary>
		/// <returns><c>""</c> if this property is unavailable or if failed. Supports <see cref="lastError"/>.</returns>
		/// <remarks>
		/// Only UI elements found with flag <see cref="EFFlags.UIA"/> can have this property.
		/// </remarks>
		public string UiaCN {
			get => _GetStringProp('U');
		}
		
		/// <summary>
		/// Gets keyboard shortcut.
		/// </summary>
		/// <returns><c>""</c> if this property is unavailable or if failed. Supports <see cref="lastError"/>.</returns>
		public string KeyboardShortcut {
			get => _GetStringProp('k');
		}
		
		/// <summary>
		/// Gets default action of <see cref="Invoke"/>.
		/// </summary>
		/// <returns><c>""</c> if this property is unavailable or if failed. Supports <see cref="lastError"/>.</returns>
		/// <remarks>
		/// If this is a Java UI element, returns all actions that can be used with <see cref="JavaInvoke"/>, like <c>"action1, action2, action3"</c>, from which the first is considered default and is used by <see cref="Invoke"/>.
		/// Note: the string is supposed to be localized, ie depends on UI language; except Java.
		/// </remarks>
		public string DefaultAction {
			get => _GetStringProp('a');
		}
		
		/// <summary>
		/// Performs the UI element's default action (see <see cref="DefaultAction"/>). Usually it is "click", "press" or similar. Like a mouse click but without moving the mouse cursor or pressing mouse buttons.
		/// </summary>
		/// <exception cref="AuException">Failed.</exception>
		/// <remarks>
		/// Fails if the UI element does not have a default action. Then you can use <see cref="MouseClick"/>, or try <see cref="PostClick"/>, <see cref="Check"/>, <see cref="SendKeys"/>, other functions.
		/// The action can take long time, for example show a dialog. This function normally does not wait. It allows the caller to automate the dialog. If it waits, try <see cref="JavaInvoke"/> or one of the above functions (<see cref="MouseClick"/> etc).
		/// </remarks>
		public void Invoke() {
			ThrowIfDisposed_();
			_Invoke();
		}
		
		/// <summary>
		/// Calls <c>_InvokeL</c>, with <c>ButtonPostClickWorkaround_</c> if need. Exception if failed.
		/// </summary>
		void _Invoke(char action = 'a', string param = null, string errMsg = null) {
			int hr;
			if (!MiscFlags.HasAny(EMiscFlags.UIA | EMiscFlags.Java) && RoleInt is ERole.BUTTON or ERole.SPLITBUTTON or ERole.CHECKBOX or ERole.RADIOBUTTON) {
				using var workaround = new mouse.ButtonPostClickWorkaround_(WndContainer);
				hr = _InvokeL(action, param);
			} else {
				hr = _InvokeL(action, param);
			}
			AuException.ThrowIfHresultNot0(hr, errMsg);
			//_MinimalSleep(); //don't need. It does not make more reliable.
		}
		
		/// <summary>
		/// Calls <c>EnableActivate(-1)</c> and <c>Cpp_AccAction</c>.
		/// </summary>
		/// <returns><c>HRESULT</c></returns>
		int _InvokeL(char action = 'a', string param = null) {
			//UIA bug: if window inactive, in some cases tries to activate, and waits ~10 s if failed.
			//	Eg ExpandCollapse pattern (always) and Invoke/Toggle patterns (buttons/checkboxes, not always).
			//	Non-UIA servers also could try to activate, although now I don't remember such cases.
			WndUtil.EnableActivate(-1); //usually quite fast, and often faster than WndContainer
			
			int hr = Cpp.Cpp_AccAction(this, action, param);
			GC.KeepAlive(this);
			return hr;
		}
		
		//void _MinimalSleep()
		//{
		//	Thread.Sleep(15);
		//	//if(0 == _iacc.GetWnd(out var w)) w.MinimalSleepIfOtherThread_(); //better don't call getwnd
		//}
		
		/// <summary>
		/// Performs one of actions supported by this Java UI element.
		/// </summary>
		/// <param name="action">
		/// Action name. See <see cref="DefaultAction"/>.
		/// If <c>null</c> (default), performs default action (like <see cref="Invoke"/>) or posts <c>Space</c> key message. More info in Remarks.</param>
		/// <exception cref="AuException">Failed.</exception>
		/// <remarks>
		/// Read more about Java UI elements in <see cref="elm"/> topic.
		/// 
		/// Problem: if the action opens a dialog, <see cref="Invoke"/>/<see cref="JavaInvoke"/> do not return until the dialog is closed (or fail after some time). The caller then waits and cannot automate the dialog. Also then this process cannot exit until the dialog is closed. If the action parameter is <c>null</c> and the UI element is focusable, this function tries a workaround: it makes the UI element (button etc) focused and posts <c>Space</c> key message, which should press the button; then this function does not wait.
		/// </remarks>
		public void JavaInvoke(string action = null) {
			//problem: if the button click action opens a modal dialog, doAccessibleActions waits until closed.
			//	Waits 8 s and then returns true. Somehow in QM2 returns false.
			//	During that time any JAB calls (probably from another thread) are blocked and fail. Tried various combinations.
			//	Also then releaseJavaObject does not return until the dialog closed. It even does not allow our process to exit. In QM2 the same.
			//	Previously (with old Java version?) then whole JAB crashed. Now doesn't. Or crashes only in some conditions that I now cannot reproduce.
			
			ThrowIfDisposed_();
			
			if (action == null
				&& 0 == _GetState(out var state)
				&& (state & (EState.FOCUSABLE | EState.SELECTABLE)) == EState.FOCUSABLE //must be only focusable. If SELECTABLE, probably don't need this workaround.
				&& 0 == _GetWnd(out var w)
				&& 0 == Cpp.Cpp_AccSelect(this, ESelect.TAKEFOCUS)
				&& 0 == _GetState(out state) && state.Has(EState.FOCUSED) //avoid sending keys to another control
				) {
				GC.KeepAlive(this);
				w.Post(Api.WM_KEYDOWN, (byte)KKey.Space, 0);
				w.Post(Api.WM_KEYUP, (byte)KKey.Space, 0);
				//tested: works even if the window is inactive.
				w.MinimalSleepNoCheckThread_();
				return;
			}
			
			_Invoke('a', action);
			//_MinimalSleep(); //don't need. JAB doAccessibleActions is sync, which is bad.
		}
		
		/// <summary>
		/// Calls <see cref="Invoke"/> or <i>action</i> and waits until changes the web page (window name and page name).
		/// </summary>
		/// <param name="timeout">Timeout, seconds. Can be 0 (infinite), >0 (exception) or &lt;0 (no exception). More info: [](xref:wait_timeout).
		/// Default 60 seconds.
		/// </param>
		/// <param name="action">If used, calls it instead of <see cref="Invoke"/>.</param>
		/// <returns>Returns <c>true</c>. On timeout returns <c>false</c> if <i>timeout</i> &lt; 0; else exception.</returns>
		/// <exception cref="TimeoutException"><i>timeout</i> time has expired (if > 0).</exception>
		/// <exception cref="AuException">Failed. For example, when this UI element is invalid, or its top-level window does not contain a web page.</exception>
		/// <exception cref="AuWndException">The window was closed while waiting.</exception>
		/// <exception cref="Exception">Exceptions thrown by <see cref="Invoke"/> or by the <i>action</i> function.</exception>
		/// <remarks>
		/// This function is used to click a link in a web page and wait until current web page is gone. It prevents a following "wait for UI element" function from finding a matching UI element in the old page, which would be bad.
		/// Does not wait until the new page is completely loaded. There is no reliable/universal way for it. Instead, after calling it you can call a "wait for UI element" function which waits for a known UI element that must be in the new page.
		/// This function cannot be used when the new page has the same title as current page. Then it waits until <i>timeout</i> time or forever. The same if the invoked action does not open a web page.
		/// </remarks>
		public bool WebInvoke(Seconds? timeout = null, Action<elm> action = null) {
			wnd w = WndTopLevel; if (w.Is0) throw new AuException("*get window");
			elm doc = w.Elm["web:"].Find(-1) ?? throw new AuException("*find web page");
			
			string wndName = w.NameTL_, docName = doc.Name; Debug.Assert(!wndName.NE() && !docName.NE());
			bool wndOK = false, docOK = false;
			elmFinder f = null;
			
			if (action == null) Invoke(); else action(this);
			
			//wait until window name and document name both are changed. They can change in any order.
			var seconds = timeout ?? new(60);
			seconds.Period ??= 25;
			var loop = new WaitLoop(seconds);
			while (loop.Sleep()) {
				w.ThrowIfInvalid();
				if (!wndOK) {
					var s = w.NameTL_;
					if (s == null) continue; //probably invalid, will throw in next loop
					wndOK = s != wndName;
				}
				if (wndOK && !docOK) {
					f ??= new elmFinder("web:") { ResultGetProperty = 'n' };
					if (!w.HasElm(f)) continue; //eg in Firefox for some time there is no DOCUMENT
					if (f.ResultProperty is not string s) continue;
					docOK = s != docName;
					//if(!docOK) print.it("doc is late");
				}
				if (wndOK && docOK) {
					w.ThrowIfInvalid();
					return true;
				}
			}
			return false;
		}
		
#if false
		//This function is finished and normally works well.
		//However web browsers not always fire the event. For some pages never, or only when not cached.
		//Also, some pages are like never finish loading (the browser waiting animation does not stop spinning). Or finish when the wanted UI element is there for long time, so why to wait. Or finish, then continue loading again...
		//Also, this function inevitably will stop working with some new web browser version with new bugs. Too unreliable.
		public bool InvokeAndWaitForWebPageLoaded(double secondsTimeout = 60, Action<elm> action = null, wnd w = default)
		{
			ThrowIfDisposed_();

			int timeout; bool throwTimeout = false;
			if(secondsTimeout == 0) timeout = Timeout.Infinite;
			else {
				if(secondsTimeout < 0) secondsTimeout = -secondsTimeout; else throwTimeout = true;
				timeout = checked((int)(secondsTimeout * 1000));
			}

			if(w.Is0) {
				w = WndContainer;
				if(w.Is0) throw new AuException("*get window");
			}

			var hookEvent = EEvent.IA2_DOCUMENT_LOAD_COMPLETE;
			int browser = w.ClassNameIs(Api.string_IES, "Mozilla*", "Chrome*");
			switch(browser) {
			case 0:
				wnd ies = w.Child(null, Api.string_IES); if(ies.Is0) break;
				w = ies; goto case 1;
			case 1: hookEvent = EEvent.OBJECT_CREATE; break;
			}

			int tid = w.ThreadId; if(tid == 0) w.ThrowUseNative();
			AutoResetEvent eventNotify = null;
			int debugIndex = 0;

			Api.WINEVENTPROC hook = (IntPtr hWinEventHook, EEvent ev, wnd hwnd, int idObject, int idChild, int idEventThread, int time) =>
			{
				if(eventNotify == null) { /*print.it("null 1");*/ return; }
				if(ev == EEvent.OBJECT_CREATE && hwnd != w) return; //note: in Chrome hwnd is Chrome_RenderWidgetHostHWND
				int di = ++debugIndex;
				using(var a = elm.fromEvent(hwnd, idObject, idChild)) {
					if(a == null) { /*Debug_.Print("elm.fromEvent null");*/ return; } //often IE, but these are not useful UI elements
					if(eventNotify == null) { /*print.it("null 2");*/ return; }
					if(ev == EEvent.IA2_DOCUMENT_LOAD_COMPLETE) { //Chrome, Firefox

						//filter out frame/iframe
						if(browser == 2) { //Firefox does not fire events for frame/iframe. But the Chrome code would work too.
						} else if(0 == a._iacc.get_accParent(out var a2)) { //bug in some Chrome versions: fails for main document
							using(a2) {
								if(eventNotify == null) { /*print.it("null 3");*/ return; }
								bool isFrame;
								var hr = a2.GetRole(0, out var role, out var roleStr); if(hr != 0) Debug_.Print((uint)hr);
								if(eventNotify == null) { /*print.it("null 4");*/ return; }
								if(hr != 0) isFrame = false;
								else if(roleStr != null) isFrame = roleStr.Ends("frame", true);
								else isFrame = !(role == ERole.WINDOW || role == ERole.CLIENT);
								//print.it(role, roleStr);
								if(isFrame) return;
								//browser    main        frame     iframe
								//Firefox    "browser"   "frame"   "iframe"
								//Chrome     WINDOW      "FRAME"   DOCUMENT
							}
						}
					} else { //IE (OBJECT_CREATE)
						if(a._elem != 0) return;
						if(0 != a._iacc.GetRole(0, out var role) || role != ERole.PANE) return;
						if(eventNotify == null) { /*print.it("null 3");*/ return; }

						//filter out frame/iframe
						if(a.IsInvisible) return;
						if(eventNotify == null) { /*print.it("null 4");*/ return; }
						using(var aCLIENT = _FromWindow(w, EObjid.CLIENT, noThrow: true)) {
							if(eventNotify == null) { /*print.it("null 5");*/ return; }
							if(aCLIENT != null) {
								var URL1 = a.Value; Debug.Assert(URL1.Length > 0); //print.it(URL1); //http:..., about:...
								aCLIENT.get_accName(0, out var URL2, 0); Debug.Assert(URL2.Length > 0);
								if(URL1 != URL2) return;
								if(eventNotify == null) { /*print.it("null 6");*/ return; }
							} else Debug_.Print("aCLIENT null");
						}
					}

					//print.it(di, ev, a);
					eventNotify.Set();
					eventNotify = null;
				}
			};

			var hh = Api.SetWinEventHook(hookEvent, hookEvent, default, hook, 0, tid, 0); if(hh == default) throw new AuException();
			try {
				eventNotify = new AutoResetEvent(false);
				if(action != null) action(this); else Invoke();
				if(eventNotify.WaitOne(timeout)) {
					//Thread.CurrentThread.Join(2000);
					return true;
				}
			}
			finally { Api.UnhookWinEvent(hh); eventNotify?.Dispose(); }
			GC.KeepAlive(hook);

			if(throwTimeout) throw new TimeoutException();
			return false;
		}
#endif
		
		/// <summary>
		/// Selects or deselects.
		/// </summary>
		/// <param name="how">Specifies whether to select, focus, add to selection etc. Can be two flags, for example <c>ESelect.TAKEFOCUS | ESelect.TAKESELECTION</c>. With flag <c>TAKEFOCUS</c> activates the window like <see cref="Focus(bool)"/>.</param>
		/// <exception cref="AuException">Failed.</exception>
		/// <exception cref="AuWndException">Failed to activate the window (<see cref="wnd.Activate"/>) or focus the control (<see cref="wnd.Focus"/>).</exception>
		/// <remarks>
		/// Not all UI elements support it. Most UI elements support not all flags. It depends on <see cref="EState"/> <c>FOCUSABLE</c>, <c>SELECTABLE</c>, <c>MULTISELECTABLE</c>, <c>EXTSELECTABLE</c>, <c>DISABLED</c>.
		/// Many UI elements have bugs, especially with flag <c>TAKEFOCUS</c>. More bugs when the UI element has been found with flag <see cref="EFFlags.NotInProc"/>.
		/// </remarks>
		public void Select(ESelect how = ESelect.TAKESELECTION) {
			ThrowIfDisposed_();
			
			//Workaround for Windows controls bugs, part 1.
			wnd w = default, wTL = default; bool focusingControl = false;
			if (how.Has(ESelect.TAKEFOCUS)) {
				//Always activate/focus the window, because used by functions that then will send keys etc.
				//CONSIDER: option TAKEFOCUSNOACTIVATE to focus without activate/focus the window.
				w = WndContainer;
				//if(!w.IsEnabled(true)) throw new AuException("*set focus. Disabled"); //accSelect would not fail //rejected. In some cases the UI element may be focusable although window disabled, eg KTreeView.
				wTL = w.Window;
				wTL.Activate();
				if (focusingControl = (w != wTL))
					if (w.IsEnabled()) //see above. Would be exception if disabled.
						w.Focus();
				if (IsFocused) how &= ~ESelect.TAKEFOCUS;
				if (how == 0) return;
			} else {
				//same as with Invoke
				WndUtil.EnableActivate(-1);
			}
			
			for (int i = 0; i < 2; i++) {
				var hr = Cpp.Cpp_AccSelect(this, how);
				GC.KeepAlive(this);
				if (hr == 0) break;
				if (hr == 1) continue; //some UI elements return S_FALSE even if did what asked. Eg combobox (focuses the child Edit), slider. Or may need to retry, eg when trying to focus a listitem in a non-focused listbox.
				if (hr == Api.DISP_E_MEMBERNOTFOUND) throw new AuException("This UI element does not support this state");
				AuException.ThrowIfHresultNegative(hr);
			}
			
			if (!w.Is0) w.MinimalSleepIfOtherThread_(); //sleep only when focusing. Assume selection is sync. Also need for the bug, because the control may be activated a millisecond later.
			
			//Workaround for Windows controls bugs, part 2.
			if (focusingControl && w.IsActive) {
				//Debug_.Print("activated control");
				wTL.ActivateL();
			}
			
			//tested: IAccessible.accSelect(TAKEFOCUS):
			//	Most Windows controls have this bug: activates the control with SetForegroundWindow, which deactivates the top-level window.
			//		Especially if the control is already focused.
			//		If not already focused, fails if eg listbox item. But then works well with eg buttons.
			//		MSDN: If IAccessible::accSelect is called with the SELFLAG_TAKEFOCUS flag on a child UI element that has an HWND, the flag takes effect only if the UI element's parent has the focus.
			//		Tested, does not help: LockSetForegroundWindow, AttachThreadInput.
			//		Good news: works well if the UI element found inproc, ie without flag NotInproc.
			//			But then need to focus the control, else does not work.
			//			Use the same workaround. It focuses the control.
			//	Works well with web browsers, WinForms.
			//	With WPF initially almost does not work. After using a navigation key (Tab etc) starts to work well.
			//tested: UIA.IElement.SetFocus:
			//	In most cases works well with standard controls, all web browsers, WinForms.
			//	With WPF same as elm.
			//	Bug: If standard control is disabled, deactivates parent window and draws focus rectangle on the control.
		}
		
		/// <summary>
		/// Makes this UI element focused for keyboard input.
		/// </summary>
		/// <param name="andSelect">Add flag <c>TAKESELECTION</c>. Note: it is for selecting a list item, not for selecting text in a text box.</param>
		/// <exception cref="AuException">Failed.</exception>
		/// <exception cref="AuWndException">Failed to activate the window (<see cref="wnd.Activate"/>) or focus the control (<see cref="wnd.Focus"/>).</exception>
		/// <remarks>
		/// Calls <see cref="Select"/> with flag <c>TAKEFOCUS</c> and optionally <c>TAKESELECTION</c>.
		/// Not all UI elements support this action and not all work correctly. More info in <c>Select</c> documentation.
		/// </remarks>
		public void Focus(bool andSelect = false) {
			var how = ESelect.TAKEFOCUS;
			if (andSelect) how |= ESelect.TAKESELECTION;
			Select(how);
		}
		
		/// <summary>
		/// Gets selected direct child items.
		/// </summary>
		/// <returns>Empty array if there are no selected items of if failed. Supports <see cref="lastError"/>.</returns>
		public elm[] SelectedChildren {
			get {
				ThrowIfDisposed_();
				if (_elem != 0) { lastError.clear(); return []; }
				//return _iacc.get_accSelection();
				if (0 != _Hresult(_FuncId.selection, Cpp.Cpp_AccGetSelection(this, out var b)) || b.Is0) return [];
				GC.KeepAlive(this);
				var p = (Cpp.Cpp_Acc*)b.Ptr; int n = b.Length / sizeof(Cpp.Cpp_Acc);
				var r = new elm[n];
				for (int i = 0; i < n; i++) r[i] = new elm(p[i]);
				b.Dispose();
				return r;
			}
		}
		
		/// <summary>
		/// Gets the number of direct child UI elements.
		/// </summary>
		public int ChildCount {
			get {
				ThrowIfDisposed_();
				if (_elem != 0) { lastError.clear(); return 0; }
				_Hresult(_FuncId.child_count, Cpp.Cpp_AccGetInt(this, 'c', out int cc));
				GC.KeepAlive(this);
				return cc;
			}
		}
		
		/// <summary>
		/// Gets multiple properties.
		/// </summary>
		/// <param name="props">
		/// String that specifies properties to get, for example <c>"nv"</c> for name and value.
		/// <br/>• <c>R</c> - <see cref="Role"/>.
		/// <br/>• <c>n</c> - <see cref="Name"/>.
		/// <br/>• <c>v</c> - <see cref="Value"/>.
		/// <br/>• <c>d</c> - <see cref="Description"/>.
		/// <br/>• <c>h</c> - <see cref="Help"/>.
		/// <br/>• <c>a</c> - <see cref="DefaultAction"/>.
		/// <br/>• <c>k</c> - <see cref="KeyboardShortcut"/>.
		/// <br/>• <c>u</c> - <see cref="UiaId"/>.
		/// <br/>• <c>U</c> - <see cref="UiaCN"/>.
		/// <br/>• <c>s</c> - <see cref="State"/>.
		/// <br/>• <c>r</c> - <see cref="GetRect(out RECT, bool)"/> with <i>raw</i> <c>true</c>.
		/// <br/>• <c>D</c> - <see cref="Rect"/> or <see cref="GetRect(out RECT, bool)"/> with <i>raw</i> <c>false</c>. Don't use with <c>r</c>.
		/// <br/>• <c>w</c> - <see cref="WndContainer"/>.
		/// <br/>• <c>o</c> - <see cref="Html"/> outer.
		/// <br/>• <c>i</c> - <see cref="Html"/> inner.
		/// <br/>• <c>@</c> - <see cref="HtmlAttributes"/>.
		/// </param>
		/// <param name="result">Receives results.</param>
		/// <returns><c>false</c> if failed, for example when the UI element's window is closed. Supports <see cref="lastError"/>.</returns>
		/// <exception cref="ArgumentException">Unknown property character.</exception>
		/// <remarks>
		/// The returned variable contains values of properties specified in <i>props</i>. When a property is empty or failed to get, the member variable is <c>""</c>, empty dictionary or default value of that type; never <c>null</c>.
		/// 
		/// Normally this function is faster than calling multiple property functions, because it makes single remote procedure call. But not if this UI element was found with flag <see cref="EFFlags.NotInProc"/> etc.
		/// </remarks>
		public bool GetProperties(string props, out EProperties result) {
			//CONSIDER: use cached role. Or not, because now can help to catch bugs where the cached role is incorrect.
			
			result = null;
			ThrowIfDisposed_();
			if (props.Length == 0) return true;
			int hr = Cpp.Cpp_AccGetProps(this, props, out var b);
			GC.KeepAlive(this);
			if (hr != 0) {
				if (hr == (int)Cpp.EError.InvalidParameter) throw new ArgumentException("Unknown property character.");
				lastError.code = hr;
				return false;
			}
			result = new();
			using (b) {
				var offsets = (int*)b.Ptr;
				for (int i = 0; i < props.Length; i++) {
					int offs = offsets[i], len = ((i == props.Length - 1) ? b.Length : offsets[i + 1]) - offs;
					var p = b.Ptr + offs;
					switch (props[i]) {
					case 'r' or 'D': result.Rect = len > 0 ? *(RECT*)p : default; break;
					case 's': result.State = len > 0 ? *(EState*)p : default; break;
					case 'w': result.WndContainer = len > 0 ? (wnd)(*(int*)p) : default; break;
					case '@': result.HtmlAttributes = AttributesToDictionary_(p, len); break;
					default:
						var s = (len == 0) ? "" : new string(p, 0, len);
						switch (props[i]) {
						case 'R': result.Role = s; break;
						case 'n': result.Name = s; break;
						case 'v': result.Value = s; break;
						case 'd': result.Description = s; break;
						case 'h': result.Help = s; break;
						case 'a': result.DefaultAction = s; break;
						case 'k': result.KeyboardShortcut = s; break;
						case 'u': result.UiaId = s; break;
						case 'U': result.UiaCN = s; break;
						case 'o': result.OuterHtml = s; break;
						case 'i': result.InnerHtml = s; break;
						}
						break;
					}
				}
			}
			return true;
		}
		
		internal static Dictionary<string, string> AttributesToDictionary_(char* p, int len) {
			var d = new Dictionary<string, string>();
			int ik = 0, iv = 0;
			for (int i = 0; i < len; i++) {
				var c = p[i];
				if (c == '\0' && iv > ik) {
					string sk = new string(p, ik, iv - ik - 1);
					string sv = new string(p, iv, i - iv);
					d[sk] = sv;
					ik = i + 1;
				} else if (c == '=' && iv <= ik) {
					iv = i + 1;
				}
			}
			//print.it(d);
			return d;
		}
		
		/// <summary>
		/// Gets an adjacent or related UI element - next, child, parent, etc.
		/// </summary>
		/// <returns><c>null</c> if not found.</returns>
		/// <param name="navig">
		/// String consisting of one or more navigation direction strings separated by space, like <c>"parent next child4 first"</c>.
		/// <br/>• <c>"next"</c> - next sibling UI element in the same parent UI element.
		/// <br/>• <c>"previous"</c> - previous sibling UI element in the same parent UI element.
		/// <br/>• <c>"first"</c> - first child UI element.
		/// <br/>• <c>"last"</c> - last child UI element.
		/// <br/>• <c>"parent"</c> - parent (container) UI element.
		/// <br/>• <c>"child"</c> - child UI element by 1-based index. Example: <c>"child3"</c> (3-th child). Negative index means from end, for example -1 is the last child.
		/// <br/>• <c>"#N"</c> - custom. More info in Remarks.
		/// <br/>• Some elements also support <c>"up"</c>, <c>"down"</c>, <c>"left"</c>, <c>"right"</c>.
		/// </param>
		/// <param name="waitS">Wait for the wanted UI element max this number of seconds. Default 0 (don't wait). If negative, waits forever.</param>
		/// <exception cref="ArgumentException">Invalid <i>navig</i> string.</exception>
		/// <remarks>
		/// Can be 2 letters, like <c>"pr"</c> for <c>"previous"</c>.
		/// A string like <c>"next3"</c> or <c>"next,3"</c> is the same as <c>"next next next"</c>. Except for <c>"child"</c>.
		/// Use string like <c>"#1000"</c> to specify a custom <i>navDir</i> value to pass to <ms>IAccessible.accNavigate</ms>.
		/// 
		/// For <c>"child"</c> the function calls API <ms>AccessibleChildren</ms>.
		/// For <c>"parent"</c> the function calls <ms>IAccessible.get_accParent</ms>. Few UI elements don't support. Some UI elements return a different parent than in the tree of UI elements.
		/// For others the function calls <ms>IAccessible.accNavigate</ms>. Not all UI elements support it. Some UI elements skip invisible siblings. Instead you can use <c>"parent childN"</c> or <c>"childN"</c>.
		/// </remarks>
		/// <example>
		/// <code><![CDATA[
		/// a = e.Navigate("parent next ch3");
		/// ]]></code>
		/// </example>
		public elm Navigate(string navig, double waitS = 0) {
			Not_.Null(navig);
			ThrowIfDisposed_();
			int hr; Cpp.Cpp_Acc ca;
			if (waitS == 0) {
				hr = Cpp.Cpp_AccNavigate(this, navig, out ca);
			} else {
				var loop = new WaitLoop(waitS > 0 ? -waitS : 0d);
				do hr = Cpp.Cpp_AccNavigate(this, navig, out ca);
				while (hr != 0 && hr != (int)Cpp.EError.InvalidParameter && loop.Sleep());
			}
			GC.KeepAlive(this);
			if (hr == (int)Cpp.EError.InvalidParameter) throw new ArgumentException("Invalid navig string.");
			lastError.code = hr;
			return hr == 0 ? new elm(ca) : null;
			
			//FUTURE: when fails, possibly this is disconnected etc. Retry find with same elmFinder.
		}
		
		/// <summary>
		/// Gets parent element. Same as <see cref="Navigate"/> with argument <c>"pa"</c>.
		/// </summary>
		/// <returns><c>null</c> if failed.</returns>
		public elm Parent => Navigate("pa");
		//info: Navigate("pa") is optimized in C++
		//Chrome bug: the parent element retrieved in this way has some incorrect properties.
		//	Eg Parent.WndContainer is the legacy control, whereas this.WndContainer is the top-level window.
		
		/// <summary>
		/// Gets HTML.
		/// </summary>
		/// <returns><c>""</c> if this is not a HTML element or if failed. Supports <see cref="lastError"/>.</returns>
		/// <param name="outer">If <c>true</c>, gets outer HTML (with tag and attributes), else inner HTML.</param>
		/// <remarks>
		/// Works with Chrome, Internet Explorer and apps that use their code (Edge, Opera, web browser controls...). This UI element must be found without flag <c>NotInProc</c>.
		/// If this is the root of web page (role <c>DOCUMENT</c> or <c>PANE</c>), gets web page body HTML.
		/// </remarks>
		public string Html(bool outer) {
			ThrowIfDisposed_();
			int hr = _Hresult(_FuncId.html, Cpp.Cpp_AccWeb(this, outer ? "'o" : "'i", out BSTR s));
			GC.KeepAlive(this);
			return _BstrToString(hr, s);
		}
		
		/// <summary>
		/// Gets a HTML attribute.
		/// </summary>
		/// <returns><c>""</c> if this is not a HTML element or does not have the specified attribute or failed. Supports <see cref="lastError"/>.</returns>
		/// <param name="name">Attribute name, for example <c>"href"</c>, <c>"id"</c>, <c>"class"</c>. Full, case-sensitive.</param>
		/// <remarks>
		/// Works with Chrome, Internet Explorer and apps that use their code (Edge, Opera, web browser controls...). This UI element must be found without flag <c>NotInProc</c>.
		/// </remarks>
		/// <exception cref="ArgumentException"><i>name</i> is <c>null</c>/<c>""</c>/invalid.</exception>
		public string HtmlAttribute(string name) {
			ThrowIfDisposed_();
			if (name.NE() || name[0] == '\'') throw new ArgumentException("Invalid name.");
			int hr = _Hresult(_FuncId.html, Cpp.Cpp_AccWeb(this, name, out BSTR s));
			GC.KeepAlive(this);
			return _BstrToString(hr, s);
		}
		
		/// <summary>
		/// Gets all HTML attributes.
		/// </summary>
		/// <returns>Empty dictionary if this is not a HTML element or does not have attributes or failed. Supports <see cref="lastError"/>.</returns>
		/// <remarks>
		/// Works with Chrome, Internet Explorer and apps that use their code (Edge, Opera, web browser controls...). This UI element must be found without flag <c>NotInProc</c>.
		/// </remarks>
		public Dictionary<string, string> HtmlAttributes() {
			ThrowIfDisposed_();
			int hr = Cpp.Cpp_AccWeb(this, "'a", out BSTR s);
			GC.KeepAlive(this);
			_Hresult(_FuncId.html, hr);
			if (hr != 0) return new();
			using (s) return AttributesToDictionary_(s.Ptr, s.Length);
		}
		
		/// <summary>
		/// Scrolls this UI element into view.
		/// </summary>
		/// <exception cref="AuException">Failed to scroll, or the UI element does not support scrolling.</exception>
		/// <remarks>
		/// This function works with these UI elements:
		/// - Web page elements in Chrome, Internet Explorer and apps that use their code (Edge, Opera, web browser controls...). To find UI element, use role prefix <c>"web:"</c>, <c>"firefox:"</c> or <c>"chrome:"</c>, and don't use flag <see cref="EFFlags.NotInProc"/>.
		/// - Standard treeview, listview and listbox controls.
		/// - Some other controls if found with flag <see cref="EFFlags.UIA"/>.
		/// 
		/// Some apps after scrolling update <see cref="Rect"/> with a delay. Some apps never update it for existing <see cref="elm"/> variables. This function does not wait.
		/// </remarks>
		public void ScrollTo() {
			ThrowIfDisposed_();
			AuException.ThrowIfHresultNot0(_ScrollTo(), "*scroll");
		}
		
		int _ScrollTo() {
			int hr = 1;
			if (MiscFlags.Has(EMiscFlags.UIA)) {
				hr = _InvokeL('s');
			} else if (Item == 0) {
				hr = Cpp.Cpp_AccWeb(this, "'s", out _);
				//tested: Chrome and Firefox don't support UI Automation scrolling (IUIAutomationScrollItemPattern).
			} else if (RoleInt is ERole.LISTITEM or ERole.TREEITEM) { //try messages of some standard controls
				var w = WndContainer;
				switch (w.CommonControlType) {
				case WControlType.Listview when RoleInt is ERole.LISTITEM:
					if (0 != w.Send(LVM_ENSUREVISIBLE, Item - 1, 1)) hr = 0;
					break;
				case WControlType.Listbox when RoleInt is ERole.LISTITEM:
					if (-1 != w.Send(LB_SETTOPINDEX, Item - 1)) hr = 0;
					break;
				case WControlType.Treeview when RoleInt is ERole.TREEITEM:
					if (osVersion.is32BitProcessAnd64BitOS && !w.Is32Bit) break; //cannot get 64-bit HTREEITEM
					nint hi = w.Send(TVM_MAPACCIDTOHTREEITEM, Item); if (hi == 0) break;
					w.Send(TVM_ENSUREVISIBLE, 0, hi);
					hr = 0; //the API returns nonzero only if actually scrolls, not if already visible
					break;
				}
			}
			GC.KeepAlive(this);
			return hr;
		}
		
		/// <summary>
		/// Waits for a user-defined state/condition of this UI element. For example enabled, checked, changed name.
		/// </summary>
		/// <param name="timeout">Timeout, seconds. Can be 0 (infinite), >0 (exception) or &lt;0 (no exception). More info: [](xref:wait_timeout).</param>
		/// <param name="condition">Callback function (eg lambda). It is called repeatedly, until returns a value other than <c>default(T)</c>, for example <c>true</c>.</param>
		/// <returns>Returns the value returned by the callback function. On timeout returns <c>default(T)</c> if <i>timeout</i> is negative; else exception.</returns>
		/// <exception cref="TimeoutException"><i>timeout</i> time has expired (if > 0).</exception>
		/// <exception cref="AuWndException">Failed to get container window (<see cref="WndContainer"/>), or it was closed while waiting.</exception>
		public T WaitFor<T>(Seconds timeout, Func<elm, T> condition) {
			var w = WndContainer; //calls ThrowIfDisposed_
			var loop = new WaitLoop(timeout);
			for (; ; ) {
				w.ThrowIfInvalid();
				T r = condition(this);
				bool ok = !EqualityComparer<T>.Default.Equals(r, default);
				w.ThrowIfInvalid(); //eg when waiting for button enabled, if window closed while in callback, the DISABLED state may be removed
				if (ok) return r;
				if (!loop.Sleep()) return default;
			}
		}
		
		/// <summary>
		/// Moves the cursor (mouse pointer) to this UI element.
		/// </summary>
		/// <param name="x">X coordinate in the bounding rectangle of this UI element. Default - center. Examples: <c>10</c>, <c>^10</c> (reverse), <c>.5f</c> (fraction).</param>
		/// <param name="y">Y coordinate in the bounding rectangle of this UI element. Default - center.</param>
		/// <param name="scroll">If not 0, the function at first calls <see cref="ScrollTo"/>. If it succeeds, waits <i>scroll</i> number of milliseconds (let the target app update the UI element rectangle etc).</param>
		/// <exception cref="AuException">Failed to get UI element rectangle in container window (<see cref="elm.WndContainer"/>).</exception>
		/// <exception cref="Exception">Exceptions of <see cref="mouse.move(wnd, Coord, Coord, bool)"/>.</exception>
		/// <remarks>
		/// Calls <see cref="mouse.move(wnd, Coord, Coord, bool)"/>. To get rectangle in window, uses <see cref="GetRect(out RECT, wnd, bool)"/> with <i>intersect</i> <c>true</c>.
		/// </remarks>
		public void MouseMove(Coord x = default, Coord y = default, int scroll = 0)
			=> _ElmMouseAction(false, x, y, default, scroll);
		
		/// <summary>
		/// Clicks this UI element.
		/// </summary>
		/// <param name="x">X coordinate in the bounding rectangle of this UI element. Default - center. Examples: <c>10</c>, <c>^10</c> (reverse), <c>.5f</c> (fraction).</param>
		/// <param name="y">Y coordinate in the bounding rectangle of this UI element. Default - center.</param>
		/// <param name="button">Which button and how to use it.</param>
		/// <param name="scroll">If not 0, the function at first calls <see cref="ScrollTo"/>. If it succeeds, waits <i>scroll</i> number of milliseconds (let the target app update the UI element rectangle etc). Valid values are 0-5000. Tip: if does not scroll, try to find the UI element with flag <c>UIA</c>.</param>
		/// <exception cref="AuException">Failed to get UI element rectangle in container window (<see cref="elm.WndContainer"/>).</exception>
		/// <exception cref="Exception">Exceptions of <see cref="mouse.clickEx(MButton, wnd, Coord, Coord, bool)"/>.</exception>
		/// <remarks>
		/// Calls <see cref="mouse.clickEx(MButton, wnd, Coord, Coord, bool)"/>. To get rectangle in window, uses <see cref="GetRect(out RECT, wnd, bool)"/> with <i>intersect</i> <c>true</c>.
		/// </remarks>
		public MRelease MouseClick(Coord x = default, Coord y = default, MButton button = MButton.Left, int scroll = 0) {
			_ElmMouseAction(true, x, y, button, scroll);
			return button;
		}
		
		/// <summary>
		/// Double-clicks this UI element.
		/// </summary>
		/// <inheritdoc cref="MouseClick(Coord, Coord, MButton, int)"/>
		public void MouseClickD(Coord x = default, Coord y = default, int scroll = 0)
			=> MouseClick(x, y, MButton.DoubleClick, scroll);
		
		/// <summary>
		/// Right-clicks this UI element.
		/// </summary>
		/// <inheritdoc cref="MouseClick(Coord, Coord, MButton, int)"/>
		public void MouseClickR(Coord x = default, Coord y = default, int scroll = 0)
			=> MouseClick(x, y, MButton.Right, scroll);
		
		void _ElmMouseAction(bool click, Coord x, Coord y, MButton button, int scroll) {
			var (w, r) = _GetWndAndRectForClick(scroll);
			var p = Coord.NormalizeInRect(x, y, r, centerIfEmpty: true);
			//if (!w.Is0) {
			if (button == 0) mouse.move(w, p.x, p.y);
			else mouse.clickEx(button, w, p.x, p.y);
			//} else { //no. Unsafe, can click in another window.
			//	if (button == 0) mouse.move(p);
			//	else mouse.clickEx(button, p);
			//}
		}
		
		(wnd w, RECT r) _GetWndAndRectForClick(int scroll) {
			if (scroll != 0) {
				if ((uint)scroll > 5000) throw new ArgumentException("Valid values 0-5000", nameof(scroll));
				if (0 == _ScrollTo()) wait.ms(scroll);
			}
			
			if (!GetRect(out var r)) throw new AuException(0, "*get UI element rectangle");
			if (r.NoArea) throw new AuException(IsOffscreen ? "The UI element is offscreen. Try scroll." : "The UI element rectangle is empty");
			//var w = WndContainer; //need window for mouse functions, else could click another window etc
			var w = WndTopLevel; //direct parent control may be zero-size etc, eg in Win11 Paint when found with UIA
			bool retry = false; var r0 = r;
			g1:
			if (!w.GetRect(out var rw)) throw new AuException(0, "*get container window");
			if (!r.Intersect(rw)) {
				if (!retry && scroll != 0) { //workaround for: WndContainer of a popup item may be the popup's owner. Eg WPF combobox.
					w = w.Window.Get.EnabledOwned();
					if (retry = !w.Is0) { r = r0; goto g1; }
				}
				throw new AuException("The UI element rectangle is not in the container window." + (scroll != 0 ? null : " Try scroll."));
			}
			if (!w.MapScreenToClient(ref r)) throw new AuException(0);
			return (w, r);
		}
		
		//rejected: automatically scroll if need.
		//	Impossible to reliably detect whether need to scroll.
		//	This was an attempt, but it does not work well. And can't click non-client elements.
		//(wnd w, RECT r) _GetWndAndRectForClick() {
		//	//var w = WndContainer; //with window the mouse functions are more reliable, eg will not click another window
		//	var w = WndTopLevel; //direct parent control may be zero-size etc, eg in Win11 Paint when found with UIA
		//	if (w.Is0) throw new AuException(0, "*get container window");
		//	RECT r = _GetRect(), rr = r;
		//	print.it(r);
		//	bool retry = false;
		//	gRetry:
		//	bool bad = r.NoArea;
		//	if (!bad) {
		//		bad = (!retry && IsOffscreen) || !r.Intersect(_GetContainerClientRect(w));
		//	}
		//	print.it(bad);
		//	if (bad) {
		//		if (!retry) {
		//			if (0 == _ScrollTo())
		//				if (wait.until(-2, () => (r = _GetRect()) != rr)) {
		//					30.ms(); retry = true; goto gRetry;
		//				}
		//		}
		//		throw new AuException(0, "The UI element rectangle is " + (rr.NoArea ? "empty." : "offscreen."));
		//	}
		//	return (w, r);
		
		//	RECT _GetRect() => GetRect(out var r, w) ? r : throw new AuException(0, "*get UI element rectangle");
		
		//	//todo: now cannot click in nonclient area.
		
		//	//never mind: should intersect with all ancestor elements and windows.
		//	//	Now no OFFSCREEN state if partially clipped by an ancestor rect.
		//	//	Slow and unreliable, because visible children can be not in parent rect. Eg pagetab or treeitem.
		
		//	//problem: Firefox never updates Rect after ScrollTo. Need to find again.
		//	//	Chrome updates after several ms. Chrome does not update OFFSCREEN (or with a delay?).
		
		//	//problem: some fake container windows may be zero-size etc, and the element is drawn on another window.
		//	//	shoulddo: test more.
		//}
		
		/// <summary>
		/// Posts mouse-click messages to the container window, using coordinates in this UI element.
		/// </summary>
		/// <param name="x">X coordinate in the bounding rectangle of this UI element. Default - center. Examples: <c>10</c>, <c>^10</c> (reverse), <c>.5f</c> (fraction).</param>
		/// <param name="y">Y coordinate in the bounding rectangle of this UI element. Default - center.</param>
		/// <param name="button">Can specify the left (default), right or middle button. Also flag for double-click, press or release.</param>
		/// <param name="scroll">If not 0, the function calls <see cref="ScrollTo"/>. If it succeeds, waits <i>scroll</i> number of milliseconds (let the target app update the UI element rectangle etc). Valid values are 0-5000. Tip: if does not scroll, try to find the UI element with flag <c>UIA</c>.</param>
		/// <exception cref="AuException">
		/// - Failed to get rectangle or container window.
		/// - The element is invisible/offscreen.
		/// </exception>
		/// <exception cref="ArgumentException">Unsupported button specified.</exception>
		/// <remarks>
		/// Does not move the mouse.
		/// Does not wait until the target application finishes processing the message.
		/// Works not with all elements.
		/// Try this function when <see cref="Invoke"/> does not work and you don't want to use <c>MouseClick</c>.
		/// </remarks>
		public void PostClick(Coord x = default, Coord y = default, MButton button = MButton.Left, int scroll = 0) {
			var (w, r) = _GetWndAndRectForClick(scroll);
			
			mouse.PostClick_(w, r, x, y, button);
		}
		
		/// <summary>
		/// Posts mouse-double-click messages to the container window, using coordinates in this UI element.
		/// </summary>
		/// <exception cref="AuException">
		/// - Failed to get rectangle or container window.
		/// - The element is invisible/offscreen.
		/// </exception>
		/// <inheritdoc cref="PostClick(Coord, Coord, MButton, int)" path="//param|//remarks"/>
		public void PostClickD(Coord x = default, Coord y = default) => PostClick(x, y, MButton.DoubleClick);
		
		/// <summary>
		/// Posts mouse-right-click messages to the container window, using coordinates in this UI element.
		/// </summary>
		/// <inheritdoc cref="PostClickD(Coord, Coord)"/>
		public void PostClickR(Coord x = default, Coord y = default) => PostClick(x, y, MButton.Right);
		
		/// <summary>
		/// Makes this UI element focused (<see cref="Focus"/>) and calls <see cref="keys.send"/>.
		/// </summary>
		/// <exception cref="Exception">Exceptions of <see cref="Focus"/> and <see cref="keys.send"/>.</exception>
		/// <inheritdoc cref="keys.send" path="/param"/>
		public void SendKeys([ParamString(PSFormat.Keys)] params KKeysEtc[] keysEtc) {
			bool andSelect = RoleInt is ERole.TREEITEM or ERole.LISTITEM;
			Focus(andSelect);
			keys.send(keysEtc);
		}
		
		//rejected: too simple and limited. No x y, scroll, button.
		///// <summary>
		///// Clicks this UI element and calls <see cref="keys.send"/>.
		///// </summary>
		///// <param name="doubleClick">If <c>true</c>, calls <see cref="MouseClickD"/>, else <see cref="MouseClick"/>.</param>
		///// <exception cref="Exception">Exceptions of <see cref="MouseClick"/> and <see cref="keys.send"/>.</exception>
		///// <inheritdoc cref="keys.send" path="/param"/>
		//public void SendKeys(bool doubleClick, [ParamString(PSFormat.keys)] params KKeysEtc[] keysEtc) {
		//	if (doubleClick) MouseClickD(); else MouseClick();
		//	keys.send(keysEtc);
		//}
		
		//rejected. Use SendKeys, it allows to specify keys to replace (Ctrl+A), append (Ctrl+End), etc.
		//public void SendText(string text, bool replace, [more options?]) {
		//	Focus();
		//	...
		//	keys.sendt(text);
		//}
		
		bool _CheckNeedToggle(bool check) {
			ThrowIfDisposed_();
			var state = State;
			//if (state.Has(EState.DISABLED)) throw new AuException("Disabled."); //can do more bad than good, eg if DISABLED state is when not actually disabled
			bool isChecked = state.Has(EState.CHECKED);
			if (!isChecked) isChecked = state.Has(EState.PRESSED) && !MiscFlags.HasAny(EMiscFlags.UIA | EMiscFlags.Java) && RoleInt == ERole.BUTTON /*&& WndContainer.ClassNameIs("Chrome*")*/; //eg the toggle buttons in Chrome settings have state PRESSED instead of CHECKED
			return isChecked != check;
		}
		
		/// <summary>
		/// Checks or unchecks this checkbox or toggle-button, or selects this radio button. Uses <see cref="Invoke"/> or <see cref="SendKeys"/>.
		/// </summary>
		/// <param name="check"><c>true</c> to check, <c>false</c> to uncheck.</param>
		/// <param name="keys">Keys for <see cref="SendKeys"/>. If <c>""</c>, uses <c>"Space"</c>. If <c>null</c> (default), uses <see cref="Invoke"/>.</param>
		/// <exception cref="Exception">Exceptions of <see cref="Invoke"/> or <see cref="SendKeys"/>.</exception>
		/// <remarks>
		/// Does nothing if the UI element already has the requested checked/unchecked state. Else tries to change the state and does not verify whether it actually worked.
		/// 
		/// Does not work with 3-state checkboxes and with elements that never have <c>CHECKED</c> state.
		/// </remarks>
		public void Check(bool check = true, [ParamString(PSFormat.Keys)] string keys = null) {
			if (!_CheckNeedToggle(check)) return;
			if (keys != null) {
				SendKeys(keys.Length == 0 ? "Space" : keys);
			} else {
				_Invoke(MiscFlags.Has(EMiscFlags.UIA) ? 'c' : 'a');
			}
		}
		
		/// <summary>
		/// Checks or unchecks this checkbox or toggle-button, or selects this radio button. To check/uncheck calls callback function.
		/// </summary>
		/// <param name="action">Callback function that should check or uncheck this UI element. Its parameter is this variable.</param>
		/// <exception cref="Exception">Exceptions of the callback function.</exception>
		/// <inheritdoc cref="Check(bool, string)"/>
		public void Check(bool check, Action<elm> action) {
			if (!_CheckNeedToggle(check)) return;
			action(this);
		}
		
		//rejected: Check and Expand overloads for mouse.
		//	Script code like 'e.Check(true, false) looks not good.
		//	Better 'e.Check(true, e => e.MouseClick())' or 'e.Check(true, e => e.PostClick())'.
		
		/// <summary>
		/// Expands or collapse this expandable UI element (tree item, combo box, expander, dropdown button).
		/// </summary>
		/// <param name="expand"><c>true</c> to expand, <c>false</c> to collapse.</param>
		/// <param name="keys">If not <c>null</c>, makes this element focused and presses these keys. See <see cref="keys.send"/>. If <c>""</c>, uses keys commonly used for that UI element type, for example <c>Right</c>/<c>Left</c> for <c>TREEITEM</c>, <c>Alt+Down</c> for <c>COMBOBOX</c>. If <c>null</c>, uses <see cref="Invoke"/> or similar functions, which often are available only if the element was found with flag <c>UIA</c>; if unavailable or fails, works like with <i>keys</i> <c>""</c>.</param>
		/// <param name="waitS">If not 0, waits for new expanded/collapsed state max this number of seconds; on timeout throws exception, unless negative.</param>
		/// <param name="ignoreState">Ignore initial <c>EXPANDED</c>/<c>COLLAPSED</c> state and always perform the expand/collapse action. Can be useful when <see cref="State"/> <c>EXPANDED</c>/<c>COLLAPSED</c> is incorrect. To ignore final state, use negative <i>waitS</i> instead, for example -0.001.</param>
		/// <exception cref="Exception">Exceptions of <see cref="SendKeys"/>.</exception>
		/// <exception cref="TimeoutException">The state didn't change in <i>waitS</i> seconds (if > 0).</exception>
		/// <remarks>
		/// Does nothing if the UI element already has the requested expanded/collapsed state.
		/// 
		/// Works with UI elements that have <see cref="State"/> <c>EXPANDED</c> when expanded and <c>COLLAPSED</c> when collapsed. Also with UI elements that have state <c>CHECKED</c> or <c>PRESSED</c> when expanded and don't have this state when collapsed.
		/// </remarks>
		public void Expand(bool expand = true, [ParamString(PSFormat.Keys)] string keys = null, double waitS = 1, bool ignoreState = false) {
			_Expand(expand, keys, null, waitS, ignoreState);
		}
		
		/// <param name="action">Callback function that should expand or collapse this UI element. Its parameter is this variable.</param>
		/// <exception cref="Exception">Exceptions of the callback function.</exception>
		/// <inheritdoc cref="Expand(bool, string, double, bool)"/>
		public void Expand(bool expand, Action<elm> action, double waitS = 1, bool ignoreState = false) {
			_Expand(expand, null, action, waitS, ignoreState);
		}
		
		void _Expand(bool expand, string keys, Action<elm> action, double waitS, bool ignoreState) {
			ThrowIfDisposed_();
			
			bool _NeedToggle(bool expand) {
				var state = State;
				//print.it(RoleInt, Role, state);
				//note: ignore DISABLED state. Some non-disabled elements have it. Also probably would need to get state of parent TREEVIEW.
				bool isExpanded = !state.Has(EState.COLLAPSED) && state.HasAny(EState.EXPANDED | EState.CHECKED | EState.PRESSED);
				return isExpanded != expand;
			}
			if (!ignoreState) if (!_NeedToggle(expand)) return;
			
			int how = action != null ? 2 : keys != null ? 1 : 0;
			if (how == 0) {
				how = 1;
				if (MiscFlags.Has(EMiscFlags.UIA)) {
					if (0 == _InvokeL(expand ? 'E' : 'e')) how = 0;
				} else if (_ClassicTreeview()) {
					how = 0;
				} else {
					var da = DefaultAction;
					if (!da.NE()) {
						if (MiscFlags.Has(EMiscFlags.Java)) {
							//usually treeitem's default action is "toggleexpand", and it works. Other ways (mouse, focus+keys) are unreliable.
							//combobox action is "togglePopup", and requires active window. Does not wait until popup closed (good).
							if (da != "toggleexpand") WndTopLevel.Activate();
							if (0 == _InvokeL('a', da)) how = 0;
						} else {
							if (0 == _InvokeL()) how = 0;
							//never mind: not all actions Expand/Collapse, even if TREEITEM. Eg in Thunderbird.
							//	Could use keys etc if state didn't change eg in 0.5 s, but it can make less reliable.
							//	Let users choose another overload.
						}
					} else if (RoleInt == ERole.COMBOBOX) { //classic combobox?
						if (0 == _GetWnd(out wnd w) && w.CommonControlType == WControlType.Combobox) {
							w.SendNotify(0x014F, expand ? 1 : 0); //CB_SHOWDROPDOWN
							how = 0;
						}
					}
				}
			}
			
			if (how == 1) {
				Focus(andSelect: RoleInt is ERole.TREEITEM or ERole.LISTITEM or ERole.Custom); //exception if fails
				if (keys.NE()) {
					var role = MiscFlags.Has(EMiscFlags.Java) && Role == "combo box" ? ERole.COMBOBOX : RoleInt;
					keys = role switch {
						ERole.TREEITEM or ERole.LISTITEM or ERole.Custom => expand ? "Right" : "Left", //LISTITEM for treeviews made from listviews (not tested); Custom because we prefer treeviews
						ERole.COMBOBOX or ERole.DROPLIST => expand ? "Alt+Down" : "Esc", //DROPLIST used by the classic date/time picker, but does not work because state always 0
						ERole.BUTTON or ERole.CHECKBOX => "Space", //eg expander
						ERole.BUTTONDROPDOWN or ERole.BUTTONDROPDOWNGRID or ERole.BUTTONMENU => expand ? "Space" : "Esc",
						_ => expand ? "Down" : "Esc", //eg classic toolbar's SPLITBUTTON's dropdown part (MENUITEM); also classic SPLITBUTTON
					};
				}
				Au.keys.send(keys);
			} else if (how == 2) {
				action(this);
			}
			
			if (waitS != 0) {
				//10.ms();
				wait.until(waitS, () => !_NeedToggle(expand));
			}
			
			bool _ClassicTreeview() {
				if (Item == 0 || RoleInt != ERole.TREEITEM) return false;
				if (0 != _GetWnd(out wnd w) || w.CommonControlType != WControlType.Treeview) return false;
				if (osVersion.is32BitProcessAnd64BitOS && !w.Is32Bit) return false; //cannot get 64-bit HTREEITEM
				nint hi = w.Send(TVM_MAPACCIDTOHTREEITEM, Item); if (hi == 0) return false;
				_Expand_ClassicTreeview(w, hi, expand);
				return true;
			}
		}
		
		static void _Expand_ClassicTreeview(wnd w, nint hi, bool expand) {
#if false //like MSAA Invoke. Bad: no TVN_ITEMEXPANDED etc; eg does not change folder icon open/closed.
			w.Send(0x1102, expand ? 2 : 1, hi); //TVM_EXPAND(TVE_EXPAND:TVE_COLLAPSE)
			if (expand) w.Send(0x1114, 0, hi); //TVM_ENSUREVISIBLE
#else //like UIA expand/collapse. Bad: dirty; selects, which may do more than expand/collapse; for TVSI_NOSINGLEEXPAND need manifest.
			for (int i = 0; i < 5; i++) { //eg in old VS first time returns 0, although works. UIA sends 2 times.
				if (0 != w.Send(TVM_SELECTITEM, TVGN_CARET | TVSI_NOSINGLEEXPAND, hi)) break;
				Debug_.PrintIf(i > 0, "elm.Expand");
				//if (i > 0) wait.ms(i * 10);
			}
			int k = (int)(expand ? KKey.Right : KKey.Left);
			w.SendNotify(Api.WM_KEYDOWN, k);
			w.SendNotify(Api.WM_KEYUP, k);
			10.ms();
			//UIA posts, but then eg in old VS does not work if the control wasn't focused. Maybe that is why UIA always sets real focus.
			//CONSIDER: wnd.PostKey(), wnd.PostText().
#endif
		}
		
		/// <summary>
		/// Expands multiple treeview control items using a path string.
		/// </summary>
		/// <param name="path">
		/// String or array consisting of names (<see cref="Name"/>) of <c>TREEITEM</c> elements, like <c>"One|Two|Three"</c> or <c>["One", "Two", "Three"]</c>.
		/// Name string format: [wildcard expression](xref:wildcard_expression).
		/// </param>
		/// <param name="keys"><c>null</c> or keys to use to expand each element specified in <i>path</i>. See <see cref="Expand(bool, string, double, bool)"/>.</param>
		/// <param name="waitS">If not 0, after expanding each element waits for expanded state max this number of seconds; on timeout throws exception, unless negative. Also waits for each element this number of seconds; always exception if not found.</param>
		/// <param name="notLast">Find but don't expand the last element specified in <i>path</i>. For example if it's not a folder, and therefore can't expand it, but you need to find it (this function returns it).</param>
		/// <returns><see cref="elm"/> of the last element specified in <i>path</i>.</returns>
		/// <exception cref="ArgumentException"><i>path</i> contains an invalid wildcard expression (<c>"**options "</c> or regular expression).</exception>
		/// <exception cref="NotFoundException">Failed to find an element specified in <i>path</i>.</exception>
		/// <exception cref="AuException">Failed.</exception>
		/// <exception cref="TimeoutException">The state didn't change in <i>waitS</i> seconds (if > 0).</exception>
		/// <exception cref="NotSupportedException">The treeview control type is not supported when this is a 32-bit process running on 64-bit OS (unlikely).</exception>
		/// <exception cref="Exception">Exceptions of <see cref="SendKeys"/>.</exception>
		/// <remarks>
		/// This element can be a <c>TREE</c> or <c>TREEITEM</c>. If it is a collapsed <c>TREEITEM</c>, expands it. Then finds and expands elements specified in <i>path</i>.
		/// 
		/// Does not work if all <c>TREEITEM</c> elements in the <c>TREE</c> control are its direct children, unless it's the standard Windows treeview control.
		/// </remarks>
		public elm Expand(Strings path, [ParamString(PSFormat.Keys)] string keys = null, double waitS = 3, bool notLast = false) {
			return _ExpandPath(path, keys, null, waitS, notLast);
		}
		
		/// <param name="action">Callback function that should expand UI elements.</param>
		/// <exception cref="Exception">Exceptions of the callback function.</exception>
		/// <remarks></remarks>
		/// <inheritdoc cref="Expand(Au.Types.Strings, string, double, bool)"/>
		public elm Expand(Strings path, Action<elm> action, double waitS = 3, bool notLast = false) {
			return _ExpandPath(path, null, action, waitS, notLast);
		}
		
		elm _ExpandPath(Strings path, string keys, Action<elm> action, double waitS, bool notLast) {
			ThrowIfDisposed_();
			var a = path.ToArray();
			var e = this;
			//for classic treeview controls need special code if not UIA, because the MSAA tree is flat
			if (!MiscFlags.HasAny(EMiscFlags.UIA | EMiscFlags.Java) && 0 == _GetWnd(out wnd w) && w.CommonControlType == WControlType.Treeview) {
				if (osVersion.is32BitProcessAnd64BitOS && !w.Is32Bit) throw new NotSupportedException("32-bit process."); //cannot get 64-bit HTREEITEM
				
				nint hi = 0;
				if (Item > 0) {
					hi = w.Send(TVM_MAPACCIDTOHTREEITEM, Item); if (hi == 0) throw new AuException();
					_ExpandIfNeed(this, hi);
				}
				
				for (int i = 0; i < a.Length; i++) {
					var name = a[i];
					bool ok = waitS == 0 ? _Find(name) : wait.until(-Math.Abs(waitS), () => _Find(name));
					if (!ok) throw new NotFoundException("Not found elm expand path part: " + name);
					if (notLast && i == a.Length - 1) break;
					_ExpandIfNeed(e, hi);
				}
				
				bool _Find(wildex name) {
					elm temp = null;
					for (nint h = w.Send(TVM_GETNEXTITEM, hi == 0 ? TVGN_ROOT : TVGN_CHILD, hi); h != 0; h = w.Send(TVM_GETNEXTITEM, TVGN_NEXT, h)) {
						int item = (int)w.Send(TVM_MAPHTREEITEMTOACCID, h); if (item == 0) throw new AuException();
						var acc = new Cpp.Cpp_Acc(_iacc, item) { misc = _misc };
						if (Item == 0) { acc.misc.level++; acc.misc.roleByte = (byte)ERole.TREEITEM; }
						var s = _GetStringPropL(acc, 'n'); //the slowest part of this 'for'. FUTURE: if somewhere too slow, could make inproc.
						GC.KeepAlive(this);
						if (name.Match(s)) {
							if (temp == null) temp = new(acc, addRef: true); else temp.Item = item;
							e = temp;
							hi = h;
							return true;
						}
					}
					return false;
				}
				
				void _ExpandIfNeed(elm e, nint hi) {
					if (_IsExpanded(w, hi)) return;
					
					if (keys != null) e.SendKeys(keys.Length > 0 ? keys : "Right");
					else if (action != null) action(e);
					else _Expand_ClassicTreeview(w, hi, true);
					//p1.Next();
					
					if (waitS != 0) wait.until(waitS, () => _IsExpanded(w, hi));
					else _IsExpanded(w, hi); //usually waits
				}
				
				static bool _IsExpanded(wnd w, nint hi) => 0 != ((int)w.Send(TVM_GETITEMSTATE, hi, TVIS_EXPANDED) & TVIS_EXPANDED);
			} else {
				if (State.Has(EState.COLLAPSED))
					_Expand(true, keys, action, waitS, ignoreState: true);
				
				foreach (var name in a) {
					int level = e.Level;
					e = e.Elm[null, name, "level=0", also: o => o.State.HasAny(EState.EXPANDED | EState.COLLAPSED)].Find(-(Math.Abs(waitS) + .01));
					if (e == null) throw new NotFoundException("Not found elm expand path part: " + name);
					e.Level = level + 1;
					e._Expand(true, keys, action, waitS, ignoreState: false);
				}
			}
			return e;
		}
		
		/// <summary>
		/// Finds and selects an item in the drop-down list of this combo box or drop-down button.
		/// </summary>
		/// <param name="item">
		/// Item name (<see cref="Name"/>).
		/// String format: [wildcard expression](xref:wildcard_expression).
		/// </param>
		/// <param name="how">
		/// Try this parameter if the function fails to select the item etc.
		/// 
		/// <para>
		/// In the string can be used these characters to specify how to select the item and close the drop-down list:
		/// <br/>• <c>i</c> - call <see cref="Invoke"/>.
		/// <br/>• <c>s</c> - call <see cref="Select"/>.
		/// <br/>• <c>c</c> - close the list with <see cref="Expand"/>.
		/// <br/>• <c>m</c> - call <see cref="MouseClick"/>; often can't be used because fails to get correct rectangle or to scroll.
		/// <br/>• <c>k</c> - call <see cref="Focus"/> and <see cref="keys.send"/> (<c>Home</c>, <c>Down</c>, <c>Enter</c>).
		/// <br/>• space - nothing.
		/// </para>
		/// 
		/// If the string is <c>null</c> (default) or <c>""</c> or does not contain these characters, the function tries to detect and use what usually works for this UI element type, but it's impossible to detect always.
		/// 
		/// Usually need just a single character (string like <c>"i"</c> or <c>"m"</c>). If there are more characters, the functions are called in the specified order.
		/// 
		/// The string also can contain sleep times. For example <c>"300m"</c> will wait 300 ms and click; the first sleep will be between expanding and finding.
		/// 
		/// If the string starts with <c>"~"</c>, the function does not expand the drop-down list (it should be already expanded).
		/// 
		/// If the string isn't <c>null</c>/empty but does not contain characters <c>iscmk</c> (for example is <c>" "</c> or <c>"~ "</c> or <c>"200 "</c>), the function does not select/close. For example these codes do the same: <c>e.ComboSelect("Red", "i");</c> and <c>e.ComboSelect("Red", " ").Invoke();</c>.
		/// </param>
		/// <param name="waitS">Seconds to wait for expanded state (if not 0) and for the item. Can be negative to avoid timeout exceptions.</param>
		/// <returns>The item.</returns>
		/// <exception cref="ArgumentException">Error in <i>item</i> string (wildex options or regex) or <i>how</i>.</exception>
		/// <exception cref="NotFoundException">Item not found.</exception>
		/// <exception cref="Exception">Exceptions of used functions.</exception>
		/// <remarks>
		/// The function at first calls <see cref="Expand(bool, string, double, bool)"/> to show the drop-down list, unless <i>how</i> starts with <c>"~"</c>. Then finds the item by name, selects it and closes the drop-down list.
		/// </remarks>
		public elm ComboSelect(string item, string how = null, double waitS = 3) {
			//Works with most tested combobox types: native, web, WPF, UWP, ribbon, Office, Qt, Java, JavaFX.
			//	Does not work with OpenOffice: can't expand, need Invoke() but it isn't called because there is no DefaultAction. Didn't try to select items. Never mind, anyway no API in dialogs, only in main window.
			//	Not tested GTK. Don't have apps with working API.
			//Problems in Chrome:
			//	Select() does not work. Use Invoke(); it also collapses.
			//Problems in Firefox:
			//	Standard <select> CB don't change EXPANDED state. Eg in MyBB forum search.
			//	With some CB Select() does not work, and Invoke() works. With others vice versa.
			//	With some CB Invoke() collapses, with others not.
			//Problems in Chrome and Firefox:
			//	CB items may be not attached to the CB in the tree. Etc. More info below in _FindWebNotCOMBOBOX.
			//	With standard CB MouseClick() does not work, because gives item rect same as CB rect.
			//	With some CB selects but it does not work like when clicked. Eg does not refresh the page (eg aruodas).
			//		In FF can't click because of bad rect, but may work together with Select(). Sometimes Enter works.
			
			ThrowIfDisposed_();
			
			elm e = null;
			bool auto = how.NE() || how.FindNot("-1234567890") < 0;
			int h = how.NE() ? -1 : 0; //index in how
			bool invoke = false;
			
			#region detect window type
			int iw = 0; //1 Chrome, 2 Firefox, 3 ribbon, 4 Qt5, 10 Java, 11 JavaFX
			wnd w = default;
			if (MiscFlags.Has(EMiscFlags.Java)) {
				iw = 10;
			} else if (0 == _GetWnd(out w)) {
				if (MiscFlags.Has(EMiscFlags.UIA)) {
					if (w.ClassNameIs("GlassWndClass*")) iw = 11;
				} else {
					iw = w.ClassNameIs("Chrome*", "Mozilla*", "NetUIHWND"/*ribbon*/, "Qt5QWindow*");
					invoke = iw is 1 or 3;
				}
			}
			#endregion
			
			#region activate/focus if need
			if (!auto) {
				if (how.Contains('k')) {
					Focus();
				} else if (how.Contains('m')) {
					if (iw == 10) _GetWnd(out w);
					w.Window.Activate();
				}
			} else if (iw is 4 or 10) { //Qt, Java
				Focus();
			}
			#endregion
			
			#region expand
			bool noExpand = false, noState = false;
			if (RoleInt == ERole.COMBOBOX) {
				var state = State;
				noExpand = state.Has(EState.EXPANDED);
				noState = !state.HasAny(EState.COLLAPSED | EState.EXPANDED); //eg ribbon
			}
			if (h == 0 && how[h] == '~') {
				h++;
			} else if (!noExpand) {
				Expand(true, waitS: iw == 2 || noState ? -.1 : waitS);
				if (h == 0) _Sleep(); else 10.ms();
			}
			#endregion
			
			#region find item
			waitS = -Math.Abs(waitS);
			var f = Elm[null, item, flags: EFFlags.HiddenToo]; //usually CB item role is LISTITEM, sometimes MENUITEM, Java "label"; let's support any. May need HiddenToo for offscreen items, eg Java.
			if (iw is 1 or 2 && RoleInt is not ERole.COMBOBOX) {
				_FindWebNotCOMBOBOX();
			} else {
				var loop = new WaitLoop(waitS);
				for (; ; ) {
					e = f.Find();
					if (e == null) {
						if (iw == 11) { //JavaFX drop-down list isn't connected to the CB
							var wp = w.Get.EnabledOwned();
							//TODO3: now unreliable. Can detect a wrong window, eg a random tooltip.
							//	Try to detect more reliably. Eg must have certain styles and rect, contain LIST or MENUPOPUP, etc.
							//	Then could use with any window, not only JavaFX.
							//	Also then could detect expanded state even when there is no EXPANDED state.
							//	EnabledOwned isn't reliable in other places too.
							if (!wp.Is0) e = wp.Elm["LISTITEM", item, flags: EFFlags.UIA].Find();
						} else if (RoleInt != ERole.COMBOBOX && ChildCount == 0) { //eg ribbon dropdown button
							e = f.In(Parent).Find();
						}
					}
					if (e != null) break;
					if (!loop.Sleep()) break;
				}
			}
			if (e == null) throw new NotFoundException($"Can't find combo box item \"{item}\".");
			#endregion
			
			#region select and collapse
			if (!auto) {
				for (; h < how.Length; h++) {
					bool hasSelect = false;
					switch (how[h]) {
					case 's':
						e.Select();
						hasSelect = true;
						break;
					case 'i':
						e.Invoke();
						break;
					case 'm':
						if (iw == 2 && !hasSelect) e.Select(); //if bad rect, with this usually works anyway in FF
						e.MouseClick(scroll: iw == 2 ? 0 : 10);
						//FF bug: if scroll!=0, scrolls the combo (entire page), not the dropdown list item. Good: Select() scrolls.
						//note: WPF CB item rect changes because of dropdown animation
						break;
					case 'k':
						_Keys();
						break;
					case 'c':
						Expand(!true, waitS: -0.01, ignoreState: true);
						break;
					case ' ':
						break;
					default:
						_Sleep();
						continue;
					}
				}
			} else if (invoke) {
				e.Invoke();
			} else if (iw is 4 or 10) { //Qt, Java
				_Keys(); //nothing else works, only mouse if don't need to scroll
			} else {
				bool ignoreState = noState || (iw == 2 && !State.Has(EState.EXPANDED)); //standard <select> CB in FF does not change state
				e.Select();
				Expand(!true, waitS: -0.01, ignoreState: ignoreState);
			}
			#endregion
			return e;
			
			void _Keys() {
				var a = e.Parent.Elm[e.Role, prop: "level=0", flags: EFFlags.HiddenToo].FindAll(); //these are slow, but much faster than keys.send
				wildex wild = item;
				int i = Array.FindIndex(a, o => wild.Match(o.Name));
				if (i < 0) throw new AuException();
				Au.keys.send($"Home PgUp*{a.Length / 4} Down*{i} Enter"); //Home doesn't work with editable CB; PgUp may not work with some CB
			}
			
			void _Sleep() {
				if (!how[h].IsAsciiDigit()) { if (e == null) return; throw new ArgumentException("Invalid character " + how[h], "how"); }
				if (!how.ToInt(out int ms, h, out h)) throw new ArgumentException("Invalid number", "how");
				ms.ms();
			}
			
			void _FindWebNotCOMBOBOX() {
				//Web pages have multiple CB types. Sometimes the dropdown list isn't a descendant of the CB.
				//	In Google Advanced Search it is LIST with 2 children: MENUITEM and LISTITEM with same name (the selected).
				//		The list is a MENUPOPUP/MENUITEM near the bottom of the document. It may not contain the selected item.
				//	In Github profile Stars it is BUTTON with 0 children.
				//		The list is a MENUPOPUP/MENUITEM in its parent.
				
				elm pa = null, doc = null;
				var loop = new WaitLoop(waitS);
				for (; ; ) {
					e = f.Find(); //if the item is already selected, the dropdown list may not contain it, and this finds it
					if (e != null) break;
					pa ??= Parent; if (pa == null) break;
					var mp = pa.Elm["MENUPOPUP"].Find();
					if (mp != null) {
						e = mp.Elm["MENUITEM", item].Find();
					} else {
						if (doc == null) {
							for (var p = pa; p != null; p = p.Parent) if (p.RoleInt == ERole.DOCUMENT) { doc = p; break; }
						}
						if (doc != null) {
							e = doc.Elm["MENUPOPUP", flags: EFFlags.Reverse].Find()?.Elm["MENUITEM", item].Find();
						}
					}
					if (e != null) {
						invoke = true; //selects and closes in FF too; else difficult/unreliable.
						break;
					}
					if (!loop.Sleep()) break;
				}
			}
		}
		
		//wnd _GetOwnedPopupWindow(wnd w, RECT? r = null) {
		//	var p = w.Window.Get.EnabledOwned();
		//	if (!p.Is0) {
		//		var k = r ?? Rect;
		//		int i = k.Height / 2;
		//		k.Inflate(i, i);
		//		var pr = p.Rect;
		//		if (!pr.IntersectsWith(k) || pr.Height < k.Height * 2) p = default;
		//	}
		//	return p;
		//}
		
		const int TVM_MAPACCIDTOHTREEITEM = 0x112A;
		const int TVM_GETNEXTITEM = 0x110A;
		const int TVM_MAPHTREEITEMTOACCID = 0x112B;
		const int TVM_GETITEMSTATE = 0x1127;
		const int TVM_ENSUREVISIBLE = 0x1114;
		const int TVM_SELECTITEM = 0x110B;
		
		const int TVGN_ROOT = 0x0;
		const int TVGN_CHILD = 0x4;
		const int TVGN_NEXT = 0x1;
		const int TVGN_CARET = 0x9;
		const int TVSI_NOSINGLEEXPAND = 0x8000;
		
		const int TVIS_EXPANDED = 0x20;
		
		const int LVM_ENSUREVISIBLE = 0x1013;
		
		const int LB_SETTOPINDEX = 0x197;
		
	}
}

//rejected:
//	MenuSelect(path) - click, wait for popup menu, find/click, wait for another popup, .... Can check/uncheck.
//		Much easier and better to use keys.
//	ContextMenuSelect(path).
//		Let use MouseClickR and keys.

//TEST:
//	IUIAutomationScrollPattern: Scroll, SetScrollPercent.
//	IUIAutomationWindowPattern: Close, WaitForInputIdle, CurrentIsModal, CurrentWindowInteractionState.


================================================
FILE: Au/UI objects/elm_types.cs
================================================
namespace Au.Types {
	/// <summary>
	/// Flags for "find UI element" functions (<see cref="elmFinder"/>).
	/// </summary>
	[Flags]
	public enum EFFlags {
		/// <summary>
		/// Search in reverse order. It can make faster.
		/// When control class or id is specified in the <i>prop</i> argument, controls are searched not in reverse order. Only UI elements in them are searched in reverse order.
		/// </summary>
		Reverse = 1,

		/// <summary>
		/// The UI element can be invisible.
		/// Without this flag skips UI elements that are invisible (have state <c>INVISIBLE</c>) or are descendants of invisible <c>WINDOW</c>, <c>DOCUMENT</c>, <c>PROPERTYPAGE</c>, <c>GROUPING</c>, <c>ALERT</c>, <c>MENUPOPUP</c>.
		/// Regardless of this flag, always skips invisible standard UI elements of nonclient area: <c>TITLEBAR</c>, <c>MENUBAR</c>, <c>SCROLLBAR</c>, <c>GRIP</c>.
		/// </summary>
		HiddenToo = 2,

		/// <summary>
		/// Always search in <c>MENUITEM</c>.
		/// Without this flag skips <c>MENUITEM</c> descendant elements (for speed), unless <i>role</i> argument is <c>MENUITEM</c> or <c>MENUPOPUP</c> or searching in web page.
		/// </summary>
		MenuToo = 4,

		/// <summary>
		/// Search only in the client area of the window or control.
		/// Skips the title bar, standard menubars and scrollbars. Searches only in the client area root UI element (but will not find the UI element itself).
		/// When control class or id is specified in the <i>prop</i> argument, this flag is applied to these controls. Not applied to other controls.
		/// Don't use this flag when searching in elm or web page (role prefix <c>"web:"</c> etc) or with flag <c>UIA</c>.
		/// </summary>
		ClientArea = 8,

		/// <summary>
		/// Search without loading dll into the target process.
		/// Disadvantages: 1. Much slower. 2. Some properties are not supported, for example HTML attributes (while searching and later). 3. And more.
		/// Even without this flag, the default search method is not used with Windows Store app windows, console windows, most Java windows, windows of protected processes and processes of higher [](xref:uac) integrity level.
		/// Some windows have child controls that belong to a different process or thread than the window. For example the Windows Task Scheduler window. When searching in such windows, the default search method is not used when searching in these controls. Workaround - find the control (<see cref="wnd.Child"/> etc) and search in it.
		/// Don't need this flag when searching in elm (then it is inherited from the elm variable).
		/// See also: <see cref="elm.MiscFlags"/>.
		/// </summary>
		NotInProc = 0x100,

		/// <summary>
		/// Use UI Automation API.
		/// Need this flag to find UI elements in windows that don't support accessible objects but support UI Automation elements.
		/// UI elements found with this flag never have <c>HtmlX</c> properties, but can have <c>UiaX</c> properties.
		/// This flag can be used with most other windows too.
		/// Don't use this flag when searching in elm (then it is inherited from the elm variable) or web page (role prefix <c>"web:"</c> etc).
		/// See also: <see cref="elm.MiscFlags"/>.
		/// </summary>
		UIA = 0x200,

		//Internal. See Enum_.AFFlags_Mark.
		//Mark = 0x10000,
	}

	/// <summary>
	/// Adds internal members to public enums.
	/// </summary>
	internal static partial class Enum_ {
		/// <summary>
		/// Used by <c>Delm</c>, together with <c>ElmMiscFlags_Marked</c>.
		/// </summary>
		internal static EFFlags EFFlags_Mark = (EFFlags)0x10000;

		/// <summary>
		/// Used by <c>Delm</c>, together with <c>AFFlags_Mark</c>.
		/// </summary>
		internal static EMiscFlags EMiscFlags_Marked = (EMiscFlags)128;

		internal static EXYFlags EXYFlags_DpiScaled = (EXYFlags)0x10000;
		internal static EXYFlags EXYFlags_Fail = (EXYFlags)0x20000; //currently not used
	}

	/// <summary>
	/// Flags for <see cref="elm.fromWindow"/>.
	/// </summary>
	[Flags]
	public enum EWFlags {
		/// <summary>Don't throw exception when fails. Then returns <c>null</c>.</summary>
		NoThrow = 1,

		/// <summary>
		/// Don't load dll into the target process.
		/// More info: <see cref="EFFlags.NotInProc"/>.
		/// </summary>
		NotInProc = 2,
	}

	/// <summary>
	/// Flags for <see cref="elm.fromXY"/>.
	/// </summary>
	[Flags]
	public enum EXYFlags {
		/// <summary>
		/// Don't load dll into the target process.
		/// More info: <see cref="EFFlags.NotInProc"/>.
		/// </summary>
		NotInProc = 1,

		/// <summary>
		/// Use UI Automation API.
		/// More info: <see cref="EFFlags.UIA"/>.
		/// </summary>
		UIA = 2,

		/// <summary>
		/// Get the direct parent UI element if probably it would be much more useful, for example if its role is <c>LINK</c> or <c>BUTTON</c>.
		/// Usually links have one or more children of type <c>TEXT</c>, <c>STATICTEXT</c>, <c>IMAGE</c> or other.
		/// </summary>
		PreferLink = 4,

		[Obsolete]
#pragma warning disable CS1591 //Missing XML comment for publicly visible type or member
		TrySmaller = 8,
#pragma warning restore CS1591 //Missing XML comment for publicly visible type or member

		/// <summary>
		/// Use UI Automation API if the default API fails and in some other cases.
		/// The <b>Find UI element</b> tool uses this flag when <c>UIA</c> is in indeterminate state.
		/// </summary>
		OrUIA = 16,

		//note: don't change values. They are passed to the cpp function.
	}

	/// <summary>
	/// Flags for <see cref="elm.focused"/>.
	/// </summary>
	[Flags]
	public enum EFocusedFlags {
		/// <summary>
		/// Don't load dll into the target process.
		/// More info: <see cref="EFFlags.NotInProc"/>.
		/// </summary>
		NotInProc = 1,

		/// <summary>
		/// Use UI Automation API.
		/// Need this flag with some windows that don't support accessible objects but support UI Automation elements. Can be used with most other windows too.
		/// More info: <see cref="EFFlags.UIA"/>.
		/// </summary>
		UIA = 2,

		//note: don't change values. They are passed to the cpp function.
	}

	/// <summary>
	/// Flags returned by <see cref="elm.MiscFlags"/>.
	/// </summary>
	[Flags]
	public enum EMiscFlags : byte {
		/// <summary>
		/// This UI element was retrieved by the dll loaded into its process.
		/// More info: <see cref="EFFlags.NotInProc"/>.
		/// </summary>
		InProc = 1,

		/// <summary>
		/// This UI element was retrieved using UI Automation API.
		/// More info: <see cref="EFFlags.UIA"/>.
		/// </summary>
		UIA = 2,

		/// <summary>
		/// This UI element was retrieved using Java Access Bridge API.
		/// More info: <see cref="elm"/>.
		/// </summary>
		Java = 4,

		//Internal. See Enum_.ElmMiscFlags_Marked.
		//Marked = 128,
	}

#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member

	/// <summary>
	/// Object ids of window parts and some special UI elements.
	/// Used with <see cref="elm.fromWindow"/>
	/// </summary>
	/// <remarks>
	/// Most names are as in API <ms>AccessibleObjectFromWindow</ms> documentation but without prefix <c>OBJID_</c>.
	/// </remarks>
	public enum EObjid {
		WINDOW = 0,
		SYSMENU = -1,
		TITLEBAR = -2,
		MENU = -3,
		CLIENT = -4,
		VSCROLL = -5,
		HSCROLL = -6,
		SIZEGRIP = -7,
		CARET = -8,
		CURSOR = -9,
		ALERT = -10,
		SOUND = -11,
		/// <summary>Not used with <see cref="elm.fromWindow"/>.</summary>
		QUERYCLASSNAMEIDX = -12,
		/// <summary>Not used with <see cref="elm.fromWindow"/>.</summary>
		NATIVEOM = -16,
		/// <summary>Not used with <see cref="elm.fromWindow"/>.</summary>
		UiaRootObjectId = -25,

		//ours

		/// <summary>
		/// The root Java UI element. Can be used when the window's class name starts with <c>"SunAwt"</c>.
		/// </summary>
		Java = -100,

		/// <summary>
		/// Use UI Automation API.
		/// More info: <see cref="EFFlags.UIA"/>.
		/// </summary>
		UIA = -101,
	}

	/// <summary>
	/// Standard roles of UI elements.
	/// Used with <see cref="elm.RoleInt"/>
	/// </summary>
	/// <remarks>
	/// Most names are as in API <ms>IAccessible.get_accRole Object Roles</ms> documentation but without prefix <c>ROLE_SYSTEM_</c>. These are renamed: <c>PUSHBUTTON</c> to <c>BUTTON</c>, <c>CHECKBUTTON</c> to <c>CHECKBOX</c>, <c>GRAPHIC</c> to <c>IMAGE</c>, <c>OUTLINE</c> to <c>TREE</c>, <c>OUTLINEITEM</c> to <c>TREEITEM</c>, <c>OUTLINEBUTTON</c> to <c>TREEBUTTON</c>.
	/// </remarks>
	public enum ERole {
		TITLEBAR = 0x1,
		MENUBAR = 0x2,
		SCROLLBAR = 0x3,
		GRIP = 0x4,
		SOUND = 0x5,
		CURSOR = 0x6,
		CARET = 0x7,
		ALERT = 0x8,
		WINDOW = 0x9,
		CLIENT = 0xA,
		MENUPOPUP = 0xB,
		MENUITEM = 0xC,
		TOOLTIP = 0xD,
		APPLICATION = 0xE,
		DOCUMENT = 0xF,
		PANE = 0x10,
		CHART = 0x11,
		DIALOG = 0x12,
		BORDER = 0x13,
		GROUPING = 0x14,
		SEPARATOR = 0x15,
		TOOLBAR = 0x16,
		STATUSBAR = 0x17,
		TABLE = 0x18,
		COLUMNHEADER = 0x19,
		ROWHEADER = 0x1A,
		COLUMN = 0x1B,
		ROW = 0x1C,
		CELL = 0x1D,
		LINK = 0x1E,
		HELPBALLOON = 0x1F,
		CHARACTER = 0x20,
		LIST = 0x21,
		LISTITEM = 0x22,
		TREE = 0x23, //OUTLINE
		TREEITEM = 0x24, //OUTLINEITEM
		PAGETAB = 0x25,
		PROPERTYPAGE = 0x26,
		INDICATOR = 0x27,
		IMAGE = 0x28, //GRAPHIC
		STATICTEXT = 0x29,
		TEXT = 0x2A,
		BUTTON = 0x2B, //PUSHBUTTON
		CHECKBOX = 0x2C, //CHECKBUTTON
		RADIOBUTTON = 0x2D,
		COMBOBOX = 0x2E,
		DROPLIST = 0x2F,
		PROGRESSBAR = 0x30,
		DIAL = 0x31,
		HOTKEYFIELD = 0x32,
		SLIDER = 0x33,
		SPINBUTTON = 0x34,
		DIAGRAM = 0x35,
		ANIMATION = 0x36,
		EQUATION = 0x37,
		BUTTONDROPDOWN = 0x38,
		BUTTONMENU = 0x39,
		BUTTONDROPDOWNGRID = 0x3A,
		WHITESPACE = 0x3B,
		PAGETABLIST = 0x3C,
		CLOCK = 0x3D,
		SPLITBUTTON = 0x3E,
		IPADDRESS = 0x3F,
		TREEBUTTON = 0x40, //OUTLINEBUTTON

		/// <summary>Failed to get role.</summary>
		None = 0,

		/// <summary>Not one of predefined roles. Usually string.</summary>
		Custom = 0xFF,
	}

	/// <summary>
	/// UI element state flags.
	/// Used by <see cref="elm.State"/>.
	/// </summary>
	/// <remarks>
	/// Most names are as in API <ms>IAccessible.get_accState Object State Constants</ms> documentation but without prefix <c>STATE_SYSTEM_</c>.
	/// </remarks>
	[Flags]
	public enum EState {
		//NORMAL = 0x0,
		DISABLED = 0x1, //original name UNAVAILABLE
		SELECTED = 0x2,
		FOCUSED = 0x4,
		PRESSED = 0x8,
		CHECKED = 0x10,
		MIXED = 0x20,
		READONLY = 0x40,
		HOTTRACKED = 0x80,
		DEFAULT = 0x100,
		EXPANDED = 0x200,
		COLLAPSED = 0x400,
		BUSY = 0x800,
		FLOATING = 0x1000,
		MARQUEED = 0x2000,
		ANIMATED = 0x4000,
		INVISIBLE = 0x8000,
		OFFSCREEN = 0x10000,
		SIZEABLE = 0x20000,
		MOVEABLE = 0x40000,
		SELFVOICING = 0x80000,
		FOCUSABLE = 0x100000,
		SELECTABLE = 0x200000,
		LINKED = 0x400000,
		TRAVERSED = 0x800000,
		MULTISELECTABLE = 0x1000000,
		EXTSELECTABLE = 0x2000000,
		ALERT_LOW = 0x4000000,
		ALERT_MEDIUM = 0x8000000,
		ALERT_HIGH = 0x10000000,
		PROTECTED = 0x20000000,
		HASPOPUP = 0x40000000,
	}

	/// <summary>
	/// UI element selection flags.
	/// Used by <see cref="elm.Select"/>.
	/// </summary>
	/// <remarks>
	/// The names are as in API <ms>IAccessible.accSelect</ms> documentation but without prefix <c>SELFLAG_</c>.
	/// </remarks>
	[Flags]
	public enum ESelect {
		TAKEFOCUS = 0x1,
		TAKESELECTION = 0x2,
		EXTENDSELECTION = 0x4,
		ADDSELECTION = 0x8,
		REMOVESELECTION = 0x10,
	}

	/// <summary>
	/// Event constants for <see cref="More.WinEventHook"/>.
	/// </summary>
	/// <remarks>
	/// The names are as in API <ms>SetWinEventHook Event Constants</ms> documentation but without prefix <c>EVENT_</c>.
	/// </remarks>
	public enum EEvent {
		MIN = 0x1,
		MAX = 0x7FFFFFFF,

		SYSTEM_SOUND = 0x1,
		SYSTEM_ALERT = 0x2,
		SYSTEM_FOREGROUND = 0x3,
		SYSTEM_MENUSTART = 0x4,
		SYSTEM_MENUEND = 0x5,
		SYSTEM_MENUPOPUPSTART = 0x6,
		SYSTEM_MENUPOPUPEND = 0x7,
		SYSTEM_CAPTURESTART = 0x8,
		SYSTEM_CAPTUREEND = 0x9,
		SYSTEM_MOVESIZESTART = 0xA,
		SYSTEM_MOVESIZEEND = 0xB,
		SYSTEM_CONTEXTHELPSTART = 0xC,
		SYSTEM_CONTEXTHELPEND = 0xD,
		SYSTEM_DRAGDROPSTART = 0xE,
		SYSTEM_DRAGDROPEND = 0xF,
		SYSTEM_DIALOGSTART = 0x10,
		SYSTEM_DIALOGEND = 0x11,
		SYSTEM_SCROLLINGSTART = 0x12,
		SYSTEM_SCROLLINGEND = 0x13,
		SYSTEM_SWITCHSTART = 0x14,
		SYSTEM_SWITCHEND = 0x15,
		SYSTEM_MINIMIZESTART = 0x16,
		SYSTEM_MINIMIZEEND = 0x17,
		SYSTEM_DESKTOPSWITCH = 0x20,
		SYSTEM_SWITCHER_APPGRABBED = 0x24,
		SYSTEM_SWITCHER_APPOVERTARGET = 0x25,
		SYSTEM_SWITCHER_APPDROPPED = 0x26,
		SYSTEM_SWITCHER_CANCELLED = 0x27,
		SYSTEM_IME_KEY_NOTIFICATION = 0x29,
		SYSTEM_END = 0xFF,

		OEM_DEFINED_START = 0x101,
		OEM_DEFINED_END = 0x1FF,

		UIA_EVENTID_START = 0x4E00,
		UIA_EVENTID_END = 0x4EFF,
		UIA_PROPID_START = 0x7500,
		UIA_PROPID_END = 0x75FF,

		CONSOLE_CARET = 0x4001,
		CONSOLE_UPDATE_REGION = 0x4002,
		CONSOLE_UPDATE_SIMPLE = 0x4003,
		CONSOLE_UPDATE_SCROLL = 0x4004,
		CONSOLE_LAYOUT = 0x4005,
		CONSOLE_START_APPLICATION = 0x4006,
		CONSOLE_END_APPLICATION = 0x4007,
		CONSOLE_END = 0x40FF,

		OBJECT_CREATE = 0x8000,
		OBJECT_DESTROY = 0x8001,
		OBJECT_SHOW = 0x8002,
		OBJECT_HIDE = 0x8003,
		OBJECT_REORDER = 0x8004,
		OBJECT_FOCUS = 0x8005,
		OBJECT_SELECTION = 0x8006,
		OBJECT_SELECTIONADD = 0x8007,
		OBJECT_SELECTIONREMOVE = 0x8008,
		OBJECT_SELECTIONWITHIN = 0x8009,
		OBJECT_STATECHANGE = 0x800A,
		OBJECT_LOCATIONCHANGE = 0x800B,
		OBJECT_NAMECHANGE = 0x800C,
		OBJECT_DESCRIPTIONCHANGE = 0x800D,
		OBJECT_VALUECHANGE = 0x800E,
		OBJECT_PARENTCHANGE = 0x800F,
		OBJECT_HELPCHANGE = 0x8010,
		OBJECT_DEFACTIONCHANGE = 0x8011,
		OBJECT_ACCELERATORCHANGE = 0x8012,
		OBJECT_INVOKED = 0x8013,
		OBJECT_TEXTSELECTIONCHANGED = 0x8014,
		OBJECT_CONTENTSCROLLED = 0x8015,
		SYSTEM_ARRANGMENTPREVIEW = 0x8016,
		OBJECT_CLOAKED = 0x8017,
		OBJECT_UNCLOAKED = 0x8018,
		OBJECT_LIVEREGIONCHANGED = 0x8019,
		OBJECT_HOSTEDOBJECTSINVALIDATED = 0x8020,
		OBJECT_DRAGSTART = 0x8021,
		OBJECT_DRAGCANCEL = 0x8022,
		OBJECT_DRAGCOMPLETE = 0x8023,
		OBJECT_DRAGENTER = 0x8024,
		OBJECT_DRAGLEAVE = 0x8025,
		OBJECT_DRAGDROPPED = 0x8026,
		OBJECT_IME_SHOW = 0x8027,
		OBJECT_IME_HIDE = 0x8028,
		OBJECT_IME_CHANGE = 0x8029,
		OBJECT_TEXTEDIT_CONVERSIONTARGETCHANGED = 0x8030,
		OBJECT_END = 0x80FF,

		AIA_START = 0xA000,
		AIA_END = 0xAFFF,

		IA2_ACTION_CHANGED = 0x101,
		IA2_ACTIVE_DESCENDANT_CHANGED = 0x102,
		IA2_DOCUMENT_ATTRIBUTE_CHANGED = 0x103,
		IA2_DOCUMENT_CONTENT_CHANGED = 0x104,
		IA2_DOCUMENT_LOAD_COMPLETE = 0x105,
		IA2_DOCUMENT_LOAD_STOPPED = 0x106,
		IA2_DOCUMENT_RELOAD = 0x107,
		IA2_HYPERLINK_END_INDEX_CHANGED = 0x108,
		IA2_HYPERLINK_NUMBER_OF_ANCHORS_CHANGED = 0x109,
		IA2_HYPERLINK_SELECTED_LINK_CHANGED = 0x10a,
		IA2_HYPERTEXT_LINK_ACTIVATED = 0x10b,
		IA2_HYPERTEXT_LINK_SELECTED = 0x10c,
		IA2_HYPERLINK_START_INDEX_CHANGED = 0x10d,
		IA2_HYPERTEXT_CHANGED = 0x10e,
		IA2_HYPERTEXT_NLINKS_CHANGED = 0x10f,
		IA2_OBJECT_ATTRIBUTE_CHANGED = 0x110,
		IA2_PAGE_CHANGED = 0x111,
		IA2_SECTION_CHANGED = 0x112,
		IA2_TABLE_CAPTION_CHANGED = 0x113,
		IA2_TABLE_COLUMN_DESCRIPTION_CHANGED = 0x114,
		IA2_TABLE_COLUMN_HEADER_CHANGED = 0x115,
		IA2_TABLE_MODEL_CHANGED = 0x116,
		IA2_TABLE_ROW_DESCRIPTION_CHANGED = 0x117,
		IA2_TABLE_ROW_HEADER_CHANGED = 0x118,
		IA2_TABLE_SUMMARY_CHANGED = 0x119,
		IA2_TEXT_ATTRIBUTE_CHANGED = 0x11a,
		IA2_TEXT_CARET_MOVED = 0x11b,
		IA2_TEXT_CHANGED = 0x11c,
		IA2_TEXT_COLUMN_CHANGED = 0x11d,
		IA2_TEXT_INSERTED = 0x11e,
		IA2_TEXT_REMOVED = 0x11f,
		IA2_TEXT_UPDATED = 0x120,
		IA2_TEXT_SELECTION_CHANGED = 0x121,
		IA2_VISIBLE_DATA_CHANGED = 0x122,
	}

	/// <summary>
	/// Flags for <see cref="More.WinEventHook"/>.
	/// </summary>
	/// <remarks>
	/// The names are as in API <ms>SetWinEventHook</ms> documentation but without prefix <c>WINEVENT_</c>.
	/// There are no flags for <c>OUTOFCONTEXT</c> and <c>INCONTEXT</c>. <c>OUTOFCONTEXT</c> is default (0). <c>INCONTEXT</c> cannot be used in managed code.
	/// </remarks>
	[Flags]
	public enum EHookFlags {
		None,
		/// <summary>Don't receive events generated by this thread.</summary>
		SKIPOWNTHREAD = 0x1,

		/// <summary>Don't receive events generated by threads of this process.</summary>
		SKIPOWNPROCESS = 0x2,

		//OUTOFCONTEXT = 0x0,
		//INCONTEXT = 0x4,
	}

	/// <summary>
	/// Used with <see cref="elm.GetProperties"/>.
	/// </summary>
	public class EProperties {
		public string Role, Name, Value, Description, Help, DefaultAction, KeyboardShortcut, UiaId, UiaCN, OuterHtml, InnerHtml;
		public EState State;
		public RECT Rect;
		public wnd WndContainer;
		public Dictionary<string, string> HtmlAttributes;
	}

#pragma warning restore CS1591 // Missing XML comment for publicly visible type or member
}


================================================
FILE: Au/UI objects/ocr.cs
================================================
using System.Drawing;

namespace Au;

/// <summary>
/// OCR functions. Recognizes text on screen or in image, gets word positions, finds text, clicks found words.
/// </summary>
public class ocr {
	readonly IFArea _area;

	static regexp s_rx1 = new(@"\s+");

	internal ocr(OcrWord[] words, IFArea area) {
		_area = area;
		Words = words;
		TextForFind = _BuildText(true);
	}

	/// <summary>
	/// Recognized words (text, rectangle, etc).
	/// </summary>
	public OcrWord[] Words { get; private set; }

	/// <summary>
	/// Recognized text as single line.
	/// Any whitespace between words is replaced with single space.
	/// <see cref="find"/> and similar functions search in this text.
	/// </summary>
	public string TextForFind { get; private set; }

	/// <summary>
	/// Recognized text.
	/// </summary>
	public string Text => _textML ??= _BuildText(false);
	string _textML;

	string _BuildText(bool forFind) {
		var b = new StringBuilder();
		foreach (var word in Words) {
			var s = word.Separator;
			if (forFind) if (!s.NE() && s != " ") s = s is "\r\n" or "\n" ? " " : s_rx1.Replace(s, " "); //replace any whitespace with " "
			b.Append(s);
			if (forFind) word.Offset = b.Length;
			b.Append(word.Text);
		}
		return b.ToString();
	}

	/// <summary>
	/// Index (in <see cref="Words"/>) of the first found word.
	/// If did not search for text (for example called <see cref="recognize"/>), this property is 0.
	/// </summary>
	public int FoundWordIndex { get; internal set; }

	/// <summary>
	/// Range of found text in <see cref="TextForFind"/>.
	/// </summary>
	public StartEnd FoundTextRange { get; internal set; }

	//internal void SortResults_() {
	//	Array.Sort(Words, (x, y) => {
	//		if (y.Rect.top >= x.Rect.bottom) return -1;
	//		if (x.Rect.top >= y.Rect.bottom) return 1;
	//		return x.Rect.left - y.Rect.left;
	//	});
	//}

	internal void AdjustResults_(POINT resultOffset, OcrFlags flags) {
		if (flags.HasAny(OcrFlags.WindowDC | OcrFlags.PrintWindow) && Dpi.GetScalingInfo_(_area.W, out bool scaled, out _, out _) && scaled) {
			int d1 = screen.of(_area.W.Window).Dpi, d2 = Dpi.OfWindow(_area.W);
			foreach (ref var word in Words.AsSpan()) {
				var r = word.Rect;
				r.left = Math2.MulDiv(r.left, d1, d2);
				r.top = Math2.MulDiv(r.top, d1, d2);
				r.right = Math2.MulDiv(r.right, d1, d2);
				r.bottom = Math2.MulDiv(r.bottom, d1, d2);
				word.Rect = r;
			}
		}

		if (resultOffset.x != 0 || resultOffset.y != 0) {
			foreach (ref var word in Words.AsSpan()) {
				var r = word.Rect;
				r.Offset(resultOffset.x, resultOffset.y);
				word.Rect = r;
			}
		}
	}

	/// <summary>
	/// Gets or sets the default OCR engine.
	/// </summary>
	/// <remarks>
	/// If not set, the <c>get</c> function returns a static <see cref="OcrWin10"/> object. To use another OCR engine, create and assign an object of type <see cref="OcrWin10"/>, <see cref="OcrTesseract"/>, <see cref="OcrGoogleCloud"/>, <see cref="OcrMicrosoftAzure"/> or other class that implements <see cref="IOcrEngine"/>.
	/// </remarks>
	public static IOcrEngine engine {
		get => s_engine ??= new OcrWin10();
		set { s_engine = value; }
	}
	static IOcrEngine s_engine;

	/// <summary>
	/// Performs OCR (text recognition).
	/// </summary>
	/// <returns>
	/// Returns an <see cref="ocr"/> object that contains recognized words etc.
	/// Returns <c>null</c> if the area is empty.
	/// </returns>
	/// <inheritdoc cref="find(IFArea, string, OcrFlags, double, IOcrEngine, int)"/>
	/// <remarks>
	/// Captures image from screen or window (unless <i>area</i> is <see cref="Bitmap"/>) and passes it to the OCR engine (calls <see cref="IOcrEngine.Recognize"/>). Then creates and returns an <see cref="ocr"/> object that contains results.
	///
	/// The speed depends on engine, area size and amount of text.
	/// </remarks>
	public static ocr recognize(IFArea area, OcrFlags flags = 0, double scale = 0, IOcrEngine engine = null) {
		engine ??= ocr.engine;
		area.Before_(flags.HasAny(OcrFlags.WindowDC | OcrFlags.PrintWindow));
		if (!area.GetOcrData_(flags, out var b, out var resultOffset)) return null;
		scale = area.GetOcrScale_(scale, engine);
		var a = engine.Recognize(b, dispose: area.Type != IFArea.AreaType.Bitmap, scale);
		var r = new ocr(a, area);
		r.AdjustResults_(resultOffset, flags);
		return r;
	}

	/// <summary>
	/// Performs OCR (text recognition) and finds text in results.
	/// </summary>
	/// <returns>
	/// Returns an <see cref="ocr"/> object that contains the word index and can click it etc.
	/// Returns <c>null</c> if not found.
	/// </returns>
	/// <param name="area">
	/// On-screen area or image:
	/// <br/>• <see cref="wnd"/> - window or control (its client area).
	/// <br/>• <see cref="elm"/> - UI element.
	/// <br/>• <see cref="Bitmap"/> - image.
	/// <br/>• <see cref="RECT"/> - a rectangle area in screen.
	/// <br/>• <see cref="IFArea"/> - can contain <see cref="wnd"/>, <see cref="elm"/> or <see cref="Bitmap"/>. Also allows to specify a rectangle in it, which makes the area smaller and the function faster. Example: <c>new(w, (left, top, width, height))</c>.
	/// </param>
	/// <param name="text">
	/// Text to find in <see cref="TextForFind"/>. Can have prefix:
	/// <br/>• <c>"**r "</c> - PCRE regular expression. Example: <c>@"**r \bwhole words\b"</c>.
	/// <br/>• <c>"**R "</c> - .NET regular expression.
	/// <br/>• <c>"**i "</c> - case-insensitive.
	/// <br/>• <c>"**t "</c> - case-sensitive (default).
	/// </param>
	/// <param name="flags"></param>
	/// <param name="scale">
	/// Scale factor (how much to resize the image before performing OCR).
	/// Value 2 or 3 may improve results of OCR engine <see cref="OcrWin10"/> or <see cref="OcrTesseract"/>.
	/// If 0 (default), depends on engine's <see cref="IOcrEngine.DpiScale"/> and area's DPI.
	/// </param>
	/// <param name="engine">OCR engine. Default: <see cref="engine"/> (<see cref="OcrWin10"/> if not specified).</param>
	/// <param name="skip">Skip this count of found text instances.</param>
	/// <exception cref="AuWndException">Invalid window handle (the <i>area</i> argument).</exception>
	/// <exception cref="ArgumentException">An argument is/contains a <c>null</c>/invalid value.</exception>
	/// <exception cref="AuException">Something failed.</exception>
	/// <remarks>
	/// The function captures image from screen or window (unless area is <see cref="Bitmap"/>) and passes it to the OCR engine (calls <see cref="IOcrEngine.Recognize"/>). Then finds the specified text in results. If found, creates and returns an <see cref="ocr"/> object that contains results.
	///
	/// The speed depends on engine, area size and amount of text.
	/// </remarks>
	public static ocr find(IFArea area, string text, OcrFlags flags = 0, double scale = 0, IOcrEngine engine = null, int skip = 0)
		=> new ocrFinder(text, flags, scale, engine, skip).Find(area);

	/// <summary>
	/// Performs OCR (text recognition) and finds text in results. Can wait and throw <see cref="NotFoundException"/>.
	/// </summary>
	/// <returns>
	/// Returns an <see cref="ocr"/> object that contains the word index and can click it etc.
	/// If not found, throws exception or returns <c>null</c> (if <i>wait</i> negative).
	/// </returns>
	/// <param name="wait">The wait timeout, seconds. If 0, does not wait. If negative, does not throw exception when not found.</param>
	/// <exception cref="NotFoundException" />
	/// <exception cref="AuWndException">Invalid window handle (the area argument), or the window closed while waiting.</exception>
	/// <inheritdoc cref="find(IFArea, string, OcrFlags, double, IOcrEngine, int)"/>
	public static ocr find(Seconds wait, IFArea area, string text, OcrFlags flags = 0, double scale = 0, IOcrEngine engine = null, int skip = 0)
		=> new ocrFinder(text, flags, scale, engine, skip).Find(area, wait);

	/// <summary>
	/// Performs OCR (text recognition) and finds text in results. Waits until found.
	/// </summary>
	/// <returns>Returns an <see cref="ocr"/> object that contains the word index and can click it etc. On timeout returns <c>null</c> if <i>timeout</i> is negative; else exception.</returns>
	/// <param name="timeout">Timeout, seconds. Can be 0 (infinite), >0 (exception) or &lt;0 (no exception). More info: [](xref:wait_timeout).</param>
	/// <exception cref="TimeoutException"><i>timeout</i> time has expired (if > 0).</exception>
	/// <exception cref="AuWndException">Invalid window handle (the area argument), or the window closed while waiting.</exception>
	/// <inheritdoc cref="find(IFArea, string, OcrFlags, double, IOcrEngine, int)"/>
	public static ocr wait(Seconds timeout, IFArea area, string text, OcrFlags flags = 0, double scale = 0, IOcrEngine engine = null, int skip = 0)
		=> new ocrFinder(text, flags, scale, engine, skip).Wait(timeout, area);

	/// <summary>
	/// Performs OCR (text recognition) and waits until the specified text does not exist in results.
	/// </summary>
	/// <returns>Returns <c>true</c>. On timeout returns <c>false</c> if <i>timeout</i> is negative; else exception.</returns>
	/// <param name="timeout">Timeout, seconds. Can be 0 (infinite), >0 (exception) or &lt;0 (no exception). More info: [](xref:wait_timeout).</param>
	/// <inheritdoc cref="wait(Seconds, IFArea, string, OcrFlags, double, IOcrEngine, int)"/>
	public static bool waitNot(Seconds timeout, IFArea area, string text, OcrFlags flags = 0, double scale = 0, IOcrEngine engine = null, int skip = 0)
		=> new ocrFinder(text, flags, scale, engine, skip).WaitNot(timeout, area);

	/// <summary>
	/// Gets the rectangle of the found word.
	/// </summary>
	/// <param name="inScreen">Convert to screen coordinates. If <c>false</c>, it's in <i>area</i> coordinates (window client area, etc) without rectangle offset.</param>
	/// <param name="word">Word index offset from <see cref="FoundWordIndex"/>.</param>
	public RECT GetRect(bool inScreen, int word = 0) {
		int i = FoundWordIndex + word; if ((uint)i >= Words.Length) throw new ArgumentOutOfRangeException("word");
		var r = Words[i].Rect;
		if (inScreen) {
			if (_area.Type == IFArea.AreaType.Wnd) {
				_area.W.MapClientToScreen(ref r);
			} else if (_area.Type == IFArea.AreaType.Elm) {
				if (!_area.E.GetRect(out var rr)) return default;
				r.Offset(rr.left, rr.top);
			}
		}
		return r;
	}

	/// <summary>
	/// Moves the mouse to the found text (the first word).
	/// </summary>
	/// <param name="x">X coordinate in the word. Default - center. Examples: <c>10</c>, <c>^10</c> (reverse), <c>.5f</c> (fraction).</param>
	/// <param name="y">Y coordinate in the word. Default - center.</param>
	/// <param name="word">Word index offset from <see cref="FoundWordIndex"/>.</param>
	/// <exception cref="InvalidOperationException"><i>area</i> is <c>Bitmap</c>.</exception>
	/// <exception cref="Exception">Exceptions of <see cref="mouse.move(wnd, Coord, Coord, bool)"/>.</exception>
	/// <remarks>
	/// Calls <see cref="mouse.move(wnd, Coord, Coord, bool)"/>.
	/// </remarks>
	public void MouseMove(Coord x = default, Coord y = default, int word = 0) => _MouseAction(x, y, 0, word);

	/// <summary>
	/// Clicks the found text (the first word).
	/// </summary>
	/// <param name="x">X coordinate in the word. Default - center. Examples: <c>10</c>, <c>^10</c> (reverse), <c>.5f</c> (fraction).</param>
	/// <param name="y">Y coordinate in the word. Default - center.</param>
	/// <param name="button">Which button and how to use it.</param>
	/// <param name="word">Word index offset from <see cref="FoundWordIndex"/>.</param>
	/// <exception cref="InvalidOperationException"><i>area</i> is <c>Bitmap</c>.</exception>
	/// <exception cref="Exception">Exceptions of <see cref="mouse.clickEx(MButton, wnd, Coord, Coord, bool)"/>.</exception>
	/// <remarks>
	/// Calls <see cref="mouse.clickEx(MButton, wnd, Coord, Coord, bool)"/>.
	/// </remarks>
	public MRelease MouseClick(Coord x = default, Coord y = default, MButton button = MButton.Left, int word = 0) {
		_MouseAction(x, y, button == 0 ? MButton.Left : button, word);
		return button;
	}

	/// <summary>
	/// Double-clicks the found text (the first word).
	/// </summary>
	/// <inheritdoc cref="MouseClick(Coord, Coord, MButton, int)"/>
	public void MouseClickD(Coord x = default, Coord y = default, int word = 0) => MouseClick(x, y, MButton.DoubleClick, word);

	/// <summary>
	/// Right-clicks the found text (the first word).
	/// </summary>
	/// <inheritdoc cref="MouseClick(Coord, Coord, MButton, int)"/>
	public void MouseClickR(Coord x = default, Coord y = default, int word = 0) => MouseClick(x, y, MButton.Right, word);

	void _MouseAction(Coord x, Coord y, MButton button, int word) {
		if (_area.Type == IFArea.AreaType.Bitmap) throw new InvalidOperationException();

		var r = GetRect(false, word);
		if (r.NoArea) return;

		var p = Coord.NormalizeInRect(x, y, r, centerIfEmpty: true);

		if (_area.Type == IFArea.AreaType.Screen) {
			if (button == 0) mouse.move(p);
			else mouse.clickEx(button, p);
		} else {
			var w = _area.W;
			if (_area.Type == IFArea.AreaType.Elm) {
				if (!_area.E.GetRect(out var rr, w) || rr.NoArea) throw new AuException(0, "*get rectangle");
				p.x += rr.left; p.y += rr.top;
			}
			if (button == 0) mouse.move(w, p.x, p.y);
			else mouse.clickEx(button, w, p.x, p.y);
		}
	}

	/// <summary>
	/// Posts mouse-click messages to the window, using coordinates in the found text (the first word).
	/// </summary>
	/// <param name="x">X coordinate in the word. Default - center. Examples: <c>10</c>, <c>^10</c> (reverse), <c>.5f</c> (fraction).</param>
	/// <param name="y">Y coordinate in the word. Default - center.</param>
	/// <param name="button">Can specify the left (default), right or middle button. Also flag for double-click, press or release.</param>
	/// <param name="word">Word index offset from <see cref="FoundWordIndex"/>.</param>
	/// <exception cref="InvalidOperationException"><i>area</i> is <c>Bitmap</c> or <c>screen</c>.</exception>
	/// <exception cref="AuException">Failed to get UI element rectangle (when searched in a UI element).</exception>
	/// <remarks>
	/// Does not move the mouse.
	/// Does not wait until the target application finishes processing the message.
	/// Works not with all elements.
	/// </remarks>
	public void PostClick(Coord x = default, Coord y = default, MButton button = MButton.Left, int word = 0) {
		var w = _area.W;
		if (w.Is0) throw new InvalidOperationException();

		var r = GetRect(false, word);
		if (r.NoArea) return;

		if (_area.Type == IFArea.AreaType.Elm) {
			if (!_area.E.GetRect(out var rr, w) || r.NoArea) throw new AuException(0, "*get rectangle");
			r.Offset(rr.left, rr.top);
		}

		mouse.PostClick_(w, r, x, y, button);
	}

	//rejected: PostClickD, PostClickR. Rarely used.
}


================================================
FILE: Au/UI objects/ocrFinder.cs
================================================
using System.Drawing;
using System.Drawing.Imaging;
using System.Text.RegularExpressions;

namespace Au;

/// <summary>
/// Performs OCR (text recognition) and find text in OCR results. Contains text to find and OCR parameters.
/// </summary>
/// <remarks>
/// Can be used instead of <see cref="ocr.find"/>.
/// </remarks>
public class ocrFinder {
	readonly object _text;
	readonly int _textType;
	readonly OcrFlags _flags;
	readonly double _scale;
	readonly IOcrEngine _engine;
	readonly int _skip;

	IFArea _area;
	Hash.MD5Result _md5;
	bool _waitNot;

	internal enum Action_ { Find, Wait, WaitNot }

	/// <summary>
	/// Stores text to find and OCR parameters.
	/// </summary>
	/// <exception cref="ArgumentException"><i>text</i> is empty or contains invalid regular expression.</exception>
	/// <inheritdoc cref="ocr.find(IFArea, string, OcrFlags, double, IOcrEngine, int)" path="/param"/>
	public ocrFinder(string text, OcrFlags flags = 0, double scale = 0, IOcrEngine engine = null, int skip = 0) {
		//**r - regexp (PCRE)
		//**R - Regex (.NET)
		//**i - text, ignore case
		//**t - text
		_textType = text.Starts(false, "**r ", "**R ", "**i ", "**t ");
		if (_textType > 0) text = text[4..];
		if (string.IsNullOrWhiteSpace(text)) throw new ArgumentException("empty text");
		_text = _textType switch {
			1 => new regexp(text),
			2 => new Regex(text, RegexOptions.CultureInvariant),
			_ => text
		};

		_flags = flags;
		_scale = scale;
		_engine = engine ?? ocr.engine;
		_skip = skip;
	}

	/// <summary>
	/// Returns an <see cref="ocr"/> object that contains the word index and can click it etc.
	/// </summary>
	public ocr Result { get; internal set; }

	/// <inheritdoc cref="ocr.find(IFArea, string, OcrFlags, double, IOcrEngine, int)"/>
	public ocr Find(IFArea area) => Exists(area) ? Result : null;

	/// <inheritdoc cref="ocr.find(Seconds, IFArea, string, OcrFlags, double, IOcrEngine, int)"/>
	public ocr Find(IFArea area, Seconds wait) => Exists(area, wait) ? Result : null;

	/// <returns>If found, sets <see cref="Result"/> and returns <c>true</c>, else <c>false</c>.</returns>
	/// <inheritdoc cref="Find(IFArea)"/>
	public bool Exists(IFArea area) {
		_Before(area, Action_.Find);
		return _Find(false);
	}

	/// <returns>If found, sets <see cref="Result"/> and returns <c>true</c>. Else throws exception or returns <c>false</c> (if <i>wait</i> negative).</returns>
	/// <inheritdoc cref="Find(IFArea, Seconds)"/>
	public bool Exists(IFArea area, Seconds wait) {
		bool r = wait.Exists_() ? Exists(area) : Wait_(Action_.Wait, wait, area);
		return r || wait.ReturnFalseOrThrowNotFound_();
	}

	/// <inheritdoc cref="ocr.wait"/>
	public ocr Wait(Seconds timeout, IFArea area)
		=> Wait_(Action_.Wait, timeout, area) ? Result : null;
	//TODO3: suspend waiting while a mouse button is pressed.
	//	Now, eg if finds while scrolling, although MouseMove waits until buttons released, but moves to the old (wrong) place.

	/// <inheritdoc cref="ocr.waitNot"/>
	public bool WaitNot(Seconds timeout, IFArea area)
		=> Wait_(Action_.WaitNot, timeout, area);

	internal bool Wait_(Action_ action, Seconds timeout, IFArea area) {
		if (area.Type == IFArea.AreaType.Bitmap) throw new ArgumentException("Bitmap and wait");
		_Before(area, action);
		_md5 = default;
		try { return wait.until(timeout, () => _Find(true) ^ _waitNot); }
		finally { _area = null; }
	}

	//called at the start of _Find and Wait_
	void _Before(IFArea area, Action_ action) {
		Not_.Null(area);
		area.Before_(_flags.HasAny(OcrFlags.WindowDC | OcrFlags.PrintWindow));
		_area = area;
		_waitNot = action == Action_.WaitNot;
	}

	/// <summary>
	/// If <c>testing</c> <c>true</c>, the finder after OCR sets <c>result</c>. Then you can access it when text not found (or found).
	/// </summary>
	[ThreadStatic] internal static (bool testing, ocr result) testing_;

	bool _Find(bool waiting) {
		if (!_area.GetOcrData_(_flags, out var b, out var resultOffset)) return false;
		bool inBitmap = _area.Type == IFArea.AreaType.Bitmap;

		if (waiting) { //don't OCR if nothing changed. Can be expensive ($) if using cloud.
			var m = _BitmapHash(b);
			if (m == _md5) {
				if (!inBitmap) b.Dispose();
				return _waitNot;
			}
			_md5 = m;
		}

		var scale = _area.GetOcrScale_(_scale, _engine);
		var a = _engine.Recognize(b, dispose: !inBitmap, scale);
		var r = new ocr(a, _area);
		if (testing_.testing) testing_.result = r;

		if (!_FindText(r)) return false;

		r.AdjustResults_(resultOffset, _flags);

		Result = r;
		return true;

		static unsafe Hash.MD5Result _BitmapHash(Bitmap b) {
			using var d = b.Data(ImageLockMode.ReadOnly);
			return Hash.MD5(new RByte((void*)d.Scan0, d.Height * d.Stride));
		}
	}

	bool _FindText(ocr r) {
		string s1 = r.TextForFind, s2 = _text as string;
		if (s2 != null) {
			s1 = s1.Replace('I', 'l').Replace('1', 'l').Replace('0', 'O');
			s2 = s2.Replace('I', 'l').Replace('1', 'l').Replace('0', 'O');
		}

		int startIndex = 0, skip = _skip;
		g1:
		int i = -1, i2 = i;
		switch (_text) {
		case regexp rx:
			if (rx.Match(s1, 0, out RXGroup g, startIndex..)) { i = g.Start; i2 = g.End; }
			break;
		case Regex rx:
			if (rx.Match(s1, startIndex) is var m && m.Success) { i = m.Index; i2 = i + m.Length; }
			break;
		default:
			i = s1.Find(s2, startIndex, _textType == 3);
			i2 = i + s2.Length;
			break;
		}

		if (i >= 0) {
			if (skip > 0) { skip--; startIndex = i2; goto g1; }
			r.FoundTextRange = new(i, i2);
			for (int j = r.Words.Length; --j >= 0;) {
				if (r.Words[j].Offset <= i) { r.FoundWordIndex = j; return true; }
			}
		}

		return false;
	}

	///
	public override string ToString() => _text.ToString();
}


================================================
FILE: Au/UI objects/ocr_types.cs
================================================
using System.Drawing;
using System.Drawing.Imaging;
using System.Text.Json.Nodes;

namespace Au.Types;

/// <summary>
/// Used by <see cref="ocr"/> and <see cref="ocrFinder"/>.
/// </summary>
public interface IOcrEngine {
	/// <summary>
	/// Recognizes text in image.
	/// </summary>
	/// <param name="b">Image.</param>
	/// <param name="dispose">Call <c>b.Dispose()</c>. The image will not be used by the caller.</param>
	/// <param name="scale">Scale factor.</param>
	/// <returns>Recognized words.</returns>
	/// <remarks>
	/// The class that implements this function can use static <see cref="IOcrEngine"/> functions to prepare the image (scale etc) and get image data.
	/// </remarks>
	OcrWord[] Recognize(Bitmap b, bool dispose, double scale);

	/// <summary>
	/// Let OCR functions scale images captured from a window or screen, 1-2 times depending on DPI, unless non-zero <i>scale</i> parameter is specified.
	/// </summary>
	bool DpiScale { get; set; }

	#region util

	/// <summary>
	/// If need, resizes the image and/or ensures it isn't too small.
	/// </summary>
	/// <param name="dispose">Call <c>b.Dispose()</c> if created new image. The input image will not be used by the caller.</param>
	/// <param name="scale">Scale factor.</param>
	/// <param name="minWidth">Minimal image width accepted by the OCR engine.</param>
	/// <param name="minHeight">Minimal image height accepted by the OCR engine.</param>
	protected static Bitmap PrepareBitmap(Bitmap b, bool dispose, double scale, int minWidth = 0, int minHeight = 0) {
		var b0 = b;
		if (scale > 1) b = b.Resize(scale, BRFilter.Lanczos3, dispose);

		//Microsoft OCR (Win10 and Azure) reject small images
		if (minWidth > 0 && minHeight > 0) {
			var zi = b.Size;
			if (zi.Width < minWidth || zi.Height < minHeight) {
				int wid = Math.Max(zi.Width, minWidth), hei = Math.Max(zi.Height, minHeight);
				var b2 = new Bitmap(wid, hei, b.PixelFormat);
				b2.SetResolution(b.HorizontalResolution, b.VerticalResolution);
				using var g = Graphics.FromImage(b2);
				g.Clear(Color.White);
				g.DrawImage(b, 0, 0);
				if (dispose || b != b0) b.Dispose();
				b = b2;
			}
		}

		//var file = folders.Temp + "test.png"; b.Save(file); run.it(file);
		return b;
	}

	/// <summary>
	/// Gets image pixels.
	/// </summary>
	/// <remarks>The pixel format is either <c>Format32bppRgb</c> (if it's <i>b</i> format) or <c>Format32bppArgb</c>.</remarks>
	protected static unsafe byte[] GetBitmapData(Bitmap b) {
		using var d = b.Data(ImageLockMode.ReadOnly, b.PixelFormat == PixelFormat.Format32bppRgb ? PixelFormat.Format32bppRgb : PixelFormat.Format32bppArgb);
		return new Span<byte>((void*)d.Scan0, d.Width * d.Height * 4).ToArray();
	}

	/// <summary>
	/// Gets image data in <c>.png</c> file format.
	/// </summary>
	protected static unsafe byte[] GetBitmapPngFileData(Bitmap b) {
		using var ms = new MemoryStream();
		b.Save(ms, ImageFormat.Png);
		var a = ms.ToArray();
		return a;
	}

	/// <summary>
	/// Converts word polygon JSON nodes to <see cref="RECT"/>.
	/// </summary>
	protected static RECT PolyToRect(JsonNode xTL, JsonNode yTL, JsonNode xTR, JsonNode yTR, JsonNode xBR, JsonNode yBR, JsonNode xBL, JsonNode yBL) {
		return RECT.FromLTRB((i(xTL) + i(xBL) + 1) / 2, (i(yTL) + i(yTR) + 1) / 2, (i(xTR) + i(xBR)) / 2, (i(yBR) + i(yBL)) / 2);
		static int i(JsonNode n) => n != null ? (int)n : 0; //the node may be missing in JSON if has default value
	}

	#endregion
}

/// <summary>
/// Stores text and rectangle of a word in OCR results.
/// See <see cref="ocr.Words"/>.
/// </summary>
public record class OcrWord {
	/// <param name="separator">Separator before the word (space, new line, etc). Also can be <c>""</c> or <c>null</c>.</param>
	/// <param name="text">Word text.</param>
	/// <param name="rect">Word rectangle in <i>area</i>, possibly scaled.</param>
	/// <param name="scale">The <i>scale</i> parameter of the OCR function. This function unscales <i>rect</i> if need.</param>
	public OcrWord(string separator, string text, RECT rect, double scale) {
		Separator = separator;
		Text = text;
		Rect = scale > 1 ? RECT.FromLTRB(i(rect.left), i(rect.top), i(rect.right), i(rect.bottom)) : rect;

		int i(int x) => (x / scale).ToInt();
	}

	/// <summary>Separator before the word (space, new line, etc). Also can be <c>""</c> or <c>null</c>.</summary>
	public string Separator { get; }

	/// <summary>Word text.</summary>
	public string Text { get; }

	/// <summary>Word rectangle in <i>area</i>.</summary>
	public RECT Rect { get; internal set; }

	/// <summary>Word offset in <see cref="ocr.TextForFind"/>.</summary>
	public int Offset { get; internal set; }
}

/// <summary>
/// Flags for <see cref="ocr"/> and <see cref="ocrFinder"/>.
/// </summary>
[Flags]
public enum OcrFlags {
	/// <inheritdoc cref="IFFlags.WindowDC"/>
	WindowDC = 1,

	/// <inheritdoc cref="IFFlags.PrintWindow"/>
	PrintWindow = 2,

	///// <inheritdoc cref="IFFlags.WindowDwm"/>
	//WindowDwm = 4,

	//note: the above values must be the same in CIFlags, CIUFlags, IFFlags, OcrFlags.

	//rejected. Maybe in the future.
	///// <summary>
	///// Sort words by word rectangle position, left-to-right and top-to-bottom.
	///// </summary>
	//Sort = 0x100,
}


================================================
FILE: Au/UI objects/uiimage.cs
================================================
using System.Drawing;

namespace Au;

/// <summary>
/// Captures, finds and clicks images and colors in windows.
/// </summary>
/// <remarks>
/// An image is any visible rectangular part of a window. A color is any visible pixel (the same as image of size 1x1).
/// A <c>uiimage</c> variable holds results of <see cref="find"/> and similar functions (rectangle etc).
/// </remarks>
public class uiimage {
	#region results

	readonly IFArea _area;

	///// <summary>
	///// <i>area</i> parameter of the function.
	///// </summary>
	//public IFArea Area => _area;

	internal uiimage(IFArea area) {
		_area = area;
	}

	/// <summary>
	/// Gets location of the found image, relative to the search area.
	/// </summary>
	/// <remarks>
	/// Relative to the window/control client area (if area type is <see cref="wnd"/>), UI element (if <see cref="elm"/>), image (if <see cref="Bitmap"/>) or screen (if <see cref="RECT"/>).
	/// More info: <see cref="find"/>.
	/// </remarks>
	public RECT Rect { get; init; }

	/// <summary>
	/// Gets location of the found image in screen coordinates.
	/// </summary>
	/// <remarks>
	/// Slower than <see cref="Rect"/>.
	/// </remarks>
	public RECT RectInScreen {
		get {
			RECT r;
			switch (_area.Type) {
			case IFArea.AreaType.Wnd:
				r = Rect;
				_area.W.MapClientToScreen(ref r);
				return r;
			case IFArea.AreaType.Elm:
				if (!_area.E.GetRect(out var rr)) return default;
				r = Rect;
				r.Offset(rr.left, rr.top);
				return r;
			}
			return Rect; //screen or bitmap
		}
	}

	/// <summary>
	/// Gets 0-based index of current matching image instance.
	/// </summary>
	/// <remarks>
	/// Can be useful in <i>also</i> callback functions.
	/// When the <i>image</i> argument is a list of images, <c>MatchIndex</c> starts from 0 for each list image.
	/// </remarks>
	public int MatchIndex { get; init; }

	/// <summary>
	/// When the <i>image</i> argument is a list of images, gets 0-based index of the list image.
	/// </summary>
	public int ListIndex { get; init; }

	/// <summary>
	/// Can be used in <i>also</i> callback function to skip <i>n</i> matching images. Example: <c>also: o => o.Skip(n)</c>.
	/// </summary>
	/// <param name="n">How many matching images to skip.</param>
	public IFAlso Skip(int n) => MatchIndex == n ? IFAlso.OkReturn : (MatchIndex < n ? IFAlso.FindOther : IFAlso.FindOtherOfList);

	/// <summary>
	/// Moves the mouse to the found image.
	/// </summary>
	/// <param name="x">X coordinate in the found image. Default - center. Examples: <c>10</c>, <c>^10</c> (reverse), <c>.5f</c> (fraction).</param>
	/// <param name="y">Y coordinate in the found image. Default - center.</param>
	/// <exception cref="InvalidOperationException"><i>area</i> is <c>Bitmap</c>.</exception>
	/// <exception cref="Exception">Exceptions of <see cref="mouse.move(wnd, Coord, Coord, bool)"/>.</exception>
	/// <remarks>
	/// Calls <see cref="mouse.move(wnd, Coord, Coord, bool)"/>.
	/// </remarks>
	public void MouseMove(Coord x = default, Coord y = default) => _MouseAction(x, y, 0);

	/// <summary>
	/// Clicks the found image.
	/// </summary>
	/// <param name="x">X coordinate in the found image. Default - center. Examples: <c>10</c>, <c>^10</c> (reverse), <c>.5f</c> (fraction).</param>
	/// <param name="y">Y coordinate in the found image. Default - center.</param>
	/// <param name="button">Which button and how to use it.</param>
	/// <exception cref="InvalidOperationException"><i>area</i> is <c>Bitmap</c>.</exception>
	/// <exception cref="Exception">Exceptions of <see cref="mouse.clickEx(MButton, wnd, Coord, Coord, bool)"/>.</exception>
	/// <remarks>
	/// Calls <see cref="mouse.clickEx(MButton, wnd, Coord, Coord, bool)"/>.
	/// </remarks>
	public MRelease MouseClick(Coord x = default, Coord y = default, MButton button = MButton.Left) {
		_MouseAction(x, y, button == 0 ? MButton.Left : button);
		return button;
	}

	/// <summary>
	/// Double-clicks the found image.
	/// </summary>
	/// <inheritdoc cref="MouseClick(Coord, Coord, MButton)"/>
	public void MouseClickD(Coord x = default, Coord y = default) => MouseClick(x, y, MButton.DoubleClick);

	/// <summary>
	/// Right-clicks the found image.
	/// </summary>
	/// <inheritdoc cref="MouseClick(Coord, Coord, MButton)"/>
	public void MouseClickR(Coord x = default, Coord y = default) => MouseClick(x, y, MButton.Right);

	void _MouseAction(Coord x, Coord y, MButton button) {
		if (_area.Type == IFArea.AreaType.Bitmap) throw new InvalidOperationException();

		Debug.Assert(!Rect.NoArea);
		if (Rect.NoArea) return;

		//rejected: Click will activate it. Don't activate if just Move.
		//if(0 != (_f._flags & IFFlags.WindowDC)) {
		//	if(_area.W.IsCloaked) _area.W.ActivateL();
		//}

		var p = Coord.NormalizeInRect(x, y, Rect, centerIfEmpty: true);

		if (_area.Type == IFArea.AreaType.Screen) {
			if (button == 0) mouse.move(p);
			else mouse.clickEx(button, p);
		} else {
			var w = _area.W;
			if (_area.Type == IFArea.AreaType.Elm) {
				if (!_area.E.GetRect(out var r, w) || r.NoArea) throw new AuException(0, "*get rectangle");
				p.x += r.left; p.y += r.top;
			}
			if (button == 0) mouse.move(w, p.x, p.y);
			else mouse.clickEx(button, w, p.x, p.y);
		}
	}

	/// <summary>
	/// Posts mouse-click messages to the window, using coordinates in the found image.
	/// </summary>
	/// <param name="button">Can specify the left (default), right or middle button. Also flag for double-click, press or release.</param>
	/// <exception cref="ArgumentException">Unsupported button specified.</exception>
	/// <inheritdoc cref="PostClickD(Coord, Coord)"/>
	public void PostClick(Coord x = default, Coord y = default, MButton button = MButton.Left) {
		var w = _area.W;
		if (w.Is0) throw new InvalidOperationException();

		Debug.Assert(!Rect.NoArea);
		if (Rect.NoArea) return;

		var r = Rect;
		if (_area.Type == IFArea.AreaType.Elm) {
			if (!_area.E.GetRect(out var rr, w) || r.NoArea) throw new AuException(0, "*get rectangle");
			r.Offset(rr.left, rr.top);
		}

		mouse.PostClick_(w, r, x, y, button);
	}

	/// <summary>
	/// Posts mouse-double-click messages to the window, using coordinates in the found image.
	/// </summary>
	/// <param name="x">X coordinate in the found image. Default - center. Examples: <c>10</c>, <c>^10</c> (reverse), <c>.5f</c> (fraction).</param>
	/// <param name="y">Y coordinate in the found image. Default - center.</param>
	/// <exception cref="InvalidOperationException"><i>area</i> is <c>Bitmap</c> or <c>screen</c>.</exception>
	/// <exception cref="AuException">Failed to get UI element rectangle (when searched in a UI element).</exception>
	/// <remarks>
	/// Does not move the mouse.
	/// Does not wait until the target application finishes processing the message.
	/// Works not with all elements.
	/// </remarks>
	public void PostClickD(Coord x = default, Coord y = default) => PostClick(x, y, MButton.DoubleClick);

	/// <summary>
	/// Posts mouse-right-click messages to the window, using coordinates in the found image.
	/// </summary>
	/// <inheritdoc cref="PostClickD(Coord, Coord)"/>
	public void PostClickR(Coord x = default, Coord y = default) => PostClick(x, y, MButton.Right);

	///
	public override string ToString() => $"{ListIndex}, {MatchIndex}, {Rect}";

	#endregion

	/// <summary>
	/// Finds image(s) or color(s) displayed in a window or other area.
	/// </summary>
	/// <returns>
	/// Returns a <see cref="uiimage"/> object that contains the rectangle of the found image and can click it etc.
	/// Returns <c>null</c> if not found.
	/// </returns>
	/// <param name="area">
	/// Where to search:
	/// <br/>• <see cref="wnd"/> - window or control (its client area).
	/// <br/>• <see cref="elm"/> - UI element.
	/// <br/>• <see cref="Bitmap"/> - image.
	/// <br/>• <see cref="RECT"/> - a rectangle area in screen.
	/// <br/>• <see cref="IFArea"/> - can contain <see cref="wnd"/>, <see cref="elm"/> or <see cref="Bitmap"/>. Also allows to specify a rectangle in it, which makes the area smaller and the function faster. Example: <c>new(w, (left, top, width, height))</c>.
	/// </param>
	/// <param name="image">Image or color to find. Or array of them. More info: <see cref="IFImage"/>.</param>
	/// <param name="flags"></param>
	/// <param name="diff">Maximal allowed color difference. Can be 0 - 100, but should be as small as possible. Use to find images with slightly different colors than the specified image.</param>
	/// <param name="also">
	/// Callback function. Called for each found image instance and receives its rectangle, match index and list index. Can return one of <see cref="IFAlso"/> values.
	/// <br/>Examples:
	/// <br/>• Skip 2 matching images: <c>also: o => o.Skip(2)</c>
	/// <br/>• Skip some matching images if some condition is <c>false</c>: <c>also: o => condition ? IFAlso.OkReturn : IFAlso.FindOther</c>
	/// <br/>• Get rectangles etc of all matching images: <c>also: o => { list.Add(o); return IFAlso.OkFindMore; }</c>
	/// <br/>• Do different actions depending on which list images found: <c>var found = new BitArray(images.Length); uiimage.find(w, images, also: o => { found[o.ListIndex] = true; return IFAlso.OkFindMoreOfList; }); if(found[0]) print.it(0); if(found[1]) print.it(1);</c>
	/// </param>
	/// <exception cref="AuWndException">Invalid window handle (the <i>area</i> argument).</exception>
	/// <exception cref="ArgumentException">An argument is/contains a <c>null</c>/invalid value.</exception>
	/// <exception cref="FileNotFoundException">Image file does not exist.</exception>
	/// <exception cref="Exception">Exceptions of <see cref="ImageUtil.LoadGdipBitmap"/>.</exception>
	/// <exception cref="AuException">Something failed.</exception>
	/// <remarks>
	/// To create code for this function, use tool <b>Find image or color in window</b>.
	/// 
	/// The speed mostly depends on:
	/// 1. The size of the search area. Use the smallest possible area (control or UI element or rectangle in window).
	/// 2. Flags <see cref="IFFlags.WindowDC"/> (makes faster), <see cref="IFFlags.PrintWindow"/>. The speed depends on window.
	/// 3. Video driver. Can be much slower if incorrect, generic or virtual PC driver is used. The above flags should help.
	/// 4. <i>diff</i>. Should be as small as possible.
	/// 
	/// If flag <see cref="IFFlags.WindowDC"/> or <see cref="IFFlags.PrintWindow"/> not used, the search area must be visible on the screen, because this function then gets pixels from the screen.
	/// 
	/// Can find only images that exactly match the specified image. With <i>diff</i> can find images with slightly different colors and brightness.
	/// 
	/// Transparent and partially transparent pixels of <i>image</i> are ignored. You can draw transparent areas with an image editor that supports it, for example Paint.NET.
	/// 
	/// This function is not the best way to find objects when the script is intended for long use or for use on multiple computers or must be very reliable. Because it may fail to find the image after changing some settings - system theme, application theme, text size (DPI), font smoothing (if the image contains text), etc. Also are possible various unexpected temporary conditions that may distort or hide the image, for example adjacent window shadow, a tooltip or some temporary window. If possible, in such scripts instead use other functions, eg find control or UI element.
	/// 
	/// Flags <see cref="IFFlags.WindowDC"/> and <see cref="IFFlags.PrintWindow"/> cannot be used if <i>area</i> is <c>Bitmap</c> or <see cref="RECT"/>.
	/// </remarks>
	/// <example>
	/// Code created with tool <b>Find image or color in window</b>.
	/// <code><![CDATA[
	/// var w = wnd.find(1, "Window Name");
	/// string image = "image:iVBORw0KGgoAAAANSUhEUgAAABYAAAANCAYAAACtpZ5jAAAAAXNSR0IArs4c...";
	/// var im = uiimage.find(1, w, image);
	/// im.MouseClick();
	/// ]]></code>
	/// </example>
	public static uiimage find(IFArea area, IFImage image, IFFlags flags = 0, int diff = 0, Func<uiimage, IFAlso> also = null)
		=> new uiimageFinder(image, flags, diff, also).Find(area);

	/// <summary>
	/// Finds image(s) or color(s) displayed in a window or other area. Can wait and throw <see cref="NotFoundException"/>.
	/// </summary>
	/// <returns>
	/// Returns a <see cref="uiimage"/> object that contains the rectangle of the found image and can click it etc.
	/// If not found, throws exception or returns <c>null</c> (if <i>wait</i> negative).
	/// </returns>
	/// <param name="wait">The wait timeout, seconds. If 0, does not wait. If negative, does not throw exception when not found.</param>
	/// <exception cref="NotFoundException" />
	/// <exception cref="AuWndException">Invalid window handle (the area argument), or the window closed while waiting.</exception>
	/// <inheritdoc cref="find(IFArea, IFImage, IFFlags, int, Func{uiimage, IFAlso})"/>
	public static uiimage find(Seconds wait, IFArea area, IFImage image, IFFlags flags = 0, int diff = 0, Func<uiimage, IFAlso> also = null)
		=> new uiimageFinder(image, flags, diff, also).Find(area, wait);

	/// <summary>
	/// Finds image(s) or color(s) displayed in a window or other area. Waits until found.
	/// More info: <see cref="find"/>.
	/// </summary>
	/// <returns>Returns <see cref="uiimage"/> object containing the rectangle of the found image. On timeout returns <c>null</c> if <i>timeout</i> is negative; else exception.</returns>
	/// <param name="timeout">Timeout, seconds. Can be 0 (infinite), >0 (exception) or &lt;0 (no exception). More info: [](xref:wait_timeout).</param>
	/// <exception cref="TimeoutException"><i>timeout</i> time has expired (if > 0).</exception>
	/// <exception cref="AuWndException">Invalid window handle (the <i>area</i> argument), or the window closed while waiting.</exception>
	/// <inheritdoc cref="find(IFArea, IFImage, IFFlags, int, Func{uiimage, IFAlso})"/>
	public static uiimage wait(Seconds timeout, IFArea area, IFImage image, IFFlags flags = 0, int diff = 0, Func<uiimage, IFAlso> also = null)
		=> new uiimageFinder(image, flags, diff, also).Wait(timeout, area);

	/// <summary>
	/// Waits until image(s) or color(s) is not displayed in a window or other area.
	/// More info: <see cref="find"/>.
	/// </summary>
	/// <returns>Returns <c>true</c>. On timeout returns <c>false</c> if <i>timeout</i> is negative; else exception.</returns>
	/// <inheritdoc cref="wait(Seconds, IFArea, IFImage, IFFlags, int, Func{uiimage, IFAlso})"/>
	public static bool waitNot(Seconds timeout, IFArea area, IFImage image, IFFlags flags = 0, int diff = 0, Func<uiimage, IFAlso> also = null)
		=> new uiimageFinder(image, flags, diff, also).WaitNot(timeout, area);

	/// <summary>
	/// Waits until something visually changes in a window or other area.
	/// More info: <see cref="find"/>.
	/// </summary>
	/// <remarks>
	/// Like <see cref="waitNot"/>, but instead of <i>image</i> parameter this function captures the area image at the beginning.
	/// </remarks>
	/// <inheritdoc cref="waitNot(Seconds, IFArea, IFImage, IFFlags, int, Func{uiimage, IFAlso})"/>
	public static bool waitChanged(Seconds timeout, IFArea area, IFFlags flags = 0, int diff = 0) {
		var f = new uiimageFinder(default, flags, diff, null);
		return f.Wait_(uiimageFinder.Action_.WaitChanged, timeout, area);
	}

	#region obsolete

	/// <inheritdoc cref="CaptureScreen.Image(RECT)"/>
	[Obsolete("Use CaptureScreen.Image"), EditorBrowsable(EditorBrowsableState.Never)]
	public static Bitmap capture(RECT r) => CaptureScreen.Image(r);

	/// <inheritdoc cref="CaptureScreen.Image(wnd, RECT?, CIFlags)"/>
	[Obsolete("Use CaptureScreen.Image"), EditorBrowsable(EditorBrowsableState.Never)]
	public static Bitmap capture(wnd w, RECT r, bool printWindow = false)
		=> CaptureScreen.Image(w, r, printWindow ? CIFlags.PrintWindow : CIFlags.WindowDC);

	/// <inheritdoc cref="CaptureScreen.Pixels(RECT)"/>
	[Obsolete("Use CaptureScreen.Pixels"), EditorBrowsable(EditorBrowsableState.Never)]
	public static uint[,] getPixels(RECT r) => CaptureScreen.Pixels(r);

	/// <inheritdoc cref="CaptureScreen.Pixels(wnd, RECT?, CIFlags)"/>
	[Obsolete("Use CaptureScreen.Pixels"), EditorBrowsable(EditorBrowsableState.Never)]
	public static uint[,] getPixels(wnd w, RECT r, bool printWindow = false)
		=> CaptureScreen.Pixels(w, r, printWindow ? CIFlags.PrintWindow : CIFlags.WindowDC);

	/// <inheritdoc cref="CaptureScreen.Pixel"/>
	[Obsolete("Use CaptureScreen.Pixel"), EditorBrowsable(EditorBrowsableState.Never)]
	public static unsafe uint getPixel(POINT p) => CaptureScreen.Pixel(p);

	/// <inheritdoc cref="CaptureScreen.ImageColorRectUI"/>
	[Obsolete("Use CaptureScreen.ImageColorRectUI"), EditorBrowsable(EditorBrowsableState.Never)]
	public static bool captureUI(out ICResult result, ICFlags flags = 0, AnyWnd owner = default) {
		bool R = CaptureScreen.ImageColorRectUI(out var r1, (CIUFlags)flags, owner);
		result = Unsafe.As<ICResult>(r1);
		return R;
	}

	#endregion
}


================================================
FILE: Au/UI objects/uiimageFinder.cs
================================================
//FUTURE: option to allow % of image completely different. Eg button with/without focus rectangle.
//	Or/and in the tool allow to erase some areas (make alpha 0).

//#define WI_TEST_NO_OPTIMIZATION

using System.Drawing;
using System.Drawing.Imaging;

namespace Au;

/// <summary>
/// Finds images displayed in user interface (UI). Contains data and parameters of image(s) or color(s) to find.
/// </summary>
/// <remarks>
/// Can be used instead of <see cref="uiimage.find"/>.
/// </remarks>
public unsafe class uiimageFinder {
	class _Image {
		public uint[] pixels;
		public int width, height;
		public _OptimizationData optim;

		public _Image(string file) {
			using var b = ImageUtil.LoadGdipBitmap(file);
			_BitmapToData(b);
		}

		public _Image(Bitmap b) {
			b = b ?? throw new ArgumentException("null Bitmap");
			_BitmapToData(b);
		}

		void _BitmapToData(Bitmap b) {
			var z = b.Size;
			width = z.Width; height = z.Height;
			pixels = new uint[width * height];
			fixed (uint* p = pixels) {
				var d = new BitmapData { Scan0 = (IntPtr)p, Height = height, Width = width, Stride = width * 4, PixelFormat = PixelFormat.Format32bppArgb };
				d = b.LockBits(new Rectangle(default, z), ImageLockMode.ReadOnly | ImageLockMode.UserInputBuffer, PixelFormat.Format32bppArgb, d);
				b.UnlockBits(d);
				if (d.Stride < 0) throw new ArgumentException("bottom-up Bitmap"); //Image.FromHbitmap used to create bottom-up bitmap (stride<0) from compatible bitmap. Now cannot reproduce.
			}
		}

		public _Image(ColorInt color) {
			width = height = 1;
			pixels = new uint[1] { (uint)color.argb | 0xff000000 };
		}

		public _Image() { }
	}

	//ctor parameters
	readonly List<_Image> _images; //support multiple images
	readonly IFFlags _flags;
	readonly uint _diff;
	readonly Func<uiimage, IFAlso> _also;

	Action_ _action;
	IFArea _area;
	CaptureScreenImage _ad; //area data
	POINT _resultOffset; //to map the found rectangle from the captured area coordinates to the specified area coordinates

	/// <summary>
	/// Returns <see cref="uiimage"/> object that contains the rectangle of the found image and can click it etc.
	/// </summary>
	public uiimage Result { get; private set; }

	/// <summary>
	/// Stores image/color data and search settings in this object. Loads images if need. See <see cref="uiimage.find"/>.
	/// </summary>
	/// <exception cref="ArgumentException">An argument is/contains a <c>null</c>/invalid value.</exception>
	/// <exception cref="FileNotFoundException">Image file does not exist.</exception>
	/// <exception cref="Exception">Exceptions of <see cref="ImageUtil.LoadGdipBitmap"/>.</exception>
	/// <inheritdoc cref="uiimage.find(IFArea, IFImage, IFFlags, int, Func{uiimage, IFAlso})" path="/param"/>
	public uiimageFinder(IFImage image, IFFlags flags = 0, int diff = 0, Func<uiimage, IFAlso> also = null) {
		_flags = flags;
		uint d = (uint)diff; _diff = d switch { <= 30 => d, <= 60 => 30 + (d - 30) * 2, <= 100 => 90 + (d - 60) * 3, _ => throw new ArgumentOutOfRangeException("diff range: 0 - 100") }; //make slightly exponential, 0 - 210
		_also = also;

		_images = new List<_Image>();
		if (image.Value != null) _AddImage(image);

		void _AddImage(IFImage image) {
			switch (image.Value) {
			case string s:
				_images.Add(new _Image(s));
				break;
			case Bitmap b:
				_images.Add(new _Image(b));
				break;
			case ColorInt c:
				_images.Add(new _Image(c));
				break;
			case IFImage[] a:
				foreach (var v in a) _AddImage(v);
				break;
			}
		}
	}

	/// <summary>
	/// Finds the first image displayed in the specified window or other area.
	/// See <see cref="uiimage.find"/>.
	/// </summary>
	/// <returns>If found, returns <see cref="Result"/>, else <c>null</c>.</returns>
	/// <exception cref="AuWndException">Invalid window handle.</exception>
	/// <exception cref="ArgumentException">An argument of this function or of constructor is invalid.</exception>
	/// <exception cref="AuException">Something failed.</exception>
	/// <remarks>
	/// Functions <c>Find</c> and <see cref="Exists"/> differ only in their return types.
	/// </remarks>
	/// <inheritdoc cref="uiimage.find" path="/param"/>
	public uiimage Find(IFArea area) => Exists(area) ? Result : null;

	/// <summary>
	/// Finds the first image displayed in the specified window or other area. Can wait and throw <see cref="NotFoundException"/>.
	/// </summary>
	/// <returns>If found, returns <see cref="Result"/>. Else throws exception or returns <c>null</c> (if <i>wait</i> negative).</returns>
	/// <param name="wait">The wait timeout, seconds. If 0, does not wait. If negative, does not throw <see cref="NotFoundException"/>.</param>
	/// <exception cref="AuWndException">Invalid window handle.</exception>
	/// <exception cref="ArgumentException">An argument of this function or of constructor is invalid.</exception>
	/// <exception cref="AuException">Something failed.</exception>
	/// <exception cref="NotFoundException" />
	/// <remarks>
	/// Functions <c>Find</c> and <see cref="Exists"/> differ only in their return types.
	/// </remarks>
	/// <inheritdoc cref="uiimage.find" path="/param"/>
	public uiimage Find(IFArea area, Seconds wait) => Exists(area, wait) ? Result : null;

	/// <returns>If found, sets <see cref="Result"/> and returns <c>true</c>, else false.</returns>
	/// <inheritdoc cref="Find(IFArea)"/>
	public bool Exists(IFArea area) {
		_Before(area, Action_.Find);
		return _Find();
	}

	/// <returns>If found, sets <see cref="Result"/> and returns <c>true</c>. Else throws exception or returns <c>false</c> (if <i>wait</i> negative).</returns>
	/// <inheritdoc cref="Find(IFArea, Seconds)"/>
	public bool Exists(IFArea area, Seconds wait) {
		bool r = wait.Exists_() ? Exists(area) : Wait_(Action_.Wait, wait, area);
		return r || wait.ReturnFalseOrThrowNotFound_();
	}

	/// <summary>
	/// See <see cref="uiimage.wait"/>.
	/// </summary>
	/// <param name="timeout">Timeout, seconds. Can be 0 (infinite), >0 (exception) or &lt;0 (no exception). More info: [](xref:wait_timeout).</param>
	/// <exception cref="Exception">Exceptions of <see cref="uiimage.wait"/>, except those of the constructor.</exception>
	/// <remarks>
	/// Same as <see cref="Find(IFArea, Seconds)"/>, except:
	/// - 0 timeout means infinite.
	/// - on timeout throws <see cref="TimeoutException"/>, not <see cref="NotFoundException"/>.
	/// </remarks>
	/// <inheritdoc cref="Find(IFArea, Seconds)" path="/param"/>
	public uiimage Wait(Seconds timeout, IFArea area)
		=> Wait_(Action_.Wait, timeout, area) ? Result : null;
	//TODO3: suspend waiting while a mouse button is pressed.
	//	Now, eg if finds while scrolling, although MouseMove waits until buttons released, but moves to the old (wrong) place.

	/// <summary>
	/// See <see cref="uiimage.waitNot"/>.
	/// </summary>
	/// <exception cref="Exception">Exceptions of <see cref="uiimage.waitNot"/>, except those of the constructor.</exception>
	/// <inheritdoc cref="Wait(Seconds, IFArea)" path="/param"/>
	public bool WaitNot(Seconds timeout, IFArea area)
		=> Wait_(Action_.WaitNot, timeout, area);

	internal bool Wait_(Action_ action, Seconds timeout, IFArea area) {
		if (area.Type == IFArea.AreaType.Bitmap) throw new ArgumentException("Bitmap and wait");
		_Before(area, action);
		try { return wait.until(timeout, () => _Find() ^ (action > Action_.Wait)); }
		finally { _After(); }

		//tested: does not create garbage while waiting.
	}

	internal enum Action_ { Find, Wait, WaitNot, WaitChanged }

	//called at the start of _Find and Wait_
	void _Before(IFArea area, Action_ action) {
		Not_.Null(area);
		_action = action;
		_area = area;
		_ad ??= new();

		if (_action == Action_.WaitChanged) {
			Debug.Assert(_images.Count == 0 && _also == null); //the first _Find will capture the area and add to _images
		} else {
			if (_images.Count == 0) throw new ArgumentException("no image");
		}

		_area.Before_(_flags.HasAny(IFFlags.WindowDC | IFFlags.PrintWindow));
	}

	//called at the end of _Find (if not waiting) and Wait_
	void _After() {
		_ad.Dispose();
		_area = null;
		if (_action == Action_.WaitChanged) _images.Clear();
	}

	bool _Find() {
		//using var p1 = perf.local();
		Result = null;

		if (!_area.GetRect_(out var r, out _resultOffset, _flags)) return false;

		//If WaitChanged, first time just get area pixels into _images[0].
		if (_action == Action_.WaitChanged && _images.Count == 0) {
			return _GetAreaPixels(r, true);
		}

		//Return false if all images are bigger than the search area.
		for (int i = _images.Count; --i >= 0;) {
			var v = _images[i];
			if (v.width <= r.Width && v.height <= r.Height) goto g1;
		}
		return false; g1:

		BitmapData bitmapBD = null;
		try {
			//Get area pixels.
			bool havePixels = _area.Type == IFArea.AreaType.Bitmap;
			if (havePixels) {
				var pf = (_area.B.PixelFormat == PixelFormat.Format32bppArgb) ? PixelFormat.Format32bppArgb : PixelFormat.Format32bppRgb; //if possible, use PixelFormat of _area, to avoid conversion/copying. Both these formats are ok, we don't use alpha.
				bitmapBD = _area.B.LockBits(r, ImageLockMode.ReadOnly, pf);
				if (bitmapBD.Stride < 0) throw new ArgumentException("bottom-up Bitmap");
				_ad.SetExternalData_((uint*)bitmapBD.Scan0, bitmapBD.Width, bitmapBD.Height);
				//note: don't support rect in Bitmap. LockBits does not copy bits if same pixelformat. Would need to create new Bitmap from that rect, or use stride when searching.
			} else {
				havePixels = _GetAreaPixels(r);
			}
			//p1.Next();

			if (havePixels) {
				//Find image(s) in area.
				uiimage alsoResult = null;
				_DpiScaling dpiScaling = null;
				if (_action == Action_.WaitChanged)
					return _FindImage(0, ref alsoResult, ref dpiScaling);
				if (_flags.Has(IFFlags.Parallel) && _images.Count > 1) {
					Parallel.For(0, _images.Count, (i, pls) => {
						_FindImage(i, ref alsoResult, ref dpiScaling, pls);
					});
				} else {
					for (int i = 0; i < _images.Count; i++) {
						if (_FindImage(i, ref alsoResult, ref dpiScaling)) break;
					}
				}

				Result ??= alsoResult;
				if (Result != null) return true;
			}

			return false;
		}
		finally {
			if (bitmapBD != null) _area.B.UnlockBits(bitmapBD);
			if (_action == Action_.Find) _After();
		}
	}

	[MethodImpl(MethodImplOptions.AggressiveOptimization)]
	bool _FindImage(int listIndex, ref uiimage alsoResult, ref _DpiScaling dpiScaling, ParallelLoopState pls = null) {
		//note: can run in multiple threads simultaneously. Don't modify this fields and ref params without lock.

		var image = _images[listIndex];
		var alsoAction = IFAlso.FindOtherOfList;
		int matchIndex = 0;

		int imageWidth = image.width, imageHeight = image.height;
		if (_ad.Width < imageWidth || _ad.Height < imageHeight) return false;
		fixed (uint* imagePixels = image.pixels) {
			uint* imagePixelsTo = imagePixels + imageWidth * imageHeight;
			uint* areaPixels = _ad.Pixels;

			//rejected: if image is of same size as area, simply compare. For example, when action is WaitChanged.
			//	Does not make faster, just adds more code.

			if (!image.optim.Init(image, _ad.Width)) return false;
			var optim = image.optim; //copy struct, size = 9*int
			int o_pos0 = optim.v0.pos;
			var o_a1 = &optim.v1; var o_an = o_a1 + (optim.N - 1);

			//find first pixel. This part is very important for speed.
			//int nTimesFound = 0; //debug

			var areaWidthMinusImage = _ad.Width - imageWidth;
			var pFirst = areaPixels + o_pos0;
			var pLast = pFirst + _ad.Width * (_ad.Height - imageHeight) + areaWidthMinusImage;

			//this is a workaround for compiler not using registers for variables in fast loops (part 1)
			var f = new _FindData {
				color = (optim.v0.color & 0xffffff) | (_diff << 24),
				p = pFirst - 1,
				pLineLast = pFirst + areaWidthMinusImage
			};

			#region fast_code

			//This for loop must be as fast as possible.
			//	There are too few 32-bit registers. Must be used a many as possible registers. See comments below.
			//	No problems if 64-bit.

			gContinue:
			if (pls?.IsStopped ?? false) goto gNotFound;
			{
				var f_ = &f; //part 2 of the workaround
				var p_ = f_->p + 1; //register
				var color_ = f_->color; //register
				var pLineLast_ = f_->pLineLast; //register
				for (; ; ) { //lines
					if (color_ < 0x1000000) {
						for (; p_ <= pLineLast_; p_++) {
							if (color_ == (*p_ & 0xffffff)) goto gPixelFound;
						}
					} else {
						//all variables except f.pLineLast are in registers
						//	It is very sensitive to other code. Compiler can take some registers for other code and not use here.
						//	Then still not significantly slower, but I like to have full speed.
						//	Code above fast_code region should not contain variables that are used in loops below this block.
						//	Also don't use class members in fast_code region, because then compiler may take a register for 'this' pointer.
						//	Here we use f.pLineLast instead of pLineLast_, else d2_ would be in memory (it is used 3 times).
						var d_ = color_ >> 24; //register
						var d2_ = d_ * 2; //register
						for (; p_ <= f.pLineLast; p_++) {
							if ((color_ & 0xff) - ((byte*)p_)[0] + d_ > d2_) continue;
							if ((color_ >> 8 & 0xff) - ((byte*)p_)[1] + d_ > d2_) continue;
							if ((color_ >> 16 & 0xff) - ((byte*)p_)[2] + d_ > d2_) continue;
							goto gPixelFound;
						}
					}
					if (p_ > pLast) goto gNotFound;
					p_--; p_ += imageWidth;
					f.pLineLast = pLineLast_ = p_ + areaWidthMinusImage;
				}
				gPixelFound:
				f.p = p_;
			}

			//nTimesFound++;
			var ap = f.p - o_pos0; //the first area pixel of the top-left of the image

			//compare other 0-3 selected pixels
			for (var op = o_a1; op < o_an; op++) {
				uint aPix = ap[op->pos], iPix = op->color;
				var colorDiff = f.color >> 24;
				if (colorDiff == 0) {
					if (!_MatchPixelExact(aPix, iPix)) goto gContinue;
				} else {
					if (!_MatchPixelDiff(aPix, iPix, colorDiff)) goto gContinue;
				}
			}

			//now compare all pixels of the image
			//perf.first();
			uint* ip = imagePixels, ipLineTo = ip + imageWidth;
			for (; ; ) { //lines
				if (f.color < 0x1000000) {
					do {
						if (!_MatchPixelExact(*ap, *ip)) goto gContinue;
						ap++;
					}
					while (++ip < ipLineTo);
				} else {
					var colorDiff = f.color >> 24;
					do {
						if (!_MatchPixelDiff(*ap, *ip, colorDiff)) goto gContinue;
						ap++;
					}
					while (++ip < ipLineTo);
				}
				if (ip == imagePixelsTo) break;
				ap += areaWidthMinusImage;
				ipLineTo += imageWidth;
			}
			//perf.nw();
			//print.it(nTimesFound);

			#endregion

			if (_action != Action_.WaitChanged) {
				int iFound = (int)(f.p - o_pos0 - areaPixels);
				RECT r = new(iFound % _ad.Width, iFound / _ad.Width, imageWidth, imageHeight);

				lock (this) {
					if (pls?.IsStopped ?? false) goto gNotFound;

					if (_flags.HasAny(IFFlags.WindowDC | IFFlags.PrintWindow)) {
						dpiScaling ??= new(_area.W);
						dpiScaling.ScaleRect(ref r);
					}
					r.Offset(_resultOffset.x, _resultOffset.y);

					uiimage tempResult = new(_area) { Rect = r, MatchIndex = matchIndex, ListIndex = listIndex };

					if (_also != null) {
						alsoAction = _also(tempResult);
						if (alsoAction is IFAlso.OkFindMoreOfThis or IFAlso.FindOtherOfThis && pls != null) {
							//stop other threads, but not this thread
							pls.Stop();
							pls = null;
							//never mind: if later _also returns "continue to search in list" (unlikely), will not search.
							//	pls.Stop must be called while locked, to prevent other threads calling _also afterwards.
							//	Now using the simple way (lock).
							//	The complex way - use Monitor.Enter/Exit. Call Stop/Exit when returning. Bad: other threads would continue to search unnecessarily.
						}
						switch (alsoAction) {
						case IFAlso.OkFindMore or IFAlso.OkFindMoreOfThis:
							alsoResult = tempResult;
							matchIndex++;
							goto gContinue;
						case IFAlso.FindOther or IFAlso.FindOtherOfThis:
							matchIndex++;
							goto gContinue;
						case IFAlso.OkFindMoreOfList:
							alsoResult = tempResult;
							return false;
						case IFAlso.FindOtherOfList:
							return false;
						}
					}

					if (alsoAction != IFAlso.NotFound) Result = tempResult;
					pls?.Stop();
				}
			}
		} //fixed

		return true;
		gNotFound:
		return alsoAction is IFAlso.FindOtherOfThis or IFAlso.OkFindMoreOfThis;

		//returns true to stop seaching (skip other images in list)
	}

	struct _FindData {
		public uint color;
		public uint* p, pLineLast;
	}

	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	static bool _MatchPixelExact(uint ap, uint ip) {
		if (ip == (ap | 0xff000000)) return true;
		return ip < 0xff000000; //transparent?
	}

	[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.AggressiveOptimization)]
	static bool _MatchPixelDiff(uint ap, uint ip, uint colorDiff) {
		//info: optimized. Don't modify.
		//	All variables are in registers.
		//	Only 3.5 times slower than _MatchPixelExact (when all pixels match), which is inline.

		if (ip >= 0xff000000) { //else transparent
			uint d = colorDiff, d2 = d * 2;
			if (((ip & 0xff) - (ap & 0xff) + d) > d2) goto gFalse;
			if (((ip >> 8 & 0xff) - (ap >> 8 & 0xff) + d) > d2) goto gFalse;
			if (((ip >> 16 & 0xff) - (ap >> 16 & 0xff) + d) > d2) goto gFalse;
		}
		return true;
		gFalse:
		return false;
	}

	//bool _CompareSameSize(uint* area, uint* image, uint* imageTo, uint colorDiff)
	//{
	//	if(colorDiff == 0) {
	//		do {
	//			if(!_MatchPixelExact(*area, *image)) break;
	//			area++;
	//		} while(++image < imageTo);
	//	} else {
	//		do {
	//			if(!_MatchPixelDiff(*area, *image, colorDiff)) break;
	//			area++;
	//		} while(++image < imageTo);
	//	}
	//	return image == imageTo;
	//}

	static bool _IsTransparent(uint color) => color < 0xff000000;

	struct _OptimizationData {
		internal struct POSCOLOR {
			public int pos; //the position in area (not in image) from which to start searching. Depends on where in the image is the color.
			public uint color;
		};

#pragma warning disable 649 //never assigned
		public POSCOLOR v0, v1, v2, v3; //POSCOLOR[] would be slower
#pragma warning restore 649
		public int N; //A valid count
		int _areaWidth;

		public bool Init(_Image image, int areaWidth) {
			if (areaWidth != _areaWidth) { _areaWidth = areaWidth; N = 0; }
			if (N != 0) return N > 0;

			int imageWidth = image.width, imageHeight = image.height;
			int imagePixelCount = imageWidth * imageHeight;
			var imagePixels = image.pixels;
			int i;

#if WI_TEST_NO_OPTIMIZATION
			_Add(image, 0, areaWidth);
#else

			//Find several unique-color pixels for first-pixel search.
			//This greatly reduces the search time in most cases.

			//find first nontransparent pixel
			for (i = 0; i < imagePixelCount; i++) if (!_IsTransparent(imagePixels[i])) break;
			if (i == imagePixelCount) { N = -1; return false; } //not found because all pixels in image are transparent

			//find first nonbackground pixel (consider top-left pixel is background)
			bool singleColor = false;
			if (i == 0) {
				i = _FindDifferentPixel(0);
				if (i < 0) { singleColor = true; i = 0; }
			}

			_Add(image, i, areaWidth);
			if (!singleColor) {
				//find second different pixel
				int i0 = i;
				i = _FindDifferentPixel(i);
				if (i >= 0) {
					_Add(image, i, areaWidth);
					//find other different pixels
					fixed (POSCOLOR* p = &v0) {
						while (N < 4) {
							for (++i; i < imagePixelCount; i++) {
								var c = imagePixels[i];
								if (_IsTransparent(c)) continue;
								int j = N - 1;
								for (; j >= 0; j--) if (c == p[j].color) break; //find new color
								if (j < 0) break; //found
							}
							if (i >= imagePixelCount) break;
							_Add(image, i, areaWidth);
						}
					}
				} else {
					for (i = imagePixelCount - 1; i > i0; i--) if (!_IsTransparent(imagePixels[i])) break;
					_Add(image, i, areaWidth);
				}
			}

			//fixed (POSCOLOR* o_pc = &v0) for(int j = 0; j < N; j++) print.it($"{o_pc[j].pos} 0x{o_pc[j].color:X}");
#endif
			return true;

			int _FindDifferentPixel(int iCurrent) {
				int m = iCurrent, n = imagePixelCount;
				uint notColor = imagePixels[m++];
				for (; m < n; m++) {
					var c = imagePixels[m];
					if (c == notColor || _IsTransparent(c)) continue;
					return m;
				}
				return -1;
			}
		}

		void _Add(_Image image, int i, int areaWidth) {
			fixed (POSCOLOR* p0 = &v0) {
				var p = p0 + N++;
				p->color = image.pixels[i];
				int w = image.width, x = i % w, y = i / w;
				p->pos = y * areaWidth + x;
			}
		}
	}

	bool _GetAreaPixels(RECT r, bool toImage0 = false) {
		//Transfer from screen/window DC to memory DC (does not work without this) and get pixels.
		//This is the slowest part of Find, especially BitBlt.
		//Speed depends on computer, driver, OS version, theme, size.
		//For example, with Aero theme 2-15 times slower (on Windows 8/10 cannot disable Aero).
		//With incorrect/generic video driver can be 10 times slower. Eg on vmware virtual PC.
		//Much faster when using window DC. Then same speed as without Aero.

		_ad.DontSetAlpha_ = !toImage0;
		bool ok = _area.Type == IFArea.AreaType.Screen
			? _ad.Capture(r, relaxed: true)
			: _ad.Capture(_area.W, r, _flags.ToCIFlags_() | CIFlags.Relaxed);
		if (!ok) return false; //r not in client area. Probably the window resized since r.Intersect(clientArea).

		if (toImage0) {
			var im = new _Image { width = r.Width, height = r.Height, pixels = _ad.ToArray1D() };
			_images.Add(im);
		}

		return true;
	}

#if false
	//r is relative to the search area
	void _DpiScaleRect(ref RECT r) {
		if (!_flags.HasAny(IFFlags.WindowDC | IFFlags.PrintWindow)) return;
		var w = _area.W.Window;
		if (!Dpi.IsWindowVirtualizedWin10_(w)) return; //makes faster on Win10+; don't scale on older OS
		int d1 = screen.of(w).Dpi, d2 = Dpi.OfWindow(w);
		r.left = Math2.MulDiv(r.left, d1, d2);
		r.top = Math2.MulDiv(r.top, d1, d2);
		r.right = Math2.MulDiv(r.right, d1, d2);
		r.bottom = Math2.MulDiv(r.bottom, d1, d2);
	}
#else
	//cache DPI scaling info. Getting it can make much slower if many matches found. Above is the non-cached version.
	class _DpiScaling {
		wnd _w;
		ushort _dScreen, _dWindow;
		bool _inited, _scaled;

		public _DpiScaling(wnd w) { _w = w; }

		//r is relative to the search area
		public void ScaleRect(ref RECT r) {
			if (!_inited) {
				_inited = true;
				if (_scaled = Dpi.IsWindowVirtualizedWin10_(_w = _w.Window)) {
					_dScreen = (ushort)screen.of(_w).Dpi;
					_dWindow = (ushort)Dpi.OfWindow(_w);
				}
			}
			if (_scaled) {
				r.left = Math2.MulDiv(r.left, _dScreen, _dWindow);
				r.top = Math2.MulDiv(r.top, _dScreen, _dWindow);
				r.right = Math2.MulDiv(r.right, _dScreen, _dWindow);
				r.bottom = Math2.MulDiv(r.bottom, _dScreen, _dWindow);
			}
		}
	}
#endif
}


================================================
FILE: Au/UI objects/uiimage_types.cs
================================================
using System.Drawing;

namespace Au.Types;

#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
/// <summary>
/// Defines the search area for <see cref="uiimage.find"/> and similar functions.
/// </summary>
/// <remarks>
/// It can be a window/control, UI element, image or a rectangle in screen.
/// Has implicit conversions from <see cref="wnd"/>, <see cref="elm"/>, <see cref="Bitmap"/> and <see cref="RECT"/> (rectangle in screen).
/// Constructors can be used to specify a rectangle in window or UI element, which makes the area smaller and the function faster.
/// Example: <c>uiimage.find(new(w, (left, top, width, height)), image);</c>.
/// </remarks>
public class IFArea {
	internal enum AreaType : byte { Screen, Wnd, Elm, Bitmap }

	internal AreaType Type;
	readonly bool _hasRect, _hasCoord;
	internal wnd W;
	internal elm E;
	internal Bitmap B;
	RECT _r;
	readonly Coord _cLeft, _cTop, _cRight, _cBottom;

	IFArea(AreaType t) { Type = t; }

	/// <summary>Specifies a window or control and a rectangle in its client area.</summary>
	public IFArea(wnd w, RECT r) { Type = AreaType.Wnd; W = w; _r = r; _hasRect = true; }

	/// <summary>Specifies a UI element and a rectangle in it.</summary>
	public IFArea(elm e, RECT r) { Type = AreaType.Elm; E = e; _r = r; _hasRect = true; }

	//rejected. Rare etc.
	//public IFArea(Bitmap b, RECT r) { ... }

	/// <summary>
	/// Specifies a window or control and a rectangle in its client area.
	/// The parameters are of <see cref="Coord"/> type, therefore can be easily specified reverse and fractional coordinates, like <c>^10</c> and <c>.5f</c>. Use <c>^0</c> for right or bottom edge.
	/// </summary>
	public IFArea(wnd w, Coord left, Coord top, Coord right, Coord bottom) {
		Type = AreaType.Wnd;
		W = w;
		_cLeft = left;
		_cTop = top;
		_cRight = right;
		_cBottom = bottom;
		_hasRect = _hasCoord = true;
	}

	/// <summary>
	/// Specifies a UI element and a rectangle in it.
	/// The parameters are of <see cref="Coord"/> type, therefore can be easily specified reverse and fractional coordinates, like <c>^10</c> and <c>.5f</c>. Use <c>^0</c> for right or bottom edge.
	/// </summary>
	public IFArea(elm e, Coord left, Coord top, Coord right, Coord bottom) {
		Type = AreaType.Elm;
		E = e;
		_cLeft = left;
		_cTop = top;
		_cRight = right;
		_cBottom = bottom;
		_hasRect = _hasCoord = true;
	}

	public static implicit operator IFArea(wnd w) => new(AreaType.Wnd) { W = w };
	public static implicit operator IFArea(elm e) => new(AreaType.Elm) { E = e };
	public static implicit operator IFArea(Bitmap b) => new(AreaType.Bitmap) { B = b };
	public static implicit operator IFArea(RECT r) => new(AreaType.Screen) { _r = r };

	internal void Before_(bool windowPixels) {
		if (windowPixels && Type is AreaType.Screen or AreaType.Bitmap) throw new ArgumentException("Invalid flags for this area type");

		switch (Type) {
		case AreaType.Wnd:
			W.ThrowIfInvalid();
			break;
		case AreaType.Elm:
			if (E == null) throw new ArgumentNullException("area elm");
			W = E.WndContainer;
			goto case AreaType.Wnd;
		case AreaType.Bitmap:
			if (B == null) throw new ArgumentNullException("area Bitmap");
			break;
		}
	}

	internal bool GetRect_(out RECT r, out POINT resultOffset, IFFlags flags) {
		r = default;
		resultOffset = default;

		if (!W.Is0) {
			if (!W.IsVisible || W.IsMinimized) return false;
			if (!flags.HasAny(IFFlags.WindowDC | IFFlags.PrintWindow) && W.IsCloaked) return false;
		}

		//Get area rectangle.
		bool failed = false;
		switch (Type) {
		case AreaType.Wnd:
			failed = !W.GetClientRect(out r);
			break;
		case AreaType.Elm:
			failed = !E.GetRect(out r, W);
			break;
		case AreaType.Bitmap:
			r = new RECT(0, 0, B.Width, B.Height);
			break;
		default: //Screen
			r = _r;
			if (!screen.isInAnyScreen(r)) r = default;
			resultOffset.x = r.left; resultOffset.y = r.top;
			break;
		}
		if (failed) {
			W.ThrowIfInvalid();
			throw new AuException("*get rectangle");
		}

		//r is the area from where to get pixels. If Wnd or Elm, it is relative to W client area.
		//Intermediate results will be relative to r. Then will be added resultOffset if need.

		if (_hasRect) {
			RECT rr;
			if (_hasCoord) {
				RECT rc = new(0, 0, r.Width, r.Height);
				POINT p1 = Coord.NormalizeInRect(_cLeft, _cTop, rc), p2 = Coord.NormalizeInRect(_cRight, _cBottom, rc);
				rr = RECT.FromLTRB(p1.x, p1.y, p2.x, p2.y);
			} else {
				rr = _r;
			}
			resultOffset.x = rr.left; resultOffset.y = rr.top;
			rr.Offset(r.left, r.top);
			r.Intersect(rr);
		}

		if (Type == AreaType.Elm) {
			//adjust r and resultOffset,
			//	because object rectangle may be bigger than client area (eg WINDOW object)
			//	or its part is not in client area (eg scrolled web page).
			//	If not adjusted, then may capture part of parent or sibling controls or even other windows...
			//	Never mind: should also adjust control rectangle in ancestors in the same way.
			//		This is not so important because usually whole control is visible (resized, not clipped).
			int x = r.left, y = r.top;
			W.GetClientRect(out var rw);
			r.Intersect(rw);
			x -= r.left; y -= r.top;
			resultOffset.x -= x; resultOffset.y -= y;
		}

		return !r.NoArea; //never mind: if WaitChanged and this is the first time, immediately returns 'changed'
	}

	/// <summary>
	/// Calls <c>GetRect_</c>, and <c>CaptureScreen.Image</c> if need.
	/// </summary>
	/// <returns><c>false</c> if <c>GetRect_</c> returns <c>false</c> (empty rectangle).</returns>
	internal bool GetOcrData_(OcrFlags flags, out Bitmap b, out POINT resultOffset) {
		if (Type == AreaType.Bitmap) { b = B; resultOffset = default; return true; }
		if (!GetRect_(out RECT r, out resultOffset, (IFFlags)flags)) { b = null; return false; }
		b = Type == AreaType.Screen ? CaptureScreen.Image(r) : CaptureScreen.Image(W, r, flags.ToCIFlags_());
		return true;
	}

	/// <summary>
	/// If <i>scale</i>!=0, returns <i>scale</i>. Else returns 1...2 depending on <i>engine</i> and <i>area</i> DPI.
	/// </summary>
	internal double GetOcrScale_(double scale, IOcrEngine engine) {
		if (scale != 0) return scale;
		if (engine.DpiScale) {
			int dpi = Type switch {
				AreaType.Wnd or AreaType.Elm => Dpi.OfWindow(W),
				AreaType.Screen => screen.of(_r).Dpi,
				_ => 200
			};
			if (dpi < 192) return 192d / dpi;
		}
		return 1d;
	}
}

/// <summary>
/// Image(s) or color(s) for <see cref="uiimage.find"/> and similar functions.
/// </summary>
/// <remarks>
/// Has implicit conversions from:
/// - string - path of <c>.png</c> or <c>.bmp</c> file. If not full path, uses <see cref="folders.ThisAppImages"/>.
/// - string that starts with <c>"resources/"</c> or has prefix <c>"resource:"</c> - resource name; see <see cref="ResourceUtil.GetGdipBitmap"/>.
/// - string with prefix <c>"image:"</c> - Base64 encoded <c>.png</c> image.\
///   Can be created with tool <b>Find image or color in window</b> or with function <c>Au.Controls.KImageUtil.ImageToString</c> (in <c>Au.Controls.dll</c>).
/// - <see cref="ColorInt"/>, <c>int</c> or <c>uint</c> in <c>0xRRGGBB</c> color format, <see cref="Color"/> - color. Alpha isn't used.
/// - <see cref="Bitmap"/> - image object.
/// - <c>IFImage[]</c> - multiple images or/and colors. Action - find any. To create a different action can be used callback function (parameter <i>also</i>).
/// 
/// Icons are not supported directly; you can use <see cref="icon"/> to get icon and convert to bitmap.
/// </remarks>
public struct IFImage {
	readonly object _o;
	IFImage(object o) { _o = o; }

	public static implicit operator IFImage(string pathEtc) => new(pathEtc);
	public static implicit operator IFImage(Bitmap image) => new(image);
	public static implicit operator IFImage(ColorInt color) => new(color);
	public static implicit operator IFImage(int color) => new((ColorInt)color);
	public static implicit operator IFImage(uint color) => new((ColorInt)color);
	public static implicit operator IFImage(Color color) => new((ColorInt)color);
	public static implicit operator IFImage(System.Windows.Media.Color color) => new((ColorInt)color);
	//public static implicit operator IFImage(IEnumerable<IFImage> list) => new(list); //error: cannot convert from interfaces
	public static implicit operator IFImage(IFImage[] list) => new(list);
	//public static implicit operator IFImage(List<IFImage> list) => new(list); //rare, can use ToArray()

	/// <summary>
	/// Gets the raw value stored in this variable. Can be <c>string</c>, <see cref="Bitmap"/>, <see cref="ColorInt"/>, <see cref="IFImage"/><c>[]</c>, <c>null</c>.
	/// </summary>
	public object Value => _o;
}
#pragma warning restore CS1591 // Missing XML comment for publicly visible type or member

/// <summary>
/// Flags for <see cref="uiimage.find"/> and similar functions.
/// </summary>
[Flags]
public enum IFFlags {
	/// <summary>
	/// Get pixels from the device context (DC) of the window client area, not from screen DC. Usually much faster.
	/// Can get pixels from window parts that are covered by other windows or offscreen. But not from hidden and minimized windows.
	/// Does not work on Windows 7 if Aero theme is turned off. Then this flag is ignored.
	/// Cannot find images in some windows (including Windows Store apps), and in some window parts (glass). All pixels captured from these windows/parts are black.
	/// If the window is partially or completely transparent, the image must be captured from its non-transparent version.
	/// If the window is DPI-scaled, the image must be captured from its non-scaled version. However if used a limiting rectangle, it must contain scaled coordinates.
	/// </summary>
	WindowDC = 1,

	/// <summary>
	/// Use API <ms>PrintWindow</ms> to get window pixels.
	/// Like <c>WindowDC</c>, works with background windows, etc. Differences:
	/// <br/>• On Windows 8.1 and later works with windows where <c>WindowDC</c> doesn't.
	/// <br/>• Works without Aero theme too.
	/// <br/>• Slower.
	/// <br/>• Some windows flicker.
	/// <br/>• From some controls randomly gets partial image (API bug).
	/// <br/>• Does not work with windows of higher [](xref:uac) integrity level (throws exception).
	/// <br/>• Unreliable with DPI-scaled windows; the window image slightly changes when resizing etc.
	/// </summary>
	PrintWindow = 2,
	//rejected, makes no sense: /// <br/>• If used together with flag <c>WindowDC</c>, calls <c>PrintWindow</c> without flag <c>PW_RENDERFULLCONTENT</c>. Faster, less flickering, no bugs, but has the <c>WindowDC</c> problem: can't get pixels from some windows or window parts.

	///// <summary>
	///// Use DWM thumbnail API to get window pixels.
	///// Like <c>WindowDC</c>, works with background windows, etc. Differences:
	///// <br/>• Works with windows where <c>WindowDC</c> doesn't.
	///// <br/>• Requires Windows 10 or later. Exception if used on older OS.
	///// <br/>• Slower.
	///// <br/>• May not work with some windows (rare).
	///// </summary>
	//WindowDwm = 4,

	//note: the above values must be the same in CIFlags, CIUFlags, IFFlags, OcrFlags.

	/// <summary>
	/// This flag can make the function faster when <i>image</i> is a list of images. To search for each image, the function will use <see cref="Parallel.For"/> instead of <c>for</c>. For example, if the CPU has 4 cores (8 threads), can search for max 8 images simultaneously. However it does not mean it will be 8 times faster. Can be max 2 or 3 times faster, depending on the number of images, flag <c>WindowDC</c>, <i>diff</i>, <i>also</i>, CPU, RAM, area size, finds or not, image position, etc. Can be even slower. To measure speed, use <see cref="perf"/>.
	/// If used <i>also</i> callback function, it runs in any thread and any order, but one at a time (inside <c>lock() { }</c>).
	/// </summary>
	Parallel = 0x100

	//rejected: this was used in QM2. Now can use png alpha instead.
	///// <summary>
	///// Use the top-left pixel color of the image as transparent color (don't compare pixels that have this color).
	///// </summary>
	//MakeTransparent = ,
}

/// <summary>
/// Used with <see cref="uiimage.find"/> and <see cref="uiimage.wait"/>. Its callback function (parameter <i>also</i>) can return one of these values.
/// </summary>
public enum IFAlso {
	/// <summary>
	/// Stop searching.
	/// Let the main function return current result.
	/// </summary>
	OkReturn,

	/// <summary>
	/// Find more instances of current image. If used list of images, also search for other images.
	/// Then let the main function return current result.
	/// </summary>
	OkFindMore,

	/// <summary>
	/// Find more instances of current image. When used list of images, don't search for other images.
	/// Then let the main function return current result.
	/// </summary>
	OkFindMoreOfThis,

	/// <summary>
	/// If used list of images, search for other images. Don't search for more instances of current image.
	/// Then let the main function return current result.
	/// </summary>
	OkFindMoreOfList,

	/// <summary>
	/// Stop searching.
	/// Let the main function return <c>null</c> or throw exception or continue waiting. But if a <c>OkFindX</c> value used previously, return that result.
	/// </summary>
	NotFound,

	/// <summary>
	/// Find more instances of current image. If used list of images, also search for other images.
	/// If not found, let the main function return <c>null</c> or throw exception or continue waiting; but if a <c>OkFindX</c> value used previously, return that result.
	/// </summary>
	FindOther,

	/// <summary>
	/// Find more instances of current image. When used list of images, don't search for other images.
	/// If not found, let the main function return <c>null</c> or throw exception or continue waiting; but if a <c>OkFindX</c> value used previously, return that result.
	/// </summary>
	FindOtherOfThis,

	/// <summary>
	/// If used list of images, search for other images. Don't search for more instances of current image.
	/// If not found, let the main function return <c>null</c> or throw exception or continue waiting; but if a <c>OkFindX</c> value used previously, return that result.
	/// </summary>
	FindOtherOfList,
}


================================================
FILE: Au/resources/global2.cs
================================================
//This file is used by several projects: Au, Au.Controls, Au.Editor.

global using Au;
global using Au.Types;
global using Au.More;
global using System;
global using System.Collections.Generic;
global using System.Collections.Concurrent;
global using System.Linq;
global using System.Text;
global using System.Diagnostics;
global using System.Runtime.CompilerServices;
global using System.Runtime.InteropServices;
global using System.IO;
global using System.Threading;
global using System.Threading.Tasks;
global using System.Reflection;
global using System.Globalization;

global using SystemInformation = System.Windows.Forms.SystemInformation;
global using RStr = System.ReadOnlySpan<char>;
global using RByte = System.ReadOnlySpan<byte>;
global using System.ComponentModel;
global using IEnumerable = System.Collections.IEnumerable;
global using IEnumerator = System.Collections.IEnumerator;

[module: DefaultCharSet(CharSet.Unicode)]
[assembly: ComVisible(false)]

[assembly: AssemblyCompany("Gintaras Didžgalvis")]
[assembly: AssemblyProduct("LibreAutomate")]
[assembly: AssemblyCopyright("Copyright 2020-2026 Gintaras Didžgalvis")]
[assembly: AssemblyCulture("")]

[assembly: AssemblyVersion(Au_.Version)]

#if AU
namespace Au.More;

///
[EditorBrowsable(EditorBrowsableState.Never)]
public class Au_ {
	///
	public const string Version = "1.15.0";
}
#endif


================================================
FILE: Au/wnd/WProp.cs
================================================
namespace Au.Types
{
	/// <summary>
	/// Sets, gets, removes and lists window properties using API <ms>SetProp</ms> and co.
	/// </summary>
	public struct WProp
	{
		readonly wnd _w;

		internal WProp(wnd w) => _w = w;

		/// <summary>
		/// Gets a window property.
		/// Calls API <ms>GetProp</ms> and returns its return value.
		/// </summary>
		/// <param name="name">Property name.</param>
		/// <remarks>Supports <see cref="lastError"/>.</remarks>
		public nint this[string name] => Api.GetProp(_w, name);

		/// <summary>
		/// Gets a window property.
		/// Calls API <ms>GetProp</ms> and returns its return value.
		/// </summary>
		/// <param name="atom">Property name atom in the global atom table.</param>
		/// <remarks>
		/// This overload uses atom instead of string. It's about 3 times faster. See API <ms>GlobalAddAtom</ms>, <ms>GlobalDeleteAtom</ms>.
		/// </remarks>
		public nint this[ushort atom] => Api.GetProp(_w, atom);

		/// <summary>
		/// Sets a window property.
		/// Calls API <ms>SetProp</ms> and returns its return value.
		/// </summary>
		/// <param name="name">Property name.</param>
		/// <param name="value">Property value.</param>
		/// <remarks>
		/// Supports <see cref="lastError"/>.
		/// 
		/// Later call <see cref="Remove(string)"/> to remove the property. If you use many unique property names and don't remove the properties, the property name strings can fill the global atom table which is of a fixed size (about 48000) and which is used by all processes for various purposes.
		/// </remarks>
		public bool Set(string name, nint value) {
			return Api.SetProp(_w, name, value);
		}

		/// <summary>
		/// Sets a window property.
		/// Calls API <ms>SetProp</ms> and returns its return value.
		/// </summary>
		/// <param name="atom">Property name atom in the global atom table.</param>
		/// <param name="value">Property value.</param>
		/// <remarks>
		/// This overload uses atom instead of string. It's about 3 times faster. See API <ms>GlobalAddAtom</ms>, <ms>GlobalDeleteAtom</ms>.
		/// </remarks>
		public bool Set(ushort atom, nint value) {
			return Api.SetProp(_w, atom, value);
		}

		/// <summary>
		/// Removes a window property.
		/// Calls API <ms>RemoveProp</ms> and returns its return value.
		/// </summary>
		/// <param name="name">Property name. Other overload allows to use global atom instead, which is faster.</param>
		/// <remarks>Supports <see cref="lastError"/>.</remarks>
		public nint Remove(string name) {
			return Api.RemoveProp(_w, name);
		}

		/// <summary>
		/// Removes a window property.
		/// Calls API <ms>RemoveProp</ms> and returns its return value.
		/// </summary>
		/// <param name="atom">Property name atom in the global atom table.</param>
		public nint Remove(ushort atom) {
			return Api.RemoveProp(_w, atom);
		}

		/// <summary>
		/// Gets list of window properties.
		/// Uses API <ms>EnumPropsEx</ms>.
		/// </summary>
		/// <returns>0-length list if failed. Fails if invalid window or access denied ([](xref:uac)). Supports <see cref="lastError"/>.</returns>
		public Dictionary<string, nint> GetList() {
			var a = new Dictionary<string, nint>();
			Api.EnumPropsEx(_w, (w, name, data, p) => {
				string s;
				if ((long)name < 0x10000) s = "#" + (int)name; else s = Marshal.PtrToStringUni(name);
				a.Add(s, data);
				return true;
			}, default);
			return a;
		}

		/// <summary>
		/// Calls <see cref="GetList"/> and converts to string.
		/// </summary>
		public override string ToString() {
			return string.Join("\r\n", GetList());
		}
	}
}


================================================
FILE: Au/wnd/WTaskbarButton.cs
================================================
namespace Au.Types;

/// <summary>
/// Taskbar button flash, progress, add/delete.
/// </summary>
public unsafe class WTaskbarButton {
	readonly wnd _w;
	
	internal WTaskbarButton(wnd w) => _w = w;
	
	/// <summary>
	/// Starts or stops flashing the taskbar button of this window.
	/// </summary>
	/// <param name="count">The number of times to flash. If 0, stops flashing.</param>
	public void Flash(int count) {
		//const uint FLASHW_STOP = 0;
		//const uint FLASHW_CAPTION = 0x00000001;
		const uint FLASHW_TRAY = 0x00000002;
		//const uint FLASHW_ALL = FLASHW_CAPTION | FLASHW_TRAY;
		//const uint FLASHW_TIMER = 0x00000004;
		//const uint FLASHW_TIMERNOFG = 0x0000000C;
		
		var fi = new Api.FLASHWINFO { cbSize = sizeof(Api.FLASHWINFO), hwnd = _w };
		if (count > 0) {
			fi.uCount = count;
			//fi.dwTimeout = (uint)periodMS; //not useful
			fi.dwFlags = FLASHW_TRAY;
		}
		Api.FlashWindowEx(ref fi);
		
		//tested. FlashWindow is easier but does not work for taskbar button, only for title bar when no taskbar button.
	}
	
	/// <summary>
	/// Sets the state of the progress indicator displayed on the taskbar button of this window.
	/// Calls <ms>ITaskbarList3.SetProgressState</ms>.
	/// </summary>
	/// <param name="state">Progress indicator state and color.</param>
	public void SetProgressState(WTBProgressState state) {
		_TL?.SetProgressState(_w, state);
	}
	
	/// <summary>
	/// Sets the value of the progress indicator displayed on the taskbar button of this window.
	/// Calls <ms>ITaskbarList3.SetProgressValue</ms>.
	/// </summary>
	/// <param name="progressValue">Progress indicator value, 0 to <i>progressTotal</i>.</param>
	/// <param name="progressTotal">Max progress indicator value.</param>
	public void SetProgressValue(int progressValue, int progressTotal = 100) {
		_TL?.SetProgressValue(_w, progressValue, progressTotal);
	}
	
	/// <summary>
	/// Adds taskbar button of this window.
	/// Calls <ms>ITaskbarList.AddTab</ms>.
	/// </summary>
	public void Add() {
		_TL?.AddTab(_w);
		//tested: always returns 0, even if w is 0. Did not test other ITaskbarList3 methods.
	}
	
	/// <summary>
	/// Deletes taskbar button of this window.
	/// Calls <ms>ITaskbarList.DeleteTab</ms>.
	/// </summary>
	public void Delete() {
		_TL?.DeleteTab(_w);
	}
	
	static ITaskbarList3 _TL {
		get {
			var r = (ITaskbarList3)new TaskbarList();
			if (0 != r.HrInit()) return null;
			return r;
		}
	}
	
	[ComImport, Guid("56fdf344-fd6d-11d0-958a-006097c9a090"), ClassInterface(ClassInterfaceType.None)]
	class TaskbarList { }
	
	[ComImport, Guid("ea1afb91-9e28-4b86-90e9-9e9f8a5eefaf"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
	interface ITaskbarList3 {
		// ITaskbarList
		[PreserveSig] int HrInit();
		[PreserveSig] int AddTab(wnd hwnd);
		[PreserveSig] int DeleteTab(wnd hwnd);
		[PreserveSig] int ActivateTab(wnd hwnd);
		[PreserveSig] int SetActiveAlt(wnd hwnd);
		
		// ITaskbarList2
		[PreserveSig] int MarkFullscreenWindow(wnd hwnd, bool fFullscreen);
		
		// ITaskbarList3
		[PreserveSig] int SetProgressValue(wnd hwnd, long ullCompleted, long ullTotal);
		[PreserveSig] int SetProgressState(wnd hwnd, WTBProgressState state);
		[PreserveSig] int RegisterTab(wnd hwndTab, wnd hwndMDI);
		[PreserveSig] int UnregisterTab(wnd hwndTab);
		[PreserveSig] int SetTabOrder(wnd hwndTab, wnd hwndInsertBefore);
		[PreserveSig] int SetTabActive(wnd hwndTab, wnd hwndMDI, uint dwReserved);
		[PreserveSig] int ThumbBarAddButtons(wnd hwnd, uint cButtons, IntPtr pButton); //LPTHUMBBUTTON
		[PreserveSig] int ThumbBarUpdateButtons(wnd hwnd, uint cButtons, IntPtr pButton); //LPTHUMBBUTTON
		[PreserveSig] int ThumbBarSetImageList(wnd hwnd, IntPtr himl);
		[PreserveSig] int SetOverlayIcon(wnd hwnd, IntPtr hIcon, string pszDescription);
		[PreserveSig] int SetThumbnailTooltip(wnd hwnd, string pszTip);
		[PreserveSig] int SetThumbnailClip(wnd hwnd, ref RECT prcClip);
	}
}

/// <summary>
/// Used by <see cref="WTaskbarButton.SetProgressState"/>.
/// </summary>
public enum WTBProgressState {
#pragma warning disable 1591 //XML doc
	NoProgress = 0,
	Indeterminate = 0x1,
	Normal = 0x2,
	Error = 0x4,
	Paused = 0x8
#pragma warning restore 1591 //XML doc
}


================================================
FILE: Au/wnd/WndCopyData.cs
================================================
namespace Au.More {
	/// <summary>
	/// Send/receive data to/from other process using message <ms>WM_COPYDATA</ms>.
	/// </summary>
	/// <remarks>
	/// This struct is <ms>COPYDATASTRUCT</ms>.
	/// <note>By default [](xref:uac) blocks messages sent from processes of lower integrity level. Call <see cref="EnableReceivingWM_COPYDATA"/> if need.</note>
	/// </remarks>
	/// <seealso cref="System.IO.MemoryMappedFiles.MemoryMappedFile"/>
	/// <seealso cref="System.IO.Pipes.NamedPipeServerStream"/>
	public unsafe struct WndCopyData {
		//COPYDATASTRUCT fields
		nint _dwData;
		int _cbData;
		byte* _lpData;

		#region receive

		/// <summary>
		/// Initializes this variable from <i>lParam</i> of a received <ms>WM_COPYDATA</ms> message.
		/// Then you can call functions of this variable to get data in managed format.
		/// </summary>
		/// <param name="lParam"><i>lParam</i> of a <ms>WM_COPYDATA</ms> message received in a window procedure. It is <ms>COPYDATASTRUCT</ms> pointer.</param>
		public WndCopyData(nint lParam) {
			var p = (WndCopyData*)lParam;
			_dwData = p->_dwData; _cbData = p->_cbData; _lpData = p->_lpData;
		}

		/// <summary>
		/// Data id. It is <ms>COPYDATASTRUCT.dwData</ms>.
		/// </summary>
		public int DataId { get => (int)_dwData; set => _dwData = value; }

		/// <summary>
		/// Unmanaged data pointer. It is <ms>COPYDATASTRUCT.lpData</ms>.
		/// </summary>
		public byte* RawData { get => _lpData; set => _lpData = value; }

		/// <summary>
		/// Unmanaged data size. It is <ms>COPYDATASTRUCT.cbData</ms>.
		/// </summary>
		public int RawDataSize { get => _cbData; set => _cbData = value; }

		/// <summary>
		/// Gets received data as string.
		/// </summary>
		public string GetString() {
			return new string((char*)_lpData, 0, _cbData / 2);
		}

		/// <summary>
		/// Gets received data as <c>byte[]</c>.
		/// </summary>
		public byte[] GetBytes() {
			var a = new byte[_cbData];
			Marshal.Copy((IntPtr)_lpData, a, 0, a.Length);
			return a;
		}

		/// <summary>
		/// Calls API <ms>ChangeWindowMessageFilter</ms>(<c>WM_COPYDATA</c>). Then windows of this process can receive this message from lower [](xref:uac) integrity level processes.
		/// </summary>
		public static void EnableReceivingWM_COPYDATA() {
			Api.ChangeWindowMessageFilter(Api.WM_COPYDATA, 1);
		}

		#endregion

		#region send

		/// <summary>
		/// Sends string or other data to a window of any process. Uses API <ms>SendMessage</ms> <ms>WM_COPYDATA</ms>.
		/// </summary>
		/// <typeparam name="T">Type of data elements. For example, <c>char</c> for string, <c>byte</c> for <c>byte[]</c>.</typeparam>
		/// <param name="w">The window.</param>
		/// <param name="dataId">Data id. It is <ms>COPYDATASTRUCT.dwData</ms>.</param>
		/// <param name="data">Data. For example string or <c>byte[]</c>. String can contain <c>'\0'</c> characters.</param>
		/// <param name="wParam">Can be any value. Optional.</param>
		/// <returns><c>SendMessage</c>'s return value.</returns>
		public static unsafe nint Send<T>(wnd w, int dataId, ReadOnlySpan<T> data, nint wParam = 0) where T : unmanaged {
			fixed (T* p = data) {
				var c = new WndCopyData { _dwData = dataId, _cbData = data.Length * sizeof(T), _lpData = (byte*)p };
				return w.Send(Api.WM_COPYDATA, wParam, &c);
			}
		}

		/// <summary>
		/// Type of <see cref="SendReceive{TSend, TReceive}(wnd, int, ReadOnlySpan{TSend}, ResultReader{TReceive})"/> callback function.
		/// </summary>
		/// <param name="span">Received data buffer. The callback function can convert it to array, string, etc.</param>
		public delegate void ResultReader<TReceive>(ReadOnlySpan<TReceive> span) where TReceive : unmanaged;
		//compiler error if Action<ReadOnlySpan<TReceive>>.
		//could instead use System.Buffers.ReadOnlySpanAction, but then need TState, which is difficult to use for return, and nobody would use, and would not make faster etc.

		static readonly Lazy<IntPtr> s_mutex = new(Api.CreateMutex(null, false, "Au-mutex-WndUtil.Data")); //tested: don't need Api.SECURITY_ATTRIBUTES.ForLowIL

		/// <summary>
		/// Sends string or other data to a window of any process. Uses API <ms>SendMessage</ms> <ms>WM_COPYDATA</ms>.
		/// Receives string or other data returned by that window with <see cref="Return"/>.
		/// </summary>
		/// <typeparam name="TSend">Type of data elements. For example, <c>char</c> for string, <c>byte</c> for <c>byte[]</c></typeparam>
		/// <typeparam name="TReceive">Type of received data elements. For example, <c>char</c> for string, <c>byte</c> for <c>byte[]</c>.</typeparam>
		/// <param name="w">The window.</param>
		/// <param name="dataId">Data id. It is <ms>COPYDATASTRUCT.dwData</ms>.</param>
		/// <param name="send">Data to send. For example string or <c>byte[]</c>. String can contain <c>'\0'</c> characters.</param>
		/// <param name="receive">Callback function that can convert the received data to desired format.</param>
		/// <returns><c>false</c> if failed.</returns>
		public static unsafe bool SendReceive<TSend, TReceive>(wnd w, int dataId, ReadOnlySpan<TSend> send, ResultReader<TReceive> receive) where TSend : unmanaged where TReceive : unmanaged {
			var mutex = s_mutex.Value;
			if (Api.WaitForSingleObject(mutex, -1) is not (0 or Api.WAIT_ABANDONED_0)) return false;
			try {
				int len = (int)Send(w, dataId, send, Api.GetCurrentProcessId());
				if (len == 0) return false;
				var sm = SharedMemory_.ReturnDataPtr;
				if (len > 0) { //shared memory
					if (len <= SharedMemory_.ReturnDataSize) {
						receive(new ReadOnlySpan<TReceive>((TReceive*)sm, len / sizeof(TReceive)));
					} else {
						using var m2 = SharedMemory_.Mapping.CreateOrOpen(new((char*)sm), len);
						receive(new ReadOnlySpan<TReceive>((TReceive*)m2.Mem, len / sizeof(TReceive)));
					}
				} else { //process memory
					var pm = (void*)*(long*)sm;
					receive(new ReadOnlySpan<TReceive>((TReceive*)pm, -len / sizeof(TReceive)));
					bool ok = Api.VirtualFree(pm);
					Debug_.PrintIf(!ok, "VirtualFree");
				}
				return true;
			}
			finally { Api.ReleaseMutex(mutex); }
		}

		/// <summary>
		/// Calls <see cref="SendReceive{TSend, TReceive}(wnd, int, ReadOnlySpan{TSend}, ResultReader{TReceive})"/> and gets the received data as <c>byte[]</c>.
		/// </summary>
		/// <param name="received">The received data.</param>
		/// <inheritdoc cref="SendReceive{TSend, TReceive}(wnd, int, ReadOnlySpan{TSend}, ResultReader{TReceive})"/>
		public static bool SendReceive<TSend>(wnd w, int dataId, ReadOnlySpan<TSend> send, out byte[] received) where TSend : unmanaged {
			byte[] r = null;
			bool R = SendReceive<TSend, byte>(w, dataId, send, span => r = span.ToArray());
			received = r;
			return R;
		}

		/// <summary>
		/// Calls <see cref="SendReceive{TSend, TReceive}(wnd, int, ReadOnlySpan{TSend}, ResultReader{TReceive})"/> and gets the received string.
		/// </summary>
		/// <param name="received">The received data.</param>
		/// <inheritdoc cref="SendReceive{TSend, TReceive}(wnd, int, ReadOnlySpan{TSend}, ResultReader{TReceive})"/>
		public static bool SendReceive<TSend>(wnd w, int dataId, ReadOnlySpan<TSend> send, out string received) where TSend : unmanaged {
			string r = null;
			bool R = SendReceive<TSend, char>(w, dataId, send, span => r = span.ToString());
			received = r;
			return R;
		}

		/// <summary>
		/// Returns data to <see cref="SendReceive"/>.
		/// </summary>
		/// <param name="data"></param>
		/// <param name="length"></param>
		/// <param name="wParam"><i>wParam</i> of the received <c>WM_COPYDATA</c> message. Important, pass unchanged.</param>
		/// <returns>Your window procedure must return this value.</returns>
		public static unsafe int Return(void* data, int length, nint wParam) {
			var sm = SharedMemory_.ReturnDataPtr;

			//use shared memory of this library. Max 1 MB.
			if (length <= SharedMemory_.ReturnDataSize) {
				MemoryUtil.Copy(data, sm, length);
				return length;
			}

			//allocate memory in caller process
			using var pm = new ProcessMemory((int)wParam, length, noException: true);
			if (pm.ProcessHandle != default) { //fails if that process has higher UAC IL. Rare.
				pm.Write(data, length);
				*(long*)sm = (long)pm.Mem;
				pm.MemAllocated = default;
				return -length;
			}

			//allocate new shared memory
			try {
				var smname = "Au-memory-" + Guid.NewGuid().ToString();
				fixed (char* p = smname) MemoryUtil.Copy(p, sm, smname.Length * 2 + 2);
				var m2 = SharedMemory_.Mapping.CreateOrOpen(smname, length);
				MemoryUtil.Copy(data, m2.Mem, length);
				Task.Run(() => { //wait until caller returns and then close the shared memory in this process
					var mutex = s_mutex.Value;
					if (Api.WaitForSingleObject(mutex, -1) is not (0 or Api.WAIT_ABANDONED_0)) { Debug_.Print("WaitForSingleObject"); return; }
					Api.ReleaseMutex(mutex);
					m2.Dispose();
				});
				return length;
			}
			catch { return 0; }

			//speed when size 1 MB and hot CPU:
			//	shared memory: 1000 mcs
			//	process memory: 1500 mcs
			//	shared memory 2: 2500 mcs
		}

		/// <summary>
		/// Returns string or other data to <see cref="SendReceive"/>.
		/// </summary>
		/// <typeparam name="T">Type of data elements. For example, <c>char</c> for string, <c>byte</c> for <c>byte[]</c></typeparam>
		/// <param name="data"></param>
		/// <param name="wParam"><i>wParam</i> of the received <c>WM_COPYDATA</c> message. Important, pass unchanged.</param>
		/// <returns>Your window procedure must return this value.</returns>
		public static unsafe int Return<T>(ReadOnlySpan<T> data, nint wParam) where T : unmanaged {
			fixed (T* f = data) return Return(f, data.Length * sizeof(T), wParam);
		}

		//rejected. Don't need too many not important overloads. Good: in most cases data size is 2 times smaller. Same: speed.
		//[SkipLocalsInit]
		//public static unsafe int ReturnStringUtf8_(RStr data, nint wParam) {
		//	var e = Encoding.UTF8;
		//	using var b = new FastBuffer<byte>(e.GetByteCount(data));
		//	int len = e.GetBytes(data, new Span<byte>(b.p, b.n));
		//	return ReturnData_(b.p, len, wParam);
		//}

		#endregion
	}
}


================================================
FILE: Au/wnd/WndSavedRect.cs
================================================
//TODO3: it seems makes WPF window visible too early.
//TODO3: if window not resizable, restore only position, not size.

namespace Au.More;

/// <summary>
/// Helps to save and restore window rectangle and state. Ensures in screen, per-monitor-DPI-aware, etc.
/// </summary>
/// <example>
/// WPF window created with <see cref="wpfBuilder"/>.
/// <code><![CDATA[
/// const string c_rkey = @"HKEY_CURRENT_USER\Software\Au\Test", c_rvalue = @"Wpf7.Rect";
/// var b = new wpfBuilder("Window").WinSize(400).R.AddOkCancel().End();
/// 	
/// WndSavedRect.Restore(b.Window, Registry.GetValue(c_rkey, c_rvalue, null) as string, s1 => Registry.SetValue(c_rkey, c_rvalue, s1));
/// 
/// //the same
/// //b.WinSaved(Registry.GetValue(c_rkey, c_rvalue, null) as string, s1 => Registry.SetValue(c_rkey, c_rvalue, s1));
/// 
/// if (!b.ShowDialog()) return;
/// ]]></code>
/// </example>
public struct WndSavedRect {
	/// <summary>
	/// Window rectangle in normal state (not maximized/minimized), as retrieved by API <ms>GetWindowPlacement</ms>.
	/// </summary>
	public RECT RawRect { get => _r; set => _r = value; }
	RECT _r;

	/// <summary>
	/// <see cref="Dpi.OfWindow"/>.
	/// </summary>
	public int Dpi { get; set; }

	/// <summary>
	/// The window should be maximized.
	/// </summary>
	public bool Maximize { get; set; }

	/// <summary>
	/// <see cref="wnd.IsToolWindow"/>. If <c>false</c>, <see cref="RawRect"/> may have an offset that depends on work area.
	/// </summary>
	public bool IsToolWindow { get; set; }

	/// <summary>
	/// Converts this object to string for saving.
	/// The string is very simple, like <c>"1 2 3 4 5 6"</c>.
	/// </summary>
	public override string ToString() {
		return $"{_r.left} {_r.top} {_r.Width} {_r.Height} {Dpi} {(Maximize ? 1 : 0) | (IsToolWindow ? 2 : 0)}";
	}

	/// <summary>
	/// Creates <see cref="WndSavedRect"/> from string created by <see cref="ToString"/>.
	/// </summary>
	/// <returns><c>false</c> if the string is <c>null</c> or invalid.</returns>
	/// <param name="saved">String created by <see cref="ToString"/>.</param>
	/// <param name="x">Result.</param>
	public static bool FromString(string saved, out WndSavedRect x) {
		x = default;
		if (saved == null) return false;
		var a = new int[6];
		for (int i = 0, j = 0; i < a.Length; i++) if (!saved.ToInt(out a[i], j, out j)) return false;
		x._r = (a[0], a[1], a[2], a[3]);
		x.Dpi = a[4];
		var flags = a[5];
		x.Maximize = 0 != (flags & 1);
		x.IsToolWindow = 0 != (flags & 2);
		return true;
	}

	/// <summary>
	/// Gets window rectangle and state for saving. Usually called when closing the window.
	/// See also <see cref="ToString"/>.
	/// </summary>
	/// <exception cref="AuWndException">Failed to get rectangle, probably invalid window handle.</exception>
	public WndSavedRect(wnd w) {
		if (!w.GetWindowPlacement_(out var p, false)) w.ThrowUseNative();
		_r = p.rcNormalPosition;
		Dpi = More.Dpi.OfWindow(w);
		Maximize = p.showCmd == Api.SW_SHOWMAXIMIZED || (p.showCmd == Api.SW_SHOWMINIMIZED && 0 != (p.flags & Api.WPF_RESTORETOMAXIMIZED));
		IsToolWindow = w.IsToolWindow;
	}

	/// <summary>
	/// Gets window rectangle and state for saving. Usually called when closing the window.
	/// See also <see cref="ToString"/>.
	/// </summary>
	/// <exception cref="AuWndException">Failed to get rectangle, probably invalid window handle.</exception>
	public WndSavedRect(System.Windows.Window w) : this(w.Hwnd()) { }

	/// <summary>
	/// Gets window rectangle and state for saving. Usually called when closing the window.
	/// See also <see cref="ToString"/>.
	/// </summary>
	/// <exception cref="AuWndException">Failed to get rectangle, probably invalid window handle.</exception>
	public WndSavedRect(System.Windows.Forms.Form form) : this(form.Hwnd()) { }

	/// <summary>
	/// Gets real rectangle for restoring saved window rectangle.
	/// </summary>
	/// <remarks>
	/// It is recommended to call this before creating window, and create window with the returned rectangle. Also set maximized state if <see cref="Maximize"/>.
	/// If it is not possible, can be called later, for example when window is created but still invisible. However then possible various problems, for example may need to set window rectangle two times, because the window may be for example DPI-scaled when moving to another screen etc.
	/// 
	/// This function ensures the window is in screen, ensures correct size when screen DPI changed, etc.
	/// </remarks>
	public RECT NormalizeRect() {
		var r = _r;
		var scr = screen.of(r);
		int dpi = scr.Dpi;
		if (dpi != this.Dpi) {
			r.Width = Math2.MulDiv(r.Width, dpi, this.Dpi);
			r.Height = Math2.MulDiv(r.Height, dpi, this.Dpi);
			//don't change xy. Anyway we cannot cover all cases, eg changed DPI of another screen that could affect xy of the window in this screen.
		}
		if (!IsToolWindow) {
			var v = scr.Info;
			r.Offset(v.workArea.left - v.rect.left, v.workArea.top - v.rect.top);
		}
		r.EnsureInScreen(scr, workArea: !IsToolWindow); //TODO3: use simple rect adjust. Or add EnsureInRect.
		return r;
	}

	/// <summary>
	/// Calls <see cref="FromString"/>. If it returns <c>true</c>, calls <see cref="NormalizeRect"/>, <see cref="ExtWpf.SetRect"/>, maximizes if need and returns <c>true</c>.
	/// Call this function before showing window.
	/// </summary>
	/// <param name="w"></param>
	/// <param name="saved">String created by <see cref="ToString"/>.</param>
	/// <param name="save">If not <c>null</c>, called when closing the window. Receives string for saving. Can save it in registry, file, anywhere.</param>
	/// <exception cref="InvalidOperationException">Window is loaded.</exception>
	public static bool Restore(System.Windows.Window w, string saved, Action<string> save = null) {
		if (w.IsLoaded) throw new InvalidOperationException("Window is loaded.");
		bool ret = FromString(saved, out var v);
		if (ret) {
			var r = v.NormalizeRect();
			if (v.Maximize) w.WindowState = System.Windows.WindowState.Maximized;
			w.SetRect(r);
		}
		if (save != null) {
			w.Closing += (_, _) => {
				if (w.IsLoaded) save(new WndSavedRect(w).ToString());
			};
		}
		return ret;
	}

	/// <summary>
	/// Calls <see cref="FromString"/>. If it returns <c>true</c>, sets <i>form</i> bounds = <see cref="NormalizeRect"/>, maximizes if need, sets <c>StartPosition</c> = <c>Manual</c>, and returns <c>true</c>.
	/// Call this function before showing window.
	/// </summary>
	/// <param name="form"></param>
	/// <param name="saved">String created by <see cref="ToString"/>.</param>
	/// <param name="save">If not <c>null</c>, called when closing the window. Receives string for saving. Can save it in registry, file, anywhere.</param>
	public static bool Restore(System.Windows.Forms.Form form, string saved, Action<string> save = null) {
		bool ret = FromString(saved, out var v);
		if (ret) {
			form.StartPosition = System.Windows.Forms.FormStartPosition.Manual;
			form.Bounds = v.NormalizeRect();
			if (v.Maximize) form.WindowState = System.Windows.Forms.FormWindowState.Maximized;
		}
		if (save != null) {
			form.FormClosing += (_, _) => {
				if (form.IsHandleCreated) save(new WndSavedRect(form).ToString());
			};
		}
		return ret;
	}

	//probably not useful. Unfinished. Or move to wnd.
	///// <summary>
	///// Calls <see cref="FromString"/>. If it returns <c>true</c>, sets <i>w</i> rectangle = <see cref="NormalizeRect"/>, maximizes if need, and returns <c>true</c>.
	///// </summary>
	///// <param name="w"></param>
	///// <param name="saved">String created by <see cref="ToString"/>.</param>
	///// <param name="allStates">If need to maximize and the window already is maximized, set the restored window rectangle too.</param>
	//public static unsafe bool Restore(wnd w, string saved, bool allStates = false) {
	//	w.ThrowIfInvalid();
	//	bool ret = FromString(saved, out var v);
	//	if (ret) {
	//		//var p = new Api.WINDOWPLACEMENT {
	//		//	rcNormalPosition = v.NormalizeRect(),
	//		//	showCmd = v.Maximize ? Api.SW_SHOWMAXIMIZED : Api.SW_RESTORE
	//		//};
	//		//w.SetWindowPlacement_(ref p, false, "Failed to restore window position");

	//		if (!allStates && v.Maximize && w.IsMaximized) return true;
	//		if (w.IsMaximized) w.ShowNotMinMax(true);
	//		if(!w.MoveL(v.NormalizeRect())) w.ThrowUseNative("Failed to restore window position");
	//		if (v.Maximize) w.ShowMaximized(true);
	//	}
	//	return ret;
	//}
}


================================================
FILE: Au/wnd/WndUtil.cs
================================================
namespace Au.More {
	/// <summary>
	/// Miscellaneous window-related functions. Rarely used in automation scripts.
	/// </summary>
	public static class WndUtil {
		//public void ShowAnimate(bool show)
		//{
		//	//Don't add wnd function, because:
		//		//Rarely used.
		//		//Api.AnimateWindow() works only with windows of current thread.
		//		//Only programmers would need it, and they can call the API directly.
		//}

		/// <summary>
		/// Registers new window class in this process.
		/// </summary>
		/// <param name="className">Class name.</param>
		/// <param name="wndProc">
		/// Delegate of a window procedure. See <ms>Window Procedures</ms>.
		/// 
		/// Use <c>null</c> when you need a different delegate (method or target object) for each window instance; create windows with <see cref="CreateWindow(WNDPROC, bool, string, string, WS, WSE, int, int, int, int, wnd, nint, IntPtr, nint)"/> or <see cref="CreateMessageOnlyWindow(WNDPROC, string, string)"/>.
		/// If not <c>null</c>, it must be a static named method; create windows with any other function, including API <ms>CreateWindowEx</ms>.
		/// </param>
		/// <param name="etc">
		/// Can be used to specify API <ms>WNDCLASSEX</ms> fields.
		/// To set cursor use field <c>mCursor</c> (standard cursor) or <c>hCursor</c> (native handle of a custom cursor).
		/// If <c>null</c>, this function sets arrow cursor and style <c>CS_VREDRAW | CS_HREDRAW</c>.
		/// </param>
		/// <exception cref="ArgumentException"><i>wndProc</i> is an instance method. Must be static method or <c>null</c>. If need instance method, use <c>null</c> here and pass <i>wndProc</i> to <see cref="CreateWindow"/>.</exception>
		/// <exception cref="InvalidOperationException">The class already registered with this function and different <i>wndProc</i> (another method or another target object).</exception>
		/// <exception cref="Win32Exception">Failed, for example if the class already exists and was registered not with this function.</exception>
		/// <remarks>
		/// Calls API <ms>RegisterClassEx</ms>.
		/// The window class is registered until this process ends. Don't need to unregister.
		/// If called next time for the same window class, does nothing if <i>wndProc</i> is equal to the previous (or both <c>null</c>). Then ignores <i>etc</i>. Throws exception if different.
		/// Thread-safe.
		/// Protects the <i>wndProc</i> delegate from GC.
		/// </remarks>
		public static unsafe void RegisterWindowClass(string className, WNDPROC wndProc = null, RWCEtc etc = null) {
			if (wndProc?.Target != null) throw new ArgumentException("wndProc must be static method or null");
			//never mind: Target of static lambda != null. Could use code `&& !wndProc.Target.GetType().FullName.Ends("+<>c")`, but it's undocumented and may stop working in new .NET version.

			lock (s_classes) {
				if (s_classes.TryGetValue(className, out var wpPrev)) {
					if (wpPrev != wndProc) throw new InvalidOperationException("Window class already registered"); //another method or another target object
					return;
				}
				var x = new Api.WNDCLASSEX(etc);

				fixed (char* pCN = className) {
					x.lpszClassName = pCN;
					if (wndProc != null) {
						x.lpfnWndProc = Marshal.GetFunctionPointerForDelegate(wndProc);
					} else {
						x.lpfnWndProc = s_cwProcFP;
					}
					x.style |= Api.CS_GLOBALCLASS;

					if (0 == Api.RegisterClassEx(x)) throw new Win32Exception();
					//note: we don't return atom because: 1. Rarely used. 2. If assigned to an unused field, compiler may remove the function call.

					s_classes.Add(className, wndProc);
				}
			}
		}

		internal static bool IsClassRegistered_(string name, out WNDPROC wndProc) {
			lock (s_classes) {
				return s_classes.TryGetValue(name, out wndProc);
			}
		}

		static Dictionary<string, WNDPROC> s_classes = new(StringComparer.OrdinalIgnoreCase); //allows to find registered classes and protects their wndProc delegates from GC
		[ThreadStatic] static Dictionary<wnd, WNDPROC> t_windows; //allows to dispatch messages and protects wndProc delegates of windows created in this thread from GC

		static nint _CWProc(wnd w, int msg, nint wParam, nint lParam) {
			//PrintMsg(w, msg, wParam, lParam);
			if (t_cwUnsafe) {
				t_cwUnsafe = false;
				var wndProc = t_cwProc;
				t_cwProc = null;
				Api.SetWindowLongPtr(w, GWL.WNDPROC, Marshal.GetFunctionPointerForDelegate(wndProc));
				//print.it("subclassed", w);
				return wndProc(w, msg, wParam, lParam);
			} else {
				var a = t_windows;
				if (a == null || !a.TryGetValue(w, out var wndProc)) {
					wndProc = t_cwProc;
					if (wndProc == null) {
						//print.it("DefWindowProc", w);
						return Api.DefWindowProc(w, msg, wParam, lParam); //creating not with our CreateWindow(wndProc, ...)
					}
					a[w] = wndProc;
					//print.it("added", a.Count, w);
					t_cwProc = null;
				}

				var R = wndProc(w, msg, wParam, lParam);

				if (msg == Api.WM_NCDESTROY) {
					a.Remove(w);
					//print.it("removed", a.Count, w);
				}

				return R;
			}
		}
		static WNDPROC s_cwProc; //GC
		static IntPtr s_cwProcFP = Marshal.GetFunctionPointerForDelegate(s_cwProc = _CWProc);
		[ThreadStatic] static WNDPROC t_cwProc;
		[ThreadStatic] static bool t_cwUnsafe;

		/// <summary>
		/// Creates native/unmanaged window (API <ms>CreateWindowEx</ms>) and sets its window procedure.
		/// </summary>
		/// <param name="wndProc">Window procedure.</param>
		/// <param name="keepAlive">
		/// Protect <i>wndProc</i> from GC (garbage collector) until the window is destroyed (message <ms>WM_NCDESTROY</ms> received or thread ended).
		/// <para>IMPORTANT: In some cases it may prevent destroying the window until thread ends, and it can be a big memory leak. For example WPF then does not destroy <c>HwndHost</c>-ed controls. Then let <i>keepAlive</i>=<c>false</c> and manually manage <i>wndProc</i> lifetime, for example keep it as a field of the wrapper class.</para>
		/// </param>
		/// <exception cref="AuException">Failed to create window. Unlikely.</exception>
		/// <remarks>
		/// If the class was registered with <see cref="RegisterWindowClass"/> with <c>null</c> <i>wndProc</i>, the <i>wndProc</i> function will receive all messages. Else will not receive messages sent before <c>CreateWindowEx</c> returns (<c>WM_CREATE</c> etc).
		/// 
		/// To destroy the window can be used any function, including API <ms>DestroyWindow</ms>, <see cref="DestroyWindow"/>, <see cref="wnd.Close"/>, API <ms>WM_CLOSE</ms>.
		/// </remarks>
		public static wnd CreateWindow(WNDPROC wndProc, bool keepAlive, string className, string name = null, WS style = 0, WSE exStyle = 0, int x = 0, int y = 0, int width = 0, int height = 0, wnd parent = default, nint controlId = 0, IntPtr hInstance = default, nint param = 0) {
			Not_.Null(wndProc, className);

			t_windows ??= new();
			wnd w;
			if (IsClassRegistered_(className, out var wp) && wp == null) {
				//if keepAlive, need to cubclass the new window, else add hwnd+wndProc to t_windows.
				//	But not after CreateWindowEx, because wndProc must receive all messages.
				//	Let _CWProc do it on first message.
				t_cwProc = wndProc;
				t_cwUnsafe = !keepAlive;
				try { w = Api.CreateWindowEx(exStyle, className, name, style, x, y, width, height, parent, controlId, hInstance, param); }
				finally { t_cwProc = null; t_cwUnsafe = false; } //if CreateWindowEx failed and _CWProc not called
				if (w.Is0) throw new AuException(0);
			} else {
				w = Api.CreateWindowEx(exStyle, className, name, style, x, y, width, height, parent, controlId, hInstance, param);
				if (w.Is0) throw new AuException(0);
				if (keepAlive) {
					t_windows[w] = wndProc;
					Api.SetWindowLongPtr(w, GWL.WNDPROC, s_cwProcFP);
				} else {
					Api.SetWindowLongPtr(w, GWL.WNDPROC, Marshal.GetFunctionPointerForDelegate(wndProc));
				}
			}

			return w;
		}

		/// <summary>
		/// Creates native/unmanaged window.
		/// </summary>
		/// <exception cref="AuException">Failed to create window. Unlikely.</exception>
		/// <remarks>
		/// Calls API <ms>CreateWindowEx</ms>.
		/// To destroy the window can be used any function, including API <ms>DestroyWindow</ms>, <see cref="DestroyWindow"/>, <see cref="wnd.Close"/>, API <ms>WM_CLOSE</ms>.
		/// </remarks>
		/// <seealso cref="RegisterWindowClass"/>
		public static wnd CreateWindow(string className, string name = null, WS style = 0, WSE exStyle = 0, int x = 0, int y = 0, int width = 0, int height = 0, wnd parent = default, nint controlId = 0, IntPtr hInstance = default, nint param = 0) {
			var w = Api.CreateWindowEx(exStyle, className, name, style, x, y, width, height, parent, controlId, hInstance, param);
			if (w.Is0) throw new AuException(0);
			return w;
		}

		/// <summary>
		/// Creates native/unmanaged <ms>message-only window</ms>.
		/// </summary>
		/// <param name="className">Window class name. Can be any existing class.</param>
		/// <param name="name">Window name or <c>null</c>.</param>
		/// <exception cref="AuException">Failed to create window. Unlikely.</exception>
		/// <remarks>
		/// Styles: <ms>WS_POPUP</ms>, <c>WS_EX_NOACTIVATE</c>.
		/// To destroy the window can be used any function, including API <ms>DestroyWindow</ms>, <see cref="DestroyWindow"/>, <see cref="wnd.Close"/>, API <ms>WM_CLOSE</ms>.
		/// </remarks>
		public static wnd CreateMessageOnlyWindow(string className, string name = null) {
			return CreateWindow(className, name, WS.POPUP, WSE.NOACTIVATE, parent: SpecHWND.MESSAGE);
			//note: WS_EX_NOACTIVATE is important.
		}

		/// <summary>
		/// Creates native/unmanaged <ms>message-only window</ms> and sets its window procedure.
		/// </summary>
		/// <param name="wndProc"></param>
		/// <param name="className">Window class name.</param>
		/// <param name="name">Window name or <c>null</c>.</param>
		/// <exception cref="AuException">Failed to create window. Unlikely.</exception>
		/// <remarks>
		/// Styles: <ms>WS_POPUP</ms>, <c>WS_EX_NOACTIVATE</c>.
		/// Calls <see cref="CreateWindow(WNDPROC, bool, string, string, WS, WSE, int, int, int, int, wnd, nint, IntPtr, nint)"/> with <i>keepAlive</i>=<c>true</c>.
		/// </remarks>
		public static wnd CreateMessageOnlyWindow(WNDPROC wndProc, string className, string name = null) {
			return CreateWindow(wndProc, true, className, name, WS.POPUP, WSE.NOACTIVATE, parent: SpecHWND.MESSAGE);
			//note: WS_EX_NOACTIVATE is important.
		}

		/// <summary>
		/// Auto-registers window class <c>"Au.DWP"</c> with <c>wndproc = DefWindowProc</c> and creates hidden window.
		/// </summary>
		/// <param name="messageOnly"></param>
		/// <param name="wndProcUnsafe">If not <c>null</c>, replaces window procedure (<c>SetWindowLongPtr</c>). The caller must protect the delegate from GC.</param>
		/// <exception cref="AuException">Failed to create window. Unlikely.</exception>
		internal static wnd CreateWindowDWP_(bool messageOnly, WNDPROC wndProcUnsafe = null) {
			var cn = WindowClassDWP_;
			var w = messageOnly ? CreateMessageOnlyWindow(cn) : CreateWindow(cn);
			if (wndProcUnsafe != null) Api.SetWindowLongPtr(w, GWL.WNDPROC, Marshal.GetFunctionPointerForDelegate(wndProcUnsafe));
			return w;
		}
		static int s_registeredDWP;
		const string c_wndClassDWP = "Au.DWP";

		/// <summary>
		/// Auto-registers window class <c>"Au.DWP"</c> with <c>wndproc = DefWindowProc</c> and returns <c>"Au.DWP"</c>.
		/// </summary>
		internal static unsafe string WindowClassDWP_ {
			get {
				if (0 == Interlocked.CompareExchange(ref s_registeredDWP, 1, 0)) {
					var x = new Api.WNDCLASSEX { cbSize = sizeof(Api.WNDCLASSEX), style = Api.CS_GLOBALCLASS };
					fixed (char* pCN = c_wndClassDWP) {
						x.lpszClassName = pCN;
						x.lpfnWndProc = Api.GetProcAddress("user32.dll", "DefWindowProcW");
						if (0 == Api.RegisterClassEx(x)) throw new Win32Exception();
					}
				}
				return c_wndClassDWP;
			}
		}

		/// <summary>
		/// Replaces window procedure (<c>SetWindowLongPtr</c>). Returns previous window procedure.
		/// The caller must protect the delegate from GC.
		/// </summary>
		internal static IntPtr SubclassUnsafe_(wnd w, WNDPROC wndProc) {
			return Api.SetWindowLongPtr(w, GWL.WNDPROC, Marshal.GetFunctionPointerForDelegate(wndProc));
		}

		/// <summary>
		/// Destroys a native window of this thread.
		/// Calls API <ms>DestroyWindow</ms>.
		/// </summary>
		/// <returns><c>false</c> if failed. Supports <see cref="lastError"/>.</returns>
		/// <seealso cref="wnd.Close"/>
		public static bool DestroyWindow(wnd w) {
			return Api.DestroyWindow(w);
		}

		/// <summary>
		/// Sets font.
		/// </summary>
		/// <param name="w"></param>
		/// <param name="font">
		/// Native font handle.
		/// If <c>default(IntPtr)</c>, sets font that is used by most windows and controls on this computer, usually <c>Segoe UI</c> 9, DPI-scaled for <i>w</i> screen.
		/// </param>
		/// <remarks>
		/// Sends <ms>WM_SETFONT</ms> message.
		/// </remarks>
		public static void SetFont(wnd w, IntPtr font = default) {
			w.Send(Api.WM_SETFONT, font != default ? font : NativeFont_.RegularCached(Dpi.OfWindow(w)).Handle);
		}

		//rejected. Rarely used. Easy to send message.
		///// <summary>
		///// Gets native font handle.
		///// Sends message API <ms>WM_GETFONT</ms>.
		///// Does not copy the font; don't need to dispose.
		///// Use this function only with windows of current process.
		///// </summary>
		//public static IntPtr GetFont(wnd w)
		//{
		//	return w.Send(Api.WM_GETFONT);
		//}

		/// <summary>
		/// Gets window Windows Store app user model id, like <c>"Microsoft.WindowsCalculator_8wekyb3d8bbwe!App"</c>.
		/// </summary>
		/// <returns><c>null</c> if failed. On Windows 7 returns <c>null</c> unless <i>getExePathIfNotWinStoreApp</i> <c>true</c>.</returns>
		/// <param name="w">A top-level window.</param>
		/// <param name="prependShellAppsFolder">Prepend <c>@"shell:AppsFolder\"</c> (to run or get icon).</param>
		/// <param name="getExePathIfNotWinStoreApp">Get program path if it is not a Windows Store app.</param>
		/// <remarks>
		/// Most Windows Store app windows have class name <c>"Windows.UI.Core.CoreWindow"</c> or <c>"ApplicationFrameWindow"</c>.
		/// </remarks>
		public static unsafe string GetWindowsStoreAppId(wnd w, bool prependShellAppsFolder = false, bool getExePathIfNotWinStoreApp = false) {
			string appId = null;

			if (osVersion.minWin8) {
				var cn = w.ClassName;
				if (osVersion.minWin10 && cn == "ApplicationFrameWindow") {
					var w2 = w.ChildFast(null, "Windows.UI.Core.CoreWindow");
					if (!w2.Is0) {
						w = w2;
						cn = "Windows.UI.Core.CoreWindow";
					} else { //probably minimized. Very slow, ~20 times slower than GetApplicationUserModelId.
						if (0 == Api.SHGetPropertyStoreForWindow(w, Api.IID_IPropertyStore, out Api.IPropertyStore ps)) {
							if (0 == ps.GetValue(Api.PKEY_AppUserModel_ID, out var v)) {
								if (v.vt == Api.VARENUM.VT_LPWSTR) appId = Marshal.PtrToStringUni(v.value);
								v.Dispose();
							}
							Marshal.ReleaseComObject(ps);
						}
					}
				}

				//this code works with "Windows.UI.Core.CoreWindow" and WinUI 3 windows. Not with "ApplicationFrameWindow".
				if (appId == null) {
					using var p = Handle_.OpenProcess(w);
					if (!p.Is0) {
						int na = 1024; var b = stackalloc char[na];
						if (0 == Api.GetApplicationUserModelId(p, ref na, b) && na > 1) appId = new(b, 0, na - 1);
					}
				}

				if (appId != null) {
					if (cn is not ("Windows.UI.Core.CoreWindow" or "ApplicationFrameWindow")) { //is it really a Store window?
						var s = w.ProgramPath;
						if (s != null && !s.Starts(folders.ProgramFiles + @"WindowsApps\", true)) {
							Debug_.Print(s);
							return getExePathIfNotWinStoreApp ? s : null;
						}
					}
					if (prependShellAppsFolder) appId = @"shell:AppsFolder\" + appId;
					return appId;
				}
			}

			return getExePathIfNotWinStoreApp ? w.ProgramPath : null;
		}

		/// <summary>
		/// Calls API <ms>GetClassLongPtr</ms>.
		/// </summary>
		/// <remarks>
		/// Supports <see cref="lastError"/>.
		/// For <i>index</i> can be used constants from <see cref="GCL"/>. All values are the same in 32-bit and 64-bit process.
		/// In 32-bit process actually calls <c>GetClassLong</c>, because <c>GetClassLongPtr</c> is unavailable.
		/// </remarks>
		public static nint GetClassLong(wnd w, int index) => Api.GetClassLongPtr(w, index);

		/// <summary>
		/// Changes the owner window.
		/// </summary>
		/// <returns>If fails, returns <c>false</c>; supports <see cref="lastError"/>.</returns>
		/// <remarks>
		/// A window that has an owner window is always on top of it.
		/// Don't call this for controls, they don't have an owner window.
		/// Fails for example if the owner's process has higher [](xref:uac) integrity level or is a Store app.
		/// </remarks>
		/// <seealso cref="wnd.getwnd.Owner"/>
		public static bool SetOwnerWindow(wnd w, wnd owner) {
			Api.SetWindowLongPtr(w, GWL.HWNDPARENT, (nint)owner);
			if (w.Get.Owner != owner) return false;
			if (!owner.Is0) {
				bool tm = owner.IsTopmost;
				if (tm != w.IsTopmost) { if (tm) w.ZorderTopmost(); else w.ZorderNoTopmost(); }
				if (!w.ZorderIsAbove(owner)) w.ZorderAbove(owner);
			}
			return true;
		}

		//probably not useful. Dangerous.
		///// <summary>
		///// Calls API <ms>SetClassLongPtr</ms> (<c>SetClassLong</c> in 32-bit process).
		///// </summary>
		///// <exception cref="AuWndException"/>
		//public static nint SetClassLong(wnd w, int index, nint newValue)
		//{
		//	lastError.clear();
		//	nint R = Api.SetClassLongPtr(w, index, newValue);
		//	if(R == 0 && lastError.code != 0) w.ThrowUseNative();
		//	return R;
		//}

		//rejected. Does not work with many windows. Unreliable. Rarely used.
		///// <summary>
		///// Gets atom of a window class.
		///// To get class atom when you have a window <i>w</i>, use <c>WndUtil.GetClassLong(w, GCL.ATOM)</c>.
		///// </summary>
		///// <param name="className">Class name.</param>
		///// <param name="moduleHandle">Native module handle of the exe or dll that registered the class. Don't use if it is a global class (<c>CS_GLOBALCLASS</c> style).</param>
		//public static ushort GetClassAtom(string className, IntPtr moduleHandle = default)
		//{
		//	var x = new Api.WNDCLASSEX();
		//	x.cbSize = Api.SizeOf(x);
		//	return Api.GetClassInfoEx(moduleHandle, className, ref x);
		//}

		/// <summary>
		/// Calls API <ms>RegisterWindowMessage</ms>.
		/// </summary>
		/// <param name="name">Message name. Can be any unique string.</param>
		/// <param name="uacEnable">Also call API <ms>ChangeWindowMessageFilter</ms> for the message. More info: <see cref="UacEnableMessages"/>.</param>
		public static int RegisterMessage(string name, bool uacEnable = false) {
			var m = Api.RegisterWindowMessage(name);
			if (uacEnable && m != 0) Api.ChangeWindowMessageFilter(m, 1);
			return m;
		}

		/// <summary>
		/// Calls API <ms>ChangeWindowMessageFilter</ms> for each message in the list of messages.
		/// It allows processes of lower [](xref:uac) integrity level to send these messages to this process.
		/// </summary>
		public static void UacEnableMessages(params int[] messages) {
			foreach (var m in messages) Api.ChangeWindowMessageFilter(m, 1);
		}

		#region print msg

		/// <summary>
		/// Writes a Windows message to a string.
		/// If the message is specified in <i>options</i>, sets <c>s=null</c> and returns <c>false</c>.
		/// </summary>
		public static bool PrintMsg(out string s, wnd w, int msg, nint wParam, nint lParam, PrintMsgOptions options = null, [CallerMemberName] string m_ = null) {
			//Could instead use System.Windows.Forms.Message.ToString, but its list is incomplete, eg no dpichange messages.
			//	https://referencesource.microsoft.com/#System.Windows.Forms/winforms/Managed/System/WinForms/MessageDecoder.cs,b19021e2f4480d57

			if (options?.Skip is int[] a) {
				s = null;
				int prev = 0;
				foreach (var v in a) {
					if (v < 0) {
						if (msg >= prev && msg <= (v == int.MinValue ? int.MaxValue : -v)) return false;
						prev = int.MaxValue;
					} else {
						if (v == msg) return false;
						prev = v;
					}
				}
			}

			var (name, plus) = _Name(ref msg, out bool reflect);

			using (new StringBuilder_(out var b)) {
				if (options?.Number ?? true) {
					//uint counter = (uint)w.Prop["PrintMsg"]; w.Prop.Set("PrintMsg", ++counter);
					//b.Append(counter).Append(". ");
					b.Append(++s_pm_counter).Append(". ");
				}

				if (options?.Indent ?? true) { //makes ~10 times slower, but not too slow
					int i = 0;
					MethodBase m0 = null;
					foreach (var f in new StackTrace(1).GetFrames()) {
						var m1 = f.GetMethod();
						if (m1.Name != m_) continue;
						if (m0 == null) m0 = m1; else if ((object)m1 == m0) i += 4;
					}
					if (i > 0) b.Append(' ', i);
				}

				if (reflect) b.Append("WM_REFLECT+");
				if (name == null) b.AppendFormat("0x{0:X}", msg);
				else if (plus != 0) b.AppendFormat("{0}+0x{1:X}", name, plus);
				else if (msg >= 0xc000 && msg <= 0xffff) b.AppendFormat("\"{0}\"", name);
				else b.Append(name);

				b.AppendFormat(", 0x{0:X8}, 0x{1:X8}, hwnd={2}", (int)wParam, (int)lParam, w.Handle);
				if (options?.WindowProperties ?? false) {
					if (!w.Is0) b.AppendFormat(" ({0} \"{1}\" {{{2}}})", w.ClassName?.Limit(30), w.Name?.Limit(30), w.Rect.ToStringSimple());
				}

				s = b.ToString();
				return true;
			}

			static (string name, int plus) _Name(ref int m, out bool reflect) {
				reflect = false;
				if (m >= 0x10000) return default; //reserved by the system
				if (m >= 0xC000) return (ClipFormats.GetName(m, orNull: true), 0); //registered
				if (m >= Api.WM_APP) return ("WM_APP", m - Api.WM_APP); //0x8000
				if (reflect = m >= Api.WM_REFLECT && m < Api.WM_REFLECT * 2) m -= Api.WM_REFLECT; //0x2000
				if (m >= Api.WM_USER) return ("WM_USER", m - Api.WM_USER); //0x400
				#region switch
				var s = m switch {
					0x0 => "WM_NULL",
					0x1 => "WM_CREATE",
					0x2 => "WM_DESTROY",
					0x3 => "WM_MOVE",
					0x5 => "WM_SIZE",
					0x6 => "WM_ACTIVATE",
					0x7 => "WM_SETFOCUS",
					0x8 => "WM_KILLFOCUS",
					0xA => "WM_ENABLE",
					0xB => "WM_SETREDRAW",
					0xC => "WM_SETTEXT",
					0xD => "WM_GETTEXT",
					0xE => "WM_GETTEXTLENGTH",
					0xF => "WM_PAINT",
					0x10 => "WM_CLOSE",
					0x11 => "WM_QUERYENDSESSION",
					0x13 => "WM_QUERYOPEN",
					0x16 => "WM_ENDSESSION",
					0x12 => "WM_QUIT",
					0x14 => "WM_ERASEBKGND",
					0x15 => "WM_SYSCOLORCHANGE",
					0x18 => "WM_SHOWWINDOW",
					0x1A => "WM_SETTINGCHANGE",
					0x1B => "WM_DEVMODECHANGE",
					0x1C => "WM_ACTIVATEAPP",
					0x1D => "WM_FONTCHANGE",
					0x1E => "WM_TIMECHANGE",
					0x1F => "WM_CANCELMODE",
					0x20 => "WM_SETCURSOR",
					0x21 => "WM_MOUSEACTIVATE",
					0x22 => "WM_CHILDACTIVATE",
					0x23 => "WM_QUEUESYNC",
					0x24 => "WM_GETMINMAXINFO",
					0x26 => "WM_PAINTICON",
					0x27 => "WM_ICONERASEBKGND",
					0x28 => "WM_NEXTDLGCTL",
					0x2A => "WM_SPOOLERSTATUS",
					0x2B => "WM_DRAWITEM",
					0x2C => "WM_MEASUREITEM",
					0x2D => "WM_DELETEITEM",
					0x2E => "WM_VKEYTOITEM",
					0x2F => "WM_CHARTOITEM",
					0x30 => "WM_SETFONT",
					0x31 => "WM_GETFONT",
					0x32 => "WM_SETHOTKEY",
					0x33 => "WM_GETHOTKEY",
					0x37 => "WM_QUERYDRAGICON",
					0x39 => "WM_COMPAREITEM",
					0x3D => "WM_GETOBJECT",
					0x41 => "WM_COMPACTING",
					0x44 => "WM_COMMNOTIFY",
					0x46 => "WM_WINDOWPOSCHANGING",
					0x47 => "WM_WINDOWPOSCHANGED",
					0x48 => "WM_POWER",
					0x4A => "WM_COPYDATA",
					0x4B => "WM_CANCELJOURNAL",
					0x4E => "WM_NOTIFY",
					0x50 => "WM_INPUTLANGCHANGEREQUEST",
					0x51 => "WM_INPUTLANGCHANGE",
					0x52 => "WM_TCARD",
					0x53 => "WM_HELP",
					0x54 => "WM_USERCHANGED",
					0x55 => "WM_NOTIFYFORMAT",
					0x7B => "WM_CONTEXTMENU",
					0x7C => "WM_STYLECHANGING",
					0x7D => "WM_STYLECHANGED",
					0x7E => "WM_DISPLAYCHANGE",
					0x7F => "WM_GETICON",
					0x80 => "WM_SETICON",
					0x81 => "WM_NCCREATE",
					0x82 => "WM_NCDESTROY",
					0x83 => "WM_NCCALCSIZE",
					0x84 => "WM_NCHITTEST",
					0x85 => "WM_NCPAINT",
					0x86 => "WM_NCACTIVATE",
					0x87 => "WM_GETDLGCODE",
					0x88 => "WM_SYNCPAINT",
					0xA0 => "WM_NCMOUSEMOVE",
					0xA1 => "WM_NCLBUTTONDOWN",
					0xA2 => "WM_NCLBUTTONUP",
					0xA3 => "WM_NCLBUTTONDBLCLK",
					0xA4 => "WM_NCRBUTTONDOWN",
					0xA5 => "WM_NCRBUTTONUP",
					0xA6 => "WM_NCRBUTTONDBLCLK",
					0xA7 => "WM_NCMBUTTONDOWN",
					0xA8 => "WM_NCMBUTTONUP",
					0xA9 => "WM_NCMBUTTONDBLCLK",
					0xAB => "WM_NCXBUTTONDOWN",
					0xAC => "WM_NCXBUTTONUP",
					0xAD => "WM_NCXBUTTONDBLCLK",
					0xFE => "WM_INPUT_DEVICE_CHANGE",
					0xFF => "WM_INPUT",
					0x100 => "WM_KEYDOWN",
					0x101 => "WM_KEYUP",
					0x102 => "WM_CHAR",
					0x103 => "WM_DEADCHAR",
					0x104 => "WM_SYSKEYDOWN",
					0x105 => "WM_SYSKEYUP",
					0x106 => "WM_SYSCHAR",
					0x107 => "WM_SYSDEADCHAR",
					0x109 => "WM_UNICHAR",
					0x10D => "WM_IME_STARTCOMPOSITION",
					0x10E => "WM_IME_ENDCOMPOSITION",
					0x10F => "WM_IME_COMPOSITION",
					0x110 => "WM_INITDIALOG",
					0x111 => "WM_COMMAND",
					0x112 => "WM_SYSCOMMAND",
					0x113 => "WM_TIMER",
					0x114 => "WM_HSCROLL",
					0x115 => "WM_VSCROLL",
					0x116 => "WM_INITMENU",
					0x117 => "WM_INITMENUPOPUP",
					0x119 => "WM_GESTURE",
					0x11A => "WM_GESTURENOTIFY",
					0x11F => "WM_MENUSELECT",
					0x120 => "WM_MENUCHAR",
					0x121 => "WM_ENTERIDLE",
					0x122 => "WM_MENURBUTTONUP",
					0x123 => "WM_MENUDRAG",
					0x124 => "WM_MENUGETOBJECT",
					0x125 => "WM_UNINITMENUPOPUP",
					0x126 => "WM_MENUCOMMAND",
					0x127 => "WM_CHANGEUISTATE",
					0x128 => "WM_UPDATEUISTATE",
					0x129 => "WM_QUERYUISTATE",
					0x132 => "WM_CTLCOLORMSGBOX",
					0x133 => "WM_CTLCOLOREDIT",
					0x134 => "WM_CTLCOLORLISTBOX",
					0x135 => "WM_CTLCOLORBTN",
					0x136 => "WM_CTLCOLORDLG",
					0x137 => "WM_CTLCOLORSCROLLBAR",
					0x138 => "WM_CTLCOLORSTATIC",
					0x200 => "WM_MOUSEMOVE",
					0x201 => "WM_LBUTTONDOWN",
					0x202 => "WM_LBUTTONUP",
					0x203 => "WM_LBUTTONDBLCLK",
					0x204 => "WM_RBUTTONDOWN",
					0x205 => "WM_RBUTTONUP",
					0x206 => "WM_RBUTTONDBLCLK",
					0x207 => "WM_MBUTTONDOWN",
					0x208 => "WM_MBUTTONUP",
					0x209 => "WM_MBUTTONDBLCLK",
					0x20A => "WM_MOUSEWHEEL",
					0x20B => "WM_XBUTTONDOWN",
					0x20C => "WM_XBUTTONUP",
					0x20D => "WM_XBUTTONDBLCLK",
					0x20E => "WM_MOUSEHWHEEL",
					0x210 => "WM_PARENTNOTIFY",
					0x211 => "WM_ENTERMENULOOP",
					0x212 => "WM_EXITMENULOOP",
					0x213 => "WM_NEXTMENU",
					0x214 => "WM_SIZING",
					0x215 => "WM_CAPTURECHANGED",
					0x216 => "WM_MOVING",
					0x218 => "WM_POWERBROADCAST",
					0x219 => "WM_DEVICECHANGE",
					0x220 => "WM_MDICREATE",
					0x221 => "WM_MDIDESTROY",
					0x222 => "WM_MDIACTIVATE",
					0x223 => "WM_MDIRESTORE",
					0x224 => "WM_MDINEXT",
					0x225 => "WM_MDIMAXIMIZE",
					0x226 => "WM_MDITILE",
					0x227 => "WM_MDICASCADE",
					0x228 => "WM_MDIICONARRANGE",
					0x229 => "WM_MDIGETACTIVE",
					0x230 => "WM_MDISETMENU",
					0x231 => "WM_ENTERSIZEMOVE",
					0x232 => "WM_EXITSIZEMOVE",
					0x233 => "WM_DROPFILES",
					0x234 => "WM_MDIREFRESHMENU",
					0x238 => "WM_POINTERDEVICECHANGE",
					0x239 => "WM_POINTERDEVICEINRANGE",
					0x23A => "WM_POINTERDEVICEOUTOFRANGE",
					0x240 => "WM_TOUCH",
					0x241 => "WM_NCPOINTERUPDATE",
					0x242 => "WM_NCPOINTERDOWN",
					0x243 => "WM_NCPOINTERUP",
					0x245 => "WM_POINTERUPDATE",
					0x246 => "WM_POINTERDOWN",
					0x247 => "WM_POINTERUP",
					0x249 => "WM_POINTERENTER",
					0x24A => "WM_POINTERLEAVE",
					0x24B => "WM_POINTERACTIVATE",
					0x24C => "WM_POINTERCAPTURECHANGED",
					0x24D => "WM_TOUCHHITTESTING",
					0x24E => "WM_POINTERWHEEL",
					0x24F => "WM_POINTERHWHEEL",
					0x251 => "WM_POINTERROUTEDTO",
					0x252 => "WM_POINTERROUTEDAWAY",
					0x253 => "WM_POINTERROUTEDRELEASED",
					0x281 => "WM_IME_SETCONTEXT",
					0x282 => "WM_IME_NOTIFY",
					0x283 => "WM_IME_CONTROL",
					0x284 => "WM_IME_COMPOSITIONFULL",
					0x285 => "WM_IME_SELECT",
					0x286 => "WM_IME_CHAR",
					0x288 => "WM_IME_REQUEST",
					0x290 => "WM_IME_KEYDOWN",
					0x291 => "WM_IME_KEYUP",
					0x2A1 => "WM_MOUSEHOVER",
					0x2A3 => "WM_MOUSELEAVE",
					0x2A0 => "WM_NCMOUSEHOVER",
					0x2A2 => "WM_NCMOUSELEAVE",
					0x2B1 => "WM_WTSSESSION_CHANGE",
					0x2E0 => "WM_DPICHANGED",
					0x2E2 => "WM_DPICHANGED_BEFOREPARENT",
					0x2E3 => "WM_DPICHANGED_AFTERPARENT",
					0x2E4 => "WM_GETDPISCALEDSIZE",
					0x300 => "WM_CUT",
					0x301 => "WM_COPY",
					0x302 => "WM_PASTE",
					0x303 => "WM_CLEAR",
					0x304 => "WM_UNDO",
					0x305 => "WM_RENDERFORMAT",
					0x306 => "WM_RENDERALLFORMATS",
					0x307 => "WM_DESTROYCLIPBOARD",
					0x308 => "WM_DRAWCLIPBOARD",
					0x309 => "WM_PAINTCLIPBOARD",
					0x30A => "WM_VSCROLLCLIPBOARD",
					0x30B => "WM_SIZECLIPBOARD",
					0x30C => "WM_ASKCBFORMATNAME",
					0x30D => "WM_CHANGECBCHAIN",
					0x30E => "WM_HSCROLLCLIPBOARD",
					0x30F => "WM_QUERYNEWPALETTE",
					0x310 => "WM_PALETTEISCHANGING",
					0x311 => "WM_PALETTECHANGED",
					0x312 => "WM_HOTKEY",
					0x317 => "WM_PRINT",
					0x318 => "WM_PRINTCLIENT",
					0x319 => "WM_APPCOMMAND",
					0x31A => "WM_THEMECHANGED",
					0x31D => "WM_CLIPBOARDUPDATE",
					0x31E => "WM_DWMCOMPOSITIONCHANGED",
					0x31F => "WM_DWMNCRENDERINGCHANGED",
					0x320 => "WM_DWMCOLORIZATIONCOLORCHANGED",
					0x321 => "WM_DWMWINDOWMAXIMIZEDCHANGE",
					0x323 => "WM_DWMSENDICONICTHUMBNAIL",
					0x326 => "WM_DWMSENDICONICLIVEPREVIEWBITMAP",
					0x33F => "WM_GETTITLEBARINFOEX",
					0x8000 => "WM_APP",
					0x400 => "WM_USER",
					_ => null
				};
				#endregion
				return (s, 0);
			}
		}
		[ThreadStatic] static uint s_pm_counter;

#if !true //this script creates the switch { ... }
//var a=new List<string>();
print.clear();
var b = new StringBuilder("var s = m switch {\r\n");
var s1 = File.ReadAllText(@"C:\code\au\Au\Api\Api_const.cs");
foreach (var m in s1.RxFindAll(@"(?m)^\h*internal const int (WM_\w+) *= *(\w+);")) {
	var s = m[1].Value;
	if (s.Ends("FIRST") || s.Ends("LAST") || s.Starts("WM_PSD_") || s.Starts("WM_DDE_") || s.Starts("WM_CHOOSEFONT_") || s == "WM_WININICHANGE") {
		//print.it(s);
		continue;
	}
	//print.it(s, m[2]);
	//a.Add(s);
	b.AppendFormat("{0} => \"{1}\",\r\n", m[2].Value, s);
}
b.Append("_ => null};\r\nreturn (s, 0);");
//a.Sort();
//print.it(a);
var s2 = b.ToString();
print.it(s2);
#endif

		/// <summary>
		/// Writes a Windows message to the output, unless it is specified in <i>options</i>.
		/// </summary>
		public static void PrintMsg(wnd w, int msg, nint wParam, nint lParam, PrintMsgOptions options = null, [CallerMemberName] string m_ = null) {
			if (PrintMsg(out string s, w, msg, wParam, lParam, options, m_)) print.it(s);
		}

		/// <summary>
		/// Writes a Windows message to a string.
		/// If the message is specified in <i>options</i>, sets <c>s=null</c> and returns <c>false</c>.
		/// </summary>
		/// <remarks>
		/// The <i>m</i> parameter also accepts <see cref="System.Windows.Interop.MSG"/> (WPF) and <see cref="System.Windows.Forms.Message"/>.
		/// </remarks>
		public static bool PrintMsg(out string s, in MSG m, PrintMsgOptions options = null, [CallerMemberName] string m_ = null) {
			return PrintMsg(out s, m.hwnd, m.message, m.wParam, m.lParam, options, m_);
		}

		/// <summary>
		/// Writes a Windows message to the output, unless it is specified in <i>options</i>.
		/// </summary>
		/// <remarks>
		/// The <i>m</i> parameter also accepts <see cref="System.Windows.Interop.MSG"/> (WPF) and <see cref="System.Windows.Forms.Message"/>.
		/// </remarks>
		public static void PrintMsg(in MSG m, PrintMsgOptions options = null, [CallerMemberName] string m_ = null) {
			PrintMsg(m.hwnd, m.message, m.wParam, m.lParam, options, m_);
		}

		#endregion

		/// <summary>
		/// Simple non-OLE drag operation.
		/// </summary>
		/// <returns><c>true</c> if dropped, <c>false</c> if canceled.</returns>
		/// <param name="window">Window or control that owns the drag operation. Must be of this thread.</param>
		/// <param name="mouseButton">Mouse button that is used for the drag operation: <c>Left</c>, <c>Right</c>, <c>Middle</c>.</param>
		/// <param name="onMouseKeyMessage">Callback function, called on each received mouse/key message. Optional.</param>
		public static bool DragLoop(AnyWnd window, MButtons mouseButton = MButtons.Left, Action<WDLArgs> onMouseKeyMessage = null) {
			wnd w = window.Hwnd;
			Api.SetCapture(w);

			bool R = false;
			var x = new WDLArgs();
			for (; ; ) {
				if (Api.GetCapture() != w) return false;
				if (!Api.GetMessage(out x.msg)) {
					if (x.msg.message == Api.WM_QUIT) Api.PostQuitMessage((int)x.msg.wParam);
					break;
				}

				bool call = false;
				int m = x.msg.message;
				if (m >= Api.WM_MOUSEFIRST && m <= Api.WM_MOUSELAST) {
					if (m == Api.WM_LBUTTONUP) {
						if (R = mouseButton.Has(MButtons.Left)) break;
					} else if (m == Api.WM_RBUTTONUP) {
						if (R = mouseButton.Has(MButtons.Right)) break;
					} else if (m == Api.WM_MBUTTONUP) {
						if (R = mouseButton.Has(MButtons.Middle)) break;
					}
					call = true;
				} else if (m == Api.WM_KEYDOWN || m == Api.WM_KEYUP || m == Api.WM_SYSKEYDOWN || m == Api.WM_SYSKEYUP) {
					//on key down/up caller may want to update cursor when eg Ctrl pressed/released
					if (x.msg.wParam == (byte)KKey.Escape) break;
					call = true;
				}

				if (call && onMouseKeyMessage != null) {
					onMouseKeyMessage(x);
					if (x._stopped) break;
					if (x.cursor != default) {
						Api.SetCursor(x.cursor);
						x.cursor = default;
					}
				}

				Api.DispatchMessage(x.msg);
			}

			Api.ReleaseCapture();
			return R;
		}

		/// <summary>
		/// Waits while there is no active window.
		/// </summary>
		/// <param name="doEvents">While waiting call <see cref="wait.doEvents"/> to process Windows messages etc.</param>
		/// <remarks>
		/// When there is no active window, functions <see cref="wnd.active"/> and API <ms>GetForegroundWindow</ms> return 0.
		/// It sometimes happens after closing, minimizing or switching the active window, briefly until another window becomes active.
		/// This function waits max 500 ms, then returns <c>false</c> if there is no active window.
		/// Don't need to call this after calling functions of this library.
		/// </remarks>
		public static bool WaitForAnActiveWindow(bool doEvents = false) {
			for (int i = 0; ;) {
				if (doEvents) wait.doEvents();
				if (!wnd.active.Is0) return true;
				if (++i == 32) break;
				wait.ms(i);
			}
			return false;
			//Call WaitForAnActiveWindow(true) after showing a dialog API.
			//	In a thread that does not process messages, after closing a dialog may be not updated key states.
			//	Processing remaining unprocessed messages fixes it.
		}

		/// <summary>
		/// Temporarily enables this process to activate windows with API <ms>SetForegroundWindow</ms>.
		/// </summary>
		/// <returns><c>false</c> if failed.</returns>
		/// <param name="processId">Process id. If not 0, enables that process to activate windows too. If -1, all processes will be enabled.</param>
		/// <remarks>
		/// In some cases you may need this function because Windows often disables API <ms>SetForegroundWindow</ms> to not allow background applications to activate windows while the user is working (using keyboard/mouse) with the currently active window. Then <c>SetForegroundWindow</c> usually just makes the window's taskbar button flash.
		/// Usually you don't call <c>SetForegroundWindow</c> directly. It is called by some other functions.
		/// Don't need to call this function before calling <see cref="wnd.Activate"/> and other functions of this library that activate windows.
		/// </remarks>
		public static bool EnableActivate(int processId = 0) {
			if (!wnd.Internal_.EnableActivate(false)) return false;
			return processId == 0 || Api.AllowSetForegroundWindow(processId);
		}

		/// <summary>
		/// Calls API <ms>PostThreadMessage</ms>. 
		/// </summary>
		/// <returns><c>false</c> if failed. Supports <see cref="lastError"/>.</returns>
		public static bool PostThreadMessage(int threadId, int message, nint wParam = 0, nint lParam = 0) {
			return Api.PostThreadMessage(threadId, message, wParam, lParam);
		}

		/// <summary>
		/// Subclasses a window.
		/// </summary>
		/// <param name="w">A window or control of this thread.</param>
		/// <param name="proc">The new window procedure. It is called on every message received by the window (unless blocked by another subclass added later). Let it call <see cref="DefSubclassProc"/>, except when you want to block the message.</param>
		/// <returns>A cookie for <see cref="Unsubclass"/>. Returns <c>null</c> if failed.</returns>
		/// <remarks>
		/// Uses API <ms>SetWindowSubclass</ms>.
		/// Implicitly unsubclasses when the window is destroyed.
		/// Protects <i>proc</i> from GC for as long as need.
		/// </remarks>
		public static object Subclass(wnd w, WNDPROC proc) {
			Api.SUBCLASSPROC sp = null;
			if (!Api.SetWindowSubclass(w, sp = _WndProc, 1)) return null;
			(t_asp ??= new()).Add(sp);
			nint _WndProc(wnd w, int msg, nint wp, nint lp, nint idSubclass, nint refData) {
				var r = proc(w, msg, wp, lp);
				if (msg == Api.WM_NCDESTROY) if (Api.RemoveWindowSubclass(w, sp, 1)) t_asp.Remove(sp);
				return r;
			}
			return new _SubclassCookie(w, sp);
		}
		[ThreadStatic] static List<Api.SUBCLASSPROC> t_asp; //GC
		record class _SubclassCookie(wnd w, Api.SUBCLASSPROC sp);

		/// <summary>
		/// Unsubclasses window subclassed by <see cref="Subclass"/>.
		/// Unsubclassing is optional; the window is implicitly unsubclassed when closed.
		/// </summary>
		/// <param name="cookie">The return value of <see cref="Subclass"/>.</param>
		public static void Unsubclass(object cookie) {
			if (cookie == null) return;
			if (cookie is not _SubclassCookie c) throw new ArgumentException();
			if (Api.RemoveWindowSubclass(c.w, c.sp, 1) || !c.w.IsAlive) t_asp.Remove(c.sp);
		}

		/// <summary>
		/// Let your callback function used with <see cref="Subclass"/> call this function and return its return value. After or before processing the message.
		/// </summary>
		public static nint DefSubclassProc(wnd w, int msg, nint wp, nint lp)
			=> Api.DefSubclassProc(w, msg, wp, lp);
	}
}

namespace Au.Types {
	/// <summary>
	/// Options for <see cref="WndUtil.PrintMsg"/>.
	/// </summary>
	public class PrintMsgOptions {
		///
		public PrintMsgOptions() { }

		/// <summary>
		/// Sets <see cref="Skip"/>.
		/// </summary>
		public PrintMsgOptions(params int[] skip) { Skip = skip; }

		/// <summary>
		/// Prepend counter 1, 2, 3...
		/// Default <c>true</c>.
		/// </summary>
		public bool Number { get; set; } = true;

		/// <summary>
		/// Prepend one or more tabs if the caller function (usually a window procedure) is called recursively.
		/// Default <c>true</c>.
		/// </summary>
		public bool Indent { get; set; } = true;

		/// <summary>
		/// Ignore these messages.
		/// To specify a range of messages, use two array elements: first message and negative last message.
		/// </summary>
		public int[] Skip { get; set; }

		/// <summary>
		/// Append window classname, name and rectangle.
		/// </summary>
		public bool WindowProperties { get; set; }
	}

	/// <summary>
	/// <see cref="WndUtil.DragLoop"/> callback function arguments.
	/// </summary>
	public class WDLArgs {
		/// <summary>
		/// Current message retrieved by API <ms>GetMessage</ms>.
		/// API <ms>MSG</ms>.
		/// </summary>
		public MSG msg;

		/// <summary>
		/// Native cursor handle. The callback function can set this to temporarily set cursor.
		/// </summary>
		public IntPtr cursor;

		/// <summary>
		/// The callback function can call this to end the operation.
		/// </summary>
		public void Stop() { _stopped = true; }
		internal bool _stopped;
	}

	/// <summary>
	/// Used with <see cref="WndUtil.RegisterWindowClass"/>.
	/// </summary>
	public class RWCEtc {
#pragma warning disable 1591 //XML doc
		public uint style;
		public int cbClsExtra;
		public int cbWndExtra;
		public IntPtr hIcon;
		public IntPtr hCursor;
		public MCursor mCursor;
		public nint hbrBackground;
		public IntPtr hIconSm;
#pragma warning restore 1591 //XML doc
	}
}


================================================
FILE: Au/wnd/inactive/desktop.cs
================================================
//rejected.
//	Existing functions are rarely used and can be invoked with hotkeys, eg Win+D = Show Desktop, Win+Tab = Task View, Win+M = Minimize All, Win+Shift+M = Undo.
//	Maybe will be added in the future, when added more functions, eg for virtual desktops.
#if !true
namespace Au
{
	/// <summary>
	/// Arranges windows, shows/hides desktop. The same as the taskbar right-click menu commands.
	/// </summary>
	public static class desktop
	{
		/// <summary>
		/// Shows or hides desktop.
		/// If there are non-minimized main windows, minimizes them. Else restores windows recently minimized by this function.
		/// </summary>
		public static void toggleShowDesktop() => _Do(0);

		/// <summary>
		/// Minimizes main windows.
		/// </summary>
		public static void minimizeWindows() => _Do(1);

		/// <summary>
		/// Cascades non-minimized main windows.
		/// </summary>
		public static void cascadeWindows() => _Do(3);

		/// <summary>
		/// Arranges non-minimized main windows horizontally or vertically.
		/// </summary>
		public static void tileWindows(bool vertically) => _Do(vertically ? 5 : 4);

		/// <summary>
		/// Restores windows recently minimized, cascaded or tiled with other functions of this class.
		/// </summary>
		public static void undoMinimizeEtc() => _Do(2);

		/// <summary>
		/// Shows the Task View, aka Window Switcher.
		/// May not work on some Windows versions.
		/// </summary>
		public static void taskView() => _Do(6);

		static void _Do(int what) {
			try {
				dynamic shell = Activator.CreateInstance(Type.GetTypeFromProgID("Shell.Application")); //speed: faster than calling a method
				switch (what) {
				case 0: shell.ToggleDesktop(); break;
				case 1: shell.MinimizeAll(); break;
				case 2: shell.UndoMinimizeALL(); break;
				case 3: shell.CascadeWindows(); break;
				case 4: shell.TileHorizontally(); break;
				case 5: shell.TileVertically(); break;
				case 6: shell.WindowSwitcher(); break;
				}
				Marshal.ReleaseComObject(shell);

				//The COM object does not do exactly the same as the true Explorer commands.
				//Eg MinimizeAll does not activete desktop. Then a minimized window is active.
				if (what == 1 && wnd.active.IsMinimized && wnd.getwnd.desktop(out var wd, out _)) wd.ActivateL();
			}
			catch { }

			wnd.getwnd.shellWindow.MinimalSleepIfOtherThread_();
		}
	}

	//FUTURE: use IVirtualDesktopManager to manage virtual desktops.
	//Its MoveWindowToDesktop does not work with windows of other processes, but we can inject a dll into another process.
	//The inteface also has IsWindowOnCurrentVirtualDesktop and GetWindowDesktopId.
	//Also there are internal/undocumented interfaces to add/remove/switch desktops etc. There is a GitHub library. And another library that injects.
}
#endif


================================================
FILE: Au/wnd/wnd.cs
================================================
namespace Au;

/// <summary>
/// A variable of <c>wnd</c> type represents a window or control. It is a window handle, also known as <ms>HWND</ms>.
/// </summary>
/// <remarks>
/// <c>wnd</c> functions can be used with windows and controls of any process/thread. Also can be used with .NET form/control and WPF window class variables, like <c>wnd w=form.Hwnd(); w.Method(...);</c>.
/// 
/// There are two main types of windows - top-level windows and controls. Controls are child windows of top-level windows.
/// 
/// More window functions are in types named like <c>WndX</c>, in namespace <c>Au.More</c>. They are used mostly in programming, rarely in automation scripts.
/// 
/// What happens when a <c>wnd</c> member function fails:
/// - Functions that get window properties don't throw exceptions. They return <c>false</c>/0/<c>null</c>/empty. Most of them support <see cref="lastError"/>, and it is mentioned in function documentation.
/// - Many functions that change window properties throw exception. Exceptions are listed in function documentation. Almost all these functions throw only <see cref="AuWndException"/>.
/// - Other functions that change window properties return <c>false</c>. They are more often used in programming than in automation scripts.
/// - When a "find" function does not find the window or control, it returns <c>default(wnd)</c> (window handle 0). Then <see cref="Is0"/> will return <c>true</c>.
/// - If a function does not follow these rules, it is mentioned in function documentation.
/// 
/// Many functions fail if the window's process has a higher [](xref:uac) integrity level (administrator, uiAccess) than this process, unless this process has uiAccess level. Especially the functions that change window properties. Some functions that still work: <c>Activate</c>, <c>ActivateL</c>, <c>ShowMinimized</c>, <c>ShowNotMinimized</c>, <c>ShowNotMinMax</c>, <c>Close</c>.
/// 
/// The <c>wnd</c> type can be used with native Windows API functions without casting. Use <c>wnd</c> for the parameter type in the declaration, like <c>[DllImport(...)] static extern bool NativeFunction(wnd hWnd, ...)</c>.
/// 
/// See also: <ms>Window Features</ms>.
/// </remarks>
/// <example>
/// <code><![CDATA[
/// wnd w = wnd.find("* - Notepad");
/// if(w.Is0) { print.it("window not found"); return; }
/// w.Activate();
/// wnd c = w.Child(cn: "Button");
/// print.it(c.Name);
/// ]]></code>
/// </example>
public unsafe partial struct wnd : IEquatable<wnd>, IComparable<wnd> {
#if false
	/// <remarks>
	/// Why <c>wnd</c> is struct, not class:
	/// 	Advantages:
	/// 	- Lightweight. Same as <c>nint</c> (8 or 4 bytes).
	/// 	- Easier to create overloaded functions that have a window parameter. If it was a class, then a <c>null</c> argument could be ambiguous if eg could also be a string etc.
	/// 	- When a find-window function does not find the window, calling next function (without checking the return value) does not throw <c>null</c>-reference exception. Instead the function can throw a more specific exception or just return <c>false</c> etc.
	/// 	- The handle actually already is a reference (to a window object managed by the OS). We don't own the object; we usually don't need to destroy the window finally; it is more like a numeric window id.
	/// 	- Code where a window argument is <c>default(wnd)</c> is more clear. If it would be <c>null</c>, then it is unclear how the function interprets it: as a 0 handle or as "don't use it". Now if we want a "don't use it" behavior, we'll use an overload.
	/// 	- In my experience, it makes programming/scripting easier than if it would be a class. Because windows are not found so often (in automation scripts). A find-window function could throw a "not found" exception, but it is not good (it's easier to check the return value than to use try/catch or throwing/non-throwing overloads).
	/// 	- Probably it is not a "bad practice" to have a struct with many member functions, because eg the .NET <c>DateTime</c> is struct.
	/// 	
	/// 	Disadvantages:
	/// 	- Cannot be a base class of other classes. Workaround: Use it as a public field or property of the other class (or struct); in some cases it can be even better, because <c>wnd</c> has very many methods, and the non-inherited methods of that class would be difficult to find; now they are separated, and can be used like <c>x.NewClassMethod()</c> and <c>x.w.WndMethod()</c>; anyway, in most cases we'll need the new window classes only for the functions that they add, not for <c>wnd</c> functions, eg we would use a class <c>ButtonWnd</c> mostly only for button functions, not for general window functions.
	/// 	- In some cases C# does not allow to call a property-set function. <c>wnd</c> has few such functions, maybe none.
	/// 	
	/// </remarks>
	//note: don't use :IWin32Window, because it loads System.Windows.Forms.dll always when wnd used.
#endif
	
	readonly nint _h;
	
	#region constructors, operators, overrides
	
#pragma warning disable 1591 //XML doc
	public wnd(nint hwnd) { _h = hwnd; }
	
	//note: don't need implicit conversions. It creates more problems than is useful.
	
	public static explicit operator wnd(nint hwnd) => new(hwnd);
	public static explicit operator nint(wnd w) => w.Handle;
	public static explicit operator wnd(int hwnd) => new(hwnd);
	public static explicit operator int(wnd w) => (int)w._h;
	
	/// <summary>
	/// Converts from a special handle value.
	/// </summary>
	/// <param name="hwnd">See API <ms>SetWindowPos</ms>.</param>
	public static implicit operator wnd(SpecHWND hwnd) => new((int)hwnd);
	
	/// <summary>Compares window handles.</summary>
	public static bool operator ==(wnd w1, wnd w2) => w1._h == w2._h;
	
	/// <summary>Compares window handles.</summary>
	public static bool operator !=(wnd w1, wnd w2) => w1._h != w2._h;
	
	//Prevent accidental usage wnd==null. The C# compiler used to allow it without a warning; level-5 warning since C# 9. Bad: disables wnd==wnd?.
	//[Obsolete("Replace wnd==wnd? with wnd.Equals(wnd?). Replace wnd==null with wnd.Is0.", true), NoDoc]
	//public static bool operator ==(wnd w1, wnd? w2) => false;
	//[Obsolete("Replace wnd==wnd? with wnd.Equals(wnd?). Replace wnd==null with wnd.Is0.", true), NoDoc]
	//public static bool operator !=(wnd w1, wnd? w2) => true;
	//[Obsolete("Replace wnd==wnd? with wnd.Equals(wnd?). Replace wnd==null with wnd.Is0.", true), NoDoc]
	//public static bool operator ==(wnd? w1, wnd w2) => false;
	//[Obsolete("Replace wnd==wnd? with wnd.Equals(wnd?). Replace wnd==null with wnd.Is0.", true), NoDoc]
	//public static bool operator !=(wnd? w1, wnd w2) => true;
#pragma warning restore 1591 //XML doc
	
	/// <summary>
	/// Returns <c>true</c> if <c>w != null</c> and <c>w.Value == this</c>.
	/// </summary>
	public bool Equals(wnd? w) => w != null && w.GetValueOrDefault() == this;
	
	/// <summary>
	/// Returns <c>true</c> if <i>obj</i> is <see cref="wnd"/> and contains the same window handle.
	/// </summary>
	public override bool Equals(object obj) => obj is wnd w && this == w;
	
	/// <summary>
	/// Returns <c>true</c> if <c>other == this</c>.
	/// </summary>
	public bool Equals(wnd other) => other == this; //IEquatable<wnd>.Equals, to avoid boxing with eg Dictionary<wnd, T2>
	
	/// <summary>
	/// Implements <see cref="IComparable{T}"/>. It allows to sort a collection.
	/// </summary>
	public int CompareTo(wnd other) => _h.CompareTo(other);
	
	///
	public override int GetHashCode() => (int)_h;
	//window handles are always 32-bit int, although in a 64-bit process stored in 64-bit variables.
	
	/// <summary>
	/// Gets window handle as <c>IntPtr</c>.
	/// Code <c>w.Handle</c> is the same as <c>(IntPtr)w</c> .
	/// </summary>
	public IntPtr Handle => _h;
	
	/// <summary>
	/// Formats string <c>$"{handle}  {ClassName}  \"{Name}\"  {ProgramName}  {Rect}"</c>.
	/// </summary>
	public override string ToString() {
		if (Is0) return "0";
		var cn = ClassName;
		var sh = Handle.ToString();
		if (cn == null) return sh + " <invalid handle>";
		string s = Name;
		if (s != null) s = s.Escape(limit: 250);
		return $"{sh}  {cn}  \"{s}\"  {ProgramName}  {Rect.ToString()}";
	}
	
	#endregion
	
	#region send/post message
	
	/// <summary>
	/// Calls API <ms>SendMessage</ms>.
	/// </summary>
	/// <remarks>Supports <see cref="lastError"/>.</remarks>
	public nint Send(int message, nint wParam = 0, nint lParam = 0) {
		Debug_.PrintIf(Is0);
		return Api.SendMessage(this, message, wParam, lParam);
	}
	
	/// <summary>
	/// Calls API <ms>SendMessage</ms> where <i>lParam</i> is string.
	/// </summary>
	/// <remarks>Supports <see cref="lastError"/>.</remarks>
	public nint Send(int message, nint wParam, string lParam) {
		Debug_.PrintIf(Is0);
		fixed (char* p = lParam)
			return Api.SendMessage(this, message, wParam, (nint)p);
		//info: don't use overload, then eg ambiguous if null.
	}
	
	/// <summary>
	/// Calls API <ms>SendMessage</ms> where <i>lParam</i> is any pointer.
	/// </summary>
	/// <remarks>Supports <see cref="lastError"/>.</remarks>
	public nint Send(int message, nint wParam, void* lParam) {
		Debug_.PrintIf(Is0);
		return Api.SendMessage(this, message, wParam, (nint)lParam);
		//info: don't use overload, then eg ambiguous if null.
	}
	
	//rejected: overload without out result parameter. Confusing intellisense when bad types of other parameters. Not so often used, and not so hard to put ', out _'.
	///// <summary>
	///// Calls API <ms>SendMessageTimeout</ms>.
	///// Returns its return value (<c>false</c> if failed). Supports <see cref="lastError"/>.
	///// </summary>
	//public bool SendTimeout(int millisecondsTimeout, int message, nint wParam = 0, nint lParam = 0, SMTFlags flags = SMTFlags.ABORTIFHUNG) {
	//	Debug_.PrintIf(Is0);
	//	return 0 != Api.SendMessageTimeout(this, message, wParam, lParam, flags, millisecondsTimeout, out _);
	//}
	
	/// <summary>
	/// Calls/returns API <ms>SendMessageTimeout</ms> and gets the result of the message processing.
	/// </summary>
	/// <returns><c>false</c> if failed. Supports <see cref="lastError"/>.</returns>
	public bool SendTimeout(int millisecondsTimeout, out nint result, int message, nint wParam = 0, nint lParam = 0, SMTFlags flags = SMTFlags.ABORTIFHUNG) {
		Debug_.PrintIf(Is0);
		return 0 != Api.SendMessageTimeout(this, message, wParam, lParam, flags, millisecondsTimeout, out result);
	}
	
	/// <summary>
	/// Calls/returns API <ms>SendMessageTimeout</ms> where <i>lParam</i> is string.
	/// </summary>
	/// <returns><c>false</c> if failed. Supports <see cref="lastError"/>.</returns>
	public bool SendTimeout(int millisecondsTimeout, out nint result, int message, nint wParam, string lParam, SMTFlags flags = SMTFlags.ABORTIFHUNG) {
		Debug_.PrintIf(Is0);
		result = 0;
		fixed (char* p = lParam)
			return 0 != Api.SendMessageTimeout(this, message, wParam, (nint)p, flags, millisecondsTimeout, out result);
	}
	
	/// <summary>
	/// Calls/returns API <ms>SendMessageTimeout</ms> and gets the result of the message processing.
	/// </summary>
	/// <returns><c>false</c> if failed. Supports <see cref="lastError"/>.</returns>
	public bool SendTimeout(int millisecondsTimeout, out nint result, int message, nint wParam, void* lParam, SMTFlags flags = SMTFlags.ABORTIFHUNG) {
		Debug_.PrintIf(Is0);
		return 0 != Api.SendMessageTimeout(this, message, wParam, (nint)lParam, flags, millisecondsTimeout, out result);
	}
	
	/// <summary>
	/// Calls/returns API <ms>SendNotifyMessage</ms>.
	/// </summary>
	/// <returns><c>false</c> if failed. Supports <see cref="lastError"/>.</returns>
	public bool SendNotify(int message, nint wParam = 0, nint lParam = 0) {
		Debug_.PrintIf(Is0);
		return Api.SendNotifyMessage(this, message, wParam, lParam);
	}
	
	/// <summary>
	/// Calls/returns API <ms>PostMessage</ms>.
	/// </summary>
	/// <returns><c>false</c> if failed. Supports <see cref="lastError"/>.</returns>
	/// <seealso cref="WndUtil.PostThreadMessage"/>
	public bool Post(int message, nint wParam = 0, nint lParam = 0) {
		//Debug.Assert(!Is0); //no, can be used for "post thread message"
		return Api.PostMessage(this, message, wParam, lParam);
	}
	
	#endregion
	
	#region throw, valid
	
	/// <summary>
	/// If <see cref="Is0"/>, throws <see cref="AuWndException"/>.
	/// </summary>
	/// <returns>This.</returns>
	/// <exception cref="AuWndException"></exception>
	public wnd ThrowIf0() {
		if (Is0) throw new AuWndException(this, Api.ERROR_INVALID_WINDOW_HANDLE);
		return this;
	}
	
	/// <summary>
	/// If <see cref="Is0"/> or not <see cref="IsAlive"/>, throws <see cref="AuWndException"/>.
	/// </summary>
	/// <returns>This.</returns>
	/// <exception cref="AuWndException"></exception>
	public wnd ThrowIfInvalid() {
		if (Is0 || !Api.IsWindow(this)) throw new AuWndException(this, Api.ERROR_INVALID_WINDOW_HANDLE);
		return this;
	}
	
	///// <summary>
	///// If <see cref="Is0"/>, throws <see cref="AuWndException"/>. Returns <c>!IsAlive</c>.
	///// </summary>
	///// <exception cref="AuWndException"></exception>
	//public bool IsInvalidThrowIf0()
	//{
	//	if(Is0) throw new AuWndException(this, Api.ERROR_INVALID_WINDOW_HANDLE);
	//	return !Api.IsWindow(this);
	//}
	//CONSIDER: in many places replace ThrowIfInvalid with ThrowIf0 or IsInvalidThrowIf0.
	
	/// <summary>
	/// Throws <see cref="AuWndException"/> that uses the last Windows API error (code and message).
	/// Also the message depends on whether the window handle is 0/invalid.
	/// </summary>
	/// <exception cref="AuWndException"></exception>
	public void ThrowUseNative() {
		throw new AuWndException(this, 0);
	}
	
	/// <summary>
	/// Throws <see cref="AuWndException"/> that uses the specified Windows API error code and its message.
	/// Also the message depends on whether the window handle is 0/invalid.
	/// </summary>
	/// <exception cref="AuWndException"></exception>
	public void ThrowUseNative(int errorCode) {
		throw new AuWndException(this, errorCode);
	}
	
	/// <summary>
	/// Throws <see cref="AuWndException"/> that uses <i>mainMessage</i> and the last Windows API error (code and message).
	/// Also the message depends on whether the window handle is 0/invalid.
	/// </summary>
	/// <exception cref="AuWndException"></exception>
	public void ThrowUseNative(string mainMessage) {
		throw new AuWndException(this, 0, mainMessage);
	}
	
	/// <summary>
	/// Throws <see cref="AuWndException"/> that uses <i>mainMessage</i> and the specified Windows API error code.
	/// Also the message depends on whether the window handle is 0/invalid.
	/// </summary>
	/// <exception cref="AuWndException"></exception>
	public void ThrowUseNative(int errorCode, string mainMessage) {
		throw new AuWndException(this, errorCode, mainMessage);
	}
	
	/// <summary>
	/// Throws <see cref="AuWndException"/> that uses <i>mainMessage</i> and does not use the last Windows API error.
	/// Also the message depends on whether the window handle is 0/invalid.
	/// </summary>
	/// <exception cref="AuWndException"></exception>
	public void ThrowNoNative(string mainMessage) {
		throw new AuWndException(this, mainMessage);
	}
	
	/// <summary>
	/// Returns <c>true</c> if the window handle is 0 (this variable == <c>default(wnd)</c>).
	/// </summary>
	/// <example>
	/// <code><![CDATA[
	/// wnd w = wnd.find("Window*");
	/// if(w.Is0) { print.it("window not found"); return; }
	/// ]]></code>
	/// </example>
	/// <seealso cref="IsAlive"/>
	public bool Is0 => _h == default;
	
	/// <summary>
	/// Returns <c>true</c> if the window exists (the window handle is valid).
	/// Returns <c>false</c> if the handle is 0 or invalid.
	/// Invalid non-0 handle usually means that the window is closed/destroyed.
	/// </summary>
	/// <remarks>
	/// Calls <see cref="Is0"/> and API <ms>IsWindow</ms>.
	/// Although a <see cref="wnd"/> variable holds a window handle, which is like a reference to a window, it does not prevent closing that window and making the handle invalid. After closing the window, the OS can even assign the same handle value to a new window, although normally it can happen only after long time.
	/// <note>Use this carefully with windows of other applications or threads. The window can be closed at any moment, even when your thread is still in this function.</note>
	/// </remarks>
	public bool IsAlive => !Is0 && Api.IsWindow(this);
	
	#endregion
	
	#region visible, enabled, cloaked
	
	/// <summary>
	/// Returns <c>true</c> if the window is visible.
	/// Returns <c>false</c> if is invisible or is a child of invisible parent.
	/// Also returns <c>false</c> when fails (probably window closed or 0 handle). Supports <see cref="lastError"/>.
	/// </summary>
	/// <remarks>
	/// Calls API <ms>IsWindowVisible</ms>. Does not call <see cref="IsCloaked"/>.
	/// 
	/// Even when this function returns <c>true</c>, the window may be actually invisible. It can be cloaked, on an inactive Windows 10 virtual desktop (cloaked), inactive Windows Store app (cloaked), transparent, zero-size, minimized, off-screen, covered by other windows or can have zero-size window region.
	/// </remarks>
	/// <seealso cref="IsCloaked"/>
	/// <seealso cref="IsVisibleAndNotCloaked"/>
	/// <seealso cref="Show"/>
	/// <seealso cref="Activate"/>
	public bool IsVisible => Api.IsWindowVisible(this);
	
	//rejected. Unreliable, eg then does not find Store apps in inactive desktops. Instead now Find skips all cloaked by default.
	///// <summary>
	///// Returns <c>true</c> if the window is visible.
	///// Returns <c>false</c> if is invisible or is a child of invisible parent.
	///// Also returns <c>false</c> when fails (probably window closed or 0 handle). Supports <see cref="lastError"/>.
	///// </summary>
	///// <remarks>
	///// Returns <c>false</c> if API <ms>IsWindowVisible</ms> returns <c>false</c>.
	///// Also returns <c>false</c> if <see cref="IsCloaked"/> returns <c>true</c>, but only for some popup windows that usually are useless and could cause problems if considered visible.
	///// Else returns <c>true</c>.
	///// 
	///// Even when this function returns <c>true</c>, the window may be actually invisible. It can be cloaked (except the above case), on an inactive Windows 10 virtual desktop (cloaked), inactive Windows Store app (cloaked), transparent, zero-size, minimized, off-screen, covered by other windows or can have zero-size window region.
	///// </remarks>
	///// <seealso cref="IsVisible"/>
	///// <seealso cref="IsCloaked"/>
	///// <seealso cref="IsVisibleAndNotCloaked"/>
	///// <seealso cref="Show"/>
	///// <seealso cref="Activate()"/>
	//public bool IsVisibleEx {
	//	get {
	//		if(!Api.IsWindowVisible(this)) return false;
	
	//		var style = Style;
	//		if((style & (WS.POPUP | WS.CHILD)) == WS.POPUP) {
	//			if((style & WS.CAPTION) != WS.CAPTION) return !IsCloaked;
	
	//			//is it a ghost ApplicationFrameWindow, like closed Calculator on Win10?
	//			if(osVersion.minWin10 && HasExStyle(WSE.NOREDIRECTIONBITMAP) && IsCloaked && ClassNameIs("ApplicationFrameWindow")) {
	//				var isGhost = default == Api.FindWindowEx(this, default, "Windows.UI.Core.CoreWindow", null);
	//				//print.it(isGhost, this);
	//				return !isGhost;
	//			}
	//		}
	//		return true;
	//	}
	//}
	
	
	/// <summary>
	/// Returns <c>true</c> if <see cref="IsVisible"/> returns <c>true</c> and <see cref="IsCloaked"/> returns <c>false</c>.
	/// </summary>
	public bool IsVisibleAndNotCloaked => IsVisible && !IsCloaked;
	
	/// <summary>
	/// Returns <c>true</c> if this window is visible in the specified parent or ancestor window.
	/// Like <see cref="IsVisible"/>, but does not check the visibility of the specified parent/ancestor window.
	/// </summary>
	/// <param name="wParent">Parent or ancestor window.</param>
	internal bool IsVisibleIn_(wnd wParent) {
		if (IsVisible) return true; //these two make faster in most cases (when wTL is visible)
		if (wParent.IsVisible) return false;
		var c = this;
		for (int i = 0; i < 10000; i++) {
			//print.it(c);
			if (!c.HasStyle(WS.VISIBLE)) return false;
			c = c.ParentGWL_;
			if (c == wParent) return true;
			if (c.Is0) break;
		}
		Debug.Assert(false);
		return false;
	}
	
	/// <summary>
	/// Shows (if hidden) or hides this window.
	/// </summary>
	/// <remarks>
	/// Does not activate/deactivate/zorder.
	/// This window can be of any thread. If you know it is of this thread, use <see cref="ShowL"/>. This function calls it.
	/// </remarks>
	/// <exception cref="AuWndException"/>
	public void Show(bool show) {
		if (!ShowL(show)) ThrowUseNative(show ? "*show*" : "*hide*");
		MinimalSleepIfOtherThread_();
	}
	
	/// <summary>
	/// Shows (if hidden) or hides this window.
	/// </summary>
	/// <returns>Returns <c>false</c> if failed. Supports <see cref="lastError"/>.</returns>
	/// <remarks>
	/// Does not activate/deactivate/zorder.
	/// 
	/// There are two similar functions to show/hide a window: 
	/// - <see cref="Show"/> is better to use in automation scripts, with windows of any process/thread. It calls <c>ShowL</c>, and throws exception if it fails. Adds a small delay if the window is of another thread.
	/// - <c>ShowL</c> is better to use in programming, with windows of current thread. It is more lightweight. Does not throw exceptions. Does not add a delay. But both functions can be used with windows of any thread.
	/// </remarks>
	public bool ShowL(bool show) {
		if (show == HasStyle(WS.VISIBLE)) return true; //avoid messages and make much faster. Never mind: if show==false, returns true even if invalid hwnd.
		Send(Api.WM_SHOWWINDOW, show ? 1 : 0); //not necessary for most windows, but eg winforms would not update the Visible property without it. ShowWindow sends it but SetWindowPos doesn't.
		return SetWindowPos((show ? SWPFlags.SHOWWINDOW : SWPFlags.HIDEWINDOW)
			| SWPFlags.NOSIZE | SWPFlags.NOMOVE | SWPFlags.NOACTIVATE | SWPFlags.NOZORDER | SWPFlags.NOOWNERZORDER);
		
		//This code is similar to ShowWindow(SW_SHOWNA). Don't use it because:
		//	May change Z order. Eg makes above other windows of same thread.
		//	Also may not work first time in process. The documentation is unclear. Not tested.
	}
	
	/// <summary>
	/// Returns <c>true</c> if the window is enabled for mouse and keyboard input.
	/// Returns <c>false</c> if disabled. Also <c>false</c> if failed (probably window closed or 0 handle). Supports <see cref="lastError"/>.
	/// </summary>
	/// <param name="ancestorsToo">Check whether all ancestors of this control are enabled too. If <c>false</c> (default), this function simply calls API <ms>IsWindowEnabled</ms>, which usually returns <c>true</c> for controls in disabled windows.</param>
	public bool IsEnabled(bool ancestorsToo = false) {
		if (!ancestorsToo) return Api.IsWindowEnabled(this);
		for (var w = this; ;) {
			if (!Api.IsWindowEnabled(w)) return false;
			w = w.Get.DirectParent; if (w.Is0) break;
		}
		return true;
	}
	
	/// <summary>
	/// Enables or disables.
	/// Calls API <ms>EnableWindow</ms>.
	/// </summary>
	/// <param name="enable">Enable or disable.</param>
	/// <exception cref="AuWndException"/>
	public void Enable(bool enable) {
		lastError.clear();
		Api.EnableWindow(this, enable);
		if (lastError.code != 0) ThrowUseNative("*enable/disable*");
	}
	
	/// <summary>
	/// Gets the cloaked state (it's a way to hide a window).
	/// </summary>
	/// <value>
	/// <br/>• 0 if not cloaked or if failed.
	/// <br/>• 1 cloaked by its application.
	/// <br/>• 2 cloaked by Windows.
	/// <br/>• 4 cloaked because its owner window is cloaked.
	/// 
	/// <para>
	/// On Windows 7 returns 0 because there is no "cloaked window" feature.
	/// </para>
	/// </value>
	/// <seealso cref="IsCloaked"/>
	public int IsCloakedGetState {
		get {
			if (!osVersion.minWin8) return 0;
			int cloaked = 0;
			int hr = Api.DwmGetWindowAttribute(this, Api.DWMWA.CLOAKED, &cloaked, 4);
			return cloaked;
		}
	}
	/// <summary>
	/// Detects whether the window is cloaked (it's a way to hide a window).
	/// </summary>
	/// <value><c>true</c> if the window is cloaked. <c>false</c> if not cloaked or if failed.</value>
	/// <remarks>
	/// On Windows 7 returns <c>false</c> because there is no "cloaked window" feature.
	/// Windows 10 uses window cloaking mostly to hide windows on inactive desktops. Windows 8 - mostly to hide Windows Store app windows.
	/// </remarks>
	/// <seealso cref="IsCloakedGetState"/>
	public bool IsCloaked => IsCloakedGetState != 0;
	
	#endregion
	
	#region minimized, maximized
	
	/// <summary>
	/// Returns <c>true</c> if minimized, <c>false</c> if not.
	/// Also returns <c>false</c> when fails (probably window closed or 0 handle). Supports <see cref="lastError"/>.
	/// Calls API <ms>IsIconic</ms>.
	/// </summary>
	public bool IsMinimized => Api.IsIconic(this);
	
	/// <summary>
	/// Returns <c>true</c> if maximized, <c>false</c> if not.
	/// Also returns <c>false</c> when fails (probably window closed or 0 handle). Supports <see cref="lastError"/>.
	/// Calls API <ms>IsZoomed</ms>.
	/// </summary>
	public bool IsMaximized => Api.IsZoomed(this);
	
	/// <summary>
	/// If not minimized, minimizes.
	/// Also unhides.
	/// </summary>
	/// <param name="how">What API to use: 0 <ms>ShowWindow</ms>, 1 <ms>SetWindowPlacement</ms> (no animation), 2 <ms>WM_SYSCOMMAND</ms>.</param>
	/// <exception cref="AuWndException">The API call failed. No exception if the window did not obey.</exception>
	public void ShowMinimized(int how = 0) => _MinMaxRes(Api.SW_MINIMIZE, how);
	
	/// <summary>
	/// If not minimized, minimizes.
	/// Also unhides.
	/// </summary>
	/// <param name="how">What API to use: 0 <ms>ShowWindow</ms>, 1 <ms>SetWindowPlacement</ms> (no animation), 2 <ms>WM_SYSCOMMAND</ms>.</param>
	/// <exception cref="AuWndException">The API call failed. No exception if the window did not obey.</exception>
	public void ShowMaximized(int how = 0) => _MinMaxRes(Api.SW_SHOWMAXIMIZED, how);
	
	/// <summary>
	/// If maximized or minimized, makes normal (not min/max).
	/// Also unhides.
	/// </summary>
	/// <param name="how">What API to use: 0 <ms>ShowWindow</ms>, 1 <ms>SetWindowPlacement</ms> (no animation), 2 <ms>WM_SYSCOMMAND</ms>.</param>
	/// <exception cref="AuWndException">The API call failed. No exception if the window did not obey.</exception>
	public void ShowNotMinMax(int how = 0) => _MinMaxRes(Api.SW_SHOWNORMAL, how);
	
	/// <summary>
	/// If minimized, restores previous non-minimized state (maximized or normal).
	/// Also unhides.
	/// </summary>
	/// <param name="how">What API to use: 0 <ms>ShowWindow</ms>, 1 <ms>SetWindowPlacement</ms> (no animation), 2 <ms>WM_SYSCOMMAND</ms>.</param>
	/// <exception cref="AuWndException">The API call failed. No exception if the window did not obey.</exception>
	public void ShowNotMinimized(int how = 0) => _MinMaxRes(Api.SW_RESTORE, how);
	
	///
	[Obsolete, EditorBrowsable(EditorBrowsableState.Never)]
	public void ShowMinimized(bool noAnimation) => _MinMaxRes(Api.SW_MINIMIZE, noAnimation ? 1 : 0);
	///
	[Obsolete, EditorBrowsable(EditorBrowsableState.Never)]
	public void ShowMaximized(bool noAnimation) => _MinMaxRes(Api.SW_SHOWMAXIMIZED, noAnimation ? 1 : 0);
	///
	[Obsolete, EditorBrowsable(EditorBrowsableState.Never)]
	public void ShowNotMinMax(bool noAnimation) => _MinMaxRes(Api.SW_SHOWNORMAL, noAnimation ? 1 : 0);
	///
	[Obsolete, EditorBrowsable(EditorBrowsableState.Never)]
	public void ShowNotMinimized(bool noAnimation) => _MinMaxRes(Api.SW_RESTORE, noAnimation ? 1 : 0);
	
	/// <summary>
	/// Sets window min/max/normal/restore state.
	/// Also unhides.
	/// </summary>
	/// <param name="state">Must be <c>SW_MINIMIZE</c>, <c>SW_RESTORE</c> (restores to normal/max if minimized), <c>SW_SHOWNORMAL</c> or <c>SW_SHOWMAXIMIZED</c>.</param>
	/// <param name="how">0 <c>ShowWindow</c>, 1 <c>SetWindowPlacement</c> (no animation), 2 <c>WM_SYSCOMMAND</c>.</param>
	/// <exception cref="AuWndException"/>
	void _MinMaxRes(int state, int how) {
		Debug.Assert(state == Api.SW_MINIMIZE || state == Api.SW_RESTORE || state == Api.SW_SHOWNORMAL || state == Api.SW_SHOWMAXIMIZED);
		ThrowIfInvalid();
		
		bool ok = false, wasMinimized = IsMinimized;
		
		switch (state) {
		case Api.SW_MINIMIZE:
			ok = wasMinimized;
			break;
		case Api.SW_RESTORE:
			ok = !wasMinimized;
			break;
		case Api.SW_SHOWMAXIMIZED:
			ok = IsMaximized;
			break;
		default: //SW_SHOWNORMAL
			ok = !wasMinimized && !IsMaximized; //info: if invalid handle, Show() will return false, don't need to check here.
			break;
		}
		
		if (ok) {
			if (IsVisible) return;
			Show(true);
		} else {
			//WPF bug: if using SizeToContent, maximizing with ShowWindow/SetWindowPlacement sets incorrect size.
			//	Example: if SizeToContent=vertical, resizes vertically for content, and horizontally for entire screen (not work area).
			//		If inactive, resizes vertically for content, and horizontally does not resize.
			//	Works well with WM_SYSCOMMAND.
			//if(how!=2 && state == Api.SW_SHOWMAXIMIZED && ClassNameIs("HwndWrapper[*")) how=2; //no. Never mind.
			
			if (how == 0) {
				Api.ShowWindow(this, state);
				//note: The API returns TRUE if was visible, not if succeeded. Tested: lastError can't be used.
				ok = _IsState(this, state);
			} else if (how == 1 && (ok = GetWindowPlacement_(out var p, false))) {
				int state2 = state;
				switch (state) {
				case Api.SW_MINIMIZE:
					if (p.showCmd == Api.SW_SHOWMAXIMIZED) p.flags |= Api.WPF_RESTORETOMAXIMIZED; else p.flags &= ~Api.WPF_RESTORETOMAXIMIZED; //Windows forgets to remove the flag
					break;
				case Api.SW_RESTORE:
					if ((p.showCmd == Api.SW_SHOWMINIMIZED) && (p.flags & Api.WPF_RESTORETOMAXIMIZED) != 0) state2 = Api.SW_SHOWMAXIMIZED; //without this would make normal
					break;
				}
				
				//if(wasMinimized) p.flags|=Api.WPF_ASYNCWINDOWPLACEMENT; //Windows bug: if window of another thread, deactivates currently active window and does not activate this window. However then animates window. If we set this while the window is not minimized, it would set blinking caret in inactive window. Instead we use another workaround, see below.
				p.showCmd = state2;
				ok = SetWindowPlacement_(ref p, false);
			}
			
			static bool _IsState(wnd w, int state) => state switch {
				Api.SW_MINIMIZE => w.IsMinimized,
				Api.SW_RESTORE => !w.IsMinimized,
				Api.SW_SHOWMAXIMIZED => w.IsMaximized,
				_ => !(w.IsMinimized || w.IsMaximized)
			} && w.IsVisible;
			
			if (!ok) {
				if (how == 2 || UacAccessDenied) {
					var cmd = state switch {
						Api.SW_MINIMIZE => Api.SC_MINIMIZE,
						Api.SW_SHOWMAXIMIZED => Api.SC_MAXIMIZE, //fails, never mind
						_ => Api.SC_RESTORE,
					};
					Send(Api.WM_SYSCOMMAND, cmd);
					//if was minimized, now can be maximized, need to restore if SW_SHOWNORMAL
					if (state == Api.SW_SHOWNORMAL && IsMaximized) Send(Api.WM_SYSCOMMAND, cmd);
					//note: the Send return value is unreliable
					ok = _IsState(this, state);
				}
				
				if (!ok) ThrowNoNative("*minimize/maximize/restore*");
			}
			
			if (!IsOfThisThread) {
				if (wasMinimized) ActivateL(); //Windows bug: if window of another thread, deactivates currently active window and does not activate this window
				else if (state == Api.SW_MINIMIZE) WndUtil.WaitForAnActiveWindow();
			}
		}
		
		if (how != 1) MinimalSleepIfOtherThread_();
	}
	
	/// <summary>
	/// Initializes a <c>WINDOWPLACEMENT</c> struct and calls API <ms>GetWindowPlacement</ms>.
	/// </summary>
	/// <param name="wp"></param>
	/// <param name="rectInScreen">Remove workarea thickness from <c>wp.rcNormalPosition</c>.</param>
	/// <param name="errStr">If not <c>null</c>, throws it if failed.</param>
	/// <remarks>Supports <see cref="lastError"/>.</remarks>
	/// <exception cref="AuWndException">Failed. Throws, only if <c>errStr!=null</c>, else returns <c>false</c>.</exception>
	internal bool GetWindowPlacement_(out Api.WINDOWPLACEMENT wp, bool rectInScreen, string errStr = null) {
		//initially this was public, but probably don't need.
		
		wp = new Api.WINDOWPLACEMENT(); wp.length = Api.SizeOf(wp);
		if (Api.GetWindowPlacement(this, ref wp)) {
			if (rectInScreen) _Wp1(ref wp, false);
			return true;
		}
		if (errStr != null) ThrowUseNative(errStr);
		return false;
	}
	
	/// <summary>
	/// Sets <c>WINDOWPLACEMENT</c> <c>length</c> field and calls API <ms>SetWindowPlacement</ms>.
	/// </summary>
	/// <param name="wp"></param>
	/// <param name="rectInScreen"><c>wp.rcNormalPosition</c> is without workarea thickness.</param>
	/// <param name="errStr">If not <c>null</c>, throws it if failed.</param>
	/// <exception cref="AuWndException">Failed. Throws, only if <c>errStr!=null</c>, else returns <c>false</c>.</exception>
	internal bool SetWindowPlacement_(ref Api.WINDOWPLACEMENT wp, bool rectInScreen, string errStr = null) {
		//initially this was public, but probably don't need.
		
		if (rectInScreen) _Wp1(ref wp, true);
		wp.length = Api.SizeOf(wp);
		if (Api.SetWindowPlacement(this, wp)) return true;
		if (errStr != null) ThrowUseNative(errStr);
		return false;
	}
	
	void _Wp1(ref Api.WINDOWPLACEMENT wp, bool set) {
		if (!IsToolWindow) {
			var s = set ? screen.of(wp.rcNormalPosition) : screen.of(this);
			var v = s.Info;
			int i = set ? -1 : 1;
			wp.rcNormalPosition.Offset((v.workArea.left - v.rect.left) * i, (v.workArea.top - v.rect.top) * i);
		}
	}
	
	#endregion
	
	#region activate, focus
	
	internal static partial class Internal_ {
		/// <summary>
		/// No exceptions.
		/// </summary>
		internal static bool EnableActivate(bool goingToActivateAWindow) {
			if (_EnableActivate_AllowSetFore()) return true; //not locked, or already successfully called ASF_Key
			
			_EnableActivate_SendKey(true);
			if (_EnableActivate_AllowSetFore()) return true;
			//First time fails if the foreground window is of higher IL. Then sending keys does not work.
			
			//_EnableActivate_MinRes() makes no active window...
			if (goingToActivateAWindow) {
				_EnableActivate_MinRes();
				return _EnableActivate_AllowSetFore();
			}
			
			var wFore = active; bool retry = false;
			g1: _EnableActivate_MinRes();
			if (!_EnableActivate_AllowSetFore()) return false;
			if (!wFore.Is0 && !retry) {
				Api.SetForegroundWindow(wFore);
				if (!_EnableActivate_AllowSetFore()) { retry = true; goto g1; } //didn't notice this but let's be safer
			}
			return true;
			
			//Other possible ways to allow set foreground window:
			//1. Instead of key can use attachthreadinput. But it is less reliable, eg works first time only, and does not allow our process to activate later easily. Does not work if foreground window is higher IL.
			//2. Call allowsetforegroundwindow from a hook from the foreground process (or from the shell process, not tested). Too dirty. Need 2 native dlls (32/64-bit). Cannot inject if higher IL.
			
			//Other possible ways to set foreground window:
			//1. Create temp window, RegisterHotKey, SendInput, and call SetForegroundWindow on WM_HOTKEY. Does not work if foreground window is higher IL.
			//2. WM_SETHOTKEY. More info below. Could not make it work well in all cases.
			//3. IUIAutomationElement.SetFocus. Does not work if foreground window is higher IL. Slow. Briefly makes the taskbar button red.
			
			//tested: cannot disable the foreground lock timeout with SystemParametersInfo(SPI_SETFOREGROUNDLOCKTIMEOUT) when this process cannot activate windows.
		}
		
		/// <summary>
		/// Sends a key (<c>VK_0</c> up). It allows to activate now.
		/// Later this process usually (but not always) can activate easily (without key etc). It works even with higher IL windows.
		/// Don't know why is this behavior. Tested on all OS.
		/// Does not work if the foreground process has higher UAC IL.
		/// Does not work if bad input desktop.
		/// </summary>
		static void _EnableActivate_SendKey(bool debugOut) {
			//if (debugOut) Debug_.Print("EnableActivate: need key"); //FUTURE: temporarily enable to see maybe there are too many calls
			
			var x = new Api.INPUTK(0, 128, Api.KEYEVENTF_KEYUP);
			Api.SendInput(&x, dontThrow: true);
			//info: works without waiting.
		}
		
		/// <summary>
		/// Creates a temporary minimized window and restores it. It activates the window and allows us to activate.
		/// Then sets "no active window" to prevent auto-activating another window when destroying the temporary window.
		/// </summary>
		static void _EnableActivate_MinRes() {
			//Debug_.Print("EnableActivate: need min/res");
			Debug_.Print($"EnableActivate: need min/res, {miscInfo.isInputDesktop(false)} {miscInfo.isInputDesktop(true)}, {wnd.active}");
			//CONSIDER: don't try if !miscInfo.isInputDesktop(true)
			
			wnd t = WndUtil.CreateWindow(WndUtil.WindowClassDWP_, null, WS.POPUP | WS.MINIMIZE | WS.VISIBLE, WSE.TOOLWINDOW);
			//info: When restoring, the window must be visible, or may not work.
			try {
				var wp = new Api.WINDOWPLACEMENT { showCmd = Api.SW_RESTORE };
				t.SetWindowPlacement_(ref wp, false); //activates t; fast (no animation)
				_EnableActivate_SendKey(false); //makes so that later our process can always activate
				_EnableActivate_AllowSetFore();
				Api.SetForegroundWindow(getwnd.root); //set no foreground window, or may activate the higher IL window (maybe does not activate, but winevents hook gets events, in random order). Other way would be to destroy our window later, but more difficult to implement.
			}
			finally { Api.DestroyWindow(t); }
			
			//Another way:
			//	t.Send(Api.WM_SETHOTKEY, ...);
			//	Api.SendInputKey(...)
			//Works if UAC allows SendInput.
			//WM_SETHOTKEY works only if visible. No wm_syscommand if inactive, but activates. Unlike registerhotkey, not blocked by UAC even without modifiers. Need more testing.
			//This does not work: t.Send(WM_SYSCOMMAND, SC_HOTKEY);
		}
		
		/// <summary>
		/// Calls <c>Api.AllowSetForegroundWindow(Api.GetCurrentProcessId())</c>.
		/// </summary>
		static bool _EnableActivate_AllowSetFore() {
			return Api.AllowSetForegroundWindow(Api.GetCurrentProcessId());
		}
		
		internal static bool ActivateL(wnd w) {
			if (w.IsActiveOrNoActiveAndThisIsWndRoot_) return true;
			
			try {
				bool canAct = EnableActivate(true);
				
				if (!Api.SetForegroundWindow(w)) {
					if (!canAct || !w.IsAlive) return false;
					//It happens when foreground process called LockSetForegroundWindow.
					//Although AllowSetForegroundWindow returns true, SetForegroundWindow fails.
					//It happens only before this process sends keys. Eg after first _EnableActivate_SendKey this never happens again.
					//If it has higher IL (and this process is User), also need _EnableActivate_MinRes.
					_EnableActivate_SendKey(true);
					if (!Api.SetForegroundWindow(w)) {
						_EnableActivate_MinRes();
						if (!Api.SetForegroundWindow(w)) return false;
					}
				}
				
				//Often after SetForegroundWindow there is no active window for several ms. Not if the window is of this thread.
				//	https://devblogs.microsoft.com/oldnewthing/20161118-00/?p=94745
				if (w == getwnd.root) return active.Is0;
				if (WndUtil.WaitForAnActiveWindow()) return true;
				w.SendTimeout(1000, out _, 0);
				return !active.Is0;
			}
			//catch(AuWndException) { return false; }
			catch { return false; }
		}
		
		[Flags]
		internal enum ActivateFlags {
			/// <summary>
			/// Don't call <see cref="ThrowIfInvalid"/> (ie caller ensures it is valid).
			/// </summary>
			NoThrowIfInvalid = 1,
			
			/// <summary>
			/// Don't try to get top-level window (ie caller ensures it's a top-level window, not control).
			/// </summary>
			NoGetWindow = 2,
			
			/// <summary>
			/// Don't activate if has <ms>WS_EX_NOACTIVATE</ms> style or is toolwindow without title bar, unless cloaked.
			/// Then just calls <see cref="ZorderTop"/>, which in most cases does not work (inactive window).
			/// </summary>
			IgnoreIfNoActivateStyleEtc = 4,
			
			/// <summary>
			/// Wait for window animations to end. Eg when switching Win10 desktops.
			/// </summary>
			ForScreenCapture = 8,
		}
	}
	
	/// <summary>
	/// Activates this window (brings to the foreground).
	/// The same as <see cref="Activate"/>, but has some options.
	/// Returns <c>false</c> if does not activate because of flag <c>IgnoreIfNoActivateStyleEtc</c>.
	/// </summary>
	/// <exception cref="AuWndException"/>
	/// <exception cref="InputDesktopException"></exception>
	internal bool Activate_(Internal_.ActivateFlags flags) {
		if (!flags.Has(Internal_.ActivateFlags.NoThrowIfInvalid)) ThrowIfInvalid();
		if (flags.Has(Internal_.ActivateFlags.NoGetWindow)) Debug.Assert(!IsChild);
		else {
			var w = Window;
			if (w != this) {
				if (!w.Is0) print.warning("Child windows can't be activated. You may want to call Focus() instead.");
				return w.Activate_((flags | Internal_.ActivateFlags.NoGetWindow) & ~Internal_.ActivateFlags.NoThrowIfInvalid);
			}
		}
		
		bool R, noAct = false, isMinimized = false, ofThisThread = IsOfThisThread;
		bool forScreenCapture = 0 != (flags & Internal_.ActivateFlags.ForScreenCapture);
		
		if (IsMinimized) {
			ShowNotMinimized(1);
			isMinimized = IsMinimized;
			if (forScreenCapture && !isMinimized && !ofThisThread) Thread.Sleep(250); //although we use noAnimation, in some cases still restores with animation
		}
		if (!IsVisible) Show(true);
		
		R = IsActiveOrNoActiveAndThisIsWndRoot_;
		if (!R) {
			if (0 != (flags & Internal_.ActivateFlags.IgnoreIfNoActivateStyleEtc)) {
				if (IsNoActivateStyle_() && !IsCloaked) {
					ZorderTop();
					return false; //if cloaked, need to activate to uncloak
				}
			}
			
			for (int i = 0; i < 3; i++) {
				bool ok = Internal_.ActivateL(this);
				
				if (!ofThisThread) {
					MinimalSleepNoCheckThread_();
					MinimalSleepNoCheckThread_();
				}
				
				if (ok) {
					wnd f = active;
					if (f == this) R = true;
					else if (this == getwnd.root) R = f.Is0; //activating GetDesktopWindow makes "no active window"
					else { //forgive if the target app instead activated another window of same thread
						int tid = ThreadId; if (tid == 0) break;
						if (f.ThreadId == tid) {
							//at first try to recognize such known windows, to avoid the hard way
							if (isMinimized || (f.Get.Owner == this && Rect.NoArea)) {
								R = true;
							} else {
								R = Api.SetForegroundWindow(getwnd.root) && ActivateL() && active.ThreadId == tid;
								if (R && !ofThisThread) {
									MinimalSleepNoCheckThread_();
									R = active.ThreadId == tid;
								}
							}
							//Example 1:
							//Excel creates a minimized window for each workbook opened in that excel process.
							//These windows just add taskbar buttons. Also it allows to find and activate workbooks.
							//When you activate such window, Excel instead activates its main window, where it displays all workbooks.
							//For this reason we would fail (not always, because this may be temporarily active).
							//Same with PowerPoint. Other Office apps no.
							//Example 2:
							//Inno Setup, SQLite Expert. They have a zero-size owner window that just adds taskbar button.
						}
					}
					if (R) break;
				}
				
				if (noAct) break;
				Thread.Sleep(30);
			}
		}
		
		if (R && !ofThisThread && this != getwnd.root) {
			//If we activate a window that is on an inactive Win10 desktop, its desktop becomes active.
			//Windows on inactive desktops are cloaked. They are uncloaked after ~15 ms.
			if (IsCloaked) {
				R = false;
				for (int i = 0; i < 50; i++) { Thread.Sleep(30); if (R = !IsCloaked) break; }
				if (R) {
					if (forScreenCapture) Thread.Sleep(800); //need minimum 600 for 'find image' functions, because of animation while switching Win10 desktops.
					MinimalSleepNoCheckThread_();
					R = IsActive;
					if (!R && ActivateL()) {
						MinimalSleepNoCheckThread_();
						R = IsActive;
					}
				}
			}
		}
		
		if (!R) {
			InputDesktopException.ThrowIfBadDesktop("*activate window", detectLocked: true);
			ThrowNoNative("*activate*");
		}
		if (forScreenCapture) MinimalSleepIfOtherThread_();
		
		return true;
		
		//tested: if the window is hung, activates the ghost window and fails (exception). It's OK.
	}
	
	internal bool IsNoActivateStyle_() {
		var es = ExStyle;
		if ((es & WSE.NOACTIVATE) != 0) return true;
		if ((es & (WSE.TOOLWINDOW | WSE.APPWINDOW)) == WSE.TOOLWINDOW) return !HasStyle(WS.CAPTION);
		return false;
	}
	
	/// <summary>
	/// Activates this window. Also makes it visible and not minimized.
	/// The active window is in the foreground and receives keyboard and mouse input.
	/// </summary>
	/// <returns>Self.</returns>
	/// <remarks>
	/// Activating a window usually also uncloaks it, for example switches to its virtual desktop on Windows 10/11.
	/// Fails (throws exception) if cannot activate this window, except:
	/// - When this is a control. Then activates its top-level parent window.
	/// - When the window's process instead activates another window of the same thread.
	/// - If this is <see cref="getwnd.root"/>, just deactivates the currently active window.
	/// </remarks>
	/// <exception cref="AuWndException">Failed to activate.</exception>
	/// <exception cref="InputDesktopException"></exception>
	/// <seealso cref="ActivateL"/>
	/// <seealso cref="IsActive"/>
	/// <seealso cref="active"/>
	/// <seealso cref="switchActiveWindow"/>
	public wnd Activate() {
		Activate_(0);
		return this;
	}
	//CONSIDER: if fails to activate:
	//dialog.show("Failed to activate window", w.ToString(), footer: The script will continue if you activate the window in {x} s.", timeout: 10);
	
	//rejected: Activate(double waitS = 0) /// <param name="waitS">Max time interval (seconds) to wait until the window naturally becomes active before activating it.</param>
	//	It would have sense if we somehow know that the window was created by previous action (or several actions).
	//	Would need an explicit function call before the action(s). Nobody would use it.
	
	/// <summary>
	/// Lightweight version of <see cref="Activate"/>. Does not throw exceptions.
	/// </summary>
	/// <param name="full">
	/// Call <see cref="Activate"/> and handle exceptions; on exception return <c>false</c>.
	/// If <c>false</c> (default), just activates; does not show hidden, does not restore minimized, does not check whether it is a top-level window or control, does not check whether activated exactly this window, etc.
	/// </param>
	/// <returns><c>false</c> if failed.</returns>
	public bool ActivateL(bool full = false) {
		if (!full) return Internal_.ActivateL(this);
		try {
			Activate();
			return true;
		}
		catch { return false; }
	}
	
	//Too unreliable.
	///// <summary>
	///// Calls API <c>LockSetForegroundWindow</c>, which temporarily prevents other applications from activating windows easily with <c>SetForegroundWindow</c>.
	///// If <c>LockSetForegroundWindow</c> fails, calls <c>EnableActivate</c> and retries.
	///// </summary>
	///// <param name="on">Lock or unlock.</param>
	//public static bool lockActiveWindow(bool on)
	//{
	//	uint f = on ? Api.LSFW_LOCK : Api.LSFW_UNLOCK;
	//	if(Api.LockSetForegroundWindow(f)) return true;
	//	return EnableActivate() && Api.LockSetForegroundWindow(f);
	//}
	
	/// <summary>
	/// Sets the keyboard input focus to this control.
	/// Also activates its top-level parent window (see <see cref="Activate"/>).
	/// </summary>
	/// <remarks>
	/// The control can belong to any process/thread. With controls of this thread you can use the more lightweight function <see cref="thisThread.focus"/>.
	/// Works not with all windows. For example, does not work with Windows Store apps. Then use <see cref="elm.Focus"/>.
	/// Can instead focus a child control. For example, if this is a combo box, it will focus its child Edit control. Then does not throw exception.
	/// This can be control or top-level window. Top-level windows also can have focus.
	/// Fails when the target process is admin or uiAccess and this process isn't. See [](xref:uac).
	/// </remarks>
	/// <exception cref="AuWndException">
	/// - Invalid handle.
	/// - Disabled.
	/// - Failed to set focus.
	/// - Failed to activate parent window.
	/// </exception>
	/// <exception cref="InputDesktopException"></exception>
	/// <seealso cref="focused"/>
	/// <seealso cref="IsFocused"/>
	/// <seealso cref="elm.Focus"/>
	public void Focus() {
		ThrowIfInvalid();
		wnd wTL = Window;
		if (!wTL.IsActive) wTL.Activate_(Internal_.ActivateFlags.NoGetWindow);
		
		int tid = ThreadId;
		if (tid == Api.GetCurrentThreadId()) {
			if (!thisThread.focus(this)) {
				if (!IsEnabled(true)) goto gDisabled;
				goto gFailed;
			}
			return;
		}
		
		if (IsFocused) return;
		if (!IsEnabled(true)) goto gDisabled;
		
		bool ok = false;
		using (new AttachThreadInput_(tid, out bool atiOK)) {
			if (atiOK) { //FUTURE: if fails, try elm.Focus or UIA. AttachThreadInput is unreliable.
				for (int i = 0; i < 5; i++) {
					if (i > 0) Thread.Sleep(30);
					lastError.clear();
					if (thisThread.focus(this)) {
						wnd f = focused;
						if (f == this || f.IsChildOf(this)) { ok = true; break; }
					}
				}
			}
		}
		if (!ok) goto gFailed;
		
		MinimalSleepNoCheckThread_();
		return;
		gDisabled: //SetFocus fails if disabled
		ThrowIfInvalid();
		ThrowNoNative("*set focus. Disabled");
		gFailed:
		ThrowUseNative("*set focus");
	}
	
	/// <summary>
	/// Gets the control or window that has the keyboard input focus.
	/// </summary>
	/// <remarks>
	/// The control/window can belong to any process/thread. With controls/windows of this thread you can use the more lightweight function <see cref="thisThread.focused"/>.
	/// Calls API <ms>GetGUIThreadInfo</ms>.
	/// </remarks>
	/// <seealso cref="Focus"/>
	/// <seealso cref="IsFocused"/>
	public static wnd focused {
		get {
			miscInfo.getGUIThreadInfo(out var g);
			return g.hwndFocus;
		}
	}
	//FUTURE: need functions that wait eg max 1 s until a window is focused or active.
	//	Example: after activating a window using the taskbar, there is no active window for 100 ms or more.
	//	Example: after opening a common file dialog, the Edit control is focused after 200 ms, until that there is no focus.
	// For 'active' we already have More.WaitForAnActiveWindow.
	
	/// <summary>
	/// Returns <c>true</c> if this is the control or window that has the keyboard input focus.
	/// </summary>
	/// <remarks>
	/// This control/window can belong to any process/thread. With controls/windows of this thread you can use the more lightweight function <see cref="thisThread.isFocused"/>.
	/// Calls <see cref="focused"/>.
	/// </remarks>
	/// <seealso cref="Focus"/>
	public bool IsFocused => !this.Is0 && this == focused;
	
	/// <summary>
	/// Functions that can be used only with windows/controls of this thread.
	/// </summary>
	public static class thisThread {
		/// <summary>
		/// Calls API <ms>SetFocus</ms>. It sets the keyboard input focus to the specified control or window, which must be of this thread.
		/// </summary>
		/// <returns><c>false</c> if failed. Supports <see cref="lastError"/>.</returns>
		/// <remarks>
		/// Fails if the control/window belongs to another thread or is invalid or disabled.
		/// Can instead focus a child control. For example, if combo box, will focus its child Edit control. Then returns <c>true</c>.
		/// </remarks>
		public static bool focus(wnd w) {
			if (w.Is0) { Api.SetLastError(Api.ERROR_INVALID_WINDOW_HANDLE); return false; }
			var f = Api.GetFocus(); if (f == w) return true;
			if (!Api.SetFocus(w).Is0) return true;
			if (f.Is0) return !Api.GetFocus().Is0;
			return false;
		}
		
		/// <summary>
		/// Gets the focused control or window of this thread.
		/// </summary>
		/// <remarks>
		/// Calls API <ms>GetFocus</ms>.
		/// </remarks>
		public static wnd focused => Api.GetFocus();
		
		//rejected.
		///// <summary>
		///// Gets the focused control or form of this thread.
		///// </summary>
		///// <remarks>
		///// Calls API <ms>GetFocus</ms> and <see cref="System.Windows.Forms.Control.FromHandle"/>.
		///// </remarks>
		//public static System.Windows.Forms.Control focusedWinformsControl => System.Windows.Forms.Control.FromHandle(Api.GetFocus().Handle);
		
		/// <summary>
		/// Returns <c>true</c> if <i>w</i> is the focused control or window of this thread.
		/// </summary>
		/// <remarks>
		/// Calls API <ms>GetFocus</ms>.
		/// </remarks>
		public static bool isFocused(wnd w) => !w.Is0 && w == Api.GetFocus();
		
		/// <summary>
		/// Gets the active window of this thread.
		/// Calls API <ms>GetActiveWindow</ms>.
		/// </summary>
		public static wnd active => Api.GetActiveWindow();
	}
	
	#endregion
	
	#region rect
	
	/// <summary>
	/// Gets rectangle (position and size) in screen coordinates.
	/// </summary>
	/// <param name="r">Receives the rectangle. Will be <c>default(RECT)</c> if failed.</param>
	/// <param name="withoutExtendedFrame">Don't include the transparent part of window border. For it is used API <ms>DwmGetWindowAttribute</ms>(<c>DWMWA_EXTENDED_FRAME_BOUNDS</c>); it is less reliable.</param>
	/// <remarks>
	/// The same as the <see cref="Rect"/> property.
	/// Calls API <ms>GetWindowRect</ms> and returns its return value.
	/// Supports <see cref="lastError"/>.
	/// </remarks>
	public bool GetRect(out RECT r, bool withoutExtendedFrame = false) {
		if (withoutExtendedFrame) {
			RECT t;
			if (0 == Api.DwmGetWindowAttribute(this, Api.DWMWA.EXTENDED_FRAME_BOUNDS, &t, 16)) {
				r = t;
				return true;
				//tested: on Win7 gets physical (not logical) coords of DPI-scaled window
			}
		}
		
		if (Api.GetWindowRect(this, out r)) return true;
		r = default;
		return false;
	}
	
	/// <summary>
	/// Gets rectangle (position and size) in screen coordinates.
	/// </summary>
	/// <remarks>
	/// Calls <see cref="GetRect"/>. Returns <c>default(RECT)</c> if fails (eg window closed).
	/// Supports <see cref="lastError"/>.
	/// </remarks>
	public RECT Rect {
		get {
			GetRect(out RECT r);
			return r;
		}
	}
	
	///// <summary>
	///// Gets width and height.
	///// </summary>
	///// <param name="z">Receives width and height. Will be <c>default(SIZE)</c> if failed.</param>
	///// <remarks>
	///// The same as the <see cref="Size"/> property.
	///// Calls API <ms>GetWindowRect</ms> and returns its return value.
	///// Supports <see cref="lastError"/>.
	///// </remarks>
	//public bool GetSize(out SIZE z) {
	//	if (Api.GetWindowRect(this, out RECT r)) { z = new SIZE(r.Width, r.Height); return true; }
	//	z = default;
	//	return false;
	//}
	
	///// <summary>
	///// Gets width and height.
	///// </summary>
	///// <remarks>
	///// Calls <see cref="GetSize"/>. Returns <c>default(SIZE)</c> if fails (eg window closed).
	///// Supports <see cref="lastError"/>.
	///// </remarks>
	//public SIZE Size {
	//	get {
	//		GetSize(out SIZE z);
	//		return z;
	//	}
	//}
	
	///// <summary>
	///// Gets position in screen coordinates.
	///// </summary>
	///// <remarks>
	///// Calls <see cref="GetRect"/>. Returns <c>default(POINT)</c> if fails (eg window closed).
	///// Supports <see cref="lastError"/>.
	///// </remarks>
	//public POINT XY {
	//	get { var r = Rect; return new(r.left, r.top); }
	//}
	
	///// <summary>
	///// Gets horizontal position in screen coordinates.
	///// </summary>
	///// <remarks>Calls <see cref="GetRect"/>.</remarks>
	//public int X {
	//	get => Rect.left;
	//}
	
	///// <summary>
	///// Gets vertical position in screen coordinates.
	///// </summary>
	///// <remarks>Calls <see cref="GetRect"/>.</remarks>
	//public int Y {
	//	get => Rect.top;
	//}
	
	///// <summary>
	///// Gets width.
	///// </summary>
	///// <remarks>Calls <see cref="GetRect"/>.</remarks>
	//public int Width {
	//	get => Rect.Width;
	//}
	
	///// <summary>
	///// Gets height.
	///// </summary>
	///// <remarks>Calls <see cref="GetRect"/>.</remarks>
	//public int Height {
	//	get => Rect.Height;
	//}
	
	/// <summary>
	/// Gets client area rectangle.
	/// </summary>
	/// <param name="r">Receives the rectangle. Will be <c>default(RECT)</c> if failed.</param>
	/// <param name="inScreen">
	/// Get rectangle in screen coordinates; like <see cref="GetWindowAndClientRectInScreen"/> but faster.
	/// If <c>false</c> (default), calls API <ms>GetClientRect</ms>; the same as <see cref="ClientRect"/>.</param>
	/// <remarks>
	/// Supports <see cref="lastError"/>.
	/// </remarks>
	public bool GetClientRect(out RECT r, bool inScreen = false) {
#if true
		if (Api.GetClientRect(this, out r) && (!inScreen || Api.MapWindowPoints(this, default, ref r, out _))) return true;
		r = default; return false;
#else //>= 2 times slower
			if(inScreen) return GetWindowAndClientRectInScreen(out _, out r);
			if(Api.GetClientRect(this, out r)) return true;
			r = default;
			return false;
#endif
	}
	
	/// <summary>
	/// Gets client area rectangle (width and height).
	/// </summary>
	/// <remarks>
	/// The left and top fields are always 0.
	/// Calls <see cref="GetClientRect"/>. Returns <c>default(RECT)</c> if fails (eg window closed).
	/// </remarks>
	public RECT ClientRect {
		get {
			GetClientRect(out RECT r);
			return r;
		}
	}
	
	///// <summary>
	///// Gets client area width and height.
	///// </summary>
	///// <param name="z">Receives width and height. Will be <c>default(RECT)</c> if failed.</param>
	///// <remarks>
	///// The same as the <see cref="ClientSize"/> property.
	///// The same as <see cref="GetClientRect"/>, just the parameter type is different.
	///// Calls API <ms>GetClientRect</ms> and returns its return value.
	///// Supports <see cref="lastError"/>.
	///// </remarks>
	//public bool GetClientSize(out SIZE z) {
	//	if (Api.GetClientRect(this, out RECT r)) { z = new SIZE(r.right, r.bottom); return true; }
	//	z = default;
	//	return false;
	//}
	
	/// <summary>
	/// Gets client area rectangle (width and height) in screen.
	/// </summary>
	/// <remarks>
	/// Calls <see cref="GetClientRect"/>. Returns <c>default(RECT)</c> if fails (eg window closed).
	/// </remarks>
	public RECT ClientRectInScreen {
		get {
			GetClientRect(out RECT r, true);
			return r;
		}
	}
	
	///// <summary>
	///// Gets client area width and height.
	///// </summary>
	///// <remarks>
	///// The same as <see cref="ClientRect"/>, just the return type is different.
	///// Calls <see cref="GetClientSize"/>. Returns <c>default(SIZE)</c> if fails (eg window closed).
	///// </remarks>
	//public SIZE ClientSize {
	//	get {
	//		GetClientSize(out SIZE z);
	//		return z;
	//	}
	//}
	
	///// <summary>
	///// Gets client area width.
	///// </summary>
	///// <remarks>Calls <see cref="GetClientSize"/>.</remarks>
	//public int ClientWidth {
	//	get => ClientSize.width;
	//}
	
	///// <summary>
	///// Gets client area height.
	///// </summary>
	///// <remarks>Calls <see cref="GetClientSize"/>.</remarks>
	//public int ClientHeight {
	//	get => ClientSize.height;
	//}
	
	/// <summary>
	/// Resizes this window to match the specified client area size.
	/// Calls <see cref="ResizeL"/>.
	/// </summary>
	/// <param name="width">Client area width. Use <c>null</c> to not change.</param>
	/// <param name="height">Client area height. Use <c>null</c> to not change.</param>
	/// <exception cref="AuWndException"/>
	public void ResizeClient(int? width, int? height) {
		if (GetWindowInfo_(out var u)) {
			int W = width ?? u.rcClient.Width; W += u.rcWindow.Width - u.rcClient.Width;
			int H = height ?? u.rcClient.Height; H += u.rcWindow.Height - u.rcClient.Height;
			
			if (ResizeL(W, H)) return;
		}
		
		ThrowUseNative();
	}
	
	/// <summary>
	/// Calls API <ms>GetWindowInfo</ms>.
	/// </summary>
	/// <param name="wi">Receives window/client rectangles, styles etc.</param>
	/// <remarks>Supports <see cref="lastError"/>.</remarks>
	internal bool GetWindowInfo_(out Api.WINDOWINFO wi) {
		//initially this was public, but probably don't need.
		
		wi = default; wi.cbSize = Api.SizeOf(wi);
		return Api.GetWindowInfo(this, ref wi);
	}
	
	/// <summary>
	/// Gets window rectangle and client area rectangle, both in screen coordinates.
	/// </summary>
	/// <param name="rWindow">Receives window rectangle.</param>
	/// <param name="rClient">Receives client area rectangle.</param>
	/// <remarks>Calls API <ms>GetWindowInfo</ms>. Supports <see cref="lastError"/>.</remarks>
	public bool GetWindowAndClientRectInScreen(out RECT rWindow, out RECT rClient) {
		if (GetWindowInfo_(out var u)) {
			rWindow = u.rcWindow;
			rClient = u.rcClient;
			return true;
		}
		rWindow = default;
		rClient = default;
		return false;
	}
	
	//rejected: because now GetClientRect has 'inScreen' parameter.
	///// <summary>
	///// Gets client area rectangle in screen coordinates.
	///// </summary>
	///// <remarks>
	///// Calls <see cref="GetWindowAndClientRectInScreen"/>. Returns <c>default(RECT)</c> if fails (eg window closed).
	///// </remarks>
	//public RECT ClientRectInScreen
	//{
	//	get
	//	{
	//		GetWindowAndClientRectInScreen(out var rw, out var rc);
	//		return rc;
	//	}
	//}
	
	/// <summary>
	/// Converts coordinates relative to the client area of this window to coordinates relative to the client area of window <i>w</i>.
	/// </summary>
	/// <remarks>Supports <see cref="lastError"/>.</remarks>
	public bool MapClientToClientOf(wnd w, ref RECT r) => !Is0 && !w.Is0 && Api.MapWindowPoints(this, w, ref r, out _);
	
	/// <summary>
	/// Converts coordinates relative to the client area of this window to coordinates relative to the client area of window <i>w</i>.
	/// </summary>
	/// <remarks>Supports <see cref="lastError"/>.</remarks>
	public bool MapClientToClientOf(wnd w, ref POINT p) => !Is0 && !w.Is0 && Api.MapWindowPoints(this, w, ref p, out _);
	
	/// <summary>
	/// Converts coordinates relative to the client area of this window to coordinates relative to the screen.
	/// </summary>
	/// <remarks>Supports <see cref="lastError"/>.</remarks>
	public bool MapClientToScreen(ref RECT r) => !Is0 && Api.MapWindowPoints(this, default, ref r, out _);
	
	/// <summary>
	/// Converts coordinates relative to the client area of this window to coordinates relative to the screen.
	/// </summary>
	/// <remarks>Supports <see cref="lastError"/>.</remarks>
	public bool MapClientToScreen(ref POINT p) => Api.ClientToScreen(this, ref p);
	
	/// <summary>
	/// Converts coordinates relative to the screen to coordinates relative to the client area of this window.
	/// </summary>
	/// <remarks>Supports <see cref="lastError"/>.</remarks>
	public bool MapScreenToClient(ref RECT r) => !Is0 && Api.MapWindowPoints(default, this, ref r, out _);
	
	/// <summary>
	/// Converts coordinates relative to the screen to coordinates relative to the client area of this window.
	/// </summary>
	/// <remarks>Supports <see cref="lastError"/>.</remarks>
	public bool MapScreenToClient(ref POINT p) => Api.ScreenToClient(this, ref p);
	
	/// <summary>
	/// Converts coordinates relative to the client area of this window to coordinates relative to the top-left corner of this window.
	/// </summary>
	/// <remarks>Supports <see cref="lastError"/>.</remarks>
	public bool MapClientToWindow(ref POINT p) {
		if (!GetWindowAndClientRectInScreen(out var rw, out var rc)) return false;
		p.x += rc.left - rw.left; p.y += rc.top - rw.top;
		return true;
	}
	
	/// <summary>
	/// Converts coordinates relative to the client area of this window to coordinates relative to the top-left corner of this window.
	/// </summary>
	/// <remarks>Supports <see cref="lastError"/>.</remarks>
	public bool MapClientToWindow(ref RECT r) {
		if (!GetWindowAndClientRectInScreen(out var rw, out var rc)) return false;
		r.Offset(rc.left - rw.left, rc.top - rw.top);
		return true;
	}
	
	/// <summary>
	/// Converts coordinates relative to the top-left corner of this window to coordinates relative to the client area of this window.
	/// </summary>
	/// <remarks>Supports <see cref="lastError"/>.</remarks>
	public bool MapWindowToClient(ref POINT p) {
		if (!GetWindowAndClientRectInScreen(out var rw, out var rc)) return false;
		p.x += rw.left - rc.left; p.y += rw.top - rc.top;
		return true;
	}
	
	/// <summary>
	/// Converts coordinates relative to the top-left corner of this window to coordinates relative to the client area of this window.
	/// </summary>
	/// <remarks>Supports <see cref="lastError"/>.</remarks>
	public bool MapWindowToClient(ref RECT r) {
		if (!GetWindowAndClientRectInScreen(out var rw, out var rc)) return false;
		r.Offset(rw.left - rc.left, rw.top - rc.top);
		return true;
	}
	
	/// <summary>
	/// Converts coordinates relative to the top-left corner of this window to screen coordinates.
	/// </summary>
	/// <remarks>Supports <see cref="lastError"/>.</remarks>
	public bool MapWindowToScreen(ref POINT p) {
		if (!GetRect(out var rw)) return false;
		p.x += rw.left; p.y += rw.top;
		return true;
	}
	
	/// <summary>
	/// Converts coordinates relative to the top-left corner of this window to screen coordinates.
	/// </summary>
	/// <remarks>Supports <see cref="lastError"/>.</remarks>
	public bool MapWindowToScreen(ref RECT r) {
		if (!GetRect(out var rw)) return false;
		r.Offset(rw.left, rw.top);
		return true;
	}
	
	/// <summary>
	/// Gets rectangle of this window (usually control) relative to the client area of another window (usually parent).
	/// </summary>
	/// <param name="w">Parent, ancestor or any other window or control. If <c>default(wnd)</c>, gets rectangle in screen.</param>
	/// <param name="r">Receives the rectangle.</param>
	/// <remarks>Supports <see cref="lastError"/>.</remarks>
	/// <seealso cref="RectInDirectParent"/>
	/// <seealso cref="RectInWindow"/>
	public bool GetRectIn(wnd w, out RECT r) {
		if (w.Is0) return GetRect(out r);
		return GetRect(out r) && w.MapScreenToClient(ref r);
	}
	
	/// <summary>
	/// Gets child window rectangle in the client area of the direct parent window.
	/// </summary>
	/// <remarks>
	/// Calls <see cref="getwnd.DirectParent"/> and <see cref="GetRectIn"/>. Returns <c>default(RECT)</c> if fails (eg window closed).
	/// </remarks>
	public RECT RectInDirectParent => GetRectIn(Get.DirectParent, out var r) ? r : default;
	
	/// <summary>
	/// Gets child window rectangle in the client area of the top-level parent window.
	/// </summary>
	/// <remarks>
	/// Calls <see cref="Window"/> and <see cref="GetRectIn"/>. Returns <c>default(RECT)</c> if fails (eg window closed).
	/// </remarks>
	public RECT RectInWindow => GetRectIn(Window, out var r) ? r : default;
	
	/// <summary>
	/// Gets rectangle of normal (restored) window even if currently it is minimized or maximized.
	/// </summary>
	/// <remarks>Supports <see cref="lastError"/>.</remarks>
	public bool GetRectNotMinMax(out RECT r) {
		if (!(IsMinimized || IsMaximized)) return GetRect(out r);
		if (!GetWindowPlacement_(out var p, true)) { r = default; return false; }
		r = p.rcNormalPosition;
		return true;
	}
	
	//TEST: undocumented API GetWindowMinimizeRect. Gets rect of taskbar button or where it would be minimized above the Start button. But probably not useful.
	
	/// <summary>
	/// Returns mouse pointer position relative to the client area of this window.
	/// </summary>
	public POINT MouseClientXY {
		get {
			Api.GetCursorPos(out var p);
			if (!MapScreenToClient(ref p)) p = default;
			return p;
		}
	}
	
	/// <summary>
	/// Returns <c>true</c> if this window (its rectangle) contains the specified point.
	/// </summary>
	/// <param name="x">X coordinate in screen. Not used if <c>default</c>. Examples: <c>10</c>, <c>^10</c> (reverse), <c>.5f</c> (fraction).</param>
	/// <param name="y">Y coordinate in screen. Not used if <c>default</c>.</param>
	public bool ContainsScreenXY(Coord x, Coord y) {
		POINT p = Coord.Normalize(x, y);
		if (!GetRect(out RECT r)) return false;
		if (!r.Contains(x.IsEmpty ? r.left : p.x, y.IsEmpty ? r.top : p.y)) return false;
		return true;
		
		//note: we don't use name ContainsXY and 2 overloads, mostly because of possible incorrect usage. Also now easier to read the code.
	}
	
	/// <summary>
	/// Returns <c>true</c> if this control (its rectangle) contains the specified point in parent window.
	/// </summary>
	/// <param name="parent">
	/// Direct or indirect parent window. The coordinates are relative to its client area.
	/// Actually this and parent can be any windows or controls, the function does not check whether this is a child of parent.
	/// </param>
	/// <param name="x">X coordinate. Not used if <c>default</c>. Examples: <c>10</c>, <c>^10</c> (reverse), <c>.5f</c> (fraction).</param>
	/// <param name="y">Y coordinate. Not used if <c>default</c>.</param>
	public bool ContainsWindowXY(wnd parent, Coord x, Coord y) {
		if (!parent.IsAlive) return false;
		POINT p = Coord.NormalizeInWindow(x, y, parent);
		if (!GetRectIn(parent, out RECT r)) return false;
		if (!r.Contains(x.IsEmpty ? r.left : p.x, y.IsEmpty ? r.top : p.y)) return false;
		return true;
	}
	
	/// <summary>
	/// This overload calls <see cref="ContainsWindowXY(wnd, Coord, Coord)"/> with <see cref="Window"/>, <i>x</i> and <i>y</i>.
	/// </summary>
	/// <inheritdoc cref="ContainsWindowXY"/>
	public bool ContainsWindowXY(Coord x, Coord y) {
		return ContainsWindowXY(Window, x, y);
	}
	
	#endregion
	
	#region move, resize, SetWindowPos
	
	/// <summary>
	/// Calls API <ms>SetWindowPos</ms>.
	/// </summary>
	/// <param name="swpFlags"></param>
	/// <param name="x"></param>
	/// <param name="y"></param>
	/// <param name="cx"></param>
	/// <param name="cy"></param>
	/// <param name="zorderAfter">A window or a constant from <see cref="SpecHWND"/> (<c>TOP</c>, <c>BOTTOM</c>, <c>TOPMOST</c>, <c>NOTOPMOST</c>).</param>
	/// <remarks>
	/// Supports <see cref="lastError"/>.
	/// </remarks>
	public bool SetWindowPos(SWPFlags swpFlags, int x = 0, int y = 0, int cx = 0, int cy = 0, wnd zorderAfter = default) {
		return Api.SetWindowPos(this, zorderAfter, x, y, cx, cy, swpFlags);
	}
	
	/// <summary>
	/// Moves and resizes.
	/// </summary>
	/// <remarks>
	/// See also <see cref="Move(Coord, Coord, Coord, Coord, bool, screen, bool)"/>. It is better to use in automation scripts, with windows of any process/thread. It throws exceptions, supports optional/reverse/fractional/workarea coordinates, restores if min/max, does not support <c>SWP</c> flags.
	/// This function is more lightweight, it just calls API <ms>SetWindowPos</ms> with flags <c>NOZORDER|NOOWNERZORDER|NOACTIVATE|swpFlagsToAdd</c>. It is better to use in programming, with windows of current thread.
	/// Supports <see cref="lastError"/>.
	/// 
	/// For top-level windows use screen coordinates. For controls - direct parent client coordinates.
	/// </remarks>
	/// <seealso cref="SetWindowPos"/>
	public bool MoveL(int x, int y, int width, int height, SWPFlags swpFlagsToAdd = 0) {
		return SetWindowPos(SWPFlags.NOZORDER | SWPFlags.NOOWNERZORDER | SWPFlags.NOACTIVATE | swpFlagsToAdd, x, y, width, height);
	}
	
	/// <summary>
	/// Moves and resizes. Same as <see cref="MoveL(int, int, int, int, SWPFlags)"/>.
	/// </summary>
	/// <param name="visibleRect">Use the visible rectangle without the transparent frame. Note: the window should be visible. This parameter not used with child windows.</param>
	public bool MoveL(RECT r, SWPFlags swpFlagsToAdd = 0, bool visibleRect = false) {
		if (visibleRect && GetRect(out var rTrue) && GetRect(out var rVisible, withoutExtendedFrame: true) && rVisible != rTrue) {
			r.left -= rVisible.left - rTrue.left;
			r.top -= rVisible.top - rTrue.top;
			r.right += rTrue.right - rVisible.right;
			r.bottom += rTrue.bottom - rVisible.bottom;
		}
		
		return MoveL(r.left, r.top, r.Width, r.Height, swpFlagsToAdd);
	}
	
	/// <summary>
	/// Moves.
	/// </summary>
	/// <remarks>
	/// See also <see cref="Move(Coord, Coord, bool, screen, bool)"/>. It is better to use in automation scripts, with windows of any process/thread. It throws exceptions, supports optional/reverse/fractional/workarea coordinates, restores if min/max.
	/// This function is more lightweight, it just calls API <ms>SetWindowPos</ms> with flags <c>NOSIZE|NOZORDER|NOOWNERZORDER|NOACTIVATE</c>. It is better to use in programming, with windows of current thread.
	/// Supports <see cref="lastError"/>.
	/// 
	/// For top-level windows use screen coordinates. For controls - direct parent client coordinates.
	/// </remarks>
	/// <seealso cref="SetWindowPos"/>
	public bool MoveL(int x, int y) {
		return MoveL(x, y, 0, 0, SWPFlags.NOSIZE);
	}
	
	internal bool MoveL_(POINT p) => MoveL(p.x, p.y);
	
	/// <summary>
	/// Resizes.
	/// </summary>
	/// <remarks>
	/// See also <see cref="Resize(Coord, Coord, bool, screen, bool)"/>. It is better to use in automation scripts, with windows of any process/thread. It throws exceptions, supports optional/reverse/fractional/workarea coordinates, restores if min/max.
	/// This function is more lightweight, it just calls API <ms>SetWindowPos</ms> with flags <c>NOMOVE|NOZORDER|NOOWNERZORDER|NOACTIVATE</c>. It is better to use in programming, with windows of current thread.
	/// Supports <see cref="lastError"/>.
	/// </remarks>
	/// <seealso cref="SetWindowPos"/>
	public bool ResizeL(int width, int height) {
		return MoveL(0, 0, width, height, SWPFlags.NOMOVE);
	}
	
	internal bool ResizeL_(SIZE z) => ResizeL(z.width, z.height);
	
	/// <summary>
	/// Moves and/or resizes.
	/// </summary>
	/// <param name="x">Left. If <c>default</c>, does not move in X axis. Examples: <c>10</c>, <c>^10</c> (reverse), <c>.5f</c> (fraction).</param>
	/// <param name="y">Top. If <c>default</c>, does not move in Y axis.</param>
	/// <param name="width">Width. If <c>default</c>, does not change width.</param>
	/// <param name="height">Height. If <c>default</c>, does not change height.</param>
	/// <param name="workArea"><i>x y width height</i> are relative to the work area. This parameter not used with child windows.</param>
	/// <param name="screen"><i>x y width height</i> are relative to this screen or its work area. Default - primary. Example: <c>screen.index(1)</c>. This parameter not used with child windows.</param>
	/// <param name="visibleRect">Use the visible rectangle without the transparent frame. Note: the window should be visible. This parameter not used with child windows.</param>
	/// <exception cref="AuWndException"/>
	/// <remarks>
	/// Also restores the visible top-level window if it is minimized or maximized.
	/// For top-level windows use screen coordinates. For controls - direct parent client area coordinates.
	/// With windows of current thread usually it's better to use <see cref="MoveL"/>.
	/// </remarks>
	public void Move(Coord x, Coord y, Coord width, Coord height, bool workArea = false, screen screen = default, bool visibleRect = false) {
		ThrowIfInvalid();
		
		wnd w = Get.DirectParent;
		POINT xy, wh;
		if (!w.Is0) {
			xy = Coord.NormalizeInWindow(x, y, w);
			wh = Coord.NormalizeInWindow(width, height, w);
		} else {
			xy = Coord.Normalize(x, y, workArea, screen);
			wh = Coord.Normalize(width, height, workArea, screen, widthHeight: true);
		}
		
		SWPFlags f = 0; uint getRect = 0;
		if (x.IsEmpty && y.IsEmpty) f |= SWPFlags.NOMOVE; else if (x.IsEmpty) getRect |= 1; else if (y.IsEmpty) getRect |= 2;
		if (width.IsEmpty && height.IsEmpty) f |= SWPFlags.NOSIZE; else if (width.IsEmpty) getRect |= 4; else if (height.IsEmpty) getRect |= 8;
		
		if (getRect != 0) {
			if (!GetRectIn(w, out RECT r)) ThrowUseNative("*move/resize*");
			if ((getRect & 1) != 0) xy.x = r.left;
			if ((getRect & 2) != 0) xy.y = r.top;
			if ((getRect & 4) != 0) wh.x = r.Width;
			if ((getRect & 8) != 0) wh.y = r.Height;
		}
		
		//restore min/max, except if child or hidden
		if (w.Is0 && (IsMinimized || IsMaximized) && IsVisible) {
			ShowNotMinMax(1);
			//info: '&& IsVisible' because ShowNotMinMax unhides
		}
		
		if (visibleRect && GetRect(out var rTrue) && GetRect(out var rVisible, withoutExtendedFrame: true) && rVisible != rTrue) {
			int dx = rVisible.left - rTrue.left, dy = rVisible.top - rTrue.top;
			if (!x.IsEmpty) xy.x -= dx;
			if (!y.IsEmpty) xy.y -= dy;
			if (!width.IsEmpty) wh.x += rTrue.right - rVisible.right + dx;
			if (!height.IsEmpty) wh.y += rTrue.bottom - rVisible.bottom + dy;
		}
		
		if (!MoveL(xy.x, xy.y, wh.x, wh.y, f)) ThrowUseNative("*move/resize*");
		
		MinimalSleepIfOtherThread_();
	}
	
	/// <summary>
	/// Moves.
	/// </summary>
	/// <param name="workArea"><i>x y</i> are relative to the work area. This parameter not used with child windows.</param>
	/// <param name="screen"><i>x y</i> are relative to this screen or its work area. Default - primary. Example: <c>screen.index(1)</c>. This parameter not used with child windows.</param>
	/// <inheritdoc cref="Move(Coord, Coord, Coord, Coord, bool, screen, bool)"/>
	public void Move(Coord x, Coord y, bool workArea = false, screen screen = default, bool visibleRect = false) {
		Move(x, y, default, default, workArea, screen, visibleRect);
	}
	
	/// <summary>
	/// Resizes.
	/// </summary>
	/// <param name="width">Width. If <c>default</c>, does not change width.</param>
	/// <param name="height">Height. If <c>default</c>, does not change height.</param>
	/// <param name="workArea">For <see cref="Coord.Fraction"/> etc use width/height of the work area. This parameter not used with child windows.</param>
	/// <param name="screen">For <see cref="Coord.Fraction"/> etc use width/height of this screen. Default - primary. Example: <c>screen.index(1)</c>. This parameter not used with child windows.</param>
	/// <param name="visibleRect">Use the visible rectangle without the transparent frame. Note: the window should be visible. This parameter not used with child windows.</param>
	/// <exception cref="AuWndException"/>
	/// <remarks>
	/// Also restores the visible top-level window if it is minimized or maximized.
	/// With windows of current thread usually it's better to use <see cref="ResizeL(int, int)"/>.
	/// </remarks>
	public void Resize(Coord width, Coord height, bool workArea = false, screen screen = default, bool visibleRect = false) {
		Move(default, default, width, height, workArea, screen, visibleRect);
	}
	
	#endregion
	
	#region MoveInScreen, EnsureInScreen, Screen
	
	internal static partial class Internal_ {
		
		static void _MoveRect(ref RECT r, Coord left, Coord top, RECT rs, bool ensureIn, bool ensureMethod) {
			int x, y;
			if (ensureMethod) {
				Debug.Assert(ensureIn && left.IsEmpty && top.IsEmpty); //left/top unused
				x = r.left;
				y = r.top;
			} else {
				if (left.IsEmpty) left = Coord.Center;
				if (top.IsEmpty) top = Coord.Center;
				(x, y) = Coord.NormalizeInRect(left, top, rs);
				switch (left.Type) { case CoordType.Reverse: x -= r.Width; break; case CoordType.Fraction: x -= (int)(r.Width * left.FractionValue); break; }
				switch (top.Type) { case CoordType.Reverse: y -= r.Height; break; case CoordType.Fraction: y -= (int)(r.Height * top.FractionValue); break; }
			}
			
			if (ensureIn) {
				x = Math.Max(Math.Min(x, rs.right - r.Width), rs.left);
				y = Math.Max(Math.Min(y, rs.bottom - r.Height), rs.top);
				if (r.Width > rs.Width) r.Width = rs.Width;
				if (r.Height > rs.Height) r.Height = rs.Height;
			}
			
			r.Move(x, y);
		}
		
		public static void MoveRectInRect(ref RECT r, Coord left, Coord top, RECT rs, bool ensureIn) {
			_MoveRect(ref r, left, top, rs, ensureIn, false);
		}
		
		public static void MoveRectInScreen(bool ensureMethod, ref RECT r, Coord left, Coord top, screen screen, bool workArea, bool ensureIn) {
			var scr2 = !screen.IsEmpty ? screen.Now : ensureMethod ? screen.of(r) : screen.primary;
			var rs = scr2.GetRect(workArea);
			_MoveRect(ref r, left, top, rs, ensureIn, ensureMethod);
		}
		
		/// <summary>
		/// Moves <i>w</i> to <i>left top</i> in screen, and/or ensures it's in screen.
		/// </summary>
		/// <param name="ensureMethod">Just ensure in screen. Not used parameters: left, top.</param>
		/// <param name="w"></param>
		/// <param name="left">If empty, uses center.</param>
		/// <param name="top">If empty, uses center.</param>
		/// <param name="screen">If empty, uses screen of <i>w</i>.</param>
		/// <param name="workArea"></param>
		/// <param name="ensureIn"></param>
		public static void MoveWindowInScreen(bool ensureMethod, wnd w, Coord left, Coord top, screen screen, bool workArea, bool ensureIn) {
			var scr2 = !screen.IsEmpty ? screen.Now : screen.of(w);
			var rs = scr2.GetRect(workArea);
			var scr1 = screen.of(w);
			bool moveToOtherScreen = scr2 != scr1;
			
			bool isMaximized = w.IsMaximized, isMinimized = !isMaximized && w.IsMinimized;
			if (isMaximized || isMinimized) {
				bool visible = w.IsVisible;
				if (moveToOtherScreen) {
					bool restoreMaximized = false;
					if (isMinimized && w.GetWindowPlacement_(out var wp1, false, "*move*") && 0 != (wp1.flags & 2)) {
						wp1.flags &= ~2u;
						restoreMaximized = w.SetWindowPlacement_(ref wp1, false, "*move*");
					}
					Api.ShowWindow(w, Api.SW_SHOWNOACTIVATE); //less flickering than with SetWindowPlacement; same speed
					_Move();
					Api.ShowWindow(w, isMaximized ? Api.SW_SHOWMAXIMIZED : Api.SW_SHOWMINNOACTIVE);
					if (restoreMaximized && w.GetWindowPlacement_(out var wp2, false)) {
						wp2.flags |= 2;
						w.SetWindowPlacement_(ref wp2, false);
					}
					if (!visible) w.ShowL(false);
					
					//With SetWindowPlacement could avoid restoring and showing, but then does not resize for different DPI.
					//Also tested: temporarily remove WS_MAXIMIZE. With some windows does not work well, eg Firefox. Does not work with minimized. Dangerous, undocumented.
					
					//never mind: old Dreamweaver maximizes to the old screen. Need to repeat or before maximizing wait ~300 ms.
				} else {
					w.GetWindowPlacement_(out var wp, true, "*move*");
					_MoveRect(ref wp.rcNormalPosition, left, top, rs, ensureIn, ensureMethod);
					wp.showCmd = visible ? Api.SW_SHOWNA : Api.SW_HIDE;
					w.SetWindowPlacement_(ref wp, true, "*move*");
				}
				
				//would need this if using SetWindowPlacement when moving to other screen
				//if (isMaximized && moveToOtherScreen) {
				//	//When moved to screen's coordinates and sized to screen's work area size, OS adjusts window pos to be correct, ie border is outside screen, but invisible in adjacent screen.
				//	//Must call SetWindowPos twice, or it may refuse to move at all.
				//	//OS does this on Win+Shift+Left or Right.
				//	//Some windows does not respond well. Eg old Dreamweaver.
				//	//The biggest problem is DPI-scaling. Even the OS hotkey does not scale correctly (because the app does not have a chance to scale itself).
				//	rs = scr2.WorkArea;
				//	if (!w.MoveL(rs.left, rs.top) || !w.ResizeL(rs.Width, rs.Height)) w.ThrowUseNative("*move*");
				//}
			} else {
				_Move();
			}
			
			void _Move() {
				if (moveToOtherScreen) {
					int dpi1 = scr1.Dpi, dpi2 = scr2.Dpi;
					if (dpi2 != dpi1 || !ensureIn) {
						//resize w if would be too big for that screen. Because DPI may change if bigger part will be in another screen.
						int wid = rs.Width, hei = rs.Height;
						if (dpi2 != dpi1) { wid = Math2.MulDiv(wid, dpi1, dpi2); hei = Math2.MulDiv(hei, dpi1, dpi2); }
						var k = w.Rect;
						if (k.Width > wid || k.Height > hei) {
							w.ResizeL(Math.Min(k.Width, wid), Math.Min(k.Height, hei));
						}
					}
					if (dpi2 != dpi1) {
						//at first move to the screen, let it DPI-scale self. Some windows don't DPI-scale self when moving with resizing. Anyway would need to correct afterwards.
						w.MoveL(rs.left, rs.top);
					}
				}
				
				var r = w.Rect;
				_MoveRect(ref r, left, top, rs, ensureIn, ensureMethod);
				w.MoveL(r);
			}
			
			w.MinimalSleepIfOtherThread_();
		}
	}
	
	/// <summary>
	/// Moves this window to coordinates <i>x y</i> in specified screen, and ensures that entire window is in that screen.
	/// </summary>
	/// <param name="x">X coordinate in the specified screen. If <c>default</c> - screen center. Examples: <c>10</c>, <c>^10</c> (reverse), <c>.5f</c> (fraction).</param>
	/// <param name="y">Y coordinate in the specified screen. If <c>default</c> - screen center.</param>
	/// <param name="screen">Move to this screen (see <see cref="screen"/>). If default, uses screen of this window. Example: <c>screen.index(1)</c>.</param>
	/// <param name="workArea">Use the work area, not whole screen. Default <c>true</c>.</param>
	/// <param name="ensureInScreen">If part of window is not in screen, move and/or resize it so that entire window would be in screen. Default <c>true</c>.</param>
	/// <exception cref="AuWndException"/>
	/// <remarks>
	/// If the window is maximized, minimized or hidden, it will have the new position and size when restored, not immediately, except when moving maximized to another screen.
	/// </remarks>
	/// <seealso cref="RECT.MoveInScreen"/>
	public void MoveInScreen(Coord x, Coord y, screen screen = default, bool workArea = true, bool ensureInScreen = true) {
		Internal_.MoveWindowInScreen(false, this, x, y, screen, workArea, ensureInScreen);
	}
	
	/// <summary>
	/// Moves this window if need, to ensure that entire window is in that screen.
	/// </summary>
	/// <param name="screen">Move to this screen (see <see cref="screen"/>). If default, uses screen of this window.</param>
	/// <param name="workArea">Use the work area, not whole screen. Default <c>true</c>.</param>
	/// <exception cref="AuWndException"/>
	/// <remarks>
	/// If the window is maximized, minimized or hidden, it will have the new position and size when restored, not immediately.
	/// </remarks>
	/// <seealso cref="RECT.EnsureInScreen"/>
	public void EnsureInScreen(screen screen = default, bool workArea = true) {
		Internal_.MoveWindowInScreen(true, this, default, default, screen, workArea, true);
	}
	
	/// <summary>
	/// Moves this window to the center of the screen. Ensures that entire window is in that screen.
	/// </summary>
	/// <param name="screen">Move to this screen (see <see cref="screen"/>). If default, uses screen of this window.</param>
	/// <exception cref="AuWndException"/>
	/// <remarks>Calls <c>ShowNotMinMax(true)</c> and <c>MoveInScreen(default, default, screen, true)</c>. See <see cref="MoveInScreen"/>.</remarks>
	/// <seealso cref="RECT.MoveInScreen"/>
	public void MoveToScreenCenter(screen screen = default) {
		ShowNotMinMax();
		MoveInScreen(default, default, screen, true);
	}
	
	/// <summary>
	/// Gets <see cref="screen"/> of the screen that contains this window (the biggest part of it) or is nearest to it.
	/// If this window handle is <c>default(wnd)</c> or invalid, gets the primary screen.
	/// Calls <see cref="screen.of"/>.
	/// </summary>
	public screen Screen => screen.of(this);
	
	#endregion
	
	#region Zorder
	const SWPFlags _SWP_ZORDER_OWNER = SWPFlags.NOMOVE | SWPFlags.NOSIZE | SWPFlags.NOACTIVATE,
		_SWP_ZORDER_NOOWNER = SWPFlags.NOMOVE | SWPFlags.NOSIZE | SWPFlags.NOACTIVATE | SWPFlags.NOOWNERZORDER;
	//info: with SWP_NOOWNERZORDER the API does not zorder owner and owned windows.
	//note: without SWP_NOOWNERZORDER the API is full of bugs. Eg fails if the window has a topmost owned window.
	
	/// <summary>
	/// Calls <c>SetWindowPos</c> with zorder-only flags.
	/// Does not check owners etc.
	/// </summary>
	/// <param name="wAfter"></param>
	/// <param name="before">Call <c>wAfter = wAfter.Get.Previous();</c>.</param>
	/// <param name="noownerzorder">With <c>SWP_NOOWNERZORDER</c>.</param>
	/// <returns></returns>
	internal bool ZorderL_(wnd wAfter, bool before = false, bool noownerzorder = false) {
		if (before) {
			var w0 = wAfter;
			wAfter = wAfter.Get.Previous();
			if (wAfter == this) return true;
			if (wAfter.Is0 && !w0.IsAlive) return false;
		}
		return SetWindowPos(noownerzorder ? _SWP_ZORDER_NOOWNER : _SWP_ZORDER_OWNER, zorderAfter: wAfter);
	}
	
	/// <summary>
	/// Places this window above window <i>w</i> in the Z order.
	/// </summary>
	/// <param name="w">Another window.</param>
	/// <param name="ownerToo">Place owner windows below this window. If <c>false</c> (default), does it only if they otherwise would be on top of this window.</param>
	/// <remarks>
	/// This window and <i>w</i> can be both top-level windows or both controls of same parent.
	/// Can make this window topmost or non-topmost, depending on where <i>w</i> is in the Z order.
	/// Also affects owned and owner windows, but does not make them topmost/non-topmost if not necessary.
	/// Uses API <ms>SetWindowPos</ms>.
	/// Supports <see cref="lastError"/>.
	/// </remarks>
	public bool ZorderAbove(wnd w, bool ownerToo = false)
		=> _ZorderAB(w, true, ownerToo);
	
	/// <summary>
	/// Places this window below window <i>w</i> in the Z order.
	/// </summary>
	/// <param name="w">Another window. If <c>default(wnd)</c>, calls <see cref="ZorderTop"/>.</param>
	/// <inheritdoc cref="ZorderAbove(wnd, bool)"/>
	public bool ZorderBelow(wnd w, bool ownerToo = false)
		=> _ZorderAB(w, false, ownerToo);
	
	bool _ZorderAB(wnd w, bool before, bool ownerToo, bool top = false) {
		if (!top) {
			if (before || !w.Is0) {
				if (!w.IsAlive || w == this) return false;
				if (before) {
					g1: var wp = w.Get.Previous();
					if (wp.Is0 && !w.IsAlive) return false; //w is at the very top?
					w = wp;
					for (wnd ow = Get.Owner; !ow.Is0; ow = ow.Get.Owner) if (w == ow) goto g1;
				}
			}
		}
		if (IsChild) return SetWindowPos(_SWP_ZORDER_NOOWNER, zorderAfter: w);
		
		//All ZorderX functions work almost like SetWindowPos without SWP_NOOWNERZORDER should work as documented.
		//	However cannot simply call it because of its bugs.
		//	To simulate it, we zorder this and each owned/owner window with SWP_NOOWNERZORDER.
		//	The flag isn't well documented. With it zorders only this window; ignores owner and owned windows.
		//	Speed: 10% slower than SetWindowPos without SWP_NOOWNERZORDER.
		//	Still can't overcome this API bug: can't zorder above a topmost uiAccess window; also Start menu.
		
		var od = new getwnd.OwnedDescendants_();
		var all = od.all;
		int iLastTopmost = -1; for (int i = 0; i < all.Length && all[i].IsTopmost; i++) iLastTopmost = i;
		int iThis = Array.IndexOf(all, this);
		if (iThis < 0) return false;
		int iW = -1;
		if (top) { //make this the top window in the topmost or nontopmost group
			if (iThis > iLastTopmost && iLastTopmost >= 0) w = all[iW = iLastTopmost];
		} else if (!w.Is0) {
			iW = Array.IndexOf(all, w);
			if (iW < 0) return false;
		}
		bool wasTopmost = iThis <= iLastTopmost;
		bool willBeTopmost = iW < iLastTopmost || (iW == iLastTopmost && wasTopmost);
		
		//descendants
		bool skipTopmostOwned = !willBeTopmost && !wasTopmost;
		List<int> ai = od.GetIndices(this, skipTopmostOwned ? i => i <= iLastTopmost || i == iW : i => i == iW);
		ai.Add(iThis);
		
		//owners
		int iSkip = iThis;
		for (wnd ow = Get.Owner; !ow.Is0; ow = ow.Get.Owner) {
			int i2 = Array.IndexOf(all, ow);
			if (i2 < 0 || i2 == iW) break;
			if (willBeTopmost && i2 > iLastTopmost) break; //ignore nontopmost owners
			if (!ownerToo && i2 > iW) break; //don't zorder owners unless they would be on top of this
			List<int> ai2 = od.GetIndices(ow, i => i == iSkip || (!willBeTopmost && i <= iLastTopmost));
			ai.AddRange(ai2);
			ai.Add(iSkip = i2);
		}
		
		if (ai.Count == 1) return SetWindowPos(_SWP_ZORDER_NOOWNER, zorderAfter: w);
		
		//With DeferWindowPos faster and no flickering.
		//	But it's unreliable. Eg can't change topmost/notopmost.
		//	If fails, retry with SetWindowPos.
		
		bool dwpWillFail = willBeTopmost; //will fail if need to move above topmost uiAccess etc windows
		if (!dwpWillFail) { //will fail if need to change topmost/notopmost
			for (int i = 0; i < ai.Count; i++) { if (dwpWillFail = ai[i] <= iLastTopmost) break; }
		}
		
		var wPrev = w;
		if (!dwpWillFail) {
			var hp = Api.BeginDeferWindowPos(ai.Count);
			for (int i = 0; i < ai.Count; i++) {
				var k = all[ai[i]];
				hp = Api.DeferWindowPos(hp, k, wPrev, 0, 0, 0, 0, _SWP_ZORDER_NOOWNER);
				if (hp == default) break;
				wPrev = k;
			}
			if (hp != default) {
				Api.EndDeferWindowPos(hp); //usually returns true when fails
				wPrev = w;
				for (int i = 0; ;) {
					var k = all[ai[i]];
					if (k.Get.Previous() != wPrev) break;
					if (++i == ai.Count) return true;
					wPrev = k;
				}
			}
			Debug_.Print("DeferWindowPos failed");
			wPrev = w;
		}
		
		for (int i = 0; i < ai.Count; i++) {
			var k = all[ai[i]];
			bool ok = k.SetWindowPos(_SWP_ZORDER_NOOWNER, zorderAfter: wPrev);
			if (!ok) {
				if (k == this) return false;
				continue;
			}
			wPrev = k;
		}
		return true;
	}
	
	/// <summary>
	/// Places this window or control at the top of the Z order. Does not activate.
	/// If the window was topmost, it will be at the top of topmost windows, else at the top of other windows.
	/// </summary>
	/// <param name="ownerToo">Place owner windows below this window. If <c>false</c> (default), does it only if they otherwise would be on top of this window.</param>
	/// <remarks>
	/// Also affects owner and owned windows.
	/// Uses API <ms>SetWindowPos</ms>.
	/// Supports <see cref="lastError"/>.
	/// </remarks>
	public bool ZorderTop(bool ownerToo = false)
		=> _ZorderAB(default, false, ownerToo, top: true);
	
	/// <summary>
	/// Calls <c>SetWindowPos</c> with <c>HWND_TOP</c> and <c>SWP_NOOWNERZORDER</c> (ignores owner and owned windows).
	/// </summary>
	internal bool ZorderTopRaw_() {
		Debug_.PrintIf(!IsChild && !Get.EnabledOwned().Is0, "has owned windows: " + ToString());
		if (IsChild || IsTopmost || IsActive) return SetWindowPos(_SWP_ZORDER_NOOWNER);
		getwnd.top2(out var lastTopmost);
		return SetWindowPos(_SWP_ZORDER_NOOWNER, zorderAfter: lastTopmost);
	}
	
	/// <summary>
	/// Places this window or control at the bottom of the Z order.
	/// </summary>
	/// <remarks>
	/// Also affects owner and owned windows.
	/// If the window was topmost, makes it and its owner and owned windows non-topmost.
	/// Uses API <ms>SetWindowPos</ms>.
	/// Supports <see cref="lastError"/>.
	/// </remarks>
	public bool ZorderBottom() {
		return SetWindowPos(_SWP_ZORDER_OWNER, zorderAfter: SpecHWND.BOTTOM);
		//Bug in older Windows 10: the first HWND_BOTTOM moves a topmost window to the top of non-topmost windows.
	}
	
	/// <summary>
	/// Makes this window topmost (always on top of non-topmost windows in the Z order). Does not activate.
	/// </summary>
	/// <remarks>
	/// This cannot be a control.
	/// Also affects owned windows. Does not affect owners.
	/// Uses API <ms>SetWindowPos</ms>.
	/// Supports <see cref="lastError"/>.
	/// </remarks>
	public bool ZorderTopmost() {
		if (!SetWindowPos(_SWP_ZORDER_NOOWNER, zorderAfter: SpecHWND.TOPMOST)) return false;
		var a = Get.AllOwned(allDescendants: true);
		for (int i = a.Length; --i >= 0;) {
			a[i].SetWindowPos(_SWP_ZORDER_NOOWNER, zorderAfter: SpecHWND.TOPMOST);
		}
		return true;
		//note: cannot use without SWP_NOOWNERZORDER because of API bugs.
	}
	
	///
	[Obsolete, EditorBrowsable(EditorBrowsableState.Never)]
	public bool ZorderTopmost(bool ownerToo)
		=> (ownerToo ? Get.RootOwnerOrThis() : this).ZorderTopmost();
	
	/// <summary>
	/// Makes this window non-topmost.
	/// </summary>
	/// <param name="afterActiveWindow">Also place this window below the active non-topmost window in the Z order, unless the active window is this or owner.</param>
	/// <remarks>
	/// This cannot be a control.
	/// Also affects owner and owned windows.
	/// Uses API <ms>SetWindowPos</ms>.
	/// Supports <see cref="lastError"/>.
	/// </remarks>
	public bool ZorderNoTopmost(bool afterActiveWindow = false) {
		if (!IsTopmost) return IsAlive;
		if (afterActiveWindow) {
			wnd wa = active;
			if (wa != this && !wa.Is0 && !wa.IsTopmost && !Get.Owners().Contains(wa)) {
				if (SetWindowPos(_SWP_ZORDER_OWNER, zorderAfter: wa) && !IsTopmost) return true;
			}
		}
		return SetWindowPos(_SWP_ZORDER_OWNER, zorderAfter: SpecHWND.NOTOPMOST);
	}
	
	//Windows 7-10 bug: cannot make a topmost uiAccess window non-topmost (with HWND_NOTOPMOST, HWND_BOTTOM or non-topmost hwndInsertAfter).
	//	Workaround: call SWP 2 times. With some Windows updates also need SWP_NOOWNERZORDER.
	//	It seems it's fixed in current Win10.
	//Bug with SWP_NOOWNERZORDER: if used with non-uiAccess windows, then later HWND_TOPMOST does not work.
	//	It seems it's fixed in current Win10. Can reproduce on Win8.1.
	//More problems with topmost uiAccess windows:
	//	Can't insert a uiAccess window after a normal window.
	//	Problems with HWND_BOTTOM and owned windows.
	//	And so on. Possibly some now fixed.
	
	/// <summary>
	/// Returns <c>true</c> if this is a topmost (always-on-top) window.
	/// </summary>
	public bool IsTopmost => HasExStyle(WSE.TOPMOST);
	
	/// <summary>
	/// Returns <c>true</c> if this window is above window <i>w</i> in the Z order.
	/// </summary>
	public bool ZorderIsAbove(wnd w) {
		if (w.Is0) return false;
		for (wnd t = this; !t.Is0;) {
			t = Api.GetWindow(t, Api.GW_HWNDNEXT);
			if (t == w) return true;
		}
		return false;
	}
	
	#endregion
	
	#region style, exStyle
	
	/// <summary>
	/// Gets window style.
	/// </summary>
	/// <value>One or more <see cref="WS"/> flags and/or class-specific style flags. Reference: <ms>window styles</ms>.</value>
	/// <remarks>Supports <see cref="lastError"/>.</remarks>
	/// <seealso cref="HasStyle"/>
	/// <seealso cref="SetStyle"/>
	public WS Style {
		get => (WS)(uint)GetWindowLong(GWL.STYLE);
	}
	
	/// <summary>
	/// Gets window extended style.
	/// </summary>
	/// <value>One or more <see cref="WSE"/> flags. Reference: <ms>extended window styles</ms>.</value>
	/// <remarks>Supports <see cref="lastError"/>.</remarks>
	/// <seealso cref="HasExStyle"/>
	/// <seealso cref="SetExStyle"/>
	public WSE ExStyle {
		get => (WSE)(uint)GetWindowLong(GWL.EXSTYLE);
	}
	
	/// <summary>
	/// Returns <c>true</c> if the window has all specified style flags (see <see cref="Style"/>).
	/// </summary>
	/// <param name="style">One or more styles.</param>
	/// <param name="any">
	/// Return <c>true</c> if has any (not necessary all) of the specified styles.
	/// Note: don't use <see cref="WS.CAPTION"/>, because it consists of two other styles - <c>BORDER</c> and <c>DLGFRAME</c>.
	/// </param>
	/// <remarks>Supports <see cref="lastError"/>.</remarks>
	public bool HasStyle(WS style, bool any = false) {
		var k = Style & style;
		return any ? k != 0 : k == style;
	}
	
	/// <summary>
	/// Returns <c>true</c> if the window has all specified extended style flags (see <see cref="ExStyle"/>).
	/// </summary>
	/// <param name="exStyle">One or more extended styles.</param>
	/// <param name="any">Return <c>true</c> if has any (not necessary all) of the specified styles.</param>
	/// <remarks>Supports <see cref="lastError"/>.</remarks>
	public bool HasExStyle(WSE exStyle, bool any = false) {
		var k = ExStyle & exStyle;
		return any ? k != 0 : k == exStyle;
	}
	
	/// <summary>
	/// Changes window style.
	/// </summary>
	/// <param name="style">One or more <see cref="WS"/> flags and/or class-specific style flags. Reference: <ms>window styles</ms>.</param>
	/// <param name="flags"></param>
	/// <returns>Previous value.</returns>
	/// <exception cref="AuWndException"/>
	/// <seealso cref="Style"/>
	public WS SetStyle(WS style, WSFlags flags = 0)
		=> (WS)_SetStyle(false, (int)style, flags);
	
	/// <summary>
	/// Changes window extended style.
	/// </summary>
	/// <param name="style">One or more <see cref="WSE"/> flags. Reference: <ms>extended window styles</ms>.</param>
	/// <param name="flags"></param>
	/// <returns>Previous value.</returns>
	/// <exception cref="AuWndException"/>
	/// <seealso cref="ExStyle"/>
	public WSE SetExStyle(WSE style, WSFlags flags = 0)
		=> (WSE)_SetStyle(true, (int)style, flags);
	
	nint _SetStyle(bool ex, int style, WSFlags flags) {
		var gwl = ex ? GWL.EXSTYLE : GWL.STYLE;
		switch (flags & (WSFlags.Add | WSFlags.Remove)) {
		case WSFlags.Add: style = (int)GetWindowLong(gwl) | style; break;
		case WSFlags.Remove: style = (int)GetWindowLong(gwl) & ~style; break;
		}
		nint R = SetWindowLong(gwl, style, noException: flags.Has(WSFlags.NoException));
		
		if (flags.Has(WSFlags.UpdateNonclient)) SetWindowPos(SWPFlags.FRAMECHANGED | SWPFlags.NOMOVE | SWPFlags.NOSIZE | SWPFlags.NOZORDER | SWPFlags.NOOWNERZORDER | SWPFlags.NOACTIVATE);
		if (flags.Has(WSFlags.UpdateClient)) Api.InvalidateRect(this, true);
		
		return R;
	}
	
	/// <summary>
	/// Returns <c>true</c> if has <see cref="WS.POPUP"/> style.
	/// </summary>
	/// <remarks>Supports <see cref="lastError"/>.</remarks>
	public bool IsPopupWindow => HasStyle(WS.POPUP);
	
	/// <summary>
	/// Returns <c>true</c> if has <see cref="WSE.TOOLWINDOW"/> style.
	/// </summary>
	/// <remarks>Supports <see cref="lastError"/>.</remarks>
	public bool IsToolWindow => HasExStyle(WSE.TOOLWINDOW);
	
	/// <summary>
	/// Returns <c>true</c> if has <see cref="WS.THICKFRAME"/> style.
	/// </summary>
	/// <remarks>Supports <see cref="lastError"/>.</remarks>
	public bool IsResizable => HasStyle(WS.THICKFRAME);
	
	#endregion
	
	#region window/class long, control id, prop
	
	/// <summary>
	/// Calls API <ms>GetWindowLongPtr</ms>.
	/// </summary>
	/// <param name="index">A constant from <see cref="GWL"/>, or an offset in window memory reserved when registering window class.</param>
	/// <remarks>
	/// Supports <see cref="lastError"/>.
	/// In 32-bit process actually calls <c>GetWindowLong</c>, because <c>GetWindowLongPtr</c> is unavailable.
	/// </remarks>
	public nint GetWindowLong(int index) => Api.GetWindowLongPtr(this, index);
	
	/// <summary>
	/// Calls API <ms>SetWindowLongPtr</ms>.
	/// </summary>
	/// <param name="index">A constant from <see cref="GWL"/>, or an offset in window memory reserved when registering window class.</param>
	/// <param name="newValue">New value.</param>
	/// <param name="noException">Don't throw exception when fails.</param>
	/// <returns>Previous value. If fails and <i>noException</i> <c>true</c>, returns 0, and can be used <see cref="lastError"/>.</returns>
	/// <exception cref="AuWndException"/>
	/// <remarks>
	/// See also API <ms>SetWindowSubclass</ms>.
	/// </remarks>
	public nint SetWindowLong(int index, nint newValue, bool noException = false) {
		lastError.clear();
		var prev = Api.SetWindowLongPtr(this, index, newValue);
		if (prev == 0 && !noException) {
			var e = lastError.code;
			if (e != 0 && (Api.GetWindowLongPtr(this, index) != newValue || !IsAlive)) ThrowUseNative(e);
			//if GWL_HWNDPARENT(0), last error "invalid window handle"
		}
		return prev;
	}
	
	/// <summary>
	/// Gets or sets id of this control.
	/// The <c>get</c> function supports <see cref="lastError"/>.
	/// </summary>
	/// <exception cref="AuWndException">The <c>set</c> function failed.</exception>
	public int ControlId {
		get => Api.GetDlgCtrlID(this);
		set { SetWindowLong(GWL.ID, value); }
	}
	
	/// <summary>
	/// Returns an object that manages window properties using API <ms>SetProp</ms> and co.
	/// </summary>
	/// <example>
	/// <code><![CDATA[
	/// var w = wnd.find("* Explorer");
	/// w.Prop.Set("example", 5);
	/// print.it(w.Prop["example"]);
	/// print.it(w.Prop); //all w properties
	/// w.Prop.Remove("example"); //you should always remove window properties if don't want to see unrelated applications crashing after some time. And don't use many unique property names.
	/// ]]></code>
	/// </example>
	public WProp Prop => new(this);
	
	/// <summary>
	/// Returns an object that manages the taskbar button of this window: flash, progress, add/delete.
	/// </summary>
	/// <example>
	/// <code><![CDATA[
	/// var w = wnd.find(0, "*Notepad", "Notepad");
	/// w.TaskbarButton.Delete();
	/// ]]></code>
	/// </example>
	public WTaskbarButton TaskbarButton => new(this);
	
	#endregion
	
	#region thread, process, is Unicode, is 64-bit, is hung/ghost, is console, UAC, is message-only
	
	/// <summary>
	/// Gets native thread id and process id of this window.
	/// Calls API <ms>GetWindowThreadProcessId</ms>.
	/// </summary>
	/// <returns>Thread id, or 0 if failed. Supports <see cref="lastError"/>.</returns>
	/// <remarks>
	/// It is not the same as <see cref="Environment.CurrentManagedThreadId"/>.
	/// </remarks>
	public unsafe int GetThreadProcessId(out int processId) {
		int pid = 0, tid = Api.GetWindowThreadProcessId(this, &pid);
		processId = pid;
		return tid;
	}
	
	/// <summary>
	/// Gets native thread id of this window. Calls API <ms>GetWindowThreadProcessId</ms>.
	/// </summary>
	/// <returns>0 if failed. Supports <see cref="lastError"/>.</returns>
	/// <remarks>
	/// It is not the same as <see cref="Environment.CurrentManagedThreadId"/>.
	/// </remarks>
	public int ThreadId => Api.GetWindowThreadProcessId(this, null); //2 times faster when pid null
	
	/// <summary>
	/// Gets native process id of this window. Calls API <ms>GetWindowThreadProcessId</ms>.
	/// </summary>
	/// <returns>0 if failed. Supports <see cref="lastError"/>.</returns>
	public int ProcessId { get { GetThreadProcessId(out var pid); return pid; } }
	
	/// <summary>
	/// Returns <c>true</c> if this window belongs to the current thread, <c>false</c> if to another thread.
	/// Also returns <c>false</c> when fails (probably window closed or 0 handle). Supports <see cref="lastError"/>.
	/// Calls API <ms>GetWindowThreadProcessId</ms>.
	/// </summary>
	public bool IsOfThisThread => Api.GetCurrentThreadId() == ThreadId;
	
	/// <summary>
	/// Returns <c>true</c> if this window belongs to the current process, <c>false</c> if to another process.
	/// Also returns <c>false</c> when fails (probably window closed or 0 handle). Supports <see cref="lastError"/>.
	/// Calls API <ms>GetWindowThreadProcessId</ms>.
	/// </summary>
	public bool IsOfThisProcess => Api.GetCurrentProcessId() == ProcessId;
	
	/// <summary>
	/// Returns <c>true</c> if the window is a Unicode window, <c>false</c> if ANSI.
	/// Also returns <c>false</c> when fails (probably window closed or 0 handle). Supports <see cref="lastError"/>.
	/// Calls API <ms>IsWindowUnicode</ms>.
	/// </summary>
	public bool IsUnicode => Api.IsWindowUnicode(this);
	
	/// <summary>
	/// Returns <c>true</c> if the window is of a 32-bit process, <c>false</c> if of a 64-bit process.
	/// Also returns <c>false</c> if failed. Supports <see cref="lastError"/>.
	/// </summary>
	/// <remarks>
	/// <note>If you know that the window belongs to current process, instead use <see cref="osVersion"/> functions or <c>IntPtr.Size==4</c>. This function is much slower.</note>
	/// </remarks>
	public bool Is32Bit => process.is32Bit(ProcessId);
	
	/// <summary>
	/// Returns <c>true</c> if thread of this window is considered hung (not responding).
	/// Calls API <ms>IsHungAppWindow</ms>.
	/// </summary>
	/// <remarks>Supports <see cref="lastError"/>.</remarks>
	public bool IsHung => Api.IsHungAppWindow(this);
	
	/// <summary>
	/// Returns <c>true</c> if the window is a ghost window that the system creates over a hung (not responding) window to allow the user to minimally interact with it.
	/// </summary>
	public bool IsHungGhost {
		get => IsHung && ClassNameIs("Ghost") && ProgramName.Eqi("DWM.exe");
		//Class is "Ghost", exe is "DWM" (even if no Aero), text sometimes ends with "(Not Responding)".
		//IsHungWindow returns true for ghost window, although it is not actually hung. It is the fastest.
		//TEST: undocumented API HungWindowFromGhostWindow
	}
	
	/// <summary>
	/// Returns <c>true</c> if this is a console window (class name <c>"ConsoleWindowClass"</c>).
	/// </summary>
	/// <remarks>Supports <see cref="lastError"/>.</remarks>
	public bool IsConsole => ClassNameIs("ConsoleWindowClass");
	
	//FUTURE: GetConsoleText. See QM2.
	
	internal void UacCheckAndThrow_(string prefix = null) {
		if (!Is0 && UacAccessDenied) {
			if (prefix == null) prefix = "Failed. The"; else if (prefix.Ends('.')) prefix += " The"; //this is to support prefix used by mouse.move: "The active"
			throw new AuException(Api.ERROR_ACCESS_DENIED, prefix + " window's process has a higher UAC integrity level (admin or uiAccess) than this process.");
		}
	}
	
	/// <summary>
	/// Gets UAC info of the process.
	/// </summary>
	public uacInfo Uac => uacInfo.ofProcess(ProcessId);
	
	/// <summary>
	/// Returns <c>true</c> if [](xref:uac) would not allow to automate the window.
	/// It happens when current process has lower UAC integrity level and is not uiAccess, unless UAC is turned off.
	/// </summary>
	/// <remarks>Supports <see cref="lastError"/>.</remarks>
	public bool UacAccessDenied {
		get {
			if (uacInfo.isAdmin) return false;
			lastError.clear();
			//Api.RemoveProp(this, 0); //documented ERROR_ACCESS_DENIED, and used to work, but on latest Win10 GetLastError always returns 0.
			Api.SetWindowLongPtr(this, -1111, 0); //ERROR_INVALID_INDEX or ERROR_ACCESS_DENIED
			return lastError.code == Api.ERROR_ACCESS_DENIED;
		}
	}
	
	//These are not useful. Use UacAccessDenied or class uacInfo.
	///// <summary>
	///// Gets UAC integrity level of window's process.
	///// Returns <c>UacIL.Unknown</c> if failed.
	///// This function considers <c>UIAccess</c> equal to <c>High</c>.
	///// See also: class <see cref="uacInfo"/>.
	///// </summary>
	//public UacIL UacIntegrityLevel
	//{
	//	get { var p = uacInfo.ofProcess(ProcessId); return p == null ? UacIL.Unknown : p.IntegrityLevel; }
	//}
	
	///// <summary>
	///// Returns <c>true</c> if window's process has higher UAC integrity level (IL) than current process.
	///// Returns <c>true</c> if fails to open process handle, which usually means that the process has higher integrity level.
	///// This function considers <c>UIAccess</c> equal to <c>High</c>.
	///// See also: class <see cref="uacInfo"/>.
	///// </summary>
	//public bool UacIntegrityLevelIsHigher
	//{
	//	get => UacIntegrityLevel > uacInfo.ofThisProcess.IntegrityLevel;
	//}
	
	/// <summary>
	/// Returns <c>true</c> if this is a <ms>message-only window</ms>.
	/// </summary>
	/// <remarks>
	/// To find message-only windows use <see cref="findFast"/>.
	/// </remarks>
	public bool IsMessageOnly {
		get {
			var t = HasStyle(WS.CHILD) ? Window : this;
			var v = t.ParentGWL_;
			if (v != default) {
				if (!s_messageOnlyParent.IsAlive) {
					for (int i = 0; i < 5; i++) {
						var w = findFast(null, null, true); //find a message-only window
						if (w.Is0) return false; //if there are no message-only windows, this window isn't message only
						w = w.ParentGWL_;
						if (!w.Is0) { s_messageOnlyParent = w; break; } //if 0, either w destroyed/reparented or GetWindowLong(GWL_HWNDPARENT) always returns 0 on this OS version
					}
					Debug.Assert(!s_messageOnlyParent.Is0);
				}
				return v == s_messageOnlyParent;
			}
			return false;
		}
	}
	static wnd s_messageOnlyParent;
	
	#endregion
	
	#region text, class, program
	
	/// <summary>
	/// Gets window class name.
	/// </summary>
	/// <returns><c>null</c> if failed, eg if the window is closed. Supports <see cref="lastError"/>.</returns>
	[SkipLocalsInit]
	public string ClassName {
		get {
			var b = stackalloc char[260];
			int n = Api.GetClassName(this, b, 260);
			if (n == 0) return null;
			return new string(b, 0, n);
		}
	}
	
	/// <summary>
	/// Returns <c>true</c> if the class name of this window matches <i>cn</i>. Else returns <c>false</c>.
	/// Also returns <c>false</c> when fails (probably window closed or 0 handle). Supports <see cref="lastError"/>.
	/// </summary>
	/// <param name="cn">Class name. Case-insensitive wildcard. See <see cref="ExtString.Like(string, string, bool)"/>. Cannot be <c>null</c>.</param>
	/// <seealso cref="IsMatch"/>
	public bool ClassNameIs(string cn) => ClassName.Like(cn, true);
	
	/// <summary>
	/// If window class name matches one of strings in <i>classNames</i>, returns 1-based string index. Else returns 0.
	/// Also returns 0 if fails to get class name (probably window closed or 0 handle). Supports <see cref="lastError"/>.
	/// </summary>
	/// <param name="classNames">Class names. Case-insensitive wildcard. See <see cref="ExtString.Like(string, string, bool)"/>. The array and strings cannot be <c>null</c>.</param>
	public int ClassNameIs(params ReadOnlySpan<string> classNames) {
		string s = ClassName; if (s == null) return 0;
		return s.Like(true, classNames);
	}
	
	/// <summary>
	/// Gets name.
	/// </summary>
	/// <returns>Returns <c>""</c> if no name. Returns <c>null</c> if failed, eg if the window is closed. Supports <see cref="lastError"/>.</returns>
	/// <remarks>
	/// Top-level window name usually its title bar text.
	/// Control name usually is its text that does not change, for example button or static (label) control text.
	/// Unlike <see cref="ControlText"/>, this function usually does not get variable text, for example Edit control editable text, combo box control selected item text, status bar text.
	/// Calls <see cref="GetText"/><c>(false, true)</c>.
	/// </remarks>
	/// <seealso cref="SetText"/>
	/// <seealso cref="ControlText"/>
	/// <seealso cref="NameElm"/>
	/// <seealso cref="NameWinforms"/>
	public string Name => GetText(false, true);
	
	/// <summary>
	/// If window name matches one of strings in <i>names</i>, returns 1-based string index. Else returns 0.
	/// Also returns 0 if fails to get name (probably window closed or 0 handle). Supports <see cref="lastError"/>.
	/// </summary>
	/// <param name="names">Window names. Case-insensitive wildcard. See <see cref="ExtString.Like(string, string, bool)"/>. The array and strings cannot be <c>null</c>.</param>
	public int NameIs(params ReadOnlySpan<string> names) {
		string s = Name; if (s == null) return 0;
		return s.Like(true, names);
	}
	
	/// <summary>
	/// Gets window name using API <c>InternalGetWindowText</c>. The same as <c>GetText(false, false)</c>.
	/// This should be a top-level window, because does not process ampersands.
	/// </summary>
	internal string NameTL_ => _GetTextFast(false);
	
	/// <summary>
	/// Gets control text.
	/// </summary>
	/// <returns>Returns <c>""</c> if no text. Returns <c>null</c> if failed, eg if the window is closed. Supports <see cref="lastError"/>.</returns>
	/// <remarks>
	/// Unlike <see cref="Name"/>, this function prefers variable text, for example Edit control text, combo box selected item text, status bar text.
	/// For controls that cannot have such text (eg button, static), it usually gets the same text as <c>Name</c>. For example button and static (label) controls.
	/// Much slower than <c>Name</c>. Fails if the window is hung.
	/// Calls <see cref="GetText"/><c>(true, false)</c>.
	/// </remarks>
	/// <seealso cref="SetText"/>
	/// <seealso cref="Name"/>
	public string ControlText => GetText(true, false);
	
	/// <summary>
	/// Gets window/control name or control text.
	/// This is a low-level function. You can instead use <see cref="Name"/> and <see cref="ControlText"/>.
	/// </summary>
	/// <returns>Returns <c>""</c> if no text. Returns <c>null</c> if failed, eg if the window is closed. Supports <see cref="lastError"/>.</returns>
	/// <param name="getText">
	/// How to get text:
	/// <br/>• <c>false</c> - use API <ms>InternalGetWindowText</ms>. This is used by <see cref="Name"/>.
	/// <br/>• <c>true</c> - use API <ms>WM_GETTEXT</ms>. It is slow and prefers editable text. This is used by <see cref="ControlText"/>. Fails if the window is hung.
	/// <br/>• <c>null</c> - try <c>InternalGetWindowText</c>. If it gets <c>""</c> and this is a control, then try <c>WM_GETTEXT</c>.
	/// </param>
	/// <param name="removeUnderlineAmpersand">
	/// Remove the invisible <c>'&amp;'</c> characters that are used to underline keyboard shortcuts with the <c>Alt</c> key.
	/// Removes only if this is a control (has style <see cref="WS.CHILD"/>).
	/// Calls <see cref="StringUtil.RemoveUnderlineChar"/>.
	/// </param>
	/// <seealso cref="SetText"/>
	/// <seealso cref="NameElm"/>
	/// <seealso cref="NameWinforms"/>
	public string GetText(bool? getText = null, bool removeUnderlineAmpersand = true) {
		var R = getText switch { true => _GetTextSlow(), false => _GetTextFast(false), _ => _GetTextFast(true) };
		
		if (removeUnderlineAmpersand
			&& !R.NE()
			//&& R.Contains('&') //slower than HasStyle if the string is longer than 20
			&& HasStyle(WS.CHILD)
			) R = StringUtil.RemoveUnderlineChar(R);
		
		return R;
	}
	
	/// <summary>
	/// Gets text.
	/// Returns <c>""</c> if it is empty.
	/// Calls API <ms>InternalGetWindowText</ms>. If it fails, and <c>getControlTextIfEmpty</c>==<c>true</c>, and this is a control, calls <c>_GetTextSlow</c>, which uses <c>WM_GETTEXT</c>.
	/// </summary>
	/// <returns><c>null</c> if failed, eg if the control is destroyed or its thread is hung. Supports <see cref="lastError"/>.</returns>
	[SkipLocalsInit]
	string _GetTextFast(bool useSlowIfEmpty) {
		if (Is0) { lastError.code = Api.ERROR_INVALID_WINDOW_HANDLE; return null; } //return early. Used in properties of wnd and other types. They can be called not explicitly from code, eg by debugger, record.ToString(), etc. Eg a record may have a property of wnd type, and it may be 0 (it's valid).
		using FastBuffer<char> b = new();
		for (; ; b.More()) {
			lastError.clear();
			int nr = Api.InternalGetWindowText(this, b.p, b.n);
			if (nr < b.n - 1) {
				if (nr > 0) return new string(b.p, 0, nr);
				if (lastError.code != 0) return null;
				if (useSlowIfEmpty && HasStyle(WS.CHILD)) return _GetTextSlow();
				return "";
			}
		}
	}
	
	/// <summary>
	/// Gets text.
	/// Returns <c>""</c> if it is empty.
	/// Uses <c>WM_GETTEXT</c>.
	/// </summary>
	/// <returns><c>null</c> if failed, eg if the control is destroyed or its thread is hung. Supports <see cref="lastError"/>.</returns>
	[SkipLocalsInit]
	string _GetTextSlow() {
		if (Is0) { lastError.code = Api.ERROR_INVALID_WINDOW_HANDLE; return null; }
		if (!SendTimeout(5000, out nint n, Api.WM_GETTEXTLENGTH)) return null;
		if (n < 1) return "";
		
		using FastBuffer<char> b = new((int)n + 1);
		if (!SendTimeout(30000, out n, Api.WM_GETTEXT, b.n, b.p)) return null;
		if (n < 1) return "";
		b.p[n] = '\0';
		return b.GetStringFindLength(); //info: some controls return incorrect n, eg including '\0'
		
		//note: cannot do this optimization:
		//	At first allocate stack memory and send WM_GETTEXT without WM_GETTEXTLENGTH. Then use WM_GETTEXTLENGTH/WM_GETTEXT if returned size is buffer length - 1.
		//	It works with most controls, but some controls return 0 if buffer is too small. Eg SysLink. The WM_GETTEXT documentation does not say what should happen when buffer is too small.
		//	The speed is important for wnd.Child().
		//	It is ~30% faster when all controls have text, but not much if called for many controls that don't have text (then we don't use WM_GETTEXT).
	}
	
	/// <summary>
	/// Sets window/control name or control text.
	/// </summary>
	/// <param name="text">Text. Can be <c>null</c>, it is the same as <c>""</c>.</param>
	/// <remarks>
	/// Uses API <ms>WM_SETTEXT</ms>.
	/// Top-level window name usually its title bar text.
	/// For variable-text controls (edit, combo box, status bar, ...) this usually is the text that <see cref="ControlText"/> would get.
	/// For other controls (button, static, ...) and top-level windows this usually is the text that <see cref="Name"/> would get.
	/// </remarks>
	/// <exception cref="AuWndException">Failed, for example the window is closed.</exception>
	/// <seealso cref="GetText"/>
	/// <seealso cref="Name"/>
	/// <seealso cref="ControlText"/>
	public void SetText(string text) {
		if (!SendTimeout(30000, out var _, Api.WM_SETTEXT, 0, text ?? "", 0)) ThrowUseNative();
	}
	
	//rejected: faster but not better than NameElm. Or must be improved.
	//	Instead, let Child find label control, and then navigate with Get.Right() etc.
	///// <summary>
	///// Gets <see cref="Name"/> of previous (in Z order) sibling control.
	///// Returns <c>null</c> if there is no such control.
	///// </summary>
	///// <remarks>
	///// Can be used to identify controls that have no name but have a named control (label) at the left or above. For example <c>Edit</c> and <c>ComboBox</c> controls in dialogs.
	///// In such cases this function works like <see cref="NameElm"/>, but is faster and supports any sibling control type.
	///// </remarks>
	//public string NameLabel
	//{
	//	get
	//	{
	//		for(var w = this; ;) {
	//			var p = w.Get.DirectParent;
	//			if(p.Is0) return null;
	//			w = w.Get.Previous(); if(!w.Is0) return w.Name;
	//			w = p;
	//		}
	//		//_todo: if the label control is not at the left/above, find topmost control at the left/above
	//	}
	//}
	
	/// <summary>
	/// Gets <see cref="elm.Name"/> of the UI element (role <c>WINDOW</c>) of this window or control.
	/// </summary>
	/// <returns>Returns <c>""</c> if the object has no name or failed to get it. Returns <c>null</c> if invalid window handle.</returns>
	public string NameElm => elm.NameOfWindow_(this);
	
	/// <summary>
	/// Gets the <see cref="System.Windows.Forms.Control.Name"/> property value of a .NET Windows Forms control.
	/// </summary>
	/// <returns><c>null</c> if it is not a Windows Forms control or if failed.</returns>
	/// <remarks>
	/// <note>Use this with controls of other processes. Don't use with your controls, when you have a <c>Control</c> object.</note>
	/// 
	/// <note>Slow when getting names of multiple controls in a window. Instead create a <see cref="WinformsControlNames"/> instance and call its <see cref="WinformsControlNames.GetControlName"/> method for each control.</note>
	/// </remarks>
	/// <seealso cref="WinformsControlNames.IsWinformsControl"/>
	public string NameWinforms => WinformsControlNames.GetSingleControlName(this);
	
	/// <summary>
	/// Gets filename of process executable file, like <c>"notepad.exe"</c>.
	/// </summary>
	/// <returns><c>null</c> if failed.</returns>
	/// <remarks>
	/// Calls <see cref="ProcessId"/> and <see cref="process.getName"/>.
	/// This function is much slower than getting window name or class name. Don't use code like <c>if(w.ProgramName=="A" || w.ProgramName=="B")</c>. Instead use <c>var s=w.ProgramName; if(s=="A" || s=="B")</c>.
	/// </remarks>
	public string ProgramName => process.GetNameCached_(this, ProcessId);
	
	/// <summary>
	/// If window program name matches one of strings in <i>programNames</i>, returns 1-based string index. Else returns 0.
	/// Also returns 0 if fails to get program name (probably window closed or 0 handle). Supports <see cref="lastError"/>.
	/// </summary>
	/// <param name="programNames">Program names, like <c>"notepad.exe"</c>. Case-insensitive wildcard. See <see cref="ExtString.Like(string, string, bool)"/>. The array and strings cannot be <c>null</c>.</param>
	public int ProgramNameIs(params ReadOnlySpan<string> programNames) {
		string s = ProgramName; if (s == null) return 0;
		return s.Like(true, programNames);
	}
	
	/// <summary>
	/// Gets full path of process executable file.
	/// </summary>
	/// <returns><c>null</c> if failed.</returns>
	/// <remarks>
	/// Calls <see cref="ProcessId"/> and <see cref="process.getName"/>.
	/// This function is much slower than getting window name or class name. Don't use code like <c>if(w.ProgramPath=="A" || w.ProgramPath=="B")</c>. Instead use <c>var s=w.ProgramPath; if(s=="A" || s=="B")</c>.
	/// </remarks>
	public string ProgramPath => process.GetNameCached_(this, ProcessId, true);
	
	/// <summary>
	/// Gets description of process executable file.
	/// </summary>
	/// <returns><c>null</c> if failed.</returns>
	/// <remarks>
	/// Calls <see cref="ProcessId"/> and <see cref="process.getDescription"/>.
	/// This function is slow. Much slower than <see cref="ProgramName"/>.
	/// </remarks>
	public string ProgramDescription => process.getDescription(ProcessId);
	
	#endregion
	
	#region close, destroy
	
	/// <summary>
	/// Closes the window.
	/// </summary>
	/// <returns><c>true</c> if successfully closed or if it was already closed (the handle is 0 or invalid) or if <i>noWait</i>==<c>true</c>.</returns>
	/// <param name="noWait">
	/// If <c>true</c>, does not wait until the window is closed.
	/// If <c>false</c>, waits about 1 s (depends on window type etc) until the window is destroyed or disabled.
	/// </param>
	/// <param name="useXButton">
	/// If <c>false</c> (default), uses API message <ms>WM_CLOSE</ms>.
	/// If <c>true</c>, uses API message <ms>WM_SYSCOMMAND SC_CLOSE</ms>, like when the user clicks the <c>X</c> button in the title bar.
	/// Most windows can be closed with any of these messages, but some respond properly only to one of them. For example, some applications on <c>WM_CLOSE</c> don't exit, although the main window is closed. Some applications don't respond to <c>WM_SYSCOMMAND</c> if it is posted soon after opening the window.
	/// </param>
	/// <remarks>
	/// The window may refuse to be closed. For example, it may be hung, or hide itself instead, or display a "Save?" message box, or is a dialog without <c>X</c> button, or just need more time to close it.
	/// If the window is of this thread, just calls <see cref="Send"/> or <see cref="Post"/> (if <i>noWait</i>==<c>true</c>) and returns <c>true</c>.
	/// </remarks>
	/// <seealso cref="WaitForClosed"/>
	/// <example>
	/// <code><![CDATA[
	/// //close all Notepad windows
	/// foreach (var w in wnd.findAll("* Notepad", "Notepad")) w.Close();
	/// ]]></code>
	/// </example>
	public bool Close(bool noWait = false, bool useXButton = false) {
		if (!IsAlive) return true;
		
		int msg = Api.WM_CLOSE; int wparam = 0;
		if (useXButton) { msg = Api.WM_SYSCOMMAND; wparam = Api.SC_CLOSE; }
		
		if (IsOfThisThread) {
			if (noWait) Post(msg, wparam);
			else Send(msg, wparam);
			return true;
		}
		
		//Some windows cannot be properly closed using only WM_CLOSE. For example, VS 7 window closed, but the process not.
		//Some windows (eg IE), ignore SC_CLOSE if it is posted soon after starting the program. Only if using Post, not if SendNotify.
		//When the user closes a window, Windows sends SC_CLOSE. DefWindowProc on SC_CLOSE sends WM_CLOSE, except if disabled.
		
		//Other apps use either WM_CLOSE or SC_CLOSE.
		//	Task Manager and taskbar send (not post) SC_CLOSE.
		//	Process Explorer and taskkill post WM_CLOSE.
		
		//For our purposes WM_CLOSE is probably better.
		//	QM2 used SC_CLOSE or WM_CLOSE depending on window style.
		
		//note: Don't use SendX messages because of possible crashes and other anomalies.
		//	Eg it can hide (not close) some windows, and next app instance does not start (eg Firefox).
		//	Imagine if the target window's app is in SendMessage which dispatches foreign messages, and after it returns, the window is already died.
		
		bool ok = Post(msg, wparam);
		if (!ok) {
			//print.it(lastError.code); //0 when UAC access denied
			if (!useXButton) ok = Post(Api.WM_SYSCOMMAND, Api.SC_CLOSE); //UAC blocks WM_CLOSE but not WM_SYSCOMMAND
		}
		
		//if(!noWait.HasValue) noWait = this_thread_is_UI; //rejected
		if (noWait) return true;
		
		if (ok) {
			for (int i = 0; i < 100; i++) {
				Thread.Sleep(15);
				if (!IsEnabled(false)) break; //destroyed or has an owned modal dialog box, eg "Save?"
				
				//Wait less if hidden, eg has a tray icon.
				//Also if a popup, eg a Yes/No message box (disabled X button).
				//Also if child.
				//if(!IsVisible && !_IsBusy(2)) i += 4; //unreliable, too dirty
				if (!IsVisible || (Style & (WS.POPUP | WS.CHILD)) != 0) i += 2;
				
				if (i >= 50) {
					if (!SendTimeout(200, out _, 0)) {
						if (!IsAlive || IsHung) break;
					}
				}
			}
		}
		MinimalSleepNoCheckThread_();
		WndUtil.WaitForAnActiveWindow();
		
		return !IsAlive;
	}
	
	//bool _IsBusy(int milliseconds)
	//{
	//	//Need to measure time. Cannot use just 2 ms timeout and ST return value because of the system timer default period 15.6 ms etc.
	//	var t = perf.mcs;
	//	SendTimeout(5 + milliseconds, 0, flags: 0);
	//	var d = perf.mcs - t;
	//	//print.it(d);
	//	return (d >= milliseconds * 1000L);
	//}
	
	//Rarely used. It is easy, and there is example in Close() help: foreach (var w in wnd.findAll("* Notepad", "Notepad")) w.Close();
	///// <summary>
	///// Closes all matching windows.
	///// Calls <see cref="FindAll"/>. All parameters etc are the same. Then calls <see cref="Close"/> for each found window.
	///// Returns the number of found windows.
	///// </summary>
	//public static int closeAll(
	//	string name, string cn = null, WOwner of = default,
	//	WFlags flags = 0, Func<wnd, bool> f = null, WContains contains = default
	//	)
	//{
	//	var a = FindAll(name, cn, of, flags, f, contains);
	//	foreach(wnd w in a) w.Close();
	//	return a.Count;
	//}
	
	#endregion
	
}


================================================
FILE: Au/wnd/wndChildFinder.cs
================================================
using static Au.wnd.Internal_;

namespace Au;

/// <summary>
/// Finds window controls (child windows). Contains name and other parameters of controls to find.
/// </summary>
/// <remarks>
/// Can be used instead of <see cref="wnd.Child"/> or <see cref="wnd.ChildAll"/>.
/// Also can be used to find window that contains certain control, like in examples.
/// </remarks>
/// <example>
/// Find window that contains certain control, and get the control too.
/// <code><![CDATA[
/// var cf = new wndChildFinder("Password*", "Static");
/// wnd w = wnd.find(cn: "#32770", also: t => t.HasChild(cf));
/// print.it(w);
/// print.it(cf.Result);
/// ]]></code>
/// The same with parameter <i>contains</i>.
/// <code><![CDATA[
/// var cf = new wndChildFinder("Password*", "Static");
/// wnd w = wnd.find(cn: "#32770", contains: cf);
/// print.it(w);
/// print.it(cf.Result);
/// ]]></code>
/// </example>
public class wndChildFinder {
	enum _NameIs : byte { name, text, elmName, wfName }
	
	readonly wildex _name;
	readonly wildex _cn;
	readonly Func<wnd, bool> _also;
	WinformsControlNames _wfControls;
	readonly int _skipCount;
	readonly WCFlags _flags;
	readonly int? _id;
	readonly _NameIs _nameIs;
	
	/// <summary>
	/// See <see cref="wnd.Child"/>.
	/// </summary>
	/// <exception cref="ArgumentException">
	/// - <i>name</i> starts with <c>"***"</c>, but the prefix is invalid.
	/// - <i>cn</i> is <c>""</c>. To match any, use <c>null</c>.
	/// - Invalid wildcard expression (<c>"**options "</c> or regular expression).
	/// </exception>
	/// <inheritdoc cref="wnd.Child(string, string, WCFlags, int?, Func{wnd, bool}, int)" path="/param"/>
	public wndChildFinder(
		[ParamString(PSFormat.Wildex)] string name = null,
		[ParamString(PSFormat.Wildex)] string cn = null,
		WCFlags flags = 0, int? id = null, Func<wnd, bool> also = null, int skip = 0
		) {
		if (cn != null) {
			if (cn.Length == 0) throw new ArgumentException("Class name cannot be \"\". Use null.");
			_cn = cn;
		}
		if (name != null) {
			switch (StringUtil.ParseParam3Stars_(ref name, "text", "elmName", "wfName"/*, "label"*/)) {
			case -1: throw new ArgumentException("Invalid name prefix. Can be: \"***text \", \"***elmName \", \"***wfName \"."); //, \"***label \"
			case 1: _nameIs = _NameIs.text; break;
			case 2: _nameIs = _NameIs.elmName; break;
			case 3: _nameIs = _NameIs.wfName; break;
				//case 4: _nameIs = _NameIs.label; break;
			}
			_name = name;
		}
		_flags = flags;
		_id = id;
		_also = also;
		_skipCount = skip;
	}
	
	/// <summary>
	/// The found control.
	/// </summary>
	public wnd Result { get; internal set; }
	
	/// <summary>
	/// Finds the specified child control, like <see cref="wnd.Child"/>.
	/// </summary>
	/// <returns>If found, returns <see cref="Result"/>, else <c>default(wnd)</c>.</returns>
	/// <param name="wParent">Direct or indirect parent window. Can be top-level window or control.</param>
	/// <exception cref="AuWndException">Invalid <i>wParent</i>.</exception>
	/// <remarks>
	/// Functions <c>Find</c> and <see cref="Exists"/> differ only in their return types.
	/// </remarks>
	public wnd Find(wnd wParent) => Exists(wParent) ? Result : default;
	
	/// <summary>
	/// Finds the specified child control, like <see cref="wnd.Child"/>. Can wait and throw <see cref="NotFoundException"/>.
	/// </summary>
	/// <returns>If found, returns <see cref="Result"/>. Else throws exception or returns <c>default(wnd)</c> (if <i>wait</i> negative).</returns>
	/// <param name="wParent">Direct or indirect parent window. Can be top-level window or control.</param>
	/// <param name="wait">The wait timeout, seconds. If 0, does not wait. If negative, does not throw exception when not found.</param>
	/// <exception cref="AuWndException">Invalid <i>wParent</i>.</exception>
	/// <exception cref="NotFoundException" />
	/// <remarks>
	/// Functions <c>Find</c> and <see cref="Exists"/> differ only in their return types.
	/// </remarks>
	public wnd Find(wnd wParent, Seconds wait) => Exists(wParent, wait) ? Result : default;
	
	/// <returns>If found, sets <see cref="Result"/> and returns <c>true</c>, else <c>false</c>.</returns>
	/// <inheritdoc cref="Find(wnd)"/>
	public bool Exists(wnd wParent) {
		using var k = new WndList_(_AllChildren(wParent));
		return _FindInList(wParent, k) >= 0;
	}
	
	/// <returns>If found, sets <see cref="Result"/> and returns <c>true</c>. Else throws exception or returns <c>false</c> (if <i>wait</i> negative).</returns>
	/// <inheritdoc cref="Find(wnd, Seconds)"/>
	public bool Exists(wnd wParent, Seconds wait) {
		var r = wait.Exists_() ? Exists(wParent) : Au.wait.until(wait, () => Exists(wParent));
		return r || wait.ReturnFalseOrThrowNotFound_();
	}
	
	ArrayBuilder_<wnd> _AllChildren(wnd wParent) {
		wParent.ThrowIfInvalid();
		return EnumWindows2(EnumAPI.EnumChildWindows,
			onlyVisible: 0 == (_flags & WCFlags.HiddenToo),
			sortFirstVisible: true,
			wParent: wParent,
			directChild: 0 != (_flags & WCFlags.DirectChild));
	}
	
	/// <summary>
	/// Finds the specified control in a list of controls.
	/// The <see cref="Result"/> property will be the control.
	/// </summary>
	/// <returns>0-based index, or -1 if not found.</returns>
	/// <param name="a">List of controls, for example returned by <see cref="wnd.getwnd.Children"/>.</param>
	/// <param name="wParent">Direct or indirect parent window. Used only for flag <c>DirectChild</c>.</param>
	public int FindInList(IEnumerable<wnd> a, wnd wParent = default) {
		using var k = new WndList_(a);
		return _FindInList(wParent, k);
	}
	
	/// <summary>
	/// Finds all matching child controls, like <see cref="wnd.ChildAll"/>.
	/// </summary>
	/// <returns>Array containing zero or more <see cref="wnd"/>.</returns>
	/// <param name="wParent">Direct or indirect parent window. Can be top-level window or control.</param>
	/// <exception cref="AuWndException">Invalid <i>wParent</i>.</exception>
	public wnd[] FindAll(wnd wParent) {
		return _FindAll(new WndList_(_AllChildren(wParent)), wParent);
	}
	
	/// <summary>
	/// Finds all matching controls in a list of controls.
	/// </summary>
	/// <returns>Array containing zero or more <see cref="wnd"/>.</returns>
	/// <param name="a">List of controls, for example returned by <see cref="wnd.getwnd.Children"/>.</param>
	/// <param name="wParent">Direct or indirect parent window. Used only for flag <c>DirectChild</c>.</param>
	public wnd[] FindAllInList(IEnumerable<wnd> a, wnd wParent = default) {
		return _FindAll(new WndList_(a), wParent);
	}
	
	wnd[] _FindAll(WndList_ k, wnd wParent) {
		using (k) {
			using var ab = new ArrayBuilder_<wnd>();
			_FindInList(wParent, k, w => ab.Add(w)); //CONSIDER: ab could be part of _WndList. Now the delegate creates garbage.
			return ab.ToArray();
		}
	}
	
	/// <summary>
	/// Returns index of matching element or -1.
	/// </summary>
	/// <param name="wParent">Parent window. Can be <c>default(wnd)</c> if <i>inList</i> and no <c>DirectChild</c> flag and not using winforms name.</param>
	/// <param name="a">List of <see cref="wnd"/>. Does not dispose it.</param>
	/// <param name="getAll">If not <c>null</c>, calls it for all matching and returns -1.</param>
	int _FindInList(wnd wParent, WndList_ a, Action<wnd> getAll = null) {
		Result = default;
		if (a.Type == WndList_.ListType.None) return -1;
		bool inList = a.Type != WndList_.ListType.ArrayBuilder;
		int skipCount = _skipCount;
		
		try { //will need to dispose something
			for (int index = 0; a.Next(out wnd w); index++) {
				if (w.Is0) continue;
				
				if (inList) { //else the enum function did this
					if (!_flags.Has(WCFlags.HiddenToo)) {
						if (!w.IsVisibleIn_(wParent)) continue;
					}
					
					if (_flags.Has(WCFlags.DirectChild) && !wParent.Is0) {
						if (w.ParentGWL_ != wParent) continue;
					}
				}
				
				if (_id != null) {
					if (w.ControlId != _id.Value) continue;
				}
				
				if (_cn != null) {
					if (!_cn.Match(w.ClassName)) continue;
				}
				
				if (_name != null) {
					string s;
					switch (_nameIs) {
					case _NameIs.text:
						s = w.ControlText;
						break;
					case _NameIs.elmName:
						s = w.NameElm;
						break;
					case _NameIs.wfName:
						if (_wfControls == null) {
							try {
								_wfControls = new WinformsControlNames(wParent.Is0 ? w : wParent);
							}
							catch (AuWndException) { //invalid parent window
								return -1;
							}
							catch (AuException e) { //probably process of higher UAC integrity level
								print.warning($"Failed to get winforms control names. {e.Message}");
								return -1;
							}
						}
						s = _wfControls.GetControlName(w);
						break;
					//case _NameIs.label:
					//	s = w.NameLabel;
					//	break;
					default:
						s = w.Name;
						break;
					}
					
					if (!_name.Match(s)) continue;
				}
				
				if (_also != null && !_also(w)) continue;
				
				if (getAll != null) {
					getAll(w);
					continue;
				}
				
				if (skipCount-- > 0) continue;
				
				Result = w;
				return index;
			}
		}
		finally {
			if (_wfControls != null) { _wfControls.Dispose(); _wfControls = null; }
		}
		
		return -1;
	}
	
	/// <summary>
	/// Returns <c>true</c> if control <c>c</c> properties match the specified properties.
	/// </summary>
	/// <param name="c">A control. Can be 0/invalid, then returns <c>false</c>.</param>
	/// <param name="wParent">Direct or indirect parent window. If used, returns <c>false</c> if it isn't parent (also depends on flag <c>DirectChild</c>).</param>
	public bool IsMatch(wnd c, wnd wParent = default) {
		if (!wParent.Is0 && !c.IsChildOf(wParent)) {
			Result = default;
			return false;
		}
		return 0 == _FindInList(wParent, new WndList_(c));
	}
	
	///
	public override string ToString() {
		using (new StringBuilder_(out var b)) {
			b.Append('[');
			_Append("name", _name, true);
			_Append("cn", _cn, true);
			if (_id != null) _Append("id", _id.ToString(), false);
			if (_flags != 0) _Append("flags", _flags.ToString(), false);
			if (_also != null) _Append("also", "...", false);
			if (_skipCount != 0) _Append("skip", _skipCount.ToString(), false);
			b.Append(']');
			return b.ToString();
			
			void _Append(string k, object v, bool isString) {
				if (v == null) return;
				if (b.Length > 1) b.Append(", ");
				var s = v.ToString();
				if (isString) s = s.Escape(limit: 50, quote: true);
				b.Append(k).Append(": ").Append(s);
			}
		}
	}
}


================================================
FILE: Au/wnd/wndFinder.cs
================================================
using static Au.wnd.Internal_;

//TODO3: if no name, prefer non-tooltip window. Now often finds tooltip instead of the wanted window. Eg Java menus.

namespace Au;

/// <summary>
/// Finds top-level windows (<see cref="wnd"/>). Contains name and other parameters of windows to find.
/// </summary>
/// <remarks>
/// Can be used instead of <see cref="wnd.find"/> or <see cref="wnd.findAll"/>.
/// These codes are equivalent:
/// <code><![CDATA[wnd w = wnd.find(a, b, c, d, e); if(!w.Is0) print.it(w);]]></code>
/// <code><![CDATA[var p = new wndFinder(a, b, c, d, e); if(p.Exists()) print.it(p.Result);]]></code>
/// Also can find in a list of windows.
/// </remarks>
public class wndFinder {
	readonly wildex _name;
	readonly wildex _cn;
	readonly wildex _program;
	readonly int _processId;
	readonly int _threadId;
	readonly wnd _owner;
	readonly Func<wnd, bool> _also;
	readonly WFlags _flags;
	readonly WContains _contains;

#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
	/// <summary>
	/// Parsed parameter values. All read-only.
	/// </summary>
	public TProps Props => new(this);

	[NoDoc]
	public struct TProps {
		readonly wndFinder _f;
		internal TProps(wndFinder f) { _f = f; }

		public wildex name => _f._name;
		public wildex cn => _f._cn;
		public wildex program => _f._program;
		public int processId => _f._processId;
		public int threadId => _f._threadId;
		public wnd owner => _f._owner;
		public WFlags flags => _f._flags;
		public Func<wnd, bool> also => _f._also;
		public WContains contains => _f._contains;

		/// <summary>
		/// After unsuccessful <see cref="IsMatch"/> indicates the parameter that does not match.
		/// </summary>
		public EProps DoesNotMatch => _f._stopProp;
	}

	EProps _stopProp;

	[NoDoc]
	public enum EProps { name = 1, cn, of, also, contains, visible, cloaked, }

	public override string ToString() {
		using (new StringBuilder_(out var b)) {
			_Append("name", _name);
			_Append("cn", _cn);
			if (_program != null) _Append("program", _program); else if (_processId != 0) _Append("processId", _processId); else if (_threadId != 0) _Append("threadId", _threadId);
			if (_also != null) _Append("also", "");
			_Append("contains", _contains.Value);
			return b.ToString();

			void _Append(string k, object v) {
				if (v == null) return;
				if (b.Length != 0) b.Append(", ");
				b.Append(k).Append('=').Append(v);
			}
		}
	}
#pragma warning restore CS1591

	/// <inheritdoc cref="wnd.find" path="//param|//exception"/>
	public wndFinder(
		[ParamString(PSFormat.Wildex)] string name = null,
		[ParamString(PSFormat.Wildex)] string cn = null,
		[ParamString(PSFormat.Wildex)] WOwner of = default,
		WFlags flags = 0, Func<wnd, bool> also = null, WContains contains = default) {
		_name = name;
		if (cn != null) _cn = cn.Length != 0 ? cn : throw new ArgumentException("cn cannot be \"\". Use null.");
		of.GetValue(out _program, out _processId, out _threadId, out _owner);
		_flags = flags;
		_also = also;
		_contains = contains;
	}

	//rejected. Better slightly longer code than unclear and possibly ambiguous code where need to learn string parsing rules.
	///// <summary>
	///// Implicit conversion from string that can contain window name, class name, program and/or a <i>contains</i> object.
	///// Examples: <c>"name,cn,program"</c>, <c>"name"</c>, <c>",cn"</c>, <c>"*,,program"</c>, <c>"name,cn"</c>, <c>"name,,program"</c>, <c>",cn,program"</c>, <c>"name,,,object"</c>.
	///// </summary>
	///// <param name="s">
	///// One or more comma-separated window properties: name, class, program and/or a <i>contains</i> object. Empty name means <c>""</c> (for any use *); other empty parts mean <c>null</c>.
	///// The same as parameters of <see cref="wnd.find"/>. The first 3 parts are <i>name</i>, <i>cn</i> and <i>of</i>. The last part is <i>contains</i> as string; can specify a UI element, control or image.
	///// The first 3 comma-separated parts cannot contain commas. Alternatively, parts can be separated by <c>'\0'</c> characters, like <c>"name\0"+"cn\0"+"program\0"+"object"</c>. Then parts can contain commas. Example: <c>"*one, two, three*\0"</c> (name with commas).
	///// </param>
	///// <exception cref="ArgumentException">See <see cref="wnd.find"/>.</exception>
	///// <exception cref="Exception">If specifies a <i>contains</i> object: exceptions of constructor of <see cref="wndChildFinder"/> or <see cref="elmFinder"/> or <see cref="uiimageFinder"/>.</exception>
	//public static implicit operator wndFinder(string s) {
	//	string name = null, cn = null, prog = null, contains = null;
	//	char[] sep = null; if (s.Contains('\0')) sep = s_sepZero; else if (s.Contains(',')) sep = s_sepComma;
	//	if (sep == null) name = s;
	//	else {
	//		var ra = s.Split(sep, 4);
	//		name = ra[0];
	//		if (ra[1].Length > 0) cn = ra[1];
	//		if (ra.Length > 2 && ra[2].Length > 0) prog = ra[2];
	//		if (ra.Length > 3 && ra[3].Length > 0) contains = ra[3];
	//	}
	//	return new wndFinder(name, cn, prog, contains: contains);
	//}
	//static readonly char[] s_sepComma = { ',' }, s_sepZero = { '\0' };

	/// <summary>
	/// The found window.
	/// </summary>
	public wnd Result { get; internal set; }

	/// <summary>
	/// Finds the specified window, like <see cref="wnd.find"/>.
	/// </summary>
	/// <returns>If found, returns <see cref="Result"/>, else <c>default(wnd)</c>.</returns>
	/// <remarks>
	/// Functions <c>Find</c> and <see cref="Exists"/> differ only in their return types.
	/// </remarks>
	public wnd Find() => Exists() ? Result : default;

	/// <summary>
	/// Finds the specified window, like <see cref="wnd.find"/>. Can wait and throw <see cref="NotFoundException"/>.
	/// </summary>
	/// <returns>If found, returns <see cref="Result"/>. Else throws exception or returns <c>default(wnd)</c> (if <i>wait</i> negative).</returns>
	/// <param name="wait">The wait timeout, seconds. If 0, does not wait. If negative, does not throw exception when not found.</param>
	/// <exception cref="NotFoundException" />
	/// <remarks>
	/// Functions <c>Find</c> and <see cref="Exists"/> differ only in their return types.
	/// </remarks>
	public wnd Find(Seconds wait) => Exists(wait) ? Result : default;

	/// <returns>If found, sets <see cref="Result"/> and returns <c>true</c>, else <c>false</c>.</returns>
	/// <inheritdoc cref="Find()"/>
	public bool Exists() {
		using var k = new WndList_(_AllWindows());
		return _FindOrMatch(k) >= 0;
	}

	/// <returns>If found, sets <see cref="Result"/> and returns <c>true</c>. Else throws exception or returns <c>false</c> (if <i>wait</i> negative).</returns>
	/// <inheritdoc cref="Find(Seconds)"/>
	public bool Exists(Seconds wait) {
		var r = wait.Exists_() ? Exists() : !Wait(wait, false).Is0;
		return r || wait.ReturnFalseOrThrowNotFound_();
	}

	/// <summary>
	/// Waits until window exists or is active.
	/// </summary>
	/// <returns>Returns <see cref="Result"/>. On timeout returns <c>default(wnd)</c> if <i>timeout</i> is negative; else exception.</returns>
	/// <param name="timeout">Timeout, seconds. Can be 0 (infinite), >0 (exception) or &lt;0 (no exception). More info: [](xref:wait_timeout).</param>
	/// <param name="active">The window must be the active window (<see cref="wnd.active"/>), and not minimized.</param>
	/// <exception cref="TimeoutException"><i>timeout</i> time has expired (if > 0).</exception>
	/// <remarks>
	/// Same as <see cref="Find(Seconds)"/>, except:
	/// - 0 timeout means infinite.
	/// - on timeout throws <see cref="TimeoutException"/>, not <see cref="NotFoundException"/>.
	/// - has parameter <i>active</i>.
	/// </remarks>
	public wnd Wait(Seconds timeout, bool active) {
		var loop = new WaitLoop(timeout);
		for (; ; ) {
			if (active) {
				wnd w = wnd.active;
				if (IsMatch(w) && !w.IsMinimized) return Result = w;
				//CONSIDER: also wait until released mouse buttons.
			} else {
				if (Exists()) return Result;
			}
			if (!loop.Sleep()) return default;
		}
	}

	ArrayBuilder_<wnd> _AllWindows() {
		//FUTURE: optimization: if cn not wildcard etc, at first find atom.
		//	If not found, don't search. If found, compare atom, not class name string.

		var f = _threadId != 0 ? EnumAPI.EnumThreadWindows : EnumAPI.EnumWindows;
		return EnumWindows2(f, 0 == (_flags & WFlags.HiddenToo), true, wParent: _owner, threadId: _threadId);
	}

	/// <summary>
	/// Finds the specified window in a list of windows, and sets <see cref="Result"/>.
	/// </summary>
	/// <returns>Returns 0-based index, or -1 if not found.</returns>
	/// <param name="a">Array or list of windows, for example returned by <see cref="wnd.getwnd.allWindows"/>.</param>
	public int FindInList(IEnumerable<wnd> a) {
		using var k = new WndList_(a);
		return _FindOrMatch(k);
	}

	/// <summary>
	/// Finds all matching windows, like <see cref="wnd.findAll"/>.
	/// </summary>
	/// <returns>Array containing 0 or more window handles as <see cref="wnd"/>.</returns>
	public wnd[] FindAll() {
		return _FindAll(new WndList_(_AllWindows()));
	}

	/// <summary>
	/// Finds all matching windows in a list of windows.
	/// </summary>
	/// <returns>Array containing 0 or more window handles as <see cref="wnd"/>.</returns>
	/// <param name="a">Array or list of windows, for example returned by <see cref="wnd.getwnd.allWindows"/>.</param>
	public wnd[] FindAllInList(IEnumerable<wnd> a) {
		return _FindAll(new WndList_(a));
	}

	wnd[] _FindAll(WndList_ k) {
		using (k) {
			using var ab = new ArrayBuilder_<wnd>();
			_FindOrMatch(k, w => ab.Add(w)); //CONSIDER: ab could be part of WndList_. Now the delegate creates garbage.
			return ab.ToArray();
		}
	}

	/// <summary>
	/// Returns index of matching element or -1.
	/// Returns -1 if using <i>getAll</i>.
	/// </summary>
	/// <param name="a">List of <see cref="wnd"/>. Does not dispose it.</param>
	/// <param name="getAll">If not <c>null</c>, calls it for all matching and returns -1.</param>
	/// <param name="cache"></param>
	int _FindOrMatch(WndList_ a, Action<wnd> getAll = null, WFCache cache = null) {
		Result = default;
		_stopProp = 0;
		if (a.Type == WndList_.ListType.None) return -1;
		bool inList = a.Type != WndList_.ListType.ArrayBuilder;
		bool ignoreVisibility = cache?.IgnoreVisibility ?? false;
		bool mustBeVisible = inList && (_flags & WFlags.HiddenToo) == 0 && !ignoreVisibility;
		bool isOwner = inList && !_owner.Is0;
		int ownerTid = 0;
		bool isTid = inList ? _threadId != 0 : false;
		List<int> pids = null; bool programNamePlanB = false; //variables for faster getting/matching program name

		int index = 0;
		for (; a.Next(out wnd w); index++) {
			if (w.Is0) continue;

			//Speed of getting properties of 1000 windows with hot CPU:
			//name 1000, class 1000
			//foreign tid/pid 900/1800,
			//visible 30, cloaked 1100,
			//owner 40, style 40, exstyle 40,
			//isOwned(2) 2000, isOwned(2, ref tid) 1000,
			//rect 500,
			//GetProp(randomString) 1700, GetProp(existingString) 3000, GetProp(atom) 1000, GlobalFindAtom 1700,
			//program 6000

			if (mustBeVisible) {
				if (!w.IsVisible) { _stopProp = EProps.visible; continue; }
			}

			if (isOwner) {
				if (!w.IsOwnedBy2_(_owner, 2, ref ownerTid)) { _stopProp = EProps.of; continue; }
			}

			cache?.Begin(w);

			if (_name != null) {
				var s = cache != null && cache.CacheName ? (cache.Name ??= w.NameTL_) : w.NameTL_;
				if (!_name.Match(s)) { _stopProp = EProps.name; continue; }
				//note: name is before classname. It makes faster in slowest cases (HiddenToo), because most windows are nameless.
			}

			if (_cn != null) {
				var s = cache != null ? (cache.Class ?? (cache.Class = w.ClassName)) : w.ClassName;
				if (!_cn.Match(s)) { _stopProp = EProps.cn; continue; }
			}

			if (0 == (_flags & WFlags.CloakedToo) && !ignoreVisibility) {
				if (w.IsCloaked) { _stopProp = EProps.cloaked; continue; }
			}

			int pid = 0, tid = 0;
			if (_program != null || _processId != 0 || isTid) {
				if (cache != null) {
					if (cache.Tid == 0) cache.Tid = w.GetThreadProcessId(out cache.Pid);
					tid = cache.Tid; pid = cache.Pid;
				} else tid = w.GetThreadProcessId(out pid);
				if (tid == 0) { _stopProp = EProps.of; continue; }
				//speed: with foreign processes the same speed as getting name or class name. Much faster if same process.
			}

			if (isTid) {
				if (_threadId != tid) { _stopProp = EProps.of; continue; }
			}

			if (_processId != 0) {
				if (_processId != pid) { _stopProp = EProps.of; continue; }
			}

			if (_program != null) {
				//Getting program name is one of slowest parts.
				//Usually it does not slow down much because need to do it only 1 or several times, only when window name, class etc match.
				//The worst case is when only program is specified, and the very worst case is when also using flag HiddenToo.
				//We are prepared for the worst case.
				//Normally we call process.getName. In most cases it is quite fast.
				//Anyway, we use this optimization:
				//	Add pid of processes that don't match the specified name in the pids list (bad pids).
				//	Next time, if pid is in the bad pids list, just continue, don't need to get program name again.
				//However in the worst case we would encounter some processes that process.getName cannot get name using the fast API.
				//For each such process it would then use the much slower 'get all processes' API, which is almost as slow as Process.GetProcessById(pid).ProgramName.
				//To solve this:
				//We tell process.getName to not use the slow API, but just return null when the fast API fails.
				//When it happens (process.getName returns null):
				//	If need full path: continue, we cannot do anything more.
				//	Switch to plan B and no longer use all the above. Plan B:
				//	Get list of pids of all processes that match _program. For it we call process.GetProcessesByName_, which uses the same slow API, but we call it just one time.
				//	If it returns null (it means there are no matching processes), break (window not found).
				//	From now, in each loop will need just to find pid in the returned list, and continue if not found.

				_stopProp = EProps.of;
				g1:
				if (programNamePlanB) {
					if (!pids.Contains(pid)) continue;
				} else {
					if (pids != null && pids.Contains(pid)) continue; //is known bad pid?

					string pname = cache != null ? (cache.Program ?? (cache.Program = _Program())) : _Program();
					string _Program() => process.getName(pid, false, true);
					//string _Program() => process.getName(pid, 0!=(_flags&WFlags.ProgramPath), true);

					if (pname == null) {
						//if(0!=(_flags&WFlags.ProgramPath)) continue;

						//switch to plan B
						process.GetProcessesByName_(ref pids, _program);
						if (pids.NE_()) break;
						programNamePlanB = true;
						goto g1;
					}

					if (!_program.Match(pname)) {
						if (a.Type == WndList_.ListType.SingleWnd) break;
						pids ??= new List<int>(16);
						pids.Add(pid); //add bad pid
						continue;
					}
				}
				_stopProp = 0;
			}

			if (_also != null) {
				bool ok = false;
				try { ok = _also(w); }
				catch (AuWndException) { } //don't throw if w destroyed
				if (!ok) { _stopProp = EProps.also; continue; }
			}

			if (_contains.Value != null) {
				bool found = false;
				try {
					switch (_contains.Value) {
					case elmFinder f: found = w.HasElm(f); break;
					case wndChildFinder f: found = f.Exists(w); break;
					case uiimageFinder f: found = f.Exists(w); break;
					case ocrFinder f: found = f.Exists(w); break;
					}
				}
				catch (Exception ex) {
					if (!(ex is AuWndException)) print.warning("Exception when tried to find the 'contains' object. " + ex, -1);
				}
				if (!found) { _stopProp = EProps.contains; continue; }
			}

			if (getAll != null) {
				getAll(w);
				continue;
			}

			Result = w;
			return index;
		}

		if (index == 0 && !inList) if (!_owner.Is0 || _threadId != 0) _stopProp = EProps.of;

		return -1;
	}

	/// <summary>
	/// Returns <c>true</c> if window <i>w</i> properties match the specified properties.
	/// </summary>
	/// <param name="w">A top-level window. If 0 or invalid, returns <c>false</c>.</param>
	/// <param name="cache">Can be used to make faster when multiple <see cref="wndFinder"/> variables are used with same window. The function gets window name/class/program once, and stores in <i>cache</i>; next time it gets these strings from <i>cache</i>.</param>
	/// <seealso cref="wnd.IsMatch"/>
	public bool IsMatch(wnd w, WFCache cache = null) {
		return 0 == _FindOrMatch(new WndList_(w), cache: cache);
	}
}


================================================
FILE: Au/wnd/wnd_child.cs
================================================
namespace Au {
	public unsafe partial struct wnd {
		/// <summary>
		/// Finds a child control and returns its handle as <see cref="wnd"/>.
		/// </summary>
		/// <returns>Returns <c>default(wnd)</c> if not found. See also: <see cref="Is0"/>.</returns>
		/// <param name="name">
		/// Control name.
		/// String format: [wildcard expression](xref:wildcard_expression).
		/// <c>null</c> means "can be any". <c>""</c> means "no name".
		/// 
		/// By default to get control names this function uses <see cref="Name"/>.
		/// Can start with these prefix strings:
		/// <br/>• <c>"***text "</c> - use <see cref="ControlText"/>. Slower and less reliable because can get editable text. If a character can be underlined with <c>Alt</c>, insert <c>'&amp;'</c> before it.
		/// <br/>• <c>"***elmName "</c> - use <see cref="NameElm"/>. Slower.
		/// <br/>• <c>"***wfName "</c> - use .NET Forms control name (see <see cref="WinformsControlNames"/>). Slower and can fail because of [](xref:uac).
		/// </param>
		/// <param name="cn">
		/// Control class name.
		/// String format: [wildcard expression](xref:wildcard_expression).
		/// <c>null</c> means "can be any". Cannot be <c>""</c>.
		/// </param>
		/// <param name="flags"></param>
		/// <param name="id">Control id. See <see cref="ControlId"/>. Not used if <c>null</c> (default).</param>
		/// <param name="also">
		/// Callback function. Called for each matching control.
		/// It can evaluate more properties of the control and return <c>true</c> when they match.
		/// Example: <c>also: t => t.IsEnabled</c>
		/// </param>
		/// <param name="skip">
		/// 0-based index of matching control.
		/// For example, if 1, the function skips the first matching control and returns the second.
		/// </param>
		/// <exception cref="AuWndException">This variable is invalid (window not found, closed, etc).</exception>
		/// <exception cref="ArgumentException">
		/// - <i>name</i> starts with <c>"***"</c>, but the prefix is invalid.
		/// - <i>cn</i> is <c>""</c>. To match any, use <c>null</c>.
		/// - Invalid wildcard expression (<c>"**options "</c> or regular expression).
		/// </exception>
		/// <remarks>
		/// To create code for this function, use tool <b>Find window</b>.
		/// </remarks>
		public wnd Child(
			[ParamString(PSFormat.Wildex)] string name = null,
			[ParamString(PSFormat.Wildex)] string cn = null,
			WCFlags flags = 0, int? id = null, Func<wnd, bool> also = null, int skip = 0
			) => new wndChildFinder(name, cn, flags, id, also, skip).Find(this);

		/// <summary>
		/// Finds a child control and returns its handle as <see cref="wnd"/>. Can wait and throw <see cref="NotFoundException"/>.
		/// </summary>
		/// <returns>Child control handle. If not found, throws exception or returns <c>default(wnd)</c> (if <i>wait</i> negative).</returns>
		/// <param name="wait">The wait timeout, seconds. If 0, does not wait. If negative, does not throw exception when not found.</param>
		/// <exception cref="AuWndException">This variable is invalid (window not found, closed, etc). Or closed while waiting.</exception>
		/// <exception cref="NotFoundException" />
		/// <inheritdoc cref="Child(string, string, WCFlags, int?, Func{wnd, bool}, int)"/>
		public wnd Child(
			Seconds wait,
			[ParamString(PSFormat.Wildex)] string name = null,
			[ParamString(PSFormat.Wildex)] string cn = null,
			WCFlags flags = 0, int? id = null, Func<wnd, bool> also = null, int skip = 0
			) => new wndChildFinder(name, cn, flags, id, also, skip).Find(this, wait);

		/// <summary>
		/// Finds all matching child controls.
		/// </summary>
		/// <returns>Array containing zero or more <see cref="wnd"/>.</returns>
		/// <remarks>
		/// Everything except the return type is the same as with <see cref="Child"/>.
		/// 
		/// In the returned array, hidden controls (when using <see cref="WCFlags.HiddenToo"/>) are always after visible controls.
		/// </remarks>
		/// <seealso cref="getwnd.Children"/>
		/// <inheritdoc cref="Child(string, string, WCFlags, int?, Func{wnd, bool}, int)"/>
		public wnd[] ChildAll(
			[ParamString(PSFormat.Wildex)] string name = null,
			[ParamString(PSFormat.Wildex)] string cn = null,
			WCFlags flags = 0, int? id = null, Func<wnd, bool> also = null) {
			//ThrowIfInvalid(); //will be called later
			var f = new wndChildFinder(name, cn, flags, id, also);
			return f.FindAll(this);
		}

		/// <summary>
		/// Returns <c>true</c> if this window contains the specified control.
		/// Calls <see cref="wndChildFinder.Exists"/>.
		/// </summary>
		/// <exception cref="AuWndException"/>
		/// <example>
		/// Find window that contains certain control, and get the control too.
		/// <code><![CDATA[
		/// var cf = new wndChildFinder("Password*", "Static");
		/// wnd w = wnd.find(cn: "#32770", also: t => t.HasChild(cf));
		/// print.it(w);
		/// print.it(cf.Result);
		/// ]]></code>
		/// The same with parameter <i>contains</i>.
		/// <code><![CDATA[
		/// var cf = new wndChildFinder("Password*", "Static");
		/// wnd w = wnd.find(cn: "#32770", contains: cf);
		/// print.it(w);
		/// print.it(cf.Result);
		/// ]]></code>
		/// </example>
		public bool HasChild(wndChildFinder f) => f.Exists(this);

		//rejected. Rare. Can use w.HasChild(new("Apply", "Button")) or !w.Child(...).Is0 etc. Or would also need HasElm(string...).
		///// <summary>
		///// Returns <c>true</c> if this window contains the specified control.
		///// Calls <see cref="Child"/>.
		///// <para>NOTE: Calling this function many times with same arguments is inefficient. Instead create new <see cref="wndChildFinder"/> and call <see cref="wndChildFinder.Exists"/> or <see cref="HasChild(wndChildFinder)"/>. See example.</para>
		///// </summary>
		///// <remarks></remarks>
		///// <example></example>
		///// <inheritdoc cref="Child(string, string, WCFlags, int?, Func{wnd, bool}, int)"/>
		//public bool HasChild(
		//	[ParamString(PSFormat.Wildex)] string name = null,
		//	[ParamString(PSFormat.Wildex)] string cn = null,
		//	WCFlags flags = 0, int? id = null, Func<wnd, bool> also = null, int skip = 0) {
		//	return default != Child(name, cn, flags, id, also, skip);
		//}

		/// <summary>
		/// Returns <c>true</c> if this window contains the specified UI element.
		/// Calls <see cref="elmFinder.Exists"/>.
		/// </summary>
		/// <exception cref="AuWndException"/>
		/// <example>
		/// Find window that contains certain UI element, and get the UI element too.
		/// <code><![CDATA[
		/// var f = new elmFinder("BUTTON", "OK");
		/// wnd w = wnd.find(cn: "#32770", also: t => t.HasElm(f));
		/// print.it(w);
		/// print.it(f.Result);
		/// ]]></code>
		/// The same with parameter <i>contains</i>.
		/// <code><![CDATA[
		/// var f = new elmFinder("BUTTON", "OK");
		/// wnd w = wnd.find(cn: "#32770", contains: f);
		/// print.it(w);
		/// print.it(f.Result);
		/// ]]></code>
		/// </example>
		public bool HasElm(elmFinder f) => f.Find_(false, this, null);

		//rejected. Use Child. Don't need 2 function for the same. Also the wait parameter is confusing. Also there is no finder.
		//	This is faster and less garbage, but it's not so important. Also there is ChildFast(id) for direct children.
		///// <summary>
		///// Finds a child control by its id and returns its handle as <see cref="wnd"/>.
		///// </summary>
		///// <returns>Child control handle, or <c>default(wnd)</c> if not found. See also: <see cref="Is0"/>.</returns>
		///// <param name="id">Control id.</param>
		///// <param name="flags">This function supports flags <c>DirectChild</c> and <c>HiddenToo</c>. If both are set, it is much faster because uses API <ms>GetDlgItem</ms>. Else uses API <ms>EnumChildWindows</ms>, like <see cref="Child"/>.</param>
		///// <exception cref="AuWndException">This variable is invalid (window not found, closed, etc).</exception>
		///// <remarks>
		///// To create code for this function, use tool <b>Find window</b>.
		///// 
		///// Not all controls have a useful id. If control id is not unique or is different in each window instance, this function is not useful.
		///// </remarks>
		//public wnd ChildById(int id, WCFlags flags = 0) {
		//	ThrowIfInvalid();
		//	if (flags.Has(WCFlags.DirectChild | WCFlags.HiddenToo)) return Api.GetDlgItem(this, id); //fast

		//	var d = new _KidEnumData() { wThis = this, id = id }; //info: to avoid garbage delegates, we use _KidEnumData instead of captured variables
		//	var wParent = this;
		//	Api.EnumChildWindows(this, (c, p) => {
		//		ref var x = ref *(_KidEnumData*)p;
		//		if (c.ControlId == x.id) {
		//			if (x.flags.Has(WCFlags.DirectChild) && c.ParentGWL_ != x.wThis) return 1;
		//			if (c.IsVisibleIn_(wParent)) { x.cVisible = c; return 0; }
		//			if (x.flags.Has(WCFlags.HiddenToo) && x.cHidden.Is0) x.cHidden = c;
		//		}
		//		return 1;
		//	}, &d);
		//	return d.cVisible.Is0 ? d.cHidden : d.cVisible;
		//}

		///// <summary>
		///// Finds a child control by its id and returns its handle as <see cref="wnd"/>. Can wait and throw <see cref="NotFoundException"/>.
		///// </summary>
		///// <returns>Child control handle. If not found, throws exception or returns <c>default(wnd)</c> (if <i>wait</i> negative).</returns>
		///// <param name="wait">The wait timeout, seconds. If 0, does not wait. If negative, does not throw exception when not found.</param>
		///// <param name="id"></param>
		///// <param name="flags"></param>
		///// <exception cref="AuWndException">This variable is invalid (window not found, closed, etc). Or closed while waiting.</exception>
		///// <exception cref="NotFoundException" />
		//public wnd ChildById(Seconds wait, int id, WCFlags flags = 0) {
		//	wnd r;
		//	if (wait.Exists_()) {
		//		r = ChildById(id, flags);
		//	} else {
		//		var to = new WaitLoop(wait);
		//		do { r = ChildById(id, flags); if (!r.Is0) break; } while (to.Sleep());
		//	}
		//	return !r.Is0 || wait.Time < 0 ? r : throw new NotFoundException();
		//}

		//struct _KidEnumData
		//{
		//	public wnd wThis, cVisible, cHidden;
		//	public int id;
		//	public WCFlags flags;
		//}

		/// <summary>
		/// Finds a direct child control by name and/or class name and returns its handle as <see cref="wnd"/>.
		/// </summary>
		/// <returns>Returns <c>default(wnd)</c> if not found. See also: <see cref="Is0"/>. Supports <see cref="lastError"/>.</returns>
		/// <param name="name">
		/// Name.
		/// Full, case-insensitive. Wildcard etc not supported.
		/// <c>null</c> means "can be any". <c>""</c> means "no name".
		/// Must include the invisible <c>'&amp;'</c> characters that are used to underline keyboard shortcuts with the <c>Alt</c> key.
		/// </param>
		/// <param name="cn">
		/// Class name.
		/// Full, case-insensitive. Wildcard etc not supported.
		/// <c>null</c> means "can be any". Cannot be <c>""</c>.
		/// </param>
		/// <param name="wAfter">If used, starts searching from the next control in the Z order.</param>
		/// <remarks>
		/// Calls API <ms>FindWindowEx</ms>.
		/// Faster than <see cref="Child"/>, which uses API <ms>EnumChildWindows</ms>.
		/// Can be used only when you know full name and/or class name.
		/// Finds hidden controls too. Finds only direct children, not other descendants.
		/// </remarks>
		public wnd ChildFast(string name, string cn, wnd wAfter = default) {
			//ThrowIfInvalid(); //no, it can be HWND_MESSAGE
			if (Is0) {
				Api.SetLastError(Api.ERROR_INVALID_WINDOW_HANDLE);
				return default;
			}
			return Api.FindWindowEx(this, wAfter, cn, name);
		}

		/// <summary>
		/// Finds a direct child control by its id and returns its handle as <see cref="wnd"/>.
		/// </summary>
		/// <returns>Returns <c>default(wnd)</c> if not found. See also: <see cref="Is0"/>. Supports <see cref="lastError"/>.</returns>
		/// <param name="id">Control id.</param>
		/// <remarks>
		/// Calls API <ms>GetDlgItem</ms>.
		/// Faster than <see cref="Child"/>, which uses API <ms>EnumChildWindows</ms>.
		/// Finds only direct children, not other descendants. Finds hidden controls too.
		/// Not all controls have a useful id. If control id is not unique or is different in each window instance, this function is not useful.
		/// </remarks>
		public wnd ChildFast(int id) {
			//ThrowIfInvalid(); //no, let it be same as other overload
			return Api.GetDlgItem(this, id);
		}

		public partial struct getwnd {
			/// <summary>
			/// Gets child controls, including all descendants.
			/// </summary>
			/// <returns>Array containing zero or more <see cref="wnd"/>.</returns>
			/// <param name="onlyVisible">Need only visible controls.</param>
			/// <param name="sortFirstVisible">Place all array elements of hidden controls at the end of the array.</param>
			/// <param name="directChild">Need only direct children, not all descendants.</param>
			/// <exception cref="AuWndException">This variable is invalid (window not found, closed, etc).</exception>
			/// <remarks>
			/// Calls API <ms>EnumChildWindows</ms>.
			/// </remarks>
			/// <seealso cref="ChildAll"/>
			public wnd[] Children(bool onlyVisible = false, bool sortFirstVisible = false, bool directChild = false) {
				_w.ThrowIfInvalid();
				return Internal_.EnumWindows(Internal_.EnumAPI.EnumChildWindows, onlyVisible, sortFirstVisible, _w, directChild);
			}

			//rejected
			///// <summary>
			///// Gets child controls, including all descendants.
			///// </summary>
			///// <param name="a">Receives results. If <c>null</c>, this function creates new <c>List</c>, else clears before adding items.</param>
			///// <param name="onlyVisible">Need only visible controls.</param>
			///// <param name="sortFirstVisible">Place all array elements of hidden controls at the end of the array.</param>
			///// <param name="directChild">Need only direct children, not all descendants.</param>
			///// <exception cref="AuWndException">This variable is invalid (window not found, closed, etc).</exception>
			///// <remarks>
			///// Use this overload to avoid much garbage when calling frequently with the same <c>List</c> variable. Other overload always allocates new array. This overload in most cases reuses memory allocated for the list variable.
			///// </remarks>
			//public void Children(ref List<wnd> a, bool onlyVisible = false, bool sortFirstVisible = false, bool directChild = false) {
			//	_w.ThrowIfInvalid();
			//	Internal_.EnumWindows2(Internal_.EnumAPI.EnumChildWindows, onlyVisible, sortFirstVisible, _w, directChild, list: a ??= new List<wnd>());
			//}

			//rejected: unreliable.
			///// <summary>
			///// Gets list of direct child controls.
			///// Faster than API <c>EnumChildWindows</c>.
			///// Should be used only with windows of current thread. Else it is unreliable because, if some controls are zordered or destroyed while enumerating, some controls can be skipped or retrieved more than once.
			///// </summary>
			//public wnd[] DirectChildrenFastUnsafe(string cn = null)
			//{
			//	wildex wild = cn;
			//	var a = new List<wnd>();
			//	for(wnd c = FirstChild; !c.Is0; c = c.Next) {
			//		if(wild != null && !c._ClassNameIs(wild)) continue;
			//		a.Add(c);
			//	}
			//	return a.ToArray();
			//}
		}

		///// <summary>
		///// Casts this to <see cref="WButton"/>.
		///// </summary>
		//public WButton AsButton => new(this);

		/// <summary>
		/// Finds and clicks a button in this window. Does not use the mouse.
		/// </summary>
		/// <param name="id">Control id of the button. See <see cref="Child"/>.</param>
		/// <exception cref="AuWndException">This variable is invalid (window not found, closed, etc).</exception>
		/// <exception cref="NotFoundException">Button not found.</exception>
		/// <remarks>
		/// This function just calls <see cref="Child"/> and <see cref="mouse.postClick"/>.
		/// Uses this code: <c>mouse.postClick(this.Child(1, id: id));</c>
		/// </remarks>
		/// <example>
		/// <code><![CDATA[
		/// wnd.find("Options").ButtonClick(2);
		/// ]]></code>
		/// </example>
		public void ButtonClick(int id) => mouse.postClick(this.Child(1, id: id));

		/// <summary>
		/// Finds and clicks a button in this window. Does not use the mouse.
		/// </summary>
		/// <param name="name">Button name. String format: [wildcard expression](xref:wildcard_expression).</param>
		/// <param name="asControl">
		/// If <c>true</c>, finds/clicks as child control: <c>mouse.postClick(this.Child(1, name, roleCN ?? "*Button*"));</c>.
		/// If <c>false</c>, finds/clicks as UI element: <c>this.Elm[roleCN ?? "BUTTON", name].Find(1).Invoke();</c>.
		/// Default is <c>false</c>; it's slower but works with more windows.
		/// </param>
		/// <param name="roleCN">UI element role or control class name (if <i>asControl</i> <c>true</c>). String format: [wildcard expression](xref:wildcard_expression). Default role is <c>"BUTTON"</c>, class name <c>"*Button*"</c>.</param>
		/// <remarks>
		/// This function is just a shorter way to call other functions that have more options but require more code to call. If <i>asControl</i> <c>true</c>, it calls <see cref="Child"/> and <see cref="mouse.postClick"/>. Else <see cref="Elm"/>, <see cref="elmFinder.this"/>, <see cref="elmFinder.Find"/> and <see cref="elm.Invoke"/>.
		/// </remarks>
		/// <exception cref="ArgumentException">Invalid <i>name</i> (when starts with <c>"***"</c>). See <see cref="elmFinder.this"/>, <see cref="Child"/>.</exception>
		/// <exception cref="AuWndException">This variable is invalid (window not found, closed, etc).</exception>
		/// <exception cref="NotFoundException">Button not found.</exception>
		/// <exception cref="AuException">Failed to click. For example need to activate the window. No exception if <i>asControl</i> <c>true</c>.</exception>
		/// <example>
		/// <code><![CDATA[
		/// wnd.find("Options").ButtonClick("Cancel");
		/// ]]></code>
		/// </example>
		public void ButtonClick([ParamString(PSFormat.Wildex)] string name, bool asControl = false, string roleCN = null) {
			if (asControl) {
				mouse.postClick(this.Child(1, name, roleCN ?? "*Button*"));
			} else {
				this.Elm[roleCN ?? "BUTTON", name].Find(1).Invoke();
			}
		}

		/// <summary>
		/// Posts a "menu item clicked" notification (<ms>WM_COMMAND</ms>) as if that menu item has been clicked. Does not use the mouse.
		/// </summary>
		/// <param name="itemId">Menu item id. Must be in range 1 to 0xffff.</param>
		/// <param name="systemMenu">The menu item is in the title bar's context menu, not in the menu bar. Posts <ms>WM_SYSCOMMAND</ms> instead.</param>
		/// <exception cref="AuWndException">Invalid window.</exception>
		/// <exception cref="ArgumentOutOfRangeException">Invalid <i>itemId</i>.</exception>
		/// <remarks>
		/// Works only with classic menus. The drop-down menu window class name must be <c>"#32768"</c>. Works with menu items in window menu bar, system menu and some context menus.
		/// Does not use the menu itself. Just posts <c>WM_COMMAND</c> or <c>WM_SYSCOMMAND</c> message. Even if a menu item with this id does not exist.
		/// This variable is the window that contains the menu bar or system menu. Or the drop-down menu window (class <c>"#32768"</c>) that contains the menu item.
		/// </remarks>
		public void MenuClick(int itemId, bool systemMenu = false) {
			if ((uint)(itemId - 1) >= 0xffff) throw new ArgumentOutOfRangeException();
			ThrowIfInvalid();
			var w = this;
			if (ClassNameIs("#32768") && miscInfo.getGUIThreadInfo(out var g, ThreadId) && !g.hwndMenuOwner.Is0) w = g.hwndMenuOwner;
			w.Post(systemMenu ? Api.WM_SYSCOMMAND : Api.WM_COMMAND, itemId);
			w.MinimalSleepIfOtherThread_();
		}

		//rejected: use elm functions instead.
		///// <summary>
		///// Finds a menu item by name and posts a "menu item clicked" notification as if that menu item was clicked. Does not use the mouse.
		///// Works with all standard menus and some non-standard menus.
		///// </summary>
		///// <param name="itemName">
		///// Menu item name.
		///// String format: [wildcard expression](xref:wildcard_expression).
		///// </param>
		///// <param name="systemMenu">The menu item is in the title bar's context menu, not in the menu bar.</param>
		//public void Click([ParamString(PSFormat.wildex)] string itemName, bool systemMenu = false)
		//{
		//	
		//}

		//rejected: need just 1 function. To get state, use elm.
		///// <summary>
		///// Click standard (classic) menu items, get state.
		///// </summary>
		//public static class menu
		//{

		//}
	}
}

namespace Au.Types {
	/// <summary>
	/// Flags for <see cref="wnd.Child"/>.
	/// </summary>
	[Flags]
	public enum WCFlags {
		/// <summary>Can find hidden controls.</summary>
		HiddenToo = 1,

		/// <summary>Skip indirect descendant controls (children of children and so on).</summary>
		DirectChild = 2,
	}

#if !true //rejected. Nobody would use this when there is elm. Eg BM_CLICK is the same as elm.Invoke or elm.PostClick. For Check can use code if(!e.IsChecked) e.Invoke();.
	/// <summary>
	/// Like <see cref="wnd"/>, but has only button, check box and radio button functions - <c>Click</c>, <c>Check</c> etc.
	/// See also <see cref="wnd.AsButton"/>.
	/// </summary>
	/// <example>
	/// <code><![CDATA[
	/// wnd.find("Options").Child("Cancel").AsButton.Click();
	/// ]]></code>
	/// </example>
	public struct WButton
	{
		/// <summary>
		/// Button handle as <see cref="wnd"/>.
		/// </summary>
		public wnd W { get; }

		internal WButton(wnd w) { W = w; }

		///
		public static implicit operator wnd(WButton b) => b.W;

		/////
		//public static explicit operator WButton(wnd w) => new(w);

		///
		public override string ToString() => W.ToString();

		/// <summary>
		/// Posts a "click" message to this button control. Does not use the mouse.
		/// </summary>
		/// <param name="useElm">Use <see cref="elm.Invoke"/>. If <c>false</c> (default), posts <ms>BM_CLICK</ms> message.</param>
		/// <exception cref="AuWndException">This window is invalid.</exception>
		/// <exception cref="AuException">Failed.</exception>
		/// <remarks>
		/// Works not with all button controls. Sometimes does not work if the window is inactive.
		/// Check boxes and radio buttons also are buttons. This function can click them.
		/// </remarks>
		/// <example>
		/// <code><![CDATA[
		/// wnd.find("Options").Child("Cancel").AsButton.Click();
		/// ]]></code>
		/// </example>
		public void Click(bool useElm = false) {
			W.ThrowIfInvalid();
			if (useElm) {
				using var e = elm.fromWindow(W, EObjid.CLIENT); //exception if failed
				e.Invoke();
			} else {
				_PostBmClick(); //async if other thread, because may show a dialog.
			}
			W.MinimalSleepIfOtherThread_();
			//FUTURE: sync better
		}

		void _PostBmClick() {
			var w = W.Window;
			bool workaround = !w.IsActive;
			if (workaround) w.Post(Api.WM_ACTIVATE, 1); //workaround for the documented BM_CLICK bug
			W.Post(BM_CLICK); //it sends WM_LBUTTONDOWN/UP
			if (workaround) w.Post(Api.WM_ACTIVATE, 0);
		}

		/// <summary>
		/// Checks or unchecks this check box. Does not use the mouse.
		/// Calls <see cref="SetCheckState"/> with state 0 or 1.
		/// </summary>
		/// <param name="on">Checks if <c>true</c>, unchecks if <c>false</c>.</param>
		/// <param name="useElm"></param>
		/// <exception cref="AuWndException">This window is invalid.</exception>
		/// <exception cref="AuException">Failed.</exception>
		/// <remarks>
		/// Works not with all button controls. Sometimes does not work if the window is inactive.
		/// If this is a radio button, does not uncheck other radio buttons in its group.
		/// </remarks>
		public void Check(bool on, bool useElm = false) {
			SetCheckState(on ? 1 : 0, useElm);
		}

		/// <summary>
		/// Sets checkbox state. Does not use the mouse.
		/// </summary>
		/// <param name="state">0 unchecked, 1 checked, 2 indeterminate.</param>
		/// <param name="useElm">Use <see cref="elm.Invoke"/>. If <c>false</c> (default), posts <ms>BM_SETCHECK</ms> message and also <c>BN_CLICKED</c> notification to the parent window; if that is not possible, instead uses <ms>BM_CLICK</ms> message.</param>
		/// <exception cref="ArgumentOutOfRangeException">Invalid state.</exception>
		/// <exception cref="AuWndException">This window is invalid.</exception>
		/// <exception cref="AuException">Failed.</exception>
		/// <remarks>
		/// Does nothing if the check box already has the specified check state (if can get it).
		/// Works not with all button controls. Sometimes does not work if the window is inactive.
		/// If this is a radio button, does not uncheck other radio buttons in its group.
		/// </remarks>
		public void SetCheckState(int state, bool useElm = false) {
			if (state < 0 || state > 2) throw new ArgumentOutOfRangeException();
			W.ThrowIfInvalid();
			int id;
			if (useElm || !_IsCheckbox() || (uint)((id = W.ControlId) - 1) >= 0xffff) {
				using var e = elm.fromWindow(W, EObjid.CLIENT); //exception if failed
				int k = _GetElmCheckState(e);
				if (k == state) return;
				if (useElm) e.Invoke(); else _PostBmClick();
				bool clickAgain = false;
				switch (state) {
				case 0:
					if (k == 1) {
						W.MinimalSleepIfOtherThread_();
						if (GetCheckState(true) == 2) clickAgain = true;
						else return;
					}
					break;
				case 1:
					if (k == 2) clickAgain = true;
					break;
				case 2:
					if (k == 0) clickAgain = true;
					break;
				}
				if (clickAgain) {
					if (useElm) e.Invoke(); else _PostBmClick();
				}
			} else {
				if (state == W.Send(BM_GETCHECK)) return;
				W.Post(BM_SETCHECK, state);
				W.Get.DirectParent.Post(Api.WM_COMMAND, id, (nint)W);
			}
			W.MinimalSleepIfOtherThread_();
		}

		/// <summary>
		/// Gets check state of this check box or radio button.
		/// Calls <see cref="GetCheckState"/> and returns <c>true</c> if it returns 1.
		/// </summary>
		public bool IsChecked(bool useElm = false) {
			return 1 == GetCheckState(useElm);
		}

		/// <summary>
		/// Gets check state of this check box or radio button.
		/// Returns 0 if unchecked, 1 if checked, 2 if indeterminate. Also returns 0 if this is not a button or if failed to get state.
		/// </summary>
		/// <param name="useElm">Use <see cref="elm.State"/>. If <c>false</c> (default) and this button has a standard checkbox style, uses API <ms>BM_GETCHECK</ms>.</param>
		public int GetCheckState(bool useElm = false) {
			if (useElm || !_IsCheckbox()) {
				//info: Windows Forms controls are user-drawn and don't have one of the styles, therefore BM_GETCHECK does not work.
				try { //avoid exception in property-get functions
					using var e = elm.fromWindow(W, EObjid.CLIENT, flags: EWFlags.NoThrow);
					if (e == null) return 0;
					return _GetElmCheckState(e);
				}
				catch (Exception ex) { Debug_.Print(ex); } //CONSIDER: if fails, show warning. In all wnd property-get functions.
				return 0;
			} else {
				return (int)W.Send(BM_GETCHECK);
			}
		}

		int _GetElmCheckState(elm e) {
			var state = e.State;
			if (state.Has(EState.MIXED)) return 2;
			if (state.Has(EState.CHECKED)) return 1;
			return 0;
		}

		bool _IsCheckbox() {
			switch ((uint)W.Style & 15) {
			case BS_CHECKBOX:
			case BS_AUTOCHECKBOX:
			case BS_RADIOBUTTON:
			case BS_3STATE:
			case BS_AUTO3STATE:
			case BS_AUTORADIOBUTTON:
				return true;
			}
			return false;
		}

		internal const int BM_CLICK = 0xF5;
		internal const int BM_GETCHECK = 0xF0;
		internal const int BM_SETCHECK = 0xF1;

		internal const uint BS_CHECKBOX = 0x2;
		internal const uint BS_AUTOCHECKBOX = 0x3;
		internal const uint BS_RADIOBUTTON = 0x4;
		internal const uint BS_3STATE = 0x5;
		internal const uint BS_AUTO3STATE = 0x6;
		internal const uint BS_AUTORADIOBUTTON = 0x9;

	}
#endif
}


================================================
FILE: Au/wnd/wnd_find.cs
================================================
namespace Au {
	public unsafe partial struct wnd {
		/// <summary>
		/// Finds a top-level window and returns its handle as <see cref="wnd"/>.
		/// </summary>
		/// <returns>Window handle, or <c>default(wnd)</c> if not found. See also: <see cref="Is0"/>.</returns>
		/// <param name="name">
		/// Window name. Usually it is the title bar text.
		/// String format: [wildcard expression](xref:wildcard_expression).
		/// <c>null</c> means "can be any". <c>""</c> means "no name".
		/// </param>
		/// <param name="cn">
		/// Window class name.
		/// String format: [wildcard expression](xref:wildcard_expression).
		/// <c>null</c> means "can be any". Cannot be <c>""</c>.
		/// </param>
		/// <param name="of">
		/// Owner window, program or thread. Depends on argument type:
		/// <br/>• <see cref="wnd"/> - owner window. Will use <see cref="IsOwnedBy(wnd, int)"/> with level 2.
		/// <br/>• <c>string</c> - program file name, like <c>"notepad.exe"</c>. String format: [wildcard expression](xref:wildcard_expression). Cannot be <c>""</c> or path.
		/// <br/>• <see cref="WOwner"/> - <see cref="WOwner.Process"/>(process id), <see cref="WOwner.Thread"/>(thread id).
		/// 
		/// <para>
		/// See <see cref="getwnd.Owner"/>, <see cref="ProcessId"/>, <see cref="process.thisProcessId"/>, <see cref="ThreadId"/>, <see cref="process.thisThreadId"/>.
		/// </para>
		/// </param>
		/// <param name="flags"></param>
		/// <param name="also">
		/// Callback function. Called for each matching window.
		/// It can evaluate more properties of the window and return <c>true</c> when they match.
		/// Example: <c>also: t => !t.IsPopupWindow</c>.
		/// Called after evaluating all other parameters except <i>contains</i>.
		/// </param>
		/// <param name="contains">
		/// Defines an object that must be in the client area of the window:
		/// <br/>• UI element: <see cref="elmFinder"/> or string like <c>"name"</c> or <c>"e 'role' name"</c> or <c>"e 'role'"</c>.
		/// <br/>• Child control: <see cref="wndChildFinder"/> or string like <c>"c 'cn' name"</c> or <c>"c '' name"</c> or <c>"c 'cn'"</c>.
		/// <br/>• Image(s) or color(s): <see cref="uiimageFinder"/> or string <c>"image:..."</c> (uses a <see cref="uiimageFinder"/> with flag <see cref="IFFlags.WindowDC"/>).
		/// <br/>• OCR text: <see cref="ocrFinder"/> or string <c>"ocr:..."</c> (uses an <see cref="ocrFinder"/> with flag <see cref="OcrFlags.WindowDC"/>).
		/// </param>
		/// <exception cref="ArgumentException">
		/// - <i>cn</i> is <c>""</c>. To match any, use <c>null</c>.
		/// - <i>of</i> is <c>""</c> or 0 or contains character <c>'\\'</c> or <c>'/'</c>. To match any, use <c>null</c>.
		/// - Invalid wildcard expression (<c>"**options "</c> or regular expression).
		/// </exception>
		/// <remarks>
		/// To create code for this function, use tool <b>Find window</b>.
		/// 
		/// If there are multiple matching windows, gets the first in the Z order matching window, preferring visible windows.
		/// 
		/// On Windows 8 and later may skip Windows Store app Metro-style windows (on Windows 10 few such windows exist). It happens if this program does not have <c>disableWindowFiltering = true</c> in its manifest and is not uiAccess; to find such windows you can use <see cref="findFast"/>.
		/// 
		/// To find message-only windows use <see cref="findFast"/> instead.
		/// </remarks>
		/// <example>
		/// Try to find Notepad window. Return if not found.
		/// <code><![CDATA[
		/// wnd w = wnd.find("* Notepad");
		/// if(w.Is0) { print.it("not found"); return; }
		/// ]]></code>
		/// Try to find Notepad window. Throw <see cref="NotFoundException"/> if not found.
		/// <code><![CDATA[
		/// wnd w1 = wnd.find(0, "* Notepad");
		/// ]]></code>
		/// Wait for Notepad window max 3 seconds. Throw <see cref="NotFoundException"/> if not found during that time.
		/// <code><![CDATA[
		/// wnd w1 = wnd.find(3, "* Notepad");
		/// ]]></code>
		/// Wait for Notepad window max 3 seconds. Return if not found during that time.
		/// <code><![CDATA[
		/// wnd w1 = wnd.find(-3, "* Notepad");
		/// if(w.Is0) { print.it("not found"); return; }
		/// ]]></code>
		/// Wait for Notepad window max 3 seconds. Throw <see cref="NotFoundException"/> if not found during that time. When found, wait max 1 s until becomes active, then activate.
		/// <code><![CDATA[
		/// wnd w1 = wnd.find(3, "* Notepad").Activate(1);
		/// ]]></code>
		/// </example>
		public static wnd find(
			[ParamString(PSFormat.Wildex)] string name = null,
			[ParamString(PSFormat.Wildex)] string cn = null,
			[ParamString(PSFormat.Wildex)] WOwner of = default,
			WFlags flags = 0, Func<wnd, bool> also = null, WContains contains = default
			) => new wndFinder(name, cn, of, flags, also, contains).Find();
		
		//rejected: single overload with last parameter double? wait.
		//	Then in scripts almost always would need eg ' , wait: 1'. Or would need ', wait: 0' just for 'exception if not found'.
		
		/// <summary>
		/// Finds a top-level window and returns its handle as <see cref="wnd"/>. Can wait and throw <see cref="NotFoundException"/>.
		/// </summary>
		/// <returns>Window handle. If not found, throws exception or returns <c>default(wnd)</c> (if <i>wait</i> negative).</returns>
		/// <param name="wait">The wait timeout, seconds. If 0, does not wait. If negative, does not throw exception when not found.</param>
		/// <exception cref="NotFoundException" />
		/// <inheritdoc cref="find(string, string, WOwner, WFlags, Func{wnd, bool}, WContains)" path="//param|//exception"/>
		public static wnd find(
			Seconds wait,
			[ParamString(PSFormat.Wildex)] string name = null,
			[ParamString(PSFormat.Wildex)] string cn = null,
			[ParamString(PSFormat.Wildex)] WOwner of = default,
			WFlags flags = 0, Func<wnd, bool> also = null, WContains contains = default
			) => new wndFinder(name, cn, of, flags, also, contains).Find(wait);
		
		//rejected: probably most users will not understand/use it. It's easy and more clear to create and use wndFinder instances.
		///// <summary>
		///// Gets arguments and result of this thread's last call to <see cref="Find"/> or <see cref="FindAll"/>.
		///// </summary>
		///// <remarks>
		///// <c>wnd.wait</c> and similar functions don't change this property. <see cref="FindOrRun"/> and some other functions of this library change this property because they call <see cref="Find"/> internally.
		///// </remarks>
		///// <example>
		///// This example is similar to what <see cref="FindOrRun"/> does.
		///// <code><![CDATA[
		///// wnd w = wnd.find("*- Notepad", "Notepad");
		///// if(w.Is0) { run.it("notepad.exe"); w = wnd.waitAny(60, true, wnd.LastFind).w; }
		///// ]]></code>
		///// </example>
		//[field: ThreadStatic]
		//public static wndFinder lastFind { get; set; }
		
		//CONSIDER: add property: [field: ThreadStatic] public static wnd last { get; set; }
		
		/// <summary>
		/// Finds all matching windows.
		/// </summary>
		/// <returns>Array containing zero or more <see cref="wnd"/>.</returns>
		/// <remarks>
		/// The list is sorted to match the Z order, however hidden windows (when using <see cref="WFlags.HiddenToo"/>) and IME windows are always after visible windows.
		/// </remarks>
		/// <seealso cref="getwnd.allWindows"/>
		/// <seealso cref="getwnd.mainWindows"/>
		/// <seealso cref="getwnd.threadWindows"/>
		/// <inheritdoc cref="find(string, string, WOwner, WFlags, Func{wnd, bool}, WContains)" path="//param|//exception"/>
		public static wnd[] findAll(
			[ParamString(PSFormat.Wildex)] string name = null,
			[ParamString(PSFormat.Wildex)] string cn = null,
			[ParamString(PSFormat.Wildex)] WOwner of = default,
			WFlags flags = 0, Func<wnd, bool> also = null, WContains contains = default) {
			var f = new wndFinder(name, cn, of, flags, also, contains);
			var a = f.FindAll();
			//LastFind = f;
			return a;
		}
		
		/// <summary>
		/// Finds a top-level window and returns its handle as <see cref="wnd"/>.
		/// </summary>
		/// <returns>Returns <c>default(wnd)</c> if not found. See also: <see cref="Is0"/>.</returns>
		/// <param name="name">
		/// Name.
		/// Full, case-insensitive. Wildcard etc not supported.
		/// <c>null</c> means "can be any". <c>""</c> means "no name".
		/// </param>
		/// <param name="cn">
		/// Class name.
		/// Full, case-insensitive. Wildcard etc not supported.
		/// <c>null</c> means "can be any". Cannot be <c>""</c>.
		/// </param>
		/// <param name="messageOnly">Search only message-only windows.</param>
		/// <param name="wAfter">If used, starts searching from the next window in the Z order.</param>
		/// <remarks>
		/// Calls API <ms>FindWindowEx</ms>.
		/// Faster than <see cref="find"/>, which uses API <ms>EnumWindows</ms>.
		/// Finds hidden windows too.
		/// Supports <see cref="lastError"/>.
		/// It is not recommended to use this function in a loop to enumerate windows. It would be unreliable because window positions in the Z order can be changed while enumerating. Also then it would be slower than <see cref="find"/> and <see cref="findAll"/>.
		/// </remarks>
		public static wnd findFast(string name = null, string cn = null, bool messageOnly = false, wnd wAfter = default) {
			return Api.FindWindowEx(messageOnly ? SpecHWND.MESSAGE : default, wAfter, cn, name);
		}
		
		internal struct Cached_ {
			wnd _w;
			long _time;
			
			/// <summary>
			/// Calls/returns <see cref="findFast"/> and stores found <see cref="wnd"/> and time. Returns the cached <see cref="wnd"/> if called frequently and it's still valid.
			/// </summary>
			public wnd FindFast(string name, string cn, bool messageOnly) {
				long t = Environment.TickCount64;
				if (t - _time > 1000 || !_w.IsAlive) {
					lock ("x5rX3BZJrE+pOTqszh4ttQ") {
						if (t - _time > 1000 || !_w.IsAlive) {
							_w = findFast(name, cn, messageOnly);
						}
					}
				}
				_time = t;
				return _w;
			}
			
			/// <summary>
			/// Calls/returns callback <i>f</i> and stores found <see cref="wnd"/> and time. Returns the cached <see cref="wnd"/> if called frequently and it's still valid.
			/// </summary>
			public wnd Get(Func<wnd> f) {
				long t = Environment.TickCount64;
				if (t - _time > 1000 || !_w.IsAlive) {
					lock ("x5rX3BZJrE+pOTqszh4ttQ") {
						if (t - _time > 1000 || !_w.IsAlive) {
							_w = f();
						}
					}
				}
				_time = t;
				return _w;
			}
		}
		
		/// <summary>
		/// Finds a top-level window, like <see cref="find"/>. If found, activates (optionally), else calls callback function and waits for the window. The callback should open the window, for example call <see cref="run.it"/>.
		/// </summary>
		/// <returns>Window handle as <see cref="wnd"/>. On timeout returns <c>default(wnd)</c> if <i>wait</i> &lt; 0 (else exception).</returns>
		/// <param name="run">Callback function. See example.</param>
		/// <param name="wait">How long to wait for the window after calling the callback function. Seconds. Default 60.</param>
		/// <param name="activate">Activate the window. Default: <c>true</c>.</param>
		/// <exception cref="NotFoundException"><i>wait</i> time has expired (if >= 0).</exception>
		/// <exception cref="AuWndException">Failed to activate.</exception>
		/// <example>
		/// <code><![CDATA[
		/// wnd w = wnd.findOrRun("* Notepad", run: () => run.it("notepad.exe"));
		/// print.it(w);
		/// ]]></code>
		/// </example>
		/// <inheritdoc cref="find(string, string, WOwner, WFlags, Func{wnd, bool}, WContains)" path="//param|//exception"/>
		public static wnd findOrRun(
			[ParamString(PSFormat.Wildex)] string name = null,
			[ParamString(PSFormat.Wildex)] string cn = null,
			[ParamString(PSFormat.Wildex)] WOwner of = default,
			WFlags flags = 0, Func<wnd, bool> also = null, WContains contains = default,
			Action run = null, Seconds? wait = default, bool activate = true) {
			wnd w = default;
			var f = new wndFinder(name, cn, of, flags, also, contains);
			if (f.Exists()) {
				w = f.Result;
				if (activate) w.Activate();
			} else {
				run();
				if (!f.Exists(wait ?? new(60))) return default;
				w = f.Result;
				if (activate) w._ActivateAfterRun();
			}
			return w;
		}
		
		//What to do if activate true and the window started inactive? Activate immediately or wait, and how long?
		//	Possible cases:
		//		Starts inactive, but soon becomes active naturally.
		//		Occasionally starts inactive and never would become active naturally, for example if the user clicked another window after starting the process and therefore OS disabled setforegroundwindow in the new process.
		//		Always starts inactive and never becomes active naturally.
		//	This code waits max 1 s. It's better if the window becomes active naturally (case 1), but need to activate in cases 2 and 3.
		//	Tested many windows. Most were active after 0-10 ms, few after 11-70 ms, PowerShell after 250 ms, dotPeek after 1000 ms.
		//	Some windows start active but soon a dialog pops up.
		//	Also tested what happens if we activate the "slow" window without waiting.
		//		Some are OK (eg PowerShell). Anyway, many windows render content after showing/activating.
		//		But some windows (eg dotPeek) then soon become inactive temporarily, because the app activates another window.
		void _ActivateAfterRun() {
			if (!IsActive && !WaitFor(-1, w => w.IsActive)) {
				Activate();
			}
			//note: exception if closed while waiting. As well as if fails to activate.
		}
		
		/// <summary>
		/// Opens and finds new window. Ignores old windows. Activates.
		/// </summary>
		/// <returns>Window handle as <see cref="wnd"/>. On timeout returns <c>default(wnd)</c> if <i>timeout</i> &lt; 0 (else exception).</returns>
		/// <param name="timeout">How long to wait for the window. Seconds. Can be 0 (infinite), >0 (exception on timeout) or &lt;0 (no exception). More info: [](xref:wait_timeout).</param>
		/// <param name="run">Callback function. Should open the window. See example.</param>
		/// <param name="activate">Activate the window. Default: <c>true</c>.</param>
		/// <exception cref="TimeoutException"><i>timeout</i> time has expired (if > 0).</exception>
		/// <exception cref="AuWndException">Failed to activate.</exception>
		/// <remarks>
		/// This function isn't the same as just two statements <see cref="run.it"/> and <see cref="wnd.find"/>. It never returns a window that already existed before calling it.
		/// </remarks>
		/// <example>
		/// <code><![CDATA[
		/// var w = wnd.runAndFind(
		/// 	() => run.it(folders.Windows + @"explorer.exe"),
		/// 	10, cn: "CabinetWClass");
		/// print.it(w);
		/// ]]></code>
		/// </example>
		/// <inheritdoc cref="find(string, string, WOwner, WFlags, Func{wnd, bool}, WContains)" path="//param|//exception"/>
		public static wnd runAndFind(Action run, Seconds timeout,
			[ParamString(PSFormat.Wildex)] string name = null,
			[ParamString(PSFormat.Wildex)] string cn = null,
			[ParamString(PSFormat.Wildex)] WOwner of = default,
			WFlags flags = 0, Func<wnd, bool> also = null, WContains contains = default,
			bool activate = true) {
			var f = new wndFinder(name, cn);
			var a = f.FindAll();
			
			run();
			
			var loop = new WaitLoop(timeout);
			while (loop.Sleep()) {
				var w = f.Find();
				if (!w.Is0 && !a.Contains(w)) {
					if (activate) w._ActivateAfterRun();
					return w;
				}
			}
			return default;
		}
		
		/// <summary>
		/// Compares window name and other properties like <see cref="find"/> does.
		/// </summary>
		/// <returns><c>true</c> if all specified (non-<c>null</c>/default) properties match.</returns>
		/// <remarks>
		/// Creates new <see cref="wndFinder"/> and calls <see cref="wndFinder.IsMatch"/>.
		/// To compare single parameter, use more lightweight code. Examples: <c>if (w.Name.Like("* Notepad"))</c>, <c>if (w.ClassNameIs("CabinetWClass"))</c>.
		/// </remarks>
		/// <seealso cref="Name"/>
		/// <seealso cref="ClassName"/>
		/// <seealso cref="ClassNameIs"/>
		/// <seealso cref="ProgramName"/>
		/// <inheritdoc cref="find(string, string, WOwner, WFlags, Func{wnd, bool}, WContains)" path="//param|//exception"/>
		public bool IsMatch(
			[ParamString(PSFormat.Wildex)] string name = null,
			[ParamString(PSFormat.Wildex)] string cn = null,
			[ParamString(PSFormat.Wildex)] WOwner of = default,
			WFlags flags = 0,
			Func<wnd, bool> also = null,
			WContains contains = default
			) {
			var f = new wndFinder(name, cn, of, flags, also, contains);
			return f.IsMatch(this);
		}
		
		/// <summary>
		/// Compares window name and other properties like <see cref="find"/> does. Can be specified multiple windows.
		/// </summary>
		/// <returns>1-based index of the match, or 0 if none.</returns>
		/// <example>
		/// <code><![CDATA[
		/// var w = wnd.active;
		/// int i = w.IsMatch([new("name1", "class1"), new("name2", of: "program2")]);
		/// print.it(i);
		/// ]]></code>
		/// Cache finders to improve performance when IsMatch is called multiple times. Creating all finders each time is expensive.
		/// <code><![CDATA[
		/// class C {
		/// 	static wndFinder[] s_wf1;
		/// 	
		/// 	void F(wnd w) {
		/// 		int i = w.IsMatch(s_wf1 ??= [new("name1", "class1"), new("name2", of: "program2")]);
		/// 		print.it(i);
		/// 	}
		/// }
		/// ]]></code>
		/// </example>
		public int IsMatch(ReadOnlySpan<wndFinder> windows) {
			WFCache cache = windows.Length > 1 ? new() { CacheName = true, NoTimeout = true } : null;
			for (int i = 0; i < windows.Length; i++) {
				if (windows[i].IsMatch(this, cache)) return i + 1;
			}
			return 0;
		}
		
		public partial struct getwnd {
			/// <summary>
			/// Gets top-level windows.
			/// </summary>
			/// <returns>Array containing zero or more <see cref="wnd"/>.</returns>
			/// <param name="onlyVisible">
			/// Need only visible windows.
			/// Note: this function does not check whether windows are cloaked, as it is rather slow. Use <see cref="IsCloaked"/> if need.
			/// </param>
			/// <param name="sortFirstVisible">
			/// Place hidden windows at the end of the array.
			/// Not used when <i>onlyVisible</i> is <c>true</c>.</param>
			/// <remarks>
			/// Calls API <ms>EnumWindows</ms>.
			/// Although undocumented, the API retrieves most windows as in the Z order, however places IME windows (hidden) at the end. See also: <see cref="allWindowsZorder"/>;
			/// <note>The array can be bigger than you expect, because there are many invisible windows, tooltips, etc. See also <see cref="mainWindows"/>.</note>
			/// Skips message-only windows; use <see cref="findFast"/> if need.
			/// On Windows 8 and later may skip Windows Store app Metro-style windows (on Windows 10 few such windows exist). It happens if this program does not have <c>disableWindowFiltering = true</c> in its manifest and is not uiAccess; to find such windows you can use <see cref="findFast"/>.
			/// Tip: To get top-level and child windows in single array: <c>var a = wnd.getwnd.root.Get.Children();</c>.
			/// </remarks>
			/// <seealso cref="Children"/>
			/// <seealso cref="findAll"/>
			public static wnd[] allWindows(bool onlyVisible = false, bool sortFirstVisible = false) {
				return Internal_.EnumWindows(Internal_.EnumAPI.EnumWindows, onlyVisible, sortFirstVisible);
			}
			
			/// <summary>
			/// Gets top-level windows ordered as in the Z order.
			/// </summary>
			/// <returns>Array containing zero or more <see cref="wnd"/>.</returns>
			/// <remarks>
			/// Uses API <ms>GetWindow</ms> and ensures it is reliable.
			/// </remarks>
			public static wnd[] allWindowsZorder() {
				//Algorithm to make getting all windows with GetWindow reliable:
				//	Get all windows 2 times, and compare results. If different, wait 1-2 ms and repeat.
				//	Still occasionally 1 window missing.
				//		It seems, when OS is reordering windows, it removes a window from its internal array and inserts in another place not atomically.
				//		To fix it, wait 1 ms after the first _GetWindows if results are different than previously.
				//Tested in stress conditions and compared with EnumWindows results. Never failed.
				//Speed with cold CPU: ~20% faster than EnumWindows.
				
				WeakReference<List<wnd>> wr1 = t_awz.wr1, wr2 = t_awz.wr2;
				if (wr1 == null) t_awz = (wr1 = new(null), wr2 = new(null), default);
				if (!wr1.TryGetTarget(out var a1)) wr1.SetTarget(a1 = new(800));
				if (!wr2.TryGetTarget(out var a2)) wr2.SetTarget(a2 = new(800));
				
				int nRetry = 0;
				_GetWindows(a1);
				
				//the fix
				var hash1 = _Hash(a1);
				if (hash1 != t_awz.hash1) 1.ms();
				
				g1:
				_GetWindows(a2);
				if (a1.SequenceEqual(a2)) {
					Debug_.PrintIf(nRetry > 50, nRetry);
					t_awz.hash1 = nRetry == 0 ? hash1 : _Hash(a2);
					return a2.ToArray();
				}
				Math2.Swap(ref a1, ref a2);
				1.ms();
				nRetry++;
				goto g1;
				
				void _GetWindows(List<wnd> a) {
					a.Clear();
					for (var w = wnd.getwnd.top; !w.Is0; w = w.Get.Next()) a.Add(w);
				}
				
				Hash.MD5Result _Hash(List<wnd> a) {
					return Hash.MD5(MemoryMarshal.AsBytes(CollectionsMarshal.AsSpan(a)));
				}
			}
			[ThreadStatic] static (WeakReference<List<wnd>> wr1, WeakReference<List<wnd>> wr2, Hash.MD5Result hash1) t_awz;
			
			/// <summary>
			/// Gets top-level windows of a thread.
			/// </summary>
			/// <returns>Array containing zero or more <see cref="wnd"/>.</returns>
			/// <param name="threadId">
			/// Unmanaged thread id.
			/// See <see cref="process.thisThreadId"/>, <see cref="ThreadId"/>.
			/// If 0, throws exception. If other invalid value (ended thread?), returns empty list. Supports <see cref="lastError"/>.
			/// </param>
			/// <param name="onlyVisible">Need only visible windows.</param>
			/// <param name="sortFirstVisible">Place all array elements of hidden windows at the end of the array, even if the hidden windows are before some visible windows in the Z order.</param>
			/// <exception cref="ArgumentException"><i>threadId</i> is 0.</exception>
			/// <remarks>
			/// Calls API <ms>EnumThreadWindows</ms>.
			/// </remarks>
			/// <seealso cref="process.thisThreadHasMessageLoop"/>
			public static wnd[] threadWindows(int threadId, bool onlyVisible = false, bool sortFirstVisible = false) {
				if (threadId == 0) throw new ArgumentException("0 threadId.");
				return Internal_.EnumWindows(Internal_.EnumAPI.EnumThreadWindows, onlyVisible, sortFirstVisible, threadId: threadId);
			}
			
			//rejected
			///// <param name="a">Receives results. If <c>null</c>, this function creates new <c>List</c>, else clears before adding items.</param>
			///// <remarks>This overload can be used to avoid much garbage when calling frequently.</remarks>
			///// <inheritdoc cref="threadWindows(int, bool, bool)"/>
			//public static void threadWindows(ref List<wnd> a, int threadId, bool onlyVisible = false, bool sortFirstVisible = false) {
			//	if (threadId == 0) throw new ArgumentException("0 threadId.");
			//	Internal_.EnumWindows2(Internal_.EnumAPI.EnumThreadWindows, onlyVisible, sortFirstVisible, threadId: threadId, list: a ??= new List<wnd>());
			//}
			
			/// <summary>
			/// Gets the first in Z order window of this thread.
			/// </summary>
			/// <param name="onlyVisible"></param>
			/// <param name="nonPopup">Skip <c>WS_POPUP</c> without <c>WS_CAPTION</c>.</param>
			internal static wnd TopThreadWindow_(bool onlyVisible, bool nonPopup) {
				wnd r = default;
				Api.EnumThreadWindows(Api.GetCurrentThreadId(), (w, _) => {
					if (onlyVisible && !w.IsVisible) return 1;
					if (nonPopup) if ((w.Style & (WS.POPUP | WS.CAPTION)) == WS.POPUP) return 1;
					r = w;
					return 0;
				});
				return r;
			}
		}
		
		/// <summary>
		/// Internal static functions.
		/// </summary>
		internal static partial class Internal_ {
			internal enum EnumAPI { EnumWindows, EnumThreadWindows, EnumChildWindows, }
			
			internal static wnd[] EnumWindows(EnumAPI api,
				bool onlyVisible, bool sortFirstVisible, wnd wParent = default, bool directChild = false, int threadId = 0) {
				using var a = EnumWindows2(api, onlyVisible, sortFirstVisible, wParent, directChild, threadId);
				return a.ToArray();
			}
			
			/// <summary>
			/// This version creates much less garbage.
			/// The caller must dispose the returned <c>ArrayBuilder_</c>, unless list is not <c>null</c>.
			/// If list is not <c>null</c>, adds windows there (clears at first) and returns <c>default(ArrayBuilder_)</c>.
			/// </summary>
			internal static ArrayBuilder_<wnd> EnumWindows2(EnumAPI api,
				bool onlyVisible, bool sortFirstVisible = false, wnd wParent = default, bool directChild = false, int threadId = 0,
				Func<wnd, object, bool> predicate = null, object predParam = default, List<wnd> list = null
				) {
				if (directChild && wParent == getwnd.root) { api = EnumAPI.EnumWindows; wParent = default; }
				
				ArrayBuilder_<wnd> ab = default;
				bool disposeArray = true;
				var d = new _EnumData { api = api, onlyVisible = onlyVisible, directChild = directChild, wParent = wParent };
				try {
					switch (api) {
					case EnumAPI.EnumWindows:
						Api.EnumWindows(_wndEnumProc, &d);
						break;
					case EnumAPI.EnumThreadWindows:
						Api.EnumThreadWindows(threadId, _wndEnumProc, &d);
						break;
					case EnumAPI.EnumChildWindows:
						Api.EnumChildWindows(wParent, _wndEnumProc, &d);
						break;
					}
					
					int n = d.len;
					if (n > 0) {
						if (predicate != null) {
							n = 0;
							for (int i = 0; i < d.len; i++) {
								if (predicate((wnd)d.a[i], predParam)) d.a[n++] = d.a[i];
							}
						}
						
						if (list != null) {
							list.Clear();
							if (list.Capacity < n) list.Capacity = n + n / 2;
						} else {
							ab.Alloc(n, zeroInit: false, noExtra: true);
						}
						if (sortFirstVisible && !onlyVisible) {
							int j = 0;
							for (int i = 0; i < n; i++) {
								var w = (wnd)d.a[i];
								if (!_EnumIsVisible(w, api, wParent)) continue;
								if (list != null) list.Add(w); else ab[j++] = w;
								d.a[i] = 0;
							}
							for (int i = 0; i < n; i++) {
								int wi = d.a[i];
								if (wi == 0) continue;
								var w = (wnd)wi;
								if (list != null) list.Add(w); else ab[j++] = w;
							}
						} else if (list != null) {
							for (int i = 0; i < n; i++) list.Add((wnd)d.a[i]);
						} else {
							for (int i = 0; i < n; i++) ab[i] = (wnd)d.a[i];
						}
					}
					disposeArray = false;
					return ab;
				}
				finally {
					MemoryUtil.Free(d.a);
					if (disposeArray) ab.Dispose();
				}
			}
			static Api.WNDENUMPROC _wndEnumProc = (w, p) => ((_EnumData*)p)->Proc(w);
			
			struct _EnumData {
				public int* a;
				public int len;
				int _cap;
				public EnumAPI api;
				public bool onlyVisible, directChild;
				public wnd wParent;
				int _ownerTid;
				bool _ownerFound;
				
				public int Proc(wnd w) {
					if (api == EnumAPI.EnumChildWindows) {
						if (onlyVisible && !w.IsVisibleIn_(wParent)) return 1;
						if (directChild && w.ParentGWL_ != wParent) return 1;
					} else if (wParent.Is0) {
						if (onlyVisible && !w.IsVisible) return 1;
					} else {
						if (!_ownerFound && w == wParent) { _ownerFound = true; return 1; }
						if (onlyVisible && !w.IsVisible) return 1;
						if (!w.IsOwnedBy2_(wParent, _ownerFound ? 1 : 2, ref _ownerTid)) return 1;
						//if _ownerFound, still call with level 1, in case of bug "owned window is behind owner"
					}
					if (a == null) a = MemoryUtil.Alloc<int>(_cap = onlyVisible ? 200 : 1000);
					else if (len == _cap) MemoryUtil.ReAlloc(ref a, _cap *= 2);
					a[len++] = (int)w;
					return 1;
				}
				
				//note: need this in exe manifest. Else EnumWindows skips "immersive" windows if this process is not admin/uiAccess.
				/*
<asmv3:application>
...
<asmv3:windowsSettings xmlns="http://schemas.microsoft.com/SMI/2011/WindowsSettings">
  <disableWindowFiltering>true</disableWindowFiltering>
</asmv3:windowsSettings>
</asmv3:application>
				*/
			}
			
			static bool _EnumIsVisible(wnd w, EnumAPI api, wnd wParent)
				=> api == EnumAPI.EnumChildWindows ? w.IsVisibleIn_(wParent) : w.IsVisible;
		}
	}
}

namespace Au.Types {
	/// <summary>
	/// Flags of <see cref="wnd.find"/> and similar functions.
	/// </summary>
	[Flags]
	public enum WFlags {
		/// <summary>
		/// Can find invisible windows. See <see cref="wnd.IsVisible"/>.
		/// Use this carefully. Always use <i>cn</i> (class name), not just <i>name</i>, to avoid finding a wrong window with the same name.
		/// </summary>
		HiddenToo = 1,
		
		/// <summary>
		/// Can find cloaked windows. See <see cref="wnd.IsCloaked"/>.
		/// Cloaked are windows hidden not in the classic way, therefore <see cref="wnd.IsVisible"/> does not detect it, but <see cref="wnd.IsCloaked"/> detects. For example, windows on inactive Windows 10 virtual desktops, ghost windows of inactive Windows Store apps, various hidden system windows.
		/// Use this carefully. Always use <i>cn</i> (class name), not just <i>name</i>, to avoid finding a wrong window with the same name.
		/// </summary>
		CloakedToo = 2,
	}
	
	/// <summary>
	/// Used with <see cref="wnd.find"/> and similar functions to specify an owner of the window.
	/// Can be program name (like <c>"notepad.exe"</c>), process id (<see cref="Process"/>), thread id (<see cref="Thread"/> or <see cref="ThisThread"/>), owner window.
	/// </summary>
	public struct WOwner {
		readonly string _s; //program
		readonly int _i; //wnd, tid, pid
		readonly byte _what; //0 _o, 1 owner, 2 tid, 3 pid
		
		//readonly byte _ownerLevel; //rejected. Rarely used. Can use *also* instead.
		
		WOwner(string s) => _s = s;
		
		WOwner(int i, byte what) { _i = i; _what = what; }
		
		/// <summary>Program name like <c>"notepad.exe"</c>, or <c>null</c>. See <see cref="wnd.ProgramName"/>.</summary>
		public static implicit operator WOwner([ParamString(PSFormat.Wildex)] string program) => new(program);
		
		/// <summary>Owner window. See <see cref="wnd.getwnd.Owner"/>. Will use <see cref="wnd.IsOwnedBy(wnd, int)"/> with level 2.</summary>
		public static implicit operator WOwner(wnd ownerWindow) => new((int)ownerWindow, 1);
		
		///// <summary>Owner window. See <see cref="wnd.getwnd.Owner"/>. Will use <see cref="wnd.IsOwnedBy(wnd, int)"/> with level 2.</summary>
		//public static implicit operator WOwner(System.Windows.DependencyObject ownerWindow) => new((int)ownerWindow.Hwnd(), 1);
		
		/// <summary>Process id. See <see cref="wnd.ProcessId"/>.</summary>
		public static WOwner Process(int processId) => new(processId, 3);
		
		/// <summary>Thread id. See <see cref="wnd.ThreadId"/>.</summary>
		public static WOwner Thread(int threadId) => new(threadId, 2);
		
		/// <summary>Thread id of this thread.</summary>
		public static WOwner ThisThread => new(Api.GetCurrentThreadId(), 2);
		
		/// <summary>
		/// Gets program name or process id or thread id or owner window.
		/// Other variables will be <c>null</c>/0.
		/// </summary>
		/// <exception cref="ArgumentException">The value is <c>""</c> or 0 or contains characters <c>'\\'</c> or <c>'/'</c> or is invalid wildcard expression.</exception>
		public void GetValue(out wildex program, out int pid, out int tid, out wnd owner) {
			program = null; pid = 0; tid = 0; owner = default;
			switch (_what) {
			case 0 when _s != null:
				if (_s.Length == 0) throw new ArgumentException("Program name cannot be \"\". Use null.");
				if (!_s.Starts("**")) { //can be regex
					if (_s.FindAny(@"\/") >= 0) throw new ArgumentException("Program name contains \\ or /.");
					if (pathname.findExtension(_s) < 0 && !wildex.hasWildcardChars(_s)) print.warning("Program name without .exe.");
				}
				program = _s;
				break;
			case 1:
				owner = (wnd)_i;
				if (owner.Is0) throw new ArgumentException("owner window 0");
				break;
			case 2:
				if ((tid = _i) == 0) throw new ArgumentException("thread id 0");
				break;
			case 3:
				if ((pid = _i) == 0) throw new ArgumentException("process id 0");
				break;
			}
		}
		
		/// <summary>
		/// Returns <c>true</c> if nothing was assigned to this variable.
		/// </summary>
		public bool IsEmpty => _what == 0 && _s == null;
	}
	
	/// <summary>
	/// The <i>contains</i> parameter of <see cref="wnd.find"/> and similar functions.
	/// Specifies text, image or other object that must be in the window.
	/// </summary>
	public struct WContains {
		readonly object _o;
		WContains(object o) => _o = o;
		
		///
		public static implicit operator WContains(wndChildFinder f) => new(f);
		
		///
		public static implicit operator WContains(elmFinder f) => new(f);
		
		///
		public static implicit operator WContains(uiimageFinder f) => new(f);
		
		///
		public static implicit operator WContains(ocrFinder f) => new(f);
		
		/// <summary>
		/// Converts from string to <see cref="wndChildFinder"/>, <see cref="elmFinder"/>, <see cref="uiimageFinder"/> or <see cref="ocrFinder"/>.
		/// See <see cref="wnd.find"/>.
		/// </summary>
		/// <exception cref="Exception">Exceptions of constructor of <see cref="wndChildFinder"/>, <see cref="elmFinder"/>, <see cref="uiimageFinder"/> or <see cref="ocrFinder"/>.</exception>
		public static implicit operator WContains(string s) => new(_ParseString(s));
		
		static object _ParseString(string s) {
			if (s.NE()) return null;
			string role = null, name = s;
			switch (s[0]) {
			case 'e': //"e 'role' name" or just "name"
			case 'c': //"c 'class' text"
				if (s.RxMatch(@"^. ?'(.+?)?' ?((?s).+)?$", out var m)) {
					role = m[1].Value; name = m[2].Value;
					if (s[0] == 'c') return new wndChildFinder(name, role);
				}
				break;
			case 'i' when s.Starts("image:"):
				return new uiimageFinder(s, IFFlags.WindowDC);
			case 'o' when s.Starts("ocr:"):
				return new ocrFinder(s[4..], OcrFlags.WindowDC);
			}
			return new elmFinder(role, name, flags: EFFlags.ClientArea) { ResultGetProperty = '-' };
		}
		
		/// <summary>
		/// Gets object stored in this variable. Can be <c>null</c>, <see cref="wndChildFinder"/>, <see cref="elmFinder"/>, <see cref="uiimageFinder"/> or <see cref="ocrFinder"/>.
		/// </summary>
		public object Value => _o;
	}
	
	/// <summary>
	/// Can be used with <see cref="wndFinder.IsMatch"/>.
	/// </summary>
	public class WFCache {
		wnd _w;
		long _time;
		internal string Name, Class, Program;
		internal int Tid, Pid;
		
		/// <summary>
		/// Cache window name.
		/// Default: <c>false</c>.
		/// </summary>
		/// <remarks>
		/// Window name is not cached by default because can be changed. Window class name and program name are always cached because cannot be changed.
		/// </remarks>
		public bool CacheName { get; set; }
		
		/// <summary>
		/// Don't auto-clear cached properties on timeout.
		/// </summary>
		public bool NoTimeout { get; set; }
		
		internal void Begin(wnd w) {
			if (NoTimeout) {
				if (w != _w) {
					Clear();
					_w = w;
				}
			} else {
				var t = Api.GetTickCount64();
				if (w != _w || t - _time > 2500) {
					Clear();
					if (w.IsAlive) { _w = w; _time = t; }
				}
				//else if(CacheName && t - _time > 100) Name = null; //no, instead let call Clear if need
			}
		}
		
		/// <summary>
		/// Clears all cached properties, or only name.
		/// </summary>
		/// <remarks>
		/// Usually don't need to call this function. It is implicitly called when the variable is used with a new window.
		/// </remarks>
		/// <param name="onlyName">Clear only name (because it may change, unlike other cached properties).</param>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Clear(bool onlyName = false) {
			if (onlyName) Name = null;
			else { _w = default; _time = 0; Name = Class = Program = null; Tid = Pid = 0; }
		}
		
		/// <summary>
		/// Match invisible and cloaked windows too, even if the flags are not set (see <see cref="WFlags"/>).
		/// </summary>
		public bool IgnoreVisibility { get; set; }
	}
}


================================================
FILE: Au/wnd/wnd_fromxy.cs
================================================
namespace Au {
	public partial struct wnd {
		/// <summary>
		/// Gets visible top-level window or control from point.
		/// </summary>
		/// <param name="p">
		/// Coordinates.
		/// Tip: To specify coordinates relative to the right, bottom, work area or a non-primary screen, use <see cref="Coord.Normalize"/>, like in the example.
		/// </param>
		/// <param name="flags"></param>
		/// <remarks>
		/// Unlike API <ms>WindowFromPhysicalPoint</ms> etc, this function: does not skip disabled controls; always skips transparent control like group box if a smaller sibling is there. All this is not true with flag <c>Raw</c>.
		/// </remarks>
		/// <example>
		/// Find window at 100 200.
		/// <code><![CDATA[
		/// var w = wnd.FromXY((100, 200), WXYFlags.NeedWindow);
		/// print.it(w);
		/// ]]></code>
		/// 
		/// Find window or control at 50 from left and 100 from bottom of the work area.
		/// <code><![CDATA[
		/// var w = wnd.FromXY(Coord.Normalize(50, ^100, workArea: true));
		/// print.it(w);
		/// ]]></code>
		/// </example>
		public static wnd fromXY(POINT p, WXYFlags flags = 0) {
			bool needW = flags.Has(WXYFlags.NeedWindow);
			bool needC = flags.Has(WXYFlags.NeedControl);
			if (needW && needC) throw new ArgumentException("", "flags");
			
			if (flags.HasAny(WXYFlags.Raw | WXYFlags.NeedWindow)) {
				var w = Api.WindowFromPoint(p);
				if (needW) return w.Window;
				return !needC || w.IsChild ? w : default;
			} else {
				var w = _FromXY(p, out bool isChild);
				return !needC || isChild ? w : default;
			}
			
			//info:
			//WindowFromPoint is the most reliable. It skips really transparent top-level windows (TL). Unfortunately it skips disabled controls (but not TL).
			//ChildWindowFromPointEx with CWP_SKIPINVISIBLE|CWP_SKIPTRANSPARENT skips all with WS_EX_TRANSPARENT, although without WS_EX_LAYERED they aren't actually transparent.
			//RealChildWindowFromPoint does not skip transparent TL. It works like ChildWindowFromPointEx(CWP_SKIPINVISIBLE).
			//None of the above API prefers a really visible control that is under a transparent part of a sibling control. RealChildWindowFromPoint does it only for group buttons, but not for tab controls etc.
			//All API skip windows that have a hole etc in window region at that point.
			//If same thread, WindowFromPoint uses WM_NCHITTEST+HTTRANSPARENT. Other API tested only with TL of other processes and don't use.
			//AccessibleObjectFromPoint too dirty, unreliable and often very slow, because sends WM_GETOBJECT etc.
			//IUIAutomation.FromPoint very slow. Getting window handle from it is not easy, > 0.5 ms.
		}
		
		/// <inheritdoc cref="fromXY(POINT, WXYFlags)"/>
		public static wnd fromXY(int x, int y, WXYFlags flags = 0) => fromXY(new POINT(x, y), flags);
		
		//rejected: FromXY(Coord, Coord, ...). Coord makes no sense.
		
		/// <summary>
		/// Gets visible top-level window or control from mouse cursor position.
		/// More info: <see cref="fromXY"/>.
		/// </summary>
		public static wnd fromMouse(WXYFlags flags = 0) => fromXY(mouse.xy, flags);
		
		/// <summary>
		/// Gets descendant control from point.
		/// </summary>
		/// <returns>By default returns <c>default(wnd)</c> if the point is not in a child control; it depends on <i>flags</i>.</returns>
		/// <param name="x">X coordinate in client area or screen (if flag <c>ScreenXY</c>). Examples: <c>10</c>, <c>^10</c> (reverse), <c>.5f</c> (fraction).</param>
		/// <param name="y">Y coordinate.</param>
		/// <param name="flags"></param>
		/// <exception cref="AuWndException">This variable is invalid (window not found, closed, etc).</exception>
		public wnd ChildFromXY(Coord x, Coord y, WXYCFlags flags = 0) {
			ThrowIfInvalid();
			POINT p = flags.Has(WXYCFlags.ScreenXY) ? Coord.Normalize(x, y) : Coord.NormalizeInWindow(x, y, this);
			return _ChildFromXY(p, flags);
		}
		
		/// <summary>
		/// Gets descendant control from point.
		/// </summary>
		/// <returns>By default returns <c>default(wnd)</c> if the point is not in a child control; it depends on <i>flags</i>.</returns>
		/// <param name="p">Coordinates in client area or screen (if flag <c>ScreenXY</c>).</param>
		/// <param name="flags"></param>
		/// <exception cref="AuWndException">This variable is invalid (window not found, closed, etc).</exception>
		public wnd ChildFromXY(POINT p, WXYCFlags flags = 0) {
			ThrowIfInvalid();
			return _ChildFromXY(p, flags);
		}
		
		//Gets real control or window from point in screen.
		//The input control can be eg from WindowFromPhysicalPoint, which skips disabled and transparent controls and does not get controls under transparent siblings such as groupbox button.
		//In such cases this struct replaces the input control (hwnd field) with the real control (descendant or sibling).
		//Fully DPI-aware on Win8.1+.
		struct _WindowFromPoint : IDisposable {
			POINT _p;
			IntPtr _hr;
			public wnd hwnd;
			public RECT r;
			
			public _WindowFromPoint(POINT p, wnd hwndStart) {
				r = default;
				_hr = default;
				hwnd = hwndStart;
				_p = p;
				
				//rejected. This library does not support DPI-scaled windows on Win7-8; too expensive.
				//if (!osVersion.minWin8_1 && !Api.PhysicalToLogicalPoint(hwnd, ref _p)) _p = p;
				////print.it(p, _p);
				
				//tested: on Win10 WM_NCHITTEST and GetWindowRgn use physical coords with DPI-scaled windows.
			}
			
			public void Dispose() { if (_hr != default) Api.DeleteObject(_hr); }
			
			public (bool inWindow, bool inClient) IsInWindow() {
				if (hwnd.GetWindowInfo_(out var k)) return (k.rcWindow.Contains(_p), k.rcClient.Contains(_p));
				return default;
			}
			
			bool _IsPointVisibleIn_1(wnd c) {
				return c.HasStyle(WS.VISIBLE) && Api.GetWindowRect(c, out r) && r.Contains(_p);
			}
			
			bool _IsPointVisibleIn_2(wnd c) {
				if (_hr == default) _hr = Api.CreateRectRgn(0, 0, 0, 0);
				if (Api.GetWindowRgn(c, _hr) > 1 && !Api.PtInRegion(_hr, _p.x - r.left, _p.y - r.top)) return false;
				if (c.HasExStyle(WSE.LAYERED) && c.IsCloaked) return false;
				return true;
				//if(osVersion.minWin8 && c.HasExStyle(WSE.LAYERED) && Api.GetLayeredWindowAttributes(c, ... //never mind. We can get alpha 0 (probably rare), but difficult or impossible to detect whether the point is transparent because of color key (probably not so rare).
				//tested: WindowFromPoint skips all: region, cloaked, transparent (by alpha or colorkey).
				//tested: RealChildWindowFromPoint skips region and cloaked, but not transparent.
				//tested: UI Automation skips region and cloaked, but not transparent.
				//tested: AccessibleObjectFromPoint skips only cloaked.
				//tested: Spy++ skips none.
				//tested: NtUserWindowFromPoint is the same as WindowFromPoint.
			}
			
			public bool FindSibling() {
				bool found = false;
				if (Api.GetWindowRect(hwnd, out RECT r1)) {
					for (wnd c2 = hwnd; !(c2 = Api.GetWindow(c2, Api.GW_HWNDNEXT)).Is0;) { //GetWindow often is the slowest part. EnumChildWindows slower.
						if (_IsPointVisibleIn_1(c2)) {
							if (r.left >= r1.left && r.top >= r1.top && r.right <= r1.right && r.bottom <= r1.bottom && (r.right - r.left < r1.right - r1.left || r.bottom - r.top < r1.bottom - r1.top)) {
								if (_IsPointVisibleIn_2(c2)) {
									if (hwnd.SendTimeout(1000, out var ht, Api.WM_NCHITTEST, 0, Math2.MakeLparam(_p), SMTFlags.ABORTIFHUNG | SMTFlags.BLOCK) && ht != Api.HTTRANSPARENT) break;
									hwnd = c2;
									r1 = r;
									found = true;
								}
							}
						}
					}
				}
				return found;
			}
			
			public bool FindDescendant(bool directChild = false) {
				bool found = false;
				gNextGeneration:
				for (wnd c2 = Api.GetWindow(hwnd, Api.GW_CHILD); !c2.Is0; c2 = Api.GetWindow(c2, Api.GW_HWNDNEXT)) {
					if (_IsPointVisibleIn_1(c2) && _IsPointVisibleIn_2(c2)) {
						hwnd = c2;
						found = true;
						if (directChild) break;
						goto gNextGeneration;
					}
				}
				return found;
			}
		}
		
		/// <summary>
		/// Gets window or control from point.
		/// Returns <c>default(wnd)</c> if failed (unlikely).
		/// </summary>
		/// <param name="p">Point in screen.</param>
		/// <param name="isChild">Receives <c>true</c> if control, false if top-level or failed.</param>
		static wnd _FromXY(POINT p, out bool isChild) {
			wnd w = Api.WindowFromPoint(p);
			if (w.Is0) { isChild = false; return default; }
			using var k = new _WindowFromPoint(p, w);
			bool findSibling = w.IsChild, findDescendant = true;
			for (; ; ) {
				//find a smaller sibling fully covered by c
				if (findSibling) findDescendant |= k.FindSibling();
				
				//find descendant, because: 1. WindowFromPoint does not find disabled controls. 2. The above code may change k.hwnd.
				if (!findDescendant) break;
				if (!k.FindDescendant()) break;
				findSibling = true; findDescendant = false;
			}
			isChild = findSibling;
			return k.hwnd;
			
			//note: don't use API [Real]ChildWindowFromPoint[Ex]. Bugs:
			//	1. Returns wrong control in DPI-scaled windows in non-primary screen with different DPI.
			//	2. Returns wrong control in RTL windows.
		}
		
		/// <summary>
		/// Gets descendant control from point. This can be top-level window or control.
		/// If there is no descendant, the return value depends on <i>flags</i>.
		/// </summary>
		/// <param name="p">Point in client area or screen (if flag <c>ScreenXY</c>).</param>
		/// <param name="flags"></param>
		wnd _ChildFromXY(POINT p, WXYCFlags flags = 0) {
			if (!flags.Has(WXYCFlags.ScreenXY)) Api.ClientToScreen(this, ref p);
			
			bool directChild = flags.Has(WXYCFlags.DirectChild),
				orThis = flags.Has(WXYCFlags.OrThis),
				inside = flags.Has(WXYCFlags.Inside);
			
			using var k = new _WindowFromPoint(p, this);
			if (inside) {
				var v = k.IsInWindow();
				if (!v.inWindow) return default;
				if (!v.inClient) return orThis ? this : default;
			}
			
			for (; ; ) {
				//find descendant
				if (!k.FindDescendant(directChild)) break;
				
				//find a smaller sibling fully covered by c
				if (!k.FindSibling()) break;
				if (directChild) break;
			}
			
			var R = k.hwnd;
			if (R == this) {
				if (!orThis || (!inside && !k.IsInWindow().inWindow)) R = default;
			}
			return R;
		}
		
		/// <summary>
		/// Gets sibling control in space: left, right, above or below.
		/// Returns <c>default(wnd)</c> if there is no sibling.
		/// </summary>
		/// <param name="direction"></param>
		/// <param name="distance">Distance from this control (from its edge) in the specified direction.</param>
		/// <param name="edgeOffset">
		/// Distance in perpendicular direction, along the specified edge. Default 5.
		/// If <i>direction</i> is <c>Left</c> or <c>Right</c>, 0 is the top edge, 1 is 1 pixel down, -1 is 1 pixel up, and so on.
		/// If <i>direction</i> is <c>Above</c> or <c>Below</c>, 0 is the left edge, 1 is 1 pixel to the right, -1 is 1 pixel to the left, and so on.
		/// </param>
		/// <param name="topChild">If at that point is a visible child or descendant of the sibling, get that child/descendant. Default <c>false</c>.</param>
		/// <exception cref="AuWndException">This variable is invalid (window not found, closed, etc).</exception>
		/// <remarks>
		/// This function is used mostly with controls, but supports top-level windows too.
		/// </remarks>
		wnd _SiblingXY(_SibXY direction, int distance, int edgeOffset = 5, bool topChild = false) {
			ThrowIfInvalid();
			wnd w = Get.DirectParent;
			if (!(w.Is0 ? GetRect(out RECT r) : GetRectIn(w, out r))) ThrowUseNative(); //note: most other wnd 'get' functions don't throw, but here it's better to throw.
			POINT p = default;
			switch (direction) {
			case _SibXY.Left: p = (r.left - distance, r.top + edgeOffset); break;
			case _SibXY.Right: p = (r.right + distance, r.top + edgeOffset); break;
			case _SibXY.Above: p = (r.left + edgeOffset, r.top - distance); break;
			case _SibXY.Below: p = (r.left + edgeOffset, r.bottom + distance); break;
			}
			//print.it(p); if(w.Is0) mouse.move(p); else mouse.move(w, p.x, p.y);
			wnd R = w.Is0
				? fromXY(p, topChild ? 0 : WXYFlags.NeedWindow)
				: w._ChildFromXY(p, topChild ? 0 : WXYCFlags.DirectChild);
			return R == this ? default : R; //cannot return self, but can return child if topChild, it's ok
		}
		
		enum _SibXY { Left, Right, Above, Below }
		
		wnd _SiblingXY(_SibXY direction) {
			ThrowIfInvalid();
			wnd desktop = default; if (!this.IsChild) getwnd.desktop(out desktop, out _);
			var r = Rect;
			wnd nearest = default; int nearestDist = int.MaxValue;
			for (var c = Api.GetWindow(this, Api.GW_HWNDFIRST); !c.Is0; c = Api.GetWindow(c, Api.GW_HWNDNEXT)) {
				if (c == this) continue;
				if (!c.IsVisible) continue;
				var k = c.Rect;
				int dist = 0;
				switch (direction) {
				case _SibXY.Left: if (k.left >= r.left || k.bottom < r.top || k.top >= r.bottom) continue; dist = r.left - k.right; break;
				case _SibXY.Above: if (k.top >= r.top || k.right < r.left || k.left >= r.right) continue; dist = r.top - k.bottom; break;
				case _SibXY.Right: if (k.right <= r.right || k.bottom < r.top || k.top >= r.bottom) continue; dist = k.left - r.right; break;
				case _SibXY.Below: if (k.bottom <= r.bottom || k.right < r.left || k.left >= r.right) continue; dist = k.top - r.bottom; break;
				}
				dist = Math.Max(dist, 0);
				if (dist < nearestDist) {
					if (c.IsCloaked || c.IsMinimized || c.IsMaximized) continue;
					if (!desktop.Is0) if (c == desktop || c.ThreadId == desktop.ThreadId) continue;
					nearestDist = dist;
					nearest = c;
				}
			}
			return nearest;
		}
	}
}

namespace Au.Types {
	/// <summary>
	/// Flags for <see cref="wnd.fromXY"/> and <see cref="wnd.fromMouse"/>.
	/// </summary>
	[Flags]
	public enum WXYFlags {
		/// <summary>
		/// Need top-level window. If at that point is a control, gets its top-level parent.
		/// Don't use together with <c>NeedControl</c>.
		/// </summary>
		NeedWindow = 1,
		
		/// <summary>
		/// Need a control (child window). Returns <c>default(wnd)</c> if there is no control at that point.
		/// Don't use together with <c>NeedWindow</c>.
		/// Without flags <c>NeedWindow</c> and <c>NeedControl</c> the function gets control or top-level window.
		/// </summary>
		NeedControl = 2,
		
		/// <summary>
		/// Just call API <ms>WindowFromPhysicalPoint</ms>.
		/// Faster, but skips disabled controls and in some cases gets transparent control like group box although a smaller visible sibling is there.
		/// Not used with flag <c>NeedWindow</c>.
		/// </summary>
		Raw = 4,
	}
	
	/// <summary>
	/// Flags for <see cref="wnd.ChildFromXY"/>.
	/// </summary>
	[Flags]
	public enum WXYCFlags {
		/// <summary>
		/// If the point is in this window but not in a descendant control, return this. Default - return <c>default(wnd)</c>.
		/// </summary>
		OrThis = 1,
		
		/// <summary>
		/// The point is in screen coordinates. Default - client area.
		/// </summary>
		ScreenXY = 2,
		
		/// <summary>
		/// Must be direct child of this. Default - any descendant.
		/// </summary>
		DirectChild = 4,
		
		/// <summary>
		/// If the point is not in client area, don't look for descendants; if with flag <c>OrThis</c> and the point is in this (non-client area), return this, else return <c>default(wnd)</c>.
		/// </summary>
		Inside = 8,
	}
}


================================================
FILE: Au/wnd/wnd_get.cs
================================================
namespace Au;

public partial struct wnd {
	/// <summary>
	/// Gets related windows and controls.
	/// Use like <c>wnd w2 = w1.Get.Owner;</c> (here <i>w1</i> is a <see cref="wnd"/> variable).
	/// </summary>
	public getwnd Get => new(this);

	/// <summary>
	/// Static functions of this class are used to get special windows (used like <c>wnd w = wnd.getwnd.top;</c>) and all windows.
	/// Instances of this class are used to get related windows and controls, like <c>wnd w2 = w1.Get.FirstChild;</c> (here <i>w1</i> is a <see cref="wnd"/> variable).
	/// </summary>
	public partial struct getwnd {
		wnd _w;
		///
		public getwnd(wnd wThis) => _w = wThis;

		#region instance

		/// <summary>
		/// Gets nearest visible sibling control to the left from this.
		/// </summary>
		/// <returns><c>default(wnd)</c> if not found.</returns>
		/// <exception cref="AuWndException">This variable is invalid (window not found, closed, etc).</exception>
		/// <remarks>
		/// This function is used mostly with controls, but supports top-level windows too. Skips maximized/minimized windows and desktop.
		/// </remarks>
		public wnd SiblingLeft() => _w._SiblingXY(_SibXY.Left);
		//FUTURE: add these to the window tool, like navig in Delm. Also add previous/next/parent/child in Z order.

		/// <summary>
		/// Gets nearest visible sibling control to the right from this.
		/// </summary>
		/// <returns><c>default(wnd)</c> if not found.</returns>
		/// <exception cref="AuWndException">This variable is invalid (window not found, closed, etc).</exception>
		/// <remarks>
		/// This function is used mostly with controls, but supports top-level windows too. Skips maximized/minimized windows and desktop.
		/// </remarks>
		public wnd SiblingRight() => _w._SiblingXY(_SibXY.Right);

		/// <summary>
		/// Gets nearest visible sibling control above this.
		/// </summary>
		/// <returns><c>default(wnd)</c> if not found.</returns>
		/// <exception cref="AuWndException">This variable is invalid (window not found, closed, etc).</exception>
		/// <remarks>
		/// This function is used mostly with controls, but supports top-level windows too. Skips maximized/minimized windows and desktop.
		/// </remarks>
		public wnd SiblingAbove() => _w._SiblingXY(_SibXY.Above);

		/// <summary>
		/// Gets nearest visible sibling control to below this.
		/// </summary>
		/// <returns><c>default(wnd)</c> if not found.</returns>
		/// <exception cref="AuWndException">This variable is invalid (window not found, closed, etc).</exception>
		/// <remarks>
		/// This function is used mostly with controls, but supports top-level windows too. Skips maximized/minimized windows and desktop.
		/// </remarks>
		public wnd SiblingBelow() => _w._SiblingXY(_SibXY.Below);

		/// <summary>
		/// Gets a visible sibling control to the left from this.
		/// </summary>
		/// <returns><c>default(wnd)</c> if there is no sibling.</returns>
		/// <param name="distance">Horizontal distance from the left of this control.</param>
		/// <param name="yOffset">Vertical offset from the top of this control. If negative - up. Default 5.</param>
		/// <param name="topChild">If at that point is a visible child of the sibling, get that child. Default <c>false</c>.</param>
		/// <exception cref="AuWndException">This variable is invalid (window not found, closed, etc).</exception>
		/// <remarks>
		/// This function is used mostly with controls, but supports top-level windows too.
		/// </remarks>
		public wnd SiblingLeft(int distance, int yOffset = 5, bool topChild = false) => _w._SiblingXY(_SibXY.Left, distance, yOffset, topChild);

		/// <summary>
		/// Gets a visible sibling control to the right from this.
		/// </summary>
		/// <returns><c>default(wnd)</c> if there is no sibling.</returns>
		/// <param name="distance">Horizontal distance from the right of this control.</param>
		/// <param name="yOffset">Vertical offset from the top of this control. If negative - up. Default 5.</param>
		/// <param name="topChild">If at that point is a visible child of the sibling, get that child. Default <c>false</c>.</param>
		/// <exception cref="AuWndException">This variable is invalid (window not found, closed, etc).</exception>
		/// <remarks>
		/// This function is used mostly with controls, but supports top-level windows too.
		/// </remarks>
		public wnd SiblingRight(int distance, int yOffset = 5, bool topChild = false) => _w._SiblingXY(_SibXY.Right, distance, yOffset, topChild);

		/// <summary>
		/// Gets a visible sibling control above this.
		/// </summary>
		/// <returns><c>default(wnd)</c> if there is no sibling.</returns>
		/// <param name="distance">Vertical distance from the top of this control.</param>
		/// <param name="xOffset">Horizontal offset from the left of this control. If negative - to the left. Default 5.</param>
		/// <param name="topChild">If at that point is a visible child of the sibling, get that child. Default <c>false</c>.</param>
		/// <exception cref="AuWndException">This variable is invalid (window not found, closed, etc).</exception>
		/// <remarks>
		/// This function is used mostly with controls, but supports top-level windows too.
		/// </remarks>
		public wnd SiblingAbove(int distance, int xOffset = 5, bool topChild = false) => _w._SiblingXY(_SibXY.Above, distance, xOffset, topChild);

		/// <summary>
		/// Gets a visible sibling control below this.
		/// </summary>
		/// <returns><c>default(wnd)</c> if there is no sibling.</returns>
		/// <param name="distance">Vertical distance from the bottom of this control.</param>
		/// <param name="xOffset">Horizontal offset from the left of this control. If negative - to the left. Default 5.</param>
		/// <param name="topChild">If at that point is a visible child of the sibling, get that child. Default <c>false</c>.</param>
		/// <exception cref="AuWndException">This variable is invalid (window not found, closed, etc).</exception>
		/// <remarks>
		/// This function is used mostly with controls, but supports top-level windows too.
		/// </remarks>
		public wnd SiblingBelow(int distance, int xOffset = 5, bool topChild = false) => _w._SiblingXY(_SibXY.Below, distance, xOffset, topChild);

		wnd _GetWindow(int dir, int skip) {
			if (skip < 0) return default;
			wnd w;
			for (w = _w; skip >= 0 && !w.Is0; skip--) {
				w = Api.GetWindow(w, dir);
			}
			return w;
		}

		/// <summary>
		/// Gets next sibling window or control in the Z order.
		/// </summary>
		/// <returns><c>default(wnd)</c> if this is the last or if failed.</returns>
		/// <param name="skip">How many next windows to skip.</param>
		/// <remarks>
		/// If this is a top-level window, gets next top-level window, else gets next control of the same direct parent.
		/// Calls API <ms>GetWindow</ms>(<c>GW_HWNDNEXT</c>).
		/// Supports <see cref="lastError"/>.
		/// </remarks>
		public wnd Next(int skip = 0) => _GetWindow(Api.GW_HWNDNEXT, skip);

		/// <summary>
		/// Gets previous sibling window or control in the Z order.
		/// </summary>
		/// <returns><c>default(wnd)</c> if this is the first or if failed.</returns>
		/// <param name="skip">How many previous windows to skip.</param>
		/// <remarks>
		/// If this is a top-level window, gets previous top-level window, else gets previous control of the same direct parent.
		/// Calls API <ms>GetWindow</ms>(<c>GW_HWNDPREV</c>).
		/// Supports <see cref="lastError"/>.
		/// </remarks>
		public wnd Previous(int skip = 0) => _GetWindow(Api.GW_HWNDPREV, skip);

		/// <summary>
		/// Gets the first sibling window or control in the Z order.
		/// If this is the first, returns this.
		/// </summary>
		/// <remarks>
		/// If this is a top-level window, gets the first top-level window, else gets the first control of the same direct parent.
		/// Calls API <ms>GetWindow</ms>(this, <c>GW_HWNDFIRST</c>).
		/// Supports <see cref="lastError"/>.
		/// </remarks>
		public wnd FirstSibling => Api.GetWindow(_w, Api.GW_HWNDFIRST);

		/// <summary>
		/// Gets the last sibling window or control in the Z order.
		/// If this is the last, returns this, not <c>default(wnd)</c>.
		/// </summary>
		/// <remarks>
		/// If this is a top-level window, gets the last top-level window, else gets the last control of the same direct parent.
		/// Calls API <ms>GetWindow</ms>(this, <c>GW_HWNDLAST</c>).
		/// Supports <see cref="lastError"/>.
		/// </remarks>
		public wnd LastSibling => Api.GetWindow(_w, Api.GW_HWNDLAST);

		/// <summary>
		/// Gets the first direct child control in the Z order.
		/// </summary>
		/// <returns><c>default(wnd)</c> if no children or if failed.</returns>
		/// <remarks>
		/// Calls API <ms>GetWindow</ms>(<c>GW_CHILD</c>).
		/// Supports <see cref="lastError"/>.
		/// </remarks>
		public wnd FirstChild => Api.GetWindow(_w, Api.GW_CHILD);

		/// <summary>
		/// Gets the last direct child control in the Z order.
		/// </summary>
		/// <returns><c>default(wnd)</c> if no children or if failed.</returns>
		/// <remarks>
		/// Calls API <ms>GetWindow</ms>.
		/// Supports <see cref="lastError"/>.
		/// </remarks>
		public wnd LastChild { get { var t = Api.GetWindow(_w, Api.GW_CHILD); return t.Is0 ? t : Api.GetWindow(t, Api.GW_HWNDLAST); } }

		/// <summary>
		/// Gets a direct child control by index.
		/// </summary>
		/// <returns><c>default(wnd)</c> if no children or if index is invalid or if failed.</returns>
		/// <param name="index">0-based index of the child control in the Z order.</param>
		/// <remarks>
		/// Calls API <ms>GetWindow</ms>.
		/// Supports <see cref="lastError"/>.
		/// </remarks>
		public wnd Child(int index) {
			if (index < 0) return default;
			wnd c = Api.GetWindow(_w, Api.GW_CHILD);
			for (; index > 0 && !c.Is0; index--) c = Api.GetWindow(c, Api.GW_HWNDNEXT);
			return c;
		}

		/// <summary>
		/// Gets the owner window of this top-level window.
		/// </summary>
		/// <returns><c>default(wnd)</c> if this window isn't owned or if failed.</returns>
		/// <remarks>
		/// A window that has an owner window is always on top of it.
		/// Controls don't have an owner window.
		/// Supports <see cref="lastError"/>.
		/// </remarks>
		/// <seealso cref="WndUtil.SetOwnerWindow"/>
		public wnd Owner => Api.GetWindow(_w, Api.GW_OWNER);

		/// <summary>
		/// Gets the top-level parent window of this control.
		/// If this is a top-level window, returns this.
		/// </summary>
		/// <returns><c>default(wnd)</c> if failed.</returns>
		/// <remarks>
		/// Supports <see cref="lastError"/>.
		/// This function is the same as <see cref="wnd.Window"/>.
		/// </remarks>
		public wnd Window => _w.Window;

		/// <summary>
		/// Gets the direct parent window of this control. It can be the top-level window or another control.
		/// </summary>
		/// <returns><c>default(wnd)</c> if this is a top-level window or if failed.</returns>
		/// <remarks>
		/// Supports <see cref="lastError"/>.
		/// Unlike API <ms>GetParent</ms>, this function never returns the owner window.
		/// </remarks>
		public wnd DirectParent {
			get {
#if true
				var p = _w.GetWindowLong(GWL.HWNDPARENT);
				if (p == default) {
					//#if DEBUG
					//var p2 = Api.GetAncestor(_w, Api.GA_PARENT);
					//Debug.Assert(p2.Is0 || p2 == Root);
					//#endif
					return default;
				}
				lastError.clear();
				var o = Api.GetWindow(_w, Api.GW_OWNER);
				if (o.Is0) {
					var ec = lastError.code;
					if (ec == 0) return (wnd)p;
					Debug.Assert(ec == Api.ERROR_INVALID_WINDOW_HANDLE);
				}
				return default;
#else //the ms-recommended version, but >=6 times slower. The same IsTopLevelWindow (undocumented API).
					var p = Api.GetAncestor(_w, Api.GA_PARENT);
					if(p.Is0 || p == Root) return default;
					return p;
#endif
			}
		}

		//rejected. Not much faster than our DirectParent.
		///// <summary>
		///// Calls API <ms>GetParent</ms>.
		///// </summary>
		///// <remarks>
		///// The API function is fast but unreliable. It can get parent or owner window, and fails in some cases. Read more in the API documentation. It is reliable only if you know that this window is a child window and has <c>WS_CHILD</c> style.
		///// Supports <see cref="lastError"/>.
		///// </remarks>
		//[Obsolete("Unreliable")]
		//public wnd GetParentApi => Api.GetParent(_w);

		/// <summary>
		/// Gets the first (in Z order) enabled window owned by this window.
		/// </summary>
		/// <param name="orThis">Return this window if there are no enabled owned windows. If <c>false</c>, then returns <c>default(wnd)</c>.</param>
		/// <remarks>
		/// This window should be top-level, not child; see <see cref="wnd.Window"/>.
		/// 
		/// Calls API <ms>GetWindow</ms>(<c>GW_ENABLEDPOPUP</c>). Supports <see cref="lastError"/>.
		/// </remarks>
		public wnd EnabledOwned(bool orThis = false) {
			var r = Api.GetWindow(_w, Api.GW_ENABLEDPOPUP);
			if (orThis) {
				if (r.Is0) r = _w;
			} else {
				if (r == _w) r = default;
			}
			return r;
			//MSDN doc says it returns this window if there are no owned, but actually returns 0.
		}

		/// <summary>
		/// Gets the most recently active window in the chain of windows owned by this window, or this window itself if there are no such windows.
		/// </summary>
		/// <returns><c>default(wnd)</c> if failed.</returns>
		/// <param name="includeOwners">Can return an owner (or owner's owner and so on) of this window too.</param>
		/// <remarks>
		/// Supports <see cref="lastError"/>.
		/// </remarks>
		public wnd LastActiveOwnedOrThis(bool includeOwners = false) {
			var wRoot = RootOwnerOrThis(); //always use the root owner because GetLastActivePopup always returns _w if _w is owned
			var R = Api.GetLastActivePopup(wRoot);
			if (!includeOwners) {
				if (R != _w && wRoot != _w && !R.Is0) {
					for (var t = _w; !t.Is0; t = t.Get.Owner) if (t == R) return _w;
				}
			}
			return R;
		}

		/// <summary>
		/// Gets the bottom-most owner window in the chain of owner windows of this window.
		/// If this window is not owned, returns this window.
		/// </summary>
		/// <returns><c>default(wnd)</c> if failed.</returns>
		/// <param name="supportControls">If this is a child window, use its top-level parent window instead.</param>
		/// <remarks>Supports <see cref="lastError"/>.</remarks>
		public wnd RootOwnerOrThis(bool supportControls = false) {
			//return Api.GetAncestor(_w, Api.GA_ROOTOWNER); //slow, and can return Get.Root, eg for combolbox

			if (supportControls) {
				var r = Api.GetAncestor(_w, Api.GA_ROOTOWNER);
				return r == root ? _w : r;
				//never mind speed, better make it simple
			} else { //fast
				for (wnd r = _w, t; ; r = t) {
					t = r.Get.Owner;
					if (t.Is0) return r.IsAlive ? r : default;
				}
			}
		}

		/// <summary>
		/// Gets all owner windows (owner, its owner and so on) of this window.
		/// </summary>
		/// <param name="andThisWindow">Add this window (or its top-level parent if control) as the first list element.</param>
		/// <param name="onlyVisible">Skip invisible windows.</param>
		/// <remarks>
		/// This window can be top-level window or control.
		/// </remarks>
		public wnd[] AllOwners(bool andThisWindow = false, bool onlyVisible = false)
			=> Owners(andThisWindow, onlyVisible).ToArray();

		///
		[EditorBrowsable(EditorBrowsableState.Never)] //returns List, whereas all other public functions return array
		public List<wnd> Owners(bool andThisWindow = false, bool onlyVisible = false) {
			var a = new List<wnd>();
			for (var w = Window; !w.Is0 && w != root; w = w.Get.Owner) {
				if (!andThisWindow) { andThisWindow = true; continue; }
				if (!onlyVisible || w.IsVisible) a.Add(w);
			}
			return a;
		}

		/// <summary>
		/// Gets windows owned by this window.
		/// </summary>
		/// <param name="allDescendants">Also get indirectly owned windows (owned by owned windows).</param>
		/// <param name="andThisWindow">Add this window to the array. Since the array is sorted like in the Z order, usually it is the last element, but not always.</param>
		/// <returns>Array containing zero or more elements. Sorted like in the Z order.</returns>
		public wnd[] AllOwned(bool allDescendants, bool andThisWindow = false) {
			if (allDescendants) {
				var od = new OwnedDescendants_();
				var ai = od.GetIndices(_w, andOwner: andThisWindow);
				if (ai.Count == 0) return [];
				var ar = new wnd[ai.Count];
				for (int i = 0; i < ai.Count; i++) ar[i] = od.all[ai[i]];
				return ar;
			} else {
				var ar = new List<wnd>();
				var all = allWindowsZorder(); //the slowest part
				foreach (var k in all) {
					if (k == _w) { if (andThisWindow) ar.Add(k); continue; }
					if (k.Get.Owner == _w) ar.Add(k);
				}
				return ar.ToArray();
			}
		}

		/// <summary>
		/// Gets indices of owned windows of the specified window, including all descendants.
		/// </summary>
		internal class OwnedDescendants_ {
			/// <summary>
			/// All top-level windows in Z order.
			/// The array is created once in ctor.
			/// </summary>
			public readonly wnd[] all;

			/// <summary>
			/// Owners of all windows that are in the <i>all</i> array.
			/// The array is created once in ctor.
			/// </summary>
			public readonly int[] owners;

			public OwnedDescendants_() {
				all = getwnd.allWindowsZorder();
				owners = new int[all.Length];
				for (int i = 0; i < all.Length; i++) owners[i] = (int)all[i].Get.Owner;
			}

			/// <summary>
			/// Gets indices of owned windows of the specified window, including all descendants.
			/// Can be called multiple times for different owner windows; uses arrays created in ctor (the slowest part).
			/// </summary>
			/// <param name="owner">Owner window.</param>
			/// <param name="skip">A callback function that receives descendant index and can return <c>true</c> to skip that window and its descendants.</param>
			/// <param name="andOwner">Add <i>owner</i> to the list too, at the position matching the Z order.</param>
			/// <returns>List of <see cref="all"/> indices of owned windows. Sorted like in the Z order. Not <c>null</c>.</returns>
			public List<int> GetIndices(wnd owner, Func<int, bool> skip = null, bool andOwner = false) {
				var ai = new List<int>();
				_Owned(owner);

				void _Owned(wnd owner) {
					int oint = (int)owner;
					for (int i = 0; i < owners.Length; i++) {
						if (owners[i] == oint) {
							if (skip != null && skip(i)) continue;
							ai.Add(i);
							_Owned(all[i]);
						}
					}
				}

				if (andOwner) {
					int j = Array.IndexOf(all, owner);
					if (j >= 0) ai.Add(j); else Debug_.Print("owner not in all");
				}
				ai.Sort();
				return ai;
			}
		}

		#endregion

		#region static

		/// <summary>
		/// Gets the first top-level window in the Z order.
		/// </summary>
		/// <remarks>
		/// Probably it is a topmost window. To get the first non-topmost window, use <see cref="top2"/>.
		/// Calls API <ms>GetTopWindow</ms>.
		/// </remarks>
		public static wnd top => Api.GetTopWindow(default);

		/// <summary>
		/// Finds and returns the first non-topmost window in the Z order.
		/// </summary>
		/// <param name="lastTopmost">Receives the last topmost window.</param>
		/// <remarks>
		/// This function is slower than <see cref="top"/> etc. Enumerates windows, because there is no API to get directly.
		/// </remarks>
		public static wnd top2(out wnd lastTopmost) {
			wnd w, lastTM, w2 = default, lastTM2 = default;
			for (; ; ) { //repeat until gets same results 2 times. At any time windows can be destroyed, reordered, reparented. The second time 2-3 times faster.
				lastTM = default; w = top; if (w.Is0) break; //no windows in this session
				for (; w.IsTopmost; w = w.Get.Next()) lastTM = w;
				if (w == w2 && lastTM == lastTM2 && !w.Is0) break;
				w2 = w; lastTM2 = lastTM;
			}
			lastTopmost = lastTM;
			return w;
		}

		/// <summary>
		/// Calls API <ms>GetDesktopWindow</ms>. It gets the virtual parent window of all top-level windows.
		/// </summary>
		/// <remarks>
		/// <note>It is not the desktop window (see <see cref="desktop"/>) that displays icons and wallpaper.</note>
		/// </remarks>
		public static wnd root { get; } = Api.GetDesktopWindow();

		/// <summary>
		/// Calls API <ms>GetShellWindow</ms>. It gets a window of the shell process (usually process <c>"explorer"</c>, class name <c>"Progman"</c>).
		/// </summary>
		/// <returns><c>default(wnd)</c> if there is no shell process, for example Explorer process killed/crashed and still not restarted, or if using a custom shell that does not register a shell window.</returns>
		/// <remarks>
		/// It can be the window that contains desktop icons (see <see cref="desktop"/>) or other window of the same thread.
		/// </remarks>
		public static wnd shellWindow => Api.GetShellWindow();

		/// <summary>
		/// Gets the desktop window and its child control that displays desktop icons and wallpaper.
		/// </summary>
		/// <returns><c>false</c> if failed.</returns>
		/// <param name="desktopWindow">Receives the top-level desktop window. Class name <c>"Progman"</c> or <c>"WorkerW"</c>.</param>
		/// <param name="control">Receives the control of <c>"SysListView32"</c> class that contains icons and wallpaper.</param>
		/// <remarks>
		/// This function is not very reliable. May stop working on a new Windows version or don't work with a custom shell.
		/// Fails if there is no shell process, for example Explorer process killed/crashed and still not restarted, or if using a custom shell that does not register a shell window.
		/// </remarks>
		public static bool desktop(out wnd desktopWindow, out wnd control) {
			wnd w = shellWindow;
			var f = new wndChildFinder(cn: "SysListView32");
			if (!f.Exists(w)) w = wnd.find(null, "WorkerW", WOwner.Thread(w.ThreadId), also: t => f.Exists(t));
			desktopWindow = w;
			control = f.Result;
			return !w.Is0;

			//info:
			//If no wallpaper, desktop is GetShellWindow, else a visible WorkerW window.
			//When was no wallpaper and user selects a wallpaper, explorer creates WorkerW and moves the same SysListView32 control to it.

			//tested: with COM (IShellWindows -> IShellBrowser -> IShellView.GetWindow) slower 17 times.
		}

		//FUTURE:
		//public static wnd editorWindow =>
		//public static wnd editorCodeControl =>

		#endregion
	}

	#region main windows

	public partial struct getwnd {
		/// <summary>
		/// Returns <c>true</c> if window <i>w</i> is considered a main window, ie probably is in the Windows taskbar.
		/// Returns <c>false</c> if it is invisible, cloaked, owned, toolwindow, menu, etc.
		/// </summary>
		/// <param name="w">A top-level window.</param>
		/// <param name="allDesktops">On Windows 10 include (return <c>true</c> for) windows on all virtual desktops. On Windows 8 include Windows Store apps if possible; read more: <see cref="allWindows(bool, bool)"/>.</param>
		/// <param name="skipMinimized">Return <c>false</c> if <i>w</i> is minimized.</param>
		public static bool isMainWindow(wnd w, bool allDesktops = false, bool skipMinimized = false) {
			if (!w.IsVisible) return false;

			var exStyle = w.ExStyle;
			if ((exStyle & WSE.APPWINDOW) == 0) {
				if ((exStyle & (WSE.TOOLWINDOW | WSE.NOACTIVATE)) != 0) return false;
				if (!w.Get.Owner.Is0) return false;
			}

			if (skipMinimized && w.IsMinimized) return false;

			if (osVersion.minWin10) {
				if (w.IsCloaked) {
					if (!allDesktops) return false;
					if ((exStyle & WSE.NOREDIRECTIONBITMAP) != 0) { //probably a store app
						switch (w.ClassNameIs("Windows.UI.Core.CoreWindow", "ApplicationFrameWindow")) {
						case 1: return false; //Windows search, experience host, etc. Also app windows that normally would sit on ApplicationFrameWindow windows.
						case 2: if (_WindowsStoreAppFrameChild(w).Is0) return false; break; //skip hosts
						}
					}
				}
			} else if (osVersion.minWin8) {
				if ((exStyle & WSE.NOREDIRECTIONBITMAP) != 0 && !w.HasStyle(WS.CAPTION)) {
					if (!allDesktops && (exStyle & WSE.TOPMOST) != 0) return false; //skip store apps
					if (shellWindow.GetThreadProcessId(out var pidShell) != 0 && w.GetThreadProcessId(out var pid) != 0 && pid == pidShell) return false; //skip shell windows with no title bar
				}
				//On Win8 impossible to get next window like Alt+Tab.
				//	All store apps are topmost, covering non-topmost desktop windows.
				//	DwmGetWindowAttribute makes no sense here.
				//	Desktop windows are never cloaked, inactive store windows are cloaked, etc.
			}

			return true;
		}

		/// <summary>
		/// Gets main windows, ie those that probably are in the Windows taskbar.
		/// </summary>
		/// <returns>Array containing zero or more <see cref="wnd"/>.</returns>
		/// <param name="allDesktops">On Windows 10 include windows on all virtual desktops. On Windows 8 include Windows Store apps if possible; read more: <see cref="allWindows(bool, bool)"/>.</param>
		/// <remarks>
		/// Uses <see cref="isMainWindow"/>.
		/// Does not match the order of buttons in the Windows taskbar.
		/// </remarks>
		public static wnd[] mainWindows(bool allDesktops = false) {
			var a = new List<wnd>();
			foreach (var w in allWindows(onlyVisible: true)) {
				if (isMainWindow(w, allDesktops: allDesktops)) a.Add(w);
			}
			return a.ToArray();

			//Another way - UI Automation:
			//	var x = new CUIAutomation8();
			//	var cond = x.CreatePropertyCondition(30003, 0xC370); //UIA_ControlTypePropertyId, UIA_WindowControlTypeId
			//	var a = x.GetRootElement().FindAll(TreeScope.TreeScope_Children, cond);
			//	for(int i = 0; i < a.Length; i++) print.it((wnd)a.GetElement(i).CurrentNativeWindowHandle);
			//Advantages: 1. Maybe can filter unwanted windows more reliably, although I did't notice a difference.
			//Disadvantages: 1. Skips windows of higher integrity level (UAC). 2. Cannot include cloaked windows, eg those in inactive Win10 virtual desktops. 3. About 1000 times slower, eg 70 ms vs 70 mcs; cold 140 ms.
		}

		/// <summary>
		/// Gets next window in the Z order, skipping invisible and other windows that probably are not in the Windows taskbar.
		/// </summary>
		/// <returns><c>default(wnd)</c> if there are no such windows.</returns>
		/// <param name="w">Start from this window. If <c>default(wnd)</c>, starts from the top of the Z order.</param>
		/// <param name="allDesktops">On Windows 10 include windows on all virtual desktops. On Windows 8 include Windows Store apps if possible; read more: <see cref="allWindows(bool, bool)"/>.</param>
		/// <param name="skipMinimized">Skip minimized windows.</param>
		/// <param name="retryFromTop">If <i>w</i> is not <c>default(wnd)</c> and there are no matching windows after it, retry from the top of the Z order. Then can return <i>w</i>.</param>
		/// <remarks>
		/// Uses <see cref="isMainWindow"/>.
		/// This function is quite slow. Does not match the order of buttons in the Windows taskbar.
		/// </remarks>
		public static wnd nextMain(wnd w = default, bool allDesktops = false, bool skipMinimized = false, bool retryFromTop = false) {
			if (w.Is0) retryFromTop = false;

			for (; ; ) {
				w = w.Is0 ? getwnd.top : w.Get.Next();
				if (w.Is0) {
					if (retryFromTop) { retryFromTop = false; continue; }
					return default;
				}
				if (isMainWindow(w, allDesktops: allDesktops, skipMinimized: skipMinimized)) return w;
			}
		}
	}

	/// <summary>
	/// Activates next non-minimized main window, like with <c>Alt+Tab</c>.
	/// </summary>
	/// <returns><c>true</c> if activated; <c>false</c> if there is no such window or if failed to activate.</returns>
	/// <remarks>
	/// Uses <see cref="getwnd.nextMain"/>, <see cref="getwnd.LastActiveOwnedOrThis"/>, <see cref="Activate"/>.
	/// An alternative way - send <c>Alt+Tab</c> keys, but it works not everywhere.
	/// </remarks>
	public static bool switchActiveWindow() {
		try {
			wnd wActive = active, wRO = wActive.Get.RootOwnerOrThis();
			wnd wMain = getwnd.nextMain(wRO, skipMinimized: true, retryFromTop: true);
			if (!wMain.Is0 && wMain != wActive && wMain != wRO) {
				var wMainOrOwned = wMain.Get.LastActiveOwnedOrThis();
				if (!wMainOrOwned.Is0) {
					//print.it(wMainOrOwned);
					wMainOrOwned.Activate();
					return true;
				}
			}
		}
		catch (AuWndException) { }
		return false;

		//notes:
		//This function ignores minimized windows, because:
		//	Impossible to get exactly the same window as Alt+Tab, which on Win10 is the most recently minimized.
		//	Activating a random minimized window is not very useful. Maybe in the future.
		//The order of windows used by Alt+Tab is not the same as the Z order, especially when there are minimized windows.
		//	We cannot get that order and have to use the Z order. It seems that the order is different on Win10 but not on Win7.
		//After minimizing a window its position in the Z order is undefined.
		//	Most windows then are at the bottom when used the Minimize button or ShowWindow etc.
		//	But some are at the top, just after the active window, for example MS Document Explorer (Win7 SDK).
		//	Also at the top when minimized with the taskbar button.
	}

	#endregion

	/// <summary>
	/// Gets the top-level parent window of this control.
	/// If this is a top-level window, returns this.
	/// </summary>
	/// <returns><c>default(wnd)</c> if this window is invalid.</returns>
	/// <remarks>Supports <see cref="lastError"/>.</remarks>
	/// <seealso cref="Get"/>
	public wnd Window {
		get {
			var w = Api.GetAncestor(this, Api.GA_ROOT);
			if (w.Is0 && this == getwnd.root) w = this;
			return w;
		}
	}
	//This is in getwnd and here, because frequently used.

	/// <summary>
	/// Returns <c>true</c> if this is a child window (control), <c>false</c> if top-level window.
	/// </summary>
	/// <remarks>
	/// Supports <see cref="lastError"/>.
	/// Another way is <c>w.HasStyle(WS.CHILD)</c>. It is faster but less reliable, because some top-level windows have <c>WS_CHILD</c> style and some child windows don't.
	/// </remarks>
	/// <seealso cref="getwnd.DirectParent"/>
	public bool IsChild => !Get.DirectParent.Is0;

	/// <summary>
	/// Returns <c>true</c> if this is a child or descendant of window <i>w</i>.
	/// </summary>
	/// <remarks>
	/// Calls API <ms>IsChild</ms>.
	/// Supports <see cref="lastError"/>.
	/// </remarks>
	public bool IsChildOf(wnd w) { return Api.IsChild(w, this); }

	/// <summary>
	/// Returns <c>(wnd)GetWindowLong(GWL.HWNDPARENT)</c>.
	/// </summary>
	internal wnd ParentGWL_ => (wnd)GetWindowLong(GWL.HWNDPARENT);

	/// <summary>
	/// Gets the active (foreground) window.
	/// Calls API <ms>GetForegroundWindow</ms>.
	/// </summary>
	/// <value>Returns <c>default(wnd)</c> if there is no active window; more info: <see cref="WndUtil.WaitForAnActiveWindow"/>.</value>
	public static wnd active => Api.GetForegroundWindow();

	/// <summary>
	/// Returns <c>true</c> if this window is the active (foreground) window.
	/// </summary>
	public bool IsActive => !Is0 && this == Api.GetForegroundWindow();

	//FUTURE: static bool IsActiveAny(list of wnd or wndFinder).

	/// <summary>
	/// Returns <c>true</c> if this window is the active (foreground) window.
	/// If this is <see cref="getwnd.root"/>, returns <c>true</c> if there is no active window.
	/// </summary>
	internal bool IsActiveOrNoActiveAndThisIsWndRoot_ {
		get {
			if (Is0) return false;
			var f = Api.GetForegroundWindow();
			return this == (f.Is0 ? getwnd.root : f);
		}
	}

	/// <summary>
	/// Returns <c>true</c> if this window is directly or indirectly owned by window <i>w</i>.
	/// </summary>
	/// <param name="w"></param>
	/// <param name="level">
	/// Return <c>true</c> if:
	/// <br/>• 0 - <i>w</i> is direct owner. See <see cref="getwnd.Owner"/>.
	/// <br/>• 1 - <i>w</i> is direct or indirect owner (eg owner's owner).
	/// <br/>• 2 - <i>w</i> is direct or indirect owner, or this is a menu-like window that looks like owned by <i>w</i> (same thread, topmost, etc).
	/// </param>
	/// <remarks>
	/// Many popup menus and similar temporary windows don't have an owner window. Instead they have topmost style. If <i>level</i> is 2, this function tries to detect this case. In most cases it works, but not always (depends on styles).
	/// </remarks>
	public bool IsOwnedBy(wnd w, int level) {
		if ((uint)level > 2) throw new ArgumentOutOfRangeException(nameof(level));
		int tid = 0;
		return IsOwnedBy2_(w, level, ref tid);
	}

	/// <summary>
	/// This version is used by "find window" functions.
	/// Uses <i>tid</i> to avoid getting <i>w</i> thread id (slow) for each window; let it be 0 initially.
	/// </summary>
	internal bool IsOwnedBy2_(wnd w, int level, ref int tid) {
		for (var o = Get.Owner; !o.Is0; o = o.Get.Owner) {
			if (o == w) return true;
			if (level == 0) break;
		}

		if (level > 1) {
			//print.it("level>1");
			var es = ExStyle;
			if (es.Has(WSE.TOPMOST) && es.HasAny(WSE.TOOLWINDOW | WSE.NOACTIVATE) && !es.Has(WSE.APPWINDOW)) {
				var s = Style;
				if (!s.Has(WS.CAPTION) && !s.Has(WS.THICKFRAME))
					switch (s & (WS.CHILD | WS.POPUP)) {
					case WS.POPUP:
					case WS.CHILD when !w.IsChild: //ComboLBox
						if (tid == 0) tid = w.ThreadId; //much slower than style/exstyle
						if (ThreadId == tid)
							return !w.IsTopmost || ZorderIsAbove(w);
						break;
					}
			}
		}

		return false;
	}
}


================================================
FILE: Au/wnd/wnd_other.cs
================================================
namespace Au {
	public partial struct wnd {
		/// <summary>
		/// Sets window transparency attributes (opacity and/or transparent color).
		/// </summary>
		/// <param name="allowTransparency">Set or remove <ms>WS_EX_LAYERED</ms> style that is required for transparency. If <c>false</c>, other parameters are not used.</param>
		/// <param name="opacity">Opacity from 0 (completely transparent) to 255 (opaque). Does not change if <c>null</c>. If less than 0 or greater than 255, makes 0 or 255.</param>
		/// <param name="colorKey">Make pixels of this color completely transparent. Does not change if <c>null</c>. The alpha byte is not used.</param>
		/// <param name="noException">Don't throw exception when fails.</param>
		/// <exception cref="AuWndException"/>
		/// <remarks>
		/// Uses API <ms>SetLayeredWindowAttributes</ms>.
		/// On Windows 7 works only with top-level windows, not with controls.
		/// Fails with WPF windows (class name starts with <c>"HwndWrapper"</c>).
		/// </remarks>
		public void SetTransparency(bool allowTransparency, int? opacity = null, ColorInt? colorKey = null, bool noException = false) {
			var est = ExStyle;
			bool layered = est.Has(WSE.LAYERED);
			
			if (allowTransparency) {
				uint col = 0, f = 0; byte op = 0;
				if (colorKey != null) { f |= 1; col = (uint)colorKey.Value.ToBGR(); }
				if (opacity != null) { f |= 2; op = (byte)Math.Clamp(opacity.Value, 0, 255); }
				
				if (!layered) SetExStyle(est | WSE.LAYERED, noException ? WSFlags.NoException : 0);
				if (!Api.SetLayeredWindowAttributes(this, col, op, f) && !noException) ThrowUseNative();
			} else if (layered) {
				SetExStyle(est & ~WSE.LAYERED, noException ? WSFlags.NoException : 0);
				//tested: resets attributes, ie after adding WSE.LAYERED the window will be normal
			}
		}
		
		/// <summary>
		/// Gets window transparency attributes (opacity and transparency color).
		/// </summary>
		/// <param name="opacity">If this function returns <c>true</c> and the window has an opacity attribute, receives the opacity value 0-255, else <c>null</c>.</param>
		/// <param name="colorKey">If this function returns <c>true</c> and the window has a transparency color attribute, receives the color, else <c>null</c>.</param>
		/// <returns>True if the window has transparency attributes set with <see cref="SetTransparency"/> or API <ms>SetLayeredWindowAttributes</ms>. Supports <see cref="lastError"/>.</returns>
		/// <remarks>
		/// Uses API <ms>GetLayeredWindowAttributes</ms>.
		/// </remarks>
		public bool GetTransparency(out int? opacity, out ColorInt? colorKey) {
			opacity = default; colorKey = default;
			if (/*ExStyle.Has(WSE.LAYERED) && */Api.GetLayeredWindowAttributes(this, out uint col, out byte op, out uint f)) {
				if (0 != (f & 1)) colorKey = col;
				if (0 != (f & 2)) opacity = op;
				return true;
			}
			return false;
		}
		
		/// <summary>
		/// Returns <c>true</c> if this is a full-screen window and not desktop.
		/// </summary>
		public bool IsFullScreen => IsFullScreen_(out _);
		
		internal unsafe bool IsFullScreen_(out screen scrn) {
			scrn = default;
			if (Is0) return false;
			
			//is client rect equal to window rect (no border)?
			RECT r, rc, rm;
			r = Rect; //fast
			int cx = r.right - r.left, cy = r.bottom - r.top;
			if (cx < 400 || cy < 300) return false; //too small
			rc = ClientRect; //fast
			if (rc.right != cx || rc.bottom != cy) {
				if (cx - rc.right > 2 || cy - rc.bottom > 2) return false; //some windows have 1-pixel border
			}
			
			//covers whole screen rect?
			scrn = screen.of(this, SODefault.Zero); if (scrn.IsEmpty) return false;
			rm = scrn.Rect;
			
			if (r.left > rm.left || r.top > rm.top || r.right < rm.right || r.bottom < rm.bottom - 1) return false; //info: -1 for inactive Chrome
			
			//is it desktop?
			if (IsOfShellThread_) return false;
			if (this == getwnd.root) return false;
			
			return true;
			
			//This is the best way to test for fullscreen (FS) window. Fast.
			//Window and client rect was equal of almost all my tested FS windows. Except Winamp visualization.
			//Most FS windows are same size as screen, but some slightly bigger.
			//Don't look at window styles. For some FS windows they are not as should be.
			//Returns false if the active window is owned by a fullscreen window. This is different than appbar API interprets it. It's OK for our purposes.
		}
		
		/// <summary>
		/// Returns <c>true</c> if this belongs to <c>GetShellWindow</c>'s thread (usually it is the desktop window).
		/// </summary>
		internal bool IsOfShellThread_ {
			get => 1 == s_isShellWindow.IsShellWindow(this);
		}
		
		/// <summary>
		/// Returns <c>true</c> if this belongs to <c>GetShellWindow</c>'s process (eg a folder window, desktop, taskbar).
		/// </summary>
		internal bool IsOfShellProcess_ {
			get => 0 != s_isShellWindow.IsShellWindow(this);
		}
		
		struct _ISSHELLWINDOW {
			int _tidW, _tidD, _pidW, _pidD;
			IntPtr _w, _wDesk; //not wnd because then TypeLoadException
			
			public int IsShellWindow(wnd w) {
				if (w.Is0) return 0;
				wnd wDesk = getwnd.shellWindow; //fast
				if (w == wDesk) return 1; //Progman. Other window (WorkerW) may be active when desktop active.
				
				//cache because GetWindowThreadProcessId quite slow
				if (w.Handle != _w) { _w = w.Handle; _tidW = w.GetThreadProcessId(out _pidW); }
				if (wDesk.Handle != _wDesk) { _wDesk = wDesk.Handle; _tidD = wDesk.GetThreadProcessId(out _pidD); }
				
				if (_tidW == _tidD) return 1;
				if (_pidW == _pidD) return 2;
				return 0;
			}
		}
		static _ISSHELLWINDOW s_isShellWindow;
		
		/// <summary>
		/// Returns <c>true</c> if this window has Metro style, ie is not a classic desktop window.
		/// </summary>
		/// <remarks>
		/// On Windows 8/8.1 most Windows Store app windows and many shell windows have Metro style.
		/// On Windows 10 few windows have Metro style.
		/// On Windows 7 there are no Metro style windows.
		/// </remarks>
		/// <seealso cref="WndUtil.GetWindowsStoreAppId"/>
		public bool IsWindows8MetroStyle {
			get {
				if (!osVersion.minWin8) return false;
				if (!HasExStyle(WSE.TOPMOST | WSE.NOREDIRECTIONBITMAP) || (Style & WS.CAPTION) != 0) return false;
				if (ClassNameIs("Windows.UI.Core.CoreWindow")) return true;
				if (!osVersion.minWin10 && IsOfShellProcess_) return true;
				return false;
				//could use IsImmersiveProcess, but this is better
			}
		}
		
		/// <summary>
		/// On Windows 10 and later returns non-zero if this top-level window is a UWP app window: 1 if class name is <c>"ApplicationFrameWindow"</c>, 2 if <c>"Windows.UI.Core.CoreWindow"</c>.
		/// </summary>
		/// <seealso cref="WndUtil.GetWindowsStoreAppId"/>
		public int IsUwpApp {
			get {
				if (!osVersion.minWin10) return 0;
				if (!HasExStyle(WSE.NOREDIRECTIONBITMAP)) return 0;
				return ClassNameIs("ApplicationFrameWindow", "Windows.UI.Core.CoreWindow");
				//could use IsImmersiveProcess, but this is better
			}
		}
		
		//This is too litle tested to be public. Tested only with WinUI 3 Controls Gallery. Also WinUI3 is still kinda experimental and rare (2021).
		/// <summary>
		/// On Windows 10 and later returns <c>true</c> if this top-level window is a WinUI app window (class name <c>"WinUIDesktopWin32WindowClass"</c>).
		/// </summary>
		internal bool IsWinUI_ {
			get {
				if (!osVersion.minWin10) return false;
				//if (!HasExStyle(WSE.NOREDIRECTIONBITMAP)) return 0; //only the control (cn "Microsoft.UI.Content.ContentWindowSiteBridge") has this style
				return ClassNameIs("WinUIDesktopWin32WindowClass");
			}
		}
		
		/// <summary>
		/// If this control is (or is based on) a standard control provided by Windows, such as button or treeview, returns the control type. Else returns <c>None</c>.
		/// </summary>
		/// <remarks>
		/// Sends message <c>WM_GETOBJECT</c> <ms>QUERYCLASSNAMEIDX</ms>. Slower than <see cref="ClassName"/> or <see cref="ClassNameIs(string)"/>, but can detect the base type of controls based on standard Windows controls but with a different class name.
		/// </remarks>
		public WControlType CommonControlType => (WControlType)Send(Api.WM_GETOBJECT, 0, (nint)EObjid.QUERYCLASSNAMEIDX);
	}
}

namespace Au.Types {
	/// <summary>
	/// Flags for <see cref="wnd.SetStyle"/> and <see cref="wnd.SetExStyle"/>.
	/// </summary>
	[Flags]
	public enum WSFlags {
		/// <summary>Add the specified styles and don't change others.</summary>
		Add = 1,
		
		/// <summary>Remove the specified styles and don't change others.</summary>
		Remove = 2,
		
		/// <summary>Update non-client area (frame, title bar).</summary>
		UpdateNonclient = 4,
		
		/// <summary>Update client area.</summary>
		UpdateClient = 8,
		
		/// <summary>Don't throw exception when fails.</summary>
		NoException = 16,
	}
	
	/// <summary>
	/// <see cref="wnd.CommonControlType"/>
	/// </summary>
	public enum WControlType {
#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
		None,
		Listbox = 65536,
		Button = 65536 + 2,
		Static,
		Edit,
		Combobox,
		Scrollbar = 65536 + 10,
		Status,
		Toolbar,
		Progress,
		Animate,
		Tab,
		Hotkey,
		Header,
		Trackbar,
		Listview,
		Updown = 65536 + 22,
		ToolTips = 65536 + 24,
		Treeview,
		RichEdit = 65536 + 28
#pragma warning restore CS1591 // Missing XML comment for publicly visible type or member
	}
}

================================================
FILE: Au/wnd/wnd_private.cs
================================================
namespace Au;

public unsafe partial struct wnd {
	/// <summary>
	/// <c>if(!IsOfThisThread) { Thread.Sleep(15); SendTimeout(1000, 0); }</c>
	/// </summary>
	internal void MinimalSleepIfOtherThread_() {
		if (!IsOfThisThread) MinimalSleepNoCheckThread_();
	}
	
	/// <summary>
	/// <c>Thread.Sleep(15); SendTimeout(1000, 0);</c>
	/// </summary>
	internal void MinimalSleepNoCheckThread_() {
		Debug.Assert(!IsOfThisThread);
		//perf.first();
		Thread.Sleep(15);
		SendTimeout(1000, out _, 0);
		//perf.nw();
	}
	
	/// <summary>
	/// On Win10+, if <i>w</i> is <c>"ApplicationFrameWindow"</c>, returns the real app window <c>"Windows.UI.Core.CoreWindow"</c> hosted by <i>w</i>.
	/// If <i>w</i> is minimized, cloaked (eg on other desktop) or the app is starting, the <c>"Windows.UI.Core.CoreWindow"</c> is not its child. Then searches for a top-level window named like <i>w</i>. It is unreliable, but no API for this.
	/// Info: <c>"Windows.UI.Core.CoreWindow"</c> windows hosted by <c>"ApplicationFrameWindow"</c> belong to separate processes. All <c>"ApplicationFrameWindow"</c> windows belong to a single process.
	/// </summary>
	static wnd _WindowsStoreAppFrameChild(wnd w) {
		bool retry = false;
		string name;
		g1:
		if (!osVersion.minWin10 || !w.ClassNameIs("ApplicationFrameWindow")) return default;
		wnd c = Api.FindWindowEx(w, default, "Windows.UI.Core.CoreWindow", null);
		if (!c.Is0) return c;
		if (retry) return default;
		
		name = w.NameTL_; if (name.NE()) return default;
		
		for (; ; ) {
			c = Api.FindWindowEx(default, c, "Windows.UI.Core.CoreWindow", name); //I could not find API for it
			if (c.Is0) break;
			if (c.IsCloaked) return c; //else probably it is an unrelated window
		}
		
		retry = true;
		goto g1;
	}
	
	//not used
	///// <summary>
	///// The reverse of <c>_WindowsStoreAppFrameChild</c>.
	///// </summary>
	//static wnd _WindowsStoreAppHost(wnd w)
	//{
	//	if(!osVersion.minWin10 || !w.ClassNameIs("Windows.UI.Core.CoreWindow")) return default;
	//	wnd wo = w.Get.DirectParent; if(!wo.Is0 && wo.ClassNameIs("ApplicationFrameWindow")) return wo;
	//	string s = w.GetText(false, false); if(s.NE()) return default;
	//	return Api.FindWindow("ApplicationFrameWindow", s);
	//}
	
	internal static partial class Internal_ {
		/// <summary>
		/// Calls API <c>SetProp</c>/<c>GetProp</c> to set/get misc flags for a window.
		/// Currently unused.
		/// </summary>
		internal static class WinFlags {
			static readonly ushort s_atom = Api.GlobalAddAtom("Au.WFlags_"); //atom is much faster than string
			//note: cannot delete atom, eg in static dtor. Deletes even if currently used by a window prop, making the prop useless.
			
			internal static bool Set(wnd w, WFlags_ flags, bool? setAddRem = null) {
				switch (setAddRem) {
				case true: flags = Get(w) | flags; break;
				case false: flags = Get(w) & ~flags; break;
				}
				return w.Prop.Set(s_atom, (int)flags);
			}
			
			internal static WFlags_ Get(wnd w) {
				return (WFlags_)(int)w.Prop[s_atom];
			}
			
			internal static WFlags_ Remove(wnd w) {
				return (WFlags_)(int)w.Prop.Remove(s_atom);
			}
			
			[Flags]
			internal enum WFlags_ {
				//these were used by elm.
				//ChromeYes = 1,
				//ChromeNo = 2,
			}
		}
		
		//internal class LastWndProps
		//{
		//	wnd _w;
		//	long _time;
		//	string _class, _programName, _programPath;
		//	int _tid, _pid;
		
		//	void _GetCommon(wnd w)
		//	{
		//		var t = perf.ms;
		//		if(w != _w || t - _time > 100) { _w = w; _class = _programName= _programPath = null; _tid = _pid = 0; }
		//		_time = t;
		//	}
		
		//	//internal string GetName(wnd w) { _GetCommon(w); return _name; }
		
		//	internal string GetClass(wnd w) { _GetCommon(w); return _class; }
		
		//	internal string GetProgram(wnd w, bool fullPath) { _GetCommon(w); return fullPath ? _programPath : _programName; }
		
		//	internal int GetTidPid(wnd w, out int pid) { _GetCommon(w); pid = _pid; return _tid; }
		
		//	//internal void SetName(string s) => _name = s;
		
		//	internal void SetClass(string s) => _class = s;
		
		//	internal void SetProgram(string s, bool fullPath) { if(fullPath) _programPath = s; else _programName = s; }
		
		//	internal void SetTidPid(int tid, int pid) { _tid = tid; _pid = pid; }
		
		//	[ThreadStatic] static LastWndProps _ofThread;
		//	internal static LastWndProps OfThread => _ofThread ??= new LastWndProps();
		//}
		
		/// <summary>
		/// Returns <c>true</c> if <i>w</i> contains a non-zero special handle value (<see cref="SpecHWND"/>).
		/// Note: <c>SpecHWND.TOP</c> is 0.
		/// </summary>
		public static bool IsSpecHwnd(wnd w) {
			int i = (int)w;
			return (i <= 1 && i >= -3) || i == 0xffff;
		}
		
		/// <summary>
		/// Converts object to <see cref="wnd"/>.
		/// Object can contain <c>null</c>, <see cref="wnd"/>, <c>Control</c>, or <c>System.Windows.DependencyObject</c> (must be in element 0 of <c>object[]</c>).
		/// Avoids loading Forms and WPF dlls when not used.
		/// </summary>
		public static wnd FromObject(object o) => o switch {
			null => default,
			wnd w => w,
			object[] a => _Wpf(a[0]),
			_ => _Control(o)
		};
		
		[MethodImpl(MethodImplOptions.NoInlining)] //prevents loading Forms dlls when don't need
		static wnd _Control(object o) => (o as System.Windows.Forms.Control).Hwnd();
		
		[MethodImpl(MethodImplOptions.NoInlining)] //prevents loading WPF dlls when don't need
		static wnd _Wpf(object o) => (o as System.Windows.DependencyObject).Hwnd();
		
		/// <summary>
		/// If <i>w</i> is handle of a WPF element (<c>Window</c>, <c>Popup</c>, <c>HwndHost</c>-ed control, <c>HwndSource.RootVisual</c>), returns that element, else <c>null</c>.
		/// Slow if <c>HwndHost</c>-ed control.
		/// <i>w</i> can be <c>default</c>.
		/// </summary>
		public static System.Windows.FrameworkElement ToWpfElement(wnd w) {
			if (!w.Is0) {
				if (System.Windows.Interop.HwndSource.FromHwnd(w.Handle) is System.Windows.Interop.HwndSource hs) return hs.RootVisual as System.Windows.FrameworkElement;
				for (var p = w; !(p = p.Get.DirectParent).Is0; w = p) {
					if (System.Windows.Interop.HwndSource.FromHwnd(p.Handle)?.RootVisual is System.Windows.Media.Visual v) {
						return v.FindVisualDescendant(d => d is System.Windows.Interop.HwndHost hh && hh.Handle == w.Handle, orSelf: true) as System.Windows.FrameworkElement; //speed: 200 mcs
					}
				}
			}
			return null;
		}
		
		/// <summary>
		/// An enumerable list of <see cref="wnd"/> for <see cref="wndFinder._FindOrMatch"/> and <see cref="wndChildFinder._FindInList"/>.
		/// Holds <c>ArrayBuilder_</c> or <c>IEnumerator</c> or single <see cref="wnd"/> or none.
		/// Must be disposed if it is <c>ArrayBuilder_</c> or <c>IEnumerator</c>, else disposing is optional.
		/// </summary>
		internal struct WndList_ : IDisposable {
			internal enum ListType { None, ArrayBuilder, Enumerator, SingleWnd }
			
			ListType _t;
			int _i;
			wnd _w;
			IEnumerator<wnd> _en;
			ArrayBuilder_<wnd> _ab;
			
			internal WndList_(ArrayBuilder_<wnd> ab) {
				_ab = ab;
				_t = ListType.ArrayBuilder;
			}
			
			internal WndList_(IEnumerable<wnd> en) {
				var e = en?.GetEnumerator();
				if (e != null) {
					_en = e;
					_t = ListType.Enumerator;
				}
			}
			
			internal WndList_(wnd w) {
				if (!w.Is0) {
					_w = w;
					_t = ListType.SingleWnd;
				}
			}
			
			internal ListType Type => _t;
			
			internal bool Next(out wnd w) {
				w = default;
				switch (_t) {
				case ListType.ArrayBuilder:
					if (_i == _ab.Count) return false;
					w = _ab[_i++];
					break;
				case ListType.Enumerator:
					if (!_en.MoveNext()) return false;
					w = _en.Current;
					break;
				case ListType.SingleWnd:
					if (_i > 0) return false;
					_i = 1; w = _w;
					break;
				default:
					return false;
				}
				return true;
			}
			
			public void Dispose() {
				switch (_t) {
				case ListType.ArrayBuilder: _ab.Dispose(); break;
				case ListType.Enumerator: _en.Dispose(); break;
				}
			}
		}
	}
}


================================================
FILE: Au/wnd/wnd_wait.cs
================================================
namespace Au;

public partial struct wnd {
	/// <summary>
	/// Waits until window exists or is active.
	/// </summary>
	/// <returns>Window handle. On timeout returns <c>default(wnd)</c> if <i>timeout</i> is negative; else exception.</returns>
	/// <param name="timeout">Timeout, seconds. Can be 0 (infinite), >0 (exception) or &lt;0 (no exception). More info: [](xref:wait_timeout).</param>
	/// <param name="active">The window must be the active window (<see cref="active"/>), and not minimized.</param>
	/// <exception cref="TimeoutException"><i>timeout</i> time has expired (if > 0).</exception>
	/// <exception cref="ArgumentException" />
	/// <remarks>
	/// Parameters etc are the same as <see cref="find"/>.
	/// By default ignores invisible and cloaked windows. Use <i>flags</i> if need.
	/// If you have a window's <see cref="wnd"/> variable, to wait until it is active/visible/etc use <see cref="WaitFor"/> instead.
	/// </remarks>
	/// <example>
	/// <code><![CDATA[
	/// wnd w = wnd.wait(10, false, "* Notepad");
	/// print.it(w);
	/// ]]></code>
	/// Using in a WPF window with async/await.
	/// <code><![CDATA[
	/// using System.Windows;
	/// var b = new wpfBuilder("Window").WinSize(250);
	/// b.R.AddButton("Wait", async _ => {
	/// 	  print.it("waiting for Notepad...");
	/// 	  wnd w = await Task.Run(() => wnd.wait(-10, false, "* Notepad"));
	/// 	  if(w.Is0) print.it("timeout"); else print.it(w);
	/// });
	/// if (!b.ShowDialog()) return;
	/// ]]></code>
	/// </example>
	/// <inheritdoc cref="find"/>
	public static wnd wait(Seconds timeout, bool active,
		[ParamString(PSFormat.Wildex)] string name = null,
		[ParamString(PSFormat.Wildex)] string cn = null,
		[ParamString(PSFormat.Wildex)] WOwner of = default,
		WFlags flags = 0, Func<wnd, bool> also = null, WContains contains = default
		) => new wndFinder(name, cn, of, flags, also, contains).Wait(timeout, active);
	
	/// <summary>
	/// Waits until any of specified windows exists or is active.
	/// </summary>
	/// <param name="timeout">Timeout, seconds. Can be 0 (infinite), >0 (exception) or &lt;0 (no exception). More info: [](xref:wait_timeout).</param>
	/// <param name="active">The window must be the active window (<see cref="active"/>), and not minimized.</param>
	/// <param name="windows">Specifies windows, like <c>new("Window1"), new("Window2")</c>.</param>
	/// <returns>1-based index and window handle. On timeout returns <c>(0, default(wnd))</c> if <i>timeout</i> is negative; else exception.</returns>
	/// <exception cref="TimeoutException"><i>timeout</i> time has expired (if > 0).</exception>
	/// <remarks>
	/// By default ignores invisible and cloaked windows. Use <see cref="wndFinder"/> flags if need.
	/// </remarks>
	/// <example>
	/// <code><![CDATA[
	/// var (i, w) = wnd.waitAny(10, true, new("* Notepad"), new("* Word"));
	/// print.it(i, w);
	/// ]]></code>
	/// </example>
	public static (int index, wnd w) waitAny(Seconds timeout, bool active, params wndFinder[] windows) {
		foreach (var f in windows) f.Result = default;
		WFCache cache = active && windows.Length > 1 ? new WFCache() : null;
		var loop = new WaitLoop(timeout);
		for (; ; ) {
			if (active) {
				wnd w = wnd.active;
				for (int i = 0; i < windows.Length; i++) {
					if (windows[i].IsMatch(w, cache) && !w.IsMinimized) return (i + 1, w);
				}
			} else {
				for (int i = 0; i < windows.Length; i++) {
					var f = windows[i];
					if (f.Exists()) return (i + 1, f.Result);
				}
				//FUTURE: optimization: get list of windows once (Lib.EnumWindows2).
				//	Problem: list filtering depends on wndFinder flags. Even if all finders have same flags, its easy to make bugs.
			}
			if (!loop.Sleep()) return default;
		}
	}
	
	//rejected. Not useful. Use the non-static WaitForClosed.
	//		/// <summary>
	//		/// Waits until window does not exist.
	//		/// </summary>
	//		/// <param name="timeout">Timeout, seconds. Can be 0 (infinite), >0 (exception) or &lt;0 (no exception). More info: [](xref:wait_timeout).</param>
	//		/// <returns>Returns true. On timeout returns false if <i>timeout</i> is negative; else exception.</returns>
	//		/// <exception cref="TimeoutException"><i>timeout</i> time has expired (if > 0).</exception>
	//		/// <exception cref="Exception">Exceptions of <see cref="Find"/>.</exception>
	//		/// <remarks>
	//		/// Parameters etc are the same as <see cref="Find"/>.
	//		/// By default ignores invisible and cloaked windows. Use flags if need.
	//		/// If you have a window's wnd variable, to wait until it is closed use <see cref="WaitForClosed"/> instead.
	//		/// Examples: <see cref="Wait"/>.
	//		/// </remarks>
	//		public static bool waitNot(Seconds timeout,
	//			[ParamString(PSFormat.wildex)] string name = null,
	//			[ParamString(PSFormat.wildex)] string cn = null,
	//			[ParamString(PSFormat.wildex)] WOwner of = default,
	//			WFlags flags = 0, Func<wnd, bool> also = null, WContents contains = default)
	//		{
	//			var f = new wndFinder(name, cn, of, flags, also, contains);
	//			return WaitNot(timeout, out _, f);
	//		}
	
	//		/// <summary>
	//		/// Waits until window does not exist.
	//		/// </summary>
	//		/// <param name="timeout"></param>
	//		/// <param name="wFound">On timeout receives the first found matching window that exists.</param>
	//		/// <param name="f">Window properties etc. Can be string, see <see cref="wndFinder.op_Implicit(string)"/>.</param>
	//		/// <exception cref="TimeoutException"><i>timeout</i> time has expired (if > 0).</exception>
	//		public static bool waitNot(Seconds timeout, out wnd wFound, wndFinder f)
	//		{
	//			wFound = default;
	//			var to = new WaitLoop(timeout);
	//			wnd w = default;
	//			for(; ; ) {
	//				if(!w.IsAlive || !f.IsMatch(w)) { //if first time, or closed (!IsAlive), or changed properties (!IsMatch)
	//					if(!f.Exists()) { wFound = default; return true; }
	//					wFound = w = f.Result;
	//				}
	//				if(!to.Sleep()) return false;
	//			}
	//		}
	
	//rejected. Cannot use implicit conversion string to wndFinder.
	//public static bool waitNot(Seconds timeout, wndFinder f)
	//	=> WaitNot(timeout, out _, f);
	
	//Not often used. It's easy with await Task.Run. Anyway, need to provide an example of similar size.
	//public static async Task<wnd> waitAsync(Seconds timeout, string name)
	//{
	//	return await Task.Run(() => wait(timeout, name));
	//}
	
	/// <summary>
	/// Waits for a user-defined state/condition of this window. For example active, visible, enabled, closed, contains something.
	/// </summary>
	/// <param name="timeout">Timeout, seconds. Can be 0 (infinite), >0 (exception) or &lt;0 (no exception). More info: [](xref:wait_timeout).</param>
	/// <param name="condition">Callback function (eg lambda). It is called repeatedly, until returns a value other than <c>default(T)</c>, for example <c>true</c>.</param>
	/// <param name="dontThrowIfClosed">
	/// Do not throw exception when the window handle is invalid or the window was closed while waiting.
	/// In such case the callback function must return a non-default value, like in examples with <see cref="IsAlive"/>. Else exception is thrown (with a small delay) to prevent infinite waiting.
	/// </param>
	/// <returns>Returns the value returned by the callback function. On timeout returns <c>default(T)</c> if <i>timeout</i> is negative; else exception.</returns>
	/// <exception cref="TimeoutException"><i>timeout</i> time has expired (if > 0).</exception>
	/// <exception cref="AuWndException">The window handle is invalid or the window was closed while waiting.</exception>
	/// <example>
	/// <code><![CDATA[
	/// wnd w = wnd.find("* Notepad");
	/// 
	/// //wait max 30 s until window w is active. Exception on timeout or if closed.
	/// w.WaitFor(30, t => t.IsActive);
	/// print.it("active");
	/// 
	/// //wait max 30 s until window w is enabled. Exception on timeout or if closed.
	/// w.WaitFor(30, t => t.IsEnabled);
	/// print.it("enabled");
	/// 
	/// //wait until window w is closed
	/// w.WaitFor(0, t => !t.IsAlive, true); //same as w.WaitForClosed()
	/// print.it("closed");
	/// 
	/// //wait until window w is minimized or closed
	/// w.WaitFor(0, t => t.IsMinimized || !t.IsAlive, true);
	/// if(!w.IsAlive) { print.it("closed"); return; }
	/// print.it("minimized");
	/// 
	/// //wait until window w contains focused control classnamed "Edit"
	/// var c = new wndChildFinder(cn: "Edit");
	/// w.WaitFor(10, t => c.Exists(t) && c.Result.IsFocused);
	/// print.it("control focused");
	/// ]]></code>
	/// </example>
	public T WaitFor<T>(Seconds timeout, Func<wnd, T> condition, bool dontThrowIfClosed = false) {
		bool wasInvalid = false;
		var loop = new WaitLoop(timeout);
		for (; ; ) {
			if (!dontThrowIfClosed) ThrowIfInvalid();
			T r = condition(this);
			if (!EqualityComparer<T>.Default.Equals(r, default)) return r;
			if (dontThrowIfClosed) {
				if (wasInvalid) ThrowIfInvalid();
				wasInvalid = !IsAlive;
			}
			if (!loop.Sleep()) return default;
		}
	}
	
	/// <summary>
	/// Waits until this window has the specified name.
	/// </summary>
	/// <param name="timeout">Timeout, seconds. Can be 0 (infinite), >0 (exception) or &lt;0 (no exception). More info: [](xref:wait_timeout).</param>
	/// <param name="name">
	/// Window name. Usually it is the title bar text.
	/// String format: [wildcard expression](xref:wildcard_expression).
	/// </param>
	/// <param name="not">Wait until this window does not have the specified name.</param>
	/// <returns>Returns <c>true</c>. On timeout returns <c>false</c> if <i>timeout</i> is negative; else exception.</returns>
	/// <exception cref="TimeoutException"><i>timeout</i> time has expired (if > 0).</exception>
	/// <exception cref="AuWndException">The window handle is invalid or the window was closed while waiting.</exception>
	/// <exception cref="ArgumentException">Invalid wildcard expression.</exception>
	public bool WaitForName(Seconds timeout, [ParamString(PSFormat.Wildex)] string name, bool not = false) {
		wildex x = name; //ArgumentNullException, ArgumentException
		return WaitFor(timeout, t => x.Match(t.Name) != not);
	}
	
	/// <summary>
	/// Waits until this window is closed/destroyed or until its process ends.
	/// </summary>
	/// <param name="timeout">Timeout, seconds. Can be 0 (infinite), >0 (exception) or &lt;0 (no exception). More info: [](xref:wait_timeout).</param>
	/// <param name="waitUntilProcessEnds">Wait until the process of this window ends.</param>
	/// <returns>Returns <c>true</c>. On timeout returns <c>false</c> if <i>timeout</i> is negative; else exception.</returns>
	/// <exception cref="TimeoutException"><i>timeout</i> time has expired (if > 0).</exception>
	/// <exception cref="AuException">Failed to open process handle when <i>waitUntilProcessEnds</i> is <c>true</c>.</exception>
	/// <remarks>
	/// If the window is already closed, immediately returns <c>true</c>.
	/// </remarks>
	public bool WaitForClosed(Seconds timeout, bool waitUntilProcessEnds = false) {
		if (!waitUntilProcessEnds) return WaitFor(timeout, t => !t.IsAlive, true);
		
		//TODO3: if window of this thread or process...
		
		if (!IsAlive) return true;
		using var ph = Handle_.OpenProcess(this, Api.SYNCHRONIZE);
		if (ph.Is0) {
			var e = new AuException(0, "*open process handle"); //info: with SYNCHRONIZE can open process of higher IL
			if (!IsAlive) return true;
			throw e;
		}
		return 0 != Au.wait.forHandle(timeout, 0, ph);
	}
}


================================================
FILE: Au/x/NuGet.md
================================================
LibreAutomate is an automation library for Windows. Mostly desktop and web UI automation.

To get the most of it, install the [LibreAutomate](https://www.libreautomate.com/) app.

The host program should use a manifest like [this](https://github.com/qgindi/LibreAutomate/blob/master/_/default.exe.manifest). [More info](https://www.libreautomate.com/articles/Library.html).

================================================
FILE: Au.AppHost/AppHost.cpp
================================================
#define WIN32_LEAN_AND_MEAN
#define _CRT_SECURE_NO_WARNINGS
#pragma warning(disable: 6386 6385 6255 6305 6011 28251)

#include <string>
#include <vector>
#include <windows.h>
#include "coreclrhost.h"

//min supported .NET version. Installed major must be ==, minor >=, patch any (we'll use highest found), preview any (we'll use release or highest preview).
#define NETVERMAJOR 10
#define NETVERMINOR 0
#define NETVERPATCH 0
//#define NETVERPATCH 2 //see the workaround comment below
#define NETVER_SUPPORT_PREVIEW 0 //eg fails with 5.0.0 preview, MethodNotFound exception

/*
Workaround for .NET SDK 6.0.2+ bug: WPF and winforms apps can't start if installed older .NET 6 Runtime.
https://github.com/dotnet/core/issues/7176
The suggested workaround works, tested. But need to edit 4 project files, install the old SDK, build ref.db with the old SDK, maybe more.
Instead let show a message box "please upgrade .NET".
*/

#if 0
template<typename ... Args>
void Print(LPCSTR frm, Args ... args) {
	HWND w = FindWindowW(L"QM_Editor", nullptr); if (w == 0) return;
	size_t size = sizeof...(Args) > 0 ? snprintf(nullptr, 0, frm, args ...) : 0;
	char* buf = size > 0 ? (char*)malloc(++size) : nullptr;
	if (buf != nullptr) {
		snprintf(buf, size, frm, args ...);
		frm = (LPCSTR)buf;
	} else {
		if (frm == nullptr) frm = "";
		size = strlen(frm) + 1;
	}
	auto u = (wchar_t*)malloc(size * 2);
	MultiByteToWideChar(CP_UTF8, 0, frm, (int)size, u, (int)size);
	SendMessage(w, WM_SETTEXT, -1, (LPARAM)u);
	free(u);
	if (buf != nullptr) free(buf);
}
#else
#define Print __noop
#endif

#define lenof(x) (sizeof(x) / sizeof(*(x)))
#define is32bit (sizeof(void*) == 4)

void _WstringFrom(std::wstring& r, LPCWSTR w1, size_t len1, LPCWSTR w2, size_t len2) {
	if (len1 == (size_t)(-1)) len1 = w1 == nullptr ? 0 : wcslen(w1);
	if (len2 == (size_t)(-1)) len2 = w2 == nullptr ? 0 : wcslen(w2);
	if (len1 > 0) {
		r.reserve(len1 + len2);
		r.assign(w1, len1);
		if (len2 > 0) r.append(w2, len2);
	} else r.assign(w2, len2);
}

void _WstringFrom(std::wstring& r, const std::wstring& w1, LPCWSTR w2, size_t len2) {
	_WstringFrom(r, w1.c_str(), w1.length(), w2, len2);
}

void _ToUtf8(LPCWSTR w, size_t len, std::string& r) {
	r.resize(WideCharToMultiByte(CP_UTF8, 0, w, (int)len, nullptr, 0, nullptr, nullptr));
	WideCharToMultiByte(CP_UTF8, 0, w, (int)len, &r[0], (int)r.length(), nullptr, nullptr);
	//note: reserve/resize does not work, because resize fills with 0 chars. It seems there is no way to avoid.
}

void _ToUtf8(const std::wstring& w, std::string& r) {
	_ToUtf8(w.c_str(), (int)w.length(), r);
}

int _ToUtf8(LPCWSTR w, size_t len, LPSTR utf8, size_t lenUtf8) {
	return WideCharToMultiByte(CP_UTF8, 0, w, (int)len, utf8, (int)lenUtf8, nullptr, nullptr);
}

//int _ToUtf16(LPCSTR utf8, int lenUtf8, LPWSTR utf16, int lenUtf16) {
//	return MultiByteToWideChar(CP_UTF8, 0, utf8, lenUtf8, utf16, lenUtf16);
//}

bool _StrEqualI(const std::wstring& s1, LPCWSTR s2) {
	int len = (int)s1.length();
	return wcslen(s2) == len && 2 == CompareStringOrdinal(s1.c_str(), len, s2, len, 1);
}
//bool _StrEqualI(const std::wstring& s1, const std::wstring& s2) {
//	int len = s1.length();
//	return s2.length() == len && 2 == CompareStringOrdinal(s1.c_str(), len, s2.c_str(), len, 1);
//}

bool _FileExists(LPCWSTR path) {
	return 0 == (FILE_ATTRIBUTE_DIRECTORY & GetFileAttributesW(path));
}

bool _DirExists(LPCWSTR path) {
	DWORD att = GetFileAttributesW(path);
	return att != 0xffffffff && 0 != (att & FILE_ATTRIBUTE_DIRECTORY);
}

bool _IsProcessWow64() {
#if _WIN64
	return false;
#else
	BOOL isWow = 0;
	return IsWow64Process(GetCurrentProcess(), &isWow) && isWow;
#endif
}

//bool _IsProcessArm64() {
//#if _M_ARM64
//	return true;
//#else
//	return false;
//#endif
//}

LPCWSTR _ProcessPlatformString() {
#if _M_ARM64
	return L"arm64";
#elif _WIN64
	return L"x64";
#else
	return L"x86";
#endif
}

bool _IsProcessX64andOsArm64() {
#if _M_X64
	static bool have, is;
	if (!have) {
		have = true;
		USHORT processMachine = 0, nativeMachine = 0;
		auto IsWow64Process2 = (BOOL(WINAPI*)(HANDLE, USHORT*, USHORT*))GetProcAddress(GetModuleHandleW(L"kernel32.dll"), "IsWow64Process2");
		if (IsWow64Process2)
			is = IsWow64Process2(GetCurrentProcess(), &processMachine, &nativeMachine) && nativeMachine == IMAGE_FILE_MACHINE_ARM64;
	}
	return is;
#else
	return false;
#endif
}

struct PATHS {
	std::wstring appDir, netCore, netDesktop, coreclrDll, exeName;
	std::string asmDll, exePath;
	bool isPrivateNetRuntime;
	BYTE isEditorOrTaskExe; //1 Au.Editor.exe, 2 Au.Task.exe
};

struct VERSTRUCT {
	int vMinor, vPatch;
	bool preview;
	LPWSTR dirName;
};

bool GetRuntimeDir(LPWSTR dotnetDir, size_t len, std::wstring& rtDir, VERSTRUCT& ver, bool desktop) {
	//get all compatible installed .NET versions
	//	See C:\Downloads\runtime-master\src\installer\corehost\cli\fxr\fx_resolver.cpp
	std::vector<VERSTRUCT> a;
	wcscpy(dotnetDir + len, desktop ? L"\\shared\\Microsoft.WindowsDesktop.App\\*" : L"\\shared\\Microsoft.NETCore.App\\*");
	//#define TESTVERSIONS
#ifdef TESTVERSIONS
	LPCWSTR atest[] = { L"5.2.1", /*L"5.0.1",*/ L"5.0.0-preview.2", /*L"5.0.5-preview.2",*/ L"5.1.2", L"5.2.2", };
	//LPCWSTR atest[] = { L"3.0.1", L"5.0.0-preview.2", L"6.0.0", };
	for (int itest = 0; itest < lenof(atest); itest++) {
		LPWSTR s = (LPWSTR)atest[itest], s0 = s;
#else
	WIN32_FIND_DATAW fd;
	HANDLE h = FindFirstFileW(dotnetDir, &fd);
	if (h == INVALID_HANDLE_VALUE) return false;
	do {
		LPWSTR s = fd.cFileName, s0 = s;
		if (*s < '1' || *s > '9' || 0 == (fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) continue;
#endif
		//Print("%S", s);
		int vMajor = wcstol(s, &s, 10); if (vMajor != NETVERMAJOR) continue;
		if (*s++ != '.' || *s < '0' || *s > '9') continue;
		int vMinor = wcstol(s, &s, 10); if (vMinor < NETVERMINOR) continue;
		//if(desktop && vMinor != ver.vMinor) continue; //no, dotnet apphost eats it
		if (*s++ != '.' || *s < '0' || *s > '9') continue;
		int vPatch = wcstol(s, &s, 10); if (vPatch < NETVERPATCH) continue;
		VERSTRUCT v;
		v.vMinor = vMinor;
		v.vPatch = vPatch;
		v.preview = s[0] == '-' && s[1] == 'p';
		if (!NETVER_SUPPORT_PREVIEW && v.preview && vMinor == NETVERMINOR && v.vPatch == 0) continue;
		v.dirName = _wcsdup(s0);
		//Print("%i %i %i %i", vMajor, v.vMinor, v.vPatch, v.preview);
		a.push_back(v);
#ifdef TESTVERSIONS
	}
#else
	} while (FindNextFileW(h, &fd));
	FindClose(h);
#endif
	int n = (int)a.size();
	if (n == 0) return false;

	//get the best match
	//	https://learn.microsoft.com/en-us/dotnet/core/versions/selection
	//	Like documented there, we roll forward to the nearest minor version and use the highest patch version.
	//	But dotnet apphost doesn't, eg fails if need 3.1 but found 3.2, and even if need 3.1.2 but found 3.1.0. Only rolls forward patch version.
	//		Tested long ago. Not tested with .NET 5. Maybe this was set in json by VS.
	int iBest = -1, bestMinor = -1, bestPatch = -1;
	for (int i = 0; i < n; i++) {
		int v = a[i].vMinor;
		if (desktop && v == ver.vMinor) { bestMinor = v; break; }
		if ((DWORD)v < (DWORD)bestMinor) bestMinor = v;
	}
	for (int i = 0; i < n; i++) {
		if (a[i].vMinor != bestMinor) continue;
		int v = a[i].vPatch;
		if (desktop && v == ver.vPatch) { bestPatch = v; iBest = i; break; }
		if (v > bestPatch) {
			bestPatch = v; iBest = i;
		}
	}
	if (a[iBest].preview) { //don't need this if preview is auto-uninstalled when installing release, but I still did not have a chance to test
		for (int i = 0; i < n; i++) {
			if (a[i].vMinor != bestMinor || a[i].vPatch != bestPatch) continue;
			//if(!a[i].preview || StrCmpLogicalW(a[i].dirName, a[iBest].dirName) > 0) iBest = i; //no, it seems old previews are auto-unisnstalled
			if (!a[i].preview) {
				iBest = i; break;
			}
		}
	}
#ifdef TESTVERSIONS
	Print("BEST: %i %i %S", bestMinor, bestPatch, a[iBest].dirName);
	exit(0);
#endif

	_WstringFrom(rtDir, dotnetDir, wcslen(dotnetDir) - 1, a[iBest].dirName, -1);
	ver = a[iBest];

	for (int i = 0; i < n; i++) free(a[i].dirName);

	return true;
}

char s_asmName[800] = "\0hi7yl8kJNk+gqwTDFi7ekQ";

bool GetPaths(PATHS& p) {
	//https://github.com/dotnet/designs/blob/master/accepted/install-locations.md

	wchar_t w[1000];
	size_t lenApp, lenAppDir;

	//get exe full path
	lenApp = ::GetModuleFileNameW(0, w, lenof(w) - 100);
	_ToUtf8(w, lenApp, p.exePath);

	//get appDir and exeName
	for (lenAppDir = lenApp; w[--lenAppDir] != '\\'; ) {}
	p.appDir.assign(w, lenAppDir);
	p.exeName = w + lenAppDir + 1;

	//get asmDll
	if (s_asmName[0] == 0) p.isEditorOrTaskExe = 2; //Au.Task.exe. Don't need p.asmDll.
	else {
		if (s_asmName[0] == 1) p.isEditorOrTaskExe = 1; //Au.Editor.exe (see project BuildEvents); else exe created from a script (see Compiler.cs > _AppHost).
		_ToUtf8(w, lenAppDir + 1, p.asmDll);
		p.asmDll += s_asmName + p.isEditorOrTaskExe;
	}

#if _M_ARM64
	auto coreclr2 = L"\\dotnetARM\\coreclr.dll";
#elif _WIN64
	auto coreclr2 = L"\\dotnet\\coreclr.dll";
#else
	auto coreclr2 = L"\\dotnet32\\coreclr.dll";
#endif

	p.isPrivateNetRuntime = false;
	//is coreclr.dll in app dir?
	wcscpy(w + lenAppDir, L"\\coreclr.dll");
	if (_FileExists(w)) goto gPrivate;
	//is in "dotnet" subdir?
	wcscpy(w + lenAppDir, coreclr2);
	if (_FileExists(w)) goto gPrivate;

	//is this an exeProgram launched from portable LA? Then LA dir contains coreclr.dll.
	if (p.isEditorOrTaskExe == 0) {
		auto n = GetCurrentDirectory(lenof(w), w);
		auto s1 = L"\\Roslyn\\.exeProgram"; const int len1 = 19;
		if (n >= 4 + len1 && n < lenof(w) - 50 && _wcsicmp(w + n - len1, s1) == 0) {
			n -= len1;
			wcscpy(w + n, L"\\coreclr.dll");
			if (_FileExists(w)) goto gPrivate;
			wcscpy(w + n, coreclr2);
			if (_FileExists(w)) goto gPrivate;
		}
	}

	//get .NET root path, like "C:\Program Files\dotnet". See C:\Downloads\runtime-master\src\installer\corehost\cli\fxr_resolver.cpp.
	for (int i = 0; i <= 2; i++) {
		DWORD lenDotnet;
		if (i == 0) { //env var DOTNET_ROOT
			auto varName = _IsProcessWow64() ? L"DOTNET_ROOT(x86)" : _IsProcessX64andOsArm64() ? L"DOTNET_ROOT_X64" : L"DOTNET_ROOT";
			lenDotnet = GetEnvironmentVariableW(varName, w, lenof(w));

			if (lenDotnet > 0) Print("%S=%S", varName, w);
		} else if (i == 1) { //registry InstallLocation
			wchar_t key[50] = LR"(SOFTWARE\dotnet\Setup\InstalledVersions\)";
			wcscat(key, _ProcessPlatformString());
			HKEY hk1;
			if (0 != RegOpenKeyExW(HKEY_LOCAL_MACHINE, key, 0, KEY_READ | KEY_WOW64_32KEY, &hk1)) lenDotnet = 0;
			else {
				if (0 != RegQueryValueExW(hk1, L"InstallLocation", nullptr, nullptr, (LPBYTE)w, &(lenDotnet = lenof(w)))) lenDotnet = 0; else lenDotnet /= 2;
				RegCloseKey(hk1);
			}

			//if (lenDotnet > 0) Print("registry=%S", w);
		} else { //default location
			lenDotnet = ExpandEnvironmentStringsW(L"%ProgramFiles%\\dotnet", w, lenof(w) - 100);
			if (w[0] == '%') lenDotnet = 0;
			else if (_IsProcessX64andOsArm64()) { wcscat(w, L"\\x64"); lenDotnet += 4; }

			//SHGetSpecialFolderPathW //no, don't use shell apis, it's not so important. Current dotnet versions set the registry value. Dotnet apphost even uses literal "Program Files" etc string.

			if (lenDotnet > 0) Print("default=%S", w);
		}
		if (i > 0 && lenDotnet != 0) lenDotnet--;
		if (lenDotnet > 1 && w[lenDotnet - 1] == '\\') lenDotnet--;
		if (lenDotnet > 1 && lenDotnet < lenof(w) - 100 && _DirExists(w)) {
			VERSTRUCT ver;
			if (!GetRuntimeDir(w, lenDotnet, p.netCore, ver, false)) continue;
			if (!GetRuntimeDir(w, lenDotnet, p.netDesktop, ver, true)) continue;

			//get coreclrDll
			_WstringFrom(p.coreclrDll, p.netCore, L"\\coreclr.dll", -1);
			if (_FileExists(p.coreclrDll.c_str())) return true;
		}
	}
	return false;

gPrivate:
	p.isPrivateNetRuntime = true;
	p.coreclrDll = w;
	p.netCore.assign(w, p.coreclrDll.length() - 12);
	p.netDesktop = p.netCore;
	return true;
}

//Gets TPA assemblies (.NET, Au, etc) from resource added from file dotnet_ref_editor.txt or dotnet_ref_task.txt.
//The file is created by script "Create dotnet_ref.txt.cs".
//	The script parses .NET deps.json, like dotnet does it at run time.
//		Need to run it for each major .NET version.
//	The script also adds Au, and in the future maybe other omnipresent assemblies.
//		For Au.Editor also adds Au.Controls, and in the future maybe more.
//		Need to edit/run it when these dependencies change.
//For Au.Editor.exe and Au.Task.exe the resource is added by BuildEvents.exe (executed as a postbuild task of Au.Editor project).
//For exeProgram the resource is added by Compiler._Resources.AddTpa.
void BuildTpaList(const PATHS& p, std::string& tpaList) {
	std::string dir;
	auto ri = FindResource(0, (LPCWSTR)1, (LPCWSTR)220);
	DWORD size = SizeofResource(0, ri);
	auto s = (LPCSTR)LockResource(LoadResource(0, ri));

	for (LPCSTR se = s + size; s < se;) {
		auto ss = s; while (*ss != '|' && ss < se) ss++;
		if (*s == '*') {
			switch (*(++s)) {
			case 'd': _ToUtf8(p.netDesktop, dir); break;
			case 'c': _ToUtf8(p.netCore, dir); break;
			default: _ToUtf8(p.appDir, dir); break; //'a'
			}
			dir += '\\';
		} else {
			tpaList.append(dir);
			tpaList.append(s, ss - s);
			tpaList.append(".dll;");
		}
		s = ss + 1;
	}

	//note: don't use stringstream, it makes file size *= 2.
}

const char** ArgsUtf8(int& nArgs) {
	int na = __argc - 1;
	auto a = __wargv + 1;
	size_t size = 0; for (int i = 0; i < na; i++) size += wcslen(a[i]) * 3 + 1;
	auto r = (const char**)malloc(na * sizeof(LPSTR) + size);
	LPSTR p = (LPSTR)(r + na);
	for (int i = 0; i < na; i++) {
		int k = _ToUtf8(a[i], -1, p, size);
		if (k == 0) exit(-1);
		r[i] = p;
		p += k;
		size -= k;
	}
	nArgs = na;
	return r;
}

struct _TaskInit {
	const char* asmFile;
	const char** args;
	int nArgs;
};

int APIENTRY wWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPWSTR pCmdLine, int nCmdShow) {
#if 0
	//LARGE_INTEGER c;
	//QueryPerformanceCounter(&c);
	//return c.LowPart;


	return 0;
#else
	//LARGE_INTEGER t1, t2, t3, t4; QueryPerformanceCounter(&t1);

	PATHS p;
	bool pathsOK = GetPaths(p);
	//Print("pathsOK=%i", pathsOK);
	//Print("exeName=%S", p.exeName.c_str());
	//Print("exePath=%s", p.exePath.c_str());
	//Print("asmDll=%s", p.asmDll.c_str());
	//Print("appDir=%S", p.appDir.c_str());
	//Print("netCore=%S", p.netCore.c_str());
	//Print("netDesktop=%S", p.netDesktop.c_str());
	//Print("coreclrDll=%S", p.coreclrDll.c_str());

	if (!pathsOK) {
		wchar_t w[200];
		wsprintfW(w, L"To run this application, need to install:\r\n\r\n"
			L".NET %i Desktop Runtime %s\r\n\r\n"
			L"Would you like to download it now?", NETVERMAJOR, _ProcessPlatformString());
		if (IDYES == MessageBoxW(0, w, p.exeName.c_str(), MB_ICONERROR | MB_YESNO | MB_TOPMOST | MB_SETFOREGROUND)) {
			AllowSetForegroundWindow(ASFW_ANY);
			auto ShellExecuteW = (int(WINAPI*)(HWND, LPCWSTR, LPCWSTR, LPCWSTR, LPCWSTR, INT))GetProcAddress(LoadLibraryExW(L"shell32", 0, 0), "ShellExecuteW");
			//wsprintfW(w, L"https://dotnet.microsoft.com/en-us/download/dotnet/%i.%i/runtime", NETVERMAJOR, NETVERMINOR);
#if true
			wsprintfW(w, L"https://dotnet.microsoft.com/en-us/download/dotnet/%i.%i", NETVERMAJOR, NETVERMINOR);
			ShellExecuteW(NULL, nullptr, w, nullptr, nullptr, SW_SHOWNORMAL);
			Sleep(1000);
			wsprintfW(w, L"In the dowload page please find and download this:\r\n\r\n.NET Desktop Runtime for Windows %s", _ProcessPlatformString());
			MessageBoxW(0, w, p.exeName.c_str(), MB_ICONINFORMATION | MB_TOPMOST | MB_SETFOREGROUND);
#else
			//rejected. It's a legacy undocumented URL. Very slow in some countries, eg China, because does not use CDN.
			//note: this URL is different for preview/rc (before the final version released).
			wsprintfW(w, L"https://aka.ms/dotnet/%i.%i/windowsdesktop-runtime-win-x%i.exe", NETVERMAJOR, NETVERMINOR, bits); //latest patch
			ShellExecuteW(NULL, nullptr, w, nullptr, nullptr, SW_SHOWNORMAL);
#endif
		}
		return -1;
	}

	HMODULE hm = LoadLibraryExW(p.coreclrDll.c_str(), 0, LOAD_WITH_ALTERED_SEARCH_PATH); //3 ms
	if (hm == NULL) return -2;
	auto coreclr_initialize = (coreclr_initialize_ptr)GetProcAddress(hm, "coreclr_initialize");
	auto coreclr_execute_assembly = (coreclr_execute_assembly_ptr)GetProcAddress(hm, "coreclr_execute_assembly");
	auto coreclr_shutdown = (coreclr_shutdown_ptr)GetProcAddress(hm, "coreclr_shutdown");

	void* hostHandle;
	unsigned int domainId;
	int hr;
	{
		//TRUSTED_PLATFORM_ASSEMBLIES
		std::string tpaList; tpaList.reserve(30000);
		BuildTpaList(p, tpaList);

		//NATIVE_DLL_SEARCH_DIRECTORIES
		std::wstring nd16; nd16.reserve(1000);
		nd16 += p.appDir;
#if _M_ARM64 //these are mostly fbc, if somebody uses it. See Cpp.LoadAuNativeDll.
		nd16 += L"\\64\\ARM\\;";
#elif _WIN64
		nd16 += L"\\64\\;";
#else
		nd16 += L"\\32\\;";
#endif
		//rejected. For NuGet packages we use another way. This would not work, because sometimes need L"\\runtimes\\win10-x64\\native\\;" etc.
//		nd16 += p.appDir;
//#if _M_ARM64
//		nd16 += L"\\runtimes\\win-arm64\\native\\;";
//#elif _WIN64
//		nd16 += L"\\runtimes\\win-x64\\native\\;";
//#else
//		nd16 += L"\\runtimes\\win-x86\\native\\;";
//#endif
		if (!p.isPrivateNetRuntime) { nd16 += p.netDesktop; nd16 += L"\\;"; }
		nd16 += p.netCore; nd16 += L"\\;";
		std::string nd8; _ToUtf8(nd16, nd8);

		//APP_CONTEXT_BASE_DIRECTORY
		std::string appDir8; _ToUtf8(p.appDir, appDir8); appDir8 += '\\';

		const char* propertyKeys[] = { "TRUSTED_PLATFORM_ASSEMBLIES", "NATIVE_DLL_SEARCH_DIRECTORIES", "APP_CONTEXT_BASE_DIRECTORY", "APP_PATHS" };
		const char* propertyValues[] = { tpaList.c_str(), nd8.c_str(), appDir8.c_str(), nullptr };

		//Note: don't add APP_PATHS. The .NET apphost does not add it too.
		//	.NET and Au.* assemblies are in the TPA list.
		//	For others, on assembly resolve event we call AssemblyLoadContext.LoadFromAssemblyPath.
		//  Cannot use both APP_PATHS and event. If a dll with same name is in APP_PATHS, .NET loads it instead.
		int nProp = 3;
#if !true
		std::string ap8;
		if (p.isEditorOrTaskExe == 0) {
			ap8.assign(appDir8, 0, appDir8.length() - 1);
			propertyValues[nProp++] = ap8.c_str();
		}
		//this code adds only appDir. But if using nuget's "runtimes" subdir, at first need to add its dlls to TPA (or maybe subdirs to APP_PATHS). It is difficult here. The event code handles it.
#endif
		//Print("--- %S ---", p.exeName.c_str());
		//Print("TRUSTED_PLATFORM_ASSEMBLIES:"); Print("%s", propertyValues[0]);
		//Print("NATIVE_DLL_SEARCH_DIRECTORIES:"); Print("%s", propertyValues[1]);
		//Print("APP_CONTEXT_BASE_DIRECTORY:"); Print("%s", propertyValues[2]);

		SetEnvironmentVariableW(L"COMPlus_legacyCorruptedStateExceptionsPolicy", L"1");

		//QueryPerformanceCounter(&t2); //all above code 6 ms cold, 3.6 hot

		hr = coreclr_initialize(p.exePath.c_str(), "main", nProp, propertyKeys, propertyValues, &hostHandle, &domainId);
		if (hr < 0) {
			return -3;
		}

		//QueryPerformanceCounter(&t3); //22 ms cold, 16 hot
	} //free temp strings eg tpaList 30000

	//attaching debugger? Note, this must be after coreclr_initialize, else fails to attach.
	STARTUPINFOW si = {};
	GetStartupInfoW(&si);
	if (si.dwXCountChars == 1703529821) {
		auto he = OpenEventW(SYNCHRONIZE, false, L"Au.event.Debugger");
		if (!he || 0 != WaitForSingleObject(he, 30000)) return -1;
		CloseHandle(he);
	}

	unsigned int ec = 0;
	if (p.isEditorOrTaskExe == 2) { //Au.Task.exe (task process for a script with role miniProgram)
		auto coreclr_create_delegate = (coreclr_create_delegate_ptr)GetProcAddress(hm, "coreclr_create_delegate");
		void (STDMETHODCALLTYPE * Init)(LPWSTR, _TaskInit&) = nullptr;
		coreclr_create_delegate(hostHandle, domainId, "Au", "Au.More.MiniProgram_", "Init", (void**)&Init); //waits until editor asks to execute a task; it sends task info through pipe
		//QueryPerformanceCounter(&t4); //1 ms
		_TaskInit t = { };
		Init(pCmdLine, t);
		if (t.asmFile != nullptr) { //null when editor exits
			hr = coreclr_execute_assembly(hostHandle, domainId, t.nArgs, t.args, t.asmFile, &ec);
		}
	} else {
		int nArgs = 0;
		const char* args0[1] = {};
		const char** args = *pCmdLine != 0 ? ArgsUtf8(nArgs) : args0;

		hr = coreclr_execute_assembly(hostHandle, domainId, nArgs, args, p.asmDll.c_str(), &ec); //6 ms
	}
	//Print("%i %i %i", (t2.LowPart - t1.LowPart) / 10, (t3.LowPart - t2.LowPart) / 10, (t4.LowPart - t3.LowPart) / 10);

	//tested: AppDomain.ProcessExit event is in coreclr_shutdown.
	//	AppDomain.UnhandledException event is in coreclr_execute_assembly, and it does not return.

	coreclr_shutdown(hostHandle, domainId);

	if (hr < 0) {
		return -4;
	}
	return ec;
#endif
}


================================================
FILE: Au.AppHost/Au.AppHost.vcxproj
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <ItemGroup Label="ProjectConfigurations">
    <ProjectConfiguration Include="Release|ARM64">
      <Configuration>Release</Configuration>
      <Platform>ARM64</Platform>
    </ProjectConfiguration>
    <ProjectConfiguration Include="Release|Win32">
      <Configuration>Release</Configuration>
      <Platform>Win32</Platform>
    </ProjectConfiguration>
    <ProjectConfiguration Include="Release|x64">
      <Configuration>Release</Configuration>
      <Platform>x64</Platform>
    </ProjectConfiguration>
  </ItemGroup>
  <PropertyGroup Label="Globals">
    <VCProjectVersion>16.0</VCProjectVersion>
    <ProjectGuid>{5DCF20C5-9BBD-44E2-96BE-323A845B99F4}</ProjectGuid>
    <Keyword>Win32Proj</Keyword>
    <RootNamespace>Au.AppHost</RootNamespace>
    <ProjectName>Au.AppHost</ProjectName>
    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
  </PropertyGroup>
  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
    <ConfigurationType>Application</ConfigurationType>
    <UseDebugLibraries>false</UseDebugLibraries>
    <PlatformToolset>v143</PlatformToolset>
    <WholeProgramOptimization>true</WholeProgramOptimization>
    <CharacterSet>Unicode</CharacterSet>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
    <ConfigurationType>Application</ConfigurationType>
    <UseDebugLibraries>false</UseDebugLibraries>
    <PlatformToolset>v143</PlatformToolset>
    <WholeProgramOptimization>true</WholeProgramOptimization>
    <CharacterSet>Unicode</CharacterSet>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'" Label="Configuration">
    <ConfigurationType>Application</ConfigurationType>
    <UseDebugLibraries>false</UseDebugLibraries>
    <PlatformToolset>v143</PlatformToolset>
    <WholeProgramOptimization>true</WholeProgramOptimization>
    <CharacterSet>Unicode</CharacterSet>
  </PropertyGroup>
  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
  <ImportGroup Label="ExtensionSettings">
  </ImportGroup>
  <ImportGroup Label="Shared">
  </ImportGroup>
  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
  </ImportGroup>
  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
  </ImportGroup>
  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'" Label="PropertySheets">
    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
  </ImportGroup>
  <PropertyGroup Label="UserMacros" />
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
    <LinkIncremental>false</LinkIncremental>
    <OutDir>bin\$(Configuration)\$(Platform)\</OutDir>
    <EmbedManifest>false</EmbedManifest>
    <IntDir>obj\$(Configuration)\$(Platform)\</IntDir>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
    <LinkIncremental>false</LinkIncremental>
    <OutDir>bin\$(Configuration)\$(Platform)\</OutDir>
    <EmbedManifest>false</EmbedManifest>
    <IntDir>obj\$(Configuration)\$(Platform)\</IntDir>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'">
    <LinkIncremental>false</LinkIncremental>
    <OutDir>bin\$(Configuration)\$(Platform)\</OutDir>
    <EmbedManifest>false</EmbedManifest>
    <IntDir>obj\$(Configuration)\$(Platform)\</IntDir>
  </PropertyGroup>
  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
    <ClCompile>
      <PrecompiledHeader>
      </PrecompiledHeader>
      <WarningLevel>Level3</WarningLevel>
      <Optimization>MinSpace</Optimization>
      <FunctionLevelLinking>true</FunctionLevelLinking>
      <IntrinsicFunctions>true</IntrinsicFunctions>
      <SDLCheck>false</SDLCheck>
      <PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <ConformanceMode>true</ConformanceMode>
      <FavorSizeOrSpeed>Size</FavorSizeOrSpeed>
      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
    </ClCompile>
    <Link>
      <SubSystem>Windows</SubSystem>
      <EnableCOMDATFolding>true</EnableCOMDATFolding>
      <OptimizeReferences>true</OptimizeReferences>
      <GenerateDebugInformation>true</GenerateDebugInformation>
      <DelayLoadDLLs>
      </DelayLoadDLLs>
      <StackReserveSize>0x200000</StackReserveSize>
    </Link>
    <PostBuildEvent>
      <Command>xcopy $(TargetPath) $(SolutionDir)_\32\ /Y
</Command>
    </PostBuildEvent>
  </ItemDefinitionGroup>
  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
    <ClCompile>
      <PrecompiledHeader>
      </PrecompiledHeader>
      <WarningLevel>Level3</WarningLevel>
      <FunctionLevelLinking>true</FunctionLevelLinking>
      <IntrinsicFunctions>true</IntrinsicFunctions>
      <SDLCheck>false</SDLCheck>
      <PreprocessorDefinitions>NDEBUG;WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <ConformanceMode>true</ConformanceMode>
      <FavorSizeOrSpeed>Size</FavorSizeOrSpeed>
      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
      <LanguageStandard>Default</LanguageStandard>
      <Optimization>MinSpace</Optimization>
    </ClCompile>
    <Link>
      <SubSystem>Windows</SubSystem>
      <EnableCOMDATFolding>true</EnableCOMDATFolding>
      <OptimizeReferences>true</OptimizeReferences>
      <GenerateDebugInformation>true</GenerateDebugInformation>
      <SectionAlignment>
      </SectionAlignment>
      <DelayLoadDLLs>
      </DelayLoadDLLs>
      <StackReserveSize>0x200000</StackReserveSize>
    </Link>
    <PostBuildEvent>
      <Command>xcopy $(TargetPath) $(SolutionDir)_\64\ /Y</Command>
    </PostBuildEvent>
  </ItemDefinitionGroup>
  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'">
    <ClCompile>
      <PrecompiledHeader>
      </PrecompiledHeader>
      <WarningLevel>Level3</WarningLevel>
      <FunctionLevelLinking>true</FunctionLevelLinking>
      <IntrinsicFunctions>true</IntrinsicFunctions>
      <SDLCheck>false</SDLCheck>
      <PreprocessorDefinitions>NDEBUG;WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <ConformanceMode>true</ConformanceMode>
      <FavorSizeOrSpeed>Size</FavorSizeOrSpeed>
      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
      <LanguageStandard>Default</LanguageStandard>
      <Optimization>MinSpace</Optimization>
    </ClCompile>
    <Link>
      <SubSystem>Windows</SubSystem>
      <EnableCOMDATFolding>true</EnableCOMDATFolding>
      <OptimizeReferences>true</OptimizeReferences>
      <GenerateDebugInformation>true</GenerateDebugInformation>
      <SectionAlignment>
      </SectionAlignment>
      <DelayLoadDLLs>
      </DelayLoadDLLs>
      <StackReserveSize>0x200000</StackReserveSize>
    </Link>
    <PostBuildEvent>
      <Command>xcopy $(TargetPath) $(SolutionDir)_\64\ARM\ /Y</Command>
    </PostBuildEvent>
  </ItemDefinitionGroup>
  <ItemGroup>
    <ClCompile Include="AppHost.cpp" />
  </ItemGroup>
  <ItemGroup>
    <ClInclude Include="coreclrhost.h" />
  </ItemGroup>
  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
  <ImportGroup Label="ExtensionTargets">
  </ImportGroup>
</Project>

================================================
FILE: Au.AppHost/Au.AppHost.vcxproj.filters
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <ItemGroup>
    <ClCompile Include="AppHost.cpp" />
  </ItemGroup>
  <ItemGroup>
    <ClInclude Include="coreclrhost.h" />
  </ItemGroup>
</Project>

================================================
FILE: Au.AppHost/ResourceHacker.txt
================================================
[FILENAMES]
Exe=    64\Au.AppHost.exe
SaveAs= Au.Task.exe
Log= CONSOLE
[COMMANDS]
-add ..\Au.AppHost\Script.ico, ICONGROUP,32512,0
-addoverwrite ..\Au.Editor\Resources\Au.manifest, MANIFEST,1,0
-add dotnet_ref.txt, 220,1,0


================================================
FILE: Au.AppHost/coreclrhost.h
================================================
// Retrieved from https://github.com/dotnet/coreclr/blob/master/src/coreclr/hosts/inc/coreclrhost.h

// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.

//
// APIs for hosting CoreCLR
//

#ifndef __CORECLR_HOST_H__
#define __CORECLR_HOST_H__

#if defined(_WIN32) && defined(_M_IX86)
#define CORECLR_CALLING_CONVENTION __stdcall
#else
#define CORECLR_CALLING_CONVENTION
#endif

// For each hosting API, we define a function prototype and a function pointer
// The prototype is useful for implicit linking against the dynamic coreclr
// library and the pointer for explicit dynamic loading (dlopen, LoadLibrary)
#define CORECLR_HOSTING_API(function, ...) \
    extern "C" int CORECLR_CALLING_CONVENTION function(__VA_ARGS__); \
    typedef int (CORECLR_CALLING_CONVENTION *function##_ptr)(__VA_ARGS__)
    
//
// Initialize the CoreCLR. Creates and starts CoreCLR host and creates an app domain
//
// Parameters:
//  exePath                 - Absolute path of the executable that invoked the ExecuteAssembly (the native host application)
//  appDomainFriendlyName   - Friendly name of the app domain that will be created to execute the assembly
//  propertyCount           - Number of properties (elements of the following two arguments)
//  propertyKeys            - Keys of properties of the app domain
//  propertyValues          - Values of properties of the app domain
//  hostHandle              - Output parameter, handle of the created host
//  domainId                - Output parameter, id of the created app domain 
//
// Returns:
//  HRESULT indicating status of the operation. S_OK if the assembly was successfully executed
//
CORECLR_HOSTING_API(coreclr_initialize,
            const char* exePath,
            const char* appDomainFriendlyName,
            int propertyCount,
            const char** propertyKeys,
            const char** propertyValues,
            void** hostHandle,
            unsigned int* domainId);

//
// Shutdown CoreCLR. It unloads the app domain and stops the CoreCLR host.
//
// Parameters:
//  hostHandle              - Handle of the host
//  domainId                - Id of the domain
//
// Returns:
//  HRESULT indicating status of the operation. S_OK if the assembly was successfully executed
//
CORECLR_HOSTING_API(coreclr_shutdown,
            void* hostHandle,
            unsigned int domainId);

//
// Shutdown CoreCLR. It unloads the app domain and stops the CoreCLR host.
//
// Parameters:
//  hostHandle              - Handle of the host
//  domainId                - Id of the domain
//  latchedExitCode         - Latched exit code after domain unloaded
//
// Returns:
//  HRESULT indicating status of the operation. S_OK if the assembly was successfully executed
//
CORECLR_HOSTING_API(coreclr_shutdown_2,
            void* hostHandle,
            unsigned int domainId,
            int* latchedExitCode);

//
// Create a native callable function pointer for a managed method.
//
// Parameters:
//  hostHandle              - Handle of the host
//  domainId                - Id of the domain 
//  entryPointAssemblyName  - Name of the assembly which holds the custom entry point
//  entryPointTypeName      - Name of the type which holds the custom entry point
//  entryPointMethodName    - Name of the method which is the custom entry point
//  delegate                - Output parameter, the function stores a native callable function pointer to the delegate at the specified address
//
// Returns:
//  HRESULT indicating status of the operation. S_OK if the assembly was successfully executed
//
CORECLR_HOSTING_API(coreclr_create_delegate,
            void* hostHandle,
            unsigned int domainId,
            const char* entryPointAssemblyName,
            const char* entryPointTypeName,
            const char* entryPointMethodName,
            void** delegate);

//
// Execute a managed assembly with given arguments
//
// Parameters:
//  hostHandle              - Handle of the host
//  domainId                - Id of the domain 
//  argc                    - Number of arguments passed to the executed assembly
//  argv                    - Array of arguments passed to the executed assembly
//  managedAssemblyPath     - Path of the managed assembly to execute (or NULL if using a custom entrypoint).
//  exitCode                - Exit code returned by the executed assembly
//
// Returns:
//  HRESULT indicating status of the operation. S_OK if the assembly was successfully executed
//
CORECLR_HOSTING_API(coreclr_execute_assembly,
            void* hostHandle,
            unsigned int domainId,
            int argc,
            const char** argv,
            const char* managedAssemblyPath,
            unsigned int* exitCode);

#undef CORECLR_HOSTING_API
                      
#endif // __CORECLR_HOST_H__


================================================
FILE: Au.Controls/Au.Controls.cs
================================================
/*/
role classLibrary
define CONTROLS,IDE_LA,NO_GLOBAL,NO_DEFAULT_CHARSET_UNICODE
noWarnings 1591,419,649
preBuild ..\@Au.Editor\_prePostBuild.cs
outputPath %folders.Workspace%\..\Au.Editor
miscFlags 1
noRef *\Au.dll
pr ..\@Au\Au.cs
resource resources\Generic.xaml /embedded
/*/


================================================
FILE: Au.Controls/Au.Controls.csproj
================================================
<Project Sdk="Microsoft.NET.Sdk">

	<PropertyGroup>
		<TargetFramework>net10.0-windows</TargetFramework>
		<UseWPF>true</UseWPF>
		<UseWindowsForms>true</UseWindowsForms>
		<GenerateAssemblyInfo>false</GenerateAssemblyInfo>
		<AssemblyName>Au.Controls</AssemblyName>
		<RootNamespace>Au.Controls</RootNamespace>
		<SignAssembly>true</SignAssembly>
		<AssemblyOriginatorKeyFile>..\Au.snk</AssemblyOriginatorKeyFile>
		<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
		<DocumentationFile>bin\Au.Controls.xml</DocumentationFile>
		<NoWarn>1591;419;8981</NoWarn>
		<LangVersion>preview</LangVersion>
		<NoDefaultLaunchSettingsFile>true</NoDefaultLaunchSettingsFile>
		<ProduceReferenceAssembly>False</ProduceReferenceAssembly>
		<Platforms>AnyCPU</Platforms>
	</PropertyGroup>

	<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
	  <DebugType>embedded</DebugType>
	  <DefineConstants>$(DefineConstants);CONTROLS</DefineConstants>
	</PropertyGroup>

	<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">
	  <DebugType>embedded</DebugType>
	  <DefineConstants>$(DefineConstants);CONTROLS</DefineConstants>
	</PropertyGroup>

	<ItemGroup>
	  <Compile Include="..\Au\Resources\global2.cs" Link="resources\global2.cs" />
	</ItemGroup>

	<ItemGroup>
	  <ProjectReference Include="..\Au\Au.csproj" />
	</ItemGroup>

</Project>


================================================
FILE: Au.Controls/KMenuCommands/KMenuCommands+.cs
================================================
using System.Windows;
using System.Windows.Controls;
using System.Windows.Controls.Primitives;
using System.Windows.Data;
using System.Windows.Input;
using System.Windows.Media;
using System.Xml.Linq;

namespace Au.Controls;

public partial class KMenuCommands {
	/// <summary>
	/// Contains a method delegate and a menu item that executes it. Implements <see cref="ICommand"/> and can have one or more attached buttons etc and key/mouse shortcuts that execute it. All can be disabled/enabled with single function call.
	/// Also used for submenu-items (created from nested types); it allows for example to enable/disable all descendants with single function call.
	/// </summary>
	public class Command : ICommand {
		readonly KMenuCommands _mc;
		readonly Delegate _del; //null if submenu
		readonly CommandAttribute _ca;
		MenuItem _mi;
		bool _enabled;
		
		internal Command(KMenuCommands mc, string name, string text, MemberInfo mi, CommandAttribute ca) {
			_mc = mc;
			_enabled = true;
			Name = name;
			Text = text;
			_ca = ca;
			Keys = ca.keys;
			if (mi is MethodInfo k) _del = k.CreateDelegate(k.GetParameters().Length == 0 ? typeof(Action) : typeof(Action<MenuItem>));
			//if (mi is MethodInfo k) _del = k.CreateDelegate(k.GetParameters().Length == 0 ? typeof(Action) : typeof(Action<object>));
		}
		
		internal void SetMenuItem_(object text, string image, MenuItem miFactory = null) {
			_mi = miFactory ?? new MenuItem { Header = text }; //factory action may have set it
			_mi.Command = this;
			if (image != null && miFactory?.Icon == null) _SetImage(image);
		}
		
		MenuItem _Mi => _mi ?? throw new InvalidOperationException("Call FactoryParams.SetMenuItem before.");
		
		///
		public MenuItem MenuItem => _mi;
		
		/// <summary>
		/// true if this is a submenu-item.
		/// </summary>
		public bool IsSubmenu => _del == null;
		
		/// <summary>
		/// Method name. If submenu-item - type name.
		/// Or <see cref="CommandAttribute.name"/>.
		/// May have prefix <see cref="CommandAttribute.namePrefix"/>.
		/// </summary>
		public string Name { get; }
		
		///
		public override string ToString() => Name;
		
		public CommandAttribute Attribute => _ca;
		
		/// <summary>
		/// Menu item text. Also button text/tooltip if not set.
		/// </summary>
		public string Text { get; }
		
		/// <summary>
		/// Button text or tooltip. Same as menu item text but without _ for Alt-underline.
		/// </summary>
		public string ButtonText { get; set; }
		
		/// <summary>
		/// <see cref="CommandAttribute.tooltip"/>.
		/// </summary>
		public string ButtonTooltip { get; set; }
		
		/// <summary>
		/// Default or custom hotkey etc.
		/// </summary>
		public string Keys { get; private set; }
		
		/// <summary>
		/// Subscribes to <see cref="MenuItem.SubmenuOpened"/> event.
		/// Will propagate to copied submenus.
		/// Call once.
		/// </summary>
		/// <param name="action">Called on <b>SubmenuOpened</b> event. Not called for events bubbled from descendant submenus.</param>
		public void OnSubmenuOpened(Action<MenuItem> action) {
			Debug.Assert(_submenuOpened == null);
			_Mi.SubmenuOpened += _submenuOpened = (o, e) => {
				if (o != e.Source) return; //bubbled
				action((MenuItem)o);
			};
		}
		RoutedEventHandler _submenuOpened;
		
		//static void _SetSubmenuOpenedEvent(MenuItem mi, Action<MenuItem> )
		
		/// <summary>
		/// Something to attach to this object. Not used by this class.
		/// </summary>
		public object Tag { get; set; }
		
		/// <summary>
		/// Sets properties of a button to match properties of this menu item.
		/// </summary>
		/// <param name="b">Button or checkbox etc.</param>
		/// <param name="imageAt">If menu item has image, set <b>Content</b> = <b>DockPanel</b> with image and text and dock image at this side. If null (default), sets image without text. Not used if there is no image.</param>
		/// <param name="image">Button image element, if different than menu item image. Must not be a child of something.</param>
		/// <param name="text">Button text, if different than menu item text.</param>
		/// <param name="skipImage">Don't change image.</param>
		/// <exception cref="InvalidOperationException">This is a submenu. Or called from factory action before <see cref="FactoryParams.SetMenuItem"/>.</exception>
		/// <remarks>
		/// Sets these properties:
		/// - <b>Content</b> (image or/and text),
		/// - <b>ToolTip</b>,
		/// - <b>Foreground</b>,
		/// - <b>Command</b> (to execute same method and automatically enable/disable together),
		/// - Automation Name (if with image),
		/// - if checkable, synchronizes checked state (the button should be a ToggleButton (CheckBox or RadioButton)).
		/// </remarks>
		public void CopyToButton(ButtonBase b, Dock? imageAt = null, UIElement image = null, string text = null, bool skipImage = false) {
			if (IsSubmenu) throw new InvalidOperationException("Submenu. Use CopyToMenu.");
			_ = _Mi;
			text ??= ButtonText;
			
			if (skipImage) {
				switch (b.Content) {
				case DockPanel dp: image = dp.Children[0]; dp.Children.Clear(); break;
				case UIElement ue: image = ue; break;
				default: image = null; break;
				}
				b.Content = null;
			} else {
				image ??= CopyImage();
			}
			
			if (image == null) {
				b.Content = text;
				b.Padding = new Thickness(4, 1, 4, 2);
				_SetTooltip(ButtonTooltip);
			} else if (imageAt != null) {
				var v = new DockPanel();
				var dock = imageAt.Value;
				DockPanel.SetDock(image, dock);
				v.Children.Add(image);
				var t = new TextBlock { Text = text };
				if (dock == Dock.Left || dock == Dock.Right) t.Margin = new Thickness(2, -1, 2, 1);
				v.Children.Add(t);
				b.Content = v;
				_SetTooltip(ButtonTooltip);
			} else { //only image
				b.Content = image;
				_SetTooltip(ButtonTooltip ?? text);
			}
			b.Foreground = _mi.Foreground;
			if (image != null && !text.NE()) System.Windows.Automation.AutomationProperties.SetName(b, text);
			b.Command = this;
			
			if (_mi.IsCheckable) {
				if (b is ToggleButton tb) tb.SetBinding(ToggleButton.IsCheckedProperty, new Binding("IsChecked") { Source = _mi });
				else print.warning($"Menu item {Name} is checkable, but button isn't a ToggleButton (CheckBox or RadioButton).");
			}
			
			void _SetTooltip(string s) {
				string k = this.Keys, g = _mi.InputGestureText;
				if (!k.NE() || !g.NE()) {
					if (!g.NE()) k = k.NE() ? g : g + ", " + k;
					s = s.NE() ? k : $"{s}\n\n{k}";
				}
				b.ToolTip = s;
			}
		}
		
		//public void CopyToButton<T>(out T b, Dock? imageAt = null) where T : ButtonBase, new() => CopyToButton(b = new T(), imageAt);
		
		/// <summary>
		/// Sets properties of another menu item (not in this menu) to match properties of this menu item.
		/// If this is a submenu-item, copies with descendants.
		/// </summary>
		/// <param name="m"></param>
		/// <param name="image">Image element (<see cref="MenuItem.Icon"/>), if different. Must not be a child of something.</param>
		/// <param name="text">Text (<see cref="HeaderedItemsControl.Header"/>), if different.</param>
		/// <exception cref="InvalidOperationException">Called from factory action before <see cref="FactoryParams.SetMenuItem"/>.</exception>
		/// <remarks>
		/// Sets these properties:
		/// - <b>Header</b> (if string),
		/// - <b>Icon</b> (if possible),
		/// - <b>InputGestureText</b>,
		/// - <b>ToolTip</b>,
		/// - <b>Foreground</b>,
		/// - <b>Command</b> (to execute same method and automatically enable/disable together),
		/// - <b>IsCheckable</b> (and synchronizes checked state).
		/// </remarks>
		public void CopyToMenu(MenuItem m, UIElement image = null, object text = null) => _CopyToMenu(_Mi, m, image, text);
		
		static MenuItem _CopyToMenu(MenuItem from, MenuItem to, UIElement image = null, object text = null) {
			if (from.Command is not Command c) return null;
			to ??= new();
			
			to.Icon = image ?? _CopyImage(from);
			if (text != null) to.Header = text;
			else if (from.Header is string s) {
				if (to.Role is MenuItemRole.TopLevelItem) s = StringUtil.RemoveUnderlineChar(s, '_'); //eg _Find would disable normal operation of _File
				to.Header = s;
			}
			to.InputGestureText = from.InputGestureText;
			to.ToolTip = from.ToolTip;
			to.Foreground = from.Foreground;
			to.Command = c;
			
			bool checkable = from.IsCheckable;
			to.IsCheckable = checkable;
			if (checkable) to.SetBinding(MenuItem.IsCheckedProperty, new Binding("IsChecked") { Source = from });
			
			if (from.HasItems) {
				//lazy. Toolbar item submenus created now don't display hotkeys, because keyboard bindings are set afterwards.
				to.Items.Add("");
				RoutedEventHandler smo = null;
				smo = (_, _) => {
					to.SubmenuOpened -= smo;
					to.Items.Clear();
					_CopyDescendants(from, to);
				};
				to.SubmenuOpened += smo;
				
				if (c._submenuOpened != null) to.SubmenuOpened += c._submenuOpened;
			}
			
			return to;
		}
		
		static void _CopyDescendants(ItemsControl from, ItemsControl to) {
			int n = 0;
			foreach (var v in from.Items) {
				object k;
				switch (v) {
				case Separator:
					k = new Separator();
					break;
				case MenuItem g:
					k = _CopyToMenu(g, null);
					if (k == null) continue; //not Command. Added dynamically. Will add again.
					break;
				default: continue;
				}
				to.Items.Add(k);
				n++;
			}
		}
		
		/// <summary>
		/// Copies descendants of this submenu to a context menu.
		/// </summary>
		/// <exception cref="InvalidOperationException">This is not a submenu. Or called from factory action before <see cref="FactoryParams.SetMenuItem"/>.</exception>
		/// <remarks>
		/// For each new item sets the same properties as other overload.
		/// </remarks>
		public void CopyToMenu(ContextMenu cm) {
			if (!IsSubmenu) throw new InvalidOperationException("Not submenu");
			_CopyDescendants(_Mi, cm);
		}
		
		/// <summary>
		/// Copies menu item image element. Returns null if no image or cannot copy.
		/// </summary>
		/// <exception cref="InvalidOperationException">Called from factory action before <see cref="FactoryParams.SetMenuItem"/>.</exception>
		public UIElement CopyImage() => _CopyImage(_Mi);
		
		static UIElement _CopyImage(MenuItem from) {
			switch (from.Icon) {
			case Image im: return new Image { Source = im.Source };
			case UIElement e when e.Uid is string res: //see _SetImage
				if (ResourceUtil.HasResourcePrefix(res)) return ResourceUtil.GetXamlObject(res) as UIElement;
				if (res.Starts("source:")) return ImageUtil.LoadWpfImageElement(res[7..]);
				break;
			}
			return null;
		}
		
		bool _SetImage(string image, bool custom = false) {
			try {
				if (image.NE()) {
					_mi.Icon = null;
				} else {
#if DEBUG
					bool res = !(custom || image.Starts('*') || pathname.isFullPath(image));
#else
					bool res = !(custom || image.Starts('*'));
#endif
					var ie = res
						? ResourceUtil.GetWpfImageElement(image)
						: ImageUtil.LoadWpfImageElement(image);
					if (ie is not Image) ie.Uid = (res ? "resource:" : "source:") + image; //xaml source for _CopyImage
					_mi.Icon = ie;
				}
				return true;
			}
			catch (Exception ex) {
				if (custom) CustomizingError("failed to load image", ex);
				else print.it($"Failed to load image {image}. {ex.ToStringWithoutStack()}");
			}
			return false;
		}
		
		/// <summary>
		/// Gets enabled/disabled state of this command, menu item and all controls with <b>Command</b> property = this (see <see cref="CopyToButton"/>, <see cref="CopyToMenu"/>).
		/// </summary>
		public bool Enabled => _enabled;
		
		/// <summary>
		/// Sets enabled/disabled state of this command, menu item and all controls with <b>Command</b> property = this (see <see cref="CopyToButton"/>, <see cref="CopyToMenu"/>).
		/// If submenu-item, also enables/disables all descendants. Does not actually disable/enable the submenu-item.
		/// </summary>
		/// <exception cref="InvalidOperationException">Called from factory action before <see cref="FactoryParams.SetMenuItem"/>.</exception>
		public void Enable(bool enable) {
			_ = _Mi;
			if (enable == _enabled) return;
			_enabled = enable;
			if (IsSubmenu) {
				foreach (var v in _mi.Items) if (v is MenuItem m && m.Command is Command c && !c.NoIndirectDisable) c.Enable(enable);
			} else {
				CanExecuteChanged?.Invoke(this, EventArgs.Empty); //enables/disables this menu item and all buttons etc with Command=this
			}
		}
		
		/// <summary>
		/// Don't change the enabled state indirectly when changing that of the parent menu.
		/// </summary>
		public bool NoIndirectDisable { get; set; }
		
		/// <summary>
		/// Gets or sets checked state of this checkable menu item and all checkable controls with <b>Command</b> property = this (see <see cref="CopyToButton"/>, <see cref="CopyToMenu"/>).
		/// </summary>
		/// <exception cref="InvalidOperationException">Called from factory action before <see cref="FactoryParams.SetMenuItem"/>.</exception>
		public bool Checked {
			get => _Mi.IsChecked;
			set { if (value != _Mi.IsChecked) _mi.IsChecked = value; }
		}
		
		#region ICommand
		
		public bool CanExecute(object parameter) => _enabled;
		
		public void Execute(object parameter) {
			_mc.ExecutingStartedEnded?.Invoke(true);
			try {
				switch (_del) {
				case Action a0: a0(); break;
				case Action<MenuItem> a1: a1(_mi); break;
					//case Action<object> a1: a1(parameter); break;
					//default: throw new InvalidOperationException("Submenu");
				}
			}
			finally { _mc.ExecutingStartedEnded?.Invoke(false); }
		}
		
		/// <summary>
		/// When disabled or enabled with <see cref="Enabled"/>.
		/// </summary>
		public event EventHandler CanExecuteChanged;
		
		#endregion
		
		/// <summary>
		/// Finds and returns toolbar button that has this command. Returns null if not found.
		/// </summary>
		public ButtonBase FindButtonInToolbar(ToolBar tb) => tb.Items.OfType<ButtonBase>().FirstOrDefault(o => o.Command == this);
		
		/// <summary>
		/// Finds and returns toolbar menu-button that has this command. Returns null if not found.
		/// </summary>
		public MenuItem FindMenuButtonInToolbar(ToolBar tb) {
			foreach (var e in tb.Items) {
				if (e is Decorator d && d.Child is Menu m && m.Items[0] is MenuItem mi && mi.Command == this) return mi;
			}
			return null;
		}
		
		//public void Test() {
		//	foreach (var v in CanExecuteChanged.GetInvocationList()) {
		//		print.it(v.Target);
		//	}
		//}
		
		internal void Customize_(XElement x, ToolBar toolbar) {
			OverflowMode hide = default;
			bool separator = false;
			string text = null, btext = null;
			Dock? imageAt = null;
			
			foreach (var a in x.Attributes()) {
				string an = a.Name.LocalName, av = a.Value;
				try {
					switch (an) {
					case "keys":
						Keys = av;
						break;
					case "color":
						_mi.Foreground = new SolidColorBrush((Color)ColorConverter.ConvertFromString(av));
						break;
					case "image":
						_SetImage(av, custom: true);
						break;
					case "text":
						_mi.Header = text = av;
						break;
					case "btext" when toolbar != null:
						btext = av;
						break;
					case "separator" when toolbar != null:
						separator = true;
						break;
					case "hide" when toolbar != null:
						hide = Enum.Parse<OverflowMode>(av, true);
						break;
					case "imageAt" when toolbar != null:
						imageAt = Enum.Parse<Dock>(av, true);
						break;
					default:
						CustomizingError($"attribute '{an}' can't be used here");
						break;
					}
				}
				catch (Exception ex) { CustomizingError($"invalid '{an}' value", ex); }
			}
			if ((btext ?? text) != null) ButtonText = btext ?? StringUtil.RemoveUnderlineChar(text, '_');
			
			if (toolbar != null) {
				try {
					if (separator) {
						var sep = new Separator();
						if (hide != default) ToolBar.SetOverflowMode(sep, hide);
						toolbar.Items.Add(sep);
					}
					FrameworkElement e;
					if (IsSubmenu) {
						var k = new MenuItem();
						var image = _mi.Icon;
						bool onlyImage = image != null && imageAt == null;
						if (image == null || onlyImage) k.Padding = new Thickness(3, 1, 3, 2); //make taller. If image+text, button too tall, text too high, icon too low, never mind. Never mind: not good on Win7.
						CopyToMenu(k, text: btext);
						if (onlyImage) { k.Header = k.Icon; k.Icon = null; } //make narrower
						if (ButtonTooltip != null) k.ToolTip = ButtonTooltip; else if (onlyImage) k.ToolTip = ButtonText + "...";
						var m = new Menu { Background = toolbar.Background, IsMainMenu = false, UseLayoutRounding = true };
						m.Items.Add(k); //parent must be Menu, else wrong Role (must be TopLevelHeader, we can't change) and does not work
						
						//workaround for: 1. Descendant icon part black when checked. 2. Different drop-down menu style.
						//	Never mind: different hot style.
						e = new Border { Child = m };
						k.Padding = osVersion.minWin8 ? new(4, 2, 4, 2) : new(5, 3, 5, 3); //on Win7 smaller
					} else {
						var b = _mi.IsCheckable ? (ButtonBase)new CheckBox() : new Button(); //rejected: support RadioButton
						b.Focusable = false;
						b.UseLayoutRounding = true;
						CopyToButton(b, imageAt);
						b.Padding = new(4, 2, 4, 2);
						e = b;
					}
					if (hide != default) ToolBar.SetOverflowMode(e, hide);
					toolbar.Items.Add(e);
				}
				catch (Exception ex) { CustomizingError("failed to create button", ex); }
			}
		}
		
		public void CustomizingError(string s, Exception ex = null) {
			_mc.OnCustomizingError?.Invoke(this, s, ex);
		}
	}
	
	public event Action<bool> ExecutingStartedEnded;
	
	class _XElementNameEqualityComparer : IEqualityComparer<XElement> {
		bool IEqualityComparer<XElement>.Equals(XElement x, XElement y) => x.Name == y.Name;
		int IEqualityComparer<XElement>.GetHashCode(XElement x) => x.Name.GetHashCode();
	}
	static _XElementNameEqualityComparer s_xmlNameComparer = new();
	
	/// <summary>
	/// Called on error in a custom attribute.
	/// </summary>
	public Action<Command, string, Exception> OnCustomizingError;
	
	/// <summary>
	/// Parameters for factory action of <see cref="KMenuCommands"/>.
	/// </summary>
	public class FactoryParams {
		internal FactoryParams(Command command, MemberInfo member) { this.command = command; this.member = member; }
		
		/// <summary>
		/// The new command.
		/// <see cref="Command.MenuItem"/> is still null and you can call <see cref="SetMenuItem"/>.
		/// </summary>
		public readonly Command command;
		
		/// <summary>
		/// <see cref="MethodInfo"/> of method or <see cref="TypeInfo"/> of nested class.
		/// For example allows to get attributes of any type.
		/// </summary>
		public readonly MemberInfo member;
		
		/// <summary>
		/// Text or a WPF element to add to the text part of the menu item. In/out parameter.
		/// Text may contain _ for Alt-underline, whereas <c>command.Text</c> is without it.
		/// </summary>
		public object text;
		
		/// <summary><see cref="CommandAttribute.image"/>. In/out parameter.</summary>
		public string image;
		
		/// <summary><see cref="CommandAttribute.param"/>. In/out parameter. This class does not use it.</summary>
		public object param;
		
		/// <summary>
		/// Sets <see cref="Command.MenuItem"/> property.
		/// If your factory action does not call this function, the menu item will be created after it returns.
		/// </summary>
		/// <param name="mi">Your created menu item. If null, this function creates standard menu item.</param>
		/// <remarks>
		/// Uses the <i>text</i> and <i>image</i> fields; you can change them before. Sets menu item's <b>Icon</b> property if image!=null and mi?.Image==null. Sets <b>Header</b> property only if creates new item.
		/// The menu item will be added to the parent menu after your factory action returns.
		/// </remarks>
		public void SetMenuItem(MenuItem mi = null) => command.SetMenuItem_(text, image, mi);
	}
}

/// <summary>
/// Used with <see cref="KMenuCommands"/>.
/// Allows to add menu items in the same order as methods and nested types, and optionally specify menu item text etc.
/// </summary>
[AttributeUsage(AttributeTargets.Method | AttributeTargets.Class, AllowMultiple = false, Inherited = false)]
public class CommandAttribute : Attribute {
	internal readonly int order_;
	
	/// <summary>
	/// Command name to use instead of method/type name. Use to resolve duplicate name conflict.
	/// </summary>
	public string name;
	
	/// <summary>
	/// Name prefix of this command, and default prefix of descendants. Use to resolve duplicate name conflict.
	/// </summary>
	public string namePrefix;
	
	/// <summary>
	/// Menu item text. Use _ to Alt-underline a character. If "...", appends it to default text.
	/// </summary>
	public string text;
	
	/// <summary>
	/// Alt-underlined character in menu item text.
	/// </summary>
	public char underlined;
	
	/// <summary>
	/// Add separator before the menu item.
	/// </summary>
	public bool separator;
	
	/// <summary>
	/// Checkable menu item.
	/// </summary>
	public bool checkable;
	
	/// <summary>
	/// Default hotkey etc. See <see cref="KMenuCommands.BindKeysTarget"/>.
	/// </summary>
	public string keys;
	
	/// <summary>
	/// Element where the hotkey etc (default or customized) will work. See <see cref="KMenuCommands.BindKeysTarget"/>.
	/// If this property applied to a class (submenu), all descendant commands without this property inherit it from the ancestor class.
	/// </summary>
	public string target;
	
	/// <summary>
	/// Text for <see cref="MenuItem.InputGestureText"/>. If not set, will use <b>keys</b>.
	/// </summary>
	public string keysText;
	
	/// <summary>
	/// Image string.
	/// The factory action receives this string in parameters. It can load image and set menu item's <b>Icon</b> property.
	/// If factory action not used or does not set <b>Image</b> property and does not set image=null, this class loads image from database or exe or script resources and sets <b>Icon</b> property. The resource file can be xaml (for example converted from svg) or png etc. If using Visual Studio, to add an image to resources set its build action = Resource. More info: <see cref="Au.More.ResourceUtil"/>.
	/// </summary>
	public string image;
	
	/// <summary>
	/// Tooltip text for the menu item and toolbar button (see <see cref="KMenuCommands.Command.CopyToButton"/>).
	/// The displayed tooltip also contains menu item text in the first line.
	/// </summary>
	public string tooltip;
	
	/// <summary>
	/// A string or other value to pass to the factory action.
	/// </summary>
	public object param;
	
	/// <summary>
	/// Don't add the <b>MenuItem</b> to menu.
	/// </summary>
	public bool hide;
	
	/// <summary>
	/// Don't change the enabled state indirectly when changing that of the parent menu.
	/// </summary>
	public bool noIndirectDisable;
	
	/// <summary>
	/// Sets menu item text = method/type name with spaces instead of _ , like Select_all -> "Select all".
	/// </summary>
	/// <param name="l_">[](xref:caller_info)</param>
	public CommandAttribute([CallerLineNumber] int l_ = 0) { order_ = l_; }
	
	/// <summary>
	/// Specifies menu item text.
	/// </summary>
	/// <param name="text">Menu item text. Use _ to Alt-underline a character, like "_Copy".</param>
	/// <param name="l_">[](xref:caller_info)</param>
	public CommandAttribute(string text, [CallerLineNumber] int l_ = 0) { this.text = text; order_ = l_; }
	
	/// <summary>
	/// Specifies Alt-underlined character. Sets menu item text = method/type name with spaces instead of _ , like Select_all -> "Select all".
	/// </summary>
	/// <param name="underlined">Character to underline.</param>
	/// <param name="l_">[](xref:caller_info)</param>
	public CommandAttribute(char underlined, [CallerLineNumber] int l_ = 0) { this.underlined = underlined; order_ = l_; }
}


================================================
FILE: Au.Controls/KMenuCommands/KMenuCommands.cs
================================================
using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;
using System.Xml.Linq;

//TODO3: when a checkbox button command invoked with a hotkey, now does not change check state in menu and toolbar.
//	Only in Edit menu. Even if target="" and scintilla not focused. Works well in other menus. Don't know why.
//	Currently affected code explicitly changes check state.

namespace Au.Controls;

/// <summary>
/// Builds a WPF window menu with submenus and items that execute static methods defined in a class and nested classes.
/// Supports xaml/png/etc images, key/mouse shortcuts, auto-Alt-underline, easy creating of toolbar buttons and context menus with same/synchronized properties (command, text, image, enabled, checked, etc).
/// </summary>
/// <remarks>
/// Creates submenus from public static nested types with <see cref="CommandAttribute"/>.
/// Creates executable menu items from public static methods with <see cref="CommandAttribute"/>.
/// From each such type and method creates a <see cref="Command"/> object that you can access through indexer.
/// Supports methods <c>public static void Method()</c> and <c>public static void Method(MenuItem)</c>.
/// </remarks>
/// <example>
/// <code><![CDATA[
/// var cmd=new KMenuCommands(typeof(Commands), menu);
/// cmd[nameof(Commands.Edit.Paste)].Enabled = false;
/// cmd[nameof(Commands.File.Rename)].SetKeys("F12", _window);
/// ]]></code>
/// 
/// <code><![CDATA[
/// static class Commands {
/// 	[Command('F')]
/// 	public static class File {
/// 		[Command('R')]
/// 		public static void Rename() {  }
/// 		
/// 		[Command('D')]
/// 		public static void Delete() {  }
/// 		
/// 		[Command("_Properties...", image = "properties.xaml")]
/// 		public static void Properties() {  }
/// 		
/// 		[Command('N')]
/// 		public static class New {
/// 			[Command('D')]
/// 			public static void Document() {  }
/// 			
/// 			[Command('F')]
/// 			public static void Folder() {  }
/// 		}
/// 		
/// 		[Command('x', separator = true)]
/// 		public static void Exit(object param) {  }
/// 	}
/// 	
/// 	[Command('E')]
/// 	public static class Edit {
/// 		[Command('t')]
/// 		public static void Cut() {  }
/// 		
/// 		[Command('C')]
/// 		public static void Copy() {  }
/// 		
/// 		[Command('P')]
/// 		public static void Paste() {  }
/// 		
/// 		[Command('D', name = "Edit-Delete")]
/// 		public static void Delete() {  }
/// 		
/// 		[Command('a')]
/// 		public static void Select_all() {  }
/// 	}	
/// }
/// ]]></code>
/// </example>
public partial class KMenuCommands {
	readonly Dictionary<string, Command> _d = new(200);
	Menu _menubar;
	
	/// <summary>
	/// Builds a WPF window menu with submenus and items that execute static methods defined in a class and nested classes.
	/// See example in class help.
	/// </summary>
	/// <param name="commands">A type that contains nested types with methods. Must be in single source file (not partial class).</param>
	/// <param name="menu">An empty <b>Menu</b> object. This function adds items to it.</param>
	/// <param name="autoUnderline">Automatically insert _ in item text for Alt-underlining where not specified explicitly.</param>
	/// <param name="itemFactory">Optional callback function that is called for each menu item. Can create menu items, set properties, create toolbar buttons, etc.</param>
	/// <exception cref="ArgumentException">Duplicate name. Use <see cref="CommandAttribute.name"/>.</exception>
	public KMenuCommands(Type commands, Menu menu, bool autoUnderline = true, Action<FactoryParams> itemFactory = null) {
		_menubar = menu;
		_CreateMenu(commands, menu, autoUnderline, itemFactory);
	}
	
	void _CreateMenu(Type type, ItemsControl parentMenu, bool autoUnderline, Action<FactoryParams> itemFactory, List<string> added = null, string namePrefix_ = null, string inheritTarget_ = null) {
		var am = type.GetMembers(BindingFlags.Public | BindingFlags.Static | BindingFlags.DeclaredOnly);
		
		if (am.Length == 0) { //dynamic submenu
			parentMenu.Items.Add(new Separator());
			return;
		}
		
		List<(MemberInfo mi, CommandAttribute a)> list = new(am.Length);
		foreach (var mi in am) {
			var ca = mi.GetCustomAttribute<CommandAttribute>(false);
			//var ca = mi.GetCustomAttributes().OfType<CommandAttribute>().FirstOrDefault(); //CommandAttribute and inherited. Similar speed. Don't need because factory action receives MemberInfo an can get other attributes from it.
			if (ca != null) list.Add((mi, ca));
		}
		
		var au = new List<char>();
		
		foreach (var (mi, ca) in list.OrderBy(o => o.a.order_)) {
			if (ca.separator && !ca.hide) parentMenu.Items.Add(new Separator());
			
			ca.target ??= inheritTarget_;
			
			string text = ca.text, buttonText, dots = null; //menu item text, possibly with _ for Alt-underline
			if (text == "...") { dots = text; text = null; }
			if (text != null) {
				buttonText = StringUtil.RemoveUnderlineChar(text, '_');
			} else {
				buttonText = text = mi.Name.Replace('_', ' ') + dots;
				char u = ca.underlined;
				if (u != default) {
					int i = text.IndexOf(u);
					if (i >= 0) text = text.Insert(i, "_"); else print.it($"Alt-underline character '{u}' not found in \"{text}\"");
				}
			}
			
			var namePrefix = ca.namePrefix ?? namePrefix_;
			string name = namePrefix + (ca.name ?? mi.Name);
			var c = new Command(this, name, text, mi, ca);
			_d.Add(name, c);
			added?.Add(name);
			
			c.ButtonText = buttonText;
			if (ca.tooltip is string tt) c.ButtonTooltip = parentMenu is Menu ? tt : $"{buttonText}{(ca.checkable ? "  (option)" : null)}.\n{tt}";
			else if (ca.checkable) c.ButtonTooltip = $"{buttonText}  (option)";
			
			FactoryParams f = null;
			if (itemFactory != null) {
				f = new FactoryParams(c, mi) { text = text, image = ca.image, param = ca.param };
				itemFactory(f);
				if (c.MenuItem == null) c.SetMenuItem_(f.text, f.image); //did not call SetMenuItem
			} else {
				if (c.MenuItem == null) c.SetMenuItem_(text, ca.image);
			}
			if (!ca.keysText.NE()) c.MenuItem.InputGestureText = ca.keysText;
			if (autoUnderline && c.MenuItem.Header is string s && _FindUnderlined(s, out char uc)) au.Add(char.ToLower(uc));
			if (ca.checkable) c.MenuItem.IsCheckable = true;
			if (c.ButtonTooltip != null) c.MenuItem.ToolTip = c.ButtonTooltip;
			if (ca.noIndirectDisable) c.NoIndirectDisable = true;
			if (parentMenu is Menu m1) c.MenuItem.MinHeight = 22;
			
			if (!ca.hide) parentMenu.Items.Add(c.MenuItem);
			if (mi is TypeInfo ti) {
				_CreateMenu(ti, c.MenuItem, autoUnderline, itemFactory, added, namePrefix, ca.target);
				if (ti.GetDeclaredMethod("_Init") is { } init) init.Invoke(null, [this, c]);
			}
		}
		
		if (autoUnderline) {
			foreach (var v in parentMenu.Items) {
				if (v is MenuItem m && m.Header is string s && s.Length > 0 && !_FindUnderlined(s, out _)) {
					int i = 0;
					for (; i < s.Length; i++) {
						char ch = s[i]; if (!char.IsLetterOrDigit(ch)) continue;
						ch = char.ToLower(ch);
						if (!au.Contains(ch)) { au.Add(ch); break; }
					}
					if (i == s.Length) i = 0;
					m.Header = s.Insert(i, "_");
				}
			}
		}
		
		static bool _FindUnderlined(string s, out char u) {
			u = default;
			int i = 0;
			g1: i = s.IndexOf('_', i) + 1;
			if (i == 0 || i == s.Length) return false;
			u = s[i++];
			if (u == '_') goto g1;
			return true;
		}
	}
	
	/// <summary>
	/// Gets a <b>Command</b> by name.
	/// </summary>
	/// <param name="command">Method name, for example "Select_all". Or nested type name if it's a submenu-item.</param>
	/// <exception cref="KeyNotFoundException"></exception>
	public Command this[string command] => _d[command];
	
	/// <summary>
	/// Tries to find a <b>Command</b> by name. Returns false if not found.
	/// Same as the indexer, but does not throw exception when not found.
	/// </summary>
	/// <param name="command">Method name, for example "Select_all". Or nested type name if it's a submenu-item.</param>
	/// <param name="c"></param>
	public bool TryFind(string command, out Command c) => _d.TryGetValue(command, out c);
	
	/// <summary>
	/// Adds to <i>target</i>'s <b>InputBindings</b> all keys etc where <b>CommandAttribute.target</b> == <i>name</i>.
	/// </summary>
	/// <param name="target"></param>
	/// <param name="name"></param>
	public void BindKeysTarget(UIElement target, string name) {
		//print.it($"---- {name} = {target}");
		foreach (var c in _d.Values) {
			var ca = c.Attribute;
			var keys = c.Keys;
			if (!keys.NE() && ca.target == name) {
				//print.it(c, keys);
				int i = keys.Find(", ");
				if (i < 0) _Add(keys); else foreach (var v in keys.Split(", ")) _Add(v);
				void _Add(string s) {
					if (!Au.keys.more.parseHotkeyString(s, out var mod, out var key, out var mouse)) {
						c.CustomizingError("invalid keys: " + s);
						return;
					}
					if (key != default) target.InputBindings.Add(new KeyBinding(c, key, mod));
					else if (target is System.Windows.Interop.HwndHost) c.CustomizingError(s + ": mouse shortcuts don't work in the target control");
					else target.InputBindings.Add(new MouseBinding(c, new MouseGesture(mouse, mod)));
					
					//FUTURE: support mouse shortcuts in HwndHost
					//if (target is System.Windows.Interop.HwndHost hh) {
					//	hh.MessageHook += _Hh_MessageHook;
					//	//or use native mouse hook
					//} else {
					//	target.InputBindings.Add(new MouseBinding(this, new MouseGesture(mouse, mod)));
					//}
				}
				var mi = c.MenuItem;
				var s = mi.InputGestureText;
				if (s.NE()) s = keys; else s = s + ", " + keys;
				mi.InputGestureText = s;
			}
		}
		
		//let global key bindings work in any window of this thread, not only when target (main window) is active. Never mind mouse bindings.
		if (name == "") {
			var a = target.InputBindings.OfType<KeyBinding>().ToArray();
			if (a.Length > 0) {
				EventManager.RegisterClassHandler(typeof(Window), UIElement.KeyDownEvent, new KeyEventHandler(_KeyDown));
				//InputManager.Current.PreProcessInput += _App_PreProcessInput; //works too, but more events
				
				void _KeyDown(object source, KeyEventArgs e) {
					if (!process.IsLaMainThread_) return;

					//perf.first();
					if (e.Handled) return;
					var k = e.Key; if (k == Key.System) k = e.SystemKey;
					if (k is Key.LeftCtrl or Key.LeftShift or Key.LeftAlt or Key.RightCtrl or Key.RightShift or Key.RightAlt or Key.LWin or Key.RWin or Key.DeadCharProcessed or Key.ImeProcessed) return;
					//print.it(k);
					ModifierKeys mod = 0; bool haveMod = false;
					foreach (var kb in a) {
						//print.it(kb.Command);
						if (kb.Key != k) continue;
						if (!haveMod) { haveMod = true; mod = Keyboard.Modifiers; }
						if (kb.Modifiers != mod) continue;
						var c = kb.Command; var cp = kb.CommandParameter;
						if (c.CanExecute(cp)) c.Execute(cp);
						e.Handled = true;
						break;
						//note: execute even if main window disabled. Maybe the command works in current window. Or maybe user wants to save (Ctrl+S).
					}
					//perf.nw(); //fast
				}
				
				//void _PreProcessInput(object sender, PreProcessInputEventArgs e) {
				//	if (e.Canceled) return;
				//	var re = e.StagingItem.Input.RoutedEvent;
				//	if (re == Keyboard.KeyDownEvent && e.StagingItem.Input is KeyEventArgs ke) {
				//		var k = ke.Key; if (k == Key.System) k = ke.SystemKey;
				//		if (k is Key.LeftCtrl or Key.LeftShift or Key.LeftAlt or Key.RightCtrl or Key.RightShift or Key.RightAlt or Key.LWin or Key.RWin or Key.DeadCharProcessed or Key.ImeProcessed) return;
				//		print.it(k);
				//	//} else { //no mouse events in hwndhosted control. It's ok, don't need global mouse shortcuts. Normal WPF bindings don't work too.
				//	//	print.it(re);
				//	}
				//}
			}
		}
	}
	
	public string DefaultFile { get; private set; }
	public string UserFile { get; private set; }
	
	/// <summary>
	/// Adds toolbar buttons specified in <i>xmlFileCustomized</i> and <i>xmlFileDefault</i>.
	/// Applies customizations specified there.
	/// </summary>
	/// <param name="xmlFileDefault">XML file containing default toolbar buttons. See Default\Commands.xml in editor project.</param>
	/// <param name="xmlFileCustomized">XML file containing user-modified commands and toolbar buttons. Can be null. The file can exist or not.</param>
	/// <param name="toolbars">Empty toolbars where to add buttons. XML tag = <b>Name</b> property.</param>
	public void InitToolbarsAndCustomize(string xmlFileDefault, string xmlFileCustomized, ToolBar[] toolbars) {
		DefaultFile = xmlFileDefault;
		UserFile = xmlFileCustomized;
		
		var a = LoadFiles(); if (a == null) return;
		
		foreach (var x in a) {
			ToolBar tb = null;
			var tbname = x.Name.LocalName;
			if (tbname != "menu") {
				tb = toolbars.FirstOrDefault(o => o.Name == tbname);
				if (tb == null) { Debug_.Print("Unknown toolbar " + tbname); continue; }
			}
			
			foreach (var v in x.Elements()) {
				if (_d.TryGetValue(v.Name.LocalName, out var c)) c.Customize_(v, tb);
			}
		}
		
	}
	
	/// <summary>
	/// Loads and merges default and customized commands files.
	/// </summary>
	public XElement[] LoadFiles() {
		static XElement[] _LoadFile(string file) {
			try { return XmlUtil.LoadElem(file).Elements().ToArray(); }
			catch (Exception ex) { print.it($"<>Failed to load file <explore>{file}<>. <_>{ex.ToStringWithoutStack()}</_>"); return null; }
		}
		
		var a = _LoadFile(DefaultFile); if (a == null) return null;
		var ac = UserFile != null && filesystem.exists(UserFile, true).File ? _LoadFile(UserFile) : null;
		
		if (ac != null) { //replace a elements with elements that exist in ac. If some toolbar does not exist there, use default.
			for (int i = 0; i < a.Length; i++) {
				var name = a[i].Name;
				foreach (var x in ac) if (x.Name == name && x.HasElements) { _AddMissingButtons(a[i], x); a[i] = x; break; }
			}
			
			void _AddMissingButtons(XElement xDef, XElement xUser) {
				if (xUser.Name.LocalName == "menu") return;
				foreach (var v in xDef.Elements().Except(xUser.Elements(), s_xmlNameComparer)) {
					//rejected: hide new buttons to avoid pushing some old buttons to the overflow if the toolbar size cannot grow.
					//	Then new and probably important features would be used rarely and/or inconveniently.
					//	Instead hide just duplicates, eg when the new button actually is an old button moved to this toolbar.
					//v.SetAttributeValue("hide", "always");
					foreach (var tb in ac) if (tb != xUser && tb.Elements(v.Name).Any()) { v.SetAttributeValue("hide", "always"); break; }
					
					if (v.PreviousNode is XElement xdPrev && xUser.Element(xdPrev.Name) is { } xuPrev) xuPrev.AddAfterSelf(v); //insert in default place
					else xUser.Add(v); //add to the end
				}
			}
		}
		
		return a;
	}
	
	//currently not used.
	//public void AddExtensionMenus(Type commands, MenuItem parentMenu = null, bool autoUnderline = true) {
	//	ItemsControl pa = parentMenu ?? _menubar as ItemsControl;
	//	_extensions ??= new();
	//	if (_extensions.Remove(commands.Name, out var t)) {
	//		foreach (var v in t.menus) pa.Items.Remove(v);
	//		foreach (var v in t.commands) _d.Remove(v);
	//	}
	//	int n = pa.Items.Count;
	//	List<string> added = new();
	//	_CreateMenu(commands, pa, autoUnderline, null, added);
	//	_extensions.Add(commands.Name, (pa.Items.OfType<object>().Skip(n).ToArray(), added));
	//}
	//Dictionary<string, (object[] menus, List<string> commands)> _extensions;
	////_extensions used to support updating the same extension. Remove the code if don't need.
}


================================================
FILE: Au.Controls/KPanels/FlexStackPanel.cs
================================================
// Copyright (c) 2013 xmetropol.
// This code is distributed under the Microsoft Public License (Ms-PL).
// All rights reserved.

//https://www.codeproject.com/Articles/598123/WPF-Flexible-StackPanel

using System.Windows;
using System.Windows.Controls;
using System.Windows.Media;

namespace Au.Controls;

public enum FlexStretchDirection {
	DownOnly,
	UpOnly,
	Both,
	None,
}

public class FlexStackPanel : Panel {
	#region Static Fields
	
	private const double Tolerance = 0.001;
	
	public static readonly DependencyProperty OrientationProperty = DependencyProperty.Register
	  ("Orientation", typeof(Orientation), typeof(FlexStackPanel),
		  new FrameworkPropertyMetadata(Orientation.Horizontal, FrameworkPropertyMetadataOptions.AffectsMeasure, OnOrientationChanged));
	
	public static readonly DependencyProperty StretchDirectionProperty = DependencyProperty.Register
	  ("StretchDirection", typeof(FlexStretchDirection), typeof(FlexStackPanel),
		 new FrameworkPropertyMetadata(default(FlexStretchDirection), FrameworkPropertyMetadataOptions.AffectsMeasure));
	
	public static readonly DependencyPropertyKey HasOverflowedChildrenPropertyKey = DependencyProperty.RegisterReadOnly
	  ("HasOverflowedChildren", typeof(bool), typeof(FlexStackPanel), new PropertyMetadata(default(bool)));
	
	public static readonly DependencyProperty HasOverflowedChildrenProperty = HasOverflowedChildrenPropertyKey.DependencyProperty;
	
	public static readonly DependencyProperty MinSlotSizeProperty = DependencyProperty.RegisterAttached
	  ("MinSlotSize", typeof(double?), typeof(FlexStackPanel),
		 new FrameworkPropertyMetadata(default(double?), FrameworkPropertyMetadataOptions.AffectsParentMeasure));
	
	public static readonly DependencyProperty MaxSlotSizeProperty = DependencyProperty.RegisterAttached
	  ("MaxSlotSize", typeof(double?), typeof(FlexStackPanel),
		 new FrameworkPropertyMetadata(default(double?), FrameworkPropertyMetadataOptions.AffectsParentMeasure));
	
	private static readonly DependencyPropertyKey IsOverflowedPropertyKey = DependencyProperty.RegisterAttachedReadOnly
	  ("IsOverflowed", typeof(bool), typeof(FlexStackPanel), new PropertyMetadata(default(bool)));
	
	public static readonly DependencyProperty IsOverflowedProperty = IsOverflowedPropertyKey.DependencyProperty;
	
	public static readonly DependencyProperty MeasureToSlotProperty = DependencyProperty.Register
	  ("MeasureToSlot", typeof(bool), typeof(FlexStackPanel), new FrameworkPropertyMetadata(true, FrameworkPropertyMetadataOptions.AffectsMeasure));
	
	public static readonly DependencyProperty ShrinkOnOverflowProperty = DependencyProperty.RegisterAttached
	  ("ShrinkOnOverflow", typeof(bool), typeof(FlexStackPanel), new FrameworkPropertyMetadata(default(bool), FrameworkPropertyMetadataOptions.AffectsMeasure, OnAffectMeasurePropertyChanged));
	
	public static readonly DependencyProperty IgnoreMinConstraintsProperty = DependencyProperty.Register
	  ("IgnoreMinConstraints", typeof(bool), typeof(FlexStackPanel), new FrameworkPropertyMetadata(default(bool), FrameworkPropertyMetadataOptions.AffectsMeasure));
	
	public static readonly DependencyProperty IgnoreMaxConstraintsProperty = DependencyProperty.Register
	  ("IgnoreMaxConstraints", typeof(bool), typeof(FlexStackPanel), new FrameworkPropertyMetadata(default(bool), FrameworkPropertyMetadataOptions.AffectsMeasure));
	
	#endregion
	
	#region Fields
	
	private readonly Dictionary<UIElement, Size> childToConstraint = new Dictionary<UIElement, Size>();
	private bool isMeasureDirty;
	private bool isMeasureOverrideInProgress;
	private bool isHorizontal = true;
	private List<UIElement> orderedSequence;
	private Slot[] slots;
	
	#endregion
	
	#region Ctors
	
	static FlexStackPanel() {
		DefaultStyleKeyProperty.OverrideMetadata
		  (typeof(FlexStackPanel),
		   new FrameworkPropertyMetadata(typeof(FlexStackPanel)));
	}
	
	#endregion
	
	#region Properties
	
	protected override bool HasLogicalOrientation {
		get { return true; }
	}
	
	public bool HasOverflowedChildren {
		get { return (bool)GetValue(HasOverflowedChildrenProperty); }
		private set { SetValue(HasOverflowedChildrenPropertyKey, value); }
	}
	
	public bool IgnoreMaxConstraints {
		get { return (bool)GetValue(IgnoreMaxConstraintsProperty); }
		set { SetValue(IgnoreMaxConstraintsProperty, value); }
	}
	
	public bool IgnoreMinConstraints {
		get { return (bool)GetValue(IgnoreMinConstraintsProperty); }
		set { SetValue(IgnoreMinConstraintsProperty, value); }
	}
	
	protected override Orientation LogicalOrientation {
		get { return Orientation; }
	}
	
	public bool MeasureToSlot {
		get { return (bool)GetValue(MeasureToSlotProperty); }
		set { SetValue(MeasureToSlotProperty, value); }
	}
	
	public Orientation Orientation {
		get { return (Orientation)GetValue(OrientationProperty); }
		set { SetValue(OrientationProperty, value); }
	}
	
	public FlexStretchDirection StretchDirection {
		get { return (FlexStretchDirection)GetValue(StretchDirectionProperty); }
		set { SetValue(StretchDirectionProperty, value); }
	}
	
	#endregion
	
	#region Methods
	
	public static bool GetIsOverflowed(UIElement element) {
		return (bool)element.GetValue(IsOverflowedProperty);
	}
	
	public static double? GetMaxSlotSize(UIElement element) {
		return (double?)element.GetValue(MaxSlotSizeProperty);
	}
	
	public static double? GetMinSlotSize(UIElement element) {
		return (double?)element.GetValue(MinSlotSizeProperty);
	}
	
	public static bool GetShrinkOnOverflow(UIElement element) {
		return (bool)element.GetValue(ShrinkOnOverflowProperty);
	}
	
	public static void SetMaxSlotSize(UIElement element, double? value) {
		element.SetValue(MaxSlotSizeProperty, value);
	}
	
	public static void SetMinSlotSize(UIElement element, double? value) {
		element.SetValue(MinSlotSizeProperty, value);
	}
	
	public static void SetShrinkOnOverflow(UIElement element, bool value) {
		element.SetValue(ShrinkOnOverflowProperty, value);
	}
	
	protected override Size ArrangeOverride(Size finalSize) {
		var size = new Size(isHorizontal ? 0 : finalSize.Width, !isHorizontal ? 0 : finalSize.Height);
		
		var childrenCount = Children.Count;
		
		var rc = new Rect();
		for (var index = 0; index < childrenCount; index++) {
			var child = orderedSequence[index];
			if (GetIsOverflowed(child)) {
				child.Arrange(new Rect());
				continue;
			}
			
			var slotVal = slots[index].Val;
			if (isHorizontal) {
				rc.Width = double.IsInfinity(slotVal) ? child.DesiredSize.Width : slotVal;
				rc.Height = Math.Max(finalSize.Height, child.DesiredSize.Height);
				size.Width += rc.Width;
				size.Height = Math.Max(size.Height, rc.Height);
				child.Arrange(rc);
				rc.X += rc.Width;
			} else {
				rc.Width = Math.Max(finalSize.Width, child.DesiredSize.Width);
				rc.Height = double.IsInfinity(slotVal) ? child.DesiredSize.Height : slotVal;
				size.Width = Math.Max(size.Width, rc.Width);
				size.Height += rc.Height;
				child.Arrange(rc);
				rc.Y += rc.Height;
			}
		}
		
		return new Size(Math.Max(finalSize.Width, size.Width), Math.Max(finalSize.Height, size.Height));
	}
	
	protected override Size MeasureOverride(Size availableSize) {
		try {
			isMeasureOverrideInProgress = true;
			
			var ignoreMinConstraints = IgnoreMinConstraints;
			var ignoreMaxConstraints = IgnoreMaxConstraints;
			
			for (var i = 0; i < 3; i++) {
				isMeasureDirty = false;
				
				var childrenDesiredSize = new Size();
				
				var childrenCount = Children.Count;
				
				if (childrenCount == 0)
					return childrenDesiredSize;
				
				var childConstraint = GetChildrenConstraint(availableSize);
				var uniSize = GetUniformSize(availableSize);
				
				slots = new Slot[childrenCount];
				
				orderedSequence = Children.Cast<UIElement>().ToList();
				
				for (var index = 0; index < childrenCount; index++) {
					if (isMeasureDirty)
						break;
					
					var child = orderedSequence[index];
					var minLength = (ignoreMinConstraints ? (double?)0.0 : null) ?? GetMinSlotSize(child);
					var maxLength = (ignoreMaxConstraints ? (double?)0.0 : null) ?? GetMaxSlotSize(child);
					
					var frameworkChild = child as FrameworkElement;
					if (frameworkChild != null) {
						var margin = frameworkChild.Margin;
						minLength = minLength ?? (isHorizontal ? frameworkChild.MinWidth : frameworkChild.MinHeight);
						maxLength = maxLength ?? (isHorizontal ? frameworkChild.MaxWidth + margin.Width() : frameworkChild.MaxHeight + margin.Height());
					}
					
					minLength = minLength ?? 0.0;
					maxLength = maxLength ?? double.PositiveInfinity;
					
					MeasureChild(child, childConstraint);
					
					if (isHorizontal) {
						childrenDesiredSize.Width += child.DesiredSize.Width;
						slots[index] = new Slot(minLength.Value, maxLength.Value, StretchDirection == FlexStretchDirection.Both ? uniSize.Width : child.DesiredSize.Width);
						childrenDesiredSize.Height = Math.Max(childrenDesiredSize.Height, child.DesiredSize.Height);
					} else {
						childrenDesiredSize.Height += child.DesiredSize.Height;
						slots[index] = new Slot(minLength.Value, maxLength.Value, StretchDirection == FlexStretchDirection.Both ? uniSize.Height : child.DesiredSize.Height);
						childrenDesiredSize.Width = Math.Max(childrenDesiredSize.Width, child.DesiredSize.Width);
					}
				}
				
				if (isMeasureDirty)
					continue;
				
				var current = slots.Sum(s => s.Val);
				var target = GetSizePart(availableSize);
				
				var finalSize = new Size
				  (Math.Min(availableSize.Width, isHorizontal ? current : childrenDesiredSize.Width),
				   Math.Min(availableSize.Height, isHorizontal ? childrenDesiredSize.Height : current));
				
				if (double.IsInfinity(target))
					return finalSize;
				
				RecalcSlots(current, target);
				
				// Current length is greater than available and we have no possibility to stretch down -> mark elements as overflow
				current = 0.0;
				for (var index = 0; index < childrenCount; index++) {
					var child = orderedSequence[index];
					
					var slot = slots[index];
					
					if (GetShrinkOnOverflow(child) && IsGreater(current + slot.Val, target, Tolerance) && IsGreater(target, current, Tolerance)) {
						var rest = IsGreater(target, current, Tolerance) ? target - current : 0.0;
						if (IsGreater(rest, slot.Min, Tolerance))
							slot.Val = rest;
					}
					
					current += slot.Val;
					SetIsOverflowed(child, IsGreater(current, target, Tolerance));
				}
				
				HasOverflowedChildren = current > target;
				
				if (MeasureToSlot)
					RemeasureChildren(finalSize);
				
				finalSize = new Size
				  (Math.Min(availableSize.Width, isHorizontal ? target : childrenDesiredSize.Width),
				   Math.Min(availableSize.Height, isHorizontal ? childrenDesiredSize.Height : target));
				
				if (isMeasureDirty)
					continue;
				
				return finalSize;
			}
		}
		finally {
			isMeasureOverrideInProgress = false;
		}
		return new Size();
	}
	
	protected override void OnVisualChildrenChanged(DependencyObject visualAdded, DependencyObject visualRemoved) {
		base.OnVisualChildrenChanged(visualAdded, visualRemoved);
		
		var removedUIElement = visualRemoved as UIElement;
		
		if (removedUIElement != null)
			childToConstraint.Remove(removedUIElement);
	}
	
	private static void ExpandSlots(IEnumerable<Slot> slots, double target) {
		var sortedSlots = slots.OrderBy(v => v.Val).ToList();
		var maxValidTarget = sortedSlots.Sum(s => s.Max);
		if (maxValidTarget < target) {
			foreach (var slot in sortedSlots)
				slot.Val = slot.Max;
			return;
		}
		do {
			var tmpTarget = target;
			for (var iSlot = sortedSlots.Count - 1; iSlot >= 0; iSlot--) {
				var slot = sortedSlots[iSlot];
				if (slot.Val * (iSlot + 1) <= tmpTarget) {
					var avg = tmpTarget / (iSlot + 1);
					var success = true;
					for (var jSlot = iSlot; jSlot >= 0; jSlot--) {
						var tslot = sortedSlots[jSlot];
						tslot.Val = Math.Min(tslot.Max, avg);
						
						// Max constraint skip success expand on this iteration
						if (Math.Abs(avg - tslot.Val) <= Tolerance) continue;
						
						target -= tslot.Val;
						success = false;
						sortedSlots.RemoveAt(jSlot);
					}
					if (success)
						return;
					
					break;
				}
				tmpTarget -= slot.Val;
			}
		} while (sortedSlots.Count > 0);
	}
	
	private Size GetChildrenConstraint(Size availableSize) {
		return new Size
		  (isHorizontal ? double.PositiveInfinity : availableSize.Width,
		   !isHorizontal ? double.PositiveInfinity : availableSize.Height);
	}
	
	private double GetSizePart(Size size) {
		return isHorizontal ? size.Width : size.Height;
	}
	
	private Size GetUniformSize(Size availableSize) {
		var childrenCount = Children.Count;
		if (childrenCount == 0)
			return new Size();
		
		return new Size
		  (isHorizontal ? availableSize.Width / childrenCount : availableSize.Width,
		   !isHorizontal ? availableSize.Height / childrenCount : availableSize.Height);
	}
	
	private static bool IsGreater(double a, double b, double tolerance) {
		return a - b > tolerance;
	}
	
	private void MeasureChild(UIElement child, Size childConstraint) {
		Size lastConstraint;
		if ((child.IsMeasureValid && childToConstraint.TryGetValue(child, out lastConstraint) && lastConstraint.Equals(childConstraint))) return;
		
		child.Measure(childConstraint);
		childToConstraint[child] = childConstraint;
	}
	
	private void OnAffectMeasureChanged() {
		if (isMeasureOverrideInProgress)
			isMeasureDirty = true;
	}
	
	private static void OnAffectMeasurePropertyChanged(DependencyObject dependencyObject, DependencyPropertyChangedEventArgs dependencyPropertyChangedEventArgs) {
		var flexStackPanel = VisualTreeHelper.GetParent(dependencyObject) as FlexStackPanel;
		if (flexStackPanel != null)
			flexStackPanel.OnAffectMeasureChanged();
	}
	
	private static void OnOrientationChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) {
		var panel = (FlexStackPanel)d;
		panel.isHorizontal = panel.Orientation == Orientation.Horizontal;
	}
	
	private void RecalcSlots(double current, double target) {
		var shouldShrink = IsGreater(current, target, Tolerance) && (StretchDirection == FlexStretchDirection.DownOnly || StretchDirection == FlexStretchDirection.Both);
		var shouldExpand = IsGreater(target, current, Tolerance) && (StretchDirection == FlexStretchDirection.UpOnly || StretchDirection == FlexStretchDirection.Both);
		
		if (shouldShrink)
			ShrinkSlots(slots, target);
		else if (shouldExpand)
			ExpandSlots(slots, target);
	}
	
	private void RemeasureChildren(Size availableSize) {
		var childrenCount = Children.Count;
		if (childrenCount == 0)
			return;
		
		var childConstraint = GetChildrenConstraint(availableSize);
		for (var index = 0; index < childrenCount; index++) {
			var child = orderedSequence[index];
			if (Math.Abs(GetSizePart(child.DesiredSize) - slots[index].Val) > Tolerance)
				MeasureChild(child, new Size(isHorizontal ? slots[index].Val : childConstraint.Width,
											!isHorizontal ? slots[index].Val : childConstraint.Height));
		}
	}
	
	private static void SetIsOverflowed(UIElement element, bool value) {
		element.SetValue(IsOverflowedPropertyKey, value);
	}
	
	private static void ShrinkSlots(IEnumerable<Slot> slots, double target) {
		var sortedSlots = slots.OrderBy(v => v.Val).ToList();
		var minValidTarget = sortedSlots.Sum(s => s.Min);
		if (minValidTarget > target) {
			foreach (var slot in sortedSlots)
				slot.Val = slot.Min;
			return;
		}
		do {
			var tmpTarget = target;
			for (var iSlot = 0; iSlot < sortedSlots.Count; iSlot++) {
				var slot = sortedSlots[iSlot];
				if (slot.Val * (sortedSlots.Count - iSlot) >= tmpTarget) {
					var avg = tmpTarget / (sortedSlots.Count - iSlot);
					var success = true;
					for (var jSlot = iSlot; jSlot < sortedSlots.Count; jSlot++) {
						var tslot = sortedSlots[jSlot];
						tslot.Val = Math.Max(tslot.Min, avg);
						
						// Min constraint skip success expand on this iteration
						if (Math.Abs(avg - tslot.Val) <= Tolerance) continue;
						
						target -= tslot.Val;
						success = false;
						sortedSlots.RemoveAt(jSlot);
						jSlot--;
					}
					if (success)
						return;
					
					break;
				}
				tmpTarget -= slot.Val;
			}
		} while (sortedSlots.Count > 0);
	}
	
	#endregion
	
	#region Nested type: Slot
	
	private class Slot {
		#region Fields
		
		public readonly double Max;
		public readonly double Min;
		public double Val;
		
		#endregion
		
		#region Ctors
		
		public Slot(double min, double max, double val) {
			Min = min;
			Max = max;
			Val = val;
			
			Val = Math.Max(min, val);
			Val = Math.Min(max, Val);
		}
		
		#endregion
	}
	
	#endregion
}

file static class MeasureUtil {
	public static double Height(this Thickness thickness) {
		return thickness.Top + thickness.Bottom;
	}
	
	public static double Width(this Thickness thickness) {
		return thickness.Left + thickness.Right;
	}
}


================================================
FILE: Au.Controls/KPanels/ILeaf.cs
================================================
using System.Windows;
using System.Windows.Controls;

namespace Au.Controls;

public partial class KPanels {
	/// <summary>
	/// Interface for a leaf item (panel, toolbar or document).
	/// </summary>
	public interface ILeaf {
		/// <summary>
		/// Gets or sets content of panel/toolbar/document.
		/// </summary>
		FrameworkElement Content { get; set; }
		
		/// <summary>
		/// true if visible, either floating or docked.
		/// The <c>get</c> function returns true even if inactive tab item. The <c>set</c> function makes tab item active.
		/// </summary>
		bool Visible { get; set; }
		
		/// <summary>
		/// true if floating and visible.
		/// false if docked or hidden.
		/// </summary>
		bool Floating { get; set; }
		
		/// <summary>
		/// If not null, clicking on the parent tab header does not change the current focus (if possible).
		/// The action is called if the currently focused element is in the tab control; it must set focus to some visible element or call <b>Keyboard.ClearFocus</b>.
		/// </summary>
		Action DontFocusTab { get; set; }
		
		
		Func<UIElement, bool> DontActivateFloating { get; set; }
		
		/// <summary>
		/// Adds new leaf item (panel, toolbar or document) before or after this.
		/// </summary>
		/// <param name="after"></param>
		/// <param name="type"></param>
		/// <param name="name"></param>
		/// <param name="canClose">Add "Close    M-click" item in context menu. It will fire <see cref="Closing"/> event and call <see cref="Delete"/> if not canceled.</param>
		/// <param name="isExtension">Save layout etc in file.</param>
		/// <returns>Interface of the new item.</returns>
		/// <exception cref="ArgumentException"><i>type</i> is not Panel/Toolbar/Document, or <i>name</i> is null, or <i>name</i> panel already exists.</exception>
		/// <remarks>
		/// Added items can be deleted with <see cref="Delete"/>.
		/// Add documents only by the document placeholder or by added documents. Don't add other nodes by documents.
		/// </remarks>
		ILeaf AddSibling(bool after, LeafType type, string name, bool canClose, bool isExtension);
		
		/// <summary>
		/// Deletes this leaf item added with <see cref="AddSibling"/>.
		/// </summary>
		/// <exception cref="InvalidOperationException">Added not with <b>AddSibling</b>.</exception>
		void Delete();
		
		/// <summary>
		/// Renames this document.
		/// </summary>
		void Rename(string name);
		
		/// <summary>
		/// Gets parent elements and index.
		/// </summary>
		ParentInfo Parent { get; }
		
		/// <summary>
		/// After hiding or showing this leaf item.
		/// </summary>
		event EventHandler<bool> VisibleChanged;
		
		/// <summary>
		/// After made floating or non-floating this leaf item.
		/// </summary>
		event EventHandler<bool> FloatingChanged;
		
		/// <summary>
		/// When user tries to close this leaf item.
		/// Only if added with <see cref="AddSibling"/> with <i>canClose</i> true.
		/// </summary>
		event System.ComponentModel.CancelEventHandler Closing;
		
		///// <summary>
		///// When opening context menu of this leaf item.
		///// You can add menu items. All default items are already added.
		///// </summary>
		//event EventHandler<popupMenu> ContextMenuOpening;
		//FUTURE: reenable this if useful when ContextMenu_ will be public
		
		/// <summary>
		/// When this tab item selected (becomes the active item).
		/// </summary>
		event EventHandler TabSelected;
		
		/// <summary>
		/// When moved to other tab or stack.
		/// </summary>
		event EventHandler ParentChanged;
	}
	
	/// <summary>Leaf item type.</summary>
	public enum LeafType { None, Panel, Toolbar, Document }
	
	public struct ParentInfo {
		readonly DockPanel _panel;
		readonly FrameworkElement _elem;
		readonly int _index;
		
		internal ParentInfo(DockPanel panel, FrameworkElement elem, int index) {
			_panel = panel; _elem = elem; _index = index;
		}
		
		/// <summary>
		/// Gets <b>DockPanel</b> that contains or will contain <see cref="ILeaf.Content"/>.
		/// The first child is header, and is <b>TextBlock</b> or <b>Rectangle</b>. The second child is <b>Content</b> (if set) or none.
		/// </summary>
		public DockPanel Panel => _panel;
		
		/// <summary>
		/// Gets parent <b>Grid</b> if in stack, else null.
		/// </summary>
		public Grid Grid => _elem as Grid;
		
		/// <summary>
		/// Gets parent <b>TabControl</b> if in tab, else null.
		/// </summary>
		public TabControl TabControl => _elem as TabControl;
		
		/// <summary>
		/// Gets parent <b>TabItem</b> if in tab, else null.
		/// Its <b>Tag</b> is this <b>ILeaf</b>.
		/// </summary>
		public TabItem TabItem => TabControl?.Items[_index] as TabItem;
		
		/// <summary>
		/// Gets node index in parent node. If in tab, it is also tab item index.
		/// </summary>
		public int Index => _index;
	}
}


================================================
FILE: Au.Controls/KPanels/KPanels.cs
================================================
using System.Xml.Linq;
using System.Xml;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Media;

namespace Au.Controls;

/// <summary>
/// Creates and manages window layout like in Visual Studio.
/// Multiple docked movable/sizable/tabable/floatable/hidable/savable panels/toolbars/documents with splitters.
/// </summary>
/// <remarks>
/// Layout is defined in default XML file, then saved in other XML file. See Layout.xml in Au.Editor project.
/// If new app version adds/removes/renames panels etc, this class automatically updates the saved layout.
/// 
/// Let your window's ctor:
/// - call <see cref="Load"/>;
/// - set content of all leaf items (panels, toolbars, document placeholder) like <c>_panels["Files"].Content = new TreeView();</c>;
/// - set <see cref="Container"/> like <c>_panels.Container = g => this.Content = g;</c>. The action is called immediately and also may be called later if need to create new root element when moving a panel etc.
/// If want to save user-customized layout, call <see cref="Save"/> when closing window or at any time before it.
/// </remarks>
public partial class KPanels {
	readonly Dictionary<string, _Node> _dictLeaf = new();
	readonly Dictionary<string, _Node> _dictUserDoc = new();
	_Node _rootStack;
	string _xmlFile;
	bool _loaded;
	
	/// <summary>
	/// Loads layout from XML file.
	/// </summary>
	/// <param name="xmlFileDefault">
	/// XML file containing default layout. See Default\Layout.xml in editor project.
	/// If starts with '&lt;', loads from XML string instead.
	/// </param>
	/// <param name="xmlFileCustomized">XML file containing user-modified layout. It will be created or updated by <see cref="Save"/>. If null, will not save.</param>
	public void Load(string xmlFileDefault, string xmlFileCustomized) {
		if (_loaded) throw new InvalidOperationException();
		_loaded = true;
		_xmlFile = xmlFileCustomized;
		
		//At first try to load xmlFileCustomized. If it does not exist or is invalid, load xmlFileDefault.
		string xmlFile = xmlFileCustomized; bool useDefaultXML = xmlFileCustomized == null;
		gRetry:
		if (useDefaultXML) xmlFile = xmlFileDefault;
		else if (useDefaultXML = !filesystem.exists(xmlFile).File) goto gRetry;
		
		try {
			var x = XmlUtil.LoadElem(xmlFile);
			if (!useDefaultXML) _AutoUpdateXml(x, xmlFileDefault);
			new _Node(this, x); //creates all and sets _rootStack
		}
		catch (Exception e) when (!Debugger.IsAttached) {
			var sErr = $"Failed to load file '{xmlFile}'.\r\n\t{e.ToStringWithoutStack()}";
			if (useDefaultXML) {
				_xmlFile = null;
				dialog.showError("Cannot load window layout from XML file.",
					$"{sErr}\r\n\r\nReinstall the application.",
					expandedText: e.StackTrace);
				Environment.Exit(1);
			} else {
				print.warning(sErr, -1);
			}
			_dictLeaf.Clear(); _rootStack = null;
			useDefaultXML = true; goto gRetry;
		}
	}
	
	/// <summary>
	/// Saves layout to XML file <i>xmlFileCustomized</i> specified when calling <see cref="Load"/>.
	/// Can be called at any time. When closing window, should be called in OnClosing override after calling base.OnClosing.
	/// Fast. Saves only if changed. Can be called eg every 30 s.
	/// Does nothing if <i>xmlFileCustomized</i> was null.
	/// </summary>
	public void Save() {
		if (_xmlFile == null) return;
		try {
			s_xws ??= new XmlWriterSettings() {
				OmitXmlDeclaration = true,
				Indent = true,
				IndentChars = "\t"
			};
			var b = new StringBuilder(2000);
			using (var x = XmlWriter.Create(b, s_xws)) { //not `using var...;`
				x.WriteStartDocument();
				_rootStack.Save(x);
			}
			var s1 = b.ToString();
			try { _savedXML ??= filesystem.loadText(_xmlFile); } catch { }
			if (s1 != _savedXML) {
				filesystem.saveText(_xmlFile, s1);
				_savedXML = s1;
			}
		}
		catch { }
	}
	static XmlWriterSettings s_xws;
	string _savedXML;
	
	void _AutoUpdateXml(XElement rootStack, string xmlFileDefault) {
		var defRootStack = XmlUtil.LoadElem(xmlFileDefault);
		var eOld = rootStack.Descendants("panel").Concat(rootStack.Descendants("toolbar"))/*.Concat(rootStack.Descendants("document"))*/; //same speed as with .Where(cached delegate)
		var eNew = defRootStack.Descendants("panel").Concat(defRootStack.Descendants("toolbar"))/*.Concat(defRootStack.Descendants("document"))*/;
		var cmp = new _XmlNameAttrComparer();
		var added = eNew.Except(eOld, cmp);
		var removed = eOld.Except(eNew, cmp);
		if (removed.Any()) {
			foreach (var x in removed.ToArray()) {
				if (x.HasAttr("ext")) continue;
				_Remove(x);
				print.it($"Info: {x.Name} {x.Attr("name")} has been removed in this app version.");
			}
			//removes x and ancestor stacks/tabs that would then have <= 1 child
			static void _Remove(XElement x) {
				var pa = x.Parent;
				x.Remove();
				var a = pa.Elements();
				int n = a.Count();
				if (n > 1) return;
				if (n == 1) {
					var f = a.First();
					f.SetAttributeValue("z", pa.Attr("z"));
					f.SetAttributeValue("s", pa.Attr("s"));
					f.Remove();
					pa.AddAfterSelf(f);
				}
				_Remove(pa);
			}
		}
		if (added.Any()) {
			foreach (var x in added) {
				//try to add near the default place
				string sAppend = null;
				//print.qm2.use=true;
				//print.clear();
				var byDef = x.Parent.Elements().LastOrDefault(o => o != x && o.Name.LocalName is not ("stack" or "tab"));
				if (byDef != null && rootStack.Desc(byDef.Name, "name", byDef.Attribute("name").Value) is { } by) {
					bool inTab = x.Parent.Name == "tab";
					if (inTab && by.Parent.Name != "tab") {
						var tab = new XElement("tab", x);
						if (by.Attribute("z") is { } a1) { a1.Remove(); tab.SetAttributeValue("z", a1.Value); }
						if (by.Attribute("headerAt") is { } a2) tab.SetAttributeValue("headerAt", a2.Value);
						by.AddAfterSelf(tab);
						by.Remove();
						tab.AddFirst(by);
					} else {
						if (x.Parent.Name == "stack" && byDef.Parent.Name == "stack" && x.Parent.Attr("o") != by.Parent.Attr("o") && x.Parent.Elements().Count() == 2) {
							by.AddAfterSelf(x.Parent);
							by.Remove();
						} else {
							if (!inTab) x.SetAttributeValue("z", 50); else x.SetAttributeValue("z", null);
							by.AddAfterSelf(x);
						}
					}
					string s1 = by.Name.LocalName; if (s1 == "document") s1 = "panel";
					sAppend = $"next to the {by.Attr("name")} {s1}. You can move it to a better place (right-click...){(inTab ? "" : " or/and resize")}.";
				} else {
					x.SetAttributeValue("z", 50); //note: set even if was no "z", because maybe was in a tab
					rootStack.Add(x);
					sAppend = "at the bottom of the window. Right-click its header and move it to a better place.";
				}
				string sAppend2 = x.Attr(out int state, "state") && 0 != (state & 1) ? "\r\n\tNow it's hidden. To show, right-click any panel header." : null;
				print.it($"<>New {x.Name} in this app version: <b>{x.Attr("name")}<>.\r\n\tIt's {sAppend}{sAppend2}");
			}
		}
		//print.it(rootStack);
	}
	
	///// <summary>
	///// Deletes the user's saved layout file. Then next time will use the default file.
	///// </summary>
	//public void DeleteSavedFile() {
	//	filesystem.delete(_xmlFile);
	//}
	
	/// <summary>
	/// Action that adds the root node (Grid) to a container (for example Window), like <c>_panels.Container = g => this.Content = g;</c>.
	/// The action is called immediately and also may be called later if need to create new root element when moving a panel etc.
	/// </summary>
	public Action<Grid> Container {
		get => _setContainer;
		set {
			_setContainer = value;
			var e = _rootStack.Elem as Grid;
			if (e.Parent == null) _setContainer(e);
		}
	}
	Action<Grid> _setContainer;
	
	//public Grid RootElem => _rootStack.Elem as Grid;
	
	/// <summary>
	/// Gets interface of a leaf item (panel, toolbar or document).
	/// </summary>
	/// <value>null if not found.</value>
	/// <param name="name"></param>
	/// <param name="userDocument">It is a document (not panel/toolbar) added with <see cref="ILeaf.AddSibling"/>. User documents are in a separate dictionary, to avoid name conflicts.</param>
	public ILeaf this[string name, bool userDocument = false] {
		get {
			var d = userDocument ? _dictUserDoc : _dictLeaf;
			d.TryGetValue(name, out var v);
			return v;
		}
	}
	
	/// <summary>
	/// Gets interface of container leaf item (panel, toolbar or document).
	/// </summary>
	/// <param name="e">Leaf's <b>Content</b> or any descendant.</param>
	/// <exception cref="NotFoundException"></exception>
	public ILeaf this[DependencyObject e] {
		get {
			while (e != null) {
				if (e is _DockPanelWithBorder d && d.Tag is ILeaf f) return f;
				e = VisualTreeHelper.GetParent(e); //same with LogicalTreeHelper
			}
			throw new NotFoundException();
		}
	}
	
	public ILeaf AddNewExtension(bool toolbar, string name, ILeaf where = null, bool after = false) {
		if (name.NE()) throw new ArgumentException();
		if (where == null) {
			where = _rootStack.LastChild as ILeaf;
			after = true;
			print.it($"Info: added new {(toolbar ? "toolbar" : "panel")} {name}. It is at the bottom of the window. Right-click its header and move it to a better place.");
		}
		return where.AddSibling(after, toolbar ? LeafType.Toolbar : LeafType.Panel, name, canClose: false, isExtension: true);
	}
	
	//rejected. Rarely used. Can set in Container action.
	///// <summary>
	///// Background brush of the root grid.
	///// Set before <see cref="Load"/>.
	///// </summary>
	//public Brush Background {
	//	get => _gridBackground;
	//	set => _gridBackground = value;
	//}
	
	/// <summary>
	/// Background brush of panel/document header and tab strip. Default Brushes.LightSteelBlue.
	/// Set before <see cref="Load"/>.
	/// </summary>
	public Brush HeaderBrush { get; set; } = Brushes.LightSteelBlue;
	
	//rejected. Looks ugly when different color, unless white.
	///// <summary>
	///// Background brush of tab strip. Default Brushes.LightSteelBlue.
	///// Set before <see cref="Load"/>.
	///// </summary>
	//public Brush TabBrush { get; set; } = Brushes.LightSteelBlue;
	
	/// <summary>
	/// Background brush of splitters.
	/// Set before <see cref="Load"/>.
	/// </summary>
	public Brush SplitterBrush { get; set; }
	
	/// <summary>
	/// Border color of panels and documents.
	/// Set before <see cref="Load"/>.
	/// If not set, no borders will be added.
	/// </summary>
	public Brush BorderBrush { get; set; }
	
	/// <summary>
	/// Gets top-level window, for example to use as owner of menus/dialogs.
	/// Note: it may not be direct container of the root element.
	/// </summary>
	Window _ContainerWindow => _window ??= Window.GetWindow(_rootStack.Elem);
	Window _window;
	
	class _XmlNameAttrComparer : IEqualityComparer<XElement> {
		public bool Equals(XElement x, XElement y) => x.Attr("name") == y.Attr("name");
		public int GetHashCode(XElement obj) => obj.Attr("name").GetHashCode();
		//fast, same as with XName _name.
	}
}


================================================
FILE: Au.Controls/KPanels/_Floating.cs
================================================
using System.Windows;
using System.Windows.Controls;
using System.Windows.Controls.Primitives;
using System.Windows.Media;
using System.Windows.Interop;
using System.Windows.Input;

namespace Au.Controls;

public partial class KPanels {
	partial class _Node {
		class _Floating : Window {
			readonly _Node _node;
			readonly Window _owner;
			readonly bool _noActivate;
			
			public _Floating(_Node node, bool onDrag) {
				_node = node;
				_owner = _node._pm._ContainerWindow;
				_noActivate = _node._IsToolbarsNode || _node.DontActivateFloating != null;
				
				//workaround for: if a HwndHost-ed native control in this panel is focused, WPF may activate the floating panel and disable next mouse click
				if (Keyboard.FocusedElement == null) {
					var wFocus = Api.GetFocus();
					if (!wFocus.Is0 && wFocus.IsChildOf(_owner.Hwnd())) {
						if (null != _node.Elem.FindVisualDescendant(o => o is HwndHost h && h.Handle == wFocus.Handle)) _owner.Focus();
					}
				}
				
				var style = WS.THICKFRAME | WS.POPUP | WS.CLIPCHILDREN;
				if (_node._IsStack) style |= WS.CAPTION;
				bool unowned = _node._windowStyle.Has(_WindowStyle.Unowned);
				if (unowned) style |= WS.CAPTION | WS.MAXIMIZEBOX | WS.MINIMIZEBOX | WS.SYSMENU;
				var estyle = unowned ? WSE.APPWINDOW | WSE.WINDOWEDGE : /*WSE.TOOLWINDOW |*/ WSE.WINDOWEDGE; //note: don't use WS_EX_TOOLWINDOW, because of Win11 bug: no WM_DPICHANGED when screen DPI changes; tested workarounds don't work well.
				
				RECT rect = default;
				bool defaultRect = onDrag | (_node._floatSavedRect == null);
				if (defaultRect) {
					var c2 = _node._ParentIsTab ? _node.Parent._elem : _node._elem;
					if (c2.IsVisible) {
						rect = c2.RectInScreen();
						Dpi.AdjustWindowRectEx(c2, ref rect, style, estyle);
					} else {
						var p = mouse.xy;
						rect = (p.x - 10, p.y - 10, 200, 200);
					}
				}
				
				base.SourceInitialized += (_, _) => {
					var w = this.Hwnd();
					w.SetStyle(style);
					if (_noActivate) w.SetExStyle(WSE.NOACTIVATE, WSFlags.Add);
				};
				
				base.Title = script.name + " - " + _node.ToString();
				base.WindowStartupLocation = WindowStartupLocation.Manual;
				base.ShowActivated = false;
				if (!unowned) {
					if (!_node._windowStyle.Has(_WindowStyle.Topmost)) base.Owner = _owner;
					/*base.WindowStyle = WindowStyle.ToolWindow;*/
					base.ShowInTaskbar = false; //never mind: if false, WPF creates a "Hidden Window", probably as owner, even if owner specified
				}
				if (_node._windowStyle.Has(_WindowStyle.Topmost)) base.Topmost = true;
				
				if (defaultRect) this.SetRect(rect);
				else WndSavedRect.Restore(this, _node._floatSavedRect);
				
				_owner.Closing += _Owner_Closing;
				_owner.IsVisibleChanged += _Owner_IsVisibleChanged;
			}
			
			public void ShowIfOwnerVisible() {
				if (_owner.IsVisible) Show();
			}
			
			private void _Owner_IsVisibleChanged(object sender, DependencyPropertyChangedEventArgs e) {
				//never mind: no event if closed from outside.
				bool visible = (bool)e.NewValue;
				//print.it("owner visible", visible);
				if (visible) Show(); else Hide();
			}
			
			private void _Owner_Closing(object sender, CancelEventArgs e) {
				//print.it("owner closing", e.Cancel);
				if (!e.Cancel) this.Close();
			}
			
			protected override void OnClosing(CancelEventArgs e) {
				//print.it("closing", e.Cancel, _node._state);
				if (!e.Cancel) {
					_owner.IsVisibleChanged -= _Owner_IsVisibleChanged;
					Save();
					Content = null;
					_node._floatWindow = null;
				}
				base.OnClosing(e);
			}
			
			public void Save() {
				//print.it("save");
				_node._floatSavedRect = new WndSavedRect(this).ToString();
			}
			
			protected override void OnSourceInitialized(EventArgs e) {
				base.OnSourceInitialized(e);
				var hs = PresentationSource.FromVisual(this) as HwndSource;
				hs.AddHook(WndProc);
			}
			
			private IntPtr WndProc(IntPtr hwnd, int msg, IntPtr wParam, IntPtr lParam, ref bool handled) {
				var w = (wnd)hwnd;
				//WndUtil.PrintMsg(w, msg, wParam, lParam);
				switch (msg) {
				case Api.WM_MOUSEACTIVATE:
					bool no = Math2.LoWord(lParam) != Api.HTCLIENT;
					if (!no) {
						if (_noActivate) { //activate if clicked a focusable element
							var ie = Mouse.DirectlyOver;
							if (ie == null) { //native child control?
								if (_node.DontActivateFloating != null) {
									var c = wnd.fromMouse(WXYFlags.Raw);
									if (c != w && !c.Is0) {
										if (wnd.Internal_.ToWpfElement(c) is { } e) no = _node.DontActivateFloating(e);
									}
								}
							} else {
								no = true;
								for (var e = ie as UIElement; e != null && e != _node._elem; e = VisualTreeHelper.GetParent(e) as UIElement) {
									//print.it(e, e.Focusable);
									if (e.Focusable) {
										if (e is ButtonBase) {
											//e.Focusable = false;
											//Dispatcher.InvokeAsync(() => e.Focusable = true);
										} else {
											no = _node.DontActivateFloating?.Invoke(e) == true;
										}
										break;
									}
								}
							}
						} else if (!_node._IsStack) { //activate if clicked not panel header and not tab header
							FrameworkElement e;
							if (_node._IsTab) e = (_node._tab.tc.SelectedItem as TabItem)?.Content as FrameworkElement;
							else e = _node._leaf.content;
							no = e != null && !e.RectInScreen().Contains(mouse.xy);
						}
					}
					if (no) {
						//print.it("MA_NOACTIVATE");
						w.ZorderTop();
						handled = true;
						return (IntPtr)Api.MA_NOACTIVATE;
						//never mind: if clicked or dragged resizable border, on mouse up OS activates the window.
					}
					break;
				case Api.WM_CLOSE:
					if (w.IsMinimized) w.ShowNotMinimized(); //without this would be exception (why?)
					if (_node._state == _DockState.Float) { //closing not by _SetDockState
						handled = true;
						_node._SetDockState(0);
					}
					break;
				}
				
				return default;
			}
			
			//Currently supports only moving but not docking. Docking is implemented in _ContextMenu_Move+_MoveTo.
			public void Drag(POINT p) {
				
				//bool canDock = false;
				//_DockTarget target = null;
				var w = this.Hwnd();
				RECT r = w.Rect;
				POINT offs = (p.x - r.left, p.y - r.top);
				bool ok = WndUtil.DragLoop(w, MButtons.Left, d => {
					if (d.msg.message != Api.WM_MOUSEMOVE) return;
					
					p = mouse.xy;
					w.MoveL(p.x - offs.x, p.y - offs.y);
					
					//if (!canDock && keys.gui.isAlt) {
					//	canDock = true;
					//	//w.SetTransparency(true, 128);
					//	//_dockIndic = new _DockIndicator(_manager, this);
					//	//_dockIndic.Show(this);
					//}
					////if (canDock) _dockIndic.OnFloatMoved(_manager.PointToClient(p));
				});
				
				//if (canDock) {
				//	w.SetTransparency(false);
				//	_dockIndic.Close();
				//	if (ok) {
				//		target = _dockIndic.OnFloatDropped();
				//	}
				//	_dockIndic = null;
				//}
				
				//return target;
			}
			
			public void ChangeWindowStyle(_WindowStyle style) {
				bool on = _node._windowStyle.Has(style);
				var w = this.Hwnd();
				if (style == _WindowStyle.Topmost) {
					bool unowned = _node._windowStyle.Has(_WindowStyle.Unowned);
					if (on) {
						if (!unowned) base.Owner = null;
						w.ZorderTopmost();
					} else {
						w.ZorderNoTopmost();
						if (!unowned) base.Owner = _owner;
					}
				} else if (style == _WindowStyle.Unowned) {
					if (!on) w.ShowNotMinMax();
					bool topmost = _node._windowStyle.Has(_WindowStyle.Topmost);
					if (!topmost) base.Owner = on ? null : _owner; //or `WndUtil.SetOwnerWindow(w, on ? default : _owner.Hwnd());`
					w.SetExStyle(WSE.APPWINDOW, on ? WSFlags.Add : WSFlags.Remove); //w.SetExStyle(w.ExStyle & ~(WSE.TOOLWINDOW | WSE.APPWINDOW) | (on ? WSE.APPWINDOW : WSE.TOOLWINDOW));
					var ws = WS.CAPTION | WS.MAXIMIZEBOX | WS.MINIMIZEBOX | WS.SYSMENU;
					if (!on && _node._IsStack) ws &= ~WS.CAPTION;
					w.SetStyle(ws, on ? WSFlags.Add | WSFlags.UpdateNonclient : WSFlags.Remove | WSFlags.UpdateNonclient);
					base.ShowInTaskbar = on;
				}
			}
		}
		
		public Func<UIElement, bool> DontActivateFloating { get; set; }
	}
}


================================================
FILE: Au.Controls/KPanels/_Node.cs
================================================
using System.Xml.Linq;
using System.Xml;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Media;
using System.Windows.Shapes;

namespace Au.Controls;

public partial class KPanels {
	partial class _Node : TreeBase<_Node>, ILeaf {
		readonly KPanels _pm;
		readonly _StackFields _stack;
		readonly _TabFields _tab;
		readonly _LeafFields _leaf;
		readonly FrameworkElement _elem; //_stack.grid or _tab.tc or _leaf.panel
		GridSplitter2 _splitter; //splitter before this node in stack. null if in tab or first in stack
		readonly LeafType _leafType;
		int _index; //index in parent stack or tab. Grid row/column index is _index*2, because at _index*2-1 is splitter if _index>0.
		GridLength _dockedSize;
		Dock _headerAt;
		_DockState _state, _savedDockState;
		_Floating _floatWindow;
		string _floatSavedRect;
		_WindowStyle _windowStyle;
		//_Flags _flags;
		bool _dontSave;
		
		static readonly Brush s_toolbarHeaderBrush = SystemColors.ControlBrush;
		const int c_minSize = 4;
		const int c_defaultSplitterSize = 4;
		
		class _StackFields {
			public Grid grid;
			public bool isVertical; //vertical stack with horizontal splitters
		}
		
		class _TabFields {
			public _TabControl tc;
			public bool isVerticalHeader; //vertical buttons at left/right
		}
		
		class _LeafFields {
			public _DockPanelWithBorder panel;
			public FrameworkElement content; //app sets it = any element
			public FrameworkElement header; //TextBlock if panel/userdocument, Rectangle if toolbar/documentplaceholder. null if in tab.
			public string name; //used by the indexer to find it, also as header/tabitem text
			public bool addedLater; //added with AddSibling
			public bool canClose; //AddSibling(canClose). Adds context menu item "Close".
			public bool isExtension; //AddSibling(isExtension). Saves.
		}
		
		[Flags]
		enum _Flags { Splitter_ResizeNearest = 1 }
		
		/// <summary>
		/// Used to create root node when loading from XML.
		/// </summary>
		public _Node(KPanels pm, XElement x) : this(pm, x, null, 0) { }
		
		/// <summary>
		/// Used to create nodes when loading from XML.
		/// </summary>
		_Node(KPanels pm, XElement x, _Node parent, int index) {
			_pm = pm;
			_index = index;
			
			string tag = x.Name.LocalName;
			
			if (parent == null) { //the root XML element
				if (tag != "stack") throw new ArgumentException("XML root element must be 'stack'");
				_pm._rootStack = this;
			} else {
				parent.AddChild(this);
			}
			
			switch (tag) {
			case "stack":
				_stack = new _StackFields { isVertical = x.Attr("o") == "v" };
				_elem = _stack.grid = new Grid();
				break;
			case "tab":
				_tab = new();
				_elem = _tab.tc = new _TabControl();
				break;
			case "panel":
			case "toolbar":
			case "document":
				_leaf = new();
				_elem = _leaf.panel = new();
				_leafType = tag[0] switch { 'p' => LeafType.Panel, 't' => LeafType.Toolbar, _ => LeafType.Document };
				_leaf.name = x.Attr("name") ?? throw new ArgumentException("XML element without 'name'");
				_leaf.isExtension = x.HasAttr("ext");
				_Dictionary.Add(_leaf.name, this);
				break;
			default: throw new ArgumentException("unknown XML tag: " + tag);
			}
			_elem.UseLayoutRounding = true;
			_elem.Tag = this;
			
			if (parent != null) {
				if (!_IsDocument) {
					_savedDockState = (_DockState)(x.Attr("state", 0) & 3);
					_floatSavedRect = x.Attr("floatRect");
					x.Attr(out _windowStyle, "window");
				}
				if (!_IsStack) x.Attr(out _headerAt, "headerAt");
				
				if (_ParentIsStack) {
					_dockedSize = _GridLengthFromString(x.Attr("z")); //height in vertical stack or width in horizontal stack
					_AddToStack(moving: false, _index == 0 ? 0 : x.Attr("s", c_defaultSplitterSize));
					
					var flags = (_Flags)x.Attr("flags", 0);
					if (flags.Has(_Flags.Splitter_ResizeNearest) && _splitter != null) _splitter.ResizeNearest = true;
					
					if (_IsTab) _InitTabControl();
				} else {
					_AddToTab(moving: false);
				}
			}
			
			if (!_IsLeaf) { //stack or tab
				if (_ParentIsTab) throw new ArgumentException(tag + " in 'tab'");
				int i = 0;
				foreach (var e in x.Elements()) {
					new _Node(_pm, e, this, i++);
				}
				Debug.Assert(i > 0);
				
				if (_IsTab && i > 0) {
					_tab.tc.SelectedIndex = Math.Clamp(x.Attr("active", 0), 0, i - 1);
				}
			}
			
			//print.it(new string('\t', parent?.Level ?? 0) + _ntype, _ptype, Name, _indexInParent);
			
			if (parent == null) { //the root XML element
				int nVisible = 0; _Node firstHidden = null;
				List<_Node> aFloat = null;
				foreach (var v in Descendants()) {
					if (!v._IsStack) if (v._IsVisibleReally(true)) nVisible++; else firstHidden ??= v;
					var ds = v._savedDockState;
					if (ds == _DockState.Float) (aFloat ??= new()).Add(v);
					else if (ds != 0) v._SetDockState(ds);
				}
				if (nVisible == 0 && firstHidden != null) { //if all non-stack hidden, unhide one, else user cannot unhide any because there are no headers to show the context menu
					firstHidden._SetDockState(0);
				}
				if (aFloat != null) {
					DependencyPropertyChangedEventHandler eh = null;
					eh = (_, e) => {
						if (e.NewValue is bool visible && visible) {
							_stack.grid.IsVisibleChanged -= eh;
							_stack.grid.Dispatcher.InvokeAsync(() => {
								foreach (var v in aFloat) {
									if (v._state == _DockState.Hide) { v._state |= _DockState.Float; continue; } //hidden after loading
									v._SetDockState(_DockState.Float);
								}
							});
						}
					};
					_stack.grid.IsVisibleChanged += eh;
				}
				
				//timer.after(1000, _ => _Test(5));
				////timer.after(5000, _ => _Test(0));
				//void _Test(int margin) {
				//	foreach (var v in Descendants(true)) {
				//		if (v._IsStack) v._stack.grid.Background = (v.Level & 3) switch { 0 => Brushes.CornflowerBlue, 1 => Brushes.Khaki, 2 => Brushes.YellowGreen, _ => Brushes.LightYellow };
				//		if(v!=this) v._elem.Margin = new Thickness(margin);
				//		if (v._splitter != null) v._splitter.Visibility = Visibility.Collapsed;
				//	}
				//}
				
				////_stack.grid.PreviewMouseMove += _RootGrid_PreviewMouseMove;
			}
		}
		
		/// <summary>
		/// Used when moving a node, to create new parent (this) stack or tab for it and target.
		/// Also when moving a node, to create new parent (this) tab for it (target).
		/// </summary>
		_Node(_Node target, bool isTab, bool verticalStack = false) {
			_pm = target._pm;
			
			bool targetIsRoot = !isTab && target.Parent == null;
			if (targetIsRoot) {
				_pm._rootStack = this;
			} else {
				_index = target._index;
				target.AddSibling(this, after: false);
				target.Remove();
				target._index = 0;
			}
			AddChild(target);
			
			if (isTab) {
				_tab = new();
				_elem = _tab.tc = new _TabControl();
			} else {
				_stack = new _StackFields { isVertical = verticalStack };
				_elem = _stack.grid = new Grid();
			}
			_elem.Tag = this;
			
			if (targetIsRoot) {
				//target._dockedSize = ...; //_AddToParentWhenMovingOrAddingLater will set it for target and this
				_pm._setContainer(_stack.grid);
			} else {
				_ReplaceInStack(target);
				if (isTab) {
					_headerAt = target._headerAt;
					_InitTabControl();
				}
			}
		}
		
		/// <summary>
		/// Used when creating new leaf node later (after loading).
		/// </summary>
		_Node(_Node target, bool after, LeafType type, string name, bool canClose, bool isExtension) {
			_pm = target._pm;
			_leaf = new() { addedLater = true, name = name, canClose = canClose, isExtension = isExtension };
			_elem = _leaf.panel = new() { Tag = this, UseLayoutRounding = true };
			_leafType = type;
			_dontSave = !isExtension;
			_Dictionary.Add(name, this);
			_AddToParentWhenMovingOrAddingLater(target, after);
		}
		
		public void Save(XmlWriter x) {
			if (Parent == null) { //mark to not save stack/tab nodes without savable leaf descendants
				_Children(this);
				static bool _Children(_Node p) {
					bool R = false;
					foreach (var v in p.Children()) {
						if (!v._IsLeaf) v._dontSave = !_Children(v);
						R |= !v._dontSave;
					}
					return R;
				}
			} else {
				if (_dontSave) return;
			}
			
			x.WriteStartElement(_IsStack ? "stack" : (_IsTab ? "tab" : (_IsToolbar ? "toolbar" : (_IsDocument ? "document" : "panel"))));
			
			if (_IsStack) x.WriteAttributeString("o", _stack.isVertical ? "v" : "h");
			
			if (Parent != null) {
				if (_IsLeaf) {
					x.WriteAttributeString("name", _leaf.name);
					if (_leaf.isExtension) x.WriteAttributeString("ext", "");
				}
				
				if (_ParentIsStack) {
					if (!_dockedSize.IsAuto) {
						if (_IsDockedInStack) _dockedSize = _SizeDef; //update _dockedSize
						x.WriteAttributeString("z", _GridLengthToString(_dockedSize));
					}
					
					var z = _SplitterSize;
					if (z > 0 && z != c_defaultSplitterSize) x.WriteAttributeString("s", z.ToString());
					
					if (_splitter != null && _splitter.ResizeNearest) x.WriteAttributeString("flags", ((int)_Flags.Splitter_ResizeNearest).ToString());
				}
				
				if (_IsTab) {
					int i = _tab.tc.SelectedIndex;
					if (i > 0) x.WriteAttributeString("active", i.ToString());
				}
				
				if (_headerAt != 0) x.WriteAttributeString("headerAt", _headerAt.ToString());
				if (!_IsDocument) {
					if (_state != 0) x.WriteAttributeString("state", ((int)_state).ToString());
					_floatWindow?.Save();
					if (_floatSavedRect != null) x.WriteAttributeString("floatRect", _floatSavedRect);
					if (_windowStyle != 0) x.WriteAttributeString("window", _windowStyle.ToString());
				}
			}
			
			if (!_IsLeaf) foreach (var v in Children()) v.Save(x);
			
			x.WriteEndElement();
		}
		
		bool _IsStack => _stack != null;
		bool _IsTab => _tab != null;
		bool _IsLeaf => _leaf != null;
		bool _IsPanel => _leafType == LeafType.Panel;
		bool _IsToolbar => _leafType == LeafType.Toolbar;
		bool _IsDocument => _leafType == LeafType.Document;
		bool _ParentIsStack => Parent?._IsStack ?? false;
		bool _ParentIsTab => Parent?._IsTab ?? false;
		bool _ParentIsTabAndNotFloating => _ParentIsTab && _state != _DockState.Float;
		
		/// <summary>
		/// true if this is toolbar or this is stack/tab containing only toolbars.
		/// </summary>
		bool _IsToolbarsNode => _IsToolbar || (!_IsLeaf && Descendants().All(o => o._IsToolbar));
		
		/// <summary>
		/// true if this is document or this is tab containing documents (or tab with 0 children, which normally is not possible).
		/// </summary>
		bool _IsDocumentsNode => _IsDocument || (_IsTab && (FirstChild?._IsDocument ?? true));
		
		Dictionary<string, _Node> _Dictionary => (_leaf.addedLater && _IsDocument) ? _pm._dictUserDoc : _pm._dictLeaf;
		
		/// <summary>
		/// Gets name of panel/toolbar/document. Exception if not leaf.
		/// </summary>
		public string Name => _leaf.name;
		
		/// <summary>
		/// Gets the UI element of this node. It is Grid if this is stack, or TabControl if tab, else DockPanel.
		/// </summary>
		public FrameworkElement Elem => _elem;
		
		public override string ToString() {
			string s;
			if (_IsLeaf) {
				s = Name;
				if (_IsToolbar) s = "tb " + Name;
				return s;
			}
			if (Parent == null) return "Root stack";
			var a = Descendants().Where(o => o._IsLeaf).ToArray();
			s = a.Length switch {
				0 => "",
				1 => a[0].ToString(),
				2 => a[0].ToString() + ", " + a[1].ToString(),
				_ => a[0].ToString() + " ... " + a[^1].ToString()
			};
			return (_IsTab ? "Tabs {" : "Stack {") + s + "}";
		}
		
		//string _ToStringWithoutTB() {
		//	var s = ToString();
		//	if (_IsToolbar) s = s[3..];
		//	return s;
		//}
		
		/// <summary>
		/// true if _IsPanel or (_IsDocument and _leaf.addedLater).
		/// </summary>
		bool _CanHaveHeaderWithText => _IsPanel || (_IsDocument && _leaf.addedLater);
		
		void _SetHeaderAt(Dock ca, bool firstTime = false) {
			//if (_ParentIsTab) {
			//	Parent._SetHeaderAt(ca, firstTime);
			//	return;
			//}
			Dock old = firstTime ? Dock.Top : _headerAt;
			_headerAt = ca;
			if (_IsTab) {
				var tc = _tab.tc;
				if (ca == tc.TabStripPlacement) return;
				if (_tab.isVerticalHeader) {
					_tab.isVerticalHeader = false;
					foreach (TabItem v in tc.Items) v.Style = null;
				}
				tc.TabStripPlacement = ca;
				_VerticalTabHeader();
			} else if (_leaf.header != null) {
				DockPanel.SetDock(_leaf.header, ca);
				if (_leaf.content != null) _SetToolbarOrientation();
				if (ca == old || !_CanHaveHeaderWithText) return;
				if (ca == Dock.Top || ca == Dock.Bottom) {
					if (old == Dock.Left || old == Dock.Right) _leaf.header.LayoutTransform = null;
				} else {
					_leaf.header.LayoutTransform = new RotateTransform(ca == Dock.Left ? 270d : 90d);
				}
			}
		}
		
		void _AddRemoveHeaderAndBorder() {
			if (!_IsLeaf) return;
			if (_ParentIsTab && !_state.Has(_DockState.Float)) {
				if (_leaf.header != null) {
					_leaf.panel.Children.Remove(_leaf.header);
					_leaf.header = null;
					
					_leaf.panel.BorderThickness = default;
				}
			} else {
				if (_leaf.header == null) {
					if (_CanHaveHeaderWithText) {
						_leaf.header = new TextBlock {
							Text = Name,
							TextAlignment = TextAlignment.Center,
							Padding = new Thickness(2, 1, 2, 3),
							Background = _pm.HeaderBrush,
							Foreground = Brushes.Black,
							TextTrimming = TextTrimming.CharacterEllipsis
						};
					} else if (_IsToolbar) {
						var c = new Rectangle {
							MinHeight = 5,
							MinWidth = 5,
							Fill = s_toolbarHeaderBrush,
							//note: without Fill there are no events
						};
						c.MouseEnter += (_, _) => c.Fill = _pm.HeaderBrush;
						c.MouseLeave += (_, _) => c.Fill = s_toolbarHeaderBrush;
						_leaf.header = c;
					} else { //document placeholder
						var c = new Rectangle {
							//MinHeight = 5, MinWidth = 5, //rejected. Let be 0 (no header). User could accidentally undock when trying to scroll.
							//	Not tested headerless with tabbed documents. Then probably this code not used because _CanHaveHeaderWithText true.
							Fill = _pm.HeaderBrush,
						};
						_leaf.header = c;
						
						_leaf.panel.LastChildFill = false;
						bool hasDoc = false;
						c.SizeChanged += (_, e) => {
							bool has = _leaf.panel.Children.Count > 1;
							if (has != hasDoc) _leaf.panel.LastChildFill = hasDoc = has;
						};
					}
					_leaf.panel.Children.Insert(0, _leaf.header);
					_SetHeaderAt(_headerAt, true);
					_leaf.header.ContextMenuOpening += _HeaderContextMenu;
					_leaf.header.MouseDown += _OnMouseDown;
					
					if (_pm.BorderBrush != null && !_IsToolbar) {
						_leaf.panel.BorderBrush = _pm.BorderBrush;
						_leaf.panel.BorderThickness = new Thickness(1);
					}
				}
			}
		}
		
		void _SetToolbarOrientation() {
			if (_IsToolbar && _leaf.content is ToolBarTray t) {
				var ori = _headerAt == Dock.Top || _headerAt == Dock.Bottom ? Orientation.Vertical : Orientation.Horizontal;
				if (t.Orientation != ori) t.Orientation = ori;
			}
		}
		
		#region ILeaf
		
		FrameworkElement ILeaf.Content {
			get => _leaf.content;
			set {
				if (_leaf.content != null) _leaf.panel.Children.Remove(_leaf.content);
				_leaf.panel.Children.Add(_leaf.content = value);
				_SetToolbarOrientation();
			}
		}
		
		bool ILeaf.Visible {
			get => _IsVisibleReally();
			set {
				if (value && _savedDockState == _DockState.Float) return; //will make float async
				if (value) _Unhide(); else _Hide();
				if (value && _ParentIsTabAndNotFloating) {
					Parent._tab.tc.SelectedIndex = _index;
					if (value && !_elem.IsLoaded) _elem.UpdateLayout(); //workaround: WPF creates HwndHost control handle async. Let's create now.
				}
			}
		}
		
		/// <summary>
		/// Returns true if this node does not have hidden state and is not docked in hidden tab.
		/// </summary>
		bool _IsVisibleReally(bool useSavedState = false) {
			var state = useSavedState ? _savedDockState : _state;
			if (state.Has(_DockState.Hide)) return false;
			if (state == 0 && _ParentIsTab) return Parent._IsVisibleReally(useSavedState);
			return true;
		}
		
		bool ILeaf.Floating {
			get => _state == _DockState.Float;
			set {
				if (value && _savedDockState == _DockState.Float) return; //will make float async
				_SetDockState(value ? _DockState.Float : _state & ~_DockState.Float);
			}
		}
		
		public Action DontFocusTab { get; set; }
		
		ParentInfo ILeaf.Parent => new ParentInfo(_leaf.panel.Panel, Parent._elem, _index);
		
		ILeaf ILeaf.AddSibling(bool after, LeafType type, string name, bool canClose, bool isExtension) {
			if (name == null || (type is not (LeafType.Panel or LeafType.Toolbar or LeafType.Document))) throw new ArgumentException();
			return new _Node(this, after, type, name, canClose, isExtension);
		}
		
		public void Delete() {
			if (!_leaf.addedLater && !_leaf.isExtension) throw new InvalidOperationException();
			if (_state == _DockState.Float) _SetDockState(0);
			var oldParent = Parent;
			_RemoveFromParentWhenMovingOrDeleting();
			_RemoveParentIfNeedAfterMovingOrDeleting(oldParent);
			_Dictionary.Remove(_leaf.name);
		}
		
		void ILeaf.Rename(string name) {
			//if (!_IsLeaf) throw new InvalidOperationException(); //impossible, unless called from this class
			if (name == null) throw new ArgumentException();
			_Dictionary.Remove(_leaf.name);
			_Dictionary.Add(_leaf.name = name, this);
			if (_leaf.header is TextBlock t) t.Text = name;
			if (_ParentIsTab) {
				(Parent._tab.tc.Items[_index] as TabItem).Header = name;
				Parent._VerticalTabHeader(onMove: true);
			}
			if (_floatWindow != null) _floatWindow.Title = name;
		}
		
		public event EventHandler<bool> VisibleChanged;
		
		public event EventHandler<bool> FloatingChanged;
		
		public event System.ComponentModel.CancelEventHandler Closing;
		
		//public event EventHandler<popupMenu> ContextMenuOpening;
		
		public event EventHandler TabSelected;
		
		public event EventHandler ParentChanged;
		
		#endregion
	}
	
	class _DockPanelWithBorder : Border {
		public readonly DockPanel Panel;
		
		public _DockPanelWithBorder() {
			Child = Panel = new();
			SnapsToDevicePixels = true;
		}
		
		public UIElementCollection Children => Panel.Children;
		
		public bool LastChildFill { get => Panel.LastChildFill; set => Panel.LastChildFill = value; }
		
		public new object Tag {
			get => base.Tag;
			set { base.Tag = value; Panel.Tag = value; }
		}
	}
}



================================================
FILE: Au.Controls/KPanels/dock.cs
================================================
using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;
using System.Windows.Controls.Primitives;

namespace Au.Controls;

public partial class KPanels {
	partial class _Node {
		[Flags]
		enum _DockState { Hide = 1, Float = 2, }
		
		[Flags]
		enum _WindowStyle { Topmost = 1, Unowned = 2, }
		
		void _HeaderContextMenu(object sender, ContextMenuEventArgs e) {
			if (!_IsGoodMouseEvent(sender, e, out var target)) return;
			e.Handled = true;
			target._HeaderContextMenu(this);
		}
		
		void _HeaderContextMenu(_Node thisOrParentTab) {
			if (_IsDocument && !_leaf.addedLater) return;
			var m = new popupMenu();
			
			bool canClose = _leaf?.canClose ?? false;
			if (canClose) m["Close\tM-click"] = _ => _UserClosing();
			_DockStateItem(_DockState.Hide, canClose ? "Hide" : "Hide\tM-click");
			
			if (_state.Has(_DockState.Float)) _DockStateItem(0, "Dock\tD-click");
			else _DockStateItem(_DockState.Float, "Float\tD-click, drag");
			
			m.Submenu("Header at", m => {
				_HeaderAtItem(Dock.Left);
				_HeaderAtItem(Dock.Top);
				_HeaderAtItem(Dock.Right);
				_HeaderAtItem(Dock.Bottom);
				
				void _HeaderAtItem(Dock ca) {
					m.AddRadio(ca.ToString(), ca == thisOrParentTab._headerAt, o => thisOrParentTab._SetHeaderAt(ca));
				}
			});
			
			m.Submenu("Window", m => {
				_WindowItem(_WindowStyle.Topmost, "Topmost");
				_WindowItem(_WindowStyle.Unowned, "Unowned, can min/max");
				
				void _WindowItem(_WindowStyle ws, string s) {
					m.AddCheck(s, _windowStyle.Has(ws), o => { _windowStyle ^= ws; _floatWindow?.ChangeWindowStyle(ws); });
				}
			});
			
			_ContextMenu_Move(m);
			
			if (_leaf?.isExtension ?? false) {
				m["Remove..."] = o => {
					var s1 = _leafType == LeafType.Toolbar ? "toolbar" : "panel";
					if (!dialog.showYesNo($"Remove this extension {s1}?", this.Name, owner: _pm._ContainerWindow)) return;
					Delete();
					print.it($"Info: extension {s1} {this.Name} has been removed. To uninstall the extension, also remove its script from startup scripts in Options and delete the script.");
				};
			}
			
			_ShowSubmenus();
			
			//ContextMenuOpening?.Invoke(this, m);
			
			m.Show(owner: _pm._ContainerWindow);
			
			void _DockStateItem(_DockState state, string text) {
				m[text] = o => _SetDockState(state);
			}
			
			void _ShowSubmenus() {
				var a = new List<_Node>();
				foreach (var v in RootAncestor.Descendants()) {
					if (v._IsStack || !v._state.Has(_DockState.Hide)) continue;
					if (v._IsTab && v.Children().All(o => o._state.Has(_DockState.Hide))) continue;
					a.Add(v);
				}
				if (a.Count == 0) return;
				m.Separator();
				a.Sort((x, y) => {
					if (x._IsToolbar && !y._IsToolbar) return -1;
					if (y._IsToolbar && !x._IsToolbar) return 1;
					return string.Compare(x.ToString(), y.ToString(), true);
				});
				m.Submenu("Show", m => {
					int i = 0;
					foreach (var v in a) {
						if (i > 0 && a[i - 1]._IsToolbar != a[i]._IsToolbar) m.Separator();
						i++;
						m[v.ToString()] = _ => v._Unhide();
					}
#if DEBUG
					if (a.Count > 1) {
						m.Separator();
						m["Show all (debug)"] = _ => {
							foreach (var v in a) v._Unhide();
						};
					}
#endif
				});
			}
#if DEBUG
			m.Separator();
			m.Submenu("Debug", m => {
				m["Invalidate window"] = _ => _Invalidate(_pm._ContainerWindow);
				m["Invalidate floats"] = _ => {
					foreach (var v in RootAncestor.Descendants()) {
						if (v._floatWindow != null) _Invalidate(v._floatWindow);
					}
				};
				m.Add(0, "info: toggle ScrollLock if does not work", disable: true);
			});
			
			void _Invalidate(Window w) {
				//if (keys.isScrollLock) Api.InvalidateRect(w.Hwnd(), IntPtr.Zero, true); //works
				////else w.UpdateLayout(); //no
				//else w.InvalidateVisual(); //no
				
				Api.InvalidateRect(w.Hwnd(), keys.isScrollLock);
			}
#endif
		}
		
		private protected void _OnMouseDown(object sender, MouseButtonEventArgs e) {
			switch (e.ChangedButton) { case MouseButton.Left: case MouseButton.Middle: break; default: return; }
			if (_IsGoodMouseEvent(sender, e, out var target)) target._OnMouseDown(e);
		}
		
		void _OnMouseDown(MouseButtonEventArgs e) {
			if (_IsStack) {
				if (!(e.ChangedButton == MouseButton.Left && e.ClickCount == 1 && Keyboard.Modifiers == ModifierKeys.Alt)) return;
				if (Parent == null) { e.Handled = true; return; }
			}
			e.Handled = true;
			if (e.ChangedButton == MouseButton.Left) {
				if (e.ClickCount == 1) {
					e.Handled = false; //if tab item, let select it
					timer.after(1, _ => { //Dispatcher.InvokeAsync does not work
						POINT p = mouse.xy;
						if (Api.DragDetect(_elem.Hwnd(), p)) {
							_SetDockState(_DockState.Float, onDrag: true);
							_floatWindow?.Drag(p);
						}
					});
				} else if (e.ClickCount == 2) {
					_SetDockState(_state ^ _DockState.Float);
				}
			} else {
				if (_leaf?.canClose ?? false) _UserClosing();
				else _Hide();
			}
		}
		
		bool _IsGoodMouseEvent(object sender, RoutedEventArgs e, out _Node target) {
			target = null;
			if (e.Source == sender) {
				if (_IsTab && e.OriginalSource is not FlexStackPanel) return false; //tab control border
				target = sender == _splitter ? Parent : this;
			} else if (e.Source is TabItem ti && ti.Parent == sender) target = _NodeFromTabItem(ti);
			else return false;
			return true;
		}
		
		void _UserClosing() {
			if (Closing != null) {
				var e = new CancelEventArgs();
				Closing(this, e);
				if (e.Cancel) return;
			}
			Delete();
		}
		
		void _Hide() => _SetDockState(_DockState.Hide);
		void _Unhide() => _SetDockState(_state & ~_DockState.Hide);
		
		void _SetDockState(_DockState state, bool onDrag = false) {
			//print.qm2.write(this, state, "                    ", _state);
			_savedDockState = 0;
			if (state == _DockState.Hide) state |= _state & _DockState.Float;
			if (state == _state) {
				if (state == 0 && Parent._state.Has(_DockState.Hide)) Parent._Unhide(); //in hidden tab
				return;
			}
			
			var oldState = _state;
			_state = state;
			
			if (oldState == _DockState.Float) {
				_floatWindow?.Close();
				//_floatWindow sets _floatWindow=null when closing
			} else if (state == _DockState.Float) {
				_floatWindow = new _Floating(this, onDrag);
				//ctor uses docked rect
			}
			
			if (state == 0) { //dock; was hidden or floating
				_AddRemoveHeaderAndBorder();
				if (_ParentIsTab) _ShowHideInTab(true);
				else _ShowHideInStack(true);
			} else {
				if (oldState == 0) { //was docked; now hide or float
					if (_ParentIsTab) _ShowHideInTab(false);
					else _ShowHideInStack(false);
				}
				
				_AddRemoveHeaderAndBorder();
				
				if (state == _DockState.Float) {
					_floatWindow.Content = _elem;
					_floatWindow.ShowIfOwnerVisible();
				}
			}
			
			if ((state ^ oldState).Has(_DockState.Hide)) VisibleChanged?.Invoke(this, oldState.Has(_DockState.Hide));
			if ((state ^ oldState).Has(_DockState.Float)) FloatingChanged?.Invoke(this, state.Has(_DockState.Float));
		}
		
		void _ContextMenu_Move(popupMenu m) {
			m.Submenu("Move to", m => {
				m.RawText = true;
				string sThis = ToString();
				foreach (var target in RootAncestor.Descendants(andSelf: true)) {
					bool targetInTab = target._ParentIsTab;
					if (targetInTab) {
						if (!_IsLeaf || target._IsDocument != _IsDocument) continue;
					} else if (_IsDocument && _ParentIsTab) {
						//allow only beside parent tab or in/besides another document or doc tab. Elsewhere probably not useful, just adds many menu items.
						if (target != Parent && !target._IsDocumentsNode) continue;
					}
					if (target.Ancestors(andSelf: true).Contains(this)) continue;
					
					string sTarget = target.ToString();
					var s1 = new string(' ', target.Level * 4) + sTarget + (target._state switch { 0 => null, _DockState.Float => " (floating)", _ => " (hidden)" });
					m.Submenu(s1, m => {
						bool sep = false;
						//this would be duplicate of before/after
						//if (target._IsStack || (target._IsTab && _IsLeaf && (target.FirstChild?._IsDocument ?? false) == _IsDocument)) {
						//	int i = 0;
						//	foreach (var u in target.Children()) {
						//		m[i++ == 0 ? "First" : ($"Before '{u}'")] = o => _MoveTo(u, _HowToMove.BeforeTarget);
						//	}
						//	m["Last"] = o => _MoveTo(target.LastChild, _HowToMove.AfterTarget);
						//	sep = true;
						//}
						if (target.Parent != null) {
							//if (sep) m.Separator();
							if (target.Previous != this) _AddMI($"Before '{sTarget}'", _HowToMove.BeforeTarget);
							if (target.Next != this) _AddMI($"After '{sTarget}'", _HowToMove.AfterTarget);
							sep = true;
						}
						if (!targetInTab) {
							if (sep) m.Separator();
							if (target._IsLeaf && _IsLeaf && target._IsDocument == _IsDocument) {
								m.Add(0, $"Create tabs and add '{sThis}' as:", disable: true);
								_AddMI($"- First tab (before '{sTarget}')", _HowToMove.FirstInNewTab);
								_AddMI($"- Last tab (after '{sTarget}')", _HowToMove.LastInNewTab);
								m.Separator();
							}
							m.Add(0, $"Create stack and add '{sThis}' at:", disable: true);
							_AddMI("- Left", _HowToMove.NewStack, Dock.Left);
							_AddMI("- Right", _HowToMove.NewStack, Dock.Right);
							_AddMI("- Top", _HowToMove.NewStack, Dock.Top);
							_AddMI("- Bottom", _HowToMove.NewStack, Dock.Bottom);
						}
						if (target._IsStack || (target._IsTab && _IsLeaf) && target.FirstChild == null) { //empty
							m.Separator();
							_AddMI($"- Into '{sTarget}'", _HowToMove.Child);
						}
						
						void _AddMI(string text, _HowToMove how, Dock dock = default) {
							_MoveRect k = new(target, how, dock);
							m.Add(text, o => _MoveTo(k.target, k.how, k.dock)).Tag = k;
						}
						
						_RectTimer(m, true);
					}).Tag = target;
				}
				
				_RectTimer(m, false);
				
				static void _RectTimer(popupMenu m, bool second) {
					var osd = new osdRect { Color = second ? 0x60c000 : 0x4040ff };
					if (second) osd.Opacity = .5;
					PMItem pmi = null;
					timer.every(100, t => {
						if (m.IsOpen) {
							var mi = m.FocusedItem;
							if (mi != pmi) {
								pmi = mi;
								bool visible = false;
								if (mi != null) {
									if (!second) {
										var n = mi.Tag as _Node;
										if (visible = _GetRectInScreen(n, out var r)) osd.Rect = r;
									} else if (mi.Tag is _MoveRect k) {
										var n = k.target;
										if (n._floatWindow == null)
											if (visible = _GetRectInScreen(n, out var r)) {
												r.Inflate(-osd.Thickness, -osd.Thickness);
												if (k.how is _HowToMove.BeforeTarget or _HowToMove.AfterTarget) {
													bool vert = n._ParentIsTab ? n.Parent._headerAt is Dock.Left or Dock.Right : n.Parent._stack.isVertical;
													if (k.how == _HowToMove.BeforeTarget) {
														if (vert) r.bottom = r.top + r.Height / 2; else r.right = r.left + r.Width / 2;
													} else {
														if (vert) r.top = r.bottom - r.Height / 2; else r.left = r.right - r.Width / 2;
													}
												} else if (k.how == _HowToMove.Child) {
													if (n._stack.isVertical) r.bottom = r.top + r.Height / 4; else r.right = r.left + r.Width / 4;
												} else if (k.how == _HowToMove.NewStack) {
													if (k.dock == Dock.Left) r.right = r.left + r.Width / 2;
													if (k.dock == Dock.Right) r.left = r.right - r.Width / 2;
													if (k.dock == Dock.Top) r.bottom = r.top + r.Height / 2;
													if (k.dock == Dock.Bottom) r.top = r.bottom - r.Height / 2;
												}
												osd.Rect = r;
											}
									}
								}
								osd.Visible = visible;
							}
						} else {
							t.Stop();
							osd.Dispose();
						}
					});
				}
				
				static bool _GetRectInScreen(_Node n, out RECT r) {
					if (n._IsVisibleReally()) {
						FrameworkElement e =
							n._IsStack ? n._stack.grid
							: n._IsTab ? n._tab.tc
							: n._elem.Parent is TabItem ti ? ti
							: n._leaf.panel.Panel;
						try {
							r = e.RectInScreen();
							return true;
						}
						catch (Exception) {  }
					}
					r = default;
					return false;
				}
			});
		}
		
		enum _HowToMove //don't reorder
		{
			BeforeTarget, //before target in parent stack or tab
			AfterTarget, //after target in parent stack or tab
			NewStack, //create new stack in place of target; add target and this to it; use dock to set orientation of new stack and index ot this and target
			FirstInNewTab, //create new tab in place of target; add this (first) and target to it
			LastInNewTab, //create new tab in place of target; add target and this (last) to it
			Child, //add as child of target (target is empty stack or tab)
		}
		
		record class _MoveRect(_Node target, _HowToMove how, Dock dock = default);
		
		void _MoveTo(_Node target, _HowToMove how, Dock dock = default) {
			if (target == this) return;
			bool beforeAfter = how <= _HowToMove.AfterTarget;
			if (_state != 0) _SetDockState(0);
			if (target._state != 0 && !beforeAfter) target._SetDockState(0);
			
			bool after = how == _HowToMove.AfterTarget;
			var oldParent = Parent;
			
			if (beforeAfter && target.Parent == oldParent && oldParent._IsTab) { //just reorder buttons
				_ReorderInTab(target, after);
				return;
			}
			
			_RemoveFromParentWhenMovingOrDeleting();
			
			switch (how) {
			case _HowToMove.NewStack:
				new _Node(target, isTab: false, verticalStack: dock == Dock.Top || dock == Dock.Bottom);
				target._AddToStack(moving: false, c_defaultSplitterSize);
				after = dock == Dock.Right || dock == Dock.Bottom;
				break;
			case _HowToMove.FirstInNewTab:
			case _HowToMove.LastInNewTab:
				new _Node(target, isTab: true);
				target._AddToTab(moving: false);
				after = how == _HowToMove.LastInNewTab;
				break;
			}
			
			if (how == _HowToMove.Child) _AddToParentWhenMoving(target);
			else _AddToParentWhenMovingOrAddingLater(target, after);
			
#if false //debug print
			int i = 0;
			foreach (var v in Parent.Children()) {
				print.it(i++, v._index, v);
				if (Parent._IsStack) {
					if (v._splitter != null) print.it("splitter", _RC(v._splitter));
					print.it("elem    ", _RC(v._elem), v._dockedSize, v._SizeDef);
					int _RC(FrameworkElement e) => Parent._stack.isVertical ? Grid.GetRow(e) : Grid.GetColumn(e);
				}
			}
#endif
			
			_RemoveParentIfNeedAfterMovingOrDeleting(oldParent);
			
			if (how <= _HowToMove.NewStack && _IsDocument && oldParent._IsTab && !_ParentIsTab) {
				_headerAt = oldParent._headerAt;
				new _Node(this, isTab: true);
				_AddToTab(moving: false);
			}
			
			if (Parent != oldParent) ParentChanged?.Invoke(this, EventArgs.Empty);
		}
		
		void _AddToParentWhenMovingOrAddingLater(_Node target, bool after) {
			target.AddSibling(this, after);
			_index = target._index + (after ? 1 : 0);
			if (_ParentIsTab) {
				_AddToTab(moving: true);
				_AddRemoveHeaderAndBorder();
				//if(select) Parent._tab.tc.SelectedIndex = _index;
			} else {
				if (!(_dockedSize.IsAuto && _IsToolbarsNode)) _dockedSize = new GridLength(100, GridUnitType.Star);
				if (Parent.Count == 2) target._SizeDef = target._dockedSize = new GridLength(100, GridUnitType.Star);
				
				_AddToStack(moving: true, c_defaultSplitterSize);
			}
		}
		
		void _AddToParentWhenMoving(_Node parent) {
			parent.AddChild(this, first: true);
			_index = 0;
			if (_ParentIsTab) {
				_AddToTab(moving: true);
				_AddRemoveHeaderAndBorder();
				Parent._tab.tc.SelectedIndex = _index;
			} else {
				if (!(_dockedSize.IsAuto && _IsToolbarsNode)) _dockedSize = new GridLength(100, GridUnitType.Star);
				
				_AddToStack(moving: true, c_defaultSplitterSize);
			}
		}
		
		void _RemoveFromParentWhenMovingOrDeleting() {
			if (Parent._IsStack) {
				_RemoveGridRowCol(_elem);
				_RemoveSplitter();
				if (_index == 0) Next?._RemoveSplitter();
			} else {
				if (_elem.Parent is TabItem ti) { //null if hidden or floating
					ti.Content = null;
					Parent._tab.tc.Items.Remove(ti);
				}
			}
			_ShiftSiblingIndices(-1);
			Remove();
		}
		
		void _RemoveParentIfNeedAfterMovingOrDeleting(_Node oldParent) {
			int n = oldParent.Count;
			if (n == 0) {
				var pp = oldParent.Parent;
				oldParent._RemoveFromParentWhenMovingOrDeleting();
				oldParent._RemoveParentIfNeedAfterMovingOrDeleting(pp);
			} else if (n == 1) {
				if (!_IsDocument) {
					var f = oldParent.FirstChild;
					if (oldParent.Parent != null) {
						f._MoveTo(oldParent, _HowToMove.BeforeTarget);
					} else {
						f._RemoveFromParentWhenMovingOrDeleting();
						_pm._rootStack = f;
						_pm._setContainer(f._stack.grid);
					}
				}
			} else if (oldParent._IsTab && Parent != oldParent) {
				oldParent._VerticalTabHeader(onMove: true);
			}
		}
		
		void _ShiftSiblingIndices(int n) {
			for (var v = this; (v = v.Next) != null;) v._index += n;
		}
	}
	
	[Conditional("DEBUG")]
	internal void PrintTree_(string header = null) {
		print.qm2.write("-----" + header);
		foreach (var v in _rootStack.Descendants(true)) {
			print.qm2.write(new string('\t', v.Level) + v);
		}
	}
}


================================================
FILE: Au.Controls/KPanels/stack.cs
================================================
using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;

namespace Au.Controls;

public partial class KPanels
{
	partial class _Node
	{
		/// <summary>
		/// Gets nodes docked and really visible in this stack (not in tab, not floating, not hidden).
		/// </summary>
		List<_Node> _Stack_DockedNodes {
			get {
				var a = new List<_Node>();
				foreach (var v in Children()) if (v._elem.Parent == _stack.grid) a.Add(v);
				return a;
			}
		}

		/// <summary>
		/// true if parent is stack and this is docked and not floating/hidden.
		/// </summary>
		bool _IsDockedInStack => _ParentIsStack && _elem.Parent == Parent._stack.grid;

		_Node _PreviousDockedInStack {
			get {
				for (var v = this; (v = v.Previous) != null;) if (v._IsDockedInStack) return v;
				return null;
			}
		}

		//not used
		//_Node _NextDockedInStack {
		//	get {
		//		for (var v = this; (v = v.Next) != null;) if (v._IsDockedInStack) return v;
		//		return null;
		//	}
		//}

		/// <summary>
		/// Adds elements of this to parent stack. Creates splitter if need, adds row/column, sets element properties (header etc).
		/// </summary>
		/// <param name="moving">Called when moving this. Inserts, shifts sibling indices, etc. If false, adds as last item in stack.</param>
		/// <param name="splitterSize"></param>
		void _AddToStack(bool moving, int splitterSize) {
			int i = _index * 2;
			if (i > 0) _CreateSplitter(splitterSize);
			var pstack = Parent._stack;
			var g = pstack.grid;
			if (pstack.isVertical) {
				g.InsertRow(i, new RowDefinition { Height = _dockedSize, MinHeight = c_minSize });
				g.AddChild(_elem, i, 0);
			} else {
				g.InsertColumn(i, new ColumnDefinition { Width = _dockedSize, MinWidth = c_minSize });
				g.AddChild(_elem, 0, i);
			}
			if (moving) {
				_ShiftSiblingIndices(1);

				var next = Next;
				if (next != null) {
					if (next._splitter == null) next._CreateSplitter(c_defaultSplitterSize);

					//workaround for: when moving a fixed-size item, 1 pixel of splitter after it may stop working. If splitter size is 1 pixel...
					else if (next._SplitterSize < c_defaultSplitterSize) next._SplitterSize = c_defaultSplitterSize;
				}
			}
			_AddRemoveHeaderAndBorder();
		}

		/// <summary>
		/// Replaces target with this in parent stack.
		/// Used when moving, to create new parent (this) tab or stack for target and the moved node.
		/// Does not add/remove tree nodes.
		/// </summary>
		void _ReplaceInStack(_Node target) {
			if (target._splitter != null) {
				target._SetSplitterEvents(false);
				_splitter = target._splitter; target._splitter = null;
				_SetSplitterEvents(true);
			}

			_dockedSize = target._dockedSize;
			if (_dockedSize.IsAuto) _SizeDef = _dockedSize = new GridLength(100, GridUnitType.Star);

			int i = _index * 2;
			var pstack = Parent._stack;
			var g = pstack.grid;
			if (pstack.isVertical) Grid.SetRow(_elem, i); else Grid.SetColumn(_elem, i);
			g.Children.Remove(target._elem);
			g.Children.Add(_elem);
			_AddRemoveHeaderAndBorder();
			target._AddRemoveHeaderAndBorder();
		}

		/// <summary>
		/// Removes an element of this from parent stack grid. Removes its row/column and shifts sibling indices.
		/// </summary>
		/// <param name="e">_elem or _splitter</param>
		void _RemoveGridRowCol(FrameworkElement e) {
			var pstack = Parent._stack;
			if (pstack.isVertical) pstack.grid.RemoveRow(e, false); else pstack.grid.RemoveColumn(e, false);
		}

		void _ShowHideInStack(bool show) {
			var g = Parent._stack.grid;
			var a = Parent._Stack_DockedNodes;
			if (!show) {
				_dockedSize = _SizeDef;

				g.Children.Remove(_elem);
				if (_splitter != null) _splitter.Visibility = Visibility.Collapsed;
				_SizeMin = 0;
				_SizeDef = default; //Auto

				a.Remove(this);
				if (a.Count == 0) {
					if (Parent._state == _DockState.Float) Parent._Hide();
					else Parent._ShowHideInStack(show);
				} else if (_dockedSize.IsStar && !a.Any(o => o._SizeDef.IsStar)) { //if hiding last star-sized, make the last visible fixed node star-sized
					a.LastOrDefault(o => o._SizeDef.IsAbsolute)?._ChangeSizeUnit(GridUnitType.Star, false);
					//never mind: later should restore. It makes everything complicated. This probably is rare, and it's easy for user to set fixed size again.
				}
			} else {
				if (a.Count == 0) {
					if (Parent._state.Has(_DockState.Float)) Parent._SetDockState(_DockState.Float);
					else Parent._ShowHideInStack(show);
				}

				_SizeDef = _dockedSize;
				_SizeMin = c_minSize;
				g.Children.Add(_elem);
			}
			Parent._Stack_UpdateSplittersVisibility();
		}

		#region splitter

		void _CreateSplitter(int size) {
			bool verticalStack = Parent._stack.isVertical;
			var c = new GridSplitter2();
			if (verticalStack) { //horz splitter
				c.ResizeDirection = GridResizeDirection.Rows;
				c.VerticalAlignment = VerticalAlignment.Top;
				c.HorizontalAlignment = HorizontalAlignment.Stretch;
			} else { //vert splitter
				c.ResizeDirection = GridResizeDirection.Columns;
				c.HorizontalAlignment = HorizontalAlignment.Left;
				//default stretch
			}
			if (_pm.SplitterBrush != null) c.Background = _pm.SplitterBrush;
			_splitter = c;
			_SplitterSize = size;
			var g = Parent._stack.grid;
			int i = _index * 2 - 1;
			if (verticalStack) {
				g.InsertRow(i, new RowDefinition { Height = default }); //Auto
				g.AddChild(c, i, 0);
			} else {
				g.InsertColumn(i, new ColumnDefinition { Width = default });
				g.AddChild(c, 0, i);
			}
			_SetSplitterEvents(true);
		}

		void _SetSplitterEvents(bool add) {
			if (add) {
				_splitter.ContextMenuOpening += _SplitterContextMenu;
				_splitter.PreviewMouseDown += _OnMouseDown;
			} else {
				_splitter.ContextMenuOpening -= _SplitterContextMenu;
				_splitter.PreviewMouseDown -= _OnMouseDown;
			}
		}

		/// <summary>
		/// This must be stack. Hides splitter of first visible child and shows splitters of other visible children.
		/// </summary>
		void _Stack_UpdateSplittersVisibility() {
			var a = _Stack_DockedNodes;
			for (int i = 0; i < a.Count; i++) {
				var v = a[i];
				if (i > 0) v._splitter.Visibility = Visibility.Visible;
				else if (v._splitter != null) v._splitter.Visibility = Visibility.Collapsed;
			}
		}

		void _RemoveSplitter() {
			if (_splitter != null) {
				_RemoveGridRowCol(_splitter);
				_splitter = null;
			}
		}

		/// <summary>
		/// Gets or sets actual height of <see cref="_splitter"/> in vertical stack or width in horizontal stack.
		/// </summary>
		int _SplitterSize {
			get {
				if (_splitter == null) return 0;
				return (Parent._stack.isVertical ? _splitter.ActualHeight : _splitter.ActualWidth).ToInt();
			}
			set {
				if (_splitter == null) return;
				if (Parent._stack.isVertical) _splitter.Height = value; else _splitter.Width = value;
			}
		}

		void _SplitterContextMenu(object sender, ContextMenuEventArgs e) {
			e.Handled = true;
			var parentStack = Parent._stack;
			var m = new popupMenu();
			m.Submenu("Splitter size", m => {
				int z = _SplitterSize;
				for (int i = 1; i <= 10; i++) {
					m.AddRadio(i.ToString(), i == z, o => _SplitterSize = o.Text.ToInt());
				}
			});
			m.Separator();
			bool vert = parentStack.isVertical;
			_PreviousDockedInStack._SplitterContextMenu_Unit(m, vert ? "Top" : "Left");
			_SplitterContextMenu_Unit(m, vert ? "Bottom" : "Right");
			if ((parentStack.isVertical ? parentStack.grid.RowDefinitions.Where(o => !o.Height.IsAuto).Count() : parentStack.grid.ColumnDefinitions.Where(o => !o.Width.IsAuto).Count()) > 2) {
				//m.Separator();
				m.AddCheck("Resize Nearest\tCtrl", _splitter.ResizeNearest, _ => _splitter.ResizeNearest ^= true);
			}
			if (Parent.Parent != null) {
				m.Separator();
				m.Submenu("Stack", m => {
					bool isFloating = Parent._state.Has(_DockState.Float);
					m[isFloating ? "Dock" : "Float\tAlt+drag"] = o => Parent._SetDockState(isFloating ? 0 : _DockState.Float);
					Parent._ContextMenu_Move(m);
				});
			}
			timer.after(100, _ => Mouse.SetCursor(Cursors.Arrow)); //workaround. 30 too small, 50 ok
			m.Show();
		}

		void _SplitterContextMenu_Unit(popupMenu m, string s1) {
			var unitNow = _SizeDef.GridUnitType;
			//var unitNow = _dockedSize.GridUnitType;
			//print.it(this, unitNow);
			bool allToolbars = _IsToolbarsNode;
			bool disableFixed = !allToolbars && unitNow != GridUnitType.Pixel
				&& Parent.Children().Count(o => o._SizeDef.GridUnitType == GridUnitType.Star) < (unitNow == GridUnitType.Star ? 2 : 1);
			_UnitItem(s1 + " fixed", GridUnitType.Pixel);
			if (allToolbars) _UnitItem(s1 + " auto", GridUnitType.Auto);

			void _UnitItem(string text, GridUnitType unit) {
				m.AddCheck(text, unit == unitNow, o => _SetUnit(unit), disable: disableFixed && unit == GridUnitType.Pixel);
				//CONSIDER: don't disable. Maybe user wants to set row A fixed and then row B star, not vice versa. But if forgets and makes window smaller, some panels and splitters may become invisible.
			}

			void _SetUnit(GridUnitType unit) {
				if (unit == _SizeDef.GridUnitType) unit = GridUnitType.Star; //unchecking Fixed or Auto
				_ChangeSizeUnit(unit, true);
			}
		}

		#endregion

		#region row/col, size

		//void _NormalizeChildStars(bool percent) {//FUTURE: remove if unused. Not sure it is finished.
		//	var e = Children();
		//	double sizeOfStars = percent ? e.Sum(v => !v._dockedSize.IsStar ? 0 : v._SizeNowDockedOrNot) : 0;
		//	foreach (var v in e) {
		//		if (!v._dockedSize.IsStar) continue;
		//		var z = _SizeNowDockedOrNot;
		//		if (percent && sizeOfStars >= 0.1) z = z * 100 / sizeOfStars;
		//		_dockedSize = new GridLength(z, GridUnitType.Star);
		//		if (_IsDockedInStack) _SizeDef = _dockedSize;
		//	}
		//}

		///// <summary>
		///// If _IsDockedInStack, returns _SizeNow, else _dockedSize.Value.
		///// </summary>
		//double _SizeNowDockedOrNot => _IsDockedInStack ? _SizeNow : _dockedSize.Value;

		///// <summary>
		///// Gets actual row height in vertical stack or column width in horizontal stack.
		///// </summary>
		//double _SizeNow => new _RowCol(this).SizeNow;

		/// <summary>
		/// Gets or sets defined row height/unit in vertical stack or column width/unit in horizontal stack.
		/// </summary>
		GridLength _SizeDef {
			get => new _RowCol(this).SizeDef;
			set => new _RowCol(this) { SizeDef = value };
			//set {
			//	print.it(this, value.GridUnitType);
			//	new _RowCol(this) { SizeDef = value };
			//}
		}

		///// <summary>
		///// Gets GridLength with actual row height in vertical stack or column width in horizontal stack.
		///// </summary>
		//GridLength _SizeDefNow => new _RowCol(this).SizeDefNow;

		/// <summary>
		/// Gets or sets minimal row height in vertical stack or column width in horizontal stack.
		/// </summary>
		double _SizeMin {
			//get => new _RowCol(this).SizeMin;
			set => new _RowCol(this) { SizeMin = value };
		}

		///// <summary>
		///// Gets or sets maximal row height in vertical stack or column width in horizontal stack.
		///// </summary>
		//double _SizeMax {
		//	get => new _RowCol(this).SizeMax;
		//	set => new _RowCol(this) { SizeMax = value };
		//}

		/// <summary>
		/// Sets size = actual size and new unit.
		/// </summary>
		void _ChangeSizeUnit(GridUnitType unit, bool updateStars) {
			Debug.Assert(_IsDockedInStack);
			_dockedSize = new _RowCol(this).ChangeUnit(unit);
			if (updateStars && unit == GridUnitType.Star) //update other stars, else the splitter may jump
				foreach (var v in Parent._Stack_DockedNodes)
					if (v != this && v._dockedSize.IsStar)
						v._ChangeSizeUnit(unit, false); //unit is same, just update value in grid and _dockedSize
		}

		struct _RowCol
		{
			readonly DefinitionBase _d;

			public _RowCol(_Node node) {
				var stack = node.Parent._stack;
				int i = node._index * 2;
				if (stack.isVertical) _d = stack.grid.RowDefinitions[i];
				else _d = stack.grid.ColumnDefinitions[i];
			}

			public DefinitionBase RowCol => _d;

			public GridLength SizeDef {
				get => (_d is RowDefinition rd) ? rd.Height : (_d as ColumnDefinition).Width;
				set { if (_d is RowDefinition rd) rd.Height = value; else (_d as ColumnDefinition).Width = value; }
			}

			public double SizeNow => (_d is RowDefinition rd) ? rd.ActualHeight : (_d as ColumnDefinition).ActualWidth;

			public GridLength SizeDefNow => new GridLength(SizeNow, SizeDef.GridUnitType);

			public double SizeMin {
				get => (_d is RowDefinition rd) ? rd.MinHeight : (_d as ColumnDefinition).MinWidth;
				set { if (_d is RowDefinition rd) rd.MinHeight = value; else (_d as ColumnDefinition).MinWidth = value; }
			}

			public double SizeMax {
				get => (_d is RowDefinition rd) ? rd.MaxHeight : (_d as ColumnDefinition).MaxWidth;
				set { if (_d is RowDefinition rd) rd.MaxHeight = value; else (_d as ColumnDefinition).MaxWidth = value; }
			}

			public GridLength ChangeUnit(GridUnitType unit) { var r = new GridLength(SizeNow, unit); SizeDef = r; return r; }
		}

		static GridLength _GridLengthFromString(string s) {
			double w = 0; var u = GridUnitType.Star;
			if (s == null) u = GridUnitType.Auto;
			else if (s.Ends("*")) w = s.Length > 1 ? s.ToNumber(..^1) : 1.0;
			else { w = s.ToNumber(); u = GridUnitType.Pixel; }
			return new GridLength(w, u);
			//also tested GridLengthConverter
		}

		static string _GridLengthToString(GridLength k) {
			if (k.IsAuto) return null;
			var s = Math.Round(k.Value, 10).ToS();
			return k.IsStar ? s + "*" : s;
			//GridLength.ToString is almost same, but: for Auto returns "Auto"; can return long string like "425.79999999999995" instead of "425.8".
		}

		#endregion
	}
}


================================================
FILE: Au.Controls/KPanels/tab.cs
================================================
using System.Windows;
using System.Windows.Controls;
using System.Windows.Media;
using System.Windows.Input;
using System.Windows.Interop;

namespace Au.Controls;

public partial class KPanels {
	partial class _Node {
		static readonly Style
			s_styleTabControl = XamlResources.Dictionary["AuPanelsTabControlStyle"] as Style,
			s_styleTabItem = XamlResources.Dictionary["AuPanelsTabItemStyle"] as Style,
			s_styleTabLeft = XamlResources.Dictionary["TabItemVerticalLeft"] as Style,
			s_tyleTabRight = XamlResources.Dictionary["TabItemVerticalRight"] as Style;
		
		void _InitTabControl() {
			var tc = _tab.tc;
			tc.Style = s_styleTabControl;
			if (_pm.HeaderBrush != Brushes.LightSteelBlue) {
				tc.ApplyTemplate();
				if (VisualTreeHelper.GetChild(tc, 0) is Grid tg) tg.Background = _pm.HeaderBrush; //note: tc must have a parent.
			}
			tc.Padding = default;
			tc.TabStripPlacement = _headerAt;
			tc.SizeChanged += (_, e) => {
				switch (tc.TabStripPlacement) { case Dock.Top: case Dock.Bottom: return; }
				bool bigger = e.NewSize.Height > e.PreviousSize.Height;
				if (bigger != _tab.isVerticalHeader) _VerticalTabHeader(e.NewSize.Height);
			};
			tc.ContextMenuOpening += _HeaderContextMenu;
			tc.PreviewMouseDown += _OnMouseDown;
			tc.SelectionChanged += (o, e) => {
				if (e.Source != o) return; //eg a descendant ComboBox
				e.Handled = true;
				if (e.AddedItems.Count == 0) return;
				var v = (e.AddedItems[0] as TabItem).Tag as _Node;
				v.TabSelected?.Invoke(v, EventArgs.Empty);
			};
			
			//implement DontFocusTab (prevent changing focus when clicking a tabitem)
			tc.PreviewMouseLeftButtonDown += (_, e) => {
				if (e.Source is TabItem ti && ti.Tag is _Node n && n.DontFocusTab != null) {
					bool focusWithin;
					if (Keyboard.FocusedElement != null) {
						focusWithin = tc.IsKeyboardFocusWithin;
					} else {
						wnd w = Api.GetFocus();
						if (!w.IsChildOf(ti.Hwnd())) return;
						focusWithin = null != tc.FindVisualDescendant(o => o is HwndHost hh && hh.Handle == w.Handle);
					}
					if (focusWithin && ti.IsSelected) return;
					
					ti.PreviewGotKeyboardFocus += _PreviewGotKeyboardFocus;
					ti.Dispatcher.InvokeAsync(() => { ti.PreviewGotKeyboardFocus -= _PreviewGotKeyboardFocus; });
					void _PreviewGotKeyboardFocus(object sender, KeyboardFocusChangedEventArgs e) {
						e.Handled = true;
						if (focusWithin) ti.Dispatcher.InvokeAsync(n.DontFocusTab);
					}
					//note: cannot implement it in _AddToTab, because then we don't know whether the tab header clicked or some descendant.
				}
			};
		}
		
		void _VerticalTabHeader(double height = -1, bool onMove = false) {
			var tc = _tab.tc;
			if (tc.TabStripPlacement is Dock.Top or Dock.Bottom) return;
			
			if (height < 0) height = tc.ActualHeight;
			
			var d = _CalcHeight(); //not too slow
			bool vertHeader = d < height - 10;
			if (vertHeader == _tab.isVerticalHeader && !onMove) return;
			_tab.isVerticalHeader = vertHeader;
			var dock = tc.TabStripPlacement;
			foreach (TabItem v in tc.Items) {
				v.Style = vertHeader ? (dock == Dock.Left ? s_styleTabLeft : s_tyleTabRight) : s_styleTabItem;
			}
			
			double _CalcHeight() {
				var cult = CultureInfo.InvariantCulture;
				var fdir = tc.FlowDirection;
				var font = new Typeface(tc.FontFamily, tc.FontStyle, tc.FontWeight, tc.FontStretch);
				var fsize = tc.FontSize;
				var brush = SystemColors.ControlTextBrush;
				//var ppd = VisualTreeHelper.GetDpi(tc).PixelsPerDip; print.it(ppd); //ignored, and we don't need it
				double r = 4;
				foreach (TabItem v in tc.Items) {
					var f = new FormattedText(v.Header.ToString(), cult, fdir, font, fsize, brush, 1);
					r += f.Width + 11;
				}
				return r;
			}
		}
		
		/// <summary>
		/// Adds this to parent tab at startup or when moving.
		/// Caller before must call AddChild (or AddSibling) and set _index.
		/// </summary>
		void _AddToTab(bool moving) {
			var ti = new TabItem { Style = s_styleTabItem, Header = _leaf.name, Content = _elem, Tag = this };
			var tc = Parent._tab.tc;
			tc.Items.Insert(_index, ti);
			if (moving) {
				_ShiftSiblingIndices(1);
				Parent._VerticalTabHeader(onMove: true);
			}
		}
		
		void _ShowHideInTab(bool show) {
			var tc = Parent._tab.tc;
			var ti = tc.Items[_index] as TabItem;
			if (!show) {
				var a = tc.Items.OfType<TabItem>().Where(o => o.Visibility == Visibility.Visible).ToArray();
				if (a.Length > 1) {
					if (ti == tc.SelectedItem) {
						int i = Array.IndexOf(a, ti);
						if (++i == a.Length) i -= 2;
						tc.SelectedItem = a[i];
					}
				} else if (!_IsDocument) {
					if (Parent._state == _DockState.Float) Parent._Hide();
					else if (!Parent._state.Has(_DockState.Hide)) Parent._ShowHideInStack(show);
				}
				ti.Visibility = Visibility.Collapsed;
				ti.Content = null;
			} else {
				if (tc.Parent == null) {
					if (Parent._state.Has(_DockState.Float)) Parent._SetDockState(_DockState.Float);
					else Parent._ShowHideInStack(show);
				}
				
				ti.Content = _elem;
				ti.Visibility = Visibility.Visible;
				tc.SelectedItem = ti;
			}
		}
		
		void _ReorderInTab(_Node target, bool after) {
			if (target == this || (after && target.Next == this) || (!after && target.Previous == this)) return;
			Remove(); target.AddSibling(this, after);
			int index = 0; foreach (var v in Parent.Children()) v._index = index++;
			//to avoid auto-selecting next item when removed active item, we remove all inactive items and then add in new order.
			var tc = Parent._tab.tc;
			var sel = tc.SelectedItem;
			var a = tc.Items.OfType<TabItem>().ToArray();
			for (int i = a.Length; --i >= 0;) if (a[i] != sel) tc.Items.RemoveAt(i);
			Array.Sort(a, (x, y) => (x.Tag as _Node)._index - (y.Tag as _Node)._index);
			for (int i = 0; i < a.Length; i++) if (a[i] != sel) tc.Items.Insert(i, a[i]);
		}
		
		static _Node _NodeFromTabItem(TabItem ti) => ti.Tag as _Node;
	}
	
	class _TabControl : TabControl {
		protected override void OnKeyDown(KeyEventArgs e) {
			//Apps often use Ctrl+Tab and Ctrl+Shift+Tab eg to switch documents, but TabControl would steal them for switching tabs.
			//	To swith TabControl tabs also can be used Shift+Tab (makes tab item focused) then arrows.
			if (e.Key == Key.Tab && Keyboard.Modifiers is ModifierKeys.Control or (ModifierKeys.Control | ModifierKeys.Shift)) return;
			base.OnKeyDown(e);
		}
	}
}


================================================
FILE: Au.Controls/KScintilla/KScintilla.cs
================================================
using System.Windows;
using System.Windows.Interop;
using System.Windows.Input;

namespace Au.Controls;

using static Sci;

/// <summary>
/// This .NET control wraps native Scintilla control.
/// It is not a universal Scintilla wrapper class. Just for this library and related software.
/// </summary>
/// <remarks>
/// Most functions throw ArgumentOutOfRangeException when: 1. A position or line index argument is negative. 2. Scintilla returned a negative position or line index.
/// If a position or line index argument is greater than text length or the number of lines, some functions return the text length or the last line, and it is documented; for other functions the behaviour is undefined, eg ArgumentOutOfRangeException or Scintilla's return value or like of the documented methods.
/// 
/// Function/event names start with aa, because VS intellisense cannot group by inheritance and would mix with 300 WPF functions/events.
/// </remarks>
public unsafe partial class KScintilla : HwndHost {
	wnd _w;
	WNDPROC _wndproc;
	nint _wndprocScintilla;
	nint _sciPtr;
	Sci_NotifyCallback _notifyCallback;
	int _managedThreadId;
	internal int _dpi;
	
#if DEBUG
	public bool test_; //we use many scintilla controls, but often want to test something on one of them. Then set test_ = true...
#endif
	
	static KScintilla() {
		Cpp.LoadAuNativeDll(SCINTILLA_DLL);
	}
	
	public KScintilla() {
		_adapter = new(this);
	}
	
	//public nint AaSciPtr => _sciPtr;
	public nint AaSciPtr {
		get {
			Debug.Assert(_sciPtr != 0);
			return _sciPtr;
		}
	}
	
	public SciImages AaImages { get; private set; }

	public SciTags AaTags => field ??= (AaInitTagsStyle == AaTagsStyle.NoTags ? null : new(this));
	//can be used to add user-defined tags before creating window handle
	
	#region HwndHost
	
	public wnd AaWnd => _w;
	
	/// <summary>
	/// Invoked by <b>AaOnHandleCreated</b>, which is called by <see cref="BuildWindowCore"/> after initializing everything but before setting text and subclassing.
	/// </summary>
	public event Action<KScintilla> AaHandleCreated;
	
	/// <summary>
	/// Called by <see cref="BuildWindowCore"/> after initializing everything but before setting text and subclassing.
	/// Invokes event <see cref="AaHandleCreated"/>.
	/// </summary>
	protected virtual void AaOnHandleCreated() => AaHandleCreated?.Invoke(this);
	
	protected override HandleRef BuildWindowCore(HandleRef hwndParent) {
		var wParent = (wnd)hwndParent.Handle;
		_dpi = Dpi.OfWindow(wParent);
		WS style = WS.CHILD; if (AaInitBorder) style |= WS.BORDER;
		//note: no WS_VISIBLE. WPF will manage it. It can cause visual artefacts occasionally, eg scrollbar in WPF area.
		_w = Api.CreateWindowEx(0, "Scintilla", Name, style, 0, 0, 0, 0, wParent);
		//size 0 0 is not the best, but it is a workaround for WPF bugs
		
		_sciPtr = _w.Send(SCI_GETDIRECTPOINTER);
		_managedThreadId = Environment.CurrentManagedThreadId;
		Call(SCI_SETNOTIFYCALLBACK, 0, Marshal.GetFunctionPointerForDelegate(_notifyCallback = _NotifyCallback));
		
		bool hasTags = AaInitTagsStyle != AaTagsStyle.NoTags;
		if (AaInitReadOnlyAlways) {
			MOD mask = 0;
			if (AaInitImages || hasTags) mask |= MOD.SC_MOD_INSERTTEXT | MOD.SC_MOD_DELETETEXT;
			Call(SCI_SETMODEVENTMASK, (int)mask);
		}
		_InitDocument();
		Call(SCI_SETSCROLLWIDTHTRACKING, 1);
		Call(SCI_SETSCROLLWIDTH, 1); //TODO3: later make narrower when need, eg when folded long lines (alas there is no direct notification). Maybe use timer.
		if (!AaInitUseDefaultContextMenu) Call(SCI_USEPOPUP);
		Call(SCI_SETCARETWIDTH, 2); //not DPI-scaled
		
		//Need to set selection colors or layer, because the default inactive selection color is darker than active.
		//	It is 0x3F808080, but alpha is ignored if SC_LAYER_BASE (default).
		Call(SCI_SETSELECTIONLAYER, SC_LAYER_UNDER_TEXT);
		aaaSetElementColor(SC_ELEMENT_SELECTION_BACK, 0xA0A0A0A0); //use alpha to mix with indicators
		aaaSetElementColor(SC_ELEMENT_SELECTION_INACTIVE_BACK, 0x60A0A0A0);
		aaaSetElementColor(SC_ELEMENT_SELECTION_ADDITIONAL_BACK, 0x60A0A0A0);
		
		if (AaInitWrapVisuals) {
			Call(SCI_SETWRAPVISUALFLAGS, SC_WRAPVISUALFLAG_START | SC_WRAPVISUALFLAG_END);
			Call(SCI_SETWRAPVISUALFLAGSLOCATION, SC_WRAPVISUALFLAGLOC_END_BY_TEXT);
			Call(SCI_SETWRAPINDENTMODE, SC_WRAPINDENT_SAME);
		}
		if (AaWrapLines) {
			Call(SCI_SETWRAPMODE, SC_WRAP_WORD);
		}
		
		//note: cannot set styles here, because later derived class will call aaaStyleClearAll, which sets some special styles.
		
		if (AaInitImages) AaImages = new SciImages(this);
		
		if (FocusManager.GetFocusScope(this) is Window fs && FocusManager.GetFocusedElement(fs) == this && Api.GetFocus() == wParent)
			Api.SetFocus(_w);
		
		AaOnHandleCreated();
		
		_adapter.HandleCreated(); //after derived classes set styles etc
		
		_wndprocScintilla = Api.SetWindowLongPtr(_w, GWL.WNDPROC, Marshal.GetFunctionPointerForDelegate(_wndproc = _WndProc));
		//WPF will subclass this window. It respects the GWL.WNDPROC subclass, but breaks SetWindowSubclass.
		
		return new HandleRef(this, _w.Handle);
	}
	
	void _InitDocument() {
		//these must be set for each document of this Scintilla window
		
		Call(SCI_SETCODEPAGE, Api.CP_UTF8);
		Call(SCI_SETTABWIDTH, 4);
		if (AaInitReadOnlyAlways) {
			Call(SCI_SETREADONLY, 1);
			Call(SCI_SETUNDOCOLLECTION);
		} //else if (_isReadOnly) Call(SCI_SETREADONLY, 1);
	}
	
	protected override void DestroyWindowCore(HandleRef hwnd) {
		WndUtil.DestroyWindow((wnd)hwnd.Handle);
		_w = default;
		_sciPtr = 0;
		_acc?.Dispose(); _acc = null;
		
		//workaround for: never GC-collected if disposed before removing from parent WPF element (shouldn't do it).
		if (this is IKeyboardInputSink iks) {
			Debug_.PrintIf(iks.KeyboardInputSite != null);
			iks.KeyboardInputSite?.Unregister();
		}
		
		//GC.ReRegisterForFinalize(this); //to detect memory leak
	}
	
	//~KScintilla() { print.it("~KScintilla"); } //to detect memory leak. Also enable the GC.ReRegisterForFinalize.
	
	//static PrintMsgOptions s_pmo = new(Api.WM_TIMER, Api.WM_MOUSEMOVE, Api.WM_SETCURSOR, Api.WM_NCHITTEST, Api.WM_PAINT, Api.WM_IME_SETCONTEXT, Api.WM_IME_NOTIFY);
	
	nint _WndProc(wnd w, int msg, nint wp, nint lp) {
		//if (Name == "x") WndUtil.PrintMsg(w, msg, wp, lp);
		//if(Name == "x") WndUtil.PrintMsg(_w, msg, wp, lp, s_pmo);
		
		switch (msg) {
		case Api.WM_SETFOCUS:
			if (!_inOnWmSetFocus) if (_OnWmSetFocus()) return 0;
			break;
		case Api.WM_KILLFOCUS:
			if (_inOnWmSetFocus) return 0;
			break;
		case Api.WM_LBUTTONDOWN or Api.WM_RBUTTONDOWN or Api.WM_MBUTTONDOWN:
			if (Api.GetFocus() != _w) {
				bool setFocus = !AaNoMouseSetFocus.Has(_MouseButton(msg));
				if (setFocus && msg == Api.WM_LBUTTONDOWN && AaInitReadOnlyAlways) { //don't focus if link clicked
					int pos = Call(SCI_CHARPOSITIONFROMPOINTCLOSE, Math2.LoShort(lp), Math2.HiShort(lp));
					if (pos >= 0) {
						if (aaaStyleHotspot(aaaStyleGetAt(pos))) setFocus = false;
						else { //indicator-link?
							uint indic = (uint)Call(SCI_INDICATORALLONFOR, pos);
							for (int i = 0; indic != 0; i++, indic >>>= 1)
								if (0 != (indic & 1) && 0 != Call(SCI_INDICGETHOVERFORE, i))
									setFocus = false;
						}
					}
				}
				if (setFocus) this.Focus();
			}
			break;
		case Api.WM_LBUTTONUP:
			if (AaInitReadOnlyAlways && Api.GetFocus() != _w)
				if (aaaHasSelection) this.Focus();
			break;
		}
		
		static MButtons _MouseButton(int msg) => msg switch { Api.WM_LBUTTONDOWN or Api.WM_LBUTTONUP => MButtons.Left, Api.WM_RBUTTONDOWN or Api.WM_RBUTTONUP => MButtons.Right, Api.WM_MBUTTONDOWN or Api.WM_MBUTTONUP => MButtons.Middle, _ => 0 };
		
		var R = WndProc(w, msg, wp, lp);
		
		switch (msg) {
		case Api.WM_TIMER when wp == 5:
			//Workaround for Scintilla bug: bad scrollbar pos on "open file and go to line".
			//	Scintilla adds scrollbars after ~400 ms. For it uses this timer.
			Api.SCROLLINFO x = new(Api.SIF_POS);
			if (x.Get(w, true)) {
				int line = Call(Sci.SCI_GETFIRSTVISIBLELINE);
				if (x.nPos != line) { x.nPos = line; x.Set(w, true); }
			}
			break;
		}
		
		return R;
	}
	
	protected virtual nint WndProc(wnd w, int msg, nint wp, nint lp) {
		//return CallRetPtr(msg, wp, lp); //no, then Scintilla does not process WM_NCDESTROY
		return Api.CallWindowProc(_wndprocScintilla, w, msg, wp, lp);
	}
	
	protected override IntPtr WndProc(IntPtr hwnd, int msg, IntPtr wParam, IntPtr lParam, ref bool handled) {
		if (msg == Api.WM_GETOBJECT) { //WPF steals it from _WndProc
			handled = true;
			return (_acc ??= new _Accessible(this)).WmGetobject(wParam, lParam);
		}
		return base.WndProc(hwnd, msg, wParam, lParam, ref handled);
	}
	
	protected override void OnDpiChanged(DpiScale oldDpi, DpiScale newDpi) {
		if (!_w.Is0 && newDpi.PixelsPerDip != oldDpi.PixelsPerDip) {
			_dpi = newDpi.PixelsPerInchY.ToInt();
			_MarginWidthsDpiChanged();
		}
		base.OnDpiChanged(oldDpi, newDpi);
	}
	
	#region problems with focus, keyboard, destroying
	
	//Somehow WPF does not care about native control focus, normal keyboard work, destroying, etc.
	//1. No Tab key navigation. Also does not set focus when parent tab item selected.
	//	Workaround: override TabIntoCore and call API SetFocus.
	//2. Does not set logical focus to HwndHost when its native control is really focused. Then eg does not restore real focus after using menu.
	//	Workaround: set focus on WM_LBUTTONDOWN etc. Also on WM_SETFOCUS, with some tricks.
	//3. Steals arrow keys, Tab and Enter from native control and sets focus to other controls or closes dialog.
	//	Workaround: override TranslateAcceleratorCore, pass the keys to the control and return true.
	//4. When closing parent window, does not destroy hwnhosted controls. Instead moves to a hidden parking window, and destroys later on GC if you are careful.
	//	Need to always test whether hwnhosted controls are destroyed on GC, to avoid leaked windows + many managed objects.
	//	Eg to protect wndproc delegate from GC don't add it to a thread-static array until destroyed; let it be a field of the wrapper class.
	//	Or let app dispose the HwndHost in OnClosing. But control itself cannot reliably know when to self-destroy.
	//5. When closing parent window, briefly tries to show native control, and focus if was focused.
	//	Workaround: let app dispose the HwndHost in OnClosing.
	//Never mind: after SetFocus, Keyboard.FocusedElement is null.
	
	bool _OnWmSetFocus() {
		//keep logical focus on HwndHost, else will not work eg restoring of real focus when closing menu.
		if (IsVisible && Focusable) { //info: !IsVisible when closing window without disposing this (WPF bug)
			var fs = FocusManager.GetFocusScope(this);
			if (fs != null && FocusManager.GetFocusedElement(fs) != this) { //focused not by WPF
				_inOnWmSetFocus = true;
				FocusManager.SetFocusedElement(fs, this); //in some cases would work better than this.Focus()
				_inOnWmSetFocus = false;
				//all WPF 'Focus' functions make the main window focused. Then OnGotKeyboardFocus makes _w focused again.
				//	Wndproc receives wm_setfocus, wm_killfocus and wm_setfocus. Passes to scintilla only the last wm_setfocus.
				//	Can prevent this, eg set IsFocusable=false before, but then WPF in some cases does not restore focus after switching windows etc.
				//	To prevent this on click, Wndproc calls Focus, and scintilla does not call SetFocus (mod).
				//	Could not find a way to avoid this in other cases, never mind.
				return true;
			}
		}
		return false;
	}
	bool _inOnWmSetFocus;
	
	//Makes _w focused when called this.Focus() or Keyboard.Focus(this).
	protected override void OnGotKeyboardFocus(KeyboardFocusChangedEventArgs e) {
		e.Handled = true;
		Api.SetFocus(_w);
		base.OnGotKeyboardFocus(e);
	}
	
	//Sets focus when tabbed to this or when clicked the parent tab item. Like eg WPF TextBox.
	protected override bool TabIntoCore(TraversalRequest request) {
		Focus();
		return true;
		//base.TabIntoCore(request); //empty func, returns false
	}
	
	protected override bool TranslateAcceleratorCore(ref System.Windows.Interop.MSG msg, ModifierKeys modifiers) {
		var m = msg.message;
		var k = (KKey)msg.wParam;
		//if (m == Api.WM_KEYDOWN) print.it(m, k);
		if (m is Api.WM_KEYDOWN or Api.WM_KEYUP /*or Api.WM_SYSKEYDOWN or Api.WM_SYSKEYUP*/)
			if (!modifiers.Has(ModifierKeys.Alt)) {
				switch (k) {
				case KKey.Left or KKey.Right or KKey.Up or KKey.Down:
				case KKey.Enter when modifiers == 0 && !aaaIsReadonly:
				case KKey.Tab when !modifiers.Has(ModifierKeys.Control) && !aaaIsReadonly:
					Call(msg.message, msg.wParam, msg.lParam); //not DispatchMessage or Send
					return true;
				case KKey.Insert when modifiers == 0: return true;
				}
			}
		
		return base.TranslateAcceleratorCore(ref msg, modifiers);
	}
	
	//Without this, user cannot type eg character 'a' in HwndHost'ed control if there is button with text like "_Apply".
	protected override bool TranslateCharCore(ref System.Windows.Interop.MSG msg, ModifierKeys modifiers) {
		if (msg.message is not (Api.WM_CHAR or Api.WM_DEADCHAR)) return false; //WM_SYSCHAR etc if with Alt
		if (msg.hwnd != _w.Handle) return false; //WPF bug. Eg when on key down the app makes this control focused.
		if ((int)msg.wParam <= 32) return false; //eg control chars on Ctrl+key
		_w.Send(msg.message, msg.wParam, msg.lParam); //not Call or WndProc
		return true;
	}
	
	#endregion
	
	#endregion
	
	void _NotifyCallback(void* cbParam, ref SCNotification n) {
		try {
			var code = n.code;
			//if(code != NOTIF.SCN_PAINTED) print.qm2.write(code.ToString());
			switch (code) {
			case NOTIF.SCN_MODIFIED:
				var mt = n.modificationType;
				//if(this.Name!= "Output_text") print.it(mt, n.position);
				if (mt.HasAny(MOD.SC_MOD_INSERTTEXT | MOD.SC_MOD_DELETETEXT)) {
					_adapter.TextModified();
					
					bool inserted = mt.Has(MOD.SC_MOD_INSERTTEXT);
					_RdOnModified(inserted, n);
					//AaImages?.OnTextChanged_(inserted, n);
					AaTags?.OnTextChanged_(inserted, n);
				} else if (n.modificationType.Has(Sci.MOD.SC_MOD_BEFOREDELETE)) {
					_DeleteMarkers(ref n);
				}
				//if(mt.Has(MOD.SC_MOD_CHANGEANNOTATION)) ChangedAnnotation?.Invoke(this, ref n);
				if (AaDisableModifiedNotifications) return;
				break;
			case NOTIF.SCN_HOTSPOTRELEASECLICK:
				if (aaaHasSelection) return;
				AaTags?.OnLinkClick_(n.position, 0 != (n.modifiers & SCMOD_CTRL));
				break;
			case NOTIF.SCN_INDICATORRELEASE:
				if (aaaHasSelection) return;
				break;
			}
			AaOnSciNotify(ref n);
		}
		catch (Exception e1) when (!Debugger.IsAttached) {
			//DispatcherUnhandledException not raised on exception here. Let's add handler code here like in App._Main.
			if (1 != dialog.showError("Exception", e1.ToStringWithoutStack(), "1 Continue|2 Exit", DFlags.Wider, _w.Window, e1.ToString()))
				Environment.Exit(1);
		}
	}
	
	/// <summary>
	/// Raises the <see cref="AaNotify"/> event.
	/// </summary>
	protected virtual void AaOnSciNotify(ref SCNotification n) {
		AaNotify?.Invoke(new(this, ref n));
		switch (n.code) {
		case NOTIF.SCN_MODIFIED:
			if (AaTextChanged is { } e && n.modificationType.HasAny(MOD.SC_MOD_INSERTTEXT | MOD.SC_MOD_DELETETEXT)) e(new(this, ref n));
			break;
		}
	}
	
	public ref struct AaEventHandlerArgs {
		public readonly KScintilla c;
		public readonly ref SCNotification n;
		public AaEventHandlerArgs(KScintilla sci, ref SCNotification notif) { c = sci; n = ref notif; }
	}
	
	public delegate void AaEventHandler(AaEventHandlerArgs e);
	
	/// <summary>
	/// Occurs when any Scintilla notification is received.
	/// </summary>
	public event AaEventHandler AaNotify;
	
	/// <summary>
	/// Occurs when text changed (<b>SCN_MODIFIED</b> notification with <b>SC_MOD_INSERTTEXT</b> or <b>SC_MOD_DELETETEXT</b>).
	/// </summary>
	public event AaEventHandler AaTextChanged;
	
	//workaround for: Scintilla does not delete markers of deleted lines. Instead moves to the next or previous line.
	void _DeleteMarkers(ref SCNotification n) {
		int end = n.position + n.length;
		int line1 = aaaLineFromPos(false, n.position), line2 = aaaLineFromPos(false, end);
		if (end == aaaLen8) line2++;
		if (line2 <= line1) return;
		int start1 = aaaLineStart(false, line1);
		if (start1 < n.position) line1++;
		for (int line = line1; line < line2; line++) {
			uint markers = (uint)Call(Sci.SCI_MARKERGET, line); //never mind: no folding markers
			if (markers != 0) AaOnDeletingLineWithMarkers(line, markers);
		}
	}
	
	/// <summary>
	/// Called before deleting a line that contains markers (except folding markers), unless <b>MOD.SC_MOD_BEFOREDELETE</b> notification removed with <b>SCI_SETMODEVENTMASK</b>.
	/// Deletes all these markers; an override can prevent it by not calling the base method.
	/// </summary>
	/// <param name="line"></param>
	/// <param name="markers">See SCI_MARKERGET.</param>
	protected virtual void AaOnDeletingLineWithMarkers(int line, uint markers) {
		for (uint i = 0, m = markers; m != 0; m >>= 1, i++) {
			if ((m & 1) != 0) Call(SCI_MARKERDELETE, line, (int)i);
		}
	}
	
	/// <summary>
	/// Sends a Scintilla message to the control and returns int.
	/// Don't call this function from another thread.
	/// </summary>
	[DebuggerStepThrough]
	public int Call(int sciMessage, nint wParam = 0, nint lParam = 0) => (int)CallRetPtr(sciMessage, wParam, lParam);
	
	/// <summary>
	/// Sends a Scintilla message to the control and returns int.
	/// Don't call this function from another thread.
	/// </summary>
	[DebuggerStepThrough]
	public int Call(int sciMessage, nint wParam, void* lParam) => (int)CallRetPtr(sciMessage, wParam, (nint)lParam);
	
	/// <summary>
	/// Sends a Scintilla message to the control and returns int.
	/// Don't call this function from another thread.
	/// </summary>
	[DebuggerStepThrough]
	public int Call(int sciMessage, nint wParam, bool lParam) => (int)CallRetPtr(sciMessage, wParam, lParam ? 1 : 0);
	
	/// <summary>
	/// Sends a Scintilla message to the control and returns int.
	/// Don't call this function from another thread.
	/// </summary>
	[DebuggerStepThrough]
	public int Call(int sciMessage, bool wParam, nint lParam = 0) => (int)CallRetPtr(sciMessage, wParam ? 1 : 0, lParam);
	
	/// <summary>
	/// Sends a Scintilla message to the control and returns nint.
	/// Don't call this function from another thread.
	/// </summary>
	[DebuggerStepThrough]
	public nint CallRetPtr(int sciMessage, nint wParam = 0, nint lParam = 0) {
#if DEBUG
		if (AaDebugPrintMessages_) _DebugPrintMessage(sciMessage);
		
		Debug.Assert(_sciPtr != 0);
		//0 before creating or after destroying Scintilla window.
		//note: don't auto-create handle. It can be dangerous, create parked control, etc.
		
		Debug.Assert(Environment.CurrentManagedThreadId == _managedThreadId);
		//possible wrong thread eg if an async continuation cannot be executed in correct thread,
		//	probably because there is no WPF SynchronizationContext, eg Application.Run ended on exception.
#else
		if (_sciPtr == 0) throw new InvalidOperationException("KScintilla.CallRetPtr: _sciPtr==null");
		if (Environment.CurrentManagedThreadId != _managedThreadId) throw new InvalidOperationException("KScintilla.CallRetPtr: wrong thread");
#endif
		
		return Sci_Call(_sciPtr, sciMessage, wParam, lParam);
	}
	
#if DEBUG
	static void _DebugPrintMessage(int sciMessage) {
		if (sciMessage < SCI_START) return;
		switch (sciMessage) {
		case SCI_COUNTCODEUNITS:
		case SCI_POSITIONRELATIVECODEUNITS:
		case SCI_CANUNDO:
		case SCI_CANREDO:
		case SCI_GETREADONLY:
		case SCI_GETSELECTIONEMPTY:
			//case SCI_GETTEXTLENGTH:
			return;
		}
		if (s_debugPM == null) {
			s_debugPM = new();
			foreach (var v in typeof(Sci).GetFields()) {
				var s = v.Name;
				//print.it(v.Name);
				if (s.Starts("SCI_")) s_debugPM.Add((int)v.GetRawConstantValue(), s);
			}
		}
		if (!s_debugPM.TryGetValue(sciMessage, out var k)) {
			k = sciMessage.ToString();
		}
		print.qm2.write(k);
	}
	static Dictionary<int, string> s_debugPM;
	
	internal bool AaDebugPrintMessages_ { get; set; }
#endif
	
	#region properties
	
	/// <summary>
	/// Border style.
	/// Must be set before creating control handle.
	/// </summary>
	public bool AaInitBorder { get; set; }
	
	/// <summary>
	/// Use the default Scintilla's context menu.
	/// Must be set before creating control handle.
	/// </summary>
	public bool AaInitUseDefaultContextMenu { get; set; }
	
	/// <summary>
	/// This control is used just to display text, not to edit.
	/// Must be set before creating control handle.
	/// </summary>
	public bool AaInitReadOnlyAlways { get; set; }
	
	/// <summary>
	/// Whether to show images specified in tags like &lt;image "image file path"&gt;, including icons of non-image file types.
	/// Must be set before creating control handle.
	/// If false, <see cref="AaImages"/> property is null.
	/// </summary>
	public bool AaInitImages { get; set; }
	
	/// <summary>
	/// See <see cref="AaInitTagsStyle"/>.
	/// </summary>
	public enum AaTagsStyle {
		/// <summary>Don't support tags. The <see cref="AaTags"/> property is null.</summary>
		NoTags,
		
		/// <summary>Let <see cref="aaaText"/>, aaaSetText and aaaAppendText parse tags when the text has prefix "&lt;&gt;".</summary>
		AutoWithPrefix,
		
		/// <summary>Let <see cref="aaaText"/>, aaaSetText and aaaAppendText parse tags always.</summary>
		AutoAlways,
		
		/// <summary>Tags are parsed only when calling Tags.AddText.</summary>
		User,
	}
	
	/// <summary>
	/// Whether and when supports tags.
	/// Must be set before creating control handle.
	/// </summary>
	public AaTagsStyle AaInitTagsStyle { get; set; }
	
	/// <summary>
	/// Whether to show arrows etc to make wrapped lines more visible.
	/// Must be set before creating control handle.
	/// </summary>
	public bool AaInitWrapVisuals { get; set; } = true;
	
	/// <summary>
	/// Word-wrap.
	/// </summary>
	public bool AaWrapLines {
		get => _wrapLines;
		set {
			if (value != _wrapLines) {
				_wrapLines = value;
				if (!_w.Is0) Call(SCI_SETWRAPMODE, value ? SC_WRAP_WORD : 0);
			}
		}
	}
	bool _wrapLines;
	
	/// <summary>
	/// Whether uses Enter key.
	/// If null (default), false if <see cref="AaInitReadOnlyAlways"/> is true.
	/// </summary>
	public bool? AaUsesEnter { get; set; }
	
	/// <summary>
	/// On SCN_MODIFIED notifications suppress <see cref="AaOnSciNotify"/>, <see cref="AaNotify"/> and <see cref="AaTextChanged"/>.
	/// Use to temporarily disable 'modified' notifications. Never use SCI_SETMODEVENTMASK, because then the control would stop working correctly.
	/// </summary>
	public bool AaDisableModifiedNotifications { get; set; }
	
	/// <summary>
	/// Don't set focus on mouse left/right/middle button down.
	/// </summary>
	public MButtons AaNoMouseSetFocus { get; set; }
	
	#endregion
	
	#region range data
	
	struct _RangeData {
		public int from, to;
		public object data;
	}
	
	List<_RangeData> _rd;
	bool _rdLocked;
	
	/// <summary>
	/// Attaches any data to a range of text. Like a hidden indicator with attached data of any type.
	/// </summary>
	/// <exception cref="InvalidOperationException">Called from <see cref="AaRangeDataRemoved"/>.</exception>
	public void AaRangeDataAdd(bool utf16, Range r, object data) {
		if (_rdLocked) throw new InvalidOperationException("Called from event handler.");
		var (from, to) = aaaNormalizeRange(utf16, r);
		
		_rd ??= new();
		_rd.Add(new() { from = from, to = to, data = data });
	}
	
	/// <summary>
	/// Gets data of type <i>T</i> attached to a range of text with <see cref="AaRangeDataAdd"/> at the specified position.
	/// </summary>
	/// <param name="data">Receives data. Use type <b>object</b> to get data of any type.</param>
	/// <returns>true if <i>pos</i> is in a range added with <see cref="AaRangeDataAdd"/> and the range data type is <i>T</i> (or inherited).</returns>
	/// <exception cref="InvalidOperationException">Called from <see cref="AaRangeDataRemoved"/>.</exception>
	public bool AaRangeDataGet<T>(bool utf16, int pos, out T data) where T : class
		=> AaRangeDataGet(utf16, pos, out data, out _, out _);
	
	/// <summary>
	/// Gets data of type <i>T</i> attached to a range of text with <see cref="AaRangeDataAdd"/> at the specified position.
	/// </summary>
	/// <param name="data">Receives data. Use type <b>object</b> to get data of any type.</param>
	/// <returns>true if <i>pos</i> is in a range added with <see cref="AaRangeDataAdd"/> and the range data type is <i>T</i> (or inherited).</returns>
	/// <exception cref="InvalidOperationException">Called from <see cref="AaRangeDataRemoved"/>.</exception>
	public bool AaRangeDataGet<T>(bool utf16, int pos, out T data, out int from, out int to) where T : class {
		if (_rdLocked) throw new InvalidOperationException("Called from AaRangeDataRemoved.");
		pos = _ParamPos(utf16, pos);
		foreach (ref var v in _rd.AsSpan()) {
			if (pos >= v.from && pos < v.to && v.data is T d) {
				data = d;
				from = v.from;
				to = v.to;
				return true;
			}
		}
		data = null;
		from = 0;
		to = 0;
		return false;
	}
	
	/// <summary>
	/// Gets all datas of type <i>T</i> added with <see cref="AaRangeDataAdd"/>.
	/// </summary>
	/// <returns></returns>
	public IEnumerable<T> AaRangeDataEnum<T>() {
		if (!_rd.NE_()) {
			foreach (var v in _rd) if (v.data is T r) yield return r;
		}
	}
	
	/// <summary>
	/// When a text range registered with <see cref="AaRangeDataAdd"/> removed (when control text changed).
	/// </summary>
	/// <remarks>
	/// The event handler must not modify control text and must not call <b>AaRangeDataX</b> functions.
	/// </remarks>
	public event Action<object> AaRangeDataRemoved;
	
	void _RdOnModified(bool inserted, in SCNotification n) {
		if (_rd.NE_()) return;
		if (_rdLocked) throw new InvalidOperationException("Called from event handler.");
		_rdLocked = true;
		try {
			int start = n.position, end = start + n.length, len = n.length;
			
			if (inserted) {
				foreach (ref var v in _rd.AsSpan()) {
					if (start < v.to) {
						if (start <= v.from) v.from += len;
						v.to += len;
					}
				}
			} else {
				if (start == 0 && aaaLen8 == 0) { //deleted all text
					if (AaRangeDataRemoved != null) foreach (var v in _rd) AaRangeDataRemoved(v.data);
					_rd.Clear();
					return;
				}
				
				System.Collections.BitArray remove = null;
				int j = -1;
				foreach (ref var v in _rd.AsSpan()) {
					j++;
					if (start < v.to) {
						if (end < v.from) {
							v.from -= len;
							v.to -= len;
						} else if (start <= v.from) {
							if (end < v.to) {
								v.to -= len;
								v.from = start;
							} else {
								remove ??= new(_rd.Count);
								remove[j] = true;
								AaRangeDataRemoved?.Invoke(v.data);
							}
						} else if (end < v.to) {
							v.to -= len;
						} else {
							v.to = start;
						}
					}
				}
				
				if (remove != null) {
					for (int i = remove.Count; --i >= 0;) {
						if (remove[i]) _rd.RemoveAt(i);
					}
				}
			}
		}
		finally { _rdLocked = false; }
		
		//print.it("ranges", _rd.Select(o => (o.from, o.to, o.data)));
	}
	
	#endregion
	
	#region acc
	
	_Accessible _acc;
	
	class _Accessible : HwndHostAccessibleBase_ {
		readonly KScintilla _sci;
		
		internal _Accessible(KScintilla sci) : base(sci, sci.AaWnd) {
			_sci = sci;
		}
		
		public override ERole Role(int child) => _sci.AaAccessibleRole;
		
		public override string Name(int child) => _sci.AaAccessibleName;
		
		public override string Description(int child) => _sci.AaAccessibleDescription;
		
		public override string Value(int child) => _sci.AaAccessibleValue;
		
		public override EState State(int child) {
			var r = base.State(child);
			if (_sci.aaaIsReadonly) r |= EState.READONLY;
			return r;
		}
	}
	
	protected virtual ERole AaAccessibleRole => ERole.TEXT;
	
	protected virtual string AaAccessibleName => Name;
	
	protected virtual string AaAccessibleDescription => null;
	
	protected virtual string AaAccessibleValue => AaInitReadOnlyAlways ? aaaText?.Limit(0xffff) : null;
	
	#endregion
}


================================================
FILE: Au.Controls/KScintilla/Sci API.cs
================================================
namespace Au.Controls;

public static unsafe class Sci {
	#region au modifications

	public const int SCI_MARGINSTYLENEXT = 9502;
	public delegate void Sci_NotifyCallback(void* cbParam, ref SCNotification n);
	public const int SCI_SETNOTIFYCALLBACK = 9503;
	public delegate int Sci_AnnotationDrawCallback(void* cbParam, ref Sci_AnnotationDrawCallbackData d);
	public const int SCI_SETANNOTATIONDRAWCALLBACK = 9504;
	public delegate void Sci_MarginDrawCallback(ref Sci_MarginDrawCallbackData d);
	public const int SCI_SETMARGINDRAWCALLBACK = 9505;
	public const int SCI_ISXINMARGIN = 9506;
	public const int SCI_DRAGDROP = 9507;

	public const string SCINTILLA_DLL = "Scintilla.dll";

	[DllImport(SCINTILLA_DLL, EntryPoint = "Scintilla_DirectFunction")]
	public static extern nint Sci_Call(nint sci, int message, nint wParam = 0, nint lParam = 0);

	[DllImport(SCINTILLA_DLL)]
	public static extern int Sci_Range(nint sci, int start8, int end8, out byte* p1, out byte* p2, int* length = null);

	[DllImport(SCINTILLA_DLL)]
	public static extern void Sci_SetFoldLevels(nint sci, int line, int lastLine, int len, int* a);

	public record struct Sci_VisibleRange {
		public int dlineFrom, dlineTo, vlineFrom, vlineTo, posFrom, posTo;
	}

	/// <summary>
	/// flags: 1 need pos
	/// </summary>
	[DllImport(SCINTILLA_DLL)]
	public static extern void Sci_GetVisibleRange(nint sci, out Sci_VisibleRange r);

	//[DllImport("Lexilla.dll", EntryPoint = "CreateLexer")]
	//public static extern nint Sci_CreateLexer(byte[] lexer);

#pragma warning disable 649
	public unsafe struct Sci_AnnotationDrawCallbackData {
		public int step;
		public IntPtr hdc;
		public RECT rect;
		public byte* text;
		public int textLen, line, annotLine;
	};
	public unsafe struct Sci_MarginDrawCallbackData {
		public IntPtr hdc;
		public RECT rect;
		public int margin, firstLine, lastLine;
	};
	public struct Sci_DragDropData {
		public int x, y;
		public byte* text;
		public int len;
		public int copy; //bool
	}
#pragma warning restore 649

	public const int STYLE_HIDDEN = 31; //DEFAULT-1

	#endregion

	public delegate nint SciFnDirectStatus(nint ptr, int iMessage, nint wParam, nint lParam, out int pStatus);

	public const int INVALID_POSITION = -1;
	public const int SCI_START = 2000;
	public const int SCI_OPTIONAL_START = 3000;
	public const int SCI_LEXER_START = 4000;
	public const int SCI_ADDTEXT = 2001;
	public const int SCI_ADDSTYLEDTEXT = 2002;
	public const int SCI_INSERTTEXT = 2003;
	public const int SCI_CHANGEINSERTION = 2672;
	public const int SCI_CLEARALL = 2004;
	public const int SCI_DELETERANGE = 2645;
	public const int SCI_CLEARDOCUMENTSTYLE = 2005;
	public const int SCI_GETLENGTH = 2006;
	public const int SCI_GETCHARAT = 2007;
	public const int SCI_GETCURRENTPOS = 2008;
	public const int SCI_GETANCHOR = 2009;
	//public const int SCI_GETSTYLEAT = 2010; //obsolete, use SCI_GETSTYLEINDEXAT
	public const int SCI_GETSTYLEINDEXAT = 2038;
	public const int SCI_REDO = 2011;
	public const int SCI_SETUNDOCOLLECTION = 2012;
	public const int SCI_SELECTALL = 2013;
	public const int SCI_SETSAVEPOINT = 2014;
	public const int SCI_GETSTYLEDTEXT = 2015;
	public const int SCI_GETSTYLEDTEXTFULL = 2778;
	public const int SCI_CANREDO = 2016;
	public const int SCI_MARKERLINEFROMHANDLE = 2017;
	public const int SCI_MARKERDELETEHANDLE = 2018;
	public const int SCI_MARKERHANDLEFROMLINE = 2732;
	public const int SCI_MARKERNUMBERFROMLINE = 2733;
	public const int SCI_GETUNDOCOLLECTION = 2019;
	public const int SCWS_INVISIBLE = 0;
	public const int SCWS_VISIBLEALWAYS = 1;
	public const int SCWS_VISIBLEAFTERINDENT = 2;
	public const int SCWS_VISIBLEONLYININDENT = 3;
	public const int SCI_GETVIEWWS = 2020;
	public const int SCI_SETVIEWWS = 2021;
	public const int SCTD_LONGARROW = 0;
	public const int SCTD_STRIKEOUT = 1;
	public const int SCI_GETTABDRAWMODE = 2698;
	public const int SCI_SETTABDRAWMODE = 2699;
	public const int SCI_POSITIONFROMPOINT = 2022;
	public const int SCI_POSITIONFROMPOINTCLOSE = 2023;
	public const int SCI_GOTOLINE = 2024;
	public const int SCI_GOTOPOS = 2025;
	public const int SCI_SETANCHOR = 2026;
	public const int SCI_GETCURLINE = 2027;
	public const int SCI_GETENDSTYLED = 2028;
	public const int SC_EOL_CRLF = 0;
	public const int SC_EOL_CR = 1;
	public const int SC_EOL_LF = 2;
	public const int SCI_CONVERTEOLS = 2029;
	public const int SCI_GETEOLMODE = 2030;
	public const int SCI_SETEOLMODE = 2031;
	public const int SCI_STARTSTYLING = 2032;
	public const int SCI_SETSTYLING = 2033;
	public const int SCI_GETBUFFEREDDRAW = 2034;
	public const int SCI_SETBUFFEREDDRAW = 2035;
	public const int SCI_SETTABWIDTH = 2036;
	public const int SCI_GETTABWIDTH = 2121;
	public const int SCI_CLEARTABSTOPS = 2675;
	public const int SCI_ADDTABSTOP = 2676;
	public const int SCI_GETNEXTTABSTOP = 2677;
	public const int SC_CP_UTF8 = 65001;
	public const int SCI_SETCODEPAGE = 2037;
	public const int SCI_SETFONTLOCALE = 2760;
	public const int SCI_GETFONTLOCALE = 2761;
	public const int SC_IME_WINDOWED = 0;
	public const int SC_IME_INLINE = 1;
	public const int SCI_GETIMEINTERACTION = 2678;
	public const int SCI_SETIMEINTERACTION = 2679;
	public const int MARKER_MAX = 31;
	public const int SC_MARK_CIRCLE = 0;
	public const int SC_MARK_ROUNDRECT = 1;
	public const int SC_MARK_ARROW = 2;
	public const int SC_MARK_SMALLRECT = 3;
	public const int SC_MARK_SHORTARROW = 4;
	public const int SC_MARK_EMPTY = 5;
	public const int SC_MARK_ARROWDOWN = 6;
	public const int SC_MARK_MINUS = 7;
	public const int SC_MARK_PLUS = 8;
	public const int SC_MARK_VLINE = 9;
	public const int SC_MARK_LCORNER = 10;
	public const int SC_MARK_TCORNER = 11;
	public const int SC_MARK_BOXPLUS = 12;
	public const int SC_MARK_BOXPLUSCONNECTED = 13;
	public const int SC_MARK_BOXMINUS = 14;
	public const int SC_MARK_BOXMINUSCONNECTED = 15;
	public const int SC_MARK_LCORNERCURVE = 16;
	public const int SC_MARK_TCORNERCURVE = 17;
	public const int SC_MARK_CIRCLEPLUS = 18;
	public const int SC_MARK_CIRCLEPLUSCONNECTED = 19;
	public const int SC_MARK_CIRCLEMINUS = 20;
	public const int SC_MARK_CIRCLEMINUSCONNECTED = 21;
	public const int SC_MARK_BACKGROUND = 22;
	public const int SC_MARK_DOTDOTDOT = 23;
	public const int SC_MARK_ARROWS = 24;
	public const int SC_MARK_PIXMAP = 25;
	public const int SC_MARK_FULLRECT = 26;
	public const int SC_MARK_LEFTRECT = 27;
	public const int SC_MARK_AVAILABLE = 28;
	public const int SC_MARK_UNDERLINE = 29;
	public const int SC_MARK_RGBAIMAGE = 30;
	public const int SC_MARK_BOOKMARK = 31;
	public const int SC_MARK_VERTICALBOOKMARK = 32;
	public const int SC_MARK_BAR = 33;
	public const int SC_MARK_CHARACTER = 10000;
	public const int SC_MARKNUM_HISTORY_REVERTED_TO_ORIGIN = 21;
	public const int SC_MARKNUM_HISTORY_SAVED = 22;
	public const int SC_MARKNUM_HISTORY_MODIFIED = 23;
	public const int SC_MARKNUM_HISTORY_REVERTED_TO_MODIFIED = 24;
	public const int SC_MARKNUM_FOLDEREND = 25;
	public const int SC_MARKNUM_FOLDEROPENMID = 26;
	public const int SC_MARKNUM_FOLDERMIDTAIL = 27;
	public const int SC_MARKNUM_FOLDERTAIL = 28;
	public const int SC_MARKNUM_FOLDERSUB = 29;
	public const int SC_MARKNUM_FOLDER = 30;
	public const int SC_MARKNUM_FOLDEROPEN = 31;
	public const int SC_MASK_HISTORY = 0x01E00000;
	public const int SC_MASK_FOLDERS = unchecked((int)0xFE000000);
	public const int SCI_MARKERDEFINE = 2040;
	public const int SCI_MARKERSETFORE = 2041;
	public const int SCI_MARKERSETBACK = 2042;
	public const int SCI_MARKERSETBACKSELECTED = 2292;
	public const int SCI_MARKERSETFORETRANSLUCENT = 2294;
	public const int SCI_MARKERSETBACKTRANSLUCENT = 2295;
	public const int SCI_MARKERSETBACKSELECTEDTRANSLUCENT = 2296;
	public const int SCI_MARKERSETSTROKEWIDTH = 2297;
	public const int SCI_MARKERENABLEHIGHLIGHT = 2293;
	public const int SCI_MARKERADD = 2043;
	public const int SCI_MARKERDELETE = 2044;
	public const int SCI_MARKERDELETEALL = 2045;
	public const int SCI_MARKERGET = 2046;
	public const int SCI_MARKERNEXT = 2047;
	public const int SCI_MARKERPREVIOUS = 2048;
	public const int SCI_MARKERDEFINEPIXMAP = 2049;
	public const int SCI_MARKERADDSET = 2466;
	public const int SCI_MARKERSETALPHA = 2476;
	public const int SCI_MARKERGETLAYER = 2734;
	public const int SCI_MARKERSETLAYER = 2735;
	public const int SC_MAX_MARGIN = 4;
	public const int SC_MARGIN_SYMBOL = 0;
	public const int SC_MARGIN_NUMBER = 1;
	public const int SC_MARGIN_BACK = 2;
	public const int SC_MARGIN_FORE = 3;
	public const int SC_MARGIN_TEXT = 4;
	public const int SC_MARGIN_RTEXT = 5;
	public const int SC_MARGIN_COLOUR = 6;
	public const int SCI_SETMARGINTYPEN = 2240;
	public const int SCI_GETMARGINTYPEN = 2241;
	public const int SCI_SETMARGINWIDTHN = 2242;
	public const int SCI_GETMARGINWIDTHN = 2243;
	public const int SCI_SETMARGINMASKN = 2244;
	public const int SCI_GETMARGINMASKN = 2245;
	public const int SCI_SETMARGINSENSITIVEN = 2246;
	public const int SCI_GETMARGINSENSITIVEN = 2247;
	public const int SCI_SETMARGINCURSORN = 2248;
	public const int SCI_GETMARGINCURSORN = 2249;
	public const int SCI_SETMARGINBACKN = 2250;
	public const int SCI_GETMARGINBACKN = 2251;
	public const int SCI_SETMARGINS = 2252;
	public const int SCI_GETMARGINS = 2253;
	public const int STYLE_DEFAULT = 32;
	public const int STYLE_LINENUMBER = 33;
	public const int STYLE_BRACELIGHT = 34;
	public const int STYLE_BRACEBAD = 35;
	public const int STYLE_CONTROLCHAR = 36;
	public const int STYLE_INDENTGUIDE = 37;
	public const int STYLE_CALLTIP = 38;
	public const int STYLE_FOLDDISPLAYTEXT = 39;
	public const int STYLE_LASTPREDEFINED = 39;
	public const int STYLE_MAX = 255;
	public const int SC_CHARSET_ANSI = 0;
	public const int SC_CHARSET_DEFAULT = 1;
	public const int SC_CHARSET_BALTIC = 186;
	public const int SC_CHARSET_CHINESEBIG5 = 136;
	public const int SC_CHARSET_EASTEUROPE = 238;
	public const int SC_CHARSET_GB2312 = 134;
	public const int SC_CHARSET_GREEK = 161;
	public const int SC_CHARSET_HANGUL = 129;
	public const int SC_CHARSET_MAC = 77;
	public const int SC_CHARSET_OEM = 255;
	public const int SC_CHARSET_RUSSIAN = 204;
	public const int SC_CHARSET_OEM866 = 866;
	public const int SC_CHARSET_CYRILLIC = 1251;
	public const int SC_CHARSET_SHIFTJIS = 128;
	public const int SC_CHARSET_SYMBOL = 2;
	public const int SC_CHARSET_TURKISH = 162;
	public const int SC_CHARSET_JOHAB = 130;
	public const int SC_CHARSET_HEBREW = 177;
	public const int SC_CHARSET_ARABIC = 178;
	public const int SC_CHARSET_VIETNAMESE = 163;
	public const int SC_CHARSET_THAI = 222;
	public const int SC_CHARSET_8859_15 = 1000;
	public const int SCI_STYLECLEARALL = 2050;
	public const int SCI_STYLESETFORE = 2051;
	public const int SCI_STYLESETBACK = 2052;
	public const int SCI_STYLESETBOLD = 2053;
	public const int SCI_STYLESETITALIC = 2054;
	public const int SCI_STYLESETSIZE = 2055;
	public const int SCI_STYLESETFONT = 2056;
	public const int SCI_STYLESETEOLFILLED = 2057;
	public const int SCI_STYLERESETDEFAULT = 2058;
	public const int SCI_STYLESETUNDERLINE = 2059;
	public const int SC_CASE_MIXED = 0;
	public const int SC_CASE_UPPER = 1;
	public const int SC_CASE_LOWER = 2;
	public const int SC_CASE_CAMEL = 3;
	public const int SCI_STYLEGETFORE = 2481;
	public const int SCI_STYLEGETBACK = 2482;
	public const int SCI_STYLEGETBOLD = 2483;
	public const int SCI_STYLEGETITALIC = 2484;
	public const int SCI_STYLEGETSIZE = 2485;
	public const int SCI_STYLEGETFONT = 2486;
	public const int SCI_STYLEGETEOLFILLED = 2487;
	public const int SCI_STYLEGETUNDERLINE = 2488;
	public const int SCI_STYLEGETCASE = 2489;
	public const int SCI_STYLEGETCHARACTERSET = 2490;
	public const int SCI_STYLEGETVISIBLE = 2491;
	public const int SCI_STYLEGETCHANGEABLE = 2492;
	public const int SCI_STYLEGETHOTSPOT = 2493;
	public const int SCI_STYLESETCASE = 2060;
	public const int SC_FONT_SIZE_MULTIPLIER = 100;
	public const int SCI_STYLESETSIZEFRACTIONAL = 2061;
	public const int SCI_STYLEGETSIZEFRACTIONAL = 2062;
	public const int SC_WEIGHT_NORMAL = 400;
	public const int SC_WEIGHT_SEMIBOLD = 600;
	public const int SC_WEIGHT_BOLD = 700;
	public const int SCI_STYLESETWEIGHT = 2063;
	public const int SCI_STYLEGETWEIGHT = 2064;
	public const int SCI_STYLESETCHARACTERSET = 2066;
	public const int SCI_STYLESETHOTSPOT = 2409;
	public const int SCI_STYLESETCHECKMONOSPACED = 2254;
	public const int SCI_STYLEGETCHECKMONOSPACED = 2255;
	public const int SC_STRETCH_ULTRA_CONDENSED = 1;
	public const int SC_STRETCH_EXTRA_CONDENSED = 2;
	public const int SC_STRETCH_CONDENSED = 3;
	public const int SC_STRETCH_SEMI_CONDENSED = 4;
	public const int SC_STRETCH_NORMAL = 5;
	public const int SC_STRETCH_SEMI_EXPANDED = 6;
	public const int SC_STRETCH_EXPANDED = 7;
	public const int SC_STRETCH_EXTRA_EXPANDED = 8;
	public const int SC_STRETCH_ULTRA_EXPANDED = 9;
	public const int SCI_STYLESETSTRETCH = 2258;
	public const int SCI_STYLEGETSTRETCH = 2259;
	public const int SCI_STYLESETINVISIBLEREPRESENTATION = 2256;
	public const int SCI_STYLEGETINVISIBLEREPRESENTATION = 2257;
	public const int SC_ELEMENT_LIST = 0;
	public const int SC_ELEMENT_LIST_BACK = 1;
	public const int SC_ELEMENT_LIST_SELECTED = 2;
	public const int SC_ELEMENT_LIST_SELECTED_BACK = 3;
	public const int SC_ELEMENT_SELECTION_TEXT = 10;
	public const int SC_ELEMENT_SELECTION_BACK = 11;
	public const int SC_ELEMENT_SELECTION_ADDITIONAL_TEXT = 12;
	public const int SC_ELEMENT_SELECTION_ADDITIONAL_BACK = 13;
	public const int SC_ELEMENT_SELECTION_SECONDARY_TEXT = 14;
	public const int SC_ELEMENT_SELECTION_SECONDARY_BACK = 15;
	public const int SC_ELEMENT_SELECTION_INACTIVE_TEXT = 16;
	public const int SC_ELEMENT_SELECTION_INACTIVE_BACK = 17;
	public const int SC_ELEMENT_SELECTION_INACTIVE_ADDITIONAL_TEXT = 18;
	public const int SC_ELEMENT_SELECTION_INACTIVE_ADDITIONAL_BACK = 19;
	public const int SC_ELEMENT_CARET = 40;
	public const int SC_ELEMENT_CARET_ADDITIONAL = 41;
	public const int SC_ELEMENT_CARET_LINE_BACK = 50;
	public const int SC_ELEMENT_WHITE_SPACE = 60;
	public const int SC_ELEMENT_WHITE_SPACE_BACK = 61;
	public const int SC_ELEMENT_HOT_SPOT_ACTIVE = 70;
	public const int SC_ELEMENT_HOT_SPOT_ACTIVE_BACK = 71;
	public const int SC_ELEMENT_FOLD_LINE = 80;
	public const int SC_ELEMENT_HIDDEN_LINE = 81;
	public const int SCI_SETELEMENTCOLOUR = 2753;
	public const int SCI_GETELEMENTCOLOUR = 2754;
	public const int SCI_RESETELEMENTCOLOUR = 2755;
	public const int SCI_GETELEMENTISSET = 2756;
	public const int SCI_GETELEMENTALLOWSTRANSLUCENT = 2757;
	public const int SCI_GETELEMENTBASECOLOUR = 2758;
	public const int SCI_SETSELFORE = 2067;
	public const int SCI_SETSELBACK = 2068;
	public const int SCI_GETSELALPHA = 2477;
	public const int SCI_SETSELALPHA = 2478;
	public const int SCI_GETSELEOLFILLED = 2479;
	public const int SCI_SETSELEOLFILLED = 2480;
	public const int SC_LAYER_BASE = 0;
	public const int SC_LAYER_UNDER_TEXT = 1;
	public const int SC_LAYER_OVER_TEXT = 2;
	public const int SCI_GETSELECTIONLAYER = 2762;
	public const int SCI_SETSELECTIONLAYER = 2763;
	public const int SCI_GETCARETLINELAYER = 2764;
	public const int SCI_SETCARETLINELAYER = 2765;
	public const int SCI_GETCARETLINEHIGHLIGHTSUBLINE = 2773;
	public const int SCI_SETCARETLINEHIGHLIGHTSUBLINE = 2774;
	public const int SCI_SETCARETFORE = 2069;
	public const int SCI_ASSIGNCMDKEY = 2070;
	public const int SCI_CLEARCMDKEY = 2071;
	public const int SCI_CLEARALLCMDKEYS = 2072;
	public const int SCI_SETSTYLINGEX = 2073;
	public const int SCI_STYLESETVISIBLE = 2074;
	public const int SCI_GETCARETPERIOD = 2075;
	public const int SCI_SETCARETPERIOD = 2076;
	public const int SCI_SETWORDCHARS = 2077;
	public const int SCI_GETWORDCHARS = 2646;
	public const int SCI_SETCHARACTERCATEGORYOPTIMIZATION = 2720;
	public const int SCI_GETCHARACTERCATEGORYOPTIMIZATION = 2721;
	public const int SCI_BEGINUNDOACTION = 2078;
	public const int SCI_ENDUNDOACTION = 2079;
	public const int SCI_GETUNDOSEQUENCE = 2799;
	public const int SCI_GETUNDOACTIONS = 2790;
	public const int SCI_SETUNDOSAVEPOINT = 2791;
	public const int SCI_GETUNDOSAVEPOINT = 2792;
	public const int SCI_SETUNDODETACH = 2793;
	public const int SCI_GETUNDODETACH = 2794;
	public const int SCI_SETUNDOTENTATIVE = 2795;
	public const int SCI_GETUNDOTENTATIVE = 2796;
	public const int SCI_SETUNDOCURRENT = 2797;
	public const int SCI_GETUNDOCURRENT = 2798;
	public const int SCI_PUSHUNDOACTIONTYPE = 2800;
	public const int SCI_CHANGELASTUNDOACTIONTEXT = 2801;
	public const int SCI_GETUNDOACTIONTYPE = 2802;
	public const int SCI_GETUNDOACTIONPOSITION = 2803;
	public const int SCI_GETUNDOACTIONTEXT = 2804;
	public const int INDIC_PLAIN = 0;
	public const int INDIC_SQUIGGLE = 1;
	public const int INDIC_TT = 2;
	public const int INDIC_DIAGONAL = 3;
	public const int INDIC_STRIKE = 4;
	public const int INDIC_HIDDEN = 5;
	public const int INDIC_BOX = 6;
	public const int INDIC_ROUNDBOX = 7;
	public const int INDIC_STRAIGHTBOX = 8;
	public const int INDIC_DASH = 9;
	public const int INDIC_DOTS = 10;
	public const int INDIC_SQUIGGLELOW = 11;
	public const int INDIC_DOTBOX = 12;
	public const int INDIC_SQUIGGLEPIXMAP = 13;
	public const int INDIC_COMPOSITIONTHICK = 14;
	public const int INDIC_COMPOSITIONTHIN = 15;
	public const int INDIC_FULLBOX = 16;
	public const int INDIC_TEXTFORE = 17;
	public const int INDIC_POINT = 18;
	public const int INDIC_POINTCHARACTER = 19;
	public const int INDIC_GRADIENT = 20;
	public const int INDIC_GRADIENTCENTRE = 21;
	public const int INDIC_POINT_TOP = 22;
	public const int INDICATOR_CONTAINER = 8;
	public const int INDICATOR_IME = 32;
	public const int INDICATOR_IME_MAX = 35;
	public const int INDICATOR_HISTORY_REVERTED_TO_ORIGIN_INSERTION = 36;
	public const int INDICATOR_HISTORY_REVERTED_TO_ORIGIN_DELETION = 37;
	public const int INDICATOR_HISTORY_SAVED_INSERTION = 38;
	public const int INDICATOR_HISTORY_SAVED_DELETION = 39;
	public const int INDICATOR_HISTORY_MODIFIED_INSERTION = 40;
	public const int INDICATOR_HISTORY_MODIFIED_DELETION = 41;
	public const int INDICATOR_HISTORY_REVERTED_TO_MODIFIED_INSERTION = 42;
	public const int INDICATOR_HISTORY_REVERTED_TO_MODIFIED_DELETION = 43;
	public const int INDICATOR_MAX = 43;
	//deprecated
	//public const int INDIC_CONTAINER = 8;
	//public const int INDIC_IME = 32;
	//public const int INDIC_IME_MAX = 35;
	//public const int INDIC_MAX = 35;
	//public const int INDIC0_MASK = 0x20;
	//public const int INDIC1_MASK = 0x40;
	//public const int INDIC2_MASK = 0x80;
	//public const int INDICS_MASK = 0xE0;
	public const int SCI_INDICSETSTYLE = 2080;
	public const int SCI_INDICGETSTYLE = 2081;
	public const int SCI_INDICSETFORE = 2082;
	public const int SCI_INDICGETFORE = 2083;
	public const int SCI_INDICSETUNDER = 2510;
	public const int SCI_INDICGETUNDER = 2511;
	public const int SCI_INDICSETHOVERSTYLE = 2680;
	public const int SCI_INDICGETHOVERSTYLE = 2681;
	public const int SCI_INDICSETHOVERFORE = 2682;
	public const int SCI_INDICGETHOVERFORE = 2683;
	public const int SC_INDICVALUEBIT = 0x1000000;
	public const int SC_INDICVALUEMASK = 0xFFFFFF;
	public const int SC_INDICFLAG_NONE = 0;
	public const int SC_INDICFLAG_VALUEFORE = 1;
	public const int SCI_INDICSETFLAGS = 2684;
	public const int SCI_INDICGETFLAGS = 2685;
	public const int SCI_INDICSETSTROKEWIDTH = 2751;
	public const int SCI_INDICGETSTROKEWIDTH = 2752;
	public const int SCI_SETWHITESPACEFORE = 2084;
	public const int SCI_SETWHITESPACEBACK = 2085;
	public const int SCI_SETWHITESPACESIZE = 2086;
	public const int SCI_GETWHITESPACESIZE = 2087;
	//deprecated
	//public const int SCI_SETSTYLEBITS = 2090;
	//public const int SCI_GETSTYLEBITS = 2091;
	public const int SCI_SETLINESTATE = 2092;
	public const int SCI_GETLINESTATE = 2093;
	public const int SCI_GETMAXLINESTATE = 2094;
	public const int SCI_GETCARETLINEVISIBLE = 2095;
	public const int SCI_SETCARETLINEVISIBLE = 2096;
	public const int SCI_GETCARETLINEBACK = 2097;
	public const int SCI_SETCARETLINEBACK = 2098;
	public const int SCI_GETCARETLINEFRAME = 2704;
	public const int SCI_SETCARETLINEFRAME = 2705;
	public const int SCI_STYLESETCHANGEABLE = 2099;
	public const int SCI_AUTOCSHOW = 2100;
	public const int SCI_AUTOCCANCEL = 2101;
	public const int SCI_AUTOCACTIVE = 2102;
	public const int SCI_AUTOCPOSSTART = 2103;
	public const int SCI_AUTOCCOMPLETE = 2104;
	public const int SCI_AUTOCSTOPS = 2105;
	public const int SCI_AUTOCSETSEPARATOR = 2106;
	public const int SCI_AUTOCGETSEPARATOR = 2107;
	public const int SCI_AUTOCSELECT = 2108;
	public const int SCI_AUTOCSETCANCELATSTART = 2110;
	public const int SCI_AUTOCGETCANCELATSTART = 2111;
	public const int SCI_AUTOCSETFILLUPS = 2112;
	public const int SCI_AUTOCSETCHOOSESINGLE = 2113;
	public const int SCI_AUTOCGETCHOOSESINGLE = 2114;
	public const int SCI_AUTOCSETIGNORECASE = 2115;
	public const int SCI_AUTOCGETIGNORECASE = 2116;
	public const int SCI_USERLISTSHOW = 2117;
	public const int SCI_AUTOCSETAUTOHIDE = 2118;
	public const int SCI_AUTOCGETAUTOHIDE = 2119;
	public const int SC_AUTOCOMPLETE_NORMAL = 0;
	public const int SC_AUTOCOMPLETE_FIXED_SIZE = 1;
	public const int SC_AUTOCOMPLETE_SELECT_FIRST_ITEM = 2;
	public const int SCI_AUTOCSETOPTIONS = 2638;
	public const int SCI_AUTOCGETOPTIONS = 2639;
	public const int SCI_AUTOCSETDROPRESTOFWORD = 2270;
	public const int SCI_AUTOCGETDROPRESTOFWORD = 2271;
	public const int SCI_REGISTERIMAGE = 2405;
	public const int SCI_CLEARREGISTEREDIMAGES = 2408;
	public const int SCI_AUTOCGETTYPESEPARATOR = 2285;
	public const int SCI_AUTOCSETTYPESEPARATOR = 2286;
	public const int SCI_AUTOCSETMAXWIDTH = 2208;
	public const int SCI_AUTOCGETMAXWIDTH = 2209;
	public const int SCI_AUTOCSETMAXHEIGHT = 2210;
	public const int SCI_AUTOCGETMAXHEIGHT = 2211;
	public const int SCI_AUTOCSETSTYLE = 2109;
	public const int SCI_AUTOCGETSTYLE = 2120;
	public const int SCI_AUTOCSETIMAGESCALE = 2815;
	public const int SCI_AUTOCGETIMAGESCALE = 2816;
	public const int SCI_SETINDENT = 2122;
	public const int SCI_GETINDENT = 2123;
	public const int SCI_SETUSETABS = 2124;
	public const int SCI_GETUSETABS = 2125;
	public const int SCI_SETLINEINDENTATION = 2126;
	public const int SCI_GETLINEINDENTATION = 2127;
	public const int SCI_GETLINEINDENTPOSITION = 2128;
	public const int SCI_GETCOLUMN = 2129;
	public const int SCI_COUNTCHARACTERS = 2633;
	public const int SCI_COUNTCODEUNITS = 2715;
	public const int SCI_SETHSCROLLBAR = 2130;
	public const int SCI_GETHSCROLLBAR = 2131;
	public const int SC_IV_NONE = 0;
	public const int SC_IV_REAL = 1;
	public const int SC_IV_LOOKFORWARD = 2;
	public const int SC_IV_LOOKBOTH = 3;
	public const int SCI_SETINDENTATIONGUIDES = 2132;
	public const int SCI_GETINDENTATIONGUIDES = 2133;
	public const int SCI_SETHIGHLIGHTGUIDE = 2134;
	public const int SCI_GETHIGHLIGHTGUIDE = 2135;
	public const int SCI_GETLINEENDPOSITION = 2136;
	public const int SCI_GETCODEPAGE = 2137;
	public const int SCI_GETCARETFORE = 2138;
	public const int SCI_GETREADONLY = 2140;
	public const int SCI_SETCURRENTPOS = 2141;
	public const int SCI_SETSELECTIONSTART = 2142;
	public const int SCI_GETSELECTIONSTART = 2143;
	public const int SCI_SETSELECTIONEND = 2144;
	public const int SCI_GETSELECTIONEND = 2145;
	public const int SCI_SETEMPTYSELECTION = 2556;
	public const int SCI_SETPRINTMAGNIFICATION = 2146;
	public const int SCI_GETPRINTMAGNIFICATION = 2147;
	public const int SC_PRINT_NORMAL = 0;
	public const int SC_PRINT_INVERTLIGHT = 1;
	public const int SC_PRINT_BLACKONWHITE = 2;
	public const int SC_PRINT_COLOURONWHITE = 3;
	public const int SC_PRINT_COLOURONWHITEDEFAULTBG = 4;
	public const int SC_PRINT_SCREENCOLOURS = 5;
	public const int SCI_SETPRINTCOLOURMODE = 2148;
	public const int SCI_GETPRINTCOLOURMODE = 2149;
	public const int SCFIND_WHOLEWORD = 0x2;
	public const int SCFIND_MATCHCASE = 0x4;
	public const int SCFIND_WORDSTART = 0x00100000;
	public const int SCFIND_REGEXP = 0x00200000;
	public const int SCFIND_POSIX = 0x00400000;
	public const int SCFIND_CXX11REGEX = 0x00800000;
	public const int SCI_FINDTEXT = 2150;
	public const int SCI_FINDTEXTFULL = 2196;
	public const int SCI_FORMATRANGE = 2151;
	public const int SCI_FORMATRANGEFULL = 2777;
	public const int SC_CHANGE_HISTORY_DISABLED = 0;
	public const int SC_CHANGE_HISTORY_ENABLED = 1;
	public const int SC_CHANGE_HISTORY_MARKERS = 2;
	public const int SC_CHANGE_HISTORY_INDICATORS = 4;
	public const int SCI_SETCHANGEHISTORY = 2780;
	public const int SCI_GETCHANGEHISTORY = 2781;
	public const int SC_UNDO_SELECTION_HISTORY_DISABLED = 0;
	public const int SC_UNDO_SELECTION_HISTORY_ENABLED = 1;
	public const int SC_UNDO_SELECTION_HISTORY_SCROLL = 2;
	public const int SCI_SETUNDOSELECTIONHISTORY = 2782;
	public const int SCI_GETUNDOSELECTIONHISTORY = 2783;
	public const int SCI_SETSELECTIONSERIALIZED = 2784;
	public const int SCI_GETSELECTIONSERIALIZED = 2785;
	public const int SCI_GETFIRSTVISIBLELINE = 2152;
	public const int SCI_GETLINE = 2153;
	public const int SCI_GETLINECOUNT = 2154;
	public const int SCI_ALLOCATELINES = 2089;
	public const int SCI_SETMARGINLEFT = 2155;
	public const int SCI_GETMARGINLEFT = 2156;
	public const int SCI_SETMARGINRIGHT = 2157;
	public const int SCI_GETMARGINRIGHT = 2158;
	public const int SCI_GETMODIFY = 2159;
	public const int SCI_SETSEL = 2160;
	public const int SCI_GETSELTEXT = 2161;
	public const int SCI_GETTEXTRANGE = 2162;
	public const int SCI_GETTEXTRANGEFULL = 2039;
	public const int SCI_HIDESELECTION = 2163;
	public const int SCI_GETSELECTIONHIDDEN = 2088;
	public const int SCI_POINTXFROMPOSITION = 2164;
	public const int SCI_POINTYFROMPOSITION = 2165;
	public const int SCI_LINEFROMPOSITION = 2166;
	public const int SCI_POSITIONFROMLINE = 2167;
	public const int SCI_LINESCROLL = 2168;
	public const int SCI_SCROLLVERTICAL = 2817;
	public const int SCI_SCROLLCARET = 2169;
	public const int SCI_SCROLLRANGE = 2569;
	public const int SCI_REPLACESEL = 2170;
	public const int SCI_SETREADONLY = 2171;
	public const int SCI_NULL = 2172;
	public const int SCI_CANPASTE = 2173;
	public const int SCI_CANUNDO = 2174;
	public const int SCI_EMPTYUNDOBUFFER = 2175;
	public const int SCI_UNDO = 2176;
	public const int SCI_CUT = 2177;
	public const int SCI_COPY = 2178;
	public const int SCI_PASTE = 2179;
	public const int SCI_CLEAR = 2180;
	public const int SCI_SETTEXT = 2181;
	public const int SCI_GETTEXT = 2182;
	public const int SCI_GETTEXTLENGTH = 2183;
	public const int SCI_GETDIRECTFUNCTION = 2184;
	public const int SCI_GETDIRECTSTATUSFUNCTION = 2772;
	public const int SCI_GETDIRECTPOINTER = 2185;
	public const int SCI_SETOVERTYPE = 2186;
	public const int SCI_GETOVERTYPE = 2187;
	public const int SCI_SETCARETWIDTH = 2188;
	public const int SCI_GETCARETWIDTH = 2189;
	public const int SCI_SETTARGETSTART = 2190;
	public const int SCI_GETTARGETSTART = 2191;
	public const int SCI_SETTARGETEND = 2192;
	public const int SCI_GETTARGETEND = 2193;
	public const int SCI_SETTARGETRANGE = 2686;
	public const int SCI_GETTARGETTEXT = 2687;
	public const int SCI_TARGETFROMSELECTION = 2287;
	public const int SCI_TARGETWHOLEDOCUMENT = 2690;
	public const int SCI_REPLACETARGET = 2194;
	public const int SCI_REPLACETARGETRE = 2195;
	public const int SCI_REPLACETARGETMINIMAL = 2779;
	public const int SCI_SEARCHINTARGET = 2197;
	public const int SCI_SETSEARCHFLAGS = 2198;
	public const int SCI_GETSEARCHFLAGS = 2199;
	public const int SCI_CALLTIPSHOW = 2200;
	public const int SCI_CALLTIPCANCEL = 2201;
	public const int SCI_CALLTIPACTIVE = 2202;
	public const int SCI_CALLTIPPOSSTART = 2203;
	public const int SCI_CALLTIPSETPOSSTART = 2214;
	public const int SCI_CALLTIPSETHLT = 2204;
	public const int SCI_CALLTIPSETBACK = 2205;
	public const int SCI_CALLTIPSETFORE = 2206;
	public const int SCI_CALLTIPSETFOREHLT = 2207;
	public const int SCI_CALLTIPUSESTYLE = 2212;
	public const int SCI_CALLTIPSETPOSITION = 2213;
	public const int SCI_VISIBLEFROMDOCLINE = 2220;
	public const int SCI_DOCLINEFROMVISIBLE = 2221;
	public const int SCI_WRAPCOUNT = 2235;
	public const int SC_FOLDLEVELNONE = 0x0;
	public const int SC_FOLDLEVELBASE = 0x400;
	public const int SC_FOLDLEVELWHITEFLAG = 0x1000;
	public const int SC_FOLDLEVELHEADERFLAG = 0x2000;
	public const int SC_FOLDLEVELNUMBERMASK = 0x0FFF;
	public const int SCI_SETFOLDLEVEL = 2222;
	public const int SCI_GETFOLDLEVEL = 2223;
	public const int SCI_GETLASTCHILD = 2224;
	public const int SCI_GETFOLDPARENT = 2225;
	public const int SCI_SHOWLINES = 2226;
	public const int SCI_HIDELINES = 2227;
	public const int SCI_GETLINEVISIBLE = 2228;
	public const int SCI_GETALLLINESVISIBLE = 2236;
	public const int SCI_SETFOLDEXPANDED = 2229;
	public const int SCI_GETFOLDEXPANDED = 2230;
	public const int SCI_TOGGLEFOLD = 2231;
	public const int SCI_TOGGLEFOLDSHOWTEXT = 2700;
	public const int SC_FOLDDISPLAYTEXT_HIDDEN = 0;
	public const int SC_FOLDDISPLAYTEXT_STANDARD = 1;
	public const int SC_FOLDDISPLAYTEXT_BOXED = 2;
	public const int SCI_FOLDDISPLAYTEXTSETSTYLE = 2701;
	public const int SCI_FOLDDISPLAYTEXTGETSTYLE = 2707;
	public const int SCI_SETDEFAULTFOLDDISPLAYTEXT = 2722;
	public const int SCI_GETDEFAULTFOLDDISPLAYTEXT = 2723;
	public const int SC_FOLDACTION_CONTRACT = 0;
	public const int SC_FOLDACTION_EXPAND = 1;
	public const int SC_FOLDACTION_TOGGLE = 2;
	public const int SC_FOLDACTION_CONTRACT_EVERY_LEVEL = 4;
	public const int SCI_FOLDLINE = 2237;
	public const int SCI_FOLDCHILDREN = 2238;
	public const int SCI_EXPANDCHILDREN = 2239;
	public const int SCI_FOLDALL = 2662;
	public const int SCI_ENSUREVISIBLE = 2232;
	public const int SC_AUTOMATICFOLD_NONE = 0x0000;
	public const int SC_AUTOMATICFOLD_SHOW = 0x0001;
	public const int SC_AUTOMATICFOLD_CLICK = 0x0002;
	public const int SC_AUTOMATICFOLD_CHANGE = 0x0004;
	public const int SCI_SETAUTOMATICFOLD = 2663;
	public const int SCI_GETAUTOMATICFOLD = 2664;
	public const int SC_FOLDFLAG_NONE = 0x0000;
	public const int SC_FOLDFLAG_LINEBEFORE_EXPANDED = 0x0002;
	public const int SC_FOLDFLAG_LINEBEFORE_CONTRACTED = 0x0004;
	public const int SC_FOLDFLAG_LINEAFTER_EXPANDED = 0x0008;
	public const int SC_FOLDFLAG_LINEAFTER_CONTRACTED = 0x0010;
	public const int SC_FOLDFLAG_LEVELNUMBERS = 0x0040;
	public const int SC_FOLDFLAG_LINESTATE = 0x0080;
	public const int SCI_SETFOLDFLAGS = 2233;
	public const int SCI_ENSUREVISIBLEENFORCEPOLICY = 2234;
	public const int SCI_SETTABINDENTS = 2260;
	public const int SCI_GETTABINDENTS = 2261;
	public const int SCI_SETBACKSPACEUNINDENTS = 2262;
	public const int SCI_GETBACKSPACEUNINDENTS = 2263;
	public const int SC_TIME_FOREVER = 10000000;
	public const int SCI_SETMOUSEDWELLTIME = 2264;
	public const int SCI_GETMOUSEDWELLTIME = 2265;
	public const int SCI_WORDSTARTPOSITION = 2266;
	public const int SCI_WORDENDPOSITION = 2267;
	public const int SCI_ISRANGEWORD = 2691;
	public const int SC_IDLESTYLING_NONE = 0;
	public const int SC_IDLESTYLING_TOVISIBLE = 1;
	public const int SC_IDLESTYLING_AFTERVISIBLE = 2;
	public const int SC_IDLESTYLING_ALL = 3;
	public const int SCI_SETIDLESTYLING = 2692;
	public const int SCI_GETIDLESTYLING = 2693;
	public const int SC_WRAP_NONE = 0;
	public const int SC_WRAP_WORD = 1;
	public const int SC_WRAP_CHAR = 2;
	public const int SC_WRAP_WHITESPACE = 3;
	public const int SCI_SETWRAPMODE = 2268;
	public const int SCI_GETWRAPMODE = 2269;
	public const int SC_WRAPVISUALFLAG_NONE = 0x0000;
	public const int SC_WRAPVISUALFLAG_END = 0x0001;
	public const int SC_WRAPVISUALFLAG_START = 0x0002;
	public const int SC_WRAPVISUALFLAG_MARGIN = 0x0004;
	public const int SCI_SETWRAPVISUALFLAGS = 2460;
	public const int SCI_GETWRAPVISUALFLAGS = 2461;
	public const int SC_WRAPVISUALFLAGLOC_DEFAULT = 0x0000;
	public const int SC_WRAPVISUALFLAGLOC_END_BY_TEXT = 0x0001;
	public const int SC_WRAPVISUALFLAGLOC_START_BY_TEXT = 0x0002;
	public const int SCI_SETWRAPVISUALFLAGSLOCATION = 2462;
	public const int SCI_GETWRAPVISUALFLAGSLOCATION = 2463;
	public const int SCI_SETWRAPSTARTINDENT = 2464;
	public const int SCI_GETWRAPSTARTINDENT = 2465;
	public const int SC_WRAPINDENT_FIXED = 0;
	public const int SC_WRAPINDENT_SAME = 1;
	public const int SC_WRAPINDENT_INDENT = 2;
	public const int SC_WRAPINDENT_DEEPINDENT = 3;
	public const int SCI_SETWRAPINDENTMODE = 2472;
	public const int SCI_GETWRAPINDENTMODE = 2473;
	public const int SC_CACHE_NONE = 0;
	public const int SC_CACHE_CARET = 1;
	public const int SC_CACHE_PAGE = 2;
	public const int SC_CACHE_DOCUMENT = 3;
	public const int SCI_SETLAYOUTCACHE = 2272;
	public const int SCI_GETLAYOUTCACHE = 2273;
	public const int SCI_SETSCROLLWIDTH = 2274;
	public const int SCI_GETSCROLLWIDTH = 2275;
	public const int SCI_SETSCROLLWIDTHTRACKING = 2516;
	public const int SCI_GETSCROLLWIDTHTRACKING = 2517;
	public const int SCI_TEXTWIDTH = 2276;
	public const int SCI_SETENDATLASTLINE = 2277;
	public const int SCI_GETENDATLASTLINE = 2278;
	public const int SCI_TEXTHEIGHT = 2279;
	public const int SCI_SETVSCROLLBAR = 2280;
	public const int SCI_GETVSCROLLBAR = 2281;
	public const int SCI_APPENDTEXT = 2282;
	public const int SC_PHASES_ONE = 0;
	public const int SC_PHASES_TWO = 1;
	public const int SC_PHASES_MULTIPLE = 2;
	public const int SCI_GETPHASESDRAW = 2673;
	public const int SCI_SETPHASESDRAW = 2674;
	public const int SC_EFF_QUALITY_MASK = 0xF;
	public const int SC_EFF_QUALITY_DEFAULT = 0;
	public const int SC_EFF_QUALITY_NON_ANTIALIASED = 1;
	public const int SC_EFF_QUALITY_ANTIALIASED = 2;
	public const int SC_EFF_QUALITY_LCD_OPTIMIZED = 3;
	public const int SCI_SETFONTQUALITY = 2611;
	public const int SCI_GETFONTQUALITY = 2612;
	public const int SCI_SETFIRSTVISIBLELINE = 2613;
	public const int SC_MULTIPASTE_ONCE = 0;
	public const int SC_MULTIPASTE_EACH = 1;
	public const int SCI_SETMULTIPASTE = 2614;
	public const int SCI_GETMULTIPASTE = 2615;
	public const int SCI_GETTAG = 2616;
	public const int SCI_LINESJOIN = 2288;
	public const int SCI_LINESSPLIT = 2289;
	public const int SCI_SETFOLDMARGINCOLOUR = 2290;
	public const int SCI_SETFOLDMARGINHICOLOUR = 2291;
	public const int SC_ACCESSIBILITY_DISABLED = 0;
	public const int SC_ACCESSIBILITY_ENABLED = 1;
	public const int SCI_SETACCESSIBILITY = 2702;
	public const int SCI_GETACCESSIBILITY = 2703;
	public const int SCI_LINEDOWN = 2300;
	public const int SCI_LINEDOWNEXTEND = 2301;
	public const int SCI_LINEUP = 2302;
	public const int SCI_LINEUPEXTEND = 2303;
	public const int SCI_CHARLEFT = 2304;
	public const int SCI_CHARLEFTEXTEND = 2305;
	public const int SCI_CHARRIGHT = 2306;
	public const int SCI_CHARRIGHTEXTEND = 2307;
	public const int SCI_WORDLEFT = 2308;
	public const int SCI_WORDLEFTEXTEND = 2309;
	public const int SCI_WORDRIGHT = 2310;
	public const int SCI_WORDRIGHTEXTEND = 2311;
	public const int SCI_HOME = 2312;
	public const int SCI_HOMEEXTEND = 2313;
	public const int SCI_LINEEND = 2314;
	public const int SCI_LINEENDEXTEND = 2315;
	public const int SCI_DOCUMENTSTART = 2316;
	public const int SCI_DOCUMENTSTARTEXTEND = 2317;
	public const int SCI_DOCUMENTEND = 2318;
	public const int SCI_DOCUMENTENDEXTEND = 2319;
	public const int SCI_PAGEUP = 2320;
	public const int SCI_PAGEUPEXTEND = 2321;
	public const int SCI_PAGEDOWN = 2322;
	public const int SCI_PAGEDOWNEXTEND = 2323;
	public const int SCI_EDITTOGGLEOVERTYPE = 2324;
	public const int SCI_CANCEL = 2325;
	public const int SCI_DELETEBACK = 2326;
	public const int SCI_TAB = 2327;
	public const int SCI_LINEINDENT = 2813;
	public const int SCI_BACKTAB = 2328;
	public const int SCI_LINEDEDENT = 2814;
	public const int SCI_NEWLINE = 2329;
	public const int SCI_FORMFEED = 2330;
	public const int SCI_VCHOME = 2331;
	public const int SCI_VCHOMEEXTEND = 2332;
	public const int SCI_ZOOMIN = 2333;
	public const int SCI_ZOOMOUT = 2334;
	public const int SCI_DELWORDLEFT = 2335;
	public const int SCI_DELWORDRIGHT = 2336;
	public const int SCI_DELWORDRIGHTEND = 2518;
	public const int SCI_LINECUT = 2337;
	public const int SCI_LINEDELETE = 2338;
	public const int SCI_LINETRANSPOSE = 2339;
	public const int SCI_LINEREVERSE = 2354;
	public const int SCI_LINEDUPLICATE = 2404;
	public const int SCI_LOWERCASE = 2340;
	public const int SCI_UPPERCASE = 2341;
	public const int SCI_LINESCROLLDOWN = 2342;
	public const int SCI_LINESCROLLUP = 2343;
	public const int SCI_DELETEBACKNOTLINE = 2344;
	public const int SCI_HOMEDISPLAY = 2345;
	public const int SCI_HOMEDISPLAYEXTEND = 2346;
	public const int SCI_LINEENDDISPLAY = 2347;
	public const int SCI_LINEENDDISPLAYEXTEND = 2348;
	public const int SCI_HOMEWRAP = 2349;
	public const int SCI_HOMEWRAPEXTEND = 2450;
	public const int SCI_LINEENDWRAP = 2451;
	public const int SCI_LINEENDWRAPEXTEND = 2452;
	public const int SCI_VCHOMEWRAP = 2453;
	public const int SCI_VCHOMEWRAPEXTEND = 2454;
	public const int SCI_LINECOPY = 2455;
	public const int SCI_MOVECARETINSIDEVIEW = 2401;
	public const int SCI_LINELENGTH = 2350;
	public const int SCI_BRACEHIGHLIGHT = 2351;
	public const int SCI_BRACEHIGHLIGHTINDICATOR = 2498;
	public const int SCI_BRACEBADLIGHT = 2352;
	public const int SCI_BRACEBADLIGHTINDICATOR = 2499;
	public const int SCI_BRACEMATCH = 2353;
	public const int SCI_BRACEMATCHNEXT = 2369;
	public const int SCI_GETVIEWEOL = 2355;
	public const int SCI_SETVIEWEOL = 2356;
	public const int SCI_GETDOCPOINTER = 2357;
	public const int SCI_SETDOCPOINTER = 2358;
	public const int SCI_SETMODEVENTMASK = 2359;
	public const int EDGE_NONE = 0;
	public const int EDGE_LINE = 1;
	public const int EDGE_BACKGROUND = 2;
	public const int EDGE_MULTILINE = 3;
	public const int SCI_GETEDGECOLUMN = 2360;
	public const int SCI_SETEDGECOLUMN = 2361;
	public const int SCI_GETEDGEMODE = 2362;
	public const int SCI_SETEDGEMODE = 2363;
	public const int SCI_GETEDGECOLOUR = 2364;
	public const int SCI_SETEDGECOLOUR = 2365;
	public const int SCI_MULTIEDGEADDLINE = 2694;
	public const int SCI_MULTIEDGECLEARALL = 2695;
	public const int SCI_GETMULTIEDGECOLUMN = 2749;
	public const int SCI_SEARCHANCHOR = 2366;
	public const int SCI_SEARCHNEXT = 2367;
	public const int SCI_SEARCHPREV = 2368;
	public const int SCI_LINESONSCREEN = 2370;
	public const int SC_POPUP_NEVER = 0;
	public const int SC_POPUP_ALL = 1;
	public const int SC_POPUP_TEXT = 2;
	public const int SCI_USEPOPUP = 2371;
	public const int SCI_SELECTIONISRECTANGLE = 2372;
	public const int SCI_SETZOOM = 2373;
	public const int SCI_GETZOOM = 2374;
	public const int SC_DOCUMENTOPTION_DEFAULT = 0;
	public const int SC_DOCUMENTOPTION_STYLES_NONE = 0x1;
	public const int SC_DOCUMENTOPTION_TEXT_LARGE = 0x100;
	public const int SCI_CREATEDOCUMENT = 2375;
	public const int SCI_ADDREFDOCUMENT = 2376;
	public const int SCI_RELEASEDOCUMENT = 2377;
	public const int SCI_GETDOCUMENTOPTIONS = 2379;
	public const int SCI_GETMODEVENTMASK = 2378;
	public const int SCI_SETCOMMANDEVENTS = 2717;
	public const int SCI_GETCOMMANDEVENTS = 2718;
	public const int SCI_SETFOCUS = 2380;
	public const int SCI_GETFOCUS = 2381;
	public const int SC_STATUS_OK = 0;
	public const int SC_STATUS_FAILURE = 1;
	public const int SC_STATUS_BADALLOC = 2;
	public const int SC_STATUS_WARN_START = 1000;
	public const int SC_STATUS_WARN_REGEX = 1001;
	public const int SCI_SETSTATUS = 2382;
	public const int SCI_GETSTATUS = 2383;
	public const int SCI_SETMOUSEDOWNCAPTURES = 2384;
	public const int SCI_GETMOUSEDOWNCAPTURES = 2385;
	public const int SCI_SETMOUSEWHEELCAPTURES = 2696;
	public const int SCI_GETMOUSEWHEELCAPTURES = 2697;
	public const int SC_CURSORNORMAL = -1;
	public const int SC_CURSORARROW = 2;
	public const int SC_CURSORWAIT = 4;
	public const int SC_CURSORREVERSEARROW = 7;
	public const int SCI_SETCURSOR = 2386;
	public const int SCI_GETCURSOR = 2387;
	public const int SCI_SETCONTROLCHARSYMBOL = 2388;
	public const int SCI_GETCONTROLCHARSYMBOL = 2389;
	public const int SCI_WORDPARTLEFT = 2390;
	public const int SCI_WORDPARTLEFTEXTEND = 2391;
	public const int SCI_WORDPARTRIGHT = 2392;
	public const int SCI_WORDPARTRIGHTEXTEND = 2393;
	public const int VISIBLE_SLOP = 0x01;
	public const int VISIBLE_STRICT = 0x04;
	public const int SCI_SETVISIBLEPOLICY = 2394;
	public const int SCI_DELLINELEFT = 2395;
	public const int SCI_DELLINERIGHT = 2396;
	public const int SCI_SETXOFFSET = 2397;
	public const int SCI_GETXOFFSET = 2398;
	public const int SCI_CHOOSECARETX = 2399;
	public const int SCI_GRABFOCUS = 2400;
	public const int CARET_SLOP = 0x01;
	public const int CARET_STRICT = 0x04;
	public const int CARET_JUMPS = 0x10;
	public const int CARET_EVEN = 0x08;
	public const int SCI_SETXCARETPOLICY = 2402;
	public const int SCI_SETYCARETPOLICY = 2403;
	public const int SCI_SETPRINTWRAPMODE = 2406;
	public const int SCI_GETPRINTWRAPMODE = 2407;
	public const int SCI_SETHOTSPOTACTIVEFORE = 2410;
	public const int SCI_GETHOTSPOTACTIVEFORE = 2494;
	public const int SCI_SETHOTSPOTACTIVEBACK = 2411;
	public const int SCI_GETHOTSPOTACTIVEBACK = 2495;
	public const int SCI_SETHOTSPOTACTIVEUNDERLINE = 2412;
	public const int SCI_GETHOTSPOTACTIVEUNDERLINE = 2496;
	public const int SCI_SETHOTSPOTSINGLELINE = 2421;
	public const int SCI_GETHOTSPOTSINGLELINE = 2497;
	public const int SCI_PARADOWN = 2413;
	public const int SCI_PARADOWNEXTEND = 2414;
	public const int SCI_PARAUP = 2415;
	public const int SCI_PARAUPEXTEND = 2416;
	public const int SCI_POSITIONBEFORE = 2417;
	public const int SCI_POSITIONAFTER = 2418;
	public const int SCI_POSITIONRELATIVE = 2670;
	public const int SCI_POSITIONRELATIVECODEUNITS = 2716;
	public const int SCI_COPYRANGE = 2419;
	public const int SCI_COPYTEXT = 2420;
	public const int SC_SEL_STREAM = 0;
	public const int SC_SEL_RECTANGLE = 1;
	public const int SC_SEL_LINES = 2;
	public const int SC_SEL_THIN = 3;
	public const int SCI_SETSELECTIONMODE = 2422;
	public const int SCI_CHANGESELECTIONMODE = 2659;
	public const int SCI_GETSELECTIONMODE = 2423;
	public const int SCI_SETMOVEEXTENDSSELECTION = 2719;
	public const int SCI_GETMOVEEXTENDSSELECTION = 2706;
	public const int SCI_GETLINESELSTARTPOSITION = 2424;
	public const int SCI_GETLINESELENDPOSITION = 2425;
	public const int SCI_LINEDOWNRECTEXTEND = 2426;
	public const int SCI_LINEUPRECTEXTEND = 2427;
	public const int SCI_CHARLEFTRECTEXTEND = 2428;
	public const int SCI_CHARRIGHTRECTEXTEND = 2429;
	public const int SCI_HOMERECTEXTEND = 2430;
	public const int SCI_VCHOMERECTEXTEND = 2431;
	public const int SCI_LINEENDRECTEXTEND = 2432;
	public const int SCI_PAGEUPRECTEXTEND = 2433;
	public const int SCI_PAGEDOWNRECTEXTEND = 2434;
	public const int SCI_STUTTEREDPAGEUP = 2435;
	public const int SCI_STUTTEREDPAGEUPEXTEND = 2436;
	public const int SCI_STUTTEREDPAGEDOWN = 2437;
	public const int SCI_STUTTEREDPAGEDOWNEXTEND = 2438;
	public const int SCI_WORDLEFTEND = 2439;
	public const int SCI_WORDLEFTENDEXTEND = 2440;
	public const int SCI_WORDRIGHTEND = 2441;
	public const int SCI_WORDRIGHTENDEXTEND = 2442;
	public const int SCI_SETWHITESPACECHARS = 2443;
	public const int SCI_GETWHITESPACECHARS = 2647;
	public const int SCI_SETPUNCTUATIONCHARS = 2648;
	public const int SCI_GETPUNCTUATIONCHARS = 2649;
	public const int SCI_SETCHARSDEFAULT = 2444;
	public const int SCI_AUTOCGETCURRENT = 2445;
	public const int SCI_AUTOCGETCURRENTTEXT = 2610;
	public const int SC_CASEINSENSITIVEBEHAVIOUR_RESPECTCASE = 0;
	public const int SC_CASEINSENSITIVEBEHAVIOUR_IGNORECASE = 1;
	public const int SCI_AUTOCSETCASEINSENSITIVEBEHAVIOUR = 2634;
	public const int SCI_AUTOCGETCASEINSENSITIVEBEHAVIOUR = 2635;
	public const int SC_MULTIAUTOC_ONCE = 0;
	public const int SC_MULTIAUTOC_EACH = 1;
	public const int SCI_AUTOCSETMULTI = 2636;
	public const int SCI_AUTOCGETMULTI = 2637;
	public const int SC_ORDER_PRESORTED = 0;
	public const int SC_ORDER_PERFORMSORT = 1;
	public const int SC_ORDER_CUSTOM = 2;
	public const int SCI_AUTOCSETORDER = 2660;
	public const int SCI_AUTOCGETORDER = 2661;
	public const int SCI_ALLOCATE = 2446;
	public const int SCI_TARGETASUTF8 = 2447;
	public const int SCI_SETLENGTHFORENCODE = 2448;
	public const int SCI_ENCODEDFROMUTF8 = 2449;
	public const int SCI_FINDCOLUMN = 2456;
	public const int SCI_GETCARETSTICKY = 2457;
	public const int SCI_SETCARETSTICKY = 2458;
	public const int SC_CARETSTICKY_OFF = 0;
	public const int SC_CARETSTICKY_ON = 1;
	public const int SC_CARETSTICKY_WHITESPACE = 2;
	public const int SCI_TOGGLECARETSTICKY = 2459;
	public const int SCI_SETPASTECONVERTENDINGS = 2467;
	public const int SCI_GETPASTECONVERTENDINGS = 2468;
	public const int SCI_REPLACERECTANGULAR = 2771;
	public const int SCI_SELECTIONDUPLICATE = 2469;
	public const int SC_ALPHA_TRANSPARENT = 0;
	public const int SC_ALPHA_OPAQUE = 255;
	public const int SC_ALPHA_NOALPHA = 256;
	public const int SCI_SETCARETLINEBACKALPHA = 2470;
	public const int SCI_GETCARETLINEBACKALPHA = 2471;
	public const int CARETSTYLE_INVISIBLE = 0;
	public const int CARETSTYLE_LINE = 1;
	public const int CARETSTYLE_BLOCK = 2;
	public const int CARETSTYLE_OVERSTRIKE_BAR = 0;
	public const int CARETSTYLE_OVERSTRIKE_BLOCK = 16;
	public const int CARETSTYLE_CURSES = 0x20;
	public const int CARETSTYLE_INS_MASK = 0xF;
	public const int SCI_SETCARETSTYLE = 2512;
	public const int SCI_GETCARETSTYLE = 2513;
	public const int SCI_SETINDICATORCURRENT = 2500;
	public const int SCI_GETINDICATORCURRENT = 2501;
	public const int SCI_SETINDICATORVALUE = 2502;
	public const int SCI_GETINDICATORVALUE = 2503;
	public const int SCI_INDICATORFILLRANGE = 2504;
	public const int SCI_INDICATORCLEARRANGE = 2505;
	public const int SCI_INDICATORALLONFOR = 2506;
	public const int SCI_INDICATORVALUEAT = 2507;
	public const int SCI_INDICATORSTART = 2508;
	public const int SCI_INDICATOREND = 2509;
	public const int SCI_SETPOSITIONCACHE = 2514;
	public const int SCI_GETPOSITIONCACHE = 2515;
	public const int SCI_SETLAYOUTTHREADS = 2775;
	public const int SCI_GETLAYOUTTHREADS = 2776;
	public const int SCI_COPYALLOWLINE = 2519;
	public const int SCI_CUTALLOWLINE = 2810;
	public const int SCI_SETCOPYSEPARATOR = 2811;
	public const int SCI_GETCOPYSEPARATOR = 2812;
	public const int SCI_GETCHARACTERPOINTER = 2520;
	public const int SCI_GETRANGEPOINTER = 2643;
	public const int SCI_GETGAPPOSITION = 2644;
	public const int SCI_INDICSETALPHA = 2523;
	public const int SCI_INDICGETALPHA = 2524;
	public const int SCI_INDICSETOUTLINEALPHA = 2558;
	public const int SCI_INDICGETOUTLINEALPHA = 2559;
	public const int SCI_SETEXTRAASCENT = 2525;
	public const int SCI_GETEXTRAASCENT = 2526;
	public const int SCI_SETEXTRADESCENT = 2527;
	public const int SCI_GETEXTRADESCENT = 2528;
	public const int SCI_MARKERSYMBOLDEFINED = 2529;
	public const int SCI_MARGINSETTEXT = 2530;
	public const int SCI_MARGINGETTEXT = 2531;
	public const int SCI_MARGINSETSTYLE = 2532;
	public const int SCI_MARGINGETSTYLE = 2533;
	public const int SCI_MARGINSETSTYLES = 2534;
	public const int SCI_MARGINGETSTYLES = 2535;
	public const int SCI_MARGINTEXTCLEARALL = 2536;
	public const int SCI_MARGINSETSTYLEOFFSET = 2537;
	public const int SCI_MARGINGETSTYLEOFFSET = 2538;
	public const int SC_MARGINOPTION_NONE = 0;
	public const int SC_MARGINOPTION_SUBLINESELECT = 1;
	public const int SCI_SETMARGINOPTIONS = 2539;
	public const int SCI_GETMARGINOPTIONS = 2557;
	public const int SCI_ANNOTATIONSETTEXT = 2540;
	public const int SCI_ANNOTATIONGETTEXT = 2541;
	public const int SCI_ANNOTATIONSETSTYLE = 2542;
	public const int SCI_ANNOTATIONGETSTYLE = 2543;
	public const int SCI_ANNOTATIONSETSTYLES = 2544;
	public const int SCI_ANNOTATIONGETSTYLES = 2545;
	public const int SCI_ANNOTATIONGETLINES = 2546;
	public const int SCI_ANNOTATIONCLEARALL = 2547;
	public enum AnnotationsVisible {
		ANNOTATION_HIDDEN = 0,
		ANNOTATION_STANDARD = 1,
		ANNOTATION_BOXED = 2,
		ANNOTATION_INDENTED = 3,
	}
	public const int SCI_ANNOTATIONSETVISIBLE = 2548;
	public const int SCI_ANNOTATIONGETVISIBLE = 2549;
	public const int SCI_ANNOTATIONSETSTYLEOFFSET = 2550;
	public const int SCI_ANNOTATIONGETSTYLEOFFSET = 2551;
	public const int SCI_RELEASEALLEXTENDEDSTYLES = 2552;
	public const int SCI_ALLOCATEEXTENDEDSTYLES = 2553;
	public const int UNDO_MAY_COALESCE = 1;
	public const int SCI_ADDUNDOACTION = 2560;
	public const int SCI_CHARPOSITIONFROMPOINT = 2561;
	public const int SCI_CHARPOSITIONFROMPOINTCLOSE = 2562;
	public const int SCI_SETMOUSESELECTIONRECTANGULARSWITCH = 2668;
	public const int SCI_GETMOUSESELECTIONRECTANGULARSWITCH = 2669;
	public const int SCI_SETMULTIPLESELECTION = 2563;
	public const int SCI_GETMULTIPLESELECTION = 2564;
	public const int SCI_SETADDITIONALSELECTIONTYPING = 2565;
	public const int SCI_GETADDITIONALSELECTIONTYPING = 2566;
	public const int SCI_SETADDITIONALCARETSBLINK = 2567;
	public const int SCI_GETADDITIONALCARETSBLINK = 2568;
	public const int SCI_SETADDITIONALCARETSVISIBLE = 2608;
	public const int SCI_GETADDITIONALCARETSVISIBLE = 2609;
	public const int SCI_GETSELECTIONS = 2570;
	public const int SCI_GETSELECTIONEMPTY = 2650;
	public const int SCI_CLEARSELECTIONS = 2571;
	public const int SCI_SETSELECTION = 2572;
	public const int SCI_ADDSELECTION = 2573;
	public const int SCI_SELECTIONFROMPOINT = 2474;
	public const int SCI_DROPSELECTIONN = 2671;
	public const int SCI_SETMAINSELECTION = 2574;
	public const int SCI_GETMAINSELECTION = 2575;
	public const int SCI_SETSELECTIONNCARET = 2576;
	public const int SCI_GETSELECTIONNCARET = 2577;
	public const int SCI_SETSELECTIONNANCHOR = 2578;
	public const int SCI_GETSELECTIONNANCHOR = 2579;
	public const int SCI_SETSELECTIONNCARETVIRTUALSPACE = 2580;
	public const int SCI_GETSELECTIONNCARETVIRTUALSPACE = 2581;
	public const int SCI_SETSELECTIONNANCHORVIRTUALSPACE = 2582;
	public const int SCI_GETSELECTIONNANCHORVIRTUALSPACE = 2583;
	public const int SCI_SETSELECTIONNSTART = 2584;
	public const int SCI_GETSELECTIONNSTART = 2585;
	public const int SCI_SETSELECTIONNEND = 2586;
	public const int SCI_GETSELECTIONNEND = 2587;
	public const int SCI_SETRECTANGULARSELECTIONCARET = 2588;
	public const int SCI_GETRECTANGULARSELECTIONCARET = 2589;
	public const int SCI_SETRECTANGULARSELECTIONANCHOR = 2590;
	public const int SCI_GETRECTANGULARSELECTIONANCHOR = 2591;
	public const int SCI_SETRECTANGULARSELECTIONCARETVIRTUALSPACE = 2592;
	public const int SCI_GETRECTANGULARSELECTIONCARETVIRTUALSPACE = 2593;
	public const int SCI_SETRECTANGULARSELECTIONANCHORVIRTUALSPACE = 2594;
	public const int SCI_GETRECTANGULARSELECTIONANCHORVIRTUALSPACE = 2595;
	public const int SCVS_NONE = 0;
	public const int SCVS_RECTANGULARSELECTION = 1;
	public const int SCVS_USERACCESSIBLE = 2;
	public const int SCVS_NOWRAPLINESTART = 4;
	public const int SCI_SETVIRTUALSPACEOPTIONS = 2596;
	public const int SCI_GETVIRTUALSPACEOPTIONS = 2597;
	public const int SCI_SETRECTANGULARSELECTIONMODIFIER = 2598;
	public const int SCI_GETRECTANGULARSELECTIONMODIFIER = 2599;
	public const int SCI_SETADDITIONALSELFORE = 2600;
	public const int SCI_SETADDITIONALSELBACK = 2601;
	public const int SCI_SETADDITIONALSELALPHA = 2602;
	public const int SCI_GETADDITIONALSELALPHA = 2603;
	public const int SCI_SETADDITIONALCARETFORE = 2604;
	public const int SCI_GETADDITIONALCARETFORE = 2605;
	public const int SCI_ROTATESELECTION = 2606;
	public const int SCI_SWAPMAINANCHORCARET = 2607;
	public const int SCI_MULTIPLESELECTADDNEXT = 2688;
	public const int SCI_MULTIPLESELECTADDEACH = 2689;
	public const int SCI_CHANGELEXERSTATE = 2617;
	public const int SCI_CONTRACTEDFOLDNEXT = 2618;
	public const int SCI_VERTICALCENTRECARET = 2619;
	public const int SCI_MOVESELECTEDLINESUP = 2620;
	public const int SCI_MOVESELECTEDLINESDOWN = 2621;
	public const int SCI_SETIDENTIFIER = 2622;
	public const int SCI_GETIDENTIFIER = 2623;
	public const int SCI_RGBAIMAGESETWIDTH = 2624;
	public const int SCI_RGBAIMAGESETHEIGHT = 2625;
	public const int SCI_RGBAIMAGESETSCALE = 2651;
	public const int SCI_MARKERDEFINERGBAIMAGE = 2626;
	public const int SCI_REGISTERRGBAIMAGE = 2627;
	public const int SCI_SCROLLTOSTART = 2628;
	public const int SCI_SCROLLTOEND = 2629;
	public const int SC_TECHNOLOGY_DEFAULT = 0;
	public const int SC_TECHNOLOGY_DIRECTWRITE = 1;
	public const int SC_TECHNOLOGY_DIRECTWRITERETAIN = 2;
	public const int SC_TECHNOLOGY_DIRECTWRITEDC = 3;
	public const int SC_TECHNOLOGY_DIRECT_WRITE_1 = 4;
	public const int SCI_SETTECHNOLOGY = 2630;
	public const int SCI_GETTECHNOLOGY = 2631;
	public const int SCI_CREATELOADER = 2632;
	public const int SCI_FINDINDICATORSHOW = 2640;
	public const int SCI_FINDINDICATORFLASH = 2641;
	public const int SCI_FINDINDICATORHIDE = 2642;
	public const int SCI_VCHOMEDISPLAY = 2652;
	public const int SCI_VCHOMEDISPLAYEXTEND = 2653;
	public const int SCI_GETCARETLINEVISIBLEALWAYS = 2654;
	public const int SCI_SETCARETLINEVISIBLEALWAYS = 2655;
	public const int SC_LINE_END_TYPE_DEFAULT = 0;
	public const int SC_LINE_END_TYPE_UNICODE = 1;
	public const int SCI_SETLINEENDTYPESALLOWED = 2656;
	public const int SCI_GETLINEENDTYPESALLOWED = 2657;
	public const int SCI_GETLINEENDTYPESACTIVE = 2658;
	public const int SCI_SETREPRESENTATION = 2665;
	public const int SCI_GETREPRESENTATION = 2666;
	public const int SCI_CLEARREPRESENTATION = 2667;
	public const int SCI_CLEARALLREPRESENTATIONS = 2770;
	public const int SC_REPRESENTATION_PLAIN = 0;
	public const int SC_REPRESENTATION_BLOB = 1;
	public const int SC_REPRESENTATION_COLOUR = 0x10;
	public const int SCI_SETREPRESENTATIONAPPEARANCE = 2766;
	public const int SCI_GETREPRESENTATIONAPPEARANCE = 2767;
	public const int SCI_SETREPRESENTATIONCOLOUR = 2768;
	public const int SCI_GETREPRESENTATIONCOLOUR = 2769;
	public const int SCI_EOLANNOTATIONSETTEXT = 2740;
	public const int SCI_EOLANNOTATIONGETTEXT = 2741;
	public const int SCI_EOLANNOTATIONSETSTYLE = 2742;
	public const int SCI_EOLANNOTATIONGETSTYLE = 2743;
	public const int SCI_EOLANNOTATIONCLEARALL = 2744;
	public const int EOLANNOTATION_HIDDEN = 0x0;
	public const int EOLANNOTATION_STANDARD = 0x1;
	public const int EOLANNOTATION_BOXED = 0x2;
	public const int EOLANNOTATION_STADIUM = 0x100;
	public const int EOLANNOTATION_FLAT_CIRCLE = 0x101;
	public const int EOLANNOTATION_ANGLE_CIRCLE = 0x102;
	public const int EOLANNOTATION_CIRCLE_FLAT = 0x110;
	public const int EOLANNOTATION_FLATS = 0x111;
	public const int EOLANNOTATION_ANGLE_FLAT = 0x112;
	public const int EOLANNOTATION_CIRCLE_ANGLE = 0x120;
	public const int EOLANNOTATION_FLAT_ANGLE = 0x121;
	public const int EOLANNOTATION_ANGLES = 0x122;
	public const int SCI_EOLANNOTATIONSETVISIBLE = 2745;
	public const int SCI_EOLANNOTATIONGETVISIBLE = 2746;
	public const int SCI_EOLANNOTATIONSETSTYLEOFFSET = 2747;
	public const int SCI_EOLANNOTATIONGETSTYLEOFFSET = 2748;
	public const int SC_SUPPORTS_LINE_DRAWS_FINAL = 0;
	public const int SC_SUPPORTS_PIXEL_DIVISIONS = 1;
	public const int SC_SUPPORTS_FRACTIONAL_STROKE_WIDTH = 2;
	public const int SC_SUPPORTS_TRANSLUCENT_STROKE = 3;
	public const int SC_SUPPORTS_PIXEL_MODIFICATION = 4;
	public const int SC_SUPPORTS_THREAD_SAFE_MEASURE_WIDTHS = 5;
	public const int SCI_SUPPORTSFEATURE = 2750;
	public const int SC_LINECHARACTERINDEX_NONE = 0;
	public const int SC_LINECHARACTERINDEX_UTF32 = 1;
	public const int SC_LINECHARACTERINDEX_UTF16 = 2;
	public const int SCI_GETLINECHARACTERINDEX = 2710;
	public const int SCI_ALLOCATELINECHARACTERINDEX = 2711;
	public const int SCI_RELEASELINECHARACTERINDEX = 2712;
	public const int SCI_LINEFROMINDEXPOSITION = 2713;
	public const int SCI_INDEXPOSITIONFROMLINE = 2714;
	public const int SCI_STARTRECORD = 3001;
	public const int SCI_STOPRECORD = 3002;
	public const int SCI_SETILEXER = 4033;
	public const int SCI_GETLEXER = 4002;
	public const int SCI_COLOURISE = 4003;
	public const int SCI_SETPROPERTY = 4004;
	public const int KEYWORDSET_MAX = 8;
	public const int SCI_SETKEYWORDS = 4005;
	public const int SCI_GETPROPERTY = 4008;
	public const int SCI_GETPROPERTYEXPANDED = 4009;
	public const int SCI_GETPROPERTYINT = 4010;
	public const int SCI_GETLEXERLANGUAGE = 4012;
	public const int SCI_PRIVATELEXERCALL = 4013;
	public const int SCI_PROPERTYNAMES = 4014;
	public const int SC_TYPE_BOOLEAN = 0;
	public const int SC_TYPE_INTEGER = 1;
	public const int SC_TYPE_STRING = 2;
	public const int SCI_PROPERTYTYPE = 4015;
	public const int SCI_DESCRIBEPROPERTY = 4016;
	public const int SCI_DESCRIBEKEYWORDSETS = 4017;
	public const int SCI_GETLINEENDTYPESSUPPORTED = 4018;
	public const int SCI_ALLOCATESUBSTYLES = 4020;
	public const int SCI_GETSUBSTYLESSTART = 4021;
	public const int SCI_GETSUBSTYLESLENGTH = 4022;
	public const int SCI_GETSTYLEFROMSUBSTYLE = 4027;
	public const int SCI_GETPRIMARYSTYLEFROMSTYLE = 4028;
	public const int SCI_FREESUBSTYLES = 4023;
	public const int SCI_SETIDENTIFIERS = 4024;
	public const int SCI_DISTANCETOSECONDARYSTYLES = 4025;
	public const int SCI_GETSUBSTYLEBASES = 4026;
	public const int SCI_GETNAMEDSTYLES = 4029;
	public const int SCI_NAMEOFSTYLE = 4030;
	public const int SCI_TAGSOFSTYLE = 4031;
	public const int SCI_DESCRIPTIONOFSTYLE = 4032;
	[Flags]
	public enum MOD {
		SC_MOD_INSERTTEXT = 0x1,
		SC_MOD_DELETETEXT = 0x2,
		SC_MOD_CHANGESTYLE = 0x4,
		SC_MOD_CHANGEFOLD = 0x8,
		SC_PERFORMED_USER = 0x10,
		SC_PERFORMED_UNDO = 0x20,
		SC_PERFORMED_REDO = 0x40,
		SC_MULTISTEPUNDOREDO = 0x80,
		SC_LASTSTEPINUNDOREDO = 0x100,
		SC_MOD_CHANGEMARKER = 0x200,
		SC_MOD_BEFOREINSERT = 0x400,
		SC_MOD_BEFOREDELETE = 0x800,
		SC_MULTILINEUNDOREDO = 0x1000,
		SC_STARTACTION = 0x2000,
		SC_MOD_CHANGEINDICATOR = 0x4000,
		SC_MOD_CHANGELINESTATE = 0x8000,
		SC_MOD_CHANGEMARGIN = 0x10000,
		SC_MOD_CHANGEANNOTATION = 0x20000,
		SC_MOD_CONTAINER = 0x40000,
		SC_MOD_LEXERSTATE = 0x80000,
		SC_MOD_INSERTCHECK = 0x100000,
		SC_MOD_CHANGETABSTOPS = 0x200000,
		SC_MOD_CHANGEEOLANNOTATION = 0x400000,
		SC_MODEVENTMASKALL = 0x7FFFFF,
	}
	[Flags]
	public enum UPDATE {
		SC_UPDATE_CONTENT=1,
		SC_UPDATE_SELECTION=2,
		SC_UPDATE_V_SCROLL=4,
		SC_UPDATE_H_SCROLL=8,
	}
	
	public const int SCEN_CHANGE = 768;
	public const int SCEN_SETFOCUS = 512;
	public const int SCEN_KILLFOCUS = 256;
	public const int SCK_DOWN = 300;
	public const int SCK_UP = 301;
	public const int SCK_LEFT = 302;
	public const int SCK_RIGHT = 303;
	public const int SCK_HOME = 304;
	public const int SCK_END = 305;
	public const int SCK_PRIOR = 306;
	public const int SCK_NEXT = 307;
	public const int SCK_DELETE = 308;
	public const int SCK_INSERT = 309;
	public const int SCK_ESCAPE = 7;
	public const int SCK_BACK = 8;
	public const int SCK_TAB = 9;
	public const int SCK_RETURN = 13;
	public const int SCK_ADD = 310;
	public const int SCK_SUBTRACT = 311;
	public const int SCK_DIVIDE = 312;
	public const int SCK_WIN = 313;
	public const int SCK_RWIN = 314;
	public const int SCK_MENU = 315;
	public const int SCMOD_NORM = 0;
	public const int SCMOD_SHIFT = 1;
	public const int SCMOD_CTRL = 2;
	public const int SCMOD_ALT = 4;
	public const int SCMOD_SUPER = 8;
	public const int SCMOD_META = 16;
	public const int SC_AC_FILLUP = 1;
	public const int SC_AC_DOUBLECLICK = 2;
	public const int SC_AC_TAB = 3;
	public const int SC_AC_NEWLINE = 4;
	public const int SC_AC_COMMAND = 5;
	public const int SC_AC_SINGLE_CHOICE = 6;
	public const int SC_CHARACTERSOURCE_DIRECT_INPUT = 0;
	public const int SC_CHARACTERSOURCE_TENTATIVE_INPUT = 1;
	public const int SC_CHARACTERSOURCE_IME_RESULT = 2;
	public enum NOTIF {
		SCN_STYLENEEDED = 2000,
		SCN_CHARADDED = 2001,
		SCN_SAVEPOINTREACHED = 2002,
		SCN_SAVEPOINTLEFT = 2003,
		SCN_MODIFYATTEMPTRO = 2004,
		SCN_KEY = 2005,
		SCN_DOUBLECLICK = 2006,
		SCN_UPDATEUI = 2007,
		SCN_MODIFIED = 2008,
		SCN_MACRORECORD = 2009,
		SCN_MARGINCLICK = 2010,
		SCN_NEEDSHOWN = 2011,
		SCN_PAINTED = 2013,
		SCN_USERLISTSELECTION = 2014,
		SCN_URIDROPPED = 2015,
		SCN_DWELLSTART = 2016,
		SCN_DWELLEND = 2017,
		SCN_ZOOM = 2018,
		SCN_HOTSPOTCLICK = 2019,
		SCN_HOTSPOTDOUBLECLICK = 2020,
		SCN_CALLTIPCLICK = 2021,
		SCN_AUTOCSELECTION = 2022,
		SCN_INDICATORCLICK = 2023,
		SCN_INDICATORRELEASE = 2024,
		SCN_AUTOCCANCELLED = 2025,
		SCN_AUTOCCHARDELETED = 2026,
		SCN_HOTSPOTRELEASECLICK = 2027,
		SCN_FOCUSIN = 2028,
		SCN_FOCUSOUT = 2029,
		SCN_AUTOCCOMPLETED = 2030,
		SCN_MARGINRIGHTCLICK = 2031,
		SCN_AUTOCSELECTIONCHANGE = 2032,
	}
	public const int SC_BIDIRECTIONAL_DISABLED = 0;
	public const int SC_BIDIRECTIONAL_L2R = 1;
	public const int SC_BIDIRECTIONAL_R2L = 2;
	public const int SCI_GETBIDIRECTIONAL = 2708;
	public const int SCI_SETBIDIRECTIONAL = 2709;

	public struct Sci_CharacterRange {
		public int cpMin;
		public int cpMax;
	}

	public struct Sci_TextRange {
		public int cpMin;
		public int cpMax;
		public byte* lpstrText;
	}

	public struct Sci_TextToFind {
		public int cpMin;
		public int cpMax;
		public byte* lpstrText;
		public Sci_CharacterRange chrgText;
	}

	public struct Sci_Rectangle {
		public int left;
		public int top;
		public int right;
		public int bottom;
	}

	public struct Sci_RangeToFormat {
		public IntPtr hdc;
		public IntPtr hdcTarget;
		public Sci_Rectangle rc;
		public Sci_Rectangle rcPage;
		public Sci_CharacterRange chrg;
	}

	public struct Sci_NotifyHeader {
		public wnd hwndFrom;
		public nint idFrom;
		public NOTIF code;
	}

	public struct SCNotification {
#pragma warning disable 649 //field never assigned
		public Sci_NotifyHeader nmhdr;
		/// <summary>Returns <c>nmhdr.code</c>.</summary>
		public NOTIF code => nmhdr.code;
		nint _position;
		/// <summary>Raw UTF-8 position.</summary>
		public int position => (int)_position;
		public int ch;
		public int modifiers;
		public MOD modificationType;
		public byte* textUTF8;
		nint _length;
		public int length => (int)_length;
		nint _linesAdded;
		public int linesAdded => (int)_linesAdded;
		public int message;
		public nint wParam;
		public nint lParam;
		nint _line;
		public int line => (int)_line;
		public int foldLevelNow;
		public int foldLevelPrev;
		public int margin;
		public int listType;
		public int x;
		public int y;
		public int token;
		nint _annotationLinesAdded;
		public int annotationLinesAdded => (int)_annotationLinesAdded;
		public UPDATE updated;
		public int listCompletionMethod;
#pragma warning restore 649 //field never assigned

		/// <summary>
		/// Returns position, UTF-8. If SCN_MODIFIED(SC_MOD_INSERTTEXT|SC_MOD_BEFOREINSERT|SC_MOD_INSERTCHECK), adds length, because position then is old position.
		/// </summary>
		public int FinalPosition {
			get {
				int r = position;
				if (length > 0 && nmhdr.code == NOTIF.SCN_MODIFIED
					&& modificationType.HasAny(MOD.SC_MOD_INSERTTEXT | MOD.SC_MOD_BEFOREINSERT | MOD.SC_MOD_INSERTCHECK)
					) r += length;
				return r;
			}
		}

		/// <summary>
		/// Converts textUTF8 to C# string.
		/// Returns null if textUTF8 is null.
		/// Don't call this property multiple times for the same notification. Store the return value in a variable and use it.
		/// </summary>
		public string Text {
			get {
				if (textUTF8 == null) return null;
				if (textUTF8[0] == 0) return "";
				return new string((sbyte*)textUTF8, 0, length, Encoding.UTF8);
			}
		}
	}
}


================================================
FILE: Au.Controls/KScintilla/Sci adapter.cs
================================================
namespace Au.Controls;

using static Sci;

public unsafe partial class KScintilla {
	_Adapter _adapter; //created in KScintilla ctor
	
	/// <summary>
	/// Gets or sets text.
	/// Uses caching, therefore the <c>get</c> function is fast and garbage-free when calling multiple times.
	/// </summary>
	/// <remarks>
	/// The <c>get</c> function gets cached text if called not the first time after setting or modifying control text.
	/// The <c>set</c> function calls <see cref="aaaSetText"/> when need. Uses default parameters (with undo and notifications, unless <b>AaInitReadOnlyAlways</b>).
	/// Unlike the above methods, this property can be used before creating handle.
	/// </remarks>
	public string aaaText {
		get => _adapter.Text;
		set { _adapter.Text = value; }
	}
	
	/// <summary>
	/// UTF-8 text length.
	/// </summary>
	public int aaaLen8 => _adapter.Len8;
	
	/// <summary>
	/// UTF-16 text length.
	/// </summary>
	public int aaaLen16 => _adapter.Len16;
	
	/// <summary>
	/// Converts UTF-16 position to UTF-8 position. Fast.
	/// </summary>
	/// <exception cref="ArgumentOutOfRangeException">Negative or greater than <see cref="aaaLen16"/>.</exception>
	public int aaaPos8(int pos16) => _adapter.Pos8(pos16);
	
	/// <summary>
	/// Converts UTF-8 position to UTF-16 position. Fast.
	/// </summary>
	/// <exception cref="ArgumentOutOfRangeException">Negative or greater than <see cref="aaaLen8"/>.</exception>
	public unsafe int aaaPos16(int pos8) => _adapter.Pos16(pos8);
	
	/// <summary>
	/// Maps UTF-16 to/from UTF-8 positions.
	/// Gets UTF-16 and UTF-8 length.
	/// Gets cached UTF-16 text.
	/// </summary>
	class _Adapter {
		record struct _NA(int i8, int i16, int len16, int charLen);
		
		readonly KScintilla _sci;
		string _text;
		readonly List<_NA> _a;
		int _len8, _len16;
		bool _mapDone;
		
		public _Adapter(KScintilla sci) {
			_sci = sci;
			_a = new();
		}
		
		public void HandleCreated() {
			if (!_text.NE()) _sci.aaaSetText(_text, SciSetTextFlags.NoUndoNoNotify);
		}
		
		public void TextModified() {
			_text = null;
			_a.Clear();
			_mapDone = false;
		}
		
		string _GetText() => _sci._RangeText(0, Len8);
		
		public string Text {
			get {
				//if (_sci.Name == "document") print.qm2.write($"Text: cached={_text != null}");
				if (_text == null && !_sci._w.Is0) _text = _GetText(); //_NotifyModified sets _text=null
				return _text;
			}
			set {
				if (_sci._w.Is0) _text = value; //will set control text on WM_CREATE
				else _sci.aaaSetText(value); //_NotifyModified sets _text=null. Control text can be != value, eg when tags parsed.
			}
		}
		
		public int Len8 => _mapDone ? _len8 : _sci.Call(SCI_GETTEXTLENGTH);
		
		public int Len16 {
			get {
				if (_text != null) return _text.Length;
				if (!_mapDone) _CreatePosMap();
				return _len16;
			}
		}
		
		public int Pos8(int pos16) {
			if (!_mapDone) _CreatePosMap();
			
			Debug.Assert((uint)pos16 <= _len16);
			if ((uint)pos16 > _len16) throw new ArgumentOutOfRangeException(nameof(pos16), $"pos16 = {pos16}, _len16 = {_len16}, _GetText().Length={_GetText().Length}");
			
			//using binary search find max _a[r].i16 that is < pos16
			int r = -1, from = 0, to = _a.Count;
			while (to > from) {
				int m = (from + to) / 2;
				if (_a[m].i16 < pos16) from = (r = m) + 1; else to = m;
			}
			if (r < 0) return pos16; //_a is empty (ASCII text) or pos16 <= _a[0].i16 (before first non-ASCII character)
			var p = _a[r];
			return p.i8 + Math.Min(pos16 - p.i16, p.len16) * p.charLen + Math.Max(pos16 - (p.i16 + p.len16), 0); //p.i8 + utf + ascii
		}
		
		public unsafe int Pos16(int pos8) {
			if (!_mapDone) _CreatePosMap();
			
			Debug.Assert((uint)pos8 <= _len8);
			if ((uint)pos8 > _len8) throw new ArgumentOutOfRangeException(nameof(pos8), $"pos8 = {pos8}, _len8 = {_len8}, _sci.Call(SCI_GETTEXTLENGTH)={_sci.Call(SCI_GETTEXTLENGTH)}");
			
			//using binary search find max _a[r].i8 that is < pos8
			int r = -1, from = 0, to = _a.Count;
			while (to > from) {
				int m = (from + to) / 2;
				if (_a[m].i8 < pos8) from = (r = m) + 1; else to = m;
			}
			if (r < 0) return pos8; //_a is empty (ASCII text) or pos8 <= _a[0].i8 (before first non-ASCII character)
			var p = _a[r];
			int len8 = p.len16 * p.charLen;
			return p.i16 + Math.Min(pos8 - p.i8, len8) / p.charLen + Math.Max(pos8 - (p.i8 + len8), 0); //p.i16 + utf + ascii
		}
		
		[MethodImpl(MethodImplOptions.AggressiveOptimization)]
		unsafe void _CreatePosMap() {
			//This func is fast and often garbageless. For code edit controls don't need to optimize to avoid calling it frequently, eg for each added character.
			//Should not be used for output/log controls if called on each "append text".
			
			int textLen;
			int gap = Sci_Range(_sci.AaSciPtr, 0, -1, out var p, out var p2, &textLen);
			int to8 = p2 == null ? textLen : gap;
			int i8 = 0, i16 = 0;
			for (; ; ) {
				//ASCII range
				int start8 = i8;
				int lenAscii8 = new RByte(p + i8, to8 - i8).IndexOfAnyExceptInRange((byte)0, (byte)127);
				if (lenAscii8 < 0) i8 = to8; else i8 += lenAscii8;
				i16 += i8 - start8;
				
				//non-ASCII range
				if (i8 < to8) {
					start8 = i8;
					int charLen = 0;
					while (i8 < to8 && p[i8] >= 0x80) {
						Rune.DecodeFromUtf8(new(p + i8, to8 - i8), out _, out int nb);
						if (charLen == 0) charLen = nb; else if (nb != charLen) break;
						i8 += nb;
					}
					if (charLen == 4) charLen = 2;
					int len16 = (i8 - start8) / charLen;
					_a.Add(new(start8, i16, len16, charLen));
					i16 += len16;
					if (i8 < to8) continue;
				}
				
				//the part after gap
				if (p2 == null) break;
				p = p2 - i8;
				p2 = null;
				to8 = textLen;
			}
			
			_len8 = textLen;
			_len16 = i16;
			_mapDone = true;
		}
	}
}


================================================
FILE: Au.Controls/KScintilla/Sci loader.cs
================================================
namespace Au.Controls;

using static Sci;

public unsafe partial class KScintilla {
	public class aaaFileLoaderSaver {
		_Encoding _enc;
		byte[] _text;

		public bool IsBinary => _enc == _Encoding.Binary;

		public bool IsImage { get; private set; }

		/// <summary>
		/// Loads file as UTF-8.
		/// Supports any encoding (UTF-8, UTF-16, etc), BOM. Remembers it for Save.
		/// </summary>
		/// <exception cref="Exception">Exceptions of File.OpenRead, File.Read, Encoding.Convert.</exception>
		public void Load(string file) {
			_enc = _Encoding.Binary;
			IsImage = false;
			if (file.Ends(true, ".png", ".bmp", ".jpg", ".jpeg", ".gif", ".tif", ".tiff", ".ico", ".cur", ".ani") > 0) {
				if (!filesystem.exists(file).File) throw new FileNotFoundException($"Could not find file '{file}'.");
				IsImage = true;
				_text = Encoding.UTF8.GetBytes($"<image \"{file}\">");
				return;
			}

			using var fr = filesystem.loadStream(file);

			if (fr.Length > 100_000_000) {
				_text = "//Cannot edit. The file is too big, more than 100_000_000 bytes."u8.ToArray();
				return;
			}

			int fileSize = (int)fr.Length;
			var b = new byte[fileSize];
			if (fr.Read(b, 0, fileSize) != fileSize) throw null;

			_enc = _DetectEncoding(b);
			//print.it(_enc);
			if (_enc == _Encoding.Binary) {
				_text = "//Cannot edit. The file is binary, not text."u8.ToArray();
				return;
			}

			if (_enc == _Encoding.Utf8_BOM && !System.Text.Unicode.Utf8.IsValid(b[3..])) b = b.ToStringUTF8().ToUTF8(); //else Scintilla text would be bad

			if (_EncodingEnumToObject() is { } e) {
				int bomLength = (int)_enc >>> 4;
				b = Encoding.Convert(e, Encoding.UTF8, b, bomLength, (int)fileSize - bomLength);
			}

			_text = b;
		}

		Encoding _EncodingEnumToObject() {
			switch (_enc) {
			case _Encoding.Utf16_BOM or _Encoding.Utf16: return Encoding.Unicode;
			case _Encoding.Utf16BE_BOM or _Encoding.Utf16BE: return Encoding.BigEndianUnicode;
			case _Encoding.Utf32_BOM: return Encoding.UTF32;
			case _Encoding.Utf32BE_BOM: return new UTF32Encoding(true, false);
			case _Encoding.Ansi: return StringUtil.GetEncoding(-1);
			}
			return null;
		}

		static unsafe _Encoding _DetectEncoding(RByte s) {
			int len = s.Length;
			//is too short to have a BOM?
			if (len == 0) return _Encoding.Utf8;
			if (len == 1) return s[0] == 0 ? _Encoding.Binary : (s[0] < 128 ? _Encoding.Utf8 : _Encoding.Ansi);
			//has a BOM?
			if (s is [0xEF, 0xBB, 0xBF, ..]) return _Encoding.Utf8_BOM;
			if (s is [0xFF, 0xFE, 0, 0, ..]) return _Encoding.Utf32_BOM;
			if (s is [0xFF, 0xFE, ..]) return _Encoding.Utf16_BOM;
			if (s is [0xFE, 0xFF, ..]) return _Encoding.Utf16BE_BOM;
			if (s is [0, 0, 0xFE, 0xFF, ..]) return _Encoding.Utf32BE_BOM;
			//has '\0'?
			int zeroAt = s.IndexOf((byte)0);
			if (zeroAt is 0 or 1 && 0 == (len & 1)) {
				if (MemoryMarshal.Cast<byte, char>(s).Contains('\0')) return _Encoding.Binary;
				return zeroAt is 0 ? _Encoding.Utf16BE : _Encoding.Utf16;
			}
			//if (zeroAt == len - 1) { s = s[..--len]; zeroAt = -1; } //WordPad saves .rtf files with '\0' at the end. Rejected; eg VS and VSCode detects as binary.
			if (zeroAt >= 0) return _Encoding.Binary;
			return System.Text.Unicode.Utf8.IsValid(s) ? _Encoding.Utf8 : _Encoding.Ansi;
		}

		enum _Encoding : byte {
			/// <summary>Not a text file, or loading failed, or not initialized.</summary>
			Binary = 0, //must be 0

			/// <summary>ASCII or UTF-8 without BOM.</summary>
			Utf8 = 1,

			/// <summary>UTF-8 with BOM (3 bytes).</summary>
			Utf8_BOM = 1 | (3 << 4),

			/// <summary>ANSI containing non-ASCII characters, unknown code page.</summary>
			Ansi = 2,

			/// <summary>UTF-16 without BOM.</summary>
			Utf16 = 3,

			/// <summary>UTF-16 big endian without BOM.</summary>
			Utf16BE = 4,

			/// <summary>UTF-16 with BOM (2 bytes).</summary>
			Utf16_BOM = 3 | (2 << 4),

			/// <summary>UTF-16 with big endian BOM (2 bytes).</summary>
			Utf16BE_BOM = 4 | (2 << 4),

			/// <summary>UTF-32 with BOM (4 bytes).</summary>
			Utf32_BOM = 5 | (4 << 4),

			/// <summary>UTF-32 with big endian BOM (4 bytes).</summary>
			Utf32BE_BOM = 6 | (4 << 4),

			//rejected. .NET does not save/load with UTF-7 BOM, so we too. Several different BOM of different length.
			///// <summary>UTF-7 with BOM.</summary>
			//Utf7_BOM,
		}

		/// <summary>
		/// Sets control text.
		/// If the file is image, binary or too big (<c>> 100_000_000</c>), sets to display the image or/and some short info text, makes the control read-only, sets <b>Save</b> to throw exception, and returns false. Else returns true.
		/// Uses <see cref="SciSetTextFlags"/> NoUndo and NoNotify.
		/// Must be called once.
		/// </summary>
		public unsafe bool SetText(KScintilla k) {
			RByte text = _text;
			if (_enc == _Encoding.Utf8_BOM) text = text[3..];
			if (_enc == _Encoding.Binary) k.Call(SCI_SETREADONLY); //caller may set AaInitReadOnlyAlways = true
			using (new _NoUndoNotif(k, SciSetTextFlags.NoUndoNoNotify)) {
				if (IsImage && k.AaTags is {  } tags) tags.AddText(text.ToStringUTF8(), false, false, dontHideImageTag: true);
				else k.aaaSetString(SCI_APPENDTEXT, text.Length, text);
			}
			if (_enc != _Encoding.Binary) return true;
			k.Call(SCI_SETREADONLY, 1);
			return false;
		}

		/// <summary>
		/// Returns true if text contains newlines other than <c>\r\n</c> and <c>\n</c>.
		/// </summary>
		public bool DetectBadNewlines() {
			if (_enc != _Encoding.Binary) {
				var s = _text;
				for (int i = 0; i < s.Length - 1;) { //ends with '\0'
					switch (s[i++]) {
					case 13 when s[i] != 10: return true;
					case 0xc2 when s[i] == 0x85: return true;
					case 0xe2 when s[i] == 0x80 && s[i + 1] is 0xa8 or 0xa9: return true;
					}
				}
			}
			return false;
		}

		public void FinishedLoading() {
			_text = null; //GC
		}

		/// <summary>
		/// Saves control text with the same encoding/BOM as loaded. Uses <see cref="filesystem.save"/>.
		/// </summary>
		/// <param name="file">To pass to filesystem.save.</param>
		/// <param name="tempDirectory">To pass to filesystem.save.</param>
		/// <exception cref="Exception">Exceptions of filesystem.save.</exception>
		/// <exception cref="InvalidOperationException">The file is binary (then <b>SetText</b> made the control read-only), or <b>Load</b> not called.</exception>
		public unsafe void Save(KScintilla k, string file, string tempDirectory = null) {
			if (_enc == _Encoding.Binary) throw new InvalidOperationException();

			//_enc = _Encoding.; //test

			Encoding e = _EncodingEnumToObject();

			int bom = (int)_enc >> 4; //BOM length
			uint bomm = 0; //BOM memory
			if (e != null) bomm = _enc switch {
				_Encoding.Utf16_BOM or _Encoding.Utf32_BOM => 0xFEFF,
				_Encoding.Utf16BE_BOM => 0xFFFE,
				_Encoding.Utf32BE_BOM => 0xFFFE0000,
				_ => 0
			};
			else if (bom == 3) bomm = 0xBFBBEF; //UTF8; else bom 0

			//print.it(_enc, bom, bomm, e);

			filesystem.save(file, temp => {
				using var fs = File.Create(temp);
				if (bomm != 0) { uint u = bomm; fs.Write(new RByte((byte*)&u, bom)); } //rare
				if (e != null) { //rare
					var bytes = e.GetBytes(k.aaaText); //convert encoding. aaaText likely gets cached text, fast
					fs.Write(bytes);
				} else {
					int len = k.aaaLen8;
					var bytes = (byte*)k.CallRetPtr(SCI_GETCHARACTERPOINTER);
					fs.Write(new RByte(bytes, len));
				}
			}, tempDirectory: tempDirectory);

			//print.it("file", File.ReadAllBytes(file));
		}
	}
}


================================================
FILE: Au.Controls/KScintilla/Sci other.cs
================================================
namespace Au.Controls;

using static Sci;

public partial class KScintilla {
	
	#region markers
	
	/// <summary>
	/// Sets marker style and colors.
	/// </summary>
	/// <param name="marker">Marker index, 0-31. Indices 25-31 are used for folding markers (SC_MARKNUM_FOLDERx). Indices 21-24 are used for change history markers. Scintilla draws markers from smaller to bigger index.</param>
	/// <param name="style">SC_MARK_.</param>
	/// <param name="foreColor">SCI_MARKERSETFORE.</param>
	/// <param name="backColor">SCI_MARKERSETBACK.</param>
	public void aaaMarkerDefine(int marker, int style, ColorInt? foreColor = null, ColorInt? backColor = null) {
		if ((uint)marker > 31) throw new ArgumentOutOfRangeException(nameof(marker));
		Call(SCI_MARKERDEFINE, marker, style);
		if (foreColor != null) Call(SCI_MARKERSETFORE, marker, foreColor.Value.ToBGR());
		if (backColor != null) Call(SCI_MARKERSETBACK, marker, backColor.Value.ToBGR());
	}
	
	/// <summary>
	/// SCI_MARKERADD.
	/// </summary>
	/// <returns>Marker handle, or -1 if failed.</returns>
	public int aaaMarkerAdd(int marker, int line) {
		return Call(SCI_MARKERADD, line, marker);
	}
	
	/// <summary>
	/// SCI_MARKERADD in line containing <i>pos</i>.
	/// </summary>
	/// <returns>Marker handle, or -1 if failed.</returns>
	public int aaaMarkerAdd(int marker, bool utf16, int pos) {
		return aaaMarkerAdd(marker, aaaLineFromPos(utf16, pos));
	}
	
	/// <summary>
	/// SCI_MARKERDELETE.
	/// </summary>
	public void aaaMarkerDelete(int marker, int line) {
		Call(SCI_MARKERDELETE, line, marker);
	}
	
	/// <summary>
	/// SCI_MARKERDELETE in line containing <i>pos</i>.
	/// </summary>
	public void aaaMarkerDelete(int marker, bool utf16, int pos) {
		aaaMarkerDelete(marker, aaaLineFromPos(utf16, pos));
	}
	
	/// <summary>
	/// SCI_MARKERDELETEALL.
	/// </summary>
	/// <param name="marker">If -1, delete all markers from all lines.</param>
	public void aaaMarkerDeleteAll(int marker) {
		Call(SCI_MARKERDELETEALL, marker);
	}
	
	/// <summary>
	/// SCI_MARKERDELETEHANDLE.
	/// </summary>
	public void aaaMarkerDeleteHandle(int handle) {
		Call(SCI_MARKERDELETEHANDLE, handle);
	}
	
	#endregion
	
	#region indicators
	
	/// <summary>
	/// Sets indicator style, color, etc.
	/// </summary>
	/// <param name="indic">Indicator index, 0-31. Scintilla draws indicators from smaller to bigger index.</param>
	/// <param name="style">Eg Sci.INDIC_FULLBOX.</param>
	/// <param name="color">SCI_INDICSETFORE.</param>
	/// <param name="alpha">SCI_INDICSETALPHA. Valid for some styles.</param>
	/// <param name="borderAlpha">SCI_INDICSETOUTLINEALPHA. Valid for some styles.</param>
	/// <param name="strokeWidth">SCI_INDICSETSTROKEWIDTH (%). Valid for some styles.</param>
	/// <param name="underText">SCI_INDICSETUNDER (under text).</param>
	/// <param name="hoverColor">SCI_INDICSETHOVERFORE.</param>
	/// <param name="hoverStyle">SCI_INDICSETHOVERSTYLE</param>
	public void aaaIndicatorDefine(int indic, int style, ColorInt? color = null, int? alpha = null, int? borderAlpha = null, int? strokeWidth = null, bool underText = false, ColorInt? hoverColor = null, int? hoverStyle = null) {
		if ((uint)indic > 31) throw new ArgumentOutOfRangeException(nameof(indic));
		Call(SCI_INDICSETSTYLE, indic, style);
		if (style != INDIC_HIDDEN) {
			if (color != null) Call(SCI_INDICSETFORE, indic, color.Value.ToBGR());
			if (alpha != null) Call(SCI_INDICSETALPHA, indic, alpha.Value);
			if (borderAlpha != null) Call(SCI_INDICSETOUTLINEALPHA, indic, borderAlpha.Value);
			if (strokeWidth != null) Call(SCI_INDICSETSTROKEWIDTH, indic, strokeWidth.Value);
			if (underText) Call(SCI_INDICSETUNDER, indic, underText);
		}
		if (hoverColor != null) Call(SCI_INDICSETHOVERFORE, indic, hoverColor.Value.ToBGR());
		if (hoverStyle != null) Call(SCI_INDICSETHOVERSTYLE, indic, hoverStyle.Value);
	}
	
	public void aaaIndicatorClear(int indic) => aaaIndicatorClear(indic, false, ..);
	
	public void aaaIndicatorClear(int indic, bool utf16, Range r) {
		var (from, to) = aaaNormalizeRange(utf16, r);
		Call(SCI_SETINDICATORCURRENT, indic);
		Call(SCI_INDICATORCLEARRANGE, from, to - from);
	}
	
	public void aaaIndicatorAdd(int indic, bool utf16, Range r, int value = 1) {
		var (from, to) = aaaNormalizeRange(utf16, r);
		Call(SCI_SETINDICATORCURRENT, indic);
		Call(SCI_SETINDICATORVALUE, value);
		Call(SCI_INDICATORFILLRANGE, from, to - from);
	}
	
	/// <summary>
	/// SCI_INDICATORVALUEAT.
	/// </summary>
	public int aaaIndicatorGetValue(int indic, int pos, bool utf16 = false) {
		if (utf16) pos = aaaPos8(pos);
		return Call(SCI_INDICATORVALUEAT, indic, pos);
	}
	
	/// <summary>
	/// SCI_INDICATORALLONFOR. Returns a bitmap value representing which indicators are non-zero at <i>pos</i>.
	/// </summary>
	public int aaaIndicatorGetAll(int pos, bool utf16 = false) {
		if (utf16) pos = aaaPos8(pos);
		return Call(SCI_INDICATORALLONFOR, pos);
	}
	
	/// <summary>
	/// Finds the first range of the specified indicator.
	/// </summary>
	/// <param name="indic"></param>
	/// <param name="r">UTF-8.</param>
	/// <returns>false if not found.</returns>
	public bool aaaIndicatorFindFirst(int indic, out StartEnd r) {
		r = default;
		int start = Call(SCI_INDICATOREND, indic);
		if (start <= 0) {
			if (start < 0 || aaaIndicatorGetValue(indic, 0) == 0) return false;
		}
		int end = Call(SCI_INDICATOREND, indic, start);
		if (end <= start) return false;
		r = new(start, end);
		return true;
	}
	
	#endregion
	
	#region margins
	
	/// <summary>
	/// SCI_SETMARGINTYPEN. Optionally SCI_SETMARGINSENSITIVEN, SCI_SETMARGINCURSORN, SCI_SETMARGINMASKN.
	/// </summary>
	/// <param name="margin"></param>
	/// <param name="type">SC_MARGIN_.</param>
	/// <param name="markersMask">SCI_SETMARGINMASKN.</param>
	/// <param name="sensitive">SCI_SETMARGINSENSITIVEN.</param>
	/// <param name="cursorArrow">SCI_SETMARGINCURSORN. True SC_CURSORARROW, false SC_CURSORREVERSEARROW.</param>
	public void aaaMarginSetType(int margin, int type, int? markersMask = null, bool? sensitive = null, bool? cursorArrow = null) {
		Call(SCI_SETMARGINTYPEN, margin, type);
		if (markersMask.HasValue) Call(SCI_SETMARGINMASKN, margin, markersMask.Value);
		if (sensitive.HasValue) Call(SCI_SETMARGINSENSITIVEN, margin, sensitive.Value);
		if (cursorArrow.HasValue) Call(SCI_SETMARGINCURSORN, margin, cursorArrow == true ? SC_CURSORARROW : SC_CURSORREVERSEARROW);
	}
	
	/// <summary>
	/// SCI_SETMARGINWIDTHN or SCI_SETMARGINLEFT or SCI_SETMARGINRIGHT.
	/// Dpi-scales, and will scale when DPI changed.
	/// </summary>
	/// <param name="margin">Margin index for SCI_SETMARGINWIDTHN, or -1 to use SCI_SETMARGINLEFT, or -2 to use SCI_SETMARGINRIGHT.</param>
	/// <param name="pixels">Logical pixels or 0.</param>
	/// <param name="chars">Number of character '8' widths or 0. If both <i>pixels</i> and <i>chars</i> are not 0, uses their sum.</param>
	public void aaaMarginSetWidth(int margin, int pixels, int chars = 0) {
		_marginDpi ??= new (short, short)[Call(SCI_GETMARGINS) + 2];
		_marginDpi[margin + 2] = ((short)pixels, (short)chars);
		_MarginSetWidth(margin, pixels, chars);
	}
	(short pixels, short chars)[] _marginDpi; //logical pixels
	
	void _MarginWidthsDpiChanged() {
		if (_marginDpi is { } a)
			for (int i = a.Length; --i >= 0;) if (a[i] != default) _MarginSetWidth(i - 2, a[i].pixels, a[i].chars);
	}
	
	void _MarginSetWidth(int i, int pixels, int chars) {
		if (pixels != 0) pixels = Dpi.Scale(pixels, _dpi);
		if (chars != 0) pixels += chars * aaaStyleMeasureStringWidth(STYLE_LINENUMBER, "8");
		if (i == -2) Call(SCI_SETMARGINRIGHT, 0, pixels); else if (i == -1) Call(SCI_SETMARGINLEFT, 0, pixels); else Call(SCI_SETMARGINWIDTHN, i, pixels);
	}
	
	/// <returns>Margin index, or -1 if not in a margin.</returns>
	public int aaaMarginFromPoint(POINT p, bool screenCoord = false) {
		if (screenCoord) _w.MapScreenToClient(ref p);
		if (_w.ClientRect.Contains(p)) {
			for (int i = 0, n = Call(SCI_GETMARGINS), w = 0; i < n; i++) { w += Call(SCI_GETMARGINWIDTHN, i); if (w >= p.x) return i; }
		}
		return -1;
	}
	
	/// <summary>
	/// SCI_GETMARGINWIDTHN.
	/// </summary>
	public (int left, int right) aaaMarginGetX(int margin, bool dpiUnscale = false) {
		int x = 0;
		for (int i = 0; i < margin; i++) x += Call(SCI_GETMARGINWIDTHN, i);
		var r = (left: x, right: x + Call(SCI_GETMARGINWIDTHN, margin));
		if (dpiUnscale) {
			r.left = Dpi.Unscale(r.left, _dpi).ToInt();
			r.right = Dpi.Unscale(r.right, _dpi).ToInt();
		}
		return r;
	}
	
	/// <summary>
	/// Initializes folding margin and optionally separator marker.
	/// </summary>
	/// <param name="foldMargin">Margin index.</param>
	/// <param name="separatorMarker">Separator marker index, or -1 if never using seperators in this control.</param>
	/// <param name="autoFold">Set SC_AUTOMATICFOLD_CLICK.</param>
	public void aaaFoldingInit(int foldMargin = 0, int separatorMarker = -1, bool autoFold = false) {
		Call(SCI_SETMARGINTYPEN, foldMargin, SC_MARGIN_SYMBOL);
		Call(SCI_SETMARGINMASKN, foldMargin, SC_MASK_FOLDERS);
		Call(SCI_SETMARGINSENSITIVEN, foldMargin, 1);
		
		Call(SCI_MARKERDEFINE, SC_MARKNUM_FOLDEROPEN, SC_MARK_BOXMINUS);
		Call(SCI_MARKERDEFINE, SC_MARKNUM_FOLDER, SC_MARK_BOXPLUS);
		Call(SCI_MARKERDEFINE, SC_MARKNUM_FOLDERSUB, SC_MARK_VLINE);
		Call(SCI_MARKERDEFINE, SC_MARKNUM_FOLDERTAIL, SC_MARK_LCORNER);
		Call(SCI_MARKERDEFINE, SC_MARKNUM_FOLDEREND, SC_MARK_BOXPLUSCONNECTED);
		Call(SCI_MARKERDEFINE, SC_MARKNUM_FOLDEROPENMID, SC_MARK_BOXMINUSCONNECTED);
		Call(SCI_MARKERDEFINE, SC_MARKNUM_FOLDERMIDTAIL, SC_MARK_TCORNER);
		for (int i = 25; i < 32; i++) {
			Call(SCI_MARKERSETFORE, i, 0xffffff);
			Call(SCI_MARKERSETBACK, i, 0x808080);
			Call(SCI_MARKERSETBACKSELECTED, i, i == SC_MARKNUM_FOLDER ? 0xFF : 0x808080);
		}
		//Call(SCI_MARKERENABLEHIGHLIGHT, 1); //red [+]
		
		int fflags = SC_AUTOMATICFOLD_SHOW //show hidden lines when header line deleted. Also when hidden text modified, and it is not always good.
									| SC_AUTOMATICFOLD_CHANGE; //show hidden lines when header line modified like '#region' -> '//#region'
		if (autoFold) fflags |= SC_AUTOMATICFOLD_CLICK;
		Call(SCI_SETAUTOMATICFOLD, fflags);
		Call(SCI_SETFOLDFLAGS, SC_FOLDFLAG_LINEAFTER_CONTRACTED);
		Call(SCI_FOLDDISPLAYTEXTSETSTYLE, SC_FOLDDISPLAYTEXT_STANDARD);
		aaaStyleForeColor(STYLE_FOLDDISPLAYTEXT, 0x808080);
		
		Call(SCI_SETMARGINCURSORN, foldMargin, SC_CURSORARROW);
		
		aaaMarginSetWidth(foldMargin, 12);
		
		//separator lines below functions, types etc
		if (separatorMarker >= 0) aaaMarkerDefine(separatorMarker, SC_MARK_UNDERLINE, backColor: 0xa0a0a0);
	}
	
	/// <summary>
	/// Adds or updates fold points and optionally separators.
	/// </summary>
	/// <param name="af">Fold points. If null or empty, just clears old.</param>
	/// <param name="separatorMarker">Separator marker index, or -1 if never using seperators in this control. The marker should have an underline style.</param>
	public void aaaFoldingApply(List<SciFoldPoint> af, int separatorMarker = -1) {
		int underlinedLine = 0;
		
		int[] a = null;
		if (af != null) {
			a = new int[af.Count];
			for (int i = 0; i < a.Length; i++) {
				var v = af[i];
				int pos8 = aaaPos8(v.pos);
				a[i] = pos8 | (v.start ? 0 : unchecked((int)0x80000000));
				
				if (separatorMarker >= 0 && v.separator != 0) {
					//add separator below, or above if start
					if (v.start) { //above
						int k = v.pos - v.separator; if (k <= 0) continue;
						pos8 = aaaPos8(k);
					}
					int li = aaaLineFromPos(false, pos8);
					_DeleteUnderlinedLineMarkers(li);
					//if(underlinedLine != li) print.it("add", li + 1);
					if (underlinedLine != li) Call(SCI_MARKERADD, li, separatorMarker);
					else underlinedLine++;
				}
			}
		}
		
		if (separatorMarker >= 0) _DeleteUnderlinedLineMarkers(int.MaxValue);
		
		void _DeleteUnderlinedLineMarkers(int beforeLine) {
			if ((uint)underlinedLine > beforeLine) return;
			int marker = 1 << separatorMarker;
			for (; ; underlinedLine++) {
				underlinedLine = Call(SCI_MARKERNEXT, underlinedLine, marker);
				if ((uint)underlinedLine >= beforeLine) break;
				//print.it("delete", underlinedLine + 1);
				do Call(SCI_MARKERDELETE, underlinedLine, separatorMarker);
				while (0 != (marker & Call(SCI_MARKERGET, underlinedLine)));
			}
		}
		
		unsafe { //we implement folding in Scintilla. Calling many SCI_SETFOLDLEVEL here would be slow.
			fixed (int* ip = a) Sci_SetFoldLevels(AaSciPtr, 0, -1, a.Lenn_(), ip);
		}
		//p1.NW('F');
	}
	
	/// <summary>
	/// SCI_GETFOLDLEVEL.
	/// </summary>
	/// <returns>0-based level (never less than 0) and whether it has SC_FOLDLEVELHEADERFLAG.</returns>
	public (int level, bool isHeader) aaaFoldingLevel(int line) {
		int r = Call(SCI_GETFOLDLEVEL, line);
		return (Math.Max(0, (r & SC_FOLDLEVELNUMBERMASK) - SC_FOLDLEVELBASE), 0 != (r & SC_FOLDLEVELHEADERFLAG));
	}
	
	#endregion
}

/// <summary>
/// See <see cref="KScintilla.aaaFoldingApply"/>
/// </summary>
/// <param name="pos">A position anywhere in the line.</param>
/// <param name="start">Start or end.</param>
/// <param name="separator">If not 0, adds separator. If <i>start</i> true, adds above, at <c>pos-separator</c>; else adds below, and let it be 1.</param>
public record struct SciFoldPoint(int pos, bool start, ushort separator = 0);


================================================
FILE: Au.Controls/KScintilla/Sci styles.cs
================================================
namespace Au.Controls;

using static Sci;

public unsafe partial class KScintilla {
	
	public void aaaStyleFont(int style, string name) {
		aaaSetString(SCI_STYLESETFONT, style, name);
	}
	
	//public string aaaStyleFont(int style)
	//{
	//	return aaaGetString(SCI_STYLEGETFONT, style, 100);
	//}
	
	public void aaaStyleFont(int style, string name, double size) {
		aaaStyleFont(style, name);
		aaaStyleFontSize(style, size);
	}
	
	/// <summary>Uses only font name and size. Not style etc.</summary>
	public void aaaStyleFont(int style, System.Windows.Controls.Control c) {
		aaaStyleFont(style, c.FontFamily.ToString(), c.FontSize.ToInt() * 72 / 96);
	}
	
	/// <summary>Segoe UI, 9.</summary>
	public void aaaStyleFont(int style) {
		aaaStyleFont(style, "Segoe UI", 9);
	}
	
	public void aaaStyleFontSize(int style, double value) {
		Call(SCI_STYLESETSIZEFRACTIONAL, style, (int)(value * 100));
	}
	
	//public int aaaStyleFontSize(int style)
	//{
	//	return Call(SCI_STYLEGETSIZE, style);
	//}
	
	public void aaaStyleHidden(int style, bool value) {
		Call(SCI_STYLESETVISIBLE, style, !value);
	}
	
	//public bool aaaStyleHidden(int style)
	//{
	//	return 0 == Call(SCI_STYLEGETVISIBLE, style);
	//}
	
	public void aaaStyleBold(int style, bool value) {
		Call(SCI_STYLESETBOLD, style, value);
	}
	
	public void aaaStyleItalic(int style, bool value) {
		Call(SCI_STYLESETITALIC, style, value);
	}
	
	public void aaaStyleUnderline(int style, bool value) {
		Call(SCI_STYLESETUNDERLINE, style, value);
	}
	
	public void aaaStyleEolFilled(int style, bool value) {
		Call(SCI_STYLESETEOLFILLED, style, value);
	}
	
	public void aaaStyleHotspot(int style, bool value) {
		Call(SCI_STYLESETHOTSPOT, style, value);
	}
	
	public bool aaaStyleHotspot(int style) {
		return 0 != Call(SCI_STYLEGETHOTSPOT, style);
	}
	
	public void aaaStyleForeColor(int style, ColorInt color) {
		Call(SCI_STYLESETFORE, style, color.ToBGR());
	}
	
	public void aaaStyleBackColor(int style, ColorInt color) {
		Call(SCI_STYLESETBACK, style, color.ToBGR());
	}
	
	/// <summary>
	/// SCI_TEXTWIDTH.
	/// </summary>
	public int aaaStyleMeasureStringWidth(int style, string s) {
		return aaaSetString(SCI_TEXTWIDTH, style, s);
	}
	
	/// <summary>
	/// Calls SCI_STYLECLEARALL, which sets all styles to be the same as STYLE_DEFAULT.
	/// Then also sets some special styles: STYLE_HIDDEN, SC_ELEMENT_HOT_SPOT_ACTIVE.
	/// </summary>
	/// <param name="belowDefault">Clear only styles 0..STYLE_DEFAULT.</param>
	public void aaaStyleClearAll(bool belowDefault = false) {
		if (belowDefault) aaaStyleClearRange(0, STYLE_DEFAULT);
		else Call(SCI_STYLECLEARALL);
		aaaStyleHidden(STYLE_HIDDEN, true);
		//aaaSetString(SCI_STYLESETINVISIBLEREPRESENTATION, STYLE_HIDDEN, "-"u8); //no
		aaaSetElementColor(SC_ELEMENT_HOT_SPOT_ACTIVE, 0x8000FF);
	}
	
	/// <summary>
	/// Calls SCI_STYLECLEARALL(styleFrom8, styleTo8NotIncluding), which sets range of styles to be the same as STYLE_DEFAULT.
	/// If styleTo8NotIncluding is 0, clears all starting from styleFrom.
	/// </summary>
	public void aaaStyleClearRange(int styleFrom8, int styleTo8NotIncluding = 0) {
		Call(SCI_STYLECLEARALL, styleFrom8, styleTo8NotIncluding);
	}
	
	/// <summary>
	/// Gets style at position.
	/// Uses SCI_GETSTYLEINDEXAT.
	/// Returns 0 if pos is invalid.
	/// </summary>
	public int aaaStyleGetAt(int pos8) {
		return Call(SCI_GETSTYLEINDEXAT, pos8);
	}
	
	/// <summary>
	/// Sets scintilla's "end-styled position" = to8 (default int.MaxValue), to avoid SCN_STYLENEEDED notifications.
	/// Fast, just sets a field in scintilla.
	/// </summary>
	/// <remarks>
	/// Scintilla sends SCN_STYLENEEDED, unless a lexer is set. In some cases 1 or several, in some cases many, in some cases every 500 ms.
	/// </remarks>
	public void aaaSetStyled(int to8 = int.MaxValue) => Call(SCI_STARTSTYLING, to8);
	
	/// <summary>
	/// SCI_SETELEMENTCOLOUR.
	/// </summary>
	/// <param name="element">SC_ELEMENT_.</param>
	/// <param name="color">Color. Can be with alpha. If null, calls SCI_RESETELEMENTCOLOUR.</param>
	public void aaaSetElementColor(int element, ColorInt? color) {
		if (color.HasValue) Call(SCI_SETELEMENTCOLOUR, element, color.Value.ToBGR(zeroAlpha: false));
		else Call(SCI_RESETELEMENTCOLOUR, element);
	}
	
	/// <summary>
	/// SCI_GETELEMENTCOLOUR.
	/// </summary>
	/// <param name="element">SC_ELEMENT_.</param>
	public ColorInt aaaGetElementColor(int element) {
		return ColorInt.FromBGR(Call(SCI_GETELEMENTCOLOUR, element), false);
	}
	
	/// <summary>
	/// SCI_STARTSTYLING and SCI_SETSTYLINGEX.
	/// </summary>
	public void aaaSetStyling(int start8, RByte styles) {
		Call(SCI_STARTSTYLING, start8);
		unsafe { fixed (byte* bp = styles) Call(SCI_SETSTYLINGEX, styles.Length, bp); }
	}
	
	/// <summary>
	/// If <i>text</i> is ASCII, returns <i>styles</i>. Else returns new array where style bytes are converted from UTF-16 offsets to UTF-8 offsets.
	/// </summary>
	/// <param name="styles">Style bytes. The offsets are UTF-16. The function does not modify it.</param>
	/// <param name="text">Text to be styled. Must be same length as <i>styles</i>.</param>
	/// <returns></returns>
	public static Span<byte> aaaConvertStylingBytesToUtf8(Span<byte> styles, RStr text) {
		Debug.Assert(styles.Length == text.Length);
		if (!text.IsAscii()) {
			var u = new byte[Encoding.UTF8.GetByteCount(text)];
			int i = 0, j = 0;
			foreach (var r in text.EnumerateRunes()) {
				var v = styles[i++];
				if (!r.IsBmp) i++;
				for (int n8 = r.Utf8SequenceLength; n8-- > 0;) u[j++] = v;
			}
			styles = u;
		}
		return styles;
	}
}


================================================
FILE: Au.Controls/KScintilla/Sci text.cs
================================================
//Functions to work with Scintilla control text, etc.

namespace Au.Controls;

using static Sci;

public unsafe partial class KScintilla {
	#region low level
	
	/// <summary>
	/// Calls a Scintilla message that sets a string which is passed using <i>lParam</i>.
	/// The string can be null if the Scintilla message allows it.
	/// If the message changes control text, this function does not work if the control is read-only. At first make non-readonly temporarily.
	/// Don't call this function from another thread.
	/// </summary>
	public int aaaSetString(int sciMessage, nint wParam, RStr lParam) {
		fixed (byte* s = _ToUtf8(lParam, out var len)) {
			return Call(sciMessage, wParam, s);
		}
	}
	
	/// <summary>
	/// Calls a Scintilla message that sets a string which is passed using <i>lParam</i> (UTF-8 string) and <i>wParam</i> (UTF-8 string length).
	/// The string can be null if the Scintilla message allows it.
	/// If the message changes control text, this function does not work if the control is read-only. At first make non-readonly temporarily.
	/// Don't call this function from another thread.
	/// </summary>
	public int aaaSetString(int sciMessage, RStr lParam) {
		fixed (byte* s = _ToUtf8(lParam, out var len)) {
			return Call(sciMessage, len, s);
		}
	}
	
	/// <summary>
	/// Calls a Scintilla message that sets a string which is passed using <i>wParam</i>.
	/// The string can be null if the Scintilla message allows it.
	/// If the message changes control text, this function does not work if the control is read-only. At first make non-readonly temporarily.
	/// Don't call this function from another thread.
	/// </summary>
	public int aaaSetString(int sciMessage, RStr wParam, nint lParam) {
		fixed (byte* s = _ToUtf8(wParam)) {
			return Call(sciMessage, (nint)s, lParam);
		}
	}
	
	/// <summary>
	/// Calls a Scintilla message that sets a string which is passed using <i>lParam</i>.
	/// With many messages the <i>lParam</i> string must be '\0'-terminated, eg UTF-8 string literal like <c>"example"u8</c>.
	/// The string can be null if the Scintilla message allows it.
	/// If the message changes control text, this function does not work if the control is read-only. At first make non-readonly temporarily.
	/// </summary>
	public int aaaSetString(int sciMessage, nint wParam, RByte lParam) {
		fixed (byte* p = lParam) {
			return Call(sciMessage, wParam, p);
		}
	}
	
	/// <summary>
	/// Calls a Scintilla message and passes two strings using <i>wParam</i> and <i>lParam</i>.
	/// <i>wParamlParam</i> must be like "WPARAM\0LPARAM". Asserts if no '\0'.
	/// If the message changes control text, this function does not work if the control is read-only. At first make non-readonly temporarily.
	/// Don't call this function from another thread.
	/// </summary>
	public int aaaSetStringString(int sciMessage, RStr wParamlParam) {
		fixed (byte* s = _ToUtf8(wParamlParam, out var len)) {
			int i = Ptr_.Length(s);
			Debug.Assert(i < len);
			return Call(sciMessage, (nint)s, s + i + 1);
		}
	}
	
	/// <summary>
	/// Calls a Scintilla message that gets a string when length is known.
	/// Always uses <i>utf8Length</i> bytes of the result (does not find length).
	/// Can get binary string (with '\0' characters).
	/// </summary>
	/// <param name="sciMessage"></param>
	/// <param name="wParam"></param>
	/// <param name="utf8Length">
	/// Known length (bytes) of the result UTF-8 string, without the terminating '\0' character.
	/// If 0, returns "" and does not call the message.
	/// </param>
	public string aaaGetStringOfLength(int sciMessage, nint wParam, int utf8Length)
		=> _GetString(sciMessage, wParam, utf8Length, false);
	
	/// <summary>
	/// Calls a Scintilla message that gets a string. See <see cref="aaaGetStringOfLength"/>.
	/// To get buffer size, at first calls <i>sciMessage</i> with <i>lParam</i>=0 (null buffer).
	/// Can get binary string (with '\0' characters).
	/// Don't call this function from another thread.
	/// </summary>
	/// <param name="sciMessage"></param>
	/// <param name="wParam"></param>
	public string aaaGetStringGetLength(int sciMessage, nint wParam)
		=> _GetString(sciMessage, wParam, Call(sciMessage, wParam), false);
	
	/// <summary>
	/// Calls a Scintilla message that gets a '\0'-terminated string.
	/// Cannot get binary string (with '\0' characters).
	/// Don't call this function from another thread.
	/// </summary>
	/// <param name="sciMessage"></param>
	/// <param name="wParam"></param>
	/// <param name="bufferSize">
	/// How much UTF-8 bytes to allocate for Scintilla to store the text.
	/// Can be either known or max expected text length, without the terminating '\0' character. The function will find length of the retrieved string (finds '\0').
	/// If 0, returns "" and does not call the message.
	/// </param>
	public string aaaGetString0Terminated(int sciMessage, nint wParam, int bufferSize)
		=> _GetString(sciMessage, wParam, bufferSize, true);
	
	[SkipLocalsInit]
	string _GetString(int sciMessage, nint wParam, int len, bool findLength) {
		if (len == 0) return "";
		using FastBuffer<byte> b = new(len + 1);
		b[len] = 0;
		Call(sciMessage, wParam, b.p);
		Debug.Assert(b[len] == 0);
		if (findLength) len = b.FindByteStringLength();
		return Encoding.UTF8.GetString(b, len);
	}
	
	static string _FromUtf8(byte* b) => Convert2.Utf8Decode(b);
	
	static byte[] _ToUtf8(RStr s) => Convert2.Utf8Encode(s);
	
	static byte[] _ToUtf8(RStr s, out int utf8Length) {
		var r = Convert2.Utf8Encode(s);
		utf8Length = r.Length - 1;
		return r;
	}
	
	/// <summary>
	/// Optimized 'get text' function.
	/// </summary>
	/// <param name="start8">Start index, UTF-8.</param>
	/// <param name="end8">End index, UTF-8.</param>
	/// <remarks>
	/// Does not create an intermediate byte[].
	/// Gets big text 5 times faster than aaaGetStringOfLength. Tested with text 31K length, 1K lines.
	/// </remarks>
	string _RangeText(int start8, int end8) {
		Debug.Assert(end8 >= start8);
		Debug.Assert((uint)end8 <= aaaLen8);
		if (end8 == start8) return "";
		int gap = Sci_Range(AaSciPtr, start8, end8, out var p1, out var p2);
		if (p2 != null) {
			int n1 = gap - start8, n2 = end8 - gap;
			int len1 = Encoding.UTF8.GetCharCount(p1, n1);
			int len2 = Encoding.UTF8.GetCharCount(p2, n2);
			nint k1 = (nint)p1, k2 = (nint)p2;
			return string.Create(len1 + len2, (k1, k2, n1, n2), static (span, a) => {
				int len1 = Encoding.UTF8.GetChars(new RByte((byte*)a.k1, a.n1), span);
				Encoding.UTF8.GetChars(new RByte((byte*)a.k2, a.n2), span.Slice(len1));
			});
		} else {
			int n1 = end8 - start8;
			int len1 = Encoding.UTF8.GetCharCount(p1, n1);
			nint k1 = (nint)p1;
			return string.Create(len1, (k1, n1), static (span, a) => {
				Encoding.UTF8.GetChars(new RByte((byte*)a.k1, a.n1), span);
			});
		}
	}
	
	/// <summary>
	/// If <i>utf16</i>, converts <i>from</i> and <i>to</i> from characters to UTF-8 bytes.
	/// </summary>
	/// <param name="utf16">Input values are UTF-16.</param>
	/// <param name="from"></param>
	/// <param name="to">If -1, uses <see cref="aaaLen8"/>.</param>
	/// <exception cref="ArgumentOutOfRangeException">Invalid argument, eg greater than text length or <i>to</i> less than <i>from</i>.</exception>
	public void aaaNormalizeRange(bool utf16, ref int from, ref int to) {
		if (from < 0 || (to < from && to != -1)) throw new ArgumentOutOfRangeException();
		if (utf16) from = aaaPos8(from);
		if (to < 0) to = aaaLen8; else if (utf16) to = aaaPos8(to);
	}
	
	/// <summary>
	/// If <i>utf16</i>, converts <i>from</i> and <i>to</i> from characters to UTF-8 bytes.
	/// </summary>
	/// <param name="utf16">Input values are UTF-16.</param>
	/// <param name="r">Range. Can be spacified from start or/and from end.</param>
	/// <exception cref="ArgumentOutOfRangeException">Invalid argument, eg <i>to</i> less than <i>from</i>.</exception>
	public (int from, int to) aaaNormalizeRange(bool utf16, Range r) {
		int from, to;
		if (r.Start.IsFromEnd || r.End.IsFromEnd) {
			(from, to) = r.GetStartEnd(utf16 ? aaaLen16 : aaaLen8);
			if (utf16) {
				from = aaaPos8(from);
				to = aaaPos8(to);
			}
		} else {
			from = r.Start.Value;
			to = r.End.Value;
			aaaNormalizeRange(utf16, ref from, ref to);
		}
		return (from, to);
	}
	
	/// <summary>
	/// Same as <see cref="aaaNormalizeRange(bool, ref int, ref int)"/>, but can be <i>to</i> less than <i>from</i>. If so, returns true.
	/// </summary>
	/// <exception cref="ArgumentOutOfRangeException">Invalid argument, eg greater than text length.</exception>
	public bool aaaNormalizeRangeCanBeReverse(bool utf16, ref int from, ref int to, bool swapFromTo) {
		bool reverse = to >= 0 && to < from;
		if (reverse) Math2.Swap(ref from, ref to);
		aaaNormalizeRange(utf16, ref from, ref to);
		if (reverse && !swapFromTo) Math2.Swap(ref from, ref to);
		return reverse;
	}
	
	/// <summary>
	/// => utf16 ? aaaPos8(pos) : pos;
	/// </summary>
	/// <exception cref="ArgumentOutOfRangeException">Negative.</exception>
	int _ParamPos(bool utf16, int pos) => pos >= 0 ? (utf16 ? aaaPos8(pos) : pos) : throw new ArgumentOutOfRangeException();
	
	/// <summary>
	/// => utf16 ? aaaPos16(pos) : pos;
	/// </summary>
	/// <exception cref="ArgumentOutOfRangeException">Negative.</exception>
	int _ReturnPos(bool utf16, int pos) => pos >= 0 ? (utf16 ? aaaPos16(pos) : pos) : throw new ArgumentOutOfRangeException();
	
	/// <summary>
	/// pos >= 0 ? (utf16 ? aaaPos16(pos) : pos) : pos;
	/// </summary>
	int _ReturnPosCanBeNegative(bool utf16, int pos) => pos >= 0 ? (utf16 ? aaaPos16(pos) : pos) : pos;
	
	/// <summary>
	/// => line;
	/// </summary>
	/// <exception cref="ArgumentOutOfRangeException">Negative.</exception>
	int _ParamLine(int line) => line >= 0 ? line : throw new ArgumentOutOfRangeException();
	
	struct _NoReadonly : IDisposable {
		KScintilla _t;
		bool _ro;
		
		public _NoReadonly(KScintilla t) {
			_t = t;
			_ro = _t.AaInitReadOnlyAlways || _t.aaaIsReadonly;
			if (_ro) _t.Call(SCI_SETREADONLY, 0);
		}
		
		public void Dispose() {
			if (_ro) _t.Call(SCI_SETREADONLY, 1);
		}
	}
	
	struct _NoUndoNotif : IDisposable {
		KScintilla _t;
		bool _noUndo, _noNotif;
		
		public _NoUndoNotif(KScintilla t, SciSetTextFlags flags) {
			_t = t;
			_noUndo = flags.Has(SciSetTextFlags.NoUndo) && 0 != _t.Call(SCI_GETUNDOCOLLECTION);
			_noNotif = flags.Has(SciSetTextFlags.NoNotify) && !_t.AaDisableModifiedNotifications;
			if (_noNotif) _t.AaDisableModifiedNotifications = true;
			if (_noUndo) _t.Call(SCI_SETUNDOCOLLECTION);
		}
		
		public void Dispose() {
			if (_noUndo) {
				_t.Call(SCI_EMPTYUNDOBUFFER);
				_t.Call(SCI_SETUNDOCOLLECTION, 1);
			}
			if (_noNotif) _t.AaDisableModifiedNotifications = false;
		}
	}
	
	#endregion
	
	#region set/get/clear all text, append text
	
	/// <summary>
	/// Removes all text (SCI_CLEARALL).
	/// </summary>
	/// <param name="flags"></param>
	public void aaaClearText(SciSetTextFlags flags = 0) {
		if (_w.Is0) return;
		using (new _NoUndoNotif(this, flags))
		using (new _NoReadonly(this))
			Call(SCI_CLEARALL);
	}
	
	/// <summary>
	/// Replaces all text.
	/// Parses tags if need.
	/// </summary>
	/// <param name="s">Text.</param>
	/// <param name="flags"></param>
	/// <param name="ignoreTags">Don't parse tags, regardless of <b>AaInitTagsStyle</b>.</param>
	public void aaaSetText(string s, SciSetTextFlags flags = 0, bool ignoreTags = false) {
		using (new _NoUndoNotif(this, flags)) {
			if (!ignoreTags && _CanParseTags(s)) {
				aaaClearText();
				AaTags.AddText(s, false, AaInitTagsStyle == AaTagsStyle.AutoWithPrefix);
			} else {
				using (new _NoReadonly(this))
					aaaSetString(SCI_SETTEXT, 0, s ?? "");
			}
		}
	}
	
	bool _CanParseTags(string s) {
		if (s.NE()) return false;
		return AaInitTagsStyle switch {
			AaTagsStyle.AutoAlways => s.Contains('<'),
			AaTagsStyle.AutoWithPrefix => s.Starts("<>"),
			_ => false,
		};
	}
	
	/// <summary>
	/// Appends text and optionally "\r\n".
	/// Parses tags if need. Optionally scrolls and moves current position to the end (SCI_GOTOPOS).
	/// </summary>
	/// <param name="s"></param>
	/// <param name="andRN">Also append "\r\n". Ignores (uses true) if parses tags.</param>
	/// <param name="scroll">Move current position and scroll to the end.</param>
	/// <param name="ignoreTags">Don't parse tags, regardless of <b>AaInitTagsStyle</b>.</param>
	public void aaaAppendText(string s, bool andRN, bool scroll, bool ignoreTags = false) {
		s ??= "";
		if (!ignoreTags && _CanParseTags(s)) {
			AaTags.AddText(s, true, AaInitTagsStyle == AaTagsStyle.AutoWithPrefix, scroll);
		} else {
			var a = Convert2.Utf8Encode(s, andRN ? "\r\n" : "");
			using (new _NoReadonly(this))
				fixed (byte* b = a) Call(SCI_APPENDTEXT, a.Length, b);
			
			if (scroll) Call(SCI_GOTOPOS, aaaLen8);
		}
	}
	
	/// <summary>
	/// SCI_APPENDTEXT.
	/// </summary>
	/// <param name="s"></param>
	/// <param name="scroll">Move current position and scroll to the end.</param>
	public void aaaAppendText8(RByte s, bool scroll) {
		using (new _NoReadonly(this)) {
			fixed (byte* p = s) Call(SCI_APPENDTEXT, s.Length, p);
		}
		
		if (scroll) Call(SCI_GOTOPOS, aaaLen8);
	}
	
	/// <summary>
	/// Sets or appends UTF-8 text of specified length. Does not parse tags.
	/// If <i>scroll</i>, moves current position and scrolls to the end (SCI_GOTOPOS).
	/// </summary>
	internal void aaaAddText8_(bool append, bool scroll, byte* s, int lenToAppend) {
		using (new _NoReadonly(this))
			if (append) Call(SCI_APPENDTEXT, lenToAppend, s);
			else Call(SCI_SETTEXT, 0, s);
		
		if (scroll) Call(SCI_GOTOPOS, aaaLen8);
	}
	
	//not used now
	///// <summary>
	///// Sets or appends styled UTF-8 text of specified length.
	///// Does not append newline (s should contain it). Does not parse tags. Moves current position and scrolls to the end.
	///// Uses SCI_ADDSTYLEDTEXT. Caller does not have to move cursor to the end.
	///// lenToAppend is length in bytes, not in cells.
	///// </summary>
	//internal void aaaAddStyledText_(bool append, byte* s, int lenBytes)
	//{
	//	if(append) Call(SCI_SETEMPTYSELECTION, TextLengthBytes);
	
	//	using(new _NoReadonly(this))
	//	if(!append) Call(SCI_SETTEXT);
	//	Call(SCI_ADDSTYLEDTEXT, lenBytes, s);
	
	//	if(append) Call(SCI_GOTOPOS, TextLengthBytes);
	//}
	
	#endregion
	
	/// <summary>
	/// Gets (SCI_GETCURRENTPOS) or sets (SCI_SETEMPTYSELECTION) current caret position in UTF-8 bytes.
	/// The <c>set</c> function makes empty selection; does not scroll and does not make visible like aaaGoToPos.
	/// </summary>
	public int aaaCurrentPos8 { get => Call(SCI_GETCURRENTPOS); set => Call(SCI_SETEMPTYSELECTION, value); }
	
	/// <summary>
	/// Gets (SCI_GETCURRENTPOS) or sets (SCI_SETEMPTYSELECTION) current caret position in UTF-16 chars.
	/// The <c>set</c> function makes empty selection; does not scroll and does not make visible like aaaGoToPos.
	/// </summary>
	public int aaaCurrentPos16 { get => aaaPos16(aaaCurrentPos8); set => Call(SCI_SETEMPTYSELECTION, aaaPos8(value)); }
	
	/// <summary>
	/// SCI_GETSELECTIONSTART UTF-8.
	/// </summary>
	public int aaaSelectionStart8 => Call(SCI_GETSELECTIONSTART);
	
	/// <summary>
	/// SCI_GETSELECTIONSTART UTF-16.
	/// </summary>
	public int aaaSelectionStart16 => aaaPos16(aaaSelectionStart8);
	
	/// <summary>
	/// SCI_GETSELECTIONEND UTF-8.
	/// Always greater or equal than SelectionStart8.
	/// </summary>
	public int aaaSelectionEnd8 => Call(SCI_GETSELECTIONEND);
	
	/// <summary>
	/// SCI_GETSELECTIONEND UTF-16.
	/// Always greater or equal than SelectionStart16.
	/// </summary>
	public int aaaSelectionEnd16 => aaaPos16(aaaSelectionEnd8);
	
	/// <summary>
	/// <c>utf16 ? (aaaSelectionStart16, aaaSelectionEnd16) : (aaaSelectionStart8, aaaSelectionEnd8)</c>
	/// </summary>
	public (int start, int end) aaaSelection(bool utf16)
		=> utf16 ? (aaaSelectionStart16, aaaSelectionEnd16) : (aaaSelectionStart8, aaaSelectionEnd8);
	
	/// <summary>
	/// true if !SCI_GETSELECTIONEMPTY.
	/// </summary>
	public bool aaaHasSelection => 0 == Call(SCI_GETSELECTIONEMPTY);
	
	/// <summary>
	/// Gets line index from character position.
	/// </summary>
	/// <param name="utf16"></param>
	/// <param name="pos">A position in document text. Returns the last line if too big.</param>
	public int aaaLineFromPos(bool utf16, int pos)
		=> Call(SCI_LINEFROMPOSITION, _ParamPos(utf16, pos));
	
	/// <summary>
	/// Gets line index at <see cref="aaaSelectionStart8"/>.
	/// </summary>
	public int aaaLineFromPos()
		=> Call(SCI_LINEFROMPOSITION, aaaSelectionStart8);
	
	/// <summary>
	/// Gets line start position from line index.
	/// </summary>
	/// <param name="utf16">Return UTF-16.</param>
	/// <param name="line">0-based line index. Returns text length if too big.</param>
	public int aaaLineStart(bool utf16, int line) => _ReturnPos(utf16, _LineStart(line));
	
	int _LineStart(int line) {
		if (line < 0) throw new ArgumentOutOfRangeException();
		int R = Call(SCI_POSITIONFROMLINE, _ParamLine(line));
		return R >= 0 ? R : aaaLen8;
		//If line < 0, Scintilla returns line start from selection start.
		//If line > number of lines, Scintilla returns -1.
	}
	
	/// <summary>
	/// Gets line end position from line index.
	/// </summary>
	/// <param name="utf16">Return UTF-16.</param>
	/// <param name="line">0-based line index. Returns text length if too big.</param>
	/// <param name="withRN">Include \r\n.</param>
	public int aaaLineEnd(bool utf16, int line, bool withRN = false) {
		line = _ParamLine(line);
		return _ReturnPos(utf16, withRN ? _LineStart(line + 1) : Call(SCI_GETLINEENDPOSITION, line));
	}
	
	/// <summary>
	/// Gets line start position from any position.
	/// </summary>
	/// <param name="utf16">pos is UTF-16. Return UTF-16.</param>
	/// <param name="pos">A position in document text. Returns text length if too big.</param>
	public int aaaLineStartFromPos(bool utf16, int pos)
		=> aaaLineStart(utf16, aaaLineFromPos(utf16, pos));
	
	/// <summary>
	/// Gets line start position from any position and gets line index.
	/// Returns start position.
	/// </summary>
	/// <param name="utf16">pos is UTF-16. Return UTF-16.</param>
	/// <param name="pos">A position in document text. Returns text length if too big.</param>
	/// <param name="line">Receives line index.</param>
	public int aaaLineStartFromPos(bool utf16, int pos, out int line)
		=> aaaLineStart(utf16, line = aaaLineFromPos(utf16, pos));
	
	/// <summary>
	/// Gets line end position from any position.
	/// </summary>
	/// <param name="utf16">pos is UTF-16. Return UTF-16.</param>
	/// <param name="pos">A position in document text. Returns text length if too big.</param>
	/// <param name="withRN">Include \r\n.</param>
	/// <param name="lineStartIsLineEnd">If pos is at a line start (0 or after '\n' character), return pos.</param>
	public int aaaLineEndFromPos(bool utf16, int pos, bool withRN = false, bool lineStartIsLineEnd = false) {
		int pos0 = pos;
		pos = _ParamPos(utf16, pos);
		if (lineStartIsLineEnd) {
			if (pos == 0 || aaaCharAt8(pos - 1) == '\n') return pos0;
		}
		return aaaLineEnd(utf16, aaaLineFromPos(false, pos), withRN);
	}
	
	/// <summary>
	/// Gets line index, start and end positions from position.
	/// </summary>
	/// <param name="utf16">pos is UTF-16. Return UTF-16.</param>
	/// <param name="pos">A position in document text. Uses the last line if too big.</param>
	/// <param name="withRN">Include \r\n.</param>
	/// <param name="utf16Return">If not null, overrides <i>utf16</i> for return values.</param>
	public (int line, int start, int end) aaaLineStartEndFromPos(bool utf16, int pos, bool withRN = false, bool? utf16Return = null) {
		int startPos = aaaLineStartFromPos(false, _ParamPos(utf16, pos), out int line);
		int endPos = aaaLineEnd(false, line, withRN);
		utf16 = utf16Return ?? utf16;
		return (line, _ReturnPos(utf16, startPos), _ReturnPos(utf16, endPos));
	}
	
	/// <summary>
	/// Gets line text.
	/// </summary>
	/// <param name="line">0-based line index. If invalid, returns "".</param>
	/// <param name="withRN">Include \r\n.</param>
	public string aaaLineText(int line, bool withRN = false) => _RangeText(aaaLineStart(false, line), aaaLineEnd(false, line, withRN));
	
	/// <summary>
	/// Gets line height.
	/// Currently all lines are of the same height.
	/// </summary>
	public int aaaLineHeight() => Call(SCI_TEXTHEIGHT, 0);
	
	/// <summary>
	/// Gets the number of lines.
	/// </summary>
	public int aaaLineCount => Call(SCI_GETLINECOUNT);
	
	/// <summary>
	/// Gets the number of tabs + spaces/4 at the start of the line that contains the specified position.
	/// </summary>
	/// <param name="utf16"></param>
	/// <param name="pos">A position in document text.</param>
	/// <param name="extraSpaces">Receives the number of extra spaces, 0 to 3.</param>
	public int aaaLineIndentFromPos(bool utf16, int pos, out int extraSpaces) {
		int line = aaaLineFromPos(utf16, pos);
		int i = Call(SCI_GETLINEINDENTATION, line), r = i / 4;
		extraSpaces = i - r * 4;
		return r;
	}
	
	/// <summary>
	/// Gets the number of tabs + spaces/4 at the start of the line that contains the specified position.
	/// </summary>
	/// <param name="utf16"></param>
	/// <param name="pos">A position in document text.</param>
	public int aaaLineIndentFromPos(bool utf16, int pos) => aaaLineIndentFromPos(utf16, pos, out _);
	
	/// <summary>
	/// Gets position from point.
	/// </summary>
	/// <param name="utf16">Return UTF-16.</param>
	/// <param name="p">Point in client area.</param>
	/// <param name="minusOneIfFar">Return -1 if p is not in text characters.</param>
	public int aaaPosFromXY(bool utf16, POINT p, bool minusOneIfFar)
		=> _ReturnPosCanBeNegative(utf16, Call(minusOneIfFar ? SCI_POSITIONFROMPOINTCLOSE : SCI_POSITIONFROMPOINT, p.x, p.y));
	
	/// <summary>
	/// Gets annotation text of line.
	/// Returns "" if the line does not contain annotation or is invalid line index.
	/// </summary>
	public string aaaAnnotationText(int line) => AaImages?.AnnotationText_(line) ?? aaaAnnotationText_(line);
	
	/// <summary>
	/// Gets raw annotation text which can contain image info.
	/// aaaAnnotationText gets text without image info.
	/// Returns "" if the line does not contain annotation or is invalid line index.
	/// </summary>
	public string aaaAnnotationText_(int line) => aaaGetStringGetLength(SCI_ANNOTATIONGETTEXT, line);
	
	/// <summary>
	/// Sets annotation text of line.
	/// Does nothing if invalid line index.
	/// If s is null or "", removes annotation.
	/// Preserves existing image info.
	/// </summary>
	public void aaaAnnotationText(int line, string s, bool eol = false) {
		if (eol) aaaAnnotationText_(line, s, eol);
		else if (AaImages != null) AaImages.AnnotationText_(line, s);
		else aaaAnnotationText_(line, s);
	}
	
	/// <summary>
	/// Sets raw annotation text which can contain image info.
	/// If s is null or "", removes annotation.
	/// </summary>
	internal void aaaAnnotationText_(int line, string s, bool eol = false) {
		if (s.NE()) s = null;
		aaaSetString(eol ? SCI_EOLANNOTATIONSETTEXT : SCI_ANNOTATIONSETTEXT, line, s);
	}
	
	/// <summary>
	/// Moves <i>from</i> to the start of its line, and <i>to</i> to the end of its line.
	/// Does not change <i>to</i> if it is at a line start.
	/// </summary>
	/// <param name="utf16"></param>
	/// <param name="from">Start index.</param>
	/// <param name="to">End index.</param>
	/// <param name="withRN">Include "\r\n".</param>
	public void aaaRangeToFullLines(bool utf16, ref int from, ref int to, bool withRN = false) {
		Debug.Assert(from <= to);
		from = _ReturnPos(utf16, aaaLineStartFromPos(utf16, from));
		to = _ReturnPos(utf16, aaaLineEndFromPos(utf16, to, withRN, true));
	}
	
	/// <summary>
	/// SCI_INSERTTEXT.
	/// </summary>
	/// <param name="utf16"></param>
	/// <param name="pos">Start index. Cannot be negative.</param>
	/// <param name="s">Text to insert. Can be null.</param>
	/// <param name="addUndoPointBefore">Call <see cref="aaaAddUndoPoint"/> before.</param>
	/// <param name="addUndoPointAfter">Call <see cref="aaaAddUndoPoint"/> after.</param>
	/// <param name="restoreFolding">If <i>pos</i> is hidden because of folding, finally collapse its folding again. See <see cref="aaaFoldingRestorer"/>.</param>
	/// <remarks>
	/// Does not parse tags.
	/// Does not change current selection, unless <i>pos</i> is in it; for it use <see cref="aaaReplaceSel"/> or <see cref="aaaReplaceRange"/>.
	/// </remarks>
	public void aaaInsertText(bool utf16, int pos, string s, bool addUndoPointBefore = false, bool addUndoPointAfter = false, bool restoreFolding = false) {
		if (addUndoPointBefore) aaaAddUndoPoint();
		using (new _NoReadonly(this))
		using (new aaaFoldingRestorer(restoreFolding ? this : null, pos))
			aaaSetString(SCI_INSERTTEXT, _ParamPos(utf16, pos), s ?? "");
		if (addUndoPointAfter) aaaAddUndoPoint();
	}
	
	/// <summary>
	/// If ctor detects that the line from <i>pos</i> is hidden because of folding, <b>Dispose</b> collapses its folding again.
	/// Use when modifying text to prevent unfolding.
	/// </summary>
	public struct aaaFoldingRestorer : IDisposable {
		KScintilla _sci;
		int _foldLine;
		//tested: temp setting SCI_SETAUTOMATICFOLD does not work. If restoring async, does not expand, but draws incorrectly.
		
		/// <param name="sci">Can be null, then does nothing.</param>
		/// <param name="pos"></param>
		public aaaFoldingRestorer(KScintilla sci, int pos) {
			_sci = sci;
			_foldLine = -1;
			if (sci != null) {
				int line = sci.aaaLineFromPos(true, pos);
				if (0 == sci.Call(SCI_GETLINEVISIBLE, line)) _foldLine = sci.Call(SCI_GETFOLDPARENT, line);
			}
		}
		
		public void Dispose() {
			if (_foldLine < 0) return;
			_sci.Call(SCI_FOLDLINE, _foldLine);
			
			//If at the modified line index was a nested folding point, Scintilla will expand again, very async.
			//	Could restore again with the following code, but it can be dangerous, eg document closed. Never mind.
			//var sci = _sci; var i = _foldLine;
			//timer.after(300, _ => sci.Call(SCI_FOLDLINE, i));
		}
	}
	
	///// <summary>
	///// Inserts text at current position.
	///// Does not parse tags.
	///// Does not change current selection; for it use <see cref="aaaReplaceSel"/>.
	///// </summary>
	///// <param name="s">Text to insert. Can be null.</param>
	//public void aaaInsertText(string s)
	//{
	//	using(new _NoReadonly(this))
	//		aaaSetString(SCI_INSERTTEXT, -1, s ?? "");
	//}
	
	/// <summary>
	/// SCI_DELETERANGE.
	/// </summary>
	/// <param name="utf16"></param>
	/// <param name="from">Start index.</param>
	/// <param name="to">End index. If -1, uses control text length.</param>
	/// <remarks>
	/// Does not parse tags.
	/// Does not change current selection, unless it is in the range (including <i>to</i>); for it use <see cref="aaaReplaceSel"/> or <see cref="aaaReplaceRange"/>.
	/// </remarks>
	public void aaaDeleteRange(bool utf16, int from, int to) {
		aaaNormalizeRange(utf16, ref from, ref to);
		using (new _NoReadonly(this))
			Call(SCI_DELETERANGE, from, to - from);
	}
	
	/// <summary>
	/// Replaces text range.
	/// </summary>
	/// <param name="utf16"></param>
	/// <param name="from">Start index.</param>
	/// <param name="to">End index. If -1, uses control text length. Can be less than <i>from</i>.</param>
	/// <param name="s">Replacement text. Can be null.</param>
	/// <param name="moveCurrentPos">
	/// After replacing set curent position at the end of the replacement. If <i>from</i> less than to - at <i>from</i>.
	/// Else if current position was in the range (including <i>to</i>), Scintilla sets at <i>from</i>.
	/// Else does not change current position and selection.
	/// </param>
	/// <remarks>
	/// Does not parse tags.
	/// By default does not change current selection, unless it is in the range (including <i>to</i>).
	/// </remarks>
	public void aaaReplaceRange(bool utf16, int from, int to, string s, bool moveCurrentPos = false) {
		bool reverse = aaaNormalizeRangeCanBeReverse(utf16, ref from, ref to, swapFromTo: true);
		using (new _NoReadonly(this)) {
			int fromEnd = !moveCurrentPos || reverse ? 0 : aaaLen8 - to;
			Call(SCI_SETTARGETRANGE, from, to);
			aaaSetString(SCI_REPLACETARGET, s ?? "");
			if (moveCurrentPos) aaaCurrentPos8 = reverse ? from : aaaLen8 - fromEnd;
		}
	}
	
	/// <summary>
	/// Gets range text.
	/// </summary>
	/// <param name="utf16"></param>
	/// <param name="from">Start index.</param>
	/// <param name="to">End index. If -1, uses control text length.</param>
	public string aaaRangeText(bool utf16, int from, int to) {
		aaaNormalizeRange(utf16, ref from, ref to);
		return _RangeText(from, to);
	}
	
	/// <summary>
	/// Gets direct pointer to a text range in Scintilla buffer (SCI_GETRANGEPOINTER).
	/// Does not validate arguments, just asserts to >= from.
	/// </summary>
	/// <param name="from">UTF-8 start position.</param>
	/// <param name="to">UTF-8 end position.</param>
	public byte* aaaRangePointer(int from, int to) {
		Debug.Assert(to >= from);
		return (byte*)CallRetPtr(SCI_GETRANGEPOINTER, from, to - from);
	}
	
	/// <summary>
	/// Gets direct pointer to a text range in Scintilla buffer (SCI_GETRANGEPOINTER).
	/// Does not validate arguments, just asserts to >= from.
	/// </summary>
	/// <param name="from">UTF-8 start position.</param>
	/// <param name="to">UTF-8 end position.</param>
	public RByte aaaRangeSpan(int from, int to) => new(aaaRangePointer(from, to), to - from);
	
	/// <summary>
	/// SCI_REPLACESEL.
	/// </summary>
	/// <param name="s">Replacement text. Can be null.</param>
	/// <remarks>
	/// Does not parse tags.
	/// If read-only, asserts and fails (unlike most other functions that change text).
	/// </remarks>
	public void aaaReplaceSel(string s) {
		Debug.Assert(!aaaIsReadonly);
		aaaSetString(SCI_REPLACESEL, 0, s ?? "");
	}
	
	/// <summary>
	/// Sets selection (SCI_SETSEL) and replaces with new text (SCI_REPLACESEL).
	/// </summary>
	/// <param name="utf16"></param>
	/// <param name="from">Start index.</param>
	/// <param name="to">End index. If -1, uses control text length. Can be less than from.</param>
	/// <param name="s">Replacement text. Can be null.</param>
	/// <remarks>
	/// Does not parse tags.
	/// If read-only, asserts and fails (unlike most other functions that change text).
	/// </remarks>
	public void aaaSetAndReplaceSel(bool utf16, int from, int to, string s) {
		Debug.Assert(!aaaIsReadonly);
		aaaSelect(utf16, from, to);
		aaaSetString(SCI_REPLACESEL, 0, s ?? "");
	}
	
	/// <summary>
	/// SCI_GOTOPOS and ensures visible.
	/// </summary>
	public void aaaGoToPos(bool utf16, int pos) {
		pos = _ParamPos(utf16, pos);
		int line = Call(SCI_LINEFROMPOSITION, pos);
		Call(SCI_ENSUREVISIBLEENFORCEPOLICY, line);
		Call(SCI_GOTOPOS, pos);
	}
	
	/// <summary>
	/// SCI_GOTOLINE and ensures visible.
	/// </summary>
	public void aaaGoToLine(int line) {
		Call(SCI_ENSUREVISIBLEENFORCEPOLICY, line);
		Call(SCI_GOTOLINE, line);
	}
	
	/// <summary>
	/// SCI_SETSEL and optionally ensures visible.
	/// </summary>
	/// <param name="utf16"></param>
	/// <param name="from"></param>
	/// <param name="to">If -1, uses text length. Else <i>to</i> can be less than <i>from</i>. Caret will be at <i>to</i>.</param>
	/// <param name="makeVisible">Ensure line visible and selection visible. Without it in some cases selection to the left of the caret may be invisible.</param>
	public void aaaSelect(bool utf16, int from, int to, bool makeVisible = false) {
		aaaNormalizeRangeCanBeReverse(utf16, ref from, ref to, swapFromTo: false);
		if (makeVisible) aaaGoToPos(false, from);
		Call(SCI_SETSEL, from, to);
	}
	
	/// <summary>
	/// SCI_GETREADONLY, SCI_SETREADONLY.
	/// </summary>
	public bool aaaIsReadonly {
		get => 0 != Call(SCI_GETREADONLY);
		set => Call(SCI_SETREADONLY, value ? 1 : 0);
	}
	
	//public bool aaaIsReadonly {
	//	get => _isReadOnly;
	//	set {
	//		if (value != _isReadOnly) {
	//			_isReadOnly = value;
	//			if (!_w.Is0) Call(SCI_SETREADONLY, _isReadOnly);
	//		}
	//	}
	//}
	//bool _isReadOnly;
	
	/// <summary>
	/// Gets text and offsets of lines containing selection.
	/// Returns true. If <i>ifFullLines</i> is true, may return false.
	/// </summary>
	/// <param name="utf16">Return UTF-16.</param>
	/// <param name="x">Results.</param>
	/// <param name="ifFullLines">Fail (return false) if selection length is 0 or selection start is not at a line start.</param>
	/// <param name="oneMore">Get +1 line if selection ends at a line start, except if selection length is 0.</param>
	public bool aaaGetSelectionLines(bool utf16, out (int selStart, int selEnd, int linesStart, int linesEnd, string text) x, bool ifFullLines = false, bool oneMore = false) {
		x = default;
		x.selStart = aaaSelectionStart8; x.selEnd = aaaSelectionEnd8;
		if (ifFullLines && x.selEnd == x.selStart) return false;
		var (_, start, end) = aaaLineStartEndFromPos(false, x.selStart);
		if (ifFullLines && start != x.selStart) return false;
		x.linesStart = start;
		
		if (x.selEnd > x.selStart) {
			(_, start, end) = aaaLineStartEndFromPos(false, x.selEnd);
			if (!oneMore && start == x.selEnd) end = start; //selection end is at line start. We need the line only if oneMore.
			if (ifFullLines && x.selEnd < end) return false;
		}
		
		x.linesEnd = end;
		x.text = _RangeText(x.linesStart, end);
		if (utf16) {
			x.linesStart = aaaPos16(x.linesStart);
			x.linesEnd = aaaPos16(x.linesEnd);
			x.selStart = aaaPos16(x.selStart);
			x.selEnd = aaaPos16(x.selEnd);
		}
		return true;
	}
	
	public string aaaSelectedText() => _RangeText(aaaSelectionStart8, aaaSelectionEnd8);
	
	/// <summary>
	/// SCI_FINDTEXT.
	/// </summary>
	/// <param name="utf16">pos is UTF-16. Return UTF-16.</param>
	/// <param name="s"></param>
	/// <param name="start"></param>
	/// <param name="end">If -1, text length.</param>
	public unsafe int aaaFindText(bool utf16, RStr s, int start = 0, int end = -1) {
		aaaNormalizeRange(utf16, ref start, ref end);
		fixed (byte* b = _ToUtf8(s)) {
			var k = new Sci_TextToFind { cpMin = start, cpMax = end, lpstrText = b, chrgText = default };
			return _ReturnPosCanBeNegative(utf16, Call(SCI_FINDTEXT, SCFIND_MATCHCASE, &k));
		}
		//tested: with SCI_SEARCHINTARGET slightly slower
	}
	
	/// <summary>
	/// SCI_GETCHARAT.
	/// </summary>
	public char aaaCharAt8(int pos8) => (char)Call(SCI_GETCHARAT, pos8);
	
	/// <summary>
	/// SCI_BEGINUNDOACTION, SCI_ENDUNDOACTION.
	/// </summary>
	public void aaaAddUndoPoint() {
		Call(SCI_BEGINUNDOACTION);
		Call(SCI_ENDUNDOACTION);
	}
	
	/// <summary>
	/// SCI_BEGINUNDOACTION.
	/// </summary>
	/// <returns>Final counter of nested undo actions. Called SCI_BEGINUNDOACTION if it's 1.</returns>
	public int aaaBeginUndoAction() {
		if (_inUndoAction == 0) Call(SCI_BEGINUNDOACTION);
		return ++_inUndoAction;
	}
	int _inUndoAction;
	
	/// <summary>
	/// SCI_ENDUNDOACTION.
	/// </summary>
	/// <returns>Final counter of nested undo actions. Called SCI_ENDUNDOACTION if it's 0.</returns>
	public int aaaEndUndoAction() {
		Debug.Assert(_inUndoAction > 0);
		if (--_inUndoAction == 0) Call(SCI_ENDUNDOACTION);
		return _inUndoAction;
	}
	
	//currently not used. Moved to SciCode, which also supports onUndoDontChangeCaretPos.
	///// <summary>
	///// <c>=> new aaaUndoAction(this);</c>
	///// </summary>
	//public aaaUndoAction aaaNewUndoAction() => new aaaUndoAction(this);
	
	///// <summary>
	///// Ctor calls <see cref="aaaBeginUndoAction"/>. Dispose() calls <see cref="aaaEndUndoAction"/>.
	///// Does nothing if it's a nested undo action.
	///// </summary>
	//public struct aaaUndoAction : IDisposable {
	//	KScintilla _sci;
		
	//	/// <summary>
	//	/// Calls SCI_BEGINUNDOACTION.
	//	/// </summary>
	//	/// <param name="sci">Can be null, then does nothing.</param>
	//	public aaaUndoAction(KScintilla sci) {
	//		_sci = sci;
	//		_sci?.aaaBeginUndoAction();
	//	}
		
	//	/// <summary>
	//	/// Calls SCI_ENDUNDOACTION and clears this variable.
	//	/// </summary>
	//	public void Dispose() {
	//		if (_sci != null) {
	//			_sci.aaaEndUndoAction();
	//			_sci = null;
	//		}
	//	}
	//}
}

/// <summary>
/// Flags for 'set text', 'clear text' and similar functions. Eg you can disable Undo collection or 'changed' notifications.
/// Note: Ignores NoUndo and NoNotify if <b>AaInitReadOnlyAlways</b>, because then Undo and notifications are disabled when creating control.
/// </summary>
[Flags]
public enum SciSetTextFlags {
	/// <summary>
	/// Cannot be undone. Clear Undo buffer.
	/// </summary>
	NoUndo = 1,
	
	/// <summary>
	/// Don't send 'modified' and 'text changed' notifications (don't call overrides and events).
	/// </summary>
	NoNotify = 2,
	
	/// <summary>
	/// NoUndo | NoNotify.
	/// </summary>
	NoUndoNoNotify = 3,
}

/// <summary>
/// Provides fast direct access to a range of UTF-8 characters in Scintilla internal text.
/// Uses SCI_GETRANGEPOINTER. See <see cref="KScintilla.aaaRangePointer"/>.
/// Ensures that the gap is not moved (it could be slow if frequently).
/// </summary>
unsafe struct SciDirectRange {
	int _from, _to, _gap;
	byte* _p1, _p2; //before and after gap
	
	public SciDirectRange(KScintilla sci, int from8, int to8) {
		_from = from8;
		_to = to8;
		_gap = sci.Call(SCI_GETGAPPOSITION);
		//print.it(_from, _to, _gap);
		if (_gap > _from && _gap < _to) {
			_p1 = sci.aaaRangePointer(_from, _gap);
			_p2 = sci.aaaRangePointer(_gap, _to);
		} else {
			_p1 = sci.aaaRangePointer(_from, _to);
			_p2 = null;
		}
	}
	
	/// <summary>
	/// Returns character at position <i>i</i> in entire text (not from the start of the range).
	/// </summary>
	/// <exception cref="IndexOutOfRangeException"></exception>
	public char this[int i] {
		get {
			if (i < _from || i >= _to) throw new IndexOutOfRangeException();
			if (_p2 == null || i < _gap) return (char)_p1[i - _from];
			return (char)_p2[i - _gap];
		}
	}
}


================================================
FILE: Au.Controls/KScintilla/SciImages.cs
================================================
namespace Au.Controls;

using static Sci;

/// <summary>
/// Gets image file paths etc from <see cref="KScintilla"/> control text and displays the images below that lines.
/// </summary>
/// <remarks>
/// Draws images in annotation areas.
/// Supports text annotations too, below images and in no-image lines. But it is limited:
/// 1. To set/get it use <see cref="KScintilla.aaaAnnotationText(int, string, bool)"/>, not direct Scintilla API.
/// 2. You cannot hide all annotations (SCI_ANNOTATIONSETVISIBLE). This class sets it to show always.
/// 3. You cannot clear all annotations (SCI_ANNOTATIONCLEARALL).
/// 4. Setting annotation styles is currently not supported.
/// </remarks>
public unsafe class SciImages {
	class _Image {
		public long nameHash, evictionTime;
		public byte[] data;
		public int width, height;
	}
	
	class _ThreadSharedData {
		List<_Image> _a;
		int _dpi;
		timer _timer;
		
		public int CacheSize { get; private set; }
		
		public void AddImage(_Image im) {
			_a ??= [];
			_a.Add(im);
			CacheSize += im.data.Length;
			
			im.evictionTime = Environment.TickCount64 + 2000;
			//rejected: keep im in cache longer if the loading was slow. Eg AV scans exe files when we extract icons.
			//	Usually only the first time is slow. Later the file is in the OS file cache.
			
			_timer ??= new(t => {
				var now = Environment.TickCount64;
				for (int i = _a.Count; --i >= 0;)
					if (now - _a[i].evictionTime > 0) {
						CacheSize -= _a[i].data.Length;
						_a.RemoveAt(i);
					}
				
				if (_a.Count == 0) _timer.Stop();
			});
			if (!_timer.IsRunning) _timer.Every(500);
		}
		
		public _Image FindImage(long nameHash, int dpi) {
			if (dpi != _dpi) {
				ClearCache();
				_dpi = dpi;
			}
			if (!_a.NE_()) {
				for (int j = 0; j < _a.Count; j++) if (_a[j].nameHash == nameHash) return _a[j];
			}
			return null;
		}
		
		public void ClearCache() {
			_a?.Clear();
			CacheSize = 0;
		}
		
		/// <summary>
		/// If cache is large (at least MaxCacheSize and 4 images), removes about 3/4 of older cached images.
		/// Will auto-reload from files etc when need.
		/// </summary>
		public void CompactCache() {
			if (_a == null) return;
			//print.it(_cacheSize);
			if (CacheSize < MaxCacheSize || _a.Count < 4) return;
			CacheSize = 0;
			int n = _a.Count, max = MaxCacheSize / 4;
			while (CacheSize < max && n > 2) CacheSize += _a[--n].data.Length;
			_a.RemoveRange(0, n);
		}
		
		public int MaxCacheSize { get; set; } = 4 * 1024 * 1024;
	}
	[ThreadStatic] static _ThreadSharedData t_data; //all SciImages of a thread share single cache etc
	
	KScintilla _c;
	IntPtr _callbackPtr;
	const int c_indicImage = 7;
	
	/// <summary>
	/// Prepares this variable and the Scintilla control to display images.
	/// Note: will call SCI_ANNOTATIONSETVISIBLE(ANNOTATION_STANDARD) to draw images in annotation areas.
	/// Note: uses indicator 7.
	/// </summary>
	/// <param name="c">The control.</param>
	internal SciImages(KScintilla c) {
		t_data ??= new();
		_c = c;
		_sci_AnnotationDrawCallback = _AnnotationDrawCallback;
		_callbackPtr = Marshal.GetFunctionPointerForDelegate(_sci_AnnotationDrawCallback);
		_c.Call(SCI_SETANNOTATIONDRAWCALLBACK, 0, _callbackPtr);
		_c.aaaIndicatorDefine(c_indicImage, INDIC_HIDDEN);
	}
	
	_Image _GetImageFromText(RByte s) {
		//is it an image string?
		var imType = KImageUtil.ImageTypeFromString(out int prefixLength, s);
		if (imType == KImageUtil.ImageType.None) return null;
		if (prefixLength == 10) { s = s[prefixLength..]; prefixLength = 0; } //"imagefile:"
		
		var d = t_data;
		
		//is already loaded?
		long hash = Hash.Fnv1Long(s);
		var im = d.FindImage(hash, _c._dpi);
		//print.qm2.write(im != null, s.ToStringUTF8());
		if (im != null) return im;
		
		string path = s[prefixLength..].ToStringUTF8();
		
		//load
		long t1 = computer.tickCountWithoutSleep;
		byte[] b = KImageUtil.BmpFileDataFromString(path, imType, true, (_c._dpi, null));
		t1 = computer.tickCountWithoutSleep - t1; if (t1 > 1000) print.warning($"Time to load image '{path}' is {t1} ms.", -1, prefix: "<>Note: "); //eg if network path unavailable, may wait ~7 s
		if (b == null) return null;
		if (!KImageUtil.GetBitmapFileInfo_(b, out var q)) return null;
		
		//create _Image
		im = new _Image() {
			data = b,
			nameHash = hash,
			width = q.width,
			height = Math.Min(q.height + IMAGE_MARGIN_TOP + IMAGE_MARGIN_BOTTOM, 2000)
		};
		
		//add to cache
		//Compact cache to avoid memory problems when loaded many big images, eg showing all png in Program Files.
		//Will auto reload when need, it does not noticeably slow down.
		//Cache even very large images, because we draw each line separately, would need to load whole image for each line, which is VERY slow.
		d.CompactCache();
		d.AddImage(im);
		
		return im;
	}
	
	/// <summary>
	/// Sets image annotations for one or more lines of text.
	/// Called at the end of SciTags._AddText if the added text contains image tags.
	/// </summary>
	internal void SetImagesForTextRange_(RByte text, List<StartEnd> images, int prevLen) {
		bool allText = prevLen == 0;
		bool annotAdded = false;
		int iLine = -1, maxHeight = 0, totalWidth = 0;
		foreach (var v in images) {
			int line = _c.aaaLineFromPos(false, prevLen + v.start);
			if (line != iLine) {
				_AddLine();
				(iLine, maxHeight, totalWidth) = (line, 0, 0);
			}
			for (int start = v.start, end = 0; start < v.end; start = end + 1) { //foreach image in image1|image2|image3
				for (end = start; end < v.end && text[end] != '|';) end++;
				var s = text[start..end];
				if (_GetImageFromText(s) is not _Image u) continue;
				if (maxHeight < u.height) maxHeight = u.height;
				if (totalWidth > 0) totalWidth += 30;
				totalWidth += u.width;
				_c.aaaIndicatorAdd(c_indicImage, false, (start + prevLen)..(end + prevLen));
			}
		}
		_AddLine();
		
		[SkipLocalsInit]
		void _AddLine() {
			if (maxHeight == 0) return;
			int annotLen = _c.Call(SCI_ANNOTATIONGETTEXT, iLine); //we'll need old annotation text later, and we'll get it into the same buffer after the new image info
			
			//calculate n annotation lines from image height
			int lineHeight = _c.aaaLineHeight(); if (lineHeight <= 0) return;
			int nAnnotLines = Math.Min((maxHeight + (lineHeight - 1)) / lineHeight, 255);
			//print.it(lineHeight, maxHeight, nAnnotLines);
			
			using FastBuffer<byte> buffer = new(annotLen + nAnnotLines + 20);
			var p = buffer.p;
			*p++ = 3; Api._ltoa(totalWidth << 8 | nAnnotLines, p, 16); while (*(++p) != 0) { }
			while (nAnnotLines-- > 1) *p++ = (byte)'\n';
			*p = 0;
			
			//TODO2: code in this file can be simplified in several places. We don't use image+text annotations and images in editable text. Initially it was designed to support such images in code editor in editable mode.
			//An annotation possibly already exists. Possible cases:
			//1. No annotation. Need to add our image annotation.
			//2. A text-only annotation. Need to add our image annotation + that text.
			//3. Different image, no text. Need to replace it with our image annotation.
			//4. Different image + text. Need to replace it with our image annotation + that text.
			//5. This image, with or without text. Don't need to change.
			if (annotLen > 0) {
				//get existing annotation into the same buffer after our image info
				var a = p + 1;
				_c.Call(SCI_ANNOTATIONGETTEXT, iLine, a);
				a[annotLen] = 0;
				//print.it($"OLD: '{new string((sbyte*)a)}'");
				
				//is it our image info?
				int imageLen = (int)(p - buffer.p);
				if (annotLen >= imageLen) {
					int j;
					for (j = 0; j < imageLen; j++) if (a[j] != buffer[j]) goto g1;
					if (annotLen == imageLen || a[imageLen] == '\n') return; //case 5
				}
				g1:
				//contains image?
				if (a[0] == 3) {
					int j = _ParseAnnotText(a, annotLen, out var _);
					if (j < annotLen) { //case 4
						Api.memmove(a, a + j, annotLen - j + 1);
						p[0] = (byte)'\n';
					} //else case 3
				} else { //case 2
					p[0] = (byte)'\n';
				}
			} //else case 1
			
			//print.it($"NEW: '{new string((sbyte*)b0.p)}'");
			//perf.first();
			if (!annotAdded) {
				annotAdded = true;
				if (allText) _c.Call(SCI_ANNOTATIONSETVISIBLE, (int)AnnotationsVisible.ANNOTATION_HIDDEN);
			}
			_c.Call(SCI_ANNOTATIONSETTEXT, iLine, buffer.p);
			//perf.nw();
		}
		
		if (annotAdded && allText) {
			_c.Call(SCI_ANNOTATIONSETVISIBLE, (int)AnnotationsVisible.ANNOTATION_STANDARD);
		}
	}
	
	/// <summary>
	/// Parses annotation text.
	/// If it starts with image info string ("\x3NNN\n\n..."), returns its length. Else returns 0.
	/// </summary>
	/// <param name="s">Annotation text. Can start with image info string or not.</param>
	/// <param name="length">s length.</param>
	/// <param name="imageInfo">The NNN part of image info, or 0.</param>
	static int _ParseAnnotText(byte* s, int length, out int imageInfo) {
		imageInfo = 0;
		if (s == null || length < 4 || s[0] != '\x3') return 0;
		byte* s2;
		int k = Api.strtoi(s + 1, &s2, 16);
		int len = (int)(s2 - s); if (len < 4) return 0;
		int n = k & 0xff;
		len += (n - 1);
		if (n < 1 || length < len) return 0;
		if (length > len) len++; //\n between image info and visible annotation text
		imageInfo = k;
		return len;
	}
	
	/// <summary>
	/// Sets annotation text, preserving existing image info.
	/// </summary>
	/// <param name="line"></param>
	/// <param name="s">New text without image info.</param>
	[SkipLocalsInit]
	internal void AnnotationText_(int line, string s) {
		int n = _c.Call(SCI_ANNOTATIONGETTEXT, line);
		if (n > 0) {
			int lens = (s == null) ? 0 : s.Length;
			using FastBuffer<byte> buffer = new(n + 1 + lens * 3);
			var p = buffer.p;
			_c.Call(SCI_ANNOTATIONGETTEXT, line, p); p[n] = 0;
			int imageLen = _ParseAnnotText(p, n, out var _);
			if (imageLen > 0) {
				//info: now len<=n
				if (lens == 0) {
					if (imageLen == n) return; //no "\nPrevText"
					p[--imageLen] = 0; //remove "\nPrevText"
				} else {
					if (imageLen == n) p[imageLen++] = (byte)'\n'; //no "\nPrevText"
					//Convert2.Utf8FromString(s, p + imageLen, lens * 3);
					Encoding.UTF8.GetBytes(s, new Span<byte>(p + imageLen, lens * 3));
				}
				_c.Call(SCI_ANNOTATIONSETTEXT, line, p);
				return;
			}
		}
		_c.aaaAnnotationText_(line, s);
	}
	
	/// <summary>
	/// Gets annotation text without image info.
	/// </summary>
	[SkipLocalsInit]
	internal string AnnotationText_(int line) {
		int n = _c.Call(SCI_ANNOTATIONGETTEXT, line);
		if (n > 0) {
			using FastBuffer<byte> buffer = new(n);
			var p = buffer.p;
			_c.Call(SCI_ANNOTATIONGETTEXT, line, p); p[n] = 0;
			int imageLen = _ParseAnnotText(p, n, out var _);
			//info: now len<=n
			if (imageLen < n) {
				if (imageLen != 0) { p += imageLen; n -= imageLen; }
				return Encoding.UTF8.GetString(p, n);
			}
		}
		return "";
	}
	
	const int IMAGE_MARGIN_TOP = 2; //frame + 1
	const int IMAGE_MARGIN_BOTTOM = 1; //just for frame. It is minimal margin, in most cases will be more.
	
	Sci_AnnotationDrawCallback _sci_AnnotationDrawCallback;
	unsafe int _AnnotationDrawCallback(void* cbParam, ref Sci_AnnotationDrawCallbackData c) {
		//Function info:
		//Called for all annotations, not just for images.
		//Returns image width. Returns 0 if there is no image or when called for annotation text line below image.
		//Called for each line of annotation, not once for whole image. Draws each image slice separately.
		//Called 2 times for each line: step 0 - to get width; step 1 - to draw that image slice on that line. Step 0 skipped if AnnotationsVisible.ANNOTATION_STANDARD (we don't use other styles).
		
		//Get image info from annotation text. Return 0 if there is no image info, ie no image.
		//Image info is at the start. Format "\x3XXX", where XXX is a hex number that contains image width and number of lines.
		byte* s = c.text;
		if (c.textLen < 4 || s[0] != '\x3') return 0;
		int k = Api.strtoi(++s, null, 16); if (k < 256) return 0;
		int nLines = k & 0xff, width = k >> 8;
		
		if (c.step == 0) return width + 1; //just get width
		if (c.annotLine >= nLines) return 0; //an annotation text line below the image lines
		
		//find image strings and draw the images
		bool hasImages = false;
		var hdc = c.hdc;
		IntPtr pen = default, oldPen = default;
		try { //Handle exceptions because SetDIBitsToDevice may read more than need, like CreateDIBitmap, although I never noticed this.
			int from = _c.aaaLineStart(false, c.line), to = _c.aaaLineEnd(false, c.line);
			RECT r = c.rect;
			int x = r.left + 1;
			for (int end = from; ;) { //for each `IMAGE` in this line, in text like `A <image "IMAGE"> b <image "IMAGE|IMAGE"> c`
				int start = _c.Call(SCI_INDICATOREND, c_indicImage, end); if (start <= 0 || start >= to) break;
				end = _c.Call(SCI_INDICATOREND, c_indicImage, start); if (end <= start) break;
				
				var u = _GetImageFromText(_c.aaaRangeSpan(start, end)); //find cached image or load and addd to the cache
				if (u is null) break;
				hasImages = true;
				
				//draw image (single slice, for this visual line)
				if (!KImageUtil.GetBitmapFileInfo_(u.data, out var q)) { Debug.Assert(false); continue; }
				int isFirstLine = (c.annotLine == 0) ? 1 : 0, hLine = r.bottom - r.top;
				int currentTop = c.annotLine * hLine, currentBottom = currentTop + hLine, imageBottom = q.height + IMAGE_MARGIN_TOP;
				int y = r.top + isFirstLine * IMAGE_MARGIN_TOP, yy = Math.Min(currentBottom, imageBottom) - currentTop;
				
				if (imageBottom > currentTop && q.width > 0 && q.height > 0) {
					fixed (byte* bp = u.data) {
						KImageUtil.BITMAPFILEHEADER* f = (KImageUtil.BITMAPFILEHEADER*)bp;
						byte* pBits = bp + f->bfOffBits;
						int bytesInLine = Math2.AlignUp(q.width * q.bitCount, 32) / 8;
						int sizF = u.data.Length - f->bfOffBits, siz = bytesInLine * q.height;
						if (q.isCompressed) {
							//this is slow with big images. It seems processes current line + all remaining lines. Such bitmaps are rare.
							int yOffs = -c.annotLine * hLine; if (isFirstLine == 0) yOffs += IMAGE_MARGIN_TOP;
							var ok = Api.SetDIBitsToDevice(hdc, x, r.top + isFirstLine * IMAGE_MARGIN_TOP,
								q.width, q.height, 0, yOffs, 0, q.height,
								pBits, q.biHeader);
							Debug.Assert(ok > 0);
						} else if (siz <= sizF) {
							//this is fast, but cannot use with compressed bitmaps
							int hei = yy - y, bmY = q.height - (currentTop - ((isFirstLine ^ 1) * IMAGE_MARGIN_TOP) + hei);
							var ok = Api.SetDIBitsToDevice(hdc, x, r.top + isFirstLine * IMAGE_MARGIN_TOP,
								q.width, hei, 0, 0, 0, hei,
								pBits + bmY * bytesInLine, q.biHeader);
							Debug.Assert(ok > 0);
						} else Debug.Assert(false);
						
						//could use this instead, but very slow with big images. It seems always processes whole bitmap, not just current line.
						//int hei=yy-y, bmY=q.height-(currentTop-((isFirstLine ^ 1)*IMAGE_MARGIN_TOP)+hei);
						//StretchDIBits(hdc,
						//	x, y, q.width, hei,
						//	0, bmY, q.width, hei,
						//	pBits, h, 0, SRCCOPY);
					}
				}
				
				//draw frame
				if (pen == default) oldPen = Api.SelectObject(hdc, pen = Api.CreatePen(0, 1, 0x60C060)); //quite fast. Caching in a static or ThreadStatic var is difficult.
				int xx = x + q.width;
				if (isFirstLine != 0) y--;
				if (yy > y) {
					Api.MoveToEx(hdc, x - 1, y, out _); Api.LineTo(hdc, x - 1, yy); //left |
					Api.MoveToEx(hdc, xx, y, out _); Api.LineTo(hdc, xx, yy); //right |
					if (isFirstLine != 0) { Api.MoveToEx(hdc, x, y, out _); Api.LineTo(hdc, xx, y); } //top _
				}
				if (yy >= y && yy < hLine) { Api.MoveToEx(hdc, x - 1, yy, out _); Api.LineTo(hdc, xx + 1, yy); } //bottom _
				
				x += u.width + 30;
			}
		}
		catch (Exception ex) { Debug_.Print(ex); }
		finally { if (pen != default) Api.DeleteObject(Api.SelectObject(hdc, oldPen)); }
		//perf.nw();
		
		//If there are no image strings (text edited), delete the annotation or just its part containing image info and '\n's.
		if (!hasImages && c.annotLine == 0) {
			int line = c.line; var annot = AnnotationText_(line);
			//_c.aaaAnnotationText_(line, annot); //dangerous
			_c.Dispatcher.InvokeAsync(() => { _c.aaaAnnotationText_(line, annot); });
			return 1;
		}
		
		return width + 1;
		
		//speed: fast. The fastest way. Don't need bitmap handle, memory DC, etc.
		//tested: don't know what ColorUse param of SetDIBitsToDevice does, but DIB_RGB_COLORS works for any h_biBitCount.
		//speed if drawing frame: multiple LineTo is faster than single PolyPolyline.
		//tested: GDI+ much slower, particularly DrawImage().
		//tested: in QM2 was used LZO compression, now ZIP (DeflateStream). ZIP compresses better, but not so much. LZO is faster, but ZIP is fast enough. GIF and JPG in most cases compress less than ZIP and sometimes less than LZO.
		//tested: saving in 8-bit format in most cases does not make much smaller when compressed. For screenshots we reduce colors to 4-bit.
	}
}


================================================
FILE: Au.Controls/KScintilla/SciTags.cs
================================================
/*
Most tags are like in QM2.

NEW TAGS:
   <bi> - bold italic.
   <mono> - monospace font.
   <size n> - font size (1-127).
   <fold> - collapsed lines.
   <explore> - select file in File Explorer.
   <\a>text</\a> - alternative for <_>text</_>.
   <nonl> - no newline.

NEW PARAMETERS:
   <c ColorName> - .NET color name for text color. Also color can be #RRGGBB.
   <bc ColorName> - .NET color name for background color. Also color can be #RRGGBB.
   <lc ColorName> - .NET color name for background color, whole line. Also color can be #RRGGBB.

RENAMED TAGS:
	<script>, was <macro>.
	<bc>, was <z>.
	<lc>, was <Z>.

REMOVED TAGS:
	<tip>.
	<mes>, <out>. Now use <fold>.

DIFFERENT SYNTAX:
	Most tags can be closed with <> or </> or </anything>.
		Except these: <_>text</_>, <\a>text</\a>, <code>code</code>, <fold>text</fold>.
		No closing tag: <image "file">.
	Attributes can be enclosed with "" or '' or non-enclosed (except for <image>).
		Does not support escape sequences. An attribute ends with "> (if starts with ") or '> (if starts with ') or > (if non-enclosed).
		In QM2 need "" for most; some can be non-enclosed. QM2 supports escape sequences.
	Link tag attribute parts now are separated with "|". In QM2 was " /".

OTHER CHANGES:
	Supports user-defined link tags. Need to provide delegates of functions that implement them. Use SciTags.AddCommonLinkTag or SciTags.AddLinkTag.
	These link tags are not implemented by this class, but you can provide delegates of functions that implement them:
		<open>, <script>.
	<help> by default calls Au.More.HelpUtil.AuHelp, which opens a topic in web browser. You can override it with SciTags.AddCommonLinkTag or SciTags.AddLinkTag.
	<code> attributes are not used.

CHANGES IN <image>:
	Don't need the closing tag (</image>).
	Currently supports only 16x16 icons. Does not support icon resources.
	Supports images embedded directly in text.
	More info in help topic "Output tags". File "Output tags.md".
*/

namespace Au.Controls;

using static Sci;

/// <summary>
/// Adds links and text formatting to a <see cref="KScintilla"/> control.
/// </summary>
/// <remarks>
/// Links and formatting is specified in text, using tags like in HTML. Depending on control style, may need prefix <c><![CDATA[<>]]></c>.
/// Reference: [](xref:output_tags).
/// Tags are supported by <see cref="print.it"/> when it writes to the Au script editor.
/// 
/// This control does not implement some predefined tags: open, script.
/// If used, must be implemented by the program.
/// Also you can register custom link tags that call your callback functions.
/// See <see cref="AddLinkTag"/>, <see cref="AddCommonLinkTag"/>.
/// 
/// Tags are supported by some existing controls based on <see cref="KScintilla"/>. In editor it is the output (use <see cref="print.it"/>, like in the example below). In this library - the <see cref="KSciInfoBox"/> control. To enable tags in other <see cref="KScintilla"/> controls, use <see cref="KScintilla.AaInitTagsStyle"/> and optionally <see cref="KScintilla.AaInitImages"/>.
/// </remarks>
/// <example>
/// <code><![CDATA[
/// print.it("<>Text with <i>tags<>.");
/// ]]></code>
/// </example>
public unsafe class SciTags {
	const int STYLE_FIRST_EX = STYLE_LASTPREDEFINED + 1;
	const int NUM_STYLES_EX = STYLE_MAX - STYLE_LASTPREDEFINED;
	
	public struct TagStyle {
		uint u1, u2;
		
		//u1
		public int Color { get => (int)(u1 & 0xffffff); set => u1 = (u1 & 0xff000000) | ((uint)value & 0xffffff) | 0x1000000; }
		public bool HasColor => 0 != (u1 & 0x1000000);
		public int Size { get => (int)(u1 >> 25); set => u1 = (u1 & 0x1ffffff) | ((uint)Math.Clamp(value, 0, 127) << 25); }
		
		//u2
		public int BackColor { get => (int)(u2 & 0xffffff); set => u2 = (u2 & 0xff000000) | ((uint)value & 0xffffff) | 0x1000000; }
		public bool HasBackColor => 0 != (u2 & 0x1000000);
		public bool Bold { get => 0 != (u2 & 0x2000000); set { if (value) u2 |= 0x2000000; else u2 &= unchecked((uint)~0x2000000); } }
		public bool Italic { get => 0 != (u2 & 0x4000000); set { if (value) u2 |= 0x4000000; else u2 &= unchecked((uint)~0x4000000); } }
		public bool Underline { get => 0 != (u2 & 0x8000000); set { if (value) u2 |= 0x8000000; else u2 &= unchecked((uint)~0x8000000); } }
		public bool Eol { get => 0 != (u2 & 0x10000000); set { if (value) u2 |= 0x10000000; else u2 &= unchecked((uint)~0x10000000); } }
		public bool Hotspot { get => 0 != (u2 & 0x40000000); set { if (value) u2 |= 0x40000000; else u2 &= unchecked((uint)~0x40000000); } }
		public bool Mono { get => 0 != (u2 & 0x80000000); set { if (value) u2 |= 0x80000000; else u2 &= unchecked((uint)~0x80000000); } }
		
		public bool Equals(TagStyle x) { return x.u1 == u1 && x.u2 == u2; }
		public void Merge(TagStyle x) {
			var t1 = x.u1;
			if (HasColor) t1 &= 0xff000000;
			if (Size > 0) t1 &= 0x1ffffff;
			u1 |= t1;
			var t2 = x.u2;
			if (HasBackColor) {
				t2 &= 0xff000000;
				t2 &= unchecked((uint)~0x10000000); //don't inherit Eol
			}
			u2 |= t2;
		}
		public bool IsEmpty => u1 == 0 & u2 == 0;
		
		public TagStyle(UserDefinedStyle k) {
			u1 = u2 = 0;
			if (k.textColor != null) Color = k.textColor.Value.argb;
			if (k.backColor != null) BackColor = k.backColor.Value.argb;
			Size = k.size;
			Bold = k.bold;
			Italic = k.italic;
			Underline = k.underline;
			Eol = k.eolFilled;
			Mono = k.monospace;
		}
	}
	
	/// <summary>
	/// For <see cref="AddStyleTag"/>.
	/// </summary>
	public class UserDefinedStyle {
		public ColorInt? textColor, backColor;
		public int size;
		public bool bold, italic, underline, eolFilled, monospace;
	}
	
	readonly KScintilla _c;
	readonly List<TagStyle> _styles = [];
	
	internal SciTags(KScintilla c) {
		_c = c;
	}
	
	public (IReadOnlyList<TagStyle> a, int first) TagStyles => (_styles, STYLE_FIRST_EX);
	
	/// <summary>
	/// Font name and size for tag styles with <see cref="TagStyle.Mono"/>.
	/// If not set, will use "Consolas" and default text size.
	/// Not used for the styled code tag.
	/// Does not update existing styles when the property changed.
	/// </summary>
	public (string name, double size) FontForMonoTags { get; set; }
	
	void _SetUserStyles(int from) {
		int i, j;
		for (i = from; i < _styles.Count; i++) {
			TagStyle st = _styles[i];
			j = i + STYLE_FIRST_EX;
			if (st.HasColor) _c.aaaStyleForeColor(j, st.Color);
			if (st.HasBackColor) { _c.aaaStyleBackColor(j, st.BackColor); if (st.Eol) _c.aaaStyleEolFilled(j, true); }
			if (st.Bold) _c.aaaStyleBold(j, true);
			if (st.Italic) _c.aaaStyleItalic(j, true);
			if (st.Underline) _c.aaaStyleUnderline(j, true);
			if (st.Mono) _c.aaaStyleFont(j, FontForMonoTags.name ?? "Consolas");
			if (st.Hotspot) _c.aaaStyleHotspot(j, true);
			int size = st.Size;
			if (size > 0) {
				if (size < 6 && st.Hotspot) size = 6;
				_c.aaaStyleFontSize(j, size);
			} else if (st.Mono && FontForMonoTags.size >= 6) {
				_c.aaaStyleFontSize(j, FontForMonoTags.size);
			}
		}
	}
	
	/// <summary>
	/// Clears user-defined (through tags) styles.
	/// Max number of user styles is NUM_STYLES_EX (216). Need to clear old styles before new styles can be defined.
	/// This func is usually called after clearing control text.
	/// </summary>
	void _ClearUserStyles() {
		if (_styles.Count > 0) {
			_c.aaaStyleClearRange(STYLE_FIRST_EX);
			_styles.Clear();
		}
		//QM2 also cleared the image cache, but now it is shared by all controls of this thread.
	}
	
	internal void OnTextChanged_(bool inserted, in SCNotification n) {
		//if deleted or replaced all text, clear user styles
		if (!inserted && n.position == 0 && _c.aaaLen8 == 0) {
			_ClearUserStyles();
			//_linkDelegates.Clear(); //no
		}
	}
	
	/// <summary>
	/// Displays <see cref="PrintServer"/> messages that are currently in its queue.
	/// </summary>
	/// <param name="ps">The <b>PrintServer</b> instance.</param>
	/// <param name="onMessage">
	/// A callback function that can be called when this function gets/removes a message from ps.
	/// When message type is Write, it can change message text; if null, this function ignores the message.
	/// It also processes messages of type TaskEvent; this function ignores them.
	/// </param>
	/// <remarks>
	/// Removes messages from the queue.
	/// Appends text messages + "\r\n" to the control's text, or clears etc (depends on message).
	/// Messages with tags must have prefix "&lt;&gt;".
	/// Limits text length to about 4 MB (removes oldest text when exceeded).
	/// </remarks>
	/// <seealso cref="PrintServer.SetNotifications"/>
	public void PrintServerProcessMessages(PrintServer ps, Action<PrintServerMessage> onMessage = null) {
		//info: Cannot call _c.Write for each message, it's too slow. Need to join all messages.
		//	If multiple messages, use StringBuilder.
		//	If some messages have tags, use string "<\x15\x0\x4" to separate messages. Never mind: don't escape etc.
		
		string s = null;
		StringBuilder b = null;
		bool hasTags = false, hasTagsPrev = false, scrollToTop = false;
		while (ps.GetMessage(out var m)) {
			onMessage?.Invoke(m);
			switch (m.Type) {
			case PrintServerMessageType.Clear:
				_c.aaaClearText();
				s = null;
				b?.Clear();
				break;
			case PrintServerMessageType.ScrollToTop:
				scrollToTop = true;
				break;
			case PrintServerMessageType.Write when m.Text != null:
				if (s == null) {
					s = m.Text;
					hasTags = hasTagsPrev = s.Starts("<>");
				} else {
					b ??= new StringBuilder();
					if (b.Length == 0) b.Append(s);
					
					s = m.Text;
					
					bool hasTagsThis = m.Text.Starts("<>");
					if (hasTagsThis && !hasTags) { hasTags = true; b.Insert(0, "<\x15\x0\x4"); }
					
					if (!hasTags) {
						b.Append("\r\n");
					} else if (hasTagsThis) {
						b.Append("\r\n<\x15\x0\x4");
						//info: add "\r\n" here, not later, because later it would make more difficult <lc> tag
					} else {
						b.Append(hasTagsPrev ? "\r\n<\x15\x0\x4" : "\r\n");
					}
					b.Append(s);
					hasTagsPrev = hasTagsThis;
				}
				break;
			}
		}
		
		if (s != null) { //else 0 messages or the last message is Clear
			if (b != null) s = b.ToString();
			
			//limit
			int len = _c.aaaLen8;
			if (len > 10_000_000) {
				len = _c.aaaLineStartFromPos(false, len / 2);
				if (len > 0) _c.aaaReplaceRange(false, 0, len, "...\r\n");
			}
			
			if (hasTags) AddText(s, true, true);
			else _c.aaaAppendText(s, true, true, true);
			
			//test slow client
			//Thread.Sleep(500);
			//print.qm2.write(s.Length / 1048576d);
		}
		
		if (scrollToTop) _c.Call(SCI_SETFIRSTVISIBLELINE);
		//never mind: more print.it() may be after print.scrollToTop().
	}
	
	/// <summary>
	/// Sets or appends styled text.
	/// </summary>
	/// <param name="text">Text with tags (optionally).</param>
	/// <param name="append">Append. Also appends "\r\n". If false, replaces control text.</param>
	/// <param name="skipLTGT">If text starts with "&lt;&gt;", skip it.</param>
	/// <param name="scroll">Set caret and scroll to the end. If null, does it if <i>append</i> true.</param>
	public void AddText(string text, bool append, bool skipLTGT, bool? scroll = null, bool dontHideImageTag = false) {
		//perf.first();
		if (text.NE() || (skipLTGT && text == "<>")) {
			if (append) _c.aaaAppendText("", true, true, true); else _c.aaaClearText();
			return;
		}
		
		int len = Encoding.UTF8.GetByteCount(text);
		byte* buffer = MemoryUtil.Alloc(len * 2 + 8), s = buffer;
		try {
			Encoding.UTF8.GetBytes(text, new Span<byte>(buffer, len));
			if (append) { s[len++] = (byte)'\r'; s[len++] = (byte)'\n'; }
			if (skipLTGT && s[0] == '<' && s[1] == '>') { s += 2; len -= 2; }
			s[len] = s[len + 1] = 0;
			_AddText(s, len, append, scroll, dontHideImageTag);
		}
		finally {
			MemoryUtil.Free(buffer);
		}
	}
	
	record struct _StackItem(byte kind, byte style, int i = 0, string s = null, ushort attrLen = 0); //kind: 0 style, 1 link, 2 fold
	
	class _Garbage {
		public readonly List<_StackItem> stack = new();
		public readonly List<StartEnd> codes = new();
		public readonly List<POINT> folds = new();
		public readonly List<(int start, int end, string s)> links = new();
		
		public void Clear() {
			stack.Clear();
			codes.Clear();
			folds.Clear();
			links.Clear();
		}
	}
	[ThreadStatic] static WeakReference<_Garbage> t_garbage;
	
	void _AddText(byte* s, int len, bool append, bool? scroll, bool dontHideImageTag) {
		//perf.next();
		byte* s0 = s, sEnd = s + len; //source text
		byte* t = s0; //destination text (without some tags)
		byte* r0 = s0 + (len + 2), r = r0; //destination style bytes
		
		int prevStylesCount = _styles.Count;
		bool hasTags = false;
		byte currentStyle = STYLE_DEFAULT;
		List<StartEnd> images = null;
		
		if ((t_garbage ??= new(null)).TryGetTarget(out var m)) m.Clear(); else t_garbage.SetTarget(m = new());
		
		while (s < sEnd) {
			//find '<'
			var ch = *s++;
			if (ch != '<') {
				_Write(ch, currentStyle);
				continue;
			}
			
			var tag = s;
			
			//end tag. Support <> and </tag>, but don't care what tag it is.
			if (s[0] == '/') {
				s++;
				ch = *s; if ((char)ch is '+' or '.') s++;
				while (((char)*s).IsAsciiAlpha()) s++;
				if (s[0] != '>') goto ge;
			}
			if (s[0] == '>') {
				int n = m.stack.Count - 1;
				if (n < 0) goto ge; //<> without tag
				s++;
				var v = m.stack[n];
				if (v.kind is 0 or 1) { //the tag is a style tag or some other styled tag (eg link)
					if (currentStyle >= STYLE_FIRST_EX && _styles[currentStyle - STYLE_FIRST_EX].Eol) {
						if (*s == '\r') _Write(*s++, currentStyle);
						if (*s == '\n') _Write(*s++, currentStyle);
					}
					currentStyle = v.style;
					if (v.kind == 1) m.links.Add((v.i, (int)(t - s0), v.s));
				} else { //currently can be only 2 for <fold>
					if (!(s - tag == 6 && new RByte(tag + 1, 4).StartsWith("fold"u8))) goto ge;
					m.folds.Add((v.i, (int)(t - s0)));
					m.links.Add((v.i, v.i + v.attrLen, ""));
				}
				m.stack.RemoveAt(n);
				continue;
			}
			
			//multi-message separator
			if (s[0] == 0x15 && s[1] == 0 && s[2] == 4 && (s - s0 == 1 || s[-2] == 10)) {
				s += 3;
				if (s[0] == '<' && s[1] == '>') s += 2; //message with tags
				else { //one or more messages without tags
					while (s < sEnd && !(s[0] == '<' && s[1] == 0x15 && s[2] == 0 && s[3] == 4 && s[-1] == 10)) _Write(*s++, STYLE_DEFAULT);
				}
				currentStyle = STYLE_DEFAULT;
				m.stack.Clear();
				continue;
			}
			
			//read tag name
			ch = *s; if ((char)ch is '_' or '\a' or '+' or '.') s++;
			while (((char)*s).IsAsciiAlpha()) s++;
			int tagLen = (int)(s - tag);
			if (tagLen == 0) goto ge;
			
			//read attribute
			byte* attr = null; int attrLen = 0;
			if (*s == 32) {
				var quot = *(++s);
				if ((char)quot is '\'' or '"') s++; else quot = (byte)'>'; //never mind: escape sequences \\, \', \"
				attr = s;
				while (*s != quot && *s != 0) s++;
				if (*s == 0) goto ge; //either the end of string or a multi-message separator
				attrLen = (int)(s - attr);
				if (quot != '>' && *(++s) != '>') goto ge;
				s++;
			} else {
				if (*s++ != '>') goto ge;
			}
			
			//tags
			TagStyle style = default;
			bool linkTag = false;
			int i2;
			ch = *tag;
			var span = new RByte(tag, tagLen);
			switch (tagLen << 16 | ch) {
			case 1 << 16 | 'b':
				style.Bold = true;
				break;
			case 1 << 16 | 'i':
				style.Italic = true;
				break;
			case 2 << 16 | 'b' when tag[1] == 'i':
				style.Bold = style.Italic = true;
				break;
			case 1 << 16 | 'u':
				style.Underline = true;
				break;
			case 1 << 16 | 'c':
			case 2 << 16 | 'b' when tag[1] == 'c':
			case 2 << 16 | 'l' when tag[1] == 'c':
			case 2 << 16 | 'B' when tag[1] == 'C': //fbc
			case 1 << 16 | 'z' or 1 << 16 | 'Z': //fbc
				if (attr == null) goto ge;
				int color;
				if (((char)*attr).IsAsciiDigit()) color = Api.strtoi(attr);
				else if (*attr == '#') color = Api.strtoi(attr + 1, radix: 16);
				else {
					var c = System.Drawing.Color.FromName(new string((sbyte*)attr, 0, attrLen));
					if (c.A == 0) break; //invalid color name
					color = c.ToArgb() & 0xffffff;
				}
				if (ch == 'c') style.Color = color; else style.BackColor = color;
				if ((char)ch is 'l' or 'B' or 'Z') style.Eol = true;
				break;
			case 4 << 16 | 's' when span.SequenceEqual("size"u8) && attr != null:
				style.Size = Api.strtoi(attr);
				break;
			case 4 << 16 | 'm' when span.SequenceEqual("mono"u8):
				style.Mono = true;
				break;
			//case 6 << 16 | 'h' when span.SequenceEqual("hidden"u8): //rejected. Not useful; does not hide newlines.
			//	style.Hidden = true;
			//	break;
			case 5 << 16 | 'i' when span.SequenceEqual("image"u8) && attr != null:
				Debug_.PrintIf(_c.AaImages is null);
				for (var h = tag - 1; h < s; h++) _Write(*h, (byte)(dontHideImageTag ? STYLE_DEFAULT : STYLE_HIDDEN));
				hasTags = true;
				int imageOutPos = (int)((attr - s0) - (s - t));
				(images ??= []).Add(new(imageOutPos, imageOutPos + attrLen));
				continue;
			case 4 << 16 | 'n' when span.SequenceEqual("nonl"u8):
				if (s[0] == 13) s++;
				if (s[0] == 10) s++;
				continue;
			case 1 << 16 | '_': //<_>text where tags are ignored</_>
			case 1 << 16 | '\a': //<\a>text where tags are ignored</\a>
				i2 = new RByte(s, (int)(sEnd - s)).IndexOf(ch == '_' ? "</_>"u8 : "</\a>"u8); if (i2 < 0) goto ge;
				while (i2-- > 0) _Write(*s++, currentStyle);
				s += 4;
				continue;
			case 4 << 16 | 'c' when span.SequenceEqual("code"u8): //<code>code</code>
				i2 = new RByte(s, (int)(sEnd - s)).IndexOf("</code>"u8); if (i2 < 0) goto ge;
				if (CodeStylesProvider != null) {
					int iStartCode = (int)(t - s0);
					m.codes.Add(new(iStartCode, iStartCode + i2));
					hasTags = true;
				}
				while (i2-- > 0) _Write(*s++, STYLE_DEFAULT);
				s += 7;
				continue;
			case 4 << 16 | 'f' when span.SequenceEqual("fold"u8): //<fold>text</fold>
				bool foldHasAttr = attrLen > 0; if (foldHasAttr) attrLen = Math.Min(attrLen, ushort.MaxValue);
				m.stack.Add(new(2, 0, (int)(t - s0), attrLen: (ushort)(foldHasAttr ? attrLen : 2)));
				//add 'expand/collapse' link in this line
				byte foldStyle = _GetStyleIndex(new TagStyle { Hotspot = true, Underline = true, Color = 0x80FF }, currentStyle, m.stack);
				if (!foldHasAttr) _WriteString(">>", foldStyle); else for (int i = 0; i < attrLen; i++) _Write(attr[i], foldStyle);
				//let the folded text start from next line
				var s1 = s; if (s1[0] == '<' && (char)s1[1] is '_' or '\a' && s1[2] == '>') s1 += 3;
				if (s1[0] is not (10 or 13)) _WriteString("\r\n", currentStyle);
				hasTags = true;
				continue;
			case 4 << 16 | 'l' when span.SequenceEqual("link"u8):
			case 6 << 16 | 'g' when span.SequenceEqual("google"u8):
			case 4 << 16 | 'h' when span.SequenceEqual("help"u8):
			case 7 << 16 | 'e' when span.SequenceEqual("explore"u8):
			case 4 << 16 | 'o' when span.SequenceEqual("open"u8):
			case 6 << 16 | 's' when span.SequenceEqual("script"u8):
				linkTag = true;
				break;
			default:
				//user-defined tag or unknown.
				//user-defined tags must start with '+' (links) or '.' (styles).
				//don't hide unknown tags, unless start with '+'. Can be either misspelled (hiding would make harder to debug) or not intended for us (forgot <_>).
				if (ch == '+') {
					//if(!_userLinkTags.ContainsKey(new string((sbyte*)tag, 0, tagLen))) goto ge; //no, it makes slower and creates garbage. Also would need to look in the static dictionary too. It's not so important to check now because we use '+' prefix.
					linkTag = true;
					break;
				} else if (ch == '.' && _FindUserStyle(new(tag, tagLen), out style) == true) {
					break;
				}
				goto ge;
			}
			
			if (linkTag) {
				if (!(ch == '+' && _FindUserStyle(new(tag, tagLen), out style))) {
					if (DefaultLinkStyle != null) style = new TagStyle(DefaultLinkStyle);
					else { style.Color = 0x0080FF; style.Underline = true; }
				}
				style.Hotspot = true;
			}
			
			byte si = _GetStyleIndex(style, currentStyle, m.stack);
			if (linkTag) {
				m.stack.Add(new(1, currentStyle, (int)(t - s0), Encoding.UTF8.GetString(tag, (int)(s - tag - 1))));
			} else {
				m.stack.Add(new(0, currentStyle));
			}
			currentStyle = si;
			
			hasTags = true;
			continue;
			ge: //invalid format of the tag
			_Write((byte)'<', currentStyle);
			s = tag;
		}
		
		Debug.Assert(t <= s0 + len);
		Debug.Assert(r <= r0 + len);
		Debug.Assert(t - s0 == r - r0);
		*t = 0; len = (int)(t - s0);
		
		if (_styles.Count > prevStylesCount) _SetUserStyles(prevStylesCount);
		
		//perf.next();
		int prevLen = append ? _c.aaaLen8 : 0;
		_c.aaaAddText8_(append, scroll ?? append, s0, len);
		if (!hasTags) {
			_c.Call(SCI_STARTSTYLING, prevLen);
			_c.Call(SCI_SETSTYLING, len, STYLE_DEFAULT);
			return;
		}
		
		foreach (var v in m.links) {
			_c.AaRangeDataAdd(false, (prevLen + v.start)..(prevLen + v.end), v.s);
		}
		
		for (int i = m.folds.Count; --i >= 0;) { //need reverse for nested folds
			var v = m.folds[i];
			int lineStart = _c.Call(SCI_LINEFROMPOSITION, v.x + prevLen), lineEnd = _c.Call(SCI_LINEFROMPOSITION, v.y + prevLen);
			int level = _c.Call(SCI_GETFOLDLEVEL, lineStart) & SC_FOLDLEVELNUMBERMASK;
			_c.Call(SCI_SETFOLDLEVEL, lineStart, level | SC_FOLDLEVELHEADERFLAG);
			for (int j = lineStart + 1; j <= lineEnd; j++) _c.Call(SCI_SETFOLDLEVEL, j, level + 1);
			_c.Call(SCI_FOLDLINE, lineStart);
		}
		
		int endStyled = 0;
		foreach (var v in m.codes) {
			_StyleRangeTo(v.start);
			var code = Encoding.UTF8.GetString(s0 + v.start, v.Length);
			//print.qm2.write(v, code);
			var b = CodeStylesProvider(code);
			_c.Call(SCI_STARTSTYLING, v.start + prevLen);
			fixed (byte* p = b) _c.Call(SCI_SETSTYLINGEX, b.Length, p);
			endStyled = v.end;
		}
		
		_StyleRangeTo(len);
		//perf.next();
		//print.qm2.write(perf.ToString());
		
		if (images != null) _c.AaImages?.SetImagesForTextRange_(new(s0, len), images, prevLen);
		
		void _StyleRangeTo(int to) {
			if (endStyled < to) {
				_c.Call(SCI_STARTSTYLING, endStyled + prevLen);
				_c.Call(SCI_SETSTYLINGEX, to - endStyled, r0 + endStyled);
			}
		}
		
		void _Write(byte ch, byte style) {
			//print.qm2.write($"{ch} {style}");
			*t++ = ch; *r++ = style;
		}
		
		void _WriteString(string ss, byte style) {
			for (int i_ = 0; i_ < ss.Length; i_++) _Write((byte)ss[i_], style);
		}
	}
	
	byte _GetStyleIndex(TagStyle style, byte currentStyle, List<_StackItem> stack) {
		//merge nested style with ancestors
		if (currentStyle >= STYLE_FIRST_EX) style.Merge(_styles[currentStyle - STYLE_FIRST_EX]);
		for (int j = stack.Count; --j > 0;) {
			var v = stack[j];
			if (v.kind is not (0 or 1)) continue; //a non-styled tag
			if (v.style >= STYLE_FIRST_EX) style.Merge(_styles[v.style - STYLE_FIRST_EX]);
		}
		
		//find or add style
		int i, n = _styles.Count;
		for (i = 0; i < n; i++) if (_styles[i].Equals(style)) break;
		if (i == NUM_STYLES_EX) {
			i = currentStyle;
			//CONSIDER: overwrite old styles added in previous calls. Now we just clear styles when control text cleared.
		} else {
			if (i == n) _styles.Add(style);
			i += STYLE_FIRST_EX;
		}
		return (byte)i;
	}
	
	/// <summary>
	/// Called on SCN_HOTSPOTRELEASECLICK.
	/// </summary>
	internal void OnLinkClick_(int pos, bool ctrl) {
		if (keys.gui.isAlt) return;
		if (!GetLinkFromPos(pos, out var tag, out var attr)) return;
		//process it async, because bad things happen if now we remove focus or change control text etc
		_c.Dispatcher.InvokeAsync(() => OnLinkClick(tag, attr));
	}
	
	public bool GetLinkFromPos(int pos, out string tag, out string attr) {
		tag = attr = null;
		if (pos >= 0 && _c.AaRangeDataGet(false, pos, out string s, out int from, out int to)) {
			if (s.Length == 0) { //<fold>
				_c.Call(SCI_TOGGLEFOLD, _c.Call(SCI_LINEFROMPOSITION, pos));
			} else if (s.RxMatch(@"(?s)^(\+?\w+)(?| '([^']*)'| ""([^""]*)""| ([^>]*))?$", out var m)) {
				tag = m[1].Value;
				attr = m[2].Value ?? _c.aaaRangeText(false, from, to);
				return true;
			}
		}
		return false;
	}
	
	//note: attr can be ""
	public void OnLinkClick(string tag, string attr) {
		//print.it($"'{tag}'  '{attr}'");
		
		if (_userLinkTags.TryGetValue(tag, out var d) || s_userLinkTags.TryGetValue(tag, out d)) {
			d.Invoke(attr);
			return;
		}
		
		var a = attr.Split('|');
		bool one = a.Length == 1;
		string s1 = a[0], s2 = one ? null : a[1];
		
		switch (tag) {
		case "link":
			run.itSafe(s1, s2);
			break;
		case "help":
			HelpUtil.AuHelp(attr);
			break;
		case "explore":
			run.selectInExplorer(attr);
			break;
		default:
			//case "open": case "script": case "google": //the control recognizes but cannot implement these. The lib user can implement.
			//others are unregistered tags. Only if start with '+' (others are displayed as text).
			if (opt.warnings.Verbose) dialog.showWarning("Debug", "Tag '" + tag + "' is not implemented.\nUse SciTags.AddCommonLinkTag or SciTags.AddLinkTag.");
			break;
		}
	}
	
	public UserDefinedStyle DefaultLinkStyle { get; set; }
	
	readonly Dictionary<string, Action<string>> _userLinkTags = new();
	static readonly ConcurrentDictionary<string, Action<string>> s_userLinkTags = new();
	
	/// <summary>
	/// Adds (registers) a user-defined link tag for this control.
	/// </summary>
	/// <param name="name">
	/// Tag name, like "+myTag".
	/// Must start with '+'. Other characters must be 'a'-'z', 'A'-'Z'. Case-sensitive.
	/// Or can be one of predefined link tags, if you want to override or implement it (some are not implemented by the control).
	/// If already exists, replaces the delegate.
	/// </param>
	/// <param name="a">
	/// A delegate of a callback function (probably you'll use a lambda) that is called on link click.
	/// It's string parameter contains tag's attribute (if "&lt;name "attribute"&gt;TEXT&lt;&gt;) or link text (if "&lt;name&gt;TEXT&lt;&gt;).
	/// The function is called in control's thread. The mouse button is already released. It is safe to do anything with the control, eg replace text.
	/// </param>
	/// <param name="style">Style for this link tag. If null, uses <see cref="DefaultLinkStyle"/>.</param>
	/// <remarks>
	/// Call this function when control handle is already created. Until that <see cref="KScintilla.AaTags"/> returns null.
	/// </remarks>
	/// <seealso cref="AddCommonLinkTag"/>
	public void AddLinkTag(string name, Action<string> a, UserDefinedStyle style = null) {
		_userLinkTags[name] = a;
		if (style != null) _AddUserStyle(name, style);
	}
	
	public bool HasLinkTag(string name) => _userLinkTags.ContainsKey(name);
	
	/// <summary>
	/// Adds (registers) a user-defined link tag for all controls.
	/// </summary>
	/// <inheritdoc cref="AddLinkTag" path="/param"/>
	/// <seealso cref="AddLinkTag"/>
	public static void AddCommonLinkTag(string name, Action<string> a) {
		s_userLinkTags[name] = a;
	}
	
	public static bool HasCommonLinkTag(string name) => s_userLinkTags.ContainsKey(name);
	
	/// <summary>
	/// Adds (registers) a user-defined style tag for this control.
	/// </summary>
	/// <param name="name">
	/// Tag name, like ".my".
	/// Must start with '.'. Other characters must be 'a'-'z', 'A'-'Z'. Case-sensitive.
	/// </param>
	/// <param name="style"></param>
	/// <exception cref="ArgumentException">name does not start with '.'.</exception>
	/// <exception cref="InvalidOperationException">Trying to add more than 100 styles.</exception>
	/// <remarks>
	/// Call this function when control handle is already created. Until that <see cref="KScintilla.AaTags"/> returns null.
	/// 
	/// Does nothing if the style is already added.
	/// </remarks>
	public void AddStyleTag(string name, UserDefinedStyle style) {
		if (!name.Starts('.')) throw new ArgumentException();
		_AddUserStyle(name, style);
	}
	
	public void _AddUserStyle(string name, UserDefinedStyle style) {
		_userStyles ??= new();
		if (_userStyles.Count >= 100) throw new InvalidOperationException();
		var u8 = name.ToUTF8();
		if (!_FindUserStyle(u8, out _)) _userStyles.Add((u8, new(style)));
	}
	List<(byte[] name, TagStyle style)> _userStyles;
	
	[MethodImpl(MethodImplOptions.AggressiveOptimization)]
	bool _FindUserStyle(RByte tag, out TagStyle ts) {
		if (_userStyles is { } a) {
			foreach (ref var v in a.AsSpan()) {
				if (v.name.SequenceEqual(tag)) { ts = v.style; return true; }
			}
		}
		ts = default;
		return false;
	}
	
	public Func<string, byte[]> CodeStylesProvider;
	
	//FUTURE: add control-tags, like <clear> (clear output), <scroll> (ensure line visible), <mark x> (add some marker etc).
	//FUTURE: let our links be accessible objects.
}


================================================
FILE: Au.Controls/KScintilla/SciTextBuilder.cs
================================================
namespace Au.Controls;

using static Sci;

public class SciTextBuilder {
	readonly StringBuilder _b = new();
	readonly List<(int marker, int pos)> _markers = new();
	readonly List<(int indic, int start, int end, int value)> _indicators = new();
	readonly List<(int indic, int start, int end, object data)> _links = new();
	readonly List<(int style, int start, int end)> _styles = new();
	readonly List<SciFoldPoint> _folding = new();
	Stack<(int indic, int start, int value)> _stackIndicator = new();
	Stack<(int indic, int start, object data)> _stackLink = new();
	Stack<(int style, int start)> _stackStyle = new();

	public void Clear() {
		_b.Clear();
		_markers.Clear();
		_indicators.Clear();
		_links.Clear();
		_styles.Clear();
		_folding.Clear();
		_stackIndicator.Clear();
		_stackLink.Clear();
		_stackStyle.Clear();
	}

	public unsafe void Apply(KScintilla sci) {
		var s = _b.ToString();
		sci.aaaSetText(s, ignoreTags: true);
		if (_styles.Count > 0) {
			//code like in GetScintillaStylingBytes
			var styles8 = new byte[Encoding.UTF8.GetByteCount(s)];
			var map8 = styles8.Length == s.Length ? null : Convert2.Utf8EncodeAndGetOffsets_(s).offsets;
			foreach (var v in _styles) {
				int i = v.start, end = v.end;
				if (map8 != null) { i = map8[i]; end = map8[end]; }
				while (i < end) styles8[i++] = (byte)v.style;
			}
			sci.Call(SCI_STARTSTYLING);
			fixed (byte* p = styles8) sci.Call(SCI_SETSTYLINGEX, styles8.Length, p);
		}
		foreach (var v in _markers) {
			sci.aaaMarkerAdd(v.marker, true, v.pos);
		}
		foreach (var v in _indicators.AsSpan()) {
			sci.aaaIndicatorAdd(v.indic, true, v.start..v.end, v.value);
		}
		foreach (var v in _links.AsSpan()) {
			var (start, end) = sci.aaaNormalizeRange(true, v.start..v.end);
			if (v.indic < 0) {
				sci.aaaIndicatorAdd(-v.indic, false, start..end);
				sci.aaaIndicatorAdd(-v.indic + 1, false, start..end);
			} else {
				sci.aaaIndicatorAdd(v.indic, false, start..end);
			}
			sci.AaRangeDataAdd(false, start..end, v.data);
		}
		if (_folding.Count > 0) sci.aaaFoldingApply(_folding);
	}

	/// <summary>
	/// Gets current text length.
	/// </summary>
	public int Length => _b.Length;

	/// <summary>
	/// Adds text.
	/// </summary>
	public SciTextBuilder Text(RStr text) {
		_b.Append(text);
		return this;
	}

	/// <summary>
	/// Adds <c>"\r\n"</c>.
	/// </summary>
	public SciTextBuilder NL() {
		_b.AppendLine();
		return this;
	}

	/// <summary>
	/// Adds marker in current or previous line.
	/// </summary>
	/// <param name="prevLine">Add at the line of position <c>Length - 2</c>.</param>
	public SciTextBuilder Marker(int marker, bool prevLine = false) {
		_markers.Add((marker, Length - (prevLine ? 2 : 0)));
		return this;
	}

	/// <summary>
	/// Adds indicator in a text range.
	/// </summary>
	/// <param name="indic">Indicator index, 0-31.</param>
	/// <exception cref="ArgumentOutOfRangeException"><i>range</i> is not within current text.</exception>
	public SciTextBuilder Indic(int indic, int start, int end, int value = 1) {
		_indicators.Add((indic, start, end, value));
		return this;
	}

	/// <summary>
	/// Adds text with indicator.
	/// </summary>
	/// <param name="indic">Indicator index, 0-31.</param>
	public SciTextBuilder Indic(int indic, RStr text, int value = 1) {
		int start = Length;
		_b.Append(text);
		return Indic(indic, start, Length, value);
	}

	/// <summary>
	/// Starts indicator range from current text length. Later use <see cref="Indic_"/> to end it.
	/// </summary>
	/// <param name="indic">Indicator index, 0-31.</param>
	public SciTextBuilder Indic(int indic, int value = 1) {
		_stackIndicator.Push((indic, Length, value));
		return this;
	}

	/// <summary>
	/// Ends indicator range started by <see cref="Indic(int, int)"/>.
	/// </summary>
	public SciTextBuilder Indic_() {
		var v = _stackIndicator.Pop();
		return Indic(v.indic, v.start, Length, v.value);
	}

	/// <summary>
	/// Adds link in a text range.
	/// </summary>
	/// <param name="indic">Indicator index. If negative, will be set 2 indicators: -value and -value+1.</param>
	/// <exception cref="ArgumentOutOfRangeException"><i>range</i> is not within current text.</exception>
	public SciTextBuilder Link(object data, int start, int end, int indic) {
		_links.Add((indic, start, end, data));
		return this;
	}

	/// <summary>
	/// Adds link in a text range.
	/// </summary>
	public SciTextBuilder Link(object data, RStr text, int indic) {
		int start = Length;
		_b.Append(text);
		return Link(data, start, Length, indic);
	}

	/// <summary>
	/// Starts link range from current text length. Later use <see cref="Link_"/> to end it.
	/// </summary>
	public SciTextBuilder Link(object data, int indic) {
		_stackLink.Push((indic, Length, data));
		return this;
	}

	/// <summary>
	/// Ends link range started by <see cref="Link(object, int)"/>.
	/// </summary>
	public SciTextBuilder Link_() {
		var v = _stackLink.Pop();
		return Link(v.data, v.start, Length, v.indic);
	}

	/// <summary>
	/// Adds style in a text range.
	/// </summary>
	/// <exception cref="ArgumentOutOfRangeException"><i>range</i> is not within current text.</exception>
	public SciTextBuilder Style(int style, int start, int end) {
		_styles.Add((style, start, end));
		return this;
	}

	/// <summary>
	/// Adds text with style.
	/// </summary>
	public SciTextBuilder Style(int style, RStr text) {
		int start = Length;
		_b.Append(text);
		return Style(style, start, Length);
	}

	/// <summary>
	/// Starts style range from current text length. Later use <see cref="Style_"/> to end it.
	/// </summary>
	public SciTextBuilder Style(int style) {
		_stackStyle.Push((style, Length));
		return this;
	}

	/// <summary>
	/// Ends style range started by <see cref="Style(int)"/>.
	/// </summary>
	public SciTextBuilder Style_() {
		var v = _stackStyle.Pop();
		return Style(v.style, v.start, Length);
	}

	/// <summary>
	/// Adds a folding start or end point.
	/// </summary>
	public SciTextBuilder Fold(SciFoldPoint fp) {
		_folding.Add(fp);
		return this;
	}

	public int BoldStyle { get; set; }
	public SciTextBuilder B(int start, int end) => Style(BoldStyle, start, end);
	public SciTextBuilder B(RStr text) => Style(BoldStyle, text);
	public SciTextBuilder B() => Style(BoldStyle);
	public SciTextBuilder B_() => Style_();

	public int GrayStyle { get; set; }
	public SciTextBuilder Gray(int start, int end) => Style(GrayStyle, start, end);
	public SciTextBuilder Gray(RStr text) => Style(GrayStyle, text);
	public SciTextBuilder Gray() => Style(GrayStyle);
	public SciTextBuilder Gray_() => Style_();

	public int GreenStyle { get; set; }
	public SciTextBuilder Green(int start, int end) => Style(GreenStyle, start, end);
	public SciTextBuilder Green(RStr text) => Style(GreenStyle, text);
	public SciTextBuilder Green() => Style(GreenStyle);
	public SciTextBuilder Green_() => Style_();

	public int LinkIndic { get; set; }
	public SciTextBuilder Link(object data, int start, int end) => Link(data, start, end, LinkIndic);
	public SciTextBuilder Link(object data, RStr text) => Link(data, text, LinkIndic);
	public SciTextBuilder Link(object data) => Link(data, LinkIndic);

	public int Link2Indic { get; set; }
	public SciTextBuilder Link2(object data, int start, int end) => Link(data, start, end, Link2Indic);
	public SciTextBuilder Link2(object data, RStr text) => Link(data, text, Link2Indic);
	public SciTextBuilder Link2(object data) => Link(data, Link2Indic);

	/// <summary>
	/// Callers can use this as they want. Not used by this class.
	/// </summary>
	public (int i, object o) user;
}


================================================
FILE: Au.Controls/KScintilla/other/KSciInfoBox.cs
================================================
using System.Windows;
using System.Windows.Controls;

namespace Au.Controls;

/// <summary>
/// Scintilla-based control to show formatted information text.
/// To set text use the <see cref="aaaText"/> property. For formatting and links use tags: <see cref="SciTags"/>.
/// </summary>
public class KSciInfoBox : KScintilla {
	public KSciInfoBox() {
		AaInitReadOnlyAlways = true;
		AaInitTagsStyle = AaTagsStyle.AutoAlways;
		AaInitImages = true;
		AaInitUseDefaultContextMenu = true;
		AaInitWrapVisuals = false;
		AaWrapLines = true;
		//TabStop = false;
		Name = "info";
	}

	protected override void AaOnHandleCreated() {
		base.AaOnHandleCreated();

		aaaStyleBackColor(Sci.STYLE_DEFAULT, 0xf8fff0);
		if (AaInitUseSystemFont) aaaStyleFont(Sci.STYLE_DEFAULT); //Segoe UI 9 is narrower but taller than the default Verdana 8. Also tested Calibri 9, but Verdana looks better.
		aaaStyleClearAll();

		aaaMarginSetWidth(1, 0);
		aaaMarginSetWidth(-1, AaInitBlankMargins.left);
		aaaMarginSetWidth(-2, AaInitBlankMargins.right);
	}

	/// <summary>
	/// Use font Segoe UI 9 instead of the default font Verdana 8.
	/// </summary>
	public bool AaInitUseSystemFont { get; set; }

	/// <summary>
	/// The width of the blank margin on both sides of the text. Logical pixels.
	/// </summary>
	public (int left, int right) AaInitBlankMargins { get; set; } = (1, 1);

	//protected override bool IsInputKey(Keys keyData) {
	//	switch (keyData & Keys.KeyCode) { case Keys.Tab: case Keys.Escape: case Keys.Enter: return false; }
	//	return base.IsInputKey(keyData);
	//}

	/// <summary>
	/// Sets element's tooltip text to show in this control instead of standard tooltip popup.
	/// Uses <b>ToolTip</b> property; don't overwrite it.
	/// </summary>
	public void AaAddElem(FrameworkElement c, string text) {
		c.ToolTip = text;
		c.ToolTipOpening += (o, e) => {
			e.Handled = true;
			if (_suspendElems != 0) {
				if (Environment.TickCount64 < _suspendElems) return;
				_suspendElems = 0;
			}
			this.aaaText = (o as FrameworkElement).ToolTip as string;
		};
		if (c is TextBox or ComboBox) c.GotKeyboardFocus += (o, _) => { this.aaaText = (o as FrameworkElement).ToolTip as string; };
	}

	/// <summary>
	/// Temporarily suspends showing tooltips of elements in this control. See <see cref="AaAddElem"/>.
	/// </summary>
	/// <param name="timeMS">Suspend for this time interval, ms. If 0, resumes.</param>
	public void AaSuspendElems(long timeMS = 3000) {
		_suspendElems = Environment.TickCount64 + timeMS;
	}
	long _suspendElems;

	///
	public bool AaElemsSuspended => _suspendElems != 0 && Environment.TickCount64 < _suspendElems;
	
	/// <inheritdoc cref="KScintilla.aaaText"/>
	public new string aaaText {
		get => base.aaaText;
		set {
			if (value == _text) return; //prevent scrolling to the top
			base.aaaText = _text = value;
		}
	}
	string _text;
}


================================================
FILE: Au.Controls/KTreeView/KTreeView.cs
================================================
using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;

namespace Au.Controls;

public unsafe partial class KTreeView {
	_VisibleItem[] _avi;
	Dictionary<ITreeViewItem, int> _dvi; //for IndexOf
	int _width, _height, _itemHeight, _itemLineHeight, _imageSize, _imageMarginX, _marginLeft, _marginRight, _itemsWidth, _dpi;
	int _focusedIndex, _hotIndex;
	(int indexPlus1, bool scrollTop) _ensureVisible;
	NativeScrollbar_ _vscroll, _hscroll;
	
	struct _VisibleItem {
		public ITreeViewItem item;
		public int measured;
		public ushort level;
		public TVParts noParts;
		public bool isSelected;
		
		public bool Select(bool on) {
			if (on && !item.IsSelectable) return false;
			isSelected = on;
			return true;
		}
	}
	
	///
	public KTreeView() {
		//UseLayoutRounding = true;
		Focusable = true;
		FocusVisualStyle = null;
		_focusedIndex = _hotIndex = -1;
		_ScrollInit();
	}
	
	#region size, dpi, set visible items, root/index/count properties
	
	void _SetDpiAndItemSize(int dpi) {
		_dpi = dpi;
		_imageSize = _DpiScale(_logicalImageSize);
		_imageMarginX = _DpiScale(4);
		_marginLeft = _DpiScale(ItemMarginLeft);
		_marginRight = _DpiScale(ItemMarginRight);
		
		using var tr = new GdiTextRenderer(dpi);
		_itemHeight = _itemLineHeight = Math.Max(_imageSize, tr.MeasureText("A").height) + _DpiScale(2);
		if (CustomItemHeightAddPercent > 0) _itemHeight += Math2.PercentToValue(_itemHeight, CustomItemHeightAddPercent, true);
	}
	
	///
	protected override void OnDpiChanged(DpiScale oldDpi, DpiScale newDpi) {
		if (_hasHwnd) {
			_SetDpiAndItemSize(newDpi.PixelsPerInchY.ToInt()); //don't use Dpi.OfWindow(this), it's invalid when reparenting
			_MeasureClear(false);
		}
		base.OnDpiChanged(oldDpi, newDpi);
	}
	
	///
	public int Dpi => _dpi;
	
	/// <summary>
	/// Logical image size.
	/// Can be changed before or after creating handle.
	/// </summary>
	public int ImageSize {
		get => _logicalImageSize;
		set {
			if (value == _logicalImageSize) return;
			_logicalImageSize = value;
			if (_hasHwnd) {
				_SetDpiAndItemSize(_dpi);
				_MeasureClear(true);
			}
		}
	}
	int _logicalImageSize = 16;
	
	void _SetVisibleItems(bool init) {
		bool wasEmpty = _avi.NE_();
		_hotIndex = -1;
		_ensureVisible = default;
		
		int n = _itemsSource == null ? 0 : _CountVisible(_itemsSource);
		static int _CountVisible(IEnumerable<ITreeViewItem> a) {
			int r = 0;
			foreach (var v in a) {
				r++;
				if (v.IsExpanded) r += _CountVisible(v.Items);
			}
			return r;
		} //TODO3: now calls v.Items 2 times (_CountVisible and _AddVisible). It can be expensive.
		
		if (n == 0) {
			_avi = [];
			_dvi = null;
			_focusedIndex = -1;
			_itemsWidth = 0;
			if (wasEmpty) return;
		} else {
			List<ITreeViewItem> selected = null; ITreeViewItem focused = null;
			if (!(init || wasEmpty)) {
				selected = SelectedItems;
				focused = FocusedItem;
			}
			_focusedIndex = -1;
			_itemsWidth = 0;
			
			_avi = new _VisibleItem[n];
			_dvi = new Dictionary<ITreeViewItem, int>(n);
			_AddVisible(_itemsSource, 0, 0);
			int _AddVisible(IEnumerable<ITreeViewItem> a, int i, int level) {
				foreach (var v in a) {
					_avi[i] = new _VisibleItem { item = v, level = (ushort)level };
					_dvi.Add(v, i);
					i++;
					if (v.IsExpanded) i = _AddVisible(v.Items, i, level + 1);
				}
				return i;
			}
			
			if (selected != null) {
				foreach (var v in selected) {
					int i = IndexOf(v); if (i < 0) continue;
					_avi[i].Select(true);
					if (v == focused) _focusedIndex = i;
				}
			}
		}
		
		if (_hasHwnd) {
			if (init && _vscroll.Pos > 0) _vscroll.Pos = 0;
			
			_Measure();
			_Invalidate();
		}
	}
	
	/// <summary>
	/// Sets (adds, replaces or removes) all items.
	/// </summary>
	/// <param name="items">Items at tree root. Can be null.</param>
	/// <param name="modified">true when adding/removing one or more items in same tree/list. Preserves selection, scroll position, etc.</param>
	public void SetItems(IEnumerable<ITreeViewItem> items, bool modified = false) {
		_itemsSource = items;
		_SetVisibleItems(!modified);
	}
	IEnumerable<ITreeViewItem> _itemsSource;
	
	/// <summary>
	/// Gets the number of visible items.
	/// </summary>
	public int CountVisible => _avi.Lenn_();
	
	/// <summary>
	/// Gets item index in visible items.
	/// Returns -1 if not found.
	/// </summary>
	/// <param name="item">Can be null.</param>
	public int IndexOf(ITreeViewItem item) {
		if (item != null && _dvi != null && _dvi.TryGetValue(item, out int i)) return i;
		return -1;
	}
	
	/// <summary>
	/// Gets item index in visible items.
	/// Returns -1 if not found.
	/// </summary>
	public int IndexOf(Func<ITreeViewItem, bool> func) {
		if (!_avi.NE_()) {
			for (int i = 0; i < _avi.Length; i++) {
				if (func(_avi[i].item)) return i;
			}
		}
		return -1;
	}
	
	/// <summary>
	/// Gets visible item at index.
	/// </summary>
	/// <exception cref="IndexOutOfRangeException"></exception>
	/// <exception cref="NullReferenceException">Items not added.</exception>
	public ITreeViewItem this[int index] => _avi[index].item;
	
	#endregion
	
	#region scroll, top index, expand folder, ensure visible
	
	void _ScrollInit() {
		_vscroll = new(true, i => i * _itemHeight, i => (i + 1) * _itemHeight);
		_hscroll = new(false, i => i, i => i + 1);
		
		_vscroll.PosChanged += (sb, part) => {
			_hotIndex = -1;
			_Measure(true);
			_Invalidate();
			if (part <= -2) _OnMouseMoveOrScroll(true); //wheel, not scrollbar or keyboard
		};
		
		_hscroll.PosChanged += (sb, part) => {
			_Invalidate();
		};
	}
	
	///
	protected override void OnMouseWheel(MouseWheelEventArgs e) {
		e.Handled = true;
		if (!_avi.NE_() && _vscroll.Visible) _vscroll.WndProc(_w, Api.WM_MOUSEWHEEL, Math2.MakeLparam(0, e.Delta), 0);
		base.OnMouseWheel(e);
	}
	
	/// <summary>
	/// Gets or sets index of the first item in the scroll view; it is the value of the vertical scrollbar.
	/// The <c>set</c> function scrolls if need. Clamps if invalid index.
	/// </summary>
	public int TopIndex {
		get => _vscroll.Pos;
		set { _vscroll.Pos = value; }
	}
	
	/// <summary>
	/// Expands or collapses folder.
	/// </summary>
	/// <param name="index"></param>
	/// <param name="expand">If null, toggles.</param>
	/// <exception cref="InvalidOperationException">Not folder. Or control not created.</exception>
	/// <exception cref="IndexOutOfRangeException"></exception>
	public void Expand(int index, bool? expand) {
		if (!_hasHwnd) throw new InvalidOperationException();
		if (!_IndexToItem(index, out var item)) throw new IndexOutOfRangeException();
		if (!item.IsFolder) throw new InvalidOperationException();
		bool wasExp = item.IsExpanded;
		bool exp = expand == null ? !wasExp : expand.Value;
		if (exp == wasExp) return;
		if (!exp && _focusedIndex > index && _IsInside(index, _focusedIndex)) _avi[_focusedIndex = index].Select(true); //select/focus item if a descendant is focused
		item.SetIsExpanded(exp);
		_SetVisibleItems(init: false);
	}
	
	/// <summary>
	/// Expands or collapses folder.
	/// </summary>
	/// <param name="item"></param>
	/// <param name="expand">If null, toggles.</param>
	/// <exception cref="InvalidOperationException">Not folder. Or control not created.</exception>
	/// <exception cref="ArgumentException"><i>item</i> is not a visible item in this control. No exception if <i>expand</i> == false.</exception>
	public void Expand(ITreeViewItem item, bool? expand) {
		if (!_IndexOfOrThrowIfImportant(expand != false, item, out int i)) return;
		Expand(i, expand);
	}
	
	//internal bool test;
	
	/// <summary>
	/// Scrolls if need to make item actually visible.
	/// </summary>
	/// <exception cref="IndexOutOfRangeException"></exception>
	public void EnsureVisible(int index, bool scrollTop = false) {
		if (!_IsValid(index)) throw new IndexOutOfRangeException();
		if (!_hasHwnd || !IsVisible) { _ensureVisible = (index + 1, scrollTop); return; }
		bool retry = false;
		g1:
		_ensureVisible = default;
		var r = GetRectPhysical(index);
		if (scrollTop) {
			if (r.top != 0) _vscroll.Pos = index;
		} else if (r.top < 0 || r.bottom > _height) {
			int max = _vscroll.Max;
			_vscroll.Pos = (r.top < 0 || _height < _itemHeight) ? index : index - _height / _itemHeight + 1;
			if (!retry) if (retry = _vscroll.Max > max) goto g1; //added horz scrollbar and maybe it covers the item
		}
	}
	
	/// <summary>
	/// Expands descendant folders and scrolls if need to make item actually visible.
	/// </summary>
	/// <returns>Item index.</returns>
	public int EnsureVisible(ITreeViewItem item, bool scrollTop = false) {
		int i = IndexOf(item);
		if (i < 0) { //expand ancestor folders
			if (!_Find(_itemsSource, item)) throw new ArgumentException();
			_SetVisibleItems(init: false);
			i = IndexOf(item);
			static bool _Find(IEnumerable<ITreeViewItem> a, ITreeViewItem item) {
				if (a != null)
					foreach (var v in a) {
						if ((object)v == item) return true;
						if (v.IsFolder && _Find(v.Items, item)) {
							v.SetIsExpanded(true);
							return true;
						}
					}
				return false;
			}
		}
		EnsureVisible(i, scrollTop);
		return i;
	}
	
	#endregion
	
	#region mouse/keyboard input and related events
	
	//Returns false if not on item.
	void _OnMouseDown(MouseButton button, nint wParam, nint lParam, bool @double = false) {
		if (button != MouseButton.Middle && Focusable && !_w.Window.HasExStyle(WSE.NOACTIVATE)) Focus();
		var xy = Math2.NintToPOINT(lParam);
		if (!HitTest(xy, out var h) || !Api.GetCapture().Is0) return;
		
		if (button == MouseButton.Left && h.part == TVParts.Image && h.item.IsFolder) {
			Expand(h.index, null);
		} else {
			var mk = (0 != (wParam & Api.MK_CONTROL) ? ModifierKeys.Control : 0) | (0 != (wParam & Api.MK_SHIFT) ? ModifierKeys.Shift : 0); //never mind Alt, it's never used and may activate menubar
			bool multiSelect = MultiSelect && button == MouseButton.Left && !@double && (mk is ModifierKeys.Control or ModifierKeys.Shift);
			bool checkbox = h.part == TVParts.Checkbox && button == MouseButton.Left && !multiSelect;
			bool unselectOnUp = false;
			if (button == MouseButton.Left && !multiSelect && !checkbox) {
				unselectOnUp = MultiSelect && IsSelected(h.index); //unselect other on up, else could not drag multiple
				Select(h.index, true, unselectOther: !unselectOnUp, focus: true);
			}
			bool clickEvent = false, activateEvent = false;
			if (checkbox) {
				clickEvent = true;
			} else if (!@double || button == MouseButton.Middle) {
				Api.SetCapture(_w);
				_mouse = (true, button, h, xy, mk, multiSelect, unselectOnUp);
			} else if (button == MouseButton.Left) {
				//print.it("double", h.item);
				if (!(FullRowExpand && !MultiSelect) && h.part != TVParts.Image && h.item.IsFolder) Expand(h.index, null);
				clickEvent = true;
				activateEvent = !SingleClickActivate;
			}
			if (clickEvent || activateEvent) _MouseEvents(clickEvent, activateEvent, false, button, h, xy, mk, @double);
		}
	}
	(bool active, MouseButton button, TVHitTest h, POINT xy, ModifierKeys mk, bool multiSelect, bool unselect) _mouse;
	
	void _MouseEvents(bool click, bool activate, bool drag, MouseButton button, in TVHitTest h, POINT xy, ModifierKeys mk, bool @double = false) {
		var v = new TVItemEventArgs(h.item, h.index, h.part, button, @double ? 2 : 1, xy, mk);
		if (click) ItemClick?.Invoke(v);
		if (activate && !h.item.IsDisabled) ItemActivated?.Invoke(v);
		if (drag) ItemDragStart?.Invoke(v);
	}
	
	void _MouseEnd() {
		if (_mouse.active) {
			_mouse.active = false;
			Api.ReleaseCapture();
		}
	}
	
	bool _OnMouseUp(MouseButton button) {
		if (_mouse.active && button == _mouse.button) {
			_MouseEnd();
			if (_mouse.multiSelect) { //extend selection on up. If on down, interferes with drag.
				int i = _mouse.h.index;
				if (_mouse.mk == ModifierKeys.Shift) _ShiftSelect(i); else Select(i, !IsSelected(i), unselectOther: false);
				_focusedIndex = i;
			} else {
				if (_mouse.unselect) Select(_mouse.h.index, true, unselectOther: true);
				if (FullRowExpand && !MultiSelect && button == MouseButton.Left && _mouse.mk == 0 && _mouse.h.item.IsFolder) {
					Expand(_mouse.h.index, null);
				}
				bool activateEvent = SingleClickActivate && _mouse.button == MouseButton.Left;
				_MouseEvents(true, activateEvent, false, _mouse.button, _mouse.h, _mouse.xy, _mouse.mk);
			}
			return true;
		}
		return false;
	}
	
	void _OnMouseMove(nint wParam) {
		if (_mouse.active) {
			if (0 != (wParam & (_mouse.button switch { MouseButton.Left => Api.MK_LBUTTON, MouseButton.Right => Api.MK_RBUTTON, _ => Api.MK_MBUTTON }))) {
				//print.it("move");
				if (Math2.Distance(_w.MouseClientXY, _mouse.xy) > _itemLineHeight / 4) {
					//print.it("drag");
					int i = _mouse.h.index;
					if (!IsSelected(i)) SelectSingle(i, andFocus: true);
					_MouseEnd();
					_MouseEvents(false, false, true, _mouse.button, _mouse.h, _mouse.xy, _mouse.mk);
				}
			} else {
				_MouseEnd();
			}
		}
		_OnMouseMoveOrScroll(false);
	}
	
	void _OnMouseMoveOrScroll(bool wheel) {
		int i = _ItemFromY(_w.MouseClientXY.y);
		if (i != _hotIndex) {
			if (HotTrack) {
				if (_hotIndex >= 0) _Invalidate(_hotIndex);
				if (i >= 0) _Invalidate(i);
			}
			
			if (_hotIndex < 0 != i < 0) Api.TrackMouseLeave(_w, i >= 0);
			_hotIndex = i;
			
			if (ShowLabelTip) (_labeltip ??= new(this)).HotChanged(i);
			
			(_tooltip ??= new(this)).HotChanged(i);
		}
	}
	
	void _OnMouseLeave() {
		if (_hotIndex >= 0) {
			if (HotTrack) _Invalidate(_hotIndex);
			_hotIndex = -1;
		}
		_labeltip?.Hide();
		_tooltip?.Hide();
	}
	
	/// <summary>
	/// Whether to higlight an item when mouse is over.
	/// </summary>
	public bool HotTrack { get; set; }
	
	/// <summary>
	/// Whether to show a tooltip with full item text when mouse is over an item with partially visible text. Default true.
	/// </summary>
	public bool ShowLabelTip { get; set; } = true;
	
	/// <summary>
	/// Whether to activate an item on single click instead of double click.
	/// </summary>
	/// <seealso cref="ItemActivated"/>
	public bool SingleClickActivate { get; set; }
	
	/// <summary>
	/// To expand/collapse folders can click not only icon.
	/// Ignored if <see cref="MultiSelect"/>.
	/// </summary>
	public bool FullRowExpand { get; set; }
	
	///
	protected override void OnKeyDown(KeyEventArgs e) {
		//print.it(e.Key, _focusedIndex);
		if (EditingLabel) {
			var k = e.Key;
			switch (k) {
			case Key.Enter: EndEditLabel(); e.Handled = true; break;
			case Key.Escape: EndEditLabel(true); e.Handled = true; break;
			}
		} else {
			base.OnKeyDown(e);
			if (!e.Handled) e.Handled = ProcessKey(e.Key);
		}
	}
	
	/// <summary>
	/// Processes keys such as arrow, page, Enter, Ctrl+A.
	/// Returns true if handled.
	/// </summary>
	/// <seealso cref="keys.more.KKeyToWpf"/>
	public bool ProcessKey(Key k) {
		bool handled = false;
		if (!_avi.NE_()) {
			var mod = Keyboard.Modifiers;
			bool isFocus = _IsValid(_focusedIndex);
			int selIndex = -1, selAdd = 0;
			switch (k) {
			case Key.Enter:
				handled = true;
				if (isFocus) {
					var v = _IndexToItem(_focusedIndex);
					if (!v.IsDisabled) ItemActivated?.Invoke(new(v, _focusedIndex, Mod: mod));
				}
				break;
			case Key.Home or Key.End or Key.Down or Key.Up or Key.PageDown or Key.PageUp:
				selIndex = _vscroll.KeyNavigate(_focusedIndex, keys.more.KKeyFromWpf(k));
				break;
			case Key.Left:
			case Key.Right:
				if (mod != 0) break;
				handled = true;
				if (isFocus) {
					var v = _avi[_focusedIndex];
					if (v.item.IsFolder) {
						if ((k == Key.Right && !v.item.IsExpanded) || (k == Key.Left && v.item.IsExpanded)) {
							Expand(_focusedIndex, k == Key.Right);
							break;
						}
						if (k == Key.Right) { selAdd = 1; break; } //folder -> child
					}
					if (k == Key.Left && v.level > 0) { //child -> folder
						for (int i = _focusedIndex; --i >= 0; selAdd--) if (_avi[i].level < v.level) break;
						selAdd--;
					}
				}
				break;
			case Key.A when mod == ModifierKeys.Control && MultiSelect:
				handled = true;
				Select(.., true);
				break;
			}
			
			if (selAdd != 0) selIndex = Math.Clamp((isFocus ? _focusedIndex : (selAdd > 0 ? -1 : _avi.Length)) + selAdd, 0, _avi.Length - 1);
			if (selIndex >= 0 && (mod == 0 || (mod == ModifierKeys.Shift && MultiSelect))) {
				handled = true;
				if (selIndex != _focusedIndex) {
					if (mod == 0) SelectSingle(selIndex, andFocus: false); else _ShiftSelect(selIndex);
					SetFocusedItem(selIndex);
				}
			}
		}
		return handled;
	}
	
	/// <summary>
	/// When an item double-clicked. Or clicked, if <see cref="SingleClickActivate"/>. Also on Enter key if focused.
	/// Not sent if disabled.
	/// </summary>
	public event Action<TVItemEventArgs> ItemActivated;
	
	/// <summary>
	/// When an item clicked or double-clicked with the left, right or middle mouse button.
	/// </summary>
	public event Action<TVItemEventArgs> ItemClick;
	
	/// <summary>
	/// When drag start detected.
	/// </summary>
	public event Action<TVItemEventArgs> ItemDragStart;
	
	/// <summary>
	/// Right-click non on an item.
	/// </summary>
	public event Action RightClickInEmptySpace;
	
	#endregion
	
	#region selection, focus, checkboxes
	
	/// <summary>
	/// Whether can select multiple items, for example with Ctrl or Shift key.
	/// </summary>
	public bool MultiSelect { get; set; } //never mind: if set false, unselect all except focused
	
	/// <summary>
	/// Selects or unselects item.
	/// </summary>
	/// <param name="index"></param>
	/// <param name="select">true to select, false to unselect.</param>
	/// <param name="unselectOther">Unselect other items. Used only if <see cref="MultiSelect"/> true, else always unselects other items.</param>
	/// <param name="focus">Make the item focused and ensure visible.</param>
	/// <param name="scrollTop">Scroll if need so that the item would be at the top of really visible range.</param>
	/// <exception cref="IndexOutOfRangeException"></exception>
	public void Select(int index, bool select = true, bool unselectOther = false, bool focus = false, bool scrollTop = false) {
		if (!_IsValid(index)) throw new IndexOutOfRangeException();
		
		if (focus) SetFocusedItem(index, scrollTop ? TVFocus.EnsureVisible | TVFocus.ScrollTop : TVFocus.EnsureVisible);
		else if (scrollTop) _vscroll.Pos = index;
		
		Select(index..(index + 1), select, unselectOther);
		if (select && unselectOther) SelectedSingle?.Invoke(this, index);
	}
	
	/// <summary>
	/// Selects or unselects item.
	/// </summary>
	/// <param name="item"></param>
	/// <param name="select">true to select, false to unselect.</param>
	/// <param name="unselectOther">Unselect other items. Used only if <see cref="MultiSelect"/> true, else always unselects other items.</param>
	/// <param name="focus">Make the item focused and ensure visible.</param>
	/// <param name="scrollTop">Scroll if need so that the item would be at the top of really visible range.</param>
	/// <exception cref="ArgumentException"><i>item</i> not found in this control. No exception if <i>select</i> false.</exception>
	public void Select(ITreeViewItem item, bool select = true, bool unselectOther = false, bool focus = false, bool scrollTop = false) {
		int i;
		if (select) {
			i = EnsureVisible(item, scrollTop);
		} else {
			i = IndexOf(item);
			if (i < 0) return; //ok if tries to unselect an already unselected item in a collapsed folder
		}
		Select(i, select, unselectOther, focus, scrollTop);
	}
	
	/// <summary>
	/// Selects or unselects range of items.
	/// </summary>
	/// <param name="range">Range of item indices. For example <c>..</c> means all.</param>
	/// <param name="select">true to select, false to unselect.</param>
	/// <param name="unselectOther">Unselect other items. Used only if <see cref="MultiSelect"/> true, else always unselects other items.</param>
	public void Select(Range range, bool select = true, bool unselectOther = false) {
		var (from, to) = range.GetStartEnd(_avi.Lenn_());
		if (select && !MultiSelect) {
			if (to - from > 1) throw new InvalidOperationException();
			unselectOther = true;
		}
		bool invalidate = false;
		if (select && unselectOther) {
			for (int k = 0; k < 2; k++) {
				int i, j; if (k == 0) { i = 0; j = from; } else { i = to; j = _avi.Length; }
				for (; i < j; i++) if (_avi[i].isSelected) { _avi[i].isSelected = false; invalidate = true; }
			}
		}
		for (; from < to; from++) if (select != IsSelected(from)) invalidate |= _avi[from].Select(select);
		if (invalidate) _Invalidate();
		
		SelectionChanged?.Invoke(this, EventArgs.Empty);
	}
	
	/// <summary>
	/// Unselects all.
	/// </summary>
	public void UnselectAll() => Select(.., select: false);
	
	public event EventHandler SelectionChanged;
	public event EventHandler<int> SelectedSingle;
	
	/// <summary>
	/// Selects item, unselects others, optionally makes the focused.
	/// </summary>
	/// <param name="andFocus">Make the item focused and ensure visible.</param>
	/// <param name="scrollTop">Scroll if need so that the item would be at the top of really visible range.</param>
	public void SelectSingle(int index, bool andFocus, bool scrollTop = false) => Select(index, true, true, andFocus, scrollTop);
	
	/// <summary>
	/// Selects item and unselects others. Makes visible and focused.
	/// </summary>
	/// <param name="scrollTop">Scroll if need so that the item would be at the top of really visible range.</param>
	/// <exception cref="ArgumentException"><i>item</i> not found in this control.</exception>
	public void SelectSingle(ITreeViewItem item, bool scrollTop = false) => Select(item, true, true, true, scrollTop);
	
	void _ShiftSelect(int last) {
		int from; if (last >= _focusedIndex) from = Math.Max(_focusedIndex, 0); else { from = last; last = _focusedIndex; }
		Select(from..++last, true, unselectOther: false);
	}
	
	/// <summary>
	/// Returns true if the item is selected.
	/// </summary>
	/// <seealso cref="MultiSelect"/>
	/// <exception cref="IndexOutOfRangeException"></exception>
	public bool IsSelected(int index) => _avi[index].isSelected;
	
	/// <summary>
	/// Returns true if the item is visible and selected.
	/// </summary>
	/// <seealso cref="MultiSelect"/>
	public bool IsSelected(ITreeViewItem item) {
		int i = IndexOf(item); //if not found, probably it is an unselected item in a collapsed folder
		return i >= 0 && _avi[i].isSelected;
	}
	
	/// <summary>
	/// Gets selected items. Returns empty list if none selected.
	/// </summary>
	/// <seealso cref="MultiSelect"/>
	public List<int> SelectedIndices {
		get {
			var a = new List<int>();
			for (int i = 0; i < _avi.Length; i++) if (_avi[i].isSelected) a.Add(i);
			return a;
		}
	}
	
	/// <summary>
	/// Gets selected items. Returns empty list if none selected.
	/// </summary>
	/// <seealso cref="MultiSelect"/>
	public List<ITreeViewItem> SelectedItems {
		get {
			var a = new List<ITreeViewItem>();
			for (int i = 0; i < _avi.Length; i++) if (_avi[i].isSelected) a.Add(_avi[i].item);
			return a;
		}
	}
	
	/// <summary>
	/// Returns index of first selected item, or -1 if no selection.
	/// </summary>
	public int SelectedIndex {
		get {
			for (int i = 0; i < _avi.Length; i++) if (_avi[i].isSelected) return i;
			return -1;
		}
	}
	
	/// <summary>
	/// Returns first selected item, or null if no selection.
	/// </summary>
	public ITreeViewItem SelectedItem {
		get {
			int i = SelectedIndex; return i >= 0 ? _avi[i].item : null;
		}
	}
	
	/// <summary>
	/// Gets index of item that has logical focus within the control. Can be -1.
	/// </summary>
	public int FocusedIndex => _focusedIndex;
	
	/// <summary>
	/// Gets item that has logical focus within the control. Can be null.
	/// </summary>
	public ITreeViewItem FocusedItem => _IndexToItem(_focusedIndex);
	
	/// <summary>
	/// Sets item that has logical focus within the control.
	/// </summary>
	/// <param name="index">Can be -1.</param>
	/// <param name="flags"></param>
	/// <exception cref="IndexOutOfRangeException"></exception>
	/// <remarks>
	/// Used with keyboard actions (Enter-activate, arrows, page down/up), range selection (Shift+click when <see cref="MultiSelect"/> true), optionally <see cref="Select"/>.
	/// </remarks>
	public void SetFocusedItem(int index, TVFocus flags = TVFocus.EnsureVisible) {
		if (!_IsValid(index) && index != -1) throw new IndexOutOfRangeException();
		_focusedIndex = index;
		if (flags.HasAny(TVFocus.EnsureVisible | TVFocus.ScrollTop)) if (index >= 0) EnsureVisible(index, flags.Has(TVFocus.ScrollTop));
	}
	
	/// <summary>
	/// Sets item that has logical focus within the control.
	/// </summary>
	/// <param name="item">Can be null.</param>
	/// <param name="flags"></param>
	/// <exception cref="ArgumentException">The item is not a visible item in this control.</exception>
	public void SetFocusedItem(ITreeViewItem item, TVFocus flags = TVFocus.EnsureVisible)
		=> SetFocusedItem(_IndexOfOrThrow(item, canBeNull: true), flags);
	
	///
	protected override void OnGotKeyboardFocus(KeyboardFocusChangedEventArgs e) {
		_Invalidate();
		base.OnGotKeyboardFocus(e);
	}
	
	///
	protected override void OnLostKeyboardFocus(KeyboardFocusChangedEventArgs e) {
		_MouseEnd();
		_Invalidate();
		base.OnLostKeyboardFocus(e);
	}
	
	/// <summary>
	/// Has checkboxes.
	/// </summary>
	/// <remarks>
	/// To get checkbox states the control calls <see cref="ITreeViewItem.CheckState"/>.
	/// The control does not automatically set checkbox states. You can do it in <see cref="ItemClick"/> event handler like in the example.
	/// </remarks>
	/// <example>
	/// Event handler.
	/// <code><![CDATA[
	/// _tv.ItemClick+=(_,e)=>{
	/// 	var v=e.Item as TvItem; //TvItem is your class that implements ITreeViewItem interface
	/// 	if(e.ClickedPart==KTreeView.TVParts.Checkbox && !v.IsDisabled) v.CheckState=v.CheckState==default ? KTreeView.TVCheck.Checked : default;
	/// };
	/// ]]></code>
	/// Property of your TvItem class that implements ITreeViewItem interface.
	/// <code><![CDATA[
	/// KTreeView.TVCheck CheckState {
	/// 	get => _checkState;
	/// 	set { if(value!=_checkState) { _checkState=value; _tv.Redraw(this); } }
	/// }
	/// KTreeView.TVCheck _checkState;
	/// ]]></code>
	/// </example>
	public bool HasCheckboxes {
		get => _hasCheckboxes;
		set {
			if (value != _hasCheckboxes) {
				_hasCheckboxes = value;
				_MeasureClear(true);
			}
		}
	}
	bool _hasCheckboxes;
	
	/// <summary>
	/// Gets checked items (<see cref="TVCheck.Checked"/>). Returns empty list if none checked.
	/// </summary>
	public List<int> CheckedIndices {
		get {
			var a = new List<int>();
			for (int i = 0; i < _avi.Length; i++) if (_avi[i].item.CheckState == TVCheck.Checked) a.Add(i);
			return a;
		}
	}
	
	/// <summary>
	/// Gets checked items (<see cref="TVCheck.Checked"/>). Returns empty list if none checked.
	/// </summary>
	public List<ITreeViewItem> CheckedItems {
		get {
			var a = new List<ITreeViewItem>();
			for (int i = 0; i < _avi.Length; i++) if (_avi[i].item.CheckState == TVCheck.Checked) a.Add(_avi[i].item);
			return a;
		}
	}
	
	//rejected. Then also need setter, but CheckState is read-only and I don't want to make it read-write.
	//	/// <summary>
	//	/// Gets checked items (<see cref="TVCheck.Checked"/>) as flags.
	//	/// Skips items that don't have state <b>Checked</b> or <b>Unchecked</b>.
	//	/// </summary>
	//	public ulong CheckedBits {
	//		get {
	//			ulong flags=0; ulong j=1;
	//			for (int i = 0; i < _avi.Length; i++) {
	//				switch (_avi[i].item.CheckState) {
	//				case TVCheck.Checked: flags|=j; break;
	//				case TVCheck.Unchecked: break;
	//				default: continue;
	//				}
	//				if(j<0x8000000000000000) j<<=1; else break;
	//			}
	//			return flags;
	//		}
	//	}
	
	#endregion
	
	#region edit label
	
	/// <summary>
	/// Starts focused item text editing.
	/// The type must implement <see cref="ITreeViewItem.SetNewText"/>.
	/// </summary>
	/// <exception cref="InvalidOperationException">Control not created.</exception>
	public void EditLabel(Action<bool> ended = null) { int i = _focusedIndex; if (i >= 0) EditLabel(i, ended); }
	
	/// <summary>
	/// Starts item text editing.
	/// The type must implement <see cref="ITreeViewItem.SetNewText"/>.
	/// </summary>
	/// <exception cref="ArgumentException"></exception>
	/// <exception cref="InvalidOperationException">Control not created.</exception>
	public void EditLabel(ITreeViewItem item, Action<bool> ended = null) => _EditLabel(item, _IndexOfOrThrow(item), ended);
	
	/// <summary>
	/// Starts item text editing.
	/// The type must implement <see cref="ITreeViewItem.SetNewText"/>.
	/// </summary>
	/// <exception cref="IndexOutOfRangeException"></exception>
	/// <exception cref="InvalidOperationException">Control not created.</exception>
	public void EditLabel(int index, Action<bool> ended = null) {
		if (!_IndexToItem(index, out var item)) throw new IndexOutOfRangeException();
		_EditLabel(item, index, ended);
	}
	
	void _EditLabel(ITreeViewItem item, int index, Action<bool> ended) {
		EndEditLabel();
		EnsureVisible(index);
		if (!IsFocused) Focus();
		
		var r = GetRectPhysical(index, TVParts.Text | TVParts.MarginRight | TVParts.Right);
		r.left -= _imageMarginX;
		r.Intersect(_w.ClientRect);
		if (r.Width < 8 || r.Height < 8) return;
		
		_leItem = item;
		_leEnded = ended;
		
		//add border. Cannot add WS_BORDER to _leEdit because it also adds padding and therefore must be taller than we need, else there is no top border.
		_leBorder = WndUtil.CreateWindow((w, msg, wp, lp) => {
			if (msg == Api.WM_COMMAND && Math2.HiWord(wp) == /*EN_KILLFOCUS*/ 0x0200) EndEditLabel();
			return Api.DefWindowProc(w, msg, wp, lp);
		}, true, "Static", null, WS.CHILD | WS.VISIBLE | WS.BORDER | (WS)6 /*SS_WHITERECT*/, 0, r.left, r.top, r.Width, r.Height, _w);
		
		_leEdit = WndUtil.CreateWindow("Edit", item.DisplayText, WS.CHILD | WS.VISIBLE | Api.ES_AUTOHSCROLL, 0, 0, 0, r.Width - 2, r.Height - 2, _leBorder);
		WndUtil.SetFont(_leEdit);
		EditLabelStartedEventArgs e = new(this, item);
		e.SelectText();
		
		Api.SetFocus(_leEdit);
		
		EditLabelStarted?.Invoke(e);
	}
	
	wnd _leEdit, _leBorder;
	ITreeViewItem _leItem;
	Action<bool> _leEnded;
	
	/// <summary>
	/// When item text editing started.
	/// </summary>
	public event Action<EditLabelStartedEventArgs> EditLabelStarted;
	
	public record class EditLabelStartedEventArgs(KTreeView tv, ITreeViewItem item) {
		public string Text {
			get => item.DisplayText;
			set { tv._leEdit.SetText(value); }
		}
		
		/// <summary>
		/// Selects text. To select all, use 0 -1.
		/// </summary>
		public void SelectText(int start = 0, int end = -1) {
			tv._leEdit.Send(/*EM_SETSEL*/ 0x00B1, start, end);
		}
	}
	
	public bool EditingLabel => !_leEdit.Is0;
	
	/// <summary>
	/// Ends item text editing.
	/// </summary>
	public void EndEditLabel(bool cancel = false) {
		if (!EditingLabel) return;
		int index = cancel ? -1 : IndexOf(_leItem);
		if (!cancel) cancel = index < 0 || !IsVisible;
		//print.it("EndEditLabel, cancel=", cancel);
		bool focus = Api.GetFocus() == _leEdit;
		var text = cancel ? null : _leEdit.ControlText;
		var item = _leItem; _leItem = null;
		var ended = _leEnded; _leEnded = null;
		_leEdit = default;
		Api.DestroyWindow(_leBorder); _leBorder = default;
		if (focus) Focus();
		if (!cancel && text != item.DisplayText) {
			int meas = _avi[index].measured;
			item.SetNewText(text);
			if (_avi[index].measured == meas) Redraw(index, remeasure: true); //SetNewText (app) should do it, but may forget
		}
		ended?.Invoke(!cancel);
	}
	
	#endregion
	
	#region drag & drop
	
	///
	protected override void OnDragLeave(DragEventArgs e) {
		base.OnDragLeave(e);
		_dd?.ClearInsertMark();
		_dd = null;
	}
	
	///
	protected override void OnDrop(DragEventArgs e) {
		base.OnDrop(e);
		_dd?.ClearInsertMark();
		_dd = null;
	}
	
	/// <summary>
	/// Can be called from "drag over" override or event handler to show/hide insertion mark, expand/collapse folder and scroll if need.
	/// </summary>
	/// <param name="canDrop">Can drop here. If false, hides insertion mark and returns.</param>
	/// <remarks>
	/// Draws black line between nearest items. If mouse is on a folder vertical center, draws rectangle.
	/// When mouse is on a folder, expands it if pressed key Right and collapses if Left.
	/// Scrolls when mouse is near top or bottom or pressed key Down, Up, PageDown, PageUp, Home or End.
	/// </remarks>
	/// <seealso cref="GetDropInfo"/>
	public void OnDragOver2(bool canDrop) {
		if (!canDrop || _avi.NE_()) { _dd?.ClearInsertMark(); return; }
		_dd ??= new _DragDrop(this);
		var p = _w.MouseClientXY;
		GetDropInfo(p, out var d);
		bool noMark = false;
		Key key;
		//expand/collapse folder
		if (Keyboard.IsKeyDown(key = Key.Right) || Keyboard.IsKeyDown(key = Key.Left)) {
			if (d.targetItem?.IsFolder ?? false) Expand(d.targetIndex, key == Key.Right);
			return;
		}
		//scroll. When not moving mouse, this is called every 64 ms.
		if (_vscroll.Visible) {
			int scroll = 0, dist = _imageSize * 3 / 2;
			if (Keyboard.IsKeyDown(key = Key.Down)) scroll = 3;
			else if (Keyboard.IsKeyDown(key = Key.Up)) scroll = -3;
			else if (Keyboard.IsKeyDown(key = Key.PageDown)) scroll = _height / _itemHeight;
			else if (Keyboard.IsKeyDown(key = Key.PageUp)) scroll = -_height / _itemHeight;
			else if (Keyboard.IsKeyDown(Key.Home)) noMark = _Scroll(0, true);
			else if (Keyboard.IsKeyDown(Key.End)) noMark = _Scroll(_vscroll.Max, true);
			else if (_height > dist * 3) {
				key = 0;
				if (p.y < dist) scroll--; else if (p.y > _height - dist) scroll++;
			}
			if (scroll == 0) {
				_dd.scrolling = false;
				_dd.scrollDelayTime = 0;
				_dd.scrollTime = 0;
			} else if (_dd.scrolling || key != 0) {
				long time = Environment.TickCount64;
				if (time - _dd.scrollTime > 110) {
					_dd.scrollTime = time;
					noMark = _Scroll(scroll, false);
				} else noMark = true;
			} else if (_dd.scrollDelayTime == 0 || p != _dd.scrollDelayPoint) {
				_dd.scrollDelayTime = Environment.TickCount64;
				_dd.scrollDelayPoint = p;
			} else if (Environment.TickCount64 - _dd.scrollDelayTime > 400) {
				_dd.scrolling = true;
			}
		}
		//insertion mark
		if (!noMark) _dd.SetInsertMark(d.targetIndex, d.insertAfter, d.intoFolder);
		
		bool _Scroll(int scroll, bool absolute) {
			if (!absolute) scroll += _vscroll.Pos;
			int i = Math.Clamp(scroll, 0, _vscroll.Max);
			if (i == _vscroll.Pos) return false;
			_dd.ClearInsertMark();
			_vscroll.Pos = i;
			return true;
		}
	}
	
	//fields for drag scrolling and insertion mark
	class _DragDrop {
		KTreeView _tv;
		public bool scrolling;
		public long scrollDelayTime, scrollTime;
		public POINT scrollDelayPoint;
		public int insertIndex;
		public bool insertAfter, insertFolder;
		
		public _DragDrop(KTreeView tv) {
			_tv = tv;
			insertIndex = -1;
		}
		
		public void SetInsertMark(int i, bool after, bool folder) {
			if (i == insertIndex && after == insertAfter && folder == insertFolder) return;
			int pi = insertIndex;
			insertIndex = i; insertAfter = after; insertFolder = folder;
			if (pi >= 0) _tv._Invalidate(pi);
			if (i >= 0) _tv._Invalidate(i);
		}
		
		public void ClearInsertMark() => SetInsertMark(-1, false, false);
	}
	_DragDrop _dd;
	
	/// <summary>
	/// Can be called from "drag over" and "drop" overrides or event handlers to get drop info.
	/// This overload uses mouse position (<see cref="wnd.MouseClientXY"/>).
	/// </summary>
	/// <param name="d"></param>
	/// <seealso cref="OnDragOver2"/>
	public void GetDropInfo(out TVDropInfo d) => GetDropInfo(_w.MouseClientXY, out d);
	
	/// <summary>
	/// Can be called from "drag over" and "drop" overrides or event handlers to get drop info.
	/// </summary>
	/// <param name="xy">A point relative to the top-left of the control without border. Physical pixels.</param>
	/// <param name="d"></param>
	/// <seealso cref="OnDragOver2"/>
	public void GetDropInfo(POINT xy, out TVDropInfo d) {
		d = default;
		d.xy = xy;
		if (_avi.NE_()) {
			d.targetIndex = -1;
			return;
		}
		if (HitTest(d.xy, out var h)) {
			d.targetIndex = h.index;
			double y = d.xy.y, top = _ItemTop(h.index), quarter = _itemHeight / 4d;
			bool after = y >= top + quarter * 2;
			if (h.item.IsFolder && y >= top + quarter) {
				if (y < top + quarter * 3) d.intoFolder = true;
				else if (h.index < _avi.Length - 1 && _avi[h.index + 1].level > _avi[h.index].level) d.targetIndex++; //between folder and its first child
				else d.insertAfter = after;
			} else d.insertAfter = after;
			
			d.targetItem = _avi[d.targetIndex].item;
		} else {
			d.targetIndex = -1;
		}
	}
	
	#endregion
}


================================================
FILE: Au.Controls/KTreeView/tv-acc.cs
================================================
//Implements MSAA IAccessible.

//Problem: UIA "object from point" returns CLIENT, not item, although has items in tree. MSAA works well.
//	For UIA to work correctly, need to implement UIA (AutomationPeer for control and items).
//		But then problem: if not implemented MSAA, MSAA "object from point" does not return item, although has items in tree.
//			If implemented both, tree contains duplicate subtrees; example - SysListView32 control.
//		Also, cannot implement it directly for HwndHost, because WPF then throws exception. But can implement for its parent.
//	I did not find a way to make both UIA and MSAA work correctly with WPF HwndHost.
//	Good: NVDA now works anyway.

//Strange: QM2 does not find items and client unless checked +invisible, although no invisible state. Never mind.

using NAVDIR = Au.Types.Api.NAVDIR;

namespace Au.Controls;

public partial class KTreeView {
	class _Accessible : HwndHostAccessibleBase_ {
		KTreeView _tv;

		internal _Accessible(KTreeView tv) : base(tv, tv.Hwnd) {
			_tv = tv;
		}

		ITreeViewItem _Item(int child) {
			if (child == -1) return null;
			if ((uint)child < _tv.CountVisible) return _tv._avi[child].item;
			throw new ArgumentException();
		}

		public override int ChildCount => _tv.CountVisible;

		public override string Name(int child) {
			var k = _Item(child);
			if (k == null) return _tv.Name;
			return k.DisplayText;
		}

		public override ERole Role(int child) {
			return child == -1 ? ERole.TREE : ERole.TREEITEM;
		}

		public override EState State(int child) {
			if (child == -1) return base.State(child);
			var k = _Item(child);
			EState r = 0;
			if (_tv.Focusable) {
				r |= EState.FOCUSABLE;
				if (child == _tv._focusedIndex && _tv.IsKeyboardFocused) r |= EState.FOCUSED;
			}
			if (k.IsSelectable) {
				r |= EState.SELECTABLE;
				if (_tv.MultiSelect) r |= EState.MULTISELECTABLE;
				if (_tv.IsSelected(child)) r |= EState.SELECTED;
			}
			if (k.IsFolder) r |= k.IsExpanded ? EState.EXPANDED : EState.COLLAPSED;
			var (from, to) = _tv._GetViewRange(); if (child < from || child >= to) r |= EState.INVISIBLE | EState.OFFSCREEN;
			if (k.IsDisabled) r |= EState.DISABLED;
			switch (k.CheckState) { case TVCheck.Checked: case TVCheck.RadioChecked: r |= EState.CHECKED; break; case TVCheck.Mixed: r |= EState.MIXED; break; }
			//if(child==_tv._hotIndex) r|=EState.HOTTRACKED;
			//if(!k.IsEditable) r|=EState.READONLY;
			return r;
		}

		public override int FocusedChild => _tv._focusedIndex;

		public override List<int> SelectedChildren => _tv.SelectedIndices;

		public override string DefaultAction(int child) {
			var k = _Item(child);
			if (k == null) return null;
			if (k.IsFolder) return k.IsExpanded ? "Collapse" : "Expand";
			return "Activate";
		}

		public override void SelectChild(ESelect flagsSelect, int child) {
			//if(flagsSelect.HasAny(ESelect.ADDSELECTION|ESelect.EXTENDSELECTION) && !_tv.MultiSelect) throw new InvalidOperationException();
			//int anchor=Math.Max(_tv.FocusedIndex, 0);
			switch (flagsSelect & (ESelect.TAKESELECTION | ESelect.ADDSELECTION | ESelect.EXTENDSELECTION | ESelect.REMOVESELECTION)) {
			case 0: break;
			case ESelect.TAKESELECTION:
				_tv.SelectSingle(child, andFocus: false);
				break;
			case ESelect.REMOVESELECTION:
				_tv.Select(child, false);
				break;
			case ESelect.ADDSELECTION when _tv.MultiSelect:
				_tv.Select(child, true);
				break;
			//case ESelect.EXTENDSELECTION: //rarely used
			//case ESelect.ADDSELECTION|ESelect.EXTENDSELECTION:
			//	break;
			//case ESelect.REMOVESELECTION|ESelect.EXTENDSELECTION:
			//	break;
			default: throw new ArgumentException();
			}
			if (flagsSelect.Has(ESelect.TAKEFOCUS)) {
				//_tv.Focus();
				_tv.SetFocusedItem(child);
			}
		}

		public override RECT ChildRect(int child) => _tv.GetRectPhysical(child);

		public override int? Navigate(NAVDIR navDir, int childStart) {
			if (childStart == -1) { //navDir can be only first or last
				int n = _tv.CountVisible; if (n == 0) return null;
				return navDir == NAVDIR.FIRSTCHILD ? 0 : n - 1;
			} else { //navDir cannot be first or last
				switch (navDir) {
				case NAVDIR.PREVIOUS:
				case NAVDIR.UP:
					if (childStart > 0) return childStart - 1;
					break;
				case NAVDIR.NEXT:
				case NAVDIR.DOWN:
					if (++childStart < _tv.CountVisible) return childStart;
					break;
				}
				return null;
			}
		}

		public override int HitTest(int x, int y) => _tv._ItemFromY(y);

		public override void DoDefaultAction(int child) {
			var k = _Item(child);
			if (k == null) return;
			if (k.IsFolder) _tv.Expand(child, null);
			else {
				_tv.SelectSingle(child, andFocus: true);
				_tv.ItemActivated?.Invoke(new(k, child));
			}
		}
	}
}

================================================
FILE: Au.Controls/KTreeView/tv-hh.cs
================================================
using System.Windows;
using System.Windows.Interop;
using System.Windows.Media;
using System.Windows.Input;

namespace Au.Controls;

public unsafe partial class KTreeView : HwndHost {
	wnd _w;
	bool _hasHwnd;
	
	public wnd Hwnd => _w;
	
	//const string c_winClassName = "KTreeView";
	//static KTreeView() {
	//	WndUtil.RegisterWindowClass(c_winClassName);
	//}
	
	//bool _test;
	
	protected override HandleRef BuildWindowCore(HandleRef hwndParent) {
		//_test = Name == "Files_list";
		
		var wParent = (wnd)hwndParent.Handle;
		_w = WndUtil.CreateWindow(_wndProc = _WndProc, false, "Static", Name, WS.CHILD | WS.CLIPCHILDREN, 0, 0, 0, 10, 10, wParent);
		_hasHwnd = true;
		_SetDpiAndItemSize(More.Dpi.OfWindow(_w));
		
		return new HandleRef(this, _w.Handle);
	}
	
	protected override void DestroyWindowCore(HandleRef hwnd) {
		//print.it("DestroyWindowCore", (wnd)hwnd.Handle);
		Api.DestroyWindow(_w);
	}
	
	WNDPROC _wndProc;
	nint _WndProc(wnd w, int msg, nint wParam, nint lParam) {
		//var pmo = new PrintMsgOptions(Api.WM_NCHITTEST, Api.WM_SETCURSOR, Api.WM_MOUSEMOVE, Api.WM_NCMOUSEMOVE, 0x10c1);
		//if (WndUtil.PrintMsg(out string s, _w, msg, wParam, lParam, pmo)) print.it("<><c green>" + s + "<>");
		//if (_test) if (WndUtil.PrintMsg(out string s, _w, msg, wParam, lParam)) print.it("<><c green>" + s + "<>");
		
		if (_vscroll.WndProc(w, msg, wParam, lParam) || _hscroll.WndProc(w, msg, wParam, lParam)) return default;
		
		switch (msg) {
		//case Api.WM_NCCREATE:
		//	_w = w;
		//	_hasHwnd = true;
		//	_SetDpiAndItemSize(More.Dpi.OfWindow(_w));
		//	break;
		case Api.WM_NCDESTROY:
			_w = default;
			_hasHwnd = false;
			_acc?.Dispose(); _acc = null;
			break;
		case Api.WM_PAINT:
			using (var bp = new BufferedPaint(w, true)) _Render(bp.DC, bp.UpdateRect);
			return default;
		case Api.WM_SHOWWINDOW when wParam == 1:
			int iev = _ensureVisible.indexPlus1 - 1;
			if (iev > 0) EnsureVisible(iev, _ensureVisible.scrollTop);
			break;
		case Api.WM_SIZE:
			_width = Math2.LoWord(lParam);
			_height = Math2.HiWord(lParam);
			_Measure();
			break;
		case Api.WM_SYSCOMMAND when (wParam & 0xFFF0) is Api.SC_VSCROLL or Api.SC_HSCROLL: //note: Windows bug: swapped SC_VSCROLL and SC_HSCROLL
			try {
				_inScrollbarScroll = true;
				return Api.DefWindowProc(w, msg, wParam, lParam);
			}
			finally {
				_ScrollEnded();
				_inScrollbarScroll = false;
			}
		case >= Api.WM_MOUSEFIRST and <= Api.WM_MOUSELAST:
			switch (msg) {
			case Api.WM_LBUTTONDOWN:
				_OnMouseDown(System.Windows.Input.MouseButton.Left, wParam, lParam);
				break;
			case Api.WM_RBUTTONDOWN:
				_OnMouseDown(System.Windows.Input.MouseButton.Right, wParam, lParam);
				break;
			case Api.WM_MBUTTONDOWN:
				_OnMouseDown(System.Windows.Input.MouseButton.Middle, wParam, lParam);
				break;
			case Api.WM_LBUTTONDBLCLK:
				_OnMouseDown(System.Windows.Input.MouseButton.Left, wParam, lParam, true);
				break;
			case Api.WM_MBUTTONDBLCLK:
				_OnMouseDown(System.Windows.Input.MouseButton.Middle, wParam, lParam, true);
				break;
			case Api.WM_LBUTTONUP:
				_OnMouseUp(System.Windows.Input.MouseButton.Left);
				break;
			case Api.WM_RBUTTONUP:
				if (!_OnMouseUp(System.Windows.Input.MouseButton.Right))
					if (!HitTest(Math2.NintToPOINT(lParam), out _)) RightClickInEmptySpace?.Invoke();
				break;
			case Api.WM_MBUTTONUP:
				_OnMouseUp(System.Windows.Input.MouseButton.Middle);
				break;
			case Api.WM_MOUSEMOVE:
				_OnMouseMove(wParam);
				break;
			}
			return 0;
		case Api.WM_MOUSELEAVE:
			_OnMouseLeave();
			break;
		case Api.WM_CAPTURECHANGED:
			_mouse.active = false;
			break;
		}
		
		var R = Api.DefWindowProc(w, msg, wParam, lParam);
		
		switch (msg) {
		case Api.WM_NCHITTEST when R == Api.HTCLIENT: //let WPF manage drag-drop
			if (Api.GetCapture().ClassNameIs("CLIPBRDWNDCLASS")) R = Api.HTTRANSPARENT;
			break;
		}
		
		return R;
	}
	
	protected override nint WndProc(IntPtr hwnd, int msg, IntPtr wParam, IntPtr lParam, ref bool handled) {
		if (msg == Api.WM_GETOBJECT) { //not in _WndProc, because WPF steals it if passed to base.WndProc
			handled = true;
			return (_acc ??= new _Accessible(this)).WmGetobject(wParam, lParam);
		}
		return base.WndProc(hwnd, msg, wParam, lParam, ref handled);
	}
	
	//protected override System.Windows.Automation.Peers.AutomationPeer OnCreateAutomationPeer() => null; //removes unused object from MSAA tree, but then no UIA
	_Accessible _acc;
	
	protected override void OnPropertyChanged(DependencyPropertyChangedEventArgs e) {
		//print.it(e.Property);
		if (!_leEdit.Is0 && e.Property.Name == "IsVisible" && e.NewValue is bool y && !y) EndEditLabel(true);
		base.OnPropertyChanged(e);
	}
	
	///
	protected override bool TabIntoCore(TraversalRequest r) {
		Focus();
		return true;
	}
	
	///
	protected override HitTestResult HitTestCore(PointHitTestParameters hitTestParameters)
		=> new PointHitTestResult(this, hitTestParameters.HitPoint);
	//need this for drag-drop. See case Api.WM_NCHITTEST above.
}


================================================
FILE: Au.Controls/KTreeView/tv-misc.cs
================================================
using System.Windows;
using System.Windows.Controls;
using System.Windows.Controls.Primitives;

namespace Au.Controls;

public unsafe partial class KTreeView {
	bool _IsValid(int index) => (uint)index < _avi.Lenn_();
	
	//unused
	//bool _IndexToItemStruct(int i, out _VisibleItem item) {
	//	bool r = _IsValid(i);
	//	item = r ? _avi[i] : default;
	//	return r;
	//}
	
	bool _IndexToItem(int i, out ITreeViewItem item) {
		bool r = _IsValid(i);
		item = r ? _avi[i].item : null;
		return r;
	}
	
	ITreeViewItem _IndexToItem(int i) => _IsValid(i) ? _avi[i].item : null;
	
	int _IndexOfOrThrow(ITreeViewItem item, bool canBeNull = false) {
		int i = -1;
		if (item != null) { i = IndexOf(item); if (i < 0) throw new ArgumentException(); } else if (!canBeNull) throw new ArgumentNullException();
		return i;
	}
	
	bool _IndexOfOrThrowIfImportant(bool important, ITreeViewItem item, out int index) {
		index = IndexOf(item);
		if (index < 0) return !important ? false : throw new ArgumentException();
		return true;
	}
	
	bool _IsInside(int iParent, int iChild) {
		int i = iParent;
		if (iChild > i) {
			var level = _avi[i].level;
			while (++i < _avi.Length && _avi[i].level > level) if (i == iChild) return true;
		}
		//never mind: faster would be to use Parent. Would need to add Parent to the interface. Currently don't need speed.
		return false;
	}
	
	//unused
	//bool _IsInside(ITreeViewItem parent, int iChild) {
	//	int i = IndexOf(parent);
	//	return i >= 0 && _IsInside(i, iChild);
	//}
	
	int _DpiScale(int value) => More.Dpi.Scale(value, _dpi);
	
	int _ItemTop(int index) => (index - _vscroll.Pos) * _itemHeight;
	
	/// <summary>
	/// Returns item index, or -1 if not on item.
	/// </summary>
	/// <param name="y">In control coord, physical.</param>
	int _ItemFromY(int y) {
		int i = y / _itemHeight + _vscroll.Pos;
		if (!_IsValid(i)) i = -1;
		return i;
	}
	
	struct _PartOffsets {
		public int left, checkbox, marginLeft, image, text, marginRight, right;
		public bool hasCheckbox;
	}
	
	void _GetPartOffsets(int i, out _PartOffsets p, bool measuring = false) {
		var no = _avi[i].noParts;
		p.left = measuring ? 0 : -_hscroll.Offset;
		p.checkbox = p.left + _Indent(_avi[i]);
		p.hasCheckbox = HasCheckboxes && !no.Has(TVParts.Checkbox);
		p.marginLeft = p.checkbox + (p.hasCheckbox ? _itemLineHeight : 0);
		p.image = p.marginLeft + (no.Has(TVParts.MarginLeft) ? 0 : _marginLeft);
		p.text = p.image + (no.Has(TVParts.Image) ? 0 : _imageSize + _imageMarginX) + _imageMarginX;
		p.marginRight = p.text + _avi[i].measured;
		p.right = p.marginRight + (no.Has(TVParts.MarginRight) ? 0 : _marginRight);
		//print.it(p.checkbox, p.marginLeft, p.image, p.text, p.marginRight, p.right);
		
		int _Indent(in _VisibleItem v) {
			int r = v.level; if (r > 0 && v.noParts.Has(TVParts.Left)) r--;
			int j = _imageSize; if (SmallIndent) j /= 2;
			return r * j;
		}
	}
	
	/// <summary>
	/// Gets item rectangle in physical pixel units.
	/// Horizontally the rectangle is limited to the visible area.
	/// </summary>
	/// <exception cref="IndexOutOfRangeException"></exception>
	/// <exception cref="InvalidOperationException">Control not created.</exception>
	public RECT GetRectPhysical(int index, TVParts parts = 0, bool inScreen = false, bool clampX = false) {
		if (!_IsValid(index)) throw new IndexOutOfRangeException();
		if (!_hasHwnd) throw new InvalidOperationException();
		int y = _ItemTop(index);
		var r = new RECT(0, y, _width, _itemHeight);
		if (parts != 0) {
			_GetPartOffsets(index, out var k);
			//left
			if (parts.Has(TVParts.Left)) r.left = k.left;
			else if (parts.Has(TVParts.Checkbox)) r.left = k.checkbox;
			else if (parts.Has(TVParts.MarginLeft)) r.left = k.marginLeft;
			else if (parts.Has(TVParts.Image)) r.left = k.image;
			else if (parts.Has(TVParts.Text)) r.left = k.text;
			else if (parts.Has(TVParts.MarginRight)) r.left = k.marginRight;
			else r.left = k.right;
			//right
			if (parts.Has(TVParts.Right)) r.right = Math.Max(k.right, _width);
			else if (parts.Has(TVParts.MarginRight)) r.right = k.right;
			else if (parts.Has(TVParts.Text)) r.right = k.marginRight;
			else if (parts.Has(TVParts.Image)) r.right = k.text;
			else if (parts.Has(TVParts.MarginLeft)) r.right = k.image;
			else if (parts.Has(TVParts.Checkbox)) r.right = k.marginLeft;
			else r.right = k.checkbox;
			//clamp
			if (clampX) {
				r.left = Math.Clamp(r.left, 0, _width);
				r.right = Math.Clamp(r.right, 0, _width);
			}
		} else if (!clampX) {
			r.left = -_hscroll.Offset;
			r.right = Math.Max(_width, _itemsWidth - r.left);
		}
		if (inScreen) _w.MapClientToScreen(ref r);
		return r;
	}
	
	/// <summary>
	/// Gets item rectangle in WPF logical pixel units.
	/// </summary>
	/// <exception cref="IndexOutOfRangeException"></exception>
	public Rect GetRectLogical(int index, TVParts parts = 0, bool inScreen = false, bool clampX = false) {
		var r = GetRectPhysical(index, parts, inScreen, clampX);
		double f = 96d / _dpi;
		return new Rect(r.left * f, r.top * f, r.Width * f, r.Height * f);
	}
	
	/// <summary>
	/// Gets item from point, and its part.
	/// Returns false if not on an item.
	/// </summary>
	/// <param name="p">Point in control coordinates. Physical pixels.</param>
	/// <param name="h">Results.</param>
	public bool HitTest(POINT p, out TVHitTest h) {
		h = default;
		if ((uint)p.x < _width && (uint)p.y < _height) {
			int i = _ItemFromY(p.y);
			if (_IndexToItem(i, out var v)) {
				h.index = i;
				h.item = v;
				_GetPartOffsets(i, out var k);
				int x = p.x;
				if (x < k.checkbox) h.part = TVParts.Left;
				else if (x < k.marginLeft) h.part = TVParts.Checkbox;
				else if (x < k.image) h.part = TVParts.MarginLeft;
				else if (x < k.text) h.part = TVParts.Image;
				else if (x < k.marginRight) h.part = TVParts.Text;
				else if (x < k.right) h.part = TVParts.MarginRight;
				else h.part = TVParts.Right;
				return true;
			}
		}
		h.index = -1;
		return false;
	}
	
	/// <summary>
	/// Gets item from mouse, and its part.
	/// Returns false if not on an item.
	/// </summary>
	/// <param name="h">Results.</param>
	public bool HitTest(out TVHitTest h) => HitTest(_w.MouseClientXY, out h);
	
	_LabelTip _labeltip;
	
	class _LabelTip {
		readonly KTreeView _tv;
		ToolTip _tt;
		timer _timer;
		int _i;
		_VisibleItem[] _avi;
		
		public _LabelTip(KTreeView tv) { _tv = tv; }
		
		public void HotChanged(int i) {
			if (i >= 0) {
				var r = _tv.GetRectPhysical(i, TVParts.Text, clampX: true);
				if (_tv._avi[i].measured > r.Width) {
					_timer ??= new timer(_Show);
					_avi = _tv._avi; _i = i;
					_timer.After(300);
					return;
				}
			}
			Hide();
		}
		
		void _Show(timer t) {
			if (_avi != _tv._avi || _i != _tv._hotIndex) return;
			if (_tt == null) {
				_tt = new ToolTip() {
					PlacementTarget = _tv, //need for correct DPI in non-primary screen
					Placement = PlacementMode.Right,
					HorizontalOffset = 4,
					HasDropShadow = false //why no shadow on Win10?
				};
				if (osVersion.minWin8) _tt.Padding = new(2, -1, 2, 1); //on Win7 makes too small
			}
			var r = _tv.GetRectLogical(_i, clampX: true);
			r.X -= 4; r.Width += 4;
			_tt.PlacementRectangle = r;
			_tt.Content = _avi[_i].item.DisplayText;
			_tt.IsOpen = true;
		}
		
		public void Hide() {
			_avi = null;
			_timer?.Stop();
			if (_tt != null && _tt.IsOpen) _tt.IsOpen = false;
		}
	}
	
	_Tooltip _tooltip;
	
	class _Tooltip {
		readonly KTreeView _tv;
		ToolTip _tt;
		timer _timer;
		_VisibleItem[] _avi;
		int _i, _td;
		
		public _Tooltip(KTreeView tv) { _tv = tv; }
		
		public void HotChanged(int i) {
			Hide();
			if (i >= 0 && _tv._IndexToItem(i, out var item) && item.TooltipDelay is int td && td > 0) {
				_timer ??= new timer(_Timer);
				_avi = _tv._avi; _i = i;
				_td = td;
				_timer.Every(50);
			}
		}
		
		void _Timer(timer t) {
			if (_avi != _tv._avi || _i != _tv._hotIndex) { t.Stop(); return; }
			if (Environment.TickCount64 - Api.GetLastInputTime() < _td) return;
			t.Stop();
			_tt ??= new ToolTip() {
				PlacementTarget = _tv, //need for correct DPI in non-primary screen
				Placement = PlacementMode.Mouse,
				HorizontalOffset = 20,
			};
			_avi[_i].item.TooltipSetContent(_tt);
			_tt.IsOpen = true;
		}
		
		public void Hide() {
			_avi = null;
			_timer?.Stop();
			if (_tt != null && _tt.IsOpen) _tt.IsOpen = false;
		}
	}
	
	
}


================================================
FILE: Au.Controls/KTreeView/tv-render.cs
================================================
using System.Drawing;

namespace Au.Controls;

public unsafe partial class KTreeView {
	bool _dontMeasure;
	
	//Called on resize, scroll, set visible items (replace, clear, expand/collapse, add/remove/move).
	void _Measure(bool onScroll = false) {
		if (_dontMeasure) return; //this func is adding/removing scrollbars
		EndEditLabel();
		_labeltip?.Hide();
		_tooltip?.Hide();
		
		int sbV = More.Dpi.ScrollbarV_(_dpi), sbH = More.Dpi.ScrollbarH_(_dpi);
		var rw = _w.Rect; //never mind: minus border. We don't use border.
		int width = rw.Width, height = rw.Height;
		if (width <= sbV || height <= sbH || _avi.NE_()) {
			NativeScrollbar_.ShowVH(_vscroll, false, _hscroll, false);
			return;
		}
		
		int oldScrollPos = _vscroll.Pos;
		g1:
		var range = _GetViewRange();
		
		int maxWidth = _itemsWidth;
		GdiTextRenderer tr = null;
		for (int i = range.from; i < range.to; i++) {
			if (_avi[i].measured > 0) continue;
			tr ??= new GdiTextRenderer(_dpi);
			var item = _avi[i].item;
			bool bold = item.IsBold; if (bold) tr.FontBold();
			int textWidth = item.MesureTextWidth(tr);
			if (textWidth < 0) textWidth = tr.MeasureText(item.DisplayText).width;
			if (bold) tr.FontNormal();
			_avi[i].measured = textWidth + 2;
			_avi[i].noParts = item.NoParts;
			_GetPartOffsets(i, out var p, true); //parts left-to-right: indent, checkbox, left margin, image, text, right margin
			maxWidth = Math.Max(maxWidth, p.right);
		}
		tr?.Dispose();
		if (maxWidth > _itemsWidth) _itemsWidth = maxWidth; else if (onScroll) return;
		
		//set scrollbars
		int itemsHeight = _avi.Length * _itemHeight;
		bool needH = _itemsWidth > width && height >= _imageSize + sbH; if (needH) height -= sbH;
		bool needV = itemsHeight > height && _avi.Length > 1;
		if (needV) { width -= sbV; if (!needH) needH = _itemsWidth > width && height >= _imageSize + sbH; }
		if (_scrollCorrection = (needH && onScroll && _inScrollbarScroll && !_hscroll.Visible)) needH = false;
		_dontMeasure = true;
		NativeScrollbar_.ShowVH(_vscroll, needV, _hscroll, needH);
		_dontMeasure = false;
		if (needV) _vscroll.SetRange(_avi.Length); else _vscroll.NItems = _avi.Length;
		if (needH) _hscroll.SetRange(_itemsWidth); else _hscroll.NItems = 0;
		
		if (!onScroll && _vscroll.Pos != oldScrollPos && oldScrollPos >= 0) { //may scroll up after collapsing a folder
			oldScrollPos = -1;
			goto g1;
		}
	}
	bool _inScrollbarScroll;
	bool _scrollCorrection;
	
	void _ScrollEnded() {
		//workaround for: if we add other scrollbar while SB_THUMBTRACK-scrolling, does not scroll to the very bottom. Would need to scroll 2 times.
		//	Also, if while SB_LINEDOWN-scrolling, the scroll box arrow remains not erased at the bottom-right corner.
		//	Alas scintilla has these problems too.
		if (_scrollCorrection) {
			_scrollCorrection = false;
			int max = _vscroll.Max, pos = _vscroll.Pos;
			_hscroll.Visible = true;
			_hscroll.SetRange(_itemsWidth);
			if (_vscroll.Max > max && pos == max) EnsureVisible(_avi.Length - 1);
		}
	}
	
	void _MeasureClear(bool updateNow) {
		if (!_hasHwnd) return;
		if (_avi != null) for (int i = 0; i < _avi.Length; i++) _avi[i].measured = 0;
		_itemsWidth = 0;
		if (updateNow) {
			_Measure();
			_Invalidate();
		}
	}
	
	(int from, int to) _GetViewRange() {
		int len = _avi.Lenn_(); if (len == 0) return default;
		int i = _vscroll.Pos + (_height + _itemHeight - 1) / _itemHeight;
		return (_vscroll.Pos, Math.Min(i, len));
	}
	
	void _Invalidate(RECT* r = null) {
		if (_hasHwnd) Api.InvalidateRect(_w, r, false);
	}
	
	void _Invalidate(int index) {
		if (!_hasHwnd) return;
		var r = GetRectPhysical(index, clampX: true);
		if (r.bottom > 0 && r.top < _height) Api.InvalidateRect(_w, &r, false);
	}
	
	/// <summary>
	/// Asynchronously redraws item.
	/// Does nothing if the control is not created.
	/// </summary>
	/// <param name="index"></param>
	/// <param name="remeasure">Remeasure item width. My need this when changed text or text style.</param>
	/// <exception cref="IndexOutOfRangeException"></exception>
	public void Redraw(int index, bool remeasure = false) {
		if (!_hasHwnd) return;
		if (!_IsValid(index)) throw new IndexOutOfRangeException();
		if (remeasure) {
			//if this was the widest measured item, need to remeasure all, else would not update horz scrollbar if this item become narrower
			int max = 0; for (int i = 0; i < _avi.Length; i++) max = Math.Max(max, _avi[i].measured);
			if (max == _avi[index].measured) {
				_MeasureClear(updateNow: true);
				return;
			}
			_avi[index].measured = 0;
			_Measure();
		}
		_Invalidate(index);
	}
	
	/// <summary>
	/// Asynchronously redraws item.
	/// Does nothing if the control is not created or <i>item</i> is not a visible item in this control.
	/// </summary>
	/// <param name="item"></param>
	/// <param name="remeasure">Remeasure item width. My need this when changed text or text style.</param>
	public void Redraw(ITreeViewItem item, bool remeasure = false) {
		if (!_hasHwnd) return;
		int i = IndexOf(item);
		if (i >= 0) Redraw(i, remeasure);
	}
	
	/// <summary>
	/// Asynchronously redraws all items.
	/// Does nothing if the control is not created.
	/// </summary>
	/// <param name="remeasure">Remeasure item width. My need this when changed text or text style.</param>
	public void Redraw(bool remeasure = false) {
		if (!_hasHwnd) return;
		if (remeasure) _MeasureClear(updateNow: true);
		else _Invalidate();
	}
	
	//	/// <summary>
	//	/// Remeasure item widths and redraws. My need this when changed text or text style.
	//	/// Does nothing if the control is not created.
	//	/// </summary>
	//	/// <param name="indices"></param>
	//	/// <exception cref="ArgumentOutOfRangeException"></exception>
	//	public void Remeasure(Range indices) {
	//		if(_border==null) return;
	//		var (i, to)=indices.GetStartEnd(_avi.Lenn_());
	//		while(i<to) _avi[i++].measured=0;
	//		_Measure();
	//		_Invalidate();
	//	}
	
	/// <summary>
	/// Image background brush.
	/// Does not redraw.
	/// </summary>
	public Brush ImageBrush { get; set; }
	
	/// <summary>
	/// Background color.
	/// Ignored if high contrast.
	/// </summary>
	public ColorInt? BackgroundColor { get; set; }
	
	//public ColorInt? TextColor { get; set; }
	
	public const int ColorSelectedItemFocused = 0xc4d5ff;
	
	public const int ColorSelectedItemNonfocused = 0xe0e0e0;
	
	public const int ColorHotItem = 0xe8f0ff;
	
	/// <summary>
	/// Smaller indentation.
	/// </summary>
	public bool SmallIndent { get; set; }
	
	void _Render(IntPtr dc, RECT rUpdate) {
		Graphics graphics = null;
		try {
			TVColorInfo colorInfo = new() { isHighContrast = System.Windows.SystemParameters.HighContrast };
			
			bool haveBackColor = BackgroundColor != null && !colorInfo.isHighContrast;
			if (haveBackColor) {
				graphics = Graphics.FromHdc(dc);
				graphics.Clear((Color)BackgroundColor.Value);
			} else {
				Api.FillRect(dc, rUpdate, (IntPtr)(Api.COLOR_WINDOW + 1));
			}
			if (_avi.NE_()) return;
			
			var range = _GetViewRange();
			int nDraw = range.to - range.from;
			if (nDraw > 0) {
				int backColor = haveBackColor ? BackgroundColor.Value.ToBGR() : Api.GetSysColor(Api.COLOR_WINDOW);
				int textColor = Api.GetSysColor(Api.COLOR_WINDOWTEXT);
				
				colorInfo.isTextBlack = textColor == 0;
				if (colorInfo.isHighContrast) colorInfo.isHighContrastDark = WpfUtil_.IsHighContrastDark;
				colorInfo.isFocusedControl = this.IsKeyboardFocused;
				
				int yyImages = (_itemLineHeight + 1 - _imageSize) / 2;
				//int yyText = _itemLineHeight <= 22 ? 1 : _itemLineHeight <= 28 ? 0 : -1; //when high DPI, text used to be too low, but now on Win11 it seems good, don't need this correction
				int yyText = 1;
				
				graphics ??= Graphics.FromHdc(dc);
				var tr = new GdiTextRenderer(dc, _dpi);
				IntPtr checkTheme = HasCheckboxes ? Api.OpenThemeData(_w, "Button", _dpi) : default;
				try {
					graphics.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.HighQualityBicubic;
					SIZE cSize = default;
					if (HasCheckboxes)
						if (checkTheme == default || 0 != Api.GetThemePartSize(checkTheme, dc, 3, 1, null, Api.THEMESIZE.TS_TRUE, out cSize))
							cSize.width = cSize.height = More.Dpi.Scale(13, _dpi);
					
					var cd = CustomDraw;
					var cdi = cd == null ? null : new TVDrawInfo(this, dc, graphics, _dpi);
					cd?.Begin(cdi, tr);
					
					for (int i = 0; i < nDraw; i++) {
						int y = i * _itemHeight;
						var r = new RECT(0, y, _width, _itemHeight);
						if (!r.IntersectsWith(rUpdate)) continue;
						
						int index = i + range.from;
						var v = _avi[index];
						var item = v.item;
						var noParts = v.noParts;
						_GetPartOffsets(index, out var p); //parts left-to-right: indent, checkbox, left margin, image, text, right margin
						int xImage = p.image + _imageMarginX, yImage = y + yyImages;
						int yText = y + yyText;
						
						colorInfo.isSelected = v.isSelected;
						colorInfo.isHot = index == _hotIndex;
						colorInfo.isFocusedItem = index == _focusedIndex;
						
						if (cdi != null) {
							cdi.index = index;
							cdi.item = item;
							cdi.rect = r;
							cdi.imageRect = new RECT(xImage, yImage, noParts.Has(TVParts.Image) ? 0 : _imageSize, _imageSize);
							cdi.xText = p.text;
							cdi.yText = yText;
							cdi.xLeft = p.marginLeft;
							cdi.xRight = p.marginRight;
							cdi.lineHeight = _itemLineHeight;
							cdi.colorInfo = colorInfo;
							cdi.marginLeft = noParts.Has(TVParts.MarginLeft) ? 0 : _marginLeft;
							cdi.marginRight = noParts.Has(TVParts.MarginRight) ? 0 : _marginRight;
							cdi.checkSize = p.hasCheckbox ? cSize : default;
						}
						
						//background
						bool hiliteSysColor = false;
						if (cd == null || !cd.DrawBackground()) {
							int color = item.Color(colorInfo);
							if (color != -1 || (backColor & 0xe0e0e0) == 0xe0e0e0) { //custom color, or default color is [almost] white
								if (color != -1) //draw custom color
									using (var b1 = GdiObject_.ColorBrush(color)) b1.BrushFill(dc, r);
								int alpha = color >>> 24;
								if (color == -1 || alpha is >= 1 and <= 3) { //if no custom color or if custom color's alpha is 1 - 3, draw selection or hot background
									color = -1;
									if (v.isSelected) {
										if (0 != (alpha & 1)) {
											color = item.SelectedColor(colorInfo);
											if (color == -1) color = colorInfo.isFocusedControl ? ColorSelectedItemFocused : ColorSelectedItemNonfocused;
										}
									} else if (HotTrack && index == _hotIndex) {
										if (0 != (alpha & 2)) color = ColorHotItem;
									}
									if (color != -1) {
										var r2 = r; r2.left = p.text - _imageMarginX / 2; //don't draw selection background under icon and checkbox
										using (var b2 = GdiObject_.ColorBrush(color)) b2.BrushFill(dc, r2);
									}
								}
							} else { //probably high contrast or dark BackgroundColor
								if (hiliteSysColor = v.isSelected) Api.FillRect(dc, r, (IntPtr)(Api.COLOR_HIGHLIGHT + 1));
							}
							
							color = item.BorderColor(colorInfo);
							if (color != -1) {
								int alpha = color >>> 24;
								var r2 = r; if (alpha == 1) r2.left = p.text - _imageMarginX / 2 - 1;
								using (var b3 = GdiObject_.ColorBrush(color)) b3.BrushRect(dc, r2);
							}
						}
						
						//checkbox
						if (p.hasCheckbox && item.CheckState != TVCheck.None) {
							if (cd == null || !cd.DrawCheckbox()) {
								//if(1==(i&3)) item.CheckState=TVCheck.Checked; if(2==(i&3)) item.CheckState=TVCheck.Mixed; if(3==(i&3)) item.CheckState=TVCheck.Excluded; if(0!=(i&4)) v.IsDisabled=true; //test
								var rr = new RECT(p.marginLeft - cSize.width - (p.marginLeft - p.checkbox - cSize.width) * 2 / 5, y + (_itemLineHeight - cSize.height) / 2, cSize.width, cSize.height);
								var ch = item.CheckState;
								if (checkTheme != default) {
									int state = ch switch { TVCheck.Checked => 5, TVCheck.RadioChecked => 5, TVCheck.Mixed => 9, TVCheck.Excluded => 17, _ => 1 }; //CBS_x,RBS_x
									if (item.IsDisabled) state += 3; else if (index == _hotIndex) state += 1;
									Api.DrawThemeBackground(checkTheme, dc, (ch == TVCheck.RadioChecked || ch == TVCheck.RadioUnchecked) ? 2 : 3, state, rr); //BP_RADIOBUTTON,BP_CHECKBOX
								} else if (ch != TVCheck.Excluded) {
									int state = ch switch { TVCheck.Checked => 0x400, TVCheck.Mixed => 0x408, TVCheck.RadioUnchecked => 0x4, TVCheck.RadioChecked => 0x404, _ => 0 }; //DFCS_x
									if (item.IsDisabled) state |= 0x100; else if (index == _hotIndex) state |= 0x1000;
									KApi.DrawFrameControl(dc, rr, 4, state); //DFC_BUTTON
								}
								//cannot use .NET CheckBoxRenderer etc because no per-monitor DPI.
							}
						}
						
						if (!noParts.Has(TVParts.Image)) {
							//image background
							if (ImageBrush != null) {
								int imm = (_imageMarginX + 1) / 2;
								graphics.FillRectangle(ImageBrush, xImage - imm, y, _imageSize + imm * 2, _itemLineHeight);
							}
							
							//image
							_DrawImage(item.Image);
							
							void _DrawImage(object imo) {
								Bitmap b = null;
								switch (imo) {
								case Bitmap v:
									b = v;
									break;
								case string v:
									if (v == "link:") { v = s_stockLinkIcon.Value; if (v == null) break; }
									b = ImageCache.Get(v, _dpi, ImageUtil.HasImageOrResourcePrefix(v));
									break;
								case IEnumerable<object> v:
									foreach (var o in v) _DrawImage(o);
									break;
								}
								
								if (b != null) {
									try { //exception if Image.LoadBitmap loaded an invalid or ico file
										if (cd == null || !cd.DrawImage(b)) {
											graphics.DrawImage(b, new Rectangle(xImage, yImage, _imageSize, _imageSize));
										}
									}
									catch (Exception ex) { Debug_.Print(ex); }
								}
							}
						}
						
						//text
						if (cd == null || !cd.DrawText()) {
							bool bold = item.IsBold; if (bold) tr.FontBold();
							int color = item.TextColor(colorInfo);
							if (color == -1) color = item.IsDisabled ? Api.GetSysColor(Api.COLOR_GRAYTEXT) : hiliteSysColor ? Api.GetSysColor(Api.COLOR_HIGHLIGHTTEXT) : textColor;
							else color = ColorInt.SwapRB(color);
							
							//tr.DrawText(item.DisplayText, (p.text, yText), color);
							RECT rt = new(p.text, yText, v.measured, r.bottom - yText);
							tr.DrawText(item.DisplayText, rt, color);
							
							if (bold) tr.FontNormal();
						}
						
						if (cd != null) {
							if (!noParts.Has(TVParts.MarginLeft)) cd.DrawMarginLeft();
							if (!noParts.Has(TVParts.MarginRight)) cd.DrawMarginRight();
						}
						
						//drag & drop insertion mark
						if (_dd != null && _dd.insertIndex == index) {
							int thick = More.Dpi.Scale(3, _dpi);
							using var pen = new Pen(SystemColors.WindowText, thick);
							y += thick / 2; int h1 = _itemHeight - thick;
							if (_dd.insertFolder) {
								graphics.DrawRectangle(pen, xImage, y, _imageSize, h1);
							} else {
								if (_dd.insertAfter) y += h1;
								graphics.DrawLine(pen, p.checkbox, y, _width, y);
							}
						}
					}
					
					cd?.End();
				}
				finally {
					tr.Dispose();
					if (checkTheme != default) Api.CloseThemeData(checkTheme);
				}
			}
		}
		finally { graphics?.Dispose(); }
	}
	
	static string _StockLinkLocation() {
		if (!icon.GetStockIconLocation_(StockIcon.LINK, out var ipath, out int iindex)) return null;
		return ipath + "," + iindex.ToS();
	}
	static Lazy<string> s_stockLinkIcon = new(_StockLinkLocation);
	
	/// <summary>
	/// Gets or sets image cache.
	/// If not set, uses <see cref="IconImageCache.Common"/>.
	/// </summary>
	public IconImageCache ImageCache {
		get => _imageCache ??= IconImageCache.Common;
		set { _imageCache = value; }
	}
	IconImageCache _imageCache;
	
	/// <summary>
	/// Width of custom-draw area before image. For example for state images.
	/// Use WPF logical units, not physical pixels.
	/// </summary>
	public int ItemMarginLeft {
		get => _itemMarginLeft_;
		set {
			if (value != _itemMarginLeft_) {
				_itemMarginLeft_ = value;
				_marginLeft = _DpiScale(value);
				_MeasureClear(true);
			}
		}
	}
	int _itemMarginLeft_;
	
	/// <summary>
	/// Width of custom-draw area after item text.
	/// Use WPF logical units, not physical pixels.
	/// </summary>
	public int ItemMarginRight {
		get => _itemMarginRight_;
		set {
			if (value != _itemMarginRight_) {
				_itemMarginRight_ = value;
				_marginRight = _DpiScale(value);
				_MeasureClear(true);
			}
		}
	}
	int _itemMarginRight_;
	
	/// <summary>
	/// Custom-draw interface.
	/// </summary>
	public ITVCustomDraw CustomDraw {
		get => _customDraw_;
		set {
			if (value != _customDraw_) {
				_customDraw_ = value;
				_Invalidate();
			}
		}
	}
	ITVCustomDraw _customDraw_;
	
	/// <summary>
	/// Add this % to the item height. The area is below the main text/icon/checkbox. The control does not draw in it. Let your custom draw class draw there.
	/// </summary>
	public int CustomItemHeightAddPercent { get; set; }
	
	///// <summary>
	///// If not null, fills background with this color instead of the system window background color.
	///// Set this property at startup (does not update control when changed).
	///// </summary>
	//public ColorInt? BackgroundColor { get; set; }
#pragma warning restore 1591
}


================================================
FILE: Au.Controls/KTreeView/tv-types.cs
================================================
using System.Windows.Input;

namespace Au.Controls;

/// <summary>
/// Interface for <see cref="KTreeView"/> items. Provides text and other properties.
/// </summary>
public interface ITreeViewItem {
	/// <summary>
	/// Folder's child items. Return null if not folder.
	/// </summary>
	IEnumerable<ITreeViewItem> Items => null;

	/// <summary>
	/// Is folder.
	/// </summary>
	bool IsFolder => false;

	/// <summary>
	/// Is expanded folder.
	/// </summary>
	bool IsExpanded => false;

	/// <summary>
	/// Called after expanding or collapsing this folder.
	/// </summary>
	void SetIsExpanded(bool yes) { }

	/// <summary>
	/// Text to display.
	/// </summary>
	string DisplayText { get; }

	/// <summary>
	/// Called after label editing.
	/// </summary>
	void SetNewText(string text) { }

	/// <summary>
	/// Image as:
	/// <br/>• string - image source.
	/// <br/>• <b>System.Drawing.Bitmap</b>.
	/// <br/>• <b>IEnumerable&lt;object&gt;</b> of these, to draw image and overlay(s).
	/// <para>
	/// If string, will use <see cref="IconImageCache.Get"/>; see <see cref="KTreeView.ImageCache"/>.
	/// <br/>String prefix:
	/// <br/>• none - gets file icon; see <see cref="icon.of"/>.
	/// <br/>• <c>"*"</c> - icon name like <c>"*Pack.Icon color"</c>.
	/// <br/>• <c>"imagefile:"</c> - path of png/bmp/jpg/gif/tif or xaml file.
	/// <br/>• <c>"resource:"</c> - path of png/bmp/jpg/gif/tif or xaml resource. Don't need prefix if starts with "resources/", like "resources/file.png".
	/// <br/>• <c>"image:"</c> - Base64 encoded image file.
	/// <br/>• <c>"link:"</c> (and nothing more) - link overlay image.
	/// </para>
	/// <para>
	/// If <b>Bitmap</b>, and its DPI does not match control's DPI (<see cref="KTreeView.Dpi"/>), draws it auto-scaled.
	/// </para>
	/// </summary>
	object Image => null;

	/// <summary>
	/// How to draw checkbox when <see cref="KTreeView.HasCheckboxes"/> true. Default <b>Unchecked</b>.
	/// </summary>
	TVCheck CheckState => default;

	/// <summary>
	/// Draw text and checkbox like disabled (usually gray).
	/// </summary>
	bool IsDisabled => false;

	/// <summary>
	/// Draw bold text.
	/// </summary>
	bool IsBold => false;

	/// <summary>
	/// Can be selected. Default true.
	/// </summary>
	bool IsSelectable => true;

	/// <summary>
	/// Background color 0xRRGGBB. If -1 (default), uses default colors, depending on state (normal, selected, hot).
	/// If alpha is 1 - 3: if contains flag 1, draws selection color when selected; if 2, draws hot color when hot.
	/// </summary>
	int Color(TVColorInfo ci) => -1;

	/// <summary>
	/// Selected item background color 0xRRGGBB. If -1 (default), uses default color.
	/// Not called if the background color isn't near white or if <see cref="Color"/> sets a custom color.
	/// </summary>
	int SelectedColor(TVColorInfo ci) => -1;

	/// <summary>
	/// Text color 0xRRGGBB. If -1 (default), uses default colors, depending on state (normal, disabled).
	/// </summary>
	int TextColor(TVColorInfo ci) => -1;

	/// <summary>
	/// Border color 0xRRGGBB. No border if -1 (default).
	/// If alpha is 1, draws left edge between text and icon.
	/// </summary>
	int BorderColor(TVColorInfo ci) => -1;
	
	/// <summary>
	/// Called to measure text width.
	/// If not implemented or returns -1, will measure <see cref="DisplayText"/>.
	/// </summary>
	int MesureTextWidth(GdiTextRenderer tr) => -1;
	
	/// <summary>
	/// Don't measure/draw these parts.
	/// Valid flags: <b>Checkbox</b>, <b>MarginLeft</b>, <b>Image</b>, <b>MarginRight</b>, <b>Left</b> (minus 1 indent).
	/// </summary>
	TVParts NoParts => 0;
	
	/// <summary>
	/// Called when mouse enters this item. If returns &gt; 0, after this hover time (ms) will call <see cref="TooltipSetContent"/>
	/// </summary>
	int TooltipDelay => 0;
	
	/// <summary>
	/// Called before showing tooltip, to set tooltip content and maybe change tooltip properties.
	/// The controls calls this and shows the tooltip only if <see cref="TooltipDelay"/> &gt; 0.
	/// </summary>
	void TooltipSetContent(System.Windows.Controls.ToolTip tt) {  }
}

/// <summary>
/// <see cref="KTreeView"/> checkbox state.
/// </summary>
public enum TVCheck : byte { Unchecked, Checked, Mixed, Excluded, RadioUnchecked, RadioChecked, None }

/// <summary>
/// <see cref="KTreeView"/> item parts.
/// </summary>
[Flags]
public enum TVParts : byte {
	/// <summary>Empty area at the left (indentation).</summary>
	Left = 1,

	/// <summary>Checkbox rectangle.</summary>
	Checkbox = 2,

	/// <summary>Left margin rectangle.</summary>
	MarginLeft = 4,

	/// <summary>Image rectangle.</summary>
	Image = 8,

	/// <summary>Text rectangle.</summary>
	Text = 16,

	/// <summary>Right margin rectangle.</summary>
	MarginRight = 32,

	/// <summary>Empty area at the right.</summary>
	Right = 64,

	//note: values must be increasing from left to right
}

/// <summary>
/// <see cref="KTreeView.HitTest"/> results.
/// </summary>
public struct TVHitTest {
	/// <summary>Item, or null if not on an item.</summary>
	public ITreeViewItem item;

	/// <summary>Item index, or -1 if not on an item.</summary>
	public int index;

	/// <summary>Item part.</summary>
	public TVParts part;
}

/// <param name="Item"></param>
/// <param name="Index"></param>
/// <param name="Part">Valid if clicked with mouse.</param>
/// <param name="Button">Valid if clicked with mouse.</param>
/// <param name="ClickCount">1 click, 2 double-click, 0 key or acc.</param>
/// <param name="XY">Valid if clicked with mouse.</param>
/// <param name="Mod"></param>
public record class TVItemEventArgs(ITreeViewItem Item, int Index, TVParts Part = 0, MouseButton Button = 0, int ClickCount = 0, POINT XY = default, ModifierKeys Mod = 0);

/// <summary>
/// Custom-draw interface used with <see cref="KTreeView.CustomDraw"/>.
/// </summary>
/// <remarks>
/// When drawing the control, the first and last called functions are <b>Begin</b> and <b>End</b>. For each actually visible item are called functions in this order: <b>DrawBackground</b>, <b>DrawCheckbox</b>, <b>DrawImage</b>, <b>DrawText</b>, <b>DrawMarginLeft</b>, <b>DrawMarginRight</b>. If a bool function returns false, the control draws that part of the item.
/// </remarks>
public interface ITVCustomDraw {
	void Begin(TVDrawInfo cd, GdiTextRenderer tr);
	bool DrawBackground() => false;
	bool DrawCheckbox() => false;
	bool DrawImage(System.Drawing.Bitmap image) => false;
	bool DrawText() => false;
	void DrawMarginLeft() { }
	void DrawMarginRight() { }
	void End() { }
}

/// <summary>
/// Custom-draw info passed to <see cref="ITVCustomDraw"/>.
/// </summary>
public class TVDrawInfo {
	public readonly KTreeView control;

	/// <summary>GDI device context handle.</summary>
	public readonly IntPtr dc;

	public readonly System.Drawing.Graphics graphics;
	public readonly int dpi;

	/// <summary>Index of current item.</summary>
	public int index;

	/// <summary>Current item.</summary>
	public ITreeViewItem item;

	/// <summary>Background drawing rectangle of current item.</summary>
	public RECT rect;

	/// <summary>Image drawing rectangle of current item.</summary>
	public RECT imageRect;

	/// <summary>Text drawing X offset of current item.</summary>
	public int xText;

	/// <summary>Text drawing Y offset of current item.</summary>
	public int yText;

	/// <summary>Left margin drawing X offset of current item.</summary>
	public int xLeft;

	/// <summary>Right margin drawing X offset of current item.</summary>
	public int xRight;

	/// <summary>Left margin width of current item.</summary>
	public int marginLeft;

	/// <summary>Right margin width of current item.</summary>
	public int marginRight;

	/// <summary>Checkbox size.</summary>
	public SIZE checkSize;
	
	/// <summary>
	/// Item height without added custom height (<see cref="KTreeView.CustomItemHeightAddPercent"/>).
	/// </summary>
	public int lineHeight;
	
	public TVColorInfo colorInfo;

	public TVDrawInfo(KTreeView tv, IntPtr dc, System.Drawing.Graphics graphics, int dpi) {
		control = tv;
		this.dc = dc;
		this.graphics = graphics;
		this.dpi = dpi;
	}
}

public struct TVColorInfo {
	public bool isSelected, isHot, isFocusedItem, isFocusedControl, isHighContrast, isHighContrastDark, isTextBlack;
}

/// <summary>See <see cref="KTreeView.GetDropInfo"/>.</summary>
public struct TVDropInfo {
	/// <summary>Point relative to the top-left of the control without border. Physical pixels.</summary>
	public POINT xy;

	/// <summary>Item at <b>targetIndex</b>, or null if <b>xy</b> is not on an item.</summary>
	public ITreeViewItem targetItem;

	/// <summary>Index of item from <b>xy</b>, or -1 if <b>xy</b> is not on an item.</summary>
	public int targetIndex;

	/// <summary>If true, should insert after the drop target item. Else before. Not used if <b>intoFolder</b> is true.</summary>
	public bool insertAfter;

	/// <summary><b>xy</b> is in a folder center, therefore should move to the folder.</summary>
	public bool intoFolder;
}

/// <summary>
/// Used with <see cref="KTreeView.SetFocusedItem"/> and functions that call it.
/// </summary>
[Flags]
public enum TVFocus {
	/// <summary>
	/// Call <see cref="EnsureVisible"/>. Default.
	/// </summary>
	EnsureVisible = 1,
	
	/// <summary>
	/// Scroll if need so that the item would be at the top of really visible range.
	/// </summary>
	ScrollTop = 2,
}


================================================
FILE: Au.Controls/Simple/KCheckBox.cs
================================================
using System.Windows;
using System.Windows.Controls;
using System.Windows.Media;
using System.Windows.Controls.Primitives;

namespace Au.Controls;

/// <summary>
/// Replaces bool? IsChecked with bool IsChecked.
/// Adds events/overrides for "checked state changed".
/// </summary>
public class KCheckBox : CheckBox {
	public new bool IsChecked {
		get => base.IsChecked == true;
		set => base.IsChecked = value;
	}

	protected override void OnChecked(RoutedEventArgs e) {
		base.OnChecked(e);
		OnCheckChanged(e);
	}

	protected override void OnUnchecked(RoutedEventArgs e) {
		base.OnUnchecked(e);
		OnCheckChanged(e);
	}

	protected override void OnIndeterminate(RoutedEventArgs e) {
		base.OnIndeterminate(e);
		OnCheckChanged(e);
	}

	/// <summary>
	/// Raises <see cref="CheckChanged"/> event.
	/// </summary>
	protected virtual void OnCheckChanged(RoutedEventArgs e) {
		CheckChanged?.Invoke(this, e);
	}

	/// <summary>
	/// When check state changed (checked/unchecked/indeterminate).
	/// Can be used to avoid 2-3 event handlers (Checked/Unchecked/Indeterminate).
	/// </summary>
	public event RoutedEventHandler CheckChanged;
}

/// <summary>
/// <see cref="KCheckBox"/> without the box part.
/// </summary>
class KCheckNoBox : KCheckBox {
	static KCheckNoBox() {
		bool contrast = SystemParameters.HighContrast;
		
		var borderFactory = new FrameworkElementFactory(typeof(Border));
		borderFactory.Name = "border";
		borderFactory.SetValue(Border.CornerRadiusProperty, new CornerRadius(8));
		borderFactory.SetValue(Border.BorderThicknessProperty, new Thickness(contrast ? 2 : 1));
		borderFactory.SetValue(Border.BorderBrushProperty, SystemColors.ControlLightBrush);
		borderFactory.SetValue(Border.BackgroundProperty, SystemColors.ControlLightLightBrush);
		borderFactory.SetValue(Border.PaddingProperty, new Thickness(4, 0, 4, 1));
		
		var contentPresenter = new FrameworkElementFactory(typeof(ContentPresenter));
		contentPresenter.SetValue(System.Windows.Documents.TextElement.ForegroundProperty, new TemplateBindingExtension(ForegroundProperty));
		contentPresenter.SetValue(ContentPresenter.RecognizesAccessKeyProperty, true);
		
		borderFactory.AppendChild(contentPresenter);
		
		var template = new ControlTemplate(typeof(KCheckNoBox));
		template.VisualTree = borderFactory;
		
		if (contrast) {
			var t1 = new Trigger { Property = IsCheckedProperty, Value = true };
			t1.Setters.Add(new Setter(Border.BackgroundProperty, SystemColors.HighlightBrush, "border"));
			t1.Setters.Add(new Setter(ForegroundProperty, SystemColors.HighlightTextBrush));
			template.Triggers.Add(t1);
		} else {
			var brushes = GetBrushes_();
			
			var t1 = new Trigger { Property = IsCheckedProperty, Value = true };
			t1.Setters.Add(new Setter(Border.BackgroundProperty, brushes.checkedCold, "border"));
			t1.Setters.Add(new Setter(Border.BorderBrushProperty, SystemColors.ControlLightLightBrush, "border"));
			template.Triggers.Add(t1);
			
			var t2 = new Trigger { Property = IsMouseOverProperty, Value = true };
			t2.Setters.Add(new Setter(Border.BackgroundProperty, brushes.uncheckedHot, "border"));
			template.Triggers.Add(t2);
			
			var mt = new MultiTrigger(); //checked hot
			mt.Conditions.Add(new Condition { Property = IsCheckedProperty, Value = true });
			mt.Conditions.Add(new Condition { Property = IsMouseOverProperty, Value = true });
			mt.Setters.Add(new Setter(Border.BackgroundProperty, brushes.checkedHot, "border"));
			template.Triggers.Add(mt);
		}
		
		var style = new Style(typeof(KCheckNoBox));
		style.Setters.Add(new Setter(TemplateProperty, template));
		
		StyleProperty.OverrideMetadata(typeof(KCheckNoBox), new FrameworkPropertyMetadata(style));
	}
	
	internal static (Brush checkedCold, Brush checkedHot, Brush uncheckedHot) GetBrushes_() {
		if (s_checkedCold == null) {
			var c = (Color)new ColorInt(0x92C1E6);
			SolidColorBrush brush1 = new(c), brush2 = new(Color.FromArgb(180, c.R, c.G, c.B)), brush3 = new(Color.FromArgb(80, c.R, c.G, c.B));
			brush1.Freeze();
			brush2.Freeze();
			brush3.Freeze();
			s_checkedHot = brush2;
			s_uncheckedHot = brush3;
			s_checkedCold = brush1;
		}
		return (s_checkedCold, s_checkedHot, s_uncheckedHot);
	}
	static Brush s_checkedCold, s_checkedHot, s_uncheckedHot;
}

/// <summary>
/// Child <c>Button</c> for <see cref="KCheckNoBox"/>.
/// </summary>
class KButtonRoundNoBorder : Button {
	static KButtonRoundNoBorder() {
		bool contrast = SystemParameters.HighContrast;
		
		var borderFactory = new FrameworkElementFactory(typeof(Border));
		borderFactory.Name = "border";
		borderFactory.SetValue(Border.CornerRadiusProperty, new CornerRadius(8));
		borderFactory.SetValue(Border.BackgroundProperty, SystemColors.ControlLightLightBrush);
		borderFactory.SetValue(Border.PaddingProperty, new Thickness(3, 0, 3, 0));
		
		var contentPresenter = new FrameworkElementFactory(typeof(ContentPresenter));
		contentPresenter.SetValue(System.Windows.Documents.TextElement.ForegroundProperty, new TemplateBindingExtension(ForegroundProperty));
		contentPresenter.SetValue(ContentPresenter.RecognizesAccessKeyProperty, true);
		
		borderFactory.AppendChild(contentPresenter);
		
		var template = new ControlTemplate(typeof(KButtonRoundNoBorder));
		template.VisualTree = borderFactory;
		
		if (!contrast) {
			var brushes = KCheckNoBox.GetBrushes_();
			
			var t2 = new Trigger { Property = IsMouseOverProperty, Value = true };
			t2.Setters.Add(new Setter(Border.BackgroundProperty, brushes.uncheckedHot, "border"));
			template.Triggers.Add(t2);
		}
		
		var style = new Style(typeof(KButtonRoundNoBorder));
		style.Setters.Add(new Setter(TemplateProperty, template));
		
		StyleProperty.OverrideMetadata(typeof(KButtonRoundNoBorder), new FrameworkPropertyMetadata(style));
	}
}

/// <summary>
/// KCheckBox and KTextBox. Optionally + Button and KPopupListBox.
/// </summary>
public class KCheckTextBox {
	public readonly KCheckBox c;
	public readonly KTextBox t;
	readonly Button _button;
	KPopupListBox _popup;
	object _items; //List<string> or Func<List<string>>
	
	///
	public KCheckTextBox(KCheckBox c, KTextBox t, Button button = null) {
		this.c = c;
		this.t = t;
		c.Tag = this;
		t.Tag = this;
		t.Small = true;
		_button = button;
		if (_button != null) {
			//_button.ClickMode = ClickMode.Press; //open on button down. But then Popup.StaysOpen=false does not work. Tried async, but same. //TODO3: replace Popup in KPopupListBox with KPopup.
			_button.Click += (_, _) => {
				if (_popup?.IsOpen ?? false) {
					_popup.IsOpen = false;
					return;
				}
				List<string> a = null;
				switch (_items) {
				case List<string> u: a = u; break;
				case Func<List<string>> u: a = u(); break;
				}
				if (a.NE_()) return;
				if (_popup == null) {
					_popup = new KPopupListBox { PlacementTarget = t };
					_popup.OK += o => {
						c.IsChecked = true;
						var s = o as string;
						t.Text = s;
						t.Focus();
					};
				}
				_popup.Control.ItemsSource = null;
				_popup.Control.ItemsSource = a;
				_popup.Control.MinWidth = t.ActualWidth + _button.ActualWidth - 1;
				_popup.IsOpen = true;
			};
		}
	}
	
	///
	public void Deconstruct(out KCheckBox c, out TextBox t) { c = this.c; t = this.t; }
	
	/// <summary>
	/// Gets or sets <b>Visibility</b> of controls. If false, <b>Visibility</b> is <b>Collapsed</b>.
	/// </summary>
	public bool Visible {
		get => t.Visibility == Visibility.Visible;
		set {
			var vis = value ? Visibility.Visible : Visibility.Collapsed;
			c.Visibility = vis;
			t.Visibility = vis;
			if (_button != null) _button.Visibility = vis;
		}
	}
	
	public void Set(bool check, string text) {
		c.IsChecked = check;
		t.Text = text;
	}
	
	public void Set(bool check, string text, List<string> items) {
		c.IsChecked = check;
		t.Text = text;
		_items = items;
	}
	
	public void Set(bool check, string text, Func<List<string>> items) {
		c.IsChecked = check;
		t.Text = text;
		_items = items;
	}
	
	public void Clear(string text = null) {
		c.IsChecked = false;
		t.Text = text;
		_items = null;
	}
	
	/// <summary>
	/// If checked and visible and text not empty, gets text and returns true. Else sets s=null and returns false.
	/// </summary>
	/// <param name="s"></param>
	/// <param name="emptyToo">If text empty, get "" and return true.</param>
	public bool GetText(out string s, bool emptyToo = false) {
		s = null;
		if (!c.IsChecked || !Visible) return false;
		var v = t.Text;
		if (!emptyToo && v.Length == 0) return false;
		s = v;
		return true;
	}
	
	public bool CheckIfTextNotEmpty() {
		if (!c.IsChecked && t.Text.Length > 0) { c.IsChecked = true; return true; }
		return false;
	}
}

/// <summary>
/// KCheckBox and ComboBox.
/// </summary>
public class KCheckComboBox {
	public readonly KCheckBox c;
	public readonly ComboBox t;
	
	///
	public KCheckComboBox(KCheckBox c, ComboBox t) {
		this.c = c;
		this.t = t;
		c.Tag = this;
		t.Tag = this;
	}
	
	///
	public void Deconstruct(out KCheckBox c, out ComboBox t) { c = this.c; t = this.t; }
	
	/// <summary>
	/// Gets or sets <b>Visibility</b> of controls. If false, <b>Visibility</b> is <b>Collapsed</b>.
	/// </summary>
	public bool Visible {
		get => t.Visibility == Visibility.Visible;
		set {
			var vis = value ? Visibility.Visible : Visibility.Collapsed;
			c.Visibility = vis;
			t.Visibility = vis;
		}
	}
	
	/// <summary>
	/// If checked and visible, gets selected item index and returns true. Else sets index=-1 and returns false.
	/// </summary>
	public bool GetIndex(out int index) {
		index = -1;
		if (!c.IsChecked || !Visible) return false;
		index = t.SelectedIndex;
		return index >= 0;
	}
	
	/// <summary>
	/// If checked and visible, gets selected item text and returns true. Else sets text=null and returns false.
	/// </summary>
	public bool GetText(out string text) {
		if (!GetIndex(out int i)) { text = null; return false; }
		text = t.Items[i] as string;
		return true;
	}
}


================================================
FILE: Au.Controls/Simple/KCheckDropdownBox.cs
================================================
using System.Windows;
using System.Windows.Controls;
using System.Windows.Controls.Primitives;
using System.Windows.Input;
using System.Numerics;

namespace Au.Controls;

/// <summary>
/// Read-only <b>TextBox</b> that shows a dropdown list of checkboxes and displays the list of checked items as its text.
/// </summary>
public class KCheckDropdownBox : TextBox {
	///
	public KCheckDropdownBox() {
		IsReadOnly = true;
		//TextWrapping = TextWrapping.Wrap;
		Cursor = Cursors.Arrow;
		AddHandler(UIElement.MouseLeftButtonUpEvent, new MouseButtonEventHandler(_MouseLeftButtonUp), handledEventsToo: true);
	}
	
	/// <summary>
	/// Checkbox names. Max 64.
	/// </summary>
	public object[] Checkboxes {
		get => _checkboxes;
		set {
			if (value?.Length > 64) throw new ArgumentException("Max 64.");
			_checkboxes = value;
			Checked = 0;
		}
	}
	object[] _checkboxes;
	
	/// <summary>
	/// Sets or gets bits that correspond to checked checkboxes.
	/// Set this property after setting <see cref="Checkboxes"/>.
	/// </summary>
	/// <exception cref="ArgumentException">The setter called before setting <see cref="Checkboxes"/>.</exception>
	public ulong Checked {
		get => _checked;
		set {
			int n = _checkboxes?.Length ?? 0;
			if (n == 0 && value != 0) throw new ArgumentException("Set Checkboxes before Checked.");
			
			_checked = value;
			
			string s = "";
			if (_checked != 0) {
				StringBuilder b = new();
				string sep = null;
				for (int i = 0; i < n; i++) {
					if (0 != (_checked & 1UL << i)) {
						b.Append(sep).Append(_checkboxes[i]);
						sep = ", ";
					}
				}
				s = b.ToString();
				if (AllText is { } s1) if (BitOperations.TrailingZeroCount(~_checked) >= n) s = string.Format(s1, s);
			}
			Text = s;
		}
	}
	ulong _checked;
	
	/// <summary>
	/// Text of "check all" checkbox, or null (default) to not add the checkbox.
	/// </summary>
	public object AllItem { get; set; }
	
	/// <summary>
	/// Control text when all checked, or null (default) to display the list.
	/// Can contain placeholder {0} for the list.
	/// </summary>
	public string AllText { get; set; }
	
	/// <summary>
	/// Used with <see cref="DropdownSettings"/>.
	/// </summary>
	/// <param name="panel">Panel that will contain checkboxes. Can be <b>WrapPanel</b>, <b>UniformGrid</b> or other simple panel type. Unsupported types: <b>Grid</b>, <b>Canvas</b>. Default: vertical <b>StackPanel</b>.</param>
	/// <param name="fixedWidth">Set the dropdown width = the control width. If false, can be wider.</param>
	/// <param name="noHScroll">Disable horizontal scrolling.</param>
	/// <param name="noVScroll">Disable vertical scrolling.</param>
	public record DDSettings(Panel panel = null, bool fixedWidth = false, bool noHScroll = false, bool noVScroll = false);
	
	/// <summary>
	/// Callback function that can provide the dropdown panel and settings. Called whenever starting to create a dropdown.
	/// </summary>
	public Func<DDSettings> DropdownSettings { get; set; }
	
	/// <summary>
	/// When dropdown initialized, before showing.
	/// </summary>
	public event Action<DropdownEventData> DropdownOpening;
	
	/// <summary>
	/// When dropdown closed.
	/// </summary>
	public event Action<DropdownEventData> DropdownClosed;
	
	/// <summary>
	/// Used with events.
	/// </summary>
	/// <param name="cb">This control.</param>
	/// <param name="popup">The dropdown window.</param>
	/// <param name="checkboxes">Array of checkboxes.</param>
	/// <param name="cancel">True when dropdown closed with <c>Esc</c> key and therefore checkbox states are ignored.</param>
	public record DropdownEventData(KCheckDropdownBox cb, Popup popup, CheckBox[] checkboxes, bool cancel);
	
	///
	protected override void OnPreviewMouseLeftButtonUp(MouseButtonEventArgs e) {
		_clickedThis = IsMouseCaptured;
		base.OnPreviewMouseLeftButtonUp(e);
	}
	
	bool _clickedThis;
	
	void _MouseLeftButtonUp(object sender, MouseButtonEventArgs e) {
		if (!_clickedThis) return;
		_clickedThis = false;
		if (SelectionLength == 0) {
			_ShowDropdown();
		}
	}
	
	void _ShowDropdown() {
		int n = _checkboxes?.Length ?? 0;
		if (n == 0) return;
		
		var ps = DropdownSettings?.Invoke() ?? new();
		
		Panel panel = ps.panel ?? new StackPanel();
		panel.Margin = new(2);
		
		var ac = new CheckBox[n];
		for (int i = 0; i < n; i++) {
			var c = new CheckBox { Content = _checkboxes[i], Margin = new(1) };
			if (0 != (_checked & 1UL << i)) c.IsChecked = true;
			panel.Children.Add(c);
			ac[i] = c;
		}
		var cFirst = ac[0];
		
		if (AllItem is { } cai) {
			cFirst = new CheckBox { Content = cai, Margin = new(1), IsChecked = BitOperations.TrailingZeroCount(~_checked) >= n };
			panel.Children.Insert(0, cFirst);
			cFirst.Checked += (_, _) => _SetAll(true);
			cFirst.Unchecked += (_, _) => _SetAll(false);
			void _SetAll(bool check) {
				foreach (var c in ac) c.IsChecked = check;
			}
		}
		
		var sv = new ScrollViewer {
			Content = panel,
			HorizontalScrollBarVisibility = ps.noHScroll ? ScrollBarVisibility.Disabled : ScrollBarVisibility.Auto,
			VerticalScrollBarVisibility = ps.noVScroll ? ScrollBarVisibility.Disabled : ScrollBarVisibility.Auto,
		};
		
		var border = new Border {
			Child = sv,
			Background = SystemColors.WindowBrush,
			BorderThickness = new(1),
			BorderBrush = SystemColors.ActiveBorderBrush,
		};
		
		_popup = new Popup { Child = border, PlacementTarget = this, StaysOpen = false };
		if (ps.fixedWidth) _popup.Width = ActualWidth; else _popup.MinWidth = ActualWidth;
		
		bool esc = false;
		_popup.Closed += (_, _) => {
			var popup = _popup;
			_popup = null;
			
			if (!esc) {
				ulong r = 0, k = 1;
				foreach (var c in ac) {
					if (c.IsChecked == true) r |= k;
					k <<= 1;
				}
				Checked = r;
			}
			
			if (popup.IsKeyboardFocusWithin) Focus();
			
			DropdownClosed?.Invoke(new(this, popup, ac, esc));
		};
		
		_popup.PreviewKeyDown += (_, e) => {
			if (e.Key == Key.Space) { //workaround for: if StaysOpen false, on Space key disappears if mouse is not in it or its PlacementTarget
				e.Handled = true;
				if (Keyboard.FocusedElement is CheckBox c) c.IsChecked = !c.IsChecked;
			} else if (e.Key is Key.Escape or Key.Enter) {
				e.Handled = true;
				esc = e.Key == Key.Escape;
				_popup.IsOpen = false;
			}
		};
		
		border.MouseLeave += (_, _) => { IsDropdownOpen = false; };
		
		DropdownOpening?.Invoke(new(this, _popup, ac, false));
		
		_popup.IsOpen = true;
		if (cFirst.IsVisible) cFirst.Focus();
	}
	Popup _popup;
	
	/// <summary>
	/// Gets whether the dropdown is open, or opens/closes it.
	/// </summary>
	public bool IsDropdownOpen {
		get => _popup != null;
		set {
			if (value) {
				if (_popup == null) _ShowDropdown();
			} else {
				if (_popup != null) _popup.IsOpen = false;
			}
		}
	}
	
	///
	protected override void OnPreviewKeyDown(KeyEventArgs e) {
		if (e.SystemKey == Key.Down) {
			IsDropdownOpen = true;
		}
		base.OnPreviewKeyDown(e);
	}
	
	///
	protected override void OnPreviewTextInput(TextCompositionEventArgs e) {
		if (IsReadOnly) IsDropdownOpen = true;
		base.OnPreviewTextInput(e);
	}
}


================================================
FILE: Au.Controls/Simple/KColorPicker.cs
================================================
using System.Windows.Interop;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Media;
using System.Windows.Shapes;

namespace Au.Controls;

/// <summary>
/// WPF control for selecting color.
/// </summary>
public class KColorPicker : UserControl {
	TextBox _tColor;
	_Palette _pal;
	bool _hlsChanging, _palSelecting;
	
	public KColorPicker() {
		StackPanel p1 = new();
		StackPanel p2 = new() { Orientation = Orientation.Horizontal, Margin = new Thickness(0, 0, 0, 3) };
		p1.Children.Add(p2);
		StackPanel p3 = new() { Orientation = Orientation.Horizontal, Margin = new Thickness(0, 0, 4, 0), Background = Brushes.White };
		p2.Children.Add(p3);
		
		TextBox tH = null, tL = null, tS = null;
		
		var fColor = new TextBlock { Text = "Color", ToolTip = "Color RRGGBB", Foreground = Brushes.Black };
		p3.Children.Add(fColor);
		
		var bColor = new Rectangle { Width = 9, Height = 9, Fill = Brushes.Black, Margin = new Thickness(4, 2, 4, 0) };
		p3.Children.Add(bColor);
		
		_tColor = new() { Width = 64, Text = "000000", ToolTip = fColor.ToolTip };
		_tColor.TextChanged += (o, e) => {
			int col = _GetColor(bgr: true);
			if (!_hlsChanging) {
				var (H, L, S) = ColorInt.ToHLS(col, bgr: true);
				_hlsChanging = true;
				if (S != 0) tH.Text = H.ToString();
				tL.Text = L.ToString();
				tS.Text = S.ToString();
				_hlsChanging = false;
			}
			
			if (!_palSelecting) _pal.SelectColor(col);
			
			var brush = new SolidColorBrush(System.Windows.Media.Color.FromRgb((byte)col, (byte)(col >> 8), (byte)(col >> 16)));
			fColor.Foreground = brush;
			bColor.Fill = brush;
			p3.Background = ColorInt.GetPerceivedBrightness(col, bgr: true) <= .8 ? Brushes.White : Brushes.DimGray;
			
			if (ColorChanged != null) {
				if (!BGR) col = ColorInt.SwapRB(col);
				ColorChanged(col);
			}
		};
		p2.Children.Add(_tColor);
		
		//hls: 0 H, 1 L, 2 S.
		TextBox _AddHLS(int hls, string label, string tooltip) {
			p2.Children.Add(new TextBlock { Text = label, Margin = new Thickness(hls == 0 ? 18 : 12, 0, 4, 0), ToolTip = tooltip });
			TextBox t = new() { Width = 34, Text = "0", ToolTip = tooltip };
			t.TextChanged += (o, e) => {
				if (_hlsChanging) return;
				var tb = o as TextBox;
				int i = tb.Text.ToInt();
				if (i < 0 || i > 240) {
					_hlsChanging = true;
					tb.Text = Math.Clamp(i, 0, 240).ToS();
					_hlsChanging = false;
				}
				
				int H = tH.Text.ToInt(), L = tL.Text.ToInt(), S = tS.Text.ToInt();
				int col = ColorInt.FromHLS(H, L, S, bgr: true);
				_hlsChanging = true;
				_SetColor(col, bgr: true);
				_hlsChanging = false;
			};
			t.MouseWheel += (o, e) => {
				int d = e.Delta / 15; //+-8
				if (o == tH) d /= 2; //hue is more sensitive; 8 would jump directly from box to box
				int i = t.Text.ToInt() + d;
				if (hls == 0) { if (i < 0) i += 240; else if (i > 240) i -= 240; }
				int v = Math.Clamp(i, 0, 240);
				t.Text = v.ToS();
			};
			p2.Children.Add(t);
			return t;
		}
		
		tH = _AddHLS(0, "H", "Hue 0-240. Change with mouse wheel.");
		tL = _AddHLS(1, "L", "Luminance 0-240. Change with mouse wheel.");
		tS = _AddHLS(2, "S", "Saturation 0-240. Change with mouse wheel.");
		
		_pal = new _Palette(this);
		p1.Children.Add(_pal);
		
		base.Content = p1;
	}
	
	class _Palette : HwndHost {
		KColorPicker _cp;
		wnd _w;
		int _dpi;
		int _cellSize;
		const int c_nHue = 30; //number of hue columns. Must be 240-divisible.
		const int c_nLum = 7; //number of luminance rows. Must be 240-divisible minus 1.
		
		public wnd Hwnd => _w;
		
		public _Palette(KColorPicker cp) {
			_cp = cp;
		}
		
		protected override HandleRef BuildWindowCore(HandleRef hwndParent) {
			var wParent = (wnd)hwndParent.Handle;
			_w = WndUtil.CreateWindow(_wndProc = _WndProc, false, "Static", null, WS.CHILD | WS.CLIPCHILDREN, 0, 0, 0, 10, 10, wParent);
			
			return new HandleRef(this, _w.Handle);
		}
		
		protected override void DestroyWindowCore(HandleRef hwnd) {
			Api.DestroyWindow(_w);
		}
		
		protected override Size MeasureOverride(Size constraint) => _Measure();
		
		WNDPROC _wndProc;
		nint _WndProc(wnd w, int msg, nint wParam, nint lParam) {
			//var pmo = new PrintMsgOptions(Api.WM_NCHITTEST, Api.WM_SETCURSOR, Api.WM_MOUSEMOVE, Api.WM_NCMOUSEMOVE, 0x10c1);
			//if (WndUtil.PrintMsg(out string s, _w, msg, wParam, lParam, pmo)) print.it("<><c green>" + s + "<>");
			
			switch (msg) {
			case Api.WM_NCDESTROY:
				_w = default;
				break;
			//case Api.WM_NCHITTEST: //never mind: if in Popup, probably click closes. Currently not using in popups.
			//	return Api.HTTRANSPARENT;
			case Api.WM_LBUTTONDOWN:
				_WmLbuttondown(lParam);
				break;
			case Api.WM_PAINT:
				using (var bp = new BufferedPaint(w, true)) _Paint(bp.DC);
				return default;
			}
			
			return Api.DefWindowProc(w, msg, wParam, lParam);
		}
		
		Size _Measure() {
			_dpi = Dpi.OfWindow(_w);
			int i = _cellSize = Dpi.Scale(10, _dpi);
			var z = new SIZE(i, i);
			z.width *= c_nHue; z.width++;
			z.height *= c_nLum + 1; z.height++; z.height += _cellSize / 4;
			return Dpi.Unscale(z, _dpi);
		}
		
		void _Paint(nint dc) {
			using var g = System.Drawing.Graphics.FromHdc(dc);
			using var penSel = new System.Drawing.Pen(System.Drawing.Color.Black) { DashStyle = System.Drawing.Drawing2D.DashStyle.Dot };
			g.Clear(System.Drawing.Color.White);
			
			var z = _cellSize;
			
			//colors. Hue in x axis, luminance in y axis.
			int y = 0;
			for (int i = 0, lum = 240; (lum -= 240 / (c_nLum + 1)) > 0; i++) {
				for (int j = 0, hue = 0; hue < 240; j++, hue += 240 / c_nHue) {
					_Draw(s_ac[j, i], j * z);
				}
				y += z;
			}
			
			//black...white
			y += _cellSize / 4;
			for (int j = 0, gray = 0; j < c_nHue; j++, gray += gray < 120 ? 10 : 8) {
				_Draw(s_ac[j, c_nLum], j * z);
			}
			
			//selection
			y = _select.lum * z; if (_select.lum == c_nLum) y += _cellSize / 4;
			g.DrawRectangle(penSel, _select.hue * z, y, z, z);
			
			void _Draw(int col, int x) {
				RECT r = (x + 1, y + 1, z - 1, z - 1);
				var brush = Api.CreateSolidBrush(col);
				Api.FillRect(dc, r, brush);
				Api.DeleteObject(brush);
			}
		}
		
		static int[,] _GenerateColors() {
			int[,] a = new int[c_nHue, c_nLum + 1];
			for (int i = 0, lum = 240; (lum -= 240 / (c_nLum + 1)) > 0; i++) {
				for (int j = 0, hue = 0; hue < 240; j++, hue += 240 / c_nHue) {
					//var col=_ColorHLSToRGB(hue, lum, 240);
					
					int lum2 = lum;
					if (lum >= 120) {
						int d = Math.Abs(80 - hue); //diff from green
						if (d <= 64) {
							d /= 4;
							//if(lum==120) print.it(Math.Max(d, 10), (240-lum)/Math.Max(d, 10));
							lum2 -= (240 - lum) / Math.Max(d, 8);
						}
					}
					var col = ColorInt.FromHLS(hue, lum2, 240, bgr: true);
					
					a[j, i] = col;
					
					//if(lum==120 /*&& hue<=180*/) {
					//	ColorInt k=ColorInt.FromBGR(col, true);
					//	var b=k.GetPerceivedBrightness();
					//	print.it(col.ToString("X6"), hue, lum, b);
					//}
				}
			}
			
			//black...white
			for (int j = 0, gray = 0; j < c_nHue; j++, gray += gray < 120 ? 10 : 8) {
				//print.it(gray);
				if (gray > 255) gray = 255;
				var col = (gray << 16) | (gray << 8) | gray;
				a[j, c_nLum] = col;
			}
			
			return a;
		}
		
		static readonly int[,] s_ac = _GenerateColors();
		
		(int hue, int lum) _select = (0, c_nLum);
		
		//public int SelectedColor => _ac[_select.hue, _select.lum];
		
		//public bool SelectedGray => _select.lum==c_nLum;
		
		public void SelectColor(int col) {
			//print.it((uint)col);
			var (H, L, S) = ColorInt.ToHLS(col, bgr: true);
			if (S == 0) { //gray
				int lum = L * 255 / 240;
				for (int j = 0; j < c_nHue; j++) {
					int gray = s_ac[j, c_nLum] & 255;
					if (gray >= lum) { _select = (j, c_nLum); break; }
				}
			} else {
				const int nLum = c_nLum + 1, hueStep = 240 / c_nHue, lumStep = 240 / nLum;
				double dif = 1000000;
				for (int hue = 0; hue < 240; hue += hueStep) {
					for (int lum = 240; (lum -= lumStep) > 0;) {
						int dH = hue - H, dL = lum - L;
						double d = Math.Sqrt(dH * dH + dL * dL);
						if (d < dif) { dif = d; _select = (hue / hueStep, c_nLum - lum / lumStep); }
					}
				}
			}
			Invalidate();
		}
		
		void _WmLbuttondown(nint xy) {
			var (x, y) = Math2.NintToPOINT(xy);
			x--; x /= _cellSize;
			y--; y /= _cellSize;
			x = Math.Clamp(x, 0, c_nHue - 1);
			y = Math.Clamp(y, 0, c_nLum);
			_select = (x, y);
			_cp._palSelecting = true;
			int col = s_ac[x, y];
			_cp._SetColor(col, bgr: true);
			_cp._palSelecting = false;
			Invalidate();
		}
		
		public unsafe void Invalidate() {
			var w = Hwnd;
			if (w.IsVisible) Api.InvalidateRect(w, null, false);
		}
	}
	
	void _SetColor(int color, bool bgr) {
		if (bgr) color = ColorInt.SwapRB(color);
		var s = color.ToS("X6");
		_tColor.Text = s;
	}
	
	int _GetColor(bool bgr) {
		var s = _tColor.Text;
		int col = s.ToInt(s.Starts('#') ? 1 : (s.Starts("0x") ? 2 : 0), STIFlags.IsHexWithout0x);
		if (bgr) col = ColorInt.SwapRB(col);
		return col;
	}
	
	/// <summary>
	/// With public functions and events use color format 0xBBGGRR. If false (default), uses 0xRRGGBB.
	/// </summary>
	public bool BGR { get; set; }
	
	public int Color {
		get => _GetColor(BGR);
		set => _SetColor(value, BGR);
	}
	
	public event Action<int> ColorChanged;
	
	public static void ColorTool(Action<string> result, Window owner, bool modal, bool add0xRgbButton, bool addBgrButton) {
		var w = new KDialogWindow { Title = "Color", ShowInTaskbar = owner == null, Owner = owner };
		var b = new wpfBuilder(w);
		w.ResizeMode = ResizeMode.NoResize;
		b.R.Add(out KColorPicker palette);
		b.R.StartGrid().Columns(-1, -1, -1);
		b.R.AddButton("#RRGGBB", _ => _Result($"#{palette.Color:X6}")).Span(1);
		if (add0xRgbButton) b.AddButton("0xRRGGBB", _ => _Result($"0x{palette.Color:X6}")).Span(1);
		if (addBgrButton) b.AddButton("0xBBGGRR", _ => _Result($"0x{ColorInt.SwapRB(palette.Color):X6}"));
		b.End();
		b.R.Add("Color name", out _ComboBox cbNamed).Brush(Brushes.White);
		b.End();
		
		List<(string name, ColorInt c, int H)> aNamed = new();
		//cbNamed.MaxDropDownHeight = 1000;
		cbNamed.DropDownOpened += _cbNet_DropDownOpened;
		void _cbNet_DropDownOpened(object sender, EventArgs e) {
			cbNamed.DropDownOpened -= _cbNet_DropDownOpened;
			
			foreach (var mi in typeof(Colors).GetProperties()) {
				if (mi.GetValue(0) is Color co) {
					var name = mi.Name;
					if (name == "Transparent") continue;
					var ci = (ColorInt)co;
					var (H, L, S) = ColorInt.ToHLS(ci.argb, false);
					if (S < 50) H = L - 1000;
					else H = (H + 240 - 43) % 240;
					aNamed.Add((name, ci, H));
				}
			}
			aNamed.Sort((x, y) => x.H - y.H);
			var darkBrush = new SolidColorBrush(System.Windows.Media.Color.FromRgb(64, 64, 64));
			for (int i = 0; i < aNamed.Count; i++) {
				var name = aNamed[i].name;
				var ci = aNamed[i].c;
				var brush = new SolidColorBrush((Color)ci);
				var k = new StackPanel { Orientation = Orientation.Horizontal };
				k.Children.Add(new Rectangle { Fill = brush, Stroke = Brushes.White, Width = 16, StrokeThickness = 3 });
				k.Children.Add(new TextBlock { Text = "Text", Foreground = brush, Background = Brushes.White, Padding = new(0, 0, 3, 0) });
				k.Children.Add(new TextBlock { Text = "Text", Foreground = brush, Background = darkBrush, Padding = new(3, 0, 3, 0) });
				k.Children.Add(new TextBlock { Text = name, Padding = new(3, 0, 3, 0) });
				cbNamed.Items.Add(k);
			}
			cbNamed.SelectionChanged += (_, e) => { if (cbNamed.SelectedIndex is int i && i >= 0) _Result(aNamed[i].name); };
		}
		
		if (modal) w.ShowDialog(); else w.Show();
		
		void _Result(string color) {
			result(color);
			w.Close();
		}
	}
	
	class _ComboBox : ComboBox {
		public _ComboBox() {
			//workaround for the ComboBox slowness
			ItemsPanel = new ItemsPanelTemplate();
			var stackPanelTemplate = new FrameworkElementFactory(typeof(VirtualizingStackPanel));
			ItemsPanel.VisualTree = stackPanelTemplate;
		}
		
		//public override void OnApplyTemplate() {
		//	base.OnApplyTemplate();
		//	if (Template.FindName("PART_Popup", this) is Popup p) p.PopupAnimation = PopupAnimation.None;
		//}
	}
}


================================================
FILE: Au.Controls/Simple/KDateTime.cs
================================================
using System.Windows;
using System.Windows.Controls;
using System.Windows.Controls.Primitives;
using System.Windows.Input;
using System.Windows.Media;
using CalendarControl = System.Windows.Controls.Calendar;

namespace Au.Controls;

/// <summary>
/// Text box for editing date and time.
/// </summary>
public class KDateTime : TextBox {
	const string c_format = "yyyy-MM-dd HH:mm:ss";
	
	///
	public KDateTime() {
		AddHandler(UIElement.MouseLeftButtonUpEvent, new MouseButtonEventHandler(_MouseLeftButtonUp), handledEventsToo: true);
	}
	
	/// <summary>
	/// <b>Text</b> as <b>DateTime</b>.
	/// </summary>
	/// <value>
	/// Setter sets control text, or clears if null.
	/// Getter returns control text converted to <b>DateTime</b>, or null if fails to convert.
	/// Use <see cref="wpfBuilder.Validation"/> with <see cref="Validation"/> to ensure that <b>Text</b> is valid date-time.
	/// </value>
	public DateTime? Value {
		get => _ParseDate(Text, out var d) ? d : null;
		set { Text = value?.ToString(c_format); }
	}
	
	/// <summary>
	/// Validation function for <see cref="wpfBuilder.Validation"/>.
	/// </summary>
	public static string Validation(FrameworkElement e) => ((KDateTime)e)._Validation();
	
	string _Validation() {
		if (IsEnabled && Visibility == Visibility.Visible) {
			string s = Text;
			if (s.Length == 0) return "Date/time empty";
			if (!_ParseDate(s, out var d)) return "Date/time invalid";
			if (d.Year < ValidationFirstYear) return "Min year " + ValidationFirstYear;
			if (ValidationDateMustBeAfter?.Invoke() is DateTime d2 && d <= d2) return "Must be > " + d2.ToString(c_format);
		}
		return null;
	}
	
	/// <summary>
	/// Validation fails if the control's year is less than this value.
	/// Default 1602. Note: if less than 1601-01-02, user code may not work because can't convert to FILETIME.
	/// </summary>
	public int ValidationFirstYear { get; set; } = 1602;
	
	/// <summary>
	/// Validation fails if the control's date isn't after that of returned by the callback function (if returns not null).
	/// </summary>
	public Func<DateTime?> ValidationDateMustBeAfter { get; set; }
	
	/// <summary>
	/// Selects and spins field from mouse.
	/// </summary>
	protected override void OnMouseWheel(MouseWheelEventArgs e) {
		int pos = _MouseCharPos(e, false);
		if (pos >= 0) {
			int add = e.Delta > 0 ? 1 : -1;
			var mod = Keyboard.Modifiers;
			if (mod is 0 or ModifierKeys.Control) {
				if (mod == ModifierKeys.Control) add *= 10;
				_FieldUpDown(pos, add);
				Focus();
				base.Cursor = Cursors.None;
				e.Handled = true;
			}
		}
		base.OnMouseWheel(e);
	}

	///
	protected override void OnMouseMove(MouseEventArgs e) {
		if (base.Cursor == Cursors.None) base.Cursor = null;
		base.OnMouseMove(e);
	}
	
	///
	protected override void OnPreviewMouseLeftButtonUp(MouseButtonEventArgs e) {
		_clickedThis = IsMouseCaptured;
		base.OnPreviewMouseLeftButtonUp(e);
	}
	
	bool _clickedThis;
	
	void _MouseLeftButtonUp(object sender, MouseButtonEventArgs e) {
		if (!_clickedThis) return;
		_clickedThis = false;
		if (SelectionLength == 0 && _PartFromPos(Text, _MouseCharPos(e, true), out int part, out var m)) {
			base.Select(m[part].Start, m[part].Length);
			if (part <= 3) _ShowCalendar(part, false);
		}
	}
	
	void _ShowCalendar(int part, bool focusCalendar) {
		if (!_ParseDate(Text, out var dt)) return;
		
		var cis = new Style(typeof(CalendarItem));
		cis.Setters.Add(new Setter(FrameworkElement.MarginProperty, new Thickness(0)));
		
		var c = new CalendarControl {
			CalendarItemStyle = cis,
			Language = System.Windows.Markup.XmlLanguage.GetLanguage(CultureInfo.InstalledUICulture.IetfLanguageTag),
			DisplayMode = part switch { 1 => CalendarMode.Decade, 2 => CalendarMode.Year, _ => CalendarMode.Month },
			DisplayDate = dt,
		};
		//var v = new Viewbox { Child = c, Width = 220,  }; //make font bigger. But then blurred.
		
		_calendarPopup = new Popup() { Child = c, PlacementTarget = this, StaysOpen = false };
		
		_calendarPopup.Closed += (_, _) => {
			if (_calendarPopup.IsKeyboardFocusWithin) Focus();
			_calendarPopup = null;
		};
		
		_calendarPopup.IsOpen = true;
		
		if (_calendarPopup != null) {
			if (focusCalendar) c.Focus();
			
			c.PreviewMouseLeftButtonUp += (sender, e) => {
				if (c.DisplayMode == CalendarMode.Month && e.OriginalSource is UIElement k && k.FindVisualAncestor<CalendarDayButton>(true, sender, false) is { } cdb) {
					_CloseCalendar(c);
				}
			};
			
			c.PreviewKeyDown += (_, e) => {
				if (e.Key is Key.Enter && c.DisplayMode == CalendarMode.Month) e.Handled = _CloseCalendar(c);
				if (e.Key is Key.Escape) e.Handled = _CloseCalendar();
			};
			
			_calendarPopup.PreviewMouseWheel += (_, e) => {
				if (!c.RectInScreen().Contains(mouse.xy)) _calendarPopup.IsOpen = false;
			};
		}
	}
	
	Popup _calendarPopup;
	
	bool _CloseCalendar(CalendarControl c = null) {
		bool r = _calendarPopup?.IsOpen == true;
		if (r) {
			if (c != null) {
				var d = c.SelectedDate ?? c.DisplayDate;
				var s = Text;
				if (_ParseRX(s, out var m)) {
					Text = d.ToString("yyyy-MM-dd") + s[m[3].End..];
					Select(m[4].Start, m[4].Length);
				}
			}
			_calendarPopup.IsOpen = false;
		}
		return r;
	}
	
	/// <summary>
	/// Selects adjacent field on Left/Right/space. Spins current field on Up/Down. Opens calendar on Alt+Down. Closes calendar.
	/// </summary>
	protected override void OnPreviewKeyDown(KeyEventArgs e) {
		e.Handled = _CloseCalendar() && e.Key is Key.Escape or Key.Enter;
		
		if (e.Key is Key.Left or Key.Right or Key.Down or Key.Up) {
			var mod = Keyboard.Modifiers;
			if (mod is 0 or ModifierKeys.Control) {
				var s = Text;
				int pos = CaretIndex;
				if (_PartFromPos(s, pos, out int part, out var m)) {
					if (e.Key is Key.Left or Key.Right) {
						part += e.Key == Key.Right ? 1 : -1;
						if (part == 0) part = 6; else if (part == 7) part = 1;
						base.Select(m[part].Start, m[part].Length);
					} else {
						int add = e.Key is Key.Up ? 1 : -1;
						if (mod == ModifierKeys.Control) add *= 10;
						_FieldUpDown(pos, add);
					}
					e.Handled = true;
				}
			}
		} else if (e.Key is Key.Space) { //no OnPreviewTextInput
			e.Handled = _OnPreviewTextInput(' ');
		} else if (e.SystemKey == Key.Down) {
			e.Handled = true;
			if (_PartFromPos(Text, CaretIndex, out int part, out var m)) {
				if (part <= 3) {
					base.Select(m[part].Start, m[part].Length);
					_ShowCalendar(part, true);
				}
			}
		}
		
		if (!e.Handled) base.OnPreviewKeyDown(e);
	}
	
	/// <summary>
	/// Limits the number of digits in current field. Selects adjacent field on -/:. Blocks other characters.
	/// </summary>
	protected override void OnPreviewTextInput(TextCompositionEventArgs e) {
		if (e.Text is [(>= '0' and <= '9') or '-' or ':' or ' '] s) e.Handled = _OnPreviewTextInput(s[0]);
		else e.Handled = true;
		base.OnPreviewTextInput(e);
	}
	
	bool _OnPreviewTextInput(char c) {
		int pos = CaretIndex;
		if (_PartFromPos(Text, pos, out int part, out var m)) {
			if (c is >= '0' and <= '9') {
				int k = part == 1 ? 4 : 2;
				if (m[part].Length == k && SelectionLength == 0) {
					Select(m[part].Start, m[part].Length);
				}
			} else {
				if (++part < 7) Select(m[part].Start, m[part].Length);
				return true;
			}
		}
		return false;
	}
	
	void _FieldUpDown(int pos, int add) {
		var s = Text;
		if (!_PartFromPos(s, pos, out int part, out _)) return;
		if (!_ParseDate(s, out var d)) return;
		try {
			switch (part) {
			case 1: d = d.AddYears(add); break;
			case 2: d = d.AddMonths(add); break;
			case 3: d = d.AddDays(add); break;
			case 4: d = d.AddHours(add); break;
			case 5: d = d.AddMinutes(add); break;
			case 6: d = d.Add(TimeSpan.FromSeconds(add)); break;
			}
			Text = s = d.ToString(c_format);
			if (_ParseRX(s, out var m)) {
				base.Select(m[part].Start, m[part].Length);
			}
		}
		catch { }
	}
	
	bool _ParseRX(string s, out RXMatch m) {
		_rx ??= new(@"^(\d{0,4})-(\d{0,2})-(\d{0,2}) +(\d{0,2}):(\d{0,2}):(\d{0,2})$");
		return _rx.Match(s, out m);
	}
	regexp _rx;
	
	bool _PartFromPos(string s, int pos, out int part, out RXMatch m) {
		if (!_ParseRX(s, out m)) { part = 0; return false; }
		part = 6; while (part > 0 && !(pos >= m[part].Start && pos <= m[part].End)) part--;
		return part > 0;
	}
	
	static bool _ParseDate(string s, out DateTime d) {
		return DateTime.TryParseExact(s, "yyyy-M-d H:m:s", null, DateTimeStyles.None, out d);
	}
	
	int _MouseCharPos(MouseEventArgs e, bool snapToText) => base.GetCharacterIndexFromPoint(e.GetPosition(this), snapToText);
}


================================================
FILE: Au.Controls/Simple/KDialogWindow.cs
================================================
using System.Windows;

namespace Au.Controls;

/// <summary>
/// Can be used as base class for WPF windows used as dialogs.
/// Adds WS_POPUP style, which prevents activating an unrelated window when closing this active owned nonmodal window (OS bug).
/// Also adds functions <see cref="ShowSingle"/>, <see cref="ShowAndWait"/>.
/// </summary>
public class KDialogWindow : Window {
	/// <summary>
	/// Shows window of type T (the caller's class) and ensures that there is single window of that type at a time. 
	/// If a window of type T already exists (created with this function), activates it. Else calls <i>fNew</i> and <b>Show</b>. Will use <b>OnClose</b> to forget that window.
	/// Not thread-safe.
	/// Example: <c>ShowSingle(() => new DThisClass());</c>
	/// </summary>
	/// <param name="fNew">Called to create new T if there is no T window.</param>
	protected static T ShowSingle<T>(Func<T> fNew) where T : KDialogWindow {
		Debug_.PrintIf(!process.IsLaMainThread_);

		if (s_single.Find(o => o is T) is {  } d) {
			d.Hwnd().ActivateL(true);
		} else {
			s_single.Add(d = fNew());
			d.Show();
		}
		return d as T;
	}
	static List<KDialogWindow> s_single = new();
	
	protected override void OnClosed(EventArgs e) {
		s_single.Remove(this);
		base.OnClosed(e);
	}
	
	/// <summary>
	/// If a window of type T already exists (created with <see cref="ShowSingle"/>), gets it and returns true, else returns false.
	/// </summary>
	public static bool GetSingle<T>(out T window) where T : KDialogWindow
		=> null != (window = s_single.OfType<T>().FirstOrDefault());
	
	/// <summary>
	/// Sets <b>Title</b>, <b>Owner</b>, <b>ShowInTaskbar</b>.
	/// </summary>
	/// <param name="owner">Window or element or null.</param>
	public void InitWinProp(string title, DependencyObject owner, bool showInTaskbar = false) {
		Title = title;
		if (owner != null) Owner = owner as Window ?? GetWindow(owner);
		ShowInTaskbar = showInTaskbar;
	}
	
	protected override void OnSourceInitialized(EventArgs e) {
		var w = this.Hwnd();
		w.SetStyle(WS.POPUP, WSFlags.Add);
		if (process.IsLaProcess_ && !process.IsLaMainThread_) w.Prop.Set("close me on exit", 1);
		base.OnSourceInitialized(e);
	}
	
	/// <summary>
	/// Sets <b>Owner</b> and calls <b>ShowDialog</b> without disabling thread windows.
	/// </summary>
	/// <returns>True if clicked OK (<b>DialogResult</b> true).</returns>
	/// <param name="owner">If not null, sets <b>Owner</b>.</param>
	/// <param name="hideOwner">Temporarily hide owner.</param>
	/// <param name="disableOwner">Temporarily disable owner.</param>
	public bool ShowAndWait(Window owner = null, bool hideOwner = false, bool disableOwner = false) {
		if (owner != null) Owner = owner; else hideOwner = disableOwner = false;
		wnd ow = hideOwner || disableOwner ? Owner.Hwnd() : default;
		if (hideOwner) ow.ShowL(false); //not owner.Hide(), it closes owner if it is modal
		if (disableOwner) {
			ow.Enable(false);
			Closing += (_, e) => { if (!e.Cancel) ow.Enable(true); }; //the best time to enable. Later would activate wrong window.
		}
		
		//To prevent disabling thread windows, temporarily disable all visible enabled thread windows.
		//	See WPF code in Window.cs functions EnableThreadWindows, ThreadWindowsCallback, ShowDialog.
		//	Disabling/enabing a window is fast and does not send messages to it, even wm_stylechanging/ed.
		//	Another way: Show and Dispatcher.PushFrame. Problem: does not set DialogResult. How to know how the dialog was closed?
		bool reenable = false;
		var tw = wnd.getwnd.threadWindows(process.thisThreadId, onlyVisible: true);
		for (int i = 0; i < tw.Length; i++) { if (tw[i].IsEnabled()) { reenable = true; tw[i].Enable(false); } else tw[i] = default; }
		RoutedEventHandler eh = null; //would be less code with Dispatcher.InvokeAsync or timer, but unreliable, eg can be too soon or interfere with another dialog
		if (reenable) Loaded += eh = (_, _) => {
			eh = null;
			foreach (var v in tw) if (!v.Is0) v.Enable(true);
		};
		
		if (owner == null && ShowActivated && !wnd.active.IsOfThisProcess) {
			Loaded += (_, _) => this.Hwnd().ActivateL();
		}
		
		try { return ShowDialog() == true; }
		finally {
			eh?.Invoke(null, null); //if failed to load
			if (hideOwner) { ow.ShowL(true); ow.ActivateL(); }
		}
	}
}


================================================
FILE: Au.Controls/Simple/KGroupBox.cs
================================================
using System.Windows;
using System.Windows.Controls;
using System.Windows.Media;

namespace Au.Controls;

/// <summary>
/// Makes the GroupBox more vivid.
/// </summary>
public class KGroupBox : GroupBox {
	protected private readonly bool _no;
	
	public KGroupBox() {
		if (_no = SystemParameters.HighContrast) return;
		BorderBrush = SystemColors.ActiveBorderBrush; //default is almost invisible
	}
	
	protected override void OnHeaderChanged(object oldHeader, object newHeader) {
		if (newHeader is string s && !_no) {
			if (oldHeader is null) {
				Header = new TextBlock { Text = s, FontWeight = FontWeights.Bold };
				return;
			} else if (oldHeader is TextBlock t) {
				t.Text = s;
				Header = t;
				return;
			}
		}
		base.OnHeaderChanged(oldHeader, newHeader);
	}
}

/// <summary>
/// Makes the GroupBox look like separator with label.
/// </summary>
public class KGroupBoxSeparator : KGroupBox {
	public KGroupBoxSeparator() {
		if (_no) return; //WPF draws badly
		BorderThickness = new(0, 1, 0, 0);
		Padding = new(-6, 0, -6, -6);
	}
}


================================================
FILE: Au.Controls/Simple/KHotkeyControl.cs
================================================
using System.Windows;
using System.Windows.Documents;
using System.Windows.Controls;

namespace Au.Controls;

public class KHotkeyControl : UserControl {
	TextBox _tHotkey;
	CheckBox _cCtrl, _cShift, _cAlt, _cWin;
	WindowsHook _hook;
	KKey _key;
	bool _noEvents;
	bool _forTrigger, _onlyMod;
	
	public KHotkeyControl(bool forTrigger = false, bool onlyMod = false) {
		_forTrigger = forTrigger;
		_onlyMod = onlyMod;
		
		var b = new wpfBuilder(this);
		if (_onlyMod) b.Columns(0, 0, 0, 0, -1); else if (_forTrigger) b.Columns(-1, 0, 0, 0, 0); else b.Columns(-1);
		b.Options(margin: _forTrigger || _onlyMod ? new(0, 0, 10, 0) : new());
		
		if (!_onlyMod) {
			b.R.Add<AdornerDecorator>().Child().Add(out _tHotkey).Readonly(caretVisible: true)
				.Watermark("Hotkey")
				.Tooltip("Focus this field and press a key with any combination of Ctrl, Shift, Alt, Win");
		}
		
		if (_forTrigger || _onlyMod) {
			b.Add(out _cCtrl, "Ctrl").Add(out _cShift, "Shift").Add(out _cAlt, "Alt").Add(out _cWin, "Win");
			foreach (var c in b.Panel.Children.OfType<CheckBox>()) (c.IsThreeState, c.IsEnabled) = (_forTrigger, _onlyMod);
			RoutedEventHandler modCheck = (_, _) => {
				if (_noEvents) return;
				KMod mod = 0, modAny = 0;
				_Mod(KMod.Ctrl, _cCtrl);
				_Mod(KMod.Shift, _cShift);
				_Mod(KMod.Alt, _cAlt);
				_Mod(KMod.Win, _cWin);
				_Format(mod, modAny);
				Changed?.Invoke(default);
				
				void _Mod(KMod m, CheckBox cb) {
					bool? c = cb.IsChecked;
					if (c != false) { mod |= m; if (c == null) modAny |= m; }
				}
			};
			_cCtrl.Checked += modCheck;
			_cCtrl.Unchecked += modCheck;
			_cCtrl.Indeterminate += modCheck;
			_cShift.Checked += modCheck;
			_cShift.Unchecked += modCheck;
			_cShift.Indeterminate += modCheck;
			_cAlt.Checked += modCheck;
			_cAlt.Unchecked += modCheck;
			_cAlt.Indeterminate += modCheck;
			_cWin.Checked += modCheck;
			_cWin.Unchecked += modCheck;
			_cWin.Indeterminate += modCheck;
		}
		
		if (!_onlyMod) {
			_tHotkey.GotKeyboardFocus += (_, _) => {
				WindowsHook.DontRestoreKeyboardHooks_ = true;
				
				_hook = WindowsHook.Keyboard(k => {
					if (k.IsUp) return;
					KMod mod = 0;
					if (k.Mod == 0) {
						_key = k.Key;
						mod = keys.getMod();
						if (!(_key is KKey.CapsLock or KKey.NumLock or KKey.ScrollLock)) k.BlockEvent();
					} else {
						if (_key == 0) return;
						_key = 0;
					}
					
					if (_forTrigger) {
						_noEvents = true;
						_cCtrl.IsChecked = mod.Has(KMod.Ctrl);
						_cShift.IsChecked = mod.Has(KMod.Shift);
						_cAlt.IsChecked = mod.Has(KMod.Alt);
						_cWin.IsChecked = mod.Has(KMod.Win);
						_noEvents = false;
						bool en = _key != 0;
						_cCtrl.IsEnabled = en;
						_cShift.IsEnabled = en;
						_cAlt.IsEnabled = en;
						_cWin.IsEnabled = en;
					}
					
					_Format(mod);
					Changed?.Invoke(k);
				});
			};
			
			_tHotkey.LostKeyboardFocus += (_, _) => {
				if (_hook != null) {
					_hook.Dispose();
					_hook = null;
					WindowsHook.DontRestoreKeyboardHooks_ = false;
				}
			};
		}
	}
	
	void _Format(KMod mod, KMod modAny = 0) {
		if (_onlyMod ? mod != 0 : _key != 0) {
			StringBuilder b = new();
			if (modAny == (KMod)15) {
				b.Append("?+");
			} else {
				_Mod(KMod.Ctrl);
				_Mod(KMod.Shift);
				_Mod(KMod.Alt);
				_Mod(KMod.Win);
				
				void _Mod(KMod m) {
					if (!mod.Has(m)) return;
					b.Append(m);
					if (modAny.Has(m)) b.Append('?');
					b.Append('+');
				}
			}
			if (_onlyMod) b.Remove(b.Length - 1, 1); else b.Append(_key);
			Result = b.ToString();
			if (!_onlyMod) {
				_tHotkey.Text = Result;
				_tHotkey.CaretIndex = Result.Length;
			}
		} else {
			Result = null;
			_tHotkey?.Clear();
		}
	}
	
	/// <summary>
	/// Returns the hotkey string or null.
	/// </summary>
	public string Result { get; private set; }
	
	/// <summary>
	/// Hotkey changed.
	/// The parameter is null if checked/unchecked a checkbox.
	/// </summary>
	public event Action<HookData.Keyboard?> Changed;
	
	///
	public new void Focus() {
		_tHotkey?.Focus();
	}
}


================================================
FILE: Au.Controls/Simple/KListBoxItemWithImage.cs
================================================
using System.Windows;
using System.Windows.Controls;

namespace Au.Controls;

public class KListBoxItemWithImage : ListBoxItem {
	readonly TextBlock _tb;
	
	/// <param name="image">String for <see cref="ImageUtil.LoadWpfImageElement"/> or <see cref="FrameworkElement"/> or null.</param>
	/// <param name="text"></param>
	/// <param name="imageMarginTB">Image's top and bottom margins.</param>
	public KListBoxItemWithImage(object image, string text, int imageMarginTB = 0) {
		(var p, _, _tb) = CreateContent(image, text, imageMarginTB);
		Content = p;
	}
	
	public void SetText(string text) {
		_tb.Text = text;
	}
	
	public void SetText(string text, string tooltip) {
		_tb.Text = text;
		ToolTip = tooltip;
	}
	
	public override string ToString() => _tb.Text;
	
	public static (StackPanel panel, FrameworkElement image, TextBlock text) CreateContent(object image, string text, int imageMarginTB) {
		var p = new StackPanel { Orientation = Orientation.Horizontal };
		
		var im = image as FrameworkElement;
		if (im == null && image is string s) try { im = ImageUtil.LoadWpfImageElement(s); } catch {  }
		if (im != null) {
			im.Margin = new(0, imageMarginTB, 4, imageMarginTB);
			p.Children.Add(im);
		}
		
		var tb = new TextBlock { Text = text };
		p.Children.Add(tb);
		return (p, im, tb);
	}
}

//not used
//public class KComboBoxItemWithImage : ComboBoxItem {
//	readonly TextBlock _tb;

//	/// <param name="image">String for <see cref="ImageUtil.LoadWpfImageElement"/> or <see cref="ImageSource"/> or null.</param>
//	/// <param name="text"></param>
//	public KComboBoxItemWithImage(object image, string text) {
//		(var p, _, _tb) = KListBoxItemWithImage.CreateContent(image, text);
//		Content = p;
//	}

//	public override string ToString() => _tb.Text;
//}


================================================
FILE: Au.Controls/Simple/KPasswordBox.cs
================================================
using System.Windows;
using System.Windows.Controls;
using System.Windows.Controls.Primitives;

namespace Au.Controls;

/// <summary>
/// <c>PasswordBox</c> box with a toggle button "Environment variable" that turns it into <c>TextBox</c>.
/// </summary>
class KPasswordBox : UserControl {
	DockPanel _dp;
	TextBox _tb;
	PasswordBox _pb;
	ToggleButton _toggle;
	
	public KPasswordBox() {
		Thickness pad = new(2, 1, 2, 2);
		_tb = new() { Padding = pad };
		_pb = new() { Padding = pad };
		_toggle = new() { Content = ImageUtil.LoadWpfImageElement("*Material.Variable #404040 @12"), ToolTip = "Environment variable" };
		//DockPanel.SetDock(_toggle, Dock.Left);
		_dp = new();
		_dp.Children.Add(_toggle);
		_dp.Children.Add(_pb);
		base.Content = _dp;
		
		_toggle.Checked += (_, _) => {
			_dp.Children.Remove(_pb);
			_dp.Children.Add(_tb);
			_tb.Text = _pb.Password;
			_tb.SelectAll();
			if (_toggle.IsFocused) _tb.Focus();
		};
		_toggle.Unchecked += (_, _) => {
			_dp.Children.Remove(_tb);
			_dp.Children.Add(_pb);
			_pb.Password = _tb.Text;
			_pb.SelectAll();
			if (_toggle.IsFocused) _pb.Focus();
		};
	}
	
	/// <summary>
	/// Gets or sets the state of the "Environment variable" toggle button and the type of the text field (<c>TextBox</c> if <c>true</c>, else <c>PasswordBox</c>). Default <c>false</c>.
	/// </summary>
	public bool IsEnvVar {
		get => _toggle.IsChecked == true;
		set { _toggle.IsChecked = value; }
	}
	
	/// <summary>
	/// Gets or sets the password or environment variable (if <see cref="IsEnvVar"/> <c>true</c>).
	/// </summary>
	public string Text {
		get => IsEnvVar ? _tb.Text : _pb.Password;
		set { if (IsEnvVar) _tb.Text = value; else _pb.Password = value; }
	}
	
	public TextBox TheTextBox => _tb;
	
	public PasswordBox ThePasswordBox => _pb;
}


================================================
FILE: Au.Controls/Simple/KPopup.cs
================================================
using System.Windows.Interop;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;

namespace Au.Controls;

/// <summary>
/// HwndSource-based window to use for various temporary tool/info popup windows.
/// For example, in editor used for code info windows (completion list, parameters, "Regex" etc) and for some tooltips.
/// Unlike Window and Popup, you can set any window style, easily show at any position at any DPI, etc.
/// Like Popup, can show by rectangle. Unlike Popup, can be resizable.
/// Like Popup, can be click-closed, and does not eat mouse events like Popup.
/// </summary>
public class KPopup {
	WS _style;
	WSE _exStyle;
	SizeToContent _sizeToContent;
	bool _shadow;
	HwndSource _hs;
	wnd _w;
	bool _inSizeMove;
	
	///
	public KPopup(WS style = WS.POPUP | WS.THICKFRAME, WSE exStyle = WSE.TOOLWINDOW | WSE.NOACTIVATE, bool shadow = false, SizeToContent sizeToContent = default) {
		_style = style;
		_exStyle = exStyle;
		_shadow = shadow;
		_sizeToContent = sizeToContent;
	}
	
	HwndSource _Create() {
		if (_hs == null) {
			var p = new HwndSourceParameters {
				WindowStyle = (int)_style,
				ExtendedWindowStyle = (int)_exStyle,
				WindowClassStyle = _shadow && !_style.Has(WS.THICKFRAME) ? (int)Api.CS_DROPSHADOW : 0,
				WindowName = _windowName,
				//AcquireHwndFocusInMenuMode = false,
				//RestoreFocusMode = System.Windows.Input.RestoreFocusMode.None,
				//TreatAsInputRoot = false,
				HwndSourceHook = _Hook
			};
			_hs = new _HwndSource(p) { kpopup = this, RootVisual = Border, SizeToContent = default };
			//print.it(_hs.AcquireHwndFocusInMenuMode, _hs.RestoreFocusMode, p.TreatAsInputRoot); //True, Auto, True
			
			OnHandleCreated();
		}
		return _hs;
	}
	
	class _HwndSource : HwndSource {
		public _HwndSource(HwndSourceParameters p) : base(p) { }
		public KPopup kpopup;
	}
	
	protected virtual void OnHandleCreated() { HandleCreated?.Invoke(); }
	public event Action HandleCreated;
	
	public static KPopup FromHwnd(wnd w) {
		if (w.IsAlive && HwndSource.FromHwnd(w.Handle) is _HwndSource hs) return hs.kpopup;
		return null;
	}
	
	/// <summary>
	/// Gets popup window handle. Returns default(wnd) if not created (also after destroying).
	/// </summary>
	public wnd Hwnd => _w;
	
	//public HwndSource HwndSource => _hs ?? _Create();
	
	/// <summary>
	/// Gets or sets window name.
	/// </summary>
	public string WindowName {
		get => _windowName;
		set {
			_windowName = value;
			if (!_w.Is0) _w.SetText(value);
		}
	}
	string _windowName;
	
	/// <summary>
	/// Gets or sets this <b>KPopup</b> object name. It is not window name.
	/// </summary>
	public string Name { get; set; }
	
	/// <summary>
	/// Gets or sets WPF content. It is child of <see cref="Border"/>.
	/// </summary>
	public UIElement Content {
		get => _content;
		set {
			_content = value;
			if (_border != null) _border.Child = value;
		}
	}
	UIElement _content;
	
	/// <summary>
	/// Gets the WPF root object (<see cref="HwndSource.RootVisual"/>) of the popup window. Its child is <see cref="Content"/>.
	/// </summary>
	public Border Border => _border ??= new Border { Child = _content, SnapsToDevicePixels = true };
	Border _border;
	//workaround for: if content is eg FlowDocumentScrollViewer, it has focus problems if it is RootVisual.
	//	Eg context menu items disabled. Need a container, eg Border or Panel.
	
	/// <summary>
	/// Desired window size. WPF logical pixels.
	/// Actual size can be smaller if would not fit in screen.
	/// </summary>
	public SIZE Size {
		get => _size;
		set {
			_size = value;
			if (IsVisible) _w.ResizeL_(Dpi.Scale(_size, _w));
		}
	}
	SIZE _size;
	
	/// <summary>
	/// Set <see cref="HwndSource.SizeToContent"/>.
	/// If false (default), this class calculates content size when showing, and does not update while showing. If true, may align incorrectly.
	/// </summary>
	public bool WpfSizeToContent { get; set; }
	
	/// <summary>
	/// Shows the popup window by a window, WPF element or rectangle.
	/// </summary>
	/// <param name="owner">Provides owner window and optionally rectangle. Can be <b>FrameworkElement</b>, <b>KPopup</b>, <b>wnd</b> or null.</param>
	/// <param name="side">Show at this side of rectangle, or opposite side if does not fit in screen. If null, shows in rectangle.</param>
	/// <param name="rScreen">Rectangle in screen (physical pixels). If null, uses owner's rectangle. Cannot be both null.</param>
	/// <param name="exactSize">If does not fit in screen, cover part of rectangle but don't make smaller.</param>
	/// <param name="exactSide">Never show at opposite side.</param>
	/// <exception cref="NotSupportedException">Unsupported <i>owner</i> type.</exception>
	/// <exception cref="ArgumentException">Both owner and rScreen are null. Or owner handle not created.</exception>
	/// <remarks>
	/// If <see cref="Size"/> not set, uses <see cref="SizeToContent.WidthAndHeight"/>.
	/// </remarks>
	public void ShowByRect(object owner, Dock? side, RECT? rScreen = null, bool exactSize = false, bool exactSide = false) {
		//CloseHides = true; //print.it(_w); //18 -> 5 ms
		//perf.first(); if(owner is FrameworkElement test) test.Dispatcher.InvokeAsync(() => perf.nw());
		
		wnd ow = default;
		switch (owner) {
		case null:
			if (rScreen == null) throw new ArgumentException("owner and rScreen are null");
			break;
		case FrameworkElement e:
			ow = e.Hwnd().Window;
			rScreen ??= e.RectInScreen();
			break;
		case KPopup p:
			ow = p._w;
			rScreen ??= ow.Rect;
			break;
		case wnd w:
			ow = w;
			rScreen ??= ow.Rect;
			break;
		default: throw new NotSupportedException("owner type");
		}
		if (owner != null && ow.Is0) throw new ArgumentException("owner window not created");
		if (_size == default) _sizeToContent = SizeToContent.WidthAndHeight;
		
		_Create();
		
		//could use API CalculatePopupWindowPosition instead of this code, but it is not exactly what need here.
		RECT r = rScreen.Value;
		var scrn = screen.of(r);
		var rs = scrn.WorkArea;
		int dpi = scrn.Dpi;
		SIZE size = Dpi.Scale(Size, dpi);
		
		if (_sizeToContent != default) {
			RECT nc = default;
			Dpi.AdjustWindowRectEx(dpi, ref nc, _style, _exStyle);
			rs.left -= nc.left; rs.right -= nc.right; rs.top -= nc.top; rs.bottom -= nc.bottom;
			
			if (_sizeToContent.Has(SizeToContent.Width)) size.width = rs.Width; else size.width = Math.Min(size.width, rs.Width);
			if (_sizeToContent.Has(SizeToContent.Height)) size.height = rs.Height; else size.height = Math.Min(size.height, rs.Height);
			_border.Measure(Dpi.Unscale(size, dpi));
			//never mind: it seems FlowDocument measures only height.
			//	If need width, could instead use TextBlock. It does not support paragraph etc, but we can use multiple TextBlock etc in StackPanel.
			//	But then no select/copy, not so easy scrolling, etc.
			_border.UpdateLayout();
			var ds = _border.DesiredSize;
			ds.Width = Math.Ceiling(ds.Width + .5); ds.Height = Math.Ceiling(ds.Height + .5); //avoid scrollbars
			size = Dpi.Scale(ds, dpi);
			size.width += nc.Width; size.height += nc.Height;
		}
		size.width = Math.Min(size.width, rs.Width);
		size.height = Math.Min(size.height, rs.Height);
		
		_hs.SizeToContent = WpfSizeToContent ? _sizeToContent : default;
		
		if (side != null) {
			int spaceT = r.top - rs.top, spaceB = rs.bottom - r.bottom, spaceL = r.left - rs.left, spaceR = rs.right - r.right;
			if (!exactSide) {
				switch (side) {
				case Dock.Left:
					if (size.width > spaceL && spaceR > spaceL) side = Dock.Right;
					break;
				case Dock.Right:
					if (size.width > spaceR && spaceL > spaceR) side = Dock.Left;
					break;
				case Dock.Top:
					if (size.height > spaceT && spaceB > spaceT) side = Dock.Bottom;
					break;
				case Dock.Bottom:
					if (size.height > spaceB && spaceT > spaceB) side = Dock.Top;
					break;
				}
			}
			if (!exactSize) {
				switch (side) {
				case Dock.Left:
					if (size.width > spaceL) size.width = Math.Max(spaceL, size.width / 2);
					break;
				case Dock.Right:
					if (size.width > spaceR) size.width = Math.Max(spaceR, size.width / 2);
					break;
				case Dock.Top:
					if (size.height > spaceT) size.height = Math.Max(spaceT, size.height / 2);
					break;
				case Dock.Bottom:
					if (size.height > spaceB) size.height = Math.Max(spaceB, size.height / 2);
					break;
				}
			}
			switch (side) {
			case Dock.Left: r.left -= size.width; break;
			case Dock.Right: r.left = r.right; break;
			case Dock.Top: r.top -= size.height; break;
			case Dock.Bottom: r.top = r.bottom; break;
			}
		}
		
		r.left = Math.Clamp(r.left, rs.left, rs.right - size.width);
		r.top = Math.Clamp(r.top, rs.top, rs.bottom - size.height);
		r.Width = size.width; r.Height = size.height;
		
		_inSizeMove = false;
		_w.MoveL(r);
		if (_w.Get.Owner != ow) WndUtil.SetOwnerWindow(_w, ow);
		if (!IsVisible) _w.SetWindowPos(SWPFlags.SHOWWINDOW | SWPFlags.NOMOVE | SWPFlags.NOSIZE | SWPFlags.NOACTIVATE | SWPFlags.NOOWNERZORDER);
	}
	
	/// <summary>
	/// Destroys or hides the popup window, depending on <see cref="CloseHides"/>.
	/// </summary>
	public void Close() {
		if (_hs == null) return;
		if (CloseHides) _w.ShowL(false);
		else _hs.Dispose();
	}
	
	/// <summary>
	/// Don't destroy the popup window when closing, but just hide.
	/// In any case, if destroyed, <b>ShowX</b> will create new window.
	/// </summary>
	public bool CloseHides { get; set; }
	
	/// <summary>
	/// true if closed (or hidden if <see cref="CloseHides"/>) when the user clicked the x button.
	/// </summary>
	public bool UserClosed { get; set; }
	
	/// <summary>
	/// Whether the popup window is currently visible.
	/// </summary>
	public bool IsVisible => _w.IsVisible;
	
	/// <summary>
	/// When the popup window becomes invisible. It also happend when destroying.
	/// </summary>
	public event EventHandler Hidden;
	
	/// <summary>
	/// When destroying the popup window (WM_NCDESTROY).
	/// </summary>
	public event EventHandler Destroyed;
	
	/// <summary>
	/// Close when mouse clicked.
	/// </summary>
	public CC ClickClose { get; set; }

	/// <summary>
	/// Activate the owner window when clicked, if this and owner both are inactive. Only if has <b>WS_EX_NOACTIVATE</b> style.
	/// </summary>
	public bool ClickInactiveActivateOwner { get; set; }
	
	void _ClickCloseTimer(bool? start) {
		if (start == null) {
			int state = (keys.gui.getKeyState(KKey.MouseLeft) & 1)
				| (keys.gui.getKeyState(KKey.MouseRight) & 1) << 1
				| (keys.gui.getKeyState(KKey.MouseMiddle) & 1) << 2;
			if (_ccState < 0) _ccState = state; //first time
			if (state == _ccState) return;
			_ccState = state;
			if (ClickClose != CC.Anywhere) {
				var wm = wnd.fromMouse(WXYFlags.NeedWindow);
				if (ClickClose == CC.Inside) {
					if (wm != _w) return;
				} else {
					if (wm == _w) return;
					if (wm.IsOfThisThread && wm.ZorderIsAbove(_w)) return;
				}
			}
			Close();
		} else if (start == true) {
			if (!ClickClose.HasAny(CC.Anywhere)) return;
			_ccTimer = 0 != Api.SetTimer(_w, c_ccTimer, 100, null);
			_ccState = -1; //GetKeyState may not work if called from WM_WINDOWPOSCHANGED. Call from WM_TIMER.
		} else if (_ccTimer) {
			_ccTimer = false;
			Api.KillTimer(_w, c_ccTimer);
		}
	}
	const int c_ccTimer = 10;
	bool _ccTimer;
	int _ccState;
	
	[Flags]
	public enum CC { Inside = 1, Outside = 2, Anywhere = 3 };
	
	unsafe nint _Hook(nint hwnd, int msg, nint wParam, nint lParam, ref bool handled) {
		var r = _Hook((wnd)hwnd, msg, wParam, lParam);
		handled = r != null;
		return r ?? 0;
	}
	
	unsafe nint? _Hook(wnd w, int msg, nint wParam, nint lParam) {
		//WndUtil.PrintMsg(w, msg, wParam, lParam);
		//if(WndUtil.PrintMsg(out string s1, w, msg, wParam, lParam)) print.qm2.write(s1);
		//if (msg == Api.WM_ACTIVATE && wParam != 0) print.it("ACTIVATE");
		
		switch (msg) {
		case Api.WM_NCCREATE:
			_w = w;
			break;
		case Api.WM_NCDESTROY:
			Destroyed?.Invoke(this, EventArgs.Empty);
			_hs.RootVisual = null;
			_hs = null;
			_w = default;
			break;
		case Api.WM_WINDOWPOSCHANGED:
			var wp = (Api.WINDOWPOS*)lParam;
			//print.it(wp->flags & SWPFlags._KNOWNFLAGS, IsVisible);
			if (!wp->flags.Has(SWPFlags.NOSIZE) && _inSizeMove) _size = SIZE.From(Dpi.Unscale((wp->cx, wp->cy), w), true);
			if (wp->flags.Has(SWPFlags.SHOWWINDOW)) {
				UserClosed = false;
				_ClickCloseTimer(true);
			}
			if (wp->flags.Has(SWPFlags.HIDEWINDOW)) {
				_ClickCloseTimer(false);
				if (Border.IsKeyboardFocusWithin) Keyboard.ClearFocus();
				Hidden?.Invoke(this, EventArgs.Empty);
			}
			break;
		case Api.WM_ENTERSIZEMOVE:
			_inSizeMove = true;
			break;
		case Api.WM_EXITSIZEMOVE:
			_inSizeMove = false;
			break;
		case Api.WM_MOUSEACTIVATE:
			//OS ignores WS_EX_NOACTIVATE if the active window is of this thread. Workaround: on WM_MOUSEACTIVATE return MA_NOACTIVATE.
			switch (Math2.HiShort(lParam)) {
			case Api.WM_MBUTTONDOWN:
				Close(); //never mind: we probably don't receive this message if our thread is inactive
				return Api.MA_NOACTIVATEANDEAT;
			}
			if (_exStyle.Has(WSE.NOACTIVATE)) {
				if (ClickInactiveActivateOwner && w.Get.Owner is var ow && ow.IsAlive && !ow.IsActive && !w.IsActive) {
					ow.ActivateL();
				}
				return Api.MA_NOACTIVATE;
			}
			break;
		case Api.WM_NCLBUTTONDOWN:
			if (_exStyle.Has(WSE.NOACTIVATE)) {
				//OS activates when clicked in non-client area, eg when moving or resizing. Workaround: on WM_NCLBUTTONDOWN suppress activation with a CBT hook.
				//When moving or resizing, WM_NCLBUTTONDOWN returns when moving/resizing ends. On resizing would activate on mouse button up.
				var wa = wnd.thisThread.active;
				if (wa != default && wa != w) {
					using (WindowsHook.ThreadCbt(d => d.code == HookData.CbtEvent.ACTIVATE && d.Hwnd == w))
						Api.DefWindowProc(w, msg, wParam, lParam);
					return 0;
				}
			}
			break;
		case Api.WM_SYSCOMMAND when (wParam & 0xFFF0) == Api.SC_CLOSE:
			UserClosed = true;
			break;
		case Api.WM_CLOSE:
			if (CloseHides) { _w.ShowL(false); return 0; }
			break;
		case Api.WM_DPICHANGED:
			if (!_inSizeMove) *(RECT*)lParam = _w.Rect; //prevent changing rect, it's already calculated for the DPI
			_hs.DpiChangedWorkaround();
			break;
		case Api.WM_TIMER when wParam == c_ccTimer:
			_ClickCloseTimer(null);
			break;
		case Api.WM_SHOWWINDOW:
			if (wParam == 0) {
				if (lParam == 1) _w.ShowL(false); //minimizing owner. Prevent showing again when restoring.
				else if (w.IsActive) {
					var ow = w.Get.Owner;
					_hs.Dispatcher.InvokeAsync(() => { if(w.IsActive && ow.IsVisible && !ow.IsMinimized) ow.ActivateL(); });
				}
			}
			break;
		}
		return null;
	}
}


================================================
FILE: Au.Controls/Simple/KPopupListBox.cs
================================================
using System.Windows;
using System.Windows.Controls;
using System.Windows.Controls.Primitives;
using System.Windows.Input;

namespace Au.Controls;

/// <summary>
/// Simple <see cref="Popup"/> with child <see cref="ListBox"/>.
/// </summary>
/// <remarks>
/// The <see cref="Control"/> property gets the <b>ListBox</b>. Add items to it.
/// Show the popup as usually (set <b>PlacementTarget</b> etc and <b>IsOpen</b>=true).
/// 
/// When an item clicked, closes the popup and fires <see cref="OK"/> event. Also when pressed Enter key when an item is selected.
/// Closes the popup without the event when clicked outside or pressed Esc key.
/// </remarks>
public class KPopupListBox : Popup {
	readonly ListBox _lb;
	
	///
	public KPopupListBox() {
		Child = _lb = new ListBox();
		StaysOpen = false;
	}
	
	/// <summary>
	/// Gets the <b>ListBox</b>.
	/// </summary>
	public ListBox Control => _lb;
	
	/// <summary>
	/// When an item clicked, or pressed Enter key and there is a selected item.
	/// The popup is already closed.
	/// </summary>
	public event Action<object> OK;
	
	void _CloseOK() {
		IsOpen = false;
		if (_lb.SelectedItem is { } v) OK?.Invoke(v);
	}
	
	///
	protected override void OnMouseUp(MouseButtonEventArgs e) {
		switch (e.ChangedButton) {
		case MouseButton.Left: _CloseOK(); break;
		case MouseButton.Middle: IsOpen = false; break;
		}
		base.OnMouseUp(e);
	}
	
	#region steal keyboard from the focused HwndHost-ed control
	
	protected override void OnKeyUp(KeyEventArgs e) { //if OnKeyDown, next time Esc defocuses the HwndHost-ed control
		switch (e.Key) {
		case Key.Enter: _CloseOK(); break;
		case Key.Escape: IsOpen = false; break;
		}
		base.OnKeyUp(e);
	}
	
	protected override void OnOpened(EventArgs e) {
		_lb.Focus();
		base.OnOpened(e);
		_hook = WindowsHook.ThreadKeyboard(_Hook);
	}
	WindowsHook _hook; //also tested ComponentDispatcher.ThreadPreprocessMessage, but it does not steal messages from HwndHost-ed controls
	
	protected override void OnClosed(EventArgs e) {
		_hook?.Dispose();
		_hook = null;
		base.OnClosed(e);
	}
	
	bool _Hook(HookData.ThreadKeyboard k) {
		if (!_lb.IsKeyboardFocusWithin) return false;
		if (PresentationSource.FromVisual(_lb) is not { } inputSource) return false;
		var key = KeyInterop.KeyFromVirtualKey((int)k.key);
		var e = new KeyEventArgs(Keyboard.PrimaryDevice, inputSource, 0, key) { RoutedEvent = k.IsUp ? Keyboard.KeyUpEvent : Keyboard.KeyDownEvent };
		_lb.RaiseEvent(e);
		return true;
	}
	
	#endregion
}


================================================
FILE: Au.Controls/Simple/KScreenComboBox.cs
================================================
using System.Windows.Controls;

namespace Au.Controls;

/// <summary>
/// <b>ComboBox</b> to select screen.
/// Ctor adds items. Finally call <b>Result</b>.
/// </summary>
public class KScreenComboBox : ComboBox {
	///
	public KScreenComboBox() {
		Items.Add("Primary screen");
		SelectedIndex = 0;
		
		var a = screen.all;
		if (a.Length > 1) {
			//add functions of screen.at
			foreach (var v in typeof(screen.at).GetMethods(BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public)) {
				Items.Add("screen.at." + v.Name);
			}
			
			//if defined type "screens", add its public static properties that return screen
			//	This code works, but probably this feature would be rarely used. Now undocumented.
			//if (_compilation.GetSymbolsWithName("screens", SymbolFilter.Type).FirstOrDefault() is INamedTypeSymbol screens) {
			//	foreach (var v in screens.GetMembers()) {
			//		if (v is not IPropertySymbol p || !v.IsStatic || v.DeclaredAccessibility is not Microsoft.CodeAnalysis.Accessibility.Public) continue;
			//		if (p.Type.ToString() != "Au.screen") continue;
			//		Items.Add("screens." + v.Name);
			//	}
			//}
			
			//if (a.Length == 2) Items.Add("screen.index(1)"); //no. More screens may be added in the future, and indices may change then.
		}
	}
	
	/// <summary>
	/// Formats <i>screen</i> argument code.
	/// </summary>
	/// <param name="trigger"></param>
	/// <returns>null if primary screen.</returns>
	public string Result(bool trigger) {
		int iScreen = SelectedIndex;
		if (iScreen == 0) return null;
		var s = Items[iScreen] as string;
		//if (s.Starts("screens.")) return s;
		if (s.Starts("screen.at.")) s += trigger ? "(true)" : "()";
		else if (trigger && s.Like("screen.index(*)")) s = s.Insert(^1, ", lazy: true");
		return s;
	}
}


================================================
FILE: Au.Controls/Simple/KTextBox.cs
================================================
using System.Windows;
using System.Windows.Media;
using System.Windows.Controls;
using System.Windows.Documents;
using System.Windows.Input;

namespace Au.Controls;

/// <summary>
/// Adds some features:
/// <br/>• Changes caret position when clicked left margin.
/// <br/>• Clears on middle-click.
/// <br/>• Can disable horizontal scrollbar when not focused.
/// </summary>
public class KTextBox : TextBox {
	/// <summary>
	/// Disables horizontal scrollbar when not focused.
	/// </summary>
	public bool Small {
		get => _small;
		set {
			if (_small) throw new InvalidOperationException();
			_small = true;
			HorizontalScrollBarVisibility = ScrollBarVisibility.Disabled;
		}
	}
	bool _small;
	
	protected override void OnGotKeyboardFocus(KeyboardFocusChangedEventArgs e) {
		if (_small) HorizontalScrollBarVisibility = ScrollBarVisibility.Auto;
		base.OnGotKeyboardFocus(e);
	}
	
	protected override void OnLostKeyboardFocus(KeyboardFocusChangedEventArgs e) {
		if (_small) HorizontalScrollBarVisibility = ScrollBarVisibility.Disabled;
		base.OnLostKeyboardFocus(e);
	}
	
	protected override void OnMouseDown(MouseButtonEventArgs e) {
		//Workaround for this nasty default behavior of TextBox: does not set the caret position when clicked the left padding area.
		//	Then difficult to set the caret position eg at the start, because the width of the sensitive area is 0.5 of the width of the first character (eg 2 pixels if `i`).
		//	Classic Edit controls etc don't have this problem. Users often click the padding area to move the caret at the start, but in WPF TextBox it does not work.
		if (e.ChangedButton == MouseButton.Left && e.OriginalSource is Grid g && e.GetPosition(g).X < Padding.Left + 3) {
			var p = e.GetPosition(this);
			int i = base.GetCharacterIndexFromPoint(p, true);
			if (i >= 0) this.CaretIndex = i;
			//never mind: cursor not I-beam.
			//never mind: can't drag-select starting from the padding area.
		}
		if (e.ChangedButton == MouseButton.Middle) {
			Clear();
		}
		base.OnMouseDown(e);
	}
	
	protected override void OnContextMenuOpening(ContextMenuEventArgs e) {
		if (ContextMenu == null) {
			this.xAddCutCopyPasteToContextMenu(addClear: true, setStateNow: true);
		}
		base.OnContextMenuOpening(e);
	}
}

/// <summary>
/// TextBox for a file or folder path.
/// Supports drag-drop and Browse dialog (right-click).
/// </summary>
public class KTextBoxFile : TextBox {
	bool _canDrop;
	
	///
	protected override void OnPreviewDragEnter(DragEventArgs e) {
		if (e.Handled = _canDrop = e.Data.GetDataPresent(DataFormats.FileDrop)) e.Effects = DragDropEffects.Link;
		base.OnPreviewDragEnter(e);
	}
	
	///
	protected override void OnPreviewDragOver(DragEventArgs e) {
		if (e.Handled = _canDrop) e.Effects = DragDropEffects.Link;
		base.OnPreviewDragEnter(e);
	}
	
	///
	protected override void OnDrop(DragEventArgs e) {
		if (e.Data.GetData(DataFormats.FileDrop) is string[] a && a.Length > 0) {
			var s = a[0];
			if (s.Ends(".lnk", true) && filesystem.exists(s).File)
				try { s = shortcutFile.getTarget(s); }
				catch (Exception) { }
			Text = s;
		}
		base.OnDrop(e);
	}
	
	///
	protected override void OnContextMenuOpening(ContextMenuEventArgs e) {
		var m = new popupMenu { CheckDontClose = true };
		
		m["Browse..."] = o => {
			var d = new FileOpenSaveDialog(ClientGuid ?? (IsFolder ? "3d4a9167-929a-4346-adfb-e2f03427412c" : "6a7d02c0-7f98-4808-b764-84985ca6e767"));
			if (d.ShowOpen(out string s, owner: this.Hwnd(), selectFolder: IsFolder)) _SetText(s);
		};
		m["folders.EditMe + @\"EditMe\""] = o => _SetText(o.Text);
		m.Submenu("Known folders", m => {
			foreach (var v in typeof(folders).GetProperties()) {
				bool nac = folders.noAutoCreate;
				folders.noAutoCreate = true;
				string path = v.GetValue(null) switch { string k => k, FolderPath k => k.Path, _ => null };
				folders.noAutoCreate = nac;
				if (path == null) continue;
				var name = v.Name;
				m[$"{name}\t{path.Limit(80, middle: true)}"] = o => _SetText(Unexpand ? $"folders.{name} + @\"EditMe\"" : path + (path.Ends('\\') ? "" : "\\"));
			}
		});
		m.Submenu("Environment variables", m => {
			foreach (var (name, path) in Environment.GetEnvironmentVariables().OfType<System.Collections.DictionaryEntry>().Select(o => (o.Key as string, o.Value as string)).OrderBy(o => o.Item1)) {
				if (!pathname.isFullPath(path, orEnvVar: true)) continue;
				int i = path.IndexOf(';'); if (i > 0 && pathname.isFullPath(path.AsSpan(i + 1), orEnvVar: true)) continue; //list of paths
				if (IsFolder && filesystem.exists(path).File) continue;
				m[$"{name}\t{path.Limit(80, middle: true)}"] = o => _SetText(Unexpand ? $"%{name}%\\" : pathname.expand(path));
			}
		});
		m.Submenu("Folder windows", m => {
			foreach (var v in ExplorerFolder.All(onlyFilesystem: true).Select(o => o.GetFolderPath())) {
				m[v.Limit(100, middle: true)] = o => _SetText(v);
			}
		});
		m.Separator();
		m.AddCheck("Unexpand", Unexpand, o => { Unexpand ^= true; UnexpandChanged?.Invoke(); });
		
		void _SetText(string s) {
			Text = s;
			CaretIndex = s.Length;
		}
		
		m.Show(owner: this.Hwnd());
		e.Handled = true;
	}
	
	/// <summary>
	/// true if this control is for a folder path.
	/// </summary>
	public bool IsFolder { get; set; }
	
	/// <summary>
	/// For <see cref="FileOpenSaveDialog"/>.
	/// If not set, uses 2 different GUIDs: one for folders (see <see cref="IsFolder"/>), other for files.
	/// </summary>
	public string ClientGuid { get; set; }
	
	/// <summary>
	/// Let <b>GetCode</b> unexpand path.
	/// Also used/changed by the context menu.
	/// Default true.
	/// </summary>
	public bool Unexpand { get; set; } = true;
	
	public event Action UnexpandChanged;
	
	/// <summary>
	/// Formats code like '@"path"' or 'folders.X + @"relative"' or 'folders.X'.
	/// </summary>
	public string GetCode() {
		var s = Text;
		if (s.Contains('"') || s.Starts("folders.")) return s;
		if (Unexpand && folders.unexpandPath(s, out var s1, out var s2)) return s2.NE() ? s1 : $"{s1} + @\"{s2}\"";
		return $"@\"{s}\"";
	}
}


================================================
FILE: Au.Controls/Simple/KWpfMenu.cs
================================================
using System.Windows;
using System.Windows.Controls;
using System.Windows.Media;
using System.Windows.Threading;
using System.Windows.Input;
using System.Windows.Interop;
using System.Windows.Media.Imaging;

namespace Au.Controls;

/// <summary>
/// Based on WPF <see cref="ContextMenu"/>, makes simpler to use it.
/// </summary>
/// <example>
/// <code><![CDATA[
/// var m = new KWpfMenu();
/// m["One"] = o => print.it(o);
/// using(m.Submenu("Sub")) {
/// 	m["Three"] = o => print.it(o);
/// 	m["Four"] = o => print.it(o);
/// }
/// m.Separator();
/// m["Two"] = o => { print.it(o); };
/// m.Show(this); //or m.IsOpen=true;
/// ]]></code>
/// </example>
public class KWpfMenu : ContextMenu {
	///
	public KWpfMenu() {
	}
	
	/// <summary>
	/// Creates new <see cref="MenuItem"/> and adds to the menu. Returns it.
	/// </summary>
	/// <param name="text">
	/// Label. See <see cref="HeaderedItemsControl.Header"/>.
	/// If contains '\0' character, uses text before it for label and text after it for <see cref="MenuItem.InputGestureText"/>; example: "Text\0" + "Ctrl+E".
	/// </param>
	/// <param name="click">Action called on click.</param>
	/// <param name="icon">See <see cref="this[string, bool, object]"/>.</param>
	/// <remarks>
	/// Usually it's easier to use the indexer instead. It just calls this function. See example.
	/// </remarks>
	/// <example>
	/// <code><![CDATA[
	/// m["Example"] = o => print.it(o);
	/// m.Last.IsChecked = true;
	/// ]]></code>
	/// </example>
	public MenuItem Add(object text, Action<WpfMenuActionArgs> click = null, object icon = null) {
		string gest = null;
		if (text is string s && s.Contains('\0')) {
			int j = s.IndexOf('\0');
			text = s[0..j];
			gest = s[++j..];
		}
		var item = new _MenuItem(this) {
			action = click,
			actionException = ActionException,
			Header = text
		};
		if (gest != null) item.InputGestureText = gest;
		item.Icon = MenuItemIcon_(icon);
		CurrentAddMenu.Items.Add(Last = item);
		ItemAdded?.Invoke(item);
		return item;
	}
	
	/// <summary>
	/// Creates new <see cref="MenuItem"/> and adds to the menu.
	/// </summary>
	/// <param name="text">
	/// Label. See <see cref="HeaderedItemsControl.Header"/>.
	/// If contains '\0' character, uses text before it for label and text after it for <see cref="MenuItem.InputGestureText"/>; example: "Text\0" + "Ctrl+E".
	/// </param>
	/// <param name="enabled">Disabled if false. Default true.</param>
	/// <param name="icon">
	/// Can be:
	/// - <see cref="Image"/> or other WPF control to assign directly to <see cref="MenuItem.Icon"/>.
	/// - <see cref="ImageSource"/> - a WPF image. To create image from icon, use <see cref="icon.ToWpfImage"/>.
	/// - string - image file path, or resource path that starts with "resources/" or has prefix "resource:", or Base64 encoded image with prefix "image:". Can be XAML file or resource. See <see cref="ImageUtil.LoadWpfImageElement"/>. Supports environment variables. If not full path, looks in <see cref="folders.ThisAppImages"/>.
	/// - <see cref="Uri"/> - image file path, or resource pack URI, or URL. Does not support environment variables and <see cref="folders.ThisAppImages"/>.
	/// 
	/// If failed to find or load image file, prints warning (<see cref="print.warning"/>).
	/// To create Base64 string, use menu Code > Find image.
	/// To add an image resource in Visual Studio, use build action "Resource" for the image file.
	/// </param>
	/// <value>Action called on click.</value>
	/// <remarks>
	/// Calls <see cref="Add(object, Action{WpfMenuActionArgs}, object)"/>.
	/// </remarks>
	/// <example>
	/// <code><![CDATA[
	/// m["Example"] = o => print.it(o);
	/// m.Last.IsChecked = true;
	/// ]]></code>
	/// </example>
	public Action<WpfMenuActionArgs> this[string text, bool enabled = true, object icon = null] {
		set {
			var v = Add(text, value, icon);
			if (!enabled) v.IsEnabled = false;
		}
	}
	
	/// <summary>
	/// Adds separator.
	/// </summary>
	public void Separator() { CurrentAddMenu.Items.Add(new Separator()); }
	
	/// <summary>
	/// Creates new <see cref="MenuItem"/> for a submenu and adds to the menu.
	/// </summary>
	/// <param name="text">Label. See <see cref="HeaderedItemsControl.Header"/>.</param>
	/// <param name="icon"><see cref="MenuItem.Icon"/>.</param>
	/// <param name="click">Action called on click. Rarely used.</param>
	/// <remarks>
	/// Then the add-item functions will add items to the submenu, until the returned variable is disposed.
	/// </remarks>
	/// <example><see cref="KWpfMenu"/></example>
	public UsingEndAction Submenu(object text, object icon = null, Action<WpfMenuActionArgs> click = null) {
		var mi = Add(text, click, icon);
		_submenuStack.Push(mi);
		return new UsingEndAction(() => _submenuStack.Pop());
		//CONSIDER: copy some properties of current menu. Or maybe WPF copies automatically, need to test.
	}
	
	Stack<MenuItem> _submenuStack = new();
	//bool _AddingSubmenuItems => _submenuStack.Count > 0;
	
	/// <summary>
	/// Gets <see cref="ItemsControl"/> of the menu or submenu where new items currently would be added.
	/// </summary>
	public ItemsControl CurrentAddMenu => _submenuStack.Count > 0 ? _submenuStack.Peek() : this;
	
	/// <summary>
	/// Gets the last added <see cref="MenuItem"/>.
	/// </summary>
	public MenuItem Last { get; private set; }
	
	/// <summary>
	/// Called when added a non-separator item.
	/// </summary>
	public Action<MenuItem> ItemAdded { get; set; }
	
	/// <summary>
	/// Whether to handle exceptions in item action code. If false (default), handles exceptions and on exception calls <see cref="print.warning"/>.
	/// Applied to menu items added afterwards.
	/// </summary>
	public bool ActionException { get; set; }
	
	/// <summary>
	/// Sets <see cref="ContextMenu.PlacementTarget"/> = <i>owner</i> and <see cref="ContextMenu.IsOpen"/> = true.
	/// </summary>
	/// <param name="owner"><see cref="ContextMenu.PlacementTarget"/>. The menu uses its DPI. If null, uses DPI of primary screen (WPF bug).</param>
	/// <param name="byCaret">Show by caret (text cursor) position if possible.</param>
	/// <param name="modal">Wait until closed.</param>
	public void Show(UIElement owner, bool byCaret = false, bool modal = false) {
		if (byCaret && miscInfo.getTextCursorRect(out RECT cr, out _)) {
			var r = owner == null ? cr : new Rect(owner.PointFromScreen(new Point(cr.left, cr.top)), owner.PointFromScreen(new Point(cr.right, cr.bottom)));
			r.Inflate(30, 2);
			PlacementRectangle = r;
			Placement = System.Windows.Controls.Primitives.PlacementMode.Bottom;
		}
		PlacementTarget = owner;
		
		//tested: VisualTreeHelper.SetRootDpi does not work.
		
		//workaround for: if focused is a native control in a HwndHost, it remains focused, and menu keyboard does not work normally.
		//	Temporarily remove native focus from the control.
		//	Also tried to redirect key messages with a hook, but it does not work for arrow keys.
		//	Also tried to remove focus in OnOpened, but it closes the menu.
		//	Never mind: hides caret. In notepad etc menus don't hide caret. But eg in VS hide too.
		if (owner is HwndHost hh && hh.IsFocused && Api.GetFocus() == (wnd)hh.Handle && FocusManager.GetFocusScope(hh) is UIElement fs) {
			fs.Focus();
		}
		
		IsOpen = true;
		
		if (modal) {
			_dispFrame = new DispatcherFrame();
			Dispatcher.PushFrame(_dispFrame);
		}
	}
	DispatcherFrame _dispFrame;
	
	void _EndModal() {
		if (_dispFrame != null) {
			_dispFrame.Continue = false;
			_dispFrame = null;
		}
	}
	
	///
	protected override void OnClosed(RoutedEventArgs e) {
		_EndModal();
		base.OnClosed(e);
	}
	
	internal static object MenuItemIcon_(object icon) {
		if (icon != null) {
			try {
				ImageSource iso = null;
				switch (icon) {
				case string s:
					return ImageUtil.LoadWpfImageElement(s);
				case Uri s:
					iso = BitmapFrame.Create(s);
					break;
				case ImageSource s:
					iso = s;
					break;
				default:
					return icon;
				}
				if (iso != null) return new Image { Source = iso };
			}
			catch (Exception ex) { print.warning("Failed to load menu item image. " + ex.ToStringWithoutStack()); }
		}
		return null;
		//rejected: cache, like popupMenu.
	}
	
	/// <summary>
	/// Creates and shows popup menu where items use ids instead of actions.
	/// Returns selected item id, or 0 if canceled.
	/// </summary>
	/// <param name="items">
	/// Menu items. Can be string[], List&lt;string&gt; or string like "One|Two|Three".
	/// Item id can be optionally specified like "1 One|2 Two|3 Three". If missing, uses id of previous non-separator item + 1. Example: "One|Two|100 Three Four" //1|2|100|101.
	/// For separators use null or empty strings: "One|Two||Three|Four".
	/// </param>
	/// <param name="owner"><see cref="ContextMenu.PlacementTarget"/>. The menu uses its DPI. If null, uses DPI of primary screen (WPF bug).</param>
	/// <param name="byCaret">Show by caret (text cursor) position if possible.</param>
	/// <param name="beforeShow">Called after adding menu items, before showing the menu. For example can set placement properties.</param>
	/// <remarks>
	/// The menu is modal; the function returns when closed.
	/// </remarks>
	/// <seealso cref="dialog.showList"/>
	public static int ShowSimple(Strings items, UIElement owner, bool byCaret = false, Action<KWpfMenu> beforeShow = null) {
		var a = items.ToArray();
		var m = new KWpfMenu();
		//	var dispFrame = new DispatcherFrame();
		//	m.Closed+=(_,_)=>dispFrame.Continue=false;
		int result = 0, autoId = 0;
		foreach (var v in a) {
			var s = v;
			if (s.NE()) {
				m.Separator();
			} else {
				if (s.ToInt(out int id, 0, out int end)) {
					if (s.Eq(end, ' ')) end++;
					s = s[end..];
					autoId = id;
				} else {
					id = ++autoId;
				}
				m.Add(s, o => result = (int)o.Item.Tag).Tag = id;
				//			m.Add(s, o => {
				//				result = (int)o.Item.Tag;
				//				dispFrame.Continue=false;
				//			}).Tag = id;
			}
		}
		beforeShow?.Invoke(m);
		m.Show(owner, byCaret: byCaret, modal: true);
		//	m.IsOpen=true;
		//	Dispatcher.PushFrame(dispFrame);
		return result;
	}
	
	class _MenuItem : MenuItem {
		KWpfMenu _m;
		public Action<WpfMenuActionArgs> action;
		public bool actionException;
		
		public _MenuItem(KWpfMenu m) { _m = m; }
		
		protected override void OnClick() {
			base.OnClick(); //must be first, because changes IsChecked (if IsCheckable)
			
			_m._EndModal(); //workaround for: OnClosed called with 160 ms delay. Same with native message loop.
			if (action != null) {
				try { action(new WpfMenuActionArgs(this)); }
				catch (Exception ex) when (!actionException) { print.warning(ex); }
			}
		}
		
		protected override void OnPreviewMouseUp(MouseButtonEventArgs e) {
			switch (e.ChangedButton) {
			//case MouseButton.Right:
			//	if (this.HasItems && e.Source != this) break;
			//	e.Handled = true;
			//	break;
			case MouseButton.Middle:
				_m.IsOpen = false;
				break;
			}
			base.OnPreviewMouseUp(e);
		}
	}
}
//}

//namespace Au.Types
//{
/// <summary>
/// Arguments for <see cref="KWpfMenu"/> item actions.
/// </summary>
public class WpfMenuActionArgs {
	///
	public WpfMenuActionArgs(MenuItem item) { Item = item; }
	
	/// <summary>
	/// The menu item object.
	/// </summary>
	public MenuItem Item { get; }
	
	///
	public override string ToString() {
		var d = Item.Dispatcher;
		if (d.Thread == Thread.CurrentThread) return Item.Header.ToString();
		return d.Invoke(() => Item.Header.ToString());
	}
}

================================================
FILE: Au.Controls/Util, Api/HwndHostAccessibleBase_.cs
================================================
using System.Windows;
using IAccessible = Au.Types.Api.IAccessible;
using VarInt = Au.Types.Api.VarInt;
using NAVDIR = Au.Types.Api.NAVDIR;

namespace Au.Controls;

//public //if non-public, GetIDispatchForObject throws, and with GetIUnknownForObject does not work too.
//	See https://learn.microsoft.com/en-us/dotnet/standard/native-interop/qualify-net-types-for-interoperation.
//	But somehow works if implements IReflect, even if all functions just return default. Winforms use it.
//	Now with Cpp_AccWorkaround works without all that.
abstract class HwndHostAccessibleBase_ : IAccessible, IDisposable/*, IReflect*/
{
	FrameworkElement _e;
	wnd _w;
	
	/// <param name="e">HwndHost or its container control (if the HwndHost is part of the control).</param>
	/// <param name="w">Native control hosted by the HwndHost.</param>
	public HwndHostAccessibleBase_(FrameworkElement e, wnd w) {
		_e = e;
		_w = w;
	}
	
	IAccessible _StdAO {
		get {
			if (_stdAO == null) Api.CreateStdAccessibleObject(_w, EObjid.CLIENT, typeof(IAccessible).GUID, out _stdAO);
			return _stdAO;
			//note: not in ctor. It is called om WM_GETOBJECT, and CreateStdAccessibleObject sends WM_GETOBJECT too when called there (but not when called later).
		}
	}
	IAccessible _stdAO;
	
	public void Dispose() {
		if (_stdAO != null) {
			Marshal.ReleaseComObject(_stdAO);
			_stdAO = null;
		}
	}
	
	#region IAccessible
	
	IAccessible IAccessible.get_accParent() => _StdAO?.get_accParent();
	
	//Once was exception on process exit, while debugging. _StdAO returned null. Cannot reproduce. Replaced `.` with `?.` everywhere.
	//IAccessible IAccessible.get_accParent() {
	//	print.qm2.write("get_accParent");
	//	print.qm2.write(_w);
	//	print.qm2.write(_w.Get.DirectParent);
	//	print.qm2.write(new StackTrace(true));
	//	if (_StdAO is { } k) return k.get_accParent();
	//	return null;
	//}
	
	/// <summary>
	/// Returns 0.
	/// </summary>
	public virtual int ChildCount => 0;
	int IAccessible.get_accChildCount() => ChildCount;
	
	//[PreserveSig]
	int IAccessible.get_accChild(VarInt varChild, [MarshalAs(UnmanagedType.IDispatch)] out object ppdispChild) {
		ppdispChild = null;
		return 1;
		//currently this class supports only simple element children.
	}
	
	/// <summary>
	/// Returns FrameworkElement.Name.
	/// </summary>
	public virtual string Name(int child) => _e.Name;
	string IAccessible.get_accName(VarInt varChild) => Name(varChild);
	
	/// <summary>
	/// Returns null.
	/// </summary>
	public virtual string Value(int child) => null;
	string IAccessible.get_accValue(VarInt varChild) => Value(varChild);
	
	/// <summary>
	/// Returns null.
	/// </summary>
	public virtual string Description(int child) => null;
	string IAccessible.get_accDescription(VarInt varChild) => Description(varChild);
	
	public abstract ERole Role(int child);
	VarInt IAccessible.get_accRole(VarInt varChild) => (int)Role(varChild) - 1;
	
	/// <summary>
	/// If self (child -1), returns combination of FOCUSABLE, FOCUSED, DISABLED, INVISIBLE. Else returns 0.
	/// </summary>
	/// <param name="child"></param>
	/// <returns></returns>
	public virtual EState State(int child) {
		if (child != -1) return 0;
		EState r = 0;
		if (_e.Focusable) {
			r |= EState.FOCUSABLE;
			if (wnd.thisThread.isFocused(_w) || _e.IsKeyboardFocused) r |= EState.FOCUSED;
		}
		if (!_e.IsEnabled) r |= EState.DISABLED;
		if (!_e.IsVisible) r |= EState.INVISIBLE;
		return r;
	}
	VarInt IAccessible.get_accState(VarInt varChild) => (int)State(varChild) - 1;
	
	/// <summary>
	/// Returns null.
	/// </summary>
	public virtual string Help(int child) => null;
	string IAccessible.get_accHelp(VarInt varChild) => Help(varChild);
	
	int IAccessible.get_accHelpTopic(out string pszHelpFile, VarInt varChild) => throw new NotImplementedException();
	
	/// <summary>
	/// Returns null.
	/// </summary>
	public virtual string KeyboardShortcut(int child) => null;
	string IAccessible.get_accKeyboardShortcut(VarInt varChild) => KeyboardShortcut(varChild);
	
	/// <summary>
	/// Returns -1.
	/// Called only if the control is focused.
	/// </summary>
	public virtual int FocusedChild => -1;
	object IAccessible.get_accFocus() => wnd.thisThread.isFocused(_w) ? FocusedChild + 1 : null;
	//object IAccessible.get_accFocus() {
	//	print.it("get_accFocus", wnd.thisThread.isFocused(_w));//TODO3. Now this not called for KTreeView. The native control normally is never focused. IAccessible.get_accFocus called by QM2 returns unknown error 0x80131509.
	//	return wnd.thisThread.isFocused(_w) ? FocusedChild + 1 : null;
	//}
	
	/// <summary>
	/// Returns null.
	/// </summary>
	public virtual List<int> SelectedChildren => null;
	object IAccessible.get_accSelection() {
		var a = SelectedChildren;
		if (a.NE_()) return null;
		if (a.Count == 1) return a[0] + 1;
		return new _EnumSelected(a);
	}
	
	unsafe class _EnumSelected : IEnumVarInt {
		List<int> _a;
		int _i;
		public _EnumSelected(List<int> a) { _a = a; }
		
		public int Next(int celt, VarInt* rgVar, int* pCeltFetched) {
			int n = Math.Min(celt, _a.Count - _i);
			if (pCeltFetched != null) *pCeltFetched = n;
			for (int i = 0; i < n;) rgVar[i++] = _a[_i++];
			return n == celt ? 0 : 1;
		}
		
		public int Skip(int celt) {
			long i = (long)_i + (uint)celt;
			if (i > _a.Count) return 1;
			_i = (int)i;
			return 0;
		}
		
		public void Reset() { _i = 0; }
		
		public IEnumVarInt Clone() => throw new NotImplementedException();
	}
	
	[ComImport, Guid("00020404-0000-0000-C000-000000000046"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
	internal unsafe interface IEnumVarInt {
		[PreserveSig] int Next(int celt, VarInt* rgVar, int* pCeltFetched);
		[PreserveSig] int Skip(int celt);
		void Reset();
		IEnumVarInt Clone();
	}
	
	/// <summary>
	/// Returns null.
	/// </summary>
	public virtual string DefaultAction(int child) => null;
	string IAccessible.get_accDefaultAction(VarInt varChild) => DefaultAction(varChild);
	
	/// <summary>
	/// Does nothing.
	/// Not called for self.
	/// </summary>
	public virtual void SelectChild(ESelect flagsSelect, int child) { }
	void IAccessible.accSelect(ESelect flagsSelect, VarInt varChild) {
		int child = varChild;
		if (flagsSelect.Has(ESelect.TAKEFOCUS)) Api.SetFocus(_w); // _e.Focus();//TODO3: now Api.SetFocus makes KTreeView item nonfocused (works like focused but displayed like not)
		if (child == -1) {
			if (flagsSelect is not (ESelect.TAKEFOCUS or 0)) throw new ArgumentException();
		} else {
			SelectChild(flagsSelect, child);
		}
	}
	
	/// <summary>
	/// Returns default.
	/// Return child rect in client area.
	/// Not called for self.
	/// </summary>
	public virtual RECT ChildRect(int child) => default;
	void IAccessible.accLocation(out int pxLeft, out int pyTop, out int pcxWidth, out int pcyHeight, VarInt varChild) {
		int child = varChild;
		if (child == -1) {
			pxLeft = pyTop = pcxWidth = pcyHeight = 0;
			_StdAO?.accLocation(out pxLeft, out pyTop, out pcxWidth, out pcyHeight, varChild);
		} else {
			var r = ChildRect(child);
			_w.MapClientToScreen(ref r);
			pxLeft = r.left; pyTop = r.top; pcxWidth = r.Width; pcyHeight = r.Height;
		}
	}
	
	/// <summary>
	/// Returns null.
	/// If self (childStart==-1), navDir is FIRSTCHILD or LASTCHILD, else navDir is any except these.
	/// </summary>
	public virtual int? Navigate(NAVDIR navDir, int childStart) => null;
	object IAccessible.accNavigate(NAVDIR navDir, VarInt varStart) {
		int i = varStart;
		if (navDir == NAVDIR.FIRSTCHILD || navDir == NAVDIR.LASTCHILD) {
			if (i != -1) return null;
		} else {
			if (i == -1) return _StdAO?.accNavigate(navDir, varStart); //never mind: gets some not adjacent UI element
		}
		var v = Navigate(navDir, i);
		if (v == null) return null;
		return v.Value + 1;
	}
	
	/// <summary>
	/// Returns -1.
	/// x y are in client area.
	/// Not called if not in client area.
	/// </summary>
	public virtual int HitTest(int x, int y) => -1;
	VarInt IAccessible.accHitTest(int xLeft, int yTop) {
		POINT p = (xLeft, yTop); _w.MapScreenToClient(ref p);
		if (_w.ClientRect.Contains(p)) return HitTest(p.x, p.y);
		if (_StdAO is { } k) return k.accHitTest(xLeft, yTop);
		return default;
	}
	
	/// <summary>
	/// Does nothing.
	/// </summary>
	public virtual void DoDefaultAction(int child) { }
	void IAccessible.accDoDefaultAction(VarInt varChild) => DoDefaultAction(varChild);
	
	void IAccessible.put_accName(VarInt varChild, string szName) { }
	
	void IAccessible.put_accValue(VarInt varChild, string szValue) { }
	
	#endregion
	
	
	//#region IReflect
	
	//FieldInfo IReflect.GetField(string name, BindingFlags bindingAttr) => null;
	//FieldInfo[] IReflect.GetFields(BindingFlags bindingAttr) => null;
	//MemberInfo[] IReflect.GetMember(string name, BindingFlags bindingAttr) => null;
	//MemberInfo[] IReflect.GetMembers(BindingFlags bindingAttr) => null;
	//MethodInfo IReflect.GetMethod(string name, BindingFlags bindingAttr) => null;
	//MethodInfo IReflect.GetMethod(string name, BindingFlags bindingAttr, Binder binder, Type[] types, ParameterModifier[] modifiers) => null;
	//MethodInfo[] IReflect.GetMethods(BindingFlags bindingAttr) => null;
	//PropertyInfo[] IReflect.GetProperties(BindingFlags bindingAttr) => null;
	//PropertyInfo IReflect.GetProperty(string name, BindingFlags bindingAttr) => null;
	//PropertyInfo IReflect.GetProperty(string name, BindingFlags bindingAttr, Binder binder, Type returnType, Type[] types, ParameterModifier[] modifiers) => null;
	//object IReflect.InvokeMember(string name, BindingFlags invokeAttr, Binder binder, object target, object[] args, ParameterModifier[] modifiers, System.Globalization.CultureInfo culture, string[] namedParameters) => null;
	//Type IReflect.UnderlyingSystemType => null;
	
	//#endregion
	
	/// <summary>
	/// Call in hook wndproc on WM_GETOBJECT like this: <c>handled = true; return (_acc ??= new _Accessible(this)).WmGetobject(wParam, lParam);</c>.
	/// If lParam is EObjid.CLIENT, calls API LresultFromObject(this), else calls API DefWindowProc.
	/// </summary>
	public nint WmGetobject(nint wParam, nint lParam) {
		var oid = (EObjid)lParam;
		//print.it(oid);
		if (oid != EObjid.CLIENT) return Api.DefWindowProc(_w, Api.WM_GETOBJECT, wParam, lParam);
		
		return Cpp.Cpp_AccWorkaround(this, wParam, ref _accWorkaround);
		
		//cannot use this because of .NET bug: then calls our IAccessible implementation methods in other thread.
		//var accIP = Marshal.GetIUnknownForObject(this);
		////var accIP=Marshal.GetIDispatchForObject(this);
		//var r = Api.LresultFromObject(typeof(IAccessible).GUID, wParam, accIP);
		////Marshal.AddRef(accIP); print.it(Marshal.Release(accIP));
		//Marshal.Release(accIP);
		//return r;
	}
	nint _accWorkaround;
	
	~HwndHostAccessibleBase_() { if (_accWorkaround != 0) Cpp.Cpp_AccWorkaround(null, 0, ref _accWorkaround); }
	
}


================================================
FILE: Au.Controls/Util, Api/KApi.cs
================================================
namespace Au.Controls;

[DebuggerStepThrough]
static unsafe class KApi {
	
	[DllImport("user32.dll")]
	internal static extern bool DrawFrameControl(IntPtr hdc, in RECT r, int type, int state);
	
	
}



================================================
FILE: Au.Controls/Util, Api/KExtWpf.cs
================================================
using System.Windows;
using System.Windows.Controls;
using System.Windows.Controls.Primitives;
using System.Windows.Data;
using System.Windows.Input;

namespace Au.Controls;

/// <summary>
/// Extension methods for dialogs.
/// </summary>
public static class KExtWpf {
	/// <summary>
	/// Adds KCheckBox, CheckBox or RadioButton that can be used with TextBox in a propertygrid row. Or alone in a grid or stack row.
	/// </summary>
	/// <param name="b"></param>
	/// <param name="c"></param>
	/// <param name="name">Checkbox text.</param>
	/// <param name="noR">Don't add new row.</param>
	/// <param name="check">Checkbox state.</param>
	public static wpfBuilder xAddCheck<T>(this wpfBuilder b, out T c, string name, bool noR = false, bool check = false) where T : ToggleButton, new() {
		if (!noR && b.Panel is Grid) b.Row(0);
		b.Add<T>(out c, name).Height(18);
		if (check) b.Checked();
		return b;
	}
	
	/// <summary>
	/// Adds KTextBox that can be used with KCheckBox in a propertygrid row. Or alone in a grid or stack row.
	/// Sets multiline with limited height. If in grid, sets padding/margin for propertygrid.
	/// </summary>
	public static wpfBuilder xAddText<TTBox>(this wpfBuilder b, out TTBox t, string text = null) where TTBox : KTextBox, new() {
		b.Add(out t, text).Multiline(..55, wrap: TextWrapping.NoWrap);
		if (b.Panel is Grid) b.Padding(new Thickness(0, 0, 0, 1)).Margin(left: 4);
		return b;
	}
	
	/// <summary>
	/// Adds KCheckBox (<see cref="xAddCheck"/>) and multiline KTextBox (<see cref="xAddText"/>) in a propertygrid row.
	/// </summary>
	/// <param name="b"></param>
	/// <param name="name">Checkbox text.</param>
	/// <param name="text">Textbox text.</param>
	/// <param name="noR">Don't add new row.</param>
	/// <param name="check">Checkbox state.</param>
	public static KCheckTextBox xAddCheckText<TTBox>(this wpfBuilder b, string name, string text = null, bool noR = false, bool check = false) where TTBox : KTextBox, new() {
		xAddCheck(b, out KCheckBox c, name, noR, check);
		var m = c.Margin; if (m.Top <= 1) c.Margin = m with { Top = m.Top + 1 };
		xAddText(b, out TTBox t, text);
		return new(c, t);
	}
	
	/// <inheritdoc cref="xAddCheckText{TTBox}(wpfBuilder, string, string, bool, bool)"/>
	public static KCheckTextBox xAddCheckText(this wpfBuilder b, string name, string text = null, bool noR = false, bool check = false)
		=> xAddCheckText<KTextBox>(b, name, text, noR, check);
	
	/// <summary>
	/// Adds KCheckBox (<see cref="xAddCheck"/>) and multiline KTextBox (<see cref="xAddText"/>) in a propertygrid row.
	/// Also adds ▾ button that shows a drop-down list (see <see cref="KCheckTextBox.Set(bool, string, List{string})"/>).
	/// Unlike ComboBox, text can be multiline and isn't selected when receives focus.
	/// </summary>
	/// <param name="b"></param>
	/// <param name="name">Checkbox text.</param>
	/// <param name="text">Textbox text.</param>
	/// <param name="check">Checkbox state.</param>
	public static KCheckTextBox xAddCheckTextDropdown<TTBox>(this wpfBuilder b, string name, string text = null, bool check = false) where TTBox : KTextBox, new() {
		xAddCheck(b, out KCheckBox c, name, check: check);
		xAddText(b, out TTBox t, text);
		b.And(14).Add(out Button k, "▾").Padding(new Thickness(0)).Border(); //tested: ok on Win7
		k.Width += 4;
		return new(c, t, k);
	}
	
	/// <inheritdoc cref="xAddCheckTextDropdown{TTBox}(wpfBuilder, string, string, bool)"/>
	public static KCheckTextBox xAddCheckTextDropdown(this wpfBuilder b, string name, string text = null, bool check = false)
		=> xAddCheckTextDropdown<KTextBox>(b, name, text, check);
	
	/// <summary>
	/// Adds KCheckBox (<see cref="xAddCheck"/>) and readonly ComboBox (<see cref="xAddOther"/>) in a propertygrid row.
	/// </summary>
	/// <param name="b"></param>
	/// <param name="name">Checkbox text.</param>
	/// <param name="items">Combobox items like "One|Two".</param>
	/// <param name="index">Combobox selected index.</param>
	public static KCheckComboBox xAddCheckCombo(this wpfBuilder b, string name, string items, int index = 0) {
		xAddCheck(b, out KCheckBox c, name);
		xAddOther(b, out ComboBox t);
		if (!items.NE()) {
			b.Items(items);
			if (index != 0) t.SelectedIndex = index;
		}
		return new(c, t);
	}
	
	/// <summary>
	/// Adds any control that can be used in a propertygrid row.
	/// </summary>
	public static wpfBuilder xAddOther<T>(this wpfBuilder b, out T other, string text = null, string label = null) where T : FrameworkElement, new() {
		if (label != null) b.xAddOther(out TextBlock _, label);
		b.Add(out other, text);
		_xSetOther(b, other);
		return b;
	}
	
	static void _xSetOther(wpfBuilder b, FrameworkElement e) {
		b.Height(19).Margin(left: 4);
		if (e is Control) b.Padding(e is ComboBox ? new Thickness(4, 1, 4, 0) : new Thickness(4, 0, 4, 0)); //tested with Button and ComboBox
	}
	
	/// <summary>
	/// Adds button that can be used in a propertygrid row.
	/// </summary>
	public static wpfBuilder xAddButton(this wpfBuilder b, out Button button, string text, Action<WBButtonClickArgs> click) {
		b.AddButton(out button, text, click);
		_xSetOther(b, button);
		return b;
	}
	
	/// <summary>
	/// Adds button that can be used in a propertygrid row.
	/// </summary>
	public static wpfBuilder xAddButton(this wpfBuilder b, string text, Action<WBButtonClickArgs> click) => xAddButton(b, out _, text, click);
	
	/// <summary>
	/// Adds KCheckBox (<see cref="xAddCheck"/>) and other control (<see cref="xAddOther"/>) in a propertygrid row.
	/// </summary>
	/// <param name="name">Checkbox text.</param>
	/// <param name="text">Text of other control.</param>
	public static wpfBuilder xAddCheckAnd<T>(this wpfBuilder b, out KCheckBox r, string name, out T other, string text = null) where T : FrameworkElement, new() {
		xAddCheck(b, out r, name);
		xAddOther(b, out other, text);
		return b;
	}
	
	/// <summary>
	/// Adds Border with standard thickness/color and an element in it.
	/// </summary>
	public static Border xAddInBorder<T>(this wpfBuilder b, out T var, string margin = null, Thickness? thickness = null) where T : FrameworkElement, new() {
		b.Add(out Border c).Border(thickness2: thickness);
		if (margin != null) b.Margin(margin);
		b.Child().Add(out var);
		return c;
	}
	
	/// <summary>
	/// Adds Border with standard thickness/color and an element in it.
	/// </summary>
	public static Border xAddInBorder(this wpfBuilder b, FrameworkElement e, string margin = null, Thickness? thickness = null) {
		b.Add(out Border c).Border(thickness2: thickness);
		if (margin != null) b.Margin(margin);
		b.Child().Add(e);
		return c;
	}
	
	/// <summary>
	/// Adds KCheckBox with icon like in a toolbar.
	/// </summary>
	public static wpfBuilder xAddCheckIcon(this wpfBuilder b, out KCheckBox r, string icon, string tooltip, Action checkChanged = null) {
		b.Add(out r, ImageUtil.LoadWpfImageElement(icon)).Tooltip(tooltip);
		r.Style = b.Panel.FindResource(ToolBar.CheckBoxStyleKey) as Style;
		r.Focusable = false;
		if (checkChanged != null) r.CheckChanged += (_, _) => checkChanged();
		//var p = (r.Content as Viewbox).Child as System.Windows.Shapes.Path;
		//r.Checked += (_, _) => p.Fill.Opacity = 1;
		//r.Unchecked += (_, _) => p.Fill.Opacity = 0.3;
		return b;
	}
	
	/// <summary>
	/// Adds Button with icon like in a toolbar.
	/// </summary>
	public static wpfBuilder xAddButtonIcon(this wpfBuilder b, out Button r, string icon, Action<WBButtonClickArgs> click, string tooltip) {
		b.AddButton(out r, ImageUtil.LoadWpfImageElement(icon), click).Tooltip(tooltip);
		r.Style = b.Panel.FindResource(ToolBar.ButtonStyleKey) as Style;
		r.Focusable = false;
		return b;
	}
	
	/// <summary>
	/// Adds Button with icon like in a toolbar.
	/// </summary>
	public static wpfBuilder xAddButtonIcon(this wpfBuilder b, string icon, Action<WBButtonClickArgs> click, string tooltip)
		=> xAddButtonIcon(b, out _, icon, click, tooltip);
	
	/// <summary>
	/// Adds <b>Grid</b> with two horizontal separators and <b>TextBlock</b>.
	/// Looks almost like <see cref="KGroupBoxSeparator"/>, but is not inside a GroupBox+Panel.
	/// </summary>
	/// <param name="text">String (to add new <b>TextBlock</b>) or <b>FrameworkElement</b> (probably <b>TextBlock</b>).</param>
	public static wpfBuilder xAddGroupSeparator(this wpfBuilder b, object text, bool center = false) {
		b.StartGrid().Columns(center ? -1 : 10, 0, -1);
		b.AddSeparator(vertical: false).Margin(right: 0);
		Debug.Assert(text is string or FrameworkElement);
		if (text is string s) {
			b.Add<TextBlock>(s).Margin(left: 3, right: 4).Font(bold: true);
		} else if (text is FrameworkElement e) {
			b.Add(e);
		}
		b.AddSeparator(vertical: false).Margin(left: 0);
		b.End();
		return b;
	}
	
	public static ToolBar xAddToolBar(this wpfBuilder t, bool vertical = false, bool hideOverflow = false, bool controlBrush = false) {
		var tt = new ToolBarTray { IsLocked = true };
		if (vertical) tt.Orientation = Orientation.Vertical;
		var tb = new ToolBar();
		if (controlBrush) {
			tt.Background = SystemColors.ControlBrush;
			tb.Background = SystemColors.ControlBrush;
		}
		KeyboardNavigation.SetTabNavigation(tb, KeyboardNavigationMode.Once);
		tt.ToolBars.Add(tb);
		if (hideOverflow) tb.HideGripAndOverflow(false);
		t.Add(tt);
		return tb;
	}
	
	/// <summary>
	/// Adds a toolbar button with icon and tooltip.
	/// </summary>
	/// <param name="click">Can be null.</param>
	/// <param name="padding">Set <c>Padding = new(4, 2, 4, 2)</c>.</param>
	public static Button AddButton(this ToolBar t, string icon, Action<Button> click, string tooltip, bool enabled = true, bool padding = true) {
		var c = new Button { Content = ImageUtil.LoadWpfImageElement(icon), ToolTip = tooltip };
		if (click != null) c.Click += (_, _) => click(c);
		if (padding) c.Padding = new(4, 2, 4, 2);
		if (!enabled) c.IsEnabled = false;
		t.Items.Add(c);
		return c;
	}
	
	/// <summary>
	/// Adds a toolbar checkbox with icon and tooltip.
	/// </summary>
	/// <param name="padding">Set <c>Padding = new(4, 2, 4, 2)</c>.</param>
	public static KCheckBox AddCheckbox(this ToolBar t, string icon, string tooltip, bool enabled = true, bool padding = true) {
		var c = new KCheckBox { Content = ImageUtil.LoadWpfImageElement(icon), ToolTip = tooltip };
		c.Style = t.FindResource(ToolBar.CheckBoxStyleKey) as Style; //need because this is KCheckBox, not CheckBox
		if (padding) c.Padding = new(4, 2, 4, 2);
		if (!enabled) c.IsEnabled = false;
		t.Items.Add(c);
		return c;
	}
	
	/// <summary>
	/// Adds <b>MouseRightButtonDown</b> event handler which shows a context menu.
	/// </summary>
	/// <param name="t"></param>
	/// <param name="fill">Let it fill the menu.</param>
	public static void xContextMenu(this ButtonBase t, Action<popupMenu> fill) {
		t.MouseRightButtonDown += (_, _) => {
			var m = new popupMenu();
			fill(m);
			m.Show(owner: t);
			//var r = t.RectInScreen();
			//m.Show(xy: new(r.left, r.bottom), excludeRect: r, owner: t);
		};
	}
	
	/// <summary>
	/// Adds <b>Click</b> event handler which shows a drop-down menu.
	/// </summary>
	/// <param name="t"></param>
	/// <param name="fill">Let it fill the menu.</param>
	public static void xDropdownMenu(this ButtonBase t, Action<popupMenu> fill) {
		t.Click += (_, _) => {
			var m = new popupMenu();
			fill(m);
			var r = t.RectInScreen();
			m.Show(xy: new(r.left, r.bottom), excludeRect: r, owner: t);
		};
	}
	
	/// <summary>
	/// Adds ScrollViewer, adds 2-column grid or vertical stack panel in it (StartGrid, StartStack), and calls <c>Options(modifyPadding: false, margin: new(1))</c>.
	/// </summary>
	public static ScrollViewer xStartPropertyGrid(this wpfBuilder b, string margin = null, bool stack = false) {
		b.Add(out ScrollViewer v);
		if (margin != null) b.Margin(margin);
		v.VerticalScrollBarVisibility = ScrollBarVisibility.Auto;
		v.FocusVisualStyle = null;
		if (stack) b.StartStack(vertical: true, childOfLast: true); else b.StartGrid(childOfLast: true);
		b.Options(modifyPadding: false, margin: new(1));
		return v;
	}
	
	/// <summary>
	/// Ends grid/stack set by <see cref="xStartPropertyGrid"/> and restores options.
	/// </summary>
	/// <param name="b"></param>
	public static void xEndPropertyGrid(this wpfBuilder b) {
		b.Options(modifyPadding: true, margin: new Thickness(3));
		b.End();
	}
	
	/// <summary>
	/// Sets header control properties: center, bold.
	/// It can be Label, TextBlock or CheckBox. Not tested others.
	/// </summary>
	public static void xSetHeaderProp(this wpfBuilder b) {
		//b.Font(bold: true).Brush(foreground: SystemColors.ControlDarkDarkBrush).Align("C");
		b.Font(bold: true).Align("C");
	}
	//public static void xSetHeaderProp(this wpfBuilder b, bool vertical = false) {
	//	b.Font(bold: true).Brush(foreground: SystemColors.ControlDarkDarkBrush);
	//	if (vertical) {
	//		b.Align(y: "C");
	//		b.Last.LayoutTransform = new RotateTransform(270d);
	//	} else {
	//		b.Align("C");
	//	}
	//}
	
	/// <summary>
	/// Adds vertical splitter.
	/// </summary>
	public static void xAddSplitterV(this wpfBuilder b, int span = 1, double thickness = 4) {
		b.Add<GridSplitter2>().Splitter(true, span, thickness);
	}
	
	/// <summary>
	/// Adds horizontal splitter.
	/// </summary>
	public static void xAddSplitterH(this wpfBuilder b, int span = 1, double thickness = 4) {
		b.R.Add<GridSplitter2>().Splitter(false, span, thickness);
	}
	
	/// <summary>
	/// Adds <b>TextBlock</b> with green background, wrapping and some padding, and calls <see cref="wpfBuilder.FormatText"/>.
	/// </summary>
	/// <inheritdoc cref="wpfBuilder.FormatText(wpfBuilder.InterpolatedString)" path="/param"/>
	public static wpfBuilder xAddInfoBlockF(this wpfBuilder t, wpfBuilder.InterpolatedString text, bool scrollViewer = false) {
		var r = t.xAddInfoBlockT(null, scrollViewer);
		t.FormatText(text);
		return r;
	}
	
	/// <summary>
	/// Adds <b>TextBlock</b> with green background, wrapping and some padding.
	/// </summary>
	public static wpfBuilder xAddInfoBlockT(this wpfBuilder t, string text, bool scrollViewer = false) //not overload. Somehow then it is used with $"string" too.
		=> xAddInfoBlockT(t, out _, text, scrollViewer);
	
	/// <summary>
	/// Adds <b>TextBlock</b> with green background, wrapping and some padding.
	/// </summary>
	public static wpfBuilder xAddInfoBlockT(this wpfBuilder t, out TextBlock r, string text = null, bool scrollViewer = false) {
		if (scrollViewer) t.Add(new ScrollViewer { VerticalScrollBarVisibility = ScrollBarVisibility.Auto }).Child();
		return t.Add(out r, text).Wrap().Brush(WpfUtil_.IsHighContrastDark ? 0x2E4D00 : 0xf8fff0).Padding(2, 1, 2, 2);
	}
	
	/// <summary>
	/// Adds icon-button "Help" for a control.
	/// </summary>
	public static wpfBuilder xAddControlHelpButton(this wpfBuilder t, Action<WBButtonClickArgs> click, string tooltip = null) {
		return xAddButtonIcon(t, "*Material.HelpCircleOutline #4080FF|#99CCFF", click, tooltip).Margin(0);
	}
	
	/// <summary>
	/// Adds icon-button "Help" for a control. On click calls <see cref="HelpUtil.AuHelp"/> with <i>helpTopic</i>.
	/// </summary>
	public static wpfBuilder xAddControlHelpButton(this wpfBuilder t, string helpTopic, string tooltip = null)
		=> xAddControlHelpButton(t, _ => HelpUtil.AuHelp(helpTopic), tooltip);
	
	/// <summary>
	/// Adds icon-button "Help" for a dialog window. On click or F1 calls <i>clickF1</i>.
	/// </summary>
	public static wpfBuilder xAddDialogHelpButtonAndF1(this wpfBuilder t, Action clickF1) {
		t.Window.PreviewKeyDown += (_, e) => {
			if (e.Key == Key.F1 && Keyboard.Modifiers == 0) {
				clickF1();
				e.Handled = true;
			}
		};
		return xAddButtonIcon(t, "*Material.HelpBox #4080FF|#99CCFF", _ => clickF1(), "Help (F1)").Width(24).Margin(20);
	}
	
	/// <summary>
	/// Adds icon-button "Help" for a dialog window. On click or F1 calls <see cref="HelpUtil.AuHelp"/> with <i>helpTopic</i>.
	/// </summary>
	public static wpfBuilder xAddDialogHelpButtonAndF1(this wpfBuilder t, string helpTopic)
		=> xAddDialogHelpButtonAndF1(t, () => HelpUtil.AuHelp(helpTopic));
	
	/// <summary>
	/// Can be used like <see cref="wpfBuilder.Validation"/> with hotkey <b>TextBox</b> controls.
	/// </summary>
	public static wpfBuilder xValidateHotkey(this wpfBuilder b, bool errorIfEmpty = false) {
		return b.Validation(e => {
			var s = (e as TextBox).Text;
			if (!errorIfEmpty && s.NE()) return null;
			if (keys.more.parseHotkeyString(s, out _, out _)) return null;
			return "Invalid hotkey";
		});
	}
	
	/// <summary>
	/// Sets binding to show/hide the last added element when the specified <b>CheckBox</b> checked/unchecked.
	/// </summary>
	public static wpfBuilder xBindCheckedVisible(this wpfBuilder t, CheckBox c, bool setLabeledBy = false) {
		t.Bind(FrameworkElement.VisibilityProperty, new Binding("IsChecked") { Source = c, Converter = s_bvc ??= new() });
		if (setLabeledBy) {
			Debug.Assert(!(t.Last is ButtonBase or Label or TextBlock));
			System.Windows.Automation.AutomationProperties.SetLabeledBy(t.Last, c);
		}
		return t;
	}
	static BooleanToVisibilityConverter s_bvc;
	
	/// <summary>
	/// Sets binding to enable/disable the last added element when the specified <b>CheckBox</b> checked/unchecked.
	/// </summary>
	public static wpfBuilder xBindCheckedEnabled(this wpfBuilder t, CheckBox c, bool setLabeledBy = false) {
		t.Bind(FrameworkElement.IsEnabledProperty, new Binding("IsChecked") { Source = c });
		if (setLabeledBy) {
			Debug.Assert(!(t.Last is ButtonBase or Label or TextBlock));
			System.Windows.Automation.AutomationProperties.SetLabeledBy(t.Last, c);
		}
		return t;
	}
	
	/// <summary>
	/// Calls <b>DockPanel.SetDock</b> and <c>t.Children.Add</c>.
	/// </summary>
	public static void xAddDocked(this DockPanel t, UIElement e, Dock dock) {
		DockPanel.SetDock(e, dock);
		t.Children.Add(e);
	}
	
	/// <summary>
	/// Adds standard <c>Cut Copy Paste</c> items to the <c>ContextMenu</c> of this <c>TextBox</c>.
	/// On <c>ContextMenuOpening</c> enables/disables items depending on the state of the <c>TextBox</c> control and clipboard.
	/// Creates/sets new context menu if it's <c>null</c>.
	/// </summary>
	/// <returns>The context menu.</returns>
	public static ContextMenu xAddCutCopyPasteToContextMenu(this TextBox t, bool addClear, bool setStateNow) {
		var m = t.ContextMenu ??= new();
		
		var cut = m.xAdd("Cut", "Ctrl+X", (_, _) => t.Cut(), false);
		var copy = m.xAdd("Copy", "Ctrl+C", (_, _) => t.Copy(), false);
		var paste = m.xAdd("Paste", "Ctrl+V", (_, _) => t.Paste(), false);
		if (addClear) m.xAdd("Clear", "M-click", (_, _) => t.Clear());
		
		t.ContextMenuOpening += _t_ContextMenuOpening;
		if (setStateNow) _t_ContextMenuOpening(null, null);
		
		void _t_ContextMenuOpening(object sender, ContextMenuEventArgs e) {
			cut.IsEnabled = t.SelectionLength > 0 && !t.IsReadOnly;
			copy.IsEnabled = t.SelectionLength > 0;
			paste.IsEnabled = !t.IsReadOnly && Clipboard.ContainsText();
		}
		
		return m;
	}
	
	/// <summary>
	/// Adds new menu item.
	/// </summary>
	/// <param name="t"></param>
	/// <param name="name"></param>
	/// <param name="hotkey"></param>
	/// <param name="click"></param>
	/// <param name="enabled"></param>
	/// <returns></returns>
	public static MenuItem xAdd(this ContextMenu t, string name, string hotkey, RoutedEventHandler click, bool enabled = true) {
		var k = new MenuItem { Header = name, InputGestureText = hotkey, IsEnabled = enabled };
		k.Click += click;
		t.Items.Add(k);
		return k;
	}
	
	/// <summary>
	/// Adds new separator.
	/// </summary>
	public static void xAddSeparator(this ContextMenu t) {
		t.Items.Add(new Separator());
	}
}


================================================
FILE: Au.Controls/Util, Api/KImageUtil.cs
================================================
using System.Drawing;
using System.Drawing.Imaging;

namespace Au.Controls;

#pragma warning disable 649

public static unsafe class KImageUtil {
	#region API
	
	[StructLayout(LayoutKind.Sequential, Pack = 2)]
	internal struct BITMAPFILEHEADER {
		public ushort bfType;
		public int bfSize;
		public ushort bfReserved1;
		public ushort bfReserved2;
		public int bfOffBits;
	}
	
	internal struct BITMAPCOREHEADER {
		public int bcSize;
		public ushort bcWidth;
		public ushort bcHeight;
		public ushort bcPlanes;
		public ushort bcBitCount;
	}
	
	internal struct BITMAPV5HEADER {
		public int bV5Size;
		public int bV5Width;
		public int bV5Height;
		public ushort bV5Planes;
		public ushort bV5BitCount;
		public int bV5Compression;
		public int bV5SizeImage;
		public int bV5XPelsPerMeter;
		public int bV5YPelsPerMeter;
		public int bV5ClrUsed;
		public int bV5ClrImportant;
		public uint bV5RedMask;
		public uint bV5GreenMask;
		public uint bV5BlueMask;
		public uint bV5AlphaMask;
		public uint bV5CSType;
		public CIEXYZTRIPLE bV5Endpoints;
		public uint bV5GammaRed;
		public uint bV5GammaGreen;
		public uint bV5GammaBlue;
		public uint bV5Intent;
		public uint bV5ProfileData;
		public uint bV5ProfileSize;
		public uint bV5Reserved;
	}
	
	internal struct CIEXYZTRIPLE {
		public CIEXYZ ciexyzRed;
		public CIEXYZ ciexyzGreen;
		public CIEXYZ ciexyzBlue;
	}
	
	internal struct CIEXYZ {
		public int ciexyzX;
		public int ciexyzY;
		public int ciexyzZ;
	}
	
	#endregion
	
	internal struct BitmapFileInfo_ {
		/// <summary>
		/// Can be BITMAPINFOHEADER/BITMAPV5HEADER or BITMAPCOREHEADER.
		/// </summary>
		public void* biHeader;
		public int width, height, bitCount;
		public bool isCompressed;
	}
	
	/// <summary>
	/// Gets some info from BITMAPINFOHEADER or BITMAPCOREHEADER.
	/// Checks if it is valid bitmap file header. Returns false if invalid.
	/// </summary>
	internal static bool GetBitmapFileInfo_(byte[] mem, out BitmapFileInfo_ x) {
		x = new BitmapFileInfo_();
		fixed (byte* bp = mem) {
			BITMAPFILEHEADER* f = (BITMAPFILEHEADER*)bp;
			int minHS = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPCOREHEADER);
			if (mem.Length <= minHS || f->bfType != (((byte)'M' << 8) | (byte)'B') || f->bfOffBits >= mem.Length || f->bfOffBits < minHS)
				return false;
			
			Api.BITMAPINFOHEADER* h = (Api.BITMAPINFOHEADER*)(f + 1);
			int siz = h->biSize;
			if (siz >= sizeof(Api.BITMAPINFOHEADER) && siz <= sizeof(BITMAPV5HEADER) * 2) {
				x.width = h->biWidth;
				x.height = h->biHeight;
				x.bitCount = h->biBitCount;
				x.isCompressed = h->biCompression != 0;
			} else if (siz == sizeof(BITMAPCOREHEADER)) {
				BITMAPCOREHEADER* ch = (BITMAPCOREHEADER*)h;
				x.width = ch->bcWidth;
				x.height = ch->bcHeight;
				x.bitCount = ch->bcBitCount;
			} else return false;
			
			//x.height = Math.Abs(x.height); //no, then draws incorrectly if top-down
			if (x.height <= 0) return false; //rare
			
			x.biHeader = h;
			return true;
			//note: don't check f->bfSize. Sometimes it is incorrect (> or < memSize). All programs open such files. Instead check other data later.
		}
	}
	
	/// <summary>
	/// Image type detected by <see cref="ImageTypeFromString(out int, string)"/>.
	/// </summary>
	public enum ImageType {
		/// <summary>The string isn't image.</summary>
		None,
		
		/// <summary>Base64 encoded image file data with prefix "image:" (.png/gif/jpg) or "image:WkJN" (compressed .bmp). See <see cref="ImageToString(string)"/>.</summary>
		Base64Image,
		
		/// <summary>.bmp file path.</summary>
		Bmp,
		
		/// <summary>.png, .gif or .jpg file path.</summary>
		PngGifJpg,
		
		/// <summary>.ico file path.</summary>
		Ico,
		
		/// <summary>.cur or .ani file path.</summary>
		Cur,
		
		/// <summary>Icon from a .dll or other file containing icons, like @"C:\a\b.dll,15".</summary>
		IconLib,
		
		/// <summary>None of other image types.</summary>
		ShellIcon,
		
		/// <summary>XAML image data.</summary>
		Xaml,
		
		/// <summary>XAML icon name "*Pack.Icon color".</summary>
		XamlIconName,
		
		//rejected. Where it used, we cannot know the assembly; maybe it is script's assembly and in editor we cannot get its resources or it is difficult (need to use meta).
		///// <summary>"resource:name". An image resource name from managed resources of the entry assembly. In Visual Studio use build action "Resource".</summary>
		//Resource,
	}
	
	/// <summary>
	/// Gets image type from string.
	/// </summary>
	/// <param name="prefixLength">Length of prefix "imagefile:" or "image:".</param>
	/// <param name="s">File path etc. See <see cref="ImageType"/>. It is UTF-8 because used directly with Scintilla text.</param>
	internal static ImageType ImageTypeFromString(out int prefixLength, RByte s) {
		prefixLength = 0;
		if (s.Length < 2) return default; //C:\x.bmp or .h
		char c1 = (char)s[0], c2 = (char)s[1];
		
		//special strings
		switch (c1) {
		case 'i':
			if (s.StartsWith("image:"u8)) {
				if (s.Length < 10) return default;
				prefixLength = 6;
				return ImageType.Base64Image;
			}
			if (s.StartsWith("imagefile:"u8)) {
				s = s[10..];
				if (s.Length < 8) return default;
				prefixLength = 10;
				c1 = (char)s[0]; c2 = (char)s[1];
			}
			break;
		//case 'r': if (s.StartsWith("resource:"u8)) return ImageType.Resource; break;
		case '<':
			if (s.IndexOf("xmlns='http://schemas.microsoft.com/winfx/2006/xaml/presentation'"u8) > 0) {
				if (s.IndexOf("<Path "u8) >= 0) return ImageType.Xaml;
				if (s.IndexOf("<GeometryDrawing "u8) >= 0) return ImageType.Xaml;
			}
			return default;
		case '*':
			if (_DetectIconString(s)) return ImageType.XamlIconName;
			return default;
		}
		
		//file path
		if (s.Length >= 8 && (c1 == '%' || (c2 == ':' && c1.IsAsciiAlpha()) || (c1 == '\\' && c2 == '\\'))) { //is image file path?
			if (s[^4] == '.') {
				Span<byte> e = stackalloc byte[3];
				for (int j = 0, k = s.Length - 3; j < 3;) e[j++] = (byte)char.ToLowerInvariant((char)s[k++]);
				if (e.SequenceEqual("bmp"u8)) return ImageType.Bmp;
				if (e.SequenceEqual("png"u8)) return ImageType.PngGifJpg;
				if (e.SequenceEqual("gif"u8)) return ImageType.PngGifJpg;
				if (e.SequenceEqual("jpg"u8)) return ImageType.PngGifJpg;
				if (e.SequenceEqual("ico"u8)) return ImageType.Ico;
				if (e.SequenceEqual("cur"u8)) return ImageType.Cur;
				if (e.SequenceEqual("ani"u8)) return ImageType.Cur;
			} else if (((char)s[^1]).IsAsciiDigit()) { //can be like C:\x.dll,10
				int i = s.LastIndexOf((byte)',');
				if (i >= 8 && s[i - 4] == '.' && char.IsAsciiLetter((char)s[i - 1])) {
					if (s[++i] == '-') i++;
					if (!s[i..].ContainsAnyExceptInRange((byte)'0', (byte)'9')) return ImageType.IconLib;
				}
			}
		}
		
		return ImageType.ShellIcon; //can be other file type, URL, .ext, :: ITEMIDLIST, ::{CLSID}
		
		//copied from WpfUtil_.DetectIconString(RStr)
		static bool _DetectIconString(RByte s) {
			if (s.Length < 8 || s[0] != '*') return false;
			int pack = 1;
			if (s[1] == '<') { // *<library>*icon
				pack = s.IndexOf((byte)'>');
				if (pack++ < 0 || s.Length - pack < 8 || s[pack] != '*') return false;
				pack++;
			}
			int name = pack; while (name < s.Length && s[name] != '.') name++; if (name < pack + 4) return false;
			int end = ++name; while (end < s.Length && s[end] != ' ') end++;
			return end > name;
		}
	}
	
	/// <summary>
	/// Gets image type from string.
	/// </summary>
	/// <param name="prefixLength">Length of prefix "imagefile:" or "image:".</param>
	/// <param name="s">File path etc. See <see cref="ImageType"/>.</param>
	public static ImageType ImageTypeFromString(out int prefixLength, string s) {
		return ImageTypeFromString(out prefixLength, Encoding.UTF8.GetBytes(s));
	}
	
	/// <summary>
	/// Loads image and returns its data in .bmp file format.
	/// Returns null if fails, for example file not found or invalid Base64 string.
	/// </summary>
	/// <param name="s">Depends on t. File path or resource name without prefix "imagefile:" or Base64 image data without prefix "image:".</param>
	/// <param name="t">Image type and string format.</param>
	/// <param name="searchPath">Use <see cref="filesystem.searchPath"/></param>
	/// <param name="xaml">If not null, supports XAML images. See <see cref="ImageUtil.LoadGdipBitmapFromXaml"/>.</param>
	/// <remarks>Supports environment variables etc. If not full path, searches in <see cref="folders.ThisAppImages"/>.</remarks>
	public static byte[] BmpFileDataFromString(string s, ImageType t, bool searchPath = false, (int dpi, SIZE? size)? xaml = null) {
		//print.qm2.write(t);
		try {
			switch (t) {
			case ImageType.Bmp or ImageType.PngGifJpg or ImageType.Cur:
				if (searchPath) {
					s = filesystem.searchPath(s, folders.ThisAppImages);
					if (s == null) return null;
				} else {
					if (!pathname.isFullPathExpand(ref s)) return null;
					s = pathname.normalize(s, folders.ThisAppImages);
					if (!filesystem.exists(s).File) return null;
				}
				break;
			}
			g1:
			switch (t) {
			case ImageType.Base64Image:
				var a = Convert.FromBase64String(s);
				if (s.AsSpan().TrimStart().StartsWith("WkJN")) return Convert2.BrotliDecompress(a.AsSpan(3));
				return _ImageToBytes(new(new MemoryStream(a, false)));
			//case ImageType.Resource:
			//	return _ImageToBytes(ResourceUtil.GetGdipBitmap(s));
			case ImageType.Bmp:
				return File.ReadAllBytes(s);
			case ImageType.PngGifJpg:
				return _ImageToBytes(new(s));
			case ImageType.Ico or ImageType.IconLib or ImageType.ShellIcon or ImageType.Cur:
				return _IconToBytes(s, t == ImageType.Cur, searchPath);
			case ImageType.XamlIconName when xaml != null:
				s = ScriptEditor.GetIcon(s, EGetIcon.IconNameToXaml);
				if (s == null) break;
				t = ImageType.Xaml;
				goto g1;
			case ImageType.Xaml when xaml != null:
				var xv = xaml.Value;
				return _ImageToBytes(ImageUtil.LoadGdipBitmapFromXaml(s, xv.dpi, xv.size));
			}
		}
		catch (Exception ex) { Debug_.PrintIf(t != ImageType.Xaml, ex.Message + "    " + s); }
		return null;
	}
	
	static byte[] _ImageToBytes(Bitmap im) {
		if (im == null) return null;
		try {
			//workaround for the black alpha problem. Does not make slower.
			var flags = (ImageFlags)im.Flags;
			if (0 != (flags & ImageFlags.HasAlpha)) { //most png have it
				var t = new Bitmap(im.Width, im.Height);
				t.SetResolution(im.HorizontalResolution, im.VerticalResolution);
				
				using (var g = Graphics.FromImage(t)) {
					g.Clear(Color.White);
					g.DrawImageUnscaled(im, 0, 0);
				}
				
				var old = im; im = t; old.Dispose();
			}
			
			var m = new MemoryStream();
			im.Save(m, ImageFormat.Bmp);
			return m.ToArray();
		}
		catch (Exception ex) { Debug_.Print(ex); return null; }
		finally { im.Dispose(); }
	}
	
	static byte[] _IconToBytes(string s, bool isCursor, bool searchPath) {
		//info: would be much easier with Icon.ToBitmap(), but it creates bitmap that is displayed incorrectly when we draw it in Scintilla.
		//	Mask or alpha areas then are black.
		//	Another way - draw it like in the png case. Not tested. Maybe would not work with cursors. Probably slower.
		
		IntPtr hi; int siz;
		if (isCursor) {
			hi = Api.LoadImage(default, s, Api.IMAGE_CURSOR, 0, 0, Api.LR_LOADFROMFILE | Api.LR_DEFAULTSIZE);
			siz = Api.GetSystemMetrics(Api.SM_CXCURSOR);
			//note: if LR_DEFAULTSIZE, uses SM_CXCURSOR, normally 32. It may be not what Explorer displays eg in Cursors folder. But without it gets the first cursor, which often is large, eg 128.
		} else {
			hi = icon.of(s, 16, searchPath ? 0 : IconGetFlags.DontSearch)?.Detach() ?? default;
			siz = 16;
		}
		if (hi == default) return null;
		try {
			using var m = new MemoryBitmap(siz, siz);
			RECT r = new(0, 0, siz, siz);
			Api.FillRect(m.Hdc, r, Api.GetStockObject(0)); //WHITE_BRUSH
			if (!Api.DrawIconEx(m.Hdc, 0, 0, hi, siz, siz)) return null;
			
			int headersSize = sizeof(BITMAPFILEHEADER) + sizeof(Api.BITMAPINFOHEADER);
			var a = new byte[headersSize + siz * siz * 3];
			fixed (byte* p = a) {
				var f = (BITMAPFILEHEADER*)p;
				f->bfType = ((byte)'M' << 8) | (byte)'B'; f->bfOffBits = headersSize; f->bfSize = a.Length;
				var bi = new Api.BITMAPINFO(siz, siz, 24);
				if (siz != Api.GetDIBits(m.Hdc, m.Hbitmap, 0, siz, p + headersSize, ref bi, 0)) return null; //DIB_RGB_COLORS
				MemoryUtil.Copy(&bi, f + 1, bi.biSize);
			}
			return a;
		}
		finally {
			Api.DestroyIcon(hi);
		}
	}
	
#if false //currently not used. If using, move to icon class.

	/// <summary>
	/// Gets icon or cursor size from its native handle.
	/// Returns 0 if failed.
	/// </summary>
	public static int GetIconSizeFromHandle(IntPtr hi)
	{
		if(!Api.GetIconInfo(hi, out var ii)) return 0;
		try {
			var hb = (ii.hbmColor != default) ? ii.hbmColor : ii.hbmMask;
			Api.BITMAP b;
			if(0 == Api.GetObject(hb, sizeof(BITMAP), &b)) return 0;
			print.it(b.bmWidth, b.bmHeight, b.bmBits);
			return b.bmWidth;
		}
		finally {
			Api.DeleteObject(ii.hbmColor);
			Api.DeleteObject(ii.hbmMask);
		}
	}
#endif
	
	/// <summary>
	/// Compresses .bmp file data (<see cref="Convert2.BrotliCompress"/>) and Base64-encodes.
	/// Returns string with "image:" prefix.
	/// </summary>
	public static string BmpFileDataToString(byte[] bmpFileData) {
		if (bmpFileData == null) return null;
		return "image:WkJN" + Convert.ToBase64String(Convert2.BrotliCompress(bmpFileData));
		//WkJN is Base64 of "ZBM"
	}
	
	/// <summary>
	/// Converts image file data to string that can be used in source code instead of file path. It is supported by some functions of this library, for example <see cref="uiimage.find"/>.
	/// Supports all <see cref="ImageType"/> formats. For non-image files gets icon. Converts icons to bitmap.
	/// If <i>path</i> is of <see cref="ImageType"/> type <b>Base64Image</b>, <b>Xaml</b> or <b>XamlIconName</b>, returns <i>path</i>. Else returns Base64 encoded file data with prefix "image:" (.png/gif/jpg) or "image:WkJN" (compressed .bmp).
	/// Returns null if path is not a valid image string or the file does not exist or failed to load.
	/// </summary>
	/// <remarks>Supports environment variables etc. If not full path, searches in <see cref="folders.ThisAppImages"/> and standard directories.</remarks>
	public static string ImageToString(string path) {
		var t = ImageTypeFromString(out _, path);
		switch (t) {
		case ImageType.None: return null;
		case ImageType.Base64Image or ImageType.Xaml or ImageType.XamlIconName: return path;
		//case ImageType.Resource: return path;
		case ImageType.PngGifJpg:
			path = filesystem.searchPath(path, folders.ThisAppImages); if (path == null) return null;
			try { return "image:" + Convert.ToBase64String(filesystem.loadBytes(path)); }
			catch (Exception ex) { Debug_.Print(ex); return null; }
		}
		return BmpFileDataToString(BmpFileDataFromString(path, t, true));
	}
	
	//currently not used.
	//	When tried to display the WPF image in Image control, was blurry when high DPI, although size is correct (because bitmap's DPI is correct).
	//	UseLayoutRounding did not help. It seems WPF scales/unscales the image don't know how many times.
	///// <summary>
	///// Converts GDI+ bitmap to WPF bitmap image.
	///// </summary>
	//public static System.Windows.Media.Imaging.BitmapSource WinformsBitmapToWpf(Bitmap bmp, bool dispose, int? dpi = null) {
	//	var size = bmp.Size;
	//	var bd = bmp.LockBits(new Rectangle(default, size), ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb);
	//	try {
	//		return System.Windows.Media.Imaging.BitmapSource.Create(
	//			size.Width, size.Height,
	//			dpi ?? bmp.HorizontalResolution.ToInt(),
	//			dpi ?? bmp.VerticalResolution.ToInt(),
	//			pixelFormat: System.Windows.Media.PixelFormats.Bgra32,
	//			null, bd.Scan0, bd.Height * bd.Stride, bd.Stride);
	//	}
	//	finally {
	//		bmp.UnlockBits(bd);
	//		if (dispose) bmp.Dispose();
	//	}
	//}
	
	///// <summary>
	///// If <i>dpi</i> &gt; 96 (100%) and image resolution is different, returns scaled image.Size. Else returns image.Size.
	///// </summary>
	//public static SIZE ImageSize(Image image, int dpi) {
	//	if (image == null) return default;
	//	SIZE z = image.Size;
	//	if (dpi > 96) {
	//		z.width = Math2.MulDiv(z.width, dpi, image.HorizontalResolution.ToInt());
	//		z.height = Math2.MulDiv(z.height, dpi, image.VerticalResolution.ToInt());
	//	}
	//	return z;
	//}
	
	///// <summary>
	///// If <i>dpi</i> &gt; 96 (100%) and image resolution is different, returns scaled copy of <i>image</i>. Else returns <i>image</i>.
	///// </summary>
	///// <param name="image"></param>
	///// <param name="dpi"></param>
	///// <param name="disposeOld">If performed scaling (it means created new image), dispose old image.</param>
	///// <remarks>
	///// Unlike <see cref="System.Windows.Forms.Control.ScaleBitmapLogicalToDevice"/>, returns same object if don't need scaling.
	///// </remarks>
	//public static Image ScaleImage(Image image, int dpi, bool disposeOld) {
	//	if (image != null && dpi > 96) {
	//		int xRes = image.HorizontalResolution.ToInt(), yRes = image.VerticalResolution.ToInt();
	//		//print.it(xRes, yRes, dpi);
	//		if (xRes != dpi || yRes != dpi) {
	//			var z = image.Size;
	//			var r = _ScaleBitmap(image, Math2.MulDiv(z.Width, dpi, xRes), Math2.MulDiv(z.Height, dpi, yRes), z);
	//			if (disposeOld) image.Dispose();
	//			image = r;
	//		}
	//	}
	//	return image;
	//}
	
	////From .NET DpiHelper.ScaleBitmapToSize, which is used by Control.ScaleBitmapLogicalToDevice.
	//private static Bitmap _ScaleBitmap(Image oldImage, int width, int height, Size oldSize) {
	//	//note: could simply return new Bitmap(oldImage, width, height). It uses similar code, but lower quality.
	
	//	var r = new Bitmap(width, height, oldImage.PixelFormat);
	
	//	using var graphics = Graphics.FromImage(r);
	//	var mode = InterpolationMode.HighQualityBicubic;
	//	//if(width % oldSize.Width == 0 && height % oldSize.Height == 0) mode = InterpolationMode.NearestNeighbor; //DpiHelper does it, but maybe it isn't a good idea
	//	graphics.InterpolationMode = mode;
	//	graphics.CompositingQuality = CompositingQuality.HighQuality;
	
	//	var sourceRect = new RectangleF(-0.5f, -0.5f, oldSize.Width, oldSize.Height);
	//	var destRect = new RectangleF(0, 0, width, height);
	
	//	graphics.DrawImage(oldImage, destRect, sourceRect, GraphicsUnit.Pixel);
	
	//	return r;
	//}
	
	//currently not used.
	///// <summary>
	///// Creates GDI+ <b>Bitmap</b> from a GDI bitmap.
	///// </summary>
	///// <param name="hbitmap">GDI bitmap handle.</param>
	///// <remarks>
	///// How this function is different from <see cref="System.Drawing.Image.FromHbitmap"/>:
	///// 1. <b>Image.FromHbitmap</b> usually creates bottom-up bitmap, which is incompatible with <see cref="uiimage.find"/>. This function creates normal top-down bitmap, like <c>new Bitmap(...)</c>, <c>Bitmap.FromFile(...)</c> etc.
	///// 2. This function always creates bitmap of <b>PixelFormat</b> <b>Format32bppRgb</b>.
	///// </remarks>
	///// <exception cref="AuException">Failed. For example <i>hbitmap</i> is default(IntPtr).</exception>
	///// <exception cref="Exception">Exceptions of Bitmap(int, int, PixelFormat) constructor.</exception>
	//public static unsafe System.Drawing.Bitmap ConvertHbitmapToGdipBitmap(IntPtr hbitmap) {
	//	var bh = new Api.BITMAPINFOHEADER() { biSize = sizeof(Api.BITMAPINFOHEADER) };
	//	using (var dcs = new ScreenDC_()) {
	//		if (0 == Api.GetDIBits(dcs, hbitmap, 0, 0, null, &bh, 0)) goto ge;
	//		int wid = bh.biWidth, hei = bh.biHeight;
	//		if (hei > 0) bh.biHeight = -bh.biHeight; else hei = -hei;
	//		bh.biBitCount = 32;
	
	//		var R = new System.Drawing.Bitmap(wid, hei, System.Drawing.Imaging.PixelFormat.Format32bppRgb);
	//		var d = R.LockBits(new System.Drawing.Rectangle(0, 0, wid, hei), System.Drawing.Imaging.ImageLockMode.ReadWrite, R.PixelFormat);
	//		bool ok = hei == Api.GetDIBits(dcs, hbitmap, 0, hei, (void*)d.Scan0, &bh, 0);
	//		R.UnlockBits(d);
	//		if (!ok) { R.Dispose(); goto ge; }
	//		return R;
	//	}
	//	ge:
	//	throw new AuException();
	//}
}


================================================
FILE: Au.Controls/resources/AssemblyInfo.cs
================================================
using System.Windows;

[assembly: AssemblyTitle("Au.Controls")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
//more in global2.cs

#if IDE_LA
[assembly: InternalsVisibleTo("Au.Editor")]
#else
[assembly: InternalsVisibleTo("Au.Editor, PublicKey=0024000004800000940000000602000000240000525341310004000001000100095c6b7a0fe60fbe4a77e52dd10a09331ee3c3a7399aa9cc17db8a015647469a19784d5e33a2450a0a49c37bf17c0c3223674f64104eae649ba27c51a90c24989faec87d59217d7850efc8151109bbf9b027b7714fc01788317d2b991b2c2669836a7725e942f76607efde5cdacd8c497a45c5f9673fcf102fdbf92237a524a4")]
#endif

[assembly: ThemeInfo(
	ResourceDictionaryLocation.None, //where theme specific resource dictionaries are located
									 //(used if a resource is not found in the page,
									 // or application resource dictionaries)
	ResourceDictionaryLocation.SourceAssembly //where the generic resource dictionary is located
											  //(used if a resource is not found in the page,
											  // app, or any theme specific resource dictionaries)
)]


================================================
FILE: Au.Controls/resources/Generic.xaml
================================================
<!-- note: don't use local types (clr-namespace). Then VS compiles project 2 times. -->
<ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
                    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
                    xmlns:controls="clr-namespace:Au.Controls">
    <SolidColorBrush x:Key="TabItem.Selected.Background" Color="#FFFFFF"/>
    <SolidColorBrush x:Key="TabItem.Selected.Border" Color="#ACACAC"/>
    <Style x:Key="AuPanelsTabControlStyle" TargetType="{x:Type TabControl}">
        <Setter Property="Padding" Value="2"/>
        <Setter Property="HorizontalContentAlignment" Value="Center"/>
        <Setter Property="VerticalContentAlignment" Value="Center"/>
        <Setter Property="Background" Value="{StaticResource TabItem.Selected.Background}"/>
        <Setter Property="BorderBrush" Value="{StaticResource TabItem.Selected.Border}"/>
        <Setter Property="BorderThickness" Value="1"/>
        <Setter Property="Foreground" Value="{DynamicResource {x:Static SystemColors.ControlTextBrushKey}}"/>
        <Setter Property="Template">
            <Setter.Value>
                <ControlTemplate TargetType="{x:Type TabControl}">
                    <Grid x:Name="templateRoot" Background="LightSteelBlue" ClipToBounds="true" SnapsToDevicePixels="true" KeyboardNavigation.TabNavigation="Local">
                        <Grid.ColumnDefinitions>
                            <ColumnDefinition x:Name="ColumnDefinition0"/>
                            <ColumnDefinition x:Name="ColumnDefinition1" Width="0"/>
                        </Grid.ColumnDefinitions>
                        <Grid.RowDefinitions>
                            <RowDefinition x:Name="RowDefinition0" Height="Auto"/>
                            <RowDefinition x:Name="RowDefinition1" Height="*"/>
                        </Grid.RowDefinitions>
                        <controls:FlexStackPanel x:Name="headerPanel" Background="Transparent" Grid.Column="0" IsItemsHost="true" Margin="2,2,8,0" Grid.Row="0" KeyboardNavigation.TabIndex="1" Panel.ZIndex="1"/>
                        <Border x:Name="contentPanel" Background="{TemplateBinding Background}" BorderThickness="{TemplateBinding BorderThickness}" BorderBrush="{TemplateBinding BorderBrush}" Grid.Column="0" KeyboardNavigation.DirectionalNavigation="Contained" Grid.Row="1" KeyboardNavigation.TabNavigation="Local" KeyboardNavigation.TabIndex="2">
                            <ContentPresenter x:Name="PART_SelectedContentHost" ContentSource="SelectedContent" Margin="{TemplateBinding Padding}" SnapsToDevicePixels="{TemplateBinding SnapsToDevicePixels}"/>
                        </Border>
                    </Grid>
                    <ControlTemplate.Triggers>
                        <Trigger Property="TabStripPlacement" Value="Bottom">
                            <Setter Property="Grid.Row" TargetName="headerPanel" Value="1"/>
                            <Setter Property="Grid.Row" TargetName="contentPanel" Value="0"/>
                            <Setter Property="Height" TargetName="RowDefinition0" Value="*"/>
                            <Setter Property="Height" TargetName="RowDefinition1" Value="Auto"/>
                            <Setter Property="Margin" TargetName="headerPanel" Value="2,0,8,2"/>
                        </Trigger>
                        <Trigger Property="TabStripPlacement" Value="Left">
                            <Setter Property="Orientation" Value="Vertical" TargetName="headerPanel"/>
                            <Setter Property="Grid.Row" TargetName="headerPanel" Value="0"/>
                            <Setter Property="Grid.Row" TargetName="contentPanel" Value="0"/>
                            <Setter Property="Grid.Column" TargetName="headerPanel" Value="0"/>
                            <Setter Property="Grid.Column" TargetName="contentPanel" Value="1"/>
                            <Setter Property="Width" TargetName="ColumnDefinition0" Value="Auto"/>
                            <Setter Property="Width" TargetName="ColumnDefinition1" Value="*"/>
                            <Setter Property="Height" TargetName="RowDefinition0" Value="*"/>
                            <Setter Property="Height" TargetName="RowDefinition1" Value="0"/>
                            <Setter Property="Margin" TargetName="headerPanel" Value="2,2,0,8"/>
                        </Trigger>
                        <Trigger Property="TabStripPlacement" Value="Right">
                            <Setter Property="Orientation" Value="Vertical" TargetName="headerPanel"/>
                            <Setter Property="Grid.Row" TargetName="headerPanel" Value="0"/>
                            <Setter Property="Grid.Row" TargetName="contentPanel" Value="0"/>
                            <Setter Property="Grid.Column" TargetName="headerPanel" Value="1"/>
                            <Setter Property="Grid.Column" TargetName="contentPanel" Value="0"/>
                            <Setter Property="Width" TargetName="ColumnDefinition0" Value="*"/>
                            <Setter Property="Width" TargetName="ColumnDefinition1" Value="Auto"/>
                            <Setter Property="Height" TargetName="RowDefinition0" Value="*"/>
                            <Setter Property="Height" TargetName="RowDefinition1" Value="0"/>
                            <Setter Property="Margin" TargetName="headerPanel" Value="0,2,2,8"/>
                        </Trigger>
                        <Trigger Property="IsEnabled" Value="false">
                            <Setter Property="TextElement.Foreground" TargetName="templateRoot" Value="{DynamicResource {x:Static SystemColors.GrayTextBrushKey}}"/>
                        </Trigger>
                    </ControlTemplate.Triggers>
                </ControlTemplate>
            </Setter.Value>
        </Setter>
    </Style>
    <Style x:Key="FocusVisual">
        <Setter Property="Control.Template">
            <Setter.Value>
                <ControlTemplate>
                    <Rectangle Margin="2" StrokeDashArray="1 2" SnapsToDevicePixels="true" StrokeThickness="1" Stroke="{DynamicResource {x:Static SystemColors.ControlTextBrushKey}}"/>
                </ControlTemplate>
            </Setter.Value>
        </Setter>
    </Style>
    <LinearGradientBrush x:Key="TabItem.Static.Background" EndPoint="0,1" StartPoint="0,0">
        <GradientStop Color="#F0F0F0" Offset="0.0"/>
        <GradientStop Color="#E5E5E5" Offset="1.0"/>
    </LinearGradientBrush>
    <SolidColorBrush x:Key="TabItem.Static.Border" Color="#ACACAC"/>
    <LinearGradientBrush x:Key="TabItem.MouseOver.Background" EndPoint="0,1" StartPoint="0,0">
        <GradientStop Color="#ECF4FC" Offset="0.0"/>
        <GradientStop Color="#DCECFC" Offset="1.0"/>
    </LinearGradientBrush>
    <SolidColorBrush x:Key="TabItem.MouseOver.Border" Color="#7EB4EA"/>
    <SolidColorBrush x:Key="TabItem.Selected.Background1" Color="#FFFFFF"/>
    <SolidColorBrush x:Key="TabItem.Selected.Border1" Color="#ACACAC"/>
    <SolidColorBrush x:Key="TabItem.Disabled.Background" Color="#F0F0F0"/>
    <SolidColorBrush x:Key="TabItem.Disabled.Border" Color="#D9D9D9"/>
    <Style x:Key="AuPanelsTabItemStyle" TargetType="{x:Type TabItem}">
        <Setter Property="FocusVisualStyle" Value="{StaticResource FocusVisual}"/>
        <Setter Property="Foreground" Value="Black"/>
        <Setter Property="Background" Value="{StaticResource TabItem.Static.Background}"/>
        <Setter Property="BorderBrush" Value="{StaticResource TabItem.Static.Border}"/>
        <Setter Property="Margin" Value="0"/>
        <Setter Property="Padding" Value="6,2,6,2"/>
        <Setter Property="HorizontalContentAlignment" Value="Stretch"/>
        <Setter Property="VerticalContentAlignment" Value="Stretch"/>
        <Setter Property="Template">
            <Setter.Value>
                <ControlTemplate TargetType="{x:Type TabItem}">
                    <Grid x:Name="templateRoot" SnapsToDevicePixels="true">
                        <Border x:Name="mainBorder" Background="{TemplateBinding Background}" BorderThickness="1,1,1,0" BorderBrush="{TemplateBinding BorderBrush}" Margin="0">
                            <Border x:Name="innerBorder" Background="{StaticResource TabItem.Selected.Background1}" BorderThickness="1,1,1,0" BorderBrush="{StaticResource TabItem.Selected.Border1}" Margin="-1" Opacity="0"/>
                        </Border>
                        <ContentPresenter x:Name="contentPresenter" ContentSource="Header" Focusable="False" HorizontalAlignment="{Binding HorizontalContentAlignment, RelativeSource={RelativeSource AncestorType={x:Type ItemsControl}}}" Margin="{TemplateBinding Padding}" RecognizesAccessKey="True" SnapsToDevicePixels="{TemplateBinding SnapsToDevicePixels}" VerticalAlignment="{Binding VerticalContentAlignment, RelativeSource={RelativeSource AncestorType={x:Type ItemsControl}}}"/>
                    </Grid>
                    <ControlTemplate.Triggers>
                        <MultiDataTrigger>
                            <MultiDataTrigger.Conditions>
                                <Condition Binding="{Binding IsMouseOver, RelativeSource={RelativeSource Self}}" Value="true"/>
                                <Condition Binding="{Binding TabStripPlacement, RelativeSource={RelativeSource AncestorType={x:Type TabControl}}}" Value="Left"/>
                            </MultiDataTrigger.Conditions>
                            <Setter Property="Background" TargetName="mainBorder" Value="{StaticResource TabItem.MouseOver.Background}"/>
                            <Setter Property="BorderBrush" TargetName="mainBorder" Value="{StaticResource TabItem.MouseOver.Border}"/>
                            <Setter Property="BorderThickness" TargetName="innerBorder" Value="1,1,0,1"/>
                            <Setter Property="BorderThickness" TargetName="mainBorder" Value="1,1,0,1"/>
                        </MultiDataTrigger>
                        <MultiDataTrigger>
                            <MultiDataTrigger.Conditions>
                                <Condition Binding="{Binding IsMouseOver, RelativeSource={RelativeSource Self}}" Value="true"/>
                                <Condition Binding="{Binding TabStripPlacement, RelativeSource={RelativeSource AncestorType={x:Type TabControl}}}" Value="Bottom"/>
                            </MultiDataTrigger.Conditions>
                            <Setter Property="Background" TargetName="mainBorder" Value="{StaticResource TabItem.MouseOver.Background}"/>
                            <Setter Property="BorderBrush" TargetName="mainBorder" Value="{StaticResource TabItem.MouseOver.Border}"/>
                            <Setter Property="BorderThickness" TargetName="innerBorder" Value="1,0,1,1"/>
                            <Setter Property="BorderThickness" TargetName="mainBorder" Value="1,0,1,1"/>
                        </MultiDataTrigger>
                        <MultiDataTrigger>
                            <MultiDataTrigger.Conditions>
                                <Condition Binding="{Binding IsMouseOver, RelativeSource={RelativeSource Self}}" Value="true"/>
                                <Condition Binding="{Binding TabStripPlacement, RelativeSource={RelativeSource AncestorType={x:Type TabControl}}}" Value="Right"/>
                            </MultiDataTrigger.Conditions>
                            <Setter Property="Background" TargetName="mainBorder" Value="{StaticResource TabItem.MouseOver.Background}"/>
                            <Setter Property="BorderBrush" TargetName="mainBorder" Value="{StaticResource TabItem.MouseOver.Border}"/>
                            <Setter Property="BorderThickness" TargetName="innerBorder" Value="0,1,1,1"/>
                            <Setter Property="BorderThickness" TargetName="mainBorder" Value="0,1,1,1"/>
                        </MultiDataTrigger>
                        <MultiDataTrigger>
                            <MultiDataTrigger.Conditions>
                                <Condition Binding="{Binding IsMouseOver, RelativeSource={RelativeSource Self}}" Value="true"/>
                                <Condition Binding="{Binding TabStripPlacement, RelativeSource={RelativeSource AncestorType={x:Type TabControl}}}" Value="Top"/>
                            </MultiDataTrigger.Conditions>
                            <Setter Property="Background" TargetName="mainBorder" Value="{StaticResource TabItem.MouseOver.Background}"/>
                            <Setter Property="BorderBrush" TargetName="mainBorder" Value="{StaticResource TabItem.MouseOver.Border}"/>
                            <Setter Property="BorderThickness" TargetName="innerBorder" Value="1,1,1,0"/>
                            <Setter Property="BorderThickness" TargetName="mainBorder" Value="1,1,1,0"/>
                        </MultiDataTrigger>
                        <MultiDataTrigger>
                            <MultiDataTrigger.Conditions>
                                <Condition Binding="{Binding IsEnabled, RelativeSource={RelativeSource Self}}" Value="false"/>
                                <Condition Binding="{Binding TabStripPlacement, RelativeSource={RelativeSource AncestorType={x:Type TabControl}}}" Value="Left"/>
                            </MultiDataTrigger.Conditions>
                            <Setter Property="Opacity" TargetName="contentPresenter" Value="0.56"/>
                            <Setter Property="Background" TargetName="mainBorder" Value="{StaticResource TabItem.Disabled.Background}"/>
                            <Setter Property="BorderBrush" TargetName="mainBorder" Value="{StaticResource TabItem.Disabled.Border}"/>
                            <Setter Property="BorderThickness" TargetName="innerBorder" Value="1,1,0,1"/>
                            <Setter Property="BorderThickness" TargetName="mainBorder" Value="1,1,0,1"/>
                        </MultiDataTrigger>
                        <MultiDataTrigger>
                            <MultiDataTrigger.Conditions>
                                <Condition Binding="{Binding IsEnabled, RelativeSource={RelativeSource Self}}" Value="false"/>
                                <Condition Binding="{Binding TabStripPlacement, RelativeSource={RelativeSource AncestorType={x:Type TabControl}}}" Value="Bottom"/>
                            </MultiDataTrigger.Conditions>
                            <Setter Property="Opacity" TargetName="contentPresenter" Value="0.56"/>
                            <Setter Property="Background" TargetName="mainBorder" Value="{StaticResource TabItem.Disabled.Background}"/>
                            <Setter Property="BorderBrush" TargetName="mainBorder" Value="{StaticResource TabItem.Disabled.Border}"/>
                            <Setter Property="BorderThickness" TargetName="innerBorder" Value="1,0,1,1"/>
                            <Setter Property="BorderThickness" TargetName="mainBorder" Value="1,0,1,1"/>
                        </MultiDataTrigger>
                        <MultiDataTrigger>
                            <MultiDataTrigger.Conditions>
                                <Condition Binding="{Binding IsEnabled, RelativeSource={RelativeSource Self}}" Value="false"/>
                                <Condition Binding="{Binding TabStripPlacement, RelativeSource={RelativeSource AncestorType={x:Type TabControl}}}" Value="Right"/>
                            </MultiDataTrigger.Conditions>
                            <Setter Property="Opacity" TargetName="contentPresenter" Value="0.56"/>
                            <Setter Property="Background" TargetName="mainBorder" Value="{StaticResource TabItem.Disabled.Background}"/>
                            <Setter Property="BorderBrush" TargetName="mainBorder" Value="{StaticResource TabItem.Disabled.Border}"/>
                            <Setter Property="BorderThickness" TargetName="innerBorder" Value="0,1,1,1"/>
                            <Setter Property="BorderThickness" TargetName="mainBorder" Value="0,1,1,1"/>
                        </MultiDataTrigger>
                        <MultiDataTrigger>
                            <MultiDataTrigger.Conditions>
                                <Condition Binding="{Binding IsEnabled, RelativeSource={RelativeSource Self}}" Value="false"/>
                                <Condition Binding="{Binding TabStripPlacement, RelativeSource={RelativeSource AncestorType={x:Type TabControl}}}" Value="Top"/>
                            </MultiDataTrigger.Conditions>
                            <Setter Property="Opacity" TargetName="contentPresenter" Value="0.56"/>
                            <Setter Property="Background" TargetName="mainBorder" Value="{StaticResource TabItem.Disabled.Background}"/>
                            <Setter Property="BorderBrush" TargetName="mainBorder" Value="{StaticResource TabItem.Disabled.Border}"/>
                            <Setter Property="BorderThickness" TargetName="innerBorder" Value="1,1,1,0"/>
                            <Setter Property="BorderThickness" TargetName="mainBorder" Value="1,1,1,0"/>
                        </MultiDataTrigger>
                        <MultiDataTrigger>
                            <MultiDataTrigger.Conditions>
                                <Condition Binding="{Binding IsSelected, RelativeSource={RelativeSource Self}}" Value="false"/>
                                <Condition Binding="{Binding TabStripPlacement, RelativeSource={RelativeSource AncestorType={x:Type TabControl}}}" Value="Left"/>
                            </MultiDataTrigger.Conditions>
                            <Setter Property="BorderThickness" TargetName="innerBorder" Value="1,1,0,1"/>
                            <Setter Property="BorderThickness" TargetName="mainBorder" Value="1,1,0,1"/>
                        </MultiDataTrigger>
                        <MultiDataTrigger>
                            <MultiDataTrigger.Conditions>
                                <Condition Binding="{Binding IsSelected, RelativeSource={RelativeSource Self}}" Value="true"/>
                                <Condition Binding="{Binding TabStripPlacement, RelativeSource={RelativeSource AncestorType={x:Type TabControl}}}" Value="Left"/>
                            </MultiDataTrigger.Conditions>
                            <Setter Property="Panel.ZIndex" Value="1"/>
                            <Setter Property="Opacity" TargetName="innerBorder" Value="1"/>
                            <Setter Property="BorderThickness" TargetName="innerBorder" Value="1,1,0,1"/>
                            <Setter Property="BorderThickness" TargetName="mainBorder" Value="1,1,0,1"/>
                        </MultiDataTrigger>
                        <MultiDataTrigger>
                            <MultiDataTrigger.Conditions>
                                <Condition Binding="{Binding IsSelected, RelativeSource={RelativeSource Self}}" Value="false"/>
                                <Condition Binding="{Binding TabStripPlacement, RelativeSource={RelativeSource AncestorType={x:Type TabControl}}}" Value="Bottom"/>
                            </MultiDataTrigger.Conditions>
                            <Setter Property="BorderThickness" TargetName="innerBorder" Value="1,0,1,1"/>
                            <Setter Property="BorderThickness" TargetName="mainBorder" Value="1,0,1,1"/>
                        </MultiDataTrigger>
                        <MultiDataTrigger>
                            <MultiDataTrigger.Conditions>
                                <Condition Binding="{Binding IsSelected, RelativeSource={RelativeSource Self}}" Value="true"/>
                                <Condition Binding="{Binding TabStripPlacement, RelativeSource={RelativeSource AncestorType={x:Type TabControl}}}" Value="Bottom"/>
                            </MultiDataTrigger.Conditions>
                            <Setter Property="Panel.ZIndex" Value="1"/>
                            <Setter Property="Opacity" TargetName="innerBorder" Value="1"/>
                            <Setter Property="BorderThickness" TargetName="innerBorder" Value="1,0,1,1"/>
                            <Setter Property="BorderThickness" TargetName="mainBorder" Value="1,0,1,1"/>
                        </MultiDataTrigger>
                        <MultiDataTrigger>
                            <MultiDataTrigger.Conditions>
                                <Condition Binding="{Binding IsSelected, RelativeSource={RelativeSource Self}}" Value="false"/>
                                <Condition Binding="{Binding TabStripPlacement, RelativeSource={RelativeSource AncestorType={x:Type TabControl}}}" Value="Right"/>
                            </MultiDataTrigger.Conditions>
                            <Setter Property="BorderThickness" TargetName="innerBorder" Value="0,1,1,1"/>
                            <Setter Property="BorderThickness" TargetName="mainBorder" Value="0,1,1,1"/>
                        </MultiDataTrigger>
                        <MultiDataTrigger>
                            <MultiDataTrigger.Conditions>
                                <Condition Binding="{Binding IsSelected, RelativeSource={RelativeSource Self}}" Value="true"/>
                                <Condition Binding="{Binding TabStripPlacement, RelativeSource={RelativeSource AncestorType={x:Type TabControl}}}" Value="Right"/>
                            </MultiDataTrigger.Conditions>
                            <Setter Property="Panel.ZIndex" Value="1"/>
                            <Setter Property="Opacity" TargetName="innerBorder" Value="1"/>
                            <Setter Property="BorderThickness" TargetName="innerBorder" Value="0,1,1,1"/>
                            <Setter Property="BorderThickness" TargetName="mainBorder" Value="0,1,1,1"/>
                        </MultiDataTrigger>
                        <MultiDataTrigger>
                            <MultiDataTrigger.Conditions>
                                <Condition Binding="{Binding IsSelected, RelativeSource={RelativeSource Self}}" Value="false"/>
                                <Condition Binding="{Binding TabStripPlacement, RelativeSource={RelativeSource AncestorType={x:Type TabControl}}}" Value="Top"/>
                            </MultiDataTrigger.Conditions>
                            <Setter Property="BorderThickness" TargetName="innerBorder" Value="1,1,1,0"/>
                            <Setter Property="BorderThickness" TargetName="mainBorder" Value="1,1,1,0"/>
                        </MultiDataTrigger>
                        <MultiDataTrigger>
                            <MultiDataTrigger.Conditions>
                                <Condition Binding="{Binding IsSelected, RelativeSource={RelativeSource Self}}" Value="true"/>
                                <Condition Binding="{Binding TabStripPlacement, RelativeSource={RelativeSource AncestorType={x:Type TabControl}}}" Value="Top"/>
                            </MultiDataTrigger.Conditions>
                            <Setter Property="Panel.ZIndex" Value="1"/>
                            <Setter Property="Opacity" TargetName="innerBorder" Value="1"/>
                            <Setter Property="BorderThickness" TargetName="innerBorder" Value="1,1,1,0"/>
                            <Setter Property="BorderThickness" TargetName="mainBorder" Value="1,1,1,0"/>
                        </MultiDataTrigger>
                    </ControlTemplate.Triggers>
                </ControlTemplate>
            </Setter.Value>
        </Setter>
    </Style>
    <Style x:Key='TabItemVerticalLeft' TargetType='{x:Type TabItem}' BasedOn='{StaticResource AuPanelsTabItemStyle}'>
        <Setter Property='HeaderTemplate'>
            <Setter.Value>
                <DataTemplate>
                    <ContentPresenter Content='{TemplateBinding Content}'>
                        <ContentPresenter.LayoutTransform>
                            <RotateTransform Angle='270' />
                        </ContentPresenter.LayoutTransform>
                    </ContentPresenter>
                </DataTemplate>
            </Setter.Value>
        </Setter>
        <Setter Property='Padding' Value='2,6,2,6' />
    </Style>
    <Style x:Key='TabItemVerticalRight' TargetType='{x:Type TabItem}' BasedOn='{StaticResource AuPanelsTabItemStyle}'>
        <Setter Property='HeaderTemplate'>
            <Setter.Value>
                <DataTemplate>
                    <ContentPresenter Content='{TemplateBinding Content}'>
                        <ContentPresenter.LayoutTransform>
                            <RotateTransform Angle='90' />
                        </ContentPresenter.LayoutTransform>
                    </ContentPresenter>
                </DataTemplate>
            </Setter.Value>
        </Setter>
        <Setter Property='Padding' Value='2,6,2,6' />
    </Style>
</ResourceDictionary>

================================================
FILE: Au.Controls/resources/XamlResources.cs
================================================
using System.Windows;

namespace Au.Controls;

public class XamlResources {
#if IDE_LA
	static XamlResources() {
		//Dictionary = System.Windows.Markup.XamlReader.Load(typeof(XamlResources).Assembly.GetManifestResourceStream("Generic.xaml")) as ResourceDictionary;
		
		//workaround for: at run time fails to load XAML if without `;assembly=Au.Controls`, but VS fails to compile if with.
		using var stream = typeof(XamlResources).Assembly.GetManifestResourceStream("Generic.xaml");
		string xaml = new StreamReader(stream).ReadToEnd();
		xaml = xaml.Replace("clr-namespace:Au.Controls", "clr-namespace:Au.Controls;assembly=Au.Controls");
		using var xmlReader = System.Xml.XmlReader.Create(new StringReader(xaml));
		Dictionary = (ResourceDictionary)System.Windows.Markup.XamlReader.Load(xmlReader);
	}
	
	public static readonly ResourceDictionary Dictionary;
#else
	public static readonly ResourceDictionary Dictionary = Application.LoadComponent(new("/Au.Controls;component/resources/generic.xaml", UriKind.Relative)) as ResourceDictionary; //build action = Page (default)
	//public static ResourceDictionary Dictionary = System.Windows.Markup.XamlReader.Load(typeof(XamlResources).Assembly.GetManifestResourceStream("Au.Controls.Themes.Generic.xaml")) as ResourceDictionary; //build action = embedded resource. Works, but debugger prints handled exception. And probably slower.
#endif
}


================================================
FILE: Au.Editor/App/App-resources.xaml
================================================
<!-- note: don't use local types (clr-namespace). Then VS compiles project 2 times. -->
<ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
                    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
                    >
        <Style TargetType="{x:Type Paragraph}">
            <Setter Property="Margin" Value="4,6,4,6"/>
        </Style>
        <Style x:Key="type" TargetType="{x:Type Run}">
            <Setter Property="Foreground" Value="#088" />
        </Style>
        <Style x:Key="keyword" TargetType="{x:Type Run}">
            <Setter Property="Foreground" Value="#00f" />
        </Style>
        <Style x:Key="string" TargetType="{x:Type Run}">
            <Setter Property="Foreground" Value="#a74" />
        </Style>
        <Style x:Key="number" TargetType="{x:Type Run}">
            <Setter Property="Foreground" Value="#a40" />
        </Style>
        <Style x:Key="namespace" TargetType="{x:Type Run}">
            <Setter Property="Foreground" Value="#777" />
        </Style>
        <Style x:Key="comment" TargetType="{x:Type Run}">
            <Setter Property="Foreground" Value="#080" />
        </Style>
        <Style x:Key="dot" TargetType="{x:Type Run}">
            <Setter Property="Foreground" Value="#ccc" />
        </Style>
        <Style x:Key="dotSelected" TargetType="{x:Type Run}">
            <Setter Property="Foreground" Value="#c0f" />
        </Style>
        <Style x:Key="codeSpan" TargetType="{x:Type Span}">
            <Setter Property="Background" Value="#f0f0f0" />
            <Setter Property="FontFamily" Value="Consolas" />
        </Style>
        <Style x:Key="codeBlock" TargetType="{x:Type Paragraph}">
            <Setter Property="Background" Value="#f0f0f0" />
            <Setter Property="FontFamily" Value="Consolas" />
            <Setter Property="Margin" Value="2,6,2,6"/>
            <Setter Property="Padding" Value="2,3,2,3"/>
        </Style>
        <Style x:Key="hilite" TargetType="{x:Type Span}">
            <Setter Property="Background" Value="#fca" />
        </Style>
        <Style x:Key="div" TargetType="{x:Type Paragraph}">
            <Setter Property="Margin" Value="4,0,4,0"/>
        </Style>
        <Style x:Key="header" TargetType="{x:Type Paragraph}">
            <Setter Property="Margin" Value="4,8,4,4"/>
            <Setter Property="FontWeight" Value="Bold"/>
        </Style>
        <LinearGradientBrush x:Key="overflowGradient" StartPoint="0.5,0" EndPoint="0.5,1">
            <GradientStop Color="#fffff0"/>
            <GradientStop Color="#fffcd0" Offset="1"/>
        </LinearGradientBrush>
        <Style x:Key="overload" TargetType="{x:Type Paragraph}">
            <Setter Property="Margin" Value="0"/>
            <Setter Property="Padding" Value="4,1,4,2"/>
            <Setter Property="BorderThickness" Value="0,0,0,1" />
            <Setter Property="BorderBrush" Value="#ccc" />
            <Setter Property="Background" Value="{StaticResource overflowGradient}" />
        </Style>
        <Style x:Key="overloadSelected" TargetType="{x:Type Paragraph}" BasedOn="{StaticResource overload}">
            <Setter Property="Background" Value="#f8f0a0" />
        </Style>
        <Style x:Key="parameter" TargetType="{x:Type Paragraph}">
            <Setter Property="Background" Value="#dec" />
            <Setter Property="Margin" Value="2,0,2,0"/>
            <Setter Property="Padding" Value="2,0,2,2"/>
        </Style>
        <Style TargetType="{x:Type Hyperlink}">
            <Setter Property="Focusable" Value="False" />
        </Style>
        <Style x:Key="divLink" TargetType="{x:Type Hyperlink}">
            <Setter Property="TextDecorations" Value="" />
            <Setter Property="Foreground" Value="#000" />
            <Setter Property="Focusable" Value="False" />
        </Style>

        <Style TargetType="Viewbox">
            <Style.Triggers>
                <Trigger Property="IsEnabled" Value="False">
                    <Setter Property="Opacity" Value="0.3" />
                </Trigger>
            </Style.Triggers>
        </Style>
</ResourceDictionary>


================================================
FILE: Au.Editor/App/App.TrayIcon.cs
================================================
namespace LA;

static partial class App {
	internal static class TrayIcon {
		static IntPtr[] _icons;
		static bool _disabled = Au.Triggers.ActionTriggers.DisabledEverywhere;
		static wnd _wNotify;
		
		const int c_msgNotify = Api.WM_APP + 1;
		static int s_msgTaskbarCreated;
		
		internal static void Update_() {
			if (_icons == null) {
				_icons = new IntPtr[2];
				
				s_msgTaskbarCreated = WndUtil.RegisterMessage("TaskbarCreated", uacEnable: true);
				
				WndUtil.RegisterWindowClass("Au.Editor.TrayNotify", _WndProc);
				_wNotify = WndUtil.CreateWindow("Au.Editor.TrayNotify", null, WS.POPUP, WSE.NOACTIVATE);
				//not message-only, because must receive s_msgTaskbarCreated and also used for context menu
				
				process.thisProcessExit += _ => {
					var d = new Api.NOTIFYICONDATA(_wNotify);
					Api.Shell_NotifyIcon(Api.NIM_DELETE, d);
				};
				
				_Add(false);
			} else {
				var d = new Api.NOTIFYICONDATA(_wNotify, Api.NIF_ICON) { hIcon = _GetIcon() };
				bool ok = Api.Shell_NotifyIcon(Api.NIM_MODIFY, d);
				Debug_.PrintIf(!ok, lastError.message);
			}
		}
		
		static void _Add(bool restore) {
			var d = new Api.NOTIFYICONDATA(_wNotify, Api.NIF_MESSAGE | Api.NIF_ICON | Api.NIF_TIP /*| Api.NIF_SHOWTIP*/) { //need NIF_SHOWTIP if called NIM_SETVERSION(NOTIFYICON_VERSION_4)
				uCallbackMessage = c_msgNotify,
				hIcon = _GetIcon(),
				szTip = App.AppName
			};
			if (Api.Shell_NotifyIcon(Api.NIM_ADD, d)) {
				//d.uFlags = 0;
				//d.uVersion = Api.NOTIFYICON_VERSION_4;
				//Api.Shell_NotifyIcon(Api.NIM_SETVERSION, d);
				
				//timer.after(2000, _ => Update(TrayIconState.Disabled));
				//timer.after(3000, _ => Update(TrayIconState.Running));
				//timer.after(4000, _ => Update(TrayIconState.Normal));
			} else if (!restore) { //restore when "TaskbarCreated" message received. It is also received when taskbar DPI changed.
				Debug_.Print(lastError.message);
			}
		}
		
		static IntPtr _GetIcon() {
			int i = _disabled ? 1 : 0;
			ref IntPtr icon = ref _icons[i];
			if (icon == default) Api.LoadIconMetric(Api.GetModuleHandle(null), Api.IDI_APPLICATION + i, 0, out icon);
			return icon;
			//Windows 10 on DPI change automatically displays correct non-scaled icon if it is from native icon group resource.
			//	I guess then it calls GetIconInfoEx to get module/resource and extracts new icon from same resource.
		}
		
		static void _Notified(nint wParam, nint lParam) {
			int msg = Math2.LoWord(lParam);
			//if (msg != Api.WM_MOUSEMOVE) WndUtil.PrintMsg(default, msg, 0, 0);
			switch (msg) {
			case Api.WM_LBUTTONUP:
				ShowWindow();
				break;
			case Api.WM_RBUTTONUP:
				_ContextMenu();
				break;
			//case Api.WM_MBUTTONDOWN: //does not work on Win11
			//	TriggersAndToolbars.DisableTriggers(null);
			//	break;
			}
		}
		
		static unsafe nint _WndProc(wnd w, int m, nint wParam, nint lParam) {
			//WndUtil.PrintMsg(w, m, wParam, lParam);
			if (m == c_msgNotify) _Notified(wParam, lParam);
			else if (m == s_msgTaskbarCreated) _Add(true); //when explorer restarted or taskbar DPI changed
			else if (m == Api.WM_DESTROY) _Exit();
			else if (m == Api.WM_DISPLAYCHANGE) {
				Tasks.OnWM_DISPLAYCHANGE();
			} else if (m == Api.WM_SETTINGCHANGE) {
				if (lParam != 0) {
					string s = null;
					try { s = new((char*)lParam); }
					catch (Exception e1) { Debug_.Print(e1); }
					//print.it("WM_SETTINGCHANGE", wParam, s);
					if (s == "Environment") App._envVarUpdater.WmSettingchange();
				}
			}
			
			return Api.DefWindowProc(w, m, wParam, lParam);
		}
		
		static void _ContextMenu() {
			var m = new popupMenu();
			m.AddCheck("Disable triggers", check: _disabled, _ => TriggersAndToolbars.DisableTriggers(null));
			m.Separator();
			m.Add("Exit", _ => _Exit());
			m.Show(PMFlags.AlignBottom | PMFlags.AlignCenterH);
		}
		
		static void _Exit() {
			_app.Shutdown();
		}
		
		public static bool Disabled {
			get => _disabled;
			set { if (value == _disabled) return; _disabled = value; Update_(); }
		}
	}
}


================================================
FILE: Au.Editor/App/App.cs
================================================
using Au.Controls;
using System.Runtime.Loader;
using System.Windows;
using System.Windows.Threading;

[assembly: AssemblyTitle(LA.App.AppName)]
//more attributes in global2.cs

namespace LA;

static partial class App {
	public const string AppName = "LibreAutomate";
	
	internal static PrintServer PrintServer;
	public static AppSettings Settings;
	public static KMenuCommands Commands;
	public static FilesModel Model;
	public static RunningTasks Tasks;
	static EnvVarUpdater _envVarUpdater;
	
	//[STAThread] //no, makes command line etc slower. Will set STA later.
	static int Main(string[] args) {
#if IDE_LA //test tools
		//		print.clear();
		
		//		args = ["/tool", "0", "Dwnd", "0", "0"];
		//args = ["/tool", "0", "Delm"];
		//		//args = ["/tool", "0", "Duiimage", "0"];
		//		//args = ["/tool", "0", "Docr"];
#endif
		
#if DEBUG && !IDE_LA //note: not static ctor. Eg Settings used in scripts while creating some new parts of the app. The ctor would run there.
		if (!(args is ["/tool" or "/pip" or "/dd" or "/mcp", ..])) {
			print.qm2.use = true;
			//print.clear(); 
			//print.redirectConsoleOutput = true; //cannot be before the CommandLine.ProgramStarted1 call.
		}
#endif
		
		script.role = SRole.EditorExtension; //used by the folders class
		script.name = AppName;
		Thread.CurrentThread.Name = "@Au.Main";
		
		if (CommandLine.ProgramStarted1(args, out int exitCode)) return exitCode;
		
		//restart as admin if started as non-admin on admin user account
		if (args.Length > 0 && args[0] is "/n" or "-n") {
			args = args.RemoveAt(0);
			_raaResult = WinScheduler.RResult.ArgN;
		} else if (uacInfo.ofThisProcess.Elevation == UacElevation.Limited) {
			if (_RestartAsAdmin(args)) return 0;
		}
		
		process.IsLaProcess_ = true;
		process.IsLaMainThread_ = true; //[ThreadStatic]
		InitThisAppFoldersEtc_(args);
		
		//This would make startup faster eg 900 ms -> 700 ms.
		//	Unfortunately can't use it. It tries to optimize editorExtension asseblies too. Then exception because can't load.
		//	Never mind: possible workaround: load it in _Assembly_Resolving().
		//try {
		//	var poDir = folders.ThisAppDataLocal + "optimization";
		//	if (!Directory.Exists(poDir)) Directory.CreateDirectory(poDir);
		//	AssemblyLoadContext.Default.SetProfileOptimizationRoot(poDir);
		//	AssemblyLoadContext.Default.StartProfileOptimization("main");
		//}
		//catch (Exception ex) { Debug_.Print(ex); }
		
		//Debug_.PrintLoadedAssemblies(true, !true);
		
		//load settings in parallel, while Settings still not used. Saves 50 ms. After SetThisAppFoldersEtc_.
		Task task1 = Task.Run(() => {
			AppSettings.Load();
			//Debug_.PrintLoadedAssemblies(true, !true);
		});
		
		_Main(args, task1);
		return 0;
	}
	
	[MethodImpl(MethodImplOptions.NoInlining)]
	static void _Main(string[] args, Task task1) {
		//Debug_.PrintLoadedAssemblies(true, !true);
		
		AppDomain.CurrentDomain.UnhandledException += _UnhandledException;
		process.ThisThreadSetComApartment_(ApartmentState.STA);
		process.thisProcessCultureIsInvariant = true;
		if (!Debugger.IsAttached) DebugTraceListener.Setup(usePrint: true);
		Directory.SetCurrentDirectory(folders.ThisApp); //it is c:\windows\system32 when restarted as admin
		Api.SetSearchPathMode(Api.BASE_SEARCH_PATH_ENABLE_SAFE_SEARCHMODE | Api.BASE_SEARCH_PATH_PERMANENT); //let SearchPath search in current directory after system directories
		Api.SetErrorMode(Api.SEM_FAILCRITICALERRORS); //disable some error message boxes, eg when removable media not found; MSDN recommends too.
		
		if (CommandLine.ProgramStarted2(args)) return;
		
#if IDE_LA
		PrintServer = new(miscInfo.isChildSession) { NoNewline = true };
#else
		PrintServer = new(true) { NoNewline = true };
#endif
		PrintServer.Start();
#if DEBUG
		print.qm2.use = !true;
		_RemindToBuildAllPlatforms();
#endif
		_envVarUpdater = new();
		
		AssemblyLoadContext.Default.Resolving += _Assembly_Resolving;
		AssemblyLoadContext.Default.ResolvingUnmanagedDll += _UnmanagedDll_Resolving;
		
		_app = new() { ShutdownMode = ShutdownMode.OnMainWindowClose }; //before LoadWorkspace etc, because need _app.Dispatcher ASAP
		SynchronizationContext.SetSynchronizationContext(new DispatcherSynchronizationContext()); //some code may use await before Application.Run. Without this it would continue in a TP thread.
		
		Tasks = new RunningTasks();
		ScriptEditor.IconNameToXaml_ = DIcons.GetIconString;
		
		task1.Wait(); //note: code executed before this must not use Settings
		
		FilesModel.LoadWorkspace(CommandLine.WorkspaceDirectory);
		CommandLine.ProgramLoaded();
		Loaded = AppState.LoadedWorkspace;
		
		TrayIcon.Update_();
		
		_app.MainWindow = Wmain = new MainWindow();
		if (!Settings.runHidden || CommandLine.StartVisible || (App.Settings.startVisibleIfNotAutoStarted && !CommandLine.AutoStarted)) ShowWindow();
		
		_timer = timer.every(1000, _TimerProc);
		
		_app.Dispatcher.InvokeAsync(() => {
			AppSettings.SetReloadModifiedExternally();
			Model.RunStartupScripts(false);
			if (miscInfo.isChildSession) PipIPC.StartPipeServerThread(); //after RunStartupScripts. If pipe server now will start a script, it will start after startup scripts with role editorExtension.
		});
		
		AppDomain.CurrentDomain.UnhandledException -= _UnhandledException;
		if (!Debugger.IsAttached) {
			_app.DispatcherUnhandledException += (_, e) => {
				e.Handled = 1 == dialog.showError("Exception", e.Exception.ToStringWithoutStack(), "1 Continue|2 Exit", DFlags.Wider, Hmain, e.Exception.ToString());
			};
		}
		
		try {
			_app.Run();
			//Hidden app should start as fast as possible, because usually starts with Windows.
			//Tested with native message loop (before show window). Faster by 70 ms (240 vs 310 without the .NET startup time).
			//	But then problems. Eg cannot auto-create main window synchronously, because need to exit native loop and start WPF loop.
		}
		catch (Exception e1) when (!Debugger.IsAttached) {
			_timer.Stop();
			Wmain.Close();
			dialog.showError("Exception", e1.ToString(), flags: DFlags.Wider);
		}
		finally { MainFinally_(); }
	}
	
	internal static void MainFinally_() {
		if (Loaded == AppState.Unloaded) return;
		Loaded = AppState.Unloading;
		
		_timer.Stop(); //eg if will show a Debug.Assert dialog
		
		var fm = Model; Model = null;
		fm.Dispose(); //stops tasks etc
		
		Loaded = AppState.Unloaded;
		
		PrintServer.Stop();
	}
	
	class _Application : Application {
		protected override void OnSessionEnding(SessionEndingCancelEventArgs e) {
			base.OnSessionEnding(e);
			Wmain.Close();
			MainFinally_();
			process.thisProcessExitInvoke(); //OS terminates this process before or during process.thisProcessExit event
		}
	}
	
	//public static Application Instance => _app; //Application.Current
	static _Application _app;
	
	/// <summary>
	/// <b>Dispatcher</b> of main thread.
	/// </summary>
	public static Dispatcher Dispatcher => _app?.Dispatcher;
	
	/// <summary>
	/// true if called in the main thread.
	/// NOTE: don't use <c>Environment.CurrentManagedThreadId == 1</c>, it's not always 1 in the main thread.
	/// </summary>
	public static bool IsMainThread => process.IsLaMainThread_;
	
	/// <summary>
	/// Main window.
	/// Not loaded if never was visible.
	/// Use only in main thread; if other threads need <b>Dispatcher</b> of main thread, use <see cref="Dispatcher"/>.
	/// </summary>
	public static MainWindow Wmain { get; private set; }
	
	/// <summary>
	/// Main window handle.
	/// defaul(wnd) if never was visible.
	/// </summary>
	public static wnd Hmain { get; internal set; }
	
	public static void ShowWindow() {
		//workaround for WPF bug: Window.Show pumps posted messages.
		//	And crashes if a message causes to call Show again.
		//	To reproduce, let the program start hidden, and double-click the tray icon.
		if (_sw1) return;
		
		_sw1 = true;
		Wmain.Show(); //auto-creates MainWindow if never was visible
		_sw1 = false;
		Hmain.ActivateL(true);
	}
	static bool _sw1;
	
	static void _UnhandledException(object sender, UnhandledExceptionEventArgs e) {
#if DEBUG
		print.qm2.write(e.ExceptionObject);
#else
		dialog.showError("Exception", e.ExceptionObject.ToString(), flags: DFlags.Wider);
#endif
	}
	
	private static Assembly _Assembly_Resolving(AssemblyLoadContext alc, AssemblyName an) {
		if (0 == an.Name.Starts(false, "NuGet.", "Microsoft.Web.WebView2.")) {
			var dlls = _arDlls ??= filesystem.enumFiles(folders.ThisAppBS + "Roslyn", "*.dll", FEFlags.UseRawPath)
				.ToDictionary(o => o.Name[..^4], o => o.FullPath);
			if (dlls.TryGetValue(an.Name, out var path)) return alc.LoadFromAssemblyPath(path);
			
			if (_FindEditorExtensionInStack(out var asm)) return MiniProgram_.ResolveAssemblyFromRefPathsAttribute_(alc, an, asm);
			
			Debug_.Print(an.FullName);
			//print.qm2.write(an);
		}
		return alc.LoadFromAssemblyPath(folders.ThisAppBS + an.Name + ".dll");
	}
	static Dictionary<string, string> _arDlls;
	
	private static IntPtr _UnmanagedDll_Resolving(Assembly _, string name) {
		//print.it("_UnmanagedDll_Resolving", name);
		
		//resolve native dlls used by meta pr libraries that are used by editorExtension scripts.
		//	These libraries are loaded in default context.
		//	editorExtension assemblies are loaded in other contexts.
		//	Dlls directly used by editorExtension assemblies are resolved in RunAssembly.Run.
		if (_FindEditorExtensionInStack(out var asm)) return MiniProgram_.ResolveUnmanagedDllFromNativePathsAttribute_(name, asm);
		return default;
	}
	
	static bool _FindEditorExtensionInStack(out Assembly asm) {
		var st = new StackTrace(2); //not too slow
		for (int i = 0; ; i++) {
			var f = st.GetFrame(i); if (f == null) break;
			asm = f.GetMethod()?.DeclaringType?.Assembly;
			if (asm != null && asm.GetName().Name.Contains('|')) return true; //ScriptName|GUID
		}
		asm = null;
		return false;
	}
	
	internal static void InitThisAppFoldersEtc_(string[] args = null) {
		dialog.options.defaultTitle = AppName + " message";
		folders.Editor = folders.ThisApp;
		
		if (args != null) {
			if (filesystem.exists(folders.ThisAppBS + "data")) {
				IsPortable = true;
				ScriptEditor.IsPortable = true;
				
				//CONSIDER: when changed portable user (SID), delete folders.ThisAppDataLocal (\data\appLocal).
				//	LA/Au currently uses it only for the icon cache.
				//	But some scripts may not want it.
				//	Probably should delete folders.ThisAppTemp (\data\temp).
				
				//on ARM64, if Au.Editor.exe is x64, run Au.Editor-arm.exe instead
				if (!osVersion.isArm64Process && osVersion.isArm64OS) _RestartArm64(args);
			}
			
			try {
				//create now if does not exist
				_ = folders.ThisAppDocuments;
				_ = folders.ThisAppDataLocal;
				_ = folders.ThisAppDataRoaming;
#if IDE_LA
				folders.ThisAppTemp = new(folders.Temp + "LibreAutomate_2");
#else
				folders.ThisAppTemp = new(folders.Temp + (miscInfo.isChildSession ? @"LibreAutomate\PiP" : "LibreAutomate"));
#endif
				//these are currently not used in editor and library, but may be used in scripts. Just prevent changing.
				folders.noAutoCreate = true;
				_ = folders.ThisAppDataCommon; //Created by the installer (it requires admin rights). Should be used only for data installed by the installer.
				_ = folders.ThisAppImages;
				folders.noAutoCreate = false;
			}
			catch (Exception e1) {
				dialog.showError("Failed to set app folders", e1.ToString());
				Environment.Exit(1);
			}
			
		} else {
			if (filesystem.exists(folders.ThisAppBS + "data")) {
				ScriptEditor.IsPortable = true;
			}
		}
	}
	
#if DEBUG
	static void _RemindToBuildAllPlatforms() {
		if (IsAtHome)
			if (filesystem.GetTime_(folders.ThisAppBS + @"..\Cpp", out var t64)) {
				if (!filesystem.GetTime_(folders.ThisAppBS + @"32\AuCpp.dll", out var t32) || t64 > t32) print.it("Note: may need to build Cpp project x86.");
				if (!filesystem.GetTime_(folders.ThisAppBS + @"64\ARM\AuCpp.dll", out var tARM) || t64 > tARM) print.it("Note: may need to build Cpp project ARM64.");
			}
	}
#endif
	
	internal static void OnMainWindowLoaded_() {
		if (IsPortable) {
			print.it($"<>Info: <help editor/Portable app>portable mode<>. Using <link {folders.PortableData_}>data<> folder.");
		} else {
			//in v0.12 changed some spec folders from "...\Au" to "...\LibreAutomate\_script"
			//	FUTURE: delete this code.
			_Folder(folders.Documents, "folders.ThisAppDocuments");
			_Folder(folders.LocalAppData, "folders.ThisAppDataLocal");
			static void _Folder(string dir, string name) {
				var dir1 = dir + @"\Au";
				if (filesystem.exists(dir1, useRawPath: true)) {
					var dir2 = dir + @"\LibreAutomate\_script";
					if (!filesystem.exists(dir2, useRawPath: true)) {
						try {
							filesystem.copy(dir1, dir2);
							print.it($"""
							<>Note: in this program version has been changed <help>{name}<> path.
								Old: <explore>{dir1}<>. The folder is no longer used. You can delete it.
								New: <explore>{dir2}<>. The old folder has been copied here.
							""");
						}
						catch { }
					}
				}
			}
			
			if (_raaResult is not (WinScheduler.RResult.None or WinScheduler.RResult.ArgN)) {
				var s1 = _raaResult == WinScheduler.RResult.TaskNotFound ? null : $"\r\n\tFailed to run as administrator. Error: {_raaResult}.";
				var s = $"""
<>Info: running not as administrator. <fold>
	Without admin rights this program cannot automate admin windows etc. See <help articles/UAC>UAC<>.{s1}
	Restart as administrator: <+restartAdmin >now<>, <+restartAdmin /raa>now and always<> (later without UAC consent).
	</fold>
""";
				print.it(s);
				Panels.Output.Scintilla.AaTags.AddLinkTag("+restartAdmin", k => Restart(k, admin: true));
			} else if (CommandLine.Raa) { //restarted because clicked link "Restart as administrator: now and always"
				var name = IsAtHome ? "_Au.Editor" : "Au.Editor";
				bool ok = 0 == WinScheduler.CreateTaskWithoutTriggers("Au", name, UacIL.System, process.thisExePath, "/s $(Arg0)", AppName);
				if (!ok) print.warning(@"Failed to create Windows Task Scheduler task \Au\Au.Editor.", -1);
				
				//note: don't create the task in the setup program. It requires a C++ dll, and it triggers AV false positives.
			}
		}
	}
	
	internal static void OnMainWindowClosed_() {
		_timer.Stop();
	}
	
	static WinScheduler.RResult _raaResult;
	
	static bool _RestartAsAdmin(string[] args) {
		if (Debugger.IsAttached) return false; //very fast
		bool home = IsAtHome;
		string sesId = process.thisProcessSessionId.ToS();
		args = args.Length == 0 ? [sesId] : args.InsertAt(0, sesId);
		(int pid, _raaResult) = WinScheduler.RunTask("Au",
			home ? "_Au.Editor" : "Au.Editor", //in C:\code\au\_ or <installed path>
			process.thisExePath, true, args);
		if (pid == 0) { //probably this program is not installed (no scheduled task)
			if (home) print.qm2.write("failed to run as admin", _raaResult);
			return false;
		}
		//Api.AllowSetForegroundWindow(pid); //fails and makes no sense
		return true;
	}
	
	/// <summary>
	/// Restarts this program.
	/// </summary>
	/// <param name="commandLine">Command line arguments to append. Don't use /n and /v because this func manages it.</param>
	/// <param name="admin">UAC-elevate (verb runas).</param>
	public static void Restart(string commandLine = null, bool admin = false) {
		Debug.Assert(Loaded == AppState.LoadedUI);
		var cl = Hmain.IsVisible ? "/n /v /restart" : "/n /restart";
		if (!commandLine.NE()) cl = cl + " " + commandLine;
		process.thisProcessExit += _ => { run.it(process.thisExePath, cl, admin ? RFlags.Admin : RFlags.InheritAdmin); };
		_app.Shutdown(); //closes window async, with no possibility to cancel
	}
	
	static unsafe void _RestartArm64(string[] args) {
		var s = process.thisExePath;
		if (!s.Ends(@"\Au.Editor.exe", true)) return;
		s = s.Insert(^4, "-arm");
		if (!filesystem.exists(s).File) return;
		
		var sa = StringUtil.CommandLineFromArray(args.Where(o => !(o is "/n" or "-n" or "/restart")).Prepend("/restart").Prepend("/n").ToArray());
		
		var ps = new ProcessStarter_(s, sa);
		try { ps.Start(inheritUiaccess: true); }
		catch { return; }
		
		Environment.Exit(0);
	}
	
	/// <summary>
	/// Timer with 1 s period.
	/// </summary>
	public static event Action Timer1s;
	
	/// <summary>
	/// Timer with 1 s period when main window hidden and 0.25 s period when visible.
	/// </summary>
	public static event Action Timer1sOr025s;
	
	/// <summary>
	/// Timer with 0.25 s period, only when main window visible.
	/// </summary>
	public static event Action Timer025sWhenVisible;
	
	/// <summary>
	/// Timer with 1 s period, only when main window visible.
	/// </summary>
	public static event Action Timer1sWhenVisible;
	
	/// <summary>
	/// True if Timer1sOr025s period is 0.25 s (when main window visible), false if 1 s (when hidden).
	/// </summary>
	public static bool IsTimer025 => _timerCounter > 0;
	static uint _timerCounter;
	
	static void _TimerProc(timer t) {
		Timer1sOr025s?.Invoke();
		bool needFast = Wmain.IsVisible;
		if (needFast != (_timerCounter > 0)) t.Every(needFast ? 250 : 1000);
		if (needFast) {
			Timer025sWhenVisible?.Invoke();
			_timerCounter++;
		} else _timerCounter = 0;
		if (0 == (_timerCounter & 3)) {
			Timer1s?.Invoke();
			if (needFast) Timer1sWhenVisible?.Invoke();
		}
	}
	static timer _timer;
	
	public static AppState Loaded;
	
	public static bool IsAtHome { get; } = Api.EnvironmentVariableExists("Au.Home<PC>") && folders.ThisAppBS.Eqi(@"C:\code\au\_\");
	
	public static bool IsPortable { get; private set; }
	
	/// <summary>
	/// Calls <i>action</i> in try/catch, and manages filesystem sync (still not implemented). On exception prints message and returns false.
	/// </summary>
	/// <param name="paths">Path of the destination file used in the filesystem operation. On move pass 2 paths: destination and source. This info is used by filesystem watchers to detect and ignore files saved by own process.</param>
	/// <param name="action"></param>
	public static bool TryFileOperation(ReadOnlySpan<string> paths, Action action) {
		try { action(); }
		catch (Exception ex) { print.warning(ex); return false; }
		return true;
	}
	
	public static async void CheckForUpdates(System.Windows.Controls.Button b = null) {
		bool forceNow = b != null;
		int day = (int)(DateTime.Now.Ticks / 864000000000);
		if (!forceNow && day == App.Settings.checkForUpdatesDay) return;
		App.Settings.checkForUpdatesDay = day;
		
		if (forceNow) b.IsEnabled = false;
		try {
			var r = await internet.http.GetAsync("https://www.libreautomate.com/version.txt");
			r.EnsureSuccessStatusCode();
			var s = await r.Content.ReadAsStringAsync();
			s = s.Lines()[0];
			if (s != Au_.Version && System.Version.TryParse(Au_.Version, out var v1) && System.Version.TryParse(s, out var v2) && v2 > v1) {
				//Panels.Output.Scintilla.AaTags.AddLinkTag("+appUpdate", _Update);
				//print.it($"<>{AppNameShort} {s} is available. The installed version is {Au_.Version}.  [<+appUpdate>update...<>]  [<link https://github.com/qgindi/LibreAutomate/tree/master/Other/DocFX/_doc/changes>changes<>]  [<link https://www.libreautomate.com>website<>]");
				print.it($"<>{AppName} {s} is available. The installed version is {Au_.Version}.  [<link https://github.com/qgindi/LibreAutomate/tree/master/Other/DocFX/_doc/changes>changes<>]  [<link https://www.libreautomate.com>download<>]");
			} else if (forceNow) {
				dialog.showInfo(null, $"{AppName} is up to date. Version {Au_.Version}.", owner: Hmain);
			}
		}
		catch (Exception e1) { if (forceNow) print.warning(e1); }
		finally { if (forceNow) b.IsEnabled = true; }
		
		//static async Task _Update(string s) {
		//	if (!dialog.showOkCancel(null, $"This will download and install the new {AppNameShort} version.")) return;
		//	try {
		
		//	}
		//	catch (Exception e1) { print.warning(e1); }
		//}
	}
}

enum AppState {
	/// <summary>
	/// Before the first workspace fully loaded.
	/// </summary>
	Loading,
	
	/// <summary>
	/// The first workspace is fully loaded etc, but the main window not.
	/// </summary>
	LoadedWorkspace,
	
	/// <summary>
	/// The main window is loaded and either visible now or was visible and now hidden.
	/// </summary>
	LoadedUI,
	
	/// <summary>
	/// Unloading workspace, stopping everything.
	/// </summary>
	Unloading,
	
	/// <summary>
	/// Main window closed, workspace unloaded, everything stopped.
	/// </summary>
	Unloaded,
}


================================================
FILE: Au.Editor/App/AppSettings.cs
================================================
using System.Text.Json;
using System.Text.Json.Serialization;

namespace LA;
//note: used in ToolLand too.

/// <summary>
/// Application settings.
/// folders.ThisAppDocuments + @".settings\Settings.json"
/// </summary>
record AppSettings : JSettings {
	//This is loaded at startup and therefore must be fast.
	//	NOTE: Don't use types that would cause to load UI dlls (WPF etc). Eg when it is a nested type and its parent class is a WPF etc control.
	//	Speed: first time 80 ms. Mostly to load/jit/etc dlls used by JsonSerializer. Later fast regardless of data size.
	
	public static JsonSerializerOptions SerializerOptions2 { get; } = new(JSettings.SerializerOptions) { PreferredObjectCreationHandling = JsonObjectCreationHandling.Populate, IgnoreReadOnlyFields = false };
	//note: don't modify JSettings.SerializerOptions. Would be unexpected for editorExtension scripts.
	
	public static void Load() { //in TP thread
		var r = Load<AppSettings>(DirBS + "Settings.json", jsOpt: SerializerOptions2);
		r._Loaded();
		App.Settings = r;
	}
	
	public static void SetReloadModifiedExternally() { //in main thread
		App.Settings.ModifiedExternally += static () => {
			if (!App.Settings.Reload(out AppSettings r)) return;
			r._Loaded();
			Debug_.PrintIf(r.session.user != App.Settings.session.user);
			r.session.user = App.Settings.session.user;
			App.Settings = r;
		};
		
		//Never mind: Currently only Settings.json is synced. There are many other settings/snippets/etc files. Some are separate in PiP. It's important to sync Settings.json if using PiP.
	}
	
	void _Loaded() {
		if (session_main == null) _InitSessionSettings();
		session = miscInfo.isChildSession ? session_pip ??= new() : session_main;
		_NE(ref session.user) ??= Guid.NewGuid().ToString();
		session.hotkeys ??= new();
		(font_output ??= new()).Normalize("Consolas", 9);
		(font_find ??= new()).Normalize("Consolas", 9);
	}
	
	static ref string _NE(ref string s) {
		if (s == "") s = null;
		return ref s;
	}
	
#if IDE_LA
	public static readonly string DirBS = folders.ThisAppDocuments + @".settings_\";
#else
	public static readonly string DirBS = folders.ThisAppDocuments + @".settings\";
#endif
	
	#region settings that are different in main and child (PiP) session
	
	public record session_t {
		public string user;
		public bool runHidden, startVisibleIfNotAutoStarted;
		public bool checkForUpdates;
		public int checkForUpdatesDay;
		public int wpfpreview_xy;
		public wndpos_t wndpos;
		public hotkeys_t hotkeys;
	}
	public session_t session_main, session_pip;
	[JsonIgnore] public session_t session;
	
	[JsonIgnore] public ref bool runHidden => ref session.runHidden;
	[JsonIgnore] public ref bool startVisibleIfNotAutoStarted => ref session.startVisibleIfNotAutoStarted;
	[JsonIgnore] public string userGuid => session.user;
	[JsonIgnore] public ref bool checkForUpdates => ref session.checkForUpdates;
	[JsonIgnore] public ref int checkForUpdatesDay => ref session.checkForUpdatesDay;
	[JsonIgnore] public ref int wpfpreview_xy => ref session.wpfpreview_xy;
	
	//saved positions of various windows
	public record struct wndpos_t {
		public string main, wnd, elm, uiimage, ocr, recorder, icons, symbol;
	}
	[JsonIgnore] public ref wndpos_t wndpos => ref session.wndpos;
	
	//Options > Hotkeys
	public record hotkeys_t {
		public string
			tool_quick = "Ctrl+Shift+Q",
			tool_wnd = "Ctrl+Shift+W",
			tool_elm = "Ctrl+Shift+E",
			tool_uiimage
			;
	}
	[JsonIgnore] public hotkeys_t hotkeys => session.hotkeys;
	
	void _InitSessionSettings() {
		//previously there were no session settings. Copy from the JSON root if need. Else existing users would lose their settings.
		if (user != null) {
			try {
				var file = DirBS + "Settings.json";
				if (filesystem.exists(file)) {
					session_main = JsonSerializer.Deserialize<session_t>(filesystem.loadBytes(file), SerializerOptions2);
				}
				user = null;
			}
			catch (Exception ex) { Debug_.Print(ex); }
		}
		
		session_main ??= new();
	}
	[JsonInclude] string user; //it's one of fields that previoulsy were in the JSON root but now are in a nested record. Now this field is used to detect the old format.
	
	#endregion
	
	public string workspace;
	public string[] recentWS;
	
	//When need a nested type, use record class. Everything works well; later can add/remove members like in main type.
	//Don't use record struct when need to set init values (now or in the future), because:
	//	1. Older .NET versions don't support it, or have bugs.
	//		Eg .NET 6.0.3 throws "InvalidCastException, Unable to cast object of type 'System.String' to type 'hotkeys_t'" when `public record hotkeys_t()` (need the `()` when using default field values).
	//			Works if `public record hotkeys_t(string a, string b)`, but then need 'new("a", "b")'; I don't like it etc.
	//	2. If `public record hotkeys_t(string a, string b)`, and later added a new member like `, c = "value"`, the value is null/0. The deserializer uses the default ctor.
	//		Also the same happens if somebody deletes an existing member from JSON.
	//		Works well with `public record hotkeys_t()`, but cannot use it because of 1.
	//Note: deserializer always creates new object, even if default object created. Avoid custom ctors etc.
	//If like `public hotkeys_t hotkeys = new()`, creates new object 2 times: 1. explicit new(); 2. when deserializing. Also in JSON can be `= null`. Move the `new()` to _Loaded.
	//Tuple does not work well. New members are null/0. Also item names in file are like "Item1".
	
	//font of various UI parts
	public record font_t {
		public string name;
		public double size;
		
		string _defName;
		double _defSize;
		
		internal void Normalize(string defName, double defSize) {
			_defName = defName;
			_defSize = defSize;
			Normalize();
		}
		
		public void Normalize() {
			if (name.NE()) name = _defName;
			if (size == 0) size = _defSize; else size = Math.Clamp(size, 6, 30);
		}
	}
	public font_t font_output, font_find;
	
	//Options > Templates
	public int templ_use;
	//public int templ_flags;
	
	//Options > Other
	public string internetSearchUrl { get => field ?? "https://www.google.com/search?q="; set { field = value.NullIfEmpty_(); } }
	public bool doc_web;
	public bool? comp_printCompiled = false;
	
	//code editor
	public bool edit_wrap, edit_noImages;
	public string edit_theme;
	
	//code info, autocorrection, formatting
	public bool ci_complGroup = true, ci_formatCompact = true, ci_formatTabIndent = true, ci_formatAuto = true, ci_semicolon = true;
	public bool ci_enterBeforeParen = true, ci_enterBeforeSemicolon = true, ci_tempRawEnter;
	public int ci_complParen { get => field; set { field = value.EnsureValid_(0, 2); } }
	public int ci_enterWith { get => field; set { field = value.EnsureValid_(0, 2); } }
	public int ci_rename;
	
	//AI
	public readonly DictionaryI_<string> ai_ak = new();
	public string ai_modelEmbed, ai_modelRerank/*, ai_modelChat*/;
	//public string ai_modelIconSearch;
	public bool ai_mcp_print;
	
	//panel Files
	public bool files_multiSelect;
	
	//file type icons
	public record struct icons_t {
		public string ft_script, ft_class, ft_folder, ft_folderOpen;
	}
	public icons_t icons;
	
	//panel Output
	public bool output_wrap, output_white;
	
	//panel Outline
	public byte outline_flags;
	
	//panel Open
	public byte openFiles_flags;
	
	//panel Mouse
	public bool mouse_singleLine;
	public int mouse_limitText = 100;
	
	//panel Debug
	public record debug_t {
		public bool stepIntoAll, noJMC, printVarCompact, activateLA;
		public double hVar = 150, hStack = 100;
		public byte breakT = 15; //flags: 1 enabled, 2 the exceptions list is active, 4 not exceptions in the list, 8 when caught
		public byte breakU = 1; //flags: 1 enabled
		const string c_defNotExc = """
System.OperationCanceledException
System.Threading.Tasks.TaskCanceledException

""";
		public string breakListT = c_defNotExc, breakListU = c_defNotExc;
		public byte printEvents;
	}
	public readonly debug_t debug = new();
	
	//settings common to various tools
	public bool tools_pathUnexpand = true, tools_pathLnk;
	
	//DIcons
	public int dicons_listColor;
	public bool dicons_contrastUse;
	public string dicons_contrastColor = "#E0E000";
	
	//DPortable
	public string portable_dir;
	public int portable_check = -1;
	public string[] portable_skip;
	
	//DSnippets
	public Dictionary<string, HashSet<string>> ci_hiddenSnippets;
	
	//CiGoTo
	public record gotoAsm_t {
		public string repo, path, context;
		public bool csharp;
		public gotoAsm_t() { csharp = true; }
	}
	public Dictionary<string, gotoAsm_t> ci_gotoAsm;
	public int ci_gotoTab;
	
	//CiFindGo
	public bool ci_findgoDclick;
	
	//DInputRecorder
	public record recorder_t {
		public bool keys = true, text = true, text2 = true, mouse = true, wheel, drag, move;
		public int xyIn;
		public string speed = "10";
	}
	public readonly recorder_t recorder = new();
	
	//Delm
	public record delm_t {
		public string hk_capture = "F3", hk_insert = "F4", hk_smaller = "Shift+F3"; //for all tools
		public string def_wait, def_action;
		public bool? def_UIA;
		public int flags;
	}
	public readonly delm_t delm = new();
	
	//DOcr
	public record ocr_t {
		public string wLang, tLang, tCL, gKey, gFeat, gIC, mUrl, mKey;
	}
	public ocr_t ocr;
	
	//panel Find
	public string find_skip;
	public int find_searchIn, find_printSlow = 50;
	public bool find_parallel, find_case, find_word;
	
	//DNuget
	public bool nuget_noPrerelease;
	
	//other
	public int publish, export;
	public bool? minimalSDK;
	public string nilesoftShellDir;
}

/// <summary>
/// Workspace settings.
/// WorkspaceDirectory + @"\settings.json"
/// </summary>
record WorkspaceSettings : JSettings {
	public static WorkspaceSettings Load(string jsonFile) => Load<WorkspaceSettings>(jsonFile);
	
	public record User(string guid) {
		public string startupScripts, gitUrl;
		public bool gitBackup;
	}
	public User[] users;
	
	public User CurrentUser {
		get {
			if (_cu == null) {
				_cu = users?.FirstOrDefault(o => o.guid == App.Settings.userGuid);
				if (_cu == null) {
					_cu = new User(App.Settings.userGuid);
					users = users == null ? new[] { _cu } : users.InsertAt(0, _cu);
				}
			}
			return _cu;
		}
	}
	User _cu;
	
	public string ci_skipFolders;
	
	public string syncfs_skip = """
*\.git
*\.vs
*\bin
*\obj

""";
}


================================================
FILE: Au.Editor/App/CommandLine.cs
================================================

namespace LA;

static class CommandLine {
	/// <summary>
	/// Processes the command line of this program. Called before any initialization.
	/// Returns true if this instance must exit.
	/// </summary>
	public static bool ProgramStarted1(ReadOnlySpan<string> args, out int exitCode) {
#if IDE_LA && !true //test 2 LA instances, eg when developing filesystem sync for PiP
		if (args is ["/second"]) {
			typeof(miscInfo).GetField("s_isChildSession", BindingFlags.NonPublic | BindingFlags.Static).SetValue(null, (bool?)true);
		} else if (args.Length == 0) {
			Task.Run(() => {
				1.s();
				var id2 = new ProcessStarter_(process.thisExePath, "/second").Start().pid;
				var w1 = wnd.wait(-5, false, "LibreAutomate", of: WOwner.Process(process.thisProcessId));
				var w2 = wnd.wait(-5, false, "LibreAutomate", of: WOwner.Process(id2));
				if (w1.Is0 || w2.Is0) return;
				w1.ShowNotMinMax();
				w2.ShowNotMinMax();
				var r = screen.at.left().WorkArea;
				int k = r.right;
				r.Width /= 2;
				w1.MoveL(r);
				r.left = r.right; r.right = k;
				w2.MoveL(r);
			});
		}
#endif
		
		//print.it(process.thisExeName, args.ToArray());
		exitCode = 0; //note: Environment.ExitCode bug: the setter's set value is ignored and the process returns 0.
		if (args.Length > 0) {
			switch (args[0]) {
			case "/s":
				exitCode = _RunEditorAsAdmin();
				return true;
			case "/pip":
				exitCode = Pip.Run(args[1..]);
				return true;
			case "/dd":
				UacDragDrop.NonAdminProcess.MainDD(args[1..]);
				return true;
			case "/tool":
				ToolLand.ToolProcess.Run(args[1..]);
				return true;
			case "/mcp":
				McpServer.Run(args[1..]);
				return true;
			}
			
			string argN = null; if (args is ["/n" or "-n", ..]) { argN = args[0]; args = args[1..]; }
			
			if (args.Length > 0 && args[0] is var s && !s.NE()) {
				if (s[0] is '/' or '-') {
				} else if (!pathname.isFullPath(s)) {
					exitCode = _LetEditorRunScript(args, argN);
					return true;
				}
			}
		}
		return false;
	}
	
	/// <summary>
	/// Processes the command line of this program. Called after partial initialization.
	/// Returns true if this instance must exit:
	/// 	1. If finds previous program instance; then sends the command line to it if need.
	/// 	2. If incorrect command line.
	/// </summary>
	public static bool ProgramStarted2(string[] args) {
		string s = null;
		int cmd = 0; //1 open workspace, 2 import workspace, 3 import files, -5 reload workspace
		bool restarting = false;
		if (args.Length > 0) {
			//print.it(args);
			s = args[0];
			if (s is ['/' or '-', ..]) {
				for (int i = 0; i < args.Length; i++) {
					s = args[i];
					bool good = s is ['/' or '-', ..];
					if (good) {
						switch (s.AsSpan(1)) {
						case "v":
							StartVisible = true;
							break;
						case "a":
							AutoStarted = true;
							break;
						case "reload":
							cmd = -5;
							break;
						case "restart":
							restarting = true;
							break;
						case "raa":
							Raa = true;
							break;
						case "test":
							if (++i < args.Length) TestArg = args[i];
							break;
						case "second":
							return false;
						default:
							good = false;
							break;
						}
					}
					if (!good) {
						dialog.showError("Unknown command line parameter", s);
						return true;
					}
				}
				s = null;
			} else { //one or more files
				if (args.Length == 1 && FilesModel.IsWorkspaceDirectoryOrZip_ShowDialogOpenImport(s, out cmd)) {
					switch (cmd) {
					case 1: WorkspaceDirectory = s; break;
					case 2: _importWorkspace = s; break;
					default: return true;
					}
				} else {
					cmd = 3;
					_importFiles = args;
				}
				StartVisible = true;
			}
		}
		
		//single instance
#if IDE_LA
		s_mutex = new Mutex(true, "Au.Editor.Mutex.m3gVxcTJN02pDrHiQ00aSQ_IDE_LA", out bool createdNew);
#else
		s_mutex = new Mutex(true, "Au.Editor.Mutex.m3gVxcTJN02pDrHiQ00aSQ", out bool createdNew);
#endif
		if (createdNew) return false;
		if (restarting) return Api.WaitForSingleObject(s_mutex.SafeWaitHandle.DangerousGetHandle(), 5000) is Api.WAIT_TIMEOUT or Api.WAIT_FAILED;
		
		var w = wnd.findFast(null, ScriptEditor.c_msgWndClassName, true);
		if (!w.Is0) {
			w.Send(Api.WM_USER, 0, 1); //auto-creates, shows and activates main window
			
			if (cmd != 0) {
				Thread.Sleep(100);
				
				if (cmd > 0) { //pass string
					if (cmd == 3) s = string.Join("\0", args); //import files
					WndCopyData.Send<char>(w, cmd, s);
				} else {
					w.Send(Api.WM_USER, -cmd);
				}
			}
		}
		return true;
	}
	static Mutex s_mutex; //GC
	
	/// <summary>
	/// null or argument after "/test".
	/// </summary>
	public static string TestArg;
	
	/// <summary>
	/// true if /v
	/// </summary>
	public static bool StartVisible;
	
	/// <summary>
	/// true if /a
	/// </summary>
	public static bool AutoStarted;
	
	/// <summary>
	/// true if /raa
	/// </summary>
	public static bool Raa;
	
	/// <summary>
	/// Called after loading workspace. Before executing startup scripts, adding tray icon and creating UI.
	/// </summary>
	public static void ProgramLoaded() {
		WndUtil.UacEnableMessages(Api.WM_COPYDATA, /*Api.WM_DROPFILES, 0x0049,*/ Api.WM_USER, Api.WM_CLOSE);
		//WM_COPYDATA, WM_DROPFILES and undocumented WM_COPYGLOBALDATA=0x0049 should enable drag-drop from lower UAC IL processes, but only through WM_DROPFILES/DragAcceptFiles, not OLE D&D.
		
		WndUtil.RegisterWindowClass(ScriptEditor.c_msgWndClassName, _WndProc);
		_msgWnd = WndUtil.CreateMessageOnlyWindow(ScriptEditor.c_msgWndClassName);
		script.s_wndEditorMsg = _msgWnd;
	}
	
	/// <summary>
	/// Called from MainWindow.Loaded.
	/// </summary>
	public static void UILoaded() {
		if (_importWorkspace != null || _importFiles != null) {
			App.Dispatcher.InvokeAsync(() => {
				try {
					if (_importWorkspace != null) App.Model.ImportWorkspace(_importWorkspace);
					else App.Model.ImportFiles(_importFiles);
				}
				catch (Exception ex) { print.warning(ex); }
			}, System.Windows.Threading.DispatcherPriority.ApplicationIdle);
		}
	}
	
	/// <summary>
	/// null or workspace folder specified in command line.
	/// </summary>
	public static string WorkspaceDirectory;
	
	static string _importWorkspace;
	static string[] _importFiles;
	
	static wnd _msgWnd;
	
	/// <summary>
	/// The message-only window.
	/// Available after loading the first workspace.
	/// </summary>
	public static wnd MsgWnd => _msgWnd;
	
	static nint _WndProc(wnd w, int message, nint wparam, nint lparam) {
		try {
			switch (message) {
			case Api.WM_USER:
				if (App.Loaded >= AppState.Unloading) return 0;
				return _WmUser(wparam, lparam);
			case Api.WM_COPYDATA:
				if (App.Loaded >= AppState.Unloading) return 0;
				return _WmCopyData(wparam, lparam);
			case RunningTasks.WM_TASK_ENDED: //WM_USER+900
				App.Tasks.TaskEnded2(wparam, lparam);
				return 0;
			}
		}
		catch (Exception ex) { print.warning(ex); return 0; }
		
		return Api.DefWindowProc(w, message, wparam, lparam);
	}
	
	static nint _WmUser(nint wparam, nint lparam) {
		switch (wparam) {
		case 0: //ScriptEditor.MainWindow, etc
			if (lparam == 1) App.ShowWindow(); //else returns default(wnd) if never was visible
			return App.Hmain.Handle;
		case 1: //ScriptEditor.ShowMainWindow
			if (lparam == 0) lparam = App.Wmain.IsVisible ? 2 : 1; //toggle
			if (lparam == 1) App.ShowWindow();
			else App.Wmain.Hide_();
			return 0;
		case 3: //get wpf preview window saved xy
			return App.Settings.wpfpreview_xy;
		case 4: //save wpf preview window xy
			App.Settings.wpfpreview_xy = (int)lparam;
			break;
		case 5:
			Menus.File.Workspace.Reload_this_workspace();
			break;
		case 10:
			UacDragDrop.AdminProcess.OnTransparentWindowCreated((wnd)lparam);
			break;
		case 20: //Triggers.DisabledEverywhere
			TriggersAndToolbars.OnDisableTriggers();
			break;
		//case 21: //end task by process id. Currently not used.
		//	App.Tasks.TaskFromProcessId((int)lparam)?.End(false);
		//	break;
		case 30: //script.debug()
			return _ScriptDebug((int)lparam);
		}
		return 0;
		
		static nint _ScriptDebug(int processId) {
			if (processId == process.thisProcessId) { //a process can't debug itself
#if IDE_LA //to debug this second LA process use the primary LA process
				var w = wnd.findFast(null, ScriptEditor.c_msgWndClassName, true);
				if (w == MsgWnd) w = wnd.findFast(null, ScriptEditor.c_msgWndClassName, true, w);
				return w.Send(Api.WM_USER, 30, processId);
#else
				return 0;
#endif
			}
			if (!App.Wmain.IsVisible) App.ShowWindow(); else if (!App.Hmain.IsActive) { App.Hmain.TaskbarButton.Flash(3); /*timer.after(10000, _ => App.Hmain.TaskbarButton.Flash(0));*/ }
			return Panels.Debug.Attach(processId) ? 1 : 0;
		}
	}
	
	static nint _WmCopyData(nint wparam, nint lparam) {
		var c = new WndCopyData(lparam);
		int action = Math2.LoWord(c.DataId), action2 = Math2.HiWord(c.DataId);
		bool isString = action < 100;
		string s = isString ? c.GetString() : null;
		byte[] b = isString ? null : c.GetBytes();
		switch (action) {
		case 1: //command line (ProgramStarted2)
			FilesModel.LoadWorkspace(s);
			break;
		case 2: //command line (ProgramStarted2)
			App.Model.ImportWorkspace(s);
			break;
		case 3: //command line (ProgramStarted2)
			Api.ReplyMessage(1); //avoid 'wait' cursor while we'll show dialog
			App.Model.ImportFiles(s.Split('\0'));
			break;
		case 4: //ScriptEditor.Open
			Api.ReplyMessage(1);
			_OpenFile();
			break;
		case 5 or 6: //script.end(name) or script.isRunning(name)
			return _ScriptAction(action);
		case 10: //ScriptEditor.GetIcon
			s = DIcons.GetIconString(s, (EGetIcon)action2);
			return s == null ? 0 : WndCopyData.Return<char>(s, wparam);
		case 11: //ScriptEditor.InvokeCommand
			return Menus.Invoke(s, false, (int)wparam);
		case 12: //ScriptEditor.GetCommandState
			return Menus.Invoke(s, true, (int)wparam);
		//case 13: //ScriptEditor.Folders (rejected)
		//	s = string.Join('|', (string)folders.ThisAppDocuments, (string)folders.ThisAppDataLocal, (string)folders.ThisAppTemp);
		//	return WndCopyData.Return<char>(s, wparam);
		case 14: //ScriptEditor.GetFileInfo
			return _GetFileInfo(s) is byte[] r1 ? WndCopyData.Return<byte>(r1, wparam) : 0;
		case 15: //get styling for tools
			return WndCopyData.Return<byte>(CiUtil.GetScintillaStylingBytes8(s), wparam);
		case 16:
			return _GetCodeFileText(s, out var text1) ? WndCopyData.Return<char>(text1, wparam) : 0;
		case 17:
			InsertCode.Statements(System.Text.Json.JsonSerializer.Deserialize<InsertCode.InsertCodeParams>(s));
			return 1;
		case 18:
			PanelHelp.OpenRecipe(s);
			return 1;
		case 19:
			return PathInfo.FromWindow((wnd)s.ToInt()) is {  } pathInfo ? WndCopyData.Return<char>(pathInfo.FormatCode(PathCode.Run), wparam) : 0;
		case 100: //script.run/runWait
		case 101: //run script from command line
		case 102: //script.runInPip
			return _RunScript();
		case 110: //received from our non-admin drop-target process on OnDragEnter
			return UacDragDrop.AdminProcess.DragEvent((int)wparam, b);
		//case 200: //run any action. Use when App.Dispatcher may be still unavailable.
		//	return 0;
		default:
			Debug_.Print("bad action");
			return 0;
		}
		return 1;
		
		nint _RunScript() {
			int mode = (int)wparam; //1 - wait, 3 - wait and get script.writeResult output, 4 restarting (set meta ifRunning run)
			var d = Serializer_.Deserialize(b);
			string file = d[0];
			string[] args = d[1];
			string pipeName = action == 102 ? null : (string)d[2];
			int schedPid = action == 101 ? d[3] : 0; //if scheduled task, it is the temp LA process, else 0
			bool scheduled = schedPid != 0;
			
			var f = App.Model?.FindCodeFile(file);
			if (f == null) {
				if (action == 101) print.it($"{(scheduled ? "Scheduled task" : "Command line")}: script '{file}' not found."); //else the caller script will throw exception
				return (int)script.RunResult_.notFound;
			}
			
			if (action == 102) {
				PipIPC.RunScriptInPip(f, args);
				return 1;
			}
			
			//options can be specified in args[0] like "[[name1=value1|name2=value2]]"
			//MCIfRunning? ifRunning = null;
			//if (args.FirstOrDefault() is string k && k.Like("[[*]]")) {
			//	foreach (var v in k.Segments("|", SegFlags.NoEmpty, 2..^2)) {
			//		bool good = false;
			//		if (k.IndexOf('=', v.start, v.Length) is int i && i > 0) {
			//			string sn = k[v.start..i], sv = k[++i..v.end];
			//			switch (sn) {
			//			case "ifRunning":
			//				if (good = Enum.TryParse(sv, out MCIfRunning ir)) ifRunning = ir;
			//				break;
			//			}
			//		}
			//		if (!good) { print.it($"<>Cannot start script {f.SciLink()}. Error in args[0]: {k}."); return (int)script.RunResult_.failed; }
			//	}
			//	args = args.RemoveAt(0);
			//}
			
			int r = CompileRun.CompileAndRun(true, f, args, noDefer: 0 != (mode & 1), wrPipeName: pipeName, ifRunning: 0 != (mode & 4) ? MCIfRunning.run : null);
			
			if (scheduled && r > 0) { //enable Task Scheduler to end script process
				run.thread(() => {
					using var hp = Handle_.OpenProcess(schedPid, Api.SYNCHRONIZE);
					if (0 == Api.WaitForSingleObject(hp, -1)) {
						Thread.Sleep(10);
						App.Tasks.TaskFromProcessId(r)?.End(false);
					}
				}, sta: false);
			}
			
			return r;
		}
		
		nint _ScriptAction(int action) {
			if (App.Model.Find(s) is FileNode f) {
				return action switch {
					5 => App.Tasks.EndTasksOf(f, (int)wparam) ? 1 : 2,
					6 => App.Tasks.IsRunning(f) ? 1 : 0,
					_ => 0
				};
			}
			print.warning($"File not found: '{s}'.", -1);
			return 0;
		}
		
		void _OpenFile() {
			var a = s.Split('|'); //"file|line|offset". line and/or offset is empty if was null.
			s = a[0];
			if (App.Model.Find(s) is FileNode f1) {
				int line = a[1].NE() ? -1 : a[1].ToInt() - 1;
				int offset = a[2].NE() ? -1 : a[2].ToInt();
				App.Model.OpenAndGoTo(f1, line, offset);
			} else print.warning($"File not found: '{s}'.", -1);
		}
		
		byte[] _GetFileInfo(string s) {
			int flags = s.ToInt(0, out int end);
			var f = end == s.Length ? Panels.Editor.ActiveDoc?.EFile : App.Model.Find(s[++end..], FNFind.File);
			if (f != null) {
				var kind = f.FileType switch { FNType.Script => EFileKind.Script, FNType.Class => EFileKind.Class, _ => EFileKind.Other };
				string text = null; if (0 != (flags & 1)) f.GetCurrentText(out text, null);
				return Serializer_.Serialize(f.ItemPath, text, (int)kind, (int)f.Id, f.FilePath, App.Model.WorkspaceDirectory);
			}
			return null;
		}
		
		static bool _GetCodeFileText(string name, out string text) {
			text = null;
			var f = name.Eqi("global.cs") ? App.Model.FindGlobalCs() : App.Model.FindCodeFile(name);
			return f?.GetCurrentText(out text) == true;
		}
	}
	
	//Called when command line starts with "/s". This process is running as SYSTEM in session 0.
	//This process is started by the Task Scheduler task installed by the setup program. The task started by App._RestartAsAdmin.
	[MethodImpl(MethodImplOptions.NoOptimization)]
	static unsafe int _RunEditorAsAdmin() {
		var s1 = Api.GetCommandLine();
		//_MBox(new string(s1));
		//Normally it is like "C:\...\Au.Editor.exe /s sessionId" or "C:\...\Au.Editor.exe /s sessionId arguments",
		//	but if started from Task Scheduler it is "C:\...\Au.Editor.exe /s $(Arg0)".
		
		int len = Ptr_.Length(s1) + 1;
		var span = new Span<char>(s1, len);
		var s2 = span.ToArray();
		int i = span.IndexOf("/s") + 1; //info: it's safe. Can't be "C:/s/..." because the scheduled task wasn't created like this.
		s2[i++] = 'n'; // /n - don't try to restart as admin
		
		//get session id
		char* se = null;
		int sesId = Api.strtoi(s1 + i, &se);
		if (se != s1 + i) { //remove the session id argument
			if (*se == 0) s2[i] = '\0'; //no more arguments
			else for (int j = (int)(se - s1); j < len;) s2[i++] = s2[j++];
		} else { //$(Arg0) not replaced. Probably started from Task Scheduler.
			s2[i] = '\0';
			sesId = Api.WTSGetActiveConsoleSessionId();
			if (sesId < 1) return 1;
		}
		//_MBox(new string(s2));
		
		if (!_Api.WTSQueryUserToken(sesId, out var hToken)) return 2;
		if (_Api.GetTokenInformation(hToken, Api.TOKEN_INFORMATION_CLASS.TokenLinkedToken, out var hToken2, sizeof(nint), out _)) { //fails if non-admin user or if UAC turned off
			Api.CloseHandle(hToken);
			hToken = hToken2;
			
			//rejected: add uiAccess.
			//DWORD uiAccess=1; Api.SetTokenInformation(hToken, TokenUIAccess, &uiAccess, 4);
			
			//With uiAccess works better in some cases, eg on Win8 can set a window on top of metro.
			//Cannot use it because of SetParent API bug: fails if the new parent window is topmost and the old parent isn't (or is 0).
			//	SetParent is extensively used by winforms and WPF, to move parked controls from the parking window (message-only) to the real parent window.
			//	Then, if the window is topmost, SetParent fails and the control remains hidden on the parking window.
			//	Also, if it is the first control in form, form is inactive and like disabled. Something activates the parking window instead.
			//It seems uiAccess mode is little tested by Microsoft and little used by others. I even did not find anything about this bug.
			//I suspect this mode also caused some other anomalies.
			//	Eg sometimes activating the editor window stops working normally: it becomes active but stays behind other windows.
			
		} //else MBox(L"GetTokenInformation failed");
		
		if (!_Api.CreateEnvironmentBlock(out var eb, hToken, false)) return 3;
		
		var si = new Api.STARTUPINFO { cb = sizeof(Api.STARTUPINFO), dwFlags = Api.STARTF_FORCEOFFFEEDBACK };
		var desktop = stackalloc char[] { 'w', 'i', 'n', 's', 't', 'a', '0', '\\', 'd', 'e', 'f', 'a', 'u', 'l', 't', '\0' }; //"winsta0\\default"
		si.lpDesktop = desktop;
		
		if (!_Api.CreateProcessAsUser(hToken, null, s2, null, null, false, Api.CREATE_UNICODE_ENVIRONMENT, eb, null, si, out var pi)) {
			_MBox("CreateProcessAsUserW: " + lastError.message);
			return 4;
		}
		
		Api.CloseHandle(pi.hThread);
		Api.CloseHandle(pi.hProcess);
		//Api.AllowSetForegroundWindow(pi.dwProcessId); //fails
		
		_Api.DestroyEnvironmentBlock(eb);
		
		Api.CloseHandle(hToken);
		return 0;
	}
	
	/// <summary>
	/// Shows message box in interactive session. Called from session 0.
	/// </summary>
	[Conditional("DEBUG")]
	static void _MBox(object o) {
#if DEBUG
		var s = o.ToString();
		var title = "Debug";
		_Api.WTSSendMessage(default, Api.WTSGetActiveConsoleSessionId(), title, title.Length * 2, s, s.Length * 2, _Api.MB_TOPMOST | _Api.MB_SETFOREGROUND, 0, out _, true);
#endif
	}
	
	/// <summary>
	/// Finds the message-only window. Starts editor if not running. In any case waits for the window max 15 s.
	/// </summary>
	static bool _EnsureEditorRunningAndGetMsgWindow(out wnd wMsg, string args) {
		wMsg = default;
		for (int i = 0; i < 1000; i++) { //if we started editor process, wait until it fully loaded, then it creates the message-only window
			wMsg = wnd.findFast(null, ScriptEditor.c_msgWndClassName, true);
			if (!wMsg.Is0) return true;
			if (i == 0) {
				var ps = new ProcessStarter_(process.thisExePath, args, rawExe: true);
				if (!ps.StartL(out var pi)) break;
				Api.AllowSetForegroundWindow(pi.dwProcessId);
				pi.Dispose();
				//note: the process will restart as admin if started from non-admin process, unless the program isn't installed correctly
			}
			Thread.Sleep(15);
		}
		return false;
	}
	
	//Initially for this was used native exe. Rejected because of AV false positives.
	//	Speed with native exe 50 ms, now 85 ms. Never mind.
	static unsafe int _LetEditorRunScript(ReadOnlySpan<string> args, string argN) {
		if (!_EnsureEditorRunningAndGetMsgWindow(out wnd w, argN)) return (int)script.RunResult_.noEditor;
		
		//If script name has prefix *, need to wait until script process ends.
		//	Also auto-detect whether need to write script.writeResult to stdout.
		var file = args[0];
		string[] scriptArgs = args[1..].ToArray();
		
		if (file[0] == '>') { //set by DSchedule
			return script.RunCL_(w, 1, file[1..], scriptArgs, null, process.thisProcessId);
		}
		
		int mode = 0; //1 - wait, 3 - wait and get script.writeResult output
		if (file[0] == '*') {
			file = file[1..];
			mode |= 1;
			if ((default != Api.GetStdHandle(Api.STD_OUTPUT_HANDLE)) //redirected stdout
				|| _Api.AttachConsole(_Api.ATTACH_PARENT_PROCESS) //parent process is console
				) mode |= 2;
		}
		
		if (0 == (mode & 2)) return script.RunCL_(w, mode, file, scriptArgs, null);
		
		return script.RunCL_(w, mode, file, scriptArgs, static o => {
			var a = Encoding.UTF8.GetBytes(o);
			bool ok = Api.WriteFile2(Api.GetStdHandle(Api.STD_OUTPUT_HANDLE), a, out int n);
			if (!ok || n != a.Length) throw new AuException(0);
			//tested: 100_000_000 bytes OK.
		});
		//note: Console.Write does not write UTF8 if redirected. Console.OutputEncoding and SetConsoleOutputCP fail.
		//note: in cmd execute this to change cmd console code page to UTF-8: chcp 65001
	}
	
	static unsafe class _Api {
		[DllImport("wtsapi32.dll")]
		internal static extern bool WTSQueryUserToken(int SessionId, out IntPtr phToken);
		
		[DllImport("advapi32.dll")]
		internal static extern bool GetTokenInformation(IntPtr TokenHandle, Api.TOKEN_INFORMATION_CLASS TokenInformationClass, out IntPtr TokenInformation, int TokenInformationLength, out int ReturnLength);
		
		[DllImport("userenv.dll")]
		internal static extern bool CreateEnvironmentBlock(out IntPtr lpEnvironment, IntPtr hToken, bool bInherit);
		
		[DllImport("userenv.dll")]
		internal static extern bool DestroyEnvironmentBlock(IntPtr lpEnvironment);
		
		[DllImport("advapi32.dll", EntryPoint = "CreateProcessAsUserW", SetLastError = true)]
		internal static extern bool CreateProcessAsUser(IntPtr hToken, string lpApplicationName, char[] lpCommandLine, void* lpProcessAttributes, void* lpThreadAttributes, bool bInheritHandles, uint dwCreationFlags, IntPtr lpEnvironment, string lpCurrentDirectory, in Api.STARTUPINFO lpStartupInfo, out Api.PROCESS_INFORMATION lpProcessInformation);
		
#if DEBUG
		[DllImport("wtsapi32.dll", EntryPoint = "WTSSendMessageW")]
		internal static extern bool WTSSendMessage(IntPtr hServer, int SessionId, string pTitle, int TitleLength, string pMessage, int MessageLength, uint Style, int Timeout, out int pResponse, bool bWait);
		internal const uint MB_TOPMOST = 0x40000;
		internal const uint MB_SETFOREGROUND = 0x10000;
#endif
		
		[DllImport("kernel32.dll")]
		internal static extern bool AttachConsole(uint dwProcessId);
		
		internal const uint ATTACH_PARENT_PROCESS = 0xFFFFFFFF;
	}
}


================================================
FILE: Au.Editor/App/DOptions.cs
================================================
using System.Windows;
using System.Windows.Controls;
using Au.Controls;
using Microsoft.Win32;
using System.Windows.Controls.Primitives;
using ToolLand;
using System.Windows.Media;
using System.Windows.Documents;
using System.Windows.Input;
using EStyle = LA.SciTheme.EStyle;

namespace LA;

class DOptions : KDialogWindow {
	public enum EPage { App, Workspace, FontAndColors, CodeEditor, Templates, Hotkeys, AI, Other, OS }
	
	public static void AaShow(EPage? page = null) {
		var d = ShowSingle(() => new DOptions());
		if (page != null) d._tc.SelectedIndex = (int)page.Value;
	}
	
	wpfBuilder _b;
	TabControl _tc;
	
	DOptions() {
		InitWinProp(@"Options", App.Wmain);
		
		_b = new wpfBuilder(this).WinSize(600);
		_b.Row(-1).Add(out _tc).Height(300..);
		_b.R.StartOkCancel()
			.AddOkCancel(out var bOK, out var bCancel, out _, apply: "Apply")
			.xAddDialogHelpButtonAndF1("editor/Settings");
		if (miscInfo.isChildSession) _b.Add<TextBlock>().FormatText($"<a {() => HelpUtil.AuHelp("editor/PiP session")}>PiP</a>");
		_b.End();
		bOK.IsDefault = false; bCancel.IsCancel = false;
		
		_App();
		_Workspace();
		_FontAndColors();
		_CodeEditor();
		_Templates();
		_Hotkeys();
		_AI();
		_Other();
		_OS();
		
		//_tc.SelectedIndex = 2;
		
		_b.End();
	}
	
	/// <summary>
	/// Adds new TabItem to _tc. Creates and returns new wpfBuilder for building the tab page.
	/// </summary>
	wpfBuilder _Page(string name, WBPanelType panelType = WBPanelType.Grid) {
		var tp = new TabItem { Header = name, MinWidth = 30 };
		_tc.Items.Add(tp);
		return new wpfBuilder(tp, panelType).Margin("3");
	}
	
	void _App() {
		var b = _Page("App").Columns(-1, 20, -1);
		
		//left column
		b.StartGrid();
		b.R.Add(out KCheckBox startWithWin, "Start with Windows"); //note: must be the first checkbox in Options, and don't change text, because used for the forum registration security question
		b.R.Add(out KCheckBox startHidden, wpfBuilder.formattedText($"Start hidden; let <s b='#C42B1C' c='white' FontFamily='Segoe UI Symbol' FontSize='11'>  ✖  </s> hide")).Checked(App.Settings.runHidden);
		b.R.Add(out KCheckBox visibleIfNotAutoStarted, "Visible if not auto-started").Margin(22).Checked(App.Settings.startVisibleIfNotAutoStarted).xBindCheckedEnabled(startHidden);
		b.R.Add(out KCheckBox checkForUpdates, "Check for updates every day").Checked(App.Settings.checkForUpdates);
		b.R.AddButton("Check for updates now", o => App.CheckForUpdates(o.Button)).Margin(22).Width(150, "L");
		b.End();
		
		//right column
		b.Skip().StartStack(vertical: true);
		b.End();
		
		b.End();
		
		const string c_rkRun = @"Software\Microsoft\Windows\CurrentVersion\Run";
		string init_swwValue = Registry.GetValue(@"HKEY_CURRENT_USER\" + c_rkRun, "Au.Editor", null) as string;
		bool init_swwYes = true == init_swwValue?.RxMatch($"^\"(.+?)\"", 1, out string s1) && filesystem.more.isSameFile(s1, process.thisExePath);
		startWithWin.IsChecked = init_swwYes;
		if (App.IsPortable) startWithWin.Checked += (_, _) => dialog.showWarning("Portable mode warning", "This setting will be saved in the Registry. Portable apps should not do it.", owner: this);
		
		_b.OkApply += e => {
			if (startWithWin.IsChecked != init_swwYes || (init_swwYes && !init_swwValue.Ends(" /a"))) {
				try {
					using var rk = Registry.CurrentUser.OpenSubKey(c_rkRun, true);
					if (init_swwYes = startWithWin.IsChecked) rk.SetValue("Au.Editor", init_swwValue = $"\"{process.thisExePath}\" /a");
					else rk.DeleteValue("Au.Editor");
				}
				catch (Exception ex) { print.it("Failed to change 'Start with Windows'. " + ex.ToStringWithoutStack()); }
			}
			App.Settings.runHidden = startHidden.IsChecked;
			App.Settings.startVisibleIfNotAutoStarted = visibleIfNotAutoStarted.IsChecked;
			App.Settings.checkForUpdates = checkForUpdates.IsChecked;
		};
	}
	
	void _Workspace() {
		var b = _Page("Workspace").Columns(-1.5, 20, -1);
		b.R.xAddInfoBlockT("Settings of current workspace");
		
		//left column
		b.R.StartStack(vertical: true);
		b.Add("Startup scripts", out TextBox startupScripts, App.Model.UserSettings.startupScripts).Multiline(110, TextWrapping.NoWrap)
			.Tooltip("Example:\nScript1.cs\n\\Folder\\Script2.cs\n//Disabled.cs\nDelay1.cs, 3s\nDelay2.cs, 300ms\n\"Comma, comma.cs\"")
			.Validation(_startupScripts_Validation);
		
		b.Add(out KCheckBox cBackup, "Auto-backup (Git commit)").Checked(App.Model.UserSettings.gitBackup).Margin("T10")
			.Tooltip("Silently run Git commit when LibreAutomate is visible the first time after loading this workspace or activated later after several hours from the last backup.\nIt creates a local backup of workspace files (scripts etc). To upload etc, you can use menu File > Git.");
		cBackup.Checked += (_, _) => { if (!Git.IsReady) App.Dispatcher.InvokeAsync(Git.Setup); };
		b.End();
		
		//right column
		b.Skip().StartStack(vertical: true);
		b.Add("Hide/ignore files and folders", out TextBox tSyncFsSkip, App.Model.WSSett.syncfs_skip).Multiline(110, TextWrapping.NoWrap)
			.Tooltip(@"Hide and don't use files and folders whose paths in workspace would match a wildcard from this list.
Example:
*.bak
*\FolderAnywhere
\Folder
\Folder1\Folder2
//Comment");
		b.End();
		
		b.End();
		
		_b.OkApply += e => {
			App.Model.UserSettings.startupScripts = startupScripts.Text.Trim().NullIfEmpty_();
			App.Model.UserSettings.gitBackup = cBackup.IsChecked;
			
			string skipOld = App.Model.WSSett.syncfs_skip, skipNew = tSyncFsSkip.TextOrNull();
			App.Model.WSSett.syncfs_skip = skipNew;
			if (skipNew != skipOld) App.Model.SyncWithFilesystem_();
		};
		
		static string _startupScripts_Validation(FrameworkElement fe) {
			//print.it("validating");
			string text = (fe as TextBox).Text; if (text.NE()) return null;
			try {
				var t = csvTable.parse(text);
				if (t.ColumnCount > 2) return "Too many commas in a line. If script name contains comma, enclose in \"\".";
				regexp rxDelay = null;
				foreach (var v in t.Rows) {
					var s0 = v[0];
					if (s0.Starts("//")) continue;
					if (App.Model.FindCodeFile(s0) == null) return "Script not found: " + s0;
					var delay = v.Length == 1 ? null : v[1];
					if (!delay.NE()) {
						rxDelay ??= new regexp(@"(?i)^\d+ *m?s$");
						if (!rxDelay.IsMatch(delay)) return "Delay must be like 2 s or 500 ms";
					}
				}
			}
			catch (FormatException ex) { return ex.Message; }
			return null;
		}
	}
	
	class _FontControls {
		public ComboBox name;
		public TextBox size;
		
		public void Init(string[] fonts) {
			name.ItemsSource = fonts;
			size.MouseWheel += static (o, e) => {
				var tb = o as TextBox;
				if (!tb.Text.ToNumber(out double d)) d = 9;
				tb.Text = Math.Clamp(d + e.Delta / 160d, 6, 30).ToS("0.##"); //120/160d=0.75
			};
		}
		
		public void Init(string[] fonts, AppSettings.font_t f) {
			Init(fonts);
			Set(f.name, f.size);
		}
		
		public void Set(string fontName, double fontSize) {
			name.SelectedItem = fontName; if (name.SelectedItem is null) name.Text = fontName;
			size.Text = fontSize.ToS("0.##");
		}
		
		public (string name, double size) Get() {
			var s = name.Text.Trim(); if (s == "" || s.Starts("[ ")) s = "Consolas";
			return (s, size.Text.ToNumber());
		}
		
		public bool Apply(ref AppSettings.font_t f) {
			var s = name.Text.Trim(); var d = size.Text.ToNumber();
			if (s == f.name && d == f.size) return false;
			f.name = s;
			f.size = d;
			f.Normalize();
			return true;
		}
	}
	
	void _FontAndColors() {
		SciTheme theme = null, savedTheme = null;
		bool ignoreColorEvents = false;
		
		var b = _Page("Font, colors", WBPanelType.Dock);
		b.Options(bindLabelVisibility: true);
		
		b.Add(out KScintilla sciStyles).Width(180);
		sciStyles.AaInitBorder = true;
		sciStyles.Name = "styles";
		//note: not readonly. Eg users may want to paste and see any character in multiple fonts.
		
		b.StartGrid().Columns(-1).Margin(20);
		b.R.StartGrid<KGroupBox>(out var gFont, "Font");
		_FontControls _AddFontControls(string label) {
			b.R.Add(label, out ComboBox name).Editable().And(40).Add(out TextBox size).Tooltip("Font size.\nUse mouse wheel to select.");
			return new() { name = name, size = size };
		}
		var font = _AddFontControls("Editor");
		var fontOutput = _AddFontControls("Output");
		var fontFind = _AddFontControls("Find");
		b.R.xAddInfoBlockT("Only editor font depends on theme.");
		b.End();
		b.R.StartGrid();
		var pColor = b.Panel as Grid;
		b.R.Add(out KColorPicker colorPicker);
		b.R.StartStack();
		var pFontStyle = b.Panel;
		b.Add(out KCheckBox cBold, "Bold");
		b.Add(out KCheckBox cItalic, "Italic");
		b.Add(out KCheckBox cUnderline, "Underline");
		b.Add(out KCheckBox cBackground, "Background");
		b.End();
		b.R.Add("", out TextBox tAlpha).Width(50, "L");
		var lAlpha = b.Last2 as Label;
		b.End();
		b.Row(-1);
		b.R.AddSeparator();
		b.R.StartStack();
		b.AddButton("Theme ▾", _ThemesButtonClicked).Width(70);
		b.End().Align("r");
		b.End();
		b.End();
		
		pColor.Visibility = Visibility.Collapsed;
		
		b.Loaded += () => {
			sciStyles.Call(Sci.SCI_SETCARETLINEFRAME, 1);
			sciStyles.aaaSetElementColor(Sci.SC_ELEMENT_CARET_LINE_BACK, 0xE0E0E0);
			sciStyles.Call(Sci.SCI_SETCARETLINEVISIBLEALWAYS, 1);
			
			//font
			
			List<string> fontsMono = new(), fontsVar = new();
			using (var dc = new ScreenDC_()) {
				unsafe {
					_Api.EnumFontFamiliesEx(dc, default, (lf, tm, fontType, lParam) => {
						if (lf->lfFaceName[0] != '@') {
							var fn = new string(lf->lfFaceName);
							if ((lf->lfPitchAndFamily & 0xf0) == 48) fontsMono.Add(fn); else fontsVar.Add(fn); //FF_MODERN=48
						}
						return 1;
					}, default, 0);
				}
			}
			fontsMono.Sort();
			fontsVar.Sort();
			string[] fonts = ["[ Fixed-width fonts ]", .. fontsMono, "", "[ Variable-width fonts ]", .. fontsVar];
			
			font.Init(fonts);
			fontOutput.Init(fonts, App.Settings.font_output);
			fontFind.Init(fonts, App.Settings.font_find);
			
			//styles
			
			const int indicHidden = 0;
			sciStyles.aaaIndicatorDefine(indicHidden, Sci.INDIC_HIDDEN);
			sciStyles.aaaMarginSetWidth(1, 0);
			
			const int c_isStyle = 0, c_isIndicator = 1, c_isElementAlpha = 2, c_isFont = 3, c_isBackground = 4, c_isElementThickness = 5, c_isElementColorOnly = 6;
			
			(string name, int kind, int index)[] table = [
				("Font", c_isFont, 0),

				("Background", c_isBackground, 0),

				("Text", c_isStyle, (int)EStyle.None),
				("//Comment", c_isStyle, (int)EStyle.Comment),
				(@"""String"" 'c'", c_isStyle, (int)EStyle.String),
				(@"\r\n\t\0\\", c_isStyle, (int)EStyle.StringEscape),
				("1234567890", c_isStyle, (int)EStyle.Number),
				("()[]{},;:", c_isStyle, (int)EStyle.Punctuation),
				("Operator", c_isStyle, (int)EStyle.Operator),
				("Keyword", c_isStyle, (int)EStyle.Keyword),
				("Namespace", c_isStyle, (int)EStyle.Namespace),
				("Type", c_isStyle, (int)EStyle.Type),
				("Function", c_isStyle, (int)EStyle.Function),
				("Event", c_isStyle, (int)EStyle.Event),
				("Local variable", c_isStyle, (int)EStyle.LocalVariable),
				("Field variable", c_isStyle, (int)EStyle.Field),
				("Constant", c_isStyle, (int)EStyle.Constant),
				("GotoLabel", c_isStyle, (int)EStyle.Label),
				("#directive", c_isStyle, (int)EStyle.Preprocessor),
				("#if-disabled", c_isStyle, (int)EStyle.Excluded),
				("/// doc text", c_isStyle, (int)EStyle.XmlDocText),
				("/// <doc tag>", c_isStyle, (int)EStyle.XmlDocTag),
				("Regexp text", c_isStyle, (int)EStyle.RxText),
				("Regexp meta", c_isStyle, (int)EStyle.RxMeta),
				("Regexp chars", c_isStyle, (int)EStyle.RxChars),
				("Regexp option", c_isStyle, (int)EStyle.RxOption),
				("Regexp escape", c_isStyle, (int)EStyle.RxEscape),
				("Regexp callout", c_isStyle, (int)EStyle.RxCallout),
				("Regexp comment", c_isStyle, (int)EStyle.RxComment),
				("Line number text", c_isStyle, (int)EStyle.LineNumber),
				("Line number margin", c_isElementColorOnly, -1),
				("Marker margin", c_isElementColorOnly, -2),

				("Text highlight", c_isIndicator, SciTheme.Indic.Found),
				("Symbol highlight", c_isIndicator, SciTheme.Indic.Refs),
				("Brace highlight", c_isIndicator, SciTheme.Indic.Braces),
				("Debug highlight", c_isIndicator, SciTheme.Indic.Debug),
				("Snippet field", c_isIndicator, SciTheme.Indic.SnippetField),
				("Snippet field active", c_isIndicator, SciTheme.Indic.SnippetFieldActive),

				("Selection", c_isElementAlpha, Sci.SC_ELEMENT_SELECTION_BACK),
				("Selection no focus", c_isElementAlpha, Sci.SC_ELEMENT_SELECTION_INACTIVE_BACK),
				
				("Caret", c_isElementThickness, Sci.SC_ELEMENT_CARET),
				("Caret line frame", c_isElementThickness, Sci.SC_ELEMENT_CARET_LINE_BACK),
			];
			
			sciStyles.aaaText = string.Join("\r\n", table.Select(o => o.name));
			for (int i = 0; i < table.Length; i++) {
				int lineStart = sciStyles.aaaLineStart(false, i), lineEnd = sciStyles.aaaLineEnd(false, i);
				sciStyles.aaaIndicatorAdd(indicHidden, false, lineStart..lineEnd, i + 1);
				var kind = table[i].kind;
				if (kind is c_isStyle) {
					sciStyles.Call(Sci.SCI_STARTSTYLING, lineStart);
					sciStyles.Call(Sci.SCI_SETSTYLING, lineEnd - lineStart, table[i].index);
				} else if (kind is c_isIndicator) {
					sciStyles.aaaIndicatorAdd(table[i].index, false, lineStart..lineEnd);
				} else if (kind is c_isElementColorOnly && table[i].index is -1) { //line number margin
					sciStyles.Call(Sci.SCI_STARTSTYLING, lineStart);
					sciStyles.Call(Sci.SCI_SETSTYLING, lineEnd - lineStart, Sci.STYLE_LINENUMBER);
				}
			}
			
			//when changed current line
			int currentItem = 0;
			sciStyles.AaNotify += e => {
				switch (e.n.code) {
				case Sci.NOTIF.SCN_UPDATEUI:
					int i = sciStyles.aaaIndicatorGetValue(indicHidden, sciStyles.aaaLineStartFromPos(false, sciStyles.aaaCurrentPos8)) - 1;
					if (i != currentItem && i >= 0) {
						currentItem = i;
						var k = table[i];
						if (k.kind is c_isFont) {
							pColor.Visibility = Visibility.Collapsed;
							gFont.Visibility = Visibility.Visible;
						} else {
							gFont.Visibility = Visibility.Collapsed;
							pColor.Visibility = Visibility.Visible;
							ignoreColorEvents = true;
							int col;
							pFontStyle.Visibility = k.kind is c_isStyle ? Visibility.Visible : Visibility.Collapsed;
							tAlpha.Visibility = k.kind is c_isIndicator or c_isElementAlpha or c_isElementThickness ? Visibility.Visible : Visibility.Collapsed;
							lAlpha.Content = k.kind is c_isElementThickness ? "Thickness 1-4" : "Opacity 0-255";
							if (k.kind is c_isStyle) {
								ref var rs = ref theme[(EStyle)k.index];
								col = rs.color;
								cBold.IsChecked = rs.bold;
								cItalic.IsChecked = rs.italic;
								cUnderline.IsChecked = rs.underline;
								bool back = (EStyle)k.index is >= EStyle.RxText and <= EStyle.RxComment;
								if (back) cBackground.IsChecked = rs.back;
								cBackground.Visibility = back ? Visibility.Visible : Visibility.Collapsed;
							} else if (k.kind is c_isIndicator) {
								ref var ri = ref theme.Indicator(k.index);
								col = ri.color;
								tAlpha.Text = ri.alpha.ToS();
							} else if (k.kind is c_isElementAlpha or c_isElementThickness) {
								col = theme.Element(k.index);
								tAlpha.Text = (col >>> 24).ToS();
								col &= 0xFFFFFF;
							} else if (k.kind is c_isElementColorOnly) {
								col = theme.Element(k.index) & 0xFFFFFF;
							} else { //Background
								col = theme.Background;
							}
							colorPicker.Color = col;
							ignoreColorEvents = false;
						}
					}
					break;
				}
			};
			
			//when changed values of controls
			TextChangedEventHandler textChanged = (_, _) => {
				(theme.FontName, theme.FontSize) = font.Get();
				theme.ToScintilla(sciStyles);
			};
			font.name.AddHandler(TextBoxBase.TextChangedEvent, textChanged);
			font.size.AddHandler(TextBoxBase.TextChangedEvent, textChanged);
			
			colorPicker.ColorChanged += _ => _UpdateSci();
			cBold.CheckChanged += (sender, _) => _UpdateSci(sender);
			cItalic.CheckChanged += (sender, _) => _UpdateSci(sender);
			cUnderline.CheckChanged += (sender, _) => _UpdateSci(sender);
			cBackground.CheckChanged += (sender, _) => _UpdateSci(sender);
			tAlpha.TextChanged += (sender, _) => _UpdateSci(sender);
			
			void _UpdateSci(object control = null) {
				if (ignoreColorEvents || currentItem < 0) return;
				var k = table[currentItem];
				int col = colorPicker.Color;
				if (k.kind is c_isStyle) {
					ref var rs = ref theme[(EStyle)k.index];
					if (control == cBold) rs.bold = cBold.IsChecked;
					else if (control == cItalic) rs.italic = cItalic.IsChecked;
					else if (control == cUnderline) rs.underline = cUnderline.IsChecked;
					else if (control == cBackground) rs.back = cBackground.IsChecked;
					else rs.color = col;
				} else if (k.kind is c_isIndicator) {
					ref var ri = ref theme.Indicator(k.index);
					if (control == tAlpha) ri.alpha = Math.Clamp(tAlpha.Text.ToInt(), 0, 255);
					else ri.color = col;
				} else if (k.kind is c_isElementAlpha or c_isElementThickness or c_isElementColorOnly) {
					ref var m = ref theme.Element(k.index);
					if (control == tAlpha) {
						bool cl = k.kind is c_isElementThickness; //note: don't allow caret line frame 0, which set line background color instead of frame, because it would be mixed with translucent indicators
						m = (m & 0xFFFFFF) | Math.Clamp(tAlpha.Text.ToInt(), cl ? 1 : 0, cl ? 4 : 255) << 24;
					} else m = (m & ~0xFFFFFF) | (col & 0xFFFFFF);
				} else if (k.kind is c_isBackground) {
					theme.Background = col;
				}
				theme.ToScintilla(sciStyles);
			}
			
			_b.OkApply += e => {
				bool stylesChanged = theme != savedTheme;
				bool stylesOrThemeChanged = _ThemeApply(stylesChanged);
				if (stylesChanged) { savedTheme = SciTheme.Current; theme = savedTheme with { }; }
				
				if (fontFind.Apply(ref App.Settings.font_find) || stylesOrThemeChanged) Panels.Find.CodeStylesChanged_();
				if (fontOutput.Apply(ref App.Settings.font_output)) Panels.Output.Scintilla.AaSetStyles();
			};
			
			_OpenTheme(SciTheme.Current);
		};
		
		void _OpenTheme(SciTheme t) {
			savedTheme = t;
			theme = savedTheme with { };
			
			font.Set(theme.FontName, theme.FontSize);
			theme.ToScintilla(sciStyles);
			sciStyles.aaaGoToPos(false, 0);
		}
		
		void _ThemesButtonClicked(WBButtonClickArgs e) {
			var m = new popupMenu();
			_Add("LA.csv");
			foreach (var v in filesystem.enumFiles(SciTheme.ThemesDirDefaultBS, "*.csv")) _Add(v.Name);
			
			void _Add(string fn) {
				var s = fn[..^4];
				_Add2(s);
				if (filesystem.exists(SciTheme.ThemesDirCustomizedBS + fn)) _Add2(s + " [customized]");
				
				void _Add2(string s) {
					var v = m.AddRadio(s);
					if (s == theme.Name) v.IsChecked = true;
				}
			}
			
			m.Separator();
			m.Submenu("Open folder", m => {
				m["Default themes"] = o => { run.itSafe(SciTheme.ThemesDirDefaultBS); };
				m["Customized themes"] = o => { run.itSafe(SciTheme.ThemesDirCustomizedBS); };
			});
			
			m.Show(owner: this);
			if (m.Result is { IsChecked: true } r) {
				_OpenTheme(new(r.Text));
			}
		}
		
		bool _ThemeApply(bool modified) {
			if (!modified && theme.Name == SciTheme.Current.Name) return false;
			
			var name = theme.Name;
			if (modified && !name.Ends(" [customized]")) name += " [customized]";
			
			var t = theme with { Name = name };
			SciTheme.Current = t;
			
			App.Settings.edit_theme = name == "LA" ? null : name;
			if (modified) t.Save();
			
			foreach (var v in Panels.Editor.OpenDocs) {
				t.ToScintilla(v);
				v.ESetLineNumberMarginWidth_();
			}
			
			return true;
		}
	}
	
	void _CodeEditor() {
		var b = _Page("Code editor").Columns(-1, 20, -1);
		b.R.StartStack(vertical: true); //left
		
		b.StartGrid<KGroupBox>("Completion list");
		b.R.Add("Append ( )", out ComboBox complParen).Items("Space|Space, Tab, Enter, 2*click|None").Select(App.Settings.ci_complParen)
			.Tooltip("These keys etc can be used to append ( ) when completing a function name or a keyword like 'if'.\nPlus characters ;.,:([{+-*/ etc.");
		b.End();
		
		b.StartGrid<KGroupBox>("Statement completion");
		b.R.Add("Hotkey", out ComboBox enterWith).Items("Ctrl+Enter|Shift+Enter|Ctrl+Shift+Enter").Select(App.Settings.ci_enterWith);
		b.R.Add(out KCheckBox enterBeforeParen, "Enter before )").Checked(App.Settings.ci_enterBeforeParen)
			.Tooltip("Key Enter before ) or ] completes statement like with Ctrl etc.\nExcept after comma or space or with Shift etc.");
		b.R.Add(out KCheckBox enterBeforeSemicolon, "Enter before ;").Checked(App.Settings.ci_enterBeforeSemicolon)
			.Tooltip("Key Enter before ; completes statement like with Ctrl etc.\nExcept after comma or space or with Shift etc.");
		b.R.Add(out KCheckBox autoSemicolon, "Add ; when starting a statement").Checked(App.Settings.ci_semicolon);
		b.End();
		
		b.End(); //left
		
		b.Skip().StartStack(vertical: true); //right
		
		b.StartGrid<KGroupBox>("Formatting");
		b.R.Add(out KCheckBox formatCompact, "Compact").Checked(App.Settings.ci_formatCompact)
			.Tooltip("""
Brace in same line. Don't indent case in switch.
Examples:

void Checked() {
    if (true) {

    } else {

    }
}

void Unchecked()
{
    if (true)
    {

    }
    else
    {

    }
}
""");
		b.R.Add(out KCheckBox formatTabIndent, "Tab-indent").Checked(App.Settings.ci_formatTabIndent)
			.Tooltip("For indent use tab character, not spaces");
		b.R.Add(out KCheckBox formatAuto, "Auto-format").Checked(App.Settings.ci_formatAuto)
			.Tooltip("Automatically format statement on ;{} etc");
		b.End();
		
		b.StartGrid<KGroupBox>("Find references, rename");
		b.R.Add("Skip\nfolders", out TextBox skipFolders, App.Model.WSSett.ci_skipFolders).Multiline(55, wrap: TextWrapping.NoWrap)
			.Tooltip(@"Don't search in these folders.
Example:
\Garbage
\Folder1\Folder2");
		b.End();
		
		b.End(); //right
		
		b.End();
		
		//b.Loaded += () => {
		
		//};
		
		_b.OkApply += e => {
			App.Settings.ci_complParen = complParen.SelectedIndex;
			App.Settings.ci_enterWith = enterWith.SelectedIndex;
			App.Settings.ci_enterBeforeParen = enterBeforeParen.IsChecked;
			App.Settings.ci_enterBeforeSemicolon = enterBeforeSemicolon.IsChecked;
			App.Settings.ci_semicolon = autoSemicolon.IsChecked;
			
			if (formatCompact.IsChecked != App.Settings.ci_formatCompact || formatTabIndent.IsChecked != App.Settings.ci_formatTabIndent) {
				App.Settings.ci_formatCompact = formatCompact.IsChecked;
				App.Settings.ci_formatTabIndent = formatTabIndent.IsChecked;
				ModifyCode.FormattingOptions = null; //recreate
				
				//note: don't SCI_SETUSETABS(false).
				//	Eg VS does not use it, and it's good; VSCode uses, and it's bad, eg cannot insert tab in raw strings.
				//	All autocorrect/autoindent/format code inserts spaces if need. Users rarely have to type indent tabs.
				//	And don't add options to set tab/indent size. Too many options isn't good.
			}
			App.Settings.ci_formatAuto = formatAuto.IsChecked;
			
			App.Model.WSSett.ci_skipFolders = skipFolders.TextOrNull();
		};
		
		//CONSIDER: completion list: option to single-click.
	}
	
	void _Templates() {
		var b = _Page("Templates").Columns(0, 100, -1, 0, 100);
		b.R.Add("Template", out ComboBox template).Items("Script|Class")
			.Skip().Add("Use", out ComboBox use).Items("Default|Custom");
		b.Row(-1).Add(out KSciCodeBoxWnd sci); sci.AaInitBorder = true;
		//b.R.Add(out KCheckBox fold, "Fold script").Checked(0 == (1 & App.Settings.templ_flags));
		b.End();
		
		string[] customText = new string[2];
		var useCustom = (FileNode.ETempl)App.Settings.templ_use;
		
		template.SelectionChanged += _Combo_Changed;
		use.SelectionChanged += _Combo_Changed;
		sci.AaTextChanged += _ => customText[template.SelectedIndex] = sci.aaaText;
		b.Loaded += () => {
			_Combo_Changed(template, null);
		};
		
		_b.OkApply += e => {
			for (int i = 0; i < customText.Length; i++) {
				string text = customText[i]; if (text == null) continue;
				var tt = (FileNode.ETempl)(1 << i);
				var file = FileNode.Templates.FilePathRaw(tt, true);
				try {
					if (text == FileNode.Templates.Load(tt, false)) {
						filesystem.delete(file);
					} else {
						filesystem.saveText(file, text);
					}
				}
				catch (Exception ex) { print.it(ex.ToStringWithoutStack()); }
			}
			App.Settings.templ_use = (int)useCustom;
			
			//int flags = App.Settings.templ_flags;
			//if (fold.IsChecked) flags &= ~1; else flags |= 1;
			//App.Settings.templ_flags = flags;
		};
		
		void _Combo_Changed(object sender, SelectionChangedEventArgs e) {
			int i = template.SelectedIndex;
			FileNode.ETempl tt = i switch { 1 => FileNode.ETempl.Class, _ => FileNode.ETempl.Script, };
			if (sender == template) use.SelectedIndex = useCustom.Has(tt) ? 1 : 0;
			bool custom = use.SelectedIndex > 0;
			string text = null;
			if (e != null) {
				useCustom.SetFlag(tt, custom);
				if (custom) text = customText[i];
			}
			text ??= FileNode.Templates.Load(tt, custom);
			sci.AaSetText(text, readonlyFrom: custom ? -1 : 0);
		}
	}
	
	void _Hotkeys() {
		var b = _Page("Hotkeys");
		b.R.Add("Capture wnd and show menu", out TextBox captureMenu, App.Settings.hotkeys.tool_quick).xValidateHotkey();
		b.R.Add("Capture wnd and show tool", out TextBox captureDwnd, App.Settings.hotkeys.tool_wnd).xValidateHotkey();
		b.R.Add("Capture elm and show tool", out TextBox captureDelm, App.Settings.hotkeys.tool_elm).xValidateHotkey();
		b.R.Add("Capture image and show tool", out TextBox captureDuiimage, App.Settings.hotkeys.tool_uiimage).xValidateHotkey();
		b.End();
		
		_b.OkApply += e => {
			AppSettings.hotkeys_t v = new() {
				tool_quick = captureMenu.TextOrNull(),
				tool_wnd = captureDwnd.TextOrNull(),
				tool_elm = captureDelm.TextOrNull(),
				tool_uiimage = captureDuiimage.TextOrNull(),
			};
			if (v != App.Settings.session.hotkeys) {
				App.Settings.session.hotkeys = v;
				RegHotkeys.UnregisterPermanent();
				RegHotkeys.RegisterPermanent();
			}
		};
	}
	
	void _AI() {
		var b = _Page("AI", WBPanelType.VerticalStack);
		
		b.xAddGroupSeparator("API keys");
		b.StartGrid().Columns(100, -1);
		b.R.Add(out ComboBox api)
			.Add(out KPasswordBox apiKey).Tooltip("API key or environment variable (if (X) checked).\nAPI keys are saved encrypted and can't be decrypted on other computers/accounts.").Hidden();
		b.End();
		
		b.StartGrid().Columns(0, -1, -1);
		b.R.xAddGroupSeparator("AI models for documentation search");
		b.R.Add("Embedding", out ComboBox modelEmbed).Tooltip("Embedding model is the main component of semantic search").Span(1);
		b.R.Add("Reranker", out ComboBox modelRerank).Tooltip("Reranker model improves search results").Span(1);
		
		//b.R.Add("Chat", out ComboBox modelChat).Span(1);
		
		//b.R.StartGrid<KGroupBox>("Chat model settings");
		//b.End();
		
		//rejected. Currently using Voyage multimodal. It supports text and images.
		//b.xAddGroupSeparator("Models for icon search in the Icons tool");
		//b.R.Add("Search", out ComboBox modelIconSearch).Tooltip("AI embedding model for icon search");
		
		b.R.xAddGroupSeparator("MCP");
		b.R.Add(out KCheckBox mcpDebug, "Print tool calls").Checked(App.Settings.ai_mcp_print);
		
		b.R.AddSeparator(false);
		b.R.AddButton("...", _ => _MoreMenu()).Align(HorizontalAlignment.Left).Span(1);
		
		b.End();
		b.End();
		
		b.Loaded += () => {
			var apiNames = AI.AiModel.Models.Select(o => o.api).Distinct(StringComparer.OrdinalIgnoreCase).ToArray();
			var apiKeys = new (bool once, (string key, bool ev) now, (string key, bool ev) old)[apiNames.Length];
			int currentApi = -1;
			api.ItemsSource = apiNames;
			api.SelectionChanged += (_, e) => {
				if (currentApi >= 0) apiKeys[currentApi].now = (apiKey.Text.NullIfEmpty_(), apiKey.IsEnvVar);
				currentApi = api.SelectedIndex;
				apiKey.Visibility = currentApi >= 0 ? Visibility.Visible : Visibility.Hidden;
				if (currentApi < 0) return;
				if (!apiKeys[currentApi].once) {
					apiKeys[currentApi].once = true;
					App.Settings.ai_ak.TryGetValue((string)api.SelectedItem, out var key);
					bool ev = false;
					if (key.NE()) key = null;
					else {
						ev = key is ['%', _, .., '%'];
						key = ev ? key[1..^1] : EdProtectedData.Unprotect(key);
					}
					apiKeys[currentApi].now = apiKeys[currentApi].old = (key, ev);
				}
				(apiKey.Text, apiKey.IsEnvVar) = apiKeys[currentApi].now;
			};
			//api.SelectedIndex = 0; //no
			b.Validation(apiKey, _ => {
				if (currentApi >= 0) apiKeys[currentApi].now = (apiKey.Text.NullIfEmpty_(), apiKey.IsEnvVar);
				if (apiKeys.Any(o => o.now.ev && o.now.key.Lenn() >= 32)) return "Variable name too long. Uncheck (X) if it's not a variable."; //probably checked the toggle button to see the key and forgot to uncheck
				return null;
			});
			
			_InitModelCombo(modelEmbed, o => o is AI.AiEmbeddingModel { isCompact: false }, App.Settings.ai_modelEmbed);
			_InitModelCombo(modelRerank, o => o is AI.AiRerankModel, App.Settings.ai_modelRerank, optional: true);
			//_InitModelCombo(modelChat, o => o is AI.AiChatModel, App.Settings.ai_modelChat);
			//_InitModelCombo(modelIconSearch, o => o is AI.AiEmbeddingModel { isCompact: true }, App.Settings.ai_modelIconSearch);
			
			void _InitModelCombo(ComboBox c, Func<AI.AiModel, bool> predicate, string select, bool optional = false) {
				var e = AI.AiModel.Models.Where(predicate).Select(o => o.DisplayName);
				if (optional) e = e.Prepend("none");
				c.ItemsSource = e.ToArray();
				c.SelectedItem = select;
			}
			
			_b.OkApply += e => {
				foreach (var (i, v) in apiKeys.Index()) {
					if (v.once && v.now != v.old) {
						apiKeys[i].old = v.now;
						var key = v.now.key == null ? null : v.now.ev ? $"%{v.now.key}%" : EdProtectedData.Protect(v.now.key);
						App.Settings.ai_ak[apiNames[i]] = key;
					}
				}
				
				App.Settings.ai_modelEmbed = _GetModelCombo(modelEmbed);
				App.Settings.ai_modelRerank = _GetModelCombo(modelRerank);
				//App.Settings.ai_modelChat = _GetModelCombo(modelChat);
				//App.Settings.ai_modelIconSearch = _GetModelCombo(modelIconSearch);
				
				string _GetModelCombo(ComboBox c) => c.SelectedItem is string s && s != "none" ? s : null;
				
				App.Settings.ai_mcp_print = mcpDebug.IsChecked;
			};
		};
		
		void _MoreMenu() {
			var m = new popupMenu();
			m["Print all model configurations"] = o => { print.it(AI.AiModel.Models); };
			//m["How to add new model"] = o => { _AddCustomModel(); };
			
			var emDir = AI.Embeddings.VectorDir;
			if (filesystem.exists(emDir).Directory) m["Open embedding vectors folder"] = o => { var s = run.itSafe(emDir); };
			
			m.Separator();
			m["Help"] = o => { HelpUtil.AuHelp("editor/LA and AI"); };
			m.Show(owner: this);
		}

#if !true
		void _AddCustomModel() {
			if (modelChat.SelectedIndex < 0 && modelChat.Items.Count > 0) modelChat.SelectedIndex = 0;
			if (!(modelChat.SelectedItem is string mdn && AI.AiModel.Models.FirstOrDefault(o => o is AI.AiChatModel && o.DisplayName == mdn) is AI.AiChatModel m)) return;
			string code = $$"""
/*/ role editorExtension; testInternal Au.Editor; r Au.Editor.dll; /*/
using AI;
var model1 = AiModel.GetModel<{{m.GetType()}}>() with { model = "model-name" };
AiModel.Models.Add(model1);

""";
			StringBuilder s = new("<>To add an AI model configuration, you need a script with role editorExtension (");
			foreach (var v in App.Model.GetStartupScriptsExceptDisabled()) if (new MetaCommentsParser(v.f).role == "editorExtension") s.Append(v.f.SciLink()).Append(", ");
			s.Append($$"""
<+newStartupScriptEditorExtension {{code.Replace('>', '\x1')}}>create<>). Add the script to <+options Workspace>startup scripts<>.
It's possible to create a completely new AI model configuration (any AI API, any parameters). How - please ask in the forum.
Or clone an existing model configuration and change some properties. Example:
<code>{{code}}</code>
""");
			print.it(s);
			Panels.Output.Scintilla.AaTags.AddLinkTag("+newStartupScriptEditorExtension", code => {
				code = code.Replace('\x1', '>');
				App.Model.NewItem("Script.cs", name: "init.cs", beginRenaming: true, text: new(true, code));
				//note: can't auto-add to startup scripts now, because the final script name is unknown
			});
		}
#endif
	}

	void _Other() {
		var b = _Page("Other");
		b.R.Add("Documentation", out ComboBox localHelp).Items("Local docs of this app version, in Read panel|Online docs of the latest version, in web browser").Select(App.Settings.doc_web ? 1 : 0);
		b.R.Add("Internet search URL", out TextBox internetSearchUrl, App.Settings.internetSearchUrl);
		b.R.Add(out CheckBox minimalSdk, "Use minimal .NET SDK").Checked(App.Settings.minimalSDK, threeState: true).Tooltip("The SDK is used to install NuGet packages and for the Publish feature.\nIndeterminate - use full SDK if installed, else minimal.");
		b.R.Add(out CheckBox printCompiled, "Always print \"Compiled\"").Checked(App.Settings.comp_printCompiled, threeState: true)
			.Tooltip("Always print a \"Compiled\" message when a script etc compiled successfully.\nIf unchecked, prints only if role is exeProgram or classLibrary.\nIf 3-rd state, prints only when executing the Compile command.");
		b.End();
		
		b.Loaded += () => {
			_b.OkApply += e => {
				if ((localHelp.SelectedIndex == 1) != App.Settings.doc_web) {
					App.Settings.doc_web ^= true;
					DocsHttpServer.StartOrSwitch();
				}
				App.Settings.internetSearchUrl = internetSearchUrl.TextOrNull();
				App.Settings.minimalSDK = minimalSdk.IsChecked;
				App.Settings.comp_printCompiled = printCompiled.IsChecked;
			};
		};
	}
	
	unsafe void _OS() {
		var b = _Page("OS");
		b.R.xAddInfoBlockF($"Some Windows settings for all programs{(!App.IsPortable ? null : "\n<s c='red'>Portable mode warning: portable apps should not change Windows settings.</s>")}");
		
		b.R.Add("Key/mouse hook timeout, ms", out TextBox hooksTimeout).Width(70, "L");
		b.R.Add(out KCheckBox cDisableLAW, "Disable \"lock active window\"");
		b.R.Add(out KCheckBox cUnderlineAK, "Underline menu/dialog item access keys");
		b.R.AddButton("Java...", _ => Delm.Java.EnableDisableJabUI(this)).Width(70, "L");
		b.End();
		
		b.Loaded += () => {
			hooksTimeout.Text = WindowsHook.LowLevelHooksTimeout.ToS();
			b.Validation(hooksTimeout, o => ((o as TextBox).Text.ToInt() is >= 300 and <= 1000) ? null : "300-1000");
			bool disableLAW = 0 == Api.SystemParametersInfo(Api.SPI_GETFOREGROUNDLOCKTIMEOUT, 0);
			cDisableLAW.IsChecked = disableLAW;
			bool underlineAK = Api.SystemParametersInfo(Api.SPI_GETKEYBOARDCUES);
			cUnderlineAK.IsChecked = underlineAK;
			
			_b.OkApply += e => {
				int t = hooksTimeout.Text.ToInt();
				if (t != WindowsHook.LowLevelHooksTimeout) {
					WindowsHook.LowLevelHooksTimeout = t;
					print.it("Info: The new hook timeout value will be used after restarting Windows.");
				}
				
				if (cDisableLAW.IsChecked != disableLAW)
					Api.SystemParametersInfo(Api.SPI_SETFOREGROUNDLOCKTIMEOUT, 0, (void*)(disableLAW ? 15000 : 0), save: true, notify: true);
				if (cUnderlineAK.IsChecked != underlineAK)
					Api.SystemParametersInfo(Api.SPI_SETKEYBOARDCUES, 0, (void*)(underlineAK ? 0 : 1), save: true, notify: true);
			};
		};
	}
	
	class _Api : NativeApi {
		[DllImport("gdi32.dll", EntryPoint = "EnumFontFamiliesExW")]
		internal static extern int EnumFontFamiliesEx(IntPtr hdc, in Api.LOGFONT lpLogfont, FONTENUMPROC lpProc, nint lParam, uint dwFlags);
		internal unsafe delegate int FONTENUMPROC(Api.LOGFONT* lf, IntPtr tm, uint fontType, nint lParam);
		
	}
}


================================================
FILE: Au.Editor/App/MainWindow.cs
================================================
using Au.Controls;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Interop;
using System.Windows.Input;
using System.Windows.Media;

namespace LA;

partial class MainWindow : Window {
	protected override void OnPropertyChanged(DependencyPropertyChangedEventArgs e) {
		if (e.Property == VisibilityProperty && (Visibility)e.NewValue == Visibility.Visible) {
			//This is the first OnX when showing window.
			//	Window.Show just sets the Visibility property.
			//	Then WPF changes Left, Top, some other properties, and calls OnInitialized.
			if (!_inited) { _inited = true; _Init(); }
		}
		base.OnPropertyChanged(e);
	}
	bool _inited;
	
	void _Init() {
		//_StartProfileOptimization();
		
		Application.Current.Resources = Application.LoadComponent(new("/Au.Editor;component/app/app-resources.xaml", UriKind.Relative)) as ResourceDictionary;
		
		Title = App.AppName; //don't append document name etc
		
		if (App.Settings.wndpos.main == null) {
			Width = 1200;
			Height = 750;
			WindowStartupLocation = WindowStartupLocation.CenterScreen;
			//and will EnsureInScreen
		}
		WndSavedRect.Restore(this, App.Settings.wndpos.main, o => App.Settings.wndpos.main = o);
		
		Panels.LoadAndCreateToolbars();
		
		App.Commands = new KMenuCommands(typeof(Menus), Panels.Menu);
		
		App.Commands.OnCustomizingError = (c, s, ex) => print.it($"<>Customization error in <+DCustomize>{c.Name}<>: {s}. {ex?.ToStringWithoutStack()}");
		var atb = new ToolBar[6] { Panels.TTools, Panels.TFile, Panels.TRun, Panels.TEdit, Panels.TCustom1, Panels.TCustom2 };
		App.Commands.InitToolbarsAndCustomize(folders.ThisAppBS + @"Default\Commands.xml", AppSettings.DirBS + "Commands.xml", atb);
		
		if (App.Commands[nameof(Menus.File.New)].FindMenuButtonInToolbar(Panels.TFile) is { } bNew)
			bNew.MouseDoubleClick += (_, e) => { e.Handled = true; Menus.File.New.New_script(); };
		if (App.Commands[nameof(Menus.Run.Run_script)].FindButtonInToolbar(Panels.TRun) is { } bRun) { //make Run button bigger
			bool vert = bRun.Parent is ToolBar { Orientation: Orientation.Vertical };
			if (vert) bRun.MinHeight = 40; else bRun.MinWidth = 40;
			Thickness margin = vert ? new(0, 8, 0, 8) : new(8, 0, 8, 0);
			bRun.Margin = margin;
			if (App.Commands[nameof(Menus.Run.Debug_run)].FindButtonInToolbar(Panels.TRun) is { } bDebugRun) bDebugRun.Margin = margin;
		}
		
		Panels.CreatePanels();
		
		App.Commands.BindKeysTarget(this, "");
		
		Panels.PanelManager.Container = g => { this.Content = g; };
		
		_NormalizeMouseWheel();
		
		DocsHttpServer.StartOrSwitch();
		
#if DEBUG
		App.Timer1s += () => {
			var e = Keyboard.FocusedElement as FrameworkElement;
			Debug_.PrintIf(e != null && !e.IsVisible, "focused invisible");
			//print.it(e, FocusManager.GetFocusedElement(App.Wmain));
		};
#endif
	}
	
	protected override void OnSourceInitialized(EventArgs e) {
		var hs = PresentationSource.FromVisual(this) as HwndSource;
		App.Hmain = (wnd)hs.Handle;
		
		hs.CompositionTarget.RenderMode = RenderMode.SoftwareOnly;
		RenderOptions.ProcessRenderMode = RenderMode.SoftwareOnly;
		
		base.OnSourceInitialized(e);
		
		if (App.Settings.wndpos.main == null) App.Hmain.EnsureInScreen();
		
		//workaround for: sometimes OS does not set foreground window. Then we have a fake active/focused state (blinking caret, called OnActivated, etc).
		//	1. When started hidden, and now clicked tray icon first time. Is it because of the "lock foreground window"? Or WPF shows window somehow incorrectly?
		//	2. When starting visible, if VMWare Player is active. Same with some other programs too (WPF, appstore, some other).
		//this.Activate(); //does not work with VMWare, also if user clicks a window after starting this process
		App.Hmain.ActivateL(); //works always, possibly with workarounds
		
		Panels.PanelManager["Output"].Visible = true;
		
		App.Model.WorkspaceLoadedWithUI(onUiLoaded: true);
		
		App.Loaded = AppState.LoadedUI;
		
		//workaround for WPF bug: on Environment.Exit its "process exit" event handler creates chaoss, eg pumps messages, including wmtimer, and app crashes.
		process.thisProcessExitDone_ += () => { //after calling all process.thisProcessExit event handlers
			if (App.Loaded == AppState.LoadedUI) Api.ExitProcess(Environment.ExitCode);
		};
		
		CodeInfo.UiLoaded();
		
		UacDragDrop.AdminProcess.Enable(true); //rejected: disable when hiding main window. Some other window may be visible.
		
		hs.AddHook(_WndProc);
		
		RegHotkeys.RegisterPermanent();
		
		App.OnMainWindowLoaded_();
		
		//Created?.Invoke();
		
		Loaded += (_, _) => {
			EditorExtension.WindowLoaded_();
			CommandLine.UILoaded();
		};
	}
	
	///// <summary>
	///// When window handle created.
	///// Documents are open, etc.
	///// </summary>
	//public event Action Created;
	
	protected override void OnClosing(CancelEventArgs e) {
		//note: called by Window.Close (sync) and Application.Shutdown (async) even if the window never was loaded.
		
		if (App.Loaded == AppState.LoadedUI) {
			App.Model.Save.AllNowIfNeed();
			Panels.PanelManager.Save();
			TUtil2.CloseDialogsInNonmainThreads(); //let they save rects etc
		}
		
		EditorExtension.ClosingWorkspace_(onExit: true); //must be called before closing documents
		
		base.OnClosing(e);
	}
	
	protected override void OnClosed(EventArgs e) {
		//note: called by Window.Close (sync) and Application.Shutdown (async) even if the window never was loaded.
		
		bool loaded = App.Loaded == AppState.LoadedUI;
		App.Loaded = AppState.Unloading;
		App.OnMainWindowClosed_();
		base.OnClosed(e);
		if (loaded) {
			UacDragDrop.AdminProcess.Enable(false);
			CodeInfo.Stop();
			App.Model.Save.AllNowIfNeed();
		}
	}
	
	unsafe nint _WndProc(nint hwnd, int msg, nint wParam, nint lParam, ref bool handled) {
		var w = (wnd)hwnd;
		
		switch (msg) {
		case Api.WM_DPICHANGED:
			this.DpiChangedWorkaround();
			break;
		case Api.WM_HOTKEY:
			handled = true;
			RegHotkeys.WmHotkey_(wParam);
			break;
		case Api.WM_ACTIVATEAPP: //note: not received at startup, because sets the hook when the window is already active
			OnActivatedDeactivatedAppOrPip_(wParam != 0);
			break;
		case Api.WM_SYSCOMMAND when (wParam & 0xFFF0) == Api.SC_CLOSE:
			if (handled = App.Settings.runHidden) Hide_();
			break;
		}
		
		return default;
	}
	
	/// <summary>
	/// Called on WM_ACTIVATEAPP of the main window. In LA PiP also called on WM_ACTIVATE of the host PiP window, if the main window is active.
	/// </summary>
	internal static void OnActivatedDeactivatedAppOrPip_(bool activated) {
		if (activated) {
			s_appActivatedTimer ??= new(static _ => {
				Panels.Editor.OnAppActivated_();
				if (App.Settings.checkForUpdates) App.CheckForUpdates();
				Git.AutoBackup(false);
			});
			s_appActivatedTimer.After(250);
		} else {
			s_appActivatedTimer?.Stop();
			App.Model.Save.AllNowIfNeed();
		}
	}
	static timer s_appActivatedTimer;
	
	internal void Hide_() {
		if (IsVisible) {
			App.Model.Save.AllNowIfNeed();
			Panels.PanelManager.Save();
			Hide();
			process.ThisProcessMinimizePhysicalMemory_(1000);
		}
	}
	
	//this was for testing document tabs. Now we don't use document tabs. All documents now are in single panel.
	//void _OpenDocuments() {
	//	var docLeaf = _AddDoc("Document 1");
	//	_AddDoc("Document 2");
	//	_AddDoc("Document 3");
	//	_AddDoc("Document 4");
	//	docLeaf.Visible = true;
	//	//Panels.DocPlaceholder_.Visible = false;
	//	docLeaf.Content.Focus();
	
	//	KPanels.ILeaf _AddDoc(string name) {
	//		//var docPlaceholder = App.Panels["Open"]; //in stack
	//		var docPlaceholder = Panels.DocPlaceholder_; //in tab
	//		var v = docPlaceholder.AddSibling(false, KPanels.LeafType.Document, name, true);
	//		v.Closing += (_, e) => { e.Cancel = !dialog.showOkCancel("Close?"); };
	//		v.ContextMenuOpening += (o, m) => {
	//			var k = o as KPanels.ILeaf;
	//			m.Separator();
	//			m["Close 2"] = o => k.Delete();
	//		};
	//		v.TabSelected += (_, _) => _OpenDoc(v);
	
	//		return v;
	//	}
	
	//	static void _OpenDoc(KPanels.ILeaf leaf) {
	//		if (leaf.Content != null) return;
	//		leaf.Content = new KScintilla();
	//	}
	//}
	
	//Used to make faster, but now with tiered JIS makes faster only by ~100 ms.
	static void _StartProfileOptimization() {
#if !DEBUG
		var fProfile = folders.ThisAppDataLocal + "ProfileOptimization";
		filesystem.createDirectory(fProfile);
		System.Runtime.ProfileOptimization.SetProfileRoot(fProfile);
		System.Runtime.ProfileOptimization.StartProfile("Au.Editor.startup");
#endif
	}
	
	public void AaShowAndActivate() {
		Show();
		var w = App.Hmain;
		w.ShowNotMinimized();
		w.ActivateL();
	}
	
	//If winver < 10 or disabled normal mouse scrolling, sets a mouse hook to scroll the mouse control.
	//	Without it can't scroll any KTreeView even if focused.
	static unsafe void _NormalizeMouseWheel() {
		if (osVersion.minWin10 && Api.SystemParametersInfo(Api.SPI_GETMOUSEWHEELROUTING, 0) >= 2) return;
		WindowsHook.ThreadGetMessage(k => {
			if (k.PM_NOREMOVE) return;
			if (k.msg->message is Api.WM_MOUSEWHEEL or Api.WM_MOUSEHWHEEL) {
				var w = wnd.fromMouse(WXYFlags.Raw);
				if (w.IsOfThisThread) k.msg->hwnd = w;
			}
		});
		//never mind other threads. Eg the wnd and elm tools.
	}
}


================================================
FILE: Au.Editor/App/Menus.cs
================================================
/*
LibreAutomate's menu bar menus are defined in the `Menus` class. The menu hierarchy is the same as the hierarchy of nested classes.
At startup the program creates all menus using reflection. Also it creates customizable toolbars with buttons for the same commands.
For each class and method with `[Command]` attribute, the program creates a menu item and its `ICommand`. Classes define menus/submenus. Methods define leaf items.
Some classes also have method named `_Init`. The program calls it when it created all menus. The method eg can set initial check states or event handlers to populate the submenu dynamically.

## Menu item properties
All properties can be defined via `CommandAttribute`. Some properties are by default derived from the method/class name.

- `name` (string) - command name (used to find commands, customization, etc). Assigned in one of ways: 1. By default it's the name of the method or class. 2. Attribute property `name`; this way can be used to prevent duplicates.
- `text` (string) - the display text (in menu item and button tooltip). Assigned in one of ways: 1. By default it's the name of the method or class, but underscores are replaced with spaces; if the first argument is "...", it is appended. 2. The first argument as string, except if it's "...".
- `checkable` (bool) - it's a toggle.
- `hide` (bool) - it's a command without UI (menu item, toolbar button).
- `image` (string) - icon of the menu item and toolbar button. Usually XAML icon name.
- `keys` (string) - default hotkey. Users can change it.
- `keysText` (string) - alternative display text for hotkey.
- `namePrefix` (string) - name prefix of the command, and default prefix of descendants. Used to prevent duplicates.
- `separator` (bool) - add separator before the menu item.
- `tooltip` (string) - tooltip text of the menu item and toolbar button (to be appended to the display text).
- `target` (string) - name of panel etc where the hotkey(s) is/are active. Inheritable. If "" - in entire window (used to override the inherited target).
- `underlined` (char) - the access character. Assigned in one of ways: 1. The first argument as char. 2. Underscore in explicitly specified display text. 3. Auto-assigned by the program.

When AI generates documentation from this code:
- Include all menu items generated from classes and methods with `[Command]` attribute, except where `hide` is present.
- Markdown format: Use headings for menus/submenus (hierarchical, not flat). Place leaf items in lists.
- Generate menu item descriptions from these properties: `text`, `checkable`, `tooltip`. Ignore other properties and separators. Example: `- **Display text**. Tooltip or optionally AI-generated short description.`.
- If a tooltip is missing and the display text does not give enough information to users, generate short description from the display text or/and the method code. Don't generate if you are unsure how the command works. Better no description than incorrect description.
- You can generate multiline descriptions. Keep newlines in tooltips.
- Where method `_Init` populates submenu items dynamically, mention it somehow, eg "Populated dynamically at run time".
- The generated Markdown document will be part of the LibreAutomate documentation. LibreAutomate users will see it.
*/

using Au.Controls;
using ToolLand;
using System.Windows;
using System.Windows.Controls;

namespace LA;

static class Menus {
	const string
		black = EdIcons.black,
		blue = EdIcons.blue,
		green = EdIcons.green,
		green2 = EdIcons.green2,
		brown = EdIcons.brown,
		purple = EdIcons.purple,
		darkYellow = EdIcons.darkYellow,
		orange = EdIcons.orange,
		red = EdIcons.red
		;
	
	[Command(target = "Files")]
	public static class File {
		[Command(target = "", image = "*Material.FilePlusOutline" + black)]
		public static class New {
			static FileNode _New(string name) => App.Model.NewItem(name, beginRenaming: true);
			
			[Command('s', keys = "Ctrl+N", image = EdIcons.Script, tooltip = "A script is a C# code file that can be executed like a program.")]
			public static void New_script() { _New("Script.cs"); }
			
			[Command('c', image = EdIcons.Class, tooltip = "Class files contain C# classes/functions that can be used in other C# files.")]
			public static void New_class() { _New("Class.cs"); }
			
			[Command('t', image = "*FeatherIcons.FileText" + black, tooltip = "Text files contain any text except C# code.\nTo change the file type, edit the \"txt\" in the filename.")]
			public static void New_text_file() { _New("File.txt"); }
			
			[Command('f', image = EdIcons.Folder)]
			public static void New_folder() { _New(null); }
			
			static void _Init(KMenuCommands mc, KMenuCommands.Command c) {
				c.OnSubmenuOpened(mi => FilesModel.FillMenuNew(mi));
			}
		}
		
		[Command("Delete...", separator = true, keysText = "Delete", image = "*Modern.Delete" + black)]
		public static void Delete() { App.Model.DeleteSelected(); }
		
		[Command(keys = "F2", image = "*BoxIcons.RegularRename @15" + black)]
		public static void Rename() { App.Model.RenameSelected(); }
		
		[Command(image = "*RemixIcon.ChatSettingsLine" + green)]
		public static void Properties() { App.Model.Properties(); }
		
		[Command("Copy, paste")]
		public static class CopyPaste {
			[Command("Multi-select", checkable = true, image = "*Modern.ListTwo" + green, tooltip = "If checked:\n    - You can select multiple items with Ctrl or Shift.\n    - Double-click to open.")]
			public static void MultiSelect_files() { Panels.Files.TreeControl.SetMultiSelect(toggle: true); }
			
			[Command("Cu_t", separator = true, keysText = "Ctrl+X")]
			public static void Cut_file() { App.Model.CutCopySelected(true); }
			
			[Command("Copy", keysText = "Ctrl+C")]
			public static void Copy_file() { App.Model.CutCopySelected(false); }
			
			[Command("Paste", keysText = "Ctrl+V")]
			public static void Paste_file() { App.Model.Paste(); }
			
			[Command("Cancel Cut/Copy", keysText = "Esc")]
			public static void CancelCutCopy_file() { App.Model.Uncut(); }
			
			[Command('r', separator = true, tooltip = @"Path in this workspace (in the Files list), like ""\Folder\File.cs"".")]
			public static void Copy_relative_path() { App.Model.SelectedCopyPath(false); }
			
			[Command('f', tooltip = "Full path of the file.")]
			public static void Copy_full_path() { App.Model.SelectedCopyPath(true); }
		}
		
		[Command("Open, close")]
		public static class OpenClose {
			[Command(keysText = "Enter")]
			public static void Open() { App.Model.OpenSelected(1); }
			
			[Command(image = "*MaterialDesign.OpenInNew" + black)]
			public static void Open_in_default_app() { App.Model.OpenSelected(3); }
			
			[Command(image = "*Material.FolderMarker" + darkYellow)]
			public static void Select_in_Explorer() { App.Model.OpenSelected(4); }
			
			[Command(separator = true, target = "", keys = "Ctrl+F4", keysText = "M-click")]
			public static void Close() { App.Model.CloseEtc(FilesModel.ECloseCmd.CloseSelectedOrCurrent); }
			
			[Command(target = "")]
			public static void Close_all() { App.Model.CloseEtc(FilesModel.ECloseCmd.CloseAll); }
			
			[Command(separator = true, target = "", image = "*Codicons.CollapseAll" + black)]
			public static void Collapse_all_folders() { App.Model.CloseEtc(FilesModel.ECloseCmd.CollapseAllFolders); }
			
			[Command(target = "", image = "*Codicons.CollapseAll" + black)]
			public static void Collapse_inactive_folders() { App.Model.CloseEtc(FilesModel.ECloseCmd.CollapseInactiveFolders); }
		}
		
		[Command("Export, import", separator = true)]
		public static class ExportImport {
			[Command("...")]
			public static void Export() { App.Model.ExportSelected(); }
			
			[Command("Import .zip...", separator = true)]
			public static void Import_zip() {
				var d = new FileOpenSaveDialog("{4D1F3AFB-DA1A-45AC-8C12-41DDA5C51CDA}") { Title = "Import .zip", FileTypes = "Zip files|*.zip" };
				if (d.ShowOpen(out string s, App.Hmain))
					App.Model.ImportWorkspace(s);
			}
			
			[Command("...")]
			public static void Import_workspace() {
				var d = new FileOpenSaveDialog("{4D1F3AFB-DA1A-45AC-8C12-41DDA5C51CDA}") { Title = "Import workspace" };
				if (d.ShowOpen(out string s, App.Hmain, selectFolder: true))
					App.Model.ImportWorkspace(s);
			}
			
			[Command("...")]
			public static void Import_files() { App.Model.ImportFiles(false); }
			
			[Command("...")]
			public static void Import_folder() { App.Model.ImportFiles(true); }
		}
		
		[Command(target = "")]
		public static class Workspace {
			static void _Init(KMenuCommands mc, KMenuCommands.Command c) {
				c.OnSubmenuOpened(mi => FilesModel.FillMenuRecentWorkspaces(mi));
			}
			
			[Command(image = "*Material.Reload" + black)]
			public static void Reload_this_workspace() { FilesModel.LoadWorkspace(App.Model.WorkspaceDirectory); }
			
			[Command("...", separator = true)]
			public static void Open_workspace() { FilesModel.OpenWorkspaceUI(); }
			
			[Command("...")]
			public static void New_workspace() { FilesModel.NewWorkspaceUI(); }
			
			[Command("...", separator = true)]
			public static void Repair_workspace() { RepairWorkspace.Repair(); }
			
			[Command(separator = true, keys = "Ctrl+S", image = "*BoxIcons.RegularSave" + black, tooltip = "Save all changes now (don't wait for auto-save). Editor text, files, settings etc.")]
			public static void Save_now() { App.Model?.Save.AllNowIfNeed(); }
		}
		
		[Command(target = "", image = "*Material.Git" + blue)]
		public static class Git {
			[Command(image = "*MaterialDesign.InfoOutline" + blue)]
			public static void Git_status() { LA.Git.Status(); }
			
			[Command("Commit", image = "*RemixIcon.GitCommitLine" + blue)]
			public static void Git_commit() { LA.Git.Commit(); }
			
			[Command("Push to GitHub", image = "*Unicons.CloudUpload" + blue)]
			public static void Git_push() { LA.Git.Push(); }
			
			[Command("Pull from GitHub", image = "*Unicons.CloudDownload" + blue)]
			public static void Git_pull() { LA.Git.Pull(); }
			
			[Command("GitHub Desktop", image = "*Codicons.Github" + purple, separator = true)]
			public static void Git_gui() { LA.Git.RunGui(); }
			
			[Command("Cmd", image = "*Material.Console" + black)]
			public static void Git_cmd() { LA.Git.RunCmd(); }
			
			[Command("Workspace folder", image = "*Material.Folder" + darkYellow)]
			public static void Git_workspace_folder() { LA.Git.WorkspaceFolder(); }
			
			[Command("Reload workspace", image = "*Material.Reload" + black)]
			public static void Git_reload_workspace() { LA.Git.ReloadWorkspace(); }
			
			[Command("GitHub sign out", separator = true)]
			public static void Git_sign_out() { LA.Git.Signout(); }
			
			[Command("Maintenance...")]
			public static void Git_maintenance() { LA.Git.Maintenance(); }
			
			[Command("...")]
			public static void Git_setup() { LA.Git.Setup(); }
		}
		
		[Command(separator = true, target = "", keysText = "Alt+F4")]
		public static void Close_window() { if (App.Settings.runHidden) App.Wmain.Hide_(); else App.Wmain.Close(); }
		
		[Command(target = "")]
		public static void Exit() { Application.Current.Shutdown(); }
	}
	
	[Command(target = "Edit")]
	public static class Edit {
		[Command]
		public static class Clipboard {
			[Command('t', keys = "Ctrl+X", image = "*Zondicons.EditCut" + brown)]
			public static void Cut() { Panels.Editor.ActiveDoc.Call(Sci.SCI_CUT); }
			
			[Command(keys = "Ctrl+C", image = "*Material.ContentCopy" + brown)]
			public static void Copy() { Panels.Editor.ActiveDoc.ECopy(); }
			
			[Command(keys = "Ctrl+V", image = EdIcons.Paste)]
			public static void Paste() { Panels.Editor.ActiveDoc.EPaste(); }
			
			[Command("Copy _forum code", image = "*Material.ForumOutline" + brown, separator = true)]
			public static void Forum_copy() { Panels.Editor.ActiveDoc.ECopy(SciCode.ECopyAs.Forum); }
			
			[Command("Copy HTML <span style>")]
			public static void Copy_HTML_span_style() { Panels.Editor.ActiveDoc.ECopy(SciCode.ECopyAs.HtmlSpanStyle); }
			
			[Command("Copy HTML <span class> and CSS")]
			public static void Copy_HTML_span_class_CSS() { Panels.Editor.ActiveDoc.ECopy(SciCode.ECopyAs.HtmlSpanClassCss); }
			
			[Command("Copy HTML <span class>")]
			public static void Copy_HTML_span_class() { Panels.Editor.ActiveDoc.ECopy(SciCode.ECopyAs.HtmlSpanClass); }
			
			[Command]
			public static void Copy_markdown() { Panels.Editor.ActiveDoc.ECopy(SciCode.ECopyAs.Markdown); }
			
			[Command]
			public static void Copy_without_screenshots() { Panels.Editor.ActiveDoc.ECopy(SciCode.ECopyAs.TextWithoutScreenshots); }
		}
		
		[Command("Undo")]
		public static class UndoRedo {
			[Command(keys = "Ctrl+Z", image = EdIcons.Undo)]
			public static void Undo() { SciUndo.OfWorkspace.UndoRedo(false); }
			
			[Command(keys = "Ctrl+Y", image = "*Ionicons.RedoiOS" + brown)]
			public static void Redo() { SciUndo.OfWorkspace.UndoRedo(true); }
			
			[Command(separator = true, tooltip = "Undo a multi-file operation, such as renaming a symbol in multiple files.")]
			public static void Undo_in_files() { SciUndo.OfWorkspace.UndoRedoMultiFileReplace(false); }
			
			[Command(tooltip = "Redo a multi-file operation.")]
			public static void Redo_in_files() { SciUndo.OfWorkspace.UndoRedoMultiFileReplace(true); }
		}
		
		[Command("Find", separator = true)]
		public static class Find {
			[Command("Find text", keys = "Ctrl+F", image = "*Material.FindReplace" + blue)]
			public static void Find_text() { Panels.Find.CtrlF(Panels.Editor.ActiveDoc); }
			
			[Command("...", keys = "Ctrl+T", image = "*FontAwesome.SearchLocationSolid" + blue)]
			public static void Find_symbol() { CiFindGo.ShowSingle(); }
			
			[Command(keys = "Shift+F12", image = EdIcons.References, separator = true)]
			public static void Find_references() { CiFind.FindReferencesOrImplementations(false); }
			
			[Command(image = "*Material.InformationVariant" + blue)]
			public static void Find_implementations() { CiFind.FindReferencesOrImplementations(true); }
			
			[Command(keys = "F12", image = "*RemixIcon.WalkFill" + blue, separator = true)]
			public static void Go_to_definition() { CiGoTo.GoToDefinition(); }
			
			[Command]
			public static void Go_to_base() { CiGoTo.GoToBase(); }
			
			[Command(keys = "F2", image = "*PicolIcons.Edit" + blue, separator = true)]
			public static void Rename_symbol() { CiFind.RenameSymbol(); }
			
			[Command(keys = "F3", target = "", separator = true)]
			public static void Find_next() { Panels.Find.FindNextInEditor(false); }
			
			[Command(keys = "Shift+F3", target = "")]
			public static void Find_previous() { Panels.Find.FindNextInEditor(true); }
			
			[Command(keys = "F4", target = "")]
			public static void Next_found() { Panels.Found.NextFound(false); }
			
			[Command(keys = "Shift+F4", target = "")]
			public static void Previous_found() { Panels.Found.NextFound(true); }
		}
		
		[Command]
		public static class Assist {
			[Command(keysText = "Ctrl+Space", image = "*FontAwesome.ListUlSolid" + blue)]
			public static void Autocompletion_list() { CodeInfo.ShowCompletionList(); }
			
			[Command(keysText = "Ctrl+Shift+Space", image = "*RemixIcon.ParenthesesLine" + blue)]
			public static void Parameter_info() { CodeInfo.ShowSignature(); }
			
			const string c_tooltip_Autocorrect_raw_enter = """
Temporarily disables the "auto-complete statement on Enter" features that are enabled in Options > Code editor.
Other ways to insert new line before ) or ] or ; when the auto-completion features are enabled:
- Shift+Enter. Or Ctrl+Enter, depending on settings.
- Space, then Enter.
- Enter, then Ctrl+Z (undo).
- Continue a vertical method chain by typing . on the next line after the ;.
To exit statement when the features are disabled, use Ctrl+Enter. Or Shift+Enter, depending on settings.
More info in app help topic "Code editor".
""";
			
			[Command("Raw Enter before ) ] ;", checkable = true, separator = true, image = "*Unicons.Enter" + green, tooltip = c_tooltip_Autocorrect_raw_enter)]
			public static void Autocorrect_raw_enter() {
				App.Settings.ci_tempRawEnter ^= true;
				if (!App.Settings.ci_enterBeforeParen && !App.Settings.ci_enterBeforeSemicolon)
					print.it($"<>Note: the <b>Raw Enter before ) ] ;<> option temporarily disables the statement auto-completion features if they are enabled in <+options {DOptions.EPage.CodeEditor}>Options<>. Currently it has no effect because the features are disabled.");
			}
			
			static void _Init(KMenuCommands mc, KMenuCommands.Command c) {
				if (App.Settings.ci_tempRawEnter) mc[nameof(Autocorrect_raw_enter)].MenuItem.IsChecked = true;
			}
		}
		
		[Command]
		public static class Navigate {
			[Command(image = "*Material.Bookmark @16" + darkYellow)]
			public static void Toggle_bookmark() { Panels.Bookmarks.ToggleBookmark(); }
			
			[Command(image = "*JamIcons.ArrowSquareUp" + black, keys = "Alt+Up", noIndirectDisable = true)]
			public static void Previous_bookmark() { Panels.Bookmarks.NextBookmark(true); }
			
			[Command(image = "*JamIcons.ArrowSquareDown" + black, keys = "Alt+Down", noIndirectDisable = true)]
			public static void Next_bookmark() { Panels.Bookmarks.NextBookmark(false); }
			
			[Command(keys = "Alt+Left", target = "", image = EdIcons.Back, separator = true, noIndirectDisable = true)]
			public static void Go_back() { App.Model.EditGoBack.GoBack(); }
			
			[Command(keys = "Alt+Right", target = "", image = "*EvaIcons.ArrowForward" + black, noIndirectDisable = true)]
			public static void Go_forward() { App.Model.EditGoBack.GoForward(); }
			
			[Command(separator = true, target = "", keys = "Ctrl+Tab", noIndirectDisable = true)]
			public static void Previous_document() { var a = App.Model.OpenFiles; if (a.Count > 1) App.Model.SetCurrentFile(a[1]); }
		}
		
		[Command(separator = true)]
		public static class Selection {
			[Command(keys = "Ctrl+/", image = $"*Material.SlashForward{brown} %1,1,7,1,f; *FontAwesome.AsteriskSolid{brown} %9")]
			public static void Toggle_comment() { ModifyCode.Comment(null); }
			
			[Command(keysText = "R-click margin", image = $"*Material.SlashForward{brown} %1,1,7,1,f; *Material.SlashForward{brown} %7,1,1,1,f,p")]
			public static void Toggle_line_comment() { ModifyCode.Comment(null, notSlashStar: true); }
			
			[Command(image = $"*Material.SlashForward{brown} %1,1,7,1,f; *Material.SlashForward{brown} %5,1,3,1,f; *Material.Plus{brown} %10,10,,1,,p")]
			public static void Comment_selection() { ModifyCode.Comment(true); }
			
			[Command(image = $"*Material.SlashForward{brown} %1,1,7,1,f; *Material.SlashForward{brown} %5,1,3,1,f; *Material.Minus{brown} %11,10,,1,,p")]
			public static void Uncomment_selection() { ModifyCode.Comment(false); }
			
			//TODO2: Toggle multiline (parameters, collections, etc). Hotkey Ctrl+L.
			
			[Command("...", image = "*RemixIcon.BracesLine" + brown, separator = true)]
			public static void Surround() { CiSnippets.Surround(); }
			
			[Command("...")]
			public static void Documentation_tags() { run.itSafe("https://www.libreautomate.com/forum/showthread.php?tid=7461"); }
			
			[Command(separator = true, keysText = "Ctrl+A")]
			public static void Select_all() { Panels.Editor.ActiveDoc.Call(Sci.SCI_SELECTALL); }
		}
		
		[Command]
		public static class Tidy_code {
			[Command(image = "*PixelartIcons.AlignLeft" + brown)]
			public static void Format_document() { ModifyCode.Format(false); }
			
			[Command(image = "*PixelartIcons.AlignLeft" + brown)]
			public static void Format_selection() { ModifyCode.Format(true); }
			
			[Command]
			public static void Disable_format_selection() { InsertCode.SurroundPragmaWarningFormat(); }
			
			[Command("Indent selected lines", keysText = "Tab", image = "*Material.FormatIndentIncrease" + brown, separator = true)]
			public static void Indent() { Panels.Editor.ActiveDoc.Call(Sci.SCI_TAB); }
			//never mind: now does not indent empty lines if was no indent.
			
			[Command("Unindent selected lines", keysText = "Shift+Tab", image = "*Material.FormatIndentDecrease" + brown)]
			public static void Unindent() { Panels.Editor.ActiveDoc.Call(Sci.SCI_BACKTAB); }
			
			[Command("Deduplicate wnd.find", separator = true, image = "*Material.Broom" + brown, tooltip = "Remove duplicate `wnd.find` statements in all or selected text.")]
			public static void Deduplicate_wnd_find() { ModifyCode.CleanupWndFind(); }
			
			[Command(tooltip = "Remove screenshots in all or selected text.\nScreenshot images are saved in text as hidden comments.")]
			public static void Remove_screenshots() { Panels.Editor.ActiveDoc.EImageRemoveScreenshots(); }
		}
		
		[Command]
		public static class Generate {
			[Command(keys = "Ctrl+Shift+D", image = "*Material.Lambda" + brown)]
			public static void Create_delegate() { GenerateCode.CreateDelegate(); }
			
			[Command("Implement interface/abstract", tooltip = "Implement members of interface or abstract base class.")]
			public static void Implement_interface() { GenerateCode.ImplementInterfaceOrAbstractClass(); }
			
			[Command]
			public static void Create_event_handlers() { GenerateCode.CreateEventHandlers(); }
			
			[Command]
			public static void Create_overrides() { GenerateCode.CreateOverrides(); }
			
			[Command("Create GUID")]
			public static void Create_GUID() { var s = Guid.NewGuid().ToString(); clipboard.text = s; print.it($"Clipboard: {s}"); }
			//}
			
			//[Command]
			//public static class Refactor {
			[Command]
			public static void Add_function_Main() { InsertCode.AddClassProgram(); }
			
			[Command("Convert [PreserveSig] methods")]
			public static void Convert_PreserveSig() { ModifyCode.ConvertInterfaceMethodPreserveSig(); }
		}
		
		[Command(separator = true)]
		public static class View {
			[Command(checkable = true, keys = "Ctrl+W", image = "*Codicons.WordWrap" + green)]
			public static void Wrap_lines() { SciCode.EToggleView_call_from_menu_only_(SciCode.EView.Wrap); }
			
			[Command(checkable = true, image = "*Material.TooltipImageOutline" + green, tooltip = "If checked, displays images (file icons, screenshots, \"image:\", \"*icon\").\nAlso captures screenshots when recording etc.")]
			public static void Images_in_code() { SciCode.EToggleView_call_from_menu_only_(SciCode.EView.Images); }
			
			[Command(checkable = true, image = "*Codicons.Preview" + green)]
			public static void WPF_preview(MenuItem mi) { SciCode.WpfPreviewStartStop(mi); }
			
			[Command("Customize...", separator = true)]
			public static void Customize_edit_context_menu() { DCustomizeContextMenu.Dialog("Edit", "code editor"); }
		}
	}
	
	[Command(target = "Edit", tooltip = "Tools for creating code")]
	public static class Code {
		[Command(underlined: 'r', image = "*Material.RecordRec" + blue)]
		public static void Input_recorder() { DInputRecorder.ShowRecorder(); }
		
		[Command("Find _window", image = "*BoxIcons.SolidWindowAlt" + blue)]
		public static void wnd() { ToolProcess.StartDwnd(); }
		
		[Command("Find UI _element", image = "*Material.CheckBoxOutline @15" + blue)]
		public static void elm() { ToolProcess.StartDelm(); }
		
		[Command("Find _image", image = "*Material.ImageSearchOutline" + blue)]
		public static void uiimage() { ToolProcess.StartDuiimage(); }
		
		[Command("Find _OCR text", image = "*Material.Ocr" + blue)]
		public static void ocr() { ToolProcess.StartDocr(); }
		
		[Command(image = "*Material.FolderOutline" + blue)]
		public static void Get_files_in_folder() { DEnumDir.Dialog(); }
		
		[Command(keysText = "Ctrl+Space in string", image = EdIcons.Keys)]
		public static void Keys() { CiTools.CmdShowKeysWindow(); }
		
		[Command(underlined: 'x', image = EdIcons.Regex, keysText = "Ctrl+Space in string")]
		public static void Regex() { CiTools.CmdShowRegexWindow(); }
		
		[Command(image = EdIcons.Color)]
		public static void Color() { KColorPicker.ColorTool(s => { clipboard.text = s; print.it($"Clipboard: {s}"); }, App.Wmain, modal: false, add0xRgbButton: true, addBgrButton: true); }
		
		[Command(underlined: 'A', image = "*Material.Api" + blue)]
		public static void Windows_API() { new DWinapi().Show(); }
		
		[Command(separator = true)]
		public static void Quick_capturing_info() { QuickCapture.Info(); }
	}
	
	[Command("T\x2009T", target = "", tooltip = "Triggers and toolbars")]
	public static class TT {
		[Command('k'/*, separator = true*/)]
		public static void Hotkey_triggers() { TriggersAndToolbars.Edit(@"Triggers\Hotkey triggers.cs"); }
		
		[Command]
		public static void Autotext_triggers() { TriggersAndToolbars.Edit(@"Triggers\Autotext triggers.cs"); }
		
		[Command]
		public static void Mouse_triggers() { TriggersAndToolbars.Edit(@"Triggers\Mouse triggers.cs"); }
		
		[Command]
		public static void Window_triggers() { TriggersAndToolbars.Edit(@"Triggers\Window triggers.cs"); }
		
		[Command("...", image = EdIcons.Trigger)]
		public static void New_trigger() { TriggersAndToolbars.NewTrigger(); }
		
		//rejected. It's in the quick capturing menu.
		//[Command("...")]
		//public static void Trigger_scope() { TriggersAndToolbars.TriggerScope(); }
		
		//has no sense. It shows triggers for the active window. Also may be multiple trigger scripts running. Instead let use a trigger that calls ActionTriggers.TriggersListWindow.
		//[Command]
		//public static void Active_triggers() { TriggersAndToolbars.ShowActiveTriggers(); }
		
		[Command]
		public static void Other_triggers() { TriggersAndToolbars.Edit(@"Triggers\Other triggers.cs"); PanelHelp.OpenRecipe("Other triggers"); }
		
		[Command(separator = true)]
		public static void Toolbars() { TriggersAndToolbars.GoToToolbars(); }
		
		[Command("...", image = "*Material.ShapeRectanglePlus" + blue)]
		public static void New_toolbar() { TriggersAndToolbars.NewToolbar(); }
		
		[Command("...")]
		public static void Toolbar_trigger() { TriggersAndToolbars.SetToolbarTrigger(); }
		
		[Command]
		public static void Active_toolbars() { TriggersAndToolbars.ShowActiveToolbars(); }
		
		[Command(separator = true)]
		public static void Disable_triggers() { TriggersAndToolbars.DisableTriggers(null); }
		
		static void _Init(KMenuCommands mc, KMenuCommands.Command c) {
			if (Au.Triggers.ActionTriggers.DisabledEverywhere) mc[nameof(Disable_triggers)].Checked = true;
		}
		
		[Command]
		public static void Restart_TT_script() { TriggersAndToolbars.Restart(); }
		
		[Command(tooltip = "Finds triggers of current script.\nFinds its name in '@Triggers and toolbars' files in trigger actions, toolbar button actions and other code.\nAlso finds scheduled tasks, workspace startup scripts and class file test scripts.")]
		public static void Find_triggers() { TriggersAndToolbars.AllTriggersMenu(App.Model.CurrentFile); }
		
		[Command]
		public static void Triggers_list_info() { PanelHelp.OpenRecipe("Show triggers"); }
		
		[Command(separator = true, image = "*RemixIcon.TerminalLine" + blue)]
		public static class Script_launchers {
			[Command("...", image = "*RemixIcon.TerminalLine" + blue)]
			public static void Command_line() { DCommandline.Commandline.ShowForCurrentFile(); }
			
			[Command("...", image = "*Unicons.Schedule" + blue)]
			public static void Schedule() { DSchedule.ShowFor(App.Model.CurrentFile); }
			
			[Command("...")]
			public static void Shortcut() { DCommandline.Shortcut.ShowForCurrentFile(); }
			
			[Command("...")]
			public static void Shell_menu() { DCommandline.ShellMenu.ShowForCurrentFile(); }
			
			[Command("...", separator = true)]
			public static void Run_at_startup() { DOptions.AaShow(DOptions.EPage.Workspace); }
		}
	}
	
	[Command(target = "Edit")]
	public static class Run {
		[Command(image = "*VaadinIcons.Compile" + blue)]
		public static void Compile() { CompileRun.CompileAndRun(false, App.Model.CurrentFile); }
		
		[Command("Run", image = "*Codicons.DebugStart" + green2)]
		public static void Run_script() { CompileRun.CompileAndRun(true, App.Model.CurrentFile, runFromEditor: true); }
		
		[Command(image = "*Material.SquareOutline @14" + black)]
		public static void End_task() {
			var f = App.Model.CurrentFile;
			if (f != null) {
				f = f.GetProjectMainOrThis();
				if (App.Tasks.EndTasksOf(f)) return;
			}
			
			var a = App.Tasks.Items;
			if (a.Count > 0) {
				var m = new popupMenu { RawText = true };
				m.Submenu("End task", m => {
					foreach (var t in a) m[t.f.DisplayName] = o => App.Tasks.EndTask(t);
				});
				m.Show(owner: App.Hmain);
			}
		}
		
		[Command("...", image = "*BoxIcons.RegularHistory" + black)]
		public static void Recent() { RecentTT.Show(); }
		
		[Command(image = "*Material.Bug" + green2)]
		public static void Debug_run() { Panels.Debug.Start(); }
		
		[Command("...", image = "*Entypo.Publish" + blue, separator = true)]
		public static void Publish() { new XPublish().Publish(); }
		
		[Command(image = "*MaterialDesign.PictureInPictureAlt" + blue, separator = true, tooltip = "Another session of this user inside a Picture-in-Picture window")]
		public static void PiP_session() { PipIPC.StartPip(); }
		
		[Command(image = "*Codicons.DebugStart %,,6" + green2 + "; *MaterialDesign.Rectangle %10.2,10.8,,.6,f" + blue)]
		public static void Run_in_PiP() { PipIPC.RunScriptInPip(App.Model.CurrentFile); }
	}
	
	[Command(target = "")]
	public static class Tools {
		[Command(image = "*PicolIcons.Settings" + green)]
		public static void Options() { DOptions.AaShow(); }
		
		[Command(image = EdIcons.Icons)]
		public static void Icons() { DIcons.ShowSingle(); }
		
		[Command(tooltip = "Clear icon caches")]
		public static void Update_icons() { IconImageCache.ClearAll(); }
		
		[Command(image = "*SimpleIcons.NuGet" + blue)]
		public static void NuGet() { DNuget.ShowSingle(); }
		
		[Command(image = "*Codicons.SymbolSnippet" + blue)]
		public static void Snippets() { DSnippets.ShowSingle(); }
		
		[Command]
		public static void Customize() { DCustomize.ShowSingle(); }
		
		[Command]
		public static void Portable() { DPortable.ShowSingle(); }
		
		[Command(separator = true, target = "Output")]
		public static class Output {
			[Command("Clear", keysText = "M-click")]
			public static void Output_clear() { Panels.Output.Clear(); }
			
			[Command("Copy", keysText = "Ctrl+C")]
			public static void Output_copy() { Panels.Output.Copy(); }
			
			[Command("History")]
			public static void Output_history() { Panels.Output.History(); }
			
			[Command("Wrap lines", separator = true, checkable = true)]
			public static void Output_wrap_lines() { Panels.Output.WrapLines ^= true; }
			
			[Command("White space", checkable = true)]
			public static void Output_white_space() { Panels.Output.WhiteSpace ^= true; }
		}
	}
	
	[Command(target = "")]
	public static class Help {
		[Command(image = EdIcons.Help)]
		public static void LA_docs() { Panels.Help.MenuCommand(); }
		
		[Command("C# docs", image = "*Modern.LanguageCsharp" + darkYellow)]
		public static void CSharp_docs() { run.itSafe("https://learn.microsoft.com/en-us/dotnet/csharp/"); }
		
		[Command(keys = "F1", image = "*Unicons.MapMarkerQuestion" + darkYellow)]
		public static void Context_help() {
			var w = Api.GetFocus();
			if (w.ClassNameIs("HwndWrapper*")) {
				//var e = Keyboard.FocusedElement as FrameworkElement;
				
			} else if (Panels.Editor.ActiveDoc is SciCode doc && w == doc.AaWnd) {
				CiUtil.OpenSymbolEtcFromPosHelp();
			}
		}
		
		[Command(image = "*Modern.Home" + darkYellow)]
		public static void Website() { run.itSafe("https://www.libreautomate.com/"); }
		
		[Command(image = "*Material.Forum" + darkYellow)]
		public static void Forum() { run.itSafe("https://www.libreautomate.com/forum/"); }
		
		[Command("What's new")]
		public static void Whats_new() { run.itSafe($"https://github.com/qgindi/LibreAutomate/blob/master/Other/DocFX/_doc/changes/v{new Version(Au_.Version).ToString(2)}.md"); }
		
		[Command]
		public static void Email() { run.itSafe($"mailto:info@libreautomate.com?subject={App.AppName} {Au_.Version}"); }
		
		[Command]
		public static void Donate() { run.itSafe("https://github.com/sponsors/qgindi"); }
		
		[Command]
		public static void About() {
			print.it($@"<>---- {App.AppName} ----
Version: {Au_.Version}
Download: <link>https://www.libreautomate.com/<>
Source code: <link>https://github.com/qgindi/LibreAutomate<>
Uses C# 14, <link https://dotnet.microsoft.com/download>.NET {Environment.Version}<>, <link https://github.com/dotnet/roslyn>Roslyn<>, <link https://www.scintilla.org/>Scintilla 5.5.7<>, <link https://www.pcre.org/>PCRE 10.46<>, <link https://www.sqlite.org/index.html>SQLite<>, <link https://github.com/MahApps/MahApps.Metro.IconPacks>MahApps.Metro.IconPacks 5.1<>, <link https://github.com/dotnet/docfx>DocFX<>, <link https://github.com/Samsung/netcoredbg>Samsung/netcoredbg<>, <link https://github.com/microsoft/win32metadata>win32metadata<>, <link https://github.com/google/diff-match-patch>DiffMatchPatch<>, <link https://github.com/DmitryGaravsky/ILReader>ILReader<>, <link https://github.com/nemec/porter2-stemmer>Porter2Stemmer<>, <link https://github.com/xoofx/markdig>Markdig<>.
Folders: <link {folders.Workspace}>Workspace<>, <link {folders.ThisApp}>ThisApp<>, <link {folders.ThisAppDocuments}>ThisAppDocuments<>, <link {folders.ThisAppDataLocal}>ThisAppDataLocal<>, <link {folders.ThisAppDataRoaming}>ThisAppDataRoaming<>, <link {folders.ThisAppTemp}>ThisAppTemp<>.
{typeof(App).Assembly.GetCustomAttribute<AssemblyCopyrightAttribute>().Copyright}.
--------------------------");
		}
	}
	
#if DEBUG || IDE_LA
	//[Command(target = "", keys = "F11")] //no, dangerous, eg can accidentally press instead of F12
	[Command]
	public static void TEST() { Test.FromMenubar(); }
	
	[Command]
	public static void gc() {
		GC.Collect();
		GC.WaitForPendingFinalizers(); //GC.Collect does not free much memory without this
	}
#endif
	
	//Used by ScriptEditor.InvokeCommand/GetCommandState.
	//flags: 1 check, 2 uncheck, 4 activate window, 8 dontWait, 16 editorExtension.
	internal static int Invoke(string command, bool getState, int flags = 0) {
		var w = App.Hmain;
		bool loading = w.Is0;
		if (loading) {
			//this func can't work if the main window still not created
			App.ShowWindow();
			//let the script wait and retry. Some commands don't work until inited codeinfo etc. Until then w is disabled.
		} else {
			//few commands work or have sense when the window is invisible. Show it even when getState.
			if (0 != (flags & 4)) App.ShowWindow(); //show and activate
			else { //just show
				WndUtil.EnableActivate(); //enable activating if need, eg tool windows
				if (!App.Wmain.IsVisible) App.Wmain.Show();
			}
		}
		
		if (App.Commands.TryFind(command, out var c)) {
			if (loading || !w.IsEnabled()) {
				if (0 != (flags & 16)) return getState ? (int)ECommandState.Disabled : 0; //editorExtension, can't wait
				return -1; //let the script wait while disabled, even if getState
			}
			
			if (getState) {
				ECommandState r = c.CanExecute(null) ? 0 : ECommandState.Disabled;
				if (c.Checked) r |= ECommandState.Checked;
				return (int)r;
			} else if (c.CanExecute(null)) {
				if (0 != (flags & 8)) { //dontWait
					if (0 != (flags & 16)) { //editorExtension
						App.Dispatcher.InvokeAsync(_Invoke);
						return 1;
					}
					Api.ReplyMessage(1);
				}
				_Invoke();
				return 1;
				
				void _Invoke() {
					int check = flags & 3;
					if (check is 1 or 2) c.Checked = check == 1; else c.Execute(null);
				}
			}
		} else {
			var names = new StringBuilder();
			foreach (var v in Panels.Menu.Items) _Menu(v, 0);
			void _Menu(object o, int level) {
				if (o is MenuItem mi && mi.Command is KMenuCommands.Command c) {
					names.Append('\t', level).AppendLine(c.Name);
					foreach (var v in mi.Items) _Menu(v, level + 1);
				}
			}
			
			print.it(command.NE() ? "Commands:\r\n" + names : $"Unknown command '{command}'. Commands:\r\n{names}");
		}
		return 0;
	}
}


================================================
FILE: Au.Editor/Au.Editor.cs
================================================
/*/
role exeProgram
define IDE_LA,NO_GLOBAL,NO_DEFAULT_CHARSET_UNICODE
noWarnings 8002,419
testInternal Microsoft.CodeAnalysis,Microsoft.CodeAnalysis.CSharp,Microsoft.CodeAnalysis.Features,Microsoft.CodeAnalysis.CSharp.Features,Microsoft.CodeAnalysis.Workspaces,Microsoft.CodeAnalysis.CSharp.Workspaces
preBuild .\_prePostBuild.cs
postBuild .\_prePostBuild.cs /post $(outputPath)
outputPath %folders.Workspace%\..\Au.Editor
icon resources\ico
manifest resources\Au.manifest
sign resources\Au.snk
miscFlags 1
noRef *\Au.dll
pr ..\@Au\Au.cs
pr ..\@Au.Controls\Au.Controls.cs
r Roslyn\Microsoft.CodeAnalysis.dll /noCopy
r Roslyn\Microsoft.CodeAnalysis.CSharp.dll /noCopy
r Roslyn\Microsoft.CodeAnalysis.Features.dll /noCopy
r Roslyn\Microsoft.CodeAnalysis.CSharp.Features.dll /noCopy
r Roslyn\Microsoft.CodeAnalysis.Workspaces.dll /alias=CAW|noCopy
r Roslyn\Microsoft.CodeAnalysis.CSharp.Workspaces.dll /noCopy
r AxMSTSCLib.dll
r MSTSCLib.dll
r NuGet.Configuration.dll
r NuGet.Versioning.dll
nuget webview\Microsoft.Web.WebView2
resource app\app-resources.xaml /path
resource resources\ci /path
file .\Default
/*/


================================================
FILE: Au.Editor/Au.Editor.csproj
================================================
<Project Sdk="Microsoft.NET.Sdk">

	<PropertyGroup>
		<OutputType>WinExe</OutputType>
		<TargetFramework>net10.0-windows</TargetFramework>
		<UseWPF>true</UseWPF>
		<UseWindowsForms>true</UseWindowsForms>
		<GenerateAssemblyInfo>false</GenerateAssemblyInfo>
		<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
		<SignAssembly>true</SignAssembly>
		<AssemblyOriginatorKeyFile>..\Au.snk</AssemblyOriginatorKeyFile>
		<CopyLocalLockFileAssemblies>true</CopyLocalLockFileAssemblies>
		<OutDir>$(SolutionDir)_</OutDir>
		<LangVersion>preview</LangVersion>
		<NoDefaultLaunchSettingsFile>true</NoDefaultLaunchSettingsFile>
		<ProduceReferenceAssembly>False</ProduceReferenceAssembly>
		<GenerateDocumentationFile>True</GenerateDocumentationFile>
		<NoWarn>1701;1702;8002;419;8981;WFO1000</NoWarn>
		<SupportedOSPlatformVersion>7.0</SupportedOSPlatformVersion>
		<NoWin32Manifest>true</NoWin32Manifest>
	</PropertyGroup>

	<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
	  <DebugType>embedded</DebugType>
	</PropertyGroup>

	<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">
	  <DebugType>embedded</DebugType>
	</PropertyGroup>

	<ItemGroup>
		<Compile Include="..\Au\Resources\global2.cs" Link="resources\global2.cs" />
	</ItemGroup>

	<ItemGroup>
		<Compile Remove="_prePostBuild.cs" />
		<Compile Remove="Au.Editor.cs" />
	</ItemGroup>

	<ItemGroup>
		<None Remove="Default\Commands.xml" />
		<None Remove="Default\Layout.xml" />
		<None Remove="Default\Snippets.xml" />
		<None Remove="Default\Themes\*.csv" />
	</ItemGroup>

	<ItemGroup>
		<Content Include="Default\Commands.xml">
			<CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
		</Content>
		<Content Include="Default\Layout.xml">
			<CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
			<SubType>Designer</SubType>
		</Content>
		<Content Include="Default\Snippets.xml">
			<CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
		</Content>
		<Content Include="Default\Themes\*.csv">
		  <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
		</Content>
	</ItemGroup>

	<ItemGroup>
		<Page Remove="resources\ci\Class.xaml" />
		<Page Remove="resources\ci\Constant.xaml" />
		<Page Remove="resources\ci\Delegate.xaml" />
		<Page Remove="resources\ci\Enum.xaml" />
		<Page Remove="resources\ci\EnumMember.xaml" />
		<Page Remove="resources\ci\Event.xaml" />
		<Page Remove="resources\ci\ExpandScope.xaml" />
		<Page Remove="resources\ci\ExtensionMethod.xaml" />
		<Page Remove="resources\ci\Field.xaml" />
		<Page Remove="resources\ci\GroupBy.xaml" />
		<Page Remove="resources\ci\Interface.xaml" />
		<Page Remove="resources\ci\Keyword.xaml" />
		<Page Remove="resources\ci\Label.xaml" />
		<Page Remove="resources\ci\LocalMethod.xaml" />
		<Page Remove="resources\ci\LocalVariable.xaml" />
		<Page Remove="resources\ci\Method.xaml" />
		<Page Remove="resources\ci\Namespace.xaml" />
		<Page Remove="resources\ci\Operator.xaml" />
		<Page Remove="resources\ci\OverlayAbstract.xaml" />
		<Page Remove="resources\ci\OverlayInternal.xaml" />
		<Page Remove="resources\ci\OverlayPrivate.xaml" />
		<Page Remove="resources\ci\OverlayProtected.xaml" />
		<Page Remove="resources\ci\OverlayStatic.xaml" />
		<Page Remove="resources\ci\Property.xaml" />
		<Page Remove="resources\ci\Region.xaml" />
		<Page Remove="resources\ci\Snippet.xaml" />
		<Page Remove="resources\ci\Structure.xaml" />
		<Page Remove="resources\ci\TypeParameter.xaml" />
	</ItemGroup>

	<ItemGroup>
		<Resource Include="resources\ci\Class.xaml" />
		<Resource Include="resources\ci\Constant.xaml" />
		<Resource Include="resources\ci\Delegate.xaml" />
		<Resource Include="resources\ci\Enum.xaml" />
		<Resource Include="resources\ci\EnumMember.xaml" />
		<Resource Include="resources\ci\Event.xaml" />
		<Resource Include="resources\ci\ExpandScope.xaml" />
		<Resource Include="resources\ci\ExtensionMethod.xaml" />
		<Resource Include="resources\ci\Field.xaml" />
		<Resource Include="resources\ci\GroupBy.xaml" />
		<Resource Include="resources\ci\Interface.xaml" />
		<Resource Include="resources\ci\Keyword.xaml" />
		<Resource Include="resources\ci\Label.xaml" />
		<Resource Include="resources\ci\LocalMethod.xaml" />
		<Resource Include="resources\ci\LocalVariable.xaml" />
		<Resource Include="resources\ci\Method.xaml" />
		<Resource Include="resources\ci\Namespace.xaml" />
		<Resource Include="resources\ci\Operator.xaml" />
		<Resource Include="resources\ci\OverlayAbstract.xaml" />
		<Resource Include="resources\ci\OverlayInternal.xaml" />
		<Resource Include="resources\ci\OverlayPrivate.xaml" />
		<Resource Include="resources\ci\OverlayProtected.xaml" />
		<Resource Include="resources\ci\OverlayStatic.xaml" />
		<Resource Include="resources\ci\Property.xaml" />
		<Resource Include="resources\ci\Region.xaml" />
		<Resource Include="resources\ci\Snippet.xaml" />
		<Resource Include="resources\ci\Structure.xaml" />
		<Resource Include="resources\ci\TypeParameter.xaml" />
	</ItemGroup>

	<ItemGroup>
		<ProjectReference Include="..\Au.Controls\Au.Controls.csproj" />
		<ProjectReference Include="..\Au\Au.csproj" />
	</ItemGroup>

	<ItemGroup>
		<Reference Include="AxMSTSCLib">
		  <HintPath>..\_\AxMSTSCLib.dll</HintPath>
		</Reference>
		<Reference Include="Microsoft.CodeAnalysis">
			<HintPath>..\_\Roslyn\Microsoft.CodeAnalysis.dll</HintPath>
			<Private>False</Private>
		</Reference>
		<Reference Include="Microsoft.CodeAnalysis.CSharp">
			<HintPath>..\_\Roslyn\Microsoft.CodeAnalysis.CSharp.dll</HintPath>
			<Private>False</Private>
		</Reference>
		<Reference Include="Microsoft.CodeAnalysis.CSharp.Features">
			<HintPath>..\_\Roslyn\Microsoft.CodeAnalysis.CSharp.Features.dll</HintPath>
			<Private>False</Private>
		</Reference>
		<Reference Include="Microsoft.CodeAnalysis.CSharp.Workspaces">
			<HintPath>..\_\Roslyn\Microsoft.CodeAnalysis.CSharp.Workspaces.dll</HintPath>
			<Private>False</Private>
		</Reference>
		<Reference Include="Microsoft.CodeAnalysis.Features">
			<HintPath>..\_\Roslyn\Microsoft.CodeAnalysis.Features.dll</HintPath>
			<Private>False</Private>
		</Reference>
		<Reference Include="Microsoft.CodeAnalysis.Workspaces">
			<HintPath>..\_\Roslyn\Microsoft.CodeAnalysis.Workspaces.dll</HintPath>
			<Private>False</Private>
			<Aliases>CAW</Aliases>
		</Reference>
		<Reference Include="MSTSCLib">
		  <HintPath>..\_\MSTSCLib.dll</HintPath>
		</Reference>
	</ItemGroup>

	<ItemGroup>
	  <PackageReference Include="Microsoft.Web.WebView2" Version="1.0.3595.46" />
	  <PackageReference Include="NuGet.Configuration" Version="6.14.0" />
	  <PackageReference Include="NuGet.Versioning" Version="6.14.0" />
	</ItemGroup>

	<Target Name="PreBuild" BeforeTargets="PreBuildEvent">
		<Exec Command="$(SolutionDir)Other\BuildEvents\bin\Debug\BuildEvents.exe preBuild $(Configuration)" />
	</Target>

	<Target Name="PostBuild" AfterTargets="PostBuildEvent">
		<Exec Command="$(SolutionDir)Other\BuildEvents\bin\Debug\BuildEvents.exe postBuild $(Configuration)" />
	</Target>

</Project>


================================================
FILE: Au.Editor/Compiler/Compiler.cs
================================================
extern alias CAW;

using System.Reflection.Metadata;
using System.Reflection.PortableExecutable;
using System.Xml.Linq;

using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Emit;

namespace LA;

/// <summary>
/// Compiles C# files.
/// </summary>
partial class Compiler {
	/// <summary>
	/// Compiles C# file or project if need.
	/// Returns false if fails (C# errors etc).
	/// </summary>
	/// <param name="reason">Whether to recompile if compiled, etc. See also Remarks.</param>
	/// <param name="r">Results.</param>
	/// <param name="f">C# file. If projFolder used, must be the main file of the project.</param>
	/// <param name="projFolder">null or project folder.</param>
	/// <param name="needMeta">Parse metacomments and set r.meta even if don't need to compile.</param>
	/// <param name="canCompile">Called after parsing meta, creating trees and compilation, but before emit. Return false to cancel.</param>
	/// <param name="addMetaFlags">Add these flags to the usual flags of MetaComments. Used by MetaComments._PR.</param>
	/// <remarks>
	/// Must be always called in the main UI thread.
	/// 
	/// Adds <see cref="MetaReferences.DefaultReferences"/>.
	/// 
	/// If f role is classFile:
	/// 	If CompReason.Run, does not compile (just parses meta), sets r.role=classFile and returns false.
	/// 	Else compiles but does not create output files.
	/// </remarks>
	public static bool Compile(CCReason reason, out CompResults r, FileNode f, FileNode projFolder = null, bool needMeta = false, Func<CanCompileArgs, bool> canCompile = null, MCFlags addMetaFlags = 0) {
		Debug.Assert(App.IsMainThread);
		r = null;
		var cache = XCompiled.OfWorkspace;
		if (reason is not (CCReason.CompileAlways or CCReason.WpfPreview) && !addMetaFlags.Has(MCFlags.Publish) && cache.IsCompiled(f, out r, projFolder)) {
			//print.it("cached");
			if (needMeta) {
				var m = new MetaComments(MCFlags.PrintErrors | MCFlags.OnlyRef);
				if (!m.Parse(f, projFolder)) return false;
				r.meta = m;
				//CONSIDER: save used dll etc paths in xcompiled, to avoid parsing meta of all pr.
			}
			return true;
		} else {
			//print.it("COMPILE");
			Action aFinally = null;
			try {
				var c = new Compiler();
				if (c._Compile(reason, f, out r, projFolder, out aFinally, canCompile, addMetaFlags)) return true;
			}
			catch (Exception ex) {
				if (reason != CCReason.WpfPreview) print.it($"Failed to compile '{f.Name}'. {ex}");
			}
			finally {
				aFinally?.Invoke();
			}
			
			cache.Remove(f, false);
			return false;
		}
	}
	
	/// <summary>_Compile() output assembly info.</summary>
	public record CompResults {
		/// <summary>C# file name without ".cs".</summary>
		public string name;
		
		/// <summary>Full path of assembly file.</summary>
		public string file;
		
		public MCRole role;
		public MCIfRunning ifRunning;
		public MCUac uac;
		public MiniProgram_.MPFlags flags;
		public MCPlatform platform;
		
		/// <summary>The assembly is normal .exe or .dll file, not in cache. If exe, its dependencies were copied to its directory.</summary>
		public bool notInCache;
		
		/// <summary>May be null if not explicitly requested.</summary>
		public MetaComments meta;
	}
	
	MetaComments _meta;
	CSharpCompilation _compilation;
	Dictionary<string, string> _dr, _dn;
	string _tpa;
	
	bool _Compile(CCReason reason, FileNode f, out CompResults r, FileNode projFolder, out Action aFinally, Func<CanCompileArgs, bool> canCompile, MCFlags addMetaFlags) {
		//print.it("COMPILE");
		
		//var p1 = perf.local();
		r = new CompResults();
		aFinally = null;
		
		_meta = new((reason == CCReason.WpfPreview ? MCFlags.WpfPreview : MCFlags.PrintErrors) | addMetaFlags);
		if (!_meta.Parse(f, projFolder)) return false;
		var err = _meta.Errors;
		r.meta = _meta;
		//p1.Next('m');
		
		bool needOutputFiles = _meta.Role != MCRole.classFile;
		
		//if for run, don't compile if f role is classFile
		if (reason == CCReason.Run && !needOutputFiles) {
			r.role = MCRole.classFile;
			return false;
		}
		
		XCompiled cache = XCompiled.OfWorkspace;
		string outPath = null, outFile = null, fileName = null;
		bool notInCache = false;
		if (needOutputFiles) {
			if (notInCache = _meta.OutputPath != null) {
				outPath = _meta.OutputPath;
				fileName = _meta.Name + ".dll";
			} else {
				outPath = cache.CacheDirectory;
				if (reason == CCReason.WpfPreview) fileName = "WPFpreview.dll";
				else fileName = f.IdString + ".dll";
				//note: must have ".dll", else somehow don't work GetModuleHandle, Process.GetCurrentProcess().Modules etc
			}
			outFile = outPath + "\\" + fileName;
			filesystem.createDirectory(outPath);
		}
		
		if (_meta.PreBuild.f != null && !_RunPrePostBuildScript(false, outFile)) return false;
		
		var trees = CompilerUtil.CreateSyntaxTrees(_meta);
		//p1.Next('t');
		
		string asmName = _meta.Name;
		if (_meta.Role == MCRole.editorExtension) { //cannot load multiple assemblies with same name
			asmName = asmName + "|" + Guid.NewGuid().ToString();
			//use GUID, not counter, because may be loaded old assembly from cache with same counter value
		} else if (_meta.Role == MCRole.miniProgram) {
			//workaround for: coreclr_execute_assembly and even AssemblyLoadContext.Default.LoadFromAssemblyPath fail
			//	if asmName is the same as of a .NET etc assembly.
			//	It seems it at first ignores path and tries to find assembly by name.
			//	But be careful. It could break something. Eg with WPF resources use "pack:...~AssemblyName...".
			asmName = "~" + asmName;
		}
		
		if (_meta.TestInternal is string[] testInternal) {
			TestInternal.CompilerStart(asmName, testInternal);
			aFinally += TestInternal.CompilerEnd; //this func is called from try/catch/finally which calls aFinally
		}
		
		List<ResourceDescription> resMan = null;
		if (needOutputFiles) { //before creating compilation. May modify trees[] elements.
			resMan = _CreateManagedResources(asmName, trees);
			if (err.ErrorCount != 0) { err.PrintAll(); return false; }
			//p1.Next('y');
		}
		
		var cOpt = _meta.CreateCompilationOptions();
		_compilation = CSharpCompilation.Create(asmName, trees, _meta.References.Refs, cOpt);
		//p1.Next('c');
		
		if (canCompile != null && !canCompile(new(_meta, trees, _compilation))) return false;
		
		string xdFile = null;
		Stream xdStream = null;
		Stream resNat = null;
		EmitOptions eOpt = null;
		
		if (needOutputFiles) {
			r.flags |= _AddAttributesEtc();
			//p1.Next('a');
			
			//rejected: if empty script, add {} to avoid error "no Main". See AddErrorOrWarning.
			
			//Create debug info always. It is used for run-time error links.
			//Embed it in assembly. It adds < 1 KB. Almost the same compiling speed. Same loading speed.
			//Don't use classic pdb file. It is 14 KB, 2 times slower compiling, slower loading; error with .NET Core: Unexpected error writing debug information -- 'The version of Windows PDB writer is older than required: 'diasymreader.dll''.
			//#if DEBUG //temp test debugger with non-user-code dll
			//			if (!(_meta.Role == MCRole.classLibrary && (_meta.Optimize || _meta.Name == "Au")))
			//#endif
			eOpt = new EmitOptions(debugInformationFormat: DebugInformationFormat.Embedded);
			
			if (_meta.XmlDoc) //allowed if role is classLibrary or exeProgram, but in Properties hidden if exeProgram (why could need it?)
				xdStream = filesystem.waitIfLocked(() => File.Create(xdFile = outPath + "\\" + _meta.Name + ".xml"));
			
			resNat = _CreateNativeResources();
			if (err.ErrorCount != 0) { err.PrintAll(); return false; }
			
			//EmbeddedText.FromX //it seems we can embed source code in PDB. Not tested.
		}
		
		//p1.Next();
		var asmStream = new MemoryStream(20_000);
		var emitResult = _compilation.Emit(asmStream, null, xdStream, resNat, resMan, eOpt);
		
		if (needOutputFiles) {
			xdStream?.Dispose();
			resNat?.Dispose(); //info: compiler disposes resMan
		}
		//p1.Next('e');
		
		if (reason != CCReason.WpfPreview) {
			var diag = emitResult.Diagnostics;
			if (!diag.IsDefaultOrEmpty) {
				foreach (var d in diag) {
					if (d.Severity == DiagnosticSeverity.Hidden) continue;
					err.AddErrorOrWarning(d, f);
					if (d.Severity == DiagnosticSeverity.Error && d.Id == "CS0009") MetaReferences.RemoveBadRefFromCache(d.GetMessage());
				}
				err.PrintAll();
			}
		}
		if (!emitResult.Success) {
			if (needOutputFiles) {
				Api.DeleteFile(outFile);
				if (xdFile != null) Api.DeleteFile(xdFile);
			}
			return false;
		}
		
		if (needOutputFiles) {
			if (_meta.Role == MCRole.miniProgram) {
				//is Main with [MTAThread]? Default STA, even if Main without [STAThread].
				//FUTURE: C# ?? [assembly: MTAThread]
				if (_compilation.GetEntryPoint(default)?.GetAttributes().Any(o => o.ToString() == "System.MTAThreadAttribute") ?? false) r.flags |= MiniProgram_.MPFlags.MTA;
				
				if (_meta.Console) r.flags |= MiniProgram_.MPFlags.Console;
			}
			
			//create assembly file
			//p1.Next();
			gSave:
			var hf = Api.CreateFile(outFile, Api.GENERIC_WRITE, 0, Api.CREATE_ALWAYS);
			if (hf.Is0) {
				var ec = lastError.code;
				if (ec == Api.ERROR_SHARING_VIOLATION && _RenameLockedFile(outFile, notInCache: notInCache)) goto gSave;
				throw new AuException(ec, outFile);
			}
			var b = asmStream.GetBuffer();
			
			using (hf) if (!Api.WriteFile2(hf, b.AsSpan(0, (int)asmStream.Length), out _)) throw new AuException(0);
			//saving would be fast, but with AV can take half of time.
			//	With WD now fast, but used to be slow. Now on save WD scans async, and on load scans only if still not scanned, eg if loading soon after saving.
			//	With Avast now the same as with WD.
			//p1.Next('s');
			r.file = outFile;
			
			if (_meta.Role == MCRole.exeProgram) {
				_GetDllPaths();
				
				var need = _NeedNativeExeAndDllFilesOfPlatforms();
				
				//copy app host template exe, add native resources, set assembly name, set console flag if need
				if (need.x64) _AppHost(outFile, fileName, MCPlatform.x64);
				if (need.arm64) _AppHost(outFile, fileName, MCPlatform.arm64);
				if (need.x86) _AppHost(outFile, fileName, MCPlatform.x86);
				//p1.Next('h'); //very slow with AV. Eg with WD this part makes whole compilation several times slower.
				
				//copy dlls to the output directory
				_CopyDlls(asmStream, need64: need.x64, needArm: need.arm64, need32: need.x86);
				//p1.Next('d');
			}
			
			if (!_meta.Console && _meta.Role is MCRole.miniProgram or MCRole.exeProgram && !addMetaFlags.Has(MCFlags.Publish)) {
				//if using assembly System.Console, let it redirect Console.Write etc to print.it, and Console.ReadLine to dialog.showInput.
				//	Don't redirect always, it's slow.
				//Speed of this code: 50 mcs.
				asmStream.Position = 0;
				using var pr = new PEReader(asmStream, PEStreamOptions.LeaveOpen);
				var mr = pr.GetMetadataReader();
				foreach (var handle in mr.AssemblyReferences) {
					var name = mr.GetString(mr.GetAssemblyReference(handle).Name);
					if (name == "System.Console") { r.flags |= MiniProgram_.MPFlags.RedirectConsole; break; }
				}
			}
		}
		
		if (_meta.PostBuild.f != null && !_RunPrePostBuildScript(true, outFile)) return false;
		
		if (_meta.StartFaster) r.flags |= MiniProgram_.MPFlags.Preloaded;
		
		if (reason != CCReason.WpfPreview && !addMetaFlags.Has(MCFlags.Publish)) {
			if (needOutputFiles) {
				cache.AddCompiled(f, outFile, _meta, r.flags);
				
				if (_meta.Role == MCRole.classLibrary) {
					MetaReferences.UncacheOldFiles();
					if (MetaReferences.IsDefaultRef(_meta.Name)
						&& _meta.References.Refs.Any(o => _meta.Name.Eqi(o.Display.Contains('\\') ? pathname.getNameNoExt(o.Display) : o.Display))) //may be removed with meta noRef
						print.warning($"Library name '{_meta.Name}' should not be used. Rename the C# file.", -1);
				}
				
				if (notInCache) print.it($"<>Compiled {f.SciLink()} -> <explore>{outFile}<>");
			}
			
			if (App.Settings.comp_printCompiled != false && !notInCache)
				if (App.Settings.comp_printCompiled == true || reason == CCReason.CompileAlways)
					print.it($"<>Compiled {f.SciLink()}");
		}
		
		r.name = _meta.Name;
		r.role = _meta.Role;
		r.ifRunning = _meta.IfRunning;
		r.uac = _meta.Uac;
		r.platform = _meta.Platform;
		r.notInCache = notInCache;
		
		//#if DEBUG
		//p1.NW('C');
		//#endif
		//print.it($"<><c red>compiled<> {f}");
		return true;
		
		//TODO3: rebuild if missing apphost. Now rebuilds only if missing dll.
	}
	
	/// <summary>
	/// Adds some module/assembly attributes. Also adds module initializer for role exeProgram.
	/// </summary>
	MiniProgram_.MPFlags _AddAttributesEtc() {
		MiniProgram_.MPFlags rflags = 0;
		//bool needDefaultCharset = true;
		//foreach (var v in _compilation.SourceModule.GetAttributes()) {
		//	//print.it(v.AttributeClass.Name);
		//	if (v.AttributeClass.Name == "DefaultCharSetAttribute") { needDefaultCharset = false; break; }
		//}
		bool needTargetFramework = false, needAssemblyTitle = false;
		if (_meta.Role is MCRole.exeProgram or MCRole.classLibrary or MCRole.miniProgram) {
			needTargetFramework = true; //for AppContext.TargetFrameworkName, else it will return null
			needAssemblyTitle = _meta.Role is MCRole.exeProgram or MCRole.classLibrary; //displayed in various system UI as program description (else empty)
			foreach (var v in _compilation.Assembly.GetAttributes()) {
				//print.it(v.AttributeClass.Name);
				switch (v.AttributeClass.Name) {
				case "TargetFrameworkAttribute": needTargetFramework = false; break;
				case "AssemblyTitleAttribute": needAssemblyTitle = false; break;
				}
			}
		}
		
		using (new StringBuilder_(out var sb)) {
			//sb.AppendLine("using System.Reflection;using System.Runtime.InteropServices;");
			
			//rejected. Now in global.cs, #if !NO_DEFAULT_CHARSET_UNICODE
			//if (needDefaultCharset) sb.AppendLine("[module: System.Runtime.InteropServices.DefaultCharSet(System.Runtime.InteropServices.CharSet.Unicode)]");
			
			if (needTargetFramework) sb.AppendLine($"[assembly: System.Runtime.Versioning.TargetFramework(\"{AppContext.TargetFrameworkName}\")]");
			if (needAssemblyTitle) sb.AppendLine($"[assembly: System.Reflection.AssemblyTitle(\"{_meta.Name}\")]");
			
			if (_meta.Role is MCRole.miniProgram or MCRole.editorExtension) {
				_GetDllPaths();
				if (_dr != null) { //add RefPaths attribute to resolve paths of managed dlls at run time
					foreach (var v in _dr) {
						sb.Append(rflags.Has(MiniProgram_.MPFlags.RefPaths) ? "|" : $"[assembly: Au.Types.RefPaths(@\"");
						sb.Append(v.Value);
						rflags |= MiniProgram_.MPFlags.RefPaths;
					}
					sb.AppendLine("\")]");
				}
				if (_dn != null) { //add NativePaths attribute to resolve paths of native dlls at run time
					foreach (var v in _dn) {
						sb.Append(rflags.Has(MiniProgram_.MPFlags.NativePaths) ? "|" : $"[assembly: Au.Types.NativePaths(@\"");
						sb.Append(v.Value);
						rflags |= MiniProgram_.MPFlags.NativePaths;
					}
					sb.AppendLine("\")]");
				}
			}
			
			if (_meta.TestInternal != null) {
				//https://www.strathweb.com/2018/10/no-internalvisibleto-no-problem-bypassing-c-visibility-rules-with-roslyn/
				//IgnoresAccessChecksToAttribute is defined in Au assembly.
				//	Could define here, but then warning "already defined in assembly X" when compiling 2 projects (meta pr) with that attribute.
				//	never mind: Au.dll must exist by the compiled assembly, even if not used for other purposes.
				foreach (var v in _meta.TestInternal) sb.AppendLine($"[assembly: System.Runtime.CompilerServices.IgnoresAccessChecksTo(\"{v}\")]");
				//sb.Append(@"
				//namespace System.Runtime.CompilerServices {
				//[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
				//public class IgnoresAccessChecksToAttribute : Attribute {
				//	public IgnoresAccessChecksToAttribute(string assemblyName) { AssemblyName = assemblyName; }
				//	public string AssemblyName { get; }
				//}}");
			}
			
			var fm = _meta.MainFile.f;
			sb.AppendLine($"[assembly: Au.Types.PathInWorkspace(@\"{fm.ItemPath}\", @\"{fm.FilePath}\")]");
			if (_meta.Role == MCRole.exeProgram) {
				sb.AppendLine(@"class ModuleInit__ { [System.Runtime.CompilerServices.ModuleInitializer] internal static void Init() { Au.script.AppModuleInit_(auCompiler: true); }}");
			}
			
			string code = sb.ToString(); //print.it(code);
			var tree = CSharpSyntaxTree.ParseText(code, new CSharpParseOptions(LanguageVersion.Preview)) as CSharpSyntaxTree;
			//insert as first, else user's module initializers would run before. Same speed.
			//_compilation = _compilation.AddSyntaxTrees(tree);
			_compilation = _compilation.RemoveAllSyntaxTrees().AddSyntaxTrees(_compilation.SyntaxTrees.Insert(0, tree));
		}
		return rflags;
	}
	
	//Gets paths of used managed and unmanaged dlls (meta nuget, r, com, pr).
	//Sets: _dr - managed dlls, _dn - other dlls. If compiling exeProgram, _dn also contains other files from nuget.
	//	Full paths are in dictionary values. Keys contain filenames or nuget relative paths, and for callers almost not useful.
	//Called when:
	//	Compiling exeProgram. The files will be copied to the output.
	//	Compiling miniProgram or editorExtension. Dll paths will be added to an assembly attribute. At run time will use it to find dlls.
	//Depending on meta properties, filters out unused dlls, eg 32-bit or dlls for other OS versions.
	void _GetDllPaths() {
		Dictionary<string, string> dr = null, dn = null, dr2 = null; //managed, native
		HashSet<FileNode> noDup = null;
		
		_Project(_meta);
		
		void _Project(MetaComments m) {
			if (m != _meta) if (!(noDup ??= new()).Add(m.MainFile.f)) return; //skip duplicates
			
			//managed dlls, except com and nuget
			{
				var refs = m.References.Refs;
				for (int k = m.References.DefaultRefCount; k < refs.Count; k++) {
					if (refs[k].Properties.EmbedInteropTypes || MetaReferences.IsNuget(refs[k])) continue; //com or nuget
					
					if (m.References.NoCopyRefs is { } ncr && _meta.Role == MCRole.exeProgram) {
						if(ncr.Contains(refs[k])) continue;
					}
					
					var path = refs[k].FilePath;
					_Add(ref dr, pathname.getName(path), path);
					
					//add managed dlls used by that dll but not specified in meta
					_Deps(path);
					void _Deps(string path) {
						string dir = null;
						using var peReader = new PEReader(filesystem.loadStream(path));
						var mr = peReader.GetMetadataReader();
						foreach (var arh in mr.AssemblyReferences) {
							var ar = mr.GetAssemblyReference(arh);
							var an = mr.GetString(ar.Name);
							if (MetaReferences.IsDefaultRef(an)) continue;
							if (dr2?.ContainsKey(an) ?? false) continue;
							dir ??= pathname.getDirectory(path, withSeparator: true);
							var path2 = dir + an + ".dll";
							if (!filesystem.exists(path2, useRawPath: true).File) continue;
							(dr2 ??= new()).Add(an, path2);
							_Deps(path2);
						}
					}
				}
			}
			
			//managed and native dlls from nuget. If exeProgram, also non-dll files.
			if (m.NugetXmlRoot is XElement xn) {
				foreach (var (package, _) in m.NugetPackages) {
					var xp = xn.Elem("package", "path", package, true);
					if (xp != null) {
						var dir = App.Model.NugetDirectoryBS + pathname.getDirectory(package);
						if (xp.Attr(out int format, "format")) {
							foreach (var f in xp.Elements()) {
								switch (f.Name.LocalName) { //see DNuget._Build
								case "r" or "rt":
									_Add2(ref dr, f.Value);
									break;
								case "native":
									_Add2(ref dn, f.Value);
									break;
								case "group":
									_AddGroup(f, false);
									break;
								case "natives":
									_AddGroup(f, true);
									break;
								case "other" when _meta.Role == MCRole.exeProgram:
									//copy all other files. Except XML doc, they are not in nuget.xml.
									_Add2(ref dn, f.Value, isDll: false);
									break;
								}
							}
							
							void _AddGroup(XElement x, bool native) {
								ref var d = ref (native ? ref dn : ref dr);
								
								int verPC = osVersion.minWin10 ? 100 : osVersion.minWin8_1 ? 81 : osVersion.minWin8 ? 80 : 70; //don't need Win11
								int verBest = -1;
								
								var need = _NeedNativeExeAndDllFilesOfPlatforms();
								
								string sBest = null;
								foreach (var f in x.Elements(native ? "native" : "rt")) {
									string s = f.Value; //like \runtimes\win\..., \runtimes\win-x64\..., \runtimes\win10-x64\...
									int i = 13, verDll = 0;
									if (s[i] != '-') verDll = s.ToInt(i, out i);
									
									if (i > 0 && s[i] == '-') {
										if (!need.x64 && s.Eq(i, @"-x64\", true)) continue;
										if (!need.arm64 && s.Eq(i, @"-arm64\", true)) continue;
										if (!need.x86 && s.Eq(i, @"-x86\", true)) continue;
									}
									
									if (_meta.Role == MCRole.exeProgram) {
										_Add2(ref d, s); //will select at run time
									} else {
										if (verDll != 81) verDll *= 10;
										if (verDll > verPC) continue;
										if (verDll > verBest) {
											verBest = verDll;
											sBest = s;
										}
									}
								}
								
								if (sBest != null) {
									_Add2(ref d, sBest);
								}
							}
						} else {
							//old format (the very first)
							throw new FileFormatException($"Please reinstall NuGet package '{package}'.");
						}
						
						void _Add2(ref Dictionary<string, string> d, string s, bool isDll = true)
							=> _Add(ref d, s, dir + s, isDll);
					}
				}
			}
			
			//unmanaged dlls specified in meta file
			if (m.OtherFiles != null && _meta.Role != MCRole.exeProgram) {
				foreach (var v in m.OtherFiles) {
					if (v.f.IsFolder) {
						foreach (var des in v.f.Descendants()) if (!des.IsFolder) _AddOther(des);
					} else {
						_AddOther(v.f);
					}
				}
				
				void _AddOther(FileNode f) {
					var path = f.FilePath;
					if (!path.Ends(".dll", true)) return;
					dn ??= new(StringComparer.OrdinalIgnoreCase);
					dn.TryAdd(path, path);
				}
			}
			
			if (m.ProjectReferences is { } pr)
				foreach (var v in pr) _Project(v.m);
		}
		
		void _Add(ref Dictionary<string, string> d, string s, string path, bool isDll = true) {
			if (isDll && _meta.Role == MCRole.exeProgram && _meta.Name.Eqi(pathname.getNameNoExt(s)))
				throw new InvalidOperationException($@"The program uses a dll file with the same name. Rename C# file {_meta.Name}");
			
			d ??= new(StringComparer.OrdinalIgnoreCase);
			if (d.TryAdd(s, path)) return;
			var existing = d[s]; if (existing.Eqi(path)) return;
			Debug_.Print($"compares file data of '{path}' and '{existing}'");
			if (filesystem.loadBytes(existing).AsSpan().SequenceEqual(filesystem.loadBytes(path))) return;
			
			throw new InvalidOperationException($@"Two different versions of file:
	{existing}
	{path}");
		}
		
		if (dr2 != null) {
			foreach (var (k, v) in dr2) {
				_Add(ref dr, k + ".dll", v);
			}
		}
		
		//print.it("dr");
		//print.it(dr);
		//print.it("dn");
		//print.it(dn);
		
		if (_meta.Role == MCRole.exeProgram) {
			_tpa = _GetDefaultTPA();
			if (dr != null) {
				//remove replaced defaults. Rare.
				foreach (var v in dr.Keys) {
					var fn = pathname.getNameNoExt(v);
					int i = _tpa.Find_(fn, static (s, from, to) => s[from - 1] == '|' && (to == s.Length || s[to] == '|'), true);
					if (i > 0) _tpa = _tpa.Remove(i - 1, fn.Length + 1);
				}
				
				StringBuilder b = null;
				foreach (var v in dr.Keys) {
					if (v.Starts(@"\runtimes\", true)) continue; //managed by ResolveNugetRuntimes_, because difficult in C++
					b ??= new(_tpa);
					int bs = v[0] == '\\' ? 1 : 0;
					b.Append('|').Append(v, bs, v.Length - 4 - bs);
				}
				if (b != null) _tpa = b.ToString();
			}
		}
		
		_dr = dr;
		_dn = dn;
	}
	
	static string _GetDefaultTPA() {
		if (s_sDefTPA == null) {
			var s = _NativeResources.LoadNativeResourceUtf8String_(220, 1);
			int i = s.LastIndexOf("|Au|") + 3; //remove Au.Controls etc
			s_sDefTPA = s[..i];
		}
		return s_sDefTPA;
	}
	static string s_sDefTPA;
	
	List<ResourceDescription> _CreateManagedResources(string asmName, CSharpSyntaxTree[] trees) {
		List<ResourceDescription> R = null;
		if (CompilerUtil.CreateManagedResources(_meta, asmName, trees, _ResourceException, o => { (R ??= new()).Add(new ResourceDescription(o.name, () => o.stream, true)); })) return R;
		return null;
	}
	
	void _ResourceException(Exception e, FileNode curFile) {
		var em = e.ToStringWithoutStack();
		var err = _meta.Errors;
		var f = _meta.MainFile.f;
		if (curFile == null) err.AddError(f, "Failed to add resources. " + em);
		else err.AddError(f, $"Failed to add resource '{curFile.Name}'. " + em);
	}
	
	Stream _CreateNativeResources() {
#if true
		if (_meta.Role is MCRole.exeProgram or MCRole.classLibrary) //add only version. If exe, will add icon and manifest to apphost exe. //rejected: support adding icons to dll; VS allows it.
			return _compilation.CreateDefaultWin32Resources(versionResource: true, noManifest: true, null, null);
		
		if (_meta.IconFile != null) { //add only icon. No version, no manifest.
			Stream icoStream = null;
			FileNode curFile = null;
			try {
				//if(_meta.ResFile != null) return File.OpenRead((curFile = _meta.ResFile).FilePath);
				icoStream = File.OpenRead((curFile = _meta.IconFile).FilePath);
				curFile = null;
				return _compilation.CreateDefaultWin32Resources(versionResource: false, noManifest: true, null, icoStream);
			}
			catch (Exception e) {
				icoStream?.Dispose();
				_ResourceException(e, curFile);
			}
		} else if (_GetMainFileIcon(out var stream)) {
			return _compilation.CreateDefaultWin32Resources(versionResource: false, noManifest: true, null, stream);
		}
		
		return null;
#else
			var manifest = _meta.ManifestFile;

			string manifestPath = null;
			if(manifest != null) manifestPath = manifest.FilePath;
			else if(_meta.Role == MetaRole.exeProgram /*&& _meta.ResFile == null*/) manifestPath = folders.ThisAppBS + "default.exe.manifest"; //don't: uac

			Stream manStream = null, icoStream = null;
			FileNode curFile = null;
			try {
				//if(_meta.ResFile != null) return File.OpenRead((curFile = _meta.ResFile).FilePath);
				if(manifestPath != null) { curFile = manifest; manStream = File.OpenRead(manifestPath); }
				if(_meta.IconFile != null) icoStream = File.OpenRead((curFile = _meta.IconFile).FilePath);
				curFile = null;
				return _compilation.CreateDefaultWin32Resources(versionResource: true, noManifest: manifestPath == null, manStream, icoStream);
			}
			catch(Exception e) {
				manStream?.Dispose();
				icoStream?.Dispose();
				_ResourceException(e, curFile);
				return null;
			}
#endif
	}
	
	string _AppHost(string outFile, string fileName, MCPlatform platform) {
		//A .NET Core+ exe actually is a managed dll hosted by a native exe file known as apphost.
		//When creating an exe, VS copies template apphost from "C:\Program Files\dotnet\sdk\version\AppHostTemplate\apphost.exe"
		//	and modifies it, eg copies native resources from the dll.
		//We have own apphost exe created by the Au.AppHost project. This function copies it and modifies in a similar way like VS does.
		
		//var p1 = perf.local();
		string exeFile = DllNameToExeName(outFile, platform != _meta.Platform ? platform : default);
		
		if (filesystem.exists(exeFile) && !Api.DeleteFile(exeFile)) {
			var ec = lastError.code;
			if (!(ec == Api.ERROR_ACCESS_DENIED && _RenameLockedFile(exeFile, notInCache: true))) throw new AuException(ec);
		}
		
		//delete old "program-64.exe" if now x64, or "program-arm.exe" if now arm64. It may exist if user switched meta platform x64/arm64.
		if (platform is MCPlatform.x64 or MCPlatform.arm64) Api.DeleteFile(exeFile.Insert(^4, platform is MCPlatform.x64 ? "-64" : "-arm"));
		
		var appHost = folders.ThisAppBS + platform switch { MCPlatform.x86 => "32", MCPlatform.arm64 => @"64\ARM", _ => "64" } + @"\Au.AppHost.exe";
		bool done = false;
		try {
			var b = File.ReadAllBytes(appHost);
			//p1.Next();
			//write assembly name in placeholder memory. In AppHost.cpp: char s_asmName[800] = "\0hi7yl8kJNk+gqwTDFi7ekQ";
			int i = b.AsSpan().IndexOf("hi7yl8kJNk+gqwTDFi7ekQ"u8) - 1;
			i += Encoding.UTF8.GetBytes(fileName, 0, fileName.Length, b, i);
			b[i] = 0;
			
			var res = new _NativeResources();
			if (_meta.IconFile != null) {
				_NativeResources.ICONCONTEXT ic = default;
				if (_meta.IconFile.IsFolder) {
					foreach (var des in _meta.IconFile.Descendants()) {
						if (des.IsFolder) continue;
						if (des.Name.Ends(".ico", true)) {
							res.AddIcon(des.FilePath, ref ic);
						} else if (des.Name.Ends(".xaml", true)) {
							_GetIconFromXaml(filesystem.loadText(des.FilePath), out var stream);
							res.AddIcon(stream.ToArray(), ref ic);
						}
					}
				} else {
					res.AddIcon(_meta.IconFile.FilePath, ref ic);
				}
			} else if (_GetMainFileIcon(out var stream)) {
				_NativeResources.ICONCONTEXT ic = default;
				res.AddIcon(stream.ToArray(), ref ic);
			}
			res.AddVersion(outFile);
			res.AddTpa(_tpa);
			
			string manifest = null;
			if (_meta.ManifestFile != null) manifest = _meta.ManifestFile.FilePath;
			else if (_meta.Role == MCRole.exeProgram) manifest = folders.ThisAppBS + "default.exe.manifest"; //don't: uac
			if (manifest != null) res.AddManifest(manifest);
			
			res.WriteAll(exeFile, b, platform, _meta.Console);
			
			//speed: AV makes this slooow.
			//p1.NW();
			done = true;
		}
		finally { if (!done) Api.DeleteFile(exeFile); }
		
		return exeFile;
	}
	
	bool _GetMainFileIcon(out MemoryStream ms) {
		try {
			if (DIcons.TryGetIconFromDB(_meta.MainFile.f.CustomIconName, out string xaml)) {
				_GetIconFromXaml(xaml, out ms);
				return true;
			}
		}
		catch (Exception e1) { _ResourceException(e1, null); }
		ms = null;
		return false;
	}
	
	static void _GetIconFromXaml(string xaml, out MemoryStream ms) {
		ms = new MemoryStream();
		var e = ImageUtil.LoadWpfImageElement(xaml);
		ImageUtil.ConvertWpfImageElementToIcon_(ms, e, [16, 24, 32, 48, 64]);
		ms.Position = 0;
	}
	
	void _CopyDlls(Stream asmStream, bool need64, bool needArm, bool need32) {
		asmStream.Position = 0;
		
		//note: need Au.dll and AuCpp.dll even if not used in code. Au.dll contains script.AppModuleInit_.
		CompilerUtil.CopyFileIfNeed(folders.ThisAppBS + @"Au.dll", _meta.OutputPath + @"\Au.dll");
		//note: always need all AuCpp.dll and Au.DllHost.exe, because maybe elm will have to load AuCpp.dll into other processes.
		CompilerUtil.CopyFileIfNeed(folders.ThisAppBS + @"64\AuCpp.dll", _meta.OutputPath + @"\64\AuCpp.dll");
		CompilerUtil.CopyFileIfNeed(folders.ThisAppBS + @"64\Au.DllHost.exe", _meta.OutputPath + @"\64\Au.DllHost.exe");
		CompilerUtil.CopyFileIfNeed(folders.ThisAppBS + @"32\AuCpp.dll", _meta.OutputPath + @"\32\AuCpp.dll");
		CompilerUtil.CopyFileIfNeed(folders.ThisAppBS + @"32\Au.DllHost.exe", _meta.OutputPath + @"\32\Au.DllHost.exe");
		CompilerUtil.CopyFileIfNeed(folders.ThisAppBS + @"64\ARM\AuCpp.dll", _meta.OutputPath + @"\64\ARM\AuCpp.dll");
		CompilerUtil.CopyFileIfNeed(folders.ThisAppBS + @"64\ARM\Au.DllHost.exe", _meta.OutputPath + @"\64\ARM\Au.DllHost.exe");
		
		//bool usesSqlite = CompilerUtil.UsesSqlite(asmStream);
		
		//copy managed dlls, including from nuget
		if (_dr != null) {
			foreach (var v in _dr) {
				CompilerUtil.CopyFileIfNeed(v.Value, _meta.OutputPath + "\\" + v.Key);
				
				//if (!usesSqlite && !v.Value.Starts(App.Model.NugetDirectoryBS)) usesSqlite = CompilerUtil.UsesSqlite(v.Value);
			}
		}
		
		//copy other files from nuget
		if (_dn != null) {
			foreach (var v in _dn) {
				CompilerUtil.CopyFileIfNeed(v.Value, _meta.OutputPath + v.Key);
			}
		}
		
		////print.it(usesSqlite);
		//if (usesSqlite) {
		//	if (need64) CompilerUtil.CopyFileIfNeed(folders.ThisAppBS + @"64\sqlite3.dll", _meta.OutputPath + @"\64\sqlite3.dll");
		//	if (needArm) CompilerUtil.CopyFileIfNeed(folders.ThisAppBS + @"64\ARM\sqlite3.dll", _meta.OutputPath + @"\64\ARM\sqlite3.dll");
		//	if (need32) CompilerUtil.CopyFileIfNeed(folders.ThisAppBS + @"32\sqlite3.dll", _meta.OutputPath + @"\32\sqlite3.dll");
		//}
		
		//copy meta 'file' files
		CompilerUtil.CopyMetaFileFilesOfAllProjects(_meta, _meta.OutputPath);
	}
	
	bool _RunPrePostBuildScript(bool post, string outFile) {
		if (_meta.Role == MCRole.exeProgram) outFile = DllNameToExeName(outFile, default);
		return CompilerUtil.RunPrePostBuildScript(_meta, post, outFile, false);
	}
	
	/// <summary>
	/// Replaces ".dll" with ".exe" (if Default) or "-32.exe" or "-64.exe" or "-arm.exe".
	/// </summary>
	public static string DllNameToExeName(string dll, MCPlatform platform)
		=> dll.ReplaceAt(^4.., platform switch { MCPlatform.x64 => "-64.exe", MCPlatform.arm64 => "-arm.exe", MCPlatform.x86 => "-32.exe", _ => ".exe" });
	
	(bool x64, bool arm64, bool x86) _NeedNativeExeAndDllFilesOfPlatforms() {
		if (_meta.Role == MCRole.exeProgram) {
			if (_meta.Platform == MCPlatform.x86) return (false, false, true);
			if (_meta.Optimize) return (true, true, false);
		}
		if (_meta.Platform == MCPlatform.arm64) return (false, true, false);
		return (true, false, false);
	}
	
	static bool _RenameLockedFile(string file, bool notInCache) {
		//If the assembly file is currently loaded, we get ERROR_SHARING_VIOLATION. But we can rename the file.
		//tested: can't rename if ERROR_USER_MAPPED_FILE or ERROR_LOCK_VIOLATION.
		string renamed = null;
		for (int i = 1; ; i++) {
			renamed = file + "'" + i.ToString();
			if (Api.MoveFileEx(file, renamed, 0)) goto g1;
			if (lastError.code != Api.ERROR_ALREADY_EXISTS) break;
			if (Api.MoveFileEx(file, renamed, Api.MOVEFILE_REPLACE_EXISTING)) goto g1;
		}
		return false;
		g1:
		if (notInCache) {
			if (s_renamedFiles == null) {
				s_renamedFiles = new List<string>();
				process.thisProcessExit += _ => _DeleteRenamedLockedFiles(null);
				s_rfTimer = new timer(_DeleteRenamedLockedFiles);
			}
			if (!s_rfTimer.IsRunning) s_rfTimer.Every(60_000);
			s_renamedFiles.Add(renamed);
		}
		return true;
	}
	static List<string> s_renamedFiles;
	static timer s_rfTimer;
	
	//TODO3: remove this? Probably fails anyway. Will delete when this app starts next time.
	static void _DeleteRenamedLockedFiles(timer timer) {
		var a = s_renamedFiles;
		for (int i = a.Count; --i >= 0;) {
			if (Api.DeleteFile(a[i]) || lastError.code == Api.ERROR_FILE_NOT_FOUND) a.RemoveAt(i);
		}
		if (a.Count == 0) timer?.Stop();
	}
	
	public static void Warmup(CAW::Microsoft.CodeAnalysis.Document document) {
		//using var p1 = perf.local();
		var compilation = document.Project.GetCompilationAsync().Result_();
		//compilation.GetDiagnostics(); //just makes Emit faster, and does not make the real GetDiagnostics faster first time
		//var eOpt = new EmitOptions(debugInformationFormat: DebugInformationFormat.Embedded);
		var asmStream = new MemoryStream(16000);
		compilation.Emit(asmStream);
		//compilation.Emit(asmStream, null, options: eOpt); //somehow makes slower later
		//compilation.Emit(asmStream, null, xdStream, resNat, resMan, eOpt);
	}
}

enum CCReason { Run, CompileAlways, CompileIfNeed, WpfPreview }

record CanCompileArgs(MetaComments m, CSharpSyntaxTree[] trees, CSharpCompilation compilation);


================================================
FILE: Au.Editor/Compiler/EditorExtension.cs
================================================
//#define STREAM
//#define TEST_STARTUP_SPEED
//#define TEST_UNLOAD

using System.Runtime.Loader;
using System.Windows;

using LA;

/// <summary>
/// Functions and events for scripts with role editorExtension.
/// The script must have this at the start <c>/*/ role editorExtension; r Au.Editor.dll; /*/</c>.
/// </summary>
public static class EditorExtension {
	/// <summary>
	/// Executes assembly in this thread.
	/// </summary>
	/// <param name="asmFile">Full path of assembly file.</param>
	/// <param name="args">To pass to Main.</param>
	/// <param name="handleExceptions">Handle/print exceptions.</param>
	internal static async void Run_(string asmFile, string[] args, bool handleExceptions) {
		try {
			//using var p1 = perf.local();
			
			_LoadedScriptAssembly lsa = default;
			var (asm, loaded) = lsa.Find(asmFile);
			if (asm == null) {
				var alc = new AssemblyLoadContext(null, isCollectible: true);
				//p1.Next();
				
#if STREAM
				//Uses LoadFromStream, not LoadFromAssemblyPath.
				//LoadFromAssemblyPath has this problem: does not reload modified assembly from same file.
				//	Need a dll file with unique name for each version of same script.
				//Note: the 'loaded' was intended to make faster in some cases. However cannot use it because of the xor.
				//tested: step-debugging works. Don't need the overload with pdb parameter.

				var b = File.ReadAllBytes(asmFile); //with WD ~7 ms, but ~25 ms without xor. With Avast ~7 ms regardless of xor. Both fast if already scanned.
				for (int i = 0; i < b.Length; i++) b[i] ^= 1; //prevented AV full dll scan twice. Now fully scans once (WD always scans when loading assembly from stream; Avast when loading from stream or earlier).
				using var stream = new MemoryStream(b, false);
				//p1.Next();
				asm = alc.LoadFromStream(stream); //with WD always 15-25 ms. With Avast it seems always fast.
#else
				//Uses LoadFromAssemblyPath. If LoadFromStream, no source file/line info in stack traces; also no Assembly.Location, and possibly more problems.
				//never mind: Creates and loads many dlls when edit-run many times.
				//tested: .NET unloads dlls, but later than Assembly objects, maybe after 1-2 minutes, randomly.
				
				if (loaded) {
					var s = asmFile.Insert(^4, "'" + perf.mcs.ToString()); //info: compiler will delete all files with "'" on first run after editor restart
#if true //copy file
					unsafe {
						if (!Api.CopyFileEx(asmFile, s, 0)) throw new AuException(0, "failed to copy assembly file");
					}
					//p1.Next('C');
					//bad: WD makes much slower. Scans 2 times. Avast scans faster, and only when copying.
					//never mind: compiler should create file with unique name, to avoid copying now. Probably would complicate too much, or even not possible.
					asm = alc.LoadFromAssemblyPath(s);
#else //rename file. Faster, but unreliable when need to run soon again. Then compiler would not find the file and compile again. Or the new file could be replaced with the old, etc.
					if (!Api.MoveFileEx(asmFile, s, 0)) throw new AuException(0, "failed to rename assembly file");
					p1.Next('C'); //WD does not scan when renaming
					asm = alc.LoadFromAssemblyPath(s);
					p1.Next('L');
					//now need to rename or copy back. Else would compile each time.
					//if (!Api.MoveFileEx(s, asmFile, 0)) throw new AuException(0, "failed to rename assembly file"); //works, but no stack trace
					Task.Run(() => { Api.CopyFileEx(s, asmFile, null, default, null, 0); }); //make compiler happy next time. Now let AV scan it async.
#endif
				} else {
					asm = alc.LoadFromAssemblyPath(asmFile);
				}
#endif
#if TEST_UNLOAD
				new _AssemblyDtor(asm);
#endif
				//p1.Next('L');
				
				lsa.Add(asmFile, asm);
				
				//this event will be here for editorExtension assemblies only.
				//	Libraries used by editorExtension scripts are loaded by AssemblyLoadContext.Default.
				//	Dlls used by meta pr libraries are resolved in app project -> _UnmanagedDll_Resolving.
				//	Don't need alc.Resolving here. Libraries are always loaded in default context.
				alc.ResolvingUnmanagedDll += (asm, name) => MiniProgram_.ResolveUnmanagedDllFromNativePathsAttribute_(name, asm);
			}
			
			var entryPoint = asm.EntryPoint ?? throw new InvalidOperationException("assembly without entry point (function Main)");
			
			//support async. Then EntryPoint returns some `void <Main>(string[])` that calls the true entry method and hangs.
			bool isAsync = false;
			if (entryPoint.IsSpecialName) {
				var ep2 = entryPoint.DeclaringType.GetMethods(BindingFlags.DeclaredOnly | BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static)
					.FirstOrDefault(static o => o.ReturnType is var rt && (rt == typeof(Task) || rt == typeof(Task<int>)) && o.Name is "<Main>$" or "Main" && o.GetParameters() is { } pa && (pa.Length == 0 || (pa.Length == 1 && pa[0].ParameterType == typeof(string[]))) && o.IsDefined(typeof(System.Runtime.CompilerServices.AsyncStateMachineAttribute)));
				if (isAsync = ep2 != null) entryPoint = ep2;
			}
			
			var epParams = entryPoint.GetParameters().Length != 0 ? new object[] { args ?? Array.Empty<string>() } : null;
			
			if (isAsync) {
				await (Task)entryPoint.Invoke(null, epParams);
			} else {
				entryPoint.Invoke(null, epParams);
			}
		}
		catch (Exception e1) when (handleExceptions) {
			print.it(e1 is TargetInvocationException te ? te.InnerException : e1);
		}
	}
	
	/// <summary>
	/// Remembers and finds script assemblies loaded in this process, to avoid loading the same unchanged assembly multiple times.
	/// </summary>
	struct _LoadedScriptAssembly {
		long _fileTime;
		
		[MethodImpl(MethodImplOptions.NoInlining)]
		public (Assembly asm, bool loaded) Find(string asmFile) {
			if (filesystem.GetTime_(asmFile, out var time)) {
				_fileTime = time;
				if (_d.TryGetValue(asmFile, out var x)) {
					bool modified = x.time != _fileTime;
					
					if (x.restarting != null) {
						var v = x.restarting; x.restarting = null;
						try { v(modified); }
						catch (Exception e1) { print.it(e1); }
					}
					
					if (!modified) return (x.asm, true);
					_d.Remove(asmFile);
					return (null, true);
				}
			}
			return default;
		}
		
		[MethodImpl(MethodImplOptions.NoInlining)]
		public void Add(string asmFile, Assembly asm) {
			if (_fileTime == default) return; //filesystem.getProperties failed
			_d.Add(asmFile, new _Asm { time = _fileTime, asm = asm });
			
			//foreach(var v in _d.Values) print.it(v.asm.FullName);
			//foreach(var v in AppDomain.CurrentDomain.GetAssemblies()) print.it(v.FullName);
		}
	}
	
	class _Asm {
		public long time;
		public Assembly asm;
		public Action<bool> restarting;
	}
	
	static readonly Dictionary<string, _Asm> _d = new(StringComparer.OrdinalIgnoreCase);
	
	static _Asm _FindAsmValue(Assembly asm) {
		foreach (var v in _d.Values) if (v.asm == asm) return v;
		throw new InvalidOperationException("This code must be in the script assembly");
	}
	
	/// <summary>
	/// When starting new instance of this script.
	/// </summary>
	/// <remarks>
	/// <para>The bool parameter is true if the script has been modified. It also means that the new instance will be a new assembly. If false, the new instance will be the same loaded assembly.</para>
	/// 
	/// <para>The event handler should end all activities of current instance: unsubscribe events, stop timers, end threads and other tasks, remove added UI elements, etc. Unless it supports multiple instances.</para>
	/// 
	/// <para>If the old instance does not end its activities properly when restarting, you may notice these problems:
	/// <br/>• Duplicate events, timers, etc.
	/// <br/>• Old assemblies never unloaded after restarting modified script. Usually such memory leaks aren't dangerous, but be aware of it. To avoid it, let the event handler ensure that the script is not leaving any GC roots, for example event handlers subscribed to external events, running timers, threads and other code that could still run in the future. If the assembly is rooted, GC cannot unload it.
	/// </para>
	/// <para>If the script has static fields, and the parameter is false, the new script will inherit their values. You may want to reset them.</para>
	/// 
	/// <para>When this event is raised, it is unsubscribed automatically. Don't need to unsubscribe.</para>
	/// </remarks>
	public static event Action<bool> Restarting {
		add { _FindAsmValue(Assembly.GetCallingAssembly()).restarting += value; }
		remove { _FindAsmValue(Assembly.GetCallingAssembly()).restarting -= value; }
	}
	
	/// <summary>
	/// When the main window loaded. If already loaded when adding the event handler, it is called now instead.
	/// </summary>
	/// <remarks>
	/// <para>Don't need to unsubscribe. The event can occur max 1 time in this process, and then is unsubscribed automatically.</para>
	/// 
	/// <para>If the program starts hidden (it can be set in Options), it does not create the main window until need to show it (eg clicked tray icon). While hidden, <see cref="App.Hmain"/> is <c>default(wnd)</c>; <see cref="App.Wmain"/> is not null, but its <b>IsLoaded</b> property returns false. The window is created the first time it must be shown, and then not closed until it's time to exit the process. If the program starts visible, the event handler is executed when trying to subscribe the event.</para>
	/// </remarks>
	public static event Action WindowLoaded {
		add {
			if (App.Loaded == AppState.LoadedUI) {
				_InvokeAction(value);
			} else if (App.Loaded < AppState.LoadedUI) {
				_windowLoaded += value;
			}
		}
		remove { _windowLoaded -= value; }
	}
	static Action _windowLoaded;
	
	internal static void WindowLoaded_() {
		var v = _windowLoaded; _windowLoaded = null;
		_InvokeAction(v);
	}
	
	static void _InvokeAction(Action a) {
		if (a == null) return;
		try { a(); }
		catch (Exception e1) { print.it(e1); }
	}
	
	/// <summary>
	/// When main window loaded and is ready for editing. If already ready when adding the event handler, it is called now instead.
	/// </summary>
	/// <remarks>
	/// Don't need to unsubscribe. The event can occur max 1 time in this process, and then is unsubscribed automatically.
	/// </remarks>
	public static event Action WindowReady {
		add { if (CodeInfo.IsReadyForEditing) _InvokeAction(value); else CodeInfo.ReadyForEditing += value; } //handles exceptions
		remove { CodeInfo.ReadyForEditing -= value; }
	}
	
	//note: cannot add event WindowCreated (before loaded, when still invisible). If editor starts visible, startup scripts run when it is already loaded/visible.
	
	/// <summary>
	/// When closing current workspace.
	/// </summary>
	/// <remarks>
	/// <para>The bool parameter is true on program exit, false when opening another workspace (or reopening this).</para>
	/// 
	/// <para>Everything is already saved. Documents in editor still not closed. Task processes still not ended.</para>
	/// 
	/// <para>When this event is raised, it is unsubscribed automatically. The script must unsubscribe only on <see cref="Restarting"/>.</para>
	/// </remarks>
	public static event Action<bool> ClosingWorkspace {
		add { _closingWorkspace += value; }
		remove { _closingWorkspace -= value; }
	}
	
	internal static void ClosingWorkspace_(bool onExit) {
		if (_closingWorkspace == null) return;
		var v = _closingWorkspace; _closingWorkspace = null;
		try { v(onExit); }
		catch (Exception e1) { dialog.showError("Exception in EditorExtension.ClosingWorkspace event handler", e1.ToString(), owner: App.Hmain.IsVisible ? App.Hmain : default, secondsTimeout: 5); }
		if (App.Loaded >= AppState.LoadedUI) App.Model.Save.AllNowIfNeed();
	}
	static Action<bool> _closingWorkspace;
	
#if TEST_UNLOAD
	//This shows that AssemblyLoadContext are unloaded on GC.
	class _AssemblyLoadContext : AssemblyLoadContext {
		public _AssemblyLoadContext(string name, bool isCollectible) : base(name, isCollectible) { }

		~_AssemblyLoadContext() { print.it("AssemblyLoadContext unloaded", Name); }

		//protected override Assembly Load(AssemblyName assemblyName) {
		//	//print.it("Load", assemblyName);
		//	return null;
		//}
	}

	//This shows that Assembly are unloaded on GC, although later than AssemblyLoadContext.
	//The dlls are unloaded even later, maybe after 1-2 minutes.
	class _AssemblyDtor {
		static readonly ConditionalWeakTable<Assembly, _AssemblyDtor> s_cwt = new();

		readonly string _file, _name;

		public _AssemblyDtor(Assembly a) {
			s_cwt.Add(a, this);
			_file = a.Location;
			_name = a.FullName.Split('|')[0];
		}

		~_AssemblyDtor() {
			print.it("Assembly unloaded", _name, _file);
			var s = _file;
			Task.Delay(120_000).ContinueWith(_ => { print.it(Api.DeleteFile(s)); });
		}

		//BAD: memory leak:
		//	First assembles never GC-collected after removing from _d (when starting a modified version of the script).
		//	Only if the assembly loaded at startup when app started hidden.
		//	Tested with VS tools: they don't have GC roots.
		//	It seems it's a .NET bug. Could not find a workaround.
		//	Never mind. It's a very small leak compared to WPF leaks.
		//	See also: https://learn.microsoft.com/en-us/dotnet/standard/assembly/unloadability?source=recommendations

		//public static void Test2() {
		//	print.it("-- _AssemblyDtor --");
		//	foreach(var v in s_cwt) {
		//		print.it(v.Key.Location);
		//	}
		//}
	}

	//public static void Test() {
	//	foreach (var v in _d) {
	//		print.it(v.Key, v.Value.asm.Location);
	//	}
	//	//_AssemblyDtor.Test2();
	//}
#endif
}


================================================
FILE: Au.Editor/Compiler/ErrBuilder.cs
================================================
using Microsoft.CodeAnalysis;

namespace LA;

/// <summary>Code errors text builder.</summary>
class ErrBuilder {
	StringBuilder _b;
	
	public int ErrorCount { get; private set; }
	public int WarningCount { get; private set; }
	
	public void Clear() {
		ErrorCount = 0; WarningCount = 0;
		_b = null;
	}
	
	/// <summary>
	/// Adds compiler error or warning message with a link that opens the C# file and goes to that position.
	/// </summary>
	/// <param name="d">Error or warning.</param>
	/// <param name="fMain">Main file of the compilation. Used only for failures that are not C# errors, eg when fails to open a metadata reference file.</param>
	/// <remarks>
	/// This and other AddX functions add line like "[C:\path\file.cs(line,column)]: message" or "[C:\path\file.cs]: message".
	/// Then our PrintServer.SetNotifications callback will convert the "[...]" part to a link.
	/// </remarks>
	public void AddErrorOrWarning(Diagnostic d, FileNode fMain) {
		_StartAdd(isWarning: d.Severity != DiagnosticSeverity.Error);
		var s = d.ToString();
		int i = d.Location.IsInSource ? s.Find("): ") + 1 : 0;
		if (i > 0) {
			_b.AppendFormat("[{0}]{1}", s[..i], s[i..]);
		} else {
			_b.AppendFormat("[{0}]: {1}", fMain.FilePath, s);
		}
		
		//if empty script, error "no Main". Users would not understand why.
		//	rejected: auto-add {} (empty block, to make the script not empty). Difficult to detect when need it. Eg would give an incorrect/unclear error if Main exists but is unsuitable.
		if (d.Severity == DiagnosticSeverity.Error && d.Id == "CS5001") _b.Append(". Or the script is empty.");
	}
	
	/// <summary>
	/// Adds error message with a link that opens the C# file but does not go to a position.
	/// </summary>
	public void AddError(FileNode f, string message) {
		_StartAdd();
		_b.AppendFormat("[{0}]: {1}", f.FilePath, message);
	}
	
	/// <summary>
	/// Adds error message with a link that opens the C# file and goes to the specified position.
	/// Used for meta errors.
	/// </summary>
	/// <param name="f">C# file.</param>
	/// <param name="code">f code.</param>
	/// <param name="pos">Position in code.</param>
	/// <param name="message">Text to append. Example: "error: message".</param>
	/// <param name="formatArgs">If not null/empty, calls StringBuilder.AppendFormat(message, formatArgs).</param>
	public void AddError(FileNode f, string code, int pos, string message, params object[] formatArgs) {
		_StartAdd();
		StringUtil.LineAndColumn(code, pos, out int line, out int col);
		_Append(f, line, col, message, formatArgs);
	}
	
	/// <summary>
	/// Adds error message with a link that opens the C# file and goes to the specified position.
	/// </summary>
	/// <param name="pos">Position in code.</param>
	/// <param name="message">Text to append. Example: "error: message".</param>
	/// <param name="formatArgs">If not null/empty, calls StringBuilder.AppendFormat(message, formatArgs).</param>
	public void AddError(FileNode f, Microsoft.CodeAnalysis.Text.LinePosition pos, string message, params object[] formatArgs) {
		_StartAdd();
		_Append(f, pos.Line, pos.Character, message, formatArgs);
	}
	
	void _StartAdd(bool isWarning = false) {
		if (_b == null) _b = new();
		else _b.AppendLine();
		
		if (isWarning) WarningCount++; else ErrorCount++;
	}
	
	void _Append(FileNode f, int line, int col, string message, params object[] formatArgs) {
		_Append(f.FilePath, line, col, message, formatArgs);
	}
	
	void _Append(string file, int line, int col, string message, params object[] formatArgs) {
		_b.AppendFormat("[{0}({1},{2})]: ", file, ++line, ++col);
		if ((formatArgs?.Length ?? 0) != 0) _b.AppendFormat(message, formatArgs); else _b.Append(message);
	}
	
	public override string ToString() => _b?.ToString();
	
	/// <summary>
	/// Prints all errors and warnings.
	/// Calls <see cref="Clear"/>.
	/// Does nothing if no errors and warnings.
	/// </summary>
	public void PrintAll() {
		if (_b == null) return;
		
		var s = ToString();
		_b.Clear();
		
		//header line
		_b.AppendFormat("<><lc #{0}>Compilation: ", ErrorCount != 0 ? "F0E080" : "A0E0A0");
		if (ErrorCount != 0) _b.Append(ErrorCount).Append(" errors").Append(WarningCount != 0 ? ", " : "");
		if (WarningCount != 0) _b.Append(WarningCount).Append(" warnings <fold>	Warnings can be disabled with <google>C# #pragma warning<> or in <b>Properties<>.</fold>");
		_b.AppendLine("<>");
		
		//errors and warnings
		_b.Append(s);
		
		print.it(_b.ToString());
		Clear();
	}
	
	//currently not used.
	///// <summary>
	///// If the SyntaxTree contains errors, prints them (<see cref="PrintAll"/>) and returns true.
	///// In any case, prints errors and warnings.
	///// </summary>
	///// <param name="tree"></param>
	///// <param name="f"></param>
	///// <param name="printWarnings">Add warnings too (but print only if error).</param>
	//public bool AddAllAndPrint(SyntaxTree tree, FileNode f, bool printWarnings = false)
	//{
	//	foreach(var v in tree.GetDiagnostics()) {
	//		if(v.Severity == DiagnosticSeverity.Error || printWarnings) AddErrorOrWarning(v, f);
	//	}
	//	if(ErrorCount == 0) return false;
	//	PrintAll();
	//	return true;
	//}
}


================================================
FILE: Au.Editor/Compiler/MetaComments.cs
================================================
using System.Xml.Linq;

using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;

//CONSIDER: c https://..../file.cs
//	Problem: security. These files could contain malicious code.
//	It seems nuget supports source files, not only compiled assemblies: https://stackoverflow.com/questions/52880687/how-to-share-source-code-via-nuget-packages-for-use-in-net-core-projects

namespace LA;

//This XML doc is outdated. Most info is in the Properties dialog.
/// <summary>
/// Extracts C# file/project settings, references, etc from meta comments in C# code.
/// </summary>
/// <remarks>
/// To compile C# code, often need various settings, more files, etc. In Visual Studio you can set it in project Properties and Solution Explorer. In Au you can set it in C# code as meta comments.
/// Meta comments is a block of comments that starts and ends with <c>/*/</c>. Must be at the start of C# code. Before can be only comments, empty lines, spaces and tabs. Example:
/// <code><![CDATA[
/// /*/ option1 value1; option2 value2; option2 value3 /*/
/// ]]></code>
/// Options and values must match case, except filenames/paths. No "enclosing", no escaping.
/// Some options can be several times with different values, for example to specify several references.
/// When compiling multiple files (project, or using option 'c'), only the main file can contain all options. Other files can contain only 'r', 'c', 'com', 'nuget', 'resource', 'file'.
/// All available options are in the examples below. Here a|b|c means a or b or c. The //comments are not allowed in real meta comments.
/// </remarks>
/// <example>
/// <h3>References</h3>
/// <code><![CDATA[
/// r Assembly //assembly reference. With or without ".dll". Must be in folders.ThisApp.
/// r C:\X\Y\Assembly.dll //assembly reference using full path. If relative path, must be in folders.ThisApp.
/// r Alias=Assembly //assembly reference that can be used with C# keyword 'extern alias'.
/// ]]></code>
/// Don't need to add Au.dll and .NET runtime assemblies.
/// 
/// <h3>Other C# files to compile together</h3>
/// <code><![CDATA[
/// c file.cs //a class file in this C# file's folder
/// c folder\file.cs //path relative to this C# file's folder
/// c .\folder\file.cs //the same as above
/// c ..\folder\file.cs //path relative to the parent folder
/// c \folder\file.cs //path relative to the workspace folder
/// ]]></code>
/// The file must be in this workspace. Or it can be a link (in workspace) to an external file. The same is true with most other options.
/// If folder, compiles all its descendant class files.
/// 
/// <h3>References to libraries created in this workspace</h3>
/// <code><![CDATA[
/// pr \folder\file.cs
/// ]]></code>
/// Compiles the .cs file or its project and uses the output dll file like with option r. It is like a "project reference" in Visual Studio.
/// 
/// <h3>References to COM interop assemblies (.NET assemblies converted from COM type libraries)</h3>
/// <code><![CDATA[
/// com Accessibility 1.1 44782f49.dll
/// ]]></code>
/// How this different from option r:
/// 1. If not full path, must be in @"%folders.Workspace%\.interop".
/// 2. The interop assembly is used only when compiling, not at run time. It contains only metadata, not code. The compiler copies used parts of metadata to the output assembly. The real code is in native COM dll, which at run time must be registered as COM component and must match the bitness (64-bit or 32-bit) of the process that uses it. 
/// 
/// <h3>Files to add to managed resources</h3>
/// <code><![CDATA[
/// resource file.png  //file as stream. Can be filename or relative path, like with 'c'.
/// resource file.ext /byte[]  //file as byte[]
/// resource file.txt /string  //text file as string
/// resource file.csv /strings  //CSV file containing multiple strings as 2-column CSV (name, value)
/// resource file.png /embedded  //file as embedded resource stream
/// resource folder  //all files in folder, as streams
/// resource folder /byte[]  //all files in folder, as byte[]
/// resource folder /string  //all files in folder, file as strings
/// resource folder /embedded  //all files in folder, as embedded resource streams
/// ]]></code>
/// More info in .cs of the Properties window.
/// 
/// <h3>Other files</h3>
/// <code><![CDATA[
/// file file.png
/// file file.dll /output_subfolder
/// ]]></code>
/// 
/// <h3>Settings used when compiling</h3>
/// <code><![CDATA[
/// optimize false|true //if false (default), don't optimize code; this is known as "Debug configuration". If true, optimizes code; then low-level code is faster, but can be difficult to debug; this is known as "Release configuration".
/// define SYMBOL1,SYMBOL2,d:DEBUG_ONLY,r:RELEASE_ONLY //define preprocessor symbols that can be used with #if etc. If no optimize true, DEBUG and TRACE are added implicitly.
/// warningLevel 1 //compiler warning level.
/// noWarnings 3009,162 //don't show these compiler warnings
/// testInternal Assembly1,Assembly2 //access internal symbols of specified assemblies, like with InternalsVisibleToAttribute
/// preBuild file /arguments //run this script before compiling. More info below.
/// postBuild file /arguments //run this script after compiled successfully. More info below.
/// ]]></code>
/// About options 'preBuild' and 'postBuild':
/// The script must have meta option role editorExtension. It runs in compiler's thread. Compiler waits and does not respond during that time. To stop compilation, let the script throw an exception.
/// The script has parameter (variable) string[] args. If there is no /arguments, args[0] is the output assembly file, full path. Else args contains the specified arguments, parsed like a command line. In arguments you can use these variables:
/// $(outputFile) -  the output assembly file, full path; $(sourceFile) - the C# file, full path; $(source) - path of the C# file in workspace, eg "\folder\file.cs"; $(outputPath) - meta option 'outputPath', default ""; $(optimize) - meta option 'optimize', default "false".
/// 
/// <h3>Settings used to run the compiled script</h3>
/// <code><![CDATA[
/// ifRunning warn_restart|warn|cancel_restart|cancel|wait_restart|wait|run_restart|run|restart|end|end_restart //what to do if this script is already running. Default: warn_restart. More info below.
/// uac inherit|user|admin //UAC integrity level (IL) of the task process. Default: inherit. More info below.
/// platform default|x64|arm64|x86
/// ]]></code>
/// Here word "task" is used for "script that is running or should start".
/// Options 'ifRunning' and 'uac' are applied only when the task is started from editor process, not when it runs as independent exe program.
/// 
/// About ifRunning:
/// When trying to start this script, what to do if it is already running. Values:
/// warn - print warning and don't run.
/// cancel - don't run.
/// wait - run later, when that task ends.
/// run - run simultaneously.
/// restart - end it and run.
/// end - end it and don't run.
/// If ends with _restart, the Run button/menu will restart. Useful for quick edit-test.
/// 
/// About uac:
/// inherit (default) - the task process has the same UAC integrity level (IL) as the editor process.
/// user - Medium IL, like most applications. The task cannot automate high IL process windows, write some files, change some settings, etc.
/// admin - High IL, aka "administrator", "elevated". The task has many rights, but cannot automate some apps through COM, etc.
/// 
/// <h3>Settings used to create assembly file</h3>
/// <code><![CDATA[
/// role miniProgram|exeProgram|editorExtension|classLibrary|classFile //purpose of this C# file. Also the type of the output assembly file (exe, dll, none). Default: miniProgram for scripts, classFile for class files. More info below.
/// outputPath path //create output files (.exe, .dll, etc) in this directory. Used with role exeProgram and classLibrary. Can be full path or relative path like with 'c'. Default for exeProgram: %folders.Workspace%\exe\filename. Default for classLibrary: %folders.Workspace%\dll.
/// console false|true //let the program run with console
/// icon file.ico //icon of the .exe file. Can be filename or relative path, like with 'c'.
/// manifest file.manifest //manifest file of the .exe file. Can be filename or relative path, like with 'c'.
/// (rejected) resFile file.res //file containing native resources to add to the .exe/.dll file. Can be filename or relative path, like with 'c'.
/// sign file.snk //sign the output assembly with a strong name using this .snk file. Can be filename or relative path, like with 'c'. 
/// xmlDoc false|true //create XML documentation file from XML comments. Creates in the 'outputPath' directory.
/// ]]></code>
/// 
/// About role:
/// If role is 'exeProgram' or 'classLibrary', creates .exe or .dll file, named like this C# file, in 'outputPath' directory.
/// If role is 'miniProgram' (default for scripts) or 'editorExtension', creates a temporary assembly file in subfolder ".compiled" of the workspace folder.
/// If role is 'classFile' (default for class files) does not create any output files from this C# file. Its purpose is to be compiled together with other C# code files.
/// If role is 'editorExtension', the task runs in the main UI thread of the editor process. Rarely used. Can be used to create editor extensions. The user cannot see and end the task. Creates memory leaks when executing recompiled assemblies (eg after editing the script), because old assembly versions cannot be unloaded until process exits.
/// 
/// Full path can be used with 'r', 'com', 'outputPath'. It can start with an environment variable or special folder name, like <c>%folders.ThisAppDocuments%\file.exe</c>.
/// Files used with other options ('c', 'resource' etc) must be in this workspace.
/// 
/// About native resources:
/// (rejected) If option 'resFile' specified, adds resources from the file, and cannot add other resources; error if also specified 'icon' or 'manifest'.
/// If 'manifest' and 'resFile' not specified when creating .exe file, adds manifest from file "default.exe.manifest" in the main Au folder.
/// If 'resFile' not specified when creating .exe or .dll file, adds version resource, with values from attributes such as [assembly: AssemblyVersion("...")]; see how it is in Visual Studio projects, in file Properties\AssemblyInfo.cs.
/// </example>
class MetaComments {
	/// <summary>
	/// Name of the main C# file, without ".cs".
	/// </summary>
	public string Name { get; private set; }
	
	/// <summary>
	/// The compilation entry file. Probably not <c>CodeFiles[0]</c>.
	/// </summary>
	public MCCodeFile MainFile { get; private set; }
	
	/// <summary>
	/// All C# files of this compilation.
	/// The order is optimized for compilation and does not match the natural order:
	/// - If there is global.cs, it is the first, followed by its descendant meta c files, total <see cref="GlobalCount"/>.
	/// - Then main file, preceded by its descendant meta c files.
	/// - Then project files, each preceded by its descendant meta c files.
	/// </summary>
	public List<MCCodeFile> CodeFiles { get; private set; }
	
	/// <summary>
	/// Count of global files, ie global.cs and its meta c descendants. They are at the start of <see cref="CodeFiles"/>.
	/// Note: if main file is a descendant of global.cs, it and its descendants are not included.
	/// </summary>
	public int GlobalCount { get; private set; }
	
	/// <summary>
	/// Meta option 'optimize'.
	/// Default: false.
	/// </summary>
	public bool Optimize { get; private set; }
	
	/// <summary>
	/// Meta option 'define' + default preprocessor symbols.
	/// </summary>
	public string[] Defines { get; private set; }
	List<string> _defines;
	static readonly string[] s_defaultDefines = ["NET10_0"/*delete when updating .NET*/, "NET10_0_OR_GREATER", "NET9_0_OR_GREATER", "NET8_0_OR_GREATER", "NET7_0_OR_GREATER", "NET6_0_OR_GREATER", "NET5_0_OR_GREATER", "NETCOREAPP3_1_OR_GREATER", "NETCOREAPP3_0_OR_GREATER", "NETCOREAPP", "NET", "WINDOWS", "WINDOWS7_0_OR_GREATER"]; //and no WINDOWS10_0_17763_0_OR_GREATER etc (see VS intellisense at #if Ctrl+Space)
	
	/// <summary>
	/// Meta option 'warningLevel'.
	/// Default: <see cref="DefaultWarningLevel"/>.
	/// </summary>
	public int WarningLevel { get; private set; }
	
	public const int DefaultWarningLevel = 8;
	//Wave 7 adds 1 warning ("The type name only contains lower-cased ascii characters"), not useful.
	//When changing the value here, change it also in `File properties.md`.
	
	/// <summary>
	/// Meta option 'noWarnings'.
	/// Default: <see cref="DefaultNoWarnings"/>.
	/// </summary>
	public List<string> NoWarnings { get; private set; }
	
	/// <summary>
	/// Gets or sets default meta option 'noWarnings' value. Initially CS1701,CS1702 (from default VS project properties) and CS8981 (lowercase typename).
	/// </summary>
	public static string[] DefaultNoWarnings { get; set; } = ["CS1701", "CS1702", "CS8981"];
	
	/// <summary>
	/// Meta 'testInternal'.
	/// Default: null.
	/// </summary>
	public string[] TestInternal { get; private set; }
	
	/// <summary>
	/// All meta errors of all files. Includes meta syntax errors, file 'not found' errors, exceptions.
	/// null if flag <b>ForCodeInfo</b> or <b>ForFindReferences</b>.
	/// </summary>
	public ErrBuilder Errors { get; private set; }
	
	/// <summary>
	/// Default references and unique references added through meta options 'r', 'com', 'nuget' and 'pr' in all C# files of this compilation.
	/// Use References.<see cref="MetaReferences.Refs"/>.
	/// </summary>
	public MetaReferences References { get; private set; }
	
	/// <summary>
	/// Project main files added through meta option 'pr'.
	/// null if none.
	/// </summary>
	public List<(FileNode f, MetaComments m)> ProjectReferences { get; private set; }
	
	/// <summary>
	/// Meta nuget, like @"-\PackageName".
	/// </summary>
	public List<(string package, string alias)> NugetPackages { get; private set; }
	
	/// <summary>
	/// If there are meta nuget, returns the root element of the auto-loaded XML file that contains a list of installed NuGet packages and their files. Else null.
	/// </summary>
	public XElement NugetXmlRoot => _xnuget;
	XElement _xnuget;
	
	/// <summary>
	/// Unique resource files added through meta option 'resource' in all C# files of this compilation.
	/// null if none.
	/// </summary>
	public List<MCFileAndString> Resources { get; private set; }
	
	/// <summary>
	/// Unique files added through meta option 'file' in all C# files of this compilation.
	/// null if none.
	/// </summary>
	public List<MCFileAndString> OtherFiles { get; private set; }
	
	/// <summary>
	/// Meta c files and folders for exporting.
	/// </summary>
	internal List<FileNode> ExportC_ { get; private set; }
	
	/// <summary>
	/// Meta option 'preBuild'.
	/// </summary>
	public MCFileAndString PreBuild { get; private set; }
	
	/// <summary>
	/// Meta option 'postBuild'.
	/// </summary>
	public MCFileAndString PostBuild { get; private set; }
	
	/// <summary>
	/// Meta option 'ifRunning'.
	/// Default: warn_restart (warn and don't run, but restart if from editor).
	/// </summary>
	public MCIfRunning IfRunning { get; private set; }
	
	/// <summary>
	/// Meta option 'uac'.
	/// Default: inherit.
	/// </summary>
	public MCUac Uac { get; private set; }
	
	/// <summary>
	/// Meta option 'startFaster'.
	/// Default: false.
	/// </summary>
	public bool StartFaster { get; private set; }
	
	/// <summary>
	/// Meta option 'platform'.
	/// If meta not specified, this property is = <see cref="DefaultPlatform"/> if executable role, else <b>Default</b>.
	/// </summary>
	public MCPlatform Platform { get; private set; }
	
	/// <summary>
	/// Default <see cref="Platform"/> when meta 'platform' not specified for an executable role.
	/// Same as LA (x64 or arm64).
	/// </summary>
	public static MCPlatform DefaultPlatform => osVersion.isArm64Process ? MCPlatform.arm64 : MCPlatform.x64;
	
	/// <summary>
	/// Meta option 'console'.
	/// Default: false.
	/// </summary>
	public bool Console { get; private set; }
	
	/// <summary>
	/// Meta option 'icon'.
	/// </summary>
	public FileNode IconFile { get; private set; }
	
	/// <summary>
	/// Meta option 'manifest'.
	/// </summary>
	public FileNode ManifestFile { get; private set; }
	
	//rejected
	///// <summary>
	///// Meta option 'res'.
	///// </summary>
	//public FileNode ResFile { get; private set; }
	
	/// <summary>
	/// Meta option 'outputPath'.
	/// Default: null.
	/// </summary>
	public string OutputPath { get; private set; }
	
	/// <summary>
	/// Meta option 'role'.
	/// Default: miniProgram if script, else classFile.
	/// In WPF preview mode it's always miniProgram.
	/// </summary>
	public MCRole Role { get; private set; }
	
	/// <summary>
	/// Gets default meta option 'role' value. It is miniProgram if isScript, else classFile.
	/// </summary>
	public static MCRole DefaultRole(bool isScript) => isScript ? MCRole.miniProgram : MCRole.classFile;
	
	/// <summary>
	/// Same As <b>Role</b>, but unchanged in WPF preview mode.
	/// </summary>
	public MCRole UnchangedRole { get; private set; }
	
	/// <summary>
	/// Meta option 'sign'.
	/// </summary>
	public FileNode SignFile { get; private set; }
	
	/// <summary>
	/// Meta 'xmlDoc'.
	/// Default: false.
	/// </summary>
	public bool XmlDoc { get; private set; }
	
	public NullableContextOptions Nullable { get; private set; }
	
	/// <summary>
	/// Which options are specified.
	/// </summary>
	public MCSpecified Specified { get; private set; }
	
	/// <summary>
	/// If there is meta, gets character positions before the starting /*/ and after the ending /*/. Else default.
	/// </summary>
	public StartEnd MetaRange { get; private set; }
	
	/// <summary>
	/// Meta 'miscFlags'.
	/// <br/>• 1 - don't add XAML icons from code strings to resources.
	/// </summary>
	public int MiscFlags { get; private set; }
	
	readonly MCFlags _flags;
	readonly Dictionary<FileNode, string> _fileTextCache;
	
	/// <param name="fileTextCache">
	/// If not null, tries to get file text from it; if not found, loads and adds to it.
	/// Use to avoid loading text of same file many times when processing multiple files. Eg for each file need global.cs and its meta c.
	/// </param>
	public MetaComments(MCFlags flags, Dictionary<FileNode, string> fileTextCache = null) {
		_flags = flags;
		_fileTextCache = fileTextCache;
	}
	
	/// <summary>
	/// Extracts meta comments from all C# files of this compilation, including project files and files added through meta option 'c'.
	/// Call once.
	/// </summary>
	/// <returns>false if there are errors, except with flag <b>ForCodeInfo</b> or <b>ForFindReferences</b>. Then use <see cref="Errors"/>.</returns>
	/// <param name="f">Main C# file. If projFolder not null, must be the main file of the project.</param>
	/// <param name="projFolder">Project folder of the main file, or null if it is not in a project.</param>
	public bool Parse(FileNode f, FileNode projFolder) {
		if (!_flags.Has(MCFlags.ForCodeInfo)) Errors = new ErrBuilder();
		if (_flags.Has(MCFlags.Publish)) Optimize = true;
		
		if (_ParseFile(f, true, false)) {
			if (projFolder != null) {
				foreach (var ff in projFolder.EnumProjectClassFiles(f)) _ParseFile(ff, false, false);
			}
			
			//print.it(GlobalCount, CodeFiles);
			
			//define d:DEBUG_ONLY, r:RELEASE_ONLY
			for (int i = _defines.Count; --i >= 0;) {
				var s = _defines[i]; if (s.Length < 3 || s[1] != ':') continue;
				bool? del = s[0] switch { 'r' => !Optimize, 'd' => Optimize, _ => null };
				if (del == true) _defines.RemoveAt(i); else if (del == false) _defines[i] = s[2..];
			}
			
			if (!Optimize) {
				if (!_defines.Contains("DEBUG")) _defines.Add("DEBUG");
				if (!_defines.Contains("TRACE")) _defines.Add("TRACE");
			}
			//if(Role == MCRole.exeProgram && !_defines.Contains("EXE")) _defines.Add("EXE"); //rejected
			Defines = [.. s_defaultDefines, .. _defines];
			
			if (_flags.Has(MCFlags.ForFindReferences)) return true;
			
			_f = MainFile;
			_metaRange = MetaRange;
			_FinalCheckOptions();
			
			if (Platform == default && Role <= MCRole.editorExtension) Platform = DefaultPlatform;
		}
		
		if (Errors?.ErrorCount > 0) {
			if (_flags.Has(MCFlags.PrintErrors)) Errors.PrintAll();
			return false;
		}
		
		if (_flags.Has(MCFlags.Publish) && Role == MCRole.classLibrary) {
			OutputPath = folders.ThisAppTemp + @"publish\pr\" + Name;
		}
		
		return true;
	}
	
	/// <summary>
	/// Gets meta comments from a C# file and its meta c descendants.
	/// </summary>
	bool _ParseFile(FileNode f, bool isMain, bool isC, bool isGlobal = false) {
		if (!isMain && _CodeFilesContains(f)) return false;
		
		string code = null;
		if (_fileTextCache == null || !_fileTextCache.TryGetValue(f, out code)) {
			if (f.GetCurrentText(out code, silent: true).error is string es1) { Errors?.AddError(f, es1); return false; }
			_fileTextCache?.Add(f, code);
		}
		
		bool isScript = f.IsScript;
		var cf = new MCCodeFile(f, code, isMain, isC);
		
		if (isMain) {
			MainFile = cf;
			
			Name = pathname.getNameNoExt(f.Name);
			
			WarningLevel = DefaultWarningLevel;
			NoWarnings = DefaultNoWarnings != null ? new(DefaultNoWarnings) : new();
			_defines = new();
			Role = DefaultRole(isScript);
			
			CodeFiles = new();
			References = new();
			NugetPackages = new();
		}
		
		CodeFiles.Add(cf);
		int nc = CodeFiles.Count;
		var fPrev = _f; _f = cf;
		
		//add global.cs
		if (isMain) {
			var model = f.Model;
			if (!_flags.Has(MCFlags.ExportNoGlobal)) {
				var glob = model.FindGlobalCs(); //fast, uses dictionary
				if (glob != null) {
					if (glob == f) isGlobal = true;
					else {
						if (_flags.Has(MCFlags.Export)) (ExportC_ ??= new()).Add(glob);
						_ParseFile(glob, false, true, isGlobal: true);
					}
				}
			}
		}
		
		var meta = _metaRange = FindMetaComments(code);
		if (meta.end > 0) {
			if (isMain) MetaRange = meta;
			foreach (var t in EnumOptions(code, meta)) {
				//var p1 = perf.local();
				_ParseOption(t.Name, t.Value, t.nameStart, t.valueStart);
				//p1.Next(); var t1 = p1.TimeTotal; if(t1 > 5) print.it(t1, t.Name(), t.Value());
			}
		}
		
		if (isMain) {
			this.UnchangedRole = this.Role;
			if (_flags.Has(MCFlags.WpfPreview)) {
				this.Role = MCRole.miniProgram;
				this.IfRunning = MCIfRunning.run;
				_defines.Add("WPF_PREVIEW");
				this.Uac = default;
				//this.StartFaster = true;
				this.Platform = default;
				this.Console = false;
				this.Optimize = false;
				this.OutputPath = null;
				this.PreBuild = default;
				this.PostBuild = default;
				this.XmlDoc = false;
				this.Nullable = default;
			}
		}
		
		//let at first compile "global.cs" and meta c files. Why:
		//	1. If they have same classes etc or assembly/module attributes, it's better to show error in current file.
		//	2. If they have module initializers, it's better to call them first.
		if (isGlobal) {
			GlobalCount = CodeFiles.Count - (isMain ? 0 : 1);
		} else if (CodeFiles.Count > nc) {
			CodeFiles.RemoveAt(nc - 1);
			CodeFiles.Add(cf);
		}
		_f = fPrev;
		
		return true;
	}
	
	MCCodeFile _f; //current
	StartEnd _metaRange; //current
	
	void _ParseOption(string name, string value, int iName, int iValue) {
		if (name is null) return; //disabled
		
		//print.it(name, value);
		_nameFrom = iName; _nameTo = iName + name.Length;
		_valueFrom = iValue; _valueTo = iValue + value.Length;
		
		if (value.Length == 0) { _ErrorV("value cannot be empty"); return; }
		bool forCodeInfo = _flags.Has(MCFlags.ForCodeInfo),
			forFindRef = _flags.Has(MCFlags.ForFindReferences),
			forExport = _flags.Has(MCFlags.Export);
		
		switch (name) {
		case "r" or "com" or "pr" or "nuget":
			if (forExport) if (name[0] != 'p' || !_flags.Has(MCFlags.ExportPR)) return;
			if (!MetaReferences.ParseRefAliasEtc_(name, value, out var s1, out var alias, out bool noCopy)) {
				_ErrorV("invalid string");
			} else if (name[0] == 'n') {
				_NuGet(s1, alias);
			} else {
				if (name[0] == 'p') {
					//Specified |= EMSpecified.pr;
					if (!_PR(ref s1) || forCodeInfo || forExport) return;
				}
				
				try {
					//var p1 = perf.local();
					if (!References.Resolve(s1, alias, isCOM: name[0] == 'c', isNuget: false, noCopy: noCopy)) {
						_ErrorV("reference assembly not found: " + s1); //TODO3: need more info, or link to Help
					}
					//p1.NW('r');
				}
				catch (Exception e) {
					_ErrorV("exception: " + e.Message); //unlikely. If bad format, will be error later, without position info.
				}
			}
			return;
		case "c":
			if (_GetFile(value, FNFind.Any) is FileNode ff) {
				if (forExport) (ExportC_ ??= new()).Add(ff);
				if (ff.IsFolder) {
					foreach (var v in ff.Descendants()) if (v.IsClass) _ParseFile(v, false, true);
				} else {
					if (ff.IsClass) _ParseFile(ff, false, true);
					else _ErrorV("must be a class file");
				}
			}
			return;
		case "file":
			if (!forFindRef) {
				var fs1 = _GetFileAndString(value, FNFind.Any);
				if (!forCodeInfo && fs1.f != null) {
					OtherFiles ??= new();
					if (!OtherFiles.Exists(o => o == fs1)) OtherFiles.Add(fs1);
				}
			}
			return;
		case "miscFlags":
			if (!forCodeInfo) MiscFlags = value.ToInt();
			return;
		case "noRef" when _f.isMain:
			References.RemoveFromRefs(value);
			return;
		}
		if (_flags.Has(MCFlags.OnlyRef)) return;
		
		if (name is "resource") {
			if (!forFindRef) {
				//if (value.Ends(" /resources")) { //add following resources in value.resources instead of in AssemblyName.g.resources. //rejected. Rarely used. Would need more code, because meta resource can be in multiple files.
				//	if (!forCodeInfo) (Resources ??= new()).Add(new(null, value[..^11]));
				//	return;
				//}
				var fs1 = _GetFileAndString(value, FNFind.Any);
				if (!forCodeInfo && fs1.f != null) {
					Resources ??= new();
					if (!Resources.Exists(o => o == fs1)) Resources.Add(fs1);
				}
			}
			return;
		}
		
		if (!_f.isMain) {
			if (!forFindRef) {
				//In class files compiled as not main silently ignore all options if the first option is role other than class.
				//	It allows to test a class file without a test script etc.
				//	How: In meta define symbol X. Then #if X, enable executable code that uses the class.
				if (name is "role") {
					if (_f.allowAnyMeta_ = _Enum(out MCRole ro1, value) && ro1 != MCRole.classFile) return;
				} else if (_f.allowAnyMeta_) {
					if (name is "optimize" or "define" or "warningLevel" or "noWarnings" or "testInternal" or "preBuild" or "postBuild" or "outputPath" or "ifRunning" or "uac" or "platform" or "bit32" or "console" or "manifest" or "icon" or "sign" or "xmlDoc") return;
					_ErrorN("unknown meta comment option");
				}
				
				_ErrorN($"in this file only these options can be used: c, r, pr, nuget, com, resource, file. Others only in the main file of the compilation - {MainFile.f.Name}. <help editor/Class files, projects>More info<>.");
			}
			return;
		}
		
		switch (name) {
		case "role":
			_Specified(MCSpecified.role);
			if (_Enum(out MCRole ro, value)) {
				Role = ro;
				if (MainFile.f.IsScript && (ro == MCRole.classFile || Role == MCRole.classLibrary)) _ErrorV("role classFile and classLibrary can be only in class files");
			}
			return;
		case "optimize":
			_Specified(MCSpecified.optimize);
			if (_TrueFalse(out bool optim, value) && !_flags.Has(MCFlags.Publish)) Optimize = optim;
			return;
		case "define":
			_Specified(MCSpecified.define);
			_defines.AddRange(value.Split_(','));
			return;
		case "testInternal":
			_Specified(MCSpecified.testInternal);
			TestInternal = value.Split_(',');
			return;
		case "sign":
			_Specified(MCSpecified.sign);
			SignFile = _GetFile(value, FNFind.File);
			return;
		}
		if (forFindRef) return;
		
		switch (name) {
		case "warningLevel":
			_Specified(MCSpecified.warningLevel);
			int wl = value.ToInt();
			if (wl >= 0 && wl <= 9999) WarningLevel = wl;
			else _ErrorV("must be 0 - 9999");
			break;
		case "noWarnings":
			_Specified(MCSpecified.noWarnings);
			NoWarnings.AddRange(value.Split_(','));
			break;
		case "preBuild":
			_Specified(MCSpecified.preBuild);
			PreBuild = _GetFileAndString(value, FNFind.CodeFile);
			break;
		case "postBuild":
			_Specified(MCSpecified.postBuild);
			PostBuild = _GetFileAndString(value, FNFind.CodeFile);
			break;
		case "outputPath":
			_Specified(MCSpecified.outputPath);
			if (!forCodeInfo) OutputPath = _GetOutPath(value);
			break;
		case "ifRunning":
			_Specified(MCSpecified.ifRunning);
			if (_Enum(out MCIfRunning ifR, value)) IfRunning = ifR;
			break;
		case "uac":
			_Specified(MCSpecified.uac);
			if (_Enum(out MCUac uac, value)) Uac = uac;
			break;
		case "startFaster": //undocumented. Likely will be removed in the future.
			_Specified(MCSpecified.startFaster);
			if (_TrueFalse(out bool startFaster, value)) StartFaster = startFaster;
			break;
		case "platform":
			_Specified(MCSpecified.platform);
			if (_Enum(out MCPlatform platform, value)) Platform = platform;
			break;
		case "bit32": //fbc. Now use platform instead.
			_Specified(MCSpecified.platform);
			if (_TrueFalse(out bool is32, value) && is32) Platform = MCPlatform.x86;
			break;
		case "console":
			_Specified(MCSpecified.console);
			if (_TrueFalse(out bool con, value)) Console = con;
			break;
		case "manifest":
			_Specified(MCSpecified.manifest);
			ManifestFile = _GetFile(value, FNFind.File);
			break;
		case "icon":
			_Specified(MCSpecified.icon);
			IconFile = _GetFile(value, FNFind.Any);
			break;
		//case "resFile":
		//	_Specified(EMSpecified.resFile);
		//	ResFile = _GetFile(value);
		//	break;
		case "xmlDoc":
			_Specified(MCSpecified.xmlDoc);
			if (_TrueFalse(out bool xmlDOc, value)) XmlDoc = xmlDOc;
			break;
		case "nullable":
			_Specified(MCSpecified.nullable);
			if (_Enum(out NullableContextOptions nco, value)) Nullable = nco;
			break;
		default:
			_ErrorN("unknown meta comment option");
			break;
		}
	}
	
	#region util
	
	int _nameFrom, _nameTo, _valueFrom, _valueTo;
	
	bool _Error(string s, int from, int to) {
		if (Errors != null) {
			Errors.AddError(_f.f, _f.code, from, "error in meta: " + s);
		} else if (_flags.Has(MCFlags.ForCodeInfoInEditor) && _f.f == Panels.Editor.ActiveDoc.EFile) {
			CodeInfo._diag.AddMetaError(_metaRange, from, to, s);
		}
		return false;
	}
	
	/// <summary>Error in name.</summary>
	bool _ErrorN(string s) => _Error(s, _nameFrom, _nameTo);
	
	/// <summary>Error in value.</summary>
	bool _ErrorV(string s) => _Error(s, _valueFrom, _valueTo);
	
	/// <summary>Error in unknown place.</summary>
	bool _ErrorM(string s) => _Error(s, _metaRange.start, _metaRange.start + 3);
	
	void _Specified(MCSpecified what) {
		if (Specified.Has(what)) _ErrorN("this meta comment option is already specified");
		Specified |= what;
	}
	
	bool _TrueFalse(out bool b, string s) {
		b = false;
		switch (s) {
		case "true" or "!false": b = true; break;
		case "false" or "!true": break;
		default: return _ErrorV("must be true or false or !true or !false");
		}
		return true;
	}
	
	unsafe bool _Enum<T>(out T result, string s) where T : unmanaged, Enum {
		Debug.Assert(sizeof(T) == 4);
		bool R = _Enum2(typeof(T), out int v, s);
		result = Unsafe.As<int, T>(ref v);
		return R;
	}
	bool _Enum2(Type t, out int result, string s) {
		result = default;
		if (!s_enumCache.TryGetValue(t, out var r)) {
			var a = t.GetFields(BindingFlags.Public | BindingFlags.Static);
			int n = a.Length; foreach (var v in a) if (v.Name.Starts('_')) n--;
			r = new (string, int)[n];
			for (int i = 0, j = 0; i < a.Length; i++) {
				var sn = a[i].Name;
				if (!sn.Starts('_')) {
					if (char.IsUpper(sn[0])) sn = char.ToLowerInvariant(sn[0]) + sn[1..];
					r[j++] = (sn, (int)a[i].GetRawConstantValue());
				}
			}
			s_enumCache[t] = r;
		}
		foreach (var v in r) if (v.name == s) { result = v.value; return true; }
		return _ErrorV("must be one of:\n" + string.Join(", ", r.Select(o => o.name)));
	}
	static readonly Dictionary<Type, (string name, int value)[]> s_enumCache = new();
	
	FileNode _GetFile(string s, FNFind kind) {
		string s0 = s;
		var f = _f.f.FindRelative(true, s, kind);
		if (f == null) {
			if (App.Model.FoundMultiple != null) _ErrorV($"multiple '{s}' exist in this workspace. Use path, or rename a file.");
			else if (kind == FNFind.Folder) _ErrorV($"folder '{s}' does not exist in this workspace");
			else if (kind != FNFind.Any && null != _f.f.FindRelative(false, s, FNFind.File)) _ErrorV($"expected a {(kind == FNFind.Class ? "class" : "C#")} file");
			else _ErrorV($"file '{s}' does not exist in this workspace");
			return null;
		}
		int v = filesystem.exists(s = f.FilePath, true);
		if (v != (f.IsFolder ? 2 : 1)) { _ErrorV("file does not exist: " + s); return null; }
		
		if (_flags.Has(MCFlags.Export) && s0.Contains('\\')) { _ErrorV($"must be <c green>{pathname.getName(s0)}<>. Path would be invalid when imported elsewhere."); return null; }
		
		return f;
	}
	
	public static FileNode FindFile(FileNode fRelativeTo, string metaValue, FNFind kind) {
		var f = fRelativeTo.FindRelative(true, metaValue, kind);
		if (f != null) {
			int v = filesystem.exists(f.FilePath, true);
			if (v != (f.IsFolder ? 2 : 1)) return null;
		}
		return f;
	}
	
	MCFileAndString _GetFileAndString(string s, FNFind kind) {
		s = SplitArgs_(s, out var s2);
		
		//rejected
		//if (orFullPathAnywhere && pathname.isFullPathExpand(ref s)) {
		//	//rejected: support folders or wildcard. Users can add a link to the folder to the workspace, it is supported.
		//	if (!filesystem.exists(s).File) { _ErrorV("file does not exist: " + s); s = null; }
		//	return new(null, s2, s);
		//}
		
		return new(_GetFile(s, kind), s2);
	}
	
	internal static string SplitArgs_(string s, out string s2) {
		int i = s.Find(" /");
		if (i > 0) {
			s2 = s[(i + 2)..].NullIfEmpty_();
			s = s[..i];
		} else s2 = null;
		return s;
	}
	
	string _GetOutPath(string s) {
		s = s.TrimEnd('\\');
		if (!pathname.isFullPathExpand(ref s)) {
			if (s.Starts('%')) _ErrorV("relative path starts with %");
			if (s.Starts('\\')) s = _f.f.Model.FilesDirectory + s;
			else s = pathname.getDirectory(_f.f.FilePath, true) + s;
		}
		return pathname.Normalize_(s, noExpandEV: true);
	}
	
	bool _CodeFilesContains(FileNode f) {
		//return CodeFiles.Exists(o => o.f == f); //garbage
		var a = CodeFiles;
		for (int i = a.Count; --i >= 0;) if (a[i].f == f) return true;
		return false;
	}
	
	#endregion
	
	bool _PR(ref string value) {
		if (_GetFile(value, FNFind.Class) is not FileNode f) return false;
		if (f.FindProject(out var projFolder, out var projMain)) f = projMain;
		if (f == MainFile.f) return _ErrorV("circular reference");
		if (ProjectReferences is { } pr) foreach (var v in pr) if (v.f == f) return false;
		MetaComments m = null;
		if (_flags.Has(MCFlags.Export)) {
			//don't need MetaComments and recursion. The export function will do it.
			//m = new MetaComments(_flags | MCFlags.IsPR);
			//if (!m.Parse(f, projFolder)) return false;
		} else if (!_flags.Has(MCFlags.ForCodeInfo)) {
			if (!Compiler.Compile(CCReason.CompileIfNeed, out var r, f, projFolder, needMeta: true, addMetaFlags: (_flags & MCFlags.Publish) | MCFlags.IsPR))
				return _ErrorV("failed to compile library");
			//print.it(r.role, r.file);
			if (r.role != MCRole.classLibrary) return _ErrorV("it is not a class library (no meta role classLibrary)");
			value = r.file;
			m = r.meta;
		}
		(ProjectReferences ??= new()).Add((f, m));
		return true;
	}
	
	void _NuGet(string value, string alias) {
		value = value.Replace('/', '\\');
		foreach (var v in NugetPackages) if (v.package.Eqi(value)) return;
		NugetPackages.Add((value, alias));
		if (_flags.Has(MCFlags.Publish) && !_flags.Has(MCFlags.IsPR)) return;
		try {
			_xnuget ??= XmlUtil.LoadElemIfExists(App.Model.NugetDirectoryBS + "nuget.xml");
			var xx = _xnuget?.Elem("package", "path", value, true);
			if (xx == null) {
				bool forCiErrors = _flags.Has(MCFlags.ForCodeInfoInEditor);
				var b = new StringBuilder(forCiErrors ? "<>" : null);
				b.Append("NuGet package not installed: ").Append(value);
				//append "install" link etc
				if (value.Split('\\', 2) is var a && a.Length == 2 && a[0].Length > 0 && a[1].Length > 0) {
					var sep = forCiErrors ? "\r\n" : "\r\n\t";
					b.Append(sep);
					//is installed in another folder?
					bool appended = false;
					if (_xnuget != null) {
						var s1 = "\\" + a[1];
						foreach (var v in _xnuget.Elements("package")) {
							if (v.Attr("path") is string s2 && s2.Ends(s1, true)) {
								s2 = s2[..^s1.Length];
								b.Append(!appended ? $"Replace code `nuget {value}` with" : $" or").Append($" `nuget {s2}{s1}`");
								appended = true;
							}
						}
						if (appended) b.Append(sep).Append($"Or <+nuget {value}>install or move<> {a[1]} to folder {a[0]}.");
					}
					if (!appended) b.Append($"<+nuget {value}>Install {a[1]}...<>");
				}
				_ErrorV(b.ToString());
				return;
			}
			var dir = App.Model.NugetDirectoryBS + pathname.getDirectory(value);
			foreach (var x in xx.Elements()) {
				if (x.Name.LocalName is not ("r" or "ro")) continue;
				var r = dir + x.Value;
				if (!References.Resolve(r, alias, isCOM: false, isNuget: true)) {
					_ErrorV("NuGet file not found: " + r);
				}
			}
		}
		catch (Exception e) {
			_ErrorV("exception: " + e.Message);
		}
	}
	
	bool _FinalCheckOptions() {
		//const MCSpecified c_spec1 = MCSpecified.ifRunning | MCSpecified.uac | MCSpecified.platform | MCSpecified.manifest | MCSpecified.icon | MCSpecified.console | MCSpecified.startFaster;
		//const string c_spec1S = "cannot use: ifRunning, uac, manifest, icon, console, platform, startFaster";
		const MCSpecified c_spec1 = MCSpecified.ifRunning | MCSpecified.uac | MCSpecified.platform | MCSpecified.manifest | MCSpecified.icon | MCSpecified.console;
		const string c_spec1S = "cannot use: ifRunning, uac, manifest, icon, console, platform";
		
		bool needOP = false;
		var role = UnchangedRole;
		switch (role) {
		case MCRole.miniProgram:
			if (Specified.HasAny(MCSpecified.outputPath | MCSpecified.manifest | MCSpecified.platform | MCSpecified.xmlDoc))
				return _ErrorM("with role miniProgram cannot use: outputPath, manifest, platform, xmlDoc");
			//rejected: allow platform x64 on ARM64 OS. It's easy to implement (we have the ARM task exe), but rarely used etc. Let use role exeProgram.
			break;
		case MCRole.exeProgram:
			//if (Specified.Has(MCSpecified.startFaster)) return _ErrorM("with role exeProgram cannot use: startFaster");
			needOP = true;
			break;
		case MCRole.editorExtension:
			if (Specified.HasAny(c_spec1 | MCSpecified.outputPath | MCSpecified.xmlDoc))
				return _ErrorM($"with role editorExtension {c_spec1S}, outputPath, xmlDoc");
			break;
		case MCRole.classLibrary:
			if (Specified.HasAny(c_spec1)) return _ErrorM("with role classLibrary " + c_spec1S);
			needOP = true;
			break;
		case MCRole.classFile:
			if (Specified != 0) return _ErrorM("with role classFile (default role of class files) can be used only c, com, nuget, r, resource, file");
			break;
		}
		if (needOP && !_flags.Has(MCFlags.WpfPreview)) OutputPath ??= GetDefaultOutputPath(_f.f, role, withEnvVar: false);
		
		if (IconFile?.IsFolder ?? false) if (role != MCRole.exeProgram) return _ErrorM("icon folder can be used only with role exeProgram"); //difficult to add multiple icons if miniProgram
		
		//if(ResFile != null) {
		//	if(IconFile != null) return _ErrorM("cannot add both res file and icon");
		//	if(ManifestFile != null) return _ErrorM("cannot add both res file and manifest");
		//}
		
		return true;
	}
	
	public static string GetDefaultOutputPath(FileNode f, MCRole role, bool withEnvVar) {
		Debug.Assert(role is MCRole.exeProgram or MCRole.classLibrary or MCRole.miniProgram);
		string r;
		if (role == MCRole.classLibrary) r = withEnvVar ? @"%folders.Workspace%\dll" : App.Model.DllDirectory;
		else r = (withEnvVar ? @"%folders.Workspace%\exe\" : App.Model.WorkspaceDirectory + @"\exe\") + f.DisplayName;
		return r;
	}
	
	public CSharpCompilationOptions CreateCompilationOptions() {
		OutputKind oKind = OutputKind.WindowsApplication;
		if (Role == MCRole.classLibrary || Role == MCRole.classFile) oKind = OutputKind.DynamicallyLinkedLibrary;
		else if (Console) oKind = OutputKind.ConsoleApplication;
		
		var r = new CSharpCompilationOptions(
			oKind,
			optimizationLevel: Optimize ? OptimizationLevel.Release : OptimizationLevel.Debug, //speed: compile the same, load Release slightly slower. Default Debug.
			allowUnsafe: true,
			warningLevel: WarningLevel,
			specificDiagnosticOptions: NoWarnings?.Select(wa => new KeyValuePair<string, ReportDiagnostic>(wa[0].IsAsciiDigit() ? ("CS" + wa.PadLeft(4, '0')) : wa, ReportDiagnostic.Suppress)),
			cryptoKeyFile: SignFile?.FilePath, //also need strongNameProvider
			strongNameProvider: SignFile == null ? null : new DesktopStrongNameProvider(),
			nullableContextOptions: Nullable
		//,metadataImportOptions: TestInternal != null ? MetadataImportOptions.Internal : MetadataImportOptions.Public
		);
		
		//Allow to use internal/protected of assemblies specified using IgnoresAccessChecksToAttribute.
		//https://www.strathweb.com/2018/10/no-internalvisibleto-no-problem-bypassing-c-visibility-rules-with-roslyn/
		//This code (the above and below commented code) is for compiler. Also Compiler._AddAttributes adds attribute for run time.
		//if (TestInternal != null) {
		//	r = r.WithTopLevelBinderFlags(BinderFlags.IgnoreAccessibility);
		//}
		//But if using this code, code info has problems. Completion list contains internal/protected from all assemblies, and difficult to filter out. No signature info.
		//We instead modify Roslyn code and use class TestInternal. More info in project CompilerDlls here.
		
		//r = r.WithTopLevelBinderFlags(BinderFlags.SemanticModel); //should be used in editor? Tested a bit, it seems works the same.
		
		return r;
	}
	
	public CSharpParseOptions CreateParseOptions() {
		var docMode = DocumentationMode.None;
		if (_flags.Has(MCFlags.ForFindReferences)) docMode = DocumentationMode.Parse;
		else if (_flags.Has(MCFlags.ForCodeInfoInEditor) || XmlDoc) docMode = DocumentationMode.Diagnose;
		
		return new(LanguageVersion.Preview, docMode, SourceCodeKind.Regular, Defines);
	}
	
	/// <summary>
	/// Returns (start, end) of metacomments "/*/ ... /*/" at the start of code (before can be comments, empty lines, spaces, tabs, shebang). Returns default if no metacomments.
	/// </summary>
	/// <seealso cref="MetaCommentsParser"/>
	public static StartEnd FindMetaComments(RStr code) {
		int i = 0;
		if (code is ['#', '!', ..]) {
			i = code.IndexOf(i, '\n') + 1; if (i == 0) return default;
		}
		for (; i <= code.Length - 6; i++) {
			char c = code[i];
			if (c == '/') {
				c = code[++i];
				if (c == '*') {
					int j = code.IndexOf(++i, "*/");
					if (j < 0) break;
					if (code[i] == '/' && code[j - 1] == '/') return new(i - 2, j + 2);
					i = j + 1;
				} else if (c == '/') {
					i = code.IndexOf(i, '\n');
					if (i < 0) break;
				} else break;
			} else if (c is not ('\r' or '\n' or ' ' or '\t')) break;
		}
		return default;
	}
	
	/// <summary>
	/// Parses metacomments and returns offsets of all option names and values in code.
	/// </summary>
	/// <param name="code">Code that starts with metacomments "/*/ ... /*/".</param>
	/// <param name="meta">The range of metacomments, returned by <see cref="FindMetaComments"/>.</param>
	/// <seealso cref="MetaCommentsParser"/>
	[MethodImpl(MethodImplOptions.AggressiveOptimization)]
	public static IEnumerable<Token> EnumOptions(string code, StartEnd meta) {
		for (int i = meta.start + 3, iEnd = meta.end - 3; i < iEnd; i++) {
			Token t = default;
			for (; i < iEnd; i++) if (code[i] > ' ') break; //find next option
			if (i == iEnd) break;
			t.nameStart = i;
			if (i < iEnd && code[i] is '/') {
				t.nameEnd = i;
			} else {
				while (i < iEnd && code[i] is > ' ' and not ';') i++; //find separator after name
				t.nameEnd = i;
				while (i < iEnd && code[i] is ' ' or '\t') i++; //find value
			}
			t.valueStart = i;
			i = code.AsSpan(i, iEnd - i).IndexOfAny(';', '\n'); if (i < 0) i = iEnd; else i += t.valueStart; //find ; or newline after value
			int j = i; while (j > t.valueStart && code[j - 1] <= ' ') j--; //rtrim
			t.valueEnd = j;
			t.code = code;
			yield return t;
		}
	}
	
	/// <summary>
	/// <see cref="EnumOptions"/>.
	/// </summary>
	public struct Token {
		public int nameStart, nameEnd, valueStart, valueEnd;
		public string code;
		
		public string Name => nameEnd > nameStart ? code[nameStart..nameEnd] : null;
		public string Value => code[valueStart..valueEnd];
		public bool NameIs(string s) => code.Eq(nameStart..nameEnd, s);
		public bool ValueIs(string s) => code.Eq(valueStart..valueEnd, s);
		public bool IsDisabled => nameEnd == nameStart;
	}
}

/// <param name="f"></param>
/// <param name="code"></param>
/// <param name="isMain"></param>
/// <param name="isC">Added through meta 'c' or "global.cs".</param>
record class MCCodeFile(FileNode f, string code, bool isMain, bool isC) {
	internal bool allowAnyMeta_;
	public override string ToString() => f.ToString();
}

record struct MCFileAndString(FileNode f, string s);

enum MCRole { miniProgram, exeProgram, editorExtension, classLibrary, classFile }

enum MCUac { inherit, user, admin }

enum MCIfRunning { warn_restart, warn, cancel_restart, cancel, wait_restart, wait, run_restart, run, restart, end, end_restart, _norestartFlag = 1 }

enum MCPlatform { Default, x64, arm64, x86 }

/// <summary>
/// Flags for <see cref="MetaComments"/>
/// </summary>
[Flags]
enum MCFlags {
	/// <summary>
	/// Used for code info, not when compiling.
	/// Ignores meta such as run options (ifRunning etc) and non-code/reference files (resource etc).
	/// This flag is included in <b>ForCodeInfoInEditor</b> and <b>ForFindReferences</b>.
	/// </summary>
	ForCodeInfo = 1,
	
	/// <summary>
	/// Used for code info in editor.
	/// Includes <b>ForCodeInfo</b>.
	/// Same as <b>ForCodeInfo</b>; also adds some editor-specific stuff, like CodeInfo._diag.AddMetaError and DocumentationMode.Diagnose.
	/// </summary>
	ForCodeInfoInEditor = 2 | 1,
	
	/// <summary>
	/// Used by <see cref="CiProjects.GetSolutionForFindReferences"/>.
	/// Includes <b>ForCodeInfo</b>.
	/// </summary>
	ForFindReferences = 4 | 1,
	
	/// <summary>
	/// Call <see cref="ErrBuilder.PrintAll"/>.
	/// </summary>
	PrintErrors = 8,
	
	/// <summary>
	/// Need only references (r, pr, com, nuget) and file.
	/// </summary>
	OnlyRef = 16,
	
	/// <summary>
	/// Compiling for WPF preview.
	/// Defines WPF_PREVIEW and resets some meta.
	/// </summary>
	WpfPreview = 32,
	
	/// <summary>
	/// Used via meta pr of another project.
	/// </summary>
	IsPR = 64,
	
	/// <summary>
	/// Used for Publish.
	/// </summary>
	Publish = 128,
	
	/// <summary>
	/// When exporting.
	/// Note: does not include <b>ForCodeInfo</b>.
	/// </summary>
	Export = 0x10000000,
	
	/// <summary>
	/// Export pr too. Use with <b>ForExport</b>.
	/// </summary>
	ExportPR = 0x20000000,
	
	/// <summary>
	/// Don't export global.cs. Use with <b>ForExport</b>.
	/// </summary>
	ExportNoGlobal = 0x40000000,
}

[Flags]
enum MCSpecified {
	ifRunning = 1,
	uac = 1 << 1,
	platform = 1 << 2,
	optimize = 1 << 3,
	define = 1 << 4,
	warningLevel = 1 << 5,
	noWarnings = 1 << 6,
	testInternal = 1 << 7,
	preBuild = 1 << 8,
	postBuild = 1 << 9,
	outputPath = 1 << 10,
	role = 1 << 11,
	icon = 1 << 12,
	manifest = 1 << 13,
	sign = 1 << 14,
	xmlDoc = 1 << 15,
	console = 1 << 16,
	nullable = 1 << 17,
	startFaster = 1 << 18,
}


================================================
FILE: Au.Editor/Compiler/MetaReferences.cs
================================================
extern alias CAW;

using System.Collections.Immutable;

using Microsoft.CodeAnalysis;
using CAW::Microsoft.CodeAnalysis;

namespace LA;

/// <summary>
/// Resolves assembly metadata references (string to PortableExecutableReference).
/// For each compilation create a MetaReferences variable, call Resolve if need non-default references, then use Refs list.
/// </summary>
/// <remarks>
/// Temporarily keeps PortableExecutableReference objects in a cache. Except Au and .NET design-time assemblies (they are small, without code).
/// Single static cache is used by all MetaReferences variables.
/// Cache may require many MB of unmanaged memory, therefore PortableExecutableReference objects are removed and GC-collected when not used anywhere for some time. Reloading is quite fast.
/// 	A reference to a PortableExecutableReference variable prevents removing it from cache and GC-collecting.
/// 	A reference to a MetaReferences variable prevents removing/disposing its Refs items.
/// 	CodeAnalysis Project etc objects also have references, therefore need to manage their lifetimes too.
/// MetaReferences variables can be created in different threads, but a variable must be used in a single thread.
/// </remarks>
class MetaReferences {
	/// <summary>
	/// Contains info used to load a PortableExecutableReference. Loads when need. Supports XML documentation.
	/// </summary>
	class _MR {
		public readonly string name, path;
		public readonly bool isNuget;
		public bool ignoreThis, ignoreDef;
		readonly WeakReference<PortableExecutableReference> _wr = new(null);
		PortableExecutableReference _refKeeper;
		long _rkTimeout;
		long _fileTime;
		
		public _MR(string name, string path, bool isNuget) {
			//print.it(name);
			this.name = name;
			this.path = path;
			this.isNuget = isNuget;
		}
		
		public PortableExecutableReference Ref {
			get {
				if (!_wr.TryGetTarget(out var r)) {
					//for(int i=0;i<10;i++) //tested: process memory does not grow when loading same file several times
					//perf.first();
					r = MetadataReference.CreateFromFile(path, (this as _MR2)?.Prop ?? default, _DocumentationProvider.Create(path));
					if (isNuget) s_attach.AddOrUpdate(r, "");
					filesystem.GetTime_(path, out _fileTime);
					//perf.nw();
					
					_wr.SetTarget(r);
					//print.it("LOADED", name, this is _MR2);
				} //else print.it("cached", name, this is _MR2);
				
				//prevent GC too early, eg while compiling many files
				_rkTimeout = Environment.TickCount64 + 30_000;
				_refKeeper = r;
				
				return r;
			}
		}
		
		public void UncacheIfNeed(long timeNow) {
			if (_fileTime != 0) {
				filesystem.GetTime_(path, out var t);
				if (t != _fileTime) {
					_wr.SetTarget(null);
					_refKeeper = null;
					_fileTime = 0;
					return;
				}
			}
			if (_refKeeper != null && timeNow > _rkTimeout) _refKeeper = null;
		}
		
#if DEBUG
		public bool IsCached => _wr.TryGetTarget(out _);
#endif
	}
	
	class _MR2 : _MR {
		readonly string _alias;
		readonly bool _isCOM;
		
		public _MR2(string name, string path, string alias, bool isCOM, bool isNuget) : base(name, path, isNuget) {
			_alias = alias;
			_isCOM = isCOM;
		}
		
		public MetadataReferenceProperties Prop => new(aliases: _alias == null ? default : ImmutableArray.Create(_alias), embedInteropTypes: _isCOM);
		
		public bool PropEq(string alias, bool isCOM) => isCOM == _isCOM && alias == _alias;
	}
	
	static readonly List<_MR> s_cache = new();
	
	public static bool IsNuget(PortableExecutableReference r) => s_attach.TryGetValue(r, out _);
	static ConditionalWeakTable<PortableExecutableReference, string> s_attach = new();
	
	/// <summary>
	/// List containing most <see cref="DefaultReferences"/> + references for which was called <see cref="Resolve"/> of this MetaReferences variable.
	/// </summary>
	public IReadOnlyList<PortableExecutableReference> Refs => _refs;
	readonly List<PortableExecutableReference> _refs;
	
	/// <summary>
	/// These references are added when compiling any script/library.
	/// Au.dll and all .NET design-time assemblies.
	/// </summary>
	public static readonly Dictionary<string, PortableExecutableReference> DefaultReferences = new(300, StringComparer.OrdinalIgnoreCase);
	
	/// <summary>
	/// Returns true if <i>name</i> is in <b>DefaultReferences</b> or is a private .NET assembly. Case-insensitive.
	/// </summary>
	public static bool IsDefaultRef(string name) => DefaultReferences.ContainsKey(name) || name.Eqi("System.Private.CoreLib");
	
	static MetaReferences() {
		//var p1 = perf.local();
		s_netDocProvider = new _NetDocumentationProvider();
		//p1.Next('d');
		
		using var db = EdDatabases.OpenRef();
		using var stat = db.Statement("SELECT * FROM ref");
		while (stat.Step()) {
			var asmName = stat.GetText(0);
			var doc = s_netDocProvider.HaveRef(asmName) ? s_netDocProvider : null;
			var r = MetadataReference.CreateFromImage(stat.GetArray<byte>(1), documentation: doc, filePath: asmName);
			DefaultReferences.Add(asmName, r);
		}
		//p1.Next('c');
		
		var auPath = folders.ThisAppBS + "Au.dll";
		DefaultReferences.Add("Au", MetadataReference.CreateFromFile(auPath, documentation: _DocumentationProvider.Create(auPath)));
		//p1.NW('a');
		
		App.Timer1sWhenVisible += UncacheOldFiles;
	}
	
	public static void UncacheOldFiles() {
		//using var p1 = perf.local();
		lock (s_cache) {
			long timeNow = Environment.TickCount64;
			foreach (var v in s_cache) v.UncacheIfNeed(timeNow);
		}
	}
	
	public MetaReferences() {
		var def = DefaultReferences;
		_refs = new List<PortableExecutableReference>(def.Count + 10);
		foreach (var v in def) _refs.Add(v.Value);
		
		DefaultRefCount = _refs.Count;
	}
	
	//public MetaReferences(FileNode fn) : this() {
	//	_test = fn.Name == "test.cs";
	//}
	//bool _test;
	
	/// <summary>
	/// Splits <i>s</i> if it is like <c>"X /properties"</c>.
	/// Called for meta r, com, pr and nuget.
	/// </summary>
	/// <param name="s1">Receives <i>s</i> or its part before <c>" /"</c>.</param>
	/// <param name="alias">Receives ALIAS if <i>s</i> is like <c>"X /alias=ALIAS"</c>, else <c>null</c>.</param>
	/// <param name="noCopy"><i>s</i> is like <c>"X.dll /noCopy"</c></param>
	/// <returns>false if invalid "/string".</returns>
	internal static bool ParseRefAliasEtc_(string name, string s, out string s1, out string alias, out bool noCopy) {
		alias = null;
		noCopy = false;
		s1 = MetaComments.SplitArgs_(s, out var s2);
		if (s2 != null) {
			foreach (var v in s2.Split('|')) {
				if (v.Starts("alias=")) {
					if (name[0] == 'p') return false; //could support for pr too, but who will use it
					alias = v[6..].NullIfEmpty_();
				} else if (v == "noCopy") {
					if (!(name[0] is 'r')) return false; //could support for pr and com too, but who will use it
					noCopy = true;
				} else return false;
			}
		}
		return true;
	}
	
	/// <summary>
	/// Finds reference assembly file, creates PortableExecutableReference and adds to the cache.
	/// Returns false if file not found.
	/// </summary>
	/// <param name="reference">
	/// Assembly filename (like "My.dll" or "My"), relative path or full path.
	/// If not full path, must be in <b>folders.ThisApp</b>; if <i>isCOM</i> - in App.Model.WorkspaceDirectory + @"\.interop\".
	/// </param>
	/// <param name="alias">Alias or null.</param>
	/// <exception cref="Exception">Eg failed to load the found file.</exception>
	/// <remarks>
	/// Loads the file but does not parse. If bad format, error later when compiling.
	/// </remarks>
	public bool Resolve(string reference, string alias, bool isCOM, bool isNuget, bool noCopy = false) {
		if (reference.Length == 0) return false;
		
		var cache = s_cache;
		lock (cache) {
			int i;
			for (i = 0; i < cache.Count; i++) {
				if (cache[i].name.Eqi(reference) && _PropEq(cache[i], alias, isCOM)) goto g1;
			}
			
			bool isFull = pathname.isFullPathExpand(reference, out string path);
			if (!isFull && isCOM) { isFull = true; path = App.Model.WorkspaceDirectory + @"\.interop\" + path; }
			if (!isFull) path = folders.ThisAppBS + path;
			path = pathname.Normalize_(path);
			if (!filesystem.exists(path, useRawPath: true).File) return false;
			//note: we don't use Microsoft.CodeAnalysis.Scripting.ScriptMetadataResolver. It is very slow, makes compiling many times slower.
			
			for (i = 0; i < cache.Count; i++) {
				if (cache[i].path.Eqi(path) && _PropEq(cache[i], alias, isCOM)) goto g1;
			}
			
			_MR k;
			if (isCOM || alias != null) k = new _MR2(reference, path, alias, isCOM, isNuget);
			else k = new _MR(reference, path, isNuget);
			
			if (!isCOM && _BadDefReplacement(k)) throw new InvalidOperationException($"Cannot use reference '{reference}'.");
			
			cache.Add(k);
			
			g1:
			_AddRef(i);
		}
		
		return true;
		
		static bool _PropEq(_MR u, string alias, bool isCOM) {
			if (u is _MR2 m2) return m2.PropEq(alias, isCOM);
			return !isCOM && alias == null;
		}
		
		void _AddRef(int iCache) {
			var k = s_cache[iCache];
			
			if (k.ignoreThis) return;
			
			var r = k.Ref;
			if (_refs.Contains(r)) return;
			
			if (k.ignoreDef) {
				var s = pathname.getNameNoExt(k.path);
				for (int i = DefaultRefCount; --i >= 0;) {
					if (_refs[i].Display.Eqi(s)) {
						_refs.RemoveAt(i);
						DefaultRefCount--;
						break;
					}
				}
			}
			
			_refs.Add(r);
			if (noCopy) (NoCopyRefs ??= []).Add(r);
		}
		
		//Returns true if k name matches one of default refs, unless k is any version of that ref.
		//In the later case sets k.ignoreDef=true if k is a newer version, else sets k.ignoreThis=true.
		bool _BadDefReplacement(_MR k) {
			var name = pathname.getNameNoExt(k.path);
			if (!DefaultReferences.TryGetValue(name, out var def)) return false;
			
			if (_hsNoRef?.Contains(name) ?? false) return false;
			//TODO3: what if eg two nuget packages (from different folders) have two different versions of that assembly?
			//	Eg from _refs already removed v6 and added v8, and now trying to add v7 or v9.
			//	Rare.
			//	Now should try to find in _refs. If not found in default area and found in nondefault area, replace the nondefault.
			
			var idR = _Identity(k.Ref); if (idR == null) return true;
			var idD = _Identity(def);
			//print.it(idR, idDef);
			if (idR.Name != idD.Name || !idR.PublicKeyToken.SequenceEqual(idD.PublicKeyToken)) return true;
			if (idR.Version > idD.Version) k.ignoreDef = true; else k.ignoreThis = true;
			return false;
			
			static AssemblyIdentity _Identity(PortableExecutableReference pe) {
				if (pe.GetMetadataNoCopy() is AssemblyMetadata am && am.GetAssembly() is PEAssembly pa) return pa.Identity;
				return null;
			}
			
			//TODO3: also for k dependencies that aren't in meta
		}
	}
	
	/// <summary>
	/// Gets the number of default references.
	/// Note: it may be less than DefaultReferences.Count (some default references can be removed).
	/// </summary>
	public int DefaultRefCount { get; private set; }
	
	/// <summary>
	/// Dlls from meta <c>r dll /noCopy</c>. Don't copy these dlls to the exeProgram's output dir.
	/// <c>null</c> if there are no such references.
	/// </summary>
	public List<PortableExecutableReference> NoCopyRefs { get; private set; }
	
	/// <summary>
	/// Removes from <b>Refs</b> all matching a wildex. Used for meta noRef.
	/// </summary>
	internal void RemoveFromRefs(string wildx) {
		wildex x = wildx;
		for (int i = _refs.Count; --i >= 0;) {
			var r = _refs[i];
			if (x.Match(r.FilePath)) {
				_refs.RemoveAt(i);
				if (i < DefaultRefCount) {
					DefaultRefCount--;
					(_hsNoRef ??= new(StringComparer.OrdinalIgnoreCase)).Add(pathname.getNameNoExt(r.Display));
				}
			}
		}
	}
	HashSet<string> _hsNoRef; //names of refs removed by meta noRef
	
	/// <summary>
	/// Extracts path from compiler error message CS0009 and removes the reference from cache.
	/// </summary>
	/// <param name="errorMessage">"Metadata file '....dll' could not be opened ..."</param>
	public static void RemoveBadRefFromCache(string errorMessage) {
		if (errorMessage.RxMatch(@"'(.+?)'", 1, out string path))
			lock (s_cache) { s_cache.RemoveAll(v => v.path.Eqi(path)); }
	}
	
	//public static void CompactCache() => _MR.CompactCache();
	
#if DEBUG
	internal static void DebugPrintCachedRefs() {
		foreach (var v in s_cache) if (v.IsCached) print.it(v.name);
	}
#endif
	
	/// <summary>
	/// Gets XML documentation for an assembly.
	/// Uses a 2-column SQLite database auto-created from XML file by <see cref="Create"/>.
	/// Not XML file directly because it uses much memory. Unless the file is small or DB fails.
	/// </summary>
	class _DocumentationProvider : DocumentationProvider {
		protected sqlite _db;
		sqliteStatement _stat;
		
		/// <summary>
		/// Creates documentation provider for assembly <i>asmPath</i>.
		/// Returns null if its xml file does not exist.
		/// Returns _DocumentationProvider if xml file is big and found or successfully created and successfully loaded database for it.
		/// Else returns _XmlFileDocumentationProvider.
		/// </summary>
		public static DocumentationProvider Create(string asmPath) {
			if (s_d.TryGetValue(asmPath, out var dp)) return dp;
			
			var xmlPath = Path.ChangeExtension(asmPath, "xml");
			if (!filesystem.GetProp_(xmlPath, out var px)) return null;
			
			if (px.size >= 10_000) {
				_Cleanup();
				var md5 = new Hash.MD5Context(); md5.Add(xmlPath.Lower());
				var dbPath = folders.ThisAppTemp + $@"refDoc\{md5.Hash.ToString()}.db";
				try {
					if (filesystem.GetProp_(dbPath, out var pd) && pd.time == px.time) {
						DateTime now = DateTime.UtcNow, created = DateTime.FromFileTimeUtc(pd.timeCreated);
						//print.it("cached", dbPath, now - created);
						if (now - created > TimeSpan.FromDays(10)) try { File.SetCreationTimeUtc(dbPath, now); } catch { } //keep cached (see _Cleanup())
					} else {
						//Debug_.Print($"creating db: {asmPath}  ->  {dbPath}");
						filesystem.delete(dbPath);
						bool isAu = asmPath.Ends("\\Au.dll", true);
						using (var d = new sqlite(dbPath)) {
							using var trans = d.Transaction();
							d.Execute("CREATE TABLE doc (name TEXT PRIMARY KEY, xml TEXT)");
							using var statInsert = d.Statement("INSERT INTO doc VALUES (?, ?)");
							
							var xr = XmlUtil.LoadElem(xmlPath);
							foreach (var e in xr.Descendants("member")) {
								var name = e.Attr("name");
								
								if (isAu) {
									//remove <remarks>. Users can press F1 and read online.
									//	In editor sometimes it takes too much space. Badly formatted because optimized for markdown.
									e.Element("remarks")?.Remove();
									e.Element("example")?.Remove();
									
									//CONSIDER: option to show short remarks; add link if long.
									
									//rejected. Too much info for "quick info". Can be distracting and annoying. Ok if would show icons instead. Or maybe 1-word links.
									//var er = e.Element("remarks");
									//var ee = e.Element("example");
									//if (er != null) {
									//	er.Value = ee != null
									//		? "More info in Remarks. Example available. Click and press F1."
									//		: "More info in Remarks. Click and press F1.";
									//	ee?.Remove();
									//} else {
									//	ee?.ReplaceWith(new XElement("remarks", "Example available. Click and press F1."));
									//}
								} else {
									e.Element("example")?.Remove();
								}
								
								using var reader = e.CreateReader();
								reader.MoveToContent();
								var xml = reader.ReadInnerXml();
								//print.it(name, xml);
								
								statInsert.BindAll(name, xml).Step();
								statInsert.Reset();
							}
							trans.Commit();
							d.Execute("VACUUM");
						}
						try { File.SetLastWriteTimeUtc(dbPath, px.TimeAsDateTime); } catch { }
					}
					var db = new sqlite(dbPath, SLFlags.SQLITE_OPEN_READONLY); //never mind: we don't dispose it on process exit
					s_d[asmPath] = dp = new _DocumentationProvider { _db = db };
					return dp;
				}
				catch (Exception ex) { Debug_.Print(ex); }
			}
			//return XmlDocumentationProvider.CreateFromFile(xmlPath); //no, need XML with root element.
			return new _XmlFileDocumentationProvider(xmlPath);
		}
		static ConcurrentDictionary<string, _DocumentationProvider> s_d = new(StringComparer.OrdinalIgnoreCase);
		
		protected internal override string GetDocumentationForSymbol(string documentationMemberID, CultureInfo preferredCulture, CancellationToken cancellationToken = default) {
			if (_db != null) {
				lock (_db) { //sometimes not in main thread
					try {
						//print.it(documentationMemberID);
						_stat ??= _db.Statement("SELECT xml FROM doc WHERE name=?");
						//if (_stat.Bind(1, documentationMemberID).Step()) return _stat.GetText(0);
						if (_stat.Bind(1, documentationMemberID).Step()) return "<r>" + _stat.GetText(0) + "</r>";
						//Roslyn bug: inheritdoc does not work with XML fragment (without single root element).
						//	Also then trows/catches exception every time.
						//	But eg XmlDocumentationProvider.CreateFromFile provider returns fragment.
						//Debug_.Print(documentationMemberID);
					}
					catch (SLException ex) { Debug_.Print(ex); }
					finally { _stat?.Reset(); }
				}
			}
			return null;
		}
		
		public override bool Equals(object obj) {
			Debug_.PrintIf(obj != this, "Equals");
			return obj == this;
		}
		
		public override int GetHashCode() {
			Debug_.Print("GetHashCode");
			return 1;
		}
		
		static void _Cleanup() {
			if (!s_cleanup) s_cleanup = true; else return;
			var now = DateTime.UtcNow;
			var month = TimeSpan.FromDays(30);
			try {
				var dir = folders.ThisAppTemp + "refDoc";
				if (!filesystem.exists(dir).Directory) { //previously the temp db files were not in refDoc (bad)
					filesystem.createDirectory(dir);
					foreach (var f in new DirectoryInfo(folders.ThisAppTemp).GetFiles("*.db")) {
						if (f.Name.Length == 35) Api.MoveFileEx(f.FullName, f.FullName.Insert(^35, @"refDoc\"), 0);
					}
				}
				foreach (var f in new DirectoryInfo(dir).GetFiles("*.db")) {
					if (f.Name.Length == 35 && now - f.CreationTimeUtc > month) Api.DeleteFile(f.FullName);
				}
			}
			catch { }
		}
		static bool s_cleanup;
	}
	
	/// <summary>
	/// Gets XML documentation for .NET runtime assemblies.
	/// Uses a 2-column SQLite database created from XML files by script "Create .NET ref and doc databases.cs".
	/// Not XML files directly because it uses about 150 MB of memory.
	/// </summary>
	class _NetDocumentationProvider : _DocumentationProvider {
		HashSet<string> _refs;
		
		public _NetDocumentationProvider() {
			try {
				_db = EdDatabases.OpenDoc(); //never mind: we don't dispose it on process exit
				if (_db.Get(out string s, "SELECT xml FROM doc WHERE name='.'")) _refs = new HashSet<string>(s.Split('\n'));
			}
			catch (SLException ex) { Debug_.Print(ex); }
		}
		
		/// <summary>
		/// Returns true if the database contains XML doc of the reference assembly.
		/// </summary>
		/// <param name="refName">Like "mscorlib" or "System.Drawing" or "Au".</param>
		public bool HaveRef(string refName) => _refs?.Contains(refName) ?? false;
	}
	static readonly _NetDocumentationProvider s_netDocProvider;
	
	/// <summary>
	/// Gets XML documentation from XML file.
	/// </summary>
	sealed class _XmlFileDocumentationProvider : XmlDocumentationProvider {
		private readonly string _filePath;
		
		public _XmlFileDocumentationProvider(string filePath) {
			_filePath = filePath;
		}
		
		protected override Stream GetSourceStream(CancellationToken cancellationToken)
			=> new FileStream(_filePath, FileMode.Open, FileAccess.Read);
		
		protected override string GetDocumentationForSymbol(string documentationMemberID, CultureInfo preferredCulture, CancellationToken cancellationToken = default) {
			var s = base.GetDocumentationForSymbol(documentationMemberID, preferredCulture, cancellationToken);
			//print.it(documentationMemberID, s);
			if (!s.NE()) s = "<r>" + s + "</r>";
			return s;
		}
		
		public override bool Equals(object obj) => obj == this;
		
		public override int GetHashCode() => 1;
	} //copied from Roslyn's private FileBasedXmlDocumentationProvider (XmlDocumentationProvider.CreateFromFile returns it) and modified
}


================================================
FILE: Au.Editor/Compiler/RecentTT.cs
================================================
namespace LA;

/// <summary>
/// Logs started/ended tasks and trigger actions for menu Run > Recent.
/// </summary>
static class RecentTT {
	record _Item {
		public long id;
		public FileNode file;
		public int line;
		public int repeated;
		public long startTime;
		public long endTime;
		public string trigger;
		public bool failed;
	}
	
	static readonly List<_Item> s_a = new();
	
	public static void TaskEvent(bool started, RunningTask t, int exitCode = 0) {
		Api.GetSystemTimeAsFileTime(out long time);
		if (started) _Started(t.taskId, t.f, 0, time, null);
		else _Ended(t.taskId, time, exitCode < 0);
	}
	
	public static void TriggerEvent(PrintServerMessage m) {
		string s = m.Text, z = m.Caller;
		//z format: "id\0sourceFilePath\0line1based"
		//	id identifies that action instance in time (start/end/fail events have same id).
		
		z.ToInt(out long id, 0, out int i); i++;
		
		int j = z.IndexOf('\0', i);
		var fn = App.Model.FindByFilePath(z[i..j], FNFind.CodeFile);
		if (fn == null) return; //deleted item?
		int line = z.ToInt(++j);
		
		if (s[1] == 'S') _Started(id, fn, line, m.TimeUtc, s[3..]);
		else _Ended(id, m.TimeUtc, s[1] == 'F');
	}
	
	static void _Started(long id, FileNode fn, int line, long time, string trigger) {
		//remove oldest ended items
		if (s_a.Count > 250) {
			var t1 = Environment.TickCount64;
			if (t1 - s_shrinkTime > 1000) {
				s_shrinkTime = t1;
				var ar = new List<_Item>(); //running
				int to = s_a.Count / 4;
				for (int i = 0; i < to; i++) if (s_a[i].endTime == 0) ar.Add(s_a[i]);
				s_a.RemoveRange(0, to);
				s_a.InsertRange(0, ar);
			}
		}
		
		//join multiple same items if started/ended frequently, eg an auto-repeated hotkey
		//CONSIDER: join when ends. To avoid joining failed with succeeded and running with ended.
		//CONSIDER: in main menu display only dictinct. Display multiple run instances (start/end time, failed) in submenu or tooltip.
		_Item last = null;
		for (int i = s_a.Count; --i >= 0;) {
			var v = s_a[i];
			if (v.endTime == 0) continue;
			if (time - v.endTime > 10_000_000L * 70) break; //70 s
			if (v.file == fn && v.line == line && v.trigger == trigger && !v.failed) {
				last = v;
				break;
			}
		}
		if (last != null) {
			//print.it("same");
			last.id = id; last.startTime = time; last.endTime = 0; last.repeated++;
		} else {
			s_a.Add(new() { id = id, file = fn, line = line, startTime = time, trigger = trigger });
		}
	}
	static long s_shrinkTime;
	
	static void _Ended(long id, long time, bool failed) {
		for (int i = s_a.Count; --i >= 0;) if (s_a[i].id == id) {
				var k = s_a[i];
				k.endTime = time;
				k.failed = failed;
				break;
			}
	}
	
	public static void Clear() {
		s_a.Clear();
	}
	
	public static void Show() {
		if (s_a.Count == 0) return;
		bool highContrast = System.Windows.SystemParameters.HighContrast;
		var m = new popupMenu();
		for (int i = s_a.Count; --i >= 0;) {
			var v = s_a[i];
			var s = $"{v.trigger ?? v.file.DisplayName}\t{_Time(v.startTime)} - {_Time(v.endTime)}";
			if (v.repeated > 0) s = $"{s} ({v.repeated + 1} times)";
			var k = m.Add(s, v.trigger != null ? EdIcons.Trigger : v.file.IconString);
			k.Tag = v;
			if (highContrast) {
				if (v.failed) k.TextColor = 0xff0000;
			} else {
				if (v.endTime == 0) k.TextColor = 0x0000ff; else if (v.failed) k.TextColor = 0xff0000;
			}
		}
		m.Show();
		if (m.Result?.Tag is _Item r) App.Model.OpenAndGoTo(r.file, r.line - 1);
		
		static string _Time(long t) {
			if (t == 0) return null;
			return DateTime.FromFileTimeUtc(t).ToLocalTime().ToString("dd H:mm:ss");
		}
	}
}


================================================
FILE: Au.Editor/Compiler/Run task.cs
================================================
//#define TEST_STARTUP_SPEED

using Au.Controls;

//CONSIDER: for ifRunning use mutex. Release mutex as soon as script ends, ie before the process ends (need some time to unload .NET).
//	Maybe then could repeatedly start short tasks more frequently.

namespace LA;

static class CompileRun {
	/// <summary>
	/// Compiles and/or executes C# file or its project.
	/// If <paramref name="run"/> is false, returns 1 if compiled, 0 if failed to compile.
	/// Else returns: process id if started now, 0 if failed, (int)script.RunResult_.deferred if scheduled to run later, (int)script.RunResult_.editorThread if runs in editor thread.
	/// </summary>
	/// <param name="run">If true, compiles if need and executes. If false, always compiles and does not execute.</param>
	/// <param name="f">C# file. Does nothing if null or not C# file.</param>
	/// <param name="args">To pass to Main.</param>
	/// <param name="noDefer">Don't schedule to run later.</param>
	/// <param name="wrPipeName">Pipe name for script.writeResult.</param>
	/// <param name="runFromEditor">Starting from the Run button or menu Run command. Can restart etc.</param>
	/// <param name="ifRunning">If not null, overrides meta ifRunning.</param>
	/// <param name="debugAttach">Will attach the debugger.</param>
	/// <remarks>
	/// Saves editor text if need.
	/// Calls <see cref="Compiler.Compile"/>.
	/// Must be always called in the main UI thread, because calls its file model functions.
	/// </remarks>
	public static int CompileAndRun(bool run, FileNode f, string[] args = null, bool noDefer = false, string wrPipeName = null, bool runFromEditor = false, MCIfRunning? ifRunning = null, Func<int, bool> debugAttach = null) {
#if TEST_STARTUP_SPEED
		args = new string[] { perf.ms.ToString() }; //and in script use this code: print.it(perf.ms-Convert.ToInt64(args[0]));
#endif
		
		App.Model.Save.TextNowIfNeed(onlyText: true);
		App.Model.Save.WorkspaceNowIfNeed(); //because the script may kill editor, eg if runs in editor thread
		
		if (!Compile(run, ref f, out var r)) return 0;
		if (!run) return 1;
		
		if (r.role == MCRole.editorExtension) {
			if (debugAttach != null) { print.it("Cannot debug scripts with role editorExtension."); return 0; }
			
			EditorExtension.Run_(r.file, args, handleExceptions: true);
			return (int)script.RunResult_.editorThread;
		}
		
		if (ifRunning != null) r.ifRunning = ifRunning.Value;
		
		return App.Tasks.RunCompiled(f, r, args, noDefer, wrPipeName, runFromEditor: runFromEditor, debugAttach: debugAttach);
	}
	
	/// <summary>
	/// Gets correct file for run or compile (project-main etc), and compiles.
	/// </summary>
	/// <param name="forRun"></param>
	/// <param name="f">Input: any file or null. Output: main code file to run or compile; if <i>forRun</i>, it's an executable code file.</param>
	/// <param name="r">Compilation results.</param>
	/// <returns>false if can't get correct code file or if failed to compile.</returns>
	public static bool Compile(bool forRun, ref FileNode f, out Compiler.CompResults r) {
		r = null;
		if (f == null) return false;
		if (f.FindProject(out var projFolder, out var projMain)) f = projMain;
		
		//can be set to run other script instead.
		//	Useful for library projects. Single files have other alternatives - move to a script project or move code to a script file.
		if (forRun && f.TestScript is { } f2) {
			if (!f2.FindProject(out projFolder, out projMain)) f = f2;
			else if (projMain != f) f = projMain;
			else { print.it($"<>The test script {f2.SciLink()} cannot be in the project folder {projFolder.SciLink()}"); return false; }
		}
		
		if (!f.IsCodeFile) return false;
		
		bool ok = Compiler.Compile(forRun ? CCReason.Run : CCReason.CompileAlways, out r, f, projFolder);
		
		if (forRun && r.role is MCRole.classFile or MCRole.classLibrary) { //info: if classFile, compiler sets r.role and returns false (does not compile)
			_OnRunClassFile(f, projFolder);
			return false;
		}
		
		return ok;
	}
	
	public static void RunWpfPreview(FileNode f, Func<CanCompileArgs, bool> canCompile) {
		if (f.FindProject(out var projFolder, out var projMain)) f = projMain;
		
		//If f is a class file, run it as a script.
		//	Ignore its test script. For a library it wouldn't work. For a simple projectless class file usually don't need.
		
		bool ok = Compiler.Compile(CCReason.WpfPreview, out var r, f, projFolder, canCompile: canCompile);
		if (!ok) return;
		
		int pid = App.Tasks.RunCompiled(f, r, new string[] { "WPF_PREVIEW", s_wpfPreview.pid.ToS(), s_wpfPreview.time.ToS() });
		Api.GetSystemTimeAsFileTime(out long time);
		s_wpfPreview = (pid, time);
	}
	static (int pid, long time) s_wpfPreview;
	
	static void _OnRunClassFile(FileNode f, FileNode projFolder) {
		if (!s_isRegisteredLinkRCF) { s_isRegisteredLinkRCF = true; SciTags.AddCommonLinkTag("+runClass", _SciLink_RunClassFile); }
		var ids = f.IdStringWithWorkspace;
		var s2 = projFolder != null || f.Name.Eqi("global.cs") ? "" : $" or project (<+runClass 2|{ids}>create<>). Or <+runClass 1|{ids}>change<> file type or role";
		print.it($"<>Cannot run '{f.Name}'. It is a <help editor/Class files, projects>class file<>. Need a test script (<+runClass 3|{ids}>create<>){s2}.");
	}
	
	static void _SciLink_RunClassFile(string s) {
		int action = s.ToInt(); //1 change role, 2 create Script project, 3 create new test script and set "run" attribute
		var f = App.Model.Find(s[2..]); if (f == null) return;
		if (action == 1) { //change role
			if (!App.Model.SetCurrentFile(f)) return;
			App.Model.Properties();
		} else {
			FileNode f2;
			if (action == 2) { //create project
				if (!_NewItem(out f2, @"New project\@Script")) return;
				f.FileMove(new(f2, FNInsert.After));
			} else { //create test script
				if (!_NewItem(out f2, "Script.cs", "test " + f.Name)) return;
				f.TestScript = f2;
			}
			
			//Creates new item above f or f's project folder.
			bool _NewItem(out FileNode ni, string template, string name = null) {
				bool isProject = f.FindProject(out var target, out _);
				if (!isProject) target = f;
				
				//extract code from /// <example>
				string example = null;
				if (f.GetCurrentText(out var s) && s.RxMatch(@"(?m)^\h*/// *<example>\h*\R((\h*/// ?.*\R)+?)^\h*/// *</example>", 1, out RXGroup g)) {
					if (s.RxMatch(@"(?m)^\h*/// *<code>(<!\[CDATA\[)?\s+((\h*/// ?.*\R)+?)^\h*/// *(?(1)\]\]>)</code>", 2, out g, range: g)) {
						example = g.Value.RxReplace(@"(?m)^\h*/// ?", "");
					}
				}
				
				var text = new NewFileText();
				if (action == 2) {
					text.text = example ?? "//Class1.Function1();\r\n";
				} else {
					text.meta = $"{(isProject ? "pr" : "c")} {f.ItemPath};";
					text.text = example ?? $"//{(isProject ? "Library." : "")}Class1.Function1();\r\n";
				}
				
				ni = App.Model.NewItem(template, new(target, FNInsert.Before), name, text: text);
				return ni != null;
			}
		}
	}
	static bool s_isRegisteredLinkRCF;
}

/// <summary>
/// A running script task.
/// Starts/ends task, watches/notifies when ended.
/// </summary>
class RunningTask : ITreeViewItem {
	volatile WaitHandle _process;
	public readonly FileNode f;
	public readonly int taskId;
	public readonly int processId;
	
	static int s_taskId;
	
	public RunningTask(FileNode f, WaitHandle hProcess, int processId) {
		taskId = ++s_taskId;
		this.f = f;
		_process = hProcess;
		this.processId = processId;
		
		RecentTT.TaskEvent(true, this);
		
		RegisteredWaitHandle rwh = null;
		rwh = ThreadPool.RegisterWaitForSingleObject(_process, (context, wasSignaled) => {
			rwh.Unregister(_process);
			var p = _process; _process = null;
			Api.GetExitCodeProcess(p.SafeWaitHandle.DangerousGetHandle(), out int ec);
			p.Dispose();
			App.Tasks.TaskEnded1(taskId, ec);
		}, null, -1, true);
	}
	
	/// <summary>
	/// False if task is already ended or still not started.
	/// </summary>
	public bool IsRunning => _process is { } p && Api.WaitForSingleObject(p.SafeWaitHandle.DangerousGetHandle(), 0) == Api.WAIT_TIMEOUT;
	
	/// <summary>
	/// Ends this task (kills process), if running.
	/// Returns false if fails, unlikely.
	/// </summary>
	/// <param name="onProgramExit">Called on program exit. Returns true even if fails. Does not wait.</param>
	public bool End(bool onProgramExit) {
		if (_process is { } p) {
			var h = p.SafeWaitHandle.DangerousGetHandle();
			
			int pid = process.processIdFromHandle(h);
			if (pid != 0) {
				if (Panels.Debug?.EndIfDebugging(pid) == true) return true;
				
				//let it call Environment.Exit. It removes tray icons etc.
				var w1 = wnd.findFast(pid.ToS(), script.c_auxWndClassName, messageOnly: true);
				if (!w1.Is0 && w1.Post(Api.WM_CLOSE)) {
					if (0 == Api.WaitForSingleObject(h, 1000)) return true;
				}
			}
			
			if (_process != null) {
				bool ok = Api.TerminateProcess(h, -1);
				if (onProgramExit) return true;
				if (ok) {
					//TerminateProcess is async. Usually the process ends after several ms.
					if (Api.WaitForSingleObject(h, 500) == Api.WAIT_TIMEOUT) Debug_.Print("process not terminated");
				} else {
					//ERROR_ACCESS_DENIED when the process is ending
					var s = lastError.message;
					if (Api.WaitForSingleObject(h, 500) == Api.WAIT_TIMEOUT) { Debug_.Print(s); return false; }
				}
			}
		}
		return true;
		//TODO3: release pressed keys.
	}
	
	#region ITreeViewItem
	
	string ITreeViewItem.DisplayText => f.DisplayName;
	
	object ITreeViewItem.Image => f.Image;
	
	//TVCheck ITreeViewItem.CheckState { get; }
	
	//bool ITreeViewItem.IsDisabled { get; }
	
	//bool ITreeViewItem.IsBold { get; }
	
	//bool ITreeViewItem.IsSelectable { get; }
	
	//int ITreeViewItem.Color { get; }
	
	//int ITreeViewItem.TextColor => 0xff0000;
	
	#endregion
}

/// <summary>
/// Manages running script tasks.
/// </summary>
class RunningTasks {
	class _WaitingTask {
		public readonly FileNode f;
		public readonly Compiler.CompResults r;
		public readonly string[] args;
		
		public _WaitingTask(FileNode f, Compiler.CompResults r, string[] args) {
			this.f = f; this.r = r; this.args = args;
		}
	}
	
	readonly List<RunningTask> _a = new();
	readonly List<_WaitingTask> _q = new(); //not Queue because may need to remove item at any index
	bool _updateUI;
	volatile bool _disposed;
	
	/// <summary>
	/// Gets running tasks.
	/// Order: the last started is the first in the list.
	/// </summary>
	public IReadOnlyList<RunningTask> Items => _a;
	
	public RunningTasks() {
		App.Timer1sOr025s += _TimerUpdateUI;
	}
	
	public void OnWorkspaceClosed() {
		bool onExit = App.Loaded >= AppState.Unloading;
		
		if (onExit) {
			_disposed = true;
			App.Timer1sOr025s -= _TimerUpdateUI;
		}
		
		for (int i = _a.Count; --i >= 0;) {
			_EndTask(_a[i], onExit: onExit);
		}
		
		if (onExit) _a.Clear();
		_q.Clear();
		
		if (!onExit) _UpdatePanels();
	}
	
	/// <summary>
	/// Adds a started task to the 'running' list.
	/// Must be called in the main thread.
	/// </summary>
	/// <param name="rt"></param>
	void _Add(RunningTask rt) {
		Debug.Assert(!_disposed);
		_a.Insert(0, rt);
		_updateUI = true;
	}
	
	/// <summary>
	/// Called in a threadpool thread when a task process exited.
	/// </summary>
	/// <param name="taskId"></param>
	internal void TaskEnded1(int taskId, int exitCode) {
		if (_disposed) return;
		CommandLine.MsgWnd.Post(WM_TASK_ENDED, taskId, exitCode);
	}
	
	/// <summary>
	/// When task ended, this message is posted to CommandLine.MsgWnd, with wParam=taskId.
	/// </summary>
	public const int WM_TASK_ENDED = Api.WM_USER + 900;
	
	/// <summary>
	/// Removes an ended task from the 'running' list. If a task is queued and can run, starts it.
	/// When task ended, TaskEnded1 posts message WM_TASK_ENDED with task id in wParam to the message window, which calls this function.
	/// </summary>
	internal void TaskEnded2(nint wParam, nint lParam) {
		if (_disposed) return;
		
		int taskId = (int)wParam;
		int i = _Find(taskId);
		if (i < 0) { Debug_.Print("not found. It's OK, but should be very rare, mostly with 1-core CPU."); return; }
		
		RecentTT.TaskEvent(false, _a[i], (int)lParam);
		_a.RemoveAt(i);
		
		for (int j = _q.Count; --j >= 0;) {
			var t = _q[j];
			if (_CanRunNow(t.f, t.r, out _)) {
				_q.RemoveAt(j);
				RunCompiled(t.f, t.r, t.args, ignoreLimits: true);
				break;
			}
		}
		
		_updateUI = true;
	}
	
	void _TimerUpdateUI() {
		if (!_updateUI) return;
		if (!App.Hmain.IsVisible) return;
		_UpdatePanels();
	}
	
	void _UpdatePanels() {
		_updateUI = false;
		Panels.Tasks.UpdateList();
	}
	
	/// <summary>
	/// Returns true if one or more tasks of file f are running.
	/// </summary>
	/// <param name="f">Can be null.</param>
	public bool IsRunning(FileNode f) => null != _GetRunning(f);
	
	RunningTask _GetRunning(FileNode f) {
		for (int i = 0; i < _a.Count; i++) {
			var r = _a[i];
			if (r.f == f && r.IsRunning) return r;
		}
		return null;
	}
	
	//currently not used
	///// <summary>
	///// Returns all running files.
	///// For files that have multiple tasks is added 1 item in the list.
	///// Each time creates new list; caller can modify it.
	///// </summary>
	//public List<FileNode> GetRunningFiles() {
	//	var a = new List<FileNode>(_a.Count);
	//	for(int i = 0; i < _a.Count; i++) {
	//		var t = _a[i];
	//		if(!a.Contains(t.f)) a.Add(t.f);
	//	}
	//	return a;
	//}
	
	public RunningTask TaskFromProcessId(int processId) {
		foreach (var v in _a) if (v.processId == processId) return v;
		return null;
	}
	
	/// <summary>
	/// Ends all tasks of file f.
	/// Returns true if was running.
	/// </summary>
	/// <param name="f">Can be null.</param>
	/// <param name="exceptProcessId"></param>
	public bool EndTasksOf(FileNode f, int exceptProcessId = 0) {
		bool wasRunning = false;
		for (int i = _a.Count; --i >= 0;) {
			var r = _a[i];
			if (r.f != f || !r.IsRunning) continue;
			if (exceptProcessId != 0 && r.processId == exceptProcessId) continue;
			_EndTask(r);
			wasRunning = true;
		}
		return wasRunning;
	}
	
	/// <summary>
	/// Ends a task, if still running.
	/// </summary>
	public void EndTask(RunningTask rt) {
		if (_a.Contains(rt)) _EndTask(rt);
	}
	
	bool _EndTask(RunningTask rt, bool onExit = false) {
		Debug.Assert(_a.Contains(rt));
		return rt.End(onExit);
	}
	
	bool _CanRunNow(FileNode f, Compiler.CompResults r, out RunningTask running, bool runFromEditor = false) {
		running = null;
		if (r.ifRunning == MCIfRunning.run || (r.ifRunning == MCIfRunning.run_restart && !runFromEditor)) return true;
		running = _GetRunning(f);
		return running == null;
	}
	
	//rejected: use shared memory instead of pipe. Tested, same speed.
	
	/// <summary>
	/// Executes the compiled assembly in new process.
	/// Returns: process id if started now, 0 if failed, (int)script.RunResult_.deferred if scheduled to run later.
	/// </summary>
	/// <param name="f"></param>
	/// <param name="r"></param>
	/// <param name="args"></param>
	/// <param name="noDefer">Don't schedule to run later. If cannot run now, just return 0.</param>
	/// <param name="wrPipeName">Pipe name for script.writeResult.</param>
	/// <param name="ignoreLimits">Don't check whether the task can run now.</param>
	/// <param name="runFromEditor">Starting from the Run button or menu Run command. Can restart etc.</param>
	/// <param name="debugAttach">Will attach the debugger.</param>
	public unsafe int RunCompiled(FileNode f, Compiler.CompResults r, string[] args,
		bool noDefer = false, string wrPipeName = null, bool ignoreLimits = false, bool runFromEditor = false, Func<int, bool> debugAttach = null) {
		
		g1:
		if (!ignoreLimits && !_CanRunNow(f, r, out var running, runFromEditor)) {
			var ifRunning = r.ifRunning;
			if (!ifRunning.Has(MCIfRunning._norestartFlag) && ifRunning != MCIfRunning.restart) {
				if (runFromEditor) ifRunning = MCIfRunning.restart;
				else if (ifRunning == MCIfRunning.end_restart) ifRunning = MCIfRunning.end;
				else ifRunning |= MCIfRunning._norestartFlag;
			}
			//print.it(same, ifRunning);
			switch (ifRunning) {
			case MCIfRunning.cancel:
				break;
			case MCIfRunning.wait when !noDefer:
				_q.Insert(0, new _WaitingTask(f, r, args));
				return (int)script.RunResult_.deferred;
			case MCIfRunning.restart when _EndTask(running):
				goto g1;
			case MCIfRunning.end:
				_EndTask(running);
				break;
			default: //warn
				print.it($"<>Cannot start {f.SciLink()} because it is running. You may want to <+properties {f.IdStringWithWorkspace}>change<> <c green>ifRunning<>.");
				break;
			}
			return 0;
		}
		
		_SpUac uac = _SpUac.normal; int preIndex = 0;
		if (!uacInfo.isUacDisabled) {
			//info: to completely disable UAC on Win7: gpedit.msc/Computer configuration/Windows settings/Security settings/Local policies/Security options/User Account Control:Run all administrators in Admin Approval Mode/Disabled. Reboot.
			//note: when UAC disabled, if our uac is System, IsUacDisabled returns false (we probably run as SYSTEM user). It's OK.
			var IL = uacInfo.ofThisProcess.IntegrityLevel;
			if (r.uac == MCUac.inherit) {
				switch (IL) {
				case UacIL.High: preIndex = 1; break;
				case UacIL.UIAccess: uac = _SpUac.uiAccess; preIndex = 2; break;
				}
			} else {
				switch (IL) {
				case UacIL.Medium:
				case UacIL.UIAccess:
					if (r.uac == MCUac.admin) uac = _SpUac.elevate;
					break;
				case UacIL.High:
					if (r.uac == MCUac.user
						&& uacInfo.ofThisProcess.Elevation == UacElevation.Full //eg on Azure VM there are no Medium IL processes (all normal processes are High), and Elevation returns Default, although UAC not turned off
						) uac = _SpUac.userFromAdmin;
					break;
				case UacIL.Low:
				case UacIL.Untrusted:
				case UacIL.Unknown:
				//break;
				case UacIL.System:
				case UacIL.Protected:
					print.it($"<>Cannot run {f.SciLink()}. Meta comment option <c green>uac {r.uac}<> cannot be used when the UAC integrity level of this process is {IL}. Supported levels are Medium, High and uiAccess.");
					return 0;
					//info: cannot start Medium IL process from System process. Would need another function. Never mind.
				}
				if (r.uac == MCUac.admin) preIndex = 1;
			}
		}
		
		bool exeProgram = r.notInCache, usePreloaded = false, debugger = debugAttach != null;
		_Preloaded pre = null;
		string exeFile, argsString;
		
		//rejected: 32-bit miniProgram. The task exe has been removed because of AV false positives. And rarely used. Can use exeProgram instead.
		
		if (exeProgram) { //meta role exeProgram
			exeFile = Compiler.DllNameToExeName(r.file, default);
			argsString = args == null ? null : StringUtil.CommandLineFromArray(args);
		} else {
			if (debugger) {
				if (uac == _SpUac.elevate) { print.it("Cannot debug this script. Remove /*/ uac admin; /*/, or run LA as admin."); return 0; }
				//Don't use preloaded. It would load some assemblies before 'attach debugger' and then debugger cannot disable JIT optimizations.
			} else if (usePreloaded = r.flags.Has(MiniProgram_.MPFlags.Preloaded) && uac != _SpUac.elevate) {
				pre = s_preloaded[preIndex] ??= new _Preloaded(preIndex);
			}
			pre ??= new _Preloaded(100); //temporary, just to create pipe with unique name and reuse preloaded launch code
			
			exeFile = folders.ThisAppBS + $"Au.Task-{(osVersion.isArm64Process ? "arm" : "x64")}.exe";
			argsString = pre.pipeName;
		}
		
		int pid = 0; WaitHandle hProcess = null; bool disconnectPipe = false;
		try {
			bool preloadedProcessExists = false;
			if (usePreloaded) {
				var pp = pre.hProcess;
				preloadedProcessExists = pp != null && Api.WAIT_TIMEOUT == Api.WaitForSingleObject(pp.SafeWaitHandle.DangerousGetHandle(), 0);
				if (preloadedProcessExists) {
					hProcess = pp; pid = pre.pid;
					pre.hProcess = null; pre.pid = 0;
				} else if (pp != null) { //preloaded process existed but somehow ended
					pp.Dispose();
					pre.hProcess = null; pre.pid = 0;
				}
			}
			if (!preloadedProcessExists) {
				(pid, hProcess) = _StartProcess(uac, exeFile, argsString, wrPipeName, r.notInCache, runFromEditor, f.Id, debugAttach, r.flags.Has(MiniProgram_.MPFlags.RedirectConsole));
				if (pid == 0) return 0; //failed to start debugging
			}
			Api.AllowSetForegroundWindow(pid);
			
			if (!exeProgram) {
				var f1 = r.flags;
				if (runFromEditor) f1 |= MiniProgram_.MPFlags.FromEditor;
				if (App.IsPortable) f1 |= MiniProgram_.MPFlags.IsPortable;
				if (!preloadedProcessExists) f1 &= ~MiniProgram_.MPFlags.Preloaded;
				byte[] taskParams = Serializer_.SerializeWithSize(r.name, r.file, (int)f1, args, wrPipeName, (string)folders.Workspace, (int)f.Id, process.thisProcessId, (int)CommandLine.MsgWnd);
				
				var o = new Api.OVERLAPPED { hEvent = pre.overlappedEvent };
				if (!Api.ConnectNamedPipe(pre.hPipe, &o)) {
					int e = lastError.code;
					if (e != Api.ERROR_PIPE_CONNECTED) {
						if (e != Api.ERROR_IO_PENDING) throw new AuException(e);
						var ha = stackalloc IntPtr[2] { pre.overlappedEvent, hProcess.SafeWaitHandle.DangerousGetHandle() };
						//perf.shared.Next('r');
						int wr = Api.WaitForMultipleObjectsEx(2, ha, false, -1, false);
						if (wr != 0) { Api.CancelIo(pre.hPipe); throw new AuException("*start task. Preloaded task process ended"); } //note: if fails when 32-bit process, rebuild solution with platform x86
						disconnectPipe = true;
						if (!Api.GetOverlappedResult(pre.hPipe, ref o, out _, false)) throw new AuException(0);
					}
				}
				
				if (!Api.WriteFile2(pre.hPipe, taskParams, out _)) throw new AuException(0);
				Api.DisconnectNamedPipe(pre.hPipe); disconnectPipe = false;
				
				//start preloaded process for next task. Let it wait for pipe connection.
				if (usePreloaded) {
					try { (pre.pid, pre.hProcess) = _StartProcess(uac, exeFile, argsString, null, r.notInCache, false, 0, null, false); }
					catch (Exception ex) { Debug_.Print(ex); }
				}
			}
		}
		catch (Exception ex) {
			print.it(ex);
			if (disconnectPipe) Api.DisconnectNamedPipe(pre.hPipe);
			hProcess?.Dispose();
			return 0;
		}
		finally {
			if (!usePreloaded) pre?.Dispose();
		}
		
		var rt = new RunningTask(f, hProcess, pid);
		_Add(rt);
		return pid;
	}
	
	class _Preloaded {
		public readonly string pipeName;
		public readonly Handle_ hPipe;
		public readonly Handle_ overlappedEvent;
		public WaitHandle hProcess;
		public int pid;
		
		public _Preloaded(int index) {
			pipeName = $@"\\.\pipe\Au.Task-{Api.GetCurrentProcessId()}-{index}";
			hPipe = Api.CreateNamedPipe(pipeName,
				Api.PIPE_ACCESS_OUTBOUND | Api.FILE_FLAG_OVERLAPPED, //use async pipe because editor would hang if task process exited without connecting. Same speed.
				Api.PIPE_TYPE_MESSAGE | Api.PIPE_REJECT_REMOTE_CLIENTS,
				1, 0, 0, 0, null);
			overlappedEvent = Api.CreateEvent(false);
		}
		
		public void Dispose() {
			hPipe.Dispose();
			overlappedEvent.Dispose();
		}
	}
	//static _Preloaded[] s_preloaded = new _Preloaded[6]; //user, admin, uiAccess, user32, admin32, uiAccess32
	static _Preloaded[] s_preloaded = new _Preloaded[3]; //user, admin, uiAccess
	
	/// <summary>
	/// How _StartProcess must start process.
	/// Note: it is not UAC IL of the process.
	/// </summary>
	enum _SpUac {
		normal, //start process of same IL as this process, but without uiAccess. It is how CreateProcess API works.
		elevate, //start admin process from this user or uiAccess process
		userFromAdmin, //start user process from this admin process
		uiAccess, //start uiAccess process from this uiAccess process
	}
	
	/// <summary>
	/// Starts task process.
	/// Returns (processId, processHandle). Throws if failed. Returns 0 if failed to attach debugger.
	/// </summary>
	static unsafe (int pid, WaitHandle hProcess) _StartProcess(_SpUac uac, string exeFile, string args, string wrPipeName, bool exeProgram, bool runFromEditor, uint idMain, Func<int, bool> debugAttach, bool redirectConsoleInExe) {
		if (s_inSP) throw new AuException("_StartProcess: can't reenter"); //starting the debugger. See wait.forHandle below. Very rare, never mind.
		s_inSP = true;
		try {
			(int pid, WaitHandle hProcess) r;
			string cwd;
			
			if (exeProgram) {
				if (s_cwdExe == null) {
					//Pass this working directory to let the exe know it was launched from editor.
					//	Then its AppModuleInit_ will read from shared memory and set the event.
					//	Also AppHost uses this to find portable .NET runtime.
					//There are no other ways to pass data when using shellexecute(runas) when cannot use command line args.
					//This empty hidden directory is created by the setup program. This code creates it if missing.
					cwd = folders.ThisApp.Path + "\\Roslyn\\.exeProgram";
					if (!filesystem.exists(cwd).Directory) {
						filesystem.createDirectory(cwd);
						File.SetAttributes(cwd, FileAttributes.Directory | FileAttributes.Hidden);
					}
					s_cwdExe = cwd;
					s_event1 = Api.CreateEvent2(default, true, false, "Au.event.exeProgram.1");
				} else {
					cwd = s_cwdExe;
					Api.ResetEvent(s_event1);
				}
				
				var p = &SharedMemory_.Ptr->script;
				p->pidEditor = process.thisProcessId;
				p->hwndMsg = (int)CommandLine.MsgWnd;
				p->idMainFile = idMain;
				int flags = 0;
				if (runFromEditor) flags |= 2;
				if (App.IsPortable) flags |= 4;
				if (wrPipeName != null) { flags |= 8; p->pipe = wrPipeName; }
				if (redirectConsoleInExe) flags |= 16;
				p->flags = flags;
				p->workspace = folders.Workspace;
			} else cwd = folders.ThisApp;
			
			if (uac == _SpUac.elevate) {
				var k = run.it(exeFile, args, RFlags.Admin | RFlags.NeedProcessHandle, cwd);
				r = (k.ProcessId, k.ProcessHandle);
				//note: don't try to start task without UAC consent. It is not secure.
				//	Normally editor runs as admin in admin user account, and don't need to go through this.
			} else {
				var ps = new ProcessStarter_(exeFile, args, cwd, rawExe: true);
				
				if (debugAttach != null) ps.si.dwXCountChars = 1703529821; //let the process wait for "debugger attached" event
				
				var need = ProcessStarter_.Result.Need.WaitHandle;
				var psr = uac == _SpUac.userFromAdmin
					? ps.StartUserIL(need)
					: ps.Start(need, inheritUiaccess: uac == _SpUac.uiAccess);
				r = (psr.pid, psr.waitHandle);
				
				if (debugAttach != null) {
					if (!debugAttach(psr.pid)) {
						Api.TerminateProcess(psr.waitHandle.SafeWaitHandle.DangerousGetHandle(), 0);
						psr.waitHandle.Dispose();
						return default;
					}
				}
			}
			
			if (exeProgram) {
				nint hProc = r.hProcess.SafeWaitHandle.DangerousGetHandle();
				if (debugAttach != null) {
					//can't block, because need to communicate with netcoredbg.exe
					wait.forHandle(0, WHFlags.DoEvents, s_event1, hProc);
				} else { //better low-level than wait.forHandle with flags 0
					nint* ha = stackalloc nint[2] { s_event1, hProc };
					Api.WaitForMultipleObjectsEx(2, ha, false, -1, false);
				}
				
				Api.ResetEvent(s_event1);
			}
			
			return r;
		}
		finally { s_inSP = false; }
	}
	static IntPtr s_event1;
	static string s_cwdExe;
	static bool s_inSP;
	
	int _Find(int taskId) {
		for (int i = 0; i < _a.Count; i++) {
			if (_a[i].taskId == taskId) return i;
		}
		return -1;
	}
	
	public void OnWM_DISPLAYCHANGE() {
		//End preloaded processes. Else they may use wrong DPI.
		foreach (var v in s_preloaded) {
			if (v?.hProcess == null) continue;
			if (!Api.TerminateProcess(v.hProcess.SafeWaitHandle.DangerousGetHandle(), 0)) return;
			v.hProcess.Dispose();
			v.hProcess = null;
			v.pid = 0;
		}
	}
}


================================================
FILE: Au.Editor/Compiler/TestInternal.cs
================================================
namespace LA;

static class TestInternal {
	static HashSet<(string user, string target)> _hsCompiler = new(), _hsCi = new(), _hsRefs = new();
	static bool _compiling, _findingRefs;
	
	static TestInternal() {
		//Used by everything except 'find references'.
		//Called from any thread.
		RoslynMod.TestInternal.IsInternalsVisibleCallback = static (string thisName, string toName) => {
			//print.it("IsInternalsVisibleCallback", thisName, toName);
			if (_compiling) return _hsCompiler.Contains((toName, thisName));
			if (_findingRefs) return _hsRefs.Contains((toName, thisName));
			lock (_hsCi) return _hsCi.Contains((toName, thisName));
		};
		
		//Used by 'find references'. Not by 'find implementations'.
		//Called from any thread.
		RoslynMod.TestInternal.AppendInternalsVisibleCallback += static (string thisName, HashSet<string> toNames) => {
			foreach (var v in _hsRefs) if (v.target == thisName) toNames.Add(v.user);
			//print.it("AppendInternalsVisibleCallback", thisName, toNames);
		};
	}
	
	public static void CompilerStart(string asmName, string[] testInternals) {
		//print.it("CompilerStart", asmName, testInternals);
		Debug.Assert(!_compiling);
		foreach (var v in testInternals) _hsCompiler.Add((asmName, v));
		_compiling = true;
	}
	
	public static void CompilerEnd() {
		//print.it("CompilerEnd");
		_compiling = false;
		_hsCompiler.Clear();
	}
	
	public static void CiAdd(string asmName, string[] testInternals) {
		//print.it("CiAdd", asmName, testInternals);
		lock (_hsCi) {
			foreach (var v in testInternals) _hsCi.Add((asmName, v));
		}
	}
	
	public static void CiClear() {
		//print.it("CiClear");
		lock (_hsCi) _hsCi.Clear();
	}
	
	public static void RefsStart() {
		//print.it("RefsStart", _hsCi);
		_hsRefs.Clear();
		_hsRefs.UnionWith(_hsCi);
		_findingRefs = true;
	}
	
	public static void RefsEnd() {
		//print.it("RefsEnd");
		_findingRefs = false;
		_hsRefs.Clear();
	}
	
	public static void RefsAdd(string asmName, string[] testInternals) {
		//print.it("RefsAdd", asmName, testInternals);
		foreach (var v in testInternals) _hsRefs.Add((asmName, v));
	}
}


================================================
FILE: Au.Editor/Compiler/XCompiled.cs
================================================
namespace LA;

partial class Compiler {
	/// <summary>
	/// Resolves whether need to [re]compile or can run previously compiled assembly.
	/// </summary>
	unsafe class XCompiled {
		readonly string _file;
		Dictionary<uint, string> _data;
		string _environmentString;
		
		public string CacheDirectory { get; }
		
		public static XCompiled OfWorkspace => (App.Model.CompilerContext_ ??= new XCompiled()) as XCompiled;
		
		public XCompiled() {
			CacheDirectory = App.Model.WorkspaceDirectory + @"\.compiled";
			_file = CacheDirectory + @"\compiled.log";
			
			//The first line in the log file contains .NET version, Au.dll version, OS version and workspace path,
			//	like 5.0.4|1.2.3.4|A00-64|\\?\Volume{GUID}\Path
			//	Volume GUID for a removable drive is:
			//		The same on the same computer/OS, regardless of drive letter and USB port.
			//		Different on each computer/OS. It's good.
			filesystem.more.getFinalPath(folders.Workspace, out var ws, format: FPFormat.VolumeGuid);
			_environmentString = osVersion.onaString + "|" + ws;
		}
		
		/// <summary>
		/// Called before executing script f. If returns true, don't need to compile.
		/// </summary>
		/// <param name="f"></param>
		/// <param name="r">Receives file path and execution options.</param>
		/// <param name="projFolder">Project folder or null. If not null, f must be its main file.</param>
		public bool IsCompiled(FileNode f, out CompResults r, FileNode projFolder) {
			r = new CompResults();
			
			if (_data == null && !_Open()) return false;
			
			if (!_data.TryGetValue(f.Id, out string value)) return false;
			//Debug_.Print(value);
			int iPipe = 0;
			
			bool isScript = f.IsScript;
			r.role = MetaComments.DefaultRole(isScript);
			
			string asmFile;
			if (r.notInCache = value?.Starts("|=") ?? false) {
				iPipe = value.IndexOf('|', 2); if (iPipe < 0) iPipe = value.Length;
				asmFile = pathname.NormalizeMinimally_(value[2..iPipe]);
			} else {
				asmFile = CacheDirectory + "\\" + f.IdString + ".dll";
			}
			//print.it(asmFile);
			
			if (!filesystem.GetTime_(asmFile, out var asmTime)) return false;
			
			if (_IsFileModified(f)) return false;
			
			bool isMultiFileProject = false;
			if (value != null && iPipe < value.Length) {
				iPipe++;
				foreach (var v in value.SplitSE(iPipe.., '|', StringSplitOptions.RemoveEmptyEntries)) {
					int offs = v.start + 1;
					char ch = value[v.start];
					switch (ch) {
					case 't':
						r.role = (MCRole)value.ToInt(offs);
						break;
					case 'n':
						r.ifRunning = (MCIfRunning)value.ToInt(offs);
						break;
					case 'u':
						r.uac = (MCUac)value.ToInt(offs);
						break;
					case 'b':
						r.platform = (MCPlatform)value.ToInt(offs);
						break;
					case 'f':
						r.flags = (MiniProgram_.MPFlags)value.ToInt(offs);
						break;
					case 'p':
						isMultiFileProject = true;
						if (projFolder != null) {
							if (!Hash.MD5Result.FromString(value.AsSpan(offs, v.end - offs), out var md5)) return false;
							Hash.MD5Context md = default;
							foreach (var f1 in projFolder.EnumProjectClassFiles(f)) {
								if (_IsFileModified(f1)) return false;
								md.Add(f1.Id);
							}
							if (md.IsEmpty || md.Hash != md5) return false;
						}
						break;
					case '*':
						string dll;
						if (value[offs] == '*') dll = string.Concat(App.Model.NugetDirectoryBS, value.AsSpan((offs + 1)..v.end));
						else if (value[offs] == '?') dll = string.Concat(App.Model.DllDirectoryBS, value.AsSpan((offs + 1)..v.end));
						else {
							dll = value[offs..v.end];
							if (!pathname.isFullPathExpand(ref dll)) dll = folders.ThisAppBS + dll;
						}
						if (_IsFileModified2(dll)) return false;
						break;
					case 'l':
					case 'c':
					case 'x':
					case 'y':
					case 'k':
					case 'm':
					case 's':
						value.ToInt(out uint u1, offs);
						var f2 = App.Model.FindById(u1);
						if (f2 == null) return false;
						if (ch == 'l') {
							if (f2.FindProject(out var projFolder2, out var projMain2)) f2 = projMain2;
							if (f2 == f) return false; //will be compiler error "circular reference"
							//print.it(f2, projFolder2);
							if (!IsCompiled(f2, out _, projFolder2)) return false;
							//print.it("library is compiled");
						} else {
							if (_IsFileModified(f2)) return false;
						}
						break;
					default: return false;
					}
				}
			}
			if (isMultiFileProject != (projFolder != null)) {
				if (projFolder == null) return false;
				foreach (var f1 in projFolder.EnumProjectClassFiles(f)) return false; //project with single file?
			}
			//Debug_.Print("compiled");
			
			r.file = asmFile;
			r.name = pathname.getNameNoExt(f.Name);
			return true;
			
			bool _IsFileModified(FileNode f_) => _IsFileModified2(f_.FilePath);
			
			bool _IsFileModified2(string path_) {
				if (!filesystem.GetProp_(path_, out var prop_)) return true;
				Debug.Assert(!prop_.attr.Has(FileAttributes.Directory));
				//print.it(prop_.LastWriteTimeUtc, asmDate);
				if (prop_.time > asmTime) return true;
				return false;
			}
		}
		
		/// <summary>
		/// Called when successfully compiled script f. Saves data that next time will be used by <see cref="IsCompiled"/>.
		/// </summary>
		/// <param name="outFile">The output assembly.</param>
		public void AddCompiled(FileNode f, string outFile, MetaComments m, MiniProgram_.MPFlags miniFlags) {
			if (_data == null && !_Open()) _data = new();
			
			/*
IDmain|=path.exe|tN|nN|uN|bN|fN|pMD5project|cIDcode|lIDlibrary|xIDresource|yIDfile|kIDicon|mIDmanifest|sIDsign|*ref
= - outFile
t - role
n - ifRunning
u - uac
b - platform
f - miniFlags
p - MD5 of Id of all project files except main
c - c
l - pr
x - resource
y - file
k - icon
m - manifest
s - sign
* - r
			*/
			
			string value = null;
			using (new StringBuilder_(out var b)) {
				if (m.OutputPath != null) b.Append("|=").Append(folders.unexpandPath(outFile)); //else f.Id in cache
				if (m.Role != MetaComments.DefaultRole(m.MainFile.f.IsScript)) b.Append("|t").Append((int)m.Role);
				if (m.IfRunning != default) b.Append("|n").Append((int)m.IfRunning);
				if (m.Uac != default) b.Append("|u").Append((int)m.Uac);
				b.Append("|b").Append((int)m.Platform);
				if (miniFlags != default) b.Append("|f").Append((int)miniFlags);
				
				Hash.MD5Context md = default;
				foreach (var v in m.CodeFiles) {
					if (v.isC) _AppendFile("|c", v.f); //ids of C# files added through meta 'c'
					else if (!v.isMain) md.Add(v.f.Id); //MD5 hash of project files, except main
				}
				if (!md.IsEmpty) b.Append("|p").Append(md.Hash.ToString());
				
				if (m.ProjectReferences is { } pr) foreach (var (v, _) in pr) _AppendFile("|l", v); //ids of meta 'pr' files
				if (m.Resources != null) foreach (var v in m.Resources) _AppendFile("|x", v.f); //ids of meta 'resource' files
				if (m.OtherFiles != null) foreach (var v in m.OtherFiles) _AppendFile("|y", v.f); //ids of meta 'file' files
				_AppendFile("|k", m.IconFile);
				_AppendFile("|m", m.ManifestFile);
				_AppendFile("|s", m.SignFile);
				
				//references
				var refs = m.References.Refs;
				int j = m.References.DefaultRefCount;
				if (refs.Count > j) {
					string appDir = folders.ThisAppBS, nugetDir = App.Model.NugetDirectoryBS, dllDir = App.Model.DllDirectoryBS;
					for (; j < refs.Count; j++) {
						string s1 = refs[j].FilePath, prefix = "|*";
						if (s1.Starts(nugetDir, true)) { //note: in portable LA it is in app dir
							s1 = s1[nugetDir.Length..];
							prefix = "|**";
						} else if (s1.Starts(dllDir, true)) { //note: in portable LA it is in app dir
							s1 = s1[dllDir.Length..];
							prefix = "|*?";
						} else if (s1.Starts(appDir, true)) {
							s1 = s1[appDir.Length..];
						} else {
							s1 = folders.unexpandPath(s1);
						}
						b.Append(prefix).Append(s1);
					}
				}
				
				if (b.Length != 0) value = b.ToString();
				
				void _AppendFile(string m, FileNode f) {
					if (f == null) return;
					if (f.IsFolder) {
						Debug.Assert(m is "|x" or "|y" or "|k");
						foreach (var des in f.Descendants()) if (!des.IsFolder) b.Append(m).Append(des.IdString);
					} else {
						b.Append(m).Append(f.IdString);
					}
				}
			}
			
			uint id = f.Id;
			if (_data.TryGetValue(id, out var oldValue) && value == oldValue) { /*Debug_.Print("same");*/ return; }
			//Debug_.Print("different");
			_data[id] = value;
			_Save();
		}
		
		/// <summary>
		/// Removes saved f data, so that next time <see cref="IsCompiled"/> will return false.
		/// </summary>
		public void Remove(FileNode f, bool deleteAsmFile) {
			if (_data == null && !_Open()) return;
			if (_data.Remove(f.Id)) {
				_Save();
				if (deleteAsmFile) {
					try { filesystem.delete(CacheDirectory + "\\" + f.IdString + ".dll"); }
					catch (Exception ex) { Debug_.Print(ex); }
				}
			}
		}
		
		bool _Open() {
			if (_data != null) return true;
			if (!filesystem.exists(_file).File) return false;
			string sData = filesystem.loadText(_file);
			foreach (var v in sData.Lines(.., noEmpty: true)) {
				if (_data == null) {
					if (sData[v.Range] != _environmentString) goto g1;
					_data = new(sData.LineCount());
				} else {
					sData.ToInt(out uint id, v.start, out int idEnd);
					if (null != App.Model.FindById(id))
						_data[id] = v.end > idEnd ? sData[idEnd..v.end] : null;
				}
			}
			if (_data == null) return false; //empty file
			
			//delete temp files
			foreach (var f in filesystem.enumerate(CacheDirectory, FEFlags.UseRawPath | FEFlags.IgnoreInaccessible)) {
				if (f.Name.Like("*'*")) Api.DeleteFile(f.FullPath);
			}
			
			return true;
			g1:
			_ClearCache();
			return false;
		}
		
		void _Save() {
			filesystem.createDirectory(CacheDirectory);
			using var b = filesystem.waitIfLocked(() => File.CreateText(_file));
			b.WriteLine(_environmentString);
			foreach (var v in _data) {
				if (v.Value == null) b.WriteLine(v.Key); else { b.Write(v.Key); b.WriteLine(v.Value); }
			}
			//tested: fast, same speed as StringBuilder+WriteAllText. With b.WriteLine(v.Key+v.Value) same speed or slower.
		}
		
		void _ClearCache() {
			_data = null;
			try { filesystem.delete(CacheDirectory); }
			catch (AuException e) { print.warning("Failed to delete compiled script assembly cache. " + e.ToString(), -1); }
		}
	}
	
	public static void Uncache(FileNode f, bool andDescendants = false) {
		var x = XCompiled.OfWorkspace;
		x.Remove(f, true);
		if (andDescendants && f.IsFolder) foreach (var v in f.Descendants()) x.Remove(v, true);
	}
}


================================================
FILE: Au.Editor/Compiler/XPublish.cs
================================================
using Au.Controls;
using System.Xml.Linq;
using System.Windows;
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using System.Windows.Controls;

namespace LA;

class XPublish {
	MetaComments _meta;
	string _csprojDir, _csprojFile;
	
	public async void Publish() {
		var cmd = App.Commands[nameof(Menus.Run.Publish)];
		if (!cmd.Enabled) return;
		cmd.Enable(false);
		try {
			var b = new wpfBuilder("Publish").WinSize(300).WinProperties(resizeMode: ResizeMode.NoResize, showInTaskbar: false);
			b.R.Add(out KCheckBox cSingle, "Single file").Checked(0 == (1 & App.Settings.publish));
			b.R.Add(out CheckBox cSelfExtract, "Self-extract").Margin(20)
				.xBindCheckedEnabled(cSingle)
				.Tooltip("""
Checked - use <IncludeAllContentForSelfExtract>. Adds all files to exe. Will extract all (including .NET dlls) to a temporary directory.
Unchecked - adds only .NET dlls to exe. Native dlls and other files (if any) will live in the exe's directory. Will use .NET dlls without extracting.
Indeterminate - use <IncludeNativeLibrariesForSelfExtract>. Adds all dlls to exe. Will extract native dlls, and use .NET dlls without extracting.
""")
				.Checked((App.Settings.publish >>> 8 & 3) switch { 1 => false, 2 => true, _ => null }, threeState: true);
			b.R.Add(out KCheckBox cNet, "Add .NET Runtime").Checked(0 != (2 & App.Settings.publish));
			b.R.Add(out KCheckBox cR2R, "ReadyToRun").Checked(0 != (4 & App.Settings.publish));
			b.R.Add("Platform", out ComboBox cbPlatform).Width(100, "L").Items("x64|arm64|x86").Select(Math.Clamp(App.Settings.publish >>> 4 & 3, 0, 2));
			b.R.Add(out TextBlock tProgress).Hidden(null);
			b.R.StartOkCancel().AddOkCancel(out var bOK, out _, out _).xAddDialogHelpButtonAndF1("editor/Creating exe programs").End();
			b.End();
			
			DotnetUtil.MissingSdkUI(b.Window, [bOK]);
			
			if (!b.ShowDialog(App.Wmain)) return;
			
			int platform = cbPlatform.SelectedIndex;
			App.Settings.publish = (cSingle.IsChecked ? 0 : 1) | (cNet.IsChecked ? 2 : 0) | (cR2R.IsChecked ? 4 : 0) | ((cSelfExtract.IsChecked switch { false => 1, true => 2, _ => 0 }) << 8) | (platform << 4);
			//TODO3: maybe support publish profiles like in VS: <PublishProfileFullPath>
			
			print.it($"<><lc YellowGreen>Building program files for publishing. Please wait until DONE.<>");
			
			bool singleFile = cSingle.IsChecked; bool? selfExtract = cSelfExtract.IsChecked;
			if (!_CreateCsproj(singleFile: singleFile, selfExtract, selfContained: cNet.IsChecked, readyToRun: cR2R.IsChecked, platform)) return;
			
			var outDir = $@"{_csprojDir}\release_{platform switch { 0 => "x64", 1 => "arm64", _ => "x86" }}";
			var outFile = $@"{outDir}\{_meta.Name}.exe";
			_PrepareOutDir(outDir, outFile);
			if (_meta.PreBuild.f != null && !CompilerUtil.RunPrePostBuildScript(_meta, false, outFile, true)) return;
			if (!await Task.Run(() => _DotnetPublish(outDir, singleFile, selfExtract))) return;
			if (_meta.PostBuild.f != null && !CompilerUtil.RunPrePostBuildScript(_meta, true, outFile, true)) return;
			
			_DeleteOldOutputDir("64");
			_DeleteOldOutputDir("32");
			void _DeleteOldOutputDir(string bit) {
				var s = $@"{_csprojDir}\release_{bit}";
				if (filesystem.exists(s)) print.it($"<>This LibreAutomate version uses different names for publish output folders. You may want to delete this old unused folder: <explore>{s}<>");
			}
			
			print.it("==== DONE ====");
		}
		catch (Exception e1) { print.it(e1); }
		finally {
			filesystem.delete(folders.ThisAppTemp + "publish", FDFlags.CanFail);
			cmd.Enable(true);
		}
	}
	
	static void _PrepareOutDir(string outDir, string outFile) {
		if (filesystem.exists(outDir).Directory) {
			CompilerUtil.DeleteExeFile(outFile);
			foreach (var v in filesystem.enumerate(outDir)) filesystem.delete(v.FullPath, FDFlags.CanFail);
		}
	}
	
	bool _DotnetPublish(string outDir, bool singleFile, bool? selfExtract) {
		bool dirExisted = filesystem.exists(outDir);
		
		var buildDir = _csprojDir + @"\.build";
		var cl = $@"publish ""{_csprojFile}"" -c Release -o ""{outDir}"" --artifacts-path ""{buildDir}"" -v q";
		print.it($"<><c blue>dotnet {cl}<>");
		if (0 != run.console(DotnetUtil.DotnetExe, cl)) { print.it("Failed"); return false; }
		print.it($@"<>{_meta.Name} -> <explore>{outDir}\{_meta.Name}.exe<>");
		
		filesystem.delete(buildDir, FDFlags.CanFail);
		
		int nFiles = 0;
		foreach (var v in filesystem.enumerate(outDir)) {
			var path = v.FullPath;
			if (!v.IsDirectory && path.Ends(".pdb", true)) filesystem.delete(path, FDFlags.CanFail); //probably Au.pdb (at home only)
			else nFiles++;
		}
		
		//warn if singleFile with IncludeNativeLibrariesForSelfExtract produced more than single exe file. See comments in _CreateCsproj.
		if (singleFile && selfExtract != true) {
			if (selfExtract == false) print.it("<>Note: <b>Self-extract<> is unchecked, therefore only .NET dlls have been added to exe. Other files are located in the exe's directory.");
			else if (nFiles > 1) print.it("<>Warning: If <b>Self-extract<> is indeterminate, some files used by this script cannot be added to exe, and the program may be invalid. It should be either checked or unchecked.");
			//BAD: may not add some files even with selfExtract true. Eg from nuget Selenium.WebDriver.ChromeDriver.
		}
		
		//sometimes Explorer does not update the folder view
		if (dirExisted) filesystem.ShellNotify_(Api.SHCNE_UPDATEDIR, outDir);
		
		return true;
	}
	
	bool _CreateCsproj(bool singleFile, bool? selfExtract, bool selfContained, bool readyToRun, int platform) {
		App.Model.Save.TextNowIfNeed(onlyText: true);
		
		var doc = Panels.Editor.ActiveDoc; if (doc == null) return false;
		var f = doc.EFile;
		if (f.FindProject(out var projFolder, out var projMain)) f = projMain;
		if (!f.IsCodeFile) return false;
		
		_meta = new MetaComments(MCFlags.Publish | MCFlags.PrintErrors);
		if (!_meta.Parse(f, projFolder)) return false;
		if (_meta.Role is not (MCRole.miniProgram or MCRole.exeProgram)) return _Err("expected role exeProgram or miniProgram");
		if (_meta.TestInternal != null) return _Err("testInternal not supported");
		
		_csprojDir = $@"{_meta.OutputPath ?? MetaComments.GetDefaultOutputPath(f, _meta.Role, withEnvVar: false)}\publish";
		filesystem.createDirectory(_csprojDir);
		
		var xroot = new XElement("Project", new XAttribute("Sdk", "Microsoft.NET.Sdk"));
		var xpg = new XElement("PropertyGroup");
		xroot.Add(xpg);
		
		_Add(xpg, "TargetFramework", $"net{Environment.Version.ToString(2)}-windows");
		_Add(xpg, "LangVersion", "preview");
		_Add(xpg, "AllowUnsafeBlocks", "true");
		_Add(xpg, "UseWindowsForms", "true");
		_Add(xpg, "UseWPF", "true");
		_Add(xpg, "EnableDefaultItems", "false"); //https://learn.microsoft.com/en-us/dotnet/core/project-sdk/msbuild-props-desktop#wpf-default-includes-and-excludes
		_Add(xpg, "CopyLocalLockFileAssemblies", "true");
		_Add(xpg, "ProduceReferenceAssembly", "false");
		_Add(xpg, "PublishReferencesDocumentationFiles", "false");
		_Add(xpg, "DebugType", "embedded");
		_Add(xpg, "CopyDebugSymbolFilesFromPackages", "false");
		_Add(xpg, "AppendTargetFrameworkToOutputPath", "false");
		_Add(xpg, "NuGetAudit", "false"); //don't connect to nuget.org unless using nuget references. If no internet connection, waits several s and prints: warning NU1900: Error occurred while getting package vulnerability data: No such host is known. (api.nuget.org:443). But sometimes hangs. Error if command line contains --no-restore. 
		_Add(xpg, "AllowMissingPrunePackageData", "true");
		
		_Add(xpg, "AssemblyName", _meta.Name);
		_Add(xpg, "OutputType", _meta.Console ? "Exe" : "WinExe");
		
		_Add(xpg, "DisableImplicitFrameworkDefines", "true");
		_Add(xpg, "DefineConstants", string.Join(';', _meta.Defines));
		
		_Add(xpg, "WarningLevel", _meta.WarningLevel);
		_Add(xpg, "NoWarn", string.Join(';', _meta.NoWarnings) + ";WFAC010;WFO0003;CA1416");
		if (_meta.Nullable != 0) _Add(xpg, "Nullable", _meta.Nullable);
		
		var sPlatform = platform switch { 0 => "x64", 1 => "arm64", _ => "x86" };
		_Add(xpg, "PlatformTarget", sPlatform);
		_Add(xpg, "RuntimeIdentifier", "win-" + sPlatform);
		
		if (!_Icon()) return false;
		_Add(xpg, "ApplicationManifest", _Path(_meta.ManifestFile) ?? folders.ThisAppBS + "default.exe.manifest");
		
		//if (_meta.CodeFiles.Any(o => o.f.Name.Eqi("AssemblyInfo.cs"))) _Add(xpg, "GenerateAssemblyInfo", "false"); //no, users don't know it. See https://www.libreautomate.com/forum/showthread.php?tid=7591
		_Add(xpg, "GenerateAssemblyInfo", "false");
		
		if (_meta.SignFile != null) {
			_Add(xpg, "SignAssembly", "true");
			_Add(xpg, "AssemblyOriginatorKeyFile", _Path(_meta.SignFile));
		}
		
		if (singleFile) {
			_Add(xpg, "PublishSingleFile", "true");
			if (selfContained) _Add(xpg, "EnableCompressionInSingleFile", "true"); //else compression not supported (with IncludeAllContentForSelfExtract too)
			if (selfExtract == null) _Add(xpg, "IncludeNativeLibrariesForSelfExtract", "true"); else if (selfExtract == true) _Add(xpg, "IncludeAllContentForSelfExtract", "true");
			//About selfExtract:
			//IncludeNativeLibrariesForSelfExtract (selfExtract null) has problems:
			//	1. Does not add data files (of most types).
			//	2. Adds not only native dlls, but also exe etc. With this mess the program usually crashes. To repro, add nuget Microsoft.Playwright.
			//IncludeAllContentForSelfExtract (selfExtract true) solves both. Also solves the "no assembly location etc" problem. But has own issues.
			//selfExtract false solves #2.
			//rejected: instead use normal checkbox that adds IncludeAllContentForSelfExtract when checked.
			//	If unchecked, use IncludeNativeLibrariesForSelfExtract only it produces single file (else there is no sense to add dlls etc).
			//	To implement it probably would need to run dotnet publish twice. I don't know other ways.
		}
		_Add(xpg, "SelfContained", selfContained ? "true" : "false");
		if (readyToRun) _Add(xpg, "PublishReadyToRun", "true");
		
		var xig = new XElement("ItemGroup");
		xroot.Add(xig);
		
		_AddAttr(xig, "Compile", "Include", _ModuleInit());
		foreach (var v in _meta.CodeFiles) _AddAttr(xig, "Compile", "Include", _Path(v.f));
		
		var trees = CompilerUtil.CreateSyntaxTrees(_meta);
		
		_AddAuNativeDll("AuCpp.dll", 0);
		_AddAuNativeDll("Au.DllHost.exe", -1);
		//if (_NeedSqlite()) _AddAuNativeDll("sqlite3.dll", 1);
		CompilerUtil.CopyMetaFileFilesOfAllProjects(_meta, _csprojDir, (from, to) => _AddContentFile(from, to));
		
		if (_meta.References.DefaultRefCount != MetaReferences.DefaultReferences.Count) return _Err("noRef not supported"); //TODO3: try <DisableImplicitFrameworkReferences>
		_AddAttr(xig, "Reference", "Include", _meta.References.Refs[_meta.References.DefaultRefCount - 1].FilePath); //Au
		_References();
		
		if (!_Nuget()) return false;
		
		if (!_ManagedResources()) return false;
		
		//print.it(xroot);
		xroot.SaveElem(_csprojFile = $@"{_csprojDir}\{_meta.Name}.csproj");
		return true;
		
		static bool _Err(string s) { print.it("Error: " + s); return false; }
		
		static string _Path(FileNode f) => f?.FilePath;
		
		static XElement _Add(XElement parent, string tag, object value) {
			XElement x = new(tag, value);
			parent.Add(x);
			return x;
		}
		
		static XElement _AddAttr(XElement parent, string tag, string attr, object value) {
			XElement x = new(tag, new XAttribute(attr, value));
			parent.Add(x);
			return x;
		}
		
		void _AddContentFile(string path, string to) {
			var x = _AddAttr(xig, "Content", "Include", path);
			_Add(x, "CopyToOutputDirectory", "PreserveNewest");
			if (to.PathStarts(_csprojDir)) to = to[(_csprojDir.Length + 1)..];
			_Add(x, "Link", to); //note: TargetPath should be the same, but somehow ignores files in subfolders (meta file x /sub) if single-file, unless the folder exists.
		}
		
		//platforms: 0 all, 1 only this, -1 only other
		void _AddAuNativeDll(string filename, int platforms) {
			for (int i = 0; i < 3; i++) {
				if (platforms == 0 || (platforms > 0 ? i == platform : i != platform)) {
					var s = i switch { 0 => @"64\", 1 => @"64\ARM\", _ => @"32\" } + filename;
					//_AddContentFile(folders.ThisAppBS + s, s); //no, NativeLibrary.TryLoad fails if single-file
					_AddContentFile(folders.ThisAppBS + s, i == platform ? filename : s);
				}
			}
			//why need AuCpp.dll and Au.DllHost.exe for other platforms: for elm functions to load AuCpp.dll into processes of different platform. See func SwitchArchAndInjectDll in in-proc.cpp.
		}
		
		string _ModuleInit() {
			var path = _csprojDir + @"\ModuleInit__.cs";
			filesystem.saveText(path, @"class ModuleInit__ { [System.Runtime.CompilerServices.ModuleInitializer] internal static void Init() { Au.script.AppModuleInit_(auCompiler: false); }}"); //like in Compiler._AddAttributesEtc but with `auCompiler: false`
			return path;
		}
		
		bool _Icon() {
			if (_meta.IconFile is { } fIco) {
				if (fIco.IsFolder) return _Err("icons folder not supported");
				_Add(xpg, "ApplicationIcon", _Path(fIco));
			} else if (DIcons.TryGetIconFromDB(f.CustomIconName, out string xaml)) {
				var file = _csprojDir + @"\icon.ico";
				try {
					var e = ImageUtil.LoadWpfImageElement(xaml);
					ImageUtil.ConvertWpfImageElementToIcon_(file, e, [16, 24, 32, 48, 64]);
					_Add(xpg, "ApplicationIcon", file);
				}
				catch (Exception e1) { print.it(e1); }
			}
			return true;
		}
		
		bool _ManagedResources() {
			var resourcesFile = _csprojDir + @"\g.resources";
			return CompilerUtil.CreateManagedResources(_meta, _meta.Name, trees, _ResourceException, o => {
				var x = _AddAttr(xig, "EmbeddedResource", "Include", o.file);
				_Add(x, "LogicalName", o.name);
			}, resourcesFile);
			
			static void _ResourceException(Exception e, FileNode curFile) {
				var em = e.ToStringWithoutStack();
				if (curFile == null) _Err("Failed to add resources. " + em);
				else _Err($"Failed to add resource '{curFile.Name}'. " + em);
			}
		}
		
		void _References() {
			var noDup = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			_Ref2(_meta);
			void _Ref2(MetaComments m) {
				foreach (var v in m.References.Refs.Skip(_meta.References.DefaultRefCount)) { //r, pr, com
					if (MetaReferences.IsNuget(v)) continue;
					var x = _AddAttr(xig, "Reference", "Include", v.FilePath);
					if (v.Properties.EmbedInteropTypes) _Add(x, "EmbedInteropTypes", "true");
					if (!v.Properties.Aliases.IsDefaultOrEmpty) _Add(x, "Aliases", v.Properties.Aliases[0]);
					if (!noDup.Add(x.ToString())) x.Remove();
				}
				if (m.ProjectReferences is { } pr) {
					foreach (var v in pr) _Ref2(v.m);
				}
			}
		}
		
		bool _Nuget() {
			var noDup = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			return _Nuget2(_meta);
			bool _Nuget2(MetaComments m) {
				foreach (var (p, alias) in m.NugetPackages) {
					var dir = pathname.getDirectory(p);
					var path = $@"{App.Model.NugetDirectoryBS}{dir}\{dir}.csproj";
					if (XmlUtil.LoadElemIfExists(path) is not { } xproj || xproj.Desc("PackageReference", "Include", pathname.getName(p), true) is not { } x) return _Err("NuGet package not installed: " + p);
					if (alias != null) _Add(x, "Aliases", alias);
					if (!noDup.Add(x.ToString())) continue;
					xig.Add(x);
				}
				if (m.ProjectReferences is { } pr) {
					foreach (var v in pr) if (!_Nuget2(v.m)) return false;
				}
				return true;
			}
		}
		
		//bool _NeedSqlite() {
		//	var cOpt = new CSharpCompilationOptions(OutputKind.WindowsApplication, allowUnsafe: true, warningLevel: 0);
		//	var compilation = CSharpCompilation.Create(_meta.Name, trees, _meta.References.Refs, cOpt);
		//	var asmStream = new MemoryStream(16000);
		//	var emitResult = compilation.Emit(asmStream);
		//	asmStream.Position = 0;
		//	if (emitResult.Success && CompilerUtil.UsesSqlite(asmStream)) return true;
		
		//	foreach (var v in _meta.References.Refs.Skip(_meta.References.DefaultRefCount)) {
		//		if (v.Properties.EmbedInteropTypes) continue; //com; and no nuget refs when publishing
		//		if (CompilerUtil.UsesSqlite(v.FilePath, recursive: true)) return true;
		//	}
		
		//	return false;
		//}
	}
}


================================================
FILE: Au.Editor/Compiler/util/CompilerUtil.cs
================================================
using System.Reflection.Metadata;
using System.Reflection.PortableExecutable;
using System.Resources;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp.Syntax;

namespace LA;

static partial class CompilerUtil {
	/// <summary>
	/// Returns true if the dll file is a .NET assembly (any, not only of the .NET library).
	/// </summary>
	public static bool IsNetAssembly(string path) {
		using var pr = new PEReader(filesystem.loadStream(path));
		return pr.HasMetadata;
	}
	
	/// <summary>
	/// Returns true if the dll file is a .NET assembly. Sets isRefOnly = true if it's a reference-only assembly.
	/// </summary>
	public static bool IsNetAssembly(string path, out bool isRefOnly) {
		isRefOnly = false;
		using var pr = new PEReader(filesystem.loadStream(path));
		if (!pr.HasMetadata) return false;
		var mr = pr.GetMetadataReader();
		
		foreach (var v in mr.GetAssemblyDefinition().GetCustomAttributes()) {
			var ca = mr.GetCustomAttribute(v);
			var h = ca.Constructor;
			if (h.Kind == HandleKind.MemberReference) {
				var m = mr.GetMemberReference((MemberReferenceHandle)h);
				var t = mr.GetTypeReference((TypeReferenceHandle)m.Parent);
				var s = mr.GetString(t.Name);
				if (s == "ReferenceAssemblyAttribute") { isRefOnly = true; break; }
			}
		}
		
		return true;
	}
	
	public static CSharpSyntaxTree[] CreateSyntaxTrees(MetaComments meta) {
		var pOpt = meta.CreateParseOptions();
		var trees = new CSharpSyntaxTree[meta.CodeFiles.Count];
		for (int i = 0; i < trees.Length; i++) {
			var f1 = meta.CodeFiles[i];
			
			//never mind: should use Encoding.UTF8 etc if the file is with BOM. Encoding.Default is UTF-8 without BOM.
			//	Else, when debugging with VS or VS Code, they say "source code changed" and can't set breakpoints by default.
			//	But they have an option to debug modified files anyway.
			//	This program saves new files without BOM. It seems VS Code too. VS saves with BOM (maybe depends on its settings).
			//	CONSIDER: use ParseText overload with SourceText, for which use StreamReader that detects BOM. Not tested.
			var encoding = Encoding.Default;
			
			trees[i] = CSharpSyntaxTree.ParseText(f1.code, pOpt, f1.f.FilePath, encoding) as CSharpSyntaxTree;
			
			//info: file path is used later in several places: in compilation error messages, run time stack traces (from PDB), debuggers, etc.
			//	Our PrintServer.SetNotifications callback will convert file/line info to links. It supports compilation errors and run time stack traces.
		}
		return trees;
	}
	
	/// <summary>
	/// Creates managed resources for embedding.
	/// </summary>
	/// <param name="meta"></param>
	/// <param name="asmName"></param>
	/// <param name="trees">Syntax trees of all source files. Used to extract XAML icons from strings like "*icon". If library, this func can replace some array elements.</param>
	/// <param name="failed">Called when failed. Eg a file not found, or error in meta. The <b>FileNode</b> can be null.</param>
	/// <param name="result">
	/// Called for each embedded resource, including the one containing non-embedded resources. Receives:
	/// <br/>• name - embedded resource name.
	/// <br/>• stream - embedded resource data. Null if <i>resourcesFile</i> not null.
	/// <br/>• file - path of embedded resource file. If the resource contains non-embedded resources, it is <i>resourcesFile</i> (which can be null).</param>
	/// <param name="resourcesFile">If not null, saves non-embedded resources in this ".resources" file. Then the caller can add the file as an embedded resource.</param>
	/// <returns>false if failed.</returns>
	public static bool CreateManagedResources(MetaComments meta, string asmName, CSharpSyntaxTree[] trees, Action<Exception, FileNode> failed, Action<(string name, Stream stream, string file)> result, string resourcesFile = null) {
		ResourceWriter rw = null;
		MemoryStream stream = null;
		FileNode curFile = null;
		bool needStream = resourcesFile == null;
		
		void _RW() { rw ??= needStream ? new(stream = new()) : new(resourcesFile); }
		
		try {
			var a = meta.Resources;
			if (!a.NE_()) {
				foreach (var v in a) {
					//if (v.f == null) { // /resources //rejected
					//	_End();
					//	resourcesName = v.s + ".resources";
					//} else
					
					//if has suffix /path, make resource name = path relative to pathRoot, like "subfolder/filename.ext". Else "filename.ext".
					bool usePath = false;
					FileNode pathRoot = null;
					string resType = v.s;
					if (resType != null) {
						if (usePath = resType == "path") resType = null;
						else if (usePath = resType.Ends(" /path")) resType = resType[..^6].NullIfEmpty_();
						if (usePath) {
							curFile = v.f;
							pathRoot = meta.MainFile.f.Parent;
							if (!v.f.IsDescendantOf(pathRoot)) throw new ArgumentException("/path cannot be used if the file isn't in this folder");
							if (resType == "strings") throw new ArgumentException("/path cannot be used with /strings");
						}
					}
					
					if (v.f.IsFolder) {
						foreach (var des in v.f.Descendants()) if (!des.IsFolder) _Add(des, resType, pathRoot ?? v.f);
					} else {
						_Add(v.f, resType, pathRoot);
					}
				}
				curFile = null;
				
				void _Add(FileNode f, string resType, FileNode folder = null) {
					curFile = f;
					string name = f.Name, path = f.FilePath;
					if (folder != null) for (var pa = f.Parent; pa != folder; pa = pa.Parent) name = pa.Name + "/" + name;
					//print.it(f, resType, folder, name, path);
					if (resType == "embedded") {
						result((name, needStream ? filesystem.loadStream(path) : null, path));
					} else {
						name = name.Lower(); //else pack URI fails; ResourceUtil can find any.
						_RW();
						switch (resType) {
						case null:
							//rw.AddResource(name, File.OpenRead(path), closeAfterWrite: true); //no, would not close on error
							rw.AddResource(name, new MemoryStream(filesystem.loadBytes(path)));
							break;
						case "byte[]":
							rw.AddResource(name, filesystem.loadBytes(path));
							break;
						case "string":
							rw.AddResource(name, filesystem.loadText(path));
							break;
						case "strings":
							var csv = csvTable.load(path);
							if (csv.ColumnCount != 2) throw new ArgumentException("CSV must contain 2 columns separated with ,");
							foreach (var row in csv.Rows) rw.AddResource(row[0], row[1]);
							break;
						default: throw new ArgumentException("error in meta: Incorrect /suffix");
						}
					}
					//documented in DProperties: This program does not URL-encode resource names.
					//	VS encodes space -> %20, UTF8 -> %xx, ^ -> %5e, etc. But not like .NET URL-encoding functions do.
					//	I did not find documentation about it.
					//	If not encoded, pack URI will not work.
					//	But if encoded, ResourceUtil would not work. Or should it URL-encode the parameter?
				}
			}
			
			//add XAML icons from strings like "*name #color"
			if (meta.Role != MCRole.editorExtension && 0 == (meta.MiscFlags & 1)) {
				HashSet<string> hs = null;
				for (int i = 0; i < trees.Length; i++) {
					List<LiteralExpressionSyntax> ai = null;
					var tree = trees[i];
					var root = tree.GetCompilationUnitRoot();
					foreach (var v in root.DescendantNodes()) {
						if (v is LiteralExpressionSyntax les && les.IsKind(SyntaxKind.StringLiteralExpression) && les.Token.Value is string s && s.Length >= 8 && s[0] == '*') {
							bool hasLibraryPrefix = s[1] == '<';
							if (hasLibraryPrefix) {
								int j = s.IndexOf('>');
								if (j < 0 || !s.Eq(2..j, asmName, true)) continue;
								s = s[++j..];
							}
							if (!IconString_.DetectAndRemoveParametersForResources(s, out s)) continue; //remove string icon parameters to support icon strings like `"*Pack.Icon"+colorConstant` and `$"*Pack.Icon{colorConstant}"`. At run time will call IconString_.XamlSetColorSizeMargin to add them.
							if (DIcons.TryGetIconFromDB(s, out var xaml, forResource: true)) {
								s = s.Lower();
								if ((hs ??= new()).Add(s)) {
									_RW();
									rw.AddResource(s, xaml);
								}
								if (!hasLibraryPrefix && meta.Role == MCRole.classLibrary) (ai ??= new()).Add(les);
							}
						}
					}
					if (ai != null) { //in library need "*<asmName>*name #color"
						var r2 = root.ReplaceNodes(ai, (n, _) => {
							var s = n.Token.Value as string;
							var tok = SyntaxFactory.Literal($"*<{asmName}>{s.Lower()}");
							return SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression, tok);
						});
						trees[i] = tree.WithRootAndOptions(r2, tree.Options) as CSharpSyntaxTree;
					}
				}
			}
			
			if (rw != null) {
				rw.Generate();
				stream?.Seek(0, SeekOrigin.Begin);
				result((asmName + ".g.resources", stream, resourcesFile));
			}
			
			return true;
		}
		catch (Exception e) {
			failed(e, curFile);
			return false;
		}
		finally {
			if (!needStream) rw?.Dispose(); //else Roslyn will close the stream. There is no other disposable data in rw.
		}
	}
	
	public static void CopyFileIfNeed(string sFrom, string sTo) {
		if (filesystem.GetProp_(sTo, out var p2) && filesystem.GetProp_(sFrom, out var p1) && p2 == p1) return;
		filesystem.copy(sFrom, sTo, FIfExists.Delete);
	}
	
	/// <summary>
	/// Gathers all files from meta 'file' of <i>meta</i> project and descendant pr projects, and copies to <i>outDir</i> or calls callback for each.
	/// </summary>
	/// <param name="meta"></param>
	/// <param name="outDir"></param>
	/// <param name="copy">Called for each file. If null, calls <see cref="CopyFileIfNeed"/>.</param>
	public static void CopyMetaFileFilesOfAllProjects(MetaComments meta, string outDir, Action<string, string> copy = null) {
		HashSet<FileNode> noDup = null;
		_OtherFilesOfProject(meta);
		
		void _OtherFilesOfProject(MetaComments m) {
			if (m != meta) if (!(noDup ??= new()).Add(m.MainFile.f)) return; //skip duplicates
			
			if (m.OtherFiles != null) {
				foreach (var v in m.OtherFiles) {
					var dest = outDir;
					if (!v.s.NE()) dest = pathname.combine(dest, v.s, s2CanBeFullPath: true);
					
					_CopyOther(v.f, dest);
					
					void _CopyOther(FileNode f, string dest) {
						if (f.IsFolder) {
							if (!f.Name.Ends('-')) dest = dest + "\\" + f.Name;
							foreach (var c in f.Children()) _CopyOther(c, dest);
						} else {
							string from = f.FilePath, to = dest + "\\" + pathname.getName(from);
							if (copy != null) copy(from, to);
							else CopyFileIfNeed(from, to);
						}
					}
				}
			}
			
			if (m.ProjectReferences is { } pr)
				foreach (var v in pr) _OtherFilesOfProject(v.m);
		}
	}

#if false //in the past this was used for sqlite. Maybe in the future this code can be useful for something.
	public static bool UsesSqlite(Stream asmStream, bool recursive = false) {
		using var pr = new PEReader(asmStream, PEStreamOptions.LeaveOpen);
		var mr = pr.GetMetadataReader();
		
		//var usedRefs = mr.AssemblyReferences.Select(handle => mr.GetString(mr.GetAssemblyReference(handle).Name)).ToArray();
		//print.it(usedRefs);
		
		foreach (var handle in mr.TypeReferences) {
			var tr = mr.GetTypeReference(handle);
			//print.it(mr.GetString(tr.Name), mr.GetString(tr.Namespace));
			string type = mr.GetString(tr.Name);
			if ((type.Starts("sqlite") && mr.GetString(tr.Namespace) == "Au")
				|| (type.Starts("SL") && mr.GetString(tr.Namespace) == "Au.Types")) return true;
		}
		
		if (recursive) {
			var fs = asmStream as FileStream; Debug.Assert(fs != null);
			var dir = pathname.getDirectory(fs.Name, withSeparator: true);
			var hs = new HashSet<string>();
			foreach (var arh in mr.AssemblyReferences) {
				var ar = mr.GetAssemblyReference(arh);
				var an = mr.GetString(ar.Name);
				if (MetaReferences.IsDefaultRef(an)) continue;
				if (hs.Contains(an)) continue;
				var path2 = dir + an + ".dll";
				if (!filesystem.exists(path2, useRawPath: true).File) continue;
				if (UsesSqlite(path2, true)) return true;
			}
		}
		
		return false;
	}
	
	/// <summary>
	/// Returns true if the .NET assembly uses sqlite types and therefore sqlite3.dll.
	/// </summary>
	/// <param name="dll">Assembly path.</param>
	/// <param name="recursive">Include descendant reference assemblies.</param>
	public static bool UsesSqlite(string dll, bool recursive = false) {
		using var fs = filesystem.loadStream(dll);
		return UsesSqlite(fs, recursive);
	}
#endif
	
	public static bool RunPrePostBuildScript(MetaComments m, bool post, string outFile, bool publish) {
		var x = post ? m.PostBuild : m.PreBuild;
		var f = m.MainFile.f;
		string outPath = publish ? pathname.getDirectory(outFile) : m.OutputPath;
		
		string[] args;
		if (x.s == null) {
			args = new string[] { outFile };
		} else {
			args = StringUtil.CommandLineToArray(x.s);
			
			//fbc: replace variables like $(variable)
			for (int i = 0; i < args.Length; i++)
				if (args[i].Contains("$(")) {
					args[i] = (s_rx1 ??= new regexp(@"\$\((\w+)\)")).Replace(args[i], k => k[1].Value switch {
						"outputFile" => outFile,
						"outputPath" => outPath,
						"source" => f.ItemPath,
						"role" => m.Role.ToString(),
						"optimize" => m.Optimize ? "true" : "false",
						"bit32" => m.Platform == MCPlatform.x86 ? "true" : "false",
						_ => throw new ArgumentException("error in meta: unknown variable " + k.Value)
					});
				}
		}
		
		bool ok = Compiler.Compile(CCReason.Run, out var r, x.f);
		if (r.role != MCRole.editorExtension) throw new ArgumentException($"'{x.f.Name}' role must be editorExtension");
		if (!ok) return false;
		
		PrePostBuild.Info = new(outFile, outPath, f.ItemPath, m.Role.ToString(), m.Optimize, m.Platform.ToString(), !post, publish);
		try { EditorExtension.Run_(r.file, args, handleExceptions: false); }
		finally { PrePostBuild.Info = null; }
		return true;
	}
	static regexp s_rx1;
	
	public static void DeleteExeFile(string programPath) {
		if (filesystem.exists(programPath, useRawPath: true) && !Api.DeleteFile(programPath)) {
			var a = process.getProcessIds(programPath, fullPath: true);
			if (a.Any()) {
				//if (!dialog.showYesNo("End process?", $"Need to delete this program file, but the program is running.\n\n{programPath}", owner: App.Hmain)) return;
				foreach (var v in a) process.terminate(v);
				wait.until(-3, () => Api.DeleteFile(programPath));
			}
		}
	}
}


================================================
FILE: Au.Editor/Compiler/util/Compiler_resources.cs
================================================
namespace LA;

partial class Compiler {
	unsafe class _NativeResources {
		class _Res {
			public byte[] data;
			public ushort resType, resId;
			//don't need to support language and string type/name

			public _Res(ushort resType, ushort resId, byte[] data) {
				this.data = data;
				this.resType = resType;
				this.resId = resId;
			}
		}

		List<_Res> _a = new();

		public void AddVersion(string asmFile) {
			var hModule = Api.LoadLibraryEx(asmFile, default, Api.LOAD_LIBRARY_AS_DATAFILE);
			if (hModule == default) _Throw();
			try { _a.Add(new _Res(16, 1, _LoadNativeResource(hModule, 16, 1))); } //RT_VERSION
			finally { Api.FreeLibrary(hModule); }
		}

		public void AddManifest(string manifestFile) {
			_a.Add(new _Res(24, 1, File.ReadAllBytes(manifestFile))); //RT_MANIFEST
		}

		public void AddIcon(string iconFile, ref ICONCONTEXT ic)
			=> AddIcon(File.ReadAllBytes(iconFile), ref ic);

		public void AddIcon(byte[] iconBytes, ref ICONCONTEXT ic) {
			//info:
			//An icon file begins with NEWHEADER followed by multiple ICONDIRENTRY for each icon.
			//In resource instead of ICONDIRENTRY is RESDIR, where DWORD dwImageOffset ir replaced with WORD id.
			//Note that sizeof(ICONDIRENTRY) is 16 and sizeof(RESDIR) is 14.
			//In icon file then follow multiple ICONIMAGE (or png). Their file offsets are ICONDIRENTRY.dwImageOffset.
			//In resources instead there are multiple RT_ICON resources that are referenced
			//	by RESDIR.wIconCursorId. An RT_ICON resource contains ICONIMAGE or png.

			if (ic.groupId == 0) ic.groupId = Api.IDI_APPLICATION;

			var m = new MemoryStream();
			fixed (byte* mem = iconBytes) {
				if (iconBytes.Length <= sizeof(Api.NEWHEADER)) _Throw();
				var ph = (Api.NEWHEADER*)mem;
				var pi = (Api.ICONDIRENTRY*)(ph + 1);
				int n = ph->wResCount;
				if (iconBytes.Length <= sizeof(Api.NEWHEADER) + n * sizeof(Api.ICONDIRENTRY)) _Throw();
				m.Write(new RByte(ph, sizeof(Api.NEWHEADER)));

				for (int i = 0; i < n; i++) {
					Api.ICONDIRENTRY* ide = pi + i;
					int offset = ide->dwImageOffset, size = ide->dwBytesInRes;
					if (offset + size > iconBytes.Length) _Throw();
					ushort id = (ushort)(++ic.iconId);
					ide->dwImageOffset = id; //RESDIR.wIconCursorId
					m.Write(new RByte(ide, sizeof(Api.ICONDIRENTRY) - 2)); //ICONDIRENTRY to RESDIR

					_a.Add(new _Res(3, id, new RByte(mem + offset, size).ToArray())); //RT_ICON
				}
			}

			_a.Add(new _Res(14, (ushort)ic.groupId++, m.ToArray())); //RT_GROUP_ICON
		}

		public struct ICONCONTEXT { public int groupId, iconId; }

		public void AddTpa(string tpa) {
			_a.Add(new _Res(220, 1, Encoding.UTF8.GetBytes(tpa)));
		}

		//rejected. Rarely used. If need, users can add later, with tools like ResourceHacker. Here makes more difficult because need to support string type/name, language, etc.
		//public void AddRes(string resFile)
		//{

		//}

		static void _Throw() {
			throw new AuException("*add resources");
		}

		static bool _LoadNativeResource(IntPtr hModule, ushort resType, ushort resId, out byte* ptr, out int size) {
			ptr = null; size = 0;
			var hRes = Api.FindResource(hModule, resId, resType); if (hRes == default) return false;
			var hGlob = LoadResource(hModule, hRes); if (hGlob == default) return false;
			ptr = LockResource(hGlob);
			size = SizeofResource(hModule, hRes);
			return ptr != null && size > 0;
			//info: don't need to free or unlock. It is documented.
		}

		static byte[] _LoadNativeResource(IntPtr hModule, ushort resType, ushort resId) {
			if (!_LoadNativeResource(hModule, resType, resId, out var data, out var size)) _Throw();
			return new RByte(data, size).ToArray();
		}

		internal static string LoadNativeResourceUtf8String_(ushort resType, ushort resId) {
			if (!_LoadNativeResource(default, resType, resId, out var data, out var size)) _Throw();
			return Encoding.UTF8.GetString(new RByte(data, size));
		}

		public void WriteAll(string exeFile, byte[] exeData, MCPlatform platform, bool console) {
			fixed (byte* pBase = exeData) {
				IMAGE_NT_HEADERS64* nth = ImageNtHeader(pBase); if (nth == null) _Throw();
				var oh = &nth->OptionalHeader;
				uint fileAlignment = oh->FileAlignment;
				uint resRva = oh->SizeOfImage;

				if (fileAlignment != 512
					|| (uint)exeData.Length % fileAlignment != 0
					|| exeData.Length < 2048
					|| oh->DataDirectory_Resource.VirtualAddress != 0 //must not contain resources
					) _Throw();

				var m = new MemoryStream();
				m.Position = exeData.Length; //reserve for updated exeData
				if (!_WriteResources(m, resRva)) _Throw();
				uint resSize = (uint)(m.Length - exeData.Length), resSizeAligned = Math2.AlignUp(resSize, fileAlignment);
				m.SetLength((uint)m.Length + resSizeAligned);

				//The exe template does not contain resources, therefore .rsrc section does not exist and ImageDirectoryEntryToDataEx fails.
				//Could add a placeholder resource, but then it is not the last section...
				//But we can simply append new section header here. There is empty space, because sections are aligned at 0x400.
				var ish = (IMAGE_SECTION_HEADER*)((byte*)oh + nth->FileHeader.SizeOfOptionalHeader + nth->FileHeader.NumberOfSections * sizeof(IMAGE_SECTION_HEADER));
				long ishOffset = (byte*)ish - pBase; if (ishOffset <= 512 || ishOffset > 1024 - sizeof(IMAGE_SECTION_HEADER)) _Throw();

				//write IMAGE_SECTION_HEADER of .rsrc section
				for (int i = 0; i < 5; i++) ish->Name[i] = (byte)".rsrc"[i];
				ish->VirtualSize = resSize;
				ish->VirtualAddress = resRva;
				ish->SizeOfRawData = Math2.AlignUp(resSize, fileAlignment);
				ish->PointerToRawData = (uint)exeData.Length;
				ish->Characteristics = 0x40000040;

				uint resSize2 = Math2.AlignUp(resSize, oh->SectionAlignment);
				if (platform == MCPlatform.x86) {
					var oh32 = (IMAGE_OPTIONAL_HEADER32*)oh;
					oh32->DataDirectory_Resource.VirtualAddress = resRva;
					oh32->DataDirectory_Resource.Size = resSize;
					oh32->SizeOfInitializedData += resSizeAligned;
					oh32->SizeOfImage += resSize2;
					if (console) oh32->Subsystem = 3;
					oh32->CheckSum = 0;
				} else {
					//in IMAGE_OPTIONAL_HEADER write RVA/size of .rsrc section
					oh->DataDirectory_Resource.VirtualAddress = resRva;
					oh->DataDirectory_Resource.Size = resSize;

					//update some other fields
					oh->SizeOfInitializedData += resSizeAligned;
					oh->SizeOfImage += resSize2;
					if (console) oh->Subsystem = 3; //IMAGE_SUBSYSTEM_WINDOWS_CUI
					oh->CheckSum = 0;
				}
				nth->FileHeader.NumberOfSections++;
				nth->FileHeader.TimeDateStamp = 0;

				//write updated exeData to stream
				m.Position = 0;
				m.Write(exeData);
				m.Position = 0;

				using var fs = new FileStream(exeFile, FileMode.OpenOrCreate, FileAccess.Write, FileShare.None);
				m.CopyTo(fs);
			}
		}

		bool _WriteResources(Stream m, uint resRva) {
			//calc number of resource types and ids (sum of unique ids of all types)
			//We can have max 1 version, 1 manifest and multiple RT_ICONGROUP (each + its multiple RT_ICON).

			_a.Sort((v1, v2) => {
				int r = v1.resType - v2.resType;
				if (r == 0) r = v1.resId - v2.resId;
				return r;
			});

			int nTypes = 0, nIds = 0, prevType = -1, prevId = -1;
			foreach (var r in _a) {
				if (r.resType != prevType) { prevType = r.resType; nTypes++; prevId = -1; }
				if (r.resId != prevId) { prevId = r.resId; nIds++; }
			}

			//calc offsets and size of all directories
			int sizeResDir = sizeof(IMAGE_RESOURCE_DIRECTORY);
			int sizeDirEntry = sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY);
			int baseNameIdDir = sizeResDir + nTypes * sizeDirEntry;
			int baseLangDir = baseNameIdDir + sizeResDir * nTypes + nIds * sizeDirEntry;
			int baseDataDir = baseLangDir + sizeResDir * nIds + sizeDirEntry * _a.Count;
			int baseResData = baseDataDir + _a.Count * sizeof(IMAGE_RESOURCE_DATA_ENTRY);
			int offsData = baseResData; //temp

			//create and write directories
			var aDir = new byte[baseResData];
			fixed (byte* pDir = aDir) {
				var dT = (IMAGE_RESOURCE_DIRECTORY*)pDir;
				var eT = (IMAGE_RESOURCE_DIRECTORY_ENTRY*)(dT + 1);
				IMAGE_RESOURCE_DIRECTORY* dN = null, dL = null;
				IMAGE_RESOURCE_DIRECTORY_ENTRY* eN = null, eL = null;
				prevType = -1; prevId = -1;
				foreach (var r in _a) {
					if (r.resType != prevType) {
						prevType = r.resType;
						prevId = -1;

						//write resource type entry
						dT->NumberOfIdEntries++;
						eT->Id = r.resType;
						eT->OffsetToData = baseNameIdDir | unchecked((int)0x80000000);
						eT++;

						//write directory of resource ids
						dN = (IMAGE_RESOURCE_DIRECTORY*)(pDir + baseNameIdDir);
						baseNameIdDir += sizeResDir;
						eN = (IMAGE_RESOURCE_DIRECTORY_ENTRY*)(dN + 1);
					}

					if (r.resId != prevId) {
						prevId = r.resId;

						//write resource id entry
						dN->NumberOfIdEntries++;
						eN->Id = r.resId;
						eN->OffsetToData = baseLangDir | unchecked((int)0x80000000);
						eN++;
						baseNameIdDir += sizeDirEntry;

						//write directory of languages
						dL = (IMAGE_RESOURCE_DIRECTORY*)(pDir + baseLangDir);
						baseLangDir += sizeResDir;
						eL = (IMAGE_RESOURCE_DIRECTORY_ENTRY*)(dL + 1);
					}

					//write language entry
					dL->NumberOfIdEntries++;
					eL->Id = 0;
					eL->OffsetToData = baseDataDir;
					eL++;
					baseLangDir += sizeDirEntry;

					//write data entry
					var de = (IMAGE_RESOURCE_DATA_ENTRY*)(pDir + baseDataDir);
					baseDataDir += sizeof(IMAGE_RESOURCE_DATA_ENTRY);
					de->Size = (uint)r.data.Length;
					de->OffsetToData = resRva + (uint)offsData; //RVA
					offsData += Math2.AlignUp(r.data.Length, 4);
				}
			}
			m.Write(aDir);

			//write resource data
			foreach (var r in _a) {
				m.Write(r.data);
				for (int k = Math2.AlignUp(r.data.Length, 4) - r.data.Length; k > 0; k--) m.WriteByte(0); //4-align
			}

			return true;
		}

		[DllImport("kernel32.dll")]
		internal static extern IntPtr LoadResource(IntPtr hModule, IntPtr hResInfo);

		[DllImport("kernel32.dll")]
		internal static extern byte* LockResource(IntPtr hResData);

		[DllImport("kernel32.dll")]
		internal static extern int SizeofResource(IntPtr hModule, IntPtr hResInfo);

		[DllImport("dbghelp.dll")]
		internal static extern IMAGE_NT_HEADERS64* ImageNtHeader(byte* Base);

#pragma warning disable 649 //field never assigned

		internal struct IMAGE_SECTION_HEADER {
			public fixed byte Name[8];
			public uint VirtualSize;
			public uint VirtualAddress;
			public uint SizeOfRawData;
			public uint PointerToRawData;
			public uint PointerToRelocations;
			public uint PointerToLinenumbers;
			public ushort NumberOfRelocations;
			public ushort NumberOfLinenumbers;
			public uint Characteristics;
		}

		internal struct IMAGE_DATA_DIRECTORY {
			public uint VirtualAddress;
			public uint Size;
		}

		[StructLayout(LayoutKind.Sequential, Pack = 4)]
		internal struct IMAGE_OPTIONAL_HEADER32 {
			public ushort Magic;
			public byte MajorLinkerVersion;
			public byte MinorLinkerVersion;
			public uint SizeOfCode;
			public uint SizeOfInitializedData;
			public uint SizeOfUninitializedData;
			public uint AddressOfEntryPoint;
			public uint BaseOfCode;
			public uint BaseOfData;
			public uint ImageBase;
			public uint SectionAlignment;
			public uint FileAlignment;
			public ushort MajorOperatingSystemVersion;
			public ushort MinorOperatingSystemVersion;
			public ushort MajorImageVersion;
			public ushort MinorImageVersion;
			public ushort MajorSubsystemVersion;
			public ushort MinorSubsystemVersion;
			public uint Win32VersionValue;
			public uint SizeOfImage;
			public uint SizeOfHeaders;
			public uint CheckSum;
			public ushort Subsystem;
			public ushort DllCharacteristics;
			public uint SizeOfStackReserve;
			public uint SizeOfStackCommit;
			public uint SizeOfHeapReserve;
			public uint SizeOfHeapCommit;
			public uint LoaderFlags;
			public uint NumberOfRvaAndSizes;
			IMAGE_DATA_DIRECTORY _d0, _d1;
			public IMAGE_DATA_DIRECTORY DataDirectory_Resource;
		}

		[StructLayout(LayoutKind.Sequential, Pack = 4)]
		internal struct IMAGE_OPTIONAL_HEADER64 {
			public ushort Magic;
			public byte MajorLinkerVersion;
			public byte MinorLinkerVersion;
			public uint SizeOfCode;
			public uint SizeOfInitializedData;
			public uint SizeOfUninitializedData;
			public uint AddressOfEntryPoint;
			public uint BaseOfCode;
			public ulong ImageBase;
			public uint SectionAlignment;
			public uint FileAlignment;
			public ushort MajorOperatingSystemVersion;
			public ushort MinorOperatingSystemVersion;
			public ushort MajorImageVersion;
			public ushort MinorImageVersion;
			public ushort MajorSubsystemVersion;
			public ushort MinorSubsystemVersion;
			public uint Win32VersionValue;
			public uint SizeOfImage;
			public uint SizeOfHeaders;
			public uint CheckSum;
			public ushort Subsystem;
			public ushort DllCharacteristics;
			public ulong SizeOfStackReserve;
			public ulong SizeOfStackCommit;
			public ulong SizeOfHeapReserve;
			public ulong SizeOfHeapCommit;
			public uint LoaderFlags;
			public uint NumberOfRvaAndSizes;
			IMAGE_DATA_DIRECTORY _d0, _d1;
			public IMAGE_DATA_DIRECTORY DataDirectory_Resource;
		}

		internal struct IMAGE_FILE_HEADER {
			public ushort Machine;
			public ushort NumberOfSections;
			public uint TimeDateStamp;
			public uint PointerToSymbolTable;
			public uint NumberOfSymbols;
			public ushort SizeOfOptionalHeader;
			public ushort Characteristics;
		}

		[StructLayout(LayoutKind.Sequential, Pack = 4)]
		internal struct IMAGE_NT_HEADERS64 {
			public uint Signature;
			public IMAGE_FILE_HEADER FileHeader;
			public IMAGE_OPTIONAL_HEADER64 OptionalHeader;
		}

		internal struct IMAGE_RESOURCE_DIRECTORY {
			public uint Characteristics;
			public uint TimeDateStamp;
			public ushort MajorVersion;
			public ushort MinorVersion;
			public ushort NumberOfNamedEntries;
			public ushort NumberOfIdEntries;
		}

		internal struct IMAGE_RESOURCE_DIRECTORY_ENTRY {
			//simplified, does not support name as string
			public ushort Id;
			public int OffsetToData;
		}

		internal struct IMAGE_RESOURCE_DATA_ENTRY {
			public uint OffsetToData;
			public uint Size;
			public uint CodePage;
			public uint Reserved;
		}

		//Icon resource entry (part of RT_GROUP_ICON)
		//[StructLayout(LayoutKind.Sequential, Pack = 2)]
		//struct RESDIR
		//{
		//	public ICONRESDIR ird;
		//	public ushort wPlanes;
		//	public ushort wBitCount;
		//	public uint dwBytesInRes;
		//	public ushort wIconCursorId;
		//};

		//Icon image in file. RT_ICON resource is the same.
		//[StructLayout(LayoutKind.Sequential, Pack = 2)]
		//struct ICONIMAGE
		//{
		//	public BITMAPINFOHEADER icHeader;
		//	public RGBQUAD icColors[1];
		//	public byte icXOR[1];
		//	public byte icAND[1];
		//};
	}
}


================================================
FILE: Au.Editor/Debugger/PD-stack.cs
================================================
using Au.Controls;

namespace LA;

partial class PanelDebug {
	KTreeView _tvStack;
	_StackViewItem[] _aStack;
	
	void _StackViewInit() {
		_tvStack = new() { Name = "Callstack_list", SingleClickActivate = true };
		_tvStack.ItemActivated += _tvStack_ItemActivated;
	}
	
	void _StackViewSetItems(_FRAME[] a, int iSelect = 0) {
		if (a == null) {
			_aStack = null;
		} else {
			_aStack = new _StackViewItem[a.Length];
			for (int i = 0; i < a.Length; i++) {
				_aStack[i] = new(this, a[i]);
			}
		}
		
		_tvStack.SetItems(_aStack);
		if (a != null) _tvStack.SelectSingle(iSelect, andFocus: true);
	}
	
	void _tvStack_ItemActivated(TVItemEventArgs e) {
		if (!IsStopped) return;
		var v = e.Item as _StackViewItem;
		_s.frame = v.f;
		_GoToLine(v.f, keepMarkers: true);
		//_VariablesViewChangedFrameOrThread();
		_ListVariables();
	}
	
	class _StackViewItem : ITreeViewItem {
		readonly PanelDebug _panel;
		readonly public _FRAME f;
		readonly string _text;
		
		public _StackViewItem(PanelDebug panel, _FRAME f) {
			_panel = panel;
			this.f = f;
			_text = _panel._FormatFrameString(f);
		}
		
		//ITreeViewItem
		
		string ITreeViewItem.DisplayText => _text;
		
		TVParts ITreeViewItem.NoParts => TVParts.Image;
		
		//public bool IsDisabled => f.file.NE();
		
		//bool ITreeViewItem.IsSelectable => !IsDisabled;
		
		int ITreeViewItem.TextColor(TVColorInfo ci) => f.file.NE() ? 0x808080 : -1;
	}
}


================================================
FILE: Au.Editor/Debugger/PD-variables.cs
================================================
extern alias CAW;

using Microsoft.CodeAnalysis;
using CAW::Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Text;
using Microsoft.CodeAnalysis.CSharp.Extensions;
using Microsoft.CodeAnalysis.Shared.Extensions;
using CAW::Microsoft.CodeAnalysis.Shared.Extensions;

using Au.Controls;
using System.Windows.Input;

//CONSIDER: save watches.
//CONSIDER: add separate "Watch" treeview. Also move <mouse> there.

namespace LA;

partial class PanelDebug {
	KTreeView _tvVariables;
	_VariablesViewItem[] _aVar;
	_VariablesViewItem _watch;
	
	void _VariablesViewInit() {
		_tvVariables = new() { Name = "Variables_list", SingleClickActivate = true };
		_tvVariables.ItemClick += _tvVariables_ItemClick;
		_tvVariables.ItemActivated += e => { ((_VariablesViewItem)e.Item).Print(); };
	}
	
	void _ListVariables() {
		if (_s.frame.clr_addr.module_id.NE()) { //f.func "[Native Frames]". Would be ^error.
			_VariablesViewSetItems(null);
			return;
		}
		_d.Send($"-stack-list-variables --thread {_s.threadId} --frame {_s.frame.level}");
	}
	
	//Rejected. See comment in VarDelete.
	//Called when the user selects a frame or thread.
	//Calls -var-delete for all _aVar items.
	//Not really necessary, just frees some memory in the debugger process now. Debugger itself deletes all variables on step/continue.
	//void _VariablesViewChangedFrameOrThread() {
	//	if (_aVar == null) return;
	//	foreach (var v in _aVar) v.VarDelete();
	//}
	
	void _VariablesViewSetItems(_VARIABLE[] a) {
		if (a.NE_()) {
			_aVar = a != null ? new _VariablesViewItem[2] : null;
		} else {
			_aVar = new _VariablesViewItem[a.Length + 2];
			for (int i = 0; i < a.Length; i++) {
				_aVar[i + 2] = new(this, a[i]);
			}
		}
		
		if (_aVar != null) {
			_aVar[0] = new _VariablesViewItem(this, _VVItemKind.Mouse);
			if (_watch == null) {
				_aVar[1] = _watch = new(this, _VVItemKind.Watch);
			} else {
				_aVar[1] = _watch;
				foreach (var v in _watch.Children) v.UpdateWatch();
			}
		}
		
		_tvVariables.SetItems(_aVar);
	}
	
	//called by CiQuickInfo when mouse hovers on a non-literal token
	internal void SciMouseHover_(CodeInfo.Context cd) {
		if (!IsStopped || _aVar.NE_()) return;
		
		//get expression string
		//It can be a variable/field/property name, x.y, x[y] or similar.
		
		string exp = null;
		int pos = cd.pos;
		var tok = cd.syntaxRoot.FindToken(pos);
		var node = tok.Parent;
		//CiUtil.PrintNode(tok);
		//CiUtil.PrintNode(node);
		var tk = tok.Kind();
		if (tk == SyntaxKind.IdentifierToken) {
			if (node is VariableDeclaratorSyntax vds) {
				if (vds.Identifier.Span.ContainsOrTouches(pos)) exp = tok.Text;
			} else if (node is ParameterSyntax ps) {
				if (ps.Identifier.Span.ContainsOrTouches(pos)) exp = tok.Text;
			} else if (node is PropertyDeclarationSyntax pds) {
				if (pds.Identifier.Span.ContainsOrTouches(pos)) exp = tok.Text;
			} else if (node is SingleVariableDesignationSyntax svds) { //`Call(out var tok)` or `if (x is Y tok)` or tuple etc
				if (svds.Identifier.Span.ContainsOrTouches(pos)) exp = tok.Text;
			} else if (node is IdentifierNameSyntax /*or GenericNameSyntax*/) {
				if (cd.semanticModel.GetSymbolInfo(node).Symbol is ISymbol sym) {
					if (sym.Kind is SymbolKind.Field or SymbolKind.Local or SymbolKind.Parameter or SymbolKind.Property) {
						if (sym is IPropertySymbol ips && ips.IsWriteOnly) {
						} else if (tok.GetPreviousToken().Kind() is SyntaxKind.DotToken or SyntaxKind.MinusGreaterThanToken) {
							exp = cd.code[_FindStartOfMemberAccessOrElementAccess(node)..tok.Span.End];
						} else {
							exp = tok.Text;
						}
					//} else if (sym.Kind is SymbolKind.Method && node.GetAncestor<InvocationExpressionSyntax>() is { } ies) { //for testing only
					//	var span = ies.Span;
					//	int i = span.Start;
					//	if (cd.code[i] == '.') i = _FindStartOfMemberAccessOrElementAccess(ies);
					//	exp = cd.code[i..span.End];
					}
				}
			}
		} else if (node is BracketedArgumentListSyntax && node.Parent is ElementAccessExpressionSyntax or ElementBindingExpressionSyntax) {
			//if (App.Settings.debug.noFuncEval) return; //debugger crashes if it's an indexer other than of string or array. And with this flag would fail anyway.
			exp = cd.code[_FindStartOfMemberAccessOrElementAccess(node)..node.Span.End];
		} else return;
		
		int _FindStartOfMemberAccessOrElementAccess(SyntaxNode node) {
			var r = node.Parent;
			for (var n = r; n is MemberAccessExpressionSyntax or ConditionalAccessExpressionSyntax or ElementAccessExpressionSyntax or ElementBindingExpressionSyntax or MemberBindingExpressionSyntax or InvocationExpressionSyntax; n = n.Parent) {
				if (n is MemberAccessExpressionSyntax or ConditionalAccessExpressionSyntax) r = n;
			}
			return r.SpanStart;
		}
		
		if (exp != null) {
			//print.it(exp);
			//note: can be `MethodCall().member', `x[MethodCall()]` etc, not only variables, properties, indexers and operators.
			//info: netcoredbg does not support many expressions.
			//	Eg `x->y`, `n::x.y`, `stringOrArray.Length`, `string[0]`, `x[true ? 0 : 1]`, `x[Index]`, `x[a..b]`, `((C2)cc).P`, `x++`, typeof, as, is, Method<T>.
			//	See StackMachine.cs in ManagedPart project.
			//	Issue: https://github.com/Samsung/netcoredbg/issues/132
			
			//get frame
			
			SyntaxNode _GetEnclosingFunction(SyntaxNode n) {
				for (; n != null; n = n.Parent)
					if (n is BaseMethodDeclarationSyntax or LocalFunctionStatementSyntax or BasePropertyDeclarationSyntax or EventDeclarationSyntax or AnonymousFunctionExpressionSyntax) break;
				return n;
			}
			
			int frame = 0;
			if (_aStack.Length > 1) {
				var path = cd.sci.EFile.FilePath;
				var ef = _GetEnclosingFunction(node);
				if (ef == null) { //TLS
					if (node.HasAncestor<GlobalStatementSyntax>()) frame = _aStack.Length - 1; //else pos is in a class but not in a func
				} else {
					for (int i = 0; i < _aStack.Length; i++) {
						var f = _aStack[i].f;
						if (f.fullname != path) continue;
						int p = cd.sci.aaaLineStart(true, f.line - 1) + f.col - 1; //position of current statement in frame i
						var ef2 = _GetEnclosingFunction(cd.syntaxRoot.FindToken(p).Parent);
						if (ef2 == ef) { frame = i; break; }
					}
				}
			}
			//print.it(frame);
			
			//create MI variable, and display it as the first item in _tvVariables
			
			if (_VarCreate(exp, frame) is _VAR r) {
				//_aVar[0].VarDelete();
				_aVar[0] = new(this, null, r, _VVItemKind.Mouse);
				_tvVariables.SetItems(_aVar, true);
				_tvVariables.EnsureVisible(0);
				return;
			}
		}
		
		//_aVar[0].VarDelete();
		_aVar[0] = new(this, _VVItemKind.Mouse);
		_tvVariables.SetItems(_aVar, true);
	}
	
	_VAR _VarCreate(string exp, int frame = -1) {
		exp = _EscapeExpression(exp);
		if (frame < 0) frame = _s.frame.level;
		int evalFlags = 0; //enum_EVALFLAGS, https://learn.microsoft.com/en-us/visualstudio/extensibility/debugger/reference/evalflags
		//if (App.Settings.debug.noFuncEval) evalFlags |= 0x80; //EVAL_NOFUNCEVAL. Rejected. Not useful, just makes code more complex. Also tested EVAL_NOSIDEEFFECTS and EVAL_ALLOWERRORREPORT; it seems they do nothing.
		if (_d.SendSync(100, $"-var-create - {exp} --thread {_s.threadId} --frame {frame} --evalFlags {evalFlags}") is string s) {
			//print.it("VAR", s);
			if (s.Starts("^done,name=")) return new _MiRecord(s).Data<_VAR>();
			Debug_.Print($"<c orange>{s}<>");
		}
		return null;
		//tested: debugger has a 5-10 s timeout for expression evaluation.
	}
	
	_VAR _VarCreateL(string exp) {
		if (_d.SendSync(100, $"-var-create - {exp}") is string s) {
			if (s.Starts("^done,name=")) return new _MiRecord(s).Data<_VAR>();
			Debug_.Print($"<c orange>{s}<>");
		}
		return null;
	}
	
	void _WatchAdd(string exp, int frame = -1) {
		if (_VarCreate(exp, frame) is _VAR r) {
			_VariablesViewItem v = new(this, _watch, r, _VVItemKind.Watch);
			_watch.AddWatch(v);
			_tvVariables.SetItems(_aVar, true);
			_tvVariables.Expand(1, true);
			_tvVariables.SelectSingle(v);
		}
	}
	
	void _WatchRemove(_VariablesViewItem v) {
		_watch.RemoveWatch(v);
		_tvVariables.SetItems(_aVar, true);
	}
	
	static string _EscapeExpression(string s) {
		s = s.RxReplace(@"[\r\n\t]+", " ").Escape();
		s = '"' + s + '"';
		return s;
	}
	
	void _tvVariables_ItemClick(TVItemEventArgs e) {
		var v = e.Item as _VariablesViewItem;
		if (e.Button == MouseButton.Right && e.ClickCount == 1 && e.Mod == 0) {
			var m = new popupMenu();
			
			if (v.itemKind == _VVItemKind.Watch) {
				if (v.Parent == null) m["Clear"] = o => _WatchRemove(null);
				else m["Remove"] = o => _WatchRemove(v);
			} else {
				if (v.Exp == null) return; //<mouse>, <static>
				m["Watch"] = o => _WatchAdd(v.ExpPath());
			}
			
			m.Show(owner: _tvVariables);
		}
	}
	static Stack<string> s_pathStack;
	
	class _VariablesViewItem : ITreeViewItem {
		readonly PanelDebug _panel;
		_VAR _v;
		string _text, _exp;
		bool _isFolder;
		bool _isExpanded;
		public readonly _VVItemKind itemKind;
		_VariablesViewItem[] _children;
		
		public _VariablesViewItem(PanelDebug panel, _VARIABLE v) {
			_panel = panel;
			_exp = v.name;
			_SetTextAndIsFolder(v.value);
		}
		
		void _SetTextAndIsFolder(string value) {
			if (value != null) {
				_text = $"{_exp}={value.Limit(8000)}";
				_isFolder = value.Starts('{') && (_v != null ? _v.numchild > 0 : !value.Ends("[0]}"));
			} else _text = _exp;
		}
		
		public _VariablesViewItem(PanelDebug panel, _VariablesViewItem parent, _VAR v, _VVItemKind itemKind) {
			_panel = panel;
			Parent = parent;
			this.itemKind = itemKind;
			_v = v;
			if (v.value.NE() && v.exp == "Static members") {
				_text = "<static>";
				_isFolder = true;
			} else {
				var s = v.exp; if (s.Ends('.')) s = "*" + s[..^1];
				_exp = s;
				_SetTextAndIsFolder(v.value);
			}
		}
		
		//Adds <mouse> or <watch>.
		public _VariablesViewItem(PanelDebug panel, _VVItemKind itemKind) {
			_panel = panel;
			this.itemKind = itemKind;
			bool isWatch = itemKind == _VVItemKind.Watch;
			_text = isWatch ? "<watch>" : "<mouse>";
			if (isWatch) _children = [];
		}
		
		//public void VarDelete() {
		//	if (_v == null) return;
		//	//_panel._d.SendSync(102, $"-var-delete {v.name}"); //no. Somehow then every other -var-list-children fails.
		//	_v = null;
		//	_isFolder = _isExpanded = false;
		//	_children = null;
		//}
		
		public _VariablesViewItem Parent { get; }
		
		public _VariablesViewItem[] Children => _children;
		
		public string Exp => _exp;
		
		public string ExpPath() {
			var p = this;
			int n = 0; for (; p?._exp != null; p = p.Parent) n++;
			string r;
			if (n == 1) r = _exp;
			else {
				var s = s_pathStack ??= new();
				s.Clear();
				for (p = this; p?._exp != null; p = p.Parent) s.Push(p._exp);
				r = string.Join('.', s).Replace(".[", "[");
			}
			if (p?.Parent?._v is { } u) r = u.type + "." + r; //if in <static>, prepend type
			return r;
		}
		
		public void AddWatch(_VariablesViewItem v) {
			if (_children.NE_()) _children = [v]; else _children = _children.InsertAt(-1, v);
			_isFolder = true;
		}
		
		//Deletes all if v null.
		public void RemoveWatch(_VariablesViewItem v) {
			if (v == null) {
				_children = [];
			} else {
				var i = Array.IndexOf(_children, v);
				if (i < 0) return;
				_children = _children.RemoveAt(i);
			}
			_isFolder = _children.Length > 0;
		}
		
		public void UpdateWatch() {
			if (_panel._VarCreate(_exp) is _VAR v) {
				_v = v;
				_SetTextAndIsFolder(v.value);
			} else {
				_v = null;
				_isFolder = false;
				_text = $"{_exp}=";
			}
			_children = null;
		}
		
		public void Print() {
			if (_exp == null) return;
			if (!_EnsureHaveVar()) return;
			if (_v.value?.Ends('}') != false) {
				var s1 = App.Settings.debug.printVarCompact ? "Compact" : "";
				string t = _v.type, e = ExpPath();
				if (t is "IntPtr" or "UIntPtr" or "int" or "uint" or "long" or "ulong" or "short" or "ushort" or "byte" or "sbyte" or "double" or "float" or "char" or "bool") {
					//actually object or dynamic. Would fail or get garbage.
					e = $"{e}.ToString()";
					t = "string";
					//} else if (t.Ends("[]")) { //array. Fails everything I tried.
					//t="System.Array";
					//s1 = "Array";
					//t = t[..^2];
				}
				var k = $"Au.More.LaDebugger_<{t}>.Print{s1}({e})";
				//print.it(k);
				//print.it(_v);
				if (_panel._VarCreate(k) is { } v) {
					if (v.value.Starts('"')) {
						var s = Encoding.UTF8.GetString(Convert.FromBase64String(v.value[1..^1]));
						print.it(_AndHex(s));
					} else {
						print.it(v.value); //{Some.Exception}
					}
				}
				
			} else if (_v.value.Ends('"')) {
				print.it(_v.value[1..^1].Unescape());
			} else if (_v.value.Starts('<')) {
				//"<error>". Eg because of option "Don't call functions to get values" (rejected).
			} else {
				print.it(_AndHex(_v.value));
			}
			
			string _AndHex(string s) {
				var t = _v.type.TrimEnd('*');
				if (t is "IntPtr" or "UIntPtr" or "int" or "uint" or "long" or "ulong" or "short" or "ushort" or "byte" or "sbyte") {
					if (s.ToInt(out long x)) s = $"{s}  0x{x:X}";
				} else if (t is "char" && s.Length == 1) {
					var v = s == "'" ? @"\'" : s == "\"" ? s : s.Escape();
					s = $"{(int)s[0]} '{v}'";
				}
				return s;
			}
		}
		
		bool _EnsureHaveVar() {
			if (_v == null && _panel._VarCreate(_exp) is { } v) {
				_v = v;
			}
			return _v != null;
		}
		
		//ITreeViewItem
		
		string ITreeViewItem.DisplayText => _text;
		
		IEnumerable<ITreeViewItem> ITreeViewItem.Items {
			get {
				if (!_panel.IsStopped) return Array.Empty<_VariablesViewItem>();
				if (_children == null) {
					if (_EnsureHaveVar() && _v.numchild > 0) {
						//note: if without `--all-values`, values will be null, but calls properties anyway (same speed).
						//	In any case, does not call properties if the parent variable was created with evalFlags EVAL_NOFUNCEVAL. Then fast.
						
						//TODO3: slow if many children. Eg WPF Window has almost 400, and the time is ~550 ms.
						//	If > 100 children, should get child properties when/if displaying them first time.
						//	Now we need just names for sorting. To make it fast, call -var-create with flag EVAL_NOFUNCEVAL (-var-list-children inherits its flags).
						//		This inheritance can be a problem. Unless I'll modify netcoredbg to pass flags to -var-list-children.
						//	Tested: if -var-list-children called for each child separately, the total time for a WPF Window is ~850 ms (instead of ~550 ms).
						//		Because need to sort, we cannot call -var-list-children to get just currently displayed children in single call.
						
						//print.it(_v);
						var max = _v.type.Ends(']') ? 100 : 5000;
						if (_panel._d.SendSync(101, $"-var-list-children --all-values {_v.name} 0 {max}") is string s) {
							if (s.Starts("^done,numchild=")) {
								var r = new _MiRecord(s).Data<_DONE_CHILDREN>();
								if (r.numchild > 0) {
									_children = new _VariablesViewItem[r.children.Length];
									for (int i = 0; i < _children.Length; i++) {
										_children[i] = new(_panel, this, r.children[i], itemKind);
									}
									Array.Sort(_children, (x, y) => string.Compare(x._exp ?? "\xffff", y._exp ?? "\xffff", StringComparison.OrdinalIgnoreCase));
									
									//FUTURE: show non-raw children of List, Dictionary, IEnumerable etc. Like other debuggers.
									//	Issue: https://github.com/Samsung/netcoredbg/issues/85
									//	Issue: https://github.com/Samsung/netcoredbg/issues/132#issuecomment-1868233713
									//	Now, as a workaround, users can click the variable to print items. But it works not with all ienumerables.
									
									//CONSIDER: put private members into a folder, except if parent is 'this'. But can be slow to correctly detect private members.
								}
							} else {
								//tested: debugger has a timeout for expression evaluation.
								//	Eg if the executed code contains code `12.s();`, waits 5 s, and that value is "<error>".
								//	But if contains code `dialog.show("");`, waits 10 s and returns error.
								//	Debugger respects [DebuggerBrowsable(DebuggerBrowsableState.Never)] but ignores other [DebuggerX].
								Debug_.Print($"<c orange>{s}<>");
							}
						}
					}
					if (_children == null) _isFolder = false;
					_children ??= [];
				}
				return _children;
			}
		}
		
		public bool IsFolder => _isFolder;
		
		bool ITreeViewItem.IsExpanded => _isExpanded;
		
		void ITreeViewItem.SetIsExpanded(bool yes) { _isExpanded = yes; }
		
		object ITreeViewItem.Image
			=> _isFolder ? EdIcons.FolderArrow(_isExpanded)
			: null;
		
		void ITreeViewItem.SetNewText(string text) {
			
		}
		
		int ITreeViewItem.TextColor(TVColorInfo ci) => itemKind switch { _VVItemKind.Mouse => 0xE08000, _VVItemKind.Watch => 0x40A000, _ => -1 };
	}
	
	enum _VVItemKind : byte { Default, Mouse, Watch }
	
#if DEBUG
	void _Test() {
		//if (_VarCreate($"type", 0) is _VAR r) {
		//	print.it(r);
		//	print.it(r.value);
		//	_d.Send($"-var-assign {r.name} list.GetType()");
		//}
		
		//var s = "Au.print.util.toString(dict)";
		////s = "_ToString(i)";
		//s = "C.Print(i)";
		//s = "e1.GetEnumerator().MoveNext()";
		//if (_VarCreate($"{s}", 0) is _VAR r) {
		//	print.it(r);
		//	print.it(r.value);
		//}
		
		if (_d.SendSync(7, "-test") is string s1) {
			print.it(s1);
		}
	}
#endif
}


================================================
FILE: Au.Editor/Debugger/PD._Debugger.cs
================================================
//From netcoredbg we need only netcoredbg.exe, dbgshim.dll, ManagedPart.dll, Microsoft.CodeAnalysis.dll and Microsoft.CodeAnalysis.CSharp.dll.
//	The default netcoredbg also contains 2 unused Roslyn scripting dlls.
//	Also these Roslyn dlls are very old.
//	Now debugger files are in the Debugger folder. Need just netcoredbg.exe, dbgshim.dll and ManagedPart.dll. They use the new Roslyn dlls.
//	Using modified netcoredbg and ManagedPart.
//	Using newer dbgshim.dll: https://www.nuget.org/packages/Microsoft.Diagnostics.DbgShim.win-x64 and Microsoft.Diagnostics.DbgShim.win-arm64
//	More info in netcoredbg solution > readme.md.

namespace LA;

partial class PanelDebug {
	class _Debugger {
		consoleProcess _p;
		FileStream _fs;
		Action<string> _events;
		bool _ignoreEvents;
		Action _readEvents;
		
		public _Debugger(Action<string> events) {
			_events = events;
			_readEvents = _ReadEvents;
		}
		
		public bool Init(bool arm64) {
			//var log = @"C:\Test\debugger-log.txt"; filesystem.delete(log); Environment.SetEnvironmentVariable("LOG_OUTPUT", log);
			_p = new($@"{folders.ThisAppBS}Debugger\{(arm64 ? "arm64" : "x64")}\netcoredbg.exe", $"--interpreter=mi");
			
			if (SendSync(0, $"-handshake") != "^done") { //waits until the debugger is ready to process commands. Then we can measure the speed of other sync commands at startup.
				_Print("Failed to start debugger.");
				return false;
			}
			
			_fs = new(new Microsoft.Win32.SafeHandles.SafeFileHandle(_p.OutputHandle_, ownsHandle: false), FileAccess.Read);
			timer.after(200, _ => _readEvents());
			
			return true;
		}
		
		void _ReadEvents() {
			//print.it(">>>");
			while (!_ignoreEvents && _p != null) {
				int canRead = _p.CanReadNow_;
				if (canRead == 0) break;
				if (canRead < 0 || !_p.ReadLine(out var k)) {
					_Print("Debugger crashed.");
					_events("^exit");
					return;
				}
				//print.qm2.write($"_ReadEvents:  {k}");
				if (k is not ("(gdb)" or "")) {
					try { _events(k); }
					catch (Exception e1) {
						print.it(e1);
						_events("^exit");
						return;
					}
				}
			}
			//print.it("<<<");
			if (_p == null) return;
			_fs.BeginRead([], 0, 0, ar => {
				while (_ignoreEvents) Thread.Sleep(10);
				App.Dispatcher.InvokeAsync(_readEvents);
			}, null);
		}
		
		public void Dispose() {
			if (_p == null) return;
			_p.Dispose();
			_p = null;
			_fs?.Dispose();
		}
		
		bool _Write(string s) {
			try { _p.Write(s); }
			catch (AuException e1) {
				_Print("Debugger crashed.");
				Debug_.Print(e1);
				Dispose();
				App.Dispatcher.InvokeAsync(() => _events("^exit"));
				return false;
			}
			return true;
		}
		
		/// <summary>
		/// Writes <i>s</i>. Does not read.
		/// </summary>
		/// <param name="s">Command, optionally with a token &gt;=1000, like "1020-command".</param>
		public void Send(string s) {
			_Write(s);
		}
		
		/// <summary>
		/// Writes token+s, like "5-command".
		/// Then synchronously reads until received a line that starts with the token followed by '^'. For other received lines calls the events callback.
		/// </summary>
		/// <param name="token">A number 1-999. Token 0 is used by this class.</param>
		/// <param name="noEvent">Called on events. Return true to not call the events callback.</param>
		/// <returns>The received line without token. Returns null if the debugger process ended.</returns>
		public string SendSync(int token, string s, Func<string, bool> noEvent = null) {
			var st = token.ToS();
			if (!_Write(st + s)) return null;
			_ignoreEvents = true;
			try {
				while (_p.ReadLine(out var k)) {
					//print.qm2.write($"SendSync:  {k}");
					if (k.Starts(st) && k.Eq(st.Length, '^')) return k[st.Length..];
					if (k is not ("(gdb)" or "")) {
						if (noEvent?.Invoke(k) == true) continue;
						_events(k);
					}
				}
			}
			finally { _ignoreEvents = false; }
			return null;
		}
	}
}


================================================
FILE: Au.Editor/Debugger/PD._MiRecord.cs
================================================
using System.Text.Json;
using System.Text.Json.Nodes;

namespace LA;

partial class PanelDebug {
	record class _MiRecord {
		public readonly int token;
		public readonly char kind;
		public readonly string name;
		public readonly JsonObject data;
		
		public _MiRecord(RStr s) {
			if (char.IsAsciiDigit(s[0])) {
				if (!s.ToInt_(out token, out int e)) throw new ArgumentException();
				s = s[e..];
			}
			kind = s[0];
			if (kind is not ('^' or '*' or '+' or '=' or '~' or '@' or '&')) throw new ArgumentException();
			s = s[1..];
			int i = s.IndexOf(',');
			if (i < 0) {
				name = s.ToString();
			} else {
				name = s[..i].ToString();
				s = s[++i..];
				data = _ReadObject(ref s, true, name);
			}
		}
		
		static JsonObject _ReadObject(ref RStr s, bool root, string fieldName) {
			if (!root) s = s[1..];
			var r = new JsonObject();
			for (bool once = false; ;) {
				if (root) { if (s.Length == 0) break; } else if (s[0] == '}') { s = s[1..]; break; }
				if (!once) once = true; else if (s[0] == ',') s = s[1..]; else throw new ArgumentException(s.ToString());
				
				int i = s.IndexOf('=');
				string name = s[..i].ToString().Replace('-', '_');
				s = s[++i..];
				r[name] = _ReadValue(ref s, name);
			}
#if DEBUG
			if (fieldName != null) _PrintType(r, fieldName);
#endif
			return r;
		}
		
		static JsonArray _ReadList(ref RStr s, string fieldName) {
#if DEBUG
			fieldName = fieldName?.TrimEnd('s'); //eg threads -> thread
#endif
			s = s[1..];
			var r = new JsonArray();
			for (bool once = false; ;) {
				if (s[0] == ']') { s = s[1..]; break; }
				if (!once) once = true; else if (s[0] == ',') s = s[1..]; else throw new ArgumentException();
				
				if (s[0] is not ('"' or '{' or '[')) { //name=value
					int i = s.IndexOf('=');
					string name = s[..i].ToString();
					s = s[++i..];
#if DEBUG
					if (fieldName != null) fieldName = name;
#endif
				}
				
				r.Add(_ReadValue(ref s, fieldName));
				fieldName = null; //print type once
			}
			return r;
		}
		
		static JsonNode _ReadValue(ref RStr s, string fieldName) {
			return s[0] switch {
				'"' => _ReadString(ref s),
				'{' => _ReadObject(ref s, false, fieldName),
				'[' => _ReadList(ref s, fieldName),
				_ => throw new ArgumentException()
			};
		}
		
		static string _ReadString(ref RStr s) {
			for (int i = 1; ; i++) {
				i = s.IndexOf(i, '"');
				bool esc = false; for (int j = i; s[--j] == '\\';) esc ^= true;
				if (!esc) {
					var r = s[1..i].ToString().Unescape();
					s = s[++i..];
					return r;
				}
			}
		}
		
#if DEBUG
		static void prt(RStr s) { print.it(s.ToString()); }
#endif
		
		public T Data<T>() {
			return data.Deserialize<T>(s_jso);
		}
		
		static JsonSerializerOptions s_jso = new(JsonSerializerDefaults.General) {
			IncludeFields = true,
			NumberHandling = System.Text.Json.Serialization.JsonNumberHandling.AllowReadingFromString,
#if DEBUG
			UnmappedMemberHandling = System.Text.Json.Serialization.JsonUnmappedMemberHandling.Disallow
#endif
		};
		
#if DEBUG
		static void _PrintType(JsonObject x, string fieldName) {
			//var b = new StringBuilder();
			//foreach (var (k, v) in x) {
			//	if (b.Length > 0) b.Append(", "); else b.Append("record ").Append('_').Append(fieldName.Replace('-', '_').Upper()).Append('(');
			//	switch (v.GetValueKind()) {
			//	case JsonValueKind.String:
			//		var s = (string)v;
			//		if (s.ToInt(out int i1, 0, out int e, STIFlags.DontSkipSpaces | STIFlags.NoHex) && e == s.Length) b.Append("int"); else b.Append("string");
			//		break;
			//	case JsonValueKind.Object:
			//		b.Append('_').Append(k.Upper());
			//		break;
			//	case JsonValueKind.Array:
			//		b.Append('_').Append(k.Upper()).Append("[]");
			//		break;
			//	}
			//	b.Append(' ').Append(k);
			//}
			//b.Append(");");
			//print.it($"<><c green>{b.ToString()}<>");
		}
#endif
	}
}


================================================
FILE: Au.Editor/Debugger/PanelBreakpoints.cs
================================================
using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;
using Au.Controls;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis;
using System.Xml.Linq;

namespace LA;

class PanelBreakpoints {
	KTreeView _tv;
	_Item _root;
	string _file;
	bool _initOnce;
	int _save;
	
	public PanelBreakpoints() {
		_tv = new() { Name = "Breakpoints_list", SingleClickActivate = true, HasCheckboxes = true, SmallIndent = true };
		P.Children.Add(_tv);
		
		FilesModel.AnyWorkspaceLoadedAndDocumentsOpened += _LoadIfNeed;
		
		Panels.PanelManager["Breakpoints"].DontActivateFloating = e => e == _tv;
	}
	
	public DockPanel P { get; } = new();
	
	void _LoadIfNeed() {
		if (_root != null) return;
		_root = new(this, null, true);
		
		_file = $@"{App.Model.WorkspaceDirectory}\.state{(miscInfo.isChildSession ? @"\pip" : null)}\breakpoints.xml";
		if (filesystem.exists(_file).File) {
			try {
				var xr = XElement.Load(_file);
				foreach (var xf in xr.Elements("file")) {
					if (xf.Attr(out int id, "id") && App.Model.FindById((uint)id) is { } f) {
						_Item folder = new(this, f, xf.HasAttr("exp"));
						_root.AddChild(folder);
						foreach (var xb in xf.Elements("b")) folder.AddChild(new(this, xb));
					} else {
						_SaveLater(1);
					}
				}
			}
			catch (Exception e1) { print.it(e1); }
		}
		_TvSetItems();
		
		if (!_initOnce) {
			_initOnce = true;
			
			FilesModel.UnloadingAnyWorkspace += () => {
				if (_root == null) return;
				SaveNowIfNeed();
				_root = null;
				_TvSetItems();
			};
			
			FilesModel.NeedRedraw += v => {
				if (!v.renamed) return;
				var f = _FindItemOfFile(v.f);
				if (f != null) _tv.Redraw(f, v.remeasure);
			};
			
			_tv.ItemActivated += e => {
				if (e.Mod != 0) return;
				if (e.Item is _Item b && !b.IsFolder) {
					App.Model.OpenAndGoTo(b.Parent.file, b.line);
				}
			};
			
			_tv.ItemClick += e => {
				var b = e.Item as _Item;
				switch (e.Button) {
				case MouseButton.Left when e.Part is TVParts.Checkbox:
					_SetEnabled(b, !b.IsEnabledOrHasEnabledChildren);
					break;
				case MouseButton.Left:
					switch (e.Mod) {
					case ModifierKeys.Control: _DeleteItem(b); break;
					}
					break;
				case MouseButton.Right:
					_ContextMenu(b);
					break;
				case MouseButton.Middle:
					_SetEnabled(b, !b.IsEnabledOrHasEnabledChildren);
					break;
				}
			};
			
			_tv.PreviewKeyDown += (_, e) => {
				if (e.Key is Key.Up or Key.Down && e.KeyboardDevice.Modifiers == ModifierKeys.Shift && _tv.FocusedItem is _Item { IsFolder: true } f) {
					e.Handled = true;
					_MoveFolder(f, e.Key is Key.Up);
				}
			};
			
			_tv.RightClickInEmptySpace += () => _ContextMenu(null);
			
			App.Timer1sWhenVisible += () => { if (_save != 0 && --_save <= 0) _SaveNow(); };
		}
	}
	
	public void SaveNowIfNeed() {
		if (_save != 0) _SaveNow();
	}
	
	void _SaveNow() {
		var xr = new XElement("breakpoints");
		for (var f = _root.FirstChild; f != null; f = f.Next) {
			var xf = new XElement("file");
			xf.SetAttributeValue("id", f.file.IdString);
			if (f.IsExpanded) xf.SetAttributeValue("exp", "");
			xr.Add(xf);
			for (var b = f.FirstChild; b != null; b = b.Next) {
				var xb = new XElement("b");
				xb.SetAttributeValue("line", b.line.ToS());
				xb.SetAttributeValue("name", b.name);
				if (b.IsEnabled) xb.SetAttributeValue("en", "");
				if (!b.condition.NE()) xb.SetAttributeValue("condition", b.condition);
				if (!b.log.NE()) xb.SetAttributeValue("log", b.log);
				if (b.LogExpression) xb.SetAttributeValue("flags", "1");
				xf.Add(xb);
			}
		}
		
		if (!App.Model.TryFileOperation(FOSync.PrivateFileWrite, () => { xr.SaveElem(_file); })) return;
		_save = 0;
		//print.it("saved");
	}
	
	void _SaveLater(int afterS = 30) {
		//print.it(new StackTrace(true));
		_save = _save == 0 ? afterS : Math.Min(_save, afterS);
	}
	
	internal void SciLoaded(SciCode doc) {
		_LoadIfNeed();
		var f = _FindItemOfFile(doc); if (f == null) return;
		bool removed = false;
		for (var b = f.FirstChild; b != null;) {
			if (b.SetMarkerInDoc()) b = b.Next;
			else {
				var bb = b; b = b.Next;
				bb.Remove();
				removed = true;
				_SaveLater(1);
			}
		}
		if (removed) _TvSetItems(true);
	}
	
	_Item _FindItemOfFile(FileNode fn) {
		if (_root != null && fn != null)
			for (var f = _root.FirstChild; f != null; f = f.Next)
				if (f.file == fn) return f;
		return null;
	}
	_Item _FindItemOfFile(SciCode doc) => _FindItemOfFile(doc?.EFile);
	
	public void ToggleBreakpoint(int pos8 = -1, bool logpoint = false) {
		var doc = Panels.Editor.ActiveDoc;
		if (doc == null || !doc.EFile.IsCodeFile) return;
		bool useSelStart = pos8 < 0;
		int line = useSelStart ? doc.aaaLineFromPos() : doc.aaaLineFromPos(false, pos8);
		if (_IsBreakpoint(doc, line)) {
			_DeleteBreakpoint(doc, line);
		} else {
			if (!useSelStart) if (doc.aaaLineFromPos() == line) useSelStart = true;
			
			int h = doc.aaaMarkerAdd(logpoint ? SciTheme.Marker.BreakpointL : SciTheme.Marker.Breakpoint, line); if (h < 0) return;
			var folder = _FindItemOfFile(doc);
			if (folder == null) {
				_root.AddChild(folder = new(this, doc.EFile, true), true);
			} else folder.SetIsExpanded(true);
			
			var name = PanelBookmarks.GetMarkerName_(doc, line, useSelStart) ?? "Breakpoint";
			_Item b = new(this, line, h, name) { IsEnabled = true, log = logpoint ? "LOGPOINT" : null };
			if (folder.Children().FirstOrDefault(o => o.line > line) is { } b2) b2.AddSibling(b, false);
			else folder.AddChild(b);
			
			_TvSetItems(true);
			_tv.SelectSingle(b);
			_SaveLater();
			
			if (logpoint) _BreakpointProperties(b, doc);
		}
	}
	
	void _SetEnabled(_Item b, bool enabled) {
		if (b.IsFolder) {
			foreach (var v in b.Children()) _SetEnabled(v, enabled);
		} else if (b.IsEnabled != enabled) {
			b.IsEnabled = enabled;
			_tv.Redraw(b);
			b.SetMarkerInDoc();
		}
		_SaveLater();
	}
	
	internal bool SciMiddleClick_(SciCode doc, int line) {
		if (_BreakpointFromLine(doc, line) is not { } b) return false;
		_SetEnabled(b, !b.IsEnabled);
		return true;
	}
	
	internal void AddMarginMenuItems_(SciCode doc, popupMenu m, int line, int pos8) {
		if (_BreakpointFromLine(doc, line) is { } b) {
			m["Delete breakpoint", "*Material.MinusCircle @12 #EE3000"] = o => ToggleBreakpoint(pos8);
			m["Breakpoint properties..."] = o => _BreakpointProperties(b, doc);
			m.AddCheck("Enabled breakpoint\tM-click", b.IsEnabled, o => _SetEnabled(b, o.IsChecked));
		} else {
			m["Add breakpoint", "*Material.Circle @12 #EE3000"] = o => ToggleBreakpoint(pos8);
			m["Add logpoint", "*BootstrapIcons.DiamondFill @14" + EdIcons.green2] = o => ToggleBreakpoint(pos8, true);
		}
	}
	
	void _BreakpointProperties(_Item x, DependencyObject owner) {
		var w = new KDialogWindow();
		w.InitWinProp("Breakpoint properties", owner);
		var b = new wpfBuilder(w).Width(300..800);
		b.R.Add("Condition", out TextBox eCondition, x.condition).Font("Consolas")
			.Tooltip("""
Break when this expression evaluates to true.
Example: i==5
Not all kinds of expressions are supported.
Conditional breakpoints have different marker and Breakpoints panel text color.
""");
		//b.R.Add("Hit count", out TextBox eHit).Width(50, "L");
		b.R.Add("Message", out TextBox eLog, x.log)
			.Tooltip("""
Print this text or expression instead of pausing.
Such breakpoints are known as logpoints, tracepoints.
Green marker and Breakpoints panel text color.
Simple text examples:
  Simple text
  Text with <b>output tags<>
Expression examples:
  "Multiline\nstring"
  variable
  "variable=" + variable
  "<c red>x.y=" + x.y + "<>"
  Au.clipboard.text
""");
		b.R.Skip().Add(out KCheckBox cLE, "Message is expression").Checked(x.LogExpression)
			.Tooltip("""
Message is a C# expression. See examples in Message tooltip.
Not all kinds of expressions are supported.
""");
		b.R.AddOkCancel();
		b.End();
		var e1 = !x.log.NE() ? eLog : eCondition; e1.SelectAll(); e1.Focus();
		if (!w.ShowAndWait()) return;
		
		string cond = eCondition.TextOrNull(), log = eLog.TextOrNull();
		bool isLE = cLE.IsChecked;
		if (cond != x.condition || log != x.log || isLE != x.LogExpression) {
			x.condition = cond;
			x.log = log;
			x.LogExpression = isLE;
			_SaveLater();
			_tv.Redraw(x);
			x.SetMarkerInDoc();
			Panels.Debug.BreakpointPropertiesChanged_(x);
		}
	}
	
	internal void SciMouseDwell_(bool started, SciCode doc, in Sci.SCNotification n) {
		if (_marginTooltip != null) _marginTooltip.IsOpen = false;
		if (n.position >= 0 || !doc.EFile.IsCodeFile) return;
		if (started) {
			int margin = doc.aaaMarginFromPoint((n.x, n.y));
			if (margin != SciTheme.Margin.Markers) return;
			int pos = doc.aaaPosFromXY(false, (n.x, n.y), false);
			int line = doc.aaaLineFromPos(false, pos);
			if (_BreakpointFromLine(doc, line) is { } b && b.HasProperties) {
				_marginTooltip ??= new ToolTip { Placement = System.Windows.Controls.Primitives.PlacementMode.MousePoint, HorizontalOffset = 20 };
				_marginTooltip.PlacementTarget = doc;
				b.TooltipSetContent(_marginTooltip);
				_marginTooltip.IsOpen = true;
			}
		}
	}
	ToolTip _marginTooltip;
	
	void _TvSetItems(bool modified = false) {
		if (_root?.Count > 0) {
			_tv.SetItems(_root.Children(), modified);
		} else {
			_tv.SetItems(null);
		}
	}
	
	void _ContextMenu(_Item b) {
		var m = new popupMenu();
		
		if (b != null) {
			_tv.SelectSingle(b);
			
			if (b.IsFolder) {
				m["Move up\tShift+Up", disable: b.Previous == null] = o => _MoveFolder(b, true);
				m["Move down\tShift+Down", disable: b.Next == null] = o => _MoveFolder(b, false);
				m.Separator();
				bool haveEnabled1 = b.IsEnabledOrHasEnabledChildren;
				m[haveEnabled1 ? "Disable these breakpoints\tM-click" : "Enable these breakpoints\tM-click"] = o => _SetEnabled(b, !haveEnabled1);
				m["Delete these breakpoints\tCtrl+click"] = o => _DeleteItem(b);
			} else {
				m["Delete\tCtrl+click"] = o => _DeleteItem(b);
				m["Properties..."] = o => _BreakpointProperties(b, P);
				m.AddCheck("Enabled\tM-click", b.IsEnabled, o => _SetEnabled(b, o.IsChecked));
			}
			m.Separator();
		} else if (!(_root?.Count > 0)) {
			print.it("To add a breakpoint, click the white margin in the code editor.");
			return;
		}
		
		bool haveEnabled = _root.IsEnabledOrHasEnabledChildren;
		m[haveEnabled ? "Disable all breakpoints" : "Enable all breakpoints"] = o => { foreach (var v in _root.Children()) _SetEnabled(v, !haveEnabled); };
		m.Submenu("Delete all", m => {
			m["Delete all disabled breakpoints"] = o => {
				foreach (var v in _root.Descendants().ToArray()) if (!v.IsFolder && !v.IsEnabled) _DeleteItem(v);
			};
			m["Delete all breakpoints"] = o => {
				foreach (var v in _root.Children().ToArray()) _DeleteItem(v);
			};
		});
		
		m.Show(owner: _tv);
	}
	
	bool _IsBreakpoint(SciCode doc, int line) => (doc.Call(Sci.SCI_MARKERGET, line) & 63 << SciTheme.Marker.Breakpoint) != 0;
	
	_Item _BreakpointFromLine(SciCode doc, int line) {
		if (_FindItemOfFile(doc) is { } folder) {
			for (int i = 0; ; i++) {
				int h = doc.Call(Sci.SCI_MARKERHANDLEFROMLINE, line, i);
				if (h < 0) return null;
				for (var b = folder.FirstChild; b != null; b = b.Next) if (b.markerHandle == h) return b;
			}
		}
		return null;
	}
	
	void _DeleteBreakpoint(SciCode doc, int line, bool sciDelete = true) {
		if (_BreakpointFromLine(doc, line) is { } b) {
			if (sciDelete) doc.aaaMarkerDeleteHandle(b.markerHandle);
			_DeleteBreakpointL(b);
		}
	}
	
	void _DeleteBreakpointL(_Item b) {
		if (b.IsEnabled) Panels.Debug.BreakpointAddedDeleted_(b, false);
		var folder = b.Parent;
		b.Remove();
		if (!folder.HasChildren) folder.Remove();
		_TvSetItems(true);
		_SaveLater();
	}
	
	void _DeleteItem(_Item b) {
		if (b.IsFolder) {
			foreach (var v in b.Children().ToArray()) _DeleteItem(v);
		} else {
			var folder = b.Parent;
			if (b.markerHandle != 0 && folder.file.OpenDoc is { } doc) {
				doc.aaaMarkerDeleteHandle(b.markerHandle);
			}
			_DeleteBreakpointL(b);
		}
	}
	
	internal void FileDeleted(IEnumerable<FileNode> files) {
		foreach (var file in files) {
			if (_FindItemOfFile(file) is { } folder) {
				foreach (var b in folder.Children()) if (b.IsEnabled) Panels.Debug.BreakpointAddedDeleted_(b, false);
				folder.Remove();
				_TvSetItems(true);
				_SaveLater();
			}
		}
	}
	
	void _MoveFolder(_Item f, bool up) {
		if (up && f == _root.FirstChild) return;
		var ff = up ? f.Previous : f.Next;
		if (ff == null) return;
		f.Remove();
		ff.AddSibling(f, after: !up);
		_TvSetItems(true);
		_SaveLater();
	}
	
	internal void SciDeletingLineWithMarker(SciCode doc, int line) {
		_DeleteBreakpoint(doc, line, false);
	}
	
	internal void SciModified(SciCode doc, in Sci.SCNotification n) {
		if (n.linesAdded != 0) {
			//update the line field, and display
			var folder = _FindItemOfFile(doc);
			if (folder == null) return;
			bool redraw = false;
			for (var b = folder.FirstChild; b != null; b = b.Next) {
				int line = doc.Call(Sci.SCI_MARKERLINEFROMHANDLE, b.markerHandle);
				if (line != b.line) {
					b.line = line;
					redraw = true;
					_SaveLater(2 * 60);
				}
			}
			if (redraw && folder.IsExpanded) _tv.Redraw();
		}
	}
	
	internal IEnumerable<IBreakpoint> GetBreakpoints(bool disabledToo = false) {
		for (var f = _root.FirstChild; f != null; f = f.Next) {
			for (var b = f.FirstChild; b != null; b = b.Next) {
				if (disabledToo || b.IsEnabled) yield return b;
			}
		}
	}
	
	class _Item : TreeBase<_Item>, ITreeViewItem, IBreakpoint {
		readonly PanelBreakpoints _view;
		public readonly FileNode file; //if folder
		public int line, markerHandle; //if breakpoint
		public string condition, log; //if breakpoint
		public readonly string name;
		readonly bool _isFolder;
		bool _isExpanded;
		bool _isEnabled;
		
		//folder
		public _Item(PanelBreakpoints view, FileNode file, bool isExpanded) {
			_view = view;
			this.file = file;
			_isFolder = true;
			_isExpanded = isExpanded;
		}
		
		//new breakpoint
		public _Item(PanelBreakpoints bv, int line, int markerHandle, string name) {
			_view = bv;
			this.line = line;
			this.markerHandle = markerHandle;
			this.name = name;
		}
		
		//loading breakpoint
		public _Item(PanelBreakpoints bv, XElement x) {
			_view = bv;
			line = x.Attr("line", 0);
			name = x.Attr("name");
			_isEnabled = x.HasAttr("en");
			condition = x.Attr("condition");
			log = x.Attr("log");
			if (x.Attr(out int flags, "flags")) {
				if ((flags & 1) != 0) LogExpression = true;
			}
		}
		
#if DEBUG
		public override string ToString() => ((ITreeViewItem)this).DisplayText;
#endif
		
		public bool IsEnabledOrHasEnabledChildren => IsFolder ? Children().Any(static o => o.IsEnabledOrHasEnabledChildren) : _isEnabled;
		
		public bool SetMarkerInDoc() {
			if (Parent.file.OpenDoc is { } doc) {
				if (markerHandle != 0) { doc.aaaMarkerDeleteHandle(markerHandle); markerHandle = 0; }
				int marker = !log.NE() ? SciTheme.Marker.BreakpointL : !condition.NE() ? SciTheme.Marker.BreakpointC : SciTheme.Marker.Breakpoint;
				if (!_isEnabled) marker++;
				var h = doc.aaaMarkerAdd(marker, line);
				if (h != -1) { markerHandle = h; return true; }
			}
			return false;
		}
		
		//ITreeViewItem
		
		public bool IsFolder => _isFolder;
		
		public bool IsExpanded => _isExpanded;
		
		public void SetIsExpanded(bool yes) { _isExpanded = yes; _view._SaveLater(5 * 60); }
		
		IEnumerable<ITreeViewItem> ITreeViewItem.Items => base.Children();
		
		string ITreeViewItem.DisplayText => _isFolder ? (file.Parent.HasParent ? $"{file.Name}  [{file.Parent.ItemPath}]" : file.Name) : $"{(line + 1).ToS()}  {name}";
		//never mind: after moving the file should display the new path (just redraw).
		
		object ITreeViewItem.Image => _isFolder ? EdIcons.FolderArrow(_isExpanded) : null;
		
		TVParts ITreeViewItem.NoParts => _isFolder ? TVParts.Checkbox : TVParts.Image;
		
		TVCheck ITreeViewItem.CheckState => _isEnabled ? TVCheck.Checked : TVCheck.Unchecked;
		
		int ITreeViewItem.TextColor(TVColorInfo ci) => !log.NE() ? 0x00A000 : !condition.NE() ? (ci.isHighContrastDark ? 0x8080FF : 0x0000FF) : -1;
		
		int ITreeViewItem.TooltipDelay => HasProperties ? 500 : 0;
		
		public void TooltipSetContent(ToolTip tt) {
			if (tt.Content is not TextBlock k) tt.Content = k = new TextBlock { FontFamily = new("Consolas") };
			string s1 = condition.NE() ? null : "Condition: ", s2 = log.NE() ? null : condition.NE() ? "Message: " : "\nMessage: ";
			k.Text = $"{s1}{condition}{s2}{log}";
		}
		
		//IBreakpoint
		
		FileNode IBreakpoint.File => file ?? Parent.file;
		
		int IBreakpoint.Line => line;
		
		string IBreakpoint.Condition => condition;
		
		string IBreakpoint.Log => log;
		
		public bool LogExpression { get; set; }
		
		public bool HasProperties => !(condition.NE() && log.NE());
		
		public bool IsEnabled {
			get => _isEnabled;
			set {
				if (value == _isEnabled) return;
				_isEnabled = value;
				Panels.Debug.BreakpointAddedDeleted_(this, _isEnabled);
			}
		}
		
		int IBreakpoint.Id { get; set; }
	}
}

interface IBreakpoint {
	FileNode File { get; }
	int Line { get; }
	string Condition { get; }
	string Log { get; }
	bool LogExpression { get; set; }
	bool HasProperties { get; }
	bool IsEnabled { get; }
	int Id { get; set; }
}


================================================
FILE: Au.Editor/Debugger/PanelDebug.cs
================================================
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Text;

using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;
using Au.Controls;

namespace LA;

partial class PanelDebug {
	_Debugger _d;
	(Button debug, Button restart, Button next, Button step, Button stepOut, Button @continue, Button pause, Button end) _buttons;
	ComboBox _cbThreads;
	KPanels.ILeaf _ipanel;
	bool _restart;
	_Session _s;
	static IntPtr s_event;
	
	record class _Session(int processId, bool attachMode) {
		public FileNode file;
		public int threadId;
		public _FRAME frame;
		public bool attached, stepping, inStoppedEvent, stoppedOnException;
		public (int breakpointId, bool nonstop) runToHere;
		public _RthData restartToHere;
		public Process process;
		public string[] exceptionsT, exceptionsU;
		public _STOPPED thrownException;
		public string tePath;
		public TextSpan teSpan;
		public List<int> startedThreads;
		public Dictionary<string, string> modules = new();
	}
	
	public PanelDebug() {
		P.UiaSetName("Debug panel");
		
		var b = new wpfBuilder(P).Columns(-1).Brush(SystemColors.ControlBrush);
		b.Options(margin: new());
		
		var tb = b.xAddToolBar(hideOverflow: true);
		tb.UiaSetName("Debug_toolbar");
		const string c_color = EdIcons.blue, c_color2 = EdIcons.green2, c_color3 = EdIcons.black;
		_buttons.debug = _TbButton("*Material.Bug" + c_color2, _ => _Start(), "Run with debugger.\nWill stop (pause) at a breakpoint or exception line.\nTo add a breakpoint, click the white margin in the code editor.");
		_buttons.restart = _TbButton("*Codicons.DebugRestart" + c_color2, _ => _Restart(), "Restart");
		_buttons.end = _TbButton("*Material.SquareOutline @14" + c_color3, button => {
			if (_s == null) return;
			if (_s.attachMode) {
				var m = new popupMenu();
				m.Add("Disconnect", o => _Disconnect(), "*Codicons.DebugDisconnect").Tooltip = "Continue without debugger";
				m.Add("End task", o => _End(), "*Material.SquareOutline @14").Tooltip = "Stop debugging and end task";
				var r = button.RectInScreen();
				m.Show(xy: new(r.left, r.bottom), excludeRect: r, owner: button);
			} else {
				_End();
			}
		}, "Stop debugging and end task.\nRight click to disconnect the debugger only.");
		_buttons.end.xContextMenu(m => {
			m.Add("Disconnect", o => _Disconnect(), "*Codicons.DebugDisconnect", disable: !IsDebugging).Tooltip = "Continue without debugger";
		});
		tb.Items.Add(new Separator());
		_buttons.@continue = _TbButton("*Codicons.DebugContinue @14" + c_color, _ => _Continue(), "Continue\n\nF5");
		_buttons.pause = _TbButton("*Codicons.DebugPause @14" + c_color, _ => _Pause(), "Pause\n\nF6");
		_buttons.next = _TbButton("*Codicons.DebugStepOver @14" + c_color, _ => _Next(), "Step over\n\nF10");
		_buttons.step = _TbButton("*Codicons.DebugStepInto" + c_color, _ => _Step(), "Step into\n\nF11");
		_buttons.stepOut = _TbButton("*Codicons.DebugStepOut" + c_color, _ => _StepOut(), "Step out\n\nShift+F11");
		tb.Items.Add(new Separator());
		//_TbButton("*BoxIcons.RegularMenu" + c_color3, null,  "More debugger commands").xDropdownMenu(_CommandsMenu);
		_TbButton("*EvaIcons.Options2" + EdIcons.green, null, "Debugger options").xDropdownMenu(_OptionsMenu);
#if DEBUG
		_TbButton("*WeatherIcons.SnowWind #FF3300", _ => { _Test(); }, "Test");
#endif
		
		Button _TbButton(string icon, Action<Button> click, string tooltip/*, bool overflow = false*/) {
			var v = tb.AddButton(icon, click, tooltip);
			//if (overflow) ToolBar.SetOverflowMode(v, OverflowMode.Always);
			return v;
		}
		
		b.Options(margin: new());
		
		using (_Header("Variables", false)) {
			
		}
		_VariablesViewInit();
		b.Row((-Math.Max(1, App.Settings.debug.hVar), 1..)).xAddInBorder(_tvVariables, thickness: new(0, 0, 0, 1));
		
		using (_Header("Call stack", true, 0, 16, -1)) {
			b.Skip().Add(out _cbThreads).Tooltip("Threads.\nThe text is thread id and name (Thread.Name).");
			_cbThreads.SelectionChanged += (_, _) => { if (_cbThreads.SelectedItem is ComboBoxItem k && k.Tag is _THREAD t) _SelectedThread(t); };
		}
		_StackViewInit();
		b.Row((-Math.Max(1, App.Settings.debug.hStack), 1..)).Add(_tvStack);
		
		b.End();
		_UpdateUI(_UU.Init);
		
		_ipanel = Panels.PanelManager["Debug"];
		_ipanel.DontActivateFloating = e => true;
		
		UsingEndAction _Header(string text, bool splitter, params WBGridLength[] cols) {
			b.Row(0);
			if (splitter) {
				b.Add(out GridSplitter k).Splitter(vertical: false, thickness: double.NaN).And(0);
				k.DragCompleted += (_, e) => { App.Settings.debug.hVar = _tvVariables.ActualHeight; App.Settings.debug.hStack = _tvStack.ActualHeight; };
			}
			b.StartGrid().Columns(cols);
			b.Add(out TextBlock t).FormatText($"<b>{text}</b>").Margin("2").Align(y: VerticalAlignment.Bottom);
			t.IsHitTestVisible = false;
			return new UsingEndAction(() => b.End());
		}
	}
	
	public UserControl P { get; } = new();
	
	public bool IsDebugging { get; private set; }
	
	public bool IsStopped { get; private set; }
	
	void _Start(FileNode restart = null, _RthData runToHere = null) {
		FileNode f;
		if (restart == null) {
			f = App.Model.CurrentFile;
			if (f == null) return;
			if (f.FindProject(out _, out var projMain)) f = projMain;
		} else {
			if (restart.IsAlien) return;
			f = restart;
		}
		
		if (IsDebugging) {
			_restart = true;
			_s.file = f;
			_s.restartToHere = runToHere;
			_End();
			return;
		}
		
		if (s_event == 0) s_event = Api.CreateEvent2(0, false, false, "Au.event.Debugger");
		else Api.ResetEvent(s_event);
		
		int processId = CompileRun.CompileAndRun(true, f, noDefer: true, runFromEditor: true, debugAttach: processId => _Attach(processId, false, f, runToHere));
		if (processId <= 0) {
			if (restart != null) _UpdateUI(_UU.Ended);
		}
	}
	
	void _Restart(_RthData runToHere = null) {
		if (_s?.file is { } f) _Start(f, runToHere);
	}
	
	bool _Attach(int processId, bool attachMode, FileNode file, _RthData runToHere = null) {
		//#if DEBUG
		//		print.clear(); print.qm2.clear();
		//#endif
		
		int arch = Cpp.Cpp_GetProcessArchitecture(processId);
		if(arch == 1) { _Print("Cannot debug x86 processes (platform x86)."); return false; }
		
		_restart = false;
		_s = new(processId, attachMode) { file = file };
		_d = new _Debugger(_Events);
		if (!_d.Init(arch == 3)) return _Failed();
		IsDebugging = true;
		
		_SetOptions();
		_SetExceptions(0);
		_SetBreakpoints();
		if (runToHere != null) _RunToHere(runToHere.file, runToHere.line, runToHere.nonstop);
		
		if (!attachMode) _TempDisableAuDebugging(true);
		
		if (_d.SendSync(1, $"-target-attach {processId}") != "^done") {
			_Print("Failed to attach debugger."); //never mind: fails to attach to 32-bit process, error "parameter incorrect"
			IsDebugging = false;
			_d.Send($"-gdb-exit");
			return _Failed();
		}
		
		_s.attached = true;
		_UpdateUI(_UU.Started);
		_PrintThread(null, true);
		_AutoShowHidePanel(true);
		RegHotkeys.RegisterDebug();
		print.it("<><lc #C0C0FF>Debugging started<>");
		Api.SetEvent(s_event); //let the process run
		return true;
		
		bool _Failed() {
			_d.Dispose();
			_d = null;
			_UpdateUI(_UU.Ended);
			_s = null;
			return false;
		}
	}
	
	public void Start() {
		_Start();
	}
	
	public bool Attach(int processId) {
		if (IsDebugging) return false;
		var f = App.Tasks.TaskFromProcessId(processId)?.f;
		if (f == null) return false;
		return _Attach(processId, true, f);
	}
	
	public bool EndIfDebugging(int processId) {
		if (!IsDebugging || processId != _s.processId) return false;
		_End();
		return true;
	}
	
	internal void WmHotkey_(RegHotkeys.Id id) {
		if (!IsDebugging) return;
		switch (id) {
		case RegHotkeys.Id.DebugNext: _Next(); break;
		case RegHotkeys.Id.DebugStep: _Step(); break;
		case RegHotkeys.Id.DebugStepOut: _StepOut(); break;
		case RegHotkeys.Id.DebugContinue: _Continue(); break;
		case RegHotkeys.Id.DebugPause: _Pause(); break;
			//case RegHotkeys.Id.DebugEnd: _End(); break;
			//case RegHotkeys.Id.DebugRestart: _Restart(); break;
		}
	}
	
	#region options, exceptions, breakpoints
	
	void _OptionsMenu(popupMenu m) {
		m[(App.Settings.debug.breakT & 9) switch { 1 => "Exceptions...  (break when thrown)", 9 => "Exceptions...  (break when caught)", _ => "Exceptions..." }] = _DExceptionTypes;
		m.AddCheck("Step into properties and operators", App.Settings.debug.stepIntoAll, o => {
			App.Settings.debug.stepIntoAll = o.IsChecked;
			if (IsDebugging) _d.Send("-gdb-set enable-step-filtering " + (o.IsChecked ? "0" : "1"));
		});
		m.AddCheck("Debug optimized code", App.Settings.debug.noJMC, o => { App.Settings.debug.noJMC = o.IsChecked; }, disable: IsDebugging);
		m.Separator();
		m.AddCheck("Print clicked variable in 1 line", App.Settings.debug.printVarCompact, o => { App.Settings.debug.printVarCompact = o.IsChecked; });
		m.AddCheck("Print 'module loaded/unloaded'", (App.Settings.debug.printEvents & 1) != 0, o => { App.Settings.debug.printEvents ^= 1; });
		m.AddCheck("Print 'thread started/ended'", (App.Settings.debug.printEvents & 2) != 0, o => { App.Settings.debug.printEvents ^= 2; });
		m.Separator();
		m.AddCheck("Activate LA when stepping", App.Settings.debug.activateLA, o => { App.Settings.debug.activateLA ^= true; });
		
		void _DExceptionTypes(PMItem mi) {
			var w = new KDialogWindow();
			w.InitWinProp("Exception settings", App.Wmain);
			var b = new wpfBuilder(w).WinSize(450, 400).Columns(-1);
			
			b.StartStack();
			b.Add(out KCheckBox cThrown, "Break when exception thrown").Checked((App.Settings.debug.breakT & 1) != 0)
				.Add(out KCheckBox cCaught, "when caught in user code").Checked((App.Settings.debug.breakT & 8) != 0).xBindCheckedEnabled(cThrown);
			b.End();
			b.StartStack().Margin("TBL16");
			b.Add(out KCheckBox cUseListT, "If exception is").Checked((App.Settings.debug.breakT & 2) != 0)
				.Add(out KCheckBox cNotT, "not").Checked((App.Settings.debug.breakT & 4) != 0).xBindCheckedEnabled(cUseListT);
			b.End();
			b.Row(-2).Add(out TextBox eListT, App.Settings.debug.breakListT).LabeledBy(cUseListT).Multiline(wrap: TextWrapping.NoWrap).Margin("B10")
				.Tooltip("""
Exception types.
If the list is empty or 'if exception is' unchecked, will break on all exceptions.
Example:
System.DivideByZeroException
System.IO.FileNotFoundException
//comment
""");
			
			b.Add(out KCheckBox cUU, "Break when exception unhandled in user code is caught elsewhere").Checked((App.Settings.debug.breakU & 1) != 0);
			b.Add<Label>("If exception is not").Margin("TBL16");
			b.Row(-1).Add(out TextBox eListU, App.Settings.debug.breakListU).LabeledBy().Multiline(wrap: TextWrapping.NoWrap)
				.Tooltip("""
Exception types.
Example:
System.OperationCanceledException
System.Threading.Tasks.TaskCanceledException
//comment
""");
			
			b.R.AddOkCancel();
			if (!w.ShowAndWait()) return;
			
			App.Settings.debug.breakListT = eListT.TextOrNull();
			App.Settings.debug.breakListU = eListU.TextOrNull();
			App.Settings.debug.breakT.SetFlag_(1, cThrown.IsChecked);
			App.Settings.debug.breakT.SetFlag_(2, cUseListT.IsChecked);
			App.Settings.debug.breakT.SetFlag_(4, cNotT.IsChecked);
			App.Settings.debug.breakT.SetFlag_(8, cCaught.IsChecked);
			App.Settings.debug.breakU.SetFlag_(1, cUU.IsChecked);
			_SetExceptions(3);
			
			//CONSIDER: allow to specify stack patterns where 'thrown' exceptions are ignored
		}
	}
	
	void _SetOptions() {
		if (App.Settings.debug.stepIntoAll) _d.Send("-gdb-set enable-step-filtering 0");
		if (App.Settings.debug.noJMC) _d.Send("-gdb-set just-my-code 0");
	}
	
	/// <param name="action">0 init, 1 change 'throw', 2 change 'user-unhandled', 3 change both.</param>
	void _SetExceptions(int action) {
		if (!IsDebugging) return;
		if (action is 0 or 1 or 3) _Apply("throw", App.Settings.debug.breakT, App.Settings.debug.breakListT, ref _s.exceptionsT);
		if (action is 0 or 2 or 3) _Apply("user-unhandled", App.Settings.debug.breakU | 6, App.Settings.debug.breakListU, ref _s.exceptionsU);
		
		void _Apply(string tuu, int flags, string types, ref string[] ids) {
			if (action != 0 && ids != null) _d.SendSync(3, $"-break-exception-delete {string.Join(' ', ids)}");
			ids = null;
			if ((flags & 1) != 0) {
				string etypes = "*";
				if ((flags & 2) != 0 && !types.NE()) {
					using (new StringBuilder_(out var sb)) {
						bool appendNot = (flags & 4) != 0;
						foreach (var v in types.Split_('\n')) {
							if (v.Starts("//")) continue;
							if (appendNot) { appendNot = false; sb.Append("--not"); }
							sb.Append(' ').Append(v);
						}
						if (sb.Length > 0) etypes = sb.ToString();
					}
				}
				var s = _d.SendSync(2, $"-break-exception-insert {tuu} {etypes}");
				if (s.Starts("^done,bkpt={")) { //^done,bkpt={number="1"}
					ids = [s.Split('"')[1]];
				} else if (s.Starts("^done,bkpt=[")) { //^done,bkpt=[{number="1"},{number="2"}]
					var a = new _MiRecord(s).data["bkpt"].AsArray();
					ids = new string[a.Count];
					for (int i = 0; i < ids.Length; i++) ids[i] = (string)a[i]["number"];
				}
			}
		}
		
		//With -break-exception-insert can be specified unhandled|user-unhandled|throw|throw+user-unhandled.
		//	It seems 'unhandled' is always on and cannot be changed.
		//	'user-unhandled' means "Break when handled exception was unhandled in user code". Eg in Task.Run action when not awaited.
	}
	
	void _SetBreakpoints() {
		foreach (var b in Panels.Breakpoints.GetBreakpoints()) {
			_SetBreakpoint(b);
		}
	}
	
	void _SetBreakpoint(IBreakpoint b) {
		b.Id = _SetBreakpoint(b.File, b.Line);
		if (_s.runToHere.nonstop && b.Id != _s.runToHere.breakpointId) _d.Send($"-break-activate false {b.Id}");
		if (b.HasProperties) _SetBreakpointCondition(b);
	}
	
	int _SetBreakpoint(FileNode f, int line) {
		var s = _d.SendSync(4, $"-break-insert \"{f.FilePath.Replace(@"\", @"\\")}:{line + 1}\"");
		var r = new _MiRecord(s);
		var d = r.Data<_DONE_BKPT>().bkpt;
		return d.number;
	}
	
	internal void BreakpointAddedDeleted_(IBreakpoint b, bool added) {
		if (!IsDebugging) return;
		if (added) {
			App.Dispatcher.InvokeAsync(() => { if (IsDebugging) _SetBreakpoint(b); });
		} else {
			int n = b.Id;
			b.Id = 0;
			Debug_.PrintIf(n == 0);
			if (n != 0 && n != _s.runToHere.breakpointId) _d.Send($"-break-delete {n}");
		}
	}
	
	internal void BreakpointPropertiesChanged_(IBreakpoint b) {
		if (IsDebugging) _SetBreakpointCondition(b);
	}
	
	void _SetBreakpointCondition(IBreakpoint b) {
		string s;
		if (b.HasProperties) {
			string cond = b.Condition, log = b.Log;
			cond = cond?.RxReplace(@"[\r\n]+", " ");
			if (log.NE()) s = cond;
			else {
				log = log.RxReplace(@"[\r\n]+", " ");
				if (!b.LogExpression) log = log.Escape(quote: true);
				else log = $"({log}).ToString()";
				if (cond.NE()) cond = "true";
				s = $"Au.More.LaDebugger_.Logpoint({cond}, {log}, \"{b.File.IdStringWithWorkspace}|{b.Line + 1}\")";
			}
		} else s = "false";
		_d.Send($"-break-condition {b.Id} {s}");
		//note: without ""
	}
	
	#endregion
	
	internal void AddMarginMenuItems_(SciCode doc, popupMenu m, int line) {
		m["Run to here", "*JamIcons.ArrowCircleDownRight @14" + EdIcons.blue] = o => _RunToHere(doc.EFile, line, false);
		m["Run to here non-stop", "*JamIcons.ArrowCircleDownRight @14" + EdIcons.blue] = o => _RunToHere(doc.EFile, line, true);
		if (IsDebugging) m["Restart and run to here non-stop", "*Codicons.DebugRestart @14" + EdIcons.green2] = o => _RunToHere(doc.EFile, line, true, true);
		if (IsStopped) m["Jump to here", "*Codicons.DebugStackframe @14" + EdIcons.green2] = o => _JumpToHere(doc.EFile, line);
	}
	
	void _Step(string s) {
		if (!IsStopped) return;
		bool step = s[0] != 'c';
		if (step && _s.stoppedOnException) s = "finish"; //workaround for: if was stopped on user-unhandled exception, 'step' and 'next' behave like 'continue'.
		_s.stoppedOnException = false;
		if (_ExecStepL(step && _s.threadId != 0 ? $"-exec-{s} --thread {_s.threadId}" : $"-exec-{s}")) {
			IsStopped = false;
			_s.stepping = step;
			_s.frame = null;
			_UpdateUI(_UU.Resumed);
		} else if (step) { //eg when paused in [Native Frames]. Never seen after modifying netcoredbg.
			_Print("Can't step here. Try 'Continue' or 'Run to here'.");
		}
	}
	
	void _Next() => _Step("next");
	
	void _Step() => _Step("step");
	
	void _StepOut() => _Step("finish");
	
	void _Continue() => _Step("continue");
	
	bool _ExecStepL(string s) {
		//return _d.SendSync(6, s) == "^running";
		return _d.SendSync(6, s, o => {
			int i = 0; while (i < o.Length && o[i].IsAsciiDigit()) i++;
			//print.it($"<><c blue>{o[i..]}<>");
			if (o.Eq(i, "^done,variables=") || o.Eq(i, "^done,stack=")) return true; //old
			return false;
		}) == "^running";
	}
	
	void _RunToHere(FileNode f, int line, bool nonstop, bool restart = false) {
		if (!IsDebugging) {
			_Start(runToHere: new(f, line, nonstop));
		} else if (restart) {
			_Restart(runToHere: new(f, line, nonstop));
		} else {
			if (_s.runToHere.breakpointId != 0) _RthEnd();
			if (_s.runToHere.nonstop = nonstop) _d.Send("-break-activate false");
			_s.runToHere.breakpointId = _SetBreakpoint(f, line);
			if (nonstop && _IsEnabledBreakpoint(_s.runToHere.breakpointId)) _d.Send($"-break-activate true {_s.runToHere.breakpointId}");
			if (IsStopped) _Continue();
		}
	}
	
	void _RthEnd() {
		if (!_IsEnabledBreakpoint(_s.runToHere.breakpointId)) _d.Send($"-break-delete {_s.runToHere.breakpointId}");
		_s.runToHere.breakpointId = 0;
		if (_s.runToHere.nonstop) { _s.runToHere.nonstop = false; _d.Send("-break-activate true"); }
	}
	
	void _JumpToHere(FileNode f, int line) {
		_s.stoppedOnException = false;
		var s = _d.SendSync(7, $"-jump \"{f.FilePath.Replace(@"\", @"\\")}:{line + 1}\"");
		if (s?.Starts("^done,sp=") == true) {
			int i = 9;
			line = s.ToInt(i, out i) - 1;
			int endLine = s.ToInt(++i, out i) - 1;
			int col = s.ToInt(++i, out i) - 1;
			int endCol = s.ToInt(++i, out i) - 1;
			App.Model.OpenAndGoTo(f, line, col, activateLA: App.Settings.debug.activateLA);
			_marker2.Delete();
			_marker.Add(line, col, endLine, endCol);
			_d.Send($"-stack-list-frames --thread {_s.threadId}");
		} else {
			if (s.Like("^error,msg=\"*\"")) s = s[12..^1];
			if (s == "SetIP cannot be done on any frame except the leaf frame.") _Print("Cannot jump to another function.");
			else _Print("Cannot jump to here. " + s);
		}
	}
	
	bool _IsEnabledBreakpoint(int id) => Panels.Breakpoints.GetBreakpoints().Any(o => o.Id == id);
	
	record class _RthData(FileNode file, int line, bool nonstop);
	
	void _Pause() {
		if (!IsDebugging || IsStopped) return;
		int tid = _s.threadId;
		if (tid == 0) { //pause main thread
			try {
				if (_s.process == null) _s.process = Process.GetProcessById(_s.processId); else _s.process.Refresh();
				tid = _s.process.Threads[0].Id;
			}
			catch (Exception e1) { Debug_.Print(e1); }
		}
		_d.Send($"-exec-interrupt --thread {tid}"); //note: netcoredbg code is modified, added --thread parameter. If --thread 0, works like without --thread.
	}
	
	void _End() {
		if (IsDebugging) _d.Send($"-exec-abort");
	}
	
	void _Disconnect() {
		if (IsDebugging) _d.Send($"-gdb-exit"); //detach and exit debugger
	}
	
	void _Events(string s) {
		if (_s == null) {
			Debug_.Print("_s==null");
			return;
		}
		
		if (s.ToInt(out int token, 0, out int endToken)) s = s[endToken..]; //info: currently not using tokens
		
#if DEBUG
		if (s.Starts("^error")) print.it($"<><c red>{s}<>");
		//else if (0 == s.Starts(true, "^done", "=message,", "=library-", "=thread-")) print.it("EVENT", s);
#endif
		
		if (s == "^exit") {
			_d.Dispose();
			_d = null;
			IsDebugging = IsStopped = false;
			_UpdateUI(_UU.Ended);
			RegHotkeys.UnregisterDebug();
			_AutoShowHidePanel(false);
			
			if (_restart) {
				_restart = false;
				var file = _s.file;
				var rth = _s.restartToHere;
				timer.after(100, _ => _Start(file, rth));
			}
			
			_s = null;
			print.it("<><lc #C0C0FF><>");
		} else if (s.Starts("*stopped")) {
			if (s.Eq(17, "exited")) {
				IsDebugging = IsStopped = false;
				_d.Send($"-gdb-exit");
				_UpdateUI(_UU.Ended);
				if (s.RxMatch(@"\bexit-code=""(.+?)""", 1, out string ec)) _Print($"The process has exited with code {ec} (0x{ec.ToInt():X}).");
			} else {
				IsStopped = true;
				
				_s.inStoppedEvent = true;
				try { if (!_Stopped(s)) return; }
				finally { _s.inStoppedEvent = false; }
				
				_UpdateUI(_UU.Paused);
			}
		} else if (s.Starts("^done,stack=")) {
			if (!IsStopped) return;
			_FRAME[] a = new _MiRecord(s).Data<_DONE_STACK>().stack;
			if (a.Length == 0) return;
			
			int iSelect = Math.Max(0, Array.FindIndex(a, o => o.fullname?.Starts(App.Model.FilesDirectory) ?? false));
			
			_StackViewSetItems(a, iSelect);
			_s.frame = a[iSelect];
			_ListVariables();
			
			if (!_marker.Exists && !_marker2.Exists) {
				for (int i = iSelect; i < a.Length; i++) {
					if (_GoToLine(a[i])) break;
				}
			}
		} else if (s.Starts("^done,variables=")) {
			if (!IsStopped) return;
			_VARIABLE[] a = new _MiRecord(s).Data<_DONE_VARIABLES>().variables;
			_VariablesViewSetItems(a);
		} else if (s.Starts('=')) {
			if (s.Starts("=library-")) {
				var r = new _MiRecord(s);
				string id = (string)r.data["id"], lib = (string)r.data["target_name"];
				if (s.Starts("=library-loaded,")) {
					_s.modules[id] = lib;
					if ((App.Settings.debug.printEvents & 1) != 0) _Print($"Module loaded{((string)r.data["symbols_loaded"] == "1" ? " with symbols" : "")}: {lib}");
				} else if (s.Starts("=library-unloaded,")) {
					_s.modules.Remove(id);
					if ((App.Settings.debug.printEvents & 1) != 0) _Print($"Module unloaded: {lib}");
				}
			} else if (s.Starts("=thread-created,id=")) {
				_PrintThread(s, true);
			} else if (s.Starts("=thread-exited,id=")) {
				_PrintThread(s, false);
				if (s.ToInt(19) == _s.threadId) _s.threadId = 0;
			} else if (s.Starts("=message,")) { //Debug.Print etc, like =message,text="TEXT\r\n",send-to="output-window",source="Debugger.Log"
				var r = new _MiRecord(s);
				var text = ((string)r.data["text"]).TrimEnd();
				_Print(text.Starts("<>") ? text[2..] : $"<\a>{text}</\a>");
				//BAD: not in sync with print.it.
			}
		}
	}
	
	//returns false to continue
	bool _Stopped(string s) {
		var x = new _MiRecord(s).Data<_STOPPED>();
		_s.threadId = x.thread_id;
		_s.stoppedOnException = false;
		var thrownException = _s.thrownException; _s.thrownException = null;
		
		switch (x.reason) {
		case "breakpoint-hit":
			if (_s.runToHere.breakpointId != 0 && x.bkptno == _s.runToHere.breakpointId) {
				_RthEnd();
				//never mind: does not delete the _runToHere breakpoint if stops there on exception
			} else {
				if (!x.exception.NE()) _Print($"<c red>{x.exception}<>"); //bad expression of condition or logpoint
			}
			break;
		case "exception-received":
			if (_StoppedOnException(x)) return false;
			_s.stoppedOnException = true;
			break;
		case "end-stepping-range":
			if (thrownException != null) if (!_DetectCatch(x, thrownException)) return false;
			break;
			//case "signal-received": //Pause or Debugger.Break
			
			//	break;
		}
		
		if (_GetThreads() is _THREAD[] a) { //fast
			a = a.Where(t => t.id == _s.threadId || !_IsHiddenThreadName(t.name)).ToArray();
			bool same = a.Length == _cbThreads.Items.Count;
			if (same) for (int i = 0; i < a.Length; i++) if (!(same = _cbThreads.Items[i] is ComboBoxItem k && k.Tag is _THREAD t && t == a[i])) break;
			if (!same) {
				_cbThreads.Items.Clear();
				foreach (var t in a) _cbThreads.Items.Add(new ComboBoxItem { Content = $"{t.id}  {t.name}", Tag = t });
			}
			
			_GoToLine(x.frame);
			
			int iSel = Array.FindIndex(a, t => t.id == _s.threadId);
			if (iSel >= 0) {
				if (iSel != _cbThreads.SelectedIndex) _cbThreads.SelectedIndex = iSel; //_cbThreads.SelectionChanged -> _SelectedThread
				else _SelectedThread(a[iSel]);
			}
		}
		
		return true;
		
		_THREAD[] _GetThreads() {
			if (_d.SendSync(5, "-thread-info") is string s && s.Starts("^done,threads=")) {
				_THREAD[] a = new _MiRecord(s).Data<_DONE_THREADS>().threads;
				foreach (var t in a) {
					var s1 = t.name;
					_GetThreadNameAndTime(t.id, out t.name, out t.time);
					if (t.name == null && s1 != "<No name>") t.name = s1;
				}
				a = a.OrderBy(o => o.time).ToArray();
				a[0].name ??= "Main Thread";
				return a;
			}
			return null;
		}
		
		bool _StoppedOnException(_STOPPED x) {
			if (_s.runToHere.nonstop && x.exception_stage != "unhandled") {
				_Continue();
				return true;
			}
			
			var stage = x.exception_stage switch { "throw" => "thrown", "user-unhandled" => "unhandled in user code", _ => x.exception_stage };
			
			if ((App.Settings.debug.breakT & 9) == 9 && x.exception_stage == "throw") {
				_s.thrownException = x;
				_s.tePath = null;
				if (_ExecStepL("-exec-finish")) return true;
				Debug_.Print("-exec-x failed on thrown exception");
				_s.thrownException = null;
			}
			
			_PrintException(x, stage, false);
			return false;
		}
		
		//Returns: true - stop, false - continue.
		bool _DetectCatch(_STOPPED x, _STOPPED thrownException) {
			var f = x.frame;
			if (!f.fullname.NE()) {
				try {
					var s = filesystem.loadText(f.fullname);
					for (int i = 0, line = 0; i < s.Length; i++) {
						if (++line == f.line) {
							int pos = i + f.col - 1;
							if (s.Eq(pos, "catch") || s.Eq(pos, "when")) {
								var tok = CiUtil.CreateSyntaxTree(s).FindToken(pos);
								var cc = tok.Parent as CatchClauseSyntax;
								if (cc == null && tok.Parent is CatchFilterClauseSyntax) cc = tok.Parent.Parent as CatchClauseSyntax;
								if (cc != null) {
									_s.thrownException = thrownException;
									_s.tePath = f.fullname;
									_s.teSpan = cc.Block.Span;
									if (_ExecStepL("-exec-next")) return false; //run until `{ }` or next `when`
									Debug_.Print("-exec-next failed on detected catch or when");
									_s.thrownException = null;
									_s.tePath = null;
									return true;
								}
							} else if (f.fullname == _s.tePath && _s.teSpan.Contains(pos)) {
								_PrintException(thrownException, "caught", true);
								break;
							}
							if (_s.stepping) break;
							_Continue();
							return false;
						}
						i = s.IndexOf('\n', i);
						if (i < 0) break;
					}
				}
				catch (Exception e1) { Debug_.Print(e1); }
			} else Debug_.Print("non-user code");
			return true;
		}
		
		void _PrintException(_STOPPED x, string stage, bool caught) {
			if (_VarCreateL("$exception.ToString()") is { } v) {
				string s = v.value.Trim('"').Unescape(), color = caught ? "#CC00FF" : "red", append = null;
				if (_VarCreateL("$exception.InnerException") is { } vi && vi.value.Starts('{')) {
					append = " See also: Debug panel > Variables > $exception > InnerException.";
				}
				_Print($"<c {color}>{stage.Upper(SUpper.FirstChar)}: {s}\r\n{append}<>");
			}
		}
	}
	
	void _SelectedThread(_THREAD t) {
		if (!IsStopped) return;
		//if (!_s.inStoppedEvent) _VariablesViewChangedFrameOrThread();
		if (t.id != _s.threadId) {
			_s.threadId = t.id;
			_ClearTreeviewsAndMarkers();
		}
		_d.Send($"-stack-list-frames --thread {_s.threadId}");
	}
	
	bool _GoToLine(_FRAME f, bool keepMarkers = false) {
		if (f != null) {
			int line = f.line - 1, col = f.col - 1, line2 = f.end_line - 1, col2 = f.end_col - 1;
			if (App.Model.OpenAndGoTo(f.fullname, line, col, activateLA: App.Settings.debug.activateLA)) {
				if (f.level > 0) {
					_marker2.Add(line, col, line2, col2);
				} else {
					_marker2.Delete();
					_marker.Add(line, col, line2, col2);
				}
				return true;
			}
		}
		if (!keepMarkers) {
			_marker.Delete();
			_marker2.Delete();
		}
		return false;
	}
	_Marker _marker = new(SciTheme.Marker.DebugLine, SciTheme.Indic.Debug), _marker2 = new(SciTheme.Marker.DebugLine2, SciTheme.Indic.Debug2);
	
	void _UpdateUI(_UU u) {
		if (u == _UU.Resumed) {
			_timerResumeUU ??= new(_ => _UpdateUI(_UU.Resumed2));
			_timerResumeUU.After(100);
		} else {
			_timerResumeUU?.Stop();
			bool deb = IsDebugging, stopped = IsStopped;
			_buttons.debug.IsEnabled = !deb;
			_buttons.restart.IsEnabled = deb && !_restart;
			_buttons.end.IsEnabled = deb;
			_buttons.next.IsEnabled = stopped;
			_buttons.step.IsEnabled = stopped;
			_buttons.stepOut.IsEnabled = stopped;
			_buttons.@continue.IsEnabled = stopped;
			_buttons.pause.IsEnabled = deb && !stopped;
			bool restart = deb || _restart;
			_buttons.debug.Visibility = !restart ? Visibility.Visible : Visibility.Collapsed;
			_buttons.restart.Visibility = restart ? Visibility.Visible : Visibility.Collapsed;
			_buttons.@continue.Visibility = !deb || stopped ? Visibility.Visible : Visibility.Collapsed;
			_buttons.pause.Visibility = deb && !stopped ? Visibility.Visible : Visibility.Collapsed;
			if (!stopped && u is _UU.Resumed2 or _UU.Ended) {
				_cbThreads.Items.Clear();
				_ClearTreeviewsAndMarkers();
			}
			
			if (u == _UU.Ended) _TempDisableAuDebugging(false);
		}
	}
	
	enum _UU { Init, Started, Ended, Paused, Resumed, Resumed2 }
	
	timer _timerResumeUU;
	
	void _ClearTreeviewsAndMarkers() {
		_StackViewSetItems(null);
		_VariablesViewSetItems(null);
		_marker.Delete();
		_marker2.Delete();
	}
	
	void _AutoShowHidePanel(bool starting) {
		if (starting) {
			if (_hidePanelWhenEnds) _timerHidePanel?.Stop();
			if (!_ipanel.Visible) _hidePanelWhenEnds = true;
			_ipanel.Visible = true;
		} else if (_hidePanelWhenEnds && !_restart) {
			_timerHidePanel ??= new timer(t => {
				if (_ipanel.Visible) {
					if (_ipanel.Parent.Panel.IsMouseOver) return;
					var w = wnd.fromMouse(WXYFlags.Raw);
					if (w == _tvVariables.Hwnd || w == _tvStack.Hwnd) return; //eg when ending/disconnecting through a context menu of a toolbar button
					_ipanel.Visible = false;
				}
				t.Stop();
				_hidePanelWhenEnds = false;
			});
			_timerHidePanel.Every(200);
		}
	}
	bool _hidePanelWhenEnds;
	timer _timerHidePanel;
	
	#region util
	
	static void _Print(string s) {
		print.it($"<><lc #f8f8d0>{s}<>");
	}
	
	static unsafe bool _GetThreadNameAndTime(int id, out string name, out long time) {
		name = null;
		using var th = Api.OpenThread(Api.THREAD_QUERY_LIMITED_INFORMATION, false, id);
		if (!Api.GetThreadTimes(th, out time, out _, out _, out _)) {
			time = long.MaxValue; //for sorting
			return false;
		}
		if (osVersion.minWin10_1607) {
			if (0x10000000 == Api.GetThreadDescription(th, out var s1) && s1 != null) {
				if (s1[0] != 0) name = new string(s1);
				Api.LocalFree(s1);
			}
		}
		return true;
	}
	
	static bool _IsHiddenThreadName(string s) => s is "Au.Aux" or ".NET TP Gate" or ".NET Tiered Compilation Worker" or ".NET Counter Poller" or ".NET Finalizer" or "Stylus Input" or "Au.JSettings";
	
	string _GetModuleName(_FRAME f) {
		if (f.clr_addr.module_id.NE()) return ""; //f.func "[Native Frames]"
		if (_s.modules.TryGetValue(f.clr_addr.module_id, out var r)) r = pathname.getName(r);
		return r;
	}
	
	string _FormatFrameString(_FRAME f/*, bool forPrint = false*/) {
		if (f.file.NE()) return $"{_GetModuleName(f)}!{f.func}";
		//if (forPrint) return $"<open {f.file}|{f.line}><\a>{f.func}  ::  {f.file} {f.line}</\a><>";
		return $"{f.func}  ::  {f.file} {f.line}";
	}
	
	void _PrintThread(string s, bool started) {
		if ((App.Settings.debug.printEvents & 2) == 0) return;
		if (s == null) { //called when attached. Detects the main thread and prints threads ordered by the start time.
			if (_s.startedThreads is { } a) {
				List<(int id, string name, long time)> k = new();
				foreach (var v in a) if (_GetThreadNameAndTime(v, out var name, out var time) && !_IsHiddenThreadName(name)) k.Add((v, name, time));
				bool once = false;
				foreach (var v in k.OrderBy(o => o.time)) {
					string name = v.name;
					if (!once) { once = true; name ??= "Main Thread"; }
					_Print($"Thread started: {v.id} {name}");
				}
			}
		} else {
			int id = s.ToInt(s.Find(",id=\"") + 5);
			if (_s.attached) {
				if (_GetThreadNameAndTime(id, out var name, out _) && !_IsHiddenThreadName(name))
					_Print($"Thread {(started ? "started" : "ended")}: {id} {name}");
			} else if (started) {
				(_s.startedThreads ??= new()).Add(id);
			}
		}
	}
	
	[Conditional("DEBUG")]
	static void _TempDisableAuDebugging(bool disable) {
		if (disable == _tempDisableAuDebugging) return;
		if (disable) if (!App.IsAtHome || Debugger.IsAttached) return;
		string from = folders.ThisAppBS + (disable ? "Au.pdb" : "Au-.pdb"), to = disable ? "Au-.pdb" : "Au.pdb";
		try { filesystem.rename(from, to, FIfExists.Delete); }
		catch (Exception e1) { Debug_.Print(e1); return; }
		_tempDisableAuDebugging = disable;
	}
	static bool _tempDisableAuDebugging;
	
	#endregion
	
	class _Marker {
		readonly int _marker, _indic;
		SciCode _doc;
		int _line, _handle;
		
		public _Marker(int marker, int indic) {
			_marker = marker;
			_indic = indic;
		}
		
		public void Add(int line, int column, int line2, int column2) {
			//Column = column;
			var doc = Panels.Editor.ActiveDoc;
			
			if (line != _line || doc != _doc) {
				Delete();
				_doc = doc;
				_line = line;
				_handle = _doc.aaaMarkerAdd(_marker, line);
			} else _doc.aaaIndicatorClear(_indic);
			
			int start = doc.aaaLineStart(false, line) + column;
			int end = doc.aaaLineStart(false, line2) + column2;
			doc.aaaIndicatorAdd(_indic, false, start..end);
		}
		
		public void Delete() {
			if (_doc == null) return;
			if (!_doc.AaWnd.Is0) {
				_doc.aaaMarkerDeleteHandle(_handle);
				_doc.aaaIndicatorClear(_indic);
			}
			_doc = null;
			_line = 0;
			_handle = 0;
		}
		
		public bool Exists => _doc != null;
		
		public SciCode Doc => _doc;
		//public int Line => _line;
		//public int Column { get; private set; }
	}
	
	#region MI output record types. Generated by _MiRecord._PrintType.
	
	record _BKPT(int number, string type, string disp, string enabled, string func, string file, string fullname, int line, string warning);
	record _DONE_BKPT(_BKPT bkpt);
	
	record _THREAD(int id, string state) { public string name; public long time; }
	record _DONE_THREADS(_THREAD[] threads);
	
	record struct _CLR_ADDR(string module_id, string method_token, int method_version, int il_offset, int native_offset);
	record _FRAME(int level, string file, string fullname, int line, int col, int end_line, int end_col, _CLR_ADDR clr_addr, string func, string addr, string active_statement_flags);
	record _STOPPED(string reason, int thread_id, string stopped_threads, int bkptno, int times, _FRAME frame, string exception_name, string exception, string exception_stage, string exception_category, string signal_name);
	
	record _DONE_STACK(_FRAME[] stack);
	
	record _VARIABLE(string name, string value);
	record _DONE_VARIABLES(_VARIABLE[] variables);
	
	record _VAR(string name, string value, string attributes, string exp, int numchild, string type, int thread_id);
	
	record _DONE_CHILDREN(int numchild, _VAR[] children, int has_more);
	
	#endregion
}

//CONSIDER: later report these small bugs and suggestions, maybe consolidated into one github issue.
//1. When stops because of exception, step commands don't work in some cases. Eg when fails to load a [DllImport] function.
//	Fix: in `AsyncStepper::SetupStep` replace `if (pFrame == nullptr) return E_FAIL;` with `if (pFrame == nullptr) return S_FALSE;`.
//2. -exec-run fails if I compiled.
//3. Debugger crashes when evaluating expression like `c[0]` with evalFlags EVAL_NOFUNCEVAL.
//	Command string: $"-var-create - \"c[0]\" --frame 0 --evalFlags 128"
//	Here c is a variable of a class with an indexer, eg List.
//4. The used Roslyn dlls are very old. They don't support newer C# features.
//5. The Roslyn scripting dlls are not used. Instead use <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.8.0" />.
//6. Both protocols (MI and VSCode) should support everything supported by the debugger. Examples:
/*
Now MI protocol supports setting options at any time (-gdb-set), but VSCode protocol only in the launch request (bot not in the attach request). Also it seems MI supports an additional option 'hot reload' (I didn't test).
Now MI protocol does not support --thread in -exec-interrupt, although VSCode supports it.
Now MI protocol does not support ExceptionBreakpoint.negativeCondition (prefix '!' in VSCode protocol).
*/


================================================
FILE: Au.Editor/Default/Commands.xml
================================================
<!--
Command XML attributes:
	color - text color. Value: .NET color name or #RRGGBB or #RGB.
	text - menu item text and toolbar button text. Insert _ before Alt-underlined character.
	image - icon name (see menu Tools > Icons) or image file (xaml, png). See ImageUtil.LoadWpfImageElement.
	keys - keyboard or/and mouse shortcut(s), like "Ctrl+E, Shift+M-click". See keys.more.parseHotkeyString.

These attributes are used only for toolbar buttons:
	separator - add separator before. Value: none.
	hide - overflow mode. Value: always, never, asNeeded (default).
	imageAt - show image + text; image at this side. Value: left, top, right, bottom. For submenu-items always left.
	btext - button text. Use if it is different than menu item text.

All attributes are optional. The Example command contains all.
<Example color="green" text="Ab" image="*Material.Forum #A6C639" keys="Ctrl+H" separator="" hide="never" imageAt="left" btext="Bc"/>
-->
<commands>
	<!-- Customized commands that maybe don't have a toolbar button. -->
	<menu>
		
	</menu>
	<!-- Toolbars. Commands added here will have a toolbar button.
	Attributes can be specified here or/and in <menu>.
	Toolbars missing in the user file are automatically added from the default file.
	Unknown toolbars and commands in the user file are ignored.
	-->
	<File>
		<New />
		<Properties />
		<MultiSelect_files />
		<Collapse_all_folders hide="always" />
		<Save_now hide="always" />
		<Git hide="always" />
	</File>
	<Run>
		<Compile />
		<Run_script />
		<End_task />
		<Debug_run />
		<Recent separator="" />
	</Run>
	<Edit>
		<Undo />
		<Redo />
		<Cut hide="always" separator="" />
		<Copy hide="always" />
		<Paste hide="always" />
		<Format_document separator="" />
		<Toggle_comment />
		<Surround />
		<Create_delegate />
		<Deduplicate_wnd_find />
		<Find separator="" />
		<Find_references />
		<Find_symbol />
		<Go_back separator="" />
		<Go_forward />
		<Next_bookmark hide="always" />
		<Wrap_lines separator="" />
		<Images_in_code />
		<WPF_preview />
		<Autocorrect_raw_enter />
	</Edit>
	<Tools>
		<Input_recorder />
		<wnd />
		<elm />
		<uiimage />
		<Keys />
		<New_trigger separator="" />
		<Options separator="" />
		<Icons />
	</Tools>
	<Custom1>

	</Custom1>
	<Custom2>

	</Custom2>
</commands>

================================================
FILE: Au.Editor/Default/Layout.xml
================================================
<!--
The layout is a tree with 3 main types of nodes: stack, tab and leaf. Leaf has 3 subtypes: panel, toolbar and document.
All nodes can be docked (default), floating or hidden. Stacks are hidden only implicitly, when there are no more docked nodes.
Tags:
stack - stack. Contains 2 or more nodes (stack, tab, leaf) and implicit splitters between them.
tab - container for 1 or more leaf nodes displayed one at a time, with buttons to select the active node.
panel - container for a control that often has child controls. Has header with text.
toolbar - container for a toolbar. Like panel, but header is small without text, and behavior is slightly different.
document - placeholder for real document nodes that are added/removed later. Like panel, but without header, and behavior is slightly different.
Attributes:
name - name of the panel or toolbar. Displayed in the panel header.
o - stack orientation: v vertical, h horizontal.
z - node size (width in horizontal stack or height in vertical). Star-sized if like "100*". Default for toolbar and stack: auto-sized. For others must be specified, cannot be auto.
s - splitter size. Default 4. Min 1. Every node in stack except the first has a splitter before it.
headerAt - Left, Top, Right, Bottom. Default Left.
state - flags: 1 hidden, 2 floating.
flags - misc flags:
	1 - splitter resizes the nearest node at each side instead of all star-sized nodes.
active - 0-based index of active node in tab. Default 0.
Attributes valid in:
name - panel, toolbar, document.
o - stack.
z, s - any. Not used if in tab.
headerAt - any except stack. Not used if in tab.
state, flags - any.
active - tab.
-->
<stack o="h">
	<stack o="v" z="800*">
		<stack o="h">
			<toolbar name="Menu" />
			<toolbar name="Tools" />
			<toolbar name="Custom1" z="100*" />
		</stack>
		<stack o="h" z="600*" s="1">
			<stack o="v" z="200">
				<toolbar name="File" />
				<tab z="320*" s="1" headerAt="Top">
					<panel name="Files" headerAt="Top" />
					<panel name="Outline" headerAt="Top" />
				</tab>
				<panel name="Open" z="80" />
				<tab z="140" headerAt="Top">
					<panel name="Find" headerAt="Top" />
					<panel name="Bookmarks" headerAt="Top" />
					<panel name="Breakpoints" headerAt="Top" />
				</tab>
			</stack>
			<stack o="v" z="600*">
				<stack o="h">
					<toolbar name="Run" />
					<toolbar name="Edit" />
					<toolbar name="Custom2" z="100*" />
				</stack>
				<stack o="h" z="500*">
					<document name="documents" z="300*" headerAt="Right" />
					<panel name="Read" z="300*" state="1" />
				</stack>
				<tab z="140">
					<panel name="Output" />
					<panel name="Found" />
					<panel name="Mouse" />
				</tab>
			</stack>
		</stack>
	</stack>
	<stack o="v" z="220">
		<tab z="1000*" headerAt="Top">
			<panel name="Help" headerAt="Top" />
			<panel name="Debug" headerAt="Top" />
		</tab>
		<panel name="Tasks" z="80" headerAt="Right" />
	</stack>
</stack>

================================================
FILE: Au.Editor/Default/Snippets.xml
================================================
<snippets>

	<!--context="Function"-->

	<snippet name="ifElseSnippet" info="if { code } else { code }">
		<![CDATA[if (${1:true}) {
	${SELECTED_TEXT}$0
} else {
	
}]]>
	</snippet>
	<snippet name="ifSurround" info="if { code }">
		<![CDATA[if (${1:true}) {
	${SELECTED_TEXT}$0
}]]>
	</snippet>
	<snippet name="forLoopSnippet" info="Repeat { code } count times." more="See also: Cookbook article &quot;for, foreach&quot;.">
		<![CDATA[for (int ${1:i} = 0; $1 < ${2:count}; $1++) {
	${SELECTED_TEXT}$0
}]]>
	</snippet>
	<snippet name="forReverseSnippet" info="Repeat { code } count times." more="See also: Cookbook article &quot;for, foreach&quot;.">
		<![CDATA[for (int ${1:i} = ${2:count}; --$1 >= 0; ) {
	${SELECTED_TEXT}$0
}]]>
	</snippet>
	<snippet name="switchSnippet" info="Go to a case that matches a variable, or default if none.">
		<list item="switch statement">
			<![CDATA[switch (${1:variable}) {
case ${2:C}:
	$0
	break;
case ${3:C}:
	
	break;
case ${4:C}:
	
	break;
case ${5:C}:
	
	break;
case ${6:C}:
	
	break;
case ${7:C}:
	
	break;
case ${8:C}:
	
	break;
case ${9:C}:
	
	break;
case ${10:C}:
	
	break;
default:
	
	break;
}]]>
		</list>
		<list item="switch &amp;expression, 1 line">
			<![CDATA[var ${1:result} = ${2:variable} switch { ${3:C} => ${4:R}, ${5:C} => ${6:R}, ${7:C} => ${8:R}, _ => ${10:default} };]]>
		</list>
		<list item="switch expression, &amp;multiline">
			<![CDATA[var ${1:result} = ${2:variable} switch {
	${3:C} => ${4:R},
	${5:C} => ${6:R},
	${7:C} => ${8:R},
	${9:C} => ${10:R},
	${11:C} => ${12:R},
	${13:C} => ${14:R},
	${15:C} => ${16:R},
	${17:C} => ${18:R},
	${19:C} => ${20:R},
	_ => ${21:default}
};]]>
		</list>
	</snippet>
	<snippet name="trySnippet" info="Exception handling." more="See also: Cookbook article &quot;Errors, exceptions&quot;.">
		<list item="catch">
			<![CDATA[try {
	${SELECTED_TEXT}
}
catch(${1:Exception} ex) { $0 }]]>
		</list>
		<list item="&amp;finally">
			<![CDATA[try {
	${SELECTED_TEXT}
}
finally { $0 }]]>
		</list>
		<list item="c&amp;atch finally">
			<![CDATA[try {
	${SELECTED_TEXT}
}
catch(${1:Exception} ex) { $0 }
finally {  }]]>
		</list>
	</snippet>
	<snippet name="threadSnippet" info="Run action in other thread.">
		<list item="Start new thread">
			<![CDATA[run.thread(() => { $0 });]]>
		</list>
		<list item="Use thread pool">
			<![CDATA[Task.Run(() => { $0 });]]>
		</list>
	</snippet>
	<snippet name="dsDialogShowSnippet" info="Standard dialog window." more="See also: wpfDialogSnippet.">
		<list item="OK button">
			<![CDATA[dialog.show("${1:header}", $"${2:text}"$3);]]>
		</list>
		<list item="OK button and &amp;info icon">
			<![CDATA[dialog.showInfo("${1:header}", $"${2:text}"$3);]]>
		</list>
		<list item="OK button and &amp;warning icon">
			<![CDATA[dialog.showWarning("${1:header}", $"${2:text}"$3);]]>
		</list>
		<list item="OK button and &amp;error icon">
			<![CDATA[dialog.showError("${1:header}", $"${2:text}"$3);]]>
		</list>
		<list item="OK and &amp;Cancel buttons">
			<![CDATA[if (!dialog.showOkCancel("${1:header}", $"${2:text}"$3)) return;]]>
		</list>
		<list item="&amp;Yes and No buttons">
			<![CDATA[if (!dialog.showYesNo("${1:header}", $"${2:text}"$3)) return;]]>
		</list>
		<list item="Custom &amp;buttons">
			<![CDATA[int button = dialog.show("${1:header}", $"${2:text}", "${3:1 OK|2 Cancel|3 Yes|4 No|5 Retry|6 Close|10 Button1|11 Button2}", flags: DFlags.CommandLinks$4);
switch (button) {
case 1: $0 break;
case 3:  break;
case 4:  break;
case 5:  break;
case 6:  break;
case 10:  break;
case 11:  break;
default: return;
}]]>
		</list>
		<list item="&amp;List of buttons">
			<![CDATA[int button = dialog.showList("${1:one|two|three}", "${2:header}", $"${3:text}"$4);}]]>
		</list>
		<list item="&amp;Text input">
			<![CDATA[if (!dialog.showInput(out string ${1:s}, "${2:header}", $"${3:text}"$4)) return;]]>
		</list>
		<list item="&amp;Number input">
			<![CDATA[if (!dialog.showInputNumber(out int ${1:i}, "${2:header}", $"${3:text}"$4)) return;]]>
		</list>
	</snippet>
	<snippet name="winFindSnippet" info="Find window.">
		<![CDATA[var w = wnd.find(0, "${1:*Name}");]]>
	</snippet>
	<snippet name="osdSnippet" info="Show OSD text (on-screen display) or tooltip.">
		<list item="Transparent text">
			<![CDATA[osdText.showTransparentText($0);]]>
		</list>
		<list item="Tooltip">
			<![CDATA[osdText.showText($0);]]>
		</list>
		<list item="Transparent text, until current function ends">
			<![CDATA[using var osd = osdText.showTransparentText($0, -1);]]>
		</list>
		<list item="Tooltip, until current function ends">
			<![CDATA[using var osd = osdText.showText($0, -1);]]>
		</list>
	</snippet>
	<snippet name="triggerSnippet" info="Add hotkey, autotext, mouse or window trigger." more="Add triggers in a file that contains triggers of this type. To open, use menu TT. Local triggers can be in any other script.">
		<list item="Hotkey">
			<![CDATA[hk["${1:Ctrl+E}"] = o => { $0 };]]>
		</list>
		<list item="Autotext">
			<![CDATA[tt["${1:text}"] = o => { $0 };]]>
		</list>
		<list item="Autotext replace">
			<![CDATA[tt["${1:text}"] = o => o.Replace("${2:replacement}");]]>
		</list>
		<list item="Autotext simple replace">
			<![CDATA[tr["${1:text}"] = "${2:replacement}";]]>
		</list>
		<list item="Autotext menu">
			<![CDATA[tt["${1:text}"] = o => o.Menu([
	"${2:replacement1}",
	new("Label1", "replacement2"),
	new("Label2", "replacement3", "<b>html</b>"),
	"<tag>[[|]]</tag>",
	]);]]>
		</list>
		<list item="Mouse click">
			<![CDATA[Triggers.Mouse[TMClick.$1] = o => { $0 };]]>
		</list>
		<list item="Mouse wheel">
			<![CDATA[Triggers.Mouse[TMWheel.$1] = o => { $0 };]]>
		</list>
		<list item="Mouse edge">
			<![CDATA[Triggers.Mouse[TMEdge.$1] = o => { $0 };]]>
		</list>
		<list item="Mouse move">
			<![CDATA[Triggers.Mouse[TMMove.$1] = o => { $0 };]]>
		</list>
		<list item="Window">
			<![CDATA[Triggers.Window[TWEvent.ActiveNew, "$1"] = o => { $0 };]]>
		</list>
		<list item="Local triggers" using="Au.Triggers">
			<![CDATA[//Script-local triggers running all the time, as main script code.
ActionTriggers Triggers = new();

//trigger examples
var hk = Triggers.Hotkey;
hk["Ctrl+F1"] = o => { print.it(o); };
hk["Win+F1"] = o => { Triggers.Stop(); };

Triggers.Run(); //waits
]]>
		</list>
		<list item="Local triggers thread" using="Au.Triggers">
			<![CDATA[//Script-local triggers running simultaneously with main script code until it ends.
run.thread(() => {
	ActionTriggers Triggers = new();
	
	//trigger examples
	var hk = Triggers.Hotkey;
	hk["Ctrl+F1"] = o => { print.it(o); };
	
	//Triggers.Mouse[TMEdge.Right] = o => { print.it(o); };
	//Triggers.Window[TWEvent.ActiveNew, "* Notepad"] = o => { print.it(o); };
	
	Triggers.Run();
});
dialog.show("Testing triggers thread"); //replace this line with real script code
]]>
		</list>
	</snippet>
	<snippet name="stringBuilderSnippet" info="Create string with StringBuilder.">
		<![CDATA[StringBuilder ${1:b} = new();
$1.Append($0);
$1.AppendLine();
$1.AppendFormat("{0}, {1}", 10, 20);
var s = $1.ToString();
print.it(s);]]>
	</snippet>
	<snippet name="ifActiveWindowSnippet" info="If the active window is...">
		<![CDATA[var ${1:w} = wnd.active;
if ($1.IsMatch("${2:*Name}")) {
	$0
}]]>
	</snippet>
	<snippet name="ifKeySnippet" info="If key is down (pressed).">
		<list item="Ctrl">
			<![CDATA[if (keys.isCtrl) { $0 }]]>
		</list>
		<list item="Shift">
			<![CDATA[if (keys.isShift) { $0 }]]>
		</list>
		<list item="Alt">
			<![CDATA[if (keys.isAlt) { $0 }]]>
		</list>
		<list item="Win">
			<![CDATA[if (keys.isWin) { $0 }]]>
		</list>
		<list item="Ctrl, Shift, Alt or Win">
			<![CDATA[if (keys.isMod()) { $0 }]]>
		</list>
		<list item="Specified key">
			<![CDATA[if (keys.isPressed(KKey.$1)) { $0 }]]>
		</list>
		<list item="Caps Lock toggled">
			<![CDATA[if (keys.isCapsLock) { $0 }]]>
		</list>
		<list item="Num Lock toggled">
			<![CDATA[if (keys.isNumLock) { $0 }]]>
		</list>
		<list item="Scroll Lock toggled">
			<![CDATA[if (keys.isScrollLock) { $0 }]]>
		</list>
	</snippet>
	<snippet name="speedOptSnippet" info="Change sleep times used by mouse, keyboard and clipboard functions.">
		<list item="All speed options">
			<![CDATA[//all speed opt, with default values. Delete lines you don't need. Edit values.
opt.key.KeySpeed = 1;
opt.key.TextSpeed = 0;
opt.key.SleepFinally = 10;
opt.key.PasteSleep = 100;
opt.key.KeySpeedClipboard = 5;
opt.mouse.ClickSpeed = 20;
opt.mouse.ClickSleepFinally = 10;
opt.mouse.MoveSpeed = 0;
opt.mouse.MoveSleepFinally = 10;
]]>
		</list>
		<list item="For windows">
			<![CDATA[//different options depending on the active window
opt.key.Hook = k => {
	var w = k.w.Window;
	//print.it(w);
	string name = w.Name, cn = w.ClassName;
	if (name.Like("*Word Online - Google Chrome")) { //example
		k.optk.TextHow = OKeyText.Paste;
		k.optk.PasteSleep = 400;
	}
	//else if (...) { ... }
	//else if (...) { ... }
};
]]>
		</list>
		<list item="For triggers">
			<![CDATA[//options for trigger actions of triggers added afterwards
Triggers.Options.BeforeAction = o => {
	//set opt options here
};
]]>
		</list>
	</snippet>
	<snippet name="perfSnippet" info="Measure code speed.">
		<list item="&amp;Static">
			<![CDATA[perf.first();$0
perf.next();
perf.nw();]]>
		</list>
		<list item="&amp;Local, auto-NW">
			<![CDATA[using var p1 = perf.local();$0
p1.Next();]]>
		</list>
	</snippet>
	<snippet name="menuSnippet" info="Popup menu.">
		<list item="Menu for automation scripts">
			<![CDATA[var ${1:m} = new popupMenu("${GUID}");

$1["${2:Text}"] = o => { $0 };
$1[""] = o => {  };
$1.Submenu("", $1 => {
	$1[""] = o => {  };
	$1[""] = o => {  };
});
$1.Separator();
$1["Run program|Tooltip"] = o => run.it(folders.System + @"notepad.exe");
$1["Run script"] = o => script.run("Script123456789.cs");
$1["Copy-paste"] = o => {
	string s = clipboard.copy();
	s = s.Upper();
	clipboard.paste(s);
};

$1.Show();]]>
		</list>
		<list item="Context menu for your program">
			<![CDATA[var ${1:m} = new popupMenu();

$1["${2:Text}"] = o => { $0 };
$1[""] = o => {  };
$1.Submenu("", $1 => {
	$1[""] = o => {  };
	$1[""] = o => {  };
});
$1.Separator();
$1[""] = o => {  };
$1[""] = o => {  };

$1.Show();]]>
		</list>
		<list item="Simple menu, returns item id">
			<![CDATA[int ${1:id} = popupMenu.showSimple("${2:1 One|2 Two|3 Three||0 Cancel}");
switch ($1) {
case 1: $0 break;
case 2:  break;
case 3:  break;
default: return;
}]]>
		</list>
	</snippet>
	<snippet name="menuItemSnippet" info="Menu item." more="Other ways: drag-drop scripts, files, links; hotkey Ctrl+Shift+Q. More info in Cookbook." var="Au.popupMenu,m">
		<![CDATA[${VAR}["${1:Text}"] = o => { $0 };]]>
	</snippet>
	<snippet name="menuSubmenuSnippet" info="Menu submenu." var="Au.popupMenu,m">
		<![CDATA[${VAR}.Submenu("${1:Text}", ${VAR} => {
	${VAR}["${2:Text}"] = o => { $0 };
	${VAR}[""] = o => {  };
});]]>
	</snippet>
	<snippet name="tbToolbarButtonSnippet" info="Toolbar button." more="Other ways: drag-drop scripts, files, links; hotkey Ctrl+Shift+Q. More info in Cookbook." var="Au.toolbar,t">
		<![CDATA[${VAR}["${1:Text}"] = o => { $0 };]]>
	</snippet>
	<snippet name="tbToolbarMenuSnippet" info="Toolbar drop-down menu." var="Au.toolbar,t">
		<![CDATA[${VAR}.Menu("${1:Text}", ${VAR} => {
	${VAR}["${2:Text}"] = o => { $0 };
	${VAR}[""] = o => {  };
});]]>
	</snippet>
	<snippet name="wpfDialogSnippet" info="Create dialog window." more="See also: dialogSnippet, menu File &gt; New &gt; Dialogs." using="System.Windows;System.Windows.Controls;System.Windows.Controls.Primitives;System.Windows.Input;System.Windows.Media">
		<![CDATA[var b = new wpfBuilder("${1:Window}").WinSize(400);
b.R.Add("Text", out TextBox text1).Focus();
b.R.Add("Combo", out ComboBox combo1).Items("Zero|One|Two");
b.R.Add(out CheckBox c1, "Check");
b.R.AddButton("Button", _ => { print.it("Button clicked"); });
b.R.AddOkCancel();
b.End();
#if WPF_PREVIEW //menu Edit > View > WPF preview
b.Window.Preview();
#endif
if (!b.ShowDialog()) return;
//print.it(text1.Text, combo1.SelectedIndex, c1.IsChecked == true);]]>
	</snippet>
	<snippet name="wpfWndprocSnippet" info="Set WPF window hook to receives messages." using="System.Windows;System.Windows.Interop">
		<![CDATA[${1:window}.SourceInitialized += (o, _) => {
	var hs = PresentationSource.FromVisual(o as Window) as HwndSource;
	hs.AddHook(_WndProc);
	nint _WndProc(nint hwnd, int msg, nint wParam, nint lParam, ref bool handled) {
		var w = (wnd)hwnd;
		//WndUtil.PrintMsg(w, msg, wParam, lParam);
		
		switch (msg) {
		
		}
		
		return 0;
	}
};]]>
	</snippet>
	<snippet name="ssScriptSetupSnippet" info="Set run-time options such as tray icon and emergency exit ways.">
		<![CDATA[//.
script.setup(trayIcon: true, sleepExit: true);
//..
]]>
	</snippet>
	<snippet name="piPrintItSnippet" info="Display text and variables in the output window.">
		<![CDATA[print.it($0);]]>
	</snippet>
	<snippet name="outPrintItSnippet" info="Display text and variables in the output window.">
		<![CDATA[print.it($0);]]>
	</snippet>
	<snippet name="pcPrintClearSnippet" info="Clear the output window.">
		<![CDATA[print.clear();]]>
	</snippet>
	<snippet name="kkKeysSendSnippet" info="Generate virtual keystrokes (keys, text).">
		<![CDATA[keys.send("$0");]]>
	</snippet>
	<snippet name="ktKeysSendtSnippet" info="Send text to the active window using virtual keystrokes.">
		<![CDATA[keys.sendt($0);]]>
	</snippet>
	<snippet name="pasteSnippet" info="Paste text using the clipboard and Ctrl+V.">
		<![CDATA[clipboard.paste($0);]]>
	</snippet>
	<snippet name="copySnippet" info="Get the selected text using the clipboard and Ctrl+C." context="Function">
		<list item="&amp;Copy">
			<![CDATA[string ${1:s} = clipboard.copy();$0]]>
		</list>
		<list item="&amp;Try copy">
			<![CDATA[if (!clipboard.tryCopy(out var ${1:s}, 500)) return;$0]]>
		</list>
		<list item="C&amp;ut">
			<![CDATA[string ${1:s} = clipboard.copy(cut: true);$0]]>
		</list>
	</snippet>
	<snippet name="riRunItSnippet" info="Run a program or open a document, folder, web page." more="Tip: drag and drop.">
		<![CDATA[run.it(${1:folders.System + @"notepad.exe"});]]>
	</snippet>
	<snippet name="srScriptRunSnippet" info="Start to execute a script." more="Tip: drag and drop.">
		<![CDATA[script.run(@"${1:\Folder\Script}.cs");]]>
	</snippet>
	<snippet name="failedSnippet" info="Throw 'failed' exception." more="Exception text is optional.">
		<![CDATA[throw new ${2:AuException}($1);]]>
	</snippet>
	<snippet name="httpPostJsonSnippet" info="Sends an HTTP POST request with JSON data and parses the JSON response." using="System.Text.Json.Nodes">
		<![CDATA[var post = new { aString = "A", aNumber = 10, aBool = true, anArray = (object[])[new { x = "X0", y = "Y0" }, new { x = "X1", y = "Y1" }] }; //example input; will be sent as JSON; or you can use a raw JSON string instead
//print.it(System.Text.Json.JsonSerializer.Serialize(post)); //debug-print the JSON that will be sent
if (!internet.http.TryPost(out var r, "$0", internet.jsonContent(post), headers: ["Authorization: Bearer " + Environment.GetEnvironmentVariable("API_KEY")], printError: true)) return;
//var r = internet.http.Post("$0", internet.jsonContent(post), headers: ["Authorization: Bearer " + Environment.GetEnvironmentVariable("API_KEY")]);
//if (!r.IsSuccessStatusCode) { print.it(r.StatusCode, r.ReasonPhrase, r.Text(ignoreError: true)); return; } //on error the response likely contains an error message
//print.it(r.Text()); //debug-print the response JSON
JsonNode j = r.Json();
//var s1 = (string)j["a"]["b"]; print.it(s1);
//foreach (var v in j["c"].AsArray()) { print.it(v["d"]); }
]]>
	</snippet>

	<!--context="Type"-->

	<snippet name="propSnippet" info="Property.">
		<list item="{ get; set; }">
			<![CDATA[public ${1:string} ${2:Property} { get; set; }]]>
		</list>
		<list item="{ get; &amp;private set; }">
			<![CDATA[public ${1:string} ${2:Property} { get; private set; }]]>
		</list>
		<list item="{ g&amp;et {  } set {  } }">
			<![CDATA[public ${1:string} ${2:Property} {
	get {
		$0
	}
	set {
		
	}
}]]>
		</list>
	</snippet>

	<!--context="Namespace|Type"-->

	<snippet name="nativeApiSnippet" info="Adds class for Windows API declarations.">
		<![CDATA[/// <summary>
/// Add an empty class like this in scripts (at the end) and projects (in any file) where you want to use Windows API.
/// Then, whenever you need an API function etc, type the class name and dot (api.). The completion list contains API names and adds declarations to this class.
/// </summary>
#pragma warning disable 649, 169 //field never assigned/used
unsafe class ${1:api} : NativeApi {}
#pragma warning restore 649, 169 //field never assigned/used]]>
	</snippet>
	<snippet name="settingsSnippet" info="Adds a class for settings used by this script/program/library/etc.">
		<![CDATA[/// <summary>
/// Settings of this script/program/library/etc.
/// Function <see cref="MySettings.Load"/> loads settings from file or creates default; returns a new variable that lets you get or set settings, like <c>var v = sett.i; sett.i = 2;</c>.
/// Settings are lazily auto-saved soon after changing.
/// </summary>
internal record class MySettings : JSettings {
	public static readonly string File = folders.ThisAppDocuments + @"${1:RenameMe}.json";

	public static MySettings Load() => Load<MySettings>(File);
	
	//examples of settings. Most types are supported. Use public fields.
	public int i;
	public string s = "default";
	public string[] a = [];
}

//add this at class level:
//internal static readonly MySettings sett = MySettings.Load();

//or in script as local variable:
//using var sett = MySettings.Load();]]>
	</snippet>

	<!--context="Namespace"-->

	<!--rejected: programMainSurround.-->

	<!--context="Attributes"-->

	<snippet name="marshalAsSnippet" info="Adds MarshalAs attribute." more="Then press dot and select from list." context="Attributes">
		<![CDATA[MarshalAs(UnmanagedType$0)]]>
	</snippet>

	<!--context="Any|Line"-->

	<snippet name="#ifSnippet" info="Enables or disables code depending on a preprocessor expression.">
		<![CDATA[#if ${1:true}
${SELECTED_TEXT}$0
#else
#endif]]>
	</snippet>
	<snippet name="#regionSnippet" info="Fold (hide) code lines.">
		<![CDATA[#region ${1}
				
${SELECTED_TEXT}$0

#endregion]]>
	</snippet>

	<!--context="Any"-->
	
	<snippet name="//.Surround" info="Fold (hide) code lines." more="In LibreAutomate it is the same as #region. Can be //. or //. text.">
		<![CDATA[//.
${SELECTED_TEXT}$0
//..]]>
	</snippet>
</snippets>

================================================
FILE: Au.Editor/Default/Themes/Material dark.csv
================================================
Font, Consolas, 9.75
Background, 0x263238
None, 0xEEFFFF
Comment, 0x7E99A5
String, 0xC3E88D
StringEscape, 0xFFD68F
Number, 0xF78C6C
Punctuation, 0xEEFFFF
Operator, 0x89DDFF
Keyword, 0x89DDFF
Namespace, 0xFFCB6B
Type, 0xFFCB6B
Function, 0x82AAFF, 1
Event, 0x82AAFF, 1
LocalVariable, 0xEEFFFF
Field, 0xEEFFFF
Constant, 0xEEFFFF
Label, 0xFFCB6B
Preprocessor, 0x89DDFF
Excluded, 0x9B9B9B
XmlDocText, 0x7E99A5
XmlDocTag, 0x546E7A
RxText, 0xC3E88D
RxMeta, 0x05C3BA
RxChars, 0x2EABFE
RxOption, 0x05C3BA
RxEscape, 0xFFD68F
RxCallout, 0xF979AE
RxComment, 0x57A64A
LineNumber, 0x808080
LineNumberMargin, 0x1F445C
MarkerMargin, 0x263238
IndicRefs, 0x408000, 40
IndicBraces, 0x80C000, 255
IndicDebug, 0xC7CC75, 128
IndicFound, 0x67370B, 255
IndicSnippetField, 0xE0A000, 60
IndicSnippetFieldActive, 0x33ADFF, 60
SelColor, 0x466568, 160
SelNofocusColor, 0x466568, 96
Caret, 0xEEFFFF, 2
CaretLine, 0x404040, 1


================================================
FILE: Au.Editor/Default/Themes/One Monokai dark.csv
================================================
Font, Consolas, 9.75
Background, 0x282C34
None, 0xBBBBBB
Comment, 0x939AA6
String, 0xE5C07B
StringEscape, 0x56B6C2
Number, 0xC678DD
Punctuation, 0xBBBBBB
Operator, 0xE06C75
Keyword, 0xE06C75
Namespace, 0x61AFEF
Type, 0x61AFEF
Function, 0x98C379, 1
Event, 0x98C379, 1
LocalVariable, 0xBBBBBB
Field, 0xBBBBBB
Constant, 0xBBBBBB
Label, 0xBBBBBB
Preprocessor, 0xE06C75
Excluded, 0xABB2BF
XmlDocText, 0x939AA6
XmlDocTag, 0x676F7D
RxText, 0xE5C07B
RxMeta, 0x05C3BA
RxChars, 0x2EABFE
RxOption, 0x05C3BA
RxEscape, 0xFFD68F
RxCallout, 0xF979AE
RxComment, 0x57A64A
LineNumber, 0x808080
LineNumberMargin, 0x233858
MarkerMargin, 0x263238
IndicRefs, 0x408000, 40
IndicBraces, 0x80C000, 255
IndicDebug, 0xC7CC75, 128
IndicFound, 0x67370B, 255
IndicSnippetField, 0xE0A000, 60
IndicSnippetFieldActive, 0x33ADFF, 60
SelColor, 0x5A6376, 160
SelNofocusColor, 0x5A6376, 96
Caret, 0xF8F8F0, 2
CaretLine, 0x404040, 1


================================================
FILE: Au.Editor/Default/Themes/Visual Studio dark.csv
================================================
Font, Consolas, 9.75
Background, 0x1E1E1E
None, 0xDCDCDC
Comment, 0x57A64A
String, 0xD69D85
StringEscape, 0xFFD68F
Number, 0xB5CEA8
Punctuation, 0xDCDCDC
Operator, 0xB4B4B4
Keyword, 0x569CD6
Namespace, 0xDCDCDC
Type, 0x4EC9B0
Function, 0xDCDCAA, 1
Event, 0xDCDCAA, 1
LocalVariable, 0x9CDCFE
Field, 0x9CDCFE
Constant, 0xDCDCDC
Label, 0xDCDCDC
Preprocessor, 0x9B9B9B
Excluded, 0x9B9B9B
XmlDocText, 0x608B4E
XmlDocTag, 0x808080
RxText, 0xD69D85
RxMeta, 0x05C3BA
RxChars, 0x2EABFE
RxOption, 0x05C3BA
RxEscape, 0xFFD68F
RxCallout, 0xF979AE
RxComment, 0x57A64A
LineNumber, 0xA0A0A0
LineNumberMargin, 0x20384A
MarkerMargin, 0x1E1E1E
IndicRefs, 0x408000, 40
IndicBraces, 0x80C000, 255
IndicDebug, 0xC5C870, 128
IndicFound, 0x653306, 255
IndicSnippetField, 0xE0A000, 60
IndicSnippetFieldActive, 0x33ADFF, 60
SelColor, 0x2F70B0, 160
SelNofocusColor, 0x2F70B0, 96
Caret, 0xDCDCDC, 2
CaretLine, 0x404040, 1


================================================
FILE: Au.Editor/Edit/Ci-types.cs
================================================
using Au.Controls;

using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.Text;
using Microsoft.CodeAnalysis.Completion;

namespace LA;

class CiComplItem : ITreeViewItem {
	CompletionItem _ci;
	public readonly CiItemKind kind;
	public readonly CiItemAccess access;
	readonly CiComplProvider _provider;
	public CiComplItemHiddenBy hidden;
	public CiComplItemMoveDownBy moveDown;
	public ulong hilite; //bits for max 64 characters
	public int group;
	public int commentOffset;
	string _dtext;
	object _symbols; //ISymbol or List<ISymbol> or IReadonlyList<ISymbol> or null
	
	public CompletionItem GetCI([CallerMemberName] string m_ = null) {
		if (_ci == null) { //initially null if winapi provider
			SetCI(CompletionItem.Create(_dtext));
			Debug_.PrintIf(m_ != "SelectBestMatch", "CompletionItem auto-created for a winapi provider item");
		}
		return _ci;
	}
	
	public void SetCI(CompletionItem c) {
		_ci = c;
		_ci.Attach = this;
	}
	
	public CiComplItem(CiComplProvider provider, CompletionItem ci) {
		_provider = provider;
		_symbols = ci.Symbols;
		SetCI(ci);
		CiUtil.TagsToKindAndAccess(ci.Tags, out kind, out access);
		//ci.DebugPrint();
	}
	
	public CiComplItem(CiComplProvider provider, string name, CiItemKind kind, CiItemAccess access = default) {
		_provider = provider;
		this.kind = kind;
		this.access = access;
		if (provider == CiComplProvider.Winapi) {
			_dtext = name;
		} else {
			SetCI(CompletionItem.Create(name));
			//_ci.Span = span; //FUTURE: may need this for our new providers. Current providers (Winapi, Snippets) don't use this.
		}
	}
	
	public IEnumerable<ISymbol> Symbols {
		get {
			if (_symbols is ISymbol sym) _symbols = new ISymbol[1] { sym };
			return _symbols as IEnumerable<ISymbol>;
		}
	}
	
	public ISymbol FirstSymbol => _symbols switch { ISymbol sym => sym, IEnumerable<ISymbol> en => en.FirstOrDefault(), _ => null };
	
	/// <summary>
	/// Gets displayed text without prefix, suffix (eg generic) and green comments (group or inline description).
	/// In most cases it is simple name, but in some cases can be eg "Namespace.Name", "Name(parameters)", etc.
	/// </summary>
	public string Text => _ci?.DisplayText ?? _dtext;
	
	public string FilterText => _ci?.FilterText ?? _dtext;
	
	public string DisplayTextPrefix => _ci?.DisplayTextPrefix;
	
	public CiComplProvider Provider => _provider;
	
	#region ITreeViewItem
	string ITreeViewItem.DisplayText => _dtext;
	
	object ITreeViewItem.Image => ImageResource(kind);
	
	#endregion
	
	public void SetDisplayText(string comment) {
		if (_ci == null) return;
		var desc = _ci.InlineDescription; if (desc.NE()) desc = comment;
		bool isComment = !desc.NE();
		if (_dtext != null && !isComment && commentOffset == 0) return;
		_dtext = _ci.DisplayText + _ci.DisplayTextSuffix + (isComment ? "    //" : null) + desc;
		if (_ci.DisplayTextPrefix is var dt && dt.Length > 0) {
			_dtext = dt + _dtext;
			Debug_.PrintIf(dt != "(", $"{_dtext}, {dt}"); //seen only of casts, eg "(" + "int" + ")"
		}
		commentOffset = isComment ? _dtext.Length - desc.Length - 6 : 0;
	}
	
	public static string ImageResource(CiItemKind kind) => kind switch {
		CiItemKind.Class => "resources/ci/class.xaml",
		CiItemKind.Constant => "resources/ci/constant.xaml",
		CiItemKind.Delegate => "resources/ci/delegate.xaml",
		CiItemKind.Enum => "resources/ci/enum.xaml",
		CiItemKind.EnumMember => "resources/ci/enummember.xaml",
		CiItemKind.Event => "resources/ci/event.xaml",
		CiItemKind.ExtensionMethod => "resources/ci/extensionmethod.xaml",
		CiItemKind.Field => "resources/ci/field.xaml",
		CiItemKind.Interface => "resources/ci/interface.xaml",
		CiItemKind.Keyword => "resources/ci/keyword.xaml",
		CiItemKind.Label => "resources/ci/label.xaml",
		CiItemKind.LocalVariable => "resources/ci/localvariable.xaml",
		CiItemKind.Method => "resources/ci/method.xaml",
		CiItemKind.Namespace => "resources/ci/namespace.xaml",
		CiItemKind.Operator => "resources/ci/operator.xaml",
		CiItemKind.Property => "resources/ci/property.xaml",
		CiItemKind.Snippet => "resources/ci/snippet.xaml",
		CiItemKind.Structure => "resources/ci/structure.xaml",
		CiItemKind.TypeParameter => "resources/ci/typeparameter.xaml",
		CiItemKind.LocalMethod => "resources/ci/localmethod.xaml",
		CiItemKind.Region => "resources/ci/region.xaml",
		_ => null
	};
	
	public string AccessImageSource => AccessImageResource(access);
	
	public static string AccessImageResource(CiItemAccess access) => access switch {
		CiItemAccess.Private => "resources/ci/overlayprivate.xaml",
		CiItemAccess.Protected => "resources/ci/overlayprotected.xaml",
		CiItemAccess.Internal => "resources/ci/overlayinternal.xaml",
		_ => null
	};
	
	public string ModifierImageSource => _ModifierImageResource(this);
	
	static string _ModifierImageResource(CiComplItem ci) {
		var sym = ci.FirstSymbol;
		if (sym != null) {
			if (sym.IsStatic && ci.kind is not (CiItemKind.Constant or CiItemKind.EnumMember or CiItemKind.Namespace)) return "resources/ci/overlaystatic.xaml";
			if (ci.kind == CiItemKind.Class && sym.IsAbstract) return "resources/ci/overlayabstract.xaml";
		} else {
			//if (ci.Provider == CiComplProvider.Winapi && ci.kind == CiItemKind.Method) return "resources/ci/overlaystatic.xaml"; //no
		}
		return null;
	}
}

enum CiComplProvider : byte {
	Other,
	Symbol,
	Keyword,
	Cref,
	XmlDoc,
	EmbeddedLanguage, //Regex, DateTime format, maybe more
	Override,
	//ExternAlias,
	//ObjectAndWithInitializer,
	//AttributeNamedParameter,
	
	//ours
	Snippet,
	Winapi,
}

enum CiComplResult {
	/// <summary>
	/// No completion.
	/// </summary>
	None,
	
	/// <summary>
	/// Inserted text displayed in the popup list. Now caret is after it.
	/// </summary>
	Simple,
	
	/// <summary>
	/// Inserted more text than displayed in the popup list, eg "(" or "{  }" or override. Now caret probably is somewhere in middle of it. Also if regex.
	/// Only if ch == ' ', '\n' (Enter) or default (Tab).
	/// </summary>
	Complex,
}

[Flags]
enum CiComplItemHiddenBy : byte { FilterText = 1, Kind = 2, Always = 4 }

[Flags]
enum CiComplItemMoveDownBy : sbyte { Name = 1, Obsolete = 2, FilterText = 4 }

//The order must match CiUtil.ItemKindNames. In this order are displayed group buttons in the completion popup. See also code in CiWinapi.cs: " WHERE kind<=4".
enum CiItemKind : sbyte {
	//types
	Class, Structure, Interface, Enum, Delegate,
	//functions, events
	Method, ExtensionMethod, Property, Operator, Event,
	//data
	Field, LocalVariable, Constant, EnumMember,
	//other
	Namespace, Keyword, Label, Snippet, TypeParameter,
	//not in autocomplete. Not in CiUtil.ItemKindNames.
	LocalMethod, Region,
	None
}

//don't reorder!
enum CiItemAccess : sbyte { Public, Private, Protected, Internal }

class CiNamespaceSymbolEqualityComparer : IEqualityComparer<INamespaceSymbol> {
	public bool Equals(INamespaceSymbol x, INamespaceSymbol y) {
		for (; ; ) {
			if (x.MetadataName != y.MetadataName) return false;
			x = x.ContainingNamespace;
			y = y.ContainingNamespace;
			if (x == null) return y == null;
			if (y == null) return false;
		}
	}
	
	public int GetHashCode(INamespaceSymbol obj) {
		for (int r = obj.MetadataName.GetHashCode(); ;) {
			obj = obj.ContainingNamespace;
			if (obj == null) return r;
			r ^= obj.MetadataName.GetHashCode();
		}
	}
}

class CiNamespaceOrTypeSymbolEqualityComparer : IEqualityComparer<INamespaceOrTypeSymbol> {
	public bool Equals(INamespaceOrTypeSymbol x, INamespaceOrTypeSymbol y) {
		for (; ; ) {
			if (x.MetadataName != y.MetadataName) return false;
			if ((x is INamespaceSymbol) != (y is INamespaceSymbol)) return false;
			x = x.ContainingSymbol as INamespaceOrTypeSymbol;
			y = y.ContainingSymbol as INamespaceOrTypeSymbol;
			if (x == null) return y == null;
			if (y == null) return false;
		}
	}
	
	public int GetHashCode(INamespaceOrTypeSymbol obj) {
		for (int r = obj.MetadataName.GetHashCode(); ;) {
			obj = obj.ContainingSymbol as INamespaceOrTypeSymbol;
			if (obj == null) return r;
			r ^= obj.MetadataName.GetHashCode();
		}
	}
}

struct CiStringRange {
	public readonly string code;
	public readonly int start, end;
	public readonly bool verbatim;
	
	public CiStringRange(string code, int start, int end, bool verbatim) {
		this.code = code; this.start = start; this.end = end; this.verbatim = verbatim;
	}
	
	public override string ToString() {
		var s = code[start..end];
		if (!verbatim) s.Unescape(out s);
		return s;
	}
	
	public int Length => end - start;
}


================================================
FILE: Au.Editor/Edit/CiAutocorrect.cs
================================================
extern alias CAW;

using System.Windows.Input;
using Au.Controls;

using Microsoft.CodeAnalysis;
using CAW::Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Text;
using Microsoft.CodeAnalysis.Shared.Extensions;
using CAW::Microsoft.CodeAnalysis.Shared.Extensions;
using Microsoft.CodeAnalysis.CSharp.Extensions;
using Microsoft.CodeAnalysis.CSharp.Indentation;
using CAW::Microsoft.CodeAnalysis.Indentation;

namespace LA;

class CiAutocorrect {
	/// <summary>
	/// Call when added text with { } etc and want it behave like when the user types { etc.
	/// </summary>
	public void BracketsAdded(SciCode doc, int innerFrom, int innerTo, EBrackets operation) {
		var r = doc.ETempRanges_Add(this, innerFrom, innerTo);
		if (operation == EBrackets.NewExpression) r.OwnerData = "new";
		else r.OwnerData = "ac";
	}
	
	public enum EBrackets {
		/// <summary>
		/// The same as when the user types '(' etc and is auto-added ')' etc. The user can overtype the ')' with the same character or delete '()' with Backspace.
		/// </summary>
		Regular,
		
		/// <summary>
		/// Like Regular, but also the user can overtype entire empty '()' with '[' or '{'. Like always, is auto-added ']' or '}' and the final result is '[]' or '{}'.
		/// </summary>
		NewExpression,
	}
	
	/// <summary>
	/// Called on Enter, Ctrl/Shift+Enter, Ctrl+;, Tab, Backspace and Delete, before passing it to Scintilla. Won't pass if returns true.
	/// Enter: adds new line. If need, completes statement (if before `)` etc) and/or adds indent. Always returns true.
	/// Ctrl/Shift+Enter: The same as above, but anywhere. The hotkey depends on App.Settings.ci_enterWith; if not the hotkey, can just add new line + indent.
	/// Ctrl+;: Like SciBeforeCharAdded(';'), but anywhere; and inserts semicolon now.
	/// Tab: calls/returns SciBeforeCharAdded, which skips auto-added ')' etc.
	/// Backspace: If inside an empty temp range, selects the '()' etc to erase and returns false.
	/// Backspace: If in blank line before `}` line, deletes the blank line and adds new line after the block.
	/// Delete, Backspace: If after deleting newline would be tabs after caret, deletes newline with tabs and returns true.
	/// </summary>
	public bool SciBeforeKey(SciCode doc, KKey key, ModifierKeys mod) {
		if (key is KKey.Enter) {
			switch (mod) {
			case 0:
				_OnEnter(-1);
				return true;
			case ModifierKeys.Control:
				_OnEnter(0);
				return true;
			case ModifierKeys.Shift:
				_OnEnter(1);
				return true;
			case ModifierKeys.Control | ModifierKeys.Shift:
				_OnEnter(2);
				return true;
			}
		} else {
			switch ((key, mod)) {
			case (KKey.OemSemicolon, ModifierKeys.Control):
				_OnSemicolon(anywhere: true);
				return true;
			case (KKey.Back, 0):
				return _OnBackspaceOrDelete(doc, true) || SciBeforeCharAdded(doc, '\b');
			case (KKey.Delete, 0):
				return _OnBackspaceOrDelete(doc, false);
			case (KKey.Tab, 0):
				return SciBeforeCharAdded(doc, '\t');
			}
		}
		return false;
	}
	
	/// <summary>
	/// Called on WM_CHAR, before passing it to Scintilla. Won't pass if returns true. Not called if ch less than ' '.
	/// If ch is ')' etc, and at current position is ')' etc previously added on '(' etc, clears the temp range and returns true.
	/// If ch is ';' and current position is at '(...|)' and the statement etc must end with ';': adds ';' if missing, sets current position after ';', and returns true.
	/// If ch is '"' after two '"', may close raw string (add """") and return true.
	/// If ch is '.' after a statement that ends with `expression;`, replaces the ';' with `\r\n\t.;` for method chain.
	/// Also called by SciBeforeKey on Backspace and Tab. Then ch is '\b' or '\t'.
	/// If a new statement can start here, may add semicolon.
	/// If at the very end, adds "\r\n" at the end.
	/// </summary>
	public bool SciBeforeCharAdded(SciCode doc, char ch) {
		var (pos8, selEnd8) = doc.aaaSelection(false);
		bool hasSelection = selEnd8 > pos8, isBackspace = ch is '\b', isOpenBrac = false;
		
		if (isBackspace) {
			if (hasSelection) return false;
		} else {
			if (selEnd8 == doc.aaaLen8 && !CodeInfo._compl.IsVisibleUI) { //if at the end of text, add newline
				doc.aaaInsertText(false, selEnd8, "\r\n");
				if (hasSelection) doc.aaaSelect(false, pos8, selEnd8);
			}
			
			if (hasSelection) {
				_AutoSemicolon();
				return false;
			}
			
			if (_AutoSemicolon()) return false;
			
			if (ch == ';') return _OnSemicolon(anywhere: false);
			if (ch == '.') return _OnDot();
			
			switch (ch) {
			case '"' or '\'' or ')' or ']' or '}' or '>' or '\t': break; //skip auto-added char
			case '[' or '{' or '(' or '<': isOpenBrac = true; break; //replace auto-added '()' when completing 'new Type' with '[]' or '{}'
			default: return false;
			}
		}
		
		var r = doc.ETempRanges_Enum(pos8, this, endPosition: (ch == '"' || ch == '\''), utf8: true).FirstOrDefault();
		if (r == null) {
			if (ch == '"') return _RawString();
			return false;
		}
		if (isOpenBrac && (object)r.OwnerData is not ("ac" or "new")) return false;
		r.GetCurrentFromTo(out int from, out int to, utf8: true);
		
		if (isBackspace || isOpenBrac) {
			if (pos8 != from) return false;
		} else {
			if (ch != '\t' && ch != doc.aaaCharAt8(to)) { //info: '\0' if pos8 invalid
				if (ch == '"') return _RawString();
				return false;
			}
			if (ch == '\t' && doc.aaaCharAt8(pos8 - 1) is '\t' or '\n') return false; //don't exit temp range if pos8 is at the start of line
		}
		for (int i = pos8; i < to; i++) if (!(doc.aaaCharAt8(i) is ' ' or '\t' or '\r' or '\n')) return false; //eg space before '}'
		
		//rejected: ignore user-typed '(' or '<' after auto-added '()' or '<>' by autocompletion. Probably more annoying than useful, because then may want to type (cast) or ()=>lambda or (tup, le).
		//if(isOpenBrac && (ch == '(' || ch == '<') && ch == doc.aaaCharAt(pos8 - 1)) {
		//	r.OwnerData = null;
		//	return true;
		//}
		if (isOpenBrac && r.OwnerData != (object)"new") return false;
		
		if (ch is '"' or '\'') { //don't skip `"` if escaped, eg `"text\""`. Same for `'`.
			int i = pos8; while (doc.aaaCharAt8(i - 1) is '\\') i--;
			if (0 != ((pos8 - i) & 1)) {
				bool verbatim = ch is '"' && doc.aaaCharAt8(i - 2) is var c2 && (c2 is '@' || (c2 is '$' && doc.aaaCharAt8(i - 3) is '@'));
				if (!verbatim) return false;
			}
		}
		
		r.Remove();
		
		if (isBackspace || isOpenBrac) {
			doc.Call(Sci.SCI_SETSEL, pos8 - 1, to + 1); //select and pass to Scintilla, let it delete or overtype
			return false;
		}
		
		doc.aaaCurrentPos8 = to + 1;
		return true;
		
		bool _AutoSemicolon() {
			if (!App.Settings.ci_semicolon) return false;
			
			//is ch a statement-start character?
			if (!SyntaxFacts.IsIdentifierStartCharacter(ch)) {
				if (!(ch is (>= '0' and <= '9') or '@' or '$' or '*' or '(' or '"' or '\'' or '{')) return false;
			}
			
			//is caret at the end of line?
			for (int i = selEnd8; ; i++) {
				char c1 = doc.aaaCharAt8(i);
				if (c1 is '\r' or '\n' or '\0' or '}') break;
				if (!(c1 is ' ' or '\t')) return false;
			}
			//is caret at the start of line or after a statement-end or block-start character?
			for (int i = pos8; --i >= 0;) {
				char c1 = doc.aaaCharAt8(i);
				if (c1 is '\n' or ';' or '{' or '}' or ':' or ')' or '/' or 'e' or 'o') break;
				if (!(c1 is ' ' or '\t')) return false;
			}
			
			//can a statement start here?
			if (!CodeInfo.GetContextAndDocument(out var cd, doc.aaaPos16(pos8))) return false;
			var tok = cd.syntaxRoot.FindTokenOnLeftOfPosition(cd.pos);
			var node = tok.Parent;
			switch (tok.Kind()) {
			case 0: break;
			case SyntaxKind.OpenBraceToken:
				if (node is not BlockSyntax) return false;
				break;
			case SyntaxKind.CloseBraceToken:
				if (!(node is BlockSyntax { Parent: StatementSyntax or GlobalStatementSyntax or ElseClauseSyntax or CatchClauseSyntax or FinallyClauseSyntax or SwitchSectionSyntax } or SwitchStatementSyntax)) return false;
				break;
			case SyntaxKind.SemicolonToken:
				if (!(node is StatementSyntax or UsingDirectiveSyntax or ExternAliasDirectiveSyntax) || cd.pos < node.Span.End) return false;
				if (IsSwitchSectionEndStatement_(node)) return false; //after `break;` etc in `switch`, probably starting to type `case` or `default`
				if (node is EmptyStatementSyntax && cd.pos == node.Span.End) {
					if (hasSelection) cd.sci.aaaReplaceSel("");
					cd.sci.aaaGoToPos(true, node.SpanStart);
					return true;
				}
				break;
			case SyntaxKind.ColonToken:
				if (!(node is SwitchLabelSyntax or LabeledStatementSyntax)) return false;
				break;
			case SyntaxKind.CloseParenToken:
				if (!(node is IfStatementSyntax or ForStatementSyntax or CommonForEachStatementSyntax or WhileStatementSyntax or FixedStatementSyntax or LockStatementSyntax or UsingStatementSyntax)) return false;
				break;
			case SyntaxKind.ElseKeyword or SyntaxKind.DoKeyword:
				break;
			case SyntaxKind.CloseBracketToken:
				if (!(node is AttributeListSyntax { Target: { } alst } && alst.Identifier.Kind() is SyntaxKind.ModuleKeyword or SyntaxKind.AssemblyKeyword)) return false;
				break;
			default: return false;
			}
			if (ch is '{') return false; //`{` can just replace empty statement `;` (see `case SyntaxKind.SemicolonToken`)
			if (CiUtil.IsPosInNonblankTrivia(cd.syntaxRoot, cd.pos, cd.code)) return false;
			
			doc.aaaInsertText(false, selEnd8, ";");
			if (hasSelection) doc.aaaSelect(false, pos8, selEnd8);
			return true;
		}
		
		bool _RawString() { //close raw string now if need. In SciCharAdded too late, code is invalid and cannot detect correctly.
			if (pos8 > 3 && doc.aaaCharAt8(pos8 - 1) == '"' && doc.aaaCharAt8(pos8 - 2) == '"' && doc.aaaCharAt8(pos8 - 3) != '@') {
				if (!CodeInfo.GetContextAndDocument(out var cd)) return false;
				var pos16 = cd.pos;
				var token = cd.syntaxRoot.FindToken(pos16 - 1);
				var tkind = token.Kind();
				if (tkind is SyntaxKind.StringLiteralToken or SyntaxKind.InterpolatedStringEndToken) {
					//if pos is at ""|, make """|""" and append ; if missing
					var span = token.Span;
					if (pos16 == span.End && (tkind == SyntaxKind.StringLiteralToken ? span.Length == 2 : token.Parent.Span.Length == 3)) {
						//never mind: does not work if $$"". Then code is already invalid, and can't detect correctly. VS ignores it too.
						doc.aaaInsertText(false, pos8, "\"");
						doc.aaaAddUndoPoint();
						var nt = token.GetNextToken(includeZeroWidth: true);
						bool semicolon = nt.IsKind(SyntaxKind.SemicolonToken) && nt.IsMissing;
						doc.aaaInsertText(false, pos8 + 1, semicolon ? "\"\"\";" : "\"\"\"");
						doc.aaaCurrentPos8 = pos8 + 1;
						return true;
					}
				} else if (tkind is SyntaxKind.SingleLineRawStringLiteralToken or SyntaxKind.MultiLineRawStringLiteralToken or SyntaxKind.InterpolatedSingleLineRawStringStartToken or SyntaxKind.InterpolatedMultiLineRawStringStartToken) {
					//if pos it at """|""", make """"|""""
					int q1 = 0, q2 = 0;
					for (int i = pos8; doc.aaaCharAt8(--i) == '"';) q1++;
					for (int i = pos8; doc.aaaCharAt8(i++) == '"';) q2++;
					if (q1 == q2 && q1 >= 3) {
						if (tkind is SyntaxKind.SingleLineRawStringLiteralToken or SyntaxKind.MultiLineRawStringLiteralToken && token.SpanStart != pos8 - q1) return false;
						doc.aaaInsertText(false, pos8, "\"");
						doc.aaaAddUndoPoint();
						doc.aaaInsertText(false, pos8 + 1, "\"");
						doc.aaaCurrentPos8 = pos8 + 1;
						return true;
					}
				}
			}
			return false;
		}
	}
	
	//CONSIDER: insert missing `break;` in `switch` when completed a statement.
	
	/// <summary>
	/// Called on SCN_CHARADDED.
	/// If ch is '(' etc, adds ')' etc. For /* adds */.
	/// At the start of line corrects indent of '}' (or formats the block) or '{'. Removes that of '#'.
	/// Replaces code like 5s with 5.s(); etc.
	/// If ch is '/' in XML comments, may add the end tag.
	/// If ch is ';' or ':', may auto-format the completed statement or `case`.
	/// If ch is '{' or ':', may remove semicolon.
	/// </summary>
	public void SciCharAdded(CodeInfo.CharContext c) {
		char ch = c.ch;
		
		if (ch is ';' or ':') {
			if (ch is ':') _ReplaceSemicolonAfterColon();
			_AutoFormat(ch);
			return;
			//never mind: formats even if ';' added in a wrong place, eg `Func(...|...)`. In VS too.
		}
		
		string replaceText = ch switch {
			'"' => "\"",
			'\'' => "'",
			'(' => ")",
			'[' => "]",
			'{' => "}",
			'<' => ">",
			'*' => "*/",
			's' or 't' or '}' or '#' or '/' => "",
			_ => null
		};
		if (replaceText == null) return;
		
		if (!CodeInfo.GetContextAndDocument(out var cd)) return;
		string code = cd.code;
		int pos = cd.pos - 1; if (pos < 0) return;
		
		Debug.Assert(code[pos] == ch);
		if (code[pos] != ch) return;
		
		var root = cd.syntaxRoot;
		//if(!root.ContainsDiagnostics) return; //no. Don't use errors. It can do more bad than good. Tested.
		
		if (ch is 's' or 't') {
			if (!SyntaxFacts.IsIdentifierPartCharacter(code.At_(cd.pos))) {
				if (ch == 's') { //when typed like `5s` or `500ms`, replace with `5.s();` or `500.ms();`
					if (pos > 0 && code[pos - 1] == 'm') { pos--; replaceText = ".ms();"; } else replaceText = ".s();";
					if (_IsNumericLiteralStatement(out _)) {
						//never mind: should ignore if not int s/ms or double s. Error if eg long or double ms.
						_ReplaceST(pos, false);
					}
				}
				if (ch == 't') { //when typed like `5t`, replace with snippet `for (int i = 0; i < 5; i++) {  }`
					if (_IsNumericLiteralStatement(out int spanStart)) {
						replaceText = $$"""for (int ${1:i} = 0; $1 < {{code[spanStart..pos]}}; $1++) { $0 }""";
						_ReplaceST(spanStart, true);
					}
				}
			}
			return;
			
			bool _IsNumericLiteralStatement(out int spanStart) {
				if (pos > 0 && code[pos - 1].IsAsciiDigit()) {
					var node = root.FindToken(pos - 1).Parent;
					if (node.IsKind(SyntaxKind.NumericLiteralExpression) && node.Parent is ExpressionStatementSyntax) {
						var span = node.Span;
						spanStart = span.Start;
						return span.Contains(pos - 1);
					}
				}
				spanStart = 0;
				return false;
			}
		}
		
		int replaceLength = 0, tempRangeFrom = 0, tempRangeTo = 0, newPos = 0, replaceSemicolonAt = 0;
		
		if (ch == '#') { //#directive
			if (CiUtil.IsLineStart(code, pos, out int i) && i < pos) {
				if (root.FindTrivia(pos).IsDirective) {
					c.doc.aaaDeleteRange(true, i, pos);
				}
			}
			return;
		} else if (ch == '*') { /**/
			var trivia = root.FindTrivia(pos);
			if (!trivia.IsKind(SyntaxKind.MultiLineCommentTrivia)) return;
			if (trivia.SpanStart != --pos) return;
		} else if (ch == '/') { //</tag>
			if (!(root.FindToken(pos, findInsideTrivia: true).Parent is XmlElementEndTagSyntax et && et.Name?.IsMissing != false && et.Parent is XmlElementSyntax e1)) return;
			replaceText = e1.StartTag.Name.ToString() + '>';
		} else {
			var token = root.FindToken(pos);
			var node = token.Parent;
			
			if (ch == '}') { //decrease indent
				if (!token.IsKind(SyntaxKind.CloseBraceToken) || pos != token.SpanStart) return;
				if (App.Settings.ci_formatAuto) {
					if (node.Parent is var p && p is (StatementSyntax and not BlockSyntax) or (MemberDeclarationSyntax and not GlobalStatementSyntax) or AccessorDeclarationSyntax) node = p;
					if (node is StatementSyntax or MemberDeclarationSyntax or AccessorDeclarationSyntax) _AutoFormat(node, cd);
				} else if (CiUtil.IsLineStart(code, pos, out int i) && i > 1) {
					if (node is not (BlockSyntax or SwitchStatementSyntax or MemberDeclarationSyntax or AccessorListSyntax or InitializerExpressionSyntax or AnonymousObjectCreationExpressionSyntax or SwitchExpressionSyntax or PropertyPatternClauseSyntax)) return;
					var sInd = _GetIndent();
					if (!code.Eq(i..pos, sInd)) {
						c.doc.aaaReplaceRange(true, i, pos, sInd);
						c.ignoreChar = true;
					}
				}
				return;
			}
			
			string _GetIndent() => new CiIndent(cd, token.SpanStart, false, useDefaultOptions: true).ToString();
			//info: without useDefaultOptions would be `if (true)\r\n\t{  }` if not compact formatting. We need `if (true)\r\n{  }`.
			
			if (node is InterpolatedStringTextSyntax) node = node.Parent;
			var kind = node.Kind();
			
			var span = node.Span;
			if (span.Start > pos) return; // > if pos is in node's leading trivia, eg comments or #if-disabled block
			
			tempRangeFrom = tempRangeTo = cd.pos;
			if (ch == '\'') {
				if (kind != SyntaxKind.CharacterLiteralExpression || span.Start != pos) return;
			} else if (ch == '"') {
				bool isVerbatim, isInterpolated = false;
				switch (kind) {
				case SyntaxKind.StringLiteralExpression:
					isVerbatim = code[span.Start] == '@';
					break;
				case SyntaxKind.InterpolatedStringExpression:
					isInterpolated = true;
					isVerbatim = code[span.Start] == '@' || code[span.Start + 1] == '@';
					break;
				default: return;
				}
				if (span.Start != pos - (isVerbatim ? 1 : 0) - (isInterpolated ? 1 : 0)) return;
			} else {
				switch (kind) {
				case SyntaxKind.CompilationUnit or SyntaxKind.CharacterLiteralExpression or SyntaxKind.StringLiteralExpression or SyntaxKind.Utf8StringLiteralExpression:
					return;
				case SyntaxKind.InterpolatedStringExpression:
					//after next typed { in interpolated string remove } added after first {
					if (ch == '{' && code.Eq(pos - 1, "{{}") && c.doc.ETempRanges_Enum(cd.pos, this, endPosition: true).Any()) {
						replaceLength = 1;
						replaceText = null;
						tempRangeFrom = 0;
						break;
					}
					return;
				default:
					if (kind != SyntaxKind.Interpolation) {
						var g = code.At_(cd.pos);
						if (g > ' ' && !(g is '/' && code.At_(cd.pos + 1) is '/' or '*')) {
							if (!(g is ';' or ',' or '.' or ':' or '?' or '{' or '}' or '(' or ')' or '[' or ']' or '#')) return;
							if ((ch, g) is ('(', '(')) return;
						}
						
						if (CiUtil.IsPosInNonblankTrivia(node, pos, code)) return;
					}
					
					if (ch == '{') {
						if (kind == SyntaxKind.Interpolation) { //add } or }} etc if need
							int n = 0;
							for (int i = pos; code[i] == '{'; i--) n++;
							if (n > 1) tempRangeFrom = 0; //raw string like $$"""...{{
							for (int i = cd.pos; code.Eq(i, '}'); i++) n--;
							if (n <= 0) return;
							if (n > 1) replaceText = new('}', n);
						} else {
							replaceText = "  }";
							if (pos > 0 && !char.IsWhiteSpace(code[pos - 1])) {
								replaceText = " {  }";
								tempRangeFrom++;
								cd.pos--; replaceLength = 1; //replace the '{' too
							} else if (CiUtil.IsLineStart(code, pos, out int i) && i >= 4
								&& token.IsKind(SyntaxKind.OpenBraceToken) && pos == token.SpanStart) {
								//if { at the start of line (and maybe after an indent), correct indent
								var sInd = _GetIndent();
								if (!code.Eq(i..pos, sInd)) {
									replaceText = sInd + "{  }";
									tempRangeFrom = i + sInd.Length + 1;
									cd.pos = i; replaceLength = pos - i + 1;
								}
							}
							
							newPos = tempRangeFrom + 1;
							
							replaceSemicolonAt = _ReplaceSemicolonAfterBrace(token);
						}
					} else if (ch == '<') {
						if (!_IsGenericLessThan()) return; //can be operators
						
						bool _IsGenericLessThan() {
							if (kind is SyntaxKind.TypeParameterList or SyntaxKind.TypeArgumentList) return true;
							if (kind != SyntaxKind.LessThanExpression) return false;
							var tok2 = token.GetPreviousToken(); if (!tok2.IsKind(SyntaxKind.IdentifierToken)) return false;
							var semo = cd.semanticModel;
							var sa = semo.GetSymbolInfo(tok2).GetAllSymbols();
							if (!sa.IsEmpty) {
								foreach (var v in sa) {
									if (v is INamedTypeSymbol { IsGenericType: true } or IMethodSymbol { IsGenericMethod: true }) return true;
									//never mind: if eg IList and IList<T> are available, GetSymbolInfo gets only IList. Then no '>' completion. The same in VS.
									//	OK if only IList<T> available. Methods OK.
								}
							}
							return false;
						}
					}
					break;
				}
			}
		}
		
		
		if (newPos > 0) { // `{ | }`
			using var undo = cd.sci.ENewUndoAction();
			if (replaceSemicolonAt > 0) cd.sci.aaaReplaceRange(true, replaceSemicolonAt, replaceSemicolonAt + 1, "");
			c.doc.aaaReplaceRange(true, cd.pos, cd.pos + replaceLength, replaceText);
			c.doc.aaaCurrentPos16 = newPos;
			_AutoFormat(ch);
			//add temprange AFTER autoformatting. Else it may disappear.
			newPos = c.doc.aaaCurrentPos16;
			tempRangeFrom = newPos - 1;
			tempRangeTo = newPos + 1;
		} else {
			c.doc.aaaReplaceRange(true, cd.pos, cd.pos + replaceLength, replaceText, moveCurrentPos: ch is ';' or '/');
		}
		
		if (tempRangeFrom > 0) c.doc.ETempRanges_Add(this, tempRangeFrom, tempRangeTo);
		else c.ignoreChar = true;
		
		static void _ReplaceSemicolonAfterColon() {
			if (App.Settings.ci_semicolon && CodeInfo.GetContextAndDocument(out var cd)) {
				var tok = cd.syntaxRoot.FindTokenOnRightOfPosition(cd.pos);
				if (tok.Parent is EmptyStatementSyntax && tok.GetPreviousToken().Parent is LabeledStatementSyntax or CaseSwitchLabelSyntax) {
					var (from, to) = tok.Span;
					cd.sci.aaaReplaceRange(true, from, to, "");
				}
			}
		}
		
		static int _ReplaceSemicolonAfterBrace(SyntaxToken braceToken) {
			if (App.Settings.ci_semicolon && braceToken.GetNextToken(includeSkipped: true) is { RawKind: (int)SyntaxKind.SemicolonToken } tok) {
				var node = braceToken.Parent;
				if (node is BlockSyntax { Parent: StatementSyntax or ElseClauseSyntax or CatchClauseSyntax or FinallyClauseSyntax } or SwitchStatementSyntax or MemberDeclarationSyntax) {
					return tok.SpanStart;
				}
			}
			return 0;
		}
		
		void _ReplaceST(int from, bool snippet) {
			int to = cd.pos;
			if (App.Settings.ci_semicolon && CiUtil.SkipSpace(code, to) is int semicolonAt && code.Eq(semicolonAt, ';')) to = semicolonAt + 1;
			if (snippet) {
				c.doc.aaaReplaceRange(true, from, to, "");
				CiSnippets.Surround(replaceText, from..from);
			} else {
				c.doc.aaaReplaceRange(true, from, to, replaceText, moveCurrentPos: true);
			}
			c.ignoreChar = true;
		}
	}
	
	//Called by SciBeforeCharAdded on '.'.
	//Implements a quick way to continue a vertical method chain: type `.` on the next line after the `;`, and it will replace the `;\r\n` with `\r\n\t.;` and show the completion list.
	static bool _OnDot() {
		if (!CodeInfo.GetContextWithoutDocument(out var cd)) return false;
		int i = CiUtil.SkipSpaceAndNewlineBack(cd.code, cd.pos);
		if (!cd.code.Eq(--i, ';')) return false;
		if (!cd.GetDocument()) return false;
		var token = cd.syntaxRoot.FindToken(i);
		if (!token.IsKind(SyntaxKind.SemicolonToken) || token.SpanStart != i) return false;
		var node = token.GetPreviousToken().Parent;
		if (node?.FirstAncestorOrSelf<ExpressionSyntax>() is not { } es) return false;
		
		using var undo = cd.sci.ENewUndoAction();
		if (cd.code.AsSpan(i..cd.pos).Contains('\n')) {
			CiIndent ind = new(cd, i, forNewLine: true);
			var s = "\r\n" + ind.ToString() + ";";
			cd.sci.aaaReplaceRange(true, i, cd.pos, s);
			i += s.Length - 1;
		}
		cd.sci.aaaCurrentPos16 = i;
		cd.sci.Call(Api.WM_CHAR, (nint)'.');
		return true;
	}
	
	//anywhere true when Ctrl+;.
	static bool _OnSemicolon(bool anywhere) {
		if (!CodeInfo.GetDocumentAndFindToken(out var cd, out var token)) return false;
		var node = token.Parent;
		
		if (!anywhere) {
			var tk1 = token.Kind();
			
			if (tk1 == SyntaxKind.SemicolonToken) return _ReplaceSemicolon();
			
			if (!(tk1 is SyntaxKind.CloseParenToken or SyntaxKind.CloseBracketToken)) return false;
			if (!(node is BaseArgumentListSyntax or BaseParameterListSyntax or ArrayRankSpecifierSyntax
				or ParenthesizedExpressionSyntax or TupleExpressionSyntax or CollectionExpressionSyntax
				or TypeOfExpressionSyntax or SizeOfExpressionSyntax or DefaultExpressionSyntax or CheckedExpressionSyntax
				or DoStatementSyntax)
				) return false;
			if (cd.pos != token.SpanStart) return false;
		}
		
		node = node.GetStatementEtc(cd.pos);
		if (node == null) return false;
		
		var lastToken = node.GetLastToken(includeZeroWidth: true);
		if (!_GetLastTokenForSemicolonStatementCompletion(ref lastToken, out bool isComplete)) return false;
		if (isComplete) {
			cd.sci.aaaGoToPos(true, lastToken.SpanStart + 1);
		} else {
			_InsertNodeCompletionTextWithAutoformat(cd, node, ";", lastToken.Span.End);
		}
		
		return true;
		
		//CONSIDER: make similar feature for '{'. On '{': `if (...|)` -> `if (...) { | }`. `Func(...|)` -> `Func(...) { | }`.
		//	Rarely used. Much work to detect all possible cases where `(...{ })` is valid. Eg lambda/anonymous func, `is`, `switch`, `with`, `new`, `new X`, `new X()`, `new X[]`.
		
		bool _ReplaceSemicolon() {
			if (App.Settings.ci_semicolon && token.SpanStart == cd.pos && node.Span.End == cd.pos + 1) {
				cd.sci.aaaCurrentPos16 = cd.pos + 1;
				if (App.Settings.ci_formatAuto) _AutoFormat(node, cd);
				return true;
			}
			return false;
		}
	}
	
	/// <param name="lastToken">
	/// In: last token of the statement etc node, found like `nodeStat.GetLastToken(includeZeroWidth: true)`.
	/// Out: if <i>isComplete</i> false - the existing token before missing `;`. Else the existing `;` token (unchanged).</param>
	/// <param name="isComplete">`;` exists.</param>
	/// <returns>false if can't determine where `;` should be.</returns>
	static bool _GetLastTokenForSemicolonStatementCompletion(ref SyntaxToken lastToken, out bool isComplete) {
		isComplete = false;
		var node = lastToken.Parent;
		var tk2 = lastToken.Kind();
		bool isSemicolon = tk2 is SyntaxKind.SemicolonToken;
		if (isSemicolon || (tk2 is SyntaxKind.CloseBraceToken && node is TypeDeclarationSyntax tds && tds.ParameterList != null)) {
			//CiUtil.PrintNode(node, printErrors: true);
			var diag = isSemicolon && node.ContainsDiagnostics ? node.GetDiagnostics() : null;
			if (isSemicolon && diag?.Any(o => o.Code is 1513 or 1026) == true) return false; //"} expected" or ") expected". Eg in `timer.after(1, _=>{print.it(1));` after `(1)`.
			if (node.ContainsSkippedText) {
				//code examples (TLS):
				//	var k = (6, 9) void L() {}
				//	var k = (6, 9) void L() {int i;}
				//	int i=5 print.it(1);
				//	var s="aaa bbb" char c = 'a';
				//	var a = s.Lines() for (int i = 0; i < count; i++) { }
				if (isSemicolon && node is LocalDeclarationStatementSyntax && diag?.FirstOrDefault(static o => o.Code is 1003) is { } d) { //", expected"
					lastToken = node.FindTokenOnLeftOfPosition(d.Location.SourceSpan.Start);
				} else {
					Debug_.Print("ContainsSkippedText");
					return false;
				}
			} else if (lastToken.IsMissing) {
				lastToken = lastToken.GetPreviousToken();
			} else {
				isComplete = true;
			}
			return true;
		}
		return false;
	}
	
	static void _OnEnter(int mod) {
		var doc = Panels.Editor.ActiveDoc;
		using var undo = doc.ENewUndoAction();
		if (mod < 0 && doc.aaaHasSelection) doc.Call(Sci.SCI_DELETEBACK);
		if (!_OnEnter2(mod)) doc.Call(Sci.SCI_NEWLINE);
	}
	
	//mod: Ctrl 0, Shift 1, Ctrl+Shift 2, none -1, don't correct -2.
	static bool _OnEnter2(int mod) {
		if (!CodeInfo.GetContextAndDocument(out var cd)) return false;
		var doc = cd.sci;
		var code = cd.code;
		int pos = cd.pos;
		if (pos < 1) return false;
		
		bool anywhere = mod == App.Settings.ci_enterWith, canCorrect = anywhere, canCorrectOnEnterBeforeParenEtc = false, isEOF = false;
		
		var tok1 = cd.syntaxRoot.FindToken(pos);
		if (tok1.IsKind(SyntaxKind.EndOfFileToken)) {
			if (!anywhere) if (1 == _InNonblankTriviaOrStringOrChar(cd, tok1)) return true;
			tok1 = tok1.GetPreviousToken();
			if (tok1.RawKind == 0) return false;
			isEOF = true;
		}
		var tk1 = tok1.Kind();
		SyntaxNode nodeFromPos = tok1.Parent;
		
		if (!anywhere && mod != -2) {
			if (tk1 is SyntaxKind.CloseParenToken or SyntaxKind.CloseBracketToken && tok1.SpanStart == pos) {
				if (!App.Settings.ci_tempRawEnter && App.Settings.ci_enterBeforeParen && !(mod >= 0 || code[pos - 1] is ' ' or ',')) {
					canCorrect = canCorrectOnEnterBeforeParenEtc = nodeFromPos
						is BaseArgumentListSyntax or BaseParameterListSyntax or ArrayRankSpecifierSyntax
						or ParenthesizedExpressionSyntax or TupleExpressionSyntax or CollectionExpressionSyntax
						or CatchDeclarationSyntax or CatchFilterClauseSyntax
						or TypeOfExpressionSyntax or SizeOfExpressionSyntax or DefaultExpressionSyntax or CheckedExpressionSyntax
						or (StatementSyntax and not BlockSyntax) || _IsSwitchCast(nodeFromPos);
				}
			} else if (tk1 is SyntaxKind.SemicolonToken && tok1.SpanStart == pos) {
				if (!App.Settings.ci_tempRawEnter && App.Settings.ci_enterBeforeSemicolon && !(mod >= 0 || code[pos - 1] is ' ' or ',')) {
					canCorrect = canCorrectOnEnterBeforeParenEtc = !(nodeFromPos is ForStatementSyntax or EmptyStatementSyntax);
				}
			} else if (!isEOF) {
				int r = _InNonblankTriviaOrStringOrChar(cd, tok1);
				if (r == 1) return true; //yes and corrected
				if (r == 2) return false; //yes and not corrected
				if (r == 3) canCorrect = true; //string or char. Let's complete statement.
			}
		}
		
		SyntaxNode node = null;
		foreach (var v in nodeFromPos.AncestorsAndSelf()) {
			if (v is BlockSyntax) {
				if (v.Parent is BlockSyntax or GlobalStatementSyntax || v.Span.ContainsInside(pos)) break;
				continue;
			} else if (v is StatementSyntax) {
			} else if (v is MemberDeclarationSyntax) {
				if (v is GlobalStatementSyntax) break;
			} else if (v is AttributeListSyntax) {
				if (v.Parent is ParameterSyntax) continue;
			} else if (v is ExpressionSyntax) {
				if (!(v.Parent is InitializerExpressionSyntax)) continue;
			} else if (v is AccessorDeclarationSyntax or ElseClauseSyntax or FinallyClauseSyntax or CatchClauseSyntax or UsingDirectiveSyntax or ExternAliasDirectiveSyntax or CollectionElementSyntax) {
			} else continue;
			
			if (v is EnumMemberDeclarationSyntax or ExpressionSyntax or CollectionElementSyntax && pos >= v.Span.End) continue; //if `{ ... member| }`, move caret after `}`
			
			node = v;
			break;
		}
		if (node == null || !node.Span.Contains(pos)) canCorrect = false;
		
		bool hasSemicolon = false;
		if (canCorrect) {
			bool needBraces = false, needSemicolon = false, needComma = false;
			SyntaxToken afterToken = default;
			
			switch (node) {
			//StatementSyntax
			case CommonForEachStatementSyntax k: _WithBlock(k.Statement, k.CloseParenToken); break;
			case FixedStatementSyntax k: _WithBlock(k.Statement, k.CloseParenToken); break;
			case ForStatementSyntax k: _WithBlock(k.Statement, k.CloseParenToken); break;
			case IfStatementSyntax k: _WithBlock(k.Statement, k.CloseParenToken); break;
			case LockStatementSyntax k: _WithBlock(k.Statement, k.CloseParenToken); break;
			case UsingStatementSyntax k: _WithBlock(k.Statement, k.CloseParenToken); break;
			case WhileStatementSyntax k: _WithBlock(k.Statement, k.CloseParenToken); break;
			case TryStatementSyntax k: _WithBlock(k.Block, k.TryKeyword); break;
			case LocalFunctionStatementSyntax k: _Function(k.Body, k.ExpressionBody, k.ParameterList.CloseParenToken, k.SemicolonToken); break;
			case SwitchStatementSyntax k:
				var obt = k.OpenBraceToken;
				if (needBraces = obt.IsMissing) {
					var cpt = k.CloseParenToken;
					if (cpt.IsMissing) { //if 'switch(word) no {}', sometimes Roslyn thinks '(word)...' is a cast expression. See _IsSwitchCast.
						if (k.SwitchKeyword.GetNextToken().Parent is not CastExpressionSyntax ce) return false;
						cpt = ce.CloseParenToken;
					}
					afterToken = cpt;
				} else {
					if (pos <= obt.SpanStart) afterToken = obt;
				}
				break;
			//MemberDeclarationSyntax
			case NamespaceDeclarationSyntax k: _WithBraces(k.OpenBraceToken); break;
			case BaseTypeDeclarationSyntax k: _WithBraces(k.OpenBraceToken); break;
			case BaseMethodDeclarationSyntax k: _Function(k.Body, k.ExpressionBody, k.ParameterList.CloseParenToken, k.SemicolonToken); break;
			case PropertyDeclarationSyntax k: _Property(k.AccessorList, k.ExpressionBody, k.Identifier, k.SemicolonToken); break;
			case IndexerDeclarationSyntax k: _Property(k.AccessorList, k.ExpressionBody, k.ParameterList.CloseBracketToken, k.SemicolonToken); break;
			case EventDeclarationSyntax k: _Property(k.AccessorList, null, k.Identifier, default); break;
			case EnumMemberDeclarationSyntax k: _WithComma(k.EqualsValue); break;
			//other
			case AccessorDeclarationSyntax k: _Function(k.Body, k.ExpressionBody, k.Keyword, k.SemicolonToken); break;
			case ElseClauseSyntax k: _WithBlock(k.Statement, k.ElseKeyword); break;
			case FinallyClauseSyntax k: _WithBlock(k.Block, k.FinallyKeyword); break;
			case CatchClauseSyntax k: _WithBlock(k.Block, k.Filter?.CloseParenToken ?? k.Declaration?.CloseParenToken ?? k.CatchKeyword); break;
			case ExpressionSyntax k: _WithComma(k); break;
			case CollectionElementSyntax k: _WithComma(k); break;
			case AttributeListSyntax: break;
			default: _WithSemicolon(node.GetLastToken(includeZeroWidth: true)); break;
			}
			//print.it($"{{}}={needBraces}  ;={needSemicolon},  ,={needComma}");
			
			//for nodes that can have a child block statement. Eg `if`, 'catch`.
			void _WithBlock(StatementSyntax statement, in SyntaxToken tokenBeforeBlock) {
				if (tokenBeforeBlock.IsMissing) return;
				if (statement is BlockSyntax bs && !bs.OpenBraceToken.IsMissing) afterToken = bs.OpenBraceToken;
				else { needBraces = true; afterToken = tokenBeforeBlock; }
			}
			
			//for nodes that have `{  }` but it isn't a block statement. Eg type declarations.
			void _WithBraces(in SyntaxToken openBraceToken) {
				if (needBraces = openBraceToken.IsMissing) afterToken = openBraceToken;
				else if (pos <= openBraceToken.SpanStart) afterToken = openBraceToken;
			}
			
			//for member and local functions
			void _Function(BlockSyntax block, ArrowExpressionClauseSyntax arrow, in SyntaxToken tokenBeforeBlock, in SyntaxToken semicolonToken) {
				if (tokenBeforeBlock.IsMissing) return;
				if (block != null) afterToken = block.OpenBraceToken;
				else if (needBraces = arrow is null) afterToken = tokenBeforeBlock;
				else needSemicolon = semicolonToken.IsMissing;
			}
			
			//for properties, indexers and events
			void _Property(AccessorListSyntax block, ArrowExpressionClauseSyntax arrow, in SyntaxToken tokenBeforeBlock, in SyntaxToken semicolonToken) {
				if (tokenBeforeBlock.IsMissing) return;
				if (block != null) afterToken = block.OpenBraceToken;
				else if (needBraces = arrow is null) afterToken = tokenBeforeBlock;
				else needSemicolon = semicolonToken.IsMissing;
			}
			
			//for statements that should end with semicolon
			void _WithSemicolon(in SyntaxToken semicolonToken) {
				if (!semicolonToken.IsKind(SyntaxKind.SemicolonToken)) { Debug_.Print(semicolonToken.Kind()); return; }
				afterToken = semicolonToken;
				if (_GetLastTokenForSemicolonStatementCompletion(ref afterToken, out hasSemicolon)) needSemicolon = !hasSemicolon;
			}
			
			//for enum members and object/collection initializer expression elements
			void _WithComma(SyntaxNode lastNode) {
				var lastToken = lastNode.GetLastToken();
				var nextToken = lastToken.GetNextToken();
				var tk = nextToken.Kind();
				if (tk is SyntaxKind.CommaToken && nextToken.GetNextToken().IsKind(SyntaxKind.CloseBraceToken)) afterToken = nextToken;
				else { needComma = true; afterToken = lastToken; }
			}
			
			canCorrect = needBraces || needSemicolon || needComma;
			if (afterToken.RawKind == 0) afterToken = node.GetLastToken();
			pos = CiUtil.SkipNewlineBack(code, canCorrect ? afterToken.Span.End : afterToken.FullSpan.End);
			
			if (canCorrect) {
				CiIndent ind = new(cd, node.SpanStart, forNewLine: false);
				string s, sInd = ind.ToString();
				int replaceSemicolonAt = 0;
				if (needBraces) {
					string sInd2 = node is SwitchStatementSyntax && App.Settings.ci_formatCompact ? sInd : (ind + 1).ToString();
					s = App.Settings.ci_formatCompact
						? " {" + "\r\n" + sInd2 + "\r\n" + sInd + "}"
						: "\r\n" + sInd + "{" + "\r\n" + sInd2 + "\r\n" + sInd + "}";
					
					if (App.Settings.ci_semicolon && afterToken.GetNextToken(includeSkipped: true) is { RawKind: (int)SyntaxKind.SemicolonToken } tok)
						if (node is StatementSyntax or ElseClauseSyntax or CatchClauseSyntax or FinallyClauseSyntax or SwitchStatementSyntax or MemberDeclarationSyntax)
							replaceSemicolonAt = code.Length - tok.SpanStart;
				} else {
					s = (needSemicolon ? ";" : ",") + "\r\n" + sInd;
				}
				
				_InsertNodeCompletionTextWithAutoformat(cd, node, s, pos, needBraces ? 3 + sInd.Length : 0);
				
				if (replaceSemicolonAt > 0) {
					replaceSemicolonAt = cd.sci.aaaLen16 - replaceSemicolonAt;
					cd.sci.aaaReplaceRange(true, replaceSemicolonAt, replaceSemicolonAt + 1, "");
				}
				
				if (canCorrectOnEnterBeforeParenEtc) _OnUndoAddSimpleNewline();
				return true;
			} else {
				doc.aaaCurrentPos16 = pos;
			}
		}
		
		//auto-indent
		if (hasSemicolon && App.Settings.ci_formatAuto && App.Settings.ci_semicolon) { //probably auto-added semicolon
			CiIndent ind = new(cd, pos, forNewLine: true);
			_InsertNodeCompletionTextWithAutoformat(cd, node, "\r\n" + ind, pos);
		} else {
			var (from, to) = CiUtil.SkipSpaceAround(code, pos); //remove spaces and tabs around the line break
			if (from == 0) return false;
			bool atStartOfLine = code[from - 1] == '\n';
			bool atStartOfNonblankLine = atStartOfLine && !(to == code.Length || code[to] is '\r' or '\n');
			
			CiIndent ind = new(cd, from, forNewLine: !atStartOfNonblankLine);
			CiIndent indBefore = atStartOfNonblankLine ? new(cd, from - (code.Eq(from - 2, '\r') ? 2 : 1), forNewLine: true) : default;
			bool noInd = ind == 0 && indBefore == 0;
			string sInd = ind.ToString(), sBefore = indBefore.ToString(), sAfter = "";
			
			// `{ | }` -> `{\r\n\t|\r\n}`
			if (!atStartOfNonblankLine && code.Eq(to, '}') && cd.syntaxRoot.FindToken(to) is { RawKind: (int)SyntaxKind.CloseBraceToken } cbt && cbt.SpanStart == to) {
				node = cbt.Parent;
				
				bool same = App.Settings.ci_formatCompact && node is SwitchStatementSyntax;
				
				if (noInd && !same) return false;
				
				string sInd2 = (same ? ind : ind - 1).ToString();
				
				if (!cbt.GetPreviousToken().IsKind(SyntaxKind.OpenBraceToken)) { //if `{ tokens | }`, don't add empty line, usually it is unwanted
					sInd = sInd2;
				} else {
					sAfter = "\r\n" + sInd2;
					
					if (!App.Settings.ci_formatCompact // `owner {` -> `owner\r\n{`
						&& code[from - 1] == '{'
						&& !(node is BlockSyntax && node.Parent is BlockSyntax or GlobalStatementSyntax)
						&& node is not InterpolationSyntax
						&& !CiUtil.IsLineStart(code, from - 1, out int i1)
						) {
						from = i1;
						sBefore = "\r\n" + (ind - 1).ToString() + "{";
					}
				}
			} else {
				if (noInd) return false;
				if (atStartOfLine && !atStartOfNonblankLine) sBefore = sInd;
			}
			var s = sBefore + "\r\n" + sInd + sAfter;
			
			doc.aaaReplaceRange(true, from, to, s);
			doc.aaaGoToPos(true, from + s.Length - sAfter.Length);
		}
		
		if (canCorrectOnEnterBeforeParenEtc) _OnUndoAddSimpleNewline();
		return true;
		
		void _OnUndoAddSimpleNewline() {
			int pos = cd.pos;
			cd.sci.AaTextChanged += _doc_AaTextChanged;
			void _doc_AaTextChanged(KScintilla.AaEventHandlerArgs e) {
				e.c.AaTextChanged -= _doc_AaTextChanged;
				if (e.n.modificationType.Has(Sci.MOD.SC_PERFORMED_UNDO)) {
					App.Dispatcher.InvokeAsync(() => {
						if (Panels.Editor.ActiveDoc != cd.sci) return;
						cd.sci.aaaCurrentPos16 = pos;
						_OnEnter(-2);
					});
				}
			}
		}
	}
	
	/// <returns>0 no, 1 yes and corrected, 2 yes and not corrected, 3 string or char.</returns>
	static int _InNonblankTriviaOrStringOrChar(CodeInfo.Context cd, SyntaxToken token) {
		string code = cd.code, suffix = null;
		bool insertEmptyLine = false;
		int pos = cd.pos, posStart = pos, posEnd = pos;
		var span = token.Span;
		if (pos < span.Start || pos > span.End) { //trivia
			var trivia = token.FindTrivia(pos);
			span = trivia.Span;
			var kind = trivia.Kind();
			if (pos == span.Start && kind != SyntaxKind.MultiLineDocumentationCommentTrivia) return 0; //info: /** span starts after /**
			switch (kind) {
			case SyntaxKind.MultiLineCommentTrivia when span.Length == 4 && pos == span.Start + 2:
				insertEmptyLine = true;
				break;
			case SyntaxKind.MultiLineCommentTrivia or SyntaxKind.MultiLineDocumentationCommentTrivia:
				return 2;
			case SyntaxKind.SingleLineCommentTrivia:
				suffix = "//";
				break;
			case SyntaxKind.SingleLineDocumentationCommentTrivia:
				suffix = "/// ";
				if (CiUtil.IsLineStart(code, pos, out int sol)) pos = posStart = posEnd = CiUtil.SkipNewlineBack(code, sol);
				break;
			default: return 0;
			}
			if (suffix != null) { //trim spaces
				while (posStart > span.Start && CiUtil.IsSpace(code[posStart - 1])) posStart--;
				while (posEnd < span.End && CiUtil.IsSpace(code[posEnd])) posEnd++;
				if (kind is SyntaxKind.SingleLineDocumentationCommentTrivia && code.Eq(posStart - 3, "/// ") && CiUtil.IsLineStart(code, posStart - 3)) posStart++; //let empty lines be `/// `, not '///`
			}
		} else {
			if (span.ContainsInside(pos) && token.IsKind(SyntaxKind.CharacterLiteralToken)) return 3;
			bool? isString = token.IsInString(pos, code, out var si, orU8: true);
			if (isString == false) return 0;
			if (si.isRawPrefixCenter) {
				cd.sci.aaaInsertText(true, pos, "\r\n\r\n"); //let Enter in raw string prefix like """|""" add extra newline
				cd.sci.aaaCurrentPos16 = pos + 2;
				return 1;
			}
			if (isString == null && !si.isRawMultilineBetweenStartQuotesAndText) return 2;
			if (si.isRawMultiline || si.isRawMultilineBetweenStartQuotesAndText) {
				(posStart, posEnd) = CiUtil.SkipSpaceAround(code, pos);
				var sInd = new CiIndent(cd, posStart, forNewLine: true, rawString: true).ToString();
				if (sInd.Length == 0) return 2;
				string sIndBefore = !si.isRawMultilineBetweenStartQuotesAndText && code[posStart - 1] == '\n' ? sInd : null; //is start of line?
				cd.sci.aaaReplaceRange(true, posStart, posEnd, sIndBefore + "\r\n" + sInd, moveCurrentPos: true);
				return 1;
			}
			if (si.isRaw && !si.stringNode.ContainsDiagnostics) {
				var textSpan = si.stringNode is InterpolatedStringExpressionSyntax ises ? ises.Contents.Span : si.textSpan;
				if (pos != textSpan.Start) return 3;
				//"""|text""" -> """|\r\ntext\r\n"""
				cd.sci.aaaInsertText(true, pos + textSpan.Length, "\r\n");
				cd.sci.aaaInsertText(true, pos, "\r\n");
				return 1;
			}
			if (!si.isClassic) return 2;
			return 3;
			//rejected: split string into "abc" + "" or "abc\r\n" + "". Rarely used. Better complete statement.
		}
		
		var doc = cd.sci;
		int indent = doc.aaaLineIndentFromPos(true, posStart);
		if (indent < 1 /*&& prefix == null*/ && suffix == null && !insertEmptyLine) return 2;
		
		var b = new StringBuilder();
		if (insertEmptyLine) {
			b.AppendLine().AppendLine().AppendIndent(indent);
			
			doc.aaaInsertText(true, pos, b.ToString());
			doc.aaaCurrentPos16 = pos + 2;
		} else {
			b.AppendLine();
			if (suffix != null) b.AppendIndent(indent).Append(suffix);
			
			doc.aaaReplaceRange(true, posStart, posEnd, b.ToString(), moveCurrentPos: true);
		}
		
		return 1;
	}
	
	static bool _OnBackspaceOrDelete(SciCode doc, bool back) {
		//when joining 2 non-empty lines with Delete or Backspace, remove indent from the second line
		if (doc.aaaHasSelection) return false;
		int i = doc.aaaCurrentPos16;
		var code = doc.aaaText;
		RXGroup g;
		if (back) {
			if (_BlockCompletion()) return true;
			int i0 = i;
			if (code.Eq(i - 1, '\n')) i--;
			if (code.Eq(i - 1, '\r')) i--;
			if (i == i0) return false;
		} else {
			//if at the start of a line containing just tabs/spaces, let Delete delete entire line
			if (code.RxMatch(@"(?m)^\h+\R", 0, out g, RXFlags.ANCHORED, i..)) goto g1;
		}
		if (!code.RxMatch(@"(?m)(?<!^)\R\h+", 0, out g, RXFlags.ANCHORED, i..)) return false;
		g1: doc.aaaDeleteRange(true, g.Start, g.End);
		return true;
		
		//On Backspace in the last blank line before `}` in multiline `{ block }` deleted that line and adds new line after the block.
		//Supports most `{ }` kinds and `[collection]`.
		bool _BlockCompletion() {
			var (from, to) = CiUtil.SkipSpaceAround(code, i);
			int nextLineAt = CiUtil.SkipNewline(code, to);
			if ((nextLineAt > to && code.At_(from - 1) == '\n')) {
				int braceAt = nextLineAt; while (CiUtil.IsSpace(code, braceAt)) braceAt++;
				if (code.At_(braceAt) is '}' or ']') {
					if (CodeInfo.GetDocumentAndFindToken(out var cd, out var tok, to) && tok.Kind() is var tk && tk is SyntaxKind.CloseBraceToken or SyntaxKind.CloseBracketToken) {
						var node = tok.Parent;
						string s = null, sInd = null;
						bool needSemicolon = false, format = false;
						int moveCaret = -2;
						
						if (node is ExpressionSyntax || (node is BlockSyntax && node.Parent is ExpressionSyntax)) {
							//note: API returns incorrect indent before `]` if no comma before
							if (tok.GetNextToken(includeZeroWidth: true) is { RawKind: (int)SyntaxKind.SemicolonToken } tSemicolon) {
								sInd = new CiIndent(cd, tSemicolon.Parent.GetStatementEtc(cd.pos).Span.End, true).ToString();
								if (needSemicolon = tSemicolon.IsMissing) to = tok.FullSpan.End; else to = tSemicolon.FullSpan.End;
								format = true;
							} else {
								cd.sci.aaaCurrentPos16 = braceAt + 1;
								cd.sci.aaaDeleteRange(true, from, nextLineAt);
								return true;
							}
						} else if (node is StatementSyntax or BaseTypeDeclarationSyntax or NamespaceDeclarationSyntax or AccessorListSyntax) {
							var ind = new CiIndent(cd, braceAt, false);
							if (ind.Spaces + 4 < cd.sci.aaaLineIndentFromPos(true, from, out int spaces) * 4 + spaces) return false; //maybe the coder just wants to delete extra indent
							sInd = ind.ToString();
							if (node is BlockSyntax && node.Parent is var p && !(p is BlockSyntax or GlobalStatementSyntax)) {
								if (p is DoStatementSyntax dss && dss.WhileKeyword.IsMissing) (to, s) = (braceAt + 1, " while();");
								else if (p is CatchClauseSyntax) to = p.Parent.FullSpan.End;
								else to = p.FullSpan.End;
							} else {
								to = tok.FullSpan.End;
							}
						} else return false;
						
						if (s == null) {
							if (code[to - 1] == '\n') s = sInd + "\r\n"; else { s = "\r\n" + sInd + "\r\n" + sInd; moveCaret -= sInd.Length; }
						}
						
						using var undo = cd.sci.ENewUndoAction();
						cd.sci.aaaInsertText(true, to, s);
						cd.sci.aaaCurrentPos16 = to + s.Length + moveCaret;
						if (needSemicolon) cd.sci.aaaInsertText(true, braceAt + 1, ";");
						cd.sci.aaaDeleteRange(true, from, nextLineAt);
						if (format) _AutoFormat(default);
						
						return true;
					}
				}
			}
			return false;
		}
	}
	
	static void _AutoFormat(char ch) {
		//This func is called when text changed in these cases:
		//	1. On ';' or ':' (from SciCharAdded). Then *pos* is after the char. Then *ch* is ';' or ':'.
		//	2. On '{' when SciCharAdded added `{  }`. Then *pos* is after `{ `. Then *ch* is '{'.
		//	3. On Backspace, if completed a `{ block };`. Then *pos* is in new line after ';'. Then *ch* is '\0'.
		
		if (!App.Settings.ci_formatAuto && ch != ':') return;
		
		if (!CodeInfo.GetContextAndDocument(out var cd)) return;
		int pos = cd.pos;
		
		var tok = cd.syntaxRoot.FindTokenOnLeftOfPosition(pos);
		if (tok.Parent is not { } n) return;
		
		if (ch is ';' or ':') if (pos != n.Span.End) return; //skip if in trivia, string, for(;;) etc
		
		int maxTo = -1;
		var tk = tok.Kind();
		if (ch == ':') {
			if (n is not SwitchLabelSyntax sls) return;
			if (!App.Settings.ci_formatAuto) maxTo = sls.Keyword.Span.End; //just correct indent
		} else if (tk is SyntaxKind.SemicolonToken) {
			if (n is StatementSyntax && n.Parent is var p && p is StatementSyntax and not BlockSyntax) n = p; //eg format `if(...) statement;`, not just `statement;`
		} else if (tk is SyntaxKind.OpenBraceToken) {
			//blocks: BlockSyntax, SwitchStatementSyntax, BaseTypeDeclarationSyntax, NamespaceDeclarationSyntax, AccessorListSyntax
			//expressions etc: InitializerExpressionSyntax, AnonymousObjectCreationExpressionSyntax, SwitchExpressionSyntax, PropertyPatternClauseSyntax
			
			bool skipBlock = ch == '{'; //don't format `{  }`, because would make `{ }`
			if (n is BlockSyntax bs) { //eg `if(...) {  }` or `if(...) {\r\n\t\r\n}` or `if(...) {\r\n\t\r\n statements }`. Format `if(...) ` or `if(...) {\r\n\t\r\n}`.
				if (n.Parent is BlockSyntax or GlobalStatementSyntax) return;
				if (skipBlock || bs.Statements.Any()) maxTo = n.SpanStart; //don't format `{  }` and `{\r\n\t\r\n statements }`
				n = n.Parent;
			} else { //`class C {  }`, `switch(...) {  }`, `new C {  }`, etc
				if (n is ExpressionSyntax or PropertyPatternClauseSyntax) return;
				if (skipBlock || !tok.GetNextToken().IsKind(SyntaxKind.CloseBraceToken)) maxTo = tok.SpanStart; //don't format `{  }` and `{\r\n\t\r\n tokens }`
				if (n is AccessorListSyntax) n = n.Parent;
			}
		}
		
		_AutoFormat(n, cd, maxTo);
	}
	
	static void _AutoFormat(SyntaxNode n, CodeInfo.Context cd, int maxTo = -1) {
		var (from, to) = n.GetRealFullSpan(spanEnd: true);
		if (maxTo > from) to = maxTo;
		//CiUtil.DebugHiliteRange(from, to); wait.doEvents(); 500.ms(); CiUtil.DebugHiliteRange(0, 0);
		ModifyCode.Format(cd, from, to);
	}
	
	//Used when pasting, dropping or inserting statement(s).
	//If inserting text before or after `;` and it is an empty statement, deletes the `;` if it is redundant.
	internal class Pasting {
		SciCode _doc;
		int _insertedCount, _deleteSemicolonAt = -1;
		
		public Pasting(SciCode doc) {
			if (App.Settings.ci_semicolon) {
				_doc = doc;
				_doc.AaTextChanged += _doc_AaTextChanged;
			}
		}
		
		unsafe void _doc_AaTextChanged(KScintilla.AaEventHandlerArgs e) {
			if (e.n.modificationType.Has(Sci.MOD.SC_MOD_INSERTTEXT) && ++_insertedCount == 1) {
				int start8 = e.n.position, end8 = start8 + e.n.length;
				var doc = e.c;
				bool semicolonBefore = doc.aaaCharAt8(start8 - 1) is ';', semicolonAfter = !semicolonBefore && doc.aaaCharAt8(end8) is ';';
				if (semicolonAfter) semicolonAfter = new RByte(e.n.textUTF8, e.n.length) is [.., (byte)';'] or [.., (byte)';', (byte)'\r', (byte)'\n'] or [.., (byte)';', (byte)'\n'];
				if (semicolonBefore || semicolonAfter) _deleteSemicolonAt = semicolonBefore ? start8 - 1 : end8;
			}
		}
		
		public void After() {
			if (_doc != null) {
				_doc.AaTextChanged -= _doc_AaTextChanged;
				if (_insertedCount == 1 && _deleteSemicolonAt >= 0) {
					int pos8 = _deleteSemicolonAt;
					if (_doc.aaaCharAt8(pos8) != ';') {
						Debug_.Print("not ;");
					} else {
						int pos = _doc.aaaPos16(pos8);
						if (CodeInfo.GetDocumentAndFindNode(out var cd, out var node, pos) && node is EmptyStatementSyntax && node.SpanStart == cd.pos) {
							_doc.aaaReplaceRange(false, pos8, pos8 + 1, "");
							//rejected: if inserted after `;`, and semicolon missing at the end of text, insert semicolon there. Unreliable etc.
							//bad: the user also may want to auto-delete or move the auto-added `;` when it isn't an empty statement. Eg when text dropped/pasted after `int i = ;`. But impossible to know.
						}
					}
				}
			}
		}
	}
	
	#region util
	
	/// <summary>
	/// Inserts text after node, autoformats node if need, and sets final cursor position.
	/// Used for statement completion on Enter or ';'.
	/// Uses single text modification operation (insert or replace).
	/// </summary>
	/// <param name="cd"></param>
	/// <param name="node">Node to format. Does not format if null.</param>
	/// <param name="sInsert">Text to insert. Eg ";" or " {  }". Does not format it.</param>
	/// <param name="pos">The end of the span of the last normal token of the node. Formats until it.</param>
	/// <param name="finalPosMinus">Move the final caret position from the end of inserted text back by this count chars.</param>
	/// <returns>The end of the inserted text in new text.</returns>
	static int _InsertNodeCompletionTextWithAutoformat(CodeInfo.Context cd, SyntaxNode node, string sInsert, int pos, int finalPosMinus = 0) {
		if (App.Settings.ci_formatAuto && node != null) {
			int from = node.GetRealFullSpan(spanEnd: true).Start, to = pos, pos0 = pos;
			if (ModifyCode.Format(cd, ref from, ref to, ref pos, ref pos) is { } a) {
				using var undo = cd.sci.ENewUndoAction();
				cd.sci.aaaInsertText(true, pos0, sInsert);
				for (int i = a.Count; --i >= 0;) {
					var c = a[i];
					if (c.Span.Start == pos0 && c.Span.IsEmpty) { pos -= c.NewText.Length; continue; } //don't insert space at the end, eg `if (true)  {  }`
					cd.sci.aaaReplaceRange(true, c.Span.Start, c.Span.End, c.NewText);
				}
				goto g1;
			}
		}
		cd.sci.aaaInsertText(true, pos, sInsert);
		g1:
		int r = pos + sInsert.Length;
		cd.sci.aaaGoToPos(true, r - finalPosMinus);
		return r;
	}
	
	/// <summary>
	/// If <c>switch(word)</c> without <c>{}</c> is followed by another statement, Roslyn thinks <c>(word)</c> is a cast expression.
	/// This function returns true if <i>node</i> is <b>CastExpressionSyntax</b> followed by <c>switch</c>.
	/// </summary>
	/// <param name="node">Parent node of <c>)</c> token.</param>
	/// <returns></returns>
	static bool _IsSwitchCast(SyntaxNode node)
		=> node is CastExpressionSyntax ce && ce.OpenParenToken.GetPreviousToken() is { RawKind: (int)SyntaxKind.SwitchKeyword, Parent: SwitchStatementSyntax };
	
	internal static bool IsSwitchSectionEndStatement_(SyntaxNode n)
		=> n.Parent is SwitchSectionSyntax && n is BreakStatementSyntax or ContinueStatementSyntax or GotoStatementSyntax or ReturnStatementSyntax or YieldStatementSyntax or ThrowStatementSyntax;
	
	#endregion
}

/// <summary>
/// Gets indent for a code line.
/// </summary>
struct CiIndent {
	int _spaces;
	
	/// <summary>
	/// Determines indent for line containing <i>pos</i>; if <i>forNewLine</i> - for new line that would be inserted at <i>pos</i>.
	/// Can be used to determine the indent of new line on <c>Enter</c>. Not for formatting of existing code.
	/// Ignores current indent of the line, but may use that of previous line.
	/// Does not have the formatter problems (bad comment alignment etc).
	/// </summary>
	public CiIndent(CodeInfo.Context cd, int pos, bool forNewLine, bool rawString = false, bool useDefaultOptions = false) {
		var d = cd.document;
		var root = cd.syntaxRoot;
		string code = cd.code;
		SourceText stext;
		
		if (forNewLine) {
			code = code.Insert(pos, "\r\n\r\n");
			stext = SourceText.From(code);
			//try faster way. Faster ~2 times if big file. And the speed is stable; the simple way is randomly much slower.
			bool fast = false;
			if (!rawString) {
				if (root.FindTrivia(pos) is { RawKind: not 0 } tri) { //the most common case. Eg when pos is at the end of a line or in `{  }`.
					if (fast = tri.SpanStart == pos) {
						root = root.InsertTriviaBefore(tri, new SyntaxTriviaList(SyntaxFactory.CarriageReturnLineFeed, SyntaxFactory.CarriageReturnLineFeed));
						//stext = root.GetText(); code = stext.ToString(); //much slower
					}
				} else if (root.FindToken(pos) is { RawKind: not 0 } tok) {
					if (fast = tok.SpanStart == pos && !tok.HasLeadingTrivia) {
						root = root.ReplaceToken(tok, tok.WithLeadingTrivia(SyntaxFactory.CarriageReturnLineFeed, SyntaxFactory.CarriageReturnLineFeed));
					}
				}
			}
			if (!fast) root = root.SyntaxTree.WithChangedText(stext).GetCompilationUnitRoot();
			pos += 2;
		} else {
			stext = root.SyntaxTree.GetText();
		}
		
		var parsedDocument = new ParsedDocument(d.Id, stext, root, d.Project.GetExtendedLanguageServices());
		var indenter = parsedDocument.LanguageServices.GetRequiredService<IIndentationService>();
		int line = parsedDocument.Text.Lines.GetLineFromPosition(pos).LineNumber;
		var indOpt = useDefaultOptions ? IndentationOptionsProviders.GetDefault(parsedDocument.LanguageServices) : new IndentationOptions(ModifyCode.FormattingOptions);
		IndentationResult ind = indenter.GetIndentation(parsedDocument, line, indOpt, default);
		
		//IndentationResult -> _ind
		
		int to = ind.BasePosition, i = to;
		while (i > 0 && code[i - 1] is '\t' or ' ') i--;
		int k = 0;
		for (; i < to; i++) {
			if (code[i] == ' ') k++;
			else k = k / 4 * 4 + 4;
		}
		
		_spaces = k + ind.Offset;
		
		if (forNewLine && !rawString) {
			//bad indent after `break;` etc in `switch{}`
			if (_spaces >= 4 && root.FindTokenOnLeftOfPosition(pos) is { RawKind: (int)SyntaxKind.SemicolonToken } ts && CiAutocorrect.IsSwitchSectionEndStatement_(ts.Parent)) {
				_spaces -= 4;
			}
		}
	}
	
	public static CiIndent operator ++(CiIndent i) { i._spaces += 4; return i; }
	
	public static CiIndent operator --(CiIndent i) { i._spaces = Math.Max(0, i._spaces - 4); return i; }
	
	public static CiIndent operator +(CiIndent i, int plus) => new() { _spaces = i._spaces + plus * 4 };
	
	public static CiIndent operator -(CiIndent i, int minus) => new() { _spaces = Math.Max(0, i._spaces - minus * 4) };
	
	public override string ToString() {
		if (_spaces == 0) return "";
		if (!App.Settings.ci_formatTabIndent) return new(' ', _spaces);
		var (tabs, spaces) = Math.DivRem(_spaces, 4);
		return spaces == 0 ? new('\t', tabs)
			: tabs == 0 ? new(' ', spaces)
			: new string('\t', tabs) + new string(' ', spaces);
	}
	
	public int Spaces => _spaces;
	
	public static implicit operator int(CiIndent i) => (i._spaces + 3) / 4;
}


================================================
FILE: Au.Editor/Edit/CiCompletion.cs
================================================
extern alias CAW;

using System.Collections.Immutable;
using Au.Controls;

using Microsoft.CodeAnalysis;
using CAW::Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Text;
using Microsoft.CodeAnalysis.CSharp.Extensions;
using Microsoft.CodeAnalysis.Shared.Extensions;
using CAW::Microsoft.CodeAnalysis.Shared.Extensions;
using Microsoft.CodeAnalysis.Completion;
using Microsoft.CodeAnalysis.CSharp.Extensions.ContextQuery;

//PROBLEM: Roslyn bug: no popup list if first parameter of indexer setter is enum. Same in VS.
//	Even on Ctrl+Space does not select the enum in list. And does not add enum members like "Enum.Member".

//CONSIDER: completion in keys string. But probably really useful only for keys like MediaNextTrack.

//CONSIDER: if string starts with <>, on < show list of output tags. User suggestion. And useful for me. Maybe even show a list of standard colors and the color control.
//	Also need a tool for wildcard expression.
//	Now users can in "string" press F1 or Ctrl+Space to open the help page.

namespace LA;

partial class CiCompletion {
	CiPopupList _popupList;
	_Data _data; //not null while the popup list window is visible
	CancellationTokenSource _cancelTS;
	
	class _Data {
		public CompletionService completionService;
		public Document document;
		public SemanticModel model;
		public List<CiComplItem> items;
		public int codeLength;
		public string filterText;
		public SciCode.ITempRange tempRange;
		public bool forced, noAutoSelect, isDot, unimported;
		public CiWinapi winapi;
	}
	
	public bool IsVisibleUI => _data != null;
	
	public void Cancel() {
		_cancelTS?.Cancel();
		_cancelTS = null;
		_CancelUI();
	}
	
	void _CancelUI(bool popupListHidden = false, bool tempRangeRemoved = false) {
		//print.it("_CancelUI", _data != null);
		if (_data == null) return;
		if (!tempRangeRemoved) _data.tempRange.Remove();
		_data = null;
		if (!popupListHidden) _popupList.Hide();
	}
	
	/// <summary>
	/// Called before <see cref="CiAutocorrect.SciCharAdded"/> and before passing the character to Scintilla.
	/// If showing popup list, synchronously commits the selected item if need (inserts text).
	/// Else inserts text at caret position and now caret is after the text.
	/// </summary>
	public CiComplResult SciCharAdding_Commit(SciCode doc, char ch) {
		CiComplResult R = CiComplResult.None;
		if (_data != null) {
			if (!SyntaxFacts.IsIdentifierPartCharacter(ch)) {
				var ci = _popupList.SelectedItem;
				if (ci != null && _data.filterText.Length == 0 && ch != '.') ci = null;
				if (ci != null) R = _Commit(doc, ci, ch, default);
				_CancelUI();
				//return;
			}
		}
		return R;
	}
	
	/// <summary>
	/// Asynchronously shows popup list if need.
	/// </summary>
	public void SciCharAdded_ShowList(CodeInfo.CharContext c) {
		if (_data == null) {
			_ShowList(c.ch);
		}
	}
	
	/// <summary>
	/// If showing popup list, synchronously filters/selects items.
	/// </summary>
	public void SciModified(SciCode doc, in Sci.SCNotification n) {
		if (_data != null) {
			bool trValid = _data.tempRange.GetCurrentFromTo(out int from, out int to, utf8: true);
			Debug.Assert(trValid); if (!trValid) { Cancel(); return; }
			string s = doc.aaaRangeText(false, from, to);
			
			//cancel if typed nonalpha if auto-showed by typing nonalpha (eg space in parameters or '(' after method name)
			if (!_data.forced && _data.filterText.NE() && s.Length == 1 && !SyntaxFacts.IsIdentifierStartCharacter(s[0]) && !(SyntaxFacts.IsIdentifierPartCharacter(s[0]) && _data.isDot)) {
				Cancel();
				return;
			}
			
			foreach (var v in s) if (!SyntaxFacts.IsIdentifierPartCharacter(v)) return; //mostly because now is before SciCharAddedCommit, which commits (or cancels) if added invalid char
			_data.filterText = s;
			_FilterItems(_data);
			_popupList.UpdateVisibleItems(); //and calls SelectBestMatch
		}
	}
	
	public void ShowList(char ch = default) {
		_ShowList(ch);
	}
	
	//static bool s_workaround1;
	
	async void _ShowList(char ch) {
		//using
		//var p1 = perf.local();
		
		//print.it(_cancelTS);
		//bool busy = _cancelTS != null;
		bool isCommand = ch == default;
		
		if (!CodeInfo.GetContextWithoutDocument(out var cd)) { //returns false if position is in meta comments
			Cancel();
			return;
		}
		SciCode doc = cd.sci;
		int position = cd.pos;
		string code = cd.code;
		
		if (ch != default && position > 1 && SyntaxFacts.IsIdentifierPartCharacter(ch) && SyntaxFacts.IsIdentifierPartCharacter(code[position - 2])) { //in word
			return;
			//never mind: does not hide Regex completions. Same in VS.
		}
		
		bool unimported = isCommand && IsVisibleUI;
		
		Cancel();
		
		//CodeInfo.HideTextPopupAndTempWindows(); //no
		CodeInfo.HideTextPopup();
		
		//using var nogcr = keys.isScrollLock ? new Debug_.NoGcRegion(50_000_000) : default;
		
		if (!cd.GetDocument()) return; //returns false if fails (unlikely)
		var document = cd.document;
		//p1.Next('d');
		
		if (ch == '/') {
			GenerateCode.DocComment(cd);
			return;
		}
		
		bool isDot = false, canGroup = false;
		PSFormat stringFormat = PSFormat.None;
		CiStringInfo stringInfo = default;
		CompletionService completionService = null;
		SemanticModel model = null;
		CompilationUnitSyntax root = null;
		CSharpSyntaxContext syncon = null;
		ITypeSymbol typeL = null; //not null if X. where X is not type/namespace/unknown
		ISymbol symL = null; //symbol at left of . etc
		int typenameStart = -1;
		INamedTypeSymbol nativeApiClass = null;
		
		var cancelTS = _cancelTS = new CancellationTokenSource();
		var cancelToken = cancelTS.Token;
#if DEBUG
		if (Debugger.IsAttached) { cancelToken = default; _cancelTS = null; }
#endif
		
		try {
			CompletionList r = await Task.Run(async () => { //info: usually GetCompletionsAsync etc are not async
				model = await document.GetSemanticModelAsync(cancelToken).ConfigureAwait(false); //speed: does not make slower, because GetCompletionsAsync calls it too. Same speed if only GetSyntaxRootAsync.
				root = model.Root as CompilationUnitSyntax;
				var tok = root.FindToken(position, findInsideTrivia: true);
				//CiUtil.PrintNode(tok);
				
				//return if in trivia, except if space in non-comments
				if (!isCommand && !tok.Span.ContainsOrTouches(position)) {
					bool good = false;
					if (ch == ' ') good = tok.FindTrivia(position - 1).IsKind(SyntaxKind.WhitespaceTrivia);
					if (ch == '<') good = tok.FindTrivia(position - 1).RawKind == 0; //in XML doc
					if (!good) return null;
				}
				
				try { syncon = CSharpSyntaxContext.CreateContext(document, model, position, cancelToken); }
				catch (ArgumentException) { return null; } //may happen in invalid code, where probably don't need intellisense
				
				var node = tok.Parent;
				//p1.Next('s');
				
				//in some cases show list when typing a character where GetCompletionsAsync works only on command
				if (ch == '[' && syncon.IsAttributeNameContext) ch = default;
				if (ch == ' ' && syncon.IsObjectCreationTypeContext) ch = default;
				//rejected. Then, if typed space, shows list 2 times. Not nice.
				//if (ch == '|') { //show on 'Enum.Member|'. Roslyn shows only on 'Enum.Member| ' (need space after |).
				//	var t2 = tok.GetPreviousToken();
				//	if (t2.IsKind(SyntaxKind.BarToken) && t2.SpanStart == position - 1 && t2.Parent.IsKind(SyntaxKind.BitwiseOrExpression)) {
				//		var n2 = t2.GetPreviousToken().Parent;
				//		if (n2 is IdentifierNameSyntax && (model.GetTypeInfo(n2).Type?.IsEnumType() ?? false)) ch = default;
				//	}
				//}
				
				completionService = CompletionService.GetService(document);
				if (cancelToken.IsCancellationRequested) return null;
				
				var options = CompletionOptions.Default with {
					TriggerInArgumentLists = false,
					ShowNameSuggestions = false,
					SnippetsBehavior = SnippetsRule.NeverInclude,
					PerformSort = false,
					ShowItemsFromUnimportedNamespaces = unimported,
					ForceExpandedCompletionIndexCreation = unimported,
					ExpandedCompletionBehavior = unimported ? ExpandedCompletionMode.ExpandedItemsOnly : ExpandedCompletionMode.AllItems,
					//TargetTypedCompletionFilter = true, //?
				};
				//print.it(options);
				//rejected: support /// <completionlist cref="ClassUsedLikeEnum"/>. There is no option. It seems it's a legacy undocumented VS-only feature.
				var trigger = ch == default ? default : CompletionTrigger.CreateInsertionTrigger(ch);
				
				CompletionList r1 = await completionService.GetCompletionsAsync(document, position, options, null, trigger, cancellationToken: cancelToken).ConfigureAwait(false);
				if (r1 != null && r1.ItemsList.Count == 0) r1 = null;
				if (unimported) return r1; //don't support grouping etc. The completion items don't have Symbol. It's OK.
				if (r1 != null) {
					canGroup = true;
					//is it member access?
					bool propPatOrInit = node is PropertyPatternClauseSyntax or InitializerExpressionSyntax;
					if (propPatOrInit) {
						propPatOrInit = node.Span.ContainsInside(position);
					} else {
						if (position <= tok.SpanStart && tok.GetPreviousToken() is var t1 && t1.Kind() is SyntaxKind.CommaToken or SyntaxKind.OpenBraceToken)
							if (t1.Parent is PropertyPatternClauseSyntax or InitializerExpressionSyntax) (node, propPatOrInit) = (t1.Parent, true);
					}
					if (propPatOrInit) {
						if (node is InitializerExpressionSyntax) {
							//if only properties and/or fields, group by inheritance. Else group by namespace; it's a collection initializer list and contains everything.
							isDot = !r1.ItemsList.Any(o => o.Symbols?[0] is not (IPropertySymbol or IFieldSymbol));
							if (!isDot && ch == '{') return null; //eg 'new int[] {'
						} else isDot = true;
					} else {
						isDot = syncon.IsRightOfNameSeparator;
						if (isDot) { //set canGroup = false if Namespace.X or alias::X
							if (syncon.IsInImportsDirective) {
								canGroup = false;
							} else {
								var token = syncon.TargetToken; //not LeftToken, it seems they are swapped
								node = token.Parent;
								//CiUtil.PrintNode(token);
								//CiUtil.PrintNode(node);
								
								switch (node) {
								case MemberAccessExpressionSyntax s1: // . or ->
									node = s1.Expression;
									break;
								case MemberBindingExpressionSyntax s1: // ?.
									if (s1.Parent.Parent is ConditionalAccessExpressionSyntax caes1) node = caes1.Expression; else node = s1;
									break;
								case QualifiedNameSyntax s1: // eg . outside functions
									node = s1.Left;
									break;
								case AliasQualifiedNameSyntax: // ::
								case ExplicitInterfaceSpecifierSyntax: //Interface.X
								case QualifiedCrefSyntax: //does not include base members
									canGroup = false;
									break;
								case RangeExpressionSyntax: //x..y (user may want to make x.Method().y)
									break;
								default:
									Debug_.Print(node.GetType());
									isDot = canGroup = false;
									break;
								}
								
								if (canGroup) {
#if true //need typeL
									var ti = model.GetTypeInfo(node).Type;
									if (ti == null) {
										Debug_.PrintIf(model.GetSymbolInfo(node).Symbol is not INamespaceSymbol, node);
										canGroup = false;
									} else {
										symL = model.GetSymbolInfo(node).Symbol;
										Debug_.PrintIf(symL is INamespaceSymbol, node);
										//print.it(symL, symL is INamedTypeSymbol);
										if (symL is INamedTypeSymbol ints1) {
											typenameStart = node.SpanStart;
											if (CiWinapi.IsWinapiClassSymbol(ints1)) nativeApiClass = ints1.BaseType;
										} else typeL = ti;
									}
#else //need just canGroup
									if (model.GetSymbolInfo(node).Symbol is INamespaceSymbol) canGroup = false;
#endif
								}
								//print.it(canGroup);
							}
						}
					}
					//p1.Next('M');
				} else if (isCommand) {
					if (tok.IsInString(position, code, out stringInfo) == true) {
						var tspan = stringInfo.textSpan;
						stringFormat = CiUtil.GetParameterStringFormat(stringInfo.stringNode, model, true);
						if (stringFormat == PSFormat.Wildex) { //is regex in wildex?
							if (code.RxMatch(@"\G(?:\*\*\*\w+ )?\*\*c?rc? ", 0, out RXGroup rg, 0, tspan.ToRange())
								&& position >= tspan.Start + rg.Length) stringFormat = PSFormat.Regexp;
						} else if (stringFormat == PSFormat.None) stringFormat = (PSFormat)100;
					}
				}
				return r1;
			}); //await Task.Run
			
			if (cancelToken.IsCancellationRequested) return;
			
			if (r == null) {
				if (stringFormat == (PSFormat)100) {
					var m = new popupMenu();
					m["Regex"] = o => CodeInfo._tools.ShowForStringParameter(PSFormat.Regexp, cd, stringInfo);
					m["Keys"] = o => CodeInfo._tools.ShowForStringParameter(PSFormat.Keys, cd, stringInfo);
					m.Separator();
					m.Submenu("Help\tF1", m => {
						m["C# strings"] = o => run.itSafe(CiUtil.GoogleURL("C# strings"));
						m["String formatting"] = o => run.itSafe(CiUtil.GoogleURL("C# string formatting"));
						m["Wildcard expression"] = o => HelpUtil.AuHelp("articles/Wildcard expression");
						m["Output tags"] = o => HelpUtil.AuHelp("articles/Output tags");
					});
					m.Show(PMFlags.ByCaret, owner: doc.AaWnd);
				} else if (stringFormat != 0) {
					CodeInfo._tools.ShowForStringParameter(stringFormat, cd, stringInfo);
				}
				return;
			}
			
			Debug.Assert(doc == Panels.Editor.ActiveDoc); //when active doc changed, cancellation must be requested
			if (doc.aaaText != code) { //changed while awaiting
				timer.after(55, _ => { if (doc == Panels.Editor.ActiveDoc) ShowList(); });
				return;
				//TODO3: instead: when text changed, cancel and set timer.
			} else if (doc.aaaCurrentPos16 != position) return;
			//p1.Next('T');
			
			var provider = _GetProvider(r.ItemsList[0]); //currently used only in cases when all completion items are from same provider
			if (!isDot) isDot = provider == CiComplProvider.Override;
			//print.it(provider, isDot, canGroup, r.Items[0].DisplayText);
			
			var span = r.Span;
			
			var d = new _Data {
				completionService = completionService,
				document = document,
				model = model,
				codeLength = code.Length,
				filterText = code.Substring(span.Start, span.Length),
				items = new(r.ItemsList.Count),
				forced = isCommand,
				noAutoSelect = r.SuggestionModeItem != null,
				isDot = isDot,
				unimported = unimported
			};
			//if (r.SuggestionModeItem is {  } l) print.it(l.DisplayText, l.InlineDescription, l.Properties, l.ProviderName, l.Tags); //the item is not useful
			
			//ISymbol enclosing = null;
			//bool _IsAccessible(ISymbol symbol) {
			//	enclosing ??= model.GetEnclosingNamedTypeOrAssembly(position, default);
			//	return enclosing != null && symbol.IsAccessibleWithin(enclosing);
			//}
			
			//info: some members of enum UnmanagedType are missing. Hidden with EditorBrowsableState.Never, don't know why.
			
			//var testInternal = CodeInfo.Meta.TestInternal;
			Dictionary<INamespaceOrTypeSymbol, List<int>> groups = canGroup ? new(new CiNamespaceOrTypeSymbolEqualityComparer()) : null;
			List<int> keywordsGroup = null, etcGroup = null, snippetsGroup = null;
			uint kinds = 0; bool hasNamespaces = false;
			foreach (var ci_ in r.ItemsList) {
				//FUTURE: test with new Roslyn, maybe this fixed (in VS works well):
				//	The list contains only types if after `is`. Example: `bool ok = m is C.`. Here C is a class that contains inner types and int constants.
				
				var ci = ci_;
				if (unimported) {
					//if (ci.Flags.Has(CompletionItemFlags.Expanded)) { //now instead used CompletionOptions.ExpandedCompletionBehavior
					d.items.Add(new CiComplItem(provider, ci));
					//}
					continue;
				}
				
				Debug.Assert(ci.Symbols == null || ci.Symbols.Count > 0); //we may use code ci?.Symbols[0]. Roslyn uses this code in CompletionItem ctor: var firstSymbol = symbols[0];
				var sym = ci.Symbols?[0];
				
				//if (unimported && (ci.DisplayText == "Activator" || ci.DisplayText.Starts("Post"))) {
				//	print.it(ci.Flags, ci.InlineDescription, ci.Properties, ci.Tags);
				//}
				
				if (sym != null) {
					if (sym is IAliasSymbol ia) ci.Symbols = ImmutableArray.Create(sym = ia.Target);
					
					if (provider == CiComplProvider.Cref) { //why it adds internals from other assemblies?
						switch (sym.Kind) {
						case SymbolKind.NamedType when sym.DeclaredAccessibility != Microsoft.CodeAnalysis.Accessibility.Public && !sym.IsInSource() && !model.IsAccessible(0, sym):
							//ci.DebugPrint();
							continue;
						case SymbolKind.Namespace:
							//print.it(sym, sym.ContainingAssembly?.Name, sym.IsInSource());
							switch (sym.Name) {
							case "Internal" when sym.ContainingAssembly?.Name == "System.Core":
							case "Windows" when sym.ContainingAssembly?.Name == "mscorlib":
							case "MS" when sym.ContainingAssembly?.Name == null:
							case "FxResources" when sym.ContainingAssembly?.Name == "System.Resources.Extensions":
								continue;
							}
							break;
						}
					} else if (nativeApiClass != null && sym.ContainingType == nativeApiClass) {
						//d.items.Add(new CiComplItem(provider, ci) { moveDown = CiComplItemMoveDownBy.Name });
						d.items.Add(new CiComplItem(provider, ci) { hidden = CiComplItemHiddenBy.Always });
						continue;
					}
				}
				
				var v = new CiComplItem(provider, ci);
				kinds |= 1u << ((int)v.kind);
				//print.it(ci.DisplayText, sym);
				//if(ci.SortText != ci.DisplayText) print.it($"<>{ci.DisplayText}, sort={ci.SortText}");
				//if(ci.FilterText != ci.DisplayText) print.it($"<>{ci.DisplayText}, filter={ci.FilterText}");
				//if(!ci.DisplayTextSuffix.NE()) print.it($"<>{ci.DisplayText}, suf={ci.DisplayTextSuffix}");
				//if(!ci.DisplayTextPrefix.NE()) print.it($"<>{ci.DisplayText}, pre={ci.DisplayTextPrefix}");
				//print.it(ci.Flags); //a new internal property. Always None.
				
				switch (v.kind) {
				case CiItemKind.Method:
					if (sym != null) {
						if (sym.IsStatic) {
							switch (ci.DisplayText) {
							case "Equals":
							case "ReferenceEquals":
								//hide static members inherited from Object
								if (sym.ContainingType.BaseType == null) { //Object
									if (isDot && !(symL is INamedTypeSymbol ints1 && ints1.BaseType == null)) continue; //if not object
									v.moveDown = CiComplItemMoveDownBy.Name;
								}
								break;
							case "Main" when _IsOurScriptClass(sym.ContainingType):
								v.moveDown = CiComplItemMoveDownBy.Name;
								break;
							}
						} else {
							switch (ci.DisplayText) {
							case "Equals" or "GetHashCode" or "GetType" or "ToString":
							case "MemberwiseClone":
							case "Deconstruct": //record
							case "GetEnumerator": //IEnumerable
							case "CompareTo": //IComparable
							case "GetTypeCode": //IConvertible
							case "Clone" when sym.ContainingType.Name == "String": //this useless method would be the first in the list
								v.moveDown = CiComplItemMoveDownBy.Name;
								break;
							}
							//var ct = sym.ContainingType;
							//print.it(ct.ToString(), ct.Name, ct.ContainingNamespace.ToString(), ct.BaseType);
						}
					}
					break;
				case CiItemKind.Namespace when ci.Symbols != null: //null if extern alias
					hasNamespaces = true;
					switch (ci.DisplayText) {
					case "Accessibility":
					case "UIAutomationClientsideProviders":
						v.moveDown = CiComplItemMoveDownBy.Name;
						break;
					case "XamlGeneratedNamespace": continue;
					}
					break;
				case CiItemKind.TypeParameter:
					if (sym == null && ci.DisplayText == "T") continue;
					break;
				case CiItemKind.Class:
					if (!isDot && sym is INamedTypeSymbol ins && _IsOurScriptClass(ins)) v.moveDown = CiComplItemMoveDownBy.Name;
					break;
				case CiItemKind.EnumMember when !isDot:
					//workaround for: if Enum.Member, members are sorted by value, not by name. Same in VS.
					if (ci.SortText != ci.DisplayText) {
						string ss = ci.SortText, se = sym.ContainingType.Name;
						if (ss.Length == se.Length + 5 && ss.Starts(se) && ss[se.Length] == '_') //like "EnumName_0001"
							v.SetCI(ci = ci.WithSortText(se + "." + sym.Name));
					}
					break;
				case CiItemKind.EnumMember when isDot:
				case CiItemKind.Label:
					canGroup = false;
					break;
				case CiItemKind.LocalVariable:
					if (isDot) continue; //see the bug comment below
					break;
				}
				
				static bool _IsOurScriptClass(INamedTypeSymbol t) => t.Name is "Program" or "Script";
				
				if (sym != null && v.kind is not (CiItemKind.LocalVariable or CiItemKind.Namespace or CiItemKind.TypeParameter)) {
					if (ci.Symbols.All(sy => sy.IsObsolete())) v.moveDown = CiComplItemMoveDownBy.Obsolete; //can be several overloads, some obsolete but others not
				}
				
				d.items.Add(v);
			}
			//p1.Next('i');
			
			if (canGroup) {
				for (int i = 0; i < d.items.Count; i++) {
					var v = d.items[i];
					var sym = v.FirstSymbol;
					if (sym == null) {
						if (v.kind == CiItemKind.Keyword) (keywordsGroup ??= []).Add(i);
						else (etcGroup ??= []).Add(i);
					} else {
						INamespaceOrTypeSymbol nts;
						if (!isDot) {
							nts = sym.ContainingNamespace;
							
							//put locals at the top
							if (nts?.ContainingNamespace != null && sym.ContainingSymbol is not INamespaceOrTypeSymbol) {
								while (nts.ContainingNamespace is INamespaceSymbol n1) nts = n1; //global namespace
							}
							//rejected: also put members of enclosing type[s] (and the type itself) at the top.
							//	Not so easy to implement without problems like "Enum.Member" in a different group than the "Enum".
							//	In some cases model.GetEnclosingNamedType returns other object although logically it is the same as sym.
							//	Also then may be more confusion. Now everything is clear: locals are at the top, as well as everything namespaceless.
							//	Simple code that does not work well:
							//let only types be in namespace groups. Put locals and non-type members of enclosing type(s) at the top.
							//if (nts.ContainingNamespace != null && sym is not INamespaceOrTypeSymbol) {
							//	while (nts.ContainingNamespace is INamespaceSymbol n1) nts = n1; //global namespace
							//}
							
							//CONSIDER: put in different groups: namespaces, locals, members of enclosing type(s), other namespaceless symbols. Now grouped by kind.
						}
						//else if(sym is ReducedExtensionMethodSymbol em) nts = em.ReceiverType; //rejected. Didn't work well, eg with linq.
						else nts = sym.ContainingType;
						
						//Roslyn bug: sometimes adds some garbage items.
						//To reproduce: invoke global list. Then invoke list for a string variable. Adds String, Object, all local string variables, etc. Next time works well. After Enum dot adds the enum type, even in VS; in VS sometimes adds enum methods and extmethods.
						//Debug_.PrintIf(nts == null, sym.Name);
						if (nts == null) continue;
						
						//extension type (no Name) -> containing type
						if (nts is INamedTypeSymbol { IsExtension: true }) nts = nts.ContainingType;
						
						if (groups.TryGetValue(nts, out var list)) list.Add(i); else groups.Add(nts, [i]);
					}
				}
				
				//snippets, winapi
				if (isDot) {
					if (typeL != null) { //eg variable.x
					} else if (nativeApiClass != null) { //api.x
						int i = d.items.Count;
						bool newExpr = syncon.TargetToken.Parent.Parent is ObjectCreationExpressionSyntax or StackAllocArrayCreationExpressionSyntax; //info: syncon.IsObjectCreationTypeContext false
						d.winapi = CiWinapi.AddWinapi(symL as INamedTypeSymbol, d.items, typenameStart, newExpr);
						int n = d.items.Count - i;
						if (n > 0) {
							snippetsGroup = new(n);
							for (; i < d.items.Count; i++) snippetsGroup.Add(i);
						}
					}
				} else if (!d.noAutoSelect && (hasNamespaces || _OnlyCSharpKeywordsOrDirectives())) {
					//add snippets
					if (provider is not (CiComplProvider.Cref or CiComplProvider.XmlDoc)) {
						int i = d.items.Count;
						CiSnippets.AddSnippets(d.items, span, root, code, false, syncon);
						for (; i < d.items.Count; i++) (snippetsGroup ??= []).Add(i);
					}
				}
				
				bool _OnlyCSharpKeywordsOrDirectives()
					=> kinds == 1u << (int)CiItemKind.Keyword && provider == CiComplProvider.Keyword;
			}
			//p1.Next('+');
			
			if (d.items.Count == 0) return;
			
			List<string> groupsList = null;
			if (canGroup && groups.Count + (keywordsGroup == null ? 0 : 1) + (etcGroup == null ? 0 : 1) + (snippetsGroup == null ? 0 : 1) > 1) {
				List<(string, List<int>)> g = null;
				if (isDot) {
					var gs = groups.ToList();
					gs.Sort((k1, k2) => {
						//let extension methods be at bottom, sorted by type name
						int em1 = d.items[k1.Value[0]].kind == CiItemKind.ExtensionMethod ? 1 : 0;
						int em2 = d.items[k2.Value[0]].kind == CiItemKind.ExtensionMethod ? 1 : 0;
						int diff = em1 - em2;
						if (diff != 0) return diff;
						if (em1 == 1) return string.Compare(k1.Key.Name, k2.Key.Name, StringComparison.OrdinalIgnoreCase);
#if true
						//sort non-extension members by inheritance or base interface
						var t1 = k1.Key as INamedTypeSymbol; var t2 = k2.Key as INamedTypeSymbol;
						if (t1.InheritsFromOrImplementsOrEqualsIgnoringConstruction(t2)) return -1;
						if (t2.InheritsFromOrImplementsOrEqualsIgnoringConstruction(t1)) return 1;
						//interface and object? For both, BaseType returns null and InheritsFromOrImplementsOrEqualsIgnoringConstruction returns false.
						var tk1 = t1.TypeKind; var tk2 = t2.TypeKind;
						if (tk1 == TypeKind.Class && t1.BaseType == null) return 1; //t1 is object
						if (tk2 == TypeKind.Class && t2.BaseType == null) return -1; //t2 is object
						//Debug_.Print($"{t1}, {t2},    {t1.BaseType}, {t2.BaseType},    {tk1}, {tk2}");
#else
						//sort non-extension members by inheritance
						var t1 = k1.Key as INamedTypeSymbol; var t2 = k2.Key as INamedTypeSymbol;
						if (_IsBase(t1, t2)) return -1;
						if (_IsBase(t2, t1)) return 1;
						static bool _IsBase(INamedTypeSymbol t, INamedTypeSymbol tBase) {
							for (t = t.BaseType; t != null; t = t.BaseType) if (t == tBase) return true;
							return false;
						}
						//can be both interfaces, or interface and object. For object and interfaces BaseType returns null.
						var tk1 = t1.TypeKind; var tk2 = t2.TypeKind;
						if (tk1 == TypeKind.Class && t1.BaseType == null) return 1; //t1 is object
						if (tk2 == TypeKind.Class && t2.BaseType == null) return -1; //t2 is object
						if (tk1 == TypeKind.Interface && tk2 == TypeKind.Interface) {
							if (t2.AllInterfaces.Contains(t1)) return 1;
							if (t1.AllInterfaces.Contains(t2)) return -1;
						}
						//fails for eg ObservableCollection<>. Uses 2 variables for t2 and t1.BaseType although it is the same type.
						Debug_.Print($"{t1}, {t2}, {k1.Value.Count}, {k2.Value.Count}, {tk1}, {tk2}, {t1.BaseType}, {t2.BaseType}"); //usually because of Roslyn bugs
#endif
						
						return 0;
					});
					//print.it(gs);
					
#if true
					if (gs[0].Key.Name == "String") { //don't group Au extension methods
						for (int i = gs.Count; --i > 0;) {
							if (d.items[gs[i].Value[0]].kind != CiItemKind.ExtensionMethod) continue;
							var ns = gs[i].Key.ContainingNamespace;
							if (ns.Name == "Types" && ns.ContainingNamespace.Name == "Au") {
								gs[0].Value.AddRange(gs[i].Value);
								gs.RemoveAt(i);
								//break; //no. If testInternal Au, we have 2 Au.Types.
							}
						}
					}
#else
					if(!App.Settings.ci_complGroupEM) { //don't group non-Linq extension methods
						for(int i = 1; i < gs.Count; i++) {
							if(d.items[gs[i].Value[0]].kind != CiItemKind.ExtensionMethod) continue;
							var ns = gs[i].Key.ContainingNamespace;
							if(ns.Name != "Linq") {
								gs[0].Value.AddRange(gs[i].Value);
								gs.RemoveAt(i--);
							}
						}
					}
#endif
					
					g = gs.Select(o => (o.Key.Name, o.Value)).ToList(); //list<(itype, list)> -> list<typeName, list>
				} else {
					g = groups.Select(o => (o.Key.QualifiedName(), o.Value)).ToList(); //dictionary<inamespace, list> -> list<namespaceName, list>
					g.Sort((e1, e2) => {
						//order: global, Au, my, others by name, Microsoft.*
						string s1 = e1.Item1, s2 = e2.Item1;
						int k1 = s1.Length <= 2 ? (s1 switch { "" => 3, "Au" => 2, "my" => 1, _ => 0 }) : s1.Starts("Microsoft.") ? -1 : 0;
						int k2 = s2.Length <= 2 ? (s2 switch { "" => 3, "Au" => 2, "my" => 1, _ => 0 }) : s2.Starts("Microsoft.") ? -1 : 0;
						int kd = k2 - k1; if (kd != 0) return kd;
						return string.Compare(s1, s2, StringComparison.OrdinalIgnoreCase);
					});
					//print.it("----");
					//foreach(var v in g) print.it(v.Item1, v.Item2.Count);
					
					if (hasNamespaces && _GetFilters(model, out var filters)) {
						foreach (var (ns, a) in g) { //for each namespace in completion list
							if (ns.NE() || !filters.TryGetValue(ns, out var k)) continue;
							foreach (var i in a) { //for each type in that namespace in completion list
								var sym = d.items[i].FirstSymbol;
								if (sym is not INamedTypeSymbol nt) {
									if (sym is IFieldSymbol fs) nt = fs.ContainingType; //enum member
									else continue;
								}
								var s = nt.Name;
								string opt = k[0];
								bool found = k.Length == 1 || (k.Length == 2 && k[1] == "*");
								if (!found) {
									for (int j = 1; j < k.Length; j++) { //for each type in filter, including additional options, like [-~ T1 T2 - T3 T4]
										var t = k[j];
										if (t[0] is '+' or '-') { opt = t; continue; }
										//if (s.Like(u)) { found = true; break; }
										if (t[0] == '*') found = s.Ends(t.AsSpan(1..));
										else if (t[^1] == '*') found = s.Starts(t.AsSpan(..^1));
										else found = s == t;
										if (found) break;
									}
								}
								if (found == (opt[0] == '-')) {
									var ci = d.items[i];
									if (opt.Eq(1, '~')) ci.moveDown |= CiComplItemMoveDownBy.Name;
									else ci.hidden |= CiComplItemHiddenBy.Always;
								}
							}
						}
					}
				}
				if (keywordsGroup != null) g.Add(("keywords", keywordsGroup));
				if (snippetsGroup != null) g.Add((isDot ? "" : "snippets", snippetsGroup));
				if (etcGroup != null) g.Add(("etc", etcGroup));
				for (int i = 0; i < g.Count; i++) {
					foreach (var v in g[i].Item2) d.items[v].group = i;
				}
				groupsList = g.Select(o => o.Item1).ToList();
			}
			//p1.Next('g');
			
			if (!span.IsEmpty) _FilterItems(d);
			//p1.Next('F');
			
			d.tempRange = doc.ETempRanges_Add(this, span.Start, span.End, () => {
				//print.it("leave", _data==d);
				if (_data == d) _CancelUI(tempRangeRemoved: true);
			}, position == span.End ? SciCode.TempRangeFlags.LeaveIfPosNotAtEndOfRange : 0);
			
			_data = d;
			if (_popupList == null) {
				_popupList = new CiPopupList(this);
				_popupList.PopupWindow.Hidden += (_, _) => _CancelUI(popupListHidden: true);
			}
			_popupList.Show(doc, span.Start, _data.items, groupsList, winApi: nativeApiClass != null); //and calls SelectBestMatch
		}
		catch (OperationCanceledException) { /*Debug_.Print("canceled");*/ return; }
		finally {
			if (_data == null) {
				//p1.Next('z');
				//print.it($"{p1.ToString()}  |  ch='{(ch == default ? "" : ch.ToString())}', canceled={cancelTS.IsCancellationRequested}");
			}
			cancelTS.Dispose();
			if (cancelTS == _cancelTS) _cancelTS = null;
		}
		
		static bool _GetFilters(SemanticModel model, out Dictionary<string, string[]> filters) {
			//using var p2 = perf.local(); //~50 mcs
			var stCurrent = model.SyntaxTree;
			filters = null;
			foreach (var st in model.Compilation.SyntaxTrees) {
				//print.it(st.FilePath);
				foreach (var u in st.GetCompilationUnitRoot().Usings) {
					if (u.GlobalKeyword.RawKind == 0 && st != stCurrent) break;
					if (u.Alias != null || u.StaticKeyword.RawKind != 0) continue;
					//print.it(u);
					var tt = u.GetTrailingTrivia().FirstOrDefault(o => o.IsKind(SyntaxKind.SingleLineCommentTrivia));
					if (tt.RawKind != 0) {
						var text = tt.ToString(); //print.it((object)text==tt.ToString()); //true, fast
						if (text[^1] == ']') {
							int i = text.LastIndexOf('[') + 1;
							if (i > 0 && text[i] is '+' or '-') {
								var a = text[i..^1].Split(' ', StringSplitOptions.RemoveEmptyEntries);
								filters ??= new();
								filters[u.Name.ToString()] = a;
								continue;
							}
						}
					}
					filters?.Remove(u.Name.ToString());
				}
			}
			return filters != null;
		}
	}
	
	static void _FilterItems(_Data d) {
		var filterText = d.filterText;
		foreach (var v in d.items) {
			v.hidden &= ~CiComplItemHiddenBy.FilterText;
			v.hilite = 0;
			v.moveDown &= ~CiComplItemMoveDownBy.FilterText;
		}
		if (!filterText.NE()) {
			string textLower = filterText.Lower(), textUpper = filterText.Upper();
			char c0Lower = textLower[0], c0Upper = textUpper[0];
			foreach (var v in d.items) {
				if (v.kind == CiItemKind.None) continue; //eg regex completion
				var s = v.FilterText;
				//Debug_.PrintIf(v.FilterText != v.Text, $"{v.FilterText}, {v.Text}");
				//print.it(v.Text, v.FilterText, v.ci.SortText, v.ci.ToString());
				bool found = false;
				int iFirst = _FilterFindChar(s, 0, c0Lower, c0Upper), iFirstFirst = iFirst;
				if (iFirst >= 0) {
					if (filterText.Length == 1) {
						_HiliteChar(iFirst);
					} else {
						while (!s.Eq(iFirst, filterText, true)) {
							iFirst = _FilterFindChar(s, iFirst + 1, c0Lower, c0Upper);
							if (iFirst < 0) break;
						}
						if (iFirst >= 0) {
							_HiliteSubstring(iFirst);
						} else { //has all uppercase chars? Eg add OneTwoThree if text is "ott" or "ot" or "tt".
							_HiliteChar(iFirstFirst);
							for (int i = 1, j = iFirstFirst + 1; i < filterText.Length; i++, j++) {
								j = _FilterFindChar(s, j, textLower[i], textUpper[i], camel: true);
								if (j < 0) { found = false; break; }
								_HiliteChar(j);
							}
						}
					}
				}
				
				void _HiliteChar(int i) {
					found = true;
					if (i < 64) v.hilite |= 1UL << i;
				}
				
				void _HiliteSubstring(int i) {
					found = true;
					int to = Math.Min(i + filterText.Length, 64);
					while (i < to) v.hilite |= 1UL << i++;
				}
				
				if (found) {
					v.hilite <<= v.DisplayTextPrefix.Lenn();
					
					//if DisplayText != FilterText, correct or clear hilites. Eg cref.
					if (s != v.Text) {
						iFirst = v.Text.Find(s);
						if (iFirst < 0) v.hilite = 0; else v.hilite <<= iFirst;
					}
				} else {
					if (filterText.Length > 1 && (iFirst = s.Find(filterText, true)) >= 0) {
						v.moveDown |= CiComplItemMoveDownBy.FilterText; //sort bottom
						_HiliteSubstring(iFirst);
					} else v.hidden |= CiComplItemHiddenBy.FilterText;
				}
			}
		}
	}
	
	/// <summary>
	/// Finds character in s where it is one of: uppercase; lowercase after '_'/'@'; not uppercase/lowercase; any at i=0.
	/// </summary>
	/// <param name="s"></param>
	/// <param name="i">Start index.</param>
	/// <param name="cLower">Lowercase version of character to find.</param>
	/// <param name="cUpper">Uppercase version of character to find.</param>
	/// <param name="camel">Uppercase must not be preceded and followed by uppercase.</param>
	static int _FilterFindChar(string s, int i, char cLower, char cUpper, bool camel = false) {
		for (; i < s.Length; i++) {
			char c = s[i];
			if (c == cUpper) { //any not lowercase
				if (!camel) return i;
				if (i == 0 || !char.IsUpper(c)) return i;
				if (!char.IsUpper(s[i - 1])) return i;
				if (i + 1 < s.Length && char.IsLower(s[i + 1])) return i;
			}
			if (c == cLower) { //lowercase
				if (i == 0) return i;
				switch (s[i - 1]) { case '_': case '@': return i; }
			}
		}
		return -1;
	}
	
	public void SelectBestMatch(List<CiComplItem> visibleListItems, bool grouped) {
		CiComplItem ci = null;
		var filterText = _data.filterText;
		
		bool noSelect = visibleListItems.Count == 0 || filterText == "_";
		if (!noSelect && visibleListItems.Count > 10000 && filterText.Length <= 2) { //make the winapi list faster
			if (filterText.Length < 2) noSelect = true;
			else {
				ci = visibleListItems.FirstOrDefault(o => o.Text.Starts(filterText));
				ci ??= visibleListItems.FirstOrDefault(o => o.Text.Starts(filterText, true));
				noSelect = ci != null;
			}
		}
		
		if (!noSelect) {
			
			//rejected. Need FilterItems anyway, eg to select enum type or 'new' type.
			//if(filterText.NE()) {
			//	_popupList.SelectFirstVisible();
			//	return;
			//}
			
			var visible = visibleListItems.Select(o => o.GetCI()).ToImmutableArray();
			var fi = _data.completionService.FilterItems(_data.document, visible, filterText);
			//if (filterText.Length > 0) print.it("-", fi);
			//print.it(visible.Length, fi.Length);
			if (!fi.IsDefaultOrEmpty) {
				if (fi.Length < visible.Length || filterText.Length > 0 || visible.Length == 1) {
					var v = fi[0];
					if (!v.DisplayTextPrefix.NE() && fi.Length > 1 && fi.FirstOrDefault(o => o.DisplayTextPrefix.NE()) is { } vv) v = vv; //eg "(nint)" -> "Name"
					ci = v.Attach as CiComplItem;
					
					//rejected. Not sure it's better.
					//For normal priority items should ignore group and select by alphabet.
					//	Else often selects eg an Au or System namespace item instead of keyword. Probably it is not what users like.
					//if (grouped && fi.Length > 1 && filterText.Length > 1 && ci.ci.SortText.Starts(filterText[0])) {
					//	for(int i = 1; i < fi.Length; i++) {
					//		var v = fi[i].Attach as CiComplItem;
					//		if (v.moveDown != 0) break;
					//		if (v.group == ci.group) continue;
					//		string s1 = v.ci.SortText, s2 = ci.ci.SortText;
					//		if (s1.NE() || s2.NE() || s1[0] != s2[0]) continue;
					//		if (string.CompareOrdinal(s1, s2) < 0) ci = v;
					//	}
					//	//foreach(var v in fi) print.it(v, v.Rules.MatchPriority, v.Rules.SelectionBehavior); //all 0, Default
					//}
				}
			} else if (filterText == "" && !_data.isDot && !_data.unimported) {
				//Workaround for bug in new Roslyn: does not select enum when the target type is enum.
				//	The same after keyword 'new'.
				//	Never mind: does not prefer the target type when typed eg single letter and the list also contains static fields or props of that type like "Type.Member". It never worked.
				//	VS works well in all cases. Maybe it does not use this Roslyn API, or uses different Roslyn version.
				//	FUTURE: test after updating Roslyn, maybe fixed.
				foreach (var v in _data.items) {
					//if (v.ci is var j && j.DisplayText.Starts("DEdit")) print.it(j.DisplayText, j.Flags, j.Span, j.Tags, j.Properties, j.IsPreferredItem());
					//if (j.ci is var j && j.Properties.ContainsKey("Symbols")) print.it(j.DisplayText, j.Flags, j.Span, j.Tags, j.Properties, j.IsPreferredItem());
					if (v.kind is CiItemKind.Enum or CiItemKind.Class or CiItemKind.Structure or CiItemKind.Delegate && v.GetCI().Properties.ContainsKey("Symbols")) { //TODO3: unreliable
						ci = v;
						break;
					}
				}
			}
		}
		
		if (_data.noAutoSelect && ci != null) _popupList.SuggestedItem = ci;
		else _popupList.SelectedItem = ci;
	}
	//CONSIDER: when typed 1-2 lowercase chars, select keyword instead of type.
	//	Now these types are selected first (but none when typed 3 chars):
	/*
	elm else
	folders for
	inputBlocker int
	regexp return/ref/readonly/record    //ref/record are rare and before return, but readonly...
	trayIcon true/try
	uiimage uint

	RARE
	clipboard class
	filesystem finally/fixed
	pathname params
	print / process private/protected

	*/
	
	public System.Windows.Documents.Section GetDescriptionDoc(CiComplItem ci, int iSelect) {
		if (_data == null) return null;
		switch (ci.Provider) {
		case CiComplProvider.Snippet: return CiSnippets.GetDescription(ci);
		case CiComplProvider.Winapi: return CiWinapi.GetDescription(ci);
		}
		switch (ci.kind) {
		case CiItemKind.Keyword: return CiText.FromKeyword(ci.Text);
		case CiItemKind.Label: return CiText.FromLabel(ci.Text);
		}
		var symbols = ci.Symbols;
		if (symbols != null) return CiText.FromSymbols(symbols, iSelect, _data.model, _data.tempRange.CurrentFrom);
		if (ci.kind == CiItemKind.Namespace) return null; //extern alias
		Debug_.PrintIf(!(ci.kind == CiItemKind.None || ci.GetCI().Flags.Has(CompletionItemFlags.Expanded)), ci.kind); //None if Regex
		var r = _data.completionService.GetDescriptionAsync(_data.document, ci.GetCI()).Result_(); //fast if Regex, else not tested
		return r == null ? null : CiText.FromTaggedParts(r.TaggedParts);
	}
	
	/// <summary>
	/// Inserts the replacement text of the completion item.
	/// ch == default if clicked or pressed Enter or Tab or a hotkey eg Ctrl+Enter.
	/// key == default if clicked or typed a character (except Tab and Enter). Does not include hotkey modifiers.
	/// </summary>
	CiComplResult _Commit(SciCode doc, CiComplItem item, char ch, KKey key) {
		//At first hide UI and set _data=null. Else modifying document text may cause bugs.
		var data = _data;
		int currentFrom = data.tempRange.CurrentFrom, currentTo = data.tempRange.CurrentTo;
		_CancelUI();
		
		if (item.Provider == CiComplProvider.EmbeddedLanguage) { //can complete only on click or Tab
			if (ch != default || !(key == default || key == KKey.Tab)) return CiComplResult.None;
		} else if (ch == ':') { //don't complete if `label:`
			if (data.model.SyntaxTree.FindTokenOrEndToken(currentFrom, default).Parent is IdentifierNameSyntax node) {
				if ((node.Parent is ExpressionStatementSyntax ess && ess.Parent is BlockSyntax) || (node.Parent is VariableDeclarationSyntax vds && vds.Parent is LocalDeclarationStatementSyntax)) {
					if (!(item.Text == "global" || (item.FirstSymbol is INamespaceSymbol ns && ns.IsGlobalNamespace))) //eg `global::`
						return CiComplResult.None;
				}
			}
		}
		
		bool isSpace; if (isSpace = ch == ' ') ch = default;
		int codeLenDiff = doc.aaaLen16 - data.codeLength;
		
		if (item.Provider == CiComplProvider.Snippet) {
#if true
			if (ch is not ('\0' or '(')) return CiComplResult.None;
			CiSnippets.Commit(doc, item, codeLenDiff);
			return CiComplResult.Complex;
#else //rejected: support eg identifierSnippet.<new completion list>. Better use type alias.
			if (ch is not ('\0' or '(' or '.')) return CiComplResult.None;
			var snippet = CiSnippets.Commit(doc, item, codeLenDiff);
			return ch != default && snippet != null && snippet.Split('.').All(o => SyntaxFacts.IsValidIdentifier(o)) ? CiComplResult.Simple //support eg identifierSnippet.<new completion list>
				: CiComplResult.Complex; //eat the char
			//rejected: if the snippet inserted code like `Type.Method` and completed with space, append `()`. Instead let use snippet `Type.Method($end$)`.
#endif
		}
		
		string s, displayTextSuffix = null;
		int startPos, len;
		bool isComplex = false;
		bool ourProvider = item.Provider is CiComplProvider.Winapi;
		
		if (ourProvider) {
			s = item.Text;
			startPos = currentFrom;
			len = currentTo - startPos;
			//info: item.ci is null
		} else {
			var ci = item.GetCI();
			displayTextSuffix = ci.DisplayTextSuffix;
			var change = data.completionService.GetChangeAsync(data.document, ci).Result_();
			//note: don't use the commitCharacter parameter. Some providers, eg XML doc, always set IncludesCommitCharacter=true, even when commitCharacter==null, but may include or not, and may include inside text or at the end.
			
			var changes = change.TextChanges;
			var provider = _GetProvider(ci);
			isComplex = changes.Length > 1 || change.NewPosition.HasValue || provider is CiComplProvider.Override or CiComplProvider.XmlDoc;
			
			var lastChange = changes.Last();
			s = lastChange.NewText;
			if (s.NE()) return CiComplResult.None; //Roslyn bug: fails if there are parameters of type nint. Same in VS. Tried a workaround (modify ci.Properties["Symbols"]), but unsuccessfully. Tried to find/modify the Roslyn code, but it's too deep.
			var span = lastChange.Span;
			startPos = span.Start;
			len = span.Length + codeLenDiff;
			if (isComplex) { //xml doc, override, regex
				int newPos = change.NewPosition ?? -1;
				if (ch != default && newPos >= 0) return CiComplResult.None;
				switch (provider) {
				case CiComplProvider.Override:
					newPos = -1;
					if (App.Settings.ci_formatTabIndent) {
						//Replace 4 spaces with tab. Make { in same line.
						s = s.Replace("    ", "\t").RxReplace(@"\R\t*\{", " {", 1);
						//Correct indent. 
						int indent = s.FindNot("\t"), indent2 = doc.aaaLineIndentFromPos(true, currentFrom);
						if (indent > indent2) s = s.RxReplace("(?m)^" + new string('\t', indent - indent2), "");
					}
					break;
				case CiComplProvider.XmlDoc:
					if (!s.Ends('>') && s.RxMatch(@"^<?(\w+)($| )", 1, out string tag)) {
						if (CodeInfo.GetDocumentAndFindNode(out _, out var n1, span.Start, findInsideTrivia: true) && null == n1.GetAncestorOrThis<XmlNameAttributeSyntax>()) { //not in <tag attr="|">
							string lt = s.Starts('<') || doc.aaaText.Eq(span.Start - 1, '<') ? "" : "<";
							if (s == tag || (ci.Properties.TryGetValue("AfterCaretText", out var s1) && s1.NE()) && newPos > 0) newPos += 1 + lt.Length;
							s = $"{lt}{s}></{tag}>";
						}
					}
					break;
				}
				using var undo = doc.ENewUndoAction();
				bool last = true;
				for (int j = changes.Length; --j >= 0; last = false) {
					var v = changes[j];
					if (last) doc.aaaReplaceRange(true, v.Span.Start, v.Span.End + codeLenDiff, s, moveCurrentPos: newPos < 0);
					else doc.aaaReplaceRange(true, v.Span.Start, v.Span.End, v.NewText);
				}
				if (newPos >= 0) doc.aaaSelect(true, newPos, newPos, makeVisible: true);
				
				return CiComplResult.Complex;
			}
		}
		Debug_.PrintIf(startPos != currentFrom && item.Provider != CiComplProvider.EmbeddedLanguage, $"{currentFrom}, {startPos}");
		
		//if typed space after method or keyword 'if' etc, replace the space with '(' etc. Also add if pressed Tab or Enter.
		CiAutocorrect.EBrackets bracketsOperation = default;
		int caretBack = 0, bracketsFrom = 0, bracketsLen = 0;
		//bool isEnter = key == KKey.Enter;
		string sAppend = null;
		
		if (s.FindAny("({[<") < 0) {
			if (ch == default) { //completed with Enter, Tab, Space or click
				switch (item.kind) {
				case CiItemKind.Method or CiItemKind.ExtensionMethod:
					ch = '(';
					break;
				case CiItemKind.Keyword:
					string name = item.Text;
					switch (name) {
					case "for" or "foreach" or "while" or "lock" or "catch":
					case "if" when !_IsDirective():
					case "fixed" when _IsStartOfStatement(): //else in struct
					//case "using" when _IsStartOfStatement(): //else directive. But can be with or without `()`.
					case "when" when _IsInAncestorNode(startPos, n => (n is CatchClauseSyntax, n is SwitchSectionSyntax)): //`catch(...) when`
						(ch, sAppend) = ('(', " ()");
						break;
					//rejected: append ` {  }`. Too many confusing features isn't good. Probably rarely somebody uses or likes it. Also, would need to delete `;`.
					//case "try" or "finally":
					//case "get" or "set" or "add" or "remove" or "do" or "unsafe" or "checked" or "unchecked" when isEnter:
					//case "else" when isEnter && !_IsDirective():
					//	ch = '{';
					//	break;
					case "switch":
						if (_IsStartOfStatement()) (ch, sAppend) = ('(', " ()"); //else ch = '{';
						break;
					case "nameof" or "sizeof" or "typeof":
					case "checked" or "unchecked" when !_IsStartOfStatement():
						ch = '(';
						break;
					default:
						if (_NeedParentheses()) ch = '(';
						break;
					}
					break;
				case CiItemKind.Class or CiItemKind.Structure or CiItemKind.Interface or CiItemKind.Enum or CiItemKind.Delegate:
					if (displayTextSuffix == "<>") ch = '<';
					else if (_NeedParentheses()) ch = '(';
					break;
				}
				
				bool _IsDirective() => doc.aaaText.Eq(startPos - 1, "#"); //info: CompletionItem of 'if' and '#if' are identical. Nevermind: this code does not detect '# if'.
				
				if (isComplex = ch != default) {
					//if (ch == '{') {
					//	if (isEnter) {
					//		int indent = doc.aaaLineIndentFromPos(true, startPos);
					//		var b = new StringBuilder(" {\r\n");
					//		b.AppendIndent(indent + 1);
					//		b.AppendLine().AppendIndent(indent).Append('}');
					//		sAppend = b.ToString();
					//		caretBack = indent + 3;
					//	} else {
					//		sAppend = " {  }";
					//		caretBack = 2;
					//	}
					//	bracketsFrom = startPos + s.Length + 2;
					//	bracketsLen = sAppend.Length - 3;
					//} else
					if (App.Settings.ci_complParen switch { 0 => isSpace, 1 => true, _ => false } && !data.noAutoSelect && !doc.aaaText.Eq(startPos + len, ch)) { //info: noAutoSelect when lambda argument
						sAppend ??= ch == '(' ? "()" : "<>";
						caretBack = 1;
						bracketsFrom = startPos + s.Length + sAppend.Length - 1;
					} else {
						ch = default;
						sAppend = null;
						isComplex = false;
					}
				}
			} else if (!(ch is '(' or '<' or '[' or '{' || data.noAutoSelect)) { //completed with ;,.?- etc
				if (_NeedParentheses()) sAppend = "()";
			}
			
			bool _NeedParentheses() {
				if (item.kind is CiItemKind.Method or CiItemKind.ExtensionMethod) return true;
				if (ch == '.') return false; //if 'new Word.', often can be eg 'new Word.Word()' but rarely 'new Word().'
				switch (item.kind) {
				case CiItemKind.Class or CiItemKind.Structure or CiItemKind.Enum or CiItemKind.Delegate:
				//if (ci.Properties.TryGetValue("ShouldProvideParenthesisCompletion", out var v1) && v1.Eqi("True")) goto g1; //missing when eg 'new Namespace.Type'
				//break;
				case CiItemKind.Keyword when item.Text is "string" or "object" or "int" or "uint" or "nint" or "nuint" or "long" or "ulong" or "byte" or "sbyte" or "short" or "ushort" or "char" or "bool" or "double" or "float" or "decimal":
					if (CodeInfo.GetDocumentAndFindNode(out _, out var node, startPos)) {
						node = node.Parent;
						if (node is QualifiedNameSyntax) node = node.Parent;
						if (node is ObjectCreationExpressionSyntax) goto g1;
						if (node is AttributeSyntax && item.kind is CiItemKind.Class) return true;
					}
					break;
				}
				return false;
				g1:
				bracketsOperation = CiAutocorrect.EBrackets.NewExpression;
				return true;
				//If 'new Type', adds '()'.
				//If then coder types '[' for 'new Type[]' or '{' for 'new Type { initializers }', autocorrection will replace the '()' with '[]' or '{  }'.
			}
			
			//bool _IsGeneric()
			//	=> ci.Properties.TryGetValue("IsGeneric", out var v1) && v1.Eqi("True");
		}
		
		try {
			if (sAppend == null && s == data.filterText) return CiComplResult.None;
			
			if (!doc.aaaText.Eq(startPos..(startPos + len), s)) doc.aaaSetAndReplaceSel(true, startPos, startPos + len, s); else doc.aaaCurrentPos16 = startPos + len;
			if (sAppend != null) {
				doc.aaaReplaceSel(sAppend);
				if (ch == ';' && caretBack == 0 && doc.aaaCharAt8(doc.aaaCurrentPos8) == ';') { caretBack = -1; isComplex = true; } //skip `;`
			}
			if (caretBack != 0) doc.aaaCurrentPos8 -= caretBack;
			if (bracketsFrom > 0) {
				CodeInfo._correct.BracketsAdded(doc, bracketsFrom, bracketsFrom + bracketsLen, bracketsOperation);
			}
			
			return isComplex ? CiComplResult.Complex : CiComplResult.Simple;
		}
		finally {
			if (ourProvider) {
				switch (item.Provider) {
				case CiComplProvider.Winapi: data.winapi.OnCommitInsertDeclaration(item); break;
				}
			}
			if (isComplex && ch is '(' or '<') {
				CodeInfo._signature.SciCharAdded(doc, ch, methodCompletion: ch == '(' && item.kind is CiItemKind.Method or CiItemKind.ExtensionMethod);
				bool methodCompletion = ch == '(' && item.kind is CiItemKind.Method or CiItemKind.ExtensionMethod; //may need to show enum list for the first method parameter, like when typed '('
				CodeInfo._signature.SciCharAdded(doc, ch, methodCompletion);
			}
		}
		
		//static bool _IsInAncestorNodeOfType<T>(int pos) where T : SyntaxNode
		//	=> CodeInfo.GetDocumentAndFindNode(out _, out var node, pos) && null != node.GetAncestor<T>();
		
		static bool _IsInAncestorNode(int pos, Func<SyntaxNode, (bool yes, bool no)> f) {
			if (!CodeInfo.GetDocumentAndFindNode(out _, out var node, pos)) return false;
			while ((node = node.Parent) != null) {
				//CiUtil.PrintNode(node);
				var (yes, no) = f(node);
				if (yes) return true;
				if (no) return false;
			}
			return false;
		}
		
		bool _IsStartOfStatement() {
			if (!CodeInfo.GetDocumentAndFindToken(out _, out var tok, startPos, metaToo: true)) return false;
			for (var node = tok.Parent; node?.SpanStart == startPos; node = node.Parent) {
				if (node is StatementSyntax or IncompleteMemberSyntax { Parent: CompilationUnitSyntax }) {
					//still can be an expression. Eg if `int j = i sw`, Roslyn assumes `int j = i` is a statement with missing `;`, and `sw` is another statement.
					tok = tok.GetPreviousToken();
					return tok.Kind() is 0 or SyntaxKind.SemicolonToken or SyntaxKind.OpenBraceToken or SyntaxKind.CloseBraceToken or SyntaxKind.ColonToken;
				}
			}
			return false;
		}
	}
	
	/// <summary>
	/// Double-clicked item in list.
	/// </summary>
	public void Commit(SciCode doc, CiComplItem item) => _Commit(doc, item, default, default);
	
	/// <summary>
	/// Tab, Enter, Ctrl/Shift+Enter, Ctrl+;.
	/// </summary>
	public CiComplResult OnCmdKey_Commit(SciCode doc, KKey key) {
		var R = CiComplResult.None;
		if (_data != null) {
			var ci = _popupList.SelectedItem;
			if (key is KKey.Tab) ci ??= _popupList.SuggestedItem;
			if (ci != null) {
				R = _Commit(doc, ci, default, key);
				if (R == CiComplResult.None && key is KKey.Tab or KKey.Enter) R = CiComplResult.Simple; //always suppress Tab and Enter
			}
			_CancelUI();
		}
		return R;
	}
	
	/// <summary>
	/// Esc, Arrow, Page, Home, End.
	/// </summary>
	public bool OnCmdKey_SelectOrHide(KKey key) => _data != null && _popupList.OnCmdKey(key);
	
	static CiComplProvider _GetProvider(CompletionItem ci) {
		var s = ci.ProviderName;
		Debug_.PrintIf(s == null, "ProviderName null");
		if (s == null) return CiComplProvider.Other;
		int i = s.LastIndexOf('.') + 1;
		Debug.Assert(i > 0);
		//print.it(s[i..]);
		if (s.Eq(i, "Symbol")) return CiComplProvider.Symbol;
		if (s.Eq(i, "Keyword")) return CiComplProvider.Keyword;
		if (s.Eq(i, "Cref")) return CiComplProvider.Cref;
		if (s.Eq(i, "XmlDoc")) return CiComplProvider.XmlDoc;
		if (s.Find("EmbeddedLanguage", i) >= 0) return CiComplProvider.EmbeddedLanguage;
		if (s.Eq(i, "Override")) return CiComplProvider.Override;
		//if (s.Eq(i, "ExternAlias")) return CiComplProvider.ExternAlias;
		//if (s.Eq(i, "ObjectAndWith")) return CiComplProvider.ObjectAndWithInitializer;
		//if (s.Eq(i, "AttributeNamedParameter")) return CiComplProvider.AttributeNamedParameter; //don't use because can be mixed with other symbols
		return CiComplProvider.Other;
	}
}


================================================
FILE: Au.Editor/Edit/CiErrors.cs
================================================
extern alias CAW;

using Au.Controls;
using System.Collections.Immutable;

using Microsoft.CodeAnalysis;
using CAW::Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Text;
using Microsoft.CodeAnalysis.Shared.Extensions;
using CAW::Microsoft.CodeAnalysis.Shared.Extensions;
using Microsoft.CodeAnalysis.CSharp.Extensions.ContextQuery;

namespace LA;

class CiErrors {
	record struct _Diagnostic(Diagnostic d, int start, int end) {
		public ErrorCode Code => (ErrorCode)d.Code;
	}
	
	SemanticModel _semo;
	List<_Diagnostic> _codeDiag;
	readonly List<StartEndText> _stringErrors = new();
	readonly List<StartEndText> _metaErrors = new();
	StartEnd _metaRange;
	
	/// <param name="start16"></param>
	/// <param name="end16"></param>
	/// <param name="pasting">true on paste, drop or `InsertCode.Statements`</param>
	/// <param name="pastingSilent">true if `InsertCode.Statements`</param>
	public void Indicators(int start16, int end16, bool pasting = false, bool pastingSilent = false) {
		bool pastedWithUsings = false;
		gStart:
		_semo = null;
		
		if (!CodeInfo.GetContextAndDocument(out var cd, 0, metaToo: true)) return;
		var doc = cd.sci;
		var code = cd.code;
		if (end16 < code.Length && code.Eq(end16 - 1, '\n')) end16--; //don't include error from next line
		if (end16 <= start16) return;
		bool has = false;
		var semo = cd.semanticModel;
		
		var aDiag = semo.GetDiagnostics(TextSpan.FromBounds(start16, end16));
		
		if (!aDiag.IsDefaultOrEmpty) {
			if (pasting && !pastingSilent && !pastedWithUsings && _PastedWithUsings(cd, aDiag, ref start16, ref end16)) {
				pastedWithUsings = true;
				goto gStart;
			}
			
			_codeDiag = new(aDiag.Length);
			foreach (var d_ in aDiag) {
				var d = d_;
				if (d.IsSuppressed) continue;
				var loc = d.Location; if (!loc.IsInSource) continue;
				var span = loc.SourceSpan;
				//print.it(d.Severity, span, d.Id);
				int start = Math.Min(span.Start, code.Length), end = Math.Clamp(span.End, start, code.Length);
				if (end == start) {
					if (end < code.Length && code[end] is not ('\r' or '\n')) end++;
					else if (start > 0) start--;
				}
				var ec = (ErrorCode)d.Code;
				if (start == 0 && ec == ErrorCode.WRN_UnprocessedXMLComment) continue; //XML comment at start
				
				//workaround for: when starting to type the last top-level statement, if it's a word (a C# type or non-keyword), error
				//	"A namespace cannot directly contain members such as fields or methods". Users would think it's a bug of this program.
				//	Another workaround would be to add ';' after. But it does not work if it's a C# type eg 'int'.
				//	Let's ignore it in editor. It's a lesser evil. And nobody will compile such unfinished code.
				//if (ec == ErrorCode.ERR_NamespaceUnexpected) continue;
				if (ec == ErrorCode.ERR_NamespaceUnexpected) {
					//If unknown name, convert to ERR_NameNotInContext. Then on mouse hover will display tooltip with links to add using directive etc.
					var d2 = cd.document.WithText(SourceText.From(code.Insert(end, ";")));
					var m2 = d2.GetSemanticModelAsync().Result_();
					//print.it(m2.GetDiagnostics(span));
					d = m2.GetDiagnostics(span).FirstOrDefault(o => (ErrorCode)o.Code == ErrorCode.ERR_NameNotInContext);
					if (d == null) continue;
					ec = ErrorCode.ERR_NameNotInContext;
				}
				
				if (!has) doc.EInicatorsDiag_(has = true);
				var indic = d.Severity switch { DiagnosticSeverity.Error => SciTheme.Indic.Error, DiagnosticSeverity.Warning => SciTheme.Indic.Warning, DiagnosticSeverity.Info => SciTheme.Indic.Info, _ => SciTheme.Indic.DiagHidden };
				doc.aaaIndicatorAdd(indic, true, start..end);
				_codeDiag.Add(new(d, start, end));
				
				if (d.Severity == DiagnosticSeverity.Error) {
					switch (ec) {
					case ErrorCode.ERR_NameNotInContext
					or ErrorCode.ERR_SingleTypeNameNotFound
					or ErrorCode.ERR_NoSuchMemberOrExtension
					or ErrorCode.ERR_NoSuchMemberOrExtensionNeedUsing
					or ErrorCode.ERR_UnimplementedInterfaceMember
					or ErrorCode.ERR_UnimplementedAbstractMethod
					or ErrorCode.ERR_BadBinaryOps:
						_semo = semo;
						break;
					}
				}
			}
		}
		if (_metaErrors.Count > 0) {
			int offs = 0; //!=0 if modified text before metacomments
			if (cd.meta.end - cd.meta.start == _metaRange.end - _metaRange.start) offs = cd.meta.start - _metaRange.start;
			
			foreach (var v in _metaErrors) {
				int from = v.start + offs, to = v.end + offs;
				if (to <= start16 || from >= end16) continue;
				if (!has) doc.EInicatorsDiag_(has = true);
				doc.aaaIndicatorAdd(SciTheme.Indic.Error, true, from..to);
			}
		}
		_Strings(semo, cd, start16, end16);
		if (_stringErrors.Count > 0) {
			if (!has) doc.EInicatorsDiag_(has = true);
			foreach (var v in _stringErrors) {
				doc.aaaIndicatorAdd(SciTheme.Indic.Warning, true, v.start..v.end);
			}
		}
		if (!has) {
			doc.EInicatorsDiag_(false);
			_codeDiag = null;
		} else if (pasting && _semo != null) {
			//insert missing using directives
			List<_MissingUsingError> aMissingUsing = null;
			foreach (var v in _codeDiag) {
				if (_MissingUsingError.IsMissingUsingError(v.Code, out bool extMethod)) {
					var mu = new _MissingUsingError(code, v.start, v.end, extMethod, _semo);
					_MissingUsingError.AddToList(ref aMissingUsing, mu);
				}
			}
			//var e1 = _codeDiag.Where(o => o.d.Severity == DiagnosticSeverity.Error); print.it(e1.Count(), e1);
			//print.it(amu.Lenn_(), amu);
			
			List<string> usings = _GetMissingUsings(aMissingUsing);
			if (usings != null) {
				//uncheck some usings that are rarely used and cause errors
				bool uncheckForms = usings.Count > 1 && usings.Any(o => o is "System.Windows" or "System.Windows.Controls" or "System.Windows.Controls.Primitives" or "System.Windows.Input");
				bool uncheckDrawing = usings.Count > 1 && usings.Contains("System.Windows.Media");
				if (pastingSilent && uncheckForms) usings.Remove("System.Windows.Forms");
				if (pastingSilent && uncheckDrawing) usings.Remove("System.Drawing");
				
				if (!pastingSilent) {
					var d = new CheckListDialog("Add missing using directives?");
					foreach (var u in usings) {
						bool check = true;
						if (uncheckForms && u is "System.Windows.Forms") check = false;
						if (uncheckDrawing && u is "System.Drawing") check = false;
						d.Add(u, check);
					}
					if (!d.ShowDialog(doc) || !d.ResultItems.Any()) return;
					usings = d.ResultItems.ToList();
				}
				if (usings.Count > 0) InsertCode.UsingDirective(string.Join(';', usings), true);
				if (!pastingSilent && usings.Count > 1) print.it("Info: multiple using directives have been added. If it causes 'ambiguous reference' errors, remove one of usings displayed in the error tooltip. If that does not work, undo and remove other using.");
			}
		}
	}
	
	void _Strings(SemanticModel semo, CodeInfo.Context cd, int start16, int end16) {
		_stringErrors.Clear();
		var code = cd.code;
		ArgumentListSyntax keysArgs = null;
		foreach (var node in semo.Root.DescendantNodes(TextSpan.FromBounds(start16, end16))) {
			var format = CiUtil.GetParameterStringFormat(node, semo, false, ignoreInterpolatedString: true);
			if (format is PSFormat.None or PSFormat.RegexpReplacement) continue;
			var tok1 = node.GetFirstToken();
			var s = tok1.ValueText; //replaced escape sequences
			if (s.Length == 0) continue;
			string es = null;
			try {
				switch (format) {
				case PSFormat.NetRegex:
					new System.Text.RegularExpressions.Regex(s); //never mind: may have 'options' argument, eg ECMAScript or Compiled
					break;
				case PSFormat.Regexp:
					new regexp(s);
					break;
				case PSFormat.Wildex:
					if (s.Starts("***")) s = s[(s.IndexOf(' ') + 1)..]; //eg wnd.Child("***elmName ...")
					if (s.Starts("**")) new wildex(s);
					break;
				case PSFormat.Keys:
					if (s[0] is '!' or '%') break;
					
					//if keys.send("arg1", "arg2"), use single keys instance to validate all args.
					//	Else possible false positives such as if second arg is ")".
					var args = node.GetAncestor<ArgumentListSyntax>();
					if (args == null || args == keysArgs) break;
					keysArgs = args;
					
					var k = new keys(null);
					foreach (var nk in args.DescendantNodes()) {
						if (nk is ArgumentSyntax) continue;
						if (nk is LiteralExpressionSyntax les && nk.Kind() == SyntaxKind.CharacterLiteralExpression) {
							if (les.Token.Value is char c1) k.AddChar(c1);
						} else {
							if (CiUtil.GetParameterStringFormat(nk, semo, false) != PSFormat.Keys) continue;
							s = nk.GetFirstToken().ValueText;
							if (s.Length == 0 || s[0] is '!' or '%') continue; //never mind: can be "keys"+"!keys"
							try { k.AddKeys(s); }
							catch (ArgumentException ex) {
								var e = ex.Message;
								//print.it(e); CiUtil.PrintNode(nk); CiUtil.PrintNode(nk.Parent);
								//detect some common valid cases like "keys*"+x or $"keys*{x}"
								if (((s.Ends('*') || s.Starts('*')) && e.Contains("<<<*")) || (s.Ends('_') && e.Contains("<<<_>>>"))) {
									if (nk.Parent is not ArgumentSyntax) continue; //eg like "Tab*"+5 or $"Tab*{5}"
								}
								_AddError(nk, e);
							}
						}
					}
					break;
				case PSFormat.Hotkey:
					if (!keys.more.parseHotkeyString(s, out _, out _))
						_AddError(node, "Invalid hotkey string.");
					break;
				case PSFormat.HotkeyTrigger:
					if (!keys.more.parseTriggerString(s, out _, out _, out _, false))
						_AddError(node, "Invalid hotkey string.");
					break;
				case PSFormat.TriggerMod:
					if (!keys.more.parseTriggerString(s, out _, out _, out _, true))
						_AddError(node, "Invalid modifiers string.");
					break;
				case PSFormat.CodeFile or PSFormat.FileInWorkspace:
					if (null == App.Model.Find(s, format == PSFormat.CodeFile ? FNFind.CodeFile : FNFind.Any, silent: true)) {
						var ae = App.Model.FoundMultiple;
						if (ae != null) {
							var paths = string.Join('\n', ae.Select(o => o.ItemPath));
							_AddError(node, "Multiple found. Use path, or rename some.\nPaths:\n" + paths);
							//never mind: should add links.
						} else _AddError(node, "Not found.");
					}
					break;
				}
			}
			catch (ArgumentException ex) { es = ex.Message; }
			if (es != null) _AddError(node, es);
			
			void _AddError(SyntaxNode node, string es) {
				var span = node.Span;
				_stringErrors.Add(new(span.Start, span.End, es));
			}
		}
	}
	
	public void ClearMetaErrors() => _metaErrors.Clear();
	
	public void AddMetaError(StartEnd metaRange, int from, int to, string s) {
		_metaRange = metaRange;
		_metaErrors.Add(new(from, to > from ? to : from + 1, s));
	}
	
	public void EraseIndicatorsInLine(SciCode doc, int pos8) {
		var (_, start, end) = doc.aaaLineStartEndFromPos(false, pos8, withRN: true);
		doc.aaaIndicatorClear(SciTheme.Indic.DiagHidden, false, start..end);
		doc.aaaIndicatorClear(SciTheme.Indic.Info, false, start..end);
		doc.aaaIndicatorClear(SciTheme.Indic.Warning, false, start..end);
		doc.aaaIndicatorClear(SciTheme.Indic.Error, false, start..end);
	}
	
	public void SciModified(SciCode doc, in Sci.SCNotification n) {
		//clear arrays to prevent showing tooltip because positions changed. But don't clear indicators because we'll update them soon.
		_codeDiag = null;
		_stringErrors.Clear();
		
		if (_pasting.doc != null && n.modificationType.Has(Sci.MOD.SC_MOD_INSERTTEXT | Sci.MOD.SC_PERFORMED_USER)) {
			var p = _pasting; _pasting = default;
			if (doc == p.doc && n.length > 3) {
				int start = doc.aaaPos16(n.position), end = doc.aaaPos16(n.position + n.length);
				string text = doc.aaaText;
				doc.Dispatcher.InvokeAsync(() => { //may need to modify code (can't do it in a scintilla modified notification)
					if (Panels.Editor.ActiveDoc != doc || doc.aaaText != text) return;
					try {
						Indicators(start, end, pasting: true, pastingSilent: p.silent);
					}
					catch (Exception ex) { Debug_.Print(ex); }
				});
			}
		}
	}
	(SciCode doc, bool silent) _pasting;
	
	public void Pasting(SciCode doc, bool silent) { _pasting = (doc, silent); }
	
	public System.Windows.Documents.Section GetPopupTextAt(SciCode doc, int pos8, int pos16, out Action<CiPopupText, string> onLinkClick) {
		onLinkClick = null;
		if (_codeDiag == null && _metaErrors.Count == 0 && _stringErrors.Count == 0) return null;
		if (pos8 < 0) return null;
		int all = doc.Call(Sci.SCI_INDICATORALLONFOR, pos8);
		//print.it(all);
		if (0 == (all & ((1 << SciTheme.Indic.Error) | (1 << SciTheme.Indic.Warning) | (1 << SciTheme.Indic.Info) | (1 << SciTheme.Indic.DiagHidden)))) return null;
		
		var x = new CiText();
		x.StartParagraph();
		
		ErrorCode ecPrev = 0;
		int implPos = -1;
		for (int i = 0, n = _codeDiag?.Count ?? 0; i < n; i++) {
			var v = _codeDiag[i];
			if (pos16 < v.start || pos16 > v.end) continue;
			var d = v.d;
			var s1 = d.Severity switch { DiagnosticSeverity.Error => "Error", DiagnosticSeverity.Warning => "Warning", _ => "Info" };
			x.LineBreak(s1, notIfFirstInParagraph: true);
			x.Append(": " + d.GetMessage());
			
			var ec = (ErrorCode)d.Code;
			if (d.Severity == DiagnosticSeverity.Error) {
				//print.it(ec, d.Id);
				if (_semo == null) continue;
				if (_MissingUsingError.IsMissingUsingError(ec, out bool extMethod) || ec == ErrorCode.ERR_DottedTypeNameNotFoundInNS /*Namespace.NotFound*/) {
					if (ec == ecPrev && !extMethod) continue; //probably "not found 'AbcAttribute'" followed by "not found 'Abc'"
					ecPrev = ec;
					_UsingsEtc(x, v, doc, extMethod);
				} else {
					switch (ec) {
					case ErrorCode.ERR_UnimplementedInterfaceMember or ErrorCode.ERR_UnimplementedAbstractMethod:
						Debug.Assert(implPos == -1 || implPos == v.start);
						implPos = v.start;
						break;
					case ErrorCode.ERR_BadBinaryOps:
						//New users may not know how to use multiple flags, and intuitively try operator +. Let's add more info.
						if (d.GetMessage().RxIsMatch(@"^Operator '\+' cannot be applied to operands of type '(\w+)' and '\1'$")) {
							var n1 = _semo.Root.FindToken(v.start).Parent;
							if (_semo.GetTypeInfo(n1).Type?.IsEnumType() ?? false) {
								x.Append(". Use operator '|'.");
							}
						}
						break;
					}
				}
			} else if (d.Severity == DiagnosticSeverity.Warning) {
				x.Append("\nCopy: ");
				x.Hyperlink($"^wi {d.Id}", d.Id, ", ");
				x.Hyperlink($"^wp {d.Id} {d.Descriptor.Title}", $"#pragma warning disable");
				switch (ec) {
				case ErrorCode.WRN_MissingXMLComment:
					x.Append("\nTo add XML comment, type /// above.");
					break;
				}
			}
		}
		if (implPos >= 0) x.Hyperlink("^ii" + implPos, "\nImplement");
		
		_Also(_metaErrors, "Error: ");
		_Also(_stringErrors, null);
		void _Also(List<StartEndText> a, string prefix) {
			foreach (var v in a) {
				if (pos16 < v.start || pos16 > v.end) continue;
				x.LineBreak(prefix, notIfFirstInParagraph: true);
				if (v.text.Starts("<>") && v.text.RxFindAll(@"(<\+?\w+ .+?)>(.+?)<>", out var am)) {
					int i = 2;
					foreach (var m in am) {
						if (m.Start > i) x.Append(v.text[i..m.Start]);
						x.Hyperlink("^" + m[1].Value, m[2].Value);
						i = m.End;
					}
					if (i < v.text.Length) x.Append(v.text[i..v.text.Length]);
				} else {
					x.Append(v.text);
				}
			}
		}
		
		x.EndParagraph();
		onLinkClick = (ph, e) => _LinkClicked(e);
		return x.Result;
	}
	
	record _MissingUsingError {
		public static bool IsMissingUsingError(ErrorCode ec, out bool extMethod) {
			extMethod = false;
			return ec switch {
				ErrorCode.ERR_NoSuchMemberOrExtension or ErrorCode.ERR_NoSuchMemberOrExtensionNeedUsing => extMethod = true, //these end with (are you missing a using directive...
				ErrorCode.ERR_NameNotInContext or ErrorCode.ERR_SingleTypeNameNotFound => true,
				_ => false,
			};
			//not tested: ERR_GlobalSingleTypeNameNotFound, ERR_DottedTypeNameNotFoundInAgg, ERR_AliasNotFound, ERR_TypeNotFound
		}
		
		public static void AddToList(ref List<_MissingUsingError> a, _MissingUsingError mu) {
			if (mu.isEM && mu.emReceiverType == null) return; //unlikely
			a ??= new();
			foreach (var v in a) if (v.name == mu.name && v.emReceiverType == mu.emReceiverType && v.isGeneric == mu.isGeneric && v.isAttribute == mu.isAttribute) return;
			a.Add(mu);
		}
		
		public _MissingUsingError(string code, int start, int end, bool extMethod, SemanticModel semo) {
			int end2 = code.IndexOf('<', start, end - start);
			if (end2 < 0) end2 = end; else isGeneric = true;
			name = code[start..end2];
			isAttribute = !extMethod && _IsAttributeNameWithoutSuffix(name, start, semo);
			if (isEM = extMethod) emReceiverType = _GetExtensionMethodReceiverType(semo, start);
			Debug_.PrintIf(extMethod && emReceiverType == null, "failed to get extension method receiver type"); //unlikely
		}
		
		public readonly string name;
		public readonly bool isEM, isGeneric, isAttribute;
		public readonly ITypeSymbol emReceiverType;
	}
	
	List<string> _GetMissingUsings(List<_MissingUsingError> a) {
		if (a.NE_()) return null;
		List<string> usings = null;
		var compilation = _semo.Compilation;
		var stack = new List<string>();
		int need = 0; foreach (var v in a) if (v.isEM) need |= 2; else need |= 1;
		//var p1 = perf.local();
		//var p1 = new perf.Instance { Incremental = true };
		_EnumNamespace(compilation.GlobalNamespace);
		//p1.Write();
		//p1.NW();
		
		//CONSIDER: async, because slow. Or use AssemblyMetadata.CachedSymbols (internal), it's faster except first time.
		void _EnumNamespace(INamespaceSymbol ns) {
			bool found = false;
			foreach (var nt in ns.GetMembers()) {
				string sn = nt.Name;
				//print.it("<>" + new string(' ', stack.Count) + (nt is INamespaceSymbol ? "<c blue>" + nt.ToString() + "<>" : nt.ToString())/*, nt.ContainingAssembly?.Name*/);
				if (sn.NE() || sn[0] == '<') continue;
				if (nt is INamespaceSymbol ins) {
					stack.Add(sn);
					_EnumNamespace(ins);
					stack.RemoveAt(stack.Count - 1);
				} else if (!found) { //else continue to search in nested namespaces
					var its = nt as INamedTypeSymbol;
					if (0 != (need & 1)) {
						foreach (var v in a) {
							if (v.isEM) continue;
							if (sn != v.name) {
								if (!(v.isAttribute && sn.Length == v.name.Length + 9 && sn.Starts(v.name) && sn.Ends("Attribute"))) continue;
							}
							if (v.isGeneric && !its.IsGenericType) continue;
							if (_AddNamespace(nt)) goto gNext;
						}
					}
					if (0 != (need & 2)) {
						//p1.First();
						if (its.IsStatic && its.MightContainExtensionMethods) { //fast, but without IsStatic slow first time
							foreach (var m in nt.GetMembers().OfType<IMethodSymbol>()) { //fast; slightly slower than nt.MemberNames.Contains(errName) which gets member types etc too
								foreach (var v in a) {
									if (!v.isEM) continue;
									if (m.Name == v.name && m.IsExtensionMethod) {
										if (null == m.ReduceExtensionMethod(v.emReceiverType)) { /*Debug_.Print(emReceiverType);*/ continue; }
										if (_AddNamespace(m)) goto gNext;
									}
								}
							}
						}
						//p1.Next();
					}
					gNext:;
					
					bool _AddNamespace(ISymbol sym) {
						if (!sym.IsAccessibleWithin(compilation.Assembly)) return false;
						(usings ??= new()).Add(string.Join('.', stack));
						return found = true;
					}
				}
			}
		}
		return usings;
	}
	
	void _UsingsEtc(CiText x, in _Diagnostic v, SciCode doc, bool extMethod) {
		var d = v.d;
		var ec = (ErrorCode)d.Code;
		var mu = new _MissingUsingError(doc.aaaText, v.start, v.end, extMethod, _semo);
		List<_MissingUsingError> amu = null;
		_MissingUsingError.AddToList(ref amu, mu);
		List<string> usings = _GetMissingUsings(amu);
		if (usings != null) {
			var sstart = doc.aaaPos8(v.start).ToString();
			x.Append("\nAdd using ");
			for (int i = 0; i < usings.Count; i++) {
				var u = usings[i];
				if (i > 0) x.Append(" or ");
				x.Hyperlink("^u" + sstart + u, u);
			}
			if (!extMethod) {
				x.Append("\nOr prefix ");
				for (int i = 0; i < usings.Count; i++) {
					var u = usings[i];
					if (i > 0) x.Append(" or ");
					x.Hyperlink("^p" + sstart + u, u);
				}
			}
		} else {
			x.Hyperlink("^r", "\nAdd assembly reference or class file...");
			x.Hyperlink("^n", "\nAdd NuGet package...");
			if (!(mu.isEM | mu.isGeneric | mu.isAttribute || ec == ErrorCode.ERR_DottedTypeNameNotFoundInNS || _semo.GetEnclosingSymbol(v.start) is null or INamespaceSymbol))
				x.Hyperlink("^A" + mu.name, "\nFind Windows API...");
		}
	}
	
	void _LinkClicked(string s) {
		CodeInfo.HideTextPopup();
		char action = s[1];
		if (action is 'u' or 'p') { //add 'using', prefix namespace
			int pos8 = s.ToInt(2, out int i);
			s = s[i..];
			var doc = Panels.Editor.ActiveDoc;
			EraseIndicatorsInLine(doc, pos8);
			if (action == 'p') {
				doc.aaaInsertText(false, pos8, s + ".", addUndoPointAfter: true);
			} else {
				InsertCode.UsingDirective(s, true);
			}
		} else if (action == 'A') { //Windows API
			new DWinapi(s[2..]).Show();
		} else if (action == 'r') { //Add reference
			Menus.File.Properties();
		} else if (action == 'n') { //Add NuGet package
			DNuget.ShowSingle();
		} else if (action == 'i') { //implement interface or abstract class
			GenerateCode.ImplementInterfaceOrAbstractClass(s.ToInt(3));
		} else if (action == '<') { //output tag
			int i = s.IndexOf(' ');
			Panels.Output.Scintilla.AaTags.OnLinkClick(s[2..i], s[++i..]);
		} else if (action == 'w') { //copy warning
			if (s[2] == 'i') s = s[4..]; else if (s.Split(' ', 3) is var a) s = $"#pragma warning disable {a[1]} //{a[2]}\r\n#pragma warning restore {a[1]} //{a[2]}\r\n";
			clipboard.text = s;
		}
	}
	
	static bool _IsAttributeNameWithoutSuffix(string name, int pos, SemanticModel semo) {
		if (name.Ends("Attribute")) return false;
		return semo.SyntaxTree.IsAttributeNameContext(pos, default);
	}
	
	static ITypeSymbol _GetExtensionMethodReceiverType(SemanticModel semo, int startOfMethodName) {
		ITypeSymbol t = null;
		if (semo.SyntaxTree.GetRoot().FindToken(startOfMethodName).Parent.Parent is MemberAccessExpressionSyntax ma)
			t = semo.GetTypeInfo(ma.Expression).Type;
		Debug_.PrintIf(t == null, "failed to get extension method receiver type");
		return t;
	}
	
	bool _PastedWithUsings(CodeInfo.Context cd, ImmutableArray<Diagnostic> aDiag, ref int start16, ref int end16) {
		int firstStart = int.MaxValue, lastEnd = 0;
		foreach (var d in aDiag) {
			if ((ErrorCode)d.Code != ErrorCode.ERR_UsingAfterElements) continue;
			firstStart = Math.Min(firstStart, d.Location.SourceSpan.Start);
			lastEnd = Math.Max(lastEnd, d.Location.SourceSpan.End);
		}
		if (firstStart < lastEnd) {
			if (cd.syntaxRoot.FindTokenOnLeftOfPosition(lastEnd) is { RawKind: (int)SyntaxKind.SemicolonToken } t1) lastEnd = t1.FullSpan.End;
			int i = InsertCode.FindUsingsInsertPos(cd);
			if (i >= 0 && i <= firstStart) {
				var sUsings = cd.code[firstStart..lastEnd];
				if (!sUsings.Ends('\n')) sUsings += "\r\n";
				
				//don't add duplicate usings
				var text2 = cd.code.Remove(firstStart..lastEnd).Insert(i, sUsings);
				var document2 = cd.document.WithText(SourceText.From(text2));
				var semo = document2.GetSemanticModelAsync().Result_();
				if (semo.GetDiagnostics(new(i, sUsings.Length)) is { IsDefaultOrEmpty: false } ad2) {
					StringBuilder b = null; int appended = i;
					foreach (var d in ad2) {
						if ((ErrorCode)d.Code is ErrorCode.WRN_DuplicateUsing or ErrorCode.HDN_DuplicateWithGlobalUsing) {
							b ??= new();
							int start = d.Location.SourceSpan.Start, end = d.Location.SourceSpan.End;
							if (semo.SyntaxTree.GetRoot().FindToken(start).Parent.GetAncestorOrThis<UsingDirectiveSyntax>() is { } nUsing) {
								start = nUsing.SpanStart;
								end = nUsing.FullSpan.End;
								b.Append(text2, appended, start - appended);
								appended = end;
							}
						}
					}
					if (b != null) {
						b.Append(text2, appended, i + sUsings.Length - appended);
						sUsings = b.ToString();
					}
				}
				
				var doc = cd.sci;
				using var undo = doc.ENewUndoAction();
				doc.aaaDeleteRange(true, firstStart, lastEnd);
				doc.aaaInsertText(true, i, sUsings);
				
				start16 = firstStart + sUsings.Length;
				end16 += firstStart - lastEnd+ sUsings.Length;
				
				return true;
			}
		}
		return false;
	}
}


================================================
FILE: Au.Editor/Edit/CiFind.cs
================================================
extern alias CAW;

using System.Collections.Immutable;
using System.Windows;
using System.Windows.Controls;

using Microsoft.CodeAnalysis;
using CAW::Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Text;
using Microsoft.CodeAnalysis.CSharp.Extensions;
using Microsoft.CodeAnalysis.Shared.Extensions;
using CAW::Microsoft.CodeAnalysis.Shared.Extensions;
using CAW::Microsoft.CodeAnalysis.FindSymbols;
using CAW::Microsoft.CodeAnalysis.Rename;
using CAW::Microsoft.CodeAnalysis.Rename.ConflictEngine;

using Au.Controls;
using static Au.Controls.Sci;

namespace LA;

static class CiFind {
	const int c_markerSymbol = 0, c_markerInfo = 1, c_markerSeparator = 2, c_indicProject = 15;
	const int c_markerRenameComment = 3, c_markerRenameDisabled = 4, c_markerRenameString = 5, c_markerRenameError = 6;
	const int c_marginUsage = 1;
	const int c_marginStyleBlack = 50, c_marginStyleWrite = 51, c_marginStyleRead = 52;
	static bool _working;
	
	public static async void FindReferencesOrImplementations(bool implementations) {
		if (_working) return;
		_working = true;
		try {
			var (sym, cd) = CiUtil.GetSymbolFromPos();
			if (sym == null) {
				Panels.Found.ClearResults(PanelFound.Found.SymbolReferences);
				return;
			}
			
			using var workingState = Panels.Found.Prepare(PanelFound.Found.SymbolReferences, sym.JustName(), out var b);
			var k = workingState.Scintilla;
			if (workingState.NeedToInitControl) {
				k.aaaMarkerDefine(c_markerSymbol, SC_MARK_BACKGROUND, backColor: 0xC0C0FF);
				k.aaaMarkerDefine(c_markerInfo, SC_MARK_BACKGROUND, backColor: 0xEEE8AA);
				k.aaaMarkerDefine(c_markerSeparator, SC_MARK_UNDERLINE, backColor: 0xe0e0e0);
				k.aaaIndicatorDefine(c_indicProject, INDIC_GRADIENT, 0xC0C0C0, alpha: 255, underText: true);
				k.aaaMarginSetType(c_marginUsage, SC_MARGIN_TEXT);
				k.aaaStyleBackColor(c_marginStyleBlack, 0xE0E0E0);
				k.aaaStyleForeColor(c_marginStyleBlack, 0);
				k.aaaStyleBackColor(c_marginStyleWrite, 0xE0E0E0);
				k.aaaStyleForeColor(c_marginStyleWrite, 0x0000ff);
				k.aaaStyleBackColor(c_marginStyleRead, 0xE0E0E0);
				k.aaaStyleForeColor(c_marginStyleRead, 0x008000);
			}
			k.aaaMarginSetWidth(c_marginUsage, 0, implementations ? 0 : 7);
			
			//perf.first();
			TestInternal.RefsStart();
			var (solution, info) = await CiProjects.GetSolutionForFindReferences(sym, cd);
			
			//perf.next('s');
			bool multiProj = solution.ProjectIds.Count > 1;
			_LocationComparer locComp = new();
			var symComp = new _SymbolComparer(locComp);
			List<(int pos, byte kind, ushort usage)> aUsage = new(); //kind: 1 TypeOrNamespaceUsageInfo, 2 ValueUsageInfo
			if (implementations) {
				if (sym is INamedTypeSymbol nts) {
					if (nts.TypeKind == TypeKind.Interface) {
						_AppendSymbols("Implementations", await SymbolFinder.FindImplementationsAsync(nts, solution));
						_AppendSymbols("Derived interfaces", await SymbolFinder.FindDerivedInterfacesAsync(nts, solution));
					} else {
						_AppendSymbols("Derived classes", await SymbolFinder.FindDerivedClassesAsync(nts, solution));
					}
				} else if (sym.ContainingType is INamedTypeSymbol nts2) {
					if (nts2.TypeKind == TypeKind.Interface) {
						_AppendSymbols("Implementations", await SymbolFinder.FindImplementationsAsync(sym, solution));
					} else {
						_AppendSymbols("Overrides", await SymbolFinder.FindOverridesAsync(sym, solution));
					}
				}
				if (b.Length == 0) return;
				//never mind: Roslyn gives 1 result when implemented in 2 projects and same type name and assembly name.
				//	Same in VS.
				//	We could generate unique assembly names, but it breaks [InternalsVisibleTo] and testInternal.
				//	Too difficult to modify Roslyn code.
				
				void _AppendSymbols(string header, IEnumerable<ISymbol> e) {
					e = e.Where(o => o.IsInSource());
					if (e.Any()) {
						//join duplicates added through meta c
						var implSymbols = e.GroupBy(o => o, (k, e) => (sym: k, locs: e.SelectMany(o => o.Locations).Distinct(locComp)), symComp)
							.OrderBy(o => o.sym.Name);
						
						_Fold(true).Marker(c_markerSymbol).Text(header).NL();
						foreach (var v in implSymbols) _AppendSymbol(v.sym, false, v.locs);
						_Fold(false);
					}
				}
			} else {
				HashSet<_Seen> seen = new();
				var options = FindReferencesSearchOptions.GetFeatureOptionsForStartingSymbol(sym);
				var rr = await SymbolFinder.FindReferencesAsync(sym, solution, options, default);
				//perf.next('f');
				
				//sort. Join duplicate definitions of logically same symbol added through meta c or in a case of partial method.
				var refSymbols = rr.Where(o => o.ShouldShow(options))
					.GroupBy(o => o.Definition, (defSym, e) => (defSym, defLocs: e.SelectMany(k => k.Definition.Locations), refs: e.SelectMany(k => k.Locations)), symComp)
					.OrderByDescending(o => o.defSym.Kind)
					.ThenBy(o => o.defSym.ContainingAssembly?.Name != cd.document.Project.AssemblyName) //let current project be the first
					.ThenBy(o => o.defSym.ContainingAssembly?.Name);
				
				bool allInThisDoc = refSymbols.All(o => o.refs.All(oo => oo.Document == cd.document));
				if (allInThisDoc) multiProj = false;
				
				foreach (var (defSym, defLocs, refs) in refSymbols) {
					if (refs.Any()) {
						//definition
						
						_Fold(true).Marker(c_markerSymbol);
						//usage
						string defInit = null;
						if (defSym is ILocalSymbol or IParameterSymbol or IFieldSymbol or IPropertySymbol
							&& defSym.IsFromSource()
							&& defSym.Locations[0].FindNode(default) is SyntaxNode n1) {
							EqualsValueClauseSyntax evc = n1 switch { VariableDeclaratorSyntax g => g.Initializer, PropertyDeclarationSyntax g => g.Initializer, ParameterSyntax g => g.Default, _ => null };
							if (evc != null) {
								aUsage.Add((b.Length, 2, (ushort)ValueUsageInfo.Write));
								defInit = evc.ToString();
							}
						}
						
						_AppendSymbol(defSym, true, defLocs.Distinct(locComp), defInit);
						bool isCtor = defSym is IMethodSymbol ms && ms.IsConstructor();
						
						//references
						
						if (multiProj) _Fold(true);
						ProjectId prevProjId = null;
						FileNode prevFile = null;
						var refs2 = refs
							.OrderBy(o => o.Document.Project.Id != cd.document.Project.Id) //let current project be the first
							.ThenBy(o => o.Document.Project.Name)
							.ThenBy(o => o.Document.Name);
						foreach (var rloc in refs2) {
							var f = CiProjects.FileOf(rloc.Document);
							var span = rloc.Location.SourceSpan;
							if (!seen.Add(new(f, span.Start))) continue; //remove logical duplicates added because of meta c
							if (!rloc.Document.TryGetText(out var st)) { Debug_.Print(f); continue; }
							var text = st.ToString();
							
							if (f != prevFile) {
								if (prevFile != null) b.Marker(c_markerSeparator, prevLine: true);
								prevFile = f;
							}
							
							if (multiProj && rloc.Document.Project.Id != prevProjId) {
								prevProjId = rloc.Document.Project.Id;
								_Fold(false);
								_Fold(true);
								b.Indic(c_indicProject).Text("Project ").B(rloc.Document.Project.Name).Indic_().NL();
							}
							
							//usage
							var sui = rloc.SymbolUsageInfo;
							if (sui.TypeOrNamespaceUsageInfoOpt != null) {
								aUsage.Add((b.Length, 1, (ushort)sui.TypeOrNamespaceUsageInfoOpt.Value));
							} else if (sui.ValueUsageInfoOpt != null) {
								if (isCtor && sui.ValueUsageInfoOpt == ValueUsageInfo.Read) //for 'new()' of a ctor Roslyn gives ValueUsageInfo.Read
									aUsage.Add((b.Length, 1, (ushort)TypeOrNamespaceUsageInfo.ObjectCreation));
								else if (!(defSym is IMethodSymbol && sui.ValueUsageInfoOpt is ValueUsageInfo.Read)) //'read' for methods makes no sense
									aUsage.Add((b.Length, 2, (ushort)sui.ValueUsageInfoOpt.Value));
							}
							
							PanelFound.AppendFoundLine(b, f, text, span.Start, span.End, workingState, displayFile: !allInThisDoc, indicHilite: PanelFound.Indicators.HiliteG);
						}
						if (multiProj) _Fold(false);
						
						_Fold(false);
					}
				}
			}
			//perf.next();
			
			if (!info.NE()) b.Marker(c_markerInfo).Text(info).NL();
			
			void _AppendSymbol(ISymbol sym, bool refDef = false, IEnumerable<Location> locations = null, string defInit = null) {
				var sDef = sym is INamespaceSymbol
					? sym.ToString() /* with ancestor namespaces */
					: sym.ToDisplayString(SymbolDisplayFormat.CSharpShortErrorMessageFormat); /* no namespaces, no param names, no return type */
				bool isInSource = false;
				var symName = sym.JustName();
				var e = (locations ?? sym.Locations)
					.Where(o => o.IsInSource)
					.Select(o => (f: CiProjects.FileOf(o.SourceTree, solution), ts: o.SourceSpan))
					.OrderBy(o => StringUtil.LevenshteinDistance(o.f.DisplayName, symName));
				foreach (var (f, ts) in e) {
					if (isInSource) b.Text("   ");
					b.Link2(new PanelFound.CodeLink(f, ts.Start));
					if (!isInSource) {
						if (refDef) b.B(sDef); else b.Text(sDef);
						if (defInit != null) b.Text(" ").Text(defInit.Limit(50).ReplaceLineEndings(" "));
						b.Text("      ");
					}
					b.Gray(f.Name);
					b.Link_();
					isInSource = true;
					//if (!refDef && multiProj) b.Text($" ({solution.GetDocument(loc.SourceTree)?.Project.Name})"); //bad if many partials
				}
				if (!isInSource) { if (refDef) b.B(sDef); else b.Text(sDef); }
				b.NL();
			}
			
			SciTextBuilder _Fold(bool start) => b.Fold(new(b.Length - (start ? 0 : 2), start));
			
			Panels.Found.SetResults(workingState, b);
			
			//margin text
			foreach (var v in aUsage) {
				string s = null;
				int style = c_marginStyleBlack;
				if (v.kind == 1) {
					var u = (TypeOrNamespaceUsageInfo)v.usage;
					s = u switch {
						TypeOrNamespaceUsageInfo.Base => "base",
						TypeOrNamespaceUsageInfo.Import => "using",
						//TypeOrNamespaceUsageInfo.NamespaceDeclaration => "ns",
						TypeOrNamespaceUsageInfo.ObjectCreation => "new",
						//TypeOrNamespaceUsageInfo.Qualified => "A.B", //weird and distracting
						TypeOrNamespaceUsageInfo.Qualified => ".",
						TypeOrNamespaceUsageInfo.TypeArgument => "<T>",
						TypeOrNamespaceUsageInfo.TypeConstraint => "where",
						_ => null
					};
				} else {
					var u = (ValueUsageInfo)v.usage;
					s = u switch {
						ValueUsageInfo.Name => "name",
						ValueUsageInfo.Read or ValueUsageInfo.ReadableReference => "read",
						ValueUsageInfo.ReadableWritableReference => "ref",
						ValueUsageInfo.ReadWrite => "r w",
						ValueUsageInfo.WritableReference => "out",
						ValueUsageInfo.Write => "write",
						_ => null
					};
					if (u.Has(ValueUsageInfo.Write)) style = c_marginStyleWrite; else if (u.Has(ValueUsageInfo.Read)) style = c_marginStyleRead;
				}
				int line = k.aaaLineFromPos(true, v.pos);
				k.Call(SCI_MARGINSETSTYLE, line, style);
				if (s != null) k.aaaSetString(SCI_MARGINSETTEXT, line, s);
			}
			
			timer.after(1, _ => GC.Collect());
			//perf.nw();
		}
		finally {
			_working = false;
			TestInternal.RefsEnd();
		}
	}
	
	record struct _Seen(object file, int pos);
	
	class _LocationComparer : IEqualityComparer<Location> {
		public bool Equals(Location x, Location y)
			=> x.IsInSource && y.IsInSource && x.SourceSpan == y.SourceSpan && x.SourceTree.FilePath == y.SourceTree.FilePath;
		
		public int GetHashCode(Location x)
			=> x.Kind == LocationKind.SourceFile ? x.SourceSpan.Start : x.GetHashCode();
	}
	
	class _SymbolComparer : IEqualityComparer<ISymbol> {
		_LocationComparer _locComp;
		
		public _SymbolComparer(_LocationComparer locComp) { _locComp = locComp; }
		
		//public bool Equals(ISymbol x, ISymbol y) => x.Locations.Intersect(y.Locations, _locComp).Any();
		public bool Equals(ISymbol x, ISymbol y) { //faster, no garbage
			foreach (var xl in x.Locations)
				foreach (var yl in y.Locations)
					if (_locComp.Equals(xl, yl)) return true;
			return false;
		}
		
		public int GetHashCode(ISymbol x) => x.Name.GetHashCode();
	}
	
	public static void SciUpdateUI(SciCode doc, bool modified) {
		if (modified || 0 == doc.aaaIndicatorGetValue(SciTheme.Indic.Refs, doc.aaaCurrentPos8) || doc.aaaHasSelection)
			doc.aaaIndicatorClear(SciTheme.Indic.Refs);
		doc.aaaIndicatorClear(SciTheme.Indic.Braces);
		_cancelTS?.Cancel();
		_cancelTS = null;
		_doc = doc;
		//_timer1.After(modified ? 1000 : 200);
		if (!modified) _timer1.After(200);
	}
	
	static readonly timer _timer1 = new(_SciUpdateUI);
	static CancellationTokenSource _cancelTS;
	static SciCode _doc;
	
	static async void _SciUpdateUI(timer _1) {
		if (!CodeInfo.GetContextAndDocument(out var cd) || cd.sci != _doc) return;
		if (cd.sci.aaaHasSelection) return;
		
		//hilite symbol references
		if (CiUtil.GetSymbolFromPos(cd) is ISymbol sym) {
			if (sym is IAliasSymbol a1 && a1.Target is INamespaceSymbol ns1 && ns1.ContainingNamespace == null) return; //'global' keyword. Would hilite entire code.
			List<Range> ar = new();
			var cancelTS = _cancelTS = new CancellationTokenSource();
			var cancelToken = cancelTS.Token;
			try {
				var options = FindReferencesSearchOptions.GetFeatureOptionsForStartingSymbol(sym);
				
				var solution = cd.document.Project.Solution;
				var ihs = ImmutableHashSet.Create(cd.document);
				var rr = await SymbolFinder.FindReferencesAsync(sym, solution, (IFindReferencesProgress)null, ihs, options, cancelToken);
				
				if (Panels.Editor.ActiveDoc != cd.sci) return;
				
				foreach (var v in rr) {
					if (!v.ShouldShow(options)) continue;
					
					//definition
					foreach (var loc in v.Definition.Locations) {
						if (loc.SourceTree == cd.syntaxRoot.SyntaxTree) {
							ar.Add(loc.SourceSpan.ToRange());
						}
					}
					
					//references
					foreach (var rloc in v.Locations) {
						if (rloc.Document == cd.document) {
							var span = rloc.Location.SourceSpan;
							if (span.Length == 0 && span.Start < cd.code.Length) span = new(span.Start, 1); //indexer
							ar.Add(span.ToRange());
						}
					}
				}
				
				foreach (var v in ar) {
					if (cd.sci.SnippetMode_ != null && 0 != (cd.sci.aaaIndicatorGetAll(v.Start.Value, true) & 1 << SciTheme.Indic.SnippetFieldActive)) continue; //avoid mixed color
					cd.sci.aaaIndicatorAdd(SciTheme.Indic.Refs, true, v);
				}
			}
			catch (OperationCanceledException) { return; }
			catch (Exception e1) { Debug_.Print(e1); } //Roslyn bug: when caret at '!=' in 'if (Sheet != App.ActiveSheet)' (COM). Also once "Unexpected value 'PointerElementAccess'".
			finally {
				cancelTS.Dispose();
				if (cancelTS == _cancelTS) _cancelTS = null;
			}
		}
		//See also: Roslyn -> AbstractDocumentHighlightsService.cs.
		
		//CONSIDER: now brace hiliting is distracting and I as a user rarely need it.
		//	Maybe hilite only when a single brace selected.
		//	But other IDEs hilite like this.
		_HighlightMatchingBracesOrDirectives(cd);
	}
	
	static void _HighlightMatchingBracesOrDirectives(CodeInfo.Context cd) {
		string code = cd.code;
		int pos = cd.pos;
		char chL = pos <= code.Length - 2 ? code[pos] : default, chR;
		if (chL is '(' or '[' or '{' or '<') {
			chR = chL switch { '(' => ')', '[' => ']', '{' => '}', _ => '>' };
			_Brace(false);
		} else if (chL == '#' && CiUtil.IsLineStart(code, pos)) {
			_Directive();
		}
		
		chR = --pos >= 0 ? code[pos] : default;
		if (chR is ')' or ']' or '}' or '>') {
			chL = chR switch { ')' => '(', ']' => '[', '}' => '{', _ => '<' };
			_Brace(true);
		} else if (chR == '#' && CiUtil.IsLineStart(code, pos)) {
			_Directive();
		}
		
		void _Brace(bool isPrevChar) {
			var (kL, kR) = chL switch {
				'(' => (SyntaxKind.OpenParenToken, SyntaxKind.CloseParenToken),
				'[' => (SyntaxKind.OpenBracketToken, SyntaxKind.CloseBracketToken),
				'{' => (SyntaxKind.OpenBraceToken, SyntaxKind.CloseBraceToken),
				_ => (SyntaxKind.LessThanToken, SyntaxKind.GreaterThanToken)
			};
			var token = cd.syntaxRoot.FindToken(pos);
			var span = token.Span;
			if (span.Start != pos || span.Length != 1) return;
			if (!token.IsKind(isPrevChar ? kR : kL)) return;
			var node = token.Parent;
			int posL = -1, posR = -1;
			foreach (var v in node.ChildTokens()) {
				if (posL < 0) {
					if (v.IsKind(kL) && v.Span.Length == 1) posL = v.SpanStart;
				} else if (posR < 0) {
					if (v.IsKind(kR) && v.Span.Length == 1) posR = v.SpanStart;
				}
			}
			if (posR < 0 || !(posL == pos || posR == pos)) return;
			if (posR - posL < 4) return; //don't hilite () etc
			cd.sci.aaaIndicatorAdd(SciTheme.Indic.Braces, true, posL..(posL + 1));
			cd.sci.aaaIndicatorAdd(SciTheme.Indic.Braces, true, posR..(posR + 1));
		}
		
		void _Directive() {
			if (cd.syntaxRoot.FindToken(pos, findInsideTrivia: true).Parent is not DirectiveTriviaSyntax node) return;
			IEnumerable<DirectiveTriviaSyntax> a = null;
			if (node is IfDirectiveTriviaSyntax or ElseDirectiveTriviaSyntax or ElifDirectiveTriviaSyntax or EndIfDirectiveTriviaSyntax) {
				var m = node.GetMatchingConditionalDirectives(default);
				if (m.Length > 1) a = m;
			} else {
				var node2 = node.GetMatchingDirective(default);
				if (node2 != null) a = [node, node2];
			}
			if (a == null) return;
			foreach (var v in a) cd.sci.aaaIndicatorAdd(SciTheme.Indic.Braces, true, v.HashToken.Span.ToRange());
		}
	}
	
	public static void RenameSymbol() {
		if (_working) return;
		_working = true;
		try { new _Renamer().Rename(); }
		finally { _working = false; }
	}
	
	class _Renamer {
		string _oldName, _newName, _info;
		bool _overloads, _comments, _disabled, _strings, _preview;
		List<_File> _a;
		FileNode _currentFile;
		KScintilla _sciPreview;
		static WeakReference<KScintilla> s_sciPreview;
		
		public async void Rename() {
			if (s_sciPreview?.TryGetTarget(out var sciPreview) ?? false) Panels.Found.Close(sciPreview);
			s_sciPreview = null;
			
			if (!CodeInfo.GetContextAndDocument(out var cd)) return;
			_currentFile = cd.sci.EFile;
			
			var sym = await RenameUtilities.TryGetRenamableSymbolAsync(cd.document, cd.pos, default);
			
			if (sym == null || !sym.IsInSource() || sym.IsImplicitlyDeclared || !sym.Locations[0].FindToken(default).IsKind(SyntaxKind.IdentifierToken)) {
				dialog.show("This element cannot be renamed", owner: App.Hmain);
				return;
			}
			
			if (!_Dialog(sym)) return;
			
			//using var p1 = perf.local();
			LightweightRenameLocations rlocs;
			TestInternal.RefsStart();
			try {
				(var solution, _info) = await CiProjects.GetSolutionForFindReferences(sym, cd);
				//p1.Next('s');
				
				SymbolRenameOptions sro = new(_overloads, _strings, _comments | _disabled);
				rlocs = await Renamer.FindRenameLocationsAsync(solution, sym, sro, default);
			}
			finally { TestInternal.RefsEnd(); }
			//p1.Next('f');
			
			Dictionary<FileNode, _File> df = new();
			HashSet<_Seen> seen = new();
			foreach (var v in rlocs.Locations) {
				var f = CiProjects.FileOf(v.DocumentId);
				var span = v.Location.SourceSpan;
				if (!seen.Add(new(f, span.Start))) continue; //remove logical duplicates added because of meta c
				
				int marker = 0;
				if (v.IsRenameInStringOrComment) {
					var trivia = v.Location.SourceTree.GetRoot(default).FindTrivia(v.Location.SourceSpan.Start);
					marker = trivia.Kind() switch {
						SyntaxKind.None => c_markerRenameString,
						SyntaxKind.DisabledTextTrivia => c_markerRenameDisabled,
						_ => c_markerRenameComment
					};
					if (marker == c_markerRenameComment && !_comments) continue;
					if (marker == c_markerRenameDisabled && !_disabled) continue;
				} else if (v.CandidateReason != CandidateReason.None) {
					marker = c_markerRenameError;
				}
				if (marker > 0) _preview = true;
				
				if (!df.TryGetValue(f, out var x)) {
					if (!rlocs.Solution.GetDocument(v.DocumentId).TryGetText(out var st)) { Debug_.Print(f); continue; }
					df.Add(f, x = new(f, st.ToString(), new()));
				}
				
				x.a.Add(new(span.Start, span.End, _newName, marker));
			}
			
			//Resolve conflicts.
			//	We use Renamer.FindRenameLocationsAsync (above) and ResolveConflictsAsync (below).
			//	Bad: ResolveConflictsAsync makes 4 times slower. Optional if don't need conflict resolution.
			//Could instead use Renamer.RenameSymbolAsync. Simpler, and same speed. Problems:
			//	- Fails to rename some, eg tuple fields. Now fails only to resolve conflicts (that is why the try/catch).
			//	- Skips #if-disabled code.
			//	- Joins some changes, eg in doc comments. Then a change can span many lines. How to display it?
			try {
				var res = await rlocs.ResolveConflictsAsync(sym, _newName, default);
				if (res.IsSuccessful && res.RelatedLocations.Any(o => o.Type.HasAny(RelatedLocationType.UnresolvedConflict))) {
					if (!dialog.showOkCancel("Unresolved conflict", "Rename anyway?", owner: App.Hmain)) return;
					//But does not find eg variable name conflicts in top-level statements.
					//In some places false positive unresolved conflict. Same in VS. Therefore don't show text like "This name already exists".
				}
				if (res.IsSuccessful && res.RelatedLocations.Any(o => o.Type is RelatedLocationType.ResolvedNonReferenceConflict or RelatedLocationType.ResolvedReferenceConflict)) {
					var drloc = rlocs.Locations.ToDictionary(o => o.Location.SourceSpan.Start);
					foreach (var did in res.DocumentIds) {
						var drels = res.GetRelatedLocationsForDocument(did);
						if (!drels.Any(o => o.Type is RelatedLocationType.ResolvedNonReferenceConflict or RelatedLocationType.ResolvedReferenceConflict)) continue;
						var f = CiProjects.FileOf(did);
						var doc1 = res.OldSolution.GetDocument(did);
						var doc2 = res.NewSolution.GetDocument(did);
						foreach (var tc in await doc2.GetTextChangesAsync(doc1)) {
							if (tc.Span.Length == _oldName.Length && tc.NewText == _newName) continue; //not a conflict
							if (!seen.Add(new(did, tc.Span.End))) continue; //remove logical duplicates added because of meta c
							
							if (!df.TryGetValue(f, out var x)) {
								if (!doc1.TryGetText(out var st)) { Debug_.Print(f); continue; }
								df.Add(f, x = new(f, st.ToString(), new()));
							}
							
							//Roslyn may add indent, and it is always spaces. Trim it.
							var s = tc.NewText.TrimStart();
							int start = tc.Span.Start, end = tc.Span.End;
							while (start < end && x.text[start] is '\t' or ' ') start++;
							
							//remove the overlapping change added before. Eg remove 'NewName' if this is 'PrependedNamespace.NewName'.
							if (end > start) x.a.RemoveAll(o => o.start < end && o.end > start);
							
							x.a.Add(new(start, end, s, 0));
						}
					}
				}
			}
			catch (Exception e1) { Debug_.PrintIf(sym.Kind != SymbolKind.Field, e1); }
			
			_a = df.Values.OrderBy(o => o.f.Name).ToList();
			foreach (var v in _a) v.a.Sort((x, y) => x.end - y.end);
			//p1.Next();
			
			if (_preview) _Preview();
			else _Finish();
		}
		
		bool _Dialog(ISymbol sym) {
			_oldName = sym.JustName();
			bool hasOverloads = CAW::Microsoft.CodeAnalysis.Rename.RenameUtilities.GetOverloadedSymbols(sym).Any();
			
			var b = new wpfBuilder("Rename symbol").Width(300..);
			b.WinProperties(WindowStartupLocation.CenterOwner, showInTaskbar: false);
			b.R.Add(out KTextBox newName, _oldName).Font("Consolas").Focus()
				.Validation(_ => SyntaxFacts.IsValidIdentifier(newName.Text.TrimStart('@')) ? null : "Invalid name");
			newName.SelectAll();
			b.R.Add(out KCheckBox cOverloads, "Include overloads").Hidden(!hasOverloads).Checked(0 != (App.Settings.ci_rename & 1));
			b.R.Add(out KCheckBox cComments, "Include comments").Checked(0 != (App.Settings.ci_rename & 2));
			b.R.Add(out KCheckBox cDisabled, "Include #if-disabled code").Checked(0 != (App.Settings.ci_rename & 4));
			b.R.Add(out KCheckBox cStrings, "Include strings").Checked(0 != (App.Settings.ci_rename & 8));
			//b.R.Add(out KCheckBox cPreview, "Preview");
			b.R.AddOkCancel();
			b.End();
			if (!b.ShowDialog(App.Wmain)) return false;
			_overloads = cOverloads.IsChecked;
			_comments = cComments.IsChecked;
			_disabled = cDisabled.IsChecked;
			_strings = cStrings.IsChecked;
			//_preview = cPreview.IsChecked;
			App.Settings.ci_rename = (_overloads ? 1 : 0) | (_comments ? 2 : 0) | (_disabled ? 4 : 0) | (_strings ? 8 : 0);
			_newName = newName.Text;
			return _newName != _oldName;
		}
		
		void _Preview() {
			using var workingState = Panels.Found.Prepare(PanelFound.Found.SymbolRename, "Renaming", out var b);
			if (workingState.NeedToInitControl) {
				var k = workingState.Scintilla;
				k.aaaMarkerDefine(c_markerInfo, SC_MARK_BACKGROUND, backColor: 0xEEE8AA);
				k.aaaMarkerDefine(c_markerSeparator, SC_MARK_UNDERLINE, backColor: 0xe0e0e0);
				k.aaaMarginSetWidth(1, 12);
				k.aaaMarkerDefine(c_markerRenameComment, SC_MARK_SMALLRECT, backColor: 0x80C000);
				k.aaaMarkerDefine(c_markerRenameDisabled, SC_MARK_SMALLRECT, backColor: 0);
				k.aaaMarkerDefine(c_markerRenameString, SC_MARK_SMALLRECT, backColor: 0xC09060);
				k.aaaMarkerDefine(c_markerRenameError, SC_MARK_SMALLRECT, backColor: 0xFF0000);
			}
			b.Marker(c_markerInfo).Text("You may want to exclude some of these. Right-click.\r\n");
			
			FileNode prevFile = null;
			foreach (var (f, text, a) in _a) {
				foreach (var v in a) {
					//if (v.marker > 0) b.Marker(v.marker);
					if (v.marker == 0) continue;
					b.Marker(v.marker);
					if (f != prevFile) { if (prevFile != null) b.Marker(c_markerSeparator, prevLine: true); prevFile = f; }
					PanelFound.AppendFoundLine(b, f, text, v.start, v.end, workingState, displayFile: true, indicHilite: PanelFound.Indicators.HiliteB);
					//rejected: in results display newName (hilited) as if already replaced. Or old red and new green, like in VSCode.
				}
			}
			
			b.Marker(c_markerInfo)
				.B().Link(() => _Link(false), "Rename").B_()
				.Text("  ").Link(() => _Link(true), "Cancel").NL();
			b.Marker(c_markerInfo).Text("Markers: green - comment, black - #if, brown - string, red - error or ambiguous.");
			if (!_info.NE()) b.NL().Marker(c_markerInfo).Text(_info);
			
			Panels.Found.SetResults(workingState, b);
			s_sciPreview = new(_sciPreview = workingState.Scintilla);
		}
		
		void _Link(bool cancel) {
			//async because cannot close Scintilla from link click notification
			App.Dispatcher.InvokeAsync(() => {
				if (!cancel) _Finish();
				Panels.Found.Close(_sciPreview);
			});
			s_sciPreview = null;
		}
		
		void _Finish() {
			foreach (var (f, text, _) in _a) {
				if (f.GetCurrentText(out var t1, null) && t1 != text) {
					dialog.show(null, $"Cannot rename symbol, because '{f.Name}' text changed in the meantime.", owner: App.Hmain);
					return;
				}
			}
			
			if (_sciPreview != null) { //remove excluded items
				int line = 1;
				for (int j = 0; j < _a.Count; j++) {
					var a = _a[j].a;
					for (int i = 0; i < a.Count; i++) {
						if (a[i].marker == 0) continue;
						if (0 != _sciPreview.aaaIndicatorGetValue(PanelFound.Indicators.Excluded, _sciPreview.aaaLineStart(false, line++)))
							a.RemoveAt(i--);
					}
					if (a.Count == 0) _a.RemoveAt(j--);
				}
				if (_a.Count == 0) return;
			}
			
			//var progress = App.Hmain.TaskbarButton;
			var undoInFiles = SciUndo.OfWorkspace;
			try {
				undoInFiles.StartReplaceInFiles();
				foreach (var (f, text, a1) in _a) {
					var a = a1.Select(o => new StartEndText(o.start, o.end, o.text)).ToList();
					if (f.ReplaceAllInText(text, a, out var text2)) {
						if (f.OpenDoc != null) undoInFiles.RifAddFile(f.OpenDoc, text, text2, a);
						else undoInFiles.RifAddFile(f, text, text2, a);
					}
				}
			}
			finally {
				undoInFiles.FinishReplaceInFiles($"rename symbol {_oldName} to {_newName}");
				//progress.SetProgressState(WTBProgressState.NoProgress);
				CodeInfo.FilesChanged();
			}
		}
		
		record struct _Change(int start, int end, string text, int marker);
		record struct _File(FileNode f, string text, List<_Change> a);
	}
}


================================================
FILE: Au.Editor/Edit/CiFindGo.cs
================================================
extern alias CAW;

using System.Collections.Immutable;
using System.Windows;
using System.Windows.Controls;

using Microsoft.CodeAnalysis;
using CAW::Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Text;
using Microsoft.CodeAnalysis.CSharp.Extensions;
using Microsoft.CodeAnalysis.Shared.Extensions;
using CAW::Microsoft.CodeAnalysis.Shared.Extensions;
using CAW::Microsoft.CodeAnalysis.FindSymbols;
using CAW::Microsoft.CodeAnalysis.PatternMatching;
using CAW::Microsoft.CodeAnalysis.Collections;

using Au.Controls;
using System.Windows.Input;

namespace LA;

class CiFindGo : KDialogWindow {
	KTextBox _tQuery;
	KCheckBox _cFuzzy, _cKeepOpen;
	KTreeView _tv;
	CancellationTokenSource _cancelTS;
	
	public static void ShowSingle() {
		if (Panels.Editor.ActiveDoc?.EFile.IsCodeFile != true) return;
		ShowSingle(() => new CiFindGo());
	}
	
	CiFindGo() {
		InitWinProp("Find symbol", App.Wmain);
		var b = new wpfBuilder(this).WinSize(600, 600).Columns(-1, 0, 0, 0);
		
		_timer1 = new(_ => _Update());
		
		b.R.Add(out _tQuery, s_lastQuery).Font("Consolas").Align(y: VerticalAlignment.Center).Focus()
			.Tooltip("""
Symbol name.
Can be part, or part1 part2, or Type.Member, or camel.
If fuzzy, must be full name, 1 word.
Filters: t Type, m Member, n Namespace.
""");
		_tQuery.TextChanged += (_, _) => _timer1.After(200);
		
		b.Add(out _cFuzzy, "Fuzzy");
		_cFuzzy.CheckChanged += (_, _) => _timer1.After(200);
		
		b.xAddButtonIcon("*EvaIcons.Options2" + EdIcons.green, _Options, "Tool settings");
		b.xAddCheckIcon(out _cKeepOpen, "*MaterialLight.Pin" + EdIcons.black, "Keep this window open");
		
		b.Row(-1).Add(out _tv);
		_tv.CustomDraw = new _TvDraw();
		_tv.CustomItemHeightAddPercent = 100;
		_tv.ItemMarginLeft = 8;
		_tv.HotTrack = true;
		_tv.SingleClickActivate = !App.Settings.ci_findgoDclick;
		_tv.ItemActivated += e => {
			if (!_cKeepOpen.IsChecked) Close();
			(e.Item as _TvItem).Clicked();
		};
		
		b.End();
		
		if (!s_lastQuery.NE()) {
			_tQuery.SelectAll();
			_timer1.After(1);
		}
		
		b.WinSaved(App.Settings.wndpos.symbol, o => App.Settings.wndpos.symbol = o);
	}
	
	timer _timer1;
	static string s_lastQuery;
	
	async void _Update() {
		_cancelTS?.Cancel(); //it seems the API always runs in this thread, but anyway
		
		var query = _tQuery.Text.Trim();
		if (query.Length < 2) {
			_tv.SetItems(null);
			return;
		}
		s_lastQuery = query;
		
		if (!CodeInfo.GetContextAndDocument(out var cd, metaToo: true)) return;
		
		var a = new List<_TvItem>();
		
		var filter = SymbolFilter.All;
		if (query.Length > 2 && query[1] is ' ' or ':' && query[0] is 't' or 'm' or 'n') {
			filter = query[0] switch { 't' => SymbolFilter.Type, 'm' => SymbolFilter.Member, _ => SymbolFilter.Namespace };
			query = query[2..].TrimStart();
		}
		
		bool fuzzy = _cFuzzy.IsChecked;
		
		var cancelTS = _cancelTS = new CancellationTokenSource();
		var cancelToken = cancelTS.Token;
		
		IEnumerable<ISymbol> e;
		var solution = cd.document.Project.Solution;
		try {
			if (fuzzy) {
				using var sq = SearchQuery.CreateFuzzy(query);
				e = await SymbolFinder.FindSourceDeclarationsWithCustomQueryAsync(solution, sq, filter, cancelToken);
			} else {
				e = await SymbolFinder.FindSourceDeclarationsWithPatternAsync(solution, query, filter, cancelToken);
			}
			//BAD: skips ctors. Same in VSCode, but in VS ok.
		}
		catch (OperationCanceledException) { return; }
		finally {
			cancelTS.Dispose();
			if (cancelTS == _cancelTS) _cancelTS = null;
		}
		
		if (!e.Any()) {
			_tv.SetItems(null);
			return;
		}
		
		var qname = PatternMatcher.GetNameAndContainer(query).name;
		using var matcher = PatternMatcher.CreatePatternMatcher(qname, includeMatchedSpans: true, allowFuzzyMatching: fuzzy);
		using var ta = TemporaryArray<PatternMatch>.Empty;
		var b1 = new StringBuilder();
		
		foreach (var sym in e) {
			string name = sym.JustName(), text;
			int nameStart = 0;
			if (sym is INamespaceSymbol) {
				text = sym.ToString(); /* with ancestor namespaces */
				nameStart = text.Length - sym.Name.Length;
			} else {
				text = sym.ToDisplayString(s_symbolFormat);
				if (name.Length < text.Length) {
					nameStart = text.FindWord(name, isWordChar: c => SyntaxFacts.IsIdentifierPartCharacter(c));
					Debug_.PrintIf(nameStart < 0, $"{name}, {text}");
				}
			}
			
			ImmutableArray<PatternMatch> matches = default;
			if (nameStart >= 0) {
				if (matcher.AddMatches(name, ref ta.AsRef())) {
					matches = ta.ToImmutableAndClear();
				} else ta.Clear();
			}
			
			string type = sym is INamespaceOrTypeSymbol ? null : sym.ContainingType?.ToDisplayString(s_symbolFormat);
			
			foreach (var loc in sym.Locations) {
				var st = loc.SourceTree;
				if (st == null) continue;
				string path = st.FilePath;
				string text2 = type != null ? $"in {type},  {path}" : path;
				var fn = CiProjects.FileOf(loc.SourceTree, solution);
				
				a.Add(new(sym, text, text2, matches, nameStart, fn, loc.SourceSpan.Start));
			}
		}
		
		a.Sort((x, y) => x.CompareTo(y));
		
		_tv.SetItems(a);
		_tv.Select(0, focus: true);
	}
	
	class _TvItem : ITreeViewItem {
		string _text, _text2, _kindImage, _accessImage;
		ImmutableArray<PatternMatch> _matches;
		int _nameStart, _pos;
		FileNode _f;
		
		public _TvItem(ISymbol sym, string text, string text2, ImmutableArray<PatternMatch> matches, int nameStart, FileNode f, int pos) {
			_text = text;
			_text2 = text2;
			_matches = matches;
			_nameStart = nameStart;
			_f = f;
			_pos = pos;
			(_kindImage, _accessImage) = sym.ImageResource();
		}
		
		#region ITreeViewItem
		
		object ITreeViewItem.Image => _kindImage;
		
		string ITreeViewItem.DisplayText => _text + "\n" + _text2; //for tooltip only
		
		int ITreeViewItem.MesureTextWidth(GdiTextRenderer tr) => Math.Max(tr.MeasureText(_text).width, tr.MeasureText(_text2).width);
		
		int ITreeViewItem.SelectedColor(TVColorInfo ci) => ci.isSelected ? 0xD5E1FF : -1;
		
		int ITreeViewItem.BorderColor(TVColorInfo ci) => ci.isSelected ? 0x91B1FF : -1;
		
		#endregion
		
		public void DrawText(TVDrawInfo d, GdiTextRenderer tr) {
			int y = d.yText;
			tr.MoveTo(d.xText, y);
			
			bool dark = d.colorInfo.isHighContrastDark && !d.colorInfo.isSelected;
			int textColor = dark ? 0xFFFFFF : 0;
			if (!_matches.IsDefault) {
				int i = 0;
				foreach (var v in _matches) {
					foreach (var t in v.MatchedSpans) {
						int from = _nameStart + t.Start, to = _nameStart + t.End;
						if (from > i) tr.DrawText(_text, textColor, i..from);
						tr.DrawText(_text, textColor, from..to, dark ? 0x0080A0 : 0x80F0FF);
						i = to;
					}
				}
				if (i < _text.Length) tr.DrawText(_text, textColor, i..);
			} else {
				tr.DrawText(_text, textColor);
			}
			
			y = d.rect.top + d.lineHeight;
			tr.MoveTo(d.xText, y);
			tr.DrawText(_text2, dark ? textColor : 0x808080);
		}
		
		public void DrawMarginLeft(TVDrawInfo d, GdiTextRenderer tr) {
			if (_accessImage == null) return;
			var cxy = d.imageRect.Width;
			var ri = new System.Drawing.Rectangle(d.imageRect.left - cxy / 2, d.imageRect.top + cxy / 4, cxy, cxy);
			d.graphics.DrawImage(IconImageCache.Common.Get(_accessImage, d.dpi, isImage: true), ri);
		}
		
		public void Clicked() {
			App.Model.OpenAndGoTo(_f, columnOrPos: _pos);
		}
		
		public int CompareTo(_TvItem other) {
			var x = _matches;
			var y = other._matches;
			
			if (x.IsDefault) return y.IsDefault ? 0 : 1;
			if (y.IsDefault) return -1;
			
			//Debug.Assert(x.Length == y.Length); //Once. After restarting could not reproduce. The text was "MD5" or "MD5R", while editing an Au file. Then added `else ta.Clear();` in _Update().
			Debug_.PrintIf(x.Length != y.Length, $"x.Length={x.Length}, y.Length={y.Length}");
			if (x.Length != y.Length) return 0;
			
			int r = 0;
			for (int i = 0; i < x.Length; i++) r += x[i].CompareTo(y[i]);
			return r;
		}
	}
	
	class _TvDraw : ITVCustomDraw {
		TVDrawInfo _cd;
		GdiTextRenderer _tr;
		
		#region ITVCustomDraw
		
		public void Begin(TVDrawInfo cd, GdiTextRenderer tr) {
			_cd = cd;
			_tr = tr;
		}
		
		//public bool DrawBackground() {
		
		//	return default;
		//}
		
		//public bool DrawImage(System.Drawing.Bitmap image) {
		
		//	return default;
		//}
		
		public bool DrawText() {
			(_cd.item as _TvItem).DrawText(_cd, _tr);
			return true;
		}
		
		public void DrawMarginLeft() {
			(_cd.item as _TvItem).DrawMarginLeft(_cd, _tr);
		}
		
		//public void DrawMarginRight() {
		
		//}
		
		//public void End() {
		
		//}
		
		#endregion
	}
	
	const SymbolDisplayMiscellaneousOptions s_miscDisplayOptions =
		SymbolDisplayMiscellaneousOptions.AllowDefaultLiteral
		| SymbolDisplayMiscellaneousOptions.EscapeKeywordIdentifiers
		//| SymbolDisplayMiscellaneousOptions.IncludeNullableReferenceTypeModifier //?
		//| SymbolDisplayMiscellaneousOptions.IncludeNotNullableReferenceTypeModifier //!
		| SymbolDisplayMiscellaneousOptions.UseErrorTypeSymbolName
		| SymbolDisplayMiscellaneousOptions.UseSpecialTypes;
	const SymbolDisplayParameterOptions s_parameterDisplayOptions =
		SymbolDisplayParameterOptions.IncludeType
		| SymbolDisplayParameterOptions.IncludeName
		| SymbolDisplayParameterOptions.IncludeParamsRefOut
		//| SymbolDisplayParameterOptions.IncludeOptionalBrackets
		;
	
	internal static readonly SymbolDisplayFormat s_symbolFormat = new(
		SymbolDisplayGlobalNamespaceStyle.OmittedAsContaining,
		SymbolDisplayTypeQualificationStyle.NameAndContainingTypes,
		SymbolDisplayGenericsOptions.IncludeTypeParameters,
		SymbolDisplayMemberOptions.IncludeParameters,
		SymbolDisplayDelegateStyle.NameAndSignature,
		SymbolDisplayExtensionMethodStyle.Default,
		s_parameterDisplayOptions,
		SymbolDisplayPropertyStyle.NameOnly,
		SymbolDisplayLocalOptions.IncludeType,
		SymbolDisplayKindOptions.None,
		s_miscDisplayOptions
		);
	
	protected override void OnPreviewKeyDown(KeyEventArgs e) {
		if (e.Source != _tv && e.Key is Key.Enter or Key.Down or Key.Up or Key.PageDown or Key.PageUp) {
			_tv.ProcessKey(e.Key);
			e.Handled = true;
		} else if (e.Key is Key.Escape) {
			Close();
			e.Handled = true;
		}
		base.OnPreviewKeyDown(e);
	}
	
	protected override void OnDeactivated(EventArgs e) {
		base.OnDeactivated(e);
		if (IsVisible && !_cKeepOpen.IsChecked) {
			//need timer, else something activates wrong window, even with InvokeAsync
			timer.after(25, _ => { if (!IsActive) Close(); });
		}
	}
	
	void _Options(WBButtonClickArgs e) {
		var m = new popupMenu();
		
		m.AddCheck("Double-click", App.Settings.ci_findgoDclick, _ => {
			App.Settings.ci_findgoDclick ^= true;
			_tv.SingleClickActivate = !App.Settings.ci_findgoDclick;
		});
		
		m.Show(owner: this);
	}
}


================================================
FILE: Au.Editor/Edit/CiFolding.cs
================================================
//#define PRINT

extern alias CAW;

using Microsoft.CodeAnalysis;
using CAW::Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Text;
using Microsoft.CodeAnalysis.CSharp.Extensions;
using Microsoft.CodeAnalysis.Shared.Extensions;
using CAW::Microsoft.CodeAnalysis.Shared.Extensions;

using Au.Controls;
using static Au.Controls.Sci;

namespace LA;

class CiFolding {
	//Called from CiStyling._Work -> Task.Run when document opened or modified (250 ms timer).
	//We always set/update folding for entire code. Makes slower, but without it sometimes bad folding.
	public static List<SciFoldPoint> GetFoldPoints(SyntaxNode root, string code, CancellationToken cancelToken) {
#if PRINT
		using var p1 = perf.local();
#endif
		void _PN(char ch = default) {
#if PRINT
			p1.Next(ch);
#endif
		}
		
		List<SciFoldPoint> af = null;
		s_foldPoints.Clear();
		
		void _AddFoldPoint(FoldKind what, int pos, bool start, bool trimNewline = false, ushort separator = 0) {
			if (trimNewline) {
				if (code[pos - 1] == '\n') pos--;
				if (code[pos - 1] == '\r') pos--;
			}
			(af ??= new()).Add(new(pos, start, separator));
			if (start) s_foldPoints.Add((pos, what));
		}
		void _AddFoldPoints(FoldKind what, int start, int end, ushort separator = 0) {
			if (separator == 0) {
				int k = code.IndexOf('\n', start, end - start);
				if (k < 0 || k == end - 1) return;
			}
			_AddFoldPoint(what, start, true);
			_AddFoldPoint(what, end, false, true, separator);
		}
		
		IEnumerable<SyntaxNode> nodes;
#if !true //slow
		if (code.Length > 200_000) { //fast, but does not fold anything inside functions and statements
			nodes = root.DescendantNodes(static o => {
				if (o is MemberDeclarationSyntax) return o is BaseNamespaceDeclarationSyntax or TypeDeclarationSyntax;
				return o is CompilationUnitSyntax;
			});
		} else { //slow
			nodes = root.DescendantNodes();
		}
#else //2-3 times faster
		if (code.Length > 500_000) { //fast, but does not fold anything inside functions and statements
			nodes = root.DescendantNodes(static o => {
				if (o is MemberDeclarationSyntax) return o is BaseNamespaceDeclarationSyntax or TypeDeclarationSyntax;
				return o is CompilationUnitSyntax;
			});
		} else {
			nodes = root.DescendantNodes(n => {
				//note: all this code is just to make faster. It does not add any features.
				if (n is StatementSyntax) { //don't descend into statements that don't contain `{` etc
					var nspan = n.Span;
					if (nspan.Length < 20) return false;
					var s = code.AsSpan(nspan.ToRange());
					int i = s.IndexOf(1, '{');
					if (s[0] != '{') { //not BlockSyntax
						if (i > 0) {
							if (s[^1] == '}' || n is IfStatementSyntax { Statement: BlockSyntax } or DoStatementSyntax) i = s.IndexOf(i + 1, '{');
						} else if (s[^1] is ';' && s[^2] is ']' or '"') { //maybe like `int[] a = [ multiline ];` or `var s = """multiline""";`
							return s.Contains('\n');
						}
					}
					if (i < 0 && s.Contains('\n')) {
						i = s.IndexOf("\";");
						if (i < 0) i = s.IndexOf("];");
					}
					return i >= 0;
				}
				return true;
			});
		}
#endif
		SyntaxNode prevStatementOrMember = null;
		foreach (var n in nodes) {
			if (n is GlobalStatementSyntax g) continue;
			//CiUtil.PrintNode(n, indent: true);
			
			FoldKind foldKind = FoldKind.Member;
			int foldStart = -1;
			bool separatorBefore = false;
			SyntaxNode prevSibling = null;
			
			switch (n) {
			case ExtensionBlockDeclarationSyntax d:
				foldKind = FoldKind.Type;
				foldStart = d.Keyword.SpanStart;
				break;
			case BaseTypeDeclarationSyntax d: //class, struct, interface, enum
				foldKind = FoldKind.Type;
				foldStart = d.Identifier.SpanStart;
				separatorBefore = _PrevSibling(n) is StatementSyntax and not LocalFunctionStatementSyntax;
				break;
			case BaseMethodDeclarationSyntax d: //method, ctor, etc
				if (d.Body == null && d.ExpressionBody == null) continue; //extern, interface, partial
				foldStart = d.ParameterList.SpanStart; //not perfect, but the best common property
				separatorBefore = _PrevSibling(n) is BaseFieldDeclarationSyntax;
				break;
			case BasePropertyDeclarationSyntax d: //property, indexer, event
				foldStart = d.Type.FullSpan.End; //not perfect, but the best common property
				separatorBefore = _PrevSibling(n) is BaseFieldDeclarationSyntax;
				break;
			case LocalFunctionStatementSyntax d:
				if (d.Parent is GlobalStatementSyntax) separatorBefore = !(_PrevSibling(n) is null or LocalFunctionStatementSyntax);
				else if (_ManyLines(n, 3)) foldKind = FoldKind.Statement;
				else break;
				foldStart = d.Identifier.SpanStart;
				break;
			case AnonymousFunctionExpressionSyntax d when d.ExpressionBody == null: //lambda, delegate(){}
			case InitializerExpressionSyntax or CollectionExpressionSyntax:
			case LiteralExpressionSyntax { RawKind: (int)SyntaxKind.StringLiteralExpression } or InterpolatedStringExpressionSyntax:
				if (_ManyLines(n, n is AnonymousFunctionExpressionSyntax ? 3 : 5)) {
					foldStart = n.SpanStart;
					foldKind = FoldKind.Statement;
				}
				break;
			case NamespaceDeclarationSyntax d:
				foldStart = d.Name.SpanStart;
				foldKind = FoldKind.Namespace;
				break;
			}
			
			//print.it(foldStart);
			if (foldStart >= 0) {
				_AddFoldPoints(foldKind, foldStart, n.Span.End, separator: (ushort)(foldKind == FoldKind.Statement ? 0 : 1));
				
				//add separator before top-level local function preceded by statement of other type.
				//	Also before other functions preceded by field or simple event.
				if (separatorBefore) {
					int i = _PrevSibling(n).Span.End; //add separator at the bottom of line containing position i
					if (n is LocalFunctionStatementSyntax) { //if there are empty lines, set i at the last empty line
						var kPrev = SyntaxKind.EndOfLineTrivia;
						foreach (var t in n.GetLeadingTrivia()) {
							var k = t.Kind();
							if (k == SyntaxKind.EndOfLineTrivia && k == kPrev) i = t.SpanStart;
							kPrev = k;
						}
					}
					i = foldStart - i;
					if (i <= ushort.MaxValue) af[^2] = af[^2] with { separator = (ushort)i };
				}
			}
			if (n is StatementSyntax or MemberDeclarationSyntax) prevStatementOrMember = n;
			if (cancelToken.IsCancellationRequested) return null;
			
			SyntaxNode _PrevSibling(SyntaxNode n) {
				if (prevSibling != null) return prevSibling;
				var p = n.Parent;
				var r = prevStatementOrMember;
				while (r != null) {
					var p2 = r.Parent;
					if (p2 == p || p2 is GlobalStatementSyntax) break;
					r = p2;
				}
				return prevSibling = r;
			}
			
			bool _ManyLines(SyntaxNode n, int lines) {
				var s = code.AsSpan(n.Span.ToRange());
				for (int i = 0; ;) {
					i = s.IndexOf(i, '\n') + 1;
					if (i == 0) return false;
					if (--lines <= 1) return true;
				}
			}
		}
		_PN('n');
		
		List<TextSpan> disabledRanges = null;
		var dir = root.GetDirectives(o => o is RegionDirectiveTriviaSyntax or EndRegionDirectiveTriviaSyntax or BranchingDirectiveTriviaSyntax or EndIfDirectiveTriviaSyntax);
		foreach (var v in dir) {
			if (v is RegionDirectiveTriviaSyntax or EndRegionDirectiveTriviaSyntax) {
				_AddFoldPoint(FoldKind.Region, v.SpanStart, v is RegionDirectiveTriviaSyntax);
			} else if (v is BranchingDirectiveTriviaSyntax br && !br.BranchTaken) {
				var rd = br.GetRelatedDirectives();
				for (int i = 0; i < rd.Count - 1;) {
					if (rd[i++] == v) {
						int start = v.SpanStart, end = rd[i].SpanStart;
						while (end > start && code[end - 1] is not ('\n' or '\r')) end--;
						_AddFoldPoints(FoldKind.Disabled, start, end);
						(disabledRanges ??= new()).Add(TextSpan.FromBounds(start, end));
						break;
					}
				}
			}
		}
		_PN('d');
		
		//Find comments that need to fold:
		//	1. Blocks of //comments of >= 5 lines. Include empty lines, but split at the last empty line if last comments are followed by non-comments or other type of comments.
		//	2. Blocks of ///comments of >= 2 lines.
		//	3. /*...*/ comments of >= 2 lines. Same for /**...*/.
		//	4. //. is like #region, but can be not at the start of line too. Must not be followed by a non-space character.
		//	5. //.. is like #endregion, but can be not at the start of line too. Must not be followed by a non-space character.
		//		Rejected: //... unfolds 2 levels, //.... 3 levels and so on. Often //... comment used for "more code" or "etc". Also now not useful (was useful when C# did not have top-level statements).
		
		//Since root.DescendantTrivia is slow, we parse code
		//	and then use Roslyn just to verify that the found // etc is at start of trivia, ie isn't inside a string or other comments or #directive.
		//We skip disabled code (!BranchingDirectiveTriviaSyntax.BranchTaken).
		for (int ir = 0, nr = disabledRanges.Lenn_(), rangeStart = 0; ; rangeStart = disabledRanges[ir++].End) {
			int rangeEnd = ir == nr ? code.Length : disabledRanges[ir].Start;
			//print.it(rangeEnd-rangeStart);
			int rangeLength = rangeEnd - rangeStart;
			if (rangeLength > 2) { //possible at least //.
				var s = code.AsSpan(rangeStart, rangeLength); //current non-disabled range in code
				for (int i = 0; i <= s.Length - 4;) { //until last possible //..
					if (cancelToken.IsCancellationRequested) return null;
					
					int i0 = i = s.IndexOf(i, '/'); if ((uint)i > s.Length - 4) break;
					char c = s[++i]; if (c is not ('/' or '*')) continue;
					if (c == '/' && _IsDotComment(s, ++i, out bool closing)) { //.
						if (!_IsStartOfTrivia(false)) continue;
						_AddFoldPoint(FoldKind.DotFold, rangeStart + i0, !closing);
					} else if (c == '*' || CiUtil.IsLineStart(s, i0)) {
						i = i0 + 2;
						bool isLineComment = c == '/', isDocComment = false;
						if (!isLineComment) {
							//ignore /*single line*/
							int k = s.IndexOf(i, '\n');
							if (k < 0 || s[i..k].Contains("*/", StringComparison.Ordinal)) continue;
						} else if (s.Eq(i, '/') && !s.Eq(++i, '/')) { //doc comment ///
							isLineComment = false;
							i0 = i; //somehow Span of doc comment trivia starts after ///
							
							//ignore single-line doc comments
							int k = s.IndexOf(i, '\n'); if (k++ < 0) continue;
							while (k < s.Length && s[k] is '\t' or ' ') k++;
							if (!s.Eq(k, "///")) continue;
							isDocComment = true;
						} else {
							int nlines = 0, joinAt = 0, joinNlines = 0;
							for (; ; nlines++) {
								if (nlines > 0) {
									int lineStart = i;
									while (i < s.Length && s[i] is '\t' or ' ') i++; //skip indent
									g1:
									bool ok = s.Eq(i, '/') && s.Eq(i + 1, '/');
									if (ok) {
										i += 2;
										//is same type of comment?
										if (s.Eq(i, '/')) ok = s.Eq(++i, '/'); //is /// ?
										else ok = !_IsDotComment(s, i, out _); //is //. ?
									} else {
										//join adjacent blocks of comments that end with empty line
										if (i == s.Length) joinAt = 0; //join
										else if (s[i] is '\r' or '\n') { //empty line. Continue, and later either join or split here.
											joinAt = lineStart; joinNlines = nlines;
											while (++i < s.Length && s[i] <= ' ') { } //skip empty lines and indents
											goto g1;
										}
									}
									if (!ok) {
										if (joinAt > 0) { lineStart = joinAt; nlines = joinNlines; } //split
										i = lineStart;
										break;
									}
								}
								while (i < s.Length && s[i] != '\n') i++;
								if (i == s.Length) { nlines++; break; }
								i++;
							}
							if (nlines < 5) continue;
						}
						if (!_IsStartOfTrivia(isLineComment)) continue;
						_AddFoldPoints(isDocComment ? FoldKind.Doc : FoldKind.Comment, rangeStart + i0, rangeStart + i);
					}
					
					static bool _IsDotComment(RStr s, int j, out bool closing) {
						if (s.Eq(j, '.')) {
							if (closing = ++j < s.Length && s[j] == '.') j++;
							if (j == s.Length || s[j] <= ' ') return true; //must be at the end of line or followed by space (like //. comment). Else could be like //.Member
						} else closing = false;
						return false;
					}
					
					bool _IsStartOfTrivia(bool isLineComment) {
						//p2.First();
						int start = rangeStart + i0;
						var t = root.FindToken(start);
						var span = t.Span;
						//p2.Next();
						if (span.Contains(start)) { i = span.End - rangeStart; return false; }
#if true
						var v = t.FindTrivia(start);
						span = v.Span;
						if (span.End == 0) { Debug_.Print(start); return false; }
						bool ok = span.Start == start;
						if (!(ok && isLineComment)) i = span.End - rangeStart;
						//p2.Next();
						return ok;
#elif true //usually slightly slower, but in worst case could be much slower
						var v = t.Parent.FindTrivia(start);
						span = v.Span;
						if (span.End == 0) { Debug_.Print(start); return false; }
						bool ok = span.Start == start;
						if (!(ok && isLineComment)) i = span.End - rangeStart;
						return ok;
#else //slightly slower than above
						foreach (var v in t.GetAllTrivia()) {
							span = v.Span;
							if (span.Start == start) { if (!isLineComment) i = span.End - rangeStart; return true; }
							if (span.Start > start) break;
							if (span.End > start) { i = span.End - rangeStart; return false; }
						}
						return false;
#endif
					}
				}
			}
			if (ir == nr) break;
		}
		_PN('t');
		
		if (af != null) {
			af.Sort((x, y) => x.pos - y.pos);
			//remove redundant fold end points
			for (int i = 0, level = 0; i < af.Count; i++) {
				if (af[i].start) level++;
				else if (level > 0) level--;
				else af.RemoveAt(i--);
			}
			//print.it(af);
		}
		return af;
	}
	
	public static void Fold(SciCode doc, List<SciFoldPoint> af) {
		doc.aaaFoldingApply(af, SciTheme.Marker.Underline);
		doc.ERestoreEditorData_();
	}
	
	public static void InitFolding(SciCode doc) {
		doc.aaaFoldingInit(SciTheme.Margin.Fold, SciTheme.Marker.Underline);
	}
	
	[Flags]
	internal enum FoldKind { Member = 1, Type = 2, Region = 4, Comment = 8, Doc = 16, DotFold = 32, Disabled = 64, Statement = 128, Namespace = 256 }
	
	/// <summary>
	/// Fold points (start position and kind) of the last <see cref="GetFoldPoints"/>. Later used for the context menu.
	/// </summary>
	internal static readonly List<(int pos, FoldKind kind)> s_foldPoints = new();
}

partial class SciCode {
	internal void ERestoreEditorData_() {
		//print.it(_openState);
		if (_openState == _EOpenState.FoldingDone) return;
		var os = _openState; _openState = _EOpenState.FoldingDone;
		
		if (os is _EOpenState.NewFileFromTemplate) {
			if (_fn.IsScript) {
				var code = aaaText;
				if (!code.NE()) {
					//fold all //.
					for (int i = base.aaaLineCount - 1; --i >= 0;) {
						if (aaaFoldingLevel(i).isHeader) {
							int j = aaaLineEnd(false, i);
							if (aaaCharAt8(j - 1) == '.' && aaaCharAt8(j - 2) == '/') Call(SCI_FOLDLINE, i);
						}
					}
					
					if (code.RxMatch(@"//\.\.+\R\R?(?=\z|\R)", 0, out RXGroup g)) {
						aaaGoToPos(true, g.End);
					}
					//if (CodeInfo.GetContextAndDocument(out var cd, 0, true) && !cd.code.NE() && cd.document.GetSyntaxRootAsync().Result is CompilationUnitSyntax cu) {
					//	print.it(cu);
					//}
				}
			}
		} else if (os == _EOpenState.NewFileNoTemplate) {
		} else {
			//TODO2: test SCI_SCROLLVERTICAL
			
			//restore saved folding, some markers, scroll position and caret position
			if (App.Model.State.EditorGet(_fn, out _sed)) {
				int cp = aaaCurrentPos8;
				if (_sed.fold != null) {
					for (int i = _sed.fold.Length; --i >= 0;) EFoldLine(_sed.fold[i]);
					if (cp > 0) Call(SCI_ENSUREVISIBLEENFORCEPOLICY, aaaLineFromPos(false, cp));
				}
				//if (_sed.someMarker != null) {
				//	foreach (var v in _sed.someMarker) Call(SCI_MARKERADD, v, c_markerX);
				//}
				if (os != _EOpenState.Reopen) {
					if (_sed.top != 0 || _sed.pos != 0) {
						_sed.top = _sed.pos = 0;
						App.Model.State.EditorSave(_fn, _sed, true, false);
					}
				} else {
					int top = Math.Max(0, _sed.top), pos = Math.Clamp(_sed.pos, 0, aaaLen8);
					if (top + pos > 0 && cp == 0) {
						//workaround for:
						//	When reopening a non-first document, scrollbar position remains at the top, although scrolls the view.
						//	Scintilla calls SetScrollInfo(pos), but it does not work because still didn't call SetScrollInfo(max).
						//	Another possible workaround would be a timer, but even 50 ms is too small.
						Call(SCI_SETVSCROLLBAR, false);
						Call(SCI_SETVSCROLLBAR, true);
						
						if (top > 0) Call(SCI_SETFIRSTVISIBLELINE, Call(SCI_VISIBLEFROMDOCLINE, top));
						if (pos <= aaaLen8) {
							App.Model.EditGoBack.OnRestoringSavedPos();
							//aaaGoToPos(false, pos); //sometimes does not work well here (it also calls SCI_ENSUREVISIBLEENFORCEPOLICY)
							Call(SCI_GOTOPOS, pos);
						}
					}
				}
			}
		}
	}
	
	enum _EOpenState : byte { Open, Reopen, NewFileFromTemplate, NewFileNoTemplate, FoldingDone }
	_EOpenState _openState;
	
	/// <summary>
	/// Saves folding, markers, cursor position, etc.
	/// </summary>
	internal void ESaveEditorData_(bool closingDoc) {
		if (_openState < _EOpenState.FoldingDone) return; //if did not have time to open editor data, better keep old data than delete. Also if not a code file.
		
		var a = new List<int>();
		var x = new WorkspaceState.Editor {
			fold = _GetLines(31),
			//someMarker = _GetLines(c_markerBreakpoint),
		};
		if (!closingDoc) {
			x.pos = aaaCurrentPos8;
			x.top = Call(SCI_GETFIRSTVISIBLELINE);
			if (x.top > 0) x.top = Call(SCI_DOCLINEFROMVISIBLE, x.top); //save document line, because visible line changes after changing wrap mode or resizing in wrap mode etc. Never mind: the top visible line may be not at the start of the document line.
		}
		
		if (x.Equals(_sed, out bool changedState, out bool changedFolding)) return;
		_sed = x;
		App.Model.State.EditorSave(_fn, x, changedState, changedFolding);
		
		//Gets indices of lines containing markers or contracted folding points.
		//If marker 31, uses SCI_CONTRACTEDFOLDNEXT. Else uses SCI_MARKERNEXT; must be 0...24 (markers 25-31 are used for folding).
		int[] _GetLines(int marker/*, int skipLineFrom = 0, int skipLineTo = 0*/) {
			a.Clear();
			for (int i = 0; ; i++) {
				if (marker == 31) i = Call(SCI_CONTRACTEDFOLDNEXT, i);
				else i = Call(SCI_MARKERNEXT, i, 1 << marker);
				if (i < 0) break;
				a.Add(i);
			}
			return a.Count > 0 ? a.ToArray() : null;
		}
	}
	WorkspaceState.Editor _sed;
	
	public void EFoldLine(int line, bool unfold = false, bool andDescendants = false) {
		if (!aaaFoldingLevel(line).isHeader) return;
		
		if (unfold) {
			Call(andDescendants ? SCI_FOLDCHILDREN : SCI_FOLDLINE, line, 1);
			return;
		}
		
		if (0 != Call(SCI_GETFOLDEXPANDED, line)) {
			//get text for SCI_TOGGLEFOLDSHOWTEXT
			string s = aaaLineText(line), s2 = null;
			int i = CiUtil.SkipSpace(s, 0);
			if (!s.Eq(i, '#')) {
				if (!s.Eq(i, "//")) {
					int last = Call(SCI_GETLASTCHILD, line, -1);
					s = aaaLineText(last);
					if (s.Length > 2) if (s.Ends("*/") || (s.Ends("\";") && s[^3] != '\"')) s = s[^2..]; //`text*/` -> `*/` or `text";` -> `";`
					s2 = "... " + s;
				} else if (s.Eq(i, "///")) { //let s2 = summary text
					s_rxFold.summary1 ??= new regexp(@"\h*<summary>\h*$", RXFlags.ANCHORED);
					if (s_rxFold.summary1.IsMatch(s, (i + 3)..)) {
						i = aaaLineStart(false, line + 1);
						int len = aaaLen8;
						if (i < len) {
							const int maxLen = 100;
							s = aaaRangeText(false, i, Math.Min(len, i + maxLen + 10));
							int to = s.Find("</summary>");
							bool limited = to < 0;
							if (limited) to = Math.Min(s.Length, maxLen); //Min to avoid partial </summary> at the end
							s_rxFold.summary2 ??= new regexp(@"\h*///\h*\K.+");
							using (new StringBuilder_(out var b)) {
								foreach (var g in s_rxFold.summary2.FindAllG(s, 0, 0..to)) {
									if (b.Length > 0) b.Append(' ');
									b.Append(s, g.Start, g.Length);
								}
								if (limited) b.Append(" …");
								s2 = b.ToString();
							}
						}
					}
				}
			}
			
			if (s2 != null) aaaSetString(SCI_TOGGLEFOLDSHOWTEXT, line, s2);
			else Call(SCI_FOLDLINE, line);
		}
		
		if (andDescendants) {
			for (int last = Call(SCI_GETLASTCHILD, line, -1); ++line < last;) {
				EFoldLine(line);
			}
			//never mind: probably should not fold inside functions and statements.
		}
	}
	static (regexp summary1, regexp summary2) s_rxFold;
	
	/// <param name="modifiers">
	/// 0 - toggle this.
	/// Shift (1) - expand this and descendants.
	/// Ctrl (2) - toggle this and descendants.
	/// </param>
	void _FoldOnMarginClick(int pos8, int modifiers) {
		if (modifiers > 2) return;
		int line = Call(SCI_LINEFROMPOSITION, pos8);
		if (!aaaFoldingLevel(line).isHeader) return;
		if (modifiers == 1) {
			Call(SCI_FOLDCHILDREN, line, 1);
			return;
		}
		bool hide = 0 != Call(SCI_GETFOLDEXPANDED, line);
		EFoldLine(line, !hide, modifiers == 2);
		if (hide) {
			//move caret out of contracted region
			int pos = aaaCurrentPos8;
			if (pos > pos8) {
				int i = aaaLineEnd(false, Call(SCI_GETLASTCHILD, line, -1));
				if (pos <= i) aaaCurrentPos8 = pos8;
			}
		}
	}
	
	void _FoldContextMenu(int pos8 = -1) {
		if (!_fn.IsCodeFile) return;
		
		//get the fold kind for "Fold all of this kind"
		int headLine = aaaLineFromPos(false, pos8 < 0 ? aaaCurrentPos8 : pos8);
		if (!aaaFoldingLevel(headLine).isHeader) headLine = Call(SCI_GETFOLDPARENT, headLine);
		var kind = headLine < 0 ? 0 : _Folds().FirstOrDefault(o => o.line == headLine).kind;
		
		var m = new popupMenu();
		if (kind != default) {
			m["Fold all of this kind"] = o => _Fold(false, kind);
			m["Unfold all of this kind"] = o => _Fold(true, kind);
			m.Separator();
		}
		m["Fold functions, events"] = o => _Fold(false, CiFolding.FoldKind.Member);
		m["Fold regions"] = o => _Fold(false, CiFolding.FoldKind.Region);
		m["Fold //."] = o => _Fold(false, CiFolding.FoldKind.DotFold);
		m["Fold ///documentation"] = o => _Fold(false, CiFolding.FoldKind.Doc);
		m["Fold comments, #if"] = o => _Fold(false, CiFolding.FoldKind.Comment | CiFolding.FoldKind.Disabled);
		m["Fold all except types"] = o => _Fold(false, CiFolding.FoldKind.Comment | CiFolding.FoldKind.Disabled | CiFolding.FoldKind.Doc | CiFolding.FoldKind.DotFold | CiFolding.FoldKind.Member | CiFolding.FoldKind.Region);
		m.Separator();
		m["Unfold all"] = o => _Fold(true, 0); //not SCI_FOLDALL because need to skip meta
		
		m.Show(owner: AaWnd);
		
		void _Fold(bool expand, CiFolding.FoldKind kind) {
			var meta = MetaComments.FindMetaComments(aaaText);
			int metaLine = meta.end == 0 ? -1 : aaaLineFromPos(true, meta.start);
			var a = _Folds().ToArray();
			List<int> a2 = new();
			for (int i = 0; i < a.Length; i++) {
				var v = a[i];
				if (v.line == metaLine) continue;
				if (kind != 0) {
					if (!kind.Has(v.kind)) continue;
					//together with members and types also fold/unfold their ///documentation
					if (kind is CiFolding.FoldKind.Member or CiFolding.FoldKind.Type) {
						if (i > 0 && a[i - 1].kind == CiFolding.FoldKind.Doc) {
							int line2 = a[i - 1].line;
							if (v.line - 1 == Call(SCI_GETLASTCHILD, line2, -1)) a2.Add(line2);
						}
					}
				}
				a2.Add(v.line);
			}
			
			//In some cases something changes current pos. Also scrolls and unfolds. Sometimes then bad styling.
			//	Difficult to find the reason.
			//	Workaround: hide/show in this order.
			if (expand) {
				for (int i = 0; i < a2.Count; i++) {
					EFoldLine(a2[i], expand);
				}
			} else {
				for (int i = a2.Count; --i >= 0;) {
					EFoldLine(a2[i], expand);
				}
				
				//move caret out of contracted region
				int line = aaaLineFromPos(false, aaaCurrentPos8), line0 = line;
				while (0 == Call(SCI_GETLINEVISIBLE, line)) {
					int i = Call(SCI_GETFOLDPARENT, line);
					if ((uint)i >= line) break;
					line = i;
				}
				if (line < line0) aaaCurrentPos8 = aaaLineStart(false, line);
			}
		}
		
		//Gets an ordered copy of CiFolding.s_foldPoints with offsets converted to line indices.
		//	GetFoldPoints does not do it because it would make slower there.
		IEnumerable<(int line, CiFolding.FoldKind kind)> _Folds()
			=> CiFolding.s_foldPoints.OrderBy(o => o.pos).Select(o => (line: aaaLineFromPos(true, o.pos), kind: o.kind));
	}
}


================================================
FILE: Au.Editor/Edit/CiGoTo.cs
================================================
//#define SG_SYMBOL //sourcegraph type:symbol. Almost unusable (2023-07-04). Does not find many types, cannot search for "member X in class Y", cannot combine with nonsymbol search, incorrect and possibly unstable select:symbol.

extern alias CAW;

using System.Net;
using System.Windows;
using System.Windows.Controls;
using Au.Controls;

using Microsoft.CodeAnalysis;
using CAW::Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Text;
using Microsoft.CodeAnalysis.Shared.Extensions;
using CAW::Microsoft.CodeAnalysis.Shared.Extensions;
using System.Text.RegularExpressions;

//FUTURE: try source link. Like now VS.

namespace LA;

class CiGoTo {
	struct _SourceLocation {
		public _SourceLocation(string file, int line, int column) {
			this.file = file; this.line = line; this.column = column;
		}
		public string file;
		public int line, column;
	}
	
	bool _canGoTo, _inSource;
	//if in source
	List<_SourceLocation> _sourceLocations;
	//if in metadata
	string _assembly, _repo, _type, _kind, _prefix, _member, _namespace, _alt;
	int _flags;
	//1 with github can use symbol: with member; eg github supports only methods.
	//2 can use "public ... Member"; eg cannot for interface and enum.
	//4 with github can use symbol: with type; eg github supports only class and struct.
	
	/// <summary>
	/// true if can go to the symbol source. Then caller eg can add link to HTML.
	/// May return true even if can't go to. Then on link click nothing happens. Next time will return false.
	/// </summary>
	public bool CanGoTo => _canGoTo;
	
	CiGoTo(bool inSource) { _canGoTo = true; _inSource = inSource; }
	
	/// <summary>
	/// Gets info required to go to symbol source file/line/position or website.
	/// This function is fast. The slower code is in the <b>GoTo</b> functions.
	/// </summary>
	public CiGoTo(ISymbol sym) {
		if (_inSource = sym.IsFromSource()) {
			_sourceLocations = new();
			foreach (var loc in sym.Locations) {
				Debug_.PrintIf(!loc.IsVisibleSourceLocation());
				//if (!loc.IsVisibleSourceLocation()) continue;
				
				var v = loc.GetLineSpan();
				_sourceLocations.Add(new _SourceLocation(v.Path, v.StartLinePosition.Line, v.StartLinePosition.Character));
			}
			_canGoTo = _sourceLocations.Count > 0;
		} else {
			var asm = sym.ContainingAssembly; if (asm == null) return;
			if (sym is INamespaceSymbol) return; //not useful
			_canGoTo = true;
			_assembly = asm.Name;
			
			if (asm.GetAttributes().FirstOrDefault(o => o.AttributeClass.Name == "AssemblyMetadataAttribute" && "RepositoryUrl" == o.ConstructorArguments[0].Value as string)?.ConstructorArguments[1].Value is string s && s.Length > 0) {
				if (s.Starts("git:")) s = s.ReplaceAt(0, 3, "https"); //eg .NET
				if (s.Starts("https://github.com/")) _repo = s.Ends(".git") ? s[19..^4] : s[19..];
				Debug_.PrintIf(_repo.NE(), s);
			}
			
			//Unfortunately the github search engine is so bad. Gives lots of garbage. Randomly returns not all results.
			//To remove some garbage, can include namespace, filename, path (can be partial, without filename).
			//There is no best way for all casses. GoTo() will show UI, and users can try several alternatives.
			//Also tried github API. Can get search results, but not always can find the match in the garbage.
			//	The returned code snippets are small and often don't contain the search words. Can download entire file, but it's too slow and dirty.
			//	The test code is in some script. Tested octokit too, but don't need it, it's just wraps the REST API, which is easy to use.
			//At first this class used referencesource, not github. Can jump directly to the class or method etc.
			//	But it seems it is now almost dead. Many API either don't exist or are obsolete (I guess) or only Unix version.
			//	And it was only for .NET and Roslyn.
			//2023-07-02: GitHub search improved. Supports regex and partially symbol: (symbol definitions). It seems always shows all results.
			//	Tested: Supports symbol: for: class, interface, method.
			//		Not for: property, event, delegate, enum, struct. For namespace only if NS{} but not if NS.NS{} or NS;.
			
			if (sym is not INamedTypeSymbol ts) {
				ts = sym.ContainingType;
				//if (ts.IsExtension) ts = ts.ContainingType; //FUTURE
				_member = sym.Name;
				if (_member.Starts('.')) _member = null; //".ctor"
				else {
					if (sym is IMethodSymbol ims && ims.MethodKind is MethodKind.Ordinary or MethodKind.ReducedExtension) _flags |= 1;
					if (ts.TypeKind is TypeKind.Class or TypeKind.Struct) _flags |= 2;
				}
			}
			ts = ts.OriginalDefinition; //eg List<int> -> List<T>
			
			_type = ts.Name; //get name like Int32 or List. GetShortName gets eg int, but we need Int32.
			if (ts.TypeKind is TypeKind.Class or TypeKind.Interface && !ts.IsRecord) _flags |= 4;
			
#if SG_SYMBOL
			if (sym is INamedTypeSymbol) {
				_kind = ts.TypeKind switch {
					TypeKind.Class => "class",
					TypeKind.Struct => "struct",
					TypeKind.Enum => "enum",
					TypeKind.Interface => "interface",
					TypeKind.Delegate => "method",
					_ => null
				};
			} else {
				_kind = sym.Kind switch {
					SymbolKind.Event => "event",
					SymbolKind.Field => "variable",
					SymbolKind.Method => "method",
					SymbolKind.Property => "property",
					_ => null
				};
				Debug_.PrintIf(_kind == null, sym.Kind);
			}
#endif
			
			_prefix = ts.TypeKind switch {
				TypeKind.Class => ts.IsRecord ? "(record class|record)" : "class",
				TypeKind.Struct => "struct",
				TypeKind.Enum => "enum",
				TypeKind.Interface => "interface",
				//TypeKind.Delegate => "delegate " + ts.DelegateInvokeMethod?.ReturnType.GetShortName(), //never mind: can be generic or qualified. Rare.
				TypeKind.Delegate => "delegate .+?",
				_ => null
			};
			
			_namespace = ts.ContainingNamespace.QualifiedName();
			
			//for source.dot.net need exact generic, preferably fully qualified, like Namespace.List<T>
			_alt = ts.ToDisplayString(s_sdnSymbolFormat);
		}
	}
	
	static SymbolDisplayFormat s_sdnSymbolFormat = new(
		   globalNamespaceStyle: SymbolDisplayGlobalNamespaceStyle.OmittedAsContaining,
		   typeQualificationStyle: SymbolDisplayTypeQualificationStyle.NameAndContainingTypesAndNamespaces,
		   genericsOptions: SymbolDisplayGenericsOptions.IncludeTypeParameters);
	
	string _GetLinkData() {
		if (!_canGoTo) return null;
		if (_inSource) {
			var b = new StringBuilder();
			foreach (var v in _sourceLocations) b.AppendFormat("|{0}?{1},{2}", v.file, v.line, v.column);
			return b.ToString();
		} else {
			return $"|\a{_assembly}\a{_repo}\a{_type}\a{_member}\a{_namespace}\a{_kind}\a{_prefix}\a{_alt}\a{_flags}";
		}
	}
	
	/// <summary>
	/// Gets link data string for <see cref="LinkGoTo"/>. Returns null if unavailable.
	/// This function is fast. The slower code is in the <b>GoTo</b> function.
	/// </summary>
	public static string GetLinkData(ISymbol sym) => new CiGoTo(sym)._GetLinkData();
	
	/// <summary>
	/// Opens symbol source file/line/position or shows github search UI. Used on link click.
	/// </summary>
	/// <param name="linkData">String returned by <see cref="GetLinkData"/>.</param>
	public static void LinkGoTo(string linkData) {
		if (linkData == null) return;
		bool inSource = !linkData.Starts("|\a");
		var g = new CiGoTo(inSource);
		if (inSource) {
			var a = linkData.Split('|');
			g._sourceLocations = new List<_SourceLocation>();
			for (int i = 1; i < a.Length; i++) {
				var s = a[i];
				int line = s.LastIndexOf('?'), column = s.LastIndexOf(',');
				g._sourceLocations.Add(new _SourceLocation(s.Remove(line), s.ToInt(line + 1), s.ToInt(column + 1)));
			}
		} else {
			var a = linkData.Split('\a');
			g._assembly = a[1];
			g._repo = a[2];
			g._type = a[3];
			g._member = a[4];
			g._namespace = a[5];
			g._kind = a[6];
			g._prefix = a[7];
			g._alt = a[8];
			g._flags = a[9].ToInt();
		}
		g.GoTo();
	}
	
	/// <summary>
	/// Opens symbol source file/line/position or website.
	/// If need to open website, runs async task.
	/// </summary>
	public void GoTo() {
		if (!_canGoTo) return;
		if (_inSource) {
			if (_sourceLocations.Count == 1) {
				_GoTo(_sourceLocations[0]);
			} else {
				int i = popupMenu.showSimple(_sourceLocations.Select(v => v.file + ", line " + v.line.ToString()).ToArray(), rawText: true);
				if (i > 0) _GoTo(_sourceLocations[i - 1]);
			}
			
			static void _GoTo(_SourceLocation v) => App.Model.OpenAndGoTo(v.file, v.line, v.column);
		} else {
			_CodeSearchDialog();
		}
	}
	
	void _CodeSearchDialog() {
		AppSettings.gotoAsm_t asm = new(), asmSaved = null;
		App.Settings.ci_gotoAsm?.TryGetValue(_assembly, out asmSaved);
		asmSaved ??= new();
		asmSaved.repo ??= _repo;
		
		var bd = new wpfBuilder("Source code search").WinSize(450).Columns(-1);
		bd.Window.UseLayoutRounding = true; //workaround for: text of OK etc buttons not centered vertically
		bd.Row(0).Add(out TabControl tc);
		
		wpfBuilder _Page(string name, WBPanelType panelType = WBPanelType.Grid) {
			var tp = new TabItem { Header = name };
			tc.Items.Add(tp);
			return new wpfBuilder(tp, panelType).Options(bindLabelVisibility: true);
		}
		
		bd.R.StartGrid<KGroupBox>("Repository info of this assembly").Columns(70, -1);
		bd.R.Add("Assembly", out Label _, _assembly).And(50).Add(out KCheckBox cSharp, "C#").Checked(asmSaved.csharp);
		bd.R.Add("Repository", out TextBox tRepo, asmSaved.repo)
			.Tooltip("Repository name, like owner/repo.\nIt's the part of the github URL.");
		bd.R.Add("Path", out TextBox tPath, asmSaved.path).Tooltip("File paths must match this regex.\nExample: src/libraries");
		bd.R.Add("Context", out TextBox tContext, asmSaved.context).Tooltip(@"Let the sourcegraph query string start with this. Not used with github. Default: context:global repo:^github\.com/");
		bd.End();
		
		bd.AddOkCancel(apply: "Search");
		bd.End();
		
		bd.OkApply += _ => {
			asm.repo = tRepo.TextOrNull();
			asm.path = tPath.TextOrNull();
			asm.context = tContext.TextOrNull();
			asm.csharp = cSharp.IsChecked;
			if (asm.repo == _repo && asm.path == null && asm.context == null && asm.csharp) {
				//print.it("remove");
				App.Settings.ci_gotoAsm?.Remove(_assembly);
			} else if (asm != asmSaved) {
				//print.it("save");
				(App.Settings.ci_gotoAsm ??= new())[_assembly] = new() { repo = asm.repo == _repo ? null : asm.repo, path = asm.path, context = asm.context, csharp = asm.csharp };
				asmSaved = asm with { };
			}
			
			App.Settings.ci_gotoTab = tc.SelectedIndex;
		};
		
#if SG_SYMBOL
		const int c_sgSymbol = 0;
		const int c_sgCode = 1;
		const int c_github = 2;
#else
		const int c_sgCode = 0;
		const int c_github = 1;
#endif
		
		if (App.Settings.ci_gotoTab is int itab && itab > 0 && itab <= c_github) tc.SelectedIndex = itab;
		
#if SG_SYMBOL
		_SourcegraphSymbol();
#endif
		_Sourcegraph();
		_Github();
		_Sourcedotnet();
		
		bd.Window.Topmost = true;
		bd.WinSaved(s_wndpos, o => s_wndpos = o);
		bd.Window.Show();
		
#if SG_SYMBOL //note: some parts of this code may be obsolete or little tested
		void _SourcegraphSymbol() {
			var b = _Page("soucegraph symbol");
			
			_AddInfo(b, "Creates and opens a sourcegraph.com symbol search URL.  [", new WBLink("syntax", "https://docs.sourcegraph.com/code_search/reference/queries"), "]");
			
			b.R.Add("Symbol", out TextBox tSymbol, $@"\b{_member.NE() ? _type : _member)}\b");
			TextBox tType = null; KCheckBox cType = null;
			if (!_member.NE()) {
				b.R.Add(out cType, "Type", out tType, $@"\b{_type}\b");
				cType.IsChecked = true;
			}
			b.R.Add(out KCheckBox cKind, "Kind", out TextBox tKind, _kind); cKind.IsChecked = _kind != null;
			b.R.Add(out KCheckBox cText, "Text", out TextBox tText, $@"\bnamespace {Regex.Escape(_namespace)}\b").Tooltip("The file must also contain this text or match this /regex/"); ;
			b.R.Add(out KCheckBox cFile, "File", out TextBox tFile, _type).Tooltip("The file name or path must contain this text or match this /regex/");
			b.R.Add(out KCheckBox cAlso, "Also", out TextBox tAlso, $"NOT file:{_NotPath()}").Tooltip("Append this to the query");
			cAlso.IsChecked = true;
			
			b.End();
			
			bd.OkApply += _ => {
				if (tc.SelectedIndex != c_sgSymbol) return;
				var q = new StringBuilder(@"patterntype:regexp case:yes context:global repo:^github\.com/");
				if (!asm.repo.NE()) q.Append(Regex.Escape(asm.repo)).Append('$');
				if (asm.csharp) q.Append(" lang:C#");
				q.Append(" type:symbol ").Append(tSymbol.Text);
				if (cType?.IsChecked == true && !tType.Text.NE()) q.Append(" AND ").Append(tType.Text);
				if (cText.IsChecked && !tText.Text.NE()) q.Append(" AND ").Append(tText.Text);
				if (cKind.IsChecked && !tKind.Text.NE()) q.Append(" select:symbol." + tKind.Text);
				if (cFile.IsChecked && !tFile.Text.NE()) q.Append(" file:").Append(tFile.Text);
				if (asm.path != null) q.Append(" file:").Append(asm.path);
				if (cAlso.IsChecked && !tAlso.Text.NE()) q.Append(' ').Append(tAlso.Text);
				//print.it(q);
				var url = $"https://sourcegraph.com/search?q={WebUtility.UrlEncode(q.ToString())}";
				run.itSafe(url);
			};
		}
#endif
		
		void _Sourcegraph() {
			var b = _Page("sourcegraph");
			
			b.xAddInfoBlockF($"Creates and opens a sourcegraph.com search URL.  [<a href='https://docs.sourcegraph.com/code_search/reference/queries'>syntax</a>]");
			
			b.R.Add("Type", out TextBox tType, $@"\b{_prefix}\s+{_type}\b"); //note: don't use unescaped space. Then splits into too: "\b{_prefix}" and "{_type}\b"
			b.R.Add("Member", out TextBox tMember);
			if (_member.NE()) b.Hidden(); else tMember.Text = 0 != (_flags & 2) ? $@"\bpublic\s.+?\s{_member}\b" : $@"\b{_member}\b";
			b.R.Add(out KCheckBox cText, "Text").Add(out TextBox tText, $@"\bnamespace\s+{Regex.Escape(_namespace)}\b").LabeledBy().Tooltip("The code must also match this regex"); ;
			//b.R.Add(out KCheckBox cText, "Text", out TextBox tText, $@"\bnamespace\s+{Regex.Escape(_namespace)}\b").Tooltip("The code must also match this regex"); ;
			b.R.Add(out KCheckBox cFile, "File").Add(out TextBox tFile, _type).LabeledBy().Tooltip("The file name or path must match this regex");
			b.R.Add(out KCheckBox cAlso, "Also").Add(out TextBox tAlso, $"NOT file:{_NotPath()}").LabeledBy().Tooltip("Append this to the query");
			cAlso.IsChecked = true;
			
			b.End();
			
			bd.OkApply += _ => {
				if (tc.SelectedIndex != c_sgCode) return;
				var q = new StringBuilder("patterntype:regexp case:yes "); //note: case:yes even if !asm.csharp
				q.Append(asm.context ?? @"context:global repo:^github\.com/");
				if (!asm.repo.NE()) q.Append(Regex.Escape(asm.repo)).Append('$');
				if (asm.csharp) q.Append(" lang:C#");
				q.Append(' ');
				if (!tMember.Text.NE()) {
					q.Append(tMember.Text);
					if (!tType.Text.NE()) q.Append($" file:has.content({tType.Text})");
					if (cText.IsChecked && !tText.Text.NE()) q.Append($" file:has.content({tText.Text})");
				} else {
					q.Append(tType.Text);
				}
				if (cFile.IsChecked && !tFile.Text.NE()) q.Append(" file:").Append(_RxEscapeSpaces(tFile.Text));
				if (asm.path != null) q.Append(" file:").Append(_RxEscapeSpaces(asm.path));
				if (cAlso.IsChecked && !tAlso.Text.NE()) q.Append(' ').Append(tAlso.Text);
				//print.it(q);
				var url = $"https://sourcegraph.com/search?q={WebUtility.UrlEncode(q.ToString())}";
				run.itSafe(url);
				
				static string _RxEscapeSpaces(string s) => s.RxReplace(@"(?<!\\) ", @"\ ");
			};
		}
		
		void _Github() {
			var b = _Page("github");
			
			Action notes = () => dialog.show("GitHub code search notes", "Results may be incomplete. Try to reload the page.\nSkips large source files.", owner: bd.Window);
			b.xAddInfoBlockF($"Creates and opens a github.com search URL.  [<a href='https://docs.github.com/en/search-github/github-code-search/understanding-github-code-search-syntax'>syntax</a>]  [<a {notes}>notes</a>]");
			
			b.R.Add("Type", out TextBox tType, 0 != (_flags & 4) && _member.NE() ? $@"symbol:/(?-i)\b{_type}\b/ /(?-i)\b{_prefix} {_type}\b/" : $@"/(?-i)\b{_prefix} {_type}\b/");
			b.R.Add("Member", out TextBox tMember).Hidden(_member.NE());
			if (!_member.NE()) tMember.Text = 0 != (_flags & 1) ? $@"symbol:/(?-i)\b{_member}\b/"
											: 0 != (_flags & 2) ? $@"/(?-i)\bpublic .+? {_member}\b/" //member of class or struct
											: $@"/(?-i)\b{_member}\b/"; //member of interface or enum
			b.R.Add(out KCheckBox cText, "Text").Add(out TextBox tText, $"\"namespace {_namespace}\"").LabeledBy().Tooltip("Append this to the query");
			b.R.Add(out KCheckBox cFile, "File").Add(out TextBox tFile, _type).LabeledBy().Tooltip("The file name or path must contain this text or match /regex/");
			b.R.Add(out KCheckBox cAlso, "Also").Add(out TextBox tAlso, $"NOT path:/{_NotPath()}/").LabeledBy().Tooltip("Append this to the query");
			cAlso.IsChecked = true;
			
			b.End();
			
			bd.OkApply += _ => {
				if (tc.SelectedIndex != c_github) return;
				var q = new StringBuilder();
				if (!asm.repo.NE()) q.Append($"repo:{asm.repo} ");
				if (asm.csharp) q.Append("lang:C# ");
				if (!tMember.Text.NE()) q.Append(tMember.Text).Append(' '); //must be before type for better results
				q.Append(tType.Text);
				if (cText.IsChecked && !tText.Text.NE()) q.Append(' ').Append(tText.Text);
				if (cFile.IsChecked && !tFile.Text.NE()) q.Append($" path:{tFile.Text}");
				if (asm.path != null) q.Append($" path:/{asm.path.RxReplace(@"(?<!\\)/", @"\/")}/"); //tested: works well when cFile specified too (both use path:)
				if (cAlso.IsChecked && !tAlso.Text.NE()) q.Append(' ').Append(tAlso.Text);
				//print.it(q);
				var url = $"https://github.com/search?q={WebUtility.UrlEncode(q.ToString())}";
				//print.it(url);
				run.itSafe(url);
			};
		}
		
		void _Sourcedotnet() {
			var tp = new TabItem { Header = "source.dot.net" };
			tc.Items.Add(tp);
			tc.SelectionChanged += (_, e) => {
				if (tc.SelectedIndex == tc.Items.Count - 1) {
					var s = "https://source.dot.net/#q=" + _alt;
					if (_member != null) s = s + "." + _member;
					run.itSafe(s);
					bd.Window.Close();
				}
			};
		}
		
		string _NotPath() => @"\b[Tt]est|\b[Gg]enerat|\b[Uu]nix\b|\/ref\/" + (_repo == "dotnet/wpf" ? @"|\/cycle-breakers\/" : null); //note: sourcegraph does not support (?i) and (?-i)
	}
	static string s_wndpos;
	
	//This was used with referencesource. It seems don't need it now.
	///// <summary>
	///// If _filename or its ancestor type is forwarded to another assembly, replaces _assembly with the name of that assembly.
	///// For example initially we get that String is in System.Runtime. But actually it is in System.Private.CoreLib, and its name must be passed to https://source.dot.net.
	///// Speed: usually < 10 ms.
	///// </summary>
	//void _GetAssemblyNameOfForwardedType() {
	//	var path = folders.NetRuntimeBS + _assembly + ".dll";
	//	if (!(filesystem.exists(path).File || filesystem.exists(path = folders.NetRuntimeDesktopBS + _assembly + ".dll").File)) return;
	
	//	var alc = new System.Runtime.Loader.AssemblyLoadContext(null, true);
	//	try {
	//		var asm = alc.LoadFromAssemblyPath(path);
	//		var ft = asm.GetForwardedTypes()?.FirstOrDefault(ty => ty.FullName == _filename);
	//		if (ft != null) _assembly = ft.Assembly.GetName().Name;
	//	}
	//	catch (Exception ex) { Debug_.Print(ex); }
	//	finally { alc.Unload(); }
	//}
	
	public static void GoToDefinition() {
		if (!CodeInfo.GetContextAndDocument(out var cd, metaToo: true)) return;
		var (sym, _, helpKind, token) = CiUtil.GetSymbolEtcFromPos(cd);
		if (sym != null) {
			if (sym is IParameterSymbol or ITypeParameterSymbol && !sym.IsInSource()) return;
			if (_GetFoldersPath(token, out var fp, sym)) {
				run.itSafe(fp);
			} else {
				var g = new CiGoTo(sym);
				if (g.CanGoTo) g.GoTo();
			}
		} else if (cd.sci.aaaHasSelection) {
			_Open(cd.sci.aaaSelectedText());
		} else if (helpKind == CiUtil.HelpKind.String && token.Parent.IsKind(SyntaxKind.StringLiteralExpression)) {
			_Open(token.ValueText, token);
		} else if (helpKind == CiUtil.HelpKind.None && cd != null) { //maybe path in comments or disabled code
			int pos = cd.pos;
			if (pos < cd.meta.end && pos > cd.meta.start) {
				foreach (var t in MetaComments.EnumOptions(cd.code, cd.meta)) {
					if (pos >= t.valueStart && pos <= t.valueEnd) {
						_Meta(t.Name, t.Value);
						break;
					}
				}
			} else {
				var root = cd.syntaxRoot;
				var trivia = root.FindTrivia(pos); if (trivia.RawKind == 0) return;
				var code = cd.code;
				var span = trivia.Span;
				int from = pos, to = from;
				static bool _IsPathOrUrlChar(char c) => !pathname.isInvalidPathChar(c) || c == '?';
				while (to < span.End && _IsPathOrUrlChar(code[to])) to++;
				while (from > span.Start && _IsPathOrUrlChar(code[from - 1])) from--;
				while (to > pos && code[to - 1] is <= ' ' or '.' or ';' or ',') to--; //trim right
				while (from < pos && code[from] <= ' ') from++; //trim left
				if (to == from) return;
				//rejected: try to find path even if without "". How to know which text part it is? Better let the user select the text.
				if (!(code.Eq(from - 1, '"') && code.Eq(to, '"'))) return;
				_Open(code[from..to]);
			}
		}
		
		//if s is script, opens it. If file path, selects in Explorer. If folder path, opens the folder. If URL, opens the web page.
		static bool _Open(string s, SyntaxToken token = default) {
			if (s.NE()) return false;
			if (pathname.isUrl(s)) {
				if (0 == s.Starts(false, "http:", "https:")) return false;
				run.itSafe(s);
			} else {
				if (!pathname.isFullPathExpand(ref s, strict: false)) {
					var f = App.Model.Find(s);
					if (f != null) { App.Model.SetCurrentFile(f); return true; }
					if (token.RawKind == 0 || !_GetFoldersPath(token, out var fp, null)) return false;
					s = pathname.combine(fp, s);
				}
				var fe = filesystem.exists(s); if (!fe) return false;
				if (fe.Directory) run.itSafe(s);
				else run.selectInExplorer(s);
			}
			return true;
		}
		
		//If t is "string" in 'folders.Folder + "string"' or Folder in 'folders.Folder', gets folder path and return true.
		static bool _GetFoldersPath(SyntaxToken t, out string s, ISymbol sym) {
			s = null;
			bool isString = sym is null;
			if (isString) {
				t = t.GetPreviousToken(); if (!t.IsKind(SyntaxKind.PlusToken)) return false;
				t = t.GetPreviousToken();
			}
			if (!t.IsKind(SyntaxKind.IdentifierToken)) return false;
			var s2 = t.Text;
			t = t.GetPreviousToken(); if (!t.IsKind(SyntaxKind.DotToken)) return false;
			t = t.GetPreviousToken(); if (!t.IsKind(SyntaxKind.IdentifierToken) || t.Text != "folders") return false;
			s = folders.getFolder(s2);
			if (s is null) return false;
			if (true == sym?.IsInSource()) {
				return 2 == popupMenu.showSimple("1 Go to definition|2 Open folder");
			}
			return true;
		}
		
		void _Meta(string name, string value) {
			FNFind? ffn = name switch { "c" => FNFind.Class, "pr" or "preBuild" or "postBuild" => FNFind.CodeFile, "sign" or "manifest" => FNFind.File, "file" or "resource" or "icon" => FNFind.Any, _ => null };
			if (ffn is { } ff) {
				var f = MetaComments.FindFile(cd.sci.EFile, value, ff);
				if (f == null && name is "c") f = MetaComments.FindFile(cd.sci.EFile, value, FNFind.Folder);
				if (f != null) App.Model.SetCurrentFile(f);
			} else if (name == "nuget") {
				DNuget.ShowSingle(value);
			} else if (name == "com") {
				var path = App.Model.WorkspaceDirectory + @"\.interop\" + value;
				if (filesystem.exists(path)) run.selectInExplorer(path);
			} else {
				_Open(value);
			}
		}
	}
	
	public static void GoToBase() {
		var (sym, cd) = CiUtil.GetSymbolFromPos(andZeroLength: true);
		if (sym is null) return;
		List<ISymbol> a = new();
		if (sym is INamedTypeSymbol nt && nt.TypeKind is TypeKind.Class or TypeKind.Interface) {
			if (nt.TypeKind == TypeKind.Interface) {
				a.AddRange(nt.AllInterfaces);
			} else if (nt.BaseType != null) { //else object
				a.AddRange(nt.GetBaseTypes().SkipLast(1).Concat(nt.AllInterfaces));
			}
		} else if (sym.Kind is SymbolKind.Method or SymbolKind.Property or SymbolKind.Event) {
			a.AddRange(CAW::Microsoft.CodeAnalysis.FindSymbols.FindReferences.BaseTypeFinder.FindOverriddenAndImplementedMembers(sym, cd.document.Project.Solution, default));
		}
		if (a.Count == 0) return;
		if (a.Count == 1) sym = a[0];
		else {
			int i = popupMenu.showSimple(a.Select(o => o.Name).ToArray(), rawText: true);
			if (--i < 0) return;
			sym = a[i];
		}
		var g = new CiGoTo(sym);
		if (g.CanGoTo) g.GoTo();
	}
}


================================================
FILE: Au.Editor/Edit/CiPopupList.cs
================================================
using Au.Controls;
using System.Windows.Controls;
using System.Windows;
using System.Windows.Controls.Primitives;
using System.Windows.Automation;

namespace LA;

class CiPopupList {
	KPopup _popup;
	DockPanel _panel;
	KTreeView _tv;
	StackPanel _tb;
	
	SciCode _doc;
	CiCompletion _compl;
	List<CiComplItem> _a;
	List<CiComplItem> _av;
	KCheckBox[] _kindButtons;
	KCheckBox _groupButton;
	Button _unimportedButton;
	bool _groupsEnabled, _winApi;
	List<string> _groups;
	CiPopupText _textPopup;
	timer _tpTimer;
	
	public KPopup PopupWindow => _popup;
	
	///// <summary>
	///// The child list control.
	///// </summary>
	//public KTreeView Control => _tv;
	
	public CiPopupList(CiCompletion compl) {
		_compl = compl;
		
		_tv = new KTreeView {
			ItemMarginLeft = 20,
			//HotTrack = true, //no
			CustomDraw = new _CustomDraw(this),
			//test = true
		};
		_tv.ItemActivated += _tv_ItemActivated;
		_tv.SelectedSingle += _tv_SelectedSingle;
		
		_tb = new StackPanel { Background = SystemColors.ControlBrush };
		
		var cstyle = Application.Current.FindResource(ToolBar.CheckBoxStyleKey) as Style;
		var bstyle = Application.Current.FindResource(ToolBar.ButtonStyleKey) as Style;
		
		var kindNames = CiUtil.ItemKindNames;
		_kindButtons = new KCheckBox[kindNames.Length];
		for (int i = 0; i < kindNames.Length; i++) {
			_AddButton(_kindButtons[i] = new(), kindNames[i], CiComplItem.ImageResource((CiItemKind)i), _KindButton_Click);
		}
		
		_tb.Children.Add(new Separator());
		
		_AddButton(_groupButton = new() { IsChecked = App.Settings.ci_complGroup }, "Group by namespace or inheritance", "resources/ci/groupby.xaml", _GroupButton_Click);
		_AddButton(_unimportedButton = new(), "Show more types or extension methods (Ctrl+Space)", "resources/ci/expandscope.xaml", _UnimportedButton_Click);
		
		//var options = new Button();
		//options.Click += _Options_Click;
		//_AddButton(options, "Options", );
		
		void _AddButton(ButtonBase b, string text, string image, RoutedEventHandler click) {
			b.Style = (b is CheckBox) ? cstyle : bstyle;
			b.Content = ResourceUtil.GetWpfImageElement(image);
			b.ToolTip = text;
			AutomationProperties.SetName(b, text);
			b.Focusable = false; //would close popup
			if (b is KCheckBox c) c.CheckChanged += click; else b.Click += click;
			_tb.Children.Add(b);
		}
		
		_panel = new DockPanel { Background = SystemColors.WindowBrush };
		DockPanel.SetDock(_tb, Dock.Left);
		_panel.Children.Add(_tb);
		_panel.Children.Add(_tv);
		_popup = new KPopup {
			Size = (300, 360),
			Content = _panel,
			CloseHides = true,
			Name = "Ci.Completion",
			WindowName = "LA completion list",
		};
		
		_textPopup = new CiPopupText(CiPopupText.UsedBy.PopupList);
		_tpTimer = new timer(_ShowTextPopup);
	}
	
	private void _KindButton_Click(object sender, RoutedEventArgs e) {
		if (_a == null) return;
		int kindsChecked = 0, kindsVisible = 0;
		for (int i = 0; i < _kindButtons.Length; i++) {
			var v = _kindButtons[i];
			if (v.IsVisible) {
				kindsVisible |= 1 << i;
				if (v.IsChecked == true) kindsChecked |= 1 << i;
			}
		}
		if (kindsChecked == 0) kindsChecked = kindsVisible;
		foreach (var v in _a) {
			if (0 != (kindsChecked & (1 << (int)v.kind))) v.hidden &= ~CiComplItemHiddenBy.Kind; else v.hidden |= CiComplItemHiddenBy.Kind;
		}
		UpdateVisibleItems();
	}
	
	private void _GroupButton_Click(object sender, RoutedEventArgs e) {
		_groupsEnabled = (sender as KCheckBox).IsChecked && _groups != null;
		_SortAndSetControlItems();
		this.SelectedItem = null;
		_tv.Redraw(true);
		App.Settings.ci_complGroup = _groupButton.IsChecked == true;
	}
	
	private void _UnimportedButton_Click(object sender, RoutedEventArgs e) {
		App.Dispatcher.InvokeAsync(() => _compl.ShowList());
	}
	
	//private void _Options_Click(object sender, RoutedEventArgs e) {
	//	var m = new popupMenu();
	//	//m[""] = o => ;
	//}
	
	private void _tv_ItemActivated(TVItemEventArgs e) {
		_compl.Commit(_doc, _av[e.Index]);
		Hide();
	}
	
	private void _tv_SelectedSingle(object sender, int index) {
		if ((uint)index < _av.Count) {
			var ci = _av[index];
			//print.it(ci.ci.ProviderName, ci.Provider);
			if (ci.Provider == CiComplProvider.XmlDoc) return;
			_tpTimer.Tag = ci;
			_tpTimer.After(300);
			_textPopup.Text = null;
		} else {
			_textPopup.Hide();
			_tpTimer.Stop();
		}
	}
	
	void _ShowTextPopup(timer t) {
		var ci = t.Tag as CiComplItem;
		var text = _compl.GetDescriptionDoc(ci, 0);
		if (text == null) return;
		_textPopup.Text = text;
		_textPopup.OnLinkClick = (ph, e) => {
			if (e.ToInt(1) is int i && i != 0) {
				ph.Text = _compl.GetDescriptionDoc(ci, e.ToInt(1));
			} else if (e.Starts("^snippet ")) {
				DSnippets.ShowSingle(e[9..]);
			}
		};
		_textPopup.Show(Panels.Editor.ActiveDoc, _popup.Hwnd.Rect, Dock.Right);
	}
	
	void _SortAndSetControlItems() {
		if (_winApi) {
			if (!_groupsEnabled) { //the database table is already grouped/sorted
				_av.Sort((c1, c2) => string.Compare(c1.Text, c2.Text, StringComparison.OrdinalIgnoreCase));
			}
		} else {
			_av.Sort((c1, c2) => {
				int diff = c1.moveDown - c2.moveDown;
				if (diff != 0) return diff;
				
				if (_groupsEnabled) {
					diff = c1.group - c2.group;
					if (diff != 0) return diff;
					
					if (_groups[c1.group].NE()) {
						CiItemKind k1 = c1.kind, k2 = c2.kind;
						
						//group Enum and Enum.Member together
						if (k1 == CiItemKind.EnumMember) k1 = CiItemKind.Enum;
						if (k2 == CiItemKind.EnumMember) k2 = CiItemKind.Enum;
						
						diff = k1 - k2;
						if (diff != 0) return diff;
					}
				}
				
				int r = CiUtil.SortComparer.Compare(c1.GetCI().SortText, c2.GetCI().SortText);
				if (r == 0) {
					r = CiSnippets.Compare(c1, c2); //custom snippet first
				}
				return r;
			});
		}
		
		CiComplItem prev = null;
		foreach (var v in _av) {
			var group = _groupsEnabled && (prev == null || v.group != prev.group) ? _groups[v.group] : null;
			v.SetDisplayText(group);
			prev = v;
		}
		
		_tv.SetItems(_av);
	}
	
	public void UpdateVisibleItems() {
		int n1 = 0; foreach (var v in _a) if (v.hidden == 0) n1++;
		_av = new(n1);
		foreach (var v in _a) if (v.hidden == 0) _av.Add(v);
		_SortAndSetControlItems();
		
		//Occasionally app used to crash without an error UI when typing a word and should show completions.
		//	Windows event log shows exception with call stack, which shows that _av.Select called with _av=null.
		//	The reason (reproduced):
		//		in _SortAndSetControlItems -> _tv.SetItems -> ... -> _Measure, probably when setting scrollbar properties,
		//		WPF raises an UIA event and waits + dispatches messages. During that time is called Hide(). It sets _av=null.
		//	Workaround: return now if _aw null. Workaround 2: replace the WPF scrollbar with native scrollbar. Both done.
		if (_av == null) return;
		
		_compl.SelectBestMatch(_av, _groupsEnabled); //pass items sorted like in the visible list
		
		//Still _av and _a null sometimes (see above comments). It means, Roslyn code called by SelectBestMatch pumps messages.
		//	It started when started using the Windows "Text cursor indicator" feature. It aggressively sends many WM_GETOBJECT.
		if (_a == null) return;
		
		int kinds = 0;
		foreach (var v in _a) if ((v.hidden & ~CiComplItemHiddenBy.Kind) == 0) kinds |= 1 << (int)v.kind;
		for (int i = 0; i < _kindButtons.Length; i++) _kindButtons[i].Visibility = 0 != (kinds & (1 << i)) ? Visibility.Visible : Visibility.Collapsed;
	}
	
	public void Show(SciCode doc, int position, List<CiComplItem> a, List<string> groups, bool winApi) {
		if (a.NE_()) {
			Hide();
			return;
		}
		
		_a = null; //let _KindButton_Click ignore the "unchecked" event triggered by the `v.IsChecked = false;`
		foreach (var v in _kindButtons) v.IsChecked = false;
		
		_a = a;
		_groups = groups;
		_groupsEnabled = _groups != null && _groupButton.IsChecked == true;
		_doc = doc;
		_winApi = winApi;
		
		_groupButton.Visibility = _groups != null ? Visibility.Visible : Visibility.Collapsed;
		_unimportedButton.Visibility = _groups != null ? Visibility.Visible : Visibility.Collapsed;
		UpdateVisibleItems();
		
		var r = _doc.EGetCaretRectFromPos(position, inScreen: true);
		r.left -= Dpi.Scale(50, _doc);
		
		_popup.ShowByRect(_doc, Dock.Bottom, r);
	}
	
	public void Hide() {
		//Debug_.PrintIf(_debug, "reenter, " + new StackTrace());
		if (_a == null) return;
		_tv.SetItems(null);
		_popup.Close();
		_textPopup.Hide();
		_tpTimer.Stop();
		_a = null;
		_av = null;
		_groups = null;
		_suggestedItem = null;
		
		if (_winApi) Task.Run(() => GC.Collect());
	}
	
	public CiComplItem SelectedItem {
		get {
			int i = _tv.SelectedIndex;
			return i >= 0 ? _av[i] : null;
		}
		set {
			int i = value == null ? -1 : _av.IndexOf(value);
			if (_tv.SelectedIndex == i) return;
			if (i >= 0) _tv.SelectSingle(i, andFocus: true, scrollTop: true); else _tv.UnselectAll();
		}
	}
	
	public CiComplItem SuggestedItem {
		get => _suggestedItem;
		set {
			_tv.UnselectAll();
			if (value != _suggestedItem) {
				var old = _suggestedItem;
				_suggestedItem = value;
				if (value != null) {
					_tv.EnsureVisible(value, scrollTop: true);
					_tv.Redraw(value);
				}
				if (old != null) _tv.Redraw(old);
			}
		}
	}
	CiComplItem _suggestedItem;
	
	public bool OnCmdKey(KKey key) {
		if (_popup.IsVisible) {
			switch (key) {
			case KKey.Escape:
				Hide();
				return true;
			case KKey.Down:
			case KKey.Up:
			case KKey.PageDown:
			case KKey.PageUp:
			case KKey.Home:
			case KKey.End:
				_tv.ProcessKey(keys.more.KKeyToWpf(key));
				return true;
			}
		}
		return false;
	}
	
	class _CustomDraw : ITVCustomDraw {
		CiPopupList _p;
		TVDrawInfo _cd;
		GdiTextRenderer _tr;
		int _textColor;
		
		public _CustomDraw(CiPopupList list) {
			_p = list;
		}
		
		public void Begin(TVDrawInfo cd, GdiTextRenderer tr) {
			_cd = cd;
			_tr = tr;
			_textColor = Api.GetSysColor(Api.COLOR_WINDOWTEXT);
		}
		
		//public bool DrawBackground() {
		//}
		
		//public bool DrawCheckbox() {
		//}
		
		//public bool DrawImage(System.Drawing.Bitmap image) {
		//}
		
		public bool DrawText() {
			var ci = _cd.item as CiComplItem;
			
			if (ci == _p.SuggestedItem) {
				_cd.graphics.DrawRectangleInset(System.Drawing.Pens.DodgerBlue, _cd.rect);
			}
			
			var s = _cd.item.DisplayText;
			Range black, green;
			if (ci.commentOffset == 0) { black = ..s.Length; green = default; } else { black = ..ci.commentOffset; green = ci.commentOffset..; }
			
			int xEndOfText = 0;
			int color = ci.moveDown.HasAny(CiComplItemMoveDownBy.Name | CiComplItemMoveDownBy.FilterText) ? 0x808080 : _textColor;
			_tr.MoveTo(_cd.xText, _cd.yText);
			if (ci.hilite != 0) {
				ulong h = ci.hilite;
				for (int normalFrom = 0, boldFrom = 0, boldTo = 0, to = black.End.Value; normalFrom < to; normalFrom = boldTo) {
					for (boldFrom = normalFrom; boldFrom < to && 0 == (h & 1); boldFrom++) h >>= 1;
					_tr.DrawText(s, color, normalFrom..boldFrom);
					if (boldFrom == to) break;
					for (boldTo = boldFrom; boldTo < to && 0 != (h & 1); boldTo++) h >>= 1;
					_tr.FontBold(); _tr.DrawText(s, color, boldFrom..boldTo); _tr.FontNormal();
				}
			} else {
				_tr.DrawText(s, color, black);
			}
			
			if (ci.moveDown.Has(CiComplItemMoveDownBy.Obsolete)) xEndOfText = _tr.GetCurrentPosition().x;
			
			if (ci.commentOffset > 0) _tr.DrawText(s, 0x00A040, green);
			
			//draw red line over obsolete items
			if (ci.moveDown.Has(CiComplItemMoveDownBy.Obsolete)) {
				int vCenter = _cd.rect.top + _cd.rect.Height / 2;
				_cd.graphics.DrawLine(System.Drawing.Pens.OrangeRed, _cd.xText, vCenter, xEndOfText, vCenter);
			}
			
			return true;
		}
		
		public void DrawMarginLeft() {
			var ci = _cd.item as CiComplItem;
			var g = _cd.graphics;
			var r = _cd.rect;
			
			//draw images: access, static/abstract
			var cxy = _cd.imageRect.Width;
			var ri = new System.Drawing.Rectangle(_cd.imageRect.left - cxy, _cd.imageRect.top + cxy / 4, cxy, cxy);
			if (ci.AccessImageSource is string s1) g.DrawImage(IconImageCache.Common.Get(s1, _cd.dpi, isImage: true), ri);
			if (ci.ModifierImageSource is string s2) g.DrawImage(IconImageCache.Common.Get(s2, _cd.dpi, isImage: true), ri);
			
			//draw group separator
			if (_cd.index > 0) {
				var cip = _p._av[_cd.index - 1];
				if (cip.moveDown != ci.moveDown || (_p._groupsEnabled && cip.group != ci.group)) {
					_cd.graphics.DrawLine(System.Drawing.Pens.YellowGreen, 0, r.top + 1, r.right, r.top + 1);
				}
			}
		}
	}
}


================================================
FILE: Au.Editor/Edit/CiPopupText.cs
================================================
using Au.Controls;
using System.Windows;
using System.Windows.Controls;

namespace LA;

class CiPopupText {
	public enum UsedBy { PopupList, Signature, Info }
	
	KPopup _w;
	FlowDocumentControl _c;
	EventHandler _onHiddenOrDestroyed;
	UsedBy _usedBy;
	System.Windows.Documents.Section _section;
	bool _updateText;
	
	public CiPopupText(UsedBy usedy, EventHandler onHiddenOrDestroyed = null) {
		_usedBy = usedy;
		_onHiddenOrDestroyed = onHiddenOrDestroyed;
	}
	
	/// <summary>
	/// The top-level popup window.
	/// </summary>
	public KPopup PopupWindow => _CreateOrGet();
	
	/// <summary>
	/// Called when clicked a link with href prefix "^".
	/// </summary>
	public Action<CiPopupText, string> OnLinkClick { get; set; }
	
	/// <summary>
	/// Text to show. Set before calling Show.
	/// </summary>
	public System.Windows.Documents.Section Text {
		get => _section;
		set {
			if (value != _section) {
				_section = value;
				if (IsVisible) _SetText(); else _updateText = true;
				//TODO3: if visible, probably does not auto-size. But maybe now not used, because never noticed incorrect size.
			}
		}
	}
	
	KPopup _CreateOrGet() {
		if (_w == null) {
			bool ubInfo = _usedBy == UsedBy.Info;
			_w = new KPopup(ubInfo ? WS.POPUP | WS.BORDER : WS.POPUP | WS.THICKFRAME, shadow: ubInfo, sizeToContent: ubInfo ? SizeToContent.Height : default) {
				Name = "Ci.Info",
				WindowName = _usedBy switch { UsedBy.PopupList => "LA completion item info", UsedBy.Signature => "LA parameters info", _ => "LA quick info" },
				CloseHides = true
			};
			_w.Size = (_usedBy == UsedBy.Signature ? 800 : 600, _usedBy == UsedBy.PopupList ? 360 : 300);
			//rejected: save size in app settings (if not info). Popup list too.
			
			_c = CiText.CreateControl();
			_w.Content = _c;
			
			if (_onHiddenOrDestroyed != null) _w.Hidden += _onHiddenOrDestroyed;
			_c.LinkClicked += (sender, s) => {
				if (s.Starts('#')) return; //anchor
				if (s.Starts('^')) {
					OnLinkClick?.Invoke(this, s);
				} else if (s.Starts('|')) { //go to symbol source file/position or web page
					CiGoTo.LinkGoTo(s);
				} else if (HelpUtil.IsAuHelp_(s)) {
					HelpUtil.AuHelp(s);
				} else {
					run.itSafe(s);
				}
			};
			
			if (ubInfo) _w.ClickInactiveActivateOwner = true;
		}
		return _w;
	}
	
	/// <summary>
	/// Shows by anchorRect, owned by ownerControl.
	/// </summary>
	/// <param name="ownerControl"></param>
	/// <param name="anchorRect">Rectangle in screen coord. The popup window will be by it but not in it (in it if side = null).</param>
	/// <param name="hideIfOutside">Hide when mouse moved outside anchorRect unless is in the popup window.</param>
	public void Show(SciCode ownerControl, RECT anchorRect, Dock? side, bool hideIfOutside = false) {
		_CreateOrGet();
		if (_updateText) _SetText();
		_w.ShowByRect(ownerControl, side, anchorRect);
		
		if (hideIfOutside) {
			timer.every(100, t => {
				if (IsVisible) {
					var p = mouse.xy;
					if (anchorRect.Contains(p) || _w.Hwnd.Rect.Contains(p) || _c.IsMouseCaptureWithin) return;
					Hide();
				}
				t.Stop();
			});
		}
	}
	
	public void Show(SciCode ownerControl, int pos16, bool hideIfOutside = false, bool above = false) {
		var r = ownerControl.EGetCaretRectFromPos(pos16, inScreen: true);
		r.Inflate(50, 0);
		Show(ownerControl, r, above ? Dock.Top : Dock.Bottom, hideIfOutside);
	}
	
	public bool Hide() {
		if (!IsVisible) return false;
		//print.it(new StackTrace());
		_w.Close();
		_section = null;
		_SetText();
		return true;
	}
	
	public bool IsVisible => _w?.IsVisible ?? false;
	
	void _SetText() {
		_updateText = false;
		_c?.Clear();
		if (_section != null) _c.Document.Blocks.Add(_section);
	}
}


================================================
FILE: Au.Editor/Edit/CiProjects.cs
================================================
extern alias CAW;

using Microsoft.CodeAnalysis;
using CAW::Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Text;
using Microsoft.CodeAnalysis.CSharp.Extensions;
using Microsoft.CodeAnalysis.Shared.Extensions;
using CAW::Microsoft.CodeAnalysis.Shared.Extensions;
using SymAcc = Microsoft.CodeAnalysis.Accessibility;


namespace LA;

class CiProjects {
	//public void Test() {
	
	//}
	
	/// <summary>
	/// From meta comments of all workspace files extracts pr and c.
	/// Slow, loads texts of all code files except those in excluded folders. At first saves everything.
	/// </summary>
	/// <returns>
	/// List containing <b>FileNode</b> of files that have valid pr or c, along with non-null <b>FileNode</b> arrays containing unique pr and c, including transitive c.
	/// All pr/c of a project are in a single list item where <b>f</b> is the project-main file.
	/// Random order if using parallel.
	/// </returns>
	static async Task<List<(FileNode f, FileNode[] pr, FileNode[] c, Dictionary<FileNode, FileNode> cPr)>> _GetAllMetaPrAndC() {
		var model = App.Model;
		model.Save.AllNowIfNeed();
		
		//excluded folders
		HashSet<FileNode> hsEF = new();
		if (!model.WSSett.ci_skipFolders.NE()) {
			foreach (var v in model.WSSett.ci_skipFolders.Lines(noEmpty: true)) {
				var f = model.Find(v, FNFind.Folder);
				if (f != null) hsEF.Add(f);
			}
		}
		
		//get file paths before loading async
		List<(FileNode f, string path)> a1 = new();
		FileNode projMain = null; //for all files in a project let f = project-main file
#if DEBUG
		//if(keys.isScrollLock) _Folder(model.Find("\\Deps", FNFind.Folder)); else
#endif
		_Folder(model.Root);
		
		void _Folder(FileNode parent) {
			for (var f = parent.FirstChild; f != null; f = f.Next) {
				if (f.IsCodeFile) {
					var path = f.FilePath;
					if (projMain != null && f.IsClass) a1.Add((projMain, path)); else a1.Add((f, path));
				} else if (f.IsFolder && !hsEF.Contains(f)) {
					bool isProj = projMain == null && f.IsProjectFolder(out projMain);
					_Folder(f);
					if (isProj) projMain = null;
				}
			}
		}
		
		//load texts of all files. Find meta pr and c, and add to d.
		var d = new Dictionary<FileNode, List<(int meta, string value)>>();
		await Task.Run(() => {
			if (App.Settings.find_parallel) {
				Parallel.For(0, a1.Count, i => _Meta(i, true));
			} else {
				for (int i = 0; i < a1.Count; i++) _Meta(i, false);
			}
			
			void _Meta(int i, bool parallel) {
				//rejected: optimize: load only n bytes from the start of the file. Tested, similar speed.
				if (FileNode.GetFileTextLL(a1[i].path) is not string code || code.Length < 9) return;
				var meta = MetaComments.FindMetaComments(code); if (meta.end == 0) return;
				bool locked = false;
				foreach (var v in MetaComments.EnumOptions(code, meta)) {
					int m; if (v.NameIs("pr")) m = 1; else if (v.NameIs("c")) m = 2; else continue;
					if (!locked && parallel) { locked = true; Monitor.Enter(d); }
					if (d.TryGetValue(a1[i].f, out var a2)) a2.Add((m, v.Value)); else d.Add(a1[i].f, new() { (m, v.Value) });
				}
				if (locked) Monitor.Exit(d);
			}
		});
		
		//find pr/c files and convert to list ar
		List<(FileNode f, FileNode[] pr, FileNode[] c, Dictionary<FileNode, FileNode> cPr)> ar = new();
		List<FileNode> aPR = new(), aC = new();
		foreach (var (f, a) in d) {
			aPR.Clear(); aC.Clear();
			foreach (var v in a) {
				if (v.meta == 1) { //pr
					var p = MetaComments.FindFile(f, v.value, FNFind.Class)?.GetProjectMainOrThis();
					if (p != null && p != f && !aPR.Contains(p)) aPR.Add(p);
				} else { //c
					if (MetaComments.FindFile(f, v.value, FNFind.Any) is FileNode ff) {
						if (ff.IsFolder) foreach (var c in ff.Descendants()) _AddC(c); else _AddC(ff);
						void _AddC(FileNode c) { if (c.IsClass && c != f && !aC.Contains(c)) aC.Add(c); }
					}
				}
			}
			if (aPR.Any() || aC.Any()) {
				ar.Add((f, aPR.ToArray(), aC.ToArray(), null));
				//print.it(f, aPR, aC);
			}
		}
		
		//append transitive c and pr. Eg if file F1 contains c F2, and F2 contains c F3, add F3 to F1.
		//	yes: F1 -> c F2 -> c F3
		//	yes: F1 -> c F2 -> pr F3
		//	yes: F1 -> pr F2 -> c F3
		//	no: F1 -> pr F2 -> pr F3
		//	no: F1 -> pr F2 -> c F3 -> pr F4
		_Transitive();
		void _Transitive() {
			var td = ar.ToDictionary(o => o.f, o => (o.pr, o.c));
			List<FileNode> tap = new(), tac = new();
			foreach (ref var v in ar.AsSpan()) {
				tap.Clear(); tap.AddRange(v.pr);
				tac.Clear(); tac.AddRange(v.c);
				Dictionary<FileNode, FileNode> cPr = null;
				foreach (var f in v.pr) _AddTransitive(f, true, f);
				foreach (var f in v.c) _AddTransitive(f, false, null);
				if (tap.Count > v.pr.Length) v.pr = tap.ToArray();
				if (tac.Count > v.c.Length) v.c = tac.ToArray();
				v.cPr = cPr;
				
				void _AddTransitive(FileNode fu, bool noPr, FileNode fPr) {
					if (!td.TryGetValue(fu, out var t)) return;
					var (apr, ac) = t;
					if (!noPr) {
						foreach (var f in apr) {
							if (tap.Contains(f)) continue;
							tap.Add(f);
							_AddTransitive(f, true, f);
						}
					}
					foreach (var f in ac) {
						if (tac.Contains(f) || tap.Contains(f)) continue;
						tac.Add(f);
						if (fPr != null) (cPr ??= new()).Add(f, fPr);
						_AddTransitive(f, noPr, fPr);
					}
				}
			}
		}
		
		//foreach (var v in ar.OrderBy(o => o.f.ItemPath)) print.it(v.f.ItemPath, v.pr, v.c);
		
		return ar;
	}
	
	/// <summary>
	/// Gets all files that use some files in <i>d</i> through meta pr or c.
	/// For files in projects gets the project-main file.
	/// </summary>
	static async Task<List<FileNode>> _GetUsers(Dictionary<FileNode, Project> d, _FRContext x) {
		var a = await _GetAllMetaPrAndC();
		
		List<FileNode> ar = new();
		var defProjects = d
			.Where(o => o.Value.CompilationOptions.OutputKind == OutputKind.DynamicallyLinkedLibrary)
			.Select(o => FileOf(o.Value))
			.Distinct()
			.ToArray();
		//print.it(d.Keys, defProjects.Select(o => o.ItemPath));
		
		var skipC = x.sol.Projects.SelectMany(o => o.DocumentIds.Select(FileOf)).ToHashSet();
		foreach (var user in a) {
			foreach (var f in defProjects)
				if (user.pr.Contains(f))
					if (!skipC.Contains(user.f)) goto g1;
			foreach (var f in d.Keys)
				if (user.c.Contains(f))
					if (!skipC.Contains(user.f)) {
						if (user.cPr != null && user.cPr.TryGetValue(f, out var cPr)) //if user uses this c through pr
							if (defProjects.Contains(cPr)) continue;
						goto g1;
					}
			continue;
			g1:
			ar.Add(user.f);
		}
		
		return ar;
	}
	
	/// <summary>
	/// Gets all files that use <i>sym</i>.-
	/// For files in projects gets the project-main file.
	/// If <i>sym</i> is defined in class file(s), calls other <b>_GetUsers</b> overload and passes them.
	/// If <i>sym</i> is defined in metadata or global.cs, and current file is a class file, calls that <b>_GetUsers</b> overload and passes current file.
	/// </summary>
	static async Task<List<FileNode>> _GetUsers(ISymbol sym, _FRContext x) {
		if (sym is IAliasSymbol alias) sym = alias.Target;
		//if (sym is not (INamespaceSymbol or INamedTypeSymbol or IMethodSymbol or IPropertySymbol or IEventSymbol or IFieldSymbol)) return null;
		if (sym.DeclaredAccessibility is SymAcc.Private or SymAcc.NotApplicable) return null; //Internal and ProtectedAndInternal can be accessed through [InternalsVisible] or testInternal.
		Dictionary<FileNode, Project> d = new();
		HashSet<FileNode> globals = null;
		bool isInMetadata = false, isInGlobal = false;
		foreach (var loc in sym.Locations) {
			FileNode f; bool currentFile = false;
			if (loc.IsInSource) {
				f = FileOf(loc.SourceTree, x.sol);
				if (f.IsClass && (globals ??= _GetGlobals()).Contains(f)) {
					isInGlobal = currentFile = true;
					f = x.cd.sci.EFile;
				}
			} else {
				if (isInMetadata) continue;
				isInMetadata = currentFile = true;
				f = x.cd.sci.EFile;
			}
			
			if (f.IsClass && !d.ContainsKey(f)) {
				var doc = currentFile
					? x.sol.GetDocument(x.sol.GetDocumentIdsWithFilePath(f.ItemPath).First())
					: x.sol.GetDocument(loc.SourceTree);
				d.Add(f, doc.Project);
			}
		}
		if (isInMetadata || isInGlobal) x.info = "Searched only in this and related files, not in entire workspace.";
		return d.Any() ? await _GetUsers(d, x) : null;
		
		//rejected: append link 'Search in entire workspace'. Can be very slow if many files.
		
		static HashSet<FileNode> _GetGlobals() {
			HashSet<FileNode> h = new();
			var g = App.Model.FindGlobalCs();
			if (g != null) _File(g);
			void _File(FileNode f) {
				if (!h.Add(f)) return;
				if (FileNode.GetFileTextLL(f.FilePath) is not string code || code.Length == 0) return;
				var meta = MetaComments.FindMetaComments(code); if (meta.end == 0) return;
				foreach (var v in MetaComments.EnumOptions(code, meta)) {
					if (v.NameIs("c")) {
						if (MetaComments.FindFile(f, v.Value, FNFind.Any) is FileNode ff) {
							if (ff.IsFolder)
								foreach (var c in ff.Descendants()) _File(c);
							else _File(ff);
						}
					}
				}
			}
			return h;
		}
	}
	
	public static async Task<(Solution solution, string info)> GetSolutionForFindReferences(ISymbol sym, CodeInfo.Context cd) {
		_FRContext x = new() { sol = cd.document.Project.Solution, cd = cd };
		var users = await _GetUsers(sym, x);
		
		if (!users.NE_()) {
			//print.it("USERS", users);
			//never mind: if S -> c C -> pr L, adds C and S as users of L, although C is included in S.
			
			//create ProjectInfos for users
			List<(ProjectInfo pri, MetaComments meta)> ap = new();
			var projects = x.sol.ProjectIds.ToDictionary(o => FileOf(o));
			Dictionary<FileNode, string> dTexts = new();
			foreach (var f in users) {
				ap.Add(_CreateProject(x, f, projects, dTexts));
			}
			
			//maybe some of these new projects have pr to other new projects
			if (ap.Count > 1) _AddNewPR();
			void _AddNewPR() {
				var prNew = ap
					.Where(o => o.pri.CompilationOptions.OutputKind == OutputKind.DynamicallyLinkedLibrary)
					.ToDictionary(o => o.meta.MainFile.f, o => o.pri.Id);
				if (prNew.Count > 0) {
					List<ProjectReference> aPr = new();
					foreach (ref var p in ap.AsSpan()) {
						if (p.meta.ProjectReferences is { } a1) {
							aPr.Clear();
							foreach (var v in a1) if (prNew.TryGetValue(v.f, out var p1)) aPr.Add(new ProjectReference(p1));
							if (aPr.Count > 0) p.pri = p.pri.WithProjectReferences(p.pri.ProjectReferences.Concat(aPr));
						}
					}
				}
			}
			
			//add these ProjectInfos to solution
			await Task.Run(() => {
				foreach (var (pri, _) in ap) x.sol = x.sol.AddProject(pri);
			});
		}
		//print.it(x.sol.Projects.Count(), x.sol.Projects.Select(o => o.Name));
		return (x.sol, x.info);
	}
	
	static (ProjectInfo pri, MetaComments meta) _CreateProject(_FRContext x, FileNode f, Dictionary<FileNode, ProjectId> projects, Dictionary<FileNode, string> dTexts) {
		if (!f.FindProject(out var projFolder, out var fmain)) fmain = f;
		var m = new MetaComments(MCFlags.ForFindReferences, dTexts);
		m.Parse(fmain, projFolder);
		
		if (m.TestInternal is string[] testInternal) TestInternal.RefsAdd(m.Name, testInternal);
		
		var projectId = ProjectId.CreateNewId();
		AttachFileOf(projectId, fmain);
		var adi = new List<DocumentInfo>();
		foreach (var mf in m.CodeFiles) {
			var docId = DocumentId.CreateNewId(projectId);
			AttachFileOf(docId, mf.f);
			var tav = TextAndVersion.Create(SourceText.From(mf.code, Encoding.UTF8), VersionStamp.Default);
			adi.Add(DocumentInfo.Create(docId, mf.f.Name, null, SourceCodeKind.Regular, TextLoader.From(tav), mf.f.ItemPath));
			//note: 'filePath=mf.f.ItemPath' is important. If same path used in multiple projects, symbolfinder finds symbols
			//	with same name in all projects, although technically it's not the same symbol. This is what we need.
		}
		
		//add project references that are in m.ProjectReferences and in current solution (intersection)
		List<ProjectReference> pr = null;
		if (m.ProjectReferences is { } a1) {
			for (int i = 0; i < a1.Count; i++) {
				if (projects.TryGetValue(a1[i].f, out var p1)) {
					(pr ??= new()).Add(new ProjectReference(p1));
					a1.RemoveAt(i--);
				}
			}
		}
		
		var pri = ProjectInfo.Create(projectId, VersionStamp.Default, m.Name, m.Name, LanguageNames.CSharp, fmain.ItemPath, null,
			m.CreateCompilationOptions(),
			m.CreateParseOptions(),
			adi,
			pr,
			m.References.Refs);
		return (pri, m);
	}
	
	class _FRContext {
		public Solution sol;
		public CodeInfo.Context cd;
		public string info;
	}
	
	public static void AttachFileOf(DocumentId docId, FileNode f) { _cwtFO.Add(docId, f); }
	public static void AttachFileOf(ProjectId projId, FileNode f) { _cwtFO.Add(projId, f); }
	
	static readonly ConditionalWeakTable<object, FileNode> _cwtFO = new();
	
	public static FileNode FileOf(DocumentId id) => _cwtFO.TryGetValue(id, out var v) ? v : null;
	public static FileNode FileOf(Document doc) => FileOf(doc.Id);
	public static FileNode FileOf(SyntaxTree t, Solution sol) => FileOf(sol.GetDocument(t));
	public static FileNode FileOf(ProjectId id) => _cwtFO.TryGetValue(id, out var v) ? v : null;
	public static FileNode FileOf(Project proj) => FileOf(proj.Id);
}


================================================
FILE: Au.Editor/Edit/CiQuickInfo.cs
================================================
using Microsoft.CodeAnalysis.QuickInfo;
//using Microsoft.CodeAnalysis.CSharp.QuickInfo;
using System.Windows.Documents;
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;

namespace LA;

class CiQuickInfo {
	public async Task<Section> GetTextAt(int pos16) {
		//using var p1 = perf.local();
		if (!CodeInfo.GetContextAndDocument(out var cd, pos16)) return null;
		//p1.Next();
		
		var tok = cd.syntaxRoot.FindToken(pos16);
		var tspan = tok.Span;
		bool isInToken = !tspan.IsEmpty && tspan.ContainsOrTouches(pos16);
		if (isInToken) {
			//print.it(tok.Kind());
			
			//CONSIDER: if over text like `0x123456` or `#123456` or `blue`, and it is a token or in a string, display quick info popup with the color (text and background). And add link "Edit color".
			//	But problem: `0x123456` can be RGB or BGR. Maybe then display both.
			
			//ignore literals
			if (cd.code[tspan.Start] is (>= '0' and <= '9') or '\'' or '"' or '@' or '$' or '{') return null;
			var tk = tok.Kind(); if (tk is SyntaxKind.InterpolatedStringTextToken or SyntaxKind.TrueKeyword or SyntaxKind.FalseKeyword) return null;
			
			//make easier to get quick info for indexer
			if (tk is SyntaxKind.IdentifierToken && tspan.Length > 1 && pos16 >= tspan.End - 1)
				if (GetIndexerToken(cd, tok, out var tok2)) pos16 = tok2.SpanStart;
			
			Panels.Debug.SciMouseHover_(cd);
		}
		
		var opt1 = QuickInfoOptions.Default with { IncludeNavigationHintsInQuickInfo = false };
		var opt2 = new Microsoft.CodeAnalysis.LanguageService.SymbolDescriptionOptions { QuickInfoOptions = opt1 };
		
		var service = QuickInfoService.GetService(cd.document);
		var r = await Task.Run(async () => await service.GetQuickInfoAsync(cd.document, pos16, opt2, default));
		//p1.Next();
		if (r == null) return null;
		//this oveload is internal, but:
		//	- The public overload does not have an options parameter. In old Roslyn could set options for workspace, but it stopped working.
		//	- Roslyn in Debug config asserts "don't use this function".
		
		//ignore literals again. The above not always works, eg the service gets quickinfo when the mouse is over `}` in `"string"}` or `number}`.
		if (isInToken && r.Span.End <= tspan.Start) return null;
		
		var x = new CiText();
		
		if (!r.Sections.IsDefaultOrEmpty) {
			//bool hasDocComm = false;
			//QuickInfoSection descr = null;
			var a = r.Sections;
			for (int i = 0; i < a.Length; i++) {
				var se = a[i];
				//print.it(se.Kind, se.Text);
				
				x.StartParagraph();
				
				if (i == 0) { //image
					CiUtil.TagsToKindAndAccess(r.Tags, out var kind, out var access);
					if (kind != CiItemKind.None) {
						if (access != default) x.Image(access);
						x.Image(kind);
						x.Append(" ");
					}
				}
				
				var tp = se.TaggedParts;
				if (tp[0].Tag == TextTags.LineBreak) { //remove/replace some line breaks in returns and exceptions
					int lessNewlines = se.Kind switch { QuickInfoSectionKinds.ReturnsDocumentationComments => 1, QuickInfoSectionKinds.Exception => 2, _ => 0 };
					var k = new List<TaggedText>(tp.Length - 1);
					for (int j = 1; j < tp.Length; j++) {
						var v = tp[j];
						if (lessNewlines > 0 && j > 1) {
							if (v.Tag == TextTags.LineBreak) {
								if (j == 2) continue; //remove line break after "Returns:" etc
								if (lessNewlines == 2) { //in list of exceptions replace "\n  " with ", "
									if (++j == tp.Length || tp[j].Tag != TextTags.Space) { j--; continue; }
									v = new(TextTags.Text, ", ");
								}
							}
						}
						k.Add(v);
					}
					x.AppendTaggedParts(k, false);
				} else {
					x.AppendTaggedParts(tp);
				}
				
				x.EndParagraph();
			}
		}
		
		if (!r.RelatedSpans.IsDefaultOrEmpty) { //when mouse is on `}` or `#endx`, r.RelatedSpans contains spans of the `class etc` or `#if etc`
			foreach (var v in r.RelatedSpans) {
				x.StartParagraph();
				x.Append(cd.code[v.ToRange()]);
				x.EndParagraph();
			}
		}
		
		return x.Result;
	}
	
	internal static bool GetIndexerToken(CodeInfo.Context cd, in SyntaxToken tok, out SyntaxToken r) {
		r = default;
		Debug.Assert(tok.Kind() is SyntaxKind.IdentifierToken);
		if (tok.GetNextToken() is var tok2 && tok2.IsKind(SyntaxKind.OpenBracketToken)) {
			var si = cd.semanticModel.GetSymbolInfo(tok.Parent);
			ITypeSymbol t = si.Symbol switch {
				IPropertySymbol k => k.Type,
				IFieldSymbol k => k.Type,
				ILocalSymbol k => k.Type,
				IParameterSymbol k => k.Type,
				_ => null
			};
			if (t != null) {
				if (t.TypeKind is TypeKind.Array || t.SpecialType is SpecialType.System_String or SpecialType.System_Array) return false; //indexer info not useful
				r = tok2;
				return true;
			}
		}
		return false;
	}
}


================================================
FILE: Au.Editor/Edit/CiSignature.cs
================================================
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Text;
using Microsoft.CodeAnalysis.SignatureHelp;
using Microsoft.CodeAnalysis.CSharp.SignatureHelp;

//FUTURE: show for lambda parameters. Currently VS does not show too.

namespace LA;

class CiSignature {
	CiPopupText _textPopup;
	_Data _data; //not null while the popup window is visible
	CancellationTokenSource _cancelTS;
	
	class _Data {
		public SignatureHelpItems r;
		public _Span span;
		public int iSelected, iUserSelected, iRoslynSelected;
		public SciCode sci;
		
		public bool IsSameSpan(_Span span2) {
			return span2.start == span.start && span2.fromEnd == span.fromEnd;
			//never mind: we don't check whether text before and after is still the same. Not that important.
		}
		
		public bool IsSameArglist(_Span span2, SignatureHelpItems r2) {
			if (!IsSameSpan(span2) || r2.Items.Count != r.Items.Count) return false;
			for (int i = 0; i < r.Items.Count; i++) {
				var hi1 = r.Items[i] as AbstractSignatureHelpProvider.SymbolKeySignatureHelpItem;
				var hi2 = r2.Items[i] as AbstractSignatureHelpProvider.SymbolKeySignatureHelpItem;
				Debug.Assert(!(hi1 == null || hi2 == null));
				if (hi1 == null || hi2 == null || hi2.Symbol != hi1.Symbol) return false;
			}
			return true;
		}
	}
	
	struct _Span {
		public int start, fromEnd;
		public _Span(int start, int fromEnd) { this.start = start; this.fromEnd = fromEnd; }
		public _Span(TextSpan span, string code) { this.start = span.Start; this.fromEnd = code.Length - span.End; }
	}
	
	public bool IsVisibleUI => _data != null;
	
	public void Cancel() {
		_cancelTS?.Cancel(); _cancelTS = null;
		_CancelUI();
	}
	
	void _CancelUI() {
		if (_data == null) return;
		foreach (var r in _data.sci.ETempRanges_Enum(this)) r.Remove();
		_data = null;
		_textPopup?.Hide();
	}
	
	public void SciPositionChanged(SciCode doc) {
		if (_afterCharAdded) { _afterCharAdded = false; return; }
		if (_data == null) return;
		_ShowSignature(doc, default);
	}
	bool _afterCharAdded;
	
	public void SciCharAdded(SciCode doc, char ch, bool methodCompletion = false) {
		switch (ch) { case '(' or '[' or '<' or ')' or ']' or '>' or ',': break; default: return; }
		_ShowSignature(doc, ch, methodCompletion);
		_afterCharAdded = true;
	}
	
	public void ShowSignature(SciCode doc) {
		_ShowSignature(doc, default);
	}
	
	async void _ShowSignature(SciCode doc, char ch, bool methodCompletion = false) {
		//using var p1 = perf.local();
		if (!CodeInfo.GetContextAndDocument(out var cd, -2) || cd.pos < 2) return; //returns false if position is in meta comments
		
		_cancelTS?.Cancel();
		var cancelTS = _cancelTS = new CancellationTokenSource();
		var cancelToken = cancelTS.Token;
#if DEBUG
		if (Debugger.IsAttached) { cancelToken = default; _cancelTS = null; }
#endif
		
		SyntaxNode root = null;
		//ISignatureHelpProvider provider = null;
		SignatureHelpItems r = null;
		try {
			//could be sync, quite fast, but then sometimes reenters (GetItemsAsync waits/dispatches) and sometimes hangs
			r = await Task.Run(async () => {
				//p1.Next();
				root = cd.syntaxRoot;
				//p1.Next('r');
				var providers = _SignatureHelpProviders;
				//print.it(providers);
				SignatureHelpItems r = null;
				var trigger = new SignatureHelpTriggerInfo(ch == default ? SignatureHelpTriggerReason.InvokeSignatureHelpCommand : SignatureHelpTriggerReason.TypeCharCommand, ch);
				foreach (var p in providers) {
					//print.it(p);
					var r2 = await p.GetItemsAsync(cd.document, cd.pos, trigger, default, cancelToken).ConfigureAwait(false);
					//never mind: GetItemsAsync may throw exception. Rare.
					
					if (cancelToken.IsCancellationRequested) { /*print.it("IsCancellationRequested");*/ return null; } //often
					if (r2 == null) continue;
					if (r == null || r2.ApplicableSpan.Start > r.ApplicableSpan.Start) {
						r = r2;
						//provider = p;
					}
					//Example: 'print.it(new Something())'.
					//	The first provider probably is for Write (invocation).
					//	Then the second is for Something (object creation).
					//	We need the innermost, in this case Something.
				}
				return r;
			});
		}
		catch (OperationCanceledException) { /*Debug_.Print("canceled");*/ return; } //never noticed
		catch (Exception e1) { Debug_.Print(e1); return; } //Roslyn bug: in certain code throws
		finally {
			cancelTS.Dispose();
			if (cancelTS == _cancelTS) _cancelTS = null;
		}
		//print.it(r, cancelToken.IsCancellationRequested);
		
		if (cancelToken.IsCancellationRequested) return;
		if (r == null) {
			_CancelUI();
			return;
		}
		Debug.Assert(doc == Panels.Editor.ActiveDoc); //when active doc changed, cancellation must be requested
		if (cd.pos != doc.aaaCurrentPos16 || (object)cd.code != doc.aaaText) return; //changed while awaiting
		//p1.Next('s');
		
		//print.it($"<><c orange>pos={cd.pos}, span={r.ApplicableSpan},    nItems={r.Items.Count},  argCount={r.ArgumentCount}, argIndex={r.ArgumentIndex}, argName={r.ArgumentName}, sel={r.SelectedItemIndex},    provider={provider}<>");
		
		//get span of the arglist. r.ApplicableSpan.Start is of the statement, not of the arglist. In chained methods it is the chain start.
		var fullSpan = r.ApplicableSpan;
		//CiUtil.HiliteRange(fullSpan); wait.doEvents(500);
		var start = fullSpan.Start;
		var tok = root.FindToken(cd.pos);
		if (tok.Kind() is SyntaxKind.OpenParenToken or SyntaxKind.OpenBracketToken or SyntaxKind.LessThanToken) tok = tok.GetPreviousToken();
		var argNode = tok.Parent;
		while (argNode != null) {
			int i = argNode.SpanStart; if (i <= start) break;
			if (argNode is BaseArgumentListSyntax or AttributeArgumentListSyntax or TypeArgumentListSyntax) {
				start = i + 1;
				break;
			}
			//CiUtil.PrintNode(argNode);
			argNode = argNode.Parent;
		}
		var argSpan = new TextSpan(start, fullSpan.End - start);
		//CiUtil.PrintNode(argNode); CiUtil.HiliteRange(argSpan); //print.it(argSpan);
		
		var span = new _Span(argSpan, cd.code);
		int iSel = 0, iSel2 = 0;
		if (r.Items.Count > 1) {
			iSel2 = r.SelectedItemIndex ?? -1;
			if (_data?.IsSameArglist(span, r) ?? false) {
				iSel = _data.iUserSelected; //preserve user selection in same session
				if (iSel2 < 0) iSel2 = _data.iRoslynSelected; //on error use last good Roslyn selection in same session, like in VS
			} else iSel = -1;
		}
		
		_data = new _Data {
			r = r,
			span = span,
			iUserSelected = iSel,
			iRoslynSelected = iSel2,
			sci = doc,
		};
		
		if (iSel < 0) iSel = iSel2;
		if (iSel < 0) {
			//r.SelectedItemIndex is null when cannot resolve overloads, eg when arglist is partially typed. Example: wnd.find(1, );
			iSel = r.SelectedItemIndex ?? (r.SyntacticArgumentCount == 0 ? 0 : -1);
			if (iSel < 0) {
				for (int i = 0; i < r.Items.Count; i++) if (r.Items[i].Parameters.Length >= r.SyntacticArgumentCount) { iSel = i; break; }
				if (iSel < 0) {
					for (int i = 0; i < r.Items.Count; i++) if (r.Items[i].IsVariadic) { iSel = i; break; }
					if (iSel < 0) iSel = 0;
				}
			}
		}
		
		doc.ETempRanges_Add(this, argSpan.Start, argSpan.End, onLeave: () => {
			if (doc.ETempRanges_Enum(doc.aaaCurrentPos8, this, utf8: true).Any()) return;
			_CancelUI();
		}, SciCode.TempRangeFlags.NoDuplicate);
		
		var rect = RECT.Union(doc.EGetCaretRectFromPos(fullSpan.Start), doc.EGetCaretRectFromPos(cd.pos));
		var rclient = doc.AaWnd.ClientRect;
		rect.left = Math.Clamp(rect.left, 0, rect.right = Math.Clamp(rect.right, 0, rclient.right));
		doc.AaWnd.MapClientToScreen(ref rect);
		rect.Width += Dpi.Scale(200, doc.AaWnd);
		rect.left -= 6;
		
		_textPopup ??= new CiPopupText(CiPopupText.UsedBy.Signature, onHiddenOrDestroyed: (_, _) => _data = null) {
			OnLinkClick = (ph, e) => ph.Text = _FormatText(e.ToInt(1), userSelected: true)
		};
		_textPopup.Text = _FormatText(iSel, userSelected: false);
		
		if (!_textPopup.IsVisible) {
			CodeInfo.HideTextPopupAndTempWindows();
			if (CodeInfo._compl.IsVisibleUI) //without this does not show completions with selected enum when typed Function( when first parameter is enum
				CodeInfo._compl.Cancel();
			if (methodCompletion) CodeInfo._compl.ShowList(ch); //when autocompletion added (); may need to show enum list 
		}
		
		_textPopup.Show(Panels.Editor.ActiveDoc, rect, System.Windows.Controls.Dock.Bottom);
		
		//also show Keys/Regex tool?
		//CiUtil.PrintNode(node);
		if (argNode is ArgumentListSyntax or BracketedArgumentListSyntax && cd.code.Eq(cd.pos - 1, "\"\"")) {
			//print.it("string");
			var semo = cd.semanticModel;
			var token = root.FindToken(cd.pos);
			if (true == token.IsInString(cd.pos, cd.code, out var stringInfo)) {
				var stringFormat = CiUtil.GetParameterStringFormat(stringInfo.stringNode, semo, true);
				if (stringFormat != 0)
					CodeInfo._tools.ShowForStringParameter(stringFormat, cd, stringInfo, _textPopup.PopupWindow.Hwnd);
			}
		}
	}
	
	System.Windows.Documents.Section _FormatText(int iSel, bool userSelected) {
		_data.iSelected = iSel;
		if (userSelected) _data.iUserSelected = iSel;
		
		var r = _data.r;
		ISymbol currentItem = null;
		SignatureHelpParameter currentParameter = null;
		var x = new CiText();
		
		//print.clear();
		for (int i = 0; i < r.Items.Count; i++) {
			var sh = r.Items[i];
			if (sh is AbstractSignatureHelpProvider.SymbolKeySignatureHelpItem kk) {
				var sym = kk.Symbol;
				if (i == iSel) currentItem = sym;
				x.StartOverload(i == iSel, i);
#if false
				x.AppendTaggedParts(sh.PrefixDisplayParts); //works, but formats not as I like (too much garbage). Has bugs with tuples.
#else
				//if(nt != null) {
				//	print.it(1, nt.IsGenericType, nt.IsTupleType, nt.IsUnboundGenericType, nt.Arity, nt.CanBeReferencedByName);
				//	print.it(2, nt.IsAnonymousType, nt.IsDefinition, nt.IsImplicitlyDeclared, nt.Kind, nt.TypeKind);
				//	print.it(3, nt.MemberNames);
				//	print.it(4, nt.Name, nt.MetadataName, nt.OriginalDefinition, nt.TupleUnderlyingType);
				//	print.it("TypeParameters:");
				//	print.it(nt.TypeParameters);
				//	print.it("TypeArguments:");
				//	print.it(nt.TypeArguments);
				//	print.it("TupleElements:");
				//	try { var te = nt.TupleElements; if(!te.IsDefault) print.it(te); } catch(Exception e1) { print.it(e1.ToStringWithoutStack()); }
				//	print.it("---");
				//}
				
				int isTuple = 0; //1 ValueTuple<...>, 2 (...)
				var nt = sym as INamedTypeSymbol;
				if (nt != null && nt.IsTupleType) isTuple = nt.IsDefinition ? 1 : 2;
				
				if (isTuple == 1) x.Append("ValueTuple"); //AppendSymbolWithoutParameters formats incorrectly
				else if (isTuple == 0) x.AppendSymbolWithoutParameters(sym);
				string b1 = "(", b2 = ")";
				if (nt != null) {
					if (nt.IsGenericType && isTuple != 2) { b1 = "<"; b2 = ">"; }
				} else if (sym is IPropertySymbol) {
					b1 = "["; b2 = "]";
				}
				x.Append(b1);
#endif
				int iArg = r.SemanticParameterIndex, lastParam = sh.Parameters.Length - 1;
				int selParam = iArg <= lastParam ? iArg : (sh.IsVariadic ? lastParam : -1);
				if (!r.ArgumentName.NE()) {
					var pa = sh.Parameters;
					for (int pi = 0; pi < pa.Length; pi++) if (pa[pi].Name == r.ArgumentName) { selParam = pi; break; }
				}
				x.AppendParameters(sym, selParam, sh);
				//x.AppendParameters(sh, selParam); //works, but formats not as I like (too much garbage)
#if false
				x.AppendTaggedParts(sh.SuffixDisplayParts);
#else
				x.Append(b2);
#endif
				if (i == iSel && selParam >= 0) currentParameter = sh.Parameters[selParam];
				x.EndOverload(i == iSel);
			} else {
				Debug_.Print(sh);
			}
		}
		
		if (currentItem != null) {
			var tt = r.Items[iSel].DocumentationFactory?.Invoke(default);
			bool haveDoc = tt?.Any() ?? false;
			string helpUrl = CiUtil.GetSymbolHelpUrl(currentItem, out _);
			string sourceUrl = CiGoTo.GetLinkData(currentItem);
			bool haveLinks = helpUrl != null || sourceUrl != null;
			if (haveDoc || haveLinks) {
				x.StartParagraph();
				if (haveDoc) x.AppendTaggedParts(tt, false);
				if (haveLinks) {
					if (haveDoc) x.Append(" ");
					x.AppendSymbolLinks(helpUrl, sourceUrl);
					x.Append(".");
				}
				x.EndParagraph();
			}
		}
		
		if (currentParameter != null && !currentParameter.Name.NE()) { //if tuple, Name is "" and then would be exception
			x.StartParagraph("parameter");
			x.Bold(currentParameter.Name); x.Append(":  ");
			var tt = currentParameter.DocumentationFactory?.Invoke(default);
			//rejected. Use inheritdoc. This would cover only part of cases.
			//if (!tt.Any()) { //if this parameter of this overload is undocumented, look for parameter with same name in other overloads
			//	for (int i = 0; i < r.Items.Count; i++) {
			//		if (i == iSel) continue;
			//		var p = r.Items[i].Parameters.FirstOrDefault(o => o.Name == currentParameter.Name);
			//		if (p != null) {
			//			tt = p.DocumentationFactory?.Invoke(default);
			//			if (tt.Any()) break;
			//		}
			//	}
			//}
			x.AppendTaggedParts(tt, false);
			x.EndParagraph();
		}
		
		return x.Result;
	}
	
	static List<ISignatureHelpProvider> _GetSignatureHelpProviders() {
		var a = new List<ISignatureHelpProvider>();
		var types = Assembly.GetAssembly(typeof(InvocationExpressionSignatureHelpProvider)).DefinedTypes;
		foreach (var t in types.Where(t =>
			t.Namespace == "Microsoft.CodeAnalysis.CSharp.SignatureHelp"
			&& t.IsDefined(typeof(ExportSignatureHelpProviderAttribute))
			//&& t.ImplementedInterfaces.Contains(typeof(ISignatureHelpProvider)) && !t.IsAbstract
			)) {
			//print.it(t);
			var c = t.GetConstructor(Type.EmptyTypes);
			Debug_.PrintIf(c == null, t.ToString());
			if (c == null) continue;
			var o = c.Invoke(null) as ISignatureHelpProvider; Debug.Assert(o != null); if (o == null) continue;
			a.Add(o);
		}
		return a;
	}
	
	List<ISignatureHelpProvider> _SignatureHelpProviders => _shp ??= _GetSignatureHelpProviders();
	List<ISignatureHelpProvider> _shp;
	
	public bool OnCmdKey(KKey key) {
		if (_data != null) {
			switch (key) {
			case KKey.Escape:
				Cancel();
				return true;
			case KKey.Down:
			case KKey.Up:
				int i = _data.iSelected, n = _data.r.Items.Count;
				if (key == KKey.Down) {
					if (++i >= n) i = 0;
				} else {
					if (--i < 0) i = n - 1;
				}
				if (i != _data.iSelected) _textPopup.Text = _FormatText(i, userSelected: true);
				return true;
			}
		}
		return false;
	}
}


================================================
FILE: Au.Editor/Edit/CiSnippets.cs
================================================
extern alias CAW;

using Microsoft.CodeAnalysis;
using CAW::Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Text;
using Microsoft.CodeAnalysis.CSharp.Extensions;
using Microsoft.CodeAnalysis.Shared.Extensions;
using CAW::Microsoft.CodeAnalysis.Shared.Extensions;
using Microsoft.CodeAnalysis.CSharp.Extensions.ContextQuery;

using System.Xml.Linq;
using Au.Controls;
using System.Windows.Input;

namespace LA;

static class CiSnippets {
	class _CiComplItemSnippet : CiComplItem {
		public readonly XElement x;
		public _Context context;
		public readonly string customFile, sortText;
		
		public _CiComplItemSnippet(string name, XElement x, string customFile) : base(CiComplProvider.Snippet, name, CiItemKind.Snippet) {
			this.x = x;
			this.customFile = customFile;
			sortText = name.Ends("Snippet") ? name[..^7] : name.Ends("Surround") ? name[..^8] : name;
		}
	}
	
	static List<_CiComplItemSnippet> s_items;
	
	[Flags]
	enum _Context {
		None,
		Namespace = 1, //global, namespace{ }
		Type = 2, //class{ }, struct{ }, interface{ }
		Function = 4, //method{ }, lambda{ }
		Arrow = 8, //lambda=>, function=>
		Attributes = 16, //[Attributes]
		Unknown = 32,
		Any = 0xffff,
		Line = 0x10000, //at start of line
		/*
		
		A context specifies where in code to add the snippets to the completion list. Several contexts can be combined.
		- **Function** - inside function body. Also in the main script code (top-level statements).
		- **Type** - inside a class, struct or interface but not inside functions. Use for snippets that insert entire methods, properties, etc.
		- **Namespace** - outside of types. Use for snippets that insert entire types.
		- **Attributes** - use for snippets that insert an `[attribute]`.
		- **Line** - at the start of a line. For example check **Line** and **Any** for snippets that insert a `#directive`.
		- **Any** - anywhere.
		- **None** - nowhere.
		
		*/
	}
	
	static _Context s_context;
	
	public static void AddSnippets(List<CiComplItem> items, TextSpan span, CompilationUnitSyntax root, string code, bool surround, CSharpSyntaxContext syncon = null) {
		if (syncon != null) {
			//CSharpSyntaxContext was discovered later and therefore almost not used here.
			if (syncon.IsObjectCreationTypeContext) return;
			//CiUtil.DebugGetContextType(syncon);
		}
		
		_Context context = _Context.Unknown;
		int pos = span.Start;
		bool inDirective = pos > 0 && code[pos - 1] == '#' && !surround; //when invoked the list after #, span does not include #
		
		if (inDirective) {
		} else if (pos < root.GetHeaderLength()) {
		} else {
			//get node from start
			var token = root.FindToken(pos);
			var node = token.Parent;
			
			//find ancestor/self that contains pos inside
			while (node != null && !node.Span.ContainsInside(pos)) node = node.Parent;
			
			switch (node) {
			case BlockSyntax:
			case SwitchSectionSyntax: //between case: and break;
			case ElseClauseSyntax:
			case LabeledStatementSyntax:
			case IfStatementSyntax s1 when pos > s1.CloseParenToken.SpanStart:
			case WhileStatementSyntax s2 when pos > s2.CloseParenToken.SpanStart:
			case DoStatementSyntax s3 when pos < s3.WhileKeyword.SpanStart:
			case ForStatementSyntax s4 when pos > s4.CloseParenToken.SpanStart:
			case CommonForEachStatementSyntax s5 when pos > s5.CloseParenToken.SpanStart:
			case LockStatementSyntax s6 when pos > s6.CloseParenToken.SpanStart:
			case FixedStatementSyntax s7 when pos > s7.CloseParenToken.SpanStart:
			case UsingStatementSyntax s8 when pos > s8.CloseParenToken.SpanStart:
				context = _Context.Function;
				break;
			case TypeDeclarationSyntax td when pos > td.OpenBraceToken.Span.Start: //{ } of class, struct, interface, extension
				context = _Context.Type;
				break;
			case NamespaceDeclarationSyntax ns when pos > ns.OpenBraceToken.Span.Start:
			case FileScopedNamespaceDeclarationSyntax ns2 when pos >= ns2.SemicolonToken.Span.End:
				context = _Context.Namespace;
				break;
			case CompilationUnitSyntax:
			case null:
				context = _Context.Namespace | _Context.Function; //Function for top-level statements. TODO3: only if in correct place.
				break;
			case LambdaExpressionSyntax:
			case ArrowExpressionClauseSyntax: //like void F() =>here
				context = _Context.Arrow;
				break;
			case AttributeListSyntax:
				context = _Context.Attributes;
				break;
			default:
				if (span.IsEmpty) { //if '=> here;' or '=> here)' etc, use =>
					var t2 = token.GetPreviousToken();
					if (t2.IsKind(SyntaxKind.EqualsGreaterThanToken) && t2.Parent is LambdaExpressionSyntax) context = _Context.Arrow;
				}
				break;
			}
		}
		s_context = context;
		
		if (s_items == null) {
			var a = new List<_CiComplItemSnippet>();
			foreach (var f in filesystem.enumFiles(AppSettings.DirBS, "*Snippets.xml")) _LoadFile(f.FullPath, true);
			_LoadFile(DefaultFile, false);
			if (a.Count == 0) return;
			a.Sort((x, y) => { //for the surround list
				int r = CiUtil.SortComparer.Compare(x.sortText, y.sortText);
				if (r == 0) return (x.customFile != null ? 0 : 1) - (y.customFile != null ? 0 : 1); //custom first
				return r;
			});
			_DetectContextsOfSnippets(a);
			s_items = a;
			
			void _LoadFile(string file, bool custom) {
				try {
					var hidden = DSnippets.GetHiddenSnippets(custom ? pathname.getName(file) : "default");
					if (hidden?.Contains("") == true) return;
					
					var customFile = custom ? pathname.getName(file) : null;
					var xroot = LoadSnippetsFile_(file);
					if (xroot == null) return;
					foreach (var xs in xroot.Elements("snippet")) {
						var name = xs.Attr("name");
						if (hidden?.Contains(name) == true) continue;
						a.Add(new _CiComplItemSnippet(name, xs, customFile));
					}
				}
				catch (Exception ex) { print.it("Failed to load snippets from " + file + "\r\n\t" + ex.ToStringWithoutStack()); }
			}
		}
		
		bool isLineStart = CiUtil.IsLineStart(code, pos - (inDirective ? 1 : 0));
		
		for (int i = 0; i < s_items.Count; i++) {
			var v = s_items[i];
			if (!v.context.HasAny(context)) continue;
			if (v.context.Has(_Context.Line) && !isLineStart) continue;
			if (!surround && v.Text.Ends("Surround")) continue;
			if (inDirective) {
				if (v.Text[0] != '#') continue;
				v = new _CiComplItemSnippet(v.Text[1..], v.x, v.customFile); //like in VS. Else typing-filtering does not work.
			}
			v.group = 0; v.hidden = 0; v.hilite = 0; v.moveDown = 0;
			v.GetCI().Span = span;
			items.Add(v);
		}
	}
	
	internal static XElement LoadSnippetsFile_(string file) {
		var xroot = XmlUtil.LoadElem(file);
		if (xroot.Name != "snippets") {
			if (xroot.Name == "Au.Snippets") {
				xroot = _ConvertOldFormat(xroot);
				try { xroot.Save(file); } catch { }
			} else return null;
		}
		return xroot;
		
		static XElement _ConvertOldFormat(XElement xRootOld) {
			var xRootNew = new XElement("snippets");
			foreach (var xg in xRootOld.Elements("group")) {
				foreach (var xs in xg.Elements("snippet")) {
					_ConvertSnippet(xs);
					xRootNew.Add(xs);
				}
			}
			return xRootNew;
			
			static void _ConvertSnippet(XElement xs) {
				if (!xs.HasElements) _ConvertCode(xs);
				else foreach (var x in xs.Elements("list")) _ConvertCode(x);
				
				static void _ConvertCode(XElement x) {
					if (x.Value is string v) {
						if (v.Find("$end$") is int i1 && i1 >= 0) { //$end$xxx$end$ -> ${1:xxx}, or $end$ -> $0
							int i1end = i1 + 5;
							if (v.Find("$end$", i1end) is int i2 && i2 > 0) v = v.ReplaceAt(i1..(i2 + 5), "${1:" + v[i1end..i2] + "}");
							else v = v.ReplaceAt(i1..i1end, i1end < v.Length && v[i1end] is >= '0' and <= '9' ? "${0}" : "$0");
						}
						v = v.Replace("$random$", "${RANDOM}");
						v = v.Replace("$guid$", "${GUID}");
						v = v.Replace("$var$", "${VAR}");
						x.Value = v;
					}
				}
			}
		}
	}
	
	static void _DetectContextsOfSnippets(List<_CiComplItemSnippet> a) {
		regexp rx1 = new(@"\$(?|(VAR|RANDOM|RANDOM_HEX|TM_FILENAME_BASE)\b|\{((?1))\})"),
			rx2 = new(@"\$(?|([1-9]\d*)(?!\d)|\{((?1))\})"),
			rx3 = new(@"\$(?:\{[A-Z_]+\}|[A-Z_]+\b|0|\{0\})"),
			rx4 = new(@"\$\{\d+:(.*?)\}");
		
		Parallel.ForEach(a, v => {
			if (v.x.Attr("context") is string s) {
				v.context = _GetFromAttr(s);
			} else {
				var x = v.x.HasElements ? v.x.Elements().First() : v.x;
				v.context = _Detect(x.Value, v.Text);
			}
		});
		
		_Context _Detect(string code, string name) {
			if (code.NE()) return _Context.None;
			
			code = rx1.Replace(code, "$1");
			code = rx2.Replace(code, "i");
			code = rx3.Replace(code, "");
			code = rx4.Replace(code, "$1");
			
			//bool debug = name.Starts("ctor");
			//if (debug) {
			//	print.it($"<><lc #B3DF00>{name}<>\r\n<\a>{code}</\a>");
			//}
			
			try {
				var cu = CiUtil.CreateSyntaxTree(code);
				if (cu.Usings.Any() || cu.Externs.Any() || cu.AttributeLists.Any()) return _Context.Namespace;
				if (!cu.Members.Any()) {
					if (cu.ContainsDirectives) return _Context.Any | _Context.Line;
					if (code.Starts("/// ")) return _Context.Namespace | _Context.Type | _Context.Line;
					return _Context.Any;
				}
				if (cu.Members.Any(SyntaxKind.GlobalStatement)) {
					if (!cu.Members.All(o => o is GlobalStatementSyntax)) {
						if (cu.Members[0] is GlobalStatementSyntax) return _Context.Namespace; //TLS + types
						//Debug_.Print($"{name}: GlobalStatement after non-global");
						if (_TryInClass()) return _Context.Type;
						return _Context.Function;
					}
					foreach (GlobalStatementSyntax gs in cu.Members) {
						var stat = gs.Statement;
						if (stat is LocalFunctionStatementSyntax) { //can be local or member function
							if (_TryInClass()) return _Context.Type;
						} else if (stat is LocalDeclarationStatementSyntax lds) { //can be local or member variable
							if (lds.Declaration.Type.IsVar) return _Context.Function;
						} else {
							if (_TryInClass()) return _Context.Type;
							//if (stat is ExpressionStatementSyntax ess && ess.SemicolonToken.IsMissing && ess.Expression is InvocationExpressionSyntax && cu.Members.Count == 1) return _Context.Attributes; //`Attribute(...)` //rejected
							return _Context.Function;
						}
					}
					return _Context.Type | _Context.Function;
				} else {
					if (cu.Members.Any(o => o is BaseNamespaceDeclarationSyntax)) return _Context.Namespace;
					if (cu.Members.All(o => o is BaseTypeDeclarationSyntax)) return _Context.Namespace | _Context.Type;
					return _Context.Type;
				}
				
				bool _TryInClass(bool debug = false) {
					try {
						int n1 = cu.GetDiagnostics().Count();
						if (n1 == 0) return false;
						var cu2 = CiUtil.CreateSyntaxTree("class C{\r\n" + code + "\r\n}");
						var d2 = cu2.GetDiagnostics();
						int n2 = d2.Count();
						if (n2 >= n1) return false;
						if (n2 > 0 && d2.Any(o => o.Code == 1519)) return false; //"Invalid token 'token' in class, struct, or interface member declaration". Eg elseSnippet.
						return true;
					}
					catch { return false; }
				}
			}
			catch { return _Context.Any; }
		}
		
		static _Context _GetFromAttr(string s) {
			_Context r = 0;
			foreach (var se in s.SplitSE(.., '|')) {
				r |= s.AsSpan(se.Range) switch {
					"Function" => _Context.Function | _Context.Arrow,
					"Type" => _Context.Type,
					"Namespace" => _Context.Namespace,
					"Attributes" => _Context.Attributes,
					"Any" => _Context.Any,
					"Line" => _Context.Line,
					_ => 0
				};
			}
			return r;
		}
	}
	
	public static void Reload() => s_items = null;
	
	public static int Compare(CiComplItem i1, CiComplItem i2) {
		if (i1 is _CiComplItemSnippet x && i2 is _CiComplItemSnippet y) {
			return (x.customFile != null ? 0 : 1) - (y.customFile != null ? 0 : 1); //sort custom first
		}
		return 0;
	}
	
	public static System.Windows.Documents.Section GetDescription(CiComplItem item) {
		var snippet = item as _CiComplItemSnippet;
		var m = new CiText();
		m.StartParagraph();
		m.Append("Snippet ");
		m.StartBold(); m.Hyperlink($"^snippet {snippet.Text}|{snippet.customFile ?? "default"}", item.Text); m.EndBold(); //DSnippets.ShowSingle(snippet.Text);
		m.Append(".");
		_AppendInfo(snippet.x);
		bool isList = snippet.x.HasElements;
		if (isList) {
			foreach (var v in snippet.x.Elements("list")) {
				m.Separator();
				m.StartParagraph();
				m.Append(StringUtil.RemoveUnderlineChar(v.Attr("item")));
				_AppendInfo(v);
				_AppendCode(v);
			}
		} else {
			_AppendCode(snippet.x);
		}
		if (snippet.x.Attr(out string more, "more")) {
			if (isList) m.Separator();
			m.StartParagraph(); m.Append(more); m.EndParagraph();
		}
		
		//CONSIDER: add link "Edit". User suggestion.
		
		return m.Result;
		
		void _AppendInfo(XElement x) {
			if (x.Attr(out string info, "info")) m.Append(" " + info);
			m.EndParagraph();
		}
		
		void _AppendCode(XElement x) {
			m.CodeBlock(x.Value.Replace("$end$", ""));
		}
	}
	
	/// <summary>
	/// Surrounds a text range with a snippet.
	/// </summary>
	/// <param name="snippetXml">If null, shows menu with all "surround" snippets that are valid at current place in code. Else can be either full snippet XML or just code; must contain <c>${SELECTED_TEXT}</c>.</param>
	/// <param name="range">If null, uses the selected range, or current statement etc if there is no selection.</param>
	/// <remarks>
	/// Can also insert using directives etc where need.
	/// Formats the text and snippet.
	/// Can start snippet mode (Tab-navigation etc).
	/// </remarks>
	public static void Surround(string snippetXml = null, Range? range = null) {
		if (!CodeInfo.GetContextAndDocument(out var k)) return;
		var (from, to) = range?.GetStartEnd(k.code.Length) ?? GetSurroundRange(k);
		
		XElement x;
		if (snippetXml != null) {
			if (!snippetXml.Starts('<')) snippetXml = "<snippet><![CDATA[" + snippetXml + "]]></snippet>";
			x = XElement.Parse(snippetXml);
		} else {
			List<CiComplItem> a = new();
			AddSnippets(a, new(from, 0), k.syntaxRoot, k.code, true);
			if (a.Count == 0) return;
			
			var m = new popupMenu { RawText = true };
			List<XElement> list = new();
			foreach (_CiComplItemSnippet snippet in a) {
				string name = null;
				if (snippet.x.HasElements) {
					list.Clear();
					foreach (var v in snippet.x.Elements("list")) if (_CanAdd(v)) list.Add(v);
					if (list.Count > 3) {
						var sub = new popupMenu { RawText = true };
						foreach (var v in list) _Add(sub, v, true);
						m.Submenu(name, () => sub);
					} else if (list.Count > 0) {
						foreach (var v in list) _Add(m, v, true);
					}
				} else {
					if (_CanAdd(snippet.x)) _Add(m, snippet.x, false);
				}
				
				bool _CanAdd(XElement x) => x.Value.Contains("${SELECTED_TEXT}");
				
				void _Add(popupMenu m, XElement x, bool listItem) {
					string s = name;
					if (s == null) {
						s = snippet.Text;
						if (s.Like("*?Snippet")) s = s[..^7];
						else if (s.Like("*?Surround")) s = s[..^8];
						name = s;
					}
					if (listItem) s = s + "  |  " + StringUtil.RemoveUnderlineChar(x.Attr("item"));
					var v = m.Add(s);
					v.Tag = x;
					v.Tooltip = snippet.x.Attr("info") + "\n\n" + x.Value;
				}
				//CONSIDER: hotkeys for surround snippets.
			}
			if (0 == m.Show()) return;
			x = m.Result.Tag as XElement;
		}
		
		if (to - from > 1 && k.code[to - 1] == '\n') {
			if (k.code[--to - 1] == '\r') to--;
		}
		
		_Commit(k.sci, from, to, x, k.code[from..to]);
	}
	
	/// <summary>
	/// Gets range for surround.
	/// If there is selection, returns the selected range.
	/// Else if caret is inside or touches a statement etc, gets its full span.
	/// Else returns empty range at caret position.
	/// </summary>
	public static (int start, int end) GetSurroundRange(CodeInfo.Context k) {
		var (from, to) = k.sci.aaaSelection(true);
		if (from == to) {
			var stat = k.syntaxRoot.FindToken(from).Parent.GetStatementEtc(from);
			if (stat is not (null or BlockSyntax)) {
				var span = stat.GetRealFullSpan(minimalLeadingTrivia: !true);
				if (span.ContainsOrTouches(from)) (from, to) = span;
			}
			if (to == from && to > 0 && !(stat is BlockSyntax && stat.Span.ContainsInside(from))) from = to = k.code.LastIndexOf('\n', to - 1) + 1;
		}
		return (from, to);
	}
	
	public static void Commit(SciCode doc, CiComplItem item, int codeLenDiff) {
		doc.SnippetMode_?.End();
		
		var snippet = item as _CiComplItemSnippet;
		var x = snippet.x;
		
		//list of snippets?
		if (x.HasElements) {
			var a = x.Elements("list").ToArray();
			var m = new popupMenu();
			foreach (var v in a) m.Add(v.Attr("item"));
			m.FocusedItem = m.Items.First();
			int g = m.Show(PMFlags.ByCaret | PMFlags.Underline);
			if (g == 0) return;
			x = a[g - 1];
		}
		
		var span = item.GetCI().Span;
		_Commit(doc, span.Start, span.End + codeLenDiff, x);
	}
	
	static void _Commit(SciCode doc, int pos, int endPos, XElement x, string surroundText = null) {
		doc.SnippetMode_?.End();
		
		var xSnippet = x.Name == "list" ? x.Parent : x;
		
		string s = x.Value;
		
		//##directive -> #directive
		if (s.Starts('#') && doc.aaaText.Eq(pos - 1, '#')) s = s[1..];
		
		//get variable name from code
		string varName = null;
		if (_GetAttr("var", out string attrVar)) {
			if (attrVar.RxMatch(@"^(.+?), *(.+)$", out var m)) {
				try {
					var t = CiUtil.GetNearestLocalVariableOfType(m[1].Value);
					varName = t?.Name ?? m[2].Value;
				}
				catch (ArgumentException ex1) { print.it($"Error in {xSnippet.Attr("name")}: {ex1.Message}"); }
			}
		}
		
		//enclose in { } if in =>
		if (s_context == _Context.Arrow && !s.Starts("throw ")) {
			if (s.Contains('\n')) {
				s = "{\r\n" + s.RxReplace(@"(?m)^", "\t") + "\r\n}";
			} else {
				s = "{ " + s + " }";
			}
			//never mind: should add ; if missing
		}
		
		//rejected: ensure unique names of declared variables.
		
		//maybe need meta comments
		if (_GetAttr("meta", out var attrMeta)) {
			int len1 = doc.aaaLen16;
			if (InsertCode.MetaComment(attrMeta)) {
				int lenDiff = doc.aaaLen16 - len1;
				pos += lenDiff;
				endPos += lenDiff;
			}
		}
		
		//maybe need using directives
		if (_GetAttr("using", out var attrUsing)) {
			int len1 = doc.aaaLen16;
			if (InsertCode.UsingDirective(attrUsing)) {
				int lenDiff = doc.aaaLen16 - len1;
				pos += lenDiff;
				endPos += lenDiff;
			}
		}
		
		new CiSnippetMode(pos, endPos, s, doc, varName, surroundText);
		
		if (_GetAttr("print", out var attrPrint)) {
			print.it(attrPrint.Insert(attrPrint.Starts("<>") ? 2 : 0, "Snippet " + xSnippet.Attr("name") + " says: "));
		}
		
		bool _GetAttr(string name, out string value) => x.Attr(out value, name) || (x != xSnippet && xSnippet.Attr(out value, name));
	}
	
	public static readonly string DefaultFile = folders.ThisApp + @"Default\Snippets.xml";
	public static readonly string CustomFile = AppSettings.DirBS + "Snippets.xml";
}

class CiSnippetMode {
	//$n/${n:text} info.
	record struct _Dollar(int n, string text, int offset, int len);
	
	//$n/${n:text} info used in snippet mode.
	class _Field {
		public int start, end, n;
#if DEBUG
		public override string ToString() => $"_Field {n} ({start}..{end})";
#endif
	}
	
	SciCode _doc;
	_Field[] _fields;
	_Field _activeField, _modifiedField;
	StartEnd _range;
	int _finalCaretPos;
	bool _ignoreModified, _ignorePosChanged;
	bool _isSurround;
	
	const string c_markComment = "/*\f\v*/", c_markAlt = "__\f\v__";
	
	public CiSnippetMode(int pos, int endPos, string s, SciCode doc, string varName, string selectedText) {
		_doc = doc;
		_isSurround = !selectedText.NE();
		
		//replace escape sequences in an easy but not perfect way
		bool escaped = 0 != s.RxReplace(@"\\[$}\\]", m => m.Subject[m.End - 1] switch { '$' => "\uf100", '}' => "\uf101", _ => "\uf102" }, out s); //Unicode private use area
		
		//in a `/* */` use c_markAlt instead of c_markComment
		var blockComments = s.RxIsMatch(@"/\*.+?\*/") && CiUtil.CreateSyntaxTree(s) is { } cu ? cu.DescendantTrivia().Where(o => o.Kind() is SyntaxKind.MultiLineCommentTrivia or SyntaxKind.MultiLineDocumentationCommentTrivia).Select(o => o.Span).ToArray() : null;
		
		List<_Dollar> dollars = null;
		if (s.Contains('$')) {
			StringBuilder b = new();
			int i = 0;
			bool hasDollar0 = false;
			foreach (var m in s.RxFindAll(@"(?s)\$(?:(?|\{(\d+)(?::(.+?))?\}|(\d+))|\{([A-Z].+?)\})")) {
				b.Append(s, i, m.Start - i);
				i = m.End;
				if (m[3].Exists) { //variable, eg ${SELECTED_TEXT}
					var v = m[3].Value;
					b.Append(_Variable(v));
				} else { //field, eg ${1:i} or $1
					dollars ??= new();
					
					int n = m[1].Value.ToInt();
					if (n == 0) {
						if (hasDollar0) continue; //error in snippet. Multiple $0 have no sense.
						hasDollar0 = true;
					}
					
					string v = _Trim(m[2].Value);
					if (v.NE()) {
						if (n != 0) foreach (var q in dollars) if (q.n == n && q.text != null) { v = q.text; break; } //eg `${n:s}, $n`. But ignore `$n, ${n:s}`, it's insane.
					} else if (v.Starts('$')) {
						v = _Variable(v[1..]);
					}
					
					v = v.NullIfEmpty_();
					string v2 = v;
					v ??= blockComments?.Any(o => o.ContainsInside(m.Start)) == true ? c_markAlt : c_markComment;
					
					dollars.Add(new(n, v2, b.Length, v.Length));
					b.Append(v);
				}
			}
			if (b.Length > 0) {
				b.Append(s, i, s.Length - i);
				s = b.ToString();
			}
		}
		
		if (escaped) s = s.Replace('\uf100', '$').Replace('\uf101', '}').Replace('\uf102', '\\');
		
		_Start(pos, endPos, s, dollars);
		
		string _Variable(string v) {
			string def = null;
			int i = v.IndexOf(':');
			if (i > 0) { def = v[++i..]; v = v[..--i]; }
			v = v switch {
				"SELECTED_TEXT" => selectedText,
				"VAR" => varName ?? "VAR",
				"GUID" => Guid.NewGuid().ToString(),
				"RANDOM" => new Random().Next(0, 1000000).ToString("d6"),
				"RANDOM_HEX" => new Random().Next(0, 0x1000000).ToString("x6"),
				"TM_FILENAME_BASE" => v, //info: TM_FILENAME_BASE is used in VSCode snippets
				_ => null
			};
			return v.NE() ? def : v;
		}
		
		static bool _IsSpace(char c) => SyntaxFacts.IsWhitespace(c) || SyntaxFacts.IsNewLine(c);
		
		static string _Trim(string s) {
			if (s != null) {
				int i = 0; while (i < s.Length && _IsSpace(s[i])) i++;
				int j = s.Length; while (j > i && _IsSpace(s[j - 1])) j--;
				if (i > 0 || j < s.Length) s = s[i..j];
			}
			return s;
		}
		
		//not supported these rarely used features:
		//	Rarely used variables.
		//	$VARIABLE. Supports only ${VARIABLE} and ${1:$VARIABLE}.
		//	Supports variables in field default value only in the simplest form: ${1:$VARIABLE}.
		//	Nested fields, like ${1:a ${2:b}}.
		//	Choice, like ${1|one,two,three|}.
		//	Variable transforms (regex).
		//	isFileTemplate.
	}
	
	//s - snippet code modified by ctor.
	void _Start(int pos, int endPos, string s, List<_Dollar> dollars) {
		int pos0 = pos;
		ModifyCode.FormatForInsert(ref s, ref pos, endPos, dollars == null ? null : _ChangesCallback);
		
		void _ChangesCallback(IList<TextChange> a) {
			var d = dollars.AsSpan();
			foreach (ref var v in d) v.offset += pos0 - pos;
			for (int i = d.Length; --i >= 0;) {
				int dStart = d[i].offset + pos, dEnd = dStart + d[i].len;
				//print.it($"dStart={dStart}, dEnd={dEnd}");
				foreach (var v in a) {
					int cStart = v.Span.Start, cEnd = v.Span.End;
					if (cStart >= dEnd) break;
					Debug.Assert(!((cStart < dStart && cEnd > dStart) || (cStart < dEnd && cEnd > dEnd))); //a change must not span dStart or dEnd
					var dif = v.NewText.Length - (cEnd - cStart);
					if (cStart <= dStart) d[i].offset += dif;
					else d[i].len += dif;
				}
			}
		}
		
		//delete semicolon?
		if (_doc.aaaText.Eq(endPos, ';') ) {
			var cu = CiUtil.CreateSyntaxTree(s);
			var tok = cu.GetLastToken(includeSkipped: true, includeDirectives: true);
			if (tok.Kind() is SyntaxKind.SemicolonToken or SyntaxKind.CloseBraceToken || tok.Parent is DirectiveTriviaSyntax || tok.Parent?.Parent is DirectiveTriviaSyntax) {
				endPos++;
				if (s.Ends(' ')) s = s[..^1]; //added when formatting
			}
		}
		
		//CodeInfo.Pasting(_doc, silent: true); //to auto-add missing using directives //rejected. Does not work well with EReplaceTextGently (because it makes multiple modifications). Namespaces can be specified in snippet.
		if (dollars == null) {
			_doc.aaaReplaceRange(true, pos, endPos, s, true);
		} else {
			//remove markers of empty fields
			for (int i = dollars.Count; --i >= 0;) {
				if (dollars[i].text == null) {
					int len = dollars[i].len;
					s = s.Remove(dollars[i].offset, len);
					dollars.Ref(i).len = 0;
					for (int j = i + 1; j < dollars.Count; j++) dollars.Ref(j).offset -= len;
				}
			}
			//never mind: the formatter splits line `/*mark*/code` -> `/*mark*/\r\ncode`
			
			if (_isSurround) _doc.EReplaceTextGently(pos, endPos, s);
			else _doc.aaaReplaceRange(true, pos, endPos, s);
			
			int nDollar0 = 0; //max 1
			foreach (ref var v in dollars.AsSpan()) {
				v.offset += pos;
				if (v.n == 0) nDollar0++;
			}
			
			if (dollars.Count == 1) {
				var d = dollars[0];
				_doc.aaaSelect(true, d.offset, d.offset + d.len, makeVisible: true);
				
				//show signature if like `Method($0...``. Also may need to add temp range.
				if (d.len == 0) {
					int k = d.offset - pos; //$n offset in s
					bool showSignature = s.RxIsMatch(@"\w[([][^)\]]*""?$", range: ..k);
					(int from, int to) tempRange = default;
					if (s.Eq(k - 1, "()") || s.Eq(k - 1, "[]") || s.Eq(k - 1, "\"\"")) tempRange = (d.offset, d.offset);
					else if (s.Eq(k - 2, "{  }")) tempRange = (d.offset - 1, d.offset + 1);
					
					if (tempRange.to > 0) CodeInfo._correct.BracketsAdded(_doc, tempRange.from, tempRange.to, default);
					if (showSignature) CodeInfo.ShowSignature();
				}
			} else {
				_fields = new _Field[dollars.Count - nDollar0];
				_finalCaretPos = -1;
				
				int fi = 0, iStart = 0, nStart = int.MaxValue;
				foreach (var v in dollars) {
					if (v.n == 0) {
						_finalCaretPos = _doc.aaaPos8(v.offset);
					} else {
						if (v.n < nStart) { nStart = v.n; iStart = fi; }
						var f = new _Field { n = v.n, start = v.offset, end = v.offset + v.len };
						_doc.aaaNormalizeRange(true, ref f.start, ref f.end);
						_doc.aaaIndicatorAdd(SciTheme.Indic.SnippetField, false, f.start..f.end, f.n);
						_fields[fi++] = f;
					}
				}
				
				_range = new(pos, pos + s.Length);
				_doc.aaaNormalizeRange(true, ref _range.start, ref _range.end);
				
				_SetActiveField(_fields[iStart], select: true);
				
				_doc.SnippetMode_ = this;
			}
		}
	}
	
	public void End(bool goToFinal = false) {
		if (_doc.SnippetMode_ != this) return;
		_doc.SnippetMode_ = null;
		
		_doc.aaaIndicatorClear(SciTheme.Indic.SnippetField);
		
		_FieldLeaved(true);
		
		if (goToFinal) _doc.aaaGoToPos(false, _finalCaretPos >= 0 ? _finalCaretPos : _range.end);
	}
	
	void _SetActiveField(_Field field, bool select) {
		if (field == _activeField) return;
		_FieldLeaved();
		_activeField = field;
		foreach (var f in _fields) {
			if (f.n == field.n) {
				_doc.aaaIndicatorAdd(SciTheme.Indic.SnippetFieldActive, false, f.start..f.end, f.n);
				_doc.aaaIndicatorClear(SciTheme.Indic.SnippetField, false, f.start..f.end); //erase SciTheme.Indic.SnippetField to avoid mixed color
			}
		}
		if (select) {
			_ignorePosChanged = true;
			_doc.aaaSelect(false, field.start, field.end);
			_ignorePosChanged = false;
		}
	}
	
	void _FieldLeaved(bool ending = false) {
		if (_activeField == null) return;
		var af = _activeField; _activeField = null;
		_doc.aaaIndicatorClear(SciTheme.Indic.SnippetFieldActive);
		if (!ending) { //restore SciTheme.Indic.SnippetField erased by _SetActiveField
			foreach (var v in _fields) {
				if (v.n == af.n) _doc.aaaIndicatorAdd(SciTheme.Indic.SnippetField, false, v.start..v.end, v.n);
			}
		}
		_ReplaceTextOfRelatedFields(ending);
	}
	
	_Field _FieldFromPos(int pos, int pos2) {
		foreach (var f in _fields) if (pos >= f.start && pos2 <= f.end) return f;
		return null;
	}
	
	_Field _FieldFromSel() => _FieldFromPos(_doc.aaaSelectionStart8, _doc.aaaSelectionEnd8);
	
	public void SciModified(in Sci.SCNotification n) {
		if (_ignoreModified) return;
		
		bool deleted = n.modificationType.Has(Sci.MOD.SC_MOD_DELETETEXT);
		int pos = n.position, len = n.length, pos2 = deleted ? pos + len : pos;
		
		bool cancel = false, cantReplaceRelated = false;
		if (deleted) {
			//cancel etc if deleted entire snippet, or part of snippet together with other code, or any part of a field together with other code. Other cases detected by _FieldFromPos.
			if (pos <= _range.start && pos2 >= _range.end) { //probably Undo
				cancel = cantReplaceRelated = true;
			} else if (pos < _range.start) {
				cancel = true;
				cantReplaceRelated = pos2 > _range.start;
			} else if (pos2 > _range.end) {
				cancel = true;
				cantReplaceRelated = pos < _range.end;
			} else {
				foreach (var f in _fields) {
					if (pos < f.start) cancel = pos2 > f.start;
					else if (pos2 > f.end) cancel = pos < f.end;
					if (cancel) break;
				}
				if (cancel) cantReplaceRelated = true;
				//else cancel = pos < _finalCaretPos && pos2 > _finalCaretPos;
			}
		}
		
		var field = cancel ? null : _FieldFromPos(pos, pos2);
		if (field == null) {
			if (cantReplaceRelated) _modifiedField = null;
			End();
			return;
		}
		
		if (deleted) len = -len;
		foreach (var f in _fields) {
			if (f.start > pos) f.start += len;
			if (f.end >= pos2) f.end += len;
		}
		if (_finalCaretPos >= pos2) _finalCaretPos += len;
		_range.end += len;
		
		_doc.aaaIndicatorAdd(_activeField != null ? SciTheme.Indic.SnippetFieldActive : SciTheme.Indic.SnippetField, false, field.start..field.end, field.n);
		
		_modifiedField = field;
		
		//_TestShowFields();
	}
	
	public void SciPosChanged() {
		if (_ignorePosChanged) return;
		if (_FieldFromSel() is { } field) {
			_SetActiveField(field, select: false);
		} else {
			_FieldLeaved();
		}
	}
	
	public bool SciKey(KKey key, ModifierKeys mod) {
		switch ((key, mod)) {
		case (KKey.Escape, 0):
			End();
			return true;
		case (KKey.Enter, 0):
			if (_FieldFromSel() == null) break;
			End(goToFinal: true);
			return true;
		case (KKey.Tab, 0):
			return _Tab(false);
		case (KKey.Tab, ModifierKeys.Shift):
			return _Tab(true);
		}
		return false;
		
		bool _Tab(bool shift) {
			if (_activeField == null) return false;
			int i = Array.IndexOf(_fields, _activeField), nNow = _activeField.n, nNext;
			_Field fNext = null;
			if (shift) {
				nNext = 0;
				foreach (var f in _fields) if (f.n < nNow && f.n > nNext) { nNext = f.n; fNext = f; } //find max n that is > nNow
				if (nNext == 0) return true;
			} else {
				nNext = int.MaxValue;
				foreach (var f in _fields) if (f.n > nNow && f.n < nNext) { nNext = f.n; fNext = f; } //find min n that is > nNow
				if (nNext == int.MaxValue) {
					End(goToFinal: true);
					return true;
				}
			}
			_SetActiveField(fNext, select: true);
			return true;
		}
	}
	
	unsafe void _ReplaceTextOfRelatedFields(bool ending) {
		var field = _modifiedField; if (field == null) return;
		_modifiedField = null;
		if (_fields.Any(o => o.n == field.n && o != field)) {
			
			//workaround for: Scintilla selects some text when clicked somewhere in the same line after a replacement.
			//if (Api.GetCapture() == _doc.AaWnd) Api.ReleaseCapture(); //works, but then caret stars to flicker. Scintilla does not listen for released capture.
			if (Api.GetCapture() == _doc.AaWnd && mouse.isPressed(MButtons.Left)) {
				var xy = mouse.xy; _doc.AaWnd.MapScreenToClient(ref xy);
				_doc.AaWnd.Send(Api.WM_LBUTTONUP, 0, Math2.MakeLparam(xy));
			}
			
			int textLen = field.end - field.start;
			var text = MemoryUtil.Alloc(textLen);
			try {
				MemoryUtil.Copy(_doc.aaaRangePointer(field.start, field.end), text, textLen);
				_ignoreModified = true;
				using var undo = _doc.ENewUndoAction();
				foreach (var f in _fields) {
					if (f.n == field.n && f != field) {
						_doc.Call(Sci.SCI_SETTARGETRANGE, f.start, f.end);
						_doc.Call(Sci.SCI_REPLACETARGET, textLen, text);
						int len = textLen - (f.end - f.start), oldStart = f.start, oldEnd = f.end;
						if (_finalCaretPos >= oldEnd) _finalCaretPos += len;
						foreach (var q in _fields) {
							if (q.start > oldStart) q.start += len;
							if (q.end >= oldEnd) q.end += len;
						}
						_range.end += len;
					}
				}
			}
			finally {
				MemoryUtil.Free(text);
				_ignoreModified = false;
			}
			if (!ending) {
				foreach (var f in _fields) {
					if (f.n == field.n && f != field) {
						_doc.aaaIndicatorAdd(SciTheme.Indic.SnippetField, false, f.start..f.end, f.n);
					}
				}
			}
			//_TestShowFields();
		}
	}
	
	//#if DEBUG
	//	void _TestShowFields() {
	//		_doc.aaaIndicatorClear(SciTheme.Indic.TestStrike);
	//		_doc.aaaIndicatorClear(SciTheme.Indic.TestPoint);
	//		foreach (var f in _fields) {
	//			_doc.aaaIndicatorAdd(SciTheme.Indic.TestStrike, false, f.start..f.end);
	//		}
	//		if (_finalCaretPos >= 0) _doc.aaaIndicatorAdd(SciTheme.Indic.TestPoint, false, _finalCaretPos..(_finalCaretPos + 1));
	//	}
	//#endif
}


================================================
FILE: Au.Editor/Edit/CiStyling.cs
================================================
//#define PRINT

extern alias CAW;

//Code colors. Also calls functions of folding, images, errors.

using Au.Controls;
using static Au.Controls.Sci;
using static LA.SciTheme;

using Microsoft.CodeAnalysis;
using CAW::Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Text;
using CAW::Microsoft.CodeAnalysis.Classification;

namespace LA;

partial class CiStyling {
	public void DocHandleDestroyed(SciCode doc) {
		if (doc == _doc) {
			_doc = null; //GC. Not important, but helps when trying to detect memory leaks.
		}
	}
	
	/// <summary>
	/// Called after setting editor control text when a document opened (not just switched active document).
	/// </summary>
	public static void DocTextAdded() => CodeInfo._styling._DocTextAdded();
	void _DocTextAdded() {
		if (CodeInfo.IsReadyForStyling) {
			_timerOpened ??= new(_ => _DocChanged());
			_timerOpened.After(10); //not Dispatcher.InvokeAsync
		} else { //at program startup
			CodeInfo.ReadyForStyling += () => _DocChanged();
		}
	}
	
	/// <summary>
	/// Sets timer to updates styling and folding from 0 to the end of the visible area.
	/// </summary>
	public void Update() => _update = true;
	
	SciCode _doc; //to detect when the active document changed
	bool _update;
	bool _folded;
	Sci_VisibleRange _visibleLines;
	timer _timerModified, _timerOpened;
	int _modStart;
	int _modFromEnd; //like SCI_GETENDSTYLED, but from end
	int _diagCounter;
	CancellationTokenSource _cancelTS;
	
	void _DocChanged(SciCode doc = null) {
		//bool opened = doc == null;
		doc ??= Panels.Editor.ActiveDoc;
		if (doc == null) return;
		_doc = doc;
		_update = false;
		_folded = false;
		_visibleLines = default;
		_timerModified?.Stop();
		_modStart = _modFromEnd = int.MaxValue;
		_diagCounter = 0;
		_Work(doc, cancel: true);
		//if (opened) {
		//}
	}
	
	/// <summary>
	/// Called every 250 ms while editor is visible.
	/// </summary>
	public void Timer250msWhenVisibleAndWarm(SciCode doc) {
		//We can't use Scintilla styling notifications, mostly because of Roslyn slowness.
		//To detect when need styling and folding we use 'opened' and 'modified' events and 250 ms timer.
		//When modified, we do styling for the modified line(s). Redraws faster, but unreliable, eg does not update new/deleted identifiers.
		//The timer does styling and folding for all visible lines. Redraws with a bigger delay, but updates everything after modified, scrolled, resized, folded, etc.
		
		if (_cancelTS != null || (_timerModified?.IsRunning ?? false)) return;
		if (doc != _doc || _update) {
			_update = false;
			if (doc != _doc) _DocChanged(doc);
			else _Work(doc, cancel: true);
		} else {
			Sci_GetVisibleRange(doc.AaSciPtr, out var vr); //fast
			if (vr != _visibleLines) {
				_Work(doc);
			} else if (_diagCounter > 0 && --_diagCounter == 0) {
				CodeInfo._diag.Indicators(doc.aaaPos16(vr.posFrom), doc.aaaPos16(vr.posTo));
			}
		}
	}
	
	/// <summary>
	/// Called when editor text modified.
	/// </summary>
	public void SciModified(SciCode doc, in SCNotification n) {
		//Delay to avoid multiple styling/folding/cancelling on multistep actions (replace text range, find/replace all, autocorrection) and fast automated text input.
		_cancelTS?.Cancel(); _cancelTS = null;
		_modStart = Math.Min(_modStart, n.position);
		_modFromEnd = Math.Min(_modFromEnd, doc.aaaLen8 - n.FinalPosition);
		_folded = false;
		//using var p1 = perf.local();
#if true
		_timerModified ??= new timer(_ModifiedTimer);
		if (!_timerModified.IsRunning) { _timerModified.Tag = doc; _timerModified.After(25); }
#else
		_StylingAndFolding(doc, doc.aaaLineEndFromPos(false, doc.aaaLen8 - _modFromEnd, withRN: true));
#endif
		//workaround for:
		//	On Undo, if the undo text contains hidden text, Scintilla it seems tries to show that unstyled text before styleneeded notification.
		//	If the hidden text is long, it adds horz scrollbar and scrolls.
		//	Not if the undo text ends with newline.
		if (n.modificationType.Has(MOD.SC_LASTSTEPINUNDOREDO | MOD.SC_MOD_INSERTTEXT)) {
			doc.EHideImages_(n.position, doc.aaaLineEndFromPos(false, n.position + n.length));
			doc.aaaSetStyled();
		}
	}
	
	void _ModifiedTimer(timer t) {
		//var p1 = perf.local();
		var doc = t.Tag as SciCode;
		if (doc != Panels.Editor.ActiveDoc) return;
		if (_cancelTS != null) return;
		_Work(doc, doc.aaaLineStartFromPos(false, _modStart), doc.aaaLineEndFromPos(false, doc.aaaLen8 - _modFromEnd, withRN: true));
		//p1.NW('a'); //we return without waiting for the async task to complete
	}
	
	async void _Work(SciCode doc, int start8 = 0, int end8 = -1, bool cancel = false) {
#if PRINT
		using var p1 = perf.local();
#endif
		void _PN(char ch = default) {
#if PRINT
			p1.Next(ch);
#endif
		}
		
		if (cancel) { _cancelTS?.Cancel(); _cancelTS = null; }
		Debug.Assert(_cancelTS == null);
		var cancelTS = _cancelTS = new CancellationTokenSource();
		var cancelToken = cancelTS.Token;
		
		var cd = new CodeInfo.Context(0);
		Debug.Assert(doc == cd.sci);
		if (!cd.GetDocument()) return;
		var document = cd.document;
		var code = cd.code;
		_PN('d');
		try {
			Sci_GetVisibleRange(doc.AaSciPtr, out var vr);
			
			bool minimal = end8 >= 0;
			bool needFolding = !minimal && !_folded;
			List<SciFoldPoint> af = null;
			
			if (needFolding) {
				await Task.Run(() => {
					_PN('s');
					af = CiFolding.GetFoldPoints(cd.syntaxRoot, code, cancelToken);
				});
				if (_Canceled()) return;
			}
			_PN('p');
			
			if (minimal) {
				start8 = Math.Max(start8, vr.posFrom);
				end8 = Math.Min(end8, vr.posTo);
			} else {
				if (needFolding) {
					CiFolding.Fold(doc, af);
					_folded = true;
					Sci_GetVisibleRange(doc.AaSciPtr, out vr);
					_PN('F');
				}
				start8 = vr.posFrom;
				end8 = vr.posTo;
			}
			if (end8 <= start8) return;
			
#if PRINT
			//print.it($"<><c green>lines {doc.aaaLineFromPos(false, start8) + 1}-{doc.aaaLineFromPos(false, end8)}, range {start8}-{end8}, {vr}<>");
#endif
			
			var ar8 = _GetVisibleRanges();
			List<StartEnd> _GetVisibleRanges() {
				List<StartEnd> a = new();
				StartEnd r = new(start8, end8);
				for (int dline = doc.aaaLineFromPos(false, start8), dlinePrev = dline - 1, vline = doc.Call(SCI_VISIBLEFROMDOCLINE, dline); ; dline = doc.Call(SCI_DOCLINEFROMVISIBLE, ++vline)) {
					int i = doc.aaaLineStart(false, dline); if (i >= end8) break;
					if (dline > dlinePrev + 1) {
						a.Add(r);
						r.start = i;
					}
					r.end = i + doc.Call(SCI_LINELENGTH, dline);
					dlinePrev = dline;
				}
				a.Add(r);
				return a;
			}
			
			var ar = new (List<ClassifiedSpan> a, StartEnd r)[ar8.Count];
			for (int i = 0; i < ar8.Count; i++) ar[i].r = new StartEnd(doc.aaaPos16(ar8[i].start), doc.aaaPos16(ar8[i].end));
			SemanticModel semo = null;
			
			await Task.Run(async () => {
				semo = await document.GetSemanticModelAsync(cancelToken).ConfigureAwait(false);
				_PN('m'); //BAD: slow when [re]opening a file in a large project
				for (int i = 0; i < ar.Length; i++) {
					var r = ar[i].r;
					ar[i].a = CiUtil.GetClassifiedSpans(semo, document, r.start, r.end, cancelToken);
				}
				//info: GetClassifiedSpansAsync calls GetSemanticModelAsync and GetClassifiedSpans, like here.
				//GetSemanticModelAsync+GetClassifiedSpans are slow, ~ 90% of total time.
				//Tried to implement own "GetClassifiedSpans", but slow too, often slower, because GetSymbolInfo is slow.
			});
			if (_Canceled()) return;
			_PN('c');
			
			int start16 = doc.aaaPos16(start8), end16 = doc.aaaPos16(end8); //from now don't use UTF-8
			var b = new byte[end16 - start16];
			
			char prevPunctuation = default;
			foreach (var (a, r) in ar) {
				foreach (var v in a) {
					EStyle style = StyleFromClassifiedSpan(v);
					//print.it($"<><c green>{v.ClassificationType}<> '{code[v.TextSpan.Start..v.TextSpan.End]}' style={style}");
					
					if (style == EStyle.None) {
#if DEBUG
						switch (v.ClassificationType) {
						case ClassificationTypeNames.Identifier or ClassificationTypeNames.PreprocessorText: break;
						default: Debug_.PrintIf(!v.ClassificationType.Starts("regex"), $"<c gray>{v.ClassificationType}, {v.TextSpan}<>"); break;
						}
#endif
					} else {
						int spanStart = Math.Max(v.TextSpan.Start, r.start), spanEnd = Math.Min(v.TextSpan.End, r.end);
						b.AsSpan(spanStart - start16, spanEnd - spanStart).Fill((byte)style);
						if (style is EStyle.String && prevPunctuation is '(' or ',' or ':') _RegexString();
						prevPunctuation = style is EStyle.Punctuation ? code[v.TextSpan.End - 1] : default;
						
						void _RegexString() {
							//we need only verbatim and raw strings, and not interpolated
							bool verbatim = v.ClassificationType == ClassificationTypeNames.VerbatimStringLiteral;
							if (verbatim) {
								if (v.TextSpan.Length < 4 || !code.Eq(v.TextSpan.Start, "@\"")) return;
							} else {
								if (v.TextSpan.Length < 7 || !code.Eq(v.TextSpan.Start, "\"\"\"")) return;
							}
							
							var tok = cd.syntaxRoot.FindToken(v.TextSpan.Start); //fast here
							if (tok.Parent is not LiteralExpressionSyntax { RawKind: (int)SyntaxKind.StringLiteralExpression } node) return;
							var format = CiUtil.GetParameterStringFormat(tok.Parent, semo, true, ignoreInterpolatedString: true);
							if (!(format is PSFormat.Regexp or PSFormat.NetRegex or PSFormat.Wildex)) return;
							
							var (from, to) = v.TextSpan;
							if (verbatim) {
								from += 2; if (code[to - 1] is '"') to--;
							} else {
								while (from < to && code[from] is '"') { from++; if (code[to - 1] is '"') to--; }
								from = CiUtil.SkipNewline(code, CiUtil.SkipSpace(code, from));
								to = CiUtil.SkipNewlineBack(code, CiUtil.SkipSpaceBack(code, to));
							}
							from = Math.Max(from, start16);
							to = Math.Min(to, end16);
							if (to <= from) return;
							
							RegexParser.GetScintillaStylingBytes16(code.AsSpan(from..to), format, b.AsSpan((spanStart - start16 + from - v.TextSpan.Start)..));
						}
					}
				}
			}
			Span<byte> b8 = KScintilla.aaaConvertStylingBytesToUtf8(b, code.AsSpan(start16..end16));
			doc.EHideImages_(start8, end8, b8);
			_PN();
			doc.aaaSetStyling(start8, b8);
			doc.aaaSetStyled(minimal ? int.MaxValue : end8);
			
			_modStart = _modFromEnd = int.MaxValue;
			_visibleLines = minimal ? default : vr;
			_PN('S');
			if (!minimal) {
				if (!App.Settings.edit_noImages) doc.EImagesGet_(cd, ar.SelectMany(o => o.a).ToArray(), vr);
				_diagCounter = 4; //update diagnostics after 1 s
			} else {
				CodeInfo._diag.EraseIndicatorsInLine(doc, doc.aaaCurrentPos8);
			}
		}
		catch (OperationCanceledException) { }
		catch (Exception e1) { Debug_.Print(e1); } //InvalidOperationException when this code: wpfBuilder ... .Also(b=>b.Panel.for)
		finally {
			cancelTS.Dispose();
			if (cancelTS == _cancelTS) _cancelTS = null;
		}
		
		bool _Canceled() {
			if (cancelToken.IsCancellationRequested) {
				_PN();
#if PRINT
				print.it($"<><c orange>canceled.  {p1.ToString()}<>");
#endif
				return true;
			}
			if (doc != Panels.Editor.ActiveDoc) {
#if PRINT
				print.it("<><c red>switched doc<>");
#endif
				return true;
			}
			return false;
		}
#if DEBUG
		//if(!s_debugPerf) { s_debugPerf = true; perf.nw('s'); }
#endif
	}
#if DEBUG
	//static bool s_debugPerf;
#endif
	
	public static EStyle StyleFromClassifiedSpan(ClassifiedSpan cs) {
		return cs.ClassificationType switch {
			ClassificationTypeNames.ClassName => EStyle.Type,
			ClassificationTypeNames.Comment => EStyle.Comment,
			ClassificationTypeNames.ConstantName => EStyle.Constant,
			ClassificationTypeNames.ControlKeyword => EStyle.Keyword,
			ClassificationTypeNames.DelegateName => EStyle.Type,
			ClassificationTypeNames.EnumMemberName => EStyle.Constant,
			ClassificationTypeNames.EnumName => EStyle.Type,
			ClassificationTypeNames.EventName => EStyle.Event,
			ClassificationTypeNames.ExcludedCode => EStyle.Excluded,
			ClassificationTypeNames.ExtensionMethodName => EStyle.Function,
			ClassificationTypeNames.FieldName => EStyle.Field,
			//ClassificationTypeNames.Identifier => _TryResolveMethod(),
			ClassificationTypeNames.InterfaceName => EStyle.Type,
			ClassificationTypeNames.Keyword => EStyle.Keyword,
			ClassificationTypeNames.LabelName => EStyle.Label,
			ClassificationTypeNames.LocalName => EStyle.LocalVariable,
			ClassificationTypeNames.MethodName => EStyle.Function,
			ClassificationTypeNames.NamespaceName => EStyle.Namespace,
			ClassificationTypeNames.NumericLiteral => EStyle.Number,
			ClassificationTypeNames.Operator => EStyle.Operator,
			ClassificationTypeNames.OperatorOverloaded => EStyle.Function,
			ClassificationTypeNames.ParameterName => EStyle.LocalVariable,
			ClassificationTypeNames.PreprocessorKeyword => EStyle.Preprocessor,
			//ClassificationTypeNames.PreprocessorText => EStyle.None,
			ClassificationTypeNames.PropertyName => EStyle.Function,
			ClassificationTypeNames.Punctuation => EStyle.Punctuation,
			ClassificationTypeNames.RecordClassName or ClassificationTypeNames.RecordStructName => EStyle.Type,
			ClassificationTypeNames.StringEscapeCharacter => EStyle.StringEscape,
			ClassificationTypeNames.StringLiteral => EStyle.String,
			ClassificationTypeNames.StructName => EStyle.Type,
			//ClassificationTypeNames.Text => EStyle.None,
			ClassificationTypeNames.VerbatimStringLiteral => EStyle.String,
			ClassificationTypeNames.TypeParameterName => EStyle.Type,
			//ClassificationTypeNames.WhiteSpace => EStyle.None,
			
			ClassificationTypeNames.XmlDocCommentText => EStyle.XmlDocText,
			ClassificationTypeNames.XmlDocCommentAttributeName => EStyle.XmlDocTag,
			ClassificationTypeNames.XmlDocCommentAttributeQuotes => EStyle.XmlDocTag,
			ClassificationTypeNames.XmlDocCommentAttributeValue => EStyle.XmlDocTag,
			ClassificationTypeNames.XmlDocCommentCDataSection => EStyle.XmlDocTag,
			ClassificationTypeNames.XmlDocCommentComment => EStyle.XmlDocTag,
			ClassificationTypeNames.XmlDocCommentDelimiter => EStyle.XmlDocTag,
			ClassificationTypeNames.XmlDocCommentEntityReference => EStyle.XmlDocTag,
			ClassificationTypeNames.XmlDocCommentName => EStyle.XmlDocTag,
			ClassificationTypeNames.XmlDocCommentProcessingInstruction => EStyle.XmlDocTag,
			
			//ClassificationTypeNames. => EStyle.,
			_ => EStyle.None
		};
		
		//it seems don't need this anymore
		//EStyle _TryResolveMethod() { //ClassificationTypeNames.Identifier. Possibly method name when there are errors in arguments.
		//	var node = semo.Root.FindNode(cs.TextSpan);
		//	if (node?.Parent is InvocationExpressionSyntax && node.Span == cs.TextSpan && !semo.GetMemberGroup(node).IsDefaultOrEmpty) return EStyle.Function; //not too slow
		//	return EStyle.None;
		//}
	}
	
	/// <summary>
	/// Returns true if character at pos8 is in a hidden text.
	/// </summary>
	public static bool IsProtected(KScintilla sci, int pos8) => sci.aaaStyleGetAt(pos8) == STYLE_HIDDEN;
	
	/// <summary>
	/// Returns true if range from8..to8 intersects a hidden text, except when it is greater or equal than the hidden text range.
	/// It means the range should not be selected or modified.
	/// </summary>
	public static bool IsProtected(KScintilla sci, int from8, int to8) {
		bool p1 = IsProtected(sci, from8);
		if (to8 <= from8) return p1 && IsProtected(sci, from8 - 1);
		if (p1) return IsProtected(sci, from8 - 1) || (IsProtected(sci, to8 - 1) && IsProtected(sci, to8));
		if (IsProtected(sci, to8 - 1)) return IsProtected(sci, to8);
		return false;
	}
	
	public static int SkipProtected(KScintilla sci, int pos8, bool back) {
		if (back) {
			while (pos8 >= 0 && IsProtected(sci, pos8)) pos8--;
			if (pos8 < 0) return SkipProtected(sci, 0, false);
		} else {
			while (IsProtected(sci, pos8)) pos8++;
		}
		return pos8;
	}
}



================================================
FILE: Au.Editor/Edit/CiText.cs
================================================
extern alias CAW;

using System.Windows.Documents;
using System.Windows;
using System.Windows.Media;
using System.Windows.Controls;
using System.Windows.Navigation;
using System.Windows.Input;
using System.Collections.Immutable;

using Microsoft.CodeAnalysis;
using CAW::Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Text;
using Microsoft.CodeAnalysis.Shared.Extensions;
using CAW::Microsoft.CodeAnalysis.Shared.Extensions;
using Microsoft.CodeAnalysis.DocumentationComments;
using Microsoft.CodeAnalysis.SignatureHelp;

namespace LA;

class CiText {
	readonly Stack<TextElement> _stack = new();
	TextElement _container = new Section();
	TextElement _last;
	
	public Section Result => (Section)_container;
	
	/// <summary>
	/// Starts Block or Span. Or adds empty.
	/// </summary>
	/// <param name="e"></param>
	/// <param name="start">Start and don't end now. If false, adds and ends.</param>
	void _Start(TextElement e, bool start) {
		switch (e) {
		case Block b: ((Section)_container).Blocks.Add(b); break;
		case Span s: Append(s); break;
		default: throw new NotSupportedException();
		}
		_last = e;
		if (start) {
			_stack.Push(_container);
			_container = e;
		}
	}
	
	/// <summary>
	/// Ends Block or Span.
	/// </summary>
	void _End() { _container = _stack.Pop(); }
	
	public Run Append(string text) {
		var r = new Run(text);
		Append(r);
		return r;
	}
	
	public void Append(Inline i) {
		_Inlines().Add(i);
		_last = i;
	}
	
	public void Append(UIElement e) {
		_Inlines().Add(e);
	}
	
	InlineCollection _Inlines() => _container switch { Paragraph p => p.Inlines, Span s => s.Inlines, _ => throw new InvalidOperationException() };
	
	public Run Run(string style, string text, string append = null) {
		var r = Append(text);
		Style(style);
		if (append != null) Append(append);
		return r;
	}
	
	public void Style(string style) {
		//_last.Style = (Style)Application.Current.Resources[style]; //finds slower
		_last.Style = (Style)Application.Current.FindResource(style);
	}
	
	public Paragraph StartParagraph(string style = null) {
		var p = new Paragraph();
		_Start(p, true);
		if (style != null) Style(style);
		return p;
	}
	
	public void EndParagraph() => _End();
	
	/// <summary>
	/// <c>StartParagraph("div");</c>
	/// </summary>
	public Paragraph StartDiv() => StartParagraph("div");
	
	public void EndDiv() => _End();
	
	public (Paragraph, Run) Header(string text) {
		var p = StartParagraph("header");
		var r = Append(text);
		EndParagraph();
		return (p, r);
	}
	
	public Separator Separator() {
		var r = new Separator { Margin = new(4) };
		var v = new BlockUIContainer(r);
		_Start(v, false);
		return r;
	}
	
	public void LineBreak(string append = null, bool notIfFirstInParagraph = false) {
		if (!(notIfFirstInParagraph && _last is Paragraph)) Append(new LineBreak());
		if (append != null) Append(append);
	}
	
	public void StartOverload(bool selected, int index) {
		StartParagraph(selected ? "overloadSelected" : "overload");
		if (!selected) { StartHyperlink($"^{index}"); Style("divLink"); }
		Run(selected ? "dotSelected" : "dot", "● ");
	}
	
	public void EndOverload(bool selected) {
		if (!selected) EndHyperlink();
		EndParagraph();
	}
	
	/// <summary>
	/// Appends codeBlock paragraph with text.
	/// </summary>
	/// <param name="code">Non-escaped text.</param>
	public void CodeBlock(string code) {
		StartParagraph("codeBlock");
		Append(code);
		EndParagraph();
	}
	
	/// <summary>
	/// Appends Span with a defined style (like HTML class).
	/// </summary>
	/// <param name="style">A style defined in app resources, like "keyword".</param>
	public Span StartSpan(string style = null) {
		var r = new Span();
		_Start(r, true);
		if (style != null) Style(style);
		return r;
	}
	
	public void EndSpan() => _End();
	
	public void StartBold() => _Start(new Bold(), true);
	
	public void EndBold() => _End();
	
	public void Bold(string text) => _Start(new Bold(new Run(text)), false);
	
	public void StartItalic() => _Start(new Italic(), true);
	
	public void EndItalic() => _End();
	
	public void Italic(string text) => _Start(new Italic(new Run(text)), false);
	
	public Hyperlink StartHyperlink(string uri) {
		var h = new Hyperlink { NavigateUri = new(uri, UriKind.RelativeOrAbsolute) };
		h.RequestNavigate += (o, e) => FlowDocumentControl.OnLinkClicked_(o as Hyperlink, e);
		_Start(h, true);
		return h;
	}
	
	public void EndHyperlink() => _End();
	
	public Hyperlink Hyperlink(string uri, string text, string append = null) {
		var h = StartHyperlink(uri);
		if (WpfUtil_.IsHighContrastDark) h.Foreground = Brushes.RoyalBlue;
		Append(text);
		EndHyperlink();
		if (append != null) Append(append);
		return h;
	}
	
	public void Image(CiItemKind i) => Image(CiComplItem.ImageResource(i));
	
	public void Image(CiItemAccess i) => Image(CiComplItem.AccessImageResource(i));
	
	/// <summary>
	/// Adds xaml or png etc image from app resources.
	/// </summary>
	/// <param name="source">Image resource, like "resources/a.xaml" or png etc.</param>
	public void Image(string source) {
		if (source.Ends(".xaml")) {
			var c = new InlineUIContainer(ResourceUtil.GetWpfImageElement(source)) { BaselineAlignment = BaselineAlignment.Center };
			Append(c);
		} else { //not used, not tested
			var c = new Image { Source = ResourceUtil.GetWpfImage(source), Stretch = Stretch.None };
			Append(c);
		}
	}
	
	public void AppendTaggedParts(IEnumerable<TaggedText> tags, bool? isParameters = null) {
		if (tags == null) return;
		//need IReadOnlyList to easier replace something. Usually it is ImmutableArray or List.
		Debug_.PrintIf(tags is not IReadOnlyList<TaggedText>, "not IReadOnlyList");
		var a = tags as IReadOnlyList<TaggedText> ?? tags.ToArray();
		//print.it(a.Count);
		bool inParameters = isParameters == true;
		for (int i = 0; i < a.Count; i++) {
			var v = a[i];
			//print.it($"{v.Tag}, '{v.Text}', {v.Style}");
			//if(lessNewlines>1) print.it($"{v.Tag}, '{v.Text}', {v.Style}");
			//print.it($"{v.Tag}, '{v.Text}', {v.Style}, navHint='{v.NavigationHint}', navTarget='{v.NavigationTarget}'");
			string s = v.Text, c = null;
			switch (v.Tag) {
			case TextTags.Struct:
				c = "type";
				
				//rejected: replace parameter type ReadOnlySpan<char> with Strinĝ, and in global.cs add: global using Strinĝ = System.ReadOnlySpan<char>;
				//	Better in XML doc tell it's a string.
				//if (inParameters) {
				//	if (s == "ReadOnlySpan" && i < a.Count - 3 && a[i + 2].Text == "char" && a[i + 1].Text == "<" && a[i + 3].Text == ">") {
				//		s = "Strinĝ";
				//		i += 3;
				//	}
				//}
				break;
			case TextTags.Class or TextTags.Enum or TextTags.Interface or TextTags.Delegate or TextTags.TypeParameter or TextTags.Record or TextTags.RecordStruct:
				c = "type";
				break;
			case TextTags.Keyword:
				c = "keyword";
				break;
			case TextTags.StringLiteral:
				c = "string";
				break;
			case TextTags.NumericLiteral:
				c = "number";
				break;
			case TextTags.Namespace:
				c = "namespace";
				break;
			case TextTags.LineBreak:
				LineBreak();
				continue;
			case TextTags.Punctuation:
				if (isParameters == null && i > 0 && s.Length == 1) { //auto-detect
					char ch = s[0];
					if (!inParameters) {
						if (ch == '(') inParameters = a[i - 1].Tag is TextTags.Method or TextTags.ExtensionMethod;
						if (ch == '[') inParameters = a[i - 1].Tag is TextTags.Keyword && a[i - 1].Text == "this";
						//note: does not detect ctor.
						//	Then a[i - 1] is type. But for cast operators it is type too; they must not be detected.
						//	Probably it's better if ctor and cast are displayed with same types.
					} else if (ch == ')') inParameters = false;
				}
				break;
			case TextTags.Method: //eg operator <
			case TextTags.Operator:
				break;
			case TextTags.Text:
				if (v.Style == 0) _ProcessText();
				break;
			case TextTags.CodeBlockStart or TextTags.CodeBlockEnd: continue;
#if DEBUG
			case TextTags.Space:
			case TextTags.Constant:
			case TextTags.EnumMember:
			case TextTags.Event:
			case TextTags.ExtensionMethod:
			case TextTags.Field:
			case TextTags.Local:
			case TextTags.Parameter:
			case TextTags.Property:
			case TextTags.RangeVariable:
			case TextTags.Alias:
			case TextTags.Label:
			case TextTags.ContainerStart:
			case TextTags.ContainerEnd:
			case TextTags.AnonymousTypeIndicator:
			case TextTags.ErrorType:
				break;
			default:
				Debug_.Print($"{v.Tag}, '{v.Text}', {v.Style}");
				break;
#endif
			}
			
			switch (v.Style) {
			case TaggedTextStyle.Strong: StartBold(); break;
			case TaggedTextStyle.Emphasis: StartItalic(); break;
			case TaggedTextStyle.Code: StartSpan("codeSpan"); break;
			}
			
			if (c != null) Run(c, s); else Append(s);
			
			switch (v.Style) {
			case TaggedTextStyle.Code: EndSpan(); break;
			case TaggedTextStyle.Emphasis: EndItalic(); break;
			case TaggedTextStyle.Strong: EndBold(); break;
			}
			
			void _ProcessText() {
				//replace [](xref:topic_id) with Hyperlink
				if (!s.Contains("](xref:")) return;
				if (s_xrefmap == null) {
					s_xrefmap = new();
					try {
						var s1 = filesystem.loadText(folders.ThisApp + "xrefmap.yml"); //generated by DocFX project
						foreach (var k in s1.RxFindAll(@"(?m)^- uid: (.+)\R  name: (.+)\R  href: (.+)$")) {
							s_xrefmap.Add(k[1].Value, (k[3].Value, k[2].Value));
						}
					}
					catch { }
				}
				int i = 0;
				foreach (var m in s.RxFindAll(@"\[(.*?)\]\(xref:(.+?)\)")) {
					if (!s_xrefmap.TryGetValue(m[2].Value, out var v)) continue;
					if (m.Start > i) Append(s[i..m.Start]);
					Hyperlink(v.url, m[1].Length > 0 ? m[1].Value : v.text);
					i = m.End;
				}
				if (i > 0) s = s[i..];
			}
		}
	}
	
	static Dictionary<string, (string url, string text)> s_xrefmap;
	
	public void AppendTaggedParts(ImmutableArray<SymbolDisplayPart> parts, bool? isParameters = null)
		=> AppendTaggedParts(parts.ToTaggedText(), isParameters);
	
	public static Section FromTaggedParts(IEnumerable<TaggedText> tags) {
		var x = new CiText();
		x.StartParagraph();
		x.AppendTaggedParts(tags, false);
		x.EndParagraph();
		return x.Result;
	}
	
	public static Section FromSymbols(IEnumerable<ISymbol> symbols, int iSelect, SemanticModel model, int position) {
		//perf.first();
		var x = new CiText();
		x.AppendSymbols(symbols, iSelect, model, position);
		return x.Result;
	}
	
	public void AppendSymbols(IEnumerable<ISymbol> symbols, int iSelect, SemanticModel model, int position) {
		//perf.first();
		ISymbol sym = null;
		int i = -1;
		foreach (var v in symbols) {
			if (++i == iSelect) sym = v;
			StartOverload(i == iSelect, i);
			var parts = v.ToDisplayParts(s_symbolFullFormat);
			AppendTaggedParts(parts);
			if (v.Kind == SymbolKind.Parameter) _AppendComment("parameter");
			EndOverload(i == iSelect);
		}
		//perf.next();
		
		if (sym != null) {
			//print.it($"<><c blue>{sym}<>");
			//print.it(sym.GetType().GetInterfaces());
			
			var parts = GetSymbolDescription(sym, model, position);
			//print.it(parts);
			if (parts.Any()) {
				StartParagraph();
				AppendTaggedParts(parts, false);
				EndParagraph();
			}
			
			//print.it(sym.GetDocumentationCommentXml());
			
			ISymbol enclosing = null;
			switch (sym.Kind) {
			case SymbolKind.NamedType:
			case SymbolKind.Event:
			case SymbolKind.Field:
			case SymbolKind.Method:
			case SymbolKind.Property:
				Separator();
				
				//HELP AND SOURCE LINKS
				StartDiv();
				AppendSymbolLinks(sym);
				EndDiv();
				
				//CONTAINER namespace/type and assembly
				StartDiv();
				Append("In ");
				var ctn = sym.ContainingType ?? sym.ContainingNamespace as INamespaceOrTypeSymbol;
				if (!(ctn is INamespaceSymbol ins && ins.IsGlobalNamespace)) {
					Append((ctn is ITypeSymbol its) ? its.TypeKind.ToString().Lower() : "namespace"); Append(" ");
					AppendTaggedParts(ctn.ToDisplayParts(s_qualifiedTypeFormat), false);
					Append(", ");
				}
				Append(sym.IsFromSource() ? "file " : "assembly "); Append(sym.ContainingAssembly.Name);
				EndDiv();
				
				//MODIFIERS
				bool isReadonly = false, isConst = false, isVolatile = false, isAsync = false, isEnumMember = false;
				var tKind = TypeKind.Unknown; //0
				INamedTypeSymbol baseType = null; string enumBaseType = null; ImmutableArray<INamedTypeSymbol> interfaces = default;
				switch (sym) {
				case IFieldSymbol ifs:
					if (isEnumMember = ifs.IsEnumMember()) {
						enumBaseType = ifs.ContainingType.EnumUnderlyingType.ToNameDisplayString();
					} else {
						isReadonly = ifs.IsReadOnly;
						isConst = ifs.IsConst;
						isVolatile = ifs.IsVolatile;
					}
					break;
				case INamedTypeSymbol ints:
					isReadonly = ints.IsReadOnly;
					tKind = ints.TypeKind;
					switch (tKind) {
					case TypeKind.Class:
						var bt = ints.BaseType;
						if (bt != null && bt.BaseType != null) baseType = bt; //not object
						goto case TypeKind.Interface;
					case TypeKind.Interface:
					case TypeKind.Struct:
						interfaces = ints.AllInterfaces;
						break;
					case TypeKind.Enum:
						enumBaseType = ints.EnumUnderlyingType.ToNameDisplayString();
						break;
					}
					break;
				case IMethodSymbol ims:
					isAsync = ims.IsAsync;
					break;
				}
				if (!isEnumMember) {
					StartDiv();
					string s1 = sym.DeclaredAccessibility switch {
						Microsoft.CodeAnalysis.Accessibility.Public => "public",
						Microsoft.CodeAnalysis.Accessibility.Private => "private",
						Microsoft.CodeAnalysis.Accessibility.Internal => "internal",
						Microsoft.CodeAnalysis.Accessibility.Protected => "protected",
						Microsoft.CodeAnalysis.Accessibility.ProtectedAndInternal => "private protected",
						Microsoft.CodeAnalysis.Accessibility.ProtectedOrInternal => "protected internal",
						_ => null
					};
					if (s1 != null) _AppendKeyword(s1);
					
					if (isConst) _AppendSpaceKeyword("const"); else if (sym.IsStatic) _AppendSpaceKeyword("static");
					if (sym.IsAbstract && tKind != TypeKind.Interface) _AppendSpaceKeyword("abstract");
					if (sym.IsSealed && (tKind == TypeKind.Class || tKind == TypeKind.Unknown)) _AppendSpaceKeyword("sealed");
					if (sym.IsVirtual) _AppendSpaceKeyword("virtual");
					if (sym.IsOverride) _AppendSpaceKeyword("override");
					if (sym.IsExtern) _AppendSpaceKeyword("extern");
					if (isReadonly) _AppendSpaceKeyword("readonly");
					if (isAsync) _AppendSpaceKeyword("async");
					if (isVolatile) _AppendSpaceKeyword("volatile");
					EndDiv();
					void _AppendSpaceKeyword(string name) {
						if (_last is not Paragraph) Append(" ");
						Run("keyword", name);
					}
				}
				
				//BASE TYPES AND IMPLEMENTED INTERFACES
				if (baseType != null || enumBaseType != null || !interfaces.IsDefaultOrEmpty) {
					StartDiv();
					Append(": ");
					if (enumBaseType != null) {
						_AppendTypeName(enumBaseType, "keyword");
					} else if (baseType != null) {
						_AppendType(baseType);
						for (baseType = baseType.BaseType; baseType.BaseType != null; baseType = baseType.BaseType) {
							Append(" : ");
							_AppendType(baseType);
						}
					}
					if (!interfaces.IsDefaultOrEmpty) {
						bool comma = baseType != null || enumBaseType != null;
						foreach (var v in interfaces) {
							_AppendComma(ref comma);
							bool hilite = v.Name == "IDisposable";
							if (hilite) StartSpan("hilite");
							_AppendType(v);
							if (hilite) EndSpan();
						}
					}
					EndDiv();
				}
				
				//ATTRIBUTES
				_AppendAttributes(sym.GetAttributes());
				switch (sym) {
				case IMethodSymbol ims:
					_AppendAttributes(ims.GetReturnTypeAttributes(), "return");
					foreach (var v in ims.Parameters) _AppendAttributes(v.GetAttributes(), v.Name, isParameter: true);
					break;
				case IPropertySymbol ips:
					var ipgs = ips.GetMethod;
					if (ipgs != null) {
						_AppendAttributes(ipgs.GetAttributes(), "get");
						_AppendAttributes(ipgs.GetReturnTypeAttributes(), "return");
					}
					var ipss = ips.SetMethod;
					if (ipss != null) _AppendAttributes(ipss.GetAttributes(), "set");
					var ipfs = ips.GetBackingFieldIfAny();
					if (ipfs != null) _AppendAttributes(ipfs.GetAttributes(), "field");
					break;
				}
				
				//TYPE MEMBERS NOT SHOWN IN THE COMPLETION LIST: constructors, finalizers, operators
				if ((tKind == TypeKind.Class || tKind == TypeKind.Struct /*|| tKind == TypeKind.Interface*/) && sym is INamespaceOrTypeSymbol t) {
					List<ISymbol> a = null;
					foreach (var v in t.GetMembers()) {
						switch (v) {
						case IMethodSymbol m:
							switch (m.MethodKind) {
							case MethodKind.Ordinary:
							case MethodKind.PropertyGet:
							case MethodKind.PropertySet:
							case MethodKind.EventAdd:
							case MethodKind.EventRemove:
							case MethodKind.ExplicitInterfaceImplementation:
							case MethodKind.Destructor:
								continue;
								//case MethodKind.Destructor: goto g1; //don't check is accessible etc
							}
							if (m.IsImplicitlyDeclared) continue; //eg default ctor of struct
							//print.it(m.MethodKind, m);
							break;
						//case IPropertySymbol p when p.IsIndexer: //now indexers are in completion list
						//	break;
						default: continue;
						}
						if (!_IsAccessible(v) || v.IsObsolete()) continue;
						//g1:
						(a ??= new List<ISymbol>()).Add(v);
					}
					if (a != null) {
						Separator();
						//string header = tKind switch { TypeKind.Class => "Constructors, finalizers, operators, indexers", TypeKind.Struct => "Constructors, operators, indexers", _ => "Indexers" };
						//string header = tKind == TypeKind.Interface ? "Indexers" : "Constructors, operators, indexers";
						string header = "Constructors, operators";
						Header(header);
						a.Sort((v1, v2) => {
							//var diff = v1.Kind - v2.Kind; //indexer is property, others are methods
							//if (diff != 0) return diff;
							if (v1 is IMethodSymbol m1 && v2 is IMethodSymbol m2) return _Sort(m1) - _Sort(m2);
							static int _Sort(IMethodSymbol sy) => sy.MethodKind switch { MethodKind.StaticConstructor => 0, MethodKind.Constructor => 1, /*MethodKind.Destructor => 2,*/ MethodKind.Conversion => 3, MethodKind.UserDefinedOperator => 4, _ => 0 };
							return 0;
						});
						foreach (var v in a) {
							StartDiv();
							Run("dot", "• ");
							if (v is IMethodSymbol m && m.MethodKind == MethodKind.StaticConstructor) _AppendKeyword("static ");
							AppendTaggedParts(v.ToDisplayParts(s_symbolFullFormat));
							EndDiv();
						}
					}
					//never mind: also should add those of base types.
				}
				break;
			}
			//perf.nw();
			
			bool _IsAccessible(ISymbol symbol) {
				enclosing ??= model.GetEnclosingNamedTypeOrAssembly(position, default);
				return enclosing != null && symbol.IsAccessibleWithin(enclosing);
			}
			void _AppendComma(ref bool isComma) { if (!isComma) isComma = true; else Append(", "); }
			void _AppendKeyword(string name) { Run("keyword", name); }
			void _AppendTypeName(string name, string cssClass = "type") => Run(cssClass, name);
			void _AppendType(INamedTypeSymbol t) {
				if (t.IsGenericType) AppendTaggedParts(t.ToDisplayParts(s_unqualifiedTypeFormat), false);
				else _AppendTypeName(t.Name);
			}
			void _AppendAttributes(ImmutableArray<AttributeData> a, string target = null, bool isParameter = false) {
				if (a.IsDefaultOrEmpty) return;
				bool attrComma = false, paramAdded = false;
				foreach (var att in a) {
					var ac = att.AttributeClass; if (ac == null) continue;
					//if(!_IsAccessible(ac)) continue; //no, would not show attributes if code does not have 'using' for the attribute
					string aname = ac.Name.RemoveSuffix("Attribute");
					if (aname == "CompilerGenerated" || aname == "IteratorStateMachine") continue;
					//att.ToString(); //similar, but too much noise
					if (isParameter) {
						if (!paramAdded) {
							paramAdded = true;
							StartDiv();
							Append(target + ": [");
						}
						_AppendComma(ref attrComma);
					} else {
						StartDiv();
						Append("[");
						if (target != null) Run("keyword", target, ": ");
					}
					bool hilite = aname == "Obsolete";
					if (hilite) StartSpan("hilite");
					_AppendTypeName(aname);
					if (hilite) EndSpan();
					var ca = att.CommonConstructorArguments;
					var na = att.CommonNamedArguments;
					if (ca.Length + na.Length > 0) {
						Append("(");
						bool paramComma = false;
						foreach (var v in ca) {
							_AppendComma(ref paramComma);
							Append(v.ToCSharpString()); //never mind: enum with namespace
						}
						foreach (var v in na) {
							_AppendComma(ref paramComma);
							Append(v.Key + " = ");
							Append(v.Value.ToCSharpString());
						}
						Append(")");
					}
					if (!isParameter) { Append("]"); EndDiv(); }
				}
				if (isParameter && paramAdded) { Append("]"); EndDiv(); }
			}
		}
		void _AppendComment(string s) {
			Run("comment", "   //" + s);
		}
	}
	
	public static ImmutableArray<TaggedText> GetSymbolDescription(ISymbol sym, SemanticModel model, int position) {
		return sym.GetDocumentationParts(model, position, _Formatter, default);
	}
	
	//public static IEnumerable<TaggedText> GetTaggedTextForXml(string xml, SemanticModel model, int position)
	//{
	//	if(xml == null) return Enumerable.Empty<TaggedText>();
	//	return _Formatter.Format(xml, model, position, ISymbolExtensions2.CrefFormat); //error in new Roslyn
	//}
	
	static IDocumentationCommentFormattingService _Formatter => s_formatter ??= CodeInfo.CurrentWorkspace.Workspace.Services.GetLanguageServices("C#").GetService<IDocumentationCommentFormattingService>();
	static IDocumentationCommentFormattingService s_formatter;
	
	const SymbolDisplayMiscellaneousOptions s_miscDisplayOptions =
		SymbolDisplayMiscellaneousOptions.AllowDefaultLiteral
		| SymbolDisplayMiscellaneousOptions.EscapeKeywordIdentifiers
		| SymbolDisplayMiscellaneousOptions.IncludeNullableReferenceTypeModifier //? //info: added 2024-11-21. Test more.
		//| SymbolDisplayMiscellaneousOptions.IncludeNotNullableReferenceTypeModifier //!
		| SymbolDisplayMiscellaneousOptions.RemoveAttributeSuffix
		| SymbolDisplayMiscellaneousOptions.UseErrorTypeSymbolName
		| SymbolDisplayMiscellaneousOptions.UseSpecialTypes;
	const SymbolDisplayParameterOptions s_parameterDisplayOptions =
		SymbolDisplayParameterOptions.IncludeType
		| SymbolDisplayParameterOptions.IncludeName
		| SymbolDisplayParameterOptions.IncludeParamsRefOut
		| SymbolDisplayParameterOptions.IncludeOptionalBrackets
		| SymbolDisplayParameterOptions.IncludeDefaultValue
		| SymbolDisplayParameterOptions.IncludeExtensionThis;
	
	internal static readonly SymbolDisplayFormat s_symbolFullFormat = new(
		SymbolDisplayGlobalNamespaceStyle.OmittedAsContaining,
		SymbolDisplayTypeQualificationStyle.NameAndContainingTypes,
		SymbolDisplayGenericsOptions.IncludeTypeParameters | SymbolDisplayGenericsOptions.IncludeVariance | SymbolDisplayGenericsOptions.IncludeTypeConstraints,
		SymbolDisplayMemberOptions.IncludeType | SymbolDisplayMemberOptions.IncludeParameters | SymbolDisplayMemberOptions.IncludeConstantValue | SymbolDisplayMemberOptions.IncludeRef | SymbolDisplayMemberOptions.IncludeExplicitInterface,
		SymbolDisplayDelegateStyle.NameAndSignature,
		SymbolDisplayExtensionMethodStyle.Default,
		s_parameterDisplayOptions,
		SymbolDisplayPropertyStyle.ShowReadWriteDescriptor,
		SymbolDisplayLocalOptions.IncludeType | SymbolDisplayLocalOptions.IncludeRef | SymbolDisplayLocalOptions.IncludeConstantValue,
		SymbolDisplayKindOptions.IncludeMemberKeyword | SymbolDisplayKindOptions.IncludeNamespaceKeyword | SymbolDisplayKindOptions.IncludeTypeKeyword,
		s_miscDisplayOptions
		);
	static SymbolDisplayFormat s_qualifiedTypeFormat = new(
		SymbolDisplayGlobalNamespaceStyle.OmittedAsContaining,
		SymbolDisplayTypeQualificationStyle.NameAndContainingTypesAndNamespaces,
		SymbolDisplayGenericsOptions.IncludeTypeParameters | SymbolDisplayGenericsOptions.IncludeVariance,
		miscellaneousOptions: s_miscDisplayOptions
		);
	static SymbolDisplayFormat s_unqualifiedTypeFormat = new(
		SymbolDisplayGlobalNamespaceStyle.Omitted,
		SymbolDisplayTypeQualificationStyle.NameOnly,
		SymbolDisplayGenericsOptions.IncludeTypeParameters | SymbolDisplayGenericsOptions.IncludeVariance,
		miscellaneousOptions: s_miscDisplayOptions
		);
	static SymbolDisplayFormat s_parameterFormat = new(
		SymbolDisplayGlobalNamespaceStyle.Omitted,
		SymbolDisplayTypeQualificationStyle.NameAndContainingTypes,
		genericsOptions: SymbolDisplayGenericsOptions.IncludeTypeParameters | SymbolDisplayGenericsOptions.IncludeVariance,
		parameterOptions: s_parameterDisplayOptions,
		miscellaneousOptions: s_miscDisplayOptions
		);
	static SymbolDisplayFormat s_symbolWithoutParametersFormat = new(
		SymbolDisplayGlobalNamespaceStyle.Omitted,
		SymbolDisplayTypeQualificationStyle.NameAndContainingTypes,
		SymbolDisplayGenericsOptions.IncludeTypeParameters | SymbolDisplayGenericsOptions.IncludeVariance,
		SymbolDisplayMemberOptions.IncludeType | SymbolDisplayMemberOptions.IncludeRef | SymbolDisplayMemberOptions.IncludeExplicitInterface,
		miscellaneousOptions: s_miscDisplayOptions
		);
	static SymbolDisplayFormat s_nameWithoutTypeParametersFormat = new(
		SymbolDisplayGlobalNamespaceStyle.Omitted,
		SymbolDisplayTypeQualificationStyle.NameOnly,
		miscellaneousOptions: s_miscDisplayOptions
		);
	
	public void AppendSymbolWithoutParameters(ISymbol sym) {
		AppendTaggedParts(sym.ToDisplayParts(sym is INamedTypeSymbol ? s_nameWithoutTypeParametersFormat : s_symbolWithoutParametersFormat), false);
	}
	
	public void AppendParameters(ISymbol sym, int iSel = -1, SignatureHelpItem sh = null) {
		ImmutableArray<IParameterSymbol> ap;
		switch (sym) {
		case IMethodSymbol sy:
			ap = sy.Parameters;
			break;
		case IPropertySymbol sy: //indexer
			ap = sy.Parameters;
			break;
		case INamedTypeSymbol sy:
			if (sy.IsTupleType && !sy.IsDefinition) {
				var te = sy.TupleElements;
				for (int i = 0; i < te.Length; i++) {
					_Param(te[i], i, 1);
				}
			} else if (sy.IsGenericType) {
				var tp = sy.TypeParameters;
				for (int i = 0; i < tp.Length; i++) {
					_Param(sy.TypeParameters[i], i, 2);
				}
			} else {
				Debug_.Print(sy);
			}
			return;
		default:
			Debug_.Print(sym);
			return;
		}
		
		for (int i = 0; i < ap.Length; i++) _Param(ap[i], i, 0);
		if (sh != null) { //eg properties in [Attribute(params, properties)]. Can be used for params too, but formats not as I like.
			var ap2 = sh.Parameters;
			for (int i = ap.Length; i < ap2.Length; i++) {
				if (i > 0) Append(", ");
				if (i == iSel) StartBold();
				AppendTaggedParts(ap2[i].DisplayParts);
				if (i == iSel) EndBold();
			}
		}
		
		void _Param(ISymbol p, int i, byte kind) { //kind: 0 param, 1 field, 2 typeparam
			if (i > 0) Append(", ");
			if (i == iSel) StartBold();
			AppendTaggedParts(p.ToDisplayParts(kind == 1 ? s_symbolWithoutParametersFormat : s_parameterFormat), isParameters: kind == 0);
			//info: s_symbolWithoutParametersFormat here maybe is not the best, but it worked well with all tested tuple parameter types.
			if (i == iSel) EndBold();
		}
	}
	
	//public void AppendParameters(SignatureHelpItem sh, int iSel = -1)
	//{
	//	var ap = sh.Parameters;
	//	for(int i = 0; i < ap.Length; i++) {
	//		if(i > 0) Append(", ");
	//		if(i == iSel) StartBold();
	//		AppendTaggedParts(ap[i].DisplayParts);
	//		if(i == iSel) EndBold();
	//	}
	//}
	
	public bool AppendSymbolLinks(ISymbol sym) {
		string helpUrl = CiUtil.GetSymbolHelpUrl(sym, out _);
		string sourceUrl = CiGoTo.GetLinkData(sym);
		if (helpUrl == null && sourceUrl == null) return false;
		AppendSymbolLinks(helpUrl, sourceUrl);
		return true;
	}
	
	public void AppendSymbolLinks(string helpUrl, string sourceUrl) {
		Append(helpUrl != null && sourceUrl != null ? "Links: " : "Link: ");
		if (helpUrl != null) Hyperlink(helpUrl, "more info");
		if (sourceUrl != null) {
			if (helpUrl != null) Append(" , ");
			Hyperlink(sourceUrl, "source code");
		}
	}
	
	public static Section FromKeyword(string name) {
		//var url = "https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/";
		var url = App.Settings.internetSearchUrl + "C%23+keyword";
		var x = new CiText();
		x.StartParagraph();
		x.Append("Keyword ");
		x.Run("keyword", name);
		x.EndParagraph();
		x.Separator();
		x.StartParagraph();
		x.Append("Links: ");
		x.Hyperlink($"{url} {name}", "more info", " , ");
		x.Hyperlink($"{url}s", "C# keywords", ".");
		x.EndParagraph();
		return x.Result;
	}
	
	public static Section FromLabel(string name) {
		var x = new CiText();
		x.StartParagraph();
		x.Append("Label "); x.Bold(name);
		x.EndParagraph();
		return x.Result;
	}
	
	public static FlowDocumentControl CreateControl(int colorRGB = 0xfffff0) {
		var ff = App.Wmain.FontFamily;
		double fs = App.Wmain.FontSize;
		if (ff.Source == "Segoe UI") { ff = new("Calibri"); fs += 2; }
		var d = new FlowDocument {
			FontFamily = ff,
			FontSize = fs,
			Background = ColorInt.WpfBrush_(colorRGB),
			PagePadding = default,
			TextAlignment = TextAlignment.Left,
		};
		TextOptions.SetTextFormattingMode(d, TextFormattingMode.Display);
		var c = new FlowDocumentControl {
			Document = d,
			FocusVisualStyle = null,
			VerticalScrollBarVisibility = ScrollBarVisibility.Auto,
			IsInactiveSelectionHighlightEnabled = true,
		};
		return c;
	}
}

class FlowDocumentControl : FlowDocumentScrollViewer {
	public event Action<FlowDocumentControl, string> LinkClicked;
	
	internal static void OnLinkClicked_(Hyperlink h, RequestNavigateEventArgs e) {
		var s = e.Uri.OriginalString;
		//print.it(s);
		DependencyObject d = h;
		while (null != (d = LogicalTreeHelper.GetParent(d))) if (d is FlowDocumentControl c) {
				c.LinkClicked?.Invoke(c, s);
				break;
			}
	}
	
	/// <summary>
	/// Clears text (removes all blocks) and applies a workaround for a WPF bug.
	/// </summary>
	public void Clear() {
		Document.Blocks.Clear();
		_ = Selection?.IsEmpty; //workaround for WPF bug: if some text was selected, would select all new text
	}
	
	protected override void OnPreviewMouseLeftButtonUp(MouseButtonEventArgs e) {
		if (!Selection.IsEmpty) this.Hwnd().ActivateL(); //user may want to copy text with Ctrl+C
		base.OnPreviewMouseLeftButtonUp(e);
	}
}


================================================
FILE: Au.Editor/Edit/CiTools.cs
================================================
using ToolLand;
using Au.Controls;
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Text;
using System.Windows.Controls;

//FUTURE: Color tool. Eg to set toolbar colors.
//	Now can select in the Icons dialog or capture with Duiimage.

namespace LA;

class CiTools {
	public bool HideTempWindows() {
		bool v1 = _regexWindow?.IsVisible ?? false, v2 = _keysWindow?.IsVisible ?? false;
		if (v1) _regexWindow.Close();
		if (v2) _keysWindow.Close();
		return v1 || v2;
	}
	
	#region regex
	
	RegexWindow _regexWindow;
	string _regexTopic;
	
	void _RegexWindowShow(SciCode doc, string code, int pos16, in CiStringInfo si, bool replace, wnd dontCover = default) {
		var (spanStart, spanEnd) = si.textSpan;
		
		_regexWindow ??= new();
		_ShowWindow(_regexWindow, doc, pos16, dontCover);
		
		if (!replace && si.isClassic) {
			doc.aaaInsertText(true, si.stringNode.SpanStart, "@"); //never mind: user may want `new regexp("""""")`
			spanStart++; spanEnd++;
		}
		
		var s = _regexWindow.CurrentTopic;
		if (s == "replace") {
			if (!replace) _regexWindow.CurrentTopic = _regexTopic;
		} else if (replace) {
			_regexTopic = s;
			_regexWindow.CurrentTopic = "replace";
		}
		doc.ETempRanges_Add(this, spanStart, spanEnd, onLeave: () => _regexWindow.Close());
	}
	
	//public bool RegexWindowIsVisible => _regexWindow?.Window.Visible ?? false;
	
	#endregion
	
	#region keys
	
	KeysWindow _keysWindow;
	
	void _KeysWindowShow(SciCode doc, string code, int pos16, in CiStringInfo si, PSFormat format, wnd dontCover = default) {
		_keysWindow ??= new KeysWindow();
		_ShowWindow(_keysWindow, doc, pos16, dontCover);
		_keysWindow.SetFormat(format);
		doc.ETempRanges_Add(this, si.textSpan.Start, si.textSpan.End, onLeave: () => _keysWindow.Close());
	}
	
	#endregion
	
	static void _ShowWindow(InfoWindow w, SciCode doc, int position, wnd dontCover) {
		if (w.IsVisible) w.Hwnd.ZorderTop();
		var r = doc.EGetCaretRectFromPos(position, inScreen: true);
		r.left -= Dpi.Scale(80, doc);
		bool above = !dontCover.Is0;
		if (above) r = RECT.Union(r, dontCover.Rect);
		w.ShowByRect(doc, above ? Dock.Top : Dock.Bottom, r, exactSize: true);
		w.InsertInControl = doc;
	}
	
	public static void CmdShowRegexWindow() => _ShowRegexOrKeysWindow(true);
	public static void CmdShowKeysWindow() => _ShowRegexOrKeysWindow(false);
	
	static void _ShowRegexOrKeysWindow(bool isRegex) {
		bool retry = false;
		g1:
		if (!CodeInfo.GetDocumentAndFindToken(out var cd, out var token)) return;
		var pos16 = cd.pos;
		bool? inString = token.IsInString(pos16, cd.code, out var stri);
		if (inString == null) return;
		if (inString != true) {
			if (isRegex || retry) {
				dialog.showInfo(isRegex ? "Regex" : "Keys", "The text cursor must be in a string.");
				return;
			}
			
			//is in keys.send argument list?
			var node = token.Parent;
			if (node != null && node is not ArgumentListSyntax && !node.Span.ContainsInside(pos16)) {
				node = node.Parent;
				if (node is ArgumentSyntax) node = node.Parent;
			}
			if (node is ArgumentListSyntax && node.Parent is InvocationExpressionSyntax ie && ie.Expression.ToString() == "keys.send") {
				SyntaxToken t1, t2;
				if (pos16 <= token.SpanStart) { t1 = token.GetPreviousToken(); t2 = token; } else { t1 = token; t2 = token.GetNextToken(); }
				//CiUtil.PrintNode(t1);
				//CiUtil.PrintNode(t2);
				SyntaxKind k1 = t1.Kind(), k2 = t2.Kind();
				bool good1 = k1 is SyntaxKind.OpenParenToken or SyntaxKind.CommaToken, good2 = k2 is SyntaxKind.CloseParenToken or SyntaxKind.CommaToken;
				string s;
				if (good1 && good2) s = "\"`|`\""; else if (good1) s = "\"`|`\", "; else if (good2) s = ", \"`|`\""; else s = ", \"`|`\", ";
				InsertCode.TextSimply(s);
			} else {
				InsertCode.Statements(new("keys.send(\"`|`\");", goTo: true));
			}
			retry = true;
			goto g1;
		}
		
		var t = CodeInfo._tools;
		if (isRegex) {
			t._RegexWindowShow(cd.sci, cd.code, pos16, stri, replace: false);
		} else {
			PSFormat format = PSFormat.Keys;
			if (inString == true) {
				var semo = cd.semanticModel;
				format = CiUtil.GetParameterStringFormat(token.Parent, semo, true);
			}
			t._KeysWindowShow(cd.sci, cd.code, pos16, stri, format);
		}
	}
	
	public void ShowForStringParameter(PSFormat stringFormat, CodeInfo.Context cd, in CiStringInfo si, wnd dontCover = default) {
		switch (stringFormat) {
		case PSFormat.Regexp:
		case PSFormat.RegexpReplacement:
			_RegexWindowShow(cd.sci, cd.code, cd.pos, si, replace: stringFormat == PSFormat.RegexpReplacement, dontCover);
			break;
		case PSFormat.Keys or PSFormat.Hotkey or PSFormat.HotkeyTrigger or PSFormat.TriggerMod:
			_KeysWindowShow(cd.sci, cd.code, cd.pos, si, stringFormat, dontCover);
			break;
		}
	}
}


================================================
FILE: Au.Editor/Edit/CiUtil.cs
================================================
extern alias CAW;

using Microsoft.CodeAnalysis;
using CAW::Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Text;
using Microsoft.CodeAnalysis.Shared.Extensions;
using CAW::Microsoft.CodeAnalysis.Shared.Extensions;
using Microsoft.CodeAnalysis.CSharp.Extensions;
using Microsoft.CodeAnalysis.CSharp.Extensions.ContextQuery;
using CAW::Microsoft.CodeAnalysis.Classification;
using CAW::Microsoft.CodeAnalysis.Tags;
using CAW::Microsoft.CodeAnalysis.FindSymbols;

using System.Collections.Immutable;
using EStyle = LA.SciTheme.EStyle;

namespace LA;

static class CiUtil {
	#region simple string util
	
	/// <summary>
	/// Returns <c>=> c is ' ' or '\t';</c>
	/// </summary>
	public static bool IsSpace(char c) => c is ' ' or '\t';
	
	/// <summary>
	/// Returns true if <i>pos</i> is in <i>code</i> and <c>code[pos] is ' ' or '\t'</c>.
	/// </summary>
	public static bool IsSpace(string code, int pos) => (uint)pos < code.Length && code[pos] is ' ' or '\t';
	
	/// <summary>
	/// Skips <c>' '</c> and <c>'\t'</c> characters after <i>pos</i>.
	/// </summary>
	public static int SkipSpace(string code, int pos) {
		while (IsSpace(code, pos)) pos++;
		return pos;
	}
	
	/// <summary>
	/// Skips <c>' '</c> and <c>'\t'</c> characters before <i>pos</i>.
	/// </summary>
	public static int SkipSpaceBack(string code, int pos) {
		while (IsSpace(code, pos - 1)) pos--;
		return pos;
	}
	
	/// <summary>
	/// Returns the start and end of the range consisting of <c>' '</c> and <c>'\t'</c> characters around <i>pos</i>.
	/// </summary>
	public static (int start, int end) SkipSpaceAround(string code, int pos) {
		int start = pos, end = pos;
		while (IsSpace(code, start - 1)) start--;
		while (IsSpace(code, end)) end++;
		return (start, end);
	}
	
	/// <summary>
	/// If <i>pos</i> is at the end of a line and not at the end of the string, returns the start of next line. Else returns <i>pos</i>.
	/// </summary>
	public static int SkipNewline(string code, int pos) {
		if (pos < code.Length && code[pos] == '\r') pos++;
		if (pos < code.Length && code[pos] == '\n') pos++;
		return pos;
	}
	
	/// <summary>
	/// If <i>pos</i> is at the start of a line, returns the end of previous line. Else returns <i>pos</i>.
	/// </summary>
	public static int SkipNewlineBack(string code, int pos) {
		if (pos > 0 && code[pos - 1] == '\n') pos--;
		if (pos > 0 && code[pos - 1] == '\r') pos--;
		return pos;
	}
	
	/// <summary>
	/// Skips <c>' '</c>, <c>'\t'</c>, <c>'\r'</c> and <c>'\n'</c> characters after <i>pos</i>.
	/// </summary>
	public static int SkipSpaceAndNewline(string code, int pos) {
		while (pos < code.Length && code[pos] is ' ' or '\t' or '\r' or '\n') pos++;
		return pos;
	}
	
	/// <summary>
	/// Skips <c>' '</c>, <c>'\t'</c>, <c>'\r'</c> and <c>'\n'</c> characters before <i>pos</i>.
	/// </summary>
	public static int SkipSpaceAndNewlineBack(string code, int pos) {
		while (pos > 0 && code[pos - 1] is ' ' or '\t' or '\r' or '\n') pos--;
		return pos;
	}
	
	/// <summary>
	/// Returns true if i is at a line start + any number of spaces and tabs.
	/// </summary>
	public static bool IsLineStart(RStr s, int i/*, out int startOfLine*/) {
		while (i > 0 && s[i - 1] is '\t' or ' ') i--;
		//startOfLine = j;
		return i == 0 || s[i - 1] == '\n';
	}
	
	/// <summary>
	/// Returns true if i is at a line start + any number of spaces and tabs.
	/// </summary>
	/// <param name="startOfLine">Receives i or the start of horizontal whitespace before i.</param>
	public static bool IsLineStart(RStr s, int i, out int startOfLine) {
		while (i > 0 && s[i - 1] is '\t' or ' ') i--;
		startOfLine = i;
		return i == 0 || s[i - 1] == '\n';
	}
	
	/// <summary>
	/// Creates string containing n tabs or n*4 spaces, depending on <b>App.Settings.ci_formatTabIndent</b>.
	/// See also <see cref="CiUtilExt.AppendIndent"/>.
	/// </summary>
	public static string CreateIndentString(int n) {
		if (n < 1) return "";
		if (App.Settings.ci_formatTabIndent) return new('\t', n);
		return new(' ', n * 4);
	}
	
	/// <summary>
	/// Returns string with same indent as of the document line from pos.
	/// The string must not contain multiline raw/verbatim strings; this func ignores it.
	/// </summary>
	public static string IndentStringForInsertSimple(string s, SciCode doc, int pos, bool indentFirstLine = false, int indentPlus = 0) {
		if (s.Contains('\n')) {
			int indent = doc.aaaLineIndentFromPos(true, pos) + indentPlus;
			//if (!App.Settings.ci_formatTabIndent) s = s.RxReplace(@"(?m)^\t+", m => CreateIndentString(m.Length)); //rejected. This could be useful for snippets. But then also need to apply App.Settings.ci_formatCompact=false, eg move braces to new lines, indent switch block. Then also need to do all it in code inserted by tools. Better let users format code afterwards.
			if (indent > 0) s = s.RxReplace(indentFirstLine ? @"(?m)^" : @"(?<=\n)", CreateIndentString(indent));
		}
		return s;
	}
	
	public static string GoogleURL(string query) => App.Settings.internetSearchUrl + System.Net.WebUtility.UrlEncode(query);
	
	#endregion
	
	#region syntax
	
	/// <summary>
	/// Returns true if <i>pos</i> is in trivia where normal tokens are not allowed. For example in comment, doccomment, directive, disabled text.
	/// </summary>
	public static bool IsPosInNonblankTrivia(SyntaxNode node, int pos, string code) {
		if (pos > 0) {
			bool minus1 = (pos == code.Length || SyntaxFacts.IsNewLine(code[pos])) && !SyntaxFacts.IsNewLine(code[pos - 1]); //end of text or non-empty line. At the left can be eg `//comment`.
			if (minus1) pos--;
			var trivia = node.FindTrivia(pos);
			var tk = trivia.Kind();
			if (!(tk is 0 or SyntaxKind.WhitespaceTrivia or SyntaxKind.EndOfLineTrivia)) {
				var ts = trivia.Span;
				//print.it($"{trivia.Kind()}, {pos}, {trivia.FullSpan}, {ts}, '{trivia}'");
				if (tk is SyntaxKind.DisabledTextTrivia or SyntaxKind.EndIfDirectiveTrivia or SyntaxKind.ElifDirectiveTrivia or SyntaxKind.ElseDirectiveTrivia or SyntaxKind.BadDirectiveTrivia) return true;
				if (minus1 && pos + 1 == ts.End && tk is SyntaxKind.MultiLineCommentTrivia or SyntaxKind.MultiLineDocumentationCommentTrivia) return false;
				if (pos > trivia.FullSpan.Start && pos < ts.End) return true;
			}
		}
		return false;
	}
	
	/// <summary>
	/// Returns true if <i>code</i> contains global statements or is empty or the first method of the first class is named "Main".
	/// </summary>
	public static bool IsScript(string code) {
		var cu = CreateSyntaxTree(code);
		var f = cu.Members.FirstOrDefault();
		if (f != null) {
			if (f is GlobalStatementSyntax) return true;
			if (f is BaseNamespaceDeclarationSyntax nd) f = nd.Members.FirstOrDefault();
			if (f is ClassDeclarationSyntax cd && cd.Members.OfType<MethodDeclarationSyntax>().FirstOrDefault()?.Identifier.Text == "Main") return true;
		} else {
			var u = cu.Usings.FirstOrDefault();
			if (u != null && u.GlobalKeyword.RawKind != 0) return false; //global.cs?
			return !cu.AttributeLists.Any(); //AssemblyInfo.cs?
		}
		return false;
	}
	
	#endregion
	
	#region symbols
	
	public static (ISymbol symbol, CodeInfo.Context cd) GetSymbolFromPos(bool andZeroLength = false, bool preferVar = false) {
		if (!CodeInfo.GetContextAndDocument(out var cd)) return default;
		return (GetSymbolFromPos(cd, andZeroLength, preferVar), cd);
	}
	
	public static ISymbol GetSymbolFromPos(CodeInfo.Context cd, bool andZeroLength = false, bool preferVar = false) {
		if (andZeroLength && _TryGetAltSymbolFromPos(cd) is ISymbol s1) return s1;
		var sym = SymbolFinder.FindSymbolAtPositionAsync(cd.document, cd.pos).Result_();
		if (sym is IMethodSymbol ims) sym = ims.PartialImplementationPart ?? sym;
		else if (preferVar && sym is INamedTypeSymbol) { //for 'this' and 'base' SymbolFinder gets INamedTypeSymbol
			int i1 = cd.pos, i2 = i1;
			while (i1 > 0 && SyntaxFacts.IsIdentifierPartCharacter(cd.code[i1 - 1])) i1--;
			while (i2 < cd.code.Length && SyntaxFacts.IsIdentifierPartCharacter(cd.code[i2])) i2++;
			if (cd.code.Eq(i1..i2, "this") || cd.code.Eq(i1..i2, "base")) {
				var node = cd.syntaxRoot.FindToken(cd.pos).Parent;
				var semo = cd.semanticModel;
				return semo.GetSymbolInfo(node).GetAnySymbol() ?? semo.GetDeclaredSymbolForNode(node);
			}
		}
		return sym;
	}
	
	static ISymbol _TryGetAltSymbolFromPos(CodeInfo.Context cd) {
		if (cd.code.Eq(cd.pos, '[')) { //indexer?
			var t = cd.syntaxRoot.FindToken(cd.pos, true);
			if (t.IsKind(SyntaxKind.OpenBracketToken) && t.Parent is BracketedArgumentListSyntax { Parent: ElementAccessExpressionSyntax es }) {
				return cd.semanticModel.GetSymbolInfo(es).GetAnySymbol();
			}
		}
		//rejected: in the same way get cast operator if pos is before '('. Not very useful.
		return null;
	}
	
	public static (ISymbol symbol, string keyword, HelpKind helpKind, SyntaxToken token) GetSymbolEtcFromPos(CodeInfo.Context cd, bool forHelp = false) {
		if (_TryGetAltSymbolFromPos(cd) is ISymbol s1) return (s1, null, default, default);
		
		int pos = cd.pos; if (pos > 0 && SyntaxFacts.IsIdentifierPartCharacter(cd.code[pos - 1])) pos--;
		if (!cd.syntaxRoot.FindTouchingToken(out var token, pos, findInsideTrivia: true)) return default;
		
		string word = cd.code[token.Span.ToRange()];
		
		var k = token.Kind();
		if (k == SyntaxKind.IdentifierToken) {
			switch (word) {
			case "var" when forHelp: //else get the inferred type
			case "dynamic":
			case "nameof":
			case "unmanaged": //tested cases
				return (null, word, HelpKind.ContextualKeyword, token);
			}
			
			if (GetSymbolFromPos(cd) is not { } sym) return (null, null, default, token);
			
			//if pressed F1 inside identifier in `identifier[...]`, it's very likely wants help for the indexer. Let's show menu.
			if (forHelp && CiQuickInfo.GetIndexerToken(cd, token, out var tok2)) {
				if (tok2.Parent is BracketedArgumentListSyntax { Parent: ElementAccessExpressionSyntax es }) {
					if (cd.semanticModel.GetSymbolInfo(es).GetAnySymbol() is { } sym2) {
						switch (popupMenu.showSimple([sym.Name, "[...]"], PMFlags.ByCaret, rawText: true)) {
						case 1: break;
						case 2: sym = sym2; break;
						default: return (null, null, default, token);
						}
					}
				}
			}
			
			return (sym, null, default, token);
		} else if (token.Parent is ImplicitObjectCreationExpressionSyntax && (!forHelp || cd.pos == token.Span.End)) {
			//for 'new(' get the ctor or type
		} else if (k == SyntaxKind.BaseKeyword) {
			
		} else {
			//print.it(
			//	//token.IsKeyword(), //IsReservedKeyword||IsContextualKeyword, but not IsPreprocessorKeyword
			//	SyntaxFacts.IsReservedKeyword(k), //also true for eg #if
			//	SyntaxFacts.IsContextualKeyword(k)
			//	//SyntaxFacts.IsQueryContextualKeyword(k) //included in IsContextualKeyword
			//	//SyntaxFacts.IsAccessorDeclarationKeyword(k),
			//	//SyntaxFacts.IsPreprocessorKeyword(k), //true if #something or can be used in #something context. Also true for eg if without #.
			//	//SyntaxFacts.IsPreprocessorContextualKeyword(k) //badly named. True only if #something.
			//	);
			
			if (SyntaxFacts.IsReservedKeyword(k)) {
				bool pp = (word == "if" || word == "else") && token.GetPreviousToken().IsKind(SyntaxKind.HashToken);
				if (pp) word = "#" + word;
				return (null, word, pp ? HelpKind.PreprocKeyword : HelpKind.ReservedKeyword, token);
			}
			if (SyntaxFacts.IsContextualKeyword(k)) {
				return (null, word, SyntaxFacts.IsAttributeTargetSpecifier(k) ? HelpKind.AttributeTarget : HelpKind.ContextualKeyword, token);
			}
			if (SyntaxFacts.IsPreprocessorKeyword(k)) {
				//if(SyntaxFacts.IsPreprocessorContextualKeyword(k)) word = "#" + word; //better don't use this internal func
				if (token.GetPreviousToken().IsKind(SyntaxKind.HashToken)) word = "#" + word;
				return (null, word, HelpKind.PreprocKeyword, token);
			}
			if (token.Parent is BaseArgumentListSyntax bals) {
				if (!GetFunctionSymbolInfoFromArgumentList(bals, cd.semanticModel, out var si)) return default;
				return (si.GetAnySymbol(), null, default, token);
			}
			switch (token.IsInString(cd.pos, cd.code, out _)) {
			case true: return (null, null, HelpKind.String, token);
			case null: return default;
			}
		}
		//note: don't pass contextual keywords to FindSymbolAtPositionAsync or GetSymbolInfo.
		//	It may get info for something other, eg 'new' -> ctor or type, or 'int' -> type 'Int32'.
		
		return (GetSymbolFromPos(cd), null, default, token);
	}
	
	/// <summary>
	/// Gets SymbolInfo of invoked method, ctor or indexer from its argument list.
	/// </summary>
	public static bool GetFunctionSymbolInfoFromArgumentList(BaseArgumentListSyntax als, SemanticModel semo, out SymbolInfo si) {
		si = default;
		var pa = als.Parent;
		if (als is ArgumentListSyntax && pa is InvocationExpressionSyntax or BaseObjectCreationExpressionSyntax) {
			si = semo.GetSymbolInfo(pa);
		} else if (als is BracketedArgumentListSyntax && pa is ElementAccessExpressionSyntax eacc) {
			si = semo.GetSymbolInfo(eacc);
		} else return false;
		return !si.IsEmpty;
	}
	
	public enum HelpKind {
		None, ReservedKeyword, ContextualKeyword, AttributeTarget, PreprocKeyword, String
	}
	
	public static void OpenSymbolEtcFromPosHelp() {
		string url = null;
		if (!CodeInfo.GetContextAndDocument(out var cd)) return;
		var (sym, keyword, helpKind, _) = GetSymbolEtcFromPos(cd, forHelp: true);
		if (sym != null) {
			url = GetSymbolHelpUrl(sym, out bool isAu);
			if (isAu) {
				HelpUtil.AuHelp(url);
				return;
			}
		} else if (keyword != null) {
			var s = helpKind switch {
				HelpKind.PreprocKeyword => "preprocessor directive",
				HelpKind.AttributeTarget => "attributes, ",
				_ => "keyword"
			};
			s = $"C# {s} \"{keyword}\"";
			//print.it(s); return;
			url = GoogleURL(s);
		} else if (helpKind == HelpKind.String) {
			int i = popupMenu.showSimple("1 C# strings|2 String formatting|3 Wildcard expression|4 Output tags|11 Regex tool (Ctrl+Space)|12 Keys tool (Ctrl+Space)", PMFlags.ByCaret);
			switch (i) {
			case 1: url = "C# strings"; break;
			case 2: url = "C# string formatting"; break;
			case 3: HelpUtil.AuHelp("articles/Wildcard expression"); break;
			case 4: HelpUtil.AuHelp("articles/Output tags"); break;
			case 11: CiTools.CmdShowRegexWindow(); break;
			case 12: CiTools.CmdShowKeysWindow(); break;
			}
			if (url != null) url = GoogleURL(url);
		}
		if (url != null) run.itSafe(url);
	}
	
	/// <summary>
	/// From position in code gets ArgumentSyntax and its IParameterSymbol.
	/// </summary>
	/// <param name="arg">Not null if returns true and the argument list isn't empty.</param>
	/// <param name="ps">If returns true, the array contains 1 or more elements. Multiple if cannot resolve overload.</param>
	/// <param name="filter"></param>
	public static bool GetArgumentParameterFromPos(BaseArgumentListSyntax als, int pos, SemanticModel semo, out ArgumentSyntax arg, out IParameterSymbol[] ps, Func<IParameterSymbol, bool> filter = null) {
		arg = null; ps = null;
		var args = als.Arguments;
		var index = args.Count == 0 ? 0 : args.IndexOf(o => pos <= o.FullSpan.End); //print.it(index);
		if (index < 0) return default;
		if (!CiUtil.GetFunctionSymbolInfoFromArgumentList(als, semo, out var si)) return default;
		string name = null;
		if (args.Count > 0) {
			arg = args[index];
			if (arg.NameColon is { } nc) name = nc.Name.Identifier.Text;
		}
		ps = GetParameterSymbol(si, index, name, args.Count, filter)
			.DistinctBy(o => o.Type.ToString()) //tested with Task.Run. 8 overloads, 4 distinct parameter types.
			.ToArray();
		return ps.Length > 0;
	}
	
	/// <summary>
	/// Gets IParameterSymbol of siFunction's parameter matching argument index or name.
	/// Can return multiple if cannot resolve overload.
	/// </summary>
	/// <param name="siFunction">SymbolInfo of the method, ctor or indexer.</param>
	/// <param name="index">Argument index. Not used if used name.</param>
	/// <param name="name">Parameter name, if specified in the argument, else null.</param>
	/// <param name="argCount">Count of arguments.</param>
	/// <param name="filter"></param>
	public static IEnumerable<IParameterSymbol> GetParameterSymbol(SymbolInfo siFunction, int index, string name, int argCount, Func<IParameterSymbol, bool> filter = null) {
		if (argCount == 0 && siFunction.Symbol is IMethodSymbol { ContainingType: var ct } ims && ims.Parameters.Length == 0) { //GetAllSymbols would contain just ims, but we need overloads with parameters
			foreach (var v in ct.GetMembers(ims.Name)) {
				if (v is IMethodSymbol m && m != ims) {
					if (_Get(m) is { } r) yield return r;
				}
			}
		} else {
			foreach (var v in siFunction.GetAllSymbols()) {
				if (_Get(v) is { } r) yield return r;
			}
		}
		
		IParameterSymbol _Get(ISymbol fsym) {
			var parms = fsym switch { IMethodSymbol ms => ms.Parameters, IPropertySymbol ps => ps.Parameters, _ => default };
			if (!parms.IsDefaultOrEmpty && parms.Length >= argCount) {
				var ps = name != null ? parms.FirstOrDefault(o => o.Name == name) : index < parms.Length ? parms[index] : null;
				if (ps != null) if (filter == null || filter(ps)) return ps;
			}
			return null;
		}
	}
	
	/// <summary>
	/// Gets <b>ILocalSymbol</b> or <b>IParameterSymbol</b> of the nearest declared/accessible local variable or parameter of one of specified types.
	/// Uses current document and caret position.
	/// Returns null if not found.
	/// </summary>
	/// <param name="types">Fully qualified type name. The type must be in an assembly, not in source.</param>
	/// <exception cref="ArgumentException">Type not found.</exception>
	public static ISymbol GetNearestLocalVariableOfType(params string[] types) {
		if (!CodeInfo.GetContextAndDocument(out var cd)) return null;
		var semo = cd.semanticModel;
		var ats = types.Select(o => semo.Compilation.GetTypeByMetadataName(o) ?? throw new ArgumentException($"Type not found: {o}."));
		var a = GetLocalVariablesAt(semo, cd.pos, o => ats.Contains(o));
		return a.Count > 0 ? a[^1] : null;
	}
	
	/// <summary>
	/// Gets <b>ILocalSymbol</b> or <b>IParameterSymbol</b> of local variables and parameters that can be used at position <i>pos</i>. The order is the same as declared in code.
	/// Not perfect.
	/// </summary>
	public static List<ISymbol> GetLocalVariablesAt(SemanticModel semo, int pos, Func<ITypeSymbol, bool> ofType = null) {
		var a = new List<ISymbol>();
		var scopes = _GetLocalScopes(semo, pos);
		if (scopes.Count > 0) {
			var e = semo.GetAllDeclaredSymbols(scopes[^1], default);
			//var e=semo.GetAllDeclaredSymbols(scopes[^1], default, o => { CiUtil.PrintNode(o); return true; });
			foreach (var v in e) {
				//if (v is not (ILocalSymbol or IParameterSymbol)) print.it(v.Name, v.GetTypeDisplayName());
				if (v is not (ILocalSymbol or IParameterSymbol)) continue;
				if (ofType != null && !ofType(v.GetSymbolType())) continue;
				var n2 = v.DeclaringSyntaxReferences.First().GetSyntax();
				var s2 = _GetLocalScope(n2);
				if (!scopes.Contains(s2)) {
					//print.it($"<>    <c #ff8080>{v.Name}, {v.GetSymbolType()}<>");
					continue;
				}
				var span = n2 is ForEachStatementSyntax fe ? fe.Identifier.Span : n2.Span;
				if (pos <= span.End) {
					//print.it($"<>    <c #c0c0c0>{v.Name}, {v.GetSymbolType()}<>");
					continue;
				}
				//print.it(v.Name, v.GetSymbolType());
				a.Add(v);
			}
		}
		return a;
	}
	
	/// <summary>
	/// Enumerates properties and fields of the enclosing class/struct.
	/// Skips write-only properties, indexers and const fields. Enums both static and non-static.
	/// </summary>
	public static IEnumerable<ISymbol> EnumPropertiesAndFields(SemanticModel semo, int pos) {
		if (semo.GetEnclosingNamedType(pos, default) is { TypeKind: TypeKind.Class or TypeKind.Struct } t) {
			foreach (var v in t.GetMembers().Where(o => o is IFieldSymbol or IPropertySymbol)) {
				if (v is IPropertySymbol ips) {
					if (ips.IsIndexer || ips.IsWriteOnly) continue;
				} else if (v is IFieldSymbol ifs) {
					if (ifs.IsConst || ifs.AssociatedSymbol != null) continue;
				} else continue;
				
				yield return v;
			}
		}
	}
	
	/// <summary>
	/// Gets ancestor scopes of local variables and parameters.
	/// For { block } gets its parent if there may be declared variables/parameters that are visible only in that block; eg function declaration or foreach statement.
	/// </summary>
	/// <param name="semo"></param>
	/// <param name="pos"></param>
	static List<SyntaxNode> _GetLocalScopes(SemanticModel semo, int pos) {
		var a = new List<SyntaxNode>();
		var node = semo.SyntaxTree.GetCompilationUnitRoot().FindToken(pos).Parent;
		bool inside = false;
		foreach (var v in node.AncestorsAndSelf()) {
			if (v is CompilationUnitSyntax) {
				a.Add(v);
				break;
			}
			if (!(inside || (inside = v.Span.ContainsInside(pos)))) continue;
			if (_IsLocalScope(v)) {
				a.Add(v);
				if (v is BaseMethodDeclarationSyntax) break;
				if (v is LocalFunctionStatementSyntax lf && lf.Modifiers.Any(SyntaxKind.StaticKeyword)) break;
				if (v is AnonymousFunctionExpressionSyntax af && af.Modifiers.Any(SyntaxKind.StaticKeyword)) break;
			} else if (v is BaseTypeDeclarationSyntax or NamespaceDeclarationSyntax) {
				a.Clear();
				break;
			}
		}
		return a;
	}
	
	/// <summary>
	/// Returns true if local/parameter variables declared inside n aren't visible outside.
	/// </summary>
	/// <param name="n"></param>
	static bool _IsLocalScope(SyntaxNode n) {
		if (n is BlockSyntax) return !_Is2(n.Parent);
		return _Is2(n) || n is SwitchSectionSyntax or CompilationUnitSyntax;
		
		static bool _Is2(SyntaxNode n) => n is BaseMethodDeclarationSyntax
			or LocalFunctionStatementSyntax
			or AnonymousFunctionExpressionSyntax
			or ForStatementSyntax
			or CommonForEachStatementSyntax
			or CatchClauseSyntax
			or FixedStatementSyntax
			or UsingStatementSyntax
			or SwitchExpressionArmSyntax
		;
	}
	
	static SyntaxNode _GetLocalScope(SyntaxNode node) => node.FirstAncestorOrSelf<SyntaxNode>(o => _IsLocalScope(o));
	
	/// <summary>
	/// 
	/// </summary>
	/// <param name="sym"></param>
	/// <param name="isAu">It's an Au symbol. Returns not URL but just HTML filename like <c>"Au.Something"</c> or <c>"Au.Types.Generic-1"</c>. Call <see cref="HelpUtil.AuHelp"/>. Another way to detect it - <see cref="HelpUtil.IsAuHelp_"/>.</param>
	/// <returns></returns>
	public static string GetSymbolHelpUrl(ISymbol sym, out bool isAu) {
		isAu = false;
		//print.it(sym);
		//print.it(sym.IsInSource(), sym.IsFromSource());
		if (sym is IParameterSymbol or ITypeParameterSymbol) return null;
		string query;
		IModuleSymbol metadata = null;
		foreach (var loc in sym.Locations) {
			if ((metadata = loc.MetadataModule) != null) break;
		}
		
		isAu = metadata?.Name == "Au.dll";
		if (isAu && !sym.HasPublicResultantVisibility()) metadata = null; //no online doc for other than public, protected, protected internal. But the google search is useful eg if it's an Api class member visible because of meta testInternal.
		
		if (metadata != null) {
			if (isAu && sym.IsEnumMember()) sym = sym.ContainingType;
			//print.it(sym, sym.GetType(), sym.GetType().GetInterfaces());
			if (sym is INamedTypeSymbol nt && nt.IsGenericType) {
				var qn = sym.QualifiedName(noDirectName: true);
				if (isAu) query = qn + "." + sym.MetadataName.Replace('`', '-');
				else query = $"{qn}.{sym.Name}<{string.Join(", ", nt.TypeParameters)}>";
			} else {
				query = sym.QualifiedName();
			}
			
			if (query.Ends("..ctor")) query = query.ReplaceAt(^6.., isAu ? ".-ctor" : " constructor");
			else if (query.Ends(".this[]")) query = query.ReplaceAt(^7.., ".Item");
			
			if (isAu) return query;
			if (metadata.Name.Starts("Au.")) return null;
			
			string kind = (sym is INamedTypeSymbol ints) ? ints.TypeKind.ToString() : sym.Kind.ToString();
			query = query + " " + kind.Lower();
		} else if (!sym.IsInSource() && !isAu) { //eg an operator of string etc
			if (!(sym is IMethodSymbol me && me.MethodKind == MethodKind.BuiltinOperator)) return null;
			//print.it(sym, sym.Kind, sym.QualifiedName());
			//query = "C# " + sym.ToString(); //eg "string.operator +(string, string)", and Google finds just Equality
			//query = "C# " + sym.QualifiedName(); //eg "System.String.op_Addition", and Google finds nothing
			query = "C# " + sym.ToString().RxReplace(@"\(.+\)$", "", 1).Replace('.', ' '); //eg C# string operator +, not bad
		} else if (sym.IsExtern) { //[DllImport]
			query = sym.Name + " function";
		} else if (sym is INamedTypeSymbol nt1 && nt1.IsComImport) { //[ComImport] interface or coclass
			query = sym.Name + " " + nt1.TypeKind.ToString().Lower();
		} else if (sym.ContainingType?.IsComImport == true) { //[ComImport] interface method
			query = sym.ContainingType.Name + "." + sym.Name;
		} else if (_IsNativeApiClass(sym.ContainingType)) {
			if (sym is INamedTypeSymbol nt2) query = sym.Name + " " + (nt2.TypeKind switch { TypeKind.Struct => "structure", TypeKind.Enum => "enumeration", TypeKind.Delegate => "callback function", _ => null });
			else query = sym.Name; //constant or Guid/etc
		} else if (sym is IFieldSymbol && _IsNativeApiClass(sym.ContainingType.ContainingType)) {
			query = sym.ContainingType.Name + "." + sym.Name; //struct field or enum member
		} else {
			return null;
		}
		
		static bool _IsNativeApiClass(INamedTypeSymbol t)
			=> t?.TypeKind is TypeKind.Class or TypeKind.Struct
			&& (t.BaseType?.Name == "NativeApi" || t.Name.Contains("Native") || t.Name.Ends("Api"));
		
		return GoogleURL(query);
	}
	
	public static PSFormat GetParameterStringFormat(SyntaxNode node, SemanticModel semo, bool isString, bool ignoreInterpolatedString = false) {
		var kind = node.Kind();
		//print.it(kind);
		SyntaxNode parent;
		if (isString || kind == SyntaxKind.StringLiteralExpression) parent = node.Parent;
		else if (kind == SyntaxKind.InterpolatedStringText && !ignoreInterpolatedString) parent = node.Parent.Parent;
		else return PSFormat.None;
		
		while (parent is BinaryExpressionSyntax && parent.IsKind(SyntaxKind.AddExpression)) parent = parent.Parent; //"string"+"string"+...
		
		if (parent is ExpressionElementSyntax { Parent: CollectionExpressionSyntax colex }) parent = colex.Parent; //["", ""]
		
		PSFormat format = PSFormat.None;
		if (parent is ArgumentSyntax asy) {
			if (parent.Parent is ArgumentListSyntax alis) {
				if (alis.Parent is ExpressionSyntax es && es is BaseObjectCreationExpressionSyntax or InvocationExpressionSyntax) {
					var si = semo.GetSymbolInfo(es);
					if (si.Symbol is IMethodSymbol m) {
						format = _GetFormat(m, alis);
					} else if (!si.CandidateSymbols.IsDefaultOrEmpty) {
						foreach (var v in si.CandidateSymbols.OfType<IMethodSymbol>()) {
							if ((format = _GetFormat(v, alis)) != 0) break;
						}
					}
				}
			} else if (parent.Parent is BracketedArgumentListSyntax balis && balis.Parent is ElementAccessExpressionSyntax eacc) {
				if (semo.GetSymbolInfo(eacc).Symbol is IPropertySymbol ips && ips.IsIndexer) {
					var ims = ips.SetMethod;
					if (ims != null) format = _GetFormat(ims, balis);
				}
			}
			
			PSFormat _GetFormat(IMethodSymbol ims, BaseArgumentListSyntax alis) {
				IParameterSymbol p = null;
				var pa = ims.Parameters;
				if (pa.Length > 0) {
					var nc = asy.NameColon;
					if (nc != null) {
						var name = nc.Name.Identifier.Text;
						foreach (var v in pa) if (v.Name == name) { p = v; break; }
					} else {
						int i; var aa = alis.Arguments;
						for (i = 0; i < aa.Count; i++) if ((object)aa[i] == asy) break;
						if (i >= pa.Length && pa[^1].IsParams) i = pa.Length - 1;
						if (i < pa.Length) p = pa[i];
					}
					if (p != null) {
						foreach (var v in p.GetAttributes()) {
							switch (v.AttributeClass.Name) {
							case nameof(ParamStringAttribute): return v.GetConstructorArgument<PSFormat>(0, SpecialType.None);
							case nameof(System.Diagnostics.CodeAnalysis.StringSyntaxAttribute) when v.GetConstructorArgument<string>(0, SpecialType.System_String) == System.Diagnostics.CodeAnalysis.StringSyntaxAttribute.Regex: return PSFormat.NetRegex; //note: the attribute also can be set on properties and fields. But Regex doesn't have.
							}
						}
					}
				}
				return PSFormat.None;
			}
		}
		return format;
	}
	
	/// <summary>
	/// Gets "global using Namespace;" directives from all files of compilation. Skips aliases and statics.
	/// </summary>
	public static IEnumerable<UsingDirectiveSyntax> GetAllGlobalUsings(SemanticModel model) {
		foreach (var st in model.Compilation.SyntaxTrees) {
			foreach (var u in st.GetCompilationUnitRoot().Usings) {
				if (u.GlobalKeyword.RawKind == 0) break;
				if (u.Alias != null || u.StaticKeyword.RawKind != 0) continue;
				yield return u;
			}
		}
	}
	
	/// <summary>
	/// Calls Classifier.GetClassifiedSpansAsync and corrects overlapped items etc.
	/// </summary>
	public static async Task<List<ClassifiedSpan>> GetClassifiedSpansAsync(Document document, int from, int to, CancellationToken cancellationToken = default) {
		var e = await Classifier.GetClassifiedSpansAsync(document, TextSpan.FromBounds(from, to)).ConfigureAwait(false);
		return _CorrectClassifiedSpans(e);
	}
	
	/// <summary>
	/// Calls Classifier.GetClassifiedSpans and corrects overlapped items etc.
	/// </summary>
	public static List<ClassifiedSpan> GetClassifiedSpans(SemanticModel semo, Document document, int from, int to, CancellationToken cancellationToken = default) {
		var proj = document.Project;
		var opt = new ClassificationOptions { ColorizeRegexPatterns = false, ColorizeJsonPatterns = true }; //default true true, but don't work; turn off regex anyway.
		var e = Classifier.GetClassifiedSpans(proj.Solution.Services, proj, semo, TextSpan.FromBounds(from, to), opt, true, cancellationToken);
		return _CorrectClassifiedSpans(e);
	}
	
	static List<ClassifiedSpan> _CorrectClassifiedSpans(IEnumerable<ClassifiedSpan> espans) {
		var a = espans as List<ClassifiedSpan>;
		//print.clear(); foreach (var v in a) print.it(v.ClassificationType);
		
		//Order StringEscapeCharacter correctly. Now in $"string" they are randomly after or before the string. Must be after.
		//	This code ignores regex and json tokens, because Classifier.GetClassifiedSpans does not produce them (why?). And callers don't support it too.
		for (int k = a.Count; --k > 0;) {
			if (a[k - 1].ClassificationType == ClassificationTypeNames.StringEscapeCharacter)
				//if (a[k].ClassificationType == ClassificationTypeNames.StringLiteral || a[k].ClassificationType == ClassificationTypeNames.VerbatimStringLiteral)
				if (a[k].TextSpan.Contains(a[k - 1].TextSpan))
					Math2.Swap(ref a.Ref(k), ref a.Ref(k - 1));
		}
		
		//remove StaticSymbol
		int i = 0, j = 0;
		for (; i < a.Count; i++) {
			if (a[i].ClassificationType == ClassificationTypeNames.StaticSymbol) continue;
			if (j != i) a[j] = a[i];
			j++;
		}
		if ((i -= j) > 0) a.RemoveRange(a.Count - i, i);
		
		return a;
	}
	
	/// <summary>
	/// For C# code gets style bytes that can be used with SCI_SETSTYLINGEX for UTF-8 text.
	/// Uses Classifier.GetClassifiedSpansAsync, like the code editor.
	/// Controls that use this should set styles like this example, probably when handle created:
	/// <c>var styles = new CiStyling.TTheme { FontSize = 9 };
	/// styles.ToScintilla(this);</c>
	/// <para>
	/// If called in LA tools process or in a non-main LA thread, runs in the main process/thread; returns <c>null</c> if failed.
	/// </para>
	/// </summary>
	public static byte[] GetScintillaStylingBytes8(string code) {
		if (!process.IsLaMainThread_) {
			if (process.IsLaProcess_) return App.Dispatcher.Invoke<byte[]>(() => GetScintillaStylingBytes8(code));
			return WndCopyData.SendReceive<char>(ScriptEditor.WndMsg_, 15, code, out byte[] r1) ? r1 : null;
		}
		
		var styles8 = new byte[Encoding.UTF8.GetByteCount(code)];
		var map8 = styles8.Length == code.Length ? null : Convert2.Utf8EncodeAndGetOffsets_(code).offsets;
		using var ws = new AdhocWorkspace();
		var document = CreateDocumentFromCode(ws, code, needSemantic: true);
		//var semo = document.GetSemanticModelAsync().Result;
		var a = GetClassifiedSpansAsync(document, 0, code.Length).Result_();
		foreach (var v in a) {
			//print.it(v.TextSpan, v.ClassificationType, code[v.TextSpan.Start..v.TextSpan.End]);
			EStyle style = CiStyling.StyleFromClassifiedSpan(v);
			if (style == EStyle.None) continue;
			var (i, end) = v.TextSpan;
			if (map8 != null) { i = map8[i]; end = map8[end]; }
			while (i < end) styles8[i++] = (byte)style;
		}
		return styles8;
	}
	
	//not used
	///// <summary>
	///// For C# code gets style bytes that can be used with <see cref="KScintilla.aaaSetStyling"/> (UTF-16).
	///// Uses Classifier.GetClassifiedSpansAsync, like the code editor.
	///// Controls that use this should set styles like this example, probably when handle created:
	///// <c>var styles = new CiStyling.TTheme { FontSize = 9 };
	///// styles.ToScintilla(this);</c>
	///// </summary>
	//public static byte[] GetScintillaStylingBytes16(string code) {
	//	var styles8 = new byte[code.Length];
	//	using var ws = new AdhocWorkspace();
	//	var document = CreateDocumentFromCode(ws, code, needSemantic: true);
	//	//var semo = document.GetSemanticModelAsync().Result;
	//	var a = GetClassifiedSpansAsync(document, 0, code.Length).Result;
	//	foreach (var v in a) {
	//		//print.it(v.TextSpan, v.ClassificationType, code[v.TextSpan.Start..v.TextSpan.End]);
	//		EStyle style = CiStyling.StyleFromClassifiedSpan(v);
	//		if (style == EStyle.None) continue;
	//		var (i, end) = v.TextSpan;
	//		while (i < end) styles8[i++] = (byte)style;
	//	}
	//	return styles8;
	//}
	
	public static CiItemKind MemberDeclarationToKind(MemberDeclarationSyntax m) {
		return m switch {
			ClassDeclarationSyntax or ExtensionBlockDeclarationSyntax => CiItemKind.Class,
			StructDeclarationSyntax => CiItemKind.Structure,
			RecordDeclarationSyntax rd => rd.IsKind(SyntaxKind.RecordStructDeclaration) ? CiItemKind.Structure : CiItemKind.Class,
			EnumDeclarationSyntax => CiItemKind.Enum,
			DelegateDeclarationSyntax => CiItemKind.Delegate,
			InterfaceDeclarationSyntax => CiItemKind.Interface,
			OperatorDeclarationSyntax or ConversionOperatorDeclarationSyntax or IndexerDeclarationSyntax => CiItemKind.Operator,
			BaseMethodDeclarationSyntax => CiItemKind.Method,
			// => CiItemKind.ExtensionMethod,
			PropertyDeclarationSyntax => CiItemKind.Property,
			EventDeclarationSyntax or EventFieldDeclarationSyntax => CiItemKind.Event,
			FieldDeclarationSyntax f => f.Modifiers.Any(o => o.Text == "const") ? CiItemKind.Constant : CiItemKind.Field,
			EnumMemberDeclarationSyntax => CiItemKind.EnumMember,
			BaseNamespaceDeclarationSyntax => CiItemKind.Namespace,
			_ => CiItemKind.None
		};
	}
	
	public static void TagsToKindAndAccess(ImmutableArray<string> tags, out CiItemKind kind, out CiItemAccess access) {
		kind = CiItemKind.None;
		access = default;
		if (tags.IsDefaultOrEmpty) return;
		kind = tags[0] switch {
			WellKnownTags.Class => CiItemKind.Class,
			WellKnownTags.Structure => CiItemKind.Structure,
			WellKnownTags.Enum => CiItemKind.Enum,
			WellKnownTags.Delegate => CiItemKind.Delegate,
			WellKnownTags.Interface => CiItemKind.Interface,
			WellKnownTags.Method => CiItemKind.Method,
			WellKnownTags.ExtensionMethod => CiItemKind.ExtensionMethod,
			WellKnownTags.Property => CiItemKind.Property,
			WellKnownTags.Operator => CiItemKind.Operator,
			WellKnownTags.Event => CiItemKind.Event,
			WellKnownTags.Field => CiItemKind.Field,
			WellKnownTags.Local => CiItemKind.LocalVariable,
			WellKnownTags.Parameter => CiItemKind.LocalVariable,
			WellKnownTags.RangeVariable => CiItemKind.LocalVariable,
			WellKnownTags.Constant => CiItemKind.Constant,
			WellKnownTags.EnumMember => CiItemKind.EnumMember,
			WellKnownTags.Keyword => CiItemKind.Keyword,
			WellKnownTags.Namespace => CiItemKind.Namespace,
			WellKnownTags.Label => CiItemKind.Label,
			WellKnownTags.TypeParameter => CiItemKind.TypeParameter,
			//WellKnownTags.Snippet => CiItemKind.Snippet,
			_ => CiItemKind.None
		};
		if (tags.Length > 1) {
			access = tags[1] switch {
				WellKnownTags.Private => CiItemAccess.Private,
				WellKnownTags.Protected => CiItemAccess.Protected,
				WellKnownTags.Internal => CiItemAccess.Internal,
				_ => default
			};
		}
	}
	
	//The order must match CiItemKind.
	public static string[] ItemKindNames { get; } = new[] {
		"Class",
		"Structure",
		"Interface",
		"Enum",
		"Delegate",
		"Method",
		"ExtensionMethod",
		"Property",
		"Operator",
		"Event",
		"Field",
		"LocalVariable",
		"Constant",
		"EnumMember",
		"Namespace",
		"Keyword",
		"Label",
		"Snippet",
		"TypeParameter"
	};
	
	/// <summary>
	/// Calls <b>string.Compare</b>. Moves items starting with an ASCII non-symbol char to the bottom.
	/// </summary>
	public class CompletionListSortComparer : IComparer<string> {
		public int Compare(string x, string y) {
			int r = _IsAsciiNonSymChar(x) - _IsAsciiNonSymChar(y);
			if (r == 0) r = string.Compare(x, y, StringComparison.OrdinalIgnoreCase);
			return r;
			
			static int _IsAsciiNonSymChar(string s) => s.Length > 0 && s[0] is char c && (char.IsAsciiLetterOrDigit(c) || c == '_' || c > 127) ? 0 : 1;
		}
	}
	public static readonly CompletionListSortComparer SortComparer = new();
	
	#endregion
	
	#region create a syntax tree, document, etc
	
	/// <summary>
	/// From C# code creates a Roslyn workspace+project+document for code analysis.
	/// If <i>needSemantic</i>, adds default references and a document with default global usings (same as in default global.cs).
	/// </summary>
	/// <param name="ws"><c>using var ws = new AdhocWorkspace(); //need to dispose</c></param>
	/// <param name="code">Any C# code fragment, valid or not.</param>
	/// <param name="needSemantic">Add default references (.NET and Au.dll) and global usings.</param>
	public static Document CreateDocumentFromCode(AdhocWorkspace ws, string code, bool needSemantic) {
		ProjectId projectId = ProjectId.CreateNewId();
		DocumentId documentId = DocumentId.CreateNewId(projectId);
		var pi = ProjectInfo.Create(projectId, VersionStamp.Default, "l", "l", LanguageNames.CSharp, null, null,
			new CSharpCompilationOptions(OutputKind.WindowsApplication, allowUnsafe: true),
			new CSharpParseOptions(LanguageVersion.Preview),
			metadataReferences: needSemantic ? new MetaReferences().Refs : null //tested: does not make slower etc
			);
		var sol = ws.CurrentSolution.AddProject(pi);
		if (needSemantic) {
			sol = sol.AddDocument(DocumentId.CreateNewId(projectId), "g.cs", c_globalUsingsText);
		}
		return sol.AddDocument(documentId, "l.cs", code).GetDocument(documentId);
		
		//It seems it's important to dispose workspaces.
		//	In the docs project at first didn't dispose. After maybe 300_000 times: much slower, process memory 3 GB, sometimes hangs.
	}
	
	public const string c_globalUsingsText = """
global using Au;
global using Au.Types;
global using System;
global using System.Collections.Generic;
global using System.Linq;
global using System.Collections.Concurrent;
global using System.Diagnostics;
global using System.Globalization;
global using System.IO;
global using System.IO.Compression;
global using System.Runtime.CompilerServices;
global using System.Runtime.InteropServices;
global using System.Text;
global using System.Text.RegularExpressions;
global using System.Threading;
global using System.Threading.Tasks;
global using Microsoft.Win32;
global using Au.More;
global using Au.Triggers;
global using System.Windows;
global using System.Windows.Controls;
global using System.Windows.Media;
""";
	
	/// <summary>
	/// Calls <b>CSharpSyntaxTree.ParseText</b> and returns <b>CompilationUnitSyntax</b>.
	/// </summary>
	public static CompilationUnitSyntax CreateSyntaxTree(string code) {
		return CSharpSyntaxTree.ParseText(code, new CSharpParseOptions(LanguageVersion.Preview)).GetCompilationUnitRoot();
	}
	
	#endregion
	
	#region DEBUG
	
#if DEBUG
	public static void PrintNode(SyntaxNode x, int pos = 0, bool printNode = true, bool printErrors = false, bool indent = false) {
		if (x == null) { print.it("null"); return; }
		if (printNode) {
			string si = null;
			if (indent) {
				int i = x.Ancestors().Count();
				if (--i > 0) si = new('\t', i);
			}
			print.it($"<>{si}<c blue>{pos}, {x.Span}, {x.FullSpan}, k={x.Kind()}, t={x.GetType().Name},<> '<c green><\a>{(x is CompilationUnitSyntax ? null : x.ToString().Limit(10, middle: true, lines: true))}</\a><>'");
		}
		if (printErrors) foreach (var d in x.GetDiagnostics()) print.it(d.Code, d.Location.SourceSpan, d);
	}
	
	public static void PrintNode(SyntaxToken x, int pos = 0, bool printNode = true, bool printErrors = false) {
		if (printNode) print.it($"<><c blue>{pos}, {x.Span}, {x.Kind()},<> '<c green><\a>{x.ToString().Limit(10, middle: true, lines: true)}</\a><>'");
		if (printErrors) foreach (var d in x.GetDiagnostics()) print.it(d.Code, d.Location.SourceSpan, d);
	}
	
	public static void PrintNode(SyntaxTrivia x, int pos = 0, bool printNode = true, bool printErrors = false) {
		if (printNode) print.it($"<><c blue>{pos}, {x.Span}, {x.Kind()},<> '<c green><\a>{x.ToString().Limit(10, middle: true, lines: true)}</\a><>'");
		if (printErrors) foreach (var d in x.GetDiagnostics()) print.it(d.Code, d.Location.SourceSpan, d);
	}
	
	public static void DebugHiliteRange(int start, int end, int indic = SciTheme.Indic.TestBox) {
		var doc = Panels.Editor.ActiveDoc;
		doc.aaaIndicatorClear(indic);
		if (end > start) doc.aaaIndicatorAdd(indic, true, start..end);
	}
	
	public static void DebugHiliteRange(TextSpan span, int indic = SciTheme.Indic.TestBox) => DebugHiliteRange(span.Start, span.End, indic);
	
	public static void DebugHiliteRanges(List<Range> a, int indic = SciTheme.Indic.TestBox) {
		var doc = Panels.Editor.ActiveDoc;
		doc.aaaIndicatorClear(indic);
		int i = 0;
		foreach (var v in a) doc.aaaIndicatorAdd(indic, true, v, ++i);
	}
	
	static IEnumerable<string> DebugGetSymbolInterfaces(ISymbol sym) {
		return sym.GetType().FindInterfaces((t, _) => t.Name.Ends("Symbol") && t.Name != "ISymbol", null).Select(o => o.Name);
	}
	
	//unfinished. Just prints what we can get from CSharpSyntaxContext.
	public static /*CiContextType*/void DebugGetContextType(/*in CodeInfo.Context cd,*/ CSharpSyntaxContext c) {
		//print.it("--------");
		print.clear();
		//print.it(cd.pos);
		_Print("IsInNonUserCode", c.IsInNonUserCode);
		_Print("IsGlobalStatementContext", c.IsGlobalStatementContext);
		_Print("IsAnyExpressionContext", c.IsAnyExpressionContext);
		//_Print("IsAtStartOfPattern", c.IsAtStartOfPattern);
		//_Print("IsAtEndOfPattern", c.IsAtEndOfPattern);
		_Print("IsAttributeNameContext", c.IsAttributeNameContext);
		//_Print("IsCatchFilterContext", c.IsCatchFilterContext);
		_Print("IsConstantExpressionContext", c.IsConstantExpressionContext);
		_Print("IsCrefContext", c.IsCrefContext);
		//_Print("IsDeclarationExpressionContext", c.IsDeclarationExpressionContext); //removed from Roslyn
		//_Print("IsDefiniteCastTypeContext", c.IsDefiniteCastTypeContext);
		//_Print("IsEnumBaseListContext", c.IsEnumBaseListContext);
		//_Print("IsFixedVariableDeclarationContext", c.IsFixedVariableDeclarationContext);
		//_Print("IsFunctionPointerTypeArgumentContext", c.IsFunctionPointerTypeArgumentContext);
		//_Print("IsGenericTypeArgumentContext", c.IsGenericTypeArgumentContext);
		//_Print("IsImplicitOrExplicitOperatorTypeContext", c.IsImplicitOrExplicitOperatorTypeContext);
		_Print("IsInImportsDirective", c.IsInImportsDirective);
		//_Print("IsInQuery", c.IsInQuery);
		_Print("IsInstanceContext", c.IsInstanceContext);
		//_Print("IsIsOrAsOrSwitchOrWithExpressionContext", c.IsIsOrAsOrSwitchOrWithExpressionContext);
		//_Print("IsIsOrAsTypeContext", c.IsIsOrAsTypeContext);
		_Print("IsLabelContext", c.IsLabelContext);
		_Print("IsLocalVariableDeclarationContext", c.IsLocalVariableDeclarationContext);
		//_Print("IsMemberAttributeContext", c.IsMemberAttributeContext(new HashSet<SyntaxKind>(), default));
		_Print("IsMemberDeclarationContext", c.IsMemberDeclarationContext());
		_Print("IsNameOfContext", c.IsNameOfContext);
		_Print("IsNamespaceContext", c.IsNamespaceContext);
		_Print("IsNamespaceDeclarationNameContext", c.IsNamespaceDeclarationNameContext);
		_Print("IsNonAttributeExpressionContext", c.IsNonAttributeExpressionContext);
		_Print("IsObjectCreationTypeContext", c.IsObjectCreationTypeContext);
		_Print("IsOnArgumentListBracketOrComma", c.IsOnArgumentListBracketOrComma);
		_Print("IsParameterTypeContext", c.IsParameterTypeContext);
		_Print("IsPossibleLambdaOrAnonymousMethodParameterTypeContext", c.IsPossibleLambdaOrAnonymousMethodParameterTypeContext);
		_Print("IsPossibleTupleContext", c.IsPossibleTupleContext);
		_Print("IsPreProcessorDirectiveContext", c.IsPreProcessorDirectiveContext);
		_Print("IsPreProcessorExpressionContext", c.IsPreProcessorExpressionContext);
		_Print("IsPreProcessorKeywordContext", c.IsPreProcessorKeywordContext);
		_Print("IsPrimaryFunctionExpressionContext", c.IsPrimaryFunctionExpressionContext);
		_Print("IsRightOfNameSeparator", c.IsRightOfNameSeparator);
		_Print("IsRightSideOfNumericType", c.IsRightSideOfNumericType);
		_Print("IsStatementAttributeContext", c.IsStatementAttributeContext());
		_Print("IsStatementContext", c.IsStatementContext);
		_Print("IsTypeArgumentOfConstraintContext", c.IsTypeArgumentOfConstraintContext);
		_Print("IsTypeAttributeContext", c.IsTypeAttributeContext(default));
		_Print("IsTypeContext", c.IsTypeContext);
		_Print("IsTypeDeclarationContext", c.IsTypeDeclarationContext());
		_Print("IsTypeOfExpressionContext", c.IsTypeOfExpressionContext);
		_Print("IsWithinAsyncMethod", c.IsWithinAsyncMethod);
		//_Print("", c.);
		//_Print("", c.);
		//_Print("", c.);
		//_Print("", c.);
		
		static void _Print(string s, bool value) {
			if (value) print.it($"<><c red>{s}<>");
			else print.it(s);
		}
		
		//return CiContextType.Namespace;
	}
	
	//unfinished. Also does not support namespaces.
	//public static CiContextType DebugGetContextType(CompilationUnitSyntax t, int pos) {
	//	var members = t.Members;
	//	var ms = members.FullSpan;
	//	//foreach(var v in members) print.it(v.GetType().Name, v); return 0;
	//	//print.it(pos, ms);
	//	//CiUtil.HiliteRange(ms);
	//	if (ms == default) { //assume empty top-level statements
	//		var v = t.AttributeLists.FullSpan;
	//		if (v == default) {
	//			v = t.Usings.FullSpan;
	//			if (v == default) v = t.Externs.FullSpan;
	//		}
	//		if (pos >= v.End) return CiContextType.Method;
	//	} else if (pos < ms.Start) {
	//	} else if (pos >= members.Span.End) {
	//		if (members.Last() is GlobalStatementSyntax) return CiContextType.Method;
	//	} else {
	//		int i = members.IndexOf(o => o is not GlobalStatementSyntax);
	//		if (i < 0 || pos <= members[i].SpanStart) return CiContextType.Method;
	
	//		//now the difficult part
	//		ms = members[i].Span;
	//		print.it(pos, ms);
	//		CiUtil.HiliteRange(ms);
	//		//unfinished. Here should use CSharpSyntaxContext.
	//	}
	//	return CiContextType.Namespace;
	//}
	
	//enum CiContextType
	//{
	//	/// <summary>
	//	/// Outside class/method/topLevelStatements. Eg before using directives or at end of file.
	//	/// Completion list must not include types.
	//	/// </summary>
	//	Namespace,
	
	//	/// <summary>
	//	/// Inside class but outside method.
	//	/// Completion list can include types but not functions and values.
	//	/// </summary>
	//	Class,
	
	//	/// <summary>
	//	/// Inside method/topLevelStatements.
	//	/// Completion list can include all symbols.
	//	/// </summary>
	//	Method
	//}
	
#endif
	
	#endregion
}


================================================
FILE: Au.Editor/Edit/CiUtilExt.cs
================================================
extern alias CAW;

using System.Collections.Immutable;

using Microsoft.CodeAnalysis;
using CAW::Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Text;
using Microsoft.CodeAnalysis.CSharp.Extensions;
using Microsoft.CodeAnalysis.Shared.Extensions;
using CAW::Microsoft.CodeAnalysis.Shared.Extensions;
using Microsoft.CodeAnalysis.Completion;
//using Microsoft.CodeAnalysis.CSharp.Extensions.ContextQuery;
//using Microsoft.CodeAnalysis.Tags;
//using Microsoft.CodeAnalysis.DocumentationComments;
//using Microsoft.CodeAnalysis.FindSymbols;
//using Roslyn.Utilities;

namespace LA;

/// <summary>
/// Code info util extension methods.
/// </summary>
static class CiUtilExt {
	/// <summary>
	/// Detects whether <i>position</i> is inside a string (literal or interpolated, except when in an interpolation code).
	/// </summary>
	/// <returns>
	/// - false - not in a string; or is in a hole of an interpolated string.
	/// - true - in a string; or in a text part of an interpolated string.
	/// - null - inside of a prefix or suffix of a string or interpolation, eg @", $", @$", """, $$""", {{, }}.
	/// </returns>
	/// <param name="t">This token. It's ref; if <b>EndOfFileToken</b>, the function sets it = previous token.</param>
	/// <param name="position">Where this token has been found using code like <c>var token = root.FindToken(position);</c>.</param>
	/// <param name="code">All code. The function uses it to compare substrings easier and faster.</param>
	/// <param name="x">If the function returns true, receives span etc.</param>
	/// <param name="orU8">Support "text"u8 etc.</param>
	public static bool? IsInString(this ref SyntaxToken t, int position, string code, out CiStringInfo x, bool orU8 = false) {
		x = default;
		var k = t.Kind();
		if (k == SyntaxKind.EndOfFileToken) {
			t = t.GetPreviousToken(includeSkipped: true, includeDirectives: true);
			k = t.Kind();
		}
		//CiUtil.PrintNode(t);
		
		var span = t.Span;
		int start = span.Start, end = span.End;
		if (position < start || position > end) return false;
		bool isInterpolated = false, isVerbatim = false, isRaw = false, isRawPrefixCenter = false, isU8 = false;
		var node = t.Parent;
		
		if (node.IsKind(SyntaxKind.StringLiteralExpression) || (orU8 && (isU8 = node.IsKind(SyntaxKind.Utf8StringLiteralExpression)))) {
			if (position == start) return false;
			if (k is not (SyntaxKind.StringLiteralToken or SyntaxKind.Utf8StringLiteralToken)) isRaw = true;
			if (!isRaw) {
				if (isVerbatim = code[start++] == '@') if (position == start++) return null; //inside @"
				if (!isU8) {
					if (position < end) { end--; goto gTrue; }
					if (code[end - 1] != '"' || end == start || node.NoClosingQuote()) goto gTrue; //no closing "
				} else if (position < end) {
					end -= 3;
					if (position > end) return null;
					goto gTrue;
				}
				return false;
			} else {
				while (start < end && code[start] == '"') start++; //skip """
				int nq = start - span.Start;
				if (position < start) { //inside """
					if (!isU8 && _IsRawPrefixCenter(span.Start, nq)) goto gTrue;
					return null;
				}
				bool ml = k is SyntaxKind.MultiLineRawStringLiteralToken or SyntaxKind.Utf8MultiLineRawStringLiteralToken;
				if (ml) { //skip newline
					while (start < end && code[start] is ' ' or '\t') start++;
					if (code[start] == '\r') start++;
					if (code[start++] != '\n') return null;
				}
				x.isRawMultiline = ml;
				if (position < start) {
					x.isRawMultilineBetweenStartQuotesAndText = true;
					return null; //before newline
				}
				
				if (position == end) {
					if (!isU8 && node.NoClosingQuote()) goto gTrue;
					return false;
				}
				
				if (isU8) end -= 2;
				while (nq > 0 && end > start && code[--end] == '"') nq--;
				if (nq > 0) goto gTrue; //unterminated
				if (position > end) return null; //inside """, or """ not in its own line (error)
				if (ml) {
					while (end > start && code[end - 1] is ' ' or '\t') end--;
					if (code[--end] != '\n') return null;
					if (code[end - 1] == '\r') end--;
					if (position > end) return null;
					//never mind indent
				}
				goto gTrue;
			}
		}
		isInterpolated = true;
		
		bool _IsRawPrefixCenter(int iq, int nq) {
			//most likely the user will write a raw string at """|""" and not at """"""|
			if (nq < 6 || 0 != (nq & 1)) return false;
			iq += nq / 2; if (iq != position) return false;
			//if (isRawPrefixCenter = node.NoClosingQuote()) start = end = iq; //not always works
			//return isRawPrefixCenter;
			start = end = iq;
			return isRawPrefixCenter = true;
		}
		
		if (k is SyntaxKind.InterpolatedSingleLineRawStringStartToken or SyntaxKind.InterpolatedMultiLineRawStringStartToken) {
			int iq = start, nq = 0; while (code[iq] == '$') iq++;
			while (code.Eq(iq + nq, '"')) nq++;
			if (_IsRawPrefixCenter(iq, nq)) goto gTrue;
		}
		
		switch (k) {
		case SyntaxKind.InterpolatedStringTextToken:
			goto gTrue;
		case SyntaxKind.InterpolatedStringEndToken:
		case SyntaxKind.InterpolatedRawStringEndToken when position == start:
			_BackToTextToken(ref t);
			goto gTrue;
		case SyntaxKind.InterpolatedRawStringEndToken:
			return position == end ? false : null;
		case SyntaxKind.InterpolatedStringStartToken or SyntaxKind.InterpolatedVerbatimStringStartToken:
		case SyntaxKind.InterpolatedSingleLineRawStringStartToken or SyntaxKind.InterpolatedMultiLineRawStringStartToken:
			return position > start ? null : false;
		case SyntaxKind.OpenBraceToken when t.Parent is InterpolationSyntax:
			if (position == start) {
				if (!_BackToTextToken(ref t)) return null;
				goto gTrue;
			}
			if (code.Eq(position - 1, "{{")) return null;
			break;
		case SyntaxKind.CloseBraceToken when t.Parent is InterpolationSyntax:
			if (code.Eq(position - 1, "}}")) return null;
			break;
		}
		
		bool _BackToTextToken(ref SyntaxToken t) {
			var tt = t.GetPreviousToken();
			var kk = tt.Kind();
			if (kk == SyntaxKind.OpenBraceToken) return false;
			if (kk == SyntaxKind.InterpolatedStringTextToken) (start, end) = tt.Span;
			else end = start;
			return true;
		}
		
		return false;
		gTrue:
		x.textSpan = TextSpan.FromBounds(start, end);
		x.stringNode = t.Parent;
		if (isInterpolated && x.stringNode is not InterpolatedStringExpressionSyntax) x.stringNode = x.stringNode.Parent;
		Debug.Assert(x.stringNode is LiteralExpressionSyntax or InterpolatedStringExpressionSyntax);
		if (x.isInterpolated = isInterpolated) {
			var k1 = x.stringNode.GetFirstToken().Kind();
			x.isRawMultiline = k1 == SyntaxKind.InterpolatedMultiLineRawStringStartToken;
			if (k1 is SyntaxKind.InterpolatedVerbatimStringStartToken) isVerbatim = true;
			else if (k1 is SyntaxKind.InterpolatedSingleLineRawStringStartToken or SyntaxKind.InterpolatedMultiLineRawStringStartToken) isRaw = true;
		}
		x.isVerbatim = isVerbatim;
		x.isRaw = isRaw;
		x.isClassic = !(isVerbatim | isRaw);
		x.isRawPrefixCenter = isRawPrefixCenter;
		x.isU8 = isU8;
		return true;
	}
	
	//It seems these have no sense. Never noticed syntax warnings.
	///// <summary>
	///// Gets <b>IEnumerable</b> of <b>Diagnostic</b> where <b>Severity</b> is <b>Error</b>.
	///// </summary>
	///// <returns>Not null.</returns>
	//public static IEnumerable<Diagnostic> GetErrors(this SyntaxNode t) {
	//	if (!t.ContainsDiagnostics) return Array.Empty<Diagnostic>(); //faster
	//	return t.GetDiagnostics().Where(static o => o.Severity is DiagnosticSeverity.Error);
	//}
	
	///// <summary>
	///// Gets <b>IEnumerable</b> of <b>Diagnostic</b> where <b>Severity</b> is <b>Error</b>.
	///// </summary>
	///// <returns>Not null.</returns>
	//public static IEnumerable<Diagnostic> GetErrors(this SyntaxToken t) {
	//	if (!t.ContainsDiagnostics) return Array.Empty<Diagnostic>();
	//	return t.GetDiagnostics().Where(static o => o.Severity is DiagnosticSeverity.Error);
	//}
	
	/// <summary>
	/// Returns true if this token is a string, and the closing quote(s) is missing (contains diagnostics error).
	/// </summary>
	public static bool NoClosingQuote(this SyntaxNode t) //fast
		=> t.ContainsDiagnostics && t.GetDiagnostics().Any(o => o.Code is 1010 or 1039 or 8997);
	//Newline in constant, Unterminated string literal, Unterminated raw string literal.
	//note: SyntaxToken may contain the same diagnostics too, but not always, eg no if $$"""""". Same speed.
	
	public static void Deconstruct(this TextSpan t, out int Start, out int End) { Start = t.Start; End = t.End; }
	
	public static Range ToRange(this TextSpan t) => t.Start..t.End;
	
	/// <summary>
	/// <c>position &gt; t.Start &amp;&amp; position &lt; t.End;</c>
	/// </summary>
	public static bool ContainsInside(this TextSpan t, int position) => position > t.Start && position < t.End;
	
	/// <summary>
	/// <c>position &gt;= t.Start &amp;&amp; position &lt;= t.End;</c>
	/// </summary>
	public static bool ContainsOrTouches(this TextSpan t, int position) => position >= t.Start && position <= t.End;
	
	/// <summary>
	/// Finds child trivia of this token. Returns default if <i>position</i> is not in child trivia of this token. Does not descend into structured trivia.
	/// The code is from Roslyn source function FindTriviaByOffset. Roslyn has function to find trivia in SyntaxNode (recursive), but not in SyntaxToken.
	/// </summary>
	/// <param name="t"></param>
	/// <param name="position">Position in whole code.</param>
	public static SyntaxTrivia FindTrivia(in this SyntaxToken t, int position) {
		int textOffset = position - t.Position;
		if (textOffset >= 0) {
			var leading = t.LeadingWidth;
			if (textOffset < leading) {
				foreach (var trivia in t.LeadingTrivia) {
					if (textOffset < trivia.FullWidth) return trivia;
					textOffset -= trivia.FullWidth;
				}
			} else if (textOffset >= leading + t.Width) {
				textOffset -= leading + t.Width;
				foreach (var trivia in t.TrailingTrivia) {
					if (textOffset < trivia.FullWidth) return trivia;
					textOffset -= trivia.FullWidth;
				}
			}
		}
		return default;
	}
	
	/// <summary>
	/// Finds token at <i>position</i>. Returns true if its span contains or touches <i>position</i>.
	/// May return previous token in some cases, eg if the found token is EndOfFileToken.
	/// </summary>
	public static bool FindTouchingToken(this SyntaxNode t, out SyntaxToken token, int position, bool findInsideTrivia = false) {
		token = t.FindToken(position, findInsideTrivia);
		if (!token.IsKind(SyntaxKind.EndOfFileToken) && token.Span.ContainsOrTouches(position)) return true;
		token = token.GetPreviousToken();
		if (token.Span.End == position) return true;
		token = default;
		return false;
	}
	
	/// <summary>
	/// Gets full span, not including leading trivia that is not comments/doccomments touching the declaration.
	/// </summary>
	/// <param name="minimalLeadingTrivia">Get leading trivia just until the first newline when searching backwards. Usually it is indent whitespace or nothing.</param>
	/// <param name="spanEnd">Get <c>Span.End</c> instead of <c>FullSpan.End</c>.</param>
	public static TextSpan GetRealFullSpan(this SyntaxNode t, bool minimalLeadingTrivia = false, bool spanEnd = false) {
		int from = t.SpanStart;
		var a = t.GetLeadingTrivia();
		for (int i = a.Count; --i >= 0;) {
			var v = a[i];
			var k = v.Kind();
			if (k == SyntaxKind.EndOfLineTrivia) {
				if (i == 0 || minimalLeadingTrivia) break;
				k = a[i - 1].Kind();
				if (k == SyntaxKind.EndOfLineTrivia) break;
				if (k == SyntaxKind.WhitespaceTrivia) if (i == 1 || a[i - 2].IsKind(SyntaxKind.EndOfLineTrivia)) break;
			} else if (k is SyntaxKind.SingleLineDocumentationCommentTrivia or SyntaxKind.MultiLineDocumentationCommentTrivia) {
				from = v.FullSpan.Start; //SpanStart does not include /// or /**
				continue;
			} else {
				if (k is not (SyntaxKind.WhitespaceTrivia or SyntaxKind.SingleLineCommentTrivia or SyntaxKind.MultiLineCommentTrivia)) break;
			}
			from = v.SpanStart;
		}
		return TextSpan.FromBounds(from, spanEnd ? t.Span.End : t.FullSpan.End);
	}
	
	/// <summary>
	/// Gets the first ancestor-or-this that is a statement or member/accessor declaration or using directive etc.
	/// </summary>
	/// <param name="t"></param>
	/// <param name="pos">See remarks.</param>
	/// <param name="notAccessor">Don't need <b>AccessorDeclarationSyntax</b> (get the property etc declaration).</param>
	/// <returns>null if the initial node is <b>CompilationUnitSyntax</b>, eg <i>pos</i> is at the end of file.</returns>
	/// <remarks>
	/// If the statement is `{ }` owned by another statement (eg `if`, but not `{ }`) or member/accessor declaration, gets the owner if <i>pos</i> is not inside `{ }`.
	/// If that owner is `{ }` in an expression (eg lambda), returns the ancestor statement.
	/// </remarks>
	public static SyntaxNode GetStatementEtc(this SyntaxNode t, int pos, bool notAccessor = false) {
		g1:
		var n = t.FirstAncestorOrSelf<SyntaxNode>(notAccessor ? static o => o is StatementSyntax or MemberDeclarationSyntax : static o => o is StatementSyntax or MemberDeclarationSyntax or AccessorDeclarationSyntax);
		if (n == null) {
			n = t.FirstAncestorOrSelf<SyntaxNode>(static o => o.Parent is CompilationUnitSyntax); //using directive etc
		} else if (n is BlockSyntax) {
			var p = n.Parent;
			if (!(p is BlockSyntax or GlobalStatementSyntax) && !n.Span.ContainsInside(pos)) {
				if (!(p is StatementSyntax or MemberDeclarationSyntax)) { t = p; goto g1; }
				n = p;
			}
		}
		return n;
	}
	
	public static IEnumerable<SyntaxNode> PreviousSiblings(this SyntaxNode t, bool andThis = false) {
		if (t.Parent is { } pa) {
			if (pa is GlobalStatementSyntax) pa = (t = pa).Parent;
			bool found = false;
			foreach (var v in pa.ChildNodesAndTokens().Reverse()) {
				if (v.AsNode(out var n)) {
					if (!found) {
						if (n != t) continue;
						found = true;
						if (!andThis) continue;
					}
					yield return n is GlobalStatementSyntax g ? g.Statement : n;
				}
			}
		}
	}
	
	public static bool Eq(this string t, TextSpan span, string s, bool ignoreCase = false)
		=> t.Eq(span.Start..span.End, s, ignoreCase);
	
	/// <summary>
	/// SyntaxFacts.IsNewLine(t[i]);
	/// </summary>
	public static bool IsCsNewlineChar(this string t, int i)
		=> SyntaxFacts.IsNewLine(t[i]);
	
	/// <summary>
	/// i == 0 || SyntaxFacts.IsNewLine(t[i - 1]);
	/// </summary>
	public static bool IsCsStartOfLine(this string t, int i)
		=> i == 0 || SyntaxFacts.IsNewLine(t[i - 1]);
	
	/// <summary>
	/// i == t.Length || SyntaxFacts.IsNewLine(t[i]);
	/// </summary>
	public static bool IsCsEndOfLine(this string t, int i)
		=> i == t.Length || SyntaxFacts.IsNewLine(t[i]);
	
	[Conditional("DEBUG")]
	public static void DebugPrint(this CompletionItem t, string color = "blue") {
		print.it($"<><c {color}>{t.DisplayText},    {string.Join("|", t.Tags)},    prefix={t.DisplayTextPrefix},    suffix={t.DisplayTextSuffix},    filter={t.FilterText},    sort={t.SortText},    inline={t.InlineDescription},    automation={t.AutomationText},    provider={t.ProviderName}<>");
		print.it(string.Join("\n", t.Properties));
	}
	
	[Conditional("DEBUG")]
	public static void DebugPrintIf(this CompletionItem t, bool condition, string color = "blue") {
		if (condition) DebugPrint(t, color);
	}
	
	/// <summary>
	/// Gets symbol name as single word good for displaying etc.
	/// Known cases when the return value != <b>Name</b>:
	/// ".ctor" -> "TypeName".
	/// "Finalize" -> "~TypeName".
	/// "QualifiedInterface.Explicit" -> "Explicit".
	/// </summary>
	public static string JustName(this ISymbol t) {
		var s = t.Name;
		if (SyntaxFacts.IsValidIdentifier(s) && !t.IsDestructor()) return s;
		return t.ToDisplayString(SymbolDisplayFormat.ShortFormat);
	}
	
	public static string QualifiedName(this ISymbol t, bool onlyNamespace = false, bool noDirectName = false) {
		var g = t_qnStack ??= new Stack<string>();
		g.Clear();
		if (noDirectName) t = t.ContainingType ?? t.ContainingNamespace as ISymbol;
		if (!onlyNamespace) for (var k = t; k != null; k = k.ContainingType) g.Push(k.Name);
		for (var n = t.ContainingNamespace; n != null && !n.IsGlobalNamespace; n = n.ContainingNamespace) g.Push(n.Name);
		return string.Join(".", g);
	}
	[ThreadStatic] static Stack<string> t_qnStack;
	
	/// <summary>
	/// Cached, thread-safe.
	/// </summary>
	public static string QualifiedNameCached(this INamespaceSymbol t) { //only 2 times faster than QualifiedName, but no garbage. Same speed with Dictionary.
		//if (t.IsGlobalNamespace || t.ContainingNamespace.IsGlobalNamespace) return t.Name; //same speed. Few such namespaces.
		if (!_namespaceNames.TryGetValue(t, out var s)) {
			s = t.QualifiedName();
			_namespaceNames.AddOrUpdate(t, s); //OrUpdate for thread safety
			//print.it(s);
		}
		return s;
	}
	static ConditionalWeakTable<INamespaceSymbol, string> _namespaceNames = new();
	
	/// <summary>
	/// Like <b>GetEnclosingNamedType</b>, but <i>pos</i> can be anywhere in the class/struct/interface/enum definition span, not just in { }.
	/// </summary>
	public static INamedTypeSymbol GetEnclosingNamedType2(this SemanticModel t, int pos, out SyntaxNode posNode, out BaseTypeDeclarationSyntax declNode) {
		posNode = t.Root.FindToken(pos).Parent;
		declNode = posNode?.GetAncestorOrThis<BaseTypeDeclarationSyntax>();
		if (declNode == null || !declNode.Span.Contains(pos) || declNode.CloseBraceToken.IsMissing) return null;
		return t.GetEnclosingNamedType(declNode.OpenBraceToken.SpanStart + 1, default);
	}
	
	/// <summary>
	/// If the file code contains usings, externs, attributes or #define directives, returns position after all them. Else 0.
	/// </summary>
	public static int GetHeaderLength(this CompilationUnitSyntax t) {
		var last = t.AttributeLists.LastOrDefault() as SyntaxNode
			?? t.Usings.LastOrDefault() as SyntaxNode
			?? t.Externs.LastOrDefault() as SyntaxNode
			?? t.GetDirectives(o => o is DefineDirectiveTriviaSyntax).LastOrDefault();
		if (last == null) return 0;
		return last.FullSpan.End;
	}
	
	public static (string kind, string access) ImageResource(this ISymbol t) {
		var glyph = t.GetGlyph();
		return glyph switch {
			Glyph.ClassPublic => ("resources/ci/class.xaml", null),
			Glyph.ClassInternal => ("resources/ci/class.xaml", "resources/ci/overlayinternal.xaml"),
			Glyph.ClassPrivate => ("resources/ci/class.xaml", "resources/ci/overlayprivate.xaml"),
			Glyph.ClassProtected => ("resources/ci/class.xaml", "resources/ci/overlayprotected.xaml"),
			
			Glyph.ConstantPublic => ("resources/ci/constant.xaml", null),
			Glyph.ConstantInternal => ("resources/ci/constant.xaml", "resources/ci/overlayinternal.xaml"),
			Glyph.ConstantPrivate => ("resources/ci/constant.xaml", "resources/ci/overlayprivate.xaml"),
			Glyph.ConstantProtected => ("resources/ci/constant.xaml", "resources/ci/overlayprotected.xaml"),
			
			Glyph.DelegatePublic => ("resources/ci/delegate.xaml", null),
			Glyph.DelegateInternal => ("resources/ci/delegate.xaml", "resources/ci/overlayinternal.xaml"),
			Glyph.DelegatePrivate => ("resources/ci/delegate.xaml", "resources/ci/overlayprivate.xaml"),
			Glyph.DelegateProtected => ("resources/ci/delegate.xaml", "resources/ci/overlayprotected.xaml"),
			
			Glyph.EnumPublic => ("resources/ci/enum.xaml", null),
			Glyph.EnumInternal => ("resources/ci/enum.xaml", "resources/ci/overlayinternal.xaml"),
			Glyph.EnumPrivate => ("resources/ci/enum.xaml", "resources/ci/overlayprivate.xaml"),
			Glyph.EnumProtected => ("resources/ci/enum.xaml", "resources/ci/overlayprotected.xaml"),
			
			Glyph.EnumMemberPublic => ("resources/ci/enummember.xaml", null),
			Glyph.EnumMemberInternal => ("resources/ci/enummember.xaml", "resources/ci/overlayinternal.xaml"), //?
			Glyph.EnumMemberPrivate => ("resources/ci/enummember.xaml", "resources/ci/overlayprivate.xaml"),
			Glyph.EnumMemberProtected => ("resources/ci/enummember.xaml", "resources/ci/overlayprotected.xaml"),
			
			Glyph.EventPublic => ("resources/ci/event.xaml", null),
			Glyph.EventInternal => ("resources/ci/event.xaml", "resources/ci/overlayinternal.xaml"),
			Glyph.EventPrivate => ("resources/ci/event.xaml", "resources/ci/overlayprivate.xaml"),
			Glyph.EventProtected => ("resources/ci/event.xaml", "resources/ci/overlayprotected.xaml"),
			
			Glyph.ExtensionMethodPublic => ("resources/ci/extensionmethod.xaml", null),
			Glyph.ExtensionMethodInternal => ("resources/ci/extensionmethod.xaml", "resources/ci/overlayinternal.xaml"),
			Glyph.ExtensionMethodPrivate => ("resources/ci/extensionmethod.xaml", "resources/ci/overlayprivate.xaml"),
			Glyph.ExtensionMethodProtected => ("resources/ci/extensionmethod.xaml", "resources/ci/overlayprotected.xaml"),
			
			Glyph.FieldPublic => ("resources/ci/field.xaml", null),
			Glyph.FieldInternal => ("resources/ci/field.xaml", "resources/ci/overlayinternal.xaml"),
			Glyph.FieldPrivate => ("resources/ci/field.xaml", "resources/ci/overlayprivate.xaml"),
			Glyph.FieldProtected => ("resources/ci/field.xaml", "resources/ci/overlayprotected.xaml"),
			
			Glyph.InterfacePublic => ("resources/ci/interface.xaml", null),
			Glyph.InterfaceInternal => ("resources/ci/interface.xaml", "resources/ci/overlayinternal.xaml"),
			Glyph.InterfacePrivate => ("resources/ci/interface.xaml", "resources/ci/overlayprivate.xaml"),
			Glyph.InterfaceProtected => ("resources/ci/interface.xaml", "resources/ci/overlayprotected.xaml"),
			
			Glyph.MethodPublic => ("resources/ci/method.xaml", null),
			Glyph.MethodInternal => ("resources/ci/method.xaml", "resources/ci/overlayinternal.xaml"),
			Glyph.MethodPrivate => ("resources/ci/method.xaml", "resources/ci/overlayprivate.xaml"),
			Glyph.MethodProtected => ("resources/ci/method.xaml", "resources/ci/overlayprotected.xaml"),
			
			Glyph.OperatorPublic => ("resources/ci/operator.xaml", null),
			Glyph.OperatorInternal => ("resources/ci/operator.xaml", "resources/ci/overlayinternal.xaml"),
			Glyph.OperatorPrivate => ("resources/ci/operator.xaml", "resources/ci/overlayprivate.xaml"),
			Glyph.OperatorProtected => ("resources/ci/operator.xaml", "resources/ci/overlayprotected.xaml"),

			Glyph.PropertyPublic => ("resources/ci/property.xaml", null),
			Glyph.PropertyInternal => ("resources/ci/property.xaml", "resources/ci/overlayinternal.xaml"),
			Glyph.PropertyPrivate => ("resources/ci/property.xaml", "resources/ci/overlayprivate.xaml"),
			Glyph.PropertyProtected => ("resources/ci/property.xaml", "resources/ci/overlayprotected.xaml"),
			
			Glyph.StructurePublic => ("resources/ci/structure.xaml", null),
			Glyph.StructureInternal => ("resources/ci/structure.xaml", "resources/ci/overlayinternal.xaml"),
			Glyph.StructurePrivate => ("resources/ci/structure.xaml", "resources/ci/overlayprivate.xaml"),
			Glyph.StructureProtected => ("resources/ci/structure.xaml", "resources/ci/overlayprotected.xaml"),
			
			Glyph.Keyword => ("resources/ci/keyword.xaml", null), //implicit 'value' parameter in a property etc
			Glyph.Label => ("resources/ci/label.xaml", null),
			Glyph.Local or Glyph.Parameter or Glyph.RangeVariable => ("resources/ci/localvariable.xaml", null),
			Glyph.Namespace => ("resources/ci/namespace.xaml", null),
			Glyph.TypeParameter => ("resources/ci/typeparameter.xaml", null),
			_ => default
		};
	}
	
	/// <summary>
	/// Appends n tabs or n*4 spaces, depending on <b>App.Settings.ci_formatTabIndent</b>.
	/// </summary>
	public static StringBuilder AppendIndent(this StringBuilder t, int n) {
		if (App.Settings.ci_formatTabIndent) t.Append('\t', n);
		else t.Append(' ', n * 4);
		return t;
	}
	
	/// <summary>
	/// Appends C# code <i>s</i> to <i>b</i>.
	/// For each line adds <i>indent</i> tabs, except in multiline @"string" or """string""" (same for u8).
	/// Ignores the last empty line of <i>s</i>. Appends newline at the end if <b>andNewline</b>.
	/// </summary>
	public static void AppendCodeWithIndent(this StringBuilder t, string s, int indent, bool andNewline) {
		if (indent > 0) {
			var cu = CSharpSyntaxTree.ParseText(s, new CSharpParseOptions(LanguageVersion.Preview)).GetCompilationUnitRoot();
			var a = s.Lines(..); int i = 0;
			foreach (var v in a) {
				bool canIndent = true;
				if (s[v.start] == '#' && cu.FindTrivia(v.start).IsDirective) canIndent = false;
				else {
					var tok = cu.FindToken(v.start);
					canIndent = tok.IsInString(v.start, s, out _, orU8: true) == false;
				}
				if (canIndent) t.AppendIndent(indent);
				t.Append(s, v.start, v.Length);
				if (++i < a.Length || andNewline) t.AppendLine();
			}
		} else {
			t.Append(s);
			if (!s.Ends('\n')) t.AppendLine();
		}
	}
}

record struct CiStringInfo {
	/// <summary>
	/// The text part of string literal or a text part of interpolated string. Without enclosing and prefix.
	/// </summary>
	public TextSpan textSpan;
	
	/// <summary>
	/// Entire string node. Can be either <b>LiteralExpressionSyntax</b> or <b>InterpolatedStringExpressionSyntax</b>.
	/// </summary>
	public SyntaxNode stringNode;
	
	public bool isVerbatim, isRaw, isInterpolated, isU8;
	
	/// <summary>
	/// Not verbatim/raw. Can be "...", $"..." or "..."u8.
	/// </summary>
	public bool isClassic;
	
	/// <summary>
	/// At """|""".
	/// </summary>
	public bool isRawPrefixCenter;
	
	/// <summary>
	/// In multiline raw string. Valid when returns true, but can be <c>true</c> regardless of the return value.
	/// </summary>
	public bool isRawMultiline;
	
	/// <summary>
	/// In multiline raw string after """ but before the start of next line. Can be <c>true</c> only if returned null.
	/// </summary>
	public bool isRawMultilineBetweenStartQuotesAndText;
}

================================================
FILE: Au.Editor/Edit/CiWinapi.cs
================================================
extern alias CAW;

using Au.Controls;

using Microsoft.CodeAnalysis;
using CAW::Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Text;
using Microsoft.CodeAnalysis.Shared.Extensions;
using CAW::Microsoft.CodeAnalysis.Shared.Extensions;

namespace LA;

class CiWinapi {
	int _typenameStart;
	bool _canInsert;
	static string s_tempFile;
	
	public static bool IsWinapiClassSymbol(INamedTypeSymbol typeSym) => typeSym?.BaseType?.Name == "NativeApi";
	
	public static CiWinapi AddWinapi(INamedTypeSymbol typeSym, List<CiComplItem> items, int typenameStart, bool onlyTypes) {
		Debug.Assert(IsWinapiClassSymbol(typeSym));
		
		//At first read from database and write to a temp binary file. Reading from it is ~2 times faster than from database.
		if (s_tempFile == null || !filesystem.GetTime_(s_tempFile, out var t1) || !filesystem.GetTime_(EdDatabases.WinapiFile, out var t2) || t2 > t1) {
			s_tempFile = folders.ThisAppTemp + "winapi.bin";
			using var w = new BinaryWriter(File.Create(s_tempFile));
			using var db = EdDatabases.OpenWinapi();
			using var stat = db.Statement("SELECT name, kind FROM api");
			while (stat.Step()) {
				w.Write((byte)stat.GetInt(1));
				w.Write(stat.GetText(0));
			}
			//note: don't use this FileStream for reading. Works but very slow.
		}
		
		var fs = filesystem.loadStream(s_tempFile);
		int cap = (int)(fs.Length / 22); if (onlyTypes) cap /= 8;
		items.Capacity = items.Count + cap;
		using var r = new BinaryReader(fs);
		while (fs.Position < fs.Length) {
			var kind = (CiItemKind)r.ReadByte();
			if (onlyTypes && (int)kind > 4) break; //sorted by kind, types first
			var name = r.ReadString();
			var ci = new CiComplItem(CiComplProvider.Winapi, name, kind/*, CiItemAccess.Internal*/);
			items.Add(ci);
		}
		
		return new() { _typenameStart = typenameStart, _canInsert = typeSym.IsFromSource() };
	}
	
	public static System.Windows.Documents.Section GetDescription(CiComplItem item) {
		var m = new CiText();
		m.StartParagraph();
		m.Append(item.kind.ToString() + " "); m.Bold(item.Text); m.Append(".");
		m.EndParagraph();
		if (_GetText(item, out string s)) m.CodeBlock(s);
		return m.Result;
	}
	
	static bool _GetText(CiComplItem item, out string text) {
		using var db = EdDatabases.OpenWinapi();
		return db.Get(out text, $"SELECT code FROM api WHERE name='{item.Text}'");
	}
	
	public void OnCommitInsertDeclaration(CiComplItem item) {
		if (!_GetText(item, out string text)) return;
		if (_InsertDeclaration(item, text)) return;
		clipboard.text = text;
		print.it("<>Clipboard:\r\n<code>" + text + "</code>");
	}
	
	bool _InsertDeclaration(CiComplItem item, string text) {
		if (!_canInsert) return false;
		if (!CodeInfo.GetDocumentAndFindNode(out var cd, out var typenameNode, _typenameStart)) return false;
		var semo = cd.semanticModel;
		var sym = semo.GetSymbolInfo(typenameNode).Symbol;
		if (sym is not INamedTypeSymbol t || !t.IsFromSource()) return false;
		var sr = t.DeclaringSyntaxReferences[0];
		
		SciCode doc = cd.sci;
		FileNode fSelect = null;
		if (sr.SyntaxTree != semo.SyntaxTree) {
			var f = App.Model.Find(sr.SyntaxTree.FilePath, FNFind.CodeFile);
			if (!App.Model.SetCurrentFile(f, dontChangeTreeSelection: true)) return false;
			doc = Panels.Editor.ActiveDoc;
			fSelect = cd.sci.EFile;
		}
		
		var hs = new HashSet<string>();
		using (doc.ENewUndoAction()) {
			_Insert(0, sr.GetSyntax(), text, item.Text, item.kind);
		}
		
		if (fSelect != null) App.Model.SetCurrentFile(fSelect);
		return true;
		
		void _Insert(int level, SyntaxNode node, string text, string name, CiItemKind kind) {
			if (node is not ClassDeclarationSyntax nodeCD) return;
			int posClass = nodeCD.Keyword.SpanStart, posInsert = nodeCD.CloseBraceToken.SpanStart;
			string emptyLine = "\r\n";
			
			//if constant, try to insert below the last existing constant with same prefix
			if (kind == CiItemKind.Constant) {
				int u = name.IndexOf('_') + 1;
				if (u > 1) {
					string prefix = " " + name[..u], code = doc.aaaText;
					foreach (var v in nodeCD.ChildNodes().OfType<FieldDeclarationSyntax>()) {
						var span = v.Span;
						int j = code.Find(prefix, span.Start..span.End);
						if (j > 0 && code.Find("const ", span.Start..j) > 0) {
							posInsert = v.FullSpan.End;
							emptyLine = null;
							//break; //no, need the last
						} else if (emptyLine == null) break;
					}
				}
			}
			
			//if (level == 0) { //insert missing usings first. Now in global.cs. Or CiErrors will add.
			//	int len = doc.aaaLen16;
			//	InsertCode.UsingDirective("Au;Au.Types;System;System.Runtime.InteropServices"); //Au: wnd; Au.Types: RECT etc; System: IntPtr, Guid etc
			//	int add = doc.aaaLen16 - len;
			//	posInsert += add; posClass += add;
			//}
			
			text = emptyLine + text + "\r\n";
			doc.aaaInsertText(true, posInsert, text, addUndoPointAfter: true, restoreFolding: true);
			
			//recursively add declarations for unknown names found in now added declaration
			if (kind is CiItemKind.Constant or CiItemKind.Field or CiItemKind.Enum or CiItemKind.Class) return;
			//print.it(level, name);
			if (level > 30) return; //max seen 10. Tested: at level 10 uses ~40 KB of stack.
			if (!CodeInfo.GetDocumentAndFindNode(out var cd, out node, posClass)) return;
			if (node is not ClassDeclarationSyntax) return;
			var semo = cd.semanticModel;
			var newSpan = new TextSpan(posInsert, text.Length);
			var da = semo.GetDiagnostics(newSpan); //the slowest part
			foreach (var d in da) {
				var ec = (ErrorCode)d.Code;
				if (ec
					is ErrorCode.ERR_SingleTypeNameNotFound
					or ErrorCode.ERR_NameNotInContext //never seen
					or ErrorCode.ERR_BadAccess //eg "'VARIANT' is inaccessible due to its protection level", because defined as internal in some assembly
					) {
					var loc = d.Location;
					if (!loc.IsInSource) {
						Debug_.Print("!insource");
						continue;
					}
					var span = loc.SourceSpan;
					if (!newSpan.Contains(span)) {
						Debug_.Print("!contains");
						continue;
					}
					name = cd.code[span.Start..span.End];
					//print.it(name);
					
					if (!hs.Add(name)) { //same name again
						//print.it("same", name);
						continue;
					}
					
					//some parameter types add much garbage, but the parameters are rarely used.
					//	If parameter, it is usually null. If interface member parameter, the member is rarely used.
					//	Let's add empty definition. It's easy to replace it with full definition when need.
					if (name == "IBindCtx") {
						text = """
[ComImport, Guid("0000000e-0000-0000-C000-000000000046"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
internal interface IBindCtx {}
""";
						kind = CiItemKind.Interface;
					} else if (name == "PROPVARIANT") {
						text = "internal struct PROPVARIANT { int a, b; nint c, d; }";
						kind = CiItemKind.Structure;
					} else {
						using var db = EdDatabases.OpenWinapi(); //fast, if compared with GetDiagnostics
						using var stat = db.Statement("SELECT code, kind FROM api WHERE name=?", name);
						if (!stat.Step()) {
							Debug_.Print("not in DB: " + name);
							continue;
						}
						text = stat.GetText(0);
						kind = (CiItemKind)stat.GetInt(1);
						//print.it(kind, text);
					}
					
					_Insert(level + 1, node, text, name, kind);
				} else {
					if (ec == ErrorCode.ERR_ManagedAddr) continue; //possibly same name is an internal managed type in some assembly, but in our DB it may be unmanaged. This error is for for field; we'll catch its type later.
					if (ec == ErrorCode.WRN_NewNotRequired) continue; //when 'new' used with a repeated member of a base interface, the base is still not declared, therefore this warning
					Debug_.Print(d);
				}
			}
		}
	}
}


================================================
FILE: Au.Editor/Edit/CiWorkspace.cs
================================================
extern alias CAW;

using Microsoft.CodeAnalysis;
using CAW::Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Text;
using Microsoft.CodeAnalysis.Shared.Extensions;
using CAW::Microsoft.CodeAnalysis.Shared.Extensions;
using Microsoft.CodeAnalysis.CSharp.Extensions;


namespace LA;

/// <summary>
/// Ctor creates new <b>AdhocWorkspace</b> (<see cref="Workspace"/>) and adds projects and documents.
/// Dtor disposes the <b>AdhocWorkspace</b>. Must be disposed soon.
/// </summary>
class CiWorkspace : IDisposable {
	public AdhocWorkspace Workspace { get; }
	
	/// <summary>
	/// <c>=> Workspace.CurrentSolution</c>
	/// </summary>
	public Solution Solution => Workspace.CurrentSolution;
	
	/// <summary>
	/// <b>MetaComments</b> of the main project.
	/// </summary>
	public MetaComments Meta { get; }
	
	/// <summary>
	/// Files etc of the main project (the first) and pr projects.
	/// </summary>
	public ProjectData[] Projects { get; }
	
	/// <summary>
	/// Gets <b>Compilation</b> of the main project: <c>=> Solution.GetProject(Projects[0].projectId).GetCompilationAsync().Result</c>
	/// </summary>
	public Compilation GetCompilation() => Solution.GetProject(Projects[0].projectId).GetCompilationAsync().Result_();
	
	/// <summary>
	/// <b>DocumentId</b> of <i>fn</i>, or null.
	/// Searches only in the main project.
	/// </summary>
	public DocumentId GetDocId(FileNode fn) {
		foreach (var v in Projects[0].files) if (v.f.f == fn) return v.docId;
		return null;
	}
	
	public CiWorkspace(FileNode fn, Caller caller) {
		Workspace = new();
		List<ProjectData> projects = new();
		
		bool inEditor = caller is Caller.CodeInfoNormal or Caller.CodeInfoWpfPreview;
		
		if (!fn.FindProject(out var projFolder, out var projMain)) projMain = fn;
		Debug.Assert(projMain.IsCodeFile);
		
		if (inEditor) TestInternal.CiClear();
		
		List<ProjectInfo> aPI = new();
		Dictionary<FileNode, ProjectReference> dPR = null;
		var mcFlags = caller switch {
			Caller.CodeInfoNormal => MCFlags.ForCodeInfoInEditor,
			Caller.CodeInfoWpfPreview => MCFlags.ForCodeInfoInEditor | MCFlags.WpfPreview,
			_ => MCFlags.ForCodeInfo
		};
		(_, Meta) = _AddProject(projMain, projFolder, mcFlags);
		Workspace.AddProjects(aPI);
		Projects = projects.ToArray();
		
		(ProjectId pid, MetaComments meta) _AddProject(FileNode projMain, FileNode projFolder, MCFlags mcFlags) {
			var m = new MetaComments(mcFlags);
			m.Parse(projMain, projFolder);
			
			if (inEditor && m.TestInternal is string[] testInternal) TestInternal.CiAdd(m.Name, testInternal);
			
			var projectId = ProjectId.CreateNewId();
			
			ProjectData pd = new(m, projectId, new());
			projects.Add(pd);
			
			if (inEditor) CiProjects.AttachFileOf(projectId, projMain);
			var adi = new List<DocumentInfo>();
			foreach (var k in m.CodeFiles) {
				var docId = DocumentId.CreateNewId(projectId);
				var tav = TextAndVersion.Create(SourceText.From(k.code, Encoding.UTF8), VersionStamp.Default, k.f.FilePath);
				adi.Add(DocumentInfo.Create(docId, k.f.Name, null, SourceCodeKind.Regular, TextLoader.From(tav), k.f.ItemPath));
				if (inEditor) CiProjects.AttachFileOf(docId, k.f);
				pd.files.Add((k, docId));
			}
			//TODO3: reuse document+syntaxtree of global.cs and its meta c files if their text not changed.
			
			int iPI = aPI.Count; aPI.Add(null); //let this project be before pr projects in aPI
			
			List<ProjectReference> aPR = null;
			if (caller != Caller.Other && m.ProjectReferences is { } a1) {
				dPR ??= new();
				foreach (var v in a1) {
					if (!dPR.TryGetValue(v.f, out var pr)) {
						pr = new ProjectReference(_AddProject(v.f, v.f.Parent, mcFlags & ~MCFlags.WpfPreview).pid);
						dPR.Add(v.f, pr);
					}
					(aPR ??= new()).Add(pr);
				}
			}
			
			aPI[iPI] = ProjectInfo.Create(projectId, VersionStamp.Default, m.Name, m.Name, LanguageNames.CSharp, null, null,
				m.CreateCompilationOptions(),
				m.CreateParseOptions(),
				adi,
				aPR,
				m.References.Refs);
			
			return (projectId, m);
		}
	}
	
	public void Dispose() {
		Workspace.Dispose();
	}
	
	public enum Caller {
		/// <summary>Called by <b>CodeInfo</b>. Supports meta testInternal, <see cref="CiProjects.FileOf"/>.</summary>
		CodeInfoNormal,
		
		/// <summary><b>CodeInfoNormal</b> + <see cref="MCFlags.WpfPreview"/>.</summary>
		CodeInfoWpfPreview,
		
		/// <summary>Add project references (meta pr).</summary>
		OtherPR,
		
		/// <summary>Don't add project references (meta pr).</summary>
		Other
	}
	
	public record struct ProjectData(MetaComments meta, ProjectId projectId, List<(MCCodeFile f, DocumentId docId)> files);
}


================================================
FILE: Au.Editor/Edit/CodeExporter.cs
================================================
extern alias CAW;

using Microsoft.CodeAnalysis;
using CAW::Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Text;
using Microsoft.CodeAnalysis.Classification;
using CAW::Microsoft.CodeAnalysis.Classification;
using static LA.SciTheme;

namespace LA;

static class CodeExporter {
	public static EStyle[] GetStyles(string s) {
		using var ws = new AdhocWorkspace();
		var document = CiUtil.CreateDocumentFromCode(ws, s, needSemantic: true);
		//var semo = document.GetSemanticModelAsync().Result;
		
		var a = new EStyle[s.Length];
		int prevEnd = 0; EStyle prevStyle = 0;
		foreach (var v in CiUtil.GetClassifiedSpansAsync(document, 0, s.Length).Result_()) {
			EStyle style = CiStyling.StyleFromClassifiedSpan(v);
			int start = v.TextSpan.Start, end = v.TextSpan.End;
			//print.it(style, s[start..end]);
			if (style == prevStyle && start > prevEnd && a[prevEnd] == 0) start = prevEnd; //join adjacent styles separated by whitespace
			prevEnd = end; prevStyle = style;
			a.AsSpan(start..end).Fill(style);
		}
		
		return a;
	}
	
	public static string ExportForum(string s) {
		var a = GetStyles(s);
		var b = new StringBuilder();
		EStyle prevStyle = 0;
		for (int i = 0; i < a.Length; i++) {
			var style = a[i];
			if (style != prevStyle) {
				if (prevStyle != 0) b.Append("(`)");
				if (style != 0) b.Append("(`").Append(_StyleToString(style)).Append(")");
				prevStyle = style;
			}
			b.Append(s[i]);
		}
		if (prevStyle != 0) b.Append("(`)");
		return b.ToString();
	}
	
	public static string ExportHtml(string s, bool spanClass, bool withCss = false) {
		var a = GetStyles(s);
		StringWriter t = new();
		if (withCss) t.Write("<style>\r\n{0}</style>\r\n", ExportCss());
		t.Write("<pre");
		if (spanClass) t.Write(" class='au'");
		if (!spanClass || withCss) t.Write(" style='{0}'", c_preStyle);
		t.Write(">\r\n");
		EStyle prevStyle = 0;
		int i = 0, ip = 0;
		for (; i < a.Length; i++) {
			var style = a[i];
			if (style != prevStyle) {
				_AppendText();
				if (style != 0) {
					if (spanClass) {
						t.Write("<span class='");
						t.Write(_StyleToString(style));
					} else {
						var k = _StyleToStruct(style);
						t.Write("<span style='color:#{0:X6}", k.color);
						if (k.bold) t.Write(";font-weight: bold");
						//we use default styles, and there are no styles with italic or underline
						//if (k.italic) t.Write(";font-style: italic");
						//if (k.underline) t.Write(";text-decoration: underline");
					}
					t.Write("'>");
				}
				prevStyle = style;
			}
		}
		_AppendText();
		
		void _AppendText() {
			if (i > ip) { System.Net.WebUtility.HtmlEncode(s[ip..i], t); ip = i; }
			if (prevStyle != 0) t.Write("</span>");
		}
		
		t.Write("</pre>\r\n");
		return t.ToString();
	}
	
	const string c_preStyle = "background-color:#FFFFFF;border:#D1D7DC;border-style:solid;border-width:1px;padding-left:2px;line-height:normal;color:black;tab-size:4;font-family:\"Consolas\";";
	
	public static string ExportCss() {
		var b = new StringBuilder();
		b.Append("pre.au {").Append(c_preStyle).AppendLine("}");
		
		_Style(EStyle.Comment);
		_Style(EStyle.Constant);
		_Style(EStyle.Excluded);
		_Style(EStyle.Function);
		_Style(EStyle.Keyword);
		_Style(EStyle.Label);
		_Style(EStyle.LocalVariable);
		_Style(EStyle.Namespace);
		_Style(EStyle.Number);
		_Style(EStyle.Operator);
		_Style(EStyle.Preprocessor);
		_Style(EStyle.Punctuation);
		_Style(EStyle.String);
		_Style(EStyle.StringEscape);
		_Style(EStyle.Type);
		_Style(EStyle.XmlDocTag);
		_Style(EStyle.XmlDocText);
		
		void _Style(EStyle style) {
			var k = _StyleToStruct(style);
			b.AppendFormat("pre.au .{0}{{color:#{1:X6};", _StyleToString(style), k.color);
			if (k.bold) b.Append("font-weight: bold;");
			//if (k.italic) b.Append("font-style: italic;");
			//if (k.underline) b.Append("text-decoration: underline;");
			b.Append("}");
		}
		
		return b.AppendLine().ToString();
	}
	
	static string _StyleToString(EStyle style)
		=> style switch {
			EStyle.Comment => "cm",
			EStyle.Constant => "cn",
			EStyle.Excluded => "ex",
			EStyle.Function or EStyle.Event => "fn",
			EStyle.Keyword => "kw",
			EStyle.Label => "lb",
			EStyle.LocalVariable or EStyle.Field => "vr",
			EStyle.Namespace => "ns",
			EStyle.Number => "nr",
			EStyle.Operator => "op",
			EStyle.Preprocessor => "pd",
			EStyle.Punctuation => "pn",
			EStyle.String => "st",
			EStyle.StringEscape => "se",
			EStyle.Type => "tp",
			EStyle.XmlDocTag => "xt",
			EStyle.XmlDocText => "xd",
			_ => "st" //Rx (unused)
		};
	
	static TStyle _StyleToStruct(EStyle style) => SciTheme.Default[style];
}


================================================
FILE: Au.Editor/Edit/CodeInfo.cs
================================================
extern alias CAW;

//#define NO_COMPL_CORR_SIGN

using System.Windows.Input;
using System.Windows;
using Au.Controls;

using Microsoft.CodeAnalysis;
using CAW::Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Text;
using Microsoft.CodeAnalysis.Shared.Extensions;
using CAW::Microsoft.CodeAnalysis.Shared.Extensions;
using Microsoft.CodeAnalysis.Classification;
using CAW::Microsoft.CodeAnalysis.Classification;
using Microsoft.CodeAnalysis.Completion;

namespace LA;

static class CodeInfo {
	internal static readonly CiCompletion _compl = new();
	internal static readonly CiSignature _signature = new();
	internal static readonly CiAutocorrect _correct = new();
	internal static readonly CiQuickInfo _quickInfo = new();
	internal static readonly CiStyling _styling = new();
	internal static readonly CiErrors _diag = new();
	internal static readonly CiTools _tools = new();
	internal static readonly CiProjects _projects = new();
	
	static Solution _solution;
	static ProjectId _projectId;
	static DocumentId _documentId;
	static Document _document;
	static CompilationUnitSyntax _syntaxRoot;
	//static MetaComments _meta;
	static string _metaText;
	static bool _isWarm;
	static bool _isUI;
	static RECT _sciRect;
	
	public static void UiLoaded() {
		//This code warms up Roslyn. It can take several s.
		//	During that time the window is visible (except document) but disabled.
		
		//perf.next('u');
		//don't allow users to make any changes until Roslyn loaded. It can be dangerous.
		App.Hmain.Enable(false);
		wnd[] aEnable = null;
		App.Dispatcher.InvokeAsync(() => { //disable floating panels too
			aEnable = wnd.getwnd.threadWindows(process.thisThreadId, onlyVisible: true);
			//print.it(aEnable);
			for (int i = 0; i < aEnable.Length; i++)
				if (aEnable[i].IsEnabled()) aEnable[i].Enable(false); else aEnable[i] = default;
		});
		var doc = Panels.Editor.ActiveDoc;
		if (doc != null) doc.Visibility = Visibility.Hidden; //hide document window. The black unfolded text is distracting. Does not have sense to show it.
		
		_warmupTask = Task.Run(() => {
			//using var p1 = perf.local();
			try {
				var code = @"using Au; print.it(""t"" + 1);";
				
				var refs = new MetaReferences().Refs;
				ProjectId projectId = ProjectId.CreateNewId();
				DocumentId documentId = DocumentId.CreateNewId(projectId);
				using var ws = new AdhocWorkspace();
				var sol = ws.CurrentSolution
					.AddProject(projectId, "p", "p", LanguageNames.CSharp)
					.AddMetadataReferences(projectId, refs)
					.AddDocument(documentId, "f.cs", code);
				var document = sol.GetDocument(documentId);
				//p1.Next();
				
				var semo = document.GetSemanticModelAsync().Result_();
				//p1.Next('s');
				
				//let the coloring and folding in editor start working immediately
				CiUtil.GetClassifiedSpansAsync(document, 0, code.Length).Wait();
				//p1.Next('c');
				
				App.Dispatcher.InvokeAsync(() => {
					_isWarm = true;
					ReadyForStyling?.Invoke();
					ReadyForStyling = null; //GC
					Panels.Editor.ActiveDocChanged += Stop;
					App.Timer025sWhenVisible += _Timer025sWhenVisible;
					_Finally();
				});
				//p1.Next();
				
				500.ms();
				//p1.Next();
				var compl = CompletionService.GetService(document);
				compl.GetCompletionsAsync(document, code.Find(".it") + 1); //not necessary, but without it sometimes the first completion list is too slow if the user types fast
				//p1.Next('C');
				
				Compiler.Warmup(document); //not necessary, but it's better when the first compilation is 200 ms instead of 500
				
				//EdUtil.MinimizeProcessPhysicalMemory(500); //with this later significantly slower
			}
			catch (Exception ex) {
				print.it(ex);
				App.Dispatcher.InvokeAsync(_Finally);
			}
		});
		
		void _Finally() {
			if (doc != null) doc.Visibility = Visibility.Visible;
			App.Hmain.Enable(true);
			if (aEnable != null) {
				for (int i = 0; i < aEnable.Length; i++)
					if (!aEnable[i].Is0) aEnable[i].Enable(true);
			}
			//perf.nw('R');
			_warmupTask = null;
			
			IsReadyForEditing = true;
			if (ReadyForEditing != null) {
				try { ReadyForEditing(); } catch (Exception e1) { print.it(e1); } //used in editorExtension scripts
				ReadyForEditing = null; //GC
			}
			Git.AutoBackup(true);
			
#if DEBUG
			RoslynMod.Print.PrintItCallback = o => print.it(o);
#endif
		}
	}
	
	/// <summary>
	/// Code styling and folding already can work after program starts.
	/// </summary>
	public static bool IsReadyForStyling => _isWarm;
	
	/// <summary>
	/// When code styling and folding already can work after program starts.
	/// Runs in main thread.
	/// </summary>
	public static event Action ReadyForStyling;
	
	/// <summary>
	/// Main window already enabled after program starts.
	/// </summary>
	public static bool IsReadyForEditing { get; private set; }
	
	/// <summary>
	/// When main window enabled after program starts.
	/// Runs in main thread, after <b>ReadyForStyling</b>.
	/// </summary>
	public static event Action ReadyForEditing;
	
	/// <summary>
	/// If the warmup task is still running, which means that still not ready for styling etc and should not open files, waits until the task completes.
	/// </summary>
	public static void WaitUntilReadyForStyling() {
		if (_warmupTask == null) return;
		_warmupTask.Wait();
		wait.doEvents(); //run Dispatcher.InvokeAsync(_Finally)
	}
	static Task _warmupTask;
	
	static bool _CanWork(SciCode doc) {
		if (!_isWarm) return false;
		if (doc == null) return false;
		if (!doc.EFile.IsCodeFile) return false;
		if (doc != Panels.Editor.ActiveDoc) { _Uncache(); return false; } //maybe changed an inactive file that participates in current compilation //FUTURE: what if isn't open?
		return true;
	}
	
	static void _Uncache() {
		//print.it("_Uncache");
		CurrentWorkspace?.Dispose();
		CurrentWorkspace = null;
		_solution = null;
		_projectId = null;
		_documentId = null;
		_document = null;
		_syntaxRoot = null;
		//_meta = null;
		_metaText = null;
	}
	
	public static void Stop() {
		Cancel();
		_Uncache();
	}
	
	public static void Cancel() {
		HideTextPopupAndTempWindows();
		_compl.Cancel();
		_signature.Cancel();
	}
	
	/// <summary>
	/// Similar to <see cref="FilesChanged"/>, but called when other conditions changed, eg a nuget package [un]installed.
	/// Not async, and does not fire an event.
	/// </summary>
	public static void StopAndUpdateStyling() {
		Stop();
		_styling.Update();
	}
	
	/// <summary>
	/// Called when files added, deleted, moved, copied, imported, renamed, text replaced.
	/// Eg need to update styling and diagnostics when a meta c file became [un]available or when project folder structure changed.
	/// Will update async, eg single updating for multiple calls. Will call <see cref="StopAndUpdateStyling"/> and <see cref="FilesChangedEvent"/>.
	/// </summary>
	public static void FilesChanged() {
		if (_filesChangedAsync) return; _filesChangedAsync = true;
		App.Dispatcher.InvokeAsync(() => {
			_filesChangedAsync = false;
			StopAndUpdateStyling();
			FilesChangedEvent?.Invoke();
		});
		//why async:
		//	1. Easier to consolidate multiple events.
		//	2. Easier to create files with custom text (the text is added after calling this).
		//	3. In some cases may be better/safer.
	}
	static bool _filesChangedAsync;
	
	/// <summary>
	/// When files added, deleted, moved, copied, imported, renamed, text replaced.
	/// Called through Dispatcher.InvokeAsync and may consolidate multiple changes.
	/// </summary>
	public static event Action FilesChangedEvent;
	
	public static void SciKillFocus(SciCode doc) {
		if (!_CanWork(doc)) return;
#if DEBUG
		if (Debugger.IsAttached) return;
#endif
		//hide code info windows, except when a code info window is focused. Code info window names start with "Ci.".
		var aw = wnd.thisThread.active;
		if (aw.Is0) Stop(); else if (!(KPopup.FromHwnd(aw) is KPopup p && p.Name.Starts("Ci."))) Cancel();
	}
	
	public static bool SciCmdKey(SciCode doc, KKey key, ModifierKeys mod) {
#if NO_COMPL_CORR_SIGN
		return false;
#endif
		if (!_CanWork(doc)) return false;
		
		switch ((key, mod)) {
		case (KKey.Space, ModifierKeys.Control):
			ShowCompletionList(doc);
			return true;
		case (KKey.Space, ModifierKeys.Control | ModifierKeys.Shift):
			ShowSignature(doc);
			return true;
		case (KKey.Escape, 0):
		case (KKey.Down, 0):
		case (KKey.Up, 0):
		case (KKey.PageDown, 0):
		case (KKey.PageUp, 0):
		case (KKey.Home, 0):
		case (KKey.End, 0):
			if ((HideTextPopup() || _tools.HideTempWindows()) && key == KKey.Escape) return true;
			//never mind: on Esc, if several popups, should hide the top popup.
			//	We instead hide less-priority popups when showing a popup. Then Esc will hide the correct popup in most cases.
			if (_compl.OnCmdKey_SelectOrHide(key) || _signature.OnCmdKey(key)) return true;
			if (key == KKey.Escape) if (doc.SnippetMode_?.SciKey(key, mod) == true) return true;
			break;
		case (KKey.Tab, 0):
		case (KKey.Enter, 0):
			if (_compl.OnCmdKey_Commit(doc, key) != CiComplResult.None) return true;
			if (doc.SnippetMode_?.SciKey(key, mod) == true) return true;
			if (_correct.SciBeforeKey(doc, key, mod)) return true;
			break;
		case (KKey.Tab, ModifierKeys.Shift):
			if (doc.SnippetMode_?.SciKey(key, mod) == true) return true;
			break;
		case (KKey.Enter, ModifierKeys.Shift) or (KKey.Enter, ModifierKeys.Control) or (KKey.Enter, ModifierKeys.Control | ModifierKeys.Shift):
		case (KKey.OemSemicolon, ModifierKeys.Control):
			var complResult = _compl.OnCmdKey_Commit(doc, key);
			if (complResult == CiComplResult.Complex) return true;
			if (_correct.SciBeforeKey(doc, key, mod) | (complResult != CiComplResult.None)) return true;
			break;
		case (KKey.Back, 0):
		case (KKey.Delete, 0):
			if (_correct.SciBeforeKey(doc, key, mod)) return true;
			break;
		}
		return false;
	}
	
	public static bool SciBeforeCharAdded(SciCode doc, char ch) {
#if NO_COMPL_CORR_SIGN
		return false;
#endif
		if (!_CanWork(doc)) return false;
		
		if (_compl.IsVisibleUI) {
			if (CiComplResult.Complex == _compl.SciCharAdding_Commit(doc, ch)) return true;
		}
		
		return _correct.SciBeforeCharAdded(doc, ch);
	}
	
	public static bool SciModified(SciCode doc, in Sci.SCNotification n) {
		if (!_CanWork(doc)) return false;
		_document = null;
		_compl.SciModified(doc, in n);
		_styling.SciModified(doc, in n);
		_diag.SciModified(doc, in n);
		Panels.Outline.SciModified();
		return true;
	}
	
	public static void SciCharAdded(SciCode doc, char ch) {
#if NO_COMPL_CORR_SIGN
		return;
#endif
		if (!_CanWork(doc)) return;
		
		using var c = new CharContext(doc, ch);
		_correct.SciCharAdded(c); //sync adds or removes ')' etc if need.
		if (!c.ignoreChar) {
			_compl.SciCharAdded_ShowList(c); //async gets completions and shows popup list. If already showing, filters/selects items.
			_signature.SciCharAdded(c.doc, c.ch); //async shows signature help. Faster than _compl.
		}
		
		//Example: user types 'wri('.
		//	When typed 'w', _compl.SciCharAdded_ShowList shows popup list (async).
		//	While typing 'ri', _compl.SciModified in the list selects Write.
		//	When typed '(':
		//		_compl.SciCharAdded_Commit replaces 'wri(' with 'Write('. Caret is after '('.
		//		_correct adds ')'. Caret is still after '('.
		//		_signature shows signature help.
		//	If then user types 'tr)':
		//		_compl on 't' shows popup list and on ')' replaces 'tr)' with 'true)'.
		//		_correct deletes the ')' it added before.
		//		_signature not called because discardChar==true. To hide signature help are used temp ranges.
		//	Finally we have 'Write(true)', and caret is after it, and no double '))'.
		//	If instead types 'tr;':
		//		_correct on ';' moves caret after ')', and finally we have 'Write(true);', and caret after ';'.
	}
	
	public static void SciUpdateUI(SciCode doc, Sci.UPDATE updated) {
#if NO_COMPL_CORR_SIGN
		return;
#endif
		//print.it("SciUpdateUI", modified, _tempNoAutoComplete);
		if (!_CanWork(doc)) return;
		
		if (updated.HasAny(Sci.UPDATE.SC_UPDATE_CONTENT | Sci.UPDATE.SC_UPDATE_SELECTION)) {
			//_compl.SciUpdateUI(doc);
			_signature.SciPositionChanged(doc);
			CiFind.SciUpdateUI(doc, updated.Has(Sci.UPDATE.SC_UPDATE_CONTENT));
		} else if (updated.HasAny(Sci.UPDATE.SC_UPDATE_V_SCROLL | Sci.UPDATE.SC_UPDATE_H_SCROLL)) {
			Cancel();
			//if (0 != (updated & 4)) { //vertically
			//	_styling.Timer250msWhenVisibleAndWarm(doc); //rejected. Uses much CPU. The 250 ms timer is OK.
			//}
		}
	}
	
	public static void ShowCompletionList(SciCode doc = null) {
		doc ??= Panels.Editor.ActiveDoc;
		if (!_CanWork(doc)) return;
		_compl.ShowList();
	}
	
	public static void ShowSignature(SciCode doc = null) {
		doc ??= Panels.Editor.ActiveDoc;
		if (!_CanWork(doc)) return;
		_signature.ShowSignature(doc);
	}
	
	/// <summary>
	/// Shows or hides quick info or/and error info.
	/// </summary>
	public static async void SciMouseDwellStarted(SciCode doc, int pos8) {
		if (!_CanWork(doc) || pos8 < 0) return;
		
		var text0 = doc.aaaText;
		int pos16 = doc.aaaPos16(pos8);
		var diag = _diag.GetPopupTextAt(doc, pos8, pos16, out var onLinkClick);
		var quick = await _quickInfo.GetTextAt(pos16);
		if (doc != Panels.Editor.ActiveDoc || (object)text0 != doc.aaaText) return; //changed while awaiting
		
		if (diag == null && quick == null) {
			HideTextPopup();
		} else {
			var text = diag ?? quick;
			if (quick != null && diag != null) {
				text.Blocks.Add(new System.Windows.Documents.BlockUIContainer(new System.Windows.Controls.Separator { Margin = new(4) }));
				text.Blocks.Add(quick);
			}
			_ShowTextPopup(doc, pos16, text, onLinkClick);
		}
	}
	
	/// <summary>
	/// Use with `using` before pasting, dropping or inserting text when may need special processing, eg auto-inserting 'using' directives.
	/// </summary>
	public class PastingEtc : IDisposable {
		SciCode _doc;
		CiAutocorrect.Pasting _ac;
		
		/// <param name="silent">Insert missing usings without showing dialog.</param>
		public PastingEtc(SciCode doc, bool silent = false) {
			if (!_CanWork(doc)) return;
			_doc = doc;
			_diag.Pasting(_doc, silent);
			_ac = new(_doc);
		}
		
		public void Dispose() {
			if (_doc == null) return;
			_ac.After();
		}
	}
	
	public class Context {
		public readonly SciCode sci;
		public readonly string code;
		public readonly StartEnd meta;
		public int pos;
		public readonly bool isCodeFile;
		
		public Document document { get; private set; }
		
		public CompilationUnitSyntax syntaxRoot { get; private set; }
		
		public SemanticModel semanticModel => document.GetSemanticModelAsync().Result_(); //only first time slow
		
		/// <summary>
		/// Initializes all fields except document.
		/// For <b>sci</b> uses <b>Panels.Editor.aaActiveDoc</b>.
		/// </summary>
		/// <param name="pos">If -1, gets current position. If -2, gets selection start.</param>
		public Context(int pos) {
			Debug.Assert(App.IsMainThread);
			
			sci = Panels.Editor.ActiveDoc;
			code = sci.aaaText;
			this.pos = pos switch { -1 => sci.aaaCurrentPos16, -2 => sci.aaaSelectionStart16, _ => pos };
			Debug.Assert((uint)this.pos <= code.Length);
			if (isCodeFile = sci.EFile.IsCodeFile) meta = MetaComments.FindMetaComments(code);
		}
		
		/// <summary>
		/// Initializes the document field.
		/// Creates or updates Solution if need.
		/// Returns false if fails, eg if code too big.
		/// </summary>
		public bool GetDocument() {
			if (_document != null) {
				document = _document;
				syntaxRoot = _syntaxRoot;
				return true;
			}
			//perf.first();
			
			//return false if code is too big. Eg Roslyn hangs if pasted 20 MB """XML""".
			if (code.Length > 10_000_000) {
				_Uncache();
				return false;
			}
			
			if (_solution != null && !code.Eq(meta.start..meta.end, _metaText)) {
				_Uncache();
				_styling.Update();
			}
			if (_solution == null) _metaText = code[meta.start..meta.end];
			
			try {
				if (_solution == null) {
					_CreateWorkspace(sci);
				} else {
					_solution = _solution.WithDocumentText(_documentId, SourceText.From(code, Encoding.UTF8));
				}
			}
			catch (Exception ex) {
				//Debug_.Print(ex);
				print.it(ex);
				_Uncache();
				return false;
			}
			
			document = _document = _solution.GetDocument(_documentId);
			//perf.next();
			
			//syntaxRoot protects the syntax tree from GC. Creating it is expensive.
			//	Roslyn keeps just a week reference, and could have to recompute it for every task.
			//	Note: now I can't reproduce. It seems TryGetSyntaxRoot etc always succeeds.
			syntaxRoot = _syntaxRoot = document.GetSyntaxRootSynchronously(default) as CompilationUnitSyntax;
			
			//When certain invalid code exists, the Roslyn's copy of file code (syntaxRoot.GetText()) may be different (usually much shorter).
			//	Then calling various Roslyn functions would throw exception. Better return false now.
			//	It seems it was caused by _ModifyTLS, now removed. //FUTURE: remove this code?
			if (syntaxRoot.EndOfFileToken.SpanStart != code.Length) {
#if DEBUG
				print.clear();
				Debug_.Print("---- bad code ----");
				foreach (var v in syntaxRoot.ChildNodes()) CiUtil.PrintNode(v);
#endif
				return false;
			}
			
			return true;
		}
	}
	
	/// <summary>
	/// Creates new Context and calls its GetDocument.
	/// Returns false if: 1. Not a code file; 2. position is in meta comments (unless metaToo==true); 3. Fails to create/update Solution (unlikely). Then r.document is null.
	/// If returns true, r.document is Document for Panels.Editor.ActiveDoc. If need, parses meta, creates Project, Solution, etc.
	/// Always sets other r fields.
	/// </summary>
	/// <param name="position">If -1, gets current position. If -2, gets selection start.</param>
	/// <param name="metaToo">Don't return false if position is in meta comments.</param>
	public static bool GetContextAndDocument(out Context r, int position = -1, bool metaToo = false) {
		if (!GetContextWithoutDocument(out r, position, metaToo)) return false;
		return r.GetDocument();
	}
	
	/// <summary>
	/// Creates new Context with document=null. Even if returns false.
	/// Returns false if: 1. Not a code file; 2. position is in meta comments (unless metaToo==true).
	/// </summary>
	/// <param name="position">If -1, gets current position. If -2, gets selection start.</param>
	/// <param name="metaToo">Don't return false if position is in meta comments.</param>
	public static bool GetContextWithoutDocument(out Context r, int position = -1, bool metaToo = false) {
		if (Panels.Editor.ActiveDoc == null) { r = null; return false; }
		r = new Context(position);
		if (!r.isCodeFile) return false;
		if (!metaToo && r.pos < r.meta.end && r.pos > r.meta.start) return false;
		return true;
	}
	
	/// <summary>
	/// Calls <see cref="GetContextAndDocument"/>, gets its syntax root and finds node.
	/// </summary>
	/// <param name="position">If -1, gets current position. If -2, gets selection start.</param>
	/// <param name="metaToo">Don't return false if position is in meta comments.</param>
	public static bool GetDocumentAndFindNode(out Context r, out SyntaxNode node, int position = -1, bool metaToo = false, bool findInsideTrivia = false) {
		if (!GetContextAndDocument(out r, position, metaToo)) { node = null; return false; }
		node = r.syntaxRoot.FindToken(r.pos, findInsideTrivia).Parent;
		return true;
	}
	
	/// <summary>
	/// Calls <see cref="GetContextAndDocument"/>, gets its syntax root and finds token.
	/// </summary>
	/// <param name="position">If -1, gets current position. If -2, gets selection start.</param>
	/// <param name="metaToo">Don't return false if position is in meta comments.</param>
	public static bool GetDocumentAndFindToken(out Context r, out SyntaxToken token, int position = -1, bool metaToo = false, bool findInsideTrivia = false) {
		if (!GetContextAndDocument(out r, position, metaToo)) { token = default; return false; }
		token = r.syntaxRoot.FindToken(r.pos, findInsideTrivia);
		return true;
	}
	
	public static CiWorkspace CurrentWorkspace { get; private set; }
	
	static void _CreateWorkspace(SciCode sci) {
		//TODO3: use same workspace if project/solution not changed.
		//	Here "solution" means when a project or file uses project references.
		//	Now eg slow GetSemanticModelAsync when [re]opening a file in a large project/solution.
		
		_diag.ClearMetaErrors();
		
		var fn = sci.EFile;
		var ws = CurrentWorkspace = new(fn, sci.EIsWpfPreview ? CiWorkspace.Caller.CodeInfoWpfPreview : CiWorkspace.Caller.CodeInfoNormal);
		_solution = ws.Solution;
		_projectId = ws.Projects[0].projectId;
		_documentId = ws.GetDocId(fn);
	}
	
	private static void _Timer025sWhenVisible() {
		var doc = Panels.Editor.ActiveDoc;
		if (!_CanWork(doc)) {
			Panels.Outline.Clear();
			return;
		}
		
		//cancel if changed the screen rectangle of the document window
		if (_compl.IsVisibleUI || _signature.IsVisibleUI || _tpVisible) {
			var r = Panels.Editor.ActiveDoc.AaWnd.Rect;
			if (!_isUI) {
				_isUI = true;
				_sciRect = r;
			} else if (r != _sciRect) { //moved/resized top-level window or eg moved some splitter
				_isUI = false;
				Cancel();
			}
		} else if (_isUI) {
			_isUI = false;
		}
		
		_styling.Timer250msWhenVisibleAndWarm(doc);
		Panels.Outline.Timer025sWhenVisible();
	}
	
	static CiPopupText _textPopup;
	static bool _tpVisible;
	
	static void _ShowTextPopup(SciCode doc, int pos16, System.Windows.Documents.Section text, Action<CiPopupText, string> onLinkClick = null) {
		_textPopup ??= new CiPopupText(CiPopupText.UsedBy.Info, onHiddenOrDestroyed: (_, _) => _tpVisible = false);
		_textPopup.Text = text;
		_textPopup.OnLinkClick = onLinkClick;
		_textPopup.Show(doc, pos16, hideIfOutside: true);
		_tpVisible = true;
	}
	
	//CONSIDER: option to show tooltip: below mouse (like now), above mouse, top/bottom (which is farther), maybe above Output etc.
	//	This test version shows above Output.
	//static void _ShowTextPopup(SciCode doc, int pos16, System.Windows.Documents.Section text, Action<CiPopupText, string> onLinkClick = null) {
	//	_textPopup ??= new CiPopupText(CiPopupText.UsedBy.Info, onHiddenOrDestroyed: (_, _) => _tpVisible = false);
	//	_textPopup.Text = text;
	//	_textPopup.OnLinkClick = onLinkClick;
	//	if (keys.isScrollLock && Panels.Output.IsVisible) {
	//		var r = Panels.Output.RectInScreen();
	//		_textPopup.Show(doc, r, null);
	//	} else {
	//		_textPopup.Show(doc, pos16, hideIfOutside: true);
	//	}
	//	_tpVisible = true;
	//}
	
	internal static bool HideTextPopup() {
		if (_tpVisible) { _textPopup.Hide(); return true; }
		return false;
	}
	
	internal static void HideTextPopupAndTempWindows() {
		HideTextPopup();
		_tools.HideTempWindows();
	}
	
	public class CharContext : IDisposable {
		public readonly SciCode doc;
		public char ch;
		/// <summary>Don't show completions, signature, etc.</summary>
		public bool ignoreChar;
		//bool _undoStarted;
		
		public CharContext(SciCode doc, char ch) {
			this.doc = doc;
			this.ch = ch;
		}
		
		//public void BeginUndoAction()
		//{
		//	if(!_undoStarted) {
		//		_undoStarted = true;
		//		doc.Call(Sci.SCI_BEGINUNDOACTION);
		//	}
		//}
		
		public void Dispose() {
			//if(_undoStarted) {
			//	_undoStarted = false;
			//	doc.Call(Sci.SCI_ENDUNDOACTION);
			//}
		}
	}
	
	//public static void Test()
	//{
	
	//}
}


================================================
FILE: Au.Editor/Edit/EditGoBack.cs
================================================
namespace LA;

class EditGoBack {
	record struct _Location(FileNode fn, int pos);
	
	List<_Location> _a = new();
	int _i = -1;
	bool _canGoBack, _canGoForward;
	long _time;
	
	internal void OnPosChanged(SciCode doc) {
		//print.it("pos", doc.aaaCurrentPos8);
		
		bool add;
		int pos = doc.aaaCurrentPos8;
		var prev = _a.Count > 0 ? _a[_i] : default;
		if (prev.fn != doc.EFile) {
			add = true;
		} else {
			if (pos == prev.pos) return; //eg on Back/Forward
			if (_recordNext) {
				_recordNext = false;
				add = Environment.TickCount64 - _time > 250;
			} else {
				add = Environment.TickCount64 - _time > 500
					&& Math.Abs(doc.aaaLineFromPos(false, pos) - doc.aaaLineFromPos(false, prev.pos)) >= 10;
			}
		}
		
		var now = new _Location(doc.EFile, pos);
		if (add) {
			if (++_i < _a.Count) _a.RemoveRange(_i, _a.Count - _i); //after GoBack
			else if (_a.Count == 256) _a.RemoveAt(0);
			_i = _a.Count;
			_a.Add(now);
		} else _a[_i] = now;
		
		_time = Environment.TickCount64;
		_UpdateUI();
		
		//timer.after(1000, _ => {
		//	print.it("----");
		//	print.it(_a);
		//});
	}
	
	internal void SciModified(SciCode doc, bool deleted, int pos, int len) {
		//print.it("mod", deleted, pos, len);
		_time = 0;
		if (_i < 0) return; //probably impossible, but anyway
		if (deleted) len = -len;
		var fn = doc.EFile;
		for (int i = _a.Count; --i >= 0;) {
			if (_a[i].fn == fn && _a[i].pos > pos) {
				_a[i] = new(fn, Math.Max(pos, _a[i].pos + len));
			}
		}
		if (deleted) { //remove adjacent duplicates
			for (int i = _a.Count - 1; --i >= 0;) {
				if (_a[i].fn == fn && _a[i].pos == pos && _a[i + 1].fn == fn && _a[i + 1].pos == pos) {
					_a.RemoveAt(i);
					if (i <= _i) _i--;
				}
			}
			//for (int i = 0; i < _a.Count; i++) print.it(_a[i].pos);
			_UpdateUI();
		}
	}
	
	//when file modified externally. Currently not used.
	//internal void OnTextReplaced(FileNode fn) {
	//	//print.it("replaced", fn);
	//	_time = 0;
	//	if (_i < 0) return;
	//	int iFirst = _a.FindIndex(o => o.fn == fn); if (iFirst < 0) return;
	//	_a[iFirst] = new(fn, 0);
	//	for (int i = _a.Count; --i > iFirst;) {
	//		if (_a[i].fn == fn) {
	//			_a.RemoveAt(i);
	//			if (i <= _i) _i--;
	//		}
	//	}
	//	_UpdateUI();
	//}
	
	internal void OnRestoringSavedPos() {
		_time = Environment.TickCount64;
	}
	
	internal void OnFileDeleted(IEnumerable<FileNode> e) {
		bool removed = false;
		foreach (var f in e) {
			if (f.IsFolder) continue;
			//print.it($"before: count={_a.Count}, _i={_i}, file={f}, _a={_a:print}");
			for (int i = _a.Count; --i >= 0;) {
				if (_a[i].fn == f) {
					_a.RemoveAt(i);
					if (i <= _i) _i--;
					//print.it(i, _i);
					removed = true;
				}
			}
		}
		if (removed) {
			if (_i > 0 && _a[_i] == _a[_i - 1]) _a.RemoveAt(_i--);
			//print.it($"after:  count={_a.Count}, _i={_i}, _a={_a:print}");
			_time = 0;
			_UpdateUI();
		}
	}
	
	/// <summary>
	/// Record next position change event, even if the position is near.
	/// </summary>
	public void RecordNext() { _recordNext = true; }
	bool _recordNext;
	
	public void GoBack() {
		if (_i < 1) return;
		_i--;
		_GoTo();
	}
	
	public void GoForward() {
		if (_i > _a.Count - 2) return;
		_i++;
		_GoTo();
	}
	
	void _GoTo() {
		var v = _a[_i];
		_UpdateUI();
		if (!App.Model.SetCurrentFile(v.fn)) return;
		var doc = Panels.Editor.ActiveDoc;
		doc.aaaGoToPos(false, v.pos);
		doc.Focus();
	}
	
	void _UpdateUI() {
		bool canGoBack = _i > 0, canGoForward = _i < _a.Count - 1;
		if (canGoBack != _canGoBack) App.Commands[nameof(Menus.Edit.Navigate.Go_back)].Enable(_canGoBack = canGoBack);
		if (canGoForward != _canGoForward) App.Commands[nameof(Menus.Edit.Navigate.Go_forward)].Enable(_canGoForward = canGoForward);
	}
	
	internal static void DisableUI() {
		if (App.Commands == null) return;
		App.Commands[nameof(Menus.Edit.Navigate.Go_back)].Enable(false);
		App.Commands[nameof(Menus.Edit.Navigate.Go_forward)].Enable(false);
	}
}


================================================
FILE: Au.Editor/Edit/GenerateCode.cs
================================================
extern alias CAW;

using Au.Controls;
using System.Windows;
using System.Windows.Controls;
using System.Collections.Immutable;

using Microsoft.CodeAnalysis;
using CAW::Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Text;
using Microsoft.CodeAnalysis.CSharp.Extensions;
using Microsoft.CodeAnalysis.Shared.Extensions;
using CAW::Microsoft.CodeAnalysis.Shared.Extensions;
using CAW::Microsoft.CodeAnalysis.Rename;
using acc = Microsoft.CodeAnalysis.Accessibility;

namespace LA;

/// <summary>
/// Inserts various code in code editor. With correct indent etc.
/// Some functions can insert in other controls too.
/// </summary>
static class GenerateCode {
	/// <summary>
	/// Called from CiCompletion._ShowList on char '/'. If need, inserts XML doc comment with empty summary, param and returns tags.
	/// </summary>
	public static void DocComment(CodeInfo.Context cd) {
		int pos = cd.pos;
		string code = cd.code;
		SciCode doc = cd.sci;
		
		if (0 == code.Eq(pos - 3, false, "///\r", "///\n") || !CiUtil.IsLineStart(code, pos - 3)) return;
		
		var root = cd.syntaxRoot;
		var node = root.FindToken(pos).Parent;
		var start = node.SpanStart;
		if (start < pos) return;
		
		node = node.GetAncestorOrThis<MemberDeclarationSyntax>();
		if (node is null or GlobalStatementSyntax or ExtensionBlockDeclarationSyntax || node.SpanStart != start) return;
		
		//already has doc comment?
		foreach (var v in node.GetLeadingTrivia()) {
			if (v.IsDocumentationCommentTrivia) { //singleline (preceded by ///) or multiline (preceded by /**)
				var span = v.Span;
				if (span.Start != pos || span.Length > 2) return; //when single ///, span includes only newline after ///
			}
		}
		//print.it(pos);
		//CiUtil.PrintNode(node);
		
		string s = @" <summary>
/// 
/// </summary>";
		BaseParameterListSyntax pl = node switch {
			BaseMethodDeclarationSyntax k => k.ParameterList,
			TypeDeclarationSyntax k => k.ParameterList,
			IndexerDeclarationSyntax k => k.ParameterList,
			DelegateDeclarationSyntax k => k.ParameterList,
			_ => null
		};
		if (pl != null) {
			var b = new StringBuilder(s);
			foreach (var p in pl.Parameters) {
				b.Append("\r\n/// <param name=\"").Append(p.Identifier.Text).Append("\"></param>");
			}
			if ((node is MethodDeclarationSyntax met2 && !code.Eq(met2.ReturnType.Span, "void"))
				|| node is IndexerDeclarationSyntax
				|| (node is DelegateDeclarationSyntax del2 && !code.Eq(del2.ReturnType.Span, "void"))
				) b.Append("\r\n/// <returns></returns>");
			
			s = b.ToString();
			//rejected: <typeparam name="TT"></typeparam>. Rarely used.
		}
		
		s = CiUtil.IndentStringForInsertSimple(s, doc, pos);
		
		doc.aaaInsertText(true, pos, s, true, true);
		doc.aaaGoToPos(true, pos + s.Find("/ ") + 2);
	}
	
	/// <summary>
	/// Prints delegate code. Does not insert.
	/// </summary>
	public static void CreateDelegate() {
		if (!_CreateDelegate()) print.it("To create delegate code, the text cursor must be where a delegate can be used, for example after 'Event+=' or in a function argument list.");
	}
	
	static bool _CreateDelegate() {
		//FUTURE: show tool to insert code, not just print.
		//	With name edit field. Options to insert as method or local func. Option to use `#region events`. Option to add `print.it("EventName");`.
		
		if (!CodeInfo.GetContextAndDocument(out var cd)) return false;
		int pos = cd.pos;
		var semo = cd.semanticModel;
		var token = cd.syntaxRoot.FindTokenOnLeftOfPosition(cd.pos);
		SyntaxNode node = token.Parent, node0 = node;
		
		for (; node != null; node = node.Parent) {
			if (node is AssignmentExpressionSyntax aes) {
				if (node.Kind() is SyntaxKind.SimpleAssignmentExpression or SyntaxKind.AddAssignmentExpression or SyntaxKind.SubtractAssignmentExpression)
					return _GetTypeAndFormat(aes.Left, aes);
			} else if (node is BaseArgumentListSyntax als) {
				if (!node.Span.ContainsInside(pos)) continue;
				if (CiUtil.GetArgumentParameterFromPos(als, pos, semo, out _, out var aps, o => _GetDelegateType(o.Type) != null)) {
					bool ok = false;
					foreach (var ps in aps) {
						ok |= _Format(ps.Type);
					}
					return ok;
					
					//rejected: support generic, like `void M12<T>(T a) where T: Delegate`
				}
			} else if (node is VariableDeclarationSyntax vds) {
				return _GetTypeAndFormat(vds.Type);
			} else if (node is ReturnStatementSyntax rss) {
				return _GetTypeAndFormat(rss.GetAncestor<MethodDeclarationSyntax>()?.ReturnType);
			} else if (node is ArrowExpressionClauseSyntax ae) {
				switch (node.Parent) {
				case MethodDeclarationSyntax m: return _GetTypeAndFormat(m.ReturnType);
				case PropertyDeclarationSyntax p: return _GetTypeAndFormat(p.Type);
				}
			} else if (node is LambdaExpressionSyntax les && node == node0 && token.IsKind(SyntaxKind.EqualsGreaterThanToken)) { //maybe the lambda returns a delegate
				if (semo.GetTypeInfo(les).ConvertedType is INamedTypeSymbol { DelegateInvokeMethod: { } dim }) return _Format(dim.ReturnType);
			} else if (node is StatementSyntax or AnonymousFunctionExpressionSyntax) {
			} else continue;
			break;
		}
		
		return false;
		
		static INamedTypeSymbol _GetDelegateType(ITypeSymbol t) {
			if (t.TypeKind == TypeKind.Delegate || t.SpecialType == SpecialType.System_Delegate) return t as INamedTypeSymbol;
			if (t is IArrayTypeSymbol ats) return _GetDelegateType(ats.ElementType);
			if (t is INamedTypeSymbol { Arity: 1 } nt && t.CanBeEnumerated()) return _GetDelegateType(nt.TypeArguments[0]);
			return null;
		}
		
		bool _GetTypeAndFormat(SyntaxNode sn, AssignmentExpressionSyntax aes = null) {
			if (sn == null) return false;
			return _Format(semo.GetTypeInfo(sn).Type, aes);
		}
		
		bool _Format(ITypeSymbol type, AssignmentExpressionSyntax aes = null) {
			if (_GetDelegateType(type) is not INamedTypeSymbol t || t is IErrorTypeSymbol) return false;
			if (t.TypeKind != TypeKind.Delegate) {
				if (t.SpecialType == SpecialType.System_Delegate && t.ContainingAssembly.GetTypeByMetadataName("System.Action") is { } tsa) t = tsa;
				else return false;
			}
			var b = new StringBuilder("<><lc #A0C0A0>Delegate method and lambda<>\r\n<code>");
			string methodName = "_RenameMe";
			if (aes != null) {
				if (aes.Left is IdentifierNameSyntax ins) {
					methodName = $"_{ins.Identifier.Text}";
				} else if (aes.Left is MemberAccessExpressionSyntax maes) {
					if (maes.Expression is IdentifierNameSyntax ins2) {
						methodName = $"_{ins2.Identifier.Text}_{maes.Name.Identifier.Text}";
					} else {
						methodName = $"_{maes.Name.Identifier.Text}";
					}
				}
				if (methodName.Starts("__")) methodName = methodName[1..];
			}
			_FormatDelegete(b, null, t, methodName, semo, pos);
			b.AppendLine("</code>");
			print.it(b);
			return true;
		}
	}
	
	static void _FormatDelegete(StringBuilder b, bool? lambda, INamedTypeSymbol t, string methodName, SemanticModel semo, int pos, string printEvent = null) {
		_sdf1 ??= new SymbolDisplayFormat(
			genericsOptions: SymbolDisplayGenericsOptions.IncludeTypeParameters,
			memberOptions: SymbolDisplayMemberOptions.IncludeParameters | SymbolDisplayMemberOptions.IncludeType | SymbolDisplayMemberOptions.IncludeRef,
			miscellaneousOptions: SymbolDisplayMiscellaneousOptions.UseSpecialTypes | SymbolDisplayMiscellaneousOptions.EscapeKeywordIdentifiers,
			parameterOptions: SymbolDisplayParameterOptions.IncludeType | SymbolDisplayParameterOptions.IncludeName | SymbolDisplayParameterOptions.IncludeParamsRefOut | SymbolDisplayParameterOptions.IncludeDefaultValue
			);
		
		var m = t.DelegateInvokeMethod;
		
		if (lambda != true) {
			b.Append(m.ToMinimalDisplayString(semo, pos, _sdf1));
			b.Replace(" Invoke(", $" {methodName}(");
			_AppendBody(false);
		}
		
		if (lambda != false) {
			var s = "()";
			if (m.Parameters.Any()) {
				var format = _sdf1.WithMemberOptions(SymbolDisplayMemberOptions.IncludeParameters);
				bool withTypes = m.Parameters.Any(o => o.RefKind != 0 || o.IsParams);
				if (withTypes) format = format.RemoveParameterOptions(SymbolDisplayParameterOptions.IncludeDefaultValue);
				else format = format.WithParameterOptions(SymbolDisplayParameterOptions.IncludeName);
				s = m.ToMinimalDisplayString(semo, pos, format);
				if (m.Parameters.Length == 1 && !withTypes) s = s[7..^1]; else s = s[6..]; //remove 'Invoke' and maybe '()'
			}
			b.Append(s).Append(" =>");
			if (lambda == true) _AppendBody(true); else b.AppendLine(" ");
		}
		
		void _AppendBody(bool oneLine) {
			b.Append(oneLine ? " { " : " {\r\n\t");
			if (printEvent != null) b.AppendFormat("_PrintEvent(\"{0}\");", printEvent).Append(oneLine ? " " : "\r\n\t");
			if (!m.ReturnsVoid) b.Append("return default;"); //never mind ref return
			b.AppendLine(oneLine ? " };" : "\r\n}");
		}
	}
	static SymbolDisplayFormat _sdf1;
	
	public static void CreateEventHandlers() {
		INamedTypeSymbol type = null;
		string varName = null;
		bool staticEvents = false;
		var (sym, cd) = CiUtil.GetSymbolFromPos(preferVar: true);
		if (sym != null) {
			if (sym is INamedTypeSymbol nts) {
				type = nts;
				varName = type.Name;
				staticEvents = true;
			} else if (sym is ILocalSymbol or IParameterSymbol or IFieldSymbol or IPropertySymbol) {
				type = sym.GetSymbolType() as INamedTypeSymbol;
				varName = sym.Name;
			}
		}
		if (type == null) {
			dialog.showInfo("Create event handlers", "Please click or right-click a variable or type name in code.\nThen retry.\nIf type name, prints static events, else non-static.");
			return;
		}
		
		string typeString = type.ToString(); //X or X<T>
		bool lambda = false;
		int button = dialog.show("Create event handlers", $"Type: {typeString}", "1 Methods|2 Lambdas|0 Cancel", flags: DFlags.CommandLinks, owner: App.Hmain);
		switch (button) { case 1: break; case 2: lambda = true; break; default: return; }
		
		bool found = false, found2 = false;
		StringBuilder b1 = new("<><lc #A0C0A0>Event handlers. The text is in the clipboard.<>\r\n<code>"), b2 = new();
		string prefix = (varName[0] != '_' ? "_" : null) + varName + "_";
		foreach (var type2 in type.TypeKind is TypeKind.Interface ? type.GetAllInterfacesIncludingThis() : type.GetBaseTypesAndThis().SkipLast(1)) {
			bool once = false;
			foreach (var v in type2.GetMembers()) {
				if (v is IEventSymbol es) {
					if (es.IsStatic == staticEvents) {
						var funcName = prefix + es.Name;
						if (!once) {
							var s1 = $"//{type2} events";
							if (found) b1.AppendLine();
							b1.AppendLine(s1);
							if (!lambda) b2.AppendLine().AppendLine(s1);
							once = found = true;
						}
						b1.Append($"{(staticEvents ? typeString : varName)}.{es.Name} += ");
						if (!lambda) {
							b1.AppendLine($"{funcName};");
							b2.AppendLine();
						}
						_FormatDelegete(lambda ? b1 : b2, lambda, es.Type as INamedTypeSymbol, funcName, cd.semanticModel, cd.pos, es.Name);
					} else found2 = true;
				}
			}
		}
		if (!found) {
			print.it(found2
				? $"Type {typeString} does not have {(staticEvents ? "static" : "non-static")} events."
				: $"Type {typeString} does not have events.");
			return;
		}
		
		b1.Append(b2).Append("\r\n[Conditional(\"DEBUG\")]\r\nstatic void _PrintEvent(string s) { print.it($\"<><c green>event <_>{s}</_><>\"); }\r\n</code>");
		var text = b1.ToString();
		print.it(text);
		clipboard.text = text[(text.Find("<code>") + 6)..^7];
	}
	
	public static void CreateOverrides() {
		if (!CodeInfo.GetContextAndDocument(out var cd)) return;
		var semo = cd.semanticModel;
		var type = semo.GetEnclosingNamedType2(cd.pos, out _, out var declNode);
		if (type == null || type.TypeKind != TypeKind.Class) return;
		int pos2 = declNode.CloseBraceToken.Span.Start;
		var b = new StringBuilder("<><lc #A0C0A0>Overrides. The text is in the clipboard.<>\r\n<code>");
		var format = CiText.s_symbolFullFormat.WithParameterOptions(CiText.s_symbolFullFormat.ParameterOptions & ~SymbolDisplayParameterOptions.IncludeOptionalBrackets);
		bool found = false;
		for (var type2 = type.BaseType; type2?.BaseType != null; type2 = type2.BaseType) { //base types except object
			//print.it(type2);
			bool once = false;
			foreach (var v in type2.GetMembers()) {
				if ((v.IsVirtual || v.IsAbstract) && (v is IMethodSymbol { MethodKind: MethodKind.Ordinary } || v is IPropertySymbol)) {
					if (!once) {
						if (found) b.AppendLine();
						b.AppendLine($"//{type2} overrides");
						once = found = true;
					}
					b.AppendLine().Append(_AccToString(v)).Append(" override ");
					var s = v.ToMinimalDisplayString(semo, pos2, format);
					if (v is IMethodSymbol ims) {
						b.Append(s);
						b.AppendLine(" {\r\n\t_PrintFunc();\r\n\t");
						if (v.IsAbstract) {
							if (!ims.ReturnsVoid) b.AppendLine("\treturn default;");
						} else {
							b.AppendLine($"\t{(ims.ReturnsVoid ? "" : "return ")}base.{v.Name}({string.Join(", ", ims.Parameters.Select(o => o.Name))});");
						}
						b.AppendLine("}");
					} else if (v is IPropertySymbol ips) {
						if (v.IsAbstract) {
							if (!ips.IsWriteOnly) s = s.Replace(" get;", $"\r\n\tget {{ _PrintFunc($\"get {v.Name}\");  return default; }}\r\n");
							if (!ips.IsReadOnly) s = s.Replace(" set;", $"\r\n\tset {{ _PrintFunc($\"set {v.Name}\");  }}\r\n");
						} else {
							if (!ips.IsWriteOnly) s = s.Replace(" get;", $"\r\n\tget {{ _PrintFunc($\"get {v.Name}\");  return base.{v.Name}; }}\r\n");
							if (!ips.IsReadOnly) s = s.Replace(" set;", $"\r\n\tset {{ _PrintFunc($\"set {v.Name}\");  base.{v.Name} = value; }}\r\n");
							if (ips.IsIndexer) s = s.Replace(" base.this[]", $" base[{string.Join(", ", ips.Parameters.Select(o => o.Name))}]");
						}
						s = s.Replace("\n }", "\n}");
						b.AppendLine(s);
					}
				}
			}
		}
		if (!found) {
			print.it($"Class {type} does not have a base class containing virtual or abstract functions.");
			return;
		}
		
		b.Append("\r\n[Conditional(\"DEBUG\")]\r\nstatic void _PrintFunc([CallerMemberName] string m_ = null) { print.it($\"<><c green>override <_>{m_}</_><>\"); }\r\n</code>");
		var text = b.ToString();
		print.it(text);
		clipboard.text = text[(text.Find("<code>") + 6)..^7];
	}
	
	static string _AccToString(ISymbol v) => v.DeclaredAccessibility switch { acc.Public => "public", acc.Internal => "internal", acc.Protected => "protected", acc.ProtectedOrInternal => "protected internal", acc.ProtectedAndInternal => "private protected", _ => "" };
	
	public static void ImplementInterfaceOrAbstractClass(int position = -1) {
		//note: ignores interface members that have default implementation. The same as in VS. To add such a member, type like `IExample.` and select from the list; it creates member code.
		
		if (!CodeInfo.GetContextAndDocument(out var cd, position)) return;
		var semo = cd.semanticModel;
		
		var thisType = semo.GetEnclosingNamedType2(cd.pos, out var node, out var declNode);
		if (thisType == null || thisType.TypeKind is not (TypeKind.Class or TypeKind.Struct)) return;
		
		var baseClass = thisType.BaseType.IsAbstract ? thisType.BaseType : null;
		if (baseClass == null && thisType.Interfaces.IsDefaultOrEmpty) return;
		
		var baseFromPos = position < 0 && node.GetAncestorOrThis<BaseTypeSyntax>() is BaseTypeSyntax bts ? semo.GetTypeInfo(bts.Type).Type as INamedTypeSymbol : null;
		
		List<(INamedTypeSymbol type, List<ISymbol> members)> types = new();
		bool implementInterfaces = false;
		if (baseFromPos != null) {
			_GetOfType(baseFromPos);
			_Interfaces(baseFromPos);
		} else {
			if (baseClass != null) _GetOfType(baseClass);
			_Interfaces(thisType);
		}
		
		void _Interfaces(INamedTypeSymbol t) { //gets direct base interfases and their all base interfaces. Unlike AllInterfaces, skips base interfaces of base classes.
			foreach (var v in t.Interfaces) {
				_GetOfType(v);
				_Interfaces(v);
			}
		}
		
		//note: GetAllUnimplementedMembersInThis gets not all members. Eg for ITreeViewItem skips properties that have default impl (but includes such methods). Or gets some garbage.
		void _GetOfType(INamedTypeSymbol t) {
			List<ISymbol> members = null;
			bool isInterface = t.TypeKind == TypeKind.Interface;
			foreach (var m in t.GetMembers()) {
				if (!m.IsAbstract) if (!isInterface || m.IsStatic || m.DeclaredAccessibility == acc.Private) continue;
				if (m is not (IMethodSymbol { MethodKind: MethodKind.Ordinary or MethodKind.UserDefinedOperator or MethodKind.Conversion } or IPropertySymbol or IEventSymbol)) continue;
				ISymbol k = isInterface ? thisType.FindImplementationForInterfaceMember(m) : thisType.FindImplementationForAbstractMember(m);
				//if (k != null && k.ContainingType != thisType) k = null;
				if (k == null) {
					if (members == null) types.Add((t, members = new()));
					members.Add(m);
				}
			}
			if (members != null) {
				members.Sort((x, y) => (y.IsAbstract ? 1 : 0) - (x.IsAbstract ? 1 : 0));
				implementInterfaces |= isInterface;
			}
			
			if (!isInterface && t.BaseType.IsAbstract) _GetOfType(t.BaseType);
		}
		
		if (types.Count == 0) {
			dialog.show("Found 0 unimplemented members", owner: App.Hmain);
			return;
		}
		
		bool explicitly;
		string buttons = implementInterfaces
			? "1 Implement\nLike 'public Type Member'|2 Implement explicitly\nLike 'Type Interface.Member'|0 Cancel"
			: "1 Implement|0 Cancel";
		switch (dialog.show("Implement", "This will add members that were not implemented.", buttons, flags: DFlags.CommandLinks, owner: App.Hmain)) {
		case 1: explicitly = false; break;
		case 2: explicitly = true; break;
		default: return;
		}
		
		position = declNode.CloseBraceToken.Span.Start;
		while (cd.code[position - 1] is ' ' or '\t') position--;
		
		var b = new StringBuilder();
		var format = CiText.s_symbolFullFormat.WithParameterOptions(CiText.s_symbolFullFormat.ParameterOptions & ~SymbolDisplayParameterOptions.IncludeOptionalBrackets);
		var formatExp = format.WithMemberOptions(SymbolDisplayMemberOptions.IncludeContainingType | SymbolDisplayMemberOptions.IncludeType | SymbolDisplayMemberOptions.IncludeParameters | SymbolDisplayMemberOptions.IncludeRef);
		
		var hsMembers = thisType.MemberNames.ToHashSet(); //nevermind method overloads, it's rare
		
		foreach (var (type, members) in types) {
			b.AppendLine().AppendLine("//" + type.ToMinimalDisplayString(semo, position, CiText.s_symbolFullFormat));
			
			bool isInterface = type.TypeKind == TypeKind.Interface;
			foreach (var v in members) {
				bool expl = false;
				if (isInterface) expl = explicitly || v.DeclaredAccessibility != acc.Public || !hsMembers.Add(v.Name);
				
				string append = null;
				switch (v) {
				case IMethodSymbol ims:
					if (ims.MethodKind == MethodKind.Ordinary) {
						append = ims.ReturnsVoid ? @" {

}" : @" {

	return default;
}";
					} else append = " => default;";
					break;
				case IPropertySymbol ips:
					if (!expl && isInterface) {
						if (ips.GetMethod != null && ips.GetMethod.DeclaredAccessibility != acc.Public) expl = true;
						if (ips.SetMethod != null && ips.SetMethod.DeclaredAccessibility != acc.Public) expl = true;
					}
					break;
				case IEventSymbol:
					append = !expl ? ";" : @" {
	add {  }
	remove {  }
}";
					break;
				default:
					continue;
				}
				
				b.AppendLine();
				if (isInterface) {
					if (!v.IsAbstract) b.AppendLine("//has default implementation");
					if (!expl) b.Append("public ");
					if (v.IsStatic) b.Append("static ");
				} else {
					b.Append(_AccToString(v));
					b.Append(" override ");
				}
				b.Append(v.ToMinimalDisplayString(semo, position, expl ? formatExp : format))
					.AppendLine(append);
			}
		}
		
		var text = b.ToString();
		text = text.Replace("] { get; set; }", @"] {
	get { return default; }
	set {  }
}"); //indexers
		text = text.RxReplace(@"[^\]] \{\K set; \}", @"
	set {  }
}"); //write-only properties
		
		text = CiUtil.IndentStringForInsertSimple(text, cd.sci, position, true, 1);
		
		cd.sci.aaaInsertText(true, position, text, addUndoPointAfter: true);
		cd.sci.aaaGoToPos(true, position);
		cd.sci.aaaSelect(true, position + text.Length, position);
		
		//tested: Microsoft.CodeAnalysis.CSharp.ImplementInterface.CSharpImplementInterfaceService works but the result is badly formatted (without spaces, etc). Internal, undocumented.
	}
}


================================================
FILE: Au.Editor/Edit/InsertCode.cs
================================================
extern alias CAW;

using Microsoft.CodeAnalysis;
using CAW::Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Text;
using Microsoft.CodeAnalysis.CSharp.Extensions;
using Microsoft.CodeAnalysis.Shared.Extensions;
using CAW::Microsoft.CodeAnalysis.Shared.Extensions;
using CAW::Microsoft.CodeAnalysis.Rename;
using acc = Microsoft.CodeAnalysis.Accessibility;

using Au.Controls;
using System.Windows;
using System.Windows.Controls;
using ToolLand;

namespace LA;

/// <summary>
/// Inserts various code in code editor. With correct indent etc.
/// Some functions can insert in other controls too.
/// </summary>
static class InsertCode {
	/// <summary>
	/// Parameters for <c>InsertCode.Statements</c>.
	/// </summary>
	/// <param name="s">Text. The function ignores "\r\n" at the end. Does nothing if null. If contains '\n', prepends/appends empty line to separate from surrounding code.</param>
	/// <param name="goTo">If text contains <c>`|`</c>, remove it and finally move caret there.</param>
	/// <param name="activateEditor">Activate editor window.</param>
	/// <param name="noFocus">Don't focus the editor control. Without this flag focuses it if window is active or activated.</param>
	/// <param name="selectNewCode"></param>
	/// <param name="makeVarName1"></param>
	/// <param name="renameVars">Variable names to rename in <i>s</i>.</param>
	public record InsertCodeParams(string s, bool goTo = false, bool activateEditor = false, bool noFocus = false, bool selectNewCode = false, bool makeVarName1 = false, (string oldName, string newName)[] renameVars = null);
	
	/// <summary>
	/// Inserts one or more statements at current line. With correct position, indent, etc.
	/// If editor is null or readonly or not C# file, prints in output.
	/// <para>
	/// If called in LA tools process or in a non-main LA thread, runs async in the main process/thread.
	/// </para>
	/// </summary>
	public static void Statements(InsertCodeParams p) {
		if (p.s == null) return;
		
		if (!process.IsLaMainThread_) {
			if (process.IsLaProcess_) App.Dispatcher.InvokeAsync(() => Statements(p));
			else WndCopyData.Send<char>(ScriptEditor.WndMsg_, 17, System.Text.Json.JsonSerializer.Serialize(p));
			return;
		}
		
		string s = p.s;
		bool separate = s.Contains('\n');
		
		if (!App.Hmain.IsVisible) App.ShowWindow();
		if (!CodeInfo.GetContextAndDocument(out var k, metaToo: true)) {
			print.it(s);
			return;
		}
		var root = k.syntaxRoot;
		var code = k.code;
		var pos = k.pos;
		var token = root.FindToken(pos);
		var node = token.Parent;
		
		//get the best valid insertion place
		
		bool havePos = false;
		var last = root.AttributeLists.LastOrDefault() as SyntaxNode
			?? root.Usings.LastOrDefault() as SyntaxNode
			?? root.Externs.LastOrDefault() as SyntaxNode
			?? root.GetDirectives(o => o is DefineDirectiveTriviaSyntax).LastOrDefault();
		if (last != null) {
			int e1 = last.FullSpan.End;
			if (havePos = pos <= e1) pos = e1;
		}
		
		if (!havePos) {
			var members = root.Members;
			if (members.Any()) {
				var g = members.LastOrDefault(o => o is GlobalStatementSyntax);
				int posAfterTLS = g?.FullSpan.End ?? members.First().FullSpan.Start;
				
				bool done1 = false;
				if (node is BlockSyntax) {
					done1 = node.Span.ContainsInside(pos);
				} else if (node is MemberDeclarationSyntax) {
					done1 = true;
					//don't use posAfterTLS if before the first type
					bool here = node == members.FirstOrDefault(o => o is not GlobalStatementSyntax) && pos <= node.SpanStart;
					pos = Math.Min(pos, here ? node.SpanStart : posAfterTLS);
				} else if (node is CompilationUnitSyntax && g != members[^1]) { //after types
					done1 = true;
					pos = Math.Min(pos, posAfterTLS);
				}
				if (!done1) {
					for (; node is not CompilationUnitSyntax; node = node.Parent) {
						//CiUtil.PrintNode(node);
						if (node is StatementSyntax) {
							var pa = node.Parent;
							if (node is BlockSyntax && pa is not (BlockSyntax or GlobalStatementSyntax)) continue;
							var span = node.Span;
							if (havePos = pos >= span.End && token.IsKind(SyntaxKind.CloseBraceToken)) pos = node.FullSpan.End;
							else if (havePos = pos >= span.Start) pos = span.Start;
							break;
						}
						if (node is MemberDeclarationSyntax) {
							pos = posAfterTLS;
							break;
						}
					}
				}
				
				havePos |= pos == posAfterTLS;
			}
		}
		
		if (k.meta.end > 0 && pos <= k.meta.end) {
			havePos = true;
			pos = k.meta.end;
			if (code.Eq(pos, "\r\n")) pos += 2; else if (code.Eq(pos, '\n')) pos++;
		}
		
		if (!havePos) { //if in comments or directive or disabled code, move to the start of trivia or line
			var trivia = root.FindTrivia(pos);
			var tk = trivia.Kind();
			if (tk is not (SyntaxKind.EndOfLineTrivia or SyntaxKind.None)) {
				if (tk == SyntaxKind.DisabledTextTrivia) {
					while (pos > 0 && code[pos - 1] != '\n') pos--;
				} else {
					pos = trivia.FullSpan.Start;
				}
				//rejected: move to the start of entire #if ... block.
				//	Rare, not easy, may be far, and maybe user wants to insert into disabled code.
			}
		}
		
		//rename symbols in s if need
		
		try { Util.RenameNewSymbols(ref s, k, node, pos, p.makeVarName1, p.renameVars); }
		catch (Exception e1) { Debug_.Print(e1); }
		
		//indent, newlines
		
		string breakLine = null;
		for (; pos > 0 && code[pos - 1] != '\n'; pos--) if (code[pos - 1] is not (' ' or '\t')) { breakLine = "\r\n"; break; }
		int replTo = CiUtil.SkipSpace(code, pos);
		
		var d = k.sci;
		
		var t2 = root.FindToken(pos); if (t2.SpanStart >= pos) t2 = t2.GetPreviousToken();
		bool afterOpenBrace = t2.IsKind(SyntaxKind.OpenBraceToken);
		bool beforeCloseBrace = replTo < code.Length && code[replTo] == '}';
		
		int indent = d.aaaLineIndentFromPos(true, pos);
		if (afterOpenBrace && breakLine != null && !(t2.Parent is BlockSyntax bs1 && bs1.Parent is GlobalStatementSyntax)) indent++;
		else if (beforeCloseBrace) indent++;
		
		var b = new StringBuilder(breakLine);
		if (separate && !afterOpenBrace && !s.Starts("{\r\n") && pos > 0) {
			int nn = 0; for (int i = pos; --i >= 0 && code[i] <= ' ';) if (code[i] == '\n' && ++nn == 2) break;
			if (nn < 2) b.AppendIndent(indent).AppendLine();
		}
		
		b.AppendCodeWithIndent(s, indent, andNewline: true);
		
		if (separate && !s.Ends("\n}") && replTo < code.Length && code[replTo] is not ('\r' or '}')) {
			b.AppendIndent(indent).AppendLine();
		}
		if (indent > 0) b.AppendIndent(beforeCloseBrace ? indent - 1 : indent);
		s = b.ToString();
		
		//insert
		
		int go = -1;
		if (p.goTo) {
			go = s.Find("`|`");
			if (go >= 0) s = s.Remove(go, 3);
		}
		
		d.aaaSelect(true, pos, replTo);
		using (new CodeInfo.PastingEtc(d, silent: true)) {
			d.aaaReplaceSel(s);
			
			if (go >= 0) d.aaaGoToPos(true, pos + go);
			else if (p.selectNewCode) d.aaaSelect(true, pos + s.TrimEnd('\t').Length, pos, true);
			//else if (p.goToStart)) d.aaaGoToPos(true, pos);
		}
		
		var w = d.AaWnd.Window;
		if (p.activateEditor) w.ActivateL();
		if (!p.noFocus && w.IsActive) d.Focus();
	}
	
	/// <summary>
	/// Inserts text in code editor at current position, not as new line, replaces selection.
	/// If editor is null or readonly, does nothing.
	/// </summary>
	/// <param name="s">If contains <c>`|`</c>, removes it and moves caret there; must be single line.</param>
	public static void TextSimply(string s) {
		Debug.Assert(App.IsMainThread);
		var d = Panels.Editor.ActiveDoc;
		if (d == null || d.aaaIsReadonly) return;
		TUtil.InsertTextIn(d, s);
	}
	
	/// <summary>
	/// Inserts code 'using ns;\r\n' in correct place in editor text, unless it is already exists.
	/// Returns true if inserted.
	/// </summary>
	/// <param name="ns">Namespace, eg "System.Diagnostics". Can be multiple, separated with semicolon (can be whitespce around).</param>
	/// <param name="missing">Don't check whether the usings exist. Caller knows they don't exist.</param>
	public static bool UsingDirective(string ns, bool missing = false) {
		Debug.Assert(App.IsMainThread);
		if (!CodeInfo.GetContextAndDocument(out var k, 0, metaToo: true)) return false;
		var namespaces = ns.Split(';', StringSplitOptions.TrimEntries);
		int i = FindUsingsInsertPos(k, missing ? null : namespaces);
		if (i < 0) return false;
		
		var b = new StringBuilder();
		if (i > 0 && k.code[i - 1] != '\n') b.AppendLine();
		foreach (var v in namespaces) {
			if (v != null) b.Append("using ").Append(v).AppendLine(";");
		}
		if (i == k.code.Length || k.code[i] is not ('\r' or '\n')) b.AppendLine();
		
		k.sci.aaaInsertText(true, i, b.ToString(), addUndoPointAfter: true, restoreFolding: true);
		
		return true;
		
		//tested: CompilationUnitSyntax.AddUsings isn't better than this code. Does not skip existing. Does not add newlines. Does not skip comments etc. Did't test #directives.
	}
	
	/// <summary>
	/// Finds where new using directives can be inserted:
	/// <br/>• after existing using directives
	/// <br/>• or at 0
	/// <br/>• or after extern aliases
	/// <br/>• or after #directives
	/// <br/>• or after meta
	/// <br/>• or after doc comments
	/// <br/>• or after 1 comments line.
	/// If namespaces!=null, clears existing namespaces in it (sets =null); if all cleared, returns -1.
	/// </summary>
	public static int FindUsingsInsertPos(CodeInfo.Context k, string[] namespaces = null) {
		//In namespaces clears elements that exist in e. If all cleared, sets namespaces=null and returns true.
		bool _ClearExistingUsings(IEnumerable<UsingDirectiveSyntax> e) {
			int n = namespaces.Count(o => o != null); //if (n == 0) return;
			foreach (var u in e) {
				int i = Array.IndexOf(namespaces, u.Name.ToString());
				if (i >= 0) {
					namespaces[i] = null;
					if (--n == 0) { namespaces = null; return true; }
				}
			}
			return false;
		}
		
		//at first look for "global using"
		var semo = k.semanticModel;
		if (namespaces != null && _ClearExistingUsings(CiUtil.GetAllGlobalUsings(semo))) return -1;
		
		int end = -1;
		var cu = k.syntaxRoot;
		
		//then look in current namespace, ancestor namespaces, compilation unit
		int pos = k.sci.aaaCurrentPos16;
		for (var node = cu.FindToken(pos).Parent; node != null; node = node.Parent) {
			SyntaxList<UsingDirectiveSyntax> usings; SyntaxList<ExternAliasDirectiveSyntax> externs;
			if (node is NamespaceDeclarationSyntax ns) {
				if (pos <= ns.OpenBraceToken.SpanStart || pos > ns.CloseBraceToken.SpanStart) continue;
				usings = ns.Usings; externs = ns.Externs;
			} else if (node is CompilationUnitSyntax) {
				usings = cu.Usings; externs = cu.Externs;
			} else continue;
			
			if (usings.Any()) {
				if (namespaces != null && _ClearExistingUsings(usings)) return -1;
				if (end < 0) end = usings[^1].FullSpan.End;
			} else if (externs.Any()) {
				if (end < 0) end = externs[^1].FullSpan.End;
			}
			if (end >= 0 && namespaces == null) break;
		}
		
		if (end < 0) { //insert at the start but after #directives and certain comments
			int end2 = -1;
			foreach (var v in cu.GetLeadingTrivia()) if (v.IsDirective) end2 = v.FullSpan.End; //skip directives
			if (end2 < 0) {
				end2 = k.meta.end; //skip meta
				if (end2 == 0) if (k.code.RxMatch(@"^(///.*\R)+(?=\R|$)", 0, out RXGroup g1)) end2 = g1.End; //skip ///comments
				if (k.code.RxMatch(@"\s*//\.(?: .*)?\R", 0, out RXGroup g2, RXFlags.ANCHORED, end2..)) end2 = g2.End; //skip //. used for folding
			}
			end = end2;
		}
		return end;
	}
	
	/// <summary>
	/// Inserts meta comments.
	/// </summary>
	/// <param name="s">One or more meta options, like <c>"c A; r B;"</c>.</param>
	/// <returns>true if changed documnt text.</returns>
	public static bool MetaComment(string s) {
		Debug.Assert(App.IsMainThread);
		if (Panels.Editor.ActiveDoc is not { EFile.IsCodeFile: true } doc) return false;
		var meta = new MetaCommentsParser(doc.aaaText);
		var meta2 = new MetaCommentsParser($"/*/ {s} /*/");
		meta.Merge(meta2);
		return meta.Apply();
	}
	
	//rejected
	//public static void AddFileDescription() {
	//	var doc = Panels.Editor.ActiveDoc;
	//	if (!doc.EFile.IsCodeFile) return;
	//	doc.aaaInsertText(false, 0, "/// Description\r\n\r\n");
	//	doc.aaaSelect(false, 4, 15, makeVisible: true);
	//}
	
	public static void SurroundPragmaWarningFormat() {
		CiSnippets.Surround("""
#pragma warning disable format
${SELECTED_TEXT}$0
#pragma warning restore format
""");
	}
	
	public static void AddClassProgram() {
		if (!CodeInfo.GetContextAndDocument(out var cd) /*|| !cd.sci.EFile.IsScript*/) return;
		int start, end = cd.code.Length;
		var members = cd.syntaxRoot.Members;
		if (members.Any()) {
			start = _FindRealStart(false, members[0]);
			if (members[0] is not GlobalStatementSyntax) end = start;
			else if (members.FirstOrDefault(v => v is not GlobalStatementSyntax) is SyntaxNode sn) end = _FindRealStart(true, sn);
			
			int _FindRealStart(bool needEnd, SyntaxNode sn) {
				int start = sn.SpanStart;
				//find first empty line in comments before
				var t = sn.GetLeadingTrivia();
				for (int i = t.Count; --i >= 0;) {
					var v = t[i];
					int ss = v.SpanStart;
					if (ss < cd.meta.end) break;
					//if (needEnd) { print.it($"{v.Kind()}, '{v}'"); continue; }
					var k = v.Kind();
					if (k == SyntaxKind.EndOfLineTrivia) {
						while (i > 0 && t[i - 1].IsKind(SyntaxKind.WhitespaceTrivia)) i--;
						if (i == 0 || t[i - 1].IsKind(k)) return needEnd ? ss : v.Span.End;
					} else if (k == SyntaxKind.SingleLineCommentTrivia) {
						if (cd.code.Eq(ss, "//.") && char.IsWhiteSpace(cd.code[ss + 3])) break;
					} else if (k is not (SyntaxKind.WhitespaceTrivia or SyntaxKind.MultiLineCommentTrivia or SyntaxKind.SingleLineDocumentationCommentTrivia or SyntaxKind.MultiLineDocumentationCommentTrivia)) {
						break; //eg #directive
					}
				}
				return start;
			}
		} else start = end;
		//CiUtil.HiliteRange(start, end); return;
		
		CiSnippets.Surround("""
class Program {
	static void Main(string[] a) => new Program(a);
	Program(string[] args) {
${SELECTED_TEXT}$0
	}
}
""", start..end);
	}
	
	/// <summary>
	/// Called from Dicons.
	/// </summary>
	/// <param name="icon">Like "*Pack.Name #color".</param>
	public static void SetMenuToolbarItemIcon(string icon) {
		if (!CodeInfo.GetDocumentAndFindNode(out var cd, out var node, -2)) return;
		var semo = cd.semanticModel;
		
		//find nearest argumentlist and its method symbol
		BaseArgumentListSyntax arglist = null; IMethodSymbol method = null;
		var es = node.FirstAncestorOrSelf<ExpressionStatementSyntax>()?.Expression;
		if (es is InvocationExpressionSyntax ies) { //m.Add("name", "image"); or m.Submenu("name", , "image"); etc
			arglist = ies.ArgumentList;
			method = semo.GetSymbolInfo(ies.Expression).Symbol as IMethodSymbol;
		} else if (es is AssignmentExpressionSyntax aes && aes.Left is ElementAccessExpressionSyntax eaes) { //m["name", "image"] = ;
			arglist = eaes.ArgumentList;
			if (semo.GetSymbolInfo(eaes).Symbol is IPropertySymbol ips && ips.IsIndexer) method = ips.SetMethod;
		} else return;
		if (method == null) return;
		
		//get index of parameter of type MTImage
		var timage = semo.Compilation.GetTypeByMetadataName("Au.Types." + nameof(MTImage)); if (timage == null) return;
		int paramIndex = 0; string paramName = null;
		foreach (var p in method.Parameters) {
			if (p.Type == timage) { paramName = p.Name; break; }
			paramIndex++;
		}
		if (paramIndex == method.Parameters.Length) return;
		
		//find image argument
		ArgumentSyntax arg = null; int i = 0;
		foreach (var a in arglist.Arguments) {
			var nc = a.NameColon;
			if (nc != null) {
				if (nc.Name.Identifier.Text == paramName) arg = a;
			} else {
				if (i == paramIndex) arg = a;
			}
			if (arg != null) break;
			i++;
		}
		
		//replace or insert
		int replFrom, replTo; string prefix = null, suffix = null;
		if (arg != null) {
			var span = arg.Span;
			replFrom = span.Start;
			replTo = span.End;
		} else if (paramIndex < arglist.Arguments.Count) {
			replFrom = replTo = arglist.Arguments[paramIndex].SpanStart;
			suffix = ", ";
		} else {
			replFrom = replTo = arglist.Span.End - 1;
			if (arglist.Arguments.Count > 0) prefix = ", ";
		}
		icon = $"{prefix}{paramName}: \"{icon}\"{suffix}";
		//print.it(cd.pos, replFrom, replTo, icon);
		
		cd.sci.aaaReplaceRange(true, replFrom, replTo, icon);
	}
	
	public static class Util {
		/// <summary>
		/// If <i>s</i> contains local variable declarations, replaces the variable names if they exist in current document in scope at caret position.
		/// </summary>
		public static void RenameNewSymbols(ref string s, int pos, bool makeVarName1 = false) {
			if (!CodeInfo.GetContextAndDocument(out var k)) return;
			var token = k.syntaxRoot.FindToken(k.pos);
			var node = token.Parent;
			try { RenameNewSymbols(ref s, k, node, pos, makeVarName1); }
			catch (Exception e1) { Debug_.Print(e1); }
		}
		
		/// <summary>
		/// If <i>s</i> contains local variable declarations, replaces the variable names if they exist in <i>k.document</i> in scope at <i>node</i>/<i>pos</i>.
		/// </summary>
		/// <param name="makeVarName1">Also rename local variables declared like `var v` with `var v1` at root level.</param>
		/// <param name="rename">Explicit renamings.</param>
		public static void RenameNewSymbols(ref string s, CodeInfo.Context k, SyntaxNode node, int pos, bool makeVarName1, (string oldName, string newName)[] rename = null) {
			//find the function or TLS where to look for declared symbols in editor code
			var scope = node;
			for (; scope is not CompilationUnitSyntax; scope = scope.Parent) {
				if (scope is BaseMethodDeclarationSyntax or LocalFunctionStatementSyntax or AnonymousFunctionExpressionSyntax) {
					if (scope.Span.ContainsInside(pos)) break;
				}
			}
			
			//modified Roslyn's GetAllDeclaredSymbols. Would be difficult to use it.
			static void _GetDeclaredSymbols(SemanticModel semo, SyntaxNode node, List<ISymbol> symbols, HashSet<string> names, HashSet<string> hVar1, int level = 0) {
				if (node is not CompilationUnitSyntax && semo.GetDeclaredSymbol(node) is ISymbol sym) {
					symbols?.Add(sym);
					names?.Add(sym.Name);
					if (hVar1 != null) if (level == 4 && node.Parent.Parent is LocalDeclarationStatementSyntax && sym.Name is var s && !s.Ends('1')) hVar1.Add(s);
				}
				if (level > 0 && node is LocalFunctionStatementSyntax or BaseTypeDeclarationSyntax) return;
				foreach (var n in node.ChildNodes()) {
					if (n is AnonymousFunctionExpressionSyntax or AnonymousObjectCreationExpressionSyntax or TupleExpressionSyntax) continue; //lambda etc
					_GetDeclaredSymbols(semo, n, symbols, names, hVar1, level + 1);
				}
			}
			
			HashSet<string> h1 = new(); //names of symbols declared in scope. If makeVarName1, also names of local variables declared in s like `var v` at root level.
			
			//get symbols declared in s
			List<ISymbol> a2 = new();
			HashSet<string> h2 = new();
			using var ws2 = new AdhocWorkspace();
			var doc2 = CiUtil.CreateDocumentFromCode(ws2, s, false);
			var semo2 = doc2.GetSemanticModelAsync().Result_();
			_GetDeclaredSymbols(semo2, semo2.Root, a2, h2, makeVarName1 ? h1 : null);
			//print.it("---- h2 ----"); foreach (var v in h2) print.it(v);
			if (h2.Count == 0) return;
			
			//get names of symbols declared in scope (editor code)
			var semo1 = k.document.GetSemanticModelAsync().Result_();
			_GetDeclaredSymbols(semo1, scope, null, h1, null);
			//print.it("---- h1 ----"); foreach (var v in h1) print.it(v);
			if (h1.Count == 0) return;
			
			bool renamed = false;
			var sol = doc2.Project.Solution;
			
			//in s rename symbols that exist in scope (editor code) or renameVars
			foreach (var sym in a2) {
				string name = sym.Name, name2 = null;
				
				if (rename != null) {
					foreach (var v in rename)
						if (v.oldName == name) {
							name = name2 = v.newName;
							if (!makeVarName1 && !h1.Contains(name)) goto g2;
							goto g1;
						}
				}
				
				if (!h1.Contains(name)) continue;
				g1:
				//create unique name and add to hs1
				int i = 1;
				if (name.RxMatch(@"\d+$", 0, out RXGroup g)) {
					i = Math.Max(i, name.ToInt(g.Start) + 1);
					name = name[..g.Start];
				}
				while (h2.Contains(name2 = name + i) || !h1.Add(name2)) i++;
				//print.it(sym.Name, name2);
				g2:
				var opt1 = new SymbolRenameOptions();
				sol = Renamer.RenameSymbolAsync(sol, sym, opt1, name2).Result_();
				h2.Remove(sym.Name);
				renamed = true;
			}
			if (renamed) s = sol.GetDocument(doc2.Id).GetTextAsync().Result_().ToString();
			
			//rejected: don't rename if variables in both codes are in unrelated { blocks }.
			//	Tested: in most cases better like now.
			
			//rejected: also replace names that match reserved keywords.
			//	This program will not create such names.
		}
	}
}


================================================
FILE: Au.Editor/Edit/ModifyCode.cs
================================================
extern alias CAW;

using Microsoft.CodeAnalysis;
using CAW::Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Text;
using Microsoft.CodeAnalysis.Shared.Extensions;
using CAW::Microsoft.CodeAnalysis.Shared.Extensions;
using Microsoft.CodeAnalysis.CSharp.Extensions;
using Microsoft.CodeAnalysis.Shared.Utilities;
using CAW::Microsoft.CodeAnalysis.Shared.Utilities;
using CAW::Microsoft.CodeAnalysis.FindSymbols;
using Microsoft.CodeAnalysis.Formatting;
using CAW::Microsoft.CodeAnalysis.Formatting;
using Microsoft.CodeAnalysis.CSharp.Formatting;

namespace LA;

static class ModifyCode {
	/// <summary>
	/// Comments out (adds // or /**/) or uncomments selected text or current line.
	/// </summary>
	/// <param name="comment">Comment out (true), uncomment (false) or toggle (null).</param>
	/// <param name="notSlashStar">Comment out lines, even if there is not-full-line selection.</param>
	public static void Comment(bool? comment, bool notSlashStar = false) {
		//how to comment/uncomment: // or /**/
		if (!CodeInfo.GetContextAndDocument(out var cd, -2, metaToo: true)) return;
		var doc = cd.sci;
		int selStart = cd.pos, selEnd = doc.aaaSelectionEnd16, replStart = selStart, replEnd = selEnd;
		bool com, slashStar = false, isSelection = selEnd > selStart;
		string code = cd.code, s = null;
		var root = cd.syntaxRoot;
		
		if (!notSlashStar) {
			var trivia = root.FindTrivia(selStart);
			if (trivia.IsMultiLineComment()) {
				if (selStart > cd.meta.start && selEnd < cd.meta.end) {
					if (slashStar = !isSelection) {
						var t = MetaComments.EnumOptions(code, new(cd.meta.start, cd.meta.end)).FirstOrDefault(o => selStart >= o.nameStart && selEnd <= o.valueEnd);
						if (t.code == null) return;
						if (comment is null) comment = !t.IsDisabled; else if (comment == t.IsDisabled) return;
						replStart = replEnd = t.nameStart;
						if (comment == true) s = "//"; else replEnd += code.Eq(replStart, "//") ? 2 : 1;
					} else notSlashStar = true;
				} else {
					var span = trivia.Span;
					if (slashStar = comment != true && selEnd <= trivia.Span.End) {
						(replStart, replEnd) = span;
						s = code[(replStart + 2)..(replEnd - 2)];
					} else notSlashStar = true;
				}
			}
		}
		
		if (!slashStar) {
			//get the start and end of lines containing selection
			while (replStart > 0 && code[replStart - 1] != '\n') replStart--;
			if (!(replEnd > replStart && code[replEnd - 1] == '\n')) {
				while (replEnd < code.Length && code[replEnd] is not ('\r' or '\n')) replEnd++;
				if (replEnd > replStart && code.Eq(replEnd, "\r\n")) replEnd += 2; //prevent on Undo moving the caret to the end of line and possibly hscrolling
			}
			if (replEnd == replStart) return;
			
			//are all lines //comments ?
			bool allLinesComments = true;
			for (int i = replStart; i < replEnd; i++) {
				i = CiUtil.SkipSpace(code, i);
				if (!(code.At_(i) is '\r' or '\n')) {
					if (root.FindTrivia(i).Kind() is var tk && !(tk is SyntaxKind.SingleLineCommentTrivia || (tk is SyntaxKind.DisabledTextTrivia or SyntaxKind.MultiLineCommentTrivia or SyntaxKind.MultiLineDocumentationCommentTrivia && code.Eq(i, "//")))) {
						allLinesComments = false;
						break;
					}
				}
				i = code.IndexOf('\n', i, replEnd - i); if (i < 0) break;
			}
			if (allLinesComments) {
				com = comment ?? false;
			} else {
				if (comment == false) return;
				com = true;
				slashStar = isSelection && !notSlashStar && (selStart > replStart || selEnd < replEnd);
				if (slashStar) { replStart = selStart; replEnd = selEnd; }
			}
			
			s = code[replStart..replEnd];
			if (slashStar) {
				s = "/*" + s + "*/";
			} else {
				if (com) {
					s.RxFindAll(@"(?m)^[\t ]*(.*)\R?", out RXMatch[] a);
					//find smallest common indentation
					int indent = 0; //tabs*4 or spaces*1
					foreach (var m in a) {
						if (m[1].Length == 0) continue;
						int n = 0; for (int i = m.Start; i < m[1].Start; i++) if (s[i] == ' ') n++; else n = (n & ~3) + 4;
						indent = indent == 0 ? n : Math.Min(indent, n);
						if (indent == 0) break;
					}
					//insert // in lines containing code
					var b = new StringBuilder();
					foreach (var m in a) {
						if (m[1].Length == 0) {
							b.Append(s, m.Start, m.Length);
						} else {
							int i = m.Start; for (int n = 0; n < indent; i++) if (s[i] == ' ') n++; else n = (n & ~3) + 4;
							b.Append(s, m.Start, i - m.Start).Append("//").Append(s, i, m.End - i);
						}
					}
					s = b.ToString();
				} else { //remove single // from all lines
					s = s.RxReplace(@"(?m)^([ \t]*)//", "$1");
				}
			}
		}
		
		bool caretAtEnd = isSelection && doc.aaaCurrentPos16 == selEnd;
		doc.EReplaceTextGently(replStart, replEnd, s);
		if (isSelection) {
			int i = replStart, j = replStart + s.Length;
			doc.aaaSelect(true, caretAtEnd ? i : j, caretAtEnd ? j : i);
		}
	}
	
	//public static string Format(ref int from, ref int to) {
	//	if (!CodeInfo.GetContextAndDocument(out var cd, from, metaToo: true)) return null;
	//	return Format(cd, ref from, ref to);
	//}
	
	public static void Format(bool selection) {
		if (!CodeInfo.GetContextAndDocument(out var cd, -2, metaToo: true)) return;
		
		var doc = cd.sci;
		int from, to, selStart = cd.pos, selEnd = doc.aaaSelectionEnd16;
		if (selection) {
			(from, to) = (selStart, selEnd);
			if (from == to) {
				var node = cd.syntaxRoot.FindToken(from).Parent.GetStatementEtc(from);
				if (node == null) return;
				(from, to) = node.FullSpan;
			}
		} else {
			(from, to) = (0, cd.code.Length);
		}
		
		if (to > from && Format(cd, ref from, ref to, ref selStart, ref selEnd) is { } a) {
			_FormatReplace(cd, a);
			doc.aaaSelect(true, selStart, selEnd);
		}
	}
	
	/// <summary>
	/// Formats text of the specified range.
	/// </summary>
	public static void Format(CodeInfo.Context cd, int from, int to) {
		int pos = cd.sci.aaaCurrentPos16;
		if (Format(cd, ref from, ref to, ref pos, ref pos) is { } a) {
			_FormatReplace(cd, a);
			if (pos >= from || pos <= to) cd.sci.aaaCurrentPos16 = pos;
		}
	}
	
	static void _FormatReplace(CodeInfo.Context cd, List<TextChange> a) {
		using var undo = a.Count < 2 ? default : cd.sci.ENewUndoAction();
		for (int i = a.Count; --i >= 0;) {
			var c = a[i];
			cd.sci.aaaReplaceRange(true, c.Span.Start, c.Span.End, c.NewText);
		}
	}
	
	/// <summary>
	/// Formats text of the specified range.
	/// </summary>
	/// <param name="cd"></param>
	/// <param name="from">Start of range. The function may adjust it to span horizontal whitespace before.</param>
	/// <param name="to">End of range. The function may adjust it to exclude newline after.</param>
	/// <param name="selStart">Selection start. The function adjusts it to match the formatted text. Can be -1 if don't need.</param>
	/// <param name="selEnd">Selection end. The function adjusts it to match the formatted text. Can be -1 if don't need. Can be the same variable as <i>selStart</i>.</param>
	/// <returns>Text changes in the final range. Or null if no changes.</returns>
	public static List<TextChange> Format(CodeInfo.Context cd, ref int from, ref int to, ref int selStart, ref int selEnd) {
		string code = cd.code;
		Debug.Assert(code.AsSpan(..to).Eq(cd.sci.aaaText.AsSpan(..to)));
		
		//exclude newline at the end. Else formats entire leading trivia of next token.
		//	Never mind: anyway formats if the last selected line is //comment.
		if (to < code.Length) {
			if (to - from > 0 && code[to - 1] == '\n') to--;
			if (to - from > 0 && code[to - 1] == '\r') to--;
		}
		if (to == from) return null;
		
		//include whitespace before. Else _Format can't detect \r\n before when indented.
		while (from > 0 && code[from - 1] is '\t' or ' ') from--;
		
		if (!_Format(cd, from, to, out var a)) return null;
		
		int i1 = from, caret1 = selStart, caret2 = selEnd, moveCaret1 = 0, moveCaret2 = 0;
		for (int i = 0; i < a.Count; i++) {
			var v = a[i];
			var newText = v.NewText;
			var (cStart, cEnd) = v.Span;
			
			_Caret(caret1, ref moveCaret1);
			_Caret(caret2, ref moveCaret2);
			
			void _Caret(int caret, ref int moveCaret) {
				if (caret >= cEnd) {
					if (caret == cEnd && cStart == cEnd && caret == caret1 && caret2 > caret) return; //inserting text at caret1. Eg adding indent when caret1 is at SOL. Let selStart remain at SOL.
					moveCaret += cStart - cEnd + newText.Length;
				} else if (caret > cStart) moveCaret += cStart - caret + newText.Length;
			}
		}
		
		caret1 += moveCaret1;
		if (caret2 >= 0) caret2 = Math.Max(caret2 + moveCaret2, caret1);
		selStart = caret1;
		selEnd = caret2;
		
		return a;
	}
	
	static bool _Format(CodeInfo.Context cd, int from, int to, out List<TextChange> ac, string code = null) {
		ac = null;
		if ((uint)(to - from) > 500_000) return false; //too slow
		
		bool changedCode = code != null;
		code ??= cd.code;
		string code0 = code;
		var root = cd.syntaxRoot;
		
		//workaround for some nasty Roslyn features that can't be changed with options:
		//	Removes tabs from empty lines.
		//	If next line after code//comment1 is //comment2, aligns //comment2 with //comment1.
		//Before formatting, in blank lines add a marker (doc comment). The same in lines containing only //comment.
		//Other ways: 1. Modify Roslyn code; too difficult etc. 2. Fix formatted code; not 100% reliable.
		const string c_mark = "///\a\b"; const int c_markLen = 5;
		int nw = (s_rx1 ??= new(@"(?m)^\h*\K(?=\R|//(?!/(?!/)))")).Replace(code, c_mark, out code, range: from..to);
		if (nw > 0 || changedCode) {
			root = root.SyntaxTree.WithChangedText(SourceText.From(code)).GetCompilationUnitRoot();
			if (root.GetText().Length != code.Length) { Debug_.Print("bad new code"); return false; }
		}
		
		//include \r\n before. Else may not correct indent.
		//	never mind: then formats all trivia before. We'll skip it.
		if (from > 0 && code[from - 1] == '\n') from--;
		if (from > 0 && code[from - 1] == '\r') from--;
		//never mind: does not add space before statement when *from* is after eg `{` or `}` or `;`.
		//	VS adds space or newline when using "Format selection", but not when auto-format.
		
		try { ac = Formatter.GetFormattedTextChanges(root, TextSpan.FromBounds(from, to + nw * c_markLen), cd.document.Project.Solution.Services, FormattingOptions) as List<TextChange>; }
		catch (Exception e1) { Debug_.Print(e1); return false; } //https://www.libreautomate.com/forum/showthread.php?tid=7622
		if (ac.Count == 0) return false;
		
		//part 2 of the workaround. Remove marker traces from ac. Then ac will match the original code (the caller's version).
		if (nw > 0) {
			//_PrintFormattingTextChanges("BEFORE", code, ac);
			
			var aInserted = new int[nw];
			for (int i = 0, j = 0; i < nw; j += c_markLen) aInserted[i++] = j = code.Find("///\a\b", j);
			
			for (int i = 0; i < ac.Count; i++) {
				var v = ac[i];
				
				//some changes contain marks
				var s = v.NewText; int lenRemoved = 0;
				if (s.Length >= c_markLen) { s = s.Replace(c_mark, null); lenRemoved = v.NewText.Length - s.Length; }
				
				int startOfChange = v.Span.Start, nInsertedBefore = 0;
				while (nInsertedBefore < nw && aInserted[nInsertedBefore] < startOfChange) nInsertedBefore++;
				
				if (nInsertedBefore > 0 || lenRemoved > 0) ac[i] = new(new(startOfChange - nInsertedBefore * c_markLen, v.Span.Length - lenRemoved), s);
			}
			
			code = code0;
			//_PrintFormattingTextChanges("AFTER", code, ac);
		}
		
		//remove fake changes. Can be many.
		for (int i = 0; i < ac.Count; i++) {
			var v = ac[i];
			if (code.AsSpan(v.Span.ToRange()).Eq(v.NewText)) ac[i] = default;
		}
		ac.RemoveAll(static o => o.NewText == null);
		if (ac.Count == 0) return false;
		
		//_PrintFormattingTextChanges("CHANGES", code, ac);
		
		for (int i = 0; i < ac.Count; i++) {
			var v = ac[i];
			if (v.Span.IsEmpty || v.NewText.Length == 0) continue;
			
			//Some changes contain unchanged text at the start or end. Eg comments and/or newlines.
			//	If a change contain newlines, it would delete markers etc. Also may span the start or end of the formatting range.
			//	Remove such unchanged text from the change.
			RStr sp1 = code.AsSpan(v.Span.ToRange()), sp2 = v.NewText;
			int commonStart = StringUtil.CommonPrefix(sp1, sp2);
			if (commonStart > 0) { sp1 = sp1[commonStart..]; sp2 = sp2[commonStart..]; }
			int commonEnd = StringUtil.CommonSuffix(sp1, sp2);
			if (commonEnd > 0) { sp1 = sp1[..^commonEnd]; sp2 = sp2[..^commonEnd]; }
			if (commonStart + commonEnd > 0) ac[i] = v = new(TextSpan.FromBounds(v.Span.Start + commonStart, v.Span.End - commonEnd), sp2.ToString());
			
			//Some changes can be multiline. Eg when code contains `//comment\r\n\r\n//comment\r\n\r\n`. Would delete markers etc. Split.
			if (sp1.Contains('\n')) {
				var a1 = code.Lines(v.Span.ToRange(), preferMore: true);
				var a2 = v.NewText.Lines(.., preferMore: true);
				if (a1.Length != a2.Length) {
					//Debug_.Print(v); //usually it's OK. Eg `foo\n{` -> `foo {`.
				} else {
					bool insert = false;
					for (int j = 0; j < a1.Length; j++) {
						if (a1[j].Length == a2[j].Length && code.Eq(a1[j].Range, v.NewText.AsSpan(a2[j].Range))) continue;
						TextChange k = new(new(a1[j].start, a1[j].Length), v.NewText[a2[j].Range]);
						if (!insert) { insert = true; ac[i] = k; } else ac.Insert(++i, k);
					}
				}
			}
		}
		
		//remove changes that are not in the range. Most likely after.
		for (int i = ac.Count; --i >= 0;) {
			var v = ac[i];
			var (cStart, cEnd) = v.Span;
			
			if (cStart < from || cEnd > to || (cEnd == to && v.NewText.Length == 0)) {
				//Debug_.Print($"a TextChange not in the formatting range {from..to}: {v}");
				Debug_.PrintIf(cStart < from && cEnd > from);
				Debug_.PrintIf(cEnd > to && cStart < to);
				ac.RemoveAt(i--);
			}
		}
		
		return ac.Count > 0;
		
		//BAD: Roslyn does not format multiline collection initializers.
		//	https://github.com/dotnet/roslyn/issues/8269
	}
	static regexp s_rx1;
	
#if DEBUG
	static void _PrintFormattingTextChanges(string header, string code, IList<TextChange> a) {
		print.it("----", header);
		foreach (var v in a) {
			if (code.AsSpan(v.Span.ToRange()).Eq(v.NewText)) print.it($"<><c gray><\a>{v}</\a><>");
			else print.it($"<><c green><\a>{v}</\a><>, <c blue>\"<\a>{code[v.Span.ToRange()]}</\a>\"<>");
		}
	}
#endif
	
	/// <summary>
	/// Formats code for inserting in current document at <i>start</i>.
	/// If end &gt; <i>start</i> - for replacing text at <c>start..end</c>.
	/// May decrease <i>start</i>; does it before calling <i>changes</i>.
	/// </summary>
	/// <returns><c>true</c> if formatted.</returns>
	public static bool FormatForInsert(ref string s, ref int start, int end, Action<IList<TextChange>> changes = null) {
		if (!CodeInfo.GetContextAndDocument(out var cd, start, metaToo: true) || s.NE()) return false;
		
		var code = cd.code.ReplaceAt(start..end, s);
		int end2 = start + s.Length;
		int start2 = start; while (start2 > 0 && cd.code[start2 - 1] is '\t' or ' ') start2--; //include whitespace before. Else _Format can't detect \r\n before when indented.
		
		if (!_Format(cd, start2, end2, out var a, code)) return false;
		
		for (int i = a.Count; --i >= 0;) {
			var v = a[i];
			int ss = v.Span.Start, se = v.Span.End;
			if (ss < start2 && se >= start2 && se < end2
				&& !(se == start2 && v.NewText == " " && cd.code.Eq(se - 1, '\n')) //formatter bug: in TLS replaces `A\n{B` with `A {B`
				) {
				int n = v.NewText.AsSpan().TrimEnd("\t ").Length;
				a[i] = new(TextSpan.FromBounds(start2, se), v.NewText[n..]);
			} else {
				if (ss < start2 || se > end2 || code.Eq(ss..se, v.NewText)) a.RemoveAt(i);
				else if (v.NewText.NE() && se - ss == 1 && code.Eq((ss - 2)..(ss + 2), "{  }")) a.RemoveAt(i); //don't replace `{  }` with `{ }` eg in snippet
			}
		}
		if (a.Count == 0) return false;
		
		//_PrintFormattingTextChanges("CHANGES", code, a);
		
		start = start2;
		if (changes != null) {
			//if (start2 < start) s = string.Concat(cd.code.AsSpan(start2..start), s); //currently not used
			changes(a);
		}
		
		var b = new StringBuilder();
		int k = start;
		foreach (var v in a) {
			b.Append(code, k, v.Span.Start - k).Append(v.NewText);
			k = v.Span.End;
		}
		b.Append(code, k, end2 - k);
		s = b.ToString();
		
		return true;
	}
	
	/// <summary>
	/// Can be replaced by editorExtension scripts.
	/// </summary>
	public static CSharpSyntaxFormattingOptions FormattingOptions {
		get {
			if (_formattingOptions == null) {
				switch (App.Settings.ci_formatCompact, App.Settings.ci_formatTabIndent) {
				case (true, true): //default in this program
					_formattingOptions = new() {
						LineFormatting = new() { UseTabs = true },
						Indentation = IndentationPlacement.BlockContents | IndentationPlacement.SwitchCaseContents | IndentationPlacement.SwitchCaseContentsWhenBlock,
						NewLines = NewLinePlacement.BeforeCatch | NewLinePlacement.BeforeFinally | NewLinePlacement.BetweenQueryExpressionClauses,
						LabelPositioning = LabelPositionOptionsInternal.NoIndent,
					};
					break;
				case (false, true):
					_formattingOptions = new() {
						LineFormatting = new() { UseTabs = true },
					};
					break;
				case (true, false):
					_formattingOptions = new() {
						Indentation = IndentationPlacement.BlockContents | IndentationPlacement.SwitchCaseContents | IndentationPlacement.SwitchCaseContentsWhenBlock,
						NewLines = NewLinePlacement.BeforeCatch | NewLinePlacement.BeforeFinally | NewLinePlacement.BetweenQueryExpressionClauses,
						LabelPositioning = LabelPositionOptionsInternal.NoIndent,
					};
					break;
				default:
					_formattingOptions = CSharpSyntaxFormattingOptions.Default;
					break;
				}
			}
			return _formattingOptions;
		}
		set { _formattingOptions = value; }
	}
	static CSharpSyntaxFormattingOptions _formattingOptions;
	
	public static void CleanupWndFind() {
		if (!CodeInfo.GetContextAndDocument(out var cd, metaToo: true)) return;
		var doc = cd.sci;
		var (from, to) = doc.aaaHasSelection ? doc.aaaSelection(true) : (0, cd.code.Length);
		Dictionary<string, List<LocalDeclarationStatementSyntax>> d = new();
		
		foreach (var n in cd.syntaxRoot.DescendantNodes(TextSpan.FromBounds(from, to))) {
			if (n is not LocalDeclarationStatementSyntax lds) continue;
			var ds = lds.Declaration;
			if (!(ds.Type.ToString() is "var" or "wnd" or "Au.wnd")) continue;
			if (ds.Variables.Count != 1) continue;
			var ds2 = ds.Variables[0];
			if (ds2.Initializer?.Value is not InvocationExpressionSyntax ies) continue;
			if (ies.Expression.ToString() != "wnd.find") {
				//maybe wnd.find(...).Activate()
				if (!ies.ToString().Like("wnd.find(*).Activate()")) continue;
				if (ies.Expression is not MemberAccessExpressionSyntax mas) continue;
				ies = mas.Expression as InvocationExpressionSyntax;
				if (ies?.Expression.ToString() != "wnd.find") continue;
			}
			var a = ies.ArgumentList.Arguments;
			if (a.Count > 0) {
				var k0 = a[0].Expression.Kind();
				if (k0 is SyntaxKind.NumericLiteralExpression || (a[0].Expression is PrefixUnaryExpressionSyntax pues && pues.Operand.Kind() is SyntaxKind.NumericLiteralExpression)) a = a.RemoveAt(0);
				else if (!(k0 is SyntaxKind.StringLiteralExpression or SyntaxKind.NullLiteralExpression)) continue; //probably Seconds
			}
			if (a.Count == 0) continue;
			var s = a.ToString();
			if (d.TryGetValue(s, out var list)) list.Add(lds); else d[s] = new() { lds };
			
			//CONSIDER: if found with similar name (eg "Doc1 - App" -> "Doc2 - App"), ask whether to remove these too. Eg UI with checkboxes.
			//	Also the UI should offer to replace these with `w.WaitForName`.
			//	But maybe in many cases the user would do it manually faster than with all this confusing UI. Or just leave it as is.
		}
		
		List<(int start, int end, string repl)> aRepl = new();
		foreach (var (k, a) in d) {
			if (a.Count < 2) continue;
			static SyntaxNode _Scope(SyntaxNode n) {
				n = n.Parent;
				if (n is GlobalStatementSyntax) n = n.Parent;
				return n;
			}
			g1:
			var ds0 = a[0];
			var repl = ds0.Declaration.Variables[0].Identifier.Text;
			var scope0 = _Scope(ds0);
			a.RemoveAt(0);
			for (int i = 0; i < a.Count; i++) {
				var lds = a[i];
				var scope = _Scope(lds);
				if (scope != scope0) {
					bool ok = false;
					foreach (var v in scope.Ancestors()) {
						if (ok = v == scope0) break;
						if (v is MemberDeclarationSyntax && v is not GlobalStatementSyntax) break;
						if (v is AnonymousFunctionExpressionSyntax or LocalFunctionStatementSyntax) break;
					}
					if (!ok) continue;
				}
				
				//remove the duplicate wnd.find statement
				if (lds.Declaration.Variables[0].Initializer.Value is InvocationExpressionSyntax ies && ies.Expression is MemberAccessExpressionSyntax mas && mas.Name.Identifier.Text == "Activate") { //.Activate()
					var span = lds.Span;
					aRepl.Add((span.Start, mas.Expression.Span.End, repl));
				} else {
					var span = lds.GetRealFullSpan(true);
					aRepl.Add((span.Start, span.End, ""));
				}
				a.RemoveAt(i--);
				
				//find references of the variable declared in the duplicate wnd.find statement
				if (cd.semanticModel.GetDeclaredSymbol(lds.Declaration.Variables[0]) is ISymbol sym) {
					if (SymbolFinder.FindReferencesAsync(sym, cd.document.Project.Solution, [cd.document]).Result_().SingleOrDefault() is { } rs) {
						foreach (var loc in rs.Locations) {
							var span = loc.Location.SourceSpan;
							aRepl.Add((span.Start, span.End, repl));
						}
					}
				}
			}
			if (a.Count > 1) goto g1;
		}
		
		if (aRepl.Count == 0) {
			dialog.showInfo("Deduplicate wnd.find", $"No duplicate wnd.find statements found{(doc.aaaHasSelection ? " in the selected text" : "")}.", owner: doc.AaWnd, secondsTimeout: 5);
			return;
		}
		
		doc.EInicatorsFound_(aRepl.Select(o => o.start..o.end).ToList());
		wait.doEvents(1000);
		if (doc != Panels.Editor.ActiveDoc || doc.aaaText != cd.code) return;
		using (doc.ENewUndoAction()) {
			foreach (var v in aRepl.OrderByDescending(o => o.end)) {
				if (v.start > to) continue; to = v.start; //a variable in a replaced statement
				doc.aaaReplaceRange(true, v.start, v.end, v.repl);
			}
		}
	}
	
	public static void ConvertInterfaceMethodPreserveSig() {
		if (!CodeInfo.GetContextAndDocument(out var cd, metaToo: true)) return;
		var doc = cd.sci;
		var code = cd.code;
		var (selStart, selEnd) = doc.aaaSelection(true);
		var tok1 = cd.syntaxRoot.FindToken(selStart);
		SyntaxNode firstNode = _ToMemberDecl(tok1.Parent), lastNode = firstNode;
		if (firstNode == null) return;
		if (selEnd > selStart) {
			var tok2 = cd.syntaxRoot.FindTokenOnLeftOfPosition(selEnd);
			if (tok2.SpanStart > tok1.SpanStart) lastNode = _ToMemberDecl(tok2.Parent) ?? firstNode;
		}
		
		//if last is `get_X`, try to include next `put_X` (or vice versa)
		if (_IsProp(lastNode, out var r1) && _ToMemberDecl(lastNode.GetLastToken().GetNextToken().Parent) is { } n1 && _IsProp(n1, out var u1) && u1.put != r1.put && u1.name[4..] == r1.name[4..]) {
			lastNode = n1;
		}
		//if first is `put_X`, try to include previous `get_X` (or vice versa)
		if (_IsProp(firstNode, out var r2) && _ToMemberDecl(firstNode.GetFirstToken().GetPreviousToken().Parent) is { } n2 && _IsProp(n2, out var u2) && u2.put != r2.put && u2.name[4..] == r2.name[4..]) {
			firstNode = n2;
		}
		bool _IsProp(SyntaxNode n, out (string name, bool put) r) {
			r = default;
			if (n is MethodDeclarationSyntax m) { r.name = m.Identifier.Text; if (r.name.Starts("get_") || (r.put = r.name.Starts("put_"))) return true; }
			return false;
		}
		
		//CiUtil.PrintNode(firstNode);
		//CiUtil.PrintNode(lastNode);
		
		StringBuilder b = new();
		var replRange = (start: firstNode.SpanStart, end: lastNode.Span.End);
		int written = replRange.start;
		
		if (firstNode is MethodDeclarationSyntax mds) {
			if (lastNode is not MethodDeclarationSyntax || firstNode.Parent != lastNode.Parent || firstNode.Parent is not InterfaceDeclarationSyntax ids2) { _PrintErrorBadSelection(); return; }
			if (firstNode == lastNode) _Methods([mds]);
			else _Methods(ids2.Members.OfType<MethodDeclarationSyntax>().SkipWhile(o => o != firstNode).TakeWhile(o => { if (lastNode == null) return false; if (o == lastNode) lastNode = null; return true; }).ToArray());
		} else if (firstNode is InterfaceDeclarationSyntax ids) {
			if (lastNode is not InterfaceDeclarationSyntax || firstNode.Parent != lastNode.Parent) { _PrintErrorBadSelection(); return; }
			if (firstNode == lastNode) {
				_Interface(ids);
			} else {
				bool found = false;
				foreach (var v in _GetDescendantInterfaces(firstNode.Parent)) {
					if (!found) { if (v == firstNode) found = true; else continue; }
					_Interface(v);
					if (v == lastNode) break;
				}
			}
		} else if (firstNode is TypeDeclarationSyntax or BaseNamespaceDeclarationSyntax) {
			if (lastNode != firstNode) { _PrintErrorBadSelection(); return; }
			foreach (var v in _GetDescendantInterfaces(firstNode)) {
				_Interface(v);
			}
		} else {
			_PrintErrorBadSelection();
			return;
		}
		
		if (b.Length > 0) {
			b.Append(code, written, replRange.end - written);
			//print.it(b);
			doc.EReplaceTextGently(replRange.start, replRange.end, b.ToString());
		}
		
		static void _PrintErrorBadSelection() {
			print.it("""
To convert COM interface methods, please click or select one of:
- One or more methods in a COM interface definition.
- One or more COM interface definitions; they can be in a class, struct or namespace.
- A class, struct or namespace that contains COM interface definitions.
""");
		}
		
		static MemberDeclarationSyntax _ToMemberDecl(SyntaxNode n) {
			return n?.FirstAncestorOrSelf<MemberDeclarationSyntax>();
		}
		
		static IEnumerable<InterfaceDeclarationSyntax> _GetDescendantInterfaces(SyntaxNode parent) {
			return parent.DescendantNodes(o => o is TypeDeclarationSyntax or BaseNamespaceDeclarationSyntax or CompilationUnitSyntax).OfType<InterfaceDeclarationSyntax>();
		}
		
		void _Interface(InterfaceDeclarationSyntax ids) {
			_Methods(ids.Members.OfType<MethodDeclarationSyntax>().ToArray());
		}
		
		void _Methods(MethodDeclarationSyntax[] a) {
			for (int i = 0; i < a.Length; i++) {
				var m = a[i];
				if (!_IsPreserveSig(m)) continue;
				b.Append(code, written, m.SpanStart - written);
				string name = m.Identifier.Text, modifiers = m.Modifiers.ToString();
				//is property?
				if (_IsProperty(m, out bool isPut, out string type)) {
					//is read-write property?
					MethodDeclarationSyntax m2 = null;
					bool isPair = i < a.Length - 1 && _IsPreserveSig(m2 = a[i + 1])
						&& m2.Identifier.Text is { } name2 && name2.Starts(isPut ? "get_" : "put_") && name2.AsSpan(4).Eq(name.AsSpan(4))
						&& _IsProperty(m2, out bool isPut2, out string type2) && isPut2 != isPut
						&& type2 == type
						&& m2.Modifiers.ToString() == modifiers
						&& m2.GetFirstToken().GetPreviousToken().Parent == m;
					
					if (!modifiers.NE()) b.Append(modifiers).Append(' ');
					name = name[4..]; if (SyntaxFacts.IsReservedKeyword(SyntaxFacts.GetKeywordKind(name))) name = '@' + name;
					b.Append(type).Append(' ').Append(name).Append(isPut ? " { set; " : " { get; ");
					
					if (isPair) {
						b.Append(isPut ? "get; }" : "set; }");
						written = m2.Span.End;
						i++;
					} else {
						b.Append('}');
						written = m.Span.End;
					}
				} else {
					//is last parameter `out`?
					var ap = m.ParameterList.Parameters;
					if (ap.Any() && ap.Last() is var p && p.Modifiers.ToString() is "out" && _ParamAttr(p, out string marshal)) {
						if (marshal != null) b.Append($"[return: {marshal}] ");
						if (!modifiers.NE()) b.Append(modifiers).Append(' ');
						b.Append(_ParamType(p)).Append(' ');
						int n = m.ParameterList.Parameters.Count;
						var span = n == 1 ? m.ParameterList.OpenParenToken.Span : m.ParameterList.Parameters[n - 2].Span;
						b.Append(code.AsSpan(m.Identifier.SpanStart..span.End)).Append(");");
					} else {
						if (!modifiers.NE()) b.Append(modifiers).Append(' ');
						b.Append("void ").Append(code.AsSpan(m.Identifier.SpanStart..m.Span.End));
					}
					written = m.Span.End;
				}
			}
			
			static bool _IsPreserveSig(MethodDeclarationSyntax m) {
				return m.ReturnType.ToString() == "int"
					&& m.AttributeLists.Count == 1 && m.AttributeLists[0].Attributes.ToString() is "PreserveSig" or "PreserveSigAttribute"
					&& m.Body == null && m.ExpressionBody == null && m.Arity == 0;
			}
			
			static bool _IsProperty(MethodDeclarationSyntax m, out bool put, out string type) {
				put = false; type = null;
				if (m.ParameterList.Parameters.Count == 1) {
					string name = m.Identifier.Text;
					if (name.Starts("get_") || (put = name.Starts("put_"))) {
						var p = m.ParameterList.Parameters.Last();
						if (put ? p.Modifiers.Count == 0 : p.Modifiers.ToString() is "out" or "ref") {
							if (_ParamAttr(p, out var marshal) && marshal == null) { //info: C# does not allow to set [MarshalAs] on properties and `set`/`get`; with `return` too.
								type = _ParamType(p);
								return true;
							}
						}
					}
				}
				return false;
			}
			
			static string _ParamType(ParameterSyntax p) => p.Type.ToString().Replace(" ", "");
			
			static bool _ParamAttr(ParameterSyntax p, out string marshal) {
				marshal = null;
				foreach (var v in p.AttributeLists) {
					if (v.Attributes.Count != 1) return false;
					var s = v.Attributes[0].ToString();
					if (s.Starts("MarshalAs")) marshal = s;
					else if (!(s is "In" or "Out")) return false;
				}
				return true;
			}
		}
	}
}


partial class SciCode {
	/// <summary>
	/// Replaces text without losing markers, expanding folded code, etc.
	/// </summary>
	public void EReplaceTextGently(string s) => _ReplaceTextGently(0, aaaLen16, s, false);
	
	/// <summary>
	/// Replaces range text without losing markers, expanding folded code, etc.
	/// </summary>
	public void EReplaceTextGently(int from, int to, string s) => _ReplaceTextGently(from, to, s, true);
	
	void _ReplaceTextGently(int rFrom, int rTo, string s, bool isRange) {
		int len = s.Lenn(); if (len == 0) goto gRaw;
		string old = isRange ? aaaRangeText(true, rFrom, rTo) : aaaText;
		if (len > 5_000_000 || old.Length > 5_000_000 || old.Length == 0) goto gRaw;
		var dmp = new Libs.DiffMatchPatch.diff_match_patch();
		var a = dmp.diff_main(old, s, true); //the slowest part. Timeout 1 s; then a valid but smaller.
		dmp.diff_cleanupEfficiency(a);
		using (ENewUndoAction(onUndoDontChangeCaretPos: !isRange)) {
			for (int i = a.Count - 1, j = old.Length; i >= 0; i--) {
				var d = a[i];
				if (d.operation == Libs.DiffMatchPatch.Operation.INSERT) {
					aaaInsertText(true, j + rFrom, d.text);
				} else {
					j -= d.text.Length;
					if (d.operation == Libs.DiffMatchPatch.Operation.DELETE)
						aaaDeleteRange(true, j + rFrom, j + d.text.Length + rFrom);
				}
			}
		}
		return;
		gRaw:
		if (isRange) aaaReplaceRange(true, rFrom, rTo, s);
		else aaaText = s;
		
		//never mind: then Undo sets position at the first replaced part (in the document it's the last, because replaces in reverse order).
		//	And then Redo sets position at the last replaced part.
		//	Could try SCI_ADDUNDOACTION.
	}
}


================================================
FILE: Au.Editor/Edit/PanelEdit.cs
================================================
//#define TEST_COPYPASTE

using System.Windows;
using System.Windows.Controls;

using Au.Controls;
using static Au.Controls.Sci;

namespace LA;

class PanelEdit {
	readonly List<SciCode> _docs = new();
	SciCode _activeDoc;
	
	public PanelEdit() {
		P.Background = SystemColors.AppWorkspaceBrush;
		App.Commands.BindKeysTarget(P, "Edit");
		_UpdateUI_IsOpen();
		UpdateUI_EditView_();
	}
	
	public Grid P { get; } = new();
	
	public SciCode ActiveDoc => _activeDoc;
	
	/// <summary>
	/// When opened new document, or switched to an open document, or closed current or all documents.
	/// When closing, <b>ActiveDoc</b> is null when calling event handlers.
	/// </summary>
	public event Action ActiveDocChanged;
	
	/// <summary>
	/// true if 1 or more documents are open.
	/// </summary>
	public bool IsOpen => _activeDoc != null;
	
	/// <summary>
	/// Documents that currently are open in editor.
	/// See also <see cref="FilesModel.OpenFiles"/> (it contains these and more).
	/// </summary>
	public IReadOnlyList<SciCode> OpenDocs => _docs;
	
	/// <summary>
	/// If f is already open, unhides its control.
	/// Else loads f text and creates control. If fails, does not change anything.
	/// Hides current file's control.
	/// Returns false if failed to read file.
	/// Does not save text of previously active document.
	/// </summary>
	/// <param name="f"></param>
	/// <param name="newFile">Should be true if opening the file first time after creating.</param>
	/// <param name="focusEditor">If null, focus later, when mouse enters editor. Ignored if editor was focused (sets focus). Also depends on <i>newFile</i>.</param>
	/// <param name="noTemplate">New file was created with custom text (option 'replaceTemplate').</param>
	public bool Open(FileNode f, bool newFile, bool? focusEditor, bool noTemplate) {
		Debug.Assert(!App.Model.IsAlien(f));
		
		if (f == _activeDoc?.EFile) return true;
		
		//print.it(focusEditor, new StackTrace(true));
		bool focusNow = !newFile && (focusEditor == true || (_activeDoc?.AaWnd.IsFocused ?? false));
		
		void _ShowHideActiveDoc(bool show) {
			if (show) {
				_activeDoc.Visibility = Visibility.Visible;
				//Children.Add(_activeDoc);
			} else if (_activeDoc != null) {
				_activeDoc.Visibility = Visibility.Hidden;
				//Children.Remove(_activeDoc);
				_activeDoc.ETempRanges_HidingOrClosingActiveDoc_();
			}
		}
		
		var doc = f.OpenDoc;
		if (doc != null) {
			_ShowHideActiveDoc(false);
			_activeDoc = doc;
			_ShowHideActiveDoc(true);
			doc.EOpenDocActivated();
			_UpdateUI_IsOpen();
			UpdateUI_EditEnabled_();
			ActiveDocChanged?.Invoke();
		} else {
			var path = f.FilePath;
			KScintilla.aaaFileLoaderSaver fls = new();
			try { fls.Load(path); }
			catch (Exception ex) { print.it("Failed to open file. " + ex.Message); return false; }
			
			_ShowHideActiveDoc(false);
			doc = new SciCode(f, fls);
			_docs.Add(doc);
			f.OpenDoc = _activeDoc = doc;
			P.Children.Add(doc);
			doc.EInit_(newFile, noTemplate);
			_UpdateUI_IsOpen();
			UpdateUI_EditEnabled_();
			ActiveDocChanged?.Invoke();
			//CodeInfo.FileOpened(doc);
		}
		
		if (focusNow) _activeDoc.Focus();
		else if (focusEditor == null || (newFile && focusEditor == true)) {
			//if opens on single click, focus later, when mouse is in doc.
			//	Else eg user clicks and presses Del to delete file but instead deletes char in doc text. Or wants to rename but F2 does nothing.
			
			int count = 60 * 4; //60 s timeout
			App.Timer025sWhenVisible += _Timer;
			void _Timer() {
				//print.it("timer");
				if (--count > 0 && f == _activeDoc?.EFile && Panels.Files.TreeControl.IsFocused) {
					if (wnd.fromMouse() != doc.AaWnd
						|| !Panels.Files.TreeControl.IsKeyboardFocused //editing item label
						) return;
					doc.Focus();
				}
				App.Timer025sWhenVisible -= _Timer;
			}
		}
		
		Panels.Find.UpdateQuickResults();
		return true;
	}
	
	/// <summary>
	/// If f is open, closes its document and destroys its control.
	/// f can be any, not necessary the active document.
	/// Saves text before closing the active document.
	/// Does not show another document when closed the active document.
	/// </summary>
	/// <param name="f"></param>
	public void Close(FileNode f) {
		Debug.Assert(f != null);
		SciCode doc;
		if (f == _activeDoc?.EFile) {
			_activeDoc.ETempRanges_HidingOrClosingActiveDoc_();
			App.Model.Save.TextNowIfNeed(closingDoc: true);
			doc = _activeDoc;
			_activeDoc = null;
			ActiveDocChanged?.Invoke();
		} else {
			doc = f.OpenDoc;
			if (doc == null) return;
		}
		_Close(doc);
		_docs.Remove(doc);
		_UpdateUI_IsOpen();
	}
	
	void _Close(SciCode doc) {
		ClosingDoc?.Invoke(doc);
		if (doc.IsFocused) doc.IsEnabled = false; //prevent focusing the scintilla control after hiding/parking
		P.Children.Remove(doc);
		//CodeInfo.FileClosed(doc);
		doc.EFile.OpenDoc = null;
		doc.Dispose();
	}
	
	/// <summary>
	/// Closes all documents and destroys controls.
	/// Called by FilesModel.UnloadingWorkspace_.
	/// Note: does not update the files model and treeview; to close normally use FilesModel.CloseX.
	/// </summary>
	internal void CloseAll_(bool saveTextIfNeed) {
		_activeDoc?.ETempRanges_HidingOrClosingActiveDoc_();
		if (saveTextIfNeed) App.Model.Save.TextNowIfNeed();
		_activeDoc = null;
		ActiveDocChanged?.Invoke();
		foreach (var doc in _docs) _Close(doc);
		_docs.Clear();
		_UpdateUI_IsOpen();
	}
	
	/// <summary>
	/// When closing a document (active or not).
	/// Called after setting <b>ActiveDoc</b> = null, invoking <b>ActiveDocChanged</b> and saving changes (event handlers must not make new changes).
	/// </summary>
	public event Action<SciCode> ClosingDoc;
	
	public bool SaveText() {
		return _activeDoc?.ESaveText_(false) ?? true;
	}
	
	public void SaveEditorData(bool closingDoc) {
		_activeDoc?.ESaveEditorData_(closingDoc);
	}
	
	//public bool IsModified => _activeDoc?.IsModified ?? false;
	
	internal void OnAppActivated_() {
		foreach (var doc in _docs) {
			doc.EFile._CheckModifiedExternally(doc);
		}
	}
	
	/// <summary>
	/// If the specified file is open in <see cref="ActiveDoc"/>: if <i>save</i>, saves text if need; else reloads if need.
	/// </summary>
	public void SyncEditorTextIfFileIs(string file, bool save) {
		if (ActiveDoc is { } doc && filesystem.more.isSameFile(file, doc.EFile.FilePath)) {
			if (save) {
				App.Model.Save.TextNowIfNeed();
			} else {
				doc.EFile._CheckModifiedExternally(doc);
			}
		}
	}
	
	/// <summary>
	/// Enables/disables Edit and Run toolbars/menus and some other UI parts depending on whether a document is open in editor.
	/// </summary>
	void _UpdateUI_IsOpen() {
		bool enable = _activeDoc != null;
		if (enable != _uiDisabled_IsOpen) return;
		_uiDisabled_IsOpen = !enable;
		_editDisabled = 0;
		
		string[] a1 = [
			nameof(Menus.Edit),
			nameof(Menus.Code),
			nameof(Menus.TT.Toolbar_trigger),
			nameof(Menus.TT.Script_launchers),
			nameof(Menus.TT.Find_triggers),
			nameof(Menus.Run.Run_script),
			nameof(Menus.Run.Compile),
			nameof(Menus.Run.Debug_run),
			nameof(Menus.Run.Publish),
			nameof(Menus.Run.Run_in_PiP),
			//nameof(Menus.Run.Debugger),
			//and not Properties, Rename, Delete, More, because users can right-click in the Files panel
			];
		foreach (string v in a1) if (v!=null) App.Commands[v].Enable(enable);
	}
	bool _uiDisabled_IsOpen;
	
	/// <summary>
	/// Enables/disables commands (toolbar buttons, menu items) depending on document state such as "can undo".
	/// Called on SCN_UPDATEUI.
	/// </summary>
	internal void UpdateUI_EditEnabled_() {
		_EUpdateUI disable = 0;
		var d = _activeDoc;
		if (d == null) return; //we disable the toolbar and menu
		if (0 == d.Call(SCI_CANUNDO)) disable |= _EUpdateUI.Undo;
		if (0 == d.Call(SCI_CANREDO)) disable |= _EUpdateUI.Redo;
		if (!d.aaaHasSelection) disable |= _EUpdateUI.Copy;
		if (disable.Has(_EUpdateUI.Copy) || d.aaaIsReadonly) disable |= _EUpdateUI.Cut;
		//if(0 == d.Call(SCI_CANPASTE)) disable |= EUpdateUI.Paste; //rejected. Often slow. Also need to see on focused etc.
		
		var dif = disable ^ _editDisabled;
		//print.it(dif);
		if (dif == 0) return;
		
		_editDisabled = disable;
		if (dif.Has(_EUpdateUI.Undo)) App.Commands[nameof(Menus.Edit.UndoRedo.Undo)].Enable(!disable.Has(_EUpdateUI.Undo));
		if (dif.Has(_EUpdateUI.Redo)) App.Commands[nameof(Menus.Edit.UndoRedo.Redo)].Enable(!disable.Has(_EUpdateUI.Redo));
		if (dif.Has(_EUpdateUI.Cut)) App.Commands[nameof(Menus.Edit.Clipboard.Cut)].Enable(!disable.Has(_EUpdateUI.Cut));
		if (dif.Has(_EUpdateUI.Copy)) App.Commands[nameof(Menus.Edit.Clipboard.Copy)].Enable(!disable.Has(_EUpdateUI.Copy));
		//if(dif.Has(EUpdateUI.Paste)) App.Commands[nameof(Menus.Edit.Paste)].Enable(!disable.Has(EUpdateUI.Paste));
		
	}
	_EUpdateUI _editDisabled;
	
	internal void UpdateUI_EditView_() {
		App.Commands[nameof(Menus.Edit.View.Wrap_lines)].Checked = App.Settings.edit_wrap;
		App.Commands[nameof(Menus.Edit.View.Images_in_code)].Checked = !App.Settings.edit_noImages;
	}
	
	[Flags]
	enum _EUpdateUI {
		Undo = 1,
		Redo = 2,
		Cut = 4,
		Copy = 8,
	}
}


================================================
FILE: Au.Editor/Edit/Sci-DD.cs
================================================
using static Au.Controls.Sci;
using System.Windows;
using ToolLand;

namespace LA;

partial class SciCode {
	void _InitDragDrop() {
		Api.RevokeDragDrop(AaWnd); //of Scintilla
		Api.RegisterDragDrop(AaWnd, _ddTarget = new _DragDrop(this));
		//Scintilla will call RevokeDragDrop when destroying window
	}
	
	_DragDrop _ddTarget;
	
	class _DragDrop : Api.IDropTarget {
		readonly SciCode _sci;
		DDData _data;
		bool _canDrop, _justText;
		
		public _DragDrop(SciCode sci) { _sci = sci; }
		
		void Api.IDropTarget.DragEnter(System.Runtime.InteropServices.ComTypes.IDataObject d, int grfKeyState, POINT pt, ref int effect) {
			_data = default;
			_justText = false;
			if (_canDrop = _data.GetData(d, getFileNodes: true)) {
				_justText = _data.text != null && _data.linkName == null;
			}
			effect = _GetEffect(effect, grfKeyState);
			CodeInfo.Cancel();
		}
		
		unsafe void Api.IDropTarget.DragOver(int grfKeyState, POINT p, ref int effect) {
			if ((effect = _GetEffect(effect, grfKeyState)) != 0) {
				_GetDropPos(ref p, out _);
				var z = new Sci_DragDropData { x = p.x, y = p.y };
				_sci.Call(SCI_DRAGDROP, 1, &z);
			}
		}
		
		void Api.IDropTarget.DragLeave() {
			if (_canDrop) {
				_canDrop = false;
				_sci.Call(SCI_DRAGDROP, 3);
			}
		}
		
		void Api.IDropTarget.Drop(System.Runtime.InteropServices.ComTypes.IDataObject d, int grfKeyState, POINT pt, ref int effect) {
			if ((effect = _GetEffect(effect, grfKeyState)) != 0) _Drop(pt, effect);
			_canDrop = false;
		}
		
		int _GetEffect(int effect, int grfKeyState) {
			if (!_canDrop) return 0;
			if (_sci.aaaIsReadonly) return 0;
			DragDropEffects r, ae = (DragDropEffects)effect;
			var ks = (DragDropKeyStates)grfKeyState;
			switch (ks & (DragDropKeyStates.ShiftKey | DragDropKeyStates.ControlKey | DragDropKeyStates.AltKey)) {
			case 0: r = DragDropEffects.Move; break;
			case DragDropKeyStates.ControlKey: r = DragDropEffects.Copy; break;
			default: return 0;
			}
			if (_data.text != null) r = 0 != (ae & r) ? r : ae;
			else if (0 != (ae & DragDropEffects.Link)) r = DragDropEffects.Link;
			else if (0 != (ae & DragDropEffects.Copy)) r = DragDropEffects.Copy;
			else r = ae;
			return (int)r;
		}
		
		void _GetDropPos(ref POINT p, out int pos) {
			_sci.AaWnd.MapScreenToClient(ref p);
			if (!_justText) { //if files etc, drop as lines, not anywhere
				pos = _sci.Call(SCI_POSITIONFROMPOINT, p.x, p.y);
				pos = _sci.aaaLineStartFromPos(false, pos);
				p.x = _sci.Call(SCI_POINTXFROMPOSITION, 0, pos);
				p.y = _sci.Call(SCI_POINTYFROMPOSITION, 0, pos);
			} else pos = 0;
		}
		
		void _Drop(POINT xy, int effect) {
			//activate the window. Most apps activate self on drop. Also eg the Windows 11 Drag Tray may activate it and close the menu.
			var wAct = _sci.AaWnd.Window;
			if (!wAct.IsActive) wAct.ActivateL();
			
			_GetDropPos(ref xy, out _);
			var z = new Sci_DragDropData { x = xy.x, y = xy.y };
			string s = null;
			var b = new StringBuilder();
			bool isCodeFile = _sci.EFile.IsCodeFile;
			Action finalAction = null;
			
			if (_justText) {
				s = _data.text;
			} else {
				unsafe { _sci.Call(SCI_DRAGDROP, 2, &z); } //just hides the drag indicator and sets caret position
				
				if (_data.scripts) {
					if (Panels.Files.TreeControl.DragDropFiles is { } a) {
						int what = 0;
						if (isCodeFile) {
							var sm = "1 string s = name;|2 string s = path;";
							if (a.All(o => o.IsCodeFile)) {
								sm += "|3 script.run(name);|4 t[name] = o => script.run(name);";
								if (a.All(o => o.IsClass)) {
									sm += a.All(o => o.GetClassFileRole() == FNClassFileRole.Library) ? "|101 /* pr name; */" : "|100 /* c name; */";
								}
							} else {
								sm += "|102 /* resource path; */";
								sm += "|103 /* file path; */";
							}
							what = popupMenu.showSimple(sm);
							if (what == 0) return;
						}
						if (what >= 100) { //meta comment
							MetaCommentsParser m = new(_sci.EFile) { };
							var list = what switch { 100 => m.c, 101 => m.pr, 102 => m.resource, _ => m.file };
							foreach (var v in a) list.Add(v.ItemPathOrName(relativeTo: _sci.EFile));
							m.Apply();
							return;
						}
						for (int i = 0; i < a.Length; i++)
							_AppendScriptOrLink(what, what is 3 or 4 ? a[i].ItemPathOrName() : a[i].ItemPath, a[i].Name, i + 1, a[i]);
					}
				} else if (_data.files != null || _data.shell != null) {
					string[] files = null, names = null;
					files = _data.shell != null ? _GetShell(_data.shell, out names) : _data.files;
					if (isCodeFile) {
						var what = PathInfo.InsertCodeMenu(files, _sci.AaWnd);
						if (what == 0) return;
						for (int i = 0; i < files.Length; i++) {
							if (i > 0) b.AppendLine();
							var k = new PathInfo(files[i], names?[i]);
							b.Append(k.FormatCode(what, i + 1));
						}
					} else {
						for (int i = 0; i < files.Length; i++) {
							if (i > 0) b.AppendLine();
							b.Append(files[i]);
						}
					}
				} else if (_data.linkName != null) {
					int what = 0;
					if (isCodeFile) {
						what = popupMenu.showSimple("11 string s = URL;|12 run.it(URL);|13 t[name] = o => run.it(URL);");
						if (what == 0) return;
					}
					finalAction = _AppendScriptOrLink(what, _data.text, _GetLinkName(_data.linkName));
				}
				s = b.ToString();
			}
			
			if (!s.NE()) {
				if (_justText) { //a simple drag-drop inside scintilla or text-only from outside
					var s8 = Encoding.UTF8.GetBytes(s);
					unsafe {
						fixed (byte* p8 = s8) {
							z.text = p8;
							z.len = s8.Length;
							if (0 == ((DragDropEffects)effect & DragDropEffects.Move)) z.copy = 1;
							using (new CodeInfo.PastingEtc(_sci))
								_sci.Call(SCI_DRAGDROP, 2, &z);
						}
					}
				} else { //file, script or URL
					if (isCodeFile) InsertCode.Statements(new(s, noFocus: true));
					else if (!_sci.aaaIsReadonly) _sci.aaaReplaceSel(s + "\r\n");
					else print.it(s);
				}
				if (!_sci.IsFocused && _sci.AaWnd.Window.IsActive) { //note: don't activate window; let the drag source do it, eg Explorer activates on drag-enter.
					_sci._noModelEnsureCurrentSelected = true; //don't scroll treeview to currentfile
					_sci.Focus();
					_sci._noModelEnsureCurrentSelected = false;
				}
			} else {
				if (_justText) _sci.Call(SCI_DRAGDROP, 3);
			}
			
			finalAction?.Invoke();
			
			Action _AppendScriptOrLink(int what, string path, string name, int index = 0, FileNode fn = null) {
				if (b.Length > 0) b.AppendLine();
				if (what == 0) {
					b.Append(path);
				} else {
					if (what == 4) name = name.RemoveSuffix(".cs");
					name = name.Escape();
					
					if (what is 4 or 13) {
						var t = CiUtil.GetNearestLocalVariableOfType("Au.toolbar", "Au.popupMenu");
						b.Append($"{t?.Name ?? "t"}[\"{name}\"] = o => ");
					} else if (what is 1 or 2 or 11) {
						b.Append($"string s{index} = ");
					}
					
					b.Append(what switch {
						1 => $"\"{name}\";",
						2 or 11 => $"@\"{path}\";",
						3 or 4 => $"script.run(@\"{path}\");",
						_ => $"run.it(@\"{path}\");"
					});
					
					if (what == 13) { //favicon
						int dropPos = _sci.aaaCurrentPos16;
						return async () => { //this code will run after inserting the statement
							string text1 = _sci.aaaText, url = $"https://www.google.com/s2/favicons?domain={path}";
							var pngBytes = await Task.Run(() => internet.http.TryGet(out var r, url) && r.Content.Headers.ContentType.MediaType == "image/png" ? r.Bytes() : null);
							if (pngBytes != null && Panels.Editor.ActiveDoc == _sci && _sci.aaaText == text1 && text1.RxMatch(@"\G.+?""(\]) = o => run\.it\(", 1, out RXGroup g, range: dropPos..)) {
								_sci.aaaInsertText(true, g.Start, $", @\"image:{Convert.ToBase64String(pngBytes)}\"");
							}
						};
					}
				}
				return null;
			}
			
			static unsafe string[] _GetShell(byte[] b, out string[] names) {
				fixed (byte* p = b) {
					int* pi = (int*)p;
					int n = *pi++;
					var paths = new string[n];
					names = new string[n];
					if (n > 0) {
						IntPtr pidlFolder = (IntPtr)(p + *pi++);
						for (int i = 0; i < n; i++) {
							using var pidl = new Pidl(pidlFolder, (IntPtr)(p + pi[i]));
							//if from Winstore apps folder, get "shell:..."
							if (folders.shell.pidlApps_Win8.ValueEquals(pidlFolder)) {
								//var s11 = pidl.ToShellString(SIGDN.DESKTOPABSOLUTEPARSING); //same as PARENTRELATIVEPARSING, not full
								var s1 = pidl.ToShellString(SIGDN.PARENTRELATIVEPARSING);
								if (s1 != null && !s1.Starts('{') && s1.Contains('!')) paths[i] = @"shell:AppsFolder\" + s1;
								//if (s1 != null) {
								//	if (s1.Starts('{')) paths[i] = s1; //like "{1AC14E77-02E7-4E5D-B744-2EB1AE5198B7}\charmap.exe". run.it fails etc. Cannot get path. The ITEMIDLIST is insanely long.
								//	else if (s1.Contains('!')) paths[i] = @"shell:AppsFolder\" + s1;
								//}
							}
							paths[i] ??= pidl.ToString();
							names[i] = pidl.ToShellString(SIGDN.NORMALDISPLAY);
						}
					}
					return paths;
				}
			}
			
			static unsafe string _GetLinkName(byte[] b) {
				if (b.Length != 596) return null; //sizeof(FILEGROUPDESCRIPTORW) with 1 FILEDESCRIPTORW
				fixed (byte* p = b) { //FILEGROUPDESCRIPTORW
					if (*(int*)p != 1) return null; //count of FILEDESCRIPTORW
					var s = new string((char*)(p + 76));
					if (!s.Ends(".url", true)) return null;
					return s[..^4];
				}
			}
		}
	}
}


================================================
FILE: Au.Editor/Edit/Sci-TR.cs
================================================
//#define TRACE_TEMP_RANGES

using Au.Controls;
using static Au.Controls.Sci;

namespace LA;

partial class SciCode : KScintilla {
	[Flags]
	public enum TempRangeFlags {
		/// <summary>
		/// Call onLeave etc when current position != current end of range.
		/// </summary>
		LeaveIfPosNotAtEndOfRange = 1,
		
		/// <summary>
		/// Call onLeave etc when range text modified.
		/// </summary>
		LeaveIfRangeTextModified = 2,
		
		/// <summary>
		/// Don't add new range if already exists a range with same current from, to, owner and flags. Then returns that range.
		/// </summary>
		NoDuplicate = 4,
	}
	
	public interface ITempRange {
		/// <summary>
		/// Removes this range from the collection of ranges of the document.
		/// Optional. Temp ranges are automatically removed sooner or later.
		/// Does nothing if already removed.
		/// </summary>
		void Remove();
		
		/// <summary>
		/// Gets current start and end positions of this range added with <see cref="ETempRanges_Add"/>.
		/// Returns false if the range is removed; then sets from = to = -1.
		/// </summary>
		bool GetCurrentFromTo(out int from, out int to, bool utf8 = false);
		
		/// <summary>
		/// Gets current start position of this range added with <see cref="ETempRanges_Add"/>. UTF-16.
		/// Returns -1 if the range is removed.
		/// </summary>
		int CurrentFrom { get; }
		
		/// <summary>
		/// Gets current end position of this range added with <see cref="ETempRanges_Add"/>. UTF-16.
		/// Returns -1 if the range is removed.
		/// </summary>
		int CurrentTo { get; }
		
		object Owner { get; }
		
		/// <summary>
		/// Any data. Not used by temp range functions.
		/// </summary>
		object OwnerData { get; set; }
	}
	
	class _TempRange : ITempRange {
		SciCode _doc;
		readonly object _owner;
		readonly int _fromUtf16;
		internal readonly int from;
		internal int to;
		internal readonly Action onLeave;
		readonly TempRangeFlags _flags;
		
		internal _TempRange(SciCode doc, object owner, int fromUtf16, int fromUtf8, int toUtf8, Action onLeave, TempRangeFlags flags) {
			_doc = doc;
			_owner = owner;
			_fromUtf16 = fromUtf16;
			from = fromUtf8;
			to = toUtf8;
			this.onLeave = onLeave;
			_flags = flags;
		}
		
		public void Remove() {
			_TraceTempRange("remove", _owner);
			if (_doc != null) {
				_doc._tempRanges.Remove(this);
				_doc = null;
			}
		}
		
		internal void Leaved() => _doc = null;
		
		public bool GetCurrentFromTo(out int from, out int to, bool utf8 = false) {
			if (_doc == null) { from = to = -1; return false; }
			if (utf8) {
				from = this.from;
				to = this.to;
			} else {
				from = _fromUtf16;
				to = CurrentTo;
			}
			return true;
		}
		
		public int CurrentFrom => _doc != null ? _fromUtf16 : -1;
		
		public int CurrentTo => _doc?.aaaPos16(to) ?? -1;
		
		public object Owner => _owner;
		
		public object OwnerData { get; set; }
		
		internal bool MustLeave(int pos, int pos2, int modLen) {
			return pos < from || pos2 > to
				|| (0 != (_flags & TempRangeFlags.LeaveIfPosNotAtEndOfRange) && pos2 != to)
				|| (0 != (_flags & TempRangeFlags.LeaveIfRangeTextModified) && modLen != 0);
		}
		
		internal bool Contains(int pos, object owner, bool endPosition)
			=> (endPosition ? (pos == to) : (pos >= from || pos <= to)) && (owner == null || ReferenceEquals(owner, _owner));
		
		internal bool Equals(int from2, int to2, object owner2, TempRangeFlags flags2) {
			if (from2 != from || to2 != to || flags2 != _flags
				//|| onLeave2 != onLeave //delegate always different if captured variables
				//|| !ReferenceEquals(onLeave2?.Method, onLeave2?.Method) //can be used but slow. Also tested Target, always different.
				) return false;
			return ReferenceEquals(owner2, _owner);
		}
		
		public override string ToString() => $"({CurrentFrom}, {CurrentTo}), owner={_owner}";
	}
	
	List<_TempRange> _tempRanges = new();
	
	/// <summary>
	/// Marks a temporary working range of text and later notifies when it is leaved.
	/// Will automatically update range bounds when editing text inside it.
	/// Supports many ranges, possibly overlapping.
	/// The returned object can be used to get range info or remove it.
	/// Used mostly for code info, eg to cancel the completion list or signature help.
	/// </summary>
	/// <param name="owner">Owner of the range. See also <see cref="ITempRange.OwnerData"/>.</param>
	/// <param name="from">Start of range, UTF-16.</param>
	/// <param name="to">End of range, UTF-16. Can be = from.</param>
	/// <param name="onLeave">
	/// Called when current position changed and is outside this range (before from or after to) or text modified outside it. Then also forgets the range.
	/// Called after removing the range.
	/// If leaved several ranges, called in LIFO order.
	/// Can be null.
	/// </param>
	/// <param name="flags"></param>
	public ITempRange ETempRanges_Add(object owner, int from, int to, Action onLeave = null, TempRangeFlags flags = 0) {
		int fromUtf16 = from;
		aaaNormalizeRange(true, ref from, ref to);
		//print.it(fromUtf16, from, to, aaaCurrentPos8);
#if DEBUG
		if (!(aaaCurrentPos8 >= from && (flags.Has(TempRangeFlags.LeaveIfPosNotAtEndOfRange) ? aaaCurrentPos8 == to : aaaCurrentPos8 <= to))) {
			Debug_.Print("bad");
			CiUtil.DebugHiliteRange(from, to);
		}
#endif
		
		if (flags.Has(TempRangeFlags.NoDuplicate)) {
			for (int i = _tempRanges.Count; --i >= 0;) {
				var t = _tempRanges[i];
				if (t.Equals(from, to, owner, flags)) return t;
			}
		}
		
		_TraceTempRange("ADD", owner);
		var r = new _TempRange(this, owner, fromUtf16, from, to, onLeave, flags);
		_tempRanges.Add(r);
		return r;
	}
	
	/// <summary>
	/// Gets ranges containing the specified position and optionally of the specified owner, in LIFO order.
	/// It's safe to remove the retrieved ranges while enumerating.
	/// </summary>
	/// <param name="position"></param>
	/// <param name="owner">If not null, returns only ranges where ReferenceEquals(owner, range.owner).</param>
	/// <param name="endPosition">position must be at the end of the range.</param>
	/// <param name="utf8"></param>
	public IEnumerable<ITempRange> ETempRanges_Enum(int position, object owner = null, bool endPosition = false, bool utf8 = false) {
		if (!utf8) position = aaaPos8(position);
		for (int i = _tempRanges.Count; --i >= 0;) {
			var r = _tempRanges[i];
			if (r.Contains(position, owner, endPosition)) yield return r;
		}
	}
	
	/// <summary>
	/// Gets ranges of the specified owner, in LIFO order.
	/// It's safe to remove the retrieved ranges while enumerating.
	/// </summary>
	/// <param name="owner">Returns only ranges where ReferenceEquals(owner, range.owner).</param>
	public IEnumerable<ITempRange> ETempRanges_Enum(object owner) {
		for (int i = _tempRanges.Count; --i >= 0;) {
			var r = _tempRanges[i];
			if (ReferenceEquals(owner, r.Owner)) yield return r;
		}
	}
	
	internal void ETempRanges_HidingOrClosingActiveDoc_() {
		if (_tempRanges.Count == 0) return;
		//_TraceTempRange("CLEAR", null);
		for (int i = _tempRanges.Count; --i >= 0;) {
			var r = _tempRanges[i];
			_TraceTempRange("leave", r.Owner);
			r.Leaved();
			r.onLeave?.Invoke();
		}
		_tempRanges.Clear();
	}
	
	void _TempRangeOnModifiedOrPosChanged(MOD mod, int pos, int len) {
		if (_tempRanges.Count == 0) return;
		if (mod == 0) pos = aaaCurrentPos8;
		int pos2 = pos;
		if (mod.Has(MOD.SC_MOD_DELETETEXT)) { pos2 += len; len = -len; }
		List<Action> aOL = null;
		for (int i = _tempRanges.Count; --i >= 0;) {
			var r = _tempRanges[i];
			if (r.MustLeave(pos, pos2, len)) {
				_TraceTempRange("leave", r.Owner);
				_tempRanges.RemoveAt(i);
				r.Leaved();
				if (r.onLeave is { } ol) (aOL ??= new()).Add(ol);
			} else {
				r.to += len;
				Debug.Assert(r.to >= r.from);
			}
		}
		if (aOL != null) foreach (var ol in aOL) ol();
	}
	
	[Conditional("TRACE_TEMP_RANGES")]
	static void _TraceTempRange(string action, object owner) => print.it(action, owner);
}


================================================
FILE: Au.Editor/Edit/Sci-images.cs
================================================
extern alias CAW;

//#define SMALLER_SCREENSHOTS //smaller if /*image:...*/

using static Au.Controls.Sci;
using System.Drawing;
using System.Buffers;
using static Au.Controls.KImageUtil;

using Microsoft.CodeAnalysis;
using CAW::Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Text;
using Microsoft.CodeAnalysis.Shared.Extensions;
using CAW::Microsoft.CodeAnalysis.Shared.Extensions;
using Microsoft.CodeAnalysis.Classification;
using CAW::Microsoft.CodeAnalysis.Classification;
using CT = CAW::Microsoft.CodeAnalysis.Classification.ClassificationTypeNames;
using Au.Controls;

namespace LA;

partial class SciCode {
	struct _Image {
		public Bitmap image;
		public bool isImage; //draw frame; else icon, draw without frame
		public bool isComment; /*image:...*/
	}
	
	//fields for drawing images in margin
	struct _Images {
		public List<_Image> a; //images retrieved by _ImagesGet on styling
		public Dictionary<string, Bitmap> cache; //image cache of this document. Used only for non-icon images; for icons we use the common cache.
		public Sci_MarginDrawCallback callback;
		public IntPtr callbackPtr;
	}
	_Images _im;
	
	//Called by CiStyling._StylingAndFolding.
	internal void EImagesGet_(CodeInfo.Context cd, ClassifiedSpan[] a, in Sci_VisibleRange vr) {
		//if (App.Settings.edit_noImages) return; //caller does it, because it has some more work to do if need images
		//using var p1 = perf.local(); //fast when bitmaps loaded/cached
		
		if (a.Length > 0) aaaIndicatorClear(SciTheme.Indic.Images, true, a[0].TextSpan.Start..a[^1].TextSpan.End);
		
		string code = cd.code;
		int maxWidth = 0;
		int nextLineStart = 0;
		
		//CONSIDER: prefer /*image:...*/? Now, if before is eg "file path", displays file icon. Or draw both somehow.
		
		for (int i = 0; i < a.Length; i++) {
			if (a[i].TextSpan.Start < nextLineStart) continue; //max 1 image/line
			string s;
			ImageType imType = 0;
			bool isComment = false;
			if (_IsString(a[i], out var sr)) {
				imType = _ImageTypeFromString(false, code.AsSpan(sr.start, sr.Length));
				if (imType == 0) continue;
				s = sr.ToString();
			} else if (i < a.Length && a[i].ClassificationType == CT.Comment) {
				var ts = a[i].TextSpan;
				if (!code.Eq(ts.Start, "/*")) continue;
				int j = ts.Start + 2;
				while (j < ts.End && code[j] <= ' ') j++;
				if (!code.Eq(j, "image:")) continue;
				int k = code.Find("*/", j..ts.End); if (k <= j) continue;
				s = code[j..k];
				imType = ImageType.Base64Image;
				isComment = true;
			} else if (null != (s = _IsFoldersEtc(a[i], ref i, out imType))) {
				if (imType == 0) imType = _ImageTypeFromString(true, s);
			}
			if (imType == 0) continue;
			Bitmap b;
			bool isImage = imType is ImageType.Base64Image or ImageType.PngGifJpg or ImageType.Bmp or ImageType.Xaml;
			if (isImage) {
				if (!(_im.cache ??= new()).TryGetValue(s, out b)) {
					try { b = ImageUtil.LoadGdipBitmap(s, (_dpi, null)); }
					catch { b = null; }
					_im.cache[s] = b;
				}
			} else {
				b = IconImageCache.Common.Get(s, _dpi, imType == ImageType.XamlIconName);
			}
			if (b == null) continue;
			
			nextLineStart = code.IndexOf('\n', a[i].TextSpan.End) + 1;
			if (nextLineStart == 0) nextLineStart = code.Length;
			
			int start = a[i].TextSpan.Start;
			int line = aaaLineFromPos(true, start), vi = Call(SCI_VISIBLEFROMDOCLINE, line);
			if (vi >= vr.vlineFrom && vi < vr.vlineTo && 0 != Call(SCI_GETLINEVISIBLE, line))
				maxWidth = Math.Max(maxWidth, _ImageDisplaySize(!isImage, b, isComment).Width);
			
			if (_im.a == null) {
				_im.a = new();
				Call(SCI_INDICSETSTYLE, SciTheme.Indic.Images, INDIC_HIDDEN);
				int descent = Dpi.Scale(16, _dpi) - Call(SCI_TEXTHEIGHT) + Call(SCI_GETEXTRADESCENT) + Call(SCI_GETEXTRAASCENT);
				if (descent > 0) {
					bool caretVisible = AaWnd.ClientRect.Contains(0, Call(SCI_POINTYFROMPOSITION, 0, aaaCurrentPos8));
					Call(SCI_SETEXTRAASCENT, descent / 2);
					Call(SCI_SETEXTRADESCENT, descent - descent / 2);
					//note: later don't restore when no visible images. Then bad scrolling and can start to repeat.
					if (caretVisible) Call(SCI_SCROLLCARET);
				}
				if (_im.callback == null) _im.callbackPtr = Marshal.GetFunctionPointerForDelegate(_im.callback = _ImagesMarginDrawCallback);
				Call(SCI_SETMARGINDRAWCALLBACK, 1 << SciTheme.Margin.Images, _im.callbackPtr);
			}
			var ab = _im.a;
			int ii;
			for (ii = 0; ii < ab.Count; ii++) if (ab[ii].image == b) break;
			if (ii == ab.Count) ab.Add(new() { image = b, isImage = isImage, isComment = isComment });
			//print.it(ii, s);
			
			aaaIndicatorAdd(SciTheme.Indic.Images, true, start..(start + 1), ii + 1);
		}
		
		//maxWidth is 0 if no images or if all images are in folded regions.
		if (maxWidth > 0) maxWidth = Math.Min(maxWidth, Dpi.Scale(100, _dpi)) + 8;
		var (left, right) = aaaMarginGetX(SciTheme.Margin.Images);
		_ImagesMarginAutoWidth(right - left, maxWidth);
		if (maxWidth > 0) Api.InvalidateRect(AaWnd, new RECT(left, 0, maxWidth, short.MaxValue));
		//TODO3: draw only when need, ie when new indicators are different than old.
		//	Now draws on each text change, eg added character, unless changes are frequent. But not too slow.
		//	And probably then also draws all other margins.
		
		#region local util
		
		bool _Eq(int i, string ctype, string text = null)
			=> (uint)i < a.Length && a[i].ClassificationType == ctype && (text == null || code.Eq(a[i].TextSpan, text));
		
		bool _IsString(ClassifiedSpan v, out CiStringRange r) {
			r = default;
			bool verbatim = false;
			var ct = v.ClassificationType;
			if (!(ct == CT.StringLiteral || (verbatim = ct == CT.VerbatimStringLiteral))) return false;
			//skip short strings and $"string" parts
			int start = v.TextSpan.Start, end = v.TextSpan.End - 1;
			if (verbatim && code[start++] != '@') return false;
			if (end - start < 3 || code[end] != '"' || code[start++] != '"') return false;
			r = new(code, start, end, verbatim);
			return true;
		}
		
		string _IsFoldersEtc(ClassifiedSpan v, ref int i, out ImageType imageType) {
			imageType = 0;
			if (_Eq(i, CT.ClassName, "folders")) {
				if (_Eq(++i, CT.Operator, ".")) {
					int i1 = ++i;
					if (_Eq(i, CT.PropertyName)
						|| (_Eq(i, CT.ClassName, "shell") && _Eq(++i, CT.Operator, ".") && _Eq(++i, CT.PropertyName))
						) {
						var fp = folders.getFolder(code[a[i1].TextSpan.Start..a[i].TextSpan.End]);
						if (!fp.IsNull) return _Plus(fp, ref i);
					} else if (_Eq(i = i1, CT.MethodName) && _Eq(i + 1, CT.Punctuation, "(") && _Eq(i + 2, CT.Punctuation, ")")) {
						i += 2;
						if (code[a[i1].TextSpan.ToRange()] == "sourceCode") return _Plus(folders.sourceCode(_fn.FilePath), ref i);
					}
				}
			} else if (_Eq(i, CT.EnumName, "StockIcon")) {
				if (_Eq(++i, CT.Operator, ".") && _Eq(++i, CT.EnumMemberName))
					if (Enum.TryParse(code.AsSpan(a[i].TextSpan.ToRange()), out StockIcon si))
						if (icon.GetStockIconLocation_(si, out string path, out int index)) {
							imageType = ImageType.IconLib;
							return path + "," + index.ToS();
						}
			}
			return null;
			
			string _Plus(FolderPath fp, ref int i) {
				//print.it("FOLDERS", fp.Path);
				if (i < a.Length - 2 && (_Eq(i + 1, CT.OperatorOverloaded, "+") || _Eq(i + 1, CT.Operator, "+")) && _IsString(a[i + 2], out var r)) {
					i += 2;
					return fp + r.ToString();
				}
				return fp.Path;
			}
		}
		
		static ImageType _ImageTypeFromString(bool folders, RStr s/*, out int prefixLength*/) {
			//prefixLength = 0;
			if (s.Length < 2) return default;
			
			//special strings
			switch (s[0]) {
			case 'i' when s.StartsWith("image:"):
				//prefixLength = 6;
				return !folders && s.Length >= 10 ? ImageType.Base64Image : default;
			case 'i' when s.StartsWith("imagefile:"):
				if (folders) return default;
				s = s[10..];
				//prefixLength = 10;
				break;
			case '<':
				if (s.Contains("xmlns='http://schemas.microsoft.com/winfx/2006/xaml/presentation'", StringComparison.Ordinal)) {
					if (s.Contains("<Path ", StringComparison.Ordinal) || s.Contains("<GeometryDrawing ", StringComparison.Ordinal)) return ImageType.Xaml;
				}
				return default;
			case '*':
				if (DIcons.PossiblyIconName(s)) return ImageType.XamlIconName;
				return default;
			case '.':
				return pathname.IsExtension_(s) ? ImageType.ShellIcon : default;
			case ':':
				return s[1] == ':' ? ImageType.ShellIcon : default;
			}
			
			//file path or URL
			//string expanded = null;
			//if (s[0] == '%') {
			//	expanded = pathname.expand(s.ToString(), strict: false);
			//	if (expanded.Length < 8 || expanded[0] == '%') return default;
			//	s = expanded;
			//}
			if (s is ['/' or '\\', '/' or '\\', ..]) return default; //would hang for several s if string like "//bad/network/path", eg xpath. String like @"\\..." is dangerous here too. Also can be a mapped drive like "N:\path", but at least it's probably a path string.
			if (pathname.isFullPath(s, orEnvVar: true)) { //is image file path?
				if (s.Length >= 8) { //can be image file. Else can be eg "C:\" or "C:\A".
					if (s[^4] == '.') {
						var ext = s[^3..];
						if (ext.Eqi("png") || ext.Eqi("gif") || ext.Eqi("jpg")) return ImageType.PngGifJpg;
						if (ext.Eqi("bmp")) return ImageType.Bmp;
						if (ext.Eqi("ico")) return ImageType.Ico;
						if (ext.Eqi("cur") || ext.Eqi("ani")) return ImageType.Cur;
					} else if (s[^1].IsAsciiDigit() && s.Contains(',')) { //can be like C:\x.dll,10
						if (icon.parsePathIndex(s.ToString(), out _, out _)) return ImageType.IconLib;
					}
				} else if (s.Length < 4 && s[1] != ':') return default; //eg "\\"
			} else {
				if (s.Length < 4) return default;
				if (pathname.isUrl(s)) {
					//display icon only for known protocols that can be used with run.it(). Ignore "web:LINK" etc and protocols with common icon (eg "http:").
					if (!(s.Starts("shell:") || s.Starts("ms-settings:"))) return default;
				} else if (!s.EndsWith(".cs", StringComparison.OrdinalIgnoreCase)) return default;
			}
			
			return ImageType.ShellIcon;
		}
		
		#endregion
	}
	
	unsafe void _ImagesMarginDrawCallback(ref Sci_MarginDrawCallbackData c) {
		//print.it(c.rect, c.firstLine, c.lastLine);
		//using var p1 = perf.local();
		
		int pos = aaaLineStart(false, c.firstLine) - 1, posEnd = aaaLineEnd(false, c.lastLine);
		int topVisibleLine = Call(SCI_GETFIRSTVISIBLELINE), lineH = Call(SCI_TEXTHEIGHT);
		int maxWidth = 0;
		Graphics g = null;
		try {
			for (; ; pos++) {
				pos = Call(SCI_INDICATOREND, SciTheme.Indic.Images, pos); //skip non-indicator range
				if (pos <= 0 || pos >= posEnd) break; //after the visible range or at the end of text
				int i = Call(SCI_INDICATORVALUEAT, SciTheme.Indic.Images, pos) - 1;
				if ((uint)i >= _im.a.Count) break; //should never
				int line = aaaLineFromPos(false, pos);
				if (0 == Call(SCI_GETLINEVISIBLE, line)) continue; //folded?
				
				//print.it(pos, i, line);
				var v = _im.a[i];
#if SMALLER_SCREENSHOTS
				bool smaller = v.isComment;
				var z = _ImageDisplaySize(!v.isImage, v.image, smaller);
#else
				var z = _ImageDisplaySize(!v.isImage, v.image, false);
#endif
				maxWidth = Math.Max(maxWidth, z.Width);
				int x = c.rect.CenterX - z.Width / 2;
				int y = (Call(SCI_VISIBLEFROMDOCLINE, line) - topVisibleLine) * lineH;
				
				RECT r = new(x, y, z.Width, z.Height);
				if (!c.rect.IntersectsWith(r)) continue;
				if (g == null) {
					g = Graphics.FromHdc(c.hdc);
					g.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.HighQualityBicubic;
				}
				
				g.IntersectClip(c.rect); //limit image width, because not clipped
				
				if (v.isImage) g.DrawRectangleInset(Color.Green, 1, r, outset: true);
				g.DrawImage(v.image, r);
			}
		}
		catch (Exception ex) { Debug_.Print(ex); }
		finally {
			g?.Dispose();
		}
		
		//auto-correct margin width, in case _ImagesGet not called because styling is valid.
		//	Need it eg after expanding/collapsing a folding containing images. Also sometimes after resizing the control or after zoom changed.
		if (maxWidth > 0) maxWidth = Math.Min(maxWidth, Dpi.Scale(100, _dpi)) + 8;
		int oldWidth = c.rect.Width;
		if (maxWidth != oldWidth)
			if (maxWidth > oldWidth || (c.rect.top == 0 && c.rect.bottom == AaWnd.ClientRect.bottom))
				_ImagesMarginAutoWidth(oldWidth, maxWidth);
	}
	
	void _ImagesMarginAutoWidth(int oldWidth, int width) {
		if (width == oldWidth) return;
		//when shrinking, in wrap mode could start autorepeating, when makes less lines wrapped and it uncovers wider images at the bottom and need to expand again.
		//	Tried to delay or to not change if changed recently, but not good. Never mind.
		if (width < oldWidth && App.Settings.edit_wrap) return;
		AaWnd.Post(SCI_SETMARGINWIDTHN, SciTheme.Margin.Images, width);
	}
	
	void _ImagesOnOff() {
		if (App.Settings.edit_noImages == (_im.a == null)) return;
		if (_im.a != null) {
			Call(SCI_SETMARGINDRAWCALLBACK);
			Call(SCI_SETMARGINWIDTHN, SciTheme.Margin.Images, 0);
			Call(SCI_SETEXTRAASCENT, 0);
			Call(SCI_SETEXTRADESCENT, 1);
			aaaIndicatorClear(SciTheme.Indic.Images);
			_im.a = null;
		} else {
			if (this == Panels.Editor.ActiveDoc) CodeInfo._styling.Update();
		}
	}
	
	Size _ImageDisplaySize(bool isIcon16, Bitmap b, bool smaller) {
		var z = b.Size;
		if (isIcon16) {
			var k = Dpi.Scale(16, _dpi);
			z = new(k, k);
		} else {
			int hr = b.HorizontalResolution.ToInt(), vr = b.VerticalResolution.ToInt();
			if (hr >= 96 && vr >= 96) z = new(Math2.MulDiv(z.Width, _dpi, hr), Math2.MulDiv(b.Height, _dpi, vr));
		}
#if SMALLER_SCREENSHOTS
		if (smaller) return new(z.Width * 3 / 4, z.Height * 3 / 4);
#endif
		return z;
	}
	
	/// <summary>
	/// Finds all /*image:Base64*/ and @"image:Base64" in scintilla text range from8..to8 (UTF-8) and sets style STYLE_HIDDEN for the Base64.
	/// If <i>styles</i> != null, writes STYLE_HIDDEN in <i>styles</i>, else uses SCI_STARTSTYLING/SCI_SETSTYLING.
	/// </summary>
	/// <remarks>
	/// Called on SCN_STYLENEEDED (to avoid bad things like briefly visible and added horizontal scrollbar) and then by CiStyling._Work (async).
	/// </remarks>
	internal unsafe void EHideImages_(int from8, int to8, Span<byte> styles = default, [CallerMemberName] string caller = null) {
		if (styles.IsNull()) from8 = aaaLineStartFromPos(false, from8);
		if (to8 - from8 < 49) return;
		
		var r = new Au.Controls.SciDirectRange(this, from8, to8);
		for (int j = from8 + 2, to2 = to8 - 47; j <= to2;) {
			int i = j;
			for (; ; i++) {
				if (i > to2) return;
				if (r[i] == 'i' && r[i + 1] == 'm' && r[i + 2] == 'a' && r[i + 3] == 'g' && r[i + 4] == 'e' && r[i + 5] == ':') break;
			}
			j = i + 6;
			
			char c1 = r[i - 1], c2 = r[i - 2];
			if (!((c1 == '*' && c2 == '/') || (c1 == '"' && c2 == '@'))) continue;
			
			int j2 = to8 - (c1 == '"' ? 1 : 2);
			while (j < j2 && r[j] is (>= 'A' and <= 'Z') or (>= 'a' and <= 'z') or (>= '0' and <= '9') or '+' or '/') j++;
			if (j - i < 46) continue; //match regex image:[A-Za-z0-9/+]{40,}
			while (j < j2 && r[j] == '=') j++;
			
			if (r[j] != c1 || (c1 == '*' && '/' != r[j + 1])) continue;
			if (c1 == '"') i += 6; else { i -= 2; j += 2; }
			
			if (!styles.IsNull()) {
				styles.Slice(i - from8, j - i).Fill(STYLE_HIDDEN);
			} else {
				Call(SCI_STARTSTYLING, i);
				Call(SCI_SETSTYLING, j - i, STYLE_HIDDEN);
			}
		}
		
		//note: don't use SCI_SETTARGETRANGE here. In some cases scintilla does not work well with it. It may create bugs.
	}
	//Not easy to use hidden style because:
	//	1. Scintilla bug: in wrap mode sometimes draws as many lines as with big font. Even caret is large and spans all lines.
	//		Plus other anomalies, eg when scrolling.
	//		Workaround: at first hide all on SCN_STYLENEEDED.
	//	2. User cannot delete text containing hidden text.
	//		Workaround: modify scintilla source in Editor::RangeContainsProtected.
	
	bool _ImageDeleteKey(KKey key) {
		if (key is KKey.Delete or KKey.Back && !base.aaaHasSelection) {
			int pos = base.aaaCurrentPos8, to = pos;
			if (key == KKey.Back) {
				while (aaaStyleGetAt(pos - 1) == STYLE_HIDDEN) pos--;
			} else {
				while (aaaStyleGetAt(to) == STYLE_HIDDEN) to++;
			}
			if (to > pos) {
				bool ok = s_imageDeleteAlways;
				if (!ok) {
					var s = base.aaaRangeText(false, pos, to).Limit(50);
					var c = new DControls { Checkbox = "Remember" };
					ok = 1 == dialog.show("Delete hidden text?", s, "OK|Cancel", controls: c, owner: this);
					s_imageDeleteAlways = ok && c.IsChecked;
				}
				if (ok) {
					aaaDeleteRange(false, pos, to);
					aaaAddUndoPoint();
					return true;
				}
			}
		}
		return false;
	}
	static bool s_imageDeleteAlways;
	
	static string _ImageRemoveScreenshots(string s, bool onCopy) {
		//s = s.RxReplace(@"/\*image:[A-Za-z0-9/+]{40,}=*\*/", "");
		//var s2 = s.RxReplace(@"""image:[A-Za-z0-9/+]{40,}=*""", @"""image:""");
		//if (s2 != s)
		//	if (dialog.showYesNo("Remove all images?", "This will replace strings \"image:<hidden image data>\" with \"image:\" in the copied text.")) s = s2;
		
		int n = s.RxReplace(@"/\*image:[A-Za-z0-9/+]{40,}=*\*/", "", out s);
		if (onCopy && n > 0) print.it($"Info: in the copied code have been removed {n} images embedded in hidden comments. The script can run without them.");
		n = s.RxReplace(@"""image:[A-Za-z0-9/+]{40,}=*""", @"""image:""", out s);
		if (onCopy && n > 0) print.it($"Info: in the copied code have been removed {n} images embedded in strings \"image:<hidden image data>\". You can copy-paste the strings separately if necessary.");
		return s;
	}
	
	public void EImageRemoveScreenshots() {
		if (aaaIsReadonly || !_fn.IsCodeFile) return;
		bool isSel = aaaHasSelection;
		string s = isSel ? aaaSelectedText() : aaaText;
		var s2 = _ImageRemoveScreenshots(s, false);
		if (s2 == s) return;
		if (isSel) EReplaceTextGently(aaaSelectionStart8, aaaSelectionEnd8, s2);
		else EReplaceTextGently(s2);
	}
}


================================================
FILE: Au.Editor/Edit/SciCode.cs
================================================
using Au.Controls;
using static Au.Controls.Sci;
using System.Windows;
using System.Windows.Input;
using System.Windows.Controls;

using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp.Syntax;

namespace LA;

partial class SciCode : KScintilla {
	readonly aaaFileLoaderSaver _fls;
	readonly FileNode _fn;
	
	public FileNode EFile => _fn;
	
	public override string ToString() => _fn.ToString();
	
	internal SciCode(FileNode file, aaaFileLoaderSaver fls) {
		_fn = file;
		_fls = fls;
		
		if (fls.IsBinary) AaInitReadOnlyAlways = true;
		if (fls.IsImage) {
			AaInitImages = true;
			AaInitTagsStyle = AaTagsStyle.User;
		}
		
		Name = "document";
	}
	
	protected override void AaOnHandleCreated() {
		Call(SCI_SETMODEVENTMASK, (int)(MOD.SC_MOD_INSERTTEXT | MOD.SC_MOD_DELETETEXT | MOD.SC_MOD_BEFOREDELETE /*| MOD.SC_MOD_INSERTCHECK | MOD.SC_MOD_BEFOREINSERT*/
			//| MOD.SC_MOD_CHANGEFOLD //only when text modified, but not when user clicks +-
			));
		
		aaaMarginSetType(SciTheme.Margin.Images, SC_MARGIN_COLOUR, markersMask: 0);
		Call(SCI_SETMARGINBACKN, SciTheme.Margin.Images, Api.GetSysColor(Api.COLOR_BTNFACE));
		aaaMarginSetWidth(SciTheme.Margin.Images, 0);
		
		aaaMarginSetType(SciTheme.Margin.Markers, SC_MARGIN_COLOUR, markersMask: 0x1FFFFFF, sensitive: true, cursorArrow: true);
		aaaMarginSetWidth(SciTheme.Margin.Markers, 16);
		
		aaaMarginSetType(SciTheme.Margin.LineNumbers, SC_MARGIN_NUMBER);
		
		aaaMarginSetWidth(SciTheme.Margin.Changes, 10);
		aaaMarginSetWidth(-1, 2);
		
		Call(SCI_SETWRAPMODE, App.Settings.edit_wrap ? SC_WRAP_WORD : 0);
		Call(SCI_SETINDENTATIONGUIDES, SC_IV_REAL);
		Call(SCI_ASSIGNCMDKEY, Math2.MakeLparam(SCK_RETURN, SCMOD_CTRL | SCMOD_SHIFT), SCI_NEWLINE);
		Call(SCI_SETEXTRADESCENT, 1); //eg to avoid drawing fold separator lines on text
		Call(SCI_SETMOUSEDWELLTIME, 500);
		Call(SCI_SETUNDOSELECTIONHISTORY, 1); //BAD: uses too much memory. Documented: >=150 / action. Tested: 270 (same when 1-char and when coalesced 10 char). Without this somehow the heap does not grow. It seems there is no easy workaround; temporarily turning off this feature clears the selection undo history.
		
		Call(SCI_SETLAYOUTTHREADS, Environment.ProcessorCount);
//#if IDE_LA //works if don't need to draw images, else crashes because there is no HDC. Need to reimplement the drawing functions, to use ID2D1RenderTarget instead of HDC. Much work. The benefit would be antialiased drawing of Scintilla's markers etc, but we don't use them. Text looks differently. Uses + 25 MB of memory.
//		Call(SCI_SETTECHNOLOGY, SC_TECHNOLOGY_DIRECTWRITEDC);
//#endif
		
		SciTheme.Current.ToScintilla(this);
		
		_OnHandleCreatedOrDpiChanged();
		if (_fn.IsCodeFile) CiFolding.InitFolding(this);
		_InitDragDrop();
		
		//C# interprets Unicode newline characters NEL, LS and PS as newlines.
		//	If editor does not support it, line numbers in errors/warnings/stacktraces may be incorrect.
		//	Visual Studio supports it. VSCode no; when pasted, suggests to replace to normal.
		//	Scintilla supports it (SCI_SETLINEENDTYPESALLOWED) only if using C++ lexer.
		//		Modified: now supports by default.
		//	Ascii VT and FF are not interpreted as newlines by C# and Scintilla.
	}
	
	void _OnHandleCreatedOrDpiChanged() {
		_IndicatorsInit();
		_DefineIconMarkers();
		Call(SCI_SETXCARETPOLICY, CARET_STRICT | CARET_EVEN | CARET_SLOP, _dpi / 2);
	}
	
	protected override void OnDpiChanged(DpiScale oldDpi, DpiScale newDpi) {
		base.OnDpiChanged(oldDpi, newDpi);
		if (!AaWnd.Is0) _OnHandleCreatedOrDpiChanged();
	}
	
	protected override void DestroyWindowCore(HandleRef hwnd) {
		CodeInfo._styling.DocHandleDestroyed(this);
		base.DestroyWindowCore(hwnd);
	}
	
	//~SciCode() { print.it("~SciCode"); } //note: never called, because Dispose (called by PanelEdit) calls GC.SuppressFinalize. To test this, call GC.ReRegisterForFinalize(this) in DestroyWindowCore.
	
	//Called by PanelEdit.Open.
	internal void EInit_(bool newFile, bool noTemplate) {
		Debug.Assert(!AaWnd.Is0);
		
		bool editable = _fls.SetText(this);
		if (!EIsBinary) {
			_fn._UpdateFileModTime();
			//if (_fn.DontSave) aaaIsReadonly = true; //rejected. Never make editor readonly when opened a text file. Would need too many `if (doc.aaaIsReadonly) return;` etc everywhere.
			if (_fn.DontSave) print.it($"<>Warning: Don't edit {_fn.SciLink()}. It will not be saved. It will be replaced when updating this app.");
		}
		ESetLineNumberMarginWidth_();
		
		if (newFile) _openState = noTemplate ? _EOpenState.NewFileNoTemplate : _EOpenState.NewFileFromTemplate;
		else if (App.Model.OpenFiles.Contains(_fn)) _openState = _EOpenState.Reopen;
		
		if (_fn.IsCodeFile) CiStyling.DocTextAdded();
		Panels.Bookmarks.SciLoaded(this);
		Panels.Breakpoints.SciLoaded(this);
		App.Model.EditGoBack.OnPosChanged(this);
		
		//detect \r without '\n', because it is not well supported. Also NEL, LS, PS.
		if (editable) {
			if (_fls.DetectBadNewlines()) {
				print.it($@"<>Note: text of {_fn.Name} contains unusual line end characters. <+badNL s>Show<>, <+badNL h>hide<>, <+badNL f>fix<>.");
				if (!s_badNewlines) {
					s_badNewlines = true;
					Panels.Output.Scintilla.AaTags.AddLinkTag("+badNL", static s1 => {
						var doc = Panels.Editor.ActiveDoc;
						if (doc != null) {
							if (s1.Starts('f')) {
								if (!doc.aaaIsReadonly) doc.aaaText = doc.aaaText.ReplaceLineEndings();
								//info: ReplaceLineEndings also replaces single \n and FF.
								//	SCI_CONVERTEOLS ignores NEL, LS, PS.
							} else {
								doc.Call(SCI_SETVIEWEOL, s1.Starts('s') ? 1 : 0);
							}
						}
					});
				}
			}
		}
		
		_fls.FinishedLoading();
	}
	static bool s_badNewlines;
	
	internal void EOpenDocActivated() {
		_fn._CheckModifiedExternally(this);
		App.Model.EditGoBack.OnPosChanged(this);
	}
	
	protected override void AaOnSciNotify(ref SCNotification n) {
		bool isActive = this == Panels.Editor.ActiveDoc;
		//if (isActive) {
		//	//if (test_) {
		//		switch (n.nmhdr.code) {
		//		case NOTIF.SCN_UPDATEUI:
		//		case NOTIF.SCN_NEEDSHOWN:
		//		case NOTIF.SCN_PAINTED:
		//		case NOTIF.SCN_FOCUSIN:
		//		case NOTIF.SCN_FOCUSOUT:
		//		case NOTIF.SCN_DWELLSTART:
		//		case NOTIF.SCN_DWELLEND:
		//			break;
		//		case NOTIF.SCN_MODIFIED:
		//			print.it(n.nmhdr.code, n.modificationType);
		//			break;
		//		default:
		//			print.it(n.nmhdr.code);
		//			break;
		//		}
		//	//}
		//} else {
		//	//#if DEBUG
		//	//			if (n.code is not (NOTIF.SCN_FOCUSOUT or NOTIF.SCN_DWELLEND
		//	//				or NOTIF.SCN_SAVEPOINTLEFT or NOTIF.SCN_SAVEPOINTREACHED or NOTIF.SCN_MODIFIED or NOTIF.SCN_UPDATEUI or NOTIF.SCN_STYLENEEDED
		//	//				)) Debug_.Print($"AaOnSciNotify in background, {_fn}, {n.nmhdr.code}");
		//	//#endif
		//}
		
		switch (n.code) {
		case NOTIF.SCN_MODIFIED:
			//print.it("SCN_MODIFIED", n.modificationType, n.position, n.FinalPosition, aaaCurrentPos8, n.Text);
			if (n.modificationType.HasAny(MOD.SC_MOD_INSERTTEXT | MOD.SC_MOD_DELETETEXT)) {
				App.Model.Save.TextLater(); //just compares/sets a field. Note: don't use SCN_SAVEPOINTLEFT. No SCN_SAVEPOINTLEFT if text modified externally. Then would not save subsequent changes in editor.
				_modified = true;
				_TempRangeOnModifiedOrPosChanged(n.modificationType, n.position, n.length);
				_ManageUndoOnModified(n.modificationType);
				SnippetMode_?.SciModified(n);
				if (isActive) {
					if (CodeInfo.SciModified(this, n)) _CodeModifiedAndCodeinfoOK(); //WPF preview
					Panels.Find.UpdateQuickResults();
				}
				Panels.Bookmarks.SciModified(this, n);
				Panels.Breakpoints.SciModified(this, n);
				Panels.Found.SciModified(this, n);
				App.Model.EditGoBack.SciModified(this, n.modificationType.Has(MOD.SC_MOD_DELETETEXT), n.position, n.length);
				if (n.linesAdded != 0) ESetLineNumberMarginWidth_(onModified: true);
			}
			break;
		case NOTIF.SCN_UPDATEUI:
			//note: SCN_UPDATEUI is async. Can be isActive true in SCN_MODIFIED but false in SCN_UPDATEUI. Or vice versa.
			//print.it(_modified, n.updated);
			if (n.updated.Has(UPDATE.SC_UPDATE_CONTENT)) {
				if (_modified) _modified = false;
				else if ((n.updated &= ~UPDATE.SC_UPDATE_CONTENT) == 0) break; //ignore when changed styling or markers
			}
			if (n.updated.HasAny(UPDATE.SC_UPDATE_CONTENT | UPDATE.SC_UPDATE_SELECTION)) {
				if (!n.updated.Has(UPDATE.SC_UPDATE_CONTENT)) _TempRangeOnModifiedOrPosChanged(0, 0, 0);
				if (isActive) {
					if (n.updated.Has(UPDATE.SC_UPDATE_SELECTION)) App.Model.EditGoBack.OnPosChanged(this);
					Panels.Editor.UpdateUI_EditEnabled_();
				}
			}
			if (isActive) {
				if ((n.updated & (UPDATE.SC_UPDATE_CONTENT | UPDATE.SC_UPDATE_SELECTION)) == UPDATE.SC_UPDATE_SELECTION) SnippetMode_?.SciPosChanged();
				CodeInfo.SciUpdateUI(this, n.updated);
			}
			break;
		case NOTIF.SCN_CHARADDED when isActive:
			//print.it($"SCN_CHARADDED  {n.ch}  '{(char)n.ch}'");
			if (n.ch == '\n' /*|| n.ch == ';'*/) { //split scintilla Undo
				aaaAddUndoPoint();
			}
			if (n.ch != '\r' && n.ch <= 0xffff) { //on Enter we receive notifications for '\r' and '\n'
				CodeInfo.SciCharAdded(this, (char)n.ch);
			}
			break;
		case NOTIF.SCN_DWELLSTART when isActive:
			CodeInfo.SciMouseDwellStarted(this, n.position);
			Panels.Breakpoints.SciMouseDwell_(true, this, n);
			break;
		case NOTIF.SCN_DWELLEND when isActive:
			Panels.Breakpoints.SciMouseDwell_(false, this, n);
			break;
		case NOTIF.SCN_MARGINCLICK when isActive:
			if (_fn.IsCodeFile) {
				CodeInfo.Cancel();
				if (n.margin == SciTheme.Margin.Fold) {
					_FoldOnMarginClick(n.position, n.modifiers);
				}
			}
			if (n.margin == SciTheme.Margin.Markers) {
				if (n.modifiers is 0) _MarkersMarginClicked(false, n.position);
			}
			break;
		//case NOTIF.SCN_MARGINRIGHTCLICK: break; //can't use it because: 1. Need to handle WM_RBUTTONDOWN. 2. Need notification on button up.
		case NOTIF.SCN_STYLENEEDED:
			//print.it("SCN_STYLENEEDED");
			if (isActive && _fn.IsCodeFile) {
				EHideImages_(Call(SCI_GETENDSTYLED), n.position);
				Call(SCI_STARTSTYLING, n.position); //need this even if would not hide images
			} else {
				aaaSetStyled();
			}
			break;
		}
		
		base.AaOnSciNotify(ref n);
	}
	bool _modified;
	
	protected override nint WndProc(wnd w, int msg, nint wp, nint lp) {
		//WndUtil.PrintMsg(w, msg, wp, lp, new(Api.WM_TIMER, Api.WM_PAINT, Api.WM_MOUSEMOVE, Api.WM_NCHITTEST, Api.WM_SETCURSOR));
		
		switch (msg) {
		case Api.WM_CHAR: {
				int c = (int)wp;
				if (c < 32) {
					if (c is not (9 or 10 or 13)) return 0;
				} else {
					if (CodeInfo.SciBeforeCharAdded(this, (char)c)) return 0;
				}
			}
			break;
		//rejected. Possibly can be bad in some cases. I can't learn and test everything.
		//case Api.WM_IME_COMPOSITION: //to add missing newline, because no WM_CHAR when using IME
		//	if (0 != (lp & 0x800)) //GCS_RESULTSTR; Scintilla uses it.
		//		CodeInfo.SciBeforeCharAdded(this, default);
		//	break;
		case Api.WM_RBUTTONDOWN or Api.WM_MBUTTONDOWN: {
				POINT p = Math2.NintToPOINT(lp);
				int margin = aaaMarginFromPoint(p);
				if (margin >= 0) {
					if (msg == Api.WM_RBUTTONDOWN) {
						//prevent changing the caret/selection when rclicked some margins
						if (margin is SciTheme.Margin.Fold or SciTheme.Margin.Markers) return 0;
						
						//prevent changing the caret/selection if it is in the rclicked line
						var selStart = aaaSelectionStart8;
						var (_, start, end) = aaaLineStartEndFromPos(false, aaaPosFromXY(false, p, false));
						if (selStart >= start && selStart <= end) return 0;
						//do vice versa if the end of non-empty selection is at the start of the rclicked line, to avoid comment/uncomment wrong lines
						if (margin is SciTheme.Margin.LineNumbers or SciTheme.Margin.Images or SciTheme.Margin.Changes) {
							if (aaaSelectionEnd8 == start) aaaGoToPos(false, start); //clear selection above start
						}
					} else if (margin == SciTheme.Margin.Markers) {
						int pos = aaaPosFromXY(false, p, false);
						if (pos >= 0) {
							int line = aaaLineFromPos(false, pos);
							if (!Panels.Breakpoints.SciMiddleClick_(this, line)) Panels.Bookmarks.SciMiddleClick_(this, line);
						}
					}
				}
			}
			break;
		case Api.WM_RBUTTONUP: {
				POINT p = Math2.NintToPOINT(lp);
				int margin = aaaMarginFromPoint(p);
				if (margin >= 0) {
					switch (margin) {
					case SciTheme.Margin.LineNumbers or SciTheme.Margin.Images or SciTheme.Margin.Changes:
						ModifyCode.Comment(null, notSlashStar: true);
						break;
					case SciTheme.Margin.Markers:
						_MarkersMarginClicked(true, base.aaaPosFromXY(false, p, false));
						break;
					case SciTheme.Margin.Fold:
						_FoldContextMenu(aaaPosFromXY(false, p, false));
						break;
					}
					return 0;
				}
			}
			break;
		case Api.WM_CONTEXTMENU: {
				bool kbd = (int)lp == -1;
				var m = new KWpfMenu();
				DCustomizeContextMenu.AddToMenu(m, "Edit");
				App.Commands[nameof(Menus.Edit)].CopyToMenu(m);
				m.Show(this, byCaret: kbd);
				return 0;
			}
		}
		
		var R = base.WndProc(w, msg, wp, lp);
		
		switch (msg) {
		case Api.WM_KILLFOCUS:
			CodeInfo.SciKillFocus(this);
			break;
		}
		
		return R;
	}
	
	void _MarkersMarginClicked(bool rclick, int pos8) {
		int line = aaaLineFromPos(false, pos8);
		var m = new popupMenu();
#if !true //breakpoints if left click, bookmarks if right click
		if (rclick) {
			Panels.Bookmarks.AddMarginMenuItems_(this, m, pos8);
		} else if (EFile.IsCodeFile) {
			Panels.Breakpoints.AddMarginMenuItems_(this, m, line, pos8);
			Panels.Debug.AddMarginMenuItems_(this, m, line);
		}
#else //breakpoints and bookmarks in single menu, but bookmarks first if rclick
		if (rclick) Panels.Bookmarks.AddMarginMenuItems_(this, m, pos8);
		if (EFile.IsCodeFile) {
			if (rclick) m.Separator();
			Panels.Breakpoints.AddMarginMenuItems_(this, m, line, pos8);
			Panels.Debug.AddMarginMenuItems_(this, m, line);
			if (!rclick) m.Separator();
		}
		if (!rclick) Panels.Bookmarks.AddMarginMenuItems_(this, m, pos8);
#endif
		var xy = mouse.xy; xy.Offset(-_dpi / 2, -_dpi / 8);
		m.Show(xy: xy, owner: AaWnd);
	}
	
	protected override bool TranslateAcceleratorCore(ref System.Windows.Interop.MSG msg, ModifierKeys mod) {
		if (msg.message is Api.WM_KEYDOWN or Api.WM_SYSKEYDOWN) {
			var key = (KKey)msg.wParam;
			if (_ImageDeleteKey(key)) return true;
			if (CodeInfo.SciCmdKey(this, key, mod)) return true;
			switch ((key, mod)) {
			case (KKey.Enter, 0):
			case (KKey.Enter, ModifierKeys.Control | ModifierKeys.Shift):
				aaaAddUndoPoint();
				break;
			}
		}
		return base.TranslateAcceleratorCore(ref msg, mod);
	}
	
	protected override void OnGotFocus(RoutedEventArgs e) {
		if (!_noModelEnsureCurrentSelected) App.Model.EnsureCurrentSelected();
		base.OnGotFocus(e);
	}
	bool _noModelEnsureCurrentSelected;
	
	internal bool EIsUnsaved_ {
		get => _isUnsaved || 0 != Call(SCI_GETMODIFY);
		set {
			if (_isUnsaved = value) App.Model.Save.TextLater(1);
		}
	}
	bool _isUnsaved;
	
	public bool EIsBinary => _fls.IsBinary;
	
	//Called by PanelEdit.SaveText.
	internal bool ESaveText_(bool force) {
		Debug.Assert(!EIsBinary); if (EIsBinary) return false;
		if (_fn.DontSave) return true;
		if (force || EIsUnsaved_) {
			//print.qm2.write("saving");
			if (!App.Model.TryFileOperation(FOSync.UserFileWrite, () => _fls.Save(this, _fn.FilePath))) return false;
			_isUnsaved = false;
			Call(SCI_SETSAVEPOINT); //note: splits Undo. Maybe it's good. But I don't remember what is the primary purpose of this. VS splits Undo on save too.
			_fn._UpdateFileModTime();
			if (this != Panels.Editor.ActiveDoc) CodeInfo.FilesChanged();
		}
		return true;
	}
	
	//Called by FileNode.CheckModifiedExternally_.
	internal void EFileModifiedExternally_() {
		Debug.Assert(!EIsBinary); if (EIsBinary) return; //caller must check it
		if (!_fn.GetFileText(out var text) || text == this.aaaText) return;
		EReplaceTextGently(text);
		Call(SCI_SETSAVEPOINT);
		
		//rejected: print info. VS and VSCode reload silently.
		//if (this == Panels.Editor.ActiveDoc) print.it($"<>Info: file {_fn.SciLink()} has been reloaded because modified outside. You can Undo.");
	}
	
	//never mind: not called when zoom changes.
	internal void ESetLineNumberMarginWidth_(bool onModified = false) {
		int c = 4;
		int lines = aaaLineCount;
		while (lines > 999) { c++; lines /= 10; }
		if (!onModified || c != _prevLineNumberMarginWidth) aaaMarginSetWidth(SciTheme.Margin.LineNumbers, 3, _prevLineNumberMarginWidth = c);
	}
	int _prevLineNumberMarginWidth;
	
	protected override void AaOnDeletingLineWithMarkers(int line, uint markers) {
		if ((markers & 3 << SciTheme.Marker.Bookmark) != 0) Panels.Bookmarks.SciDeletingLineWithMarker(this, line);
		if ((markers & 63 << SciTheme.Marker.Breakpoint) != 0) Panels.Breakpoints.SciDeletingLineWithMarker(this, line);
		base.AaOnDeletingLineWithMarkers(line, markers);
	}
	
	internal CiSnippetMode SnippetMode_;
	
	#region copy paste
	
	/// <summary>
	/// Called when copying (menu or Ctrl+C).
	/// Caller must not copy text to clipboard, and must not pass the event to Scintilla.
	/// </summary>
	public void ECopy(ECopyAs copyAs = ECopyAs.Text) {
		int i1 = aaaSelectionStart8, i2 = aaaSelectionEnd8, textLen = aaaLen8;
		if (textLen == 0) return;
		if (copyAs == ECopyAs.Text) {
			if (i2 != i1) Call(SCI_COPY);
		} else {
			bool isCS = _fn.IsCodeFile, isFragment = i2 != i1 && !(i1 == 0 && i2 == textLen);
			string s = isFragment ? aaaRangeText(false, i1, i2) : aaaText;
			if (isCS) s = _ImageRemoveScreenshots(s, true);
			switch (copyAs) {
			case ECopyAs.Forum:
				var b = new StringBuilder("[code]");
				if (isCS) {
					if (!isFragment) {
						var name = _fn.Name; if (name.RxIsMatch(_fn.IsScript ? @"(?i)^Script\d*\.cs$" : @"(?i)^Class\d*\.cs$")) name = null;
						if (!(name == null && _fn.IsScript)) b.AppendFormat("// {0} \"{1}\"\r\n", _fn.IsScript ? "script" : "class", name);
					}
					s = CodeExporter.ExportForum(s);
				}
				s = b.Append(s).AppendLine("[/code]").ToString();
				break;
			case ECopyAs.HtmlSpanStyle or ECopyAs.HtmlSpanClass or ECopyAs.HtmlSpanClassCss:
				s = CodeExporter.ExportHtml(s, spanClass: copyAs != ECopyAs.HtmlSpanStyle, withCss: copyAs == ECopyAs.HtmlSpanClassCss);
				new clipboardData().AddText(s).AddHtml(s).SetClipboard();
				return;
			case ECopyAs.Markdown:
				s = $"```csharp\r\n{s}\r\n```\r\n";
				break;
				//case ECopyAs.TextWithoutScreenshots:
			}
			clipboard.text = s;
		}
	}
	
	public enum ECopyAs { Text, Forum, HtmlSpanStyle, HtmlSpanClassCss, HtmlSpanClass, Markdown, TextWithoutScreenshots }
	
	/// <summary>
	/// Called when pasting (menu or Ctrl+V). Inserts text, possibly with processed forum bbcode etc.
	/// Caller must not insert text, and must not pass the event to Scintilla.
	/// </summary>
	public void EPaste() {
		var s1 = clipboard.text; if (s1.NE()) return;
		
		var (isFC, text, name, isClass) = EIsForumCode_(s1, false);
		if (isFC) {
			string buttons = _fn.FileType != (isClass ? FNType.Class : FNType.Script) || aaaIsReadonly
				? "1 Create new file|0 Cancel"
				: "1 Create new file|2 Replace all text|3 Paste|0 Cancel";
			switch (dialog.show("Import C# file text from clipboard", "Source file: " + name, buttons, DFlags.CommandLinks, owner: AaWnd)) {
			case 1: //Create new file
				_NewFileFromForumCode(text, name, isClass);
				break;
			case 2: //Replace all text
				aaaSetText(text);
				break;
			case 3: //Paste
				using (new CodeInfo.PastingEtc(this))
					aaaReplaceSel(text);
				break;
			} //rejected: option to rename this file
		} else {
			using (new CodeInfo.PastingEtc(this))
				Call(SCI_PASTE); //not aaaReplaceSel, because can be SCI_SETMULTIPASTE etc
		}
	}
	
	internal static (bool yes, string text, string filename, bool isClass) EIsForumCode_(string s, bool newFile) {
		if (!s.RxMatch(@"^// (script|class) ""(.*?)""( |\R)", out var m)) return default;
		
		bool isClass = s[3] == 'c';
		s = s[m.End..];
		var name = m[2].Length > 0 ? m[2].Value : (isClass ? "Class1.cs" : "Script1.cs");
		
		if (newFile && dialog.showOkCancel("Import C# file from clipboard?", "Source file: " + name, owner: App.Hmain))
			_NewFileFromForumCode(s, name, isClass);
		
		return (true, s, name, isClass);
	}
	
	static void _NewFileFromForumCode(string text, string name, bool isClass) {
		App.Model.NewItem(isClass ? "Class.cs" : "Script.cs", null, name, text: new NewFileText(replaceTemplate: true, text));
	}
	
	#endregion
	
	#region indicators
	
	void _IndicatorsInit() {
		if (!_fn.IsCodeFile) return;
		
		//workaround for: indicators too small if high DPI
		int style = _dpi < 144 ? INDIC_SQUIGGLEPIXMAP : INDIC_SQUIGGLE,
			strokeWidth = _dpi < 144 ? 100 : 200;
		//strokeWidth = _dpi < 144 ? 100 : _dpi < 192 ? 150 : 200;
		
		aaaIndicatorDefine(SciTheme.Indic.Error, style, 0xff0000, strokeWidth: strokeWidth);
		aaaIndicatorDefine(SciTheme.Indic.Warning, style, 0x008000, strokeWidth: strokeWidth); //dark green
		aaaIndicatorDefine(SciTheme.Indic.Info, INDIC_DIAGONAL, 0xc0c0c0, strokeWidth: strokeWidth);
		aaaIndicatorDefine(SciTheme.Indic.DiagHidden, INDIC_DOTS, 0xc0c0c0, strokeWidth: strokeWidth);
	}
	
	bool _indicHaveFound, _indicHaveDiag;
	
	internal void EInicatorsFound_(List<Range> a) {
		if (_indicHaveFound) {
			_indicHaveFound = false;
			aaaIndicatorClear(SciTheme.Indic.Found);
		}
		if (a.NE_()) return;
		_indicHaveFound = true;
		
		foreach (var v in a) aaaIndicatorAdd(SciTheme.Indic.Found, true, v);
	}
	
	internal void EInicatorsDiag_(bool has) {
		if (_indicHaveDiag) {
			_indicHaveDiag = false;
			aaaIndicatorClear(SciTheme.Indic.DiagHidden);
			aaaIndicatorClear(SciTheme.Indic.Info);
			aaaIndicatorClear(SciTheme.Indic.Warning);
			aaaIndicatorClear(SciTheme.Indic.Error);
		}
		if (!has) return;
		_indicHaveDiag = true;
	}
	
	#endregion
	
	#region view
	
	[Flags]
	public enum EView { Wrap = 1, Images = 2 }
	
	internal static void EToggleView_call_from_menu_only_(EView what) {
		if (what.Has(EView.Wrap)) {
			App.Settings.edit_wrap ^= true;
			foreach (var v in Panels.Editor.OpenDocs) v.Call(SCI_SETWRAPMODE, App.Settings.edit_wrap ? SC_WRAP_WORD : 0);
		}
		if (what.Has(EView.Images)) {
			App.Settings.edit_noImages ^= true;
			foreach (var v in Panels.Editor.OpenDocs) v._ImagesOnOff();
		}
		
		//should not need this, because this func called from menu commands only.
		//	But somehow KMenuCommands does not auto change menu/toolbar checked state for Edit menu. Need to fix it.
		Panels.Editor.UpdateUI_EditView_();
	}
	
	void _CodeModifiedAndCodeinfoOK() {
		if (!_wpfPreview) return;
		s_timer1 ??= new(static t => {
			var doc = Panels.Editor.ActiveDoc;
			if (doc == t.Tag) doc._WpfPreviewRun(false);
		});
		s_timer1.Tag = this;
		s_timer1.After(500);
	}
	static timer s_timer1;
	static bool s_wpfPreviewInited;
	bool _wpfPreview;
	internal bool EIsWpfPreview => _wpfPreview;
	
	void _WpfPreviewRun(bool starting) {
		if (!_wpfPreview) return;
		CompileRun.RunWpfPreview(_fn, k => {
			bool hasWPF_PREVIEW = false;
			for (int i = k.m.GlobalCount; i < k.trees.Length; i++) {
				//print.it(m.CodeFiles[i]);
				if (!k.m.CodeFiles[i].code.Contains("WPF_PREVIEW")) continue;
				var cu = k.trees[i].GetCompilationUnitRoot();
				if (!cu.GetDirectives(d => d is IfDirectiveTriviaSyntax di && di.Condition.ToString() == "WPF_PREVIEW").Any()) continue;
				hasWPF_PREVIEW = true;
				break;
			}
			if (!hasWPF_PREVIEW) {
				if (starting) {
					print.it("""
<>To enable <help editor/Code editor>WPF preview<>, add #if WPF_PREVIEW with code that calls Preview(). Examples: <fold>
<code>
//code before b.ShowDialog
#if WPF_PREVIEW
b.Window.Preview();
#endif

//code near the start of the script file, when using dialog class DialogClass
#if WPF_PREVIEW
new DialogClass().Preview();
#endif

//code before dialog class DialogClass, when not using a script file
#if WPF_PREVIEW
class Program { static void Main() { new DialogClass().Preview(); }}
#endif
</code>
</fold>
""");
				}
				return false;
			}
			//print.it(k.compilation.GetDiagnostics());
			return !k.compilation.GetDiagnostics().Any(o => o.Severity == DiagnosticSeverity.Error);
		});
	}
	
	public static void WpfPreviewStartStop(MenuItem mi) {
		var doc = Panels.Editor.ActiveDoc; if (doc == null) return;
		bool start = mi.IsChecked;
		if (start == doc._wpfPreview) return;
		doc._wpfPreview = start;
		
		if (start) doc._WpfPreviewRun(true);
		
		if (!s_wpfPreviewInited) {
			s_wpfPreviewInited = true;
			Panels.Editor.ActiveDocChanged += () => {
				mi.IsChecked = Panels.Editor.ActiveDoc?._wpfPreview ?? false;
			};
		}
		
		//update #if WPF_PREVIEW: styling, errors.
		CodeInfo.StopAndUpdateStyling();
	}
	
	#endregion
	
	#region acc
	
	protected override ERole AaAccessibleRole => ERole.DOCUMENT;
	
	protected override string AaAccessibleName => "document - " + _fn.DisplayName;
	
	protected override string AaAccessibleDescription => _fn.FilePath;
	
	#endregion
	
	#region util
	
	void _DefineIconMarkers() {
		if (s_markerBitmaps.dpi != _dpi) {
			s_markerBitmaps.dpi = _dpi;
			_Bitmap(ref s_markerBitmaps.bookmark, "*Material.Bookmark #EABB00 @16", 14);
			_Bitmap(ref s_markerBitmaps.bookmark2, "*Material.BookmarkOutline #EABB00 @16", 14);
			_Bitmap(ref s_markerBitmaps.breakpoint, "*Material.Circle #EE3000", 8);
			_Bitmap(ref s_markerBitmaps.breakpointD, "*Material.Circle #A0A0A0", 8);
			_Bitmap(ref s_markerBitmaps.breakpointC, "*Codicons.DebugBreakpointConditional #EE3000", 8);
			_Bitmap(ref s_markerBitmaps.breakpointCD, "*Codicons.DebugBreakpointConditional #A0A0A0", 8);
			_Bitmap(ref s_markerBitmaps.breakpointL, "*BootstrapIcons.DiamondFill #40B000", 10);
			_Bitmap(ref s_markerBitmaps.breakpointLD, "*BootstrapIcons.DiamondFill #A0A0A0", 10);
			_Bitmap(ref s_markerBitmaps.debugLine, "*Codicons.DebugStackframe #40B000 @16", 14);
			_Bitmap(ref s_markerBitmaps.debugLine2, "*Codicons.DebugStackframe #808080 @16", 14);
		}
		_Marker(SciTheme.Marker.Bookmark, s_markerBitmaps.bookmark);
		_Marker(SciTheme.Marker.BookmarkInactive, s_markerBitmaps.bookmark2);
		_Marker(SciTheme.Marker.Breakpoint, s_markerBitmaps.breakpoint);
		_Marker(SciTheme.Marker.BreakpointD, s_markerBitmaps.breakpointD);
		_Marker(SciTheme.Marker.BreakpointC, s_markerBitmaps.breakpointC);
		_Marker(SciTheme.Marker.BreakpointCD, s_markerBitmaps.breakpointCD);
		_Marker(SciTheme.Marker.BreakpointL, s_markerBitmaps.breakpointL);
		_Marker(SciTheme.Marker.BreakpointLD, s_markerBitmaps.breakpointLD);
		_Marker(SciTheme.Marker.DebugLine, s_markerBitmaps.debugLine);
		_Marker(SciTheme.Marker.DebugLine2, s_markerBitmaps.debugLine2);
		
		unsafe void _Bitmap(ref (int size, nint data) mb, string icon, int size) {
			if (mb.data != 0) { MemoryUtil.Free((uint*)mb.data); mb.data = 0; }
			using var b = ImageUtil.LoadGdipBitmapFromXaml(icon, _dpi, new(size, size));
			using var v = b.Data(System.Drawing.Imaging.ImageLockMode.ReadOnly, System.Drawing.Imaging.PixelFormat.Format32bppArgb);
			size = v.Width;
			var m = MemoryUtil.Alloc<uint>(size * size);
			MemoryUtil.Copy((uint*)v.Scan0, m, size * size * 4);
			for (uint* p = m, pe = p + size * size; p < pe; p++) *p = ColorInt.SwapRB(*p);
			mb = new(size, (nint)m);
		}
		
		unsafe void _Marker(int marker, (int size, nint data) b) {
			aaaMarkerDefine(marker, Sci.SC_MARK_RGBAIMAGE);
			Call(SCI_RGBAIMAGESETWIDTH, b.size);
			Call(SCI_RGBAIMAGESETHEIGHT, b.size);
			Call(SCI_MARKERDEFINERGBAIMAGE, marker, b.data);
		}
	}
	
	struct _MarkerBitmaps {
		public int dpi;
		public (int size, nint data) bookmark, bookmark2, breakpoint, breakpointD, breakpointC, breakpointCD, breakpointL, breakpointLD, debugLine, debugLine2;
	}
	static _MarkerBitmaps s_markerBitmaps;
	
	/// <summary>
	/// Gets rectangle of caret if it was at the specified UTF-16 position.
	/// If <i>pos16</i> less than 0, uses current caret position.
	/// </summary>
	public RECT EGetCaretRectFromPos(int pos16 = -1, bool inScreen = false) {
		int pos8 = pos16 < 0 ? aaaCurrentPos8 : aaaPos8(pos16);
		int x = Call(Sci.SCI_POINTXFROMPOSITION, 0, pos8), y = Call(Sci.SCI_POINTYFROMPOSITION, 0, pos8);
		var r = new RECT(x, y, 1, Call(Sci.SCI_TEXTHEIGHT, aaaLineFromPos(false, pos8)) + 2);
		if (inScreen) AaWnd.MapClientToScreen(ref r);
		return r;
	}
	
	#endregion
}


================================================
FILE: Au.Editor/Edit/SciTheme.cs
================================================
using Au.Controls;

using static Au.Controls.Sci;

namespace LA;
//note: used in ToolLand too.

record class SciTheme { //info: record class because need `with` and synthesized ==
	public record struct TStyle(int color, bool back = false, bool bold = false, bool italic = false, bool underline = false) {
		public static implicit operator TStyle(int color) => new(color);
	}
	
	public record struct TIndicator(int color, int alpha);
	
	public string FontName = "Consolas";
	public double FontSize = 9.75;
	public int Background = 0xffffff;
	
	public TStyle None; //black
	public TStyle Comment = 0x60A000; //green-yellow
	public TStyle String = 0xA07040; //brown-green
	public TStyle StringEscape = 0xFF60FF; //pink
	public TStyle Number = 0x804000; //brown-red
	public TStyle Punctuation; //black
	public TStyle Operator = 0x0000ff; //blue
	public TStyle Keyword = 0x0000ff; //blue
	public TStyle Namespace = 0x808000; //dark yellow
	public TStyle Type = 0x0080c0; //teal-blue
	public TStyle Function = new(0, bold: true); //black bold
	public TStyle Event = new(0, bold: true);
	public TStyle LocalVariable = 0x204020; //dark gray-green
	public TStyle Field = 0x204020;
	public TStyle Constant = 0x204020;
	public TStyle Label = 0xff00ff; //magenta
	public TStyle Preprocessor = 0xff3300; //red
	public TStyle Excluded = 0x808080; //gray
	public TStyle XmlDocText = 0x408000; //green
	public TStyle XmlDocTag = 0x808080; //gray
	public TStyle RxText = 0xA07040;
	public TStyle RxMeta = new(0x0060FF, bold: true);
	public TStyle RxChars = new(0x60A000, bold: true);
	public TStyle RxOption = new(0xFF4040, bold: true);
	public TStyle RxEscape = 0xFF60FF;
	public TStyle RxCallout = new(0xFF8060, back: true);
	public TStyle RxComment = 0x808080;
	
	public TStyle LineNumber = 0x808080;
	public int LineNumberMargin = 0xE0E0E0;
	public int MarkerMargin = 0xFFFFFF;
	
	public TIndicator IndicRefs = new(0x80C000, 40);
	public TIndicator IndicBraces = new(0x80C000, 255);
	public TIndicator IndicDebug = new(0xFFF181, 255);
	public TIndicator IndicFound = new(0xffff00, 255);
	public TIndicator IndicSnippetField = new(0xe0a000, 60);
	public TIndicator IndicSnippetFieldActive = new(0x33ADFF, 60);
	
	public int SelColor = unchecked((int)0xA0A0A0A0);
	public int SelNofocusColor = 0x60A0A0A0;
	public int Caret = 0x2000000; //alpha = thickness
	public int CaretLine = 0x1E0E0E0; //alpha = frame thickness
	
	//note: these must be before the static properties, else would be null when the properties use them.
	public static readonly string ThemesDirCustomizedBS = AppSettings.DirBS + @"Themes\";
	public static readonly string ThemesDirDefaultBS = folders.ThisAppBS + @"Default\Themes\";
	
	//public
	
	/// <summary>
	/// Default theme without customizations.
	/// Use as immutable. If need theme with some values changed, use code `SciTheme.Default with { ... }`.
	/// </summary>
	public static SciTheme Default { get; } = new();
	
	/// <summary>
	/// Current theme (with or without customizations).
	/// Use as immutable. If need theme with some values changed, use code `SciTheme.Current with { ... }`.
	/// </summary>
	public static SciTheme Current {
		get => field ??= new("");
		set { field = value; }
	}
	
	class _ThemeInfo {
		public string
			name, //not null if can load file; without suffix
			defPath, //not null if can load a default file
			custPath; //not null, even if file does not exist
		public bool
			customized, //true if using a customized file
			custExists; //true if customized file exists, even if not using it
		
		/// <param name="theme">"" - current. null - default ("LA").</param>
		public _ThemeInfo(string theme) {
			if (theme is "") theme = App.Settings.edit_theme.NullIfEmpty_();
			if (theme is null or "LA") {
				_Cust();
				
				//In the past LA did not support multiple themes...
				if (!custExists && theme is null) {
					var sOld = AppSettings.DirBS + "Font.csv";
					if (filesystem.exists(sOld, true).File) {
						try {
							var s = filesystem.loadText(sOld);
							s = s.RxReplace(@"(?m)^Function\b(.+)", "Function$1\r\nEvent$1");
							s = s.RxReplace(@"(?m)^Variable\b(.+)", "LocalVariable$1\r\nField$1");
							filesystem.saveText(custPath, s);
							App.Settings.edit_theme = "LA [customized]";
							name = "LA";
							customized = custExists = true;
							filesystem.rename(sOld, "Font.csv.bak", FIfExists.RenameNew);
						}
						catch (Exception e1) { Debug_.Print(e1); }
					}
				}
			} else {
				bool cust = theme.Ends(" [customized]");
				if (cust) theme = theme[..^13];
				if (cust && theme is "LA") {
					_Cust();
					if (customized = custExists) name = theme;
				} else {
					var dp = ThemesDirDefaultBS + theme + ".csv";
					if (filesystem.exists(dp, true).File) {
						name = theme;
						defPath = dp;
						custPath = ThemesDirCustomizedBS + theme + ".csv";
						custExists = filesystem.exists(custPath, true).File;
						customized = cust && custExists;
					} else {
						_Cust();
					}
				}
			}
			
			void _Cust() {
				custPath = ThemesDirCustomizedBS + "LA.csv";
				custExists = filesystem.exists(custPath, true).File;
			}
		}
	}
	
	/// <summary>
	/// Gets theme name like <c>"Name"</c> or <c>"Name [customized]"</c>.
	/// </summary>
	public string Name { get; init; } = "LA";
	
	SciTheme() { }
	
	/// <summary>
	/// Loads current or specified theme (default or customized).
	/// </summary>
	/// <param name="theme">Theme name, or <c>""</c> to load current theme. If ends with <c>" [customized]"</c>, loads customized file if exists.</param>
	public SciTheme(string theme) {
		var t = new _ThemeInfo(theme);
		if (t.name != null) {
			if (t.defPath != null && _Load(t.defPath)) Name = t.name; //need even if will load customized, because it may not have some items or may fail to load
			if (t.customized && _Load(t.custPath)) Name = t.name + " [customized]";
		}
	}
	
	bool _Load(string path) {
		csvTable csv;
		try { csv = csvTable.load(path); }
		catch (Exception e1) { print.it(e1); return false; }
		if (csv.ColumnCount < 2) return false;
		
		foreach (var a in csv.Rows) {
			switch (a[0]) {
			case "Font":
				if (!a[1].NE()) FontName = a[1];
				if (a.Length > 2) { var fs = a[2].ToNumber(); if (fs >= 5 && fs <= 100) FontSize = fs; }
				break;
			case nameof(Background): _Int6(ref Background); break;
			case nameof(None): _Style(ref None); break;
			case nameof(Comment): _Style(ref Comment); break;
			case nameof(String): _Style(ref String); break;
			case nameof(StringEscape): _Style(ref StringEscape); break;
			case nameof(Number): _Style(ref Number); break;
			case nameof(Punctuation): _Style(ref Punctuation); break;
			case nameof(Operator): _Style(ref Operator); break;
			case nameof(Keyword): _Style(ref Keyword); break;
			case nameof(Namespace): _Style(ref Namespace); break;
			case nameof(Type): _Style(ref Type); break;
			case nameof(Function): _Style(ref Function); break;
			case nameof(Event): _Style(ref Event); break;
			case nameof(LocalVariable): _Style(ref LocalVariable); break;
			case nameof(Field): _Style(ref Field); break;
			case nameof(Constant): _Style(ref Constant); break;
			case nameof(Label): _Style(ref Label); break;
			case nameof(Preprocessor): _Style(ref Preprocessor); break;
			case nameof(Excluded): _Style(ref Excluded); break;
			case nameof(XmlDocText): _Style(ref XmlDocText); break;
			case nameof(XmlDocTag): _Style(ref XmlDocTag); break;
			case nameof(RxText): _Style(ref RxText, true); break;
			case nameof(RxMeta): _Style(ref RxMeta, true); break;
			case nameof(RxChars): _Style(ref RxChars, true); break;
			case nameof(RxOption): _Style(ref RxOption, true); break;
			case nameof(RxEscape): _Style(ref RxEscape, true); break;
			case nameof(RxCallout): _Style(ref RxCallout, true); break;
			case nameof(RxComment): _Style(ref RxComment, true); break;
			case nameof(LineNumber): _Style(ref LineNumber); break;
			case nameof(LineNumberMargin): _Int6(ref LineNumberMargin); break;
			case nameof(MarkerMargin): _Int6(ref MarkerMargin); break;
			case nameof(IndicRefs): _Indic(ref IndicRefs); break;
			case nameof(IndicBraces): _Indic(ref IndicBraces); break;
			case nameof(IndicDebug): _Indic(ref IndicDebug); break;
			case nameof(IndicFound): _Indic(ref IndicFound); break;
			case nameof(IndicSnippetField): _Indic(ref IndicSnippetField); break;
			case nameof(IndicSnippetFieldActive): _Indic(ref IndicSnippetFieldActive); break;
			case nameof(SelColor): _Int6Int(ref SelColor); break;
			case nameof(SelNofocusColor): _Int6Int(ref SelNofocusColor); break;
			case nameof(Caret): _Int6Int(ref Caret); break;
			case nameof(CaretLine): _Int6Int(ref CaretLine); break;
			}
			
			void _Style(ref TStyle r, bool hasBack = false) {
				if (!a[1].NE() && a[1].ToInt(out int i)) r.color = i;
				if (a.Length > 2 && !a[2].NE() && a[2].ToInt(out int i2)) {
					r.bold = 0 != (i2 & 1);
					r.italic = 0 != (i2 & 2);
					r.underline = 0 != (i2 & 4);
					if (hasBack) r.back = 0 != (i2 & 8);
				} else r.bold = r.italic = r.underline = r.back = false;
			}
			
			void _Indic(ref TIndicator r) {
				int i = r.color; _Int6(ref i); r.color = i;
				i = r.alpha; _Alpha(ref i); r.alpha = i;
			}
			
			void _Int6(ref int value) {
				if (!a[1].NE() && a[1].ToInt(out int i)) value = i;
				value &= 0xffffff;
			}
			
			void _Alpha(ref int value) {
				if (a.Length > 2 && !a[2].NE() && a[2].ToInt(out int i)) value = Math.Clamp(i, 0, 255);
			}
			
			void _Int6Int(ref int r) {
				int i = r; _Int6(ref i);
				int j = r >>> 24; _Alpha(ref j);
				r = i | (j << 24);
			}
		}
		
		return true;
	}
	
	public void Save() {
		var b = new StringBuilder(); //don't need csvTable for such simple values
		b.AppendLine($"Font, {FontName}, {FontSize.ToS()}");
		_Int6(Background);
		_Style(None);
		_Style(Comment);
		_Style(String);
		_Style(StringEscape);
		_Style(Number);
		_Style(Punctuation);
		_Style(Operator);
		_Style(Keyword);
		_Style(Namespace);
		_Style(Type);
		_Style(Function);
		_Style(Event);
		_Style(LocalVariable);
		_Style(Field);
		_Style(Constant);
		_Style(Label);
		_Style(Preprocessor);
		_Style(Excluded);
		_Style(XmlDocText);
		_Style(XmlDocTag);
		_Style(RxText);
		_Style(RxMeta);
		_Style(RxChars);
		_Style(RxOption);
		_Style(RxEscape);
		_Style(RxCallout);
		_Style(RxComment);
		_Style(LineNumber);
		_Int6(LineNumberMargin);
		_Int6(MarkerMargin);
		_Indic(IndicRefs);
		_Indic(IndicBraces);
		_Indic(IndicDebug);
		_Indic(IndicFound);
		_Indic(IndicSnippetField);
		_Indic(IndicSnippetFieldActive);
		_Int6Int(SelColor);
		_Int6Int(SelNofocusColor);
		_Int6Int(Caret);
		_Int6Int(CaretLine);
		
		void _Style(TStyle r, [CallerArgumentExpression("r")] string name = null) {
			b.Append($"{name}, 0x{r.color:X6}");
			if (((r.bold ? 1 : 0) | (r.italic ? 2 : 0) | (r.underline ? 4 : 0) | (r.back ? 8 : 0)) is int i && i > 0) b.Append($", {i.ToS()}");
			b.AppendLine();
		}
		
		void _Indic(TIndicator i, [CallerArgumentExpression("i")] string name = null)
			=> b.AppendLine($"{name}, 0x{i.color:X6}, {i.alpha.ToS()}");
		
		void _Int6(int i, [CallerArgumentExpression("i")] string name = null)
			=> b.AppendLine($"{name}, 0x{i:X6}");
		
		void _Int6Int(int i, [CallerArgumentExpression("i")] string name = null)
			=> b.AppendLine($"{name}, 0x{i & 0xffffff:X6}, {(i >>> 24).ToS()}");
		
		var t = new _ThemeInfo("");
		filesystem.saveText(t.custPath, b.ToString());
	}
	
	/// <param name="multiFont">Set font only for code styles, not for STYLE_DEFAULT.</param>
	public void ToScintilla(KScintilla sci, bool multiFont = false, string fontName = null, double? fontSize = null) {
		//print.it(sci.GetType(), sci.Name);
		
		if (!multiFont) sci.aaaStyleFont(STYLE_DEFAULT, fontName ?? FontName, fontSize ?? FontSize);
		sci.aaaStyleBackColor(STYLE_DEFAULT, Background);
		//if(None.color != 0) sci.aaaStyleForeColor(STYLE_DEFAULT, None.color); //also would need bold and in ctor above
		sci.aaaStyleClearAll();
		
		void _Set(EStyle k, TStyle sty) {
			if (sty.back) {
				sci.aaaStyleBackColor((int)k, sty.color);
				sci.aaaStyleForeColor((int)k, None.color);
			} else sci.aaaStyleForeColor((int)k, sty.color);
			
			if (sty.bold) sci.aaaStyleBold((int)k, true);
			if (sty.italic) sci.aaaStyleItalic((int)k, true);
			if (sty.underline) sci.aaaStyleUnderline((int)k, true);
			if (multiFont) sci.aaaStyleFont((int)k, fontName ?? FontName, fontSize ?? FontSize);
		}
		
		_Set(EStyle.None, None);
		_Set(EStyle.Comment, Comment);
		_Set(EStyle.String, String);
		_Set(EStyle.StringEscape, StringEscape);
		_Set(EStyle.Number, Number);
		_Set(EStyle.Punctuation, Punctuation);
		_Set(EStyle.Operator, Operator);
		_Set(EStyle.Keyword, Keyword);
		_Set(EStyle.Namespace, Namespace);
		_Set(EStyle.Type, Type);
		_Set(EStyle.Function, Function);
		_Set(EStyle.Event, Event);
		_Set(EStyle.LocalVariable, LocalVariable);
		_Set(EStyle.Field, Field);
		_Set(EStyle.Constant, Constant);
		_Set(EStyle.Label, Label);
		_Set(EStyle.Preprocessor, Preprocessor);
		_Set(EStyle.Excluded, Excluded);
		_Set(EStyle.XmlDocText, XmlDocText);
		_Set(EStyle.XmlDocTag, XmlDocTag);
		_Set(EStyle.RxText, RxText);
		_Set(EStyle.RxMeta, RxMeta);
		_Set(EStyle.RxChars, RxChars);
		_Set(EStyle.RxOption, RxOption);
		_Set(EStyle.RxEscape, RxEscape);
		_Set(EStyle.RxCallout, RxCallout);
		_Set(EStyle.RxComment, RxComment);
		
		_Set((EStyle)STYLE_LINENUMBER, LineNumber);
		sci.aaaStyleBackColor(STYLE_LINENUMBER, LineNumberMargin); //documented: sets color of all margins except of type SC_MARGIN_COLOUR and the folding margin
		
		sci.aaaStyleForeColor(STYLE_INDENTGUIDE, 0xcccccc);
		
		if (sci is SciCode || sci.Name == "styles") { //main code editor or Options > Font, colors
			_Indic(Indic.Refs, IndicRefs.color, IndicRefs.alpha, INDIC_FULLBOX);
			_Indic(Indic.Braces, IndicBraces.color, IndicBraces.alpha, INDIC_GRADIENT);
			_Indic(Indic.Debug, IndicDebug.color, IndicDebug.alpha, INDIC_FULLBOX);
			_Indic(Indic.Debug2, IndicDebug.color, 128 + IndicDebug.alpha / 2, INDIC_GRADIENTCENTRE);
			_Indic(Indic.Found, IndicFound.color, IndicFound.alpha, INDIC_FULLBOX);
			_Indic(Indic.SnippetField, IndicSnippetField.color, IndicSnippetField.alpha, INDIC_FULLBOX);
			_Indic(Indic.SnippetFieldActive, IndicSnippetFieldActive.color, IndicSnippetFieldActive.alpha, INDIC_FULLBOX);
#if DEBUG
			_Indic(Indic.TestBox, 0xff0000, 60, INDIC_FULLBOX);
			sci.aaaIndicatorDefine(Indic.TestStrike, INDIC_STRIKE, 0xff0000);
			sci.aaaIndicatorDefine(Indic.TestPoint, INDIC_POINT, 0xff00ff);
#endif
			
			void _Indic(int indic, int color, int alpha, int style) {
				sci.aaaIndicatorDefine(indic, style, color, alpha, 255, underText: true);
			}
			//void _Indic(int indic, int color, int alpha, bool gradient) {
			//	sci.aaaIndicatorDefine(indic, gradient ? INDIC_GRADIENT : INDIC_FULLBOX, color, alpha, 255, underText: true);
			//}
		}
		
		sci.aaaSetElementColor(SC_ELEMENT_SELECTION_BACK, SelColor);
		sci.aaaSetElementColor(SC_ELEMENT_SELECTION_INACTIVE_BACK, SelNofocusColor);
		sci.aaaSetElementColor(SC_ELEMENT_CARET, Caret & 0xffffff);
		sci.Call(SCI_SETCARETWIDTH, Math.Clamp(Caret >>> 24, 1, 4)); //not DPI-scaled
		if (sci is SciCode) {
			sci.aaaSetElementColor(SC_ELEMENT_CARET_LINE_BACK, CaretLine & 0xffffff);
			sci.Call(SCI_SETCARETLINEFRAME, Math.Clamp(CaretLine >>> 24, 1, 4)); //not DPI-scaled
			sci.Call(SCI_SETCARETLINEVISIBLEALWAYS, 1);
			
			sci.Call(SCI_SETMARGINBACKN, Margin.Markers, ColorInt.SwapRB(MarkerMargin));
		}
		sci.aaaSetElementColor(SC_ELEMENT_WHITE_SPACE, 0x808080); //space/tab visuals and wrap visuals
	}
	
	public ref TStyle this[EStyle style] {
		get {
			switch (style) {
			case EStyle.None: return ref None;
			case EStyle.Comment: return ref Comment;
			case EStyle.String: return ref String;
			case EStyle.StringEscape: return ref StringEscape;
			case EStyle.Number: return ref Number;
			case EStyle.Punctuation: return ref Punctuation;
			case EStyle.Operator: return ref Operator;
			case EStyle.Keyword: return ref Keyword;
			case EStyle.Namespace: return ref Namespace;
			case EStyle.Type: return ref Type;
			case EStyle.Function: return ref Function;
			case EStyle.Event: return ref Event;
			case EStyle.LocalVariable: return ref LocalVariable;
			case EStyle.Field: return ref Field;
			case EStyle.Constant: return ref Constant;
			case EStyle.Label: return ref Label;
			case EStyle.Preprocessor: return ref Preprocessor;
			case EStyle.Excluded: return ref Excluded;
			case EStyle.XmlDocText: return ref XmlDocText;
			case EStyle.XmlDocTag: return ref XmlDocTag;
			case EStyle.RxText: return ref RxText;
			case EStyle.RxMeta: return ref RxMeta;
			case EStyle.RxChars: return ref RxChars;
			case EStyle.RxOption: return ref RxOption;
			case EStyle.RxEscape: return ref RxEscape;
			case EStyle.RxCallout: return ref RxCallout;
			case EStyle.RxComment: return ref RxComment;
			case EStyle.LineNumber: return ref LineNumber;
			}
			throw new InvalidEnumArgumentException();
		}
	}
	
	/// <param name="indicator">ScConst.indicX.</param>
	public ref TIndicator Indicator(int indicator) {
		switch (indicator) {
		case Indic.Refs: return ref IndicRefs;
		case Indic.Braces: return ref IndicBraces;
		case Indic.Debug: return ref IndicDebug;
		case Indic.Found: return ref IndicFound;
		case Indic.SnippetField: return ref IndicSnippetField;
		case Indic.SnippetFieldActive: return ref IndicSnippetFieldActive;
		}
		throw new InvalidEnumArgumentException();
	}
	
	public ref int Element(int element) {
		switch (element) {
		case Sci.SC_ELEMENT_SELECTION_BACK: return ref SelColor;
		case Sci.SC_ELEMENT_SELECTION_INACTIVE_BACK: return ref SelNofocusColor;
		case Sci.SC_ELEMENT_CARET: return ref Caret;
		case Sci.SC_ELEMENT_CARET_LINE_BACK: return ref CaretLine;
		case -1: return ref LineNumberMargin;
		case -2: return ref MarkerMargin;
		}
		throw new InvalidEnumArgumentException();
	}
	
	/// <summary>
	/// Scintilla style indices of token kinds.
	/// </summary>
	public enum EStyle : byte {
		None,
		Comment,
		String,
		StringEscape,
		Number,
		Punctuation,
		Operator,
		Keyword,
		Namespace,
		Type,
		Function,
		Event,
		LocalVariable,
		Field,
		Constant,
		Label,
		Preprocessor,
		Excluded,
		XmlDocText,
		XmlDocTag, //tags, CDATA, ///, etc
		RxText,
		RxMeta,
		RxChars,
		RxOption,
		RxEscape,
		RxCallout,
		RxComment,
		
		countUserDefined,
		
		Image = countUserDefined,
		
		//STYLE_HIDDEN=31,
		//STYLE_DEFAULT=32,
		
		LineNumber = 33, //STYLE_LINENUMBER
	}
	
#pragma warning disable CS1591 //Missing XML comment for publicly visible type or member
	/// <summary>
	/// Indicator indices.
	/// </summary>
	public static class Indic {
		//We can use 8-31. KScintilla can use 0-7. Draws indicators from smaller to bigger, eg error on warning.
		public const int
			Images = 8,
			Refs = 9,
			Braces = 10,
			Debug = 11,
			Debug2 = 12,
			Found = 13,
			SnippetField = 14,
			SnippetFieldActive = 15,
			DiagHidden = 20,
			Info = 21,
			Warning = 22,
			Error = 23,
			TestBox = 29,
			TestStrike = 30,
			TestPoint = 31
			;
	}
	
	/// <summary>
	/// Marker indices.
	/// </summary>
	public static class Marker {
		//We can use 0-20. Changes 21-24. Folding 25-31.
		public const int
			Underline = 0,
			Bookmark = 1, BookmarkInactive = 2,
			Breakpoint = 3, BreakpointD = 4, BreakpointC = 5, BreakpointCD = 6, BreakpointL = 7, BreakpointLD = 8,
			DebugLine = 19, DebugLine2 = 20;
	}
	
	/// <summary>
	/// Margin indices.
	/// </summary>
	public static class Margin {
		//Initially 0-4. We can add more with SCI_SETMARGINS.
		public const int
			Fold = 0,
			Images = 1,
			Markers = 2,
			LineNumbers = 3,
			Changes = 4; //currently not impl, just adds some space between line numbers and text
	}
#pragma warning restore CS1591 //Missing XML comment for publicly visible type or member
}


================================================
FILE: Au.Editor/Edit/SciUndo.cs
================================================
using Au.Controls;
using static Au.Controls.Sci;

namespace LA;

class SciUndo : IDisposable {
	public static SciUndo OfWorkspace => (App.Model.UndoContext_ ??= new SciUndo()) as SciUndo;
	
	sqlite _db;
	SLTransaction _transaction; //of current record
	int _id; //of current record
	int _nFiles; //in current record
	SciCode _lastDoc; //in current record
	int _idToUndo;
	HashSet<int> _invalidIds = [];
	
	void IDisposable.Dispose() {
		if (_db != null) {
			_db.Dispose();
			_db = null;
		}
	}
	
	/// <summary>
	/// Starts a multi-file replace undo record.
	/// </summary>
	public void StartReplaceInFiles() {
		_nFiles = 0;
		_lastDoc = null;
		try {
			//temp database. Uses a temp file when exceeds 2 MB.
			_db ??= new sqlite(@"", sql: """
CREATE TABLE records (id INTEGER, descr TEXT);
CREATE TABLE files (id INTEGER, fileId INTEGER, oldHash BLOB, newHash BLOB, undo BLOB, redo BLOB, find TEXT, repl TEXT);
""");
		}
		catch (Exception e1) { Debug_.Print(e1); return; }
		_transaction = _db.Transaction();
		_id++;
	}
	
	/// <summary>
	/// Commits the multi-file replace undo record started with <see cref="StartReplaceInFiles"/>.
	/// </summary>
	public void FinishReplaceInFiles(string operationDescription) {
		if (_db == null) return;
		if (_nFiles == 1 && Panels.Editor.ActiveDoc is SciCode ad && _lastDoc == ad) { //if replaced only in Panels.Editor.ActiveDoc
			_nFiles--;
			ad.ESetUndoMark_(-1);
		}
		if (_nFiles > 0) {
			try {
				_db.Execute("INSERT INTO records VALUES (?, ?)", _id, operationDescription);
				_transaction.Commit();
				
				//if was undone, that range of ids becomes invalid. Let UndoRedoMultiFileReplace skip them.
				for (int i = _idToUndo + 1; i < _id; i++) _invalidIds.Add(i); //never mind: also should remove from the database
				
				_idToUndo = _id;
				return;
			}
			catch (Exception e1) { print.it(e1); }
		}
		_transaction.Rollback();
		_id--;
	}
	
	/// <summary>
	/// Adds an open file to the current record.
	/// </summary>
	public void RifAddFile(SciCode doc, string oldText, string newText, List<StartEndText> changes) {
		if (_db == null) return;
		int n = _nFiles;
		RifAddFile(doc.EFile, oldText, newText, changes);
		if (_nFiles > n) (_lastDoc = doc).ESetUndoMark_(_id);
	}
	
	/// <summary>
	/// Adds a closed file to the current record.
	/// </summary>
	public void RifAddFile(FileNode f, string oldText, string newText, List<StartEndText> changes) {
		if (_db == null) return;
		
		//optimization: don't store full texts of files. Store only hashes and changes. Can make 100 times smaller.
		
		//optimization: don't store full info if all "find" or/and "replace" texts are same. They can be different only if used regex. Can make 4 times smaller.
		string sFind = oldText[changes[0].Range]; for (int i = 1; i < changes.Count; i++) if (!oldText.Eq(changes[i].Range, sFind)) { sFind = null; break; }
		string sRepl = changes[0].text; for (int i = 1; i < changes.Count; i++) if (changes[i].text != sRepl) { sRepl = null; break; }
		
		var ms = new MemoryStream();
		var bw = new BinaryWriter(ms);
		try {
			using var p = _db.Statement("INSERT INTO files VALUES (?, ?, ?, ?, ?, ?, ?, ?)");
			p.Bind(1, _id)
				.Bind(2, f.Id)
				.BindStruct(3, Hash.MD5(oldText))
				.BindStruct(4, Hash.MD5(newText))
				.Bind(5, _TextToBlob(false))
				.Bind(6, _TextToBlob(true))
				.Bind(7, sFind)
				.Bind(8, sRepl)
				.Step();
		}
		catch (Exception e1) { print.it(e1); return; }
		_nFiles++;
		
		Span<byte> _TextToBlob(bool redo) {
			ms.SetLength(0);
			int offset = 0;
			foreach (var v in changes) {
				if (redo) {
					bw.Write7BitEncodedInt(v.start);
					if (sFind == null) bw.Write7BitEncodedInt(v.Length);
					if (sRepl == null) bw.Write(v.text);
				} else {
					bw.Write7BitEncodedInt(v.start + offset);
					offset += v.text.Length - v.Length;
					if (sRepl == null) bw.Write7BitEncodedInt(v.text.Length);
					if (sFind == null) bw.Write(oldText[v.start..v.end]); //not bw.Write(oldText.AsSpan(v.start..v.end));
				}
			}
			return ms.GetBuffer().AsSpan(0, (int)ms.Position);
		}
	}
	
	bool _RifUndoRedo(bool redo, int id) {
		if (id < 1 || id > _id) return false;
		_db.Get(out string descr, "SELECT descr FROM records WHERE id=?", id);
		_db.Get(out int count, "SELECT COUNT(*) FROM files WHERE id=?", id);
		if (!dialog.showOkCancel($"{(redo ? "Redo" : "Undo")} in {count} files", "It was:\n" + descr, DFlags.CenterMouse, owner: App.Hmain))
			return false; //rejected: option to undo/redo only in this file. Confusing and probably not useful.
		
		StringBuilder skipped = null;
		//these will be reused to make less allocations
		StringBuilder sb = null;
		List<StartEndText> aset = new();
		MemoryStream ms = new();
		BinaryReader br = new(ms);
		
		using var x = _db.Statement("SELECT fileId, oldHash, newHash, undo, redo, find, repl FROM files WHERE id=?", id);
		while (x.Step()) {
			if (App.Model.FindById(x.GetInt(0)) is not FileNode f) continue;
			//print.it(f);
			if (f.OpenDoc is SciCode doc) {
				int mark = doc.EGetUndoMark_(redo);
				if (mark == id) {
					Debug_.PrintIf(Hash.MD5(doc.aaaText) != _HashBefore());
					_UndoRedo(doc, redo, mark);
					Debug_.PrintIf(Hash.MD5(doc.aaaText) != _HashAfter());
				} else if (0 == doc.Call(SCI_CANUNDO) && 0 == doc.Call(SCI_CANREDO) && Hash.MD5(doc.aaaText) == _HashBefore()) { //opened later
					doc.EReplaceTextGently(_TextFromBlob(doc.aaaText));
					doc.Call(SCI_EMPTYUNDOBUFFER);
				} else {
					_Skipped(f);
					continue;
				}
				doc.ESaveText_(true);
			} else {
				try {
					var textNow = filesystem.loadText(f.FilePath);
					if (Hash.MD5(textNow) == _HashBefore()) {
						f.SaveNewTextOfClosedFile(_TextFromBlob(textNow));
					} else {
						_Skipped(f);
					}
				}
				catch (Exception e1) { _Skipped(f, e1.ToString()); }
			}
			
			Hash.MD5Result _HashBefore() => x.GetStruct<Hash.MD5Result>(redo ? 1 : 2);
			Hash.MD5Result _HashAfter() => x.GetStruct<Hash.MD5Result>(redo ? 2 : 1);
			
			unsafe string _TextFromBlob(string textNow) {
				string sFind = x.GetText(5), sRepl = x.GetText(6);
				
				aset.Clear();
				var blob = x.GetBlob(redo ? 4 : 3, out int len1);
				ms.SetLength(0); ms.Write(new(blob, len1)); ms.Position = 0;
				
				while (ms.Position < len1) {
					int i = br.Read7BitEncodedInt();
					int len = (redo && sFind != null) ? sFind.Length : (!redo && sRepl != null) ? sRepl.Length : br.Read7BitEncodedInt();
					string s = (redo && sRepl != null) ? sRepl : (!redo && sFind != null) ? sFind : br.ReadString();
					aset.Add(new(i, i + len, s));
				}
				
				StartEndText.ReplaceAll(textNow, aset, ref sb);
				return sb.ToString();
			}
		}
		
		if (skipped != null) print.it(skipped);
		
		void _Skipped(FileNode f, string s = null) {
			skipped ??= new($"<>The multi-file {(redo ? "redo" : "undo")} operation skipped these files:\r\n");
			skipped.AppendLine($"\t{f.SciLink(true)}. {s ?? "Text modified later."}");
		}
		
		_idToUndo = redo ? id : id - 1;
		return true;
	}
	
	public void UndoRedo(bool redo) {
		var doc = Panels.Editor.ActiveDoc; if (doc == null) return;
		int mark = doc.EGetUndoMark_(redo);
		if (mark > 0)
			_RifUndoRedo(redo, mark);
		else
			_UndoRedo(doc, redo, mark);
	}
	
	/// <summary>
	/// Calls SCI_UNDO or SCI_REDO.
	/// If <i>mark</i> != 0, does not change current position at the end of the operation.
	/// To set and get mark use <see cref="SciCode.ESetUndoMark_"/> and <see cref="SciCode.EGetUndoMark_"/>.
	/// </summary>
	static void _UndoRedo(SciCode doc, bool redo, int mark) {
		doc.Call(redo ? SCI_REDO : SCI_UNDO, mark != 0);
	}
	
	public void UndoRedoMultiFileReplace(bool redo) {
		int id = _idToUndo; if (redo) id++;
		while (_invalidIds.Contains(id)) id += redo ? 1 : -1;
		_RifUndoRedo(redo, id);
	}
}

partial class SciCode {
	List<(int u, int mark)> _undoMarks;
	
	internal void ESetUndoMark_(int mark) {
		_undoMarks ??= [];
		int u = Call(SCI_GETUNDOCURRENT) - 1;
		if (u < 0) return;
		if (0 != (256 & Call(SCI_GETUNDOACTIONTYPE, u))) throw new InvalidOperationException("Cannot set Undo mark for a possibly not full Undo action"); //has flag "can coalesce"
		for (int i = _undoMarks.Count; --i >= 0;) {
			if (_undoMarks[i].u == u) { _undoMarks[i] = (u, mark); return; }
		}
		_undoMarks.Add((u, mark));
	}
	
	internal int EGetUndoMark_(bool redo) {
		if (!_undoMarks.NE_()) {
			int u = Call(SCI_GETUNDOCURRENT);
			if (redo) {
				int n = Call(SCI_GETUNDOACTIONS);
				while (u < n && 0 != (256 & Call(SCI_GETUNDOACTIONTYPE, u))) u++; //if multiple actions coalesced, get the last, because only it can be marked
				if (u >= n) return 0;
			} else {
				if (--u < 0) return 0;
			}
			//print.it(u, _GetUndoStack(), _undoMarks);
			var a = _undoMarks;
			for (int i = a.Count; --i >= 0;) {
				if (a[i].u == u) return a[i].mark;
				if (a[i].u < u) break;
			}
		}
		return 0;
	}
	
	void _ManageUndoOnModified(MOD mod) {
		if (mod.Has(MOD.SC_PERFORMED_USER)) {
			//from _undoMarks remove items for Scintilla Undo actions that have been removed by SCI_EMPTYUNDOBUFFER or when user-modified after an Undo or non-last Redo
			if (_undoMarks is { } a) {
				int n = Call(SCI_GETUNDOACTIONS) - 1; //the last action in the Scintilla's Undo stack. If the Undo stack previously had >= actions than now, they were removed and added this action.
				while (a.Count > 0 && a[^1].u >= n) a.RemoveAt(a.Count - 1);
			}
		}
	}
	
	//#if DEBUG
	//	int[] _GetUndoStack() {
	//		int n = Call(SCI_GETUNDOACTIONS);
	//		var a = new int[n];
	//		for (int i = 0; i < n; i++) {
	//			a[i] = Call(SCI_GETUNDOACTIONTYPE, i);
	//		}
	//		return a;
	//	}
	//#endif
	
	/// <summary>
	/// <c>=> new EUndoAction(this, onUndoDontChangeCaretPos);</c>
	/// </summary>
	public EUndoAction ENewUndoAction(bool onUndoDontChangeCaretPos = false) => new EUndoAction(this, onUndoDontChangeCaretPos);
	
	/// <summary>
	/// Ctor calls <see cref="KScintilla.aaaBeginUndoAction"/>. Dispose() calls <see cref="KScintilla.aaaEndUndoAction"/>.
	/// Does nothing if it's a nested undo action.
	/// </summary>
	public struct EUndoAction : IDisposable {
		SciCode _sci;
		bool _onUndoDontChangeCaretPos;
		
		/// <summary>
		/// Calls SCI_BEGINUNDOACTION.
		/// </summary>
		/// <param name="sci">Can be null, then does nothing.</param>
		/// <param name="onUndoDontChangeCaretPos"></param>
		public EUndoAction(SciCode sci, bool onUndoDontChangeCaretPos = false) {
			_onUndoDontChangeCaretPos = onUndoDontChangeCaretPos;
			_sci = sci;
			_sci?.aaaBeginUndoAction();
		}
		
		/// <summary>
		/// Calls SCI_ENDUNDOACTION and clears this variable.
		/// </summary>
		public void Dispose() {
			if (_sci != null) {
				if (0 == _sci.aaaEndUndoAction()) {
					if (_onUndoDontChangeCaretPos) _sci.ESetUndoMark_(-1);
				}
				_sci = null;
			}
		}
	}
}


================================================
FILE: Au.Editor/Files/DProperties.cs
================================================
//TODO2: UI to set r etc alias and noCopy

using System.Windows;
using System.Windows.Controls;
using Au.Controls;
using Microsoft.Win32;
using System.Drawing;
using System.Windows.Documents;
using ToolLand;

namespace LA;

class DProperties : KDialogWindow {
	public static void ShowFor(FileNode f) {
		f.SingleDialog(() => new DProperties(f));
	}
	
	readonly FileNode _f;
	readonly MetaCommentsParser _meta;
	readonly bool _isClass;
	MCRole _role;
	int _miscFlags;
	
	//controls
	readonly KSciInfoBox info;
	readonly ComboBox role, ifRunning, uac, warningLevel, nullable, platform;
	readonly TextBox testScript, define, noWarnings, testInternal, preBuild, postBuild, findInLists;
	readonly ComboBox outputPath, icon, manifest, sign;
	readonly KCheckBox xmlDoc, console, optimize, cMultiline;
	readonly KGroupBoxSeparator gAssembly, gCompile;
	readonly Panel pRun;
	readonly Button addNuget, addLibrary, addComRegistry, addComBrowse, addProject, addClassFile, addResource, addFile;
	
	DProperties(FileNode f) {
		_f = f;
		_isClass = f.IsClass;
		_meta = new MetaCommentsParser(_f);
		
		InitWinProp("Properties of " + _f.Name, App.Wmain);
		
		var b = new wpfBuilder(this).WinSize(800).Columns(-1, 20, -1, 20, 0);
		b.Options(bindLabelVisibility: true);
		b.R.Add(out info).Height(60).Margin("B8");
		
		//. left column
		b.R.StartGrid();
		
		b.R.StartGrid<KGroupBoxSeparator>("Role");
		b.R.Add("role", out role);
		b.End();
		
		b.R.StartGrid(out gCompile, "Compile").Columns(0, -1, 20, 0, -2);
		b.R.Add(out optimize, "optimize");
		b.R.Add("define", out define);
		b.R.Add("warningLevel", out warningLevel).Editable();
		b.Skip().Add("nullable", out nullable);
		b.R.Add("noWarnings", out noWarnings);
		b.R.Add("testInternal", out testInternal);
		b.R.Add("preBuild", out preBuild);
		b.R.Add("postBuild", out postBuild);
		b.End();
		
		b.End();
		//..
		
		//. center column
		b.Skip(1).StartGrid();
		
		b.R.StartGrid<KGroupBoxSeparator>("Run");
		b.StartGrid(); pRun = b.Panel;
		b.R.Add("ifRunning", out ifRunning);
		b.R.Add("uac", out uac);
		b.End();
		b.R.Add("testScript", out testScript)
			.Validation(_ => testScript.IsVisible && testScript.IsEnabled && testScript.Text is string s1 && s1.Length > 0 && null == _f.FindRelative(true, s1, FNFind.CodeFile) ? "testScript not found" : null);
		b.End();
		
		b.R.StartGrid(out gAssembly, "Assembly");
		b.Add("outputPath", out outputPath).Editable();
		outputPath.DropDownOpened += _OutputPath_DropDownOpened;
		b.R.Add("icon", out icon).Editable()
			.Add("manifest", out manifest).Editable();
		b.R.Add("sign", out sign).Editable();
		icon.DropDownOpened += _IconManifestSign_DropDownOpened;
		manifest.DropDownOpened += _IconManifestSign_DropDownOpened;
		sign.DropDownOpened += _IconManifestSign_DropDownOpened;
		b.R.Add(out console, "console")
			.And(0).Add(out xmlDoc, "xmlDoc");
		b.R.Add("platform", out platform).Width(100, "L");
		b.End();
		
		b.End();
		//..
		
		//. right column
		b.Skip(1).StartStack(vertical: true);
		
		b.StartGrid<KGroupBoxSeparator>("Add reference");
		b.R.AddButton(out addLibrary, "Library...", _ButtonClick_addLibrary);
		b.R.AddButton(out addNuget, "NuGet ▾", _ButtonClick_addNuget);
		b.R.AddButton(out addComRegistry, "COM ▾", _bAddComRegistry_Click)
			.AddButton(out addComBrowse, "...", _bAddComBrowse_Click).Width(30);
		b.AddButton(out addProject, "Project ▾", _ButtonClick_addProject);
		b.End();
		
		b.StartStack<KGroupBoxSeparator>("Add file", vertical: true);
		b.AddButton(out addClassFile, "Class file ▾", _ButtonClick_addClass);
		b.AddButton(out addResource, "Resource ▾", _ButtonClick_addFile);
		b.AddButton(out addFile, "Other file ▾", _ButtonClick_addFile);
		b.End();
		
		b.Add<AdornerDecorator>().Child().Add(out findInLists).Watermark("Find in lists")
			.Tooltip("In button drop-down lists show only items containing this text.\n\nTip: to hide garbage files, put them in folder(s) named \"Garbage\".");
		
		b.End();
		//..
		
		b.R.AddSeparator();
		
		b.R.StartGrid().Columns(-1, 0, 0);
		b.Add(out cMultiline, "/*/ multiple lines /*/").Checked(_meta.Multiline);
		b.Options(modifyPadding: false); //workaround for: OK/Cancel text incorrectly vcentered. Only on Win11, only in this dialog, only when this dialog is not in the secondary screen with DPI 125%.
		b.AddOkCancel();
		b.xAddDialogHelpButtonAndF1("editor/File properties");
		b.End();
		
		b.End();
		
		_role = _meta.role switch {
			"miniProgram" => MCRole.miniProgram,
			"exeProgram" => MCRole.exeProgram,
			"editorExtension" => MCRole.editorExtension,
			"classLibrary" when _isClass => MCRole.classLibrary,
			"classFile" when _isClass => MCRole.classFile,
			_ => _isClass ? MCRole.classFile : MCRole.miniProgram,
		};
		_InitCombo(role, _isClass ? "miniProgram|exeProgram|editorExtension|classLibrary|classFile" : "miniProgram|exeProgram|editorExtension", null, (int)_role);
		testScript.Text = _f.TestScript?.ItemPath;
		_miscFlags = _meta.miscFlags.ToInt();
		//Run
		_InitCombo(ifRunning, "warn_restart|warn|cancel_restart|cancel|wait_restart|wait|run_restart|run|restart|end|end_restart", _meta.ifRunning);
		_InitCombo(uac, "inherit|user|admin", _meta.uac);
		//Assembly
		outputPath.Text = _meta.outputPath;
		void _OutputPath_DropDownOpened(object sender, EventArgs e) {
			outputPath.IsDropDownOpen = false;
			var m = new popupMenu();
			m[_GetOutputPath(getDefault: true)] = o => outputPath.Text = o.ToString();
			bool isLibrary = _role == MCRole.classLibrary;
			if (isLibrary) m[@"%folders.ThisApp%\Libraries"] = o => outputPath.Text = o.ToString();
			m["Browse..."] = o => {
				var initf = _GetOutputPath(getDefault: false, expandEnvVar: true);
				if (!isLibrary && !filesystem.exists(initf)) initf = pathname.getDirectory(initf);
				filesystem.createDirectory(initf);
				var d = new FileOpenSaveDialog(isLibrary ? "{4D1F3AFB-DA1A-45AC-8C12-41DDA5C51CDD}" : "{4D1F3AFB-DA1A-45AC-8C12-51DDA5C51CDD}") {
					InitFolderFirstTime = initf,
				};
				if (d.ShowOpen(out string s, this, selectFolder: true)) outputPath.Text = folders.unexpandPath(s);
			};
			m.Show(owner: this);
		}
		icon.Text = _meta.icon;
		manifest.Text = _meta.manifest;
		sign.Text = _meta.sign;
		if (_meta.console is "true" or "!false") console.IsChecked = true;
		_InitCombo(platform, "Default|x64|arm64|x86", _meta.platform);
		if (_meta.xmlDoc == "true") xmlDoc.IsChecked = true;
		//Compile
		if (_meta.optimize is "true" or "!false") optimize.IsChecked = true;
		define.Text = _meta.define;
		_InitCombo(warningLevel, "8|7|6|5|4|3|2|1|0", _meta.warningLevel, 0);
		noWarnings.Text = _meta.noWarnings;
		_InitCombo(nullable, "disable|enable|warnings|annotations", _meta.nullable);
		testInternal.Text = _meta.testInternal;
		preBuild.Text = _meta.preBuild;
		postBuild.Text = _meta.postBuild;
		
		static void _InitCombo(ComboBox c, string items, string meta, int index = 0) {
			var a = items.Split('|');
			if (meta != null) index = Array.IndexOf(a, meta);
			foreach (var v in a) c.Items.Add(v);
			c.SelectedIndex = Math.Max(0, index);
		}
		
		_ChangedRole();
		role.SelectionChanged += (_, _) => {
			_role = (MCRole)role.SelectedIndex;
			_ChangedRole();
		};
		void _ChangedRole() {
			bool? ts = _role is MCRole.classLibrary or MCRole.classFile ? (_f.FindProject(out _, out var pmain) && _f != pmain ? null : true) : false;
			_ShowCollapse(testScript, ts != false);
			if (ts == null) { testScript.IsEnabled = false; testScript.Text = "<the first C# file of this project>"; }
			_ShowCollapse(_role is MCRole.miniProgram or MCRole.exeProgram, pRun, console, icon);
			_ShowCollapse(_role is MCRole.exeProgram or MCRole.classLibrary, outputPath);
			_ShowCollapse(_role is MCRole.exeProgram, manifest, platform);
			_ShowCollapse(_role == MCRole.classLibrary, xmlDoc);
			_ShowCollapse(_role != MCRole.classFile, gAssembly, gCompile);
		}
		
		//rejected. Will display error in code editor. Rarely used. For some would need to remove /suffix.
		//string _ValidateFile(FrameworkElement e, string name, FNFind kind) =>
		
		b.OkApply += _OkApply;
	}
	
	protected override void OnSourceInitialized(EventArgs e) {
		_InitInfo();
		base.OnSourceInitialized(e);
	}
	
	void _GetMeta() {
		//info: _Get returns null if hidden
		
		_f.TestScript = _Get(testScript) is string sts && testScript.IsEnabled ? _f.FindRelative(true, sts, FNFind.CodeFile) : null; //validated
		
		_meta.ifRunning = _Get(ifRunning, defaultIndex: 0);
		_meta.uac = _Get(uac, defaultIndex: 0);
		_meta.platform = _Get(platform, defaultIndex: 0);
		
		_meta.console = _Get(console);
		_meta.icon = _Get(icon);
		_meta.manifest = _Get(manifest);
		//_meta.resFile = _Get(resFile);
		_meta.sign = _Get(sign);
		_meta.xmlDoc = _Get(xmlDoc);
		
		_meta.optimize = _Get(optimize);
		_meta.define = _Get(define);
		_meta.warningLevel = _Get(warningLevel, defaultIndex: 0);
		_meta.noWarnings = _Get(noWarnings);
		_meta.nullable = _Get(nullable, defaultIndex: 0);
		_meta.testInternal = _Get(testInternal);
		_meta.preBuild = _Get(preBuild);
		_meta.postBuild = _Get(postBuild);
		
		var oldRole = _meta.role;
		_meta.role = null;
		_meta.outputPath = null;
		if (_role != MCRole.classFile) {
			if (_isClass || _role != MCRole.miniProgram) _meta.role = _role.ToString();
			switch (_role) {
			case MCRole.exeProgram:
			case MCRole.classLibrary:
				_meta.outputPath = _GetOutputPath(getDefault: false);
				break;
			}
		}
		
		_meta.miscFlags = _miscFlags == 0 ? null : _miscFlags.ToS();
		
		if (_isClass && oldRole is null or "classLibrary" && !(_meta.role is null or "classLibrary")) {
			print.it($$"""
<>Info: Now <help editor/Class files, projects>class file<> '{{_f.Name}}' can be executed directly. Just add code that calls a class function. Example:
<code>/*/ role {{_meta.role}}; define TEST; /*/
#if TEST //allows to use this class file elsewhere via /*/ c {{_f.Name}}; /*/
Class1.Function1();
#endif
class Class1 {
	public static void Function1() {
		print.it(1);
	}
}
</code>
""");
		}
	}
	
	void _OkApply(WBButtonClickArgs e) {
		if (App.Model.CurrentFile != _f && !App.Model.SetCurrentFile(_f)) return;
		_GetMeta();
		_meta.Multiline = cMultiline.IsChecked;
		_meta.Apply();
	}
	
	void _ButtonClick_addLibrary(WBButtonClickArgs e) {
		string dir1 = App.Model.DllDirectory, dir2 = folders.ThisAppBS + "Libraries", initDir = null;
		bool exists1 = filesystem.exists(dir1).Directory, exists2 = filesystem.exists(dir2).Directory;
		if (exists1 || exists2) {
			var m = new popupMenu { CheckDontClose = true };
			if (exists1) m.Add(1, @"%folders.Workspace%\dll");
			if (exists2) m.Add(2, @"%folders.ThisApp%\Libraries");
			m.Add(3, "Last used folder");
			m.Separator();
			m.AddCheck("Unexpand path (option)", App.Settings.tools_pathUnexpand, o => App.Settings.tools_pathUnexpand ^= true);
			int r = m.Show(owner: this); if (r == 0) return;
			if (r == 1) initDir = dir1; else if (r == 2) initDir = dir2;
		}
		var d = new FileOpenSaveDialog("{4D1F3AFB-DA1A-47AC-8C12-41DDA5C51CDB}") {
			FileTypes = "Dll|*.dll|All files|*.*",
			InitFolderNow = initDir
		};
		if (!d.ShowOpen(out string[] a, this)) return;
		
		if (!TUtil2.UnexpandPathsMetaR(a, this)) return;
		
		_meta.r.AddRange(a);
		_ShowInfo_Added(e.Button, _meta.r);
	}
	
	void _ButtonClick_addNuget(WBButtonClickArgs e) {
		var a = DNuget.GetInstalledPackages();
		if (a == null) {
			dialog.showInfo(null, "There are no NuGet packages installed in this workspace.\nTo install NuGet packages, use menu Tools > NuGet.", owner: this);
			return;
		}
		var sFind = findInLists.Text;
		if (!sFind.NE()) {
			a = a.Where(s => s.Contains(sFind, StringComparison.OrdinalIgnoreCase)).ToArray();
			if (!a.Any()) return;
		}
		int i = popupMenu.showSimple(a, owner: this, rawText: true) - 1; if (i < 0) return;
		_meta.nuget.Add(a[i]);
		_ShowInfo_Added(e.Button, _meta.nuget);
	}
	
	void _ButtonClick_addProject(WBButtonClickArgs e)
		=> _AddFromWorkspace(
			f => (f != _f && f.GetClassFileRole() == FNClassFileRole.Library) ? f : null,
			_meta.pr, false, e.Button);
	
	void _ButtonClick_addClass(WBButtonClickArgs e) {
		FileNode prFolder1 = null;
		if (_f.IsScript && _f.FindProject(out prFolder1, out var prMain1, ofAnyScript: true) && _f == prMain1) prFolder1 = null;
		
		bool _Include(FileNode f) {
			if (!f.IsClass || f == _f) return false;
			if (f.FindProject(out var prFolder, out var prMain) && !prFolder.Name.Starts("@@")) { //exclude class files that are in projects, except if project name starts with @@
				if (prFolder != prFolder1) return false; //but if _f is a non-project script in a project folder, include local classes
			}
			return f.GetClassFileRole() == FNClassFileRole.Class;
		}
		
		_AddFromWorkspace(f => _Include(f) ? f : null, _meta.c, false, e.Button);
	}
	
	void _ButtonClick_addFile(WBButtonClickArgs e) {
		bool isResource = e.Button == addResource;
		var a = isResource ? _meta.resource : _meta.file;
		var m = new popupMenu();
		if (_f.FindProject(out var proj, out _, ofAnyScript: true)) m.Submenu("Project", m => _AddFW(m, proj));
		m.Submenu("All", m => _AddFW(m));
		m.Submenu("By type", m => _AddFW(m, sortByType: true));
		if (isResource) {
			m.Submenu("Options", m => {
				m.AddCheck("Add XAML icons from code strings like \"*name color\"",
					check: _role is not (MCRole.editorExtension or MCRole.classFile) && 0 == (_miscFlags & 1),
					click: o => { if (o.IsChecked) _miscFlags &= ~1; else _miscFlags |= 1; });
			});
		}
		m.Show(owner: this);
		
		void _AddFW(popupMenu m, FileNode proj = null, bool sortByType = false) {
			_AddFromWorkspace(
				f => {
					if (f.IsCodeFile) return null;
					if (f.IsFolder) { //add if contains non-code files and does not contain code files
						if (proj == null) return null;
						bool has = false;
						foreach (var v in f.Descendants()) { if (v.IsCodeFile) return null; has |= !v.IsFolder; }
						if (!has) return null;
					}
					return f;
				}, a, true, e.Button, proj, m, sortByType);
		}
	}
	
	void _AddFromWorkspace(Func<FileNode, FileNode> filter, List<string> metaList, bool withIcons, UIElement clicked, FileNode folder = null, popupMenu pm = null, bool sortByType = false, bool noInfo = false) {
		var sFind = findInLists.Text;
		List<(FileNode f, string s, bool near)> a = new();
		folder ??= App.Model.Root;
		foreach (var f in folder.DescendantsExceptGarbage()) {
			if (filter(f) is not FileNode f2) continue;
			
			var path = f2.ItemPath;
			if (sFind.Length > 0 && path.Find(sFind, true) < 0) continue;
			
			//if (_f.Parent.Parent != null && f.IsDescendantOf(_f.Parent)) path = "." + f.ItemPathIn(_f.Parent); //rejected. Bad with export-import.
			
			if (!metaList.Contains(path, StringComparer.OrdinalIgnoreCase)) {
				bool near = _f.Parent.Parent != null && f.IsDescendantOf(_f.Parent);
				a.Add((f2, path, near));
			}
		}
		if (a.Count == 0) {
			if (pm == null) _ShowInfo_ListEmpty(clicked, sFind);
			return;
		}
		
		if (sortByType) {
			a = a.OrderBy(o => o.f.FileExt).ThenBy(o => !o.near).ThenBy(o => o.s).ToList();
		} else {
			a = a.OrderBy(o => !o.near).ThenBy(o => o.s).ToList();
		}
		
		var m = pm ?? new popupMenu();
		string prevExt = null;
		foreach (var (f, s, near) in a) {
			if (sortByType) {
				var ext = f.FileExt;
				if (prevExt != null && !ext.Eqi(prevExt)) m.Separator();
				prevExt = ext;
			}
			var v = m.Add(s.Limit(80, middle: true), o => {
				//metaList.Add(s[0] == '.' ? s : f.ItemPathOrName());
				metaList.Add(f.ItemPathOrName(relativeTo: _f));
				if (!noInfo) _ShowInfo_Added(clicked, metaList);
			}, withIcons ? f.FilePath : null);
			//if (s[0] == '.') v.TextColor = 0x0080ff;
			if (near) v.TextColor = 0x0080ff;
		}
		if (pm == null) m.Show(owner: this);
	}
	
	void _IconManifestSign_DropDownOpened(object sender, EventArgs e) {
		var cb = sender as ComboBox;
		cb.IsDropDownOpen = false;
		
		var ext = cb == icon ? ".ico" : cb == manifest ? ".manifest" : ".snk";
		List<string> r = new();
		_AddFromWorkspace(f => f.FileType == FNType.Other && f.FileExt.Eqi(ext) ? f : null, r, cb == icon, cb, noInfo: true);
		if (r.Count > 0) cb.Text = r[0];
	}
	
	#region COM
	
	void _bAddComBrowse_Click(WBButtonClickArgs e) {
		var m = new popupMenu();
		m["Select and convert a COM library..."] = _ => {
			var d = new FileOpenSaveDialog("{4D1F3AFB-DA1A-45AC-8C12-41DDA5C51CDC}") {
				FileTypes = "Type library|*.dll;*.tlb;*.olb;*.ocx;*.exe|All files|*.*"
			};
			if (d.ShowOpen(out string s, this))
				_ConvertTypeLibrary(s, e.Button);
		};
		var dir = folders.Workspace + @".interop";
		if (filesystem.exists(dir)) {
			m.Submenu("Use converted", m => {
				foreach (var f in filesystem.enumFiles(dir, "*.dll")) {
					m[f.Name] = o => {
						var s = o.Text;
						if (!_meta.com.Contains(s)) _meta.com.Add(s);
						_ShowInfo_Added(e.Button, _meta.com);
					};
				}
			});
			m["Delete converted..."] = _ => run.itSafe(dir);
		}
		m.Show(owner: this);
	}
	
	void _bAddComRegistry_Click(WBButtonClickArgs e) {
		//HKCU\TypeLib\typelibGuid\version\
		var sFind = findInLists.Text;
		var rx = new regexp(@"(?i) (?:Type |Object )?Library[ \d\.]*$");
		var a = new List<EdComUtil.RegTypelib>(1000);
		using (var tlKey = Registry.ClassesRoot.OpenSubKey("TypeLib")) { //guids
			foreach (var sGuid in tlKey.GetSubKeyNames()) {
				if (sGuid.Length != 38) continue;
				//print.it(sGuid);
				using var guidKey = tlKey.OpenSubKey(sGuid);
				foreach (var sVer in guidKey.GetSubKeyNames()) {
					using var verKey = guidKey.OpenSubKey(sVer);
					if (verKey.GetValue("") is string description) {
						if (rx.Match(description, 0, out RXGroup g)) description = description.Remove(g.Start);
						if (sFind.Length > 0 && description.Find(sFind, true) < 0) continue;
						a.Add(new(description.Limit(80, middle: true) + ", " + sVer, sGuid, sVer));
					} //else print.it(sGuid); //some Microsoft typelibs. VS does not show these too.
				}
			}
		}
		if (a.Count == 0) { _ShowInfo_ListEmpty(e.Button, sFind); return; }
		a.Sort((x, y) => string.Compare(x.text, y.text, true));
		
		var m = new popupMenu();
		foreach (var v in a) {
			m[v.text] = o => _ConvertTypeLibrary(v, e.Button);
		}
		m.Show(owner: this);
	}
	
	async void _ConvertTypeLibrary(object tlDef, Button button) {
		if (await EdComUtil.ConvertTypeLibrary(tlDef, this) is { } converted) {
			foreach (var v in converted) if (!_meta.com.Contains(v)) _meta.com.Add(v);
			_ShowInfo_Added(button, _meta.com);
		}
	}
	
	#endregion
	
	#region util
	
	static void _ShowHide(FrameworkElement e, bool show) => e.Visibility = show ? Visibility.Visible : Visibility.Hidden;
	
	static void _ShowCollapse(FrameworkElement e, bool show) => e.Visibility = show ? Visibility.Visible : Visibility.Collapsed;
	
	static void _ShowHide(bool show, params FrameworkElement[] a) {
		foreach (var v in a) _ShowHide(v, show);
	}
	
	static void _ShowCollapse(bool show, params FrameworkElement[] a) {
		foreach (var v in a) _ShowCollapse(v, show);
	}
	
	static bool _IsHidden(FrameworkElement t) {
		if (t.IsVisible) return false;
		if (t.Visibility != Visibility.Visible) return true;
		return true;
	}
	
	static string _Get(TextBox t, bool nullIfHidden = true) {
		if (nullIfHidden && _IsHidden(t)) return null;
		var r = t.Text.Trim();
		return r == "" ? null : r;
	}
	
	static string _Get(ComboBox t, bool nullIfHidden = true, int? defaultIndex = null) {
		if (defaultIndex.HasValue && t.SelectedIndex == defaultIndex.Value) return null;
		if (nullIfHidden && _IsHidden(t)) return null;
		return t.IsEditable ? t.Text : t.SelectedItem as string; //note: t.Text changes after t.SelectionChanged event
	}
	
	static string _Get(KCheckBox t, bool nullIfHidden = true) {
		if (nullIfHidden && _IsHidden(t)) return null;
		return t.IsChecked ? "true" : null;
	}
	
	static bool _IsChecked(KCheckBox t, bool falseIfHidden = true) {
		if (falseIfHidden && _IsHidden(t)) return false;
		return t.IsChecked;
	}
	
	string _GetOutputPath(bool getDefault, bool expandEnvVar = false) {
		if (!getDefault && _Get(outputPath) is string r) {
			if (expandEnvVar) r = pathname.expand(r);
		} else {
			r = MetaComments.GetDefaultOutputPath(_f, _role, withEnvVar: !expandEnvVar);
		}
		return r;
	}
	
	void _ShowInfo_ListEmpty(UIElement by, string sFind) {
		_ShowInfoTooltip(by, sFind.Length > 0 ? "There are no items containing " + sFind : "The list is empty");
	}
	
	void _ShowInfo_Added(UIElement by, List<string> metaList) {
		_ShowInfoTooltip(by, string.Join("\r\n", metaList) + "\r\n\r\nFinally click OK to save.");
	}
	
	void _ShowInfoTooltip(UIElement by, string s) {
		ToolLand.TUtil.InfoTooltip(ref _tt, by, s, Dock.Right);
	}
	KPopup _tt;
	
	#endregion
	
	#region info
	
	void _InitInfo() {
		info.AaTags.AddStyleTag(".c", new() { backColor = 0xF0F0F0, monospace = true }); //inline code
		info.AaTags.AddLinkTag("+changeFileType", _ => {
			if (!dialog.showOkCancel($"Change file type to: {(_f.IsScript ? "class" : "script")}", "This also will close the Properties dialog as if clicked Cancel.", owner: this)) return;
			_f.FileType = _f.IsScript ? FNType.Class : FNType.Script;
			Close();
		});
		
		var dialogInfo = $"""
File type: <help editor/{(_isClass ? "Class files, projects>C# class file" : "Scripts>C# script")}<>  (<+changeFileType>change...<>)
File path: <explore>{_f.FilePath}<>
""";
		info.aaaText = dialogInfo;
		info.AaAddElem(this, dialogInfo);
		
		info.AaAddElem(role, """
<b>role<> - the purpose of this C# code file. What type of assembly to create and how to execute.
 • <.c>miniProgram<> - execute in a separate host process started from editor.
 • <.c>exeProgram<> - create/execute .exe file, which can run on any computer, without editor installed.
 • <.c>editorExtension<> - execute in the editor's UI thread. Rarely used. Incorrect code can kill editor.
 • <.c>classLibrary<> - create .dll file, which can be used in C# scripts and other .NET-based programs.
 • <.c>classFile<> - don't create/execute. The file can be used by other C# files, either as part of the project or added explicitly.
""");
		
		#region Run
		info.AaAddElem(testScript, """
<b>testScript<> - a script to run when you click the <b>Run<> button.

Press F1 for more info.
""");
		info.AaAddElem(ifRunning, """
<b>ifRunning<> - when trying to start this script, what to do if it is already running.
 • <.c>warn<> - print warning and don't run.
 • <.c>cancel<> - don't run.
 • <.c>wait<> - run later, when it ends.
 • <.c>run<> - run simultaneously.
 • <.c>restart<> - end it and run.
 • <.c>end<> - end it and don't run.

Suffix <.c>_restart<> means restart if starting the script with the <b>Run<> button.
""");
		info.AaAddElem(uac, """
<b>uac<> - <help articles/UAC>UAC<> integrity level (IL) of the task process.
 • <.c>inherit<> (default) - the same as of the editor process.
 • <.c>user<> - Medium IL, like most applications. The task cannot automate some windows etc.
 • <.c>admin<> - High IL, aka "administrator", "elevated".
""");
		#endregion
		
		#region Compile
		info.AaAddElem(optimize, """
<b>optimize<> - whether to make the compiled code as fast as possible.
 • <.c>false<> (default) - don't optimize. Define <.c>DEBUG<> and <.c>TRACE<>. Aka "Debug configuration".
 • <.c>true<> (checked) - optimize. Aka "Release configuration".
""");
		info.AaAddElem(define, """
<b>define<> - symbols that can be used with <.c>#if<>.

Example: <.c>ONE,TWO,r:THREE,d:FOUR<>
Prefix <.c>r:<> - if <.c>optimize true<>. Prefix <.c>d:<> - if no <.c>optimize true<>.

See also <google C# #define>#define<>.
""");
		info.AaAddElem(warningLevel, $"""
<b>warningLevel<> - <google C# Compiler Options, WarningLevel>warning level<>.
0 - no warnings.
1 - only severe warnings.
2 - level 1 plus some less-severe warnings.
3 - most warnings.
4 - all warnings of C# 1-8.
5-9999 - level 4 plus warnings added in C# 9+.
""");
		info.AaAddElem(noWarnings, $"""
<b>noWarnings<> - don't show these warnings.

Example: <.c>151,3001,CS1234<>

See also <google C# #pragma warning>#pragma warning<>.
""");
		info.AaAddElem(nullable, """
<b>nullable<> - <google C# Nullable reference types>nullable context<>.
disable - no warnings; code does not use nullable syntax (<.c>Type? variable<>).
enable - print warnings; code uses nullable syntax.
warnings - print warnings; code does not use nullable syntax.
annotations - no warnings; code uses nullable syntax.
""");
		info.AaAddElem(testInternal, """
<b>testInternal<> - can use internal members of these assemblies, like with <.c>InternalsVisibleToAttribute<>.

Example: <.c>Assembly1,Assembly2<>
""");
		info.AaAddElem(preBuild, """
<b>preBuild<> - a script to run before compiling.

To create new preBuild script: menu <b>File > New > More<>.
Press F1 for more info.
""");
		info.AaAddElem(postBuild, """
<b>postBuild<> - a script to run after compiling successfully.

To create new postBuild script: menu <b>File > New > More<>.
Press F1 for more info.
""");
		#endregion
		
		#region Assembly
		info.AaAddElem(outputPath, """
<b>outputPath<> - directory for the output files (exe, dll etc).

Press F1 for more info.
""");
		info.AaAddElem(icon, """
<b>icon<> - icon(s) of the output exe file.

Press F1 for more info.
""");
		info.AaAddElem(manifest, """
<b>manifest<> - <google manifest file site:microsoft.com>manifest<> of the output exe file.

Press F1 for more info.
""");
		info.AaAddElem(sign, """
<b>sign<> - strong-name signing key file, to sign the output assembly.

Press F1 for more info.
""");
		info.AaAddElem(console, """
<b>console<> - let the program run with console.
""");
		info.AaAddElem(platform, $"""
<b>platform<> - CPU instruction set.

Default on this computer: {(osVersion.isArm64Process ? "arm64" : "x64")}.
Press F1 for more info.
""");
		
		info.AaAddElem(xmlDoc, """
<b>xmlDoc<> - create XML documentation file from <.c>/// comments<>. And print errors in <.c>/// comments<>.
""");
		#endregion
		
		#region Add reference
		info.AaAddElem(addLibrary, """
<b>Library<> - add a .NET assembly reference.
Adds meta comment <c green>r DllFile<>.

Press F1 for more info.
""");
		info.AaAddElem(addNuget, """
<b>NuGet<> - use a NuGet package reference (see menu <b>Tools > NuGet</b>).
Adds meta comment <c green>nuget Folder\Package<>.

Press F1 for more info.
""");
		
		const string c_com = """
<b>COM<>, <b>...<> - convert (now) a COM component's type library to an <i>interop assembly<>, and use it.
Adds meta comment <c green>com FileName.dll<>.
Saves the assembly file in <link>%folders.Workspace%\.interop<>.

Press F1 for more info.
""";
		info.AaAddElem(addComRegistry, c_com);
		info.AaAddElem(addComBrowse, c_com);
		info.AaAddElem(addProject, """
<b>Project<> - add a reference to a class library created in this workspace.
Adds meta comment <c green>pr File.cs<>.

Press F1 for more info.
""");
		#endregion
		
		#region Add file
		info.AaAddElem(addClassFile, """
<b>Class file<> - add a C# code file that contains some classes/functions used by this file.
Adds meta comment <c green>c File.cs<>.

Press F1 for more info.
""");
		//FUTURE: add UI to append resource suffix
		info.AaAddElem(addResource, """
<b>Resource<> - add image etc file(s) as managed resources.
Adds meta comment <c green>resource File<>.

Press F1 for more info.
""");
		info.AaAddElem(addFile, """
<b>Other file<> - make a file available at run time. Eg an unmanaged dll.
Adds meta comment <c green>file File<>.

Press F1 for more info.
""");
		#endregion
	}
	
	#endregion
}


================================================
FILE: Au.Editor/Files/FileNode.cs
================================================
using Au.Controls;
using System.Xml;
using System.Xml.Linq;

namespace LA;

partial class FileNode : TreeBase<FileNode>, ITreeViewItem {
	#region types
	
	//Not saved in file.
	[Flags]
	enum _State : byte {
		Deleted = 1,
	}
	
	//Saved in file.
	[Flags]
	enum _Flags : byte {
		_obsolete_Symlink = 1,
	}
	
	#endregion
	
	#region fields, ctors, load/save
	
	readonly FilesModel _model;
	string _name;
	string _displayName;
	uint _id;
	FNType _type;
	_State _state;
	_Flags _flags;
	string _linkTarget;
	string _icon;
	uint _testScriptId;
	
	/// <summary>
	/// This ctor is used when creating new item of known type in current workspace. Not when exporting.
	/// </summary>
	public FileNode(FilesModel model, string name, FNType type) {
		_model = model;
		_type = type;
		_SetName(name);
		_id = _model.AddGetId(this);
	}
	
	/// <summary>
	/// This ctor is used when importing items from files etc.
	/// </summary>
	/// <param name="model"></param>
	/// <param name="name"></param>
	/// <param name="filePath">Used to detect type (when !isDir). If isLink, sets link target.</param>
	/// <param name="isDir"></param>
	/// <param name="isLink"></param>
	public FileNode(FilesModel model, string name, string filePath, bool isDir, bool isLink = false) {
		_model = model;
		_type = isDir ? FNType.Folder : _DetectFileType(filePath);
		_SetName(name);
		_id = _model.AddGetId(this);
		if (isLink) _linkTarget = filePath;
	}
	
	/// <summary>
	/// This ctor is used when copying an item or importing a workspace.
	/// Deep-copies fields from f, except _model, _name, _id (generates new) and _testScriptId.
	/// </summary>
	FileNode(FilesModel model, FileNode f, string name) {
		_model = model;
		_SetName(name);
		_type = f._type;
		_state = f._state;
		_flags = f._flags;
		_linkTarget = f._linkTarget;
		_icon = f.CustomIconName;
		_id = _model.AddGetId(this);
	}
	
	/// <summary>
	/// This ctor is used when loading workspace (reading files.xml).
	/// </summary>
	FileNode(XmlReader x, FileNode parent, FilesModel model) {
		_model = model;
		if (parent == null) { //the root node
			if (x.Name != "files") throw new ArgumentException("XML root element name must be 'files'");
		} else {
			_type = XmlTagToFileType(x.Name, canThrow: true);
			while (x.MoveToNextAttribute()) _ReadXmlAttribute(x.Name, x.Value);
			if (_name == null) throw new ArgumentException("no 'n' attribute in XML");
		}
	}
	
	/// <summary>
	/// This ctor is used when syncing workspace (reading files.xml modified by another LA process).
	/// </summary>
	internal FileNode(XElement x, FilesModel model) {
		_model = model;
		_type = XmlTagToFileType(x.Name.LocalName, canThrow: true);
		foreach (var attr in x.Attributes()) _ReadXmlAttribute(attr.Name.LocalName, attr.Value);
		if (_name == null) throw new ArgumentException("no 'n' attribute in XML");
	}
	
	void _ReadXmlAttribute(string name, string value) {
		if (value.NE()) return;
		switch (name) {
		case "n": _SetName(value); break;
		case "i": value.ToInt(out _id); break;
		case "f": _flags = (_Flags)value.ToInt(); break;
		case "path": _linkTarget = value.Starts(@".\") ? _model.WorkspaceDirectory + value[1..] : value; break;
		case "icon": _icon = value; break;
		case "run": value.ToInt(out _testScriptId); break;
		}
	}
	
	internal void _WorkspaceLoaded(uint id, bool importing) {
		_id = id; //if id in XML was invalid, the caller generated new id
		
		if (_flags.Has(_Flags._obsolete_Symlink)) { //before v0.17 for folder links used symlinks. Bad idea.
			_flags &= ~_Flags._obsolete_Symlink;
			var linkPath = FilePath;
			filesystem.more.getFinalPath(linkPath, out _linkTarget);
			if (!importing) {
				Api.RemoveDirectory(linkPath);
				_model.Save.WorkspaceAsync();
			}
		}
	}
	
	public static FileNode LoadWorkspace(string file, FilesModel model) {
		var root = XmlLoad(file, (x, p) => new FileNode(x, p, model));
		root._isExpanded = true;
		return root;
	}
	
	public void SaveWorkspace(string file) => XmlSave(file, (x, n) => n._XmlWrite(x));
	
	void _XmlWrite(XmlWriter x) {
		if (x.WriteState is WriteState.Prolog or WriteState.Start) {
			x.WriteStartElement("files");
		} else {
			x.WriteStartElement(_type switch { FNType.Folder => "d", FNType.Script => "s", FNType.Class => "c", _ => "n" });
			x.WriteAttributeString("n", _name);
			if (_id != 0) x.WriteAttributeString("i", _id.ToString());
			if (_flags != 0) x.WriteAttributeString("f", ((int)_flags).ToString());
			if (IsLink) x.WriteAttributeString("path", _model != null && _linkTarget.PathStarts(_model.WorkspaceDirectory) ? @"." + _linkTarget[_model.WorkspaceDirectory.Length..] : _linkTarget);
			if (CustomIconName is { } ico) x.WriteAttributeString("icon", ico);
			if (_testScriptId != 0) x.WriteAttributeString("run", _testScriptId.ToString());
			
			//These are not set when exporting: _id, _model, _testScriptId.
		}
	}
	
	public static void Export(FileNode fRoot, string file) {
		fRoot.XmlSave(file, (x, n) => n._XmlWrite(x));
	}
	
	FileNode() { }
	
	/// <summary>
	/// Creates the root folder for exporting.
	/// </summary>
	public static FileNode CreateForExport() {
		return new() { _type = FNType.Folder };
	}
	
	/// <summary>
	/// Creates a folder for exporting, eg folder "Classes" for meta c files.
	/// </summary>
	/// <param name="folderName"></param>
	public static FileNode CreateForExport(string folderName) {
		return new() { _type = FNType.Folder, _name = folderName };
	}
	
	/// <summary>
	/// Creates a clone of an item for exporting.
	/// </summary>
	/// <param name="f">The original item to get properties from.</param>
	/// <param name="exportLinkTarget">Don't set <b>_linkTarget</b>.</param>
	public static FileNode CreateForExport(FileNode f, bool exportLinkTarget) {
		return new() {
			_type = f._type,
			_name = f._name,
			_flags = f._flags,
			_linkTarget = exportLinkTarget ? null : f._linkTarget,
			_icon = f._icon,
		};
	}
	
	#endregion
	
	#region properties
	
	/// <summary>
	/// Panels.Files.TreeControl.
	/// </summary>
	public static KTreeView TreeControl => Panels.Files.TreeControl;
	
	/// <summary>
	/// Gets workspace that contains this file.
	/// </summary>
	public FilesModel Model => _model;
	
	/// <summary>
	/// Gets the root node (Model.Root).
	/// </summary>
	public FileNode Root => _model.Root;
	
	/// <summary>
	/// File type.
	/// Setter can change Script to Class or vice versa; call when closing DProperties.
	/// </summary>
	public FNType FileType {
		get => _type;
		set {
			Debug.Assert(IsCodeFile);
			if (value == _type) return;
			_type = value;
			_testScriptId = 0;
			
			_model.Save.WorkspaceAsync();
			Compiler.Uncache(this);
			CodeInfo.FilesChanged();
			FilesModel.Redraw(this);
		}
	}
	
	/// <summary>
	/// true if folder or root.
	/// </summary>
	public bool IsFolder => _type == FNType.Folder;
	
	/// <summary>
	/// true if script file.
	/// </summary>
	public bool IsScript => _type == FNType.Script;
	
	/// <summary>
	/// true if class file.
	/// </summary>
	public bool IsClass => _type == FNType.Class;
	
	/// <summary>
	/// true if script or class file.
	/// false if folder or not a code file.
	/// </summary>
	public bool IsCodeFile => _type is FNType.Script or FNType.Class;
	
	/// <summary>
	/// true if not script/class/folder.
	/// </summary>
	public bool IsOtherFileType => _type == FNType.Other;
	
	/// <summary>
	/// File name with extension.
	/// </summary>
	public string Name => _name;
	
	/// <summary>
	/// File name. Without extension if ends with ".cs".
	/// </summary>
	public string DisplayName => _displayName ??= IsCodeFile ? _name.RemoveSuffix(".cs", true) : _name;
	
	void _SetName(string name) {
		if (_name != null) _model._nameMap.MultiRemove_(_name, this); //renaming
		_model._nameMap.MultiAdd_(_name = name, this);
		_displayName = null;
	}
	
	/// <summary>
	/// Unique id in this workspace. To find faster, with database, etc.
	/// Root id is 0.
	/// Ids of deleted items are not reused.
	/// </summary>
	public uint Id => _id;
	
	/// <summary>
	/// <see cref="Id"/> as string.
	/// </summary>
	public string IdString => _id.ToString();
	
	/// <summary>
	/// Formats string like ":0x10000000A", with <see cref="Id"/> in low-order uint and <see cref="FilesModel.WorkspaceSN"/> in high-order int.
	/// Such string can be passed to <see cref="FilesModel.Find"/>.
	/// </summary>
	public string IdStringWithWorkspace => ":0x" + (_id | ((long)_model.WorkspaceSN << 32)).ToString("X");
	
	/// <summary>
	/// Formats SciTags &lt;open&gt; link tag to open this file.
	/// </summary>
	/// <param name="path">In link name use <see cref="ItemPath"/> instead of name.</param>
	/// <param name="lineOrPos">If not null: if >0, appends |lineOrPos (1-based line index); else appends ||-lineOrPos (0-based position).</param>
	public string SciLink(bool path = false, int? lineOrPos = null) {
		string text = path ? ItemPath : _name;
		if (lineOrPos == null) return $"<open {IdStringWithWorkspace}>{text}<>";
		int i = lineOrPos.Value;
		if (i > 0) return $"<open {IdStringWithWorkspace}|{i}>{text}<>";
		return $"<open {IdStringWithWorkspace}||{-i}>{text}<>";
	}
	
	/// <summary>
	/// true if is a link to an external file or folder.
	/// See also IsExternal.
	/// </summary>
	public bool IsLink => _linkTarget != null;
	
	/// <summary>
	/// If <see cref="IsLink"/>, returns target path, else null.
	/// </summary>
	public string LinkTarget => _linkTarget;
	
	/// <summary>
	/// true if this or an ancestor is <see cref="IsLink"/>.
	/// </summary>
	public bool IsExternal {
		get {
			for (var v = this; v != null; v = v.Parent) if (v.IsLink) return true;
			return false;
		}
	}
	
	/// <summary>
	/// Gets the filename extension of the target file, like ".cs". Returns "" if folder.
	/// </summary>
	public string FileExt => IsFolder ? "" : pathname.getExtension(IsLink ? LinkTarget : Name);
	
	/// <summary>
	/// Gets or sets custom icon name (like "*Pack.Icon color") or null.
	/// </summary>
	/// <remarks>
	/// The setter will save workspace.
	/// User can set custom icon: menu Tools > Icons.
	/// Currently editor does not support item icons as .ico files etc. Not difficult to add, but probably don't need when we have 25000 XAML icons. For .exe files can use any icons.
	/// </remarks>
	public string CustomIconName {
		get => _icon;
		set {
			_icon = value;
			_model.Save.WorkspaceAsync();
			Compiler.Uncache(this);
			FilesModel.Redraw(this);
		}
	}
	
	/// <summary>
	/// Gets custom or default icon name or file path.
	/// </summary>
	public string IconString => CustomIconName ?? (IsOtherFileType ? FilePath : GetFileTypeImageSource(FileType));
	
	/// <summary>
	/// Gets or sets other item to run instead of this. None if null.
	/// The setter will save workspace.
	/// </summary>
	public FileNode TestScript {
		get {
			if (_testScriptId != 0) {
				var f = _model.FindById(_testScriptId); if (f != null) return f;
				TestScript = null;
			}
			return null;
		}
		set {
			uint id = value?._id ?? 0;
			if (_testScriptId == id) return;
			_testScriptId = id;
			_model.Save.WorkspaceAsync();
		}
	}
	
	/// <summary>
	/// Gets or sets 'Delete' flag. Does nothing more.
	/// </summary>
	public bool IsDeleted {
		get => 0 != (_state & _State.Deleted);
		set { Debug.Assert(value); _state |= _State.Deleted; }
	}
	
	/// <summary>
	/// true if is deleted or is not in current workspace.
	/// </summary>
	public bool IsAlien => IsDeleted || _model != App.Model;
	
	/// <summary>
	/// Returns item path in workspace, like @"\Folder\Name.cs" or @"\Name.cs".
	/// Returns null if this item is deleted.
	/// </summary>
	public string ItemPath => _ItemPath();
	
	/// <summary>
	/// Returns item path relative to <i>ancestor</i>, like @"\Folder\Name.cs" or @"\Name.cs".
	/// Returns null if this item is deleted or not in <i>ancestor</i>.
	/// If <i>ancestor</i> is null or <b>Root</b>, the result is the same as <b>ItemPath</b>.
	/// </summary>
	public string ItemPathIn(FileNode ancestor) => _ItemPath(null, ancestor);
	
	[SkipLocalsInit]
	unsafe string _ItemPath(string prefix = null, FileNode ancestor = null) {
		if (!App.IsMainThread) {
			Debug_.Print("_ItemPath called in wrong thread");
			return App.Dispatcher.Invoke(() => _ItemPath(prefix, ancestor));
		}
		int len = prefix.Lenn();
		var root = ancestor ?? Root;
		for (var f = this; f != root; f = f.Parent) {
			if (f == null) { Debug.Assert(IsDeleted); throw new InvalidOperationException(); }
			len += f._name.Length + 1;
		}
		var p = stackalloc char[len];
		char* e = p + len;
		for (var f = this; f != root; f = f.Parent) {
			f._name.CopyTo_(e -= f._name.Length);
			*(--e) = '\\';
		}
		if (e > p) prefix.CopyTo_(p);
		return new string(p, 0, len);
	}
	
	/// <summary>
	/// Gets full path of the file.
	/// If this is a link, it is the link target.
	/// </summary>
	public string FilePath {
		get {
			if (this == Root) return _model.FilesDirectory;
			if (IsDeleted) return null;
			
			if (IsLink) return LinkTarget;
			FileNode link = Parent; while (link != null && !link.IsLink) link = link.Parent;
			if (link != null) return _ItemPath(link.LinkTarget, link);
			
			return _ItemPath(_model.FilesDirectory);
		}
	}
	//rejected: cache item path and file path.
	//	When an item renamed or moved, reset cached paths of that item and of its descendants.
	//	But creating paths is fast and not so much garbage. And not so frequently used. Keeping paths in memory isn't good too.
	
	/// <summary>
	/// Returns <b>ItemPath</b> if exist multiple items with <b>Name</b>. Else returns <b>Name</b>.
	/// Can be used for inserting code, like <c>script.run</c>.
	/// </summary>
	public string ItemPathOrName() {
		//if (!_name.RxIsMatch(@"(?i)^(?:Script\d*\.cs|Class\d*\.cs|File\d*\..+|Folder\d*)$")) { //rejected
		if (Model.Find(_name, silent: true) == this) return _name; //else found multiple
		//}
		return ItemPath;
	}
	
	/// <summary>
	/// Returns <b>ItemPath</b> if exist multiple items with <b>Name</b>, unless single exists in <i>relativeTo</i>'s subfolders or in an ancestor folder. Else returns <b>Name</b>.
	/// Uses <see cref="FindRelative"/>.
	/// </summary>
	/// <param name="relativeTo">Search relative to this folder or to the parent folder of this file.</param>
	public string ItemPathOrName(FileNode relativeTo, FNFind kind = FNFind.Any) {
		if (relativeTo.FindRelative(true, _name, kind) == this) return _name;
		return ItemPath;
	}
	
	/// <summary>
	/// If is open (active or not), returns the <b>SciCode</b>, else null.
	/// </summary>
	public SciCode OpenDoc { get; internal set; }
	
	/// <summary>
	/// Returns Name.
	/// </summary>
	public override string ToString() => _name;
	
	///// <summary>
	///// Data used by code info classes.
	///// </summary>
	//public CiFileData ci;
	
	#endregion
	
	#region text
	
	/// <summary>
	/// Gets text from editor (if this is the active open document) or file (<see cref="GetFileText"/>).
	/// </summary>
	/// <param name="text">"" if failed (eg file not found) or is folder.</param>
	/// <param name="silent">Don't print warning when failed. If null, silent only if file not found.</param>
	/// <returns>(true, null) if got text or is folder. (false, error) if failed.</returns>
	public BoolError GetCurrentText(out string text, bool? silent = false) {
		if (this == _model.CurrentFile) { text = Panels.Editor.ActiveDoc.aaaText; return true; }
		return GetFileText(out text, silent);
	}
	
	/// <summary>
	/// Gets text from file.
	/// Does not get editor text like <see cref="GetCurrentText"/>.
	/// </summary>
	/// <param name="text">"" if failed (eg file not found) or is folder.</param>
	/// <param name="silent">Don't print warning when failed. If null, silent only if file not found.</param>
	/// <returns>(true, null) if got text or is folder. (false, error) if failed.</returns>
	public BoolError GetFileText(out string text, bool? silent = false) {
		text = "";
		if (IsFolder) return true;
		
		//rejected: cache text. OS caching isn't too slow.
		
		string path = FilePath, es = null;
		if (path == null) { //IsDeleted
			es = "Deleted.";
			path = "unknown";
		} else {
			try {
				using var sr = filesystem.waitIfLocked(() => new StreamReader(path));
				
				if (sr.BaseStream.Length > 100_000_000) es = "File too big, > 100_000_000.";
				else text = sr.ReadToEnd();
				
				//rejected: update _fileModTime. Would need to call OnAppActivatedAndThisIsOpen if changed.
				//var fs = (FileStream)sr.BaseStream;
				//if (fs.Length > 100_000_000) es = "File too big, > 100_000_000.";
				//else {
				//	text = sr.ReadToEnd();
				//	if (!silent) _fileModTime = Api.GetFileInformationByHandle(fs.SafeFileHandle.DangerousGetHandle(), out var fi) ? fi.ftLastWriteTime : 0;
				//}
			}
			catch (Exception ex) {
				bool notFound = ex is FileNotFoundException or DirectoryNotFoundException;
				Debug_.PrintIf(!notFound && silent == true, ex);
				if (notFound) silent ??= true;
				es = ex.ToStringWithoutStack();
			}
		}
		
		if (es == null) return true;
		es = $"Failed to get text of <open>{ItemPath}<>, file <explore>{path}<>\r\n\t{es}";
		if (silent != true) print.warning(es, -1);
		return new(false, es);
	}
	
	/// <summary>
	/// Loads text of any file like <see cref="GetFileText"/>.
	/// Thread-safe. Silent when file not found or too big.
	/// </summary>
	/// <param name="filePath">Full path, to pass directly to .NET <b>File</b> function.</param>
	/// <returns>null if failed or file size more than 100_000_000.</returns>
	public static string GetFileTextLL(string filePath) {
		//TODO3: option to load only text files. If unknown extension, try to load part and find \0.
		try {
			using var sr = filesystem.waitIfLocked(() => new StreamReader(filePath));
			if (sr.BaseStream.Length > 100_000_000) return null;
			return sr.ReadToEnd();
		}
		catch (Exception ex) {
			if (ex is not (FileNotFoundException or DirectoryNotFoundException)) print.warning(ex.ToStringWithoutStack(), -1);
		}
		return null;
	}
	
	long _fileModTime;
	
	//called when SciDoc loaded or saved the file
	internal void _UpdateFileModTime() {
		filesystem.GetTime_(FilePath, out _fileModTime);
	}
	
	internal void _CheckModifiedExternally(SciCode doc) {
		if (doc.EIsBinary) return;
		Debug_.PrintIf(_fileModTime == 0);
		if (!filesystem.GetTime_(FilePath, out var t) || t == _fileModTime) return;
		_fileModTime = t;
		doc.EFileModifiedExternally_(); //calls GetFileText
	}
	
	/// <summary>
	/// Replaces all specified text ranges with specified texts.
	/// If the file is open in editor, replaces it there; saves if it isn't the active document. Else replaces file text.
	/// </summary>
	/// <param name="text">Current text.</param>
	/// <param name="a">Text ranges and replacement texts. Must be sorted by range. Ranges must not overlap.</param>
	/// <returns>false if a is empty or failed to save.</returns>
	/// <param name="newText"></param>
	/// <exception cref="ArgumentException">Ranges are overlapped or not sorted. Only #if DEBUG.</exception>
	public bool ReplaceAllInText(string text, List<StartEndText> a, out string newText) {
		newText = null;
		if (a.Count > 0) {
			var doc = OpenDoc;
			if (doc != null) {
				Debug.Assert(!doc.aaaIsReadonly);
				StartEndText.ThrowIfNotSorted(a);
				
				using (doc.ENewUndoAction()) {
					for (int i = a.Count; --i >= 0;) {
						var (from, to, s) = a[i];
						doc.aaaNormalizeRange(true, ref from, ref to);
						if (CiStyling.IsProtected(doc, from, to)) continue; //hidden text (embedded image)
						doc.aaaReplaceRange(false, from, to, s);
					}
				}
				
				newText = doc.aaaText;
				if (doc != Panels.Editor.ActiveDoc) doc.ESaveText_(true);
				return true;
			} else {
				newText = StartEndText.ReplaceAll(text, a);
				try {
					SaveNewTextOfClosedFile(newText);
					return true;
				}
				catch (Exception e1) { print.warning($"Failed to save {SciLink()}. {e1.ToStringWithoutStack()}"); }
			}
		}
		return false;
	}
	
	/// <exception cref="Exception"></exception>
	public void SaveNewTextOfClosedFile(string text) {
		Debug.Assert(OpenDoc == null);
		if (DontSave) throw new AuException("This file should not be modified.");
		string path = FilePath;
		_model.FileOperation(FOSync.UserFileWrite, () => { filesystem.saveText(path, text); });
		_UpdateFileModTime();
		CodeInfo.FilesChanged();
	}
	
	/// <summary>
	/// true if is link to a file in folders.ThisAppBS + "Default" or "Templates".
	/// #if DEBUG, always returns false.
	/// </summary>
#if DEBUG
	public bool DontSave => false;
#else
	public bool DontSave => IsLink && FilePath is var s && s.Starts(folders.ThisAppBS) && 0 != s.Eq(folders.ThisAppBS.Length, true, @"Default\", @"Templates\");
#endif
	
	#endregion
	
	#region ITreeViewItem
	
	IEnumerable<ITreeViewItem> ITreeViewItem.Items => Children();
	
	/// <summary>
	/// Gets or sets expanded state.
	/// The setter sets to save later but does not update the control (for it use <see cref="KTreeView.Expand"/> instead, it calls the setter).
	/// </summary>
	public bool IsExpanded => _isExpanded;
	bool _isExpanded;
	
	public void SetIsExpanded(bool yes) { if (yes != _isExpanded) { _isExpanded = yes; _model.Save.StateLater(); } }
	
	string ITreeViewItem.DisplayText => DisplayName;
	
	void ITreeViewItem.SetNewText(string text) { FileRename(text); }
	
	public static string GetFileTypeImageSource(FNType ft, bool openFolder = false)
		=> ft switch {
			FNType.Script => App.Settings.icons.ft_script ?? EdIcons.Script,
			FNType.Class => App.Settings.icons.ft_class ?? EdIcons.Class,
			FNType.Folder => openFolder
				? App.Settings.icons.ft_folderOpen ?? EdIcons.FolderOpen
				: App.Settings.icons.ft_folder ?? EdIcons.Folder,
			_ => null
		};
	
	public object Image {
		get {
			var s = CustomIconName ?? (IsOtherFileType ? FilePath : GetFileTypeImageSource(FileType, _isExpanded));
			if (IsLink) return new object[] { s, "link:" };
			return s;
		}
	}
	
	int ITreeViewItem.Color(TVColorInfo ci) => ci.isTextBlack && !IsFolder && _model.OpenFiles.Contains(this) ? 0x1fafad2 : -1;
	
	int ITreeViewItem.TextColor(TVColorInfo ci) => _model.IsCut(this) ? 0xff0000 : -1;
	
	int ITreeViewItem.BorderColor(TVColorInfo ci) => this == _model.CurrentFile ? (ci.isTextBlack ? 0x1A0A0FF : 0xFF8000) : -1;
	
	#endregion
	
	#region tree view
	
	/// <summary>
	/// Unselects all and selects this. Ensures visible. Does not open document.
	/// If this is root, just unselects all.
	/// </summary>
	public void SelectSingle() {
		if (this == Root) TreeControl.UnselectAll();
		else if (!IsAlien) TreeControl.SelectSingle(this);
	}
	
	public bool IsSelected {
		get => TreeControl.IsSelected(this);
		set => TreeControl.Select(this, value);
	}
	
	/// <summary>
	/// Call this to update/redraw control row view when changed its data (text, image, checked, color, etc).
	/// Redraws only this control; to update all, call <see cref="FilesModel.Redraw"/> instead.
	/// </summary>
	public void UpdateControlRow() => TreeControl.Redraw(this);
	
	#endregion
	
	#region find, enum
	
	/// <summary>
	/// Finds descendant file or folder by name or @"\relative path".
	/// Returns null if not found; also if name is null/"".
	/// </summary>
	/// <param name="name">Name like "name.cs" or relative path like @"\name.cs" or @"\subfolder\name.cs".</param>
	/// <param name="kind"></param>
	public FileNode FindDescendant(string name, FNFind kind = FNFind.Any) {
		if (name.NE()) return null;
		if (name[0] == '\\') return _FindRelative(name, kind);
		return _FindIn(Descendants(), name, kind, true);
	}
	
	static FileNode _FindIn(IEnumerable<FileNode> e, RStr name, FNFind kind, bool preferFile) {
		FileNode folder = null;
		foreach (var f in e) {
			if (!name.Eqi(f._name)) continue;
			if (!FilesModel.KindFilter_(f, kind)) continue;
			if (preferFile && f.IsFolder) { folder ??= f; continue; }
			return f;
		}
		return folder;
	}
	
	FileNode _FindRelative(string name, FNFind kind, bool orAnywhere = false) {
		Model.FoundMultiple = null;
		bool retry = false; gRetry:
		int i = name.LastIndexOf('\\');
		var lastName = i < 0 ? name : name[(i + 1)..]; //never mind: allocation. To avoid allocation would need to enumerate without dictionary, and in big workspace it can be 100 times slower.
		if (_model._nameMap.MultiGet_(lastName, out FileNode single, out var multiple)) {
			if (multiple != null) {
				foreach (var f in multiple) if (_KindOk(f) && _PathOk(f)) return f;
				if (orAnywhere && i < 0) { //try to find single descendant in this folder or in an ancestor folder
					for (var p = this; p.HasParent; p = p.Parent) {
						FileNode found = null;
						foreach (var f in multiple) if (_KindOk(f) && p.IsAncestorOf(f)) { if (found == null) found = f; else goto gMulti; }
						if (found != null) return found;
					}
					gMulti:
					Model.FoundMultiple = multiple;
				}
			} else if (_KindOk(single)) {
				if ((orAnywhere && i < 0) || _PathOk(single)) return single;
			}
		}
		if (!retry) {
			retry = kind is FNFind.CodeFile or FNFind.Class ? !lastName.Ends(".cs", true) : kind is FNFind.Folder ? false : !lastName.Contains('.');
			if (retry) { name += ".cs"; goto gRetry; }
		}
		return null;
		
		bool _KindOk(FileNode f) => FilesModel.KindFilter_(f, kind);
		
		bool _PathOk(FileNode f) {
			f = f.Parent;
			for (int j = i; j > 0 && f != null; f = f.Parent) {
				int k = name.LastIndexOf('\\', j - 1);
				if (!name.Eq((k + 1)..j, f.Name ?? "", true)) return false;
				j = k;
			}
			return f == this;
		}
	}
	
	/// <summary>
	/// Finds file or folder by name or path relative to: this folder, parent folder (if this is file) or root (if relativePath starts with @"\").
	/// Returns null if not found; also if name is null/"".
	/// </summary>
	/// <param name="relativePath">Examples: "name.cs", @"subfolder\name.cs", @".\subfolder\name.cs", @"..\parent\name.cs", @"\root path\name.cs".</param>
	/// <param name="kind"></param>
	/// <param name="orAnywhere">If <i>relativePath</i> is filename and does not exist in this folder: if single such file exists anywhere or in subfolders or in an ancestor folder, return that file.</param>
	public FileNode FindRelative(bool orAnywhere, string relativePath, FNFind kind = FNFind.Any) {
		if (!IsFolder) return Parent.FindRelative(orAnywhere, relativePath, kind);
		var s = relativePath;
		if (s.NE()) return null;
		FileNode p = this;
		if (s[0] == '\\') p = Root;
		else if (s[0] == '.') {
			int i = 0;
			for (; s.Eq(i, @"..\"); i += 3) { p = p.Parent; if (p == null) return null; }
			if (i == 0 && s.Starts(@".\")) i = 2;
			if (i != 0) {
				if (i == s.Length) return (p == Root || !(kind is FNFind.Any or FNFind.Folder)) ? null : p;
				s = s[i..];
			}
			orAnywhere = false;
		}
		return p._FindRelative(s, kind, orAnywhere);
	}
	
	/// <summary>
	/// Finds all descendant files (and not folders) that have the specified name.
	/// Returns empty array if not found.
	/// </summary>
	/// <param name="name">File name. If starts with backslash, works like <see cref="FindDescendant"/>.</param>
	public FileNode[] FindAllDescendantFiles(string name) {
		if (!name.NE()) {
			if (name[0] == '\\') {
				var f1 = _FindRelative(name, FNFind.File);
				if (f1 != null) return [f1];
			} else {
				return Descendants().Where(k => !k.IsFolder && k._name.Eqi(name)).ToArray();
			}
		}
		return [];
	}
	
	/// <summary>
	/// Gets all descendant nodes, except descendants of folders named "Garbage".
	/// </summary>
	public IEnumerable<FileNode> DescendantsExceptGarbage() {
		int level = 0;
		foreach (var f in Descendants()) {
			if (level == 0) {
				if (f.IsFolder) if (f.Name.Eqi("Garbage")) level = f.Level;
			} else {
				if (f.Level > level) continue;
				level = 0;
			}
			yield return f;
		}
	}
	
	/// <summary>
	/// Finds ancestor (including self) project folder and its main file.
	/// </summary>
	/// <returns>true if this is in a project folder and found its main file.</returns>
	/// <param name="folder">If the function returns true, receives the project folder, else null.</param>
	/// <param name="main">If the function returns true, receives the project-main file, else null.</param>
	/// <param name="ofAnyScript">Get project even if this is a non-main script in project folder.</param>
	public bool FindProject(out FileNode folder, out FileNode main, bool ofAnyScript = false) {
		for (FileNode r = Root, f = IsFolder ? this : Parent; f != r && f != null; f = f.Parent) {
			if (!f.IsProjectFolder(out var fm)) continue;
			if (this.IsScript && this != fm && !ofAnyScript) break; //non-main scripts are not part of project
			main = fm;
			folder = f;
			return true;
		}
		folder = main = null;
		return false;
	}
	//CONSIDER: multiscript project. Each script in it is compiled together with cs files.
	
	/// <summary>
	/// If this is in a project, returns the project-main file. Else returns this.
	/// This must be a code file (asserts).
	/// </summary>
	/// <param name="ofAnyScript">Get project even if this is a non-main script in project folder.</param>
	public FileNode GetProjectMainOrThis(bool ofAnyScript = false) {
		Debug.Assert(IsCodeFile);
		return FindProject(out _, out var pm, ofAnyScript) ? pm : this;
	}
	
	//public FileNode GetProjectMainOrThis
	
	/// <summary>
	/// Returns true if this is a folder and Name starts with '@' and contains main code file.
	/// </summary>
	/// <param name="main">Receives the main code file. It is the first direct child code file.</param>
	public bool IsProjectFolder(out FileNode main) {
		main = null;
		if (IsFolder && _name[0] == '@') {
			for (var f = FirstChild; f != null; f = f.Next) {
				if (f.IsCodeFile) { main = f; return true; }
			}
		}
		return false;
	}
	
	public IEnumerable<FileNode> EnumProjectClassFiles(FileNode fSkip = null) {
		foreach (var f in Descendants()) {
			if (f._type == FNType.Class && f != fSkip) yield return f;
		}
	}
	
	/// <summary>
	/// Gets class file role from metacomments.
	/// Note: can be slow, because loads file text if this is a class file.
	/// </summary>
	/// <param name="preferApp">If it's a test-runnable class file, return <b>App</b> instead of <b>Class</b>.</param>
	public FNClassFileRole GetClassFileRole(bool preferApp = false) {
		if (_type != FNType.Class) return FNClassFileRole.None;
		var r = FNClassFileRole.Class;
		if (GetCurrentText(out var code, silent: null)) {
			var meta = MetaComments.FindMetaComments(code);
			if (meta.end > 0) {
				int i = -1;
				bool findDefineTest = false;
				foreach (var v in MetaComments.EnumOptions(code, meta)) {
					i++;
					if (findDefineTest) {
						if (v.NameIs("define")) return FNClassFileRole.Class;
					} else {
						if (!v.NameIs("role")) continue;
						if (v.ValueIs("classLibrary")) return FNClassFileRole.Library;
						if (v.ValueIs("classFile")) break;
						r = FNClassFileRole.App;
						if (!preferApp) if (findDefineTest = i == 0) continue; //maybe using feature "test-run without a test script", eg `/*/ role miniProgram; define TEST; /*/ ... #if TEST ...`
						break;
					}
				}
			}
		}
		return r;
	}
	
	/// <summary>
	/// Returns true if this is a code file that can be executed directly (not via project main or test script).
	/// </summary>
	public bool IsExecutableDirectly() {
		if (!IsCodeFile) return false;
		if (IsClass) {
			if (GetProjectMainOrThis() != this) return false;
			if (GetClassFileRole(preferApp: true) != FNClassFileRole.App) return false;
		}
		return true;
	}
	
	#endregion
	
	#region new item
	
	public static string CreateNameUniqueInFolder(FileNode folder, string fromName, bool forFolder, bool autoGenerated = false, bool moving = false, FileNode renaming = null) {
		bool isGlobal = !forFolder && !moving && fromName.Eqi("global.cs");
		if (isGlobal) {
			if (null == folder.Model.FindGlobalCs(silent: true)) return fromName;
		} else {
			if (!_Exists(fromName)) return fromName;
		}
		
		string oldName = fromName, ext = null;
		if (!forFolder) {
			int i = fromName.LastIndexOf('.');
			if (i >= 0) { ext = fromName[i..]; fromName = fromName[..i]; }
		}
		fromName = fromName.RxReplace(@"\d+$", "");
		for (int i = 2; ; i++) {
			var s = fromName + i + ext;
			if (!_Exists(s)) {
				if (!autoGenerated) print.it($"Info: name \"{oldName}\" has been changed to \"{s}\"{(isGlobal ? null : ", to make it unique in the folder")}.");
				return s;
			}
		}
		
		bool _Exists(string s) {
			var f = _FindIn(folder.Children(), s, FNFind.Any, false);
			if (f != null) return f != renaming;
			if (filesystem.exists(folder.FilePath + "\\" + s)) return true; //orphaned file?
			return false;
		}
	}
	
	public static class Templates {
		public static readonly string DefaultDirBS = folders.ThisAppBS + @"Templates\files\";
		public static readonly string UserDirBS = AppSettings.DirBS + @"Templates\";
		
		public static string FileName(ETempl templ) => templ switch { ETempl.Class => "Class.cs", _ => "Script.cs" };
		
		public static string FilePathRaw(ETempl templ, bool user) => (user ? UserDirBS : DefaultDirBS) + FileName(templ);
		
		public static string FilePathReal(ETempl templ, bool? user = null) {
			bool u = user ?? ((ETempl)App.Settings.templ_use).Has(templ);
			var file = FilePathRaw(templ, u);
			if (u && !filesystem.exists(file, true)) file = FilePathRaw(templ, false);
			return file;
		}
		
		public static string Load(ETempl templ, bool? user = null) {
			return filesystem.loadText(FilePathReal(templ, user));
		}
		
		public static bool IsStandardTemplateName(string template, out ETempl result, bool ends = false) {
			int i = ends ? template.Ends(false, s_names) : template.Eq(false, s_names);
			if (i-- == 0) { result = 0; return false; }
			result = (ETempl)(1 << i);
			return true;
		}
		
		readonly static string[] s_names = { "Script.cs", "Class.cs" };
		
		/// <summary>
		/// Loads Templates\files.xml and optionally finds a template in it.
		/// Returns null if template not found. Exception if fails to load file.
		/// Uses caching to avoid loading file each time, but reloads if file modified; don't modify the XML DOM.
		/// </summary>
		/// <param name="template">null or relative path of template in Templates\files. Case-insensitive.</param>
		public static XElement LoadXml(string template = null) {
			//load files.xml first time, or reload if file modified
			filesystem.GetTime_(s_xmlFilePath, out var time);
			if (s_xml == null || time != s_xmlFileTime) {
				s_xml = XmlUtil.LoadElem(s_xmlFilePath);
				s_xmlFileTime = time;
			}
			
			var x = s_xml;
			if (template != null) {
				var a = template.Split('\\');
				for (int i = 0; i < a.Length; i++) x = x?.Elem(i < a.Length - 1 ? "d" : null, "n", a[i], ignoreCase: true);
				Debug.Assert(x != null);
			}
			return x;
		}
		static XElement s_xml;
		static readonly string s_xmlFilePath = folders.ThisAppBS + @"Templates\files.xml";
		static long s_xmlFileTime;
		
		public static bool IsInDefault(XElement x) => x.Ancestors().Any(o => o.Attr("n") == "Default");
	}
	
	[Flags]
	public enum ETempl { Script = 1, Class = 2 }
	
	#endregion
	
	#region rename, move, copy
	
	/// <summary>
	/// Changes Name of this object and renames its file (if not link).
	/// Returns false if name is empty or fails to rename its file.
	/// </summary>
	/// <param name="name">
	/// Name, like "New name.cs" or "New name".
	/// If not folder, adds previous extension if no extension or changed code file extension.
	/// If invalid filename, replaces invalid characters etc.
	/// </param>
	/// <param name="syncing">Called by the filesystem sync. The filesystem file is renamed. Need just to set item name and update everything.</param>
	public bool FileRename(string name, bool syncing = false) {
		if (syncing) {
			_SetName(name);
		} else {
			name = pathname.correctName(name);
			if (!IsFolder) {
				var ext = FileExt;
				if (ext.Length > 0) if (name.IndexOf('.') < 0 || (IsCodeFile && !name.Ends(ext, true))) name += ext;
			}
			if (name == _name) return true;
			name = CreateNameUniqueInFolder(Parent, name, IsFolder, renaming: this);
			
			if (!RenameL_(name)) return false;
		}
		
		if (IsFolder) _model.ChangedFolderItemPath_();
		_model.Save.WorkspaceAsync();
		FilesModel.Redraw(this, remeasure: true, renamed: true);
		Compiler.Uncache(this, andDescendants: true);
		CodeInfo.FilesChanged();
		return true;
	}
	
	internal bool RenameL_(string name) {
		if (!IsLink) {
			if (!_model.TryFileOperation(FOSync.UserFileOp, () => filesystem.rename(FilePath, name, FIfExists.Fail))) return false;
		}
		_SetName(name);
		return true;
		
		//CONSIDER: when renaming or moving, search all code files (except in "Garbage*" folders) and replace the old name or path in strings.
		//	Also doc the garbage folders feature.
	}
	
	/// <summary>
	/// Returns true if can move the tree node into the specified position.
	/// For example, cannot move parent into child etc.
	/// Does not check whether can move the file.
	/// </summary>
	public bool CanMove(FNInsertPos ipos) {
		//cannot move into self or descendants
		if (ipos.f == this || ipos.f.IsDescendantOf(this)) return false;
		
		//cannot move into a non-folder or before/after self
		switch (ipos.pos) {
		case FNInsert.Before:
			if (Next == ipos.f) return false;
			break;
		case FNInsert.After:
			if (Previous == ipos.f) return false;
			break;
		default: //inside
			if (!ipos.f.IsFolder) return false;
			break;
		}
		return true;
	}
	
	/// <summary>
	/// Moves this into, before or after target.
	/// Also moves file if need.
	/// </summary>
	/// <param name="ipos">If f null, uses Root, Last.</param>
	public bool FileMove(FNInsertPos ipos) {
		if (ipos.f == null) ipos = new(Root, FNInsert.Last);
		if (!CanMove(ipos)) return false;
		
		var newParent = ipos.ParentFolder;
		if (newParent != Parent) {
			var name = CreateNameUniqueInFolder(newParent, _name, IsFolder, moving: true);
			
			if (!IsLink) {
				string path2 = newParent.FilePath + "\\" + name;
				if (!_model.TryFileOperation(FOSync.UserFileOp, () => filesystem.move(FilePath, path2, FIfExists.Fail))) return false;
			}
			
			if (name != _name) _SetName(name);
		}
		
		//move tree node
		Remove();
		Common_MoveCopyNew(ipos, true);
		
		return true;
	}
	
	public void Common_MoveCopyNew(FNInsertPos ipos, bool moving) {
		AddToTree(ipos);
		_model.Save.WorkspaceAsync();
		if (moving) {
			if (IsFolder) _model.ChangedFolderItemPath_();
			Compiler.Uncache(this, andDescendants: true);
		}
		CodeInfo.FilesChanged();
	}
	
	/// <summary>
	/// Adds this to the tree, updates control, optionally sets to save workspace.
	/// </summary>
	public void AddToTree(FNInsertPos ipos) {
		if (ipos.Inside) ipos.f.AddChild(this, first: ipos.pos == FNInsert.First); else ipos.f.AddSibling(this, after: ipos.pos == FNInsert.After);
		_model.UpdateControlItems();
	}
	
	/// <summary>
	/// Copies this into, before or after target.
	/// Also copies file if need.
	/// Returns the copy, or null if fails.
	/// </summary>
	/// <param name="ipos">If f null, uses Root, Last.</param>
	/// <param name="model">Copy into this FileModel. It is != _model when importing workspace.</param>
	/// <param name="copyLinkTarget">For links, copy the link target into the workspace.</param>
	internal FileNode _FileCopy(FNInsertPos ipos, FilesModel model, bool copyLinkTarget = false) {
		_model.Save?.TextNowIfNeed(onlyText: true);
		if (ipos.f == null) ipos = new(Root, FNInsert.Last);
		
		//create unique name
		var newParent = ipos.ParentFolder;
		string name = CreateNameUniqueInFolder(newParent, _name, IsFolder);
		
		//copy file or directory
		if (!IsLink || copyLinkTarget) {
			string path2 = newParent.FilePath + "\\" + name;
			if (!_model.TryFileOperation(FOSync.UserFileOp, () => filesystem.copy(FilePath, path2, FIfExists.Fail))) return null;
		}
		
		//create new FileNode with descendants
		var f = new FileNode(model, this, name);
		if (copyLinkTarget) f._linkTarget = null;
		_CopyChildren(this, f);
		
		void _CopyChildren(FileNode from, FileNode to) {
			if (!from.IsFolder) return;
			foreach (var v in from.Children()) {
				var t = new FileNode(model, v, v._name);
				to.AddChild(t);
				_CopyChildren(v, t);
			}
		}
		
		//insert at the specified place and set to save
		f.Common_MoveCopyNew(ipos, false);
		return f;
	}
	
	#endregion
	
	#region util
	
	//public bool ContainsName(string name, bool printInfo = false) {
	//	if (null == _FindIn(Children(), name, null, false)) return false;
	//	if (printInfo) print.it(name + " exists in this folder.");
	//	return true;
	//}
	
	/// <summary>
	/// Gets file type from XML tag which should be "d", "s", "c" or "n".
	/// If none, throws ArgumentException if canThrow, else returns FNType.Other.
	/// </summary>
	public static FNType XmlTagToFileType(string tag, bool canThrow) => tag switch {
		"d" => FNType.Folder,
		"s" => FNType.Script,
		"c" => FNType.Class,
		"n" => FNType.Other,
		_ => !canThrow ? FNType.Other : throw new ArgumentException("XML element name must be 'd', 's', 'c' or 'n'")
	};
	
	/// <summary>
	/// Detects file type from extension and code.
	/// If .cs, returns Class or Script, else Other.
	/// Must be not folder.
	/// </summary>
	static FNType _DetectFileType(string path) {
		var type = FNType.Other;
		if (path.Ends(".cs", true)) {
			type = FNType.Class;
			try {
				var code = filesystem.loadText(path);
				if (CiUtil.IsScript(code)) type = FNType.Script;
			}
			catch (Exception ex) { Debug_.Print(ex); }
		}
		return type;
	}
	
	#endregion
}


================================================
FILE: Au.Editor/Files/Files+.cs
================================================
using System.Windows;
using System.Windows.Controls;
using Au.Controls;

namespace LA;

/// <summary>
/// File type of a <see cref="FileNode"/>.
/// Saved in XML as tag name: d folder, s script, c class, n other.
/// </summary>
enum FNType : byte {
	Folder, //must be 0
	Script,
	Class,
	Other,
}

enum FNInsert { Last, First, Before, After }

record struct FNInsertPos(FileNode f, FNInsert pos) {
	public bool Inside => pos is FNInsert.First or FNInsert.Last;
	public FileNode ParentFolder => Inside ? f : f.Parent;
}

enum FNFind {
	Any, File, Folder, CodeFile, Class/*, Script*/ //Script not useful because class files can be executable too
}

enum FNClassFileRole {
	/// <summary>Not a class file.</summary>
	None,
	/// <summary>Has meta role miniProgram/exeProgram/editorExtension.</summary>
	App,
	/// <summary>Has meta role classLibrary.</summary>
	Library,
	/// <summary>Has meta role classFile, or no meta role.</summary>
	Class,
}

class NewFileText {
	public bool replaceTemplate;
	public string text, meta;
	
	public NewFileText() { }
	
	public NewFileText(bool replaceTemplate, string text, string meta = null) {
		this.replaceTemplate = replaceTemplate;
		this.text = text;
		this.meta = meta;
	}
}

class DNewWorkspace : KDialogWindow {
	string _name, _location;
	public string ResultPath { get; private set; }
	
	public DNewWorkspace(string name, string location) {
		_name = name;
		_location = location;
		
		Title = "New workspace";
		
		var b = new wpfBuilder(this).WinSize(600);
		TextBox tName, tLocation = null;
		b.R.Add("Folder name", out tName, _name).Validation(_Validate).Focus();
		b.R.Add("Parent folder", out tLocation, _location).Validation(_Validate);
		b.R.AddButton("Browse...", _Browse).Width(70, "L");
		b.R.AddOkCancel();
		b.End();
		
		void _Browse(WBButtonClickArgs e) {
			var d = new FileOpenSaveDialog("{4D1F3AFB-DA1A-45AC-8C12-41DDA5C51CDA}") {
				InitFolderNow = filesystem.exists(tLocation.Text).Directory ? tLocation.Text : folders.ThisAppDocuments,
			};
			if (d.ShowOpen(out string s, this, selectFolder: true)) tLocation.Text = s;
		}
		
		string _Validate(FrameworkElement e) {
			var s = (e as TextBox).Text.Trim();
			if (e == tLocation) {
				if (!filesystem.exists(s).Directory) return "Folder does not exist";
			} else {
				if (pathname.isInvalidName(s) || s[0] is '.' or '_') return "Invalid filename";
				ResultPath = pathname.combine(tLocation.Text, s); //validation is when OK clicked
				if (filesystem.exists(ResultPath)) return s + " already exists";
			}
			return null;
		}
		
		//b.OkApply += e => {
		//	print.it(ResultPath); e.Cancel = true;
		//};
	}
}

class RepairWorkspace {
	const int c_markerInfo = 0;
	
	public static void Repair() {
		var rootFolder = App.Model.Root;
		
		using var workingState = Panels.Found.Prepare(PanelFound.Found.Repair, "Repair", out var b);
		if (workingState.NeedToInitControl) {
			var k = workingState.Scintilla;
			k.aaaMarkerDefine(c_markerInfo, Sci.SC_MARK_BACKGROUND, backColor: 0xEEE8AA);
		}
		
		//broken links
		
		b.Marker(c_markerInfo).Text("Broken links (missing target). You may want to delete them from the Files panel.").NL();
		var links = rootFolder.Descendants().Where(o => o.IsLink && !filesystem.exists(o.FilePath)).ToArray();
		if (links.Length > 0) {
			foreach (var f in links) {
				b.NL().Link(f, f.ItemPath); if (f.IsFolder) b.Text(" (folder)");
				b.Text(" -> ").Text(f.FilePath);
			}
			b.NL();
		} else {
			b.Text("\r\nNone.\r\n");
		}
		
		//biggest files
		
		b.NL().Marker(c_markerInfo).Text("Big files. You may want to delete some files if not used. Size in KB.").NL();
		List<(long size, FileNode f)> biggest = new();
		_Biggest(rootFolder);
		void _Biggest(FileNode folder) {
			foreach (var f in folder.Children()) {
				if (f.IsLink) continue;
				if (f.IsFolder) {
					_Biggest(f);
				} else if (filesystem.GetProp_(f.FilePath, out var p) && p.size >= 50 * 1024) {
					biggest.Add((p.size, f));
				}
			}
		}
		if (biggest.Any()) {
			foreach (var (size, f) in biggest.OrderByDescending(o => o.size)) {
				b.NL().Text($"{size / 1024} ").Link(f, f.ItemPath);
			}
		} else {
			b.Text("\r\nNone.\r\n");
		}
		
		//--------------
		
		Panels.Found.SetResults(workingState, b);
	}
}


================================================
FILE: Au.Editor/Files/FilesModel.cs
================================================
//TODO2: idea: in each directory auto-create-update a hidden file containing a copy of files.xml branch for that directory. Benefits:
//	Could recreate the ordering etc when the folder imported into another workspace.
//	Could recreate deleted or corrupt files.xml.

using System.Xml.Linq;
using System.IO.Compression;
using System.Windows.Input;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Controls.Primitives;
using System.Windows.Media;
using Au.Controls;

namespace LA;

using static Menus.File;

partial class FilesModel {
	public readonly FileNode Root;
	public readonly int WorkspaceSN; //sequence number of workspace opened in this process: 1, 2...
	static int s_workspaceSN;
	public readonly string WorkspaceName;
	public readonly string WorkspaceDirectory;
	public readonly string WorkspaceFile; //.xml file containing the tree of .cs etc files
	public readonly string FilesDirectory; //.cs etc files
	public readonly string TempDirectory; //any temporary files
	public readonly string NugetDirectory; //NuGet libraries
	public readonly string NugetDirectoryBS; //NugetDirectory\
	public readonly string DllDirectory; //user-created or downloaded libraries
	public readonly string DllDirectoryBS; //LibrariesDirectory\
	public readonly AutoSave Save;
	readonly Dictionary<uint, FileNode> _idMap;
	internal readonly Dictionary<string, object> _nameMap;
	public readonly WorkspaceSettings WSSett;
	public readonly WorkspaceState State;
	readonly bool _importing;
	readonly bool _initedFully;
	internal object CompilerContext_;
	internal IDisposable UndoContext_;
	//internal event Action<bool> TreeLoaded_;
	
	/// <param name="file">Path of workspace tree file (files.xml).</param>
	/// <exception cref="ArgumentException">Invalid or not full path.</exception>
	/// <exception cref="Exception">XElement.Load exceptions. And possibly more.</exception>
	public FilesModel(string file, bool importing) {
		_importing = importing;
		WorkspaceFile = pathname.normalize(file);
		WorkspaceDirectory = pathname.getDirectory(WorkspaceFile);
		WorkspaceName = pathname.getName(WorkspaceDirectory);
		FilesDirectory = WorkspaceDirectory + @"\files";
		//CacheDirectory = WorkspaceDirectory + @"\.cache";
		TempDirectory = WorkspaceDirectory + @"\.temp";
		NugetDirectory = WorkspaceDirectory + @"\.nuget";
		NugetDirectoryBS = NugetDirectory + @"\";
		DllDirectory = WorkspaceDirectory + @"\dll";
		DllDirectoryBS = DllDirectory + @"\";
		//ExeDirectory = WorkspaceDirectory + @"\exe";
		if (!_importing) {
			WorkspaceSN = ++s_workspaceSN;
			filesystem.createDirectory(FilesDirectory);
			Save = new AutoSave(this);
		}
		_idMap = new();
		_nameMap = new(StringComparer.OrdinalIgnoreCase);
		
		Root = FileNode.LoadWorkspace(WorkspaceFile, this); //recursively creates whole model tree; caller handles exceptions
		
		List<FileNode> bad = null;
		foreach (var f in Root.Descendants()) {
			uint id = f.Id;
			if (id == 0 || !_idMap.TryAdd(id, f)) (bad ??= new()).Add(f); //missing or duplicate id in xml file
			else f._WorkspaceLoaded(id, _importing);
		}
		if (bad != null) {
			foreach (var f in bad) {
				if (!_importing) print.warning($"Invalid id of {f.SciLink(true)}. Creating new.");
				f._WorkspaceLoaded(AddGetId(f), _importing);
			}
			if (!_importing) {
				filesystem.delete(WorkspaceDirectory + @"\.compiled", FDFlags.CanFail);
				Save.WorkspaceAsync();
			}
		}
		
		//TreeLoaded_?.Invoke(_importing);
		
		if (!_importing) {
			WSSett = WorkspaceSettings.Load(WorkspaceDirectory + @"\settings.json");
			State = new WorkspaceState(this);
			folders.Workspace = new FolderPath(WorkspaceDirectory);
			Environment.SetEnvironmentVariable("dll", DllDirectory);
			
			var dirDel = TempDirectory + @"\delete";
			if (filesystem.exists(dirDel, true)) filesystem.delete(dirDel, FDFlags.CanFail);
		}
		_initedFully = true;
	}
	
	public void Dispose() {
		if (_importing) return;
		if (_initedFully) {
			App.Tasks.OnWorkspaceClosed();
			RecentTT.Clear();
			//Save.AllNowIfNeed(); //owner FilesPanel calls this before calling this func. Because may need more code in between.
		}
		Save?.Dispose();
		State?.Dispose();
		UndoContext_?.Dispose();
		_syncWatchers?.Dispose();
		WSSett?.Dispose();
		EditGoBack.DisableUI();
	}
	
	#region tree control
	
	public static FilesView TreeControl => Panels.Files?.TreeControl;
	
	/// <summary>
	/// Updates control when changed number or order of visible items (added, removed, moved, etc).
	/// </summary>
	public void UpdateControlItems() { TreeControl.SetItems(Root.Children(), true); }
	
	/// <summary>
	/// When need to redraw an item in controls that display it.
	/// If the parameter is null, redraw all items.
	/// </summary>
	public static event Action<RedrawEventData> NeedRedraw;
	
	public record class RedrawEventData(FileNode f, bool remeasure, bool renamed);
	
	/// <summary>
	/// Raises <see cref="NeedRedraw"/> event.
	/// </summary>
	public static void Redraw(FileNode f = null, bool remeasure = false, bool renamed = false) {
		NeedRedraw?.Invoke(new(f, remeasure, renamed));
	}
	
	#endregion
	
	#region load workspace
	
	public static void LoadWorkspace(string wsDir = null) {
		wsDir ??= App.Settings.workspace;
		if (wsDir.NE()) wsDir = folders.ThisAppDocuments + "Main"; else wsDir = pathname.normalize(wsDir);
		
		var xmlFile = wsDir + @"\files.xml";
		var oldModel = App.Model;
		FilesModel m = null;
		g1:
		try {
			//TODO3: if editor runs as admin, the workspace directory should be write-protected from non-admin processes.
			
			if (s_isNewWorkspace = !filesystem.exists(xmlFile).File) {
				filesystem.copy(folders.ThisAppBS + @"Default\Workspace", wsDir);
			}
			
			oldModel?.UnloadingWorkspace_(); //saves all, closes documents, sets current file = null
			
			m = new FilesModel(xmlFile, importing: false);
		}
		catch (Exception ex) {
			m?.Dispose();
			m = null;
			//print.it($"Failed to load '{wsDir}'. {ex.Message}");
			switch (dialog.showError("Failed to load workspace", wsDir,
				"1 Retry|2 Load another|3 Create new|0 Cancel",
				owner: TreeControl, expandedText: ex.ToString())) {
			case 1: goto g1;
			case 2: OpenWorkspaceUI(); break;
			case 3: NewWorkspaceUI(); break;
			}
			if (App.Model == null) Environment.Exit(1);
			return;
		}
		
		oldModel?.Dispose();
		App.Model = m;
		
		//this code is important for portable
		filesystem.more.getFinalPath(wsDir, out wsDir);
		filesystem.more.getFinalPath(folders.ThisAppDocuments, out var tad);
		var unexpanded = folders.unexpandPath(wsDir, (tad, "%folders.ThisAppDocuments%"));
		
		if (unexpanded != App.Settings.workspace) {
			if (App.Settings.workspace != null) {
				string[] ar = App.Settings.recentWS ?? [];
				int i = Array.IndexOf(ar, unexpanded);
				if (i < 0) i = Array.IndexOf(ar, wsDir);
				if (i >= 0) ar = ar.RemoveAt(i);
				App.Settings.recentWS = ar.InsertAt(0, App.Settings.workspace);
			}
			App.Settings.workspace = unexpanded;
		}
		
		if (App.Loaded == AppState.LoadedUI) m.WorkspaceLoadedWithUI(onUiLoaded: false);
	}
	
	[MethodImpl(MethodImplOptions.NoInlining)] //avoid loading WPF at startup before loading UI
	public void WorkspaceLoadedWithUI(bool onUiLoaded) {
		if (!s_isNewWorkspace) LoadState(expandFolders: true);
		TreeControl.SetItems();
		if (s_isNewWorkspace) {
			s_isNewWorkspace = false;
			AddMissingDefaultFiles(true, true);
			SetCurrentFile(Root.FirstChild, newFile: true);
		} else {
			LoadState(openFiles: true);
			App.Dispatcher.InvokeAsync(() => { SyncWithFilesystem_(); });
		}
		ThisWorkspaceLoadedAndDocumentsOpened?.Invoke();
		AnyWorkspaceLoadedAndDocumentsOpened?.Invoke();
		if (!onUiLoaded) RunStartupScripts(true);
	}
	
	static bool s_isNewWorkspace;
	
	public event Action ThisWorkspaceLoadedAndDocumentsOpened;
	public static event Action AnyWorkspaceLoadedAndDocumentsOpened;
	
	/// <summary>
	/// Shows "Open workspace" dialog. On OK loads the selected workspace.
	/// </summary>
	public static void OpenWorkspaceUI() {
		var d = new FileOpenSaveDialog("{4D1F3AFB-DA1A-45AC-8C12-41DDA5C51CDA}") { Title = "Open workspace" };
		if (!d.ShowOpen(out string s, App.Hmain, selectFolder: true)) return;
		if (!filesystem.exists(s + @"\files.xml").File) dialog.showError(null, "The folder must contain file files.xml", owner: TreeControl);
		else LoadWorkspace(s);
	}
	
	/// <summary>
	/// Shows dialog to create new workspace. On OK creates and loads new workspace.
	/// </summary>
	public static void NewWorkspaceUI() {
		var path = GetDirectoryPathForNewWorkspace();
		if (path != null) LoadWorkspace(path);
	}
	
	#endregion
	
	#region find, id
	
	/// <summary>
	/// Finds file or folder by name or @"\relative path" or id or full path.
	/// </summary>
	/// <param name="name">
	/// Can be:
	/// Name, like "name.cs" or just "name".
	/// Relative path like @"\name.cs" or @"\subfolder\name.cs".
	/// Full path in this workspace or of a linked external file.
	/// :id - <see cref="FileNode.IdString"/> with prefix ":", or <see cref="FileNode.IdStringWithWorkspace"/>; can be followed by any text.
	/// 
	/// Case-insensitive.
	/// If just "name" and not found and name does not end with ".cs", tries to find name + ".cs".
	/// </param>
	/// <param name="kind">Ignored if <i>name</i> is id.</param>
	/// <param name="silent">Don't print warning "Found multiple...".</param>
	public FileNode Find(string name, FNFind kind = FNFind.Any, bool silent = false) {
		FoundMultiple = null;
		if (name.NE()) return null;
		if (name[0] == ':') {
			name.ToInt(out long id, 1);
			return FindById(id);
		}
		if (pathname.isFullPath(name)) return FindByFilePath(name, kind);
		if (name[0] == '\\') return Root.FindDescendant(name, kind);
		return _FindByName(name, kind);
		
		FileNode _FindByName(string name, FNFind kind) {
			if (_nameMap.MultiGet_(name, out FileNode v, out var a)) {
				if (v != null) return KindFilter_(v, kind) ? v : null;
				FileNode first = null;
				foreach (var f in a) {
					if (!KindFilter_(f, kind)) continue;
					if (first == null) first = f; else (FoundMultiple ??= new() { first }).Add(f);
				}
				if (FoundMultiple == null) return first; //note: don't return the first if found multiple. Unsafe.
				if (!silent) {
					var paths = string.Join(", ", FoundMultiple.Select(o => o.SciLink(path: true)));
					print.warning($"Found multiple '{name}'. Use path if possible, or rename.\r\n\tPaths: {paths}."/*, -1*/);
				}
				return null;
			}
			if (kind != FNFind.Folder && !name.Ends(".cs", true)) return _FindByName(name + ".cs", kind);
			return null;
		}
	}
	
	/// <summary>
	/// When <see cref="Find"/> returns null because exists multiple items with the specified name/kind, this property contains them. Else null.
	/// </summary>
	public List<FileNode> FoundMultiple;
	
	internal static bool KindFilter_(FileNode f, FNFind kind) => kind switch {
		FNFind.File => !f.IsFolder,
		FNFind.Folder => f.IsFolder,
		FNFind.CodeFile => f.IsCodeFile,
		FNFind.Class => f.IsClass,
		//FNFind.Script => f.IsScript,
		_ => true, //FNFind.Any
	};
	
	/// <summary>
	/// Calls <see cref="Find(string, FNFind, bool)"/>(name, FNFind.CodeFile).
	/// </summary>
	/// <inheritdoc cref="Find(string, FNFind, bool)"/>
	public FileNode FindCodeFile(string name, bool silent = false) => Find(name, FNFind.CodeFile, silent);
	
	/// <summary>
	/// Finds file or folder by its file path (<see cref="FileNode.FilePath"/>).
	/// </summary>
	/// <param name="path">Full path of a file in this workspace or of a linked external file.</param>
	/// <param name="kind"></param>
	public FileNode FindByFilePath(string path, FNFind kind = FNFind.Any) {
		var d = FilesDirectory;
		if (path.PathStarts(d)) return Root.FindDescendant(path[d.Length..], kind); //is in workspace folder
		
		foreach (var f in Root.Descendants()) {
			if (f.IsLink) {
				if (path.Eqi(f.LinkTarget)) return KindFilter_(f, kind) ? f : null;
				if (f.IsFolder) {
					d = f.LinkTarget;
					if (path.PathStarts(d)) return f.FindDescendant(path[d.Length..], kind);
				}
			}
		}
		return null;
	}
	
	///// <summary>
	///// If path starts with <see cref="FilesDirectory"/> and '\\', removes the FilesDirectory part and returns true.
	///// </summary>
	///// <param name="path">Full or relative path or name.</param>
	//bool _FullPathToRelative(ref string path) {
	//	var d = FilesDirectory;
	//	bool full = path.Starts(d, true) && path.Eq(d.Length, '\\');
	//	if (full) path = path[d.Length..];
	//	return full;
	//}
	
	/// <summary>
	/// Finds file or folder by exact <c>@"\relative path"</c>.
	/// </summary>
	/// <param name="path">Must start with <c>@"\"</c> (asserts).</param>
	/// <remarks>
	/// Use only with paths created by the program, and not by users.
	/// Does not retry with ".cs" suffix.
	/// </remarks>
	/// <returns></returns>
	public FileNode FindByItemPath(string path) {
		Debug.Assert(path.Starts('\\'));
		int i = path.LastIndexOf('\\');
		var lastName = path[(i + 1)..];
		if (_nameMap.MultiGet_(lastName, out FileNode single, out var multiple)) {
			if (multiple != null) {
				foreach (var f in multiple) if (_PathOk(f)) return f;
			} else {
				if (_PathOk(single)) return single;
			}
		}
		return null;
		
		bool _PathOk(FileNode f) {
			f = f.Parent;
			for (int j = i; j > 0 && f != null; f = f.Parent) {
				int k = path.LastIndexOf('\\', j - 1);
				if (!path.Eq((k + 1)..j, f.Name ?? "", true)) return false;
				j = k;
			}
			return f == Root;
		}
	}
	
	/// <summary>
	/// Generates new id for f, and adds both to the dictionary that is used by <see cref="FindById"/> etc.
	/// Returns <i>id</i> or the generated id.
	/// </summary>
	public uint AddGetId(FileNode f) {
		uint id = (_idMap.Count > 0 ? _idMap.Keys.Max() : 0) + 1; //normally we don't reuse ids of deleted items
		if (id != 0) _idMap.Add(id, f);
		else while (!_idMap.TryAdd(++id, f)) { } //unlikely, but anyway. If new item created every 8 s, we have 1000 years.
		return id;
	}
	
	/// <summary>
	/// Finds file or folder by its <see cref="FileNode.Id"/>.
	/// Returns null if id is 0 or not found.
	/// id can contain <see cref="WorkspaceSN"/> in high-order int.
	/// </summary>
	public FileNode FindById(long id) {
		int idc = (int)(id >> 32); if (idc != 0 && idc != WorkspaceSN) return null;
		uint idf = (uint)id;
		if (idf == 0) return null;
		if (_idMap.TryGetValue(idf, out var f)) {
			Debug_.PrintIf(f == null, "deleted: " + idf);
			return f;
		}
		Debug_.Print("id not found: " + idf);
		return null;
	}
	
	/// <summary>
	/// Finds file or folder by its <see cref="FileNode.IdString"/> or <see cref="FileNode.IdStringWithWorkspace"/>.
	/// </summary>
	public FileNode FindById(string id) {
		id.ToInt(out long n, id.Starts(':') ? 1 : 0);
		return FindById(n);
	}
	
	/// <summary>
	/// Finds all files (and not folders) with the specified name.
	/// Returns empty array if not found.
	/// </summary>
	/// <param name="name">File name, like "name.cs". If starts with backslash, works like <see cref="Find"/>. Does not support <see cref="FileNode.IdStringWithWorkspace"/> string and filename without extension.</param>
	public FileNode[] FindAllFiles(string name) {
		return Root.FindAllDescendantFiles(name);
	}
	
	/// <summary>
	/// Finds class file "global.cs".
	/// If multiple exist, ignores external files and prefers "\Classes\global.cs".
	/// </summary>
	/// <param name="silent">Don't print warnings when not found or found multiple.</param>
	/// <returns>null if not found or if found multiple and could not pick the best.</returns>
	public FileNode FindGlobalCs(bool silent = false) {
		FoundMultiple = null;
		if (_nameMap.MultiGet_("global.cs", out FileNode g, out var a)) {
			if (g != null) {
				if (!g.IsClass) g = null;
			} else {
				for (int i = a.Count; --i >= 0;) if (!a[i].IsClass) a.RemoveAt(i);
				if (a.Count == 1) g = a[0];
				else if (a.Count > 0) {
					foreach (var v in a) if (v.Parent.Parent == Root && v.Parent.Name.Eqi("Classes")) { g = v; break; } //prefer default location
					if (g is null) { //find single non-external
						foreach (var v in a) {
							if (v.IsExternal) continue;
							if (g is null) g = v; else { g = null; break; }
						}
						if (g is null) FoundMultiple = a;
					}
				}
			}
		}
		if (g != null) {
			_noGlobalCsWarning = false;
			return g;
		}
		if (!silent) {
			if (FoundMultiple != null) {
				print.warning(@"Cannot use class file 'global.cs', because multiple exist, and none of them is \Classes\global.cs (default location).", -1);
			} else if (!_noGlobalCsWarning) {
				_noGlobalCsWarning = true;
				Panels.Output.Scintilla.AaTags.AddLinkTag("+restoreGlobal", _ => App.Model.AddMissingDefaultFiles(globalCs: true));
				print.warning("Missing class file \"global.cs\". <+restoreGlobal>Create<>.", -1, "<>");
			}
		}
		return null;
	}
	bool _noGlobalCsWarning;
	
	#endregion
	
	#region open/close, select, current, selected, context menu
	
	/// <summary>
	/// Returns true if f is null or isn't in this workspace or is deleted.
	/// </summary>
	public bool IsAlien(FileNode f) => f?.Model != this || f.IsDeleted;
	
	/// <summary>
	/// Closes f if open.
	/// Saves text if need, removes from OpenItems, deselects in treeview.
	/// </summary>
	/// <param name="f">Can be any item or null. Does nothing if it is null, folder or not open.</param>
	/// <param name="activateOther">When closing current file, if there are more open files, activate another open file.</param>
	/// <param name="selectOther">Select the activated file.</param>
	public bool CloseFile(FileNode f, bool activateOther = true, bool selectOther = false) {
		if (IsAlien(f)) return false;
		if (!_openFiles.Remove(f)) return false;
		
		bool isCurrent = f == _currentFile;
		bool setFocus = isCurrent && activateOther && f.OpenDoc.IsFocused;
		
		Panels.Editor.Close(f);
		f.IsSelected = false;
		
		//_StateCleanup();
		State.Cleanup();
		
		if (isCurrent) {
			if (activateOther) {
				if (_openFiles.Count > 0) {
					var ff = _openFiles[0];
					if (selectOther) ff.SelectSingle();
					if (_SetCurrentFile(ff, focusEditor: setFocus)) return true;
				} else if (setFocus) {
					App.Wmain.Focus(); //else would not work any hotkeys and even Alt+menu keys until something focused
				}
			}
			_currentFile = null;
		}
		f.UpdateControlRow();
		
		_UpdateOpenFiles(_currentFile);
		Save.StateLater();
		
		return true;
	}
	
	/// <summary>
	/// Closes specified files that are open.
	/// </summary>
	/// <param name="files">Any <b>IEnumerable</b> except <b>OpenFiles</b>.</param>
	/// <param name="dontClose">null or <b>FileNode</b> or <b>BitArray</b> to not close.</param>
	public void CloseFiles(IEnumerable<FileNode> files, object dontClose = null) {
		if (files == _openFiles) files = _openFiles.ToArray();
		bool closeCurrent = false;
		int i = 0;
		foreach (var f in files) {
			if (dontClose is System.Collections.BitArray ba) {
				if (i < ba.Length && ba[i++]) continue;
			} else if (f == dontClose) continue;
			if (f == _currentFile) closeCurrent = true; else CloseFile(f, activateOther: false);
		}
		if (closeCurrent) CloseFile(_currentFile);
	}
	
	/// <summary>
	/// Closes the file. If folder, closes/collapses its descendants.
	/// </summary>
	public void CloseFiles(FileNode f) {
		if (f.IsFolder) {
			CloseFiles(f.Descendants());
			CollapseAll(folder: f);
			//note: does not collapse the folder. Let the user see what happened.
		} else CloseFile(f);
	}
	
	/// <summary>
	/// Updates PanelOpen, enables/disables Previous command.
	/// </summary>
	void _UpdateOpenFiles(FileNode current) {
		Panels.Open.UpdateList();
		App.Commands[nameof(Menus.Edit.Navigate.Previous_document)].Enable(_openFiles.Count > 1);
	}
	
	/// <summary>
	/// Called by <see cref="LoadWorkspace"/> before opening another workspace and disposing this.
	/// Saves all, raises <see cref="UnloadingThisWorkspace"/> event, closes documents, sets _currentFile = null.
	/// </summary>
	internal void UnloadingWorkspace_() {
		Save.AllNowIfNeed();
		EditorExtension.ClosingWorkspace_(onExit: false);
		UnloadingThisWorkspace?.Invoke(); //closes dialogs that contain workspace-specific data, eg Properties
		UnloadingAnyWorkspace?.Invoke();
		_currentFile = null;
		Panels.Editor.CloseAll_(saveTextIfNeed: false);
		_openFiles.Clear();
		_UpdateOpenFiles(null);
	}
	
	/// <summary>
	/// Note: unsubscribe to avoid memory leaks.
	/// </summary>
	public event Action UnloadingThisWorkspace;
	public static event Action UnloadingAnyWorkspace;
	
	//rejected. Let unsubscribe in OnClosed: App.Model.UnloadingWorkspaceEvent -= Close;
	///// <summary>
	///// Closes window <i>w</i> when unloading workspace.
	///// </summary>
	//public void UnloadingWorkspaceCloseWindow(Window w) {
	//	Action aClose = w.Close;
	//	UnloadingWorkspaceEvent += aClose;
	//	EventHandler closed = null;
	//	closed = (_, _) => { UnloadingWorkspaceEvent -= aClose; w.Closed -= closed; };
	//	w.Closed += closed;
	//}
	
	/// <summary>
	/// Files that are displayed in the Open panel.
	/// Some of them are open in editor (see <see cref="PanelEdit.OpenDocs"/>, <see cref="FileNode.OpenDoc"/>), others just were open when closing this workspace the last time.
	/// </summary>
	public IReadOnlyList<FileNode> OpenFiles => _openFiles;
	List<FileNode> _openFiles = new();
	
	/// <summary>
	/// Gets the current file. It is open/active in the code editor.
	/// </summary>
	public FileNode CurrentFile => _currentFile;
	FileNode _currentFile;
	
	/// <summary>
	/// Selects the node. If not folder, opens its file in the code editor.
	/// Returns false if failed to open, for example if <i>f</i> is a folder.
	/// </summary>
	public bool SetCurrentFile(FileNode f, bool dontChangeTreeSelection = false, bool newFile = false, bool? focusEditor = true, bool noTemplate = false) {
		if (IsAlien(f)) return false;
		if (!dontChangeTreeSelection) f.SelectSingle();
		if (_currentFile != f) _SetCurrentFile(f, newFile, focusEditor, noTemplate);
		return _currentFile == f;
	}
	
	/// <summary>
	/// If f!=_currentFile and not folder:
	/// - Opens it in editor, adds to OpenFiles, sets _currentFile, saves state later, updates UI.
	/// - Saves and hides current document.
	/// Returns false if fails to read file or if f is folder.
	/// </summary>
	/// <param name="f"></param>
	/// <param name="newFile">Should be true if opening the file first time after creating.</param>
	/// <param name="focusEditor">If null, focus later, when mouse enters editor. Ignored if editor was focused (sets focus). Also depends on <i>newFile</i>.</param>
	bool _SetCurrentFile(FileNode f, bool newFile = false, bool? focusEditor = true, bool noTemplate = false) {
		Debug.Assert(!IsAlien(f));
		if (f == _currentFile) return true;
		//print.it(f);
		if (f.IsFolder) return false;
		
		CodeInfo.WaitUntilReadyForStyling();
		
		if (_currentFile != null) Save.TextNowIfNeed();
		
		var fPrev = _currentFile;
		_currentFile = f;
		
		if (!Panels.Editor.Open(f, newFile, focusEditor, noTemplate)) {
			_currentFile = fPrev;
			if (_openFiles.Contains(f)) _UpdateOpenFiles(_currentFile); //?
			return false;
		}
		
		fPrev?.UpdateControlRow();
		_currentFile.UpdateControlRow();
		
		_openFiles.Remove(f);
		_openFiles.Insert(0, f);
		_UpdateOpenFiles(f);
		Save.StateLater();
		
		return true;
	}
	
	void _ItemRightClicked(FileNode f) { //Dispatcher.InvokeAsync
		if (IsAlien(f)) return;
		if (!f.IsSelected) f.SelectSingle();
		_ContextMenu();
	}
	
	void _ContextMenu() {
		if (s_inContextMenu) return; //workaround for: sometimes, when dying mouse generates >1 rclick, somehow the menu is at screen 0 0
		if (s_contextMenu == null) {
			var m = s_contextMenu = new ContextMenu { PlacementTarget = TreeControl };
			//m.ItemsSource = App.Commands[nameof(Menus.File)].MenuItem.Items; //shows menu but then closes on mouse over
			App.Commands[nameof(Menus.File)].CopyToMenu(m);
			
			//unset s_inContextMenu when the menu closed and the command ended executing (if can show a modal dialog that closes the menu)
			m.Closed += static (_, _) => s_inContextMenu = false;
			App.Commands.ExecutingStartedEnded += started => s_inContextMenuCommand = started ? s_inContextMenu : false;
		}
		s_contextMenu.IsOpen = true;
		s_inContextMenu = s_contextMenu.IsOpen;
	}
	static ContextMenu s_contextMenu;
	static bool s_inContextMenu, s_inContextMenuCommand;
	
	/// <summary>
	/// Gets the place where item should be added in operations such as new, paste, import.
	/// If s_inContextMenuCommand or atSelection (true when pasting), uses the focused item. Else top.
	/// </summary>
	FNInsertPos _GetInsertPos(bool atSelection = false) {
		if ((atSelection || s_inContextMenuCommand) && TreeControl.FocusedItem is FileNode target) {
			var pos = FNInsert.Before;
			bool isFolder = target.IsFolder && target.IsSelected && TreeControl.SelectedIndices.Count == 1;
			if (isFolder && !target.HasChildren) pos = FNInsert.Last;
			else if (target.Next == null) pos = FNInsert.After; //usually users want to add after the last, not before
			
			return new(target, pos);
		} else { //top
			return new(Root, FNInsert.First);
		}
	}
	
	//Called when editor control focused, etc.
	public void EnsureCurrentSelected() {
		//if(_currentFile != null && !_currentFile.IsSelected && _control.SelectedIndices.Count < 2) _currentFile.SelectSingle();
		if (_currentFile != null && !_currentFile.IsSelected) _currentFile.SelectSingle();
	}
	
	/// <summary>
	/// Selects the node, opens its file in the code editor, optionally goes to the specified position or line or line/column.
	/// Returns false if failed to open, for example if it is a folder (then just selects folder).
	/// </summary>
	/// <param name="f"></param>
	/// <param name="line">If not negative, goes to this 0-based line.</param>
	/// <param name="columnOrPos">If not negative, goes to this 0-based position in text (if line negative) or to this 0-based column in line.</param>
	/// <param name="findText">If not null, finds this text (<b>FindWord</b>), and goes there if found. Then <i>line</i> and <i>columnPos</i> not used.</param>
	/// <param name="activateLA">Always activate the LA window. If false - only if wasn't visible.</param>
	public bool OpenAndGoTo(FileNode f, int line = -1, int columnOrPos = -1, string findText = null, bool activateLA = true) {
		if (activateLA || !App.Wmain.IsLoaded || !App.Wmain.IsVisible) App.Wmain.AaShowAndActivate();
		bool wasOpen = _currentFile == f;
		if (!SetCurrentFile(f)) return false;
		var doc = Panels.Editor.ActiveDoc;
		if (findText != null) {
			line = -1;
			columnOrPos = doc.aaaText.FindWord(findText);
		}
		if (line >= 0 || columnOrPos >= 0) {
			if (line >= 0) {
				int i = doc.aaaLineStart(true, line);
				if (columnOrPos > 0) i = Math.Min(i + columnOrPos, doc.aaaLen16); //not SCI_FINDCOLUMN, it calculates tabs
				columnOrPos = i;
			}
			if (!wasOpen) wait.doEvents(); //else scrolling does not work well if now opened the file. Can't async, because caller may use the new pos immediately.
			doc.aaaGoToPos(true, columnOrPos);
		} else {
			if (!wasOpen) wait.doEvents(); //caller then may call aaaGoToPos or aaaSelect etc
		}
		doc.Focus();
		return true;
	}
	
	/// <summary>
	/// Finds file and calls <see cref="OpenAndGoTo(FileNode, int, int, string, bool)"/>. Does nothing if not found. Note: default kind is CodeFile.
	/// </summary>
	public bool OpenAndGoTo(string file, int line = -1, int columnOrPos = -1, string findText = null, bool activateLA = true, FNFind kind = FNFind.CodeFile) {
		var f = Find(file, kind); if (f == null) return false;
		return OpenAndGoTo(f, line, columnOrPos, findText, activateLA);
	}
	
	/// <summary>
	/// Finds file or folder and selects the node. If not folder, opens its file in the code editor, optionally goes to the specified position or line or line/column.
	/// Returns false if failed to find or select.
	/// </summary>
	/// <param name="fileOrFolder">See <see cref="Find"/>.</param>
	/// <param name="line1Based">If not empty, goes to this 1-based line. Or can be "expand" to find and expand a folder.</param>
	/// <param name="column1BasedOrPos">If not empty, goes to this 0-based position in text (if line empty) or to this 1-based column in line.</param>
	/// <param name="activateLA"></param>
	/// <remarks>
	/// If column1BasedOrPos or line1Based not empty, searches only files, not folders.
	/// </remarks>
	public bool OpenAndGoTo2(string fileOrFolder, string line1Based = null, string column1BasedOrPos = null, bool activateLA = true) {
		bool expand = line1Based == "expand"; if (expand) line1Based = "";
		var f = Find(fileOrFolder, expand ? FNFind.Folder : line1Based.NE() && column1BasedOrPos.NE() ? FNFind.Any : FNFind.CodeFile);
		if (f == null) return false;
		if (f.IsFolder) {
			f.SelectSingle();
			if (expand) TreeControl.Expand(f, true);
			return true;
		}
		int line = line1Based.NE() ? -1 : line1Based.ToInt() - 1;
		int columnOrPos = -1; if (!column1BasedOrPos.NE()) columnOrPos = column1BasedOrPos.ToInt() - (line < 0 ? 0 : 1);
		return OpenAndGoTo(f, line, columnOrPos, activateLA: activateLA);
	}
	
	/// <summary>
	/// Finds code file, selects the node, opens in the code editor, searches for the specified text. If finds, goes there.
	/// Returns false if failed to find file or select.
	/// </summary>
	/// <param name="fileOrFolder">See <see cref="Find"/>.</param>
	/// <param name="findText"></param>
	/// <param name="activateLA"></param>
	public bool OpenAndGoTo3(string fileOrFolder, string findText, bool activateLA = true) {
		var f = FindCodeFile(fileOrFolder);
		if (f == null) return false;
		return OpenAndGoTo(f, findText: findText, activateLA: activateLA);
	}
	
	#endregion
	
	#region rename, delete, open/close (menu commands), properties
	
	public void RenameSelected(bool newFile = false) {
		Panels.PanelManager[Panels.Files.P].Visible = true; //exception if not visible
		TreeControl.EditLabel(ended: newFile ? ok => { if (ok && Keyboard.IsKeyDown(Key.Enter)) Panels.Editor.ActiveDoc?.Focus(); } : null);
	}
	
	public void RenameNewProject(FileNode folder, FileNode main) {
		Panels.PanelManager[Panels.Files.P].Visible = true; //exception if not visible
		folder.SelectSingle();
		TreeControl.EditLabel(ended: ok => {
			if (ok && Keyboard.IsKeyDown(Key.Enter)) {
				main.SelectSingle();
				RenameSelected(newFile: true);
			}
		});
	}
	
	public void DeleteSelected() {
		var a = TreeControl.SelectedItems; if (a.Length < 1) return;
		
		//confirmation
		var text = string.Join("\n", a.Select(f => f.Name));
		bool hasLinks = a.Any(o => o.Descendants(andSelf: true).Any(u => u.IsLink));
		bool hasNonlinks = a.Any(o => !o.IsLink);
		var expandedText = (hasLinks, hasNonlinks) switch {
			(true, true) => "Files will be deleted. Will use the Recycle Bin, if possible.\nLink targets will NOT be deleted.",
			(true, false) => "The link will be deleted. Its target will NOT be deleted.",
			(false, true) => "The file will be deleted. Will use the Recycle Bin, if possible.",
			_ => null
		};
		var r = dialog.show("Deleting", text, "1 OK|0 Cancel", owner: TreeControl, expandedText: expandedText);
		if (r == 0) return;
		
		foreach (var f in a) {
			if (f.IsDeleted) continue; //deleted together with the parent folder
			_Delete(f); //info: and saves everything, now and/or later
		}
		
		Save.WorkspaceAsync();
		CodeInfo.FilesChanged();
	}
	
	/// <param name="syncing">0 - normal; 1 - syncing all a startup; 2 - filesystem watchers detected a deleted file or folder.</param>
	bool _Delete(FileNode f, bool recycleBin = true, int syncing = 0) {
		var e = f.Descendants(true);
		
		CloseFiles(e);
		Uncut();
		
		if (syncing == 0) {
			if (f.IsLink) {
				print.it($"<>Info: The deleted item was a link to <explore>{f.FilePath}<>");
			} else {
				if (!TryFileOperation(FOSync.UserFileOp, () => filesystem.delete(f.FilePath, recycleBin ? FDFlags.RecycleBin : 0))) return false;
				//CONSIDER: add all paths to List, and delete finally in single call.
				//CONSIDER: move to folder '.deleted'. Moving to RB is very slow. No RB if in removable drive etc.
			}
		}
		
		EditGoBack.OnFileDeleted(e);
		Panels.Bookmarks.FileDeleted(e);
		Panels.Breakpoints.FileDeleted(e);
		foreach (var k in e) {
			if (!k.IsFolder) {
				State.EditorDelete(k);
				if (k.IsCodeFile) Compiler.Uncache(k);
			}
			if (k.IsLink && k.IsFolder) {
				//_rootLF?.Remove(k);
				_syncWatchers?.Remove(k);
			}
			
			_idMap[k.Id] = null;
			_nameMap.MultiRemove_(k.Name, k);
			k.IsDeleted = true;
		}
		
		f.Remove();
		
		if (syncing != 1) UpdateControlItems();
		if (syncing == 2) {
			Save.WorkspaceAsync();
			CodeInfo.FilesChanged();
		}
		
		return true;
	}
	
	//TODO3: once (2 times) crashed when deleting folder "@Triggers and toolbars".
	//	Both times in editor was opened a class file from the folder.
	//	First time: messagebox "exception processing message, unexpected parameters".
	//		After restarting were deleted files and tree items. Just several warnings about not found file id.
	//	Second time with debugger: access violation exception somewhere in DispatchMessage -> COM message processing.
	//		After restarting were deleted files but not tree items. Tried to reopen the file, but failed, and no editor control was created.
	//	COM wasn't used explicitly. Maybe because of Recycle Bin.
	//	Then could not reproduce (after recompiling same code).
	
	/// <summary>
	/// Opens the selected item(s) in our editor or in default app or selects in Explorer.
	/// </summary>
	/// <param name="how">1 open, 2 open in new window (not impl), 3 open in default app, 4 select in Explorer.</param>
	public void OpenSelected(int how) {
		var a = TreeControl.SelectedItems; if (a.Length == 0) return;
		
		foreach (var f in a) {
			var path = f.FilePath;
			if (how is 3 or 4) {
				var e = filesystem.exists(path, useRawPath: true);
				if (!e) { print.it(f.IsFolder ? "The folder does not exist" : "The file does not exist"); continue; }
			}
			
			switch (how) {
			case 1:
				if (f.IsFolder) TreeControl.Expand(f, true);
				else SetCurrentFile(f);
				break;
			//case 2:
			//	if(f.IsFolder) continue;
			//	//FUTURE
			//	break;
			case 3:
				run.itSafe(path);
				break;
			case 4:
				run.selectInExplorer(path);
				break;
			}
		}
	}
	
	/// <summary>
	/// Closes selected or all items, or collapses folders.
	/// Used to implement menu File > Open/Close.
	/// </summary>
	public void CloseEtc(ECloseCmd how, FileNode dontClose = null) {
		switch (how) {
		case ECloseCmd.CloseSelectedOrCurrent:
			var a = TreeControl.SelectedItems;
			if (a.Length == 0) CloseFile(_currentFile);
			else if (a.Length == 1) CloseFiles(a[0]);
			else CloseFiles(a);
			break;
		case ECloseCmd.CloseAll:
			CloseFiles(_openFiles, dontClose);
			CollapseAll();
			if (dontClose != null) TreeControl.EnsureVisible(dontClose);
			break;
		case ECloseCmd.CollapseAllFolders:
			CollapseAll();
			break;
		case ECloseCmd.CollapseInactiveFolders:
			CollapseAll(exceptWithOpenFiles: true);
			break;
		}
	}
	
	public void CollapseAll(bool exceptWithOpenFiles = false, FileNode folder = null) {
		bool update = false;
		folder ??= Root;
		foreach (var v in folder.Descendants()) {
			if (v.IsExpanded) {
				if (exceptWithOpenFiles && v.Descendants().Any(o => _openFiles.Contains(o))) continue;
				update = true;
				v.SetIsExpanded(false);
			}
		}
		if (update) UpdateControlItems();
	}
	
	public enum ECloseCmd {
		/// <summary>
		/// Closes selected files. If there are no selected files, closes current file. Does not collapse selected folders.
		/// </summary>
		CloseSelectedOrCurrent,
		CloseAll,
		CollapseAllFolders,
		CollapseInactiveFolders,
	}
	
	public void Properties() {
		FileNode f = null;
		if (s_inContextMenuCommand) {
			var a = TreeControl.SelectedItems;
			if (a.Length == 1) f = a[0];
		} else {
			EnsureCurrentSelected();
			f = _currentFile;
		}
		if (f == null) return;
		if (f.IsCodeFile) DProperties.ShowFor(f);
		//else if(f.IsFolder) DFolderProperties.ShowFor(f);
		//else DOtherFileProperties.ShowFor(f);
	}
	
	#endregion
	
	#region new item
	
	/// <summary>
	/// Creates new item.
	/// Opens file, or selects folder, or opens main file of project folder. Optionally begins renaming.
	/// Loads files.xml, finds template's element and calls <see cref="NewItemX"/>; it calls <see cref="NewItemLX"/>.
	/// </summary>
	/// <param name="template">
	/// Relative path of a file or folder in the Templates\files folder. Case-sensitive, as in workspace.
	/// Examples: "File.cs", "File.txt", "Subfolder", "Subfolder\File.cs".
	/// Special names: null (creates folder), "Script.cs", "Class.cs".
	/// If folder and not null, adds descendants too; removes '!' from the start of template folder name.
	/// </param>
	/// <param name="ipos">If null, adds at the context menu position or top.</param>
	/// <param name="name">If not null, creates with this name (eg "name.cs"). Else gets name from template. In any case makes unique name.</param>
	public FileNode NewItem(string template, FNInsertPos? ipos = null, string name = null, bool beginRenaming = false, NewFileText text = null) {
		XElement x = null;
		if (template != null) {
			x = FileNode.Templates.LoadXml(template); if (x == null) return null;
		}
		return NewItemX(x, ipos, name, beginRenaming, text);
	}
	
	/// <summary>
	/// Creates new item.
	/// Returns the new item, or null if fails.
	/// Does not open/select/startRenaming.
	/// </summary>
	/// <param name="template">See <see cref="NewItem"/>.</param>
	/// <param name="ipos">If null, adds at the context menu position or top.</param>
	/// <param name="name">If not null, creates with this name (eg "name.cs"). Else gets name from template. In any case makes unique name.</param>
	public FileNode NewItemL(string template, FNInsertPos? ipos = null, string name = null) {
		XElement x = null;
		if (template != null) {
			x = FileNode.Templates.LoadXml(template); if (x == null) return null;
		}
		return NewItemLX(x, ipos, name);
	}
	
	/// <summary>
	/// Creates new item.
	/// Opens file, or selects folder, or opens main file of project folder. Optionally begins renaming.
	/// Calls <see cref="NewItemLX"/>.
	/// <param name="template">An XElement of files.xml of the Templates workspace. If null, creates folder.</param>
	/// <param name="ipos">If null, adds at the context menu position or top.</param>
	/// <param name="name">If not null, creates with this name (eg "name.cs"). Else gets name from template. In any case makes unique name.</param>
	/// </summary>
	public FileNode NewItemX(XElement template, FNInsertPos? ipos = null, string name = null, bool beginRenaming = false, NewFileText text = null) {
		string s = null;
		if (text != null && text.replaceTemplate) {
			s = text.meta.NE() ? text.text : _MetaPlusText(text.text);
			text = null;
		}
		
		var f = NewItemLX(template, ipos, name, s);
		if (f == null) return null;
		var f0 = f;
		
		if (beginRenaming && template != null && FileNode.Templates.IsInDefault(template)) beginRenaming = false;
		
		if (f.IsFolder) {
			if (f.IsProjectFolder(out var main) && main != null) SetCurrentFile(f = main, newFile: true); //open the main file of the new project folder
			else f.SelectSingle(); //select the new folder
		} else {
			SetCurrentFile(f, newFile: true, noTemplate: text?.replaceTemplate ?? false); //open the new file
		}
		
		if (text != null && f == CurrentFile) {
			Debug.Assert(f.IsScript);
			f.GetCurrentText(out s);
			var me = MetaComments.FindMetaComments(s).end;
			if (!text.meta.NE()) {
				if (me == 0) s = _MetaPlusText(s); //never mind: should skip script doc comments at start. Rare and not important.
				else s = s.Insert(me - 3, (s[me - 4] == ' ' ? "" : " ") + text.meta + " ");
			}
			if (!text.text.NE()) {
				if (s.NE()) s = text.text;
				else if (s.RxMatch(@"\R\R", 0, out RXGroup g, range: me..)) s = s.Insert(g.End, text.text);
				else if (s.RxMatch(@"\R\z", 0, out g, range: me..)) s = s + "\r\n" + text.text;
			}
			Panels.Editor.ActiveDoc.aaaSetText(s);
		}
		
		if (beginRenaming && f.IsSelected) {
			if (f != f0) RenameNewProject(f0, f);
			else RenameSelected(newFile: !f.IsFolder);
		}
		return f;
		
		string _MetaPlusText(string t) => $"/*/ {text.meta} /*/{(t.Starts("//.") ? " " : "\r\n")}{t}";
	}
	
	/// <summary>
	/// Creates new item.
	/// Returns the new item, or null if fails.
	/// Does not open/select/startRenaming.
	/// </summary>
	/// <param name="template">An XElement of files.xml of the Templates workspace. If null, creates folder.</param>
	/// <param name="ipos">If null, adds at the context menu position or top.</param>
	/// <param name="name">If not null, creates with this name (eg "name.cs"). Else gets name from template. In any case makes unique name.</param>
	/// <param name="text">If not null, sets this text. If null, sets default text (template etc). Not used for folders.</param>
	public FileNode NewItemLX(XElement template, FNInsertPos? ipos = null, string name = null, string text = null) {
		var ip = ipos ?? _GetInsertPos();
		
		//create unique name
		bool isFolder = template == null || template.Name.LocalName == "d";
		if (name == null) {
			bool append1 = true;
			if (template == null) {
				name = "Folder";
			} else {
				name = template.Attr("n");
				if (isFolder && name.Starts('!')) name = name[1..];
				append1 = !FileNode.Templates.IsInDefault(template);
			}
			//let unique names start from 1
			if (append1) {
				int i;
				if (!isFolder && (i = name.LastIndexOf('.')) > 0) name = name.Insert(i, "1"); else name += "1";
			}
		}
		name = FileNode.CreateNameUniqueInFolder(ip.ParentFolder, name, isFolder, autoGenerated: true);
		
		return _NewItem(ip, template, name, text);
	}
	
	FileNode _NewItem(FNInsertPos ipos, XElement template, string name, string text) {
		var fileType = template == null ? FNType.Folder : FileNode.XmlTagToFileType(template.Name.LocalName, canThrow: false);
		Debug.Assert(fileType is not (FNType.Script or FNType.Class) || name.Ends(".cs"));
		
		if (text == null && fileType != FNType.Folder) {
			string relPath = template.Attr("n");
			for (var p = template; (p = p.Parent).Name.LocalName != "files";) relPath = p.Attr("n") + "\\" + relPath;
			if (fileType == FNType.Other) {
				text = filesystem.loadText(FileNode.Templates.DefaultDirBS + relPath);
			} else if (FileNode.Templates.IsStandardTemplateName(relPath, out var tt)) {
				text = FileNode.Templates.Load(tt);
				//if (tt == FileNode.ETempl.Script) text = text.RxReplace(@"\bScript\s*\{", "Script {", 1); //no. The user will see warning when compiling, and let update custom template.
			} else {
				text = filesystem.loadText(FileNode.Templates.DefaultDirBS + relPath);
				if (text.Length < 20 && text.Starts("//#")) { //load default or custom template?
					tt = text switch { "//#script" => FileNode.ETempl.Script, "//#class" => FileNode.ETempl.Class, _ => 0 };
					if (tt != 0) text = FileNode.Templates.Load(tt);
				}
			}
		}
		
		FileNode parent = ipos.ParentFolder;
		var path = parent.FilePath + "\\" + name;
		if (!TryFileOperation(FOSync.UserFileOp, () => {
			if (fileType == FNType.Folder) filesystem.createDirectory(path);
			else filesystem.saveText(path, text);
		})) return null;
		
		var f = new FileNode(this, name, fileType);
		f.Common_MoveCopyNew(ipos, false);
		
		if (template != null) {
			if (template.Attr(out string icon, "icon")) f.CustomIconName = icon;
			
			if (fileType == FNType.Folder) {
				foreach (var x in template.Elements()) {
					_NewItem(new(f, FNInsert.Last), x, x.Attr("n"), null);
				}
			}
		}
		
		return f;
	}
	
	#endregion
	
	#region clipboard
	
	struct _Clipboard {
		public FileNode[] items;
		public bool cut;
		public uint clipSN;
		
		public bool IsCut(FileNode f) => cut && items.Contains(f);
	}
	_Clipboard _clipboard;
	
	public void CutCopySelected(bool cut) {
		Uncut();
		var a = TreeControl.SelectedItems; if (a.NE_()) return;
		_clipboard = new _Clipboard { items = a, cut = cut };
		if (cut) {
			//we don't support cut to outside this workspace. Much work, rarely used, can copy/delete.
			//	The same with copy/paste between workspaces.
			clipboard.clear();
			TreeControl.Redraw();
		} else {
			var d = new clipboardData();
			d.AddFiles(a.Select(o => o.FilePath).ToArray());
			d.AddText(string.Join("\r\n", a.Select(o => o.Name)));
			d.SetClipboard();
		}
		_clipboard.clipSN = Api.GetClipboardSequenceNumber();
	}
	
	public void Paste() {
		if (_clipboard.items != null && _clipboard.clipSN != Api.GetClipboardSequenceNumber()) Uncut();
		var ipos = _GetInsertPos(atSelection: true);
		if (_clipboard.items != null) {
			_MultiCopyMove(!_clipboard.cut, _clipboard.items, ipos);
			Uncut();
		} else {
			using (new clipboard.OpenClipboard_(false)) {
				var h = Api.GetClipboardData(Api.CF_HDROP);
				if (h != default) {
					var a = clipboardData.HdropToFiles_(h);
					_DroppedOrPasted(null, a, ipos, false);
				} else if (clipboardData.GetText_(0) is string s && s.Length > 0) {
					SciCode.EIsForumCode_(s, newFile: true);
				}
			}
		}
	}
	
	public void Uncut() {
		bool cut = _clipboard.cut;
		if (!cut && _clipboard.items != null && _clipboard.clipSN == Api.GetClipboardSequenceNumber()) clipboard.clear();
		_clipboard = default;
		if (cut) TreeControl.Redraw();
	}
	
	public bool IsCut(FileNode f) => _clipboard.IsCut(f);
	
	public void SelectedCopyPath(bool full) {
		var a = TreeControl.SelectedItems; if (a.Length == 0) return;
		clipboard.text = string.Join("\r\n", a.Select(f => full ? f.FilePath : f.ItemPath));
	}
	
	#endregion
	
	#region import, move, copy
	
	void _MultiCopyMove(bool copy, FileNode[] a, FNInsertPos ipos) {
		bool copyLinkTarget = copy && a.Any(o => o.IsLink) && 2 == popupMenu.showSimple("1 Copy link|2 Copy link target", owner: TreeControl);
		if (copy) TreeControl.UnselectAll();
		try {
			bool movedCurrentFile = false;
			var a2 = new List<FileNode>(a.Length);
			//foreach (var f in (ipos.pos == FNInsert.After) ? a.Reverse() : a) { //broken in .NET 9
			foreach (var f in (ipos.pos == FNInsert.After) ? Enumerable.Reverse(a) : a) {
				if (!this.IsMyFileNode(f)) continue; //deleted?
				if (a.Contains(f.Parent)) continue;
				if (copy) {
					var fCopied = f._FileCopy(ipos, this, copyLinkTarget);
					if (fCopied != null) a2.Add(fCopied);
				} else {
					if (!f.FileMove(ipos)) continue;
					if (!movedCurrentFile && _currentFile != null) {
						if (f == _currentFile || (f.IsFolder && _currentFile.IsDescendantOf(f))) movedCurrentFile = true;
					}
				}
			}
			if (movedCurrentFile) TreeControl.EnsureVisible(_currentFile);
			if (copy && !(ipos.Inside && !ipos.f.IsExpanded)) {
				bool focus = true;
				foreach (var f in a2) {
					f.IsSelected = true;
					if (focus) { focus = false; TreeControl.SetFocusedItem(f); }
				}
			}
		}
		catch (Exception e1) { print.it(e1); }
		
		//info: don't need to schedule saving here. FileCopy and FileMove did it.
	}
	
	void _DroppedOrPasted(FileNode[] nodes, string[] files, FNInsertPos ipos, bool copy) {
		if (nodes != null) {
			_MultiCopyMove(copy, nodes, ipos);
		} else {
			if (ipos.f == null) ipos = new(Root, FNInsert.Last);
			if (files.Length == 1 && IsWorkspaceDirectoryOrZip_ShowDialogOpenImport(files[0], out int dialogResult)) {
				switch (dialogResult) {
				case 1: timer.after(1, _ => LoadWorkspace(files[0])); break;
				case 2: ImportWorkspace(files[0], ipos); break;
				}
				return;
			}
			ImportFiles(files, ipos, copy ? ImportFlags.Copy : 0);
		}
	}
	
	/// <summary>
	/// Imports one or more files or folders into the workspace. Shows dialog to select.
	/// </summary>
	public void ImportFiles(bool folder) {
		var d = new FileOpenSaveDialog("{4D1F3AFB-DA1A-45AC-8C12-41DDA5C51CDA}") { Title = folder ? "Import folder" : "Import files" };
		if (d.ShowOpen(out string[] a, owner: TreeControl, selectFolder: folder))
			ImportFiles(a);
	}
	
	/// <summary>
	/// Imports one or more files or folders into the workspace.
	/// </summary>
	public void ImportFiles(string[] a, ImportFlags flags = 0) {
		ImportFiles(a, _GetInsertPos(), flags);
	}
	
	/// <summary>
	/// Imports one or more files or/and folders.
	/// </summary>
	/// <param name="a"></param>
	/// <param name="ipos"></param>
	/// <param name="flags"></param>
	/// <returns>The first imported item, or null if failed.</returns>
	public FileNode ImportFiles(string[] a, FNInsertPos ipos, ImportFlags flags = 0) {
		FileNode fReturn = null;
		try {
			a = a.Select(s => filesystem.more.getFinalPath(s, out s, format: FPFormat.PrefixNever) ? s : null).OfType<string>().ToArray();
			if (a.Length == 0) return null;
			var newParent = ipos.ParentFolder;
			
			//need to detect files coming from the workspace. Get path of the workspace files dir and target paths of all link folders.
			var wsDirs = Root.Descendants()
				.Where(o => o.IsLink && o.IsFolder)
				.Select(o => filesystem.more.getFinalPath(o.LinkTarget, out var s, format: FPFormat.PrefixNever) ? s : null)
				.OfType<string>() //where not null
				.Prepend(FilesDirectory)
				.ToArray();
			
			var action = flags & (ImportFlags.Copy | ImportFlags.Move | ImportFlags.Link);
			bool dontPrint = flags.Has(ImportFlags.DontPrint);
			int fromWorkspaceDir = 0;
			bool isLinkToWsFile = false;
			
			for (int i = 0; i < a.Length; i++) {
				var s = a[i];
				if (s.Find(@"\$RECYCLE.BIN\", true) > 0) {
					print.it($"<>Cannot import files directly from Recycle Bin.");
					return null;
				}
				if (wsDirs.FirstOrDefault(o => o.PathStarts(s, orEquals: true)) is { } s2) {
					print.it($"<>Cannot import. The folder {(s2.Eqi(s) ? "already is" : "contains a folder that is")} in the workspace. {FindByFilePath(s2)?.SciLink(true)}");
					return null;
				}
				if (wsDirs.Any(o => s.PathStarts(o))) {
					if (action != 0) return null; //unlikely
					var f1 = FindByFilePath(s);
					if (f1 != null) {
						var sff = f1.IsFolder ? "folder" : "file";
						if (a.Length > 1) {
							print.it($"<>Cannot import. The {sff} already is in the workspace. {f1.SciLink(true)}. Try to import single file.");
							return null;
						}
						int dr = dialog.show("Import files", $"The {sff} already is in the workspace.\n\n{f1.ItemPath}", "2 Open the existing|1 Create link|0 Cancel", DFlags.CommandLinks, owner: TreeControl);
						if (dr != 1) {
							if (dr == 2) f1.Model.SetCurrentFile(f1);
							return null;
						}
						action = ImportFlags.Link;
						dontPrint = true;
						isLinkToWsFile = true;
					} else {
						//repair workspace: import file that is in a workspace folder but not in the Files panel
						fromWorkspaceDir++;
					}
				}
			}
			if (fromWorkspaceDir > 0 && fromWorkspaceDir < a.Length) return null; //some files from workspace dir and some not. Unlikely.
			
			if (action == 0) {
				if (fromWorkspaceDir > 0) {
					action = ImportFlags.Move;
				} else {
					var ab = new[] { "2 Copy to the workspace", "3 Move to the workspace", "1 Create link", "0 Cancel" };
					int dr = dialog.show("Import files", string.Join("\n", a), ab, DFlags.CommandLinks, owner: TreeControl, footer: GetSecurityInfo("v|"));
					action = dr switch { 1 => ImportFlags.Link, 2 => ImportFlags.Copy, 3 => ImportFlags.Move, _ => 0 };
					if (action == 0) return null;
				}
			}
			
			bool select = !flags.Has(ImportFlags.DontSelect) && !(ipos.Inside && !ipos.f.IsExpanded), focus = select;
			if (select) TreeControl.UnselectAll();
			
			_ImportRename iren = new(this);
			
			try {
				var newParentPath = newParent.FilePath + "\\";
				var (nf1, nd1, nc1) = dontPrint ? default : _CountFilesFolders();
				
				foreach (var path in a) {
					var g = filesystem.exists(path, true);
					if (!g.Exists || g.IsNtfsLink) continue;
					bool isDir = g.Directory;
					
					FileNode k;
					var name = pathname.getName(path);
					if (fromWorkspaceDir == 0) {
						if (isLinkToWsFile) name = "Link to " + name; //prevent duplicate name. Never mind: when isDir, we'll have duplicate names inside the dir; cannot rename.
						name = FileNode.CreateNameUniqueInFolder(newParent, name, isDir);
					}
					
					string path2;
					if (action == ImportFlags.Link) {
						k = new FileNode(this, name, path2 = path, isDir, isLink: true);
					} else {
						path2 = newParentPath + name;
						if (action == ImportFlags.Copy) {
							if (!TryFileOperation(FOSync.UserFileOp, () => { filesystem.copy(path, path2, FIfExists.Fail); })) continue;
						} else if (path2 != path) {
							if (!TryFileOperation(FOSync.UserFileOp, () => { filesystem.move(path, path2, FIfExists.Fail); })) continue;
						}
						k = new FileNode(this, name, path2, isDir);
					}
					k.AddToTree(ipos);
					if (isDir) {
						_AddDir(path2, k);
						foreach (var desc in k.Descendants()) _UnsafeAdd(desc, action == ImportFlags.Link);
					} else {
						_UnsafeAdd(k);
					}
					if (select) {
						k.IsSelected = true;
						if (focus) { focus = false; TreeControl.SetFocusedItem(k); }
					}
					if (k.IsLink && isDir) {
						//_rootLF?.Add(k);
						_syncWatchers?.Add(k);
					}
					fReturn ??= k;
				}
				
				if (!dontPrint) {
					var (nf2, nd2, nc2) = _CountFilesFolders();
					int nf = nf2 - nf1, nd = nd2 - nd1, nc = nc2 - nc1;
					if (nf + nd > 0) print.it($"Info: Imported {nf} files{(nd > 0 ? $" and {nd} folders" : null)}.{(nc > 0 ? GetSecurityInfo("\r\n\t") : null)}");
				}
			}
			catch (Exception ex) { print.it(ex); }
			Save.WorkspaceAsync();
			CodeInfo.FilesChanged();
			
			void _UnsafeAdd(FileNode f, bool inDir = false) {
				if (f.IsCodeFile && fromWorkspaceDir == 0 && !isLinkToWsFile && !flags.Has(ImportFlags.DontPrint)) iren.Imported(f, inDir);
			}
			
			(int nf, int nd, int nc) _CountFilesFolders() {
				int nf = 0, nd = 0, nc = 0;
				foreach (var v in Root.Descendants()) if (v.IsFolder) nd++; else { nf++; if (v.IsCodeFile) nc++; }
				return (nf, nd, nc);
			}
		}
		catch (Exception e1) { print.it(e1); }
		return fReturn;
	}
	
	class _ImportRename {
		HashSet<string> _hs;
		FilesModel _model;
		
		public _ImportRename(FilesModel model) {
			_model = model;
		}
		
		//When importing an unknown file that has a known auto-executed file name or "global.cs", renames it.
		public void Imported(FileNode f, bool inLinkDir) {
			if (_hs == null) {
				_hs = new(StringComparer.OrdinalIgnoreCase) { "global.cs" };
				if (_model._GetStartupScripts() is { } x) foreach (var row in x.Rows) _hs.Add(row[0]); //and never mind if \path or //comment
			}
			var name = f.Name;
			if (_hs.Contains(name)) {
				var oldName = name;
				name = name.Insert(^3, "-renamed");
				for (int i = 2, j = name.Length - 3; ; i++) {
					if (_hs.Contains(name) || filesystem.exists(f.Parent.FilePath + "\\" + name)) name = name.ReplaceAt(j..^3, i.ToS());
					else break;
				}
				const string s1 = " to prevent unintended execution or duplicate name problems";
				if (inLinkDir || !f.RenameL_(name)) print.it($"<><c red>Consider to rename or delete {f.SciLink(true)}{s1}.<>");
				else print.it($"<>File {f.SciLink(false)} has been renamed{s1}. Original name: \"{oldName}\".");
			}
		}
	}
	
	/// <summary>
	/// Finds a file or directory by path in the workspace. If not found, imports as link. Opens/selects.
	/// </summary>
	/// <param name="file">Full path.</param>
	/// <param name="ipos">If default, inserts at the top.</param>
	/// <returns>The imported item, or null if failed.</returns>
	public FileNode ImportLinkOrOpen(string file, FNInsertPos ipos = default) {
		var k = filesystem.exists(file); if (!k) return null;
		var f = FindByFilePath(file, k.Directory ? FNFind.Folder : FNFind.File);
		if (f is null) {
			if (ipos.f is null) ipos = new(Root, FNInsert.First);
			f = ImportFiles([file], ipos, ImportFlags.Link | ImportFlags.DontPrint | ImportFlags.DontSelect);
			if (f is null) return null;
		}
		return SetCurrentFile(f) ? f : null;
	}
	
	/// <summary>
	/// Adds to workspace 1 file (not folder) that exists in workspace folder in filesystem.
	/// </summary>
	public FileNode ImportFileFromWorkspaceDir(string path, FNInsertPos ipos) {
		try { //probably nothing can throw here, but anyway
			if (!filesystem.exists(path, useRawPath: true).File) return null;
			if (FindByFilePath(path) is { } f1) return f1.IsFolder ? null : f1;
			var R = new FileNode(this, pathname.getName(path), path, isDir: false);
			R.AddToTree(ipos);
			Save.WorkspaceAsync();
			CodeInfo.FilesChanged();
			return R;
		}
		catch (Exception ex) { print.warning(ex); return null; }
	}
	
	FileNode _SyncImportFromWorkspaceDir(string path, string itemPath) {
		try { //probably nothing can throw here, but anyway
			var exists = filesystem.exists(path, true);
			if (exists && !exists.Attributes.Has(FileAttributes.Hidden | FileAttributes.System) && FindByItemPath(itemPath) is null) {
				var parentItemPath = pathname.getDirectory(itemPath);
				var parent = parentItemPath.Length > 0 ? FindByItemPath(parentItemPath) : Root;
				if (parent != null) {
					FNInsertPos ipos = new(parent, parent.Id == 0 ? FNInsert.First : FNInsert.Last);
					var R = new FileNode(this, pathname.getName(path), path, isDir: exists.Directory);
					R.AddToTree(ipos);
					
					//if folder, add descendants.
					//	Note: when copying, some descendants may be still not copied; it's OK, we'll receive 'created' events for those. When moving, there are no 'created' events for descendants.
					if (exists.Directory) _AddDir(path, R);
					
					Save.WorkspaceAsync();
					CodeInfo.FilesChanged();
					return R;
				}
			}
		}
		catch (Exception ex) { print.warning(ex); }
		return null;
	}
	
	void _AddDir(string path, FileNode parent) {
		foreach (var u in filesystem.enumerate(path, FEFlags.UseRawPath | FEFlags.SkipHiddenSystem)) {
			if (_IsPathIgnored(parent.ItemPath + "\\" + u.Name)) continue;
			bool isDir = u.IsDirectory;
			var k = new FileNode(this, u.Name, u.FullPath, isDir);
			parent.AddChild(k);
			if (isDir) _AddDir(u.FullPath, k);
		}
	}
	
	/// <summary>
	/// Imports another workspace folder or zip file (workspace or not) into this workspace.
	/// </summary>
	/// <param name="wsDirOrZip">Workspace directory or any .zip file.</param>
	/// <param name="ipos">If null, calls _GetInsertPos.</param>
	public void ImportWorkspace(string wsDirOrZip = null, FNInsertPos? ipos = null) {
		try {
			string wsDir, folderName;
			bool isZip = wsDirOrZip.Ends(".zip", true) && filesystem.exists(wsDirOrZip).File, notWorkspace = false;
			
			if (isZip) {
				folderName = pathname.getNameNoExt(wsDirOrZip);
				wsDir = folders.ThisAppTemp + folderName;
				filesystem.delete(wsDir);
				ZipFile.ExtractToDirectory(wsDirOrZip, wsDir);
				notWorkspace = !IsWorkspaceDirectoryOrZip(wsDir, out _);
			} else {
				wsDir = wsDirOrZip;
				folderName = pathname.getName(wsDir);
			}
			
			//create new folder for workspace's items
			var folder = NewItemLX(null, ipos, folderName);
			if (folder == null) return;
			
			if (notWorkspace) {
				ImportFiles(Directory.GetFileSystemEntries(wsDir), new(folder, FNInsert.Last), ImportFlags.Copy);
			} else {
				var m = new FilesModel(wsDir + @"\files.xml", importing: true);
				FNInsertPos ipos2 = new(folder, FNInsert.Last);
				foreach (var f in m.Root.Children()) {
					f._FileCopy(ipos2, this);
				}
				m.Dispose(); //currently does nothing
				
				_ImportRename iren = new(this);
				foreach (var f in folder.Descendants()) {
					if (f.IsCodeFile) iren.Imported(f, false);
				}
				
				print.it($"Info: Imported '{wsDirOrZip}' to folder '{folder.Name}'.\r\n\t{GetSecurityInfo()}");
			}
			
			folder.SelectSingle();
			if (isZip) filesystem.delete(wsDir);
		}
		catch (Exception ex) { print.it(ex); }
	}
	
	#endregion
	
	#region export
	
	/// <summary>
	/// Shows dialog to get path for new or exporting workspace.
	/// Returns workspace's directory path.
	/// Does not create any files/directories.
	/// </summary>
	/// <param name="name">Default name of the workspace.</param>
	/// <param name="location">Default parent directory of the main directory of the workspace.</param>
	public static string GetDirectoryPathForNewWorkspace(string name = null, string location = null) {
		var d = new DNewWorkspace(name, location ?? folders.ThisAppDocuments) { Owner = App.Wmain, ShowInTaskbar = false };
		if (d.ShowDialog() != true) return null;
		return d.ResultPath;
	}
	
	public bool ExportSelected(string location = null) {
		var aSel = TreeControl.SelectedItems; if (aSel.Length < 1) return false;
		
		//if selected a file in a project, export the project folder instead
		for (int i = 0; i < aSel.Length; i++) if (aSel[i].FindProject(out var folder, out _)) aSel[i] = folder;
		aSel = aSel.Distinct().ToArray();
		
		var b = new wpfBuilder("Export selected files").WinSize(550);
		b.WinProperties(showInTaskbar: false);
		b.R.StartGrid<KGroupBox>("Files");
		b.R.xAddInfoBlockF($"Selected: {string.Join(", ", aSel.AsEnumerable())}");
		b.R.Add(out KCheckBox cDeps, "And files used via /*/ c, resource, file, preBuild, postBuild, icon, manifest, sign /*/")
			.Checked(0 != (App.Settings.export & 4));
		b.R.Add(out KCheckBox cGlobal, "And global.cs")
			.Margin(20).xBindCheckedEnabled(cDeps)
			.Checked(0 != (App.Settings.export & 8))
			.Tooltip("File global.cs and its /*/ c etc /*/ files.\nNote: when importing, this global.cs probably will be renamed to global2.cs because global.cs already exists. Users can rename, edit and include it where need like /*/ c renamed.cs /*/.");
		b.R.Add(out KCheckBox cPR, "And library projects used via /*/ pr /*/")
			.Margin(20).xBindCheckedEnabled(cDeps)
			.Checked(0 != (App.Settings.export & 16));
		b.End();
		b.R.StartGrid<KGroupBox>("Options");
		b.R.Add(out KCheckBox cZip, "Zip file")
			.Checked(0 != (App.Settings.export & 1))
			.Tooltip("Export as .zip file.\nIf unchecked, exports as folder. In any case it's a LibreAutomate workspace.");
		b.R.Add(out KCheckBox cLinks, "Add link target")
			.Checked(0 != (App.Settings.export & 2))
			.Tooltip("How to export links:\nChecked - export the link target instead.\nUnchecked - export the link; on other computers it probably will be invalid.");
		b.End();
		b.R.AddOkCancel();
		b.End();
		if (!b.ShowDialog(App.Wmain)) return false;
		bool zip = cZip.IsChecked, exportLinkTarget = cLinks.IsChecked, exportDeps = cDeps.IsChecked, exportGlobal = cGlobal.IsChecked, exportPR = cPR.IsChecked;
		App.Settings.export = (zip ? 1 : 0) | (exportLinkTarget ? 2 : 0) | (exportDeps ? 4 : 0) | (exportGlobal ? 8 : 0) | (exportPR ? 16 : 0);
		
		Save.AllNowIfNeed();
		
		string name = aSel[0].Name; if (!aSel[0].IsFolder) name = pathname.getNameNoExt(name);
		
		//if selected single folder, export its children without the folder
		if (aSel.Length == 1 && aSel[0].IsFolder && aSel[0].HasChildren) aSel = aSel[0].Children().ToArray();
		
		List<FileNode> aDeps = new();
		if (exportDeps && !_Deps()) return false;
		
		var fRoot = FileNode.CreateForExport();
		_Enum1(fRoot, aSel);
		void _Enum1(FileNode parent, IEnumerable<FileNode> e) {
			foreach (var f in e) {
				var fe = FileNode.CreateForExport(f, exportLinkTarget);
				parent.AddChild(fe);
				if (f.IsFolder) _Enum1(fe, f.Children());
			}
		}
		
		string wsDir;
		if (zip) {
			var d = new FileOpenSaveDialog("{4D1F3AFB-DA1A-45AC-8C12-41DDA5C51CDA}") {
				FileTypes = "Zip files|*.zip",
				DefaultExt = "zip",
				InitFolderFirstTime = location ?? folders.ThisAppDocuments,
				FileNameText = name + ".zip",
			};
			if (!d.ShowSave(out location, App.Hmain, overwritePrompt: false)) return false;
			wsDir = folders.ThisAppTemp + "Workspace zip";
			filesystem.delete(wsDir);
		} else {
			wsDir = GetDirectoryPathForNewWorkspace(name, location);
			if (wsDir == null) return false;
		}
		
		string filesDir = wsDir + @"\files";
		try {
			filesystem.createDirectory(filesDir);
			foreach (var f in aSel) {
				if (!(f.IsLink && !exportLinkTarget)) filesystem.copyTo(f.FilePath, filesDir);
			}
			
			if (exportLinkTarget) {
				foreach (var f in aSel) {
					if (f.IsFolder && !f.IsLink) {
						foreach (var v in f.Descendants()) {
							if (v.IsLink) filesystem.copy(v.FilePath, filesDir + "\\" + f.Name + v.ItemPathIn(f));
						}
					}
				}
			}
			
			if (aDeps.Count > 0) {
				var depsDirName = _GetUniqueNameForDepsFolder();
				var depsDir = filesDir + @"\" + depsDirName;
				filesystem.createDirectory(depsDir);
				FileNode fDeps = FileNode.CreateForExport(depsDirName);
				foreach (var f in aDeps) {
					if (!(f.IsLink && !exportLinkTarget)) filesystem.copyTo(f.FilePath, depsDir);
					var fe = FileNode.CreateForExport(f, exportLinkTarget);
					fDeps.AddChild(fe);
					if (f.IsFolder) _Enum1(fe, f.Children());
				}
				fRoot.AddChild(fDeps);
			}
			
			FileNode.Export(fRoot, wsDir + @"\files.xml");
		}
		catch (Exception ex) {
			print.it(ex);
			return false;
		}
		
		if (zip) {
			filesystem.delete(location);
			ZipFile.CreateFromDirectory(wsDir, location);
			filesystem.delete(wsDir);
			wsDir = location;
		}
		
		print.it($"<>Exported to <explore>{wsDir}<>");
		if (aDeps.Count > 0) print.it($"<>\tAdditional files: {string.Join(", ", aDeps.Select(o => o.SciLink()))}");
		return true;
		
		//adds meta c etc files
		bool _Deps() {
			HashSet<FileNode> hsAll = aSel.SelectMany(o => o.Descendants(andSelf: true)).ToHashSet(), hsParsed = new();
			HashSet<string> hsAllNames = new(hsAll.Select(o => o.Name), StringComparer.OrdinalIgnoreCase);
			bool failed = false;
			try { _Enum2(aSel); }
			catch (Exception ex) { failed = true; print.it("Can't export. Error: " + ex.Message); }
			return !failed;
			
			void _Enum2(IEnumerable<FileNode> e) {
				foreach (var f in e) {
					if (f.FindProject(out var fFolder, out var fMain)) {
						_ParseMeta(fMain, fFolder);
					} else if (f.IsCodeFile) {
						_ParseMeta(f);
					} else if (f.IsFolder) {
						_Enum2(f.Children());
					}
				}
				
				void _ParseMeta(FileNode f, FileNode projFolder = null) {
					if (hsParsed.Contains(f)) return;
					var m = new MetaComments(MCFlags.Export | (exportGlobal ? 0 : MCFlags.ExportNoGlobal) | (exportPR ? MCFlags.ExportPR : 0));
					exportGlobal = false;
					if (!m.Parse(f, projFolder)) {
						print.it($"<><lc #F0E080>Can't export additional files. Errors:<>\r\n{m.Errors}");
						failed = true;
						hsParsed.Add(f);
						return;
					}
					
					foreach (var c in m.CodeFiles) hsParsed.Add(c.f);
					if (m.ExportC_ is { } ac) { //meta `c fileOrFolder` (m.CodeFiles - only files)
						foreach (var c in ac) _Add(c);
					}
					if (m.Resources != null) foreach (var c in m.Resources) _Add(c.f); //meta `resource fileOrFolder`
					if (m.OtherFiles != null) foreach (var c in m.OtherFiles) _Add(c.f); //meta `file fileOrFolder`
					_Add(m.IconFile);
					_Add(m.ManifestFile);
					_Add(m.SignFile);
					_Add(m.PreBuild.f, true);
					_Add(m.PostBuild.f, true);
					if (m.ProjectReferences is { } pr) {
						foreach (var v in pr) _AddPR(v.f);
					}
					
					void _Add(FileNode f, bool parseMeta = false) {
						if (f != null && hsAll.Add(f)) {
							if (!hsAllNames.Add(f.Name)) throw new InvalidOperationException("Not unique name of additional file: " + f.Name); //don't allow duplicate names. Users would fail to compile.
							aDeps.Add(f);
							if (parseMeta) _ParseMeta(f);
						}
					}
					
					void _AddPR(FileNode f) {
						var folder = f.Parent.Name is ['@', ..] ? f.Parent : null;
						var ff = folder ?? f;
						if (hsAll.Add(ff)) {
							if (!hsAllNames.Add(ff.Name)) throw new InvalidOperationException("Not unique name of additional file: " + ff.Name);
							aDeps.Add(ff);
							_ParseMeta(f, folder);
						}
					}
				}
			}
		}
		
		string _GetUniqueNameForDepsFolder() {
			for (int i = 1; ; i++) {
				var s = i == 1 ? "Classes" : "Classes" + i;
				if (!aSel.Any(o => o.Name.Eqi(s))) return s;
			}
		}
	}
	
	#endregion
	
	#region fill menu
	
	/// <summary>
	/// Adds recent workspaces to submenu File > Workspace.
	/// </summary>
	public static void FillMenuRecentWorkspaces(MenuItem sub) {
		var mi = sub.Items[0] as MenuItem;
		mi.Header = App.Model.WorkspaceDirectory.Replace("_", "__");
		mi.FontWeight = FontWeights.Bold;
		
		sub.RemoveAllCustom();
		var ar = App.Settings.recentWS;
		int j = 0, i = 0, n = ar?.Length ?? 0;
		for (; i < n; i++) {
			if (sub.Items.Count >= 15 || !filesystem.exists(ar[i]).Directory) ar[i] = null;
			else sub.InsertCustom(++j, pathname.expand(ar[i]), LoadWorkspace);
		}
		if (j < i) App.Settings.recentWS = ar.Where(o => o != null).ToArray();
	}
	
	/// <summary>
	/// Adds templates to File > New.
	/// </summary>
	public static void FillMenuNew(MenuItem sub) {
		//rejected: call once, or if Templates\files.xml modified. Fast, don't need caching.
		
		var xroot = FileNode.Templates.LoadXml();
		sub.RemoveAllCustom();
		
		var isContextMenu = sub.Parent is ContextMenu;
		var templDir = FileNode.Templates.DefaultDirBS;
		_CreateMenu(sub, xroot, null, 0);
		
		void _CreateMenu(MenuItem mParent, XElement xParent, string dir, int level) {
			foreach (var x in xParent.Elements()) {
				string tag = x.Name.LocalName, name = x.Attr("n");
				int isFolder = tag == "d" ? 1 : 0;
				if (isFolder == 1) {
					isFolder = name[0] switch { '@' => 2, '!' => 3, _ => 1 }; //@ project, ! simple folder
				} else if (level == 0) {
					if (FileNode.Templates.IsStandardTemplateName(name, out _) || name == "File.txt") continue;
				}
				string relPath = dir + name;
				if (isFolder == 3) name = name[1..];
				var item = new MenuItem { Header = name.Replace("_", "__") };
				if (isFolder == 1) {
					_CreateMenu(item, x, relPath + "\\", level + 1);
				} else {
					item.Click += (_, e) => {
						s_inContextMenuCommand = isContextMenu;
						App.Model.NewItemX(x, beginRenaming: true);
						s_inContextMenuCommand = false;
					};
					var ft = FileNode.XmlTagToFileType(tag, canThrow: false);
					item.Icon = ft == FNType.Other
						? new Image { Source = icon.of(templDir + relPath)?.ToWpfImage() }
						: ImageUtil.LoadWpfImageElement(FileNode.GetFileTypeImageSource(ft));
				}
				mParent.InsertCustom(-1, item);
			}
		}
	}
	
	#endregion
	
	#region other
	
	//public List<FileNode> RootAndLinkFolders {
	//	get {
	//		if (_rootLF == null) {
	//			_rootLF = [];
	//			_rootLF.Add(Root);
	//			foreach (var f in Root.Descendants()) {
	//				if (f.IsLink && f.IsFolder) _rootLF.Add(f);
	//			}
	//		}
	//		return _rootLF;
	//	}
	//}
	//List<FileNode> _rootLF;
	
	internal void ChangedFolderItemPath_() {
		_syncWatchers?.UpdatePaths();
	}
	
	/// <summary>
	/// Adds some default files if missing.
	/// </summary>
	/// <param name="scriptForNewWorkspace">If empty workspace, creates new empty script from current template.</param>
	/// <param name="globalCs">If class file "global.cs" not found, creates it in existing or new folder "Classes".</param>
	public void AddMissingDefaultFiles(bool scriptForNewWorkspace = false, bool globalCs = false) {
		if (scriptForNewWorkspace && Root.FirstChild == null) {
			NewItem(@"Script.cs");
		}
		if (globalCs && null == FindGlobalCs(silent: true) && FoundMultiple == null) {
			var folder = Find(@"\Classes", FNFind.Folder) ?? NewItemL(null, new(Root, FNInsert.Last), "Classes");
			NewItemL(@"Default\global.cs", new(folder, FNInsert.Last));
		}
		//example of importing a default file as a link, as readonly
		//if (git && null == FindCodeFile("Git script.cs") && FoundMultiple == null) {
		//	var folder = Find(@"\Classes", FNFind.Folder) ?? NewItemL(null, new(Root, FNInsert.Last), "Classes");
		//	ImportFiles(new[] { folders.ThisAppBS + @"Templates\files\Default\Git script.cs" }, new(folder, FNInsert.Last), ImportFlags.Link | ImportFlags.DontPrint | ImportFlags.DontSelect);
		//}
	}
	
	public WorkspaceSettings.User UserSettings => WSSett.CurrentUser;
	
	public void RunStartupScripts(bool startAsync) {
		foreach (var (row, f) in GetStartupScriptsExceptDisabled(printNotFound: true)) {
			int delay = 0;
			if (row.Length > 1) {
				var sd = row[1];
				delay = sd.ToInt(0, out int end);
				if (end > 0 && !sd.Ends("ms", true)) delay = (int)Math.Min(delay * 1000L, int.MaxValue);
			}
			if (startAsync && delay < 10) delay = 10;
			if (delay > 0) {
				timer.after(delay, t => {
					CompileRun.CompileAndRun(true, f);
				});
			} else {
				CompileRun.CompileAndRun(true, f);
			}
		}
		Git.AutoBackup(true);
	}
	
	csvTable _GetStartupScripts() {
		if (UserSettings.startupScripts is var csv && !csv.NE()) {
			try { return csvTable.parse(csv); }
			catch (FormatException e1) { print.warning(e1); }
		}
		return null;
	}
	
	/// <summary>
	/// Gets startup scripts of this workspace, except those commented out or missing.
	/// </summary>
	/// <param name="printNotFound">Print not found scripts.</param>
	/// <returns>CSV row and the <b>FileNode</b> (null if not found).</returns>
	public IEnumerable<(string[] row, FileNode f)> GetStartupScriptsExceptDisabled(bool printNotFound = false) {
		if (_GetStartupScripts() is { } csv) {
			foreach (var row in csv.Rows) {
				string file = row[0];
				if (file.NE() || file.Starts("//")) continue;
				if (FindCodeFile(file) is { } f) yield return (row, f);
				else if (printNotFound) print.it("<>Startup script not found: " + file + ". Please edit <+options Workspace>Options > Workspace > Startup scripts<>.");
			}
		}
	}
	
	/// <summary>
	/// Finds <i>f</i> in startup scripts. If not found, adds to startup scripts.
	/// </summary>
	public EISSResult EnsureIsInStartupScripts(FileNode f, bool printAdded, bool usePath = false) {
		string itemPath = f.ItemPath;
		string itemPathOrName = usePath ? itemPath : f.ItemPathOrName();
		var ss = App.Model.UserSettings.startupScripts;
		if (ss.NE()) {
			ss = itemPathOrName;
		} else {
			if (_GetStartupScripts() is not { } csv) return EISSResult.Failed;
			string name = f.Name, name2 = f.DisplayName;
			if (csv.Rows.FirstOrDefault(a => a[0].AsSpan(a[0].Starts("//") ? 2 : 0) is var s && (s.Eqi(itemPath) || s.Eqi(name) || s.Eqi(name2))) is { } a) {
				if (!a[0].Starts("//")) return EISSResult.FoundEnabled;
				//rejected. It may be set to run from other startup script.
				//if (printDisabled) print.it($"<>Note: script \"{itemPathOrName}\" is not set to run at startup. In <+options Workspace>Options > Workspace > Startup scripts<> remove the // prefix.");
				return EISSResult.FoundDisabled;
			}
			csv.AddRow(itemPathOrName);
			ss = csv.ToString();
		}
		
		//if Options is open...
		if (KDialogWindow.GetSingle<DOptions>(out var dOptions)) {
			DOptions.AaShow(DOptions.EPage.Workspace);
			clipboard.text = itemPathOrName;
			dialog.show(null, $"Please add this to Options > Workspace > Startup scripts.\nIt's now in the clipboard.\n\n{itemPathOrName}", owner: dOptions);
			return EISSResult.Failed;
		}
		
		App.Model.UserSettings.startupScripts = ss;
		if (printAdded) print.it($"<>Info: script \"{itemPathOrName}\" has been added to <+options Workspace>Options > Workspace > Startup scripts<>. If unwanted, disable the line (prefix //).");
		return EISSResult.Added;
	}
	public enum EISSResult { FoundEnabled, FoundDisabled, Added, Failed }
	
	//Used mostly by SciCode, but owned by workspace because can go to any file.
	internal readonly EditGoBack EditGoBack = new();
	
	#endregion
	
	#region util
	
	/// <summary>
	/// Calls <i>action</i> in try/catch, and manages filesystem sync. On exception prints message and returns false.
	/// </summary>
	public bool TryFileOperation(FOSync fos, Action action) {
		_syncWatchers?.FileOperationStarted(fos);
		try { action(); return true; }
		catch (Exception ex) { print.warning(ex); return false; }
		finally { _syncWatchers?.FileOperationEnded(fos); }
	}
	
	/// <summary>
	/// Calls <i>action</i> and manages filesystem sync. Does not handle exceptions.
	/// </summary>
	/// <exception cref="Exception"></exception>
	public void FileOperation(FOSync fos, Action action) {
		_syncWatchers?.FileOperationStarted(fos);
		try { action(); }
		finally { _syncWatchers?.FileOperationEnded(fos); }
	}
	
	/// <summary>
	/// Returns true if FileNode f is not null and belongs to this FilesModel and is not deleted.
	/// </summary>
	public bool IsMyFileNode(FileNode f) { return Root.IsAncestorOf(f); }
	
	/// <summary>
	/// Returns true if s is path of a workspace directory or .zip file.
	/// </summary>
	public static bool IsWorkspaceDirectoryOrZip(string path, out bool zip) {
		zip = false;
		switch (filesystem.exists(path)) {
		case 2:
			string xmlFile = path + @"\files.xml";
			if (filesystem.exists(xmlFile).File && filesystem.exists(path + @"\files").Directory) {
				try { return XmlUtil.LoadElem(xmlFile).Name == "files"; } catch { }
			}
			break;
		case 1 when path.Ends(".zip", true):
			return zip = true;
		}
		return false;
	}
	
	/// <summary>
	/// If s is path of a workspace directory or .zip file, shows "Open/import" dialog and returns true.
	/// dialogResult receives: 1 Open, 2 Import, 0 Cancel.
	/// </summary>
	public static bool IsWorkspaceDirectoryOrZip_ShowDialogOpenImport(string path, out int dialogResult) {
		dialogResult = 0;
		if (!IsWorkspaceDirectoryOrZip(path, out bool zip)) return false;
		var text1 = zip ? "Import files from zip" : "Workspace";
		var buttons = zip ? "2 Import|0 Cancel" : "1 Open|2 Import|0 Cancel";
		dialogResult = dialog.show(text1, path, buttons, footer: GetSecurityInfo("v|"), owner: TreeControl);
		return true;
	}
	
	/// <summary>
	/// Security info string.
	/// </summary>
	public static string GetSecurityInfo(string prefix = null) {
		return prefix + "Security info: Unknown C# script files can contain malicious code - virus, spyware, etc. It is safe to import, open and edit C# files if you don't run them. Triggers don't work until run.";
	}
	
	#endregion
}

[Flags]
enum ImportFlags {
	Copy = 1,
	Move = 2,
	Link = 4,
	DontSelect = 8,
	DontPrint = 16,
}


================================================
FILE: Au.Editor/Files/FilesView.cs
================================================
using Au.Controls;
using System.Windows.Input;
using System.Windows;
using System.Windows.Controls;

namespace LA;

partial class FilesModel {
	public class FilesView : KTreeView {
		public FilesView() {
			SetMultiSelect(toggle: false);
			FullRowExpand = true;
			AllowDrop = true;

			ItemActivated += _ItemActivated;
			ItemClick += _ItemClick;

			ItemDragStart += _ItemDragStart;

			FilesModel.NeedRedraw += v => { if (v.f != null) Redraw(v.f, v.remeasure); else Redraw(v.remeasure); };

			App.Commands.BindKeysTarget(this, "Files");
		}

		public void SetItems() {
			base.SetItems(App.Model.Root.Children());
		}

		public void SetMultiSelect(bool toggle) {
			bool multi = App.Settings.files_multiSelect;
			if (toggle) App.Settings.files_multiSelect = (multi ^= true);
			MultiSelect = multi;
			SingleClickActivate = !multi;
			App.Commands[nameof(Menus.File.CopyPaste.MultiSelect_files)].Checked = multi;
		}

		private void _ItemActivated(TVItemEventArgs e) {
			var f = e.Item as FileNode;
			if (f.IsFolder) {
				if (e.ClickCount == 0) TreeControl.Expand(f, true);
			} else {
				var m = App.Model;
				if (e.ClickCount == 0 && f == m.CurrentFile) Panels.Editor.ActiveDoc?.Focus(); //let Enter set focus = active doc
				else m._SetCurrentFile(f, focusEditor: e.ClickCount switch { 1 => null, 2 => true, _ => false });
			}
		}

		private void _ItemClick(TVItemEventArgs e) {
			if (e.Mod != 0) return;
			var f = e.Item as FileNode;
			switch (e.Button) {
			case MouseButton.Right:
				Dispatcher.InvokeAsync(() => App.Model._ItemRightClicked(f));
				break;
			case MouseButton.Middle:
				App.Model.CloseFiles(f);
				break;
			}
		}

		protected override void OnKeyDown(KeyEventArgs e) {
			base.OnKeyDown(e);
			if (e.Handled || base.EditingLabel) return;
			var m = App.Model;
			switch ((e.KeyboardDevice.Modifiers, e.Key)) {
			case (0, Key.Delete): m.DeleteSelected(); break;
			case (ModifierKeys.Control, Key.X): m.CutCopySelected(true); break;
			case (ModifierKeys.Control, Key.C): m.CutCopySelected(false); break;
			case (ModifierKeys.Control, Key.V): m.Paste(); break;
			case (0, Key.Escape): m.Uncut(); break;
			default: return;
			}
			e.Handled = true;
		}

		protected override void OnContextMenuOpening(ContextMenuEventArgs e) {
			App.Model._ContextMenu();
		}

		public new FileNode[] SelectedItems => base.SelectedItems.Cast<FileNode>().ToArray();

		#region drag-drop

		private void _ItemDragStart(TVItemEventArgs e) {
			if (e.Button != MouseButton.Left) return;
			//if(e.Item.IsFolder && e.Item.IsExpanded) Expand(e.Index, false);
			var a = IsSelected(e.Index) ? SelectedItems : new FileNode[] { e.Item as FileNode };
			DragDropFiles = a;
			DragDrop.DoDragDrop(this, new DataObject(typeof(FileNode[]), a), DragDropEffects.Move | DragDropEffects.Copy);
			DragDropFiles = null;
		}

		public FileNode[] DragDropFiles { get; private set; }

		protected override void OnDragOver(DragEventArgs e) {
			e.Handled = true;
			bool can = _DragDrop(e, false);
			OnDragOver2(can);
			base.OnDragOver(e);
		}

		protected override void OnDrop(DragEventArgs e) {
			e.Handled = true;
			_DragDrop(e, true);
			base.OnDrop(e);
		}

		bool _DragDrop(DragEventArgs e, bool drop) {
			bool can;
			FileNode[] nodes = null;
			if (can = e.Data.GetDataPresent(typeof(FileNode[]))) {
				nodes = e.Data.GetData(typeof(FileNode[])) as FileNode[];
				GetDropInfo(out var d);
				if (d.targetItem is FileNode target) {
					bool no = false;
					foreach (FileNode v in nodes) {
						if (d.intoFolder) {
							no = v == target || target.IsDescendantOf(v);
						} else {
							no = target.IsDescendantOf(v);
						}
						if (no) break;
					}
					can = !no;
				}
			} else {
				can = e.Data.GetDataPresent(DataFormats.FileDrop);
			}

			if (can) {
				//convert multiple effects to single
				switch (e.KeyStates & (DragDropKeyStates.ControlKey | DragDropKeyStates.ShiftKey)) {
				case DragDropKeyStates.ControlKey: e.Effects &= DragDropEffects.Copy; break;
				case DragDropKeyStates.ShiftKey: e.Effects &= DragDropEffects.Move; break;
				case DragDropKeyStates.ControlKey | DragDropKeyStates.ShiftKey: e.Effects &= DragDropEffects.Link; break;
				default:
					if (e.Effects.Has(DragDropEffects.Move)) e.Effects = DragDropEffects.Move;
					else if (e.Effects.Has(DragDropEffects.Link)) e.Effects = DragDropEffects.Link;
					else if (e.Effects.Has(DragDropEffects.Copy)) e.Effects = DragDropEffects.Copy;
					else e.Effects = 0;
					break;
				}
			} else {
				e.Effects = 0;
			}
			if (e.Effects == 0) return false;

			if (drop) {
				var files = nodes == null ? e.Data.GetData(DataFormats.FileDrop) as string[] : null;
				GetDropInfo(out var d);
				var pos = d.intoFolder ? FNInsert.Last : (d.insertAfter ? FNInsert.After : FNInsert.Before);
				Dispatcher.InvokeAsync(() => App.Model._DroppedOrPasted(nodes, files, new(d.targetItem as FileNode, pos), e.Effects == DragDropEffects.Copy));
			}
			return true;
		}

		#endregion
	}
}

//Tested Jdenticon library that generates random icons. Works well, but the icons are too abstract and monotonic.
//partial class FileNode
//{
//	System.Drawing.Bitmap ITreeViewItem.Image {
//		get {
//			if (_bmp == null && 0 != Name.Like(true, "Script14?.cs", "Script13?.cs")) {
//				var v = Identicon.FromValue(Name, size: 16);
//				v.Style = new IdenticonStyle { BackColor = Jdenticon.Rendering.Color.Transparent/*, ColorSaturation=0.7f, ColorLightness = new(0.1f, 0.5f)*/ };
//				using var stream = v.SaveAsPng();
//				_bmp = System.Drawing.Bitmap.FromStream(stream) as System.Drawing.Bitmap;
//			}
//			return _bmp;
//		}
//	}
//	System.Drawing.Bitmap _bmp;
//}


================================================
FILE: Au.Editor/Files/Git.cs
================================================
using System.Windows;
using System.Windows.Controls;
using System.Windows.Media;
using System.Windows.Documents;
using System.Text.Json.Nodes;
using Au.Controls;
using System.Net.Http;

namespace LA;

static partial class Git {
	static string _gitExe, //git.exe path
		_dir, //workspace dir
		_go; //git output. If failed, it is "[exitcode] output".
	static bool _isPrivateGit;
	const string c_defaultGitignore = """
/.nuget/*/*
/.interop/
/exe/
/dll/

# Don't change these defaults
!/.nuget/*/*.csproj
/.compiled/
/.temp/

""";
	
	static bool _Start(bool setup = false) {
		if (_gitExe == null || setup || _dir != App.Model.WorkspaceDirectory) {
			_dir = App.Model.WorkspaceDirectory;
			if (!setup) if (!filesystem.exists(_dir + @"\.git").Directory) return false;
			if (!_FindGit(out _gitExe, out _isPrivateGit)) return false;
		}
		return true;
	}
	
	static bool _FindGit(out string path, out bool isPrivate) {
		var gitDir = folders.ThisAppBS + "Git";
		path = gitDir + @"\cmd\git.exe"; //or @"\mingw64\bin\git.exe"
		if (isPrivate = filesystem.exists(path) && !Downloader.IsDirectoryInvalid(gitDir)) return true;
		return null != (path = filesystem.searchPath("git.exe") ?? filesystem.searchPath(folders.ProgramFiles + @"Git\cmd\git.exe"));
	}
	
	#region commands
	
	static bool _InitCommand() {
		bool ok = _Start();
		if (ok) {
			if (!_EnsureMain()) return false;
			App.Model.Save.AllNowIfNeed();
			_CheckIgnored();
		} else if (t_autoBackup) {
			print.it("Auto-backup error. To fix it use menu File > Git > Git setup.");
		} else {
			Setup();
		}
		return ok;
		
		static bool _EnsureMain() {
			if (!gits("branch --show-current")) return false;
			if (_go != "main") {
				if (t_autoBackup) { print.it("Auto-backup error: not main branch."); return false; }
				if (!dialog.showOkCancel("Switch to main branch?", $"The Git command can work only with the main branch.\nCurrent branch is '{_go}'.", owner: App.Hmain)) return false;
				if (!git("switch main")) return false;
			}
			return true;
		}
		
		static void _CheckIgnored() {
			bool i1 = false, i2 = false, i3 = false;
			if (gits(@"check-ignore .compiled/* .temp/* .nuget/*/*.csproj")) {
				i1 = _go.Contains(".comp");
				i2 = _go.Contains(".temp");
				i3 = _go.Contains(".nuge");
			}
			if (!i1 || !i2 || i3) {
				string file = _dir + @"\.gitignore", s;
				if (filesystem.exists(file)) {
					s = filesystem.loadText(file) + "\r\n";
					if (!i1) s += "/./compiled\r\n";
					if (!i2) s += "/.temp/\r\n";
					if (i3) s += "!/.nuget/*/*.csproj\r\n";
				} else {
					s = c_defaultGitignore;
				}
				filesystem.saveText(file, s);
			}
		}
	}
	
	static void _Thread(Action func) {
		if (_InitCommand()) run.thread(func);
	}
	
	static bool _NotThread => App.IsMainThread;
	
#if DEBUG
	public static void Test() {
		if (_NotThread) { _Thread(Test); return; }
		
		//gita("");
	}
#endif
	
	public static void Status() {
		if (_NotThread) { _Thread(Status); return; }
		
		print.it(_GetStatus(true));
	}
	
	static bool _Commit(string m = null) {
		if (m == null) {
			m = "backup";
			do {
				if (!dialog.showInput(out m, "Git commit", "Message", editText: m, owner: App.Hmain,
					footer: new("Print:    <a href=\"status\">status</a>", _Link)
					)) return false;
			} while (m.NE());
		}
		m = m.Replace("\"", "''");
		
		if (!git("add .")) return false;
		if (!git($"commit -m \"{m}\"")) return false;
		return true;
	}
	
	public static void Commit(bool autoBackup = false, int autoBackupWorkspaceSN = 0) {
		if (_NotThread) { _Thread(() => Commit(autoBackup, autoBackupWorkspaceSN)); return; }
		
		if (autoBackup && App.Model.WorkspaceSN != autoBackupWorkspaceSN) return; //this code runs async with a delay and in new thread. During that time can be loaded another workspace.
		t_autoBackup = autoBackup;
		try {
			var gs = _GetStatus();
			if (!gs.CanCommit) _Print("Nothing to commit.");
			else if (_Commit(autoBackup ? "auto-backup" : null)) _Print("==== DONE ====");
			else if (autoBackup) print.it("Auto-backup failed. Try menu File > Git > Commit."); //else git() prints errors
		}
		catch (Exception e1) { print.it((autoBackup ? "Auto-backup: " : null) + "Git commit failed", e1); }
		finally { t_autoBackup = false; }
		
		static void _Print(string s) {
			if (!t_autoBackup) print.it(s);
		}
	}
	[ThreadStatic] static bool t_autoBackup;
	
	public static void Push() {
		if (_NotThread) { _Thread(Push); return; }
		
		var gs = _GetStatus(); //note: don't use _GetStatus(true) to detect whether need to push. In some cases it can't detect local and remote differences, eg after modifying the local commit history. Also makes slower.
		if (gs.CanCommit) if (!_Commit()) return;
		if (!git("push")) {
			gs = _GetStatus(true);
			string s1, s2;
			if (gs.behind > 0) {
				s1 = $"Exist {gs.ahead} local and {gs.behind} remote new different commits.";
				s2 = "0 Cancel|1 Overwrite remote\ngit push --force|2 Pull instead...\nYou can keep local or remote commits";
			} else { //eg after modifying the local commit history
				s1 = "The safe 'git push' command failed.";
				s2 = "0 Cancel|1 Try 'git push --force'\nIt overwrites remote commits.";
			}
			switch (dialog.show("Git push", s1, s2, DFlags.CommandLinks, DIcon.Warning, owner: App.Hmain)) {
			case 1:
				if (!git("push --force")) return;
				break;
			case 2:
				Pull();
				return;
			default: return;
			}
		} else if (_go == "Everything up-to-date") {
			print.it("==== Nothing to push ====");
			return;
		}
		print.it("==== DONE ====");
	}
	
	public static void Pull() {
		if (_NotThread) { _Thread(Pull); return; }
		
		if (!git("fetch")) return;
		var gs = _GetStatus();
		if (gs.behind == 0) { print.it("==== No new remote commits ===="); return; }
		
		//refuse to pull if there are uncommitted changes
		bool stashed = false;
		if (gs.CanCommit) {
			//changes in the .state dir are likely. They are not important and can be dropped. The .toolbars dir is similar.
			//	If uncommitted changes are only in these dirs: Now stash. Finally drop if successful, else restore.
			if (!gs.changes.Any(o => !(o.Eq(3, ".state/", true) || o.Eq(3, ".toolbars/", true)))) stashed = gits("stash");
			if (!stashed) {
				if (1 != dialog.show("Before git pull", "Need to commit, else new local changes would be lost. Commit now?",
					"1 OK|Cancel", owner: App.Hmain,
					footer: new("Print:    <a href=\"status\">status</a>", _Link)
					)) return;
				if (!_Commit()) return;
				gs.ahead++;
			}
		}
		
		bool stashDrop = false, push = false;
		try {
			if (gs.ahead > 0) {
				//note: don't merge. It can damage files, eg files.xml.
				int button = dialog.show("Git pull", $"Exist {gs.ahead} local and {gs.behind} remote new different commits.                                              ",
					"0 Cancel|1 Keep remote\nDiscards new local changes and applies remote changes.\nAt first backups the new local commits in a new branch.\nFinally reloads the workspace.|2 Keep local\nDoes not modify the workspace.\nInserts the new remote commits before the new local commits.",
					flags: DFlags.CommandLinks | DFlags.ExpandDown, icon: DIcon.Warning, owner: App.Hmain,
					expandedText: "You can click Cancel and use eg GitHubDesktop to pull. It allows to merge remote changes and resolve possible conflicts. Be careful, it can damage some files.\n\nTo avoid this, always pull before making changes in the workspace.",
					footer: new("Print:    <a href=\"diff\">diff for 'keep remote'</a>    <a href=\"diffR\">diff for 'keep local'</a>", _Link)
					);
				
				if (button == 1) {
					if (!git($"branch {DateTime.Now.ToString("yyyy-MM-dd--HH-mm-ss")}")) return;
					if (!git("reset --hard origin/main")) return;
				} else if (button == 2) {
					if (!git("merge -s ours")) return;
					push = true;
				} else return;
			} else {
				DControls dc = new() { Checkbox = "Backup workspace files", IsChecked = !ScriptEditor.IsPortable };
				if (1 != dialog.show("Git pull", "Will update your local repo and workspace files to match the remote repo.\nFinally will reload the workspace.",
					"1 OK|Cancel", owner: App.Hmain, controls: dc)) return;
				if (dc.IsChecked) _BackupWorkspace();
				if (!git("merge --ff-only")) return;
				if (_go.Starts("Already up to date")) { print.it("==== No new remote commits ===="); return; }
			}
			stashDrop = !push;
		}
		finally {
			if (stashed) {
				if (stashDrop) gits("stash drop"); else gits("stash pop");
			}
		}
		print.it("==== DONE ====");
		
		if (push) {
			//print.it("Now you can push to GitHub. It will add the new local commits to the GitHub repo.");
			if (dialog.showYesNo("Now push to GitHub?", "It will add the new local commits to the GitHub repo.\nOr you can click No and push later.", owner: App.Hmain)) {
				if (!git("push")) return;
				print.it("==== DONE ====");
			}
		} else {
			App.Dispatcher.InvokeAsync(ReloadWorkspace);
		}
	}
	
	public static void RunGui() {
		if (!_InitCommand()) return;
		
		var s = Microsoft.Win32.Registry.GetValue(@"HKEY_CLASSES_ROOT\x-github-client\shell\open\command", "", null) as string;
		if (s != null) {
			s = s.Split(' ')[0].Trim('"');
			if (!filesystem.exists(s)) s = null;
		}
		s ??= folders.LocalAppData + @"GitHubDesktop\GitHubDesktop.exe";
		if (filesystem.exists(s)) run.itSafe(s, null, RFlags.InheritAdmin); else print.it("<>GitHubDesktop not found. <link https://desktop.github.com/>Download<>.");
	}
	
	public static void RunCmd() {
		if (!_InitCommand()) return;
		
		string oldPath = null;
		if (_isPrivateGit) Environment.SetEnvironmentVariable("PATH", pathname.getDirectory(_gitExe) + ";" + (oldPath = Environment.GetEnvironmentVariable("PATH")));
		run.itSafe(folders.System + "cmd.exe", null, RFlags.InheritAdmin, _dir);
		if (_isPrivateGit) Environment.SetEnvironmentVariable("PATH", oldPath);
	}
	
	public static void WorkspaceFolder() {
		run.itSafe(App.Model.WorkspaceDirectory);
	}
	
	public static void ReloadWorkspace() {
		FilesModel.LoadWorkspace(App.Model.WorkspaceDirectory);
	}
	
	public static void Signout() {
		if (_NotThread) { _Thread(Signout); return; }
		
		if (!gits("config --get remote.origin.url")) return;
		_go.RxMatch(@"^https://github.com/(.+?)/", 1, out string user);
		if (!git("credential reject", stdin: $"protocol=https\nhost=github.com\nusername={user}\n\n")) return;
		print.it("==== DONE ====");
	}
	
	public static void Maintenance() {
		if (!_InitCommand()) return;
		
		var w = new KDialogWindow() { Title = "Git repository maintenance", ShowInTaskbar = false, Owner = App.Wmain };
		var b = new wpfBuilder(w).WinSize(400);
		
		var info = new System.Windows.Documents.Run();
		_Info();
		b.R.xAddInfoBlockF($"""
The local repository is folder <a {() => { var s1 = _dir + @"\.git"; filesystem.setAttributes(s1, FileAttributes.Hidden, false); run.selectInExplorer(s1); }}>.git</a> in the workspace folder.
{info}
Use this tool to make it smaller or delete old commits or branches.
This tool modifies only the .git folder, not workspace files.
""");
		
		b.R.xAddGroupSeparator("Safe tasks");
		b.R.AddButton("Run 'git gc' to compact the folder", async _ => {
			w.IsEnabled = false;
			await Task.Run(() => _Gc());
			_Info();
			w.IsEnabled = true;
		}).Tooltip("Collects garbage. Packs and compresses files.\nDoes not change the history, branches, etc.");
		
		b.R.xAddGroupSeparator("Destructive tasks");
		b.R.AddButton("Delete branch...", _ => _Branches());
		b.R.AddButton("Delete old commits...", _ => _DeleteOldCommits());
		
		b.R.xAddGroupSeparator("Info");
		b.R.AddButton("Print workspace folder sizes", _ => _PrintFolderSizes()).Tooltip("Print sizes of workspace folders except .git, .compiled and .temp.\nThis info can be useful when editing file .gitignore.");
		
		b.End();
		w.Show(); //not ShowDialog
		
		void _Info() {
			int nFiles = 0, nDirs = 0;
			long size = filesystem.enumerate(_dir + "\\.git", FEFlags.AllDescendants | FEFlags.IgnoreInaccessible).Sum(o => { if (o.IsDirectory) { nDirs++; return 0; } nFiles++; return o.Size; });
			gits("rev-list --count HEAD");
			info.Text = $"Size {size / 1024 / 1024} MB. Contains {nFiles} files and {nDirs} folders.\nThe main branch contains {_go} commits.";
		}
		
		static void _Gc() {
			//something adds readonly attribute to many dirs in .git/objects. Then git gc cannot delete them.
			foreach (var v in filesystem.enumDirectories(_dir + @"\.git\objects")) {
				//print.it(v.Attributes, v.Name);
				if (v.Attributes.Has(FileAttributes.ReadOnly)) {
					try { File.SetAttributes(v.FullPath, FileAttributes.Directory); } catch { }
				}
			}
			git("reflog expire --all --expire=now"); //need after deleting old commits, else does not make smaller
			git("gc --aggressive --prune=now");
			//run.it("cmd.exe", $"/c \"{gitExe}\" gc --aggressive --prune=now", RFlags.InheritAdmin | RFlags.WaitForExit, _dir);
			print.it("==== DONE ====");
		}
		
		void _Branches() {
			if (!gits("branch")) return;
			var m = new popupMenu();
			foreach (var v in _go.Lines()) {
				if (v.Starts('*')) m.Add(v).IsDisabled = true;
				else m[v.TrimStart()] = _DeleteBranch;
			}
			m.Show();
			
			void _DeleteBranch(PMItem mi) {
				var s = mi.Text;
				if (1 != dialog.show("Delete branch?", s + "\n\nThis action cannot be undone.", "0 Cancel|1 Delete", icon: DIcon.Warning, owner: w)) return;
				if (!git($"branch -D \"{s}\"")) return;
				_Info();
				print.it("==== DONE ====");
			}
		}
		
		async void _DeleteOldCommits() {
			if (1 != dialog.show("Deleting old commits", "This will delete all commits except the last.\nThen will push to GitHub.\n\nThis action cannot be undone.", "0 Cancel|1 Delete", icon: DIcon.Warning, owner: w)) return;
			w.IsEnabled = false;
			await Task.Run(() => {
				if (!git("checkout --orphan m7j9u447352k")) return;
				if (!git("add .")) return;
				if (!git($"commit -m \"Deleted old commits\"")) return;
				if (!git("branch -D main")) return;
				if (!git("branch -m main")) return;
				git("push --force");
				_Gc();
			});
			_Info();
			w.IsEnabled = true;
			
			//Also tried to delete old commits older than a selected commit. But could not find how to do it correctly.
			//	Git rebase fails (errors etc).
			//	Git clone shallow works, but does not delete remote commits.
		}
		
		static void _PrintFolderSizes() {
			FileTree.PrintSizes(_dir, true, .1, dirFilter: o => !(o.Level is 0 && o.Name.Lower() is ".git" or ".compiled" or ".temp"));
		}
	}
	
	public static void AutoBackup(bool now) {
		if (!App.Model.UserSettings.gitBackup) return;
		if (!CodeInfo.IsReadyForEditing) return;
		if (!now && _autoBackupTime != 0 && Environment.TickCount64 - _autoBackupTime < 1000 * 60 * 60 * 4) return; //4 hours
		_autoBackupTime = Environment.TickCount64;
		var wsSN = App.Model.WorkspaceSN;
		timer.after(500, _ => {
			//print.it("auto-backup", DateTime.Now);
			Commit(autoBackup: true, autoBackupWorkspaceSN: wsSN);
		});
	}
	static long _autoBackupTime;
	
	#endregion
	
	#region setup
	
	public static bool IsReady => _Start();
	
	public static void Setup() {
		new _DSetup().ShowDialog();
	}
	
	class _DSetup : KDialogWindow {
		public _DSetup() {
			_Start(setup: true);
			
			InitWinProp("Git setup", App.Wmain);
			var b = new wpfBuilder(this).WinSize(500).Columns(0, -1, 0);
			var panel = b.Panel;
			TextBox tUrl = null;
			
			b.R.StartGrid();
			Action lHelp = () => HelpUtil.AuHelp("editor/Git, backup, sync"),
				lGithub = () => run.itSafe(tUrl.TextOrNull() ?? "https://github.com");
			b.Add<TextBlock>().FormatText($"<a {lHelp}>Help</a>    <a href='{_dir}'>Workspace folder</a>    <a {lGithub}>GitHub</a>").Align(y: VerticalAlignment.Center);
			b.End();
			
			b.R.xAddGroupSeparator("GitHub repository");
			var url = _GetURL();
			b.R.Add<AdornerDecorator>("URL", out _).Child().Add(out tUrl, url).Watermark("https://github.com/owner/repo")
				.Validation(o => !_ParseURL(tUrl.Text, out _, out _) ? (tUrl.Text.NE() ? "URL empty" : "URL must be like https://github.com/owner/repo") : null);
			
			b.R.xAddGroupSeparator("Git");
			CancellationTokenSource cts = null;
			Button bGitInstall = null;
			b.R.Add(out TextBlock tGitStatus).Span(2).AddButton(out bGitInstall, "", _InstallGit)
				.Validation(o => !_FindGit(out _, out _) ? "Git not installed" : null);
			_SetGitControlText();
			b.Window.Closed += (_, _) => { cts?.Cancel(); };
			
			b.R.AddSeparator();
			b.R.Add("OK", out ComboBox cbOK).Items(filesystem.exists(_dir + @"\.git").Directory ? "Update local settings" : "Create local repository linked with the still empty GitHub repository", "Clone (download) the GitHub repository to new workspace");
			b.R.AddOkCancel();
			b.End();
			
			b.OkApply += async e => {
				e.Cancel = true;
				App.Model.UserSettings.gitUrl = tUrl.Text;
				_Start(setup: true); //may need to set _gitExe
				var w = b.Window.Hwnd();
				b.Window.IsEnabled = false; //disables controls but allows to close the window, unlike b.Window.Hwnd().Enable(false);. Git may hang, eg when auth fails on my vmware Win7.
				bool ok = false, clone = cbOK.SelectedIndex == 1;
				try {
					ok = await Task.Run(() => _OkTask(clone));
				}
				catch (Exception e1) { print.it(e1); }
				if (ok) b.Window.Close(); else b.Window.IsEnabled = true;
			};
			
			async void _InstallGit(WBButtonClickArgs k) {
				k.Button.IsEnabled = false;
				try {
					using var dl = new Downloader();
					if (dl.PrepareDirectory(folders.ThisAppBS + "Git")) {
						//get URL of the latest mingit zip
						tGitStatus.Text = "Getting the download URL (GitHub)";
						var r = await _GithubGetAsync($"repos/git-for-windows/git/releases/latest");
						r = r["assets"].AsArray().First(o => ((string)o["name"]).RxIsMatch(@"(?i)MinGit-[\d\.]+-64-bit.zip")); //note: not busybox; it's smaller and worked, but now fails.
						string url = (string)r["browser_download_url"];
						
						cts = new();
						await dl.DownloadAndExtract(url, tGitStatus, cts.Token);
						cts = null;
					}
				}
				catch (Exception ex) { print.warning(ex); }
				_SetGitControlText();
				k.Button.IsEnabled = true;
			}
			
			void _SetGitControlText() {
				bool found = _FindGit(out _, out bool isPrivate);
				tGitStatus.Text = !found ? "Git not installed" : isPrivate ? "Private Git is installed and will be used" : "Shared Git found and will be used";
				bGitInstall.Content = isPrivate ? "Update private Git" : "Install private Git";
			}
		}
		
		protected override void OnSourceInitialized(EventArgs e) {
			App.Model.UnloadingThisWorkspace += Close;
			base.OnSourceInitialized(e);
		}
		
		protected override void OnClosed(EventArgs e) {
			App.Model.UnloadingThisWorkspace -= Close;
			base.OnClosed(e);
		}
		
		static bool _OkTask(bool clone) {
			var url = App.Model.UserSettings.gitUrl;
			if (!url.Ends(".git")) url += ".git";
			
			if (clone) {
				var dir2 = pathname.makeUnique(_dir, isDirectory: true);
				bool cloned = git($"clone \"{url}\" \"{dir2}\"");
				if (cloned && !(cloned = FilesModel.IsWorkspaceDirectoryOrZip(dir2, out _))) print.it("Error. The GitHub repository does not contain a workspace.");
				if (!cloned) { filesystem.delete(dir2); return false; }
				
				var dir3 = _dir; _dir = dir2;
				try { _Config(); }
				finally { _dir = dir3; }
				
				Panels.Output.Scintilla.AaTags.AddLinkTag("+openWorkspace", s => FilesModel.LoadWorkspace(dir2));
				print.it($"<>The GitHub repository has been cloned to <link {dir2}>new workspace folder<>. Now you can <+openWorkspace {dir2}>open the new workspace<>. Also you may want to copy some files from <link {_dir}>old workspace<>.");
			} else {
				var file1 = _dir + "\\.gitignore";
				if (!filesystem.exists(file1)) filesystem.saveText(file1, c_defaultGitignore);
				
				var file2 = _dir + "\\.gitattributes";
				if (!filesystem.exists(file2)) filesystem.saveText(file2, """
* -text
/.state/* binary

""");
				
				bool localExists = filesystem.exists(_dir + @"\.git").Directory;
				if (localExists && gits("remote get-url origin") && _go == url) return true;
				
				//repo exists?
				if (!git($"ls-remote {url}")) return false;
				//rejected: try to create repo now.
				//	To get token, see the commented out _GithubGet overload.
				
				if (localExists) {
					if (!git("remote set-url origin " + url)) return false;
				} else {
					//repo empty?
					if (!_go.NE()) {
						print.it("Error. The GitHub repository must be empty (0 commits, no readme etc). Else it can only be cloned.");
						return false;
					}
					
					//repo private?
					_ParseURL(url, out var owner, out var repo); //info: the dialog validates the URL format
					var r = _GithubGet($"users/{owner}/repos");
					if (r.AsArray().Any(v => ((string)v["name"]).Eqi(repo))) {
						print.it("Error. The GitHub repository must be private. You can make it public later if really need.");
						return false;
					}
					
					if (!git("init -b main")) return false;
					if (!git("remote add origin " + url)) return false;
					if (!git("config push.autoSetupRemote true")) return false;
					_Config();
					print.it("<>Local Git repository has been created. Now you can use the Git menu to make backups etc.  [<help editor/git, backup, sync>Help<>]");
				}
			}
			return true;
			
			void _Config() {
				git("config core.autocrlf false");
				git("config core.quotepath off");
				
				if (!gits("config --get user.name") || _go.NE()) git("config user.name \"unknown\"");
				if (!gits("config --get user.email") || _go.NE()) git("config user.email \"unknown@unknown.com\"");
			}
		}
		
		static bool _ParseURL(string url, out string owner, out string repo) {
			if (!url.RxMatch(@"^https://github.com/([[:alnum:]\-]+)/([\w\-\.]+?)(?:\.git)?$", out var m)) { owner = repo = null; return false; }
			owner = m[1].Value;
			repo = m[2].Value;
			return true;
		}
		
		static string _GetURL() {
			if (_gitExe != null && gits("config --get remote.origin.url") && !_go.NE()) return _go.Ends(".git", true) ? _go[..^4] : _go;
			return App.Model.UserSettings.gitUrl;
		}
		
		static JsonNode _GithubGet(string endpoint) {
			var r = internet.http.Get($"https://api.github.com/{endpoint}", headers: ["Accept: application/vnd.github+json", "X-GitHub-Api-Version: 2022-11-28"]);
			return r.Json();
		}
		
		static async Task<JsonNode> _GithubGetAsync(string endpoint) {
			var m = new HttpRequestMessage(HttpMethod.Get, $"https://api.github.com/{endpoint}");
			m.Headers.AddMany(["Accept: application/vnd.github+json", "X-GitHub-Api-Version: 2022-11-28"]);
			var r = await internet.http.SendAsync(m);
			return r.Json();
		}
		
		//not used, not finished, just shows how to get oauth token to use GitHub features where need it
		//static JsonNode _GithubGet(string endpoint, string user) {
		//	if (!gits("credential fill", stdin: $"protocol=https\nhost=github.com\nusername={user}\n\n")) throw new AuException();
		//	if (!_go.RxMatch(@"\Rpassword=(.+)", 1, out string token)) throw new AuException();
		
		//	var ah = new[] { "Accept: application/vnd.github+json", "X-GitHub-Api-Version: 2022-11-28", $"Authorization: Bearer {token}" };
		//	var r = internet.http.Get($"https://api.github.com/{endpoint}", headers: ah);
		//	return r.Json();
		//}
	}
	
	#endregion
	
	#region util
	
	/// <summary>
	/// What should <b>git</b> print.
	/// </summary>
	enum _GP {
		/// <summary>Print blue and error. Default.</summary>
		Error,
		/// <summary>Print everything.</summary>
		All,
		/// <summary>Print blue only.</summary>
		Blue,
		/// <summary>Print nothing.</summary>
		Silent
	}
	
	static bool git(string s, _GP gp = _GP.Error, string stdin = null) {
		if (t_autoBackup) gp = _GP.Silent;
		bool silent = gp == _GP.Silent;
		if (!silent) print.it($"<><c #4040FF>git {s}<>");
		using var c = new consoleProcess(_gitExe, s, _dir);
		if (stdin != null) c.Write(stdin);
		
		bool slow = !silent && 0 != s.Starts(false, "clone", "add", "commit", "push", "fetch", "gc", "ls-remote");
		var t = slow ? timer2.after(3000, static o => { if (o.Tag == null) print.it("wait..."); }) : null;
		
		_go = c.ReadAllText().Trim("\r\n");
		
		if (t != null) { t.Tag = ""; t.Stop(); }
		
		int ec = c.ExitCode;
		bool ok = ec == 0;
		if (!ok) _go = $"[{ec}] {_go}";
		if (!_go.NE()) if (gp == _GP.All || (!ok && gp == _GP.Error)) _Print(_go, !ok);
		return ok;
		
		static void _Print(string s, bool error) {
			var color = error ? "FF3300" : "206000";
			print.it($"<><c #{color}><_>{s}</_><>");
		}
	}
	
	static bool gits(string s, string stdin = null) => git(s, _GP.Silent, stdin);
	
	static bool gita(string s, string stdin = null) => git(s, _GP.All, stdin);
	
	static _Status _GetStatus(bool remoteUpdate = false) {
		if (remoteUpdate) git("remote update"); //can be "fetch", but somehow I see "remote update" everywhere. Same speed (> 1.5 s). Both download everything including blobs, even "fetch --dry-run".
		git("status -z --branch --no-renames");
		
		int j = _go.IndexOf('\0');
		string s1 = _go[..j], s2 = j < _go.Length - 1 ? _go[++j..] : null;
		if (!s1.RxMatch(@"^##[^\[]+(?:\[(?:ahead (\d+))?(?:, )?(?:behind (\d+))?\])?", out var m)) throw new AuException("Unexpected 'git status' output:\r\n" + _go);
		
		return new(m[1].Exists ? m[1].Value.ToInt() : 0, m[2].Exists ? m[2].Value.ToInt() : 0, s2?.Split('\0', StringSplitOptions.RemoveEmptyEntries));
	}
	
	record struct _Status(int ahead, int behind, string[] changes) {
		public bool CanCommit => changes != null;
		
		public override string ToString() {
			var b = new StringBuilder($"New commits: {ahead} local, {behind} remote.\r\n");
			if (changes == null) {
				b.Append("No changes to be committed.");
			} else {
				var a = changes;
				for (int i = 0; i < a.Length; i++) {
					var s2 = a[i][..2];
					string s = s2 switch {
					[_, 'D'] or ['D', ' '] => "  deleted:  ",
					[_, '?'] or ['A', _] => "  added:    ",
					[_, 'M'] or ['M', ' '] => "  modified: ",
						_ => "  " + s2 + ":       "
					};
					a[i] = s + a[i][2..];
				}
				b.AppendLine("Changes to be committed:").AppendJoin("\r\n", a.OrderBy(o => o));
			}
			return b.ToString();
		}
	}
	
	static void _Link(DEventArgs e) {
		switch (e.LinkHref) {
		case "status": Status(); break;
		case "diff": _Diff(true); break;
		case "diffR": _Diff(false); break;
		}
		
		void _Diff(bool R) {
			var s1 = R ? "-R " : "";
			git($"diff {s1}--compact-summary origin/main");
			print.it(_go);
			git($"diff {s1}origin/main");
			_go = _go.RxReplace(@"\Rindex .+", "", 1).RxReplace(@"\R--- .(.+)\R\+\+\+ .\1", "", 1);
			print.it(_go);
		}
	}
	
	static bool _BackupWorkspace() {
		if (!gits("ls-tree -r HEAD --name-only")) goto ge;
		
		var zipFile = _dir + @"\.temp\git backup.7z";
		if (filesystem.exists(zipFile)) filesystem.delete(zipFile); else filesystem.createDirectoryFor(zipFile);
		using (var tf = new TempFile()) {
			filesystem.saveText(tf, _go);
			if (0 != run.console(out _, folders.ThisAppBS + @"32\7za.exe", $@"a ""{zipFile}"" -iw-@""{tf}""", _dir)) goto ge;
		}
		
		print.it($"<>Created <explore {zipFile}>temporary backup<> of workspace files.");
		return true;
		ge: print.it("Failed to backup workspace files.");
		return false;
	}
	
	#endregion
}


================================================
FILE: Au.Editor/Files/Save.cs
================================================
namespace LA;

partial class FilesModel {
	public class AutoSave {
		FilesModel _model;
		int _workspaceAfterS, _stateAfterS, _textAfterS;
		internal bool LoadingState;
		
		public AutoSave(FilesModel model) {
			_model = model;
			App.Timer1s += _Program_Timer1s;
		}
		
		public void Dispose() {
			_model = null;
			App.Timer1s -= _Program_Timer1s;
			
			//must be all saved or unchanged
			Debug.Assert(_workspaceAfterS == 0);
			Debug.Assert(_stateAfterS == 0);
			Debug.Assert(_textAfterS == 0);
		}
		
		/// <summary>
		/// Async-saves workspace (files.xml).
		/// </summary>
		public void WorkspaceAsync() {
			if (PauseSaveWorkspace) { _workspaceAfterS = 0; return; }
			int afterS = 1;
			if (_workspaceAfterS < 1 || _workspaceAfterS > afterS) {
				_workspaceAfterS = afterS;
				App.Dispatcher.InvokeAsync(WorkspaceNowIfNeed);
			}
		}

		/// <summary>
		/// Used by filesystem sync.
		/// </summary>
		public bool PauseSaveWorkspace { get; set { field = value; _workspaceAfterS = 0; } }
		
		/// <summary>
		/// Sets timer to save state later, if not already set.
		/// </summary>
		/// <param name="afterS">Timer time, seconds.</param>
		public void StateLater(int afterS = 30) {
			if (LoadingState) return;
			if (_stateAfterS < 1 || _stateAfterS > afterS) _stateAfterS = afterS;
		}
		
		/// <summary>
		/// Sets timer to save editor text later, if not already set.
		/// </summary>
		/// <param name="afterS">Timer time, seconds.</param>
		public void TextLater(int afterS = 60) {
			if (_textAfterS < 1 || _textAfterS > afterS) _textAfterS = afterS;
		}
		
		/// <summary>
		/// If files.xml is set to save (WorkspaceLater), saves it now.
		/// </summary>
		public void WorkspaceNowIfNeed() {
			if (_workspaceAfterS > 0) _SaveWorkspaceNow();
		}
		
		/// <summary>
		/// If state is set to save (StateLater), saves it now.
		/// </summary>
		public void StateNowIfNeed() {
			if (_stateAfterS > 0) _SaveStateNow();
		}
		
		/// <summary>
		/// If editor text is set to save (TextLater), saves it now.
		/// Also saves markers, folding, etc, unless onlyText is true.
		/// </summary>
		public void TextNowIfNeed(bool onlyText = false, bool closingDoc = false) {
			if (_textAfterS > 0) _SaveTextNow();
			if (onlyText) return;
			Panels.Editor?.SaveEditorData(closingDoc);
		}
		
		void _SaveWorkspaceNow() {
			_workspaceAfterS = 0;
			Debug.Assert(_model != null); if (_model == null) return;
			if (!_model._SaveWorkspaceNow()) _workspaceAfterS = 5; //if fails, retry later
		}
		
		void _SaveStateNow() {
			_stateAfterS = 0;
			Debug.Assert(_model != null);
			_model?._SaveStateNow();
		}
		
		void _SaveTextNow() {
			_textAfterS = 0;
			Debug.Assert(_model != null); if (_model == null) return;
			Debug.Assert(Panels.Editor.IsOpen);
			if (!Panels.Editor.SaveText()) _textAfterS = 300; //if fails, retry later
		}
		
		/// <summary>
		/// Calls WorkspaceNowIfNeed, TextNowIfNeed, StateNowIfNeed, Panels.Bookmarks.SaveNowIfNeed, Panels.Debugg.SaveNowIfNeed.
		/// </summary>
		public void AllNowIfNeed() {
			WorkspaceNowIfNeed();
			_model.State.SuspendSave(true);
			TextNowIfNeed();
			StateNowIfNeed();
			_model.State.SuspendSave(false);
			Panels.Bookmarks.SaveNowIfNeed();
			Panels.Breakpoints.SaveNowIfNeed();
		}
		
		void _Program_Timer1s() {
			if (_workspaceAfterS > 0 && --_workspaceAfterS == 0) _SaveWorkspaceNow();
			if (_stateAfterS > 0 && --_stateAfterS == 0) _SaveStateNow();
			if (_textAfterS > 0 && --_textAfterS == 0) _SaveTextNow();
		}
	}
	
	/// <summary>
	/// Used only by the Save class.
	/// </summary>
	bool _SaveWorkspaceNow() {
		return TryFileOperation(FOSync.FilesXml, () => { Root.SaveWorkspace(WorkspaceFile); });
		//XElement.Save exceptions are undocumented
	}
	
	/// <summary>
	/// Used only by the Save class.
	/// </summary>
	void _SaveStateNow() {
		State.FilesSave(_openFiles, Root.Descendants().Where(n => n.IsExpanded));
	}
	
	/// <summary>
	/// Called at the end of opening this workspace.
	/// </summary>
	public void LoadState(bool expandFolders = false, bool openFiles = false) {
		try {
			Save.LoadingState = true;
			
			if (expandFolders) {
				foreach (var id in State.FilesGet(1))
					if (FindById(id) is { } f)
						f.SetIsExpanded(true);
			}
			
			if (openFiles) {
				foreach (var id in State.FilesGet(0)) {
					if (FindById(id) is { } f) _openFiles.Add(f);
				}
				if (_openFiles.Count == 0 || !SetCurrentFile(_openFiles[0])) _UpdateOpenFiles(null); //disable Previous command
			}
		}
		catch (Exception ex) { Debug_.Print(ex); }
		finally { Save.LoadingState = false; }
	}
}


================================================
FILE: Au.Editor/Files/SyncWithFilesystem.cs
================================================
//#define USE_CHANGED_EVENTS

using System.Xml;
using System.Xml.Linq;

namespace LA;

partial class FilesModel {
	WildcardList _ignoredPaths, _ignoredPaths2;
	_FileWatchers _syncWatchers;
	
	bool _IsPathIgnored(RStr itemPath, bool orAncestorDir = false) {
		_ignoredPaths ??= new(WSSett.syncfs_skip);
		if (_ignoredPaths.IsMatch(itemPath, true)) return true;
		if (orAncestorDir) {
			_ignoredPaths2 ??= new(_ignoredPaths.ListOfStrings.Where(o => !o.Ends('*')).Select(o => o + @"\*").ToArray());
			if (_ignoredPaths2.IsMatch(itemPath, true)) return true;
		}
		return false;
	}
	
	//CONSIDER: call when workspace loaded, even if LA hidden. Now does not sync until shown (_syncWatchers too). But is it important?
	/// <summary>
	/// Called when: 1. WorkspaceLoadedWithUI; 2. WSSett.syncfs_skip changed in Options.
	/// </summary>
	internal async void SyncWithFilesystem_() {
		_ignoredPaths = new(WSSett.syncfs_skip);
		_ignoredPaths2 = null;
		
		//get the root and all folder links
		_RootDir[] rootDirs = Root.Descendants(andSelf: true)
			.Where(o => o.Id == 0 || (o.IsLink && o.IsFolder && filesystem.exists(o.FilePath).Directory))
			.Select(o => new _RootDir(o, o.ItemPath, o.FilePath))
			.ToArray();
		
		//gather all filesystem files and dirs. Can be slow. Async to avoid blocking the main thread.
		await Task.Run(() => {
			foreach (var rd in rootDirs) {
				RelativePath rel = new(rd.itemPath);
				rd.tree = _Dir(new(pathname.expand(rd.fullPath)));
				
				_DirTree _Dir(DirectoryInfo parent) {
					_DirTree t = new(parent.Name) { children = new() };
					try {
						foreach (var v in parent.EnumerateFileSystemInfos()) {
							if (v.Attributes.Has(FileAttributes.Hidden | FileAttributes.System)) continue;
							var relPath = rel.GetRelativePath(v.FullName);
							if (_IsPathIgnored(relPath)) continue;
							
							if (v is DirectoryInfo di) {
								t.children.Add(_Dir(di));
							} else {
								t.children.Add(v.Name);
							}
						}
					}
					catch (Exception ex) { //eg symlink target dir does not exist
						t.children = null; //don't remove descendant filenodes, because the symlink target may be restored later
						Debug_.Print(ex);
					}
					return t;
				}
			}
		});
		Debug.Assert(App.IsMainThread);
		if (App.Model != this) return;
		
		//get added and deleted files
		foreach (var rd in rootDirs) {
			_DirItemComparer comparer = new();
			List<Dictionary<object, _DirTree>> adict = new();
			_Dir(rd.fn, rd.tree, 0);
			void _Dir(FileNode parentNode, _DirTree parentTree, int level) {
				if (parentTree.children == null) return; //failed to enum this dir; don't remove filenodes
				
				if (level == adict.Count) adict.Add(new(comparer));
				Dictionary<object, _DirTree> dict = adict[level];
				dict.Clear();
				
				foreach (var v in parentTree.children) {
					dict.Add(v, v as _DirTree);
				}
				
				foreach (var f in parentNode.Children()) {
					if (f.IsLink) continue;
					if (!dict.Remove(f.Name, out var t)) {
						(rd.delete ??= new()).Add(f);
					} else if (f.IsFolder != (t != null)) {
						(rd.delete ??= new()).Add(f);
						dict.Add((object)t ?? f.Name, t);
					} else if (f.IsFolder) {
						_Dir(f, t, level + 1);
					}
				}
				
				if (dict.Count > 0) (rd.add ??= new()).Add((parentNode, dict.Keys.ToArray()));
			}
		}
		
		//update filenodes
		StringBuilder bAdd = null;
		bool deleted = false;
		foreach (var rd in rootDirs) {
			//print.it(rd.fn, rd.delete?.Select(o => o.ItemPath), rd.add?.Select(o => (o.parent.ItemPath, "[" + print.util.toString(o.files, compact: true) + "]")));
			if (rd.delete != null) {
				foreach (var f in rd.delete) {
					if (f.IsDeleted) continue; //was in a now deleted folder
					//bDel ??= new("Missing or <+options Workspace>excluded<> files were removed from the <b>Files<> panel:"); //probably not useful info. Just distracts and scares people.
					//bDel.Append("\r\n  ").Append(f.ItemPath);
					//if (f.IsFolder) bDel.Append("  (folder)");
					deleted = true;
					_Delete(f, syncing: 1);
				}
			}
			if (rd.add != null) {
				foreach (var v in rd.add) {
					_AddDirItems(v.parent, v.files, 0);
				}
			}
			//rejected: if renamed or moved inside workspace, preserve file id etc. If folder, preserve the order of items.
			//	Cannot make it reliable. It would be too dirty/heavy. Possible side effects. Rarely used/useful.
		}
		
		if (bAdd != null || deleted) {
			UpdateControlItems();
			Save.WorkspaceAsync();
			CodeInfo.FilesChanged();
			if (bAdd != null) {
				bAdd.Append("\r\nYou may want to review added files and: change the order; change some properties; delete unused files; hide unused files (Options > Workspace).<>");
				print.it(bAdd);
			}
		}
		
		_syncWatchers ??= new(this);
		
		void _AddDirItems(FileNode parent, IEnumerable<object> files, int indent) {
			var parentPath = parent.FilePath + "\\";
			
			foreach (var v in files) {
				var name = v.ToString();
				var f = new FileNode(this, name, parentPath + name, v is _DirTree);
				parent.AddChild(f, first: parent == parent.Root);
				bAdd ??= new("<><lc #FFFFB9>New files were added:");
				bAdd.AppendLine().Append(' ', indent * 2).Append("  ").Append(f.SciLink(true));
				if (f.IsFolder) bAdd.Append("  (folder)");
				
				if (v is _DirTree dt) _AddDirItems(f, dt.children, indent + 1);
			}
		}
	}
}

file record class _RootDir(FileNode fn, string itemPath, string fullPath) {
	public _DirTree tree;
	public List<FileNode> delete;
	public List<(FileNode parent, object[] files)> add;
}

file record class _DirTree(string name) {
	public List<object> children;
	public override string ToString() => name;
}

file class _DirItemComparer : IEqualityComparer<object> {
	bool IEqualityComparer<object>.Equals(object x, object y) {
		return x.ToString().Eqi(y.ToString());
	}
	
	int IEqualityComparer<object>.GetHashCode(object obj) {
		return obj.ToString().GetHashCode();
	}
}

partial class FilesModel {
	class _FileWatchers {
		class _Watcher : FileSystemWatcher {
			public _Watcher(string path, FileNode fn) : base(path) {
				FN = fn;
				SetFolderItemPathBS();
			}
			public FileNode FN { get; }
			public string FolderItemPathBS { get; private set; }
			
			public void SetFolderItemPathBS() {
				if (FN is { IsFolder: true } f) FolderItemPathBS = f == f.Root ? "\\" : f.ItemPath + "\\";
			}
		}
		
		readonly FilesModel _model;
		readonly Dictionary<string, _Watcher> _dDir;
		
		public _FileWatchers(FilesModel model) {
			_model = model;
			_dDir = new(StringComparer.OrdinalIgnoreCase);
			_guid = Guid.NewGuid().ToString("N");
			_syncFilePath = _model.FilesDirectory + "\\" + _guid + ".~!~";
			
			//_Add(null, _model.WorkspaceDirectory);
			_Add(_model.Root, _model.FilesDirectory);
			foreach (var f in _model.Root.Descendants()) {
				if (f.IsLink && f.IsFolder) _Add(f, f.LinkTarget);
			}
		}
		
		public void Dispose() {
			foreach (var v in _dDir.Values) v.Dispose();
			_dDir.Clear();
		}
		
		void _Add(FileNode fn, string path) {
			if (_dDir.ContainsKey(path)) {
				Debug_.Print(path);
				return;
			}
			if (!filesystem.exists(path).Directory) return;
			
			_Watcher fw = null;
			try {
				//print.it("add", path);
				fw = new _Watcher(path, fn);
				//if (fn == null) { //workspace dir
				//	fw.Filters.Add("files.xml");
				//	fw.Filters.Add("settings.json");
				//} else {
				fw.IncludeSubdirectories = true;
				if (fn == fn.Root) fw.InternalBufferSize = 64 * 1024;
				//}
				
				fw.Created += _EventInTpThread;
				fw.Deleted += _EventInTpThread;
				fw.Renamed += _EventInTpThread;
#if USE_CHANGED_EVENTS
				fw.Changed += _Event;
#else
				//if (fn == null) fw.Changed += _EventInTpThread;
#endif
#if DEBUG
				fw.Error += static (o, e) => { Debug_.Print(e.GetException()); }; //never noticed. Never mind, will update at the next startup.
#endif
				fw.EnableRaisingEvents = true;
				_dDir[path] = fw;
			}
			catch (Exception ex) {
				Debug_.Print(ex);
				fw?.Dispose();
			}
		}
		
		public void Add(FileNode f) {
			_Add(f, f.LinkTarget);
		}
		
		public void Remove(FileNode f) {
			string path = f.LinkTarget;
			//print.it("remove", path);
			if (_dDir.Remove(path, out var f1)) f1.Dispose();
			else Debug_.Print(path);
		}
		
		public void UpdatePaths() {
			foreach (var v in _dDir.Values) v.SetFolderItemPathBS();
		}
		
		public void FileOperationStarted(FOSync fos) {
			if (fos != FOSync.UserFileOp) return;
			//print.it("started", fos);
			_CreateSyncFile();
		}
		
		public void FileOperationEnded(FOSync fos) {
			if (fos != FOSync.FilesXml) return;
			//print.it("ended", fos);
			_CreateSyncFile();
			_hSyncFile.Dispose();
		}
		
		void _CreateSyncFile() {
			if (_hSyncFile.Is0) {
				_hSyncFile = Api.CreateFile(_syncFilePath, Api.GENERIC_WRITE, Api.FILE_SHARE_DELETE | Api.FILE_SHARE_READ, Api.CREATE_NEW, Api.FILE_ATTRIBUTE_TEMPORARY | Api.FILE_FLAG_DELETE_ON_CLOSE | Api.FILE_ATTRIBUTE_HIDDEN | Api.FILE_ATTRIBUTE_SYSTEM);
			}
		}
		
		readonly string _guid, _syncFilePath;
		Handle_ _hSyncFile;
		volatile int _paused;
		
		void _EventInTpThread(object sender, FileSystemEventArgs e) {
			var fw = sender as _Watcher;
			if (e.Name[^1] == '~') { //atomic save (LA, VS), Rider temp backup, or a sync file
				if (e.Name.Ends(".~!~") && e.Name.Length == _guid.Length + 4 && e.ChangeType is WatcherChangeTypes.Created or WatcherChangeTypes.Deleted) { //a sync file of this or another LA process
					if (e.ChangeType is WatcherChangeTypes.Created) {
						Interlocked.Increment(ref _paused);
					} else {
						int paused = Interlocked.Decrement(ref _paused);
						if (paused == 0) {
							if (e.Name.Starts(_guid)) {
								//print.it("own");
							} else {
								App.Dispatcher.InvokeAsync(_SyncFromAnotherLaProcess);
							}
						} else if (paused < 0) { //unlikely but possible. We did not receive the 'created' event because either: 1. Another LA process created its sync file before we started watching; 2. After a watcher error.
							_paused = 0;
						}
					}
				}
				return;
			}
			if (_paused > 0) return;
			if (e.Name.Ends(true, [".TMP", ".bak"]) > 0) return; //VS atomic save, etc
#if !USE_CHANGED_EVENTS
			if (e.ChangeType == WatcherChangeTypes.Renamed && ((RenamedEventArgs)e).OldName.Ends('~') && fw.FN != null) return; //atomic save
#endif
			//note: we ignore renaming from/to a filtered filename. Eg if renamed `file.txt` -> `file.bak` or `bind` -> `bin`.
			//	It could conflict with the atomic save detection. Rare. Will correct at the next startup.
			
			App.Dispatcher.InvokeAsync(() => _EventInMainThread(fw, e));
		}
		
		void _SyncFromAnotherLaProcess() {
			if (App.Model != _model) return;
			_timer?.Stop();
			_ae.Clear();
			_model._SyncFromAnotherLaProcess();
		}
		
		void _EventInMainThread(_Watcher fw, FileSystemEventArgs e) {
			if (App.Model != _model) return;
			
			string itemPath = null;
			var fnRootOrLinkFolder = fw.FN;
			if (fnRootOrLinkFolder != null) {
				if (fnRootOrLinkFolder.IsDeleted) return;
#if USE_CHANGED_EVENTS
				if (e.ChangeType == WatcherChangeTypes.Changed && filesystem.exists(e.FullPath, true).Directory) return;
#endif
				itemPath = fw.FolderItemPathBS + e.Name;
				if (_model._IsPathIgnored(itemPath, true)) return;
			}
			
			//print.it($"<><c green>{e.ChangeType}, {e.Name}, {(e as RenamedEventArgs)?.OldName}<>");
			
			//delay to filter out unusual replace-file sequences etc or join multiple events when copying a folder (and in some cases moving or deleting)
			_ae.Add(new(fw, e, itemPath)); //queue events. Without it, eg on copy folder, the printed items are not all and in random order, although imports without errors.
			_timer ??= new(_Timer);
			_timer.After(250);
		}
		
		timer _timer;
		List<_EventInfo> _ae = [];
		
		record class _EventInfo(_Watcher fw, FileSystemEventArgs e, string itemPath);
		
		void _Timer(timer t_) {
			if (App.Model != _model) return;
			foreach (var x in _ae) {
				if (x.fw.FN != null) {
					switch (x.e.ChangeType) {
					case WatcherChangeTypes.Renamed:
						if (x.e is RenamedEventArgs re) {
							var itemPathOld = x.fw.FolderItemPathBS + re.OldName;
							if (_model.FindByItemPath(itemPathOld) is { } fr && _model.FindByItemPath(x.itemPath) is null && !filesystem.exists(re.OldFullPath, true) && filesystem.exists(re.FullPath, true)) {
								fr.FileRename(pathname.getName(re.Name), syncing: true);
								print.it($"<><lc #FFFFB9>Renamed: {fr.SciLink(true)} (was {pathname.getName(re.OldName)})<>");
							}
						}
						break;
					case WatcherChangeTypes.Deleted:
						if (_model.FindByItemPath(x.itemPath) is { } fd && !filesystem.exists(x.e.FullPath, true)) {
							print.it($"<><lc #FFFFB9>Deleted: {fd.ItemPath}{(fd.IsFolder ? "  (folder)" : null)}<>");
							_model._Delete(fd, syncing: 2);
						}
						break;
					case WatcherChangeTypes.Created:
						if (_model._SyncImportFromWorkspaceDir(x.e.FullPath, x.itemPath) is { } fa) {
							foreach (var v in fa.Descendants(true)) print.it($"<><lc #FFFFB9>Added: {v.SciLink(true)}{(v.IsFolder ? "  (folder)" : null)}<>");
						}
						break;
					}
					//} else if (x.e.ChangeType != WatcherChangeTypes.Deleted) {
					//	print.it(x.e.Name);
				}
			}
			_ae.Clear();
		}
	}
	
	/// <summary>
	/// Called by a filesystem watcher when files.xml modified by another LA process.
	/// Normally it happens when using PiP (child session). One LA process runs in main session, and other in child session. Same user, same workspace.
	/// </summary>
	void _SyncFromAnotherLaProcess() {
		XElement newRoot;
		try {
			newRoot = filesystem.waitIfLocked(() => XElement.Load(WorkspaceFile)); //the slowest part
		}
		catch (Exception ex) { Debug_.Print(ex); return; }
		
		Save.PauseSaveWorkspace = true; //nothing here tries to save, but would be bad if somehow it would happen without this protection. Also it cancels async save.
		try {
			_SyncFromAnotherLaProcess(newRoot);
		}
		catch (Exception ex) {
			dialog.showError("Failed to sync workspace", ex.ToString(), owner: App.Hmain);
			Environment.Exit(1);
		}
		Save.PauseSaveWorkspace = false;
	}
	
	void _SyncFromAnotherLaProcess(XElement newRoot) {
		//Algorithm: remove all our filenodes from their parents, and then re-add like in the new XML.
		//Then easy to find added, deleted, moved and changed nodes.
		
		var aOld = Root.Descendants().ToArray();
		var dOld = aOld.ToDictionary(f => f.Id);
		uint[] aOldParent = new uint[aOld.Length]; for (int i = 0; i < aOld.Length; i++) aOldParent[i] = aOld[i].Parent.Id;
		List<FileNode> aAdded = [];
		
		foreach (var f in aOld) f.Remove();
		
		_Folder(Root, newRoot);
		Debug.Assert(Root.Descendants().Count() == newRoot.Descendants().Count());
		void _Folder(FileNode oldFolder, XElement newFolder) {
			foreach (var x in newFolder.Elements()) {
				if (!x.Attribute("i").Value.ToInt(out uint id)) throw new ArgumentException();
				if (!dOld.Remove(id, out var f)) {
					f = new(x, this);
					_idMap.Add(id, f); //exception if duplicate
					aAdded.Add(f);
				}
				oldFolder.AddChild(f);
				if (x.HasElements) _Folder(f, x);
			}
		}
		
		//DELETED
		foreach (var f in dOld.Values) {
			//print.it($"Deleted {f.Name}");
			if (!f.IsDeleted) _Delete(f, syncing: 1);
		}
		
		//ADDED
		//foreach (var f in aAdded) {
		//	print.it($"Added {f}");
		//}
		
		//CHANGED ATTRIBUTES OR TAG
		using (var oldEnum = Root.Descendants().GetEnumerator())
		using (var newEnum = newRoot.Descendants().GetEnumerator()) {
			while (oldEnum.MoveNext() && newEnum.MoveNext()) {
				var f = oldEnum.Current;
				Debug.Assert(newEnum.Current.Attribute("i").Value.ToInt(out uint u) && u == f.Id);
				if (aAdded.Contains(f)) continue;
				f.SyncAttributes(newEnum.Current);
			}
		}
		
		//CHANGED PARENT
		for (int i = 0; i < aOld.Length; i++) {
			var f = aOld[i];
			if (f.IsDeleted) continue;
			if (f.Parent.Id != aOldParent[i]) {
				//print.it($"Moved {f.Name}, {f.Descendants():print}");
				Compiler.Uncache(f, andDescendants: true);
			}
		}
		
		ChangedFolderItemPath_();
		UpdateControlItems();
		CodeInfo.FilesChanged();
	}
}

partial class FileNode {
	internal void SyncAttributes(XElement x) {
		var type = XmlTagToFileType(x.Name.LocalName, canThrow: true);
		if (type != _type) {
			if (!(IsCodeFile && type is FNType.Script or FNType.Class)) throw new ArgumentException();
			_type = type;
			_testScriptId = 0;
			Compiler.Uncache(this);
		}
		
		string icon = null;
		uint testScriptId = 0;
		//_Flags flags = 0;
		foreach (var attr in x.Attributes()) {
			string name = attr.Name.LocalName, value = attr.Value;
			if (value.NE()) continue;
			switch (name) {
			//case "i": break;
			//case "path": break; //never changes
			//case "f": flags = (_Flags)value.ToInt(); break; //currently there are no flags
			case "n" when value != _name:
				_SetName(value);
				Compiler.Uncache(this, andDescendants: true);
				break;
			case "icon": icon = value; break;
			case "run": value.ToInt(out testScriptId); break;
			}
		}
		
		//if (flags != _flags) {
		//	_flags = flags;
		//}
		
		if (icon != _icon) {
			_icon = icon;
			Compiler.Uncache(this);
		}
		
		if (testScriptId != _testScriptId) {
			_testScriptId = testScriptId;
		}
	}
}

enum FOSync { UserFileOp, UserFileWrite, FilesXml, PrivateFileWrite }


================================================
FILE: Au.Editor/Files/WorkspaceState.cs
================================================
//We save workspace state data in folder "%folders.Workspace%\.state", in files:
//	state - top/pos of open files, open files, expanded folders, maybe some markers.
//		It's a text file containing 3 compact lines like:
//			editor|id1=t1p2|id2=p2h1,2,3
//			open|id1|id2
//			expanded|id1|id2
//	folding - contracted fold points of all files.
//		It's a binary file, as compact as possible. Managed by struct WorkspaceState._Folding.
//In child session separately, in subfolder "pip".

namespace LA;

/// <summary>
/// Workspace state, such as open files, expanded folders, editor caret position, folded lines.
/// WorkspaceDirectory + @"\.state\state.json"
/// </summary>
class WorkspaceState : IDisposable {
	readonly FilesModel _model;
	readonly _State _s;
	
	public WorkspaceState(FilesModel model) {
		_model = model;
		_s = new _State(model);
	}
	
	public void Dispose() {
		_s.SaveIfNeed();
	}
	
	void _Save() {
		if (_suspendSave == 0) _s.SaveIfNeed();
		else _suspendSave |= 2;
	}
	byte _suspendSave; //flags: 1 suspended, 2 save when resumed
	
	public void SuspendSave(bool suspend) {
		if (suspend) _suspendSave |= 1;
		else {
			if ((_suspendSave & 2) != 0) _s.SaveIfNeed();
			_suspendSave = 0;
		}
	}
	
	#region editor
	
	//Contains parsed editor state.
	public record struct Editor {
		public int top, pos;
		public int[] fold/*, someMarker*/;
		
		public bool Equals(in Editor e, out bool changedState, out bool changedFolding) {
			changedState = !(top == e.top && pos == e.pos /*&& someMarker.AsSpan().SequenceEqual(e.someMarker)*/);
			changedFolding = !fold.AsSpan().SequenceEqual(e.fold);
			return !(changedState || changedFolding);
		}
	}
	
	public bool EditorGet(FileNode f, out Editor x) {
		x = default;
		if (_s.Find(f, out var t)) {
			var s = _s.editor;
			for (int start = t.valueStart, end; start < t.end; start = end) {
				for (end = ++start; end < t.end && s[end] is not (>= 'g' and <= 'z');) end++;
				int what = s[start - 1];
				switch (what) {
				case 'p' or 't': //int
					var k = s.ToInt(start, STIFlags.IsHexWithout0x);
					if (what == 't') x.top = k; else x.pos = k;
					break;
					//case 'h': //int[]
					//	int n = 1; for (int j = start; j < end; j++) if (s[j] == ',') n++;
					//	var a = new int[n];
					//	a[0] = start; for (int i = 0, j = start; j < end; j++) if (s[j] == ',') a[++i] = j + 1;
					//	for (int i = 0, j = 0; i < n; i++) a[i] = j += s.ToInt(a[i], STIFlags.IsHexWithout0x); //deltas
					//	if (what == 'h') x.someMarker = a;
					//	break;
				}
			}
		}
		
		if (_Folding.Get(f) is { } af) x.fold = af.ToArray();
		
		return x != default;
	}
	
	public void EditorSave(FileNode f, in Editor x, bool changedState, bool changedFolding) {
		if (changedState) _EditorSave(x);
		if (changedFolding) _Folding.Save(f, x.fold);
		
		void _EditorSave(in Editor x) {
			string s = _EditorFormat(f, x);
			if (_s.Find(f, out var t)) {
				if (s != null && _s.editor.Eq(t.start..t.end, s)) return;
				_s.editor = string.Concat(s, _s.editor.AsSpan(..t.start), _s.editor.AsSpan(t.end..));
			} else {
				if (s == null) return;
				_s.editor = s + _s.editor;
			}
			_Save();
		}
		
		static string _EditorFormat(FileNode f, in Editor x) {
			if (x.top == 0 && x.pos == 0 /*&& x.someMarker == null*/) return null;
			using (new StringBuilder_(out var b)) {
				b.Append('|').AppendHex(f.Id).Append('=');
				if (x.top > 0) b.Append('t').AppendHex(x.top);
				if (x.pos > 0) b.Append('p').AppendHex(x.pos);
				//_AppendLines(x.someMarker, 'h');
				return b.ToString();
				
				//void _AppendLines(int[] a, char c) {
				//	if (a == null) return;
				//	b.Append(c);
				//	for (int i = 0, j = 0; i < a.Length; j = a[i++]) {
				//		if (i > 0) b.Append(',');
				//		b.AppendHex(a[i] - j); //delta
				//	}
				//}
			}
		}
	}
	
	/// <summary>
	/// When deleting a file, called to delete its saved states.
	/// </summary>
	public void EditorDelete(FileNode f) {
		if (_s.Find(f, out var v)) {
			_s.editor = _s.editor.Remove(v.start..v.end);
			_Save();
		}
		
		_Folding.Delete(f);
	}
	
	//called by FilesModel.CloseFile
	public void Cleanup() {
		if (_cleanup++ != 0) return; //only the first and every 256-th time
		
		var hs = _model.OpenFiles.Select(o => o.Id).ToHashSet();
		var b = new StringBuilder(_s.editor.Length);
		int n1 = 0, n2 = 0;
		foreach (var t in _s.editor.SplitSE(.., '|', StringSplitOptions.RemoveEmptyEntries)) {
			n1++;
			if (!_s.editor.ToInt(out uint id, t.start, out int i, STIFlags.IsHexWithout0x)) continue; //remove if _js.editor corrupt
			if (!hs.Contains(id)) { //the file isn't in OpenFiles
				if (_model.FindById(id) == null) continue; //remove if file deleted
				if (_s.editor.AsSpan(++i..t.end).IndexOfAny("gh") < 0) continue; //remove if no markers etc
			}
			b.Append(_s.editor, t.start - 1, t.Length + 1);
			n2++;
		}
		if (n2 < n1) {
			_s.editor = b.ToString();
			_Save();
		}
		
		//CONSIDER: also cleanup folding? Normally don't need; unless some files edited manually, or an exception prevented deleting data, etc.
	}
	byte _cleanup;
	
	#endregion
	
	#region files
	
	//These functions set/get the 'open' and 'expanded' lines in the state file.
	
	/// <param name="what">0 open, 1 expanded.</param>
	public IEnumerable<uint> FilesGet(int what) {
		var s = what switch { 0 => _s.open, 1 => _s.expanded, _ => throw null };
		foreach (var v in s.SplitSE(.., '|')) {
			yield return (uint)s.ToInt(v.start, STIFlags.IsHexWithout0x);
		}
	}
	
	public void FilesSave(IEnumerable<FileNode> open, IEnumerable<FileNode> expanded) {
		using (new StringBuilder_(out var b)) {
			_s.open = _FormatIds(b, open);
			_s.expanded = _FormatIds(b, expanded);
		}
		_Save();
		
		static string _FormatIds(StringBuilder b, IEnumerable<FileNode> e) {
			b.Clear();
			foreach (var f in e) {
				if (b.Length > 0) b.Append('|');
				b.AppendHex(f.Id);
			}
			return b.ToString();
		}
	}
	
	#endregion
	
	//Loads/saves the state file. Contains its lines as public string fields.
	class _State {
		FilesModel _model;
		string _file;
		public string editor, open, expanded;
		string _editor, _open, _expanded;
		
		public _State(FilesModel model) {
			_model = model;
			_file = $@"{_model.WorkspaceDirectory}\.state{(miscInfo.isChildSession ? @"\pip" : null)}\state";
			try {
				var s = filesystem.loadText(_file);
				foreach (var line in s.Lines(..)) {
					int what = s.Eq(line.start, false, "editor|", "open|", "expanded|");
					if (what == 0) continue;
					switch (what) {
					case 1:
						editor = s[(line.start + 6)..line.end];
						break;
					case 2:
						open = s[(line.start + 5)..line.end];
						break;
					case 3:
						expanded = s[(line.start + 9)..line.end];
						break;
					}
				}
			}
			catch (Exception e1) {
				if (!filesystem.exists(_file)) _ConvertOldDb();
				else print.it(e1);
			}
			
			_editor = editor ??= "";
			_open = open ??= "";
			_expanded = expanded ??= "";
			
			//convert from old SQLite database
			void _ConvertOldDb() {
				if (miscInfo.isChildSession) return;
				var dbFile = _model.WorkspaceDirectory + @"\state.db";
				if (filesystem.exists(dbFile, true)) {
					try {
						using (var db = new sqlite(dbFile, SLFlags.SQLITE_OPEN_READONLY)) {
							//using (var p = db.Statement("SELECT * FROM _misc")) { } //never mind open/expanded/top/pos. Convert just folding.
							_Folding.ConvertOldDb(db, _model);
						}
						filesystem.delete(dbFile);
					}
					catch (Exception e1) { Debug_.Print(e1); }
				}
			}
		}
		
		public void SaveIfNeed() {
			if (editor == _editor && open == _open && expanded == _expanded) return;
			
			//print.it("saved");
			//if (editor != _editor) print.it($"\teditor: old={_editor}, new={editor}");
			//if (open != _open) print.it($"\topen: old={_open}, new={open}");
			//if (expanded != _expanded) print.it($"\texpanded: old={_expanded}, new={expanded}");
			
			var s = $"editor{editor}\nopen|{open}\nexpanded|{expanded}\n";
			if (!_model.TryFileOperation(FOSync.PrivateFileWrite, () => { filesystem.saveText(_file, s); })) return;
			
			_editor = editor;
			_open = open;
			_expanded = expanded;
		}
		
		public bool Find(FileNode f, out (int start, int valueStart, int end) r) {
			var s = $"|{f.Id:X}=";
			int i = editor.Find(s);
			if (i < 0) { r = default; return false; }
			int j = editor.IndexOf('|', i + s.Length); if (j < 0) j = editor.Length;
			r = new(i, i + s.Length, j);
			return true;
		}
	}
	
	//Contains folding data of a source file.
	//The static functions load/save the folding file and get/set/delete folding data of a source file.
	record struct _Folding(string path, byte[] bytes, int start, int valueStart, int end) {
		//Loads the folding file if exists, and finds f data in it.
		//Returns false if: file does not exist; failed to load; did not find f data.
		//If returns false: sets path; sets bytes if loaded.
		//If returns true: sets all fields.
		static bool _Load(FileNode f, out _Folding r) {
			uint id = f.Id;
			byte[] b = null;
			var file = $@"{f.Model.WorkspaceDirectory}\.state{(miscInfo.isChildSession ? @"\pip" : null)}\folding";
			if (filesystem.exists(file, useRawPath: true)) {
				try {
					b = filesystem.loadBytes(file);
					//find byte 0 followed by 7-bit-encoded id. There are no other byte 0, because: an id cannot be 0; a line delta cannot be 0.
					Span<byte> sid = stackalloc byte[8];
					sid = sid[.._Encode7Bit(id, sid, 1)];
					int start = b.AsSpan().IndexOf(sid);
					if (start >= 0) {
						int vstart = start + sid.Length, end = vstart;
						while (end < b.Length && b[end] != 0) end++;
						if (end > start) { //else corrupt
							r = new(file, b, start, vstart, end);
							return true;
						}
					}
				}
				catch (Exception e1) { Debug_.Print(e1); }
			}
			r = new(file, b, 0, 0, 0);
			return false;
		}
		
		//7-bit encodes id.
		//span - memory for writing. Must be at least 5 bytes + offset.
		//offset - offset in <i>span</i> where to start writing.
		//Returns the end offset.
		static int _Encode7Bit(uint id, Span<byte> span, int offset = 0) {
			while (id > 0x7Fu) { span[offset++] = (byte)(id | 0x80u); id >>= 7; }
			span[offset++] = (byte)id;
			return offset;
		}
		
		/// <summary>
		/// Gets <i>f</i> data from the folding file.
		/// </summary>
		/// <returns>[+] lines. Returns null if: no file; no data; failed.</returns>
		public static List<int> Get(FileNode f) {
			if (_Load(f, out var x)) {
				try {
					var a = new List<int>();
					//read array of 7-bit encoded line deltas
					var ms = new MemoryStream(x.bytes, x.valueStart, x.end - x.valueStart, false);
					using var r = new BinaryReader(ms);
					int line = -1;
					while (ms.Position < ms.Length) {
						int delta = r.Read7BitEncodedInt();
						a.Add(line += delta);
					}
					return a;
				}
				catch (Exception e1) { Debug_.Print(e1); }
			}
			return null;
		}
		
		/// <summary>
		/// If <i>a</i> null, deletes <i>f</i> data from file if exists. Else saves <i>f</i> data in file, unless same data is already saved.
		/// </summary>
		/// <param name="a">[+] lines or null</param>
		public static void Save(FileNode f, int[] a) {
			if (a == null) {
				Delete(f);
			} else {
				var ms = new MemoryStream();
				using var w = new BinaryWriter(ms);
				Write(w, f.Id, a);
				var b = ms.ToArray();
				
				bool exists = _Load(f, out var x);
				if (exists && x.bytes.AsSpan(x.start..x.end).SequenceEqual(b)) return;
				
				f.Model.TryFileOperation(FOSync.PrivateFileWrite, () => {
					filesystem.save(x.path, temp => {
						using var fs = File.Create(temp);
						fs.Write(b);
						if (exists) {
							fs.Write(x.bytes, 0, x.start);
							fs.Write(x.bytes, x.end, x.bytes.Length - x.end);
						}
					});
				});
			}
		}
		
		public static void Write(BinaryWriter w, uint id, int[] a) {
			w.Write((byte)0); //record separator, to find the record later. Other data does not contain 0. The minimal possible delta is 1 (see 'line = -1').
			w.Write7BitEncodedInt((int)id);
			for (int i = 0, line = -1; i < a.Length; line = a[i++]) {
				int delta = a[i] - line;
				Debug.Assert(delta > 0);
				w.Write7BitEncodedInt(delta);
			}
		}
		
		public static void Delete(FileNode f) {
			if (_Load(f, out var x)) {
				var b = x.bytes.RemoveAt(x.start, x.end - x.start);
				f.Model.TryFileOperation(FOSync.PrivateFileWrite, () => { filesystem.saveBytes(x.path, b); });
			}
		}
		
		public static void ConvertOldDb(sqlite db, FilesModel model) {
			var ms = new MemoryStream();
			using var w = new BinaryWriter(ms);
			using var p = db.Statement("SELECT id,lines FROM _editor ORDER BY id");
			while (p.Step()) {
				uint id = (uint)p.GetInt(0);
				if (model.FindById(id) != null && p.GetArray<int>(1) is { } a) {
					for (int i = 0; i < a.Length; i++) a[i] &= 0x7FFFFFF;
					_Folding.Write(w, id, a);
				}
			}
			filesystem.saveBytes(model.WorkspaceDirectory + @"\.state\folding", ms.ToArray());
		}
	}
}


================================================
FILE: Au.Editor/LibreAutomate.iss
================================================
#define MyAppName "LibreAutomate"
#define MyAppNameShort "LibreAutomate"
#define MyAppVersion "1.15.0"
#define MyAppPublisher "Gintaras Didžgalvis"
#define MyAppURL "https://www.libreautomate.com/"
#define MyAppExeName "Au.Editor.exe"

[Setup]
//note: the " C#" here is inherited from the old LA full name "LibreAutomate C#". Can't change AppId easily. Docs: not used for display anywhere.
AppId=LibreAutomate C#
AppName={#MyAppName}
AppVersion={#MyAppVersion}
UninstallDisplayName={#MyAppName}
AppPublisher={#MyAppPublisher}
AppPublisherURL={#MyAppURL}
AppSupportURL={#MyAppURL}
AppUpdatesURL={#MyAppURL}
DefaultDirName={commonpf}\{#MyAppNameShort}
SourceDir=..\_
OutputDir=.
OutputBaseFilename=LibreAutomateSetup
Compression=lzma/normal
SolidCompression=yes
ArchitecturesAllowed=x64 arm64
ArchitecturesInstallIn64BitMode=x64 arm64
MinVersion=0,6.1sp1
DisableProgramGroupPage=yes
AppMutex=Au.Editor.Mutex.m3gVxcTJN02pDrHiQ00aSQ
UsePreviousGroup=False
DisableDirPage=no
SetupIconFile=..\Au.Editor\resources\ico\app.ico
UninstallDisplayIcon={app}\{#MyAppExeName}

[Languages]
Name: "english"; MessagesFile: "compiler:Default.isl"

[Files]
#if true
Source: "Au.Editor.exe"; DestDir: "{app}"; Flags: ignoreversion
Source: "Au.Editor-arm.exe"; DestDir: "{app}"; Flags: ignoreversion
Source: "Au.Editor.dll"; DestDir: "{app}"; Flags: ignoreversion
Source: "Au.Editor.xml"; DestDir: "{app}"; Flags: ignoreversion
Source: "Au.Task-x64.exe"; DestDir: "{app}"; Flags: ignoreversion
Source: "Au.Task-arm.exe"; DestDir: "{app}"; Flags: ignoreversion
Source: "Au.dll"; DestDir: "{app}"; Flags: ignoreversion
Source: "Au.xml"; DestDir: "{app}"; Flags: ignoreversion
Source: "Au.Controls.dll"; DestDir: "{app}"; Flags: ignoreversion
Source: "Au.Controls.xml"; DestDir: "{app}"; Flags: ignoreversion
Source: "Au.Net4.exe"; DestDir: "{app}"; Flags: ignoreversion
Source: "AxMSTSCLib.dll"; DestDir: "{app}"; Flags: ignoreversion
Source: "MSTSCLib.dll"; DestDir: "{app}"; Flags: ignoreversion
Source: "Microsoft.Web.WebView2.Core.dll"; DestDir: "{app}"; Flags: ignoreversion
Source: "Microsoft.Web.WebView2.Wpf.dll"; DestDir: "{app}"; Flags: ignoreversion
Source: "runtimes\win-x64\native\WebView2Loader.dll"; DestDir: "{app}\runtimes\win-x64\native"; Flags: ignoreversion
Source: "runtimes\win-arm64\native\WebView2Loader.dll"; DestDir: "{app}\runtimes\win-arm64\native"; Flags: ignoreversion
Source: "NuGet.*.dll"; DestDir: "{app}"; Flags: ignoreversion

Source: "64\Au.AppHost.exe"; DestDir: "{app}\64"; Flags: ignoreversion
Source: "64\ARM\Au.AppHost.exe"; DestDir: "{app}\64\ARM"; Flags: ignoreversion
Source: "32\Au.AppHost.exe"; DestDir: "{app}\32"; Flags: ignoreversion

Source: "64\AuCpp.dll"; DestDir: "{app}\64"; Flags: ignoreversion
Source: "64\ARM\AuCpp.dll"; DestDir: "{app}\64\ARM"; Flags: ignoreversion
Source: "32\AuCpp.dll"; DestDir: "{app}\32"; Flags: ignoreversion

Source: "64\Au.DllHost.exe"; DestDir: "{app}\64"; Flags: ignoreversion
Source: "64\ARM\Au.DllHost.exe"; DestDir: "{app}\64\ARM"; Flags: ignoreversion
Source: "32\Au.DllHost.exe"; DestDir: "{app}\32"; Flags: ignoreversion

Source: "64\Scintilla.dll"; DestDir: "{app}\64"; Flags: ignoreversion
Source: "64\ARM\Scintilla.dll"; DestDir: "{app}\64\ARM"; Flags: ignoreversion

Source: "32\7za.exe"; DestDir: "{app}\32"; Flags: ignoreversion

Source: "Debugger\*.dll"; DestDir: "{app}\Debugger"; Flags: ignoreversion recursesubdirs
Source: "Debugger\*.exe"; DestDir: "{app}\Debugger"; Flags: ignoreversion recursesubdirs

Source: "Roslyn\*.dll"; DestDir: "{app}\Roslyn"; Flags: ignoreversion

Source: "Default\*"; DestDir: "{app}\Default"; Flags: ignoreversion
Source: "Default\Workspace\files\*"; DestDir: "{app}\Default\Workspace\files"; Flags: ignoreversion recursesubdirs
Source: "Default\Workspace\files.xml"; DestDir: "{app}\Default\Workspace"; Flags: ignoreversion
Source: "Default\Themes\*"; DestDir: "{app}\Default\Themes"; Flags: ignoreversion
Source: "Templates\files\*"; DestDir: "{app}\Templates\files"; Flags: ignoreversion recursesubdirs
Source: "Templates\files.xml"; DestDir: "{app}\Templates"; Flags: ignoreversion

Source: "doc.db"; DestDir: "{app}"; Flags: ignoreversion
Source: "doc-ai.db"; DestDir: "{app}"; Flags: ignoreversion
Source: "doc-html.db"; DestDir: "{app}"; Flags: ignoreversion
Source: "icons.db"; DestDir: "{app}"; Flags: ignoreversion
Source: "ref.db"; DestDir: "{app}"; Flags: ignoreversion
Source: "winapi.db"; DestDir: "{app}"; Flags: ignoreversion

Source: "default.exe.manifest"; DestDir: "{app}"; Flags: ignoreversion
Source: "toc.json"; DestDir: "{app}"; Flags: ignoreversion
Source: "toc-ai.yml"; DestDir: "{app}"; Flags: ignoreversion
Source: "xrefmap.yml"; DestDir: "{app}"; Flags: ignoreversion
#endif

//CONSIDER: don't include big not frequently updated files. Auto-download on demand.
//	Most .db, maybe Roslyn folder. Makes smaller: 40 MB -> 5 MB.

[Dirs]
Name: "{commonappdata}\LibreAutomate"; Flags: uninsalwaysuninstall; Permissions: authusers-modify
Name: "{app}\Git"; Flags: uninsalwaysuninstall; Permissions: authusers-modify
Name: "{app}\SDK"; Flags: uninsalwaysuninstall; Permissions: authusers-modify
Name: "{app}\Roslyn\.exeProgram"; Attribs: hidden
;why Inno stops here when debugging?

[InstallDelete]
;Type: files; Name: "{app}\file.ext"
;Type: filesandordirs; Name: "{app}\dir"
Type: filesandordirs; Name: "{app}\Roslyn"
Type: filesandordirs; Name: "{app}\64"
Type: filesandordirs; Name: "{app}\32"
Type: filesandordirs; Name: "{app}\Default"
Type: filesandordirs; Name: "{app}\Templates"

//FUTURE: remove this code
Type: files; Name: "{app}\Au.Task.exe"
Type: files; Name: "{autoprograms}\LibreAutomate C#.lnk"

[Icons]
Name: "{autoprograms}\{#MyAppName}"; Filename: "{app}\{#MyAppExeName}"

[Registry]
;register app path
Root: HKLM; Subkey: Software\Microsoft\Windows\CurrentVersion\App Paths\Au.Editor.exe; ValueType: string; ValueData: {app}\Au.Editor.exe; Flags: uninsdeletevalue uninsdeletekeyifempty

//FUTURE: remove this. It's to fix a result of a bug in the setup of LA 1.13.0, 2025/07/06, fixed in 1.13.1.
Root: HKLM; Subkey: Software\Microsoft\Windows\CurrentVersion\Uninstall\LibreAutomate_is1; Flags: deletekey

;rejected: set environment variable Au.Path, to find unmanaged dlls used by Au.dll when it is used in various scripting environments etc that copy it somewhere (they don't copy unmanaged dlls)
; Rarely used. Overwrites mine. Let users learn it, then they can use the dlls on any computer without this program installed.
;Root: HKLM; Subkey: SYSTEM\CurrentControlSet\Control\Session Manager\Environment; ValueType: string; ValueData: {app}; Flags: uninsdeletevalue

[Run]
Filename: "{app}\{#MyAppExeName}"; Flags: nowait postinstall skipifsilent; Description: "{cm:LaunchProgram,{#MyAppName}}"

[UninstallRun]
Filename: "{sys}\schtasks.exe"; Parameters: "/delete /tn \Au\Au.Editor /f"; Flags: nowait skipifdoesntexist runhidden; RunOnceId: "schtasks-delete"

;rejected because of AV false positives.
;[Files]
;Source: "Setup32.dll"; DestDir: "{app}"; Flags: ignoreversion

[Code]
//procedure Cpp_Install(step: Integer; dir: String);
//external 'Cpp_Install@files:Setup32.dll cdecl setuponly delayload';

//procedure Cpp_Uninstall(step: Integer);
//external 'Cpp_Uninstall@{app}\Setup32.dll cdecl uninstallonly delayload';

function FindWindowEx(w1, w2: Integer; cn, name: String): Integer;
external 'FindWindowExW@user32.dll';

function SendMessageTimeout(w, msg, wp, lp, flags, timeout: Integer; var res: Integer): Integer;
external 'SendMessageTimeoutW@user32.dll';

const nmax = 25000;

var
  IsDotNetInstalledCalled, IsDotNetInstalledSaidYes: Boolean;

//The same as Cpp_Unload. Maybe possible to call it, but difficult and may trigger AV FP.
procedure UnloadAuCppDll(unins: Boolean);
var
  a :Array of Integer;
  i, n, w, res :Integer;
  silent: Boolean;
begin
  //if not FileExists(ExpandConstant('{app}\64\AuCpp.dll')) then exit; //error, app still not set
  
  if unins then silent:=UninstallSilent() else silent:=WizardSilent();
  
  SetArrayLength(a, nmax);
  
  //close agent windows
  for i:=0 to nmax-1 do begin
    w:=FindWindowEx(-3, w, 'AuCpp_IPA_1', ''); //HWND_MESSAGE //if '', Pascal passes null, not ""
    if w=0 then break;
    a[i]:=w;
    inc(n);
  end;
  if n>0 then begin
    for i:=0 to n-1 do SendMessageTimeout(a[i], 16, 0, 0, 2, 5000, res); //WM_CLOSE, SMTO_ABORTIFHUNG
    if silent then Sleep(n * 50);
  end;
  //Log(IntToStr(i));
  
  //unload from processes where loaded by the clipboard hook
  if silent then SendMessageTimeout($ffff, 0, 0, 0, 2, 500, res) else SendBroadcastNotifyMessage(0, 0, 0); //HWND_BROADCAST, SMTO_ABORTIFHUNG
  n:=0; w:=0;
  for i:=0 to nmax-1 do begin
    w:=FindWindowEx(-3, w, '', ''); //HWND_MESSAGE
    if w=0 then break;
    a[i]:=w;
    inc(n);
  end;
  if silent then for i:=0 to n-1 do SendMessageTimeout(a[i], 0, 0, 0, 2, 500, res)
  else for i:=0 to n-1 do SendNotifyMessage(a[i], 0, 0, 0);
  if silent then Sleep(500);
end;

function _IsDotNetInstalled(): Boolean;
var
  args: string;
  fileName: string;
  output: AnsiString;
  resultCode: Integer;
begin
  Result := false;
  //exit;
  fileName := ExpandConstant('{tmp}\dotnet.txt');
  args := '/C dotnet --list-runtimes > "' + fileName + '" 2>&1';
  if Exec(ExpandConstant('{cmd}'), args, '', SW_HIDE, ewWaitUntilTerminated, resultCode) and (resultCode = 0) then
  begin
    if LoadStringFromFile(fileName, output) then Result := Pos('Microsoft.WindowsDesktop.App 10.', output) > 0;
  end;
  DeleteFile(fileName);
	
	//tested: If installed dotnet for multiple platforms (eg ARM64, x64, x86), only the runtime of the OS platform adds its path to PATH. It is what we need.
end;

function IsDotNetInstalled(): Boolean;
begin
  if IsDotNetInstalledCalled then
  begin
    Result := IsDotNetInstalledSaidYes;
	end else begin
		Result := _IsDotNetInstalled;
		IsDotNetInstalledSaidYes := Result;
		IsDotNetInstalledCalled := True;
  end;
end;

function InstallDotNet(): Boolean;
var
  ResultCode: Integer;
  page: TDownloadWizardPage;
  url, setupFileName, setupFilePath, txtFileName: string;
  urls: TArrayOfString;
begin
  Result := true;
  
  page := CreateDownloadPage('Installing .NET 10 Desktop Runtime', 'If stopped or failed now, download/install it manually. Size ~60 MB.', nil);
  page.Clear;
  page.Msg1Label.Caption := 'Getting the download URL of the current version.';
	txtFileName := 'net-10-url.txt';
  page.Add('https://www.libreautomate.com/download/' + txtFileName, txtFileName, '');
  page.Show;
	try
		page.Download;
		//Get the download URL of the latest .NET Desktop Runtime.
		//  Info: Script "Check for new .NET version" runs every day. If a new .NET build version available, updates the URLs here and in https://www.libreautomate.com/download/net-x-url.txt.
		//	Bad: may be inaccessible and hang, eg in China. Never mind: instead can exec curl with timeout.
		LoadStringsFromFile(ExpandConstant('{tmp}\' + txtFileName), urls);
	except
		//MsgBox('Failed: ' + 'https://www.libreautomate.com/download/' + txtFileName, mbInformation, MB_OK);
	end;
  
  //If the above failed, use these hardcoded URLs.
  //  Script "Check for new .NET version" runs every day. If a new .NET build version available, updates these strings here.
  if (Length(urls) < 2) then
  begin
    SetLength(urls, 2);
    urls[0] := 'https://builds.dotnet.microsoft.com/dotnet/WindowsDesktop/10.0.1/windowsdesktop-runtime-10.0.1-win-x64.exe';
    urls[1] := 'https://builds.dotnet.microsoft.com/dotnet/WindowsDesktop/10.0.1/windowsdesktop-runtime-10.0.1-win-arm64.exe';
  end;
	
	if IsArm64 then url := urls[1] else url := urls[0];
  setupFileName := ExtractFileName(url);
    
  page.Clear;
	page.Msg1Label.Caption := 'Downloading.';
  page.Add(url, setupFileName, '');
	try
		page.Download;
		
		page.Msg1Label.Caption := 'Running the .NET installer.';
		page.Msg2Label.Caption := setupFileName;
		page.ProgressBar.Style := npbstMarquee;
		page.AbortButton.Hide;
		
		setupFilePath := ExpandConstant('{tmp}\' + setupFileName);
		ResultCode:=-111;
		Result := Exec(setupFilePath, '/install /quiet /norestart', '', SW_HIDE, ewWaitUntilTerminated, ResultCode) and (ResultCode = 0);
		//never mind: if the .NET installer in UI mode shows "Modify Setup" (eg if dotnet dir deleted), in silent mode does nothing and returns 0.
		//	Could call _IsDotNetInstalled and retry in UI mode, but now it does not work because this process uses old PATH env var (without dotnet path).
		//info: in Windows Sandbox .NET 9.0.3+ setup hangs for ~10 minutes. Same with UI. Used to work normally. See https://github.com/microsoft/Windows-Sandbox/issues/68
		DeleteFile(setupFilePath);
	except
		if page.AbortedByUser then Log('Aborted by user.') else Log(GetExceptionMessage);
		Result := false;
	finally
		page.Hide;
	end;
end;

procedure InstallExeForCurrentArch(fileName: String);
var
  s, s64: String;
begin
  if IsArm64 then
  begin
		s := ExpandConstant('{app}\') + fileName + '.exe';
		s64 := ExpandConstant('{app}\') + fileName + '-x64.exe';
		DeleteFile(s64);
    RenameFile(s, s64);
    RenameFile(ExpandConstant('{app}\') + fileName + '-arm.exe', s);
		//info: rename both, not rename+delete. Need both x64 and ARM64 files for portable LA.
  end;
end;


function InitializeSetup(): Boolean;
begin
  //Cpp_Install(0, '');
  UnloadAuCppDll(false);
  Result:=true;
end;

function InitializeUninstall(): Boolean;
begin
  //Cpp_Uninstall(0);
  UnloadAuCppDll(true);
  Result:=true;
end;

procedure CurStepChanged(CurStep: TSetupStep);
begin
  case CurStep of
    ssInstall:
    begin
      //Cpp_Install(1, ExpandConstant('{app}\'));
    end;
    ssPostInstall:
    begin
      //Cpp_Install(2, ExpandConstant('{app}\'));
      InstallExeForCurrentArch('Au.Editor');
      if not IsDotNetInstalled() then InstallDotNet();
    end;
  end;
end;

procedure CurUninstallStepChanged(CurUninstallStep: TUninstallStep);
var
  s1: String;
begin
  case CurUninstallStep of
//     usUninstall:
//     begin
//       Cpp_Uninstall(1);
//       UnloadDLL(ExpandConstant('{app}\Setup32.dll'));
//     end;
    usPostUninstall:
    begin
      s1:=ExpandConstant('{app}');
      if DirExists(s1) and not RemoveDir(s1) then begin RestartReplace(s1, ''); end;
    end;
  end;
end;

procedure CurPageChanged(CurPageID: Integer);
begin
  if CurPageID = wpReady then
  begin
    if not IsDotNetInstalled then
    begin
      WizardForm.ReadyMemo.Lines.Add('');
      WizardForm.ReadyMemo.Lines.Add('Additional tasks:');
      WizardForm.ReadyMemo.Lines.Add('      Install .NET 10 Desktop Runtime (~60 MB download)');
    end;
  end;
end;

================================================
FILE: Au.Editor/Panels/PanelBookmarks.cs
================================================
using System.Windows.Controls;
using System.Windows.Input;
using Au.Controls;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis;
using System.Windows;

namespace LA;

class PanelBookmarks {
	KTreeView _tv;
	_Item _root;
	string _file;
	bool _initOnce;
	int _save;
	
	public PanelBookmarks() {
		_tv = new() { Name = "Bookmarks_list", SingleClickActivate = true, SmallIndent = true };
		P.Children.Add(_tv);
		
		FilesModel.AnyWorkspaceLoadedAndDocumentsOpened += _LoadIfNeed;
		
		Panels.PanelManager["Bookmarks"].DontActivateFloating = e => e == _tv;
	}
	
	public DockPanel P { get; } = new();
	
	void _LoadIfNeed() {
		if (_root != null) return;
		_root = new(null, true);
		
		_file = App.Model.WorkspaceDirectory + (miscInfo.isChildSession ? @"\bookmarks-pip.csv" : @"\bookmarks.csv");
		if (filesystem.exists(_file).File) {
			try {
				var csv = csvTable.load(_file);
				_Item folder = null;
				foreach (var a in csv.Rows) {
					if (a[0][0] == '#') {
						if (a[0].ToInt(out uint u, 1) && App.Model.FindById(u) is { } f) {
							int flags = a[1].ToInt();
							_root.AddChild(folder = new(f, 0 != (flags & 1)));
						} else {
							folder = null;
							_SaveLater(1);
						}
					} else if (folder != null) {
						folder.AddChild(new(a[0].ToInt(), 0, a[1]));
					}
				}
			}
			catch (Exception e1) { print.it(e1); }
		}
		_TvSetItems();
		
		if (!_initOnce) {
			_initOnce = true;
			
			FilesModel.UnloadingAnyWorkspace += () => {
				if (_root == null) return;
				SaveNowIfNeed();
				_root = null;
				_TvSetItems();
			};
			
			FilesModel.NeedRedraw += v => {
				if (!v.renamed) return;
				var f = _FindItemOfFile(v.f);
				if (f != null) _tv.Redraw(f, v.remeasure);
			};
			
			_tv.ItemActivated += e => {
				if (e.Mod != 0) return;
				if (e.Item is _Item b && !b.IsFolder) {
					_SetActive(b, true);
					App.Model.OpenAndGoTo(b.Parent.file, b.line);
				}
			};
			
			_tv.ItemClick += e => {
				var b = e.Item as _Item;
				switch (e.Button) {
				case MouseButton.Left:
					switch (e.Mod) {
					case ModifierKeys.Control: _DeleteItem(b); break;
					case ModifierKeys.Shift when !b.IsFolder: _Rename(b); break;
					}
					break;
				case MouseButton.Right:
					_ContextMenu(b);
					break;
				case MouseButton.Middle:
					_SetActive(b, !b.IsActiveOrHasActiveChildren);
					break;
				}
			};
			
			_tv.PreviewKeyDown += (_, e) => {
				if (e.Key is Key.Up or Key.Down && e.KeyboardDevice.Modifiers == ModifierKeys.Shift && _tv.FocusedItem is _Item { IsFolder: true } f) {
					e.Handled = true;
					_MoveFolder(f, e.Key is Key.Up);
				}
			};
			
			_tv.EditLabelStarted += e => {
				e.Text = (e.item as _Item).name; //edit without line number
				e.SelectText();
			};
			
			_tv.RightClickInEmptySpace += () => _ContextMenu(null);
			
			Panels.Editor.ClosingDoc += doc => {
				if (_FindItemOfFile(doc) is { } f) {
					foreach (var b in f.Children()) _SetActive(b, false);
				}
			};
			
			App.Timer1sWhenVisible += () => { if (_save != 0 && --_save <= 0) _SaveNow(); };
		}
	}
	
	public void SaveNowIfNeed() {
		if (_save != 0) _SaveNow();
	}
	
	void _SaveNow() {
		Action saveAction;
		if (_root.HasChildren) {
			var csv = new csvTable { ColumnCount = 2 };
			for (var f = _root.FirstChild; f != null; f = f.Next) {
				csv[^0, 0] = "#" + f.file.IdString;
				if (f.IsExpanded) csv[^1, 1] = "1";
				for (var b = f.FirstChild; b != null; b = b.Next) {
					csv.Set(^0, 0, b.line);
					csv[^1, 1] = b.name;
				}
			}
			saveAction = () => { csv.Save(_file); };
		} else {
			saveAction = () => { filesystem.saveText(_file, ""); };
		}
		if (!App.Model.TryFileOperation(FOSync.PrivateFileWrite, saveAction)) return;
		_save = 0;
		//print.it("saved");
	}
	
	void _SaveLater(int afterS = 30) {
		//print.it(new StackTrace(true));
		_save = _save == 0 ? afterS : Math.Min(_save, afterS);
	}
	
	internal void SciLoaded(SciCode doc) {
		_LoadIfNeed();
		var f = _FindItemOfFile(doc); if (f == null) return;
		bool removed = false;
		for (var b = f.FirstChild; b != null;) {
			int h = doc.aaaMarkerAdd(b.isActive ? SciTheme.Marker.Bookmark : SciTheme.Marker.BookmarkInactive, b.line);
			if (h == -1) {
				var bb = b; b = b.Next;
				bb.Remove();
				removed = true;
				_SaveLater(1);
				continue;
			}
			b.markerHandle = h;
			b = b.Next;
		}
		if (removed) _TvSetItems(true);
	}
	
	//_Item _FindItemOfFile(FileNode fn) => _root.Children().FirstOrDefault(o => o.file == fn); //slow, garbage
	_Item _FindItemOfFile(FileNode fn) {
		if (_root != null && fn != null)
			for (var f = _root.FirstChild; f != null; f = f.Next)
				if (f.file == fn) return f;
		return null;
	}
	_Item _FindItemOfFile(SciCode doc) => _FindItemOfFile(doc?.EFile);
	
	public void ToggleBookmark(int pos8 = -1) {
		var doc = Panels.Editor.ActiveDoc;
		if (doc == null) return;
		bool useSelStart = pos8 < 0;
		int line = useSelStart ? doc.aaaLineFromPos() : doc.aaaLineFromPos(false, pos8);
		if (_IsBookmark(doc, line)) {
			_DeleteBookmark(doc, line);
		} else {
			if (!useSelStart) if (doc.aaaLineFromPos() == line) useSelStart = true;
			
			int h = doc.aaaMarkerAdd(SciTheme.Marker.Bookmark, line); if (h < 0) return;
			var folder = _FindItemOfFile(doc);
			if (folder == null) {
				_root.AddChild(folder = new(doc.EFile, true), true);
			} else folder.SetIsExpanded(true);
			
			var name = GetMarkerName_(doc, line, useSelStart) ?? "Bookmark";
			_Item b = new(line, h, name) { isActive = true };
			if (folder.Children().FirstOrDefault(o => o.line > line) is { } b2) b2.AddSibling(b, false);
			else folder.AddChild(b);
			
			_TvSetItems(true);
			_tv.SelectSingle(b);
			_SaveLater();
		}
	}
	
	internal static string GetMarkerName_(SciCode doc, int line, bool useSelStart) {
		if (CodeInfo.GetDocumentAndFindNode(out var cd, out var node, useSelStart ? -2 : doc.aaaLineStart(true, line))) {
			var code = cd.code;
			if (_Node(node) is string s1) return s1 + "  " + _Line();
			return _Line();
			
			string _Line() => "¦  " + doc.aaaLineText(line).Trim().Limit(50);
			
			string _Node(SyntaxNode node) {
				for (; node != null; node = node.Parent) {
					if (node is LocalFunctionStatementSyntax or BaseMethodDeclarationSyntax or BasePropertyDeclarationSyntax or EventFieldDeclarationSyntax) {
						switch (node) {
						case LocalFunctionStatementSyntax k:
							string s1 = k.Identifier.Text + "()", s2 = _Node(k.Parent);
							return s2 == null ? s1 : $"{s1} in {s2}";
						case MethodDeclarationSyntax k:
							return k.Identifier.Text + "()";
						case ConstructorDeclarationSyntax k:
							return k.Identifier.Text + "()";
						case DestructorDeclarationSyntax k:
							return "~" + k.Identifier.Text + "()";
						case OperatorDeclarationSyntax k:
							return "operator " + k.OperatorToken.Text;
						case ConversionOperatorDeclarationSyntax k:
							return "operator " + k.Type;
						case PropertyDeclarationSyntax k:
							return k.Identifier.Text;
						case IndexerDeclarationSyntax k:
							return "this[]";
						case EventDeclarationSyntax k:
							return "event " + k.Identifier.Text;
						case EventFieldDeclarationSyntax k:
							return "event " + k.Declaration.Variables;
						}
						break;
					}
				}
				return null;
			}
		}
		return null;
	}
	
	public void NextBookmark(bool up) {
		//If there are no active bookmarks, go to next/prev bookmark in this file.
		//Else if there is an active bookmark below or above (depending on *up*) current line in this file, go to it.
		//Else go to next/prev active bookmark in any file. Start searching from (not including):
		//	If this file contains bookmarks - from next/prev file in _root.Children.
		//	Else from the focused bookmark in _tv.
		
		if (_root?.HasChildren != true) return;
		
		_Item go = null;
		var doc = Panels.Editor.ActiveDoc;
		var file = _FindItemOfFile(doc);
		
		if (_root.Descendants().Any(static o => o.isActive)) {
			if (file != null) {
				var (prev, next) = _GetPrevNextInDoc(true);
				go = up ? prev : next;
			}
			if (go == null) {
				var a = _root.Descendants().ToArray();
				var from = file != null ? (up ? file.FirstChild : file.LastChild) : _tv.FocusedItem as _Item;
				from ??= up ? a[^1] : a[0];
				int i = Array.IndexOf(a, from);
				for (; ; ) {
					if (up) i = (i > 0 ? i : a.Length) - 1; else i = ++i < a.Length ? i : 0;
					if (a[i].isActive) { go = a[i]; break; }
				}
			}
		} else if (file != null) {
			var (prev, next) = _GetPrevNextInDoc(false);
			if (prev == null && next == null) return;
			go = up ? prev ?? file.LastChild : next ?? file.FirstChild;
		}
		
		if (go != null) {
			App.Model.OpenAndGoTo(go.Parent.file, go.line);
			_tv.SelectSingle(go);
		}
		
		(_Item prev, _Item next) _GetPrevNextInDoc(bool active) {
			int line = doc.aaaLineFromPos();
			_Item prev = null;
			for (var v = file.FirstChild; v != null; v = v.Next) {
				if (active && !v.isActive) continue;
				if (v.line < line) prev = v; else if (v.line > line) return (prev, v);
			}
			return (prev, null);
		}
	}
	
	void _SetActive(_Item b, bool active) {
		if (b.IsFolder) {
			foreach (var v in b.Children()) _SetActive(v, active);
		} else if (b.isActive != active) {
			b.isActive = active;
			_tv.Redraw(b);
			
			if (b.Parent.file.OpenDoc is { } doc) {
				doc.aaaMarkerDeleteHandle(b.markerHandle);
				b.markerHandle = doc.aaaMarkerAdd(b.isActive ? SciTheme.Marker.Bookmark : SciTheme.Marker.BookmarkInactive, b.line);
			}
		}
	}
	
	void _TvSetItems(bool modified = false) {
		if (_root?.Count > 0) {
			_tv.SetItems(_root.Children(), modified);
		} else {
			_tv.SetItems(null);
		}
	}
	
	void _ContextMenu(_Item b) {
		var m = new popupMenu();
		
		if (b != null) {
			_tv.SelectSingle(b);
			
			if (b.IsFolder) {
				m["Move up\tShift+Up", disable: b.Previous == null] = o => _MoveFolder(b, true);
				m["Move down\tShift+Down", disable: b.Next == null] = o => _MoveFolder(b, false);
				m.Separator();
				m["Delete these bookmarks\tCtrl+click"] = o => _DeleteItem(b);
				m.AddCheck("Active bookmarks\tM-click", b.IsActiveOrHasActiveChildren, o => _SetActive(b, o.IsChecked));
			} else {
				m["Delete\tCtrl+click"] = o => _DeleteItem(b);
				m["Rename\tShift+click"] = o => _Rename(b);
				m.AddCheck("Active\tM-click", b.isActive, o => _SetActive(b, o.IsChecked));
			}
			m.Separator();
		} else if (!(_root?.Count > 0)) {
			print.it("To add a bookmark, click the white margin in the code editor.");
			return;
		}
		
		m["Deactivate all"] = o => { foreach (var v in _root.Children()) _SetActive(v, false); };
		m["Collapse all"] = o => { foreach (var v in _root.Children()) _tv.Expand(v, false); };
		m.Submenu("Delete all", m => {
			m["Delete all inactive bookmarks"] = o => {
				//if (1 != dialog.show("Delete all inactive bookmarks", "Are you sure?", "2 No|1 Yes", icon: DIcon.Warning, owner: _tv)) return;
				foreach (var v in _root.Descendants().ToArray()) if (!v.IsFolder && !v.isActive) _DeleteItem(v);
			};
			m["Delete all bookmarks"] = o => {
				//if (1 != dialog.show("Delete all bookmarks", "Are you sure?", "2 No|1 Yes", icon: DIcon.Warning, owner: _tv)) return;
				foreach (var v in _root.Children().ToArray()) _DeleteItem(v);
			};
		});
		
		m.Show(owner: _tv);
	}
	
	bool _IsBookmark(SciCode doc, int line) => (doc.Call(Sci.SCI_MARKERGET, line) & 3 << SciTheme.Marker.Bookmark) != 0;
	
	_Item _BookmarkFromLine(SciCode doc, int line) {
		if (_FindItemOfFile(doc) is { } folder) {
			for (int i = 0; ; i++) {
				int h = doc.Call(Sci.SCI_MARKERHANDLEFROMLINE, line, i);
				if (h < 0) return null;
				for (var b = folder.FirstChild; b != null; b = b.Next) if (b.markerHandle == h) return b;
			}
		}
		return null;
	}
	
	void _DeleteBookmark(SciCode doc, int line, bool sciDelete = true) {
		if (_BookmarkFromLine(doc, line) is { } b) {
			if (sciDelete) doc.aaaMarkerDeleteHandle(b.markerHandle);
			_DeleteBookmarkL(b);
		}
	}
	
	void _DeleteBookmarkL(_Item b) {
		var folder = b.Parent;
		b.Remove();
		if (!folder.HasChildren) folder.Remove();
		_TvSetItems(true);
		_SaveLater();
	}
	
	void _DeleteItem(_Item b) {
		if (b.IsFolder) {
			foreach (var v in b.Children().ToArray()) _DeleteItem(v);
		} else {
			var folder = b.Parent;
			if (b.markerHandle != 0 && folder.file.OpenDoc is { } doc) {
				doc.aaaMarkerDeleteHandle(b.markerHandle);
			}
			_DeleteBookmarkL(b);
		}
	}
	
	void _Rename(_Item b) {
		Panels.PanelManager[P].Visible = true;
		_tv.SelectSingle(b);
		_tv.EditLabel(b);
	}
	
	void _MoveFolder(_Item f, bool up) {
		if (up && f == _root.FirstChild) return;
		var ff = up ? f.Previous : f.Next;
		if (ff == null) return;
		f.Remove();
		ff.AddSibling(f, after: !up);
		_TvSetItems(true);
		_SaveLater();
	}
	
	internal void SciDeletingLineWithMarker(SciCode doc, int line) {
		_DeleteBookmark(doc, line, false);
	}
	
	internal void SciModified(SciCode doc, in Sci.SCNotification n) {
		if (n.linesAdded != 0) {
			//update the line field, and display
			var folder = _FindItemOfFile(doc);
			if (folder == null) return;
			bool redraw = false;
			for (var b = folder.FirstChild; b != null; b = b.Next) {
				int line = doc.Call(Sci.SCI_MARKERLINEFROMHANDLE, b.markerHandle);
				if (line != b.line) {
					b.line = line;
					redraw = true;
					_SaveLater(2 * 60);
				}
			}
			if (redraw && folder.IsExpanded) _tv.Redraw();
			//never mind: don't need to redraw if the Bookmarks panel isn't visible. It's fast, just invalidates.
		}
	}
	
	internal void AddMarginMenuItems_(SciCode doc, popupMenu m, int pos8) {
		if (_BookmarkFromLine(doc, doc.aaaLineFromPos(false, pos8)) is { } b) {
			m["Delete bookmark", "*Material.BookmarkMinus @16" + EdIcons.darkYellow] = o => ToggleBookmark(pos8);
			m["Rename bookmark"/*, "*Modern.Edit @14" + EdIcons.darkYellow*/] = o => _Rename(b);
			m.AddCheck("Active bookmark\tM-click", b.isActive, o => _SetActive(b, o.IsChecked));
		} else {
			m["Add bookmark", "*Material.Bookmark @16" + EdIcons.darkYellow] = o => ToggleBookmark(pos8);
		}
		m["Previous bookmark", "*JamIcons.ArrowSquareUp" + EdIcons.black] = o => NextBookmark(true);
		m["Next bookmark", "*JamIcons.ArrowSquareDown" + EdIcons.black] = o => NextBookmark(false);
	}
	
	internal void SciMiddleClick_(SciCode doc, int line) {
		if (_BookmarkFromLine(doc, line) is { } b) {
			_SetActive(b, !b.isActive);
		}
	}
	
	internal void FileDeleted(IEnumerable<FileNode> e) {
		foreach (var v in e) {
			if (_FindItemOfFile(v) is { } folder) {
				folder.Remove();
				_TvSetItems(true);
				_SaveLater();
			}
		}
	}
	
	class _Item : TreeBase<_Item>, ITreeViewItem {
		public readonly FileNode file; //if folder
		public int line, markerHandle; //if bookmark
		public string name;
		readonly bool _isFolder;
		bool _isExpanded;
		public bool isActive;
		
		public _Item(FileNode file, bool isExpanded) {
			this.file = file;
			_isFolder = true;
			_isExpanded = isExpanded;
		}
		
		public _Item(int line, int markerHandle, string name) {
			this.line = line;
			this.markerHandle = markerHandle;
			this.name = name;
		}
		
#if DEBUG
		public override string ToString() => ((ITreeViewItem)this).DisplayText;
#endif
		
		#region ITreeViewItem
		
		public bool IsFolder => _isFolder;
		
		public bool IsExpanded => _isExpanded;
		
		public void SetIsExpanded(bool yes) { _isExpanded = yes; Panels.Bookmarks._SaveLater(5 * 60); }
		
		IEnumerable<ITreeViewItem> ITreeViewItem.Items => base.Children();
		
		string ITreeViewItem.DisplayText => _isFolder ? (file.Parent.HasParent ? $"{file.Name}  [{file.Parent.ItemPath}]" : file.Name) : $"{(line + 1).ToS()}  {name}";
		//never mind: after moving the file should display the new path (just redraw).
		
		void ITreeViewItem.SetNewText(string text) { name = text; Panels.Bookmarks._SaveLater(); }
		
		object ITreeViewItem.Image => _isFolder ? EdIcons.FolderArrow(_isExpanded)
			: isActive ? "*Material.Bookmark @14" + EdIcons.darkYellow
			: "*Material.BookmarkOutline @14" + EdIcons.darkYellow;
		
		#endregion
		
		public bool IsActiveOrHasActiveChildren => IsFolder ? Children().Any(static o => o.isActive) : isActive;
	}
}


================================================
FILE: Au.Editor/Panels/PanelFiles.cs
================================================
using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;
using System.Windows.Documents;
using Au.Controls;
using ToolLand;

namespace LA;

partial class PanelFiles {
	FilesModel.FilesView _tv;
	KTextBox _tFind;
	timer _timerFind;
	FileNode _firstFoundFile;
	KPopup _ttError;
	
	public PanelFiles() {
		P.UiaSetName("Files panel");
		P.Background = SystemColors.ControlBrush;
		
		var b = new wpfBuilder(P).Columns(-1).Options(margin: new());
		b.Row(-1).Add(out _tv).Name("Files_list", true);
		
		b.Row(2) //maybe 4 would look better, but then can be confused with a splitter
			.Add<Border>().Border(thickness2: new(0, 1, 0, 1));
		
		_tFind = new() { BorderThickness = default };
		b.R.Add<AdornerDecorator>().Child().Add(_tFind).Name("Find_file", true)
			.Watermark("Find file").Tooltip(@"Part of file name, or wildcard expression.
Examples: part, start*, *end.cs, **r regex, **m green.cs||blue.cs.");
		
		//CONSIDER: File bookmarks. And/or tags. Probably not very useful. Unless many users will want it.
		
		b.End();
		
		_tFind.TextChanged += (_, _) => { (_timerFind ??= new(_ => _Find())).After(_tFind.Text.Length switch { 1 => 1200, 2 => 600, _ => 300 }); };
		_tFind.GotKeyboardFocus += (_, _) => P.Dispatcher.InvokeAsync(() => _tFind.SelectAll());
		_tFind.KeyDown += (_, e) => { if (e.Key is Key.Enter && _firstFoundFile != null) App.Model.OpenAndGoTo(_firstFoundFile); };
		
		_tv.EditLabelStarted += e => {
			var f = e.item as FileNode;
			var s = e.Text;
			if (f.IsFolder) {
				if (s[0] == '@') e.SelectText(1, s.Length);
			} else if (f.IsOtherFileType) {
				int i = pathname.findExtension(s);
				if (i > 0) e.SelectText(0, i);
			}
		};
		
		EditGoBack.DisableUI();
	}
	
	public UserControl P { get; } = new();
	
	public FilesModel.FilesView TreeControl => _tv;
	
	private void _Find() {
		_firstFoundFile = null;
		var s = _tFind.Text;
		
		wildex wild = null; string err = null;
		if (wildex.hasWildcardChars(s)) {
			try { wild = new wildex(s); }
			catch (Exception ex1) {
				err = ex1.Message;
				if (err.Starts("Invalid \"**options") && !s.Contains(' ')) err = null;
				s = null;
			}
		}
		if (err != null) TUtil.InfoTooltip(ref _ttError, _tFind, err); else _ttError?.Close();
		
		if (s.NE()) {
			Panels.Found.ClearResults(PanelFound.Found.Files);
			return;
		}
		
		var workingState = Panels.Found.Prepare(PanelFound.Found.Files, s, out var b);
		
		foreach (var f in App.Model.Root.Descendants()) {
			var name = f.Name;
			int i = -1;
			if (wild != null) {
				if (!wild.Match(name)) continue;
			} else {
				i = name.Find(s, true);
				if (i < 0) continue;
			}
			
			var path = f.ItemPath;
			int i1 = path.Length - name.Length;
			b.Link2(f).Gray(path.AsSpan(0, i1)).Text(name);
			if (i >= 0) {
				i += b.Length - name.Length;
				b.Indic(PanelFound.Indicators.HiliteY, i, i + s.Length);
			}
			b.Link_();
			if (f.IsFolder) b.Green("    //folder");
			b.NL();
			_firstFoundFile ??= f;
		}
		
		if (b.Length == 0) return;
		
		Panels.Found.SetResults(workingState, b);
	}
}


================================================
FILE: Au.Editor/Panels/PanelFind.cs
================================================
//TODO2: once crashed when replacing in files.
//	Can't reproduce.
//	Replaced </msdn> with </ms> in Au project. Crashed in the middle.
//	Probably crashed while saving, because left one ~backup~ file. The normal file was saved OK.
//	Process ended quickly. No exception, no log event, no dump file.

using Au.Controls;
using ToolLand;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;
using System.Media;
using System.Windows.Data;

//CONSIDER: right-click "Find" - search backward. The same for "Replace" (reject "find next"). Rarely used.
//CONSIDER: option to replace and don't find next until next click. Eg Eclipse has buttons "Replace" and "Replace/Find". Or maybe delay to preview.

namespace LA;

class PanelFind {
	KScintilla _tFind, _tReplace;
	KCheckNoBox _cCase, _cWord, _cRegex;
	Button _bInFiles, _bFilter;
	KPopup _ttRegex, _ttNext;
	
	public PanelFind() {
		P.UiaSetName("Find panel");
		
		var b = new wpfBuilder(P).Columns(-1).Brush(SystemColors.ControlBrush);
		b.Options(modifyPadding: false, margin: new Thickness(2));
		b.AlsoAll((b, _) => { if (b.Last is Button k) k.Padding = new(1, 0, 1, 1); });
		
		KScintilla _AddTextbox(string name) {
			var k = new KScintilla { AaWrapLines = true };
			var border = b.Row(-1).xAddInBorder(k);
			border.Margin = new(2, 0, 2, 0);
			b.Name(name, true);
			k.AaHandleCreated += k => _tFindReplace_HandleCreated(k);
			return k;
		}
		
		b.Row(3);
		_tFind = _AddTextbox("Find_text");
		b.xAddSplitterH();
		_tReplace = _AddTextbox("Replace_text");
		
		b.R.StartGrid().Columns((-1, ..80), (-1, ..80), (-1, ..80), 0).Margin(top: 3);
		b.R.AddButton(out var bFind, "Find", _ => _FindNextInEditor()).Tooltip("Find next in editor.\nRight click - find previous.");
		bFind.MouseRightButtonUp += (_, _) => FindNextInEditor(true);
		b.AddButton(out var bReplace, "Replace", _ => _FindNextInEditor(replace: true)).Tooltip("Replace current found text in editor and find next.\nRight click - find next.");
		bReplace.MouseRightButtonUp += (_, _) => _FindNextInEditor();
		b.AddButton("Repl. all", _bReplaceAll_Click).Tooltip("Replace all in editor");
		
		b.R.AddButton(out _bInFiles, "In files", _ => _FindAllInFiles()).Tooltip("Find text in files");
		b.StartStack();
		b.xAddButtonIcon(out _bFilter, "*Material.FolderSearchOutline" + EdIcons.green, _FilterMenu, "Let 'In files' search only in current project or root folder").Padding(1, 0, 1, 1);
		b.xAddButtonIcon("*EvaIcons.Options2" + EdIcons.green, _ => _Options(), "More options");
		
		var cmd1 = App.Commands[nameof(Menus.Edit.Navigate.Go_back)];
		b.xAddButtonIcon(EdIcons.Back, _ => Menus.Edit.Navigate.Go_back(), "Go back").Disabled(!cmd1.Enabled);
		var bBack = b.Last;
		cmd1.CanExecuteChanged += (o, e) => bBack.IsEnabled = cmd1.Enabled;
		
		b.xAddButtonIcon("*MaterialDesign.SavedSearch" + EdIcons.black, _SavedSearches, "Saved searches");
		
		b.End();
		
		b.R.StartStack();
		b.Add(out _cCase, "Case").Tooltip("Match case").Margin(right: 0).Checked(App.Settings.find_case);
		b.Add(out _cWord, "Word").Tooltip("Whole word").Margin(right: 0).Checked(App.Settings.find_word);
		
		b.Add(out _cRegex).Tooltip("Regular expression");
		b.StartGrid(true).Columns(0, 0);
		b.Add<TextBlock>("Regex").Margin("0");
		b.Add(out KButtonRoundNoBorder rxTool, ImageUtil.LoadWpfImageElement("*FileIcons.Regex @10" + EdIcons.blue)).Margin(2, 0, -3, -1).Tooltip("Regex tool");
		rxTool.Click += (_, _) => { _cRegex.IsChecked = true; _ShowRegexInfo(_tReplace.IsFocused ? _tReplace : _tFind); };
		b.End();
		b.End().End().End();
		
		_cCase.CheckChanged += _CheckedChanged;
		_cWord.CheckChanged += _CheckedChanged;
		_cRegex.CheckChanged += _CheckedChanged;
		
		P.IsVisibleChanged += (_, _) => {
			if (P.IsVisible) UpdateQuickResults();
			else {
				foreach (var d in Panels.Editor.OpenDocs) d.EInicatorsFound_(null);
				
				App.Settings.find_case = _cCase.IsChecked;
				App.Settings.find_word = _cWord.IsChecked;
			}
		};
	}
	
	public UserControl P { get; } = new();
	
	internal void CodeStylesChanged_() {
		if (!_tFind.IsLoaded) return;
		_SetCodeStyles(_tFind);
		_SetCodeStyles(_tReplace);
	}
	
	void _SetCodeStyles(KScintilla k) {
		SciTheme.Current.ToScintilla(k, fontName: App.Settings.font_find.name, fontSize: App.Settings.font_find.size);
		k.aaaStyleForeColor(255, 0xa0a0a0); //watermark
		
		if (k.Parent is Border { Parent: Grid g } b) {
			double h = Dpi.Unscale(k.aaaLineHeight(), k._dpi);
			g.RowDefinitions[Grid.GetRow(b)].MinHeight = h + 3;
		}
	}
	
	#region control events
	
	void _tFindReplace_HandleCreated(KScintilla k) {
		_SetCodeStyles(k);
		
		k.aaaMarginSetWidth(1, 0);
		k.aaaMarginSetWidth(-1, 2);
		
		if (k == _tFind) k.AaTextChanged += _ => { _RegexStyling(); UpdateQuickResults(); };
		
		_SetWatermark(true);
		
		void _SetWatermark(bool set) {
			if (set) {
				k.aaaMarginSetWidth(-1, -4);
				k.Call(Sci.SCI_EOLANNOTATIONSETSTYLE, 0, 255);
				k.aaaSetString(Sci.SCI_EOLANNOTATIONSETTEXT, 0, k == _tFind ? "Find"u8 : "Replace"u8);
				k.Call(Sci.SCI_EOLANNOTATIONSETVISIBLE, 1);
			} else {
				k.Call(Sci.SCI_EOLANNOTATIONSETVISIBLE);
				k.aaaMarginSetWidth(-1, 2);
			}
		}
		
		k.MessageHook += (nint hwnd, int msg, nint wp, nint lp, ref bool handled) => {
			var w = (wnd)hwnd;
			if (msg == Api.WM_CONTEXTMENU) {
				var m = new popupMenu();
				m["Undo\tCtrl+Z", disable: 0 == k.Call(Sci.SCI_CANUNDO)] = o => k.Call(Sci.SCI_UNDO);
				m["Redo\tCtrl+Y", disable: 0 == k.Call(Sci.SCI_CANREDO)] = o => k.Call(Sci.SCI_REDO);
				m["Cut\tCtrl+X", disable: !k.aaaHasSelection] = o => k.Call(Sci.SCI_CUT);
				m["Copy\tCtrl+C", disable: !k.aaaHasSelection] = o => k.Call(Sci.SCI_COPY);
				m["Paste\tCtrl+V", disable: 0 == k.Call(Sci.SCI_CANPASTE)] = o => k.Call(Sci.SCI_PASTE);
				m["Select all\tCtrl+A"] = o => k.Call(Sci.SCI_SELECTALL);
				m["Clear\tM-click"] = o => k.aaaClearText();
				m["Recent\tM-click"] = o => _RecentPopupList(k);
				m.Show(owner: w);
			} else if (msg == Api.WM_SETFOCUS || msg == Api.WM_KILLFOCUS) {
				bool focus = msg == Api.WM_SETFOCUS;
				if (focus) _SetWatermark(false); else if (k.aaaLen8 == 0) _SetWatermark(true);
				if (_cRegex.IsChecked) {
					if (focus) {
						//use timer to avoid temporary focus problems, for example when tabbing quickly or closing active Regex window
						timer.after(70, _ => { if (k.AaWnd.IsFocused) _ShowRegexInfo(k, onFocus: true); });
					} else if (_regexWindow?.IsVisible is true) {
						timer.after(70, _ => {
							if (_regexWindow?.IsVisible is true && !_regexWindow.Hwnd.IsActive) {
								var c = Api.GetFocus();
								if (c != _tFind.AaWnd && c != _tReplace.AaWnd) _regexWindow.Hwnd.ShowL(false);
							}
						});
					}
				}
			} else if (msg == Api.WM_MBUTTONUP) {
				if (k.aaaLen8 > 0) k.aaaClearText(); else _RecentPopupList(k);
			}
			return 0;
		};
	}
	
	RegexWindow _regexWindow;
	string _regexTopic;
	
	void _ShowRegexInfo(KScintilla k, bool onFocus = false) {
		if (onFocus) {
			if (_regexWindow == null || _regexWindow.UserClosed) return;
		} else {
			_regexWindow ??= new();
			_regexWindow.UserClosed = false;
		}
		
		if (_regexWindow.Hwnd.Is0) {
			var r = P.RectInScreen();
			r.Offset(0, -20);
			_regexWindow.ShowByRect(App.Wmain, Dock.Right, r, true);
		} else _regexWindow.Hwnd.ShowL(true);
		
		_regexWindow.InsertInControl = k;
		
		bool replace = k == _tReplace;
		var s = _regexWindow.CurrentTopic;
		if (s == "replace") {
			if (!replace) _regexWindow.CurrentTopic = _regexTopic;
		} else if (replace) {
			_regexTopic = s;
			_regexWindow.CurrentTopic = "replace";
		}
	}
	
	unsafe void _RegexStyling() {
		if (!_cRegex.IsChecked) return;
		var s = _tFind.aaaText;
		if (s.NE()) return;
		var b = new byte[s.Length];
		RegexParser.GetScintillaStylingBytes16(s, PSFormat.Regexp, b);
		_tFind.aaaSetStyling(0, KScintilla.aaaConvertStylingBytesToUtf8(b, s));
	}
	
	void _CheckedChanged(object sender, RoutedEventArgs e) {
		if (sender == _cWord) {
			if (_cWord.IsChecked) _cRegex.IsChecked = false;
		} else if (sender == _cRegex) {
			if (_cRegex.IsChecked) {
				_cWord.IsChecked = false;
				
				_RegexStyling();
			} else {
				_regexWindow?.Close();
				_regexWindow = null;
				
				_tFind.Call(Sci.SCI_STARTSTYLING);
				_tFind.Call(Sci.SCI_SETSTYLING, _tFind.aaaLen8);
			}
		}
		UpdateQuickResults();
	}
	
	void _Options() {
		var b = new wpfBuilder("Find text options").WinSize(420);
		b.R.StartGrid<KGroupBox>("Find in files");
		b.R.Add("Search in", out ComboBox cbFileType, true).Items("All files|C# files (*.cs)|Other files").Select(_SearchIn);
		b.R.Add(
			new TextBlock() { TextWrapping = TextWrapping.Wrap, Text = "Skip files whose workspace paths match a wildcard from this list" },
			out TextBox tSkip,
			App.Settings.find_skip,
			row2: 0)
			.Multiline(100, TextWrapping.NoWrap)
			.Tooltip(@"Example:
*.exe
\FolderA\*
*\FolderB\*
//Comment");
		b.R.Add(out KCheckBox cParallel, "Load files in parallel threads").Checked(App.Settings.find_parallel)
			.Tooltip("""
Load files in multiple threads simultaneously.
Makes much faster if disk is SSD, but much slower if HDD. Always faster if files are in the OS file cache. This feature can be useful if the workspace contains >1000 files.
To see maximal speed difference, before searching clear the OS file cache or restart the computer. The search time is displayed at the bottom of results if there are slow files; the 'Slow files' list does not reflect the actual speed gain.
This setting also is used by 'Find references' etc.
""");
		int iSlow = App.Settings.find_printSlow; string sSlow = iSlow > 0 ? iSlow.ToS() : null;
		b.R.StartStack().Add("Print file load+search times >=", out TextBox tSlow, sSlow).Width(50).Add<Label>("ms").End();
		b.End();
		b.R.AddOkCancel();
		b.End();
		b.Window.ShowInTaskbar = false;
		if (!b.ShowDialog(App.Wmain)) return;
		App.Settings.find_searchIn = cbFileType.SelectedIndex;
		App.Settings.find_skip = tSkip.Text; _skip = null;
		App.Settings.find_parallel = cParallel.IsChecked;
		App.Settings.find_printSlow = tSlow.Text.ToInt();
		
		//rejected: support wildex in 'skip'. Not useful.
	}
	
	void _FilterMenu(WBButtonClickArgs e) {
		int f = _filter;
		var m = new popupMenu();
		m.AddRadio("Search in entire workspace", f == 0, _ => f = 0, image: _FilterImage(0));
		m.AddRadio("Search in current root folder", f == 1, _ => f = 1, image: _FilterImage(1));
		m.AddRadio("Search in current @Project", f == 2, _ => f = 2, image: _FilterImage(2));
		m.Show();
		_SetFilter(f);
	}
	int _filter; //0 workspace, 1 root folder, 2 project or root folder
	
	static string _FilterImage(int f) => "*Material.FolderSearchOutline" + (f == 0 ? EdIcons.green : f == 1 ? EdIcons.orange : EdIcons.red);
	
	void _SetFilter(int f) {
		if (f != _filter) {
			_filter = f;
			_bFilter.Content = ImageUtil.LoadWpfImageElement(_FilterImage(f));
			_bFilter.ToolTip = f switch { 0 => "Search in entire workspace", 1 => "Search in current root folder", _ => "Search in current @Project" };
		}
	}
	
	#endregion
	
	#region common
	
	/// <summary>
	/// Makes visible and sets find text = s (should be selected text of a control; can be null/"").
	/// </summary>
	public void CtrlF(string s/*, bool findInFiles = false*/) {
		Panels.PanelManager[P].Visible = true;
		_tFind.Focus();
		if (s.NE()) {
			_tFind.Call(Sci.SCI_SELECTALL); //often user wants to type new text
			return;
		}
		_tFind.aaaText = s;
	}
	
	/// <summary>
	/// Makes visible and sets find text = selected text of e.
	/// Supports KScintilla and TextBox. If other type or null or no selected text, just makes visible etc.
	/// </summary>
	public void CtrlF(FrameworkElement e) {
		string s = null;
		switch (e) {
		case KScintilla c:
			s = c.aaaSelectedText();
			break;
		case TextBox c:
			s = c.SelectedText;
			break;
		}
		CtrlF(s);
	}
	
	/// <summary>
	/// Called when changed find text or options. Also when activated another document.
	/// Async-updates find-hiliting in editor.
	/// </summary>
	public void UpdateQuickResults() {
		if (!P.IsVisible) return;
		
		_timerUQR ??= new timer(_ => {
			Panels.Editor.ActiveDoc?.EInicatorsFound_(_FindAllInEditor());
		});
		
		_timerUQR.After(150);
	}
	timer _timerUQR;
	
	internal class TextToFind_ {
		public string findText;
		public string replaceText;
		public regexp rx;
		public bool wholeWord;
		public bool matchCase;
		public int filter;
		
		public bool IsSameFindTextAndOptions(TextToFind_ ttf)
			=> ttf.findText == findText
			&& ttf.matchCase == matchCase
			&& ttf.wholeWord == wholeWord
			&& (ttf.rx != null) == (rx != null);
		//ignore filter
		
		public int OptionsInt {
			get {
				int r = matchCase ? 1 : 0;
				if (wholeWord) r |= 2; else if (rx != null) r |= 4;
				return r | (filter << 8);
			}
		}
		
		readonly static (int flag, char letter)[] s_map = [(1, 'c'), (2, 'w'), (4, 'r'), (1 << 8, 'F'), (2 << 8, 'P'), (0x10000, 'S')];
		
		public string OptionsString(int other) => StringUtil.FlagsToLetters(OptionsInt | (other << 16), s_map);
		
		public static int OptionsStringToInt(string s) => StringUtil.FlagsFromLetters(s, s_map);
	}
	
	bool _GetTextToFind(out TextToFind_ ttf, bool forReplace = false, bool noRecent = false, bool noErrorTooltip = false) {
		_ttRegex?.Close();
		string text = _tFind.aaaText; if (text.NE()) { ttf = null; return false; }
		ttf = new() { findText = text, matchCase = _cCase.IsChecked, filter = _filter };
		try {
			if (_cRegex.IsChecked) {
				var fl = RXFlags.MULTILINE;
				if (!ttf.matchCase) fl |= RXFlags.CASELESS;
				ttf.rx = new regexp(ttf.findText, flags: fl);
			} else {
				ttf.wholeWord = _cWord.IsChecked;
			}
		}
		catch (ArgumentException e) { //regexp ctor throws if invalid
			if (!noErrorTooltip) TUtil.InfoTooltip(ref _ttRegex, _tFind, e.Message);
			return false;
		}
		if (forReplace) ttf.replaceText = _tReplace.aaaText;
		
		if (!noRecent) _AddToRecent(ttf);
		
		if (forReplace && (Panels.Editor.ActiveDoc?.aaaIsReadonly ?? true)) return false;
		return true;
	}
	
	static void _FindAllInString(string text, TextToFind_ ttf, Action<int, int> found) {
		_SkipImages si = new(text);
		
		if (ttf.rx != null) {
			foreach (var g in ttf.rx.FindAllG(text, 0)) {
				if (si.Skip(g.Start, g.End)) continue;
				found(g.Start, g.End);
			}
		} else {
			for (int i = 0; i < text.Length; i += ttf.findText.Length) {
				i = ttf.wholeWord ? text.FindWord(ttf.findText, i.., !ttf.matchCase, "_") : text.Find(ttf.findText, i, !ttf.matchCase);
				if (i < 0) break;
				int to = i + ttf.findText.Length;
				if (si.Skip(i, to)) continue;
				found(i, to);
			}
		}
	}
	
	/// <summary>
	/// Finds hidden images and determines whether a found text range is in an image.
	/// </summary>
	struct _SkipImages {
		string _text;
		int _imageStart, _imageEnd;
		
		public _SkipImages(string text) { _text = text; }
		
		/// <summary>
		/// Returns true if <i>start</i> or <i>end</i> is inside a hidden @"image:Base64" or /*image:Base64*/.
		/// </summary>
		public bool Skip(int start, int end) {
			while (start >= _imageEnd) _FindImage();
			if (end > _imageStart) {
				if (end < _imageEnd || start > _imageStart) return true;
			}
			return false;
		}
		
		void _FindImage() {
			for (int i = _imageEnd + 2; i < _text.Length; i += 6) {
				i = _text.Find("image:", i);
				if (i < 0) break;
				if (s_rx.Match(_text, 0, out RXGroup g, (i - 2)..)) {
					bool isString = _text[i - 1] == '"';
					_imageStart = i + (isString ? 6 : -2);
					_imageEnd = g.End - (isString ? 1 : 0);
					return;
				}
			}
			_imageStart = _imageEnd = int.MaxValue;
		}
		
		static regexp s_rx = new(@"@""image:[A-Za-z0-9/+]{40,}=*""|/\*image:[A-Za-z0-9/+]{40,}=*\*/", RXFlags.ANCHORED);
	}
	
	#endregion
	
	#region in editor
	
	public void FindNextInEditor(bool back) {
		if (back) {
			//this was added later. Since PCRE can't search backward, let's use _FindAllInEditor.
			_ttNext?.Close();
			var doc = Panels.Editor.ActiveDoc; if (doc == null) return;
			var a = _FindAllInEditor();
			int pos = doc.aaaSelectionStart8;
			for (int i = a.Count; --i >= 0;) {
				if (a[i].End.Value <= pos) {
					_SelectFound(true, doc, a[i].Start.Value, a[i].End.Value);
					_rxReplPos = default;
					return;
				}
			}
			SystemSounds.Asterisk.Play();
		} else {
			_FindNextInEditor();
		}
	}
	
	void _FindNextInEditor(bool replace = false) {
		if (!_GetTextToFind(out var ttf, forReplace: replace)) return;
		_FindNextInEditor2(ttf, replace);
	}
	
	void _FindNextInEditor2(TextToFind_ ttf, bool replace) {
		_ttNext?.Close();
		var doc = Panels.Editor.ActiveDoc; if (doc == null) return;
		var text = doc.aaaText; if (text.Length == 0) return;
		int i, to, len = 0, from8 = replace ? doc.aaaSelectionStart8 : doc.aaaSelectionEnd8, from = doc.aaaPos16(from8), to8 = doc.aaaSelectionEnd8;
		RXMatch rm = null;
		bool retryFromStart = false, retryRx = false;
		g1:
		if (ttf.rx != null) {
			//this code solves this problem: now would not match if the regex contains \K etc, because 'from' is different
			if (replace && _rxReplPos.doc == doc && _rxReplPos.from8 == from8 && _rxReplPos.to8 == to8 && _rxReplPos.text == text && ttf.IsSameFindTextAndOptions(_rxReplPos.ttf)) {
				i = from8; to = to8; rm = _rxReplPos.rm;
				goto g2;
			}
			
			if (ttf.rx.Match(text, out rm, from..)) {
				i = rm.Start;
				len = rm.Length;
				if (i == from && len == 0 && !(replace | retryRx | retryFromStart)) {
					if (++i > text.Length) i = -1;
					else {
						if (i < text.Length) if (text.Eq(i - 1, "\r\n") || char.IsSurrogatePair(text, i - 1)) i++;
						from = i; retryRx = true; goto g1;
					}
				}
				if (len == 0) doc.Focus();
			} else i = -1;
		} else {
			i = ttf.wholeWord ? text.FindWord(ttf.findText, from.., !ttf.matchCase, "_") : text.Find(ttf.findText, from, !ttf.matchCase);
			len = ttf.findText.Length;
		}
		if (i < 0) {
			SystemSounds.Asterisk.Play();
			_rxReplPos = default;
			if (retryFromStart || from8 == 0) return;
			from = 0; retryFromStart = true; replace = false;
			goto g1;
		}
		if (retryFromStart) TUtil.InfoTooltip(ref _ttNext, _tFind, "Info: searching from start.");
		to = doc.aaaPos8(i + len);
		i = doc.aaaPos8(i);
		g2:
		if (replace && i == from8 && to == to8) {
			var repl = ttf.replaceText;
			if (rm != null) if (!_TryExpandRegexReplacement(rm, repl, out repl)) return;
			//doc.aaaReplaceRange(i, to, repl); //also would need to set caret pos = to
			doc.aaaReplaceSel(repl);
			_FindNextInEditor2(ttf, false);
		} else if (_SelectFound(false, doc, i, to)) {
			_rxReplPos = (ttf, doc, text, i, to, rm);
		}
	}
	
	bool _SelectFound(bool back, SciCode doc, int start, int end) {
		if (CiStyling.IsProtected(doc, start, end)) {
			int skip = back ? CiStyling.SkipProtected(doc, start, true) : CiStyling.SkipProtected(doc, end, false);
			doc.aaaGoToPos(false, skip);
			return false;
		}
		
		App.Model.EditGoBack.RecordNext();
		doc.aaaSelect(false, start, end, true);
		return true;
	}
	
	(TextToFind_ ttf, SciCode doc, string text, int from8, int to8, RXMatch rm) _rxReplPos;
	
	void _bReplaceAll_Click(WBButtonClickArgs e) {
		if (!_GetTextToFind(out var ttf, forReplace: true)) return;
		_ReplaceAllInEditor(ttf);
	}
	
	//Can replace in inactive SciCode too.
	void _ReplaceAllInEditor(TextToFind_ ttf, SciCode doc = null, SciUndo undoInFiles = null) {
		doc ??= Panels.Editor.ActiveDoc;
		if (doc.aaaIsReadonly) return;
		var text = doc.aaaText;
		var a = _FindReplacements(ttf, text);
		if (doc.EFile.ReplaceAllInText(text, a, out var text2))
			undoInFiles?.RifAddFile(doc, text, text2, a);
	}
	
	void _ReplaceAllInClosedFile(TextToFind_ ttf, FileNode f, SciUndo undoInFiles) {
		if (!f.GetCurrentText(out string text, silent: null)) return;
		var a = _FindReplacements(ttf, text);
		if (f.ReplaceAllInText(text, a, out var text2))
			undoInFiles?.RifAddFile(f, text, text2, a);
	}
	
	List<StartEndText> _FindReplacements(TextToFind_ ttf, string text) {
		List<StartEndText> a = new();
		var repl = ttf.replaceText;
		if (ttf.rx != null) {
			if (ttf.rx.FindAll(text, out var ma)) {
				_SkipImages si = new(text);
				foreach (var m in ma) {
					if (si.Skip(m.Start, m.End)) continue;
					if (!_TryExpandRegexReplacement(m, repl, out var r)) break;
					a.Add(new(m.Start, m.End, r));
				}
			}
		} else {
			_FindAllInString(text, ttf, (start, end) => a.Add(new(start, end, repl)));
		}
		return a;
	}
	
	bool _TryExpandRegexReplacement(RXMatch m, string repl, out string result) {
		try {
			result = m.ExpandReplacement(repl);
			return true;
		}
		catch (Exception e) {
			TUtil.InfoTooltip(ref _ttRegex, _tReplace, e.Message);
			result = null;
			return false;
		}
	}
	
	internal bool ValidateReplacement_(TextToFind_ ttf/*, FileNode file*/) {
		//FUTURE: add regexp.IsValidReplacement and use it here.
		//if (ttf.rx != null
		//	&& file.GetCurrentText(out var s, silent: true)
		//	&& ttf.rx.Match(s, out RXMatch m)
		//	&& !_TryExpandRegexReplacement(m, _tReplace.Text, out _)
		//	) return false;
		return true;
	}
	
	List<Range> _FindAllInEditor() {
		if (!_GetTextToFind(out var ttf, noRecent: true, noErrorTooltip: true)) return null;
		var text = Panels.Editor.ActiveDoc?.aaaText; if (text.NE()) return null;
		List<Range> a = new(); //all found in editor text
		_FindAllInString(text, ttf, (start, end) => a.Add(start..end));
		return a;
	}
	
	#endregion
	
	#region in files
	
	int _SearchIn => Math.Clamp(App.Settings.find_searchIn, 0, 2);
	
	WildcardList _skip;
	readonly string[] _aSkipImagesEtc = [".png", ".bmp", ".jpg", ".jpeg", ".gif", ".tif", ".tiff", ".ico", ".cur", ".ani", ".snk", ".dll"];
	
	async void _FindAllInFiles() {
		if (_cancelTS != null) {
			_cancelTS.Cancel();
			return;
		}
		
		//using var p1 = perf.local();
		if (!_GetTextToFind(out var ttf)) return;
		
		App.Model.Save.AllNowIfNeed(); //save text of current document
		
		_bInFiles.IsEnabled = false;
		var cancelTimer = timer.after(1000, _ => { if (_cancelTS != null) { _bInFiles.Content = "Stop"; _bInFiles.IsEnabled = true; } });
		try {
			using var workingState = Panels.Found.Prepare(PanelFound.Found.Text, ttf.findText, out var b);
			
			const int c_markerFile = 0, c_markerInfo = 1;
			if (workingState.NeedToInitControl) {
				var k = workingState.Scintilla;
				k.aaaMarkerDefine(c_markerFile, Sci.SC_MARK_BACKGROUND, backColor: 0xC0E0A0);
				k.aaaMarkerDefine(c_markerInfo, Sci.SC_MARK_BACKGROUND, backColor: 0xEEE8AA);
			}
			
			FileNode folder = App.Model.Root;
			if (_filter > 0 && Panels.Editor.ActiveDoc?.EFile is FileNode fn) {
				if (_filter == 2 && fn.FindProject(out var proj, out _, ofAnyScript: true)) folder = proj;
				else folder = fn.AncestorsFromRoot(noRoot: true).FirstOrDefault() ?? folder;
			}
			
			List<(FileNode f, string s, int time, int len)> aSearchInFiles = new();
			int searchIn = _SearchIn;
			foreach (var v in folder.Descendants()) {
				if (v.IsFolder) continue;
				if (v.IsCodeFile) {
					if (searchIn == 2) continue; //0 all, 1 C#, 2 other
				} else {
					if (searchIn == 1) continue;
					if (v.Name.Ends(true, _aSkipImagesEtc) > 0) continue;
				}
				if ((_skip ??= new(App.Settings.find_skip)).IsMatch(v.ItemPath, true)) continue;
				aSearchInFiles.Add((v, v.FilePath, 0, 0));
			}
			
			List<(FileNode f, Range[] ar, string text, int i)> aResults = new();
			long timeStarted = perf.ms;
			
			//p1.Next();
			_cancelTS = new CancellationTokenSource();
			await Task.Run(() => {
				var ctoken = _cancelTS.Token;
				var po = new ParallelOptions { CancellationToken = ctoken };
				if (App.Settings.find_parallel) {
					Parallel.For(0, aSearchInFiles.Count, po, static () => new List<Range>(),
						(j, ps, ar) => {
							ref var v = ref aSearchInFiles.Ref(j);
							long t1 = perf.mcs;
							var text = FileNode.GetFileTextLL(v.s);
							_File(v.f, text, ar, j);
							v.time += (int)((perf.mcs - t1) / 100);
							v.len = text.Lenn();
							return ar;
						}, static _ => { });
				} else {
					for (int from = 0, i = 0; i < aSearchInFiles.Count; from = i) {
						for (int sumLength = 0; i < aSearchInFiles.Count && sumLength < 4_000_000; i++) { //load max 8 MB of text
							ref var v = ref aSearchInFiles.Ref(i);
							long t1 = perf.mcs;
							v.s = FileNode.GetFileTextLL(v.s);
							v.time = (int)((perf.mcs - t1) / 100);
							sumLength += v.len = v.s.Lenn();
							ctoken.ThrowIfCancellationRequested();
						}
						Parallel.For(from, i, po, static () => new List<Range>(),
							(j, ps, ar) => {
								ref var v = ref aSearchInFiles.Ref(j);
								long t1 = perf.mcs;
								_File(v.f, v.s, ar, j);
								v.time += (int)((perf.mcs - t1) / 100);
								v.s = null; //GC
								return ar;
							}, static _ => { });
						//need the Parallel in case of a very slow regex. Makes faster even if not regex.
					}
				}
				
				void _File(FileNode f, string text, List<Range> ar, int i) {
					if (text.NE() || text.Contains('\0')) return;
					
					ar.Clear();
					_FindAllInString(text, ttf, (start, end) => ar.Add(start..end));
					
					if (ar.Count > 0) {
						lock (aResults) {
							aResults.Add((f, ar.ToArray(), text, i));
						}
					}
				}
			});
			//p1.Next();
			
			int nFound = aResults.Sum(o => o.ar.Length);
			bool limited = nFound > 100_000;
			foreach (var (f, ar, text, _) in aResults.OrderBy(o => o.i)) {
				//file
				var path = f.ItemPath;
				b.Marker(c_markerFile)
					.Link2(new PanelFound.CodeLink(f, ar[0].Start.Value, isHeading: true))
					.Gray(path.AsSpan(0..^f.Name.Length))
					.B(f.Name);
				int ns = 120 - path.Length * 7 / 4; if (ns > 0) b.Text(new string(' ', ns));
				b.Link_();
				if (!limited) b.Text("    ").Link(new PanelFound.ReplaceInFileLink(f), "Replace");
				if (f.IsExternal) b.Green("    //external");
				b.NL();
				//found text instances in that file
				if (limited) continue;
				for (int i = 0; i < ar.Length; i++) {
					var range = ar[i];
					PanelFound.AppendFoundLine(b, f, text, range.Start.Value, range.End.Value, workingState, displayFile: false);
				}
			}
			
			b.Marker(c_markerInfo);
			if (aResults.Count > 0) {
				b.Text($"Found {nFound} in {aResults.Count} files.    ");
				if (!limited) b.Link("RAIF", "Replace all...");
			} else b.Text("Not found.");
			b.NL();
			
			if (folder != App.Model.Root) b.Marker(c_markerInfo).Text($"Searched only in folder '{folder.Name}'.").NL();
			if (searchIn > 0) b.Marker(c_markerInfo).Link2(new Action(_Options), $"Searched only in {(searchIn == 1 ? "C#" : "non-C#")} files.").NL();
			
			if (App.Settings.find_printSlow > 0) {
				bool once = false;
				foreach (var v in aSearchInFiles) {
					int t = v.time / 10;
					if (t < App.Settings.find_printSlow) continue;
					if (!once) {
						once = true;
						b.Marker(c_markerInfo)
							.Link2(new Action(_Options), $"Searched in {aSearchInFiles.Count} files. Time: {perf.ms - timeStarted} ms. Slow files:").NL();
					}
					b.Text($"{t} ms ").Link(v.f, v.f.ItemPath).Text($" , length {v.len}\r\n");
				}
			}
			
			//p1.Next();
			Panels.Found.SetFindInFilesResults(workingState, b, ttf, aResults.Select(o => o.f).ToList());
		}
		catch (OperationCanceledException) { }
		finally {
			_cancelTS?.Dispose();
			_cancelTS = null;
			cancelTimer.Stop();
			_bInFiles.Content = "In files";
			_bInFiles.IsEnabled = true;
		}
	}
	CancellationTokenSource _cancelTS;
	
	internal void ReplaceAllInEditorFromFoundPanel_(TextToFind_ ttf) {
		if (!_CanReplaceFromFoundPanel(ttf)) return;
		_ReplaceAllInEditor(ttf);
	}
	
	bool _CanReplaceFromFoundPanel(TextToFind_ ttf) {
		bool ok = ttf.findText == _tFind.aaaText
			&& ttf.matchCase == _cCase.IsChecked
			&& ttf.wholeWord == _cWord.IsChecked
			&& (ttf.rx != null) == _cRegex.IsChecked
			&& ttf.filter == _filter;
		if (!ok) {
			dialog.show(null, "Please click 'In files' to update the Found panel.", owner: P);
			return false;
		}
		ttf.replaceText = _tReplace.aaaText;
		_AddToRecent(ttf, onlyRepl: true);
		return true;
	}
	
	internal void ReplaceAllInFilesFromFoundPanel_(TextToFind_ ttf, List<FileNode> files) {
		if (!ValidateReplacement_(ttf)) return; //avoid opening files in editor when invalid regex replacement
		if (!_CanReplaceFromFoundPanel(ttf)) return;
		
		bool haveExternal = files.Any(o => o.IsExternal);
		
		switch (dialog.show("Replace text in files", "Replaces text in all files displayed in the Found panel.",
			haveExternal ? "1 Replace all|2 Replace all except external|0 Cancel" : "1 Replace all|0 Cancel",
			flags: /*DFlags.CommandLinks |*/ DFlags.CenterMouse,
			owner: App.Hmain)) {
		case 1:
			if (haveExternal) { //remove duplicate files (two links pointing to the same file). Else possible confusion eg disabled Undo.
				HashSet<FileId> hs = new();
				files = files.Where(o => !o.IsExternal || !filesystem.more.getFileId(o.FilePath, out var u) || hs.Add(u)).ToList();
			}
			break;
		case 2:
			files = files.Where(o => !o.IsExternal).ToList();
			break;
		default: return;
		}
		
		var progress = App.Hmain.TaskbarButton;
		var undoInFiles = SciUndo.OfWorkspace;
		try {
			undoInFiles.StartReplaceInFiles();
			progress.SetProgressState(WTBProgressState.Normal);
			
			for (int i = 0; i < files.Count; i++) {
				progress.SetProgressValue(i, files.Count);
				var f = files[i];
				if (f.OpenDoc != null) {
					_ReplaceAllInEditor(ttf, f.OpenDoc, undoInFiles);
				} else if (!f.DontSave) {
					_ReplaceAllInClosedFile(ttf, f, undoInFiles);
				}
			}
			
		}
		finally {
			undoInFiles.FinishReplaceInFiles($"replace text '{ttf.findText.Limit(50)}' with '{ttf.replaceText.Limit(50)}'");
			progress.SetProgressState(WTBProgressState.NoProgress);
			CodeInfo.FilesChanged();
		}
	}
	
	#endregion
	
	#region recent, saved
	
	string _recentPrevFind, _recentPrevReplace;
	int _recentPrevOptions;
	
	//temp is false when clicked a button, true when changed the find text or a checkbox.
	void _AddToRecent(TextToFind_ ttf, bool onlyRepl = false) {
		if (!onlyRepl) {
			int options = ttf.OptionsInt;
			if (ttf.findText != _recentPrevFind || options != _recentPrevOptions) _Add(false, _recentPrevFind = ttf.findText, _recentPrevOptions = options);
		}
		if (!ttf.replaceText.NE() && ttf.replaceText != _recentPrevReplace) _Add(true, _recentPrevReplace = ttf.replaceText, 0);
		
		static void _Add(bool replace, string text, int options) {
			if (text.Length > 3000) return;
			var ri = new _RecentItem(text, options);
			var a = _RecentLoad(replace);
			if (a.NE_()) a = new _RecentItem[] { ri };
			else if (a[0].text == text) a[0] = ri;
			else {
				for (int i = a.Length; --i > 0;) if (a[i].text == text) a = a.RemoveAt(i); //no duplicates
				if (a.Length > 29) a = a[0..29]; //limit count
				a = a.InsertAt(0, ri);
			}
			_RecentSave(replace, a);
		}
	}
	
	void _RecentPopupList(KScintilla k) {
		bool replace = k == _tReplace;
		var a = _RecentLoad(replace);
		if (a.NE_()) return;
		var p = new KPopupListBox { PlacementTarget = k };
		var c = p.Control;
		foreach (var v in a) c.Items.Add(v);
		p.OK += o => _RecentUse(o as _RecentItem, k);
		P.Dispatcher.InvokeAsync(() => p.IsOpen = true);
	}
	
	void _RecentUse(_RecentItem r, KScintilla k) {
		k.aaaText = r.text;
		if (k == _tFind) {
			int g = r.options;
			_cCase.IsChecked = 0 != (g & 1);
			_cWord.IsChecked = 0 != (g & 2);
			_cRegex.IsChecked = 0 != (g & 4);
			_SetFilter(g >> 8 & 3);
		}
	}
	
	static _RecentItem[] _RecentLoad(bool replace) {
		var file = _RecentFile(replace);
		var x = filesystem.exists(file, true).File ? csvTable.load(file) : null;
		if (x == null) return null;
		var a = new _RecentItem[x.RowCount];
		for (int i = 0; i < a.Length; i++) {
			a[i] = new(x[i][1], x[i][0].ToInt());
		}
		return a;
	}
	
	static void _RecentSave(bool replace, _RecentItem[] a) {
		var x = new csvTable { ColumnCount = 2, RowCount = a.Length };
		for (int i = 0; i < a.Length; i++) {
			x[i][0] = a[i].options.ToS();
			x[i][1] = a[i].text;
		}
		x.Save(_RecentFile(replace));
	}
	
	static string _RecentFile(bool replace) => AppSettings.DirBS + (replace ? "Recent replace.csv" : "Recent find.csv");
	
	record _RecentItem(string text, int options) {
		public override string ToString() => text.Limit(200); //ListBox item display text
	}
	
	record _SavedItem(string name, string text, int options, string repl) : _RecentItem(text, options) {
		public override string ToString() => name; //ListBox item display text
	}
	
	void _SavedSearches(WBButtonClickArgs ba) {
		string file = AppSettings.DirBS + "Saved searches.csv";
		
		Panels.Editor.SyncEditorTextIfFileIs(file, true);
		
		var p = new KPopupListBox { PlacementTarget = ba.Button };
		var c = p.Control;
		
		c.Items.Add("Save this search...");
		c.Items.Add("Edit saved searches");
		c.Items.Add(new Separator());
		
		if (filesystem.exists(file, true).File) {
			var x = csvTable.load(file); //note: no try/catch. If bad format, shows an exception mesage box with error description.
			if (x.ColumnCount < 4) x.ColumnCount = 4;
			foreach (var r in x.Rows) if (r[0].NE()) r[0] = r[2]?.Limit(200);
			foreach (var r in x.Rows.OrderBy(o => o[0], StringComparer.OrdinalIgnoreCase)) {
				if (!r[1].NE()) c.Items.Add(new _SavedItem(r[0], r[2], TextToFind_.OptionsStringToInt(r[1]), r[3]));
			}
		}
		
		(c.ItemContainerStyle = new(typeof(ListBoxItem))).Setters.Add(new Setter(ListBoxItem.ToolTipProperty, new Binding("text")));
		
		p.OK += o => {
			if (o is _SavedItem g) {
				if (g.repl is string repl) { _tReplace.Focus(); _tReplace.aaaText = repl; }
				_tFind.Focus();
				_RecentUse(g, _tFind);
				if (0 != (g.options & 0x10000)) _FindAllInFiles();
			} else if (o == c.Items[0]) { //Save this
				if (!_GetTextToFind(out var ttf, noRecent: true)) return; //info: returns false if text empty or regex invalid (shows tooltip)
				string replace = _tReplace.aaaText.NullIfEmpty_();
				
				var b = new wpfBuilder("Save this search").WinSize(400);
				b.R.Add("Name (optional)", out TextBox tName).Focus();
				b.R.Add(out KCheckBox cAndReplace, "Include the Replace field").Disabled(replace.NE());
				b.R.Add(out KCheckBox cInFiles, "Search in files when selected");
				b.R.AddOkCancel();
				b.Window.ShowInTaskbar = false;
				if (!b.ShowDialog(App.Wmain)) return;
				
				var x = filesystem.exists(file, true).File ? csvTable.load(file) : new();
				if (x.ColumnCount < 4) x.ColumnCount = 4;
				//if (x.RowCount == 0) { x.AddRow(); x.AddRow("CSV: name, options, findText, replaceText"); } //no, just adds noise
				string name = tName.Text.NullIfEmpty_(), text = ttf.findText, options = ttf.OptionsString(cInFiles.IsChecked ? 1 : 0);
				if (!cAndReplace.IsChecked) replace = null;
				string[] dup = null;
				var dupName = name is null ? null : x.Rows.FirstOrDefault(o => o[0]?.Eqi(name) == true);
				var dupText = x.Rows.FirstOrDefault(o => o[2]?.Eqi(text) == true);
				if (dupName != null || dupText != null) {
					switch (dialog.show("Replace existing?", $"A search with this {(dupName is null ? "text" : "name")} is already saved.", "1 Replace|2 Add new|0 Cancel", owner: App.Hmain)) {
					case 1: dup = dupName ?? dupText; break;
					case 2: break;
					default: return;
					}
				}
				if (dup != null) (dup[0], dup[1], dup[2], dup[3]) = (name, options, text, replace);
				else x.InsertRow(0, name, options, text, replace);
				x.Save(file);
				Panels.Editor.SyncEditorTextIfFileIs(file, false);
			} else if (o == c.Items[1]) { //Edit saved searches
				App.Model.ImportLinkOrOpen(file);
			}
		};
		
		p.IsOpen = true;
	}
	
	#endregion
}


================================================
FILE: Au.Editor/Panels/PanelFound.cs
================================================
using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;
using Au.Controls;
using static Au.Controls.Sci;

namespace LA;

class PanelFound {
	_LbItem _li;
	_KScintilla _sci;
	Grid _grid;
	ListBox _lb;
	
	public PanelFound() {
		P.UiaSetName("Found panel");
		
		var b = new wpfBuilder(P).Brush(SystemColors.ControlBrush);
		b.Options(modifyPadding: false, margin: new());
		
		var tb = b.xAddToolBar(hideOverflow: true, controlBrush: true);
		tb.UiaSetName("Found_toolbar");
		
		var cKeep = tb.AddCheckbox("*RemixIcon.Lock2Line" + EdIcons.black, "Keep results", enabled: false);
		cKeep.CheckChanged += (_, _) => { if (_sci != null) _sci.isLocked = cKeep.IsChecked; };
		
		var bCloseOF = tb.AddButton("*Codicons.CloseAll" + EdIcons.black, _ => _sci?.CloseOpenedFiles(), "Close opened files", enabled: false);
		
		b.Add<Border>().Border(thickness2: new(1, 0, 0, 0)).SpanRows(2);
		b.Child().Add(out _grid);
		
		b.Row(-1).Add(out _lb).Span(1).Border(thickness2: new(0, 1, 0, 0)).UiaName("Found_pages");
		_lb.SelectionChanged += (_, _) => {
			if (_sci != null) _sci.Visibility = Visibility.Hidden;
			_li = _lb.SelectedItem as _LbItem;
			_sci = _li?.sci;
			if (_sci != null) {
				_sci.Visibility = Visibility.Visible;
				cKeep.IsChecked = _sci.isLocked;
			} else {
				cKeep.IsChecked = false;
			}
			cKeep.IsEnabled = _sci != null && _sci.kind != Found.SymbolRename;
			bCloseOF.IsEnabled = _sci != null;
		};
		
		b.End();
		
		FilesModel.UnloadingAnyWorkspace += _CloseAll;
		
		Panels.PanelManager["Found"].DontActivateFloating = e => true;
	}
	
	public UserControl P { get; } = new();
	
	public WorkingState Prepare(Found kind, string text, out SciTextBuilder builder) {
		Panels.PanelManager[P].Visible = true;
		
		if (_sci == null || _sci.kind != kind || _sci.isLocked) {
			var li = _lb.Items.Cast<_LbItem>().FirstOrDefault(o => o.sci.kind == kind && !o.sci.isLocked);
			if (li == null) {
				var c = new _KScintilla(kind);
				_grid.Children.Add(c);
				li = new _LbItem(c, kind switch {
					Found.Files => "*FeatherIcons.File" + EdIcons.black,
					//Found.Text => "*Material.Text" + EdIcons.black,
					Found.Text => "*Material.FindReplace" + EdIcons.black,
					Found.SymbolReferences => EdIcons.References,
					Found.SymbolRename => "*PicolIcons.Edit" + EdIcons.red,
					Found.Repair => "*RPGAwesome.Repair" + EdIcons.black,
					_ => null
				}, null);
				li.ContextMenuOpening += (_, _) => {
					var m = new popupMenu();
					m["Close\tM-click"] = o => _Close(li);
					m.Show();
				};
				li.MouseDown += (_, e) => { if (e.ChangedButton == MouseButton.Middle) _Close(li); };
				_lb.Items.Add(li);
			}
			_lb.SelectedItem = li;
		}
		
		_Clear();
		_li.SetText(text.Limit(15).RxReplace(@"\R", " "), text);
		
		builder = new SciTextBuilder() {
			BoldStyle = Styles.Bold,
			GrayStyle = Styles.Gray,
			GreenStyle = Styles.Green,
			LinkIndic = Indicators.Link,
			Link2Indic = Indicators.Link2,
			user = (0, _sci)
		};
		
		if (kind is Found.Files) return new(_sci, disable: false);
		return new(_sci, disable: true);
	}
	
	public void ClearResults(Found kind) {
		if (_sci == null || _sci.kind != kind || _sci.isLocked) return;
		_Clear();
		_li.SetText(null, null);
	}
	
	void _Clear() {
		_sci.Clear();
		_docLinks = default;
	}
	
	bool _IsSciOk(in WorkingState ws) {
		return _sci == ws.Scintilla;
	}
	
	public void SetResults(in WorkingState ws, SciTextBuilder b) {
		if (!_IsSciOk(ws)) return;
		b.Apply(_sci);
	}
	
	public void SetFindInFilesResults(in WorkingState ws, SciTextBuilder b, PanelFind.TextToFind_ ttf, List<FileNode> files) {
		if (!_IsSciOk(ws)) return;
		b.Apply(_sci);
		_sci.ttf = ttf;
		_sci.files = files;
	}
	
	/// <summary>
	/// Appends limited text of line of text range <i>start..end</i>, as a link that opens file <i>f</i> and select text <i>start..end</i>, with highlighted range <i>start..end</i>.
	/// </summary>
	/// <param name="text">Text of file <i>f</i>.</param>
	public static void AppendFoundLine(SciTextBuilder b, FileNode f, string text, int start, int end, WorkingState workingState, bool displayFile, int indicHilite = Indicators.HiliteY) {
		if (b.user.i == 0) {
			var k = b.user.o as KScintilla;
			b.user.i = Math.Max((int)k.ActualWidth - k.aaaMarginGetX(4, dpiUnscale: true).right - 20, 1); //logical pixels
		}
		var fileName = displayFile ? f.Name.Limit(30) : null;
		int wid = Math.Clamp(b.user.i / 10 - (displayFile ? fileName.Length + 4 : 0), 20, 100); //chars
		int lineStart = start, lineEnd = end;
		int lsMax = Math.Max(start - wid, 0), leMax = Math.Min(end + 200, text.Length); //start/end limits like in VS
		while (lineStart > lsMax && !text.IsCsNewlineChar(lineStart - 1)) lineStart--;
		bool limitStart = lineStart > 0 && !text.IsCsNewlineChar(lineStart - 1);
		while (lineStart < start && text[lineStart] is ' ' or '\t') lineStart++;
		while (lineEnd < leMax && !text.IsCsNewlineChar(lineEnd)) lineEnd++;
		bool limitEnd = lineEnd < text.Length && !text.IsCsNewlineChar(lineEnd);
		
		b.Link2(new CodeLink(f, start));
		if (displayFile) b.Gray(fileName).Text("        ");
		if (limitStart) b.Text("…");
		b.Text(text.AsSpan(lineStart..start)).Indic(indicHilite, text.AsSpan(start..end)).Text(text.AsSpan(end..lineEnd));
		if (limitEnd) b.Text("…");
		b.Link_().NL();
		
		//CONSIDER: comments green.
		//	Now users don't see '//' if replaced with '...'.
		//	But for me it never was a problem.
	}
	
	internal void SciModified(SciCode doc, in Sci.SCNotification n) {
		var f = doc.EFile;
		
		if (_docLinks.doc != doc) { //cache links to this document, to avoid enumerating all links to all documents on each modification (slow)
			_docLinks.doc = doc;
			_docLinks.links = null;
			foreach (_LbItem li in _lb.Items) {
				if (li.sci.kind is Found.Files or Found.Repair) continue;
				foreach (var v in li.sci.AaRangeDataEnum<CodeLink>()) {
					if (v.file == f) (_docLinks.links ??= new()).Add(v);
				}
			}
		}
		if (_docLinks.links == null) return;
		
		int pos = n.position, len = n.length;
		if (n.modificationType.Has(MOD.SC_MOD_DELETETEXT)) len = -len;
		foreach (var v in _docLinks.links) {
			v.TextChanged_(pos, len);
		}
	}
	
	(SciCode doc, List<CodeLink> links) _docLinks;
	
	public void Close(KScintilla sci) {
		var li = _lb.Items.OfType<_LbItem>().FirstOrDefault(o => o.sci == sci);
		if (li != null) _Close(li);
	}
	
	void _Close(_LbItem li) {
		if (li == _li && _lb.Items.Count is int n && n > 1) {
			int i = _lb.Items.IndexOf(li);
			_lb.SelectedIndex = i == n - 1 ? i - 1 : i + 1;
		}
		_lb.Items.Remove(li);
		_CloseSci(li.sci);
	}
	
	void _CloseSci(_KScintilla sci) {
		_grid.Children.Remove(sci);
		sci.Dispose();
		if (sci.IsFocused) Keyboard.Focus(_lb);
	}
	
	void _CloseAll() {
		var a = _lb.Items.OfType<_LbItem>().ToArray();
		_lb.Items.Clear();
		foreach (var v in a) _CloseSci(v.sci);
	}
	
	public void NextFound(bool previous) {
		_sci?.NextFound(previous);
	}
	
	class _KScintilla : KScintilla {
		public readonly Found kind;
		public bool isLocked, once;
		public PanelFind.TextToFind_ ttf;
		public List<FileNode> files;
		HashSet<FileNode> _openedFiles;
		
		public _KScintilla(Found kind) {
			this.kind = kind;
			Name = "Found_" + kind;
			AaInitReadOnlyAlways = true;
			AaNoMouseSetFocus = MButtons.Right | MButtons.Middle;
			AaInitTagsStyle = AaTagsStyle.AutoAlways;
		}
		
		protected override void AaOnHandleCreated() {
			aaaMarginSetWidth(1, 0);
			aaaStyleFont(STYLE_DEFAULT, App.Wmain);
			aaaStyleClearAll();
			Call(SCI_SETCARETSTYLE, CARETSTYLE_INVISIBLE);
			Call(SCI_SETEXTRAASCENT, 1);
			Call(SCI_SETEXTRADESCENT, 1);
			
			//indicators
			aaaIndicatorDefine(Indicators.HiliteY, INDIC_STRAIGHTBOX, 0xffff00, alpha: 255, borderAlpha: 255, underText: true);
			aaaIndicatorDefine(Indicators.HiliteG, INDIC_STRAIGHTBOX, 0xC0FF60, alpha: 255, borderAlpha: 255, underText: true);
			aaaIndicatorDefine(Indicators.HiliteB, INDIC_GRADIENT, 0xA0A0FF, alpha: 255, underText: true);
			aaaIndicatorDefine(Indicators.FocusRect, INDIC_FULLBOX, 0x4169E1, alpha: 25, borderAlpha: 255, strokeWidth: _dpi / 96); //better than SC_ELEMENT_CARET_LINE_BACK/SCI_SETCARETLINEFRAME etc
			aaaIndicatorDefine(Indicators.Excluded, INDIC_STRIKE, 0xFF0000);
			
			//link indicators
			aaaIndicatorDefine(-Indicators.Link, INDIC_COMPOSITIONTHIN, 0x0080ff, hoverColor: 0x8000ff);
			aaaIndicatorDefine(-Indicators.Link + 1, INDIC_TEXTFORE, 0x0080ff, hoverColor: 0x8000ff);
			aaaIndicatorDefine(Indicators.Link2, INDIC_HIDDEN, hoverColor: 1);
			
			//styles
			aaaStyleBold(Styles.Bold, true);
			aaaStyleForeColor(Styles.Gray, 0x808080);
			aaaStyleForeColor(Styles.Green, 0x008000);
			
			if (kind == Found.SymbolReferences) aaaFoldingInit(0, autoFold: true);
			
			base.AaOnHandleCreated();
		}
		
		protected override nint WndProc(wnd w, int msg, nint wp, nint lp) {
			switch (msg) {
			case Api.WM_MBUTTONDOWN: //close file
				int pos = Call(SCI_POSITIONFROMPOINTCLOSE, Math2.LoShort(lp), Math2.HiShort(lp));
				if (pos >= 0 && AaRangeDataGet(false, pos, out object o)) {
					var f = o switch { FileNode f1 => f1, CodeLink cl => cl.file, _ => null };
					if (f != null && (_openedFiles?.Contains(f) ?? false)) //close only if opened from this panel. Else may accidentally close (eg confuse middle/right button) and lose the undo history etc.
						App.Model.CloseFile(f, selectOther: true);
				}
				return 0;
			case Api.WM_CONTEXTMENU:
				if (kind == Found.SymbolRename) {
					int i = aaaCurrentPos8;
					if (0 != aaaIndicatorGetValue(Indicators.Link2, i)) {
						var v = aaaLineStartEndFromPos(false, i);
						if (0 == aaaIndicatorGetValue(Indicators.Excluded, i)) aaaIndicatorAdd(Indicators.Excluded, false, v.start..v.end);
						else aaaIndicatorClear(Indicators.Excluded, false, v.start..v.end);
					}
				}
				return 0;
			}
			
			return base.WndProc(w, msg, wp, lp);
		}
		
		protected override void AaOnSciNotify(ref SCNotification n) {
			//if (n.code == NOTIF.SCN_MODIFIED) print.it(n.code, n.modificationType, n.position, n.length); else if (n.code is not (NOTIF.SCN_PAINTED or NOTIF.SCN_STYLENEEDED)) print.it(n.code);
			switch (n.code) {
			case NOTIF.SCN_INDICATORRELEASE:
				if (n.modifiers == 0) _OnClickIndicLink(n.position);
				break;
			}
			base.AaOnSciNotify(ref n);
		}
		
		public void Clear() {
			aaaClearText();
			ttf = null;
			files = null;
			_openedFiles = null;
		}
		
		public void CloseOpenedFiles() {
			if (_openedFiles != null) {
				App.Model.CloseFiles(_openedFiles);
				App.Model.CollapseAll(exceptWithOpenFiles: true);
				_openedFiles = null;
			}
		}
		
		void _OnClickIndicLink(int pos8) {
			if (AaRangeDataGet(false, pos8, out object o)) {
				switch (o) {
				case FileNode f:
					_OpenLinkClicked(pos8, f);
					break;
				case CodeLink k:
					if (_OpenLinkClicked(pos8, k.file)) {
						timer.after(10, _ => {
							var doc = Panels.Editor.ActiveDoc;
							if (doc?.EFile != k.file || k.start >= doc.aaaLen16) return;
							App.Model.EditGoBack.RecordNext();
							doc.aaaGoToPos(true, k.start);
							doc.Focus();
							
							//rejected: briefly show a marker, or hilite the line, or change caret color/width.
							//	More distracting than useful.
							//	The default blinking caret + default highlighting are easy to notice.
						});
						//info: scrolling works better with async when now opened the file
					}
					break;
				case ReplaceInFileLink k:
					if (_OpenLinkClicked(pos8, k.file, replaceAll: true)) {
						timer.after(10, _ => {
							if (Panels.Editor.ActiveDoc?.EFile != k.file) return;
							Panels.Find.ReplaceAllInEditorFromFoundPanel_(ttf);
						});
						//info: without timer sometimes does not set cursor pos correctly
					}
					break;
				case string s when s == "RAIF": //Replace all in all files
					Panels.Find.ReplaceAllInFilesFromFoundPanel_(ttf, files);
					break;
				case Action k:
					k.Invoke();
					break;
				default:
					Debug_.Print(o);
					break;
				}
			} else Debug_.Print(pos8);
		}
		
		bool _OpenLinkClicked(int pos8, FileNode f, bool replaceAll = false) {
			if (App.Model.IsAlien(f)) return false;
			if (f.IsFolder) f.SelectSingle();
			else {
				//avoid opening the file in editor when invalid regex replacement
				if (replaceAll && !Panels.Find.ValidateReplacement_(ttf)) return false;
				
				if (!App.Model.OpenFiles.Contains(f)) (_openedFiles ??= new()).Add(f);
				if (!App.Model.SetCurrentFile(f)) return false;
			}
			//add indicator to help the user to find this line later
			aaaIndicatorClear(Indicators.FocusRect);
			var v = aaaLineStartEndFromPos(false, pos8);
			aaaIndicatorAdd(Indicators.FocusRect, false, v.start..v.end);
			return true;
		}
		
		public void NextFound(bool previous) {
			for (int line = aaaIndicatorFindFirst(Indicators.FocusRect, out var r1) ? aaaLineFromPos(false, r1.start) : -1; ;) {
				line += (previous ? -1 : 1);
				if ((uint)line >= aaaLineCount) break;
				int pos = aaaLineStart(false, line);
				if (!AaRangeDataGet(false, pos, out CodeLink k) || k.isHeading) continue;
				_OnClickIndicLink(pos);
				break;
			}
		}
	}
	
	class _LbItem : KListBoxItemWithImage {
		public readonly _KScintilla sci;
		public _LbItem(_KScintilla sci, object image, string text) : base(image, text, 1) { this.sci = sci; }
	}
	
	public enum Found {
		Files,
		Text,
		SymbolReferences,
		SymbolRename,
		Repair
	}
	
	//CONSIDER: instead of taskbar button progress:
	//	While searching hide scintilla (or don't create until finished) and in its place show a WPF progressbar.
	//	But then need to dispatch messages, eg async-await.
	public struct WorkingState : IDisposable {
		public KScintilla Scintilla { get; private set; }
		
		public WorkingState(KScintilla sci, bool disable) {
			Scintilla = sci;
			if (disable) Panels.Found.P.IsEnabled = false;
		}
		
		public void Dispose() {
			Panels.Found.P.IsEnabled = true;
		}
		
		/// <summary>
		/// Returns true when called first time for current Scintilla control; let the caller set Scintilla styles, markers, etc. Later returns false.
		/// </summary>
		public bool NeedToInitControl {
			get {
				var k = Scintilla as _KScintilla;
				if (k.once) return false;
				k.once = true;
				return true;
			}
		}
	}
	
	public class CodeLink {
		FileNode _file;
		int _start;
		int _deletedAt;
		
		public FileNode file => _file;
		public int start => _start;
		public bool isHeading { get; private set; }
		
		public CodeLink(FileNode file, int start, bool isHeading = false) {
			_file = file;
			_start = start;
			this.isHeading = isHeading;
			_deletedAt = -1;
		}
		
		//len < 0 when deleting
		internal void TextChanged_(int pos, int len) {
			if (pos == _start) {
				if (len < 0) { _deletedAt = pos; return; } //detect when replacing the link target text. Eg replacing found substrings, or renaming found symbol references.
				if (pos != _deletedAt) _start += len;
			} else {
				if (pos < _start) _start += len;
				//never mind: will not work well in all cases. Eg when the deleted range includes _start.
			}
			_deletedAt = -1;
		}
	}
	
	public record class ReplaceInFileLink(FileNode file);
	
	/// <summary>
	/// Indices of indicators defined by this control.
	/// </summary>
	public static class Indicators {
		public const int HiliteY = 8, HiliteG = 9, HiliteB = 10, FocusRect = 11, Excluded = 12, Link = -16, Link2 = 18;
	}
	
	/// <summary>
	/// Indices of styles defined by this control.
	/// </summary>
	public static class Styles {
		public const int Bold = 30, Gray = 29, Green = 28; //31 STYLE_HIDDEN
	}
}


================================================
FILE: Au.Editor/Panels/PanelHelp.cs
================================================
using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;
using System.Xml.Linq;
using Au.Controls;
using System.Security.Authentication;
using System.Text.Json.Nodes;
using System.Net;
using System.Windows.Media;
using ToolLand;

//CONSIDER: Add a menu-button. Menu:
//	Item "Request a recipe for this search query (uses internet)".

namespace LA;

class PanelHelp {
	KTreeView _tv;
	KTextBox _search;
	_Item _root;
	_Item _selectedItem;
	List<_Item> _aiResults;
	bool _showingResults;
	bool _openingItem;
	internal (Button aiSearch, Button copyResults, ToolBarTray toolbar, Button back, Button forward, Button openInBrowser, Button toggleReadPanel) buttons_;
	
	public PanelHelp() {
		P = new();
		P.UiaSetName("Help panel");
		
		var b = new wpfBuilder(P).Columns(-1, 0, 2).Brush(SystemColors.ControlBrush);
		
		b.R.Add(out _search).Tooltip("Find documentation.\n\nMiddle-click to clear.").UiaName("Find documentation"); //rejected: watermark
		_search.TextChanged += (_, _) => _SearchInNameOnSearchTextChanged();
		_search.PreviewKeyDown += (_, e) => { if (e.Key == Key.Enter) _AiSearch(); };
		
		b.Options(modifyPadding: false, margin: new());
		
		b.xAddButtonIcon(out buttons_.aiSearch, EdIcons.AiSearch, _ => _AiSearch(), "AI search\n\nEnter");
		b.And(0).xAddButtonIcon(out buttons_.copyResults, "*Material.ContentCopy" + EdIcons.black, _CopyResultsForAiChat, "Copy results for AI chat\n\nYou can paste it in ChatGPT, Gemini, etc.\nThen the AI can answer your question better.\nPaste it anywhere in your message.").Hidden(null);
		
		_tv = new() { Name = "Help_TOC", SingleClickActivate = true, HotTrack = true, BackgroundColor = 0xf0f8e8, SmallIndent = true };
		b.Row(-1).Add(_tv);
		
		var tb = b.R.xAddToolBar(hideOverflow: true);
		buttons_.toolbar = tb.Parent as ToolBarTray;
		buttons_.toolbar.Visibility = Visibility.Collapsed; //will add buttons and show when creating web browser control
		tb.UiaSetName("Help_navigation_toolbar");
		
		b.End();
		
		Panels.PanelManager["Help"].DontActivateFloating = e => e == _tv;
		
		P.IsVisibleChanged += (_, e) => {
			if ((bool)e.NewValue && _root == null) {
				_Load();
				_tv.ItemActivated += e => _OpenItem(e.Item as _Item, false);
			}
		};
		
		//#if DEBUG
		//		_tv.ItemClick += e => {
		//			if (e.Button == MouseButton.Right) {
		//				var m = new popupMenu();
		//				m.Add("DEBUG", disable: true);
		//				//m["Print name words"] = o => _DebugGetWords();
		//				m.Show();
		//			}
		//		};
		//#endif
	}
	
	public UserControl P { get; }
	
	void _Load() {
		try {
			_root = new _Item(null, _DocKind.Folder);
			_TOC(folders.ThisAppBS + "toc.json", _root);
			
			var cookbookRoot = _root.FirstChild;
			var first = cookbookRoot.FirstChild;
			first.Remove();
			_root.AddChild(first, first: true);
			
			cookbookRoot.isExpanded = true;
			cookbookRoot.Next.isExpanded = true; //API
			
			static void _TOC(string jsonFile, _Item root) {
				var json = filesystem.loadText(jsonFile);
				var jRoot = JsonNode.Parse(json).AsArray();
				foreach (JsonObject j in jRoot) {
					var docKind = (string)j["name"] switch { "Cookbook" => _DocKind.Cookbook, "Articles" => _DocKind.Article, "Editor" => _DocKind.Editor, _ => _DocKind.Api };
					_Add(j, root, docKind);
				}
				
				static void _Add(JsonNode j, _Item ip, _DocKind docKind) {
					string name = (string)j["name"], href = (string)j["href"], symKind = null;
					if (docKind == _DocKind.Api) symKind = (string)j["kind"];
					if (j["items"] is JsonArray { Count: > 0 } ja) {
						var i = new _Item(name, _DocKind.Folder, symKind, href);
						ip.AddChild(i);
						foreach (var v in ja) {
							_Add(v, i, docKind);
						}
					} else {
						ip.AddChild(new _Item(name, docKind, symKind, href));
					}
				}
			}
			
			_tv.SetItems(_root.Children());
		}
		catch (Exception e1) { print.it(e1); }
		
		//_Test();
	}
	
	void _OpenItem(_Item item, bool select) {
		if (item == null) return;
		if (item.dir) {
			if (item.href == null) {
				_tv.Expand(item, null);
				return;
			} else if (!item.isExpanded) {
				_tv.Expand(item, true);
			}
		}
		
		if (_showingResults) {
			_selectedItem = item.clonedFrom;
		} else {
			if (select) {
				_openingItem = true;
				_search.Text = "";
				_openingItem = false;
				_tv.Select(item);
			}
			
			_selectedItem = item;
		}
		
		var s1 = item.docKind switch { _DocKind.Cookbook => "cookbook/", _DocKind.Editor => "editor/", _DocKind.Article => "articles/", _ => "api/" };
		var href = item.docKind == _DocKind.Cookbook ? Uri.EscapeDataString(item.name) + ".html" : item.href;
		HelpUtil.AuHelp($"{s1}{href}"); //opens in the Read panel or in the web browser, depending on user settings
	}
	
	void _SearchInNameOnSearchTextChanged() {
		if (_aiResults != null) {
			_aiResults = null;
			buttons_.aiSearch.Visibility = Visibility.Visible;
			buttons_.copyResults.Visibility = Visibility.Collapsed;
		}
		
		var s = _search.Text.Trim();
		if (s.Length < 2) {
			_tv.SetItems(_root.Children());
			_showingResults = false;
			if (!_openingItem && _selectedItem != null) {
				_tv.Select(_selectedItem);
			}
			return;
		}
		
		//print.clear();
		
		//CONSIDER: use Lucene.
		//rejected: use SQLite FTS5. Tried but didn't like. Lucene is much better.
		
		var root = _SearchContains(_root);
		_Item _SearchContains(_Item parent) {
			_Item R = null;
			for (var n = parent.FirstChild; n != null; n = n.Next) {
				_Item r = null;
				if (n.dir) {
					r = _SearchContains(n);
				}
				if (!n.dir || n.href != null) {
					if (n.name.Contains(s, StringComparison.OrdinalIgnoreCase)) r ??= n.Clone();
				}
				if (r != null) {
					if (R == null) {
						R = parent.Clone();
						R.isExpanded = true;
					}
					R.AddChild(r);
				}
			}
			return R;
		}
		
		//try stemmed fuzzy. Max Levenshtein distance 1 for a word.
		//	rejected: use FuzzySharp. For max distance 1 don't need it.
		bool fuzzy = root == null && s.Length >= 3;
		if (fuzzy) {
			string[] a1 = _Stem(s);
			root = _SearchFuzzy(_root);
			_Item _SearchFuzzy(_Item parent) {
				_Item R = null;
				for (var n = parent.FirstChild; n != null; n = n.Next) {
					_Item r = null;
					if (n.dir) {
						r = _SearchFuzzy(n);
					}
					if (!n.dir || n.href != null) {
						n.stemmedName ??= _Stem(n.name);
						bool allFound = true;
						foreach (var v1 in a1) {
							bool found = false;
							foreach (var v2 in n.stemmedName) {
								if (found = _Match(v1, v2)) break;
							}
							if (!(allFound &= found)) break;
						}
						if (allFound) r = n.Clone();
					}
					if (r != null) {
						if (R == null) {
							R = parent.Clone();
							R.isExpanded = true;
						}
						R.AddChild(r);
					}
				}
				return R;
			}
		}
		
		_tv.SetItems(root?.Children());
		_showingResults = true;
		
		static bool _Match(string s1, string s2) {
			if (s1[0] != s2[0] || Math.Abs(s1.Length - s2.Length) > 1) return false; //the first char must match
			if (s1.Length > s2.Length) Math2.Swap(ref s1, ref s2); //let s1 be the shorter
			
			int ib = 0, ie1 = s1.Length, ie2 = s2.Length;
			while (ib < s1.Length && s1[ib] == s2[ib]) ib++; //skip common prefix
			while (ie1 > ib && s1[ie1 - 1] == s2[--ie2]) ie1--; //skip common suffix
			
			int n = ie1 - ib;
			if (n == 1) return s1.Length == s2.Length || ib == ie1;
			return n == 0;
		}
	}
	
	string[] _Stem(string s) {
		if (_stem.stemmer == null) _stem = (new(), new(), new regexp(@"(*UCP)[^\W_]+"));
		_stem.a.Clear();
		foreach (var v in _stem.rx.FindAll(s.Lower(), 0)) {
			_stem.a.Add(_stem.stemmer.Stem(v));
		}
		return _stem.a.ToArray();
	}
	(Libs.Porter2Stemmer.EnglishPorter2Stemmer stemmer, List<string> a, regexp rx) _stem;
	
	async void _AiSearch() {
		var query = _search.Text.Trim();
		if (query.Length < 2) return;
		
		AI.AiModel.ApiKeys = App.Settings.ai_ak;
		var emModel = AI.AiModel.GetModel<AI.AiEmbeddingModel>(App.Settings.ai_modelEmbed, displayName: true);
		if (emModel == null) {
			_AiSettingsError($"Please go to Options > AI and select models for documentation search.");
			return;
		}
		var rrModel = AI.AiModel.GetModel<AI.AiRerankModel>(App.Settings.ai_modelRerank, displayName: true);
		if (rrModel == null) AI.AiModel.RerankerModelWarning();
		
		try {
			_ctsAiSearch?.Cancel();
			_ctsAiSearch?.Dispose();
			_ctsAiSearch = new();
			var cancel = _ctsAiSearch.Token;
			
			var em = new AI.Embeddings(emModel);
			var ems = await Task.Run(() => em.GetDocsEmbeddings(cancel));
			
			var r1 = _search.RectInScreen();
			using var osd = osdText.showText("Searching.\nClick to cancel.", -1, new(r1.right, r1.bottom), showMode: OsdMode.ThisThread);
			osd.Clicked += (_, _) => { _ctsAiSearch?.Cancel(); };
			
			int takePlus = Math.Min(40, query.Count(c => c is <= ' ' or ',' or '.' or ';' or '?'));
			int take = 15 + takePlus;
			
			var queryVector = await Task.Run(() => em.CreateEmbedding(query, cancel));
			var topAll = em.GetTopMatches(queryVector, ems, rrModel == null ? 50 : 150);
			if (topAll.Count == 0) return;
			
			Dictionary<string, (float score, bool summary)> dTop = [];
			foreach (var v in topAll) {
				var name = v.f.name;
				bool isSum = name[0] == '+';
				if (isSum) name = name[1..];
				dTop.TryAdd(name, (v.score, isSum));
			}
			var aTop = dTop.Select(o => (name: o.Key, v: o.Value)).OrderByDescending(o => o.v.score).ToArray();
			
			List<_Item> a = [];
			if (rrModel != null) {
				osd.Text = "Reranking.\nClick to cancel.";
				await Task.Run(() => {
					var names = aTop.Select(o => o.name).ToArray();
					var texts = em.GetDocsTexts(names);
					var headers = rrModel.GetHeaders();
					var post = rrModel.GetPostData(query, texts);
					var j = rrModel.Post(post, headers, cancel).Json();
					//print.it(j.ToJsonString(new() { WriteIndented = true }));
					var ar = rrModel.GetResults(j);
					int i = 0;
					float firstScore = 0;
					foreach (var v in ar) {
						if (i == 0) firstScore = v.score;
						if (i++ > take || firstScore - v.score > .3f || v.score < .4f) break;
						_FindAdd(names[v.index]);
					}
				});
			} else {
				float firstScore = aTop[0].v.score;
				foreach (var v in aTop) {
					if (v.v.score < firstScore - .2f) break;
					_FindAdd(v.name);
				}
			}
			
			void _FindAdd(string s) {
				if (s.Starts("[cookbook]")) {
					s = s[11..];
					if (_FindRecipe(s, true) is { } r) {
						a.Add(r.Clone());
					} else {
						Debug_.Print(s);
					}
				} else {
					bool isAPI = s[0] != '[';
					var r = _root.Children().ElementAt(isAPI ? 2 : s[1] == 'a' ? 3 : 4);
					if (isAPI) {
						int i = s.Starts("Au.More") ? 7
							: s.Starts("Au.Types") ? 8
							: s.Starts("Au.Triggers") ? 11
							: 2;
						var ns = s[..i];
						r = r.Children().First(o => o.name == ns);
						r = r.Descendants().First(o => o.ApiFullNameEquals(s));
						s = s[(i + 1)..];
						r = r.Clone(s);
					} else {
						string name = s = s[(s.IndexOf(' ') + 1)..], section = null;
						int i = s.Find(" | ");
						if (i > 0) (section, name) = (name[(i + 3)..], name[..i]);
						if (section == "other") section = null;
						
						r = r.Children().FirstOrDefault(o => o.name == name);
						if (r == null) {
							Debug_.Print(name);
							return;
						}
						
						string href = r.href;
						if (section != null) {
							s = $"{r.name} | {section}";
							section = section.Lower().Replace(' ', '-').RxReplace(@"[^[:alnum:]\-]", "");
							href = $"{href}#{section}";
						} else {
							s = r.name;
						}
						
						r = new(s, r.docKind, null, href, r);
					}
					a.Add(r);
				}
			}
			
			_tv.SetItems(a);
			_aiResults = a;
			_showingResults = true;
			buttons_.aiSearch.Visibility = Visibility.Collapsed;
			buttons_.copyResults.Visibility = Visibility.Visible;
		}
		catch (OperationCanceledException etc) { if (etc.InnerException is TimeoutException) print.it(etc.Message); }
		catch (InvalidCredentialException) {
			var api = emModel.api;
			_AiSettingsError($"Please go to Options > AI and set the API key for {api}.\nYou can create an API key in your account on the {api} website.");
		}
		catch (Exception e1) { print.it(e1); }
		
		void _AiSettingsError(string text) {
			if (!dialog.showOkCancel("AI search error", text, owner: P)) return;
			DOptions.AaShow(DOptions.EPage.AI);
		}
	}
	CancellationTokenSource _ctsAiSearch;
	
	void _CopyResultsForAiChat(WBButtonClickArgs ba) {
		if (!(_aiResults?.Count > 0)) return;
		using var db = new sqlite(folders.ThisAppBS + "doc-ai.db", SLFlags.SQLITE_OPEN_READONLY);
		var b = new StringBuilder($$"""


--- Context ---

Below are LibreAutomate documentation articles that likely contain information to answer the user question.
They are retrieved and ordered using AI embedding.
The search phrase was: {{_search.Text}}
The user question is above or below this context data. If it's missing, assume the search phrase is the question.

Articles are separated by `--- Article kind: KIND ---` lines, where KIND is one of:
- API reference - library API member reference (method, class, etc)
- library conceptual article - a library documentation article other than API member reference
- cookbook - a how-to article with code examples
- application help - LibreAutomate IDE documentation

""");
		foreach (var v_ in _aiResults) {
			var v = v_.clonedFrom;
			var name = v.name;
			var dbName = v.docKind switch {
				_DocKind.Cookbook => "[cookbook] " + name,
				_DocKind.Editor => "[editor] " + name,
				_DocKind.Article => "[articles] " + name,
				_ => v.Level == 3 ? $"{v.Parent.name}.{name}" : $"{v.Parent.Parent.name}.{v.Parent.name}.{name}"
			};
			
			if (!db.Get(out string text, "SELECT text FROM doc WHERE name=?", dbName)) { Debug_.Print(dbName); continue; }
			var docKind = v.docKind switch { _DocKind.Cookbook => "cookbook", _DocKind.Editor => "application help", _DocKind.Article => "library conceptual article", _ => "API reference" };
			b.AppendFormat("""


--- Article kind: {0} ---

{1}
""", docKind, text);
		}
		b.Append("""


--- End of context ---


""");
		
		//print.it(b.ToString());
		clipboard.text = b.ToString();
	}
	
	//#if DEBUG
	//	void _Test() {
	//		print.clear();
	//		using var db = new sqlite(folders.ThisAppBS + "doc-ai.db", SLFlags.SQLITE_OPEN_READONLY);
	//		//foreach (var v in _root.Children().ElementAt(2).Descendants().Where(o => o.Level > 2)) {
	//		//	var s = v.Level == 3 ? $"{v.Parent.name}.{v.name}" : $"{v.Parent.Parent.name}.{v.Parent.name}.{v.name}";
	//		//	//print.it(s);
	//		//	if (!db.Get(out string text, "SELECT text FROM doc WHERE name=?", s)) { Debug_.Print(s); } //fields are not included in the DB for AI
	//		//}
	//		//foreach (var v in _root.Children().ElementAt(1).Descendants().Where(o => o.Level > 2 && !o.dir)) {
	//		//	var s = "[cookbook] " + v.name;
	//		//	//print.it(s);
	//		//	if (!db.Get(out string text, "SELECT text FROM doc WHERE name=?", s)) { Debug_.Print(s); } //very small articles are not included in the DB for AI
	//		//}
	//		//foreach (var v in _root.Children().ElementAt(3).Descendants().Where(o => o.Level > 2 && !o.dir)) {
	//		//	var s = "[articles] " + v.name;
	//		//	//print.it(s);
	//		//	if (!db.Get(out string text, "SELECT text FROM doc WHERE name=?", s)) { Debug_.Print(s); }
	//		//}
	//		//foreach (var v in _root.Children().ElementAt(4).Descendants().Where(o => o.Level > 2 && !o.dir)) {
	//		//	var s = "[editor] " + v.name;
	//		//	//print.it(s);
	//		//	if (!db.Get(out string text, "SELECT text FROM doc WHERE name=?", s)) { Debug_.Print(s); }
	//		//}
	//	}
	//#endif
	
	/// <summary>
	/// Finds and opens a recipe.
	/// <para>
	/// If called in LA tools process or in a non-main LA thread, runs async in the main process/thread.
	/// </para>
	/// </summary>
	/// <param name="name">Wildcard or start or any substring of recipe name.</param>
	public static void OpenRecipe(string name) {
		if (process.IsLaMainThread_) Panels.Help._OpenRecipe(name);
		else if (process.IsLaProcess_) App.Dispatcher.InvokeAsync(() => OpenRecipe(name));
		else WndCopyData.Send<char>(ScriptEditor.WndMsg_, 18, name);
	}
	
	void _OpenRecipe(string name) {
		Panels.PanelManager[P].Visible = true;
		_OpenItem(_FindRecipe(name), true);
	}
	
	_Item _FindRecipe(string s, bool exact = false) {
		var d = _root.Descendants().Where(o => o.docKind is _DocKind.Cookbook);
		if (exact) return d.FirstOrDefault(o => !o.dir && o.name == s);
		return d.FirstOrDefault(o => !o.dir && o.name.Like(s, true))
			?? d.FirstOrDefault(o => !o.dir && o.name.Starts(s, true))
			?? d.FirstOrDefault(o => !o.dir && o.name.Find(s, true) >= 0);
	}
	
	public void MenuCommand() {
		Panels.PanelManager[P].Visible = true;
		_search.Focus();
		
		if (_selectedItem == null && !App.Settings.doc_web) {
			_OpenItem(_root.FirstChild, true);
		}
	}
	
	//#if DEBUG
	//	void _DebugGetWords() {
	//		print.clear();
	//		var hs = new HashSet<string>();
	//		foreach (var recipe in _root.Descendants().Where(o => o.docKind is _DocKind.Cookbook)) {
	//			var a = _Stem(recipe.name);
	//			foreach (var s in a)
	//				if (s.Length > 2 && !s[0].IsAsciiDigit()) hs.Add(s);
	//		}
	//		print.it(hs.OrderBy(o => o, StringComparer.OrdinalIgnoreCase));
	//	}
	//#endif
	
	enum _DocKind : byte { Folder, Cookbook, Api, Editor, Article }
	
	class _Item : TreeBase<_Item>, ITreeViewItem {
		internal readonly string name;
		internal readonly _DocKind docKind;
		internal readonly string symKind;
		internal readonly string href;
		internal readonly _Item clonedFrom;
		internal bool isExpanded;
		internal string[] stemmedName;
		
		public _Item(string name, _DocKind docKind, string symKind = null, string href = null, _Item clonedFrom = null) {
			this.name = name;
			this.docKind = docKind;
			this.symKind = symKind;
			this.href = href;
			this.clonedFrom = clonedFrom;
		}
		
		public _Item Clone(string newName = null) => new(newName ?? name, docKind, symKind, href, this);
		
		internal bool dir => docKind == _DocKind.Folder;
		
		#region ITreeViewItem
		
		string ITreeViewItem.DisplayText => name;
		
		object ITreeViewItem.Image
			=> docKind switch {
				_DocKind.Folder => symKind != null ? _KindIcon : EdIcons.FolderArrow(isExpanded),
				_DocKind.Cookbook => name == "Documentation" ? EdIcons.Help : "*BoxIcons.RegularCookie" + EdIcons.darkYellow,
				_DocKind.Api => _KindIcon,
				_DocKind.Editor => "*Material.ApplicationOutline" + EdIcons.blue,
				_DocKind.Article => "*PhosphorIcons.Article" + EdIcons.black,
				_ => null
			};
		
		string _KindIcon => symKind switch {
			"Namespace" => "resources/ci/namespace.xaml",
			"Class" => "resources/ci/class.xaml",
			"Struct" => "resources/ci/structure.xaml",
			"Enum" => "resources/ci/enum.xaml",
			"Interface" => "resources/ci/interface.xaml",
			"Delegate" => "resources/ci/delegate.xaml",
			"Method" or "Constructor" => "resources/ci/method.xaml",
			"Property" or "Indexer" => "resources/ci/property.xaml",
			"Event" => "resources/ci/event.xaml",
			"Field" => "resources/ci/field.xaml",
			"Operator" => "resources/ci/operator.xaml",
			_ => null
		};
		
		void ITreeViewItem.SetIsExpanded(bool yes) { isExpanded = yes; }
		
		bool ITreeViewItem.IsExpanded => isExpanded;
		
		IEnumerable<ITreeViewItem> ITreeViewItem.Items => base.Children();
		
		bool ITreeViewItem.IsFolder => dir;
		
		#endregion
		
		public bool ApiFullNameEquals(string s) {
			if (!s.Ends(name)) return false;
			int i1 = s.Length - name.Length - 1;
			if (s[i1] != '.') return false;
			int level = Level; if (!(level is 3 or 4)) return false;
			var t = this;
			if (level == 4) { //member of a type
				t = Parent; //type
				int i2 = i1 - t.name.Length;
				if (!s.Eq(i2, t.name) || !s.Eq(--i2, '.')) return false;
				i1 = i2;
			}
			t = t.Parent; //namespace
			if (i1 != t.name.Length || !s.Starts(t.name)) return false;
			return true;
		}
	}
}


================================================
FILE: Au.Editor/Panels/PanelMouse.cs
================================================
using Au.Controls;
using System.Windows;
using System.Windows.Controls;

namespace LA;

class PanelMouse {
	KScintilla _sci;
	POINT _prevXY;
	wnd _prevWnd;
	string _prevWndName;
	int _prevCounter;
	
	public PanelMouse() {
		//P.UiaSetName("Mouse panel"); //no UIA element for Panel
		
		_sci = new KScintilla_(this) { Name = "Mouse_info" };
		P.Children.Add(_sci);
	}
	
	public Grid P { get; } = new();
	
	void _MouseInfo() {
		//using var p1 = perf.local();
		if (!P.IsVisible) return;
		
		var p = mouse.xy;
		if (p == _prevXY && ++_prevCounter < 4) return; _prevCounter = 0; //use less CPU. c and wName rarely change when same p.
		var c = wnd.fromXY(p);
		//p1.Next();
		var w = c.Window;
		string wName = w.Name;
		if (p == _prevXY && c == _prevWnd && wName == _prevWndName) return;
		_prevXY = p;
		_prevWnd = c;
		_prevWndName = wName;
		
		string lineSep = App.Settings.mouse_singleLine ? "    ..    " : "\r\n";
		int limit = Math.Clamp(App.Settings.mouse_limitText, 20, 10000);
		
		//p1.Next();
		using (new StringBuilder_(out var b)) {
			var cn = w.ClassName;
			if (cn != null) {
				var pc = p; w.MapScreenToClient(ref pc);
				b.AppendFormat("<b>Mouse</b> {0,5} {1,5}  .  <b>in window</b> {2,5} {3,5}    ..    <b>Program</b>  {4}",
					p.x, p.y, pc.x, pc.y, w.ProgramName?.Escape(limit));
				if (c.UacAccessDenied) b.Append(" <c red>(admin)<>");
				b.AppendFormat("{0}<b>Window   ", lineSep);
				var name = wName?.Escape(limit); if (!name.NE()) b.AppendFormat("</b>{0}  .  <b>", name);
				b.Append("cn</b>  ").Append(cn.Escape(limit));
				if (c != w) {
					b.AppendFormat("{0}<b>Control   id</b>  {1}  .  <b>cn</b>  {2}",
						lineSep, c.ControlId, c.ClassName?.Escape(limit));
					var ct = c.Name;
					if (!ct.NE()) b.Append("  .  <b>name</b>  ").Append(ct.Escape(limit));
				} else if (cn == "#32768") {
					var m = MenuItemInfo.FromXY(p, w, 50);
					if (m != null) {
						b.AppendFormat("{0}<b>Menu   id</b>  {1}", lineSep, m.ItemId);
						if (m.IsSystem) b.Append(" (system)");
						//print.it(m.GetText(true, true));
					}
				}
				
				//rejected. Makes this func 5 times slower.
				//var color = CaptureScreen.Pixel(p);
			}
			var s = b.ToString();
			//p1.Next();
			_sci.aaaSetText(s);
		}
	}
	
	//public void SetMouseInfoText(string text)
	//{
	//	if(Dispatcher.Thread == Thread.CurrentThread) _SetMouseInfoText(text);
	//	else Dispatcher.InvokeAsync(() => _SetMouseInfoText(text));
	//
	//	void _SetMouseInfoText(string text) { _sci.aaaSetText(text); }
	//}
	
	internal class KScintilla_ : KScintilla {
		PanelMouse _p;
		
		internal KScintilla_(PanelMouse panel) {
			_p = panel;
			
			AaInitReadOnlyAlways = true;
			AaInitTagsStyle = KScintilla.AaTagsStyle.AutoAlways;
		}
		
		protected override void AaOnHandleCreated() {
			aaaStyleBackColor(Sci.STYLE_DEFAULT, 0xF0F0F0);
			aaaStyleFont(Sci.STYLE_DEFAULT, App.Wmain);
			aaaMarginSetWidth(1, 4);
			aaaStyleClearAll();
			Call(Sci.SCI_SETHSCROLLBAR);
			Call(Sci.SCI_SETVSCROLLBAR);
			Call(Sci.SCI_SETWRAPMODE, Sci.SC_WRAP_WORD);
			
			App.Timer025sWhenVisible += _p._MouseInfo;
		}
		
		protected override IntPtr WndProc(IntPtr hwnd, int msg, IntPtr wParam, IntPtr lParam, ref bool handled) {
			//WndUtil.PrintMsg(out var s, default, msg, wParam, lParam); print.qm2.write(s);
			switch (msg) {
			case Api.WM_CONTEXTMENU:
				var m = new popupMenu();
				m.AddCheck("Single line", App.Settings.mouse_singleLine, o => { App.Settings.mouse_singleLine = o.IsChecked; });
				m["Text length..."] = o => { if (dialog.showInputNumber(out int i, "Mouse panel", "Maximal length of name, cn and program strings.", editText: App.Settings.mouse_limitText, owner: Handle)) App.Settings.mouse_limitText = i > 0 ? i : 100; };
				m.Show(owner: Handle);
				return default;
			}
			return base.WndProc(hwnd, msg, wParam, lParam, ref handled);
		}
	}
}


================================================
FILE: Au.Editor/Panels/PanelOpen.cs
================================================
using Au.Controls;
using System.Windows.Controls;
using System.Windows.Input;

namespace LA;

class PanelOpen {
	KTreeView _tv;
	bool _updatedOnce;
	bool _closing;

	public PanelOpen() {
		//P.UiaSetName("Open panel"); //no UIA element for Panel

		_tv = new() { Name = "Open_list" };
		P.Children.Add(_tv);
		
		Panels.PanelManager["Open"].DontActivateFloating = e => true;
	}

	public DockPanel P { get; } = new();

	public KTreeView TreeControl => _tv;

	public void UpdateList() {
		var e = App.Model.OpenFiles.Select(o => new _Item { f = o });
		if (_Sort) e = e.OrderBy(o => o.f.Name, StringComparer.OrdinalIgnoreCase)
				.ThenBy(o => o.f.Id); //to make stable when there are multiple files with same name
		_tv.SetItems(e, _updatedOnce);
		_SelectCurrent(true);
		if (!_updatedOnce) {
			_updatedOnce = true;
			FilesModel.NeedRedraw += v => {
				if (v.f != null && !App.Model.OpenFiles.Contains(v.f)) return;
				if (v.renamed && _Sort) UpdateList();
				else _tv.Redraw(v.remeasure);
			};
			_tv.ItemClick += _tv_ItemClick;
			//_tv.ContextMenuOpening += (_,_) => //never mind
		}
	}

	private void _tv_ItemClick(TVItemEventArgs e) {
		if (e.Mod != 0 || e.ClickCount != 1) return;
		var f = (e.Item as _Item).f;
		switch (e.Button) {
		case MouseButton.Left:
			App.Model.SetCurrentFile(f);
			break;
		case MouseButton.Right:
			_tv.SelectSingle(e.Item);
			_ContextMenu(f);
			break;
		case MouseButton.Middle:
			_CloseFile(f);
			break;
		}
	}

	void _CloseFile(FileNode f) {
		_closing = true; //prevent scrolling to top when closing an item near the bottom
		App.Model.CloseFile(f, selectOther: true);
		_closing = false;
	}

	void _ContextMenu(FileNode f) {
		var m = new popupMenu();
		m.Add(1, "Close\tM-click");
		m.Add(2, "Close all other");
		m.Add(3, "Close all");
		m.Separator();
		m.AddCheck("Sort alphabetically", _Sort).Id = 4;
		var r = m.Show();
		switch (r) {
		case 1:
			_CloseFile(f);
			return;
		case 2:
			App.Model.CloseEtc(FilesModel.ECloseCmd.CloseAll, dontClose: f);
			return;
		case 3:
			App.Model.CloseEtc(FilesModel.ECloseCmd.CloseAll);
			return;
		case 4:
			App.Settings.openFiles_flags ^= 1;
			UpdateList();
			return;
		}
		_SelectCurrent(false);
	}

	void _SelectCurrent(bool focus) {
		if (_tv.CountVisible == 0) return;
		int i = _Sort ? _tv.IndexOf(o => (o as _Item).f == App.Model.CurrentFile) : 0;
		if (focus) _tv.SetFocusedItem(i, _closing ? 0 : TVFocus.EnsureVisible);
		_tv.SelectSingle(i, andFocus: false);
	}

	static bool _Sort => 0 != (1 & App.Settings.openFiles_flags);

	class _Item : ITreeViewItem {
		public FileNode f;

		#region ITreeViewItem

		string ITreeViewItem.DisplayText => f.DisplayName;

		object ITreeViewItem.Image => f.Image;

		#endregion
	}
}


================================================
FILE: Au.Editor/Panels/PanelOutline.cs
================================================
using System.Windows.Controls;
using Au.Controls;

using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.CSharp.Extensions;

namespace LA;

class PanelOutline {
	KTreeView _tv;
	SciCode _activeDoc;
	bool _modified;
	bool _once;
	_Item _oldTree;

	public PanelOutline() {
		//P.UiaSetName("Outline panel");

		_tv = new KTreeView { Name = "Outline_list", SingleClickActivate = true, HotTrack = true };
		_tv.ItemClick += e => { if (e.Button == System.Windows.Input.MouseButton.Right) _ContextMenu(); };
		_tv.ContextMenuOpening += (_, _) => _ContextMenu(); //right-click in empty space
		P.Children.Add(_tv);
		
		Panels.PanelManager["Outline"].DontActivateFloating = e => e == _tv;
	}

	public DockPanel P { get; } = new();

	public void Timer025sWhenVisible() {
		if (_activeDoc == null || _modified) Update(); else if (!P.IsVisible) Clear();
		//if (_oldTree != null) if (0 != (4 & App.Settings.outline_flags)) _Sync();
	}

	public void SciModified() {
		if (_activeDoc != null) _modified = true;
	}

	public void Update() {
		if (P.IsVisible) {
			try { if (_Update()) return; }
			catch (Exception e1) { print.it(e1); }
		}
		Clear();
	}

	bool _Update() {
		//print.it("update");
		//using var p1 = perf.local();
		if (!CodeInfo.GetContextAndDocument(out var cd, 0, metaToo: true)) return false;
		var cu = cd.syntaxRoot;

		var root = new _Item();

		//at first get regions
		if (cu.ContainsDirectives) {
			_Item regions = null;
			for (var d = cu.GetFirstDirective(); d != null; d = d.GetNextDirective()) {
				if (!d.IsKind(SyntaxKind.RegionDirectiveTrivia) || !d.IsActive) continue;
				var s = d.EndOfDirectiveToken.LeadingTrivia.ToString(); if (s.NE()) continue;
				if (regions == null) root.AddChild(regions = new("#region", CiItemKind.Region, 0));
				regions.AddChild(new(s, CiItemKind.Region, d.SpanStart));
			}
		}

		//then get member declarations
		var members = cu.Members;
		while (members.Count == 1) {
			var f = members.First();
			if (f is BaseNamespaceDeclarationSyntax nd) members = nd.Members;
			else if (f is TypeDeclarationSyntax td) members = td.Members;
			else break;
		}
		//p1.Next('d');
		_Members(root, members, 0);
		//p1.Next('m');

		void _Members(_Item parent, SyntaxList<MemberDeclarationSyntax> members, int level) {
			int sort = App.Settings.outline_flags & 3;
			List<_Item> a = sort != 0 ? new() : null;
			_Item locals = null;
			foreach (var m in members) {
				if (level == 0 && m is GlobalStatementSyntax g) {
					if (g.Statement is not LocalFunctionStatementSyntax d) continue;
					if (locals == null) parent.AddChild(locals = new("Local functions", CiItemKind.LocalMethod, 0));
					var k = new _Item(d);
					locals.AddChild(k);
				} else {
					var k = new _Item(m);
					if (a != null) a.Add(k); else parent.AddChild(k);
					switch (m) {
					case BaseNamespaceDeclarationSyntax d:
						_Members(k, d.Members, level + 1);
						break;
					case TypeDeclarationSyntax d:
						_Members(k, d.Members, level + 1);
						break;
					}
				}
			}
			if (a != null) {
				a.Sort((i1, i2) => {
					if (sort >= 2) {
						int k1 = (int)i1._kind, k2 = (int)i2._kind;
						if (k1 != k2) return k1 - k2;
						//if (sort == 2) return i1._pos - i2._pos;
					}
					string s1 = i1._text, s2 = i2._text;
					bool a1 = s1[0].IsAsciiAlpha(), a2 = s2[0].IsAsciiAlpha();
					if (a1 != a2) return a1 ? -1 : 1;
					return string.CompareOrdinal(s1, s2);
				});
				foreach (var v in a) parent.AddChild(v);
			}
		}

		_modified = false;
		_activeDoc = cd.sci;
		//_oldDocument = cd.document;

		int changed = 4;
		if (_oldTree != null) {
			changed = _TreeChanged(_oldTree, root);
			//print.it(changed);
			if (changed == 0) {
				_UpdatePos(_oldTree, root);
				return true;
			}
		}
		_oldTree = root;
		//p1.Next('c');

		if (!_once) {
			_once = true;
			_tv.ItemActivated += e => {
				_activeDoc.Focus();
				var v = e.Item as _Item;
				_activeDoc.aaaGoToPos(true, v._pos);
			};
			Panels.Editor.ActiveDocChanged += Clear;
		}

		_tv.SetItems(root.Children(), modified: changed != 4);
		return true;

		//0 same, 1 changed
		int _TreeChanged(_Item old, _Item now) {
			int R = 0;
			if (old.HasChildren || now.HasChildren) {
				for (_Item o = old.FirstChild, n = now.FirstChild; ; o = o.Next, n = n.Next) {
					if ((o == null) != (n == null)) return 1; //added or removed at the end
					if (o == null) break;
					if (!n.Eq(o)) {
						//is just changed text of this, or something added or removed in the middle? If added/removed, need to update _isExpanded.
						R |= 1;
						_Item o1 = o.Next, n1 = n.Next;
						if (o1 != null && n1 != null) { //else added or removed at the end
							if (!n1.Eq(o1)) { //else just changed text
								for (; n1 != null; n1 = n1.Next) if (n1.Eq(o)) { n = n1; goto g1; } //inserted 1 or more
								for (; o1 != null; o1 = o1.Next) if (o1.Eq(n)) { o = o1; goto g1; } //removed 1 or more
								return 1;
								g1:;
							}
						}
					}
					if (o.HasChildren || n.HasChildren) {
						R |= _TreeChanged(o, n);
					}
				}
				now._isExpanded = old._isExpanded;
			}
			return R;
		}

		void _UpdatePos(_Item old, _Item now) {
			for (_Item o = old.FirstChild, n = now.FirstChild; o != null; o = o.Next, n = n.Next) {
				o._pos = n._pos;
				if (o.HasChildren) _UpdatePos(o, n);
			}
		}
	}

	public void Clear() {
		if (_activeDoc == null) return;
		_activeDoc = null;
		_oldTree = null;
		_modified = false;
		_tv.SetItems(null);
	}

	//unfinished, rejected, maybe in the future. Can't use just _pos. Need to get and update full spans.
	//	Maybe better add "manual sync" button instead of "auto sync" option.
	//void _Sync() {
	//	Debug.Assert(this.IsVisible && _oldTree != null);
	//	//print.it("sync");

	//	int pos = Panels.Editor.ActiveDoc.aaaCurrentPos16; //todo: return if didn't change (use the position changed notification).
	//	_Item found = null;
	//	if (0 == (3 & App.Settings.outline_flags)) { //not sorted
	//		found = _Find(_oldTree);

	//		_Item _Find(_Item parent) {
	//			for (var v = parent.FirstChild; v != null; v = v.Next) {
	//				if (v._pos >= pos) return v;
	//				if (v.HasChildren) {
	//					var r = _Find(v);
	//					if (r != null) return r;
	//				}
	//			}
	//			return null;
	//		}
	//	}
	//	if (found != null) {
	//		print.it(found._text);

	//	}
	//}

	void _ContextMenu() {
		var m = new popupMenu();
		int flags = App.Settings.outline_flags, sort = flags & 3;
		m.AddRadio("Don't sort", sort == 0).Id = 1;
		m.AddRadio("Sort by name", sort == 1).Id = 2;
		m.AddRadio("Sort by kind and name", sort == 2).Id = 3;
		//m.AddRadio("Sort by kind and name", sort == 3).Id = 4; //sorting by kind+position probably not useful. Always sort by kind+name.
		//m.Separator();
		//m.AddCheck("Sync", 0 != (flags & 4), _ => App.Settings.outline_flags ^= 4);
		int i = m.Show(owner: P);
		if (i is >= 1 and <= 3) {
			App.Settings.outline_flags = (byte)((App.Settings.outline_flags & ~3) | (i - 1));
			if (_oldTree != null) {
				_oldTree = null;
				Update();
			}
		}
	}

	class _Item : TreeBase<_Item>, ITreeViewItem {
		internal string _text;
		internal int _pos;
		internal CiItemKind _kind;
		internal bool _isExpanded = true;

		public _Item() { } //root

		public _Item(string text, CiItemKind kind, int pos) {
			_text = text;
			_pos = pos;
			_kind = kind;
		}

		public _Item(MemberDeclarationSyntax m) {
			//CiUtil.PrintNode(m);
			string name;
			if (m is BaseFieldDeclarationSyntax fd) { //field, event
				var vd = fd.Declaration;
				var a = vd.Variables;
				if (a.Count == 1) name = a[0].Identifier.Text + " : " + vd.Type;
				else name = string.Join(", ", a.Select(o => o.Identifier.ToString())) + " : " + vd.Type;
			} else if (m is BaseNamespaceDeclarationSyntax nd) {
				name = nd.Name.ToString();
			} else if (m is ExtensionBlockDeclarationSyntax ed) {
				name = $"extension{ed.TypeParameterList}{ed.ParameterList}";
			} else if (m is TypeDeclarationSyntax td) {
				name = td.Identifier.Text + td.TypeParameterList;
			} else {
				name = m switch {
					DestructorDeclarationSyntax dd => "~" + dd.Identifier.Text,
					ConversionOperatorDeclarationSyntax od => $"{od.ImplicitOrExplicitKeyword.Text} {od.Type}",
					_ => m.GetNameToken().Text
				};

				if (m is MethodDeclarationSyntax md) name = $"{name}{md.TypeParameterList}({_Function(md.ParameterList.Parameters)}) : {md.ReturnType}";
				else if (m is OperatorDeclarationSyntax od) name = $"{name}({_Function(od.ParameterList.Parameters)}) : {od.ReturnType}";
				else if (m is BaseMethodDeclarationSyntax bmd) name = $"{name}({_Function(bmd.ParameterList.Parameters)})";
				else if (m is IndexerDeclarationSyntax id) name = $"{name}[{_Function(id.ParameterList.Parameters)}]";
				else if (m is DelegateDeclarationSyntax odd) name = $"{name}{odd.TypeParameterList}({_Function(odd.ParameterList.Parameters)}) : {odd.ReturnType}";

				if (m is BasePropertyDeclarationSyntax pd) name = $"{name} : {pd.Type}"; //property, indexer, event

				static string _Function(SeparatedSyntaxList<ParameterSyntax> a) {
					int n = a.Count; if (n == 0) return null;
					if (n == 1) return a[0].Type.ToString();
					return string.Join(", ", a.Select(o => o.Type));
				}
			}

			_text = name;
			_kind = CiUtil.MemberDeclarationToKind(m);
			_pos = m.SpanStart;
		}

		public _Item(LocalFunctionStatementSyntax m) {
			_text = m.Identifier.Text;
			_kind = CiItemKind.Method;
			_pos = m.SpanStart;
		}

		public bool Eq(_Item b) => _text == b._text && _kind == b._kind;

		#region ITreeViewItem

		string ITreeViewItem.DisplayText => _text;

		object ITreeViewItem.Image => CiComplItem.ImageResource(_kind);

		void ITreeViewItem.SetIsExpanded(bool yes) { _isExpanded = yes; }

		bool ITreeViewItem.IsExpanded => _isExpanded;

		IEnumerable<ITreeViewItem> ITreeViewItem.Items => base.Children();

		bool ITreeViewItem.IsFolder => _IsFolder;
		bool _IsFolder => base.HasChildren;

		//bool ITreeViewItem.IsBold => _IsFolder;

		#endregion
	}
}


================================================
FILE: Au.Editor/Panels/PanelOutput.cs
================================================
//TODO2: multiple output controls in the Output panel. Eg compiler output should be separated, and cleared without clearing common output text.
//	Alternatively, allow to clear certain parts of output text, eg compiler output.

using System.Windows.Controls;
using Au.Controls;
using static Au.Controls.Sci;

namespace LA;

class PanelOutput {
	readonly KScintilla_ _c;
	readonly KPanels.ILeaf _leaf;
	readonly Queue<PrintServerMessage> _history;
	
	public KScintilla_ Scintilla => _c;
	
	public PanelOutput() {
		//P.UiaSetName("Output panel"); //no UIA element for Panel
		
		_c = new KScintilla_(this) { Name = "Output_text" };
		P.Children.Add(_c);
		_history = new Queue<PrintServerMessage>();
		App.Commands.BindKeysTarget(P, "Output");
		_leaf = Panels.PanelManager["Output"];
	}
	
	public DockPanel P { get; } = new();
	
	public void Clear() { _c.aaaClearText(); _c.Call(SCI_SETSCROLLWIDTH, 1); }
	
	public void Copy() { _c.Call(SCI_COPY); }
	
	//public void Find() { Panels.Find.CtrlF(_c); }
	
	public void History() {
		var p = new KPopupListBox { PlacementTarget = P, Placement = System.Windows.Controls.Primitives.PlacementMode.MousePoint };
		p.Control.ItemsSource = _history;
		p.OK += o => print.it((o as PrintServerMessage).Text);
		P.Dispatcher.InvokeAsync(() => p.IsOpen = true);
	}
	
	void _c_HandleCreated() {
		_inInitSettings = true;
		if (WrapLines) WrapLines = true;
		if (WhiteSpace) WhiteSpace = true;
		_c.AaNoMouseSetFocus = MButtons.Middle;
		_inInitSettings = false;
	}
	bool _inInitSettings;
	
	public bool WrapLines {
		get => App.Settings.output_wrap;
		set {
			Debug.Assert(!_inInitSettings || value);
			if (!_inInitSettings) App.Settings.output_wrap = value;
			_c.Call(SCI_SETWRAPMODE, value ? SC_WRAP_WORD : 0);
			App.Commands[nameof(Menus.Tools.Output.Output_wrap_lines)].Checked = value;
		}
	}
	
	public bool WhiteSpace {
		get => App.Settings.output_white;
		set {
			Debug.Assert(!_inInitSettings || value);
			if (!_inInitSettings) App.Settings.output_white = value;
			_c.Call(SCI_SETVIEWWS, value);
			App.Commands[nameof(Menus.Tools.Output.Output_white_space)].Checked = value;
		}
	}
	
	internal class KScintilla_ : KScintilla {
		PanelOutput _p;
		StringBuilder _sb;
		
		internal KScintilla_(PanelOutput panel) {
			_p = panel;
			
			AaInitReadOnlyAlways = true;
			AaInitTagsStyle = AaTagsStyle.AutoWithPrefix;
			AaInitImages = true;
			
			//App.Commands[nameof(Menus.Tools.Output)].SetKeysTarget(this);
		}
		
		protected override void AaOnHandleCreated() {
			aaaMarginSetWidth(1, 3);
			AaSetStyles();
			_p._c_HandleCreated();
			
			AaTags.CodeStylesProvider = CiUtil.GetScintillaStylingBytes8;
			
			SciTags.AddCommonLinkTag("open", _OpenLink);
			SciTags.AddCommonLinkTag("script", _RunScript);
			SciTags.AddCommonLinkTag("google", _Google);
			SciTags.AddCommonLinkTag("+recipe", PanelHelp.OpenRecipe);
			SciTags.AddCommonLinkTag("+nuget", DNuget.ShowSingle);
			SciTags.AddCommonLinkTag("+options", s => { DOptions.AaShow(s.NE() ? null : Enum.Parse<DOptions.EPage>(s)); });
			AaTags.AddLinkTag("+properties", fid => {
				var f = App.Model.FindCodeFile(fid);
				if (f == null || !App.Model.SetCurrentFile(f)) return;
				Menus.File.Properties();
			});
			AaTags.AddLinkTag("+DCustomize", DCustomize.ShowSingle);
			
			App.PrintServer.SetNotifications(AaWnd, Api.WM_APP);
			
			base.AaOnHandleCreated();
		}
		
		public void AaSetStyles() {
			var t = SciTheme.Default with {
				FontName = App.Settings.font_output.name,
				FontSize = App.Settings.font_output.size,
				Background = 0xF7F7F7,
			};
			t.ToScintilla(this);
			Call(SCI_SETWHITESPACESIZE, 2); //not DPI-scaled
		}
		
		protected override IntPtr WndProc(IntPtr hwnd, int msg, IntPtr wParam, IntPtr lParam, ref bool handled) {
			//WndUtil.PrintMsg(out var s, default, msg, wParam, lParam); print.qm2.write(s);
			switch (msg) {
			case Api.WM_APP:
				AaTags.PrintServerProcessMessages(App.PrintServer, _onServerMessage ??= _OnServerMessage);
				return default;
			case Api.WM_MBUTTONDOWN:
				_p.Clear();
				return default;
			case Api.WM_CONTEXTMENU:
				var m = new ContextMenu { PlacementTarget = this };
				App.Commands[nameof(Menus.Tools.Output)].CopyToMenu(m);
				m.IsOpen = true;
				return default;
			}
			return base.WndProc(hwnd, msg, wParam, lParam, ref handled);
		}
		
		Action<PrintServerMessage> _onServerMessage;
		void _OnServerMessage(PrintServerMessage m) {
			if (m.Type != PrintServerMessageType.Write) {
				if (m.Type == PrintServerMessageType.TaskEvent) RecentTT.TriggerEvent(m);
				return;
			}
			
			//create links in compilation errors/warnings or run-time stack trace
			var s = m.Text; int i;
			if (s.Length >= 22) {
				if (s.Starts("<><lc #") && (s.Eq(13, ">Compilation: ") || s.Eq(13, ">Can't export "))) { //compilation. Or error in meta while exporting.
					s_rxCompError ??= new regexp(@"(?m)^\[(.+?)(\((\d+),(\d+)\))?\]: ((?:error|warning) \w+)");
					m.Text = s_rxCompError.Replace(s, x => {
						var f = App.Model?.FindByFilePath(x[1].Value);
						if (f == null) return x[0].Value;
						var sEW = x[5].Value;
						return $"<open {f.IdStringWithWorkspace}|{x[3].Value}|{x[4].Value}>{f.Name}{x[2].Value}<>: <c {(sEW[0] == 'e' ? "red" : "green")}>{sEW}<>";
					});
				} else if ((i = s.Find("   at ") + 1) >= 0 && s.Find(":line ", i) > 0) { //stack trace with source file info
					_ModifyStackTraces(m);
				}
			}
			
			if (s.Length <= 10_000) { //* 50 = 1 MB
				if (!ReferenceEquals(s, m.Text)) m = new PrintServerMessage(PrintServerMessageType.Write, s, m.TimeUtc, m.Caller);
				var h = _p._history;
				h.Enqueue(m);
				if (h.Count > 50) h.Dequeue();
			}
			
			if (!_p.P.IsVisible) _p._leaf.Visible = true;
		}
		static regexp s_rxCompError;
		
		static void _OpenLink(string s) {
			var a = s.Split('|');
			if (a.Length > 3) App.Model.OpenAndGoTo3(a[0], a[3]);
			else App.Model.OpenAndGoTo2(a[0], a.Length > 1 ? a[1] : null, a.Length > 2 ? a[2] : null);
		}
		
		static void _RunScript(string s) {
			var a = s.Split('|');
			var f = App.Model.FindCodeFile(a[0]); if (f == null) return;
			CompileRun.CompileAndRun(true, f, a.Length == 1 ? null : a.RemoveAt(0));
		}
		
		static void _Google(string s) {
			var a = s.Split('|');
			string s1 = a[0], s2 = a.Length > 1 ? a[1] : null;
			run.itSafe(App.Settings.internetSearchUrl + System.Net.WebUtility.UrlEncode(s1) + s2);
		}
		
		void _ModifyStackTraces(PrintServerMessage psm) {
			string s = psm.Text;
			//print.qm2.write("`" + s + "`");
			var b = _sb ??= new StringBuilder(s.Length + 2000);
			b.Clear();
			bool wasFormatted = s.Starts("<>");
			RXGroup[] aLit = null;
			if (wasFormatted) (s_rxLiteral ??= new regexp(@"(?s)<([\a_])>.+?</\1>")).FindAllG(s, 0, out aLit);
			else b.Append("<><\a>");
			int appendFrom = 0;
			
			//for each stack trace
			s_rxStack ??= new regexp(@"(?m)(^   at .+(?:\R|\z))+(^ *--.*\R(?1)+)*");
			foreach (var g1 in s_rxStack.FindAllG(s, 0)) {
				int start = g1.Start, end = g1.End;
				if (s[end - 1] == '\n' && s[--end - 1] == '\r') end--;
				bool inLiteral = true;
				if (wasFormatted) {
					if (s[end - 1] == '>') //don't include eg `<\a><>` at the end of the last line
						if ((s_rxClosingTags ??= new regexp(@"(?:<(?:/.+?)?>)+$")).Match(s, 0, out RXGroup g2, s.LastIndexOf('\n', end - 1)..end)) end = g2.Start;
					inLiteral = aLit?.Any(o => o.Start < start && o.End > end) ?? false;
				}
				if (s.Find("<\a>", start..end) >= 0 || s.Find("</\a>", start..end) >= 0 || s.Find("<_>", start..end) >= 0 || s.Find("</_>", start..end) >= 0) continue;
				
				b.Append(s, appendFrom, start - appendFrom); appendFrom = end;
				
				//for each line that has source file info
				bool modified = false;
				s_rxAtLine ??= new regexp(@"(?m)^   at (.+?\)) in ([^\r\n<]+):line (\d+)$");
				foreach (var m in s_rxAtLine.FindAll(s, start..end)) {
					var f = App.Model?.FindByFilePath(m[2].Value); if (f == null) continue;
					b.AppendFormat("{3}   at <open {0}|{1}>line {1}<> in <bc #FAFAD2>{2}<>{4}", f.IdStringWithWorkspace, m[3].Value, f.Name, inLiteral ? "</\a>" : "", inLiteral ? "<\a>" : "");
					bool isMain = f.IsScript && 0 != s.Eq(m[1].Start, false, "Program.<Main>$(String[] args)", "Program..ctor(String[] args)", "Script..ctor(String[] args)");
					if (!isMain) {
						var method = m[1].Value;
						bool lit = !inLiteral && method.Contains('<');
						b.AppendFormat("{1}, {0}{2}", method, lit ? "<\a>" : "", lit ? "</\a>" : "");
					}
					b.AppendLine();
					modified = true;
				}
				
				if (modified) { //append `<fold>raw stack trace</fold>`
					if (b[b.Length - 1] != '\n') b.AppendLine();
					if (inLiteral) b.Append("</\a>");
					b.Append("   <fold><\a>   --- Raw stack trace ---\r\n").Append(s, start, end - start);
					if (b[b.Length - 1] != '\n') b.AppendLine();
					b.Append("</\a></fold>");
					if (inLiteral) b.Append("<\a>");
				} else { //append raw stack trace
					if (!inLiteral) b.Append("<\a>");
					b.Append(s, start, end - start);
					if (!inLiteral) b.Append("</\a>");
				}
			}
			if (appendFrom > 0) {
				b.Append(s, appendFrom, s.Length - appendFrom);
				if (!wasFormatted) b.Append("</\a>");
				//print.qm2.write("+" + b);
				psm.Text = b.ToString();
			}
			if (_sb.Capacity > 10_000) _sb = null; //let GC free it. Usually < 4000.
		}
		static regexp s_rxStack, s_rxClosingTags, s_rxAtLine, s_rxLiteral;
	}
}


================================================
FILE: Au.Editor/Panels/PanelRead.cs
================================================
extern alias CAW;

using System.Windows;
using System.Windows.Controls;
using System.Windows.Media;
using Microsoft.Win32;
using System.Runtime.Loader;
using Au.Controls;
using Microsoft.Web.WebView2.Wpf;
using Microsoft.Web.WebView2.Core;
using System.Text.Json.Nodes;

namespace LA;

class PanelRead {
	WebView2 _wv;
	string _localBaseUri;
	
	//public PanelRead() {
	//	//P.UiaSetName("Read panel"); //no UIA element for Panel
	//}
	
	public Grid P { get; } = new();
	
	void _BeforeOpeningArticle() {
		var p = Panels.PanelManager[P];
		p.Visible = true;
		if (p.Floating) {
			wnd w = p.Content.Hwnd(), wmain = App.Hmain;
			if (w.IsMinimized) {
				w.ShowNotMinimized();
			} else if (!w.IsOwnedBy(wmain, 0) && !w.IsTopmost) {
				if (w.ClientRectInScreen.IntersectsWith(wmain.ClientRectInScreen)) w.ActivateL(true);
			}
		}
	}
	
	/// <summary>
	/// Opens a LA documentation page in this panel.
	/// Opens the local version of the page.
	/// If cannot open (eg WebView2 unavailable on current computer), opens the specified URL in default web browser app.
	/// </summary>
	/// <param name="url">Like <c>"https://www.libreautomate.com/articles/name.html"</c>.</param>
	public void OpenDocUrl(string url) {
		var baseUri = DocsHttpServer.LocalBaseUri;
		if (baseUri == null || !_IsDocsUrl(url, c_laWebsiteBaseUri) || !_IsWebViewAvailable) {
			run.itSafe(url);
			return;
		}
		_localBaseUri = baseUri; //save because DocsHttpServer.LocalBaseUri may become null
		url = string.Concat(baseUri, url.AsSpan(30));
		
		_BeforeOpeningArticle();
		if (_wv == null) _CreateWebView();
		_wv.Source = new(url);
	}
	
	const string c_laWebsiteBaseUri = "https://www.libreautomate.com/";
	
	static bool _IsDocsUrl(string url, string baseUri)
		=> url.Starts(baseUri) && url.Eq(baseUri.Length, false, "api", "editor", "articles", "cookbook") > 0;
	
	static bool _IsWebViewAvailable {
		get {
			if (s_wvAvailable == null) {
				try {
					CoreWebView2Environment.SetLoaderDllFolderPath(folders.ThisAppBS + $@"runtimes\win-{(osVersion.isArm64Process ? "arm64" : "x64")}\native"); //else would fail or use PATH etc
					
					string ver = CoreWebView2Environment.GetAvailableBrowserVersionString();
					s_wvAvailable = !ver.NE();
				}
				catch { s_wvAvailable = false; }
				if (s_wvAvailable == false) print.it("<>Info: To show documentation in <b>Read<> panel, download/install <google WebView2 site:microsoft.com>WebView2<>. Then restart this app. See <b>Options > Other<>.");
			}
			return s_wvAvailable == true;
		}
	}
	static bool? s_wvAvailable;
	
	void _CreateWebView() {
		var tb = Panels.Help.buttons_.toolbar.ToolBars[0];
		Panels.Help.buttons_.back = tb.AddButton("*EvaIcons.ArrowBack" + EdIcons.black, _ => { try { _wv.GoBack(); } catch { } }, "Back", enabled: false);
		Panels.Help.buttons_.forward = tb.AddButton("*EvaIcons.ArrowForward" + EdIcons.black, _ => { try { _wv.GoForward(); } catch { } }, "Forward", enabled: false);
		Panels.Help.buttons_.openInBrowser = tb.AddButton("*Modern.Browser" + EdIcons.black, _ => { _OpenInWebBrowser(); }, "Open in web browser", enabled: false);
		tb.Items.Add(new Separator());
		Panels.Help.buttons_.toggleReadPanel = tb.AddButton("*PixelartIcons.Article" + EdIcons.black, _ => { Panels.PanelManager[P].Visible ^= true; }, "Show/hide the Read panel");
		
		string udf = folders.ThisAppTemp + "wv";
		filesystem.delete(udf, FDFlags.CanFail); //would fail to init if it's corrupt. And it grows.
		_wv = new() {
			CreationProperties = new() { UserDataFolder = udf }
		};
		P.Children.Add(_wv);
		
		_wv.CoreWebView2InitializationCompleted += (_, e) => {
			if (!e.IsSuccess) {
				print.warning("Failed to initialize WebView2. Can't show LA documentation in the Read panel. See <+options Other>Options > Other<>. " + e.InitializationException);
				s_wvAvailable = false;
				return;
			}
			
			Panels.Help.buttons_.toolbar.Visibility = Visibility.Visible;
			
			var core = _wv.CoreWebView2;
			
			Debug.Assert(!core.Environment.UserDataFolder.Starts(folders.ThisApp)); //ignores CreationProperties if it was set too early
			
			core.HistoryChanged += (_, _) => {
				Panels.Help.buttons_.back.IsEnabled = _wv.CanGoBack;
				Panels.Help.buttons_.forward.IsEnabled = _wv.CanGoForward;
				Panels.Help.buttons_.openInBrowser.IsEnabled = true;
			};
			
			core.NavigationStarting += (_, e) => {
				var url = e.Uri;
				if (url.Starts("nuget:")) {
					e.Cancel = true;
					DNuget.ShowSingle(Uri.UnescapeDataString(url[6..]));
				} else if (!_IsDocsUrl(url, _localBaseUri)) {
					e.Cancel = true;
					run.itSafe(url);
				}
			};
			
			core.ContextMenuRequested += _ContextMenuRequested;
			
#if DEBUG
			_PreviewCurrentRecipeScript();
#endif
		};
	}
	
	/// <summary>
	/// Opens the currently displayed page in the default web browser app.
	/// </summary>
	void _OpenInWebBrowser() {
		if (_wv.Source is { } uri) {
			var url = uri.ToString();
			if (_IsDocsUrl(url, _localBaseUri)) url = c_laWebsiteBaseUri + url[_localBaseUri.Length..];
			run.itSafe(url);
		}
	}
	
	async void _ContextMenuRequested(object sender, CoreWebView2ContextMenuRequestedEventArgs e) {
		var defer = e.GetDeferral();
		try {
			var items = e.MenuItems;
			
			for (int i = items.Count; --i >= 0;) {
				if (items[i].Kind == CoreWebView2ContextMenuItemKind.Command && items[i].Name is "inspectElement" or "webCapture" or "webSelect" or "createQrCode")
					items.RemoveAt(i);
				//if need Inspect, Ctrl+Shit+I still works
			}
			
			var core = _wv.CoreWebView2;
			
			//detect <pre> and get its text
			string preText = null;
			var cmt = e.ContextMenuTarget;
			if (cmt.Kind == CoreWebView2ContextMenuTargetKind.Page && !(cmt.HasLinkUri || cmt.IsEditable)) {
				string js = $$"""
(function() {
    var el = document.elementFromPoint({{e.Location.X}}, {{e.Location.Y}});
    while(el && el.nodeType === 1) {
        if(el.tagName === 'PRE') return el.textContent;
        el = el.parentElement;
    }
    return null;
})();
""";
				try {
					preText = await core.ExecuteScriptAsync(js);
					if (preText != null) preText = (string)JsonValue.Parse(preText);
				}
				catch (Exception ex) { print.it(ex); }
			}
			
			var mCC = core.Environment.CreateContextMenuItem("Copy code", null, CoreWebView2ContextMenuItemKind.Command);
			var mNS = core.Environment.CreateContextMenuItem("New script", null, CoreWebView2ContextMenuItemKind.Command);
			if (preText != null) {
				mCC.CustomItemSelected += (_, __) => { clipboard.text = preText; };
				mNS.CustomItemSelected += (_, __) => {
					var name = pathname.getNameNoExt(Uri.UnescapeDataString(_wv.Source.AbsolutePath));
					App.Model.NewItem("Script.cs", null, name + ".cs", true, new(true, preText));
				};
			} else {
				mCC.IsEnabled = mNS.IsEnabled = false;
			}
			items.Insert(0, mCC);
			items.Insert(1, mNS);
			try { items.Insert(2, core.Environment.CreateContextMenuItem(null, null, CoreWebView2ContextMenuItemKind.Separator)); } catch { } //throws on Win7
			
			var mOB = core.Environment.CreateContextMenuItem("Open in browser", null, CoreWebView2ContextMenuItemKind.Command);
			mOB.CustomItemSelected += (_, __) => { _OpenInWebBrowser(); };
			try { items.Add(core.Environment.CreateContextMenuItem(null, null, CoreWebView2ContextMenuItemKind.Separator)); } catch { }
			items.Add(mOB);
		}
		finally {
			defer.Complete();
		}
	}
	
#if DEBUG
	/// <summary>
	/// Starts a timer that displays HTML (preview) of the current C# script, if it's a cookbook recipe source script.
	/// It makes editing cookbook recipes easy.
	/// </summary>
	void _PreviewCurrentRecipeScript() {
		string prevText = null;
		SciCode prevDoc = null;
		
		App.Timer1sWhenVisible += () => {
			if (!P.IsVisible || DocsHttpServer.LocalBaseUri == null) return;
			if (App.Model.WorkspaceName != "Cookbook") {
				if (!(App.Model.WorkspaceName == "ok" && App.Model.CurrentFile is { IsExternal: true, IsScript: true } cf && cf.Ancestors().Any(o => o.Name is "cookbook_files"))) return;
			}
			var doc = Panels.Editor.ActiveDoc;
			if (doc == null || !doc.EFile.IsScript || doc.EFile.Parent.Name == "-") return;
			
			string text = doc.aaaText;
			if (text == prevText) return;
			if (_IsCaretInPossiblyUnfinishedTag(doc, text)) return; //avoid printing debug info for invalid links etc
			
			if (_wv.Source.AbsolutePath != "/cookbook/preview.html") {
				prevText = null;
				prevDoc = doc;
				_wv.Source = new(DocsHttpServer.LocalBaseUri + "cookbook/preview.html");
				//DocsHttpServer will call GetPreviewHtmlTemplate_() and the control will display it (empty page).
				//In next timer call (the `else` code) its <article>'s inner HTML will be replaced with the HTML returned by _GetPreviewHtml.
			} else {
				var html = _GetPreviewHtml();
				var json = JsonValue.Create(html).ToJsonString();
				_wv.CoreWebView2.ExecuteScriptAsync($"window.updatePreview({json});{(doc != prevDoc ? "scrollToTop()" : null)}");
				prevDoc = doc;
				prevText = text;
			}
		};
		
		bool _IsCaretInPossiblyUnfinishedTag(SciCode doc, string text) {
			int i = doc.aaaCurrentPos16;
			i = i == 0 ? -1 : text.LastIndexOfAny(['<', '>', '\n'], i - 1);
			if (i > 0 && text[i] == '<' && text.Eq(text.LastIndexOf('\n', i) + 1, "///")) {
				//print.it("tag");
				return true;
			}
			return false;
		}
	}
	
	/// <summary>
	/// Converts text of the current C# script to HTML. It must be a cookbook recipe source script.
	/// Uses the same converter as the "Au docs" script (it creates HTML etc files for the website).
	/// </summary>
	static string _GetPreviewHtml() {
		try {
			var doc = Panels.Editor.ActiveDoc;
			string name = doc.EFile.DisplayName, code = doc.Dispatcher.Invoke(() => doc.aaaText);
			
			if (_RecipeCodeToHtml == null) {
				AssemblyLoadContext.Default.LoadFromAssemblyPath(@"C:\code\ok\.nuget\-\Markdig.dll");
				var asm = AssemblyLoadContext.Default.LoadFromAssemblyPath(@"C:\code\ok\dll\AuDocsLib.dll");
				_RecipeCodeToHtml = asm.GetType("ADL.AuDocsShared").GetMethod("RecipeCodeToHtml").CreateDelegate<Func<string, string, string>>();
			}
			return _RecipeCodeToHtml(name, code);
		}
		catch (Exception ex) { print.it(ex); throw; }
	}
	
	static Func<string, string, string> _RecipeCodeToHtml;
	
	/// <summary>
	/// Called by the HTTP server. The code is here because it's better to keep most of the preview code in one place.
	/// </summary>
	internal static string GetPreviewHtmlTemplate_() {
		return """
<!DOCTYPE html>
<html>
  <head>
    <meta charset="utf-8">
      <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1">
      <title>Constants, enum | LibreAutomate </title>
      <meta name="viewport" content="width=device-width">
      <link rel="stylesheet" href="../styles/docfx.vendor.min.css">
      <link rel="stylesheet" href="../styles/docfx.css">
      <link rel="stylesheet" href="../styles/main.css">
      <link rel="stylesheet" href="../styles/code.css">
  <link rel="stylesheet" href="../styles/la.css">
</head>
  <body>
    <a name="top"></a>
    <div id="wrapper">
      <div role="main" class="container-fluid body-content hide-when-search">
          <div class="col-md-12">
            <article class="content wrap" id="_content"/>
          </div>
      </div>
    </div>
<script>
window.updatePreview = function(html) {
    document.getElementById('_content').innerHTML = html;
};
window.scrollToTop = function() {
    window.scrollTo(0, 0);
};
</script>
</body>
</html>
""";
	}
#endif
}

/// <summary>
/// Used by the Read panel. Retrieves local LA documentation files.
/// Probably it's the best way to display local HTML files. Other ways have problems.
/// </summary>
class DocsHttpServer : HttpServerSession {
	static bool s_running;
	static int s_port;
	
	public static void StartOrSwitch() {
		if (App.Settings.doc_web || s_running) {
			_Switch();
		} else {
			s_running = true;
			run.thread(() => {
				try {
					Listen<DocsHttpServer>(0, "127.0.0.1", listener => {
						s_port = ((System.Net.IPEndPoint)listener.LocalEndpoint).Port;
						_Switch();
					});
				}
				catch (Exception ex) {
					print.warning(ex);
				}
				App.Settings.doc_web = true;
				_Switch();
				s_running = false;
			}, sta: false);
		}
	}
	
	public static string LocalBaseUri { get; private set; }
	
	static void _Switch() {
		if (App.Settings.doc_web) {
			LocalBaseUri = null;
			HelpUtil.AuHelpEvent_ -= _AuHelpEvent;
		} else {
			LocalBaseUri = $"http://127.0.0.1:{s_port}/";
			HelpUtil.AuHelpEvent_ += _AuHelpEvent;
		}
		
		static void _AuHelpEvent(HelpUtil.AuHelpEventArgs_ e) {
			e.Cancel = true;
			Panels.Read.OpenDocUrl(e.Url);
		}
	}
	
	protected override void MessageReceived(HSMessage m, HSResponse r) {
		if (m.Method != "GET") { r.Status = System.Net.HttpStatusCode.MethodNotAllowed; return; }
		
		var path = m.TargetPath; if (path.Ends('/')) path += "index.html";
		path = path[1..];
		//print.it(path);
		
#if DEBUG
		if (path == "cookbook/preview.html") {
			r.SetContentText(PanelRead.GetPreviewHtmlTemplate_(), "text/html; charset=utf-8");
			return;
		}
		//this can be used when editing/testing a CSS file
		//if (path == "styles/docfx.vendor.min.css") {
		//	r.SetContentText(filesystem.loadText(@"C:\Temp\Au\DocFX\site\styles\docfx.vendor.min.css"), "text/css");
		//	r.Headers["Cache-Control"] = "no-cache, no-store, must-revalidate";
		//	return;
		//}
#endif
		
		if (path == "favicon.ico" || path.Ends("/com.chrome.devtools.json")) { r.Status = System.Net.HttpStatusCode.NotFound; return; }
		
		lock (typeof(DocsHttpServer)) { //faster than the SQLite's busy timeout implementation
			using var db = new sqlite(folders.ThisAppBS + "doc-html.db", SLFlags.SQLITE_OPEN_READONLY); //fast, don't keep open
			if (db.Get(out byte[] content, "SELECT text FROM doc WHERE name=?", path)) {
				r.Content = content;
				var ext = pathname.getExtension(path).Lower();
				var ct = ext switch {
					".html" => "text/html; charset=utf-8",
					".css" => "text/css",
					".js" => "text/javascript",
					".png" => "image/png",
					_ => null
				};
				if (ct != null) r.Headers["Content-Type"] = ct; else Debug_.PrintIf(!(ext is ".eot"), path);
				if (ext != ".html") r.Headers["Cache-Control"] = "max-age=86400"; //1 day or until process exit
			} else {
				Debug_.PrintIf(
					!(path is "styles/docfx.vendor.min.css.map" /*size ~500kb, requested when showing devtools, works well without*/),
					"NOT FOUND: " + path);
				r.Status = System.Net.HttpStatusCode.NotFound;
			}
		}
	}
}


================================================
FILE: Au.Editor/Panels/PanelTasks.cs
================================================
using Au.Controls;
using System.Windows.Controls;
using System.Windows.Input;

namespace LA;

class PanelTasks {
	KTreeView _tv;
	bool _updatedOnce;

	public PanelTasks() {
		//P.UiaSetName("Tasks panel"); //no UIA element for Panel

		_tv = new KTreeView { Name = "Tasks_list" };
		P.Children.Add(_tv);
		
		Panels.PanelManager["Tasks"].DontActivateFloating = e => true;
	}

	public DockPanel P { get; } = new();

	public void UpdateList() {
		_tv.SetItems(App.Tasks.Items, _updatedOnce);
		if (!_updatedOnce) {
			_updatedOnce = true;
			FilesModel.NeedRedraw += v => { _tv.Redraw(v.remeasure); };
			_tv.ItemClick += _tv_ItemClick;
		}
	}

	private void _tv_ItemClick(TVItemEventArgs e) {
		if (e.Mod != 0 || e.ClickCount != 1) return;
		var t = e.Item as RunningTask;
		var f = t.f;
		switch (e.Button) {
		case MouseButton.Left:
			App.Model.SetCurrentFile(f);
			break;
		case MouseButton.Right:
			_tv.Select(t);
			var name = f.DisplayName;
			var m = new popupMenu { RawText = true };
			m["End task  '" + name + "'"] = _ => App.Tasks.EndTask(t);
			m["End all  '" + name + "'"] = _ => App.Tasks.EndTasksOf(f);
			m.Separator();
			m["Attach debugger"] = _ => Panels.Debug.Attach(t.processId);
			m.Separator();
			m["Close\tM-click", disable: f.OpenDoc == null] = _ => App.Model.CloseFile(f, selectOther: true);
			//m.Separator();
			//m["Recent tasks and triggers..."] = _ => RecentTT.Show(); //rejected. It is in menu Run. Or would also need to show context menu when rclicked in empty space.
			m.Show();
			break;
		case MouseButton.Middle:
			App.Model.CloseFile(f, selectOther: true);
			break;
		}
	}
}


================================================
FILE: Au.Editor/Panels/Panels.cs
================================================
using Au.Controls;
using System.Windows.Controls;
using System.Windows;
using System.Windows.Input;
using System.Xml.Linq;
using System.Xml.XPath;
using System.Windows.Media;

namespace LA;

static class Panels {
	public static KPanels PanelManager;
	//panels
	public static PanelEdit Editor;
	public static PanelFiles Files;
	public static PanelOutline Outline;
	public static PanelHelp Help;
	public static PanelOpen Open;
	public static PanelTasks Tasks;
	public static PanelOutput Output;
	public static PanelFind Find;
	public static PanelFound Found;
	public static PanelMouse Mouse;
	public static PanelRead Read;
	public static PanelBookmarks Bookmarks;
	public static PanelBreakpoints Breakpoints;
	public static PanelDebug Debug;
	//menu and toolbars
	public static Menu Menu;
	public static ToolBar TFile, TEdit, TRun, TTools, TCustom1, TCustom2;
	
	public static void LoadAndCreateToolbars() {
		var pm = PanelManager = new KPanels();
		
		var customLayoutPath = AppSettings.DirBS + "Layout.xml";
		if (filesystem.exists(customLayoutPath).File) {
			try {
				var x = XmlUtil.LoadElem(customLayoutPath);
				if (x.XPathSelectElement("//panel[@name='Outline']") == null) { //v0.4 added several new panels etc, and users would not know the best place for them, or even how to move
					filesystem.delete(customLayoutPath, FDFlags.RecycleBin);
					print.it("Info: The window layout has been reset, because several new panels have been added in this app version.\r\n\tIf you want to undo it: 1. Exit the program. 2. Restore file Layout.xml from the Recycle Bin (replace the existing file). 3. Run the program. 4. Move panels from the bottom of the window to a better place.");
				} else if (x.XPathSelectElement("//panel[@name='Help']") == null) { //in v1.15 renamed some panels and removed the Help toolbar
					x.XPathSelectElement("//toolbar[@name='Help']")?.Remove();
					x.XPathSelectElement("//panel[@name='Cookbook']")?.SetAttributeValue("name", "Help");
					x.XPathSelectElement("//panel[@name='Recipe']")?.SetAttributeValue("name", "Read");
					
					//also renamed some attributes
					foreach (var v in x.Descendants()) {
						if (v.Attribute("captionAt") is { } k) { v.SetAttributeValue("headerAt", k.Value); k.Remove(); }
					}
					
					x.SaveElem(customLayoutPath);
					
					//also remove the Help toolbar from toolbar customizations
					var customCommandsPath = AppSettings.DirBS + "Commands.xml";
					if (filesystem.exists(customCommandsPath).File) {
						var xc = XmlUtil.LoadElem(customCommandsPath);
						if (xc.XPathSelectElement("//Help") is { } x1) {
							x1.Remove();
							xc.Save(customCommandsPath);
						}
					}
				}
			}
			catch (Exception e1) { Debug_.Print(e1); }
		}
		
		pm.BorderBrush = SystemColors.ActiveBorderBrush;
		//pm.Load(folders.ThisAppBS + @"Default\Layout.xml", null);
		pm.Load(folders.ThisAppBS + @"Default\Layout.xml", customLayoutPath);
		
		int saveCounter = 0;
		App.Timer1sWhenVisible += () => {
			if (++saveCounter >= 60) {
				saveCounter = 0;
				pm.Save();
			}
		};
		
		pm["Menu"].Content = Menu = new Menu();
		TFile = _CreateToolbar("File");
		TEdit = _CreateToolbar("Edit");
		TRun = _CreateToolbar("Run");
		TTools = _CreateToolbar("Tools");
		TCustom1 = _CreateToolbar("Custom1");
		TCustom2 = _CreateToolbar("Custom2");
	}
	
	static ToolBar _CreateToolbar(string name, Func<DockPanel, Dock> dockPanel = null) {
		var c = new ToolBar { Name = name/*, Background = SystemColors.ControlBrush*/ };
		c.UiaSetName(name);
		c.HideGripAndOverflow(false);
		var tt = new ToolBarTray { IsLocked = true/*, Background = SystemColors.ControlBrush*/ }; //because ToolBar looks bad if parent is not ToolBarTray
		tt.ToolBars.Add(c);
		FrameworkElement content = tt;
		if (dockPanel != null) {
			var p = new DockPanel { Background = tt.Background };
			p.Children.Add(tt);
			DockPanel.SetDock(tt, dockPanel(p));
			content = p;
		}
		PanelManager[name].Content = content;
		
		c.ContextMenuOpening += DCustomize.ToolbarContextMenuOpening;
		c.PreviewMouseRightButtonDown += (o, e) => { //prevent closing the overflow panel on right mouse button down
			if ((e.OriginalSource as UIElement).VisualAncestors(true).Any(o => o is System.Windows.Controls.Primitives.ToolBarOverflowPanel)) e.Handled = true;
		};
		
		return c;
	}
	
	public static void CreatePanels() {
		var pm = PanelManager;
		
		KPanels.ILeaf _AddDontFocus(string panel, FrameworkElement content) {
			var p = pm[panel];
			p.Content = content;
			p.DontFocusTab = () => {
				var doc = Panels.Editor.ActiveDoc;
				if (doc != null) doc.Focus(); else Keyboard.ClearFocus();
			};
			return p;
		}
		
		pm["documents"].Content = (Editor = new()).P;
		
		pm["Files"].Content = (Files = new()).P;
		_AddDontFocus("Outline", (Outline = new()).P);
		pm["Help"].Content = (Help = new()).P;
		_AddDontFocus("Debug", (Debug = new()).P);
		_AddDontFocus("Open", (Open = new()).P);
		_AddDontFocus("Tasks", (Tasks = new()).P);
		pm["Find"].Content = (Find = new()).P;
		_AddDontFocus("Bookmarks", (Bookmarks = new()).P);
		_AddDontFocus("Breakpoints", (Breakpoints = new()).P);
		_AddDontFocus("Output", (Output = new()).P);
		_AddDontFocus("Mouse", (Mouse = new()).P);
		_AddDontFocus("Found", (Found = new()).P);
		var pRead = _AddDontFocus("Read", (Read = new()).P);
		pRead.Visible = false;
	}
}


================================================
FILE: Au.Editor/Properties/launchSettings.json
================================================
{
  "profiles": {
    "Au.Editor": {
      "commandName": "Project",
      "nativeDebugging": false
    }
  }
}

================================================
FILE: Au.Editor/Test.cs
================================================
#if DEBUG || IDE_LA
extern alias CAW;

using Microsoft.CodeAnalysis;
using CAW::Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Text;
using Microsoft.CodeAnalysis.Shared.Extensions;
using CAW::Microsoft.CodeAnalysis.Shared.Extensions;
using Microsoft.CodeAnalysis.CSharp.Extensions;
using Microsoft.CodeAnalysis.Shared.Utilities;
using CAW::Microsoft.CodeAnalysis.Shared.Utilities;
using CAW::Microsoft.CodeAnalysis.FindSymbols;

using Au.Triggers;
using Au.Controls;
using System.Windows.Controls;
//using System.Windows.Forms;
using System.Text.RegularExpressions;
using System.Diagnostics.CodeAnalysis;

using static Au.Controls.Sci;

namespace LA;

static class Test {
	/// <summary>
	/// 
	/// </summary>
	public static void FromMenubar() {
		//print.clear();
		
		print.it(Panels.Editor.ActiveDoc.aaaCurrentPos16);
		
		//var query = Panels.Editor.ActiveDoc.aaaText.Lines()[0];
		//var query = Panels.Editor.ActiveDoc.aaaText;
		//Task.Run(() => {
		//	try {
		//		McpTools _tools = new();
		//		var s = _tools.find_la_docs(query, "");
		//		print.scrollToTop();
		//	}
		//	catch (Exception ex) { print.it(ex); }
		//});
		//print.it(s);
		
		//timer2.every(500, _=> { GC.Collect(); });
		
		//Cpp.Cpp_Test();
		
#if !IDE_LA
#endif
	}
	
	public static void MonitorGC() {
		//if(!s_debug2) {
		//	s_debug2 = true;
		//	new TestGC();
		
		//	//timer.every(50, _ => {
		//	//	if(!s_debug) {
		//	//		s_debug = true;
		//	//		timer.after(100, _ => new TestGC());
		//	//	}
		//	//});
		//}
	}
	//static bool s_debug2;
	
	class TestGC {
		~TestGC() {
			if (Environment.HasShutdownStarted) return;
			if (AppDomain.CurrentDomain.IsFinalizingForUnload()) return;
			print.it("GC", GC.CollectionCount(0), GC.CollectionCount(1), GC.CollectionCount(2));
			//timer.after(1, _ => new TestGC());
			//var f = App.Wmain; if(!f.IsHandleCreated) return;
			//f.BeginInvoke(new Action(() => new TestGC()));
			new TestGC();
		}
	}
}
#endif


================================================
FILE: Au.Editor/Tools/CapturingWithHotkey.cs
================================================
using Au.Controls;
using System.Windows.Interop;
using System.Windows;
using System.Windows.Controls;

namespace ToolLand;

static partial class TUtil {
	/// <summary>
	/// Common code for tools that capture UI objects with F3.
	/// </summary>
	public class CapturingWithHotkey {
		public record struct Hothey(string hotkey, Action a);
		
		readonly bool _isElm;
		readonly wnd _wDialog;
		readonly KCheckBox _captureCheckbox;
		readonly Func<GetRectArgs, bool> _getRect;
		readonly Hothey _hkCapture, _hkInsert, _hkSmaller;
		HwndSource _hs;
		timer _timer;
		osdRect _osr;
		osdText _ost; //TODO3: draw rect and text in same OsdWindow
		bool _capturing;
		
		const string c_propName = "Au.Capture";
		readonly static int s_stopMessage = Api.RegisterWindowMessage(c_propName);
		const int c_hotkeyCapture = 1623031890, c_hotkeyInsert = 1623031891, c_hotkeySmaller = 1623031892;
		
		/// <param name="captureCheckbox">Checkbox that turns on/off capturing.</param>
		/// <param name="getRect">Called to get rectangle of object from mouse. Receives mouse position. Can return default to hide the rectangle.</param>
		public CapturingWithHotkey(KCheckBox captureCheckbox, Func<GetRectArgs, bool> getRect, Hothey capture, Hothey insert = default, Hothey smaller = default) {
			_wDialog = captureCheckbox.Hwnd();
			_captureCheckbox = captureCheckbox;
			_getRect = getRect;
			_hkCapture = capture;
			_hkInsert = insert;
			_hkSmaller = smaller;
			_isElm = smaller.a != null;
		}
		
		/// <summary>
		/// Starts or stops capturing.
		/// Does nothing if already in that state.
		/// </summary>
		public bool Capturing {
			get => _capturing;
			set {
				if (value == _capturing) return;
				if (value) _StartCapturing(); else _StopCapturing();
			}
		}
		
		void _StopCapturing() {
			_capturing = false;
			_timer.Stop();
			_HideRect();
			_hs.RemoveHook(_WndProc);
			Api.UnregisterHotKey(_wDialog, c_hotkeyCapture);
			if (_hkInsert.hotkey != null) Api.UnregisterHotKey(_wDialog, c_hotkeyInsert);
			if (_hkSmaller.hotkey != null) Api.UnregisterHotKey(_wDialog, c_hotkeySmaller);
			_wDialog.Prop.Remove(c_propName);
		}
		
		void _StartCapturing() {
			//let other tools stop capturing. Any process.
			wnd.find(null, "HwndWrapper[*", flags: WFlags.HiddenToo | WFlags.CloakedToo, also: o => {
				if (o != _wDialog && o.Prop[c_propName] == 1) o.SendTimeout(3000, out _, s_stopMessage);
				return false;
			});
			_wDialog.Prop.Set(c_propName, 1);
			
			//register hotkeys
			bool _RegisterHotkey(int id, string hotkey) {
				string es = null;
				try {
					var (mod, key) = RegisteredHotkey.Normalize_(hotkey);
					if (Api.RegisterHotKey(_wDialog, id, mod, key)) return true;
					es = "Failed to register.";
				}
				catch (Exception e1) { es = e1.Message; }
				dialog.showError("Hotkey " + hotkey, es + "\nClick the hotkey link to set another hotkey.", owner: _wDialog);
				return false;
			}
			if (!_RegisterHotkey(c_hotkeyCapture, _hkCapture.hotkey)) return;
			if (_hkInsert.hotkey != null) _RegisterHotkey(c_hotkeyInsert, _hkInsert.hotkey);
			if (_hkSmaller.hotkey != null) _RegisterHotkey(c_hotkeySmaller, _hkSmaller.hotkey);
			
			//hook wndproc
			if (_hs == null) {
				_hs = PresentationSource.FromDependencyObject(_captureCheckbox) as HwndSource;
				_hs.Disposed += (_, _) => {
					Capturing = false;
					_osr?.Dispose();
					_ost?.Dispose();
				};
			}
			_hs.AddHook(_WndProc);
			
			//set timer to show rectangle of UI element from mouse
			if (_timer == null) {
				_osr = CreateOsdRect(2);
				_timer = new timer(_ => {
					if (!_capturing) return;
					POINT p = mouse.xy;
					if (_isElm) {
						_elmTimer.Timer(p);
					} else {
						_ShowRect(p, wnd.fromXY(p, WXYFlags.NeedWindow));
					}
				});
			}
			if (_isElm) _elmTimer = new(this);
			_timer.Every(_isElm ? 50 : 200);
			
			_capturing = true;
		}
		_ElmTimer _elmTimer;
		
		class _ElmTimer {
			CapturingWithHotkey _capt;
			POINT _pMM;
			bool _mouseMoved;
			long _timeMM, _timeUpdated;
			wnd _w;
			
			public _ElmTimer(CapturingWithHotkey capt) {
				_capt = capt;
				_pMM.x = int.MinValue;
			}
			
			public void Timer(POINT p) {
				if (mouse.isPressed()) {
					_capt._HideRect();
					if (p == _pMM) return;
				}
				
				//get rect when mouse stops. With a delay if stops in a new window.
				if (p != _pMM) {
					if (_capt._osr.Visible && !_capt._osr.Rect.Contains(p)) _capt._HideRect();
					_pMM = p;
					_mouseMoved = true;
					_timeMM = Environment.TickCount64;
				} else {
					wnd w = wnd.fromXY(p, WXYFlags.NeedWindow);
					bool sameWindow = !_w.Is0 && (w == _w || w.ThreadId == _w.ThreadId);
					bool update = false;
					bool idle = sameWindow && !_mouseMoved;
					if (idle) { //repeat _ShowRect anyway, because may scroll, close window, etc
						long timeNow = Environment.TickCount64;
						long liTime = Api.GetLastInputTime();
						if (timeNow - liTime > 700) {
							long timeNotUpdated = timeNow - _timeUpdated;
							update = timeNotUpdated > 1000 || (liTime > _timeUpdated && timeNotUpdated > 300);
						}
					} else {
						update = sameWindow || Environment.TickCount64 - _timeMM >= 230;
					}
					if (update) {
						//print.it("update rect");
						long t1 = Environment.TickCount64;
						_capt._ShowRect(p, _w = w);
						long t2 = Environment.TickCount64;
						_timeUpdated = t2 + (t2 - t1) * 2;
					}
					_mouseMoved = false;
				}
			}
		}
		
		void _ShowRect(POINT p, wnd w) {
			bool ok = false; RECT r = default; string text = null;
			if (!(w.Is0 || w == _wDialog || (w.IsOfThisThread && w.ZorderIsAbove(_wDialog)))) {
				var k = new GetRectArgs(p, w);
				if (ok = _getRect(k)) (r, text) = (k.resultRect, k.resultText);
				
				//F3 does not work if this process has lower UAC IL than the foreground process.
				//	Normally editor is admin, but if portable etc...
				//	Shift+F3 too. But Ctrl+F3 works.
				//if (w!=wPrev && w.IsActive) {
				//	w = wPrev;
				//	if(w.UacAccessDenied)print.it("F3 ");
				//}
			}
			if (ok && !t_hideCapturingRect) {
				r.Inflate(1, 1); //1 pixel inside, 1 outside
				_LimitInsaneRect(ref r);
				_osr.Rect = r;
				_osr.Show();
				if (!text.NE()) {
					_ost ??= new() { Font = new(8), Shadow = false, ShowMode = OsdMode.ThisThread, SecondsTimeout = -1 };
					_ost.Text = text;
					var ro = _ost.Measure();
					var rs = screen.of(r).Rect;
					int x = r.left, y = r.top + 8;
					if (r.top - rs.top >= ro.Height) y = r.top - ro.Height; else if (r.Height < 200) y = r.bottom; else x += 8;
					_ost.XY = new(x, y, false);
					_ost.Show();
				} else _ost?.Visible = false;
			} else {
				_HideRect();
			}
		}
		
		void _HideRect() {
			_osr.Hide();
			_ost?.Hide();
		}
		
		public record class GetRectArgs(POINT p, wnd wTL) {
			public RECT resultRect;
			public string resultText;
		}
		
		nint _WndProc(nint hwnd, int msg, nint wParam, nint lParam, ref bool handled) {
			if (msg == s_stopMessage) {
				handled = true;
				_captureCheckbox.IsChecked = false;
			} else if (msg == Api.WM_HOTKEY && (wParam is c_hotkeyCapture or c_hotkeyInsert or c_hotkeySmaller)) {
				handled = true;
				if (wParam == c_hotkeyInsert) _hkInsert.a();
				else if (wParam == c_hotkeySmaller) _hkSmaller.a();
				else _hkCapture.a();
			}
			return default;
		}
		
		/// <summary>
		/// Adds link +hotkey that shows dialog "Hotkeys" and updates LA.App.Settings.delm.hk_x.
		/// </summary>
		public static void RegisterLink_DialogHotkey(KSciInfoBox sci) {
			if (sci.AaTags.HasLinkTag("+hotkey")) return;
			sci.AaTags.AddLinkTag("+hotkey", _ => {
				var b = new wpfBuilder("Hotkey");
				b.R.xAddGroupSeparator("In wnd and elm tools");
				b.R.Add("Capture", out TextBox capture, LA.App.Settings.delm.hk_capture).xValidateHotkey(errorIfEmpty: true).Focus();
				b.R.xAddGroupSeparator("In elm tool");
				b.R.Add("Insert code", out TextBox insert, LA.App.Settings.delm.hk_insert).xValidateHotkey();
				b.R.Add("Capturing method", out TextBox smaller, LA.App.Settings.delm.hk_smaller).xValidateHotkey();
				b.R.AddSeparator(false);
				b.R.xAddInfoBlockT("After changing hotkeys please restart the tool window.");
				if (!uacInfo.isAdmin) b.R.xAddInfoBlockT("Hotkeys don't work when the active window is admin,\nbecause this process isn't admin.");
				b.R.AddOkCancel();
				b.End();
				if (b.ShowDialog(Window.GetWindow(sci))) {
					LA.App.Settings.delm.hk_capture = capture.Text;
					LA.App.Settings.delm.hk_insert = insert.TextOrNull();
					LA.App.Settings.delm.hk_smaller = smaller.TextOrNull();
				}
			});
		}
		
		public UsingEndAction TempHideRect() {
			bool v1, v2;
			if (v1 = _osr.Visible) _osr.Hwnd.ShowL(false);
			if (v2 = _ost?.Visible == true) _ost.Hwnd.ShowL(false);
			return new(() => {
				if (v1) _osr.Hwnd.ShowL(true);
				if (v2) _ost.Hwnd.ShowL(true);
			});
		}
	}
}


================================================
FILE: Au.Editor/Tools/ColorQuantizer.cs
================================================
using System.Drawing;
using System.Drawing.Imaging;

namespace ToolLand;

/// <summary>
/// Reduces image color depth with better quality than GDI/GDI+. It makes image smaller.
/// Uses color quantizer algorithm of Xiaolin Wu.
/// Same instance can be reused to quantize multiple images and avoid 0.7 MB of garbage for each; the static functions use this.
/// </summary>
unsafe class ColorQuantizer {
	/// <summary>
	/// Takes screenshot of specified rectangle in screen, quantizes colors to make smaller, compresses, Base64 encodes and returns comment string like <c>" /*image:...*/"</c>.
	/// If fails, prints warning and returns null.
	/// </summary>
	/// <param name="r">Rectangle in screen. Must be not DPI-scaled. This function inflates it if need for DPI of that screen.</param>
	public static string MakeScreenshotComment(RECT r) {
		int dpi = screen.of(r).Dpi;
		if (dpi != 96) {
			r.Inflate((Dpi.Scale(r.Width, dpi) - r.Width) / 2, (Dpi.Scale(r.Height, dpi) - r.Height) / 2);
		}
		try {
			var b = CaptureScreen.Image(r);
			var a = Quantize(b, 16, dpi);
			var z = Convert2.BrotliCompress(a);
			return "/*image:"
				//+ "\r\n" //rejected
				+ "WkJN" + Convert.ToBase64String(z) + "*/";
		}
		catch (Exception e1) { print.warning("MakeScreenshotComment() failed. " + e1.ToStringWithoutStack()); return null; }
	}

	[ThreadStatic] static WeakReference<ColorQuantizer> t_wr;

	/// <summary>
	/// Quantizes bitmap.
	/// </summary>
	/// <param name="b">Bitmap with pixel bit count 32 or 24. If 32, alpha is ignored.</param>
	/// <param name="nColors">Max count of colors desired. Must be 2 to 256 inclusive. For example a 4-bit bitmap can have max 16 colors; 8-bit - max 256 colors.</param>
	/// <param name="dpi">Image resolution as DPI. If more than 96, this function writes this info to the bitmap header.</param>
	/// <returns>.bmp file data (BITMAPFILEHEADER, BITMAPINFOHEADER, color table, pixel bits) of quantized bitmap.</returns>
	/// <exception cref="ArgumentException"></exception>
	public static byte[] Quantize(Bitmap b, int nColors, int dpi = 0) {
		t_wr ??= new(null); if (!t_wr.TryGetTarget(out var q)) t_wr.SetTarget(q = new()); //avoid 0.7 MB of garbage each time

		using var d = b.Data(ImageLockMode.ReadOnly);
		var p = (byte*)d.Scan0;
		bool topDown = d.Stride >= 0;
		if (!topDown) p -= -d.Stride * (d.Height - 1);
		return q.Quantize(d.Width, d.Height, Image.GetPixelFormatSize(d.PixelFormat), p, ref nColors, topDown, dpi);
	}

	/// <summary>
	/// Quantizes bitmap.
	/// </summary>
	/// <param name="b">Bitmap with pixel bit count 32 or 24. If 32, alpha is ignored.</param>
	/// <param name="nColors">Max count of colors desired. Must be 2 to 256 inclusive. For example a 4-bit bitmap can have max 16 colors; 8-bit - max 256 colors.</param>
	/// <param name="dpi">Image resolution as DPI. If more than 96, this function writes this info to the bitmap header.</param>
	/// <returns>Quantized bitmap.</returns>
	/// <exception cref="ArgumentException"></exception>
	public static Bitmap QuantizeB(Bitmap b, int nColors, int dpi = 0) => new(new MemoryStream(Quantize(b, nColors, dpi)));

	// DIB data
	int _width, _height, _lineSize, _colorBytes;
	byte* _bits;

	struct Box { public int r0, r1, g0, g1, b0, b1, vol; }

	const int FI_RGBA_RED = 2, FI_RGBA_GREEN = 1, FI_RGBA_BLUE = 0;
	const int FIQ_SIZE_3D = 33 * 33 * 33;

	float[] _gm2;
	int[] _wt, _mr, _mg, _mb;
	ushort[] Qadd;
	byte[] _tag;

	/// <summary>
	/// Quantizes bitmap.
	/// </summary>
	/// <param name="width"></param>
	/// <param name="height"></param>
	/// <param name="bitCount">Pixel bit count of the input bitmap. Must be 32 or 24. If 32, alpha is ignored.</param>
	/// <param name="bits">Pixels.</param>
	/// <param name="nColors">Input - max count of colors desired. Must be 2 to 256 inclusive. For example a 4-bit bitmap can have max 16 colors; 8-bit - max 256 colors. Output - actual count of colors in color table of the returned bitmap.</param>
	/// <param name="topDown">Top-down bitmap. For example GDI+ (System.Drawing) bitmaps usually are top-down.</param>
	/// <param name="dpi">Image resolution as DPI. If more than 96, this function writes this info to the bitmap header.</param>
	/// <returns>.bmp file data (BITMAPFILEHEADER, BITMAPINFOHEADER, color table, pixel bits) of quantized bitmap.</returns>
	/// <exception cref="ArgumentException"></exception>
	public byte[] Quantize(int width, int height, int bitCount, byte* bits, ref int nColors, bool topDown, int dpi = 0) {
		if (!(bits != null && bitCount is (32 or 24) && width > 0 && height > 0 && nColors >= 2 && nColors <= 256)) throw new ArgumentException();

		_width = width;
		_height = height;
		_lineSize = _LineSize(bitCount);
		_colorBytes = bitCount / 8;
		_bits = bits;

		//Debug_.MemorySetAnchor_();
		static void _Array3D<T>(ref T[] a) { if (a == null) a = new T[FIQ_SIZE_3D]; else Array.Clear(a, 0, a.Length); }
		_Array3D(ref _gm2);
		_Array3D(ref _wt);
		_Array3D(ref _mr);
		_Array3D(ref _mg);
		_Array3D(ref _mb);
		_Array3D(ref _tag);
		Qadd = new ushort[_width * _height];

		var cube = stackalloc Box[256];
		int next;
		int i, weight;
		int k;
		var vv = stackalloc float[256]; float temp;

		// Compute 3D histogram

		Hist3D(_wt, _mr, _mg, _mb, _gm2);

		// Compute moments

		M3D(_wt, _mr, _mg, _mb, _gm2);

		cube[0].r0 = cube[0].g0 = cube[0].b0 = 0;
		cube[0].r1 = cube[0].g1 = cube[0].b1 = 32;
		next = 0;

		for (i = 1; i < nColors; i++) {
			if (Cut(ref cube[next], ref cube[i])) {
				// volume test ensures we won't try to cut one-cell box
				vv[next] = (cube[next].vol > 1) ? Var(cube[next]) : 0;
				vv[i] = (cube[i].vol > 1) ? Var(cube[i]) : 0;
			} else {
				vv[next] = 0f;   // don't try to split this box again
				i--;              // didn't create box i
			}

			next = 0; temp = vv[0];

			for (k = 1; k <= i; k++) {
				if (vv[k] > temp) {
					temp = vv[k]; next = k;
				}
			}

			if (temp <= 0.0) {
				nColors = i + 1;

				// Error: "Only got 'nColors' boxes"

				break;
			}
		}

		// Partition done

		// Allocate a new dib

		int bpp = nColors > 16 ? 8 : 4, lineSize = _LineSize(bpp), paletteSize = nColors * 4, bitsSize = _height * lineSize;
		int headersSize = sizeof(BITMAPFILEHEADER) + sizeof(Api.BITMAPINFOHEADER), bitsOffset = headersSize + paletteSize;
		var ret = new byte[bitsOffset + bitsSize];
		fixed (byte* pret = ret) {

			// create an optimized palette

			var new_pal = (RGBQUAD*)(pret + headersSize);

			for (k = 0; k < nColors; k++) {
				Mark(cube[k], k, _tag);
				weight = Vol(cube[k], _wt);

				if (weight != 0) {
					new_pal[k].rgbRed = (byte)(((float)Vol(cube[k], _mr) / (float)weight) + 0.5f);
					new_pal[k].rgbGreen = (byte)(((float)Vol(cube[k], _mg) / (float)weight) + 0.5f);
					new_pal[k].rgbBlue = (byte)(((float)Vol(cube[k], _mb) / (float)weight) + 0.5f);
				} else {
					// Error: bogus box 'k'

					new_pal[k].rgbRed = new_pal[k].rgbGreen = new_pal[k].rgbBlue = 0;
				}
			}

			// create pixel bits

			var newBits = pret + bitsOffset;
			for (int y = 0; y < _height; y++) {
				byte* new_bits = newBits + (y * lineSize);
				int yy = topDown ? _height - y - 1 : y; //always save as bottom-up
				int lineStart = yy * _width;

				if (bpp == 8) {
					for (int x = 0; x < _width; x++)
						new_bits[x] = _tag[Qadd[lineStart + x]];
				} else {
					int x, n = _width & ~1; //because using x+1
					for (x = 0; x < n; x += 2)
						new_bits[x / 2] = (byte)((_tag[Qadd[lineStart + x]] << 4) | (_tag[Qadd[lineStart + x + 1]] & 0xF));
					if (n != _width) new_bits[x / 2] = (byte)(_tag[Qadd[lineStart + x]] << 4);
				}
			}

			// output 'new_pal' as color look-up table contents,
			// 'new_bits' as the quantized image (array of table addresses).
			var f2 = (BITMAPFILEHEADER*)pret;
			f2->bfType = Math2.MakeWord('B', 'M'); f2->bfSize = ret.Length; f2->bfOffBits = bitsOffset;
			var h2 = (Api.BITMAPINFOHEADER*)(f2 + 1);
			h2->biSize = sizeof(Api.BITMAPINFOHEADER); h2->biPlanes = 1;
			h2->biBitCount = (ushort)bpp; h2->biClrUsed = nColors;
			h2->biWidth = _width; h2->biHeight = _height;
			if (dpi > 96) h2->biXPelsPerMeter = h2->biYPelsPerMeter = (dpi * 39.370079).ToInt();
		}

		//Debug_.MemoryPrint_();
		return ret;

		int _LineSize(int bitCount) => Math2.AlignUp(_width * bitCount, 32) / 8;
	}

	// 3D array indexation
	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	static int FIQ_INDEX(int r, int g, int b) => (r << 10) + (r << 6) + r + (g << 5) + g + b;

	// Histogram is in elements 1..HISTSIZE along each axis,
	// element 0 is for base or marginal value
	// NB: these must start out 0!

	// Build 3-D color histogram of counts, r/g/b, c^2
	void Hist3D(int[] vwt, int[] vmr, int[] vmg, int[] vmb, float[] m2) {
		int ind = 0;
		int inr, ing, inb;
		var table = stackalloc int[256];
		int i, y, x;

		for (i = 0; i < 256; i++)
			table[i] = i * i;

		for (y = 0; y < _height; y++) {
			var bits = _bits + y * _lineSize;

			for (x = 0; x < _width; x++) {
				inr = (bits[FI_RGBA_RED] >> 3) + 1;
				ing = (bits[FI_RGBA_GREEN] >> 3) + 1;
				inb = (bits[FI_RGBA_BLUE] >> 3) + 1;
				ind = FIQ_INDEX(inr, ing, inb);
				Qadd[y * _width + x] = (ushort)ind;
				// [inr][ing][inb]
				vwt[ind]++;
				vmr[ind] += bits[FI_RGBA_RED];
				vmg[ind] += bits[FI_RGBA_GREEN];
				vmb[ind] += bits[FI_RGBA_BLUE];
				m2[ind] += (float)(table[bits[FI_RGBA_RED]] + table[bits[FI_RGBA_GREEN]] + table[bits[FI_RGBA_BLUE]]);
				bits += _colorBytes;
			}
		}
	}
	//___________________________________________

	// At conclusion of the histogram step, we can interpret
	// wt[r][g][b] = sum over voxel of P(c)
	// mr[r][g][b] = sum over voxel of r*P(c)  ,  similarly for mg, mb
	// m2[r][g][b] = sum over voxel of c^2*P(c)
	// Actually each of these should be divided by 'ImageSize' to give the usual
	// interpretation of P() as ranging from 0 to 1, but we needn't do that here.

	// We now convert histogram into moments so that we can rapidly calculate
	// the sums of the above quantities over any desired box.

	// Compute cumulative moments
	static void M3D(int[] vwt, int[] vmr, int[] vmg, int[] vmb, float[] m2) {
		int ind1, ind2;
		byte i, r, g, b;
		int line, line_r, line_g, line_b;
		int* area = stackalloc int[33], area_r = stackalloc int[33], area_g = stackalloc int[33], area_b = stackalloc int[33];
		float line2; var area2 = stackalloc float[33];

		for (r = 1; r <= 32; r++) {
			for (i = 0; i <= 32; i++) {
				area2[i] = 0;
				area[i] = area_r[i] = area_g[i] = area_b[i] = 0;
			}
			for (g = 1; g <= 32; g++) {
				line2 = 0;
				line = line_r = line_g = line_b = 0;
				for (b = 1; b <= 32; b++) {
					ind1 = FIQ_INDEX(r, g, b); // [r][g][b]
					line += vwt[ind1];
					line_r += vmr[ind1];
					line_g += vmg[ind1];
					line_b += vmb[ind1];
					line2 += m2[ind1];
					area[b] += line;
					area_r[b] += line_r;
					area_g[b] += line_g;
					area_b[b] += line_b;
					area2[b] += line2;
					ind2 = ind1 - 1089; // [r-1][g][b]
					vwt[ind1] = vwt[ind2] + area[b];
					vmr[ind1] = vmr[ind2] + area_r[b];
					vmg[ind1] = vmg[ind2] + area_g[b];
					vmb[ind1] = vmb[ind2] + area_b[b];
					m2[ind1] = m2[ind2] + area2[b];
				}
			}
		}
	}
	//___________________________________________

	// Compute sum over a box of any given statistic
	static int Vol(in Box cube, int[] mmt) {
		return mmt[FIQ_INDEX(cube.r1, cube.g1, cube.b1)]
			  - mmt[FIQ_INDEX(cube.r1, cube.g1, cube.b0)]
			  - mmt[FIQ_INDEX(cube.r1, cube.g0, cube.b1)]
			  + mmt[FIQ_INDEX(cube.r1, cube.g0, cube.b0)]
			  - mmt[FIQ_INDEX(cube.r0, cube.g1, cube.b1)]
			  + mmt[FIQ_INDEX(cube.r0, cube.g1, cube.b0)]
			  + mmt[FIQ_INDEX(cube.r0, cube.g0, cube.b1)]
			  - mmt[FIQ_INDEX(cube.r0, cube.g0, cube.b0)];
	}
	//___________________________________________

	// The next two routines allow a slightly more efficient calculation
	// of Vol() for a proposed subbox of a given box.  The sum of Top()
	// and Bottom() is the Vol() of a subbox split in the given direction
	// and with the specified new upper bound.

	// Compute part of Vol(cube, mmt) that doesn't depend on r1, g1, or b1
	// (depending on dir)
	static int Bottom(in Box cube, byte dir, int[] mmt) {
		switch (dir) {
		case FI_RGBA_RED:
			return -mmt[FIQ_INDEX(cube.r0, cube.g1, cube.b1)]
					+ mmt[FIQ_INDEX(cube.r0, cube.g1, cube.b0)]
					+ mmt[FIQ_INDEX(cube.r0, cube.g0, cube.b1)]
					- mmt[FIQ_INDEX(cube.r0, cube.g0, cube.b0)];
		case FI_RGBA_GREEN:
			return -mmt[FIQ_INDEX(cube.r1, cube.g0, cube.b1)]
					+ mmt[FIQ_INDEX(cube.r1, cube.g0, cube.b0)]
					+ mmt[FIQ_INDEX(cube.r0, cube.g0, cube.b1)]
					- mmt[FIQ_INDEX(cube.r0, cube.g0, cube.b0)];
		case FI_RGBA_BLUE:
			return -mmt[FIQ_INDEX(cube.r1, cube.g1, cube.b0)]
					+ mmt[FIQ_INDEX(cube.r1, cube.g0, cube.b0)]
					+ mmt[FIQ_INDEX(cube.r0, cube.g1, cube.b0)]
					- mmt[FIQ_INDEX(cube.r0, cube.g0, cube.b0)];
		}

		return 0;
	}
	//___________________________________________

	// Compute remainder of Vol(cube, mmt), substituting pos for
	// r1, g1, or b1 (depending on dir)
	static int Top(in Box cube, byte dir, int pos, int[] mmt) {
		switch (dir) {
		case FI_RGBA_RED:
			return mmt[FIQ_INDEX(pos, cube.g1, cube.b1)]
				   - mmt[FIQ_INDEX(pos, cube.g1, cube.b0)]
				   - mmt[FIQ_INDEX(pos, cube.g0, cube.b1)]
				   + mmt[FIQ_INDEX(pos, cube.g0, cube.b0)];
		case FI_RGBA_GREEN:
			return mmt[FIQ_INDEX(cube.r1, pos, cube.b1)]
				   - mmt[FIQ_INDEX(cube.r1, pos, cube.b0)]
				   - mmt[FIQ_INDEX(cube.r0, pos, cube.b1)]
				   + mmt[FIQ_INDEX(cube.r0, pos, cube.b0)];
		case FI_RGBA_BLUE:
			return mmt[FIQ_INDEX(cube.r1, cube.g1, pos)]
				   - mmt[FIQ_INDEX(cube.r1, cube.g0, pos)]
				   - mmt[FIQ_INDEX(cube.r0, cube.g1, pos)]
				   + mmt[FIQ_INDEX(cube.r0, cube.g0, pos)];
		}

		return 0;
	}
	//___________________________________________

	// Compute the weighted variance of a box 
	// NB: as with the raw statistics, this is really the variance * ImageSize 
	float Var(in Box cube) {
		float dr = (float)Vol(cube, _mr);
		float dg = (float)Vol(cube, _mg);
		float db = (float)Vol(cube, _mb);
		float xx = _gm2[FIQ_INDEX(cube.r1, cube.g1, cube.b1)]
				- _gm2[FIQ_INDEX(cube.r1, cube.g1, cube.b0)]
				 - _gm2[FIQ_INDEX(cube.r1, cube.g0, cube.b1)]
				 + _gm2[FIQ_INDEX(cube.r1, cube.g0, cube.b0)]
				 - _gm2[FIQ_INDEX(cube.r0, cube.g1, cube.b1)]
				 + _gm2[FIQ_INDEX(cube.r0, cube.g1, cube.b0)]
				 + _gm2[FIQ_INDEX(cube.r0, cube.g0, cube.b1)]
				 - _gm2[FIQ_INDEX(cube.r0, cube.g0, cube.b0)];

		return (xx - (dr * dr + dg * dg + db * db) / (float)Vol(cube, _wt));
	}
	//___________________________________________

	// We want to minimize the sum of the variances of two subboxes.
	// The sum(c^2) terms can be ignored since their sum over both subboxes
	// is the same (the sum for the whole box) no matter where we split.
	// The remaining terms have a minus sign in the variance formula,
	// so we drop the minus sign and MAXIMIZE the sum of the two terms.
	float Maximize(in Box cube, byte dir, int first, int last, out int cut, int whole_r, int whole_g, int whole_b, int whole_w) {
		int half_r, half_g, half_b, half_w;
		int i;
		float temp;

		int base_r = Bottom(cube, dir, _mr);
		int base_g = Bottom(cube, dir, _mg);
		int base_b = Bottom(cube, dir, _mb);
		int base_w = Bottom(cube, dir, _wt);

		float max = 0f;

		cut = -1;

		for (i = first; i < last; i++) {
			half_r = base_r + Top(cube, dir, i, _mr);
			half_g = base_g + Top(cube, dir, i, _mg);
			half_b = base_b + Top(cube, dir, i, _mb);
			half_w = base_w + Top(cube, dir, i, _wt);

			// now half_x is sum over lower half of box, if split at i

			if (half_w == 0) {      // subbox could be empty of pixels!
				continue;           // never split into an empty box
			} else {
				temp = ((float)half_r * half_r + (float)half_g * half_g + (float)half_b * half_b) / half_w;
			}

			half_r = whole_r - half_r;
			half_g = whole_g - half_g;
			half_b = whole_b - half_b;
			half_w = whole_w - half_w;

			if (half_w == 0) {      // subbox could be empty of pixels!
				continue;           // never split into an empty box
			} else {
				temp += ((float)half_r * half_r + (float)half_g * half_g + (float)half_b * half_b) / half_w;
			}

			if (temp > max) {
				max = temp;
				cut = i;
			}
		}

		return max;
	}
	//___________________________________________

	bool Cut(ref Box set1, ref Box set2) {
		byte dir;
		int cutr, cutg, cutb;

		int whole_r = Vol(set1, _mr);
		int whole_g = Vol(set1, _mg);
		int whole_b = Vol(set1, _mb);
		int whole_w = Vol(set1, _wt);

		float maxr = Maximize(set1, FI_RGBA_RED, set1.r0 + 1, set1.r1, out cutr, whole_r, whole_g, whole_b, whole_w);
		float maxg = Maximize(set1, FI_RGBA_GREEN, set1.g0 + 1, set1.g1, out cutg, whole_r, whole_g, whole_b, whole_w);
		float maxb = Maximize(set1, FI_RGBA_BLUE, set1.b0 + 1, set1.b1, out cutb, whole_r, whole_g, whole_b, whole_w);

		if ((maxr >= maxg) && (maxr >= maxb)) {
			dir = FI_RGBA_RED;

			if (cutr < 0) {
				return false; // can't split the box
			}
		} else if ((maxg >= maxr) && (maxg >= maxb)) {
			dir = FI_RGBA_GREEN;
		} else {
			dir = FI_RGBA_BLUE;
		}

		set2.r1 = set1.r1;
		set2.g1 = set1.g1;
		set2.b1 = set1.b1;

		switch (dir) {
		case FI_RGBA_RED:
			set2.r0 = set1.r1 = cutr;
			set2.g0 = set1.g0;
			set2.b0 = set1.b0;
			break;

		case FI_RGBA_GREEN:
			set2.g0 = set1.g1 = cutg;
			set2.r0 = set1.r0;
			set2.b0 = set1.b0;
			break;

		case FI_RGBA_BLUE:
			set2.b0 = set1.b1 = cutb;
			set2.r0 = set1.r0;
			set2.g0 = set1.g0;
			break;
		}

		set1.vol = (set1.r1 - set1.r0) * (set1.g1 - set1.g0) * (set1.b1 - set1.b0);
		set2.vol = (set2.r1 - set2.r0) * (set2.g1 - set2.g0) * (set2.b1 - set2.b0);

		return true;
	}
	//___________________________________________

	static void Mark(in Box cube, int label, byte[] tag) {
		for (int r = cube.r0 + 1; r <= cube.r1; r++) {
			for (int g = cube.g0 + 1; g <= cube.g1; g++) {
				for (int b = cube.b0 + 1; b <= cube.b1; b++) {
					tag[FIQ_INDEX(r, g, b)] = (byte)label;
				}
			}
		}
	}

	[StructLayout(LayoutKind.Sequential, Pack = 2)]
	internal struct BITMAPFILEHEADER {
		public ushort bfType;
		public int bfSize;
		public ushort bfReserved1;
		public ushort bfReserved2;
		public int bfOffBits;
	}

#pragma warning disable CS0649 //field never assigned

	internal struct RGBQUAD {
		public byte rgbBlue;
		public byte rgbGreen;
		public byte rgbRed;
		public byte rgbReserved;
	}
}


================================================
FILE: Au.Editor/Tools/DCustomize.cs
================================================
using System.Windows;
using System.Windows.Controls;
using System.Windows.Controls.Primitives;
using System.Windows.Input;
using System.Windows.Media;
using Au.Controls;
using ToolLand;
using System.Xml.Linq;

#if SCRIPT
namespace Script;
#endif

namespace LA;

class DCustomize : KDialogWindow {
	public static void ShowSingle(string commandName = null) {
		var d = ShowSingle(() => new DCustomize());
		if (commandName != null) d._SelectAndOpen(commandName);
	}
	
	/// <summary>
	/// If the dialog is open, sets its Image field text and returns true. Called from the Icons dialog.
	/// </summary>
	public static bool AaSetImage(string s) {
		if (!GetSingle(out DCustomize d)) return false;
		if (d._panelProp.IsVisible) d._tImage.Text = s;
		return true;
	}
	
	List<_Custom> _tree;
	KSciInfoBox _info;
	
	ContextMenu _menu;
	Dictionary<string, _Default> _dict = new();
	
	KTreeView _tv;
	Panel _panelProp;
	TextBox _tColor, _tText, _tImage, _tKeys, _tBtext;
	TextBox _tDefText, _tDefImage, _tDefKeys;
	KCheckBox _cSeparator;
	ComboBox _cbHide, _cbImageAt;
	Label _lCommandPath;
	
	_Custom _ti; //current item
	_Custom _clip; //cut/copy item
	bool _ignoreEvents;
	
	DCustomize() {
		InitWinProp("Customize", App.Wmain);
		
		var b = new wpfBuilder(this).WinSize(700, 700).Columns(220, 0, -1);
		b.Row(-1);
		
		b.xAddInBorder(out _tv);
		b.Add<GridSplitter>().Splitter(vertical: true);
		
		b.StartGrid().Columns(-1); //right side
		
		b.Row(84).Add(out _info);
		b.AddSeparator(vertical: false);
		
		b.Row(-1).StartStack(vertical: true).Hidden();
		_panelProp = b.Panel;
		
		b.Add(out _lCommandPath).Padding("4").Brush(Brushes.LightBlue, Brushes.Black);
		b.StartGrid<KGroupBox>("Properties common to menu item and toolbar button").Columns(0, -1, 30, 30);
		b.R.Add("Text", out _tText).Tooltip("Text.\nInsert _ before Alt-underlined character.");
		b.R.Add("Color", out _tColor).Tooltip("Text color.\nCan be a .NET color name or #RRGGBB or #RGB.")
			.xAddButtonIcon(EdIcons.Color, _ => KColorPicker.ColorTool(s => { _tColor.Text = s; }, b.Window, modal: true, add0xRgbButton: false, addBgrButton: false), "Colors").Span(1);
		b.R.Add("Image", out _tImage).Tooltip("Icon name etc.\nSee ImageUtil.LoadWpfImageElement.")
			.xAddButtonIcon(EdIcons.Icons, _ => { _tImage.SelectAll(); DIcons.ShowSingle(expandMenuIcon: true); }, "Icons tool.\nSelect an icon and click button 'Menu or toolbar item'.").Span(1);
		b.R.Add("Keys", out _tKeys).Tooltip("Keyboard or/and mouse shortcut(s), like Ctrl+E, Shift+M-click.\nSee keys.more.parseHotkeyString.")
			.xAddButtonIcon(EdIcons.Keys, _ => _KeysTool(), "Keys tool");
		b.xAddButtonIcon("*FeatherIcons.Eye" + EdIcons.black, _ => _KeysList(), "Existing hotkeys");
		b.StartGrid<Expander>("Default");
		b.R.Add("Text", out _tDefText); _Readonly(_tDefText);
		b.R.Add("Image", out _tDefImage); _Readonly(_tDefImage);
		b.R.Add("Keys", out _tDefKeys); _Readonly(_tDefKeys);
		static void _Readonly(TextBox k) {
			k.IsReadOnly = true;
			k.IsReadOnlyCaretVisible = true;
			k.Background = SystemColors.ControlBrush;
		}
		b.End();
		b.End();
		
		b.StartGrid<KGroupBox>("Toolbar button properties").Columns(0, 100, -1);
		b.R.Add("Text", out _tBtext).Multiline(wrap: TextWrapping.NoWrap).Tooltip("Button text, if different than menu item text.");
		b.R.Add("Image at", out _cbImageAt).Items("", "left", "top", "right", "bottom").Span(1).Tooltip("Display image + text and put image at this side.\nFor submenu-items always left.");
		b.R.Add(out _cSeparator, "Separator before");
		b.R.Add("Hide", out _cbHide).Items("", "always", "never").Span(1).Tooltip("When to move the button to the overflow dropdown.\nIf empty - when the toolbar is too small.");
		b.End();
		
		b.StartGrid<KGroupBox>("Move");
		b.R.AddButton("Up", _ => _Move(_ti, true)).Tooltip("Shift+Up");
		b.R.AddButton("Down", _ => _Move(_ti, false)).Tooltip("Shift+Down");
		b.End().Width(90).Align("L");
		
		b.End();
		
		b.R.AddSeparator(vertical: false);
		b.R.StartOkCancel()
			.AddButton(out var bOK, "Save", _ => { _Save(); }).Width(70).Tooltip("Saves changes. Will be applied when the program starts next time.")
			.AddButton(out var bOK2, "Save and restart", _ => { _Save(); Close(); App.Restart(); }).Width(120).Tooltip("Saves changes and restarts the program.")
			.AddButton(out var bCancel, "Cancel", _ => Close()).Width(70)
			.End();
		
		b.End(); //right side
		b.End();
		
		_FillMenu();
		
		_tv.SingleClickActivate = true;
		_tv.ItemActivated += _tv_ItemActivated;
		_tv.ItemClick += _tv_ItemClick;
		_tv.KeyDown += _tv_KeyDown;
		_FillTree();
		
		foreach (var v in new Control[] { _tText, _tColor, _tImage, _tKeys, _tBtext, _cbImageAt, _cbHide, _cSeparator }) {
			void _Update() { if (!_ignoreEvents) { _GetControlValues(); _tv.Redraw(); } }
			if (v is TextBox tb) tb.TextChanged += (_, _) => _Update();
			else if (v is ComboBox cb) cb.SelectionChanged += (_, _) => _Update();
			else if (v is KCheckBox ch) ch.CheckChanged += (_, _) => _Update();
		}
		
		b.Loaded += () => {
			_info.aaaText = $"""
Here you can edit menus, toolbars and hotkeys of the main window.

<b>menu</b> - customized menu items. Right-click...
<b>File, etc</b> - toolbars. Right-click to add a button.

Menu items cannot be removed or reordered. Default toolbar buttons cannot be removed, but you can edit, reorder and hide.

Text color in the list: blue - customized; gray - hidden button; red - cut.

You also can edit the <explore {App.Commands.UserFile}>file<> in an XML editor. To reset everything, delete the file. To reset an item or toolbar, remove it from XML.
""";
		};
		
		void _KeysTool() {
			_tKeys.SelectAll();
			_tKeys.Focus();
			var k = new KeysWindow { InsertInControl = _tKeys, ClickClose = KPopup.CC.Outside, CloseHides = true };
			k.SetFormat(PSFormat.Hotkey);
			k.ShowByRect(_tKeys, Dock.Bottom);
		}
		
		void _KeysList() {
			var m = new popupMenu();
			var a = new Dictionary<_Default, string>();
			//add default hotkeys to a
			foreach (var v in _dict) {
				if (v.Value.attr.keys is string k) a.Add(v.Value, k);
			}
			//add custom hotkeys to a
			foreach (var v in _tree.SelectMany(o => o.Children())) {
				if (v.keys is string k) {
					if (k == "") a.Remove(v.def); else a[v.def] = k;
				}
			}
			//add all to menu
			foreach (var v in a.OrderBy(o => o.Value, StringComparer.OrdinalIgnoreCase)) {
				var u = m.Add(v.Key.text + "\t" + v.Value, o => {
					var d = o.Tag as _Default;
					var c = _tree.SelectMany(o => o.Children()).FirstOrDefault(o => o.def == d);
					if (c == null) {
						if (!dialog.showOkCancel("Customize this menu item?", d.text, owner: this)) return;
						_AddToCustomized(d, _tree.Find(o => o.isMenu));
					} else {
						_SelectAndOpen(c);
					}
				});
				u.Tag = v.Key;
				if (v.Value != v.Key.attr.keys) u.TextColor = Colors.Blue; //customized
			}
			m.Show(owner: this);
		}
	}
	
	void _tv_ItemActivated(TVItemEventArgs e) => _Open(e.Item as _Custom);
	
	void _Open(_Custom c) {
		//print.it(c.name);
		if (c.Level == 0) {
			_panelProp.Visibility = Visibility.Hidden;
			return;
		}
		_ti = c;
		_ignoreEvents = true;
		_panelProp.Visibility = Visibility.Visible;
		
		var path = new Stack<string>();
		for (var v = c.def; v != null; v = v.parent) path.Push(v.text);
		_lCommandPath.Content = string.Join(" > ", path);
		
		//common
		_tText.Text = c.ctext ?? c.def.text;
		_tColor.Text = c.color;
		_tImage.Text = c.image ?? c.def.attr.image;
		_tKeys.Text = c.keys ?? c.def.attr.keys;
		_tDefText.Text = c.def.text;
		_tDefImage.Text = c.def.attr.image;
		_tDefKeys.Text = c.def.attr.keys;
		//button
		_tBtext.Text = c.btext;
		_cbImageAt.SelectedIndex = c.imageAt switch { "left" => 1, "top" => 2, "right" => 3, "bottom" => 4, _ => 0 };
		_cSeparator.IsChecked = c.separator;
		_cbHide.SelectedIndex = c.hide switch { "always" => 1, "never" => 2, _ => 0 };
		
		_ignoreEvents = false;
	}
	
	void _GetControlValues() {
		var c = _ti;
		c.ctext = _Text(_tText, c.def.text);
		c.color = _Text(_tColor);
		c.image = _Text(_tImage, c.def.attr.image);
		c.keys = _Text(_tKeys, c.def.attr.keys);
		c.btext = _Text(_tBtext);
		c.imageAt = _Text(_cbImageAt);
		c.separator = _cSeparator.IsChecked;
		c.hide = _Text(_cbHide);
		
		string _Text(Control tbcb, string def = null) {
			var s = tbcb switch { TextBox tb => tb.Text, ComboBox cb => cb.SelectedValue as string, _ => null };
			s = s.NullIfEmpty_();
			if (def == null) return s;
			if (s == def) return null;
			return s ?? "";
		}
	}
	
	void _SelectAndOpen(_Custom t) {
		_tv.SelectSingle(t);
		if (t != _ti) _Open(t);
	}
	
	void _SelectAndOpen(string commandName) {
		var c = _tree.SelectMany(o => o.Children()).LastOrDefault(o => o.def.name == commandName); //Last to prefer toolbar button and not menu item
		if (c != null) _SelectAndOpen(c);
	}
	
	void _tv_ItemClick(TVItemEventArgs e) {
		var t = e.Item as _Custom;
		if (e.Button == MouseButton.Right) {
			var m = new popupMenu();
			
			var c0 = t.Level == 0 ? t : t.Parent;
			m[c0.isMenu ? "Customize menu item..." : "Add button..."] = o => { _menu.PlacementTarget = this; _menu.IsOpen = true; };
			if (t.Level == 1) {
				m.Separator();
				m["Cut"] = o => _Cut(t);
				_MiPaste(false);
				m.AddCheck("Hide", t.hide == "always", o => _Hide(t, o.IsChecked));
				if (!_IsDefaultButton(t)) {
					m.Submenu("Delete", m => {
						m["Delete"] = o => _Delete(t, ask: false);
					});
				}
			} else {
				_MiPaste(true);
			}
			
			void _MiPaste(bool into) {
				if (_CanPaste(t)) m["Paste"] = o => _Paste(t);
			}
			
			_contextMenuOwner = t;
			m.Show(owner: this);
		}
	}
	
	_Custom _contextMenuOwner;
	
	void _Cut(_Custom t) {
		if (_clip != null) _tv.Redraw(_clip);
		_clip = t;
		_tv.Redraw(t); //red etc
	}
	
	bool _CanPaste(_Custom where) {
		if (_clip == null || _clip == where) return false;
		if (_IsDefaultButton(_clip) && where != _clip.Parent && where.Parent != _clip.Parent) return false; //don't move to another toolbar
		return true;
	}
	
	void _Paste(_Custom where) {
		_clip.Remove();
		if (where.Level == 0) where.AddChild(_clip); else where.AddSibling(_clip, after: false);
		_clip = null;
		_tv.SetItems(_tree, modified: true);
	}
	
	void _AddToCustomized(_Default def, _Custom where) {
		var c0 = where.Level == 0 ? where : where.Parent;
		var c = c0.Children().FirstOrDefault(o => o.def == def);
		if (c == null) {
			c = new _Custom(this, def, c0.isMenu);
			if (c0 == where) where.AddChild(c); else where.AddSibling(c, after: false);
			
			_tv.SetItems(_tree, modified: true);
		}
		
		_SelectAndOpen(c);
	}
	
	void _Move(_Custom t, bool up) {
		var where = up ? t.Previous : t.Next;
		if (where == null) {
			if (_IsDefaultButton(t)) return; //don't move to another toolbar
			int i = _tree.IndexOf(t.Parent) + (up ? -1 : 1);
			if ((uint)i >= _tree.Count) return;
			where = _tree[i];
		}
		t.Remove();
		if (where.Level == 0) where.AddChild(t, first: !up); else where.AddSibling(t, after: !up);
		_tv.SetItems(_tree, modified: true);
		_tv.EnsureVisible(t);
	}
	
	void _Delete(_Custom t, bool ask) {
		if (!_IsDefaultButton(t)) {
			if (ask && !dialog.showOkCancel("Delete?", t.displayText, owner: this)) return;
			if (t == _ti) _panelProp.Visibility = Visibility.Hidden;
			_clip = null;
			t.Remove();
			_tv.SetItems(_tree, true);
		} else if (t == _ti) {
			_cbHide.SelectedIndex = 1;
		} else {
			t.hide = "always";
			_tv.Redraw(t);
		}
	}
	
	void _Hide(_Custom t, bool hide) {
		if (t == _ti) {
			_cbHide.SelectedIndex = hide ? 1 : 0;
		} else {
			t.hide = hide ? "always" : null;
			_tv.Redraw(t);
		}
	}
	
	bool _IsDefaultButton(_Custom t) {
		if (t.Level > 0 && !t.isMenu) {
			_xdefault ??= XmlUtil.LoadElem(App.Commands.DefaultFile);
			return _xdefault.Element(t.Parent.displayText)?.Element(t.def.name) != null;
		}
		return false;
	}
	XElement _xdefault;
	
	void _FillMenu() {
		_Menu(Panels.Menu, _menu = new(), null, 0);
		
		void _Menu(ItemsControl sourceMenu, ItemsControl destMenu, _Default parentCommand, int level) {
			foreach (var o in sourceMenu.Items) {
				if (o is not MenuItem ms || ms.Command is not KMenuCommands.Command c) continue;
				string name = c.Name;
				
				var def = new _Default(name, c.Attribute, c.Text, parentCommand);
				_dict.Add(name, def);
				
				var m = new MenuItem { Name = name, Header = c.Text };
				destMenu.Items.Add(m);
				
				if (ms.Role is MenuItemRole.SubmenuHeader or MenuItemRole.TopLevelHeader) {
					if (level > 0) m.PreviewMouseLeftButtonUp += (o, e) => { if (e.Source == o) { this.Focus(); _AddToCustomized(def, _contextMenuOwner); }; };
					
					_Menu(ms, m, def, level + 1);
				} else {
					m.Click += (o, _) => _AddToCustomized(def, _contextMenuOwner);
				}
			}
			//}
		}
	}
	
	void _FillTree() {
		_tree = new();
		var a = App.Commands.LoadFiles(); if (a == null) return;
		
		foreach (var xx in a) {
			var s1 = xx.Name.LocalName;
			bool isMenu = s1 == "menu";
			var vv = new _Custom(this, null, isMenu, s1);
			_tree.Add(vv);
			foreach (var x in xx.Elements()) {
				if (!_dict.TryGetValue(x.Name.LocalName, out var def)) continue;
				var c = new _Custom(this, def, isMenu) {
					color = x.Attr("color"),
					ctext = x.Attr("text"),
					image = x.Attr("image"),
					keys = x.Attr("keys"),
					hide = x.Attr("hide"),
					imageAt = x.Attr("imageAt"),
					separator = x.HasAttr("separator"),
					btext = x.Attr("btext"),
				};
				vv.AddChild(c);
			}
		}
		
		_tv.SetItems(_tree);
	}
	
	void _Save() {
		var xr = new XElement("commands");
		foreach (var t in _tree) {
			var xt = new XElement(t.displayText);
			xr.Add(xt);
			foreach (var c in t.Children()) {
				if (c.isMenu && !c.IsCustomized()) continue;
				var x = new XElement(c.def.name);
				xt.Add(x);
				if (c.separator) x.SetAttributeValue("separator", "");
				_Set("text", c.ctext);
				_Set("color", c.color);
				_Set("image", c.image);
				_Set("keys", c.keys);
				_Set("btext", c.btext);
				_Set("imageAt", c.imageAt);
				_Set("hide", c.hide);
				
				void _Set(string attr, string s) {
					if (s != null) x.SetAttributeValue(attr, s);
				}
			}
		}
		//print.clear();
		//print.it(xr);
		xr.SaveElem(App.Commands.UserFile);
	}
	
	//default properties (Menus member name and attributes)
	record _Default(string name, CommandAttribute attr, string text, _Default parent);
	
	//customized properties (in XML file)
	class _Custom : TreeBase<_Custom>, ITreeViewItem {
		readonly DCustomize _d;
		public readonly _Default def;
		public string displayText;
		public readonly bool isMenu;
		bool _isExpanded;
		//customized properties
		public bool separator;
		public string ctext, color, image, keys, btext, imageAt, hide;
		
		public _Custom(DCustomize d, _Default def, bool isMenu, string displayText = null) {
			_d = d;
			this.def = def;
			this.isMenu = isMenu;
			this.displayText = displayText ?? StringUtil.RemoveUnderlineChar(def.text, '_');
			_isExpanded = def == null;
		}
		
		#region ITreeViewItem
		
		void ITreeViewItem.SetIsExpanded(bool yes) { _isExpanded = yes; }
		
		public bool IsExpanded => _isExpanded;
		
		IEnumerable<ITreeViewItem> ITreeViewItem.Items => base.Children();
		
		public bool IsFolder => base.HasChildren;
		
		string ITreeViewItem.DisplayText => displayText;
		
		object ITreeViewItem.Image
			=> Level == 0 ? EdIcons.FolderArrow(_isExpanded) : (image ?? def.attr.image);
		
		int ITreeViewItem.Color(TVColorInfo ci)
			=> Level > 0 ? -1 : isMenu ? 0xF0C080 : 0xC0E0A0;
		
		int ITreeViewItem.TextColor(TVColorInfo ci)
			=> this == _d._clip ? 0xFF0000
			: hide == "always" ? 0x808080
			: IsCustomized() ? (ci.isHighContrastDark ? 0xFFFF00 : 0x0000FF)
			: Level == 0 ? 0
			: -1;
		
		#endregion
		
		public bool IsCustomized() {
			if (def == null) return false;
			if (separator && isMenu) return true; //never mind: or may be specified in the default XML file, but that info now is lost.
			return ctext != null || color != null || image != null || keys != null || btext != null || imageAt != null || hide != null;
		}
	}
	
	void _tv_KeyDown(object sender, KeyEventArgs e) {
		var k = (e.KeyboardDevice.Modifiers, e.Key);
		switch (k) {
		case (0, Key.Escape):
			if (_clip != null) {
				_clip = null;
				_tv.Redraw();
			}
			goto gh;
		}
		if (_tv.FocusedItem is _Custom t) {
			switch (k) {
			case (0, Key.Delete):
				if (t.Level > 0) _Delete(t, ask: true);
				break;
			case (ModifierKeys.Control, Key.X):
				if (t.Level > 0) _Cut(t);
				break;
			case (ModifierKeys.Control, Key.V):
				if (_CanPaste(t)) _Paste(t);
				break;
			case (ModifierKeys.Shift, Key.Up):
				if (t.Level > 0) _Move(t, up: true);
				break;
			case (ModifierKeys.Shift, Key.Down):
				if (t.Level > 0) _Move(t, up: false);
				break;
			default: return;
			}
		}
		gh:
		e.Handled = true;
	}
	
	public static void ToolbarContextMenuOpening(object sender, ContextMenuEventArgs _1) {
		if (GetSingle<DCustomize>(out _)) return;
		var toolbar = sender as ToolBar;
		FrameworkElement e = null;
		ICommand ic = null;
		int index = 0;
		
		//WPF does not have a better way to get the right-clicked element when it is disabled. Mouse.DirectlyOver etc return the container.
		var xy = mouse.xy;
		foreach (FrameworkElement v in toolbar.Items) {
			if (v.IsVisible && v is System.Windows.Controls.Primitives.ButtonBase or Border && v.RectInScreen().Contains(xy)) {
				e = v;
				if (v is ButtonBase b1) ic = b1.Command;
				else if (v is Border b2 && b2.Child is Menu m2) ic = m2.Items.OfType<MenuItem>().SingleOrDefault()?.Command;
				break;
			}
			index++;
		}
		if (ic is not KMenuCommands.Command c) return;
		
		OverflowMode hide1 = ToolBar.GetOverflowMode(e);
		bool separatorBefore = index > 0 && toolbar.Items[index - 1] is Separator;
		
		var m = new popupMenu();
		m["Customize..."] = o => DCustomize.ShowSingle(c.Name);
		m.Separator();
		m.AddCheck("Hide", hide1 == OverflowMode.Always, _ => _Hide(hide1 == OverflowMode.Always ? OverflowMode.AsNeeded : OverflowMode.Always));
		m.AddCheck("Never hide", hide1 == OverflowMode.Never, _ => _Hide(hide1 == OverflowMode.Never ? OverflowMode.AsNeeded : OverflowMode.Never));
		if (!ToolBar.GetIsOverflowItem(e)) {
			m.Separator();
			m.AddCheck("Separator before", separatorBefore, o => _Separator());
		}
		m.Show();
		
		void _Hide(OverflowMode hide2) {
			if (!_ModifyUserXmlButton(x => { x.SetAttributeValue("hide", hide2 switch { OverflowMode.Always => "always", OverflowMode.Never => "never", _ => null }); })) return;
			
			ToolBar.SetOverflowMode(e, hide2);
			if (separatorBefore) ToolBar.SetOverflowMode(toolbar.Items[index - 1] as Separator, hide2);
		}
		
		void _Separator() {
			if (!_ModifyUserXmlButton(x => { x.SetAttributeValue("separator", separatorBefore ? null : ""); })) return;
			
			if (separatorBefore) {
				toolbar.Items.RemoveAt(index - 1);
			} else {
				var sep = new Separator();
				if (hide1 != default) ToolBar.SetOverflowMode(sep, hide1);
				toolbar.Items.Insert(index, sep);
			}
		}
		
		bool _ModifyUserXmlButton(Action<XElement> modify) {
			if (App.Commands.LoadFiles() is not { } toolbars) return false;
			if (toolbars.FirstOrDefault(o => o.Name == toolbar.Name)?.Element(c.Name) is not { } x) return false;
			modify(x);
			new XElement("commands", toolbars).SaveElem(App.Commands.UserFile);
			return true;
		}
	}
}


================================================
FILE: Au.Editor/Tools/DCustomizeContextMenu.cs
================================================
using Au.Controls;
using System.Windows.Controls;
using System.Windows;
using System.Windows.Controls.Primitives;
using System.Windows.Input;
using System.Windows.Media;

namespace LA;

static class DCustomizeContextMenu {
	
	public static void Dialog(string menuName, string ownerName) {
		var (file, text) = _GetFilePathAndText(menuName);
		
		var b = new wpfBuilder("Customize context menu").WinSize(550, 550).Columns(-1, -1);
		b.WinProperties(showInTaskbar: false);
		
		b.Row(40).Add(out KSciInfoBox info);
		info.aaaText = $"""
Left - all menu commands. Select a line and drag or copy to the right.
Right - commands to add to the context menu of the {ownerName}. Separator -.
""";
		
		b.Row(-1).xAddInBorder(out KScintilla t1);
		t1.AaInitReadOnlyAlways = true;
		b.Loaded += () => {
			t1.aaaText = _GetAllCommands(menuName, out int goTo);
			if (goTo > 0) t1.Call(Sci.SCI_LINESCROLL, 0, t1.aaaLineFromPos(false, goTo));
		};
		
		b.xAddInBorder(out KScintilla t2);
		t2.AaInitUseDefaultContextMenu = true;
		t2.aaaText = text;
		//b.Validation(o => never mind);
		t2.AaNotify += e => {
			unsafe {
				if (e.n.code == Sci.NOTIF.SCN_MODIFIED) {
					//trim tabs
					if (e.n.modificationType.Has(Sci.MOD.SC_MOD_INSERTCHECK) && e.n.length > 1 && e.n.textUTF8[0] == 9) {
						var s = e.n.Text.RxReplace(@"(?m)^\t+", "");
						e.c.aaaSetString(Sci.SCI_CHANGEINSERTION, s);
					}
				}
			}
		};
		
		b.R.AddOkCancel();
		b.End();
		if (!b.ShowDialog(App.Wmain)) return;
		
		filesystem.saveText(file, t2.aaaText);
	}
	
	static string _GetAllCommands(string menuName, out int goTo) {
		int go = -1;
		var b = new StringBuilder();
		_Menu(Panels.Menu, 0);
		goTo = go;
		return b.ToString();
		
		void _Menu(ItemsControl sourceMenu, int level) {
			foreach (var o in sourceMenu.Items) {
				if (o is not MenuItem ms || ms.Command is not KMenuCommands.Command c) continue;
				bool isMenu = ms.Role is MenuItemRole.SubmenuHeader or MenuItemRole.TopLevelHeader;
				if (isMenu && go < 0 && c.Name == menuName) go = b.Length;
				b.Append('\t', level).AppendLine(c.Name);
				if (isMenu) _Menu(ms, level + 1);
			}
		}
	}
	
	static (string path, string text) _GetFilePathAndText(string menuName) {
		string file = AppSettings.DirBS + menuName + " context menu.txt", text = null;
		if (filesystem.exists(file)) text = filesystem.loadText(file);
		else if (menuName == "Edit") text = """
Cut
Copy
Paste
-
Surround
Toggle_bookmark
""";
		return (file, text);
	}
	
	public static void AddToMenu(KWpfMenu m, string menuName) {
		try {
			if (_GetFilePathAndText(menuName).text is not string text) return;
			var a = text.Lines();
			bool needSeparator = false;
			foreach (var line in a) {
				var s = line.Trim();
				if (s.Length == 0 || s.Starts('/')) continue;
				if (s == "-") {
					m.Separator();
					needSeparator = false;
				} else if (App.Commands.TryFind(s, out var c)) {
					var k = new MenuItem();
					c.CopyToMenu(k);
					m.Items.Add(k);
					needSeparator = true;
				} else {
					//print.it($"<>Unknown menu command: {s}.");
				}
			}
			if (needSeparator) m.Items.Add(new Separator());
		}
		catch (Exception e1) { Debug_.Print(e1); }
	}
}


================================================
FILE: Au.Editor/Tools/DEnumFiles.cs
================================================
using System.Windows;
using System.Windows.Controls;
using System.Windows.Controls.Primitives;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Data;
using Au.Controls;
using ToolLand;

namespace LA;

class DEnumDir : KDialogWindow {
	public static void Dialog(string initFolder = null) {
		new DEnumDir(initFolder).Show();
	}
	
	KTextBoxFile _tFolder;
	ComboBox _cbGet;
	KTextExpressionBox _tFilter;
	KCheckBox _cArray, _cForeach, _cFileFilter, _cDirFilter, _cRecurse, _cIgnore, _cSymlink, _cRelative, _cSkipHidden, _cSkipHiddenSystem, _cWhere, _cOrderBy, _cThenBy, _cSelectPath, _cSelectOther/*, _cNet*/;
	Panel _p1, _p2;
	KSciCodeBox _code;
	
	const string c_Where = ".Where(o => o.EditMe > EditMe)",
		c_OrderBy = ".OrderBy(o => o.EditMe)",
		c_ThenBy = ".ThenBy(o => o.EditMe)",
		c_Select = ".Select(o => o.EditMe)";
	
	DEnumDir(string initFolder = null) {
		InitWinProp("Get files in folder", App.Wmain);
		
		_noeventValueChanged = true;
		var b = new wpfBuilder(this).WinSize(600).Columns(0, 90, 90, -1);
		
		b.R.StartGrid().Columns(76, 76, 0, 0, -1);
		CancellationTokenSource cts = null;
		b.AddButton("Test", async e => {
			if (cts == null) {
				var s = _FormatCode(true);
				print.clear();
				e.Button.Content = "Stop";
				cts = new();
				var r = await TUtil.RunTestCodeAsync(s, cts.Token);
				cts = null;
				if (!IsLoaded) return;
				e.Button.Content = "Test";
				if (r?.isError == true) print.it($"<><b>{r.header}<>\r\n{r.text}");
			} else {
				cts.Cancel();
			}
		});
		Closing += (_, _) => { cts?.Cancel(); };
		b.AddButton("OK", _ => {
			Close();
			var s = _FormatCode();
			InsertCode.Statements(new(s, makeVarName1: true));
		});
		
		b.Add(out _cArray, "Get array").Checked().Tooltip("Store results in an array variable before starting to use them.\nThen it is safe to delete/rename/move/copy the files.\nBut then cannot start using results until all retrieved from the file system.\nCheck if going to delete/rename/move/copy files.\nUncheck if going to search in a potentially large directory.")
			.Add(out _cForeach, "Use foreach").Checked();
		//b.Add(out _cNet, "Use only .NET classes");
		b.End();
		b.R.AddSeparator();
		
		b.R.Add("Folder", out _tFolder, initFolder).Tooltip("Folder path.\nPaste, drop or right-click.").Focus();
		_tFolder.IsFolder = true;
		_tFolder.Unexpand = App.Settings.tools_pathUnexpand;
		
		b.R.Add("Get", out _cbGet).Items("files|folders|all").Margin("R12");
		_cbGet.SelectionChanged += (_, _) => {
			_p1.Visibility = _cbGet.SelectedIndex == 2 ? Visibility.Hidden : Visibility.Visible;
			_p2.Visibility = _cbGet.SelectedIndex == 2 ? Visibility.Visible : Visibility.Hidden;
		};
		
		b.StartGrid().Columns(0, -1, 0);
		_p1 = b.Panel;
		b.Add("Name wildex", out _tFilter).Tooltip("Optional file name wildex.\nExamples:\n*.txt\n**m *.png||*.jpg")
			.xAddControlHelpButton("articles/Wildcard expression", "Wildcard expression help");
		b.End().Span(2);
		
		b.And(0).StartStack();
		_p2 = b.Panel;
		b.Add(out _cFileFilter, "Use file filter").Add(out _cDirFilter, "Use folder filter").Margin("L8");
		b.End().Hidden();
		
		b.R.StartGrid<KGroupBox>("Flags");
		b.R.Add(out _cRecurse, "Include subfolders");
		b.R.Add(out _cIgnore, "Ignore inaccessible").Margin("L22").xBindCheckedVisible(_cRecurse);
		b.R.Add(out _cSymlink, "Follow NTFS links").Margin("L22").xBindCheckedVisible(_cRecurse).Tooltip("Enumerate the target folder of NTFS links (symbolic links, volume mount points, etc)");
		b.R.Add(out _cRelative, "Get relative path").Margin("L22").xBindCheckedVisible(_cRecurse).Tooltip("Store relative path in the Name property");
		b.R.Add(out _cSkipHidden, "Skip hidden");
		b.R.Add(out _cSkipHiddenSystem, "Skip hidden system");
		b.End().Span(3);
		
		b.StartGrid<KGroupBox>("Results");
		b.R.Add(out _cWhere, "Where")
			.Tooltip($"Add code '{c_Where}' to filter results by size, date, etc.\nThen in the code editor you'll edit it.");
		b.R.StartStack();
		b.Add(out _cOrderBy, "OrderBy")
			.Tooltip($"Add code '{c_OrderBy}' to sort results by some property.\nThen in the code editor you'll edit it. You can replace OrderBy with OrderByDescending.");
		b.Add(out _cThenBy, "ThenBy").xBindCheckedVisible(_cOrderBy)
			.Tooltip($"Adds code '{c_ThenBy}' to sort results by another property.\nThen in the code editor you'll edit it. You can replace ThenBy with ThenByDescending, and append more ThenBy/ThenByDescending if need.");
		b.End();
		b.R.StartStack();
		b.Add(out _cSelectPath, "Select path")
			.Tooltip($"Get only paths, not all properties.");
		b.Add(out _cSelectOther, "Select other")
			.Tooltip($"Add code '{c_Select}' to change the type of results.\nFor example select a property or several properties (tuple).\nThen in the code editor you'll edit it.");
		b.End();
		b.End();
		
		b.R.AddSeparator();
		b.Row(150..).xAddInBorder(out _code);
		
		b.End();
		_noeventValueChanged = false;
		
		b.Loaded += () => {
			_FormatCode();
		};
		_tFolder.UnexpandChanged += () => {
			App.Settings.tools_pathUnexpand = _tFolder.Unexpand;
			_FormatCode();
		};
	}
	
	static DEnumDir() {
		TUtil.OnAnyCheckTextBoxValueChanged<DEnumDir>((d, o) => d._AnyCheckTextBoxComboValueChanged(o), comboToo: true);
	}
	
	//when checked/unchecked any checkbox, and when text changed of any textbox or combobox
	void _AnyCheckTextBoxComboValueChanged(object source) {
		if (!_noeventValueChanged) {
			_noeventValueChanged = true;
			if (source == _cSkipHidden && _cSkipHidden.IsChecked) _cSkipHiddenSystem.IsChecked = false;
			if (source == _cSkipHiddenSystem && _cSkipHiddenSystem.IsChecked) _cSkipHidden.IsChecked = false;
			_noeventValueChanged = false;
			
			_FormatCode();
		}
	}
	bool _noeventValueChanged;
	
	string _FormatCode(bool forTest = false, bool onOK = false) {
		int getWhat = _cbGet.SelectedIndex;
		string filter = _tFilter.Text;
		bool hasFilter = getWhat != 2 && !filter.NE();
		
		var b = new StringBuilder();
		b.AppendLine($"var folder = {_tFolder.GetCode()};");
		b.Append("var a = ");
		//if (_cNet.IsChecked) {
		
		//} else {
		b.Append("filesystem.").Append(getWhat switch { 0 => "enumFiles", 1 => "enumDirectories", _ => "enumerate" });
		b.Append("(folder");
		if (hasFilter) b.AppendStringArg(filter);
		bool rec = _cRecurse.IsChecked;
		if (rec || _cSkipHidden.IsChecked || _cSkipHiddenSystem.IsChecked) {
			if (TUtil.FormatFlags(out var s1,
				(rec, FEFlags.AllDescendants),
				(rec && _cIgnore.IsChecked, FEFlags.IgnoreInaccessible),
				(rec && _cSymlink.IsChecked, FEFlags.RecurseNtfsLinks),
				(rec && _cRelative.IsChecked, FEFlags.NeedRelativePaths),
				(_cSkipHidden.IsChecked, FEFlags.SkipHidden),
				(_cSkipHiddenSystem.IsChecked, FEFlags.SkipHiddenSystem)
				)) b.AppendOtherArg(s1, hasFilter ? null : "flags");
		}
		if (getWhat == 2 && !forTest) {
			if (_cFileFilter.IsChecked) b.AppendOtherArg("""f => f.Name.Ends(".example", true)""");
			if (_cDirFilter.IsChecked) b.AppendOtherArg("""d => d.Name.Eqi("Example") ? 0 : 3""");
			//rejected: errorHandler parameter.
		}
		b.Append(')');
		if (!forTest) {
			int len1 = b.Length;
			if (_cWhere.IsChecked) b.Append("\r\n\t").Append(c_Where);
			if (_cOrderBy.IsChecked) { b.Append("\r\n\t").Append(c_OrderBy); if (_cThenBy.IsChecked) b.Append(c_ThenBy); }
			if (_cSelectOther.IsChecked) b.Append("\r\n\t").Append(_cSelectPath.IsChecked ? ".Select(o => (path: o.FullPath, other: o.EditMe))" : c_Select);
			else if (_cSelectPath.IsChecked) b.Append("\r\n\t.Select(o => o.FullPath)");
			if (b.Length > len1) b.Append("\r\n\t");
		}
		//}
		
		b.Append(_cArray.IsChecked && !forTest ? ".ToArray();" : ";");
		if (_cForeach.IsChecked || forTest) {
			b.Append("\r\nforeach ");
			if (!forTest && (_cSelectPath.IsChecked || _cSelectOther.IsChecked)) b.Append("(var f in a) {\r\n\tprint.it(f);");
			else b.Append("(var f in a) {\r\n\tvar path = f.FullPath;\r\n\tprint.it(path);");
			b.Append("\r\n\t");
			if (forTest) b.Append("if (cancel.IsCancellationRequested) break;");
			b.Append("\r\n}");
		}
		
		var R = b.ToString();
		
		if (!(forTest | onOK)) _code.AaSetText(R);
		
		return R;
	}
}


================================================
FILE: Au.Editor/Tools/DIcons.cs
================================================
using System.Security.Authentication;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;
using Au.Controls;

namespace LA;

class DIcons : KDialogWindow {
	public static void ShowSingle(string find = null, bool expandFileIcon = false, bool expandMenuIcon = false) {
		var d = ShowSingle(() => new DIcons(randomizeColors: find == null, expandFileIcon, expandMenuIcon));
		if (find != null) d._tName.Text = find;
	}
	
	enum _Action {
		FileIcon = 1,
		MenuIcon,
		//InsertXamlVar,
		//InsertXamlField,
		CopyName,
		CopyXaml,
		ExportXaml,
		ExportIcon,
		_DebugCopyPng,
	}
	
	List<_Item> _a;
	string _color = "#000000";
	Random _random;
	int _dpi;
	CancellationTokenSource _ctsWindow = new(), _ctsTask;
	KTreeView _tv;
	KTextBox _tName;
	KScintilla _tCustom;
	
	DIcons(bool randomizeColors, bool expandFileIcon, bool expandMenuIcon) {
		InitWinProp("Icons", App.Wmain);
		
		var b = new wpfBuilder(this).WinSize(600, 600);
		b.Columns(-1, 0);
		
		//left - edit control and tree view
		b.Row(-1).StartGrid().Columns(-1, 0);
		b.Add(out _tName).Focus().Tooltip(@"Search.
Part of icon name, or wildcard expression.
Examples: part, Part (match case), start*, *end, **rc regex case-sensitive.
Can be Pack.Icon, like Material.Folder.");
		_tName.PreviewKeyDown += (_, e) => { if (e.Key == Key.Enter) _AiSearch(); };
		
		b.xAddButtonIcon(EdIcons.AiSearch, _ => _AiSearch(), "Use AI to find icons.\nCan search by name or/and image.\nType what you want in the text box or/and copy an icon image (for example in web browser, PNG format). Then click this button.");
		b.Row(-1).xAddInBorder(out _tv);
		_tv.ImageBrush = System.Drawing.Brushes.White;
		b.End();
		
		//right - color picker, buttons, etc
		b.StartGrid().Columns(-1);
		b.Add(out KColorPicker colors).Align(HorizontalAlignment.Left);
		colors.ColorChanged += color => {
			_random = null;
			_color = _ColorToString(color);
			_tv.Redraw();
		};
		b.StartStack();
		
		TextBox randFromTo = null, iconSizes = null;
		
		b.AddButton("Randomize colors", _ => _RandomizeColors());
		b.Add("L %", out randFromTo, "30-70").Width(50);
		b.End();
		b.AddSeparator().Margin("B20");
		
		//rejected: double-clicking an icon clicks the last clicked button. Unclear and not so useful.
		
		b.AlsoAll((b, e) => { if (b.Last is Expander er) er.Header = new TextBlock { Text = er.Header as string, FontWeight = FontWeights.Bold }; });
		
		b.StartGrid<Expander>(out var exp1, "Set file icon").Columns(0, 70, 70, -1);
		b.R.Add("File", out ComboBox cbIconOf).Items("Selected file(s)", "Script files", "Class files", "Folders", "Open folders").Span(2);
		b.R.Add<Label>("Icon");
		b.AddButton(out var bThis, "This", _ => { _SetFileIcon(true); /*lastAction = _Action.FileIcon;*/ }).Disabled();
		b.AddButton("Default", _ => _SetFileIcon(false));
		//b.AddButton("Random", null); //idea: set random icons for multiple selected files. Probably too crazy.
		b.AddButton("Show current", _ => _ShowCurrent()).Margin("L20");
		b.End();
		if (expandFileIcon) exp1.IsExpanded = true;
		
		b.StartGrid<Expander>(out var exp2, "Menu/toolbar/etc icon").Columns(0, 70, 70, -1);
		b.R.Add<Label>("Set icon of: ");
		b.AddButton(out var bMenuItem, "Menu or toolbar item", _ => _InsertCodeOrExport(_Action.MenuIcon)).Span(2).Disabled()
			.Tooltip("To assign the selected icon to a toolbar button or menu item,\nin the code editor click its line (anywhere except action code)\nand then click this button.\n\nIf the 'Customize' window is open, this button sets its Image text.");
		b.R.Add<Label>("Copy text: ");
		b.AddButton(out var bCodeName, "Name", _ => _InsertCodeOrExport(_Action.CopyName)).Span(1).Disabled()
			.Tooltip("Shorter string than XAML.\nCan be used with custom menus and toolbars,\neditor menus and toolbars (edit Commands.xml),\nScriptEditor.GetIcon, IconImageCache, ImageUtil,\noutput tag <image>.");
		b.AddButton(out var bCodeXaml, "XAML", _ => _InsertCodeOrExport(_Action.CopyXaml)).Span(1).Disabled();
		b.End();
		if (expandMenuIcon) exp2.IsExpanded = true;
		
		b.StartGrid<Expander>("Export to current workspace folder").Columns(70, 70, 0, -1);
		b.AddButton(out var bExportXaml, ".xaml", _ => _InsertCodeOrExport(_Action.ExportXaml)).Disabled();
		b.AddButton(out var bExportIco, ".ico", _ => _InsertCodeOrExport(_Action.ExportIcon)).Disabled();
		b.Add("sizes", out iconSizes, "16,20,24,28,32,48,64");
		//#if DEBUG
		//		b.R.AddButton("[debug] Copy PNG", _ => _InsertCodeOrExport(_Action._DebugCopyPng));
		//#endif
		b.End();
		
		b.StartStack<Expander>("Custom icon string", vertical: true);
		b.StartGrid().Columns(30, 30, -1, 24, 40);
		b.AddButton(out var bCustomAppend, "+", _ => {
			if (_tv.SelectedItem is _Item k) _tCustom.aaaAppendText((_tCustom.aaaText is "" or [.., '\n'] ? "" : "\r\n") + _GetSelectedIconString(), true, true);
		}).Tooltip("Append selected icon").Align(y: VerticalAlignment.Bottom).Disabled();
		b.AddButton("?", _ => HelpUtil.AuHelp("Au.More.ImageUtil.LoadWpfImageElement")).Align(y: VerticalAlignment.Bottom);
		b.Skip().Add(out Border customPreview).Size(18, 18).Border().Align(y: VerticalAlignment.Bottom).Add(out Border customPreview2).Size(34, 34).Border().Margin("T-8");
		b.End();
		b.xAddInBorder(out _tCustom); b.Height(60);
		_tCustom.AaHandleCreated += k => {
			k.aaaMarginSetWidth(1, 0, 1);
		};
		_tCustom.AaTextChanged += e => {
			FrameworkElement c = null, c2 = null;
			try {
				if (_GetCustomIconString() is string s) {
					c = ImageUtil.LoadWpfImageElement(s);
					c2 = ImageUtil.LoadWpfImageElement(s);
					c2.Width = c2.Height = 32;
				}
			}
			catch { }
			customPreview.Child = c;
			customPreview2.Child = c2;
			_EnableControls();
		};
		b.End();
		
		b.StartGrid<Expander>("Options");
		
		var darkContrast = b.R.xAddCheckText("High contrast color", App.Settings.dicons_contrastColor, check: App.Settings.dicons_contrastUse);
		b.Tooltip("Append this color, like \"*Pack.Name selectedColor|thisColor\". This color is for high contrast dark theme. Can be #RRGGBB or color name.");
		darkContrast.c.CheckChanged += (_, _) => App.Settings.dicons_contrastUse = darkContrast.c.IsChecked;
		darkContrast.t.TextChanged += (_, _) => {
			var s = darkContrast.t.TextOrNull();
			if (s != null) for (int i = 0; i < 2; i++) { try { System.Windows.Media.ColorConverter.ConvertFromString(s); } catch { s = i == 0 ? "#" + s : null; } }
			App.Settings.dicons_contrastColor = s;
		};
		
		b.R.Add("List background", out ComboBox cBackground).Items("White|Black|Dark|Control").Select(Math.Clamp(App.Settings.dicons_listColor, 0, 3));
		cBackground.SelectionChanged += (o, e) => {
			App.Settings.dicons_listColor = cBackground.SelectedIndex;
			_SetListIconBrush();
			_tv.Redraw();
		};
		_SetListIconBrush();
		void _SetListIconBrush() {
			_tv.ImageBrush = App.Settings.dicons_listColor switch { 0 => System.Drawing.Brushes.White, 1 => System.Drawing.Brushes.Black, 2 => System.Drawing.Brushes.DimGray, _ => System.Drawing.SystemBrushes.Control }; ;
		}
		
		b.R.Add("List image size", out KTextBox tIconSize, "16");
		tIconSize.TextChanged += (_, _) => {
			int k = tIconSize.Text.ToInt();
			if (k < 7 || k > 256) return;
			_tv.ImageSize = k;
		};
		
		b.End();
		
		b.Row(-1);
		b.R.xAddDialogHelpButtonAndF1("editor/Icons").Align("R");
		b.End();
		
		b.End();
		
		b.Loaded += () => {
			_dpi = Dpi.OfWindow(this);
			_OpenDB();
			
			_a = new(60000);
			foreach (var (table, _) in s_tables) {
				using var stat = s_db.Statement("SELECT name FROM " + table);
				while (stat.Step()) {
					var k = new _Item(this, table, stat.GetText(0));
					_a.Add(k);
				}
			}
			_a.Sort((a, b) => string.Compare(a._name, b._name, StringComparison.OrdinalIgnoreCase));
			if (randomizeColors) _RandomizeColors();
			_tv.SetItems(_a);
		};
		
		_tName.TextChanged += (_, _) => {
			string name = _tName.Text, table = null;
			Func<_Item, bool> f = null;
			bool select = false;
			if (!name.NE()) {
				if (select = IconString_.Parse(name, out var x)) {
					table = x.pack;
					name = x.name;
					f = o => o._name == name && o._table == table;
					colors.Color = x.color is ['#', ..] ? x.color[1..].ToInt(0, STIFlags.IsHexWithout0x) : 0;
				} else {
					if (name.RxMatch(@"^(\w+)\.(.+)", out var m)) (table, name) = (m[1].Value, m[2].Value);
					wildex wild = null;
					StringComparison comp = StringComparison.OrdinalIgnoreCase;
					bool matchCase = name.RxIsMatch("[A-Z]");
					if (wildex.hasWildcardChars(name)) {
						try { wild = new wildex(name, matchCase && !name.Starts("**")); }
						catch { name = null; }
					} else if (matchCase) comp = StringComparison.Ordinal;
					
					if (name != null) f = o => (table == null || o._table.Eqi(table)) && (wild?.Match(o._name) ?? o._name.Contains(name, comp));
				}
			}
			var e = f == null ? _a : _a.Where(f);
			_tv.SetItems(e);
			if (select && (select = e.Count() == 1)) _tv.Select(0);
			_EnableControls();
		};
		
		_tv.SelectedSingle += (o, i) => _EnableControls();
		
		b.WinSaved(App.Settings.wndpos.icons, o => App.Settings.wndpos.icons = o);
		
		void _EnableControls() {
			bool enable = _UseCustom ? customPreview.Child != null : _tv.SelectedIndex >= 0;
			bThis.IsEnabled = enable;
			bMenuItem.IsEnabled = enable;
			//bCodeVar.IsEnabled = enable;
			//bCodeField.IsEnabled = enable;
			bCodeXaml.IsEnabled = enable;
			bCodeName.IsEnabled = enable;
			bExportXaml.IsEnabled = enable;
			bExportIco.IsEnabled = enable;
			bCustomAppend.IsEnabled = _tv.SelectedIndex >= 0;
		}
		
		void _SetFileIcon(bool set) {
			string icon = set ? _GetSelectedOrCustomIconString() : null;
			int si = cbIconOf.SelectedIndex;
			if (si == 0) {
				foreach (var v in FilesModel.TreeControl.SelectedItems) v.CustomIconName = icon;
			} else {
				switch (si) {
				case 1: App.Settings.icons.ft_script = icon; break;
				case 2: App.Settings.icons.ft_class = icon; break;
				case 3: App.Settings.icons.ft_folder = icon; break;
				case 4: App.Settings.icons.ft_folderOpen = icon; break;
				}
				FilesModel.Redraw();
			}
		}
		
		void _ShowCurrent() {
			_tName.Text = cbIconOf.SelectedIndex switch {
				1 => App.Settings.icons.ft_script,
				2 => App.Settings.icons.ft_class,
				3 => App.Settings.icons.ft_folder,
				4 => App.Settings.icons.ft_folderOpen,
				_ => FilesModel.TreeControl.SelectedItems.FirstOrDefault()?.CustomIconName
			};
		}
		
		void _InsertCodeOrExport(_Action what) {
			//lastAction = what;
			bool useCustom = _UseCustom;
			var k = useCustom ? null : _tv.SelectedItem as _Item;
			if (k == null && !useCustom) return;
			//string code = null;
			if (what == _Action.MenuIcon) {
				if (_GetSelectedOrCustomIconString() is string s) {
					if (DCustomize.AaSetImage(s)) return;
					InsertCode.SetMenuToolbarItemIcon(s);
				}
			} else if (what == _Action.CopyName) {
				if (_GetSelectedOrCustomIconString() is string s) {
					clipboard.text = s;
				}
			} else {
				string xaml;
				if (useCustom) {
					if (!_GetIconFromDB(_GetCustomIconString(), out xaml)) return;
				} else {
					if (!_GetIconViewboxXamlFromDB(out xaml, k._table, k._name, _ItemColor(k))) return;
				}
				xaml = xaml.Replace('"', '\'').RxReplace(@"\R\s*", "");
				switch (what) {
				//case _Action.InsertXamlVar: code = $"string icon{k._name} = \"{xaml}\";"; break;
				//case _Action.InsertXamlField: code = $"public const string {k._name} = \"{xaml}\";"; break;
				case _Action.CopyXaml: clipboard.text = xaml; break;
				case _Action.ExportXaml: _Export(false); break;
				case _Action.ExportIcon: _Export(true); break;
				case _Action._DebugCopyPng: _DebugCopyPng(); break;
				}
				
				void _Export(bool ico) {
					var folder = App.Model.CurrentFile?.Parent ?? App.Model.Root;
					string name = useCustom && IconString_.Parse(_GetCustomIconString(), out var ics) ? ics.name : k?._name ?? "name";
					var path = $"{folder.FilePath}\\{name}{(ico ? ".ico" : ".xaml")}";
					if (ico) {
						var sizes = iconSizes.Text.Split_(',').Select(o => o.ToInt()).ToArray();
						var e = ImageUtil.LoadWpfImageElement(xaml);
						ImageUtil.ConvertWpfImageElementToIcon_(path, e, sizes);
					} else {
						filesystem.saveText(path, xaml);
					}
					var fn = App.Model.ImportFileFromWorkspaceDir(path, new(folder, folder.Parent == null ? FNInsert.First : FNInsert.Last));
					if (fn == null) print.it("failed");
					else print.it($"<>Exported to <open>{fn.ItemPath}<>");
				}
				
				void _DebugCopyPng() { //note: this is only for debug. Ignores DPI.
					int size = _tv.ImageSize;
					var path = xaml.RxReplace(@"^.+?(<Path.+)</Viewbox>", "$1");
					var conv = AI.XamlIconConverter_.GetConverter(path);
					var png = conv.ToPng(size, 96, System.Windows.Media.Brushes.White);
					new clipboardData().AddBinary(png, ClipFormats.Png).SetClipboard();
				}
			}
			
			//if (code != null) {
			//	if (what is _Action.CopyName or _Action.CopyXaml) clipboard.text = code;
			//	else if (what is _Action.InsertXamlVar or _Action.InsertXamlField) InsertCode.Statements(code);
			//	else InsertCode.TextSimply(code);
			//}
		}
		
		void _RandomizeColors() {
			_random = new();
			//perf.first();
			//if (keys.isScrollLock) { //generate random HLS. Colors look not as good, maybe because the green-yellow range is too narrow and red-purple range too wide.
			//	foreach (var v in _a) {
			//		int L = _random.Next(40, 200);
			//		double k = _random.NextDouble() * 15d; int S = 240 - (int)(k * k); //print.it(S); //generate less low-saturation colors
			//		if (S < 60 && L > 60) S += 60; //avoid light-gray, because looks like disabled
			//		v._color = ColorInt.FromHLS(_random.Next(0, 240), L, S, false);
			//	}
			//} else {
			int iFrom = 0, iTo = 100; if (randFromTo.Text.RxMatch(@"^(\d+) *- *(\d+)", out var m)) { iFrom = m[1].Value.ToInt(); iTo = m[2].Value.ToInt(); }
			float briFrom = Math.Clamp(iFrom / 100f, 0f, 0.9f), briTo = Math.Clamp(iTo / 100f, briFrom + 0.05f, 1f);
			int middleL = ((briTo + briFrom) * 120f).ToInt();
			foreach (var v in _a) {
				int c = _random.Next(0, 0xffffff);
				var (H, L, S) = ColorInt.ToHLS(c, false);
				if (S < 60 && L > 60) c = ColorInt.FromHLS(H, L, S += 60, false); //avoid light-gray, because looks like disabled
				var bri = ColorInt.GetPerceivedBrightness(c, false);
				if (bri < briFrom || bri > briTo) c = ColorInt.FromHLS(H, middleL, S, false);
				v._color = c;
			}
			//}
			//perf.nw(); //4 ms
			_tv.Redraw();
		}
		
		string _GetSelectedOrCustomIconString() {
			if (_GetCustomIconString() is string s) {
				if (null == IconString_.ParseAll(s)) { dialog.show(null, "Invalid icon string.", owner: this); return null; }
				return s;
			}
			return _GetSelectedIconString();
		}
		
		string _GetSelectedIconString() {
			if (_tv.SelectedItem is not _Item k) return null;
			var s = $"*{k._table}.{k._name} {_ItemColor(k)}";
			if (App.Settings.dicons_contrastUse && !App.Settings.dicons_contrastColor.NE()) s = s + "|" + App.Settings.dicons_contrastColor;
			return s;
		}
		
		string _GetCustomIconString() => _UseCustom ? _tCustom.aaaText.RxReplace(@";?\R", "; ").TrimEnd("; ") : null;
	}
	
	static string _ColorToString(int c) => "#" + c.ToS("X6");
	
	string _ItemColor(_Item k) => _random == null ? _color : _ColorToString(k._color);
	
	bool _UseCustom => !_tCustom.AaWnd.Is0 && _tCustom.aaaLen8 > 0;
	
	async void _AiSearch() {
		string query = _tName.Text;
		byte[] png = _GetPngFromClipboard();
		
		if (query.NE() && png == null) {
			dialog.show("How to use AI to find icons", "Can search by icon name or/and image. Type what you want in the text box or/and copy an icon image (for example in web browser, PNG format). Then click the AI search button.\n\nAI embedding model: voyage-multimodal-3.", owner: this);
			return;
		}
		
		if (!query.NE() && png != null) {
			switch (popupMenu.showSimple("1 Text|2 Image (clipboard)|3 Text and image||0 Cancel", owner: this)) {
			case 1: png = null; break;
			case 2: query = null; break;
			case 3: break;
			default: return;
			}
		}
		
		static byte[] _GetPngFromClipboard() {
			byte[] png;
			if (clipboardData.getBinary(ClipFormats.Png) is { } b) png = b;
			else if (clipboardData.getFiles() is { Length: 1 } a && a[0].Ends(".png", true)) png = filesystem.loadBytes(a[0]);
			else return null;
			
			//remove alpha. The Voyage model does not support it.
			using var msIn = new MemoryStream(png);
			using var src = new System.Drawing.Bitmap(msIn);
			using var dst = new System.Drawing.Bitmap(src.Width, src.Height, System.Drawing.Imaging.PixelFormat.Format24bppRgb);
			using (var g = System.Drawing.Graphics.FromImage(dst)) {
				g.Clear(System.Drawing.Color.White);
				g.DrawImage(src, 0, 0, src.Width, src.Height);
			}
			using var msOut = new MemoryStream();
			dst.Save(msOut, System.Drawing.Imaging.ImageFormat.Png);
			return msOut.ToArray();
		}
		
		AI.AiModel.ApiKeys = App.Settings.ai_ak;
		
		var emModel = new AI.ModelVoyageEmbedM();
		//var emModel = AI.AiModel.Models.OfType<AI.AiEmbeddingModel>().First(o => o.isMultimodal /*&& o.DisplayName == App.Settings.ai_modelIconSearch*/);
		//if (emModel == null) {
		//	_AiSettingsError($"Please go to Options > AI and select model for icon search.");
		//	return;
		//}
		
		this.IsEnabled = false;
		try {
			_ctsTask?.Cancel();
			_ctsTask?.Dispose();
			_ctsTask = CancellationTokenSource.CreateLinkedTokenSource(_ctsWindow.Token);
			var cancel = _ctsTask.Token;
			
			var em = new AI.Embeddings(emModel);
			var ems = await Task.Run(() => em.GetIconsEmbeddings(true, cancel));
			
			var r1 = _tName.RectInScreen();
			using var osd = osdText.showText("Searching.\nClick to cancel.", -1, new(r1.right, r1.bottom), showMode: OsdMode.ThisThread);
			osd.Clicked += (_, _) => { _ctsTask?.Cancel(); };
			
			AI.EmInput input = new(png == null ? [query] : query.NE() ? [png] : [query, png]);
			var queryVector = await Task.Run(() => em.CreateEmbedding(input, cancel));
			var a = em.GetTopMatches(queryVector, ems, take: 300).Select(o => new _Item(this, o.f.name)).ToArray();
			_tv.SetItems(a);
		}
		catch (OperationCanceledException etc) { if (etc.InnerException is TimeoutException) print.it(etc.Message); }
		catch (InvalidCredentialException) {
			var api = emModel.api;
			_AiSettingsError($"Please go to Options > AI and set the API key for {api}.\nYou can create an API key in your account on the {api} website.");
		}
		catch (Exception e1) { print.it(e1); }
		finally {
			this.IsEnabled = true;
			_ = Task.Delay(500).ContinueWith(t => { GC.Collect(); 1.s(); GC.Collect(); });
		}
		
		void _AiSettingsError(string text) {
			if (!dialog.showOkCancel("AI search error", text, owner: this)) return;
			DOptions.AaShow(DOptions.EPage.AI);
		}
	}
	
	protected override void OnClosed(EventArgs e) {
		_ctsWindow.Cancel();
		_ctsWindow.Dispose();
		_ctsTask?.Dispose();
		base.OnClosed(e);
	}
	
	protected override void OnDpiChanged(DpiScale oldDpi, DpiScale newDpi) {
		_dpi = newDpi.PixelsPerInchX.ToInt();
		base.OnDpiChanged(oldDpi, newDpi);
	}
	
	class _Item : ITreeViewItem {
		DIcons _dialog;
		public string _table, _name;
		public int _color;
		
		public _Item(DIcons dialog, string table, string name) {
			_dialog = dialog;
			_table = table; _name = name;
		}
		
		public _Item(DIcons dialog, string tableDotName) {
			_dialog = dialog;
			int i = tableDotName.IndexOf('.');
			_table = tableDotName[..i]; _name = tableDotName[++i..];
		}
		
		//string ITreeViewItem.DisplayText => s_dialog._withCollection ? (_name + new string(' ', Math.Max(8, 40 - _name.Length * 2)) + "(" + _table + ")") : _name;
		string ITreeViewItem.DisplayText => _name + new string(' ', Math.Max(8, 40 - _name.Length * 2)) + "(" + _table + ")";
		
		object ITreeViewItem.Image {
			//note: don't store UIElement or Bitmap. They can use hundreds MB of memory and it does not make faster/better. Let GC dispose unused objects asap.
			get {
				try {
					//using var p1 = perf.local();
					if (_GetIconViewboxXamlFromDB(out string xaml, _table, _name, _dialog._ItemColor(this))) {
						//p1.Next('d');
						int size = _dialog._tv.ImageSize;
						return ImageUtil.LoadGdipBitmapFromXaml(xaml, _dialog._dpi, (size, size));
					}
				}
				catch (Exception ex) { Debug_.Print(ex); }
				return null;
			}
		}
	}
	
	static sqlite s_db;
	static Dictionary<string, string> s_tables; //table->template, ~30 tables
	
	/// <summary>
	/// Returns true if <i>s</i> starts with "*pack.name" (possibly with library) and the pack exists.
	/// Fast, does not use the database (may use only the first time).
	/// </summary>
	public static bool PossiblyIconName(RStr s) {
		if (!IconString_.Detect(s, out var d)) return false;
		_OpenDB();
		return s_tables.ContainsKey(s[d.pack.Range].ToString());
	}
	
	static void _OpenDB() {
		if (s_db == null) {
			var db = s_db = new sqlite(folders.ThisAppBS + "icons.db", SLFlags.SQLITE_OPEN_READONLY);
			process.thisProcessExit += _ => db.Dispose();
			s_tables = new(StringComparer.OrdinalIgnoreCase);
			using var st = s_db.Statement("SELECT * FROM _tables");
			while (st.Step()) {
				//print.it($"--- {st.GetText(0)}\r\n{st.GetText(1)}");
				s_tables.Add(st.GetText(0), st.GetText(1));
			}
		}
	}
	
	/// <exception cref="Exception">Failed to open database.</exception>
	static bool _GetIconPathXamlFromDB(out string xaml, string table, string name, string color, bool setColor = true) {
		xaml = null;
		_OpenDB();
		if (!s_tables.TryGetValue(table, out var templ)) return false;
		if (!s_db.Get(out string data, $"SELECT data FROM {table} WHERE name='{name}'")) return false;
		//the SELECT is the slowest part. With prepared statement just slightly faster.
		
		templ = s_rxColor.Replace(templ, setColor ? IconString_.NormalizeColor(color) : null, 1);
		
		int i = templ.Find(" Data=\"{x:Null}\"");
		xaml = templ.ReplaceAt(i + 7, 8, data);
		
		if (xaml.Contains("\"{")) return false;
		return true;
		
		//Gets data directly from the big DB. Slightly slower than with a small DB file for used icons, but simpler.
		//Maybe not good to use an 18 MB DB directly, but I didn't notice something bad.
		//An alternative version could store XAML of used icons in a small DB file. When missing, gets from the big DB and copies to the small.
		//	Faster 2 times (when the small DB is WAL). But both versions much faster than converting XAML to GDI+ bitmap. Same memory usage.
		//note: the big DB must have PRIMARY KEY. Don't need it with other version.
	}
	static regexp s_rxColor = new(@"(?:Fill|Stroke)=""\K[^""]*");
	
	/// <exception cref="Exception">Failed to open database.</exception>
	static bool _GetIconViewboxXamlFromDB(out string xaml, string table, string name, string color, bool setColor = true) {
		if (!_GetIconPathXamlFromDB(out xaml, table, name, color, setColor)) return false;
		xaml = $"{c_viewbox}{xaml}</Viewbox>";
		return true;
	}
	
	const string c_viewbox = "<Viewbox Width='16' Height='16' xmlns='http://schemas.microsoft.com/winfx/2006/xaml/presentation'>";
	
	/// <exception cref="Exception">Failed to open database.</exception>
	static bool _GetIconFromDB(string icon, out string xaml, bool forResource = false) {
		xaml = null;
		if (IconString_.ParseAll(icon) is not { } a) return false;
		
		bool simple = false;
		if (a.Length == 1) {
			ref IconString_ r = ref a[0];
			simple = !(r.HasSize || r.HasMargin);
			if (!_GetIconViewboxXamlFromDB(out xaml, r.pack, r.name, r.color, simple && !forResource)) return false;
		} else {
			var b = new StringBuilder(c_viewbox).AppendLine("<Grid>");
			for (int i = 0; i < a.Length; i++) {
				ref IconString_ r = ref a[i];
				if (!_GetIconPathXamlFromDB(out xaml, r.pack, r.name, null, false)) return false;
				b.AppendLine(xaml);
			}
			xaml = b.Append("</Grid></Viewbox>").ToString();
		}
		
		bool ok = simple || forResource || IconString_.XamlSetColorSizeMargin(ref xaml, a);
		
		//print.qm2.write($"\r\n---- {icon}\r\n{xaml}");
		
		return ok;
	}
	
	/// <param name="icon">
	/// Icon name, like <c>"*Pack.Icon color"</c>, where color is like <c>#RRGGBB</c> or color name.
	/// Full supported format: <c>"[*&lt;library&gt;]*pack.name[ color][ @size][ %margin][;more icons]"</c>.
	/// If no color, sets black.
	/// </param>
	/// <returns>false if <i>icon</i> is null or invalid format or the icon does not exist.</returns>
	public static bool TryGetIconFromDB(string icon, out string xaml, bool forResource = false) {
		//using var p1 = perf.local();
		try { if (_GetIconFromDB(icon, out xaml, forResource)) return true; }
		catch (Exception e1) { Debug_.Print(e1); }
		xaml = null;
		return false;
	}
	
	public static string GetIconString(string s, EGetIcon what) {
		if (what != EGetIcon.IconNameToXaml) {
			s = App.Model.Find(s, silent: true)?.Image switch {
				string v => v,
				IEnumerable<object> v => v.First() as string,
				_ => null
			};
		}
		if (what != EGetIcon.PathToIconName && s != null) TryGetIconFromDB(s, out s);
		return s;
	}
}


================================================
FILE: Au.Editor/Tools/DInputRecorder.cs
================================================
using System.ComponentModel;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Controls.Primitives;
using System.Windows.Media;
using Au.Controls;
using System.Windows.Threading;

//FUTURE: record "wait for UAC consent and then for normal desktop".

using ToolLand;

namespace LA;

class DInputRecorder : KDialogWindow {
	public static void ShowRecorder() {
		if (s_showing) return;
		
		int t = WindowsHook.LowLevelHooksTimeout;
		if (t < 300) { //default 300, max 1000
			print.it($"Warning: incorrect Windows settings. The keyboard/mouse hook timeout is {t} ms. Should be 1000. Set it in Options -> OS, and restart computer. Now recording and triggers are unreliable.");
		}
		
		var ir = new DInputRecorder();
#if SCRIPT
		ir.ShowDialog();
#else
		ir.Show();
#endif
	}
	static bool s_showing;
	
	wnd _wThis, _wFore;
	bool _recordKeys, _recordText, _recordText2, _recordMouse, _recordWheel, _recordDrag, _recordMove;
	int _xyIn;
	ListBox _list;
	ScrollViewer _scroller;
	TextBox _tSpeed;
	
	const string c_iconPause = "*Material.PauseCircleOutline" + EdIcons.blue,
		c_iconRetry = "*BoxIcons.RegularReset" + EdIcons.red,
		c_iconUndo = EdIcons.Undo;
	
	const int c_xyControl = 1, c_xyScreen = 2;
	
	DInputRecorder() {
		Title = "Input recorder";
		var b = new wpfBuilder(this).WinSize((300, 200..400), (284, 270..)).Columns(80, -1);
		b.WinProperties(WindowStartupLocation.Manual, showActivated: false, showInTaskbar: false, topmost: true, style: WindowStyle.ToolWindow);
		b.Window.SizeToContent = 0;
		
		b.Row(-1).StartGrid().Columns(-1);
		b.Options(margin: new(1));
		b.Add(out KCheckBox cKeys, "Keys").Tooltip("Record keyboard");
		b.Add(out KCheckBox cText, "Text").Margin("L8").Tooltip("Record text keys as text, not as key names");
		b.Add(out KCheckBox cText2, "Text+").Margin("L16").Tooltip("Record Alt+Ctrl+key as text if possible");
		b.Add(out KCheckBox cMouse, "Mouse").Tooltip("Record mouse clicks and optionally wheel and movements");
		b.Add(out KCheckBox cWheel, "Wheel").Margin("L8").Tooltip("Record mouse wheel");
		b.Add(out KCheckBox cDrag, "Drag").Margin("L8").Tooltip("Record mouse movements while a button is pressed");
		b.Add(out KCheckBox cMove, "Move").Margin("L8").Tooltip("Record mouse movements while buttons aren't pressed");
		b.Add(out ComboBox cbIn).Items("Window|Control|Screen").Tooltip("Mouse position relative to").Margin("2");
		cbIn.SelectionChanged += (_, _) => { _xyIn = cbIn.SelectedIndex; };
		cbIn.SelectedIndex = Math.Clamp(App.Settings.recorder.xyIn, 0, 2);
		b.Add<Label>("Speed").And(34).Add(out _tSpeed, App.Settings.recorder.speed).Tooltip("If not empty, adds code that sets mouse/keys/text speed = this value");
		b.Options(margin: new(2));
		
		cKeys.CheckChanged += (_, _) => {
			_recordKeys = cKeys.IsChecked;
			_recordText = _recordKeys ? cText.IsChecked : false;
			cText.IsEnabled = _recordKeys;
			_recordText2 = _recordKeys && _recordText ? cText2.IsChecked : false;
			cText2.IsEnabled = _recordKeys && _recordText;
		};
		cText.CheckChanged += (_, _) => {
			_recordText = _recordKeys && cText.IsChecked;
			cText2.IsEnabled = _recordKeys && _recordText;
		};
		cText2.CheckChanged += (_, _) => { _recordText2 = _recordKeys && _recordText && cText2.IsChecked; };
		cMouse.CheckChanged += (_, _) => {
			_recordMouse = cMouse.IsChecked;
			_recordWheel = _recordMouse ? cWheel.IsChecked : false;
			_recordDrag = _recordMouse ? cDrag.IsChecked : false;
			_recordMove = _recordMouse ? cMove.IsChecked : false;
			cWheel.IsEnabled = _recordMouse;
			cDrag.IsEnabled = _recordMouse;
			cMove.IsEnabled = _recordMouse;
		};
		cWheel.CheckChanged += (_, _) => { _recordWheel = _recordMouse && cWheel.IsChecked; };
		cDrag.CheckChanged += (_, _) => { _recordDrag = _recordMouse && cDrag.IsChecked; };
		cMove.CheckChanged += (_, _) => { _recordMove = _recordMouse && cMove.IsChecked; };
		
		if (App.Settings.recorder.keys) cKeys.IsChecked = true; else { cText.IsEnabled = false; cText2.IsEnabled = false; }
		if (App.Settings.recorder.text) cText.IsChecked = true; else cText2.IsEnabled = false;
		if (App.Settings.recorder.text2) cText2.IsChecked = true;
		if (App.Settings.recorder.mouse) cMouse.IsChecked = true; else { cWheel.IsEnabled = false; cDrag.IsEnabled = false; cMove.IsEnabled = false; }
		if (App.Settings.recorder.wheel) cWheel.IsChecked = true;
		if (App.Settings.recorder.drag) cDrag.IsChecked = true;
		if (App.Settings.recorder.move) cMove.IsChecked = true;
		this.Closing += (_, _) => {
			App.Settings.recorder.keys = cKeys.IsChecked;
			App.Settings.recorder.text = cText.IsChecked;
			App.Settings.recorder.text2 = cText2.IsChecked;
			App.Settings.recorder.mouse = cMouse.IsChecked;
			App.Settings.recorder.wheel = cWheel.IsChecked;
			App.Settings.recorder.drag = cDrag.IsChecked;
			App.Settings.recorder.move = cMove.IsChecked;
			App.Settings.recorder.xyIn = _xyIn;
			App.Settings.recorder.speed = _tSpeed.Text;
		};
		
		b.Row(-1).StartStack();
		b.xAddCheckIcon(out _, c_iconPause, "Pause recording", checkChanged: _Pause);
		b.xAddButtonIcon(c_iconRetry, _ => _Clear(), "Clear the recorded data");
		b.xAddButtonIcon(c_iconUndo, _ => _Undo(), "Remove the last recorded event, or restore cleared data");
		b.End();
		
		b.AddButton(out var bOK, "OK", _ => _OK(false)).Tooltip("Insert the code and close.\nRight-click to copy to the clipboard.");
		bOK.MouseRightButtonUp += (_, _) => _OK(true);
		//b.AddButton("Copy", _=>_OK(true)).Tooltip("Copy the code to the clipboard.\nStops recording and closes this window.");
		//b.AddButton("Cancel", _=>Close()); //can instead use x or Copy
		
		b.End();
		
		b.Add(out _list).Margin(5, 2, 2, 2);
		
		b.End();
		
		b.WinSaved(App.Settings.wndpos.recorder, o => App.Settings.wndpos.recorder = o);
	}
	
	static DInputRecorder() {
		//JIT some code that is called in hook proc
		var w = App.Hmain;
		var r1 = new _RecoWinFind { w = w, varName = 1, waitS = 1 };
		r1.FormatCode();
		var r2 = new _RecoWinChild { w = w.Get.FirstChild, varName = 1, windowVarName = 1 };
		r2.FormatCode(w);
		//print.it(r1.code); print.it(r2.code);
	}
	
	protected override void OnSourceInitialized(EventArgs e) {
		base.OnSourceInitialized(e);
		
		_wThis = this.Hwnd();
		_scroller = _list.FindVisualDescendant(o => o is ScrollViewer) as ScrollViewer;
		//_wThis.MoveInScreen(^1, ^1);
		s_showing = true;
		App.Hmain.ShowMinimized();
		
		Dispatcher.InvokeAsync(() => { //set hooks when fully loaded
			if (_closed) return;
			_keyHook = WindowsHook.Keyboard(_KeyHook);
			_mouseHook = WindowsHook.Mouse(_MouseHook);
			//_weHook=new WinEventHook(new EEvent[] { EEvent.OBJECT_SHOW, EEvent.OBJECT_HIDE }, _WeHook, flags: EHookFlags.SKIPOWNTHREAD);
		}, DispatcherPriority.ApplicationIdle);
	}
	
	protected override void OnClosed(EventArgs e) {
		base.OnClosed(e);
		
		_closed = true;
		_keyHook.Dispose();
		_mouseHook.Dispose();
		//_weHook.Dispose();
		s_showing = false;
		App.Hmain.ShowNotMinimized(); //BAD: flickers. With animation not so bad.
		App.Hmain.ActivateL();
	}
	bool _closed;
	
	protected override void OnActivated(EventArgs e) {
		if (wnd.active == _wThis) {
			if (_Last is _RecoMouseMoveBy) _Remove(^1);
		}
		base.OnActivated(e);
	}
	
	enum _Event { Key, MButton, MMove }
	
	abstract record _Reco {
		public wnd w;
		public int time;
	}
	
	record _RecoKey : _Reco {
		public KKey key;
		public KMod mod;
		public sbyte down; //1 down, -1 up, 0 down+up
		public int count;
		
		public override string ToString() {
			using (new StringBuilder_(out var b)) {
				keys.more.hotkeyToString(b, mod, key);
				if (down > 0) b.Append("*down"); else if (down < 0) b.Append("*up");
				if (count > 1) b.Append('*').Append(count);
				return b.ToString();
			}
		}
	}
	
	record _RecoChar : _Reco {
		public char c;
		public bool alt;
		public int count;
		public string s;
		
		public override string ToString() => (alt ? "Alt+" : null) + (s ?? c.ToString()) + (count > 1 ? ("*" + count) : null);
		
		public void FormatCode(StringBuilder b, bool first) {
			if (alt) {
				if (!first) b.Append("\", \"");
				b.Append("Alt+").Append(count > 1 ? '_' : '^');
			} else {
				if (first) b.Append(count > 1 ? '_' : '^');
				else if (count > 1) b.Append("\", \"_");
			}
			FormatCodeSimple(b);
		}
		
		public void FormatCodeSimple(StringBuilder b) {
			if (s != null) b.Append(s.Escape());
			else {
				if (c is '"' or '\\') b.Append('\\');
				b.Append(c);
				if (count > 1) b.Append('*').Append(count);
			}
		}
	}
	
	record _RecoMouse : _Reco //mouse.move() and base of _RecoMouseX
	{
		public POINT p, pw; //in screen and in window
		public int varName; //0 if in screen, >0 if in window (_RecoWinFind with this varName), <0 if in control (_RecoWinChild with minus this varName)
		
		protected string _VarName => varName == 0 ? null : (varName > 0 ? (" in w" + varName) : (" in c" + -varName));
		
		public override string ToString() => "Mouse move" + _VarName;
		
		public virtual void FormatCode(StringBuilder b) {
			b.Append("mouse.move(");
			_FormatMoveArgs(b);
			b.Append(");");
		}
		
		protected void _FormatMoveArgs(StringBuilder b) {
			if (varName != 0) {
				b.AppendFormat("{0}{1}, {2}, {3}", varName > 0 ? 'w' : 'c', Math.Abs(varName), pw.x, pw.y);
			} else {
				b.AppendFormat("{0}, {1}", p.x, p.y);
			}
		}
	}
	
	record _RecoMouseButton : _RecoMouse {
		public MButton button;
		public sbyte down; //1 down, -1 up, 0 down+up
		public bool two, noXY, activated;
		public string image, comment;
		
		public override string ToString() => $"Mouse {button.ToString().Lower()}{(down switch { 1 => " down", -1 => " up", _ => null })}{(two ? "*2" : null)}{_VarName}"; //not useful:, {p.x}, {p.y}
		
		public override void FormatCode(StringBuilder b) {
			b.Append("mouse.");
			bool ex = false; if (two) ex = button != MButton.Left; else ex = button is not (MButton.Left or MButton.Right);
			string s;
			if (ex) s = "clickEx";
			else if (two) s = "doubleClick";
			else if (down > 0) s = button == MButton.Left ? "leftDown" : "rightDown";
			else if (down < 0) s = button == MButton.Left ? "leftUp" : "rightUp";
			else s = button == MButton.Left ? "click" : "rightClick";
			b.Append(s).Append('(');
			if (ex) {
				b.Append("MButton.").Append(button);
				if (two) b.Append(" | MButton.DoubleClick"); else if (down > 0) b.Append(" | MButton.Down"); else if (down < 0) b.Append(" | MButton.Up");
				if (!noXY) b.Append(", ");
			}
			if (!noXY) _FormatMoveArgs(b);
			b.Append(");");
		}
		
		public void FormatDrag(StringBuilder b, object dxy/*, KMod mod*/) {
			b.Append("mouse.drag(");
			_FormatMoveArgs(b);
			switch (dxy) {
			case (int dx, int dy): b.AppendFormat(", {0}, {1}", dx, dy); break;
			case string s: b.AppendFormat(", \"{0}\"", s); break;
			}
			if (button != MButton.Left) b.Append(", MButton.").Append(button);
			//never mind: could also format modifier keys, but it's quite difficult, eg can be pressed before or/and after the mouse button.
			b.Append(");");
		}
	}
	
	record _RecoMouseWheel : _RecoMouse {
		public int ticks;
		public bool move;
		
		public override string ToString() => move && varName != 0 ? $"Mouse wheel {_TicksToS}{_VarName}" : $"Mouse wheel {_TicksToS}";
		
		string _TicksToS => (ticks / 120d).ToS();
		
		public override void FormatCode(StringBuilder b) {
			if (move) { base.FormatCode(b); b.AppendLine(); }
			b.AppendFormat("mouse.wheel({0});", _TicksToS);
		}
	}
	
	record _RecoMouseMoveBy : _RecoMouse {
		//p - the last move coord
		//a - all relative coords
		public List<uint> a;
		public bool drag;
		string _ostring;
		
		public override string ToString() => "Mouse " + (drag ? "drag" : "move");
		
		public string OffsetsString => _ostring ??= _GetOString();
		
		string _GetOString() {
			//remove some points to make shorter and faster
			//in n1=a.Count;
			double prevAngle = 400, dist = 0;
			for (int i = a.Count - 1; --i > 0;) {
				int dx = Math2.LoShort((nint)a[i]), dy = Math2.HiShort((nint)a[i]);
				double angle = Math2.AngleFromXY(dx, dy);
				dist += Math.Sqrt(dx * dx + dy * dy);
				//print.it(dx, dy, angle, dist);
				if (angle == prevAngle && dist < 30) {
					a.RemoveAt(i);
					int dx2 = Math2.LoShort((nint)a[i]), dy2 = Math2.HiShort((nint)a[i]);
					a[i] = (uint)Math2.MakeLparam(dx2 + dx, dy2 + dy);
				} else {
					prevAngle = angle;
					dist = 0;
				}
			}
			//print.it(n1, a.Count);
			return RecordingUtil.MouseToString(a, withSleepTimes: false);
		}
		
		public override void FormatCode(StringBuilder b) {
			b.AppendFormat("mouse.moveBy(\"{0}\");", OffsetsString);
		}
	}
	
	record _RecoWin : _Reco { //wnd.Activate, wnd.WaitForName, base of _RecoWinFind
		public int varName;
		public int waitS;
		public bool activate;
		public string code;
		
		public override string ToString() {
			using (new StringBuilder_(out var b)) {
				b.AppendFormat("wnd w{0}: ", varName);
				if (waitS != 0) {
					b.Append("new name");
					if (activate) b.Append(", activate");
				} else {
					b.Append("activate");
				}
				return b.ToString();
			}
		}
		
		public void FormatCode(string name = null) {
			using (new StringBuilder_(out var b)) {
				if (waitS != 0) {
					b.AppendFormat("w{0}.WaitForName({1}", varName, waitS).AppendStringArg(TUtil.EscapeWindowName(name, true)).Append(");");
					if (activate) b.AppendLine();
				}
				if (activate) b.AppendFormat("w{0}.Activate();", varName);
				code = b.ToString();
			}
		}
	}
	
	record _RecoWinFind : _RecoWin {
		public string name;
		
		public void FormatCode(int ownerVar) {
			var f = new TUtil.WindowFindCodeFormatter { VarWindow = "w" + varName };
			f.RecordWindowFields(w, waitS, activate, ownerVar > 0 ? "w" + ownerVar : null);
			code = f.Format();
			//print.it(code);
		}
		
		public override string ToString() {
			using (new StringBuilder_(out var b)) {
				b.AppendFormat("wnd w{0}: ", varName);
				b.Append("find"); if (waitS != 0) b.Append("/wait");
				if (activate) b.Append(", activate");
				return b.ToString();
			}
		}
	}
	
	record _RecoWinChild : _Reco {
		public string code;
		public int varName, windowVarName;
		
		public void FormatCode(wnd window) {
			var f = new TUtil.WindowFindCodeFormatter { NeedWindow = false, VarWindow = "w" + windowVarName, VarControl = "c" + varName, Throw = true, waitW = "1" };
			f.RecordControlFields(window, w);
			code = f.Format();
			//print.it(code);
		}
		
		public override string ToString() {
			using (new StringBuilder_(out var b)) {
				b.AppendFormat("Find control c{0} in w{1}", varName, windowVarName);
				return b.ToString();
			}
		}
	}
	
	record _RecoSleep : _Reco {
	}
	
	WindowsHook _keyHook, _mouseHook;
	//WinEventHook _weHook;
	List<_Reco> _a = new(), _aUndo;
	bool _paused;
	bool _canMove;
	
	void _Pause() {
		if (_paused ^= true) _keyToText.Clear();
	}
	
	void _Clear() {
		if (!_a.Any()) return;
		_aUndo = _a;
		_a = new();
		_keyToText.Clear();
		_list.Items.Clear();
	}
	
	void _Undo() {
		if (_a.Any()) {
			int i = _a.Count - 1;
			if (_a[i] is _RecoKey k && k.down < 0) { int j = _FindModDown(k.key, i); if (j >= 0) i = j; } //if last is Mod*up, remove all starting from Mod*down
			for (int u = _a.Count; --u >= i;) _list.Items.RemoveAt(u);
			_a.RemoveRange(i, _a.Count - i);
		} else if (_aUndo != null) {
			_a = _aUndo;
			_aUndo = null;
			foreach (var r in _a) _list.Items.Add(_NewListItem(r));
			_scroller.ScrollToEnd();
		}
	}
	
	void _Add(_Reco r, int time, wnd w, wnd wTL = default) {
		r.w = w;
		r.time = time != 0 ? time : Environment.TickCount;
		int varName = _AddWinIfNeed(r, w, wTL);
		
		if (r is _RecoMouse m) {
			m.varName = varName;
			var p = m.p;
			if (_xyIn != c_xyScreen && w.MapScreenToClient(ref p)) m.pw = p;
		}
		
		_a.Add(r);
		_list.Items.Add(_NewListItem(r));
		_scroller.ScrollToEnd();
		_canMove = true;
	}
	
	static ListBoxItem _NewListItem(_Reco r) {
		var v = new ListBoxItem { Content = r.ToString() };
		var b = r switch { _RecoMouse => Brushes.Blue, _RecoKey or _RecoChar { alt: true } => Brushes.Green, _RecoChar => Brushes.DarkOrange, _ => null };
		if (b != null) v.Foreground = b;
		return v;
	}
	
	int _AddWinIfNeed(_Reco r, wnd w, wnd wTL) { //if _RecoMouse, w may be control, and wTL is always the top-level window; else w is top-level window, and wTL not used
		if (r is not (_RecoKey or _RecoChar or _RecoMouse) || w.Is0) return 0;
		wnd wChild = default;
		bool activate = false;
		if (r is _RecoMouse) { //button, wheel or move
			if (_xyIn == c_xyScreen || (r is _RecoMouseMoveBy) || (r is _RecoMouseWheel mw && !mw.move)) return 0;
			if (r is _RecoMouseButton mb && mb.down < 0 && _Last is _RecoMouseMoveBy mm && mm.drag && _a[_a.Count - 2] is _RecoMouseButton mb2 && mb2.down > 0 && mb2.w == w) { mb.noXY = true; return 0; } //if was drag, just release button (no window, x, y)
			if (wTL != w) { wChild = w; w = wTL; }
			activate = (r is not _RecoMouseButton || !_a.Any()) && w.IsActive;
		} else { //key or char
			activate = true;
		}
		if (activate && _IsWinActivated(w)) activate = false;
		
		int varName = _AddWin(w, activate, r is not _RecoMouse, r.time);
		
		if (!wChild.Is0) {
			var rc = _FindWinChild(wChild);
			if (rc == null) {
				int vi = (_LastOfType<_RecoWinChild>()?.varName ?? 0) + 1;
				var z = new _RecoWinChild { varName = vi, windowVarName = varName };
				_Add(z, r.time, wChild);
				Task.Run(() => z.FormatCode(w)).Wait(30); //may use ***elmName (slow and may fail in hook proc)
				varName = -vi;
			} else {
				varName = -rc.varName;
			}
		}
		
		return varName;
	}
	
	/// <summary>
	/// If w is new, adds wnd.find and optionally Activate.
	/// Else if name changed, adds w.WaitForName and optionally Activate.
	/// Else if activate, adds Activate.
	/// Else just returns 0.
	/// If onKey, does nothing if !activate and name not changed.
	/// </summary>
	/// <returns>Variable name.</returns>
	int _AddWin(wnd w, bool activate, bool onKey = false, int time = 0) {
		var name = w.Name;
		_RecoWin g = null;
		var rw = _FindWinFind(w);
		int varName = rw?.varName ?? 0;
		if (rw == null) { //find
			if (!activate && onKey) return 0;
			varName = (_LastOfType<_RecoWinFind>()?.varName ?? 0) + 1;
			var z = new _RecoWinFind { w = w, name = name, varName = varName, activate = activate, waitS = _a.Any() ? 10 : 0 };
			int owner = 0; if (!w.Get.Owner.Is0 || w.IsTopmost) owner = _FindWinFind(o => w.IsOwnedBy(o, 2))?.varName ?? 0;
			z.FormatCode(owner);
			g = z;
		} else if (name.Trim('*') != rw.name.Trim('*')) { //wait for new name
			rw.name = name;
			g = new _RecoWin { activate = activate, varName = rw.varName, waitS = 30 };
			g.FormatCode(name);
		} else if (activate) { //just activate
			g = new _RecoWin { activate = true, varName = rw.varName };
			g.FormatCode();
		} else {
			if (onKey) return 0;
		}
		if (g != null) _Add(g, time, w);
		return varName;
	}
	
	void _Remove(Index i) {
		int j = i.GetOffset(_a.Count);
		_a.RemoveAt(j);
		_list.Items.RemoveAt(j);
	}
	
	/// <summary>
	/// Redraws _list.Items[i]. If r not null, replaces _a[i].
	/// </summary>
	void _Replace(Index i, _Reco r = null) {
		int j = i.GetOffset(_a.Count);
		if (r != null) _a[j] = r; else r = _a[j];
		_list.Items[j] = _NewListItem(r);
	}
	
	_Reco _Last => _a.Count > 0 ? _a[^1] : null;
	
	T _LastOfType<T>() where T : _Reco {
		for (int i = _a.Count; --i >= 0;) if (_a[i] is T r) return r;
		return null;
	}
	
	/// <summary>
	/// Finds the last modifier down event for modKey key. Searches in _a from i-1, reverse.
	/// Returns -1 if not found or if found modKey non-down event.
	/// </summary>
	int _FindModDown(KKey modKey, int i) {
		while (--i >= 0) if (_a[i] is _RecoKey rk && rk.key == modKey) return rk.down > 0 ? i : -1;
		return -1;
	}
	
	_RecoWinFind _FindWinFind(wnd w) {
		for (int i = _a.Count; --i >= 0;) if (_a[i] is _RecoWinFind f && f.w == w) return f;
		return null;
	}
	
	_RecoWinFind _FindWinFind(Func<wnd, bool> func) {
		for (int i = _a.Count; --i >= 0;) if (_a[i] is _RecoWinFind f && func(f.w)) return f;
		return null;
	}
	
	_RecoWinChild _FindWinChild(wnd w) {
		for (int i = _a.Count; --i >= 0;) if (_a[i] is _RecoWinChild f && f.w == w) return f;
		return null;
	}
	
	bool _IsWinActivated(wnd w) {
		for (int i = _a.Count; --i >= 0;) {
			switch (_a[i]) {
			case _RecoWin r:
				if (r.activate) return r.w == w;
				break;
			case _RecoMouseButton r:
				if (r.activated) return r.varName > 0 ? r.w == w : r.w.Window == w;
				break;
			}
		}
		return false;
	}
	
	KeyToTextConverter _keyToText = new();
	
	void _KeyHook(HookData.Keyboard k) {
		if (_paused || !_recordKeys) return;
		var w = wnd.active;
		if (w == _wThis) return;
		
		if (k.Mod != 0) {
			if (k.IsUp) {
				if (!keys.isPressed(k.Key)) return; //eg Ctrl up when switching windows with different keyboard layouts
				if (_RemoveMod(k.Key, k.Mod)) return;
			} else {
				if (keys.isPressed(k.Key)) return; //auto-repeated. If AltGr, auto-repeats pairs, like Alt Ctrl Alt Ctrl.
			}
			_Add(new _RecoKey { key = k.Key, down = (sbyte)(k.IsUp ? -1 : 1), count = 1 }, k.time, w);
			return;
		}
		
		if (k.IsUp) return;
		
		if (k.Key == KKey.Packet) {
			if (!_recordText) return;
			_Add(new _RecoChar { c = (char)k.scanCode, count = 1 }, k.time, w);
			return;
		}
		
		if (_recordText && _Text()) return;
		
		if (_Last is _RecoKey rk && rk.key == k.Key && rk.mod == 0 && rk.down == 0 && rk.count < 1000) { //*count
			rk.count++;
			_Replace(^1);
			return;
		}
		
		_Add(new _RecoKey { key = k.Key, count = 1 }, k.time, w);
		
		bool _Text() {
			var mod = keys.getMod();
			if (!KeyToTextConverter.IsPossiblyChar_(mod, k.Key) || k.Key is KKey.Enter or KKey.Tab) return false;
			var wf = wnd.focused; if (wf.Is0) wf = w;
			if (!_keyToText.Convert(out var t, k.Key, k.scanCode, mod, wf.ThreadId)) return false;
			if (t == default) return true; //dead-key
			if (t.c == ' ' && k.Key == KKey.Space && _Last is not _RecoChar) return false; //record Space as key if it isn't followed by a char
			var mod2 = mod & ~KMod.Shift;
			if (!_recordText2 && mod2 == (KMod.Alt | KMod.Ctrl)) if (!keys.isPressed(KKey.RAlt) || keys.isPressed(KKey.RCtrl)) return false; //AltGr = RAlt+LCtrl
			bool alt = mod2 == KMod.Alt;
			
			if (_a.Count > 0 && t.c != default) { //*count
				if (_IsSame(^1)) {
					var rc = _Last as _RecoChar;
					if (rc.count > 1) {
						rc.count++;
						_Replace(^1);
						return true;
					} else if (_a.Count > 3 && _IsSame(^2) && _IsSame(^3) && _IsSame(^4)) {
						_Remove(^2); _Remove(^2); _Remove(^2);
						rc.count = 5;
						_Replace(^1);
						return true;
					}
				}
				bool _IsSame(Index i) {
					return _a[i] is _RecoChar rc && rc.c == t.c && rc.alt == alt && rc.count < 1000;
				}
			}
			
			_Add(new _RecoChar { c = t.c, s = t.s, alt = alt, count = 1 }, k.time, w);
			
			//why Text+ checkbox exists when we can detect AltGr:
			//	1. OS bugs. Eg AltGr stops working after an Open/Save dialog etc.
			//	2. Possibly not all keyboards have RAlt.
			//	3. Somebody may want to use Ctrl+Alt even if AltGr exists and works.
			//	4. There must be a reason why Alt+Ctrl is an alternative for AltGr.
			return true;
		}
	}
	
	/// <summary>
	/// On modifier up converts sequence like {Ctrl*down, Alt*down, K, Alt*up, Ctrl*Up} to {Ctrl+Alt+K} or {text}.
	/// If returns false, the caller does not record the Mod*up event.
	/// </summary>
	bool _RemoveMod(KKey key, KMod mod) {
		//print.it("----", key, mod);
		//print.it(_a);
		int nKeys = 0, nChars = 0, iKey = -1;
		for (int i = _a.Count; --i >= 0;) {
			switch (_a[i]) {
			case _RecoKey d:
				//print.it(d);
				if (d.key == key) {
					if (d.down != 1) return false; //Mod*up without Mod*down
					if (nKeys + nChars == 0) { //modifier(s) pressed-released without a key etc in between. Replace Mod*down with Mod.
						if (i == _a.Count - 1) {
							d.down = 0;
							_Replace(i);
						} else {
							for (int j = _a.Count; --j > i;) if (_a[j] is _RecoKey u && u.down != -1) _AddMod(j);
							_Remove(i);
						}
					} else { //remove Mod*down if Mod+key or Mod+characters
						if (nKeys > 0) { //else all characters
							if (nKeys + nChars > 1) { //Mod + multiple keys or Mod + keys and chars. Now display {Mod*down, A, B, Mod*up}. Later will convert to {Mod+(A B)}.
								if (mod == KMod.Alt) while (++i < _a.Count && _a[i] is _RecoChar rc) { rc.alt = false; _Replace(i); }
								return false;
							}
							if (nKeys == 1 && iKey >= 0) _AddMod(iKey); //Mod + key
						}
						_Remove(i);
					}
					return true;
				}
				if (d.down == 0) {
					nKeys++; iKey = i;
				}
				break;
			case _RecoChar d:
				if (d.alt) nKeys++; else nChars++;
				break;
			default: return false;
			}
		}
		return false;
		
		void _AddMod(int i) {
			var r = _a[i] as _RecoKey;
			if (r.key != key) r.mod |= mod;
			_Replace(i);
		}
	}
	
	void _MouseHook(HookData.Mouse k) {
		//deactivate this window when mouse leaves it
		var wa = wnd.active;
		if (k.IsMove) {
			if (wa != _wThis) _wFore = wa;
			else if (_wFore.IsVisible && !_wThis.Rect.Contains(k.pt) && Api.GetCapture().Is0) {
				Api.SetForegroundWindow(_wFore);
				_wFore = default;
				_canMove = false; //don't record mouse move until something new recorded
			}
		}
		
		if (_paused || !_recordMouse || wa == _wThis) return;
		
		if (k.IsButton) {
			//using var p1=perf.local();
			
			if (!_WinFromXY(out wnd w, out wnd wTL)) return;
			
			if (k.IsButtonUp) {
				if (_Last is _RecoMouseButton m && m.button == k.Button && m.down > 0 && !_PointIsDrag(m.p, k.pt)) {
					if (_a.Count > 1 && _a[^2] is _RecoMouseButton u && u.button == m.button && u.down == 0 && !u.two && _PointIsDouble(u.p, m.p) && m.time - u.time <= Api.GetDoubleClickTime()) {
						u.two = true;
						_Remove(^1);
					} else {
						m.down = 0;
						
						//if clicked a taskbar and it activates a window, replace the mouse.click with wnd.Activate()
						if (m.button == MButton.Left && wTL.ClassNameIs("Shell_*TrayWnd") && wTL.ProgramName.Eqi("explorer.exe")) {
							timer.after(25, _ => {
								var w1 = wnd.active;
								if (w1 != wTL && !w1.Is0 && _Last == m) {
									_Remove(^1); //remove mouse.click(w)
									if (_Last is _RecoWinChild rc && rc.w == w) _Remove(^1); //remove wnd.Child(w)
									if (_Last is _RecoWin rw && rw.w == wTL) _Remove(^1); //remove wnd.find(wTL)
									_AddWin(w1, true);
								}
							});
						}
					}
					_Replace(^1);
					return;
				}
			}
			var r = new _RecoMouseButton { button = k.Button, down = (sbyte)(k.IsButtonDown ? 1 : -1), p = k.pt };
			_Add(r, k.time, w, wTL);
			
			if (k.IsButtonDown) {
				//don't record w.Activate() on next key etc if this click activates w
				var ww = w.Window;
				if (!ww.Is0 && !ww.IsActive) {
					timer.after(10, _ => r.activated = ww.IsActive);
				}
				
				//comments
				//p1.Next();
				var p = k.pt;
				var ta = new Task[2] {
					Task.Run(() => r.image=TUtil.MakeScreenshot(p)),
					Task.Run(_Comment)
				};
				Task.WaitAll(ta, Math.Clamp(WindowsHook.LowLevelHooksTimeout - 150, 30, 150));
				void _Comment() {
					try {
						var e = elm.fromXY(p, EXYFlags.PreferLink /*| EXYFlags.NotInProc*/); //with NotInProc in some cases works not as good, eg no Name of 32-bit classic toolbar buttons
						var role = e?.Role; if (role.NE()) return;
						var name = e.Name;
						if (!name.NE()) name = name.Escape(limit: 30, quote: true);
						else if (role is "CLIENT" or "WINDOW") return;
						r.comment = $" /* {role.Lower()} {name} */";
					}
					catch (Exception e1) { Debug_.Print(e1); }
				}
				//CONSIDER: also screenshot on button up, if not joined with down and not in same point in window.
				//	But then usually records single line (mouse.drag).
			}
		} else if (k.IsWheel) {
			if (!_recordWheel) return;
			if (!_WinFromXY(out wnd w, out wnd wTL)) return;
			
			var rm = _LastOfType<_RecoMouse>();
			bool move = rm == null || rm.p != k.pt || rm is _RecoMouseMoveBy;
			_Add(new _RecoMouseWheel { ticks = k.WheelValue, p = k.pt, move = move }, k.time, w, wTL);
		} else if (_canMove) { //IsMove
			bool drag = mouse.isPressed(MButtons.Left | MButtons.Right | MButtons.Middle);
			if (!(drag ? _recordDrag : _recordMove)) return;
			if (_a.LastOrDefault(o => o is _RecoMouse) is _RecoMouse rm) {
				if (rm.p == k.pt) return;
				if (_Last is _RecoMouseMoveBy mm) { //add to the mouse.moveBy
					mm.a.Add((uint)Math2.MakeLparam(k.pt.x - mm.p.x, k.pt.y - mm.p.y));
					mm.p = k.pt;
				} else { //start mouse.moveBy
					_Add(new _RecoMouseMoveBy { a = new() { (uint)Math2.MakeLparam(k.pt.x - rm.p.x, k.pt.y - rm.p.y) }, p = k.pt, drag = drag }, k.time, default);
				}
			} else { //this is the first mouse event, therefore before mouse.moveBy need mouse.move(x, y)
				if (!_WinFromXY(out wnd w, out wnd wTL)) return;
				_Add(new _RecoMouse { p = k.pt }, k.time, w, wTL);
			}
		}
		
		bool _WinFromXY(out wnd w, out wnd wTL) {
			bool ctl = _xyIn == c_xyControl;
			w = wnd.fromXY(k.pt, ctl ? 0 : WXYFlags.NeedWindow);
			wTL = ctl ? w.Window : w;
			if (wTL == _wThis || wTL.Is0) { w = wTL = default; return false; }
			return true;
		}
		
		//tested: SM_CXDOUBLECLK=4 and SM_CXDRAG=4 regardless of DPI (using Dpi.GetSystemMetrics), and can't be changed in Control Panel etc.
		//static bool _PointIsDrag(POINT p1, POINT p2, wnd w) {
		//	if(p1==p2) return false;
		//	int dpi=Dpi.OfWindow(w);
		//	return Math.Abs(p1.x-p2.x)>=Dpi.GetSystemMetrics(Api.SM_CXDRAG, dpi) || Math.Abs(p1.y-p2.y)>=Dpi.GetSystemMetrics(Api.SM_CYDRAG, dpi);
		//}
		static bool _PointIsDrag(POINT a, POINT b) => Math.Abs(a.x - b.x) >= 4 || Math.Abs(a.y - b.y) >= 4;
		
		static bool _PointIsDouble(POINT a, POINT b) => Math.Abs(a.x - b.x) <= 2 && Math.Abs(a.y - b.y) <= 2;
	}
	
	//void _WeHook(HookData.WinEvent k) {
	//	if (_paused) return;
	//	switch (k.event_) {
	//	case EEvent.OBJECT_SHOW:
	//		if (k.idObject != EObjid.WINDOW || k.idChild != 0 || k.w.IsChild) break;
	//		//	print.it(k.idObject, k.idChild, k.w);
	//		var w = k.w;
	//		break;
	//	case EEvent.OBJECT_HIDE:
	
	//		break;
	//		//default:
	//		//	print.it(k.event_);
	//		//	break;
	//	}
	//}
	
	string _GetCode() {
		if (_Last is _RecoMouseMoveBy) _a.RemoveAt(_a.Count - 1);
		if (!_a.Any()) return null;
		var b = new StringBuilder();
		string speed = _tSpeed.TextOrNull();
		if (speed != null) b.Append("using (opt.scope.all()) ");
		b.AppendLine("{ //recorded");
		if (speed != null) b.AppendLine($"opt.mouse.MoveSpeed = opt.key.KeySpeed = opt.key.TextSpeed = {speed};");
		//bool addEmptyLine = false;
		for (int i = 0, n = _a.Count; i < n; i++) {
			////rejected: if mouse button with screenshot, add empty lines before and after, and add comment and screenshot before. Better just add empty line after.
			//if(_a[i] is _RecoMouseButton mb0 && mb0.image != null) {
			//	b.AppendLine().Append(mb0.comment, 1, mb0.comment.Length - 1).AppendLine(mb0.image);
			//	addEmptyLine = true;
			//} else if (addEmptyLine) {
			//	if (_a[i] is not _RecoSleep) b.AppendLine();
			//	addEmptyLine = false;
			//}
			
			switch (_a[i]) {
			case _RecoWin r: //and _RecoWinFind
				b.Append(r.code);
				break;
			case _RecoWinChild r:
				b.Append(r.code);
				break;
			case _RecoMouse r:
				//if drag in same window, format mouse.drag relative
				if (r is _RecoMouseButton mb && mb.down > 0 && i < n - 1) {
					if (_a[i + 1] is _RecoMouseButton mb2 && mb2.down < 0 && !mb2.noXY && mb2.w == mb.w) {
						mb.FormatDrag(b, (mb2.p.x - mb.p.x, mb2.p.y - mb.p.y));
						i++;
						goto g1;
					} else if (_a[i + 1] is _RecoMouseMoveBy mm && _a[i + 2] is _RecoMouseButton mb3 && mb3.down < 0 && mb3.noXY) {
						mb.FormatDrag(b, mm.OffsetsString);
						i += 2;
						goto g1;
					}
				}
				r.FormatCode(b);
				g1:
				//if (r is _RecoMouseButton mbb && mbb.image == null) b.Append(mbb.comment);
				if (r is _RecoMouseButton mbb) {
					b.Append(mbb.comment);
					if (mbb.image != null) {
						b.Append(mbb.image);
						if (i < n - 1) b.AppendLine(); //make space for image
					}
				}
				break;
			case _RecoKey or _RecoChar:
				b.Append("keys.send(\"");
				for (int prev = 0; i < n; i++) { //prev: 0 none, 1 keys, 2 chars
					var r = _a[i];
					if (r is _RecoKey rk) {
						if (prev == 1) b.Append(' '); else if (prev == 2) b.Append("\", \"");
						prev = 1;
						
						//Mod*down A B Mod*up -> Mod+(A B)
						//	FUTURE: keys.send("Ctrl+", click);
						if (rk.down > 0) {
							KMod modDown = 0, modUp = 0;
							int j = i;
							for (; j < n && _a[j] is _RecoKey k2 && k2.down > 0; j++) modDown |= _KeyToMod(k2.key);
							if (modDown != 0) {
								int iKeys = j;
								while (j < n && _a[j] is _RecoKey { down: 0, mod: 0 } or _RecoChar { s: null }) j++;
								int iModUp = j;
								for (; j < n && _a[j] is _RecoKey k2 && k2.down < 0; j++) modUp |= _KeyToMod(k2.key);
								if (modUp == modDown) {
									keys.more.hotkeyToString(b, modDown, 0);
									b.Append('(');
									for (i = iKeys; i < iModUp; i++) {
										switch (_a[i]) {
										case _RecoKey k:
											if (i > iKeys) b.Append(' ');
											b.Append(k);
											break;
										case _RecoChar k:
											if (i > iKeys && _a[i - 1] is _RecoKey) b.Append(' ');
											b.Append('_');
											k.FormatCodeSimple(b);
											break;
										}
									}
									b.Append(')');
									i = j - 1;
									continue;
								}
							}
							
							static KMod _KeyToMod(KKey k) => k switch { KKey.Ctrl => KMod.Ctrl, KKey.Shift => KMod.Shift, KKey.Alt => KMod.Alt, KKey.Win => KMod.Win, _ => 0 };
						}
						
						b.Append(rk);
					} else if (r is _RecoChar rc) {
						if (prev == 1) b.Append(' ');
						rc.FormatCode(b, prev != 2);
						prev = rc.count > 1 ? 1 : 2;
					} else break;
				}
				b.Append("\");");
				i--;
				break;
			case _RecoSleep r:
				break;
			}
			if (i < n - 1) b.AppendLine();
		}
		//if (speed != null)
		b.Replace("\n", "\n\t");
		b.Append("\r\n}");
		
		return b.ToString();
	}
	
	void _OK(bool copy) {
		Close();
		var s = _GetCode(); if (s.NE()) return;
		if (copy) {
			clipboard.text = s;
		} else {
#if SCRIPT
			print.it("<><code>" + s + "</code>");
			//ScriptEditor.Open("recorded.cs");
			//keys.send("Ctrl+End");
			//clipboard.paste(s);
#else
			//InsertCode.Statements(s); //flickers
			//timer.after(100, _ => InsertCode.Statements(s));
			Dispatcher.InvokeAsync(() => InsertCode.Statements(new(s)), DispatcherPriority.ApplicationIdle); //35 ms
#endif
		}
	}
}



================================================
FILE: Au.Editor/Tools/DPortable.cs
================================================
using System.Text.Json.Nodes;
using System.Windows;
using System.Windows.Controls;
using Au.Controls;
using System.IO.Compression;

namespace LA;

class DPortable : KDialogWindow {
	public static void ShowSingle() {
		if (App.IsPortable) {
			dialog.showError("Portable mode", "Please restart this program in non-portable mode.", owner: App.Wmain);
			return;
		}
		ShowSingle(() => new DPortable());
	}
	
	string _dirNet = folders.NetRuntime, _dirNetDesktop = folders.NetRuntimeDesktop;
	bool _exists;
	
	record class _Dir(string local, string portableRelative, int iSettings, string[] skipAlways) {
		public string portable => portableRelative.NE() ? App.Settings.portable_dir : App.Settings.portable_dir + "\\" + portableRelative;
		public bool copy;
		public KCheckBox cCopy;
		public TextBox tSkip;
		
		public string Skip {
			get => field;
			set {
				var s = value;
				if (skipAlways != null) {
					var a = (s ?? "").Lines(true);
					foreach (var v in skipAlways) if (!a.Contains(v, StringComparer.OrdinalIgnoreCase)) s = v + "\r\n" + s;
				}
				field = s;
				App.Settings.portable_skip[iSettings] = s;
			}
		}
	}
	
	_Dir _dApp, _dWs, _dSett, _dScript, _dDoc, _dRoaming;
	
	DPortable() {
		if (App.Settings.portable_dir.NE() && folders.RemovableDrive0.Path is string drive) App.Settings.portable_dir = drive + @"PortableApps\LibreAutomate";
		if (filesystem.more.comparePaths(folders.ThisApp, _dirNet) is CPResult.Same or CPResult.AContainsB) _dirNet = _dirNetDesktop = null;
		if (App.Settings.portable_skip.Lenn_() != 6) App.Settings.portable_skip = ["\\SDK\r\n\\Git", ".git\r\n\\exe", "", "", ".git", ""];
		
		InitWinProp("Portable LibreAutomate setup", App.Wmain);
		var b = new wpfBuilder(this);
		
		b.R.Add("Install in folder", out TextBox tDir).Focus().Validation(_ => _ValidateFolder());
		
		b.R.xAddInfoBlockT(out var tbInfoExists);
		
		int iDir = 0;
		b.R.StartGrid().Span(2).Columns(0, -1);
		b.R.Add<TextBlock>("Copy folder").Font(bold: true).Add<TextBlock>("Skip subfolders").Font(bold: true);
		_dApp = _AddDir(folders.ThisApp, "", "Program files (LA, .NET)", skipAlways: [@"\SDK"]);
		_dWs = _AddDir(App.Model.WorkspaceDirectory, @"data\doc\" + pathname.getName(App.Model.WorkspaceDirectory), "Workspace (scripts etc)");
		_dSett = _AddDir(folders.ThisAppDocuments + ".settings", @"data\doc\.settings", @"Settings");
		_dScript = _AddDir(folders.ThisAppDocuments + "_script", @"data\doc\_script", @"Script data");
		_dDoc = _AddDir(folders.ThisAppDocuments, @"data\doc", @"Documents (except the above 3 subfolders)");
		_dRoaming = _AddDir(folders.ThisAppDataRoaming, @"data\AppRoaming", @"AppData");
		b.R.AddSeparator(false);
		b.End();
		
		_Dir _AddDir(string local, string portableRelative, string label, string[] skipAlways = null) {
			int i = iDir++;
			
			if (!filesystem.exists(local).Directory) filesystem.createDirectory(local);
			_Dir d = new(local, portableRelative, i, skipAlways) { Skip = App.Settings.portable_skip[i] };
			
			b.R.AddSeparator(false);
			
			b.R.StartStack(vertical: true);
			b.Add(out d.cCopy, label).Checked(d.copy = 0 != (App.Settings.portable_check & 1 << i));
			d.cCopy.CheckChanged += (_, _) => App.Settings.portable_check.SetFlag_(1 << i, d.copy = d.cCopy.IsChecked);
			b.xAddInfoBlockF($"<a href=\"{local}\">{local.Limit(70, middle: true)}</a>{(i == 0 ? "" : " -> \\")}{portableRelative}").Padding("T1 B2");
			b.End();
			
			b.Add(out d.tSkip, d.Skip).Multiline(wrap: TextWrapping.NoWrap).Size(..500, ..120)
				.Tooltip("These folders will not be copied. Existing folders will not be deleted or updated.\r\nExamples:\r\nDescendantFolderName\r\n\\DirectChildFolderName\r\n\\Folder1\\Folder2\r\n//comment");
			d.tSkip.TextChanged += (o, _) => { d.Skip = (o as TextBox).Text; };
			if (label.Starts("Workspace")) b.Validation(o => d.tSkip.Text.Lines(noEmpty: true) is var a1 && (a1.Contains(@"\files", StringComparer.OrdinalIgnoreCase) || a1.Contains(@"files", StringComparer.OrdinalIgnoreCase)) ? "can't skip the files subfolder" : null);
			
			return d;
		}
		
		b.R.StartOkCancel();
		b.AddButton("Print details", _ => _PrintDetails()).Width(100);
		b.AddButton("Install", null, WBBFlags.OK);
		b.AddButton("Cancel", null, WBBFlags.Cancel);
		b.xAddDialogHelpButtonAndF1("editor/Portable app");
		b.End();
		
		b.End();
		
		tDir.TextChanged += (_, _) => {
			var s = App.Settings.portable_dir = tDir.Text.Trim().TrimEnd("\\/");
			_exists = filesystem.exists(s).Directory;
			tbInfoExists.Text = _exists ? "The portable folder already exists.\nChecked portable folders will be updated." : s == "" ? "" : "The folder still does not exist; it will be created.\nCheck all 'Copy folder'. Or only those you want to copy.\nIn the future you can use this tool to update portable files.";
			if (_exists && filesystem.exists(_dApp.portable).Directory) _dApp.cCopy.IsEnabled = true; else (_dApp.cCopy.IsEnabled, _dApp.cCopy.IsChecked) = (false, true);
		};
		tDir.Text = App.Settings.portable_dir;
		
		b.OkApply += e => {
			Task.Run(() => {
				try { _InstallThread(); }
				catch (Exception e1) { dialog.showError(@"Failed", e1.ToString()); }
			});
		};
	}
	
	void _InstallThread() {
		print.it($"<><lc YellowGreen>{(_exists ? "Updating" : "Installing")} portable LibreAutomate. Please wait until DONE.<>");
		
		Action portableWsPathSetting = _WsPathInPortableSettings();
		
		if (_dApp.copy || !_exists) {
			_Copy(_dApp, "/mir /xf unins* /xd dotnet data");
			
			bool isArm = osVersion.isArm64Process;
			if (isArm) _RenameArm64();
			
			if (_dirNet != null) {
				var dotnet = App.Settings.portable_dir + (isArm ? @"\dotnetARM" : @"\dotnet");
				_Copy2(_dirNet, dotnet, "/e");
				_Copy2(_dirNetDesktop, dotnet, "/e");
			}
			
			try {
				DotnetUtil.DownloadNetRuntimesForOtherArch(_dApp.portable, true);
			}
			catch (Exception ex) {
				string arch = isArm ? "x64" : "Arm64";
				print.warning($"Failed to download .NET Runtime {arch}. Only .NET Runtime {(isArm ? "Arm64" : "x64")} has been copied to the portable folder. On Windows {arch} the portable app will run only if .NET Runtime {arch} is installed there. Exception:\r\n{ex}");
			}
		}
		
		if (_dDoc.copy) _Copy(_dDoc, $"""/mir /xd "{_dWs.local}" "{_dWs.portable}" "{_dSett.local}" "{_dSett.portable}" "{_dScript.local}" "{_dScript.portable}" """);
		else filesystem.createDirectory(_dDoc.portable); //need subdir "data" to detect portable mode
		if (_dWs.copy) _Copy(_dWs, $"""/mir /xd "{_dWs.local}\.compiled" "{_dWs.local}\.temp" """);
		if (_dSett.copy) _Copy(_dSett);
		if (_dScript.copy) _Copy(_dScript);
		if (_dRoaming.copy) _Copy(_dRoaming);
		
		portableWsPathSetting?.Invoke();
		if (_dWs.copy) {
			var file = _dWs.portable + @"\settings.json";
			var s = filesystem.loadText(file);
			s = s.Replace("\"gitBackup\": true", "\"gitBackup\": false");
			filesystem.saveText(file, s);
		}
		
		print.it($"<>DONE. Installed in <link>{App.Settings.portable_dir}<>.");
		
		static void _Copy(_Dir d, string how = "/mir") => _Copy2(d.local, d.portable, how, d.Skip);
		
		static void _Copy2(string dir, string dirTo, string how, string skipDirs = null) {
			print.it($"Copying {dir}");
			var s = _RobocopyArgs(false, dir, dirTo, how, skipDirs);
			//info: the `/r:0` turns off the robocopy's slow and unreliable retries. Use this loop instead.
			//tested: with `/mt` (multithreaded) faster eg 20 -> 17 s or 49 -> 31 s. Faster even if HDD.
			
			for (int i = 0; ;) {
				int r = run.console(out var so, "robocopy.exe", s);
				//print.it($"<><c red>{r}<>"); print.it(so);
				if ((uint)r < 8) break;
				if (++i == 5) {
					print.it($"<><c red>Failed to copy '{dir}' to '{dirTo}'.<>\r\n<\a>{so}</\a>");
					if (r == 16) throw new AuException();
					break;
				}
				100.ms();
			}
			
			//CONSIDER: options:
			//	1. Keep new and newer portable files. (instead of /mir use /e /xo; or /mir /xo /xx)
			//		Bad: if both files modified...
			//	2. Copy symbolic link target. And workspace link target.
		}
		
		Action _WsPathInPortableSettings() {
			if (!_dSett.copy && !_dWs.copy) return null;
			
			string wsPath = null, file = _dSett.portable + @"\Settings.json";
			if (!_dWs.copy) { //preserve the portable workspace path setting when replacing the portable settings file
				try { wsPath = (string)JsonNode.Parse(filesystem.loadBytes(file))["workspace"]; }
				catch { }
			}
			
			return () => {
				var j = filesystem.exists(file) ? JsonNode.Parse(filesystem.loadBytes(file)) : new JsonObject();
				j["workspace"] = wsPath ?? $@"%folders.ThisAppDocuments%\{pathname.getName(_dWs.local)}";
				filesystem.saveText(file, j.ToJsonString());
			};
		}
		
		void _RenameArm64() {
			var dir = _dApp.portable;
			_Rename("Au.Editor.exe");
			
			void _Rename(string fileName) {
				string s1 = dir + "\\" + fileName, s2 = s1.Insert(^4, "-x64");
				if (filesystem.exists(s2)) {
					filesystem.rename(s1, fileName.Insert(^4, "-arm"));
					filesystem.rename(s2, fileName);
				}
			}
		}
	}
	
	static string _RobocopyArgs(bool log, string dir, string dirTo, string how, string skipDirs) {
		dir = pathname.unprefixLongPath(dir); //robocopy unaware about "\\?\"
		dirTo = pathname.unprefixLongPath(dirTo);
		
		StringBuilder b = new($"""
"{dir}" "{dirTo}" {how} /xj /r:0 /w:1 /np /mt
""");
		
		if (!skipDirs.NE() && skipDirs.Lines(noEmpty: true) is var a) {
			bool once = false;
			foreach (var s in a) {
				if (s.Starts("//")) continue;
				if (!once) { once = true; b.Append(" /xd"); }
				
				//workaround for: robocopy does not support relative paths. Can be either filename or full path.
				//	If filename, skips all source and dest descendants with that name.
				//	To achieve the same with a relative path, specify full paths in both source and dest dir.
				if (s[0] is '\\' or '/') b.Append($" \"{dir}{s}\" \"{dirTo}{s}\"");
				else b.Append($" \"{s}\"");
			}
			
			//TODO2: allow to reinclude subfolders and files, like <+>\.nuget\subfolder.
		}
		
		if (log) b.Append(" /l /bytes /nfl /njh");
		
		return b.ToString();
	}
	
	string _RobocopyArgs(bool log, _Dir d, string how) => _RobocopyArgs(log, d.local, d.portable, how, d.Skip);
	
	async void _PrintDetails() {
		print.clear();
		
		static async Task<long> _GetDirSize2(string dir, string how = "/mir", string skipDirs = null) {
			return await Task.Run(() => {
				var s = _RobocopyArgs(true, dir, folders.Temp + "06e5f7d0-13ec-438a-a415-53b624d3c308", how, skipDirs);
				run.console(out var so, "robocopy.exe", s);
				if (so.RxMatch(@"(?m)^\h*Bytes\h*:\h*\K\d+", 0, out so) && so.ToNumber(out long k)) return k;
				return -1;
			});
		}
		
		static async Task<long> _GetDirSize(_Dir d, string how = "/mir") => await _GetDirSize2(d.local, how, d.Skip);
		
		long sizeApp = await _GetDirSize(_dApp);
		long sizeNet = _dirNet == null ? 0 : await _GetDirSize2(_dirNet) + await _GetDirSize2(_dirNetDesktop);
		long sizeWs = await _GetDirSize(_dWs);
		long sizeSett = await _GetDirSize(_dSett);
		long sizeScript = await _GetDirSize(_dScript);
		long sizeDoc = await _GetDirSize(_dDoc, $"""/mir /xd "{_dWs.local}" "{_dSett.local}" "{_dScript.local}" """);
		long sizeRoaming = await _GetDirSize(_dRoaming);
		bool isArm = osVersion.isArm64Process;
		
		var b = new StringBuilder();
		b.AppendLine($"""
<><lc YellowGreen>Portable LibreAutomate setup details. The 'Skip subfolders' setting is applied.<>
Total size: {_MB(sizeApp + sizeNet + sizeWs + sizeSett + sizeScript + sizeDoc + sizeRoaming)} MB.
Folder sizes (MB):
	{"Program",-20} {_MB(sizeApp)}
	{$".NET Runtime {(isArm ? "Arm64" : "x64")}",-20} {_MB(sizeNet)}
	{$".NET Runtime {(isArm ? "x64" : "Arm64")}",-20} ~{_MB(sizeNet)} (download)
	{"Workspace",-20} {_MB(sizeWs)}
	{"Settings",-20} {_MB(sizeSett)}
	{"Script data",-20} {_MB(sizeScript)}
	{"Documents",-20} {_MB(sizeDoc)} (except the above 3 subfolders)
	{"AppData",-20} {_MB(sizeRoaming)}
""");
		
		_Links(b);
		
		print.it(b.ToString());
		print.scrollToTop();
		
		static string _MB(long size) {
			const int MB = 1024 * 1024;
			if (size < 0) return "<failed>";
			if (size == 0) return "0";
			if (size < MB) return "<1";
			return (size / MB).ToString();
		}
		
		void _Links(StringBuilder b) {
			int n = 0;
			foreach (var f in App.Model.Root.Descendants()) {
				if (f.IsLink) {
					if (n++ == 0) b.AppendLine("Links to external files and folders will be invalid on other computers:");
					b.Append($"\t{(f.IsFolder ? "Folder " : null)}{f.SciLink(path: true)}  ->  <explore>{f.FilePath}<>\r\n");
				}
			}
		}
	}
	
	string _ValidateFolder() {
		if (App.Settings.portable_dir.NE()) return "Where to install?";
		
		//error if workspace is in portable folder (shared). Or part of it (link target).
		if (filesystem.exists(App.Settings.portable_dir)) {
			bool bad = filesystem.more.comparePaths(App.Settings.portable_dir, _dWs.local) is CPResult.AContainsB or CPResult.BContainsA or CPResult.Same;
			if (!bad) {
				foreach (var f in App.Model.Root.Descendants()) {
					if (f.IsLink) {
						var s = f.FilePath;
						if (filesystem.more.comparePaths(App.Settings.portable_dir, s) is CPResult.AContainsB or CPResult.BContainsA or CPResult.Same) {
							if (!bad) print.it("Links to portable:");
							bad = true;
							print.it($"<>{f.SciLink(path: true)}  ->  <explore>{s}<>");
						}
					}
				}
			}
			if (bad) return "Current workspace or part of it is in the portable folder, or vice versa.";
		}
		
		return null;
	}
}


================================================
FILE: Au.Editor/Tools/DPwnd.cs
================================================
using Au.Controls;
using System.Windows;
using System.Windows.Controls;

namespace ToolLand;

/// <summary>
/// Dialog page for capturing a top-level window and editing its properties.
/// The result is <b>wnd.find</b> arguments string.
/// </summary>
class DPwnd : UserControl {
	wnd _wnd;
	string _wndName;
	
	KSciInfoBox _info;
	Button _bTest;
	KCheckBox _cCapture;
	Controls _k;
	
	public DPwnd() : this(null) { }
	
	public DPwnd(string header) {
		var b = new wpfBuilder(this).Columns(-1);
		Background = SystemColors.ControlBrush; //no tooltip etc without a brush
		
		if (header != null) b.xAddGroupSeparator(header);
		b.Row(50).Add(out _info);
		
		b.R.StartGrid().Columns(0, 76, -1);
		b.xAddCheckIcon(out _cCapture, "*Unicons.Capture" + LA.EdIcons.red, $"Enable capturing ({LA.App.Settings.delm.hk_capture}) and show window rectangles");
		b.AddButton(out _bTest, "Test", _bTest_Click).Span(1).Disabled().Tooltip("Find the window and show the rectangle");
		b.End();
		
		b.R.xStartPropertyGrid("L2 T3 R2 B1");
		_k = new(b, true);
		b.xEndPropertyGrid();
		
		b.End();
		
		bool loadedOnce = false;
		this.Loaded += (_, e) => {
			if (!loadedOnce) {
				loadedOnce = true;
				_InitInfo();
			}
			_cCapture.IsChecked = true;
		};
		
		IsVisibleChanged += (_, e) => {
			if (!(bool)e.NewValue) _cCapture.IsChecked = false;
		};
	}
	
	static DPwnd() {
		TUtil.OnAnyCheckTextBoxValueChanged<DPwnd>((d, o) => d._AnyCheckTextBoxValueChanged(o));
	}
	
	public void SetWnd(wnd w) {
		bool newWindow = w != _wnd;
		_wnd = w;
		_noeventValueChanged = true;
		
		string wndName = _wnd.NameTL_;
		if (newWindow) _k.Fill(_wnd, wndName, _wnd.ClassName, _wnd.ProgramName);
		else if (wndName != _wndName) _k.FillChangedName(wndName);
		_wndName = wndName;
		
		_noeventValueChanged = false;
	}
	
	public void Clear() {
		_wnd = default;
		_wndName = null;
		_noeventValueChanged = true;
		_k.Clear();
		_noeventValueChanged = false;
	}
	
	//when checked/unchecked any checkbox, and when text changed of any textbox
	void _AnyCheckTextBoxValueChanged(object source) {
		if (source == _cCapture) {
			_cCapture_CheckedChanged();
		} else if (!_noeventValueChanged) {
			_noeventValueChanged = true;
			if (source is TextBox t && t.Tag is KCheckTextBox k) {
				k.CheckIfTextNotEmpty();
			}
			_noeventValueChanged = false;
		}
		
		if (source is KCheckBox c && _k.IsMyCheckbox(c)) _bTest.IsEnabled = _k.HasResults;
	}
	bool _noeventValueChanged;
	
	string _FormatCode(bool forTest = false) {
		var f = new TUtil.WindowFindCodeFormatter { Test = forTest };
		_k.GetResults(f);
		return f.Format();
	}
	
	#region capture
	
	TUtil.CapturingWithHotkey _capt;
	
	void _cCapture_CheckedChanged() {
		_capt ??= new(
			_cCapture,
			o => o.wTL.GetRect(out o.resultRect),
			new(LA.App.Settings.delm.hk_capture, _Capture)
			);
		_capt.Capturing = _cCapture.IsChecked;
	}
	
	void _Capture() {
		var c = wnd.fromMouse(WXYFlags.NeedWindow); if (c.Is0) return;
		SetWnd(c);
		var w = this.Hwnd();
		if (w.IsMinimized) {
			w.ShowNotMinMax();
			w.ActivateL();
		}
	}
	
	#endregion
	
	#region Result, Test
	
	/// <summary>
	/// true if any checkbox checked.
	/// </summary>
	public bool HasResult => _bTest.IsEnabled;
	
	///// <summary>
	///// The captured window. Or default if not captured.
	///// </summary>
	//public wnd AaResultWindow => _wnd;
	
	/// <summary>
	/// <b>wnd.find</b> arguments string, like <c>"\"name\", \"class\"..."</c>. Or null if not specified.
	/// </summary>
	public string AaResultCode {
		get {
			var s = _FormatCode();
			s = TUtil.ArgsFromWndFindCode(s);
			if (s.Starts("null, null, \"")) s = s.ReplaceAt(0, 13, "of: \"");
			return s == "null" ? null : s;
		}
	}
	
	private void _bTest_Click(WBButtonClickArgs ea) {
		var code = _FormatCode(true);
		var rr = TUtil.RunTestFindObject(this, code, "w", _wnd, getRect: o => {
			var w = (wnd)o;
			var r = w.Rect;
			if (w.IsMaximized) {
				var k = w.Screen.Rect; k.Inflate(-2, -2);
				r.Intersect(k);
			}
			return r;
		});
		_info.InfoErrorOrInfo(rr.info);
	}
	
	#endregion
	
	#region info
	
	TUtil.CommonInfos _commonInfos;
	void _InitInfo() {
		_commonInfos = new TUtil.CommonInfos(_info);
		string s1 = _wnd.Is0 ? "C" : "You can c", s = $@"{s1}apture a window with <+hotkey>hotkey<> <b>{LA.App.Settings.delm.hk_capture}<>.";
		_info.aaaText = s;
		_info.AaAddElem(this, s);
		TUtil.CapturingWithHotkey.RegisterLink_DialogHotkey(_info);
		_k.InitInfo(_info);
	}
	
	#endregion
	
	//used by Dwnd too
	public class Controls {
		public KCheckTextBox name, cn, program, contains, also;
		
		public Controls(wpfBuilder b, bool addAlso) {
			b.Columns(70, -1);
			name = b.xAddCheckText<KTextExpressionBox>("name");
			cn = b.xAddCheckText<KTextExpressionBox>("class");
			program = b.xAddCheckTextDropdown<KTextExpressionBox>("program");
			contains = b.xAddCheckTextDropdown<KTextExpressionBox>("contains");
			if (addAlso) also = b.xAddCheckText("also", "o=>true");
		}
		
		public void InitInfo(KSciInfoBox ib) {
			ib.InfoCT(name, "Window name.", true);
			ib.InfoCT(cn, "Window class name.", true);
			ib.InfoCT(program, "Program.", true);
			ib.InfoCT(contains, """
A UI element in the window. Format: e 'role' name.
Or a control in the window. Format: c 'class' text.
""", true, "name/class/text");
			ib.InfoCT(also, "<help>wnd.find<> " + TUtil.CommonInfos.c_alsoParameter);
		}
		
		public void Fill(wnd w, string name_, string cn_, string program_) {
			name.Set(true, TUtil.EscapeWindowName(name_, true));
			cn.Set(true, TUtil.StripWndClassName(cn_, true));
			var ap = new List<string> { program_, "WOwner.Process(processId)", "WOwner.Thread(threadId)" }; if (!w.Get.Owner.Is0) ap.Add("WOwner.Window(ow)");
			program.Set(name_.NE(), program_, ap);
			contains.Set(false, null, _ContainsCombo_DropDown);
			
			List<string> _ContainsCombo_DropDown() {
				try {
					var a1 = new List<string>();
					//child
					foreach (var c in w.Get.Children(onlyVisible: true)) {
						var cn = c.Name; if (cn.NE()) continue;
						cn = "c '" + TUtil.StripWndClassName(c.ClassName, true) + "' " + TUtil.EscapeWildex(cn);
						if (!a1.Contains(cn)) a1.Add(cn);
					}
					//elm
					var a2 = new List<string>();
					var a3 = w.Elm[name: "?*", prop: "notin=SCROLLBAR\0maxcc=100", flags: EFFlags.ClientArea].FindAll(); //all that have a name
					string prevName = null;
					for (int i = a3.Length; --i >= 0;) {
						if (!a3[i].GetProperties("Rn", out var prop)) continue;
						if (prop.Name == prevName && prop.Role == "WINDOW") continue; prevName = prop.Name; //skip parent WINDOW
						string rn = "e '" + prop.Role + "' " + TUtil.EscapeWildex(prop.Name);
						if (!a2.Contains(rn)) a2.Add(rn);
					}
					a2.Reverse();
					a1.AddRange(a2);
					
					return a1;
					//rejected: sort
				}
				catch (Exception ex) { Debug_.Print(ex); return null; }
			}
		}
		
		public void FillChangedName(string name_) {
			if (TUtil.ShouldChangeTextBoxWildex(name.t.Text, name_))
				name.Set(true, TUtil.EscapeWindowName(name_, true));
		}
		
		public void GetResults(TUtil.WindowFindCodeFormatter f) {
			name.GetText(out f.nameW, emptyToo: true);
			cn.GetText(out f.classW);
			program.GetText(out f.programW);
			also.GetText(out f.alsoW);
			contains.GetText(out f.containsW);
		}
		
		public bool IsMyCheckbox(KCheckBox c) => c == name.c || c == cn.c || c == program.c || c == also.c || c == contains.c;
		
		public bool HasResults => name.c.IsChecked || cn.c.IsChecked || program.c.IsChecked || also.c.IsChecked || contains.c.IsChecked;
		
		public void Clear() {
			name.Clear();
			cn.Clear();
			program.Clear();
			contains.Clear();
			also.Clear("o=>true");
		}
	}
}


================================================
FILE: Au.Editor/Tools/DSnippets.cs
================================================
extern alias CAW;

using Microsoft.CodeAnalysis;
using CAW::Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Text;
using Microsoft.CodeAnalysis.CSharp.Extensions;
using Microsoft.CodeAnalysis.Shared.Extensions;
using CAW::Microsoft.CodeAnalysis.Shared.Extensions;
using CAW::Microsoft.CodeAnalysis.Rename;

using System.Windows;
using System.Windows.Controls;
using System.Windows.Controls.Primitives;
using System.Windows.Input;
using System.Windows.Media;
using Au.Controls;
using System.Xml.Linq;
using System.Windows.Documents;
using System.Text.Json.Nodes;
using ToolLand;

namespace LA;

class DSnippets : KDialogWindow {
	/// <param name="openSnippet">Open this snippet. Must be <c>"snippetName|fileName.ext"</c>.</param>
	public static void ShowSingle(string openSnippet = null) {
		var d = ShowSingle(() => new DSnippets());
		if (openSnippet != null) d._SelectAndOpen(openSnippet);
	}
	
	List<_Item> _files;
	
	Panel _panelSnippet, _panelFile;
	KTreeView _tv;
	KSciCodeBox _code;
	TextBox _tName, _tContext, _tInfo, _tMore, _tPrint, _tUsing, _tMeta, _tVar;
	TextBlock _tbFile, _tbDefaultFileInfo;
	
	_Item _ti; //current item
	_Item _clip; //cut/copy item
	bool _cut;
	bool _readonly;
	bool _ignoreEvents;
	
	DSnippets() {
		InitWinProp("Snippets", App.Wmain);
		
		var b = new wpfBuilder(this).WinSize(800, 600).Columns(250, 0, -1);
		b.Row(-1);
		
		b.xAddInBorder(out _tv);
		b.Add<GridSplitter>().Splitter(vertical: true);
		
		b.StartGrid().Columns(-1); //right side
		b.Row(-1);
		
		//snippet
		
		b.StartGrid().Hidden(null).Columns(0, -1, 30, 0, -1);
		_panelSnippet = b.Panel;
		b.R.Add("Name", out _tName).Tooltip("Snippet name. Single word.\nIf ends with \"Surround\", the snippet can be used only for surround.");
		_tName.TextChanged += (_, _) => { if (!_ignoreEvents && _ti.Level == 1) _TvSetText(_tName.TextOrNull()); };
		b.Skip().Add("Context", out AdornerDecorator _).Child().Add(out _tContext).Watermark("Auto-detect");
		_tContext.TextChanged += (_, _) => { if (!_ignoreEvents) _ti.context = _tContext.TextOrNull(); };
		b.R.Add("Info", out _tInfo);
		_tInfo.TextChanged += (_, _) => { if (!_ignoreEvents) { _ti.info = _tInfo.TextOrNull(); if (_ti.Level == 2) _TvSetText(_ti.info); } };
		b.R.Add("Info+", out _tMore).Multiline(40);
		_tMore.TextChanged += (_, _) => { if (!_ignoreEvents) _ti.more = _tMore.TextOrNull(); };
		b.R.Add("Print", out _tPrint).Multiline(40).Tooltip("Print this text when inserting the snippet.\nCan contain output tags if starts with <>.");
		_tPrint.TextChanged += (_, _) => { if (!_ignoreEvents) _ti.print_ = _tPrint.TextOrNull(); };
		b.R.Add("using", out _tUsing).Tooltip("If the snippet code requires using directives, add the namespace names here.\nExample: System.Windows;System.Windows.Controls");
		_tUsing.TextChanged += (_, _) => { if (!_ignoreEvents) _ti.using_ = _tUsing.TextOrNull(); };
		b.R.Add("Meta", out _tMeta).Tooltip("If the snippet code requires /*/ meta comments /*/, add them here.\nExample: c Example.cs; nuget -\\Example");
		_tMeta.TextChanged += (_, _) => { if (!_ignoreEvents) _ti.meta_ = _tMeta.TextOrNull(); };
		b.R.Add("${VAR}", out _tVar).Tooltip("${VAR} variable type and name. Example: Au.toolbar,t");
		_tVar.TextChanged += (_, _) => { if (!_ignoreEvents) _ti.var_ = _tVar.TextOrNull(); };
		foreach (var v in _panelSnippet.Children) if (v is TextBox t1) t1.IsReadOnlyCaretVisible = true;
		
		b.R.Add<Label>("Code");
		b.StartGrid().Columns(70, 70, 70, 70, 40).Align("R");
		b.AddButton("Paste", _ => _PasteCode(clipboard.text)).Tooltip("Replaces code with the clipboard text without indent tabs");
		b.AddButton("${n:text}", _ => _InsertVar("${1:}")).Tooltip("Tab stop with text");
		b.AddButton("$n", _ => _InsertVar("$1")).Tooltip("Tab stop without text or with text of the first ${n:text}");
		b.AddButton("$0", _ => _InsertVar("$0")).Tooltip("Final text cursor position");
		b.AddButton("...", _ => _InsertVar(null));
		b.End();
		b.Row(-1).xAddInBorder(out _code);
		_code.AaTextChanged += _ => { if (!_ignoreEvents) _ti.code = _code.aaaText; };
		_code.AaNotify += e => {
			if (e.n.code == Sci.NOTIF.SCN_MODIFYATTEMPTRO && _readonly) dialog.showInfo(null, "Default snippets are read-only, but you can clone a default snippet (right click, copy, paste) and edit the clone. Uncheck the default snippet.", owner: e.c);
		};
		b.End();
		
		//file
		
		b.And(0).StartStack(true).Hidden(null);
		_panelFile = b.Panel;
		b.Add(out _tbFile);
		b.Add(out _tbDefaultFileInfo, "Don't edit this file. The setup program replaces it. Only uncheck some snippets if need.").Wrap();
		b.End();
		
		b.R.AddSeparator(vertical: false);
		b.R.StartOkCancel().AddOkCancel(out var bOK, out var bCancel, out _, apply: "Apply");
		bOK.IsDefault = false; bCancel.IsCancel = false;
		b.AddButton("Import", _ => _ImportMenu()).Width(70);
		b.xAddDialogHelpButtonAndF1("editor/Snippets");
		b.End();
		
		b.End(); //right side
		b.End();
		
		_tv.HasCheckboxes = true;
		_tv.SingleClickActivate = true;
		_tv.ItemActivated += _tv_ItemActivated;
		_tv.ItemClick += _tv_ItemClick;
		_tv.KeyDown += _tv_KeyDown;
		_FillTree();
		
		//b.Loaded += () => {
		//};
		
		b.OkApply += e => {
			_Save();
		};
	}
	
	void _tv_ItemActivated(TVItemEventArgs e) => _Open(e.Item as _Item);
	
	void _Open(_Item t) {
		_ignoreEvents = true;
		_ti = t;
		_readonly = t.IsReadonly;
		int level = t.Level;
		_panelFile.Visibility = level == 0 ? Visibility.Visible : Visibility.Collapsed;
		_panelSnippet.Visibility = level > 0 ? Visibility.Visible : Visibility.Collapsed;
		
		if (level == 0) {
			_tbFile.Inlines.Clear();
			var h = new Hyperlink(new Run(t.filePath));
			h.Click += (_, _) => run.selectInExplorer(t.filePath);
			_tbFile.Inlines.Add(h);
			_tbDefaultFileInfo.Visibility = _readonly ? Visibility.Visible : Visibility.Collapsed;
		} else {
			bool isMenu = level == 1 && t.IsFolder;
			if (!isMenu) {
				var s = t.code;
				_code.AaSetText(s, _readonly ? 0 : -1);
			}
			
			_tName.Text = level == 1 ? t.text : t.Parent.text;
			_tContext.Text = level == 1 ? t.context : t.Parent.context;
			_tInfo.Text = level == 1 ? t.info : t.text;
			_tMore.Text = level == 1 ? t.more : t.Parent.more;
			_tPrint.Text = t.print_;
			_tUsing.Text = t.using_;
			_tMeta.Text = t.meta_;
			_tVar.Text = t.var_;
			
			_code.Visibility = isMenu ? Visibility.Hidden : Visibility.Visible;
			//don't disable textboxes. Instead make read-only, to allow scroll/select/copy text.
			_tName.IsReadOnly = level == 2 || _readonly;
			_tContext.IsReadOnly = level == 2 || _readonly;
			_tInfo.IsReadOnly = _readonly;
			_tMore.IsReadOnly = level == 2 || _readonly;
			_tPrint.IsReadOnly = _readonly;
			_tUsing.IsReadOnly = _readonly;
			_tMeta.IsReadOnly = _readonly;
			_tVar.IsReadOnly = _readonly;
			foreach (var v in _panelSnippet.Children) {
				switch (v is AdornerDecorator ad ? ad.Child : v) {
				case TextBox t1: //if readonly, display like disabled
					if (t1.IsReadOnly) t1.Background = SystemColors.ControlBrush; else t1.ClearValue(TextBox.BackgroundProperty);
					break;
				case Panel p1:
					p1.IsEnabled = !(_readonly || isMenu);
					break;
				}
			}
		}
		_ignoreEvents = false;
	}
	
	void _tv_ItemClick(TVItemEventArgs e) {
		var t = e.Item as _Item;
		int level = t.Level;
		if (e.Button == MouseButton.Left) {
			//print.it(e.Part);
			if (e.Part == TVParts.Checkbox) {
				t.isChecked ^= true;
				_tv.Redraw(t);
			} else if (e.Part == TVParts.Text) {
				if (level == 1 && t.IsFolder) _tv.Expand(t, true);
			}
		} else if (e.Button == MouseButton.Right) {
			var m = new popupMenu();
			
			if (!t.IsReadonly) {
				int clipLevel = _clip?.Level ?? -1;
				if (level == 0) {
					m["Add new snippet"] = o => _New(true);
					if (clipLevel == 1) _MiPaste(true);
				} else {
					if (level == 1) m["Add new snippet"] = o => _New(false);
					m["Add new menu item"] = o => _New(level == 1);
					m.Separator();
					m["Cut"] = o => _Copy(t, true);
					m["Copy"] = o => _Copy(t);
					if (clipLevel > 0) {
						_MiPaste(false);
						if (level == 1) _MiPaste(true);
					}
					m.Submenu("Delete", m => {
						m[$"Delete {(level == 1 ? "snippet" : "menu item")} '{t.text}'"] = o => _Remove(t);
					});
				}
				
				void _New(bool into) { _AddNewOrPaste(false, t, into); }
				
				void _MiPaste(bool into) {
					if (!_CanPaste(t, into)) return;
					int le = level; if (into) le++;
					m[le == 1 ? "Paste snippet" : into ? "Paste as menu item" : "Paste menu item"] = o => _AddNewOrPaste(true, t, into);
				}
				
				if (level == 0) {
					m.Separator();
					m["Sort snippets", disable: t.Count < 2] = o => _Sort(t);
					if (t.isImportedFile || (t.Count == 0 && !t.text.Eqi("Snippets.xml"))) {
						m.Separator();
						m[$"Delete this {(t.isImportedFile ? "imported" : "empty")} file..."] = o => _ImportDeleteFile(t);
					}
				}
			} else if (level > 0) {
				m["Copy"] = o => _Copy(t);
			}
			
			m.Show(owner: this);
		}
	}
	
	void _Copy(_Item t, bool cut = false) {
		if (_clip != null) _tv.Redraw(_clip);
		_clip = t;
		_cut = cut;
		_tv.Redraw(t); //red etc
	}
	
	bool _CanPaste(_Item t, bool into) {
		int level = t.Level + (into ? 1 : 0), clipLevel = _clip?.Level ?? -1;
		if (clipLevel != level && !(level == 2 && clipLevel == 1 && !_clip.IsFolder)) return false;
		if (_clip == t.Parent || (_cut && _clip == t)) return false;
		return true;
	}
	
	//rejected: select/copy multiple. Rarely need. Can edit file text.
	
	void _AddNewOrPaste(bool paste, _Item anchor, bool into) {
		int level = anchor.Level + (into ? 1 : 0);
		_Item t;
		if (paste) {
			if (_cut) {
				t = _clip;
				if (level == 2 && t.Level == 1) {
					if (!t.info.NE()) t.text = t.info;
					if (!t.more.NE()) print.it($"{t.text} Info+ was:\r\n{t.more}");
					if (!t.context.NE()) print.it($"{t.text} Context was:\r\n{t.context}");
					t.info = t.more = t.context = null;
				}
				_Remove(t, cut: true);
			} else {
				t = new _Item(this, level, _clip.text);
				t.code = _clip.code;
				if (level == 1) {
					t.info = _clip.info;
					t.more = _clip.more;
					t.context = _clip.context;
				} else {
					if (_clip.Level == 1 && !_clip.info.NE()) t.text = _clip.info;
				}
				t.print_ = _clip.print_;
				t.using_ = _clip.using_;
				t.meta_ = _clip.meta_;
				t.var_ = _clip.var_;
				t.isChecked = _clip.isChecked;
				foreach (var v in _clip.Children()) {
					var c = new _Item(this, 2, v.text) { code = v.code, print_ = v.print_, using_ = v.using_, meta_ = v.meta_, var_ = v.var_ };
					t.AddChild(c);
				}
			}
		} else {
			t = new _Item(this, level, level == 1 ? "Snippet" : "");
			t.isChecked = level == 1;
		}
		
		if (level == 2 && into && !anchor.IsFolder) { //convert anchor to menu
			var u = new _Item(this, level, anchor.info?.TrimEnd('.')) { code = anchor.code };
			anchor.code = null;
			anchor.AddChild(u);
		}
		
		if (into) anchor.AddChild(t); else anchor.AddSibling(t, false);
		
		_tv.SetItems(_files, true);
		
		if (paste && _cut) {
			
		} else {
			if (into) _tv.Expand(anchor, true);
			_SelectAndOpen(t);
			var c = level == 1 ? _tName : _tInfo;
			c.Focus();
			if (paste) c.Select(0, t.text.Length - (t.text.Ends("Snippet") ? 7 : t.text.Ends("Surround") ? 8 : 0));
		}
	}
	
	void _SelectAndOpen(_Item t) {
		_tv.SelectSingle(t);
		if (t != _ti) _Open(t);
	}
	
	void _SelectAndOpen(string s) {
		if (!s.Split2_('|', out var snippet, out var file, 1, 1)) return;
		foreach (var f in _files) {
			if (f.text.Eqi(file)) {
				if (f.Children().FirstOrDefault(o => o.text == snippet) is { } t) {
					_SelectAndOpen(t);
				}
				break;
			}
		}
	}
	
	void _Remove(_Item t, bool cut = false) {
		_clip = null;
		var p = t.Parent;
		t.Remove();
		
		if (p.Level == 1 && p.Count == 1) { //convert p to non-menu
			var u = p.FirstChild;
			p.code = u.code;
			p.info ??= u.text;
			p.more ??= u.more;
			p.context ??= u.context;
			p.print_ ??= u.print_;
			p.using_ ??= u.using_;
			p.meta_ ??= u.meta_;
			p.var_ ??= u.var_;
			u.Remove();
		}
		
		if (!cut) _tv.SetItems(_files, true);
		
		if (p.Level == 1 && !cut) {
			_SelectAndOpen(p);
		} else if (_ti == t) {
			_SelectNone();
		}
	}
	
	void _SelectNone() {
		_ti = null;
		_clip = null;
		_panelFile.Visibility = Visibility.Collapsed;
		_panelSnippet.Visibility = Visibility.Collapsed;
	}
	
	//rejected: a main menu command or hotkey here to quickly add new snippet from selected text or clipboard text.
	//	Cannot know where and what snippet type (snippet or menu item) to add.
	//void _QuickAddSnippet() {
	
	//}
	
	void _Sort(_Item t) {
		var a = t.Children().OrderBy(o => o.text, CiUtil.SortComparer).ToArray();
		foreach (var v in a) v.Remove();
		foreach (var v in a) t.AddChild(v);
		_tv.SetItems(_files, modified: true);
	}
	
	void _InsertVar(string s) {
		var text = _code.aaaText;
		var (selStart, selEnd) = _code.aaaSelection(true);
		bool inPlaceholder = selStart >= 4 && selEnd < text.Length && text[selEnd] == '}' && text[selStart - 1] == ':' && text.LastIndexOf('$', selStart - 2) is int i1 && i1 >= 0 && text.RxIsMatch(@"\G\$\{\d+:\z", range: i1..selStart);
		
		if (s != null) {
			if (inPlaceholder) return;
			if (s == "${1:}") {
				int n = 1; while (text.RxIsMatch($@"\$(?:{{{n}[:}}]|{n}(?!\d))")) n++;
				s = $"${{{n}:{_code.aaaSelectedText()}}}";
			}
			_code.aaaReplaceSel(s);
			if (s.RxIsMatch(@"^\$\{\d+:\}$")) _code.Call(Sci.SCI_CHARLEFT);
			else if (s == "$1") _code.Call(Sci.SCI_CHARLEFTEXTEND);
			_code.Focus();
		} else {
			var m = new popupMenu();
			Action<PMItem> aIns = o => {
				var s = o.Text;
				if (inPlaceholder) s = "$" + s[2..^1];
				_code.aaaReplaceSel(s);
				_code.Focus();
			};
			m["${SELECTED_TEXT}"] = aIns;
			m["${GUID}"] = aIns;
			m["${RANDOM}"] = aIns;
			m["${RANDOM_HEX}"] = aIns;
			m["${VAR}"] = aIns;
			m.Show();
		}
	}
	
	void _PasteCode(string s) {
		if (s.NE()) return;
		var a = s.Lines();
		int indent = (int)a.Min(o => (uint)o.FindNot("\t"));
		s = string.Join("\r\n", a.Select(o => o[indent..]));
		_code.aaaReplaceRange(false, 0, -1, s);
	}
	
	void _TvSetText(string s) {
		_ti.text = s;
		_tv.Redraw(_ti, true);
	}
	
	static HashSet<string> _GetHiddenSnippets(string fileName, bool orAdd = false) {
		var files = App.Settings.ci_hiddenSnippets ??= (orAdd ? new() : null);
		if (files == null) return null;
		fileName = fileName.Lower();
		if (files.TryGetValue(fileName, out var r)) return r;
		if (orAdd) files.Add(fileName, r = new());
		return r;
	}
	
	public static HashSet<string> GetHiddenSnippets(string fileName) => _GetHiddenSnippets(fileName);
	
	/// <summary>
	/// Saves hidden snippets of a snippets file in <c>App.Settings.ci_hiddenSnippets</c>. Removes if <i>hs</i> is null or empty.
	/// </summary>
	static void _SaveHiddenSnippets(string fileName, HashSet<string> hs = null) {
		if (hs?.Count > 0) {
			(App.Settings.ci_hiddenSnippets ??= new())[fileName.Lower()] = hs;
		} else {
			App.Settings.ci_hiddenSnippets?.Remove(fileName.Lower());
		}
	}
	
	void _FillTree() {
		string snippetsDir = AppSettings.DirBS, defSnippets = CiSnippets.DefaultFile;
		if (!filesystem.exists(CiSnippets.CustomFile).File) {
			try { filesystem.saveText(CiSnippets.CustomFile, "<snippets></snippets>"); }
			catch { }
		}
		_files = new();
		
		foreach (var f in filesystem.enumFiles(snippetsDir, "*Snippets.xml")) _File(f.FullPath, f.Name, false);
		_File(defSnippets, "default", true);
		
		_tv.SetItems(_files);
		
		void _File(string path, string name, bool isDefault) {
			try {
				var hidden = _GetHiddenSnippets(name);
				var xf = CiSnippets.LoadSnippetsFile_(path);
				if (xf == null) return;
				var tf = new _Item(this, 0, name) { filePath = path, isImportedFile = !isDefault && xf.HasAttr("imported") };
				if (hidden == null || !hidden.Contains("")) tf.isChecked = true;
				_files.Add(tf);
				var e = xf.Elements("snippet");
				if (isDefault) e = e.OrderBy(o => o.Attr("name"), CiUtil.SortComparer); //rejected: order in all files. Instead there is a context menu command "Sort".
				foreach (var xs in e) {
					var ts = new _Item(this, 1, xs.Attr("name")) {
						info = xs.Attr("info"),
						more = xs.Attr("more"),
						context = xs.Attr("context"),
						print_ = xs.Attr("print"),
						using_ = xs.Attr("using"),
						meta_ = xs.Attr("meta"),
						var_ = xs.Attr("var")
					};
					if (hidden == null || !hidden.Contains(ts.text)) ts.isChecked = true;
					tf.AddChild(ts);
					if (xs.HasElements) {
						foreach (var xi in xs.Elements("list")) {
							var ti = new _Item(this, 2, xi.Attr("item")) {
								code = xi.Value,
								print_ = xi.Attr("print"),
								using_ = xi.Attr("using"),
								meta_ = xi.Attr("meta"),
								var_ = xi.Attr("var")
							};
							ts.AddChild(ti);
						}
					} else {
						ts.code = xs.Value;
					}
				}
				tf.fileXml = _ToXml(tf).ToString(); //to detect when need to save
			}
			catch (Exception e1) { print.it(e1.ToStringWithoutStack()); }
		}
	}
	
	XElement _ToXml(_Item f) {
		var xf = new XElement("snippets");
		foreach (var s in f.Children()) {
			var xs = new XElement("snippet", new XAttribute("name", s.text ?? ""), new XAttribute("info", s.info ?? ""));
			xf.Add(xs);
			if (s.context != null) xs.SetAttributeValue("context", s.context);
			if (s.more != null) xs.SetAttributeValue("more", s.more);
			_Snippet(s, xs, false);
			foreach (var i in s.Children()) {
				var xi = new XElement("list", new XAttribute("item", i.text ?? ""));
				xs.Add(xi);
				_Snippet(i, xi, true);
			}
		}
		return xf;
		
		static void _Snippet(_Item t, XElement x, bool li) {
			if (t.code != null) {
				x.Add("\n");
				x.Add(new XCData(t.code));
				x.Add(li ? "\n      " : "\n    ");
			}
			if (t.print_ != null) x.SetAttributeValue("print", t.print_);
			if (t.using_ != null) x.SetAttributeValue("using", t.using_);
			if (t.meta_ != null) x.SetAttributeValue("meta", t.meta_);
			if (t.var_ != null) x.SetAttributeValue("var", t.var_);
		}
	}
	
	void _Save() {
		foreach (var f in _files) {
			if (f.text != "default") {
				var xf = _ToXml(f);
				var xml = xf.ToString();
				if (xml != f.fileXml) {
					f.fileXml = xml;
					filesystem.saveText(f.filePath, xml);
				}
			}
			var hs = f.Descendants().Where(o => o.Level == 1 && !o.isChecked).Select(o => o.text).ToHashSet();
			if (!f.isChecked) hs.Add("");
			_SaveHiddenSnippets(f.text, hs);
		}
		CiSnippets.Reload();
	}
	
	class _Item : TreeBase<_Item>, ITreeViewItem {
		DSnippets _d;
		public string text; //displayed text. Depends on level: 0 filename or "default", 1 snippet name, 2 snippet item info
		public string filePath, fileXml; //level 0
		public string code, context, info, more, print_, using_, meta_, var_; //level 1 or 2
		public bool isChecked, isImportedFile;
		bool _isExpanded;
		
		public _Item(DSnippets d, int level, string text) {
			_d = d;
			this.text = text;
			_isExpanded = level == 0;
		}
		
		public bool IsReadonly => RootAncestor.text == "default";
		
		#region ITreeViewItem
		
		void ITreeViewItem.SetIsExpanded(bool yes) { _isExpanded = yes; }
		
		public bool IsExpanded => _isExpanded;
		
		IEnumerable<ITreeViewItem> ITreeViewItem.Items => base.Children();
		
		public bool IsFolder => base.HasChildren;
		
		string ITreeViewItem.DisplayText => text;
		
		object ITreeViewItem.Image => Level switch {
			0 => "*Modern.PageXml" + EdIcons.black,
			1 => IsFolder ? s_snippetMenuIcon : "*Codicons.SymbolSnippet" + EdIcons.blue,
			_ => "*Material.Asterisk @12" + EdIcons.blue,
		};
		static string[] s_snippetMenuIcon = ["*Codicons.SymbolSnippet" + EdIcons.blue, "*Material.Asterisk @8" + EdIcons.blue];
		
		TVCheck ITreeViewItem.CheckState => Level == 2 ? TVCheck.None : isChecked ? TVCheck.Checked : TVCheck.Unchecked;
		
		int ITreeViewItem.TextColor(TVColorInfo ci) => this == _d._clip ? (_d._cut ? 0xFF0000 : 0x00A000) : -1;
		
		#endregion
	}
	
	void _tv_KeyDown(object sender, KeyEventArgs e) {
		var k = (e.KeyboardDevice.Modifiers, e.Key);
		switch (k) {
		case (0, Key.Escape):
			if (_clip != null) {
				_clip = null;
				_tv.Redraw();
			}
			goto gh;
		}
		if (_tv.FocusedItem is _Item t) {
			switch (k) {
			case (0, Key.Delete):
				if (!t.IsReadonly && t.Level > 0 && dialog.showOkCancel("Delete?", t.text, owner: this)) _Remove(t);
				break;
			case (ModifierKeys.Control, Key.X):
				if (!t.IsReadonly && t.Level > 0) _Copy(t, true);
				break;
			case (ModifierKeys.Control, Key.C):
				if (t.Level > 0) _Copy(t);
				break;
			case (ModifierKeys.Control, Key.V):
				if (!t.IsReadonly && _clip != null) {
					bool into = _clip.Level > t.Level;
					if (_CanPaste(t, into)) _AddNewOrPaste(true, t, into);
				}
				break;
			default: return;
			}
		}
		gh:
		e.Handled = true;
	}
	
	#region import
	
	void _ImportMenu() {
		var m = new popupMenu();
		m["Import VS snippets..."] = o => _ImportVS();
		m["Import VSCode snippets..."] = o => _ImportJson();
		m.Show(owner: this);
	}
	
	void _ImportSave(XElement x) {
		x.SetAttributeValue("imported", "");
		string dir = AppSettings.DirBS, file = null;
		for (int i = 1; ; i++) { //unique filename
			file = AppSettings.DirBS + "Imported" + i + " snippets.xml";
			if (!filesystem.exists(file)) {
				x.Save(file);
				break;
			}
		}
		_SelectNone();
		_FillTree();
		if (_files.FirstOrDefault(o => o.filePath == file) is { } f) {
			_tv.SelectSingle(f, scrollTop: true);
			_Open(f);
		}
		CiSnippets.Reload();
	}
	
	void _ImportVS() {
		var d = new FileOpenSaveDialog("fc3a7c73-3be0-43f2-af26-7d4d6b6c381e") { FileTypes = "VS snippets|*.snippet", Title = "Import snippet files", FileNameLabel = "Selected files:" };
		if (!d.ShowOpen(out string[] files, owner: this)) return;
		try {
			var x = _ImportVS(files);
			_ImportSave(x);
		}
		catch (Exception ex) { dialog.showError("Failed to import snippets.", ex.ToString(), owner: this); }
	}
	
	void _ImportJson() {
		var d = new FileOpenSaveDialog("89bf0c8f-f42b-49ca-8644-649acecfe92f") { FileTypes = "VSCode snippets|*.json", Title = "Import snippets file" };
		if (!d.ShowOpen(out string file, owner: this)) return;
		try {
			var x = _ImportJson(file);
			_ImportSave(x);
		}
		catch (Exception ex) { dialog.showError("Failed to import snippets.", ex.ToString(), owner: this); }
	}
	
	static XElement _ImportVS(IEnumerable<string> files) {
		var xRoot = new XElement("snippets");
		foreach (var f in files) {
			try { _AddFile(f); }
			catch (Exception ex) { print.it($"Failed to convert {pathname.getName(f)}. {ex}"); }
		}
		return xRoot;
		
		void _AddFile(string file) {
			var xSnippets = XElement.Load(file);
			//print.it($"<><bc green>{file}<>\r\n{xSnippets}");
			var ns = xSnippets.Name.Namespace;
			foreach (var xSnippet in xSnippets.Elements(ns + "CodeSnippet")) {
				if (xSnippet.Attr("Format") is string format && !format.Starts("1.")) { print.warning($"Snippet format {format} not supported."); continue; }
				var xs = xSnippet.Element(ns + "Snippet");
				var s = xs.Elem(ns + "Code", "Language", "csharp", true)?.Value;
				if (_ImportSkip(s)) continue;
				
				List<(string id, string def)> ad = null;
				if (xs.Element(ns + "Declarations") is { } xDecls) {
					foreach (var xl in xDecls.Elements(ns + "Literal")) {
						var def = xl.Element(ns + "Default")?.Value;
						if (def == null) {
							if (xl.Element(ns + "Function")?.Value is string k && k.Like("SimpleTypeName(*)")) {
								k = k[15..^1];
								if (k.Starts("global::")) k = k[8..];
								if (k.Starts("System.") && k.IndexOf('.', 7) < 0) k = k[7..];
								def = k;
							}
						}
						var id = xl.Element(ns + "ID").Value;
						//if (xl.Attr("Editable") == "false") print.it(xl);
						if (xl.Attr("Editable") == "false" && !def.NE()) s = s.Replace($"${id}$", def);
						else (ad ??= new()).Add((id, def ?? "EDIT"));
					}
				}
				s = s.Replace("$selected$ $end$", "$selected$$end$");
				if (s.Find("$end$") is int i1 && i1 >= 0 && i1 + 5 is int i1end) s = s.ReplaceAt(i1..i1end, s.Length > i1end && s[i1end] is >= '0' and <= '9' ? "${0}" : "$0");
				s = s.Replace("$selected$", "${SELECTED_TEXT}");
				if (ad != null) {
					int n = 1;
					foreach (var v in ad) s = s.Replace($"${v.id}$", $"${{{n++}:{v.def}}}");
				}
				
				var xh = xSnippet.Element(ns + "Header");
				
				var x = _ImportAddXElement(xRoot, s, xh.Element(ns + "Shortcut").Value, xh.Element(ns + "Description")?.Value);
				if (xs.Element(ns + "Imports") is { } xImps) {
					StringBuilder bu = new();
					foreach (var xi in xImps.Elements(ns + "Import")) {
						if (xi.Element(ns + "Namespace") is { } xns) bu.Append(bu.Length > 0 ? "; " : null).Append(xns.Value);
					}
					if (bu.Length > 0) x.SetAttributeValue("using", bu.ToString());
				}
			}
		}
	}
	
	static XElement _ImportJson(string file) {
		var xRoot = new XElement("snippets");
		
		var jRoot = JsonNode.Parse(filesystem.loadText(file));
		//print.it(jRoot.ToJsonString(new() { WriteIndented = true }));
		foreach (var jSnippet in jRoot as JsonObject) {
			var info = jSnippet.Key;
			try {
				var j = jSnippet.Value.AsObject();
				var code = _ToString(j["body"]);
				code = code.Replace("${TM_SELECTED_TEXT}", "${SELECTED_TEXT}").Replace("${UUID}", "${GUID}");
				if (_ImportSkip(code)) continue;
				var more = _ToString(j["description"]);
				var n = j["prefix"];
				if (n is JsonArray ap) {
					foreach (var v in ap) _Add((string)v);
				} else {
					_Add((string)n);
				}
				
				void _Add(string prefix) {
					_ImportAddXElement(xRoot, code, prefix, info, more);
				}
				
				static string _ToString(JsonNode n) {
					if (n is JsonArray a) return string.Join("\r\n", a.GetValues<string>());
					return (string)n;
				}
			}
			catch (Exception ex) { print.it($"Failed to convert {info}. {ex}"); }
		}
		
		return xRoot;
	}
	
	static bool _ImportSkip(string code) => code.NE() || 0 != code.Starts(false, "<", "Microsoft Visual Studio Solution File", "@"); //project or solution file, XML, razor
	
	static XElement _ImportAddXElement(XElement xRoot, string code, string namePrefix, string info, string more = null) {
		var x = new XElement("snippet", "\n", new XCData(code ?? ""), "\n    ");
		x.SetAttributeValue("name", namePrefix/*.RxReplace(@"[^\p{Xan}_#]+", "_")*/ + "Snippet");
		x.SetAttributeValue("info", info);
		if (!more.NE() && more != info) x.SetAttributeValue("more", more);
		xRoot.Add(x);
		return x;
	}
	
	void _ImportDeleteFile(_Item f) {
		if (!dialog.showOkCancel("Delete this snippets file?", $"{f.filePath}", owner: this)) return;
		if (false == filesystem.delete(f.filePath, FDFlags.CanFail | FDFlags.RecycleBin)) return;
		_SaveHiddenSnippets(f.text);
		_SelectNone();
		_FillTree();
		CiSnippets.Reload();
	}
	
	#endregion
}


================================================
FILE: Au.Editor/Tools/DWinapi.cs
================================================
using System.Windows;
using System.Windows.Controls;
using Au.Controls;
using ToolLand;

namespace LA;

class DWinapi : KDialogWindow {
	sqlite _db;
	TextBox tName;
	KSciCodeBox code;

	public DWinapi(string name = null) {
		var doc = Panels.Editor.ActiveDoc;
		InitWinProp("Find Windows API", App.Wmain);

		if (name == null) {
			name = doc.aaaSelectedText();
			if (!name.NE()) {
				name = name.RxReplace(@"\W+", " ");
			}
		}

		var b = new wpfBuilder(this).WinSize(800, 500);
		b.R.Add("Name", out tName, name);
		b.Row(-1).Add(out code); code.AaInitBorder = true;
		b.R.StartOkCancel().AddOkCancel("OK, copy to clipboard").xAddDialogHelpButtonAndF1(_Help).End();
		b.End();

		b.OkApply += o => {
			string s = code.aaaText;
			if (s.NE()) return;
			Clipboard.SetText(s);
		};

		tName.TextChanged += (_, _) => _TextChanged();

		void _Help() {
			var s = @"/**
Here you can find Windows API declarations: function, struct, enum, interface, delegate, constant, GUID.
Enter API name in the above field. Case-sensitive. Wildcard examples: Start*, *End, *Part*.
Or multiple full names, like Name1 Name2 Name3.
You can in editor select text with one or more names and open this window. Or use error tooltips.
If script is without a class, create new class (or convert script to class) and paste declarations there.

Also try snippet nativeApiSnippet (select it from the completion list when text cursor is where classes can be,
for example at the end of script). It adds a special class. Then anywhere in script just type class name, dot,
and select from the list. It adds the declaration to the class, and more declarations if need.

The database contains ~200_000 declarations. They are not perfect. You can edit.
Data source: https://github.com/microsoft/win32metadata

See also: menu Edit > Generate > Convert [PreserveSig] methods.
*/";
			code.AaSetText(s);
		}
	}

	protected override void OnSourceInitialized(EventArgs e) {
		_db = EdDatabases.OpenWinapi();
		if (!tName.Text.NE()) _TextChanged();

		base.OnSourceInitialized(e);
	}

	protected override void OnClosed(EventArgs e) {
		_db?.Dispose();
		_db = null;
		base.OnClosed(e);
	}

	void _TextChanged() {
		string name = tName.Text;
		var a = new List<(string name, string code)>();

		int nWild = 0; for (int i = 0; i < name.Length; i++) { switch (name[i]) { case '*': case '?': nWild++; break; } }
		if (name.Length > 0 && (nWild == 0 || name.Length - nWild >= 2)) {
			string sql;
			if (name.Contains(' ')) sql = $"in ('{string.Join("', '", name.RxFindAll(@"\b[A-Za-z_]\w\w+", (RXFlags)0))}')";
			else if (name.FindAny("*?") >= 0) sql = $"GLOB '{name}'";
			else sql = $"= '{name}'";
			try {
				using var stat = _db.Statement("SELECT name, code FROM api WHERE name " + sql);
				//perf.first();
				while (stat.Step()) a.Add((stat.GetText(0), stat.GetText(1)));
				//perf.nw(); //30 ms cold, 10 ms warm. Without index.
			}
			catch (SLException ex) { Debug_.Print(ex); }
		}

		string s = "";
		if (a.Count != 0) {
			s = a[0].code;
			if (a.Count > 1) s = string.Join(s.Starts("internal const") ? "\r\n" : "\r\n\r\n", a.Select(o => o.code));
			s += "\r\n";
		}
		code.AaSetText(s);
	}
}


================================================
FILE: Au.Editor/Tools/Delm.cs
================================================
using Au.Controls;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;

namespace ToolLand;

//TODO3: if checked 'state', activate window before test. Else different FOCUSED etc.

//CONSIDER: here and in Dwnd: UI for "contains image".
//	Also then need to optimize "elm containing image". Now with image finder in 'also' gets pixels multiple times.

//PROBLEM: hangs when trying to get a property while the target window does not respond. Only MSAA, not UIA.
//	Eg when the Windows search UI hidden after capturing. Then its process is suspended?

//note: don't use access keys (_ in control names). It presses the button without Alt, eg when the user forgets to activate editor and starts typing.

//TEST: CoCancelCall/CoTestCancel.

//TODO3: auto detect when should use Invoke and when WebInvoke, and suggest to switch.
//	If now Invoke, and role web:, and after executing action soon changed window title, suggest WebInvoke.
//	If now WebInvoke, and role not web:, and after executing action does not change window title for eg 5 s, suggest to stop waiting and use Invoke.
//	Or just add pseudo action Auto. If "web:", use WebInvoke, else if has action, use Invoke, else MouseClick.

//TODO3: on Win11 capturing and finding in some places doesn't work because an element in the path is an invisible control.
//	Examples: taskbar, Paint.
//	Now by default auto-switches to UIA; it works, but then broken Invoke (in taskbar only).

//CONSIDER: action "screenshot".

//note: in System Informer window all UIA API hang for 2 s. Mixed acc/UIA capturing too. Pure acc OK. Same if notinproc. Other tested apps too (Inspect, PAD, UiPath).

class Delm : KDialogWindow {
	elm _elm;
	wnd _wnd, _con;
	bool _useCon;
	bool _wndNoActivate;
	string _wndName;
	string _screenshot;
	
	KSciInfoBox _info;
	Button _bTest, _bInsert, _bWindow;
	ComboBox _cbAction;
	KCheckBox _cCapture, _cAutoTestAction, _cAutoInsert, _cControl, _cException, _cScroll;
	CheckBox _cUIA;
	KCheckTextBox _wait, _xy;
	_PropPage _page, _commonPage;
	Border _pageBorder;
	KSciCodeBoxWnd _code;
	KTreeView _tree;
	
	partial class _PropPage {
		Delm _dlg;
		
		public KCheckTextBox roleA, nameA, uiaidA, uiacnA, idA, classA, valueA, descriptionA, actionA, keyA, helpA, urlA, elemA, stateA, rectA, alsoA, skipA, navigA, notinA, maxccA, levelA;
		public KCheckBox inPath, hiddenTooA, reverseA, uiaA, notInprocA, clientAreaA, menuTooA;
		public Border htmlAttr;
		public Grid panel;
		public _TreeItem ti;
		
		//elm properties, other parameters, search settings
		public _PropPage(Delm dlg) {
			//print.it("_PropPage");
			_dlg = dlg;
			
			var b = new wpfBuilder().Height(180).Columns(-2, 0, -1);
			panel = b.Panel as Grid;
			//elm properties (left side)
			b.R.xStartPropertyGrid("L2 TRB").Height = panel.Height;
			roleA = b.xAddCheckText<KTextExpressionBox>("role");
			nameA = b.xAddCheckText<KTextExpressionBox>("name");
			//note: these must be == prop property names
			uiaidA = b.xAddCheckText<KTextExpressionBox>("uiaid");
			uiacnA = b.xAddCheckText<KTextExpressionBox>("uiacn");
			idA = b.xAddCheckText<KTextExpressionBox>("id");
			classA = b.xAddCheckText<KTextExpressionBox>("class");
			valueA = b.xAddCheckText<KTextExpressionBox>("value");
			descriptionA = b.xAddCheckText<KTextExpressionBox>("desc");
			actionA = b.xAddCheckText<KTextExpressionBox>("action");
			keyA = b.xAddCheckText<KTextExpressionBox>("key");
			helpA = b.xAddCheckText<KTextExpressionBox>("help");
			urlA = b.xAddCheckText<KTextExpressionBox>("url");
			b.R.Add(out htmlAttr); //HTML attributes will be added with another builder
			elemA = b.xAddCheckText<KTextExpressionBox>("item");
			stateA = b.xAddCheckText<KTextExpressionBox>("state");
			rectA = b.xAddCheckText<KTextExpressionBox>("rect");
			b.xEndPropertyGrid();
			b.SpanRows(3);
			b.xAddSplitterV(span: 4, thickness: 12);
			//right side
			b.xStartPropertyGrid("R2 LTB").Height = 140;
			//other parameters
			alsoA = b.xAddCheckText("also", "o=>true");
			skipA = b.xAddCheckText("skip");
			navigA = b.xAddCheckText<KTextExpressionBox>("navig");
			//search settings
			b.xAddCheck(out hiddenTooA, "Find hidden too");
			b.xAddCheck(out reverseA, "Reverse order");
			b.xAddCheck(out uiaA, "UI Automation");
			b.xAddCheck(out notInprocA, "Not in-process");
			b.xAddCheck(out clientAreaA, "Only client area");
			b.xAddCheck(out menuTooA, "Can be in menu");
			notinA = b.xAddCheckText<KTextExpressionBox>("notin"); //note: these must be == prop property names
			maxccA = b.xAddCheckText<KTextExpressionBox>("maxcc");
			levelA = b.xAddCheckText<KTextExpressionBox>("level");
			b.xEndPropertyGrid();
			b.R.Skip(2).AddSeparator(vertical: false).Margin("T9 B9");
			b.Row(-1).Skip(2).Add(out inPath, "Add to path").Margin("1");
			b.End();
			
			_InitInfo();
		}
	}
	
	public Delm(POINT? p = null) {
		Title = "Find UI element";
		
		var b = new wpfBuilder(this).WinSize((500, 440..), (600, 500..)).Columns(-1, 0);
		b.R.Add(out _info).Height(60);
		b.R.StartGrid().Columns(76, 76, 130, 0, 70, -1);
		//row 1
		b.R.StartStack();
		b.xAddCheckIcon(out _cCapture, "*Unicons.Capture" + LA.EdIcons.red, $"Enable capturing (hotkey {LA.App.Settings.delm.hk_capture}, and {LA.App.Settings.delm.hk_insert} to insert) and show UI element rectangles");
		b.xAddCheckIcon(out _cAutoTestAction, "*Material.CursorDefaultClickOutline" + LA.EdIcons.red, "Auto test action when captured.\r\nIf no action selected, will show menu.");
		b.xAddCheckIcon(out _cAutoInsert, "*VaadinIcons.Insert" + LA.EdIcons.brown, "Auto insert code when captured");
		b.AddSeparator(true);
		//b.xAddButtonIcon(LA.EdIcons.iconUndo, _ => App.Dispatcher.InvokeAsync(() => SciUndo.OfWorkspace.UndoRedo(false)), "Undo in editor");
		//b.xAddButtonIcon("*Material.SquareEditOutline" + LA.EdIcons.blue, _ => App.Hmain.ActivateL(true), "Activate editor window");
		b.xAddButtonIcon("*FontAwesome.WindowMaximizeRegular" + LA.EdIcons.blue, _ => _wnd.ActivateL(true), "Activate captured window");
		b.AddSeparator(true);
		b.xAddButtonIcon("*Material.CursorDefaultClickOutline" + LA.EdIcons.black, _ => _Test(testAction: true), "Test action");
		b.xAddButtonIcon("*Material.CursorDefaultClickOutline" + LA.EdIcons.blue, _ => _Test(testAction: true, actWin: true), "Activate window and test action");
		b.AddSeparator(true);
		b.xAddButtonIcon("*EvaIcons.Options2" + LA.EdIcons.green, _ => _ToolSettings(), "Tool settings");
		b.AddSeparator(true);
		b.Add(out _cUIA, "UIA").Checked(LA.App.Settings.delm.def_UIA, threeState: true).Tooltip("What API to use to capture UI elements:\nChecked - UI Automation\nUnchecked - MSAA\nIndeterminate - auto");
		
		b.End();
		//row 2
		b.R.AddButton(out _bTest, "Test", _ => _Test()).Tooltip("Execute the 'find' part of the code now and show the rectangle.\r\nRight-click for more options.");
		_bTest.ContextMenuOpening += _bTest_ContextMenuOpening;
		b.AddButton(out _bInsert, "Insert", _ => _Insert(hotkey: false)).Tooltip($"Insert code in editor.\nHotkey {LA.App.Settings.delm.hk_insert} (while capturing).");
		b.Add(out _cbAction).Tooltip("Action. Call this function when found. Or instead of Find call FindAll or create new elmFinder.");
		_xy = b.xAddCheckText("x, y", noR: true, check: _Opt.Has(_EOptions.MouseXY)); b.Span(1).Height(18); _xy.t.HorizontalScrollBarVisibility = ScrollBarVisibility.Hidden;
		b.Add(out _cScroll, "Scroll").Checked(_Opt.Has(_EOptions.MouseScroll));
		//row 3
		b.R.StartStack();
		b.AddButton(out _bWindow, "Window...", _bWnd_Click).Width(70);
		b.xAddCheck(out _cControl, "Control").Margin("R30");
		_wait = b.xAddCheckText("Wait", LA.App.Settings.delm.def_wait ?? "1", check: !_Opt.Has(_EOptions.NoWait)); b.Width(48);
		b.xAddCheck(out _cException, "Fail if not found").Checked();
		b.End();
		
		b.End();
		_ActionInit();
		_EnableDisableTopControls(false);
		
		b.R.AddSeparator(false);
		_commonPage = new(this);
		b.R.Add(out _pageBorder).Margin("LR").Height(_commonPage.panel.Height);
		b.R.AddSeparator(false);
		
		//code
		b.Row(80).xAddInBorder(out _code, "B");
		
		//tree
		b.xAddSplitterH(span: -1);
		b.Row(-1).xAddInBorder(out _tree, "T");
		
		b.End();
		
		_InitTree();
		
		if (p != null) _ElmFromPoint(p.Value, ctor: true); //will call _SetElm in OnSourceInitialized
		
		b.WinProperties(
			topmost: true,
			showActivated: _elm != null ? false : null //eg if captured a popup menu item, activating this window closes the menu and we cannot get properties
			);
		
		WndSavedRect.Restore(this, LA.App.Settings.wndpos.elm, o => LA.App.Settings.wndpos.elm = o);
	}
	
	static Delm() {
		TUtil.OnAnyCheckTextBoxValueChanged<Delm>((d, o) => d._AnyCheckTextBoxValueChanged(o), comboToo: true);
	}
	
	protected override void OnSourceInitialized(EventArgs e) {
		base.OnSourceInitialized(e);
		
		if (_elm != null) _SetElm(false);
		_InitInfo();
		_InitCapturingWithHotkey();
	}
	
	protected override void OnClosing(CancelEventArgs e) {
		_cCapture.IsChecked = false;
		base.OnClosing(e);
	}
	
	protected override void OnClosed(EventArgs e) {
		base.OnClosed(e);
		
		//release COM objects. Else later can't unload the C++ dll from processes where used UIA etc.
		_tree.SetItems(null);
		foreach (var f in typeof(Delm).GetFields(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public)) {
			if (!f.FieldType.IsValueType) f.SetValue(this, null);
		}
		GC.Collect();
		GC.WaitForPendingFinalizers();
	}
	
	void _SetElm(bool captured) {
		wnd c = _elm.WndContainer, w = c.Window;
		if (w.Is0) return;
		
		string wndName = w.NameTL_;
		bool sameWnd = captured && w == _wnd && wndName == _wndName;
		_wndName = wndName;
		
		bool useCon = _useCon && captured && sameWnd && c == _con;
		//search in control by default in these cases:
		//	1. It is in other thread. Then would be slow because cannot use inproc. Except in known windows.
		//	2. If Java. Can find in any case if control class name specified, but now cannot get tree of entire window.
		if (!useCon && c != w) {
			if (c.ThreadId != w.ThreadId) useCon = 0 == c.ClassNameIs(Api.string_IES, "Windows.UI.Core.CoreWindow");
			else useCon = w.ClassNameIs("SunAwt*") && c.ClassNameIs("SunAwt*");
		}
		
		_SetWndCon(w, c, useCon);
		
		if (!_FillPropertiesTreeAndCode(true, sameWnd)) return;
		
		if (_IsAutoTest) timer.after(1, _ => _Test(captured: true, testAction: _cAutoTestAction.IsChecked));
	}
	
	void _SetWndCon(wnd w, wnd con, bool useCon = false) {
		_wnd = w;
		_con = con == w ? default : con;
		_useCon = useCon && !_con.Is0;
		_wndNoActivate = w.IsNoActivateStyle_();
		using var nevc = new _NoeventValueChanged(this);
		_cControl.IsChecked = _useCon; _cControl.IsEnabled = !_con.Is0;
	}
	
	//Called when: 1. _SetElm. 2. The Window button changed window. 3. The Control checkbox checked/unchecked.
	bool _FillPropertiesTreeAndCode(bool setElm = false, bool sameWnd = false) {
		//_nodeCaptured = null;
		
		//perf.first();
		_TreeItem ti = null;
		bool sameTree = sameWnd && _TrySelectInSameTree(out ti);
		//perf.next();
		
		if (!sameTree) _ClearTree();
		else if (ti != null && _PathSetPageWhenTreeItemSelected(ti)) return true;
		
		if (!_FillProperties(out var p)) return false;
		if (!sameTree) {
			Mouse.SetCursor(Cursors.Wait);
			_FillTree(p);
			Mouse.SetCursor(Cursors.Arrow);
		}
		_FormatCode();
		
		if (p.Role == "CLIENT" && _wnd.ClassNameIs("SunAwt*") && !_elm.MiscFlags.Has(EMiscFlags.Java) /*&& !osVersion.is32BitOS*/) {
			timer.every(50, t => {
				if (_testing) return;
				t.Stop();
				if (_info.AaElemsSuspended) { //eg showing test result
					string s1 = c_infoJava, s2 = _info.aaaText; if (!s2.NE() && !s2.Ends('\n')) s1 = "\r\n" + s1;
					_info.aaaAppendText(s1, false, false);
				} else _info.aaaText = c_infoJava;
			});
		}
		//_info.aaaText = c_infoJava;
		
		//_nodeCaptured = _tree.SelectedItem as _TreeItem; //print.it(_nodeCaptured?.e);
		//perf.nw();
		return true;
	}
	
	//Called when: 1. Captured, or window/control changed (_FillPropertiesTreeAndCode). 2. A tree item clicked.
	bool _FillProperties(out EProperties p) {
		bool propOK = _elm.GetProperties("Rnuvdakh@srwU", out var pr);
		var (browser, propUrl) = propOK ? _IsVisibleWebPage(_elm, _con.Is0 ? _wnd : _con) : default;
		p = pr;
		if (propOK != _bTest.IsEnabled) _EnableDisableTopControls(propOK);
		if (!propOK) {
			_pageBorder.Child = null;
			_page = null;
			_info.InfoError("Failed to get UI element properties", lastError.message);
			return false;
		}
		_page ??= _commonPage ??= new(this);
		_pageBorder.Child = _page.panel;
		
		using var nevc = new _NoeventValueChanged(this);
		
		bool isWeb = browser != 0;
		_isWebIE = browser == _BrowserEnum.IE;
		
		var role = p.Role; if (isWeb) role = "web:" + role;
		_SetHideIfEmpty(_page.roleA, role, check: true, escape: false);
		//CONSIDER: path too. But maybe don't encourage, because then the code depends on window/page structure.
		bool noName = !_SetHideIfEmpty(_page.nameA, p.Name, check: true, escape: true, dontHide: true);
		
		bool haveCon = !isWeb && !_con.Is0;
		bool uncheckCon = haveCon && !_con.IsVisible; //eg in Photos window
		if (haveCon && !uncheckCon && p.UiaId.ToInt(out int i1) && i1 == _con.ControlId) { //don't use uiaid if == control id
			if (_con.GetWindowAndClientRectInScreen(out var rw1, out var rc1))
				if (rc1 == p.Rect || rw1 == p.Rect) p.UiaId = null;
			//never mind: possibly incorrect p.Rect of DPI-scaled window.
		}
		if (_SetHideIfEmpty(_page.uiaidA, p.UiaId, check: noName, escape: true)) noName = false;
		
		if (haveCon && !uncheckCon && !p.UiaCN.NE() && p.UiaCN.Eqi(_con.ClassName)) { //don't use uiacn if == control class
			if (_con.GetWindowAndClientRectInScreen(out var rw1, out var rc1))
				if (rc1 == p.Rect || rw1 == p.Rect) p.UiaCN = null;
		}
		if (_SetHideIfEmpty(_page.uiacnA, p.UiaCN, check: false, escape: true)) noName = false;
		
		//control
		bool isClassId = haveCon && !_useCon;
		_page.idA.Visible = isClassId;
		_page.classA.Visible = isClassId;
		if (isClassId) {
			string sId = TUtil.GetUsefulControlId(_con, _wnd, out int id) ? id.ToString() : _con.NameWinforms;
			bool hasId = _SetHideIfEmpty(_page.idA, sId, check: true, escape: false);
			_Set(_page.classA, TUtil.StripWndClassName(_con.ClassName, true), check: !hasId);
			if (uncheckCon) _page.classA.c.IsChecked = _page.idA.c.IsChecked = false;
		}
		
		_SetHideIfEmpty(_page.valueA, p.Value, check: false, escape: true);
		if (_SetHideIfEmpty(_page.descriptionA, p.Description, check: noName, escape: true)) noName = false;
		_SetHideIfEmpty(_page.actionA, p.DefaultAction, check: false, escape: true);
		if (_SetHideIfEmpty(_page.keyA, p.KeyboardShortcut, check: noName, escape: true)) noName = false;
		if (_SetHideIfEmpty(_page.helpA, p.Help, check: noName, escape: true)) noName = false;
		_SetHideIfEmpty(_page.urlA, propUrl, check: true, escape: false);
		
		if (p.HtmlAttributes.Count > 0) {
			var b = new wpfBuilder(_page.htmlAttr).Columns((0, ..100), -1).Options(modifyPadding: false, margin: new());
			foreach (var attr in p.HtmlAttributes) {
				string na = attr.Key, va = attr.Value;
				bool check = noName && (na == "id" || na == "name") && va.Length > 0;
				var k = b.xAddCheckText<KTextExpressionBox>("@" + na, TUtil.EscapeWildex(va));
				if (check) { k.c.IsChecked = true; noName = false; }
				var info = TUtil.CommonInfos.AppendWildexInfo(TUtil.CommonInfos.PrependName(na, "HTML attribute."));
				_info.AaAddElem(k.c, info);
				_info.AaAddElem(k.t, info);
			}
			b.End();
		} else _page.htmlAttr.Child = null;
		
		int item = _elm.Item;
		_page.elemA.Visible = item != 0;
		if (item != 0) {
			_Set(_page.elemA, item.ToS());
			if (noName && role is "BUTTON" or "CHECKBOX") { noName = false; _page.elemA.c.IsChecked = true; } //buttons in some toolbars don't have Name
		}
		
		_Set(_page.stateA, p.State.ToString());
		_Set(_page.rectA, $"{{W={p.Rect.Width} H={p.Rect.Height}}}");
		
		_page.alsoA.c.IsChecked = false;
		_page.skipA.c.IsChecked = false;
		_page.navigA.c.IsChecked = false;
		if (isWeb && !_waitAutoCheckedOnce) _wait.c.IsChecked = _waitAutoCheckedOnce = true;
		_page.uiaA.IsChecked = _elm.MiscFlags.Has(EMiscFlags.UIA);
		
		return true;
		
		void _Set(KCheckTextBox ct, string value, bool check = false) {
			ct.t.Text = value;
			ct.c.IsChecked = check;
		}
		
		bool _SetHideIfEmpty(KCheckTextBox ct, string value, bool check, bool escape, bool dontHide = false, bool hideIfNull = false) {
			bool empty = hideIfNull ? value == null : value.NE();
			ct.Visible = !empty || dontHide;
			if (empty) check = false;
			else if (escape) value = TUtil.EscapeWildex(value);
			ct.t.Text = value;
			ct.c.IsChecked = check;
			return !empty;
		}
	}
	
	private void _bWnd_Click(WBButtonClickArgs e) {
		var wPrev = _WndSearchIn;
		bool captCheck = _cCapture.IsChecked;
		var r = _code.AaShowWndTool(this, _wnd, _con, checkControl: _useCon);
		if (captCheck) _cCapture.IsChecked = true;
		if (!r.ok) return;
		_SetWndCon(r.w, r.con, r.useCon);
		if (_WndSearchIn != wPrev) _FillPropertiesTreeAndCode();
	}
	
	//when checked/unchecked any checkbox, and when text changed of any textbox
	void _AnyCheckTextBoxValueChanged(object source) {
		if (source == _cCapture) {
			_capt.Capturing = _cCapture.IsChecked;
		} else if (_noeventValueChanged < 1 && _page != null) {
			using var nevc = new _NoeventValueChanged(this);
			if (source is KCheckBox c) {
				if (c == _cControl) {
					_useCon = c.IsChecked;
					_FillPropertiesTreeAndCode();
					return;
				} else if (c == _page.inPath) {
					_PathAddRemove();
				} else if (c == _page.uiaA) {
					_ClearTree();
					_cCapture.IsChecked = true;
					_cUIA.IsChecked = c.IsChecked;
					TUtil.InfoTooltip(ref _ttRecapture, c, "Please capture the UI element again.");
				}
			} else if (source is TextBox t && t.Tag is KCheckTextBox k) {
				k.CheckIfTextNotEmpty();
			}
			
			_FormatCode();
		}
	}
	
	int _noeventValueChanged;
	ref struct _NoeventValueChanged {
		Delm _d;
		public _NoeventValueChanged(Delm d) { _d = d; _d._noeventValueChanged++; }
		public void Dispose() { _d._noeventValueChanged--; }
	}
	
	KPopup _ttRecapture;
	
	(string code, string wndVar) _FormatCode(bool test = false) {
		if (_page == null) return default; //failed to get UI element props
		
		var action = _CurrentAction;
		bool isFinder = !test && action.IsFinder;
		bool isFindAll = !test && action.IsFindAll;
		int iFindAll = isFindAll ? action.name.Ends(false, "foreach", "for", "Select", "Select 2", "table") : 0;
		bool orThrow = !(test | isFinder | isFindAll) && _cException.IsChecked;
		bool isAction = !test && action.code != null;
		bool isVar = !(test | isFinder | isFindAll /*|| (isAction && orThrow && _Opt.Has(_EOptions.Compact))*/);
		
		var b = new StringBuilder();
		string wndCode = null, wndVar = null;
		if (isFinder) {
			b.Append("var f = elm.path");
		} else {
			(wndCode, wndVar) = _code.AaGetWndFindCode(test, _wnd, _useCon ? _con : default);
			b.AppendLine(wndCode);
			if (isVar) b.Append("var e = ");
			else if (isFindAll) b.Append(iFindAll switch { 1 => "foreach (var e in ", 5 => "var rows = ", _ => "var a = " });
			b.Append(wndVar).Append(".Elm");
		}
		
		bool isInPath = _page != _commonPage;
		int nPathPages = isInPath ? _path.Count : 1;
		for (int iPathPage = 0; iPathPage < nPathPages; iPathPage++) {
			var page = isInPath ? _path[iPathPage].page : _page;
			b.Append('[');
			page.roleA.GetText(out var role, emptyToo: true);
			if (iPathPage > 0 && !role.NE()) role = role[(role.IndexOf(':') + 1)..];
			b.AppendStringArg(role);
			
			bool isName = page.nameA.GetText(out var name, emptyToo: true);
			if (isName) b.AppendStringArg(name);
			
			int nProp = 0, propStart = 0;
			void _AppendProp(KCheckTextBox k, bool emptyToo = false) {
				if (!k.GetText(out var va, emptyToo)) return;
				if (k == page.levelA && va == "0 1000") return;
				if (k == page.maxccA && va == "10000") return;
				if (nProp++ == 0) {
					b.Append(", ");
					if (!isName) b.Append("prop: ");
					propStart = b.Length;
					b.Append("[");
				} else b.Append(", ");
				int j = b.Length;
				b.Append('"').Append(k.c.Content as string).Append('=');
				if (!va.NE()) {
					if (va.Starts("@@")) {
						b.Insert(j, '$').Append('{').Append(va[2..]).Append('}');
					} else if (TUtil.IsVerbatim(va, out int prefixLen)) {
						b.Insert(j, va[..prefixLen++]).Append(va, prefixLen, va.Length - prefixLen);
						return;
					} else {
						va = va.Escape();
						b.Append(va);
					}
				}
				b.Append('"');
			}
			
			_AppendProp(page.uiaidA, true);
			_AppendProp(page.uiacnA, true);
			if (iPathPage == 0) {
				_AppendProp(page.idA, true);
				_AppendProp(page.classA);
			}
			_AppendProp(page.valueA, true);
			_AppendProp(page.descriptionA, true);
			_AppendProp(page.actionA, true);
			_AppendProp(page.keyA, true);
			_AppendProp(page.helpA, true);
			_AppendProp(page.urlA, true);
			if (page.htmlAttr.Child is Grid g) foreach (var c in g.Children.OfType<KCheckBox>()) _AppendProp(c.Tag as KCheckTextBox, true);
			_AppendProp(page.elemA);
			_AppendProp(page.stateA);
			_AppendProp(page.rectA);
			_AppendProp(page.notinA);
			_AppendProp(page.maxccA);
			_AppendProp(page.levelA);
			if (nProp > 0) b.Append(']');
			
			if (TUtil.FormatFlags(out var s1,
				(page.hiddenTooA, EFFlags.HiddenToo),
				(page.reverseA, EFFlags.Reverse),
				(iPathPage == 0 ? page.uiaA : null, EFFlags.UIA),
				(iPathPage == 0 ? page.notInprocA : null, EFFlags.NotInProc),
				(iPathPage == 0 ? page.clientAreaA : null, EFFlags.ClientArea),
				(page.menuTooA, EFFlags.MenuToo)
				)) b.AppendOtherArg(s1, (isName && nProp > 0) ? null : "flags");
			
			if (page.alsoA.GetText(out var also)) b.AppendOtherArg(also, "also");
			if (page.skipA.GetText(out var skip)) b.AppendOtherArg(skip, "skip");
			if (page.navigA.GetText(out var navig)) b.AppendStringArg(navig, "navig");
			b.Append(']');
		}
		
		if (isFinder) {
			b.Append(';');
			b.Append(_screenshot);
		} else if (isFindAll) {
			b.Append(".FindAll()").Append(iFindAll switch {
				1 => """
) {
	print.it(e);
}
""",
				2 => """
;
for (int i = 0; i < a.Length; i++) {
	print.it(a[i]);
}
""",
				3 => """

	.Select(o => o.Name).ToArray();
foreach (var v in a) print.it(v);
//for (int i = 0; i < a.Length; i++) print.it(a[i]);
""",
				4 => """

	.Select(o => (name: o.Name, value: o.Value)).ToArray();
foreach (var v in a) print.it(v.name, v.value);
//for (int i = 0; i < a.Length; i++) print.it(a[i].name, a[i].value);
""",
				_ => """
;
for (int ir = 0; ir < rows.Length; ir++) { //for each row
	//if (ir == 0) continue; //header?
	var a = rows[ir].Elm[prop: "level=0"].FindAll(); //cells in this row. You may want to change level or/and use role etc.
	print.it(rows[ir]); print.it(a.Select(o => $"\t{o.Role},  {o.Name,-30},  {o.Rect}")); //debug
	//print.it(a[0].Name, a[1].Name); //example
	//print.it(a[1].Navigate("fi").Name, a[2].Elm["LINK"].Find(0).Name); //examples: get or find an element inside the cell
}
""",
			});
		} else {
			b.Append(test && action.IsFindAll ? ".FindAll(" : ".Find(");
			if (!test && _wait.GetText(out var waitTime, emptyToo: true)) b.AppendWaitTime(waitTime, orThrow); else if (orThrow) b.Append('0');
#if true
			b.Append(");");
			if (!test) b.Append(_screenshot);
			if (isVar && !orThrow) b.Append("\r\nif(e == null) { print.it(\"not found\"); }");
			if (isAction) {
				b.Append("\r\ne");
				if (!orThrow) b.Append('?');
				b.Append('.').Append(_ActionGetCode(test: false)).Append(';');
			}
#else
//rejected: _EOptions.Compact - instead of 2 lines "elm e=find" and "e.Action()" format 1 line "find.Action()".
//	Often I forget to uncheck it and have to edit the code if need with variable. Also then .Action() often is far.

			b.Append(')');
			if (isAction && !isVar) _AppendAction(); else b.Append(';');
			if (!forTest) b.Append(_screenshot);
			if (isVar && !orThrow) b.Append("\r\nif(e == null) { print.it(\"not found\"); }");
			if (isAction && isVar) { b.Append("\r\ne"); _AppendAction(); }

			void _AppendAction() {
				if (!orThrow) b.Append('?');
				b.Append('.').Append(_ActionGetCode(test: false)).Append(';');
			}
#endif
		}
		
		var R = b.ToString();
		
		if (!test) _code.AaSetText(R, wndCode.Lenn());
		
		return (R, wndVar);
	}
	
	#region capture
	
	TUtil.CapturingWithHotkey _capt;
	
	void _InitCapturingWithHotkey() {
		_capt = new(_cCapture,
			_GetCapturingRect,
			new(LA.App.Settings.delm.hk_capture, _Capture),
			new(LA.App.Settings.delm.hk_insert, () => _Insert(hotkey: true)),
			new(LA.App.Settings.delm.hk_smaller, _CaptureSmallerToggle));
		_cCapture.IsChecked = true;
	}
	
	//Called repeatedly while capturing to display rectangles of elements from mouse.
	bool _GetCapturingRect(TUtil.CapturingWithHotkey.GetRectArgs k) {
		//don't show rects when a mouse button is pressed. With some apps then hangs. Eg Word > Insert > Symbol, click a symbol; notinproc too, but not UIA.
		if (mouse.isPressed()) return false;
		
		if (_smaller is { } sm && sm.Window == k.wTL) {
			return sm.GetRect(k);
		}
		
		var p = k.p;
		
		var flags = _GetXYFlags();
		//using var pe1 = perf.local();
		var (e_, w) = _ElmFromPointRaw(p, flags);
		//pe1.Next('e');
		if (e_ == null) return false;
		
		using var e = e_;
		var r = e.Rect;
		//pe1.Next('r');
		
		if (_CaptureSmallerChromeWorkaround(e, w, r)) {
			return _smaller.GetRect(k);
		}
		
		k.resultRect = r;
		k.resultText = e.Role;
		return true;
	}
	
	void _Capture() {
		_ttRecapture?.Close();
		_info.aaaText = _IsAutoTest ? "" : _dialogInfo; //clear error/info from previous test etc. If with auto-test options, make empty to reduce flickering.
		
		if (!_ElmFromPoint(mouse.xy)) return;
		
		_testedAction = _aActions[0];
		_SetElm(true);
		var w = this.Hwnd();
		if (w.IsMinimized) {
			w.ShowNotMinMax();
			w.ActivateL();
		}
	}
	
	EXYFlags _GetXYFlags() {
		var flags = EXYFlags.PreferLink;
		switch (_cUIA.IsChecked) { case true: flags |= EXYFlags.UIA; break; case null: flags |= EXYFlags.OrUIA; break; }
		if (_page != null) {
			if (_page.notInprocA.IsChecked) flags |= EXYFlags.NotInProc;
		}
		return flags;
	}
	
	static EXYFlags _AdjustXYFlagsForWindow(wnd wFP, wnd wTL, EXYFlags flags) {
		if (flags.HasAny(EXYFlags.OrUIA | EXYFlags.UIA)) {
			if (!flags.Has(EXYFlags.UIA)) {
				//UIA was faster by ~20% in all tested Store apps.
				//	Also, MSAA Invoke does not work with many controls, eg in Settings and XAML Gallery. The UIA wrapper tries various patterns (Toggle, Expand, Select) and usually it works.
				//	Also, when eg window minimized, the Store process is suspended, and MSAA hangs when trying to get properties etc; UIA fails immediately (good).
				if (0 != wTL.IsUwpApp || wTL.IsWindows8MetroStyle) return flags | EXYFlags.UIA;
				if (0 != wTL.ClassNameIs(
					"WinUIDesktopWin32WindowClass", //WinUI (UIA faster/better). Eg WinUI3 Gallery, Microsoft PowerToys.
					"GlassWndClass*" //JavaFX (no MSAA)
					)) return flags | EXYFlags.UIA;
				
				if (!wTL.Child(cn: "Windows.UI.Input.InputSite.WindowClass", flags: WCFlags.HiddenToo).Is0) return flags | EXYFlags.UIA; //eg Win11 taskbar, terminal, taskmanager. MSAA bug: intermediate hidden child window; from-point API does not work; for find/enum may need hiddentoo flag.
				if (wFP != wTL) { //maybe need UIA flag only for part of window, eg Win11 explorer's ribbon. With UIA much slower to find.
					if (wFP.ClassNameIs("Microsoft.UI.Content.DesktopChildSiteBridge")) flags |= EXYFlags.UIA; //eg Win11 mspaint, explorer's ribbon, notepad. No MSAA.
				}
			}
			if (!flags.Has(EXYFlags.NotInProc)) {
				if (wTL.ClassNameIs("Notepad") && osVersion.minWin11) return flags | EXYFlags.UIA | EXYFlags.NotInProc; //need uia, but then inproc very slow find/enum
			}
		}
		return flags;
	}
	
	static (elm e, wnd w) _ElmFromPointRaw(POINT p, EXYFlags flags) {
		wnd w = default;
		elm e = elm.fromXY_(p, flags, (flags, wFP, wTL) => {
			w = wTL;
			return _AdjustXYFlagsForWindow(wFP, wTL, flags);
		});
		return (e, w);
	}
	
	//Called only when capturing, not to display rectangles of elements from mouse.
	bool _ElmFromPoint(POINT p, bool ctor = false) {
		_capturingMenu?.Close();
		
		var flags = _GetXYFlags();
		
		var a = _smaller is { } sm && sm.Window == wnd.fromXY(p, WXYFlags.NeedWindow)
			? sm.GetElm(p)
			: _GetElm(p, flags, ctor);
		if (a.NE_()) return false;
		var e = a[0];
		
		_screenshot = TUtil.MakeScreenshot(p, _capt);
		
		if (a.Length > 1) {
			var m = new popupMenu();
			for (int i = 0; i < a.Length;) {
				var v = a[i++];
				var s = v.role.NullIfEmpty_() ?? i.ToS();
				s = $"&{i}. {s}";
				var mi = m.Add(i, s);
				mi.Tooltip = v.tt;
				mi.Tag = v.rect;
			}
			_capturingMenu = m;
			int k = _ShowMenu(m, e.rect, osd: true) - 1;
			_capturingMenu = null;
			if (k < 0) return false;
			
			//some objects become invalid while showing the menu (or in any case when mouse moved out). Eg STATICTEXT in icons in VSCode left toolbar.
			while (!a[k].e.GetRect(out _, raw: true)) if (++k == a.Length) return false;
			
			e = a[k];
		}
		
		//set x y field always, not only when a mouse action selected, because may select a mouse action afterwards
		_noeventValueChanged++;
		_xy.t.Text = $"{p.x - e.rect.left}, {p.y - e.rect.top}";
		_noeventValueChanged--;
		
		_elm = e.e;
		return true;
		
		_CapturedElm[] _GetElm(POINT p, EXYFlags flags, bool ctor) {
			if (ctor) {
				//workaround for: Chrome may give wrong element at first. Eg youtube right list -> "x months ago".
				//	Possibly this can be useful with some other apps too.
				//	If not ctor, capturing works well because _ElmFromPointRaw is called to display element rectangles.
				//	Even with this delay, may be no HTML attributes at first. Never mind.
				_ElmFromPointRaw(p, flags);
				100.ms();
			}
			
			var (e, w) = _ElmFromPointRaw(p, flags);
			if (!uacInfo.isAdmin && w.UacAccessDenied) print.warning("The target process is admin; this process isn't. Can't use its UI elements.", -1); //not _info.InfoError, it's unreliable here, even with timer
			if (e == null) return null;
			
			//the same workaround as in _GetCapturingRect
			if (ctor && _CaptureSmallerChromeWorkaround(e, w)) {
				return _smaller.GetElm(p);
			}
			
			//If e probably does not support Invoke or Focus, show menu with e and the first ancestor that supports it.
			//	In some cases use the ancestor without a menu (if LINK or BUTTON etc).
			//	This code is similar to the C++ code in _FromPoint_GetLink, but covers more cases.
			//	Cannot show menu in this thread. Pass e2 and strings to the UI thread, let it show menu if e2 not null.
			elm e2 = null; string tt1 = null, tt2 = null;
			if (!e.MiscFlags.HasAny(EMiscFlags.UIA | EMiscFlags.Java)) { //TODO3: UIA too
				if (!_IsInteractive(e, true, out bool stop1) && !stop1) {
					bool found = false;
					tt1 = "This element probably does not support Invoke or Focus";
					tt2 = "This parent element probably supports Invoke";
					elm ep = e.Parent, ep0 = ep;
					for (int i = 20; i-- > 0 && ep != null; ep = ep.Parent) {
						if ((found = _IsInteractive(ep, false, out bool stop2)) || stop2) break;
						//print.it(ep.ChildCount);
						i -= ep.ChildCount; //sometimes the subtree is <div><div><div>..., 1-2 children at every level
					}
					if (!found && ep != null && e.MiscFlags.Has(EMiscFlags.InProc)) { //detect when e is not a child of its parent
						var ee = ep0.Elm[e.Role, prop: $"level=0\0rect={e.RectRawDpi_}", flags: EFFlags.MenuToo].Find();
						//print.it(ee);
						if (found = ee == null) {
							Debug_.Print("e is not a child of its parent: " + e);
							ep = ep0;
							tt1 = "Possibly disconnected from the tree";
							tt2 = "Parent element";
						}
					}
					if (found && ep.Name.NE() && !e.Name.NE()) found = false;
					if (found && ep.WndContainer.Is0) found = false; //see bug comment in C++
					if (found) {
						bool use = _RoleIsLinkOrButton(ep.RoleInt)
							//|| role ERole.MENUITEM //will need EFFlags.MenuToo. But then cannot capture child elements in some menu items, and cannot select in tree because it closes the menu.
							;
						if (use) e = ep; else e2 = ep;
					}
				} else if (!stop1) {
					//is in COMBOBOX?
					if (e.RoleInt is ERole.TEXT or ERole.BUTTON && e.Parent is elm ep) {
						var r1 = ep.RoleInt;
						if (r1 == ERole.COMBOBOX || (r1 == ERole.WINDOW && ((ep = ep.Parent)?.RoleInt ?? 0) == ERole.COMBOBOX)) e2 = ep;
					}
				}
				
				static bool _IsInteractive(elm e, bool orig, out bool stop) {
					stop = false;
					if (e.Item != 0) return true;
					var role = e.RoleInt;
					if (_RoleIsLinkOrButton(role)) return true;
					if (stop = role is ERole.WINDOW or ERole.DOCUMENT or ERole.PROPERTYPAGE or ERole.PAGETABLIST
						or ERole.TABLE or ERole.LIST or ERole.TREE
						//or ERole.CLIENT or ERole.PANE //no, sometimes used for "no role" elements
						or ERole.DIALOG //action="OK"
						) return false;
					if (stop = role == ERole.PAGETAB) if (e.ChildCount > 2) return false; /*PAGETAB can be used either as button (eg in web browsers) or as button + page with all controls (eg WPF tab control)*/
					//if static text or image, even if has action, it may just throw "not implemented". Noticed in Firefox somewhere.
					if (role is ERole.STATICTEXT or ERole.IMAGE
						or ERole.DIAGRAM //IMAGE in Firefox
						or ERole.GROUPING //often has action, but rarely useful
						) return false;
					var state = e.State;
					if (state.Has(EState.FOCUSABLE)) return true; //eg editable TEXT. It could be eg in a WPF EXPANDER with action. Not in 'if (orig)' because eg TEXT may have children.
					if (orig) {
						if (role == ERole.TEXT) return state.Has(EState.DISABLED); //probably TEXT used instead of STATICTEXT, eg in Firefox
					} else if (state.Has(EState.INVISIBLE)) return false;
					return e.DefaultAction is not (null or "" or "click ancestor" /*Chrome*/ or "Collapse" /*WPF expander*/);
				}
			}
			
			if (e2 == null) return [new(e, null, null, e.Rect)];
			return [new(e, e.Role, tt1, e.Rect), new(e2, e2.Role, tt2, e2.Rect)];
		}
	}
	bool _waitAutoCheckedOnce; //if user unchecks, don't check next time
	popupMenu _capturingMenu;
	
	record class _CapturedElm(elm e, string role, string tt, RECT rect);
	
	class _CaptureSmaller {
		Delm _d;
		wnd _w;
		(elm e, RECT rect)[] _a;
		long _timeUpdated, _updatePeriod;
		
		public _CaptureSmaller(Delm d, wnd w) {
			_d = d;
			_w = w;
		}
		
		public wnd Window => _w;
		
		public bool Update() {
			if (_d._capturingMenu != null || _d._actionMenu != null) return false;
			
			EFFlags flags = 0;
			if (_d._page is { } page) {
				if (page.notInprocA.IsChecked) flags |= EFFlags.NotInProc;
				if (page.hiddenTooA.IsChecked) flags |= EFFlags.HiddenToo;
			}
			EXYFlags xyFlags = _AdjustXYFlagsForWindow(wnd.fromMouse(WXYFlags.Raw), _w, _d._GetXYFlags());
			if (xyFlags.Has(EXYFlags.UIA)) flags |= EFFlags.UIA;
			if (xyFlags.Has(EXYFlags.NotInProc)) flags |= EFFlags.NotInProc;
			
			_timeUpdated = long.MaxValue;
			try {
				var aOld = _a;
				long t1 = Environment.TickCount64;
				_a = elmFinder.GetAllWithRect_(_w, flags).ToArray();
				long t2 = Environment.TickCount64;
				long t3 = t2 - t1;
				
				if (t3 < 3000) (_timeUpdated, _updatePeriod) = (t2, 2000 + t3 * 2);
				
				//Release old COM objects.
				//	Old test results, now can't repro:
				//		Else may become slower, and the target process memory grows, until next GC.
				//		Eg Chrome the "get all" time normally is ~32 ms, but without this grows until 80-120 ms.
				if (aOld != null) Task.Delay(1000).ContinueWith(t => { GC.Collect(); });
				
				//rejected: auto switch to UIA when need. Eg if CLIENT empty.
				//	Difficult to reliably detect whether it's better.
				//	Anyway does not improve all cases. Eg when need UIA only for a single child window, eg HtmlHelp tree.
			}
			catch (Exception e1) { Debug_.Print(e1); return false; }
			
			//Task.Run(() => { using (osdText.showTransparentText("updated", 1, PopupXY.Mouse)) 500.ms(); });
			return true;
		}
		
		public bool GetRect(TUtil.CapturingWithHotkey.GetRectArgs k) {
			long timeNow = Environment.TickCount64;
			bool update = timeNow - _timeUpdated >= _updatePeriod;
			if (!update) {
				long liTime = Api.GetLastInputTime();
				update = liTime > _timeUpdated && timeNow - liTime > 600;
			}
			if (update) Update();
			
			var a = GetElm(k.p);
			if (a.Length == 0) return false;
			k.resultRect = a[0].rect;
			k.resultText = a[0].role + " *";
			return true;
		}
		
		public _CapturedElm[] GetElm(POINT p) {
			//get objects whose rect contains p. Get only tree leaves.
			List<_CapturedElm> r = [];
			int skipLevel = 0;
			for (int i = _a.Length; --i >= 0;) {
				int level = _a[i].e.Level;
				if (level < skipLevel) { skipLevel = level; continue; }
				if (_a[i].rect.Contains(p)) {
					r.Add(new(_a[i].e, _a[i].e.Role, null, _a[i].rect));
					skipLevel = level;
				}
			}
			if (r.Count == 0) return [];
			if (r.Count == 1) return [r[0]];
			var a = r.OrderBy(o => o.rect.NoArea ? long.MaxValue : o.rect.Area_).ToArray();
			return a;
		}
	}
	_CaptureSmaller _smaller;
	wnd _noAutoSmaller;
	
	void _CaptureSmallerToggle() {
		var w = wnd.fromMouse(WXYFlags.NeedWindow);
		//var w = wnd.fromMouse(); //no, it can be a ghost child window. Eg "Intermediate D3D Window" in Chrome; GetAll hangs if UIA.
		
		if (w.IsOfThisThread) {
			dialog.showInfo(null, "Use this hotkey when the mouse is in the window where you want to capture an element.", flags: DFlags.CenterMouse, owner: this);
			return;
		}
		
		_CaptureSmallerToggle(w);
	}
	
	void _CaptureSmallerToggle(wnd w) {
		bool smaller = _smaller?.Window == w;
		smaller = !smaller && !w.Is0;
		_smaller = null;
		
		if (smaller) {
			var sm = new _CaptureSmaller(this, w);
			if (sm.Update()) _smaller = sm; else smaller = false;
		} else {
			_noAutoSmaller = w;
		}
		
		osdText.showText(smaller ? "Using alternative elm capturing method in this window" : "Using default elm capturing method", smaller ? 3 : 2, PopupXY.Mouse);
	}
	
	//workaround for Chromium bug (now fixed in browsers): can't capture links etc in acc mode.
	//	On mouse-move over a link, Chrome shows the URL at the bottom. While the URL is visible, acc elm-from-point API doesn't work.
	//	Similar in some other cases, eg when shows a tab thumbnail. Then uia API don't work too (never mind).
	//	In next Chrome and Edge version they restored the old element-from-point behavior: acc OK, UIA dead in Chrome.
	//	Still need this for VSCode (2025-09-27); for any element, not just links.
	bool _CaptureSmallerChromeWorkaround(elm e, wnd w, RECT? rIfHave = null) {
		if (w == _noAutoSmaller) return false;
		if (e == null || (e.MiscFlags & (EMiscFlags.InProc | EMiscFlags.UIA | EMiscFlags.Java)) != EMiscFlags.InProc) return false;
		if (e.RoleInt_ is ERole.PANE && w.ClassNameIs("Chrome_WidgetWin_1")) {
			var r = rIfHave ?? e.Rect;
			if (r == w.ClientRectInScreen) {
				_CaptureSmallerToggle(w);
				return _smaller != null;
			}
		}
		return false;
		
		//CONSIDER: auto-switch to smaller mode in any window. Or just inform about it. To detect:
		//	If acc rect == window rect or control rect (client):
		//	Enum direct acc children to find one at that point. If found, switch.
		//	Can detect it in C++ acc-from-point code and return a flag "has a child at that point". Then in the role tooltip display "ROLE (Shift+F3 to show smaller elements)".
		
		//[old] rejected: if big etc, inform about 'Smaller'
		//if (r.Width * r.Height > 5000) {
		//	var ri = e.RoleInt;
		//	if (!(_RoleIsLinkOrButton(ri) || ri is ERole.Custom or ERole.TEXT or ERole.STATICTEXT or ERole.IMAGE or ERole.DIAGRAM)) {
		//		int wid = (int)Dpi.Unscale(r.Width, r), hei = Math2.MulDiv(r.Height, wid, r.Width);
		//		//print.it(wid, hei, wid * hei);
		//		bool big = wid * hei > 10000;
		//		if (!big && !m.flags.Has(EXYFlags.UIA)) {
		//			var ee = _ElmFromPointRaw(m.p, m.flags | EXYFlags.UIA);
		//			if (ee != null && ee.RoleInt != ri) {
		//				var rr = ee.Rect;
		//				if (rr.Width * rr.Height < r.Width * r.Height / 2) big = true;
		//			}
		//		}
		//		if (big) s += "\nTry the hotkey";
		//	}
		//}
	}
	
	#endregion
	
	#region Insert, Test
	
	///// <summary>
	///// When OK clicked, contains C# code. Else null.
	///// </summary>
	//public string aaResultCode { get; private set; }
	
	void _Insert(bool hotkey) {
		if (_close && !hotkey) {
			base.Close();
		} else if (_code.aaaText.NullIfEmpty_() is string s) {
			if (_Opt.Has(_EOptions.Activate) && !_wndNoActivate && !_CurrentAction.IsFinder) {
				s = s.RxReplace(@"^.+?\bwnd\.find\(.+[^(]\)\K;\r", ".Activate();\r", 1);
			}
			
			(string oldName, string newName)[] rename_e = null;
			if (_Opt.Has(_EOptions.VarRole) && !(_CurrentAction.IsFinder || _CurrentAction.IsFindAll)) {
				if (s.RxMatch(@"(?m)^var e = w\.Elm\[""(?:[a-z]+:)?([a-zA-Z][\w ]+\w)""", out var m)) rename_e = [("e", m[1].Value.Lower().Replace(' ', '_'))];
			}
			
			LA.InsertCode.Statements(new(s, makeVarName1: true, renameVars: rename_e));
			if (!hotkey) {
				_close = true;
				_bInsert.Content = "Close";
				_bInsert.MouseLeave += (_, _) => {
					_close = !true;
					_bInsert.Content = "Insert";
				};
			}
		}
	}
	bool _close;
	
	void _Test(bool captured = false, bool testAction = false, bool actWin = false) {
		if (_page == null) return;
		
		var (code, wndVar) = _FormatCode(true); if (code.NE()) return;
		var elmSelected = _page == _commonPage ? _elm : _path[^1].ti.e;
		
		if (testAction) testAction = !_CurrentAction.NoTest;
		bool autoInsert = captured && _cAutoInsert.IsChecked;
		
		_testing = true;
		var restoreOwner = new int[1];
		try {
			elmFinder.t_navigResult = (true, null, null);
			var rr = TUtil.RunTestFindObject(this.Hwnd(), code, wndVar, _WndSearchIn, o => (o as elm).Rect, actWin, restoreOwner, this.Dispatcher);
			elm elmFound = rr.obj as elm, elmFoundBN = null;
			//need elm found before navig
			if (elmFound != null) elmFoundBN = elmFinder.t_navigResult.after == elmFound ? elmFinder.t_navigResult.before : elmFound;
			elmFinder.t_navigResult = default;
			bool bad = false;
			if (elmFound != null) {
				RECT r1 = elmFoundBN.Rect, r2 = elmSelected.Rect;
				//print.it(r1, r2); //in DPI-scaled windows can be slightly different if different inproc of elmSelected and elmFoundBN. Would be completely different if using raw rect.
				int diff = elmFoundBN.MiscFlags.Has(EMiscFlags.InProc) == elmSelected.MiscFlags.Has(EMiscFlags.InProc) ? 0 : 2;
				bad = (!RECT.EqualFuzzy_(r1, r2, diff) || elmFoundBN.Role != elmSelected.Role);
			}
			
			if (elmFound == null) {
				string osd;
				if (rr.info == null) _info.InfoError(osd = "Timeout", "Not found in 10 s.");
				else if (rr.speed < 0) { //error
					_info.InfoErrorOrInfo(rr.info);
					osd = rr.info.header;
				} else { //not found
					osd = "Not found";
					string s2 = "Try: check <b>Find hidden too<>; check/uncheck/edit other controls.";
					int n = _page.maxccA.GetText(out _) ? 0 : (_elm.Parent?.ChildCount ?? 0);
					if (n > 10000) { //never mind: may be an indirect ancestor. Rare.
						s2 = $"The parent element has {n} children. Need to specify maxcc.";
					} else {
						if (_PathIsIntermediate()) s2 += "\r\nTry <b>skip<> -1 to search for next path element in all matching intermediate elements.";
						if (_page.navigA.GetText(out _)) s2 += "\r\nTry <b>skip<> -1 to retry failed <b>navig<>ation with all matching intermediate elements.";
						if (!_wnd.IsActive) {
							if (_page.actionA.GetText(out _)) s2 += "\r\nNote: <b>action<> often is unavailable in inactive window.";
							if (_page.keyA.GetText(out _)) s2 += "\r\nNote: <b>key<> sometimes is unavailable in inactive window.";
							if (_page.stateA.GetText(out _)) s2 += "\r\nNote: <b>state<> often is different in inactive window.";
							s2 += "\r\n<+actTest>Activate window and test find<>";
						}
					}
					_info.InfoError("Not found", s2, rr.info.headerSmall);
				}
				_Osd(osd, true);
				return;
			}
			if (bad && !_CurrentAction.IsFindAll) {
				var s2 = "Try: <b>Add to path<> or/and <b>skip<>; check/uncheck/edit other controls.\r\nIf this element cannot be uniquely identified (no name etc), try another element and use <b>navig<>.";
				if (_PathIsIntermediate()) s2 += "\r\nTry <b>skip<> -1 to search for next path element in all matching intermediate elements.";
				string s1 = "Found wrong element";
				_info.InfoError(s1, s2, rr.info.headerSmall);
				_Osd(s1, true);
				return;
			}
			_info.InfoErrorOrInfo(rr.info);
			
			//if (quickOK && r.speed < 1_000_000) {
			//	//timer.after(1000, _ => _bOK.RaiseEvent(new RoutedEventArgs(ButtonBase.ClickEvent)));
			//	return;
			//}
			
			if (testAction) {
				string aCode = _ActionGetCode(test: true);
				if (aCode != null) {
					Api.AllowSetForegroundWindow();
					var re = TUtil.RunTestAction(elmFound, aCode);
					if (re != null) {
						_info.InfoErrorOrInfo(re);
						_Osd(re.header, true);
						return;
					}
					restoreOwner[0] = 1000;
				}
			}
			
			if (autoInsert) {
				_Insert(hotkey: true);
				_Osd("Inserted", false);
			}
		}
		finally {
			if (restoreOwner[0] == 0) restoreOwner[0] = 1;
			_testing = false;
		}
		
		void _Osd(string s, bool error) {
			if (!captured) return;
			osdText.showTransparentText(s, 2, PopupXY.Mouse, error ? 0xFF6040 : 0x00C000, showMode: OsdMode.ThisThread);
		}
	}
	bool _testing;
	
	bool _IsAutoTest => _Opt.HasAny(_EOptions.AutoTest) || _cAutoTestAction.IsChecked || _cAutoInsert.IsChecked;
	
	void _bTest_ContextMenuOpening(object sender, ContextMenuEventArgs e) {
		var m = new popupMenu();
		//bool isAction = _page != null && _ActionCanTest();
		//m["Test action", disable: !isAction] = _ => _Test(testAction: true);
		//m["Activate window and test action", disable: !isAction] = _ => _Test(testAction: true, actWin: true);
		//m["Activate window and test find", disable: _page == null] = _ => _Test(actWin: true);
		m["Activate window and test", disable: _page == null] = _ => _Test(actWin: true);
		m.Show(owner: this);
	}
	
	#endregion
	
	#region tree
	
	_TreeItem _treeRoot;
	//_TreeItem _nodeCaptured;
	bool _isWebIE; //_FillProperties sets it; then _FillTree uses it.
	
	void _InitTree() {
		_tree.SingleClickActivate = true;
		_tree.ItemActivated += e => _ItemActivated(e.Item as _TreeItem);
		
		void _ItemActivated(_TreeItem ti) {
			_elm = ti.e;
			//_screenshot = null;
			_SetWndCon(_wnd, _elm.WndContainer, _useCon);
			if (!_PathSetPageWhenTreeItemSelected(ti)) {
				if (!_FillProperties(out _)) return;
			}
			_FormatCode();
			TUtil.ShowOsdRect(_elm.Rect);
		}
		
		_tree.ItemClick += e => {
			if (e.Button == MouseButton.Right) {
				var ti = e.Item as _TreeItem;
				var m = new popupMenu();
				m["Navigate to this from the selected", disable: ti == _tree.SelectedItem] = _ => _NavigateTo(ti);
				if (!_path.NE_() && !_path.Any(o => o.ti == ti)) {
					m["Navigate to this from the last in path"] = _ => {
						var tiPath = _path[^1].ti;
						_tree.SelectSingle(tiPath);
						_ItemActivated(tiPath);
						_NavigateTo(ti);
					};
				}
				m.Show(owner: this);
			}
		};
	}
	
	void _ClearTree() {
		_tree.SetItems(null);
		_treeRoot = null;
		_PathClear();
	}
	
	(_TreeItem xRoot, _TreeItem xSelect) _CreateTreeModel(wnd w, EProperties p, bool skipWINDOW) {
		EFFlags flags = Enum_.EFFlags_Mark | EFFlags.HiddenToo | EFFlags.MenuToo;
		if (_page.uiaA.IsChecked) flags |= EFFlags.UIA;
		if (!_elm.MiscFlags.Has(EMiscFlags.InProc)) flags |= EFFlags.NotInProc; //if captured notinproc in DPI-scaled, would fail to select in tree if tree elems retrieved inproc, because would compare with non-scaled rects
		
		var us = (uint)p.State;
		var prop = $"rect={p.Rect}\0state=0x{us:X},!0x{~us:X}";
		if (skipWINDOW) prop += $"\0notin=WINDOW";
		var role = p.Role.NullIfEmpty_();
		
		_TreeItem xRoot = new(this), xSelect = null;
		var stack = new Stack<_TreeItem>(); stack.Push(xRoot);
		int level = 0;
		
		try {
			w.Elm[role, "**tc " + p.Name, prop, flags, also: o => {
				_TreeItem x = new(this);
				int lev = o.Level;
				if (lev != level) {
					if (lev > level) {
						Debug.Assert(lev - level == 1);
						stack.Push(stack.Peek().LastChild);
					} else {
						while (level-- > lev) stack.Pop();
					}
					level = lev;
				}
				x.e = o;
				if (o.MiscFlags.Has(Enum_.EMiscFlags_Marked)) {
					if (xSelect == null) xSelect = x;
				}
				stack.Peek().AddChild(x);
				return false;
			}
			].Exists();
			
			return (xRoot, xSelect);
		}
		catch (Exception ex) {
			_info.InfoError("Failed to get UI element tree.", ex.Message);
			return default;
		}
	}
	
	void _FillTree(EProperties p) {
		Debug.Assert(_treeRoot == null); Debug.Assert(_path == null); //_ClearTree must be called before
		
		var w = _WndSearchIn;
		if (_isWebIE && !_useCon && !_con.Is0) w = _con; //if IE, don't display whole tree. Could be very slow, because cannot use in-proc for web pages (and there may be many tabs with large pages), because its control is in other thread.
		var (xRoot, xSelect) = _CreateTreeModel(w, p, false);
		if (xRoot == null) return;
		
		if (xSelect == null && w.IsAlive) {
			//IAccessible of some controls are not connected to the parent.
			//	Also, WndContainer then may get the top-level window.
			//	Workaround: enum child controls and look for _elm in one them. Then add "class" row if need.
			Debug_.Print("broken IAccessible branch");
			foreach (var c in w.Get.Children(onlyVisible: true)) {
				var m = _CreateTreeModel(c, p, true);
				if (m.xSelect != null) {
					//m.xRoot.a = elm.fromWindow(c, flags: EWFlags.NoThrow);
					//if(m.xRoot.a != null) model.xRoot.Add(m.xRoot);
					//else model.xRoot = m.xRoot;
					(xRoot, xSelect) = m;
					if (!_page.classA.Visible) {
						_page.classA.t.Text = TUtil.StripWndClassName(c.ClassName, true);
						_page.classA.c.IsChecked = true;
						_page.classA.Visible = true;
					}
					break;
				}
			}
		}
		
		_tree.SetItems(xRoot.Children());
		_treeRoot = xRoot;
		if (xSelect != null) _SelectTreeItem(xSelect);
		
		GC.Collect(1); //release old COM objects. Else may become slower.
	}
	
	void _SelectTreeItem(_TreeItem x) {
		_tree.SelectSingle(x);
	}
	
	//Tries to find and select _elm in current tree when captured from same window.
	//Usually faster than recreating tree, but in some cases can be slower. Slower when fails to find.
	bool _TrySelectInSameTree(out _TreeItem ti) {
		ti = null;
		if (_treeRoot == null) return false;
		var a = _treeRoot.Descendants().ToArray();
		if (a.Length == 0) return false;
		
		if (_elm.MiscFlags.Has(EMiscFlags.UIA) != _page.uiaA.IsChecked //different tree
			|| _elm.MiscFlags.Has(EMiscFlags.InProc) != a[0].e.MiscFlags.Has(EMiscFlags.InProc) //different rects if DPI-scaled window
			) {
			_ClearTree();
			return false;
		}
		
		ti = _Find(_elm, a);
		static _TreeItem _Find(elm e, _TreeItem[] a) {
			if (!e.GetProperties("rn", out var p)) return null;
			int item = e.Item;
			var ri = e.RoleInt;
			string rs = ri == ERole.Custom ? e.Role : null;
			//CONSIDER: to make faster, run all this code inproc. Or at least switch context once for each element.
			foreach (var v in a) {
				e = v.e;
				if (e.Item != item) continue;
				if (e.RoleInt != ri) continue;
				if (rs != null && e.Role != rs) continue;
				if (!e.GetRect(out var rr, raw: true) || rr != p.Rect) continue;
				if (e.Name != p.Name) continue;
				return v;
			}
			return null;
		}
		
		if (ti != null) _SelectTreeItem(ti);
		else Debug_.Print("recreating tree of same window");
		return ti != null;
		
		//Other ways to compare elm:
		//IAccIdentity. Unavailable in web pages.
		//IUIAutomationElement. Very slow ElementFromIAccessible. In Firefox can be 30 ms.
	}
	
	class _TreeItem : TreeBase<_TreeItem>, ITreeViewItem {
		readonly Delm _dlg;
		public elm e;
		string _displayText;
		bool _isFailed;
		bool _isInvisible;
		bool _isExpanded;
		
		public _TreeItem(Delm dlg) {
			_dlg = dlg;
		}
		
		#region ITreeViewItem
		
		string ITreeViewItem.DisplayText {
			get {
				if (_displayText == null) {
					bool isWINDOW = e.RoleInt == ERole.WINDOW;
					string props = isWINDOW ? "Rnsw" : "Rns";
					if (!e.GetProperties(props, out var p)) {
						_displayText = "Failed: " + lastError.message;
						(_isInvisible, _isFailed) = (false, true);
					} else {
						if (isWINDOW) {
							using (new StringBuilder_(out var b)) {
								b.Append(p.Role).Append("  (").Append(p.WndContainer.ClassName).Append(')');
								if (p.Name.Length > 0) b.Append("  \"").Append(p.Name).Append('"');
								_displayText = b.ToString();
							}
						} else if (p.Name.Length == 0) {
							_displayText = p.Role;
						} else {
							_displayText = p.Role + " \"" + p.Name.Escape(limit: 250) + "\"";
						}
						(_isInvisible, _isFailed) = (e.IsInvisible_(p.State), false);
					}
				}
				return _displayText;
			}
		}
		
		void ITreeViewItem.SetIsExpanded(bool yes) { _isExpanded = yes; }
		
		bool ITreeViewItem.IsExpanded => _isExpanded;
		
		IEnumerable<ITreeViewItem> ITreeViewItem.Items => base.Children();
		
		bool ITreeViewItem.IsFolder => _IsFolder;
		bool _IsFolder => base.HasChildren;
		
		object ITreeViewItem.Image => _IsFolder ? LA.EdIcons.FolderArrow(_isExpanded) : null;
		
		int ITreeViewItem.TextColor(TVColorInfo ci)
			=> _isFailed ? 0xff0000
			: _isInvisible ? ColorInt.SwapRB(Api.GetSysColor(Api.COLOR_GRAYTEXT))
			: -1;
		
		int ITreeViewItem.BorderColor(TVColorInfo ci)
			=> _dlg._PathFind(this) >= 0 ? 0x00C000 : -1;
		
		#endregion
	}
	
	#endregion
	
	#region path
	
	List<(_TreeItem ti, _PropPage page)> _path;
	
	void _PathAddRemove() {
		if (_tree.SelectedItem is not _TreeItem ti) return;
		bool add = _page.inPath.IsChecked;
		if (add) {
			if (_path == null) {
				_path = new() { (ti, _commonPage) };
			} else {
				//find index where to insert
				int i = -1;
				foreach (var v in ti.Ancestors()) if (v == _path[^1].ti) { i = _path.Count; break; } //is ti after current path?
				if (i < 0) { //is ti before current path?
					for (int j = 0; j < _path.Count; j++) {
						if (_path[j].ti.Ancestors().Contains(ti)) { i = j; break; }
					}
				}
				if (i < 0) { //isn't straight path. Eg the user wants to use navig.
					if (!dialog.showInputNumber(out i, "Index in path", "This element isn't an ancestor or descendant of a path element,\r\ntherefore its index in path cannot be determined automatically.\r\n\r\n0-based index:", 0, owner: this)) {
						_page.inPath.IsChecked = false;
						return;
					}
					i = Math.Clamp(i, 0, _path.Count);
				}
				_path.Insert(i, (ti, _commonPage));
			}
			_page = _commonPage;
			_commonPage = null;
			_page.ti = ti;
		} else {
			int i = _PathFind(ti); if (i < 0) return;
			if (_path.Count > 1) _path.RemoveAt(i); else _path = null;
			_page.ti = null;
			_commonPage = _page;
		}
		
		_tree.Redraw();
		//then _FormatCode will be called
	}
	
	bool _PathSetPageWhenTreeItemSelected(_TreeItem ti) {
		//print.it(ti.e);
		if (_path == null || _page == null) return false;
		if (_page.ti == ti) return false;
		int i = _PathFind(ti);
		_page = i < 0 ? _commonPage : _path[i].page;
		if (i >= 0) _pageBorder.Child = _page.panel;
		return i >= 0;
	}
	
	int _PathFind(_TreeItem ti) {
		if (_path != null) {
			for (int i = 0; i < _path.Count; i++) if (_path[i].ti == ti) return i;
		}
		return -1;
	}
	
	bool _PathIsIntermediate() {
		if (_path == null || _page == null) return false;
		return (uint)_PathFind(_page.ti) < _path.Count - 1;
	}
	
	//int _PathFind() {
	//	if (_path != null && _tree.SelectedItem is _TreeItem ti) return _PathFind(ti);
	//	return -1;
	//}
	
	void _PathClear() {
		if (_path == null) return;
		if (_page?.ti != null) {
			_page.ti = null;
			using var nevc = new _NoeventValueChanged(this);
			_page.inPath.IsChecked = false;
			_commonPage = _page;
		}
		_path = null;
	}
	
	#endregion
	
	#region action
	
	const string c_actions = """
No action
Invoke | Invoke()
WebInvoke | WebInvoke()
Mouse
	Mouse click | MouseClick(%)
	Mouse 2*click | MouseClickD(%)
	Mouse right click | MouseClickR(%)
	Mouse move | MouseMove(%)
	-
	Post click | PostClick(%)
	Post 2*click | PostClickD(%)
	Post right click | PostClickR(%)
Keys, text
	Send keys | SendKeys("")
	Replace text | SendKeys("Ctrl+A", "!text")
	Append text | SendKeys("Ctrl+End", "!text")
	-
	Click, send keys | MouseClick(); keys.send("")
	Click, replace text | MouseClick(); keys.send("Ctrl+A", "!text")
	Click, append text | MouseClick(); keys.send("Ctrl+End", "!text")
Focus, select
	Focus | Focus()
	Select | Select()
	Select and focus | Focus(true)
Check
	Check | Check(true)
	Check (keys) | Check(true, "")
	Check (click) | Check(true, e => e.MouseClick(%))
	Check (post) | Check(true, e => e.PostClick(%))
	-
	Uncheck | Check(false)
	Uncheck (keys) | Check(false, "")
	Uncheck (click) | Check(false, e => e.MouseClick(%))
	Uncheck (post) | Check(false, e => e.PostClick(%))
ComboSelect
	ComboSelect | ComboSelect(^)
	ComboSelect (invoke) | ComboSelect(^, "i")
	ComboSelect (keys) | ComboSelect(^, "k")
	ComboSelect (mouse) | ComboSelect(^, "m")
	Item... | #cs
Expand
	Expand | Expand(true)
	Expand (keys) | Expand(true, "")
	Expand (click) | Expand(true, e => e.MouseClick(%))
	Expand (2*click) | Expand(true, e => e.MouseClickD(%))
	Expand (post) | Expand(true, e => e.PostClick(%))
	Expand (2*post) | Expand(true, e => e.PostClickD(%))
	Path... | #ep
	-
	Collapse | Expand(false)
	Collapse (keys) | Expand(false, "")
	Collapse (click) | Expand(false, e => e.MouseClick(%))
	Collapse (2*click) | Expand(false, e => e.MouseClickD(%))
	Collapse (post) | Expand(false, e => e.PostClick(%))
	Collapse (2*post) | Expand(false, e => e.PostClickD(%))
ScrollTo | ScrollTo()
WaitFor | WaitFor(0, o => !o.IsDisabled) | 1
-
FindAll
	FindAll, foreach || 3
	FindAll, for || 3
	FindAll, Select || 3
	FindAll, Select 2 || 3
	FindAll, table || 3
	-
	Help - table | ?table | 3
new elmFinder || 5
""";
	
	record class _Action(string name, string code, int _flags, bool isSubmenu, bool inSubmenu, bool separatorBefore, bool isNone) {
		public bool NoTest => 0 != (_flags & 1);
		public bool IsFindAll => 0 != (_flags & 2);
		public bool IsFinder => 0 != (_flags & 4);
		public bool IsMouse => code?.Contains('%') == true;
	}
	
	List<_Action> _aActions; //for menu
	_Action _selectedAction, _testedAction;
	
	_Action _CurrentAction => !_selectedAction.isNone ? _selectedAction : _testedAction;
	
	_Action _ActionFind(string name) => _aActions.FirstOrDefault(o => o.name == name && !o.isSubmenu) ?? _aActions[0];
	
	void _ActionInit() {
		_cbAction.Items.Add("");
		_cbAction.DropDownOpened += (o, e) => {
			_cbAction.IsDropDownOpen = false;
			_ActionMenu(false);
		};
		
		_aActions = new();
		var a = c_actions.Lines();
		bool separatorBefore = false;
		for (int i = 0; i < a.Length; i++) {
			var k = a[i].Split('|', StringSplitOptions.TrimEntries);
			var name = k[0];
			bool inSubmenu = a[i][0] == '\t';
			if (k.Length == 1) {
				if (name == "-") { separatorBefore = true; continue; }
				var x = new _Action(name, null, 0, i > 0, false, separatorBefore, i == 0);
				_aActions.Add(x);
			} else {
				var x = new _Action(name, k[1], k.Length < 3 ? 0 : k[2].ToInt(), false, inSubmenu, separatorBefore, false);
				_aActions.Add(x);
			}
			separatorBefore = false;
		}
		
		_testedAction = _aActions[0];
		_ActionChange(_ActionFind(LA.App.Settings.delm.def_action));
	}
	
	void _ActionChange(_Action action) {
		_selectedAction = action;
		_cbAction.Items[0] = action.name;
		_cbAction.SelectedIndex = 0;
		_ActionSetControlsVisibility();
		if (_page != null) _FormatCode();
	}
	
	_Action _ActionMenu(bool test) {
		var m = new popupMenu();
		for (int i = test ? 1 : 0; i < _aActions.Count; i++) {
			var x = _aActions[i];
			if (test && x.NoTest) break;
			if (x.isSubmenu) {
				if (x.separatorBefore) m.Separator();
				int from = ++i, to = i;
				while (to < _aActions.Count && _aActions[to].inSubmenu) i = to++;
				m.Submenu(x.name, m => { for (int i = from; i < to; i++) _Add(m, i); });
			} else {
				_Add(m, i);
			}
			
			void _Add(popupMenu m, int i) {
				var x = _aActions[i];
				if (test && x.code is ['#' or '?', ..]) return;
				if (x.separatorBefore) m.Separator();
				m.Add(i + 1, x.name);
			}
		}
		
		_actionMenu?.Close(); _actionMenu = m; //prevent multiple instances on capture+test
		int ia;
		if (test) { //called when testing if no action selected
			ia = m.Show(owner: this);
		} else {
			var r = _cbAction.RectInScreen();
			ia = m.Show(PMFlags.AlignRectBottomTop, new POINT(r.left, r.bottom), r, owner: this);
		}
		_actionMenu = null;
		if (--ia < 0) return _aActions[0];
		var action = _aActions[ia];
		
		if (!test) {
			_testedAction = _aActions[0];
			
			if (action.code is string s1) {
				if (s1.Starts('#')) {
					if (!_ActionInputStringArg(s1, out string selectAction)) return _aActions[0];
					//select the first action in this submenu, but don't change if was selected an action in this submenu
					action = _selectedAction.name.Starts(selectAction) ? _CurrentAction : _ActionFind(selectAction);
					if (test && ReferenceEquals(action, _testedAction)) _FormatCode();
				} else if (s1.Starts('?')) {
					if (s1 == "?table") {
						LA.PanelHelp.OpenRecipe("Extract table*UI*");
						action = _ActionFind("FindAll, table");
					}
				}
			}
		}
		
		if (!test) {
			_ActionChange(action);
		} else if (!ReferenceEquals(action, _testedAction)) {
			_testedAction = action;
			_ActionSetControlsVisibility();
			_FormatCode();
		}
		return action;
	}
	popupMenu _actionMenu;
	
	string _ActionGetCode(bool test) {
		var action = !test ? _CurrentAction : !_selectedAction.isNone ? _selectedAction : _ActionMenu(true);
		
		if (test && action.name == "WebInvoke") action = _ActionFind("Invoke"); //avoid waiting
		
		var s = action.code;
		if (s != null) {
			int j = s.IndexOf('%'); //mouse x y placeholder
			if (j > 0) {
				bool scroll = _cScroll.IsChecked;
				if (_xy.GetText(out var xy)) {
					if (s[j - 1] != '(') xy = ", " + xy;
					//if (s[j + 1] != ')') xy += ", ";
					if (scroll) xy += ", scroll: 50";
					s = s.ReplaceAt(j, 1, xy);
				} else {
					s = s.Remove(j, 1);
					if (scroll) s = s.Insert(j, "scroll: 50");
				}
			}
			
			if (s.Starts("Expand(true")) {
				if (_actionExpandPath != null) s = s.ReplaceAt(7, 4, _actionExpandPath.Escape(quote: true));
			} else if (s.Starts("ComboSelect(^")) {
				if (test) {
					if (_actionComboSelectItem == null || popupMenu.showSimple(new(_actionComboSelectItem, "8492 Other...")) == 8492) {
						if (!_ActionInputStringArg("#cs", out _) || _actionComboSelectItem == null) return null;
						_FormatCode();
					}
				}
				s = s.ReplaceAt(12, 1, (_actionComboSelectItem ?? "Item").Escape(quote: true));
			}
		}
		return s;
	}
	string _actionExpandPath, _actionComboSelectItem;
	
	bool _ActionInputStringArg(string what, out string selectAction) {
		selectAction = null;
		switch (what) {
		case "#cs":
			selectAction = "ComboSelect";
			return _Dialog(ref _actionComboSelectItem, "ComboSelect item", "Combo box item name. Wildcard expression.");
		case "#ep":
			selectAction = "Expand";
			return _Dialog(ref _actionExpandPath, "Expand path", "Tree node path for Expand actions.\nExample: Folder1|Folder2|Folder3\nPath parts are wildcard expressions.");
		}
		return false; //impossible
		
		bool _Dialog(ref string r, string text1, string text2) {
			if (!dialog.showInput(out string s, text1, text2, editText: r, owner: this)) return false;
			r = s.NullIfEmpty_();
			return true;
		}
	}
	
	void _ActionSetControlsVisibility() {
		var action = _CurrentAction;
		bool isMouse = action.IsMouse;
		_xy.Visible = isMouse;
		_cScroll.Visibility = isMouse ? Visibility.Visible : Visibility.Hidden;
		bool isFind = !(action.IsFindAll || action.IsFinder);
		_wait.Visible = isFind;
		_cException.Visibility = isFind ? Visibility.Visible : Visibility.Hidden;
	}
	
	#endregion
	
	#region misc
	
	void _ToolSettings() {
		var m = new popupMenu();
		var cAT = m.AddCheck("Auto test find", _Opt.Has(_EOptions.AutoTest)); cAT.Tooltip = "Test find when captured";
		var cWA = m.AddCheck(".Activate()", _Opt.Has(_EOptions.Activate)); cWA.Tooltip = "Append .Activate() to wnd.find(...), unless the window looks like does not like to be activated";
		var cVR = m.AddCheck("var role", _Opt.Has(_EOptions.VarRole)); cVR.Tooltip = "Use role in elm variable name";
		//var cCC = m.AddCheck("Compact code", _Opt.Has(_EOptions.Compact)); cNS.Tooltip = "Insert code without { } and don't use elm e with action";
		m.Separator();
		m.Add("Save action", _ => {
			LA.App.Settings.delm.def_action = _selectedAction.name;
			_SetOpt(_EOptions.MouseXY, _xy.c.IsChecked);
			_SetOpt(_EOptions.MouseScroll, _cScroll.IsChecked);
		}).Tooltip = "Let the tool start with current action and its settings";
		m.Add("Save wait", _ => {
			LA.App.Settings.delm.def_wait = _wait.t.Text;
			_SetOpt(_EOptions.NoWait, !_wait.c.IsChecked);
		}).Tooltip = "Let the tool start with current wait settings";
		m.Add("Save UIA", _ => {
			LA.App.Settings.delm.def_UIA = _cUIA.IsChecked;
		}).Tooltip = "Let the tool start with current UIA checkbox state";
		//if (Java.GetJavaPath(out _)) { //moved to Options -> OS. It isn't a tool setting.
		//	m.Separator();
		//	m["Java..."] = o => Java.EnableDisableJabUI(this);
		//}
		m.Show(owner: this);
		_SetOpt(_EOptions.AutoTest, cAT.IsChecked);
		//bool format = _SetOpt(_EOptions.Compact, cCC.IsChecked);
		//if (format) _FormatCode();
		_SetOpt(_EOptions.Activate, cWA.IsChecked);
		_SetOpt(_EOptions.VarRole, cVR.IsChecked);
	}
	
	[Flags]
	enum _EOptions {
		AutoTest = 1,
		//NoScope = 1 << 1, //rejected
		MouseXY = 1 << 2,
		NoWait = 1 << 3,
		MouseScroll = 1 << 4,
		Activate = 1 << 5,
		VarRole = 1 << 6,
		//and don't save autotestaction, autoinsert
	}
	
	static _EOptions _Opt {
		get => (_EOptions)LA.App.Settings.delm.flags;
		set => LA.App.Settings.delm.flags = (int)value;
	}
	
	static bool _SetOpt(_EOptions opt, bool on) {
		_EOptions f = _Opt;
		if (f.Has(opt) == on) return false;
		f.SetFlag(opt, on);
		_Opt = f;
		return true;
	}
	
	//Builds navig path from the selected tree node to *to*. Sets control text and checkbox.
	void _NavigateTo(_TreeItem to) {
		if (_tree.SelectedItem is not _TreeItem from) return;
		//print.it(from.e); print.it(to.e);
		var a = new List<(string s, int n)>();
		if (from.Parent == to.Parent) {
			_AppendNePr(from, to);
		} else {
			var aFrom = from.AncestorsFromRoot(andSelf: true);
			int i = Array.IndexOf(aFrom, to);
			if (i >= 0) { //'to' is ancestor of 'from'
				_AppendPa();
			} else {
				//find common ancestor
				var aTo = to.AncestorsFromRoot(andSelf: true);
				for (i = Math.Min(aFrom.Length, aTo.Length); --i >= 0;) if (aFrom[i] == aTo[i]) break;
				
				if (++i < aFrom.Length) {
					_AppendPa();
					_AppendNePr(aFrom[i], aTo[i]);
				} else i--;
				
				while (++i < aTo.Length) {
					var v = aTo[i]; var p = aTo[i].Parent;
					var s = v == p.FirstChild ? "fi" : v == p.LastChild ? "la" : null;
					if (s == null) a.Add(("ch", v.Index + 1));
					else if (a.Count > 0 && a[^1].s == s) a[^1] = (s, a[^1].n + 1);
					else a.Add((s, 1));
				}
			}
			
			void _AppendPa() {
				int n = aFrom.Length - i - 1;
				if (n > 0) a.Add(("pa", n)); //else common parent with a 'to' ancestor
			}
		}
		
		void _AppendNePr(_TreeItem from, _TreeItem to) {
			if (to == from) return;
			int n = to.Index - from.Index;
			a.Add((n > 0 ? "ne" : "pr", Math.Abs(n)));
			//never mind: n may be incorrect because some UI elements skip invisible siblings. Eg standard WINDOW elements.
			//	We could detect it and either display a warning or use pa ch instead (can be unreliable).
		}
		
		var b = new StringBuilder();
		foreach (var (s, n) in a) {
			if (b.Length > 0) b.Append(' ');
			b.Append(s);
			if (n > 1) b.Append(n);
		}
		var navig = b.ToString();
		
		_page.navigA.Set(navig.Length > 0, navig);
	}
	
	public static class Java {
		/// <summary>
		/// Calls <see cref="EnableDisableJab"/>. Before it shows dialog "enable/disable". After it shows dialog with results.
		/// </summary>
		public static void EnableDisableJabUI(AnyWnd owner) {
			bool enable;
			switch (dialog.show("Enable or disable Java Access Bridge", $"If enabled, scripts and programs can find UI elements in Java apps.", "1 Enable|2 Disable|Cancel", owner: owner, flags: DFlags.CenterOwner)) {
			case 1: enable = true; break;
			case 2: enable = false; break;
			default: return;
			}
			var (ok, results) = EnableDisableJab(enable);
			dialog.show(null, results, icon: ok ? DIcon.Info : DIcon.Error, owner: owner, flags: DFlags.CenterOwner);
		}
		
		/// <summary>
		/// Enables or disables Java Access Bridge for current user.
		/// Returns: ok = false if failed or canceled. results = null if canceled.
		/// </summary>
		public static (bool ok, string results) EnableDisableJab(bool enable) {
			if (!GetJavaPath(out var path)) return (false, $"Cannot find Java {RuntimeInformation.ProcessArchitecture} (JRE or JDK). Make sure it is installed and in PATH. Need the {RuntimeInformation.ProcessArchitecture} version, not 32-bit or {(osVersion.isArm64Process ? "x64" : "ARM64")}. If you have other Java versions (32-bit etc), keep them too.");
			
			string sout = null;
			string jabswitch = path + @"\jabswitch.exe";
			if (!filesystem.exists(jabswitch).File) return (false, "Cannot find jabswitch.exe.");
			try {
				run.console(out sout, jabswitch, enable ? "-enable" : "-disable");
				sout = sout?.Trim();
			}
			catch (Exception ex) {
				return (false, ex.ToStringWithoutStack());
			}
			
			sout += "\r\nAlso may need to restart Java apps and this app.";
			
			return (true, sout);
			
			//tested: the checkbox in CP does not disable JAB. Works only enabling.
			//	Tested on Win 10 (installed Java 64 and 32) and 7 (installed Java 64).
			//	Tested 64-bit and 32-bit processes.
			//	\lib\accessibility.properties is not modified, ie not enabled for all users.
			//	This function works.
		}
		
		/// <summary>
		/// Gets path of the bin folder of installed Java JRE or JDK. Only of same x64/AMD64 architecture as of this process.
		/// </summary>
		public static bool GetJavaPath(out string path) {
			path = null;
			try {
				if (0 == run.console(out string where, "where", "java")) {
					foreach (var javaExe in where.Lines()) {
						if (!javaExe.Ends(".exe", true)) continue;
						run.console(out string s, javaExe, "-XshowSettings:properties");
						
						//print.it($"<><lc yellow>{javaExe}<>");
						//print.it(s);
						
						var arch = osVersion.isArm64Process ? "aarch64" : "amd64";
						if (s.RxIsMatch($@"(?m)^\h*os.arch *= *{arch}\b") && s.RxMatch(@"(?m)^\h*java.home *= *(.+)", 1, out s)) {
							path = s + "\\bin";
							return true;
						}
					}
				}
			}
			catch { }
			return false;
		}
	}
	
	#endregion
	
	#region util
	
	wnd _WndSearchIn => _useCon ? _con : _wnd;
	
	//Returns nonzero browser if e is in visible web page in a browser, and not UIA.
	//If Chrome document URL is not https/http/file, also returns the URL as wildcard.
	static (_BrowserEnum browser, string propUrl) _IsVisibleWebPage(elm e, wnd wContainer) {
		if (e.MiscFlags.HasAny(EMiscFlags.UIA | EMiscFlags.Java)) return default;
		
		var browser = wContainer.HasStyle(WS.CHILD)
			? wContainer.ClassNameIs(Api.string_IES, "Chrome_RenderWidgetHostHWND") switch { 1 => _BrowserEnum.IE, 2 => _BrowserEnum.Chrome, _ => 0 }
			: (_BrowserEnum)wContainer.ClassNameIs("Chrome*", "Mozilla*");
		
		if (browser is _BrowserEnum.Chrome or _BrowserEnum.FF) {
			elm eDoc = null;
			do {
				if (e.RoleInt == ERole.DOCUMENT) eDoc = e;
				e = e.Parent;
			} while (e != null);
			if (eDoc == null || eDoc.IsInvisible) return default;
			
			if (browser == _BrowserEnum.Chrome) { //see _FindDocumentCallback
				var url = eDoc.Value;
				if (url.NE()) return default;
				if (0 == url.Starts(false, "https:", "http:", "file:")) {
					if (url.Starts("devtools:")) return (browser, "devtools:*");
					int i = url.FindAny("?*"); if (i >= 0) url = url[..i] + "*"; //"https://example?a=1" -> "https://example*"
					return (browser, url);
				}
			}
		}
		
		return (browser, null);
	}
	enum _BrowserEnum { Chrome = 1, FF, IE }
	
	void _EnableDisableTopControls(bool enable) {
		_bTest.IsEnabled = enable; _bInsert.IsEnabled = enable;
		_ActionSetControlsVisibility();
		var vis = enable ? Visibility.Visible : Visibility.Hidden;
		//_cbAction.Visibility = vis; _topRow2.Visibility = vis; //no, may want to change before capturing if 'Auto test action'
		_bWindow.Visibility = vis;
		_cControl.Visibility = vis;
	}
	
	//Shows popup menu m by RECT r or by the mouse cursor, depending on r size.
	//If r small, shows by r so that the menu does not cover the rectangle. Else shows by the mouse (else the user would not notice the menu easily).
	//If ods, shows OSD rects for menu items with Tag = RECT.
	int _ShowMenu(popupMenu m, RECT r, bool osd = false) {
		bool byMouse = r.Height > 200 || r.Is0;
		var mf = byMouse ? PMFlags.Underline : PMFlags.Underline | PMFlags.AlignRectBottomTop | PMFlags.AlignCenterH;
		if (osd) _RectTimer(m);
		return m.Show(mf, excludeRect: byMouse ? null : r, owner: this.IsLoaded ? this : default);
		
		static void _RectTimer(popupMenu m) {
			var osd = new osdRect { Color = 0x80C000, Thickness = 3, TopmostWorkaround_ = true };
			PMItem pmi = null;
			timer.every(100, t => {
				if (m.IsOpen) {
					var mi = m.FocusedItem;
					if (mi != pmi) {
						pmi = mi;
						if (mi?.Tag is RECT r) {
							r.Inflate(1, 1);
							osd.Rect = r;
							osd.Visible = true;
						} else osd.Visible = false;
					}
				} else {
					t.Stop();
					osd.Dispose();
				}
			});
		}
	}
	
	static bool _RoleIsLinkOrButton(ERole role) => role is ERole.LINK
			or ERole.BUTTON or ERole.BUTTONMENU or ERole.BUTTONDROPDOWN or ERole.BUTTONDROPDOWNGRID
			or ERole.CHECKBOX or ERole.RADIOBUTTON;
	
	#endregion
	
	#region info
	
	TUtil.CommonInfos _commonInfos;
	void _InitInfo() {
		_commonInfos = new TUtil.CommonInfos(_info);
		
		_info.aaaText = _dialogInfo;
		_info.AaAddElem(this, _dialogInfo);
		_info.AaTags.AddLinkTag("+jab", _ => Java.EnableDisableJabUI(this));
		_info.AaTags.AddLinkTag("+actTest", _ => { if (_wnd.ActivateL()) _Test(); });
		TUtil.CapturingWithHotkey.RegisterLink_DialogHotkey(_info);
		
		//note: for Test button etc it's better to use tooltip, not _info.
		
		_info.InfoCT(_xy,
@"Mouse x y in the UI element. Empty = center.
See <help Au.Types.Coord>Coord<>. Examples:
<mono>10, 10
^10, .9f<>");
		_info.InfoC(_cScroll, @"At first call ScrollTo");
		_info.InfoC(_cControl,
@"Find first matching control and search in it, not in all matching controls.
To change window or/and control name etc, click <b>Window...<> or edit it in the code field.");
		_info.InfoCT(_wait,
@"The wait timeout, seconds.
The function waits max this time interval. On timeout throws exception if <b>Exception<> checked, else returns null. If empty, uses 8e88 (infinite).");
		_info.InfoC(_cException,
@"Throw exception if not found.
If unchecked, returns null.");
		
		_info.Info(_tree, "Tree view",
@"All UI elements in the window.");
		
		//TODO3: now no info for HwndHost
		//		_info.Info(_code, "Code",
		//@"Code to find the UI element.
		//The ""find window"" part can be edited directly.");
	}
	
	string _dialogInfo = $@"This tool creates code to find <help elm>UI element<> in <help wnd.find>window<>.
1. Move the mouse to a UI element. Press <+hotkey>hotkey<> <b>{LA.App.Settings.delm.hk_capture}<>.
2. Click the Test button to see how the 'find' code works.
3. If need, change some fields or select another element.
4. Click Insert. Click Close, or capture/insert again.
5. If need, edit the code in editor. For example rename variables, delete duplicate wnd.find lines, replace part of window name with *, add code to click the UI element. <help elm>Examples<>.

How to find UI elements that don't have a name or other property with unique constant value? Capture another UI element near it, and use <b>navig<> to get it. Or try <b>skip<>. Or path.

If the wanted element is ""behind"" a bigger element, try <+hotkey>hotkey<> <b>{LA.App.Settings.delm.hk_smaller}<>.";
	
	const string c_infoJava = "If there are no UI elements in this window, need to <+jab>enable<> Java Access Bridge etc. More info in <help>elm<> help.";
	
	partial class _PropPage {
		void _InitInfo() {
			var _info = _dlg._info;
			_info.InfoCT(roleA,
@"Role. Prefix <b>web:<> means ""in web page"".
Read more in <help>elmFinder[]<> help.");
			_info.InfoCT(nameA, "Name.", true);
			_info.InfoCT(uiaidA, "UIA AutomationId.", true);
			_info.InfoCT(uiacnA, "UIA ClassName.", true);
			_info.InfoCT(idA, "Control id. Will search only in controls that have it.");
			_info.InfoCT(classA, "Control class name. Will search only in controls that have it.", true);
			_info.InfoCT(valueA, "Value.", true);
			_info.InfoCT(descriptionA, "Description.", true);
			_info.InfoCT(actionA, "Default action.", true);
			_info.InfoCT(keyA, "Keyboard shortcut.", true);
			_info.InfoCT(helpA, "Help.", true);
			_info.InfoCT(urlA, "Chrome DOCUMENT URL (Value).", true);
			_info.InfoCT(elemA,
@"Simple element id.");
			_info.InfoCT(stateA,
@"State. List of <help Au.Types.EState>states<> this UI element must have and/or not have.
Example: CHECKED, !DISABLED
Note: states can change. Use only states you need. Remove others from the list.");
			_info.InfoCT(rectA,
@"Raw rectangle. Can be specified width (W) and/or height (H).
Example: {W=100 H=20}");
			
			_info.InfoCT(alsoA,
@"<help>elmFinder[]<> <i>also<> " + TUtil.CommonInfos.c_alsoParameter);
			_info.InfoCT(skipA,
@"0-based index of matching UI element.
For example, if 1, gets the second matching element.
-1 means any matching intermediate element when used path or <b>navig<>.");
			_info.InfoCT(navigA,
@"Get another UI element using this tree path from the found element.
See <help>elm.Navigate<>. Tool: in the tree view right click that element...
One or several words: <u><i>parent<> <i>child<> <i>first<> <i>last<> <i>next<> <i>previous<><>. Or 2 letters, like <i>ne<>.
Example: pa ne2 ch3. The 2 means 2 times (ne ne). The 3 means 3-rd child; -3 would be 3-rd from end.
Note: ne/pr may skip invisible siblings.
Some elements also support <u><i>up<> <i>down<> <i>left<> <i>right<><>.");
			
			_info.InfoC(hiddenTooA, "Flag <help>Au.Types.EFFlags<>.HiddenToo.");
			_info.InfoC(reverseA, "Flag <help>Au.Types.EFFlags<>.Reverse (search bottom to top).");
			_info.InfoC(uiaA,
@"Flag <help>Au.Types.EFFlags<>.UIA.
This checkbox may change when capturing, depending on what is usually better in that case; it also depends on the above UIA checkbox.");
			_info.InfoC(notInprocA, @"Flag <help>Au.Types.EFFlags<>.NotInProc.
If checked, the tool also captures elements not in-proc.");
			_info.InfoC(clientAreaA, "Flag <help>Au.Types.EFFlags<>.ClientArea.");
			_info.InfoC(menuTooA,
@"Flag <help>Au.Types.EFFlags<>.MenuToo.
Check this if the UI element is in a menu and its role is not MENUITEM or MENUPOPUP.");
			_info.InfoCT(notinA,
@"Don't search in UI elements that have these roles. Can make faster.
Example: LIST,TREE,TITLEBAR,SCROLLBAR");
			_info.InfoCT(maxccA, "Don't search in UI elements that have more direct children. Default 10000, min 1, max 1000000.");
			_info.InfoCT(levelA,
@"0-based level of the UI element in the tree of UI elements. Or min and max levels. Default 0 1000.
Relative to the window, control (if used <b>class<> or <b>id<>) or web page (role prefix <b>web:<> etc).");
			_info.InfoC(inPath,
@"Adds this element to a path like [element1][element2][wantedElement].
Use path when Test finds a similar element but in another ancestor element. Then need to find the correct ancestor element at first.
1. Check this checkbox for the wanted element. 2. In the tree select an ancestor element and check this too. 3. Click Test. It should find the wanted element. If it doesn't, try <b>skip<> -1 for the ancestor element. If the ancestor cannot be uniquely identified (no name etc), you can try to find an element near it in the tree and use <b>navig<> to navigate to it.

This tool remembers edited properties of the element if this checkbox is checked. Also draws a green border in the tree.");
		}
	}
	#endregion
}


================================================
FILE: Au.Editor/Tools/Dnuget.cs
================================================
//For NuGet management we use dotnet.exe and full or minimal .NET SDK.
//Also some API from the NuGet client SDK. But it does not have API for installing dlls etc.
//We don't install packages for each script that uses them. We install all in current workspace, and let scripts use them.
//	To avoid conflicts, packages can be installed in separate folders.
//	More info in nuget.md.
//Rejected: UI to search for packages and display package info. Why to duplicate the NuGet website.

using System.Text.Json.Nodes;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;
using System.Xml.Linq;
using System.Xml.XPath;
using Au.Controls;
using NGC = NuGet.Configuration;
using System.Collections.ObjectModel;

namespace LA;

class DNuget : KDialogWindow {
	/// <param name="package">null or package name or folder\name.</param>
	public static void ShowSingle(string package = null) {
		var d = ShowSingle(() => new DNuget());
		if (package != null) {
			if (package.Split('\\', 2) is var a && a.Length == 2 && a[0].Length > 0 && a[1].Length > 0) { //folder\name
				package = a[1];
				d._cbFolder.Text = a[0];
			}
			d._tPackage.Text = package;
		}
	}
	
	readonly TextBox _tPackage;
	readonly ComboBox _cbFolder, _cbSource;
	readonly KTreeView _tv;
	readonly Panel _panelManage;
	readonly KGroupBox _groupInstall, _groupInstalled;
	readonly Button _bMenu;
	readonly TextBlock _tStatus;
	
	readonly string _nugetDir = App.Model.NugetDirectory;
	readonly ObservableCollection<string> _folders;
	readonly WindowDisabler _disabler;
	
	DNuget() {
		InitWinProp("NuGet packages", App.Wmain);
		var b = new wpfBuilder(this).WinSize(550, 600).Columns(-1, 30, 0);
		
		b.R.StartGrid(out _groupInstall, "Install").Columns(0, -1, 0);
		b.R.Add(wpfBuilder.formattedText($"<a href='https://www.nuget.org'>NuGet</a> package"), out _tPackage)
			.Tooltip("Examples:\nPackageName (will get the latest version)\nPackageName --version 1.2.3\ndotnet add package PackageName --version 1.2.3 (copied from the package's web page)")
			.Focus();
		b.xAddButtonIcon(EdIcons.Paste, _ => { _tPackage.SelectAll(); _tPackage.Paste(); }, "Paste");
		
		b.R.StartGrid().Columns(76, 0, -1, 20, 0, -1);
		
		b.R.AddButton(out var bInstall, "Install", _ => _Install()).Disabled();
		bInstall.IsDefault = true;
		
		b.Add("into folder", out _cbFolder).Editable().Tooltip(@"Press F1 if need help with this. Or just use the default selected folder.");
		_cbFolder.MaxDropDownHeight = 600;
		_cbFolder.ShouldPreserveUserEnteredPrefix = true;
		filesystem.createDirectory(_nugetDir);
		_folders = new(filesystem.enumDirectories(_nugetDir).Select(o => o.Name));
		if (_folders.Count == 0) _folders.Add("-");
		_cbFolder.ItemsSource = _folders;
		_cbFolder.SelectedIndex = 0; //probably "-"
		
		b.Window.AddHandler(TextBox.TextChangedEvent, new TextChangedEventHandler((_, e) => {
			bInstall.IsEnabled = !_tPackage.Text.Trim().NE() && !pathname.isInvalidName(_cbFolder.Text);
			if (e.Source == _tPackage) _PackageFieldTextChanged();
		}));
		
		b.Skip().Add("Source", out _cbSource).Tooltip("Package source.\nThe list contains nuget.org and sources specified in nuget.config files.");
		b.End();
		b.End();
		
		b.Row(-1).StartGrid(out _groupInstalled, "Installed").Columns(-1, 76);
		
		b.Row(-1).xAddInBorder(out _tv);
		
		b.StartGrid().Columns(-1); //right
		b.Row(-1).StartStack(vertical: true).Disabled(); //buttons
		b.AddButton("Add code", _ => _AddMeta()).Margin("B20").Tooltip("Use the package in the current C# file.\nAdds /*/ nuget Package; /*/.");
		b.AddButton("→ NuGet", _ => run.itSafe("https://www.nuget.org/packages/" + _Selected.Name)).Tooltip("Open the package's NuGet webpage");
		b.AddButton("→ Folder", _ => run.itSafe(_FolderPath(_Selected.Parent.Name))).Margin("B20").Tooltip("Open the folder");
		b.AddButton(out var bUpdate, "Update", _ => _Update(false)).Tooltip("Replace this version with the latest version");
		b.AddButton(out var bUpdateTo, "Update ▾", _ => _Update(true)).Tooltip("Replace this version with another version");
		bUpdate.ContextMenuOpening += (_, e) => _Update(true);
		b.AddButton("Move to ▾", _ => _Move()).Tooltip("Uninstall from this folder and install in another folder");
		b.AddButton("Uninstall", _ => _Uninstall()).Tooltip("Remove the package and its files from the folder");
		
		_panelManage = b.Panel;
		_tv.SelectionChanged += (_, _) => _panelManage.IsEnabled = !_tv.SelectedItem?.IsFolder ?? false;
		_tv.ItemClick += _tv_ItemClick;
		
		b.End(); //buttons
		b.AddButton("Updates...", _ => _CheckForUpdates()).Tooltip("Check for updates");
		b.End(); //right
		b.End(); //group "Installed"
		
		b.R.Add(out _tStatus)
			.xAddButtonIcon(out _bMenu, "*MaterialDesign.MoreHorizRound" + EdIcons.black, _ => _Menu(), "Menu")
			.xAddDialogHelpButtonAndF1("editor/NuGet");
		
		b.End();
		
		bool missingSdk = DotnetUtil.MissingSdkUI(b.Window, [_groupInstall, _groupInstalled, _bMenu], () => { _InitSources(); _FillTree(); });
		if (!missingSdk) _InitSources();
		
		Loaded += (_, _) => {
			App.Model.UnloadingThisWorkspace += Close;
			_FillTree(); //note: fill now even if missingSdk, or the user might have a heart attack when seeing an empty list. When installed, _FillTree will be called again, because need to set _TreeItem.Source.
		};
		
		_disabler = new(this);
	}
	
	protected override void OnClosed(EventArgs e) {
		App.Model.UnloadingThisWorkspace -= Close;
		base.OnClosed(e);
	}
	
	async void _Install(string folder = null) {
		folder ??= _cbFolder.Text.Trim();
		var package = _tPackage.Text.Trim();
		_NormalizeCopiedPackageString(ref package);
		
		if (!App.Settings.nuget_noPrerelease) if (!package.RxIsMatch("(?i) --version | -v | --prerelease\b")) package += " --prerelease";
		if (_cbSource.SelectedItem is _Source source && !package.RxIsMatch("(?i) --source | -s ")) package += $" --source \"{source.UrlList}\"";
		
		using var _ = _disabler.Disable();
		if (!await _InstallWhenInstallingUpdatingOrMoving(package, folder)) return;
		print.it("========== Finished ==========");
		CodeInfo.StopAndUpdateStyling();
	}
	
	/// <param name="packageString">Package name, possibly with --version and other options.</param>
	async Task<bool> _InstallWhenInstallingUpdatingOrMoving(string packageString, string folder, _TreeItem updating = null, bool moving = false) {
		var projPath = _ProjPath(folder);
		var package = packageString.RxReplace(@"^\s*(\S+).*", "$1");
		
		using var um = new _UndoManager(_FolderPath(folder));
		if (!um.Init()) return false;
		um.printError = $"Failed to {(updating != null ? "update" : "install")} {package}.";
		
		if (!_CreateProjectFileIfNeed(projPath)) return false;
		
		var sAdd = $@"add ""{projPath}"" package {packageString}";
		//var sAdd = $@"package add {packageString} --project ""{proj}"""; //new syntax in .NET SDK 10
		
		bool _CanAddPrereleaseOption() => !sAdd.Contains(" --prerelease") && !sAdd.Contains(" --version");
		
		List<string> errorsAndWarnings = [];
		bool retryPrerelease = false, cancel = false;
		gRetry1:
		if (!await _RunDotnet(_Operation.Add, sAdd, errorsAndWarnings: errorsAndWarnings)) {
			retryPrerelease = errorsAndWarnings.Any(o => o.Like("error: There are no stable versions*--prerelease*")) && _CanAddPrereleaseOption();
			if (!retryPrerelease) return false;
		} else if (errorsAndWarnings.Any(o => o.Starts("error:")) && updating is null) {
			switch (dialog.show("Errors detected", "Try to install anyway?\n\nMore info in the Output.", "1 No|2 Yes", icon: DIcon.Warning, owner: this)) {
			case 1: cancel = true; break;
			}
		} else if (errorsAndWarnings.Any(o => o.Starts("warn : NU1701:")) && updating is null && !moving) {
			var buttons = "1 Cancel|2 OK" + (_CanAddPrereleaseOption() ? "|3 Retry with option --prerelease\nMaybe a compatible prerelease version exists..." : null);
			switch (dialog.show("This package may be incompatible", "Install anyway?\n\nMore info in the Output.", buttons, DFlags.CommandLinks, DIcon.Warning, owner: this)) {
			case 1: cancel = true; break;
			case 3: retryPrerelease = true; break;
			}
		}
		
		if (retryPrerelease) {
			print.it("info : Added option --prerelease");
			sAdd += " --prerelease";
			goto gRetry1;
		}
		if (cancel) {
			print.it("========== Canceled ==========");
			return false;
		}
		
		if (!await _Build(folder, package)) return false;
		um.success = true;
		
		_AddToTreeOrUpdate(folder, package, updating);//TODO: review and test how when failed
		
		return true;
		
		bool _CreateProjectFileIfNeed(string path) {
			try {
				string writeProjText = null;
				string c_targetFramework = $"<TargetFramework>net{Environment.Version.ToString(2)}-windows</TargetFramework>";
				const string c_assemblyName = "<AssemblyName>___</AssemblyName>"; //without this, usually error if the folder name == a dll name, because the main dll name was the same.
				const string c_allowMissingPacksDir = "<AllowMissingPrunePackageData>true</AllowMissingPrunePackageData>"; //.NET 10 SDK requires the `packs` dir by default. The error description says add this if the dir is missing.
				if (!filesystem.exists(path, true)) {
					writeProjText = $"""
<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    {c_targetFramework}
    <UseWPF>true</UseWPF>
    <UseWindowsForms>true</UseWindowsForms>
    <ProduceReferenceAssembly>False</ProduceReferenceAssembly>
    <DebugType>none</DebugType>
    <CopyLocalLockFileAssemblies>true</CopyLocalLockFileAssemblies>
    <NuGetAudit>False</NuGetAudit>
    {c_assemblyName}
    {c_allowMissingPacksDir}
  </PropertyGroup>

  <!-- Copy XML files -->
  <Target Name="_ResolveCopyLocalNuGetPkgXmls" AfterTargets="ResolveReferences">
    <ItemGroup>
      <ReferenceCopyLocalPaths Include="@(ReferenceCopyLocalPaths->'%(RootDir)%(Directory)%(Filename).xml')" Condition="'%(ReferenceCopyLocalPaths.NuGetPackageId)'!='' and Exists('%(RootDir)%(Directory)%(Filename).xml')" />
    </ItemGroup>
  </Target>

</Project>
""";
					if (!_folders.Any(o => o.Eqi(folder))) _folders.Add(folder);
				} else { //may need to update something
					string s = filesystem.loadText(path), s0 = s;
					
					if (!s.Contains(c_targetFramework)) s = s.RxReplace(@"<TargetFramework>.+?</TargetFramework>", c_targetFramework, 1);
					if (!s.Contains(c_targetFramework)) s = s.RxReplace(@"<TargetFramework>.+?</TargetFramework>", c_targetFramework, 1);
					
					_AppendPropIfMissing(c_assemblyName);
					_AppendPropIfMissing(c_allowMissingPacksDir);
					
					void _AppendPropIfMissing(string prop) {
						if (!s.Contains(prop) && s.RxMatch(@"\R\h*</PropertyGroup>", 0, out RXGroup g)) s = s.Insert(g.Start, $"\r\n    {prop}");
					}
					
					if (s != s0) writeProjText = s;
				}
				if (writeProjText != null) filesystem.saveText(path, writeProjText);
			}
			catch (Exception e1) {
				print.warning(e1);
				return false;
			}
			return true;
		}
	}
	
	/// <summary>
	/// Creates temporary backup of current packages folder.
	/// Also it allows to update files in use, eg dlls used by script processes.
	/// </summary>
	class _UndoManager : IDisposable {
		string _folderPath, _undoPath;
		bool _dirExists, _failedMove;
		
		public _UndoManager(string folderPath) {
			_folderPath = folderPath;
			_dirExists = filesystem.exists(_folderPath);
			_undoPath = _dirExists ? pathname.makeUnique(_folderPath + "~old", true) : null;
		}
		
		public bool Init() {
			if (_dirExists) {
				try {
					filesystem.move(_folderPath, _undoPath);
				}
				catch (Exception ex) { //note: succeeds when a dll file is used, but may fail for other reasons, eg the dir itself is locked
					//TODO2: then try to copy/delete folder contents; OK if deletes all files but not all empty folders.
					
					_failedMove = true;
					print.warning("Failed to create a temporary backup of the NuGet folder. " + ex);
					return false;
				}
			}
			filesystem.createDirectory(_folderPath);
			if (_dirExists) {
				foreach (var v in filesystem.enumerate(_undoPath)) {
					if (v.Attributes.Has(FileAttributes.ReadOnly) /*user-added files*/ || (!v.IsDirectory && v.Name.Ends(".csproj", true))) {
						filesystem.copyTo(v.FullPath, _folderPath);
					}
				}
			}
			return true;
		}
		
		public bool success;
		
		public string printError;
		
		public void Dispose() {
			if (_failedMove) return;
			if (success) {
				if (_dirExists) {
					if (false == filesystem.delete(_undoPath, FDFlags.CanFail)) {
						var dir3 = App.Model.TempDirectory + @"\delete"; //will be deleted when loading the workspace next time
						filesystem.moveTo(_undoPath, dir3, FIfExists.RenameNew);
						
						//If failed, probably some dlls are used by script processes.
						//good: we can update (or delete) locked dlls.
						//bad: these dlls later may try to load updated dlls as dependencies, and may fail if different version. Never mind, it's rare.
					}
				}
			} else {
				filesystem.delete(_folderPath);
				if (_dirExists) filesystem.move(_undoPath, _folderPath);
				
				if (printError != null) print.it(printError + $" No changes have been made in folder {pathname.getName(_folderPath)}.");
			}
		}
	}
	
	async Task<bool> _Build(string folder, string package = null) {
		var folderPath = _FolderPath(folder);
		var proj = _ProjPath(folder);
		bool installing = package != null;
		
		var noRestore = installing ? "--no-restore " : null; //`package add` restores, `package remove` doesn't
		var sBuild = $@"build ""{proj}"" {noRestore}--nologo -v m -o ""{folderPath}""";
		if (!await _RunDotnet(_Operation.Build, sBuild)) return false;
		
		if (installing) {
			//we need a list of installed files (managed dll, unmanaged dll, maybe more).
			//	When compiling miniProgram or editorExtension, will need dll paths to resolve at run time.
			//	When compiling exeProgram, will need to copy them to the output directory.
			
			//at first create a copy of the csproj file with only this PackageReference (remove others)
			var dirProj2 = folderPath + @"\single";
			filesystem.createDirectory(dirProj2);
			var proj2 = dirProj2 + @"\~.csproj";
			var dirBin2 = dirProj2 + @"\bin";
			var xp = XElement.Load(proj);
			var axp = xp.XPathSelectElements($"/ItemGroup/PackageReference[@Include]").ToArray();
			foreach (var v in axp) if (!v.Attr("Include").Eqi(package)) v.Remove();
			xp.Save(proj2);
			
			//then build it, using a temp output directory
			sBuild = $@"build ""{proj2}"" --nologo -v m -o ""{dirBin2}"""; //note: no --no-restore
			if (!await _RunDotnet(_Operation.Build, sBuild, s => { })) { //try silent, but print errors if fails (unlikely)
				Debug_.Print("FAILED");
				if (!await _RunDotnet(_Operation.Build, sBuild)) return false;
			}
			//#if DEBUG
			//run.it(dirBin2);
			//dialog.show("Debug", "single build done"); //to inspect files before deleting
			//#endif
			
			//delete runtimes of unsupported OS or CPU. It seems cannot specify it in project file.
			_DeleteOtherRuntimes(folderPath);
			_DeleteOtherRuntimes(dirBin2);
			void _DeleteOtherRuntimes(string dir) {
				dir += @"\runtimes";
				if (filesystem.exists(dir)) {
					foreach (var v in filesystem.enumDirectories(dir)) {
						var n = v.Name;
						if (!n.Starts("win", true) || (n.Contains('-') && 0 == n.Ends(true, "-x64", "-x86", "-arm64"))) {
							filesystem.delete(v.FullPath);
						}
					}
				}
			}
			
			//save relative paths etc of output files in file "nuget.xml"
			//	Don't use ___.deps.json. It contains only used dlls, but may also need other files, eg exe.
			//	For testing can be used NuGet package Microsoft.PowerShell.SDK. It has dlls for testing almost all cases.
			
			var npath = _nugetDir + @"\nuget.xml";
			var xn = XmlUtil.LoadElemIfExists(npath, "nuget");
			var packagePath = folder + "\\" + package;
			xn.Elem("package", "path", packagePath, true)?.Remove();
			var xx = new XElement("package", new XAttribute("path", packagePath), new XAttribute("format", "1"));
			xn.AddFirst(xx);
			
			var dCompile = _GetCompileAssembliesFromAssetsJson(dirProj2 + @"\obj\project.assets.json", folderPath);
			
			//get lists of .NET dlls, native dlls and other files
			List<(FEFile f, int r)> aDllNet = new(); //r: 0 r (ref and run time), 1 ro (ref only), 2 rt (run time only)
			List<FEFile> aDllNative = new(), aOther = new();
			var feFlags = FEFlags.AllDescendants | FEFlags.OnlyFiles | FEFlags.UseRawPath | FEFlags.NeedRelativePaths;
			foreach (var f in filesystem.enumFiles(dirBin2, flags: feFlags).OrderBy(o => o.Level)) {
				var s = f.Name; //like @"\file" or @"\dir\file"
				bool runtimes = false;
				if (f.Level == 0) {
					if (s.Starts(@"\___.")) continue;
				} else {
					runtimes = s.Starts(@"\runtimes\win", true);
					Debug_.PrintIf(!(runtimes || s.Ends(".resources.dll") || 0 != s.Starts(false, @"\ref\", @"\.playwright\")), s); //ref is used by Microsoft.PowerShell.SDK as data files
				}
				if (s.Ends(".dll", true) && (f.Level == 0 || runtimes)) {
					if (CompilerUtil.IsNetAssembly(f.FullPath, out bool refOnly)) {
						aDllNet.Add((f, refOnly ? 1 : runtimes ? 2 : 0));
					} else {
						aDllNative.Add(f);
					}
				} else {
					aOther.Add(f);
				}
			}
			
			//.NET dlls
			HashSet<string> hsLib = new(StringComparer.OrdinalIgnoreCase);
			foreach (var group in aDllNet.ToLookup(o => pathname.getName(o.f.Name), StringComparer.OrdinalIgnoreCase)) {
				//print.it($"<><lc #BBE3FF>{group.Key}<>");
				var filename = group.Key;
				int count = group.Count();
				bool haveRO = dCompile.Remove(filename);
				if (haveRO) xx.Add(new XElement("ro", @"\_ref\" + filename));
				XElement xGroup = null;
				foreach (var (f, r) in group) {
					var s = f.Name; //like @"\file" or @"\dir\file"
					hsLib.Add(s);
					bool refOnly = r == 1 || (r == 0 && f.Level == 0 && count > 1); //if count>1, this is X.dll from [X.dll, sub\X.dll, ...]
					if (refOnly) {
						if (haveRO) continue;
						xx.Add(new XElement("ro", s));
					} else {
						if (r == 2 && s[13] != '\\') { //\runtimes\win... but not \runtimes\win\...
							if (xGroup == null) xx.Add(xGroup = new("group"));
							xGroup.Add(new XElement("rt", s));
						} else if (!haveRO && r == 0) {
							xx.Add(new XElement("r", s));
						} else {
							xx.Add(new XElement("rt", s));
						}
					}
					//print.it(s, f.Size, refOnly, haveRO);
				}
				
				//XML tags:
				//	"r" - .NET dll used at compile time and run time. Not ref-only.
				//	"ro" - .NET dll used only at compile time. Can be ref-only or not.
				//	"rt" - .NET dll used only at run time.
				//	"native" - unmanaged dll
				//	"other" - all other (including dlls in folders other than root and runtimes)
				//	"group" - group of "rt" dlls. Same dll for different OS versions/platforms.
				//	"natives" - group of "native" dlls. Same dll for different OS versions/platforms.
				//native dlls usually are in \runtimes\win-x64\native\x.dll etc, but also can be in \runtimes\win10-x64\native\x.dll etc.
			}
			
			if (dCompile.Any()) { //ref-only dlls that were not copied to dirBin2
				foreach (var (k, v) in dCompile) {
					xx.Add(new XElement("ro", @"\_ref\" + k));
					hsLib.Add(k);
				}
			}
			
			//native dlls
			foreach (var group in aDllNative.ToLookup(o => pathname.getName(o.Name), StringComparer.OrdinalIgnoreCase)) {
				XElement xGroup = null;
				foreach (var f in group) {
					var s = f.Name;
					if (f.Level > 0 && s[13] != '\\') {
						if (xGroup == null) xx.Add(xGroup = new("natives"));
						xGroup.Add(new XElement("native", s));
					} else {
						xx.Add(new XElement("native", s));
					}
				}
			}
			
			//print.it(xx);
			
			//other files
			foreach (var f in aOther) {
				var s = f.Name;
				
				//skip XML doc. When compiling exeProgram, other xml files will be copied to the output.
				if (s.Ends(".xml", true) && hsLib.Contains(s.ReplaceAt(^3..^1, "dl"))) continue;
				
				xx.Add(new XElement("other", s));
			}
			
			xn.SaveElem(npath, backup: true);
			
			//finally delete temp files
			try { filesystem.delete(dirProj2); }
			catch (Exception e1) { Debug_.Print(e1); }
		}
		
		try {
			filesystem.delete($@"{folderPath}\___.dll");
			foreach (var v in Directory.GetFiles(folderPath, "*.json")) filesystem.delete(v);
			filesystem.delete($@"{folderPath}\obj");
		}
		catch (Exception e1) { Debug_.Print(e1); }
		
		return true;
		
		static Dictionary<string, string> _GetCompileAssembliesFromAssetsJson(string file, string folderPath) {
			string refDir = null;
			var hsDotnet = _GetDotnetAssemblies();
			Dictionary<string, string> d = new(StringComparer.OrdinalIgnoreCase);
			var j = JsonNode.Parse(File.ReadAllBytes(file));
			var packages = j["packageFolders"].AsObject().First().Key;
			foreach (var (nameVersion, v1) in j["targets"].AsObject().First().Value.AsObject()) {
				var k = v1.AsObject();
				if (!k.TryGetPropertyValue("compile", out var v2)) continue;
				foreach (var (s, _) in v2.AsObject()) {
					if (s.NE() || s.Ends("/_._")) continue;
					var name = pathname.getName(s);
					if (hsDotnet.Contains(name)) continue;
					var path = (packages + nameVersion + "\\" + s).Replace('/', '\\');
					if (!filesystem.exists(path)) {
						Debug_.Print($"<c red>{path}<>");
						continue;
					}
					if (d.TryGetValue(name, out var ppath)) {
#if DEBUG
						filesystem.GetProp_(ppath, out var u1);
						filesystem.GetProp_(path, out var u2);
						if (u2.size != u1.size) Debug_.Print($"<c orange>\t{name}<>\n\t\t{u1.size}  {ppath}\n\t\t{u2.size}  {path}");
						bool e1 = filesystem.exists(ppath.ReplaceAt(^3..^1, "xm")), e2 = filesystem.exists(path.ReplaceAt(^3..^1, "xm"));
						Debug_.PrintIf(e2 != e1, "no xml");
#endif
						continue;
					}
					var path2 = folderPath + "\\" + name;
					if (filesystem.GetProp_(path2, out var p1) && filesystem.GetProp_(path, out var p2) && p1 == p2) continue;
					d.Add(name, path);
					if (refDir == null) filesystem.createDirectory(refDir = folderPath + @"\_ref");
					filesystem.copyTo(path, refDir);
					var docPath = path.ReplaceAt(^3..^1, "xm");
					if (filesystem.exists(docPath, useRawPath: true)) filesystem.copyTo(docPath, refDir);
				}
			}
			return d;
		}
		
		static HashSet<string> _GetDotnetAssemblies() {
			var s = AppContext.GetData("TRUSTED_PLATFORM_ASSEMBLIES") as string;
			var a = s.Split(';', StringSplitOptions.RemoveEmptyEntries);
			var h = new HashSet<string>(a.Length, StringComparer.OrdinalIgnoreCase);
			string net1 = folders.NetRuntimeBS, net2 = folders.NetRuntimeDesktopBS;
			foreach (var v in a) {
				if (v.Starts(net1, true) || v.Starts(net2, true)) h.Add(pathname.getName(v));
			}
			return h;
		}
	}
	
	async void _Uninstall() {
		using var _ = _disabler.Disable();
		if (!await _UninstallWhenUninstallingOrMoving(_Selected)) return;
		print.it("========== Finished ==========");
		CodeInfo.StopAndUpdateStyling();
	}
	
	async Task<bool> _UninstallWhenUninstallingOrMoving(_TreeItem t) {
		var folder = t.Parent.Name;
		var package = t.Name;
		//if (uninstalling) if (!dialog.showOkCancel("Uninstall package", package, owner: this)) return; //more annoying than useful
		
		using var um = new _UndoManager(_FolderPath(folder));
		if (!um.Init()) return false;
		um.printError = $"Failed to uninstall {package}.";
		
		if (!await _RunDotnet(_Operation.Other, $@"remove ""{_ProjPath(folder)}"" package {package}")) return false;
		//if (!await _RunDotnet($@"package remove {package} --project ""{_ProjPath()}""")) return false; //new syntax in .NET SDK 10
		
		if (!await _Build(folder)) return false;
		um.success = true;
		
		var npath = _nugetDir + @"\nuget.xml";
		if (filesystem.exists(npath)) {
			var xn = XmlUtil.LoadElem(npath);
			var xx = xn.Elem("package", "path", folder + "\\" + package, true);
			if (xx != null) {
				xx.Remove();
				xn.SaveElem(npath);
			}
		}
		
		t.Remove();
		_tv.SetItems(_tvroot.Children(), true);
		if (_Selected is null) _panelManage.IsEnabled = false;
		
		return true;
	}
	
	async void _Update(bool showVersionsMenu) {
		var t = _Selected;
		var s = t.Name;
		
		if (showVersionsMenu) {
			if (await _GetVersions(t) is not { } versions) return;
			int i = popupMenu.showSimple(versions, owner: this, rawText: true) - 1; if (i < 0) return;
			s = $"{s} --version {versions[i]}";
		} else {
			if (!App.Settings.nuget_noPrerelease || t.Version.Contains('-')) s += " --prerelease";
		}
		if (t.Source is { } so) s += $" --source \"{so.UrlList}\"";
		
		using var _ = _disabler.Disable();
		if (!await _InstallWhenInstallingUpdatingOrMoving(s, t.Parent.Name, t)) return;
		print.it("========== Finished ==========");
		CodeInfo.StopAndUpdateStyling();
	}
	
	async void _Move() {
		var t = _Selected;
		
		var otherFolders = _folders.ToList();
		if (_cbFolder.Text.Trim() is var newFolder && !pathname.isInvalidName(newFolder) && !otherFolders.Contains(newFolder, StringComparer.OrdinalIgnoreCase)) otherFolders.Add(newFolder);
		if (otherFolders.FindIndex(o => o.Eqi(t.Parent.Name)) is int i1 && i1 >= 0) otherFolders.RemoveAt(i1);
		
		int i = popupMenu.showSimple(otherFolders, owner: this, rawText: true) - 1; if (i < 0) return;
		var folder = otherFolders[i];
		
		//can't move to a folder that already contains a package with this name
		foreach (var f in _tvroot.Children()) {
			if (f.Name == folder) {
				if (f.Children().Any(o => o.Name.Eqi(t.Name))) {
					print.it("Can't move to a folder that contains a package with this name.");
					return;
				}
				break;
			}
		}
		
		var s = $"{t.Name} --version {t.Version}";
		if (t.Source is { } so) s += $" --source \"{so.UrlList}\"";
		
		using var _ = _disabler.Disable();
		if (!await _InstallWhenInstallingUpdatingOrMoving(s, folder, moving: true)) return;
		await _UninstallWhenUninstallingOrMoving(t);
		print.it("========== Finished ==========");
		CodeInfo.StopAndUpdateStyling();
	}
	
	void _AddMeta() {
		var doc = Panels.Editor.ActiveDoc; if (doc == null) return;
		var meta = new MetaCommentsParser(doc.aaaText);
		var t = _Selected;
		meta.nuget.Add($@"{t.Parent.Name}\{t.Name}");
		meta.Apply();
	}
	
	public static string[] GetInstalledPackages() {
		var xn = XmlUtil.LoadElemIfExists(App.Model.NugetDirectoryBS + "nuget.xml");
		if (xn == null) return null;
		var a = xn.Elements("package").Select(o => o.Attr("path")).ToArray();
		if (!a.Any()) return null;
		Array.Sort(a, StringComparer.OrdinalIgnoreCase);
		return a;
	}
	
	void _Menu() {
		var m = new popupMenu();
		m.AddCheck("Avoid prerelease versions", App.Settings.nuget_noPrerelease, o => { App.Settings.nuget_noPrerelease = o.IsChecked; });
		m.Last.Tooltip = "When installing or updating, if version not specified, prefer the latest stable version";
		m.Submenu("nuget.config", m => {
			foreach (var v in _Config.GetConfigFilePaths()) m[v.Limit(150, middle: true)] = o => { run.selectInExplorer(v); };
		});
		m.Submenu("NuGet cache", m => {
			m["Open packages folder"] = o => { if (_GetCacheDir() is { } s) run.itSafe(s); };
			m.Submenu("Clear all caches", m => {
				m["Clear"] = o => { _ = _RunDotnet(_Operation.Other, "nuget locals all --clear"); };
			});
		});
		m.Show();
	}
	
	void _tv_ItemClick(TVItemEventArgs e) {
		if (e.Button != MouseButton.Right) return;
		var t = e.Item as _TreeItem;
		_tv.Select(t, focus: true);
		if (t.IsFolder) {
			var path = _FolderPath(t.Name);
			var m = new popupMenu();
			m["Install into this folder", disable: _tPackage.Text.Trim().NE()] = o => { _Install(t.Name); };
			m["Rename folder"] = o => { _tv.EditLabel(t); };
			m["Delete unused folder", disable: !_CanDeleteFolder()] = o => {
				if (false == filesystem.delete(path, FDFlags.CanFail)) return;
				t.Remove();
				_tv.SetItems(_tvroot.Children(), true);
				_folders.Remove(t.Name);
			};
			m.Show();
			
			bool _CanDeleteFolder() {
				if (t.HasChildren) return false;
				if (!filesystem.exists(path).Directory) return false;
				var a = filesystem.enumerate(path, FEFlags.UseRawPath).ToArray();
				if (a.Length > 1 || (a.Length == 1 && (a[0].IsDirectory || !a[0].Name.Ends(".csproj", true)))) return false;
				return true;
			}
		}
	}
	
	enum _Operation { Add, Build, Other }
	
	async Task<bool> _RunDotnet(_Operation op, string cl, Action<string> printer = null, List<string> errorsAndWarnings = null) {
		errorsAndWarnings?.Clear();
		try {
			if (printer == null) {
				var clPrint = cl.RxReplace(@" ""[^""]+\.csproj""", "", 1).Replace(" --nologo -v m", ""); //try to print shorter command line
				print.it($"<><c blue>dotnet {clPrint}<>");
				bool skip = false;
				printer = s => {
					if (!skip) skip = s.Starts("Usage:");
					if (skip) return;
					if (s.Starts("error") || s.Contains(": error ")) {
						errorsAndWarnings?.Add(s);
						s = $"<><c red>{s}<>";
					} else if (s.Starts("warn") || s.Contains(": warning ")) {
						errorsAndWarnings?.Add(s);
						s = $"<><c DarkOrange>{s}<>";
					} else if (op == _Operation.Add) {
						if (s.Like(false,
							"info :   OK http*",
							"info : Generating MSBuild file*",
							"info : Writing assets file*",
							"info : X.* certificate chain validation will*",
							"  Determining projects to restore*",
							"log  : Restored*",
							"  Writing *",
							"info : PackageReference for package*",
							"*is compatible with all the specified frameworks in project*"
							) > 0) s = null;
					} else if (op == _Operation.Build) {
						if (s.Like(false,
							"  Determining projects to restore*",
							"Time Elapsed *",
							"    0 Warning*",
							"    0 Error*",
							@"*\___.dll"
							) > 0) s = null;
					}
					if (!s.NE()) print.it(s);
				};
			}
			
			return await Task.Run(() => 0 == run.console(printer, DotnetUtil.DotnetExe, cl));
		}
		catch (Exception e1) {
			var s = e1.ToStringWithoutStack();
			dialog.showError("Failed to run dotnet.exe", s, owner: this);
		}
		return false;
	}
	
	/// <summary>
	/// Gets our <b>NGC.ISettings</b>.
	/// </summary>
	/// <exception cref="Exception"></exception>
	NGC.ISettings _Config => field ??= NGC.Settings.LoadDefaultSettings(_nugetDir);
	
	string _GetCacheDir() {
		try { return NGC.SettingsUtility.GetGlobalPackagesFolder(_Config)?.TrimEnd('\\'); }
		catch { return null; }
	}
	
	class _Source {
		public _Source() {
			Url = UrlList = "https://api.nuget.org/v3/index.json";
			Name = "nuget.org";
			PackageBaseUrl = "https://api.nuget.org/v3-flatcontainer/";
			_packageBaseUrlInited = true;
		}
		
		public _Source(NGC.PackageSource ps) {
			Url = UrlList = ps.Source;
			Name = ps.Name;
			IsLocal = ps.IsLocal;
			if (ps.Credentials is { } cred) _auth = $"{cred.Username}:{cred.Password}"; //tested: auto-decrypts password
		}
		
		public _Source(string url) {
			Url = UrlList = Name = url;
			IsLocal = !url.Starts("http", true);
		}
		
		public string Url { get; }
		public string Name { get; }
		public bool IsLocal { get; }
		readonly string _auth;
		public override string ToString() => Name;
		
		/// <summary>
		/// Gets the base URL of packages, or null if local or <see cref="InitPackageBaseUrl"/> not called or failed.
		/// </summary>
		public string PackageBaseUrl { get; private set; }
		
		/// <summary>
		/// List of URLs for <c>dotnet add package --sources</c>, like <c>"Url;other_url"</c>.
		/// </summary>
		public string UrlList { get; set; }
		
		/// <summary>
		/// Downloads <c>index.json</c> of the source and gets the base URL of packages.
		/// Does nothing if local or already called.
		/// Not thread-safe.
		/// </summary>
		public void InitPackageBaseUrl() {
			if (_packageBaseUrlInited || IsLocal) return;
			try {
				if (!Url.Ends(".json", true)) return;
				var j = internet.http.Get(Url, auth: _auth).Json();
				var ver = (string)j["version"];
				if (!ver.Starts("3.0.")) { Debug_.Print(ver); return; }
				foreach (var v in j["resources"].AsArray()) {
					if (((string)v["@type"])?.Starts("PackageBaseAddress/3.0.") == true) {
						if ((string)v["@id"] is string s1) {
							if (!s1.Ends('/')) s1 += "/";
							PackageBaseUrl = s1;
						}
						break;
					}
				}
			}
			catch (Exception ex) { Debug_.Print(ex); }
			finally { _packageBaseUrlInited = true; }
		}
		bool _packageBaseUrlInited;
		
		/// <summary>
		/// Downloads <c>index.json</c> of a package.
		/// </summary>
		/// <returns>null if local or failed or <see cref="InitPackageBaseUrl"/> not called or failed.</returns>
		public JsonNode GetPackageIndexJson(string package) {
			if (PackageBaseUrl is string pbu) {
				var url = $"{pbu}{package.Lower()}/index.json";
				try {
					var r = internet.http.Get(url, auth: _auth);
					if (r.IsSuccessStatusCode) return r.Json();
					Debug_.PrintIf(r.StatusCode != System.Net.HttpStatusCode.NotFound, r);
				}
				catch (Exception ex) { Debug_.Print(ex); }
			}
			return null;
		}
		
		public string[] GetPackageVersions(string package) {
			if (GetPackageIndexJson(package) is JsonNode j) {
				if (j["versions"]?.AsArray() is { } versions) {
					var a = versions.Select(o => (string)o).ToArray();
					if (a.Length > 1 && NuGet.Versioning.NuGetVersion.Parse(a[0]) > NuGet.Versioning.NuGetVersion.Parse(a[^1])) Array.Reverse(a); //eg in GitHub Packages the list is in reverse order than in nuget.org
					return a;
				}
			}
			return null;
		}
		
		public byte[] GetPackageIcon(_TreeItem t) {
			if (PackageBaseUrl is string pbu) {
				var url = $"{pbu}{t.Name.Lower()}/{t.Version.Lower()}/icon";
				try {
					var r = internet.http.Get(url, auth: _auth);
					if (r.IsSuccessStatusCode) return r.Bytes();
					if (r.StatusCode == System.Net.HttpStatusCode.NotFound) return [];
					Debug_.Print(r);
				}
				catch (Exception ex) { Debug_.Print(ex); }
			}
			return null;
		}
	}
	
	void _InitSources() {
		_sources = [new()]; //nuget.org
		_dSources = new(StringComparer.OrdinalIgnoreCase) { { _sources[0].Url, _sources[0] } };
		int nNonlocal = 0;
		try {
			var provider = new NGC.PackageSourceProvider(_Config);
			foreach (var v in provider.LoadPackageSources()) {
				if (!v.IsEnabled) continue;
				if (v.Source == _sources[0].Url) continue;
				_Source so = new(v);
				if (!_dSources.TryAdd(so.Url, so)) continue; //note: no warning
				_sources.Add(so);
				if (!v.IsLocal) nNonlocal++;
			}
		}
		catch (Exception ex) { Debug_.Print(ex); }
		
		if (nNonlocal > 0) { //create UrlList for each
			var b = new StringBuilder();
			foreach (var so in _sources.Skip(1)) {
				if (so.IsLocal) continue;
				b.Clear();
				b.Append(so.Url);
				foreach (var k in _sources) if (k != so && !k.IsLocal) b.Append(';').Append(k.Url);
				so.UrlList = b.ToString();
			}
		}
		
		foreach (var v in _sources) _cbSource.Items.Add(v);
		_cbSource.Items.Add("Try all listed sources");
		_cbSource.SelectedIndex = 0;
	}
	
	List<_Source> _sources;
	Dictionary<string, _Source> _dSources;
	
	_Source _SourceFromUrl(string url) {
		if (_sources is null) return null; //SDK not installed
		if (url.NE()) return null;
		if (_dSources.TryGetValue(url, out var r)) return r;
		Debug_.Print(url);
		return new(url);
	}
	
	async Task<string[]> _GetVersions(_TreeItem t) {
		List<_Source> sources;
		if (t.Source is { } so) {
			if (so.IsLocal) {
				dialog.show("Not supported", "Cannot get package versions from local sources.\nSource: " + so.Name, owner: this);
				return null;
			}
			sources = [so];
		} else {
			sources = _sources;
		}
		var r = await Task.Run(() => {
			foreach (var source in sources) {
				source.InitPackageBaseUrl();
				if (source.GetPackageVersions(t.Name) is { } a) {
					Array.Reverse(a);
					//remove prereleases older than the latest stable version
					int i = 0; while (i < a.Length) if (!a[i++].Contains('-')) break;
					for (; i < a.Length; i++) if (a[i].Contains('-')) a[i] = null;
					return a.Where(o => o != null).ToArray();
				}
			}
			return null;
		});
		return r;
	}
	
	async void _CheckForUpdates() {
		using var _ = _disabler.Disable();
		_tStatus.Text = "Checking for updates...";
		
		var a = _tvroot.Descendants().Where(o => o.Level == 2).ToArray();
		int nStable = 0, nPrerelease = 0;
		
		await Task.Run(() => {
			foreach (var v in _sources) v.InitPackageBaseUrl();
			
			Parallel.ForEach(a, t => {
				t.Updates = null;
				try {
#if true
					string[] versions = null;
					if (t.Source is { } so) {
						versions = so.GetPackageVersions(t.Name);
					} else {
						foreach (var v in _sources) {
							versions = v.GetPackageVersions(t.Name);
							if (versions != null) break;
						}
					}
#else
					var so = t.Source ?? _sources[0];
					var versions = so.GetPackageVersions(t.Name);
#endif
					if (versions.NE_()) return;
					
					string latest = versions[^1], latestPrerelease = null, s;
					if (latest.Contains('-')) {
						latestPrerelease = latest;
						latest = versions.LastOrDefault(o => !o.Contains('-'));
					}
					
					if (latestPrerelease != null) {
						if (t.Version == latestPrerelease) return;
						bool onlyPR = latest is null || t.Version == latest;
						s = onlyPR ? latestPrerelease : $"{latest},  {latestPrerelease}";
						nPrerelease++; if (!onlyPR) nStable++;
					} else {
						if (t.Version == latest) return;
						s = latest;
						nStable++;
					}
					t.Updates = s;
				}
				catch (Exception ex) {
					Debug_.Print($"Failed to check {t.Name}: {ex}");
				}
			});
		});
		
		wpfBuilder.formatTextOf(_tStatus, $"Updates: <s c='green'>{nStable} stable</s>, <s c='blue'>{nPrerelease} prerelease</s>");
		_tv.Redraw(remeasure: true);
	}
	
	static bool _NormalizeCopiedPackageString(ref string s) {
		if (s.Starts(true, "dotnet add package ", "dotnet package add ") > 0) s = s[19..];
		else if (s.RxReplace(@"^.+?\bInstall-Package ", "", out s) > 0) s = s.Replace("-Version ", "--version ");
		else return false;
		return true;
	}
	
	void _PackageFieldTextChanged() {
		_TreeItem select = null;
		var s = _tPackage.Text;
		if (s.Length > 1) {
			if (_NormalizeCopiedPackageString(ref s)) { _tPackage.Text = s; return; } //calls this func again when text changed
			int i = s.IndexOf(' ');
			if (i > 0) s = s[..i];
			select = _tvroot.Descendants().FirstOrDefault(o => !o.IsFolder && o.Name.Find(s, true) >= 0);
		}
		
		if (select != null) _tv.SelectSingle(select);
		else _tv.UnselectAll();
	}
	
	bool _RenameFolder(_TreeItem t, string name) {
		if (name != t.Name) {
			try {
				var dir = _FolderPath(t.Name);
				filesystem.createDirectory(dir); //ensure exists
				filesystem.rename(dir, name);
				_folders[_folders.IndexOf(t.Name)] = name;
				return true;
			}
			catch (Exception ex) { print.it(ex); }
		}
		return false;
	}
	
	_TreeItem _Selected => _tv.SelectedItem as _TreeItem;
	
	string _FolderPath(string folder) => $@"{_nugetDir}\{folder}";
	
	string _ProjPath(string folder) => $@"{_nugetDir}\{folder}\{folder}.csproj";
	
	XElement _LoadProject(string folder) {
		var path = _ProjPath(folder);
		if (filesystem.exists(path))
			try { return XElement.Load(path); }
			catch (Exception ex) { print.warning(ex); }
		return null;
	}
	
	IEnumerable<(string name, string version, string source)> _GetProjectPackages(XElement xr) {
		foreach (var x in xr.XPathSelectElements("/ItemGroup/PackageReference[@Include]")) {
			yield return (x.Attr("Include"), x.Attr("Version"), x.Attr("la-source"));
		}
	}
	
	(XElement x, string name, string version, string source) _GetProjectPackage(XElement xr, string name) {
		foreach (var x in xr.XPathSelectElements("/ItemGroup/PackageReference[@Include]")) {
			string s = x.Attr("Include");
			if (s.Eqi(name)) return (x, s, x.Attr("Version"), x.Attr("la-source"));
		}
		return default;
	}
	
	void _FillTree() {
		List<_TreeItem> a = [];
		_tvroot = new(this, null);
		foreach (var folder in _folders) {
			var k = new _TreeItem(this, folder);
			if (_LoadProject(folder) is { } xr) {
				foreach (var (name, version, source) in _GetProjectPackages(xr)) {
					var t = new _TreeItem(this, name, version, _SourceFromUrl(source));
					k.AddChild(t);
					a.Add(t);
				}
			}
			_tvroot.AddChild(k);
		}
		_tv.SetItems(_tvroot.Children());
		if (_sources != null && a.Count > 0) _DisplayIcons(a, useCache: true); //if SDK installed
	}
	//CONSIDER: display transitive packages too, as child nodes.
	
	async void _DisplayIcons(List<_TreeItem> a, bool useCache) {
		const string c_defaultIcon = "*SimpleIcons.NuGet #55A7DD";
		var cacheDir = folders.ThisAppDataLocal + "nugetIcons";
		
		try {
			if (filesystem.exists(cacheDir, true).Directory) {
				if (useCache) {
					var df = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
					foreach (var v in filesystem.enumFiles(cacheDir, "**m *.png||*.jpg||*.ico||*.a")) df[pathname.getNameNoExt(v.Name)] = v.FullPath;
					for (int i = a.Count; --i >= 0;) {
						if (df.TryGetValue(a[i].Name, out string file)) {
							var ext = pathname.getExtension(file);
							a[i].Icon = ext.Eqi(".a") ? c_defaultIcon : ext.Eqi(".ico") ? file : "imagefile:" + file;
							a.RemoveAt(i);
						}
					}
				}
			} else {
				filesystem.createDirectory(cacheDir);
			}
		}
		catch { return; }
		
		if (a.Count > 0) await Task.Run(_GetIcons);
		_tv.Redraw();
		
		void _GetIcons() {
			foreach (var v in _sources) v.InitPackageBaseUrl();
			
			Parallel.ForEach(a, t => {
				try {
					t.Icon = c_defaultIcon;
					var so = t.Source ?? _sources[0];
					if (so.GetPackageIcon(t) is { } bytes) {
						var fileType = bytes switch { //note: Content-Type unreliable, eg sometimes "application/octet-stream"
							[0x89, 0x50, 0x4E, 0x47, ..] => ".png",
							[0xFF, 0xD8, 0xFF, ..] => ".jpg",
							[0, 0, 1, 0, ..] => ".ico",
							_ => ".a" //no icon or unsupported filetype. Why ".a": if will be "file.a" and "file.png", the `df[pathname.getNameNoExt(v.Name)] = v.FullPath` will choose "file.png".
						};
						var file = $@"{cacheDir}\{t.Name}{fileType}";
						filesystem.saveBytes(file, bytes);
						if (fileType != ".a") t.Icon = fileType == ".ico" ? file : "imagefile:" + file;
					}
				}
				catch (Exception ex) {
					Debug_.Print($"Failed to get icon of {t.Name}: {ex}");
				}
			});
		}
	}
	
	void _AddToTreeOrUpdate(string folder, string package, _TreeItem updating) {
		if (_LoadProject(folder) is not { } xr) return;
		var pr = _GetProjectPackage(xr, package);
		
		//from nuget cache get source and correct-cased name
		if (_GetCacheDir() is string dir) {
			dir = $@"{dir}\{package}\{pr.version}\";
			string name0 = pr.name, source0 = pr.source;
			try { pr.source = (string)JsonNode.Parse(filesystem.loadText(dir + ".nupkg.metadata"))["source"]; } catch { }
			try { pr.name = XmlUtil.LoadElem(out var ns, dir + package + ".nuspec").Element(ns + "metadata").Element(ns + "id").Value; } catch { }
			if (pr.name != name0 || pr.source != source0) {
				if (pr.name != name0) pr.x.SetAttributeValue("Include", pr.name);
				if (pr.source != source0) pr.x.SetAttributeValue("la-source", pr.source);
				try { xr.SaveElem(_ProjPath(folder)); } catch { }
			}
		}
		
		bool isNew = false;
		_TreeItem t = updating;
		if (t is null) {
			var tFolder = _tvroot.Children().FirstOrDefault(o => o.Name == folder);
			if (tFolder is null) {
				tFolder = new(this, folder);
				var tBefore = _tvroot.Children().FirstOrDefault(o => o.Name.CompareTo(folder) > 0);
				if (tBefore != null) tBefore.AddSibling(tFolder, false); else _tvroot.AddChild(tFolder);
			}
			t = tFolder.Children().FirstOrDefault(o => o.Name.Eqi(pr.name));
			if (isNew = t is null) {
				t = new(this, pr.name, pr.version, _SourceFromUrl(pr.source));
				tFolder.AddChild(t);
				_tv.SetItems(_tvroot.Children(), true);
			}
		}
		if (!isNew) {
			t.Update(pr.name, pr.version, _SourceFromUrl(pr.source));
			_tv.Redraw(t, true);
		}
		_tv.SelectSingle(t);
		_DisplayIcons([t], useCache: false);
	}
	
	_TreeItem _tvroot;
	
	class _TreeItem : TreeBase<_TreeItem>, ITreeViewItem {
		DNuget _d;
		bool _isExpanded;
		
		public _TreeItem(DNuget d, string folder) {
			_d = d;
			IsFolder = _isExpanded = true;
			Name = NameVersion = folder;
		}
		
		public _TreeItem(DNuget d, string name, string version, _Source source) {
			_d = d;
			Update(name, version, source);
		}
		
		public string Name { get; private set; }
		public string Version { get; private set; }
		public _Source Source { get; private set; }
		public string NameVersion { get; private set; }
		public string Updates { get; set; }
		public object Icon { get; set; }
		public override string ToString() => NameVersion;
		
		public void Update(string name, string version, _Source source) {
			Name = name;
			Version = version;
			Source = source;
			NameVersion = version == null ? name : $"{name} {version}";
			Updates = null;
		}
		
		#region ITreeViewItem
		
		void ITreeViewItem.SetIsExpanded(bool yes) { _isExpanded = yes; }
		bool ITreeViewItem.IsExpanded => _isExpanded;
		IEnumerable<ITreeViewItem> ITreeViewItem.Items => base.Children();
		public bool IsFolder { get; }
		string ITreeViewItem.DisplayText => Updates is null ? NameVersion : NameVersion + "  ->  " + Updates;
		object ITreeViewItem.Image => IsFolder ? EdIcons.FolderIcon(_isExpanded) : Icon;
		
		int ITreeViewItem.TextColor(TVColorInfo ci) {
			if (Updates is string s) {
				if (s.Contains('-') && !s.Contains(", ")) return 0xFF;
				return 0x9000;
			}
			return -1;
		}
		
		void ITreeViewItem.SetNewText(string text) { if (_d._RenameFolder(this, text)) Name = NameVersion = text; }
		
		#endregion
	}
}


================================================
FILE: Au.Editor/Tools/Docr.cs
================================================
using System.Windows.Controls;
using Au.Controls;
using System.Windows.Documents;

namespace ToolLand;

class Docr : KDialogWindow {
	wnd _wnd, _con;
	bool _useCon;

	KSciInfoBox _info;
	Button _bTest, _bInsert;
	ComboBox _cbAction;
	const int c_waitnot = 6, c_finder = 7;
	KSciCodeBoxWnd _code;
	TextBox _text;

	KCheckBox exceptionC, exceptionnoC;
	KCheckTextBox rectC, scaleC, skipC, waitC, waitnoC;
	KCheckComboBox wiflagsC, engineC;
	KTextExpressionBox textC;
	//CONSIDER: add wnd Activate if pixels from screen.

	public Docr() {
		Title = "Find OCR text";

		_noeventValueChanged = true;
		var b = new wpfBuilder(this).WinSize((460, 440..), (500, 400..)).Columns(160, 20, -1);
		b.R.Add(out _info).Height(80);
		b.R.StartGrid().Columns(76, 76, 76, -1);
		//row 1
		b.R.AddButton("Window...", _ => _bWnd_Click());
		b.AddButton(out _bTest, "Test", _Test).Disabled().Tooltip("Execute the code now (except wait/fail/mouse) and show the rectangle");
		b.AddButton(out _bInsert, "Insert", _Insert).Disabled();
		b.Add(out _cbAction).Align("L").Width(140).Items("|MouseMove|MouseClick|MouseClickD|MouseClickR|PostClick|waitNot|new ocrFinder").Select(2);
		//row 2
		b.StartStack();
		waitC = b.xAddCheckText("Wait", "1", check: true); b.Width(53);
		(waitnoC = b.xAddCheckText("Timeout", "5")).Visible = false; b.Width(53);
		b.xAddCheck(out exceptionC, "Fail if not found").Checked();
		b.xAddCheck(out exceptionnoC, "Fail on timeout").Checked().Hidden(null);
		b.End();
		b.End();
		//row 3
		//left
		b.R.StartGrid();
		b.R.Add("Find text:", out textC, row2: 0);
		skipC = b.R.xAddCheckText("Skip");
		b.End();
		//right
		b.Skip().xStartPropertyGrid();
		rectC = b.xAddCheckText("Rectangle", "0, 0, ^0, ^0");
		b.And(21).AddButton("···", _bRect_Click).Tooltip("Select rectangle in window").Height(19); //info: the '·' in "···" is U+00B7, because '.' is too low
		wiflagsC = b.xAddCheckCombo("Flags", "WindowDC|PrintWindow");
		scaleC = b.xAddCheckText("Scale");
		engineC = b.xAddCheckCombo("OCR engine", "Win10|Tesseract|GoogleCloud|MicrosoftAzure");
		b.And(21).AddButton("···", _bEngine_Click).Tooltip("OCR engine parameters").Height(19);
		b.xEndPropertyGrid();

		b.Row(100).xAddInBorder(out _code);
		b.xAddSplitterH(span: -1);
		b.Row(-1).Add(out _text).Margin("T").Multiline().Readonly();
		b.End();
		_noeventValueChanged = false;

		WndSavedRect.Restore(this, LA.App.Settings.wndpos.ocr, o => LA.App.Settings.wndpos.ocr = o);
	}

	static Docr() {
		TUtil.OnAnyCheckTextBoxValueChanged<Docr>((d, o) => d._AnyCheckTextBoxComboValueChanged(o), comboToo: true);
	}

	protected override void OnSourceInitialized(EventArgs e) {
		base.OnSourceInitialized(e);

		_InitInfo();
		//_bWnd_Click(); //rejected. Confusing.
	}

	void _bWnd_Click() {
		var r = _code.AaShowWndTool(this, _wnd, _con, checkControl: _wnd.Is0 || _useCon);
		if (r.ok) _SetWndCon(r.w, r.con, r.useCon);
	}

	void _bRect_Click(WBButtonClickArgs e) {
		if (_wnd.Is0) return;
		var m = new popupMenu();
		m["Select rectangle..."] = o => { if (_CaptureRect(out var r)) rectC.Set(true, r.rect.ToStringFormat("({0}, {1}, {4}, {5})")); };
		m.Show(owner: this);
	}

	void _SetWndCon(wnd w, wnd con, bool useCon) {
		var wPrev = _AreaWnd;
		_wnd = w;
		_con = con == w ? default : con;

		_noeventValueChanged = true;
		_useCon = useCon && !_con.Is0;
		if (_AreaWnd != wPrev) rectC.c.IsChecked = false;
		_noeventValueChanged = false;
		_FormatCode();
	}

	//when checked/unchecked any checkbox, and when text changed of any textbox
	void _AnyCheckTextBoxComboValueChanged(object source) {
		if (!_noeventValueChanged) {
			_noeventValueChanged = true;
			//print.it("source", source);
			if (source is KCheckBox c) {
				//bool on = c.IsChecked;
			} else if (source is TextBox t && t.Tag is KCheckTextBox k) {
				_noeventValueChanged = _formattedOnValueChanged = false; //allow auto-check but prevent formatting twice
				k.CheckIfTextNotEmpty();
				if (_formattedOnValueChanged) return;
			} else if (source is ComboBox u && u.Tag is KCheckComboBox m) {
				_noeventValueChanged = _formattedOnValueChanged = false; //allow auto-check but prevent formatting twice
				m.c.IsChecked = true;
				if (_formattedOnValueChanged) return;
			} else if (source == _cbAction) {
				int i = _cbAction.SelectedIndex;
				waitnoC.Visible = i == c_waitnot;
				exceptionnoC.Visibility = i == c_waitnot ? System.Windows.Visibility.Visible : System.Windows.Visibility.Collapsed;
				waitC.Visible = i < c_waitnot;
				exceptionC.Visibility = i < c_waitnot ? System.Windows.Visibility.Visible : System.Windows.Visibility.Collapsed;
			}
			_noeventValueChanged = false;
			_formattedOnValueChanged = true;
			//print.it("format");
			_FormatCode();
		}
	}
	bool _noeventValueChanged, _formattedOnValueChanged;

	(string code, string wndVar) _FormatCode(bool forTest = false) {
		//print.it("_FormatCode");
		StringBuilder b = new(), bb = new(); //b for the find/finder function line and everything after it; bb for everything before it.

		string waitTime = null;
		bool finder = false, waitNot = false, wait = false, orThrow = false, notTimeout = false;
		int iAction = 0;
		if (!forTest) {
			iAction = _cbAction.SelectedIndex;
			if (finder = iAction == c_finder) {

			} else if (waitNot = iAction == c_waitnot) {
				notTimeout = waitnoC.GetText(out waitTime, emptyToo: true);
				orThrow = notTimeout && exceptionnoC.IsChecked;
				if (waitTime.NE()) waitTime = "0";
			} else {
				wait = waitC.GetText(out waitTime, emptyToo: true);
				orThrow = exceptionC.IsChecked;
			}
		}

		string wndCode = null, wndVar = null;
		if (finder) {
			b.Append("var f = new ocrFinder(");
		} else {
			b.Append(waitNot ? "ocr.waitNot(" : "ocr.find(");
			if (wait || waitNot || orThrow) if (b.AppendWaitTime(waitTime ?? "0", orThrow, appendAlways: waitNot)) b.Append(", ");

			(wndCode, wndVar) = _code.AaGetWndFindCode(forTest, _wnd, _useCon ? _con : default);
			bb.AppendLine(wndCode);

			if (rectC.GetText(out var sRect)) b.AppendFormat("new({0}, {1})", wndVar, sRect);
			else b.Append(wndVar);
		}

		bool isEngine = engineC.GetIndex(out var ieng);
		if (isEngine) {
			var g = LA.App.Settings.ocr ?? new();
			bb.AppendFormat("{0}engine = new Ocr{1}(", forTest ? "var " : "ocr.", engineC.t.SelectedItem);
			if (ieng == 3) bb.AppendStringArg(g.mUrl).AppendStringArg(g.mKey);
			else if (ieng == 2) bb.AppendStringArg(g.gKey);
			bb.Append(")");
			if (ieng switch { 0 => !g.wLang.NE(), 1 => !g.tLang.NE() || !g.tCL.NE(), 2 => !g.gFeat.NE() || !g.gIC.NE(), _ => false }) {
				bb.Append(" { ");
				switch (ieng) {
				case 0:
					bb.Append("Language = ").AppendStringArg(g.wLang, noComma: true);
					break;
				case 1:
					if (!g.tLang.NE()) bb.Append("Language = ").AppendStringArg(g.tLang, noComma: true);
					if (!g.tCL.NE()) bb.Append(g.tLang.NE() ? "" : ", ").Append("CommandLine = ").AppendStringArg(g.tCL, noComma: true);
					break;
				case 2:
					if (!g.gFeat.NE()) bb.Append("Features = ").AppendStringArg(g.gFeat, noComma: true);
					if (!g.gIC.NE()) bb.Append(g.gFeat.NE() ? "" : ", ").Append("ImageContext = ").AppendStringArg(g.gIC, noComma: true);
					break;
				}
				bb.Append(" }");
			}
			bb.AppendLine(";");
		}

		b.AppendStringArg(textC.Text);

		if (wiflagsC.GetText(out var wiFlag)) b.AppendOtherArg("OcrFlags." + wiFlag);

		if (scaleC.GetText(out var scale) && scale != "0") b.AppendOtherArg(scale, "scale");

		if (forTest) b.AppendOtherArg(isEngine ? "engine" : "new OcrWin10()", "engine"); //don't set/use ocr.engine when testing

		if (skipC.GetText(out var skip)) b.AppendOtherArg(skip, "skip");

		b.Append(");");

		if (!forTest) {
			if (waitNot) {
				if (!orThrow && notTimeout) bb.Append("bool ok = ");
			} else if (!finder) {
				string mouse = iAction switch {
					1 => "t.MouseMove();",
					2 => "t.MouseClick();",
					3 => "t.MouseClickD();",
					4 => "t.MouseClickR();",
					5 => "t.PostClick();",
					_ => null
				};
				bb.Append("var t = ");
				if (!orThrow || mouse != null) b.AppendLine();
				if (!orThrow) b.Append("if(t != null) { ");
				if (mouse != null) b.Append(mouse);
				if (!orThrow) b.Append(" } else { print.it(\"not found\"); }");
			}
		}

		var R = bb.Append(b).ToString();

		if (!forTest) {
			_code.AaSetText(R, wndCode.Lenn());
			_bTest.IsEnabled = true; _bInsert.IsEnabled = true;
		}

		return (R, wndVar);
	}

	#region util, misc

	wnd _AreaWnd => _useCon ? _con : _wnd;

	bool _CaptureRect(out CIUResult r) {
		if (!CaptureScreen.ImageColorRectUI(out r, CIUFlags.Rectangle, this)) return false;

		var w2 = _useCon ? r.w : r.w.Window;
		string es = null;
		bool otherWindow = w2 != _AreaWnd;
		if (otherWindow) es = "Whole rectangle must be in the client area of the captured image's window or control.";
		if (es != null) {
			dialog.showError(null, es, owner: this);
			return false;
		}

		w2.MapScreenToClient(ref r.rect);
		return true;
	}

	#endregion

	#region Insert, Test

	///// <summary>
	///// When OK clicked, contains C# code. Else null.
	///// </summary>
	//public string aaResultCode { get; private set; }

	void _Insert(WBButtonClickArgs _1) {
		if (_close) {
			base.Close();
		} else if (_code.aaaText.NullIfEmpty_() is string s) {
			LA.InsertCode.Statements(new(s, makeVarName1: true));
			//if (_Opt.Has(_EOptions.InsertClose)) {
			//	base.Close();
			//} else {
			_close = true;
			_bInsert.Content = "Close";
			_bInsert.MouseLeave += (_, _) => {
				_close = !true;
				_bInsert.Content = "Insert";
			};
			//}

			if (rectC.GetText(out var sRect)) TUtil.InfoRectCoord(_AreaWnd, sRect);
		}
	}
	bool _close;

	void _Test(WBButtonClickArgs _1) {
		var (code, wndVar) = _FormatCode(true); if (code.NE()) return;
		ocrFinder.testing_ = (true, null);
		var rr = TUtil.RunTestFindObject(this, code, wndVar, _AreaWnd, getRect: o => (o as ocr).GetRect(inScreen: true), activateWindow: true);
		_text.Text = ocrFinder.testing_.result?.Text;
		ocrFinder.testing_ = default;
		_info.InfoErrorOrInfo(rr.info);
	}

	#endregion

	#region info

	//TUtil.CommonInfos _commonInfos;
	void _InitInfo() {
		//_commonInfos = new TUtil.CommonInfos(_info);

		_info.aaaText = c_dialogInfo;
		_info.AaAddElem(this, c_dialogInfo);

		_info.InfoCT(rectC,
@"Limit the area to this rectangle in the client area of the window or control. Smaller = faster.
Can be <b>RECT<>: <code>(left, top, width, height)</code>. Or 4 <help Au.Types.Coord>Coord<>: <code>left, top, right, bottom</code>; for example <code>^0</code> is right/bottom edge, <code>0.5f</code> is center.
If action is ocrFinder, this is used only for testing.");
		_info.InfoCO(wiflagsC,
@"Get pixels from window, not from screen.
The window can be in the background. Also with WindowDC faster.
Works not with all windows. Try WindowDC, then PrintWindow if fails.");
		_info.InfoCT(scaleC,
@"Scale factor. Value 2 or 3 may improve OCR results.
More info: <help>ocr.find<>.");
		_info.InfoCO(engineC,
@"OCR engine.
• <i>OcrWin10</i> - fast, poor accuracy, available on Windows 10 and later.
• <i>OcrTesseract</i> - slower, poor accuracy, available if Tesseract is installed, supports more languages.
• <i>OcrGoogleCloud</i> - slow, good accuracy, uses internet, need Google Cloud account, may be not free.
• <i>OcrMicrosoftAzure</i> - slowest, good accuracy, uses internet, need Microsoft Azure account, may be not free.

Normally you specify OCR engine once in script. If unchecked, will use the previously specified engine, or OcrWin10 if unspecified.");
		_info.Info(textC, "Find text", @"Text to find in OCR results. Can have prefix:
• <mono>**r<> - PCRE regular expression. Example: <mono>@""**r \bwhole words\b""<>
• <mono>**R<> - .NET regular expression.
• <mono>**i<> - case-insensitive.
• <mono>**t<> - case-sensitive (default).

Separate words with single space.");
		_info.InfoCT(skipC,
@"0-based index of matching text.
For example, if 1, finds the second matching text.");
		_info.Info(_cbAction, "Action", "Call this function when found. Or instead of <b>find<> call <b>waitNot<> or create new <b>ocrFinder<>.");
		_info.InfoCT(waitC, @"The wait timeout, seconds.
The function waits max this time interval. On timeout throws exception if <b>Fail...<> checked, else returns null. If empty, uses 8e88 (infinite).");
		_info.InfoCT(waitnoC, @"The wait timeout, seconds.
The function waits max this time interval. On timeout throws exception if <b>Fail...<> checked, else returns false. No timeout if unchecked or 0 or empty.");
		_info.InfoC(exceptionC,
@"Throw exception if not found.
If unchecked, returns null.");
		_info.InfoC(exceptionnoC,
@"Throw exception on timeout.
If unchecked, returns false.");
	}

	const string c_dialogInfo =
@"This tool creates <help>ocr.find<> code (OCR-extract <help wnd.find>window<> text and find).
1. Select a window or control. Test, OK.
2. Enter text to find.
3. Click the Test button to see how the 'find' code works.
4. If need, change some fields.
5. Click Insert. Click Close, or repeat 1-5 to create new code.
6. If need, edit the code in editor. For example rename variables, delete duplicate wnd.find lines, replace part of window name with *, add code to click the text.";

	#endregion

	#region OCR engine properties

	private void _bEngine_Click(WBButtonClickArgs e) {
		var g = LA.App.Settings.ocr ?? new();

		var b = new wpfBuilder("OCR engine properties").WinSize(500);
		b.Window.UseLayoutRounding = true;

		_StartGroupBox("OcrWin10");
		b.R.Add("Language", out KComboExpressionBox wLang, g.wLang).Editable().Tooltip("An installed language that supports OCR.\nIf empty, uses the default OCR language.");
		if (osVersion.minWin10) b.Items(true, cb => { try { cb.ItemsSource = new OcrWin10().AvailableLanguages.Select(o => o.tag); } catch { } });
		b.End();

		_StartGroupBox("OcrTesseract");
		//b.R.AddButton("Download", _=> run.itSafe("https://github.com/UB-Mannheim/tesseract/wiki")); //the link is in doc
		b.R.Add("Language", out KComboExpressionBox tLang, g.tLang).Editable().Tooltip("A language installed with Tesseract.\nIf empty, uses eng. Can be sevaral, like eng+deu.");
		b.Items(true, cb => { try { cb.ItemsSource = new OcrTesseract().AvailableLanguages; } catch { } });
		b.R.Add("Command line", out KTextExpressionBox tCL, g.tCL).Tooltip("Additional tesseract.exe command line arguments.");
		b.End();

		_StartGroupBox("OcrGoogleCloud");
		b.R.Add("API key *", out KComboExpressionBox gKey, g.gKey).Items("""@@Environment.GetEnvironmentVariable("API_KEY_1")""");
		b.R.Add("Features", out KTextExpressionBox gFeat, g.gFeat).Multiline().Tooltip("Feature type, like TEXT_DETECTION, or JSON of features array content.\nIf empty, uses DOCUMENT_TEXT_DETECTION.");
		b.R.Add("Image context", out KTextExpressionBox gIC, g.gIC).Multiline().Tooltip("JSON of imageContext.\nFor example can specify language (usually don't need).");
		b.End();

		_StartGroupBox("OcrMicrosoftAzure");
		b.R.Add("Endpoint URL *", out KComboExpressionBox mUrl, g.mUrl).Items("https://replacethis.cognitiveservices.azure.com/");
		b.R.Add("API key *", out KComboExpressionBox mKey, g.mKey).Items("""@@Environment.GetEnvironmentVariable("API_KEY_2")""");
		b.End();

		b.R.StartGrid().Columns(-1, 0);
		b.Add<TextBlock>("* required");
		b.AddOkCancel();
		b.End();
		b.End();
		
		if (!b.ShowDialog(this)) return;

		g.wLang = _Text(wLang.Text);
		g.tLang = _Text(tLang.Text);
		g.tCL = _Text(tCL.Text);
		g.gKey = _Text(gKey.Text);
		g.gFeat = _Text(gFeat.Text);
		g.gIC = _Text(gIC.Text);
		g.mUrl = _Text(mUrl.Text);
		g.mKey = _Text(mKey.Text);

		static string _Text(string s) => s.Trim().NullIfEmpty_();

		LA.App.Settings.ocr = g;
		_FormatCode();

		void _StartGroupBox(string engine) {
			var hl = new Hyperlink(new Run(engine));
			hl.Click += (_, _) => HelpUtil.AuHelp("Au.More." + engine);
			b.R.StartGrid<KGroupBox>(hl).Columns(100, -1);
		}
	}

	#endregion
}


================================================
FILE: Au.Editor/Tools/Duiimage.cs
================================================
using System.Windows.Controls;
using Au.Controls;
using System.Windows.Input;
using System.Windows.Interop;
using System.Drawing;

//FUTURE: add image tools: eraser (to draw mask, ie transparent areas), crop.

//FUTURE: if there are screens with different DPI, suggest to capture on each screen. Then code:
//string image = screen.of(w).Dpi switch {
//	120 => @"image:",
//	_ => @"image:"
//};

namespace ToolLand;

class Duiimage : KDialogWindow {
	wnd _wnd, _con;
	bool _useCon;
	Bitmap _image;
	RECT _rect;
	bool _isColor;
	uint _color;
	string _imageFile;

	KSciInfoBox _info;
	KPopup _ttInfo;
	Button _bTest, _bInsert, _bMore, _bCapture;
	ComboBox _cbAction;
	const int c_waitnot = 8, c_finder = 9;
	_PictureBox _pict;
	KSciCodeBoxWnd _code;

	KCheckBox controlC, allC, exceptionC, exceptionnoC;
	KCheckTextBox rectC, diffC, skipC, waitC, waitnoC;
	KCheckComboBox wiflagsC;
	//CONSIDER: add mouse xy like in Delm.
	//CONSIDER: add wnd Activate if pixels from screen.

	public Duiimage(wnd wCapture = default) {
		Title = "Find image or color in window";

		_noeventValueChanged = true;
		var b = new wpfBuilder(this).WinSize((450, 400..), (380, 330..)).Columns(160, -1);
		b.R.Add(out _info).Height(60);
		b.R.StartGrid().Columns(76, 76, 76, -1);
		//row 1
		b.R.AddButton(out _bCapture, "Capture", _ => _Capture());
		b.AddButton(out _bTest, "Test", _Test).Disabled().Tooltip("Execute the code now (except wait/fail/mouse) and show the rectangle");
		b.AddButton(out _bInsert, "Insert", _Insert).Disabled();
		b.Add(out _cbAction).Align("L").Width(140).Items("|MouseMove|MouseClick|MouseClickD|MouseClickR|PostClick|PostClickD|PostClickR|waitNot|new uiimageFinder").Select(2);
		//row 3
		b.R.AddButton(out _bMore, "More ▾", _bEtc_Click).Align("L");
		b.StartStack();
		waitC = b.xAddCheckText("Wait", "1", check: true); b.Width(53);
		(waitnoC = b.xAddCheckText("Timeout", "5")).Visible = false; b.Width(53);
		b.xAddCheck(out exceptionC, "Fail if not found").Checked();
		b.xAddCheck(out exceptionnoC, "Fail on timeout").Checked().Hidden(null);
		b.End();
		b.End();
		//row 4
		b.R.AddButton("Window...", _bWnd_Click).And(-70).Add(out controlC, "Control").Disabled();
		b.xStartPropertyGrid();
		rectC = b.xAddCheckText("Rectangle", "0, 0, ^0, ^0");
		b.And(21).AddButton("···", _bRect_Click).Height(19);
		wiflagsC = b.xAddCheckCombo("Flags", "WindowDC|PrintWindow");
		diffC = b.xAddCheckText("Color diff", "10");
		b.And(60).AddButton("Detect", _bDiff_Click).Tooltip("Detects the smallest diff value that allows to find the image");
		skipC = b.xAddCheckText("Skip");
		b.xAddCheck(out allC, "Get all", noR: true);
		b.xEndPropertyGrid(); b.SpanRows(2);

		b.Row(80).xAddInBorder(out _pict); b.Span(1);
		b.Row(-1).xAddInBorder(out _code);
		b.End();
		_noeventValueChanged = false;

		WndSavedRect.Restore(this, LA.App.Settings.wndpos.uiimage, o => LA.App.Settings.wndpos.uiimage = o);

		if (!wCapture.Is0) {
			WindowState = System.Windows.WindowState.Minimized;
			wiflagsC.c.IsChecked = !(wCapture.HasExStyle(WSE.NOREDIRECTIONBITMAP) || wCapture.ChildAll().Any(o => o.HasExStyle(WSE.NOREDIRECTIONBITMAP)));
			b.Loaded += () => {
				_Capture(wCapture);
			};
		}
	}

	static Duiimage() {
		TUtil.OnAnyCheckTextBoxValueChanged<Duiimage>((d, o) => d._AnyCheckTextBoxComboValueChanged(o), comboToo: true);
	}

	protected override void OnSourceInitialized(EventArgs e) {
		base.OnSourceInitialized(e);

		_InitInfo();
	}

	protected override void OnClosed(EventArgs e) {
		if (_image != null) _pict.Image = _image = null;

		base.OnClosed(e);
	}

	void _Capture(wnd wCapture = default) {
		if (!_CaptureImageOrRect(false, out var r, wCapture)) return;
		_imageFile = null;
		_SetImage(r);

		if (r.possiblyWrongWindow) {
			dialog.showWarning("Possibly wrong window", "The window that contained the captured image possibly disappeared while capturing. Please review the code. If the window is wrong, click the [Window...] button and capture the correct window; or capture later with the 'Find window' tool or 'Quick capturing' hotkey.", owner: this);
		}

		if (_Flags is 0 or CIUFlags.PrintWindow && Dpi.IsWindowVirtualized(r.w)) {
			TUtil.InfoTooltip(ref _ttInfo, _bCapture, """
Note: The window is DPI-scaled. Its pixel colors will change after resizing, and the code may stop working.
To avoid it, capture with flag WindowDC. Or try to move the window to another screen.
""");
		}
	}

	void _bRect_Click(WBButtonClickArgs e) {
		if (_wnd.Is0) return;
		var m = new popupMenu();
		m["Select rectangle..."] = o => { if (_CaptureImageOrRect(true, out var r)) _SetRect(r.rect); };
		if (_image != null) m["Rectangle of the captured image"] = o => _SetRect(_rect);
		m.Show(owner: this);
		void _SetRect(RECT k) => rectC.Set(true, k.ToStringFormat("({0}, {1}, {4}, {5})"));
	}

	void _bDiff_Click(WBButtonClickArgs e) {
		if (_image == null || _wnd.Is0) return;
		_wnd.ActivateL();
		300.ms();
		string es = null;
		try {
			using var b = CaptureScreen.Image(_AreaWnd, flags: _Flags.ToCIFlags_());
			var im = _isColor ? (IFImage)_color : _image;
			int maxFound = 0, minNotfound = 0;
			if (!new uiimageFinder(im).Exists(b)) {
				for (maxFound = 101; maxFound - minNotfound > 1;) {
					int i = (minNotfound + maxFound) / 2;
					if (new uiimageFinder(im, diff: i).Exists(b)) maxFound = i; else minNotfound = i;
				}
			}
			if (maxFound <= 100) {
				_noeventValueChanged = true;
				diffC.t.Text = maxFound.ToS();
				diffC.c.IsChecked = maxFound > 0;
				_noeventValueChanged = false;
			} else es = "Can't find with any diff.";
		}
		catch (Exception e1) { es = e1.ToStringWithoutStack(); }
		finally { this.Hwnd().ActivateL(); }
		if (es != null) TUtil.InfoTooltip(ref _ttInfo, e.Button, es);
	}

	CIUFlags _Flags => !wiflagsC.c.IsChecked ? 0 : wiflagsC.t.SelectedIndex switch { 1 => CIUFlags.PrintWindow, _ => CIUFlags.WindowDC };

	bool _CaptureImageOrRect(bool rect, out CIUResult r, wnd wCapture = default) {
		_ttInfo?.Close();

		var fl = rect ? CIUFlags.Rectangle : _Flags;
		if (!CaptureScreen.ImageColorRectUI(out r, fl, this, wCapture)) return false;

		var w2 = (!rect || _useCon) ? r.w : r.w.Window;
		string es = null;
		if (rect) {
			bool otherWindow = w2 != _AreaWnd;
			if (otherWindow) es = "Whole rectangle must be in the client area of the captured image's window or control.";
		} else if (r.w.Is0) {
			r.image?.Dispose(); r.image = null;
			es = "Whole image must be in the client area of a single window.";
		}
		if (es != null) {
			dialog.showError(null, es, owner: this);
			return false;
		}

		w2.MapScreenToClient(ref r.rect);
		return true;
	}

	//Use r on Capture. Use image on Open or Paste.
	void _SetImage(CIUResult r = null, Bitmap image = null) {
		if (r != null) { //on Capture
			var w = r.w.Window; if (w.Is0) return;
			_SetWndCon(w, r.w, true, false);
			if (_isColor = (r.image == null)) {
				using var g = Graphics.FromImage(r.image = new Bitmap(16, 16));
				g.Clear(Color.FromArgb((int)r.color));
			}
			_color = r.color & 0xffffff;
			_image = r.image;
			_rect = r.rect;
			if (r.dpiScale != 1 && !_isColor) _rect.Inflate(2, 2);
		} else { //on Open or Paste
			_isColor = false;
			_color = 0;
			_image = image;
			_rect = new RECT(0, 0, image.Width, image.Height);
		}

		//set _pict
		_pict.Image = _image;

		//set _code
		_FormatCode();

		_bTest.IsEnabled = true; _bInsert.IsEnabled = true;

		if (_MultiIsActive /*&& dialog.showYesNo("Add to array?", owner: this)*/) _MultiAdd();
	}

	void _SetWndCon(wnd w, wnd con, bool useCon, bool updateCodeIfNeed) {
		var wPrev = _AreaWnd;
		_wnd = w;
		_con = con == w ? default : con;

		_noeventValueChanged = !updateCodeIfNeed;
		_useCon = useCon && !_con.Is0;
		controlC.IsChecked = _useCon; controlC.IsEnabled = !_con.Is0;
		if (_AreaWnd != wPrev) rectC.c.IsChecked = false;
		_noeventValueChanged = false;
	}

	private void _bWnd_Click(WBButtonClickArgs e) {
		var r = _code.AaShowWndTool(this, _wnd, _con, checkControl: _useCon);
		if (r.ok) _SetWndCon(r.w, r.con, r.useCon, true);
	}

	//when checked/unchecked any checkbox, and when text changed of any textbox or combobox
	void _AnyCheckTextBoxComboValueChanged(object source) {
		if (!_noeventValueChanged) {
			_noeventValueChanged = true;
			//print.it("source", source);
			if (source is KCheckBox c) {
				bool on = c.IsChecked;
				if (c == controlC) {
					if (_useCon = on) _wnd.MapClientToClientOf(_con, ref _rect); else _con.MapClientToClientOf(_wnd, ref _rect);
					rectC.c.IsChecked = false;
				} else if (c == wiflagsC.c) {
					if (_image != null) TUtil.InfoTooltip(ref _ttInfo, c, "After changing flags may need to capture again.\nClick Test. If not found, click Capture.");
				} else if (c == skipC.c) {
					if (on) allC.IsChecked = false;
				} else if (c == allC) {
					if (on) skipC.c.IsChecked = false;
				}
			} else if (source is TextBox t && t.Tag is KCheckTextBox k) {
				_noeventValueChanged = _formattedOnValueChanged = false; //allow auto-check but prevent formatting twice
				k.CheckIfTextNotEmpty();
				if (_formattedOnValueChanged) return;
			} else if (source is ComboBox u && u.Tag is KCheckComboBox m) {
				_noeventValueChanged = _formattedOnValueChanged = false; //allow auto-check but prevent formatting twice
				m.c.IsChecked = true;
				if (_formattedOnValueChanged) return;
			} else if (source == _cbAction) {
				int i = _cbAction.SelectedIndex;
				waitnoC.Visible = i == c_waitnot;
				exceptionnoC.Visibility = i == c_waitnot ? System.Windows.Visibility.Visible : System.Windows.Visibility.Collapsed;
				waitC.Visible = i < c_waitnot;
				exceptionC.Visibility = i < c_waitnot ? System.Windows.Visibility.Visible : System.Windows.Visibility.Collapsed;
				allC.Visibility = i == c_waitnot ? System.Windows.Visibility.Hidden : System.Windows.Visibility.Visible;
			}
			_noeventValueChanged = false;
			_formattedOnValueChanged = true;
			//print.it("format");
			_FormatCode();
		}
	}
	bool _noeventValueChanged, _formattedOnValueChanged;

	(string code, string wndVar) _FormatCode(bool forTest = false) {
		//print.it("_FormatCode");
		if (_image == null) return default;
		string wndCode = null, wndVar = null;
		StringBuilder b = new(), bb = new(); //b for the find/finder function line and everything after it; bb for everything before it.

		string waitTime = null;
		bool finder = false, waitNot = false, wait = false, orThrow = false, notTimeout = false, findAll = false, isMulti = false;
		int iAction = 0;
		if (!forTest) {
			iAction = _cbAction.SelectedIndex;
			if (finder = iAction == c_finder) {

			} else if (waitNot = iAction == c_waitnot) {
				notTimeout = waitnoC.GetText(out waitTime, emptyToo: true);
				orThrow = notTimeout && exceptionnoC.IsChecked;
				if (waitTime.NE()) waitTime = "0";
			} else {
				wait = waitC.GetText(out waitTime, emptyToo: true);
				orThrow = exceptionC.IsChecked;
			}
			findAll = !waitNot && allC.IsChecked;
			isMulti = _multi != null && _multi.Count != 0;
		}
		bool isColor = _isColor && !isMulti;

		if (finder) {
			b.Append("var f = new uiimageFinder(");
		} else {
			b.Append(waitNot ? "uiimage.waitNot(" : "uiimage.find(");
			if (wait || waitNot || orThrow) if (b.AppendWaitTime(waitTime ?? "0", orThrow, appendAlways: waitNot)) b.Append(", ");

			(wndCode, wndVar) = _code.AaGetWndFindCode(forTest, _wnd, _useCon ? _con : default);
			bb.AppendLine(wndCode);

			if (rectC.GetText(out var sRect)) b.AppendFormat("new({0}, {1})", wndVar, sRect);
			else b.Append(wndVar);
		}

		//string imageVar = isColor ? "0x" : ("image" + Environment.TickCount.ToS("X"));
		string imageVar = isColor ? "0x" : "image";
		b.AppendOtherArg(imageVar);
		if (isColor) b.Append(_color.ToString("X6"));

		if (wiflagsC.GetText(out var wiFlag)) b.AppendOtherArg("IFFlags." + wiFlag);

		if (diffC.GetText(out var diff) && diff != "0") b.AppendOtherArg(diff, "diff");

		string also = null;
		if (findAll) {
			also = "o => { a.Add(o); return IFAlso.OkFindMore; }";
		} else if (skipC.GetText(out var skip)) {
			also = "o => o.Skip(" + skip + ")";
		}
		if (also != null) b.AppendOtherArg(also, "also");

		b.Append(");");

		if (!isColor) {
			if (isMulti) {
				bb.AppendLine($"IFImage[] {imageVar} = {{");
				foreach (var v in _multi) bb.Append('\t').Append(v).AppendLine(",");
				bb.Append('}');
			} else {
				bb.Append($"string {imageVar} = ").Append(_CurrentImageString());
			}
			bb.AppendLine(";");
		}

		if (!forTest) {
			if (findAll) bb.AppendLine("var a = new List<uiimage>();");
			if (waitNot) {
				if (!orThrow && notTimeout) bb.Append("bool ok = ");
			} else if (!finder) {
				string mouse = iAction switch {
					1 => "im.MouseMove();",
					2 => "im.MouseClick();",
					3 => "im.MouseClickD();",
					4 => "im.MouseClickR();",
					5 => "im.PostClick();",
					6 => "im.PostClickD();",
					7 => "im.PostClickR();",
					_ => null
				};
				if (findAll) {
					b.Append("\r\nforeach(var im in a) { ");
					if (mouse != null) b.Append(mouse).Append(" 250.ms(); ");
					b.Append('}');
				} else {
					bb.Append("var im = ");
					if (!orThrow || mouse != null) b.AppendLine();
					if (!orThrow) b.Append("if(im != null) { ");
					if (mouse != null) b.Append(mouse);
					if (!orThrow) b.Append(" } else { print.it(\"not found\"); }");
				}
			}
		}

		var R = bb.Append(b).ToString();

		if (!forTest) _code.AaSetText(R, wndCode.Lenn());

		return (R, wndVar);
	}

	#region util, misc

	wnd _AreaWnd => _useCon ? _con : _wnd;

	string _CurrentImageString() {
		if (_isColor) return "0x" + _color.ToString("X6");
		if (_imageFile != null) return "@\"" + _imageFile + "\"";
		var ms = new MemoryStream();
		_image.Save(ms, System.Drawing.Imaging.ImageFormat.Png);
		return "@\"image:" + Convert.ToBase64String(ms.GetBuffer(), 0, (int)ms.Length) + "\"";
	}

	#endregion

	#region menu, open, save, multi

	void _bEtc_Click(WBButtonClickArgs e) {
		bool isImage = _image != null && !_isColor;

		var m = new popupMenu();
		m["Copy image", disable: !isImage] = o => { new clipboardData().AddImage(_image).SetClipboard(); };
		m["Paste image", disable: !clipboardData.contains(ClipFormats.Image)] = o => _PasteImage(e.Button);
		m["Use file..."] = o => _OpenFile(false, e.Button);
		m["Embed file..."] = o => _OpenFile(true, e.Button);
		m["Save as file...", disable: !isImage] = o => _SaveFile();
		m.Separator();
		m["Add to array", disable: _image == null] = o => _MultiMenuAdd();
		m["Remove from array", disable: !_MultiIsActive] = o => _MultiRemove();
		m.Show(owner: this);
	}

	bool _RequireWindow(Button button) {
		if (!_wnd.Is0) return true;
		TUtil.InfoTooltip(ref _ttInfo, button, "At first please select a window with button 'Capture' or 'Window'.");
		return false;
	}

	void _OpenFile(bool embed, Button button) {
		if (!_RequireWindow(button)) return;
		if (!_FileDialog().ShowOpen(out string f, this)) return;
		var im = new Bitmap(f);
		_imageFile = embed ? null : f;
		_SetImage(null, im);
	}

	static FileOpenSaveDialog _FileDialog() => new("{4D1F3AFB-DA1A-45AC-8C12-41DDA5C51CDE}") { FileTypes = "png, bmp|*.png;*.bmp", DefaultExt = "png" };

	bool _SaveFile() {
		if (!_FileDialog().ShowSave(out string f, this)) return false;
		_image.Save(f, f.Ends(".bmp", true) ? System.Drawing.Imaging.ImageFormat.Bmp : System.Drawing.Imaging.ImageFormat.Png);
		_MultiRemove(true);
		_imageFile = f;
		_MultiAdd();
		_FormatCode();
		return true;
	}

	void _PasteImage(Button button) {
		if (!_RequireWindow(button)) return;
		var im = clipboardData.getImage();
		if (im != null) _SetImage(null, im);
	}

	void _MultiMenuAdd() {
		_multi ??= new HashSet<string>();
		_MultiAdd();
	}

	bool _MultiIsActive => _multi != null && _image != null;

	void _MultiAdd() {
		if (!_MultiIsActive) return;
		_multi.Add(_CurrentImageString());
		_FormatCode();
	}
	HashSet<string> _multi;

	void _MultiRemove(bool noUpdateCode = false) {
		if (!_MultiIsActive) return;
		_multi.Remove(_CurrentImageString());
		if (!noUpdateCode) _FormatCode();
	}

	//FUTURE: make transparent.
	//	This code is not useful because images are often alpha-blended with background. Need to make transparent near-color pixels too.
	//	Let the user set color difference with preview. Maybe even draw or flood-fill clicked areas.
	//void _MakeTransparent(int corner)
	//{
	//	int x = 0, y = 0;

	//	_image.MakeTransparent(_image.GetPixel(x, y));
	//	_pict.Invalidate();
	//}

	#endregion

	#region Insert, Test

	///// <summary>
	///// When OK clicked, contains C# code. Else null.
	///// </summary>
	//public string aaResultCode { get; private set; }

	void _Insert(WBButtonClickArgs _1) {
		if (_close) {
			base.Close();
		} else if (_code.aaaText.NullIfEmpty_() is string s) {
			LA.InsertCode.Statements(new(s, makeVarName1: true));
			_close = true;
			_bInsert.Content = "Close";
			_bInsert.MouseLeave += (_, _) => {
				_close = !true;
				_bInsert.Content = "Insert";
			};

			if (rectC.GetText(out var sRect)) TUtil.InfoRectCoord(_AreaWnd, sRect);
		}
	}
	bool _close;

	void _Test(WBButtonClickArgs _1) {
		var (code, wndVar) = _FormatCode(true); if (code.NE()) return;
		var rr = TUtil.RunTestFindObject(this, code, wndVar, _AreaWnd, getRect: o => (o as uiimage).RectInScreen, activateWindow: true);
		_info.InfoErrorOrInfo(rr.info);

		//CONSIDER: don't activate the window if it wasn't active when captured
	}

	#endregion

	#region info

	//TUtil.CommonInfos _commonInfos;
	void _InitInfo() {
		//_commonInfos = new TUtil.CommonInfos(_info);

		_info.aaaText = c_dialogInfo;
		_info.AaAddElem(this, c_dialogInfo);

		_info.InfoC(controlC,
@"Search only in control (if captured), not in whole window.
To change window or/and control name etc, click 'Window...' or edit it in the code field.
With uiimageFinder this is used only for testing.");
		_info.InfoCT(rectC,
@"Limit the search area to this rectangle in the client area of the window or control. Smaller = faster.
Can be <b>RECT<>: <code>(left, top, width, height)</code>. Or 4 <help Au.Types.Coord>Coord<>: <code>left, top, right, bottom</code>; for example <code>^0</code> is right/bottom edge, <code>0.5f</code> is center.
If action is uiimageFinder, this is used only for testing.");
		_info.InfoCO(wiflagsC,
@"Get pixels from window, not from screen.
The window can be in the background. Also with WindowDC faster.
Works not with all windows. Try WindowDC, then PrintWindow if fails.");
		_info.InfoCT(diffC,
@"Maximal allowed color difference.
Valid values: 0 - 100.");
		_info.InfoCT(skipC,
@"0-based index of matching image.
For example, if 1, gets the second matching image.");
		_info.Info(_cbAction, "Action", "Call this function when found. Or instead of <b>find<> call <b>waitNot<> or create new <b>uiimageFinder<>.");
		_info.Info(_bMore, "More",
@"Manage images now.
 • <i>Copy image</i> - copy the image to the clipboard. For example then you can paste it in image editing software.
 • <i>Paste image</i> - paste image from the clipboard. For example from image editing software or Snipping Tool.
 • <b>Use file</b> - use an image file instead of captured image string.
 • <b>Embed file</b> - add image file data to the code as string.
 • <b>Save as file</b> - save the image.
 • <b>Add to array</b> - add this image to a list of images to find.");
		_info.InfoC(allC, "Find all matching images.");
		_info.InfoCT(waitC, @"The wait timeout, seconds.
The function waits max this time interval. On timeout throws exception if <b>Fail...<> checked, else returns null. If empty, uses 8e88 (infinite).");
		_info.InfoCT(waitnoC, @"The wait timeout, seconds.
The function waits max this time interval. On timeout throws exception if <b>Fail...<> checked, else returns false. No timeout if unchecked or 0 or empty.");
		_info.InfoC(exceptionC,
@"Throw exception if not found.
If unchecked, returns null.");
		_info.InfoC(exceptionnoC,
@"Throw exception on timeout.
If unchecked, returns false.");
	}

	const string c_dialogInfo =
@"This tool creates code to find <help uiimage.find>image or color<> in <help wnd.find>window<>.
1. Click the Capture button. Mouse-drag-select the image.
2. Click the Test button to see how the 'find' code works.
3. If need, change some fields.
4. Click Insert. Click Close, or capture/insert again.
5. If need, edit the code in editor. For example rename variables, delete duplicate wnd.find lines, replace part of window name with *, add code to click the image.";

	protected override void OnPreviewKeyDown(KeyEventArgs e) {
		_ttInfo?.Close();
		base.OnPreviewKeyDown(e);
	}

	#endregion

	//display image in HwndHost.
	//	Tried WPF Image, but blurry when high DPI, even if bitmap's DPI is set to match window's DPI.
	//	UseLayoutRounding does not help in this case.
	//	RenderOptions.SetBitmapScalingMode(NearestNeighbor) helps it seems. But why it tries to scale the image, and how many times?
	//	Tried winforms PictureBox, bust sometimes very slowly starts.
	class _PictureBox : HwndHost {
		wnd _w;

		protected override HandleRef BuildWindowCore(HandleRef hwndParent) {
			var wParent = (wnd)hwndParent.Handle;
			_w = WndUtil.CreateWindow(_wndProc = _WndProc, false, "Static", null, WS.CHILD | WS.CLIPCHILDREN, 0, 0, 0, 10, 10, wParent);

			return new HandleRef(this, _w.Handle);
		}

		protected override void DestroyWindowCore(HandleRef hwnd) {
			Api.DestroyWindow(_w);
		}

		public Bitmap Image {
			get => _b;
			set {
				_b?.Dispose();
				_b = value;
				Api.InvalidateRect(_w);
			}
		}
		Bitmap _b;

		WNDPROC _wndProc;
		nint _WndProc(wnd w, int msg, nint wParam, nint lParam) {
			//var pmo = new PrintMsgOptions(Api.WM_NCHITTEST, Api.WM_SETCURSOR, Api.WM_MOUSEMOVE, Api.WM_NCMOUSEMOVE, 0x10c1);
			//if (WndUtil.PrintMsg(out string s, _w, msg, wParam, lParam, pmo)) print.it("<><c green>" + s + "<>");

			switch (msg) {
			case Api.WM_NCHITTEST:
				return Api.HTTRANSPARENT;
			case Api.WM_PAINT:
				var dc = Api.BeginPaint(w, out var ps);
				_WmPaint(dc);
				Api.EndPaint(w, ps);
				return default;
			}

			return Api.DefWindowProc(w, msg, wParam, lParam);
		}

		void _WmPaint(IntPtr dc) {
			using var g = Graphics.FromHdc(dc);
			g.Clear(System.Drawing.SystemColors.AppWorkspace);
			if (_b == null) return;

			g.DrawImage(_b, 0, 0);
		}
	}
}


================================================
FILE: Au.Editor/Tools/Dwnd.cs
================================================
using Au.Controls;
using System.Windows;
using System.Windows.Controls;

//FUTURE: add UI to format code 'w = w.Get.Right();' etc.
//FUTURE: init from code string.
//TODO3: try to find and select control in current tree when captured from same window. Like in Delm.

namespace ToolLand;

[Flags]
enum DwndFlags {
	DontInsert = 1,
	NoControl = 2,
	CheckControl = 4,
}

class Dwnd : KDialogWindow {
	wnd _wnd, _con;
	bool _dontInsert, _noControl, _checkControl;
	string _wndName;
	
	KSciInfoBox _info, _winInfo;
	Button _bTest, _bInsert;
	KCheckBox _cCapture, _cControl, _cActivate, _cException;
	ComboBox _cbFunc;
	Separator _sepControl;
	ScrollViewer _scroller;
	KSciCodeBoxWnd _code;
	KTreeView _tree;
	
	Grid _gCon1, _gCon2;
	DPwnd.Controls _k;
	KCheckTextBox idC, nameC, classC, alsoC, waitW, skipC;
	KCheckBox cHiddenTooW, cCloakedTooW, cHiddenTooC;
	
	public Dwnd(wnd w = default, DwndFlags flags = 0, string title = "Find window") {
		_dontInsert = flags.Has(DwndFlags.DontInsert);
		_noControl = flags.Has(DwndFlags.NoControl);
		_checkControl = flags.Has(DwndFlags.CheckControl);
		
		Title = title;
		
		var b = new wpfBuilder(this).WinSize((500, 450..), (600, 430..)).Columns(-1);
		b.R.Add(out _info).Height(60);
		b.R.StartGrid().Columns(0, 76, 76, 0, 0, -1);
		b.xAddCheckIcon(out _cCapture, "*Unicons.Capture" + LA.EdIcons.red, $"Enable capturing ({LA.App.Settings.delm.hk_capture}) and show window/control rectangles");
		b.AddButton(out _bTest, "Test", _bTest_Click).Disabled().Tooltip("Execute the 'find' part of the code now and show the rectangle");
		b.AddButton(out _bInsert, _dontInsert ? "OK" : "Insert", _Insert).Disabled(); if (!_dontInsert) b.Tooltip("Insert code in editor");
		b.Add(out _cbFunc).Items("find|findOrRun|runAndFind|finder").Tooltip("Function").Width(90);
		_cbFunc.SelectionChanged += _cbFunc_SelectionChanged;
		b.Add(out _cActivate, "Activate").Tooltip("Activate the found window");
		b.Add(out _cException, "Fail if not found").Checked(true).Tooltip("Throw exception if not found");
		//cActivate.CheckChanged += (_, _) => { cException.Visibility = cActivate.IsChecked ? Visibility.Hidden : Visibility.Visible; }; //no, need for control too
		b.End();
		
		//window and control properties and search settings
		b.R.AddSeparator(false).Margin("B");
		b.Row(0); //auto height, else adds v scrollbar when textbox height changes when a textbox text is multiline or too long (with h scrollbar)
		_scroller = b.xStartPropertyGrid("L2 T3 R2 B1"); //actually never shows scrollbar because of row auto height, but sets some options etc
		_scroller.Visibility = Visibility.Hidden;
		b.Columns(-3, 0, -1.2);
		//window
		b.R.Add<TextBlock>("Window").Margin("T1 B3").xSetHeaderProp(); //rejected: vertical headers. Tested, looks not good, too small for vertical Control checkbox.
		b.Row(0).StartGrid();
		_k = new(b, false);
		b.End();
		b.xAddSplitterV(span: 4, thickness: 12);
		b.StartGrid().Columns(44, -1);
		b.xAddCheck(out cHiddenTooW, "Find hidden too");
		b.xAddCheck(out cCloakedTooW, "Find cloaked too");
		_k.also = b.xAddCheckText("also", "o=>true");
		waitW = b.xAddCheckText("wait", "1", check: true);
		b.End();
		//control
		b.R.AddSeparator(false).Margin("T4 B0"); _sepControl = b.Last as Separator;
		b.R.Add(out _cControl, "Control").Margin("T5 B3").xSetHeaderProp();
		b.Row(0).StartGrid().Columns(70, -1); _gCon1 = b.Panel as Grid;
		nameC = b.xAddCheckTextDropdown<KTextExpressionBox>("name");
		classC = b.xAddCheckText<KTextExpressionBox>("class");
		idC = b.xAddCheckText("id");
		b.End().Skip();
		b.StartGrid().Columns(44, -1); _gCon2 = b.Panel as Grid;
		b.xAddCheck(out cHiddenTooC, "Find hidden too");
		alsoC = b.xAddCheckText("also", "o=>true");
		skipC = b.xAddCheckText("skip");
		b.End();
		b.xEndPropertyGrid();
		b.R.AddSeparator(false);
		
		//code
		b.Row(64).xAddInBorder(out _code, "B");
		
		//tree and window info
		b.xAddSplitterH(span: -1);
		b.Row(-1).StartGrid().Columns(-1, 0, -1);
		b.Row(-1).xAddInBorder(out _tree, "TR");
		b.xAddSplitterV();
		b.xAddInBorder(out _winInfo, "TL"); _winInfo.AaWrapLines = false; _winInfo.Name = "window_info";
		b.End();
		
		b.End();
		
		_InitTree();
		
		_con = w;
		
		b.WinProperties(
			topmost: true,
			showActivated: _dontInsert || w.Is0 ? null : false //eg if captured a popup menu, activating this window closes the menu and we cannot get properties
			);
		
		WndSavedRect.Restore(this, LA.App.Settings.wndpos.wnd, o => LA.App.Settings.wndpos.wnd = o);
	}
	
	static Dwnd() {
		TUtil.OnAnyCheckTextBoxValueChanged<Dwnd>((d, o) => d._AnyCheckTextBoxValueChanged(o));
	}
	
	protected override void OnSourceInitialized(EventArgs e) {
		base.OnSourceInitialized(e);
		
		if (!_con.Is0) _SetWnd(false);
		_InitInfo();
		_cCapture.IsChecked = true;
	}
	
	protected override void OnClosing(CancelEventArgs e) {
		_cCapture.IsChecked = false;
		
		base.OnClosing(e);
	}
	
	void _SetWnd(bool captured) {
		_bTest.IsEnabled = true; _bInsert.IsEnabled = true;
		
		var wndOld = _wnd;
		_wnd = _con.Window;
		if (_wnd == _con || _noControl) _con = default;
		bool newWindow = _wnd != wndOld;
		
		_ClearTree();
		if (!_FillProperties(newWindow)) return;
		_FormatCode(false);
		_FillTree();
	}
	
	bool _FillProperties(bool newWindow) {
		bool isCon = !_con.Is0;
		
		_WinInfo f = default;
		
		if (!_GetClassName(_wnd, out f.wClass)) return false; //note: get even if !newWindow, to detect closed window
		if (isCon && !_GetClassName(_con, out f.cClass)) return false;
		
		bool _GetClassName(wnd w, out string cn) {
			cn = w.ClassName; if (cn != null) return true;
			_winInfo.aaaText = "Failed to get " + (w == _wnd ? "window" : "control") + " properties: \r\n" + lastError.message;
			_scroller.Visibility = Visibility.Hidden;
			return false;
		}
		
		_noeventValueChanged = true;
		
		var wndName = _wnd.NameTL_;
		if (newWindow) _k.Fill(_wnd, wndName, f.wClass, f.wProg = _wnd.ProgramName);
		else if (wndName != _wndName) _k.FillChangedName(wndName);
		f.wName = _wndName = wndName;
		
		if (isCon) {
			//name combo
			f.cName = _con.Name;
			int iSel = f.cName.NE() ? -1 : 0;
			var an = new List<string> { TUtil.EscapeWildex(f.cName) };
			_ConNameAdd("***wfName ", f.cWF = _con.NameWinforms);
			/*bool isElm =*/
			_ConNameAdd("***elmName ", f.cElm = _con.NameElm);
			//bool isLabel = _ConNameAdd("***label ", f.cLabel = _con.NameLabel);
			//if(isElm && isLabel && iSel == an.Count - 2 && f.cElm == f.cLabel) iSel++; //if label == elmName, prefer label
			if (iSel < 0) iSel = 0; //never select text, even if all others unavailable
			_ConNameAdd("***text ", f.cText = _con.ControlText);
			bool _ConNameAdd(string prefix, string value) {
				if (value.NE()) return false;
				if (iSel < 0) iSel = an.Count;
				an.Add(prefix + TUtil.EscapeWildex(value));
				return true;
			}
			
			bool idUseful = TUtil.GetUsefulControlId(_con, _wnd, out f.cId);
			//idC.Visible = idUseful;
			idC.Set(idUseful, f.cId.ToS() + (idUseful ? null : " /*probably not useful*/"));
			string sName = an[iSel], sClass = TUtil.StripWndClassName(f.cClass, true);
			nameC.Set(!idUseful, sName, an);
			classC.Set(!idUseful, sClass);
			bool hiddenToo = !_con.IsVisible;
			cHiddenTooC.IsChecked = hiddenToo;
			var skip = idUseful ? null : TUtil.GetControlSkip(_wnd, _con, sName, sClass, hiddenToo);
			skipC.Set(skip != null, skip);
		}
		
		bool checkControl = isCon && _checkControl;
		_cControl.IsChecked = checkControl;
		_ShowControlProperties(showGrid: checkControl, showAll: isCon);
		
		_noeventValueChanged = false;
		
		_scroller.Visibility = Visibility.Visible;
		_FillWindowInfo(f);
		return true;
	}
	
	private void _cbFunc_SelectionChanged(object sender, SelectionChangedEventArgs e) {
		int iFunc = _cbFunc.SelectedIndex;
		_noeventValueChanged = true;
		var vis = iFunc == 3 ? Visibility.Hidden : Visibility.Visible;
		_cActivate.Visibility = vis;
		_cException.Visibility = vis;
		if (iFunc is 1 or 2) _cActivate.IsChecked = true;
		waitW.Visible = iFunc is 0 or 2;
		if (iFunc == 2) {
			if (waitW.t.Text == "1") waitW.t.Text = "30";
			waitW.c.IsChecked = true;
		}
		_noeventValueChanged = false;
		_FormatCode();
	}
	
	//when checked/unchecked any checkbox, and when text changed of any textbox
	void _AnyCheckTextBoxValueChanged(object source) {
		if (source == _cCapture) {
			_cCapture_CheckedChanged();
		} else if (!_noeventValueChanged) {
			_noeventValueChanged = true;
			if (source is KCheckBox c) {
				bool on = c.IsChecked;
				if (c == _cControl) {
					_checkControl = on;
					_ShowControlProperties(on, null);
				}
			} else if (source is TextBox t && t.Tag is KCheckTextBox k) {
				_noeventValueChanged = _formattedOnValueChanged = false; //allow auto-check but prevent formatting twice
				k.CheckIfTextNotEmpty();
				if (_formattedOnValueChanged) return;
			}
			_noeventValueChanged = false;
			_formattedOnValueChanged = true;
			_FormatCode();
		}
	}
	bool _noeventValueChanged = true, _formattedOnValueChanged;
	
	void _ShowControlProperties(bool showGrid, bool? showAll) {
		if (showAll != null) {
			var vis = showAll.Value ? Visibility.Visible : Visibility.Hidden;
			_cControl.Visibility = vis;
			_sepControl.Visibility = vis;
			_gCon1.Visibility = vis;
			_gCon2.Visibility = vis;
		}
		_gCon1.IsEnabled = showGrid;
		_gCon2.IsEnabled = showGrid;
	}
	
	(string code, string wndVar) _FormatCode(bool forTest = false) {
		if (!_scroller.IsVisible) return default; //still not captured, or failed to get window props
		int iFunc = _cbFunc.SelectedIndex;
		
		var f = new TUtil.WindowFindCodeFormatter {
			Test = forTest,
			Finder = iFunc == 3,
			NeedControl = !_con.Is0 && _cControl.IsChecked,
			Throw = _cException.IsChecked,
			Activate = _cActivate.IsChecked,
			hiddenTooW = cHiddenTooW.IsChecked,
			cloakedTooW = cCloakedTooW.IsChecked,
			hiddenTooC = cHiddenTooC.IsChecked,
		};
		
		if (!forTest && iFunc is 1 or 2) {
			if (WndCopyData.SendReceive<char>(ScriptEditor.WndMsg_, 19, _wnd.Handle.ToS(), out string s1)) {
				if (iFunc == 1) f.orRunW = s1; else f.andRunW = s1;
			}
		}
		
		_k.GetResults(f);
		if (!forTest) waitW.GetText(out f.waitW, emptyToo: true);
		
		if (f.NeedControl) {
			nameC.GetText(out f.nameC, emptyToo: true);
			classC.GetText(out f.classC);
			idC.GetText(out f.idC);
			alsoC.GetText(out f.alsoC);
			skipC.GetText(out f.skipC);
			f.nameC_comments = nameC.t.Text;
			f.classC_comments = classC.t.Text;
		}
		
		var R = f.Format();
		
		if (!forTest) {
			_code.AaSetText(R);
		}
		
		return (R, "w");
	}
	
	#region capture
	
	TUtil.CapturingWithHotkey _capt;
	
	void _cCapture_CheckedChanged() {
		_capt ??= new(
			_cCapture,
			o => (_noControl ? o.wTL : wnd.fromXY(o.p)).GetRect(out o.resultRect),
			new(LA.App.Settings.delm.hk_capture, _Capture)
			);
		_capt.Capturing = _cCapture.IsChecked;
	}
	
	void _Capture() {
		var c = wnd.fromMouse(); if (c.Is0) return;
		_con = c;
		_SetWnd(true);
		var w = this.Hwnd();
		if (w.IsMinimized) {
			w.ShowNotMinMax();
			w.ActivateL();
		}
	}
	
	#endregion
	
	#region Insert, Test
	
	/// <summary>
	/// When OK clicked, the top-level window (even when <see cref="AaResultUseControl"/> is true).
	/// </summary>
	public wnd AaResultWindow => _wnd;
	
	/// <summary>
	/// When OK clicked, the control (even when <see cref="AaResultUseControl"/> is false) or default(wnd).
	/// </summary>
	public wnd AaResultControl => _con;
	
	/// <summary>
	/// When OK clicked, true if a control was selected and the 'Control' checkbox checked.
	/// Use <see cref="AaResultWindow"/> or <see cref="AaResultControl"/>, depending on this property.
	/// </summary>
	public bool AaResultUseControl { get; private set; }
	
	/// <summary>
	/// When OK clicked, contains C# code. Else null.
	/// </summary>
	public string AaResultCode { get; private set; }
	
	//rejected. Can use Closed event; then aaResultCode not null if OK.
	///// <summary>
	///// When closed with OK button.
	///// </summary>
	//public event Action OK;
	
	private void _Insert(WBButtonClickArgs e) {
		var s = _code.aaaText.NullIfEmpty_();
		
		if (_dontInsert) {
			AaResultCode = s;
			if (s == null) e.Cancel = true;
			else AaResultUseControl = !_con.Is0 && _cControl.IsChecked;
			
			if (this.IsModal_() == false) Close();
			else DialogResult = s != null;
		} else if (_close) {
			Close();
		} else if (s != null) {
			LA.InsertCode.Statements(new(s, makeVarName1: true));
			_close = true;
			_bInsert.Content = "Close";
			_bInsert.MouseLeave += (_, _) => {
				_close = !true;
				_bInsert.Content = "Insert";
			};
		}
	}
	bool _close;
	
	private void _bTest_Click(WBButtonClickArgs ea) {
		var (code, wndVar) = _FormatCode(true); if (code.NE()) return;
		var rr = TUtil.RunTestFindObject(this, code, wndVar, _wnd, getRect: o => {
			var w = (wnd)o;
			var r = w.Rect;
			if (w.IsMaximized && !w.IsChild) {
				var k = w.Screen.Rect; k.Inflate(-2, -2);
				r.Intersect(k);
			}
			return r;
		});
		_info.InfoErrorOrInfo(rr.info);
	}
	
	#endregion
	
	#region tree
	
	void _InitTree() {
		_tree.SingleClickActivate = true;
		_tree.ItemActivated += e => {
			var x = e.Item as _TreeItem;
			_con = x.c == _wnd ? default : x.c;
			if (!_FillProperties(false)) return;
			_FormatCode();
			if (!_con.Is0) TUtil.ShowOsdRect(_con.Rect);
		};
	}
	
	void _ClearTree() {
		_tree.SetItems(null);
	}
	
	void _FillTree() {
		_TreeItem xWindow = new() { c = _wnd }, xSelect = _con.Is0 ? xWindow : null;
		_AddChildren(_wnd, xWindow);
		void _AddChildren(wnd wParent, _TreeItem nParent) {
			for (wnd t = wParent.Get.FirstChild; !t.Is0; t = t.Get.Next()) {
				var x = new _TreeItem() { c = t };
				nParent.AddChild(x);
				if (t == _con && xSelect == null) xSelect = x;
				_AddChildren(t, x);
			}
		}
		
		_tree.SetItems(new _TreeItem[1] { xWindow });
		
		//print.it(xWindow.Descendants().Select(o=>o.c));
		
		if (xSelect != null) _tree.SelectSingle(xSelect);
	}
	
	class _TreeItem : TreeBase<_TreeItem>, ITreeViewItem {
		public wnd c;
		string _displayText;
		bool _isExpanded;
		bool _isFailed;
		
		#region ITreeViewItem
		
		string ITreeViewItem.DisplayText {
			get {
				if (_displayText == null) {
					var cn = c.ClassName;
					if (cn == null) {
						_isFailed = true;
						return _displayText = "Failed: " + lastError.message;
					}
					
					var name = c.Name;
					if (name.NE()) _displayText = cn;
					else {
						using (new StringBuilder_(out var b)) {
							name = name.Escape(limit: 250);
							b.Append(cn).Append("  \"").Append(name).Append('"');
							_displayText = b.ToString();
						}
					}
				}
				return _displayText;
			}
		}
		
		void ITreeViewItem.SetIsExpanded(bool yes) { _isExpanded = yes; }
		
		bool ITreeViewItem.IsExpanded => _isExpanded;
		
		IEnumerable<ITreeViewItem> ITreeViewItem.Items => base.Children();
		
		bool ITreeViewItem.IsFolder => _IsFolder;
		bool _IsFolder => base.HasChildren;
		
		object ITreeViewItem.Image => _IsFolder ? LA.EdIcons.FolderArrow(_isExpanded) : null;
		
		int ITreeViewItem.TextColor(TVColorInfo ci)
			=> _isFailed ? 0xff
			: !c.IsVisible ? ColorInt.SwapRB(Api.GetSysColor(Api.COLOR_GRAYTEXT))
			: -1;
		
		#endregion
	}
	
	#endregion
	
	#region info
	
	struct _WinInfo {
		public string wClass, wName, wProg, cClass, cName, cText, /*cLabel,*/ cElm, cWF;
		public int cId;
		
		public string Format(wnd w, wnd c, int wcp) {
			var b = new StringBuilder();
			
			if (wcp == 2 && c.Is0) wcp = 1;
			if (!w.IsAlive) return "";
			if (wcp == 1) { //window
				b.AppendLine("<lc #B0E0B0><b>Window<>    <+switch 2>Control<>    <+switch 3>Process<><>");
				if (wClass == null) {
					wClass = w.ClassName;
					wName = w.Name;
				}
				_Common(false, b, w, wName, wClass);
			} else if (wcp == 2) { //control
				b.AppendLine("<lc #B0E0B0><+switch 1>Window<>    <b>Control<>    <+switch 3>Process<><>");
				if (c.IsAlive) {
					if (cClass == null) {
						cClass = c.ClassName;
						cName = c.Name;
						cText = c.ControlText;
						//cLabel = c.NameLabel;
						cElm = c.NameElm;
						cWF = c.NameWinforms;
						cId = c.ControlId;
					}
					_Common(true, b, c, cName, cClass);
				}
			} else { //program
				b.AppendLine("<lc #B0E0B0><+switch 1>Window<>    <+switch 2>Control<>    <b>Process<><>");
				g1:
				if (wProg == null) {
					wProg = w.ProgramName;
				}
				b.Append("<i>ProgramName<>:    ").AppendLine(wProg);
				b.Append("<i>ProgramPath<>:    ").AppendLine(w.ProgramPath);
				b.Append("<i>ProgramDescription<>:    ").AppendLine(w.ProgramDescription);
				int pid = w.ProcessId, tid = w.ThreadId;
				b.Append("<i>ProcessId<>:    ").AppendLine(pid.ToString());
				b.Append("<i>ThreadId<>:    ").AppendLine(tid.ToString());
				b.Append("<i>Is32Bit<>:    ").AppendLine(w.Is32Bit ? "true" : "false");
				using (var uac = uacInfo.ofProcess(pid)) {
					b.Append("<i><help articles/UAC>UAC<> IL, elevation<>:    ")
						.Append(uac.IntegrityLevel.ToString())
						.Append(", ").AppendLine(uac.Elevation.ToString());
				}
				b.Append("<i>CommandLine<>:    ").AppendLine(process.getCommandLine(pid));
				
				//if control's process or thread is different...
				if (!c.Is0) {
					int pid2 = c.ProcessId;
					if (pid2 != pid && pid2 != 0) {
						b.AppendLine("\r\n<c red>Control is in other process:<>");
						w = c; wProg = null;
						goto g1;
					}
					int tid2 = c.ThreadId;
					if (tid2 != tid && tid2 != 0) {
						b.AppendLine("\r\n<c red>Control is in other thread:<>");
						b.Append("<i>ThreadId<>:    ").AppendLine(tid2.ToString());
					}
				}
			}
			
			return b.ToString();
		}
		
		void _Common(bool isCon, StringBuilder b, wnd w, string name, string className) {
			string s, sh = w.Handle.ToString();
			b.Append("<i>Handle<>:    ").AppendLine(sh);
			b.Append("<i>ClassName<>:    ").AppendLine(className);
			if (!isCon || !name.NE()) b.Append("<i>Name<>:    ").AppendLine(name);
			if (isCon) {
				//if(!cLabel.NE()) b.Append("<i>NameLabel<>:    ").AppendLine(cLabel);
				if (!cElm.NE()) b.Append("<i>NameElm<>:    ").AppendLine(cElm);
				if (!cWF.NE()) b.Append("<i>NameWinForms<>:    ").AppendLine(cWF);
				if (!cText.NE()) b.Append("<i>ControlText<>:    ").Append("<\a>").Append(cText.Escape(10000, true)).AppendLine("</\a>");
				b.Append("<i>ControlId<>:    ").AppendLine(cId.ToString());
				b.AppendFormat("<+rect {0}><i>RectInWindow<><>:    ", sh).AppendLine(w.RectInWindow.ToString());
			} else {
				var wo = w.Get.Owner;
				if (!wo.Is0) b.AppendFormat("<+rect {0}><i>Owner<><>:    ", wo.Handle.ToString()).AppendLine(wo.ToString());
				b.AppendFormat("<+rect {0}><i>Rect<><>:    ", sh).AppendLine(w.Rect.ToString());
			}
			b.AppendFormat("<+rect {0} 1><i>ClientRect<><>:    ", sh).AppendLine(w.ClientRect.ToString());
			var style = w.Style;
			s = (style & (WS)0xffff0000).ToString();
			if (isCon) s = s.Replace("MINIMIZEBOX", "GROUP").Replace("MAXIMIZEBOX", "TABSTOP"); else s = s.Replace("GROUP", "MINIMIZEBOX").Replace("TABSTOP", "MAXIMIZEBOX");
			uint style2 = ((uint)style) & 0xffff; //unknown styles of that class
			b.Append("<i>Style<>:  0x").Append(((uint)style).ToString("X8")).Append(" (").Append(s);
			if (style2 != 0) b.Append(", 0x").Append(style2.ToString("X4"));
			b.AppendLine(")");
			var estyle = w.ExStyle;
			b.Append("<i>ExStyle<>:  0x").Append(((uint)estyle).ToString("X8")).Append(" (").Append(estyle.ToString()).AppendLine(")");
			//b.Append("<i>Class style<>:  0x").AppendLine(((uint)WndUtil.GetClassLong(w, GCL.STYLE)).ToString("X8"));
			if (!isCon) {
				b.Append("<i>Is...<>:    ");
				_AppendIs(w.IsPopupWindow, "IsPopupWindow");
				_AppendIs(w.IsToolWindow, "IsToolWindow");
				_AppendIs(w.IsTopmost, "IsTopmost");
				_AppendIs(w.IsFullScreen, "IsFullScreen");
				_AppendIs(0 != w.IsUwpApp, "IsUwpApp");
				_AppendIs(w.IsWindows8MetroStyle, "IsWindows8MetroStyle");
				b.AppendLine();
			}
			b.Append("<i>Prop[\"...\"]<>:    "); bool isProp = false;
			foreach (var p in w.Prop.GetList()) {
				if (p.Key.Starts('#')) continue;
				if (!isProp) isProp = true; else b.Append(", ");
				b.Append(p.Key).Append(" = ").Append(p.Value.ToString());
			}
			b.AppendLine();
			
			void _AppendIs(bool yes, string prop) {
				if (b[^1] != ' ') b.Append(", ");
				if (!yes) b.Append('!');
				b.Append(prop);
			}
		}
	}
	
	void _FillWindowInfo(in _WinInfo f) {
		if (_wiWCP == 0) {
			_wiWCP = 1;
			_winInfo.AaTags.AddLinkTag("+switch", s => {
				_wiWCP = s.ToInt();
				_SetText(default);
			});
			_winInfo.AaTags.AddLinkTag("+rect", s => {
				var w = (wnd)s.ToInt(0, out int e);
				int client = s.ToInt(e);
				var r = client == 1 ? w.ClientRectInScreen : w.Rect;
				TUtil.ShowOsdRect(r, limitToScreen: w.IsMaximized);
			});
		}
		_SetText(f);
		
		void _SetText(in _WinInfo wi) {
			var s1 = wi.Format(_wnd, _con, _wiWCP);
			_winInfo.aaaText = s1.TrimEnd("\r\n");
		}
	}
	int _wiWCP; //0 not inited, 1 window, 2 control, 3 program
	
	TUtil.CommonInfos _commonInfos;
	void _InitInfo() {
		_commonInfos = new TUtil.CommonInfos(_info);
		
		_info.aaaText = _dialogInfo;
		_info.AaAddElem(this, _dialogInfo);
		TUtil.CapturingWithHotkey.RegisterLink_DialogHotkey(_info);
		
		_k.InitInfo(_info);
		_info.InfoCT(idC, "Control id.");
		_info.InfoCT(nameC, "Control name.", true);
		_info.InfoCT(classC, "Control class name.", true);
		
		_info.InfoC(cHiddenTooW, "Flag <help>Au.Types.WFlags<>.HiddenToo.");
		_info.InfoC(cCloakedTooW, "Flag <help>Au.Types.WFlags<>.CloakedToo.");
		_info.InfoCT(waitW,
@"The wait timeout, seconds.
The function waits for such window max this time interval. On timeout throws exception if <b>Fail...<> checked, else returns default(wnd). If empty, uses 8e88 (infinite).");
		_info.InfoC(cHiddenTooC, "Flag <help>Au.Types.WCFlags<>.HiddenToo.");
		_info.InfoCT(alsoC,
@"<help>wnd.Child<> " + TUtil.CommonInfos.c_alsoParameter);
		_info.InfoCT(skipC,
@"0-based index of matching control.
For example, if 1, gets the second matching control.");
		
		_info.Info(_tree, "Tree view", "All child/descendant controls in the window.");
		
		//TODO3: now no info for HwndHost
		//			_Info(_code, "Code",
		//@"Created code to find the window or control.
		//Some parts can be edited directly.
		//");
		//			_Info(_winInfo, "Window info",
		//@"Various properties of the selected window, control and process.
		//For example can be useful when creating <i>also<> function.
		//");
	}
	
	string _dialogInfo =
$@"This tool creates code to find <help wnd.find>window<> or <help wnd.Child>control<>.
1. Move the mouse to a window or control. Press <+hotkey>hotkey<> <b>{LA.App.Settings.delm.hk_capture}<>.
2. Click the Test button to see how the 'find' code works.
3. If need, change some fields or select another window/control.
4. Click Insert. Click Close, or capture/insert again.
5. If need, edit the code in editor. For example rename variables, delete duplicate wnd.find lines, replace part of window name with *. Add code to use the window or control. Examples: w.Activate(); var s = w.Name;.

{(uacInfo.isAdmin ? "" : "If the hotkey does not work when the target window is active, probably its process is admin and this process isn't.")}";
	
	#endregion
}


================================================
FILE: Au.Editor/Tools/InfoWindow.cs
================================================
using Au.Controls;
using System.Windows.Controls;
using System.Windows;

namespace ToolLand;

/// <summary>
/// <see cref="KPopup"/>-based info window with 1 or 2 scintilla controls (<see cref="KSciInfoBox"/>) with output tags etc.
/// You can set text, resize and show/hide/dispose it many times.
/// User can middle-click to hide.
/// </summary>
class InfoWindow : KPopup {
	DockPanel _panel;
	_InfoBox _c, _c2;

	/// <param name="split">If not 0, sets <b>Control1.Width</b>=<i>split</i> and adds <b>Control2</b>.</param>
	/// <param name="titleBar">With title bar.</param>
	public InfoWindow(int split, bool titleBar = true) : base(titleBar ? WS.THICKFRAME | WS.POPUP | WS.CAPTION | WS.SYSMENU : WS.THICKFRAME | WS.POPUP) {
		Content = _panel = new();
		_panel.Children.Add(_c = new());
		if (split > 0) {
			_c.Width = split;
			_panel.Children.Add(_c2 = new() { Name = "info_2" });
		}
	}

	/// <summary>
	/// The child control. Displays text.
	/// </summary>
	public KSciInfoBox Control1 => _c;

	/// <summary>
	/// The second child control. Displays text.
	/// </summary>
	public KSciInfoBox Control2 => _c2;

	/// <summary>
	/// Text with output tags.
	/// </summary>
	public string Text {
		get => _c?.aaaText;
		set => Control1.aaaText = value;
	}

	/// <summary>
	/// Text of second control with output tags.
	/// </summary>
	public string Text2 {
		get => _c2?.aaaText;
		set => Control2.aaaText = value;
	}

	/// <summary>
	/// A text control in which to insert the link text when clicked.
	/// If null, uses the focused control.
	/// </summary>
	public FrameworkElement InsertInControl { get; set; }

	class _InfoBox : KSciInfoBox {
		public _InfoBox() {
			//_t = t;
			this.AaInitUseSystemFont = true;
			this.AaInitBlankMargins = (4, 4);
		}

		//protected override void aaOnHandleCreated() {
		//	base.aaOnHandleCreated();
		//	//base.NoMouseLeftSetFocus = true; //no, then cannot scroll with wheel on Win7-8.1
		//	//base.NoMouseRightSetFocus = true;
		//}
	}
}


================================================
FILE: Au.Editor/Tools/KSciCodeBox.cs
================================================
using Au.Controls;

namespace ToolLand;

/// <summary>
/// Scintilla-based control that shows colored C# code.
/// Also can be used anywhere to edit styled C# code. To make editable and set text use <see cref="AaSetText"/> with readonlyFrom=-1.
/// </summary>
class KSciCodeBox : KScintilla {
	public KSciCodeBox() {
		AaInitUseDefaultContextMenu = true;
		//aaInitBorder = true; //no, the native border is of different color and thickness (high DPI) than other WPF controls
		Name = "code";
	}
	
	protected override void AaOnHandleCreated() {
		base.AaOnHandleCreated();
		
		aaaMarginSetWidth(1, 0);
		aaaIsReadonly = true;
		LA.SciTheme.Current.ToScintilla(this, fontSize: 9);
	}
	
	protected override void AaOnSciNotify(ref Sci.SCNotification n) {
		//switch(n.nmhdr.code) {
		//case Sci.NOTIF.SCN_PAINTED: case Sci.NOTIF.SCN_UPDATEUI: break;
		//default: print.it(n.nmhdr.code, n.modificationType); break;
		//}
		
		switch (n.code) {
		case Sci.NOTIF.SCN_UPDATEUI:
			//make text after _ReadonlyStartUtf8 readonly
			if (n.updated.Has(Sci.UPDATE.SC_UPDATE_SELECTION)) { //selection changed
				if (_readonlyLenUtf8 > 0) {
					int i = Call(Sci.SCI_GETSELECTIONEND);
					aaaIsReadonly = i > _ReadonlyStartUtf8 || _LenUtf8 == 0; //small bug: if caret is at the boundary, allows to delete readonly text, etc.
				}
			}
			break;
		case Sci.NOTIF.SCN_STYLENEEDED:
			_Styling();
			break;
		}
		
		base.AaOnSciNotify(ref n);
	}
	
	/// <summary>
	/// Sets text and makes all or part of it readonly.
	/// </summary>
	/// <param name="s"></param>
	/// <param name="readonlyFrom">If 0, makes all text readonly. If s.Length or -1, makes all text editable. If between 0 and s.Length, makes readonly from this position.</param>
	public void AaSetText(string s, int readonlyFrom = 0) {
		aaaIsReadonly = false;
		aaaSetText(s, SciSetTextFlags.NoUndoNoNotify);
		if (readonlyFrom > 0) {
			_readonlyLenUtf8 = _LenUtf8 - aaaPos8(readonlyFrom);
		} else if (readonlyFrom < 0) {
			_readonlyLenUtf8 = 0;
		} else {
			aaaIsReadonly = true;
			_readonlyLenUtf8 = -1;
		}
	}
	
	public int AaReadonlyStart => _readonlyLenUtf8 < 0 ? 0 : aaaPos16(_ReadonlyStartUtf8);
	
	protected int _readonlyLenUtf8;
	
	protected int _ReadonlyStartUtf8 => _readonlyLenUtf8 < 0 ? 0 : _LenUtf8 - _readonlyLenUtf8;
	
	protected int _LenUtf8 => Call(Sci.SCI_GETTEXTLENGTH);
	
	unsafe void _Styling() {
		if (LA.CiUtil.GetScintillaStylingBytes8(aaaText) is not { } styles8) return;
		Call(Sci.SCI_STARTSTYLING);
		fixed (byte* p = styles8) Call(Sci.SCI_SETSTYLINGEX, styles8.Length, p);
	}
}


================================================
FILE: Au.Editor/Tools/KSciCodeBoxWnd.cs
================================================
using Au.Controls;
using System.Windows;
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;

namespace ToolLand;

/// <summary>
/// Scintilla-based control that shows colored C# code. Based on <see cref="KSciCodeBox"/> and adds methods to get code for wnd.find.
/// </summary>
class KSciCodeBoxWnd : KSciCodeBox {
	/// <summary>
	/// Returns code to find window w and optionally control con in it. Without newline at the end.
	/// If w/con is same as previous and code of this control is modified and valid, gets code from this code control, from the start to aaReadonlyStart.
	/// Else creates code "var w = wnd.find(...);". If w is invalid, creates code "wnd w = default;".
	/// The returned wndVar is final wnd variable name (of window or control).
	/// </summary>
	public (string code, string wndVar) AaGetWndFindCode(bool test, wnd w, wnd con = default, bool private1 = false) {
		if (test) { //remove 'wait' and 'activate' from wnd.find and wnd.Child. If no 'wait', insert 0 to throw notfoundexception.
			var k = AaGetWndFindCode(false, w, con, private1: true);
			var s = k.code;
			var p = _ParseWndFind(s, test: true);
			if (p?.wVar != null) {
				void _Replace(int end, int argsStart, int argsEnd, int nameStart, bool orRun = false, bool orRunReplace = false, int funcNameEnd = 0) {
					if (orRun && !orRunReplace) return;
					s = s.ReplaceAt(argsEnd..end, ");"); //remove '.Activate()' etc. If orRun, removes run etc arguments.
					s = s.ReplaceAt(argsStart..nameStart, nameStart < argsEnd ? "0, " : "0"); //remove 'wait, ' and add '0, ' (to throw NotFoundException)
					if (orRun) s = s.Remove(funcNameEnd - 5, 5); //findOrRun -> find
				}
				if (p.cVar != null) _Replace(p.cEnd, p.cArgsStart, p.cArgsEnd, p.cNameStart);
				_Replace(p.wEnd, p.wArgsStart, p.wArgsEnd, p.wNameStart, p.orRun, p.orRunReplace, p.wFuncNameEnd);
			}
			//print.it(s);
			k.code = s;
			return k;
		}

		string R = null, sCode = null, wndVar = "w", conVar = "c";

		if (w != _wnd) _userModified = false; else if (!_userModified) _userModified = 0 != Call(Sci.SCI_GETMODIFY);
		if (!w.Is0) {
			if (_userModified) {
				sCode = aaaRangeText(false, 0, _ReadonlyStartUtf8);
				var p = _ParseWndFind(sCode, test: false);
				if (p?.wVar != null) {
					bool isConCode = p.cVar != null;
					//print.it(isConCode);
					if (con == _con && !con.Is0 == isConCode) {
						//print.it(isConCode ? "same control" : "no control");
						if (!private1 && p.wName != null) {
							//if window name changed and does not match the name in code, change it in code
							var name = w.NameTL_;
							if (name != null && !new wildex(p.wName, noException: true).Match(name)) {
								var s = TUtil.EscapeWindowName(name, true);
								if (!(TUtil.IsVerbatim(s, out _) || TUtil.MakeVerbatim(ref s))) s = s.Escape(quote: true);
								sCode = sCode.ReplaceAt(p.wNameStart..p.wNameEnd, s);
							}
						}
						return (sCode, p.cVar ?? p.wVar);
					}
					wndVar = p.wVar;
					if (isConCode) sCode = sCode[..p.cStart];
					if (con.Is0) {
						//print.it("remove control");
						_con = default;
						return (sCode, wndVar);
					}
					if (isConCode) conVar = p.cVar;
					//print.it(isConCode ? "replace control" : "add control");
				} else sCode = null;
			}

			var f = new TUtil.WindowFindCodeFormatter {
				Throw = true,
				waitW = "1",
				VarWindow = wndVar,
				VarControl = conVar,
			};

			if (sCode != null) {
				f.CodeBefore = sCode;
				f.NeedWindow = false;
			} else if (w.ClassName is string cls) {
				f.nameW = TUtil.EscapeWindowName(w.NameTL_, true);
				f.classW = TUtil.StripWndClassName(cls, true);
				if (f.nameW.NE()) f.programW = w.ProgramName;
				f.hiddenTooW = !w.IsVisible;
				f.cloakedTooW = w.IsCloaked;
			} else {
				con = default;
				f.NeedWindow = false;
			}

			if (!con.Is0) {
				bool isId = TUtil.GetUsefulControlId(con, w, out int id);
				string cls = con.ClassName;
				if (isId || cls != null) {
					f.NeedControl = true;
					wndVar = conVar;
					if (isId) {
						f.idC = id.ToS();
						f.classC_comments = cls;
						f.nameC_comments = con.Name;
					} else {
						f.classC = TUtil.StripWndClassName(cls, true);
						string name = con.Name, prefix = null;
						if (name.NE()) {
							name = con.NameWinforms;
							if (!name.NE()) prefix = "***wfName ";
							else {
								var nameElm = con.NameElm;
								//var nameLabel = con.NameLabel;
								if (!nameElm.NE()/* || !nameLabel.NE()*/) {
									//if(nameAcc.NE() || nameLabel == nameAcc) {
									//	name = nameLabel; prefix = "***label ";
									//} else {
									name = nameElm; prefix = "***elmName ";
									//}
								}
							}
						}
						if (wildex.hasWildcardChars(name)) name = "**t " + name;

						f.nameC = prefix + name;
						f.hiddenTooC = !con.IsVisible;
						f.SetSkipC(w, con);
					}
				} else con = default;
			}

			R = f.Format();
		}

		if (R == null) {
			_wnd = default; _con = default;
			return ("wnd w = default;", "w");
		}
		_wnd = w; _con = con;
		return (R, wndVar);
	}
	wnd _wnd, _con;
	bool _userModified;

	record _WndFindParsing {
		//var w = wnd.find...
		public string wVar, wName;
		public int wEnd, wArgsStart, wArgsEnd, wNameStart, wNameEnd, wFuncNameEnd;
		public bool orRun, orRunReplace;
		//var c = w.Child...
		public string cVar;
		public int cStart, cEnd, cArgsStart, cArgsEnd, cNameStart;
	}

	//Parses var w = wnd.find(...)..., and var c = w.Child(...)... if exists.
	//Gets only strings and offsets needed for replacements.
	static _WndFindParsing _ParseWndFind(string code, bool test) {
		if (code.NE()) return null;
		var p = new _WndFindParsing();
		var cu = CSharpSyntaxTree.ParseText(code, new CSharpParseOptions(LanguageVersion.Preview)).GetCompilationUnitRoot();
		foreach (var g1 in cu.Members) {
			if (g1 is not GlobalStatementSyntax g) break;
			if (g.Statement is LocalDeclarationStatementSyntax lds && lds.Declaration.Type.ToString() is "var" or "wnd") {
				var v = lds.Declaration.Variables[0];
				if (v.ArgumentList != null) continue; //array
				if (v.Initializer.Value is InvocationExpressionSyntax ies && ies.Expression is MemberAccessExpressionSyntax mae) {
					while (mae.Expression is InvocationExpressionSyntax ies2 && ies2.Expression is MemberAccessExpressionSyntax mae2) { ies = ies2; mae = mae2; } //eg when with '.Activate()'
					string s1 = mae.Expression.ToString(), s2 = mae.Name.ToString();
					bool isW = p.wVar == null;
					if (isW ? (s1 == "wnd" && s2 == "find" || (p.orRun = s2 == "findOrRun")) : (s1 == p.wVar && s2 == "Child")) {
						var al = ies.ArgumentList;
						int argsStart = al.OpenParenToken.Span.End, argsEnd = al.CloseParenToken.SpanStart, nameStart = argsStart;
						var a = al.Arguments;
						if (a.Count > 0) {
							int iName = 0;
							//wait. Never mind: also can be +, ~, (cast), double.Constant, etc.
							if (!p.orRun && a[0].Expression.Kind() is SyntaxKind.NumericLiteralExpression or SyntaxKind.UnaryMinusExpression) {
								nameStart = a.Count > 1 ? a[1].SpanStart : argsEnd;
								iName = a.Count > 1 ? 1 : -1;
							}
							if (isW && iName >= 0 && a[iName].Expression is LiteralExpressionSyntax les && les.IsKind(SyntaxKind.StringLiteralExpression)) {
								p.wName = les.Token.ValueText;
								p.wNameEnd = les.Span.End;
							}
						}
						var varName = v.Identifier.ToString();
						int end = lds.Span.End;
						if (isW) { //wnd.find
							p.wVar = varName;
							p.wEnd = end;
							p.wArgsStart = argsStart;
							p.wArgsEnd = argsEnd;
							p.wNameStart = nameStart;
							p.wFuncNameEnd = mae.Name.Span.End;
							if (p.orRun && test) {
								for (int i = 1, n = a.Count; i < n; i++) {
									if (a[i].NameColon?.Name.Identifier.Text == "run") {
										p.orRunReplace = true;
										p.wArgsEnd = a[i - 1].Span.End;
										break;
									}
								}
							}
						} else { //w.Child
							p.cVar = varName;
							p.cEnd = end;
							p.cArgsStart = argsStart;
							p.cArgsEnd = argsEnd;
							p.cNameStart = nameStart;
							p.cStart = lds.FullSpan.Start; while (code[p.cStart - 1] <= ' ') p.cStart--;
							break;
						}
					}
				}
			}
		}
		//print.it(p);
		return p;
	}

	/// <summary>
	/// Shows <see cref="Dwnd"/> and updates text.
	/// </summary>
	public (bool ok, wnd w, wnd con, bool useCon) AaShowWndTool(Window owner, wnd w, wnd con, bool checkControl) {
		var flags = DwndFlags.DontInsert; if (checkControl) flags |= DwndFlags.CheckControl;
		var d = new Dwnd(con.Is0 ? w : con, flags);
		d.ShowAndWait(owner, hideOwner: true);
		var code = d.AaResultCode; if (code == null) return default;
		_wnd = d.AaResultWindow;
		_con = d.AaResultUseControl ? d.AaResultControl : default;
		int i = _ReadonlyStartUtf8;
		var code2 = aaaRangeText(false, i, i + _readonlyLenUtf8);
		aaaIsReadonly = false;
		aaaSetText(code + code2);
		return (true, d.AaResultWindow, d.AaResultControl, d.AaResultUseControl);
	}
}


================================================
FILE: Au.Editor/Tools/KTextExpressionBox.cs
================================================
using System.Windows.Controls;
using Au.Controls;
using System.Windows;

namespace ToolLand;

/// <summary>
/// <see cref="KTextBox"/> that supports C# expression in text.
/// Just adds context menu item "Expressions..." that shows how to enter an expression; see <see cref="SetExpressionContextMenu"/>.
/// </summary>
class KTextExpressionBox : KTextBox {
	protected override void OnContextMenuOpening(ContextMenuEventArgs e) {
		SetExpressionContextMenu(this);
		base.OnContextMenuOpening(e);
	}
	
	/// <summary>
	/// Replaces the standard context menu. Adds standard items + item "Expressions..." that shows how to enter an expression.
	/// Does nothing if <c>t.ContextMenu?.HasItems == true</c>.
	/// </summary>
	public static void SetExpressionContextMenu(TextBox t) {
		if (t.ContextMenu?.HasItems == true) return;
		var m = t.xAddCutCopyPasteToContextMenu(addClear: t is KTextBox, setStateNow: true);
		m.xAddSeparator();
		m.xAdd("Expressions...", null, (_, _) => { dialog.show("Expressions", """
In this text field you can enter literal text or a C# expression.
Literal text in code will be enclosed in "" or @"" and escaped if need.
Expression will be added to code without changes.

Examples of all supported expressions:

@@expression
@"verbatim string"
$"interpolated string like {variable} text {expression} text"
$@"interpolated verbatim string like {variable} text {expression} text"

Real expression examples:

@"\bregular expression\b"
@@Environment.GetEnvironmentVariable("API_KEY")
@@"line1\r\nline2"
""", owner: t); });
	}
}

/// <summary>
/// Editable <b>ComboBox</b> that supports C# expression in text.
/// Just adds context menu item "Expressions..." that shows how to enter an expression.
/// </summary>
class KComboExpressionBox : ComboBox {
	public KComboExpressionBox() {
		IsEditable = true;
	}
	
	public override void OnApplyTemplate() {
		base.OnApplyTemplate();
		if (GetTemplateChild("PART_EditableTextBox") is TextBox t) {
			t.ContextMenu = new();
			t.ContextMenuOpening += (_, _) => KTextExpressionBox.SetExpressionContextMenu(t);
		}
	}
}


================================================
FILE: Au.Editor/Tools/KeysWindow.cs
================================================
using Au.Controls;
using ToolLand;
using System.Windows;
using System.Windows.Controls;

namespace LA;

class KeysWindow : InfoWindow { //KPopup
	public KeysWindow() : base(0) {
		Size = (500, 240);
		WindowName = "Keys";
		Name = "Ci.Keys"; //prevent hiding when activated
		CloseHides = true;
	}
	
	protected override void OnHandleCreated() {
		var c = Control1;
		c.AaTags.AddLinkTag("+a", o => _Insert(o), new() { textColor = 0x0060E0, monospace = true }); //link that inserts a key etc
		c.AaNotify += _c_AaNotify;
		c.Call(Sci.SCI_SETMOUSEDWELLTIME, 500);
		
		_SetText();
		
		base.OnHandleCreated();
	}
	
	void _SetText() {
		var s = c_contentText.RxReplace(@"\{(.+?)\}(?!\})", "<+a>$1<>");
		if (_format != 0) {
			bool mod = _format == PSFormat.TriggerMod;
			int i = s.Find(mod ? "\n" : "\n<b>Operator") + 1;
			if (i > 0) s = s.ReplaceAt(i.., "");
			s = s.Replace("  <+a>right ▾<>", "");
		}
		this.Text = s;
	}
	
	/// <summary>
	/// Inserts s in InsertInControl, which can be either Panels.Editor.ActiveDoc or a TextBox (only for a hotkey).
	/// </summary>
	void _Insert(string s) {
		FrameworkElement con = InsertInControl;
		if (con is System.Windows.Controls.TextBox tb) {
			if (!_GetTrueKeyName()) return;
			int pos = tb.CaretIndex;
			if (pos > 0 && s[0] != '+') { //insert space between keys, even if used for a hotkey
				var code = tb.Text;
				char k1 = code[pos - 1];
				if (k1 > ' ' && k1 != '(' && !(k1 == '+' && !code.Eq(pos - 2, '#'))) s = " " + s;
			}
			if (s.Ends(false, "Alt", "Ctrl", "Shift", "Win") > 0) s += "+";
		} else {
			Debug.Assert(con == Panels.Editor.ActiveDoc);
			if (!CodeInfo.GetDocumentAndFindToken(out var cd, out var token)) return;
			if (true != token.IsInString(cd.pos, cd.code, out var si)) return;
			int pos = cd.pos, from = si.textSpan.Start, to = si.textSpan.End;
			
			switch (s) {
			case "text": _AddArg(", \"!`|`\""); return;
			case "html": _AddArg(", \"%`|`\""); return;
			case "sleepMs": _AddArg(", 100"); return;
			case "keyCode": _AddArg(", KKey.Left"); return;
			case "scanCode": _AddArg(", new KKeyScan(1, false)"); return;
			case "action": _AddArg(", new Action(() => { mouse.rightClick(); })"); return;
			}
			
			var code = cd.code;
			bool addArg = code[from] is '!' or '%' || code[from..cd.pos].Contains('^');
			string prefix = null, suffix = null;
			char k1 = code[pos - 1], k2 = code[pos];
			if (!addArg) {
				if (s[0] is '*' or '+') {
					if (k1 is '*' or '+') cd.sci?.aaaSelect(true, pos - 1, pos); //eg remove + from Alt+ if now selected *down
				} else {
					if (pos > from && k1 > ' ' && k1 != '(' && !(k1 == '+' && !code.Eq(pos - 2, '#'))) prefix = " "; //insert space between keys
				}
			}
			if (s.Ends(false, "Alt", "Ctrl", "Shift", "Win") > 0) suffix = "+";
			else if (!addArg && pos < to && k2 > ' ' && k2 is not (')' or '+' or '*')) suffix = "`|` ";
			
			if (!_GetTrueKeyName()) return;
			s = prefix + s + suffix;
			
			if (addArg) {
				_AddArg($", \"{s}`|`\"");
				return;
			}
			
			void _AddArg(string s) {
				int stringEnd = si.stringNode.Span.End;
				if (to == stringEnd) s = "\"" + s;
				cd.sci.aaaGoToPos(true, stringEnd);
				TUtil.InsertTextIn(cd.sci, s);
			}
		}
		
		TUtil.InsertTextIn(con, s);
		
		bool _GetTrueKeyName() {
			bool ok = true;
			if (s.Length == 2 && s[0] != '#' && !s[0].IsAsciiAlpha()) s = s[0] == '\\' ? "|" : s[..1]; //eg 2@ or /? or \|
			else if (s.Starts("right")) ok = _Menu("RAlt", "RCtrl", "RShift", "RWin");
			else if (s.Starts("lock")) ok = _Menu("CapsLock", "NumLock", "ScrollLock");
			else if (s.Starts("other")) ok = _Menu(s_rare);
			return ok;
			
			bool _Menu(params string[] a) {
				int j = popupMenu.showSimple(a, owner: this.Hwnd, rawText: true) - 1;
				if (j < 0) return false;
				s = a[j];
				j = s.IndexOf(' '); if (j > 0) s = s[..j];
				return true;
			}
		}
	}
	
	static string[] s_rare = {
"BrowserBack", "BrowserForward", "BrowserRefresh", "BrowserStop", "BrowserSearch", "BrowserFavorites", "BrowserHome",
"LaunchMail", "LaunchMediaSelect", "LaunchApp1", "LaunchApp2",
"MediaNextTrack", "MediaPrevTrack", "MediaStop", "MediaPlayPause",
"VolumeMute", "VolumeDown", "VolumeUp",
"IMEKanaMode", "IMEHangulMode", "IMEJunjaMode", "IMEFinalMode", "IMEHanjaMode", "IMEKanjiMode", "IMEConvert", "IMENonconvert", "IMEAccept", "IMEModeChange", "IMEProcessKey",
"Break  //Ctrl+Pause", "Clear  //Shift+#5", "Sleep",
//"F13", "F14", "F15", "F16", "F17", "F18", "F19", "F20", "F21", "F22", "F23", "F24", //rejected
  };
	
	public void SetFormat(PSFormat format) {
		if (format == PSFormat.Keys) format = 0;
		if (format == _format) return;
		_format = format;
		_SetText();
	}
	PSFormat _format;
	
	void _c_AaNotify(KScintilla.AaEventHandlerArgs e) {
		//show tooltips for some links
		var c = e.c;
		if (e.n.code == Sci.NOTIF.SCN_DWELLSTART) {
			if (_linkStyle == 0) {
				_linkStyle = c.aaaStyleGetAt(c.aaaFindText(false, "Alt"));
				c.Call(Sci.SCI_CALLTIPSETPOSITION, true); //above
				this.Hidden += (_, _) => { Control1.Call(Sci.SCI_CALLTIPCANCEL); };
			}
			if (e.n.position > 0 && _GetRange(e.n.position, out var r)) {
				if (r == _linkRange && 0 != c.Call(Sci.SCI_CALLTIPACTIVE)) return;
				var s = c.aaaRangeText(false, r.start, r.end);
				s = s switch {
					"code" => "Virtual-key code, like VK65 or VK0x42",
					"*nTimes" => "Press the key many times.\nExamples:\nkeys.send(\"Left*3\");\nint n = 3; keys.send($\"Left*{n}\");",
					"*down" => "Press the key but don't release now.\nExample:\nkeys.send(\"Ctrl*down\");",
					"*up" => "Release the key.\nExample:\nkeys.send(\"Ctrl*up\");",
					"+key" => "Press multiple keys simultaneously.\nExamples:\nkeys.send(\"Ctrl+Shift+A\");\nkeys.send(\"Alt+E+P\");",
					"+(keys)" => "Press multiple keys while holding down the modifier key.\nExample:\nkeys.send(\"Alt+(E P)\");",
					"_char" => "Next character is text, not a key name.\nExample:\nkeys.send(\"Alt+_e_a\");",
					"^chars" => "The remaining part of the string is text, not key names.\nExample:\nkeys.send(\"Alt+^ea\");",
					"text" => "Literal text.\nExamples:\nkeys.send(\"Tab\", \"!Text\", \"Tab\");\nstring s = \"Text\"; keys.send(\"Tab\", \"!\" + s, \"Tab\");\nkeys.sendt(\"Text\");",
					"html" => "HTML (if the active window supports it).\nExamples:\nkeys.send(\"%<b>Text</b>\");\nkeys.sendt(\"Text\", \"<b>Text</b>\");",
					"sleepMs" => "Sleep milliseconds.\nExample:\nkeys.send(\"Left\", 500, \"Right\");",
					"keyCode" => "A key from enum KKey.",
					"scanCode" => "Scan code etc.",
					"action" => "Callback function.\nExample:\nAction click = () => mouse.click();\nkeys.send(\"Shift+\", click);",
					_ => null
				};
				if (s != null) {
					c.aaaSetString(Sci.SCI_CALLTIPSHOW, r.start, s);
					_linkRange = r;
					return;
				}
			}
			c.Call(Sci.SCI_CALLTIPCANCEL);
		}
		
		bool _GetRange(int pos, out StartEnd r) {
			r = default;
			if (c.aaaStyleGetAt(pos) != _linkStyle) return false;
			int start = pos, end = start + 1;
			while (c.aaaStyleGetAt(start - 1) == _linkStyle) start--;
			while (c.aaaStyleGetAt(end) == _linkStyle) end++;
			r = new(start, end);
			return true;
		}
	}
	int _linkStyle;
	StartEnd _linkRange;
	
	const string c_contentText = """
<b>Modifier:<><mono>  {Alt}  {Ctrl}  {Shift}  {Win}  {right ▾}<>
<b>Navigate:<><mono>   {Down}  {Left}  {Right}  {Up}  {End}  {Home}  {PgDn}  {PgUp}<>
<b>Other:<><mono>   {Back}  {Del}  {Enter}  {Esc}  {Space}  {Tab}<>
<b>Function:<><mono>   {F1}  {F2}  {F3}  {F4}  {F5}  {F6}  {F7}  {F8}  {F9}  {F10}  {F11}  {F12}<>
<b>Letter:<><mono>   {A} {B} {C} {D} {E} {F} {G} {H} {I} {J} {K} {L} {M} {N} {O} {P} {Q} {R} {S} {T} {U} {V} {W} {X} {Y} {Z}<>
<b>Number:<><mono>   {1!}  {2@}  {3#}  {4$}  {5%}  {6^}  {7&}  {8*}  {9(}  {0)}<>
<b>Punctuation etc:<><mono>   {`~}  {-_}  {=+}  {[{}  {]}}  {\|}  {;:}  {'"}  {,<}  {.>}  {/?}<>
<b>Numpad:<><mono>   {#1} {#2} {#3} {#4} {#5} {#6} {#7} {#8} {#9} {#0} {#/} {#*} {#-} {#+} {#.}<>
<b>Rare:<><mono>   {Apps}  {Ins}  {Pause}  {PrtSc}  {lock ▾}  {other ▾}  <+a VK>code<><>
<b>Operator:<><mono>   <+a *>*nTimes<>  {*down}  {*up}  <+a +>+key<>  <+a +(`|`)>+(keys)<>  <+a _>_char<>  <+a ^>^chars<><>
<b>Argument:<><mono>   {text}  {html}  {sleepMs}  {keyCode}  {scanCode}  {action}<>

<help keys.send>Help<>    Example:  <code>keys.send("Ctrl+A Del Tab*3", "!text", 100, "Enter");</code>
""";
}


================================================
FILE: Au.Editor/Tools/QuickCapture.cs
================================================
//CONSIDER: disable hotkeys when editor hidden.

using ToolLand;

namespace LA;

static class QuickCapture {
	static popupMenu _m;

	public static void Info() {
		print.it($@"<>Hotkeys for quick capturing (<+options Hotkeys>Options > Hotkeys<>):
	{App.Settings.hotkeys.tool_quick} - capture window from mouse and show menu to insert code to find it etc.
	{App.Settings.hotkeys.tool_wnd} - capture window from mouse and show tool 'Find window'.
	{App.Settings.hotkeys.tool_elm} - capture UI element from mouse and show tool 'Find UI element'.
	{App.Settings.hotkeys.tool_uiimage} - capture image in window from mouse and show tool 'Find image'.
");
	}

	//CONSIDER: while showing menu, show on-screen rectangles of the window, control and elm.
	//CONSIDER: the 'click' items could show a dialog to select Coord format. Or add tool in editor.

	public static void Menu() {
		_m?.Close();

		var p = mouse.xy;
		wnd w0 = wnd.fromXY(p), w = w0.Window, c = w == w0 ? default : w0;
		uint color = CaptureScreen.Pixel(p) & 0xFFFFFF;
		var screenshot = TUtil.MakeScreenshot(p);

		var m = new popupMenu();
		m["Find window"] = _ => _Insert(_Wnd_Find(w));
		m.Submenu("Find+", m => {
			m["Find and activate"] = _ => _Insert(_Wnd_Find(w, activate: true));
			m["Find or run"] = _ => {
				var k = PathInfo.FromWindow(w);
				if (k != null) _Insert(_Wnd_Find(w, activate: true, orRun: k.FormatCode(PathCode.Run)));
			};
			m["Run and find"] = _ => {
				var k = PathInfo.FromWindow(w);
				if (k != null) _Insert(_Wnd_Find(w, activate: true, andRun: k.FormatCode(PathCode.Run)));
			};
			m["wndFinder"] = _ => _Insert("var f = new wndFinder(" + TUtil.ArgsFromWndFindCode(_Wnd_Find(w)) + ");");
			m["Find control"] = _ => _Insert(_Wnd_Find(w, c));
			m.Last.IsDisabled = c.Is0;
		});
		m.Submenu("Mouse", m => {
			string _Click(wnd w, string v) {
				w.MapScreenToClient(ref p);
				return $"\r\nmouse.click({v}, {p.x}, {p.y});{screenshot}";
			}
			m["Click window"] = _ => _Insert(_Wnd_Find(w) + _Click(w, "w"));
			m["Click control"] = _ => _Insert(_Wnd_Find(w, c) + _Click(c, "c"));
			m.Last.IsDisabled = c.Is0;
			//CONSIDER: UI element
			m["Click screen"] = _ => _Insert($"mouse.click({p.x}, {p.y});{screenshot}");
		});
		m.Submenu("Triggers", m => {
			m["Window trigger..."] = _ => TriggersAndToolbars.QuickWindowTrigger(w, 0);
			m["Trigger scope..."] = _ => TriggersAndToolbars.QuickWindowTrigger(w, 3);
			m["Trigger scope - window"] = _ => TriggersAndToolbars.QuickWindowTrigger(w, 1);
			m.Last.Tooltip = "Hotkey/autotext/mouse triggers added afterwards will work only when this window is active";
			m["Trigger scope - program"] = _ => TriggersAndToolbars.QuickWindowTrigger(w, 2);
			m.Last.Tooltip = "Hotkey/autotext/mouse triggers added afterwards will work only when a window of this program is active";
			
			//CONSIDER: add options for trigger scope:
			//1. `using Triggers.Of.Window(...) { ... }`
			//2. `#region ... #endregion`. With regions can find scopes in the Outline panel.
		});
		m.Submenu("Program", m => {
			var k = PathInfo.FromWindow(w);
			if (k != null) {
				PathInfo.QuickCaptureMenu(m, o => _Insert(k.FormatCode(o)));
				m.Separator();
				m["Copy path"] = _ => clipboard.text = k.fileRaw;
				m["Copy @\"path\""] = _ => clipboard.text = k.fileString;
			}
			if (w.ProgramName is string pn) m["Copy filename"] = _ => clipboard.text = pn;
			if (k != null) {
				m.Separator();
				m["Select in Explorer"] = _ => run.selectInExplorer(k.fileRaw);
			}
		});
		m.Submenu("Color", m => {
			string s0 = color.ToString("X6"), s1 = "#" + s0, s2 = $"0x" + s0, s3 = $"0x" + ColorInt.SwapRB(color).ToString("X6");
			m["Copy #RRGGBB:  " + s1] = _ => clipboard.text = s1;
			m["Copy 0xRRGGBB:  " + s2] = _ => clipboard.text = s2;
			m["Copy 0xBBGGRR:  " + s3] = _ => clipboard.text = s3;
		});
		//	m.Submenu("Get color", m => {
		//		m["Window"] = _=> {
		//			
		//		};
		//		m["Control"] = _=> {
		//			
		//		};
		//		m.Last.IsDisabled=c.Is0;
		//		m["Screen"] = _=> {
		//			
		//		};
		//	});
		m.Separator();
		m["About"] = _ => Info();
		m.Add("Cancel");

		_m = m;
		m.Show();
		_m = null;
	}

	static string _Wnd_Find(wnd w, wnd c = default, bool activate = false, string orRun = null, string andRun = null) {
		var f = new TUtil.WindowFindCodeFormatter();
		f.RecordWindowFields(w, andRun != null ? 30 : 1, activate);
		f.orRunW = orRun;
		f.andRunW = andRun;
		if (!c.Is0) f.RecordControlFields(w, c);
		return f.Format();
	}

	static void _Insert(string s) {
		//print.it(s);
		InsertCode.Statements(new(s, makeVarName1: true));
	}

	public static void AoolDwnd() {
		ToolProcess.StartDwnd(wnd.fromMouse());
	}

	public static void ToolDelm() {
		ToolProcess.StartDelm(mouse.xy);
	}

	public static void ToolDuiimage() {
		ToolProcess.StartDuiimage(wnd.fromMouse(WXYFlags.NeedWindow));
	}
}


================================================
FILE: Au.Editor/Tools/RegexWindow.cs
================================================
using Au.Controls;

namespace ToolLand;

class RegexWindow : InfoWindow { //KPopup
	public RegexWindow() : base(250) {
		Size = (800, 220);
		WindowName = "Regex";
		Name = "Ci.Regex"; //prevent hiding when activated
		CloseHides = true;
	}
	
	protected override void OnHandleCreated() {
		for (int i = 0; i < 2; i++) {
			var c = i == 0 ? this.Control1 : this.Control2;
			c.AaTags.AddStyleTag(".r", new() { textColor = 0xf08080 }); //red regex
			c.AaTags.AddLinkTag("+p", o => CurrentTopic = o); //link to a local info topic
			c.Call(Sci.SCI_SETWRAPSTARTINDENT, 4);
		}
		this.Control2.AaTags.AddStyleTag(".h", new() { backColor = 0xC0E0C0, bold = true, eolFilled = true }); //topic header
		this.Control2.AaTags.AddLinkTag("+a", o => TUtil.InsertTextIn(InsertInControl, o), new() { textColor = 0x0060E0, monospace = true }); //link that inserts a regex token
		this.Control1.AaTags.DefaultLinkStyle = new() { textColor = 0x0080FF, underline = false }; //remove underline from links
		
		_SetTocText();
		CurrentTopic = @"help";
		
		base.OnHandleCreated();
	}
	
	void _SetTocText() {
		this.Text = c_contentText.Remove(c_contentText.Find("\r\n\r\n-- "));
	}
	
	/// <summary>
	/// Opens an info topic or gets current topic name.
	/// </summary>
	public string CurrentTopic {
		get => _topic;
		set {
			if (value == _topic) return;
			_topic = value;
			string s;
			if (value.Starts("Note:")) {
				s = value;
			} else {
				s = c_contentText;
				if (!s.RxMatch($@"(?ms)^-- {_topic} --\R\R(.+?)\R-- ", 1, out s)) s = "";
				else s = s.Replace("{App.Settings.internetSearchUrl}", LA.App.Settings.internetSearchUrl);
			}
			this.Text2 = s;
		}
	}
	string _topic;
	
	public void Refresh() {
		_SetTocText();
		var s = _topic;
		_topic = null;
		CurrentTopic = s;
	}
	
	const string c_contentText = """
<+p help>Help<>
<+p options>Options<> <.r>(?imsnxUJ)<> and <.r>(*...)<>
<+p meta>Metacharacters<> <.r>^ $ . [ | ( ) * + ? { \<>
<+p escape>Escaped chars<> <.r>\^ \n<> etc and text <.r>\Q...\E<>
<+p charTypes>Character types, any char<> <.r>\d \w \s \R .<>
<+p charClasses>Character classes<> <.r>[abc]<> and <.r>(?[ext])<>
<+p repetition>Repetition quantifiers<> <.r>* + ? {n} {n,m}<>
<+p startEnd>Start/end of string/line/word<> <.r>^ $ \b<> etc
<+p or>OR operator<> <.r>A|B|C<>
<+p groups>Groups<> <.r>(...)<> and backreferences <.r>\1<>
<+p assertions>Follows/precedes<> <.r>(?=...)<> etc and <.r>\K<>

<b>Advanced and rarely used<>
<+p extended>Extended syntax<> <.r>(?x)<> and <.r>#comments<>
<+p conditional>Conditional groups<> <.r>(?(if)yes|no)<>
<+p subroutines>Subroutines, recursion<> <.r>(?&name) (?1) (?R)<>
<+p callouts>Callouts<> <.r>(?C) (?C0) (?C'text')<> etc
<+p backtracking>Backtracking control<> <.r>(*...)<>
<+p charProp>Unicode character properties<> <.r>\p{Xx}<>
<+p scripts>Unicode scripts<> <.r>\p{name}<> and <.r>(*sr:...)<>

<b>Replacement<>
<+p replace>Replacement<> <.r>$1 ${2} ${name} $$<> etc

-- help --

<.h>Help<>

<link https://www.pcre.org/current/doc/html/pcre2pattern.html>PCRE regex syntax<>
<link https://www.pcre.org/current/doc/html/pcre2syntax.html>PCRE regex syntax summary<>
<link https://www.pcre.org/current/doc/html/pcre2api.html#SEC20>PCRE2_ flags<>
<link https://www.pcre.org/current/doc/html/index.html>PCRE regex library reference<>
<link>http://www.rexegg.com/<>
<link>https://www.regular-expressions.info/<>
<link {App.Settings.internetSearchUrl}regular+expression+tester,+PCRE>Find regex test tools<>

-- options --

<.h><link https://www.pcre.org/current/doc/html/pcre2pattern.html#SEC15>Options<><>

<+a>(?i)<>  -  case-insensitive. In the Find panel this is default when 'Case' unchecked.
<+a>(?m)<>  -  <.r>^<> and <.r>$<> are start/end of a line. Default in the Find panel. Known as "multiline".
<+a>(?s)<>  -  <.r>.<> matches newlines (<.r>\r<>, <.r>\n<>) too. Known as "single-line" or "dotall".
<+a>(?n)<>  -  unnamed <.r>(...)<> groups are non-capturing, like <.r>(?:...)<>. Named still capturing: <.r>(?'name'...)<>.
<+a>(?x)<>  -  extended. Support <.r>#comments<> and ignore spaces/newlines, except in <.r>[...]<> and after <.r>\<>.
<+a>(?xx)<>  -  extended more. Like <.r>(?x)<> but also ignore spaces in <.r>[...]<> (but not newlines).
<+a>(?U)<>  -  ungreedy (lazy) quantifiers <.r>+ * ? {n}<> etc. For example makes <.r>.+<> the same as <.r>.+?<>.
<+a>(?J)<>  -  allow duplicate group names.

<b>How to remove options, set multiple, etc<>
<+a (?`|`)>(?msi)<>  -  set multiple options.
<+a (?-`|`)>(?-im)<>  -  remove options.
<+a (?`|`-)>(?si-m)<>  -  set and remove options.
<+a>(?^)<>  -  remove options <.r>imsnx<>.
<+a (?^`|`)>(?^im)<>  -  remove <.r>imsnx<> and add <.r>im<>.
<+a (?`|`:)>(?i:...)<>  -  another way to set options in non-capturing groups. The same as <.r>(?:(?i)...)<>.

These options can be set anywhere in regular expression and are applied until its end or until the end of the <.r>(...)<> group/assertion/etc or until unset.

Example regex: <.r>(?mi)^ab((?s).+?)cd(?-i)ef<>. Here option <.r>m<> is set for whole regex, option <.r>i<> until <.r>(?-i)<>, and option <.r>s<> added only in group <.r>(.+?)<>.

<.h><link https://www.pcre.org/current/doc/html/pcre2pattern.html#SEC3>Start-of-regex options<><>
<+a>(*BSR_UNICODE)<>  -  <.r>\R<> matches any Unicode newline characters, not only <.r>\n<>, <.r>\r<> and <.r>\r\n<>.
<+a>(*ANY)<>  -  newline includes any Unicode newline characters, not only <.r>\n<>, <.r>\r<> and <.r>\r\n<>.
<+a>(*LF)<>  -  newline is only <.r>\n<>.
<+a>(*CR)<>  -  newline is only <.r>\r<>.
<+a>(*CRLF)<>  -  newline is only <.r>\r\n<>.
<+a>(*NOTEMPTY)<>  -  set this flag. See the links below.
<+a>(*NOTEMPTY_ATSTART)<>  -  set this flag.
<+a>(*NO_AUTO_POSSESS)<>  -  set this flag.
<+a>(*NO_DOTSTAR_ANCHOR)<>  -  set this flag.
<+a>(*NO_START_OPT)<>  -  set this flag.
<+a>(*UTF)<>  -  set this flag.
<+a>(*UCP)<>  -  set this flag.
<+a>(*EC)<>  -  enable UTS#18 extended character classes

These options can be set only at the start of regular expression. Example: <.r>(*ANY)(*UCP)regex<>.

With regular expression functions you can also use flags <help>Au.Types.RXFlags<> and <help>Au.Types.RXMatchFlags<>. There are flags for most <.r>(?...)<> and <.r>(*...)<> options and more. Options <.r>(?...)<> set in regular expression override function's flags.

<b>Links<>
<link https://www.pcre.org/current/doc/html/pcre2api.html#SEC20>API flags<>
<link https://www.pcre.org/current/doc/html/pcre2unicode.html>Unicode, (*UTF), (*UCP)<>

-- meta --

<.h><link https://www.pcre.org/current/doc/html/pcre2pattern.html#SEC4>Metacharacters<><>

<.r>^<>  -  start of string (or line, in multiline mode).
<.r>$<>  -  end of string (or line, in multiline mode).
<.r>.<>  -  match any character except newline (by default).
<.r>[<>  -  start character class definition.
<.r>|<>  -  start of alternative branch.
<.r>(<>  -  start group or control verb.
<.r>)<>  -  end group or control verb.
<.r>*<>  -  0 or more quantifier.
<.r>+<>  -  1 or more quantifier; also "possessive quantifier".
<.r>?<>  -  0 or 1 quantifier; also quantifier minimizer.
<.r>{<>  -  start min/max quantifier.
<.r>\<>  -  general escape character with several uses.

In extended mode also:
<.r>#<>  -  starts a line comment.

In a character class <.r>[...]<> the only metacharacters are:
<.r>^<>  -  negate the class, but only if the first character.
<.r>-<>  -  indicates character range.
<.r>]<>  -  terminates the character class.
<.r>[:class:]<>  -  POSIX character class.
<.r>\<>  -  general escape character.

-- escape --

<.h><link https://www.pcre.org/current/doc/html/pcre2pattern.html#SEC5>Escape sequences and literal text<><>

<.r>\<> makes the next metacharacter a literal character. It is an <i>escape sequence<>.

<+a>\^<>, <+a>\$<>, <+a>\.<>, <+a>\[<>, <+a>\|<>, <+a>\(<>, <+a>\)<>, <+a>\*<>, <+a>\+<>, <+a>\?<>, <+a>\{<>, <+a>\\<>  -  escape sequences for metacharacters.
<+a>\#<>, <+a>\ <> (space)  -  in extended mode also need these.
<+a>\^<>, <+a>\-<>, <+a>\]<>, <+a>\[<>, <+a>\\<>  -  in character classes <.r>[...]<> need only these.

<.r>\<> before any other ASCII non-alphanumeric character is ignored (removed).

Escape sequences for non-printing characters:

<+a>\n<>  -  linefeed (character code 10).
<+a>\r<>  -  carriage return (character code 13).
<+a>\r\n<>  -  Windows newline sequence. See also "any newline" <+p charTypes>\R<>.
<+a>\t<>  -  tab (character code 9).
<+a \x`|`>\xhh<>  -  character with hex character code hh.
<+a \x{`|`}>\x{hhhh}<>  -  character with hex character code hhhh.
<+a \N{U+`|`}>\N{U+hhhh}<>  -  character with Unicode hex code point hhhh.

<+a \Q`|`\E>\Q...\E<>  -  literal text.

Metacharacter <.r>\<> also has other uses. With regex functions use <c green>@"verbatim string"<> to avoid C# escape sequences for every <.r>\<>.

-- charTypes --

<.h><link https://www.pcre.org/current/doc/html/pcre2pattern.html#SEC7>Any character<>, <link https://www.pcre.org/current/doc/html/pcre2pattern.html#newlineseq>newlines<> and <link https://www.pcre.org/current/doc/html/pcre2pattern.html#genericchartypes>character types<><>

<+a>.<>  -  any character except newlines (<.r>\r<>, <.r>\n<>). Any character if option <.r>(?s)<>.
<+a>\N<>  -  any character except newlines, regardless of option <.r>(?s)<>.
<+a>\R<>  -  newline sequence <.r>\r\n<> or <.r>\n<> or <.r>\r<>. Not allowed in <.r>[...]<>.
<+a>\d<>  -  digit (ASCII 0-9).
<+a>\D<>  -  non-digit.
<+a>\w<>  -  word character (ASCII 0-9, A-Z, a-z, _).
<+a>\W<>  -  non-word character.
<+a>\s<>  -  white space character (space, tab, newlines \r \n, vertical tab, form feed).
<+a>\S<>  -  character that is not a white space character.
<+a>\h<>  -  horizontal white space character (space, tab).
<+a>\H<>  -  character that is not a horizontal white space character.
<+a>\v<>  -  vertical white space character (newlines).
<+a>\V<>  -  character that is not a vertical white space character.
<+a \p{`|`}>\p{Xx}<>  -  character with the Xx <+p charProp>property<> or in <+p scripts>script<>.
<+a \P{`|`}>\P{Xx}<>  -  character without the Xx <+p charProp>property<> or not in <+p scripts>script<>.
<+a>\X<>  -  Unicode extended grapheme cluster.

<b>Options<>  (must be at the start of regular expression)
<+a>(*UCP)<>  -  <.r>\d<>, <.r>\w<> and <.r>\s<> match not only ASCII characters. Flag <help Au.Types.RXFlags>RXFlags.UCP<>.
<+a>(*BSR_UNICODE)<>  -  <.r>\R<> matches any Unicode newline characters, not only <.r>\n<>, <.r>\r<> and <.r>\r\n<>.
<+a>(*ANY)<>, <+a>(*LF)<>, <+a>(*CR)<>, <+a>(*CRLF)<>  -  <+p>options<> for <.r>.<> and <.r>\N<>.

-- charClasses --

<.h><link https://www.pcre.org/current/doc/html/pcre2pattern.html#SEC9>Character classes<><>

<+a [`|`]>[abc]<>  -  character a, b or c.
<+a [^`|`]>[^abc]<>  -  any character except a, b, c.
<+a [^\r\n`|`]>[^abc\r\n]<>  -  any character except a, b, c and newlines.
<+a [`|`-]>[a-z]<>  -  one of characters in range a to z.
<+a [^`|`-]>[^a-z]<>  -  any character not in range a to z.

Can include several ranges, characters plus ranges, character types like <.r>\d<> (digit), escaped characters like <.r>\n<>, POSIX character classes like <.r>[:alpha:]<>. For literal <.r>^ - ] \<> use <.r>\^ \- \] \\<>.

<b>Examples<>
<+a>[_\d]<>  -  character _ and digits 0-9.
<+a>[^"\r\n\-]<>  -  any character except ", newlines and -.
<+a>[0-9A-Fa-f]<> or <+a>[[:xdigit:]]<>  -  a hexadecimal digit.
<+a>[A-Za-z_]\w+<> or <+a>[[:alpha:]_]\w+<>  -  a C# identifier.

<.h><link https://www.pcre.org/current/doc/html/pcre2pattern.html#SEC12>POSIX character classes<> in <.r>[...]<><>
<+a>[:alnum:]<>  -  letters and digits.
<+a>[:alpha:]<>  -  letters.
<+a>[:ascii:]<>  -  character codes 0 - 127.
<+a>[:blank:]<>  -  space, tab.
<+a>[:cntrl:]<>  -  control characters.
<+a>[:digit:]<>  -  decimal digits (same as <.r>\d<>).
<+a>[:graph:]<>  -  printing characters, excluding space.
<+a>[:lower:]<>  -  lower case letters.
<+a>[:print:]<>  -  printing characters, including space.
<+a>[:punct:]<>  -  printing characters, except letters and digits and space.
<+a>[:space:]<>  -  white space (same as <.r>\s<>).
<+a>[:upper:]<>  -  upper case letters.
<+a>[:word:]<>  -  word characters (same as <.r>\w<>).
<+a>[:xdigit:]<>  -  hexadecimal digits.

See also: <+p charProp>Unicode character properties<> and <+p scripts>scripts<>.

<b>Options<>  (must be at the start of regular expression)
<+a>(*UCP)<>  -  include non-ASCII characters in POSIX classes and <.r>\w<> etc. Flag <help Au.Types.RXFlags>RXFlags.UCP<>. Also there are options and flags to exclude some.

<.h><link https://www.pcre.org/current/doc/html/pcre2pattern.html#SEC10>Extended character classes<><>
<+a (?[`|`])>(?[...])<>  -  extended character class. Can contain multiple simple classes like <.r>\d<> or <.r>[...]<>, operators like <.r>-<>, and <.r>()<> for grouping.

<b>Examples<>
<+a>(?[\w -[xy]])<>  -  word characters except x and y.
<+a>(?[\w -[:upper:]])<>  -  word characters except uppercase letters.

<.h><link https://www.pcre.org/current/doc/html/pcre2pattern.html#SEC11>UTS#18 extended character classes<><>
<+a>(*EC)<>  -  enable UTS#18 extended character classes. This must be at the start of regular expression.

<b>Examples<>
<+a>[\w--[xy]]<>  -  word characters except x and y.
<+a>[.\-\w--[:upper:]]<>  -  dot, hyphen and word characters except uppercase letters.

-- repetition --

<.h><link https://www.pcre.org/current/doc/html/pcre2pattern.html#SEC19>Repetition quantifiers<><>

<+a>?<>  -  0 or 1. Lazy <+a>??<>, possessive <+a>?+<>.
<+a>*<>  -  0 or more. Lazy <+a>*?<>, possessive <+a>*+<>.
<+a>+<>  -  1 or more. Lazy <+a>+?<>, possessive <+a>++<>.
<+a {`|`}>{n}<>  -  exactly n.
<+a {`|`,}>{n,m}<>  -  at least n, no more than m. Lazy <+a {`|`,}?>{n,m}?<>, possessive <+a {`|`,}+>{n,m}+<>.
<+a {`|`,}>{n,}<>  -  n or more. Lazy <+a {`|`,}?>{n,}?<>, possessive <+a {`|`,}+>{n,}+<>.

A quantifier after a character/group/etc specifies how many times it must match.
Examples: <.r><.r>.*<><> - 0 or more characters; <.r><.r>(\d{3}-)+<><> - 1 or more groups of 3 digits and -.

Quantifiers can be placed after:
  a character, such as <.r>c<> or <.r>\t<> (tab);
  <.r>.<> (any character except newline, or any character if option <.r>(?s)<>);
  a character type such as <.r>\d<> (digit) or <.r>\pL<> that matches a single character;
  <.r>\R<> (any newline sequence), <.r>\C<>, <.r>\X<>;
  a character class <.r>[...]<>;
  a group like <.r>(...)<> or <.r>(?:...)<> or assertion like <.r>(?=...)<> etc;
  a backreference, like <.r>\1<>;
  a subroutine call, like <.r>(?1)<> or <.r>(?R)<> or <.r>(?&name)<>.

Quantifiers can be greedy (default), lazy (with <.r>?<> or option <.r>(?U)<>) or possessive (with <.r>+<>).
• Greedy - as many as possible. For example regex <.r><.+><> matches <c green><ab> cd <ef><> in string <c green><ab> cd <ef> gh<>.
• Lazy - as few as possible. For example regex <.r><.+?><> matches <c green><ab><> in the above string.
• <link https://www.pcre.org/current/doc/html/pcre2pattern.html#SEC20>Possessive<> - once the regex part matched, it cannot be backtracked (retried smaller parts of it) when next regex part does not match; it can make faster. Greedy, ignores <.r>(?U)<>. The same as <+p groups>atomic groups<>, just simpler syntax.

-- startEnd --

<.h><link https://www.pcre.org/current/doc/html/pcre2pattern.html#smallassertions>Start/end of string/line/word<><>

<+a>\b<>  -  word boundary.
<+a>\B<>  -  not a word boundary.
<+a>^<>  -  start of string; also start of a line in multiline mode (<+p options>option<> <.r>(?m)<>; default in Find panel).
<+a>$<>  -  end of string; also before newline at end of string; also end of a line in multiline mode.
<+a>\A<>  -  start of string. This and others below don't depend on multiline mode.
<+a>\Z<>  -  end of string; also before newline at end of string.
<+a>\z<>  -  end of string.
<+a>\G<>  -  when using a non-zero start index in string - at the start index; else same as <.r>\A<>. With 'find all' and 'replace all' functions it also is previous match's end.

A word boundary is between two characters that match <.r>\w<> (letters, digits and _) and <.r>\W<> (other characters), or between <.r>\w<> and start/end. By default only ASCII characters are considered word characters, therefore for example <.r>\b<> matches between an ASCII letter and non-ASCII letter. If used option <.r>(*UCP)<> or flag <help Au.Types.RXFlags>RXFlags.UCP<>, <.r>\w<> etc match not only ASCII characters.

Default newlines are any of <.r>\r\n<>, <.r>\n<> and <.r>\r<>. There are <+p>options<> to change it, and thus change the behaviour of <.r>^<>, <.r>$<> and <.r>\Z<>.

-- or --

<.h><link https://www.pcre.org/current/doc/html/pcre2pattern.html#SEC14>OR operator<><>

<.r>red|green|blue<>  -  red or green or blue.
<.r>red|green|<>  -  red or green or empty.

Often used in a group like <.r>(one|two)<> or in a "followed/preceded by" assertion like <.r>(?=one|two)<> etc.

-- groups --

<.h><link https://www.pcre.org/current/doc/html/pcre2pattern.html#SEC16>Groups<> and backreferences<>

<+a (`|`)>(...)<>  -  capturing group.
<+a (?'`|`')>(?'name'...)<>  -  named capturing group. Or <+a "(?<`|`>)">(?<name>...)<>, <+a "(?P<`|`>)">(?P<name>...)<>.
<+a (?:`|`)>(?:...)<>  -  non-capturing group.
<+a (?|`|`)>(?|...)<>  -  nested groups like A and B in <.r>(?|(A)s|(B))<> have the same number. Non-capturing.
<+a "(?>`|`)">(?>...)<> or <+a (*atomic:`|`)>(*atomic:...)<>  -  <link https://www.pcre.org/current/doc/html/pcre2pattern.html#SEC20>atomic non-capturing group<>.

Groups are used:
1. To localize/isolate several <+p or>alternatives<> like <.r>(one|two)<> or <+p>options<> like <.r>((?i)...)<>.
2. To get the matched substring with a regex function such as <help>regexp.Match<>.
3. To use the matched substring as a backreference, like <.r>\g{1}<>.
4. To use the matched substring in the <+p replace>replacement<>, like <.r>$1<> or <.r>${name}<>.
5. To reuse the group in regex as a <+p subroutines>subroutine<> or recursive pattern.
6. To match a group n times, like <.r>(...)+<> (1 or more) or <.r>(...)?<> (0 or 1).
7. And more.

Capturing groups have numbers starting from 1. Non-capturing groups don't have numbers and cannot be used to get substring, for backreferences, replacements, subroutines.

Groups can be nested, like <.r>(group1(group2))<>.

<link https://www.pcre.org/current/doc/html/pcre2pattern.html#SEC20>Atomic groups<> can be used to avoid unnecessary backtracking and thus improve performance. Once the group matched, it cannot be backtracked (retried to find alternative matches) when next regex part does not match. For simple cases can instead be used <+p repetition>possessive quantifiers<>, which is the same just simpler syntax.

<.h><link https://www.pcre.org/current/doc/html/pcre2pattern.html#SEC21>Backreferences<><>
<+a \g`|`>\gn<>  -  reference to group n (1, 2, ...). Or <+a \`|`>\n<>, but can be ambiguous.
<+a \g{`|`}>\g{n}<>  -  reference to group n. Use when followed by a digit.
<+a \g-`|`>\g-n<> or <+a \g{-`|`}>\g{-n}<>  -  relative reference to a group started at the left.
<+a \g+`|`>\g+n<> or <+a \g{+`|`}>\g{+n}<>  -  relative reference to a group at the right.
<+a \k'`|`'>\k'name'<>  -  reference by name. Or <+a "\k<`|`>">\k<name><>, <+a \g{`|`}>\g{name}<>, <+a \k{`|`}>\k{name}<>, <+a (?P=`|`)>(?P=name)<>.

A backreference matches the same substring as the referenced group matched most recently.

-- assertions --

<.h><link https://www.pcre.org/current/doc/html/pcre2pattern.html#SEC22>Follows/precedes assertions<> and <link https://www.pcre.org/current/doc/html/pcre2pattern.html#resetmatchstart>setting the start of match<><>

<+a (?=`|`)>(?=...)<>  -  positive lookahead assertion. It means "followed by ...".
<+a (*pla:`|`)>(*pla:...)<> or <+a (*positive_lookahead:`|`)>(*positive_lookahead:...)<>  -  the same.
<+a (?!`|`)>(?!...)<>  -  negative lookahead assertion. It means "not followed by ...".
<+a (*nla:`|`)>(*nla:...)<> or <+a (*negative_lookahead:`|`)>(*negative_lookahead:...)<>  -  the same.
<+a (?<=`|`)>(?<=...)<>  -  positive lookbehind assertion. It means "preceded by ...".
<+a (*plb:`|`)>(*plb:...)<> or <+a (*positive_lookbehind:`|`)>(*positive_lookbehind:...)<>  -  the same.
<+a (?<!`|`)>(?<!...)<>  -  negative lookbehind assertion. It means "not preceded by ...".
<+a (*nlb:`|`)>(*nlb:...)<> or <+a (*negative_lookbehind:`|`)>(*negative_lookbehind:...)<>  -  the same.
<+a (*scs:(1)`|`)>(*scs:(group)...)<> or <+a (*scan_substring:(1)`|`)>(*scan_substring:(group)...)<>  -  (<link https://www.pcre.org/current/doc/html/pcre2pattern.html#SEC24>docs<>) the matched substring of group must also match .... Group: group number or +-relative or <.r>'name'<> or list. The ... regex must match at the start of the substring; use <.r>\z<> to also match at its end.

An assertion is a test on the string part following or preceding the current matching point that does not consume any characters. For example, regex <.r>ab(?=cd)<> matches ab followed by cd, but does not include cd in the reported match.

An assertion can contain several local "or" parts like <.r>(?=ab|cd)<>, local options like <.r>(?=(?i)...)<>, nested assertions. Several assertions (of any sort) may occur in succession. For example, <.r>(?<=\d{3})(?<!999)foo<> matches foo preceded by three digits that are not 999.

Lookbehind assertions ("preceded by") must be of a known length (max 255), for example <.r>(?<=abc)<> or <.r>(?<=abc|defgh)<> or <.r>(?<=\d{1,9})<>, but not <.r>(?<=.*)<> because <.r>.*<> can match a substring of any length.

Often instead of a lookbehind assertion can be used <.r>\K<>. It sets the reported start of match; the string part matched before <.r>\K<> is not included in the reported match. For example, instead of invalid regex <.r>(?<=\w*)\d<> use <.r>\w*\K\d<>.

-- extended --

<.h>Extended syntax and comments<>

If option <.r>(?x)<> is set, most white space characters (spaces, newlines, etc) in the regular expression are ignored, except when escaped (preceded by <.r>\<>) or inside a character class <.r>[...]<>. Option <.r>(?xx)<> allows spaces in <.r>[...]<> too. The <.r>#<> character starts a line comment. It makes easier to write and read big regular expressions: you can split it into multiple lines.

Example in normal mode:
<.r>one #two(?#comment)three<>

The same in extended mode can be written in multiple lines:
<.r>(?x)
one
\ \#two

#comment
three<>

<b>Comments<>
<+a #`|`>#comment<>  -  comment in extended mode.
<+a (?#`|`)>(?#comment)<>  -  comment in any mode.

<b>Links<>
<link https://www.pcre.org/current/doc/html/pcre2api.html#SEC20>Extended syntax (flag PCRE2_EXTENDED)<>

-- conditional --

<.h><link https://www.pcre.org/current/doc/html/pcre2pattern.html#SEC26>Conditional groups<><>

<+a (?(`|`))>(?(condition)yes-pattern)<>  -  "if condition is true then use yes-pattern".
<+a (?(`|`)|)>(?(condition)yes-pattern|no-pattern)<>  -  "if condition is true then use yes-pattern, else no-pattern".

Conditions:
<.r>n<>  -  reference to group n (1, 2, ...). True if the group has already been matched.
<+a -`|`>-n<>  -  relative reference to a group started at the left.
<+a +`|`>+n<>  -  relative reference to a group at the right.
<+a "'`|`'">'name'<>  -  reference to a named group. Or <+a "<`|`>"><name><>.
<+a>R<>  -  overall recursion.
<+a R`|`>Rn<>  -  specific numbered group recursion.
<+a R&`|`>R&name<>  -  specific named group recursion.
<+a ?`|`>assertion<>  -  <+p assertions>assertion<>. Example: <.r>(?(?=\d)yes|no)<>.
<+a VERSION=`|`.>VERSION=n.m<>  -  test PCRE2 version.
<+a "VERSION>=`|`.">VERSION>=n.m<>  -  test PCRE2 version.

-- subroutines --

<.h><link https://www.pcre.org/current/doc/html/pcre2pattern.html#SEC28>Subroutines and recursion<><>

<+a "(?`|`)">(?n)<>  -  call subroutine by group number n (1, 2, ...). Or <+a "\g'`|`'">\g'n'<>, <+a "\g<`|`>"><_>\g<n></_><>.
<+a "(?-`|`)">(?-n)<>  -  call subroutine by relative number. Or <+a "\g'-`|`'">\g'-n'<>, <+a "\g<-`|`>"><_>\g<-n></_><>.
<+a "(?+`|`)">(?+n)<>  -  call subroutine by relative number. Or <+a "\g'+`|`'">\g'+n'<>, <+a "\g<+`|`>"><_>\g<+n></_><>.
<+a "(?&`|`)">(?&name)<>  -  call subroutine by group name. Or <+a "\g'`|`'">\g'name'<>, <+a "\g<`|`>"><_>\g<name></_><>, <+a "(?P>`|`)">(?P>name)<>.
<+a>(?R)<>  -  recurse whole pattern.
<+a (?(DEFINE)(`|`))>(?(DEFINE)(subroutine))<>  -  define a subroutine; don't evaluate it now.

Recursive regex examples:
<+a>\(([^()]++|(?R))*\)<>  -  match a string enclosed in ( ) that may contain any number of enclosed substrings, like <c green>(...)<> or <c green>(..(..)+(..))<> or <c green>(..((..)..)..)<>.
<+a>(\(([^()]++|(?-2))*\))<>  -  the same as above when it is part of a larger regular expression.

A capturing group <.r>(...)<> can be reused in other parts of regular expression. It is like a subroutine that can be called like a function by its number or name. It also can be called recursively (from itself). Unlike a backreference (the substring captured by the referenced group), a subroutine call is like a copy of the group in the regular expression. For example, regex <.r>(\w+)-(?1)<> is the same as <.r>(\w+)-(?:\w+)<>; as well as <.r>(?(DEFINE)(\w+))(?1)-(?1)<> and <.r>(?(DEFINE)(?'word'\w+))(?&word)-(?&word)<>.

-- callouts --

<.h><link https://www.pcre.org/current/doc/html/pcre2pattern.html#SEC29>Callouts<><>

<+a>(?C)<>  -  callout (assumed number 0).
<+a (?C`|`)>(?Cn)<>  -  callout with numerical data n.
<+a (?C'`|`')>(?C'text')<>  -  callout with string data.

<b>Links<>
<help>regexp.Callout<>

-- backtracking --

<.h><link https://www.pcre.org/current/doc/html/pcre2pattern.html#SEC30>Backtracking control<><>

All backtracking control verbs may be in the form <.r>(*VERB:NAME)<>. For <.r>(*MARK)<> the name is mandatory, for the others it is optional. <.r>(*SKIP)<> changes its behaviour if <.r>:NAME<> is present. The others just set a name for passing back to the caller, but this is not a name that <.r>(*SKIP)<> can see. The following act immediately they are reached:

<+a>(*ACCEPT)<>  -  force successful match.
<+a>(*FAIL)<>  -  force backtrack; synonym <+a>(*F)<>.
<+a (*MARK:`|`)>(*MARK:NAME)<>  -  set name to be passed back; synonym <+a (*:`|`)>(*:NAME)<>.

The following act only when a subsequent match failure causes a backtrack to reach them. They all force a match failure, but they differ in what happens afterwards. Those that advance the start-of-match point do so only if the pattern is not anchored.

<+a>(*COMMIT)<>  -  overall failure, no advance of starting point.
<+a>(*PRUNE)<>  -  advance to next starting character.
<+a>(*SKIP)<>  -  advance to current matching position.
<+a (*SKIP:`|`)>(*SKIP:NAME)<>  -  advance to position corresponding to an earlier <.r>(*MARK:NAME)<>; if not found, the <.r>(*SKIP)<> is ignored.
<+a>(*THEN)<>  -  local failure, backtrack to next alternation.

The effect of one of these verbs in a group called as a subroutine is confined to the subroutine call.

-- charProp --

<.h><link https://www.pcre.org/current/doc/html/pcre2pattern.html#uniextseq>Unicode character properties<><>

<+a>\pC<>  -  Other.
<+a>\p{Cc}<>  -  Control.
<+a>\p{Cf}<>  -  Format.
<+a>\p{Cn}<>  -  Unassigned.
<+a>\p{Co}<>  -  Private use.
<+a>\p{Cs}<>  -  Surrogate.

<+a>\pL<>  -  Letter.
<+a>\p{Ll}<>  -  Lower case letter.
<+a>\p{Lm}<>  -  Modifier letter.
<+a>\p{Lo}<>  -  Other letter.
<+a>\p{Lt}<>  -  Title case letter.
<+a>\p{Lu}<>  -  Upper case letter.
<+a>\p{L&}<>  -  Ll, Lu, or Lt.

<+a>\pM<>  -  Mark.
<+a>\p{Mc}<>  -  Spacing mark.
<+a>\p{Me}<>  -  Enclosing mark.
<+a>\p{Mn}<>  -  Non-spacing mark.

<+a>\pN<>  -  Number.
<+a>\p{Nd}<>  -  Decimal number.
<+a>\p{Nl}<>  -  Letter number.
<+a>\p{No}<>  -  Other number.

<+a>\pP<>  -  Punctuation.
<+a>\p{Pc}<>  -  Connector punctuation.
<+a>\p{Pd}<>  -  Dash punctuation.
<+a>\p{Pe}<>  -  Close punctuation.
<+a>\p{Pf}<>  -  Final punctuation.
<+a>\p{Pi}<>  -  Initial punctuation.
<+a>\p{Po}<>  -  Other punctuation.
<+a>\p{Ps}<>  -  Open punctuation.

<+a>\pS<>  -  Symbol.
<+a>\p{Sc}<>  -  Currency symbol.
<+a>\p{Sk}<>  -  Modifier symbol.
<+a>\p{Sm}<>  -  Mathematical symbol.
<+a>\p{So}<>  -  Other symbol.

<+a>\pZ<>  -  Separator.
<+a>\p{Zl}<>  -  Line separator.
<+a>\p{Zp}<>  -  Paragraph separator.
<+a>\p{Zs}<>  -  Space separator.

<+a>\p{Xan}<>  -  Alphanumeric: union of properties L and N.
<+a>\p{Xps}<>  -  POSIX space: property Z or tab, NL, VT, FF, CR.
<+a>\p{Xsp}<>  -  Perl space: property Z or tab, NL, VT, FF, CR.
<+a>\p{Xuc}<>  -  Univerally-named character.
<+a>\p{Xwd}<>  -  Perl word: property Xan or underscore.

-- scripts --

<.h><link https://www.pcre.org/current/doc/html/pcre2pattern.html#uniextseq>Unicode scripts<><>

Some characters belong to certain scripts, like Greek, Arabic or Han.

<+a \p{`|`}>\p{Xxx}<>  -  a character in script Xxx.
<+a \P{`|`}>\P{Xxx}<>  -  a character not in script Xxx.

<b>Script names<>

Adlam, Ahom, Anatolian_Hieroglyphs, Arabic, Armenian, Avestan, Balinese, Bamum, Bassa_Vah, Batak, Bengali, Bhaiksuki, Bopomofo, Brahmi, Braille, Buginese, Buhid, Canadian_Aboriginal, Carian, Caucasian_Albanian, Chakma, Cham, Cherokee, Common, Coptic, Cuneiform, Cypriot, Cyrillic, Deseret, Devanagari, Dogra, Duployan, Egyptian_Hieroglyphs, Elbasan, Ethiopic, Georgian, Glagolitic, Gothic, Grantha, Greek, Gujarati, Gunjala_Gondi, Gurmukhi, Han, Hangul, Hanifi_Rohingya, Hanunoo, Hatran, Hebrew, Hiragana, Imperial_Aramaic, Inherited, Inscriptional_Pahlavi, Inscriptional_Parthian, Javanese, Kaithi, Kannada, Katakana, Kayah_Li, Kharoshthi, Khmer, Khojki, Khudawadi, Lao, Latin, Lepcha, Limbu, Linear_A, Linear_B, Lisu, Lycian, Lydian, Mahajani, Makasar, Malayalam, Mandaic, Manichaean, Marchen, Masaram_Gondi, Medefaidrin, Meetei_Mayek, Mende_Kikakui, Meroitic_Cursive, Meroitic_Hieroglyphs, Miao, Modi, Mongolian, Mro, Multani, Myanmar, Nabataean, New_Tai_Lue, Newa, Nko, Nushu, Ogham, Ol_Chiki, Old_Hungarian, Old_Italic, Old_North_Arabian, Old_Permic, Old_Persian, Old_Sogdian, Old_South_Arabian, Old_Turkic, Oriya, Osage, Osmanya, Pahawh_Hmong, Palmyrene, Pau_Cin_Hau, Phags_Pa, Phoenician, Psalter_Pahlavi, Rejang, Runic, Samaritan, Saurashtra, Sharada, Shavian, Siddham, SignWriting, Sinhala, Sogdian, Sora_Sompeng, Soyombo, Sundanese, Syloti_Nagri, Syriac, Tagalog, Tagbanwa, Tai_Le, Tai_Tham, Tai_Viet, Takri, Tamil, Tangut, Telugu, Thaana, Thai, Tibetan, Tifinagh, Tirhuta, Ugaritic, Unknown, Vai, Warang_Citi, Yi, Zanabazar_Square.

<.h><link https://www.pcre.org/current/doc/html/pcre2pattern.html#SEC25>Script runs<><>

A script run is a sequence of characters that are all from the same script.

<+a (*sr:`|`)>(*sr:...)<> - script run. Matches only if <.r>...<> belongs to a single script.
<+a (*asr:`|`)>(*asr:...)<> - atomic script run (backtracking is not allowed into the <.r>...<>).

-- replace --

<.h>Replacement<>

<+a>$0<>  -  whole match.
<+a>$1<>  <+a>$2<>  <+a>$3<>  <+a>$4<>  <+a>$5<>  <+a>$6<>  <+a>$7<>  <+a>$8<>  <+a>$9<>  <+a>$10<>  -  string part that matches a capturing group <.r>(...)<>.
<+a ${`|`}>${n}<>  -  the same as above. Here n is a group number. Example: <.r>${10}<>.
<+a ${`|`}>${name}<>  -  string part that matches a named group like <.r>(?'name'...)<>.
<+a>$+<>  -  string part that matches the last group.
<+a>$`<>  -  string part before match.
<+a>$'<>  -  string part after match.
<+a>$_<>  -  whole string.
<+a>$*<>  -  the name of the last reached mark or other named <+p backtracking>verb<> like <.r>(*MARK:NAME)<>.
<+a ${+`|`}>${+func}<>  -  call a function added with <help>regexp.addReplaceFunc<> and use its return value.
<+a ${+`|`}>${+func(group)}<>  -  call function with group number or name.
<+a ${+`|`}>${+func(group, string)}<>  -  call function with some string.
<+a>$$<>  -  $ character.

These are used in the replacement text, not in the regular expression.

<b>Example<>
String: <c green>10/08/2020<>
Regex: <.r>^(\d+)/(\d+)/(\d+)$<>
Replacement: <.r>$3-$1-$2<>
Result: <c green>2020-10-08<>

<b>Links<>
<help>regexp.Replace<>

-- end --
""";
}


================================================
FILE: Au.Editor/Tools/Scripting.cs
================================================
using System.Runtime.Loader;

using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using System.Reflection;

namespace ToolLand;

static class Scripting {
	/// <summary>
	/// Compiles C# code. Optionally loads in-memory assembly and gets MethodInfo of the first static method for executing.
	/// Returns false if there are errors in code.
	/// </summary>
	/// <param name="code">C# code.</param>
	/// <param name="r">Receives results when compiled successfully.</param>
	/// <param name="addUsings">Add usings Au, Au.Types, System, generic, LINQ.</param>
	/// <param name="addGlobalCs">Add "global.cs" to the compilation if exists. It includes [module: DefaultCharSet(CharSet.Unicode)].</param>
	/// <param name="wrapInClass">Wrap code in public class __script__.</param>
	/// <param name="dll">Create dll, ie without entry method.</param>
	/// <param name="load">If not null, load in-memory assembly and get MethodInfo of the first static method for executing from public class <i>load</i>. If "", gets entry method (<i>dll</i> must be false).</param>
	/// <remarks>
	/// Also adds default references.
	/// 
	/// Function's code does not throw exceptions, but the CodeAnalysis API may throw, although undocumented and never noticed.
	/// 
	/// Thread-safe.
	/// </remarks>
	public static bool Compile(string code, out Result r, bool addUsings, bool addGlobalCs, bool wrapInClass, bool dll, string load = "__script__") {
		if (addUsings || wrapInClass) {
			var sb = new StringBuilder();
			if (addUsings) sb.AppendLine("using Au; using Au.Types; using System; using System.Collections.Generic; using System.Linq;");
			if (wrapInClass) sb.AppendLine("public class __script__ {");
			if (!code.Contains("#line ")) sb.AppendLine("#line 1");
			sb.AppendLine(code);
			if (wrapInClass) sb.AppendLine("}");
			code = sb.ToString();
			//print.it(code);
		}
		
		var parseOpt = new CSharpParseOptions(LanguageVersion.Preview);
		
		SyntaxTree treeGlobal = null;
		if (addGlobalCs) {
			if (WndCopyData.SendReceive<char>(ScriptEditor.WndMsg_, 16, "global.cs", out string gcode)) { //never mind: in LA main process/thread could call directly.
				treeGlobal = CSharpSyntaxTree.ParseText(gcode, parseOpt);
			}
			//TODO3: also recursively add files etc specified in meta c, r, etc.
			//	Now it is not important, because this func used only in "find UI object" tools, and global.cs can be useful only in 'also' field.
		}
		
		var tree = CSharpSyntaxTree.ParseText(code, parseOpt);
		var trees = treeGlobal != null ? new SyntaxTree[] { treeGlobal, tree } : new SyntaxTree[] { tree };
		var compOpt = new CSharpCompilationOptions(dll ? OutputKind.DynamicallyLinkedLibrary : OutputKind.WindowsApplication, allowUnsafe: true);
		var compilation = CSharpCompilation.Create("script", trees, s_refs, compOpt);
		var memStream = new MemoryStream(4000 + code.Length * 2);
		var emitResult = compilation.Emit(memStream);
		
		r = new Result();
		if (!emitResult.Success) {
			r.errors = string.Join("\r\n", emitResult.Diagnostics.Where(d => d.Severity == DiagnosticSeverity.Error).Select(d => d.ToString()));
			return false;
		}
		
		memStream.Position = 0;
		if (load != null) {
			var alc = new AssemblyLoadContext(null, isCollectible: true);
			r.assembly = alc.LoadFromStream(memStream);
			//print.it(AppDomain.CurrentDomain.GetAssemblies().Where(o => o.GetName().Name == "script").Count());
			
			if (load.NE()) r.method = r.assembly.EntryPoint;
			else r.method = r.assembly.GetType(load).GetMethods(BindingFlags.InvokeMethod | BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static)[0];
		} else {
			r.stream = memStream;
		}
		return true;
	}
	
	/// <summary>
	/// Creates <b>MetadataReference</b> for all .NET assemblies and Au.dll.
	/// </summary>
	static List<MetadataReference> _GetRefs() {
		var r = new List<MetadataReference>();
		var rdb = folders.ThisAppBS + "ref.db";
		using var db = new sqlite(rdb, SLFlags.SQLITE_OPEN_READONLY);
		using var stat = db.Statement("SELECT * FROM ref");
		while (stat.Step()) r.Add(MetadataReference.CreateFromImage(stat.GetArray<byte>(1), filePath: stat.GetText(0)));
		r.Add(MetadataReference.CreateFromFile(folders.ThisAppBS + "Au.dll"));
		return r;
	}
	static List<MetadataReference> s_refs = _GetRefs();
	
	public class Result {
		/// <summary>
		/// Receives errors when fails to compile.
		/// </summary>
		public string errors;
		
		/// <summary>
		/// When load is false, receives assembly bytes in stream (position=0).
		/// </summary>
		public MemoryStream stream;
		
		/// <summary>
		/// When load is true, receives loaded assembly.
		/// </summary>
		public Assembly assembly;
		
		/// <summary>
		/// When load is true, receives MethodInfo of the first static method for executing.
		/// </summary>
		public MethodInfo method;
	}
}


================================================
FILE: Au.Editor/Tools/TUtil-main-process.cs
================================================
using System.Windows;
using System.Windows.Controls;
using Au.Controls;
using System.Windows.Interop;
using System.Windows.Media;
using System.Windows.Controls.Primitives;
using System.Windows.Threading;

using ToolLand;

namespace LA;

static class TUtil2 {
	//Some tool dialogs normally run in new thread. If started from another such dialog - in its thread.
	//Currently not using this. Tools like Delm run in separate process instead.
	public static void ShowDialogInNonmainThread(Func<KDialogWindow> newDialog) {
		if (!App.IsMainThread) {
			_Show(false);
		} else {
			run.thread(() => { _Show(true); }).Name = "Au.Tool";
		}
		
		bool _Show(bool dialog) {
			try { //unhandled exception kills process if in nonmain thread
				var d = newDialog();
				if (dialog) {
					bool ok = true == d.ShowDialog();
					d.Dispatcher.InvokeShutdown(); //without this would be huge memory leaks, random crashes etc. From Dispatcher class docs: If you create a Dispatcher on a background thread, be sure to shut down the dispatcher before exiting the thread.
					return ok;
				}
				d.Show();
			}
			catch (Exception e1) { print.it(e1); }
			return false;
		}
	}
	
	public static void CloseDialogsInNonmainThreads() {
		//close tool windows running in other threads. Elso they would not save their rect etc.
		var aw = wnd.findAll(null, "HwndWrapper[*", WOwner.Process(process.thisProcessId), WFlags.CloakedToo | WFlags.HiddenToo,
			also: o => o.Prop["close me on exit"] == 1);
		foreach (var v in aw) v.SendTimeout(1000, out _, Api.WM_CLOSE);
	}
	
	public static bool UnexpandPathsMetaR(string[] a, AnyWnd errDlgOwner) {
		foreach (var v in a) {
			if (CompilerUtil.IsNetAssembly(v)) continue;
			dialog.showError("Not a .NET assembly.", v, owner: errDlgOwner);
			return false;
		}
		
		string appDir = folders.ThisAppBS, dllDir = App.Model.DllDirectoryBS;
		if (a[0].Starts(dllDir, true)) { //note: in portable LA it is in app dir
			for (int i = 0; i < a.Length; i++) a[i] = @"%dll%\" + a[i][dllDir.Length..];
		} else if (a[0].Starts(appDir, true) && !(App.IsPortable && a[0].Starts(appDir + @"data\", true))) {
			for (int i = 0; i < a.Length; i++) a[i] = a[i][appDir.Length..];
		} else if (App.Settings.tools_pathUnexpand) { //unexpand path
			for (int i = 0; i < a.Length; i++) a[i] = folders.unexpandPath(a[i]);
		}
		
		return true;
	}
}

/// <summary>
/// From path gets name and various path formats (raw, @"string", unexpanded, shortcut) for inserting in code.
/// If shortcut, also gets arguments.
/// Supports ":: ITEMIDLIST".
/// </summary>
class PathInfo {
	public readonly string fileRaw, lnkRaw, fileString, lnkString, fileUnexpanded, lnkUnexpanded;
	readonly string _name, _name2, _args;
	readonly bool _elevated, _argsComment;
	
	public PathInfo(string path, string name = null, string args = null, bool elevated = false, bool argsComment = false) {
		fileRaw = path;
		_name = name ?? _Name(path);
		_args = args;
		_elevated = elevated;
		_argsComment = argsComment;
		if (path.Ends(".lnk", true)) {
			try {
				var g = shortcutFile.open(path);
				string target = g.TargetAnyType;
				if (target.Starts("::")) {
					using var pidl = Pidl.FromString(target);
					_name2 = pidl.ToShellString(SIGDN.NORMALDISPLAY);
				} else {
					_args ??= g.Arguments.NullIfEmpty_();
					if (name == null)
						if (!target.Ends(".exe", true) || _name.Contains("Shortcut"))
							_name2 = _Name(target);
				}
				lnkRaw = path;
				fileRaw = target;
			}
			catch { }
		}
		
		_Format(fileRaw, out fileString, out fileUnexpanded);
		if (lnkRaw != null) _Format(lnkRaw, out lnkString, out lnkUnexpanded);
		if (_args != null) _args = _Str(_args);
		
		static void _Format(string raw, out string str, out string unexpanded) {
			str = _Str(raw);
			if (folders.unexpandPath(raw, out unexpanded, out var sn) && !sn.NE()) unexpanded = unexpanded + " + " + _Str(sn);
		}
		
		static string _Name(string path) {
			if (path.Starts("shell:") || path.Starts("::")) return "";
			var s = pathname.getNameNoExt(path);
			if (s.Length == 0) {
				s = pathname.getName(path); //eg some folders are like ".name"
				if (s.Length == 0 && path.Like("?:\\")) s = path[..2]; //eg "C:\"
			}
			return s;
		}
	}
	
	static string _Str(string s) {
		if (s == null) return "null";
		if (!TUtil.MakeVerbatim(ref s)) s = s.Escape(quote: true);
		return s;
	}
	
	/// <summary>
	/// Gets path of window's program for <see cref="run.it"/>. Supports appid, folder, mmc, itemidlist.
	/// Returns null if failed to get path or app id.
	/// </summary>
	public static PathInfo FromWindow(wnd w) {
		var path = WndUtil.GetWindowsStoreAppId(w, true, true);
		if (path == null) return null;
		string name = null, args = null;
		bool elevated = w.Uac.Elevation == UacElevation.Full;
		bool argsComment = false;
		//if folder window, try to get folder path
		if (path.Starts("shell:")) {
			name = w.Name;
		} else if (path.Ends(@"\explorer.exe", true) && w.ClassNameIs("CabinetWClass")) {
			var s1 = ExplorerFolder.Of(w)?.GetFolderPath();
			if (!s1.NE()) path = s1;
		} else {
			var s = process.getCommandLine(w.ProcessId, removeProgram: true);
			if (!s.NE()) {
				if (path.Ends(@"\javaw.exe", true)) {
					args = s;
				} else if (path.Ends(@"\mmc.exe", true)
					&& path[..^8].Eqi(folders.System)
					&& s.RxMatch($@"^("".+?\.msc""|\S+\.msc)(?: (.+))?$", out RXMatch m)) {
					s = m[1].Value.Trim('"');
					if (!pathname.isFullPath(s)) s = filesystem.searchPath(s);
					else if (!filesystem.exists(s)) s = null;
					if (s != null) { path = s; args = m[2].Value; name = w.Name; }
					;
				} else {
					args = s;
					argsComment = args != null;
				}
				
			}
		}
		var r = new PathInfo(path, name, args, elevated, argsComment);
		return r;
	}
	
	/// <summary>
	/// Gets path/name/args code for inserting in editor.
	/// path is escaped/enclosed and may be unexpanded (depends on settings), like <c>@"x:\a\b.c"</c> or <c>folders.Example + @"a\b.c"</c>.
	/// If args not null, it is escaped/enclosed is like ", args" or "/*, args*/".
	/// </summary>
	public (string path, string name, string args) GetStringsForCode() {
		bool lnk = App.Settings.tools_pathLnk && lnkString != null;
		var path = lnk
			? (App.Settings.tools_pathUnexpand && lnkUnexpanded != null ? lnkUnexpanded : lnkString)
			: (App.Settings.tools_pathUnexpand && fileUnexpanded != null ? fileUnexpanded : fileString);
		var name = lnk ? _name : (_name2 ?? _name);
		var args = lnk ? null : _args;
		if (args != null) args = _argsComment ? "/*, " + args + "*/" : ", " + args;
		return (path, name, args);
	}
	
	/// <summary>
	/// Calls <see cref="GetStringsForCode"/> and returns code like <c>run.it(path);</c>.
	/// </summary>
	/// <param name="what">Var, Run or RunMenu.</param>
	/// <param name="varIndex">If not 0, appends to s in `var s = path`.</param>
	public string FormatCode(PathCode what, int varIndex = 0) {
		var (path, name, args) = GetStringsForCode();
		string nameComment = (what is PathCode.Var or PathCode.Run && (path.Starts("\":: ") || path.Like("folders.shell.*\"")) && !name.NE()) ? $"/* {name} */ " : null;
		if (what is PathCode.Var) {
			string si = varIndex > 0 ? varIndex.ToS() : null;
			return $"string s{si} = {nameComment}{path};"; //not var s, because may be FolderPath
		} else if (what is PathCode.Run or PathCode.RunMenu) {
			var b = new StringBuilder();
			if (what is PathCode.RunMenu) {
				var t = CiUtil.GetNearestLocalVariableOfType("Au.toolbar", "Au.popupMenu");
				b.Append($"{t?.Name ?? "t"}[{_Str(name)}] = o => ");
			}
			b.Append("run.it(").Append(nameComment).Append(path).Append(args);
			if (_elevated) b.Append(", flags: RFlags.Admin");
			b.Append(");");
			return b.ToString();
		}
		return null;
	}
	
	/// <summary>
	/// Shows "insert file path code" menu and returns its result.
	/// Called for drag-dropped files or shell items.
	/// </summary>
	public static PathCode InsertCodeMenu(string[] paths, AnyWnd owner) {
		var m = new popupMenu { CheckDontClose = true };
		
		void _Add(PathCode what, string text) { m.Add((int)what, text); }
		
		_Add(PathCode.Var, "string s = path;");
		_Add(PathCode.Run, "run.it(path);");
		_Add(PathCode.RunMenu, "t[name] = o => run.it(path);");
		if (paths.All(o => filesystem.exists(o).Directory)) {
			_Add(PathCode.EnumDir, "Get files in folder...");
		} else if (paths.All(o => filesystem.exists(o).File && o.Ends(".dll", true))) {
			_Add(PathCode.MetaR, "/*/ r path; /*/");
		}
		m.Separator();
		m.AddCheck("Unexpand path (option)", App.Settings.tools_pathUnexpand, o => App.Settings.tools_pathUnexpand ^= true);
		if (paths.Any(o => o.Ends(".lnk", true)))
			m.AddCheck("Shortcut path (option)", App.Settings.tools_pathLnk, o => App.Settings.tools_pathLnk ^= true);
		
		var R = (PathCode)m.Show(owner: owner);
		
		if (R is PathCode.EnumDir) {
			DEnumDir.Dialog(paths[0]);
			return 0;
		}
		
		if (R is PathCode.MetaR) {
			if (TUtil2.UnexpandPathsMetaR(paths, owner)) {
				var p = new MetaCommentsParser(App.Model.CurrentFile);
				p.r.AddRange(paths);
				p.Apply();
			}
			return 0;
		}
		
		return R;
		
		//rejected
		//static bool _IsConsole(string path) {
		//	if (!path.Ends(".exe", true)) return path.Ends(".bat", true);
		//	return 0x4550 == Api.SHGetFileInfo(path, out _, Api.SHGFI_EXETYPE);
		//}
	}
	
	/// <summary>
	/// Adds "insert file path code" items to the quick capture menu.
	/// </summary>
	/// <param name="m">Submenu "Program".</param>
	/// <param name="click"></param>
	public static void QuickCaptureMenu(popupMenu m, Action<PathCode> click) {
		m.CheckDontClose = true;
		
		void _Add(PathCode what, string text) { m[text] = o => click(what); }
		
		_Add(PathCode.Var, "string s = path;");
		_Add(PathCode.Run, "run.it(path);");
		_Add(PathCode.RunMenu, "t[name] = o => run.it(path);");
		m.Separator();
		m.AddCheck("Unexpand path (option)", App.Settings.tools_pathUnexpand, o => App.Settings.tools_pathUnexpand ^= true);
	}
}

enum PathCode { None, Var, Run, RunMenu, EnumDir, MetaR }


================================================
FILE: Au.Editor/Tools/TUtil.cs
================================================
using Au.Controls;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Interop;
using System.Windows.Media;
using System.Windows.Controls.Primitives;
using System.Windows.Threading;

namespace ToolLand;

static partial class TUtil {
	#region text
	
	/// <summary>
	/// Appends `, ` and string argument.
	/// </summary>
	/// <param name="t"></param>
	/// <param name="s">
	/// Argument value.
	/// If null, appends `null`.
	/// Else if like `@@expression`, appends `expression`.
	/// Else if matches `@"*"` or `$"*"` or `$@"*"` or `@$"*"`, appends `s`.
	/// Else appends `"escaped s"`; can make verbatim.
	/// </param>
	/// <param name="param">If not null, appends `param: s`. By default appends only `s`. If "null", appends `null, s`.</param>
	/// <param name="noComma">Don't append `, `. If false, does not append if b.Length is less than 2 or if b ends with one of: <c>,([{&lt;</c>.</param>
	public static StringBuilder AppendStringArg(this StringBuilder t, string s, string param = null, bool noComma = false) {
		_AppendArgPrefix(t, param, noComma);
		if (s == null) t.Append("null");
		else if (s.Starts("@@")) t.Append(s[2..]);
		else if (IsVerbatim(s, out _) || MakeVerbatim(ref s)) t.Append(s);
		else t.Append(s.Escape(quote: true));
		return t;
	}
	
	/// <summary>
	/// Appends `, ` and non-string argument.
	/// </summary>
	/// <param name="t"></param>
	/// <param name="s">Argument value. Must not be empty.</param>
	/// <param name="param">If not null, appends `param: s`. By default appends only `s`. If "null", appends `null, s`.</param>
	/// <param name="noComma">Don't append `, `. Use for the first parameter. If false, does not append only if b.Length is less than 2.</param>
	public static StringBuilder AppendOtherArg(this StringBuilder t, string s, string param = null, bool noComma = false) {
		Debug.Assert(!s.NE());
		_AppendArgPrefix(t, param, noComma);
		t.Append(s);
		return t;
	}
	
	static void _AppendArgPrefix(StringBuilder t, string param, bool noComma) {
		if (!noComma && t.Length > 1 && t[^1] is not ('(' or '[' or '{' or '<' or ',')) t.Append(", ");
		if (param != null) t.Append(param).Append(param == "null" ? ", " : ": ");
	}
	
	/// <summary>
	/// Appends waitTime. If !orThrow, appends "-" if need.
	/// If !orThrow and !appendAlways and waitTime == "0", appends nothing and returns false.
	/// </summary>
	public static bool AppendWaitTime(this StringBuilder t, string waitTime, bool orThrow, bool appendAlways = false) {
		if (waitTime.NE()) waitTime = "8e88";
		if (!orThrow) {
			if (!appendAlways && waitTime == "0") return false;
			if (!waitTime.Starts('-') && waitTime != "0") t.Append('-');
		}
		t.Append(waitTime);
		return true;
	}
	
	/// <summary>
	/// If some <i>use</i> are true, formats a flags argument like "Enum.Flag1 | Enum.Flag2" and returns true.
	/// </summary>
	public static bool FormatFlags<T>(out string s, params (bool use, T flag)[] af) where T : unmanaged, Enum {
		if (!af.Any(o => o.use)) { s = null; return false; }
		s = string.Join(" | ", af.Where(o => o.use).Select(o => typeof(T).Name + "." + o.flag));
		return true;
	}
	
	/// <summary>
	/// If some <i>use</i> checkboxes are checked or indeterminate, formats a flags argument like "Enum.Flag1 | Enum.Flag2" and returns true. Ignores null controls.
	/// </summary>
	public static bool FormatFlags<T>(out string s, params (CheckBox use, T flag)[] af) where T : unmanaged, Enum {
		return FormatFlags(out s, af.Select(o => (o.use != null && o.use.IsChecked != false, o.flag)).ToArray());
	}
	
	/// <summary>
	/// Formats flags like "Enum.Flag1 | Enum.Flag2".
	/// </summary>
	/// <param name="flags"></param>
	public static string FormatFlags<T>(T flags) where T : unmanaged, Enum {
		var s = flags.ToString();
		if (!char.IsAsciiDigit(s[0])) s = s.Replace(", ", " | ").RxReplace(@"\b(?=\w)", typeof(T).Name + ".");
		return s;
	}
	
	/// <summary>
	/// Returns true if s is like `@"*"` or `$"*"` or `$@"*"` or `@$"*"`.
	/// s can be null.
	/// </summary>
	public static bool IsVerbatim(string s, out int prefixLength) {
		prefixLength = (s.Like(false, "@\"*\"", "$\"*\"", "$@\"*\"", "@$\"*\"") + 1) / 2;
		return prefixLength > 0;
	}
	
	/// <summary>
	/// If s contains \ and no newlines/controlchars: replaces all " with "", prepends @", appends " and returns true.
	/// </summary>
	/// <param name="s"></param>
	/// <returns></returns>
	public static bool MakeVerbatim(ref string s) {
		if (!s.Contains('\\') || s.RxIsMatch(@"[\x00-\x1F\x85\x{2028}\x{2029}]")) return false;
		s = "@\"" + s.Replace("\"", "\"\"") + "\"";
		return true;
	}
	
	/// <summary>
	/// If s has *? characters, prepends "**t ".
	/// s can be null.
	/// </summary>
	public static string EscapeWildex(string s) {
		if (wildex.hasWildcardChars(s)) s = "**t " + s;
		return s;
	}
	
	/// <summary>
	/// If s has *? characters, prepends "**t ".
	/// If <i>canMakeVerbatim</i>, finally calls <see cref="MakeVerbatim"/>.
	/// s can be null.
	/// </summary>
	public static string EscapeWindowName(string s, bool canMakeVerbatim) {
		if (s != null) {
			if (wildex.hasWildcardChars(s)) s = "**t " + s;
			if (canMakeVerbatim) MakeVerbatim(ref s);
		}
		return s;
	}
	//rejected: if name has * at the start or end, make regex like @"**r \*?\QUntitled - Notepad\E", so that would find with or without *.
	//	Ugly. Most users will not know what it is. Anyway in most cases need to replace the document part with *.
	///// <summary>
	///// If s has *? characters, prepends "**t ".
	///// But if s has single * character, converts to "**r regex" that ignores it. Because single * often is used to indicate unsaved state.
	///// If canMakeVerbatim, finally calls <see cref="MakeVerbatim"/>.
	///// s can be null.
	///// </summary>
	//public static string EscapeWindowName(string s, bool canMakeVerbatim) {
	//	if (s == null) return s;
	//	if (wildex.hasWildcardChars(s)) {
	//		int i = s.IndexOf('*');
	//		if (i >= 0 && s.IndexOf('*', i + 1) < 0) {
	//			s = "**r " + regexp.escapeQE(s[..i]) + @"\*?" + regexp.escapeQE(s[++i..]);
	//		} else s = "**t " + s;
	//	}
	//	if (canMakeVerbatim) MakeVerbatim(ref s);
	//	return s;
	//}
	
	/// <summary>
	/// Returns true if newRawValue does not match wildex tbValue, unless contains is like $"..." or $@"...".
	/// </summary>
	/// <param name="tbValue">A wildex string, usually from a TextBox control. Can be raw or verbatim. Can be null.</param>
	/// <param name="newRawValue">New raw string, not wildex. Can be null.</param>
	public static bool ShouldChangeTextBoxWildex(string tbValue, string newRawValue) {
		tbValue ??= "";
		if (newRawValue == null) newRawValue = "";
		if (IsVerbatim(tbValue, out _)) {
			if (tbValue[0] == '$') return false;
			tbValue = tbValue[2..^1].Replace("\"\"", "\"");
		}
		var x = new wildex(tbValue, noException: true);
		return !x.Match(newRawValue);
	}
	
	/// <summary>
	/// Replaces known non-constant window class names with wildcard. Eg "WindowsForms10.EDIT..." with "*.EDIT.*".
	/// </summary>
	/// <param name="s">Can be null.</param>
	/// <param name="escapeWildex">If didn't replace, call <see cref="EscapeWildex"/>.</param>
	public static string StripWndClassName(string s, bool escapeWildex) {
		if (!s.NE()) {
			int n = s.RxReplace(@"^WindowsForms\d+(\..+?\.).+", "*$1*", out s);
			if (n == 0) n = s.RxReplace(@"^(HwndWrapper\[.+?;|Afx:).+", "$1*", out s);
			if (escapeWildex && n == 0) s = EscapeWildex(s);
		}
		return s;
	}
	
	public static string ArgsFromWndFindCode(string wndFind) {
		if (wndFind.RxMatch(@"\bwnd.find\((?:-?\d+, )?(.+)\);", 1, out RXGroup g)) return g.Value;
		return null;
	}
	
	#endregion
	
	#region misc
	
	/// <summary>
	/// Gets Keyboard.FocusedElement. If null, and a HwndHost-ed control is focused, returns the HwndHost.
	/// Slow if HwndHost-ed control.
	/// </summary>
	public static FrameworkElement FocusedElement {
		get {
			var v = System.Windows.Input.Keyboard.FocusedElement;
			if (v != null) return v as FrameworkElement;
			return wnd.Internal_.ToWpfElement(Api.GetFocus());
		}
	}
	
	/// <summary>
	/// Inserts text in specified or focused control.
	/// At current position, not as new line, replaces selection.
	/// </summary>
	/// <param name="c">If null, uses the focused control, else sets focus.</param>
	/// <param name="s">If contains <c>`|`</c>, removes it and moves caret there; must be single line.</param>
	public static void InsertTextIn(FrameworkElement c, string s) {
		if (c == null) {
			c = FocusedElement;
			if (c == null) return;
		} else {
			Debug.Assert(Environment.CurrentManagedThreadId == c.Dispatcher.Thread.ManagedThreadId);
			if (c != FocusedElement) //be careful with HwndHost
				c.Focus();
		}
		
		int i = s.Find("`|`");
		if (i >= 0) {
			Debug.Assert(!s.Contains('\n'));
			s = s.Remove(i, 3);
			i = s.Length - i;
		}
		
		if (c is KScintilla sci) {
			if (sci.aaaIsReadonly) return;
			sci.aaaReplaceSel(s);
			while (i-- > 0) sci.Call(Sci.SCI_CHARLEFT);
		} else if (c is TextBox tb) {
			if (tb.IsReadOnly) return;
			tb.SelectedText = s;
			tb.CaretIndex = tb.SelectionStart + tb.SelectionLength - Math.Max(i, 0);
		} else {
			Debug_.Print(c);
			if (!c.Hwnd().Window.ActivateL()) return;
			Task.Run(() => {
				var k = new keys(null);
				k.AddText(s);
				if (i > 0) k.AddKey(KKey.Left).AddRepeat(i);
				k.SendNow();
			});
		}
	}
	
	/// <summary>
	/// Gets control id. Returns true if it can be used to identify the control in window wWindow.
	/// </summary>
	public static bool GetUsefulControlId(wnd wControl, wnd wWindow, out int id) {
		id = wControl.ControlId;
		if (id == 0 || id == -1 || id > 0xffff || id < -0xffff) return false;
		//info: some apps use negative ids, eg FileZilla. Usually >= -0xffff. Id -1 is often used for group buttons and separators.
		//if(id == (int)wControl) return false; //.NET forms, delphi. //possible coincidence //rejected, because window handles are > 0xffff
		Debug.Assert((int)wControl > 0xffff);
		
		//if(wWindow.Child(id: id) != wControl) return false; //problem with combobox child Edit that all have id 1001
		if (wWindow.ChildAll(id: id).Length != 1) return false; //note: searching only visible controls; else could find controls with same id in hidden pages of tabbed dialog.
		return true;
	}
	
	/// <summary>
	/// Returns <b>wnd.Child</b> parameter <i>skip</i> if <i>c</i> is not the first found <i>w</i> child control with <i>name</i> and <i>cn</i>.
	/// </summary>
	public static string GetControlSkip(wnd w, wnd c, string name, string cn, bool hiddenToo) {
		if (!c.Is0) {
			var a = w.ChildAll(name, cn, hiddenToo ? WCFlags.HiddenToo : 0);
			if (a.Length > 1 && a[0] != c) {
				int skip = Array.IndexOf(a, c);
				if (skip > 0) return skip.ToS();
			}
		}
		return null;
	}
	
	/// <summary>
	/// Calls EventManager.RegisterClassHandler for CheckBox.CheckedEvent, CheckBox.UncheckedEvent, TextBox.TextChangedEvent and optionally ComboBox.SelectionChangedEvent.
	/// Call from static ctor of KDialogWindow-based or ContentControl-based classes.
	/// The specified event handler will be called on events of any of these controls in all dialogs/containers of T type.
	/// </summary>
	/// <typeparam name="T"></typeparam>
	/// <param name="changed">Called on event.</param>
	/// <param name="comboToo">Register for ComboBox too.</param>
	public static void OnAnyCheckTextBoxValueChanged<T>(Action<T, object> changed, bool comboToo = false) where T : ContentControl {
		var h = new RoutedEventHandler((sender, e) => {
			//print.it(sender, e.Source, e.OriginalSource);
			var source = e.OriginalSource; //e.Source can't be used; it == e.OriginalSource if T is KDialogWindow, but == sender if T is UserControl.
			if (source is CheckBox or TextBox or ComboBox) changed(sender as T, source);
		});
		EventManager.RegisterClassHandler(typeof(T), ToggleButton.CheckedEvent, h);
		EventManager.RegisterClassHandler(typeof(T), ToggleButton.UncheckedEvent, h);
		EventManager.RegisterClassHandler(typeof(T), TextBoxBase.TextChangedEvent, h);
		if (comboToo) EventManager.RegisterClassHandler(typeof(T), Selector.SelectionChangedEvent, h);
	}
	
	/// <summary>
	/// Takes screenshot of standard size to display in editor's margin.
	/// Color-quantizes, compresses and converts to a comment string to embed in code.
	/// Returns null if <b>LA.App.Settings.edit_noImages</b>.
	/// </summary>
	/// <param name="p">Point in center of screenshot rectangle.</param>
	/// <param name="capt">If used, temporarily hides its on-screen rect etc.</param>
	public static string MakeScreenshot(POINT p, CapturingWithHotkey capt = null) {
		if (LA.App.Settings.edit_noImages) return null;
		using var thr = capt?.TempHideRect();
		const int sh = 30;
		return ColorQuantizer.MakeScreenshotComment(new(p.x - sh, p.y - sh / 2, sh * 2, sh));
	}
	
	#endregion
	
	#region OnScreenRect
	
	/// <summary>
	/// Creates standard <see cref="osdRect"/>.
	/// </summary>
	public static osdRect CreateOsdRect(int thickness = 4) => new() { Color = 0xFF0000, Thickness = thickness, TopmostWorkaround_ = true }; //red
	
	/// <summary>
	/// Briefly shows standard blinking on-screen rectangle.
	/// If disp, shows async in its thread.
	/// </summary>
	public static void ShowOsdRect(RECT r, bool error = false, bool limitToScreen = false, Dispatcher disp = null) {
		if (disp != null) {
			disp.InvokeAsync(() => ShowOsdRect(r, error, limitToScreen));
		} else {
			int thick = error ? 6 : 2;
			var osr = new osdRect { Color = error ? 0xFF0000 : 0x0000FF, Thickness = thick * 2, TopmostWorkaround_ = true };
			r.Inflate(thick, thick); //2 pixels inside, 2 outside
			if (limitToScreen) {
				var k = screen.of(r).Rect;
				r.Intersect(k);
			} else _LimitInsaneRect(ref r);
			osr.Rect = r;
			_OsdRectShow(osr, error);
		}
	}
	
	static void _OsdRectShow(osdRect osr, bool error = false) {
		t_hideCapturingRect = true;
		osr.Show();
		int i = 0;
		timer.every(250, t => {
			if (i++ < 4) {
				osr.Hwnd.ZorderTopRaw_();
				osr.Color = (i & 1) != 0 ? 0xFFFF00 : error ? 0xFF0000 : 0x0000FF;
			} else {
				t.Stop();
				osr.Dispose();
				t_hideCapturingRect = false;
			}
		});
	}
	
	[ThreadStatic] static bool t_hideCapturingRect;
	
	//eg VS Code code editor and output are {W=1000000 H=1000000}. Then the rect drawing code would fail.
	static void _LimitInsaneRect(ref RECT r) {
		if (r.Width > 2000 || r.Height > 1200) {
			var rs = screen.virtualScreen; rs.Inflate(100, 100);
			r.Intersect(rs);
		}
	}
	
	/// <summary>
	/// Briefly shows multiple on-screen rectangles.
	/// If disp, shows async in its thread.
	/// Can modify <i>a</i> elements.
	/// </summary>
	public static void ShowOsdRects(RECT[] a, Dispatcher disp = null) {
		if (disp != null) {
			disp.InvokeAsync(() => ShowOsdRects(a));
		} else {
			var osr = new osdRect { Color = 0x0000FF, Thickness = 2, TopmostWorkaround_ = true };
			for (int i = 0; i < a.Length; i++) _LimitInsaneRect(ref a[i]);
			osr.SetRects(a);
			_OsdRectShow(osr);
		}
	}
	
	#endregion
	
	#region test
	
	public record RunTestFindResult(object obj, long speed, InfoStrings info);
	
	/// <summary>
	/// Executes test code that finds an object in window.
	/// Returns the found object, speed and info strings to display. On error speed negative.
	/// </summary>
	/// <param name="owner">Owner dialog.</param>
	/// <param name="code">
	/// Must start with one or more lines that find window or control and set wnd variable named <i>wndVar</i>. Can be any code.
	/// The last line must be a "find object" or "find all objects" function call, like <c>uiimage.find(...);</c>. No `var x = `, no "not found" exception, no wait, no action.
	/// If "find all objects", will display rectangles of all found objects and return the first found object.
	/// </param>
	/// <param name="wndVar">Name of wnd variable of the window or control in which to search.</param>
	/// <param name="w">Window or control in which to search. For a wnd tool can be 0.</param>
	/// <param name="getRect">Callback function that returns object's rectangle in screen. Called when object has been found.</param>
	/// <param name="activateWindow">Between finding window and object in it, activate the found window and wait 200 ms.</param>
	/// <param name="restoreOwner">If this func minimizes or deactivates the owner window, it sets a timer to restore it after eg ~2 seconds. If <i>restoreOwner</i> not null, the timer will delay restoring until restoreOwner[0] != 0, after restoreOwner[0] ms.</param>
	/// <param name="rectDisp">Use this dispatcher to show rectangles. For example if calling this in a non-UI thread and want to show in UI thread.</param>
	/// <example>
	/// <code><![CDATA[
	/// var rr = TUtil.RunTestFindObject(this, code, wndVar, _wnd, o => (o as elm).Rect);
	/// _info.InfoErrorOrInfo(rr.info);
	/// ]]></code>
	/// </example>
	public static RunTestFindResult RunTestFindObject(
		AnyWnd owner, string code, string wndVar, wnd w,
		Func<object, RECT> getRect = null,
		/*
		/// <param name="invoke">Callback that executes the code. Let it call/return MethodInfo.Invoke(null, null). For example if wants to execute in other thread. If null, the code is executed in this thread.</param>
		Func<MethodInfo, object> invoke = null
		*/
		bool activateWindow = false, int[] restoreOwner = null, Dispatcher rectDisp = null) {
		
		Debug.Assert(!code.NE());
		//print.it(code);
		//perf.first();
		
		var code0 = code;
		var b = new StringBuilder();
		b.AppendLine(@"static object[] __TestFunc__() {");
		if (activateWindow) b.Append("((wnd)").Append(w.Window.Handle).Append(").ActivateL(); 300.ms(); ");
		b.AppendLine("var _p_ = perf.local();");
		b.AppendLine("#line 1");
		var lines = code.Lines(true);
		int lastLine = lines.Length - 1;
		for (int i = 0; i < lastLine; i++) b.AppendLine(lines[i]);
		b.AppendLine("_p_.Next(); var _a_ =");
		b.AppendLine("#line " + (lastLine + 1));
		b.AppendLine(lines[lastLine]);
		b.AppendLine("_p_.Next();");
		b.AppendLine($"return new object[] {{ _p_.ToArray(), _a_, {wndVar} }};");
		b.AppendLine("\r\n}");
		code = b.ToString(); //print.it(code);
		
		(long[] speed, object obj, wnd w) r = default;
		wnd dlg = owner.Hwnd;
		bool dlgWasActive = dlg.IsActive, dlgMinimized = false;
		try {
			try {
				if (!Scripting.Compile(code, out var c, addUsings: true, addGlobalCs: true, wrapInClass: true, dll: true)) {
					Debug_.Print("---- CODE ----\r\n" + code + "--------------");
					//shows code too, because it may be different than in the code box
					return new(null, -1, new(true, "Errors:", $"{c.errors}\r\n\r\n<lc #C0C0C0><b>Code:<><>\r\n<code>{code0}</code>"));
				}
				//object ro = invoke?.Invoke(c.method) ?? c.method.Invoke(null, null);
				object ro = c.method.Invoke(null, null);
				var rr = (object[])ro; //use array because fails to cast tuple, probably because in that assembly it is new type
				r = ((long[])rr[0], rr[1], (wnd)rr[2]);
			}
			catch (Exception e) {
				if (e is TargetInvocationException tie) e = tie.InnerException;
				string s1, s2;
				if (e is NotFoundException) { //info: throws only when window not found
					s1 = "Window not found";
					s2 = "Tip: If part of window name changes, replace it with *";
				} else {
					s1 = e.GetType().Name;
					s2 = e.Message.RxReplace(@"^Exception of type '.+?' was thrown. ", "");
					if (e.StackTrace.RxMatch(@"(?m)^\s*( at .+?)\(.+\R\s+\Qat __script__.__TestFunc__()\E", 1, out string s3)) s1 += s3;
				}
				return new(null, -2, new(true, s1, s2));
			}
			
			//perf.nw();
			//print.it(r);
			
			static double _SpeedMcsToMs(long tn) => Math.Round(tn / 1000d, tn < 1000 ? 2 : (tn < 10000 ? 1 : 0));
			double t0 = _SpeedMcsToMs(r.speed[0]), t1 = _SpeedMcsToMs(r.speed[1]); //times of wnd.find and Object.Find
			string sSpeed;
			if (lastLine == 1 && lines[0] == "wnd w;") sSpeed = t1.ToS() + " ms"; //only wnd.find: "wnd w;\r\nw = wnd.find(...);"
			else sSpeed = t0.ToS() + " + " + t1.ToS() + " ms";
			
			if (r.obj is wnd w1 && w1.Is0) r.obj = null;
			
			//FindAll used instead of Find?
			var en = r.obj as IEnumerable<object>;
			if (en != null && !en.Any()) r.obj = null;
			
			if (r.obj != null) {
				RECT re;
				if (en != null) {
					var ar = en.Select(o => getRect(o)).ToArray();
					re = RECT.FromLTRB(ar.Min(o => o.left), ar.Min(o => o.top), ar.Max(o => o.right), ar.Max(o => o.bottom));
					r.obj = en.First();
					ShowOsdRects(ar, disp: rectDisp);
				} else {
					re = getRect(r.obj);
					ShowOsdRect(re, disp: rectDisp);
				}
				
				//if dlg covers the found object, temporarily minimize it (may be always-on-top) and activate object's window. Never mind owners.
				var wTL = r.w.Window;
				if (dlgMinimized = dlg.Rect.IntersectsWith(re) && !r.w.IsOfThisThread && !dlg.IsMinimized) {
					dlg.ShowMinimized(1);
					wTL.ActivateL();
					wait.doEvents(1000);
				}
			}
			
			if (r.w != w && !r.w.Is0 && !w.Is0) {
				ShowOsdRect(r.w.Rect, error: true, limitToScreen: true, disp: rectDisp);
				//FUTURE: show list of objects inside the wanted window, same as in the Dwnd 'contains' combo. Let user choose. Then update window code quickly.
				//string wndCode = null;
				//wndCode = "wnd w = wnd.find(\"Other\");";
				return new(null, -3, new(true, "Finds another " + (r.w.IsChild ? "control" : "window"), $"<i>Need:<>  {w}\r\n<i>Found:<>  {r.w}"));
			}
			
			return new(r.obj, r.speed[1], new(r.obj == null, r.obj != null ? "Found" : "Not found", null, ",  speed " + sSpeed));
		}
		finally {
			if (dlgWasActive || dlgMinimized) {
				int after = activateWindow && !dlgMinimized && r.w == w ? 1500 : 500;
				timer.after(after, t => {
					if (!dlg.IsAlive) return;
					if (restoreOwner == null) {
						if (dlgMinimized) dlg.ShowNotMinimized(1);
						if (dlgWasActive) dlg.ActivateL();
					} else if (restoreOwner[0] == 0) {
						t.After(100);
					} else {
						t.After(restoreOwner[0]);
						restoreOwner = null;
					}
				});
			}
		}
	}
	
	public record InfoStrings(bool isError, string header, string text, string headerSmall = null) {
		//public string text2 { get; set; }
	}
	
	/// <summary>
	/// Executes action code for a found UI element etc.
	/// </summary>
	/// <returns>Error strings to display, or null if no error.</returns>
	/// <param name="obj">The element. The function passes it to the test script.</param>
	/// <param name="code">Code like "Method(arguments)". The function prepends "obj." and appends ";".</param>
	public static InfoStrings RunTestAction(object obj, string code) {
		var code0 = code;
		code = $@"static void __TestFunc__({obj.GetType()} obj) {{
#line 1
obj.{code};
}}";
		//print.it(code);
		
		try {
			if (!Scripting.Compile(code, out var c, addUsings: true, addGlobalCs: true, wrapInClass: true, dll: true))
				return new(true, "Errors:", $"{c.errors}\r\n\r\n<b>Code:<>\r\n<code>obj.{code0};</code>");
			c.method.Invoke(null, new object[] { obj });
			return null;
		}
		catch (Exception e) {
			if (e is TargetInvocationException tie) e = tie.InnerException;
			return new(true, "Action failed", e.GetType().Name + ". " + e.Message.RxReplace(@"^Exception of type '.+?' was thrown. ", ""));
		}
	}
	
	public static async Task<InfoStrings> RunTestCodeAsync(string code, CancellationToken cancel = default) {
		var code0 = code;
		code = $@"static void __TestFunc__(CancellationToken cancel) {{
#line 1
{code}
}}";
		//print.it(code);
		
		try {
			if (!Scripting.Compile(code, out var c, addUsings: true, addGlobalCs: true, wrapInClass: true, dll: true)) {
				Debug_.Print("---- CODE ----\r\n" + code + "--------------");
				return new(true, "Errors:", $"{c.errors}\r\n\r\n<b>Code:<>\r\n<code>{code0};</code>");
			}
			await Task.Run(() => { c.method.Invoke(null, new object[] { cancel }); });
			return null;
		}
		catch (Exception e) {
			if (e is TargetInvocationException tie) e = tie.InnerException;
			return new(true, "Failed", e.GetType().Name + ". " + e.Message.RxReplace(@"^Exception of type '.+?' was thrown. ", ""));
		}
	}
	
	#endregion
	
	#region info
	
	public static void InfoError(this KSciInfoBox t, string header, string text, string headerSmall = null) {
		t.aaaText = $"<lc #F0E080><b>{header}<>{headerSmall}<>\r\n{text}";
		t.AaSuspendElems();
	}
	
	public static void InfoInfo(this KSciInfoBox t, string header, string text, string headerSmall = null) {
		t.aaaText = $"<lc #C0E0C0><b>{header}<>{headerSmall}<>\r\n{text}";
		t.AaSuspendElems();
	}
	
	public static void InfoErrorOrInfo(this KSciInfoBox t, InfoStrings info) {
		var text = info.text /*?? info.text2*/;
		if (info.isError) InfoError(t, info.header, text, info.headerSmall);
		else InfoInfo(t, info.header, text, info.headerSmall);
	}
	
	public static void Info(this KSciInfoBox t, FrameworkElement e, string name, string text) {
		text = CommonInfos.PrependName(name, text);
		t.AaAddElem(e, text);
	}
	
	public static void InfoC(this KSciInfoBox t, ContentControl k, string text) => Info(t, k, _ControlName(k), text);
	
	public static void InfoCT(this KSciInfoBox t, KCheckTextBox k, string text, bool isWildex = false, string wildexPart = null) {
		text = CommonInfos.PrependName(_ControlName(k.c), text);
		if (isWildex) text = CommonInfos.AppendWildexInfo(text, wildexPart);
		t.AaAddElem(k.c, text);
		t.AaAddElem(k.t, text);
	}
	
	public static void InfoCO(this KSciInfoBox t, KCheckComboBox k, string text) {
		text = CommonInfos.PrependName(_ControlName(k.c), text);
		t.AaAddElem(k.c, text);
		t.AaAddElem(k.t, text);
	}
	
	/// <summary>
	/// Returns k text without '_' character used for Alt+underline.
	/// </summary>
	static string _ControlName(ContentControl k) => StringUtil.RemoveUnderlineChar(k.Content as string, '_');
	
	/// <summary>
	/// Can be used by tool dialogs to display common info in <see cref="KSciInfoBox"/> control.
	/// </summary>
	public class CommonInfos {
		KSciInfoBox _control;
		RegexWindow _regexWindow;
		
		public CommonInfos(KSciInfoBox control) {
			_control = control;
			_control.AaTags.AddLinkTag("+regex", o => _Regex(o));
		}
		
		void _Regex(string _) {
			_regexWindow ??= new();
			if (_regexWindow.Hwnd.Is0) {
				_regexWindow.ShowByRect(_control.Hwnd().Window, Dock.Bottom);
			} else _regexWindow.Hwnd.ShowL(true);
		}
		
		/// <summary>
		/// Formats "name - text" string, where name is bold: <![CDATA["<b>" + name + "<> - " + text]]>.
		/// </summary>
		public static string PrependName(string name, string text) => "<b>" + name + "<> - " + text;
		
		public static string AppendWildexInfo(string s, string part = null) => s + "\r\n" + (part ?? "The text") +
@" is <help articles/Wildcard expression>wildcard expression<>. Can be <+regex>regex<>, like <mono>**rc regex<>.
Examples:
<mono>whole text
*end
start*
*middle*
time ??:??
**t literal text
**c case-sensitive text
**tc case-sensitive literal
**r regular expression
**rc case-sensitive regex
**n not this
**m this||or this||**r or this regex||**n and not this
**m(^^^) this^^^or this^^^or this
@""C# verbatim string""
<>";
		
		public const string c_alsoParameter = @"<i>also<> lambda.
Can be multiline.
Can use global usings and classes/functions from file ""global.cs"".";
	}
	
	/// <summary>
	/// Auto-creates and shows click-closed system-colored tooltip below element e.
	/// </summary>
	public static void InfoTooltip(ref KPopup p, UIElement e, string text, Dock side = Dock.Bottom) {
		if (p == null) {
			p = new(WS.POPUP | WS.BORDER, shadow: true) { Content = new Label(), ClickClose = KPopup.CC.Anywhere };
			p.Border.Background = SystemColors.InfoBrush;
		}
		(p.Content as Label).Content = text;
		p.ShowByRect(e, side);
	}
	
	///// <summary>
	///// Auto-creates and shows tooltip below element e. The tooltip has system colors, not WPF colors.
	///// </summary>
	//public static void InfoTooltip(ref ToolTip tt, UIElement e, string text) {
	//	tt ??= new ToolTip { StaysOpen = false, Placement = PlacementMode.Bottom, Background = SystemColors.InfoBrush, Foreground = SystemColors.InfoTextBrush };
	//	tt.PlacementTarget = e;
	//	tt.Content = text;
	//	tt.IsOpen = false;
	//	tt.IsOpen = true;
	//}
	
	public static void InfoRectCoord(wnd w, string rect) {
		if (!rect.RxMatch(@"^ *\( *(\d+) *, *(\d+) *, *(\d+) *, *(\d+) *\) *", out var m)) return;
		InfoRectCoord(w.ClientRect, new RECT(m[1].Value.ToInt(), m[2].Value.ToInt(), m[3].Value.ToInt(), m[4].Value.ToInt()));
	}
	
	public static void InfoRectCoord(RECT rOuter, RECT rInner) {
		var b = new StringBuilder();
		b.AppendFormat("<><help Au.Types.IFArea>IFArea<> <help Au.Types.Coord>Coord<> values equivalent to RECT ({0}, {1}, {2}, {3}) for window size ({4}, {5}): <fold>\r\n", rInner.left, rInner.top, rInner.Width, rInner.Height, rOuter.Width, rOuter.Height);
		b.AppendFormat("           {0,-8} {1,-8} {2,-8} {3}\r\n", "left", "top", "right", "bottom");
		for (int i = 0; i < 3; i++) {
			b.AppendFormat("{0,-11}", i switch { 0 => "Simple", 1 => "Reverse", _ => "Fraction" });
			for (int j = 0; j < 4; j++) {
				var (e, s1) = j switch { 0 => (rInner.left, "left"), 1 => (rInner.top, "top"), 2 => (rInner.right, "right"), _ => (rInner.bottom, "bottom") };
				int wh = ((j & 1) == 0 ? rOuter.Width : rOuter.Height);
				b.AppendFormat("{0,-9}", i switch { 0 => e.ToS(), 1 => "^" + (wh - e).ToS(), _ => wh == 0 ? "0" : ((double)e / wh).ToS("0.###") + "f" });
			}
			b.AppendLine();
		}
		b.Append("</fold>");
		print.it(b);
	}
	
	#endregion
}


================================================
FILE: Au.Editor/Tools/ToolProcess.cs
================================================
using System.Runtime.Loader;
using System.Windows;

namespace ToolLand;

/// <summary>
/// Tools like "Find UI element" run in a separate Au.Editor.exe process. They are implemented in Au.Controls.dll.
/// The <c>StartX</c> functions are used by the main Au.Editor.exe process to start a tool process.
/// Then <c>Run</c> is called in a tool process.
/// </summary>
static class ToolProcess {
	public static void StartDwnd(wnd w = default, DwndFlags flags = 0) {
		_Start($"Dwnd {w.Handle} {(int)flags}");
	}
	
	public static void StartDelm(POINT? p = null) {
		_Start($"Delm {p?.x} {p?.y}");
	}
	
	public static void StartDuiimage(wnd wCapture = default) {
		_Start($"Duiimage {wCapture.Handle}");
	}
	
	public static void StartDocr() {
		_Start($"Docr");
	}
	
	static void _Start(string commandline) {
		var ps = new ProcessStarter_(process.thisExePath, $"/tool {LA.App.Hmain.Handle} {commandline}", rawExe: true);
		ps.Start();
	}
	
	public static void Run(ReadOnlySpan<string> args) {
		//perf.first();
		
		try {
			var poDir = folders.ThisAppDataLocal + "optimization";
			if (!Directory.Exists(poDir)) Directory.CreateDirectory(poDir);
			AssemblyLoadContext.Default.SetProfileOptimizationRoot(poDir);
			Debug.Assert(args[1][0] == 'D'); //Dwnd etc
			AssemblyLoadContext.Default.StartProfileOptimization(args[1]);
		}
		catch (Exception ex) { Debug_.Print(ex); }
		
		Task task1 = Task.Run(() => { LA.AppSettings.Load(); }); //makes startup faster, although with PO not so much
		
		_ToolProcess(args[1..], (wnd)args[0].ToInt(), task1);
	}
	
	static void _ToolProcess(ReadOnlySpan<string> args, wnd wMain, Task task1) {
		//perf.next();
		process.ThisThreadSetComApartment_(ApartmentState.STA);
		process.thisProcessCultureIsInvariant = true;
		LA.App.InitThisAppFoldersEtc_();
		AssemblyLoadContext.Default.Resolving += (alc, an) => alc.LoadFromAssemblyPath($@"{folders.ThisAppBS}\Roslyn\{an.Name}.dll");
		
		new System.Windows.Window { Content = new System.Windows.Controls.Button() };
		//perf.next();
		task1.Wait();
		//perf.next('t');
		//timer.after(1, _ => { perf.nw(); });
		
		timer.after(1000, _1 => {
			Task.Run(() => { //warm-up compiler
				try { if (!Scripting.Compile("static void M() { print.it(1); }", out _, true, true, true, true)) throw null; }
				catch (Exception ex) { Debug_.Print(ex); }
			});
			
			if (!wMain.Is0) {
				var w = s_wTool.Hwnd();
				timer2.every(200, _ => { //exit when main window closed
					if (!wMain.IsAlive) {
						w.Close(noWait: true);
						if (wait.until(-2, () => !w.IsAlive)) 500.ms();
						Api.ExitProcess(0); //Environment.Exit not always works when main thread is hung
					}
				});
			}
		});
		
		if (args[0] is "Dwnd") {
			s_wTool = new Dwnd((wnd)args[1].ToInt(), (DwndFlags)args[2].ToInt());
			s_wTool.ShowDialog();
		} else if (args[0] is "Delm") {
			s_wTool = new Delm(args.Length > 2 ? new POINT(args[1].ToInt(), args[2].ToInt()) : null);
			s_wTool.ShowDialog();
		} else if (args[0] is "Duiimage") {
			s_wTool = new Duiimage((wnd)args[1].ToInt());
			s_wTool.ShowDialog();
		} else if (args[0] is "Docr") {
			s_wTool = new Docr();
			s_wTool.ShowDialog();
		}
	}
	
	static Window s_wTool;
}


================================================
FILE: Au.Editor/Tools/WindowFindCodeFormatter.cs
================================================
namespace ToolLand;

static partial class TUtil {
	public record WindowFindCodeFormatter {
		public string nameW, classW, programW, containsW, alsoW, waitW, orRunW, andRunW;
		public bool hiddenTooW, cloakedTooW, programNotStringW;
		public string idC, nameC, classC, alsoC, skipC, nameC_comments, classC_comments;
		public bool hiddenTooC;
		public bool NeedWindow = true, NeedControl, Throw, Activate, Test, Finder;
		public string CodeBefore, VarWindow = "w", VarControl = "c";
		
		public string Format() {
			if (!(NeedWindow || NeedControl)) return CodeBefore;
			var b = new StringBuilder(CodeBefore);
			if (CodeBefore != null && !CodeBefore.Ends('\n')) b.AppendLine();
			
			bool orThrow = false, orRun = false, andRun = false, activate = false, needWndFinder = false, needChildFinder = false;
			if (!(Test || Finder)) {
				orThrow = Throw;
				orRun = orRunW != null;
				andRun = andRunW != null;
				activate = Activate;
			}
			if (Finder && !Test) {
				needChildFinder = NeedControl;
				needWndFinder = !needChildFinder;
			}
			
			if (NeedWindow && !needChildFinder) {
				bool orThrowW = orThrow || NeedControl;
				
				if (needWndFinder) {
					b.Append("wndFinder f = new(");
				} else {
					b.Append(Test ? "wnd " : "var ").Append(VarWindow);
					if (Test) b.AppendLine(";").Append(VarWindow);
					
					if (orRun) {
						b.Append(" = wnd.findOrRun(");
					} else if (andRun) {
						b.Append(" = wnd.runAndFind(() => { ").Append(andRunW).Append(" }, ");
						b.AppendWaitTime(waitW, orThrowW);
					} else {
						b.Append(" = wnd.find(");
						if (waitW != null && !Test) b.AppendWaitTime(waitW, orThrowW);
						else if (orThrowW) b.Append('0');
					}
				}
				
				b.AppendStringArg(nameW);
				int m = 0;
				if (classW != null) m |= 1;
				if (programW != null) m |= 2;
				if (m != 0) b.AppendStringArg(classW);
				if (programW != null) {
					if (!(programNotStringW || programW.Starts("WOwner."))) b.AppendStringArg(programW);
					else if (!Test) b.AppendOtherArg(programW);
					else m &= ~2;
				}
				if (FormatFlags(out var s1, (hiddenTooW, WFlags.HiddenToo), (cloakedTooW, WFlags.CloakedToo))) b.AppendOtherArg(s1, m < 2 ? "flags" : null);
				if (alsoW != null) b.AppendOtherArg(alsoW, "also");
				if (containsW != null) b.AppendStringArg(containsW, "contains");
				
				if (orRun) {
					b.Append(", run: () => { ").Append(orRunW).Append(" }");
					if (!orThrowW) b.Append(", wait: -60");
				}
				if (orRun || andRun) {
					if (!activate) b.Append(", activate: !true");
					activate = false;
				}
				b.Append(')');
				if (activate && orThrowW) { b.Append(".Activate()"); activate = false; }
				b.Append(';');
			}
			
			if (NeedControl) {
				if (needChildFinder) {
					b.Append("wndChildFinder cf = new(");
				} else {
					if (NeedWindow) b.AppendLine();
					if (!Test) b.Append("var ").Append(VarControl).Append(" = ");
					b.Append(VarWindow).Append(".Child(");
					if (!Test) {
						if (waitW is not (null or "0") || orRun || andRun) b.Append(orThrow ? "1" : "-1");
						else if (orThrow) b.Append('0');
					}
				}
				if (nameC != null) b.AppendStringArg(nameC);
				if (classC != null) b.AppendStringArg(classC, nameC == null ? "cn" : null);
				if (FormatFlags(out var s1, (hiddenTooC, WCFlags.HiddenToo))) b.AppendOtherArg(s1, nameC == null || classC == null ? "flags" : null);
				if (idC != null) b.AppendOtherArg(idC, "id");
				if (alsoC != null) b.AppendOtherArg(alsoC, "also");
				if (skipC != null) b.AppendOtherArg(skipC, "skip");
				b.Append(");");
				
				if (!Test && nameC == null) { //if no control name, append // classC_comments nameC_comments
					string sn = nameC == null ? nameC_comments : null, sc = classC == null ? classC_comments : null;
					int m = 0; if (!sn.NE()) m |= 1; if (!sc.NE()) m |= 2;
					if (m != 0) {
						b.Append(" // ");
						if (0 != (m & 2)) b.Append(sc.Limit(70));
						if (0 != (m & 1)) {
							if (0 != (m & 2)) b.Append(' ');
							b.AppendStringArg(sn.Limit(100).RxReplace(@"^\*\*\*\w+ (.+)", "$1"), noComma: true);
						}
					}
				}
			}
			
			if (!orThrow && !Test && !Finder) {
				b.Append("\r\nif(").Append(NeedControl ? VarControl : VarWindow).Append(".Is0) { print.it(\"not found\"); }");
				if (activate) b.Append(" else { ").Append(VarWindow).Append(".Activate(); }");
			}
			
			return b.ToString();
		}
		
		/// <summary>
		/// Sets <b>skipC</b> if <i>c</i> is not the first found <i>w</i> child control with <b>nameC</b>/<b>classC</b>/<b>hiddenTooC</b>.
		/// </summary>
		public void SetSkipC(wnd w, wnd c) {
			skipC = GetControlSkip(w, c, nameC, classC, hiddenTooC);
		}
		
		/// <summary>
		/// Fills top-level window fields.
		/// Call once, because does not clear unused fields.
		/// </summary>
		public void RecordWindowFields(wnd w, int waitS, bool activate, string owner = null) {
			NeedWindow = true;
			Throw = true;
			Activate = activate;
			waitW = waitS.ToS();
			string name = w.Name;
			nameW = EscapeWindowName(name, true);
			classW = StripWndClassName(w.ClassName, true);
			if (programNotStringW = owner != null) programW = owner; else if (name.NE()) programW = w.ProgramName;
		}
		
		/// <summary>
		/// Fills control fields.
		/// Call once, because does not clear unused fields.
		/// </summary>
		/// <param name="w">Top-level window.</param>
		/// <param name="c">Control.</param>
		public void RecordControlFields(wnd w, wnd c) {
			NeedControl = true;
			
			string name = null, cn = StripWndClassName(c.ClassName, true);
			if (cn == null) return;
			
			bool _Name(string prefix, string value) {
				if (value.NE()) return false;
				name = prefix + EscapeWildex(value);
				return true;
			}
			
			if (GetUsefulControlId(c, w, out int id)) {
				idC = id.ToS();
				classC_comments = cn;
				_ = _Name(null, c.Name) || _Name(null, c.NameWinforms) || _Name(null, c.NameElm);
				nameC_comments = name;
			} else {
				_ = _Name(null, c.Name) || _Name("***wfName ", c.NameWinforms);
				nameC = name;
				classC = cn;
				
#if true
				SetSkipC(w, c);
				if (name == null && _Name("***elmName ", c.NameElm)) {
					if (skipC == null) nameC = name;
					else nameC_comments = name;
					//SetSkipC(w, c); //can be too slow
				}
#else
				bool setSkip = true;
				if (name == null && _Name("***elmName ", c.NameElm)) {
					nameC = name;
					setSkip = false; //can be too slow
				}
				if (setSkip) SetSkipC(w, c);
#endif
			}
		}
	}
}


================================================
FILE: Au.Editor/Triggers and toolbars/DCommandline.cs
================================================
using System.Windows;
using System.Windows.Controls;
using Au.Controls;

namespace LA;

static class DCommandline {
	static FileNode _CurrentFile() {
		var f = App.Model.CurrentFile;
		if (f != null) {
			if (f.IsExecutableDirectly()) return f;
			dialog.showInfo(null, "This file isn't runnable as a script.", owner: App.Wmain);
		}
		return null;
	}
	
	static string _Quot(string s) {
		var q = s.Contains(' ') ? "\"" : "";
		return $"{q}{s}{q}";
	}
	
	public class Commandline : KDialogWindow {
		public static void ShowForCurrentFile() {
			if (_CurrentFile() is { } f) f.SingleDialog(() => new Commandline(f));
		}
		
		Commandline(FileNode f) {
			InitWinProp("Command line - " + f.Name, App.Wmain);
			var b = new wpfBuilder(this).WinSize(500);
			b.R.xAddInfoBlockT("This tool creates a command line string to run this script from other programs (cmd, PowerShell etc). More info in Cookbook folder \"Script\".");
			b.R.Add(out KCheckBox cEditorNoPath, "Editor program name without path").Tooltip("Makes the string shorter. Not all programs support it.");
			b.R.Add(out KCheckBox cWait, "Wait until script ends").Tooltip("Unchecked:  start the script and return its process id.\nChecked: run the script and return its exit code. The caller can get script.writeResult text.");
			b.R.Add("Script arguments", out TextBox tArgs).Tooltip("Optional");
			b.R.AddSeparator();
			b.R.StartStack();
			b.AddButton("Copy to clipboard", _ => {
				var sb = new StringBuilder();
				sb.Append(_Quot(cEditorNoPath.IsChecked ? process.thisExeName : process.thisExePath)).Append(' ');
				sb.Append(_Quot((cWait.IsChecked ? "*" : "") + f.ItemPathOrName()));
				if (tArgs.Text.NullIfEmpty_() is { } sa) sb.Append(' ').Append(sa);
				
				clipboard.text = sb.ToString();
			});
			b.AddOkCancel(null, "Close");
			b.End();
			b.End();
		}
	}
	
	public class Shortcut : KDialogWindow {
		public static void ShowForCurrentFile() {
			if (_CurrentFile() is { } f) f.SingleDialog(() => new Shortcut(f));
		}
		
		Shortcut(FileNode f) {
			InitWinProp("Shortcut - " + f.Name, App.Wmain);
			var b = new wpfBuilder(this).WinSize(500);
			b.R.xAddInfoBlockT("This tool creates a shortcut (.lnk file) to run this script.");
			b.R.Add("Script arguments", out TextBox tArgs).Tooltip("Optional");
			b.R.AddSeparator();
			b.R.StartStack();
			b.AddButton("Create shortcut...", _ => {
				if (App.IsPortable && 1 != dialog.showWarning("Portable mode warning", "This will create a shortcut file. Portable apps should not create files on host computer.\r\n\r\nDo you want to continue?", "1 Yes|2 No", owner: this)) return;
				var d = new FileOpenSaveDialog("38939d61-1971-45f5-8ce5-0c405aab792c") {
					FileNameText = App.Model.CurrentFile.DisplayName + ".lnk",
					FileTypes = "Shortcut|*.lnk",
					InitFolderFirstTime = folders.Desktop,
					Title = "Create shortcut"
				};
				if (!d.ShowSave(out var lnk, this)) return;
				var s = _Quot(f.ItemPathOrName());
				if (tArgs.Text.NullIfEmpty_() is { } sa) s = s + " " + sa;
				try {
					using var sh = shortcutFile.create(lnk);
					sh.TargetPath = process.thisExePath;
					sh.Arguments = s;
					sh.Save();
					Close();
				}
				catch (Exception e1) { dialog.showError("Failed", e1.ToStringWithoutStack(), owner: this); }
			});
			b.AddOkCancel(null);
			b.End();
			b.End();
		}
	}
	
	public class ShellMenu : KDialogWindow {
		public static void ShowForCurrentFile() {
			if (_CurrentFile() is { } f) f.SingleDialog(() => new ShellMenu(f));
		}
		
		[Flags] enum _Type { file = 1, directory = 2, drive = 4, back = 8, desktop = 16, taskbar = 32 }
		
		const string infoUrl = "https://www.libreautomate.com/forum/showthread.php?tid=7819";
		
		ShellMenu(FileNode f) {
			InitWinProp("Shell menu - " + f.Name, App.Wmain);
			var b = new wpfBuilder(this).WinSize(550);
			b.Options(bindLabelVisibility: true);
			b.R.xAddInfoBlockF($"""
This tool creates <a href='{infoUrl}'>Nilesoft Shell</a> code for adding a menu item to run this script (or submenu etc). Paste in a nss file. To apply: Ctrl+right-click in a folder window or desktop.
""");
			
			b.R.xAddGroupSeparator("Menu item properties");
			b.R.Add("Title", out KTextBox tTitle, f.DisplayName);
			b.R.Add("Image", out KTextBox tImage).Tooltip(@"A font icon, like \uE025 or image.glyph(\uE025, #00e000)
Or path of a file with icons, like c:\dir\file.ico, c:\dir\file.exe, c:\dir\file.dll,3
Or color, like #c0ff80");
			//b.And(26).xAddButtonIcon("*Material.HelpCircleOutline #79AEFF" + EdIcons.blue, _ => _ImageButton(), "Image reference");
			b.And(26).xAddControlHelpButton(_ => _ImageButton(), "Image reference");
			b.R.Add("Tooltip", out KTextBox tTip).Multiline();
			b.R.Add<Label>("Separator"); b.StartStack().Add(out KCheckBox cSepBefore, "before").Add(out KCheckBox cSepAfter, "after").End();
			//b.R.Add(out KCheckBox cMenu, "Add to an existing submenu"); //rejected. Rarely used. Also would need pos.
			
			b.R.xAddGroupSeparator("Show if");
			b.R.Add("Selection", out ComboBox cbMode).Items(
				"default setting (inherit from parent menu, or single)",
				"single (selected single item)",
				"multiple (selected one or more items)",
				"multi_unique (selected one or more items of the same object type)",
				"multi_single (selected one or more items of the same file type)",
				"none (no selection)");
			
			b.R.Add<Label>("Object type").StartPanel(new WrapPanel()).Margin("T3B3");
			var ty = new EnumUI<_Type>(b.Panel, _Type.file);
			b.End();
			
			b.R.Add("File types", out KTextBox tFileTypes).Tooltip("Examples:\n.exe\n.png|.jpg|.ico\n!.exe (not .exe)");
			b.R.Add(out KCheckBox cShift, "+Shift");
			
			b.R.xAddGroupSeparator("Action");
			b.R.Add("Action", out ComboBox cbAction).Items("Run this script|Run program|Expression|Submenu");
			b.R.Add("Program", out KTextBox tProgram).Hidden(null);
			b.R.Add("Expression", out KTextBox tExpression).Hidden(null);
			b.R.Add("Arguments", out KTextBox tArgs, "@sel(true)")
				.Tooltip("@sel(true) means \"paths of selected files\".\nYou can add more arguments before or after.");
			b.And(26).xAddButtonIcon(out var bArgs, "*Modern.LanguageCsharp" + EdIcons.blue, _ => _ArgsButton(), "Copy C# code");
			cbAction.SelectionChanged += (_, _) => {
				int i = cbAction.SelectedIndex;
				tProgram.Visibility = i == 1 ? Visibility.Visible : Visibility.Collapsed;
				tExpression.Visibility = i == 2 ? Visibility.Visible : Visibility.Collapsed;
				tArgs.Visibility = bArgs.Visibility = i < 2 ? Visibility.Visible : Visibility.Collapsed;
			};
			
			b.R.AddSeparator().Margin("T8");
			b.R.StartGrid().Columns(130, 0, -1, 100, 100);
			b.AddButton("Copy to clipboard", _1 => {
				static string _SA(string prop, string s) => s.NE() ? null : _SA2(prop, s);
				static string _SA2(string prop, string s) => $"{prop}='{s?.Replace("'", "@\"'\"")}'";
				static string _SQ(string prop, string s) => s.NE() ? null : $"{prop}=\"{s.Escape()}\"";
				
				var sImage = tImage.Text;
				if (!sImage.NE()) {
					if (pathname.isFullPath(sImage, orEnvVar: true) || sImage.RxIsMatch(@"\.\w{3}(?:, *-?\d+)?$")) {
						sImage = _SA("image", sImage);
					} else {
						if (sImage.RxMatch(@"(?i)^(\\u)?([[:xdigit:]]{4})$", out var m)) {
							string u = m[1].Value ?? "\\u", h = m[2].Value;
							if (h[1] is >= '7') sImage = $"image.segoe({u}{h}, 14)"; //Windows icon font. DPI problems. 14 best, but not perfect. `image.glyph` bad.
							else sImage = u + h; //NS embedded glyphs
						}
						sImage = $"image={sImage}";
					}
				}
				var sCommon = $"""
({_SA2("title", tTitle.Text)}
	{sImage}
	{_SQ("tip", tTip.Text)}
	{_SA("sep", (cSepBefore.IsChecked, cSepAfter.IsChecked) switch { (true, false) => "before", (false, true) => "after", (true, true) => "both", _ => null })}
	{(cbMode.SelectedIndex == 0 ? "" : _SA("mode", (cbMode.SelectedItem as string).Split(' ', 2)[0]))}
	{(ty.Result == 0 ? "" : _SA("type", ty.Result.ToString().Replace(", ", "|")))}
	{_SA("find", tFileTypes.Text)}
	{(cShift.IsChecked ? "vis=key.shift()" : "")}
""".RxReplace(@"(?m)(\R\t)+$", "");
				string s;
				int i = cbAction.SelectedIndex;
				if (i == 3) { //submenu
					s = $$"""
menu{{sCommon}})
{

}

""";
				} else {
					var sca = i switch {
						0 => $"cmd='{process.thisExeName}' {_SA("args", $"\"{f.ItemPathOrName()}\" {tArgs.Text}")}",
						1 => $"{_SA2("cmd", tProgram.Text)} {_SA2("args", tArgs.Text)}",
						_ => $"cmd={tExpression.Text}"
					};
					s = $"""
item{sCommon}
	{sca})

""";
					//rejected: add UI for other command parameters: invoke, window, dir, admin, verb, wait.
				}
				clipboard.text = s;
			});
			b.AddOkCancel(null, "Close");
			b.Skip().AddButton("Open nss file", _ => _OpenNSS());
			b.AddButton("On error ▾", _ => _OnErrorButton());
			b.End();
			b.End();
			
			void _ImageButton() {
				var m = new popupMenu();
				m["Glyph icons"] = o => { run.it("https://nilesoft.org/gallery/glyphs"); };
				m["Win11 font icons (Fluent)"] = o => { run.it("https://learn.microsoft.com/en-us/windows/apps/design/style/segoe-fluent-icons-font"); };
				m["Win10 font icons (MDL2)"] = o => { run.it("https://learn.microsoft.com/en-us/windows/apps/design/style/segoe-ui-symbol-font"); };
				m.Separator();
				m["Image function"] = o => { run.it("https://nilesoft.org/docs/functions/image"); };
				m["Image property"] = o => { run.it("https://nilesoft.org/docs/configuration/properties#image"); };
				m.Show(owner: this);
			}
			
			void _ArgsButton() {
				var m = new popupMenu();
				m["Copy C# code \"foreach selected path\""] = o => { clipboard.text = """
foreach (string path in args) {
	print.it(path);
}

"""; };
				m["Copy C# code \"foreach selected path\" when there are more arguments"] = o => { clipboard.text = """
foreach (string path in args.Skip(1)) {
	print.it(path);
}

"""; };
				m.Show(owner: this);
			}
			
			void _OnErrorButton() {
				var m = new popupMenu();
				m["Print last error"] = o => { if (_GetNsDir(out var nsDir)) try { print.it(File.ReadLines(nsDir + @"\shell.log").Where(o => o.Contains("[error]")).Last()); } catch { } };
				m["Restart Explorer"] = o => { if (_GetNsDir(out var nsDir)) run.itSafe(nsDir + @"\shell.exe", "-restart"); };
				m.Show(owner: this);
			}
			
			void _OpenNSS() {
				if (!_GetNsDir(out var nsDir)) return;
				var nssFile = nsDir + @"\shell.nss";
				try {
					var text = filesystem.loadText(nssFile);
					if (text.RxFindAll(@"(?m)^\h*import +'(?!imports[/\\])(.+?)'", 1, out string[] a)) {
						nssFile = a[0];
						if (a.Length > 1) {
							int i = dialog.showList(a.Select(o => pathname.getName(o)).ToArray(), owner: this) - 1;
							if (i < 0) return;
							nssFile = a[i];
						}
					} else {
						if (1 != dialog.show("Your nss file still not imported into shell.nss", "Open shell.nss?", buttons: "1 OK|0 Cancel", footer: new($"<a>Setup info</a>", _NssLink), owner: this)) return;
					}
					if (!App.Model.OpenAndGoTo(nssFile, kind: FNFind.File)) run.itSafe(nssFile);
				}
				catch { }
			}
			
			bool _GetNsDir(out string r) {
				r = App.Settings.nilesoftShellDir;
				if (!filesystem.exists(r).Directory) {
					r = folders.ProgramFiles + "Nilesoft Shell";
					while (!filesystem.exists(r).Directory) {
						if (!dialog.showInput(out r, "Where is Nilesoft Shell installed?", $"Nilesoft Shell folder path", footer: new($"<a>Setup info</a>", _NssLink), owner: this)) return false;
						App.Settings.nilesoftShellDir = r;
					}
				}
				return true;
			}
			
			static void _NssLink(DEventArgs _) {
				run.itSafe(infoUrl);
			}
		}
	}
}


================================================
FILE: Au.Editor/Triggers and toolbars/DSchedule.cs
================================================
using Au.Controls;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Controls.Primitives;
using System.Xml;
using System.Xml.Linq;

namespace LA;

using api = WinSchedulerApi;
using TT = WinSchedulerApi.TASK_TRIGGER_TYPE2;
using TTS = WinSchedulerApi.TASK_SESSION_STATE_CHANGE_TYPE;

class DSchedule : KDialogWindow {
	public static void ShowFor(FileNode f, int triggerIndex1Based = 0) {
		if (f == null) return;
#if TEST
		var d = new DSchedule(f, triggerIndex1Based);
		d.ShowDialog();
		//d.ShowAndWait();
		//d.Show();
		//dialog.show("DSchedule");
#else
		if (!f.IsExecutableDirectly()) {
			dialog.showInfo(null, "This file isn't runnable as a script.", owner: App.Wmain);
			return;
		}
		f.SingleDialog(() => new DSchedule(f, triggerIndex1Based) { Owner = App.Wmain, ShowInTaskbar = false });
#endif
	}
	
	FileNode _f;
	wpfBuilder _b;
	ListBox _lbPages;
	Grid _gPages;
	event Action<WBButtonClickArgs> _apply;
	
	api.ITaskDefinition _td;
	string _taskName;
	
	static readonly string s_taskFolder = @"\Au\" + Environment.UserName;
	
	DSchedule(FileNode f, int selectTrigger) {
		_f = f;
		
		Title = "Schedule - " + _f.Name;
		
		var b = _b = new wpfBuilder(this).WinSize(700, 420).Columns(-1.2, 8, -2);
		b.Options(bindLabelVisibility: true);
		
		//left column
		
		Button bDeleteTrigger = null;
		
		b.Row(-1).StartGrid().Columns(-1);
		
		b.Row(-1).Add(out _lbPages);
		ScrollViewer.SetHorizontalScrollBarVisibility(_lbPages, ScrollBarVisibility.Disabled); //to wrap item text
		
		b.StartGrid().Columns(-1, -1);
		b.AddButton("New trigger", _ => _NewTrigger(true));
		b.AddButton(out bDeleteTrigger, "Delete trigger", _ => _DeleteTrigger()).Disabled();
		b.End();
		b.R.Add(out KCheckBox cTaskEnabled, "Task enabled").Margin("T10B10");
		
		b.End();
		
		//right column
		
		b.Skip(1).Add(out _gPages).Margin("0");
		
		b.R.AddSeparator().Span(-1);
		
		b.StartGrid().Columns(-1, 0);
		b.R.xAddInfoBlockT(out var tExistsInfo, "OK/Apply will create a new scheduled task.");
		b.StartOkCancel();
		b.AddOkCancel(out var bOK, out _, out _, apply: "Apply");
		b.AddButton("Task Scheduler ▾", _ => {
			var m = new popupMenu();
			m["OK, open task in Task Scheduler"] = o => {
				bOK.RaiseEvent(new RoutedEventArgs(Button.ClickEvent));
				if (!IsVisible) _EditTask(); //may be not closed if validation error
			};
			bool disabled = !_TaskExists();
			m["Cancel, open task in Task Scheduler", disable: disabled] = o => { Close(); _EditTask(); };
			m.Submenu("Delete task", m => {
				m["Delete the task and close this window"] = o => {
					WinScheduler.DeleteTask(s_taskFolder, _taskName);
					Close();
				};
			}, disable: disabled);
			m["Open Task Scheduler"] = o => { _EditTask(true); };
			m.Show(owner: this);
			
			void _EditTask(bool justOpenFolder = false) {
				WinScheduler.EditTask(s_taskFolder, justOpenFolder ? null : _taskName);
			}
			
			bool _TaskExists() => WinScheduler.TaskExists(s_taskFolder, _taskName);
		});
		b.End();
		b.End();
		b.End();
		
		b.OkApply += o => {
			//print.clear();
			
			_td.Settings.Enabled = cTaskEnabled.IsChecked;
			_apply(o);
			
			//update trigger strings in listbox
			var tc = _td.Triggers;
			for (int i = 1; i < _lbPages.Items.Count - 2; i++) {
				if (0 == tc.get_Item(i, out var v)) {
					var li = _lbPages.Items[i] as ListBoxItem;
					li.Content = _CreatePageListItemContent(v.FormatTriggerString(), true);
				}
			}
			
			//print.it(_td.XmlText); print.scrollToTop();
			
			int hr = WinScheduler.CreateTaskFromDefinition(s_taskFolder, _taskName, _td, UacIL.High, api.TASK_CREATION.TASK_CREATE_OR_UPDATE);
			if (hr != 0) {
				string s = lastError.messageFor(hr);
				if (hr == Api.E_ACCESSDENIED && !uacInfo.isAdmin) s += "\n\nRestart this program as administrator.";
				dialog.showError("Failed to register scheduled task", s, owner: this);
				o.Cancel = true;
			} else {
				tExistsInfo.Hide_(true);
			}
		};
		
		bool exists = WinScheduler.FindScriptTask(_f.Name, _f.ItemPath, out var r);
		if (exists) {
			_taskName = r.rt.Name;
			_td = r.td;
		} else {
			_taskName = _f.Name[..^3];
			if (!WinScheduler.Connect(out var ts)) throw new AuException("*get task service");
			
			var sArgs = "*" + _f.ItemPathOrName();
			if (0 != ts.NewTask(0, out _td)) throw new AuException("*create task definition");
			_td.XmlText = WinScheduler.CreateXmlForNewTask(UacIL.High, WinScheduler.EditorPath, sArgs);
			
			_NewTrigger(false);
		}
		tExistsInfo.Hide_(exists);
		//print.it(_td.XmlText);
		
		cTaskEnabled.IsChecked = _td.Settings.Enabled;
		
		_AddPage("Triggers", null);
		_AddPage("Conditions", _ConditionsPage());
		_AddPage("Settings", _SettingsPage(r.scriptArgs));
		
		foreach (var t in _td.EnumTriggers()) {
			_CreateTriggerPage(t, false);
		}
		
		_lbPages.SelectionChanged += (_, e) => {
			int i = _lbPages.SelectedIndex, n = _lbPages.Items.Count;
			if (i == 0) {
				_lbPages.SelectedIndex = n > 3 ? 1 : -1;
			} else {
				if (e.RemovedItems is [ListBoxItem { Tag: UIElement p1 }]) p1.Visibility = Visibility.Hidden;
				if (e.AddedItems is [ListBoxItem { Tag: UIElement p2 }]) p2.Visibility = Visibility.Visible;
				bDeleteTrigger.IsEnabled = i < n - 2;
			}
		};
		
#if TEST
		//_lbPages.SelectedIndex = _lbPages.Items.Count - 2;
		_lbPages.SelectedIndex = 1;
#else
		int nTriggers = _lbPages.Items.Count - 3;
		if (selectTrigger > 0 && selectTrigger <= nTriggers) _lbPages.SelectedIndex = selectTrigger;
		else if (nTriggers > 0) _lbPages.SelectedIndex = 1;
#endif
		
#if WPF_PREVIEW
		b.Window.Preview();
#endif
	}
	
	void _AddPage(string name, _Page page) {
		var li = new ListBoxItem { Content = _CreatePageListItemContent(name, page is _TriggerPage), Tag = page };
		_lbPages.Items.Insert(_lbPages.Items.Count - (page is _TriggerPage ? 2 : 0), li);
		if (page != null) {
			page.li = li;
			page.Visibility = Visibility.Collapsed;
			_gPages.Children.Add(page);
		}
	}
	
	object _CreatePageListItemContent(string text, bool isTrigger) {
		if (!isTrigger) return text;
		var r = new DockPanel();
		var img = ImageUtil.LoadWpfImageElement("*Codicons.SymbolEvent #4066FF @14");
		img.VerticalAlignment = VerticalAlignment.Top;
		img.Margin = new(-3, 0, 0, 2);
		r.Children.Add(img);
		var t = new TextBlock { Text = text, TextWrapping = TextWrapping.Wrap };
		r.Children.Add(t);
		return r;
	}
	
	class _Page : UserControl {
		public ListBoxItem li;
		
		public int Index => ((ListBox)li.Parent).Items.IndexOf(li);
	}
	
	_Page _ConditionsPage() {
		var sett = _td.Settings;
		
		_Page uc = new();
		var b = new wpfBuilder(uc);
		b.Options(bindLabelVisibility: true);
		
		//print.it(sett.);
		
		b.R.xAddGroupSeparator("Idle");
		
		_TimeIntervalControls kIdle = new(this, b, "Start only if the computer is idle for:", "1 m|10 m|1 h", 1, ("PT1M", "P31D"));
		_TimeIntervalControls kIdleWait = new(this, b, "Wait for idle for", "0 s|1 m|10 m|1 h", 3, cOther: kIdle.c);
		b.Tooltip("Max time interval to wait for the above condition");
		b.Last2.HorizontalAlignment = HorizontalAlignment.Right;
		b.R.Add(out KCheckBox cIdleStop, "Stop if the computer ceases to be idle").Margin(20).xBindCheckedEnabled(kIdle.c)
			.Tooltip("Note: triggers of type \"Computer idle\" may stop the task even if this isn't checked.");
		b.R.Add(out KCheckBox cIdleRestart, "Restart when idle again").Margin(40).xBindCheckedEnabled(kIdle.c);
		if (sett.RunOnlyIfIdle) {
			var idle = sett.IdleSettings;
			kIdle.Value = idle.IdleDuration;
			kIdleWait.Value0 = idle.WaitTimeout;
			cIdleStop.IsChecked = idle.StopOnIdleEnd;
			cIdleRestart.IsChecked = idle.RestartOnIdle;
		}
		
		b.R.xAddGroupSeparator("Power");
		
		b.R.Add(out KCheckBox cDisallowStartIfOnBatteries, "Start only if the computer is on AC power").Checked(sett.DisallowStartIfOnBatteries);
		b.R.Add(out KCheckBox cStopIfGoingOnBatteries, "Stop if the computer switches to battery power").Margin(20).Checked(sett.StopIfGoingOnBatteries).xBindCheckedEnabled(cDisallowStartIfOnBatteries);
		b.R.Add(out KCheckBox cWakeToRun, "Wake the computer to run this task").Checked(sett.WakeToRun);
		
		b.R.xAddGroupSeparator("Network");
		
		b.R.Add(out KCheckBox cNetwork, "Required network connection:").Checked(sett.RunOnlyIfNetworkAvailable);
		b.Add(out TextBox tNetwork).xBindCheckedEnabled(cNetwork, true);
		if (sett.RunOnlyIfNetworkAvailable && sett.NetworkSettings is { } ns) tNetwork.Text = ns.Name;
		
		b.End();
		
		_apply += o => {
			try {
				if (sett.RunOnlyIfIdle = kIdle.c.IsChecked) {
					var idle = sett.IdleSettings;
					idle.IdleDuration = kIdle.Value;
					idle.WaitTimeout = kIdleWait.Value;
					idle.StopOnIdleEnd = cIdleStop.IsChecked;
					idle.RestartOnIdle = cIdleRestart.IsChecked;
				}
				sett.DisallowStartIfOnBatteries = cDisallowStartIfOnBatteries.IsChecked;
				sett.StopIfGoingOnBatteries = cStopIfGoingOnBatteries.IsChecked;
				sett.WakeToRun = cWakeToRun.IsChecked;
				if (sett.RunOnlyIfNetworkAvailable = cNetwork.IsChecked) sett.NetworkSettings.Name = tNetwork.TextOrNull();
			}
			catch (Exception ex) { dialog.showError("Failed to apply Conditions", ex.ToString()); } //unlikely (all validated)
		};
		
		return uc;
	}
	
	_Page _SettingsPage(string scriptArgs) {
		var sett = _td.Settings;
		
		_Page uc = new();
		var b = new wpfBuilder(uc);
		b.Options(bindLabelVisibility: true);
		
		b.R.Add(out KCheckBox cRunAfterMissed, "Run task later if a scheduled start is missed").Checked(sett.StartWhenAvailable);
		
		_TimeIntervalControls kRetry = new(this, b, "If can't start the task, retry every:", "1 m|10 m|1 h", 0, ("PT1M", "P31D"));
		kRetry.c.ToolTip = "When Task Scheduler can't start the task when it should. This does not include failures in LibreAutomate or script, such as \"LibreAutomate can't find or start the script\" or \"the script process crashed or returned not 0\".";
		var v1 = (n: sett.RestartCount, t: sett.RestartInterval);
		bool restart = v1.n > 0 && v1.t != null;
		if (restart) kRetry.Value = v1.t;
		
		b.R.Add("Max times", out TextBox tFailedRetryTimes, restart ? v1.n : 3).xBindCheckedEnabled(kRetry.c)
			.Validation(o => _ValidateNumber(o, 1, 999), _ValidationLinkClick);
		b.Last2.HorizontalAlignment = HorizontalAlignment.Right;
		
		_TimeIntervalControls kStop = new(this, b, "Stop the task if it runs longer than:", "30 s|5 m|1 h|3 d", 3) { Value = sett.ExecutionTimeLimit };
		_TimeIntervalControls kDelete = new(this, b, "Delete expired task after:", "0 s|30 d|365 d", 1, checkboxValidation: _ValidationForDeleteExpired) { Value0 = sett.DeleteExpiredTaskAfter };
		
		b.StartDock()
			.Add("If the task is already running", out ComboBox cbIfRunning)
			.Items("Start a new instance|Queue a new instance|Don't start a new instance|Stop the existing instance")
			.Select(Math.Clamp((int)sett.MultipleInstances, 0, 3))
			.End();
		
		b.R.AddSeparator().Margin("T8B8");
		b.R.StartDock().Add("Script arguments", out TextBox tArgs, scriptArgs)
			.Tooltip("Optional string to pass to the script process in command line. The script receives parsed arguments in the args variable.")
			.End();
		
		b.R.AddSeparator().Margin("T8");
		b.Row(-1).xAddInfoBlockT("""
This tool creates or updates a Windows Task Scheduler task that starts LibreAutomate with a command to run this script. You can edit the task here or in Task Scheduler. All info about Task Scheduler is on the internet.

To run a script without LibreAutomate, instead create .exe program from the script, and in Task Scheduler create a task to run it.
""", scrollViewer: true);
		
		b.End();
		
		_apply += o => {
			try {
				sett.StartWhenAvailable = cRunAfterMissed.IsChecked;
				sett.RestartInterval = kRetry.Value;
				sett.RestartCount = kRetry.c.IsChecked ? tFailedRetryTimes.Text.ToInt() : 0;
				sett.ExecutionTimeLimit = kStop.Value ?? "PT0S"; //if null, will be the default 3 days
				sett.DeleteExpiredTaskAfter = kDelete.Value;
				sett.MultipleInstances = cbIfRunning.SelectedIndex;
				
				var x = _td.Actions.GetExecAction(1);
				var s = $"\">{_f.ItemPathOrName()}\"";
				if (tArgs.TextOrNull() is { } sa) s = s + " " + sa;
				x.Arguments = s;
			}
			catch (Exception ex) { dialog.showError("Failed to apply Settings", ex.ToString()); } //unlikely (all validated)
		};
		
		return uc;
		
		string _ValidationForDeleteExpired(FrameworkElement e) {
			if (!((KCheckBox)e).IsChecked) return null;
			if (_lbPages.Items.OfType<ListBoxItem>().Any(o => o.Tag is _TriggerPage { cExpire: { IsChecked: true } })) return null;
			return "Please also check Expire for a trigger";
		}
	}
	
	const TT c_unsupportedTT = (TT)(-1);
	readonly TT[] _ttMap = [TT.TIME, TT.DAILY, TT.WEEKLY, TT.MONTHLY, TT.MONTHLYDOW, TT.LOGON, TT.SESSION, TT.EVENT, TT.IDLE, TT.REGISTRATION, c_unsupportedTT];
	
	void _CreateTriggerPage(api.ITrigger t, bool select) {
		_TriggerPage page = new() { trigger = t };
		var b = new wpfBuilder(page).Columns(60, -1);
		b.Options(bindLabelVisibility: true);
		
		b.R.Add("Schedule", out ComboBox cbTriggerType).Span(1)
			.Items("Once|Daily|Weekly|Month days|Month week days|Log on|User session event|Event log|Computer idle|This task created or modified").Select(-1);
		
		var tt = t.Type;
		if (!_ttMap.Contains(tt) || tt == c_unsupportedTT) {
			tt = c_unsupportedTT;
			cbTriggerType.Items.Add("<unsupported trigger type>");
		}
		
		var dtf = CultureInfo.InvariantCulture.DateTimeFormat;
		var aWeekDayNames = dtf.DayNames;
		var aMonthNames = dtf.MonthNames.Take(12).ToArray();
		string defaultUserId = $@"{Environment.MachineName}\{Environment.UserName}";
		_TimeIntervalControls kDelay = null;
		
		var ap = new (Panel panel, Action<WBButtonClickArgs> apply)[11];
		var ab = new Action<int>[11] { _Once, _Daily, _Weekly, _Month, _MonthDOW, _Logon, _Session, _Eventlog, _Idle, _Registration, _Unsupported };
		
		wpfBuilder _BuilderProlog(int iType, params WBGridLength[] widths) {
			var b = new wpfBuilder();
			b.Options(bindLabelVisibility: true);
			if (widths.Length > 0) b.Columns(widths); else b.Columns(60, -1);
			ap[iType].panel = b.Panel;
			return b;
		}
		
		T _ApplyProlog<T>(TT type) where T : class {
			if (tt != type) {
				//There is no API "replace trigger type" or "replace trigger at" or "insert trigger at".
				//	To change trigger type, need to remove the trigger and add new trigger.
				//	But it adds to the end. Workaround: remove/add the listbox item too. Nevermind, it's rare.
				
				var old = t;
				page.trigger = t = _td.Triggers.Create(tt = type);
				t.Id = old.Id;
				
				int i = page.Index;
				_td.Triggers.Remove(i);
				
				if (i < _td.Triggers.Count) {
					bool select = page.li == _lbPages.SelectedItem;
					_lbPages.Items.Remove(page.li);
					_lbPages.Items.Insert(_lbPages.Items.Count - 2, page.li);
					if (select) {
						_lbPages.SelectedItem = page.li;
						_lbPages.ScrollIntoView(page.li);
					}
				}
			}
			return t as T;
		}
		
		//- trigger types
		b.Row((0, 100..)).StartGrid().Columns(60, -1, 0);
		
		_DateTimeControls dtStart = new(this, b, 1, "Start") { Value = _IsDateTrigger() ? t.StartBoundary : null };
		
		b.R.Add(out ContentControl cc).Margin("0");
		
		void _Once(int iType) {
			if (tt == TT.TIME && t is api.ITimeTrigger m) {
				kDelay.Value = m.RandomDelay;
			}
			
			ap[iType].apply = o => {
				var m = _ApplyProlog<api.ITimeTrigger>(TT.TIME);
				m.RandomDelay = kDelay.Value;
			};
		}
		
		void _Daily(int iType) {
			var b = _BuilderProlog(iType, 60, 50, -1);
			b.R.Add("Every", out TextBox tEvery, "1")
				.Validation(o => _ValidateNumber(tEvery, 1, 365), _ValidationLinkClick)
				.Add<Label>("days");
			b.End();
			if (tt == TT.DAILY && t is api.IDailyTrigger m) {
				tEvery.Text = m.DaysInterval.ToString();
				kDelay.Value = m.RandomDelay;
			}
			
			ap[iType].apply = o => {
				var m = _ApplyProlog<api.IDailyTrigger>(TT.DAILY);
				m.DaysInterval = (short)tEvery.Text.ToInt();
				m.RandomDelay = kDelay.Value;
			};
		}
		
		void _Weekly(int iType) {
			var b = _BuilderProlog(iType, 60, 50, -1);
			b.R.Add("Every", out TextBox tEvery, "1")
				.Validation(o => _ValidateNumber(tEvery, 1, 99), _ValidationLinkClick)
				.Add<Label>("weeks");
			var cdWeeks = new KCheckDropdownBox { Checkboxes = aWeekDayNames, TextWrapping = TextWrapping.Wrap };
			b.R.Add("On", cdWeeks)
				.Validation(_ValidateBits, _ValidationLinkClick);
			if (tt == TT.WEEKLY) {
				var m = (api.IWeeklyTrigger)t;
				tEvery.Text = m.WeeksInterval.ToString();
				cdWeeks.Checked = m.DaysOfWeek;
				kDelay.Value = m.RandomDelay;
			}
			b.End();
			
			ap[iType].apply = o => {
				var m = _ApplyProlog<api.IWeeklyTrigger>(TT.WEEKLY);
				m.WeeksInterval = (short)tEvery.Text.ToInt();
				m.DaysOfWeek = (ushort)cdWeeks.Checked;
				m.RandomDelay = kDelay.Value;
			};
		}
		
		void _Month(int iType) {
			var b = _BuilderProlog(iType);
			var cdMonths = new KCheckDropdownBox { Checkboxes = aMonthNames, AllItem = "All months", AllText = "All months", TextWrapping = TextWrapping.Wrap };
			b.R.Add("Months", cdMonths)
				.Validation(_ValidateBits, _ValidationLinkClick);
			var cdDays = new KCheckDropdownBox { DropdownSettings = () => new(new UniformGrid()), Checkboxes = Enumerable.Range(1, 31).Cast<object>().Append("Last").ToArray(), TextWrapping = TextWrapping.Wrap };
			b.R.Add("Days", cdDays)
				.Validation(_ValidateBits, _ValidationLinkClick);
			if (tt == TT.MONTHLY) {
				var m = (api.IMonthlyTrigger)t;
				cdMonths.Checked = m.MonthsOfYear;
				cdDays.Checked = m.DaysOfMonth | (m.RunOnLastDayOfMonth ? 1u << 31 : 0);
				kDelay.Value = m.RandomDelay;
			}
			b.End();
			
			ap[iType].apply = o => {
				var m = _ApplyProlog<api.IMonthlyTrigger>(TT.MONTHLY);
				m.MonthsOfYear = (ushort)cdMonths.Checked;
				m.DaysOfMonth = (uint)(cdDays.Checked & 0x7fff_ffff);
				m.RunOnLastDayOfMonth = 0 != (cdDays.Checked & 0x8000_0000);
				m.RandomDelay = kDelay.Value;
			};
		}
		
		void _MonthDOW(int iType) {
			var b = _BuilderProlog(iType, 60, 100, -1);
			var cdMonths = new KCheckDropdownBox { Checkboxes = aMonthNames, AllItem = "All months", AllText = "All months", TextWrapping = TextWrapping.Wrap };
			b.R.Add("Months", cdMonths)
				.Validation(_ValidateBits, _ValidationLinkClick);
			var cdWeeks = new KCheckDropdownBox { Checkboxes = ["first", "second", "third", "fourth", "last"], AllText = "every", TextWrapping = TextWrapping.Wrap };
			b.R.Add("On", cdWeeks)
				.Validation(_ValidateBits, _ValidationLinkClick);
			var dDays = new KCheckDropdownBox { Checkboxes = aWeekDayNames, AllItem = "All week days", AllText = "{0} (all days)", TextWrapping = TextWrapping.Wrap };
			b.Add(dDays)
				.Validation(_ValidateBits, _ValidationLinkClick);
			if (tt == TT.MONTHLYDOW) {
				var m = (api.IMonthlyDOWTrigger)t;
				cdMonths.Checked = m.MonthsOfYear;
				cdWeeks.Checked = m.WeeksOfMonth | (m.RunOnLastWeekOfMonth ? 1u << 4 : 0);
				dDays.Checked = m.DaysOfWeek;
				kDelay.Value = m.RandomDelay;
			}
			b.End();
			
			ap[iType].apply = o => {
				var m = _ApplyProlog<api.IMonthlyDOWTrigger>(TT.MONTHLYDOW);
				m.MonthsOfYear = (ushort)cdMonths.Checked;
				m.WeeksOfMonth = (ushort)(cdWeeks.Checked & 0xf);
				m.RunOnLastWeekOfMonth = 0 != (cdWeeks.Checked & 0x10);
				m.DaysOfWeek = (ushort)dDays.Checked;
				m.RandomDelay = kDelay.Value;
			};
		}
		
		void _Logon(int iType) {
			var b = _BuilderProlog(iType);
			b.R.Add("User", out ComboBox cbUser).Editable();
			string user = null;
			if (tt == TT.LOGON) {
				var m = (api.ILogonTrigger)t;
				user = m.UserId;
				kDelay.Value = m.Delay;
			}
			_InitUserCombo(cbUser, user);
			b.End();
			
			ap[iType].apply = o => {
				var m = _ApplyProlog<api.ILogonTrigger>(TT.LOGON);
				var s = cbUser.Text; if (s is "" or "<any>") s = null;
				m.UserId = s;
				m.Delay = kDelay.Value;
			};
		}
		
		void _Session(int iType) {
			TTS[] ttsMap = [TTS.TASK_CONSOLE_CONNECT, TTS.TASK_CONSOLE_DISCONNECT, TTS.TASK_REMOTE_CONNECT, TTS.TASK_REMOTE_DISCONNECT, TTS.TASK_SESSION_LOCK, TTS.TASK_SESSION_UNLOCK];
			
			var b = _BuilderProlog(iType);
			b.R.Add("Event", out ComboBox cbEvent).Items("Local connection to user session|Local disconnect from user session|Remote connection to user session|Remote disconnect from user session|Workstation lock|Workstation unlock").Select(-1);
			b.R.Add("User", out ComboBox cbUser).Editable();
			string user = null;
			if (tt == TT.SESSION) {
				var m = (api.ISessionStateChangeTrigger)t;
				cbEvent.SelectedIndex = Array.IndexOf(ttsMap, m.StateChange);
				user = m.UserId;
				kDelay.Value = m.Delay;
			}
			_InitUserCombo(cbUser, user);
			b.End();
			
			ap[iType].apply = o => {
				var m = _ApplyProlog<api.ISessionStateChangeTrigger>(TT.SESSION);
				var s = cbUser.Text; if (s is "" or "<any>") s = null;
				m.UserId = s;
				m.StateChange = ttsMap[cbEvent.SelectedIndex];
				m.Delay = kDelay.Value;
			};
		}
		
		void _Eventlog(int iType) {
			bool custom = false;
			var b = _BuilderProlog(iType, 60, 80, 10, 0, 100, -1, 0);
			b.R.Add("Log", out TextBox tLog)
				.Validation(o => tLog.Visibility == Visibility.Visible && tLog.Text.NE() ? "Log not specified" : null, _ValidationLinkClick);
			b.R.Add("Source", out TextBox tSource);
			b.R.Add("Event ID", out TextBox tID)
				.Validation(o => _ValidateNumber(o, 0, ushort.MaxValue, allowEmpty: true), _ValidationLinkClick);
			b.Skip().Add("Level", out ComboBox cbLevel).Items("<any>|Critical|Error|Warning|Information|Verbose");
			b.Skip().AddButton(out var bMore, "More ▾", null);
			b.R.Add("Query", out TextBox tQuery).Multiline(60..75).Hidden(null)
				.Validation(o => { if (custom) try { XElement.Parse(tQuery.Text); } catch { return "Invalid XML"; } return null; }, _ValidationLinkClick);
			if (tt == TT.EVENT) {
				var m = (api.IEventTrigger)t;
				var (q, log, source, id, level) = m.GetQuery();
				if (q != null) {
					if (log != null) {
						tLog.Text = log;
						tSource.Text = source;
						tID.Text = id;
						if (level is >= 1 and <= 5) cbLevel.SelectedIndex = level;
					} else {
						_ToggleCustom();
						tQuery.Text = q;
					}
				}
				kDelay.Value = m.Delay;
			}
			b.End();
			
			ap[iType].apply = o => {
				var m = _ApplyProlog<api.IEventTrigger>(TT.EVENT);
				string q;
				if (custom) {
					q = tQuery.Text;
				} else {
					string s = "*", log = tLog.Text, source = tSource.TextOrNull(), id = tID.TextOrNull(), level = cbLevel.SelectedIndex is var si && si > 0 ? si.ToS() : null;
					if ((source ?? id ?? level) != null) {
						s = "*[System[";
						string sep = null;
						_Append(source, "Provider[@Name='", "']");
						_Append(id, "EventID=");
						_Append(level, "Level=");
						s += "]]";
						
						void _Append(string v, string pref, string suf = null) {
							if (v != null) {
								s = s + sep + pref + v + suf;
								sep = " and ";
							}
						}
					}
					var x = new XElement("QueryList",
						new XElement("Query",
							new XAttribute("Id", "0"),
							new XAttribute("Path", log),
							new XElement("Select",
								new XAttribute("Path", log),
								s
							)
						)
					);
					q = x.ToString();
				}
				m.Subscription = q;
				m.Delay = kDelay.Value;
			};
			
			bMore.Click += (_, _) => {
				var m = new popupMenu();
				m["Open Event Viewer"] = o => { run.it(@"eventvwr.msc"); };
				m["Paste event details", disable: !tLog.IsVisible] = o => {
					if (clipboard.text is { } s && s.Starts("Log Name:")) {
						foreach (var line in s.Lines()) {
							if (line.RxMatch(@"^(Log Name|Source|Event ID|Level):\h*(.+)", out var m)) {
								var v = m[2].Value;
								var c = line[m[1].Start + 2] switch { 'g' => tLog, 'u' => tSource, 'e' => tID, _ => null };
								if (c != null) c.Text = v;
								else if (cbLevel.SelectedIndex > 0) cbLevel.Text = v; //rejected: paste Level. But need to change if incorrect selected.
							}
						}
					} else {
						dialog.showInfo(null, "In Event Viewer select an event and copy its details as text.", owner: this);
					}
				};
				m.Separator();
				m.AddCheck("Custom", custom, _ => _ToggleCustom());
				m.Show(owner: this);
			};
			
			void _ToggleCustom() {
				custom ^= true;
				tLog.Collapse_(custom);
				tSource.Collapse_(custom);
				tID.Collapse_(custom);
				cbLevel.Collapse_(custom);
				tQuery.Collapse_(!custom);
			}
		}
		
		void _Idle(int iType) {
			var b = _BuilderProlog(iType);
			b.R.xAddInfoBlockT("To change idle conditions, use the Conditions page.");
			b.End();
			
			ap[iType].apply = o => {
				_ApplyProlog<api.ITrigger>(TT.IDLE);
			};
		}
		
		void _Registration(int iType) {
			if (tt == TT.REGISTRATION && t is api.IRegistrationTrigger m) {
				kDelay.Value = m.Delay;
			}
			
			ap[iType].apply = o => {
				var m = _ApplyProlog<api.IRegistrationTrigger>(TT.REGISTRATION);
				m.Delay = kDelay.Value;
			};
		}
		
		void _Unsupported(int iType) {
			var b = _BuilderProlog(iType);
			b.R.xAddInfoBlockT(t.Type == TT.BOOT ? "LibreAutomate cannot run at system startup. Delete this trigger.\nInstead create .exe program from this script, and in Task Scheduler create a task to run it." : "Cannot edit this trigger.");
			b.End();
		}
		
		void _InitUserCombo(ComboBox cb, string user) {
			if (!user.NE()) cb.Items.Add(user);
			cb.Items.Add("<any>");
			if (user != defaultUserId) cb.Items.Add(defaultUserId);
			cb.SelectedIndex = 0;
		}
		
		b.End();
		//-
		
		b.R.xAddGroupSeparator("Trigger settings");
		
		//- Trigger settings
		b.Row(-1).Add(new ScrollViewer { VerticalScrollBarVisibility = ScrollBarVisibility.Auto }).Margin("0")
			.StartGrid(childOfLast: true);
		
		kDelay = new _TimeIntervalControls(this, b, "", "30 s|1 m|1 h|1 d", 2, ("PT1S", "P31D"));
		
		b.R.StartGrid().Columns(0, -1, 0, -1);
		
		_TimeIntervalControls kRepeat = new(this, b, "Repeat every:", "5 m|1 h", 1, ("PT1M", "P31D"));
		_TimeIntervalControls kRepeatDuration = new(this, b, "for a duration of:", "|15 m|1 h|1 d", 3,
			validation: o => ((ComboBox)o).Text is "" ? null : _ValidateTimeInterval(o, /*"PT1M"*/kRepeat.Value, "P31D"),
			cOther: kRepeat.c, noRow: true);
		b.R.Add(out KCheckBox cRepeatStop, "Stop all running tasks at end of repetition duration").Margin(22).xBindCheckedEnabled(kRepeat.c);
		if (t.Repetition is { } rep && rep.Interval is string s1) {
			kRepeat.Value = s1;
			if (rep.Duration is string s2) kRepeatDuration.Value = rep.Duration; else kRepeatDuration.cb.SelectedIndex = 0;
			cRepeatStop.IsChecked = rep.StopAtDurationEnd;
		}
		b.End();
		
		_TimeIntervalControls kStop = new(this, b, "Stop task if it runs longer than:", "30 s|5 m|1 h|3 d", 2) { Value = t.ExecutionTimeLimit };
		
		b.R.StartGrid().Columns(0, -1, 0);
		_DateTimeControls dtActivate = new(this, b, 2, "Activate") { Value = _IsDateTrigger() ? null : t.StartBoundary };
		_DateTimeControls dtExpire = new(this, b, 3, "Expire") { Value = t.EndBoundary };
		dtExpire.dt.ValidationDateMustBeAfter = () => (_IsDateTrigger() ? dtStart : dtActivate.c.IsChecked ? dtActivate : null)?.dt.Value;
		page.cExpire = dtExpire.c;
		b.End();
		
		b.R.Add(out KCheckBox cEnabled, "Trigger enabled").Checked(t.Enabled);
		
		b.End();
		//-
		
		b.End();
		
		_apply += page.apply = o => {
			try {
				int i = cbTriggerType.SelectedIndex;
				ap[i].apply?.Invoke(o);
				
				if (kRepeat.c.IsChecked) {
					var rep = t.Repetition;
					rep.Interval = kRepeat.Value;
					rep.Duration = kRepeatDuration.Value;
					rep.StopAtDurationEnd = cRepeatStop.IsChecked;
				} else {
					t.Repetition = null;
				}
				
				t.ExecutionTimeLimit = kStop.Value;
				t.StartBoundary = _IsDateTrigger() ? dtStart.Value : dtActivate.Value;
				t.EndBoundary = dtExpire.Value;
				t.Enabled = cEnabled.IsChecked;
			}
			catch (Exception ex) { dialog.showError("Failed to apply trigger #" + page.Index, ex.ToString()); } //unlikely (all validated)
		};
		
		cbTriggerType.SelectionChanged += (_, e) => {
			int i = cbTriggerType.SelectedIndex;
			
			if (ap[i].panel == null) ab[i](i);
			cc.Content = ap[i].panel;
			
			bool isDateTrigger = i <= 4;
			dtStart.Collapse(!isDateTrigger);
			dtActivate.Collapse(isDateTrigger);
			kDelay.c.Content = isDateTrigger ? "Delay task for up to (random delay):" : "Delay task for:";
			kDelay.Collapse(_ttMap[i] == TT.IDLE);
		};
		
		cbTriggerType.SelectedIndex = Array.IndexOf(_ttMap, tt);
		
		_AddPage(page.ToString(), page);
		
		if (select) {
			_lbPages.SelectedItem = page.li;
			_lbPages.ScrollIntoView(page.li);
		}
		
		//note: gets the saved trigger type. It is different if changed and still not applied.
		bool _IsDateTrigger() => tt is >= TT.TIME and <= TT.MONTHLYDOW;
	}
	
	void _NewTrigger(bool createPage) {
		var trigger = _td.Triggers.Create(TT.TIME);
		var dt = DateTime.Now;
		trigger.StartBoundary = dt.ToString("s");
		if (createPage) _CreateTriggerPage(trigger, true);
	}
	
	void _DeleteTrigger() {
		if (_lbPages.SelectedItem is ListBoxItem { Tag: _TriggerPage page } li) {
			if (0 != _td.Triggers.Remove(_lbPages.SelectedIndex)) return;
			_lbPages.Items.Remove(li);
			_apply -= page.apply;
		}
	}
	
	class _TriggerPage : _Page {
		public api.ITrigger trigger;
		public Action<WBButtonClickArgs> apply;
		public KCheckBox cExpire;
		
		public override string ToString() {
			return trigger.FormatTriggerString();
		}
	}
	
	static string _DecodeTimeInterval(string s, string returnIf0 = null) {
		if (s.NE()) return null;
		if (s[0] != 'P') return s;
		try {
			var t = XmlConvert.ToTimeSpan(s);
			if (t.Ticks == 0) return returnIf0;
			StringBuilder b = new();
			_Append(t.Days, 'd');
			_Append(t.Hours, 'h');
			_Append(t.Minutes, 'm');
			_Append(t.Seconds, 's');
			return b.ToString();
			
			void _Append(int n, char c) {
				if (n > 0) {
					if (b.Length > 0) b.Append(" ");
					b.Append(n).Append(' ').Append(c);
				}
			}
		}
		catch { return s; }
	}
	
	static string _EncodeTimeInterval(string s) {
		if (s.NE() || !s.RxMatch(@"(?i)^ *P?(?:(\d+) *d(?:ays?)?,?)? *T?(?:(\d+) *h(?:ours?)?,?)? *(?:(\d+) *m(?:in(?:utes?)?)?,?)? *(?:(\d+) *s(?:ec(?:onds?)?)?)? *$", out var m)) return null;
		bool dExists = m[1].Exists, hmsExists = m[2].Exists || m[3].Exists || m[4].Exists;
		if (!(dExists || hmsExists)) return null;
		var b = new StringBuilder("P");
		if (dExists) b.Append(m[1].Value).Append('D');
		if (hmsExists) {
			b.Append('T');
			if (m[2].Exists) b.Append(m[2].Value).Append('H');
			if (m[3].Exists) b.Append(m[3].Value).Append('M');
			if (m[4].Exists) b.Append(m[4].Value).Append('S');
		}
		return b.ToString();
	}
	
	static string _ValidateTimeInterval(FrameworkElement e, string min = null, string max = null, Func<string> also = null) {
		var c = (ComboBox)e;
		if (c.IsEnabled && c.Visibility == Visibility.Visible) {
			var s = c.Text.Trim();
			if (s.NE()) return "Empty";
			if (_EncodeTimeInterval(s) is not string k) return "Invalid duration format";
			
			try {
				var t = XmlConvert.ToTimeSpan(k);
				//print.it(k, t);
				if (min != null && t < XmlConvert.ToTimeSpan(min)) return "Duration min " + _DecodeTimeInterval(min);
				max ??= "P24855D"; //int.MaxValue seconds
				if (t > XmlConvert.ToTimeSpan(max)) return "Duration max " + _DecodeTimeInterval(max);
				
				if (also is { } vp) return vp();
			}
			catch { return "Invalid duration format"; }
		}
		return null;
	}
	
	static string _ValidateNumber(FrameworkElement e, int min, int max, bool allowEmpty = false) {
		var c = (TextBox)e;
		if (c.IsEnabled && c.Visibility == Visibility.Visible) {
			var s = c.Text.Trim();
			if (s.NE()) return allowEmpty ? null : "Empty";
			if (!s.ToInt(out long r, 0, out int end, STIFlags.NoHex) || end < s.Length) return "Invalid number format";
			if (r < min) return "Min " + min;
			if (r > max) return "Max " + max;
		}
		return null;
	}
	
	static string _ValidateBits(FrameworkElement e) {
		var c = (KCheckDropdownBox)e;
		if (c.IsEnabled && c.Visibility == Visibility.Visible) {
			if (c.Checked == 0) return "Empty";
		}
		return null;
	}
	
	void _ValidationLinkClick(FrameworkElement e) {
		if (!e.IsVisible) {
			var page = e.FindVisualAncestor<_Page>(false, null, false) as _Page;
			_lbPages.SelectedIndex = page.Index;
		}
	}
	
	class _TimeIntervalControls {
		public ComboBox cb;
		public KCheckBox c;
		Label _label;
		KCheckBox _cOther;
		
		public _TimeIntervalControls(DSchedule dialog, wpfBuilder b, string label, string cbItems, int cbIndex,
			(string min, string max) valid = default, Func<FrameworkElement, string> validation = null, Func<FrameworkElement, string> checkboxValidation = null,
			KCheckBox cOther = null, bool noRow = false) {
			
			validation ??= o => _ValidateTimeInterval(o, valid.min, valid.max);
			
			if (!noRow) b.Row(0);
			if ((_cOther = cOther) == null) {
				b.Add(out c, label);
				if (checkboxValidation != null) b.Validation(checkboxValidation, dialog._ValidationLinkClick);
			} else b.Add(out _label, label);
			
			b.Add(out cb).Editable().LabeledBy()
				.Items(cbItems).Select(cbIndex)
				.Validation(validation, dialog._ValidationLinkClick);
			b.xBindCheckedEnabled(c ?? _cOther, true);
		}
		
		public string Value {
			get => (c ?? _cOther).IsChecked ? _EncodeTimeInterval(cb.Text) : null;
			set {
				if (_DecodeTimeInterval(value) is string s) {
					cb.Text = s;
					if (c != null) c.IsChecked = true;
				}
			}
		}
		
		public string Value0 {
			set {
				if (_DecodeTimeInterval(value, "0 s") is string s) {
					cb.Text = s;
					if (c != null) c.IsChecked = true;
				}
			}
		}
		
		public void Collapse(bool collapse) {
			_label?.Collapse_(collapse);
			c?.Collapse_(collapse);
			cb.Collapse_(collapse);
		}
	}
	
	class _DateTimeControls {
		public KDateTime dt;
		public KCheckBox c;
		Label _label;
		KCheckBox _cSync;
		bool _expire;
		
		/// <param name="id">1 Start, 2 Activate, 3 Expire.</param>
		public _DateTimeControls(DSchedule dialog, wpfBuilder b, int id, string label, Func<FrameworkElement, string> validation = null) {
			_expire = id == 3;
			bool checkbox = id is 2 or 3;
			
			b.Row(0);
			if (checkbox) b.Add(out c, label); else b.Add(out _label, label);
			
			b.Add(out dt).LabeledBy(bindVisibility: false)
				.Validation(validation ?? KDateTime.Validation, dialog._ValidationLinkClick);
			if (checkbox) b.xBindCheckedEnabled(c);
			
			b.Add(out _cSync, "Sync across time zones");
			if (checkbox) b.xBindCheckedEnabled(c);
		}
		
		/// <summary>
		/// Note: getter throws if the date control text is invalid. Must be validated.
		/// </summary>
		public string Value {
			get => c?.IsChecked == false ? null : XmlConvert.ToString(dt.Value.Value, _cSync.IsChecked ? XmlDateTimeSerializationMode.Local : XmlDateTimeSerializationMode.Unspecified);
			set {
				if (!value.NE()) {
					try {
						dt.Value = XmlConvert.ToDateTime(value, XmlDateTimeSerializationMode.Local);
						if (c != null) c.IsChecked = true;
						_cSync.IsChecked = value.RxIsMatch(@"(?:Z|[+\-][\d:]+)$");
						return;
					}
					catch { }
				}
				var d = DateTime.Now;
				if (_expire) d = d.AddYears(1);
				dt.Value = d;
			}
		}
		
		public void Collapse(bool collapse) {
			_label?.Collapse_(collapse);
			c?.Collapse_(collapse);
			dt.Collapse_(collapse);
			_cSync.Collapse_(collapse);
		}
	}
}


================================================
FILE: Au.Editor/Triggers and toolbars/TT-tb.cs
================================================
extern alias CAW;

using System.Windows;
using System.Windows.Controls;

using Microsoft.CodeAnalysis;
using CAW::Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Text;
using Microsoft.CodeAnalysis.Shared.Extensions;
using CAW::Microsoft.CodeAnalysis.Shared.Extensions;
using Microsoft.CodeAnalysis.CSharp.Extensions;
using CAW::Microsoft.CodeAnalysis.FindSymbols;

using Au.Triggers;
using ToolLand;
using Au.Controls;

namespace LA;

partial class TriggersAndToolbars {
	_Toolbar[] _toolbars;
	MetaComments _meta;
	Solution _sln;
	Compilation _compilation;
	INamedTypeSymbol _programSym;
	Dictionary<FileNode, SyntaxTree> _fnToSt;
	Dictionary<SyntaxTree, FileNode> _fnFromSt;
	
	TriggersAndToolbars() {
		_Update();
	}
	
	void _NewToolbar() {
		var w = new KDialogWindow { Title = "New toolbar" };
		var b = new wpfBuilder(w).WinSize(500).Columns(50, -1);
		b.WinProperties(resizeMode: ResizeMode.NoResize, showInTaskbar: false);
		
		b.R.Add("Name", out TextBox tName, "Toolbar_").Focus()
			.Validation(_ => tName.Text is "" or "Toolbar_" ? "No name" : !SyntaxFacts.IsValidIdentifier(tName.Text) ? "Invalid function name" : null);
		
		b.R.Add("In file", out ComboBox cbFile);
		cbFile.ShouldPreserveUserEnteredPrefix = true;
		cbFile.Items.Add("<new file>");
		foreach (var st in _EnumToolbarTriggersFunctions().Select(o => o.Locations[0].SourceTree).Distinct()) {
			cbFile.Items.Add(_fnFromSt[st]);
		}
		cbFile.SelectedIndex = 0;
		
		b.R.Add("Code", out ComboBox cbTrigger).Items("Window trigger, attach to window|Window trigger, attach, auto-hide at screen edge|Show at startup, auto-hide at screen edge|Mouse trigger, auto-hide at screen edge|No trigger");
		b.R.Skip().Add(out KCheckBox cLaterName, "Show/hide whenever window name changes");
		b.R.StartGrid().Columns(50, -1, 20, 0, -1).Hidden(null)
			.R.Add("Edge", out ComboBox cbEdge).Items(typeof(TMEdge).GetEnumNames()).Select(1)
			.Skip();
		var cbScreen = _ScreenComboBoxInit(b);
		b.End();
		var pScreen = b.Last;
		var windowTriggerPage = _AddWindowPage(b);
		
		cbTrigger.SelectionChanged += (_, _) => {
			int si = cbTrigger.SelectedIndex;
			pScreen.Visibility = si is 1 or 2 or 3 ? Visibility.Visible : Visibility.Collapsed;
			cLaterName.Visibility = si is 0 or 1 ? Visibility.Visible : Visibility.Collapsed;
			windowTriggerPage.Visibility = si is 0 or 1 ? Visibility.Visible : Visibility.Collapsed;
		};
		
		b.R.AddOkCancel();
		b.End();
		
		b.Loaded += () => { tName.CaretIndex = tName.Text.Length; };
		
		if (!w.ShowAndWait(App.Wmain)) return;
		
		string sName = _GetUniqueNameInProgram(tName.Text);
		
		int iTrigger = cbTrigger.SelectedIndex;
		string sAutoHide = null;
		if (iTrigger is 0 or 4) { //window, none
			sAutoHide = """
		
		////auto-hide. Above is the auto-hide part. Below is the always-visible part.
		//t = t.AutoHide();
		//if (t.FirstTime) {
			
		//}
		
""";
			if (iTrigger == 0) sAutoHide += """

		//t.MaximizedWindowTopPlus = 6.7;
		
""";
		} else if (iTrigger is 1 or 2) { //window+screen or screen
			string sScreen = _ScreenComboBoxResult(cbScreen, false) ?? "default";
			sAutoHide = $$"""
		
		//auto-hide at the specified screen edge. Above is the auto-hide part. Below is the always-visible part.
		t = t.AutoHideScreenEdge(TMEdge.{{cbEdge.SelectedItem}}, {{sScreen}}, 5, ^5, 2);
		t.BorderColor = System.Drawing.Color.Orange;
		//if (t.FirstTime) {
			
		//}
		
""";
		} else if (iTrigger == 3) { //screen+mouse
			sAutoHide = """
		
		//auto-hide at the screen edge of the mouse trigger. Above is the auto-hide part. Below is the always-visible part.
		t = t.AutoHideScreenEdge(ta, 5, ^5, 2);
		t.BorderColor = System.Drawing.Color.Orange;
		//if (t.FirstTime) {
			
		//}
		
""";
		}
		
		var sArg = iTrigger switch {
			0 or 1 => "WindowTriggerArgs ta",
			3 => "MouseTriggerArgs ta",
			_ => "TriggerArgs ta = null"
		};
		
		bool laterName = iTrigger is 0 or 1 && cLaterName.IsChecked;
		string sRetType = laterName ? "toolbar" : "void", sRetCode = laterName ? "\r\n\t\t\r\n\t\treturn t;" : null;
		
		var text = $$"""

	{{sRetType}} {{sName}}({{sArg}}) {
		var t = new toolbar();
		if (t.FirstTime) {
			//t.DisplayText = !true; //display only icon or 2 characters, unless button text is like "Text\a"
			
		}
		
		//Add buttons here, like in examples. Hints: toolbarButtonSnippet, drag-drop, Ctrl+Shift+Q.
		//More info: 1. Cookbook > Floating toolbars. 2. toolbar class help (click word toolbar above and press F1).
		
		t["Example"] = o => { print.it("button clicked"); };
		t["|Tooltip1", image: "*Modern.TreeLeaf #73BF00"] = o => {  }; //to set icon use the Icons dialog
		t["Text\a"] = o => {  }; //this button always displays text. The above button never.
		t.Menu("Menu1", t => {
			t["A"] = o => {  };
			t["B|Tooltip3"] = o => {  };
		});
		t.Separator();
		t["Text2\a|Tooltip2"] = o => {  };
{{sAutoHide}}
		t.Show(ta);
		
		////this code is the same as t.Show(ta), but you can specify more Show parameters, for example attach to a control
		//if (ta is WindowTriggerArgs wta) {
		//	t.Show(wta.Window); //attach to the trigger window
		//} else {
		//	t.Show();
		//	ta?.DisableTriggerUntilClosed(t); //single instance
		//}{{sRetCode}}
	}

""";
		
		if (cbFile.SelectedItem is not FileNode f) { //new file
			text = $$"""
using Au.Triggers;

partial class Program {
	[Toolbars]
	void {{_GetUniqueNameInProgram(sName + "_Triggers")}}() {
	}

"""
+ text
+ @"}
";
			var folder = App.Model.Find(@"\@Triggers and toolbars\Toolbars", FNFind.Folder);
			f = App.Model.NewItem("Class.cs", new(folder, FNInsert.Last), sName + ".cs", text: new(true, text));
		} else {
			var programNode = _ProgramClassNodeFromST(_fnToSt[f]); if (programNode == null) return;
			_OpenSourceFile(f).aaaInsertText(true, programNode.CloseBraceToken.SpanStart, text);
		}
		
		_Update();
		var t = _toolbars[Array.FindIndex(_toolbars, o => o.Name == sName)];
		
		//trigger
		if (iTrigger != 4) {
			wait.doEvents(30); //workaround for bad scrolling (mouse/screen) etc
			if (iTrigger is 0 or 1) { //window
				_AddTriggerWindow(t, windowTriggerPage);
			} else if (iTrigger == 2) { //startup
				_AddTriggerStartup(t);
			} else { //mouse
				_AddTriggerMouse(t, cbEdge.SelectedItem as string, cbScreen);
			}
			_Update();
			if (!_StillExists(ref t)) return;
		}
		
		//go to the toolbar function
		int i = t.location.SourceSpan.Start;
		timer.after(iTrigger != 4 ? 500 : 10, _ => { //workaround for bad scrolling. Also briefly shows the trigger.
			_OpenSourceFile(f)?.aaaGoToPos(true, i);
		});
		
		//maybe a settings file exists with this name, probably orphaned
		var jsFolder = folders.Workspace + ".toolbars";
		var jsPath = jsFolder + "\\" + sName + ".json";
		if (filesystem.exists(jsPath)) {
			//rejected: show a dialog box.
			//CONSIDER: for new toolbar names use name+GUID.
			if (true == filesystem.delete(jsPath, FDFlags.RecycleBin | FDFlags.CanFail))
				print.it($"<>Note: A toolbar settings file with this name ({sName}) has been found, and moved to the Recycle Bin to avoid confusion.\r\n\tInfo: Each toolbar has a settings file with the same name, saved <link {jsFolder}>here<>. The program does not delete settings files of deleted or renamed toolbars. You can delete unused files. Deleting a used file resets the position, size and context menu settings of that toolbar.");
		}
	}
	
	static DPwnd _AddWindowPage(wpfBuilder b) {
		DPwnd p = new("Window");
		b.R.Add(p).Margin("LR")
			.Validation(o => p.IsVisible && !p.HasResult ? "Window not specified" : null);
		return p;
	}
	
	void _SetToolbarTrigger() {
		var t = _ToolbarFromCurrentPos(); if (t == null) return;
		
		var w = new KDialogWindow { Title = "New trigger for " + t.Name, ShowInTaskbar = false };
		var b = new wpfBuilder(w).WinSize(500);
		
		ComboBox cbReplace = null, cbEdge = null, cbScreen = null;
		DPwnd windowTriggerPage = null;
		
		if (t.triggers.Length > 0) {
			b.R.Add("Replace trigger", out cbReplace);
			cbReplace.Items.Add("Don't replace");
			foreach (var v in t.triggers) cbReplace.Items.Add(v);
			cbReplace.SelectedIndex = 0;
		}
		
		int iTrigger = -1; //0 window, 1 startup, 2 mouse
		if (t.method.Parameters.Length > 0) {
			var pt = t.method.Parameters[0].Type;
			if (pt == _compilation.GetTypeByMetadataName("Au.Triggers.WindowTriggerArgs")) iTrigger = 0;
			else if (pt == _compilation.GetTypeByMetadataName("Au.Triggers.MouseTriggerArgs")) iTrigger = 2;
		}
		
		b.R.Add("Trigger type", out ComboBox cbTrigger).Disabled(iTrigger >= 0)
			.Items(iTrigger switch { 0 => "Window", 2 => "Mouse", _ => "Window|Show at startup" });
		if (iTrigger == 2) {
			b.R.Add("Screen edge", out cbEdge).Items(typeof(TMEdge).GetEnumNames()).Select(1)
				.And(170).StartGrid();
			cbScreen = _ScreenComboBoxInit(b);
			b.End();
		} else if (iTrigger <= 0) {
			windowTriggerPage = _AddWindowPage(b);
			cbTrigger.SelectionChanged += (_, _) => { windowTriggerPage.Visibility = cbTrigger.SelectedIndex == 0 ? Visibility.Visible : Visibility.Collapsed; };
		}
		//b.R.Add(out KCheckBox cRestart, "Restart TT script").Checked(); //rejected
		
		b.R.AddOkCancel();
		b.End();
		
		if (!w.ShowAndWait(App.Wmain)) return;
		if (!_StillExists(ref t)) return;
		
		int pos = -1;
		if (cbReplace?.SelectedItem is _Trigger u && _GetTriggerStatementFullRange2(u, out var span, replacing: true)) {
			var doc = _OpenSourceFile(t.fn, span.Start);
			using var undo = doc.ENewUndoAction();
			doc.aaaDeleteRange(true, span.Start, span.End);
			pos = span.Start;
			_Add();
		} else {
			_Add();
		}
		_Update();
		
		void _Add() {
			if (iTrigger < 0) iTrigger = cbTrigger.SelectedIndex;
			if (iTrigger == 0) {
				_AddTriggerWindow(t, windowTriggerPage, pos);
			} else if (iTrigger == 1) {
				_AddTriggerStartup(t, pos);
			} else if (iTrigger == 2) {
				_AddTriggerMouse(t, cbEdge.SelectedItem as string, cbScreen, pos);
			}
		}
	}
	
	_Toolbar _ToolbarFromCurrentPos() {
		var doc = Panels.Editor.ActiveDoc; if (doc == null) return null;
		int pos = doc.aaaCurrentPos16;
		var f = doc.EFile;
		//is pos in a toolbar function?
		var t = _toolbars.FirstOrDefault(o => o.fn == f && o.method.DeclaringSyntaxReferences[0].Span.ContainsOrTouches(pos));
		if (t != null) return t;
		//is pos in a name of a toolbar function?
		foreach (var v in _toolbars) {
			foreach (var tr in v.triggers) if (tr.fn == f && tr.location.SourceSpan.ContainsOrTouches(pos)) return v;
		}
		//get the first toolbar in the file
		return _toolbars.FirstOrDefault(o => o.fn == f);
	}
	
	//void _EditToolbar(_Toolbar t) {
	//	_OpenSourceFile(t, t.location.SourceSpan);
	//}
	
	//rejected. It's better if the user reviews that code and deletes manually.
	//void _DeleteToolbar(_Toolbar t, bool commentOut) {}
	
	void _AddTriggerWindow(_Toolbar t, DPwnd p, int pos = -1) {
		string sTrigger = p.AaResultCode, sAction = t.Name, sSep = " ";
		if (!t.method.ReturnsVoid) {
			sTrigger += ", later: TWLater.Name";
			sAction = $"ta => ta.ShowToolbarWhenWindowName({sAction}, \"*window_name_when_the_toolbar_is_visible*\")";
			sSep = "\r\n\t";
			print.it("""
Please edit window name strings in the toolbar trigger code.
	The first should contain only the non-changing part, for example "*Program".
	The second - when the toolbar must be visible, for example "Document -*"
""");
		}
		_AddTrigger(t, $"Triggers.Window[TWEvent.ActiveOnce, {sTrigger}] ={sSep}{sAction};", pos);
	}
	
	void _AddTriggerStartup(_Toolbar t, int pos = -1) {
		_AddTrigger(t, $"{t.Name}();", pos);
	}
	
	void _AddTriggerMouse(_Toolbar t, string edge, ComboBox cbScreen, int pos = -1) {
		string s = _ScreenComboBoxResult(cbScreen, true);
		if (s != null) s = ", screen: " + s;
		_AddTrigger(t, $"Triggers.Mouse[TMEdge.{edge}{s}] = {t.Name};", pos);
	}
	
	void _AddTrigger(_Toolbar t, string s, int pos) {
		if (pos < 0) pos = _FindToolbarTriggersFunction(t).node.Body.CloseBraceToken.SpanStart;
		if (null == _OpenSourceFile(t.fn, pos)) return;
		InsertCode.Statements(new(s, selectNewCode: true));
	}
	
	static void _EditTrigger(_Trigger t) {
		_OpenSourceFile(t.fn, t.location.SourceSpan);
	}
	
	//bool _DeleteTrigger(_Trigger t/*, bool commentOut = false*/) {
	//	if (!_GetTriggerStatementFullRange2(t, out var span, replacing: false)) return false;
	//	var doc = _OpenSourceFile(t.fn, span.Start);
	//	//doc.aaaSelect(true, span.Start, span.End, true); return -1;
	//	//if (commentOut) {
	//	//	doc.aaaSelect(true, span.Start, span.End, true);
	//	//	ModifyCode.CommentLines(true);
	//	//} else {
	//	doc.aaaDeleteRange(true, span.Start, span.End);
	//	//}
	//	_Update();
	//	return true;
	//}
	
	ComboBox _ScreenComboBoxInit(wpfBuilder b) {
		b.Add("Screen", out ComboBox cb);
		cb.Items.Add("Primary");
		cb.SelectedIndex = 0;
		
		var a = screen.all;
		if (a.Length > 1) {
			//add functions of screen.at
			foreach (var v in typeof(screen.at).GetMethods(BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public)) {
				cb.Items.Add("screen.at." + v.Name);
			}
			
			//if defined type "screens", add its public static properties that return screen
			//	This code works, but probably this feature would be rarely used. Now undocumented.
			//if (_compilation.GetSymbolsWithName("screens", SymbolFilter.Type).FirstOrDefault() is INamedTypeSymbol screens) {
			//	foreach (var v in screens.GetMembers()) {
			//		if (v is not IPropertySymbol p || !v.IsStatic || v.DeclaredAccessibility is not Microsoft.CodeAnalysis.Accessibility.Public) continue;
			//		if (p.Type.ToString() != "Au.screen") continue;
			//		cb.Items.Add("screens." + v.Name);
			//	}
			//}
			
			//if (a.Length == 2) cb.Items.Add("screen.index(1)"); //no. More screens may be added in the future, and indices may change then.
		}
		
		return cb;
	}
	
	static string _ScreenComboBoxResult(ComboBox cbScreen, bool trigger) {
		int iScreen = cbScreen.SelectedIndex;
		if (iScreen == 0) return null;
		var s = cbScreen.Items[iScreen] as string;
		//if (s.Starts("screens.")) return s;
		//if (s.Starts("screen.at."))
		return s + (trigger ? "(true)" : "()");
		//return trigger ? s.Insert(^1, ", lazy: true") : s;
	}
	
	static bool _GetTriggerStatementFullRange2(_Trigger t, out TextSpan span, bool replacing) {
		if (_GetTriggerStatementFullRange(t, out span, replacing)) return true;
		print.it("This trigger should be deleted manually: " + t.text + "\r\n\tIt depends on other code which should be edited, deleted or reviewed.");
		if (!replacing) _EditTrigger(t);
		return false;
	}
	
	static bool _GetTriggerStatementFullRange(_Trigger t, out TextSpan span, bool replacing) {
		span = default;
		var node = t.location.FindNode(default);
		g1:
		var ss = node.GetAncestor<StatementSyntax>();
		if (ss == null) return false;
		//print.clear(); CiUtil.PrintNode(ss); CiUtil.PrintNode(ss.Parent);
		var pa = ss.Parent;
		if (pa is not BlockSyntax bs) return false;
		if (t.isTrigger && bs.Parent is SimpleLambdaExpressionSyntax) {
			if (bs.Statements.Count == 1 && bs.ToString().RxIsMatch(@"^\{\s*\w.+;\s*\}$")) { //lambda { single statement }
				node = bs; goto g1;
			}
			if (replacing) return false;
		}
		var from = ss.SpanStart;
		if (ss.HasLeadingTrivia) {
			var u = ss.GetLeadingTrivia()[^1];
			if (u.Kind() == SyntaxKind.WhitespaceTrivia) from = u.SpanStart;
		}
		span = TextSpan.FromBounds(from, ss.FullSpan.End);
		return true;
	}
	
	/// <summary>
	/// Finds the toolbar in current _toolbars.
	/// If _toolbars changed and does not contain t, tries to find in the new _toolbars and updates t; returns false if not found (the toolbar code has been deleted).
	/// </summary>
	bool _StillExists(ref _Toolbar t) {
		var tt = t;
		t = _toolbars.FirstOrDefault(o => o.EqualsMethodQName(tt));
		return t != null && !t.fn.IsDeleted;
	}
	
	static SciCode _OpenSourceFile(FileNode f, int pos = -1) {
		if (App.Model.OpenAndGoTo(f, columnOrPos: pos)) return Panels.Editor.ActiveDoc;
		return null;
	}
	
	static SciCode _OpenSourceFile(FileNode f, TextSpan span) {
		if (!App.Model.OpenAndGoTo(f)) return null;
		var doc = Panels.Editor.ActiveDoc;
		doc.aaaSelect(true, span.End, span.Start, true);
		return doc;
	}
	
	IEnumerable<IMethodSymbol> _EnumToolbarTriggersFunctions() {
		var at = _programSym.GetTypeMembers("ToolbarsAttribute")[0];
		foreach (var m in _programSym.GetMembers().OfType<IMethodSymbol>()) {
			foreach (var a in m.GetAttributes()) if (a.AttributeClass == at) yield return m;
		}
	}
	
	ClassDeclarationSyntax _ProgramClassNodeFromST(SyntaxTree tree)
		=> _programSym.Locations.FirstOrDefault(o => o.SourceTree == tree)?.FindNode(default) as ClassDeclarationSyntax;
	
	string _GetUniqueNameInProgram(string name) {
		if (_programSym.MemberNames.Contains(name)) {
			for (int i = 2; ; i++) {
				var n = name + i;
				if (!_programSym.MemberNames.Contains(n)) return n;
			}
		}
		return name;
	}
	
	(IMethodSymbol sym, MethodDeclarationSyntax node) _FindToolbarTriggersFunction(_Toolbar t) {
		bool retry = false;
		g1:
		foreach (var m in _EnumToolbarTriggersFunctions()) {
			var loc = m.Locations[0];
			if (loc.SourceTree == t.tree) return (m, loc.FindNode(default) as MethodDeclarationSyntax);
		}
		if (retry) return default; retry = true;
		
		//create the function
		string name = _GetUniqueNameInProgram("Toolbars");
		var programNode = _ProgramClassNodeFromST(t.tree);
		_OpenSourceFile(t.fn, programNode.OpenBraceToken.FullSpan.End);
		var s = $$"""

[Toolbars]
void {{name}}() {
	
}


""";
		InsertCode.TextSimply(s);
		_Update();
		t = _toolbars.First(o => o.EqualsMethodQName(t));
		goto g1;
	}
	
	void _Update() {
		var a = new List<_Toolbar>();
		var at = new List<_Trigger>();
		var proj = TriggersAndToolbars.GetProject(create: true);
		using var ws = new CiWorkspace(proj, CiWorkspace.Caller.Other);
		_meta = ws.Meta;
		_sln = ws.Solution;
		_compilation = ws.GetCompilation();
		var ntToolbar = _compilation.GetTypeByMetadataName("Au.toolbar");
		
		_fnToSt = new();
		_fnFromSt = new();
		int iTree = 0;
		foreach (var tree in _compilation.SyntaxTrees) {
			Debug.Assert(tree.FilePath == _meta.CodeFiles[iTree].f.ItemPath);
			var f = _meta.CodeFiles[iTree++].f;
			_fnToSt[f] = tree;
			_fnFromSt[tree] = f;
			
			var semo = _compilation.GetSemanticModel(tree);
			var cu = semo.SyntaxTree.GetCompilationUnitRoot();
			var k = semo.GetAllDeclaredSymbols(cu, default);
			IMethodSymbol mPrev = null;
			foreach (var v in k) {
				if (v is ILocalSymbol loc && loc.Type == ntToolbar) {
					if (loc.DeclaringSyntaxReferences[0].GetSyntax() is VariableDeclaratorSyntax vd && vd.Initializer is EqualsValueClauseSyntax evc && evc.Value is BaseObjectCreationExpressionSyntax or InvocationExpressionSyntax) {
						var m = loc.ContainingSymbol as IMethodSymbol;
						if (m == mPrev) continue; mPrev = m; //get single toolbar in function
						var t = new _Toolbar { method = m, location = m.Locations[0], Name = m.Name, fn = f, tree = tree, variable = loc, };
						
						at.Clear();
						foreach (var x in SymbolFinder.FindCallersAsync(m, _sln).Result_()) {
							foreach (var y in x.Locations) {
								var node = y.FindNode(default);
								string tt = "?";
								bool isTrigger = false;
								if (node.GetAncestor<AssignmentExpressionSyntax>()?.Left is ElementAccessExpressionSyntax ea) {
									var semo2 = y.SourceTree == tree ? semo : _compilation.GetSemanticModel(y.SourceTree);
									var ty = semo2.GetTypeInfo(ea.Expression).Type;
									if (isTrigger = ty.ContainingNamespace.ToString() == "Au.Triggers") {
										tt = ea.ArgumentList.ToString();
										if (ty.Name == nameof(WindowTriggers)) tt = tt.RxReplace(@"^\[\s*TWEvent\.\w+\s*,\s*", "[");
										else tt = ty.Name[..^8] + tt;
									}
								}
								if (!isTrigger) {
									foreach (var p in node.Ancestors()) {
										if (p is LocalFunctionStatementSyntax lf) { tt = /*"Called from " +*/ lf.Identifier.Text; break; }
										if (p is MethodDeclarationSyntax met) { tt = /*"Called from " +*/ met.Identifier.Text; break; }
										if (p is MemberDeclarationSyntax mem && p is not BaseTypeDeclarationSyntax) { tt = mem.ToString(); break; } //field, property, method
									}
								}
								tt = tt.Replace("\t", "").RxReplace(@"\R", " ");
								at.Add(new(_fnFromSt[y.SourceTree], y, tt, isTrigger));
							}
						}
						t.triggers = at.ToArray();
						if (at.Any()) t.TriggerText = string.Join('\n', at.Select(o => o.text));
						
						a.Add(t);
					}
				}
			}
		}
		
		_toolbars = a.ToArray();
		_programSym = _compilation.GlobalNamespace.GetTypeMembers("Program")[0];
	}
	
	class _Toolbar {
		public FileNode fn;
		public SyntaxTree tree;
		public IMethodSymbol method;
		public Location location;
		public ILocalSymbol variable; //currently not used. In the future may be used for adding toolbar buttons.
		public _Trigger[] triggers;
		
		public string Name { get; set; }
		public string TriggerText { get; set; }
		
		/// <summary>Equals method qualified name.</summary>
		public bool EqualsMethodQName(_Toolbar t) => Name == t.Name && method.ToString() == t.method.ToString();
		
		/// <summary>Equals SourceTree and SourceSpan.</summary>
		public bool EqualsMethodLocation(Location loc) => loc.SourceTree.FilePath == location.SourceTree.FilePath && loc.SourceSpan.Start == location.SourceSpan.Start;
	}
	
	record _Trigger(FileNode fn, Location location, string text, bool isTrigger) {
		public override string ToString() => text;
	}
}


================================================
FILE: Au.Editor/Triggers and toolbars/TT-triggers.cs
================================================
using System.Windows;
using System.Windows.Controls;
using Au.Controls;
using ToolLand;
using Au.Triggers;

namespace LA;

partial class TriggersAndToolbars {
	public enum TriggersType { None, Hotkey, Autotext, Mouse, Window }
	
	/// <summary>
	/// Tool dialog "New trigger".
	/// </summary>
	/// <param name="selectTriggersType">If not 0, selects trigger type.</param>
	/// <param name="windowTriggerWnd">Window for window trigger.</param>
	public static void NewTrigger(TriggersType selectTriggersType = 0, wnd windowTriggerWnd = default) {
		var owner = selectTriggersType > 0 ? null : App.Wmain;
		var w = new KDialogWindow { Title = "New trigger", ShowInTaskbar = owner == null, Topmost = owner == null };
		var b = new wpfBuilder(w).WinSize(500, 400);
		b.Options(bindLabelVisibility: true);
		
		UserControl[][] pages = [new UserControl[2], new UserControl[2], new UserControl[2], new UserControl[3]];
		int iPage = 0;
		Button bBack = null, bNext = null;
		_HotkeyTriggerPage hotkeyTriggerPage = null;
		_AutotextTriggerPage autotextTriggerPage = null;
		_MouseTriggerPage mouseTriggerPage = null;
		_WindowTriggerSettingsPage windowTriggerSettingsPage = null;
		DPwnd windowTriggerWindowPage = null;
		
		b.Row(-1).Add(out ContentControl ccPages).Margin("0");
		b.Child().Add(out UserControl firstPage).StartGrid(childOfLast: true);
		for (int i = 0; i < 4; i++) pages[i][0] = firstPage;
		
		TriggersType tType = selectTriggersType != 0 ? selectTriggersType : _CodeAnalysis.GetTriggersType();
		var fn = App.Model.CurrentFile;
		bool canRunThisScript = fn.IsExecutableDirectly() && !IsTtScipt(fn);
		
		b.R.Add("Trigger", out ToolBar tb).Margin("LRT").Brush(SystemColors.ControlBrush);
		tb.HideGripAndOverflow();
		string[] aTriggersTypeStrings = { "Hotkey", "Autotext", "Mouse", "Window" };
		var abc = new RadioButton[aTriggersTypeStrings.Length];
		for (int i = 0; i < abc.Length; i++) {
			tb.Items.Add(abc[i] = new RadioButton { Content = aTriggersTypeStrings[i], Width = 60, Margin = new(0, 0, 3, 0), BorderBrush = SystemColors.ActiveBorderBrush });
		}
		
		//var bMore = new Button { Content = "...", Width = 24, BorderBrush = SystemColors.ActiveBorderBrush };
		//bMore.Click += (_, _) => {
		//	var m = new popupMenu();
		//	m["Command line"] = o => { b.Window.Close(); Menus.TT.Script_launchers.Command_line(); };
		//	m["Schedule"] = o => { b.Window.Close(); Menus.TT.Script_launchers.Schedule(); };
		//	m["Shortcut"] = o => { b.Window.Close(); Menus.TT.Script_launchers.Shortcut(); };
		//	m["Shell menu"] = o => { b.Window.Close(); Menus.TT.Script_launchers.Shell_menu(); };
		//	m["Run at startup"] = o => { b.Window.Close(); Menus.TT.Script_launchers.Run_at_startup(); };
		//	m["Open file \"Other triggers\""] = o => { b.Window.Close(); Menus.TT.Other_triggers(); };
		//	m.Show(owner: b.Window);
		//};
		//tb.Items.Add(bMore);
		
		b.Row(-1).Add("Action", out ListBox lbAction);
		ScrollViewer.SetHorizontalScrollBarVisibility(lbAction, ScrollBarVisibility.Disabled);
		
		b.Row(80).Add(out KSciInfoBox info);
		
		b.End(); //of firstPage
		
		b.R.StartOkCancel();
		b.AddButton(out bBack, ImageUtil.LoadWpfImageElement("*EvaIcons.ArrowBack @12" + EdIcons.black), k => {
			ccPages.Content = pages[(int)tType - 1][--iPage];
			bBack.IsEnabled = iPage > 0;
			bNext.Content = "Next";
		}).Padding("L3R3").Disabled();
		
		b.AddButton(out bNext, "Next", k => { k.Cancel = _NextPage(); }, WBBFlags.OK);
		
		bool _NextPage() {
			int lastPage = tType == TriggersType.Window ? 2 : 1;
			if (iPage == lastPage) return false;
			iPage++;
			if (tType == TriggersType.Hotkey) {
				if (iPage == 1) pages[(int)tType - 1][iPage] ??= hotkeyTriggerPage = new();
				if (iPage == 1) timer.after(1, _ => { hotkeyTriggerPage.FocusHotkey(); }); //does not work now (after `ccPages.Content = ...`), and even with Dispatcher
			} else if (tType == TriggersType.Autotext) {
				if (iPage == 1) pages[(int)tType - 1][iPage] ??= autotextTriggerPage = new();
				if (iPage == 1) timer.after(1, _ => { autotextTriggerPage.FocusText(); });
			} else if (tType == TriggersType.Mouse) {
				if (iPage == 1) pages[(int)tType - 1][iPage] ??= mouseTriggerPage = new();
			} else if (tType == TriggersType.Window) {
				if (iPage == 1) {
					if (windowTriggerWindowPage == null) {
						pages[(int)tType - 1][iPage] = windowTriggerWindowPage = new();
						if (windowTriggerWnd.IsAlive) windowTriggerWindowPage.SetWnd(windowTriggerWnd);
					}
				}
				if (iPage == 2) pages[(int)tType - 1][iPage] ??= windowTriggerSettingsPage = new();
			}
			ccPages.Content = pages[(int)tType - 1][iPage];
			bBack.IsEnabled = true;
			bNext.Content = iPage < lastPage ? "Next" : "OK";
			return true;
		}
		
		b.AddButton("Cancel", null, WBBFlags.Cancel);
		b.End();
		
		b.End();
		
		if (tType > 0) abc[(int)tType - 1].IsChecked = true;
		if (selectTriggersType == 0) _SetTriggerType(tType, true);
		
		for (int i = 0; i < abc.Length; i++) {
			int tt = i + 1;
			abc[i].Checked += (o, _) => _SetTriggerType((TriggersType)tt, false);
		}
		
		if (selectTriggersType > 0) {
			_SetTriggerType(tType, false);
			//_NextPage();
		}
		
		void _SetTriggerType(TriggersType tt, bool startup) {
			if (!startup) {
				if (!_CodeAnalysis.IsNonStandardFileWithTriggers())
					TriggersAndToolbars.Edit($@"Triggers\{aTriggersTypeStrings[(int)tt - 1]} triggers.cs");
				tType = tt;
			}
			bool enable = tType > 0;
			if (enable) {
				info.aaaText = tType switch {
					TriggersType.Window => $"""
Now in code click where to insert the new trigger.
Then click Next, capture window, Next, set trigger properties, OK.
""",
					TriggersType.Autotext => $"""
Now in code click where to insert the new trigger.
Then click Next, set trigger properties, OK.
In code edit the replacement text. Can use [[|]] to move the caret.
To set trigger scope window can be used {App.Settings.hotkeys.tool_quick}.
""",
					_ => $"""
Now in code click where to insert the new trigger.
Then click Next, set trigger properties, OK.
To set trigger scope window can be used {App.Settings.hotkeys.tool_quick}.
"""
				} + "\r\nFinally click Run to [re]start the triggers script.";
				
				var scriptRun = $"o => script.run(@\"{(canRunThisScript ? fn.ItemPathOrName() : "script.cs")}\")";
				string[] a = tType switch {
					TriggersType.Autotext => [
						"""o => o.Replace("replacement")""",
						""""o => o.Replace("""multiline replacement""")"""",
						//"\"replacement\"", "\"\"\"multiline replacement\"\"\"", //rejected. Just another way to do the same, which is better to avoid. It has sense only when users manually write code.
						"""o => o.Menu("one", "two", new("Label3", "three"))""",
						"o => { print.it(o); }",
						scriptRun],
					TriggersType.Window => [
						"""o => { print.it("Trigger", o.Window); }""",
						"""o => { <close window> }""",
						scriptRun],
					_ => [
						"o => { print.it(o); }",
						scriptRun]
				};
				lbAction.ItemsSource = a;
				lbAction.SelectedIndex = 0;
			}
			info.Visibility = enable ? Visibility.Visible : Visibility.Hidden;
			lbAction.Visibility = enable ? Visibility.Visible : Visibility.Hidden;
			bNext.IsEnabled = enable;
		}
		
		if (!w.ShowAndWait(owner)) return;
		
		_CodeAnalysis.MoveCaretForNewTriggerOrScope();
		string ttVar = _CodeAnalysis.GetTriggersVar(tType);
		
		string s = null, sAction = ((string)lbAction.SelectedItem)[5..];
		
		if (tType == TriggersType.Hotkey) {
			s = hotkeyTriggerPage.FormatCode(sAction, ttVar);
		} else if (tType == TriggersType.Autotext) {
			sAction = sAction.Replace("multiline replacement", "\r\n\r\n");
			s = autotextTriggerPage.FormatCode(sAction, ttVar);
		} else if (tType == TriggersType.Mouse) {
			s = mouseTriggerPage.FormatCode(sAction, ttVar);
		} else if (tType == TriggersType.Window) {
			sAction = sAction.Replace(" <close window> ", """

	print.it("Closing window", o.Window);
	//examples:
	//o.Window.Close();
	//o.Window.ButtonClick("Save");
	//keys.send("Enter");
	//keys.send("Esc");
	//keys.send("Alt+S");

""");
			s = windowTriggerWindowPage.AaResultCode ?? "\"`|`\"";
			s = windowTriggerSettingsPage.FormatCode(s, sAction, ttVar);
		}
		
		InsertCode.Statements(new(s, goTo: true));
		if (s.Contains("`|`")) {
			CodeInfo.ShowSignature();
			if (tType == TriggersType.Mouse) CodeInfo.ShowCompletionList();
		}
	}
	
	class _HotkeyTriggerPage : UserControl {
		KHotkeyControl _hk;
		EnumUI<TKFlags> _eFlags;
		KCheckBox _cAlwaysEnabled;
		
		public _HotkeyTriggerPage() {
			var b = new wpfBuilder(this);
			b.R.Add(_hk = new(true));
			b.R.StartStack<KGroupBox>(EdWpf.TextAndHelp<TKFlags>("<b>Flags</b>"), true);
			_eFlags = new(b.Panel, items: [
				(TKFlags.ShareEvent, "ShareEvent - let other apps receive the key"),
				(TKFlags.KeyModUp, "KeyModUp - delay until the trigger keys are released"),
				(TKFlags.NoModOff, "NoModOff - don't release modifier keys"),
				(TKFlags.LeftMod, "LeftMod - left-side modifier keys"),
				(TKFlags.RightMod, "RightMod - right-side modifier keys"),
				(TKFlags.Numpad, "NumpadOnly - only if the numpad key"),
				(TKFlags.NumpadNot, "NumpadNot - not if the numpad key"),
			]);
			
			var (cNumpadOnly, cNumpadNot) = (b.Panel.Children[b.Panel.Children.Count - 2] as CheckBox, b.Panel.Children[b.Panel.Children.Count - 1] as CheckBox);
			cNumpadOnly.Visibility = cNumpadNot.Visibility = Visibility.Collapsed;
			_hk.Changed += k_ => {
				if (k_ is { } k) {
					cNumpadOnly.IsChecked = cNumpadNot.IsChecked = false;
					cNumpadOnly.Visibility = cNumpadNot.Visibility = Visibility.Collapsed;
					if (k.Key is KKey.Enter or KKey.Home or KKey.End or KKey.PageUp or KKey.PageDown or KKey.Left or KKey.Right or KKey.Up or KKey.Down or KKey.Insert or KKey.Delete) {
						bool isNumpad = k.IsExtended == k.Key is KKey.Enter;
						var c = isNumpad ? cNumpadOnly : cNumpadNot;
						c.IsChecked = true;
						c.Visibility = Visibility.Visible;
					}
				}
			};
			
			b.End();
			b.R.Add(out _cAlwaysEnabled, "Always enabled");
			
			//rejected. Can be confusing. Despite all info, probably often woud be used incorrectly. Let use the scope tool separately.
			//b.R.AddButton("Scope...", o => {
			//	if (_TriggerScopeDialog(out var s, true, Window.GetWindow(this))) _scope = s;
			//}).Width(70);
		}
		
		public string FormatCode(string actionCode, string ttVar) {
			StringBuilder b = new();
			b.Append($"{ttVar}[\"{(_hk.Result ?? "`|`")}\"");
			
			var flags = _eFlags.Result;
			if (flags.Has(TKFlags.ExtendedYes | TKFlags.ExtendedNo)) flags &= ~(TKFlags.ExtendedYes | TKFlags.ExtendedNo);
			if (flags.Has(TKFlags.LeftMod | TKFlags.RightMod)) flags &= ~(TKFlags.LeftMod | TKFlags.RightMod);
			if (flags != 0) b.Append(", flags: ").Append(TUtil.FormatFlags(flags));
			
			b.Append($"] = o => {actionCode};");
			if (_cAlwaysEnabled.IsChecked) b.Append($"\r\n{ttVar}.Last.EnabledAlways = true;");
			return b.ToString();
		}
		
		public void FocusHotkey() {
			_hk.Focus();
		}
	}
	
	class _AutotextTriggerPage : UserControl {
		TextBox _tText;
		EnumUI<TAFlags> _eFlags;
		EnumUI<TAPostfix> _ePostfix;
		ComboBox _useFlags;
		(ComboBox use, ComboBox cb) _postfixType;
		(ComboBox use, TextBox t) _postfixChars;
		KCheckBox _cAlwaysEnabled;
		
		public _AutotextTriggerPage() {
			var b = new wpfBuilder(this).Columns(180, -1);
			b.R.Add<System.Windows.Documents.AdornerDecorator>().Child().Add(out _tText).Watermark("Trigger text");
			
			b.R.Add(out _useFlags).Span(1).Items("Use DefaultFlags|Use flags parameter|Set DefaultFlags");
			b.R.StartStack(out KGroupBox gFlags, EdWpf.TextAndHelp<TAFlags>("<b>Flags</b>"), true);
			_useFlags.SelectionChanged += (_, _) => { gFlags.Visibility = _useFlags.SelectedIndex > 0 ? Visibility.Visible : Visibility.Collapsed; };
			_eFlags = new EnumUI<TAFlags>(b.Panel, items: [
				(TAFlags.MatchCase, "MatchCase - case-sensitive"),
				(TAFlags.DontErase, "DontErase - don't erase the text when replacing"),
				(TAFlags.ReplaceRaw, "ReplaceRaw - don't modify the replacement text"),
				(TAFlags.RemovePostfix, "RemovePostfix - erase the postfix character when replacing"),
				(TAFlags.Confirm, "Confirm - show confirmation UI when replacing"),
				(TAFlags.ShiftLeft, "ShiftLeft - select text with Shift+Left when replacing"),
			]);
			b.End().Margin("L20 T").Hidden(null);
			
			b.R.Add(out _postfixType.use).Items("Use DefaultPostfixType|Use postfixType parameter|Set DefaultPostfixType");
			var help2 = EdWpf.TextAndHelp<TAPostfix>(null);
			b.Add(out _postfixType.cb).Hidden().And(16).Add(help2).Hidden();
			_postfixType.use.SelectionChanged += (_, _) => { var v = _postfixType.use.SelectedIndex > 0 ? Visibility.Visible : Visibility.Hidden; _postfixType.cb.Visibility = help2.Visibility = v; };
			_ePostfix = new(_postfixType.cb);
			
			b.R.Add(out _postfixChars.use).Items("Use DefaultPostfixChars|Use postfixChars parameter|Set DefaultPostfixChars");
			b.Add(out _postfixChars.t).Hidden().Tooltip("Postfix characters used when postfix type is Char or CharOrKey (default). Default - non-word characters.\nUse \\t and \\r for Tab and Enter.");
			_postfixChars.use.SelectionChanged += (_, _) => { _postfixChars.t.Visibility = _postfixChars.use.SelectedIndex > 0 ? Visibility.Visible : Visibility.Hidden; };
			
			b.R.Add(out _cAlwaysEnabled, "Always enabled").Span(-1);
			
			b.R.xAddInfoBlockF($"""
<a {() => HelpUtil.AuHelp("Au.Triggers.AutotextTriggers.Item")}>Trigger help</a>
Also in code you can set PostfixKey, WordCharsPlus and MenuOptions.
""").Span(-1);
		}
		
		public string FormatCode(string actionCode, string ttVar) {
			StringBuilder b = new($"{ttVar}[\"");
			var s = _tText.Text;
			if (s.Length == 0) s = "`|`"; else s = s.Escape();
			b.Append(s).Append('"');
			
			if (_useFlags.SelectedIndex is int useFlags && useFlags > 0) {
				s = TUtil.FormatFlags(_eFlags.Result);
				if (useFlags == 2) b.Insert(0, $"{ttVar}.DefaultFlags = {s};\r\n");
				else if (s == "0") b.Append(", flags: ").Append(s);
				else b.Append(", ").Append(s);
			}
			
			if (_postfixType.use.SelectedIndex is int usePT && usePT > 0) {
				s = "TAPostfix." + _postfixType.cb.Text;
				if (usePT == 1) b.Append(", postfixType: ").Append(s);
				else b.Insert(0, $"{ttVar}.DefaultPostfixType = {s};\r\n");
			}
			
			if (_postfixChars.use.SelectedIndex is int usePC && usePC > 0) {
				s = _postfixChars.t.Text;
				if (s.Contains("\\n") && !s.Contains("\\r")) s = s.Replace("\\n", "\\r"); //for newline need \r, not \n
				s = s.Unescape().Escape(quote: true);
				if (usePC == 1) b.Append(", postfixChars: ").Append(s);
				else b.Insert(0, $"{ttVar}.DefaultPostfixChars = {s};\r\n");
			}
			
			b.Append($"] = o => {actionCode};");
			if (_cAlwaysEnabled.IsChecked) b.Append($"\r\n{ttVar}.Last.EnabledAlways = true;");
			return b.ToString();
		}
		
		public void FocusText() {
			_tText.Focus();
		}
	}
	
	class _MouseTriggerPage : UserControl {
		int _kind;
		EnumUI<TMKind> _eKind;
		ComboBox[] _acb = new ComboBox[4];
		KScreenComboBox _cbScreen;
		KHotkeyControl _hkMod;
		EnumUI<TMFlags> _eFlags;
		KCheckBox _cAlwaysEnabled;
		
		public _MouseTriggerPage() {
			var b = new wpfBuilder(this).Columns(100, 150, 0, 10, -1);
			
			b.R.Add(out ComboBox cbKind);
			_eKind = new(cbKind);
			cbKind.SelectedIndex = _kind = -1;
			
			for (int i = 0; i < 4; i++) {
				Type t = i switch { 0 => typeof(TMClick), 1 => typeof(TMWheel), 2 => typeof(TMEdge), _ => typeof(TMMove) };
				_acb[i] = new() { Padding = cbKind.Padding, ItemsSource = t.GetEnumNames() };
			}
			b.Add(out ContentControl cc);
			var tHelp1 = EdWpf.TextAndHelp(null, () => (_kind switch { /*0 => typeof(TMClick), 1 => typeof(TMWheel),*/ 2 => typeof(TMEdge), _ => typeof(TMMove) }).FullName);
			b.Add(tHelp1).Margin(0).Hidden();
			b.Skip().Add(out _cbScreen).Hidden();
			_cbScreen.Items.Add("screen.ofMouse");
			
			cbKind.SelectionChanged += (_, _) => {
				_kind = cbKind.SelectedIndex;
				cc.Content = _acb[_kind];
				var vis = _kind >= 2 ? Visibility.Visible : Visibility.Hidden;
				tHelp1.Visibility = vis; //don't need help for click and wheel enums
				_cbScreen.Visibility = vis;
			};
			
			b.R.Add(_hkMod = new(true, true));
			b.R.StartStack<KGroupBox>(EdWpf.TextAndHelp<TMFlags>("<b>Flags</b>"), true);
			_eFlags = new EnumUI<TMFlags>(b.Panel, items: [
				(TMFlags.ShareEvent, "ShareEvent - let other apps receive the click/wheel event"),
				(TMFlags.ButtonModUp, "ButtonModUp - delay until the button and keys are released"),
				(TMFlags.LeftMod, "LeftMod - left-side modifier keys"),
				(TMFlags.RightMod, "RightMod - right-side modifier keys"),
			]);
			b.End();
			
			b.R.Add(out _cAlwaysEnabled, "Always enabled").Span(2);
		}
		
		public string FormatCode(string actionCode, string ttVar) {
			StringBuilder b = new($"{ttVar}[TM");
			if (_kind < 0) {
				b.Append("`|`");
			} else {
				var kind = _eKind.Result;
				b.Append(kind).Append('.');
				var s = _acb[_kind].Text;
				b.Append(s.NE() ? "`|`" : s);
			}
			
			if (_hkMod.Result is string sMod) b.Append(", \"").Append(sMod).Append('"');
			
			var flags = _eFlags.Result;
			if (flags.Has(TMFlags.LeftMod | TMFlags.RightMod)) flags &= ~(TMFlags.LeftMod | TMFlags.RightMod);
			if (flags != 0) b.Append(", flags: ").Append(TUtil.FormatFlags(flags));
			
			if (_kind >= 2 && _cbScreen.Result(true) is string sScreen) b.Append(", screen: ").Append(sScreen);
			
			b.Append($$"""] = o => {{actionCode}};""");
			if (_cAlwaysEnabled.IsChecked) b.Append($"\r\n{ttVar}.Last.EnabledAlways = true;");
			return b.ToString();
		}
	}
	
	class _WindowTriggerSettingsPage : UserControl {
		ListBox _lbEvent, _lbWhen;
		KCheckBox _cAtStartup, _cAlwaysEnabled;
		Panel _pLater;
		EnumUI<TWLater> _later;
		
		public _WindowTriggerSettingsPage() {
			var b = new wpfBuilder(this).Columns(0, -1, 10, 0, -1);
			
			b.R.Add("Event", out _lbEvent).Items("Window active|Window visible");
			b.Skip().Add("When", out _lbWhen).Items("New window|Once per window|Every time").Select(0);
			b.R.Add(out _cAtStartup);
			_lbEvent.SelectionChanged += (o, e) => _cAtStartup.Content = $"Run the action at startup if the window then is {(_lbEvent.SelectedIndex == 0 ? "active" : "visible")}";
			_lbEvent.SelectedIndex = 0;
			b.R.Add(out _cAlwaysEnabled, "Always enabled");
			
			b.R.StartGrid<KGroupBox>(EdWpf.TextAndHelp<TWLater>("<b>Events later in that window</b>")).Columns(0, 0, 0, -1);
			_later = new EnumUI<TWLater>(_pLater = b.Panel);
			b.End();
			
			b.End();
		}
		
		public string FormatCode(string wndFindArgs, string actionCode, string ttVar) {
			StringBuilder b = new($"{ttVar}[TWEvent.");
			b.Append(_lbEvent.SelectedIndex == 0 ? "Active" : "Visible").Append(_lbWhen.SelectedIndex switch { 0 => "New", 1 => "Once", _ => null });
			b.Append(", ").Append(wndFindArgs);
			if (_cAtStartup.IsChecked) b.Append(", flags: TWFlags.RunAtStartup");
			var later = _later.Result;
			if (later != 0) b.Append(", later: ").Append(TUtil.FormatFlags(later));
			b.Append("] = o => ");
			
			if (later == 0) {
				b.Append(actionCode).Append(';');
			} else {
				b.Append($$"""
{
	if (o.Later is 0) {
		{{actionCode.Trim(" {};")}};
	}
""");
				foreach (CheckBox c in _pLater.Children) {
					if (c.IsChecked == true) b.Append($$"""
 else if (o.Later is TWLater.{{c.Content}}) {
		print.it("later: {{c.Content}}");
	}
""");
				}
				b.Append("\r\n};");
			}
			
			if (_cAlwaysEnabled.IsChecked) b.Append($"\r\n{ttVar}.Last.EnabledAlways = true;");
			return b.ToString();
		}
	}
	
	static bool _TriggerScopeDialog(out string result, wnd wnd) {
		result = null;
		
		var tt = _CodeAnalysis.GetTriggersType();
		if (tt == TriggersType.Window) {
			dialog.showInfo("Trigger scope", "Scopes are not used with window triggers. Only with hotkey, autotext and mouse triggers.");
			return false;
		}
		
		var w = new KDialogWindow() { Title = "Trigger scope", Topmost = true };
		var b = new wpfBuilder(w).WinSize(500, 350).Columns(0, 0, -1);
		b.R.Add(out DPwnd pwnd).Margin("L T R B6");
		List<string> a = new();
		b.R.AddButton("Add more windows", _ => {
			if (pwnd.HasResult) a.Add(pwnd.AaResultCode);
			pwnd.Clear();
		}).Tooltip("Add another window to the scope");
		b.Add(out KCheckBox cNot, "Not").Tooltip("Triggers will NOT work when the window is active");
		b.StartOkCancel();
		if (tt == 0) {
			b.Add("File", out ComboBox cbOpen).Width(80).Items("|Hotkey|Autotext|Mouse");
			cbOpen.SelectionChanged += (_, _) => {
				int i = cbOpen.SelectedIndex;
				if (i > 0) {
					TriggersAndToolbars.Edit($@"Triggers\{(TriggersType)i} triggers.cs");
					b.Window.Hwnd().ActivateL();
				}
			};
		}
		b.AddOkCancel();
		b.End();
		b.Row(-1).Add(out KSciInfoBox info).Margin("T6");
		info.aaaText = """
This tool will add a new <+recipe>trigger scope<> statement in code. Triggers defined below it will work only when the window is active.

Please make sure the text cursor is in correct place. The new scope statement will be inserted there. Or you can move it afterwards.
""";
		b.End();
		
		if (!wnd.Is0) pwnd.SetWnd(wnd);
		
		if (!w.ShowAndWait()) return false;
		
		var triggersVar = _CodeAnalysis.GetActionTriggersVar();
		var s = pwnd.HasResult ? pwnd.AaResultCode : null;
		if (s == null && a.Count == 0) {
			result = $"{triggersVar}.Of.AllWindows();";
		} else {
			if (a.Count > 0) {
				if (s != null) a.Add(s);
				a = a.Distinct().ToList();
				if (a.Count == 1) { s = a[0]; a.Clear(); }
			}
			StringBuilder f = new($"{triggersVar}.Of.");
			if (cNot.IsChecked) f.Append("Not");
			if (a.Count > 0) {
				f.Append("Windows([");
				for (int i = 0; i < a.Count; i++) {
					f.Append("\r\n\t").Append("new(").Append(a[i]).Append("),");
				}
				f.Append("\r\n]);");
			} else {
				f.Append("Window(").Append(s).Append(");");
			}
			result = f.ToString();
		}
		return true;
	}
	
	/// <summary>
	/// Inserts code statement for a window trigger or trigger scope.
	/// </summary>
	/// <param name="w"></param>
	/// <param name="action">0 trigger tool, 1 window scope, 2 program scope, 3 scope tool.</param>
	public static void QuickWindowTrigger(wnd w, int action) {
		if (action == 0) {
			NewTrigger(TriggersType.Window, w);
		} else {
			string s;
			if (action is 1 or 2) {
				var triggersVar = _CodeAnalysis.GetActionTriggersVar();
				if (action == 1) s = $"{triggersVar}.Of.Window({_WndFindArgs(w)});";
				else s = $"{triggersVar}.Of.Window(of: \"{w.ProgramName.Escape()}\");";
			} else {
				if (!_TriggerScopeDialog(out s, w)) return;
			}
			_CodeAnalysis.MoveCaretForNewTriggerOrScope();
			InsertCode.Statements(new(s));
		}
	}
	
	static string _WndFindArgs(wnd w) {
		var f = new TUtil.WindowFindCodeFormatter();
		f.RecordWindowFields(w, 0, false);
		return TUtil.ArgsFromWndFindCode(f.Format());
	}
}


================================================
FILE: Au.Editor/Triggers and toolbars/TT._CodeAnalysis.cs
================================================
extern alias CAW;

using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using CAW::Microsoft.CodeAnalysis.Shared.Extensions;

using CAW::Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.Text;
using Microsoft.CodeAnalysis.Shared.Extensions;
using Microsoft.CodeAnalysis.CSharp.Extensions;

using Au.Controls;
using System.Windows;
using System.Windows.Controls;

namespace LA;

partial class TriggersAndToolbars {
#if DEBUG
	public static void Test() {
		//var tt = _CodeAnalysis.GetTriggersType();
		//print.it(tt);
		//if (tt == 0) return;
		//print.it("-----");
		//print.it(_CodeAnalysis.GetTriggersVar(tt));
		
		//print.it(_CodeAnalysis.GetActionTriggersVar());
	}
#endif
	
	static class _CodeAnalysis {
		/// <summary>
		/// Called either to get triggers type (with tt 0) or triggers variable (with tt not 0). But always gets both, because not always can get just one.
		/// In current document looks for a variable of a triggers type. Or in current class looks for a field/property. Also can detect type if this is a standard triggers file.
		/// </summary>
		/// <returns>
		/// tType: if tt 0 - the detected type, or 0 if cannot detect; else tt.
		/// tVar: variable name (or like `triggers.Hotkey`), or null if tVar 0.
		/// onlyActionTriggers: true if tt 0 and found only an ActionTriggers variable.
		/// </returns>
		static (TriggersType tType, string tVar, bool onlyActionTriggers) _GetTriggersTypeOrVar(TriggersType tt) {
			if (!CodeInfo.GetContextAndDocument(out var cd, metaToo: true)) return default;
			var semo = cd.semanticModel;
			
			//Find a local variable of a triggers type (like HotkeyTriggers).
			//	Either nearest declaration, or a trigger like `variable[...]...`.
			//	Search upwards, enumerating sibling statements of current statement and its ancestors.
			//	If tt==0, find any type. Else find tt type.
			//	If not found, find an ActionTriggers variable declaration (for tVar like `triggers.Hotkey`).
			
			var tok = cd.syntaxRoot.FindToken(cd.pos);
			if (tok.IsKind(SyntaxKind.EndOfFileToken)) tok = tok.GetPreviousToken();
			var node = tok.Parent;
			if (node is MemberDeclarationSyntax and not GlobalStatementSyntax && cd.pos <= tok.SpanStart) node = (tok = tok.GetPreviousToken()).Parent;
			bool? andThis = null;
			string typeName = tt == 0 ? null : $"Au.Triggers.{tt}Triggers", actionTriggersVar = null;
			if (node is BlockSyntax) {
				SyntaxNode n1 = null;
				if (node.Span.ContainsInside(cd.pos)) n1 = tok.IsKind(SyntaxKind.CloseBraceToken) ? node.ChildNodes().LastOrDefault() : node.ChildNodes().FirstOrDefault();
				node = n1 ?? node.GetAncestor<StatementSyntax>();
			} else {
				node = node?.GetAncestorOrThis<StatementSyntax>();
				andThis = node is ExpressionStatementSyntax && (node.SpanStart <= cd.pos || tok.GetPreviousToken().IsKind(SyntaxKind.OpenBraceToken));
			}
			while (node != null) {
				foreach (var n in node.PreviousSiblings(andThis: andThis ?? node is ExpressionStatementSyntax)) {
					//CiUtil.PrintNode(n);
					if (n is LocalDeclarationStatementSyntax lds) {
						if (lds.Declaration.Variables.Count > 0 && _IsTriggersTypeVarNode(lds.Declaration.Type, out var varType)) {
							var s = lds.Declaration.Variables[0].Identifier.Text;
							if (varType != 0) return (varType, s, false);
							actionTriggersVar ??= s;
						}
					} else if (n is ExpressionStatementSyntax { Expression: AssignmentExpressionSyntax { RawKind: (int)SyntaxKind.SimpleAssignmentExpression } aes }) {
						if (aes.Left is ElementAccessExpressionSyntax ea && _IsTriggersTypeVarNode(ea.Expression, out var varType)) {
							if (varType != 0) return (varType, ea.Expression.ToString(), false);
						}
					}
				}
				
				node = node.Parent;
				if (node is BlockSyntax || node is not StatementSyntax) node = node?.GetAncestor<StatementSyntax>();
				andThis = null;
				
				//never mind: can be static func.
				//never mind: other kinds of local var declaration, eg out.
				
				bool _IsTriggersTypeVarNode(SyntaxNode varOrTypeExpr, out TriggersType varType) {
					if (semo.GetTypeInfo(varOrTypeExpr).Type is { } ty) {
						//print.it(ty, n);
						return _IsTriggersType(ty, out varType);
					}
					varType = 0;
					return false;
				}
			}
			
			//If standard triggers file, use the filename, and skip the "find field/property" code.
			if (tt == 0 || actionTriggersVar == null) {
				if (_IsStdTriggersFile(cd.sci.EFile) is var tts && tts != 0) {
					if (tt == 0) tt = tts;
					actionTriggersVar ??= "Triggers";
				}
			}
			
			//Find a field or property.
			actionTriggersVar ??= _FindActionTriggersPropertyOrField(semo, cd.pos);
			
			return (
				tt,
				tt == 0 ? null : (actionTriggersVar ?? "Triggers") + "." + tt,
				tt == 0 && actionTriggersVar != null
				);
			
			bool _IsTriggersType(ITypeSymbol ty, out TriggersType varType) {
				varType = 0;
				var s = ty.ToString();
				if (s.Like("Au.Triggers.*Triggers")) {
					if (tt == 0) {
						switch (s[12..^8]) {
						case "Hotkey": varType = TriggersType.Hotkey; return true;
						case "Autotext": varType = TriggersType.Autotext; return true;
						case "Mouse": varType = TriggersType.Mouse; return true;
						case "Window": varType = TriggersType.Window; return true;
						case "Action": return true;
						}
					} else {
						if (s == typeName) { varType = tt; return true; }
						if (s.Eq(12..^8, "Action")) return true;
					}
				} else if (s == "Au.Triggers.TASimpleReplace") {
					if (tt == 0) { varType = TriggersType.Autotext; return true; } //note: the variable will be incorrect, but we need only type
				}
				return false;
			}
		}
		
		static TriggersType _IsStdTriggersFile(FileNode fn) {
			if (fn?.IsClass == true) {
				int i = fn.Name.Eq(true, "Hotkey triggers.cs", "Autotext triggers.cs", "Mouse triggers.cs", "Window triggers.cs");
				if (i > 0 && fn.ItemPath.Eqi(@"\@Triggers and toolbars\Triggers\" + fn.Name)) return (TriggersType)i;
			}
			return 0;
		}
		
		static string _FindActionTriggersPropertyOrField(SemanticModel semo, int pos) {
			return CiUtil.EnumPropertiesAndFields(semo, pos).FirstOrDefault(o => o.GetMemberType().ToString() == "Au.Triggers.ActionTriggers")?.Name;
		}
		
		public static TriggersType GetTriggersType() {
			return _GetTriggersTypeOrVar(0).tType;
		}
		
		public static string GetTriggersVar(TriggersType tt) {
			Debug.Assert(tt != 0);
			return _GetTriggersTypeOrVar(tt).tVar ?? "Triggers." + tt;
		}
		
		public static string GetActionTriggersVar() {
			if (CodeInfo.GetContextAndDocument(out var cd)) {
				var semo = cd.semanticModel;
				if (CiUtil.GetLocalVariablesAt(semo, cd.pos, o => o.ToString() == "Au.Triggers.ActionTriggers").FirstOrDefault() is { } localSym) return localSym.Name;
				if (_FindActionTriggersPropertyOrField(semo, cd.pos) is { } pf) return pf;
			}
			return "Triggers";
		}
		
		public static bool IsNonStandardFileWithTriggers() {
			if (App.Model.CurrentFile is not { } f) return false;
			if (_IsStdTriggersFile(f) != 0) return false;
			var v = _GetTriggersTypeOrVar(0);
			return v.tType != 0 || v.onlyActionTriggers;
		}
		
		/// <summary>
		/// If current document is a standard triggers file, moves caret to a place where a new trigger can be inserted (if need).
		/// </summary>
		/// <returns>true if caret was in a correct place or if moved. false if not a standard triggers file.</returns>
		public static bool MoveCaretForNewTriggerOrScope() {
			if (!CodeInfo.GetContextAndDocument(out var cd, metaToo: true)) return false;
			var semo = cd.semanticModel;
			
			var programSym = semo.Compilation.GlobalNamespace.GetTypeMembers("Program").FirstOrDefault();
			var attrSym = programSym?.GetTypeMembers("TriggersAttribute").FirstOrDefault();
			if (attrSym == null) return false;
			
			var m = semo.GetEnclosingSymbol<IMethodSymbol>(cd.pos, default);
			while (m != null && !m.IsOrdinaryMethod()) m = m.ContainingSymbol as IMethodSymbol;
			
			if (m != null && _HasTriggersAttribute(m)) return true;
			m = programSym.GetMembers().OfType<IMethodSymbol>().FirstOrDefault(o => o.Locations[0].SourceTree == semo.SyntaxTree && _HasTriggersAttribute(o));
			if (m == null) return false; //this file has no methods with [Triggers]
			
			if (m.Locations[0].FindNode(default) is MethodDeclarationSyntax md) {
				var last = md.Body.Statements.OfType<ExpressionStatementSyntax>().LastOrDefault(o => o.Expression is AssignmentExpressionSyntax { Left: ElementAccessExpressionSyntax eae });
				if (last != null) cd.pos = last.FullSpan.End;
				else if (md.Body.Statements.OfType<IfStatementSyntax>().FirstOrDefault() is { } firstIf) cd.pos = firstIf.FullSpan.Start;
				else cd.pos = md.Body.CloseBraceToken.SpanStart;
				
				cd.sci.aaaGoToPos(true, cd.pos);
			}
			
			return true;
			
			bool _HasTriggersAttribute(IMethodSymbol m) => m.GetAttributes().Any(o => o.AttributeClass == attrSym);
		}
		
	}
	
	public record struct FoundTrigger(FileNode file, int pos, string type, string trigger, string scope);
	
	public static async Task<List<FoundTrigger>> FindTriggersInCodeAsync(FileNode thisFile) {
		if (thisFile?.IsCodeFile != true) return null;
		
		var ttFolder = GetProject(create: false);
		if (ttFolder == null) return null;
		
		List<FoundTrigger> aResults = new();
		string nameCs = thisFile.Name, nameNoCs = thisFile.DisplayName, parentDir = thisFile.ItemPath[..^nameCs.Length];
		
		using var ws = new CiWorkspace(ttFolder, CiWorkspace.Caller.OtherPR);
		await Task.Run(_Work);
		return aResults;
		
		void _Work() {
			var comp = ws.GetCompilation();
			
			INamedTypeSymbol
				ntHotkey = comp.GetTypeByMetadataName("Au.Triggers.HotkeyTriggers"),
				ntAutotext = comp.GetTypeByMetadataName("Au.Triggers.AutotextTriggers"),
				ntMouse = comp.GetTypeByMetadataName("Au.Triggers.MouseTriggers"),
				ntWindow = comp.GetTypeByMetadataName("Au.Triggers.WindowTriggers"),
				ntToolbar = comp.GetTypeByMetadataName("Au.toolbar"),
				ntMenu = comp.GetTypeByMetadataName("Au.popupMenu"),
				ntTriggerArgs = comp.GetTypeByMetadataName("Au.Triggers.TriggerArgs"),
				ntMTItem = comp.GetTypeByMetadataName("Au.Types.MTItem"),
				ntScopes = comp.GetTypeByMetadataName("Au.Triggers.TriggerScopes");
			
			INamedTypeSymbol ntTriggersAttribute = null, ntToolbarsAttribute = null;
			if (comp.GlobalNamespace.GetTypeMembers("Program").FirstOrDefault() is { } symProgram) {
				ntTriggersAttribute = symProgram.GetTypeMembers("TriggersAttribute").FirstOrDefault();
				ntToolbarsAttribute = symProgram.GetTypeMembers("ToolbarsAttribute").FirstOrDefault();
			}
			
			//var files = ws.Meta.CodeFiles.Zip(comp.SyntaxTrees, (cf, tree) => (cf: cf, tree: tree, semo: comp.GetSemanticModel(tree))).ToArray();
			var files = ws.Meta.CodeFiles.Zip(comp.SyntaxTrees, (f, tree) => (cf: f, tree: tree, semo: f.isC ? null : comp.GetSemanticModel(tree))).Where(o => !o.cf.isC).ToArray(); //skip meta c and global.cs
			
			foreach (var (cf, tree, semo) in files) {
				//print.it($"<><lc greenyellow>{cf.f}<>");
				var root = tree.GetCompilationUnitRoot();
				
				//look for strings equal to the script name or path
				foreach (var tok in root.DescendantTokens()) {
					var tk = tok.Kind();
					if (tk is SyntaxKind.StringLiteralToken or SyntaxKind.SingleLineRawStringLiteralToken or SyntaxKind.InterpolatedStringTextToken) {
						var s = tok.ValueText;
						string sn;
						if (s.Ends(sn = nameCs, true) || s.Ends(sn = nameNoCs, true)) {
							if (s.Length - sn.Length is int j && j > 0) if (j != parentDir.Length || !s.Starts(parentDir, true)) continue;
							
							int found = 0;
							_GetTrigger(tok.Parent, semo, cf, 0, false, ref found);
							
							//if trigger not found, add as string
							if (found == 0) {
								var n = tok.Parent; if (tk == SyntaxKind.InterpolatedStringTextToken) n = n.Parent;
								if (n.GetAncestors().FirstOrDefault(o => o is StatementSyntax or ArrowExpressionClauseSyntax) is { } ss) {
									//var scope = semo.GetEnclosingSymbol(ss.SpanStart)?.Name; //empty if lambda
									var scope = ss.GetAncestor<MemberDeclarationSyntax>() switch { MethodDeclarationSyntax k => k.Identifier.Text, PropertyDeclarationSyntax k => k.Identifier.Text, EventDeclarationSyntax k => k.Identifier.Text, _ => null };
									aResults.Add(new(cf.f, n.SpanStart, null, ss.ToString(), scope));
								}
							}
						}
					}
				}
			}
			
			//If node is in a trigger action, finds the trigger statement and gets the triggers type.
			//If found, adds to the _FindTriggerResult list.
			void _GetTrigger(SyntaxNode node, SemanticModel semo, MCCodeFile cf, int level, bool inFuncOfTriggersActionType, ref int result) {
				for (var n = node; n != null; n = n.Parent) {
					if (n is LocalFunctionStatementSyntax) {
						if (level < 5 && semo.GetDeclaredSymbol(n) is IMethodSymbol ims && n.GetAncestor<BlockSyntax>() is { } scope) {
							_FuncReferences(ims, scope, semo, cf, level, ref result);
						}
						break;
					} else if (n is MethodDeclarationSyntax) {
						if (level < 5 && semo.GetDeclaredSymbol(n) is IMethodSymbol ims) {
							if (ntTriggersAttribute != null && ims.GetAttributes().Any(o => o.AttributeClass == ntTriggersAttribute || o.AttributeClass == ntToolbarsAttribute)) break;
							foreach (var v in files) {
								_FuncReferences(ims, v.tree.GetCompilationUnitRoot(), v.semo, v.cf, level, ref result);
							}
						}
						break;
					} else if (n is AnonymousFunctionExpressionSyntax) {
						inFuncOfTriggersActionType = _IsFuncOfTriggersActionType(semo.GetSymbolInfo(n).Symbol as IMethodSymbol);
					} else if (!inFuncOfTriggersActionType) {
						//is it a toolbar/menu label?
						bool isLabel = n is BracketedArgumentListSyntax;
						if (!isLabel && n is InvocationExpressionSyntax { Expression: MemberAccessExpressionSyntax maes }) {
							//probably `script.run("theString")`, but can be eg `toolbarOrMenu.Add("theString")`
							var ty = semo.GetTypeInfo(maes.Expression).Type;
							isLabel = ty == ntToolbar || ty == ntMenu || ty == ntHotkey || ty == ntAutotext || ty == ntMouse || ty == ntWindow;
						}
						if (isLabel) { result |= 2; break; }
					} else if (n is InvocationExpressionSyntax or AssignmentExpressionSyntax { Left: ElementAccessExpressionSyntax }) {
						ExpressionSyntax expr = null;
						BaseArgumentListSyntax arglist = null;
						if (n is AssignmentExpressionSyntax { Left: ElementAccessExpressionSyntax eaes }) { //`t[...] = ...`
							expr = eaes.Expression;
							arglist = eaes.ArgumentList;
						} else if (n is InvocationExpressionSyntax { Expression: MemberAccessExpressionSyntax maes } ies) { //maybe `t.Add(...)` or `t.Menu(...)`
							expr = maes.Expression;
							arglist = ies.ArgumentList;
						} else continue;
						
						if (semo.GetTypeInfo(expr).Type is { } ty) {
							string triggersType = null;
							if (ty == ntHotkey || ty == ntAutotext || ty == ntMouse || ty == ntWindow) {
								triggersType = ty.Name[..^8];
							} else if (ty == ntToolbar) {
								triggersType = "Toolbar";
							} else if (ty == ntMenu) { //a submenu of a toolbar?
								foreach (var v in n.GetAncestors<InvocationExpressionSyntax>()) {
									if (v.Expression is MemberAccessExpressionSyntax maes && semo.GetTypeInfo(maes.Expression).Type is { } ty2) {
										if (ty2 == ntToolbar) { triggersType = "Toolbar"; break; }
									}
								}
							}
							
							if (triggersType != null) {
								var args = arglist.Arguments;
								string arguments = null, scope = null;
								if (ty == ntToolbar || ty == ntMenu) {
									if (n.GetAncestor<MethodDeclarationSyntax>() is { } mds) arguments = mds.Identifier.Text;
									else arguments = args[0].ToString();
								} else {
									arguments = args.ToString();
									if (ty != ntWindow) scope = _GetScope(n, semo);
									//funcOf = _GetFuncOf(n, semo);
								}
								
								aResults.Add(new(cf.f, args[0].SpanStart, triggersType, arguments, scope));
								result |= 1;
								break;
							}
						}
					}
				}
			}
			
			void _FuncReferences(IMethodSymbol ims, SyntaxNode scope, SemanticModel semo, MCCodeFile cf, int level, ref int found) {
				var range = scope.Span;
				string name = ims.Name, code = cf.code;
				bool? isOfTriggersActionType = null;
				for (int i = range.Start; ; i += name.Length) {
					i = code.Find(name, i..range.End);
					if (i < 0) break;
					if (!SyntaxFacts.IsIdentifierPartCharacter(code.At_(i - 1)) && !SyntaxFacts.IsIdentifierPartCharacter(code.At_(i + name.Length))) {
						var tok = scope.FindToken(i);
						if (tok.SpanStart != i || tok.Parent is not IdentifierNameSyntax) continue; //info: also skips the declaration, because it's not IdentifierNameSyntax
						var sym2 = semo.GetSymbolInfo(tok.Parent).Symbol;
						if (sym2 != ims) continue;
						var node = tok.Parent.Parent;
						if (node is InvocationExpressionSyntax or AssignmentExpressionSyntax or ArgumentSyntax) {
							bool tat = node is InvocationExpressionSyntax ? false : (isOfTriggersActionType ??= _IsFuncOfTriggersActionType(ims));
							_GetTrigger(node, semo, cf, level + 1, tat, ref found);
						}
					}
				}
			}
			
			bool _IsFuncOfTriggersActionType(IMethodSymbol ims) {
				if (ims != null && ims.ReturnsVoid && ims.Parameters.Length == 1 && !ims.IsGenericMethod && ims.Parameters[0] is { RefKind: RefKind.None, Type: { BaseType: var t2 } t1 }) {
					if (t2 == ntTriggerArgs || t1 == ntTriggerArgs || t2 == ntMTItem || t1 == ntMTItem) return true;
				}
				return false;
			}
			
			string _GetScope(SyntaxNode node, SemanticModel semo) {
				foreach (var stat in _EnumStatementsUp(node)) {
					if (stat is ExpressionStatementSyntax { Expression: InvocationExpressionSyntax { Expression: MemberAccessExpressionSyntax maes } ies }) {
						if (maes.Name.Identifier.Text is string s1 && s1 is "Window" or "Windows" or "Again" or "AllWindows") {
							if (semo.GetTypeInfo(maes.Expression).Type == ntScopes) {
								if (s1 == "AllWindows") return null;
								return s1 + ies.ArgumentList;
							}
						}
					}
				}
				return null;
			}
			
			//rejected. Need much more code to detect whether NextTrigger would be applied to this trigger. Can be unreliable.
			//string _GetFuncOf(SyntaxNode node, SemanticModel semo) {
			//	foreach (var stat in _EnumStatementsUp(node)) {
			//		if (stat is ExpressionStatementSyntax { Expression: AssignmentExpressionSyntax { Left: MemberAccessExpressionSyntax maes } aes }) {
			//			if (maes.Name.Identifier.Text is string s1 && s1 is "FollowingTriggers" or "FollowingTriggersBeforeWindow" or "NextTrigger" or "NextTriggerBeforeWindow") {
			//				if (semo.GetTypeInfo(maes.Expression).Type == ntFuncs) {
			//					if (aes.Right is LiteralExpressionSyntax) return null; // `= null`
			//					return aes.Right.ToString();
			//				}
			//			}
			//		}
			//	}
			//	return null;
			//}
			
			IEnumerable<StatementSyntax> _EnumStatementsUp(SyntaxNode n) {
				while (n.GetAncestorOrThis<StatementSyntax>() is { } stat) {
					foreach (var v in stat.PreviousSiblings()) {
						if (v is StatementSyntax ss) {
							yield return ss;
						} else {
							Debug_.Print(v);
							break;
						}
					}
					n = stat.Parent;
					if (n is BlockSyntax { Parent: not BlockSyntax }) n = n.Parent;
				}
			}
		}
	}
	
	/// <summary>
	/// Returns true if <i>f</i> is <c>@"\@Triggers and toolbars\Triggers and toolbars.cs"</c>.
	/// </summary>
	public static bool IsTtScipt(FileNode f) {
		return f != null && f.IsCodeFile && f.Name.Eqi("Triggers and toolbars.cs") && f.Parent.Name.Eqi("@Triggers and toolbars") && f.Parent.Parent.Parent == null;
	}
	
	public static async Task<List<FoundTrigger>> FindAllTriggersAsync(FileNode thisFile) {
		if (!thisFile.IsExecutableDirectly()) return null;
		
		//action triggers
		var ar = await FindTriggersInCodeAsync(thisFile) ?? new();
		
		//scheduler
		if (await WinScheduler.GetScriptTriggersAsync(thisFile) is { } ast) {
			foreach (var v in ast) {
				ar.Add(new(null, -1, "Scheduled", v.trigger, v.task));
			}
		}
		
		//startup script
		foreach (var v in App.Model.GetStartupScriptsExceptDisabled()) {
			if (v.f == thisFile) {
				ar.Add(new(null, -1, "Startup", "When this workspace loaded", null));
				break;
			}
		}
		
		//test script
		foreach (var v in App.Model.Root.Descendants()) {
			if (v.TestScript == thisFile) {
				ar.Add(new(v, -1, "Test script", v.Name, null));
			}
		}
		
		//rejected: preBuid/postBuild, shortcut
		
		return ar;
	}
	
	public static async void AllTriggersMenu(FileNode thisFile) {
		if (thisFile == null) return;
		//if (thisFile.IsClass) thisFile = thisFile.GetProjectMainOrThis();
		var a = await FindAllTriggersAsync(thisFile);
		
		var p = new KPopupListBox { Placement = System.Windows.Controls.Primitives.PlacementMode.Mouse, PlacementTarget = App.Wmain };
		p.OK += o => {
			if (o is ListBoxItem { Tag: Action click }) click();
		};
		
		void _Add(string s, Action click = null) {
			var li = new ListBoxItem { Content = s };
			if (click != null) li.Tag = click; else li.IsEnabled = false;
			p.Control.Items.Add(li);
		}
		
		if (a == null) {
			_Add("This file isn't runnable as a script");
		} else if (a.Count == 0) {
			_Add("No triggers found");
		} else {
			int schedTrigger = 0;
			foreach (var v in a) {
				static string _Limit(string s) {
					if (s != null) {
						s = s.Replace("\t", "    ");
						//s = string.Join('\n', s.Lines(noEmpty: true).Select(o => o.Limit(200))); //don't need. WPF limits the window width to the work area and adds hscrollbar.
					}
					return s;
				}
				string trigger = _Limit(v.trigger), scope = _Limit(v.scope);
				if (v.file != null) {
					if (v.type == "Test script") {
						_Add($"{v.type} of {trigger}", () => App.Model.OpenAndGoTo(v.file));
					} else if (v.type == null) {
						_Add($"Found in {scope}:\n    {trigger}", () => App.Model.OpenAndGoTo(v.file, columnOrPos: v.pos));
					} else {
						var s = $"{v.type} {trigger}";
						if (scope != null) s += "\n    Scope: " + scope;
						_Add(s, () => App.Model.OpenAndGoTo(v.file, columnOrPos: v.pos));
					}
				} else if (v.type == "Scheduled") {
					int i = ++schedTrigger;
					_Add(trigger, () => DSchedule.ShowFor(thisFile, i));
				} else if (v.type == "Startup") {
					_Add(trigger, () => DOptions.AaShow(DOptions.EPage.Workspace));
				}
			}
		}
		
		p.IsOpen = true;
	}
}


================================================
FILE: Au.Editor/Triggers and toolbars/TriggersAndToolbars.cs
================================================
using System.Xml.Linq;
using Au.Triggers;

namespace LA;

partial class TriggersAndToolbars {
	public static bool Edit(string file) {
		var f = _GetFile(file, create: true);
		if (f == null) return false;
		return App.Model.OpenAndGoTo(f);
	}
	
	public static void GoToToolbars() {
		var folder = GetProject(create: true);
		folder = folder.Children().First(f => f.IsFolder && f.Name.Eqi("Toolbars"));
		
		folder.SelectSingle();
		var tv = Panels.Files.TreeControl;
		if (!folder.IsExpanded) tv.Expand(folder, true);
		tv.EnsureVisible(folder, scrollTop: true);
		
		//var m = new popupMenu();
		//foreach (var f in folder.Children()) {
		//	if (!f.IsClass) continue;
		//	m[f.DisplayName] = _ => App.Model.OpenAndGoTo(f);
		//}
		//m.Show();
	}
	
	/// <summary>
	/// Finds or creates project @"\@Triggers and toolbars".
	/// </summary>
	/// <param name="create">Create if does not exist.</param>
	/// <returns>The project folder. Returns null if does not exist and <i>create</i> false.</returns>
	public static FileNode GetProject(bool create) {
		var fProject = App.Model.Find(@"\@Triggers and toolbars", FNFind.Folder);
		if (create) {
			if (fProject == null) {
				fProject = App.Model.NewItemL(s_templPath);
				print.it("Info: folder \"@Triggers and toolbars\" has been created.");
			} else { //create missing files. Note: don't cache, because files can be deleted at any time. Fast enough.
				var xTempl = FileNode.Templates.LoadXml(s_templPath); //fast, does not load the xml file each time
				_Folder(xTempl, fProject);
				void _Folder(XElement xParent, FileNode fParent) {
					foreach (var x in xParent.Elements()) {
						bool isFolder = x.Name.LocalName == "d";
						string name = x.Attr("n");
						if (isFolder && (name == "Scripts" || name == "Functions")) continue;
						var ff = fParent.Children().FirstOrDefault(o => o.Name.Eqi(name));
						if (ff == null) {
							ff = App.Model.NewItemLX(x, new(fParent, FNInsert.Last));
						} else if (isFolder) {
							_Folder(x, ff);
						}
					}
				}
			}
			
			//set run at startup
			if (_GetFile(@"Triggers and toolbars.cs", create: false) is { } f) {
				if (App.Model.EnsureIsInStartupScripts(f, printAdded: false, usePath: true) is FilesModel.EISSResult.Added) {
					print.it($"<>Info: script \"{f.Name}\" has been added to <+options Workspace>Options > Workspace > Startup scripts<>. If unwanted, disable the line (prefix //)."); //disable, not delete, else next time would auto-add again
				}
			}
		}
		return fProject;
	}
	const string s_templPath = @"Default\@Triggers and toolbars";
	
	static FileNode _GetFile(string file, bool create, FNFind kind = FNFind.File) {
		var f = GetProject(create: create);
		return f?.FindRelative(false, file, kind);
	}
	
	public static void Restart() {
		var f = _GetFile(@"Triggers and toolbars.cs", create: false);
		if (f != null) CompileRun.CompileAndRun(true, f, runFromEditor: true);
	}
	
	/// <summary>
	/// Disables, enables or toggles triggers in all processes. See <see cref="ActionTriggers.DisabledEverywhere"/>.
	/// Also updates UI: changes tray icon and checks/unchecks the menu item.
	/// </summary>
	/// <param name="disable">If null, toggles.</param>
	public static void DisableTriggers(bool? disable) {
		bool dis = disable switch { true => true, false => false, _ => !ActionTriggers.DisabledEverywhere };
		if (dis == ActionTriggers.DisabledEverywhere) return;
		ActionTriggers.DisabledEverywhere = dis; //notifies us to update tray icon etc
	}
	
	//from ActionTriggers.DisabledEverywhere through our message-only window
	internal static void OnDisableTriggers() {
		bool dis = ActionTriggers.DisabledEverywhere;
		App.TrayIcon.Disabled = dis;
		if (App.Commands is { } ac) ac[nameof(Menus.TT.Disable_triggers)].Checked = dis;
	}
	
	//rejected
	//public static void ShowActiveTriggers() {
	//	var w = wnd.findFast(cn: "Au.Triggers.Hooks", messageOnly: true);
	//	if (!w.Is0) w.Post(Api.WM_USER + 2, -1);
	//}
	
	public static void ShowActiveToolbars() {
		foreach (var w in wnd.getwnd.allWindows().Where(o => o.ClassNameIs("Au.toolbar")).DistinctBy(o => o.ThreadId)) {
			Api.AllowSetForegroundWindow(w.ProcessId);
			w.Post(Api.WM_USER + 51);
		}
	}
	
	public static void NewToolbar() {
		var tt = new TriggersAndToolbars();
		tt._NewToolbar();
	}
	
	public static void SetToolbarTrigger() {
		var tt = new TriggersAndToolbars();
		tt._SetToolbarTrigger();
	}
}


================================================
FILE: Au.Editor/Triggers and toolbars/WinScheduler.cs
================================================
using System.Security.Principal;
using System.Xml.Linq;

namespace LA;

using api = WinSchedulerApi;
using TT = WinSchedulerApi.TASK_TRIGGER_TYPE2;

static class WinScheduler {
	static string _SidCurrentUser => WindowsIdentity.GetCurrent().User.ToString();
	//static string _SddlCurrentUserReadExecute => "D:AI(A;;FA;;;SY)(A;;FA;;;BA)(A;;GRGX;;;" + _SidCurrentUser + ")";
	static string _SddlCurrentUserReadExecute => "D:AI(A;;FA;;;SY)(A;;FA;;;BA)(A;;FA;;;" + _SidCurrentUser + ")";
	static string c_sddlEveryoneReadExecute = "D:AI(A;;FA;;;SY)(A;;FA;;;BA)(A;;GRGX;;;WD)";
	
	internal static bool Connect(out api.ITaskService ts) {
		try {
			ts = new api.TaskScheduler() as api.ITaskService;
			return 0 == ts.Connect();
		}
		catch { ts = null; return false; }
	}
	
	/// <summary>
	/// Creates or updates a trigerless task that executes a program as system, admin or user.
	/// Creates the folder (and ancestors) if does not exist.
	/// This process must be admin.
	/// You can use <see cref="RunTask"/> to run the task.
	/// </summary>
	/// <param name="IL">Can be System, High or Medium. If System, runs in SYSTEM account. Else in creator's account.</param>
	/// <param name="programFile">Full path of an exe file. This function does not normalize it.</param>
	/// <param name="args">Command line arguments. Can contain literal substrings $(Arg0), $(Arg1), ..., $(Arg32) that will be replaced by <see cref="RunTask"/>.</param>
	/// <returns>HRESULT.</returns>
	/// <inheritdoc cref="RunTask" path="/param"/>
	public static int CreateTaskWithoutTriggers(string taskFolder, string taskName, UacIL IL, string programFile, string args = null, string author = "Au", api.TASK_CREATION creation = api.TASK_CREATION.TASK_CREATE) {
		var xml = CreateXmlForNewTask(IL, programFile, args, author);
		return CreateTaskFromXml(taskFolder, taskName, xml, IL, creation);
	}
	
	/// <summary>
	/// Creates or updates a task using XML.
	/// Creates the folder (and ancestors) if does not exist.
	/// This process must be admin.
	/// You can use <see cref="RunTask"/> to run the task.
	/// </summary>
	/// <param name="IL">Can be System, High or Medium. If System, runs in SYSTEM account. Else in creator's account.</param>
	/// <returns>HRESULT.</returns>
	/// <inheritdoc cref="RunTask" path="/param"/>
	public static int CreateTaskFromXml(string taskFolder, string taskName, string xml, UacIL IL, api.TASK_CREATION creation = api.TASK_CREATION.TASK_CREATE) {
		return _CreateTask(taskFolder, taskName, xml, IL, creation);
	}
	
	/// <summary>
	/// Creates or updates a task using XML.
	/// Creates the folder (and ancestors) if does not exist.
	/// This process must be admin.
	/// You can use <see cref="RunTask"/> to run the task.
	/// </summary>
	/// <param name="IL">Can be System, High or Medium. If System, runs in SYSTEM account. Else in creator's account.</param>
	/// <returns>HRESULT.</returns>
	/// <inheritdoc cref="RunTask" path="/param"/>
	internal static int CreateTaskFromDefinition(string taskFolder, string taskName, api.ITaskDefinition td, UacIL IL, api.TASK_CREATION creation = api.TASK_CREATION.TASK_CREATE) {
		return _CreateTask(taskFolder, taskName, td, IL, creation);
	}
	
	static int _CreateTask(string taskFolder, string taskName, object tdOrXml, UacIL IL, api.TASK_CREATION creation = api.TASK_CREATION.TASK_CREATE) {
		if (!(IL is UacIL.High or UacIL.Medium or UacIL.System)) throw new ArgumentException();
		if (!Connect(out var ts)) return Api.E_FAIL;
		if (0 != ts.GetFolder(taskFolder, out var tf)) {
			int hr = ts.GetFolder(null, out tf);
			if (hr == 0) hr = tf.CreateFolder(taskFolder, c_sddlEveryoneReadExecute, out tf);
			if (hr != 0) return hr;
		} else if ((creation & api.TASK_CREATION.TASK_CREATE_OR_UPDATE) == api.TASK_CREATION.TASK_CREATE) {
			tf.DeleteTask(taskName, 0); //delete if exists. Note: TASK_CREATE_OR_UPDATE does not update task file's security.
		}
		var logonType = IL == UacIL.System ? api.TASK_LOGON_TYPE.TASK_LOGON_SERVICE_ACCOUNT : api.TASK_LOGON_TYPE.TASK_LOGON_INTERACTIVE_TOKEN;
		var sddl = IL == UacIL.System ? c_sddlEveryoneReadExecute : _SddlCurrentUserReadExecute;
		if (tdOrXml is api.ITaskDefinition td) {
			return tf.RegisterTaskDefinition(taskName, td, creation, null, null, logonType, sddl, out _);
		} else {
			return tf.RegisterTask(taskName, (string)tdOrXml, creation, null, null, logonType, sddl, out _);
		}
		
		//note: cannot create a task that runs only in current interactive session, regardless of user.
		//	Tried INTERACTIVE: userId "S-1-5-4", logonType TASK_LOGON_GROUP. But then runs in all logged in sessions.
	}
	
	/// <summary>
	/// Creates XML of a new trigerless task.
	/// </summary>
	/// <param name="IL">Can be System, High or Medium. If System, runs in SYSTEM account. Else in creator's account.</param>
	/// <param name="programFile">Full path of an exe file. This function does not normalize it.</param>
	/// <param name="args">Command line arguments. Can contain literal substrings $(Arg0), $(Arg1), ..., $(Arg32) that will be replaced by <see cref="RunTask"/>.</param>
	/// <param name="author"></param>
	public static string CreateXmlForNewTask(UacIL IL, string programFile, string args = null, string author = "Au") {
		if (!(IL is UacIL.High or UacIL.Medium or UacIL.System)) throw new ArgumentException();
		var userId = IL == UacIL.System ? "<UserId>S-1-5-18</UserId>\r\n" : null;
		var runLevel = IL switch { UacIL.System => null, UacIL.High => "<RunLevel>HighestAvailable</RunLevel>", _ => "<RunLevel>LeastPrivilege</RunLevel>" };
		return $"""
<?xml version='1.0' encoding='UTF-16'?>
<Task version='1.{(osVersion.minWin10 ? "4" : "3")}' xmlns='http://schemas.microsoft.com/windows/2004/02/mit/task'>

<RegistrationInfo>
<Author>{author}</Author>
</RegistrationInfo>

<Principals>
<Principal id='Author'>
{userId}{runLevel}
</Principal>
</Principals>

<Settings>
<MultipleInstancesPolicy>Parallel</MultipleInstancesPolicy>
<DisallowStartIfOnBatteries>false</DisallowStartIfOnBatteries>
<StopIfGoingOnBatteries>false</StopIfGoingOnBatteries>
<ExecutionTimeLimit>PT0S</ExecutionTimeLimit>
<Priority>5</Priority>
</Settings>

<Actions Context='Author'>
<Exec>
<Command>{programFile}</Command>
<Arguments>{args}</Arguments>
</Exec>
</Actions>

</Task>
""";
	}
	
	/// <summary>
	/// Runs task. Does not wait.
	/// </summary>
	/// <returns>Process id. Returns 0 if failed, eg if the task does not exist or is disabled.</returns>
	/// <param name="taskFolder">Can be like <c>@"\Folder"</c> or <c>@"\A\B"</c> or <c>"Folder"</c> or <c>@"\"</c> or <c>""</c> or null.</param>
	/// <param name="taskName">Can be like <c>"Name"</c> or <c>@"\Folder\Name"</c> or <c>@"Folder\Name"</c>.</param>
	/// <param name="pathMustBe">If not null, don't run if the task action's path does not match this.</param>
	/// <param name="joinArgs">Join args into single arg for $(Arg0).</param>
	/// <param name="args">Replacement values for substrings $(Arg0), $(Arg1), ..., $(Arg32) in 'create task' args. See <ms>IRegisteredTask.Run</ms>.</param>
	public static (int processId, RResult result) RunTask(string taskFolder, string taskName, string pathMustBe, bool joinArgs, params string[] args) {
		if (!Connect(out var ts)) return (0, RResult.CantConnect);
		if (0 != ts.GetFolder(taskFolder, out var tf) || 0 != tf.GetTask(taskName, out var t)) return (0, RResult.TaskNotFound);
		
		if (!t.Enabled) return (0, RResult.TaskDisabled);
		
		if (pathMustBe != null) {
			if (t.Definition.Actions.GetExecAction(1) is not { } action) return (0, RResult.BadTask);
			if (!filesystem.more.isSameFile(pathMustBe, action.Path)) return (0, RResult.BadPath);
		}
		
		object a; if (args.NE_()) a = null; else if (joinArgs) a = StringUtil.CommandLineFromArray(args); else a = args;
		if (0 != t.Run(a, out var rt)) return (0, RResult.RunFailed);
		rt.get_EnginePID(out int pid);
		return (pid, RResult.Success);
	}
	
	public enum RResult { None, Success, CantConnect, TaskNotFound, TaskDisabled, BadTask, BadPath, RunFailed, ArgN }
	
	/// <summary>
	/// Returns true if the task exists.
	/// </summary>
	/// <inheritdoc cref="RunTask" path="/param"/>
	public static bool TaskExists(string taskFolder, string taskName) {
		if (!Connect(out var ts)) return false;
		return 0 == ts.GetFolder(taskFolder, out var tf) && 0 == tf.GetTask(taskName, out _);
	}
	
	/// <summary>
	/// Deletes task if exists.
	/// This process must be admin.
	/// </summary>
	/// <inheritdoc cref="RunTask" path="/param"/>
	public static void DeleteTask(string taskFolder, string taskName) {
		if (!Connect(out var ts)) return;
		if (0 == ts.GetFolder(taskFolder, out var tf)) tf.DeleteTask(taskName, 0);
	}
	
	public static string EditorPath { get; set; } = process.thisExePath;
	
	public record struct FSTResult(api.IRegisteredTask rt, api.ITaskDefinition td, api.IExecAction action, string scriptArgs);
	
	public static bool FindScriptTask(string fileName, string itemPath, out FSTResult r) {
		r = default;
		if (Connect(out var ts)) {
			string user = Environment.UserName, thisExePath = EditorPath;
			if (0 == ts.GetFolder(@"Au\" + user, out var tf) && 0 == tf.GetTasks(api.TASK_ENUM_HIDDEN, out var tasks) && tasks.Count is int nTasks) {
				for (int i = 1; i <= nTasks; i++) {
					if (0 == tasks.get_Item(i, out var rtask) && rtask.Definition is { } td) {
						if (td.Actions is { Count: int nActions } actions) {
							for (int j = 1; j <= nActions; j++) {
								if (actions.GetExecAction(j) is { Arguments: var s } action && !s.NE()) {
									int start = 0, end;
									if (s[0] == '"') {
										end = s.IndexOf('"', start = 1);
									} else {
										end = s.IndexOf(' '); if (end < 0) end = s.Length;
									}
									if (s.At_(start) is '>' or '*') start++;
									if (end > start) {
										Range r1 = start..end;
										if (s.Eq(r1, fileName, true) || s.Eq(r1, itemPath, true)) {
											if (action.Path is string sp && filesystem.more.isSameFile(thisExePath, sp)) {
												string scriptArgs = null;
												if (end < s.Length) {
													if (s[end] == '"') end++;
													while (end < s.Length && s[end] == ' ') end++;
													if (end < s.Length) scriptArgs = s[end..];
												}
												r = new(rtask, td, action, scriptArgs);
												return true;
											}
										}
									}
								}
							}
						}
					}
				}
			}
		}
		return false;
	}
	
	/// <summary>
	/// Returns trigger strings of all found scheduler tasks that are set to run script <i>fn</i>.
	/// For a multi-trigger task returns multiple items.
	/// </summary>
	public static async Task<List<(string task, string trigger)>> GetScriptTriggersAsync(FileNode fn) {
		string name = fn.Name, itemPath = fn.ItemPath;
		List<(string task, string trigger)> ar = null;
		await Task.Run(_Work);
		return ar;
		
		void _Work() {
			StringBuilder b = null;
			if (FindScriptTask(name, itemPath, out var r)) {
				string taskName = r.rt.Name;
				foreach (var t in r.td.EnumTriggers()) {
					(b ??= new()).Clear();
					t.FormatTriggerString(b);
					(ar ??= new()).Add((taskName, b.ToString()));
				}
			}
		}
	}
	
	/// <summary>
	/// Opens Task Scheduler UI for task editing.
	/// This process must be admin.
	/// Starts task and returns.
	/// </summary>
	/// <param name="taskFolder">Task folder, like <c>@"A\B"</c>.</param>
	/// <param name="taskName">Task name (without path). If null, just opens the Task Scheduler folder.</param>
	public static void EditTask(string taskFolder, string taskName) {
		Task.Run(() => {
			//run Task Scheduler UI
			var w = wnd.runAndFind(
				() => run.it(folders.System + "mmc.exe", folders.System + "taskschd.msc", flags: RFlags.InheritAdmin),
				60, cn: "MMCMainFrame");
			
			//expand folder "Task Scheduler Library"
			var tv = w.Child(id: 12785);
			tv.Focus();
			var htvi = wait.until(5, () => tv.Send(api.TVM_GETNEXTITEM, api.TVGN_CHILD, tv.Send(api.TVM_GETNEXTITEM)));
			wait.until(10, () => 0 != tv.Send(api.TVM_EXPAND, api.TVE_EXPAND, htvi)); //note: don't wait for TVM_GETITEMSTATE TVIS_EXPANDED
			
			//open the specified folder
			var e = elm.fromWindow(tv, EObjid.CLIENT);
			e.Item = 2;
			taskFolder = taskFolder.Trim('\\').Replace('\\', '|');
			e.Expand(taskFolder, waitS: 10, notLast: true).Select();
			
			if (taskName == null) return;
			
			//open Properties dialog of the specified task
			var lv = w.Child(30, "***wfName listViewMain", "*.SysListView32.*"); //the slowest part, ~1 s
			lv.Elm["LISTITEM", taskName, flags: EFFlags.ClientArea | EFFlags.HiddenToo].Find(10).Select();
			lv.Post(Api.WM_KEYDOWN, (int)KKey.Enter);
			
			//wait for task Properties dialog and select tab "Trigger"
			var wp = wnd.find(10, taskName + "*", "*.Window.*", WOwner.Process(w.ProcessId));
			wp.Activate();
			var tc = wp.Child(5, cn: "*.SysTabControl32.*");
			tc.Send(api.TCM_SETCURFOCUS, 1);
			
			//never mind: the script may fail at any step, although on my computers never failed.
			//	Let it do as much as it can. It's better than nothing.
			//	Task.Run silently handles exceptions.
		});
	}
}

static class ExtScheduler {
	
	public static IEnumerable<api.ITrigger> EnumTriggers(this api.ITaskDefinition t) {
		if (t.Triggers is { Count: int nTriggers } triggers && nTriggers > 0) {
			for (int k = 1; k <= nTriggers; k++) {
				if (0 == triggers.get_Item(k, out var r)) yield return r;
			}
		}
	}
	
	public static string FormatTriggerString(this api.ITrigger t) {
		StringBuilder sb = new();
		FormatTriggerString(t, sb);
		return sb.ToString();
	}
	
	public static void FormatTriggerString(this api.ITrigger t, StringBuilder b) {
		if (!t.Enabled) b.Append("(disabled) ");
		var ttype = t.Type;
		if ((int)ttype is >= 1 and <= 5) {
			string sStart = t.StartBoundary;
			var (sStartDate, sStartTime) = SplitDateTime(sStart);
			b.Append($"At {sStartTime} ");
			
			switch (ttype) {
			case TT.TIME:
				b.Append($"on {sStartDate}");
				break;
			case TT.DAILY when t is api.IDailyTrigger g:
				short daysInterval = g.DaysInterval;
				b.Append("every ").Append(daysInterval == 1 ? "day" : $"{daysInterval} day");
				break;
			case TT.WEEKLY when t is api.IWeeklyTrigger g:
				ushort daysOfWeek1 = g.DaysOfWeek;
				short weeksInterval = g.WeeksInterval;
				if ((daysOfWeek1 & 0x7f) == 0x7f) b.Append("every day of the week,"); else { b.Append("on "); _DaysOfWeek(daysOfWeek1); }
				if (weeksInterval == 1) b.Append(" every week"); else b.AppendFormat(" every {0} weeks", weeksInterval);
				break;
			case TT.MONTHLY when t is api.IMonthlyTrigger g:
				b.Append("on day ");
				_DaysOfMonth(g.DaysOfMonth, g.RunOnLastDayOfMonth);
				b.Append(" of ");
				ushort monthsOfYear1 = g.MonthsOfYear;
				if ((monthsOfYear1 & 0xfff) == 0xfff) b.Append("every month"); else _MonthsOfYear(monthsOfYear1);
				break;
			case TT.MONTHLYDOW when t is api.IMonthlyDOWTrigger g:
				ushort weeksOfMonth = g.WeeksOfMonth;
				if (g.RunOnLastWeekOfMonth) weeksOfMonth |= 0x10;
				if ((weeksOfMonth & 0x1f) == 0x1f) b.Append("every"); else { b.Append("on "); _WeeksOfMonth(weeksOfMonth); }
				b.Append(" ");
				_DaysOfWeek(g.DaysOfWeek);
				ushort monthsOfYear2 = g.MonthsOfYear;
				if ((monthsOfYear2 & 0xfff) == 0xfff) b.Append(" every month"); else { b.Append(" each "); _MonthsOfYear(monthsOfYear2); }
				break;
			}
			if ((int)ttype >= 3) b.Append(", starting ").Append(sStartDate);
		} else {
			switch (ttype) {
			case TT.BOOT:
				b.Append("At system startup");
				break;
			case TT.EVENT:
				if (t is api.IEventTrigger et) {
					var v = et.GetQuery();
					b.Append("On event: ").Append(v.log == null ? v.query : $"log={v.log}, source={v.source}, id={v.id}");
					if (v.level != 0) b.Append(", level=").Append(v.level);
				}
				break;
			case TT.IDLE:
				b.Append("When computer is idle");
				break;
			case TT.LOGON when t is api.ILogonTrigger g:
				b.Append("At log on of ").Append(g.UserId ?? "any user");
				break;
			case TT.REGISTRATION:
				b.Append("When the task is created or modified");
				break;
			case TT.SESSION when t is api.ISessionStateChangeTrigger g:
				b.Append("On ");
				b.AppendFormat(g.StateChange switch {
					api.TASK_SESSION_STATE_CHANGE_TYPE.TASK_CONSOLE_CONNECT => "local connection to {0} session",
					api.TASK_SESSION_STATE_CHANGE_TYPE.TASK_CONSOLE_DISCONNECT => "local disconnect from {0} session",
					api.TASK_SESSION_STATE_CHANGE_TYPE.TASK_REMOTE_CONNECT => "remote connection to {0} session",
					api.TASK_SESSION_STATE_CHANGE_TYPE.TASK_REMOTE_DISCONNECT => "remote disconnect from {0} session",
					api.TASK_SESSION_STATE_CHANGE_TYPE.TASK_SESSION_LOCK => "workstation lock of {0}",
					api.TASK_SESSION_STATE_CHANGE_TYPE.TASK_SESSION_UNLOCK => "workstation unlock of {0}",
					_ => ""
				}, g.UserId ?? "any user");
				break;
			default:
				b.Append("Custom trigger");
				break;
			}
		}
		b.Append('.');
		
		if (t.Repetition is { } rep && rep.Interval is string repInterval) {
			b.Append(" Then repeat every "); _Time(repInterval);
			if (rep.Duration is string repDuration) { b.Append(" for a duration of "); _Time(repDuration); }
			b.Append('.');
		}
		
		if (t.EndBoundary is string sEnd) {
			var (sd, st) = SplitDateTime(sEnd);
			b.Append($" Expires {sd} {st}.");
		}
		
		static (string date, string time) SplitDateTime(string s) {
			if (s?.IndexOf('T') is int i && i > 0) {
				var sd = s[..i++];
				int j = s.FindAny("+-", i..); if (j < 0) j = s.Length;
				return (sd, s[i..j]);
			} else return default;
		}
		
		void _Time(string s) {
			if (s.RxMatch(@"^P(?:(\d+)D)?(?:T(?:(\d+)H)?(?:(\d+)M)?)?$", out var m)) {
				for (int i = 1, n = 0; i <= 3; i++) {
					if (m[i].Value is string k) {
						if (n++ > 0) b.Append(' ');
						b.Append(k).Append(' ');
						b.Append(s[m[i].End] switch { 'D' => "day", 'H' => "hour", _ => "minute" });
						if (k != "1") b.Append('s');
					}
				}
			} else b.Append(s);
		}
		
		void _DaysOfWeek(uint days) {
			string sep = null;
			for (int i = 0; i < 7; i++) {
				if ((days >> i & 1) != 0) {
					b.Append(sep); sep ??= "|";
					b.Append(i switch { 0 => "Sunday", 1 => "Monday", 2 => "Tuesday", 3 => "Wednesday", 4 => "Thursday", 5 => "Friday", 6 => "Saturday", _ => null });
				}
			}
		}
		
		void _DaysOfMonth(uint days, bool lastDay) {
			string sep = null;
			for (int i = 0; i < 31; i++) {
				if ((days >> i & 1) != 0) {
					b.Append(sep); sep ??= "|";
					b.Append(i + 1);
				}
			}
			if (lastDay) b.Append(sep).Append("last");
		}
		
		void _MonthsOfYear(uint months) {
			string sep = null;
			for (int i = 0; i < 12; i++) {
				if ((months >> i & 1) != 0) {
					b.Append(sep); sep ??= "|";
					b.Append((i + 1) switch { 1 => "January", 2 => "February", 3 => "March", 4 => "April", 5 => "May", 6 => "June", 7 => "July", 8 => "August", 9 => "September", 10 => "October", 11 => "November", 12 => "December", _ => null });
				}
			}
		}
		
		void _WeeksOfMonth(uint weeks) {
			string sep = null;
			for (int i = 0; i < 5; i++) {
				if ((weeks >> i & 1) != 0) {
					b.Append(sep); sep ??= "|";
					b.Append((i + 1) switch { 1 => "first", 2 => "second", 3 => "third", 4 => "fourth", 5 => "last", _ => null });
				}
			}
		}
	}
	
	/// <summary>
	/// Calls <b>get_Item</b> and casts to <b>IExecAction</b>.
	/// </summary>
	/// <param name="t"></param>
	/// <param name="index">1-based.</param>
	/// <returns>null if fails.</returns>
	public static api.IExecAction GetExecAction(this api.IActionCollection t, int index) {
		if (0 == t.get_Item(1, out var v)) return v as api.IExecAction;
		return null;
	}
	
	/// <summary>
	/// Calls <b>Subscription</b> and parses the query.
	/// If it's a standard simple query, sets <b>log</b>, <b>source</b> and <b>id</b>. Else they will be null. Always sets <b>query</b>.
	/// </summary>
	public static (string query, string log, string source, string id, int level) GetQuery(this api.IEventTrigger t) {
		var s = t.Subscription;
		try {
			var x = XElement.Parse(s);
			if (x is { Name.LocalName: "QueryList" }
				&& x.Element("Query") is { NextNode: null } xq && xq.Attr("Path") is { } log
				&& xq.Element("Select") is { NextNode: null, Value: ['*', ..] v } xs && xs.Attr("Path") == log) {
				
				string source = null, id = null, level = null;
				bool ok = false;
				if (v == "*") ok = true;
				else if (v.Starts("*[System[") && v.Ends("]]")) {
					foreach (var k in v[9..^2].Split(" and ")) {
						if (k.Like("Provider[@Name='*']")) source = k[16..^2];
						else if (k.Starts("EventID=")) id = k[8..];
						else if (k.Like("(EventID=*)") && !k.Contains(' ')) id = k[9..^1];
						else if (k.Starts("Level=")) level = k[6..];
						else if (k.Like("(Level=*)") && !k.Contains(' ')) level = k[7..^1];
						else { ok = false; break; }
						ok = true;
					}
					if (ok) return (s, log, source, id, level?.ToInt() ?? 0);
				}
			}
		}
		catch { }
		return (s, null, null, null, 0);
	}
	
	//not used
	//public static void SetPrincipal(this api.ITaskDefinition t, UacIL IL, string author = "Au") {
	//	if (!(IL is UacIL.High or UacIL.Medium or UacIL.System)) throw new ArgumentException();
	//	t.get_Principal(out var p);
	//	p.put_Id("Author");
	//	p.put_LogonType(api.TASK_LOGON_TYPE.TASK_LOGON_INTERACTIVE_TOKEN);
	//	if (IL == UacIL.System) p.put_UserId("<UserId>S-1-5-18</UserId>\r\n");
	//	else p.put_RunLevel(IL == UacIL.Medium ? api.TASK_RUNLEVEL_TYPE.TASK_RUNLEVEL_LUA : api.TASK_RUNLEVEL_TYPE.TASK_RUNLEVEL_HIGHEST);
	//}
}

#pragma warning disable 649, 169 //field never assigned/used
unsafe class WinSchedulerApi : NativeApi {
	[ComImport, Guid("0f87369f-a4e5-4cfc-bd3e-73e6154572dd"), ClassInterface(ClassInterfaceType.None)]
	internal class TaskScheduler { }
	
	[ComImport, Guid("2faba4c7-4da9-4013-9697-20cc3fd40f85")] //dual
	internal interface ITaskService {
		[PreserveSig] int GetFolder(string path, out ITaskFolder ppFolder);
		[PreserveSig] int GetRunningTasks(int flags, out IRunningTaskCollection ppRunningTasks);
		[PreserveSig] int NewTask(uint flags, out ITaskDefinition ppDefinition);
		[PreserveSig] int Connect(object serverName = null, object user = null, object domain = null, object password = null);
		bool Connected { get; }
		string TargetServer { get; }
		string ConnectedUser { get; }
		string ConnectedDomain { get; }
		uint HighestVersion { get; }
	}
	
	[ComImport, Guid("8cfac062-a080-4c15-9a88-aa7c2af80dfc")] //dual
	internal interface ITaskFolder {
		string Name { get; }
		string Path { get; }
		[PreserveSig] int GetFolder(string path, out ITaskFolder ppFolder);
		[PreserveSig] int GetFolders(int flags, out ITaskFolderCollection ppFolders);
		[PreserveSig] int CreateFolder(string subFolderName, object sddl, out ITaskFolder ppFolder);
		[PreserveSig] int DeleteFolder(string subFolderName, int flags);
		[PreserveSig] int GetTask(string path, out IRegisteredTask ppTask);
		[PreserveSig] int GetTasks(int flags, out IRegisteredTaskCollection ppTasks);
		[PreserveSig] int DeleteTask(string name, int flags);
		[PreserveSig] int RegisterTask(string path, string xmlText, TASK_CREATION flags, object userId, object password, TASK_LOGON_TYPE logonType, object sddl, out IRegisteredTask ppTask);
		[PreserveSig] int RegisterTaskDefinition(string path, ITaskDefinition pDefinition, TASK_CREATION flags, object userId, object password, TASK_LOGON_TYPE logonType, object sddl, out IRegisteredTask ppTask);
		[PreserveSig] int GetSecurityDescriptor(int securityInformation, out string pSddl);
		[PreserveSig] int SetSecurityDescriptor(string sddl, int flags);
	}
	
	[Flags]
	internal enum TASK_CREATION : uint {
		TASK_VALIDATE_ONLY = 0x1,
		TASK_CREATE,
		TASK_UPDATE = 0x4,
		TASK_CREATE_OR_UPDATE = 0x6,
		TASK_DISABLE = 0x8,
		TASK_DONT_ADD_PRINCIPAL_ACE = 0x10,
		TASK_IGNORE_REGISTRATION_TRIGGERS = 0x20
	}
	
	[ComImport, Guid("86627eb4-42a7-41e4-a4d9-ac33a72f2d52")] //dual
	internal interface IRegisteredTaskCollection {
		int Count { get; }
		[PreserveSig] int get_Item(object index, out IRegisteredTask ppRegisteredTask);
	}
	
	[ComImport, Guid("9c86f320-dee3-4dd1-b972-a303f26b061e")] //dual
	internal interface IRegisteredTask {
		string Name { get; }
		string Path { get; }
		TASK_STATE State { get; }
		bool Enabled { get; set; }
		[PreserveSig] int Run(object @params, out IRunningTask ppRunningTask);
		[PreserveSig] int RunEx(object @params, int flags, int sessionID, string user, out IRunningTask ppRunningTask);
		[PreserveSig] int GetInstances(int flags, out IRunningTaskCollection ppRunningTasks);
		DateTime LastRunTime { get; }
		int LastTaskResult { get; }
		int NumberOfMissedRuns { get; }
		DateTime NextRunTime { get; }
		ITaskDefinition Definition { get; }
		string Xml { get; }
		[PreserveSig] int GetSecurityDescriptor(int securityInformation, out string pSddl);
		[PreserveSig] int SetSecurityDescriptor(string sddl, int flags);
		[PreserveSig] int Stop(int flags);
		[PreserveSig] int GetRunTimes(in SYSTEMTIME pstStart, in SYSTEMTIME pstEnd, ref uint pCount, out SYSTEMTIME* pRunTimes);
	}
	
	[ComImport, Guid("79184a66-8664-423f-97f1-637356a5d812")] //dual
	internal interface ITaskFolderCollection {
		int Count { get; }
		[PreserveSig] int get_Item(object index, out ITaskFolder ppFolder);
	}
	
	internal struct SYSTEMTIME {
		public ushort wYear;
		public ushort wMonth;
		public ushort wDayOfWeek;
		public ushort wDay;
		public ushort wHour;
		public ushort wMinute;
		public ushort wSecond;
		public ushort wMilliseconds;
	}
	
	[ComImport, Guid("f5bc8fc5-536d-4f77-b852-fbc1356fdeb6")] //dual
	internal interface ITaskDefinition {
		IRegistrationInfo RegistrationInfo { get; set; }
		ITriggerCollection Triggers { get; set; }
		ITaskSettings Settings { get; set; }
		string Data { get; set; }
		IPrincipal Principal { get; set; }
		IActionCollection Actions { get; set; }
		string XmlText { get; set; }
	}
	
	[ComImport, Guid("6a67614b-6828-4fec-aa54-6d52e8f1f2db")] //dual
	internal interface IRunningTaskCollection {
		int Count { get; }
		[PreserveSig] int get_Item(object index, out IRunningTask ppRunningTask);
	}
	
	[ComImport, Guid("653758fb-7b9a-4f1e-a471-beeb8e9b834e")] //dual
	internal interface IRunningTask {
		[PreserveSig] int get_Name(out string pName);
		[PreserveSig] int get_InstanceGuid(out string pGuid);
		[PreserveSig] int get_Path(out string pPath);
		[PreserveSig] int get_State(out TASK_STATE pState);
		[PreserveSig] int get_CurrentAction(out string pName);
		[PreserveSig] int Stop();
		[PreserveSig] int Refresh();
		[PreserveSig] int get_EnginePID(out int pPID);
	}
	
	internal enum TASK_STATE {
		TASK_STATE_UNKNOWN,
		TASK_STATE_DISABLED,
		TASK_STATE_QUEUED,
		TASK_STATE_READY,
		TASK_STATE_RUNNING
	}
	
	[ComImport, Guid("02820E19-7B98-4ed2-B2E8-FDCCCEFF619B")] //dual
	internal interface IActionCollection {
		int Count { get; }
		[PreserveSig] int get_Item(int index, out IAction ppAction);
		void __NewEnum();
		string XmlText { get; set; }
		[PreserveSig] int Create(TASK_ACTION_TYPE type, out IAction ppAction);
		[PreserveSig] int Remove(object index);
		[PreserveSig] int Clear();
		string Context { get; set; }
	}
	
	[ComImport, Guid("D98D51E5-C9B4-496a-A9C1-18980261CF0F")] //dual
	internal interface IPrincipal {
		string Id { get; set; }
		string DisplayName { get; set; }
		string UserId { get; set; }
		TASK_LOGON_TYPE LogonType { get; set; }
		string GroupId { get; set; }
		TASK_RUNLEVEL_TYPE RunLevel { get; set; }
	}
	
	[ComImport, Guid("8FD4711D-2D02-4c8c-87E3-EFF699DE127E")] //dual
	internal interface ITaskSettings {
		bool AllowDemandStart { get; set; }
		string RestartInterval { get; set; }
		int RestartCount { get; set; }
		int MultipleInstances { get; set; }
		bool StopIfGoingOnBatteries { get; set; }
		bool DisallowStartIfOnBatteries { get; set; }
		bool AllowHardTerminate { get; set; }
		bool StartWhenAvailable { get; set; }
		string XmlText { get; set; }
		bool RunOnlyIfNetworkAvailable { get; set; }
		string ExecutionTimeLimit { get; set; }
		bool Enabled { get; set; }
		string DeleteExpiredTaskAfter { get; set; }
		int Priority { get; set; }
		int Compatibility { get; set; }
		bool Hidden { get; set; }
		IIdleSettings IdleSettings { get; set; }
		bool RunOnlyIfIdle { get; set; }
		bool WakeToRun { get; set; }
		INetworkSettings NetworkSettings { get; set; }
	} //info: ITaskSettings2/3 not useful
	
	[ComImport, Guid("416D8B73-CB41-4ea1-805C-9BE9A5AC4A74")] //dual
	internal interface IRegistrationInfo {
		string Description { get; set; }
		string Author { get; set; }
		string Version { get; set; }
		string Date { get; set; }
		string Documentation { get; set; }
		string XmlText { get; set; }
		string URI { get; set; }
		object SecurityDescriptor { get; set; }
		string Source { get; set; }
	}
	
	[ComImport, Guid("9F7DEA84-C30B-4245-80B6-00E9F646F1B4")] //dual
	internal interface INetworkSettings {
		string Name { get; set; }
		string Id { get; set; }
	}
	
	[ComImport, Guid("84594461-0053-4342-A8FD-088FABF11F32")] //dual
	internal interface IIdleSettings {
		string IdleDuration { get; set; }
		string WaitTimeout { get; set; }
		bool StopOnIdleEnd { get; set; }
		bool RestartOnIdle { get; set; }
	}
	
	internal enum TASK_COMPATIBILITY {
		TASK_COMPATIBILITY_AT,
		TASK_COMPATIBILITY_V1,
		TASK_COMPATIBILITY_V2,
		TASK_COMPATIBILITY_V2_1,
		TASK_COMPATIBILITY_V2_2,
		TASK_COMPATIBILITY_V2_3,
		TASK_COMPATIBILITY_V2_4
	}
	
	internal enum TASK_INSTANCES_POLICY {
		TASK_INSTANCES_PARALLEL,
		TASK_INSTANCES_QUEUE,
		TASK_INSTANCES_IGNORE_NEW,
		TASK_INSTANCES_STOP_EXISTING
	}
	
	internal enum TASK_RUNLEVEL_TYPE {
		TASK_RUNLEVEL_LUA,
		TASK_RUNLEVEL_HIGHEST
	}
	
	internal enum TASK_LOGON_TYPE {
		TASK_LOGON_NONE,
		TASK_LOGON_PASSWORD,
		TASK_LOGON_S4U,
		TASK_LOGON_INTERACTIVE_TOKEN,
		TASK_LOGON_GROUP,
		TASK_LOGON_SERVICE_ACCOUNT,
		TASK_LOGON_INTERACTIVE_TOKEN_OR_PASSWORD
	}
	
	[ComImport, Guid("BAE54997-48B1-4cbe-9965-D6BE263EBEA4")] //dual
	internal interface IAction {
		string Id { get; set; }
		TASK_ACTION_TYPE Type { get; }
	}
	
	internal enum TASK_ACTION_TYPE {
		TASK_ACTION_EXEC,
		TASK_ACTION_COM_HANDLER = 5,
		TASK_ACTION_SEND_EMAIL,
		TASK_ACTION_SHOW_MESSAGE
	}
	
	[ComImport, Guid("4c3d624d-fd6b-49a3-b9b7-09cb3cd3f047")] //dual
	internal interface IExecAction {
		void _0(); void _1(); void _2(); //IAction
		string Path { get; set; }
		string Arguments { get; set; }
		string WorkingDirectory { get; set; }
	}
	
	internal const int TASK_ENUM_HIDDEN = 0x1;
	
	internal enum TASK_TRIGGER_TYPE2 {
		EVENT,
		TIME,
		DAILY,
		WEEKLY,
		MONTHLY,
		MONTHLYDOW,
		IDLE,
		REGISTRATION,
		BOOT,
		LOGON,
		SESSION = 11,
		CUSTOM_TRIGGER_01
	}
	
	[ComImport, Guid("85df5081-1b24-4f32-878a-d9d14df4cb77")] //dual
	internal interface ITriggerCollection {
		int Count { get; }
		[PreserveSig] int get_Item(int index, out ITrigger ppTrigger);
		void __NewEnum();
		ITrigger Create(TASK_TRIGGER_TYPE2 type);
		[PreserveSig] int Remove(object index);
		void Clear();
	}
	
	[ComImport, Guid("09941815-ea89-4b5b-89e0-2a773801fac3")] //dual
	internal interface ITrigger {
		TASK_TRIGGER_TYPE2 Type { get; }
		string Id { get; set; }
		IRepetitionPattern Repetition { get; set; }
		string ExecutionTimeLimit { get; set; }
		string StartBoundary { get; set; }
		string EndBoundary { get; set; }
		bool Enabled { get; set; }
	}
	
	[ComImport, Guid("7FB9ACF1-26BE-400e-85B5-294B9C75DFD6")] //dual
	internal interface IRepetitionPattern {
		string Interval { get; set; }
		string Duration { get; set; }
		bool StopAtDurationEnd { get; set; }
	}
	
	[ComImport, Guid("b45747e0-eba7-4276-9f29-85c5bb300006")]
	internal interface ITimeTrigger {
		void _0();void _1();void _2();void _3();void _4();void _5();void _6();void _7();void _8();void _9();void _10();void _11();void _12();
		string RandomDelay { get; set; }
	}
	
	[ComImport, Guid("126c5cd8-b288-41d5-8dbf-e491446adc5c")]
	internal interface IDailyTrigger {
		void _0(); void _1(); void _2(); void _3(); void _4(); void _5(); void _6(); void _7(); void _8(); void _9(); void _10(); void _11(); void _12();
		short DaysInterval { get; set; }
		string RandomDelay { get; set; }
	}
	
	[ComImport, Guid("5038fc98-82ff-436d-8728-a512a57c9dc1")]
	internal interface IWeeklyTrigger {
		void _0(); void _1(); void _2(); void _3(); void _4(); void _5(); void _6(); void _7(); void _8(); void _9(); void _10(); void _11(); void _12();
		ushort DaysOfWeek { get; set; }
		short WeeksInterval { get; set; }
		string RandomDelay { get; set; }
	}
	
	[ComImport, Guid("97c45ef1-6b02-4a1a-9c0e-1ebfba1500ac")]
	internal interface IMonthlyTrigger {
		void _0(); void _1(); void _2(); void _3(); void _4(); void _5(); void _6(); void _7(); void _8(); void _9(); void _10(); void _11(); void _12();
		uint DaysOfMonth { get; set; }
		ushort MonthsOfYear { get; set; }
		bool RunOnLastDayOfMonth { get; set; }
		string RandomDelay { get; set; }
	}
	
	[ComImport, Guid("77d025a3-90fa-43aa-b52e-cda5499b946a")]
	internal interface IMonthlyDOWTrigger {
		void _0(); void _1(); void _2(); void _3(); void _4(); void _5(); void _6(); void _7(); void _8(); void _9(); void _10(); void _11(); void _12();
		ushort DaysOfWeek { get; set; }
		ushort WeeksOfMonth { get; set; }
		ushort MonthsOfYear { get; set; }
		bool RunOnLastWeekOfMonth { get; set; }
		string RandomDelay { get; set; }
	}
	
	//[ComImport, Guid("2a9c35da-d357-41f4-bbc1-207ac1b1f3cb")]
	//internal interface IBootTrigger {
	//	void _0();void _1();void _2();void _3();void _4();void _5();void _6();void _7();void _8();void _9();void _10();void _11();void _12();
	//	string Delay { get; set; }
	//}
	
	[ComImport, Guid("d45b0167-9653-4eef-b94f-0732ca7af251")]
	internal interface IEventTrigger {
		void _0(); void _1(); void _2(); void _3(); void _4(); void _5(); void _6(); void _7(); void _8(); void _9(); void _10(); void _11(); void _12();
		string Subscription { get; set; }
		string Delay { get; set; }
		ITaskNamedValueCollection ValueQueries { get; set; }
	}
	
	[ComImport, Guid("b4ef826b-63c3-46e4-a504-ef69e4f7ea4d")]
	internal interface ITaskNamedValueCollection {
		int Count { get; }
		[PreserveSig] int get_Item(int index, out ITaskNamedValuePair ppPair);
		void __NewEnum();
		[PreserveSig] int Create(string name, string value, out ITaskNamedValuePair ppPair);
		[PreserveSig] int Remove(int index);
		[PreserveSig] int Clear();
	}
	
	[ComImport, Guid("39038068-2b46-4afd-8662-7bb6f868d221")]
	internal interface ITaskNamedValuePair {
		string Name { get; set; }
		string Value { get; set; }
	}
	
	[ComImport, Guid("72dade38-fae4-4b3e-baf4-5d009af02b1c")]
	internal interface ILogonTrigger {
		void _0(); void _1(); void _2(); void _3(); void _4(); void _5(); void _6(); void _7(); void _8(); void _9(); void _10(); void _11(); void _12();
		string Delay { get; set; }
		string UserId { get; set; }
	}
	
	[ComImport, Guid("4c8fec3a-c218-4e0c-b23d-629024db91a2")]
	internal interface IRegistrationTrigger {
		void _0();void _1();void _2();void _3();void _4();void _5();void _6();void _7();void _8();void _9();void _10();void _11();void _12();
		string Delay { get; set; }
	}
	
	[ComImport, Guid("754da71b-4385-4475-9dd9-598294fa3641")]
	internal interface ISessionStateChangeTrigger {
		void _0(); void _1(); void _2(); void _3(); void _4(); void _5(); void _6(); void _7(); void _8(); void _9(); void _10(); void _11(); void _12();
		string Delay { get; set; }
		string UserId { get; set; }
		TASK_SESSION_STATE_CHANGE_TYPE StateChange { get; set; }
	}
	
	internal struct MONTHLYDOW {
		public ushort wWhichWeek;
		public ushort rgfDaysOfTheWeek;
		public ushort rgfMonths;
	}
	
	internal struct MONTHLYDATE {
		public uint rgfDays;
		public ushort rgfMonths;
	}
	
	internal struct WEEKLY {
		public ushort WeeksInterval;
		public ushort rgfDaysOfTheWeek;
	}
	
	internal struct DAILY {
		public ushort DaysInterval;
	}
	
	internal enum TASK_SESSION_STATE_CHANGE_TYPE {
		TASK_CONSOLE_CONNECT = 1,
		TASK_CONSOLE_DISCONNECT,
		TASK_REMOTE_CONNECT,
		TASK_REMOTE_DISCONNECT,
		TASK_SESSION_LOCK = 7,
		TASK_SESSION_UNLOCK
	}
	
	internal const int TVM_GETNEXTITEM = 0x110A;
	internal const int TVM_EXPAND = 0x1102;
	
	internal const int TVGN_CHILD = 0x4;
	
	internal const int TVE_EXPAND = 0x2;
	
	internal const int TCM_SETCURFOCUS = 0x1330;
}
#pragma warning restore 649, 169 //field never assigned/used


================================================
FILE: Au.Editor/_prePostBuild.cs
================================================
/*/ role editorExtension; /*/

if (args[0] == "post") {
	var outputPath = args[1];
	
	var source = @"C:\code\au\_";
	run.console(out var so, "robocopy.exe", $"\"{source}\" \"{outputPath}\" /e /sj /sl /r:2 /w:1 /xd Default Git SDK /xf *.pdb Au.dll Au.Controls.dll Au.Editor.dll LibreAutomateSetup.exe");
	
	//compiler always copies the true Au.dll to outputPath. Let's replace it with our Au.dll.
	filesystem.copyTo(@"C:\code\ok\dll\Au.dll", outputPath, FIfExists.Delete);
} else {
	foreach (var w in wnd.findAll("**m LibreAutomate||Find window||Find UI element", "HwndWrapper[Au.Editor;*", also: o => o.ProcessId != process.thisProcessId)) {
		w.Close(noWait: true);
		w.WaitForClosed(3, waitUntilProcessEnds: true);
	}
}


================================================
FILE: Au.Editor/resources/AssemblyInfo.cs
================================================
using System.Windows;

[assembly: System.Resources.NeutralResourcesLanguage("en-US")]

[assembly: ThemeInfo(
	ResourceDictionaryLocation.None, //where theme specific resource dictionaries are located
									 //(used if a resource is not found in the page,
									 // or application resource dictionaries)
	ResourceDictionaryLocation.SourceAssembly //where the generic resource dictionary is located
											  //(used if a resource is not found in the page,
											  // app, or any theme specific resource dictionaries)
)]


================================================
FILE: Au.Editor/resources/Au.manifest
================================================
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0" xmlns:asmv3="urn:schemas-microsoft-com:asm.v3">
	<assemblyIdentity
		version="1.0.0.0"
		processorArchitecture="*"
		name="Company.Product.Filename"
		type="win32"
/>
	<description>File Description</description>
	<dependency>
		<dependentAssembly>
			<assemblyIdentity
				type="win32"
				name="Microsoft.Windows.Common-Controls"
				version="6.0.0.0"
				processorArchitecture="*"
				publicKeyToken="6595b64144ccf1df"
				language="*"
        />
		</dependentAssembly>
	</dependency>
	<trustInfo xmlns="urn:schemas-microsoft-com:asm.v2">
		<security>
			<requestedPrivileges>
				<requestedExecutionLevel level="asInvoker" uiAccess="false"/>
			</requestedPrivileges>
		</security>
	</trustInfo>
	<compatibility xmlns="urn:schemas-microsoft-com:compatibility.v1">
		<application>
			<!-- Windows 7 -->
			<supportedOS Id="{35138b9a-5d96-4fbd-8e2d-a2440225f93a}"/>
			<!-- Windows 8 -->
			<supportedOS Id="{4a2f28e3-53b9-4441-ba9c-d69d4a4a6e38}"/>
			<!-- Windows 8.1 -->
			<supportedOS Id="{1f676c76-80e1-4239-95bb-83d0f6d0da78}"/>
			<!-- Windows 10 -->
			<supportedOS Id="{8e0f7a12-bfb3-4fe8-b9a5-48fd50a15a9a}"/>
			<maxversiontested Id="10.0.22631.0"/>
		</application>
	</compatibility>
	<asmv3:application>
		<asmv3:windowsSettings xmlns="http://schemas.microsoft.com/SMI/2005/WindowsSettings">
			<dpiAwareness xmlns="http://schemas.microsoft.com/SMI/2016/WindowsSettings">PerMonitorV2</dpiAwareness>
			<dpiAware>True/PM</dpiAware>
		</asmv3:windowsSettings>
		<asmv3:windowsSettings xmlns="http://schemas.microsoft.com/SMI/2011/WindowsSettings">
			<disableWindowFiltering>true</disableWindowFiltering>
		</asmv3:windowsSettings>
	</asmv3:application>
</assembly>
<!--
This manifest is used in Au.Editor and Au.Task.
Added to the C++ apphost (from template Au.AppHost) in post-build event.
Note: VS does not recompile project after modifying this file, unless some other file is modified of "Copy if newer" is set.
-->

================================================
FILE: Au.Editor/resources/ci/Class.xaml
================================================
<!-- This file was generated by the AiToXaml tool.-->
<!-- Tool Version: 14.0.22307.0 -->
<Viewbox Width="16" Height="16" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
  <Rectangle Width="16" Height="16">
    <Rectangle.Fill>
      <DrawingBrush>
        <DrawingBrush.Drawing>
          <DrawingGroup>
            <DrawingGroup.Children>
              <GeometryDrawing Brush="#00FFFFFF" Geometry="F1M16,16L0,16 0,0 16,0z" />
              <GeometryDrawing Brush="#FFF6F6F6" Geometry="F1M5.5863,-0.000199999999999534L0.000299999999999301,5.5858 0.000299999999999301,6.4138 3.9993,10.4138 6.4143,7.9998 7.0003,7.9998 7.0003,9.9998 7.0003,13.0008 8.5863,13.0008 11.5853,15.9998 12.4133,15.9998 16.0003,12.4148 16.0003,11.5858 13.9143,9.4998 16.0003,7.4138 16.0003,6.5858 12.9993,3.5868 11.5853,4.9998 10.0003,4.9998 9.4143,4.9998 10.4143,4.0008 6.4143,-0.000199999999999534z" />
              <GeometryDrawing Brush="#FFC17C1A" Geometry="F1M13,10L15,12 12,15 10,13 11,12 8,12 8,7 6,7 4,9 1,6 6,1 9,4 7,6 12,6 13,5 15,7 12,10 10,8 11,7 9,7 9,11 11.999,11.002z" />
            </DrawingGroup.Children>
          </DrawingGroup>
        </DrawingBrush.Drawing>
      </DrawingBrush>
    </Rectangle.Fill>
  </Rectangle>
</Viewbox>

================================================
FILE: Au.Editor/resources/ci/Constant.xaml
================================================
<!-- This file was generated by the AiToXaml tool.-->
<!-- Tool Version: 14.0.22307.0 -->
<Viewbox Width="16" Height="16" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
  <Rectangle Width="16" Height="16">
    <Rectangle.Fill>
      <DrawingBrush>
        <DrawingBrush.Drawing>
          <DrawingGroup>
            <DrawingGroup.Children>
              <GeometryDrawing Brush="#00FFFFFF" Geometry="F1M16,16L0,16 0,0 16,0z" />
              <GeometryDrawing Brush="#FFF6F6F6" Geometry="F1M2.8789,14L0.9999,12.121 0.9999,3.879 2.8789,2 13.1209,2 14.9999,3.879 14.9999,12.121 13.1209,14z" />
              <GeometryDrawing Brush="#FFEFEFF0" Geometry="F1M11,7L5,7 5,6 11,6z M11,10L5,10 5,9 11,9z M12.293,4L3.707,4 3,4.707 3,11.293 3.707,12 12.293,12 13,11.293 13,4.707z" />
              <GeometryDrawing Brush="#FF424242" Geometry="F1M3.707,12L12.293,12 13,11.293 13,4.707 12.293,4 3.707,4 3,4.707 3,11.293z M12.707,13L3.293,13 2,11.707 2,4.293 3.293,3 12.707,3 14,4.293 14,11.707z" />
              <GeometryDrawing Brush="#FF00529C" Geometry="F1M11,9L5,9 5,10 11,10z M11,7L5,7 5,6 11,6z" />
            </DrawingGroup.Children>
          </DrawingGroup>
        </DrawingBrush.Drawing>
      </DrawingBrush>
    </Rectangle.Fill>
  </Rectangle>
</Viewbox>

================================================
FILE: Au.Editor/resources/ci/Delegate.xaml
================================================
<!-- This file was generated by the AiToXaml tool.-->
<!-- Tool Version: 14.0.22307.0 -->
<Viewbox Width="16" Height="16" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
  <Rectangle Width="16" Height="16">
    <Rectangle.Fill>
      <DrawingBrush>
        <DrawingBrush.Drawing>
          <DrawingGroup>
            <DrawingGroup.Children>
              <GeometryDrawing Brush="#00FFFFFF" Geometry="F1M16,16L0,16 0,0 16,0z" />
              <GeometryDrawing Brush="#FFF6F6F6" Geometry="F1M2.25,13C1.009,13,0,11.99,0,10.75L0,5.25C0,4.009,1.009,3,2.25,3L3.014,3C3.139,1.876,4.094,1,5.25,1L6.75,1C7.906,1,8.861,1.876,8.986,3L9.75,3C10.99,3,12,4.009,12,5.25L12,10.75C12,11.99,10.99,13,9.75,13z" />
              <GeometryDrawing Brush="#FF642D90" Geometry="F1M10,11L9,11 9,5 10,5z M7,4L5,4 5,3.25C5,3.112,5.112,3,5.25,3L6.75,3C6.888,3,7,3.112,7,3.25z M3,11L2,11 2,5 3,5z M9.75,4L8,4 8,3.25C8,2.561,7.439,2,6.75,2L5.25,2C4.561,2,4,2.561,4,3.25L4,4 2.25,4C1.561,4,1,4.561,1,5.25L1,10.75C1,11.44,1.561,12,2.25,12L9.75,12C10.44,12,11,11.44,11,10.75L11,5.25C11,4.561,10.44,4,9.75,4" />
              <GeometryDrawing Brush="#FFEFEFF0" Geometry="F1M10,11L9,11 9,5 10,5z M3,11L2,11 2,5 3,5z" />
            </DrawingGroup.Children>
          </DrawingGroup>
        </DrawingBrush.Drawing>
      </DrawingBrush>
    </Rectangle.Fill>
  </Rectangle>
</Viewbox>

================================================
FILE: Au.Editor/resources/ci/Enum.xaml
================================================
<!-- This file was generated by the AiToXaml tool.-->
<!-- Tool Version: 14.0.22307.0 -->
<Viewbox Width="16" Height="16" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
  <Rectangle Width="16" Height="16">
    <Rectangle.Fill>
      <DrawingBrush>
        <DrawingBrush.Drawing>
          <DrawingGroup>
            <DrawingGroup.Children>
              <GeometryDrawing Brush="#00FFFFFF" Geometry="F1M16,16L0,16 0,0 16,0z" />
              <GeometryDrawing Brush="#FFF6F6F6" Geometry="F1M7.5861,0.999700000000001L6.0001,2.5867 6.0001,5.9997 1.5861,5.9997 9.99999999997669E-05,7.5867 9.99999999997669E-05,13.4157 1.5861,14.9997 8.4141,14.9997 10.0001,13.4157 10.0001,9.9997 14.4141,9.9997 16.0001,8.4147 16.0001,2.5867 14.4141,0.999700000000001z" />
              <GeometryDrawing Brush="#FFEFEFF0" Geometry="F1M13,5L9,5 9,4 13,4z M14,6L14,3 8,3 8,6 8.414,6 9,6.586 9,6 13,6 13,7 9.414,7 10,7.586 10,8 14,8z M3,11L7,11 7,12 3,12z M3,9L7,9 7,10 3,10z M2,13L8,13 8,11 8,8 2,8z" />
              <GeometryDrawing Brush="#FFC17C1A" Geometry="F1M14,2.0005L8,2.0005 7,3.0005 7,6.0005 8,6.0005 8,3.0005 14,3.0005 14,6.0005 14,8.0005 10,8.0005 10,9.0005 14,9.0005 15,8.0005 15,3.0005z M9,5.0005L13,5.0005 13,4.0005 9,4.0005z M9,6.0005L10,7.0005 13,7.0005 13,6.0005z M8,8.0005L2,8.0005 2,13.0005 8,13.0005 8,11.0005z M9,8.0005L9,13.0005 8,14.0005 2,14.0005 1,13.0005 1,8.0005 2,7.0005 8,7.0005z M3,10.0005L7.001,10.0005 7.001,9.0005 3,9.0005z M3,11.0005L7.001,11.0005 7.001,12.0005 3,12.0005z" />
            </DrawingGroup.Children>
          </DrawingGroup>
        </DrawingBrush.Drawing>
      </DrawingBrush>
    </Rectangle.Fill>
  </Rectangle>
</Viewbox>

================================================
FILE: Au.Editor/resources/ci/EnumMember.xaml
================================================
<!-- This file was generated by the AiToXaml tool.-->
<!-- Tool Version: 14.0.22307.0 -->
<Viewbox Width="16" Height="16" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
  <Rectangle Width="16" Height="16">
    <Rectangle.Fill>
      <DrawingBrush>
        <DrawingBrush.Drawing>
          <DrawingGroup>
            <DrawingGroup.Children>
              <GeometryDrawing Brush="#00FFFFFF" Geometry="F1M16,16L0,16 0,0 16,0z" />
              <GeometryDrawing Brush="#FFF6F6F6" Geometry="F1M7.5852,0.999700000000001L6.0002,2.5867 6.0002,5.9997 0.000200000000000422,5.9997 0.000200000000000422,14.9997 10.0002,14.9997 10.0002,9.9997 14.4142,9.9997 16.0002,8.4147 16.0002,2.5867 14.4142,0.999700000000001z" />
              <GeometryDrawing Brush="#FFEFEFF0" Geometry="F1M7,11L3,11 3,10 7,10z M2,13L8,13 8,8 2,8z M13,5L9,5 9,4 13,4z M8,3L8,6 9,6 10,6 13,6 13,7 10,7 10,8 14,8 14,6 14,3z" />
              <GeometryDrawing Brush="#FF00529C" Geometry="F1M8,8L2,8 2,13 8,13z M9,14L1,14 1,7 9,7z M7,10L3,10 3,11 7,11z M14,2L8,2 7,3 7,6 8,6 8,3 14,3 14,6 14,8 10,8 10,9 14,9 15,8 15,3z M9,5L13,5 13,4 9,4z M10,6L13,6 13,7 10,7z" />
            </DrawingGroup.Children>
          </DrawingGroup>
        </DrawingBrush.Drawing>
      </DrawingBrush>
    </Rectangle.Fill>
  </Rectangle>
</Viewbox>

================================================
FILE: Au.Editor/resources/ci/Event.xaml
================================================
<!-- This file was generated by the AiToXaml tool.-->
<!-- Tool Version: 14.0.22307.0 -->
<Viewbox Width="16" Height="16" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
  <Rectangle Width="16" Height="16">
    <Rectangle.Fill>
      <DrawingBrush>
        <DrawingBrush.Drawing>
          <DrawingGroup>
            <DrawingGroup.Children>
              <GeometryDrawing Brush="#00FFFFFF" Geometry="F1M16,16L0,16 0,0 16,0z" />
              <GeometryDrawing Brush="#FFF6F6F6" Geometry="F1M3.3822,1.9996L0.000199999999999978,8.7636 0.000199999999999978,9.9996 2.3812,9.9996 0.3812,14.0006 2.9142,14.0006 9.5002,7.4136 9.5002,6.0006 6.4142,6.0006 9.0002,3.4146 9.0002,1.9996z" />
              <GeometryDrawing Brush="#FFC17C1A" Geometry="F1M8.5176,7L2.5176,13 1.9996,13 4.0176,9 0.9996,9 3.9996,3 7.9996,3 3.9996,7z" />
            </DrawingGroup.Children>
          </DrawingGroup>
        </DrawingBrush.Drawing>
      </DrawingBrush>
    </Rectangle.Fill>
  </Rectangle>
</Viewbox>

================================================
FILE: Au.Editor/resources/ci/ExpandScope.xaml
================================================
<Viewbox Width="16 " Height="16" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:System="clr-namespace:System;assembly=mscorlib">
  <Rectangle Width="16 " Height="16">
    <Rectangle.Resources>
      <SolidColorBrush x:Key="canvas" Opacity="0" />
      <SolidColorBrush x:Key="light-defaultgrey" Color="#212121" Opacity="1" />
      <SolidColorBrush x:Key="light-green" Color="#1f801f" Opacity="1" />
    </Rectangle.Resources>
    <Rectangle.Fill>
      <DrawingBrush Stretch="None">
        <DrawingBrush.Drawing>
          <DrawingGroup>
            <DrawingGroup x:Name="canvas">
              <GeometryDrawing Brush="{DynamicResource canvas}" Geometry="F1M16,0V16H0V0Z" />
            </DrawingGroup>
            <DrawingGroup x:Name="level_1">
              <GeometryDrawing Brush="{DynamicResource light-defaultgrey}" Geometry="F1M1.5,1H5V2H2V5H1V1.5Zm12,0H10V2h3V5h1V1.5ZM14,13.5V10H13v3H10v1h3.5ZM1.5,14H5V13H2V10H1v3.5Z" />
              <GeometryDrawing Brush="{DynamicResource light-green}" Geometry="F1M12,8H8v4H7V8H3V7H7V3H8V7h4Z" />
            </DrawingGroup>
          </DrawingGroup>
        </DrawingBrush.Drawing>
      </DrawingBrush>
    </Rectangle.Fill>
  </Rectangle>
</Viewbox>


================================================
FILE: Au.Editor/resources/ci/ExtensionMethod.xaml
================================================
<!-- This file was generated by the AiToXaml tool.-->
<!-- Tool Version: 14.0.22307.0 -->
<Viewbox Width="16" Height="16" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
  <Rectangle Width="16" Height="16">
    <Rectangle.Fill>
      <DrawingBrush>
        <DrawingBrush.Drawing>
          <DrawingGroup>
            <DrawingGroup.Children>
              <GeometryDrawing Brush="#00FFFFFF" Geometry="F1M16,16L0,16 0,0 16,0z" />
              <GeometryDrawing Brush="#FFF6F6F6" Geometry="F1M0.1674,2.8564L0.1674,8.4254 5.2914,11.6534 9.7554,8.3804 9.7554,2.8684 5.0504,0.386400000000001z M9.9994,5.0004L9.9994,9.5254 9.5304,9.0554 8.0004,10.5854 8.0004,12.4744 11.5254,16.0004 12.4744,16.0004 16.0004,12.4744 16.0004,10.5854 14.4694,9.0554 14.0004,9.5254 14.0004,5.0004z" />
              <GeometryDrawing Brush="#FFEFEFF0" Geometry="F1M8.1904,4.4258L5.6144,5.9918 5.6144,9.4548 8.1904,7.5988z M4.9954,9.5438L4.9954,5.9708 1.7864,4.1778 1.7864,7.4968 4.9534,9.5618 4.9534,9.5768 4.9614,9.5698 4.9704,9.5768 4.9704,9.5618z M4.9954,2.1878L8.0654,3.7008 5.2014,5.4198 2.1064,3.6548z" />
              <GeometryDrawing Brush="#FF642D90" Geometry="F1M8.1904,7.5986L5.6144,9.4546 5.6144,5.9926 8.1904,4.4256z M4.9704,9.5616L4.9704,9.5776 4.9614,9.5696 4.9534,9.5776 4.9534,9.5616 1.7864,7.4966 1.7864,4.1776 4.9954,5.9706 4.9954,9.5436z M4.9954,2.1876L8.0654,3.7016 5.2014,5.4196 2.1064,3.6546z M8.7544,7.8736L8.7544,3.4706 5.0414,1.5116 1.1674,3.4706 1.1674,7.8736 5.2484,10.4446z" />
              <GeometryDrawing Brush="#FF424242" Geometry="F1M11,7L13,7 13,6 11,6z M11,9L13,9 13,8 11,8z M11,10L11,11.939 9.53,10.469 8.47,11.531 12,15.06 15.53,11.531 14.469,10.469 13,11.939 13,10z" />
            </DrawingGroup.Children>
          </DrawingGroup>
        </DrawingBrush.Drawing>
      </DrawingBrush>
    </Rectangle.Fill>
  </Rectangle>
</Viewbox>

================================================
FILE: Au.Editor/resources/ci/Field.xaml
================================================
<!-- This file was generated by the AiToXaml tool.-->
<!-- Tool Version: 14.0.22307.0 -->
<Viewbox Width="16" Height="16" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
  <Rectangle Width="16" Height="16">
    <Rectangle.Fill>
      <DrawingBrush>
        <DrawingBrush.Drawing>
          <DrawingGroup>
            <DrawingGroup.Children>
              <GeometryDrawing Brush="#00FFFFFF" Geometry="F1M16,16L0,16 0,0 16,0z" />
              <GeometryDrawing Brush="#FFF6F6F6" Geometry="F1M9,-0.000199999999999534L0,4.4998 0,10.7358 7,14.2358 16,9.7358 16,3.4998z" />
              <GeometryDrawing Brush="#FF00529C" Geometry="F1M7,6.8818L3.236,4.9998 9,2.1178 12.764,3.9998z M9,0.9998L1,4.9998 1,9.9998 7,12.9998 15,8.9998 15,3.9998z" />
              <GeometryDrawing Brush="#FFEFEFF0" Geometry="F1M9,2.1182L12.764,4.0002 7,6.8822 3.236,5.0002z" />
            </DrawingGroup.Children>
          </DrawingGroup>
        </DrawingBrush.Drawing>
      </DrawingBrush>
    </Rectangle.Fill>
  </Rectangle>
</Viewbox>

================================================
FILE: Au.Editor/resources/ci/GroupBy.xaml
================================================
<!-- This file was generated by the AiToXaml tool.-->
<!-- Tool Version: 14.0.22307.0 -->
<Viewbox Width="16" Height="16" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
  <Rectangle Width="16" Height="16">
    <Rectangle.Fill>
      <DrawingBrush>
        <DrawingBrush.Drawing>
          <DrawingGroup>
            <DrawingGroup.Children>
              <GeometryDrawing Brush="#00FFFFFF" Geometry="F1M16,16L0,16 0,0 16,0z" />
              <GeometryDrawing Brush="#FFF6F6F6" Geometry="F1M0,-0.000199999999999534L0,15.9998 5,15.9998 5,14.9998 9,14.9998 9,13.9998 16,13.9998 16,8.9998 9,8.9998 9,6.9998 16,6.9998 16,1.9998 9,1.9998 9,0.9998 5,0.9998 5,-0.000199999999999534z" />
              <GeometryDrawing Brush="#FF424242" Geometry="F1M10,13L15,13 15,12 10,12z M10,11L15,11 15,10 10,10z M10,6L15,6 15,5 10,5z M10,4L15,4 15,3 10,3z M1,15L4,15 4,14 3,14 3,2 4,2 4,1 1,1z M5,9L5,14 8,14 8,13 7,13 7,10 8,10 8,9z M8,2L8,3 7,3 7,6 8,6 8,7 5,7 5,2z" />
            </DrawingGroup.Children>
          </DrawingGroup>
        </DrawingBrush.Drawing>
      </DrawingBrush>
    </Rectangle.Fill>
  </Rectangle>
</Viewbox>

================================================
FILE: Au.Editor/resources/ci/Interface.xaml
================================================
<!-- This file was generated by the AiToXaml tool.-->
<!-- Tool Version: 14.0.22307.0 -->
<Viewbox Width="16" Height="16" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
  <Rectangle Width="16" Height="16">
    <Rectangle.Fill>
      <DrawingBrush>
        <DrawingBrush.Drawing>
          <DrawingGroup>
            <DrawingGroup.Children>
              <GeometryDrawing Brush="#00FFFFFF" Geometry="F1M16,16L0,16 0,0 16,0z" />
              <GeometryDrawing Brush="#FFF6F6F6" Geometry="F1M11.5,12C9.585,12,7.898,10.759,7.272,9L5.862,9C5.326,9.985 4.29,10.625 3.125,10.625 1.402,10.625 0,9.223 0,7.5 0,5.777 1.402,4.375 3.125,4.375 4.29,4.375 5.326,5.014 5.862,6L7.272,6C7.898,4.241 9.585,3 11.5,3 13.981,3 16,5.019 16,7.5 16,9.981 13.981,12 11.5,12" />
              <GeometryDrawing Brush="#FFEFEFF0" Geometry="F1M11.5,9C10.673,9 10,8.326 10,7.5 10,6.672 10.673,6 11.5,6 12.327,6 13,6.672 13,7.5 13,8.326 12.327,9 11.5,9" />
              <GeometryDrawing Brush="#FF00529C" Geometry="F1M11.5,9C10.673,9 10,8.327 10,7.5 10,6.673 10.673,6 11.5,6 12.327,6 13,6.673 13,7.5 13,8.327 12.327,9 11.5,9 M11.5,4C9.738,4,8.295,5.306,8.05,7L5.185,7C4.959,6.069 4.125,5.375 3.125,5.375 1.951,5.375 1,6.326 1,7.5 1,8.674 1.951,9.625 3.125,9.625 4.125,9.625 4.959,8.931 5.185,8L8.05,8C8.295,9.694 9.738,11 11.5,11 13.433,11 15,9.433 15,7.5 15,5.567 13.433,4 11.5,4" />
            </DrawingGroup.Children>
          </DrawingGroup>
        </DrawingBrush.Drawing>
      </DrawingBrush>
    </Rectangle.Fill>
  </Rectangle>
</Viewbox>

================================================
FILE: Au.Editor/resources/ci/Keyword.xaml
================================================
<!-- This file was generated by the AiToXaml tool.-->
<!-- Tool Version: 14.0.22307.0 -->
<Viewbox Width="16" Height="16" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
  <Rectangle Width="16" Height="16">
    <Rectangle.Fill>
      <DrawingBrush>
        <DrawingBrush.Drawing>
          <DrawingGroup>
            <DrawingGroup.Children>
              <GeometryDrawing Brush="#00FFFFFF" Geometry="F1M16,16L0,16 0,0 16,0z" />
              <GeometryDrawing Brush="#FFF6F6F6" Geometry="F1M0,1.0006L0,6.0006 0,8.9996 0,12.0006 0,15.0006 13,15.0006 13,12.0006 16,12.0006 16,8.9996 15,8.9996 15,6.0006 11,6.0006 9,6.0006 9,5.0006 16,5.0006 16,2.0006 9,2.0006 9,1.0006z M8,8.9996L9,8.9996 9,12.0006 8,12.0006z" />
              <GeometryDrawing Brush="#FFEFEFF0" Geometry="F1M2,4L7,4 7,3 2,3z" />
              <GeometryDrawing Brush="#FF424242" Geometry="F1M7,3L2,3 2,4 7,4z M8,5L1,5 1,2 8,2z M15,10L10,10 10,11 15,11z M7,10L1,10 1,11 7,11z M12,13L1,13 1,14 12,14z M10,7L1,7 1,8 10,8z M14,7L12,7 12,8 14,8z M15,4L10,4 10,3 15,3z" />
            </DrawingGroup.Children>
          </DrawingGroup>
        </DrawingBrush.Drawing>
      </DrawingBrush>
    </Rectangle.Fill>
  </Rectangle>
</Viewbox>

================================================
FILE: Au.Editor/resources/ci/Label.xaml
================================================
<!-- This file was generated by the AiToXaml tool.-->
<!-- Tool Version: 14.0.22307.0 -->
<Viewbox Width="16" Height="16" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
  <Rectangle Width="16" Height="16">
    <Rectangle.Fill>
      <DrawingBrush>
        <DrawingBrush.Drawing>
          <DrawingGroup>
            <DrawingGroup.Children>
              <GeometryDrawing Brush="#00FFFFFF" Geometry="F1M16,16L0,16 0,0 16,0z" />
              <GeometryDrawing Brush="#FFF6F6F6" Geometry="F1M6.2793,-0.000199999999999534L0.9453,15.9998 5.0533,15.9998 6.0533,13.0008 9.9463,13.0008 10.9463,15.9998 15.0543,15.9998 9.7213,-0.000199999999999534z" />
              <GeometryDrawing Brush="#FF424242" Geometry="F1M8,4L10,10 6,10z M4.333,15L5.333,12 10.667,12 11.667,15 13.667,15 9,1 7,1 2.333,15z" />
            </DrawingGroup.Children>
          </DrawingGroup>
        </DrawingBrush.Drawing>
      </DrawingBrush>
    </Rectangle.Fill>
  </Rectangle>
</Viewbox>

================================================
FILE: Au.Editor/resources/ci/LocalMethod.xaml
================================================
<!-- This file was generated by the AiToXaml tool.-->
<!-- Tool Version: 14.0.22307.0 -->
<Viewbox Width="16" Height="16" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
  <Rectangle Width="16" Height="16">
    <Rectangle.Fill>
      <DrawingBrush>
        <DrawingBrush.Drawing>
          <DrawingGroup>
            <DrawingGroup.Children>
              <GeometryDrawing Brush="#00FFFFFF" Geometry="F1M16,16L0,16 0,0 16,0z" />
              <GeometryDrawing Brush="#FFF6F6F6" Geometry="F1M3.9996,4.6141L3.9996,3.0001 -0.000399999999999956,3.0001 -0.000399999999999956,13.0001 3.9996,13.0001 3.9996,11.5411 8.0006,13.8511 11.9996,11.5411 11.9996,13.0001 16.0006,13.0001 16.0006,3.0001 11.9996,3.0001 11.9996,4.6141 8.0006,2.3041z" />
              <GeometryDrawing Brush="#FF424242" Geometry="F1M13,11L13,12 15,12 15,4 13,4 13,5 14,5 14,11z M2,5L2,11 3,11 3,12 1,12 1,4 3,4 3,5z" />
              <GeometryDrawing Brush="#FF642D90" Geometry="F1M11,9.8086L8.5,11.2526 8.5,8.2986 11,6.8556z M5.558,6.0226L8,4.6136 10.442,6.0226 8,7.4336z M7.5,11.2526L5,9.8086 5,6.8556 7.5,8.2986z M8,3.4586L4,5.7676 4,10.3866 8,12.6966 12,10.3866 12,5.7676z" />
            </DrawingGroup.Children>
          </DrawingGroup>
        </DrawingBrush.Drawing>
      </DrawingBrush>
    </Rectangle.Fill>
  </Rectangle>
</Viewbox>

================================================
FILE: Au.Editor/resources/ci/LocalVariable.xaml
================================================
<!-- This file was generated by the AiToXaml tool.-->
<!-- Tool Version: 14.0.22307.0 -->
<Viewbox Width="16" Height="16" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
  <Rectangle Width="16" Height="16">
    <Rectangle.Fill>
      <DrawingBrush>
        <DrawingBrush.Drawing>
          <DrawingGroup>
            <DrawingGroup.Children>
              <GeometryDrawing Brush="#00FFFFFF" Geometry="F1M16,16L0,16 0,0 16,0z" />
              <GeometryDrawing Brush="#FFF6F6F6" Geometry="F1M5.0004,4.7482L5.0004,3.0002 0.000399999999999956,3.0002 0.000399999999999956,13.0002 5.0004,13.0002 5.0004,11.1412 7.1564,12.2182 10.9994,10.2952 10.9994,13.0002 16.0004,13.0002 16.0004,3.0002 10.9994,3.0002 10.9994,4.0142 8.7334,2.8812z" />
              <GeometryDrawing Brush="#FF424242" Geometry="F1M12,11L12,12 15,12 15,4 12,4 12,5 14,5 14,11z M2,5L2,11 4,11 4,12 1,12 1,4 4,4 4,5z" />
              <GeometryDrawing Brush="#FFEFEFF0" Geometry="F1M7.1558,7.1558L5.5778,6.3668 8.7338,4.7888 10.3118,5.5778z" />
              <GeometryDrawing Brush="#FF00529C" Geometry="F1M7.1558,7.1558L5.5778,6.3668 8.7338,4.7888 10.3118,5.5778z M8.7338,3.9998L3.9998,6.3668 3.9998,9.5228 7.1558,11.0998 11.8888,8.7328 11.8888,5.5778z" />
            </DrawingGroup.Children>
          </DrawingGroup>
        </DrawingBrush.Drawing>
      </DrawingBrush>
    </Rectangle.Fill>
  </Rectangle>
</Viewbox>

================================================
FILE: Au.Editor/resources/ci/Method.xaml
================================================
<!-- This file was generated by the AiToXaml tool.-->
<!-- Tool Version: 14.0.22307.0 -->
<Viewbox Width="16" Height="16" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
  <Rectangle Width="16" Height="16">
    <Rectangle.Fill>
      <DrawingBrush>
        <DrawingBrush.Drawing>
          <DrawingGroup>
            <DrawingGroup.Children>
              <GeometryDrawing Brush="#00FFFFFF" Geometry="F1M16,16L0,16 0,0 16,0z" />
              <GeometryDrawing Brush="#FFF6F6F6" Geometry="F1M7.5951,-0.000199999999999534L1.0001,3.3268 1.0001,11.5818 8.0701,15.9998 8.9751,15.9998 15.0001,11.7518 15.0001,3.3488 8.7131,-0.000199999999999534z" />
              <GeometryDrawing Brush="#FFEFEFF0" Geometry="F1M9,13.5361L9,7.8781 13,5.3981 13,10.7161z M3,5.1021L8,7.8941 8,13.5981 3,10.4731z M12.715,4.3981L8.487,7.0201 3.565,4.2721 8.144,1.9631z" />
              <GeometryDrawing Brush="#FF642D90" Geometry="F1M1.9998,3.9427L1.9998,11.0277 8.5168,15.0997 14.0008,11.2337 14.0008,3.9497 8.1558,0.8367z M3.5658,4.2717L8.1428,1.9627 12.7148,4.3977 8.4868,7.0197z M2.9998,10.4727L2.9998,5.1017 7.9998,7.8937 7.9998,13.5977z M8.9998,7.8787L12.9998,5.3977 12.9998,10.7157 8.9998,13.5357z" />
            </DrawingGroup.Children>
          </DrawingGroup>
        </DrawingBrush.Drawing>
      </DrawingBrush>
    </Rectangle.Fill>
  </Rectangle>
</Viewbox>

================================================
FILE: Au.Editor/resources/ci/Namespace.xaml
================================================
<!-- This file was generated by the AiToXaml tool.-->
<!-- Tool Version: 14.0.22307.0 -->
<Viewbox Width="16" Height="16" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
  <Rectangle Width="16" Height="16">
    <Rectangle.Fill>
      <DrawingBrush>
        <DrawingBrush.Drawing>
          <DrawingGroup>
            <DrawingGroup.Children>
              <GeometryDrawing Brush="#00FFFFFF" Geometry="F1M16,16L0,16 0,0 16,0z" />
              <GeometryDrawing Brush="#FFF6F6F6" Geometry="F1M5.7388,15.0156C2.6498,14.9806,2.3168,12.8516,2.3168,11.9376L2.3168,9.9206C2.3168,9.5936,2.2498,9.4896,2.2498,9.4886L1.3128,9.4286 1.2498,8.4986 1.2498,6.5626C1.2498,6.5626 2.1898,6.5036 2.1918,6.5036 2.2498,6.5036 2.3168,6.3896 2.3168,6.0516L2.3168,4.0896C2.3168,2.1406,3.5638,1.0086,5.7388,0.984599999999999L6.7498,0.973599999999999 6.7498,4.0196 5.7748,4.0436C5.7298,4.0446 5.6998,4.0486 5.6818,4.0526 5.6878,4.0746 5.6628,4.1676 5.6628,4.3496L5.6628,6.2776C5.6628,6.9526 5.4778,7.5306 5.1298,7.9816 5.4778,8.4316 5.6628,9.0096 5.6628,9.6886L5.6628,11.5956C5.6628,11.7706 5.6768,11.8866 5.6898,11.9586 5.7128,11.9606 6.7498,11.9846 6.7498,11.9846L6.7498,15.0276z M9.2598,11.9846L10.2378,11.9626C10.2738,11.9616 10.3038,11.9596 10.3268,11.9566 10.3378,11.8936 10.3538,11.7786 10.3538,11.5956L10.3538,9.6886C10.3538,9.0096 10.5378,8.4316 10.8838,7.9816 10.5378,7.5306 10.3538,6.9526 10.3538,6.2776L10.3538,4.3496C10.3538,4.1826 10.3328,4.0906 10.3198,4.0476 10.3178,4.0476 9.2598,4.0196 9.2598,4.0196L9.2598,0.973599999999999 10.2708,0.984599999999999C12.4378,1.0086,13.6798,2.1406,13.6798,4.0896L13.6798,6.0516C13.6798,6.4026,13.7508,6.5136,13.7518,6.5146L14.6878,6.5746 14.7398,7.5006 14.7398,9.4366 13.8048,9.4966C13.7288,9.5126,13.6798,9.6436,13.6798,9.9206L13.6798,11.9376C13.6798,12.8516,13.3478,14.9806,10.2718,15.0156L9.2598,15.0276z" />
              <GeometryDrawing Brush="#FF424242" Geometry="F1M13.7397,8.499C13.0337,8.544,12.6797,9.019,12.6797,9.921L12.6797,11.937C12.6797,13.305,11.8737,13.997,10.2607,14.016L10.2607,12.963C10.6567,12.954 10.9377,12.845 11.1037,12.635 11.2707,12.425 11.3537,12.079 11.3537,11.596L11.3537,9.688C11.3537,8.763,11.8027,8.201,12.7007,8L12.7007,7.979C11.8027,7.765,11.3537,7.198,11.3537,6.277L11.3537,4.35C11.3537,3.498,10.9897,3.062,10.2607,3.044L10.2607,1.984C11.8737,2.002,12.6797,2.705,12.6797,4.09L12.6797,6.052C12.6797,6.972,13.0337,7.456,13.7397,7.501z M5.7497,14.016C4.1277,13.997,3.3167,13.305,3.3167,11.937L3.3167,9.921C3.3167,9.019,2.9607,8.544,2.2497,8.499L2.2497,7.501C2.9607,7.456,3.3167,6.972,3.3167,6.052L3.3167,4.09C3.3167,2.705,4.1277,2.002,5.7497,1.984L5.7497,3.044C5.0257,3.062,4.6627,3.498,4.6627,4.35L4.6627,6.277C4.6627,7.198,4.2097,7.765,3.3027,7.979L3.3027,8C4.2097,8.201,4.6627,8.763,4.6627,9.688L4.6627,11.596C4.6627,12.083 4.7437,12.431 4.9057,12.638 5.0677,12.846 5.3487,12.954 5.7497,12.963z" />
            </DrawingGroup.Children>
          </DrawingGroup>
        </DrawingBrush.Drawing>
      </DrawingBrush>
    </Rectangle.Fill>
  </Rectangle>
</Viewbox>

================================================
FILE: Au.Editor/resources/ci/Operator.xaml
================================================
<!-- This file was generated by the AiToXaml tool.-->
<!-- Tool Version: 14.0.22307.0 -->
<Viewbox Width="16" Height="16" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
  <Rectangle Width="16" Height="16">
    <Rectangle.Fill>
      <DrawingBrush>
        <DrawingBrush.Drawing>
          <DrawingGroup>
            <DrawingGroup.Children>
              <GeometryDrawing Brush="#00FFFFFF" Geometry="F1M16,16L0,16 0,0 16,0z" />
              <GeometryDrawing Brush="#FFF6F6F6" Geometry="F1M16,8C16,12.418 12.418,16 8,16 3.582,16 0,12.418 0,8 0,3.582 3.582,0 8,0 12.418,0 16,3.582 16,8" />
              <GeometryDrawing Brush="#FF424242" Geometry="F1M10.1064,11.95L8.9184,11.925 11.0004,8 12.1604,8z" />
              <GeometryDrawing Brush="#FF424242" Geometry="F1M8.0331,1C4.1671,1 1.0331,4.134 1.0331,8 1.0331,11.866 4.1671,15 8.0331,15 11.8991,15 15.0331,11.866 15.0331,8 15.0331,4.134 11.8991,1 8.0331,1 M8.0331,2C11.3411,2 14.0331,4.692 14.0331,8 14.0331,11.308 11.3411,14 8.0331,14 4.7251,14 2.0331,11.308 2.0331,8 2.0331,4.692 4.7251,2 8.0331,2" />
              <GeometryDrawing Brush="#FF424242" Geometry="F1M8,5L6,5 6,3 5,3 5,5 3,5 3,6 5,6 5,8 6,8 6,6 8,6z" />
              <GeometryDrawing Brush="#FF424242" Geometry="F1M13,6L9,6 9,5 13,5z" />
              <GeometryDrawing Brush="#FF424242" Geometry="F1M8,10L4,10 4,9 8,9z" />
              <GeometryDrawing Brush="#FF424242" Geometry="F1M8,12L4,12 4,11 8,11z" />
              <GeometryDrawing Brush="#FFEFEFF0" Geometry="F1M9,5L13,5 13,6 9,6z M10.106,11.95L8.918,11.924 11,8 12.16,8z M8,6L6,6 6,8 5,8 5,6 3,6 3,5 5,5 5,3 6,3 6,5 8,5z M8,10L4,10 4,9 8,9z M8,12L4,12 4,11 8,11z M8.033,2C4.725,2 2.033,4.692 2.033,8 2.033,11.308 4.725,14 8.033,14 11.341,14 14.033,11.308 14.033,8 14.033,4.692 11.341,2 8.033,2" />
            </DrawingGroup.Children>
          </DrawingGroup>
        </DrawingBrush.Drawing>
      </DrawingBrush>
    </Rectangle.Fill>
  </Rectangle>
</Viewbox>

================================================
FILE: Au.Editor/resources/ci/OverlayAbstract.xaml
================================================
<?xml version="1.0" encoding="UTF-8"?>
<!--This file is compatible with Silverlight-->
<Canvas xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" Name="svg11" Width="16" Height="16">
  <Canvas.RenderTransform>
    <TranslateTransform X="0" Y="0"/>
  </Canvas.RenderTransform>
  <Canvas.Resources/>
  <!--Unknown tag: metadata-->
  <!--Unknown tag: sodipodi:namedview-->
  <TextBlock xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" FontSize="9.33333302" FontWeight="Normal" FontFamily="Verdana" FontStyle="normal" Foreground="#FF0046FD" Canvas.Left="7.4077458" Canvas.Top="-3.2" Name="text18">
    <Span FontSize="9.33333302">a</Span>
  </TextBlock>
</Canvas>


================================================
FILE: Au.Editor/resources/ci/OverlayInternal.xaml
================================================
<?xml version="1.0" encoding="UTF-8"?>
<!--This file is compatible with Silverlight-->
<Canvas xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" Name="svg11" Width="16" Height="16">
  <Canvas.RenderTransform>
    <TranslateTransform X="0" Y="0"/>
  </Canvas.RenderTransform>
  <Canvas.Resources/>
  <!--Unknown tag: metadata-->
  <!--Unknown tag: sodipodi:namedview-->
  <Canvas Name="outline">
    <Canvas.RenderTransform>
      <TranslateTransform X="-8.8813559" Y="-8.9491525"/>
    </Canvas.RenderTransform>
    <Path xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" Name="path4" Fill="#FFF6F6F6" Opacity="0" Data="M 0 0 H 16 V 16 H 0 Z"/>
    <Path xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" Name="path6" Fill="#FFF6F6F6" Data="M 9.5 4 H 6.414 L 9 1.414 V 0 H 3.382 L 0 6.764 V 8 h 2.382 l -2 4 H 2.914 L 9.5 5.414 Z m 4.071 5 C 13.295 9 12.894 9.055 12.5 9.305 A 1.996 1.996 0 0 0 11.429 9 C 10.112 9 9 10.137 9 11.482 c 0 0.594 0.196 1.188 0.561 1.656 0.293 0.355 2.246 2.529 2.246 2.529 L 12.104 16 h 0.909 l 0.3 -0.352 c 0 0 1.836 -2.159 2.148 -2.535 0.343 -0.442 0.54 -1.037 0.54 -1.631 C 16 10.137 14.888 9 13.571 9 Z"/>
  </Canvas>
  <Path xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" Name="color_x5F_importance" Fill="#FFC27D1A" Data="m -4.8813559 -3.9491525 3.99999997 -4 H -4.8813559 l -3 6 h 3.018 l -2.018 4 h 0.518 l 5.99999997 -6 z"/>
  <Path xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" Name="not_x5F_bg" Fill="#FF424242" Data="m 4.6896441 1.0508475 c -0.527 0 -0.86 0.747 -1.071 1.25 -0.211 -0.503 -0.545 -1.25 -1.071 -1.25 -0.728 0 -1.429 0.664 -1.429 1.482 0 0.375 0.127 0.756 0.329 1.018 0.29 0.35 2.222 2.5 2.222 2.5 0 0 1.829 -2.15 2.119 -2.5 0.203 -0.262 0.33 -0.643 0.33 -1.018 0 -0.818 -0.7 -1.482 -1.429 -1.482 z"/>
</Canvas>


================================================
FILE: Au.Editor/resources/ci/OverlayPrivate.xaml
================================================
<?xml version="1.0" encoding="UTF-8"?>
<!--This file is compatible with Silverlight-->
<Canvas xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" Name="svg14" Width="16" Height="16">
  <Canvas.RenderTransform>
    <TranslateTransform X="0" Y="0"/>
  </Canvas.RenderTransform>
  <Canvas.Resources/>
  <!--Unknown tag: metadata-->
  <!--Unknown tag: sodipodi:namedview-->
  <Canvas Name="outline">
    <Canvas.RenderTransform>
      <TranslateTransform X="-8.9491525" Y="-8"/>
    </Canvas.RenderTransform>
    <Path xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" Name="path4" Fill="#FFF6F6F6" Data="M 6.414 4 9 1.414 V 0 H 3.382 L 0 6.764 V 8 h 2.382 l -2 4 H 2.914 L 9.5 5.414 V 4 Z M 9 16 9.005 12.016 c 0 0 -0.225 -3.984 3.589 -3.984 1.532 0 3.406 0.967 3.406 3.976 V 16 Z"/>
    <Path xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" Name="path6" Fill="#FFF0EFF1" Data="m 13 14 h -1 v -0.959 h 1 z"/>
  </Canvas>
  <Path xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" Name="color_x5F_importance" Fill="#FFC27D1A" Data="m -4.9491525 -3 3.99999996 -4 H -4.9491525 l -3 6 h 3.018 l -2.018 4 h 0.518 l 5.99999996 -6 z"/>
  <Canvas Name="not_x5F_bg">
    <Canvas.RenderTransform>
      <TranslateTransform X="-8.9491525" Y="-8"/>
    </Canvas.RenderTransform>
    <Path xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" Name="path10" Fill="#FF424242" Data="m 11.019 11.563 c 0.059 -0.729 0.334 -1.541 1.575 -1.541 1.249 0 1.391 0.795 1.404 1.541 h 0.966 c -0.085 -1.119 -0.144 -2.531 -2.37 -2.531 -2.396 0 -2.445 1.406 -2.576 2.531 z M 14 12 h -4 v 3 h 5 v -3 z m -1 2 h -1 v -1 h 1 z"/>
  </Canvas>
  <Path xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" Name="not_x5F_fg" Fill="#FFF0EFF1" Data="m 3.0508475 5 h 1 v 1 h -1 z"/>
</Canvas>


================================================
FILE: Au.Editor/resources/ci/OverlayProtected.xaml
================================================
<?xml version="1.0" encoding="UTF-8"?>
<!--This file is compatible with Silverlight-->
<Canvas xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" Name="svg11" Width="16" Height="16">
  <Canvas.RenderTransform>
    <TranslateTransform X="0" Y="0"/>
  </Canvas.RenderTransform>
  <Canvas.Resources/>
  <!--Unknown tag: metadata-->
  <!--Unknown tag: sodipodi:namedview-->
  <Canvas Name="outline">
    <Canvas.RenderTransform>
      <MatrixTransform Matrix="1.2 0 0 1.2 -10.740369 -10.713749"/>
    </Canvas.RenderTransform>
    <Path xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" Name="path4" Fill="#FFF6F6F6" Opacity="0" Data="M 0 0 H 16 V 16 H 0 Z"/>
    <Path xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" Name="path6" Fill="#FFF6F6F6" Data="M 6.414 4 9 1.414 V 0 H 3.382 L 0 6.764 V 8 h 2.382 l -2 4 H 2.914 L 9.5 5.414 V 4 Z M 14.607 13.545 16 12.5 V 11 h -2.156 l -0.6 -2 h -1.488 l -0.6 2 H 9 v 1.5 L 10.393 13.545 9.656 16 h 1.677 L 12.5 15.125 13.667 16 h 1.677 z"/>
  </Canvas>
  <Path xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" Name="color_x5F_importance" Fill="#FFC27D1A" StrokeThickness="1.20000005" Data="m -5.0331559 -4.1491525 4.79999997 -4.8 H -5.0331559 l -3.6 7.2 h 3.6216 l -2.4216 4.8 h 0.6216 l 7.19999997 -7.2 z"/>
  <Path xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" Name="not_x5F_bg" Fill="#FF424242" StrokeThickness="1.20000005" Data="m 5.3676135 5.024414 1.8612 -1.3956 H 4.9488136 l -0.72 -2.4 -0.72 2.4 h -2.28 l 1.8612 1.3956 -0.6612 2.2044 1.8 -1.35 1.7999999 1.35 z"/>
</Canvas>


================================================
FILE: Au.Editor/resources/ci/OverlayStatic.xaml
================================================
<?xml version="1.0" encoding="UTF-8"?>
<!--This file is compatible with Silverlight-->
<Canvas xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" Name="svg11" Width="16" Height="16">
  <Canvas.RenderTransform>
    <TranslateTransform X="0" Y="0"/>
  </Canvas.RenderTransform>
  <Canvas.Resources/>
  <!--Unknown tag: metadata-->
  <!--Unknown tag: sodipodi:namedview-->
  <TextBlock xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" FontSize="9.33333302" FontWeight="Normal" FontFamily="Verdana" FontStyle="normal" Foreground="#FF0046FD" Canvas.Left="7.3898301" Canvas.Top="-3.2" Name="text18">
    <Span FontSize="9.33333302">s</Span>
  </TextBlock>
</Canvas>


================================================
FILE: Au.Editor/resources/ci/Property.xaml
================================================
<!-- This file was generated by the AiToXaml tool.-->
<!-- Tool Version: 14.0.22307.0 -->
<Viewbox Width="16" Height="16" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
  <Rectangle Width="16" Height="16">
    <Rectangle.Fill>
      <DrawingBrush>
        <DrawingBrush.Drawing>
          <DrawingGroup>
            <DrawingGroup.Children>
              <GeometryDrawing Brush="#00FFFFFF" Geometry="F1M16,16L0,16 0,0 16,0z" />
              <GeometryDrawing Brush="#FFF6F6F6" Geometry="F1M16,5.5C16,8.538 13.538,11 10.5,11 10.225,11 9.957,10.973 9.693,10.934 9.667,10.93 9.641,10.927 9.615,10.922 9.337,10.877 9.066,10.816 8.804,10.731L4.268,15.268C3.795,15.74 3.167,16 2.5,16 1.833,16 1.205,15.74 0.731999999999999,15.268 -0.242000000000001,14.293 -0.242000000000001,12.707 0.731999999999999,11.732L5.269,7.196C5.184,6.934 5.123,6.662 5.078,6.384 5.073,6.359 5.07,6.333 5.066,6.307 5.027,6.043 5,5.775 5,5.5 5,2.462 7.462,0 10.5,0 13.538,0 16,2.462 16,5.5" />
              <GeometryDrawing Brush="#FF424242" Geometry="F1M15,5.5C15,7.985 12.985,10 10.5,10 9.807,10 9.158,9.83 8.571,9.55L3.561,14.561C3.268,14.854 2.884,15 2.5,15 2.116,15 1.732,14.854 1.439,14.561 0.853999999999999,13.975 0.853999999999999,13.025 1.439,12.439L6.45,7.429C6.17,6.842 6,6.193 6,5.5 6,3.015 8.015,1 10.5,1 11.193,1 11.842,1.17 12.429,1.45L9.636,4.243 11.757,6.364 14.55,3.571C14.83,4.158,15,4.807,15,5.5" />
            </DrawingGroup.Children>
          </DrawingGroup>
        </DrawingBrush.Drawing>
      </DrawingBrush>
    </Rectangle.Fill>
  </Rectangle>
</Viewbox>

================================================
FILE: Au.Editor/resources/ci/Region.xaml
================================================
<!-- This file was generated by the AiToXaml tool.-->
<!-- Tool Version: 14.0.22307.0 -->
<Viewbox Width="16" Height="16" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
  <Rectangle Width="16" Height="16">
    <Rectangle.Fill>
      <DrawingBrush>
        <DrawingBrush.Drawing>
          <DrawingGroup>
            <DrawingGroup.Children>
              <GeometryDrawing Brush="#00FFFFFF" Geometry="F1M16,16L0,16 0,0 16,0z" />
              <GeometryDrawing Brush="#FFF6F6F6" Geometry="F1M1.9998,-0.000199999999999534L1.9998,15.9998 15.0008,15.9998 15.0008,4.3788 10.6208,-0.000199999999999534z" />
              <GeometryDrawing Brush="#FF424242" Geometry="F1M14,8L13,8 13,9 14,9z M12,8L11,8 11,9 12,9z M10,8L9,8 9,9 10,9z M4,8L3,8 3,9 4,9z M8,8L7,8 7,9 8,9z M6,8L5,8 5,9 6,9z M10,5L12.793,5 10,2.207z M3,7L3,1 10.207,1 14,4.793 14,7 13,7 13,6 9,6 9,2 4,2 4,7z M14,10L14,15 3,15 3,10 4,10 4,14 13,14 13,10z" />
              <GeometryDrawing Brush="#FFEFEFF0" Geometry="F1M10,2.207L10,5 12.793,5z" />
              <GeometryDrawing Brush="#FFEFEFF0" Geometry="F1M4,14L13,14 13,10 4,10z" />
              <GeometryDrawing Brush="#FFEFEFF0" Geometry="F1M13,7L13,6 9,6 9,2 4,2 4,7z" />
              <GeometryDrawing Brush="#FFF0EFF1" Geometry="F1M10,2.207L10,5 12.793,5z" />
              <GeometryDrawing Brush="#FFF0EFF1" Geometry="F1M4,14L13,14 13,10 4,10z" />
              <GeometryDrawing Brush="#FFF0EFF1" Geometry="F1M13,7L13,6 9,6 9,2 4,2 4,7z" />
            </DrawingGroup.Children>
          </DrawingGroup>
        </DrawingBrush.Drawing>
      </DrawingBrush>
    </Rectangle.Fill>
  </Rectangle>
</Viewbox>

================================================
FILE: Au.Editor/resources/ci/Snippet.xaml
================================================
<!-- This file was generated by the AiToXaml tool.-->
<!-- Tool Version: 14.0.22307.0 -->
<Viewbox Width="16" Height="16" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
  <Rectangle Width="16" Height="16">
    <Rectangle.Fill>
      <DrawingBrush>
        <DrawingBrush.Drawing>
          <DrawingGroup>
            <DrawingGroup.Children>
              <GeometryDrawing Brush="#00FFFFFF" Geometry="F1M16,16L0,16 0,0 16,0z" />
              <GeometryDrawing Brush="#FFF6F6F6" Geometry="F1M2,0L15,0 15,15 2,15z" />
              <GeometryDrawing Brush="#FF414141" Geometry="F1M7,14L8,14 8,13 7,13z" />
              <GeometryDrawing Brush="#FF414141" Geometry="F1M5,14L6,14 6,13 5,13z" />
              <GeometryDrawing Brush="#FF414141" Geometry="F1M3,14L4,14 4,13 3,13z" />
              <GeometryDrawing Brush="#FF414141" Geometry="F1M9,14L10,14 10,13 9,13z" />
              <GeometryDrawing Brush="#FF414141" Geometry="F1M11,14L12,14 12,13 11,13z" />
              <GeometryDrawing Brush="#FF414141" Geometry="F1M13,14L14.001,14 14.001,13 13,13z" />
              <GeometryDrawing Brush="#FF414141" Geometry="F1M3,1L3,12 4,12 4,2 13,2 13,12 14,12 14,1z" />
              <GeometryDrawing Brush="#FFF0EFF1" Geometry="F1M13,12L4,12 4,2 13,2z" />
            </DrawingGroup.Children>
          </DrawingGroup>
        </DrawingBrush.Drawing>
      </DrawingBrush>
    </Rectangle.Fill>
  </Rectangle>
</Viewbox>

================================================
FILE: Au.Editor/resources/ci/Structure.xaml
================================================
<!-- This file was generated by the AiToXaml tool.-->
<!-- Tool Version: 14.0.22307.0 -->
<Viewbox Width="16" Height="16" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
  <Rectangle Width="16" Height="16">
    <Rectangle.Fill>
      <DrawingBrush>
        <DrawingBrush.Drawing>
          <DrawingGroup>
            <DrawingGroup.Children>
              <GeometryDrawing Brush="#00FFFFFF" Geometry="F1M16,16L0,16 0,0 16,0z" />
              <GeometryDrawing Brush="#FFF6F6F6" Geometry="F1M1,15L1,6 5,6 5,1 15,1 15,10 11,10 11,15z" />
              <GeometryDrawing Brush="#FF00539C" Geometry="F1M14,9L11,9 11,6 6,6 6,2 14,2z M10,14L2,14 2,7 10,7z" />
            </DrawingGroup.Children>
          </DrawingGroup>
        </DrawingBrush.Drawing>
      </DrawingBrush>
    </Rectangle.Fill>
  </Rectangle>
</Viewbox>

================================================
FILE: Au.Editor/resources/ci/TypeParameter.xaml
================================================
<!-- This file was generated by the AiToXaml tool.-->
<!-- Tool Version: 14.0.22307.0 -->
<Viewbox Width="16" Height="16" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
  <Rectangle Width="16" Height="16">
    <Rectangle.Fill>
      <DrawingBrush>
        <DrawingBrush.Drawing>
          <DrawingGroup>
            <DrawingGroup.Children>
              <GeometryDrawing Brush="#00FFFFFF" Geometry="F1M16,16L0,16 0,0 16,0z" />
              <GeometryDrawing Brush="#FFF6F6F6" Geometry="F1M2.9997,1.9996L2.9997,5.0006 -0.000300000000000189,5.0006 -0.000300000000000189,13.0006 8.9997,13.0006 8.9997,9.9996 11.9997,9.9996 11.9997,1.9996z" />
              <GeometryDrawing Brush="#FFEFEFF0" Geometry="F1M2,11L7,11 7,7 2,7z M10,4L10,8 8,8 8,6 5,6 5,4z" />
              <GeometryDrawing Brush="#FF00529C" Geometry="F1M10,8L8,8 8,6 5,6 5,4 10,4z M7,11L2,11 2,7 7,7z M4,3L4,6 1,6 1,12 8,12 8,9 11,9 11,3z" />
            </DrawingGroup.Children>
          </DrawingGroup>
        </DrawingBrush.Drawing>
      </DrawingBrush>
    </Rectangle.Fill>
  </Rectangle>
</Viewbox>

================================================
FILE: Au.Editor/xAI/AI search.cs
================================================
using System.Text.Json.Nodes;
using System.Net.Http;
using System.Buffers.Text;
using LA;
using System.Text.Json;
using System.Text.Json.Serialization;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows;

namespace AI;

class Embeddings(AiEmbeddingModel model) {
	/// <summary>
	/// Calls AI embeddings API to get embedding vectors for any number of strings or multimodal data.
	/// </summary>
	/// <param name="input">0 or more.</param>
	/// <param name="forDatabase">true if for a vector database. false if for a query. Some API have optimization parameters for it.</param>
	/// <param name="getInt8"><c>true</c> - get list of <c>sbyte[]</c>. <c>false</c> - get list of <c>float[]</c>.</param>
	/// <exception cref="OperationCanceledException"></exception>
	/// <exception cref="Exception"></exception>
	public List<Array> CreateEmbeddings(IList<EmInput> input, bool forDatabase, bool getInt8 = false, CancellationToken cancel = default) {
		if (input.Count == 0) return [];
		
		var headers = model.GetHeaders();
		var allVectors = new List<Array>();
		long downloadSize = 0;
		dialog pd = null;
		using CancellationTokenSource cts = cancel != default ? CancellationTokenSource.CreateLinkedTokenSource(cancel) : new();
		if (input.Count == 1) {
			_GetBatch(input);
		} else {
			try {
				var batch = new List<EmInput>();
				int sizeSum = 0;
				int tokensToDisplay = 0;
				var lim = model.limits;
				
				foreach (var (i, data) in input.Index()) {
					int nextSize = sizeSum + data.Size;
					if ((lim.maxTokens > 0 && nextSize / 2 >= lim.maxTokens) || (lim.maxInputs > 0 && batch.Count == lim.maxInputs) || (lim.maxSize > 0 && nextSize >= lim.maxSize)) {
						if (batch.Count == 0) batch.Add(data); //try anyway
						if (pd == null) {
							var url = string.Concat(model.url.Chunk(50).Select(o => { var s = new string(o); return s.Length < 50 ? s : s.Insert(s.LastIndexOfAny('/', ':') + 1, "\n  "); }));
							pd = dialog.showProgress(false, "Creating AI search vectors", flags: DFlags.ExpandDown, expandedText: $"API: {model.api}\nModel: {model.model}\nURL: {url}", footer: " ");
							pd.Destroyed += _pd_Destroyed;
						}
						int batchTokens = _GetBatch(batch);
						bool noTokens = batchTokens == 0;
						tokensToDisplay += noTokens ? sizeSum / 3 : batchTokens;
						sizeSum = 0;
						batch.Clear();
						if (i < input.Count - 1) {
							if (!pd.IsOpen) { pd = null; throw new OperationCanceledException(); } //clicked Cancel
							pd.Send.Progress(Math2.PercentFromValue(input.Count, allVectors.Count));
							pd.Send.ChangeFooterText($"Tokens: {(noTokens ? "~" : null)}{tokensToDisplay.ToString("N0")}.  Downloaded: {downloadSize / (1024 * 1024)} MB.", false);
						}
					}
					batch.Add(data);
					sizeSum += data.Size;
				}
				if (batch.Count > 0) _GetBatch(batch);
			}
			finally {
				pd?.Destroyed -= _pd_Destroyed;
				pd?.Send.Close();
			}
			
			void _pd_Destroyed(DEventArgs _) { cts.Cancel(); }
		}
		return allVectors;
		
		int _GetBatch(IList<EmInput> input) {
			object post = model.GetPostData(input, isQuery: !forDatabase);
			//print.it(JsonSerializer.Serialize(post)); throw null;
			var r = model.Post(post, headers: headers, cts.Token);
			var bytes = r.Bytes();
			downloadSize += bytes.Length; //never mind: probably downloads less, because of compression
			var json = JsonNode.Parse(bytes);
			
			//print.it(json.ToJsonString(new(System.Text.Json.JsonSerializerDefaults.Web) { WriteIndented = true }));
			//print.it(json["usage"].ToJsonString(new(System.Text.Json.JsonSerializerDefaults.Web) { WriteIndented = true }));
			//print.it(json["data"].ToJsonString(new(System.Text.Json.JsonSerializerDefaults.Web) { WriteIndented = true }));
			
			var ja = model.GetVectors(json);
			foreach (var v in ja) {
				float[] f = null; sbyte[] b = null;
				if (v is JsonArray aj) {
					if (aj.Count != model.dimensions) throw new InvalidOperationException($"Returned array length ({aj.Count} elements) does not match model's dimensions ({model.dimensions}).");
					if (aj.All(o => o.AsValue().TryGetValue(out int i_))) {
						b = new sbyte[aj.Count];
						for (int j = 0; j < aj.Count; j++) b[j] = (sbyte)(int)aj[j];
					} else {
						f = new float[aj.Count];
						for (int j = 0; j < aj.Count; j++) f[j] = (float)aj[j];
					}
				} else { //OpenAI, Voyage and Cohere can return float[] as base64 string
					var base64 = v.GetValue<string>();
					var t = Convert.FromBase64String(base64);
					if (t.Length == model.dimensions) b = MemoryMarshal.Cast<byte, sbyte>(t).ToArray();
					else if (t.Length == model.dimensions * 4) f = MemoryMarshal.Cast<byte, float>(t).ToArray();
					else throw new InvalidOperationException($"Returned data length ({t.Length} bytes) does not match model's dimensions ({model.dimensions}).");
				}
				if (getInt8) {
					if (b is null) {
						b = new sbyte[f.Length];
						for (int j = 0; j < f.Length; j++) b[j] = (sbyte)Math.Round(f[j] * 127);
#if DEBUG
						sbyte min = b.Min(), max = b.Max();
						if (min < -100 || max > 100) Debug_.Print($"{min}, {max}");
#endif
					}
					allVectors.Add(b);
				} else {
					if (f is null) {
						f = new float[b.Length];
						for (int j = 0; j < b.Length; j++) f[j] = b[j] / 127f;
					}
					allVectors.Add(f);
				}
			}
			
			return model.GetTokens(json);
		}
	}
	
	/// <summary>
	/// Calls AI embeddings API to get embedding vector for single string or multimodal data used for a query.
	/// </summary>
	/// <exception cref="OperationCanceledException"></exception>
	/// <exception cref="Exception"></exception>
	public float[] CreateEmbedding(EmInput input, CancellationToken cancel = default) => CreateEmbeddings([input], forDatabase: false, cancel: cancel)[0] as float[];
	
	public static string VectorDir { get; } = folders2.LaDataRoaming + @"AI\Embedding"; //note: don't use the common app data folder
	
	List<EmVector> _GetEmbeddings(string dbPath, bool compact, Func<(List<string> names, List<EmInput> datas)> getData, CancellationToken cancel) {
		_EmHash newHash = _Hash(dbPath), oldHash = default;
		string emPath = VectorDir + $@"\{model.GetType()}-{pathname.getNameNoExt(dbPath)}.bin";
		var emFile = new _EmStorageFile(emPath);
		List<EmVector> ems = null;
		bool retried = false; gRetry:
		if (filesystem.exists(emPath).File) {
			try { ems = emFile.Load(out oldHash); }
			catch (Exception ex) when (emFile.Reading && ex is not OutOfMemoryException) { print.warning(ex); }
			
			//emFile.PrintUploadIfAtHome(model, newHash);
		}
		bool exists = ems != null && oldHash.modelParams == newHash.modelParams;
		if (exists && oldHash.hash == newHash.hash) return ems;
		
		if (!exists && !retried) {
			retried = true;
			if (emFile.TryDownload(model, newHash)) goto gRetry;
		}
		
		var (names, datas) = getData();
		List<(string name, EmInput data, Array vec)> aSame = null;
		
		if (exists) { //get embeddings only for new and changed texts
			var dOld = emFile.LoadForUpdate();
			aSame = new(dOld.Count);
			int j = 0;
			for (int i = 0; i < names.Count; i++) {
				string name = names[i];
				EmInput data = datas[i];
				if (dOld.TryGetValue(name, out var old) && old.hash == data.GetHash()) {
					aSame.Add((name, data, old.vec));
				} else {
					names[j] = name;
					datas[j++] = data;
				}
			}
			names.RemoveRange(j, names.Count - j);
			datas.RemoveRange(j, datas.Count - j);
		}
		//print.it(names.Count);
		
		if (names.Count > 250 && !retried) {
			retried = true;
			if (emFile.TryDownload(model, newHash)) goto gRetry;
		}
		
		var vectors = CreateEmbeddings(datas, forDatabase: true, getInt8: compact, cancel);
		
		if (exists) {
			foreach (var v in aSame) { names.Add(v.name); datas.Add(v.data); vectors.Add(v.vec); }
		}
		
		emFile.Save(names, vectors, datas, newHash);
		
		emFile.PrintUploadIfAtHome(model, newHash);
		
		return emFile.Load(out _);
		
		_EmHash _Hash(string file) {
			var hash = System.Security.Cryptography.SHA256.HashData(filesystem.loadBytes(file));
			return new(Base64Url.EncodeToString(hash), $"{model.model};{model.dimensions};{model.emType}");
		}
	}
	
	#region docs
	
	static string s_dbFileDocs = folders2.La + "doc-ai.db";
	
	/// <summary>
	/// Loads or creates/updates embeddings for docs.
	/// </summary>
	/// <exception cref="OperationCanceledException"></exception>
	/// <exception cref="Exception"></exception>
	public List<EmVector> GetDocsEmbeddings(CancellationToken cancel = default) {
		return _GetEmbeddings(s_dbFileDocs, false, _GetData, cancel);
		
		static (List<string> names, List<EmInput> texts) _GetData() {
			List<string> names = [];
			List<EmInput> texts = [];
			using var db = new sqlite(s_dbFileDocs, SLFlags.SQLITE_OPEN_READONLY);
			using var sta = db.Statement("SELECT name,summary,text FROM doc");
			while (sta.Step()) {
				string name = sta.GetText(0), sum = sta.GetText(1), text = sta.GetText(2);
				names.Add(name);
				texts.Add(text);
				if (!sum.NE()) {
					names.Add("+" + name);
					texts.Add(sum);
				}
			}
			return (names, texts);
		}
	}
	
	public string[] GetDocsTexts(IEnumerable<string> names) {
		string[] an = names.ToArray();
		var a = new string[an.Length];
		using var db = new sqlite(s_dbFileDocs, SLFlags.SQLITE_OPEN_READONLY);
		using var sta = db.Statement($"SELECT name,text FROM doc WHERE name IN ({string.Join(',', an.Select(_ => "?"))})");
		sta.BindAll(an);
		while (sta.Step()) {
			string name = sta.GetText(0), text = sta.GetText(1);
			a[an.IndexOf(name)] = text;
		}
		if (a.Contains(null)) throw new ArgumentException();
		return a;
	}
	
	#endregion
	
	#region icons
	
	static string s_dbFileIcons = folders2.La + "icons.db";
	
	/// <summary>
	/// Loads or creates/updates embeddings for icons.
	/// </summary>
	/// <exception cref="OperationCanceledException"></exception>
	/// <exception cref="Exception"></exception>
	public List<EmVector> GetIconsEmbeddings(bool withImages, CancellationToken cancel = default) {
		return _GetEmbeddings(s_dbFileIcons, true, _GetData, cancel);
		
		(List<string> names, List<EmInput> texts) _GetData() {
			var rx1 = new regexp(@"([a-z0-9])([A-Z])");
			var rx2 = new regexp(@"([A-Z])([A-Z][a-z])");
			
			if (withImages) {
				using var db = new sqlite(s_dbFileIcons, SLFlags.SQLITE_OPEN_READONLY);
				
				int _TotalCount() {
					db.Get(out string sql, """SELECT 'SELECT ' || group_concat('(SELECT COUNT(*) FROM "' || name || '")', ' + ') || ';' AS sql FROM _tables;""");
					db.Get(out int n, sql);
					return n;
				}
				int nTotal = _TotalCount();
				int nn = 0, percent = 0;
				var dp = dialog.showProgress(false, "Preparing data for AI search");
				
				List<string> names = new(nTotal);
				List<EmInput> a = new(nTotal);
				using var stTables = db.Statement("SELECT * FROM _tables");
				while (stTables.Step()) {
					var table = stTables.GetText(0);
					//if (table!="Material") continue;
					var templ = stTables.GetText(1);
					var tc = XamlIconConverter_.GetConverter(templ) ?? throw new NotImplementedException("Unknown XAML: " + templ);
					
					using var stIcons = db.Statement("SELECT name,data FROM " + table);
					while (stIcons.Step()) {
						var name = stIcons.GetText(0);
						names.Add($"{table}.{name}");
						string text = _SplitName(name);
						
						tc.PathData = stIcons.GetText(1);
						var png = tc.ToPng(64, 96, Brushes.White);
						
						text = $"Icon named \"{text}\"";
						a.Add((object[])[text, png]);
						
						if (!dp.IsOpen) throw new OperationCanceledException();
						int percent2 = Math2.PercentFromValue(nTotal, ++nn);
						if (percent2 > percent) dp.Send.Progress(percent = percent2);
					}
				}
				dp.Send.Close();
				
				return (names, a);
			} else {
				List<string> names = _GetUniqueIconNames();
				List<EmInput> texts = new(names.Count);
				foreach (var name in names) {
					texts.Add(_SplitName(name));
				}
				return (names, texts);
				
				static List<string> _GetUniqueIconNames() {
					HashSet<string> h = new(60000, StringComparer.OrdinalIgnoreCase);
					
					using var db = new sqlite(s_dbFileIcons, SLFlags.SQLITE_OPEN_READONLY);
					using var stTables = db.Statement("SELECT name FROM _tables");
					while (stTables.Step()) {
						var table = stTables.GetText(0);
						using var stNames = db.Statement("SELECT name FROM " + table);
						while (stNames.Step()) {
							var s = stNames.GetText(0);
							h.Add(s);
						}
					}
					//print.it(h.Count);
					return h.ToList();
				}
			}
			
			string _SplitName(string s) {
				s = s.Trim('_');
				//split PascalCase etc into words
				s = rx1.Replace(s, "$1 $2");
				s = rx2.Replace(s, "$1 $2");
				return s;
			}
		}
	}
	
	#endregion
	
	public List<(EmVector f, float score)> GetTopMatches(float[] queryVector, List<EmVector> ems, int take) {
		var a = ems
			.Select(f => (f, score: CosineSimilarity(queryVector, f.vec)))
			.OrderByDescending(x => x.score)
			.Take(take)
			.ToList();
		return a;
	}
	
	[MethodImpl(MethodImplOptions.AggressiveOptimization)]
	public static float CosineSimilarity(float[] query, Array saved) {
		float dot = 0, normA = 0, normB = 0;
		switch (saved) {
		case float[] b:
			for (int i = 0; i < query.Length; i++) {
				dot += query[i] * b[i];
				normA += query[i] * query[i];
				normB += b[i] * b[i];
			}
			break;
		case sbyte[] b:
			for (int i = 0; i < query.Length; i++) {
				float f = b[i] / 127f;
				dot += query[i] * f;
				normA += query[i] * query[i];
				normB += f * f;
			}
			break;
		}
		return dot / (MathF.Sqrt(normA) * MathF.Sqrt(normB));
	}
}

record struct EmVector(string name, Array vec);

file class _EmStorageFile(string file) {
	public void Save(List<string> names, List<Array> ems, List<EmInput> datas, _EmHash hash) {
		filesystem.createDirectoryFor(file);
		using var w = new BinaryWriter(File.Create(file));
		w.Write((byte)(ems[0] is float[]? 4 : 1));
		w.Write(ems[0].Length);
		w.Write(hash.hash);
		w.Write(hash.modelParams);
		for (int i = 0; i < names.Count; i++) {
			w.Write(names[i]);
			switch (ems[i]) {
			case float[] a: w.Write(MemoryMarshal.AsBytes(a)); break;
			case sbyte[] a: w.Write(MemoryMarshal.AsBytes(a)); break;
			}
			var md5 = datas[i].GetHash();
			w.Write(md5.r1);
			w.Write(md5.r2);
		}
	}
	
	BinaryReader _Load(out int type, out int vectorLen, out _EmHash hash) {
		var r = new BinaryReader(filesystem.loadStream(file));
		type = r.ReadByte();
		Reading = true; //for the caller's exception handler to detect whether the exception is likely because of corrupt file
		if (!(type is 1 or 4)) throw new FileFormatException();
		vectorLen = r.ReadInt32();
		hash = new(r.ReadString(), r.ReadString());
		return r;
	}
	
	public bool Reading { get; private set; }
	
	public List<EmVector> Load(out _EmHash hash) {
		using var r = _Load(out int type, out int vectorLen, out hash);
		List<EmVector> a = new((int)(r.BaseStream.Length / vectorLen / type));
		while (r.BaseStream.Position < r.BaseStream.Length) {
			var name = r.ReadString();
			if (type == 4) {
				var vec = GC.AllocateUninitializedArray<float>(vectorLen, pinned: true);
				r.Read(MemoryMarshal.AsBytes(vec.AsSpan()));
				a.Add(new(name, vec));
			} else {
				var vec = GC.AllocateUninitializedArray<sbyte>(vectorLen, pinned: true);
				r.Read(MemoryMarshal.AsBytes(vec.AsSpan()));
				a.Add(new(name, vec));
			}
			r.ReadInt64(); r.ReadInt64(); //hash
		}
		return a;
		
		//With AllocateUninitializedArray faster. When pinned, less work for GC, which runs simultaneously because we allocate large amount of memory.
	}
	
	public Dictionary<string, (Array vec, Hash.MD5Result hash)> LoadForUpdate() {
		Dictionary<string, (Array vec, Hash.MD5Result hash)> d = new();
		using var r = _Load(out int type, out int vectorLen, out _);
		while (r.BaseStream.Position < r.BaseStream.Length) {
			var name = r.ReadString();
			Array vec;
			if (type == 4) {
				var f = new float[vectorLen];
				r.Read(MemoryMarshal.AsBytes(f.AsSpan()));
				vec = f;
			} else {
				var b = new sbyte[vectorLen];
				r.Read(MemoryMarshal.AsBytes(b.AsSpan()));
				vec = b;
			}
			Hash.MD5Result md5 = new(r.ReadInt64(), r.ReadInt64());
			d.Add(name, (vec, md5));
		}
		return d;
	}
	
	public bool TryDownload(AiEmbeddingModel model, _EmHash hash) {
		//#if !SCRIPT
		//		if (App.IsAtHome) return false;
		//#endif
		if (_TryGetZipName(model, hash) is not { } zipName) return false;
		string zipFile = file + ".7z";
		try {
			var r = internet.http.Get($"https://www.libreautomate.com/download/ai/embedding/{zipName}", dontWait: true);
			if (!r.IsSuccessStatusCode) return false;
			r.Download(zipFile, progressText1: "Downloading data for AI search");
			var dir = pathname.getDirectory(file);
			if (!SevenZip.Extract(out var errors, zipFile, dir)) { Debug_.Print(errors); return false; }
		}
		catch (Exception ex) { Debug_.Print(ex); }
		finally { filesystem.delete(zipFile, FDFlags.CanFail); }
		return true;
	}
	
	string _TryGetZipName(AiEmbeddingModel model, _EmHash hash) {
		if (!(file.Ends("-icons.bin") && model.isCompact && model.GetType().Assembly == GetType().Assembly)) return null;
		
		var md5 = new Hash.MD5Context();
		md5.Add(hash.hash);
		md5.Add(hash.modelParams);
		return $"{pathname.getNameNoExt(file)}-{md5.Hash.ToStringBase64Url()}.zip";
	}
	
	public void PrintUploadIfAtHome(AiEmbeddingModel model, _EmHash hash) {
#if !SCRIPT
		if (!App.IsAtHome) return;
#endif
		if (_TryGetZipName(model, hash) is not { } zipName) return;
		print.it($"<><script Upload AI embeddings.cs|{file}|{zipName}>Upload<> AI embedding vectors.");
	}
}

file record struct _EmHash(string hash, string modelParams);

[JsonConverter(typeof(_JsonConverter))]
record struct EmInput {
	object _o;
	
	public EmInput(string text) { _o = text; }
	
	public EmInput(object[] multimodal) { _o = multimodal; }
	
	//public bool IsMultimodal => _o is object[];
	
	public object[] Multimodal => _o as object[];
	
	public string Text => _o as string;
	
	public static implicit operator EmInput(string s) => new(s);
	
	public static implicit operator EmInput(object[] a) => new(a);
	
	public int Size {
		get {
			if (_o is object[] a) {
				int r = 0;
				foreach (var v in a) {
					if (v is byte[] b) r += b.Length / 3 * 4 + 4; //Base64 of image
					else if (v is string g) r += g.Length;
				}
				return r;
			} else if (_o is string s) {
				return s.Length;
			} else return 0;
		}
	}
	
	public Hash.MD5Result GetHash() {
		if (_o is object[] a) {
			var h = new Hash.MD5Context();
			foreach (var v in a) {
				if (v is byte[] b) h.Add(b);
				else if (v is string g) h.Add(g);
			}
			return h.Hash;
		} else if (_o is string s) {
			return Hash.MD5(s);
		} else return default;
	}
	
	class _JsonConverter : JsonConverter<EmInput> {
		public override EmInput Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) {
			throw new NotImplementedException();
		}
		
		public override void Write(Utf8JsonWriter writer, EmInput value, JsonSerializerOptions options) {
			JsonSerializer.Serialize(writer, value.Text, options);
		}
	}
}

/// <summary>
/// Converts XAML icons (those from the LA database) to various formats.
/// 2 or more times faster than <see cref="ImageUtil.LoadGdipBitmapFromXaml"/>, but supports only raw Path XAML from the database. No *Pack.Icon, Viewbox, multiple layers, margin etc.
/// </summary>
class XamlIconConverter_ {
	bool _flip, _stroke2;
	
	public string PathData { get; set; }
	public Brush Brush { get; set; }
	
	//Each icon pack uses the same Path XAML for all its icons. Currently icon packs use one of 3 XAML versions. After updating the package may need to edit the regex.
	static regexp s_rx1 = new regexp("""
^<Path Data=.(.+?). Stretch=.Uniform. (?|Fill=.(.*?). UseLayoutRounding=.False. SnapsToDevicePixels=.False.(?: />|>\s*<Path\.LayoutTransform>\s*<ScaleTransform ScaleY=.-1. />\s*</Path\.LayoutTransform>\s*</Path>)|Stroke=.(.+?). StrokeThickness=.2. StrokeStartLineCap=.Round. StrokeEndLineCap=.Round. StrokeLineJoin=.Round. UseLayoutRounding=.False. Width=.24. Height=.24. SnapsToDevicePixels=.False. />)$
""");
	
	/// <summary>
	/// Gets a converter for the specified path XAML.
	/// </summary>
	/// <param name="pathXaml">Icon <c>Path</c> XAML. Can be with or without data (ignores it).</param>
	/// <returns><c>null</c> if <i>pathXaml</i> does not match one of icon templates from the LA icon database.</returns>
	public static XamlIconConverter_ GetConverter(string pathXaml) {
		if (!pathXaml.Starts("<Path Data=")) return null;
		if (!s_rx1.Match(pathXaml, out var m)) return null;
		string data = m[1].Value, color = m[2].Value;
		XamlIconConverter_ r = new() { _stroke2 = pathXaml[m[1].Start - 6] == 'S', _flip = pathXaml.Ends("</Path>") };
		if (data.Length > 0 && data[0] != '{') r.PathData = data;
		if (color.Length > 0 && color[0] != '{') { r.Brush = (Brush)new BrushConverter().ConvertFromString(color); r.Brush.Freeze(); }
		return r;
	}
	
	public RenderTargetBitmap ToWpfBitmap(int size, int dpi, Brush background = null) {
		var geo = Geometry.Parse(PathData ?? throw new InvalidOperationException("PathData null"));
		var bounds = _stroke2 ? new(0, 0, 24, 24) : geo.Bounds;
		double scale = Math.Min(size / bounds.Width, size / bounds.Height);
		
		var tg = new TransformGroup();
		tg.Children.Add(new TranslateTransform(-bounds.X, -bounds.Y));
		if (_flip) {
			tg.Children.Add(new ScaleTransform(scale, -scale));
			tg.Children.Add(new TranslateTransform(0, bounds.Height * scale));
		} else {
			tg.Children.Add(new ScaleTransform(scale, scale));
		}
		double size0 = Math.Max(bounds.Width, bounds.Height), centerX = (size0 - bounds.Width) * scale / 2, centerY = (size0 - bounds.Height) * scale / 2;
		if (centerX > 1 || centerY > 1) tg.Children.Add(new TranslateTransform(centerX, centerY));
		
		var brush = Brush ?? SystemColors.ControlTextBrush;
		Pen pen = null;
		if (_stroke2) {
			pen = new(brush, 2) { StartLineCap = PenLineCap.Round, EndLineCap = PenLineCap.Round, LineJoin = PenLineJoin.Round };
		}
		
		var dv = new DrawingVisual();
		using (var dc = dv.RenderOpen()) {
			if (background != null) dc.DrawRectangle(background, null, new(0, 0, size, size)); //note: AI does not support PNG with transparent background
			dc.PushTransform(tg);
			dc.DrawGeometry(pen == null ? brush : null, pen, geo);
			dc.Pop();
		}
		
		var rtb = new RenderTargetBitmap(size, size, dpi, dpi, PixelFormats.Pbgra32);
		rtb.Render(dv);
		return rtb;
	}
	
	public byte[] ToPng(int size, int dpi, Brush background = null) {
		using var ms = new MemoryStream();
		ToPng(ms, size, dpi, background);
		return ms.ToArray();
	}
	
	public void ToPng(Stream stream, int size, int dpi, Brush background = null) {
		BitmapSource bs = ToWpfBitmap(size, dpi, background);
		
		var encoder = new PngBitmapEncoder();
		encoder.Frames.Add(BitmapFrame.Create(bs));
		encoder.Save(stream);
	}
	
#if false //unused
	public System.Drawing.Bitmap ToGdipBitmap(int size, int dpi, Brush background = null) {
		var rtb = ToWpfBitmap(size, dpi, background);
		
		int stride = size * 4, msize = size * stride;
		var bmp = new System.Drawing.Bitmap(size, size, System.Drawing.Imaging.PixelFormat.Format32bppPArgb);
		using var d = bmp.Data(System.Drawing.Imaging.ImageLockMode.ReadWrite);
		rtb.CopyPixels(new System.Windows.Int32Rect(0, 0, size, size), d.Scan0, msize, stride);
		bmp.SetResolution(dpi, dpi);
		return bmp;
	}
	
	public unsafe void ToIcon(Stream stream, int[] sizes) {
		if (sizes is not { Length: >= 1 and <= 1000 }) throw new ArgumentOutOfRangeException(nameof(sizes));
		stream.Position = Math2.AlignUp(sizeof(Api.NEWHEADER) + sizeof(Api.ICONDIRENTRY) * sizes.Length, 4);
		var a = stackalloc Api.ICONDIRENTRY[sizes.Length];
		for (int i = 0; i < sizes.Length; i++) {
			int size = sizes[i];
			if (size < 1 || size > 256) throw new ArgumentOutOfRangeException();
			long pos = stream.Position;
			ToPng(stream, size, 96);
			byte bsize = (byte)size;
			a[i] = new() { bWidth = bsize, bHeight = bsize, wBitCount = 32, dwBytesInRes = (int)(stream.Position - pos), dwImageOffset = (int)pos };
		}
		var posEnd = stream.Position;
		stream.Position = 0;
		var h = new Api.NEWHEADER { wResType = 1, wResCount = (ushort)sizes.Length };
		stream.Write(new(&h, sizeof(Api.NEWHEADER)));
		stream.Write(new(a, sizeof(Api.ICONDIRENTRY) * sizes.Length));
		stream.Position = posEnd;
	}
	
	public void ToIcon(string icoFile, FrameworkElement e, int[] sizes) {
		icoFile = pathname.NormalizeMinimally_(icoFile);
		using var stream = File.OpenWrite(icoFile);
		ToIcon(stream, sizes);
	}
	
	public System.Drawing.Icon ToGdipIcon(int size) {
		using var ms = new MemoryStream();
		ToIcon(ms, [size]);
		ms.Position = 0;
		return new System.Drawing.Icon(ms);
	}
#endif
}


================================================
FILE: Au.Editor/xAI/AiModel.cs
================================================
//#define ADD_ALL_COMPACT_EMBEDDING_MODELS
#if DEBUG
#define ADD_CHAT_MODELS //currently not using chat models in LA, but likely in the future
#endif

using System.Text.Json.Nodes;
using System.Security.Authentication;
using System.Net.Http;
using LA;

namespace AI;

record AMLimits(int maxTokens, int maxInputs, int requestPeriod = 0, int maxSize = 0);

abstract record class AiModel(string api, string url, string model, AMLimits limits, string apiSuffix = null) {
	#region static
	
	static AiModel() {
		Models = [
//			new ModelOpenaiEmbed(), //don't add, because other models are much better
//#if ADD_ALL_COMPACT_EMBEDDING_MODELS
//			new ModelOpenaiEmbed2(),
//#endif
#if ADD_CHAT_MODELS
			new ModelOpenaiChat("gpt-5"),
			new ModelOpenaiChat("gpt-5-mini"),
			//new ModelOpenaiCompletionsChat("gpt-5"),
			//new ModelOpenaiCompletionsChat("gpt-5-mini"),
#endif
			
			new ModelGeminiEmbed(),
#if ADD_ALL_COMPACT_EMBEDDING_MODELS
			new ModelGeminiEmbed2(),
#endif
#if ADD_CHAT_MODELS
			new ModelGeminiChat("gemini-2.5-flash"),
			new ModelGeminiChat("gemini-2.5-flash-lite"),
#endif
			
			new ModelVoyageEmbed(),
#if ADD_ALL_COMPACT_EMBEDDING_MODELS
			new ModelVoyageEmbed2(),
#endif
			new ModelVoyageRerank("rerank-2.5"),
			new ModelVoyageRerank("rerank-2.5-lite"),
			
#if ADD_CHAT_MODELS
			new ModelClaudeChat("claude-opus-4-1"),
			new ModelClaudeChat("claude-sonnet-4-0"),
			
			new ModelDeepseekChat(),
#endif
			
#if MISTRAL
			new ModelMistralEmbed(),
#if ADD_ALL_COMPACT_EMBEDDING_MODELS
			new ModelMistralEmbed2(),
#endif
#if ADD_CHAT_MODELS
			new ModelMistralChat("mistral-medium-latest"),
			new ModelMistralChat("mistral-large-latest"),
			new ModelMistralChat("codestral-latest"),
#endif
#endif
			
#if COHERE
			new ModelCohereEmbed(),
#if ADD_ALL_COMPACT_EMBEDDING_MODELS
			new ModelCohereEmbed2(),
#endif
#if ADD_CHAT_MODELS
			new ModelCohereChat("command-a-03-2025"),
			new ModelCohereRerank("rerank-v3.5"),
			new ModelCohereRerank("rerank-english-v3.0"),
#endif
#endif
		];
	}
	
	public static List<AiModel> Models { get; }
	
	/// <summary>
	/// Finds model by type.
	/// </summary>
	public static T GetModel<T>() where T : AiModel => Models.OfType<T>().First();
	
	/// <summary>
	/// Finds model by type and name.
	/// </summary>
	/// <param name="model"></param>
	/// <param name="displayName"><i>model</i> is like <c>"API model"</c>.</param>
	/// <returns>null if not <i>model</i> found.</returns>
	public static T GetModel<T>(string model, bool displayName = false) where T : AiModel => Models.OfType<T>().FirstOrDefault(o => (displayName ? o.DisplayName : o.model) == model);
	
	public static void RerankerModelWarning() {
		if (!s_onceWarning1) s_onceWarning1 = true; else return;
		print.it("<>Note: Select an AI reranker model in <+options AI>Options > AI<>. It improves AI search results.");
	}
	static bool s_onceWarning1;
	
	#endregion
	
	public string DisplayName => $"{api}{apiSuffix} {model}";
	
	/// <exception cref="Exception"></exception>
	public IEnumerable<string> GetHeaders() {
		if (ApiKeys is not { } ak) throw new InvalidOperationException("Property ApiKeys not set");
		if (!ak.TryGetValue(api, out string apiKey) || apiKey.NE()) throw new InvalidCredentialException("AI settings error: no API key");
		
		if (apiKey is ['%', _, .., '%']) {
			apiKey = Environment.GetEnvironmentVariable(apiKey = apiKey[1..^1]) ?? throw new InvalidCredentialException($"AI settings error: missing environment variable {apiKey}");
		} else {
			apiKey = EdProtectedData.Unprotect(apiKey);
		}
		
		return _GetHeaders(apiKey);
	}
	
	protected private virtual IEnumerable<string> _GetHeaders(string apiKey) => ["Authorization: Bearer " + apiKey];
	
	public static Dictionary<string, string> ApiKeys { get; set; }
	
	/// <summary>
	/// HTTP-posts data. Manages <c>limits.requestPeriod</c> (waits if need) and error "too many requests" (waits/retries with UI and cancellation).
	/// </summary>
	/// <exception cref="OperationCanceledException"></exception>
	/// <exception cref="Exception"></exception>
	public HttpResponseMessage Post(object data, IEnumerable<string> headers, CancellationToken cancel = default) {
		_ApiPostTimes ppt = s_dpl.GetOrAdd(api, o => new());
		bool retried = false;
		gRetry:
		if (limits.requestPeriod > 0) {
			long sleep = limits.requestPeriod - (Environment.TickCount64 - ppt.lastRequestTime);
			if (sleep > 0) Task.Delay((int)sleep, cancel).GetAwaiter().GetResult();
			ppt.lastRequestTime = Environment.TickCount64;
		}
		var r = internet.http.Send(internet.message(HttpMethod.Post, url, headers: headers, internet.jsonContent(data)), cancel);
		if (r.IsSuccessStatusCode) return r;
		if (r.StatusCode == System.Net.HttpStatusCode.TooManyRequests) {
			if (r.Headers.RetryAfter is { Delta: not null } ra) ppt.waitRetryS = Math.Max(1, (int)ra.Delta.Value.TotalSeconds);
			if (retried) ppt.waitRetryS += 10; else retried = true;
			using var osd = osdText.showText("", -1, icon: icon.stock(StockIcon.WARNING), showMode: OsdMode.ThisThread, dontShow: true);
			for (int i = 0; i < ppt.waitRetryS; i++) {
				osd.Text = $"Too many AI requests.\nWaiting {ppt.waitRetryS - i} s and will retry.\nYou can click here to cancel.";
				osd.Visible = true;
				wait.doEvents(1000);
				if (!osd.Visible || cancel.IsCancellationRequested) {
					print.it("Too many AI requests", r.Text(ignoreError: true));
					throw new OperationCanceledException();
				}
			}
			goto gRetry;
		}
		throw new HttpRequestException($"{r.StatusCode}. {r.Text(ignoreError: true)}");
	}
	
	class _ApiPostTimes {
		public long lastRequestTime;
		public int waitRetryS = 10;
	}
	static ConcurrentDictionary<string, _ApiPostTimes> s_dpl = [];
}

abstract record class AiEmbeddingModel(string api, string url, string model, int dimensions, string emType, AMLimits limits)
	: AiModel(api, url, model, limits) {
	
	public bool isCompact { get; protected set; }
	
	public bool isMultimodal { get; protected set; }
	
	public abstract object GetPostData(IList<EmInput> input, bool isQuery);
	
	public abstract IEnumerable<JsonNode> GetVectors(JsonNode j);
	
	public abstract int GetTokens(JsonNode j);
}

abstract record class AiChatModel(string api, string url, string model, AMLimits limits)
	: AiModel(api, url, model, limits) {
	
	public abstract object GetPostData(string systemInstruction, List<AiChatMessage> messages, double? temperature = null);
	
	public abstract AiChatMessage GetAnswer(JsonNode j);
}

record class AiChatMessage(ACMRole role, string text, JsonNode json = null);
enum ACMRole { user, assistant, tool }

abstract record class AiRerankModel(string api, string url, string model, AMLimits limits)
	: AiModel(api, url, model, limits) {
	
	public abstract object GetPostData(string query, IList<string> documents, int top_n = 0);
	
	public abstract IEnumerable<AiRerankResult> GetResults(JsonNode j);
}

record struct AiRerankResult(int index, float score);

#region Mistral
#if MISTRAL //waekar chat model. Embedding good, but not as good as Gemini and Voyage.
record class ModelMistralEmbed : AiEmbeddingModel {
	public ModelMistralEmbed() : base("Mistral", "https://api.mistral.ai/v1/embeddings", "codestral-embed", 1024, "float", new(32000, 256, requestPeriod: 1100)) { }
	//"mistral-embed" (only 1024 dim float), "codestral-embed"
	
	public override object GetPostData(IList<EmInput> input, bool isQuery)
		=> new { model, input, output_dimension = dimensions, output_dtype = emType };
	
	public override IEnumerable<JsonNode> GetVectors(JsonNode j)
		=> j["data"].AsArray().Select(o => o["embedding"]);
	
	public override int GetTokens(JsonNode j)
		=> (int)j["usage"]["total_tokens"];
}

#if ADD_ALL_COMPACT_EMBEDDING_MODELS
record class ModelMistralEmbed2 : ModelMistralEmbed {
	public ModelMistralEmbed2() { isCompact = true; dimensions = 384; emType = "int8"; }
}
#endif

record class ModelMistralChat : AiChatModel {
	public ModelMistralChat(string model) : base("Mistral", "https://api.mistral.ai/v1/chat/completions", model, new(32000, 256, requestPeriod: 1500)) { }
	//"mistral-small-latest", "mistral-medium-latest", "mistral-large-latest", "codestral-latest"
	
	public override object GetPostData(string systemInstruction, List<AiChatMessage> messages, double? temperature = null)
		=> new {
			model,
			messages = (object[])[new { role = "system", content = systemInstruction }, .. messages.Select(o => new { role = o.role.ToString(), content = o.text })],
			temperature,
		};
	
	public override AiChatMessage GetAnswer(JsonNode j)
		=> new AiChatMessage(ACMRole.assistant, (string)j["choices"][0]["message"]["content"]);
}
#endif
#endregion

#region OpenAI

record class ModelOpenaiEmbed : AiEmbeddingModel {
	public ModelOpenaiEmbed() : base("OpenAI", "https://api.openai.com/v1/embeddings", "text-embedding-3-small", 1024, null, new(100000, 2048)) { }
	
	public override object GetPostData(IList<EmInput> input, bool isQuery)
		=> new { model, input, dimensions, encoding_format = "base64" };
	
	public override IEnumerable<JsonNode> GetVectors(JsonNode j)
		=> j["data"].AsArray().Select(o => o["embedding"]);
	
	public override int GetTokens(JsonNode j)
		=> (int)j["usage"]["total_tokens"];
}

#if ADD_ALL_COMPACT_EMBEDDING_MODELS
record class ModelOpenaiEmbed2 : ModelOpenaiEmbed {
	public ModelOpenaiEmbed2() { isCompact = true; dimensions = 384; }
}
#endif

record class ModelOpenaiChat : AiChatModel {
	public ModelOpenaiChat(string model) : base("OpenAI", "https://api.openai.com/v1/responses", model, new(100000, 2048)) { apiSuffix = " responses"; }
	//"gpt-5", "gpt-5-mini", "gpt-5-nano"
	
	/// <summary>
	/// high, medium (default), low, minimal
	/// </summary>
	public string reasoning { get; init; } = "medium";
	
	public override object GetPostData(string instructions, List<AiChatMessage> messages, double? temperature = null) {
		List<object> input = [];
		foreach (var m in messages) {
			if (m.role is ACMRole.user) input.Add(new { role = "user", content = m.text });
			else input.AddRange(m.json.AsArray());
		}
		
		if (model.Starts("gpt-4"))
			return new {
				model,
				instructions,
				input,
				temperature,
				store = false,
			};
		
		return new {
			model,
			instructions,
			input,
			//temperature, //not supported
			store = false,
			reasoning = new { effort = reasoning }
		};
	}
	
	public override AiChatMessage GetAnswer(JsonNode j) {
		var a = j["output"].AsArray();
		foreach (var v in a) {
			if ((string)v["type"] == "message") { //doc: always "message"
				var m = v["content"][0];
				if ((string)m["type"] != "output_text") continue; //refusal
				return new AiChatMessage(ACMRole.assistant, (string)m["text"], a);
			}
		}
		return null;
	}
	
	//tokens: (int)json["usage"]["total_tokens"]
}

//record class ModelOpenaiCompletionsChat : AiChatModel {
//	public ModelOpenaiCompletionsChat(string model) : base("OpenAI", "https://api.openai.com/v1/chat/completions", model, new(100000, 2048)) { apiSuffix = " completions"; }

//	public override object GetPostData(string systemInstruction, List<AiChatMessage> messages, double? temperature = null)
//		=> new {
//			model,
//			messages = (object[])[new { role = "developer", content = systemInstruction }, .. messages.Select(o => new { role = o.role.ToString(), content = o.text })],
//			temperature,
//		};

//	public override AiChatMessage GetAnswer(JsonNode j)
//		=> new AiChatMessage(ACMRole.assistant, (string)j["choices"][0]["message"]["content"]);

//	//tokens: (int)json["usage"]["total_tokens"]
//}

#endregion

#region Gemini

record class ModelGeminiEmbed : AiEmbeddingModel {
	const string c_model = "gemini-embedding-001";
	
	public ModelGeminiEmbed() : base("Gemini", $"https://generativelanguage.googleapis.com/v1beta/models/{c_model}:batchEmbedContents", c_model, 1024, null, new(8000, 100, requestPeriod: 2000)) { }
	
	private protected override IEnumerable<string> _GetHeaders(string apiKey) => ["x-goog-api-key: " + apiKey];
	
	public override object GetPostData(IList<EmInput> input, bool isQuery)
		=> new {
			requests = (object[])[input.Select(o => new {
				model = "models/" + model,
				content = new { parts = (object[])[new { text = o.Text }] },
				outputDimensionality = dimensions,
				task_type = isQuery ? "RETRIEVAL_QUERY" : "RETRIEVAL_DOCUMENT"
			})]
		};
	
	public override IEnumerable<JsonNode> GetVectors(JsonNode j)
		=> j["embeddings"].AsArray().Select(o => o["values"]);
	
	public override int GetTokens(JsonNode j) => 0;
}

#if ADD_ALL_COMPACT_EMBEDDING_MODELS
record class ModelGeminiEmbed2 : ModelGeminiEmbed {
	public ModelGeminiEmbed2() { isCompact = true; dimensions = 384; }
}
#endif

record class ModelGeminiChat : AiChatModel {
	public ModelGeminiChat(string model) : base("Gemini", $"https://generativelanguage.googleapis.com/v1beta/models/{model}:generateContent", model, new(8000, 100)) { }
	//"gemini-2.5-flash", "gemini-2.5-flash-lite"
	
	private protected override IEnumerable<string> _GetHeaders(string apiKey) => ["x-goog-api-key: " + apiKey];
	
	public override object GetPostData(string systemInstruction, List<AiChatMessage> messages, double? temperature = null) {
		return new {
			system_instruction = new { parts = (object[])[new { text = systemInstruction }] },
			contents = messages.Select(o => new { role = o.role is ACMRole.user ? "user" : "model", parts = (object[])[new { text = o.text }] }),
			generationConfig = new { temperature }
		};
	}
	
	public override AiChatMessage GetAnswer(JsonNode j)
		=> new AiChatMessage(ACMRole.assistant, (string)j["candidates"][0]["content"]["parts"][0]["text"]);
	
	//tokens: (int)json["usageMetadata"]["totalTokenCount"]
}

#endregion

#region Voyage

record class ModelVoyageEmbed : AiEmbeddingModel {
	//public ModelVoyageEmbed() : base("Voyage", "https://api.voyageai.com/v1/embeddings", "voyage-3.5", 1024, "float", new(3300, 1000, requestPeriod: 20500)) { } //free tier rate: 10000 TPM, 3 RPM
	public ModelVoyageEmbed() : base("Voyage", "https://api.voyageai.com/v1/embeddings", "voyage-3.5", 1024, "float", new(32000, 1000, requestPeriod: 1000)) { } //rate: 2000000 TPM, 2000 RPM
	
	public override object GetPostData(IList<EmInput> input, bool isQuery)
		=> new {
			model, //voyage-3.5, voyage-3.5-lite
			input,
			output_dimension = dimensions, //2048, 1024 (default), 512, and 256
			output_dtype = emType,
			encoding_format = "base64",
			input_type = isQuery ? "query" : "document"
		};
	
	public override IEnumerable<JsonNode> GetVectors(JsonNode j)
		=> j["data"].AsArray().Select(o => o["embedding"]);
	
	public override int GetTokens(JsonNode j)
		=> (int)j["usage"]["total_tokens"];
}

#if ADD_ALL_COMPACT_EMBEDDING_MODELS
record class ModelVoyageEmbed2 : ModelVoyageEmbed {
	public ModelVoyageEmbed2() { isCompact = true; dimensions = 512; emType = "int8"; }
}
#endif

record class ModelVoyageEmbedM : AiEmbeddingModel {
	public ModelVoyageEmbedM() : base("Voyage", "https://api.voyageai.com/v1/multimodalembeddings", "voyage-multimodal-3", 1024, null, new(32000, 1000, requestPeriod: 1000)) { isMultimodal = isCompact = true; }
	//With every 560 pixels of an image being counted as a token, each input in the list must not exceed 32,000 tokens, and the total number of tokens across all inputs must not exceed 320,000.
	
	public override object GetPostData(IList<EmInput> input, bool isQuery) {
		List<object> a = new(input.Count);
		List<object> aItem = [];
		foreach (var d in input) {
			aItem.Clear();
			foreach (var o in d.Multimodal) {
				if (o is string s) aItem.Add(new { type = "text", text = s });
				else if (o is byte[] png) aItem.Add(new { type = "image_base64", image_base64 = "data:image/png;base64," + Convert.ToBase64String(png) });
				else throw new ArgumentException();
			}
			a.Add(new { content = aItem.ToArray() });
		}
		
		return new {
			model, //voyage-multimodal-3
			input = a,
			output_encoding = "base64",
			input_type = isQuery ? "query" : "document"
		};
	}
	
	public override IEnumerable<JsonNode> GetVectors(JsonNode j)
		=> j["data"].AsArray().Select(o => o["embedding"]);
	
	public override int GetTokens(JsonNode j)
		=> (int)j["usage"]["total_tokens"];
}

record class ModelVoyageRerank : AiRerankModel {
	//public ModelVoyageRerank(string model) : base("Voyage", "https://api.voyageai.com/v1/rerank", model, new(3300, 1000, requestPeriod: 20500)) { } //free tier
	public ModelVoyageRerank(string model) : base("Voyage", "https://api.voyageai.com/v1/rerank", model, new(8000, 1000, requestPeriod: 1000)) { }
	
	public override object GetPostData(string query, IList<string> documents, int top_n = 0)
		=> new {
			model, //rerank-2.5, rerank-2.5-lite
			query,
			documents,
			top_k = Math.Min(top_n > 0 ? top_n : int.MaxValue, documents.Count),
			//truncation //true (default) - truncates at 8000 tok; false - error if > 8000 tok.
		};
	
	public override IEnumerable<AiRerankResult> GetResults(JsonNode j)
		=> j["data"].AsArray().Select(o => new AiRerankResult((int)o["index"], (float)o["relevance_score"]));
}

#endregion

#region Claude

//no embedding API

record class ModelClaudeChat : AiChatModel {
	public ModelClaudeChat(string model) : base("Claude", "https://api.anthropic.com/v1/messages", model, new(200000, 100000, 1250)) { } //200K tokens, 50 requests/minute, 30000 input tokens/minute, 8000 output tokens/minute
	
	private protected override IEnumerable<string> _GetHeaders(string apiKey) => ["x-api-key: " + apiKey, "anthropic-version: 2023-06-01"];
	
	public override object GetPostData(string systemInstruction, List<AiChatMessage> messages, double? temperature = null)
		=> new {
			model,
			system = systemInstruction,
			messages = messages.Select(o => new { role = o.role.ToString(), content = o.text }),
			max_tokens = 32000, //opus-4.1 32000, sonnet-4 64000
			temperature = temperature ?? 1,
		};
	
	public override AiChatMessage GetAnswer(JsonNode j)
		=> new AiChatMessage(ACMRole.assistant, (string)j["content"][0]["text"]);
}

#endregion

#region DeepSeek

//no embedding API

record class ModelDeepseekChat : AiChatModel {
	public ModelDeepseekChat(string model = "deepseek-chat") : base("DeepSeek", "https://api.deepseek.com/chat/completions", model, new(200000, 100000)) { }//TODO2: limits
	
	public override object GetPostData(string systemInstruction, List<AiChatMessage> messages, double? temperature = null)
		=> new {
			model, //deepseek-chat, deepseek-reasoner
			messages = (object[])[new { role = "system", content = systemInstruction }, .. messages.Select(o => new { role = o.role.ToString(), content = o.text })],
			temperature = temperature ?? 1, //1-2
		};
	
	public override AiChatMessage GetAnswer(JsonNode j)
		=> new AiChatMessage(ACMRole.assistant, (string)j["choices"][0]["message"]["content"]);
}

#endregion

#region Cohere
#if COHERE
record class ModelCohereEmbed : AiEmbeddingModel {
	public ModelCohereEmbed() : base("Cohere", "https://api.cohere.ai/v2/embed", "embed-v4.0", 1024, "base64", new(100000, 96, requestPeriod: 1000, maxSize: 256000)) { }
	
	public override object GetPostData(IList<EmInput> texts, bool isQuery)
		=> new { model, texts, output_dimension = dimensions, embedding_types = (string[])[emType], input_type = isQuery ? "search_query" : "search_document" };
	
	public override IEnumerable<JsonNode> GetVectors(JsonNode j)
		=> j["embeddings"][emType].AsArray();
	
	public override int GetTokens(JsonNode j)
		=> (int)j["meta"]["billed_units"]["input_tokens"];
}

#if ADD_ALL_COMPACT_EMBEDDING_MODELS
record class ModelCohereEmbed2 : ModelCohereEmbed {
	public ModelCohereEmbed2() { isCompact = true; dimensions = 512; emType = "int8"; }
}
#endif

record class ModelCohereChat : AiChatModel {
	public ModelCohereChat(string model = "command-a-03-2025") : base("Cohere", "https://api.cohere.com/v2/chat", model, new(0, 96, maxSize: 256000)) { } //doc: max content length 256k (chars or tokens?)
	
	public override object GetPostData(string systemInstruction, List<AiChatMessage> messages, double? temperature = null)
		=> new {
			model,
			messages = (object[])[new { role = "assistant", content = systemInstruction }, .. messages.Select(o => new { role = o.role.ToString(), content = o.text })],
			temperature,
		};
	
	public override AiChatMessage GetAnswer(JsonNode j)
		=> new AiChatMessage(ACMRole.assistant, (string)j["message"]["content"][0]["text"]);
}

record class ModelCohereRerank : AiRerankModel {
	public ModelCohereRerank(string model) : base("Cohere", "https://api.cohere.com/v2/rerank", model, new(4096, 1000)) { }
	
	public override object GetPostData(string query, IList<string> documents, int top_n = 0)
		=> new {
			model, //rerank-v3.5, rerank-english-v3.0
			query,
			documents,
			top_n = Math.Min(top_n > 0 ? top_n : int.MaxValue, documents.Count),
			//max_tokens_per_doc //4096 is default and max
		};
	
	public override IEnumerable<AiRerankResult> GetResults(JsonNode j)
		=> j["results"].AsArray().Select(o => new AiRerankResult((int)o["index"], (float)o["relevance_score"]));
}
#endif
#endregion

#region Jina
#if false //much worse for this task
record class ModelJinaRerank : AiRerankModel {
	public ModelJinaRerank(string model = "jina-reranker-v2-base-multilingual") : base("Jina", "https://api.jina.ai/v1/rerank", model, new(8000, 1000, requestPeriod: 1000)) { } //todo: limits
	
	public override object GetPostData(string query, IList<string> documents, int top_n = 0)
		=> new {
			model, //jina-reranker-v3 (error; paid only?), jina-reranker-v2-base-multilingual
			query,
			documents,
			top_n = Math.Min(top_n > 0 ? top_n : int.MaxValue, documents.Count),
			return_documents = false,
		};
	
	public override IEnumerable<AiRerankResult> GetResults(JsonNode j)
		=> j["results"].AsArray().Select(o => new AiRerankResult((int)o["index"], (float)o["relevance_score"]));
}
#endif
#endregion


================================================
FILE: Au.Editor/xAI/McpServer.cs
================================================
using System.Text.Json;

namespace LA;

class McpServer {
	public static void Run(ReadOnlySpan<string> args) {
#if !SCRIPT
		process.thisProcessCultureIsInvariant = true;
		App.InitThisAppFoldersEtc_();
		AppSettings.Load();
#endif
		
		var stdin = Console.OpenStandardInput();
		var stdout = Console.OpenStandardOutput();
		using var reader = new StreamReader(stdin);
		using var writer = new StreamWriter(stdout) { AutoFlush = true };
		
		var mcpServer = new McpServer();
		
		while (reader.ReadLine() is string json) {
			//print.it(json);
			if (mcpServer.MessageReceived(json) is string response) {
				writer.WriteLine(response);
			}
		}
	}
	
	McpTools _tools = new();
	
	/// <summary>
	/// Processes a MCP message. Calls a tool if need, etc.
	/// </summary>
	/// <param name="json">JSON of the received message.</param>
	/// <returns>Response JSON. <c>null</c> it's a notification.</returns>
	public string MessageReceived(string json) {
		var msg = JsonDocument.Parse(json).RootElement;
		
		int id;
		if (!(msg.TryGetProperty("id", out var eId) && eId.TryGetInt32(out id))) { //notification
			return null;
		}
		
		try {
			string method = msg.GetProperty("method").GetString();
			
			if (method == "initialize") {
				return _Send(new {
					protocolVersion = "2025-06-18",
					serverInfo = new { name = "LibreAutomate", version = "1.0" },
					capabilities = new {
						tools = new { },
						//resources = new { },
						//prompts = new { },
						//completions = new { },
						//logging = new { },
					}
				});
			} else if (method == "ping") {
				return _Send(new { });
			} else if (method == "tools/list") {
				return _Send(new { tools = _GenerateToolList() });
			} else if (method == "tools/call") {
				//print.it($"MCP: process={process.thisProcessId}");
				//print.it(json);
				var p = msg.GetProperty("params");
				var text = _CallTool(p.GetProperty("name").GetString(), p.GetProperty("arguments"));
				return _ReturnContent(new { type = "text", text });
			} else {
				return _Error(-32601, "Method not found");
			}
		}
		catch (Exception ex) {
			if (ex is TargetInvocationException tie) ex = tie.InnerException;
			print.warning(ex, "<>Exception in LA MCP server: ");
//#if DEBUG
//			Debugger.Launch();
//#endif
			return _Error(-32603, ex.ToStringWithoutStack());
		}
		
		string _Send(object result) => JsonSerializer.Serialize(new { jsonrpc = "2.0", id, result });
		
		string _ReturnContent(params object[] content) => _Send(new { content });
		
		string _Error(int code, string message) => JsonSerializer.Serialize(new { jsonrpc = "2.0", id, error = new { code, message } });
	}
	
	static List<object> _GenerateToolList() {
		List<object> tools = [];
		
		foreach (var mi in typeof(McpTools).GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly)) {
			var toolAttr = mi.GetCustomAttribute<McpAttribute>();
			if (toolAttr == null) continue;
			
			Dictionary<string, object> properties = [];
			List<string> required = [];
			
			foreach (var p in mi.GetParameters()) {
				string type = _GetJsonType(p.ParameterType);
				Dictionary<string, object> propDef = [];
				propDef["type"] = type;
				if (p.GetCustomAttribute<McpAttribute>() is { } attr) {
					propDef["description"] = attr.Description;
					if (attr.EnumValues is string sv) propDef["enum"] = sv.Split('|');
				}
				if (p.ParameterType == typeof(string[])) propDef["items"] = new { type = "string" };
				if (p.HasDefaultValue) propDef["default"] = p.DefaultValue; else required.Add(p.Name);
				properties[p.Name] = propDef;
			}
			
			var inputSchema = new {
				type = "object",
				properties,
				required
			};
			
			tools.Add(new {
				name = mi.Name,
				//title = method.Name,
				description = toolAttr.Description,
				inputSchema
			});
		}
		
		//print.it(JsonSerializer.Serialize(tools, new JsonSerializerOptions() { WriteIndented = true }));
		return tools;
		
		static string _GetJsonType(Type t) {
			if (t.IsByRef) throw new NotSupportedException("ByRef parameter");
			if (t == typeof(string)) return "string";
			if (t == typeof(bool)) return "boolean";
			if (t == typeof(int) || t == typeof(long)) return "integer";
			if (t == typeof(double)) return "number";
			if (t == typeof(string[])) return "array";
			throw new NotSupportedException($"MCP tool parameter type '{t.FullName}' is not supported. Expected string, bool, int, long, double or string[].");
		}
	}
	
	string _CallTool(string name, JsonElement jArgs) {
		var mi = typeof(McpTools).GetMethod(name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly) ?? throw new ArgumentException($"Tool `{name}` does not exist");
		var ap = mi.GetParameters();
		var ao = ap.Length > 0 ? new object[ap.Length] : null;
		if (ap.Length > 0) {
			for (int i = 0; i < ap.Length; i++) {
				var p = ap[i];
				var t = p.ParameterType;
				object v = null;
				if (jArgs.TryGetProperty(p.Name, out var jArg)) {
					//print.it(jArg.ValueKind);
					if (t == typeof(string)) v = jArg.GetString();
					else if (t == typeof(bool)) v = jArg.GetBoolean();
					else if (t == typeof(int)) v = jArg.GetInt32();
					else if (t == typeof(long)) v = jArg.GetInt64();
					else if (t == typeof(double)) v = jArg.GetDouble();
					else if (t == typeof(string[])) {
						var a1 = new string[jArg.GetArrayLength()];
						int j = 0;
						foreach (var jElem in jArg.EnumerateArray()) {
							a1[j++] = jElem.GetString();
						}
						v = a1;
					} else throw new ArgumentException($"Bad type of argument `{p.Name}`.");
				} else {
					if (p.HasDefaultValue) v = p.DefaultValue;
					else throw new ArgumentException($"Missing argument `{p.Name}`.");
				}
				ao[i] = v;
			}
		}
		return mi.Invoke(_tools, ao) as string;
	}
}

[AttributeUsage(AttributeTargets.Method | AttributeTargets.Parameter)]
class McpAttribute : Attribute {
	public McpAttribute(string description) => Description = description;
	
	/// <summary>
	/// JSON <c>"description"</c>.
	/// </summary>
	public string Description { get; }
	
	/// <summary>
	/// JSON <c>"enum"</c> like <c>"red|green|blue"</c>.
	/// </summary>
	public string EnumValues { get; init; }
}


================================================
FILE: Au.Editor/xAI/McpTools.cs
================================================
using AI;
using System.Security.Authentication;

namespace LA;

class McpTools {
	readonly string _appDir = LA.folders2.La;
	
	public McpTools() {
		AiModel.ApiKeys = App.Settings.ai_ak;
	}
	
#if !true
	[Mcp("Echoes the input string")]
	public string Echo([Mcp("Any text")] string text, [Mcp("Make lowercase")] bool lowerCase = false) {
		return lowerCase ? text.ToLowerInvariant() : text;
	}
	
	[Mcp("Test enum")]
	public string TestEnum([Mcp("Color", EnumValues = "red|green|blue")] string color) {
		return color;
	}
	
	[Mcp("Test numbers")]
	public string TestNumbers([Mcp("Int")] int a, [Mcp("Long")] long b, [Mcp("Double")] double c) {
		return (a + b + c).ToS();
	}
	
	[Mcp("Test array")]
	public string TestArray([Mcp("Colors")] string[] a) {
		return string.Join('|', a);
	}
#else
	[Mcp("Gets the table of contents of the LibreAutomate documentation.")]
	public string get_la_docs_toc() {
		return filesystem.loadText($@"{_appDir}\toc-ai.yml");
	}
	
	[Mcp("Gets specified articles from the LibreAutomate documentation.")]
	public string get_la_docs(
		[Mcp("""
Names of articles.
Names of API articles are like "Namespace.Type.Member", "Namespace.Type", "Namespace.Type<T>.Member".
Names of non-API articles are like "[articles] name", "[editor] name", "[cookbook] name".
""")]
		string[] names
		) {
		if (App.Settings.ai_mcp_print) print.it($"<><lc yellowgreen><\a>MCP {nameof(get_la_docs)}:\n{string.Join('\n', names)}</\a><>");
		
		using var db = new sqlite($@"{_appDir}\doc-ai.db", SLFlags.SQLITE_OPEN_READONLY);
		using var sta = db.Statement($"SELECT name,text FROM doc WHERE name IN ({string.Join(',', names.Select(_ => "?"))})");
		sta.BindAll(names);
		var texts = new string[names.Length];
		while (sta.Step()) {
			string name = sta.GetText(0), text = sta.GetText(1);
			texts[names.IndexOf(name)] = text;
		}
		Debug_.PrintIf(texts.Contains(null));
		
		var sb = new StringBuilder();
		sb.AppendLine("Below are the articles you requested.").AppendLine(c_listFormatInfo);
		for (int i = 0; i < texts.Length; i++) {
			_AppendArticle(sb, i, names[i], texts[i]);
		}
		
		return sb.ToString();
	}
	
	void _AppendArticle(StringBuilder sb, int i, string name, string text) {
		sb.AppendFormat("\r\n--- {0}. {1} ---\r\n\r\n{2}\r\n", i + 1, name, text);
	}
	
	const string c_listFormatInfo = """

Article separator line format: `--- N. Name ---`, where N is 1-based index of the article.

Names of library API member articles are like `Namespace.Type.Member`. Namespaces: `Au`, `Au.More`, `Au.Triggers`, `Au.Types`.
Names of other articles have a prefix:
- `[articles]` - a library documentation article other than API member reference
- `[cookbook]` - a how-to article with code examples
- `[editor]` - LibreAutomate IDE documentation
""";
	
	[Mcp("""
Returns requested information about LibreAutomate API or IDE.
Whenever you need information about LibreAutomate API or IDE, create one or more short queries and call this tool.
This tool uses semantic search (AI embedding) to find the requested information.
If this tool receives a list of queries (one per line), it processes them paralelley (much faster) and optimizes results.
""")]
	public string find_la_docs(
		[Mcp("""
One or more short queries for semantic search, one per line.
IMPORTANT: each query must be focused on a **single** task or concept.
Keyword lists are discouraged. Use meaningful phrases.
Examples of good queries: "activate window", "send keys", "key names and syntax".
Example of a BAD query: "activate Chrome window send keys Ctrl+L LibreAutomate". What's bad here: it's not a meaningful single-task phrase but a soup of search keywords for two tasks; it includes names of windows and keys; redundant context info "LibreAutomate".
""")]
		string query,
		[Mcp("The `description` text of the `query` parameter of this tool, as specified in the MCP tool definition. This is to ensure you know how to use this parameter.")]
		string passPhrase
		) {
#if DEBUG
		print.it("--- passPhrase:");
		print.it(passPhrase);
		print.it("---");
#endif
		
		if (App.Settings.ai_mcp_print) print.it($"<><lc yellowgreen>MCP {nameof(find_la_docs)}:\r\n<><lc LemonChiffon><\a>{query}</\a><>");
		
		var lines = query.Lines(noEmpty: true);
		var aResults = new List<(string name, string text)>[lines.Length];
		
		var emModel = AiModel.GetModel<AiEmbeddingModel>(App.Settings.ai_modelEmbed, displayName: true) ?? throw new AuException("Missing settings in LibreAutomate. Please go to Options > AI and select models for documentation search.");
		var rrModel = AiModel.GetModel<AiRerankModel>(App.Settings.ai_modelRerank, displayName: true);
		if (rrModel == null) AiModel.RerankerModelWarning();
		
		try {
			var em = new Embeddings(emModel);
			var ems = em.GetDocsEmbeddings();
			
			Parallel.For(0, lines.Length, i => _QueryLine(lines[i], aResults[i] = []));
			
			void _QueryLine(string query, List<(string name, string text)> results) {
				int takePlus = Math.Min(20, query.Count(c => c is <= ' ' or ',' or '.' or ';' or '?'));
				int take = 15 + takePlus;
				
				var queryVector = em.CreateEmbedding(query);
				var topAll = em.GetTopMatches(queryVector, ems, rrModel == null ? 30 : 100);
				if (topAll.Count == 0) return;
				
				Dictionary<string, (float score, bool summary)> dTop = [];
				foreach (var v in topAll) {
					var name = v.f.name;
					bool isSum = name[0] == '+';
					if (isSum) name = name[1..];
					dTop.TryAdd(name, (v.score, isSum));
				}
				var aTop = dTop.Select(o => (name: o.Key, v: o.Value)).OrderByDescending(o => o.v.score).ToArray();
				
				string[] names = aTop.Select(o => o.name).ToArray();
				string[] texts = em.GetDocsTexts(names);
				
				if (rrModel != null) {
					var headers = rrModel.GetHeaders();
					var post = rrModel.GetPostData(query, texts);
					var j = rrModel.Post(post, headers).Json();
					//print.it(j.ToJsonString(new() { WriteIndented = true }));
					var ar = rrModel.GetResults(j).ToArray();
					float maxScore = ar[0].score, minScore = maxScore - (.3f + takePlus / 200f);
					//print.it(take, maxScore, minScore, maxScore - minScore);
					int i = 0;
					foreach (var v in ar) {
						if (i++ > take || v.score < minScore || v.score < .4f) break;
						results.Add((names[v.index], texts[v.index]));
						//print.it(v.score, names[v.index]);
					}
				} else {
					int i = 0;
					float minScore = aTop[0].v.score - (.2f + takePlus / 200f);
					foreach (var v in aTop) {
						if (v.v.score < minScore) break;
						results.Add((v.name, texts[i++]));
					}
				}
			}
		}
		catch (Exception ex) when (ex is InvalidCredentialException or AggregateException { InnerException: InvalidCredentialException }) {
			var api = emModel.api;
			throw new AuException($"Missing settings in LibreAutomate. Please go to Options > AI and set the API key for {api}.\nYou can create an API key in your account on the {api} website.");
		}
		
		Dictionary<string, string> dResults = [];
		for (int i = 0, n = aResults.Max(o => o.Count); i < n; i++) {
			foreach (var list in aResults) {
				if (i < list.Count) dResults.TryAdd(list[i].name, list[i].text);
			}
		}
		
		var sb = new StringBuilder();
		
		if (passPhrase.Length < 30 && lines.Length == 1 && query.Length > 30) {
			sb.AppendLine("Warning: the `passPhrase` argument is too short. Likely you (AI) ignore the description of the `query` parameter and use an incorrect query. Then the quality of results is bad.\r\n");
			//Some models pass exact descriptions. Some models pass summaries. Some smaller models pass eg the parameter name.
		}
		
		sb.AppendLine($"""
Found {dResults.Count} articles that likely contain the requested information.
{c_listFormatInfo}

List of article names:
""");
		
		sb.AppendLine();
		foreach (var (i, name) in dResults.Keys.Index()) {
			sb.AppendLine($"{i + 1}. {name}");
			if (App.Settings.ai_mcp_print) print.it($"{i + 1}. {name}");
		}
		
		sb.AppendLine("\r\nArticles:");
		
		foreach (var (i, v) in dResults.Index()) {
			_AppendArticle(sb, i, v.Key, v.Value);
		}
		
		//print.it(sb); print.scrollToTop();
		
		return sb.ToString();
	}
#endif
}


================================================
FILE: Au.Editor/xMisc/EnvVarUpdater.cs
================================================
using System.Collections;
using DictSS = System.Collections.Generic.Dictionary<string, string>;

namespace LA;

class EnvVarUpdater {
	DictSS _r;
	
	//Called at startup.
	public EnvVarUpdater() {
		_r = _GetVars();
		//print.it(_r);
		
		var s2 = Environment.GetEnvironmentVariable("Path");
		if (_r.TryGetValue("Path", out var s1) && s1 != s2) {
			//Debug_.PrintIf( //no, some VS versions change PATH, then always warning when this process started by VS
			//	s2.Trim(';').Replace(";;", ";") != s1, //somehow s2 ends with ';' if not admin, but no ';' if admin. Once was ";;".
			//	$"PATH env var changed at startup:\n{s1}\n{s2}");
			Environment.SetEnvironmentVariable("Path", s1);
		}
	}
	
	//Called on WM_SETTINGCHANGE("Environment").
	public void WmSettingchange() {
		csvTable csv = new();
		
		var rOld = _r;
		_r = _GetVars();
		var p = _GetVars(EnvironmentVariableTarget.Process);
		
		//for each env var deleted from registry
		foreach (var k in rOld.Keys.Except(_r.Keys, StringComparer.OrdinalIgnoreCase)) {
			if (p.TryGetValue(k, out var s1) && s1 == rOld[k]) {
				Debug_.Print($"Env var deleted: {k}");
				Environment.SetEnvironmentVariable(k, null);
				csv.AddRow(k, null);
			}
		}
		
		//for each env var added or changed in registry
		foreach (var (k, v) in _r.Except(rOld)) {
			if (p.TryGetValue(k, out var pv)) {
				if (pv == v) continue;
				//print.it(rOld.ContainsKey(k));
				if (!rOld.TryGetValue(k, out var old) || pv != old) continue;
			}
			Debug_.Print(pv == null ? $"Env var added: {k} = \"{v}\"" : $"Env var changed: {k} = \"{v}\",        was \"{pv}\"");
			Environment.SetEnvironmentVariable(k, v);
			csv.AddRow(k, v);
		}
		
		//pass to script processes
		if (csv.RowCount > 0) {
			var s = csv.ToString();
			for (var w = wnd.findFast(null, script.c_auxWndClassName, true); !w.Is0; w = wnd.findFast(null, script.c_auxWndClassName, true, w))
				if (!w.IsOfThisProcess) w.SendTimeout(200, out _, Api.WM_SETTEXT, script.c_msg_wmsettext_UpdateEnvVar, s);
		}
	}
	
	DictSS _GetVars(EnvironmentVariableTarget target) {
		var id = Environment.GetEnvironmentVariables(target);
		DictSS r = new(id.Count, StringComparer.OrdinalIgnoreCase);
		foreach (DictionaryEntry e in id) r.TryAdd(e.Key as string, e.Value as string);
		return r;
	}
	
	DictSS _GetVars() {
		//Join registry env vars user + machine.
		//	Join PATH machine+";"+user. Trim ';'.
		//	Ignore other machine vars that exist in user.
		
		var r = _GetVars(EnvironmentVariableTarget.User);
		var m = Environment.GetEnvironmentVariables(EnvironmentVariableTarget.Machine);
		bool pathOK = false;
		foreach (DictionaryEntry e in m) {
			string k = e.Key as string, v = e.Value as string;
			if (!r.TryAdd(k, v)) {
				if (!pathOK && (pathOK = k.Eqi("Path"))) r["Path"] = (v + (v.Ends(';') ? null : ";") + r["Path"]).Trim(';');
			}
		}
		if (!pathOK && r.TryGetValue("Path", out var s1)) r["Path"] = s1.Trim(';');
		return r;
	}
}


================================================
FILE: Au.Editor/xMisc/Pip.cs
================================================
//AxMSTSCLib.dll and MSTSCLib.dll were created with this cmd in Visual Studio: aximp.exe c:\windows\system32\mstscax.dll.
//	See https://learn.microsoft.com/en-us/windows/win32/termserv/calling-non-scriptable-interfaces.

using AxMSTSCLib;
using MSTSCLib;
using System.Windows.Forms;
using Microsoft.Win32;
using System.Runtime.Loader;
using wpfc = System.Windows.Controls;

namespace LA;

static class Pip {
	public static bool noActivate;
	static wnd _wMsg;
	
	/// <summary>
	/// Called at startup in non-admin process when command line starts with /pip.
	/// </summary>
	/// <param name="args"><c>args</c> without the first.</param>
	/// <returns>Process exit code (non-0 on error).</returns>
	public static int Run(ReadOnlySpan<string> args) {
		process.ThisThreadSetComApartment_(ApartmentState.STA);
		process.thisProcessCultureIsInvariant = true;
		App.InitThisAppFoldersEtc_();
		
		if (args.Length > 0) {
			switch (args[0].Lower()) {
			case "/enablecs":
				return api.WTSEnableChildSessions(true) ? 0 : 1;
			case "/disablecs":
				return api.WTSEnableChildSessions(false) ? 0 : 1;
			case "/settings":
				PipWindow.SettingsDialog();
				return 0;
			case "/noactivate":
				noActivate = true;
				break;
			default: return 2;
			}
		}
		
		if (!script.TrySingle_(@"Global\Au.PiP-mutex")) {
			if (!noActivate) {
				var w = wnd.find("PiP session", "*.Window.*", process.thisExeName);
				if (!w.Is0) w.ActivateL(true);
				else print.it("A PiP already exists on this computer. Single PiP allowed.");
			}
			return 3;
		}
		
		_wMsg = WndUtil.CreateMessageOnlyWindow("#32770", "Au.PiP-msg");
		
		if (!osVersion.minWin8_1) return _Error("Requires Windows 8.1 or later."); //tested: on 8.0 error "class not registered"
		if (miscInfo.isChildSession) return _Error("Can't start another PiP session from PiP session.");
		if (Registry.GetValue(@"HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion", "ProductName", null) is string sPN && sPN.Contains(" Home"))
			return _Error($"PiP does not work on Windows Home editions. Your OS is {sPN}.");
		
		if (api.WTSIsChildSessionsEnabled(out bool y) && !y) {
			bool isAdmin = uacInfo.isAdmin;
			string sInfo = $"PiP uses Windows feature \"Child Sessions\". Click OK to enable it.{(isAdmin ? "" : "\n\nAdministrator rights required to enable this feature.")}";
			if (!dialog.showOkCancel("Picture-in-picture setup", sInfo, icon: isAdmin ? 0 : DIcon.Shield)) return 1;
			bool enabled = isAdmin ? api.WTSEnableChildSessions(true) : run.it(process.thisExePath, "/pip /enablecs", RFlags.Admin | RFlags.WaitForExit).ProcessExitCode == 0;
			if (!enabled) return _Error("Failed to enable Child Sessions.");
		}
		
		static int _Error(string s) {
			dialog.showError("PiP error", s);
			return 1;
		}
		
		AssemblyLoadContext.Default.Resolving += static (alc, an) => alc.LoadFromAssemblyPath(folders.ThisAppBS + an.Name + ".dll");
		Application.Run(new PipWindow());
		return 0;
	}
	
	internal static void SetConnected_(int connected) {
		_wMsg.SetWindowLong(GWL.DWL.USER, connected);
	}
}

file class PipWindow : Form {
	AxMsRdpClient9NotSafeForScripting _axRdp;
	IMsRdpClient9 _rdp;
	wnd _w;
	FullScreenWindow _fullScreen;
	long _reconnecting;
	
	public PipWindow() {
		Text = "PiP session";
		Icon = icon.trayIcon(Api.IDI_APPLICATION + 2).ToGdipIcon();
		/*
*PhosphorIcons.RectangleFill #BBE3FF %.5,2.5,.5,2.5,f
*PhosphorIcons.PictureInPictureLight #909090
		*/
		
		Controls.Add(_axRdp = new() { Dock = DockStyle.Fill });
		
		StartPosition = FormStartPosition.Manual;
		if (_sett.wndPos == null) {
			var rm = screen.primary.WorkArea;
			base.SetDesktopBounds(rm.left + rm.Width / 3, rm.top, rm.Width * 2 / 3, rm.Height * 3 / 4);
		}
		WndSavedRect.Restore(this, _sett.wndPos, o => _sett.wndPos = o);
	}
	
	protected override void OnHandleCreated(EventArgs e) {
		_w = this.Hwnd();
		
		if (osVersion.minWin11) unsafe {
				var rbp = api.DWM_WINDOW_CORNER_PREFERENCE.DWMWCP_DONOTROUND;
				api.DwmSetWindowAttribute(_w, api.DWMWA_WINDOW_CORNER_PREFERENCE, &rbp, 4);
			}
		
		base.OnHandleCreated(e);
	}
	
	protected override void OnLoad(EventArgs e) {
		_rdp = (IMsRdpClient9)_axRdp.GetOcx();
		var advSett = _rdp.AdvancedSettings9;
		var exSett = (IMsRdpExtendedSettings)_rdp;
		
		_rdp.Server = "localhost";
		exSett.set_Property("ConnectToChildSession", true);
		advSett.EnableCredSspSupport = true;
		
		//_rdp.UserName = Environment.UserName;
		//advSett.ClearTextPassword = "?";
		
		try {
			int scale = Dpi.Scale(100, _w);
			if (scale > 100) {
				exSett.set_Property("DesktopScaleFactor", (uint)Math.Min(500, scale));
				exSett.set_Property("DeviceScaleFactor", 100u);
			}
			
			//advSett.SmartSizing = true; //does not work; not useful
			advSett.ContainerHandledFullScreen = 1; //less trouble
			advSett.PinConnectionBar = false;
			((IMsRdpClientNonScriptable3)_rdp).ConnectionBarText = this.Text; //tested: other members of "NonScriptable" interfaces are not interesting.
			if (!_sett.redirectClipboard) advSett.RedirectClipboard = false;
			//if (osVersion.minWin10_1803) _exSett.set_Property("ManualClipboardSyncEnabled", true); //exception when trying to get the `Clipboard` property. Bug in native method. Code: if (_rdp is IMsRdpClientNonScriptable7 rdpns7) timer.every(2000, _=> { print.it(rdpns7.Clipboard); });
			//advSett.EnableWindowsKey = 1; //default 1, but does not work
			advSett.Compress = 0;
			advSett.RedirectSmartCards = true;
			//timer.after(3000, _ => { es.set_Property("ShowSessionDiagnostics", true); }); //does not work
			
			if (Api.WTSGetChildSessionId(out int csid)) {
				//print.it(csid);
			} else {
				//if editor not set to run at startup, set to run at startup once
				bool editorAutoRun = Registry.GetValue(@"HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Run", "Au.Editor", null) is string s1 && s1.RxIsMatch($"(?i)^\".+?Au.Editor.exe\"");
				if (!editorAutoRun) Registry.SetValue(@"HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\RunOnce", "Au.Editor (PiP)", $"\"{process.thisExePath}\" /a");
			}
		}
		catch (Exception ex) { print.warning(ex); }
		
		_Events();
		
		_rdp.Connect();
		
		_axRdp.SizeChanged += (_, _) => _UpdateDesktopSize();
		AutoScaleMode = AutoScaleMode.Dpi; //not in ctor, to avoid DPI-scaling of the window size at startup
		
		if (Pip.noActivate) {
			_w.SetWindowPos(SWPFlags.NOACTIVATE | SWPFlags.NOMOVE | SWPFlags.NOSIZE, zorderAfter: SpecHWND.BOTTOM);
			//var wa = wnd.active;
			//if (!wa.Is0 && wa != _w) {
			//	_w.SetWindowPos(SWPFlags.NOACTIVATE | SWPFlags.NOMOVE | SWPFlags.NOSIZE, zorderAfter: wa);
			//	//_w.TaskbarButton.Flash(1); //no
			//}
		} else {
			_w.ActivateL(); //window in background after UAC consent
		}
		
		base.OnLoad(e);
	}
	
	protected override bool ShowWithoutActivation => Pip.noActivate;
	
	protected override CreateParams CreateParams {
		get {
			var p = base.CreateParams;
			if (Pip.noActivate) p.ExStyle |= (int)WSE.NOACTIVATE; //workaround for: the ActiveX control activates the window, although ShowWithoutActivation returns true
			return p;
		}
	}

	protected override void OnFormClosing(FormClosingEventArgs e) {
		_fullScreen?.SetFullScreen(false);
		Pip.SetConnected_(0);
		base.OnFormClosing(e);
	}
	
	void _Events() {
		_axRdp.OnConnected += (sender, e) => {
			_PrintEvent("OnConnected");
			Pip.SetConnected_(1);
			_reconnecting = 0;
			if (Pip.noActivate) _w.SetExStyle(WSE.NOACTIVATE, WSFlags.Remove);
		};
		_axRdp.OnDisconnected += (sender, e) => {
			_PrintEvent("OnDisconnected", _rdp.ExtendedDisconnectReason);
			Pip.SetConnected_(0);
			if (_reconnecting != 0 && Environment.TickCount64 - _reconnecting < 5000) {
				timer.after(100, _ => {
					//print.it("reconnecting"); //tested: succeeds after 400 ms
					_rdp.AdvancedSettings9.RedirectClipboard = _sett.redirectClipboard;
					_rdp.Connect();
				});
			} else {
				Close();
			}
		};
		_axRdp.OnRequestGoFullScreen += (sender, e) => {
			_PrintEvent("OnRequestGoFullScreen");
			_SetFullScreen(true);
		};
		_axRdp.OnRequestLeaveFullScreen += (sender, e) => {
			_PrintEvent("OnRequestLeaveFullScreen");
			_SetFullScreen(false);
		};
		_axRdp.OnRequestContainerMinimize += (sender, e) => {
			_PrintEvent("OnRequestContainerMinimize");
			_w.ShowMinimized();
		};
		_axRdp.OnConnectionBarPullDown += (sender, e) => {
			_PrintEvent("OnConnectionBarPullDown");
			_rdp.FullScreen = false;
			if (mouse.isPressed(MButtons.Left) && _w.GetWindowAndClientRectInScreen(out var r, out var rc) && rc.top > r.top) {
				r.bottom = rc.top;
				Api.SetCursorPos(r.CenterX, r.CenterY);
				_w.Send(Api.WM_SYSCOMMAND, Api.SC_MOVE);
			}
		};
		_axRdp.OnAuthenticationWarningDisplayed += (sender, e) => {
			_PrintEvent("OnAuthenticationWarningDisplayed");
			print.it("Info: If PiP prompts for credentials every time: sign out of the PiP session, then sign out of your main session and sign in again.");
			if (Pip.noActivate) {
				_w.SetExStyle(WSE.NOACTIVATE, WSFlags.Remove);
				_w.ActivateL();
			}
		};
#if DEBUG
		_axRdp.OnConnecting += (sender, e) => { _PrintEvent("OnConnecting"); };
		_axRdp.OnLoginComplete += (sender, e) => { _PrintEvent("OnLoginComplete"); };
		_axRdp.OnChannelReceivedData += (sender, e) => { _PrintEvent("OnChannelReceivedData"); };
		_axRdp.OnFatalError += (sender, e) => { _PrintEvent("OnFatalError", e.errorCode); };
		_axRdp.OnWarning += (sender, e) => { _PrintEvent("OnWarning", e.warningCode); };
		_axRdp.OnEnterFullScreenMode += (sender, e) => { _PrintEvent("OnEnterFullScreenMode "); };
		_axRdp.OnLeaveFullScreenMode += (sender, e) => { _PrintEvent("OnLeaveFullScreenMode "); };
		_axRdp.OnRemoteDesktopSizeChange += (sender, e) => { _PrintEvent("OnRemoteDesktopSizeChange", e.width, e.height); };
		_axRdp.OnIdleTimeoutNotification += (sender, e) => { _PrintEvent("OnIdleTimeoutNotification"); };
		_axRdp.OnConfirmClose += (sender, e) => { _PrintEvent("OnConfirmClose"); e.pfAllowClose = true; };
		//_axRdp.OnReceivedTSPublicKey += (sender, e) => { _PrintEvent("OnReceivedTSPublicKey"); };
		_axRdp.OnAutoReconnecting += (sender, e) => { _PrintEvent("OnAutoReconnecting"); };
		_axRdp.OnAuthenticationWarningDismissed += (sender, e) => { _PrintEvent("OnAuthenticationWarningDismissed"); };
		//_axRdp.OnRemoteProgramResult += (sender, e) => { _PrintEvent("OnRemoteProgramResult"); };
		//_axRdp.OnRemoteProgramDisplayed += (sender, e) => { _PrintEvent("OnRemoteProgramDisplayed"); };
		//_axRdp.OnRemoteWindowDisplayed += (sender, e) => { _PrintEvent("OnRemoteWindowDisplayed"); };
		_axRdp.OnLogonError += (sender, e) => { _PrintEvent("OnLogonError", e.lError); };
		_axRdp.OnFocusReleased += (sender, e) => { _PrintEvent("OnFocusReleased"); };
		//_axRdp.OnUserNameAcquired += (sender, e) => { _PrintEvent("OnUserNameAcquired", e.bstrUserName); };
		//_axRdp.OnMouseInputModeChanged += (sender, e) => { _PrintEvent("OnMouseInputModeChanged"); };
		_axRdp.OnServiceMessageReceived += (sender, e) => { _PrintEvent("OnServiceMessageReceived"); };
		//_axRdp.OnNetworkStatusChanged += (sender, e) => { _PrintEvent("OnNetworkStatusChanged"); };
		_axRdp.OnDevicesButtonPressed += (sender, e) => { _PrintEvent("OnDevicesButtonPressed"); };
		_axRdp.OnAutoReconnected += (sender, e) => { _PrintEvent("OnAutoReconnected"); };
		_axRdp.OnAutoReconnecting2 += (sender, e) => { _PrintEvent("OnAutoReconnecting2"); };
#endif
	}
	
	[Conditional("DEBUG")]
	static void _PrintEvent(string s) {
		//print.it($"<><c green>event <_>{s}</_><>");
	}
	
	[Conditional("DEBUG")]
	static void _PrintEvent(object value1, object value2, params object[] more) {
		//print.it($"<><c green>event <_>{print.util.toList(", ", value1, value2, more)}</_><>");
	}
	
	void _UpdateDesktopSize() {
		if (_dontUpdateDesktopSize) return;
		var cs = _axRdp.ClientSize; int wid = cs.Width, hei = cs.Height;
		if (wid < 200 || hei < 200) return; //eg minimized
		if (wid == _rdp.DesktopWidth && hei == _rdp.DesktopHeight) return; //eg restored from minimized
		
		//print.it("_UpdateDesktopSize", wid, hei, _rdp.DesktopWidth, _rdp.DesktopHeight);
		
		int scale = Dpi.Scale(100, _w);
		try { _rdp.UpdateSessionDisplaySettings((uint)wid, (uint)hei, 0, 0, 0, (uint)scale, 100); }
		catch { } //eg soon after starting. Never mind.
	}
	
	void _SetFullScreen(bool on) {
		_fullScreen ??= new(_w);
		_dontUpdateDesktopSize = true; //because the control resized 2 times: when changing window style and size; it makes PiP desktop resizing slow.
		_fullScreen.SetFullScreen(on);
		_dontUpdateDesktopSize = false;
		_UpdateDesktopSize();
	}
	bool _dontUpdateDesktopSize;
	
	bool IsConnected => _rdp?.Connected is 1;
	//bool IsConnectedOrConnecting => _rdp?.Connected is 1 or 2;
	
	protected override void WndProc(ref Message m) {
		switch (m.Msg) {
		case Api.WM_SYSCOMMAND:
			switch (m.WParam.ToInt32() & 0xFFF0) {
			case Api.SC_MAXIMIZE:
				_rdp.FullScreen = true;
				return;
			case Api.SC_MOUSEMENU:
				_SystemIconMenu();
				return;
				//case Api.SC_CLOSE: //rejected. Inconsistent with the full-screen Close button behavior (and the button cannot be intercepted or removed).
				//	switch (popupMenu.showSimple("1 Disconnect|2 Sign out", owner: this)) {
				//	case 1: _rdp.Disconnect(); break;
				//	case 2: _ = PipIPC.SendAsync("logoff"); break;
				//	}
				//	return;
			}
			break;
		case Api.WM_ACTIVATE when IsConnected:
			_ = PipIPC.SendAsync(Math2.LoWord(m.WParam) != 0 ? "WM_ACTIVATE 1" : "WM_ACTIVATE 0", 1000);
			break;
		}
		
		base.WndProc(ref m);
	}
	
	void _SystemIconMenu() {
		if (!IsConnected) return;
#if true
		var m = new popupMenu();
		m.Add("SETTINGS (will reconnect to change)", disable: true);
		m.AddCheck("Clipboard sync enabled", _sett.redirectClipboard, o => {
			_sett.redirectClipboard = o.IsChecked;
			_reconnecting = Environment.TickCount64;
			_rdp.Disconnect();
			//note: Reconnect() does not work.
		});
#else
		if (!api.WTSGetChildSessionId(out int csid)) return;
		int rdpclip = process.allProcesses().FirstOrDefault(o => o.Name.Eqi("rdpclip.exe") && o.SessionId == csid).Id;
		var m = new popupMenu();
		m.AddCheck("Enable clipboard sync", rdpclip != 0, o => {
			if (o.IsChecked) PipAgent.Send("clipboard"); //run rdpclip.exe in PiP session
			else process.terminate(rdpclip);
		});
#endif
		m.Separator();
		m["Help"] = o => HelpUtil.AuHelp("editor/PiP session");
#if DEBUG
		m.Separator();
		m["Test 1"] = o => {
			print.it(PipIPC.SendSync("test"));
		};
		m["Test 2"] = async o => {
			if (await PipIPC.SendAsync("test") is string r) {
				print.it(r);
			}
		};
#endif
		m.Show(owner: this);
	}
	
	public static void SettingsDialog() {
		var b = new wpfBuilder("PiP settings").WinSize(400);
		b.R.Add(out wpfc.CheckBox cSepClip, "Clipboard sync enabled").Checked(_sett.redirectClipboard);
		b.R.AddOkCancel();
		b.End();
		b.Loaded += () => { b.Window.Hwnd().ActivateL(); };
		if (!b.ShowDialog()) return;
		
		_sett.redirectClipboard = cSepClip.IsChecked.Value;
	}
	
	record class _Settings : JSettings {
		public static readonly string File = AppSettings.DirBS + @"PiP.json";
		
		public static _Settings Load() => Load<_Settings>(File);
		
		public string wndPos;
		public bool redirectClipboard = true;
	}
	static _Settings _sett = _Settings.Load();
}

file class FullScreenWindow {
	wnd _w;
	RECT _r;
	WS _style;
	//WSE _exStyle; //never mind
	bool _isFS, _maximized;
	
	public FullScreenWindow(wnd w) {
		_w = w;
	}
	
	public void SetFullScreen(bool on) {
		if (on) {
			if (_isFS) return;
			_maximized = _w.IsMaximized;
			_w.ShowNotMinMax();
			_r = _w.Rect;
			_style = _w.Style;
			_w.SetStyle(_style & ~(WS.CAPTION | WS.THICKFRAME));
			_isFS = true; //before setting the final rect; then eg on wm_size IsFullScreen will return true
			_w.MoveL(screen.of(_w).Rect, SWPFlags.FRAMECHANGED); //info: it automatically makes taskbar non-topmost
		} else if (_isFS) {
			_isFS = false;
			_w.MoveL(_r, SWPFlags.FRAMECHANGED);
			_w.SetStyle(_style);
			if (_maximized) _w.ShowMaximized();
		}
	}
	
	public bool IsFullScreen => _isFS;
}

#pragma warning disable 649, 169 //field never assigned/used
unsafe file class api : NativeApi {
	[DllImport("wtsapi32.dll")]
	internal static extern bool WTSIsChildSessionsEnabled(out bool pbEnabled);
	
	[DllImport("wtsapi32.dll", SetLastError = true)]
	internal static extern bool WTSEnableChildSessions(bool bEnable);
	
	internal enum DWM_WINDOW_CORNER_PREFERENCE {
		DWMWCP_DEFAULT,
		DWMWCP_DONOTROUND,
		DWMWCP_ROUND,
		DWMWCP_ROUNDSMALL
	}
	
	[DllImport("dwmapi.dll")]
	internal static extern int DwmSetWindowAttribute(wnd hwnd, uint dwAttribute, void* pvAttribute, uint cbAttribute);
	
	internal const int DWMWA_WINDOW_CORNER_PREFERENCE = 33;
}


================================================
FILE: Au.Editor/xMisc/PipIPC.cs
================================================
using System.Security.AccessControl;
using System.Security.Principal;
using System.IO.Pipes;
using System.Text.Json.Nodes;
using Microsoft.Win32;
using System.Text.Json;

namespace LA;

/// <summary>
/// Used by all PiP processes.
/// </summary>
/// <remarks>
/// When PiP is active, 3 Au.Editor.exe processes are running:
/// <br/>• 1. Normal process in main session. Calls <see cref="StartPip"/> or <see cref="RunScriptInPip"/>. They use the <b>SendX</b> functions to communicate with process 3.
/// <br/>• 2. Process in main session that shows PiP window and starts child session. Can use the <b>SendX</b> functions to communicate with process 3.
/// 		Normally started by process 1 (the above functions). Or can be started manually, using command line <c>/pip</c>. Can run without process 1 or/and 3.
/// <br/>• 3. Normal process in child session. Calls <see cref="StartPipeServerThread"/>, which starts scripts in child session and performs other tasks requested by processes 1 and 2.
/// 		Normally started via the registry key (process 2 sets RunOnce if need). Or can be [re] started manually. If not running, processes 1 and 2 can't start scripts etc in child session.
/// </remarks>
class PipIPC {
	const string c_pipeName = "Au.PiP-pipe";
	
	/// <summary>
	/// Sends a message from the main session to the LA pipe server running in the PiP session.
	/// </summary>
	/// <param name="message">A single-line message. Can be like <c>"message"</c> or <c>"message parameter"</c>.</param>
	/// <param name="timeoutMS">Timeout for <see cref="NamedPipeClientStream.Connect"/>.</param>
	/// <returns>Response of the pipe server. Single line. Returns null if failed (eg connection timeout).</returns>
	public static string SendSync(string message, int timeoutMS = 60_000) {
		try {
			using var client = new NamedPipeClientStream(".", c_pipeName, PipeDirection.InOut);
			client.Connect(timeoutMS);
			
			var writer = new StreamWriter(client) { AutoFlush = true };
			var reader = new StreamReader(client);
			
			writer.WriteLine(message);
			var r = reader.ReadLine();
			return r;
		}
		catch (Exception ex) { Debug_.Print($"{message}.  {ex}"); return null; }
	}
	
	/// <inheritdoc cref="SendSync"/>
	public static async Task<string> SendAsync(string message, int timeoutMS = 60_000) {
		return await Task.Run(() => SendSync(message, timeoutMS));
	}
	
	public static void StartPipeServerThread() {
		run.thread(_PipeServer, sta: false);
	}
	
	static void _PipeServer() {
		try {
			var security = new PipeSecurity();
			security.AddAccessRule(new PipeAccessRule(new SecurityIdentifier(WellKnownSidType.AuthenticatedUserSid, null), PipeAccessRights.FullControl, AccessControlType.Allow));
			using var server = NamedPipeServerStreamAcl.Create(c_pipeName, PipeDirection.InOut, 1, PipeTransmissionMode.Message, 0, 0, 0, security);
			
			for (; ; ) {
				server.WaitForConnection();
				
				var reader = new StreamReader(server);
				var writer = new StreamWriter(server) { AutoFlush = true };
				
				string message = reader.ReadLine(), param = null, ret = "\a";
				int i = message.IndexOf(' ');
				if (i > 0) (param, message) = (message[(i + 1)..], message[..i]);
				//print.it(message, param);
				
				switch (message) {
				case "runScript":
					//ret = _RunScript(param);
					Task.Run(() => _RunScript(param));
					break;
				case "logoff":
					Task.Run(() => computer.logoff());
					break;
				//case "clipboard":
				//	Task.Run(() => Process.Start("rdpclip.exe"));
				//	break;
				//case "syncFiles": //no
				//	if (App.Dispatcher is { } disp) {
				//		disp.InvokeAsync(() => {
				//			Panels.Editor.OnAppActivated_();
				//			App.Model?.SyncWithFilesystem_();
				//		});
				//	}
				//	break;
				case "WM_ACTIVATE":
					if (App.Hmain.IsActive) App.Dispatcher.InvokeAsync(() => MainWindow.OnActivatedDeactivatedAppOrPip_(param == "1"));
					break;
				default:
					ret = "Bad: " + message;
					break;
				}
				
				writer.WriteLine(ret);
				server.Disconnect();
			}
		}
		catch (Exception ex) { print.it(ex); }
	}
	
	static void _RunScript(string param) {
		try {
			bool laActive = App.Hmain.IsActive;
			if (laActive) App.Dispatcher.Invoke(Panels.Editor.OnAppActivated_);
			
			var j = JsonNode.Parse(param);
			string file = (string)j["file"];
			string[] args = j["args"] is JsonArray ja ? ja.Select(o => (string)o).ToArray() : [];
			
			if (!laActive) if (!wait.until(-60, () => miscInfo.isInputDesktop(true))) throw new InputDesktopException("Now cannot run scripts in PiP session."); //1-2 s when connecting to existing session
			
			//script.run(file, args); //works, but I like more low-level code here
			App.Dispatcher.InvokeAsync(() => {
				if (App.Model?.FindCodeFile(file) is { } f) {
					CompileRun.CompileAndRun(true, f, args);
				}
			});
		}
		catch (Exception ex) { print.it(ex); }
	}
	
	///// <summary>
	///// Returns true if child sessions supported (Win8.1+, not Home edition, not in child session).
	///// </summary>
	//public static bool CanUsePip => s_canUsePip ??= osVersion.minWin8_1 && !miscInfo.isChildSession && !(Registry.GetValue(@"HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion", "ProductName", null) is string sPN && sPN.Contains(" Home"));
	//static bool? s_canUsePip;
	
	static bool _CanUsePip() {
		if (!osVersion.minWin8_1) return _Error("Requires Windows 8.1 or later."); //tested: on 8.0 error "class not registered"
		if (miscInfo.isChildSession) return _Error("Can't start another PiP session from PiP session.");
		if (Registry.GetValue(@"HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion", "ProductName", null) is string sPN && sPN.Contains(" Home"))
			return _Error($"PiP does not work on Windows Home editions. Your OS is {sPN}.");
		return true;
		//the pip exe will auto-enable child sessions
		
		static bool _Error(string s) {
			dialog.showError("PiP error", s, owner: App.Hmain);
			return false;
		}
	}
	
	public static void StartPip() {
		App.Model.Save.AllNowIfNeed();
		if (!_CanUsePip()) return;
		_PipProcessStarter("/pip").Start();
	}
	
	static ProcessStarter_ _PipProcessStarter(string args) => new(process.thisExePath, args, rawExe: true);
	
	public static async void RunScriptInPip(FileNode f, params string[] args) {
		App.Model.Save.AllNowIfNeed();
		if (!_CanUsePip()) return;
		if (!CompileRun.Compile(true, ref f, out _)) return;
		string itemPath = f.ItemPath;
		
		string _Run() {
			lock ("9j8+It9PbUaiHCFoo9QaSA") {
				static bool _EnsurePipConnected() {
					wnd wMsg = _FindWndMsg();
					if (wMsg.Is0) {
						var v = _PipProcessStarter("/pip /noactivate").Start(ProcessStarter_.Result.Need.WaitHandle);
						wait.until(0, () => !(wMsg = _FindWndMsg()).Is0 || v.waitHandle.WaitOne(0)); //wait until the pip message-only window created or the pip process ended
						v.waitHandle.Dispose();
						if (wMsg.Is0) return false;
					}
					return wait.until(0, () => wMsg.GetWindowLong(GWL.DWL.USER) == 1 || !wMsg.IsAlive) && wMsg.IsAlive; //wait until connected
					
					static wnd _FindWndMsg() => wnd.findFast("Au.PiP-msg", "#32770", messageOnly: true); //created in pip process at startup, just after entering the single-instance mutex
				}
				
				for (int i = 2; --i >= 0;) { //retry if the pip process is closing etc
					if (_EnsurePipConnected()) break;
					if (i == 0) return "Failed to start PiP session.";
					Debug_.Print("retrying PiP-connect");
					2.s();
				}
				
				return SendSync("runScript " + JsonSerializer.Serialize(new { file = itemPath, args = args }));
			}
		}
		
		if (await Task.Run(_Run) is string r) {
			if (!r.Starts("\a")) print.warning($"Failed to run script {f.SciLink()} in PiP session. {r}", -1);
		} else {
			print.warning($"Failed to run script {f.SciLink()} in PiP session. Make sure LibreAutomate is running in PiP session too.", -1);
		}
	}
}


================================================
FILE: Au.Editor/xMisc/RegHotkeys.cs
================================================
namespace LA;

static class RegHotkeys {
	static RegisteredHotkey[] _a = new RegisteredHotkey[9];
	
	public enum Id {
		QuickCaptureMenu, QuickCaptureDwnd, QuickCaptureDelm, QuickCaptureDuiimage,
		DebugNext, DebugStep, DebugStepOut, DebugContinue, DebugPause,
	}
	const Id _DebugFirst = Id.DebugNext, _DebugLast = Id.DebugPause;
	
	public static void RegisterPermanent() {
#if !IDE_LA
		(string keys, string menu)[] g = [
			(App.Settings.hotkeys.tool_quick, nameof(Menus.Code.Quick_capturing_info)),
			(App.Settings.hotkeys.tool_wnd, nameof(Menus.Code.wnd)),
			(App.Settings.hotkeys.tool_elm, nameof(Menus.Code.elm)),
			(App.Settings.hotkeys.tool_uiimage, nameof(Menus.Code.uiimage)),
		];
		for (int i = 0; i < (int)_DebugFirst; i++) {
			string keys = g[i].keys;
			if (!keys.NE()) {
				try {
					if (!_a[i].Register(i, keys, App.Hmain, noRepeat: true)) {
						print.warning($"Failed to register hotkey {keys}. Look in <+options Hotkeys>Options > Hotkeys<>.", -1);
						keys = null;
					}
				}
				catch (Exception ex) { print.it(ex); keys = null; }
			}
			if (i > 0) App.Commands[g[i].menu].MenuItem.InputGestureText = keys;
		}
#endif
	}
	
	public static void UnregisterPermanent() {
		for (int i = 0; i < (int)_DebugFirst; i++) _a[i].Unregister();
	}
	
	public static void RegisterDebug() {
		for (int i = (int)_DebugFirst; i <= (int)_DebugLast; i++) {
			string keys = (Id)i switch { Id.DebugNext => "F10", Id.DebugStep => "F11", Id.DebugStepOut => "Shift+F11", Id.DebugContinue => "F5", Id.DebugPause => "F6", _ => null };
			if (!_a[i].Register(i, keys, App.Hmain)) print.warning($"Failed to register hotkey {keys}.", -1);
		}
	}
	
	public static void UnregisterDebug() {
		for (int i = (int)_DebugFirst; i <= (int)_DebugLast; i++) _a[i].Unregister();
	}
	
	internal static void WmHotkey_(nint wParam) {
		var id = (Id)(int)wParam;
		switch (id) {
		case Id.QuickCaptureMenu: QuickCapture.Menu(); break;
		case Id.QuickCaptureDwnd: QuickCapture.AoolDwnd(); break;
		case Id.QuickCaptureDelm: QuickCapture.ToolDelm(); break;
		case Id.QuickCaptureDuiimage: QuickCapture.ToolDuiimage(); break;
		case >= _DebugFirst and <= _DebugLast: Panels.Debug.WmHotkey_(id); break;
		}
	}
}


================================================
FILE: Au.Editor/xMisc/UacDragDrop.cs
================================================
using System.Runtime.InteropServices.ComTypes;
using System.Windows.Interop;

namespace LA;

class UacDragDrop {
	public class AdminProcess {
		WinEventHook _hook; //SYSTEM_CAPTURESTART
		timer _timer; //tracks mouse etc
		bool _isDragMode; //is in drag-drop
		bool _isProcess2; //is our non-admin process started
		int _endCounter; //delays ending drag mode
		
		static AdminProcess s_inst;
		
		//Called with on=true when main window becomes visible.
		//Called with on=false when hidden or closed.
		public static void Enable(bool on) {
			if (on == (s_inst != null)) return;
			if (on) {
				if (uacInfo.ofThisProcess.Elevation != UacElevation.Full) return;
				s_inst = new AdminProcess();
			} else {
				s_inst._Dispose();
				s_inst = null;
			}
		}
		
		AdminProcess() {
			_timer = new timer(_Timer);
			
			//use hook to detect when drag-drop started
			_hook = new WinEventHook(EEvent.SYSTEM_CAPTURESTART, 0, d => {
				//print.it("SYSTEM_CAPTURESTART", d.w, d.w.IsVisible, d.w.IsMessageOnly);
				var isClass = d.w.ClassNameIs("CLIPBRDWNDCLASS", "DragWindow", "LiftedDMITCursorRecalculateClass");
				if (isClass == 3) return; //probably related to the Windows feature "Drag Tray". It we just end drag mode, drag-drop does not work first time after Windows startup if the feature is not turned off.
				_EndedDragMode();
				if (isClass == 0 && d.w.IsVisible) return; //all known inter-process drag-drop capturing windows are invisible; some also message-only.
				_StartedDragMode();
			}, flags: EHookFlags.SKIPOWNPROCESS);
			
			//note: we don't use SYSTEM_CAPTUREEND. It's too early and sometimes missing.
			//tested: no EVENT_SYSTEM_DRAGDROPSTART events.
			//info: classname "DragWindow" is of Windows Store.
			//rejected: int pid = d.w.ProcessId; using(var u = uacInfo.ofProcess(pid)) { if(u == null || u.Elevation == UacElevation.Full) return; }
		}
		
		void _Dispose() {
			_hook.Dispose();
			_EndedDragMode();
		}
		
		void _StartedDragMode() {
			_isDragMode = true;
			_endCounter = 0;
			_wTransparent = default;
			_wWindow = default;
			_wTargetControl = default;
			_data = null;
			_timer.Every(30);
		}
		
		void _EndedDragMode() {
			if (!_isDragMode) return;
			_isDragMode = _isProcess2 = false;
			_timer.Stop();
			if (!_wTransparent.Is0) _wTransparent.Post(Api.WM_USER); //let it close self
		}
		
		//Every 30 ms while in drag mode.
		void _Timer(timer t) {
			if (!_isDragMode) return;
			
			//when mouse released, end drag mode with ~100 ms delay
			if (!mouse.isPressed(MButtons.Left | MButtons.Right)) { //calls GetKeyStateAsync. GetKeyState unreliable when in drag mode.
				if (++_endCounter == 4) _EndedDragMode();
				return;
			}
			_endCounter = 0;
			//end drag mode if _wTransparent died, eg did not find useful data on drag enter
			if (!_wTransparent.Is0 && !_wTransparent.IsAlive) {
				_EndedDragMode();
				return;
			}
			
			var w = wnd.fromMouse(WXYFlags.NeedWindow);
			if (!_isProcess2) {
				if (!w.IsOfThisProcess) return;
				_isProcess2 = true;
				_wWindow = w;
				new ProcessStarter_("Au.Editor.exe", "/dd " + CommandLine.MsgWnd.Handle.ToString()).StartUserIL();
			} else if (!_wTransparent.Is0 && w != _wTransparent) {
				_wWindow = w;
				_SetTransparentSizeZorder();
			}
		}
		
		wnd _wTransparent; //our transparent non-admin window
		wnd _wWindow; //current our top-level admin window covered by _wTransparent
		
		//Called in admin process. Non-admin process may not be able to zorder its window above admin windows.
		void _SetTransparentSizeZorder() {
			if (_wWindow.IsOfThisProcess) {
				var r = _wWindow.Rect;
				_wTransparent.MoveL(r.left, r.top, r.Width, r.Height);
				bool ok = _wTransparent.ZorderL_(_wWindow, before: true);
				Debug_.PrintIf(!ok, $"ZorderL_ failed. {lastError.message}. _wWindow={_wWindow}");
			} else {
				_wTransparent.MoveL(0, 0, 0, 0);
			}
		}
		
		//SendMessage from _wTransparent on WM_CREATE.
		public static void OnTransparentWindowCreated(wnd wTransparent) {
			var x = s_inst;
			if (x?._isDragMode ?? false) {
				x._wTransparent = wTransparent;
				x._SetTransparentSizeZorder();
			} else wTransparent.Post(Api.WM_USER); //let it close self
		}
		
		public static int DragEvent(int event_, byte[] b) => s_inst?._DragEvent(event_, b) ?? 0;
		
		int _DragEvent(int event_, byte[] b) {
			if (!_isDragMode) return 0;
			DDEvent ev = (DDEvent)event_;
			if (ev == DDEvent.Leave) {
				if (!_wTargetControl.Is0) {
					_InvokeDT(_wTargetControl, ev, 0, 0, default);
					_wTargetControl = default;
				}
				return 0;
			}
			var a = Serializer_.Deserialize(b);
			int effect = a[0], keyState = a[1]; POINT pt = new(a[2], a[3]);
			if (ev == DDEvent.Enter) {
				_data = new System.Windows.DataObject();
				var t = new DDData { files = a[4], shell = a[5], text = a[6], linkName = a[7] };
				if (t.files != null) _data.SetData("FileDrop", t.files);
				if (t.shell != null) _SetDataBytes("Shell IDList Array", t.shell);
				if (t.text != null) _data.SetData("UnicodeText", t.text);
				if (t.linkName != null) _SetDataBytes("FileGroupDescriptorW", t.linkName);
				
				//workaround for: SetData writes byte[] in wrong format, probably serialized
				void _SetDataBytes(string name, byte[] a) => _data.SetData(name, new MemoryStream(a), false);
			}
			
			int ef = 0;
			var w = _wWindow.ChildFromXY(pt, WXYCFlags.ScreenXY);
			if (w.Is0) w = _wWindow;
			if (w != _wTargetControl && !_wTargetControl.Is0) {
				_InvokeDT(_wTargetControl, DDEvent.Leave, 0, 0, default);
				_wTargetControl = default;
			}
			if (!w.Is0 && w.IsOfThisProcess && w.IsEnabled(true)) {
				if (ev != 0 && _wTargetControl.Is0) {
					if (ev == DDEvent.Over) ev = 0;
					else _InvokeDT(w, DDEvent.Enter, effect, keyState, pt);
				}
				ef = _InvokeDT(_wTargetControl = w, ev, effect, keyState, pt);
			}
			
			if (ev == DDEvent.Drop) { _wTargetControl = default; }
			
			int _InvokeDT(wnd w, DDEvent ev, int effect, int keyState, POINT pt) {
				if (w.IsOfThisThread) return _InvokeDropTarget(w, ev, effect, keyState, pt);
				var d = HwndSource.FromHwnd(w.Window.Handle)?.Dispatcher;
				return d?.Invoke(() => _InvokeDropTarget(w, ev, effect, keyState, pt)) ?? 0;
			}
			
			return ef;
		}
		
		//data etc sent by _wTransparent on OnDragEnter. Then used here on enter/over/drop.
		System.Windows.DataObject _data;
		wnd _wTargetControl; //control or window from mouse
		
		unsafe int _InvokeDropTarget(wnd w, DDEvent ev, int effect, int keyState, POINT pt) {
			nint dt = w.Prop["OleDropTargetInterface"];
			if (dt == 0 && w != _wWindow) { //if w is of a HwndHost that does not register drop target, use that of the main window
				w = _wWindow;
				dt = w.Prop["OleDropTargetInterface"];
			}
			if (dt == 0) return 0;
			
#pragma warning disable CS0168 // Variable is declared but never used
			try {
				nint* vtbl = *(nint**)dt + 3;
				int hr = ev switch {
					DDEvent.Enter or DDEvent.Drop => ((delegate* unmanaged<nint, IDataObject, int, POINT, ref int, int>)vtbl[ev == DDEvent.Drop ? 3 : 0])(dt, _data, keyState, pt, ref effect),
					DDEvent.Over => ((delegate* unmanaged<nint, int, POINT, ref int, int>)vtbl[1])(dt, keyState, pt, ref effect),
					_ => ((delegate* unmanaged<nint, int>)vtbl[2])(dt)
				};
				if (hr != 0) effect = 0;
			}
			catch (Exception ex) { //once: exception "access violation". Can't repro. To call IDropTarget methods easily, then was used a C++ helper function, not C# delegate*.
#if DEBUG
				print.it("_InvokeDropTarget", dt, _data, w);
				print.it(ex);
#endif
				return 0;
			}
#pragma warning restore CS0168 // Variable is declared but never used
			return effect;
		}
	}
	
	//Drag-drop events.
	public enum DDEvent { Enter, Over, Drop, Leave } //don't change, used in C++
	
	//A window in non-admin process that accepts drag-drop events and relays to the admin process.
	//Covers our admin window. Almost transparent.
	public static class NonAdminProcess {
		static wnd _w; //our transparent window
		static wnd _msgWnd; //message-only IPC window in admin process
		static _DropTarget _dt; //GC
		static bool _enteredOnce;
		
		//Called at startup in non-admin process when command line starts with /dd.
		public static void MainDD(ReadOnlySpan<string> args) {
			process.thisProcessCultureIsInvariant = true;
			
			_msgWnd = (wnd)args[0].ToInt();
			
			WndUtil.RegisterWindowClass("Au.Editor.DD", _WndProc);
			_w = WndUtil.CreateWindow("Au.Editor.DD", null, WS.POPUP | WS.DISABLED, WSE.LAYERED | WSE.NOACTIVATE | WSE.TOOLWINDOW | WSE.TOPMOST);
			Api.SetLayeredWindowAttributes(_w, 0, 1, 2);
			
			Thread.CurrentThread.TrySetApartmentState(ApartmentState.Unknown); //uninit MTA
			Api.OleInitialize(default); //somehow RDD fails if process.ThisThreadSetComApartment_(ApartmentState.STA);
			Api.RegisterDragDrop(_w, _dt = new _DropTarget());
			_msgWnd.Send(Api.WM_USER, 10, (nint)_w);
			Api.SetTimer(_w, 1, 1000, null);
			
			_w.ShowL(true);
			while (Api.GetMessage(out var m)) Api.DispatchMessage(m);
			Api.OleUninitialize();
		}
		
		static nint _WndProc(wnd w, int msg, nint wParam, nint lParam) {
			switch (msg) {
			case Api.WM_DESTROY:
				Api.RevokeDragDrop(w);
				Api.PostQuitMessage(0);
				break;
			case Api.WM_TIMER:
				if (!_msgWnd.IsAlive) _Exit();
				break;
			case Api.WM_USER: //admin posts it when ended drag mode
				_Exit();
				break;
			}
			
			return Api.DefWindowProc(w, msg, wParam, lParam);
		}
		
		static void _Exit() { Api.DestroyWindow(_w); }
		
		class _DropTarget : Api.IDropTarget {
			void Api.IDropTarget.DragEnter(IDataObject d, int grfKeyState, POINT pt, ref int effect) {
				if (_enteredOnce) {
					(this as Api.IDropTarget).DragOver(grfKeyState, pt, ref effect);
					return;
				}
				
				DDData r = default;
				if (_enteredOnce = r.GetData(d)) {
					var b = Serializer_.Serialize(effect, grfKeyState, pt.x, pt.y, r.files, r.shell, r.text, r.linkName);
					effect = (int)WndCopyData.Send<byte>(_msgWnd, 110, b, (int)DDEvent.Enter);
				} else {
					_Exit();
				}
			}
			
			void Api.IDropTarget.DragOver(int grfKeyState, POINT pt, ref int effect) {
				if (!_enteredOnce) { effect = 0; return; }
				var b = Serializer_.Serialize(effect, grfKeyState, pt.x, pt.y);
				effect = (int)WndCopyData.Send<byte>(_msgWnd, 110, b, (int)DDEvent.Over);
			}
			
			void Api.IDropTarget.Drop(IDataObject d, int grfKeyState, POINT pt, ref int effect) {
				if (!_enteredOnce) { effect = 0; return; }
				_Exit();
				var b = Serializer_.Serialize(effect, grfKeyState, pt.x, pt.y);
				effect = (int)WndCopyData.Send<byte>(_msgWnd, 110, b, (int)DDEvent.Drop);
			}
			
			void Api.IDropTarget.DragLeave() {
				if (_enteredOnce) WndCopyData.Send<byte>(_msgWnd, 110, Serializer_.Serialize(), (int)DDEvent.Leave);
			}
		}
	}
	
}

struct DDData {
	public string[] files;
	public byte[] shell, linkName;
	public string text;
	public bool scripts;
	
	public unsafe bool GetData(IDataObject d, bool getFileNodes = false) {
		try {
			FORMATETC fHdrop = default, fShell = default, fText = default, fDesc = default;
			var afe = new FORMATETC[1]; var fe = new int[1];
			var e = d.EnumFormatEtc(DATADIR.DATADIR_GET);
			while (e.Next(1, afe, fe) == 0 && fe[0] == 1) {
				//print.it(ClipFormats.GetName((ushort)afe[0].cfFormat));
				if (afe[0].tymed != TYMED.TYMED_HGLOBAL) continue;
				int cf = (ushort)afe[0].cfFormat;
				if (cf == Api.CF_HDROP) fHdrop = afe[0];
				else if (cf == ClipFormats.ShellIDListArray_) fShell = afe[0];
				else if (cf == Api.CF_UNICODETEXT) fText = afe[0];
				else if (cf == ClipFormats.FileGroupDescriptorW_) fDesc = afe[0];
				else if (getFileNodes && cf >= 0xC000 && ClipFormats.GetName(cf) == "LA.FileNode[]") return scripts = true;
			}
			if (fHdrop.cfFormat != 0) files = _GetFiles(ref fHdrop);
			else if (fShell.cfFormat != 0) shell = _GetBytes(ref fShell);
			else if (fText.cfFormat != 0) {
				text = _GetText(ref fText);
				if (fDesc.cfFormat != 0) linkName = _GetBytes(ref fDesc); //text is URL
			} else return false;
			return true;
			
			byte[] _GetBytes(ref FORMATETC fe) {
				d.GetData(ref fe, out var m);
				int n = (int)Api.GlobalSize(m.unionmember);
				var t = Api.GlobalLock(m.unionmember);
				try { return new Span<byte>((void*)t, n).ToArray(); }
				finally { Api.GlobalUnlock(m.unionmember); Api.ReleaseStgMedium(ref m); }
			}
			
			string _GetText(ref FORMATETC fe) {
				d.GetData(ref fe, out var m);
				var t = (char*)Api.GlobalLock(m.unionmember);
				int n = (int)Api.GlobalSize(m.unionmember) / 2; if (n > 0 && t[--n] != 0) n++;
				try { return new string(t, 0, n); }
				finally { Api.GlobalUnlock(m.unionmember); Api.ReleaseStgMedium(ref m); }
			}
			
			string[] _GetFiles(ref FORMATETC fe) {
				d.GetData(ref fe, out var m);
				try { return clipboardData.HdropToFiles_(m.unionmember); }
				finally { Api.ReleaseStgMedium(ref m); }
			}
		}
		catch (Exception ex) { Debug_.Print(ex); } //info: if from IE, IDataObject.GetData fails for all formats.
		return false;
	}
}


================================================
FILE: Au.Editor/xUtil/Downloader.cs
================================================
using System.Windows.Controls;

namespace LA;

/// <summary>
/// Downloads and extracts a 7z or zip file containing multiple files into a directory. Deletes all old files. Shows progress.
/// Can be used in UI thread.
/// Must be disposed (it deletes a sentinel file if succeeded).
/// To extract uses the LA's installed 7za.exe.
/// </summary>
sealed class Downloader : IDisposable {
	string _dirExtract;
	bool _deleteOldFiles;
	string _sentinel;
	
	/// <summary>
	/// Prepares to extract files in given directory.
	/// </summary>
	/// <param name="dirExtract">Path of directory where to extract files (later). This func creates new empty directory if does not exist; else just detects whether can create files there.</param>
	/// <param name="failedWarningPrefix">Prefix text for <see cref="print.warning"/> to use when fails.</param>
	/// <returns><c>false</c> if can't install in this directory (prints warning).</returns>
	public bool PrepareDirectory(string dirExtract, string failedWarningPrefix = "<>Warning: ") {
		_dirExtract = null;
		_deleteOldFiles = false;
		try {
			if (filesystem.exists(dirExtract, true).Directory) {
				using (File.Create(dirExtract + @"\~", 0, FileOptions.DeleteOnClose)) { } //can create files there?
				_deleteOldFiles = true;
			} else {
				filesystem.createDirectory(dirExtract);
			}
			_dirExtract = dirExtract;
		}
		catch (Exception e1) {
			print.warning(e1, failedWarningPrefix);
			if (!uacInfo.isAdmin) print.it("\tRestart this program as administrator.");
			return false;
		}
		return true;
	}
	
	/// <summary>
	/// Downloads compressed file from given URL and extracts to the directory specified in a call to <see cref="PrepareDirectory"/>. Deletes all old files.
	/// </summary>
	/// <param name="url">Direct download URL. Must end with <c>".zip"</c> or <c>".7z"</c>.</param>
	/// <param name="progress">This func will set text like <c>"Downloading, 20%"</c>. Can be null.</param>
	/// <param name="ct"></param>
	/// <param name="progressText">Progress text. While downloading, this function appends ", N%".</param>
	/// <param name="failedWarningPrefix">Prefix text for <see cref="print.warning"/> to use when fails.</param>
	/// <returns><c>false</c> if failed (prints warning); <c>null</c> if canceled (no warning).</returns>
	public async Task<bool?> DownloadAndExtract(string url, TextBlock progress, CancellationToken ct, string progressText = "Downloading", string failedWarningPrefix = "<>Warning: ") {
		if (_dirExtract is null) throw new InvalidOperationException();
		var ext = pathname.getExtension(url).Lower();
		if (!(ext is ".zip" or ".7z")) throw new NotSupportedException("Bad file type");
		
		try {
			progress?.Visibility = System.Windows.Visibility.Visible;
			using var zip = new TempFile(ext);
			
			progress?.Text = progressText + ". Connecting...";
			var rm = await Task.Run(() => internet.http.Get(url, dontWait: true)); //not GetAsync because it blocks for 7 s on my VMWare Win7
			if (!await rm.DownloadAsync(zip, p => { progress?.Text = $"{progressText}, {p.Percent}%"; }, ct)) return null;
			
			progress?.Text = "Extracting";
			await Task.Run(() => {
				var aDel = _deleteOldFiles ? Directory.GetFileSystemEntries(_dirExtract) : null;
				
				string sentinel = _dirExtract + c_sentinel;
				filesystem.saveText(sentinel, "");
				
				if (_deleteOldFiles) filesystem.delete(aDel);
				
				var sevenzip = folders.ThisAppBS + @"32\7za.exe";
				if (0 != run.console(out var s, sevenzip, $@"x -aoa -o""{_dirExtract}"" ""{zip}""")) throw new AuException($"*extract files. {s}");
				
				_sentinel = sentinel;
			});
		}
		catch (Exception e1) {
			print.warning(e1, failedWarningPrefix);
			return false;
		}
		finally {
			progress?.Text = "";
		}
		return true;
	}
	
	const string c_sentinel = @"\.la-extract-sentinel";
	
	public void Dispose() {
		if (_sentinel != null) filesystem.delete(_sentinel);
	}
	
	/// <summary>
	/// Returns <c>true</c> if <see cref="DownloadAndExtract"/> was killed during the "delete existing files and extract" operation. Ie the directory content is invalid.
	/// </summary>
	/// <param name="dirExtract">The same directory as used with <b>DownloadAndExtract</b>.</param>
	public static bool IsDirectoryInvalid(string dirExtract) => filesystem.exists(dirExtract + c_sentinel, true);
}


================================================
FILE: Au.Editor/xUtil/Ed util shared.cs
================================================
//This file also can be used in scripts (meta c).

using System.Security.Cryptography;

namespace LA;

/// <summary>
/// Gets paths of LA folders, regardless whether this code runs in LA or in a script, even when launched not by LA.
/// In script must be defined SCRIPT.
/// </summary>
static class folders2 {
	/// <summary>
	/// ThisApp
	/// </summary>
	public static FolderPath La
#if SCRIPT
		=> new(Environment.GetEnvironmentVariable("au_") ?? throw null);
#else
		=> folders.ThisApp;
#endif
	
	/// <summary>
	/// ThisAppDataLocal
	/// </summary>
	public static FolderPath LaDataLocal
#if SCRIPT
		=> new(folders.LocalAppData + @"LibreAutomate");
#else
		=> folders.ThisAppDataLocal;
#endif
	
	/// <summary>
	/// ThisAppDataRoaming
	/// </summary>
	public static FolderPath LaDataRoaming
#if SCRIPT
		=> new(folders.RoamingAppData + @"LibreAutomate");
#else
		=> folders.ThisAppDataRoaming;
#endif
}

/// <summary>
/// Calls <see cref="ProtectedData"/> <c>Protect</c> or <c>Unprotect</c> with LA's entropy.
/// </summary>
static class EdProtectedData {
	static byte[] _entropy = [212, 71, 168, 115, 1, 83, 144, 90];
	
	/// <returns>Protected data as Base64 string. On exception prints warning and returns <c>null</c>.</returns>
	public static string Protect(string s) {
		try { return Convert.ToBase64String(ProtectedData.Protect(s.ToUTF8(), _entropy, DataProtectionScope.CurrentUser)); }
		catch (Exception ex) { print.warning(ex); return null; }
	}
	
	/// <returns>Unprotected data as string. On exception prints warning and returns <c>null</c>.</returns>
	public static string Unprotect(string s) {
		try { return ProtectedData.Unprotect(Convert.FromBase64String(s), _entropy, DataProtectionScope.CurrentUser).ToStringUTF8(); }
		catch (Exception ex) { print.warning(ex); return null; }
	}
}

/// <summary>
/// Compresses and extracts files using the LA's installed 7za.exe.
/// </summary>
static class SevenZip {
	static string _Sevenzip => folders2.La + @"32\7za.exe";
	
	/// <summary>
	/// Compresses a file or directory.
	/// </summary>
	/// <param name="output">7za.exe output text.</param>
	/// <param name="zipFile">The compressed file to create. If exists, deletes at first; else creates directory for it if need.</param>
	/// <param name="fileOrDir">File, directory or wildcard. Full path or path in the current directory. If directory like <c>@"dir\*"</c>, adds its contents to the root.</param>
	/// <param name="curDir">Current directory path to pass to 7za.exe.</param>
	/// <param name="type7z">Create 7z archive regardless of <i>zipFile</i> filename extension.</param>
	/// <param name="switches">Optional 7za.exe command line switches/arguments.</param>
	/// <returns>false if returned an error code.</returns>
	/// <exception cref="Exception">Exceptions of used functions. Unlikely.</exception>
	public static bool Compress(out string output, string zipFile, string fileOrDir, string curDir = null, bool type7z = false, string switches = null) {
		if (filesystem.exists(zipFile)) filesystem.delete(zipFile); else filesystem.createDirectoryFor(zipFile);
		return 0 == run.console(out output, _Sevenzip, $@"a ""{zipFile}"" ""{fileOrDir}"" {(type7z ? "-t7z " : "")}{switches}", curDir);
	}
	
	/// <summary>
	/// Compresses a multiple files/directories.
	/// </summary>
	/// <param name="output">7za.exe output text.</param>
	/// <param name="zipFile">The compressed file to create. If exists, deletes at first; else creates directory for it if need.</param>
	/// <param name="files">List of files/directories/wildcards. Full paths or paths in <i>inDir</i>. If a directory is like <c>@"dir\*"</c>, adds its contents to the root.</param>
	/// <param name="curDir">Current directory path to pass to 7za.exe. It will be the base directory of non-full-path files specified in <i>files</i>.</param>
	/// <param name="type7z">Create 7z archive regardless of <i>zipFile</i> filename extension.</param>
	/// <param name="switches">Optional 7za.exe command line switches/arguments.</param>
	/// <returns>false if returned an error code.</returns>
	/// <exception cref="Exception">Exceptions of used functions. Unlikely.</exception>
	public static bool Compress(out string output, string zipFile, IEnumerable<string> files, string curDir = null, bool type7z = false, string switches = null) {
		if (filesystem.exists(zipFile)) filesystem.delete(zipFile); else filesystem.createDirectoryFor(zipFile);
		using var tf = new TempFile();
		filesystem.saveText(tf, string.Join("\n", files));
		return 0 == run.console(out output, _Sevenzip, $@"a ""{zipFile}"" @""{tf}"" {(type7z ? "-t7z " : "")}{switches}", curDir);
	}
	
	/// <summary>
	/// Extracts a compressed file to a directory.
	/// </summary>
	/// <param name="output">7za.exe output text.</param>
	/// <param name="zipFile">The compressed file.</param>
	/// <param name="outDir">The directory where to extract. If does not exist, creates; else does not delete files before extracting.</param>
	/// <param name="switches">Optional 7za.exe command line switches/arguments. The default "-aoa" means overwrite all existing files without prompt.</param>
	/// <returns>false if returned an error code.</returns>
	public static bool Extract(out string output, string zipFile, string outDir, string switches = "-aoa") {
		return 0 == run.console(out output, _Sevenzip, $@"x ""{zipFile}"" -o""{outDir}"" {switches}");
	}
}


================================================
FILE: Au.Editor/xUtil/Ed util.cs
================================================
using Microsoft.Win32;
using System.Windows.Controls;
using System.Windows;
using System.Collections;
using System.IO.Compression;
using System.Runtime.Loader;
using System.Security.Cryptography;

namespace LA;

/// <summary>
/// .NET SDK etc.
/// </summary>
static class DotnetUtil {
	static DotnetUtil() {
		Environment.SetEnvironmentVariable("DOTNET_CLI_TELEMETRY_OPTOUT", "1");
	}
	
	/// <summary>
	/// Call this when showing a window that uses .NET SDK.
	/// If SDK missing (full or minimal, depending on <see cref="AppSettings.minimalSDK"/>), disables specified UI elements and adds an install link at the top.
	/// </summary>
	/// <param name="installedNow">Called later when SDK is installed if was missing. Called only if then <c>w.IsLoaded</c>.</param>
	/// <returns>true if missing.</returns>
	public static bool MissingSdkUI(Window w, FrameworkElement[] disable, Action installedNow = null) {
		if (InitSdk()) return false;
		
		var content = w.Content as UIElement;
		w.Content = null;
		if (w.Width < 400) w.Width = 400;
		_DisableEnableAll(enable: false);
		var panel = new DockPanel();
		
		TextBlock t = new() { Height = 18, Margin = new(5) };
		if (App.Settings.minimalSDK == false) wpfBuilder.formatTextOf(t, $"Missing .NET SDK. See <b>Options > Other > Use minimal .NET SDK</b>.");
		else wpfBuilder.formatTextOf(t, $"<b><a {_InstallMinimalSdk}>Download required components</a></b> to use this feature (~30 MB)");
		
		UIElement[] a = [t, new Separator(), content];
		foreach (var e in a) {
			if (e != content) DockPanel.SetDock(e, Dock.Top);
			panel.Children.Add(e);
		}
		w.Content = panel;
		
		return true;
		
		async void _InstallMinimalSdk() {
			if (!await EnsureSdkAsync(t)) return;
			_DisableEnableAll(enable: true);
			panel.Children.Remove(content);
			w.Content = content;
			if (installedNow is { } k && w.IsLoaded) k();
		}
		void _DisableEnableAll(bool enable) { foreach (var v in disable) v.IsEnabled = enable; }
	}
	
	/// <summary>
	/// Ensures that the full or minimal .NET SDK is installed, depending on <see cref="AppSettings.minimalSDK"/>.
	/// If not installed, downloads/installs the minimal SDK (without confirmation, just displays progress).
	/// In any case sets <see cref="DotnetExe"/> and <see cref="SdkDir"/>.
	/// Not thread-safe. Call in main thread.
	/// </summary>
	/// <param name="progress">This func will set text like <c>"Downloading minimal SDK, 20%"</c>. Also uses it to cancel when the window closed.</param>
	/// <returns>false if failed to install or canceled.</returns>
	public static async Task<bool> EnsureSdkAsync(TextBlock progress) {
		if (_InitSdk(out bool installMiniSdk)) return true;
		if (!installMiniSdk) return false;
		if (!await _InstallMinimalSDK(progress)) return false;
		return _InitSdk(out _, true);
		
		static async Task<bool> _InstallMinimalSDK(TextBlock progress) {
			var window = Window.GetWindow(progress);
			
			string filename = $"sdk-{Environment.Version.ToString(2)}-{(osVersion.isArm64OS ? "arm64" : "x64")}.zip";
			string url = $"https://www.libreautomate.com/download/sdk/{filename}";
			string dotnetDir = folders.ThisAppBS + "SDK";
			using var dl = new Downloader();
			if (!dl.PrepareDirectory(dotnetDir, failedWarningPrefix: c_errorInstallMinimalSDK)) return false;
			
			CancellationTokenSource cts = new();
			progress.Unloaded += (_, _) => { cts?.Cancel(); };
			bool? ok = await dl.DownloadAndExtract(url, progress, cts.Token, progressText: "Downloading required components", failedWarningPrefix: c_errorInstallMinimalSDK.Replace("to install", "to download"));
			cts = null;
			return ok == true;
		}
		
		//note: the minimal SDK the first time installs 3 extra packages (16 MB download). The normal SDK doesn't.
		//	It's OK. It's because the minimal SDK doesn't have the `packs` folder. Auto-downloads what's missing.
		//	Also creates empty dir `metadata` in the minimal SDK dir.
	}
	
	/// <summary>
	/// Returns <c>true</c> if the full or minimal .NET SDK is installed (depending on <see cref="AppSettings.minimalSDK"/>).
	/// Sets <see cref="DotnetExe"/> and <see cref="SdkDir"/> (null if returns <c>false</c>).
	/// Not thread-safe. Call in main thread.
	/// </summary>
	public static bool InitSdk() => _InitSdk(out _);
	
	static bool _InitSdk(out bool installMiniSdk, bool afterInstall = false) {
		installMiniSdk = false;
		
		if (!afterInstall) {
			Debug_.PrintIf(!App.IsMainThread);
			if (App.IsPortable) {
				if (_IsFullSdkInstalled()) return true;
				print.warning("This feature in portable mode requires the .NET SDK.", 1);
				return false;
			}
			if (App.Settings.minimalSDK != true) {
				if (_IsFullSdkInstalled()) return true;
				if (App.Settings.minimalSDK == false) {
					(DotnetExe, SdkDir) = (null, null);
					print.warning("This feature requires the .NET SDK. Install it or don't uncheck Options > Other > Use minimal SDK.", 1);
					Debug_.Print(new StackTrace(true));
					return false;
				}
			}
		}
		
		if (s_minimalSdkDir is null) {
			string dotnetDir = folders.ThisAppBS + @"SDK", sdkDir = dotnetDir + @"\sdk", sdkVerDir = null;
			if (filesystem.exists(sdkDir, true).Directory && !Downloader.IsDirectoryInvalid(dotnetDir)) {
				sdkVerDir = Directory.EnumerateDirectories(sdkDir, Environment.Version.ToString(2) + ".*").FirstOrDefault();
			}
			if (sdkVerDir is null) {
				installMiniSdk = true;
			} else {
				if (sdkVerDir != null && !(_EnsureLink("host") && _EnsureLink("shared"))) sdkVerDir = null; //not just when installing, because the folder may be copied and the links lost
				
				if (sdkVerDir != null) (s_minimalDotnetExe, s_minimalSdkDir) = (dotnetDir + @"\dotnet.exe", sdkVerDir);
			}
		}
		
		DotnetExe = s_minimalDotnetExe;
		SdkDir = s_minimalSdkDir;
		return s_minimalSdkDir != null;
		
		static bool _IsFullSdkInstalled() {
			if (!s_fullSdkDirOnce) {
				if (filesystem.searchPath("dotnet.exe") is string dotnetExe) {
					try {
						if (0 == run.console(out string v, dotnetExe, "--version", curDir: folders.ThisApp)) { //fast. Use `curDir: folders.ThisApp` because it searches for global.json (and SDK version in it) in this and ancestor dirs.
							var dir = pathname.getDirectory(dotnetExe) + @"\sdk\" + v.Trim();
							if (filesystem.exists(dir, true).Directory) (s_fullDotnetExe, s_fullSdkDir) = (dotnetExe, dir);
							Debug_.PrintIf(s_fullSdkDir is null, dir);
						}
					}
					catch { }
				}
				s_fullSdkDirOnce = true;
			}
			DotnetExe = s_fullDotnetExe;
			SdkDir = s_fullSdkDir;
			return s_fullSdkDir != null;
		}
		
		static bool _EnsureLink(string name) {
			var link = folders.ThisAppBS + @"SDK\" + name;
			if (!filesystem.exists(link, true).IsNtfsLink) {
				var fullDotnetDir = folders.NetRuntime.Path.RxReplace(@"(\\[^\\]+){3}$", "", 1);
				try { filesystem.more.createSymbolicLink(link, fullDotnetDir + @"\" + name, CSLink.Junction, deleteOld: true); }
				catch (Exception ex) { print.warning(ex, c_errorInstallMinimalSDK); return false; }
			}
			return true;
		}
		
		//note: the minimal SDK the first time installs 3 extra packages (16 MB download). The normal SDK doesn't.
		//	It's OK. It's because the minimal SDK doesn't have the `packs` folder. Auto-downloads what's missing.
		//	Also creates empty dir `metadata` in the minimal SDK dir.
	}
	static string s_minimalDotnetExe, s_fullDotnetExe, s_minimalSdkDir, s_fullSdkDir;
	static bool s_fullSdkDirOnce;
	const string c_errorInstallMinimalSDK = "<>Failed to install required component (minimal .NET SDK). You can retry, or manually install the full .NET 10 SDK (~200 MB download). See also Options > Other > Use minimal SDK. Issues: https://github.com/qgindi/LibreAutomate/issues.";
	
	/// <summary>
	/// Path of "dotnet.exe" set by <see cref="EnsureSdkAsync"/>. Full or minimal SDK.
	/// </summary>
	public static string DotnetExe { get; private set; }
	
	/// <summary>
	/// Path of the SDK directory with dlls, set by <see cref="EnsureSdkAsync"/>. Full or minimal SDK.
	/// </summary>
	public static string SdkDir { get; private set; }
	
	/// <summary>
	/// Downloads and extracts both .NET runtimes (core and desktop) for CPU architecture x64/ARM64 other than of this process.
	/// Run in a background thread.
	/// </summary>
	/// <param name="extractDir">Extract both to this directory.</param>
	/// <param name="portable">Extract to <i>dir</i> subdirectory <c>"dotnet"</c> (if x64) or <c>"dotnetARM"</c> (if ARM64). Delete old subdirectory.</param>
	/// <exception cref="OperationCanceledException">User-canceled.</exception>
	/// <exception cref="Exception">Failed.</exception>
	public static void DownloadNetRuntimesForOtherArch(string extractDir, bool portable) {
		bool forArm = !osVersion.isArm64Process;
		
		if (portable) {
			extractDir = extractDir + "\\dotnet" + (forArm ? "ARM" : null);
			filesystem.delete(extractDir);
			filesystem.createDirectory(extractDir);
		}
		
		string arch = forArm ? "arm64" : "x64";
		string version = Environment.Version.ToString();
		
		_ClearOld();
		_DownloadAndExtract(false);
		_DownloadAndExtract(true);
		
		void _DownloadAndExtract(bool desktop) {
			//"https://builds.dotnet.microsoft.com/dotnet/Runtime/9.0.6/dotnet-runtime-9.0.6-win-arm64.zip"
			//"https://builds.dotnet.microsoft.com/dotnet/WindowsDesktop/9.0.6/windowsdesktop-runtime-9.0.6-win-arm64.zip"
			var filename = $"{(desktop ? "windowsdesktop" : "dotnet")}-runtime-{version}-win-{arch}.zip";
			var zip = $@"{folders.ThisAppTemp}\download\{filename}";
			if (!filesystem.exists(zip)) {
				print.it("Downloading " + filename);
				var url = $"https://builds.dotnet.microsoft.com/dotnet/{(desktop ? "WindowsDesktop" : "Runtime")}/{version}/{filename}";
				var r = internet.http.Get(url, dontWait: true);
				if (!r.Download(zip + "~")) throw new OperationCanceledException();
				filesystem.rename(zip + "~", filename);
			}
			
			print.it("Extracting " + filename);
			var starts = $"shared/Microsoft.{(desktop ? "WindowsDesktop" : "NETCore")}.App/{version}/";
			using var z = ZipFile.OpenRead(zip);
			foreach (var e in z.Entries) {
				var relPath = e.FullName;
				if (!relPath.Starts(starts, true)) continue;
				relPath = relPath[starts.Length..];
				var s = extractDir + "\\" + relPath;
				if (relPath.Contains('/')) filesystem.createDirectoryFor(s);
				e.ExtractToFile(s, overwrite: true);
			}
		}
		
		void _ClearOld() {
			try {
				var rx = new regexp(@"(?i)^(?:dotnet|windowsdesktop)-runtime-(.+?)-.+\.zip$");
				foreach (var f in filesystem.enumFiles(folders.ThisAppTemp + "download")) {
					if (!rx.Match(f.Name, out var m)) continue;
					if (m[1].Value.Eqi(version)) continue;
					Api.DeleteFile(f.FullPath);
				}
			}
			catch { }
		}
	}
}

/// <summary>
/// Can be used to return bool and error text. Has implicit conversions from/to bool.
/// </summary>
record struct BoolError(bool ok, string error) {
	public static implicit operator bool(BoolError x) => x.ok;
	public static implicit operator BoolError(bool ok) => new(ok, ok ? null : "Failed.");
}

#if DEBUG

static class EdDebug {
}

#endif

static class EdWpf {
	public static TextBlock TextAndHelp(string text, string helpTopic) {
		var img = ImageUtil.LoadWpfImageElement("*Entypo.HelpWithCircle #008EEE @14");
		var s1 = text.NE() ? "" : "  ";
		return wpfBuilder.formattedText($"{text}{s1}<a {() => HelpUtil.AuHelp(helpTopic)}>{img}</a>");
	}
	
	public static TextBlock TextAndHelp<T>(string text) => TextAndHelp(text, typeof(T).ToString());
	
	public static TextBlock TextAndHelp(string text, Func<string> helpTopic) {
		var img = ImageUtil.LoadWpfImageElement("*Entypo.HelpWithCircle #008EEE @14");
		var s1 = text.NE() ? "" : "  ";
		return wpfBuilder.formattedText($"{text}{s1}<a {() => HelpUtil.AuHelp(helpTopic())}>{img}</a>");
	}
}

/// <summary>
/// Opens databases ref.db, doc.db (created by project DatabasesEtc) or winapi.db (created by script "SDK create database").
/// </summary>
static class EdDatabases {
	public static sqlite OpenRef() => _Open("ref.db");
	
	public static sqlite OpenDoc() => _Open("doc.db");
	
	public static sqlite OpenWinapi() => _Open("winapi.db");
	
	static sqlite _Open(string name) {
		var path = folders.ThisAppBS + name;
		//if (App.IsAuHomePC) { //no. Instead exit editor before running DatabasesEtc project. And it does not lock winapi.db.
		//	var pathNew = path + ".new";
		//	if (filesystem.exists(pathNew)) filesystem.move(pathNew, path, FIfExists.Delete);
		//}
		return new sqlite(path, SLFlags.SQLITE_OPEN_READONLY);
	}
	
	public static string WinapiFile => folders.ThisAppBS + "winapi.db";
}

/// <summary>
/// Temporarily disables window redrawing.
/// Ctor sends WM_SETREDRAW(0) if visible.
/// If was visible, Dispose sends WM_SETREDRAW(1) and calls RedrawWindow.
/// </summary>
struct WndSetRedraw : IDisposable {
	wnd _w;
	
	public WndSetRedraw(wnd w) {
		_w = w;
		if (_w.IsVisible) _w.Send(Api.WM_SETREDRAW, 0); else _w = default;
	}
	
	public unsafe void Dispose() {
		if (_w.Is0) return;
		_w.Send(Api.WM_SETREDRAW, 1);
		Api.RedrawWindow(_w, flags: Api.RDW_ERASE | Api.RDW_FRAME | Api.RDW_INVALIDATE | Api.RDW_ALLCHILDREN);
		_w = default;
	}
}

record struct StartEndText(int start, int end, string text) {
	public int Length => end - start;
	public Range Range => start..end;
	
	/// <inheritdoc cref="ReplaceAll(string, List{StartEndText}, ref StringBuilder)"/>
	public static string ReplaceAll(string s, List<StartEndText> a) {
		StringBuilder b = null;
		ReplaceAll(s, a, ref b);
		return b.ToString();
	}
	
	/// <summary>
	/// Replaces all text ranges specified in <i>a</i> with strings specified in <i>a</i>.
	/// </summary>
	/// <param name="a">Text ranges and replacement texts. Must be sorted by range. Ranges must not overlap.</param>
	/// <param name="b">Receives new text. If null, the function creates new, else at first calls <c>b.Clear()</c>.</param>
	/// <exception cref="ArgumentException">Ranges are overlapped or not sorted. Only #if DEBUG.</exception>
	public static void ReplaceAll(string s, List<StartEndText> a, ref StringBuilder b) {
		ThrowIfNotSorted(a);
		int cap = s.Length - a.Sum(o => o.Length) + a.Sum(o => o.text.Length);
		if (b == null) b = new(cap);
		else {
			b.Clear();
			b.EnsureCapacity(cap);
		}
		
		int i = 0;
		foreach (var v in a) {
			b.Append(s, i, v.start - i).Append(v.text);
			i = v.end;
		}
		b.Append(s, i, s.Length - i);
	}
	
	/// <exception cref="ArgumentException">Ranges are overlapped or not sorted. [Conditional("DEBUG")].</exception>
	[Conditional("DEBUG")]
	internal static void ThrowIfNotSorted(List<StartEndText> a) {
		for (int i = 1; i < a.Count; i++) if (a[i].start < a[i - 1].end) throw new ArgumentException("ranges must be sorted and not overlapped");
	}
}

static class EdComUtil {
	
	//To convert a COM type library we use TypeLibConverter class. However .NET Core+ does not have it.
	//Workaround: the code is in Au.Net4.exe. It uses .NET Framework 4.x. We call it through run.console.
	//We don't use tlbimp.exe:
	//	1. If some used interop assemblies are in GAC (eg MS Office PIA), does not create files for them. But we cannot use GAC in a Core+ app.
	//	2. Does not tell what files created.
	//	3. My PC somehow has MS Office PIA installed and there is no uninstaller. After deleting the GAC files tlbimp.exe created all files, but it took several minutes.
	//Tested: impossible to convert .NET Framework TypeLibConverter code. Part of it is in extern methods.
	//Tested: cannot use .NET Framework dll for it. Fails at run time because uses Core+ assemblies, and they don't have the class. Need exe.
	public static async Task<List<string>> ConvertTypeLibrary(object tlDef, Window owner) {
		string comDll = null;
		switch (tlDef) {
		case string path:
			comDll = path;
			break;
		case RegTypelib r:
			//can be several locales
			var aloc = new List<string>(); //registry keys like "0" or "409"
			var aloc2 = new List<string>(); //locale names for display in the list dialog
			using (var verKey = Registry.ClassesRoot.OpenSubKey($@"TypeLib\{r.guid}\{r.version}")) {
				foreach (var s1 in verKey.GetSubKeyNames()) {
					int lcid = s1.ToInt(0, out int iEnd, STIFlags.IsHexWithout0x);
					if (iEnd != s1.Length) continue; //"FLAGS" etc; must be hex number without 0x
					aloc.Add(s1);
					var s2 = "Neutral";
					if (lcid > 0) {
						try { s2 = new System.Globalization.CultureInfo(lcid).DisplayName; } catch { s2 = s1; }
					}
					aloc2.Add(s2);
				}
			}
			string locale;
			if (aloc.Count == 1) locale = aloc[0];
			else {
				int i = dialog.showList(aloc2, "COM type library locale", owner: owner);
				if (i == 0) return null;
				locale = aloc[i - 1];
			}
			comDll = r.GetPath(locale);
			if (comDll == null /*|| !filesystem.exists(comDll).File*/) { //can be "filepath/resource"
				print.it("Failed to get file path.");
				return null;
			}
			break;
		}
		
		print.it("<><lc YellowGreen>Converting COM type library to .NET assembly.<>");
		List<string> converted = [];
		int rr = -1;
		owner.IsEnabled = false;
		try {
			await Task.Run(() => {
				var dir = folders.Workspace + @".interop\";
				filesystem.createDirectory(dir);
				void _Callback(string s) {
					//skip some useless warnings, eg "can't convert some internal type"
					bool mute = s.RxIsMatch(@"Warning: .+ (?:could not convert the signature for the member '(?:\w*_|tag|[A-Z]+\.)|as a pointer and may require unsafe code to manipulate.|to import this property as a method instead.)");
					if (!mute) print.it(s);
					if (s.Starts("<>Converted: ")) {
						s.RxMatch(@"<explore .+?>(.+?)<>$", 1, out s);
						converted.Add(s);
					}
				}
				rr = run.console(_Callback, folders.ThisAppBS + "Au.Net4.exe", $"/typelib \"{dir}|{comDll}\"");
			});
		}
		catch (Exception ex) { print.it("Failed to convert type library", ex.ToStringWithoutStack()); }
		owner.IsEnabled = true;
		if (rr != 0) return null;
		print.it("==== DONE ====");
		return converted;
	}
	
	public record class RegTypelib(string text, string guid, string version) {
		public override string ToString() => text;
		
		public string GetPath(string locale) {
			var k0 = $@"TypeLib\{guid}\{version}\{locale}\win";
			for (int i = 0; i < 2; i++) {
				var bits = osVersion.is32BitProcess == (i == 1) ? "32" : "64";
				using var hk = Registry.ClassesRoot.OpenSubKey(k0 + bits);
				if (hk?.GetValue("") is string path) return path.Trim('"');
			}
			return null;
		}
	}
	
}

/// <summary>
/// Gets relative path from full path when recursively enumerating a directory. Optionally with a prefix. Almost no garbage.
/// </summary>
class RelativePath {
	char[] _a;
	int _fullPathBaseLen;
	string _prefix;
	
	public RelativePath(string prefix) {
		_prefix = prefix ?? "";
		_a = new char[_prefix.Length + 300];
		prefix.CopyTo(_a);
	}
	
	public RStr GetRelativePath(string fullPath) {
		if (_fullPathBaseLen == 0) _fullPathBaseLen = fullPath.LastIndexOf('\\');
		int len1 = fullPath.Length - _fullPathBaseLen, len2 = len1 + _prefix.Length;
		if (_a.Length < len2) Array.Resize(ref _a, len2 + 300);
		fullPath.CopyTo(_fullPathBaseLen, _a, _prefix.Length, len1);
		return _a.AsSpan(0, len2);
	}
}

/// <summary>
/// Wildcard-compares paths with a list of strings.
/// </summary>
class WildcardList {
	readonly string[] _a;
	
	/// <summary>
	/// Creates a list of strings from a multiline string.
	/// </summary>
	/// <param name="list">Multiline string. Use <c>//</c> to comment out a line.</param>
	/// <param name="replaceSlash">Replace <c>'/'</c> with <c>'\\'</c> (to match file paths).</param>
	/// <param name="matchWithoutBackslashAt0">Let `\folder` match `folder`; and let `*\folder` match both `folder` and `ancestors\folder`.</param>
	public WildcardList(string list, bool replaceSlash = true, bool matchWithoutBackslashAt0 = false) {
		if (list.NE()) {
			_a = [];
		} else {
			List<string> a = [];
			foreach (var s_ in list.Lines(noEmpty: true)) {
				string s = s_;
				if (s.Starts("//")) continue;
				if (replaceSlash) s = s.Replace('/', '\\');
				if (s.FindNot(replaceSlash ? @"*\" : "*") < 0) continue; //wildcard like "*" or "\*" or "\" etc makes no sense. Either matches always or never. Prevent accidentally excluding all files etc.
				if (matchWithoutBackslashAt0 && (s[0] == '\\' || s.Starts(@"*\"))) {
					if (s[0] == '\\') { //`\folder`: match `folder`
						a.Add(s[1..]);
					} else { //`*\folder`: match both `folder` and `ancestors\folder`
						a.Add(s[2..]);
						a.Add(s);
					}
				} else {
					a.Add(s);
				}
			}
			_a = a.ToArray();
		}
	}
	
	/// <summary>
	/// Sets <c>ListOfStrings = list</c>.
	/// </summary>
	public WildcardList(string[] list) {
		_a = list;
	}
	
	/// <summary>
	/// Wildcard-compares <i>s</i> with the list of wildcard strings.
	/// </summary>
	/// <returns>true if a <i>s</i> matches a wildcard string.</returns>
	public bool IsMatch(RStr s, bool ignoreCase) {
		foreach (var v in _a) if (s.Like(v, ignoreCase)) return true;
		return false;
	}
	
	public string[] ListOfStrings => _a;
}

/// <summary>
/// Disables/reenables a <b>Window</b>. Supports nested disabling (uses reference counting).
/// Example:
/// <c>WindowDisabler _disabler;
/// ...
/// _disabler = new(this);
/// ...
/// using var _ = _disabler.Disable();</c>
/// </summary>
class WindowDisabler {
	readonly Window _window;
	int _count;
	
	public WindowDisabler(Window window) => _window = window;
	
	public IDisposable Disable() {
		if (_count++ == 0) _window.IsEnabled = false;
		return new ReenableDisposable(this);
	}
	
	class ReenableDisposable : IDisposable {
		readonly WindowDisabler _d;
		bool _disposed;
		
		public ReenableDisposable(WindowDisabler d) => _d = d;
		
		public void Dispose() {
			if (_disposed) return;
			_disposed = true;
			if (--_d._count == 0)
				_d._window.IsEnabled = true;
		}
	}
}


================================================
FILE: Au.Editor/xUtil/EdExt.cs
================================================
using System.Windows;
using System.Windows.Controls;
using Au.Controls;

namespace LA;

/// <summary>
/// Misc extension methods.
/// </summary>
static class EdExt {
	/// <summary>
	/// Returns true if this starts with <i>s</i> and then follows '\\' or '/'.
	/// Case-insensitive.
	/// </summary>
	/// <param name="orEquals">Also return true if this equals <i>s</i>.</param>
	public static bool PathStarts(this string t, RStr s, bool orEquals = false) {
		if (!t.Starts(s, true)) return false;
		if (t.Length > s.Length) return t[s.Length] is '\\' or '/';
		return orEquals;
	}
	
	/// <summary>
	/// Appends hex like "1A".
	/// Like <c>t.Append(x.ToString("X"))</c> or <c>t.AppendFormat(...)</c>, but faster and no garbage.
	/// </summary>
	public static StringBuilder AppendHex(this StringBuilder t, uint x) {
		if (x == 0) {
			t.Append('0');
		} else {
			Span<char> p = stackalloc char[8];
			int i = 8;
			for (; x != 0; x >>= 4) {
				uint h = x & 15;
				p[--i] = (char)(h + (h < 10 ? 48 : 55));
			}
			t.Append(p[i..]);
		}
		return t;
	}
	
	/// <inheritdoc cref="AppendHex(StringBuilder, uint)"/>
	public static StringBuilder AppendHex(this StringBuilder t, int x) => AppendHex(t, (uint)x);
	
	/// <summary>
	/// Inserts <i>e</i> as menu item.
	/// If <i>e</i> is null, creates and inserts separator.
	/// </summary>
	/// <inheritdoc cref="InsertCustom(MenuItem, int, string, RoutedEventHandler, bool)"/>
	public static void InsertCustom(this MenuItem t, int i, FrameworkElement e = null) {
		e ??= new Separator();
		e.Tag = e;
		if (i < 0) t.Items.Add(e); else t.Items.Insert(i, e);
	}
	
	/// <summary>
	/// Creates and inserts menu item.
	/// </summary>
	/// <param name="i">Insert at this index. If -1, adds at the end.</param>
	/// <param name="text">Item text.</param>
	/// <param name="click"><b>Click</b> event handler or null.</param>
	/// <param name="escapeUnderscore">Replace all "_" with "__".</param>
	/// <remarks>
	/// Sets <b>Tag</b> so that <see cref="RemoveAllCustom"/> will recognize items added by this function.
	/// </remarks>
	public static MenuItem InsertCustom(this MenuItem t, int i, string text, RoutedEventHandler click, bool escapeUnderscore = true) {
		if (escapeUnderscore) text = text.Replace("_", "__");
		var mi = new MenuItem { Header = text };
		if (click != null) mi.Click += click;
		InsertCustom(t, i, mi);
		return mi;
	}
	
	/// <param name="click"><b>Click</b> event handler or null. Receives unescaped <i>text</i>.</param>
	/// <inheritdoc cref="InsertCustom(MenuItem, int, string, RoutedEventHandler, bool)"/>
	public static MenuItem InsertCustom(this MenuItem t, int i, string text, Action<string> click, bool escapeUnderscore = true)
		=> InsertCustom(t, i, text, (o, _) => click(text), escapeUnderscore);
	
	/// <summary>
	/// Removes all menu items inserted by <see cref="InsertCustom"/>.
	/// </summary>
	/// <param name="t"></param>
	public static void RemoveAllCustom(this MenuItem t) {
		for (int j = t.Items.Count; --j >= 0;) if (t.Items[j] is FrameworkElement e && e.Tag == e) t.Items.RemoveAt(j);
	}
	
	/// <summary>
	/// Shows window of type T and ensures that there is single window of that type for this <b>FileNode</b> at a time. 
	/// If a window of type T for this <b>FileNode</b> already exists (created with this function), activates it. Else calls <i>fNew</i> and <b>Show</b>. Auto-closes that window when unloading this workspace.
	/// Example: <c>f.SingleDialog(() => new DThisClass());</c>
	/// </summary>
	/// <param name="f">Can be null.</param>
	/// <param name="fNew">Called to create new T if there is no T window.</param>
	/// <returns>The window (new or existing), or null if <i>f</i> null.</returns>
	public static T SingleDialog<T>(this FileNode f, Func<T> fNew) where T : KDialogWindow {
		if (f == null) return null;
		var v = s_singleDialog.FirstOrDefault(o => o.f == f && o.d is T);
		if (v.f != null) {
			v.d.Hwnd().ActivateL(true);
			return v.d as T;
		} else {
			var d = fNew();
			s_singleDialog.Add((f, d));
			
			App.Model.UnloadingThisWorkspace += d.Close;
			d.Closed += (_, _) => {
				App.Model.UnloadingThisWorkspace -= d.Close;
				s_singleDialog.Remove((f, d));
			};
			
			d.Show();
			return d;
		}
	}
	static List<(FileNode f, KDialogWindow d)> s_singleDialog = new();
}


================================================
FILE: Au.Editor/xUtil/EdIcons.cs
================================================
namespace LA;

static class EdIcons {
	public const string
		Script = "*Material.ScriptOutline #73BF00|#87E100",
		//Script = "*Material.Square white %4,1,4,1,f;*Material.ScriptOutline #73BF00|#87E100", //white-filled. In some places looks not good.
		Class = "*Codicons.SymbolClass #4080FF|#84ACFF",
		Folder = "*Material.Folder" + darkYellow,
		FolderOpen = "*Material.FolderOpen" + darkYellow,
		Back = "*EvaIcons.ArrowBack" + black,
		Trigger = "*Codicons.SymbolEvent" + blue,
		Icons = "*FontAwesome.IconsSolid" + blue,
		Keys = "*Material.KeyboardOutline" + blue,
		Color = "*MaterialDesign.ColorLens" + blue,
		Undo = "*Ionicons.UndoiOS" + brown,
		Paste = "*Material.ContentPaste" + brown,
		References = "*Material.MapMarkerMultiple" + blue,
		Regex = "*FileIcons.Regex @12" + blue,
		Help = "*Lucide.CircleHelp" + darkYellow,
		AiSearch = $"*FontAwesome.SearchSolid %,7,7,-1{blue}; *RemixIcon.GeminiFill %4,-1,-1,4{blue}"
		;
	
	public const string
		black = " #505050|#EEEEEE",
		blue = " #4080FF|#99CCFF",
		//darkBlue = " #5060FF|#7080FF",
		//lightBlue = " #B0C0FF|#D0E0FF",
		green = " #99BF00|#A7D000",
		green2 = " #40B000|#4FD200",
		brown = " #9F5300|#EEEEEE",
		purple = " #A040FF|#D595FF",
		darkYellow = " #EABB00",
		orange = " #FFA500",
		red = " #FF4040|#FF9595"
		;
	
	public static string FolderIcon(bool open) => open ? FolderOpen : Folder;
	
	public static string FolderArrow(bool open) => open ? "*Material.ChevronDown @9 #404040" : "*Material.ChevronRight @9 #404040";
}


================================================
FILE: Au.Editor/xUtil/Libs/DiffMatchPatch.cs
================================================
/*
 * Diff Match and Patch
 * Copyright 2018 The diff-match-patch Authors.
 * https://github.com/google/diff-match-patch
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

//Au:
//	Removed System.Web dependency. Now delta escaping is C#-style, not URL.
//	Removed System.Linq dependency.
//	Replaced DateTime.Now with GetTickCount.
//	Some other small changes.

#pragma warning disable 1591 //no XML comment

using System.Text.RegularExpressions;

namespace Libs.DiffMatchPatch
{
	internal static class CompatibilityExtensions
	{
		// JScript splice function
		public static List<T> Splice<T>(this List<T> input, int start, int count,
			params T[] objects)
		{
			List<T> deletedRange = input.GetRange(start, count);
			input.RemoveRange(start, count);
			input.InsertRange(start, objects);

			return deletedRange;
		}

		// Java substring function
		public static string JavaSubstring(this string s, int begin, int end)
		{
			return s.Substring(begin, end - begin);
		}

		public static T First<T>(this List<T> t) => t[0];

		public static T Last<T>(this List<T> t) => t[t.Count - 1];
	}

	/**-
	 * The data structure representing a diff is a List of Diff objects:
	 * {Diff(Operation.DELETE, "Hello"), Diff(Operation.INSERT, "Goodbye"),
	 *  Diff(Operation.EQUAL, " world.")}
	 * which means: delete "Hello", add "Goodbye" and keep " world."
	 */
	public enum Operation
	{
		DELETE, INSERT, EQUAL
	}


	/**
	 * Class representing one diff operation.
	 */
	public class Diff
	{
		public Operation operation;
		// One of: INSERT, DELETE or EQUAL.
		public string text;
		// The text associated with this diff operation.

		/**
		 * Constructor.  Initializes the diff with the provided values.
		 * @param operation One of INSERT, DELETE or EQUAL.
		 * @param text The text being applied.
		 */
		public Diff(Operation operation, string text)
		{
			// Construct a diff with the specified operation and text.
			this.operation = operation;
			this.text = text;
		}

		/**
		 * Display a human-readable version of this Diff.
		 * @return text version.
		 */
		public override string ToString()
		{
			string prettyText = this.text.Replace('\n', '\u00b6');
			return "Diff(" + this.operation + ",\"" + prettyText + "\")";
		}

		/**
		 * Is this Diff equivalent to another Diff?
		 * @param d Another Diff to compare against.
		 * @return true or false.
		 */
		public override bool Equals(Object obj)
		{
			// If parameter is null return false.
			if(obj == null) {
				return false;
			}

			// If parameter cannot be cast to Diff return false.
			Diff p = obj as Diff;
			if((System.Object)p == null) {
				return false;
			}

			// Return true if the fields match.
			return p.operation == this.operation && p.text == this.text;
		}

		public bool Equals(Diff obj)
		{
			// If parameter is null return false.
			if(obj == null) {
				return false;
			}

			// Return true if the fields match.
			return obj.operation == this.operation && obj.text == this.text;
		}

		public override int GetHashCode()
		{
			return text.GetHashCode() ^ operation.GetHashCode();
		}
	}


	/**
	 * Class representing one patch operation.
	 */
	public class Patch
	{
		public List<Diff> diffs = new List<Diff>();
		public int start1;
		public int start2;
		public int length1;
		public int length2;

		/**
		 * Emulate GNU diff's format.
		 * Header: @@ -382,8 +481,9 @@
		 * Indices are printed as 1-based, not 0-based.
		 * @return The GNU diff string.
		 */
		public override string ToString()
		{
			string coords1, coords2;
			if(this.length1 == 0) {
				coords1 = this.start1 + ",0";
			} else if(this.length1 == 1) {
				coords1 = Convert.ToString(this.start1 + 1);
			} else {
				coords1 = (this.start1 + 1) + "," + this.length1;
			}
			if(this.length2 == 0) {
				coords2 = this.start2 + ",0";
			} else if(this.length2 == 1) {
				coords2 = Convert.ToString(this.start2 + 1);
			} else {
				coords2 = (this.start2 + 1) + "," + this.length2;
			}
			StringBuilder text = new StringBuilder();
			text.Append("@@ -").Append(coords1).Append(" +").Append(coords2)
				.Append(" @@\n");
			// Escape the body of the patch with %xx notation.
			foreach(Diff aDiff in this.diffs) {
				switch(aDiff.operation) {
				case Operation.INSERT:
					text.Append('+');
					break;
				case Operation.DELETE:
					text.Append('-');
					break;
				case Operation.EQUAL:
					text.Append(' ');
					break;
				}

				text.Append(diff_match_patch.encodeURI(aDiff.text)).Append("\n");
			}
			return text.ToString();
		}
	}


	/**
	 * Class containing the diff, match and patch methods.
	 * Also contains the behaviour settings.
	 */
	public class diff_match_patch
	{
		// Defaults.
		// Set these on your diff_match_patch instance to override the defaults.

		// Number of seconds to map a diff before giving up (0 for infinity).
		public float Diff_Timeout = 1.0f;
		// Cost of an empty edit operation in terms of edit characters.
		public short Diff_EditCost = 4;
		// At what point is no match declared (0.0 = perfection, 1.0 = very loose).
		public float Match_Threshold = 0.5f;
		// How far to search for a match (0 = exact location, 1000+ = broad match).
		// A match this many characters away from the expected location will add
		// 1.0 to the score (0.0 is a perfect match).
		public int Match_Distance = 1000;
		// When deleting a large block of text (over ~64 characters), how close
		// do the contents have to be to match the expected contents. (0.0 =
		// perfection, 1.0 = very loose).  Note that Match_Threshold controls
		// how closely the end points of a delete need to match.
		public float Patch_DeleteThreshold = 0.5f;
		// Chunk size for context length.
		public short Patch_Margin = 4;

		// The number of bits in an int.
		const short Match_MaxBits = 32;
		int _startTime, _timeout;


		//  DIFF FUNCTIONS


		/**
		 * Find the differences between two texts.
		 * @param text1 Old string to be diffed.
		 * @param text2 New string to be diffed.
		 * @param checklines Speedup flag.  If false, then don't run a
		 *     line-level diff first to identify the changed areas.
		 *     If true, then run a faster slightly less optimal diff.
		 * @return List of Diff objects.
		 */
		public List<Diff> diff_main(string text1, string text2, bool checklines = true)
		{
			// Set a deadline by which time the diff must be complete.
			if(this.Diff_Timeout <= 0 || this.Diff_Timeout > int.MaxValue / 1000) {
				_timeout = 0;
			} else {
				_startTime = Environment.TickCount;
				_timeout = (int)(this.Diff_Timeout * 1000d);
			}
			return _diff_main(text1, text2, checklines);
		}

		/**
		 * Find the differences between two texts.  Simplifies the problem by
		 * stripping any common prefix or suffix off the texts before diffing.
		 * @param text1 Old string to be diffed.
		 * @param text2 New string to be diffed.
		 * @param checklines Speedup flag.  If false, then don't run a
		 *     line-level diff first to identify the changed areas.
		 *     If true, then run a faster slightly less optimal diff.
		 *     internally for recursive calls.  Users should set DiffTimeout
		 *     instead.
		 * @return List of Diff objects.
		 */
		private List<Diff> _diff_main(string text1, string text2, bool checklines)
		{
			// Check for null inputs not needed since null can't be passed in C#.

			// Check for equality (speedup).
			List<Diff> diffs;
			if(text1 == text2) {
				diffs = new List<Diff>();
				if(text1.Length != 0) {
					diffs.Add(new Diff(Operation.EQUAL, text1));
				}
				return diffs;
			}

			// Trim off common prefix (speedup).
			int commonlength = diff_commonPrefix(text1, text2);
			string commonprefix = text1.Substring(0, commonlength);
			text1 = text1.Substring(commonlength);
			text2 = text2.Substring(commonlength);

			// Trim off common suffix (speedup).
			commonlength = diff_commonSuffix(text1, text2);
			string commonsuffix = text1.Substring(text1.Length - commonlength);
			text1 = text1.Substring(0, text1.Length - commonlength);
			text2 = text2.Substring(0, text2.Length - commonlength);

			// Compute the diff on the middle block.
			diffs = diff_compute(text1, text2, checklines);

			// Restore the prefix and suffix.
			if(commonprefix.Length != 0) {
				diffs.Insert(0, (new Diff(Operation.EQUAL, commonprefix)));
			}
			if(commonsuffix.Length != 0) {
				diffs.Add(new Diff(Operation.EQUAL, commonsuffix));
			}

			diff_cleanupMerge(diffs);
			return diffs;
		}

		/**
		 * Find the differences between two texts.  Assumes that the texts do not
		 * have any common prefix or suffix.
		 * @param text1 Old string to be diffed.
		 * @param text2 New string to be diffed.
		 * @param checklines Speedup flag.  If false, then don't run a
		 *     line-level diff first to identify the changed areas.
		 *     If true, then run a faster slightly less optimal diff.
		 * @return List of Diff objects.
		 */
		private List<Diff> diff_compute(string text1, string text2, bool checklines)
		{
			List<Diff> diffs = new List<Diff>();

			if(text1.Length == 0) {
				// Just add some text (speedup).
				diffs.Add(new Diff(Operation.INSERT, text2));
				return diffs;
			}

			if(text2.Length == 0) {
				// Just delete some text (speedup).
				diffs.Add(new Diff(Operation.DELETE, text1));
				return diffs;
			}

			string longtext = text1.Length > text2.Length ? text1 : text2;
			string shorttext = text1.Length > text2.Length ? text2 : text1;
			int i = longtext.IndexOf(shorttext, StringComparison.Ordinal);
			if(i != -1) {
				// Shorter text is inside the longer text (speedup).
				Operation op = (text1.Length > text2.Length) ?
					Operation.DELETE : Operation.INSERT;
				diffs.Add(new Diff(op, longtext.Substring(0, i)));
				diffs.Add(new Diff(Operation.EQUAL, shorttext));
				diffs.Add(new Diff(op, longtext.Substring(i + shorttext.Length)));
				return diffs;
			}

			if(shorttext.Length == 1) {
				// Single character string.
				// After the previous speedup, the character can't be an equality.
				diffs.Add(new Diff(Operation.DELETE, text1));
				diffs.Add(new Diff(Operation.INSERT, text2));
				return diffs;
			}

			// Check to see if the problem can be split in two.
			string[] hm = diff_halfMatch(text1, text2);
			if(hm != null) {
				// A half-match was found, sort out the return data.
				string text1_a = hm[0];
				string text1_b = hm[1];
				string text2_a = hm[2];
				string text2_b = hm[3];
				string mid_common = hm[4];
				// Send both pairs off for separate processing.
				List<Diff> diffs_a = _diff_main(text1_a, text2_a, checklines);
				List<Diff> diffs_b = _diff_main(text1_b, text2_b, checklines);
				// Merge the results.
				diffs = diffs_a;
				diffs.Add(new Diff(Operation.EQUAL, mid_common));
				diffs.AddRange(diffs_b);
				return diffs;
			}

			if(checklines && text1.Length > 100 && text2.Length > 100) {
				return diff_lineMode(text1, text2);
			}

			return diff_bisect(text1, text2);
		}

		/**
		 * Do a quick line-level diff on both strings, then rediff the parts for
		 * greater accuracy.
		 * This speedup can produce non-minimal diffs.
		 * @param text1 Old string to be diffed.
		 * @param text2 New string to be diffed.
		 * @return List of Diff objects.
		 */
		private List<Diff> diff_lineMode(string text1, string text2)
		{
			// Scan the text on a line-by-line basis first.
			Object[] a = diff_linesToChars(text1, text2);
			text1 = (string)a[0];
			text2 = (string)a[1];
			List<string> linearray = (List<string>)a[2];

			List<Diff> diffs = _diff_main(text1, text2, false);

			// Convert the diff back to original text.
			diff_charsToLines(diffs, linearray);
			// Eliminate freak matches (e.g. blank lines)
			diff_cleanupSemantic(diffs);

			// Rediff any replacement blocks, this time character-by-character.
			// Add a dummy entry at the end.
			diffs.Add(new Diff(Operation.EQUAL, string.Empty));
			int pointer = 0;
			int count_delete = 0;
			int count_insert = 0;
			string text_delete = string.Empty;
			string text_insert = string.Empty;
			while(pointer < diffs.Count) {
				switch(diffs[pointer].operation) {
				case Operation.INSERT:
					count_insert++;
					text_insert += diffs[pointer].text;
					break;
				case Operation.DELETE:
					count_delete++;
					text_delete += diffs[pointer].text;
					break;
				case Operation.EQUAL:
					// Upon reaching an equality, check for prior redundancies.
					if(count_delete >= 1 && count_insert >= 1) {
						// Delete the offending records and add the merged ones.
						diffs.RemoveRange(pointer - count_delete - count_insert,
							count_delete + count_insert);
						pointer = pointer - count_delete - count_insert;
						List<Diff> subDiff =
							this._diff_main(text_delete, text_insert, false);
						diffs.InsertRange(pointer, subDiff);
						pointer = pointer + subDiff.Count;
					}
					count_insert = 0;
					count_delete = 0;
					text_delete = string.Empty;
					text_insert = string.Empty;
					break;
				}
				pointer++;
			}
			diffs.RemoveAt(diffs.Count - 1);  // Remove the dummy entry at the end.

			return diffs;
		}

		/**
		 * Find the 'middle snake' of a diff, split the problem in two
		 * and return the recursively constructed diff.
		 * See Myers 1986 paper: An O(ND) Difference Algorithm and Its Variations.
		 * @param text1 Old string to be diffed.
		 * @param text2 New string to be diffed.
		 * @return List of Diff objects.
		 */
		protected List<Diff> diff_bisect(string text1, string text2)
		{
			// Cache the text lengths to prevent multiple calls.
			int text1_length = text1.Length;
			int text2_length = text2.Length;
			int max_d = (text1_length + text2_length + 1) / 2;
			int v_offset = max_d;
			int v_length = 2 * max_d;
			int[] v1 = new int[v_length];
			int[] v2 = new int[v_length];
			for(int x = 0; x < v_length; x++) {
				v1[x] = -1;
				v2[x] = -1;
			}
			v1[v_offset + 1] = 0;
			v2[v_offset + 1] = 0;
			int delta = text1_length - text2_length;
			// If the total number of characters is odd, then the front path will
			// collide with the reverse path.
			bool front = (delta % 2 != 0);
			// Offsets for start and end of k loop.
			// Prevents mapping of space beyond the grid.
			int k1start = 0;
			int k1end = 0;
			int k2start = 0;
			int k2end = 0;
			for(int d = 0; d < max_d; d++) {
				// Bail out if deadline is reached.
				if(_timeout != 0 && Environment.TickCount - _startTime > _timeout) {
					break;
				}

				// Walk the front path one step.
				for(int k1 = -d + k1start; k1 <= d - k1end; k1 += 2) {
					int k1_offset = v_offset + k1;
					int x1;
					if(k1 == -d || k1 != d && v1[k1_offset - 1] < v1[k1_offset + 1]) {
						x1 = v1[k1_offset + 1];
					} else {
						x1 = v1[k1_offset - 1] + 1;
					}
					int y1 = x1 - k1;
					while(x1 < text1_length && y1 < text2_length
						  && text1[x1] == text2[y1]) {
						x1++;
						y1++;
					}
					v1[k1_offset] = x1;
					if(x1 > text1_length) {
						// Ran off the right of the graph.
						k1end += 2;
					} else if(y1 > text2_length) {
						// Ran off the bottom of the graph.
						k1start += 2;
					} else if(front) {
						int k2_offset = v_offset + delta - k1;
						if(k2_offset >= 0 && k2_offset < v_length && v2[k2_offset] != -1) {
							// Mirror x2 onto top-left coordinate system.
							int x2 = text1_length - v2[k2_offset];
							if(x1 >= x2) {
								// Overlap detected.
								return diff_bisectSplit(text1, text2, x1, y1);
							}
						}
					}
				}

				// Walk the reverse path one step.
				for(int k2 = -d + k2start; k2 <= d - k2end; k2 += 2) {
					int k2_offset = v_offset + k2;
					int x2;
					if(k2 == -d || k2 != d && v2[k2_offset - 1] < v2[k2_offset + 1]) {
						x2 = v2[k2_offset + 1];
					} else {
						x2 = v2[k2_offset - 1] + 1;
					}
					int y2 = x2 - k2;
					while(x2 < text1_length && y2 < text2_length
						&& text1[text1_length - x2 - 1]
						== text2[text2_length - y2 - 1]) {
						x2++;
						y2++;
					}
					v2[k2_offset] = x2;
					if(x2 > text1_length) {
						// Ran off the left of the graph.
						k2end += 2;
					} else if(y2 > text2_length) {
						// Ran off the top of the graph.
						k2start += 2;
					} else if(!front) {
						int k1_offset = v_offset + delta - k2;
						if(k1_offset >= 0 && k1_offset < v_length && v1[k1_offset] != -1) {
							int x1 = v1[k1_offset];
							int y1 = v_offset + x1 - k1_offset;
							// Mirror x2 onto top-left coordinate system.
							x2 = text1_length - v2[k2_offset];
							if(x1 >= x2) {
								// Overlap detected.
								return diff_bisectSplit(text1, text2, x1, y1);
							}
						}
					}
				}
			}
			// Diff took too long and hit the deadline or
			// number of diffs equals number of characters, no commonality at all.
			List<Diff> diffs = new List<Diff>();
			diffs.Add(new Diff(Operation.DELETE, text1));
			diffs.Add(new Diff(Operation.INSERT, text2));
			return diffs;
		}

		/**
		 * Given the location of the 'middle snake', split the diff in two parts
		 * and recurse.
		 * @param text1 Old string to be diffed.
		 * @param text2 New string to be diffed.
		 * @param x Index of split point in text1.
		 * @param y Index of split point in text2.
		 * @return LinkedList of Diff objects.
		 */
		private List<Diff> diff_bisectSplit(string text1, string text2, int x, int y)
		{
			string text1a = text1.Substring(0, x);
			string text2a = text2.Substring(0, y);
			string text1b = text1.Substring(x);
			string text2b = text2.Substring(y);

			// Compute both diffs serially.
			List<Diff> diffs = _diff_main(text1a, text2a, false);
			List<Diff> diffsb = _diff_main(text1b, text2b, false);

			diffs.AddRange(diffsb);
			return diffs;
		}

		/**
		 * Split two texts into a list of strings.  Reduce the texts to a string of
		 * hashes where each Unicode character represents one line.
		 * @param text1 First string.
		 * @param text2 Second string.
		 * @return Three element Object array, containing the encoded text1, the
		 *     encoded text2 and the List of unique strings.  The zeroth element
		 *     of the List of unique strings is intentionally blank.
		 */
		protected Object[] diff_linesToChars(string text1, string text2)
		{
			List<string> lineArray = new List<string>();
			Dictionary<string, int> lineHash = new Dictionary<string, int>();
			// e.g. linearray[4] == "Hello\n"
			// e.g. linehash.get("Hello\n") == 4

			// "\x00" is a valid character, but various debuggers don't like it.
			// So we'll insert a junk entry to avoid generating a null character.
			lineArray.Add(string.Empty);

			// Allocate 2/3rds of the space for text1, the rest for text2.
			string chars1 = diff_linesToCharsMunge(text1, lineArray, lineHash, 40000);
			string chars2 = diff_linesToCharsMunge(text2, lineArray, lineHash, 65535);
			return new Object[] { chars1, chars2, lineArray };
		}

		/**
		 * Split a text into a list of strings.  Reduce the texts to a string of
		 * hashes where each Unicode character represents one line.
		 * @param text String to encode.
		 * @param lineArray List of unique strings.
		 * @param lineHash Map of strings to indices.
		 * @param maxLines Maximum length of lineArray.
		 * @return Encoded string.
		 */
		private string diff_linesToCharsMunge(string text, List<string> lineArray,
			Dictionary<string, int> lineHash, int maxLines)
		{
			int lineStart = 0;
			int lineEnd = -1;
			string line;
			StringBuilder chars = new StringBuilder();
			// Walk the text, pulling out a Substring for each line.
			// text.split('\n') would would temporarily double our memory footprint.
			// Modifying text would create many large strings to garbage collect.
			while(lineEnd < text.Length - 1) {
				lineEnd = text.IndexOf('\n', lineStart);
				if(lineEnd == -1) {
					lineEnd = text.Length - 1;
				}
				line = text.JavaSubstring(lineStart, lineEnd + 1);

				if(lineHash.ContainsKey(line)) {
					chars.Append(((char)(int)lineHash[line]));
				} else {
					if(lineArray.Count == maxLines) {
						// Bail out at 65535 because char 65536 == char 0.
						line = text.Substring(lineStart);
						lineEnd = text.Length;
					}
					lineArray.Add(line);
					lineHash.Add(line, lineArray.Count - 1);
					chars.Append(((char)(lineArray.Count - 1)));
				}
				lineStart = lineEnd + 1;
			}
			return chars.ToString();
		}

		/**
		 * Rehydrate the text in a diff from a string of line hashes to real lines
		 * of text.
		 * @param diffs List of Diff objects.
		 * @param lineArray List of unique strings.
		 */
		protected void diff_charsToLines(ICollection<Diff> diffs,
						IList<string> lineArray)
		{
			StringBuilder text;
			foreach(Diff diff in diffs) {
				text = new StringBuilder();
				for(int j = 0; j < diff.text.Length; j++) {
					text.Append(lineArray[diff.text[j]]);
				}
				diff.text = text.ToString();
			}
		}

		/**
		 * Determine the common prefix of two strings.
		 * @param text1 First string.
		 * @param text2 Second string.
		 * @return The number of characters common to the start of each string.
		 */
		public static int diff_commonPrefix(string text1, string text2)
		{
			// Performance analysis: https://neil.fraser.name/news/2007/10/09/
			int n = Math.Min(text1.Length, text2.Length);
			for(int i = 0; i < n; i++) {
				if(text1[i] != text2[i]) {
					return i;
				}
			}
			return n;
		}

		/**
		 * Determine the common suffix of two strings.
		 * @param text1 First string.
		 * @param text2 Second string.
		 * @return The number of characters common to the end of each string.
		 */
		public static int diff_commonSuffix(string text1, string text2)
		{
			// Performance analysis: https://neil.fraser.name/news/2007/10/09/
			int text1_length = text1.Length;
			int text2_length = text2.Length;
			int n = Math.Min(text1.Length, text2.Length);
			for(int i = 1; i <= n; i++) {
				if(text1[text1_length - i] != text2[text2_length - i]) {
					return i - 1;
				}
			}
			return n;
		}

		/**
		 * Determine if the suffix of one string is the prefix of another.
		 * @param text1 First string.
		 * @param text2 Second string.
		 * @return The number of characters common to the end of the first
		 *     string and the start of the second string.
		 */
		protected int diff_commonOverlap(string text1, string text2)
		{
			// Cache the text lengths to prevent multiple calls.
			int text1_length = text1.Length;
			int text2_length = text2.Length;
			// Eliminate the null case.
			if(text1_length == 0 || text2_length == 0) {
				return 0;
			}
			// Truncate the longer string.
			if(text1_length > text2_length) {
				text1 = text1.Substring(text1_length - text2_length);
			} else if(text1_length < text2_length) {
				text2 = text2.Substring(0, text1_length);
			}
			int text_length = Math.Min(text1_length, text2_length);
			// Quick check for the worst case.
			if(text1 == text2) {
				return text_length;
			}

			// Start by looking for a single character match
			// and increase length until no match is found.
			// Performance analysis: https://neil.fraser.name/news/2010/11/04/
			int best = 0;
			int length = 1;
			while(true) {
				string pattern = text1.Substring(text_length - length);
				int found = text2.IndexOf(pattern, StringComparison.Ordinal);
				if(found == -1) {
					return best;
				}
				length += found;
				if(found == 0 || text1.Substring(text_length - length) ==
					text2.Substring(0, length)) {
					best = length;
					length++;
				}
			}
		}

		/**
		 * Do the two texts share a Substring which is at least half the length of
		 * the longer text?
		 * This speedup can produce non-minimal diffs.
		 * @param text1 First string.
		 * @param text2 Second string.
		 * @return Five element String array, containing the prefix of text1, the
		 *     suffix of text1, the prefix of text2, the suffix of text2 and the
		 *     common middle.  Or null if there was no match.
		 */

		protected string[] diff_halfMatch(string text1, string text2)
		{
			if(this.Diff_Timeout <= 0) {
				// Don't risk returning a non-optimal diff if we have unlimited time.
				return null;
			}
			string longtext = text1.Length > text2.Length ? text1 : text2;
			string shorttext = text1.Length > text2.Length ? text2 : text1;
			if(longtext.Length < 4 || shorttext.Length * 2 < longtext.Length) {
				return null;  // Pointless.
			}

			// First check if the second quarter is the seed for a half-match.
			string[] hm1 = diff_halfMatchI(longtext, shorttext,
										   (longtext.Length + 3) / 4);
			// Check again based on the third quarter.
			string[] hm2 = diff_halfMatchI(longtext, shorttext,
										   (longtext.Length + 1) / 2);
			string[] hm;
			if(hm1 == null && hm2 == null) {
				return null;
			} else if(hm2 == null) {
				hm = hm1;
			} else if(hm1 == null) {
				hm = hm2;
			} else {
				// Both matched.  Select the longest.
				hm = hm1[4].Length > hm2[4].Length ? hm1 : hm2;
			}

			// A half-match was found, sort out the return data.
			if(text1.Length > text2.Length) {
				return hm;
				//return new string[]{hm[0], hm[1], hm[2], hm[3], hm[4]};
			} else {
				return new string[] { hm[2], hm[3], hm[0], hm[1], hm[4] };
			}
		}

		/**
		 * Does a Substring of shorttext exist within longtext such that the
		 * Substring is at least half the length of longtext?
		 * @param longtext Longer string.
		 * @param shorttext Shorter string.
		 * @param i Start index of quarter length Substring within longtext.
		 * @return Five element string array, containing the prefix of longtext, the
		 *     suffix of longtext, the prefix of shorttext, the suffix of shorttext
		 *     and the common middle.  Or null if there was no match.
		 */
		private string[] diff_halfMatchI(string longtext, string shorttext, int i)
		{
			// Start with a 1/4 length Substring at position i as a seed.
			string seed = longtext.Substring(i, longtext.Length / 4);
			int j = -1;
			string best_common = string.Empty;
			string best_longtext_a = string.Empty, best_longtext_b = string.Empty;
			string best_shorttext_a = string.Empty, best_shorttext_b = string.Empty;
			while(j < shorttext.Length && (j = shorttext.IndexOf(seed, j + 1,
				StringComparison.Ordinal)) != -1) {
				int prefixLength = diff_commonPrefix(longtext.Substring(i),
													 shorttext.Substring(j));
				int suffixLength = diff_commonSuffix(longtext.Substring(0, i),
													 shorttext.Substring(0, j));
				if(best_common.Length < suffixLength + prefixLength) {
					best_common = shorttext.Substring(j - suffixLength, suffixLength)
						+ shorttext.Substring(j, prefixLength);
					best_longtext_a = longtext.Substring(0, i - suffixLength);
					best_longtext_b = longtext.Substring(i + prefixLength);
					best_shorttext_a = shorttext.Substring(0, j - suffixLength);
					best_shorttext_b = shorttext.Substring(j + prefixLength);
				}
			}
			if(best_common.Length * 2 >= longtext.Length) {
				return new string[]{best_longtext_a, best_longtext_b,
			best_shorttext_a, best_shorttext_b, best_common};
			} else {
				return null;
			}
		}

		/**
		 * Reduce the number of edits by eliminating semantically trivial
		 * equalities.
		 * @param diffs List of Diff objects.
		 */
		public void diff_cleanupSemantic(List<Diff> diffs)
		{
			bool changes = false;
			// Stack of indices where equalities are found.
			Stack<int> equalities = new Stack<int>();
			// Always equal to equalities[equalitiesLength-1][1]
			string lastEquality = null;
			int pointer = 0;  // Index of current position.
							  // Number of characters that changed prior to the equality.
			int length_insertions1 = 0;
			int length_deletions1 = 0;
			// Number of characters that changed after the equality.
			int length_insertions2 = 0;
			int length_deletions2 = 0;
			while(pointer < diffs.Count) {
				if(diffs[pointer].operation == Operation.EQUAL) {  // Equality found.
					equalities.Push(pointer);
					length_insertions1 = length_insertions2;
					length_deletions1 = length_deletions2;
					length_insertions2 = 0;
					length_deletions2 = 0;
					lastEquality = diffs[pointer].text;
				} else {  // an insertion or deletion
					if(diffs[pointer].operation == Operation.INSERT) {
						length_insertions2 += diffs[pointer].text.Length;
					} else {
						length_deletions2 += diffs[pointer].text.Length;
					}
					// Eliminate an equality that is smaller or equal to the edits on both
					// sides of it.
					if(lastEquality != null && (lastEquality.Length
						<= Math.Max(length_insertions1, length_deletions1))
						&& (lastEquality.Length
							<= Math.Max(length_insertions2, length_deletions2))) {
						// Duplicate record.
						diffs.Insert(equalities.Peek(),
									 new Diff(Operation.DELETE, lastEquality));
						// Change second copy to insert.
						diffs[equalities.Peek() + 1].operation = Operation.INSERT;
						// Throw away the equality we just deleted.
						equalities.Pop();
						if(equalities.Count > 0) {
							equalities.Pop();
						}
						pointer = equalities.Count > 0 ? equalities.Peek() : -1;
						length_insertions1 = 0;  // Reset the counters.
						length_deletions1 = 0;
						length_insertions2 = 0;
						length_deletions2 = 0;
						lastEquality = null;
						changes = true;
					}
				}
				pointer++;
			}

			// Normalize the diff.
			if(changes) {
				diff_cleanupMerge(diffs);
			}
			diff_cleanupSemanticLossless(diffs);

			// Find any overlaps between deletions and insertions.
			// e.g: <del>abcxxx</del><ins>xxxdef</ins>
			//   -> <del>abc</del>xxx<ins>def</ins>
			// e.g: <del>xxxabc</del><ins>defxxx</ins>
			//   -> <ins>def</ins>xxx<del>abc</del>
			// Only extract an overlap if it is as big as the edit ahead or behind it.
			pointer = 1;
			while(pointer < diffs.Count) {
				if(diffs[pointer - 1].operation == Operation.DELETE &&
					diffs[pointer].operation == Operation.INSERT) {
					string deletion = diffs[pointer - 1].text;
					string insertion = diffs[pointer].text;
					int overlap_length1 = diff_commonOverlap(deletion, insertion);
					int overlap_length2 = diff_commonOverlap(insertion, deletion);
					if(overlap_length1 >= overlap_length2) {
						if(overlap_length1 >= deletion.Length / 2.0 ||
							overlap_length1 >= insertion.Length / 2.0) {
							// Overlap found.
							// Insert an equality and trim the surrounding edits.
							diffs.Insert(pointer, new Diff(Operation.EQUAL,
								insertion.Substring(0, overlap_length1)));
							diffs[pointer - 1].text =
								deletion.Substring(0, deletion.Length - overlap_length1);
							diffs[pointer + 1].text = insertion.Substring(overlap_length1);
							pointer++;
						}
					} else {
						if(overlap_length2 >= deletion.Length / 2.0 ||
							overlap_length2 >= insertion.Length / 2.0) {
							// Reverse overlap found.
							// Insert an equality and swap and trim the surrounding edits.
							diffs.Insert(pointer, new Diff(Operation.EQUAL,
								deletion.Substring(0, overlap_length2)));
							diffs[pointer - 1].operation = Operation.INSERT;
							diffs[pointer - 1].text =
								insertion.Substring(0, insertion.Length - overlap_length2);
							diffs[pointer + 1].operation = Operation.DELETE;
							diffs[pointer + 1].text = deletion.Substring(overlap_length2);
							pointer++;
						}
					}
					pointer++;
				}
				pointer++;
			}
		}

		/**
		 * Look for single edits surrounded on both sides by equalities
		 * which can be shifted sideways to align the edit to a word boundary.
		 * e.g: The c<ins>at c</ins>ame. -> The <ins>cat </ins>came.
		 * @param diffs List of Diff objects.
		 */
		public void diff_cleanupSemanticLossless(List<Diff> diffs)
		{
			int pointer = 1;
			// Intentionally ignore the first and last element (don't need checking).
			while(pointer < diffs.Count - 1) {
				if(diffs[pointer - 1].operation == Operation.EQUAL &&
				  diffs[pointer + 1].operation == Operation.EQUAL) {
					// This is a single edit surrounded by equalities.
					string equality1 = diffs[pointer - 1].text;
					string edit = diffs[pointer].text;
					string equality2 = diffs[pointer + 1].text;

					// First, shift the edit as far left as possible.
					int commonOffset = diff_commonSuffix(equality1, edit);
					if(commonOffset > 0) {
						string commonString = edit.Substring(edit.Length - commonOffset);
						equality1 = equality1.Substring(0, equality1.Length - commonOffset);
						edit = commonString + edit.Substring(0, edit.Length - commonOffset);
						equality2 = commonString + equality2;
					}

					// Second, step character by character right,
					// looking for the best fit.
					string bestEquality1 = equality1;
					string bestEdit = edit;
					string bestEquality2 = equality2;
					int bestScore = diff_cleanupSemanticScore(equality1, edit) +
						diff_cleanupSemanticScore(edit, equality2);
					while(edit.Length != 0 && equality2.Length != 0
						&& edit[0] == equality2[0]) {
						equality1 += edit[0];
						edit = edit.Substring(1) + equality2[0];
						equality2 = equality2.Substring(1);
						int score = diff_cleanupSemanticScore(equality1, edit) +
							diff_cleanupSemanticScore(edit, equality2);
						// The >= encourages trailing rather than leading whitespace on
						// edits.
						if(score >= bestScore) {
							bestScore = score;
							bestEquality1 = equality1;
							bestEdit = edit;
							bestEquality2 = equality2;
						}
					}

					if(diffs[pointer - 1].text != bestEquality1) {
						// We have an improvement, save it back to the diff.
						if(bestEquality1.Length != 0) {
							diffs[pointer - 1].text = bestEquality1;
						} else {
							diffs.RemoveAt(pointer - 1);
							pointer--;
						}
						diffs[pointer].text = bestEdit;
						if(bestEquality2.Length != 0) {
							diffs[pointer + 1].text = bestEquality2;
						} else {
							diffs.RemoveAt(pointer + 1);
							pointer--;
						}
					}
				}
				pointer++;
			}
		}

		/**
		 * Given two strings, compute a score representing whether the internal
		 * boundary falls on logical boundaries.
		 * Scores range from 6 (best) to 0 (worst).
		 * @param one First string.
		 * @param two Second string.
		 * @return The score.
		 */
		private int diff_cleanupSemanticScore(string one, string two)
		{
			if(one.Length == 0 || two.Length == 0) {
				// Edges are the best.
				return 6;
			}

			// Each port of this function behaves slightly differently due to
			// subtle differences in each language's definition of things like
			// 'whitespace'.  Since this function's purpose is largely cosmetic,
			// the choice has been made to use each language's native features
			// rather than force total conformity.
			char char1 = one[one.Length - 1];
			char char2 = two[0];
			bool nonAlphaNumeric1 = !Char.IsLetterOrDigit(char1);
			bool nonAlphaNumeric2 = !Char.IsLetterOrDigit(char2);
			bool whitespace1 = nonAlphaNumeric1 && Char.IsWhiteSpace(char1);
			bool whitespace2 = nonAlphaNumeric2 && Char.IsWhiteSpace(char2);
			bool lineBreak1 = whitespace1 && Char.IsControl(char1);
			bool lineBreak2 = whitespace2 && Char.IsControl(char2);
			bool blankLine1 = lineBreak1 && BLANKLINEEND.IsMatch(one);
			bool blankLine2 = lineBreak2 && BLANKLINESTART.IsMatch(two);

			if(blankLine1 || blankLine2) {
				// Five points for blank lines.
				return 5;
			} else if(lineBreak1 || lineBreak2) {
				// Four points for line breaks.
				return 4;
			} else if(nonAlphaNumeric1 && !whitespace1 && whitespace2) {
				// Three points for end of sentences.
				return 3;
			} else if(whitespace1 || whitespace2) {
				// Two points for whitespace.
				return 2;
			} else if(nonAlphaNumeric1 || nonAlphaNumeric2) {
				// One point for non-alphanumeric.
				return 1;
			}
			return 0;
		}

		// Define some regex patterns for matching boundaries.
		private Regex BLANKLINEEND = new Regex("\\n\\r?\\n\\Z");
		private Regex BLANKLINESTART = new Regex("\\A\\r?\\n\\r?\\n");

		/**
		 * Reduce the number of edits by eliminating operationally trivial
		 * equalities.
		 * @param diffs List of Diff objects.
		 */
		public void diff_cleanupEfficiency(List<Diff> diffs)
		{
			bool changes = false;
			// Stack of indices where equalities are found.
			Stack<int> equalities = new Stack<int>();
			// Always equal to equalities[equalitiesLength-1][1]
			string lastEquality = string.Empty;
			int pointer = 0;  // Index of current position.
							  // Is there an insertion operation before the last equality.
			bool pre_ins = false;
			// Is there a deletion operation before the last equality.
			bool pre_del = false;
			// Is there an insertion operation after the last equality.
			bool post_ins = false;
			// Is there a deletion operation after the last equality.
			bool post_del = false;
			while(pointer < diffs.Count) {
				if(diffs[pointer].operation == Operation.EQUAL) {  // Equality found.
					if(diffs[pointer].text.Length < this.Diff_EditCost
						&& (post_ins || post_del)) {
						// Candidate found.
						equalities.Push(pointer);
						pre_ins = post_ins;
						pre_del = post_del;
						lastEquality = diffs[pointer].text;
					} else {
						// Not a candidate, and can never become one.
						equalities.Clear();
						lastEquality = string.Empty;
					}
					post_ins = post_del = false;
				} else {  // An insertion or deletion.
					if(diffs[pointer].operation == Operation.DELETE) {
						post_del = true;
					} else {
						post_ins = true;
					}
					/*
					 * Five types to be split:
					 * <ins>A</ins><del>B</del>XY<ins>C</ins><del>D</del>
					 * <ins>A</ins>X<ins>C</ins><del>D</del>
					 * <ins>A</ins><del>B</del>X<ins>C</ins>
					 * <ins>A</del>X<ins>C</ins><del>D</del>
					 * <ins>A</ins><del>B</del>X<del>C</del>
					 */
					if((lastEquality.Length != 0)
						&& ((pre_ins && pre_del && post_ins && post_del)
						|| ((lastEquality.Length < this.Diff_EditCost / 2)
						&& ((pre_ins ? 1 : 0) + (pre_del ? 1 : 0) + (post_ins ? 1 : 0)
						+ (post_del ? 1 : 0)) == 3))) {
						// Duplicate record.
						diffs.Insert(equalities.Peek(),
									 new Diff(Operation.DELETE, lastEquality));
						// Change second copy to insert.
						diffs[equalities.Peek() + 1].operation = Operation.INSERT;
						equalities.Pop();  // Throw away the equality we just deleted.
						lastEquality = string.Empty;
						if(pre_ins && pre_del) {
							// No changes made which could affect previous entry, keep going.
							post_ins = post_del = true;
							equalities.Clear();
						} else {
							if(equalities.Count > 0) {
								equalities.Pop();
							}

							pointer = equalities.Count > 0 ? equalities.Peek() : -1;
							post_ins = post_del = false;
						}
						changes = true;
					}
				}
				pointer++;
			}

			if(changes) {
				diff_cleanupMerge(diffs);
			}
		}

		/**
		 * Reorder and merge like edit sections.  Merge equalities.
		 * Any edit section can move as long as it doesn't cross an equality.
		 * @param diffs List of Diff objects.
		 */
		public void diff_cleanupMerge(List<Diff> diffs)
		{
			// Add a dummy entry at the end.
			diffs.Add(new Diff(Operation.EQUAL, string.Empty));
			int pointer = 0;
			int count_delete = 0;
			int count_insert = 0;
			string text_delete = string.Empty;
			string text_insert = string.Empty;
			int commonlength;
			while(pointer < diffs.Count) {
				switch(diffs[pointer].operation) {
				case Operation.INSERT:
					count_insert++;
					text_insert += diffs[pointer].text;
					pointer++;
					break;
				case Operation.DELETE:
					count_delete++;
					text_delete += diffs[pointer].text;
					pointer++;
					break;
				case Operation.EQUAL:
					// Upon reaching an equality, check for prior redundancies.
					if(count_delete + count_insert > 1) {
						if(count_delete != 0 && count_insert != 0) {
							// Factor out any common prefixies.
							commonlength = diff_commonPrefix(text_insert, text_delete);
							if(commonlength != 0) {
								if((pointer - count_delete - count_insert) > 0 &&
								  diffs[pointer - count_delete - count_insert - 1].operation
									  == Operation.EQUAL) {
									diffs[pointer - count_delete - count_insert - 1].text
										+= text_insert.Substring(0, commonlength);
								} else {
									diffs.Insert(0, new Diff(Operation.EQUAL,
										text_insert.Substring(0, commonlength)));
									pointer++;
								}
								text_insert = text_insert.Substring(commonlength);
								text_delete = text_delete.Substring(commonlength);
							}
							// Factor out any common suffixies.
							commonlength = diff_commonSuffix(text_insert, text_delete);
							if(commonlength != 0) {
								diffs[pointer].text = text_insert.Substring(text_insert.Length
									- commonlength) + diffs[pointer].text;
								text_insert = text_insert.Substring(0, text_insert.Length
									- commonlength);
								text_delete = text_delete.Substring(0, text_delete.Length
									- commonlength);
							}
						}
						// Delete the offending records and add the merged ones.
						pointer -= count_delete + count_insert;
						diffs.Splice(pointer, count_delete + count_insert);
						if(text_delete.Length != 0) {
							diffs.Splice(pointer, 0,
								new Diff(Operation.DELETE, text_delete));
							pointer++;
						}
						if(text_insert.Length != 0) {
							diffs.Splice(pointer, 0,
								new Diff(Operation.INSERT, text_insert));
							pointer++;
						}
						pointer++;
					} else if(pointer != 0
						&& diffs[pointer - 1].operation == Operation.EQUAL) {
						// Merge this equality with the previous one.
						diffs[pointer - 1].text += diffs[pointer].text;
						diffs.RemoveAt(pointer);
					} else {
						pointer++;
					}
					count_insert = 0;
					count_delete = 0;
					text_delete = string.Empty;
					text_insert = string.Empty;
					break;
				}
			}
			if(diffs[diffs.Count - 1].text.Length == 0) {
				diffs.RemoveAt(diffs.Count - 1);  // Remove the dummy entry at the end.
			}

			// Second pass: look for single edits surrounded on both sides by
			// equalities which can be shifted sideways to eliminate an equality.
			// e.g: A<ins>BA</ins>C -> <ins>AB</ins>AC
			bool changes = false;
			pointer = 1;
			// Intentionally ignore the first and last element (don't need checking).
			while(pointer < (diffs.Count - 1)) {
				if(diffs[pointer - 1].operation == Operation.EQUAL &&
				  diffs[pointer + 1].operation == Operation.EQUAL) {
					// This is a single edit surrounded by equalities.
					if(diffs[pointer].text.EndsWith(diffs[pointer - 1].text,
						StringComparison.Ordinal)) {
						// Shift the edit over the previous equality.
						diffs[pointer].text = diffs[pointer - 1].text +
							diffs[pointer].text.Substring(0, diffs[pointer].text.Length -
														  diffs[pointer - 1].text.Length);
						diffs[pointer + 1].text = diffs[pointer - 1].text
							+ diffs[pointer + 1].text;
						diffs.Splice(pointer - 1, 1);
						changes = true;
					} else if(diffs[pointer].text.StartsWith(diffs[pointer + 1].text,
						StringComparison.Ordinal)) {
						// Shift the edit over the next equality.
						diffs[pointer - 1].text += diffs[pointer + 1].text;
						diffs[pointer].text =
							diffs[pointer].text.Substring(diffs[pointer + 1].text.Length)
							+ diffs[pointer + 1].text;
						diffs.Splice(pointer + 1, 1);
						changes = true;
					}
				}
				pointer++;
			}
			// If shifts were made, the diff needs reordering and another shift sweep.
			if(changes) {
				this.diff_cleanupMerge(diffs);
			}
		}

		/**
		 * loc is a location in text1, compute and return the equivalent location in
		 * text2.
		 * e.g. "The cat" vs "The big cat", 1->1, 5->8
		 * @param diffs List of Diff objects.
		 * @param loc Location within text1.
		 * @return Location within text2.
		 */
		public int diff_xIndex(List<Diff> diffs, int loc)
		{
			int chars1 = 0;
			int chars2 = 0;
			int last_chars1 = 0;
			int last_chars2 = 0;
			Diff lastDiff = null;
			foreach(Diff aDiff in diffs) {
				if(aDiff.operation != Operation.INSERT) {
					// Equality or deletion.
					chars1 += aDiff.text.Length;
				}
				if(aDiff.operation != Operation.DELETE) {
					// Equality or insertion.
					chars2 += aDiff.text.Length;
				}
				if(chars1 > loc) {
					// Overshot the location.
					lastDiff = aDiff;
					break;
				}
				last_chars1 = chars1;
				last_chars2 = chars2;
			}
			if(lastDiff != null && lastDiff.operation == Operation.DELETE) {
				// The location was deleted.
				return last_chars2;
			}
			// Add the remaining character length.
			return last_chars2 + (loc - last_chars1);
		}

		/**
		 * Convert a Diff list into a pretty HTML report.
		 * @param diffs List of Diff objects.
		 * @return HTML representation.
		 */
		public string diff_prettyHtml(List<Diff> diffs)
		{
			StringBuilder html = new StringBuilder();
			foreach(Diff aDiff in diffs) {
				string text = aDiff.text.Replace("&", "&amp;").Replace("<", "&lt;")
				  .Replace(">", "&gt;").Replace("\n", "&para;<br>");
				switch(aDiff.operation) {
				case Operation.INSERT:
					html.Append("<ins style=\"background:#e6ffe6;\">").Append(text)
						.Append("</ins>");
					break;
				case Operation.DELETE:
					html.Append("<del style=\"background:#ffe6e6;\">").Append(text)
						.Append("</del>");
					break;
				case Operation.EQUAL:
					html.Append("<span>").Append(text).Append("</span>");
					break;
				}
			}
			return html.ToString();
		}

		/**
		 * Compute and return the source text (all equalities and deletions).
		 * @param diffs List of Diff objects.
		 * @return Source text.
		 */
		public string diff_text1(List<Diff> diffs)
		{
			StringBuilder text = new StringBuilder();
			foreach(Diff aDiff in diffs) {
				if(aDiff.operation != Operation.INSERT) {
					text.Append(aDiff.text);
				}
			}
			return text.ToString();
		}

		/**
		 * Compute and return the destination text (all equalities and insertions).
		 * @param diffs List of Diff objects.
		 * @return Destination text.
		 */
		public string diff_text2(List<Diff> diffs)
		{
			StringBuilder text = new StringBuilder();
			foreach(Diff aDiff in diffs) {
				if(aDiff.operation != Operation.DELETE) {
					text.Append(aDiff.text);
				}
			}
			return text.ToString();
		}

		/**
		 * Compute the Levenshtein distance; the number of inserted, deleted or
		 * substituted characters.
		 * @param diffs List of Diff objects.
		 * @return Number of changes.
		 */
		public int diff_levenshtein(List<Diff> diffs)
		{
			int levenshtein = 0;
			int insertions = 0;
			int deletions = 0;
			foreach(Diff aDiff in diffs) {
				switch(aDiff.operation) {
				case Operation.INSERT:
					insertions += aDiff.text.Length;
					break;
				case Operation.DELETE:
					deletions += aDiff.text.Length;
					break;
				case Operation.EQUAL:
					// A deletion and an insertion is one substitution.
					levenshtein += Math.Max(insertions, deletions);
					insertions = 0;
					deletions = 0;
					break;
				}
			}
			levenshtein += Math.Max(insertions, deletions);
			return levenshtein;
		}

		/**
		 * Crush the diff into an encoded string which describes the operations
		 * required to transform text1 into text2.
		 * E.g. =3\t-2\t+ing  -> Keep 3 chars, delete 2 chars, insert 'ing'.
		 * Operations are tab-separated.  Inserted text is escaped using %xx
		 * notation.
		 * @param diffs Array of Diff objects.
		 * @return Delta text.
		 */
		public string diff_toDelta(List<Diff> diffs)
		{
			StringBuilder text = new StringBuilder();
			foreach(Diff aDiff in diffs) {
				switch(aDiff.operation) {
				case Operation.INSERT:
					text.Append("+").Append(encodeURI(aDiff.text)).Append("\t");
					break;
				case Operation.DELETE:
					text.Append("-").Append(aDiff.text.Length).Append("\t");
					break;
				case Operation.EQUAL:
					text.Append("=").Append(aDiff.text.Length).Append("\t");
					break;
				}
			}
			if(text.Length != 0) text.Length--;
			return text.ToString();
		}

		/**
		 * Given the original text1, and an encoded string which describes the
		 * operations required to transform text1 into text2, compute the full diff.
		 * @param text1 Source string for the diff.
		 * @param delta Delta text.
		 * @return Array of Diff objects or null if invalid.
		 * @throws ArgumentException If invalid input.
		 */
		public List<Diff> diff_fromDelta(string text1, string delta)
		{
			List<Diff> diffs = new List<Diff>();
			int pointer = 0;  // Cursor in text1
			string[] tokens = delta.Split('\t');
			foreach(string token in tokens) {
				if(token.Length == 0) {
					// Blank tokens are ok (from a trailing \t).
					continue;
				}
				// Each token begins with a one character parameter which specifies the
				// operation of this token (delete, insert, equality).
				string param = token.Substring(1);
				switch(token[0]) {
				case '+':
					param = decodeURI(param);
					diffs.Add(new Diff(Operation.INSERT, param));
					break;
				case '-':
				// Fall through.
				case '=':
					int n;
					try {
						n = Convert.ToInt32(param);
					}
					catch(FormatException e) {
						throw new ArgumentException(
							"Invalid number in diff_fromDelta: " + param, e);
					}
					if(n < 0) {
						throw new ArgumentException(
							"Negative number in diff_fromDelta: " + param);
					}
					string text;
					try {
						text = text1.Substring(pointer, n);
						pointer += n;
					}
					catch(ArgumentOutOfRangeException e) {
						throw new ArgumentException("Delta length (" + pointer
							+ ") larger than source text length (" + text1.Length
							+ ").", e);
					}
					if(token[0] == '=') {
						diffs.Add(new Diff(Operation.EQUAL, text));
					} else {
						diffs.Add(new Diff(Operation.DELETE, text));
					}
					break;
				default:
					// Anything else is an error.
					throw new ArgumentException(
						"Invalid diff operation in diff_fromDelta: " + token[0]);
				}
			}
			if(pointer != text1.Length) {
				throw new ArgumentException("Delta length (" + pointer
					+ ") smaller than source text length (" + text1.Length + ").");
			}
			return diffs;
		}


		//  MATCH FUNCTIONS


		/**
		 * Locate the best instance of 'pattern' in 'text' near 'loc'.
		 * Returns -1 if no match found.
		 * @param text The text to search.
		 * @param pattern The pattern to search for.
		 * @param loc The location to search around.
		 * @return Best match index or -1.
		 */
		public int match_main(string text, string pattern, int loc)
		{
			// Check for null inputs not needed since null can't be passed in C#.

			loc = Math.Max(0, Math.Min(loc, text.Length));
			if(text == pattern) {
				// Shortcut (potentially not guaranteed by the algorithm)
				return 0;
			} else if(text.Length == 0) {
				// Nothing to match.
				return -1;
			} else if(loc + pattern.Length <= text.Length
			  && text.Substring(loc, pattern.Length) == pattern) {
				// Perfect match at the perfect spot!  (Includes case of null pattern)
				return loc;
			} else {
				// Do a fuzzy compare.
				return match_bitap(text, pattern, loc);
			}
		}

		/**
		 * Locate the best instance of 'pattern' in 'text' near 'loc' using the
		 * Bitap algorithm.  Returns -1 if no match found.
		 * @param text The text to search.
		 * @param pattern The pattern to search for.
		 * @param loc The location to search around.
		 * @return Best match index or -1.
		 */
		protected int match_bitap(string text, string pattern, int loc)
		{
			// assert (Match_MaxBits == 0 || pattern.Length <= Match_MaxBits)
			//    : "Pattern too long for this application.";

			// Initialise the alphabet.
			Dictionary<char, int> s = match_alphabet(pattern);

			// Highest score beyond which we give up.
			double score_threshold = Match_Threshold;
			// Is there a nearby exact match? (speedup)
			int best_loc = text.IndexOf(pattern, loc, StringComparison.Ordinal);
			if(best_loc != -1) {
				score_threshold = Math.Min(match_bitapScore(0, best_loc, loc,
					pattern), score_threshold);
				// What about in the other direction? (speedup)
				best_loc = text.LastIndexOf(pattern,
					Math.Min(loc + pattern.Length, text.Length),
					StringComparison.Ordinal);
				if(best_loc != -1) {
					score_threshold = Math.Min(match_bitapScore(0, best_loc, loc,
						pattern), score_threshold);
				}
			}

			// Initialise the bit arrays.
			int matchmask = 1 << (pattern.Length - 1);
			best_loc = -1;

			int bin_min, bin_mid;
			int bin_max = pattern.Length + text.Length;
			// Empty initialization added to appease C# compiler.
			int[] last_rd = new int[0];
			for(int d = 0; d < pattern.Length; d++) {
				// Scan for the best match; each iteration allows for one more error.
				// Run a binary search to determine how far from 'loc' we can stray at
				// this error level.
				bin_min = 0;
				bin_mid = bin_max;
				while(bin_min < bin_mid) {
					if(match_bitapScore(d, loc + bin_mid, loc, pattern)
						<= score_threshold) {
						bin_min = bin_mid;
					} else {
						bin_max = bin_mid;
					}
					bin_mid = (bin_max - bin_min) / 2 + bin_min;
				}
				// Use the result from this iteration as the maximum for the next.
				bin_max = bin_mid;
				int start = Math.Max(1, loc - bin_mid + 1);
				int finish = Math.Min(loc + bin_mid, text.Length) + pattern.Length;

				int[] rd = new int[finish + 2];
				rd[finish + 1] = (1 << d) - 1;
				for(int j = finish; j >= start; j--) {
					int charMatch;
					if(text.Length <= j - 1 || !s.ContainsKey(text[j - 1])) {
						// Out of range.
						charMatch = 0;
					} else {
						charMatch = s[text[j - 1]];
					}
					if(d == 0) {
						// First pass: exact match.
						rd[j] = ((rd[j + 1] << 1) | 1) & charMatch;
					} else {
						// Subsequent passes: fuzzy match.
						rd[j] = ((rd[j + 1] << 1) | 1) & charMatch
							| (((last_rd[j + 1] | last_rd[j]) << 1) | 1) | last_rd[j + 1];
					}
					if((rd[j] & matchmask) != 0) {
						double score = match_bitapScore(d, j - 1, loc, pattern);
						// This match will almost certainly be better than any existing
						// match.  But check anyway.
						if(score <= score_threshold) {
							// Told you so.
							score_threshold = score;
							best_loc = j - 1;
							if(best_loc > loc) {
								// When passing loc, don't exceed our current distance from loc.
								start = Math.Max(1, 2 * loc - best_loc);
							} else {
								// Already passed loc, downhill from here on in.
								break;
							}
						}
					}
				}
				if(match_bitapScore(d + 1, loc, loc, pattern) > score_threshold) {
					// No hope for a (better) match at greater error levels.
					break;
				}
				last_rd = rd;
			}
			return best_loc;
		}

		/**
		 * Compute and return the score for a match with e errors and x location.
		 * @param e Number of errors in match.
		 * @param x Location of match.
		 * @param loc Expected location of match.
		 * @param pattern Pattern being sought.
		 * @return Overall score for match (0.0 = good, 1.0 = bad).
		 */
		private double match_bitapScore(int e, int x, int loc, string pattern)
		{
			float accuracy = (float)e / pattern.Length;
			int proximity = Math.Abs(loc - x);
			if(Match_Distance == 0) {
				// Dodge divide by zero error.
				return proximity == 0 ? accuracy : 1.0;
			}
			return accuracy + (proximity / (float)Match_Distance);
		}

		/**
		 * Initialise the alphabet for the Bitap algorithm.
		 * @param pattern The text to encode.
		 * @return Hash of character locations.
		 */
		protected Dictionary<char, int> match_alphabet(string pattern)
		{
			Dictionary<char, int> s = new Dictionary<char, int>();
			char[] char_pattern = pattern.ToCharArray();
			foreach(char c in char_pattern) {
				if(!s.ContainsKey(c)) {
					s.Add(c, 0);
				}
			}
			int i = 0;
			foreach(char c in char_pattern) {
				int value = s[c] | (1 << (pattern.Length - i - 1));
				s[c] = value;
				i++;
			}
			return s;
		}


		//  PATCH FUNCTIONS


		/**
		 * Increase the context until it is unique,
		 * but don't let the pattern expand beyond Match_MaxBits.
		 * @param patch The patch to grow.
		 * @param text Source text.
		 */
		protected void patch_addContext(Patch patch, string text)
		{
			if(text.Length == 0) {
				return;
			}
			string pattern = text.Substring(patch.start2, patch.length1);
			int padding = 0;

			// Look for the first and last matches of pattern in text.  If two
			// different matches are found, increase the pattern length.
			while(text.IndexOf(pattern, StringComparison.Ordinal)
				!= text.LastIndexOf(pattern, StringComparison.Ordinal)
				&& pattern.Length < Match_MaxBits - Patch_Margin - Patch_Margin) {
				padding += Patch_Margin;
				pattern = text.JavaSubstring(Math.Max(0, patch.start2 - padding),
					Math.Min(text.Length, patch.start2 + patch.length1 + padding));
			}
			// Add one chunk for good luck.
			padding += Patch_Margin;

			// Add the prefix.
			string prefix = text.JavaSubstring(Math.Max(0, patch.start2 - padding),
			  patch.start2);
			if(prefix.Length != 0) {
				patch.diffs.Insert(0, new Diff(Operation.EQUAL, prefix));
			}
			// Add the suffix.
			string suffix = text.JavaSubstring(patch.start2 + patch.length1,
				Math.Min(text.Length, patch.start2 + patch.length1 + padding));
			if(suffix.Length != 0) {
				patch.diffs.Add(new Diff(Operation.EQUAL, suffix));
			}

			// Roll back the start points.
			patch.start1 -= prefix.Length;
			patch.start2 -= prefix.Length;
			// Extend the lengths.
			patch.length1 += prefix.Length + suffix.Length;
			patch.length2 += prefix.Length + suffix.Length;
		}

		/**
		 * Compute a list of patches to turn text1 into text2.
		 * A set of diffs will be computed.
		 * @param text1 Old text.
		 * @param text2 New text.
		 * @return List of Patch objects.
		 */
		public List<Patch> patch_make(string text1, string text2)
		{
			// Check for null inputs not needed since null can't be passed in C#.
			// No diffs provided, compute our own.
			List<Diff> diffs = diff_main(text1, text2, true);
			if(diffs.Count > 2) {
				diff_cleanupSemantic(diffs);
				diff_cleanupEfficiency(diffs);
			}
			return patch_make(text1, diffs);
		}

		/**
		 * Compute a list of patches to turn text1 into text2.
		 * text1 will be derived from the provided diffs.
		 * @param diffs Array of Diff objects for text1 to text2.
		 * @return List of Patch objects.
		 */
		public List<Patch> patch_make(List<Diff> diffs)
		{
			// Check for null inputs not needed since null can't be passed in C#.
			// No origin string provided, compute our own.
			string text1 = diff_text1(diffs);
			return patch_make(text1, diffs);
		}

		/**
		 * Compute a list of patches to turn text1 into text2.
		 * text2 is ignored, diffs are the delta between text1 and text2.
		 * @param text1 Old text
		 * @param text2 Ignored.
		 * @param diffs Array of Diff objects for text1 to text2.
		 * @return List of Patch objects.
		 * @deprecated Prefer patch_make(string text1, List&lt;Diff&gt; diffs).
		 */
		public List<Patch> patch_make(string text1, string text2,
			List<Diff> diffs)
		{
			return patch_make(text1, diffs);
		}

		/**
		 * Compute a list of patches to turn text1 into text2.
		 * text2 is not provided, diffs are the delta between text1 and text2.
		 * @param text1 Old text.
		 * @param diffs Array of Diff objects for text1 to text2.
		 * @return List of Patch objects.
		 */
		public List<Patch> patch_make(string text1, List<Diff> diffs)
		{
			// Check for null inputs not needed since null can't be passed in C#.
			List<Patch> patches = new List<Patch>();
			if(diffs.Count == 0) {
				return patches;  // Get rid of the null case.
			}
			Patch patch = new Patch();
			int char_count1 = 0;  // Number of characters into the text1 string.
			int char_count2 = 0;  // Number of characters into the text2 string.
								  // Start with text1 (prepatch_text) and apply the diffs until we arrive at
								  // text2 (postpatch_text). We recreate the patches one by one to determine
								  // context info.
			string prepatch_text = text1;
			string postpatch_text = text1;
			foreach(Diff aDiff in diffs) {
				if(patch.diffs.Count == 0 && aDiff.operation != Operation.EQUAL) {
					// A new patch starts here.
					patch.start1 = char_count1;
					patch.start2 = char_count2;
				}

				switch(aDiff.operation) {
				case Operation.INSERT:
					patch.diffs.Add(aDiff);
					patch.length2 += aDiff.text.Length;
					postpatch_text = postpatch_text.Insert(char_count2, aDiff.text);
					break;
				case Operation.DELETE:
					patch.length1 += aDiff.text.Length;
					patch.diffs.Add(aDiff);
					postpatch_text = postpatch_text.Remove(char_count2,
						aDiff.text.Length);
					break;
				case Operation.EQUAL:
					if(aDiff.text.Length <= 2 * Patch_Margin
						&& patch.diffs.Count != 0 && aDiff != diffs.Last()) {
						// Small equality inside a patch.
						patch.diffs.Add(aDiff);
						patch.length1 += aDiff.text.Length;
						patch.length2 += aDiff.text.Length;
					}

					if(aDiff.text.Length >= 2 * Patch_Margin) {
						// Time for a new patch.
						if(patch.diffs.Count != 0) {
							patch_addContext(patch, prepatch_text);
							patches.Add(patch);
							patch = new Patch();
							// Unlike Unidiff, our patch lists have a rolling context.
							// https://github.com/google/diff-match-patch/wiki/Unidiff
							// Update prepatch text & pos to reflect the application of the
							// just completed patch.
							prepatch_text = postpatch_text;
							char_count1 = char_count2;
						}
					}
					break;
				}

				// Update the current character count.
				if(aDiff.operation != Operation.INSERT) {
					char_count1 += aDiff.text.Length;
				}
				if(aDiff.operation != Operation.DELETE) {
					char_count2 += aDiff.text.Length;
				}
			}
			// Pick up the leftover patch if not empty.
			if(patch.diffs.Count != 0) {
				patch_addContext(patch, prepatch_text);
				patches.Add(patch);
			}

			return patches;
		}

		/**
		 * Given an array of patches, return another array that is identical.
		 * @param patches Array of Patch objects.
		 * @return Array of Patch objects.
		 */
		public List<Patch> patch_deepCopy(List<Patch> patches)
		{
			List<Patch> patchesCopy = new List<Patch>();
			foreach(Patch aPatch in patches) {
				Patch patchCopy = new Patch();
				foreach(Diff aDiff in aPatch.diffs) {
					Diff diffCopy = new Diff(aDiff.operation, aDiff.text);
					patchCopy.diffs.Add(diffCopy);
				}
				patchCopy.start1 = aPatch.start1;
				patchCopy.start2 = aPatch.start2;
				patchCopy.length1 = aPatch.length1;
				patchCopy.length2 = aPatch.length2;
				patchesCopy.Add(patchCopy);
			}
			return patchesCopy;
		}

		/**
		 * Merge a set of patches onto the text.  Return a patched text, as well
		 * as an array of true/false values indicating which patches were applied.
		 * @param patches Array of Patch objects
		 * @param text Old text.
		 * @return Two element Object array, containing the new text and an array of
		 *      bool values.
		 */
		public Object[] patch_apply(List<Patch> patches, string text)
		{
			if(patches.Count == 0) {
				return new Object[] { text, new bool[0] };
			}

			// Deep copy the patches so that no changes are made to originals.
			patches = patch_deepCopy(patches);

			string nullPadding = this.patch_addPadding(patches);
			text = nullPadding + text + nullPadding;
			patch_splitMax(patches);

			int x = 0;
			// delta keeps track of the offset between the expected and actual
			// location of the previous patch.  If there are patches expected at
			// positions 10 and 20, but the first patch was found at 12, delta is 2
			// and the second patch has an effective expected position of 22.
			int delta = 0;
			bool[] results = new bool[patches.Count];
			foreach(Patch aPatch in patches) {
				int expected_loc = aPatch.start2 + delta;
				string text1 = diff_text1(aPatch.diffs);
				int start_loc;
				int end_loc = -1;
				if(text1.Length > Match_MaxBits) {
					// patch_splitMax will only provide an oversized pattern
					// in the case of a monster delete.
					start_loc = match_main(text,
						text1.Substring(0, Match_MaxBits), expected_loc);
					if(start_loc != -1) {
						end_loc = match_main(text,
							text1.Substring(text1.Length - Match_MaxBits),
							expected_loc + text1.Length - Match_MaxBits);
						if(end_loc == -1 || start_loc >= end_loc) {
							// Can't find valid trailing context.  Drop this patch.
							start_loc = -1;
						}
					}
				} else {
					start_loc = this.match_main(text, text1, expected_loc);
				}
				if(start_loc == -1) {
					// No match found.  :(
					results[x] = false;
					// Subtract the delta for this failed patch from subsequent patches.
					delta -= aPatch.length2 - aPatch.length1;
				} else {
					// Found a match.  :)
					results[x] = true;
					delta = start_loc - expected_loc;
					string text2;
					if(end_loc == -1) {
						text2 = text.JavaSubstring(start_loc,
							Math.Min(start_loc + text1.Length, text.Length));
					} else {
						text2 = text.JavaSubstring(start_loc,
							Math.Min(end_loc + Match_MaxBits, text.Length));
					}
					if(text1 == text2) {
						// Perfect match, just shove the Replacement text in.
						text = text.Substring(0, start_loc) + diff_text2(aPatch.diffs)
							+ text.Substring(start_loc + text1.Length);
					} else {
						// Imperfect match.  Run a diff to get a framework of equivalent
						// indices.
						List<Diff> diffs = diff_main(text1, text2, false);
						if(text1.Length > Match_MaxBits
							&& this.diff_levenshtein(diffs) / (float)text1.Length
							> this.Patch_DeleteThreshold) {
							// The end points match, but the content is unacceptably bad.
							results[x] = false;
						} else {
							diff_cleanupSemanticLossless(diffs);
							int index1 = 0;
							foreach(Diff aDiff in aPatch.diffs) {
								if(aDiff.operation != Operation.EQUAL) {
									int index2 = diff_xIndex(diffs, index1);
									if(aDiff.operation == Operation.INSERT) {
										// Insertion
										text = text.Insert(start_loc + index2, aDiff.text);
									} else if(aDiff.operation == Operation.DELETE) {
										// Deletion
										text = text.Remove(start_loc + index2, diff_xIndex(diffs,
											index1 + aDiff.text.Length) - index2);
									}
								}
								if(aDiff.operation != Operation.DELETE) {
									index1 += aDiff.text.Length;
								}
							}
						}
					}
				}
				x++;
			}
			// Strip the padding off.
			text = text.Substring(nullPadding.Length, text.Length
				- 2 * nullPadding.Length);
			return new Object[] { text, results };
		}

		/**
		 * Add some padding on text start and end so that edges can match something.
		 * Intended to be called only from within patch_apply.
		 * @param patches Array of Patch objects.
		 * @return The padding string added to each side.
		 */
		public string patch_addPadding(List<Patch> patches)
		{
			short paddingLength = this.Patch_Margin;
			string nullPadding = string.Empty;
			for(short x = 1; x <= paddingLength; x++) {
				nullPadding += (char)x;
			}

			// Bump all the patches forward.
			foreach(Patch aPatch in patches) {
				aPatch.start1 += paddingLength;
				aPatch.start2 += paddingLength;
			}

			// Add some padding on start of first diff.
			Patch patch = patches.First();
			List<Diff> diffs = patch.diffs;
			if(diffs.Count == 0 || diffs.First().operation != Operation.EQUAL) {
				// Add nullPadding equality.
				diffs.Insert(0, new Diff(Operation.EQUAL, nullPadding));
				patch.start1 -= paddingLength;  // Should be 0.
				patch.start2 -= paddingLength;  // Should be 0.
				patch.length1 += paddingLength;
				patch.length2 += paddingLength;
			} else if(paddingLength > diffs.First().text.Length) {
				// Grow first equality.
				Diff firstDiff = diffs.First();
				int extraLength = paddingLength - firstDiff.text.Length;
				firstDiff.text = nullPadding.Substring(firstDiff.text.Length)
					+ firstDiff.text;
				patch.start1 -= extraLength;
				patch.start2 -= extraLength;
				patch.length1 += extraLength;
				patch.length2 += extraLength;
			}

			// Add some padding on end of last diff.
			patch = patches.Last();
			diffs = patch.diffs;
			if(diffs.Count == 0 || diffs.Last().operation != Operation.EQUAL) {
				// Add nullPadding equality.
				diffs.Add(new Diff(Operation.EQUAL, nullPadding));
				patch.length1 += paddingLength;
				patch.length2 += paddingLength;
			} else if(paddingLength > diffs.Last().text.Length) {
				// Grow last equality.
				Diff lastDiff = diffs.Last();
				int extraLength = paddingLength - lastDiff.text.Length;
				lastDiff.text += nullPadding.Substring(0, extraLength);
				patch.length1 += extraLength;
				patch.length2 += extraLength;
			}

			return nullPadding;
		}

		/**
		 * Look through the patches and break up any which are longer than the
		 * maximum limit of the match algorithm.
		 * Intended to be called only from within patch_apply.
		 * @param patches List of Patch objects.
		 */
		public void patch_splitMax(List<Patch> patches)
		{
			short patch_size = Match_MaxBits;
			for(int x = 0; x < patches.Count; x++) {
				if(patches[x].length1 <= patch_size) {
					continue;
				}
				Patch bigpatch = patches[x];
				// Remove the big old patch.
				patches.Splice(x--, 1);
				int start1 = bigpatch.start1;
				int start2 = bigpatch.start2;
				string precontext = string.Empty;
				while(bigpatch.diffs.Count != 0) {
					// Create one of several smaller patches.
					Patch patch = new Patch();
					bool empty = true;
					patch.start1 = start1 - precontext.Length;
					patch.start2 = start2 - precontext.Length;
					if(precontext.Length != 0) {
						patch.length1 = patch.length2 = precontext.Length;
						patch.diffs.Add(new Diff(Operation.EQUAL, precontext));
					}
					while(bigpatch.diffs.Count != 0
						&& patch.length1 < patch_size - this.Patch_Margin) {
						Operation diff_type = bigpatch.diffs[0].operation;
						string diff_text = bigpatch.diffs[0].text;
						if(diff_type == Operation.INSERT) {
							// Insertions are harmless.
							patch.length2 += diff_text.Length;
							start2 += diff_text.Length;
							patch.diffs.Add(bigpatch.diffs.First());
							bigpatch.diffs.RemoveAt(0);
							empty = false;
						} else if(diff_type == Operation.DELETE && patch.diffs.Count == 1
							&& patch.diffs.First().operation == Operation.EQUAL
							&& diff_text.Length > 2 * patch_size) {
							// This is a large deletion.  Let it pass in one chunk.
							patch.length1 += diff_text.Length;
							start1 += diff_text.Length;
							empty = false;
							patch.diffs.Add(new Diff(diff_type, diff_text));
							bigpatch.diffs.RemoveAt(0);
						} else {
							// Deletion or equality.  Only take as much as we can stomach.
							diff_text = diff_text.Substring(0, Math.Min(diff_text.Length,
								patch_size - patch.length1 - Patch_Margin));
							patch.length1 += diff_text.Length;
							start1 += diff_text.Length;
							if(diff_type == Operation.EQUAL) {
								patch.length2 += diff_text.Length;
								start2 += diff_text.Length;
							} else {
								empty = false;
							}
							patch.diffs.Add(new Diff(diff_type, diff_text));
							if(diff_text == bigpatch.diffs[0].text) {
								bigpatch.diffs.RemoveAt(0);
							} else {
								bigpatch.diffs[0].text =
									bigpatch.diffs[0].text.Substring(diff_text.Length);
							}
						}
					}
					// Compute the head context for the next patch.
					precontext = this.diff_text2(patch.diffs);
					precontext = precontext.Substring(Math.Max(0,
						precontext.Length - this.Patch_Margin));

					string postcontext = null;
					// Append the end context for this patch.
					if(diff_text1(bigpatch.diffs).Length > Patch_Margin) {
						postcontext = diff_text1(bigpatch.diffs)
							.Substring(0, Patch_Margin);
					} else {
						postcontext = diff_text1(bigpatch.diffs);
					}

					if(postcontext.Length != 0) {
						patch.length1 += postcontext.Length;
						patch.length2 += postcontext.Length;
						if(patch.diffs.Count != 0
							&& patch.diffs[patch.diffs.Count - 1].operation
							== Operation.EQUAL) {
							patch.diffs[patch.diffs.Count - 1].text += postcontext;
						} else {
							patch.diffs.Add(new Diff(Operation.EQUAL, postcontext));
						}
					}
					if(!empty) {
						patches.Splice(++x, 0, patch);
					}
				}
			}
		}

		/**
		 * Take a list of patches and return a textual representation.
		 * @param patches List of Patch objects.
		 * @return Text representation of patches.
		 */
		public string patch_toText(List<Patch> patches)
		{
			StringBuilder text = new StringBuilder();
			foreach(Patch aPatch in patches) {
				text.Append(aPatch);
			}
			return text.ToString();
		}

		/**
		 * Parse a textual representation of patches and return a List of Patch
		 * objects.
		 * @param textline Text representation of patches.
		 * @return List of Patch objects.
		 * @throws ArgumentException If invalid input.
		 */
		public List<Patch> patch_fromText(string textline)
		{
			List<Patch> patches = new List<Patch>();
			if(textline.Length == 0) {
				return patches;
			}
			string[] text = textline.Split('\n');
			int textPointer = 0;
			Patch patch;
			Regex patchHeader
				= new Regex("^@@ -(\\d+),?(\\d*) \\+(\\d+),?(\\d*) @@$");
			Match m;
			char sign;
			string line;
			while(textPointer < text.Length) {
				m = patchHeader.Match(text[textPointer]);
				if(!m.Success) {
					throw new ArgumentException("Invalid patch string: "
						+ text[textPointer]);
				}
				patch = new Patch();
				patches.Add(patch);
				patch.start1 = Convert.ToInt32(m.Groups[1].Value);
				if(m.Groups[2].Length == 0) {
					patch.start1--;
					patch.length1 = 1;
				} else if(m.Groups[2].Value == "0") {
					patch.length1 = 0;
				} else {
					patch.start1--;
					patch.length1 = Convert.ToInt32(m.Groups[2].Value);
				}

				patch.start2 = Convert.ToInt32(m.Groups[3].Value);
				if(m.Groups[4].Length == 0) {
					patch.start2--;
					patch.length2 = 1;
				} else if(m.Groups[4].Value == "0") {
					patch.length2 = 0;
				} else {
					patch.start2--;
					patch.length2 = Convert.ToInt32(m.Groups[4].Value);
				}
				textPointer++;

				while(textPointer < text.Length) {
					try {
						sign = text[textPointer][0];
					}
					catch(IndexOutOfRangeException) {
						// Blank line?  Whatever.
						textPointer++;
						continue;
					}
					line = text[textPointer].Substring(1);
					line = decodeURI(line);
					if(sign == '-') {
						// Deletion.
						patch.diffs.Add(new Diff(Operation.DELETE, line));
					} else if(sign == '+') {
						// Insertion.
						patch.diffs.Add(new Diff(Operation.INSERT, line));
					} else if(sign == ' ') {
						// Minor equality.
						patch.diffs.Add(new Diff(Operation.EQUAL, line));
					} else if(sign == '@') {
						// Start of next patch.
						break;
					} else {
						// WTF?
						throw new ArgumentException(
							"Invalid patch mode '" + sign + "' in: " + line);
					}
					textPointer++;
				}
			}
			return patches;
		}

#if true
		internal static string encodeURI(string str)
		{
			return str.Escape();
		}

		static string decodeURI(string str)
		{
			if(!str.Unescape(out var r)) throw new ArgumentException("Invalid diff delta string escaping.");
			return r;
		}
#else //uses System.Web.dll
		/**
		 * Encodes a string with URI-style % escaping.
		 * Compatible with JavaScript's encodeURI function.
		 *
		 * @param str The string to encode.
		 * @return The encoded string.
		 */
		static string encodeURI(string str)
		{
			// C# is overzealous in the replacements.  Walk back on a few.
			return new StringBuilder(HttpUtility.UrlEncode(str))
				.Replace('+', ' ').Replace("%20", " ").Replace("%21", "!")
				.Replace("%2a", "*").Replace("%27", "'").Replace("%28", "(")
				.Replace("%29", ")").Replace("%3b", ";").Replace("%2f", "/")
				.Replace("%3f", "?").Replace("%3a", ":").Replace("%40", "@")
				.Replace("%26", "&").Replace("%3d", "=").Replace("%2b", "+")
				.Replace("%24", "$").Replace("%2c", ",").Replace("%23", "#")
				.Replace("%7e", "~")
				.ToString();
		}

		static string decodeURI(string str)
		{
			return HttpUtility.UrlDecode(str.Replace("+", "%2b"));
		}
#endif
	}
}


================================================
FILE: Au.Editor/xUtil/Libs/EnglishPorter2Stemmer.cs
================================================
//https://github.com/nemec/porter2-stemmer

#pragma warning disable 1591 //no XML comment

namespace Libs.Porter2Stemmer;

/// <summary>
/// Based off of the improved Porter2 algorithm:
/// http://snowball.tartarus.org/algorithms/english/stemmer.html
/// </summary>
public class EnglishPorter2Stemmer {

	private readonly char[] _alphabet =
		Enumerable
			.Range('a', 'z' - 'a' + 1)
			.Select(c => (char)c)
			.Concat(new[] { '\'' }).ToArray();
	public char[] Alphabet { get { return _alphabet; } }

	private readonly char[] _vowels = "aeiouy".ToArray();
	public char[] Vowels { get { return _vowels; } }

	private readonly string[] _doubles =
		{ "bb", "dd", "ff", "gg", "mm", "nn", "pp", "rr", "tt" };
	public string[] Doubles { get { return _doubles; } }

	private readonly char[] _liEndings = "cdeghkmnrt".ToArray();
	public char[] LiEndings { get { return _liEndings; } }

	private readonly char[] _nonShortConsonants = "wxY".ToArray();

	private readonly Dictionary<string, string> _exceptions = new Dictionary<string, string>
		{
				{"skis", "ski"},
				{"skies", "sky"},
				{"dying", "die"},
				{"lying", "lie"},
				{"tying", "tie"},
				{"idly", "idl"},
				{"gently", "gentl"},
				{"ugly", "ugli"},
				{"early", "earli"},
				{"only", "onli"},
				{"singly", "singl"},
				{"sky", "sky"},
				{"news", "news"},
				{"howe", "howe"},
				{"atlas", "atlas"},
				{"cosmos", "cosmos"},
				{"bias", "bias"},
				{"andes", "andes"}
			};

	private readonly string[] _exceptionsPart2 = new[]
		{
				"inning", "outing", "canning", "herring", "earring",
				"proceed", "exceed", "succeed"
			};

	private readonly string[] _exceptionsRegion1 = new[]
		{
				"gener", "arsen", "commun"
			};

	public string Stem(string word) {
		if (word.Length <= 2) {
			return word;
		}

		word = TrimStartingApostrophe(word.ToLowerInvariant());

		string excpt;
		if (_exceptions.TryGetValue(word, out excpt)) {
			return excpt;
		}

		word = MarkYsAsConsonants(word);

		var r1 = GetRegion1(word);
		var r2 = GetRegion2(word);

		word = Step0RemoveSPluralSuffix(word);
		word = Step1ARemoveOtherSPluralSuffixes(word);

		if (_exceptionsPart2.Contains(word)) {
			return word;
		}

		word = Step1BRemoveLySuffixes(word, r1);
		word = Step1CReplaceSuffixYWithIIfPreceededWithConsonant(word);
		word = Step2ReplaceSuffixes(word, r1);
		word = Step3ReplaceSuffixes(word, r1, r2);
		word = Step4RemoveSomeSuffixesInR2(word, r2);
		word = Step5RemoveEorLSuffixes(word, r1, r2);

		return word.ToLowerInvariant();
	}

	private bool IsVowel(char c) {
		return Vowels.Contains(c);
	}

	private bool IsConsonant(char c) {
		return !Vowels.Contains(c);
	}

	private static bool SuffixInR1(string word, int r1, string suffix) {
		return r1 <= word.Length - suffix.Length;
	}

	private bool SuffixInR2(string word, int r2, string suffix) {
		return r2 <= word.Length - suffix.Length;
	}

	private static string ReplaceSuffix(string word, string oldSuffix, string newSuffix = null) {
		if (oldSuffix != null) {
			word = word.Substring(0, word.Length - oldSuffix.Length);
		}

		if (newSuffix != null) {
			word += newSuffix;
		}
		return word;
	}

	private static bool TryReplace(string word, string oldSuffix, string newSuffix, out string final) {
		if (word.Contains(oldSuffix)) {
			final = ReplaceSuffix(word, oldSuffix, newSuffix);
			return true;
		}
		final = word;
		return false;
	}

	/// <summary>
	/// The English stemmer treats apostrophe as a letter, removing it from the beginning of a word, where it might have stood for an opening quote, from the end of the word, where it might have stood for a closing quote, or been an apostrophe following s.
	/// </summary>
	/// <param name="word"></param>
	/// <returns></returns>
	private static string TrimStartingApostrophe(string word) {
		if (word.StartsWith("'")) {
			word = word.Substring(1);
		}
		return word;
	}

	/// <summary>
	/// R1 is the region after the first non-vowel following a vowel, or the end of the word if there is no such non-vowel. 
	/// </summary>
	/// <param name="word"></param>
	/// <returns></returns>
	public int GetRegion1(string word) {
		// Exceptional forms
		foreach (var except in _exceptionsRegion1.Where(word.StartsWith)) {
			return except.Length;
		}
		return GetRegion(word, 0);
	}

	/// <summary>
	/// R2 is the region after the first non-vowel following a vowel in R1, or the end of the word if there is no such non-vowel. 
	/// </summary>
	/// <param name="word"></param>
	/// <returns></returns>
	public int GetRegion2(string word) {
		var r1 = GetRegion1(word);
		return GetRegion(word, r1);
	}

	private int GetRegion(string word, int begin) {
		var foundVowel = false;
		for (var i = begin; i < word.Length; i++) {
			if (IsVowel(word[i])) {
				foundVowel = true;
				continue;
			}
			if (foundVowel && IsConsonant(word[i])) {
				return i + 1;
			}
		}

		return word.Length;
	}

	/// <summary>
	/// Define a short syllable in a word as either (a) a vowel followed 
	/// by a non-vowel other than w, x or Y and preceded by a non-vowel, 
	/// or * (b) a vowel at the beginning of the word followed by a non-vowel. 
	/// </summary>
	/// <param name="word"></param>
	/// <returns></returns>
	public bool EndsInShortSyllable(string word) {
		if (word.Length < 2) {
			return false;
		}

		// a vowel at the beginning of the word followed by a non-vowel
		if (word.Length == 2) {
			return IsVowel(word[0]) && IsConsonant(word[1]);
		}

		return IsVowel(word[word.Length - 2])
			   && IsConsonant(word[word.Length - 1])
			   && !_nonShortConsonants.Contains(word[word.Length - 1])
			   && IsConsonant(word[word.Length - 3]);
	}

	/// <summary>
	/// A word is called short if it ends in a short syllable, and if R1 is null.
	/// </summary>
	/// <param name="word"></param>
	/// <returns></returns>
	public bool IsShortWord(string word) {
		return EndsInShortSyllable(word) && GetRegion1(word) == word.Length;
	}

	/// <summary>
	/// Set initial y, or y after a vowel, to Y
	/// </summary>
	/// <param name="word"></param>
	/// <returns></returns>
	public string MarkYsAsConsonants(string word) {
		var chars = word.ToCharArray();
		for (var i = 0; i < chars.Length; i++) {
			if (i == 0) {
				if (chars[i] == 'y') {
					chars[i] = 'Y';
				}
			} else if (Vowels.Contains(chars[i - 1]) && chars[i] == 'y') {
				chars[i] = 'Y';
			}
		}
		return new string(chars);
	}

	public string Step0RemoveSPluralSuffix(string word) {
		// Ordered from longest to shortest
		var suffixes = new[] { "'s'", "'s", "'" };
		foreach (var suffix in suffixes) {
			if (word.EndsWith(suffix)) {
				return ReplaceSuffix(word, suffix);
			}
		}
		return word;
	}

	public string Step1ARemoveOtherSPluralSuffixes(string word) {
		if (word.EndsWith("sses")) {
			return ReplaceSuffix(word, "sses", "ss");
		}
		if (word.EndsWith("ied") || word.EndsWith("ies")) {
			var restOfWord = word.Substring(0, word.Length - 3);
			if (word.Length > 4) {
				return restOfWord + "i";
			}
			return restOfWord + "ie";
		}
		if (word.EndsWith("us") || word.EndsWith("ss")) {
			return word;
		}
		if (word.EndsWith("s")) {
			if (word.Length < 3) {
				return word;
			}

			// Skip both the last letter ('s') and the letter before that
			for (var i = 0; i < word.Length - 2; i++) {
				if (IsVowel(word[i])) {
					return word.Substring(0, word.Length - 1);
				}
			}
		}
		return word;
	}

	public string Step1BRemoveLySuffixes(string word, int r1) {
		foreach (var suffix in new[] { "eedly", "eed" }.Where(word.EndsWith)) {
			if (SuffixInR1(word, r1, suffix)) {
				return ReplaceSuffix(word, suffix, "ee");
			}
			return word;
		}

		foreach (var suffix in new[] { "ed", "edly", "ing", "ingly" }.Where(word.EndsWith)) {
			var trunc = ReplaceSuffix(word, suffix);//word.Substring(0, word.Length - suffix.Length);
			if (trunc.Any(IsVowel)) {
				if (new[] { "at", "bl", "iz" }.Any(trunc.EndsWith)) {
					return trunc + "e";
				}
				if (Doubles.Any(trunc.EndsWith)) {
					return trunc.Substring(0, trunc.Length - 1);
				}
				if (IsShortWord(trunc)) {
					return trunc + "e";
				}
				return trunc;
			}
			return word;
		}

		return word;
	}

	public string Step1CReplaceSuffixYWithIIfPreceededWithConsonant(string word) {
		if ((word.EndsWith("y") || word.EndsWith("Y"))
			&& word.Length > 2
			&& IsConsonant(word[word.Length - 2])) {
			return word.Substring(0, word.Length - 1) + "i";
		}
		return word;
	}

	public string Step2ReplaceSuffixes(string word, int r1) {
		var suffixes = new Dictionary<string, string>
			{
					{"ization", "ize"},
					{"ational", "ate"},
					{"ousness", "ous"},
					{"iveness", "ive"},
					{"fulness", "ful"},
					{"tional", "tion"},
					{"lessli", "less"},
					{"biliti", "ble"},
					{"entli", "ent"},
					{"ation", "ate"},
					{"alism", "al"},
					{"aliti", "al"},
					{"fulli", "ful"},
					{"ousli", "ous"},
					{"iviti", "ive"},
					{"enci", "ence"},
					{"anci", "ance"},
					{"abli", "able"},
					{"izer", "ize"},
					{"ator", "ate"},
					{"alli", "al"},
					{"bli", "ble"}
				};
		foreach (var suffix in suffixes) {
			if (word.EndsWith(suffix.Key)) {
				string final;
				if (SuffixInR1(word, r1, suffix.Key)
					&& TryReplace(word, suffix.Key, suffix.Value, out final)) {
					return final;
				}
				return word;
			}
		}

		if (word.EndsWith("ogi")
			&& SuffixInR1(word, r1, "ogi")
			&& word[word.Length - 4] == 'l') {
			return ReplaceSuffix(word, "ogi", "og");
		}

		if (word.EndsWith("li") & SuffixInR1(word, r1, "li")) {
			if (LiEndings.Contains(word[word.Length - 3])) {
				return ReplaceSuffix(word, "li");
			}
		}

		return word;
	}

	public string Step3ReplaceSuffixes(string word, int r1, int r2) {
		var suffixes = new Dictionary<string, string>
			{
					{"ational", "ate"},
					{"tional", "tion"},
					{"alize", "al"},
					{"icate", "ic"},
					{"iciti", "ic"},
					{"ical", "ic"},
					{"ful", null},
					{"ness", null}
				};
		foreach (var suffix in suffixes.Where(s => word.EndsWith(s.Key))) {
			string final;
			if (SuffixInR1(word, r1, suffix.Key)
				&& TryReplace(word, suffix.Key, suffix.Value, out final)) {
				return final;
			}
		}

		if (word.EndsWith("ative")) {
			if (SuffixInR1(word, r1, "ative") && SuffixInR2(word, r2, "ative")) {
				return ReplaceSuffix(word, "ative", null);
			}
		}

		return word;
	}

	public string Step4RemoveSomeSuffixesInR2(string word, int r2) {
		foreach (var suffix in new[]
			{
					"al", "ance", "ence", "er", "ic", "able", "ible", "ant",
					"ement", "ment", "ent", "ism", "ate", "iti", "ous",
					"ive", "ize"
				}) {
			if (word.EndsWith(suffix)) {
				if (SuffixInR2(word, r2, suffix)) {
					return ReplaceSuffix(word, suffix);
				}
				return word;
			}
		}

		if (word.EndsWith("ion") &&
			SuffixInR2(word, r2, "ion") &&
			new[] { 's', 't' }.Contains(word[word.Length - 4])) {
			return ReplaceSuffix(word, "ion");
		}
		return word;
	}

	public string Step5RemoveEorLSuffixes(string word, int r1, int r2) {
		if (word.EndsWith("e") &&
			(SuffixInR2(word, r2, "e") ||
				(SuffixInR1(word, r1, "e") &&
					!EndsInShortSyllable(ReplaceSuffix(word, "e"))))) {
			return ReplaceSuffix(word, "e");
		}

		if (word.EndsWith("l") &&
			SuffixInR2(word, r2, "l") &&
			word.Length > 1 &&
			word[word.Length - 2] == 'l') {
			return ReplaceSuffix(word, "l");
		}

		return word;
	}
}


================================================
FILE: Au.Editor/xUtil/MetaCommentsParser.cs
================================================

namespace LA;

/// <seealso cref="MetaComments.FindMetaComments"/>
/// <seealso cref="MetaComments.EnumOptions"/>
class MetaCommentsParser {
	FileNode _fn;
	public string role, ifRunning, uac, platform,
		optimize, warningLevel, noWarnings, nullable, testInternal, define, preBuild, postBuild,
		outputPath, console, icon, manifest, sign, xmlDoc, miscFlags, noRef, startFaster;
	List<string> _pr, _r, _com, _nuget, _c, _resource, _file, _disabled;
	
	public List<string> pr => _pr ??= new();
	public List<string> r => _r ??= new();
	public List<string> com => _com ??= new();
	public List<string> nuget => _nuget ??= new();
	public List<string> c => _c ??= new();
	public List<string> resource => _resource ??= new();
	public List<string> file => _file ??= new();
	
	public MetaCommentsParser(FileNode f) : this(f.GetCurrentText(out var s) ? s : "") { _fn = f; }
	
	public MetaCommentsParser(string code) {
		var meta = MetaComments.FindMetaComments(code);
		if (meta.end == 0) return;
		MetaRange = meta;
		foreach (var t in MetaComments.EnumOptions(code, meta)) _ParseOption(t.Name, t.Value);
		Multiline = code[meta.start..meta.end].Contains('\n');
	}
	
	public StartEnd MetaRange { get; private set; }
	
	void _ParseOption(string name, string value) {
		switch (name) {
		case "role": role = value; break;
		case "outputPath": outputPath = value; break;
		case "ifRunning": ifRunning = value; break;
		case "uac": uac = value; break;
		case "platform": platform = value; break;
		case "bit32": platform = value is "true" or "!false" ? "x86" : "x64"; break; //fbc
		case "optimize": optimize = value; break;
		case "warningLevel": warningLevel = value; break;
		case "noWarnings": noWarnings = value; break;
		case "nullable": nullable = value; break;
		case "testInternal": testInternal = value; break;
		case "define": define = value; break;
		case "preBuild": preBuild = value; break;
		case "postBuild": postBuild = value; break;
		case "console": console = value; break;
		case "icon": icon = value; break;
		case "manifest": manifest = value; break;
		case "sign": sign = value; break;
		case "xmlDoc": xmlDoc = value; break;
		case "miscFlags": miscFlags = value; break;
		case "noRef": noRef = value; break;
		case "startFaster": startFaster = value; break;
		case "pr": pr.Add(value); break;
		case "r": r.Add(value); break;
		case "com": com.Add(value); break;
		case "nuget": nuget.Add(value.Replace('/', '\\')); break;
		case "c": c.Add(value); break;
		case "resource": resource.Add(value); break;
		case "file": file.Add(value); break;
		case null: (_disabled ??= new()).Add(value); break;
		}
	}
	
	/// <summary>
	/// Formats metacomments string "/*/ ... /*/".
	/// Returns "" if there are no options.
	/// </summary>
	public string Format(string prepend, string append) {
		//prepare to make relative paths
		string dir = null;
		if (_fn != null) {
			dir = _fn.ItemPath;
			int i = dir.LastIndexOf('\\') + 1;
			if (i > 1) dir = dir.Remove(i); else dir = null;
		}
		
		var sep = Multiline ? "\r\n" : "; ";
		var b = new StringBuilder();
		b.Append(prepend).Append(Multiline ? "/*/\r\n" : "/*/ ");
		_Append("role", role); //must be the first
		
		_Append("ifRunning", ifRunning);
		_Append("uac", uac);
		
		_Append("optimize", optimize);
		_Append("define", define);
		_Append("warningLevel", warningLevel);
		_Append("noWarnings", noWarnings);
		_Append("nullable", nullable);
		_Append("testInternal", testInternal);
		_Append("preBuild", preBuild, true);
		_Append("postBuild", postBuild, true);
		
		_Append("outputPath", outputPath);
		_Append("icon", icon, true);
		_Append("manifest", manifest, true);
		_Append("sign", sign, true);
		_Append("console", console);
		_Append("platform", platform);
		_Append("xmlDoc", xmlDoc);
		
		_Append("miscFlags", miscFlags);
		_Append("noRef", noRef);
		_Append("startFaster", startFaster);
		
		_AppendList("pr", _pr);
		_AppendList("r", _r);
		_AppendList("com", _com, true);
		_AppendList("nuget", _nuget);
		_AppendList("c", _c, true);
		_AppendList("resource", _resource, true);
		_AppendList("file", _file, true);
		
		if (_disabled != null) {
			b.AppendJoin(sep, _disabled).Append(sep);
		}
		
		if (b.Length <= 5) return "";
		b.Append("/*/");
		b.Append(append);
		return b.ToString();
		
		void _Append(string name, string value, bool relativePath = false) {
			if (value != null) {
				if (relativePath && dir != null && value.Starts(dir, true)) value = value[dir.Length..];
				b.Append(name).Append(' ').Append(value).Append(sep);
			}
		}
		
		void _AppendList(string name, List<string> a, bool relativePath = false) {
			if (a != null) foreach (var v in a.Distinct()) _Append(name, v, relativePath);
		}
	}
	
	public bool Multiline { get; set; }
	
	/// <summary>
	/// Adds or updates meta comments in the active document.
	/// </summary>
	/// <returns>true if changed documnt text.</returns>
	public bool Apply() {
		var doc = Panels.Editor.ActiveDoc;
		var f = doc.EFile;
		var code = doc.aaaText;
		var meta = MetaComments.FindMetaComments(code);
		string prepend = null, append = null;
		if (meta.end == 0) {
			if (code.RxMatch(@"^(///.*\R)+(?=\R|$)", 0, out RXGroup g)) { //description
				meta = new(g.End, g.End);
				prepend = "\r\n";
			}
			append = (f.IsScript && code.Eq(meta.end, "//.")) ? " " : "\r\n";
		}
		var s = Format(prepend, append);
		
		if (s.Length == 0) {
			if (meta.end == 0) return false;
			while (meta.end < code.Length && code[meta.end] <= ' ') meta.end++;
		} else if (s.Length == meta.end - meta.start) {
			if (s == doc.aaaRangeText(true, meta.start, meta.end)) return false; //did not change
		}
		
		doc.EReplaceTextGently(meta.start, meta.end, s);
		return true;
	}
	
	/// <summary>
	/// Merges meta options into this from <i>m</i>.
	/// If an option already exists in this: if it's a list (like c or define), adds list items that don't already exist; else replaces the value.
	/// </summary>
	public void Merge(MetaCommentsParser m) {
		_List(ref _pr, m._pr);
		_List(ref _r, m._r);
		_List(ref _com, m._com);
		_List(ref _nuget, m._nuget);
		_List(ref _c, m._c);
		_List(ref _resource, m._resource);
		_List(ref _file, m._file);
		
		_CommaList(ref define, m.define);
		_CommaList(ref noWarnings, m.noWarnings);
		_CommaList(ref testInternal, m.testInternal);
		
		_Single(ref platform, m.platform);
		_Single(ref console, m.console);
		_Single(ref icon, m.icon);
		_Single(ref ifRunning, m.ifRunning);
		_Single(ref manifest, m.manifest);
		_Single(ref miscFlags, m.miscFlags);
		_Single(ref noRef, m.noRef);
		_Single(ref nullable, m.nullable);
		_Single(ref optimize, m.optimize);
		_Single(ref outputPath, m.outputPath);
		_Single(ref postBuild, m.postBuild);
		_Single(ref preBuild, m.preBuild);
		_Single(ref role, m.role);
		_Single(ref sign, m.sign);
		_Single(ref startFaster, m.startFaster);
		_Single(ref uac, m.uac);
		_Single(ref warningLevel, m.warningLevel);
		_Single(ref xmlDoc, m.xmlDoc);
		
		static void _List(ref List<string> a, List<string> b) {
			if (b.NE_()) return;
			a ??= new();
			foreach (var s in b) {
				if (!a.Contains(s, StringComparer.OrdinalIgnoreCase)) a.Add(s);
			}
		}
		
		static void _CommaList(ref string a, string b, bool ignoreCase = false) {
			if (b.NE()) return;
			if (a.NE()) a = b;
			else {
				var hs = a.SplitHS_(',', ignoreCase);
				foreach (var s in b.Split_(',')) hs.Add(s);
				a = string.Join(',', hs);
			}
		}
		
		static void _Single(ref string a, string b) {
			if (b.NE()) return;
			a = b;
		}
	}
}


================================================
FILE: Au.Editor/xUtil/NugetDownloader.cs
================================================
using System.IO.Compression;
using System.Xml.Linq;

namespace LA;

static class NugetDownloader {
#if USED
	/// <summary>
	/// Downloads a NuGet package to a temp directory.
	/// </summary>
	/// <param name="package">Package name.</param>
	/// <param name="version">Package version. If null, gets the newest version compatible with the .NET Runtime used by this process.</param>
	/// <returns>Path of the downloaded nupkg file.</returns>
	/// <exception cref="OperationCanceledException">User-canceled.</exception>
	/// <exception cref="Exception">Failed.</exception>
	/// <remarks>
	/// If the package already exists in the temp directory, does not download again (just returns its path).
	/// </remarks>
	public static string Download(string package, string version = null) {
		package = package.Lower();
		version ??= _GetLatestCompatibleVersion(package);
		version = version.Lower();
		string fileName = $"{package}.{version}.nupkg";
		string tempDir = folders.ThisAppTemp + "download";
		string filePath = tempDir + "\\" + fileName;
		
		bool exists = false;
		if (filesystem.exists(filePath)) {
			try {
				using (ZipFile.OpenRead(filePath)) { }
				exists = true;
			}
			catch (InvalidDataException) { filesystem.delete(filePath); } //probably partially downloaded
		}
		
		if (!exists) {
			//delete old
			try {
				foreach (var v in filesystem.enumFiles(tempDir, $"{package}.*.nupkg")) {
					filesystem.delete(v.FullPath, FDFlags.CanFail);
				}
			}
			catch { } //eg the dir still does not exist
			
			string nupkgUrl = $"https://api.nuget.org/v3-flatcontainer/{package}/{version}/{fileName}";
			print.it($"Downloading from NuGet: {fileName}");
			bool ok = false;
			try {
				if (!internet.http.Get(nupkgUrl, true).Download(filePath)) throw new OperationCanceledException();
				ok = true;
			}
			finally { if (!ok) filesystem.delete(filePath); } //if failed, delete partially downloaded file
		}
		
		return filePath;
	}
	
	/// <summary>
	/// Extracts a nupkg file.
	/// </summary>
	/// <param name="nupkgPath">Path of a nupkg file.</param>
	/// <param name="extractDir">Base directory to extract files to. Creates if does not exist; else overwrites existing same files and does not delete other files.</param>
	/// <param name="rxPath">If not null, extracts only files whose relative path matches this regex. Final path will be the matched part; eg can be used <c>\K</c> to remove part of path (flatten).</param>
	/// <exception cref="Exception">Failed.</exception>
	public static void Extract(string nupkgPath, string extractDir, regexp rxPath = null) {
		print.it($"Extracting NuGet package: {pathname.getName(nupkgPath)}");
		filesystem.createDirectory(extractDir);
		using var z = ZipFile.OpenRead(nupkgPath);
		foreach (var e in z.Entries) {
			var relPath = e.FullName;
			if (rxPath != null && !rxPath.Match(relPath, 0, out relPath)) continue;
			var s = extractDir + "\\" + relPath;
			if (relPath.Contains('/')) filesystem.createDirectoryFor(s);
			e.ExtractToFile(s, overwrite: true);
		}
	}
	
	//This was used before the normal download URLs were known. Now used DotnetUtil.DownloadNetRuntimesForOtherArch.
	///// <summary>
	///// Downloads and extracts both .NET runtimes (core and desktop) for CPU architecture x64/ARM64 other than of this process.
	///// </summary>
	///// <param name="dir">Extract both to this directory.</param>
	///// <param name="portable">Extract to <i>dir</i> subdirectory <c>"dotnet"</c> (if x64) or <c>"dotnetARM"</c> (if ARM64). Delete old subdirectory.</param>
	///// <exception cref="OperationCanceledException">User-canceled.</exception>
	///// <exception cref="Exception">Failed.</exception>
	//public static void DownloadNetRuntimesForOtherArch(string dir, bool portable) {
	//	bool forArm = !osVersion.isArm64Process;
	
	//	if (portable) {
	//		dir = dir + "\\dotnet" + (forArm ? "ARM" : null);
	//		filesystem.delete(dir);
	//		filesystem.createDirectory(dir);
	//	}
	
	//	string arch = forArm ? "arm64" : "x64";
	//	string version = Environment.Version.ToString();
	//	regexp rx = new(@"(?i)^runtimes/win-\w+/(?:lib/net[^/]+|native)/\K.+");
	//	var f1 = Download($"Microsoft.NETCore.App.Runtime.win-{arch}", version);
	//	var f2 = Download($"Microsoft.WindowsDesktop.App.Runtime.win-{arch}", version);
	//	Extract(f1, dir, rx);
	//	Extract(f2, dir, rx);
	//}
	
	static string _GetLatestCompatibleVersion(string package) {
		var runtimeVersion = Environment.Version.ToString(2);
		package = package.Lower();
		
		var j = internet.http.Get($"https://api.nuget.org/v3-flatcontainer/{package}/index.json").Json();
		var versions = j["versions"].AsArray().Select(v => v.ToString()).Reverse();
		
		foreach (var v in versions) {
			//print.it(v);
			string nuspecUrl = $"https://api.nuget.org/v3-flatcontainer/{package}/{v}/{package}.nuspec";
			var nuspec = XElement.Parse(internet.http.Get(nuspecUrl).Text());
			//print.it(nuspec);
			var ns = nuspec.GetDefaultNamespace();
			var deps = nuspec.Element(ns + "metadata").Element(ns + "dependencies");
			if (deps == null) return v;
			foreach (var g in deps.Elements(ns + "group")) {
				var s = g.Attr("targetFramework");
				//print.it(s);
				if (s.Starts("net", true)) {
					if (s.RxMatch(@"^(?i)net(\d+\.\d+)(?=-windows|$)", 1, out s))
						if (s.CompareTo(runtimeVersion) <= 0) return v;
				} else {
					if (s.Starts(".NETStandard", true) || s.Starts(".NETCoreApp", true)) return v;
				}
			}
		}
		return null;
	}
#endif
}


================================================
FILE: Au.Editor/xUtil/RegexParser.cs
================================================
using EStyle = LA.SciTheme.EStyle;

namespace LA;

static class RegexParser {
	public record struct RXSpan(int start, int end, EStyle token);
	
	static regexp s_rx1 = new(@"\G[A-Z_]+(?:=\d+)?\)");
	
	public static List<RXSpan> GetClassifiedSpans(RStr s, bool net = false) {
		var a = new List<RXSpan>();
		int i = 0, ii = 0;
		bool altExtClasses = false;
		
		while (s.Eq(i, "(*") && s_rx1.Match(s, 0, out var r1, (i + 2)..)) {
			if (r1.Length == 3 && s.Eq(i + 2, "EC")) altExtClasses = true; //au mod: (*EC) sets flag PCRE2_ALT_EXTENDED_CLASS. Without it cannot correctly format or validate the regex; also users could not use this feature in the Find tool etc.
			i = r1.end;
		}
		if (i > 0) _Add(0, i, EStyle.RxOption);
		
		try { _Sub(s, false); }
		catch (Exception ex) { Debug_.Print(ex); }
		
		return a;
		
		void _Sub(RStr s, bool extended) {
			while (i < s.Length) {
				ii = i;
				char c = s[i++];
				if (c is '\\') {
					_Backslash(s, false);
				} else if (c is '[') {
					_CharClass(s, altExtClasses);
				} else if (c is '.') {
					_Add(ii, i, EStyle.RxChars);
				} else if (c is '^' or '$' or '|' or '+' or '*' or '?') {
					_Add(ii, i, EStyle.RxMeta);
				} else if (c is '{') {
					while (i < s.Length && s[i] is (>= '0' and <= '9') or ',' or ' ') i++;
					if (s.Eq(i, '}')) i++;
					_Add(ii, i, EStyle.RxMeta);
				} else if (c is '(') {
					if (!_Read(s, out c, EStyle.RxMeta)) return;
					if (c is '*') {
						if (!_Read(s, out c, EStyle.RxMeta)) return;
						if (char.IsLower(c)) { //`(*atomic:` etc
							_FindAdd(s, ':');
							if (i < s.Length) {
								if (s[(ii + 2)..(i - 1)] is "scan_substring" or "scs" && s[i] is '(') _FindAdd(s, ')');
								_Sub(s, extended);
							}
						} else { //`(*FAIL)`, `(*MARK:name)`, `(*:markName)` etc
							_FindAdd(s, ')');
						}
						continue;
					}
					if (c is '?') {
						if (!_Read(s, out c, EStyle.RxOption)) return;
						if (c is ':' or '|' or '>' or '=' or '!' or '*') goto g1;
						if (c is '#') { //`(?comment)
							_FindAdd(s, ')', EStyle.RxComment);
						} else if (c is '<' && s.At_(i) is '=' or '!' or '*') { //`(<=` etc
							i++;
							goto g1;
						} else if (c is '<' or '\'') { //`(?<name>group)`, `(?'name'group)`
							_FindAdd(s, c is '\'' ? c : '>');
							_Sub(s, extended);
						} else if (c is 'P') { //`(?P<name>group)`, `(?P=name)`, `(?P>name)`
							if (!_Read(s, out c, EStyle.RxMeta)) return;
							if (c is '<') {
								_FindAdd(s, '>');
								_Sub(s, extended);
							} else {
								_FindAdd(s, ')');
							}
						} else if (c is '(') { //`(?(condition)group)`
							if (s.Eq(i, '?') && (s.At_(i + 1) is '=' or '!' || (s.At_(i + 1) is '<' && s.At_(i + 2) is '=' or '!'))) {
								i += s.At_(i + 1) is '<' ? 3 : 2;
								_Add(ii, i, EStyle.RxMeta);
								_Sub(s, extended);
							} else {
								_FindAdd(s, ')');
							}
							_Sub(s, extended);
						} else if (c is 'R' or '&' || c.IsAsciiDigit() || (c is '-' or '+' && s.At_(i).IsAsciiDigit())) { //`(?R)`, `(?1)`, `(?-1)`, `(?&name)`
							_FindAdd(s, ')');
						} else if (c is 'C' && !net) { //callout
							//if (!s.Eq(i, ')')) { if (!_Read(s, EStyle.RxMeta)) return; if (c is '\'' or '`' or '"' or '^' or '%' or '#' or '$' or '{') {} } //never mind
							_FindAdd(s, ')', EStyle.RxCallout);
						} else if (c is '[' && !net) { //extended character class
							_ExtendedCharClass(s);
						} else { //`(?options)
							for (bool minus = false; ;) {
								if (c is ')') break;
								if (c is '-') minus = true;
								else if (c is 'x') extended = !minus;
								else if (c is '^') extended = false;
								else if (c is ':') {
									_Add(ii, ii + 1, EStyle.RxMeta);
									_Add(ii + 1, i - 1, EStyle.RxOption);
									ii = i - 1;
									goto g1; //like `(?i:group)`
								}
								if (!_Read(s, out c, EStyle.RxOption)) return;
							}
							_Add(ii, i, EStyle.RxOption);
						}
						continue;
					}
					i--;
					g1:
					_Add(ii, i, EStyle.RxMeta);
					_Sub(s, extended);
				} else if (c is ')') {
					_Add(ii, i, EStyle.RxMeta);
					return;
				} else if (c is '#' && extended) {
					_FindAdd(s, '\n', EStyle.RxComment);
				}
			}
		}
		
		void _Backslash(RStr s, bool inCharClass) {
			if (!_Read(s, out char c)) return;
			switch (c) {
			case >= '1' and <= '9' when !inCharClass:
				_AddNumber(s);
				break;
			case 'Q' when !inCharClass: //literal text
				_Add(ii, i, EStyle.RxMeta);
				if (_Find(s, @"\E", i, out int j)) _Add(j, i = j + 2, EStyle.RxMeta); else i = s.Length;
				break;
			case 'b' or 'B' or 'A' or 'Z' or 'z' or 'G' or 'R' or 'X' or 'K' when !inCharClass:
				_Add(ii, i, EStyle.RxMeta);
				break;
			case 'g' or 'k' when !inCharClass:
				if (!_Read(s, out c)) return;
				if (c is '{') _FindAdd(s, '}');
				else if (c is '<') _FindAdd(s, '>');
				else if (c is '\'') _FindAdd(s, '\'');
				else if (c is '-' or '+' or (>= '0' and <= '9')) _AddNumber(s);
				break;
			case 'N' when s.Eq(i, "{U+"): //`\N{U+xxxx}` (Unicode char code)
				_FindAdd(s, '}', EStyle.RxEscape);
				break;
			case 'w' or 'W' or 'd' or 'D' or 's' or 'S' or 'h' or 'H' or 'v' or 'V' or 'N' or 'C':
				_Add(ii, i, EStyle.RxChars);
				break;
			case 'p' or 'P': //Unicode properties
				if (s.Eq(i, '{')) _FindAdd(s, '}', EStyle.RxChars); else if (char.IsAsciiLetter(s.At_(i))) _Add(ii, ++i, EStyle.RxChars);
				break;
			case 'x': //ASCII char code
				if (s.Eq(i, '{')) i = _FindEnd(s, '}', i); else while (i < ii + 4 && char.IsAsciiHexDigit(s.At_(i))) i++;
				_Add(ii, i, EStyle.RxEscape);
				break;
			case 'u' when net:
				while (i < ii + 6 && char.IsAsciiHexDigit(s.At_(i))) i++;
				_Add(ii, i, EStyle.RxEscape);
				break;
			default:  //`\n` etc
				_Add(ii, i, EStyle.RxEscape);
				break;
			}
		}
		
		void _CharClass(RStr s, bool altExtended) {
			if (s.Eq(i, '^')) i++;
			_Add(ii, i, EStyle.RxChars);
			int ccStart = i;
			while (i < s.Length) {
				ii = i;
				char c = s[i++];
				if (c == '\\') {
					_Backslash(s, true);
				} else if (c == '[') {
					if (net) {
						if (i > ccStart + 2 && s[i - 2] == '-') _CharClass(s, false); //`[ab-[cd]]`
					} else if (s.Eq(i, ':')) { //`[...[:posix:]...]`
						_PosixCharClass(s);
					} else if (altExtended) { //nested alt-extended class
						_CharClass(s, true);
					}
				} else if (c is ']') {
					_Add(ii, i, EStyle.RxChars);
					return;
				} else if (altExtended) {
					if (c is '-' or '|' or '&' or '~' && s.Eq(i, c)) _Add(ii, ++i, EStyle.RxChars);
				} else {
					if (c is '-' && i > ccStart + 1 && !s.Eq(i, ']')) _Add(ii, i, EStyle.RxChars);
				}
			}
		}
		
		void _ExtendedCharClass(RStr s) {
			_Add(ii, i, EStyle.RxChars);
			while (i < s.Length) {
				ii = i;
				char c = s[i++];
				if (c == '\\') {
					_Backslash(s, true);
				} else if (c == '[') {
					if (s.Eq(i, ':')) { //`[...[:posix:]...]`
						_PosixCharClass(s);
					} else {
						_CharClass(s, false);
					}
				} else if (c is ']') {
					if (s.Eq(i, ')')) i++;
					_Add(ii, i, EStyle.RxChars);
					return;
				} else if (c is '-' or '+' or '&' or '|' or '^' or '!' or '(' or ')') {
					_Add(ii, i, EStyle.RxChars);
				}
			}
		}
		
		void _PosixCharClass(RStr s) {
			while (++i < s.Length && s[i] is >= 'a' and <= 'z') ;
			if (s.Eq(i, ':')) i++;
			if (s.Eq(i, ']')) i++;
			_Add(ii, i, EStyle.RxChars);
		}
		
		bool _Read(RStr s, out char c, EStyle tFalse = 0) {
			if (i < s.Length) { c = s[i++]; return true; }
			if (tFalse != 0) _Add(ii, s.Length, tFalse);
			c = default;
			return false;
		}
		
		void _FindAdd(RStr s, char c, EStyle t = EStyle.RxMeta) {
			_Add(ii, i = _FindEnd(s, c, i), t);
		}
		
		void _AddNumber(RStr s, EStyle t = EStyle.RxMeta) {
			while (s.At_(i).IsAsciiDigit()) i++;
			_Add(ii, i, t);
		}
		
		void _Add(int from, int to, EStyle t) {
			if (a.Count > 0 && a[^1].token == t && a[^1].end == from) a[^1] = new(a[^1].start, to, t);
			else a.Add(new(from, to, t));
		}
	}
	
	static bool _Find(RStr t, char c, int from, out int foundAt) {
		foundAt = t.IndexOf(from, c);
		return foundAt >= 0;
	}
	
	static bool _Find(RStr t, string s, int from, out int foundAt) {
		foundAt = t.IndexOf(from, s);
		return foundAt >= 0;
	}
	
	static int _FindEnd(RStr t, char c, int from) {
		int i = t.IndexOf(from, c);
		return i < 0 ? t.Length : i + 1;
	}
	
	/// <summary>
	/// Parses a regular expression or wildcard expression and writes regular expression syntax highlighting styles to <i>styles</i> (not UTF-8).
	/// </summary>
	/// <param name="s"></param>
	/// <param name="format"><b>Regexp</b>, <b>NetRegex</b> or <b>Wildex</b>.</param>
	/// <param name="styles">Writes styles here. Must be of length greater or equal to <c>s.Length</c>.</param>
	public static void GetScintillaStylingBytes16(RStr s, PSFormat format, Span<byte> styles) {
		Debug.Assert(styles.Length >= s.Length);
		if (format is PSFormat.Wildex) {
			if (s is not ['*', '*', _, _, _, ..]) return;
			WXType type = 0;
			string split = null;
			for (int i = 2, j; i < s.Length; i++) {
				switch (s[i]) {
				case ' ':
					styles = styles[(i + 1)..];
					s = s[(i + 1)..];
					goto g1;
				case 'r': type = WXType.RegexPcre; break;
				case 'R': type = WXType.RegexNet; break;
				case 'm': type = WXType.Multi; break;
				case '(':
					if (s[i - 1] != 'm') return;
					for (j = ++i; j < s.Length; j++) if (s[j] == ')') break;
					if (j == s.Length || j == i) return;
					split = s[i..j].ToString();
					i = j;
					break;
				case 'c' or 'n': break;
				default: return;
				}
			}
			g1:
			if (type is WXType.RegexPcre or WXType.RegexNet) {
				var a = GetClassifiedSpans(s, type is WXType.RegexNet);
				_ToScintillaStylingBytes16(s, a, styles);
			} else if (type is WXType.Multi) {
				foreach (var v in s.SplitSE(split ?? "||")) {
					GetScintillaStylingBytes16(s[v.Range], PSFormat.Wildex, styles[v.start..]);
				}
			}
		} else {
			var a = GetClassifiedSpans(s, format is PSFormat.NetRegex);
			_ToScintillaStylingBytes16(s, a, styles);
		}
	}
	
	static void _ToScintillaStylingBytes16(RStr s, List<RXSpan> a, Span<byte> styles) {
		styles[..s.Length].Fill((byte)EStyle.RxText);
		foreach (var v in a) {
			//print.it(v, s[v.start..v.end].ToString());
			var (i, end) = (v.start, v.end);
			while (i < end) styles[i++] = (byte)v.token;
		}
	}
}


================================================
FILE: Au.sln
================================================

Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio Version 17
VisualStudioVersion = 17.0.31612.314
MinimumVisualStudioVersion = 10.0.40219.1
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "App", "App", "{82D5A236-3610-446D-95BA-3888BF6E8F25}"
EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Dll", "Dll", "{0C880B80-8ECC-4252-A9C9-00BAF5C58A3C}"
EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Libraries", "Libraries", "{016834A7-5E0C-4356-81F4-E4034CD56BBD}"
EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Other", "Other", "{4B65F34E-129D-46F9-9464-25737BC43029}"
EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "solution", "solution", "{2C03BC9E-C857-44FF-8585-08DF42C687A3}"
	ProjectSection(SolutionItems) = preProject
		.editorconfig = .editorconfig
		.gitignore = .gitignore
		Au.snk = Au.snk
		global.json = global.json
		LICENSE.txt = LICENSE.txt
		Notes.txt = Notes.txt
		README.md = README.md
	EndProjectSection
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Au.Editor", "Au.Editor\Au.Editor.csproj", "{4B47A184-5CB7-4E78-8EAD-E458FB11A7EF}"
	ProjectSection(ProjectDependencies) = postProject
		{19CCA8B8-46B9-4609-B7CE-198DA19F07BD} = {19CCA8B8-46B9-4609-B7CE-198DA19F07BD}
		{5DCF20C5-9BBD-44E2-96BE-323A845B99F4} = {5DCF20C5-9BBD-44E2-96BE-323A845B99F4}
		{8662DF62-3B21-4D23-806D-4590F6091918} = {8662DF62-3B21-4D23-806D-4590F6091918}
	EndProjectSection
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Au", "Au\Au.csproj", "{B014973F-FCBB-4BC4-92E7-97AE684EA4F7}"
	ProjectSection(ProjectDependencies) = postProject
		{10559875-C9A1-484C-BCFA-8DC53A428F1C} = {10559875-C9A1-484C-BCFA-8DC53A428F1C}
	EndProjectSection
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Au.Controls", "Au.Controls\Au.Controls.csproj", "{7A27F221-F05C-4545-B6BB-3DB0F6B9A50E}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Cpp", "Cpp\Cpp.vcxproj", "{10559875-C9A1-484C-BCFA-8DC53A428F1C}"
	ProjectSection(ProjectDependencies) = postProject
		{8662DF62-3B21-4D23-806D-4590F6091918} = {8662DF62-3B21-4D23-806D-4590F6091918}
	EndProjectSection
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "PCRE", "Libraries\PCRE\PCRE.vcxproj", "{190BC611-EE00-4B10-87F2-A7E73B639E59}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Au.AppHost", "Au.AppHost\Au.AppHost.vcxproj", "{5DCF20C5-9BBD-44E2-96BE-323A845B99F4}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DocFX", "Other\DocFX\DocFX.csproj", "{C84FD40F-6D87-43FA-BBAD-5CA3C8B98E44}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Scintilla", "Libraries\scintilla\win32\Scintilla.vcxproj", "{19CCA8B8-46B9-4609-B7CE-198DA19F07BD}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Au.Net4", "Other\Au.Net4\Au.Net4.csproj", "{2157BC47-A5E1-405C-A003-F44970DC3718}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DatabasesEtc", "Other\DatabasesEtc\DatabasesEtc.csproj", "{F7F1B96D-C391-4744-BE05-95264B0815E2}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Au.DllHost", "Other\Au.DllHost\Au.DllHost.vcxproj", "{E9D9F078-BF4F-437E-BE31-3AF89F3C6548}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "BuildEvents", "Other\BuildEvents\BuildEvents.csproj", "{8662DF62-3B21-4D23-806D-4590F6091918}"
EndProject
Global
	GlobalSection(SolutionConfigurationPlatforms) = preSolution
		Debug|Any CPU = Debug|Any CPU
		Debug|ARM64 = Debug|ARM64
		Debug|x64 = Debug|x64
		Debug|x86 = Debug|x86
		Release|Any CPU = Release|Any CPU
		Release|ARM64 = Release|ARM64
		Release|x64 = Release|x64
		Release|x86 = Release|x86
	EndGlobalSection
	GlobalSection(ProjectConfigurationPlatforms) = postSolution
		{4B47A184-5CB7-4E78-8EAD-E458FB11A7EF}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{4B47A184-5CB7-4E78-8EAD-E458FB11A7EF}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{4B47A184-5CB7-4E78-8EAD-E458FB11A7EF}.Debug|ARM64.ActiveCfg = Debug|Any CPU
		{4B47A184-5CB7-4E78-8EAD-E458FB11A7EF}.Debug|x64.ActiveCfg = Debug|Any CPU
		{4B47A184-5CB7-4E78-8EAD-E458FB11A7EF}.Debug|x86.ActiveCfg = Debug|Any CPU
		{4B47A184-5CB7-4E78-8EAD-E458FB11A7EF}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{4B47A184-5CB7-4E78-8EAD-E458FB11A7EF}.Release|Any CPU.Build.0 = Release|Any CPU
		{4B47A184-5CB7-4E78-8EAD-E458FB11A7EF}.Release|ARM64.ActiveCfg = Release|Any CPU
		{4B47A184-5CB7-4E78-8EAD-E458FB11A7EF}.Release|x64.ActiveCfg = Release|Any CPU
		{4B47A184-5CB7-4E78-8EAD-E458FB11A7EF}.Release|x86.ActiveCfg = Release|Any CPU
		{B014973F-FCBB-4BC4-92E7-97AE684EA4F7}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{B014973F-FCBB-4BC4-92E7-97AE684EA4F7}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{B014973F-FCBB-4BC4-92E7-97AE684EA4F7}.Debug|ARM64.ActiveCfg = Debug|Any CPU
		{B014973F-FCBB-4BC4-92E7-97AE684EA4F7}.Debug|x64.ActiveCfg = Debug|Any CPU
		{B014973F-FCBB-4BC4-92E7-97AE684EA4F7}.Debug|x86.ActiveCfg = Debug|Any CPU
		{B014973F-FCBB-4BC4-92E7-97AE684EA4F7}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{B014973F-FCBB-4BC4-92E7-97AE684EA4F7}.Release|Any CPU.Build.0 = Release|Any CPU
		{B014973F-FCBB-4BC4-92E7-97AE684EA4F7}.Release|ARM64.ActiveCfg = Release|Any CPU
		{B014973F-FCBB-4BC4-92E7-97AE684EA4F7}.Release|x64.ActiveCfg = Release|Any CPU
		{B014973F-FCBB-4BC4-92E7-97AE684EA4F7}.Release|x86.ActiveCfg = Release|Any CPU
		{7A27F221-F05C-4545-B6BB-3DB0F6B9A50E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{7A27F221-F05C-4545-B6BB-3DB0F6B9A50E}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{7A27F221-F05C-4545-B6BB-3DB0F6B9A50E}.Debug|ARM64.ActiveCfg = Debug|Any CPU
		{7A27F221-F05C-4545-B6BB-3DB0F6B9A50E}.Debug|x64.ActiveCfg = Debug|Any CPU
		{7A27F221-F05C-4545-B6BB-3DB0F6B9A50E}.Debug|x86.ActiveCfg = Debug|Any CPU
		{7A27F221-F05C-4545-B6BB-3DB0F6B9A50E}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{7A27F221-F05C-4545-B6BB-3DB0F6B9A50E}.Release|Any CPU.Build.0 = Release|Any CPU
		{7A27F221-F05C-4545-B6BB-3DB0F6B9A50E}.Release|ARM64.ActiveCfg = Release|Any CPU
		{7A27F221-F05C-4545-B6BB-3DB0F6B9A50E}.Release|x64.ActiveCfg = Release|Any CPU
		{7A27F221-F05C-4545-B6BB-3DB0F6B9A50E}.Release|x86.ActiveCfg = Release|Any CPU
		{10559875-C9A1-484C-BCFA-8DC53A428F1C}.Debug|Any CPU.ActiveCfg = Debug|x64
		{10559875-C9A1-484C-BCFA-8DC53A428F1C}.Debug|Any CPU.Build.0 = Debug|x64
		{10559875-C9A1-484C-BCFA-8DC53A428F1C}.Debug|ARM64.ActiveCfg = Debug|ARM64
		{10559875-C9A1-484C-BCFA-8DC53A428F1C}.Debug|ARM64.Build.0 = Debug|ARM64
		{10559875-C9A1-484C-BCFA-8DC53A428F1C}.Debug|x64.ActiveCfg = Debug|x64
		{10559875-C9A1-484C-BCFA-8DC53A428F1C}.Debug|x64.Build.0 = Debug|x64
		{10559875-C9A1-484C-BCFA-8DC53A428F1C}.Debug|x86.ActiveCfg = Debug|Win32
		{10559875-C9A1-484C-BCFA-8DC53A428F1C}.Debug|x86.Build.0 = Debug|Win32
		{10559875-C9A1-484C-BCFA-8DC53A428F1C}.Release|Any CPU.ActiveCfg = Release|x64
		{10559875-C9A1-484C-BCFA-8DC53A428F1C}.Release|Any CPU.Build.0 = Release|x64
		{10559875-C9A1-484C-BCFA-8DC53A428F1C}.Release|ARM64.ActiveCfg = Release|ARM64
		{10559875-C9A1-484C-BCFA-8DC53A428F1C}.Release|ARM64.Build.0 = Release|ARM64
		{10559875-C9A1-484C-BCFA-8DC53A428F1C}.Release|x64.ActiveCfg = Release|x64
		{10559875-C9A1-484C-BCFA-8DC53A428F1C}.Release|x64.Build.0 = Release|x64
		{10559875-C9A1-484C-BCFA-8DC53A428F1C}.Release|x86.ActiveCfg = Release|Win32
		{10559875-C9A1-484C-BCFA-8DC53A428F1C}.Release|x86.Build.0 = Release|Win32
		{190BC611-EE00-4B10-87F2-A7E73B639E59}.Debug|Any CPU.ActiveCfg = Release|x64
		{190BC611-EE00-4B10-87F2-A7E73B639E59}.Debug|Any CPU.Build.0 = Release|x64
		{190BC611-EE00-4B10-87F2-A7E73B639E59}.Debug|Any CPU.Deploy.0 = Release|x64
		{190BC611-EE00-4B10-87F2-A7E73B639E59}.Debug|ARM64.ActiveCfg = Debug|ARM64
		{190BC611-EE00-4B10-87F2-A7E73B639E59}.Debug|ARM64.Build.0 = Debug|ARM64
		{190BC611-EE00-4B10-87F2-A7E73B639E59}.Debug|x64.ActiveCfg = Debug|x64
		{190BC611-EE00-4B10-87F2-A7E73B639E59}.Debug|x64.Build.0 = Debug|x64
		{190BC611-EE00-4B10-87F2-A7E73B639E59}.Debug|x86.ActiveCfg = Release|Win32
		{190BC611-EE00-4B10-87F2-A7E73B639E59}.Debug|x86.Build.0 = Release|Win32
		{190BC611-EE00-4B10-87F2-A7E73B639E59}.Release|Any CPU.ActiveCfg = Release|x64
		{190BC611-EE00-4B10-87F2-A7E73B639E59}.Release|Any CPU.Build.0 = Release|x64
		{190BC611-EE00-4B10-87F2-A7E73B639E59}.Release|ARM64.ActiveCfg = Release|ARM64
		{190BC611-EE00-4B10-87F2-A7E73B639E59}.Release|ARM64.Build.0 = Release|ARM64
		{190BC611-EE00-4B10-87F2-A7E73B639E59}.Release|x64.ActiveCfg = Release|x64
		{190BC611-EE00-4B10-87F2-A7E73B639E59}.Release|x64.Build.0 = Release|x64
		{190BC611-EE00-4B10-87F2-A7E73B639E59}.Release|x86.ActiveCfg = Release|Win32
		{190BC611-EE00-4B10-87F2-A7E73B639E59}.Release|x86.Build.0 = Release|Win32
		{5DCF20C5-9BBD-44E2-96BE-323A845B99F4}.Debug|Any CPU.ActiveCfg = Release|x64
		{5DCF20C5-9BBD-44E2-96BE-323A845B99F4}.Debug|Any CPU.Build.0 = Release|x64
		{5DCF20C5-9BBD-44E2-96BE-323A845B99F4}.Debug|ARM64.ActiveCfg = Release|ARM64
		{5DCF20C5-9BBD-44E2-96BE-323A845B99F4}.Debug|ARM64.Build.0 = Release|ARM64
		{5DCF20C5-9BBD-44E2-96BE-323A845B99F4}.Debug|x64.ActiveCfg = Release|x64
		{5DCF20C5-9BBD-44E2-96BE-323A845B99F4}.Debug|x64.Build.0 = Release|x64
		{5DCF20C5-9BBD-44E2-96BE-323A845B99F4}.Debug|x86.ActiveCfg = Release|Win32
		{5DCF20C5-9BBD-44E2-96BE-323A845B99F4}.Debug|x86.Build.0 = Release|Win32
		{5DCF20C5-9BBD-44E2-96BE-323A845B99F4}.Release|Any CPU.ActiveCfg = Release|x64
		{5DCF20C5-9BBD-44E2-96BE-323A845B99F4}.Release|Any CPU.Build.0 = Release|x64
		{5DCF20C5-9BBD-44E2-96BE-323A845B99F4}.Release|ARM64.ActiveCfg = Release|ARM64
		{5DCF20C5-9BBD-44E2-96BE-323A845B99F4}.Release|ARM64.Build.0 = Release|ARM64
		{5DCF20C5-9BBD-44E2-96BE-323A845B99F4}.Release|x64.ActiveCfg = Release|x64
		{5DCF20C5-9BBD-44E2-96BE-323A845B99F4}.Release|x64.Build.0 = Release|x64
		{5DCF20C5-9BBD-44E2-96BE-323A845B99F4}.Release|x86.ActiveCfg = Release|Win32
		{5DCF20C5-9BBD-44E2-96BE-323A845B99F4}.Release|x86.Build.0 = Release|Win32
		{C84FD40F-6D87-43FA-BBAD-5CA3C8B98E44}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{C84FD40F-6D87-43FA-BBAD-5CA3C8B98E44}.Debug|ARM64.ActiveCfg = Debug|Any CPU
		{C84FD40F-6D87-43FA-BBAD-5CA3C8B98E44}.Debug|x64.ActiveCfg = Debug|Any CPU
		{C84FD40F-6D87-43FA-BBAD-5CA3C8B98E44}.Debug|x86.ActiveCfg = Debug|Any CPU
		{C84FD40F-6D87-43FA-BBAD-5CA3C8B98E44}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{C84FD40F-6D87-43FA-BBAD-5CA3C8B98E44}.Release|ARM64.ActiveCfg = Release|Any CPU
		{C84FD40F-6D87-43FA-BBAD-5CA3C8B98E44}.Release|x64.ActiveCfg = Release|Any CPU
		{C84FD40F-6D87-43FA-BBAD-5CA3C8B98E44}.Release|x86.ActiveCfg = Release|Any CPU
		{19CCA8B8-46B9-4609-B7CE-198DA19F07BD}.Debug|Any CPU.ActiveCfg = Debug|x64
		{19CCA8B8-46B9-4609-B7CE-198DA19F07BD}.Debug|Any CPU.Build.0 = Debug|x64
		{19CCA8B8-46B9-4609-B7CE-198DA19F07BD}.Debug|ARM64.ActiveCfg = Debug|ARM64
		{19CCA8B8-46B9-4609-B7CE-198DA19F07BD}.Debug|ARM64.Build.0 = Debug|ARM64
		{19CCA8B8-46B9-4609-B7CE-198DA19F07BD}.Debug|x64.ActiveCfg = Debug|x64
		{19CCA8B8-46B9-4609-B7CE-198DA19F07BD}.Debug|x64.Build.0 = Debug|x64
		{19CCA8B8-46B9-4609-B7CE-198DA19F07BD}.Debug|x86.ActiveCfg = Debug|x64
		{19CCA8B8-46B9-4609-B7CE-198DA19F07BD}.Release|Any CPU.ActiveCfg = Release|x64
		{19CCA8B8-46B9-4609-B7CE-198DA19F07BD}.Release|Any CPU.Build.0 = Release|x64
		{19CCA8B8-46B9-4609-B7CE-198DA19F07BD}.Release|ARM64.ActiveCfg = Release|ARM64
		{19CCA8B8-46B9-4609-B7CE-198DA19F07BD}.Release|ARM64.Build.0 = Release|ARM64
		{19CCA8B8-46B9-4609-B7CE-198DA19F07BD}.Release|x64.ActiveCfg = Release|x64
		{19CCA8B8-46B9-4609-B7CE-198DA19F07BD}.Release|x64.Build.0 = Release|x64
		{19CCA8B8-46B9-4609-B7CE-198DA19F07BD}.Release|x86.ActiveCfg = Release|x64
		{2157BC47-A5E1-405C-A003-F44970DC3718}.Debug|Any CPU.ActiveCfg = Release|Any CPU
		{2157BC47-A5E1-405C-A003-F44970DC3718}.Debug|Any CPU.Build.0 = Release|Any CPU
		{2157BC47-A5E1-405C-A003-F44970DC3718}.Debug|ARM64.ActiveCfg = Debug|Any CPU
		{2157BC47-A5E1-405C-A003-F44970DC3718}.Debug|x64.ActiveCfg = Debug|Any CPU
		{2157BC47-A5E1-405C-A003-F44970DC3718}.Debug|x86.ActiveCfg = Debug|Any CPU
		{2157BC47-A5E1-405C-A003-F44970DC3718}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{2157BC47-A5E1-405C-A003-F44970DC3718}.Release|Any CPU.Build.0 = Release|Any CPU
		{2157BC47-A5E1-405C-A003-F44970DC3718}.Release|ARM64.ActiveCfg = Release|Any CPU
		{2157BC47-A5E1-405C-A003-F44970DC3718}.Release|x64.ActiveCfg = Release|Any CPU
		{2157BC47-A5E1-405C-A003-F44970DC3718}.Release|x86.ActiveCfg = Release|Any CPU
		{F7F1B96D-C391-4744-BE05-95264B0815E2}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{F7F1B96D-C391-4744-BE05-95264B0815E2}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{F7F1B96D-C391-4744-BE05-95264B0815E2}.Debug|ARM64.ActiveCfg = Debug|Any CPU
		{F7F1B96D-C391-4744-BE05-95264B0815E2}.Debug|x64.ActiveCfg = Debug|Any CPU
		{F7F1B96D-C391-4744-BE05-95264B0815E2}.Debug|x86.ActiveCfg = Debug|Any CPU
		{F7F1B96D-C391-4744-BE05-95264B0815E2}.Release|Any CPU.ActiveCfg = Debug|Any CPU
		{F7F1B96D-C391-4744-BE05-95264B0815E2}.Release|Any CPU.Build.0 = Debug|Any CPU
		{F7F1B96D-C391-4744-BE05-95264B0815E2}.Release|ARM64.ActiveCfg = Debug|Any CPU
		{F7F1B96D-C391-4744-BE05-95264B0815E2}.Release|x64.ActiveCfg = Debug|Any CPU
		{F7F1B96D-C391-4744-BE05-95264B0815E2}.Release|x86.ActiveCfg = Debug|Any CPU
		{E9D9F078-BF4F-437E-BE31-3AF89F3C6548}.Debug|Any CPU.ActiveCfg = Release|x64
		{E9D9F078-BF4F-437E-BE31-3AF89F3C6548}.Debug|Any CPU.Build.0 = Release|x64
		{E9D9F078-BF4F-437E-BE31-3AF89F3C6548}.Debug|ARM64.ActiveCfg = Release|ARM64
		{E9D9F078-BF4F-437E-BE31-3AF89F3C6548}.Debug|ARM64.Build.0 = Release|ARM64
		{E9D9F078-BF4F-437E-BE31-3AF89F3C6548}.Debug|x64.ActiveCfg = Release|x64
		{E9D9F078-BF4F-437E-BE31-3AF89F3C6548}.Debug|x64.Build.0 = Release|x64
		{E9D9F078-BF4F-437E-BE31-3AF89F3C6548}.Debug|x86.ActiveCfg = Release|Win32
		{E9D9F078-BF4F-437E-BE31-3AF89F3C6548}.Debug|x86.Build.0 = Release|Win32
		{E9D9F078-BF4F-437E-BE31-3AF89F3C6548}.Release|Any CPU.ActiveCfg = Release|x64
		{E9D9F078-BF4F-437E-BE31-3AF89F3C6548}.Release|Any CPU.Build.0 = Release|x64
		{E9D9F078-BF4F-437E-BE31-3AF89F3C6548}.Release|ARM64.ActiveCfg = Release|ARM64
		{E9D9F078-BF4F-437E-BE31-3AF89F3C6548}.Release|ARM64.Build.0 = Release|ARM64
		{E9D9F078-BF4F-437E-BE31-3AF89F3C6548}.Release|x64.ActiveCfg = Release|x64
		{E9D9F078-BF4F-437E-BE31-3AF89F3C6548}.Release|x64.Build.0 = Release|x64
		{E9D9F078-BF4F-437E-BE31-3AF89F3C6548}.Release|x86.ActiveCfg = Release|Win32
		{E9D9F078-BF4F-437E-BE31-3AF89F3C6548}.Release|x86.Build.0 = Release|Win32
		{8662DF62-3B21-4D23-806D-4590F6091918}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{8662DF62-3B21-4D23-806D-4590F6091918}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{8662DF62-3B21-4D23-806D-4590F6091918}.Debug|ARM64.ActiveCfg = Debug|Any CPU
		{8662DF62-3B21-4D23-806D-4590F6091918}.Debug|ARM64.Build.0 = Debug|Any CPU
		{8662DF62-3B21-4D23-806D-4590F6091918}.Debug|x64.ActiveCfg = Debug|Any CPU
		{8662DF62-3B21-4D23-806D-4590F6091918}.Debug|x64.Build.0 = Debug|Any CPU
		{8662DF62-3B21-4D23-806D-4590F6091918}.Debug|x86.ActiveCfg = Debug|Any CPU
		{8662DF62-3B21-4D23-806D-4590F6091918}.Debug|x86.Build.0 = Debug|Any CPU
		{8662DF62-3B21-4D23-806D-4590F6091918}.Release|Any CPU.ActiveCfg = Debug|Any CPU
		{8662DF62-3B21-4D23-806D-4590F6091918}.Release|Any CPU.Build.0 = Debug|Any CPU
		{8662DF62-3B21-4D23-806D-4590F6091918}.Release|ARM64.ActiveCfg = Debug|Any CPU
		{8662DF62-3B21-4D23-806D-4590F6091918}.Release|ARM64.Build.0 = Debug|Any CPU
		{8662DF62-3B21-4D23-806D-4590F6091918}.Release|x64.ActiveCfg = Debug|Any CPU
		{8662DF62-3B21-4D23-806D-4590F6091918}.Release|x64.Build.0 = Debug|Any CPU
		{8662DF62-3B21-4D23-806D-4590F6091918}.Release|x86.ActiveCfg = Debug|Any CPU
		{8662DF62-3B21-4D23-806D-4590F6091918}.Release|x86.Build.0 = Debug|Any CPU
	EndGlobalSection
	GlobalSection(SolutionProperties) = preSolution
		HideSolutionNode = FALSE
	EndGlobalSection
	GlobalSection(NestedProjects) = preSolution
		{4B47A184-5CB7-4E78-8EAD-E458FB11A7EF} = {82D5A236-3610-446D-95BA-3888BF6E8F25}
		{B014973F-FCBB-4BC4-92E7-97AE684EA4F7} = {0C880B80-8ECC-4252-A9C9-00BAF5C58A3C}
		{7A27F221-F05C-4545-B6BB-3DB0F6B9A50E} = {0C880B80-8ECC-4252-A9C9-00BAF5C58A3C}
		{10559875-C9A1-484C-BCFA-8DC53A428F1C} = {0C880B80-8ECC-4252-A9C9-00BAF5C58A3C}
		{190BC611-EE00-4B10-87F2-A7E73B639E59} = {016834A7-5E0C-4356-81F4-E4034CD56BBD}
		{5DCF20C5-9BBD-44E2-96BE-323A845B99F4} = {82D5A236-3610-446D-95BA-3888BF6E8F25}
		{19CCA8B8-46B9-4609-B7CE-198DA19F07BD} = {016834A7-5E0C-4356-81F4-E4034CD56BBD}
		{2157BC47-A5E1-405C-A003-F44970DC3718} = {4B65F34E-129D-46F9-9464-25737BC43029}
		{F7F1B96D-C391-4744-BE05-95264B0815E2} = {4B65F34E-129D-46F9-9464-25737BC43029}
		{E9D9F078-BF4F-437E-BE31-3AF89F3C6548} = {4B65F34E-129D-46F9-9464-25737BC43029}
		{8662DF62-3B21-4D23-806D-4590F6091918} = {4B65F34E-129D-46F9-9464-25737BC43029}
	EndGlobalSection
	GlobalSection(ExtensibilityGlobals) = postSolution
		SolutionGuid = {F4DC626A-22DF-4C8A-9686-8A694050B23E}
	EndGlobalSection
EndGlobal


================================================
FILE: Cookbook/files.xml
================================================
<files>
  <d n="-" i="357">
    <s n="How to write the cookbook.cs" i="360" />
    <s n="Test.cs" i="362" />
    <s n="TODO.cs" i="363" />
    <s n="init.cs" i="361" />
    <c n="global.cs" i="359" />
  </d>
  <s n="Documentation.cs" i="388" />
  <d n="C# language" i="4">
    <s n="C# introduction.cs" i="25" />
    <s n="Comments, disabled code.cs" i="35" />
    <s n="Strings (text), numbers, characters, bool, null, default.cs" i="57" />
    <s n="Variables, fields, built-in types.cs" i="36" />
    <s n="Constants, enum.cs" i="60" />
    <s n="Types (class, struct, generic, nullable, tuple).cs" i="37" />
    <s n="Functions (methods, properties).cs" i="38" />
    <s n="Operators, expressions.cs" i="39" />
    <s n="Namespaces, using.cs" i="64" />
    <s n="if-else, switch.cs" i="65" />
    <s n="for, foreach (repeat, loop, iterate).cs" i="66" />
    <s n="return, goto (exit, end, stop, jump).cs" i="67" />
    <s n="Errors, exceptions, try-catch-finally, throw.cs" i="62" />
    <s n="Callback functions, lambda, delegate, event.cs" i="63" />
    <s n="Collections - array, List, Stack, Queue.cs" i="300" />
    <s n="Collections - Dictionary, HashSet.cs" i="301" />
    <s n="Collections - LINQ functions.cs" i="150" />
  </d>
  <d n="Input, output" i="5">
    <s n="Display text and variables.cs" i="6" />
    <s n="Message box dialog, list.cs" i="7" />
    <s n="Input box dialog.cs" i="8" />
    <s n="File and folder dialogs, color dialog.cs" i="74" />
    <s n="Popup menu, check list.cs" i="10" />
    <s n="Play sound, speak.cs" i="100" />
  </d>
  <d n="Keys, mouse, clipboard" i="12">
    <s n="Send keys, text.cs" i="26" />
    <s n="Select-click menu, control (keyboard shortcuts).cs" i="85" />
    <s n="If key pressed, toggled.cs" i="75" />
    <s n="Wait for key, hotkey.cs" i="76" />
    <s n="Mouse click, move, drag, restore.cs" i="77" />
    <s n="Mouse get position, wait, cursor, etc.cs" i="79" />
    <s n="Clipboard copy, paste, set-get text etc.cs" i="80" />
  </d>
  <d n="Window, UI automation" i="13">
    <s n="Find window, controls, activate.cs" i="27" />
    <s n="Window actions (close, move, resize, properties, etc).cs" i="81" />
    <s n="Screens (display monitors).cs" i="82" />
    <s n="UI elements (find, click, check, focus, select, expand, check menu item, wait for state, etc).cs" i="83" />
    <s n="Web automation, navigate.cs" i="89" />
    <s n="Extract table data using UI elements.cs" i="373" />
    <s n="Web browser automation with Playwright.cs" i="386" />
    <s n="Web browser automation with Selenium.cs" i="141" />
    <s n="Find UI image or color.cs" i="90" />
    <s n="Take screenshot.cs" i="101" />
    <s n="OCR, find UI text, extract text.cs" i="168" />
    <s n="-Computer vision.cs" i="257" />
  </d>
  <d n="Wait, time" i="78">
    <s n="Simple wait (sleep, delay).cs" i="86" />
    <s n="Wait for something.cs" i="87" />
    <s n="Date and time.cs" i="96" />
    <s n="Computer time, code speed.cs" i="105" />
    <s n="Timers.cs" i="111" />
  </d>
  <d n="System" i="15">
    <s n="Run program, open document, folder, URL.cs" i="33" />
    <s n="Run console program and get its output text.cs" i="92" />
    <s n="Processes.cs" i="93" />
    <s n="Services.cs" i="88" />
    <s n="Shutdown, restart, logoff, sleep, hibernate, lock computer, battery power.cs" i="94" />
    <s n="Windows OS version, computer and user name.cs" i="109" />
    <s n="Desktop (show etc).cs" i="97" />
    <s n="Registry.cs" i="99" />
    <s n="Environment variables.cs" i="106" />
    <s n="Threads.cs" i="112" />
  </d>
  <d n="Filesystem" i="14">
    <s n="File paths, special folders.cs" i="28" />
    <s n="File exists, size, time, attributes.cs" i="123" />
    <s n="Enumerate files, folders.cs" i="122" />
    <s n="Enumerate drives, get drive properties.cs" i="127" />
    <s n="File move, rename.cs" i="118" />
    <s n="File copy.cs" i="126" />
    <s n="File delete, Recycle Bin.cs" i="125" />
    <s n="File shortcuts, symbolic links.cs" i="124" />
    <s n="Create folder.cs" i="120" />
    <s n="File read (load), write (save).cs" i="119" />
    <s n="Zip files (compress, extract).cs" i="136" />
    <s n="-Backup files.cs" i="247" />
    <s n="Wait for file.cs" i="250" />
  </d>
  <d n="Internet" i="16">
    <s n="Check internet connection, ping.cs" i="152" />
    <s n="Http get web page, download file.cs" i="137" />
    <s n="Http post web form, JSON.cs" i="139" />
    <s n="Parse HTML.cs" i="135" />
    <s n="SFTP (upload, download, etc).cs" i="142" />
    <s n="SSH (manage website).cs" i="191" />
    <s n="Send email message (SMTP).cs" i="143" />
    <s n="Send and receive email (SMTP, POP3, IMAP).cs" i="144" />
  </d>
  <d n="Script" i="186">
    <s n="Run script from script.cs" i="185" />
    <s n="Run script command line, shortcut, schedule, shell menu.cs" i="165" />
    <s n="Run script at startup, output link.cs" i="187" />
    <s n="Run script on another computer; HTTP server.cs" i="371" />
    <s n="Script run-time settings.cs" i="110" />
    <s n="End script task, pause, exit.cs" i="370" />
    <s n="Tray icon and notifications.cs" i="115" />
    <s n="Script testing and debugging.cs" i="173" />
    <s n="Saving variables, settings.cs" i="140" />
    <s n="Script class with Main().cs" i="261" />
    <s n="Multi-file scripts, projects.cs" i="259" />
    <s n="Shared classes and functions, libraries.cs" i="258" />
  </d>
  <d n="Triggers, toolbars" i="17">
    <s n="Keyboard triggers (hotkeys).cs" i="160" />
    <s n="Autotext triggers, expand text.cs" i="162" />
    <s n="Mouse triggers.cs" i="161" />
    <s n="Window triggers, auto-close popup windows.cs" i="163" />
    <d n="Using action triggers" i="368">
      <s n="Trigger scopes (window, program).cs" i="367" />
      <s n="-Trigger options.cs" i="369" />
      <s n="Remap keys.cs" i="365" />
      <s n="Show triggers.cs" i="366" />
      <s n="Script 'Triggers and toolbars'.cs" i="342" />
    </d>
    <s n="Floating toolbars.cs" i="164" />
    <s n="Process triggers (start, end).cs" i="252" />
    <s n="File change triggers (events).cs" i="251" />
    <s n="Other triggers.cs" i="171" />
    <s n="-Hooks.cs" i="172" />
    <s n="Run code when script ends.cs" i="170" />
  </d>
  <d n="Custom dialog windows" i="264">
    <s n="Dialog - add elements, show, get values.cs" i="265" />
    <s n="Dialog - set element properties and values.cs" i="291" />
    <s n="Dialog - columns, rows.cs" i="266" />
    <s n="Dialog - panels, group box.cs" i="268" />
    <s n="Dialog - element size, position, margin.cs" i="281" />
    <s n="Dialog - validation.cs" i="267" />
    <s n="Dialog - events.cs" i="270" />
    <s n="Dialog - splitters.cs" i="278" />
    <s n="Dialog - links, formatted text.cs" i="273" />
    <s n="Dialog - element color, font, border.cs" i="282" />
    <s n="Dialog - button icon, toolbar.cs" i="285" />
    <s n="Dialog - textbox watermark, adorner.cs" i="283" />
    <s n="Dialog - icons, images, shapes.cs" i="288" />
    <s n="Dialog - context menu, dropdown list.cs" i="294" />
    <s n="Dialog - enum check-list, select.cs" i="298" />
    <s n="Dialog - select date.cs" i="269" />
    <s n="Dialog - ListView.cs" i="349" />
    <s n="Dialog - DataGrid.cs" i="350" />
    <s n="Dialog - WebView2 control.cs" i="345" />
    <s n="Dialog - menu bar.cs" i="271" />
    <s n="Dialog - multiple tabs.cs" i="272" />
    <s n="Dialog - Window-based class.cs" i="276" />
    <s n="Dialog - owned, non-modal (don't wait).cs" i="286" />
    <s n="Dialog - window size, position, other properties.cs" i="290" />
    <s n="Dialog - save window placement, control values.cs" i="289" />
    <s n="Dialog - load XAML.cs" i="295" />
    <s n="Dialog - libraries of controls and themes.cs" i="296" />
    <s n="Dialog - use triggers.cs" i="384" />
    <s n="-Dialog - rejected or future.cs" i="297" />
  </d>
  <d n="Math, convert, security" i="129">
    <s n="Math functions.cs" i="145" />
    <s n="Convert to-from string.cs" i="148" />
    <s n="Convert Base64, hex, UTF-8, encoding, urlencode, htmlencode.cs" i="147" />
    <s n="Other conversions.cs" i="146" />
    <s n="Random numbers and strings, GUID.cs" i="149" />
    <s n="Compress data.cs" i="130" />
    <s n="Encrypt, hash.cs" i="157" />
    <s n="Passwords in scripts.cs" i="385" />
    <s n="-Color.cs" i="169" />
  </d>
  <d n="Text" i="18">
    <s n="Strings and characters.cs" i="174" />
    <s n="Simple string functions.cs" i="154" />
    <s n="String formatting with variables.cs" i="158" />
    <s n="Wildcard expressions (compare text).cs" i="159" />
    <s n="Regular expressions (parse text, find-replace).cs" i="155" />
    <s n="Fuzzy string matching, word stemming.cs" i="302" />
  </d>
  <d n="Data, document" i="19">
    <s n="CSV table.cs" i="128" />
    <s n="XML.cs" i="131" />
    <s n="JSON.cs" i="132" />
    <s n="Markdown.cs" i="348" />
    <s n="SQLite database.cs" i="133" />
    <s n="Databases.cs" i="134" />
    <d n="Excel files" i="379">
      <s n="Read Excel files with ExcelDataReader.cs" i="245" />
      <s n="Read-write Excel files with EPPlus.cs" i="246" />
      <s n="Read-write Excel files with ClosedXML.cs" i="380" />
    </d>
    <d n="-Excel automation" i="374">
      <s n="Excel automation script.cs" i="375" />
      <c n="ExcelExt.cs" i="381" />
      <s n="Excel types, get Range etc, use object and dynamic.cs" i="376" />
      <s n="Excel - get and set cell values.cs" i="377" />
      <s n="Excel - TODO.cs" i="383" />
    </d>
  </d>
  <d n="More" i="20">
    <s n="Using .NET, NuGet, other libraries.cs" i="389" />
    <s n="Windows API, native libraries.cs" i="22" />
    <s n="COM components and type libraries.cs" i="249" />
    <s n="Command line programs.cs" i="167" />
    <s n="WMI.cs" i="102" />
    <s n="PowerShell, VBScript, Python.cs" i="103" />
    <s n="Use C# compiler at run time.cs" i="346" />
    <s n="Editor extension - modify UI.cs" i="351" />
    <s n="Frequently asked questions.cs" i="387" />
  </d>
</files>

================================================
FILE: Cpp/Cpp.cpp
================================================
#include "stdafx.h"
#include "Cpp.h"

HRESULT AccAgent::QueryInterface(REFIID riid, void ** ppvObject)
{
	if(riid == IID_IAccessible || riid == IID_IUnknown || riid == IID_IDispatch) {
		*ppvObject = this;
		return 0;
	}
	return E_NOINTERFACE;
}

ULONG AccAgent::AddRef(void)
{
	return 1;
}

ULONG AccAgent::Release(void)
{
	return 1;
}

HRESULT AccAgent::GetTypeInfoCount(UINT * pctinfo)
{
	return E_NOTIMPL;
}

HRESULT AccAgent::GetTypeInfo(UINT iTInfo, LCID lcid, ITypeInfo ** ppTInfo)
{
	return E_NOTIMPL;
}

HRESULT AccAgent::GetIDsOfNames(REFIID riid, LPOLESTR * rgszNames, UINT cNames, LCID lcid, DISPID * rgDispId)
{
	return E_NOTIMPL;
}

HRESULT AccAgent::Invoke(DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS * pDispParams, VARIANT * pVarResult, EXCEPINFO * pExcepInfo, UINT * puArgErr)
{
	return E_NOTIMPL;
}

HRESULT AccAgent::get_accParent(IDispatch ** ppdispParent)
{
	//Print(__FUNCTIONW__);
	*ppdispParent = null;
	return 1;
}

HRESULT AccAgent::get_accChildCount(long * pcountChildren)
{
	return E_NOTIMPL;
}

HRESULT AccAgent::get_accChild(VARIANT varChild, IDispatch ** ppdispChild)
{
	return E_NOTIMPL;
}

HRESULT AccAgent::get_accName(VARIANT varChild, BSTR * pszName)
{
	*pszName = SysAllocString(L"TEST");
	return 0;
}

HRESULT AccAgent::get_accValue(VARIANT varChild, BSTR * pszValue)
{
	return E_NOTIMPL;
}

HRESULT AccAgent::get_accDescription(VARIANT varChild, BSTR * pszDescription)
{
	return E_NOTIMPL;
}

HRESULT AccAgent::get_accRole(VARIANT varChild, VARIANT * pvarRole)
{
	pvarRole->vt = VT_I4; pvarRole->lVal = ROLE_SYSTEM_STATICTEXT;
	return 0;
}

HRESULT AccAgent::get_accState(VARIANT varChild, VARIANT * pvarState)
{
	return E_NOTIMPL;
}

HRESULT AccAgent::get_accHelp(VARIANT varChild, BSTR * pszHelp)
{
	return E_NOTIMPL;
}

HRESULT AccAgent::get_accHelpTopic(BSTR * pszHelpFile, VARIANT varChild, long * pidTopic)
{
	return E_NOTIMPL;
}

HRESULT AccAgent::get_accKeyboardShortcut(VARIANT varChild, BSTR * pszKeyboardShortcut)
{
	return E_NOTIMPL;
}

HRESULT AccAgent::get_accFocus(VARIANT * pvarChild)
{
	return E_NOTIMPL;
}

HRESULT AccAgent::get_accSelection(VARIANT * pvarChildren)
{
	return E_NOTIMPL;
}

HRESULT AccAgent::get_accDefaultAction(VARIANT varChild, BSTR * pszDefaultAction)
{
	return E_NOTIMPL;
}

HRESULT AccAgent::accSelect(long flagsSelect, VARIANT varChild)
{
	return E_NOTIMPL;
}

HRESULT AccAgent::accLocation(long * pxLeft, long * pyTop, long * pcxWidth, long * pcyHeight, VARIANT varChild)
{
	return E_NOTIMPL;
}

LRESULT TestAcc2(HWND w, OUT IAccessible*& iacc);

//HRESULT AccAgent::accNavigate(long navDir, VARIANT varStart, VARIANT * pvarEndUpAt)
//{
//	if(varStart.vt!=VT_BSTR) return 1;
//	//Print(varStart.bstrVal);
//	HWND w = (HWND)navDir;
//	if(TestAcc2(w, *(IAccessible**)&pvarEndUpAt->pdispVal)) return 1;
//	pvarEndUpAt->vt = VT_DISPATCH;
//	return 0;
//}
//
//HRESULT AccAgent::accNavigate(long navDir, VARIANT varStart, VARIANT * pvarEndUpAt)
//{
//	if(varStart.vt!=VT_BSTR) return 1;
//	//Print(varStart.bstrVal);
//	HWND w = (HWND)navDir;
//	if(AccessibleObjectFromWindow(w, 0, IID_IAccessible, (void**)&pvarEndUpAt->pdispVal)) return 1;
//	pvarEndUpAt->vt = VT_DISPATCH;
//	return 0;
//}

HRESULT AccAgent::accNavigate(long navDir, VARIANT varStart, VARIANT * pvarEndUpAt)
{
	//return 1;
	if(varStart.vt!=VT_BSTR) return 1;
	//Print(varStart.bstrVal);
	HWND w = (HWND)(LPARAM)navDir;
	IAccessiblePtr a;
	if(AccessibleObjectFromWindow(w, 0, IID_IAccessible, (void**)&a)) return 1;
	pvarEndUpAt->lVal = (long)LresultFromObject(IID_IAccessible, 0, a);
	pvarEndUpAt->vt = VT_I4;
	return 0;
}

HRESULT AccAgent::accHitTest(long xLeft, long yTop, VARIANT * pvarChild)
{
	return E_NOTIMPL;
}

HRESULT AccAgent::accDoDefaultAction(VARIANT varChild)
{
	return E_NOTIMPL;
}

HRESULT AccAgent::put_accName(VARIANT varChild, BSTR szName)
{
	return E_NOTIMPL;
}

HRESULT AccAgent::put_accValue(VARIANT varChild, BSTR szValue)
{
	return E_NOTIMPL;
}


================================================
FILE: Cpp/Cpp.def
================================================
EXPORTS

UnloadAuCppDll ;__stdcall

pcre2_pattern_info=pcre2_pattern_info_16
pcre2_substring_nametable_scan=pcre2_substring_nametable_scan_16


================================================
FILE: Cpp/Cpp.h
================================================
#pragma once

//This file is used internally.
//	In the future it also could be used by C++ projects. Currently the C++ declarations are not added.
//	Currently this dll is used only by a C# project.

#ifdef Cpp_EXPORTS
#include "stdafx.h"
#define EXPORT extern "C" __declspec(dllexport)
#else
#define EXPORT extern "C" __declspec(dllimport)
#endif

//Cpp_Acc::MISC::flags.
enum class eAccMiscFlags : BYTE {
	InProc = 1, //retrieved inproc
	UIA = 2,
	Java = 4,
	Marked = 128,

	InheritMask = InProc | UIA | Java,
};
ENABLE_BITMASK_OPERATORS(eAccMiscFlags);

//IAccessible* and child element id.
//Has only ctors. Does not have a dtor (does not Release etc), operator=, etc.
struct Cpp_Acc {
	IAccessible* acc;
	long elem;
	struct MISC {
		eAccMiscFlags flags;
		BYTE roleByte; //for optimization. 0 if not set or failed to get. ROLE_CUSTOM (0xFF) if VT_BSTR or not 1-ROLE_MAX.
		WORD level; //for ToString etc. 0 if not set.
	} misc;

	Cpp_Acc() noexcept { Zero(); }

	//Does not AddRef.
	Cpp_Acc(IAccessible* acc_, int elem_, eAccMiscFlags flags_ = {}) noexcept {
		acc = acc_;
		elem = elem_;
		*(DWORD*)&misc = (DWORD)flags_;
	}

#ifdef Cpp_EXPORTS
	void Zero() { memset(this, 0, sizeof(*this)); }
	void SetRoleByte();
	void SetLevel(DWORD level) { misc.level = (WORD)(level < 0xffff ? level : 0xffff); }
#endif
};

#ifdef Cpp_EXPORTS
//Same as Cpp_Acc, but has dtor that calls Release.
#ifdef AGENTCACHE
typedef struct Cpp_Acc Cpp_Acc_Agent;
#else
struct Cpp_Acc_Agent : Cpp_Acc {
	~Cpp_Acc_Agent() {
		if (acc != null) {
			acc->Release();
			acc = null;
		}
	}
};
#endif
#endif

//Flags for Cpp_AccFind.
//The same as C# EFFlags. Documented there.
//[Flags]
enum class eAF {
	Reverse = 1,
	HiddenToo = 2,
	MenuToo = 4,
	ClientArea = 8,
	NotInProc = 0x100,
	UIA = 0x200,
	Mark = 0x10000,
	//used only in this dll
	Marked_ = 0x40000000,
};
ENABLE_BITMASK_OPERATORS(eAF);

//Parameters for Cpp_AccFind.
enum class eAF2;
struct Cpp_AccFindParams {
	STR role, name, prop;
	int roleLength, nameLength, propLength;
	eAF flags;
	int skip;
	WCHAR resultProp;
	eAF2 flags2;

	Cpp_AccFindParams() noexcept { memset(this, 0, sizeof(*this)); }
};

//Cpp_AccFind callback function type.
//Must Release a.iacc. Preferably later, in spare time. Can do it in another thread.
using Cpp_AccFindCallbackT = BOOL(__stdcall*)(Cpp_Acc a, RECT* r);

enum class eXYFlags {
	NotInProc = 1,
	UIA = 2,
	PreferLink = 4,
	//TrySmaller = 8, //rejected 2024-04-16
	OrUIA = 16,

	//internal flags, used in the C# side too
	DpiScaled_ = 0x10000,
	Fail_ = 0x20000,
};
ENABLE_BITMASK_OPERATORS(eXYFlags);

using Cpp_AccFromPointCallbackT = eXYFlags(__stdcall*)(eXYFlags flags, HWND wFP, HWND wTL);

enum class eFocusedFlags {
	NotInProc = 1,
	UIA = 2,
};
ENABLE_BITMASK_OPERATORS(eFocusedFlags);

enum class eError {
	NotFound = 0x1001, //AO not found. With FindAll - no errors. This is actually not an error.
	InvalidParameter = 0x1002, //invalid parameter, for example wildcard expression (or regular expression in it)
	WindowClosed = 0x1003, //the specified window handle is invalid or the window was destroyed while injecting
#ifdef Cpp_EXPORTS
	Inject = 0x1100, //failed to inject this dll into the target process
	WindowOfThisThread = 0x1101, //the specified window belongs to the caller thread
	UseNotInProc = 0x1102, //window class name is Windows.UI.Core.CoreWindow etc
	WaitChromeDisabled = 0x1103, //need to wait while enabling Chrome AOs
	//WaitChromeEnabledPartially = 0x1104, //need to wait more while enabling Chrome AOs
#endif
};

//Our custom OBJID for Cpp_AccFromWindow.
#define OBJID_JAVA -100
#define OBJID_UIA -101

//Our custom NAVDIR_ for Cpp_AccNavigate.
#define NAVDIR_PARENT 9
#define NAVDIR_CHILD 10

//FUTURE: declare exports (when stable), like:
//EXPORT HRESULT Cpp_AccFind(...);

#ifdef Cpp_EXPORTS
#include "util.h"
#include "internal.h"
#endif


================================================
FILE: Cpp/Cpp.manifest
================================================
<?xml version="1.0" encoding="utf-8"?>
<assembly manifestVersion="1.0" xmlns="urn:schemas-microsoft-com:asm.v1">
	<assemblyIdentity version="1.0.0.0" name="Au"/>
	<dependency>
		<dependentAssembly>
			<assemblyIdentity
				type="win32"
				name="Microsoft.Windows.Common-Controls"
				version="6.0.0.0"
				processorArchitecture="*"
				publicKeyToken="6595b64144ccf1df"
				language="*"
        />
		</dependentAssembly>
	</dependency>
</assembly>
<!-- used by ActCtx_ -->


================================================
FILE: Cpp/Cpp.vcxproj
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <ItemGroup Label="ProjectConfigurations">
    <ProjectConfiguration Include="Debug|ARM64">
      <Configuration>Debug</Configuration>
      <Platform>ARM64</Platform>
    </ProjectConfiguration>
    <ProjectConfiguration Include="Debug|Win32">
      <Configuration>Debug</Configuration>
      <Platform>Win32</Platform>
    </ProjectConfiguration>
    <ProjectConfiguration Include="Release|ARM64">
      <Configuration>Release</Configuration>
      <Platform>ARM64</Platform>
    </ProjectConfiguration>
    <ProjectConfiguration Include="Release|Win32">
      <Configuration>Release</Configuration>
      <Platform>Win32</Platform>
    </ProjectConfiguration>
    <ProjectConfiguration Include="Debug|x64">
      <Configuration>Debug</Configuration>
      <Platform>x64</Platform>
    </ProjectConfiguration>
    <ProjectConfiguration Include="Release|x64">
      <Configuration>Release</Configuration>
      <Platform>x64</Platform>
    </ProjectConfiguration>
  </ItemGroup>
  <PropertyGroup Label="Globals">
    <VCProjectVersion>15.0</VCProjectVersion>
    <ProjectGuid>{10559875-C9A1-484C-BCFA-8DC53A428F1C}</ProjectGuid>
    <Keyword>Win32Proj</Keyword>
    <RootNamespace>Cpp</RootNamespace>
    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
  </PropertyGroup>
  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
    <ConfigurationType>DynamicLibrary</ConfigurationType>
    <UseDebugLibraries>true</UseDebugLibraries>
    <PlatformToolset>v143</PlatformToolset>
    <CharacterSet>Unicode</CharacterSet>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
    <ConfigurationType>DynamicLibrary</ConfigurationType>
    <UseDebugLibraries>false</UseDebugLibraries>
    <PlatformToolset>v143</PlatformToolset>
    <WholeProgramOptimization>true</WholeProgramOptimization>
    <CharacterSet>Unicode</CharacterSet>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
    <ConfigurationType>DynamicLibrary</ConfigurationType>
    <UseDebugLibraries>true</UseDebugLibraries>
    <PlatformToolset>v143</PlatformToolset>
    <CharacterSet>Unicode</CharacterSet>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM64'" Label="Configuration">
    <ConfigurationType>DynamicLibrary</ConfigurationType>
    <UseDebugLibraries>true</UseDebugLibraries>
    <PlatformToolset>v143</PlatformToolset>
    <CharacterSet>Unicode</CharacterSet>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
    <ConfigurationType>DynamicLibrary</ConfigurationType>
    <UseDebugLibraries>false</UseDebugLibraries>
    <PlatformToolset>v143</PlatformToolset>
    <WholeProgramOptimization>true</WholeProgramOptimization>
    <CharacterSet>Unicode</CharacterSet>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'" Label="Configuration">
    <ConfigurationType>DynamicLibrary</ConfigurationType>
    <UseDebugLibraries>false</UseDebugLibraries>
    <PlatformToolset>v143</PlatformToolset>
    <WholeProgramOptimization>true</WholeProgramOptimization>
    <CharacterSet>Unicode</CharacterSet>
  </PropertyGroup>
  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
  <ImportGroup Label="ExtensionSettings">
  </ImportGroup>
  <ImportGroup Label="Shared">
  </ImportGroup>
  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
  </ImportGroup>
  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
  </ImportGroup>
  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
  </ImportGroup>
  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM64'" Label="PropertySheets">
    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
  </ImportGroup>
  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
  </ImportGroup>
  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'" Label="PropertySheets">
    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
  </ImportGroup>
  <PropertyGroup Label="UserMacros" />
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
    <LinkIncremental>true</LinkIncremental>
    <TargetName>AuCpp</TargetName>
    <OutDir>bin\$(Configuration)\$(Platform)\</OutDir>
    <IntDir>obj\$(Configuration)\$(Platform)\</IntDir>
    <GenerateManifest>false</GenerateManifest>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
    <TargetName>AuCpp</TargetName>
    <OutDir>bin\$(Configuration)\$(Platform)\</OutDir>
    <IntDir>obj\$(Configuration)\$(Platform)\</IntDir>
    <GenerateManifest>false</GenerateManifest>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM64'">
    <TargetName>AuCpp</TargetName>
    <OutDir>bin\$(Configuration)\$(Platform)\</OutDir>
    <IntDir>obj\$(Configuration)\$(Platform)\</IntDir>
    <GenerateManifest>false</GenerateManifest>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
    <LinkIncremental>false</LinkIncremental>
    <TargetName>AuCpp</TargetName>
    <OutDir>bin\$(Configuration)\$(Platform)\</OutDir>
    <IntDir>obj\$(Configuration)\$(Platform)\</IntDir>
    <GenerateManifest>false</GenerateManifest>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
    <LinkIncremental>false</LinkIncremental>
    <TargetName>AuCpp</TargetName>
    <OutDir>bin\$(Configuration)\$(Platform)\</OutDir>
    <IntDir>obj\$(Configuration)\$(Platform)\</IntDir>
    <GenerateManifest>false</GenerateManifest>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'">
    <LinkIncremental>false</LinkIncremental>
    <TargetName>AuCpp</TargetName>
    <OutDir>bin\$(Configuration)\$(Platform)\</OutDir>
    <IntDir>obj\$(Configuration)\$(Platform)\</IntDir>
    <GenerateManifest>false</GenerateManifest>
  </PropertyGroup>
  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
    <ClCompile>
      <WarningLevel>Level3</WarningLevel>
      <Optimization>Disabled</Optimization>
      <PreprocessorDefinitions>WIN32;_DEBUG;Cpp_EXPORTS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
      <LanguageStandard>stdcpp20</LanguageStandard>
      <PrecompiledHeader>Use</PrecompiledHeader>
    </ClCompile>
    <Link>
      <SubSystem>Windows</SubSystem>
      <GenerateDebugInformation>true</GenerateDebugInformation>
      <ModuleDefinitionFile>Cpp.def</ModuleDefinitionFile>
    </Link>
    <PostBuildEvent>
      <Command>$(SolutionDir)Other\BuildEvents\bin\Debug\BuildEvents.exe cppPostBuild $(Configuration) $(Platform)</Command>
    </PostBuildEvent>
  </ItemDefinitionGroup>
  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
    <ClCompile>
      <WarningLevel>Level3</WarningLevel>
      <Optimization>Disabled</Optimization>
      <PreprocessorDefinitions>_DEBUG;Cpp_EXPORTS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
      <LanguageStandard>stdcpp20</LanguageStandard>
      <PrecompiledHeader>Use</PrecompiledHeader>
    </ClCompile>
    <Link>
      <SubSystem>Windows</SubSystem>
      <GenerateDebugInformation>true</GenerateDebugInformation>
      <ModuleDefinitionFile>Cpp.def</ModuleDefinitionFile>
    </Link>
    <PostBuildEvent>
      <Command>$(SolutionDir)Other\BuildEvents\bin\Debug\BuildEvents.exe cppPostBuild $(Configuration) $(Platform)</Command>
    </PostBuildEvent>
  </ItemDefinitionGroup>
  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM64'">
    <ClCompile>
      <WarningLevel>Level3</WarningLevel>
      <Optimization>Disabled</Optimization>
      <PreprocessorDefinitions>_DEBUG;Cpp_EXPORTS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
      <LanguageStandard>stdcpp20</LanguageStandard>
      <PrecompiledHeader>Use</PrecompiledHeader>
    </ClCompile>
    <Link>
      <SubSystem>Windows</SubSystem>
      <GenerateDebugInformation>true</GenerateDebugInformation>
      <ModuleDefinitionFile>Cpp.def</ModuleDefinitionFile>
    </Link>
    <PostBuildEvent>
      <Command>$(SolutionDir)Other\BuildEvents\bin\Debug\BuildEvents.exe cppPostBuild $(Configuration) $(Platform)</Command>
    </PostBuildEvent>
  </ItemDefinitionGroup>
  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
    <ClCompile>
      <WarningLevel>Level3</WarningLevel>
      <Optimization>MaxSpeed</Optimization>
      <FunctionLevelLinking>true</FunctionLevelLinking>
      <IntrinsicFunctions>true</IntrinsicFunctions>
      <PreprocessorDefinitions>WIN32;NDEBUG;Cpp_EXPORTS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
      <StringPooling>true</StringPooling>
      <BufferSecurityCheck>false</BufferSecurityCheck>
      <LanguageStandard>stdcpp20</LanguageStandard>
      <PrecompiledHeader>Use</PrecompiledHeader>
    </ClCompile>
    <Link>
      <SubSystem>Windows</SubSystem>
      <EnableCOMDATFolding>true</EnableCOMDATFolding>
      <OptimizeReferences>true</OptimizeReferences>
      <GenerateDebugInformation>true</GenerateDebugInformation>
      <ModuleDefinitionFile>Cpp.def</ModuleDefinitionFile>
    </Link>
    <PostBuildEvent>
      <Command>$(SolutionDir)Other\BuildEvents\bin\Debug\BuildEvents.exe cppPostBuild $(Configuration) $(Platform)</Command>
    </PostBuildEvent>
  </ItemDefinitionGroup>
  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
    <ClCompile>
      <WarningLevel>Level3</WarningLevel>
      <Optimization>MaxSpeed</Optimization>
      <FunctionLevelLinking>true</FunctionLevelLinking>
      <IntrinsicFunctions>true</IntrinsicFunctions>
      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
      <StringPooling>true</StringPooling>
      <BufferSecurityCheck>false</BufferSecurityCheck>
      <LanguageStandard>stdcpp20</LanguageStandard>
      <PreprocessorDefinitions>NDEBUG;Cpp_EXPORTS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <PrecompiledHeader>Use</PrecompiledHeader>
    </ClCompile>
    <Link>
      <SubSystem>Windows</SubSystem>
      <EnableCOMDATFolding>true</EnableCOMDATFolding>
      <OptimizeReferences>true</OptimizeReferences>
      <GenerateDebugInformation>true</GenerateDebugInformation>
      <ModuleDefinitionFile>Cpp.def</ModuleDefinitionFile>
    </Link>
    <PostBuildEvent>
      <Command>$(SolutionDir)Other\BuildEvents\bin\Debug\BuildEvents.exe cppPostBuild $(Configuration) $(Platform)</Command>
    </PostBuildEvent>
  </ItemDefinitionGroup>
  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'">
    <ClCompile>
      <WarningLevel>Level3</WarningLevel>
      <Optimization>MaxSpeed</Optimization>
      <FunctionLevelLinking>true</FunctionLevelLinking>
      <IntrinsicFunctions>true</IntrinsicFunctions>
      <PreprocessorDefinitions>NDEBUG;Cpp_EXPORTS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
      <StringPooling>true</StringPooling>
      <BufferSecurityCheck>false</BufferSecurityCheck>
      <LanguageStandard>stdcpp20</LanguageStandard>
      <PrecompiledHeader>Use</PrecompiledHeader>
    </ClCompile>
    <Link>
      <SubSystem>Windows</SubSystem>
      <EnableCOMDATFolding>true</EnableCOMDATFolding>
      <OptimizeReferences>true</OptimizeReferences>
      <GenerateDebugInformation>true</GenerateDebugInformation>
      <ModuleDefinitionFile>Cpp.def</ModuleDefinitionFile>
    </Link>
    <PostBuildEvent>
      <Command>$(SolutionDir)Other\BuildEvents\bin\Debug\BuildEvents.exe cppPostBuild $(Configuration) $(Platform)</Command>
    </PostBuildEvent>
  </ItemDefinitionGroup>
  <ItemGroup>
    <ClCompile Include="acc bridge.cpp" />
    <ClCompile Include="acc get.cpp" />
    <ClCompile Include="acc java.cpp" />
    <ClCompile Include="acc func.cpp" />
    <ClCompile Include="acc web.cpp" />
    <ClCompile Include="acc workaround.cpp" />
    <ClCompile Include="MemoryPool.cpp">
      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">NotUsing</PrecompiledHeader>
      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">NotUsing</PrecompiledHeader>
      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|ARM64'">NotUsing</PrecompiledHeader>
      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'">NotUsing</PrecompiledHeader>
      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotUsing</PrecompiledHeader>
      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">NotUsing</PrecompiledHeader>
    </ClCompile>
    <ClCompile Include="other.cpp" />
    <ClCompile Include="str.cpp" />
    <ClCompile Include="acc uia.cpp" />
    <ClCompile Include="in-proc.cpp" />
    <ClCompile Include="rejected.cpp">
      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</ExcludedFromBuild>
      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</ExcludedFromBuild>
      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</ExcludedFromBuild>
      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|ARM64'">true</ExcludedFromBuild>
      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</ExcludedFromBuild>
      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'">true</ExcludedFromBuild>
    </ClCompile>
    <ClCompile Include="test.cpp" />
    <ClCompile Include="stdafx.cpp">
      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">Create</PrecompiledHeader>
      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">Create</PrecompiledHeader>
      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">Create</PrecompiledHeader>
      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|ARM64'">Create</PrecompiledHeader>
      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">Create</PrecompiledHeader>
      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'">Create</PrecompiledHeader>
    </ClCompile>
    <ClCompile Include="acc find.cpp" />
    <ClCompile Include="test Uia.cpp">
      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</ExcludedFromBuild>
      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</ExcludedFromBuild>
      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</ExcludedFromBuild>
      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|ARM64'">true</ExcludedFromBuild>
      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</ExcludedFromBuild>
      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'">true</ExcludedFromBuild>
    </ClCompile>
    <ClCompile Include="util.cpp" />
  </ItemGroup>
  <ItemGroup>
    <None Include="Cpp.def" />
  </ItemGroup>
  <ItemGroup>
    <ClInclude Include="acc.h" />
    <ClInclude Include="Cpp.h" />
    <ClInclude Include="IAccessible2.h" />
    <ClInclude Include="ISimpleDOMDocument.h" />
    <ClInclude Include="ISimpleDOMNode.h" />
    <ClInclude Include="ISimpleDOMText.h" />
    <ClInclude Include="JAB.h" />
    <ClInclude Include="MemoryPool.h" />
    <ClInclude Include="resource.h" />
    <ClInclude Include="str.h" />
    <ClInclude Include="internal.h" />
    <ClInclude Include="stdafx.h" />
    <ClInclude Include="util.h" />
  </ItemGroup>
  <ItemGroup>
    <ProjectReference Include="..\Libraries\PCRE\PCRE.vcxproj">
      <Project>{190bc611-ee00-4b10-87f2-a7e73b639e59}</Project>
    </ProjectReference>
  </ItemGroup>
  <ItemGroup>
    <Manifest Include="Cpp.manifest" />
  </ItemGroup>
  <ItemGroup>
    <ResourceCompile Include="Cpp.rc" />
  </ItemGroup>
  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
  <ImportGroup Label="ExtensionTargets">
  </ImportGroup>
</Project>

================================================
FILE: Cpp/Cpp.vcxproj.filters
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <ItemGroup>
    <Filter Include="Source Files">
      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
    </Filter>
    <Filter Include="Header Files">
      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
      <Extensions>h;hh;hpp;hxx;hm;inl;inc;xsd</Extensions>
    </Filter>
    <Filter Include="Resource Files">
      <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
      <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
    </Filter>
    <Filter Include="Source Files\excluded">
      <UniqueIdentifier>{f751c698-699c-468e-b313-9e671a759bce}</UniqueIdentifier>
    </Filter>
    <Filter Include="Source Files\util">
      <UniqueIdentifier>{37c1e08a-2650-49cc-8f21-56b63486efaf}</UniqueIdentifier>
    </Filter>
    <Filter Include="Source Files\inactive">
      <UniqueIdentifier>{99af6249-7074-418b-8e33-94bba38046d9}</UniqueIdentifier>
    </Filter>
    <Filter Include="Source Files\Acc">
      <UniqueIdentifier>{2173271c-7256-4ff0-8dd2-a9016fd326db}</UniqueIdentifier>
    </Filter>
    <Filter Include="Source Files\other">
      <UniqueIdentifier>{e8318082-67dd-44f1-8bfd-e6fc6d1f1758}</UniqueIdentifier>
    </Filter>
    <Filter Include="Header Files\interfaces">
      <UniqueIdentifier>{90b98acd-e3dc-495a-8cf1-aa3b8fe0f956}</UniqueIdentifier>
    </Filter>
  </ItemGroup>
  <ItemGroup>
    <ClCompile Include="test.cpp">
      <Filter>Source Files</Filter>
    </ClCompile>
    <ClCompile Include="test Uia.cpp">
      <Filter>Source Files\excluded</Filter>
    </ClCompile>
    <ClCompile Include="rejected.cpp">
      <Filter>Source Files\excluded</Filter>
    </ClCompile>
    <ClCompile Include="in-proc.cpp">
      <Filter>Source Files</Filter>
    </ClCompile>
    <ClCompile Include="util.cpp">
      <Filter>Source Files\util</Filter>
    </ClCompile>
    <ClCompile Include="str.cpp">
      <Filter>Source Files\util</Filter>
    </ClCompile>
    <ClCompile Include="acc bridge.cpp">
      <Filter>Source Files\Acc</Filter>
    </ClCompile>
    <ClCompile Include="acc find.cpp">
      <Filter>Source Files\Acc</Filter>
    </ClCompile>
    <ClCompile Include="acc func.cpp">
      <Filter>Source Files\Acc</Filter>
    </ClCompile>
    <ClCompile Include="acc get.cpp">
      <Filter>Source Files\Acc</Filter>
    </ClCompile>
    <ClCompile Include="acc java.cpp">
      <Filter>Source Files\Acc</Filter>
    </ClCompile>
    <ClCompile Include="acc uia.cpp">
      <Filter>Source Files\Acc</Filter>
    </ClCompile>
    <ClCompile Include="acc web.cpp">
      <Filter>Source Files\Acc</Filter>
    </ClCompile>
    <ClCompile Include="other.cpp">
      <Filter>Source Files\other</Filter>
    </ClCompile>
    <ClCompile Include="acc workaround.cpp">
      <Filter>Source Files\other</Filter>
    </ClCompile>
    <ClCompile Include="MemoryPool.cpp">
      <Filter>Source Files\util</Filter>
    </ClCompile>
    <ClCompile Include="stdafx.cpp">
      <Filter>Header Files</Filter>
    </ClCompile>
  </ItemGroup>
  <ItemGroup>
    <ClInclude Include="Cpp.h">
      <Filter>Header Files</Filter>
    </ClInclude>
    <ClInclude Include="stdafx.h">
      <Filter>Header Files</Filter>
    </ClInclude>
    <ClInclude Include="internal.h">
      <Filter>Header Files</Filter>
    </ClInclude>
    <ClInclude Include="str.h">
      <Filter>Source Files\util</Filter>
    </ClInclude>
    <ClInclude Include="util.h">
      <Filter>Source Files\util</Filter>
    </ClInclude>
    <ClInclude Include="JAB.h">
      <Filter>Source Files\Acc</Filter>
    </ClInclude>
    <ClInclude Include="acc.h">
      <Filter>Source Files\Acc</Filter>
    </ClInclude>
    <ClInclude Include="MemoryPool.h">
      <Filter>Source Files\util</Filter>
    </ClInclude>
    <ClInclude Include="resource.h">
      <Filter>Header Files</Filter>
    </ClInclude>
    <ClInclude Include="IAccessible2.h">
      <Filter>Header Files\interfaces</Filter>
    </ClInclude>
    <ClInclude Include="ISimpleDOMDocument.h">
      <Filter>Header Files\interfaces</Filter>
    </ClInclude>
    <ClInclude Include="ISimpleDOMNode.h">
      <Filter>Header Files\interfaces</Filter>
    </ClInclude>
    <ClInclude Include="ISimpleDOMText.h">
      <Filter>Header Files\interfaces</Filter>
    </ClInclude>
  </ItemGroup>
  <ItemGroup>
    <None Include="Cpp.def">
      <Filter>Header Files</Filter>
    </None>
  </ItemGroup>
  <ItemGroup>
    <Manifest Include="Cpp.manifest">
      <Filter>Resource Files</Filter>
    </Manifest>
  </ItemGroup>
  <ItemGroup>
    <ResourceCompile Include="Cpp.rc">
      <Filter>Resource Files</Filter>
    </ResourceCompile>
  </ItemGroup>
</Project>

================================================
FILE: Cpp/IAccessible2.h
================================================


/* this ALWAYS GENERATED file contains the definitions for the interfaces */


 /* File created by MIDL compiler version 7.00.0500 */
/* at Sat Jan 18 19:37:28 2014
 */
/* Compiler settings for .\IAccessible2.idl:
    Oicf, W1, Zp8, env=Win32 (32b run)
    protocol : dce , ms_ext, c_ext, robust
    error checks: allocation ref bounds_check enum stub_data 
    VC __declspec() decoration level: 
         __declspec(uuid()), __declspec(selectany), __declspec(novtable)
         DECLSPEC_UUID(), MIDL_INTERFACE()
*/
//@@MIDL_FILE_HEADING(  )

#pragma warning( disable: 4049 )  /* more than 64k source lines */


/* verify that the <rpcndr.h> version is high enough to compile this file*/
#ifndef __REQUIRED_RPCNDR_H_VERSION__
#define __REQUIRED_RPCNDR_H_VERSION__ 475
#endif

#include "rpc.h"
#include "rpcndr.h"

#ifndef __RPCNDR_H_VERSION__
#error this stub requires an updated version of <rpcndr.h>
#endif // __RPCNDR_H_VERSION__

#ifndef COM_NO_WINDOWS_H
#include "windows.h"
#include "ole2.h"
#endif /*COM_NO_WINDOWS_H*/

#ifndef __IAccessible2_h__
#define __IAccessible2_h__

#if defined(_MSC_VER) && (_MSC_VER >= 1020)
#pragma once
#endif

/* Forward Declarations */ 

#ifndef __IAccessibleRelation_FWD_DEFINED__
#define __IAccessibleRelation_FWD_DEFINED__
typedef interface IAccessibleRelation IAccessibleRelation;
#endif 	/* __IAccessibleRelation_FWD_DEFINED__ */


#ifndef __IAccessibleAction_FWD_DEFINED__
#define __IAccessibleAction_FWD_DEFINED__
typedef interface IAccessibleAction IAccessibleAction;
#endif 	/* __IAccessibleAction_FWD_DEFINED__ */


#ifndef __IAccessible2_FWD_DEFINED__
#define __IAccessible2_FWD_DEFINED__
typedef interface IAccessible2 IAccessible2;
#endif 	/* __IAccessible2_FWD_DEFINED__ */


#ifndef __IAccessible2_2_FWD_DEFINED__
#define __IAccessible2_2_FWD_DEFINED__
typedef interface IAccessible2_2 IAccessible2_2;
#endif 	/* __IAccessible2_2_FWD_DEFINED__ */


#ifndef __IAccessibleComponent_FWD_DEFINED__
#define __IAccessibleComponent_FWD_DEFINED__
typedef interface IAccessibleComponent IAccessibleComponent;
#endif 	/* __IAccessibleComponent_FWD_DEFINED__ */


#ifndef __IAccessibleValue_FWD_DEFINED__
#define __IAccessibleValue_FWD_DEFINED__
typedef interface IAccessibleValue IAccessibleValue;
#endif 	/* __IAccessibleValue_FWD_DEFINED__ */


#ifndef __IAccessibleText_FWD_DEFINED__
#define __IAccessibleText_FWD_DEFINED__
typedef interface IAccessibleText IAccessibleText;
#endif 	/* __IAccessibleText_FWD_DEFINED__ */


#ifndef __IAccessibleText2_FWD_DEFINED__
#define __IAccessibleText2_FWD_DEFINED__
typedef interface IAccessibleText2 IAccessibleText2;
#endif 	/* __IAccessibleText2_FWD_DEFINED__ */


#ifndef __IAccessibleEditableText_FWD_DEFINED__
#define __IAccessibleEditableText_FWD_DEFINED__
typedef interface IAccessibleEditableText IAccessibleEditableText;
#endif 	/* __IAccessibleEditableText_FWD_DEFINED__ */


#ifndef __IAccessibleHyperlink_FWD_DEFINED__
#define __IAccessibleHyperlink_FWD_DEFINED__
typedef interface IAccessibleHyperlink IAccessibleHyperlink;
#endif 	/* __IAccessibleHyperlink_FWD_DEFINED__ */


#ifndef __IAccessibleHypertext_FWD_DEFINED__
#define __IAccessibleHypertext_FWD_DEFINED__
typedef interface IAccessibleHypertext IAccessibleHypertext;
#endif 	/* __IAccessibleHypertext_FWD_DEFINED__ */


#ifndef __IAccessibleHypertext2_FWD_DEFINED__
#define __IAccessibleHypertext2_FWD_DEFINED__
typedef interface IAccessibleHypertext2 IAccessibleHypertext2;
#endif 	/* __IAccessibleHypertext2_FWD_DEFINED__ */


#ifndef __IAccessibleTable_FWD_DEFINED__
#define __IAccessibleTable_FWD_DEFINED__
typedef interface IAccessibleTable IAccessibleTable;
#endif 	/* __IAccessibleTable_FWD_DEFINED__ */


#ifndef __IAccessibleTable2_FWD_DEFINED__
#define __IAccessibleTable2_FWD_DEFINED__
typedef interface IAccessibleTable2 IAccessibleTable2;
#endif 	/* __IAccessibleTable2_FWD_DEFINED__ */


#ifndef __IAccessibleTableCell_FWD_DEFINED__
#define __IAccessibleTableCell_FWD_DEFINED__
typedef interface IAccessibleTableCell IAccessibleTableCell;
#endif 	/* __IAccessibleTableCell_FWD_DEFINED__ */


#ifndef __IAccessibleImage_FWD_DEFINED__
#define __IAccessibleImage_FWD_DEFINED__
typedef interface IAccessibleImage IAccessibleImage;
#endif 	/* __IAccessibleImage_FWD_DEFINED__ */


#ifndef __IAccessibleApplication_FWD_DEFINED__
#define __IAccessibleApplication_FWD_DEFINED__
typedef interface IAccessibleApplication IAccessibleApplication;
#endif 	/* __IAccessibleApplication_FWD_DEFINED__ */


#ifndef __IAccessibleDocument_FWD_DEFINED__
#define __IAccessibleDocument_FWD_DEFINED__
typedef interface IAccessibleDocument IAccessibleDocument;
#endif 	/* __IAccessibleDocument_FWD_DEFINED__ */


#ifndef __IAccessible2_FWD_DEFINED__
#define __IAccessible2_FWD_DEFINED__
typedef interface IAccessible2 IAccessible2;
#endif 	/* __IAccessible2_FWD_DEFINED__ */


#ifndef __IAccessible2_2_FWD_DEFINED__
#define __IAccessible2_2_FWD_DEFINED__
typedef interface IAccessible2_2 IAccessible2_2;
#endif 	/* __IAccessible2_2_FWD_DEFINED__ */


#ifndef __IAccessibleAction_FWD_DEFINED__
#define __IAccessibleAction_FWD_DEFINED__
typedef interface IAccessibleAction IAccessibleAction;
#endif 	/* __IAccessibleAction_FWD_DEFINED__ */


#ifndef __IAccessibleApplication_FWD_DEFINED__
#define __IAccessibleApplication_FWD_DEFINED__
typedef interface IAccessibleApplication IAccessibleApplication;
#endif 	/* __IAccessibleApplication_FWD_DEFINED__ */


#ifndef __IAccessibleComponent_FWD_DEFINED__
#define __IAccessibleComponent_FWD_DEFINED__
typedef interface IAccessibleComponent IAccessibleComponent;
#endif 	/* __IAccessibleComponent_FWD_DEFINED__ */


#ifndef __IAccessibleDocument_FWD_DEFINED__
#define __IAccessibleDocument_FWD_DEFINED__
typedef interface IAccessibleDocument IAccessibleDocument;
#endif 	/* __IAccessibleDocument_FWD_DEFINED__ */


#ifndef __IAccessibleEditableText_FWD_DEFINED__
#define __IAccessibleEditableText_FWD_DEFINED__
typedef interface IAccessibleEditableText IAccessibleEditableText;
#endif 	/* __IAccessibleEditableText_FWD_DEFINED__ */


#ifndef __IAccessibleHyperlink_FWD_DEFINED__
#define __IAccessibleHyperlink_FWD_DEFINED__
typedef interface IAccessibleHyperlink IAccessibleHyperlink;
#endif 	/* __IAccessibleHyperlink_FWD_DEFINED__ */


#ifndef __IAccessibleText_FWD_DEFINED__
#define __IAccessibleText_FWD_DEFINED__
typedef interface IAccessibleText IAccessibleText;
#endif 	/* __IAccessibleText_FWD_DEFINED__ */


#ifndef __IAccessibleHypertext_FWD_DEFINED__
#define __IAccessibleHypertext_FWD_DEFINED__
typedef interface IAccessibleHypertext IAccessibleHypertext;
#endif 	/* __IAccessibleHypertext_FWD_DEFINED__ */


#ifndef __IAccessibleHypertext2_FWD_DEFINED__
#define __IAccessibleHypertext2_FWD_DEFINED__
typedef interface IAccessibleHypertext2 IAccessibleHypertext2;
#endif 	/* __IAccessibleHypertext2_FWD_DEFINED__ */


#ifndef __IAccessibleImage_FWD_DEFINED__
#define __IAccessibleImage_FWD_DEFINED__
typedef interface IAccessibleImage IAccessibleImage;
#endif 	/* __IAccessibleImage_FWD_DEFINED__ */


#ifndef __IAccessibleRelation_FWD_DEFINED__
#define __IAccessibleRelation_FWD_DEFINED__
typedef interface IAccessibleRelation IAccessibleRelation;
#endif 	/* __IAccessibleRelation_FWD_DEFINED__ */


#ifndef __IAccessibleTable_FWD_DEFINED__
#define __IAccessibleTable_FWD_DEFINED__
typedef interface IAccessibleTable IAccessibleTable;
#endif 	/* __IAccessibleTable_FWD_DEFINED__ */


#ifndef __IAccessibleTable2_FWD_DEFINED__
#define __IAccessibleTable2_FWD_DEFINED__
typedef interface IAccessibleTable2 IAccessibleTable2;
#endif 	/* __IAccessibleTable2_FWD_DEFINED__ */


#ifndef __IAccessibleTableCell_FWD_DEFINED__
#define __IAccessibleTableCell_FWD_DEFINED__
typedef interface IAccessibleTableCell IAccessibleTableCell;
#endif 	/* __IAccessibleTableCell_FWD_DEFINED__ */


#ifndef __IAccessibleText2_FWD_DEFINED__
#define __IAccessibleText2_FWD_DEFINED__
typedef interface IAccessibleText2 IAccessibleText2;
#endif 	/* __IAccessibleText2_FWD_DEFINED__ */


#ifndef __IAccessibleValue_FWD_DEFINED__
#define __IAccessibleValue_FWD_DEFINED__
typedef interface IAccessibleValue IAccessibleValue;
#endif 	/* __IAccessibleValue_FWD_DEFINED__ */


/* header files for imported files */
#include "objidl.h"
#include "oaidl.h"
#include "oleacc.h"

#ifdef __cplusplus
extern "C"{
#endif 


/* interface __MIDL_itf_IAccessible2_0000_0000 */
/* [local] */ 


enum IA2ScrollType
    {	IA2_SCROLL_TYPE_TOP_LEFT	= 0,
	IA2_SCROLL_TYPE_BOTTOM_RIGHT	= ( IA2_SCROLL_TYPE_TOP_LEFT + 1 ) ,
	IA2_SCROLL_TYPE_TOP_EDGE	= ( IA2_SCROLL_TYPE_BOTTOM_RIGHT + 1 ) ,
	IA2_SCROLL_TYPE_BOTTOM_EDGE	= ( IA2_SCROLL_TYPE_TOP_EDGE + 1 ) ,
	IA2_SCROLL_TYPE_LEFT_EDGE	= ( IA2_SCROLL_TYPE_BOTTOM_EDGE + 1 ) ,
	IA2_SCROLL_TYPE_RIGHT_EDGE	= ( IA2_SCROLL_TYPE_LEFT_EDGE + 1 ) ,
	IA2_SCROLL_TYPE_ANYWHERE	= ( IA2_SCROLL_TYPE_RIGHT_EDGE + 1 ) 
    } ;

enum IA2CoordinateType
    {	IA2_COORDTYPE_SCREEN_RELATIVE	= 0,
	IA2_COORDTYPE_PARENT_RELATIVE	= ( IA2_COORDTYPE_SCREEN_RELATIVE + 1 ) 
    } ;

enum IA2TextSpecialOffsets
    {	IA2_TEXT_OFFSET_LENGTH	= -1,
	IA2_TEXT_OFFSET_CARET	= -2
    } ;

enum IA2TableModelChangeType
    {	IA2_TABLE_MODEL_CHANGE_INSERT	= 0,
	IA2_TABLE_MODEL_CHANGE_DELETE	= ( IA2_TABLE_MODEL_CHANGE_INSERT + 1 ) ,
	IA2_TABLE_MODEL_CHANGE_UPDATE	= ( IA2_TABLE_MODEL_CHANGE_DELETE + 1 ) 
    } ;
typedef struct IA2TableModelChange
    {
    enum IA2TableModelChangeType type;
    long firstRow;
    long lastRow;
    long firstColumn;
    long lastColumn;
    } 	IA2TableModelChange;

#define	IA2_RELATION_CONTAINING_APPLICATION	( L"containingApplication" )

#define	IA2_RELATION_CONTAINING_DOCUMENT	( L"containingDocument" )

#define	IA2_RELATION_CONTAINING_TAB_PANE	( L"containingTabPane" )

#define	IA2_RELATION_CONTAINING_WINDOW	( L"containingWindow" )

#define	IA2_RELATION_CONTROLLED_BY	( L"controlledBy" )

#define	IA2_RELATION_CONTROLLER_FOR	( L"controllerFor" )

#define	IA2_RELATION_DESCRIBED_BY	( L"describedBy" )

#define	IA2_RELATION_DESCRIPTION_FOR	( L"descriptionFor" )

#define	IA2_RELATION_EMBEDDED_BY	( L"embeddedBy" )

#define	IA2_RELATION_EMBEDS	( L"embeds" )

#define	IA2_RELATION_FLOWS_FROM	( L"flowsFrom" )

#define	IA2_RELATION_FLOWS_TO	( L"flowsTo" )

#define	IA2_RELATION_LABEL_FOR	( L"labelFor" )

#define	IA2_RELATION_LABELED_BY	( L"labelledBy" )

#define	IA2_RELATION_LABELLED_BY	( L"labelledBy" )

#define	IA2_RELATION_MEMBER_OF	( L"memberOf" )

#define	IA2_RELATION_NEXT_TABBABLE	( L"nextTabbable" )

#define	IA2_RELATION_NODE_CHILD_OF	( L"nodeChildOf" )

#define	IA2_RELATION_NODE_PARENT_OF	( L"nodeParentOf" )

#define	IA2_RELATION_PARENT_WINDOW_OF	( L"parentWindowOf" )

#define	IA2_RELATION_POPUP_FOR	( L"popupFor" )

#define	IA2_RELATION_PREVIOUS_TABBABLE	( L"previousTabbable" )

#define	IA2_RELATION_SUBWINDOW_OF	( L"subwindowOf" )



extern RPC_IF_HANDLE __MIDL_itf_IAccessible2_0000_0000_v0_0_c_ifspec;
extern RPC_IF_HANDLE __MIDL_itf_IAccessible2_0000_0000_v0_0_s_ifspec;

#ifndef __IAccessibleRelation_INTERFACE_DEFINED__
#define __IAccessibleRelation_INTERFACE_DEFINED__

/* interface IAccessibleRelation */
/* [uuid][object] */ 


EXTERN_C const IID IID_IAccessibleRelation;

#if defined(__cplusplus) && !defined(CINTERFACE)
    
    MIDL_INTERFACE("7CDF86EE-C3DA-496a-BDA4-281B336E1FDC")
    IAccessibleRelation : public IUnknown
    {
    public:
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_relationType( 
            /* [retval][out] */ BSTR *relationType) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_localizedRelationType( 
            /* [retval][out] */ BSTR *localizedRelationType) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_nTargets( 
            /* [retval][out] */ long *nTargets) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_target( 
            /* [in] */ long targetIndex,
            /* [retval][out] */ IUnknown **target) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_targets( 
            /* [in] */ long maxTargets,
            /* [length_is][size_is][out] */ IUnknown **targets,
            /* [retval][out] */ long *nTargets) = 0;
        
    };
    
#else 	/* C style interface */

    typedef struct IAccessibleRelationVtbl
    {
        BEGIN_INTERFACE
        
        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
            IAccessibleRelation * This,
            /* [in] */ REFIID riid,
            /* [iid_is][out] */ 
            __RPC__deref_out  void **ppvObject);
        
        ULONG ( STDMETHODCALLTYPE *AddRef )( 
            IAccessibleRelation * This);
        
        ULONG ( STDMETHODCALLTYPE *Release )( 
            IAccessibleRelation * This);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_relationType )( 
            IAccessibleRelation * This,
            /* [retval][out] */ BSTR *relationType);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_localizedRelationType )( 
            IAccessibleRelation * This,
            /* [retval][out] */ BSTR *localizedRelationType);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_nTargets )( 
            IAccessibleRelation * This,
            /* [retval][out] */ long *nTargets);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_target )( 
            IAccessibleRelation * This,
            /* [in] */ long targetIndex,
            /* [retval][out] */ IUnknown **target);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_targets )( 
            IAccessibleRelation * This,
            /* [in] */ long maxTargets,
            /* [length_is][size_is][out] */ IUnknown **targets,
            /* [retval][out] */ long *nTargets);
        
        END_INTERFACE
    } IAccessibleRelationVtbl;

    interface IAccessibleRelation
    {
        CONST_VTBL struct IAccessibleRelationVtbl *lpVtbl;
    };

    

#ifdef COBJMACROS


#define IAccessibleRelation_QueryInterface(This,riid,ppvObject)	\
    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 

#define IAccessibleRelation_AddRef(This)	\
    ( (This)->lpVtbl -> AddRef(This) ) 

#define IAccessibleRelation_Release(This)	\
    ( (This)->lpVtbl -> Release(This) ) 


#define IAccessibleRelation_get_relationType(This,relationType)	\
    ( (This)->lpVtbl -> get_relationType(This,relationType) ) 

#define IAccessibleRelation_get_localizedRelationType(This,localizedRelationType)	\
    ( (This)->lpVtbl -> get_localizedRelationType(This,localizedRelationType) ) 

#define IAccessibleRelation_get_nTargets(This,nTargets)	\
    ( (This)->lpVtbl -> get_nTargets(This,nTargets) ) 

#define IAccessibleRelation_get_target(This,targetIndex,target)	\
    ( (This)->lpVtbl -> get_target(This,targetIndex,target) ) 

#define IAccessibleRelation_get_targets(This,maxTargets,targets,nTargets)	\
    ( (This)->lpVtbl -> get_targets(This,maxTargets,targets,nTargets) ) 

#endif /* COBJMACROS */


#endif 	/* C style interface */




#endif 	/* __IAccessibleRelation_INTERFACE_DEFINED__ */


/* interface __MIDL_itf_IAccessible2_0000_0001 */
/* [local] */ 


enum IA2Actions
    {	IA2_ACTION_OPEN	= -1,
	IA2_ACTION_COMPLETE	= -2,
	IA2_ACTION_CLOSE	= -3
    } ;


extern RPC_IF_HANDLE __MIDL_itf_IAccessible2_0000_0001_v0_0_c_ifspec;
extern RPC_IF_HANDLE __MIDL_itf_IAccessible2_0000_0001_v0_0_s_ifspec;

#ifndef __IAccessibleAction_INTERFACE_DEFINED__
#define __IAccessibleAction_INTERFACE_DEFINED__

/* interface IAccessibleAction */
/* [uuid][object] */ 


EXTERN_C const IID IID_IAccessibleAction;

#if defined(__cplusplus) && !defined(CINTERFACE)
    
    MIDL_INTERFACE("B70D9F59-3B5A-4dba-AB9E-22012F607DF5")
    IAccessibleAction : public IUnknown
    {
    public:
        virtual HRESULT STDMETHODCALLTYPE nActions( 
            /* [retval][out] */ long *nActions) = 0;
        
        virtual HRESULT STDMETHODCALLTYPE doAction( 
            /* [in] */ long actionIndex) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_description( 
            /* [in] */ long actionIndex,
            /* [retval][out] */ BSTR *description) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_keyBinding( 
            /* [in] */ long actionIndex,
            /* [in] */ long nMaxBindings,
            /* [length_is][length_is][size_is][size_is][out] */ BSTR **keyBindings,
            /* [retval][out] */ long *nBindings) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_name( 
            /* [in] */ long actionIndex,
            /* [retval][out] */ BSTR *name) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_localizedName( 
            /* [in] */ long actionIndex,
            /* [retval][out] */ BSTR *localizedName) = 0;
        
    };
    
#else 	/* C style interface */

    typedef struct IAccessibleActionVtbl
    {
        BEGIN_INTERFACE
        
        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
            IAccessibleAction * This,
            /* [in] */ REFIID riid,
            /* [iid_is][out] */ 
            __RPC__deref_out  void **ppvObject);
        
        ULONG ( STDMETHODCALLTYPE *AddRef )( 
            IAccessibleAction * This);
        
        ULONG ( STDMETHODCALLTYPE *Release )( 
            IAccessibleAction * This);
        
        HRESULT ( STDMETHODCALLTYPE *nActions )( 
            IAccessibleAction * This,
            /* [retval][out] */ long *nActions);
        
        HRESULT ( STDMETHODCALLTYPE *doAction )( 
            IAccessibleAction * This,
            /* [in] */ long actionIndex);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_description )( 
            IAccessibleAction * This,
            /* [in] */ long actionIndex,
            /* [retval][out] */ BSTR *description);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_keyBinding )( 
            IAccessibleAction * This,
            /* [in] */ long actionIndex,
            /* [in] */ long nMaxBindings,
            /* [length_is][length_is][size_is][size_is][out] */ BSTR **keyBindings,
            /* [retval][out] */ long *nBindings);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_name )( 
            IAccessibleAction * This,
            /* [in] */ long actionIndex,
            /* [retval][out] */ BSTR *name);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_localizedName )( 
            IAccessibleAction * This,
            /* [in] */ long actionIndex,
            /* [retval][out] */ BSTR *localizedName);
        
        END_INTERFACE
    } IAccessibleActionVtbl;

    interface IAccessibleAction
    {
        CONST_VTBL struct IAccessibleActionVtbl *lpVtbl;
    };

    

#ifdef COBJMACROS


#define IAccessibleAction_QueryInterface(This,riid,ppvObject)	\
    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 

#define IAccessibleAction_AddRef(This)	\
    ( (This)->lpVtbl -> AddRef(This) ) 

#define IAccessibleAction_Release(This)	\
    ( (This)->lpVtbl -> Release(This) ) 


#define IAccessibleAction_nActions(This,nActions)	\
    ( (This)->lpVtbl -> nActions(This,nActions) ) 

#define IAccessibleAction_doAction(This,actionIndex)	\
    ( (This)->lpVtbl -> doAction(This,actionIndex) ) 

#define IAccessibleAction_get_description(This,actionIndex,description)	\
    ( (This)->lpVtbl -> get_description(This,actionIndex,description) ) 

#define IAccessibleAction_get_keyBinding(This,actionIndex,nMaxBindings,keyBindings,nBindings)	\
    ( (This)->lpVtbl -> get_keyBinding(This,actionIndex,nMaxBindings,keyBindings,nBindings) ) 

#define IAccessibleAction_get_name(This,actionIndex,name)	\
    ( (This)->lpVtbl -> get_name(This,actionIndex,name) ) 

#define IAccessibleAction_get_localizedName(This,actionIndex,localizedName)	\
    ( (This)->lpVtbl -> get_localizedName(This,actionIndex,localizedName) ) 

#endif /* COBJMACROS */


#endif 	/* C style interface */




#endif 	/* __IAccessibleAction_INTERFACE_DEFINED__ */


/* interface __MIDL_itf_IAccessible2_0000_0002 */
/* [local] */ 


enum IA2Role
    {	IA2_ROLE_UNKNOWN	= 0,
	IA2_ROLE_CANVAS	= 0x401,
	IA2_ROLE_CAPTION	= ( IA2_ROLE_CANVAS + 1 ) ,
	IA2_ROLE_CHECK_MENU_ITEM	= ( IA2_ROLE_CAPTION + 1 ) ,
	IA2_ROLE_COLOR_CHOOSER	= ( IA2_ROLE_CHECK_MENU_ITEM + 1 ) ,
	IA2_ROLE_DATE_EDITOR	= ( IA2_ROLE_COLOR_CHOOSER + 1 ) ,
	IA2_ROLE_DESKTOP_ICON	= ( IA2_ROLE_DATE_EDITOR + 1 ) ,
	IA2_ROLE_DESKTOP_PANE	= ( IA2_ROLE_DESKTOP_ICON + 1 ) ,
	IA2_ROLE_DIRECTORY_PANE	= ( IA2_ROLE_DESKTOP_PANE + 1 ) ,
	IA2_ROLE_EDITBAR	= ( IA2_ROLE_DIRECTORY_PANE + 1 ) ,
	IA2_ROLE_EMBEDDED_OBJECT	= ( IA2_ROLE_EDITBAR + 1 ) ,
	IA2_ROLE_ENDNOTE	= ( IA2_ROLE_EMBEDDED_OBJECT + 1 ) ,
	IA2_ROLE_FILE_CHOOSER	= ( IA2_ROLE_ENDNOTE + 1 ) ,
	IA2_ROLE_FONT_CHOOSER	= ( IA2_ROLE_FILE_CHOOSER + 1 ) ,
	IA2_ROLE_FOOTER	= ( IA2_ROLE_FONT_CHOOSER + 1 ) ,
	IA2_ROLE_FOOTNOTE	= ( IA2_ROLE_FOOTER + 1 ) ,
	IA2_ROLE_FORM	= ( IA2_ROLE_FOOTNOTE + 1 ) ,
	IA2_ROLE_FRAME	= ( IA2_ROLE_FORM + 1 ) ,
	IA2_ROLE_GLASS_PANE	= ( IA2_ROLE_FRAME + 1 ) ,
	IA2_ROLE_HEADER	= ( IA2_ROLE_GLASS_PANE + 1 ) ,
	IA2_ROLE_HEADING	= ( IA2_ROLE_HEADER + 1 ) ,
	IA2_ROLE_ICON	= ( IA2_ROLE_HEADING + 1 ) ,
	IA2_ROLE_IMAGE_MAP	= ( IA2_ROLE_ICON + 1 ) ,
	IA2_ROLE_INPUT_METHOD_WINDOW	= ( IA2_ROLE_IMAGE_MAP + 1 ) ,
	IA2_ROLE_INTERNAL_FRAME	= ( IA2_ROLE_INPUT_METHOD_WINDOW + 1 ) ,
	IA2_ROLE_LABEL	= ( IA2_ROLE_INTERNAL_FRAME + 1 ) ,
	IA2_ROLE_LAYERED_PANE	= ( IA2_ROLE_LABEL + 1 ) ,
	IA2_ROLE_NOTE	= ( IA2_ROLE_LAYERED_PANE + 1 ) ,
	IA2_ROLE_OPTION_PANE	= ( IA2_ROLE_NOTE + 1 ) ,
	IA2_ROLE_PAGE	= ( IA2_ROLE_OPTION_PANE + 1 ) ,
	IA2_ROLE_PARAGRAPH	= ( IA2_ROLE_PAGE + 1 ) ,
	IA2_ROLE_RADIO_MENU_ITEM	= ( IA2_ROLE_PARAGRAPH + 1 ) ,
	IA2_ROLE_REDUNDANT_OBJECT	= ( IA2_ROLE_RADIO_MENU_ITEM + 1 ) ,
	IA2_ROLE_ROOT_PANE	= ( IA2_ROLE_REDUNDANT_OBJECT + 1 ) ,
	IA2_ROLE_RULER	= ( IA2_ROLE_ROOT_PANE + 1 ) ,
	IA2_ROLE_SCROLL_PANE	= ( IA2_ROLE_RULER + 1 ) ,
	IA2_ROLE_SECTION	= ( IA2_ROLE_SCROLL_PANE + 1 ) ,
	IA2_ROLE_SHAPE	= ( IA2_ROLE_SECTION + 1 ) ,
	IA2_ROLE_SPLIT_PANE	= ( IA2_ROLE_SHAPE + 1 ) ,
	IA2_ROLE_TEAR_OFF_MENU	= ( IA2_ROLE_SPLIT_PANE + 1 ) ,
	IA2_ROLE_TERMINAL	= ( IA2_ROLE_TEAR_OFF_MENU + 1 ) ,
	IA2_ROLE_TEXT_FRAME	= ( IA2_ROLE_TERMINAL + 1 ) ,
	IA2_ROLE_TOGGLE_BUTTON	= ( IA2_ROLE_TEXT_FRAME + 1 ) ,
	IA2_ROLE_VIEW_PORT	= ( IA2_ROLE_TOGGLE_BUTTON + 1 ) ,
	IA2_ROLE_COMPLEMENTARY_CONTENT	= ( IA2_ROLE_VIEW_PORT + 1 ) 
    } ;
typedef long AccessibleStates;


enum IA2States
    {	IA2_STATE_ACTIVE	= 0x1,
	IA2_STATE_ARMED	= 0x2,
	IA2_STATE_DEFUNCT	= 0x4,
	IA2_STATE_EDITABLE	= 0x8,
	IA2_STATE_HORIZONTAL	= 0x10,
	IA2_STATE_ICONIFIED	= 0x20,
	IA2_STATE_INVALID_ENTRY	= 0x40,
	IA2_STATE_MANAGES_DESCENDANTS	= 0x80,
	IA2_STATE_MODAL	= 0x100,
	IA2_STATE_MULTI_LINE	= 0x200,
	IA2_STATE_OPAQUE	= 0x400,
	IA2_STATE_REQUIRED	= 0x800,
	IA2_STATE_SELECTABLE_TEXT	= 0x1000,
	IA2_STATE_SINGLE_LINE	= 0x2000,
	IA2_STATE_STALE	= 0x4000,
	IA2_STATE_SUPPORTS_AUTOCOMPLETION	= 0x8000,
	IA2_STATE_TRANSIENT	= 0x10000,
	IA2_STATE_VERTICAL	= 0x20000,
	IA2_STATE_CHECKABLE	= 0x40000,
	IA2_STATE_PINNED	= 0x80000
    } ;
typedef struct IA2Locale
    {
    BSTR language;
    BSTR country;
    BSTR variant;
    } 	IA2Locale;



extern RPC_IF_HANDLE __MIDL_itf_IAccessible2_0000_0002_v0_0_c_ifspec;
extern RPC_IF_HANDLE __MIDL_itf_IAccessible2_0000_0002_v0_0_s_ifspec;

#ifndef __IAccessible2_INTERFACE_DEFINED__
#define __IAccessible2_INTERFACE_DEFINED__

/* interface IAccessible2 */
/* [uuid][object] */ 


EXTERN_C const IID IID_IAccessible2;

#if defined(__cplusplus) && !defined(CINTERFACE)
    
    MIDL_INTERFACE("E89F726E-C4F4-4c19-BB19-B647D7FA8478")
    IAccessible2 : public IAccessible
    {
    public:
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_nRelations( 
            /* [retval][out] */ long *nRelations) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_relation( 
            /* [in] */ long relationIndex,
            /* [retval][out] */ IAccessibleRelation **relation) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_relations( 
            /* [in] */ long maxRelations,
            /* [length_is][size_is][out] */ IAccessibleRelation **relations,
            /* [retval][out] */ long *nRelations) = 0;
        
        virtual HRESULT STDMETHODCALLTYPE role( 
            /* [retval][out] */ long *role) = 0;
        
        virtual HRESULT STDMETHODCALLTYPE scrollTo( 
            /* [in] */ enum IA2ScrollType scrollType) = 0;
        
        virtual HRESULT STDMETHODCALLTYPE scrollToPoint( 
            /* [in] */ enum IA2CoordinateType coordinateType,
            /* [in] */ long x,
            /* [in] */ long y) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_groupPosition( 
            /* [out] */ long *groupLevel,
            /* [out] */ long *similarItemsInGroup,
            /* [retval][out] */ long *positionInGroup) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_states( 
            /* [retval][out] */ AccessibleStates *states) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_extendedRole( 
            /* [retval][out] */ BSTR *extendedRole) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_localizedExtendedRole( 
            /* [retval][out] */ BSTR *localizedExtendedRole) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_nExtendedStates( 
            /* [retval][out] */ long *nExtendedStates) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_extendedStates( 
            /* [in] */ long maxExtendedStates,
            /* [length_is][length_is][size_is][size_is][out] */ BSTR **extendedStates,
            /* [retval][out] */ long *nExtendedStates) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_localizedExtendedStates( 
            /* [in] */ long maxLocalizedExtendedStates,
            /* [length_is][length_is][size_is][size_is][out] */ BSTR **localizedExtendedStates,
            /* [retval][out] */ long *nLocalizedExtendedStates) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_uniqueID( 
            /* [retval][out] */ long *uniqueID) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_windowHandle( 
            /* [retval][out] */ HWND *windowHandle) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_indexInParent( 
            /* [retval][out] */ long *indexInParent) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_locale( 
            /* [retval][out] */ IA2Locale *locale) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_attributes( 
            /* [retval][out] */ BSTR *attributes) = 0;
        
    };
    
#else 	/* C style interface */

    typedef struct IAccessible2Vtbl
    {
        BEGIN_INTERFACE
        
        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
            IAccessible2 * This,
            /* [in] */ REFIID riid,
            /* [iid_is][out] */ 
            __RPC__deref_out  void **ppvObject);
        
        ULONG ( STDMETHODCALLTYPE *AddRef )( 
            IAccessible2 * This);
        
        ULONG ( STDMETHODCALLTYPE *Release )( 
            IAccessible2 * This);
        
        HRESULT ( STDMETHODCALLTYPE *GetTypeInfoCount )( 
            IAccessible2 * This,
            /* [out] */ UINT *pctinfo);
        
        HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )( 
            IAccessible2 * This,
            /* [in] */ UINT iTInfo,
            /* [in] */ LCID lcid,
            /* [out] */ ITypeInfo **ppTInfo);
        
        HRESULT ( STDMETHODCALLTYPE *GetIDsOfNames )( 
            IAccessible2 * This,
            /* [in] */ REFIID riid,
            /* [size_is][in] */ LPOLESTR *rgszNames,
            /* [range][in] */ UINT cNames,
            /* [in] */ LCID lcid,
            /* [size_is][out] */ DISPID *rgDispId);
        
        /* [local] */ HRESULT ( STDMETHODCALLTYPE *Invoke )( 
            IAccessible2 * This,
            /* [in] */ DISPID dispIdMember,
            /* [in] */ REFIID riid,
            /* [in] */ LCID lcid,
            /* [in] */ WORD wFlags,
            /* [out][in] */ DISPPARAMS *pDispParams,
            /* [out] */ VARIANT *pVarResult,
            /* [out] */ EXCEPINFO *pExcepInfo,
            /* [out] */ UINT *puArgErr);
        
        /* [id][propget][hidden] */ HRESULT ( STDMETHODCALLTYPE *get_accParent )( 
            IAccessible2 * This,
            /* [retval][out] */ IDispatch **ppdispParent);
        
        /* [id][propget][hidden] */ HRESULT ( STDMETHODCALLTYPE *get_accChildCount )( 
            IAccessible2 * This,
            /* [retval][out] */ long *pcountChildren);
        
        /* [id][propget][hidden] */ HRESULT ( STDMETHODCALLTYPE *get_accChild )( 
            IAccessible2 * This,
            /* [in] */ VARIANT varChild,
            /* [retval][out] */ IDispatch **ppdispChild);
        
        /* [id][propget][hidden] */ HRESULT ( STDMETHODCALLTYPE *get_accName )( 
            IAccessible2 * This,
            /* [optional][in] */ VARIANT varChild,
            /* [retval][out] */ BSTR *pszName);
        
        /* [id][propget][hidden] */ HRESULT ( STDMETHODCALLTYPE *get_accValue )( 
            IAccessible2 * This,
            /* [optional][in] */ VARIANT varChild,
            /* [retval][out] */ BSTR *pszValue);
        
        /* [id][propget][hidden] */ HRESULT ( STDMETHODCALLTYPE *get_accDescription )( 
            IAccessible2 * This,
            /* [optional][in] */ VARIANT varChild,
            /* [retval][out] */ BSTR *pszDescription);
        
        /* [id][propget][hidden] */ HRESULT ( STDMETHODCALLTYPE *get_accRole )( 
            IAccessible2 * This,
            /* [optional][in] */ VARIANT varChild,
            /* [retval][out] */ VARIANT *pvarRole);
        
        /* [id][propget][hidden] */ HRESULT ( STDMETHODCALLTYPE *get_accState )( 
            IAccessible2 * This,
            /* [optional][in] */ VARIANT varChild,
            /* [retval][out] */ VARIANT *pvarState);
        
        /* [id][propget][hidden] */ HRESULT ( STDMETHODCALLTYPE *get_accHelp )( 
            IAccessible2 * This,
            /* [optional][in] */ VARIANT varChild,
            /* [retval][out] */ BSTR *pszHelp);
        
        /* [id][propget][hidden] */ HRESULT ( STDMETHODCALLTYPE *get_accHelpTopic )( 
            IAccessible2 * This,
            /* [out] */ BSTR *pszHelpFile,
            /* [optional][in] */ VARIANT varChild,
            /* [retval][out] */ long *pidTopic);
        
        /* [id][propget][hidden] */ HRESULT ( STDMETHODCALLTYPE *get_accKeyboardShortcut )( 
            IAccessible2 * This,
            /* [optional][in] */ VARIANT varChild,
            /* [retval][out] */ BSTR *pszKeyboardShortcut);
        
        /* [id][propget][hidden] */ HRESULT ( STDMETHODCALLTYPE *get_accFocus )( 
            IAccessible2 * This,
            /* [retval][out] */ VARIANT *pvarChild);
        
        /* [id][propget][hidden] */ HRESULT ( STDMETHODCALLTYPE *get_accSelection )( 
            IAccessible2 * This,
            /* [retval][out] */ VARIANT *pvarChildren);
        
        /* [id][propget][hidden] */ HRESULT ( STDMETHODCALLTYPE *get_accDefaultAction )( 
            IAccessible2 * This,
            /* [optional][in] */ VARIANT varChild,
            /* [retval][out] */ BSTR *pszDefaultAction);
        
        /* [id][hidden] */ HRESULT ( STDMETHODCALLTYPE *accSelect )( 
            IAccessible2 * This,
            /* [in] */ long flagsSelect,
            /* [optional][in] */ VARIANT varChild);
        
        /* [id][hidden] */ HRESULT ( STDMETHODCALLTYPE *accLocation )( 
            IAccessible2 * This,
            /* [out] */ long *pxLeft,
            /* [out] */ long *pyTop,
            /* [out] */ long *pcxWidth,
            /* [out] */ long *pcyHeight,
            /* [optional][in] */ VARIANT varChild);
        
        /* [id][hidden] */ HRESULT ( STDMETHODCALLTYPE *accNavigate )( 
            IAccessible2 * This,
            /* [in] */ long navDir,
            /* [optional][in] */ VARIANT varStart,
            /* [retval][out] */ VARIANT *pvarEndUpAt);
        
        /* [id][hidden] */ HRESULT ( STDMETHODCALLTYPE *accHitTest )( 
            IAccessible2 * This,
            /* [in] */ long xLeft,
            /* [in] */ long yTop,
            /* [retval][out] */ VARIANT *pvarChild);
        
        /* [id][hidden] */ HRESULT ( STDMETHODCALLTYPE *accDoDefaultAction )( 
            IAccessible2 * This,
            /* [optional][in] */ VARIANT varChild);
        
        /* [id][propput][hidden] */ HRESULT ( STDMETHODCALLTYPE *put_accName )( 
            IAccessible2 * This,
            /* [optional][in] */ VARIANT varChild,
            /* [in] */ BSTR szName);
        
        /* [id][propput][hidden] */ HRESULT ( STDMETHODCALLTYPE *put_accValue )( 
            IAccessible2 * This,
            /* [optional][in] */ VARIANT varChild,
            /* [in] */ BSTR szValue);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_nRelations )( 
            IAccessible2 * This,
            /* [retval][out] */ long *nRelations);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_relation )( 
            IAccessible2 * This,
            /* [in] */ long relationIndex,
            /* [retval][out] */ IAccessibleRelation **relation);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_relations )( 
            IAccessible2 * This,
            /* [in] */ long maxRelations,
            /* [length_is][size_is][out] */ IAccessibleRelation **relations,
            /* [retval][out] */ long *nRelations);
        
        HRESULT ( STDMETHODCALLTYPE *role )( 
            IAccessible2 * This,
            /* [retval][out] */ long *role);
        
        HRESULT ( STDMETHODCALLTYPE *scrollTo )( 
            IAccessible2 * This,
            /* [in] */ enum IA2ScrollType scrollType);
        
        HRESULT ( STDMETHODCALLTYPE *scrollToPoint )( 
            IAccessible2 * This,
            /* [in] */ enum IA2CoordinateType coordinateType,
            /* [in] */ long x,
            /* [in] */ long y);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_groupPosition )( 
            IAccessible2 * This,
            /* [out] */ long *groupLevel,
            /* [out] */ long *similarItemsInGroup,
            /* [retval][out] */ long *positionInGroup);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_states )( 
            IAccessible2 * This,
            /* [retval][out] */ AccessibleStates *states);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_extendedRole )( 
            IAccessible2 * This,
            /* [retval][out] */ BSTR *extendedRole);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_localizedExtendedRole )( 
            IAccessible2 * This,
            /* [retval][out] */ BSTR *localizedExtendedRole);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_nExtendedStates )( 
            IAccessible2 * This,
            /* [retval][out] */ long *nExtendedStates);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_extendedStates )( 
            IAccessible2 * This,
            /* [in] */ long maxExtendedStates,
            /* [length_is][length_is][size_is][size_is][out] */ BSTR **extendedStates,
            /* [retval][out] */ long *nExtendedStates);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_localizedExtendedStates )( 
            IAccessible2 * This,
            /* [in] */ long maxLocalizedExtendedStates,
            /* [length_is][length_is][size_is][size_is][out] */ BSTR **localizedExtendedStates,
            /* [retval][out] */ long *nLocalizedExtendedStates);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_uniqueID )( 
            IAccessible2 * This,
            /* [retval][out] */ long *uniqueID);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_windowHandle )( 
            IAccessible2 * This,
            /* [retval][out] */ HWND *windowHandle);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_indexInParent )( 
            IAccessible2 * This,
            /* [retval][out] */ long *indexInParent);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_locale )( 
            IAccessible2 * This,
            /* [retval][out] */ IA2Locale *locale);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_attributes )( 
            IAccessible2 * This,
            /* [retval][out] */ BSTR *attributes);
        
        END_INTERFACE
    } IAccessible2Vtbl;

    interface IAccessible2
    {
        CONST_VTBL struct IAccessible2Vtbl *lpVtbl;
    };

    

#ifdef COBJMACROS


#define IAccessible2_QueryInterface(This,riid,ppvObject)	\
    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 

#define IAccessible2_AddRef(This)	\
    ( (This)->lpVtbl -> AddRef(This) ) 

#define IAccessible2_Release(This)	\
    ( (This)->lpVtbl -> Release(This) ) 


#define IAccessible2_GetTypeInfoCount(This,pctinfo)	\
    ( (This)->lpVtbl -> GetTypeInfoCount(This,pctinfo) ) 

#define IAccessible2_GetTypeInfo(This,iTInfo,lcid,ppTInfo)	\
    ( (This)->lpVtbl -> GetTypeInfo(This,iTInfo,lcid,ppTInfo) ) 

#define IAccessible2_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId)	\
    ( (This)->lpVtbl -> GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) ) 

#define IAccessible2_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr)	\
    ( (This)->lpVtbl -> Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) ) 


#define IAccessible2_get_accParent(This,ppdispParent)	\
    ( (This)->lpVtbl -> get_accParent(This,ppdispParent) ) 

#define IAccessible2_get_accChildCount(This,pcountChildren)	\
    ( (This)->lpVtbl -> get_accChildCount(This,pcountChildren) ) 

#define IAccessible2_get_accChild(This,varChild,ppdispChild)	\
    ( (This)->lpVtbl -> get_accChild(This,varChild,ppdispChild) ) 

#define IAccessible2_get_accName(This,varChild,pszName)	\
    ( (This)->lpVtbl -> get_accName(This,varChild,pszName) ) 

#define IAccessible2_get_accValue(This,varChild,pszValue)	\
    ( (This)->lpVtbl -> get_accValue(This,varChild,pszValue) ) 

#define IAccessible2_get_accDescription(This,varChild,pszDescription)	\
    ( (This)->lpVtbl -> get_accDescription(This,varChild,pszDescription) ) 

#define IAccessible2_get_accRole(This,varChild,pvarRole)	\
    ( (This)->lpVtbl -> get_accRole(This,varChild,pvarRole) ) 

#define IAccessible2_get_accState(This,varChild,pvarState)	\
    ( (This)->lpVtbl -> get_accState(This,varChild,pvarState) ) 

#define IAccessible2_get_accHelp(This,varChild,pszHelp)	\
    ( (This)->lpVtbl -> get_accHelp(This,varChild,pszHelp) ) 

#define IAccessible2_get_accHelpTopic(This,pszHelpFile,varChild,pidTopic)	\
    ( (This)->lpVtbl -> get_accHelpTopic(This,pszHelpFile,varChild,pidTopic) ) 

#define IAccessible2_get_accKeyboardShortcut(This,varChild,pszKeyboardShortcut)	\
    ( (This)->lpVtbl -> get_accKeyboardShortcut(This,varChild,pszKeyboardShortcut) ) 

#define IAccessible2_get_accFocus(This,pvarChild)	\
    ( (This)->lpVtbl -> get_accFocus(This,pvarChild) ) 

#define IAccessible2_get_accSelection(This,pvarChildren)	\
    ( (This)->lpVtbl -> get_accSelection(This,pvarChildren) ) 

#define IAccessible2_get_accDefaultAction(This,varChild,pszDefaultAction)	\
    ( (This)->lpVtbl -> get_accDefaultAction(This,varChild,pszDefaultAction) ) 

#define IAccessible2_accSelect(This,flagsSelect,varChild)	\
    ( (This)->lpVtbl -> accSelect(This,flagsSelect,varChild) ) 

#define IAccessible2_accLocation(This,pxLeft,pyTop,pcxWidth,pcyHeight,varChild)	\
    ( (This)->lpVtbl -> accLocation(This,pxLeft,pyTop,pcxWidth,pcyHeight,varChild) ) 

#define IAccessible2_accNavigate(This,navDir,varStart,pvarEndUpAt)	\
    ( (This)->lpVtbl -> accNavigate(This,navDir,varStart,pvarEndUpAt) ) 

#define IAccessible2_accHitTest(This,xLeft,yTop,pvarChild)	\
    ( (This)->lpVtbl -> accHitTest(This,xLeft,yTop,pvarChild) ) 

#define IAccessible2_accDoDefaultAction(This,varChild)	\
    ( (This)->lpVtbl -> accDoDefaultAction(This,varChild) ) 

#define IAccessible2_put_accName(This,varChild,szName)	\
    ( (This)->lpVtbl -> put_accName(This,varChild,szName) ) 

#define IAccessible2_put_accValue(This,varChild,szValue)	\
    ( (This)->lpVtbl -> put_accValue(This,varChild,szValue) ) 


#define IAccessible2_get_nRelations(This,nRelations)	\
    ( (This)->lpVtbl -> get_nRelations(This,nRelations) ) 

#define IAccessible2_get_relation(This,relationIndex,relation)	\
    ( (This)->lpVtbl -> get_relation(This,relationIndex,relation) ) 

#define IAccessible2_get_relations(This,maxRelations,relations,nRelations)	\
    ( (This)->lpVtbl -> get_relations(This,maxRelations,relations,nRelations) ) 

#define IAccessible2_role(This,role)	\
    ( (This)->lpVtbl -> role(This,role) ) 

#define IAccessible2_scrollTo(This,scrollType)	\
    ( (This)->lpVtbl -> scrollTo(This,scrollType) ) 

#define IAccessible2_scrollToPoint(This,coordinateType,x,y)	\
    ( (This)->lpVtbl -> scrollToPoint(This,coordinateType,x,y) ) 

#define IAccessible2_get_groupPosition(This,groupLevel,similarItemsInGroup,positionInGroup)	\
    ( (This)->lpVtbl -> get_groupPosition(This,groupLevel,similarItemsInGroup,positionInGroup) ) 

#define IAccessible2_get_states(This,states)	\
    ( (This)->lpVtbl -> get_states(This,states) ) 

#define IAccessible2_get_extendedRole(This,extendedRole)	\
    ( (This)->lpVtbl -> get_extendedRole(This,extendedRole) ) 

#define IAccessible2_get_localizedExtendedRole(This,localizedExtendedRole)	\
    ( (This)->lpVtbl -> get_localizedExtendedRole(This,localizedExtendedRole) ) 

#define IAccessible2_get_nExtendedStates(This,nExtendedStates)	\
    ( (This)->lpVtbl -> get_nExtendedStates(This,nExtendedStates) ) 

#define IAccessible2_get_extendedStates(This,maxExtendedStates,extendedStates,nExtendedStates)	\
    ( (This)->lpVtbl -> get_extendedStates(This,maxExtendedStates,extendedStates,nExtendedStates) ) 

#define IAccessible2_get_localizedExtendedStates(This,maxLocalizedExtendedStates,localizedExtendedStates,nLocalizedExtendedStates)	\
    ( (This)->lpVtbl -> get_localizedExtendedStates(This,maxLocalizedExtendedStates,localizedExtendedStates,nLocalizedExtendedStates) ) 

#define IAccessible2_get_uniqueID(This,uniqueID)	\
    ( (This)->lpVtbl -> get_uniqueID(This,uniqueID) ) 

#define IAccessible2_get_windowHandle(This,windowHandle)	\
    ( (This)->lpVtbl -> get_windowHandle(This,windowHandle) ) 

#define IAccessible2_get_indexInParent(This,indexInParent)	\
    ( (This)->lpVtbl -> get_indexInParent(This,indexInParent) ) 

#define IAccessible2_get_locale(This,locale)	\
    ( (This)->lpVtbl -> get_locale(This,locale) ) 

#define IAccessible2_get_attributes(This,attributes)	\
    ( (This)->lpVtbl -> get_attributes(This,attributes) ) 

#endif /* COBJMACROS */


#endif 	/* C style interface */




#endif 	/* __IAccessible2_INTERFACE_DEFINED__ */


#ifndef __IAccessible2_2_INTERFACE_DEFINED__
#define __IAccessible2_2_INTERFACE_DEFINED__

/* interface IAccessible2_2 */
/* [uuid][object] */ 


EXTERN_C const IID IID_IAccessible2_2;

#if defined(__cplusplus) && !defined(CINTERFACE)
    
    MIDL_INTERFACE("6C9430E9-299D-4E6F-BD01-A82A1E88D3FF")
    IAccessible2_2 : public IAccessible2
    {
    public:
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_attribute( 
            /* [in] */ BSTR name,
            /* [retval][out] */ VARIANT *attribute) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_accessibleWithCaret( 
            /* [out] */ IUnknown **accessible,
            /* [retval][out] */ long *caretOffset) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_relationTargetsOfType( 
            /* [in] */ BSTR type,
            /* [in] */ long maxTargets,
            /* [size_is][size_is][out] */ IUnknown ***targets,
            /* [retval][out] */ long *nTargets) = 0;
        
    };
    
#else 	/* C style interface */

    typedef struct IAccessible2_2Vtbl
    {
        BEGIN_INTERFACE
        
        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
            IAccessible2_2 * This,
            /* [in] */ REFIID riid,
            /* [iid_is][out] */ 
            __RPC__deref_out  void **ppvObject);
        
        ULONG ( STDMETHODCALLTYPE *AddRef )( 
            IAccessible2_2 * This);
        
        ULONG ( STDMETHODCALLTYPE *Release )( 
            IAccessible2_2 * This);
        
        HRESULT ( STDMETHODCALLTYPE *GetTypeInfoCount )( 
            IAccessible2_2 * This,
            /* [out] */ UINT *pctinfo);
        
        HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )( 
            IAccessible2_2 * This,
            /* [in] */ UINT iTInfo,
            /* [in] */ LCID lcid,
            /* [out] */ ITypeInfo **ppTInfo);
        
        HRESULT ( STDMETHODCALLTYPE *GetIDsOfNames )( 
            IAccessible2_2 * This,
            /* [in] */ REFIID riid,
            /* [size_is][in] */ LPOLESTR *rgszNames,
            /* [range][in] */ UINT cNames,
            /* [in] */ LCID lcid,
            /* [size_is][out] */ DISPID *rgDispId);
        
        /* [local] */ HRESULT ( STDMETHODCALLTYPE *Invoke )( 
            IAccessible2_2 * This,
            /* [in] */ DISPID dispIdMember,
            /* [in] */ REFIID riid,
            /* [in] */ LCID lcid,
            /* [in] */ WORD wFlags,
            /* [out][in] */ DISPPARAMS *pDispParams,
            /* [out] */ VARIANT *pVarResult,
            /* [out] */ EXCEPINFO *pExcepInfo,
            /* [out] */ UINT *puArgErr);
        
        /* [id][propget][hidden] */ HRESULT ( STDMETHODCALLTYPE *get_accParent )( 
            IAccessible2_2 * This,
            /* [retval][out] */ IDispatch **ppdispParent);
        
        /* [id][propget][hidden] */ HRESULT ( STDMETHODCALLTYPE *get_accChildCount )( 
            IAccessible2_2 * This,
            /* [retval][out] */ long *pcountChildren);
        
        /* [id][propget][hidden] */ HRESULT ( STDMETHODCALLTYPE *get_accChild )( 
            IAccessible2_2 * This,
            /* [in] */ VARIANT varChild,
            /* [retval][out] */ IDispatch **ppdispChild);
        
        /* [id][propget][hidden] */ HRESULT ( STDMETHODCALLTYPE *get_accName )( 
            IAccessible2_2 * This,
            /* [optional][in] */ VARIANT varChild,
            /* [retval][out] */ BSTR *pszName);
        
        /* [id][propget][hidden] */ HRESULT ( STDMETHODCALLTYPE *get_accValue )( 
            IAccessible2_2 * This,
            /* [optional][in] */ VARIANT varChild,
            /* [retval][out] */ BSTR *pszValue);
        
        /* [id][propget][hidden] */ HRESULT ( STDMETHODCALLTYPE *get_accDescription )( 
            IAccessible2_2 * This,
            /* [optional][in] */ VARIANT varChild,
            /* [retval][out] */ BSTR *pszDescription);
        
        /* [id][propget][hidden] */ HRESULT ( STDMETHODCALLTYPE *get_accRole )( 
            IAccessible2_2 * This,
            /* [optional][in] */ VARIANT varChild,
            /* [retval][out] */ VARIANT *pvarRole);
        
        /* [id][propget][hidden] */ HRESULT ( STDMETHODCALLTYPE *get_accState )( 
            IAccessible2_2 * This,
            /* [optional][in] */ VARIANT varChild,
            /* [retval][out] */ VARIANT *pvarState);
        
        /* [id][propget][hidden] */ HRESULT ( STDMETHODCALLTYPE *get_accHelp )( 
            IAccessible2_2 * This,
            /* [optional][in] */ VARIANT varChild,
            /* [retval][out] */ BSTR *pszHelp);
        
        /* [id][propget][hidden] */ HRESULT ( STDMETHODCALLTYPE *get_accHelpTopic )( 
            IAccessible2_2 * This,
            /* [out] */ BSTR *pszHelpFile,
            /* [optional][in] */ VARIANT varChild,
            /* [retval][out] */ long *pidTopic);
        
        /* [id][propget][hidden] */ HRESULT ( STDMETHODCALLTYPE *get_accKeyboardShortcut )( 
            IAccessible2_2 * This,
            /* [optional][in] */ VARIANT varChild,
            /* [retval][out] */ BSTR *pszKeyboardShortcut);
        
        /* [id][propget][hidden] */ HRESULT ( STDMETHODCALLTYPE *get_accFocus )( 
            IAccessible2_2 * This,
            /* [retval][out] */ VARIANT *pvarChild);
        
        /* [id][propget][hidden] */ HRESULT ( STDMETHODCALLTYPE *get_accSelection )( 
            IAccessible2_2 * This,
            /* [retval][out] */ VARIANT *pvarChildren);
        
        /* [id][propget][hidden] */ HRESULT ( STDMETHODCALLTYPE *get_accDefaultAction )( 
            IAccessible2_2 * This,
            /* [optional][in] */ VARIANT varChild,
            /* [retval][out] */ BSTR *pszDefaultAction);
        
        /* [id][hidden] */ HRESULT ( STDMETHODCALLTYPE *accSelect )( 
            IAccessible2_2 * This,
            /* [in] */ long flagsSelect,
            /* [optional][in] */ VARIANT varChild);
        
        /* [id][hidden] */ HRESULT ( STDMETHODCALLTYPE *accLocation )( 
            IAccessible2_2 * This,
            /* [out] */ long *pxLeft,
            /* [out] */ long *pyTop,
            /* [out] */ long *pcxWidth,
            /* [out] */ long *pcyHeight,
            /* [optional][in] */ VARIANT varChild);
        
        /* [id][hidden] */ HRESULT ( STDMETHODCALLTYPE *accNavigate )( 
            IAccessible2_2 * This,
            /* [in] */ long navDir,
            /* [optional][in] */ VARIANT varStart,
            /* [retval][out] */ VARIANT *pvarEndUpAt);
        
        /* [id][hidden] */ HRESULT ( STDMETHODCALLTYPE *accHitTest )( 
            IAccessible2_2 * This,
            /* [in] */ long xLeft,
            /* [in] */ long yTop,
            /* [retval][out] */ VARIANT *pvarChild);
        
        /* [id][hidden] */ HRESULT ( STDMETHODCALLTYPE *accDoDefaultAction )( 
            IAccessible2_2 * This,
            /* [optional][in] */ VARIANT varChild);
        
        /* [id][propput][hidden] */ HRESULT ( STDMETHODCALLTYPE *put_accName )( 
            IAccessible2_2 * This,
            /* [optional][in] */ VARIANT varChild,
            /* [in] */ BSTR szName);
        
        /* [id][propput][hidden] */ HRESULT ( STDMETHODCALLTYPE *put_accValue )( 
            IAccessible2_2 * This,
            /* [optional][in] */ VARIANT varChild,
            /* [in] */ BSTR szValue);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_nRelations )( 
            IAccessible2_2 * This,
            /* [retval][out] */ long *nRelations);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_relation )( 
            IAccessible2_2 * This,
            /* [in] */ long relationIndex,
            /* [retval][out] */ IAccessibleRelation **relation);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_relations )( 
            IAccessible2_2 * This,
            /* [in] */ long maxRelations,
            /* [length_is][size_is][out] */ IAccessibleRelation **relations,
            /* [retval][out] */ long *nRelations);
        
        HRESULT ( STDMETHODCALLTYPE *role )( 
            IAccessible2_2 * This,
            /* [retval][out] */ long *role);
        
        HRESULT ( STDMETHODCALLTYPE *scrollTo )( 
            IAccessible2_2 * This,
            /* [in] */ enum IA2ScrollType scrollType);
        
        HRESULT ( STDMETHODCALLTYPE *scrollToPoint )( 
            IAccessible2_2 * This,
            /* [in] */ enum IA2CoordinateType coordinateType,
            /* [in] */ long x,
            /* [in] */ long y);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_groupPosition )( 
            IAccessible2_2 * This,
            /* [out] */ long *groupLevel,
            /* [out] */ long *similarItemsInGroup,
            /* [retval][out] */ long *positionInGroup);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_states )( 
            IAccessible2_2 * This,
            /* [retval][out] */ AccessibleStates *states);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_extendedRole )( 
            IAccessible2_2 * This,
            /* [retval][out] */ BSTR *extendedRole);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_localizedExtendedRole )( 
            IAccessible2_2 * This,
            /* [retval][out] */ BSTR *localizedExtendedRole);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_nExtendedStates )( 
            IAccessible2_2 * This,
            /* [retval][out] */ long *nExtendedStates);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_extendedStates )( 
            IAccessible2_2 * This,
            /* [in] */ long maxExtendedStates,
            /* [length_is][length_is][size_is][size_is][out] */ BSTR **extendedStates,
            /* [retval][out] */ long *nExtendedStates);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_localizedExtendedStates )( 
            IAccessible2_2 * This,
            /* [in] */ long maxLocalizedExtendedStates,
            /* [length_is][length_is][size_is][size_is][out] */ BSTR **localizedExtendedStates,
            /* [retval][out] */ long *nLocalizedExtendedStates);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_uniqueID )( 
            IAccessible2_2 * This,
            /* [retval][out] */ long *uniqueID);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_windowHandle )( 
            IAccessible2_2 * This,
            /* [retval][out] */ HWND *windowHandle);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_indexInParent )( 
            IAccessible2_2 * This,
            /* [retval][out] */ long *indexInParent);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_locale )( 
            IAccessible2_2 * This,
            /* [retval][out] */ IA2Locale *locale);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_attributes )( 
            IAccessible2_2 * This,
            /* [retval][out] */ BSTR *attributes);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_attribute )( 
            IAccessible2_2 * This,
            /* [in] */ BSTR name,
            /* [retval][out] */ VARIANT *attribute);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_accessibleWithCaret )( 
            IAccessible2_2 * This,
            /* [out] */ IUnknown **accessible,
            /* [retval][out] */ long *caretOffset);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_relationTargetsOfType )( 
            IAccessible2_2 * This,
            /* [in] */ BSTR type,
            /* [in] */ long maxTargets,
            /* [size_is][size_is][out] */ IUnknown ***targets,
            /* [retval][out] */ long *nTargets);
        
        END_INTERFACE
    } IAccessible2_2Vtbl;

    interface IAccessible2_2
    {
        CONST_VTBL struct IAccessible2_2Vtbl *lpVtbl;
    };

    

#ifdef COBJMACROS


#define IAccessible2_2_QueryInterface(This,riid,ppvObject)	\
    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 

#define IAccessible2_2_AddRef(This)	\
    ( (This)->lpVtbl -> AddRef(This) ) 

#define IAccessible2_2_Release(This)	\
    ( (This)->lpVtbl -> Release(This) ) 


#define IAccessible2_2_GetTypeInfoCount(This,pctinfo)	\
    ( (This)->lpVtbl -> GetTypeInfoCount(This,pctinfo) ) 

#define IAccessible2_2_GetTypeInfo(This,iTInfo,lcid,ppTInfo)	\
    ( (This)->lpVtbl -> GetTypeInfo(This,iTInfo,lcid,ppTInfo) ) 

#define IAccessible2_2_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId)	\
    ( (This)->lpVtbl -> GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) ) 

#define IAccessible2_2_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr)	\
    ( (This)->lpVtbl -> Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) ) 


#define IAccessible2_2_get_accParent(This,ppdispParent)	\
    ( (This)->lpVtbl -> get_accParent(This,ppdispParent) ) 

#define IAccessible2_2_get_accChildCount(This,pcountChildren)	\
    ( (This)->lpVtbl -> get_accChildCount(This,pcountChildren) ) 

#define IAccessible2_2_get_accChild(This,varChild,ppdispChild)	\
    ( (This)->lpVtbl -> get_accChild(This,varChild,ppdispChild) ) 

#define IAccessible2_2_get_accName(This,varChild,pszName)	\
    ( (This)->lpVtbl -> get_accName(This,varChild,pszName) ) 

#define IAccessible2_2_get_accValue(This,varChild,pszValue)	\
    ( (This)->lpVtbl -> get_accValue(This,varChild,pszValue) ) 

#define IAccessible2_2_get_accDescription(This,varChild,pszDescription)	\
    ( (This)->lpVtbl -> get_accDescription(This,varChild,pszDescription) ) 

#define IAccessible2_2_get_accRole(This,varChild,pvarRole)	\
    ( (This)->lpVtbl -> get_accRole(This,varChild,pvarRole) ) 

#define IAccessible2_2_get_accState(This,varChild,pvarState)	\
    ( (This)->lpVtbl -> get_accState(This,varChild,pvarState) ) 

#define IAccessible2_2_get_accHelp(This,varChild,pszHelp)	\
    ( (This)->lpVtbl -> get_accHelp(This,varChild,pszHelp) ) 

#define IAccessible2_2_get_accHelpTopic(This,pszHelpFile,varChild,pidTopic)	\
    ( (This)->lpVtbl -> get_accHelpTopic(This,pszHelpFile,varChild,pidTopic) ) 

#define IAccessible2_2_get_accKeyboardShortcut(This,varChild,pszKeyboardShortcut)	\
    ( (This)->lpVtbl -> get_accKeyboardShortcut(This,varChild,pszKeyboardShortcut) ) 

#define IAccessible2_2_get_accFocus(This,pvarChild)	\
    ( (This)->lpVtbl -> get_accFocus(This,pvarChild) ) 

#define IAccessible2_2_get_accSelection(This,pvarChildren)	\
    ( (This)->lpVtbl -> get_accSelection(This,pvarChildren) ) 

#define IAccessible2_2_get_accDefaultAction(This,varChild,pszDefaultAction)	\
    ( (This)->lpVtbl -> get_accDefaultAction(This,varChild,pszDefaultAction) ) 

#define IAccessible2_2_accSelect(This,flagsSelect,varChild)	\
    ( (This)->lpVtbl -> accSelect(This,flagsSelect,varChild) ) 

#define IAccessible2_2_accLocation(This,pxLeft,pyTop,pcxWidth,pcyHeight,varChild)	\
    ( (This)->lpVtbl -> accLocation(This,pxLeft,pyTop,pcxWidth,pcyHeight,varChild) ) 

#define IAccessible2_2_accNavigate(This,navDir,varStart,pvarEndUpAt)	\
    ( (This)->lpVtbl -> accNavigate(This,navDir,varStart,pvarEndUpAt) ) 

#define IAccessible2_2_accHitTest(This,xLeft,yTop,pvarChild)	\
    ( (This)->lpVtbl -> accHitTest(This,xLeft,yTop,pvarChild) ) 

#define IAccessible2_2_accDoDefaultAction(This,varChild)	\
    ( (This)->lpVtbl -> accDoDefaultAction(This,varChild) ) 

#define IAccessible2_2_put_accName(This,varChild,szName)	\
    ( (This)->lpVtbl -> put_accName(This,varChild,szName) ) 

#define IAccessible2_2_put_accValue(This,varChild,szValue)	\
    ( (This)->lpVtbl -> put_accValue(This,varChild,szValue) ) 


#define IAccessible2_2_get_nRelations(This,nRelations)	\
    ( (This)->lpVtbl -> get_nRelations(This,nRelations) ) 

#define IAccessible2_2_get_relation(This,relationIndex,relation)	\
    ( (This)->lpVtbl -> get_relation(This,relationIndex,relation) ) 

#define IAccessible2_2_get_relations(This,maxRelations,relations,nRelations)	\
    ( (This)->lpVtbl -> get_relations(This,maxRelations,relations,nRelations) ) 

#define IAccessible2_2_role(This,role)	\
    ( (This)->lpVtbl -> role(This,role) ) 

#define IAccessible2_2_scrollTo(This,scrollType)	\
    ( (This)->lpVtbl -> scrollTo(This,scrollType) ) 

#define IAccessible2_2_scrollToPoint(This,coordinateType,x,y)	\
    ( (This)->lpVtbl -> scrollToPoint(This,coordinateType,x,y) ) 

#define IAccessible2_2_get_groupPosition(This,groupLevel,similarItemsInGroup,positionInGroup)	\
    ( (This)->lpVtbl -> get_groupPosition(This,groupLevel,similarItemsInGroup,positionInGroup) ) 

#define IAccessible2_2_get_states(This,states)	\
    ( (This)->lpVtbl -> get_states(This,states) ) 

#define IAccessible2_2_get_extendedRole(This,extendedRole)	\
    ( (This)->lpVtbl -> get_extendedRole(This,extendedRole) ) 

#define IAccessible2_2_get_localizedExtendedRole(This,localizedExtendedRole)	\
    ( (This)->lpVtbl -> get_localizedExtendedRole(This,localizedExtendedRole) ) 

#define IAccessible2_2_get_nExtendedStates(This,nExtendedStates)	\
    ( (This)->lpVtbl -> get_nExtendedStates(This,nExtendedStates) ) 

#define IAccessible2_2_get_extendedStates(This,maxExtendedStates,extendedStates,nExtendedStates)	\
    ( (This)->lpVtbl -> get_extendedStates(This,maxExtendedStates,extendedStates,nExtendedStates) ) 

#define IAccessible2_2_get_localizedExtendedStates(This,maxLocalizedExtendedStates,localizedExtendedStates,nLocalizedExtendedStates)	\
    ( (This)->lpVtbl -> get_localizedExtendedStates(This,maxLocalizedExtendedStates,localizedExtendedStates,nLocalizedExtendedStates) ) 

#define IAccessible2_2_get_uniqueID(This,uniqueID)	\
    ( (This)->lpVtbl -> get_uniqueID(This,uniqueID) ) 

#define IAccessible2_2_get_windowHandle(This,windowHandle)	\
    ( (This)->lpVtbl -> get_windowHandle(This,windowHandle) ) 

#define IAccessible2_2_get_indexInParent(This,indexInParent)	\
    ( (This)->lpVtbl -> get_indexInParent(This,indexInParent) ) 

#define IAccessible2_2_get_locale(This,locale)	\
    ( (This)->lpVtbl -> get_locale(This,locale) ) 

#define IAccessible2_2_get_attributes(This,attributes)	\
    ( (This)->lpVtbl -> get_attributes(This,attributes) ) 


#define IAccessible2_2_get_attribute(This,name,attribute)	\
    ( (This)->lpVtbl -> get_attribute(This,name,attribute) ) 

#define IAccessible2_2_get_accessibleWithCaret(This,accessible,caretOffset)	\
    ( (This)->lpVtbl -> get_accessibleWithCaret(This,accessible,caretOffset) ) 

#define IAccessible2_2_get_relationTargetsOfType(This,type,maxTargets,targets,nTargets)	\
    ( (This)->lpVtbl -> get_relationTargetsOfType(This,type,maxTargets,targets,nTargets) ) 

#endif /* COBJMACROS */


#endif 	/* C style interface */




#endif 	/* __IAccessible2_2_INTERFACE_DEFINED__ */


/* interface __MIDL_itf_IAccessible2_0000_0004 */
/* [local] */ 

typedef long IA2Color;



extern RPC_IF_HANDLE __MIDL_itf_IAccessible2_0000_0004_v0_0_c_ifspec;
extern RPC_IF_HANDLE __MIDL_itf_IAccessible2_0000_0004_v0_0_s_ifspec;

#ifndef __IAccessibleComponent_INTERFACE_DEFINED__
#define __IAccessibleComponent_INTERFACE_DEFINED__

/* interface IAccessibleComponent */
/* [uuid][object] */ 


EXTERN_C const IID IID_IAccessibleComponent;

#if defined(__cplusplus) && !defined(CINTERFACE)
    
    MIDL_INTERFACE("1546D4B0-4C98-4bda-89AE-9A64748BDDE4")
    IAccessibleComponent : public IUnknown
    {
    public:
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_locationInParent( 
            /* [out] */ long *x,
            /* [retval][out] */ long *y) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_foreground( 
            /* [retval][out] */ IA2Color *foreground) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_background( 
            /* [retval][out] */ IA2Color *background) = 0;
        
    };
    
#else 	/* C style interface */

    typedef struct IAccessibleComponentVtbl
    {
        BEGIN_INTERFACE
        
        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
            IAccessibleComponent * This,
            /* [in] */ REFIID riid,
            /* [iid_is][out] */ 
            __RPC__deref_out  void **ppvObject);
        
        ULONG ( STDMETHODCALLTYPE *AddRef )( 
            IAccessibleComponent * This);
        
        ULONG ( STDMETHODCALLTYPE *Release )( 
            IAccessibleComponent * This);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_locationInParent )( 
            IAccessibleComponent * This,
            /* [out] */ long *x,
            /* [retval][out] */ long *y);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_foreground )( 
            IAccessibleComponent * This,
            /* [retval][out] */ IA2Color *foreground);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_background )( 
            IAccessibleComponent * This,
            /* [retval][out] */ IA2Color *background);
        
        END_INTERFACE
    } IAccessibleComponentVtbl;

    interface IAccessibleComponent
    {
        CONST_VTBL struct IAccessibleComponentVtbl *lpVtbl;
    };

    

#ifdef COBJMACROS


#define IAccessibleComponent_QueryInterface(This,riid,ppvObject)	\
    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 

#define IAccessibleComponent_AddRef(This)	\
    ( (This)->lpVtbl -> AddRef(This) ) 

#define IAccessibleComponent_Release(This)	\
    ( (This)->lpVtbl -> Release(This) ) 


#define IAccessibleComponent_get_locationInParent(This,x,y)	\
    ( (This)->lpVtbl -> get_locationInParent(This,x,y) ) 

#define IAccessibleComponent_get_foreground(This,foreground)	\
    ( (This)->lpVtbl -> get_foreground(This,foreground) ) 

#define IAccessibleComponent_get_background(This,background)	\
    ( (This)->lpVtbl -> get_background(This,background) ) 

#endif /* COBJMACROS */


#endif 	/* C style interface */




#endif 	/* __IAccessibleComponent_INTERFACE_DEFINED__ */


#ifndef __IAccessibleValue_INTERFACE_DEFINED__
#define __IAccessibleValue_INTERFACE_DEFINED__

/* interface IAccessibleValue */
/* [uuid][object] */ 


EXTERN_C const IID IID_IAccessibleValue;

#if defined(__cplusplus) && !defined(CINTERFACE)
    
    MIDL_INTERFACE("35855B5B-C566-4fd0-A7B1-E65465600394")
    IAccessibleValue : public IUnknown
    {
    public:
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_currentValue( 
            /* [retval][out] */ VARIANT *currentValue) = 0;
        
        virtual HRESULT STDMETHODCALLTYPE setCurrentValue( 
            /* [in] */ VARIANT value) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_maximumValue( 
            /* [retval][out] */ VARIANT *maximumValue) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_minimumValue( 
            /* [retval][out] */ VARIANT *minimumValue) = 0;
        
    };
    
#else 	/* C style interface */

    typedef struct IAccessibleValueVtbl
    {
        BEGIN_INTERFACE
        
        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
            IAccessibleValue * This,
            /* [in] */ REFIID riid,
            /* [iid_is][out] */ 
            __RPC__deref_out  void **ppvObject);
        
        ULONG ( STDMETHODCALLTYPE *AddRef )( 
            IAccessibleValue * This);
        
        ULONG ( STDMETHODCALLTYPE *Release )( 
            IAccessibleValue * This);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_currentValue )( 
            IAccessibleValue * This,
            /* [retval][out] */ VARIANT *currentValue);
        
        HRESULT ( STDMETHODCALLTYPE *setCurrentValue )( 
            IAccessibleValue * This,
            /* [in] */ VARIANT value);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_maximumValue )( 
            IAccessibleValue * This,
            /* [retval][out] */ VARIANT *maximumValue);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_minimumValue )( 
            IAccessibleValue * This,
            /* [retval][out] */ VARIANT *minimumValue);
        
        END_INTERFACE
    } IAccessibleValueVtbl;

    interface IAccessibleValue
    {
        CONST_VTBL struct IAccessibleValueVtbl *lpVtbl;
    };

    

#ifdef COBJMACROS


#define IAccessibleValue_QueryInterface(This,riid,ppvObject)	\
    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 

#define IAccessibleValue_AddRef(This)	\
    ( (This)->lpVtbl -> AddRef(This) ) 

#define IAccessibleValue_Release(This)	\
    ( (This)->lpVtbl -> Release(This) ) 


#define IAccessibleValue_get_currentValue(This,currentValue)	\
    ( (This)->lpVtbl -> get_currentValue(This,currentValue) ) 

#define IAccessibleValue_setCurrentValue(This,value)	\
    ( (This)->lpVtbl -> setCurrentValue(This,value) ) 

#define IAccessibleValue_get_maximumValue(This,maximumValue)	\
    ( (This)->lpVtbl -> get_maximumValue(This,maximumValue) ) 

#define IAccessibleValue_get_minimumValue(This,minimumValue)	\
    ( (This)->lpVtbl -> get_minimumValue(This,minimumValue) ) 

#endif /* COBJMACROS */


#endif 	/* C style interface */




#endif 	/* __IAccessibleValue_INTERFACE_DEFINED__ */


/* interface __MIDL_itf_IAccessible2_0000_0006 */
/* [local] */ 

typedef struct IA2TextSegment
    {
    BSTR text;
    long start;
    long end;
    } 	IA2TextSegment;


enum IA2TextBoundaryType
    {	IA2_TEXT_BOUNDARY_CHAR	= 0,
	IA2_TEXT_BOUNDARY_WORD	= ( IA2_TEXT_BOUNDARY_CHAR + 1 ) ,
	IA2_TEXT_BOUNDARY_SENTENCE	= ( IA2_TEXT_BOUNDARY_WORD + 1 ) ,
	IA2_TEXT_BOUNDARY_PARAGRAPH	= ( IA2_TEXT_BOUNDARY_SENTENCE + 1 ) ,
	IA2_TEXT_BOUNDARY_LINE	= ( IA2_TEXT_BOUNDARY_PARAGRAPH + 1 ) ,
	IA2_TEXT_BOUNDARY_ALL	= ( IA2_TEXT_BOUNDARY_LINE + 1 ) 
    } ;


extern RPC_IF_HANDLE __MIDL_itf_IAccessible2_0000_0006_v0_0_c_ifspec;
extern RPC_IF_HANDLE __MIDL_itf_IAccessible2_0000_0006_v0_0_s_ifspec;

#ifndef __IAccessibleText_INTERFACE_DEFINED__
#define __IAccessibleText_INTERFACE_DEFINED__

/* interface IAccessibleText */
/* [uuid][object] */ 


EXTERN_C const IID IID_IAccessibleText;

#if defined(__cplusplus) && !defined(CINTERFACE)
    
    MIDL_INTERFACE("24FD2FFB-3AAD-4a08-8335-A3AD89C0FB4B")
    IAccessibleText : public IUnknown
    {
    public:
        virtual HRESULT STDMETHODCALLTYPE addSelection( 
            /* [in] */ long startOffset,
            /* [in] */ long endOffset) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_attributes( 
            /* [in] */ long offset,
            /* [out] */ long *startOffset,
            /* [out] */ long *endOffset,
            /* [retval][out] */ BSTR *textAttributes) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_caretOffset( 
            /* [retval][out] */ long *offset) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_characterExtents( 
            /* [in] */ long offset,
            /* [in] */ enum IA2CoordinateType coordType,
            /* [out] */ long *x,
            /* [out] */ long *y,
            /* [out] */ long *width,
            /* [retval][out] */ long *height) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_nSelections( 
            /* [retval][out] */ long *nSelections) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_offsetAtPoint( 
            /* [in] */ long x,
            /* [in] */ long y,
            /* [in] */ enum IA2CoordinateType coordType,
            /* [retval][out] */ long *offset) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_selection( 
            /* [in] */ long selectionIndex,
            /* [out] */ long *startOffset,
            /* [retval][out] */ long *endOffset) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_text( 
            /* [in] */ long startOffset,
            /* [in] */ long endOffset,
            /* [retval][out] */ BSTR *text) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_textBeforeOffset( 
            /* [in] */ long offset,
            /* [in] */ enum IA2TextBoundaryType boundaryType,
            /* [out] */ long *startOffset,
            /* [out] */ long *endOffset,
            /* [retval][out] */ BSTR *text) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_textAfterOffset( 
            /* [in] */ long offset,
            /* [in] */ enum IA2TextBoundaryType boundaryType,
            /* [out] */ long *startOffset,
            /* [out] */ long *endOffset,
            /* [retval][out] */ BSTR *text) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_textAtOffset( 
            /* [in] */ long offset,
            /* [in] */ enum IA2TextBoundaryType boundaryType,
            /* [out] */ long *startOffset,
            /* [out] */ long *endOffset,
            /* [retval][out] */ BSTR *text) = 0;
        
        virtual HRESULT STDMETHODCALLTYPE removeSelection( 
            /* [in] */ long selectionIndex) = 0;
        
        virtual HRESULT STDMETHODCALLTYPE setCaretOffset( 
            /* [in] */ long offset) = 0;
        
        virtual HRESULT STDMETHODCALLTYPE setSelection( 
            /* [in] */ long selectionIndex,
            /* [in] */ long startOffset,
            /* [in] */ long endOffset) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_nCharacters( 
            /* [retval][out] */ long *nCharacters) = 0;
        
        virtual HRESULT STDMETHODCALLTYPE scrollSubstringTo( 
            /* [in] */ long startIndex,
            /* [in] */ long endIndex,
            /* [in] */ enum IA2ScrollType scrollType) = 0;
        
        virtual HRESULT STDMETHODCALLTYPE scrollSubstringToPoint( 
            /* [in] */ long startIndex,
            /* [in] */ long endIndex,
            /* [in] */ enum IA2CoordinateType coordinateType,
            /* [in] */ long x,
            /* [in] */ long y) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_newText( 
            /* [retval][out] */ IA2TextSegment *newText) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_oldText( 
            /* [retval][out] */ IA2TextSegment *oldText) = 0;
        
    };
    
#else 	/* C style interface */

    typedef struct IAccessibleTextVtbl
    {
        BEGIN_INTERFACE
        
        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
            IAccessibleText * This,
            /* [in] */ REFIID riid,
            /* [iid_is][out] */ 
            __RPC__deref_out  void **ppvObject);
        
        ULONG ( STDMETHODCALLTYPE *AddRef )( 
            IAccessibleText * This);
        
        ULONG ( STDMETHODCALLTYPE *Release )( 
            IAccessibleText * This);
        
        HRESULT ( STDMETHODCALLTYPE *addSelection )( 
            IAccessibleText * This,
            /* [in] */ long startOffset,
            /* [in] */ long endOffset);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_attributes )( 
            IAccessibleText * This,
            /* [in] */ long offset,
            /* [out] */ long *startOffset,
            /* [out] */ long *endOffset,
            /* [retval][out] */ BSTR *textAttributes);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_caretOffset )( 
            IAccessibleText * This,
            /* [retval][out] */ long *offset);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_characterExtents )( 
            IAccessibleText * This,
            /* [in] */ long offset,
            /* [in] */ enum IA2CoordinateType coordType,
            /* [out] */ long *x,
            /* [out] */ long *y,
            /* [out] */ long *width,
            /* [retval][out] */ long *height);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_nSelections )( 
            IAccessibleText * This,
            /* [retval][out] */ long *nSelections);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_offsetAtPoint )( 
            IAccessibleText * This,
            /* [in] */ long x,
            /* [in] */ long y,
            /* [in] */ enum IA2CoordinateType coordType,
            /* [retval][out] */ long *offset);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_selection )( 
            IAccessibleText * This,
            /* [in] */ long selectionIndex,
            /* [out] */ long *startOffset,
            /* [retval][out] */ long *endOffset);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_text )( 
            IAccessibleText * This,
            /* [in] */ long startOffset,
            /* [in] */ long endOffset,
            /* [retval][out] */ BSTR *text);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_textBeforeOffset )( 
            IAccessibleText * This,
            /* [in] */ long offset,
            /* [in] */ enum IA2TextBoundaryType boundaryType,
            /* [out] */ long *startOffset,
            /* [out] */ long *endOffset,
            /* [retval][out] */ BSTR *text);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_textAfterOffset )( 
            IAccessibleText * This,
            /* [in] */ long offset,
            /* [in] */ enum IA2TextBoundaryType boundaryType,
            /* [out] */ long *startOffset,
            /* [out] */ long *endOffset,
            /* [retval][out] */ BSTR *text);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_textAtOffset )( 
            IAccessibleText * This,
            /* [in] */ long offset,
            /* [in] */ enum IA2TextBoundaryType boundaryType,
            /* [out] */ long *startOffset,
            /* [out] */ long *endOffset,
            /* [retval][out] */ BSTR *text);
        
        HRESULT ( STDMETHODCALLTYPE *removeSelection )( 
            IAccessibleText * This,
            /* [in] */ long selectionIndex);
        
        HRESULT ( STDMETHODCALLTYPE *setCaretOffset )( 
            IAccessibleText * This,
            /* [in] */ long offset);
        
        HRESULT ( STDMETHODCALLTYPE *setSelection )( 
            IAccessibleText * This,
            /* [in] */ long selectionIndex,
            /* [in] */ long startOffset,
            /* [in] */ long endOffset);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_nCharacters )( 
            IAccessibleText * This,
            /* [retval][out] */ long *nCharacters);
        
        HRESULT ( STDMETHODCALLTYPE *scrollSubstringTo )( 
            IAccessibleText * This,
            /* [in] */ long startIndex,
            /* [in] */ long endIndex,
            /* [in] */ enum IA2ScrollType scrollType);
        
        HRESULT ( STDMETHODCALLTYPE *scrollSubstringToPoint )( 
            IAccessibleText * This,
            /* [in] */ long startIndex,
            /* [in] */ long endIndex,
            /* [in] */ enum IA2CoordinateType coordinateType,
            /* [in] */ long x,
            /* [in] */ long y);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_newText )( 
            IAccessibleText * This,
            /* [retval][out] */ IA2TextSegment *newText);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_oldText )( 
            IAccessibleText * This,
            /* [retval][out] */ IA2TextSegment *oldText);
        
        END_INTERFACE
    } IAccessibleTextVtbl;

    interface IAccessibleText
    {
        CONST_VTBL struct IAccessibleTextVtbl *lpVtbl;
    };

    

#ifdef COBJMACROS


#define IAccessibleText_QueryInterface(This,riid,ppvObject)	\
    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 

#define IAccessibleText_AddRef(This)	\
    ( (This)->lpVtbl -> AddRef(This) ) 

#define IAccessibleText_Release(This)	\
    ( (This)->lpVtbl -> Release(This) ) 


#define IAccessibleText_addSelection(This,startOffset,endOffset)	\
    ( (This)->lpVtbl -> addSelection(This,startOffset,endOffset) ) 

#define IAccessibleText_get_attributes(This,offset,startOffset,endOffset,textAttributes)	\
    ( (This)->lpVtbl -> get_attributes(This,offset,startOffset,endOffset,textAttributes) ) 

#define IAccessibleText_get_caretOffset(This,offset)	\
    ( (This)->lpVtbl -> get_caretOffset(This,offset) ) 

#define IAccessibleText_get_characterExtents(This,offset,coordType,x,y,width,height)	\
    ( (This)->lpVtbl -> get_characterExtents(This,offset,coordType,x,y,width,height) ) 

#define IAccessibleText_get_nSelections(This,nSelections)	\
    ( (This)->lpVtbl -> get_nSelections(This,nSelections) ) 

#define IAccessibleText_get_offsetAtPoint(This,x,y,coordType,offset)	\
    ( (This)->lpVtbl -> get_offsetAtPoint(This,x,y,coordType,offset) ) 

#define IAccessibleText_get_selection(This,selectionIndex,startOffset,endOffset)	\
    ( (This)->lpVtbl -> get_selection(This,selectionIndex,startOffset,endOffset) ) 

#define IAccessibleText_get_text(This,startOffset,endOffset,text)	\
    ( (This)->lpVtbl -> get_text(This,startOffset,endOffset,text) ) 

#define IAccessibleText_get_textBeforeOffset(This,offset,boundaryType,startOffset,endOffset,text)	\
    ( (This)->lpVtbl -> get_textBeforeOffset(This,offset,boundaryType,startOffset,endOffset,text) ) 

#define IAccessibleText_get_textAfterOffset(This,offset,boundaryType,startOffset,endOffset,text)	\
    ( (This)->lpVtbl -> get_textAfterOffset(This,offset,boundaryType,startOffset,endOffset,text) ) 

#define IAccessibleText_get_textAtOffset(This,offset,boundaryType,startOffset,endOffset,text)	\
    ( (This)->lpVtbl -> get_textAtOffset(This,offset,boundaryType,startOffset,endOffset,text) ) 

#define IAccessibleText_removeSelection(This,selectionIndex)	\
    ( (This)->lpVtbl -> removeSelection(This,selectionIndex) ) 

#define IAccessibleText_setCaretOffset(This,offset)	\
    ( (This)->lpVtbl -> setCaretOffset(This,offset) ) 

#define IAccessibleText_setSelection(This,selectionIndex,startOffset,endOffset)	\
    ( (This)->lpVtbl -> setSelection(This,selectionIndex,startOffset,endOffset) ) 

#define IAccessibleText_get_nCharacters(This,nCharacters)	\
    ( (This)->lpVtbl -> get_nCharacters(This,nCharacters) ) 

#define IAccessibleText_scrollSubstringTo(This,startIndex,endIndex,scrollType)	\
    ( (This)->lpVtbl -> scrollSubstringTo(This,startIndex,endIndex,scrollType) ) 

#define IAccessibleText_scrollSubstringToPoint(This,startIndex,endIndex,coordinateType,x,y)	\
    ( (This)->lpVtbl -> scrollSubstringToPoint(This,startIndex,endIndex,coordinateType,x,y) ) 

#define IAccessibleText_get_newText(This,newText)	\
    ( (This)->lpVtbl -> get_newText(This,newText) ) 

#define IAccessibleText_get_oldText(This,oldText)	\
    ( (This)->lpVtbl -> get_oldText(This,oldText) ) 

#endif /* COBJMACROS */


#endif 	/* C style interface */




#endif 	/* __IAccessibleText_INTERFACE_DEFINED__ */


#ifndef __IAccessibleText2_INTERFACE_DEFINED__
#define __IAccessibleText2_INTERFACE_DEFINED__

/* interface IAccessibleText2 */
/* [uuid][object] */ 


EXTERN_C const IID IID_IAccessibleText2;

#if defined(__cplusplus) && !defined(CINTERFACE)
    
    MIDL_INTERFACE("9690A9CC-5C80-4DF5-852E-2D5AE4189A54")
    IAccessibleText2 : public IAccessibleText
    {
    public:
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_attributeRange( 
            /* [in] */ long offset,
            /* [in] */ BSTR filter,
            /* [out] */ long *startOffset,
            /* [out] */ long *endOffset,
            /* [retval][out] */ BSTR *attributeValues) = 0;
        
    };
    
#else 	/* C style interface */

    typedef struct IAccessibleText2Vtbl
    {
        BEGIN_INTERFACE
        
        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
            IAccessibleText2 * This,
            /* [in] */ REFIID riid,
            /* [iid_is][out] */ 
            __RPC__deref_out  void **ppvObject);
        
        ULONG ( STDMETHODCALLTYPE *AddRef )( 
            IAccessibleText2 * This);
        
        ULONG ( STDMETHODCALLTYPE *Release )( 
            IAccessibleText2 * This);
        
        HRESULT ( STDMETHODCALLTYPE *addSelection )( 
            IAccessibleText2 * This,
            /* [in] */ long startOffset,
            /* [in] */ long endOffset);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_attributes )( 
            IAccessibleText2 * This,
            /* [in] */ long offset,
            /* [out] */ long *startOffset,
            /* [out] */ long *endOffset,
            /* [retval][out] */ BSTR *textAttributes);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_caretOffset )( 
            IAccessibleText2 * This,
            /* [retval][out] */ long *offset);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_characterExtents )( 
            IAccessibleText2 * This,
            /* [in] */ long offset,
            /* [in] */ enum IA2CoordinateType coordType,
            /* [out] */ long *x,
            /* [out] */ long *y,
            /* [out] */ long *width,
            /* [retval][out] */ long *height);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_nSelections )( 
            IAccessibleText2 * This,
            /* [retval][out] */ long *nSelections);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_offsetAtPoint )( 
            IAccessibleText2 * This,
            /* [in] */ long x,
            /* [in] */ long y,
            /* [in] */ enum IA2CoordinateType coordType,
            /* [retval][out] */ long *offset);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_selection )( 
            IAccessibleText2 * This,
            /* [in] */ long selectionIndex,
            /* [out] */ long *startOffset,
            /* [retval][out] */ long *endOffset);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_text )( 
            IAccessibleText2 * This,
            /* [in] */ long startOffset,
            /* [in] */ long endOffset,
            /* [retval][out] */ BSTR *text);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_textBeforeOffset )( 
            IAccessibleText2 * This,
            /* [in] */ long offset,
            /* [in] */ enum IA2TextBoundaryType boundaryType,
            /* [out] */ long *startOffset,
            /* [out] */ long *endOffset,
            /* [retval][out] */ BSTR *text);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_textAfterOffset )( 
            IAccessibleText2 * This,
            /* [in] */ long offset,
            /* [in] */ enum IA2TextBoundaryType boundaryType,
            /* [out] */ long *startOffset,
            /* [out] */ long *endOffset,
            /* [retval][out] */ BSTR *text);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_textAtOffset )( 
            IAccessibleText2 * This,
            /* [in] */ long offset,
            /* [in] */ enum IA2TextBoundaryType boundaryType,
            /* [out] */ long *startOffset,
            /* [out] */ long *endOffset,
            /* [retval][out] */ BSTR *text);
        
        HRESULT ( STDMETHODCALLTYPE *removeSelection )( 
            IAccessibleText2 * This,
            /* [in] */ long selectionIndex);
        
        HRESULT ( STDMETHODCALLTYPE *setCaretOffset )( 
            IAccessibleText2 * This,
            /* [in] */ long offset);
        
        HRESULT ( STDMETHODCALLTYPE *setSelection )( 
            IAccessibleText2 * This,
            /* [in] */ long selectionIndex,
            /* [in] */ long startOffset,
            /* [in] */ long endOffset);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_nCharacters )( 
            IAccessibleText2 * This,
            /* [retval][out] */ long *nCharacters);
        
        HRESULT ( STDMETHODCALLTYPE *scrollSubstringTo )( 
            IAccessibleText2 * This,
            /* [in] */ long startIndex,
            /* [in] */ long endIndex,
            /* [in] */ enum IA2ScrollType scrollType);
        
        HRESULT ( STDMETHODCALLTYPE *scrollSubstringToPoint )( 
            IAccessibleText2 * This,
            /* [in] */ long startIndex,
            /* [in] */ long endIndex,
            /* [in] */ enum IA2CoordinateType coordinateType,
            /* [in] */ long x,
            /* [in] */ long y);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_newText )( 
            IAccessibleText2 * This,
            /* [retval][out] */ IA2TextSegment *newText);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_oldText )( 
            IAccessibleText2 * This,
            /* [retval][out] */ IA2TextSegment *oldText);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_attributeRange )( 
            IAccessibleText2 * This,
            /* [in] */ long offset,
            /* [in] */ BSTR filter,
            /* [out] */ long *startOffset,
            /* [out] */ long *endOffset,
            /* [retval][out] */ BSTR *attributeValues);
        
        END_INTERFACE
    } IAccessibleText2Vtbl;

    interface IAccessibleText2
    {
        CONST_VTBL struct IAccessibleText2Vtbl *lpVtbl;
    };

    

#ifdef COBJMACROS


#define IAccessibleText2_QueryInterface(This,riid,ppvObject)	\
    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 

#define IAccessibleText2_AddRef(This)	\
    ( (This)->lpVtbl -> AddRef(This) ) 

#define IAccessibleText2_Release(This)	\
    ( (This)->lpVtbl -> Release(This) ) 


#define IAccessibleText2_addSelection(This,startOffset,endOffset)	\
    ( (This)->lpVtbl -> addSelection(This,startOffset,endOffset) ) 

#define IAccessibleText2_get_attributes(This,offset,startOffset,endOffset,textAttributes)	\
    ( (This)->lpVtbl -> get_attributes(This,offset,startOffset,endOffset,textAttributes) ) 

#define IAccessibleText2_get_caretOffset(This,offset)	\
    ( (This)->lpVtbl -> get_caretOffset(This,offset) ) 

#define IAccessibleText2_get_characterExtents(This,offset,coordType,x,y,width,height)	\
    ( (This)->lpVtbl -> get_characterExtents(This,offset,coordType,x,y,width,height) ) 

#define IAccessibleText2_get_nSelections(This,nSelections)	\
    ( (This)->lpVtbl -> get_nSelections(This,nSelections) ) 

#define IAccessibleText2_get_offsetAtPoint(This,x,y,coordType,offset)	\
    ( (This)->lpVtbl -> get_offsetAtPoint(This,x,y,coordType,offset) ) 

#define IAccessibleText2_get_selection(This,selectionIndex,startOffset,endOffset)	\
    ( (This)->lpVtbl -> get_selection(This,selectionIndex,startOffset,endOffset) ) 

#define IAccessibleText2_get_text(This,startOffset,endOffset,text)	\
    ( (This)->lpVtbl -> get_text(This,startOffset,endOffset,text) ) 

#define IAccessibleText2_get_textBeforeOffset(This,offset,boundaryType,startOffset,endOffset,text)	\
    ( (This)->lpVtbl -> get_textBeforeOffset(This,offset,boundaryType,startOffset,endOffset,text) ) 

#define IAccessibleText2_get_textAfterOffset(This,offset,boundaryType,startOffset,endOffset,text)	\
    ( (This)->lpVtbl -> get_textAfterOffset(This,offset,boundaryType,startOffset,endOffset,text) ) 

#define IAccessibleText2_get_textAtOffset(This,offset,boundaryType,startOffset,endOffset,text)	\
    ( (This)->lpVtbl -> get_textAtOffset(This,offset,boundaryType,startOffset,endOffset,text) ) 

#define IAccessibleText2_removeSelection(This,selectionIndex)	\
    ( (This)->lpVtbl -> removeSelection(This,selectionIndex) ) 

#define IAccessibleText2_setCaretOffset(This,offset)	\
    ( (This)->lpVtbl -> setCaretOffset(This,offset) ) 

#define IAccessibleText2_setSelection(This,selectionIndex,startOffset,endOffset)	\
    ( (This)->lpVtbl -> setSelection(This,selectionIndex,startOffset,endOffset) ) 

#define IAccessibleText2_get_nCharacters(This,nCharacters)	\
    ( (This)->lpVtbl -> get_nCharacters(This,nCharacters) ) 

#define IAccessibleText2_scrollSubstringTo(This,startIndex,endIndex,scrollType)	\
    ( (This)->lpVtbl -> scrollSubstringTo(This,startIndex,endIndex,scrollType) ) 

#define IAccessibleText2_scrollSubstringToPoint(This,startIndex,endIndex,coordinateType,x,y)	\
    ( (This)->lpVtbl -> scrollSubstringToPoint(This,startIndex,endIndex,coordinateType,x,y) ) 

#define IAccessibleText2_get_newText(This,newText)	\
    ( (This)->lpVtbl -> get_newText(This,newText) ) 

#define IAccessibleText2_get_oldText(This,oldText)	\
    ( (This)->lpVtbl -> get_oldText(This,oldText) ) 


#define IAccessibleText2_get_attributeRange(This,offset,filter,startOffset,endOffset,attributeValues)	\
    ( (This)->lpVtbl -> get_attributeRange(This,offset,filter,startOffset,endOffset,attributeValues) ) 

#endif /* COBJMACROS */


#endif 	/* C style interface */




#endif 	/* __IAccessibleText2_INTERFACE_DEFINED__ */


#ifndef __IAccessibleEditableText_INTERFACE_DEFINED__
#define __IAccessibleEditableText_INTERFACE_DEFINED__

/* interface IAccessibleEditableText */
/* [uuid][object] */ 


EXTERN_C const IID IID_IAccessibleEditableText;

#if defined(__cplusplus) && !defined(CINTERFACE)
    
    MIDL_INTERFACE("A59AA09A-7011-4b65-939D-32B1FB5547E3")
    IAccessibleEditableText : public IUnknown
    {
    public:
        virtual HRESULT STDMETHODCALLTYPE copyText( 
            /* [in] */ long startOffset,
            /* [in] */ long endOffset) = 0;
        
        virtual HRESULT STDMETHODCALLTYPE deleteText( 
            /* [in] */ long startOffset,
            /* [in] */ long endOffset) = 0;
        
        virtual HRESULT STDMETHODCALLTYPE insertText( 
            /* [in] */ long offset,
            /* [in] */ BSTR *text) = 0;
        
        virtual HRESULT STDMETHODCALLTYPE cutText( 
            /* [in] */ long startOffset,
            /* [in] */ long endOffset) = 0;
        
        virtual HRESULT STDMETHODCALLTYPE pasteText( 
            /* [in] */ long offset) = 0;
        
        virtual HRESULT STDMETHODCALLTYPE replaceText( 
            /* [in] */ long startOffset,
            /* [in] */ long endOffset,
            /* [in] */ BSTR *text) = 0;
        
        virtual HRESULT STDMETHODCALLTYPE setAttributes( 
            /* [in] */ long startOffset,
            /* [in] */ long endOffset,
            /* [in] */ BSTR *attributes) = 0;
        
    };
    
#else 	/* C style interface */

    typedef struct IAccessibleEditableTextVtbl
    {
        BEGIN_INTERFACE
        
        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
            IAccessibleEditableText * This,
            /* [in] */ REFIID riid,
            /* [iid_is][out] */ 
            __RPC__deref_out  void **ppvObject);
        
        ULONG ( STDMETHODCALLTYPE *AddRef )( 
            IAccessibleEditableText * This);
        
        ULONG ( STDMETHODCALLTYPE *Release )( 
            IAccessibleEditableText * This);
        
        HRESULT ( STDMETHODCALLTYPE *copyText )( 
            IAccessibleEditableText * This,
            /* [in] */ long startOffset,
            /* [in] */ long endOffset);
        
        HRESULT ( STDMETHODCALLTYPE *deleteText )( 
            IAccessibleEditableText * This,
            /* [in] */ long startOffset,
            /* [in] */ long endOffset);
        
        HRESULT ( STDMETHODCALLTYPE *insertText )( 
            IAccessibleEditableText * This,
            /* [in] */ long offset,
            /* [in] */ BSTR *text);
        
        HRESULT ( STDMETHODCALLTYPE *cutText )( 
            IAccessibleEditableText * This,
            /* [in] */ long startOffset,
            /* [in] */ long endOffset);
        
        HRESULT ( STDMETHODCALLTYPE *pasteText )( 
            IAccessibleEditableText * This,
            /* [in] */ long offset);
        
        HRESULT ( STDMETHODCALLTYPE *replaceText )( 
            IAccessibleEditableText * This,
            /* [in] */ long startOffset,
            /* [in] */ long endOffset,
            /* [in] */ BSTR *text);
        
        HRESULT ( STDMETHODCALLTYPE *setAttributes )( 
            IAccessibleEditableText * This,
            /* [in] */ long startOffset,
            /* [in] */ long endOffset,
            /* [in] */ BSTR *attributes);
        
        END_INTERFACE
    } IAccessibleEditableTextVtbl;

    interface IAccessibleEditableText
    {
        CONST_VTBL struct IAccessibleEditableTextVtbl *lpVtbl;
    };

    

#ifdef COBJMACROS


#define IAccessibleEditableText_QueryInterface(This,riid,ppvObject)	\
    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 

#define IAccessibleEditableText_AddRef(This)	\
    ( (This)->lpVtbl -> AddRef(This) ) 

#define IAccessibleEditableText_Release(This)	\
    ( (This)->lpVtbl -> Release(This) ) 


#define IAccessibleEditableText_copyText(This,startOffset,endOffset)	\
    ( (This)->lpVtbl -> copyText(This,startOffset,endOffset) ) 

#define IAccessibleEditableText_deleteText(This,startOffset,endOffset)	\
    ( (This)->lpVtbl -> deleteText(This,startOffset,endOffset) ) 

#define IAccessibleEditableText_insertText(This,offset,text)	\
    ( (This)->lpVtbl -> insertText(This,offset,text) ) 

#define IAccessibleEditableText_cutText(This,startOffset,endOffset)	\
    ( (This)->lpVtbl -> cutText(This,startOffset,endOffset) ) 

#define IAccessibleEditableText_pasteText(This,offset)	\
    ( (This)->lpVtbl -> pasteText(This,offset) ) 

#define IAccessibleEditableText_replaceText(This,startOffset,endOffset,text)	\
    ( (This)->lpVtbl -> replaceText(This,startOffset,endOffset,text) ) 

#define IAccessibleEditableText_setAttributes(This,startOffset,endOffset,attributes)	\
    ( (This)->lpVtbl -> setAttributes(This,startOffset,endOffset,attributes) ) 

#endif /* COBJMACROS */


#endif 	/* C style interface */




#endif 	/* __IAccessibleEditableText_INTERFACE_DEFINED__ */


#ifndef __IAccessibleHyperlink_INTERFACE_DEFINED__
#define __IAccessibleHyperlink_INTERFACE_DEFINED__

/* interface IAccessibleHyperlink */
/* [uuid][object] */ 


EXTERN_C const IID IID_IAccessibleHyperlink;

#if defined(__cplusplus) && !defined(CINTERFACE)
    
    MIDL_INTERFACE("01C20F2B-3DD2-400f-949F-AD00BDAB1D41")
    IAccessibleHyperlink : public IAccessibleAction
    {
    public:
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_anchor( 
            /* [in] */ long index,
            /* [retval][out] */ VARIANT *anchor) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_anchorTarget( 
            /* [in] */ long index,
            /* [retval][out] */ VARIANT *anchorTarget) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_startIndex( 
            /* [retval][out] */ long *index) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_endIndex( 
            /* [retval][out] */ long *index) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_valid( 
            /* [retval][out] */ boolean *valid) = 0;
        
    };
    
#else 	/* C style interface */

    typedef struct IAccessibleHyperlinkVtbl
    {
        BEGIN_INTERFACE
        
        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
            IAccessibleHyperlink * This,
            /* [in] */ REFIID riid,
            /* [iid_is][out] */ 
            __RPC__deref_out  void **ppvObject);
        
        ULONG ( STDMETHODCALLTYPE *AddRef )( 
            IAccessibleHyperlink * This);
        
        ULONG ( STDMETHODCALLTYPE *Release )( 
            IAccessibleHyperlink * This);
        
        HRESULT ( STDMETHODCALLTYPE *nActions )( 
            IAccessibleHyperlink * This,
            /* [retval][out] */ long *nActions);
        
        HRESULT ( STDMETHODCALLTYPE *doAction )( 
            IAccessibleHyperlink * This,
            /* [in] */ long actionIndex);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_description )( 
            IAccessibleHyperlink * This,
            /* [in] */ long actionIndex,
            /* [retval][out] */ BSTR *description);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_keyBinding )( 
            IAccessibleHyperlink * This,
            /* [in] */ long actionIndex,
            /* [in] */ long nMaxBindings,
            /* [length_is][length_is][size_is][size_is][out] */ BSTR **keyBindings,
            /* [retval][out] */ long *nBindings);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_name )( 
            IAccessibleHyperlink * This,
            /* [in] */ long actionIndex,
            /* [retval][out] */ BSTR *name);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_localizedName )( 
            IAccessibleHyperlink * This,
            /* [in] */ long actionIndex,
            /* [retval][out] */ BSTR *localizedName);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_anchor )( 
            IAccessibleHyperlink * This,
            /* [in] */ long index,
            /* [retval][out] */ VARIANT *anchor);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_anchorTarget )( 
            IAccessibleHyperlink * This,
            /* [in] */ long index,
            /* [retval][out] */ VARIANT *anchorTarget);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_startIndex )( 
            IAccessibleHyperlink * This,
            /* [retval][out] */ long *index);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_endIndex )( 
            IAccessibleHyperlink * This,
            /* [retval][out] */ long *index);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_valid )( 
            IAccessibleHyperlink * This,
            /* [retval][out] */ boolean *valid);
        
        END_INTERFACE
    } IAccessibleHyperlinkVtbl;

    interface IAccessibleHyperlink
    {
        CONST_VTBL struct IAccessibleHyperlinkVtbl *lpVtbl;
    };

    

#ifdef COBJMACROS


#define IAccessibleHyperlink_QueryInterface(This,riid,ppvObject)	\
    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 

#define IAccessibleHyperlink_AddRef(This)	\
    ( (This)->lpVtbl -> AddRef(This) ) 

#define IAccessibleHyperlink_Release(This)	\
    ( (This)->lpVtbl -> Release(This) ) 


#define IAccessibleHyperlink_nActions(This,nActions)	\
    ( (This)->lpVtbl -> nActions(This,nActions) ) 

#define IAccessibleHyperlink_doAction(This,actionIndex)	\
    ( (This)->lpVtbl -> doAction(This,actionIndex) ) 

#define IAccessibleHyperlink_get_description(This,actionIndex,description)	\
    ( (This)->lpVtbl -> get_description(This,actionIndex,description) ) 

#define IAccessibleHyperlink_get_keyBinding(This,actionIndex,nMaxBindings,keyBindings,nBindings)	\
    ( (This)->lpVtbl -> get_keyBinding(This,actionIndex,nMaxBindings,keyBindings,nBindings) ) 

#define IAccessibleHyperlink_get_name(This,actionIndex,name)	\
    ( (This)->lpVtbl -> get_name(This,actionIndex,name) ) 

#define IAccessibleHyperlink_get_localizedName(This,actionIndex,localizedName)	\
    ( (This)->lpVtbl -> get_localizedName(This,actionIndex,localizedName) ) 


#define IAccessibleHyperlink_get_anchor(This,index,anchor)	\
    ( (This)->lpVtbl -> get_anchor(This,index,anchor) ) 

#define IAccessibleHyperlink_get_anchorTarget(This,index,anchorTarget)	\
    ( (This)->lpVtbl -> get_anchorTarget(This,index,anchorTarget) ) 

#define IAccessibleHyperlink_get_startIndex(This,index)	\
    ( (This)->lpVtbl -> get_startIndex(This,index) ) 

#define IAccessibleHyperlink_get_endIndex(This,index)	\
    ( (This)->lpVtbl -> get_endIndex(This,index) ) 

#define IAccessibleHyperlink_get_valid(This,valid)	\
    ( (This)->lpVtbl -> get_valid(This,valid) ) 

#endif /* COBJMACROS */


#endif 	/* C style interface */




#endif 	/* __IAccessibleHyperlink_INTERFACE_DEFINED__ */


#ifndef __IAccessibleHypertext_INTERFACE_DEFINED__
#define __IAccessibleHypertext_INTERFACE_DEFINED__

/* interface IAccessibleHypertext */
/* [uuid][object] */ 


EXTERN_C const IID IID_IAccessibleHypertext;

#if defined(__cplusplus) && !defined(CINTERFACE)
    
    MIDL_INTERFACE("6B4F8BBF-F1F2-418a-B35E-A195BC4103B9")
    IAccessibleHypertext : public IAccessibleText
    {
    public:
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_nHyperlinks( 
            /* [retval][out] */ long *hyperlinkCount) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_hyperlink( 
            /* [in] */ long index,
            /* [retval][out] */ IAccessibleHyperlink **hyperlink) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_hyperlinkIndex( 
            /* [in] */ long charIndex,
            /* [retval][out] */ long *hyperlinkIndex) = 0;
        
    };
    
#else 	/* C style interface */

    typedef struct IAccessibleHypertextVtbl
    {
        BEGIN_INTERFACE
        
        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
            IAccessibleHypertext * This,
            /* [in] */ REFIID riid,
            /* [iid_is][out] */ 
            __RPC__deref_out  void **ppvObject);
        
        ULONG ( STDMETHODCALLTYPE *AddRef )( 
            IAccessibleHypertext * This);
        
        ULONG ( STDMETHODCALLTYPE *Release )( 
            IAccessibleHypertext * This);
        
        HRESULT ( STDMETHODCALLTYPE *addSelection )( 
            IAccessibleHypertext * This,
            /* [in] */ long startOffset,
            /* [in] */ long endOffset);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_attributes )( 
            IAccessibleHypertext * This,
            /* [in] */ long offset,
            /* [out] */ long *startOffset,
            /* [out] */ long *endOffset,
            /* [retval][out] */ BSTR *textAttributes);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_caretOffset )( 
            IAccessibleHypertext * This,
            /* [retval][out] */ long *offset);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_characterExtents )( 
            IAccessibleHypertext * This,
            /* [in] */ long offset,
            /* [in] */ enum IA2CoordinateType coordType,
            /* [out] */ long *x,
            /* [out] */ long *y,
            /* [out] */ long *width,
            /* [retval][out] */ long *height);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_nSelections )( 
            IAccessibleHypertext * This,
            /* [retval][out] */ long *nSelections);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_offsetAtPoint )( 
            IAccessibleHypertext * This,
            /* [in] */ long x,
            /* [in] */ long y,
            /* [in] */ enum IA2CoordinateType coordType,
            /* [retval][out] */ long *offset);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_selection )( 
            IAccessibleHypertext * This,
            /* [in] */ long selectionIndex,
            /* [out] */ long *startOffset,
            /* [retval][out] */ long *endOffset);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_text )( 
            IAccessibleHypertext * This,
            /* [in] */ long startOffset,
            /* [in] */ long endOffset,
            /* [retval][out] */ BSTR *text);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_textBeforeOffset )( 
            IAccessibleHypertext * This,
            /* [in] */ long offset,
            /* [in] */ enum IA2TextBoundaryType boundaryType,
            /* [out] */ long *startOffset,
            /* [out] */ long *endOffset,
            /* [retval][out] */ BSTR *text);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_textAfterOffset )( 
            IAccessibleHypertext * This,
            /* [in] */ long offset,
            /* [in] */ enum IA2TextBoundaryType boundaryType,
            /* [out] */ long *startOffset,
            /* [out] */ long *endOffset,
            /* [retval][out] */ BSTR *text);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_textAtOffset )( 
            IAccessibleHypertext * This,
            /* [in] */ long offset,
            /* [in] */ enum IA2TextBoundaryType boundaryType,
            /* [out] */ long *startOffset,
            /* [out] */ long *endOffset,
            /* [retval][out] */ BSTR *text);
        
        HRESULT ( STDMETHODCALLTYPE *removeSelection )( 
            IAccessibleHypertext * This,
            /* [in] */ long selectionIndex);
        
        HRESULT ( STDMETHODCALLTYPE *setCaretOffset )( 
            IAccessibleHypertext * This,
            /* [in] */ long offset);
        
        HRESULT ( STDMETHODCALLTYPE *setSelection )( 
            IAccessibleHypertext * This,
            /* [in] */ long selectionIndex,
            /* [in] */ long startOffset,
            /* [in] */ long endOffset);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_nCharacters )( 
            IAccessibleHypertext * This,
            /* [retval][out] */ long *nCharacters);
        
        HRESULT ( STDMETHODCALLTYPE *scrollSubstringTo )( 
            IAccessibleHypertext * This,
            /* [in] */ long startIndex,
            /* [in] */ long endIndex,
            /* [in] */ enum IA2ScrollType scrollType);
        
        HRESULT ( STDMETHODCALLTYPE *scrollSubstringToPoint )( 
            IAccessibleHypertext * This,
            /* [in] */ long startIndex,
            /* [in] */ long endIndex,
            /* [in] */ enum IA2CoordinateType coordinateType,
            /* [in] */ long x,
            /* [in] */ long y);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_newText )( 
            IAccessibleHypertext * This,
            /* [retval][out] */ IA2TextSegment *newText);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_oldText )( 
            IAccessibleHypertext * This,
            /* [retval][out] */ IA2TextSegment *oldText);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_nHyperlinks )( 
            IAccessibleHypertext * This,
            /* [retval][out] */ long *hyperlinkCount);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_hyperlink )( 
            IAccessibleHypertext * This,
            /* [in] */ long index,
            /* [retval][out] */ IAccessibleHyperlink **hyperlink);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_hyperlinkIndex )( 
            IAccessibleHypertext * This,
            /* [in] */ long charIndex,
            /* [retval][out] */ long *hyperlinkIndex);
        
        END_INTERFACE
    } IAccessibleHypertextVtbl;

    interface IAccessibleHypertext
    {
        CONST_VTBL struct IAccessibleHypertextVtbl *lpVtbl;
    };

    

#ifdef COBJMACROS


#define IAccessibleHypertext_QueryInterface(This,riid,ppvObject)	\
    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 

#define IAccessibleHypertext_AddRef(This)	\
    ( (This)->lpVtbl -> AddRef(This) ) 

#define IAccessibleHypertext_Release(This)	\
    ( (This)->lpVtbl -> Release(This) ) 


#define IAccessibleHypertext_addSelection(This,startOffset,endOffset)	\
    ( (This)->lpVtbl -> addSelection(This,startOffset,endOffset) ) 

#define IAccessibleHypertext_get_attributes(This,offset,startOffset,endOffset,textAttributes)	\
    ( (This)->lpVtbl -> get_attributes(This,offset,startOffset,endOffset,textAttributes) ) 

#define IAccessibleHypertext_get_caretOffset(This,offset)	\
    ( (This)->lpVtbl -> get_caretOffset(This,offset) ) 

#define IAccessibleHypertext_get_characterExtents(This,offset,coordType,x,y,width,height)	\
    ( (This)->lpVtbl -> get_characterExtents(This,offset,coordType,x,y,width,height) ) 

#define IAccessibleHypertext_get_nSelections(This,nSelections)	\
    ( (This)->lpVtbl -> get_nSelections(This,nSelections) ) 

#define IAccessibleHypertext_get_offsetAtPoint(This,x,y,coordType,offset)	\
    ( (This)->lpVtbl -> get_offsetAtPoint(This,x,y,coordType,offset) ) 

#define IAccessibleHypertext_get_selection(This,selectionIndex,startOffset,endOffset)	\
    ( (This)->lpVtbl -> get_selection(This,selectionIndex,startOffset,endOffset) ) 

#define IAccessibleHypertext_get_text(This,startOffset,endOffset,text)	\
    ( (This)->lpVtbl -> get_text(This,startOffset,endOffset,text) ) 

#define IAccessibleHypertext_get_textBeforeOffset(This,offset,boundaryType,startOffset,endOffset,text)	\
    ( (This)->lpVtbl -> get_textBeforeOffset(This,offset,boundaryType,startOffset,endOffset,text) ) 

#define IAccessibleHypertext_get_textAfterOffset(This,offset,boundaryType,startOffset,endOffset,text)	\
    ( (This)->lpVtbl -> get_textAfterOffset(This,offset,boundaryType,startOffset,endOffset,text) ) 

#define IAccessibleHypertext_get_textAtOffset(This,offset,boundaryType,startOffset,endOffset,text)	\
    ( (This)->lpVtbl -> get_textAtOffset(This,offset,boundaryType,startOffset,endOffset,text) ) 

#define IAccessibleHypertext_removeSelection(This,selectionIndex)	\
    ( (This)->lpVtbl -> removeSelection(This,selectionIndex) ) 

#define IAccessibleHypertext_setCaretOffset(This,offset)	\
    ( (This)->lpVtbl -> setCaretOffset(This,offset) ) 

#define IAccessibleHypertext_setSelection(This,selectionIndex,startOffset,endOffset)	\
    ( (This)->lpVtbl -> setSelection(This,selectionIndex,startOffset,endOffset) ) 

#define IAccessibleHypertext_get_nCharacters(This,nCharacters)	\
    ( (This)->lpVtbl -> get_nCharacters(This,nCharacters) ) 

#define IAccessibleHypertext_scrollSubstringTo(This,startIndex,endIndex,scrollType)	\
    ( (This)->lpVtbl -> scrollSubstringTo(This,startIndex,endIndex,scrollType) ) 

#define IAccessibleHypertext_scrollSubstringToPoint(This,startIndex,endIndex,coordinateType,x,y)	\
    ( (This)->lpVtbl -> scrollSubstringToPoint(This,startIndex,endIndex,coordinateType,x,y) ) 

#define IAccessibleHypertext_get_newText(This,newText)	\
    ( (This)->lpVtbl -> get_newText(This,newText) ) 

#define IAccessibleHypertext_get_oldText(This,oldText)	\
    ( (This)->lpVtbl -> get_oldText(This,oldText) ) 


#define IAccessibleHypertext_get_nHyperlinks(This,hyperlinkCount)	\
    ( (This)->lpVtbl -> get_nHyperlinks(This,hyperlinkCount) ) 

#define IAccessibleHypertext_get_hyperlink(This,index,hyperlink)	\
    ( (This)->lpVtbl -> get_hyperlink(This,index,hyperlink) ) 

#define IAccessibleHypertext_get_hyperlinkIndex(This,charIndex,hyperlinkIndex)	\
    ( (This)->lpVtbl -> get_hyperlinkIndex(This,charIndex,hyperlinkIndex) ) 

#endif /* COBJMACROS */


#endif 	/* C style interface */




#endif 	/* __IAccessibleHypertext_INTERFACE_DEFINED__ */


#ifndef __IAccessibleHypertext2_INTERFACE_DEFINED__
#define __IAccessibleHypertext2_INTERFACE_DEFINED__

/* interface IAccessibleHypertext2 */
/* [uuid][object] */ 


EXTERN_C const IID IID_IAccessibleHypertext2;

#if defined(__cplusplus) && !defined(CINTERFACE)
    
    MIDL_INTERFACE("CF64D89F-8287-4B44-8501-A827453A6077")
    IAccessibleHypertext2 : public IAccessibleHypertext
    {
    public:
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_hyperlinks( 
            /* [size_is][size_is][out] */ IAccessibleHyperlink ***hyperlinks,
            /* [retval][out] */ long *nHyperlinks) = 0;
        
    };
    
#else 	/* C style interface */

    typedef struct IAccessibleHypertext2Vtbl
    {
        BEGIN_INTERFACE
        
        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
            IAccessibleHypertext2 * This,
            /* [in] */ REFIID riid,
            /* [iid_is][out] */ 
            __RPC__deref_out  void **ppvObject);
        
        ULONG ( STDMETHODCALLTYPE *AddRef )( 
            IAccessibleHypertext2 * This);
        
        ULONG ( STDMETHODCALLTYPE *Release )( 
            IAccessibleHypertext2 * This);
        
        HRESULT ( STDMETHODCALLTYPE *addSelection )( 
            IAccessibleHypertext2 * This,
            /* [in] */ long startOffset,
            /* [in] */ long endOffset);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_attributes )( 
            IAccessibleHypertext2 * This,
            /* [in] */ long offset,
            /* [out] */ long *startOffset,
            /* [out] */ long *endOffset,
            /* [retval][out] */ BSTR *textAttributes);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_caretOffset )( 
            IAccessibleHypertext2 * This,
            /* [retval][out] */ long *offset);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_characterExtents )( 
            IAccessibleHypertext2 * This,
            /* [in] */ long offset,
            /* [in] */ enum IA2CoordinateType coordType,
            /* [out] */ long *x,
            /* [out] */ long *y,
            /* [out] */ long *width,
            /* [retval][out] */ long *height);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_nSelections )( 
            IAccessibleHypertext2 * This,
            /* [retval][out] */ long *nSelections);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_offsetAtPoint )( 
            IAccessibleHypertext2 * This,
            /* [in] */ long x,
            /* [in] */ long y,
            /* [in] */ enum IA2CoordinateType coordType,
            /* [retval][out] */ long *offset);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_selection )( 
            IAccessibleHypertext2 * This,
            /* [in] */ long selectionIndex,
            /* [out] */ long *startOffset,
            /* [retval][out] */ long *endOffset);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_text )( 
            IAccessibleHypertext2 * This,
            /* [in] */ long startOffset,
            /* [in] */ long endOffset,
            /* [retval][out] */ BSTR *text);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_textBeforeOffset )( 
            IAccessibleHypertext2 * This,
            /* [in] */ long offset,
            /* [in] */ enum IA2TextBoundaryType boundaryType,
            /* [out] */ long *startOffset,
            /* [out] */ long *endOffset,
            /* [retval][out] */ BSTR *text);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_textAfterOffset )( 
            IAccessibleHypertext2 * This,
            /* [in] */ long offset,
            /* [in] */ enum IA2TextBoundaryType boundaryType,
            /* [out] */ long *startOffset,
            /* [out] */ long *endOffset,
            /* [retval][out] */ BSTR *text);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_textAtOffset )( 
            IAccessibleHypertext2 * This,
            /* [in] */ long offset,
            /* [in] */ enum IA2TextBoundaryType boundaryType,
            /* [out] */ long *startOffset,
            /* [out] */ long *endOffset,
            /* [retval][out] */ BSTR *text);
        
        HRESULT ( STDMETHODCALLTYPE *removeSelection )( 
            IAccessibleHypertext2 * This,
            /* [in] */ long selectionIndex);
        
        HRESULT ( STDMETHODCALLTYPE *setCaretOffset )( 
            IAccessibleHypertext2 * This,
            /* [in] */ long offset);
        
        HRESULT ( STDMETHODCALLTYPE *setSelection )( 
            IAccessibleHypertext2 * This,
            /* [in] */ long selectionIndex,
            /* [in] */ long startOffset,
            /* [in] */ long endOffset);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_nCharacters )( 
            IAccessibleHypertext2 * This,
            /* [retval][out] */ long *nCharacters);
        
        HRESULT ( STDMETHODCALLTYPE *scrollSubstringTo )( 
            IAccessibleHypertext2 * This,
            /* [in] */ long startIndex,
            /* [in] */ long endIndex,
            /* [in] */ enum IA2ScrollType scrollType);
        
        HRESULT ( STDMETHODCALLTYPE *scrollSubstringToPoint )( 
            IAccessibleHypertext2 * This,
            /* [in] */ long startIndex,
            /* [in] */ long endIndex,
            /* [in] */ enum IA2CoordinateType coordinateType,
            /* [in] */ long x,
            /* [in] */ long y);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_newText )( 
            IAccessibleHypertext2 * This,
            /* [retval][out] */ IA2TextSegment *newText);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_oldText )( 
            IAccessibleHypertext2 * This,
            /* [retval][out] */ IA2TextSegment *oldText);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_nHyperlinks )( 
            IAccessibleHypertext2 * This,
            /* [retval][out] */ long *hyperlinkCount);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_hyperlink )( 
            IAccessibleHypertext2 * This,
            /* [in] */ long index,
            /* [retval][out] */ IAccessibleHyperlink **hyperlink);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_hyperlinkIndex )( 
            IAccessibleHypertext2 * This,
            /* [in] */ long charIndex,
            /* [retval][out] */ long *hyperlinkIndex);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_hyperlinks )( 
            IAccessibleHypertext2 * This,
            /* [size_is][size_is][out] */ IAccessibleHyperlink ***hyperlinks,
            /* [retval][out] */ long *nHyperlinks);
        
        END_INTERFACE
    } IAccessibleHypertext2Vtbl;

    interface IAccessibleHypertext2
    {
        CONST_VTBL struct IAccessibleHypertext2Vtbl *lpVtbl;
    };

    

#ifdef COBJMACROS


#define IAccessibleHypertext2_QueryInterface(This,riid,ppvObject)	\
    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 

#define IAccessibleHypertext2_AddRef(This)	\
    ( (This)->lpVtbl -> AddRef(This) ) 

#define IAccessibleHypertext2_Release(This)	\
    ( (This)->lpVtbl -> Release(This) ) 


#define IAccessibleHypertext2_addSelection(This,startOffset,endOffset)	\
    ( (This)->lpVtbl -> addSelection(This,startOffset,endOffset) ) 

#define IAccessibleHypertext2_get_attributes(This,offset,startOffset,endOffset,textAttributes)	\
    ( (This)->lpVtbl -> get_attributes(This,offset,startOffset,endOffset,textAttributes) ) 

#define IAccessibleHypertext2_get_caretOffset(This,offset)	\
    ( (This)->lpVtbl -> get_caretOffset(This,offset) ) 

#define IAccessibleHypertext2_get_characterExtents(This,offset,coordType,x,y,width,height)	\
    ( (This)->lpVtbl -> get_characterExtents(This,offset,coordType,x,y,width,height) ) 

#define IAccessibleHypertext2_get_nSelections(This,nSelections)	\
    ( (This)->lpVtbl -> get_nSelections(This,nSelections) ) 

#define IAccessibleHypertext2_get_offsetAtPoint(This,x,y,coordType,offset)	\
    ( (This)->lpVtbl -> get_offsetAtPoint(This,x,y,coordType,offset) ) 

#define IAccessibleHypertext2_get_selection(This,selectionIndex,startOffset,endOffset)	\
    ( (This)->lpVtbl -> get_selection(This,selectionIndex,startOffset,endOffset) ) 

#define IAccessibleHypertext2_get_text(This,startOffset,endOffset,text)	\
    ( (This)->lpVtbl -> get_text(This,startOffset,endOffset,text) ) 

#define IAccessibleHypertext2_get_textBeforeOffset(This,offset,boundaryType,startOffset,endOffset,text)	\
    ( (This)->lpVtbl -> get_textBeforeOffset(This,offset,boundaryType,startOffset,endOffset,text) ) 

#define IAccessibleHypertext2_get_textAfterOffset(This,offset,boundaryType,startOffset,endOffset,text)	\
    ( (This)->lpVtbl -> get_textAfterOffset(This,offset,boundaryType,startOffset,endOffset,text) ) 

#define IAccessibleHypertext2_get_textAtOffset(This,offset,boundaryType,startOffset,endOffset,text)	\
    ( (This)->lpVtbl -> get_textAtOffset(This,offset,boundaryType,startOffset,endOffset,text) ) 

#define IAccessibleHypertext2_removeSelection(This,selectionIndex)	\
    ( (This)->lpVtbl -> removeSelection(This,selectionIndex) ) 

#define IAccessibleHypertext2_setCaretOffset(This,offset)	\
    ( (This)->lpVtbl -> setCaretOffset(This,offset) ) 

#define IAccessibleHypertext2_setSelection(This,selectionIndex,startOffset,endOffset)	\
    ( (This)->lpVtbl -> setSelection(This,selectionIndex,startOffset,endOffset) ) 

#define IAccessibleHypertext2_get_nCharacters(This,nCharacters)	\
    ( (This)->lpVtbl -> get_nCharacters(This,nCharacters) ) 

#define IAccessibleHypertext2_scrollSubstringTo(This,startIndex,endIndex,scrollType)	\
    ( (This)->lpVtbl -> scrollSubstringTo(This,startIndex,endIndex,scrollType) ) 

#define IAccessibleHypertext2_scrollSubstringToPoint(This,startIndex,endIndex,coordinateType,x,y)	\
    ( (This)->lpVtbl -> scrollSubstringToPoint(This,startIndex,endIndex,coordinateType,x,y) ) 

#define IAccessibleHypertext2_get_newText(This,newText)	\
    ( (This)->lpVtbl -> get_newText(This,newText) ) 

#define IAccessibleHypertext2_get_oldText(This,oldText)	\
    ( (This)->lpVtbl -> get_oldText(This,oldText) ) 


#define IAccessibleHypertext2_get_nHyperlinks(This,hyperlinkCount)	\
    ( (This)->lpVtbl -> get_nHyperlinks(This,hyperlinkCount) ) 

#define IAccessibleHypertext2_get_hyperlink(This,index,hyperlink)	\
    ( (This)->lpVtbl -> get_hyperlink(This,index,hyperlink) ) 

#define IAccessibleHypertext2_get_hyperlinkIndex(This,charIndex,hyperlinkIndex)	\
    ( (This)->lpVtbl -> get_hyperlinkIndex(This,charIndex,hyperlinkIndex) ) 


#define IAccessibleHypertext2_get_hyperlinks(This,hyperlinks,nHyperlinks)	\
    ( (This)->lpVtbl -> get_hyperlinks(This,hyperlinks,nHyperlinks) ) 

#endif /* COBJMACROS */


#endif 	/* C style interface */




#endif 	/* __IAccessibleHypertext2_INTERFACE_DEFINED__ */


#ifndef __IAccessibleTable_INTERFACE_DEFINED__
#define __IAccessibleTable_INTERFACE_DEFINED__

/* interface IAccessibleTable */
/* [uuid][object] */ 


EXTERN_C const IID IID_IAccessibleTable;

#if defined(__cplusplus) && !defined(CINTERFACE)
    
    MIDL_INTERFACE("35AD8070-C20C-4fb4-B094-F4F7275DD469")
    IAccessibleTable : public IUnknown
    {
    public:
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_accessibleAt( 
            /* [in] */ long row,
            /* [in] */ long column,
            /* [retval][out] */ IUnknown **accessible) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_caption( 
            /* [retval][out] */ IUnknown **accessible) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_childIndex( 
            /* [in] */ long rowIndex,
            /* [in] */ long columnIndex,
            /* [retval][out] */ long *cellIndex) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_columnDescription( 
            /* [in] */ long column,
            /* [retval][out] */ BSTR *description) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_columnExtentAt( 
            /* [in] */ long row,
            /* [in] */ long column,
            /* [retval][out] */ long *nColumnsSpanned) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_columnHeader( 
            /* [out] */ IAccessibleTable **accessibleTable,
            /* [retval][out] */ long *startingRowIndex) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_columnIndex( 
            /* [in] */ long cellIndex,
            /* [retval][out] */ long *columnIndex) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_nColumns( 
            /* [retval][out] */ long *columnCount) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_nRows( 
            /* [retval][out] */ long *rowCount) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_nSelectedChildren( 
            /* [retval][out] */ long *cellCount) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_nSelectedColumns( 
            /* [retval][out] */ long *columnCount) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_nSelectedRows( 
            /* [retval][out] */ long *rowCount) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_rowDescription( 
            /* [in] */ long row,
            /* [retval][out] */ BSTR *description) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_rowExtentAt( 
            /* [in] */ long row,
            /* [in] */ long column,
            /* [retval][out] */ long *nRowsSpanned) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_rowHeader( 
            /* [out] */ IAccessibleTable **accessibleTable,
            /* [retval][out] */ long *startingColumnIndex) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_rowIndex( 
            /* [in] */ long cellIndex,
            /* [retval][out] */ long *rowIndex) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_selectedChildren( 
            /* [in] */ long maxChildren,
            /* [length_is][length_is][size_is][size_is][out] */ long **children,
            /* [retval][out] */ long *nChildren) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_selectedColumns( 
            /* [in] */ long maxColumns,
            /* [length_is][length_is][size_is][size_is][out] */ long **columns,
            /* [retval][out] */ long *nColumns) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_selectedRows( 
            /* [in] */ long maxRows,
            /* [length_is][length_is][size_is][size_is][out] */ long **rows,
            /* [retval][out] */ long *nRows) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_summary( 
            /* [retval][out] */ IUnknown **accessible) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_isColumnSelected( 
            /* [in] */ long column,
            /* [retval][out] */ boolean *isSelected) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_isRowSelected( 
            /* [in] */ long row,
            /* [retval][out] */ boolean *isSelected) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_isSelected( 
            /* [in] */ long row,
            /* [in] */ long column,
            /* [retval][out] */ boolean *isSelected) = 0;
        
        virtual HRESULT STDMETHODCALLTYPE selectRow( 
            /* [in] */ long row) = 0;
        
        virtual HRESULT STDMETHODCALLTYPE selectColumn( 
            /* [in] */ long column) = 0;
        
        virtual HRESULT STDMETHODCALLTYPE unselectRow( 
            /* [in] */ long row) = 0;
        
        virtual HRESULT STDMETHODCALLTYPE unselectColumn( 
            /* [in] */ long column) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_rowColumnExtentsAtIndex( 
            /* [in] */ long index,
            /* [out] */ long *row,
            /* [out] */ long *column,
            /* [out] */ long *rowExtents,
            /* [out] */ long *columnExtents,
            /* [retval][out] */ boolean *isSelected) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_modelChange( 
            /* [retval][out] */ IA2TableModelChange *modelChange) = 0;
        
    };
    
#else 	/* C style interface */

    typedef struct IAccessibleTableVtbl
    {
        BEGIN_INTERFACE
        
        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
            IAccessibleTable * This,
            /* [in] */ REFIID riid,
            /* [iid_is][out] */ 
            __RPC__deref_out  void **ppvObject);
        
        ULONG ( STDMETHODCALLTYPE *AddRef )( 
            IAccessibleTable * This);
        
        ULONG ( STDMETHODCALLTYPE *Release )( 
            IAccessibleTable * This);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_accessibleAt )( 
            IAccessibleTable * This,
            /* [in] */ long row,
            /* [in] */ long column,
            /* [retval][out] */ IUnknown **accessible);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_caption )( 
            IAccessibleTable * This,
            /* [retval][out] */ IUnknown **accessible);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_childIndex )( 
            IAccessibleTable * This,
            /* [in] */ long rowIndex,
            /* [in] */ long columnIndex,
            /* [retval][out] */ long *cellIndex);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_columnDescription )( 
            IAccessibleTable * This,
            /* [in] */ long column,
            /* [retval][out] */ BSTR *description);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_columnExtentAt )( 
            IAccessibleTable * This,
            /* [in] */ long row,
            /* [in] */ long column,
            /* [retval][out] */ long *nColumnsSpanned);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_columnHeader )( 
            IAccessibleTable * This,
            /* [out] */ IAccessibleTable **accessibleTable,
            /* [retval][out] */ long *startingRowIndex);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_columnIndex )( 
            IAccessibleTable * This,
            /* [in] */ long cellIndex,
            /* [retval][out] */ long *columnIndex);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_nColumns )( 
            IAccessibleTable * This,
            /* [retval][out] */ long *columnCount);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_nRows )( 
            IAccessibleTable * This,
            /* [retval][out] */ long *rowCount);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_nSelectedChildren )( 
            IAccessibleTable * This,
            /* [retval][out] */ long *cellCount);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_nSelectedColumns )( 
            IAccessibleTable * This,
            /* [retval][out] */ long *columnCount);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_nSelectedRows )( 
            IAccessibleTable * This,
            /* [retval][out] */ long *rowCount);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_rowDescription )( 
            IAccessibleTable * This,
            /* [in] */ long row,
            /* [retval][out] */ BSTR *description);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_rowExtentAt )( 
            IAccessibleTable * This,
            /* [in] */ long row,
            /* [in] */ long column,
            /* [retval][out] */ long *nRowsSpanned);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_rowHeader )( 
            IAccessibleTable * This,
            /* [out] */ IAccessibleTable **accessibleTable,
            /* [retval][out] */ long *startingColumnIndex);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_rowIndex )( 
            IAccessibleTable * This,
            /* [in] */ long cellIndex,
            /* [retval][out] */ long *rowIndex);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_selectedChildren )( 
            IAccessibleTable * This,
            /* [in] */ long maxChildren,
            /* [length_is][length_is][size_is][size_is][out] */ long **children,
            /* [retval][out] */ long *nChildren);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_selectedColumns )( 
            IAccessibleTable * This,
            /* [in] */ long maxColumns,
            /* [length_is][length_is][size_is][size_is][out] */ long **columns,
            /* [retval][out] */ long *nColumns);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_selectedRows )( 
            IAccessibleTable * This,
            /* [in] */ long maxRows,
            /* [length_is][length_is][size_is][size_is][out] */ long **rows,
            /* [retval][out] */ long *nRows);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_summary )( 
            IAccessibleTable * This,
            /* [retval][out] */ IUnknown **accessible);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_isColumnSelected )( 
            IAccessibleTable * This,
            /* [in] */ long column,
            /* [retval][out] */ boolean *isSelected);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_isRowSelected )( 
            IAccessibleTable * This,
            /* [in] */ long row,
            /* [retval][out] */ boolean *isSelected);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_isSelected )( 
            IAccessibleTable * This,
            /* [in] */ long row,
            /* [in] */ long column,
            /* [retval][out] */ boolean *isSelected);
        
        HRESULT ( STDMETHODCALLTYPE *selectRow )( 
            IAccessibleTable * This,
            /* [in] */ long row);
        
        HRESULT ( STDMETHODCALLTYPE *selectColumn )( 
            IAccessibleTable * This,
            /* [in] */ long column);
        
        HRESULT ( STDMETHODCALLTYPE *unselectRow )( 
            IAccessibleTable * This,
            /* [in] */ long row);
        
        HRESULT ( STDMETHODCALLTYPE *unselectColumn )( 
            IAccessibleTable * This,
            /* [in] */ long column);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_rowColumnExtentsAtIndex )( 
            IAccessibleTable * This,
            /* [in] */ long index,
            /* [out] */ long *row,
            /* [out] */ long *column,
            /* [out] */ long *rowExtents,
            /* [out] */ long *columnExtents,
            /* [retval][out] */ boolean *isSelected);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_modelChange )( 
            IAccessibleTable * This,
            /* [retval][out] */ IA2TableModelChange *modelChange);
        
        END_INTERFACE
    } IAccessibleTableVtbl;

    interface IAccessibleTable
    {
        CONST_VTBL struct IAccessibleTableVtbl *lpVtbl;
    };

    

#ifdef COBJMACROS


#define IAccessibleTable_QueryInterface(This,riid,ppvObject)	\
    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 

#define IAccessibleTable_AddRef(This)	\
    ( (This)->lpVtbl -> AddRef(This) ) 

#define IAccessibleTable_Release(This)	\
    ( (This)->lpVtbl -> Release(This) ) 


#define IAccessibleTable_get_accessibleAt(This,row,column,accessible)	\
    ( (This)->lpVtbl -> get_accessibleAt(This,row,column,accessible) ) 

#define IAccessibleTable_get_caption(This,accessible)	\
    ( (This)->lpVtbl -> get_caption(This,accessible) ) 

#define IAccessibleTable_get_childIndex(This,rowIndex,columnIndex,cellIndex)	\
    ( (This)->lpVtbl -> get_childIndex(This,rowIndex,columnIndex,cellIndex) ) 

#define IAccessibleTable_get_columnDescription(This,column,description)	\
    ( (This)->lpVtbl -> get_columnDescription(This,column,description) ) 

#define IAccessibleTable_get_columnExtentAt(This,row,column,nColumnsSpanned)	\
    ( (This)->lpVtbl -> get_columnExtentAt(This,row,column,nColumnsSpanned) ) 

#define IAccessibleTable_get_columnHeader(This,accessibleTable,startingRowIndex)	\
    ( (This)->lpVtbl -> get_columnHeader(This,accessibleTable,startingRowIndex) ) 

#define IAccessibleTable_get_columnIndex(This,cellIndex,columnIndex)	\
    ( (This)->lpVtbl -> get_columnIndex(This,cellIndex,columnIndex) ) 

#define IAccessibleTable_get_nColumns(This,columnCount)	\
    ( (This)->lpVtbl -> get_nColumns(This,columnCount) ) 

#define IAccessibleTable_get_nRows(This,rowCount)	\
    ( (This)->lpVtbl -> get_nRows(This,rowCount) ) 

#define IAccessibleTable_get_nSelectedChildren(This,cellCount)	\
    ( (This)->lpVtbl -> get_nSelectedChildren(This,cellCount) ) 

#define IAccessibleTable_get_nSelectedColumns(This,columnCount)	\
    ( (This)->lpVtbl -> get_nSelectedColumns(This,columnCount) ) 

#define IAccessibleTable_get_nSelectedRows(This,rowCount)	\
    ( (This)->lpVtbl -> get_nSelectedRows(This,rowCount) ) 

#define IAccessibleTable_get_rowDescription(This,row,description)	\
    ( (This)->lpVtbl -> get_rowDescription(This,row,description) ) 

#define IAccessibleTable_get_rowExtentAt(This,row,column,nRowsSpanned)	\
    ( (This)->lpVtbl -> get_rowExtentAt(This,row,column,nRowsSpanned) ) 

#define IAccessibleTable_get_rowHeader(This,accessibleTable,startingColumnIndex)	\
    ( (This)->lpVtbl -> get_rowHeader(This,accessibleTable,startingColumnIndex) ) 

#define IAccessibleTable_get_rowIndex(This,cellIndex,rowIndex)	\
    ( (This)->lpVtbl -> get_rowIndex(This,cellIndex,rowIndex) ) 

#define IAccessibleTable_get_selectedChildren(This,maxChildren,children,nChildren)	\
    ( (This)->lpVtbl -> get_selectedChildren(This,maxChildren,children,nChildren) ) 

#define IAccessibleTable_get_selectedColumns(This,maxColumns,columns,nColumns)	\
    ( (This)->lpVtbl -> get_selectedColumns(This,maxColumns,columns,nColumns) ) 

#define IAccessibleTable_get_selectedRows(This,maxRows,rows,nRows)	\
    ( (This)->lpVtbl -> get_selectedRows(This,maxRows,rows,nRows) ) 

#define IAccessibleTable_get_summary(This,accessible)	\
    ( (This)->lpVtbl -> get_summary(This,accessible) ) 

#define IAccessibleTable_get_isColumnSelected(This,column,isSelected)	\
    ( (This)->lpVtbl -> get_isColumnSelected(This,column,isSelected) ) 

#define IAccessibleTable_get_isRowSelected(This,row,isSelected)	\
    ( (This)->lpVtbl -> get_isRowSelected(This,row,isSelected) ) 

#define IAccessibleTable_get_isSelected(This,row,column,isSelected)	\
    ( (This)->lpVtbl -> get_isSelected(This,row,column,isSelected) ) 

#define IAccessibleTable_selectRow(This,row)	\
    ( (This)->lpVtbl -> selectRow(This,row) ) 

#define IAccessibleTable_selectColumn(This,column)	\
    ( (This)->lpVtbl -> selectColumn(This,column) ) 

#define IAccessibleTable_unselectRow(This,row)	\
    ( (This)->lpVtbl -> unselectRow(This,row) ) 

#define IAccessibleTable_unselectColumn(This,column)	\
    ( (This)->lpVtbl -> unselectColumn(This,column) ) 

#define IAccessibleTable_get_rowColumnExtentsAtIndex(This,index,row,column,rowExtents,columnExtents,isSelected)	\
    ( (This)->lpVtbl -> get_rowColumnExtentsAtIndex(This,index,row,column,rowExtents,columnExtents,isSelected) ) 

#define IAccessibleTable_get_modelChange(This,modelChange)	\
    ( (This)->lpVtbl -> get_modelChange(This,modelChange) ) 

#endif /* COBJMACROS */


#endif 	/* C style interface */




#endif 	/* __IAccessibleTable_INTERFACE_DEFINED__ */


#ifndef __IAccessibleTable2_INTERFACE_DEFINED__
#define __IAccessibleTable2_INTERFACE_DEFINED__

/* interface IAccessibleTable2 */
/* [uuid][object] */ 


EXTERN_C const IID IID_IAccessibleTable2;

#if defined(__cplusplus) && !defined(CINTERFACE)
    
    MIDL_INTERFACE("6167f295-06f0-4cdd-a1fa-02e25153d869")
    IAccessibleTable2 : public IUnknown
    {
    public:
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_cellAt( 
            /* [in] */ long row,
            /* [in] */ long column,
            /* [retval][out] */ IUnknown **cell) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_caption( 
            /* [retval][out] */ IUnknown **accessible) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_columnDescription( 
            /* [in] */ long column,
            /* [retval][out] */ BSTR *description) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_nColumns( 
            /* [retval][out] */ long *columnCount) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_nRows( 
            /* [retval][out] */ long *rowCount) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_nSelectedCells( 
            /* [retval][out] */ long *cellCount) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_nSelectedColumns( 
            /* [retval][out] */ long *columnCount) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_nSelectedRows( 
            /* [retval][out] */ long *rowCount) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_rowDescription( 
            /* [in] */ long row,
            /* [retval][out] */ BSTR *description) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_selectedCells( 
            /* [size_is][size_is][out] */ IUnknown ***cells,
            /* [retval][out] */ long *nSelectedCells) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_selectedColumns( 
            /* [size_is][size_is][out] */ long **selectedColumns,
            /* [retval][out] */ long *nColumns) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_selectedRows( 
            /* [size_is][size_is][out] */ long **selectedRows,
            /* [retval][out] */ long *nRows) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_summary( 
            /* [retval][out] */ IUnknown **accessible) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_isColumnSelected( 
            /* [in] */ long column,
            /* [retval][out] */ boolean *isSelected) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_isRowSelected( 
            /* [in] */ long row,
            /* [retval][out] */ boolean *isSelected) = 0;
        
        virtual HRESULT STDMETHODCALLTYPE selectRow( 
            /* [in] */ long row) = 0;
        
        virtual HRESULT STDMETHODCALLTYPE selectColumn( 
            /* [in] */ long column) = 0;
        
        virtual HRESULT STDMETHODCALLTYPE unselectRow( 
            /* [in] */ long row) = 0;
        
        virtual HRESULT STDMETHODCALLTYPE unselectColumn( 
            /* [in] */ long column) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_modelChange( 
            /* [retval][out] */ IA2TableModelChange *modelChange) = 0;
        
    };
    
#else 	/* C style interface */

    typedef struct IAccessibleTable2Vtbl
    {
        BEGIN_INTERFACE
        
        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
            IAccessibleTable2 * This,
            /* [in] */ REFIID riid,
            /* [iid_is][out] */ 
            __RPC__deref_out  void **ppvObject);
        
        ULONG ( STDMETHODCALLTYPE *AddRef )( 
            IAccessibleTable2 * This);
        
        ULONG ( STDMETHODCALLTYPE *Release )( 
            IAccessibleTable2 * This);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_cellAt )( 
            IAccessibleTable2 * This,
            /* [in] */ long row,
            /* [in] */ long column,
            /* [retval][out] */ IUnknown **cell);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_caption )( 
            IAccessibleTable2 * This,
            /* [retval][out] */ IUnknown **accessible);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_columnDescription )( 
            IAccessibleTable2 * This,
            /* [in] */ long column,
            /* [retval][out] */ BSTR *description);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_nColumns )( 
            IAccessibleTable2 * This,
            /* [retval][out] */ long *columnCount);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_nRows )( 
            IAccessibleTable2 * This,
            /* [retval][out] */ long *rowCount);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_nSelectedCells )( 
            IAccessibleTable2 * This,
            /* [retval][out] */ long *cellCount);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_nSelectedColumns )( 
            IAccessibleTable2 * This,
            /* [retval][out] */ long *columnCount);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_nSelectedRows )( 
            IAccessibleTable2 * This,
            /* [retval][out] */ long *rowCount);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_rowDescription )( 
            IAccessibleTable2 * This,
            /* [in] */ long row,
            /* [retval][out] */ BSTR *description);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_selectedCells )( 
            IAccessibleTable2 * This,
            /* [size_is][size_is][out] */ IUnknown ***cells,
            /* [retval][out] */ long *nSelectedCells);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_selectedColumns )( 
            IAccessibleTable2 * This,
            /* [size_is][size_is][out] */ long **selectedColumns,
            /* [retval][out] */ long *nColumns);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_selectedRows )( 
            IAccessibleTable2 * This,
            /* [size_is][size_is][out] */ long **selectedRows,
            /* [retval][out] */ long *nRows);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_summary )( 
            IAccessibleTable2 * This,
            /* [retval][out] */ IUnknown **accessible);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_isColumnSelected )( 
            IAccessibleTable2 * This,
            /* [in] */ long column,
            /* [retval][out] */ boolean *isSelected);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_isRowSelected )( 
            IAccessibleTable2 * This,
            /* [in] */ long row,
            /* [retval][out] */ boolean *isSelected);
        
        HRESULT ( STDMETHODCALLTYPE *selectRow )( 
            IAccessibleTable2 * This,
            /* [in] */ long row);
        
        HRESULT ( STDMETHODCALLTYPE *selectColumn )( 
            IAccessibleTable2 * This,
            /* [in] */ long column);
        
        HRESULT ( STDMETHODCALLTYPE *unselectRow )( 
            IAccessibleTable2 * This,
            /* [in] */ long row);
        
        HRESULT ( STDMETHODCALLTYPE *unselectColumn )( 
            IAccessibleTable2 * This,
            /* [in] */ long column);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_modelChange )( 
            IAccessibleTable2 * This,
            /* [retval][out] */ IA2TableModelChange *modelChange);
        
        END_INTERFACE
    } IAccessibleTable2Vtbl;

    interface IAccessibleTable2
    {
        CONST_VTBL struct IAccessibleTable2Vtbl *lpVtbl;
    };

    

#ifdef COBJMACROS


#define IAccessibleTable2_QueryInterface(This,riid,ppvObject)	\
    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 

#define IAccessibleTable2_AddRef(This)	\
    ( (This)->lpVtbl -> AddRef(This) ) 

#define IAccessibleTable2_Release(This)	\
    ( (This)->lpVtbl -> Release(This) ) 


#define IAccessibleTable2_get_cellAt(This,row,column,cell)	\
    ( (This)->lpVtbl -> get_cellAt(This,row,column,cell) ) 

#define IAccessibleTable2_get_caption(This,accessible)	\
    ( (This)->lpVtbl -> get_caption(This,accessible) ) 

#define IAccessibleTable2_get_columnDescription(This,column,description)	\
    ( (This)->lpVtbl -> get_columnDescription(This,column,description) ) 

#define IAccessibleTable2_get_nColumns(This,columnCount)	\
    ( (This)->lpVtbl -> get_nColumns(This,columnCount) ) 

#define IAccessibleTable2_get_nRows(This,rowCount)	\
    ( (This)->lpVtbl -> get_nRows(This,rowCount) ) 

#define IAccessibleTable2_get_nSelectedCells(This,cellCount)	\
    ( (This)->lpVtbl -> get_nSelectedCells(This,cellCount) ) 

#define IAccessibleTable2_get_nSelectedColumns(This,columnCount)	\
    ( (This)->lpVtbl -> get_nSelectedColumns(This,columnCount) ) 

#define IAccessibleTable2_get_nSelectedRows(This,rowCount)	\
    ( (This)->lpVtbl -> get_nSelectedRows(This,rowCount) ) 

#define IAccessibleTable2_get_rowDescription(This,row,description)	\
    ( (This)->lpVtbl -> get_rowDescription(This,row,description) ) 

#define IAccessibleTable2_get_selectedCells(This,cells,nSelectedCells)	\
    ( (This)->lpVtbl -> get_selectedCells(This,cells,nSelectedCells) ) 

#define IAccessibleTable2_get_selectedColumns(This,selectedColumns,nColumns)	\
    ( (This)->lpVtbl -> get_selectedColumns(This,selectedColumns,nColumns) ) 

#define IAccessibleTable2_get_selectedRows(This,selectedRows,nRows)	\
    ( (This)->lpVtbl -> get_selectedRows(This,selectedRows,nRows) ) 

#define IAccessibleTable2_get_summary(This,accessible)	\
    ( (This)->lpVtbl -> get_summary(This,accessible) ) 

#define IAccessibleTable2_get_isColumnSelected(This,column,isSelected)	\
    ( (This)->lpVtbl -> get_isColumnSelected(This,column,isSelected) ) 

#define IAccessibleTable2_get_isRowSelected(This,row,isSelected)	\
    ( (This)->lpVtbl -> get_isRowSelected(This,row,isSelected) ) 

#define IAccessibleTable2_selectRow(This,row)	\
    ( (This)->lpVtbl -> selectRow(This,row) ) 

#define IAccessibleTable2_selectColumn(This,column)	\
    ( (This)->lpVtbl -> selectColumn(This,column) ) 

#define IAccessibleTable2_unselectRow(This,row)	\
    ( (This)->lpVtbl -> unselectRow(This,row) ) 

#define IAccessibleTable2_unselectColumn(This,column)	\
    ( (This)->lpVtbl -> unselectColumn(This,column) ) 

#define IAccessibleTable2_get_modelChange(This,modelChange)	\
    ( (This)->lpVtbl -> get_modelChange(This,modelChange) ) 

#endif /* COBJMACROS */


#endif 	/* C style interface */




#endif 	/* __IAccessibleTable2_INTERFACE_DEFINED__ */


#ifndef __IAccessibleTableCell_INTERFACE_DEFINED__
#define __IAccessibleTableCell_INTERFACE_DEFINED__

/* interface IAccessibleTableCell */
/* [uuid][object] */ 


EXTERN_C const IID IID_IAccessibleTableCell;

#if defined(__cplusplus) && !defined(CINTERFACE)
    
    MIDL_INTERFACE("594116B1-C99F-4847-AD06-0A7A86ECE645")
    IAccessibleTableCell : public IUnknown
    {
    public:
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_columnExtent( 
            /* [retval][out] */ long *nColumnsSpanned) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_columnHeaderCells( 
            /* [size_is][size_is][out] */ IUnknown ***cellAccessibles,
            /* [retval][out] */ long *nColumnHeaderCells) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_columnIndex( 
            /* [retval][out] */ long *columnIndex) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_rowExtent( 
            /* [retval][out] */ long *nRowsSpanned) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_rowHeaderCells( 
            /* [size_is][size_is][out] */ IUnknown ***cellAccessibles,
            /* [retval][out] */ long *nRowHeaderCells) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_rowIndex( 
            /* [retval][out] */ long *rowIndex) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_isSelected( 
            /* [retval][out] */ boolean *isSelected) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_rowColumnExtents( 
            /* [out] */ long *row,
            /* [out] */ long *column,
            /* [out] */ long *rowExtents,
            /* [out] */ long *columnExtents,
            /* [retval][out] */ boolean *isSelected) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_table( 
            /* [retval][out] */ IUnknown **table) = 0;
        
    };
    
#else 	/* C style interface */

    typedef struct IAccessibleTableCellVtbl
    {
        BEGIN_INTERFACE
        
        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
            IAccessibleTableCell * This,
            /* [in] */ REFIID riid,
            /* [iid_is][out] */ 
            __RPC__deref_out  void **ppvObject);
        
        ULONG ( STDMETHODCALLTYPE *AddRef )( 
            IAccessibleTableCell * This);
        
        ULONG ( STDMETHODCALLTYPE *Release )( 
            IAccessibleTableCell * This);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_columnExtent )( 
            IAccessibleTableCell * This,
            /* [retval][out] */ long *nColumnsSpanned);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_columnHeaderCells )( 
            IAccessibleTableCell * This,
            /* [size_is][size_is][out] */ IUnknown ***cellAccessibles,
            /* [retval][out] */ long *nColumnHeaderCells);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_columnIndex )( 
            IAccessibleTableCell * This,
            /* [retval][out] */ long *columnIndex);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_rowExtent )( 
            IAccessibleTableCell * This,
            /* [retval][out] */ long *nRowsSpanned);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_rowHeaderCells )( 
            IAccessibleTableCell * This,
            /* [size_is][size_is][out] */ IUnknown ***cellAccessibles,
            /* [retval][out] */ long *nRowHeaderCells);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_rowIndex )( 
            IAccessibleTableCell * This,
            /* [retval][out] */ long *rowIndex);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_isSelected )( 
            IAccessibleTableCell * This,
            /* [retval][out] */ boolean *isSelected);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_rowColumnExtents )( 
            IAccessibleTableCell * This,
            /* [out] */ long *row,
            /* [out] */ long *column,
            /* [out] */ long *rowExtents,
            /* [out] */ long *columnExtents,
            /* [retval][out] */ boolean *isSelected);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_table )( 
            IAccessibleTableCell * This,
            /* [retval][out] */ IUnknown **table);
        
        END_INTERFACE
    } IAccessibleTableCellVtbl;

    interface IAccessibleTableCell
    {
        CONST_VTBL struct IAccessibleTableCellVtbl *lpVtbl;
    };

    

#ifdef COBJMACROS


#define IAccessibleTableCell_QueryInterface(This,riid,ppvObject)	\
    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 

#define IAccessibleTableCell_AddRef(This)	\
    ( (This)->lpVtbl -> AddRef(This) ) 

#define IAccessibleTableCell_Release(This)	\
    ( (This)->lpVtbl -> Release(This) ) 


#define IAccessibleTableCell_get_columnExtent(This,nColumnsSpanned)	\
    ( (This)->lpVtbl -> get_columnExtent(This,nColumnsSpanned) ) 

#define IAccessibleTableCell_get_columnHeaderCells(This,cellAccessibles,nColumnHeaderCells)	\
    ( (This)->lpVtbl -> get_columnHeaderCells(This,cellAccessibles,nColumnHeaderCells) ) 

#define IAccessibleTableCell_get_columnIndex(This,columnIndex)	\
    ( (This)->lpVtbl -> get_columnIndex(This,columnIndex) ) 

#define IAccessibleTableCell_get_rowExtent(This,nRowsSpanned)	\
    ( (This)->lpVtbl -> get_rowExtent(This,nRowsSpanned) ) 

#define IAccessibleTableCell_get_rowHeaderCells(This,cellAccessibles,nRowHeaderCells)	\
    ( (This)->lpVtbl -> get_rowHeaderCells(This,cellAccessibles,nRowHeaderCells) ) 

#define IAccessibleTableCell_get_rowIndex(This,rowIndex)	\
    ( (This)->lpVtbl -> get_rowIndex(This,rowIndex) ) 

#define IAccessibleTableCell_get_isSelected(This,isSelected)	\
    ( (This)->lpVtbl -> get_isSelected(This,isSelected) ) 

#define IAccessibleTableCell_get_rowColumnExtents(This,row,column,rowExtents,columnExtents,isSelected)	\
    ( (This)->lpVtbl -> get_rowColumnExtents(This,row,column,rowExtents,columnExtents,isSelected) ) 

#define IAccessibleTableCell_get_table(This,table)	\
    ( (This)->lpVtbl -> get_table(This,table) ) 

#endif /* COBJMACROS */


#endif 	/* C style interface */




#endif 	/* __IAccessibleTableCell_INTERFACE_DEFINED__ */


#ifndef __IAccessibleImage_INTERFACE_DEFINED__
#define __IAccessibleImage_INTERFACE_DEFINED__

/* interface IAccessibleImage */
/* [uuid][object] */ 


EXTERN_C const IID IID_IAccessibleImage;

#if defined(__cplusplus) && !defined(CINTERFACE)
    
    MIDL_INTERFACE("FE5ABB3D-615E-4f7b-909F-5F0EDA9E8DDE")
    IAccessibleImage : public IUnknown
    {
    public:
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_description( 
            /* [retval][out] */ BSTR *description) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_imagePosition( 
            /* [in] */ enum IA2CoordinateType coordinateType,
            /* [out] */ long *x,
            /* [retval][out] */ long *y) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_imageSize( 
            /* [out] */ long *height,
            /* [retval][out] */ long *width) = 0;
        
    };
    
#else 	/* C style interface */

    typedef struct IAccessibleImageVtbl
    {
        BEGIN_INTERFACE
        
        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
            IAccessibleImage * This,
            /* [in] */ REFIID riid,
            /* [iid_is][out] */ 
            __RPC__deref_out  void **ppvObject);
        
        ULONG ( STDMETHODCALLTYPE *AddRef )( 
            IAccessibleImage * This);
        
        ULONG ( STDMETHODCALLTYPE *Release )( 
            IAccessibleImage * This);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_description )( 
            IAccessibleImage * This,
            /* [retval][out] */ BSTR *description);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_imagePosition )( 
            IAccessibleImage * This,
            /* [in] */ enum IA2CoordinateType coordinateType,
            /* [out] */ long *x,
            /* [retval][out] */ long *y);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_imageSize )( 
            IAccessibleImage * This,
            /* [out] */ long *height,
            /* [retval][out] */ long *width);
        
        END_INTERFACE
    } IAccessibleImageVtbl;

    interface IAccessibleImage
    {
        CONST_VTBL struct IAccessibleImageVtbl *lpVtbl;
    };

    

#ifdef COBJMACROS


#define IAccessibleImage_QueryInterface(This,riid,ppvObject)	\
    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 

#define IAccessibleImage_AddRef(This)	\
    ( (This)->lpVtbl -> AddRef(This) ) 

#define IAccessibleImage_Release(This)	\
    ( (This)->lpVtbl -> Release(This) ) 


#define IAccessibleImage_get_description(This,description)	\
    ( (This)->lpVtbl -> get_description(This,description) ) 

#define IAccessibleImage_get_imagePosition(This,coordinateType,x,y)	\
    ( (This)->lpVtbl -> get_imagePosition(This,coordinateType,x,y) ) 

#define IAccessibleImage_get_imageSize(This,height,width)	\
    ( (This)->lpVtbl -> get_imageSize(This,height,width) ) 

#endif /* COBJMACROS */


#endif 	/* C style interface */




#endif 	/* __IAccessibleImage_INTERFACE_DEFINED__ */


/* interface __MIDL_itf_IAccessible2_0000_0016 */
/* [local] */ 


enum IA2EventID
    {	IA2_EVENT_ACTION_CHANGED	= 0x101,
	IA2_EVENT_ACTIVE_DECENDENT_CHANGED	= ( IA2_EVENT_ACTION_CHANGED + 1 ) ,
	IA2_EVENT_ACTIVE_DESCENDANT_CHANGED	= IA2_EVENT_ACTIVE_DECENDENT_CHANGED,
	IA2_EVENT_DOCUMENT_ATTRIBUTE_CHANGED	= ( IA2_EVENT_ACTIVE_DESCENDANT_CHANGED + 1 ) ,
	IA2_EVENT_DOCUMENT_CONTENT_CHANGED	= ( IA2_EVENT_DOCUMENT_ATTRIBUTE_CHANGED + 1 ) ,
	IA2_EVENT_DOCUMENT_LOAD_COMPLETE	= ( IA2_EVENT_DOCUMENT_CONTENT_CHANGED + 1 ) ,
	IA2_EVENT_DOCUMENT_LOAD_STOPPED	= ( IA2_EVENT_DOCUMENT_LOAD_COMPLETE + 1 ) ,
	IA2_EVENT_DOCUMENT_RELOAD	= ( IA2_EVENT_DOCUMENT_LOAD_STOPPED + 1 ) ,
	IA2_EVENT_HYPERLINK_END_INDEX_CHANGED	= ( IA2_EVENT_DOCUMENT_RELOAD + 1 ) ,
	IA2_EVENT_HYPERLINK_NUMBER_OF_ANCHORS_CHANGED	= ( IA2_EVENT_HYPERLINK_END_INDEX_CHANGED + 1 ) ,
	IA2_EVENT_HYPERLINK_SELECTED_LINK_CHANGED	= ( IA2_EVENT_HYPERLINK_NUMBER_OF_ANCHORS_CHANGED + 1 ) ,
	IA2_EVENT_HYPERTEXT_LINK_ACTIVATED	= ( IA2_EVENT_HYPERLINK_SELECTED_LINK_CHANGED + 1 ) ,
	IA2_EVENT_HYPERTEXT_LINK_SELECTED	= ( IA2_EVENT_HYPERTEXT_LINK_ACTIVATED + 1 ) ,
	IA2_EVENT_HYPERLINK_START_INDEX_CHANGED	= ( IA2_EVENT_HYPERTEXT_LINK_SELECTED + 1 ) ,
	IA2_EVENT_HYPERTEXT_CHANGED	= ( IA2_EVENT_HYPERLINK_START_INDEX_CHANGED + 1 ) ,
	IA2_EVENT_HYPERTEXT_NLINKS_CHANGED	= ( IA2_EVENT_HYPERTEXT_CHANGED + 1 ) ,
	IA2_EVENT_OBJECT_ATTRIBUTE_CHANGED	= ( IA2_EVENT_HYPERTEXT_NLINKS_CHANGED + 1 ) ,
	IA2_EVENT_PAGE_CHANGED	= ( IA2_EVENT_OBJECT_ATTRIBUTE_CHANGED + 1 ) ,
	IA2_EVENT_SECTION_CHANGED	= ( IA2_EVENT_PAGE_CHANGED + 1 ) ,
	IA2_EVENT_TABLE_CAPTION_CHANGED	= ( IA2_EVENT_SECTION_CHANGED + 1 ) ,
	IA2_EVENT_TABLE_COLUMN_DESCRIPTION_CHANGED	= ( IA2_EVENT_TABLE_CAPTION_CHANGED + 1 ) ,
	IA2_EVENT_TABLE_COLUMN_HEADER_CHANGED	= ( IA2_EVENT_TABLE_COLUMN_DESCRIPTION_CHANGED + 1 ) ,
	IA2_EVENT_TABLE_MODEL_CHANGED	= ( IA2_EVENT_TABLE_COLUMN_HEADER_CHANGED + 1 ) ,
	IA2_EVENT_TABLE_ROW_DESCRIPTION_CHANGED	= ( IA2_EVENT_TABLE_MODEL_CHANGED + 1 ) ,
	IA2_EVENT_TABLE_ROW_HEADER_CHANGED	= ( IA2_EVENT_TABLE_ROW_DESCRIPTION_CHANGED + 1 ) ,
	IA2_EVENT_TABLE_SUMMARY_CHANGED	= ( IA2_EVENT_TABLE_ROW_HEADER_CHANGED + 1 ) ,
	IA2_EVENT_TEXT_ATTRIBUTE_CHANGED	= ( IA2_EVENT_TABLE_SUMMARY_CHANGED + 1 ) ,
	IA2_EVENT_TEXT_CARET_MOVED	= ( IA2_EVENT_TEXT_ATTRIBUTE_CHANGED + 1 ) ,
	IA2_EVENT_TEXT_CHANGED	= ( IA2_EVENT_TEXT_CARET_MOVED + 1 ) ,
	IA2_EVENT_TEXT_COLUMN_CHANGED	= ( IA2_EVENT_TEXT_CHANGED + 1 ) ,
	IA2_EVENT_TEXT_INSERTED	= ( IA2_EVENT_TEXT_COLUMN_CHANGED + 1 ) ,
	IA2_EVENT_TEXT_REMOVED	= ( IA2_EVENT_TEXT_INSERTED + 1 ) ,
	IA2_EVENT_TEXT_UPDATED	= ( IA2_EVENT_TEXT_REMOVED + 1 ) ,
	IA2_EVENT_TEXT_SELECTION_CHANGED	= ( IA2_EVENT_TEXT_UPDATED + 1 ) ,
	IA2_EVENT_VISIBLE_DATA_CHANGED	= ( IA2_EVENT_TEXT_SELECTION_CHANGED + 1 ) 
    } ;


extern RPC_IF_HANDLE __MIDL_itf_IAccessible2_0000_0016_v0_0_c_ifspec;
extern RPC_IF_HANDLE __MIDL_itf_IAccessible2_0000_0016_v0_0_s_ifspec;

#ifndef __IAccessibleApplication_INTERFACE_DEFINED__
#define __IAccessibleApplication_INTERFACE_DEFINED__

/* interface IAccessibleApplication */
/* [uuid][object] */ 


EXTERN_C const IID IID_IAccessibleApplication;

#if defined(__cplusplus) && !defined(CINTERFACE)
    
    MIDL_INTERFACE("D49DED83-5B25-43F4-9B95-93B44595979E")
    IAccessibleApplication : public IUnknown
    {
    public:
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_appName( 
            /* [retval][out] */ BSTR *name) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_appVersion( 
            /* [retval][out] */ BSTR *version) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_toolkitName( 
            /* [retval][out] */ BSTR *name) = 0;
        
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_toolkitVersion( 
            /* [retval][out] */ BSTR *version) = 0;
        
    };
    
#else 	/* C style interface */

    typedef struct IAccessibleApplicationVtbl
    {
        BEGIN_INTERFACE
        
        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
            IAccessibleApplication * This,
            /* [in] */ REFIID riid,
            /* [iid_is][out] */ 
            __RPC__deref_out  void **ppvObject);
        
        ULONG ( STDMETHODCALLTYPE *AddRef )( 
            IAccessibleApplication * This);
        
        ULONG ( STDMETHODCALLTYPE *Release )( 
            IAccessibleApplication * This);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_appName )( 
            IAccessibleApplication * This,
            /* [retval][out] */ BSTR *name);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_appVersion )( 
            IAccessibleApplication * This,
            /* [retval][out] */ BSTR *version);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_toolkitName )( 
            IAccessibleApplication * This,
            /* [retval][out] */ BSTR *name);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_toolkitVersion )( 
            IAccessibleApplication * This,
            /* [retval][out] */ BSTR *version);
        
        END_INTERFACE
    } IAccessibleApplicationVtbl;

    interface IAccessibleApplication
    {
        CONST_VTBL struct IAccessibleApplicationVtbl *lpVtbl;
    };

    

#ifdef COBJMACROS


#define IAccessibleApplication_QueryInterface(This,riid,ppvObject)	\
    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 

#define IAccessibleApplication_AddRef(This)	\
    ( (This)->lpVtbl -> AddRef(This) ) 

#define IAccessibleApplication_Release(This)	\
    ( (This)->lpVtbl -> Release(This) ) 


#define IAccessibleApplication_get_appName(This,name)	\
    ( (This)->lpVtbl -> get_appName(This,name) ) 

#define IAccessibleApplication_get_appVersion(This,version)	\
    ( (This)->lpVtbl -> get_appVersion(This,version) ) 

#define IAccessibleApplication_get_toolkitName(This,name)	\
    ( (This)->lpVtbl -> get_toolkitName(This,name) ) 

#define IAccessibleApplication_get_toolkitVersion(This,version)	\
    ( (This)->lpVtbl -> get_toolkitVersion(This,version) ) 

#endif /* COBJMACROS */


#endif 	/* C style interface */




#endif 	/* __IAccessibleApplication_INTERFACE_DEFINED__ */


#ifndef __IAccessibleDocument_INTERFACE_DEFINED__
#define __IAccessibleDocument_INTERFACE_DEFINED__

/* interface IAccessibleDocument */
/* [uuid][object] */ 


EXTERN_C const IID IID_IAccessibleDocument;

#if defined(__cplusplus) && !defined(CINTERFACE)
    
    MIDL_INTERFACE("C48C7FCF-4AB5-4056-AFA6-902D6E1D1149")
    IAccessibleDocument : public IUnknown
    {
    public:
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_anchorTarget( 
            /* [retval][out] */ IUnknown **accessible) = 0;
        
    };
    
#else 	/* C style interface */

    typedef struct IAccessibleDocumentVtbl
    {
        BEGIN_INTERFACE
        
        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
            IAccessibleDocument * This,
            /* [in] */ REFIID riid,
            /* [iid_is][out] */ 
            __RPC__deref_out  void **ppvObject);
        
        ULONG ( STDMETHODCALLTYPE *AddRef )( 
            IAccessibleDocument * This);
        
        ULONG ( STDMETHODCALLTYPE *Release )( 
            IAccessibleDocument * This);
        
        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_anchorTarget )( 
            IAccessibleDocument * This,
            /* [retval][out] */ IUnknown **accessible);
        
        END_INTERFACE
    } IAccessibleDocumentVtbl;

    interface IAccessibleDocument
    {
        CONST_VTBL struct IAccessibleDocumentVtbl *lpVtbl;
    };

    

#ifdef COBJMACROS


#define IAccessibleDocument_QueryInterface(This,riid,ppvObject)	\
    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 

#define IAccessibleDocument_AddRef(This)	\
    ( (This)->lpVtbl -> AddRef(This) ) 

#define IAccessibleDocument_Release(This)	\
    ( (This)->lpVtbl -> Release(This) ) 


#define IAccessibleDocument_get_anchorTarget(This,accessible)	\
    ( (This)->lpVtbl -> get_anchorTarget(This,accessible) ) 

#endif /* COBJMACROS */


#endif 	/* C style interface */




#endif 	/* __IAccessibleDocument_INTERFACE_DEFINED__ */


/* interface __MIDL_itf_IAccessible2_0000_0018 */
/* [local] */ 


// Type Library Definitions



extern RPC_IF_HANDLE __MIDL_itf_IAccessible2_0000_0018_v0_0_c_ifspec;
extern RPC_IF_HANDLE __MIDL_itf_IAccessible2_0000_0018_v0_0_s_ifspec;


#ifndef __IAccessible2Lib_LIBRARY_DEFINED__
#define __IAccessible2Lib_LIBRARY_DEFINED__

/* library IAccessible2Lib */
/* [hidden][version][helpstring][uuid] */ 




























EXTERN_C const IID LIBID_IAccessible2Lib;
#endif /* __IAccessible2Lib_LIBRARY_DEFINED__ */

/* Additional Prototypes for ALL interfaces */

unsigned long             __RPC_USER  BSTR_UserSize(     unsigned long *, unsigned long            , BSTR * ); 
unsigned char * __RPC_USER  BSTR_UserMarshal(  unsigned long *, unsigned char *, BSTR * ); 
unsigned char * __RPC_USER  BSTR_UserUnmarshal(unsigned long *, unsigned char *, BSTR * ); 
void                      __RPC_USER  BSTR_UserFree(     unsigned long *, BSTR * ); 

unsigned long             __RPC_USER  HWND_UserSize(     unsigned long *, unsigned long            , HWND * ); 
unsigned char * __RPC_USER  HWND_UserMarshal(  unsigned long *, unsigned char *, HWND * ); 
unsigned char * __RPC_USER  HWND_UserUnmarshal(unsigned long *, unsigned char *, HWND * ); 
void                      __RPC_USER  HWND_UserFree(     unsigned long *, HWND * ); 

unsigned long             __RPC_USER  VARIANT_UserSize(     unsigned long *, unsigned long            , VARIANT * ); 
unsigned char * __RPC_USER  VARIANT_UserMarshal(  unsigned long *, unsigned char *, VARIANT * ); 
unsigned char * __RPC_USER  VARIANT_UserUnmarshal(unsigned long *, unsigned char *, VARIANT * ); 
void                      __RPC_USER  VARIANT_UserFree(     unsigned long *, VARIANT * ); 

/* end of Additional Prototypes */

#ifdef __cplusplus
}
#endif

#endif




================================================
FILE: Cpp/ISimpleDOMDocument.h
================================================
/* this ALWAYS GENERATED file contains the definitions for the interfaces */


 /* File created by MIDL compiler version 7.00.0499 */
/* at Mon Dec 01 09:02:08 2008
 */
/* Compiler settings for e:/builds/tinderbox/XR-Trunk/WINNT_5.2_Depend/mozilla/accessible/public/msaa/ISimpleDOMDocument.idl:
    Oicf, W1, Zp8, env=Win32 (32b run)
    protocol : dce , ms_ext, c_ext
    error checks: allocation ref bounds_check enum stub_data
    VC __declspec() decoration level:
         __declspec(uuid()), __declspec(selectany), __declspec(novtable)
         DECLSPEC_UUID(), MIDL_INTERFACE()
*/
//@@MIDL_FILE_HEADING(  )

#pragma warning( disable: 4049 )  /* more than 64k source lines */


/* verify that the <rpcndr.h> version is high enough to compile this file*/
#ifndef __REQUIRED_RPCNDR_H_VERSION__
#define __REQUIRED_RPCNDR_H_VERSION__ 440
#endif


#ifndef __ISimpleDOMDocument_h__
#define __ISimpleDOMDocument_h__

#if defined(_MSC_VER) && (_MSC_VER >= 1020)
#pragma once
#endif

/* Forward Declarations */

#ifndef __ISimpleDOMDocument_FWD_DEFINED__
#define __ISimpleDOMDocument_FWD_DEFINED__
typedef interface ISimpleDOMDocument ISimpleDOMDocument;
#endif  /* __ISimpleDOMDocument_FWD_DEFINED__ */

#ifdef __cplusplus
extern "C"{
#endif


/* interface __MIDL_itf_ISimpleDOMDocument_0000_0000 */
/* [local] */

///////////////////////////////////////////////////////////////////////////////////////////////////////
//
// ISimpleDOMDocument
//
// @STATUS UNDER_REVIEW
// ---------------------------------------------------------------------------------------------------=
//
// get_URL(out] BSTR *url)
// ---------------------------------------------------------------------------------------------------=
// Get the internet URL associated with this document.
//
// get_title([out BSTR *title
// ---------------------------------------------------------------------------------------------------=
// Get the document's title from the <TITLE> element
//
// get_mimeType([out BSTR *mimeType
// ---------------------------------------------------------------------------------------------------=
// Get the registered mime type, such as text/html
//
// get_docType([out] BSTR *docType
// ---------------------------------------------------------------------------------------------------=
// Get doctype associated with the <!DOCTYPE ..> element
//
// get_nameSpaceURIForID([in] short nameSpaceID, [out] BSTR *nameSpaceURI)
// ---------------------------------------------------------------------------------------------------=
// Some of the methods for ISimpleDOMNode return a nameSpaceID (-1,0,1,2,3,....)
// This method returns the associated namespace URI for each ID.
//
// set_alternateViewMediaTypes([in] BSTR *commaSeparatedMediaType)
// ---------------------------------------------------------------------------------------------------=
// For style property retrieval on nsISimpleDOMNode elements,
// set the additional alternate media types that properties are available for.
// [in] BSTR *commaSeparatedMediaTypes is a comma separate list, for example "aural, braille".
// The alternate media properties are requested with nsISimpleDOMNode::get_computedStyle.
// Note: setting this value on a document will increase memory overhead, and may create a small delay.
//
// W3C media Types:
// * all:        Suitable for all devices.
// * aural:      Intended for speech synthesizers. See the section on aural style sheets for details.
// * braille:    Intended for braille tactile feedback devices.
// * embossed:   Intended for paged braille printers.
// * handheld:   Intended for handheld devices - typically small screen, monochrome, limited bandwidth.
// * print:      Intended for paged, opaque material and for documents viewed on screen in print preview mode. Please consult the section on paged media for information about formatting issues that are specific to paged media.
// * projection: Intended for projected presentations, for example projectors or print to transparencies. Please consult the section on paged media for information about formatting issues that are specific to paged media.
// * screen:     Intended primarily for color computer screens.
// * tty:        intended for media using a fixed-pitch character grid, such as teletypes, terminals, or portable devices with limited display capabilities. Authors should not use pixel units with the tty media type.
// * tv:         Intended for television-type devices - low resolution, color, limited-scrollability screens, sound
// * See latest W3C CSS specs for complete list of media types
//
//
///////////////////////////////////////////////////////////////////////////////////////////////////////


#define DISPID_DOC_URL  ( -5904 )

#define DISPID_DOC_TITLE        ( -5905 )

#define DISPID_DOC_MIMETYPE     ( -5906 )

#define DISPID_DOC_DOCTYPE      ( -5907 )

#define DISPID_DOC_NAMESPACE    ( -5908 )

#define DISPID_DOC_MEDIATYPES   ( -5909 )



extern RPC_IF_HANDLE __MIDL_itf_ISimpleDOMDocument_0000_0000_v0_0_c_ifspec;
extern RPC_IF_HANDLE __MIDL_itf_ISimpleDOMDocument_0000_0000_v0_0_s_ifspec;

#ifndef __ISimpleDOMDocument_INTERFACE_DEFINED__
#define __ISimpleDOMDocument_INTERFACE_DEFINED__

/* interface ISimpleDOMDocument */
/* [uuid][object] */


EXTERN_C const IID IID_ISimpleDOMDocument;

#if defined(__cplusplus) && !defined(CINTERFACE)

    MIDL_INTERFACE("0D68D6D0-D93D-4d08-A30D-F00DD1F45B24")
    ISimpleDOMDocument : public IUnknown
    {
    public:
        virtual /* [id][propget] */ HRESULT STDMETHODCALLTYPE get_URL(
            /* [retval][out] */ BSTR *url) = 0;

        virtual /* [id][propget] */ HRESULT STDMETHODCALLTYPE get_title(
            /* [retval][out] */ BSTR *title) = 0;

        virtual /* [id][propget] */ HRESULT STDMETHODCALLTYPE get_mimeType(
            /* [retval][out] */ BSTR *mimeType) = 0;

        virtual /* [id][propget] */ HRESULT STDMETHODCALLTYPE get_docType(
            /* [retval][out] */ BSTR *docType) = 0;

        virtual /* [id][propget] */ HRESULT STDMETHODCALLTYPE get_nameSpaceURIForID(
            /* [in] */ short nameSpaceID,
            /* [retval][out] */ BSTR *nameSpaceURI) = 0;

        virtual /* [id][propput] */ HRESULT STDMETHODCALLTYPE put_alternateViewMediaTypes(
            /* [in] */ BSTR *commaSeparatedMediaTypes) = 0;

    };

#else   /* C style interface */

    typedef struct ISimpleDOMDocumentVtbl
    {
        BEGIN_INTERFACE

        HRESULT ( STDMETHODCALLTYPE *QueryInterface )(
            ISimpleDOMDocument * This,
            /* [in] */ REFIID riid,
            /* [iid_is][out] */
            __RPC__deref_out  void **ppvObject);

        ULONG ( STDMETHODCALLTYPE *AddRef )(
            ISimpleDOMDocument * This);

        ULONG ( STDMETHODCALLTYPE *Release )(
            ISimpleDOMDocument * This);

        /* [id][propget] */ HRESULT ( STDMETHODCALLTYPE *get_URL )(
            ISimpleDOMDocument * This,
            /* [retval][out] */ BSTR *url);

        /* [id][propget] */ HRESULT ( STDMETHODCALLTYPE *get_title )(
            ISimpleDOMDocument * This,
            /* [retval][out] */ BSTR *title);

        /* [id][propget] */ HRESULT ( STDMETHODCALLTYPE *get_mimeType )(
            ISimpleDOMDocument * This,
            /* [retval][out] */ BSTR *mimeType);

        /* [id][propget] */ HRESULT ( STDMETHODCALLTYPE *get_docType )(
            ISimpleDOMDocument * This,
            /* [retval][out] */ BSTR *docType);

        /* [id][propget] */ HRESULT ( STDMETHODCALLTYPE *get_nameSpaceURIForID )(
            ISimpleDOMDocument * This,
            /* [in] */ short nameSpaceID,
            /* [retval][out] */ BSTR *nameSpaceURI);

        /* [id][propput] */ HRESULT ( STDMETHODCALLTYPE *put_alternateViewMediaTypes )(
            ISimpleDOMDocument * This,
            /* [in] */ BSTR *commaSeparatedMediaTypes);

        END_INTERFACE
    } ISimpleDOMDocumentVtbl;

    interface ISimpleDOMDocument
    {
        CONST_VTBL struct ISimpleDOMDocumentVtbl *lpVtbl;
    };



#ifdef COBJMACROS


#define ISimpleDOMDocument_QueryInterface(This,riid,ppvObject)  \
    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) )

#define ISimpleDOMDocument_AddRef(This) \
    ( (This)->lpVtbl -> AddRef(This) )

#define ISimpleDOMDocument_Release(This)        \
    ( (This)->lpVtbl -> Release(This) )


#define ISimpleDOMDocument_get_URL(This,url)    \
    ( (This)->lpVtbl -> get_URL(This,url) )

#define ISimpleDOMDocument_get_title(This,title)        \
    ( (This)->lpVtbl -> get_title(This,title) )

#define ISimpleDOMDocument_get_mimeType(This,mimeType)  \
    ( (This)->lpVtbl -> get_mimeType(This,mimeType) )

#define ISimpleDOMDocument_get_docType(This,docType)    \
    ( (This)->lpVtbl -> get_docType(This,docType) )

#define ISimpleDOMDocument_get_nameSpaceURIForID(This,nameSpaceID,nameSpaceURI) \
    ( (This)->lpVtbl -> get_nameSpaceURIForID(This,nameSpaceID,nameSpaceURI) )

#define ISimpleDOMDocument_put_alternateViewMediaTypes(This,commaSeparatedMediaTypes)   \
    ( (This)->lpVtbl -> put_alternateViewMediaTypes(This,commaSeparatedMediaTypes) )

#endif /* COBJMACROS */


#endif  /* C style interface */




#endif  /* __ISimpleDOMDocument_INTERFACE_DEFINED__ */


/* Additional Prototypes for ALL interfaces */

unsigned long             __RPC_USER  BSTR_UserSize(     unsigned long *, unsigned long            , BSTR * );
unsigned char * __RPC_USER  BSTR_UserMarshal(  unsigned long *, unsigned char *, BSTR * );
unsigned char * __RPC_USER  BSTR_UserUnmarshal(unsigned long *, unsigned char *, BSTR * );
void                      __RPC_USER  BSTR_UserFree(     unsigned long *, BSTR * );

/* end of Additional Prototypes */

#ifdef __cplusplus
}
#endif

#endif



================================================
FILE: Cpp/ISimpleDOMNode.h
================================================
#ifndef __REQUIRED_RPCNDR_H_VERSION__ 
#define __REQUIRED_RPCNDR_H_VERSION__ 440 
#endif 


#ifndef __ISimpleDOMNode_h__ 
#define __ISimpleDOMNode_h__ 

#if defined(_MSC_VER) && (_MSC_VER >= 1020)
#pragma once 
#endif 

/* Forward Declarations */  

#ifndef __ISimpleDOMNode_FWD_DEFINED__ 
#define __ISimpleDOMNode_FWD_DEFINED__ 
typedef interface ISimpleDOMNode ISimpleDOMNode; 
#endif 	/* __ISimpleDOMNode_FWD_DEFINED__ */ 



#ifdef __cplusplus 
extern "C"{ 
#endif  

	void * __RPC_USER MIDL_user_allocate(size_t); 
	void __RPC_USER MIDL_user_free( void * );  

	/* interface __MIDL_itf_ISimpleDOMNode_0000 */ 
	/* [local] */  

	/////////////////////////////////////////////////////////////////////////////////////////////////////// 
	// 
	// ISimpleDOMNode 
	// ---------------------------------------------------------------------------------------------------= 
	// An interface that extends MSAA's IAccessible to provide readonly DOM node information via cross-process COM. 
	// 
	// @STATUS UNDER_REVIEW 
	// 
	// get_nodeInfo( 
	//  /* [out] */ BSTR  *nodeName,   // For elements, this is the tag name 
	//  /* [out] */ short  *nameSpaceID, 
	//  /* [out] */ BSTR  *nodeValue,  
	//  /* [out] */ unsigned int    *numChildren);  
	//  /* [out] */ unsigned int    *uniqueID;  // In Win32 accessible events we generate, the target's childID matches to this 
	//  /* [out] */ unsigned short  *nodeType, 
	// ---------------------------------------------------------------------------------------------------= 
	// Get the basic information about a node. 
	// The namespace ID can be mapped to an URI using nsISimpleDOMDocument::get_nameSpaceURIForID() 
	// 
	// get_attributes( 
	//  /* [in]  */ unsigned short maxAttribs, 
	//  /* [out] */ unsigned short  *numAttribs, 
	//  /* [out] */ BSTR  *attribNames, 
	//  /* [out] */ short *nameSpaceID, 
	//  /* [out] */ BSTR  *attribValues); 
	// ---------------------------------------------------------------------------------------------------= 
	// Returns 3 arrays - the attribute names and values, and a namespace ID for each 
	// If the namespace ID is 0, it's the same namespace as the node's namespace 
	// 
	// get_attributesForNames( 
	//  /* [in] */ unsigned short numAttribs, 
	//  /* [in] */ BSTR   *attribNames, 
	//  /* [in] */ short  *nameSpaceID, 
	//  /* [out] */ BSTR  *attribValues); 
	// ---------------------------------------------------------------------------------------------------= 
	// Takes 2 arrays - the attribute names and namespace IDs, and returns an array of corresponding values 
	// If the namespace ID is 0, it's the same namespace as the node's namespace 
	// 
	// computedStyle(   
	//  /* [in]  */ unsigned short maxStyleProperties, 
	//  /* [out] */ unsigned short *numStyleProperties,  
	//  /* [in]  */ boolean useAlternateView,  // If TRUE, returns properites for media as set in nsIDOMDocument::set_alternateViewMediaTypes 
	//  /* [out] */ BSTR *styleProperties,  
	//  /* [out] */ BSTR *styleValues); 
	// ---------------------------------------------------------------------------------------------------= 
	// Returns 2 arrays -- the style properties and their values 
	//  useAlternateView=FALSE: gets properties for the default media type (usually screen) 
	//  useAlternateView=TRUE: properties for media types set w/ nsIDOMSimpleDocument::set_alternateViewMediaTypes() 
	// 
	// computedStyleForProperties(   
	//  /* [in] */  unsigned short numStyleProperties,  
	//  /* [in] */  boolean useAlternateView,  // If TRUE, returns properites for media as set in nsIDOMDocument::set_alternateViewMediaTypes 
	//  /* [in] */  BSTR *styleProperties,  
	//  /* [out] */ BSTR *styleValues); 
	// ---------------------------------------------------------------------------------------------------= 
	// Scroll the current view so that this dom node is visible. 
	//  placeTopLeft=TRUE: scroll until the top left corner of the dom node is at the top left corner of the view. 
	//  placeTopLeft=FALSE: scroll minimally to make the dom node visible. Don't scroll at all if already visible. 
	// 
	// scrollTo(  
	//  /* [in] */ boolean placeTopLeft);  
	// ---------------------------------------------------------------------------------------------------= 
	// Returns style property values for those properties in the styleProperties [in] array 
	// Returns 2 arrays -- the style properties and their values 
	//  useAlternateView=FALSE: gets properties for the default media type (usually screen) 
	//  useAlternateView=TRUE: properties for media types set w/ nsIDOMSimpleDocument::set_alternateViewMediaTypes() 
	// 
	// get_parentNode     (/* [out] */ ISimpleDOMNode **newNodePtr); 
	// get_firstChild     (/* [out] */ ISimpleDOMNode **newNodePtr); 
	// get_lastChild      (/* [out] */ ISimpleDOMNode **newNodePtr); 
	// get_previousSibling(/* [out] */ ISimpleDOMNode **newNodePtr); 
	// get_nextSibling    (/* [out] */ ISimpleDOMNode **newNodePtr); 
	// get_childAt        (/* [in] */ unsigned childIndex, /* [out] */ ISimpleDOMNode **newNodePtr); 
	// ---------------------------------------------------------------------------------------------------= 
	// DOM navigation - get a different node. 
	// 
	// get_innerHTML(/* [out] */ BSTR *htmlText); 
	// ---------------------------------------------------------------------------------------------------= 
	// Returns HTML of this DOM node's subtree. Does not include the start and end tag for this node/element. 
	// 
	// 
	// get_localInterface(/* [out] */ void **localInterface); 
	// ---------------------------------------------------------------------------------------------------= 
	// Only available in Gecko's process - casts to an XPCOM nsIAccessNode interface pointer 
	// 
	// 
	// get_language(/* [out] */ BSTR *htmlText); 
	// ---------------------------------------------------------------------------------------------------= 
	// Returns the computed language for this node, or empty string if unknown. 
	// 
	// 
	/////////////////////////////////////////////////////////////////////////////////////////////////////// 


#define	DISPID_NODE_NODEINFO	( -5900 ) 

#define	DISPID_NODE_ATTRIBUTES	( -5901 ) 

#define	DISPID_NODE_ATTRIBUTESFORNAMES	( -5902 ) 

#define	DISPID_NODE_COMPSTYLE	( -5903 ) 

#define	DISPID_NODE_COMPSTYLEFORPROPS	( -5904 ) 

#define	DISPID_NODE_LANGUAGE	( -5905 ) 



	extern RPC_IF_HANDLE __MIDL_itf_ISimpleDOMNode_0000_v0_0_c_ifspec; 
	extern RPC_IF_HANDLE __MIDL_itf_ISimpleDOMNode_0000_v0_0_s_ifspec; 

#ifndef __ISimpleDOMNode_INTERFACE_DEFINED__ 
#define __ISimpleDOMNode_INTERFACE_DEFINED__ 

	/* interface ISimpleDOMNode */ 
	/* [uuid][object] */  

#define	NODETYPE_ELEMENT	( 1 ) 

#define	NODETYPE_ATTRIBUTE	( 2 ) 

#define	NODETYPE_TEXT	( 3 ) 

#define	NODETYPE_CDATA_SECTION	( 4 ) 

#define	NODETYPE_ENTITY_REFERENCE	( 5 ) 

#define	NODETYPE_ENTITY	( 6 ) 

#define	NODETYPE_PROCESSING_INSTRUCTION	( 7 ) 

#define	NODETYPE_COMMENT	( 8 ) 

#define	NODETYPE_DOCUMENT	( 9 ) 

#define	NODETYPE_DOCUMENT_TYPE	( 10 ) 

#define	NODETYPE_DOCUMENT_FRAGMENT	( 11 ) 

#define	NODETYPE_NOTATION	( 12 ) 


	EXTERN_C const IID IID_ISimpleDOMNode; 

#if defined(__cplusplus) && !defined(CINTERFACE) 

	MIDL_INTERFACE("1814ceeb-49e2-407f-af99-fa755a7d2607") 
ISimpleDOMNode : public IUnknown 
	{ 
	public: 
		virtual /* [id][propget] */ HRESULT STDMETHODCALLTYPE get_nodeInfo(  
			/* [out] */ BSTR *nodeName, 
			/* [out] */ short *nameSpaceID, 
			/* [out] */ BSTR *nodeValue, 
			/* [out] */ unsigned int *numChildren, 
			/* [out] */ unsigned int *uniqueID, 
			/* [retval][out] */ unsigned short *nodeType) = 0; 

			virtual /* [id][propget] */ HRESULT STDMETHODCALLTYPE get_attributes(  
			/* [in] */ unsigned short maxAttribs, 
			/* [length_is][size_is][out] */ BSTR *attribNames, 
			/* [length_is][size_is][out] */ short *nameSpaceID, 
			/* [length_is][size_is][out] */ BSTR *attribValues, 
			/* [retval][out] */ unsigned short *numAttribs) = 0; 

			virtual /* [id][propget] */ HRESULT STDMETHODCALLTYPE get_attributesForNames(  
			/* [in] */ unsigned short numAttribs, 
			/* [length_is][size_is][in] */ BSTR *attribNames, 
			/* [length_is][size_is][in] */ short *nameSpaceID, 
			/* [length_is][size_is][retval][out] */ BSTR *attribValues) = 0; 

			virtual /* [id][propget] */ HRESULT STDMETHODCALLTYPE get_computedStyle(  
			/* [in] */ unsigned short maxStyleProperties, 
			/* [in] */ boolean useAlternateView, 
			/* [length_is][size_is][out] */ BSTR *styleProperties, 
			/* [length_is][size_is][out] */ BSTR *styleValues, 
			/* [retval][out] */ unsigned short *numStyleProperties) = 0; 

			virtual /* [id][propget] */ HRESULT STDMETHODCALLTYPE get_computedStyleForProperties(  
			/* [in] */ unsigned short numStyleProperties, 
			/* [in] */ boolean useAlternateView, 
			/* [length_is][size_is][in] */ BSTR *styleProperties, 
			/* [length_is][size_is][retval][out] */ BSTR *styleValues) = 0; 

			virtual HRESULT STDMETHODCALLTYPE scrollTo(  
			/* [in] */ boolean placeTopLeft) = 0; 

			virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_parentNode(  
			/* [retval][out] */ ISimpleDOMNode **node) = 0; 

			virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_firstChild(  
			/* [retval][out] */ ISimpleDOMNode **node) = 0; 

			virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_lastChild(  
			/* [retval][out] */ ISimpleDOMNode **node) = 0; 

			virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_previousSibling(  
			/* [retval][out] */ ISimpleDOMNode **node) = 0; 

			virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_nextSibling(  
			/* [retval][out] */ ISimpleDOMNode **node) = 0; 

			virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_childAt(  
			/* [in] */ unsigned int childIndex, 
			/* [retval][out] */ ISimpleDOMNode **node) = 0; 

			virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_innerHTML(  
			/* [retval][out] */ BSTR *innerHTML) = 0; 

			virtual /* [local][propget] */ HRESULT STDMETHODCALLTYPE get_localInterface(  
			/* [retval][out] */ void **localInterface) = 0; 

			virtual /* [id][propget] */ HRESULT STDMETHODCALLTYPE get_language(  
			/* [retval][out] */ BSTR *language) = 0; 

	}; 

#else 	/* C style interface */ 

	typedef struct ISimpleDOMNodeVtbl 
	{ 
		BEGIN_INTERFACE 

			HRESULT ( STDMETHODCALLTYPE *QueryInterface )(  
			ISimpleDOMNode * This, 
			/* [in] */ REFIID riid, 
			/* [iid_is][out] */ void **ppvObject); 

			ULONG ( STDMETHODCALLTYPE *AddRef )(  
			ISimpleDOMNode * This); 

			ULONG ( STDMETHODCALLTYPE *Release )(  
				ISimpleDOMNode * This); 

			/* [id][propget] */ HRESULT ( STDMETHODCALLTYPE *get_nodeInfo )(  
			ISimpleDOMNode * This, 
				/* [out] */ BSTR *nodeName, 
				/* [out] */ short *nameSpaceID, 
				/* [out] */ BSTR *nodeValue, 
				/* [out] */ unsigned int *numChildren, 
				/* [out] */ unsigned int *uniqueID, 
				/* [retval][out] */ unsigned short *nodeType); 

				/* [id][propget] */ HRESULT ( STDMETHODCALLTYPE *get_attributes )(  
				ISimpleDOMNode * This, 
				/* [in] */ unsigned short maxAttribs, 
				/* [length_is][size_is][out] */ BSTR *attribNames, 
				/* [length_is][size_is][out] */ short *nameSpaceID, 
				/* [length_is][size_is][out] */ BSTR *attribValues, 
				/* [retval][out] */ unsigned short *numAttribs); 

				/* [id][propget] */ HRESULT ( STDMETHODCALLTYPE *get_attributesForNames )(  
				ISimpleDOMNode * This, 
				/* [in] */ unsigned short numAttribs, 
				/* [length_is][size_is][in] */ BSTR *attribNames, 
				/* [length_is][size_is][in] */ short *nameSpaceID, 
				/* [length_is][size_is][retval][out] */ BSTR *attribValues); 

				/* [id][propget] */ HRESULT ( STDMETHODCALLTYPE *get_computedStyle )(  
				ISimpleDOMNode * This, 
				/* [in] */ unsigned short maxStyleProperties, 
				/* [in] */ boolean useAlternateView, 
				/* [length_is][size_is][out] */ BSTR *styleProperties, 
				/* [length_is][size_is][out] */ BSTR *styleValues, 
				/* [retval][out] */ unsigned short *numStyleProperties); 

				/* [id][propget] */ HRESULT ( STDMETHODCALLTYPE *get_computedStyleForProperties )(  
				ISimpleDOMNode * This, 
				/* [in] */ unsigned short numStyleProperties, 
				/* [in] */ boolean useAlternateView, 
				/* [length_is][size_is][in] */ BSTR *styleProperties, 
				/* [length_is][size_is][retval][out] */ BSTR *styleValues); 

				HRESULT ( STDMETHODCALLTYPE *scrollTo )(  
				ISimpleDOMNode * This, 
				/* [in] */ boolean placeTopLeft); 

				/* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_parentNode )(  
				ISimpleDOMNode * This, 
				/* [retval][out] */ ISimpleDOMNode **node); 

				/* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_firstChild )(  
				ISimpleDOMNode * This, 
				/* [retval][out] */ ISimpleDOMNode **node); 

				/* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_lastChild )(  
				ISimpleDOMNode * This, 
				/* [retval][out] */ ISimpleDOMNode **node); 

				/* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_previousSibling )(  
				ISimpleDOMNode * This, 
				/* [retval][out] */ ISimpleDOMNode **node); 

				/* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_nextSibling )(  
				ISimpleDOMNode * This, 
				/* [retval][out] */ ISimpleDOMNode **node); 

				/* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_childAt )(  
				ISimpleDOMNode * This, 
				/* [in] */ unsigned int childIndex, 
				/* [retval][out] */ ISimpleDOMNode **node); 

				/* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_innerHTML )(  
				ISimpleDOMNode * This, 
				/* [retval][out] */ BSTR *innerHTML); 

				/* [local][propget] */ HRESULT ( STDMETHODCALLTYPE *get_localInterface )(  
				ISimpleDOMNode * This, 
				/* [retval][out] */ void **localInterface); 

				/* [id][propget] */ HRESULT ( STDMETHODCALLTYPE *get_language )(  
				ISimpleDOMNode * This, 
				/* [retval][out] */ BSTR *language); 

		END_INTERFACE 
	} ISimpleDOMNodeVtbl; 

	interface ISimpleDOMNode 
	{ 
		CONST_VTBL struct ISimpleDOMNodeVtbl *lpVtbl; 
	}; 



#ifdef COBJMACROS 


#define ISimpleDOMNode_QueryInterface(This,riid,ppvObject)	\
	(This)->lpVtbl -> QueryInterface(This,riid,ppvObject)

#define ISimpleDOMNode_AddRef(This)	\
		(This)->lpVtbl -> AddRef(This)

#define ISimpleDOMNode_Release(This)	\
		(This)->lpVtbl -> Release(This)


#define ISimpleDOMNode_get_nodeInfo(This,nodeName,nameSpaceID,nodeValue,numChildren,uniqueID,nodeType)	\
		(This)->lpVtbl -> get_nodeInfo(This,nodeName,nameSpaceID,nodeValue,numChildren,uniqueID,nodeType)

#define ISimpleDOMNode_get_attributes(This,maxAttribs,attribNames,nameSpaceID,attribValues,numAttribs)	\
		(This)->lpVtbl -> get_attributes(This,maxAttribs,attribNames,nameSpaceID,attribValues,numAttribs)

#define ISimpleDOMNode_get_attributesForNames(This,numAttribs,attribNames,nameSpaceID,attribValues)	\
		(This)->lpVtbl -> get_attributesForNames(This,numAttribs,attribNames,nameSpaceID,attribValues)

#define ISimpleDOMNode_get_computedStyle(This,maxStyleProperties,useAlternateView,styleProperties,styleValues,numStyleProperties)	\
		(This)->lpVtbl -> get_computedStyle(This,maxStyleProperties,useAlternateView,styleProperties,styleValues,numStyleProperties)

#define ISimpleDOMNode_get_computedStyleForProperties(This,numStyleProperties,useAlternateView,styleProperties,styleValues)	\
		(This)->lpVtbl -> get_computedStyleForProperties(This,numStyleProperties,useAlternateView,styleProperties,styleValues)

#define ISimpleDOMNode_scrollTo(This,placeTopLeft)	\
		(This)->lpVtbl -> scrollTo(This,placeTopLeft)

#define ISimpleDOMNode_get_parentNode(This,node)	\
		(This)->lpVtbl -> get_parentNode(This,node)

#define ISimpleDOMNode_get_firstChild(This,node)	\
		(This)->lpVtbl -> get_firstChild(This,node)

#define ISimpleDOMNode_get_lastChild(This,node)	\
		(This)->lpVtbl -> get_lastChild(This,node)

#define ISimpleDOMNode_get_previousSibling(This,node)	\
		(This)->lpVtbl -> get_previousSibling(This,node)

#define ISimpleDOMNode_get_nextSibling(This,node)	\
		(This)->lpVtbl -> get_nextSibling(This,node)

#define ISimpleDOMNode_get_childAt(This,childIndex,node)	\
		(This)->lpVtbl -> get_childAt(This,childIndex,node)

#define ISimpleDOMNode_get_innerHTML(This,innerHTML)	\
		(This)->lpVtbl -> get_innerHTML(This,innerHTML)

#define ISimpleDOMNode_get_localInterface(This,localInterface)	\
		(This)->lpVtbl -> get_localInterface(This,localInterface)

#define ISimpleDOMNode_get_language(This,language)	\
		(This)->lpVtbl -> get_language(This,language)

#endif /* COBJMACROS */ 


#endif 	/* C style interface */ 



		/* [id][propget] */ HRESULT STDMETHODCALLTYPE ISimpleDOMNode_get_nodeInfo_Proxy(  
		ISimpleDOMNode * This, 
		/* [out] */ BSTR *nodeName, 
		/* [out] */ short *nameSpaceID, 
		/* [out] */ BSTR *nodeValue, 
		/* [out] */ unsigned int *numChildren, 
		/* [out] */ unsigned int *uniqueID, 
		/* [retval][out] */ unsigned short *nodeType); 


		void __RPC_STUB ISimpleDOMNode_get_nodeInfo_Stub( 
		IRpcStubBuffer *This, 
		IRpcChannelBuffer *_pRpcChannelBuffer, 
		PRPC_MESSAGE _pRpcMessage, 
		DWORD *_pdwStubPhase); 


	/* [id][propget] */ HRESULT STDMETHODCALLTYPE ISimpleDOMNode_get_attributes_Proxy(  
	ISimpleDOMNode * This, 
		/* [in] */ unsigned short maxAttribs, 
		/* [length_is][size_is][out] */ BSTR *attribNames, 
		/* [length_is][size_is][out] */ short *nameSpaceID, 
		/* [length_is][size_is][out] */ BSTR *attribValues, 
		/* [retval][out] */ unsigned short *numAttribs); 


		void __RPC_STUB ISimpleDOMNode_get_attributes_Stub( 
		IRpcStubBuffer *This, 
		IRpcChannelBuffer *_pRpcChannelBuffer, 
		PRPC_MESSAGE _pRpcMessage, 
		DWORD *_pdwStubPhase); 


	/* [id][propget] */ HRESULT STDMETHODCALLTYPE ISimpleDOMNode_get_attributesForNames_Proxy(  
	ISimpleDOMNode * This, 
		/* [in] */ unsigned short numAttribs, 
		/* [length_is][size_is][in] */ BSTR *attribNames, 
		/* [length_is][size_is][in] */ short *nameSpaceID, 
		/* [length_is][size_is][retval][out] */ BSTR *attribValues); 


		void __RPC_STUB ISimpleDOMNode_get_attributesForNames_Stub( 
		IRpcStubBuffer *This, 
		IRpcChannelBuffer *_pRpcChannelBuffer, 
		PRPC_MESSAGE _pRpcMessage, 
		DWORD *_pdwStubPhase); 


	/* [id][propget] */ HRESULT STDMETHODCALLTYPE ISimpleDOMNode_get_computedStyle_Proxy(  
	ISimpleDOMNode * This, 
		/* [in] */ unsigned short maxStyleProperties, 
		/* [in] */ boolean useAlternateView, 
		/* [length_is][size_is][out] */ BSTR *styleProperties, 
		/* [length_is][size_is][out] */ BSTR *styleValues, 
		/* [retval][out] */ unsigned short *numStyleProperties); 


		void __RPC_STUB ISimpleDOMNode_get_computedStyle_Stub( 
		IRpcStubBuffer *This, 
		IRpcChannelBuffer *_pRpcChannelBuffer, 
		PRPC_MESSAGE _pRpcMessage, 
		DWORD *_pdwStubPhase); 


	/* [id][propget] */ HRESULT STDMETHODCALLTYPE ISimpleDOMNode_get_computedStyleForProperties_Proxy(  
	ISimpleDOMNode * This, 
		/* [in] */ unsigned short numStyleProperties, 
		/* [in] */ boolean useAlternateView, 
		/* [length_is][size_is][in] */ BSTR *styleProperties, 
		/* [length_is][size_is][retval][out] */ BSTR *styleValues); 


		void __RPC_STUB ISimpleDOMNode_get_computedStyleForProperties_Stub( 
		IRpcStubBuffer *This, 
		IRpcChannelBuffer *_pRpcChannelBuffer, 
		PRPC_MESSAGE _pRpcMessage, 
		DWORD *_pdwStubPhase); 


	HRESULT STDMETHODCALLTYPE ISimpleDOMNode_scrollTo_Proxy(  
		ISimpleDOMNode * This, 
		/* [in] */ boolean placeTopLeft); 


		void __RPC_STUB ISimpleDOMNode_scrollTo_Stub( 
		IRpcStubBuffer *This, 
		IRpcChannelBuffer *_pRpcChannelBuffer, 
		PRPC_MESSAGE _pRpcMessage, 
		DWORD *_pdwStubPhase); 


	/* [propget] */ HRESULT STDMETHODCALLTYPE ISimpleDOMNode_get_parentNode_Proxy(  
	ISimpleDOMNode * This, 
		/* [retval][out] */ ISimpleDOMNode **node); 


		void __RPC_STUB ISimpleDOMNode_get_parentNode_Stub( 
		IRpcStubBuffer *This, 
		IRpcChannelBuffer *_pRpcChannelBuffer, 
		PRPC_MESSAGE _pRpcMessage, 
		DWORD *_pdwStubPhase); 


	/* [propget] */ HRESULT STDMETHODCALLTYPE ISimpleDOMNode_get_firstChild_Proxy(  
	ISimpleDOMNode * This, 
		/* [retval][out] */ ISimpleDOMNode **node); 


		void __RPC_STUB ISimpleDOMNode_get_firstChild_Stub( 
		IRpcStubBuffer *This, 
		IRpcChannelBuffer *_pRpcChannelBuffer, 
		PRPC_MESSAGE _pRpcMessage, 
		DWORD *_pdwStubPhase); 


	/* [propget] */ HRESULT STDMETHODCALLTYPE ISimpleDOMNode_get_lastChild_Proxy(  
	ISimpleDOMNode * This, 
		/* [retval][out] */ ISimpleDOMNode **node); 


		void __RPC_STUB ISimpleDOMNode_get_lastChild_Stub( 
		IRpcStubBuffer *This, 
		IRpcChannelBuffer *_pRpcChannelBuffer, 
		PRPC_MESSAGE _pRpcMessage, 
		DWORD *_pdwStubPhase); 


	/* [propget] */ HRESULT STDMETHODCALLTYPE ISimpleDOMNode_get_previousSibling_Proxy(  
	ISimpleDOMNode * This, 
		/* [retval][out] */ ISimpleDOMNode **node); 


		void __RPC_STUB ISimpleDOMNode_get_previousSibling_Stub( 
		IRpcStubBuffer *This, 
		IRpcChannelBuffer *_pRpcChannelBuffer, 
		PRPC_MESSAGE _pRpcMessage, 
		DWORD *_pdwStubPhase); 


	/* [propget] */ HRESULT STDMETHODCALLTYPE ISimpleDOMNode_get_nextSibling_Proxy(  
	ISimpleDOMNode * This, 
		/* [retval][out] */ ISimpleDOMNode **node); 


		void __RPC_STUB ISimpleDOMNode_get_nextSibling_Stub( 
		IRpcStubBuffer *This, 
		IRpcChannelBuffer *_pRpcChannelBuffer, 
		PRPC_MESSAGE _pRpcMessage, 
		DWORD *_pdwStubPhase); 


	/* [propget] */ HRESULT STDMETHODCALLTYPE ISimpleDOMNode_get_childAt_Proxy(  
	ISimpleDOMNode * This, 
		/* [in] */ unsigned int childIndex, 
		/* [retval][out] */ ISimpleDOMNode **node); 


		void __RPC_STUB ISimpleDOMNode_get_childAt_Stub( 
		IRpcStubBuffer *This, 
		IRpcChannelBuffer *_pRpcChannelBuffer, 
		PRPC_MESSAGE _pRpcMessage, 
		DWORD *_pdwStubPhase); 


	/* [propget] */ HRESULT STDMETHODCALLTYPE ISimpleDOMNode_get_innerHTML_Proxy(  
	ISimpleDOMNode * This, 
		/* [retval][out] */ BSTR *innerHTML); 


		void __RPC_STUB ISimpleDOMNode_get_innerHTML_Stub( 
		IRpcStubBuffer *This, 
		IRpcChannelBuffer *_pRpcChannelBuffer, 
		PRPC_MESSAGE _pRpcMessage, 
		DWORD *_pdwStubPhase); 


	/* [local][propget] */ HRESULT STDMETHODCALLTYPE ISimpleDOMNode_get_localInterface_Proxy(  
	ISimpleDOMNode * This, 
		/* [retval][out] */ void **localInterface); 


		void __RPC_STUB ISimpleDOMNode_get_localInterface_Stub( 
		IRpcStubBuffer *This, 
		IRpcChannelBuffer *_pRpcChannelBuffer, 
		PRPC_MESSAGE _pRpcMessage, 
		DWORD *_pdwStubPhase); 


	/* [id][propget] */ HRESULT STDMETHODCALLTYPE ISimpleDOMNode_get_language_Proxy(  
	ISimpleDOMNode * This, 
		/* [retval][out] */ BSTR *language); 


		void __RPC_STUB ISimpleDOMNode_get_language_Stub( 
		IRpcStubBuffer *This, 
		IRpcChannelBuffer *_pRpcChannelBuffer, 
		PRPC_MESSAGE _pRpcMessage, 
		DWORD *_pdwStubPhase); 



#endif 	/* __ISimpleDOMNode_INTERFACE_DEFINED__ */ 


	/* Additional Prototypes for ALL interfaces */ 

	unsigned long             __RPC_USER  BSTR_UserSize(     unsigned long *, unsigned long            , BSTR * );  
	unsigned char * __RPC_USER  BSTR_UserMarshal(  unsigned long *, unsigned char *, BSTR * );  
	unsigned char * __RPC_USER  BSTR_UserUnmarshal(unsigned long *, unsigned char *, BSTR * );  
	void                      __RPC_USER  BSTR_UserFree(     unsigned long *, BSTR * );  

	/* end of Additional Prototypes */ 

#ifdef __cplusplus 
} 
#endif 

#endif 




================================================
FILE: Cpp/ISimpleDOMText.h
================================================

/* this ALWAYS GENERATED file contains the definitions for the interfaces */


 /* File created by MIDL compiler version 7.00.0499 */
/* at Mon Dec 01 09:02:09 2008
 */
/* Compiler settings for e:/builds/tinderbox/XR-Trunk/WINNT_5.2_Depend/mozilla/accessible/public/msaa/ISimpleDOMText.idl:
    Oicf, W1, Zp8, env=Win32 (32b run)
    protocol : dce , ms_ext, c_ext
    error checks: allocation ref bounds_check enum stub_data
    VC __declspec() decoration level:
         __declspec(uuid()), __declspec(selectany), __declspec(novtable)
         DECLSPEC_UUID(), MIDL_INTERFACE()
*/
//@@MIDL_FILE_HEADING(  )

#pragma warning( disable: 4049 )  /* more than 64k source lines */


/* verify that the <rpcndr.h> version is high enough to compile this file*/
#ifndef __REQUIRED_RPCNDR_H_VERSION__
#define __REQUIRED_RPCNDR_H_VERSION__ 440
#endif


#ifndef __ISimpleDOMText_h__
#define __ISimpleDOMText_h__

#if defined(_MSC_VER) && (_MSC_VER >= 1020)
#pragma once
#endif

/* Forward Declarations */

#ifndef __ISimpleDOMText_FWD_DEFINED__
#define __ISimpleDOMText_FWD_DEFINED__
typedef interface ISimpleDOMText ISimpleDOMText;
#endif  /* __ISimpleDOMText_FWD_DEFINED__ */


#ifdef __cplusplus
extern "C"{
#endif


/* interface __MIDL_itf_ISimpleDOMText_0000_0000 */
/* [local] */

///////////////////////////////////////////////////////////////////////////////////////////////////////
//
// ISimpleDOMText
// ---------------------------------------------------------------------------------------------------=
// An interface that extends MSAA's IAccessible to provide important additional capabilities on text nodes
//
// @STATUS UNDER_REVIEW
//
// [propget] domText(/* out,retval */ BSTR *domText
// ---------------------------------------------------------------------------------------------------=
// Similar to IAccessible::get_accName, but does not strip out whitespace characters.
// Important for retrieving the correct start/end substring indices to use with other
// methods in ISimpleDOMText.
//
//
// get_[un]clippedSubstringBounds(
//   /* [in] */ unsigned int startIndex,
//   /* [in] */ unsigned int endIndex,
//   /* [out] */ int *x,
//   /* [out] */ int *y,
//   /* [out] */ int *width,
//   /* [out] */ int *height);
// ---------------------------------------------------------------------------------------------------=
// Both methods get_clippedSubstringBounds and get_unclippedSubstringBounds return the screen pixel
// coordinates of the given text substring. The in parameters for start and end indices refer
// to the string returned by ISimpleDOMText::get_domText().
//
//
// scrollToSubstring(
//   /* [in] */ unsigned int startIndex,
//   /* [in] */ unsigned int endIndex);
// ---------------------------------------------------------------------------------------------------=
// In scrollable views, scrolls to ensure that the specified substring is visible onscreen.
// The in parameters for start and end indices refer to the string returned
// by ISimpleDOMText::get_domText().
//
//
// [propget] fontFamily(/* out,retval */ BSTR *fontFamily);
// ---------------------------------------------------------------------------------------------------=
// Return a single computed font family name, which is better than the comma delineated list
// that is returned by the ISimpleDOMNode computed style methods for font-family.
// In other words, return something like 'Arial' instead of 'Arial, Helvetica, Sans-serif'.
///////////////////////////////////////////////////////////////////////////////////////////////////////




extern RPC_IF_HANDLE __MIDL_itf_ISimpleDOMText_0000_0000_v0_0_c_ifspec;
extern RPC_IF_HANDLE __MIDL_itf_ISimpleDOMText_0000_0000_v0_0_s_ifspec;

#ifndef __ISimpleDOMText_INTERFACE_DEFINED__
#define __ISimpleDOMText_INTERFACE_DEFINED__

/* interface ISimpleDOMText */
/* [uuid][object] */


EXTERN_C const IID IID_ISimpleDOMText;

#if defined(__cplusplus) && !defined(CINTERFACE)

    MIDL_INTERFACE("4e747be5-2052-4265-8af0-8ecad7aad1c0")
    ISimpleDOMText : public IUnknown
    {
    public:
        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_domText(
            /* [retval][out] */ BSTR *domText) = 0;

        virtual HRESULT STDMETHODCALLTYPE get_clippedSubstringBounds(
            /* [in] */ unsigned int startIndex,
            /* [in] */ unsigned int endIndex,
            /* [out] */ int *x,
            /* [out] */ int *y,
            /* [out] */ int *width,
            /* [out] */ int *height) = 0;

        virtual HRESULT STDMETHODCALLTYPE get_unclippedSubstringBounds(
            /* [in] */ unsigned int startIndex,
            /* [in] */ unsigned int endIndex,
            /* [out] */ int *x,
            /* [out] */ int *y,
            /* [out] */ int *width,
            /* [out] */ int *height) = 0;

        virtual HRESULT STDMETHODCALLTYPE scrollToSubstring(
            /* [in] */ unsigned int startIndex,
            /* [in] */ unsigned int endIndex) = 0;

        virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_fontFamily(
            /* [retval][out] */ BSTR *fontFamily) = 0;

    };

#else   /* C style interface */

    typedef struct ISimpleDOMTextVtbl
    {
        BEGIN_INTERFACE

        HRESULT ( STDMETHODCALLTYPE *QueryInterface )(
            ISimpleDOMText * This,
            /* [in] */ REFIID riid,
            /* [iid_is][out] */
            __RPC__deref_out  void **ppvObject);

        ULONG ( STDMETHODCALLTYPE *AddRef )(
            ISimpleDOMText * This);

        ULONG ( STDMETHODCALLTYPE *Release )(
            ISimpleDOMText * This);

        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_domText )(
            ISimpleDOMText * This,
            /* [retval][out] */ BSTR *domText);

        HRESULT ( STDMETHODCALLTYPE *get_clippedSubstringBounds )(
            ISimpleDOMText * This,
            /* [in] */ unsigned int startIndex,
            /* [in] */ unsigned int endIndex,
            /* [out] */ int *x,
            /* [out] */ int *y,
            /* [out] */ int *width,
            /* [out] */ int *height);

        HRESULT ( STDMETHODCALLTYPE *get_unclippedSubstringBounds )(
            ISimpleDOMText * This,
            /* [in] */ unsigned int startIndex,
            /* [in] */ unsigned int endIndex,
            /* [out] */ int *x,
            /* [out] */ int *y,
            /* [out] */ int *width,
            /* [out] */ int *height);

        HRESULT ( STDMETHODCALLTYPE *scrollToSubstring )(
            ISimpleDOMText * This,
            /* [in] */ unsigned int startIndex,
            /* [in] */ unsigned int endIndex);

        /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_fontFamily )(
            ISimpleDOMText * This,
            /* [retval][out] */ BSTR *fontFamily);

        END_INTERFACE
    } ISimpleDOMTextVtbl;

    interface ISimpleDOMText
    {
        CONST_VTBL struct ISimpleDOMTextVtbl *lpVtbl;
    };



#ifdef COBJMACROS


#define ISimpleDOMText_QueryInterface(This,riid,ppvObject)      \
    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) )

#define ISimpleDOMText_AddRef(This)     \
    ( (This)->lpVtbl -> AddRef(This) )

#define ISimpleDOMText_Release(This)    \
    ( (This)->lpVtbl -> Release(This) )


#define ISimpleDOMText_get_domText(This,domText)        \
    ( (This)->lpVtbl -> get_domText(This,domText) )

#define ISimpleDOMText_get_clippedSubstringBounds(This,startIndex,endIndex,x,y,width,height)    \
    ( (This)->lpVtbl -> get_clippedSubstringBounds(This,startIndex,endIndex,x,y,width,height) )

#define ISimpleDOMText_get_unclippedSubstringBounds(This,startIndex,endIndex,x,y,width,height)  \
    ( (This)->lpVtbl -> get_unclippedSubstringBounds(This,startIndex,endIndex,x,y,width,height) )

#define ISimpleDOMText_scrollToSubstring(This,startIndex,endIndex)      \
    ( (This)->lpVtbl -> scrollToSubstring(This,startIndex,endIndex) )

#define ISimpleDOMText_get_fontFamily(This,fontFamily)  \
    ( (This)->lpVtbl -> get_fontFamily(This,fontFamily) )

#endif /* COBJMACROS */


#endif  /* C style interface */




#endif  /* __ISimpleDOMText_INTERFACE_DEFINED__ */


/* Additional Prototypes for ALL interfaces */

unsigned long             __RPC_USER  BSTR_UserSize(     unsigned long *, unsigned long            , BSTR * );
unsigned char * __RPC_USER  BSTR_UserMarshal(  unsigned long *, unsigned char *, BSTR * );
unsigned char * __RPC_USER  BSTR_UserUnmarshal(unsigned long *, unsigned char *, BSTR * );
void                      __RPC_USER  BSTR_UserFree(     unsigned long *, BSTR * );

/* end of Additional Prototypes */

#ifdef __cplusplus
}
#endif

#endif


================================================
FILE: Cpp/JAB.h
================================================
#include "stdafx.h"
#include "cpp.h"

//_________________________________________________________________

namespace jab {

	//From jni.h

	typedef long jint;
	typedef __int64 jlong;
	typedef signed char jbyte;
	typedef unsigned char   jboolean;
	typedef unsigned short  jchar;
	typedef short           jshort;
	typedef float           jfloat;
	typedef double          jdouble;
	typedef int            jsize;

	//_________________________________________________________________

	//From AccessBridgePackages.h

	typedef __int64 JObject;

#define MAX_BUFFER_SIZE   10240
#define MAX_STRING_SIZE   1024
#define SHORT_STRING_SIZE   256

	// object types
	typedef JObject AccessibleContext;
	typedef JObject AccessibleText;
	typedef JObject AccessibleValue;
	typedef JObject AccessibleSelection;


	/**
	 ******************************************************
	 *  optional AccessibleContext interfaces
	 *
	 * This version of the bridge reuses the accessibleValue
	 * field in the AccessibleContextInfo struct to represent
	 * additional optional interfaces that are supported by
	 * the Java AccessibleContext.  This is backwardly compatable
	 * because the old accessibleValue was set to the BOOL
	 * value TRUE (i.e., 1) if the AccessibleValue interface is
	 * supported.
	 ******************************************************
	 */

#define cAccessibleValueInterface (jlong) 1             // 1 << 1 (TRUE)
	 //#define cAccessibleActionInterface (jlong) 2            // 1 << 2
	 //#define cAccessibleComponentInterface (jlong) 4         // 1 << 3
	 //#define cAccessibleSelectionInterface (jlong) 8         // 1 << 4
	 //#define cAccessibleTableInterface (jlong) 16            // 1 << 5
	 //#define cAccessibleTextInterface (jlong) 32             // 1 << 6
	 //#define cAccessibleHypertextInterface (jlong) 64        // 1 << 7


	typedef struct AccessibleContextInfoTag {
		wchar_t name[MAX_STRING_SIZE];          // the AccessibleName of the object
		wchar_t description[MAX_STRING_SIZE];   // the AccessibleDescription of the object

		wchar_t role[SHORT_STRING_SIZE];        // localized AccesibleRole string
		wchar_t role_en_US[SHORT_STRING_SIZE];  // AccesibleRole string in the en_US locale
		wchar_t states[SHORT_STRING_SIZE];      // localized AccesibleStateSet string (comma separated)
		wchar_t states_en_US[SHORT_STRING_SIZE]; // AccesibleStateSet string in the en_US locale (comma separated)

		int indexInParent;                     // index of object in parent
		int childrenCount;                     // # of children, if any

		int x;                                 // screen coords in pixels
		int y;                                 // "
		int width;                             // pixel width of object
		int height;                            // pixel height of object

		BOOL accessibleComponent;               // flags for various additional
		BOOL accessibleAction;                  //  Java Accessibility interfaces
		BOOL accessibleSelection;               //  FALSE if this object doesn't
		BOOL accessibleText;                    //  implement the additional interface
		//  in question

		BOOL accessibleInterfaces;              // bitfield containing additional interface flags

	} AccessibleContextInfo;

	// AccessibleText packages
	typedef struct AccessibleTextInfoTag {
		int charCount;                 // # of characters in this text object
		int caretIndex;                // index of caret
		int indexAtPoint;              // index at the passsed in point
	} AccessibleTextInfo;

#define MAX_ACTION_INFO 256
#define MAX_ACTIONS_TO_DO 32

	// an action assocated with a component
	typedef struct AccessibleActionInfoTag {
		wchar_t name[SHORT_STRING_SIZE];        // action name
	} AccessibleActionInfo;

	// all of the actions associated with a component
	typedef struct AccessibleActionsTag {
		int actionsCount;              // number of actions
		AccessibleActionInfo actionInfo[MAX_ACTION_INFO];       // the action information
	} AccessibleActions;

	// list of AccessibleActions to do
	typedef struct AccessibleActionsToDoTag {
		int actionsCount;                              // number of actions to do
		AccessibleActionInfo actions[MAX_ACTIONS_TO_DO];// the accessible actions to do
	} AccessibleActionsToDo;

#define MAX_VISIBLE_CHILDREN 256

	// visible children information
	typedef struct VisibleChildenInfoTag {
		int returnedChildrenCount; // number of children returned
		AccessibleContext children[MAX_VISIBLE_CHILDREN]; // the visible children
	} VisibleChildrenInfo;


	//_________________________________________________________________

	//From AccessBridgeCalls.h

	//Loads Java Access Bridge (JAB) dll and functions. Then you can call the functions.
	struct _JApi {

		void(*Windows_run) ();

		//BOOL (*isJavaWindow) (HWND window); //very slow, and need to load dll etc

		void(*releaseJavaObject) (long vmID, JObject object);

		BOOL(*isSameObject) (long vmID, JObject obj1, JObject obj2);

		BOOL(*getAccessibleContextFromHWND) (HWND window, long* vmID, AccessibleContext* ac);

		HWND(*getHWNDFromAccessibleContext) (long vmID, AccessibleContext ac);

		BOOL(*getAccessibleContextAt) (long vmID, AccessibleContext acParent, jint x, jint y, AccessibleContext* ac);

		BOOL(*getAccessibleContextWithFocus) (HWND window, long* vmID, AccessibleContext* ac);

		BOOL(*getAccessibleContextInfo) (long vmID, AccessibleContext ac, AccessibleContextInfo* info);

		AccessibleContext(*getAccessibleChildFromContext) (long vmID, AccessibleContext ac, jint i);

		AccessibleContext(*getAccessibleParentFromContext) (long vmID, AccessibleContext ac);

		BOOL(*getAccessibleActions)(long vmID, AccessibleContext accessibleContext, AccessibleActions* actions);

		BOOL(*doAccessibleActions)(long vmID, AccessibleContext accessibleContext, AccessibleActionsToDo* actionsToDo, jint* failure);

		BOOL(*getAccessibleTextInfo) (long vmID, AccessibleText at, AccessibleTextInfo* textInfo, jint x, jint y);

		BOOL(*getAccessibleTextRange) (long vmID, AccessibleText at, jint start, jint end, wchar_t* text, short len);

		BOOL(*getCurrentAccessibleValueFromContext) (long vmID, AccessibleValue av, wchar_t* value, short len);

		void(*addAccessibleSelectionFromContext) (long vmID, AccessibleSelection as, int i);

		void(*clearAccessibleSelectionFromContext) (long vmID, AccessibleSelection as);

		void(*removeAccessibleSelectionFromContext) (long vmID, AccessibleSelection as, int i);

		BOOL(*setTextContents) (const long vmID, const AccessibleContext ac, const wchar_t* text);

		BOOL(*getVirtualAccessibleName) (const long vmID, const AccessibleContext accessibleContext, wchar_t* name, int len);

		BOOL(*requestFocus) (const long vmID, const AccessibleContext accessibleContext);

		//AccessibleContext(*getTopLevelObject) (const long vmID, const AccessibleContext ac);

		//AccessibleContext(*getParentWithRole) (const long vmID, const AccessibleContext ac, const wchar_t* role);

		//AccessibleContext(*getParentWithRoleElseRoot) (const long vmID, const AccessibleContext ac, const wchar_t* role);

		//AccessibleContext(*getActiveDescendent) (const long vmID, const AccessibleContext ac); //does not work

		//int (*getVisibleChildrenCount) (const long vmID, const AccessibleContext accessibleContext);

		//BOOL(*getVisibleChildren) (const long vmID, const AccessibleContext accessibleContext, const int startIndex, VisibleChildrenInfo* children); //slow

	private:
		HMODULE _hmodule;
		bool _isLoaded;
	public:

		_JApi() noexcept { ZEROTHIS; }

		~_JApi() {
			_isLoaded = false;
			if (_hmodule) {
				FreeLibrary(_hmodule);
				_hmodule = 0;
			}
		}

		bool IsLoaded() { return _isLoaded; }

		void Load() {
			if (_isLoaded) return;
			if (osVer.is32BitOS()) return; //don't support 32-bit OS. Then JObject etc is 32-bit. Too much work for the dying platform.
			STR dllName = L"WindowsAccessBridge-"
#ifdef _WIN64
				L"64.dll";
#else
				L"32.dll";
#endif
			HMODULE hm = LoadLibraryW(dllName);
			if (hm == 0) {
				PRINTF(L"failed LoadLibrary: %s", dllName);
				return;
			}
			_hmodule = hm;
#define JF(f) *(FARPROC*)&f=GetProcAddress(hm, #f)
			JF(Windows_run);
			JF(releaseJavaObject);
			JF(isSameObject);
			JF(getAccessibleContextFromHWND);
			JF(getHWNDFromAccessibleContext);
			JF(getAccessibleContextAt);
			JF(getAccessibleContextWithFocus);
			JF(getAccessibleContextInfo);
			JF(getAccessibleChildFromContext);
			JF(getAccessibleParentFromContext);
			JF(getAccessibleActions);
			JF(doAccessibleActions);
			JF(getAccessibleTextInfo);
			JF(getAccessibleTextRange);
			JF(getCurrentAccessibleValueFromContext);
			JF(addAccessibleSelectionFromContext);
			JF(clearAccessibleSelectionFromContext);
			JF(removeAccessibleSelectionFromContext);
			JF(setTextContents);
			JF(getVirtualAccessibleName);
			JF(requestFocus);
			//JF(getTopLevelObject);
			//JF(getParentWithRole);
			//JF(getParentWithRoleElseRoot);
			//JF(getActiveDescendent);
			//JF(getVisibleChildrenCount);
			//JF(getVisibleChildren);

			for (FARPROC* p = (FARPROC*)&Windows_run, *pe = (FARPROC*)&_hmodule; p < pe; p++) if (*p == null) {
				PRINTS(L"Some JAB functions not found");
				return;
			}

			_isLoaded = true;
		}

	};

} //namespace jab


================================================
FILE: Cpp/MemoryPool.cpp
================================================
//https://github.com/DevShiftTeam/AppShift-MemoryPool
//Don't need modifications. Just set to not use precompiled headers for this file.
//Speed: in Release config almost as fast as using stack memory or a most primitive thread-local memory block.

/**
 * AppShift Memory Pool v2.0.0
 *
 * Copyright 2020-present Sapir Shemer, DevShift (devshift.biz)
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *  http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * @author Sapir Shemer
 */

#include "MemoryPool.h"
#include <iostream>

AppShift::Memory::MemoryPool::MemoryPool(size_t block_size)
{
	// Add first block to memory pool
	this->firstBlock = this->currentBlock = nullptr;
	this->defaultBlockSize = block_size;
	this->currentScope = nullptr;
	this->createMemoryBlock(block_size);
}

AppShift::Memory::MemoryPool::~MemoryPool() {
    SMemoryBlockHeader* block_iterator = firstBlock;

    while (block_iterator != nullptr) {
        SMemoryBlockHeader* next_iterator = block_iterator->next;
        std::free(block_iterator);
        block_iterator = next_iterator;
    }
}

void AppShift::Memory::MemoryPool::createMemoryBlock(size_t block_size)
{
	// Create the block
	SMemoryBlockHeader* block = reinterpret_cast<SMemoryBlockHeader*>(std::malloc(sizeof(SMemoryBlockHeader) + block_size));
	if (block == NULL) throw EMemoryErrors::CANNOT_CREATE_BLOCK;

	// Initalize block data
	block->blockSize = block_size;
	block->offset = 0;
	block->numberOfAllocated = 0;
	block->numberOfDeleted = 0;

	if (this->firstBlock != nullptr) {
		block->next = nullptr;
		block->prev = this->currentBlock;
		this->currentBlock->next = block;
		this->currentBlock = block;
	}
	else {
		block->next = block->prev = nullptr;
		this->firstBlock = block;
		this->currentBlock = block;
	}
}

void* AppShift::Memory::MemoryPool::allocate(size_t size)
{
	// If there is enough space in current block then use the current block
	if (size + sizeof(SMemoryUnitHeader) < this->currentBlock->blockSize - this->currentBlock->offset);
	// Create new block if not enough space
	else if (size + sizeof(SMemoryUnitHeader) >= this->defaultBlockSize) this->createMemoryBlock(size + sizeof(SMemoryUnitHeader));
	else this->createMemoryBlock(this->defaultBlockSize);

	// Add unit
	SMemoryUnitHeader* unit = reinterpret_cast<SMemoryUnitHeader*>(reinterpret_cast<char*>(this->currentBlock) + sizeof(SMemoryBlockHeader) + this->currentBlock->offset);
	unit->length = size;
	unit->container = this->currentBlock;
	this->currentBlock->numberOfAllocated++;
	this->currentBlock->offset += sizeof(SMemoryUnitHeader) + size;

	return reinterpret_cast<char*>(unit) + sizeof(SMemoryUnitHeader);
}

void* AppShift::Memory::MemoryPool::reallocate(void* unit_pointer_start, size_t new_size)
{
	if (unit_pointer_start == NULL) return nullptr;

	// Find unit
	SMemoryUnitHeader* unit = reinterpret_cast<SMemoryUnitHeader*>(reinterpret_cast<char*>(unit_pointer_start) - sizeof(SMemoryUnitHeader));
	SMemoryBlockHeader* block = unit->container;

	// If last in block && enough space in block, then reset length
	if (reinterpret_cast<char*>(block) + sizeof(SMemoryBlockHeader) + block->offset == reinterpret_cast<char*>(unit) + sizeof(SMemoryUnitHeader) + unit->length
		&& block->blockSize > block->offset + new_size - unit->length) {
		block->offset += new_size - unit->length;
		unit->length = new_size;

		return unit_pointer_start;
	}

	// Allocate new and free previous
	void* temp_point = this->allocate(new_size);
	std::memcpy(temp_point, unit_pointer_start, unit->length);
	this->free(unit_pointer_start);

	return temp_point;
}

void AppShift::Memory::MemoryPool::free(void* unit_pointer_start)
{
	if (unit_pointer_start == nullptr) return;

	// Find unit
	SMemoryUnitHeader* unit = reinterpret_cast<SMemoryUnitHeader*>(reinterpret_cast<char*>(unit_pointer_start) - sizeof(SMemoryUnitHeader));
	SMemoryBlockHeader* block = unit->container;

	// If last in block, then reset offset
	if (reinterpret_cast<char*>(block) + sizeof(SMemoryBlockHeader) + block->offset == reinterpret_cast<char*>(unit) + sizeof(SMemoryUnitHeader) + unit->length) {
		block->offset -= sizeof(SMemoryUnitHeader) + unit->length;
		block->numberOfAllocated--;
	}
	else block->numberOfDeleted++;

	// If block offset is 0 remove block if not the only one left
	if (this->currentBlock != this->firstBlock && (block->offset == 0 || block->numberOfAllocated == block->numberOfDeleted)) {
		if (block == this->firstBlock) {
			this->firstBlock = block->next;
			this->firstBlock->prev = nullptr;
		}
		else if (block == this->currentBlock) {
			this->currentBlock = block->prev;
			this->currentBlock->next = nullptr;
		}
		else {
			block->prev->next = block->next;
			block->next->prev = block->prev;
		}
		std::free(block);
	}
}


void AppShift::Memory::MemoryPool::dumpPoolData()
{
	SMemoryBlockHeader* block = this->firstBlock;
	SMemoryUnitHeader* unit;

	size_t current_unit_offset;
	size_t block_counter = 1;
	size_t unit_counter = 1;

	while (block != nullptr) {
		// Dump block data
		std::cout << "Block " << block_counter << ": " << std::endl;
		std::cout << "\t" << "Used: " << (float)(block->offset) / (float)(block->blockSize) * 100 << "% " << "(" << block->offset << "/" << block->blockSize << ")" << std::endl;

		if (block->offset == 0) {
			block = block->next;
			block_counter++;
			continue;
		}

		std::cout << "\t" << "Units: ========================" << std::endl;
		current_unit_offset = 0;
		unit_counter = 1;
		while (current_unit_offset < block->offset) {
			unit = reinterpret_cast<SMemoryUnitHeader*>(reinterpret_cast<char*>(block + 1) + current_unit_offset);
			std::cout << "\t\t" << "Unit " << unit_counter << ": " << unit->length + sizeof(SMemoryUnitHeader) << std::endl;
			current_unit_offset += sizeof(SMemoryUnitHeader) + unit->length;
			unit_counter++;
		}

		std::cout << "\t" << "===============================" << std::endl;

		block = block->next;
		block_counter++;
	}
}

void AppShift::Memory::MemoryPool::startScope()
{
	// Create new scope, on top of previous if exists
	if (this->currentScope == nullptr) {
		this->currentScope = new (this) SMemoryScopeHeader;
		this->currentScope->prevScope = nullptr;
	}
	else {
		SMemoryScopeHeader* new_scope = new (this) SMemoryScopeHeader;
		new_scope->prevScope = this->currentScope;
		this->currentScope = new_scope;
	}

	// Simply load the current offset & block to return to when scope ends
	this->currentScope->scopeOffset = this->currentBlock->offset - sizeof(SMemoryScopeHeader) - sizeof(SMemoryUnitHeader);
	this->currentScope->firstScopeBlock = this->currentBlock;
}

void AppShift::Memory::MemoryPool::endScope()
{
	// Free all blocks until the start of scope
	while (this->currentBlock != this->currentScope->firstScopeBlock) {
		this->currentBlock = this->currentBlock->prev;
		std::free(this->currentBlock->next);
		this->currentBlock->next = nullptr;
	}

	this->currentBlock->offset = this->currentScope->scopeOffset;
}

void* operator new(size_t size, AppShift::Memory::MemoryPool* mp) {
	return mp->allocate(size);
}

void* operator new[](size_t size, AppShift::Memory::MemoryPool* mp) {
	return mp->allocate(size);
}


================================================
FILE: Cpp/MemoryPool.h
================================================
/**
 * AppShift Memory Pool v2.0.0
 *
 * Copyright 2020-present Sapir Shemer, DevShift (devshift.biz)
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *  http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * @author Sapir Shemer
 */
#pragma once
#define MEMORYPOOL_DEFAULT_BLOCK_SIZE 1024 * 1024

#include <stdlib.h>
#include <cstring>
#include <cstddef>
#include <memory>

namespace AppShift::Memory {
	// Simple error collection for memory pool
    enum class EMemoryErrors {
        CANNOT_CREATE_MEMORY_POOL,
        CANNOT_CREATE_BLOCK,
        OUT_OF_POOL,
        EXCEEDS_MAX_SIZE,
        CANNOT_CREATE_BLOCK_CHAIN
    };

    // Header for a single memory block
    struct SMemoryBlockHeader {
        // Block data
        size_t blockSize;
        size_t offset;

        // Movement to other blocks
        SMemoryBlockHeader* next;
        SMemoryBlockHeader* prev;

        // Garbage management data
        size_t numberOfAllocated;
        size_t numberOfDeleted;
    };

    // Header of a memory unit in the pool holding important metadata
    struct SMemoryUnitHeader {
        size_t length;
        SMemoryBlockHeader* container;
    };

    // Header for a scope in memory
    struct SMemoryScopeHeader {
        size_t scopeOffset;
        SMemoryBlockHeader* firstScopeBlock;
        SMemoryScopeHeader* prevScope;
    };

	class MemoryPool {
	public:
		/**
		 * Creates a memory pool structure and initializes it
		 * 
		 * @param size_t block_size Defines the default size of a block in the pool, by default uses MEMORYPOOL_DEFAULT_BLOCK_SIZE
		 */
		MemoryPool(size_t block_size = MEMORYPOOL_DEFAULT_BLOCK_SIZE);
		// Destructor
		~MemoryPool();

        // Data about the memory pool blocks
        SMemoryBlockHeader* firstBlock;
        SMemoryBlockHeader* currentBlock;
        size_t defaultBlockSize;

        // Data about memory scopes
        SMemoryScopeHeader* currentScope;

		/**
		 * Create a new standalone memory block unattached to any memory pool
		 * 
		 * @param size_t block_size Defines the default size of a block in the pool, by default uses MEMORYPOOL_DEFAULT_BLOCK_SIZE
		 * 
		 * @returns SMemoryBlockHeader* Pointer to the header of the memory block
		 */
		void createMemoryBlock(size_t block_size = MEMORYPOOL_DEFAULT_BLOCK_SIZE);

		/**
		 * Allocates memory in a pool
		 *
		 * @param MemoryPool* mp Memory pool to allocate memory in
		 * @param size_t size Size to allocate in memory pool
		 *
		 * @returns void* Pointer to the newly allocate space
		 */
		void* allocate(size_t size);

		// Templated allocation
		template<typename T>
		T* allocate(size_t instances);

		/**
		 * Re-allocates memory in a pool
		 *
		 * @param void* unit_pointer_start Pointer to the object to re-allocate
		 * @param size_t new_size New size to allocate in memory pool
		 *
		 * @returns void* Pointer to the newly allocate space
		 */
		void* reallocate(void* unit_pointer_start, size_t new_size);

		// Templated re-allocation
		template<typename T>
		T* reallocate(T* unit_pointer_start, size_t new_size);

		/**
		 * Frees memory in a pool
		 *
		 * @param void* unit_pointer_start Pointer to the object to free
		 */
		void free(void* unit_pointer_start);

		/**
		 * Dump memory pool meta data of blocks unit to stream. 
		 * Might be useful for debugging and analyzing memory usage
		 * 
		 * @param MemoryPool* mp Memory pool to dump data from
		 */
		void dumpPoolData();

		/**
		 * Start a scope in the memory pool.
		 * All the allocations between startScope and andScope will be freed.
		 * It is a very efficient way to free multiple allocations
		 * 
		 * @param MemoryPool* mp Memory pool to start the scope in
		 */
		void startScope();

		/**
		 * 
		 */
		void endScope();
	};

	template<typename T>
	inline T* MemoryPool::allocate(size_t instances) {
		return reinterpret_cast<T*>(this->allocate(instances * sizeof(T)));
	}

	template<typename T>
	inline T* MemoryPool::reallocate(T* unit_pointer_start, size_t instances) {
		return reinterpret_cast<T*>(this->reallocate(reinterpret_cast<void*>(unit_pointer_start), instances * sizeof(T)));
	}
}

// Override new operators to create with memory pool
extern void* operator new(size_t size, AppShift::Memory::MemoryPool* mp);
extern void* operator new[](size_t size, AppShift::Memory::MemoryPool* mp);

================================================
FILE: Cpp/Util.cpp
================================================
#include "stdafx.h"
#include "cpp.h"

#pragma region print

HWND s_QM2;

#if TRACE

void Print(STR s) {
#if true
	if (!IsWindow(s_QM2)) {
		s_QM2 = wn::FindWnd(L"QM_Editor", 0); if (!s_QM2) return;
	}
	//SendMessageW(s_QM2, WM_SETTEXT, -1, (LPARAM)(s ? s : L""));
	DWORD_PTR res;
	SendMessageTimeoutW(s_QM2, WM_SETTEXT, -1, (LPARAM)(s ? s : L""), SMTO_BLOCK | SMTO_ABORTIFHUNG, 5000, &res);
#else
	_cputws(s);
	_cputws(L"\r\n");
#endif
}

void Printf(const wchar_t* frm, ...) {
	wchar_t b[10000];
	va_list args;
	va_start(args, frm);
	_vsnwprintf(b, 9990, frm, args);
	va_end(args);
	Print(b);
}

#endif

#pragma endregion


#if TRACE

void Perf_Inst::First() {
	QueryPerformanceCounter((LARGE_INTEGER*)&_time0);
	_counter = 0;
	_nMeasurements++;
}

void Perf_Inst::Next(char cMark/* = '\0'*/) {
	int n = _counter; if (n >= _nElem) return;
	_counter++;
	__int64 t; QueryPerformanceCounter((LARGE_INTEGER*)&t);
	t -= _time0;
	if (_incremental) _a[n] += t; else _a[n] = t;
	_aMark[n] = cMark;
}

void Perf_Inst::Write() {
	int i, n = _counter;
	if (n == 0) return;
	if (n > _nElem) n = _nElem;
	__int64 f; QueryPerformanceFrequency((LARGE_INTEGER*)&f); double freq = 1000000.0 / f;
	bool average = false; int nMeasurements = 1;

	str::StringBuilder s;
	s << L"speed:";
g1:
	double t = 0.0, tPrev = 0.0;
	for (i = 0; i < n; i++) {
		s << L"  ";
		if (_aMark[i] != '\0') {
			s << _aMark[i];
			s << '=';
		}
		t = freq * _a[i];
		double d = t - tPrev;
		if (average) d /= nMeasurements;
		s << (__int64)d;
		tPrev = t;
	}

	if (n > 1) {
		s << L"  (";
		if (average) t /= nMeasurements;
		s << (__int64)t;
		s << ')';
	}

	if (!average && _incremental && (nMeasurements = _nMeasurements) > 1) {
		average = true;
		s << L";  measured "; s << nMeasurements; s << L" times, average";
		goto g1;
	}

	Print(s);
}

#pragma section(".shared", read,write,shared)
__declspec(allocate(".shared")) Perf_Inst Perf;

#endif

OSVersion osVer;
DelayLoadedApi dlapi;

//returns: 0 failed, 1 x86, 2 x64, 3 arm64
EXPORT int Cpp_GetProcessArchitecture(DWORD pid) {
	if (osVer.is32BitOS()) return 1;

	HANDLE hp = OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION, false, pid);
	if (!hp) return 0;

	if (osVer.minWin11()) {
		PROCESS_MACHINE_INFORMATION m = {}; //Win11+
		bool ok = dlapi.GetProcessInformation(hp, ProcessMachineTypeInfo, &m, sizeof(m));
		CloseHandle(hp);
		if (!ok) return 0;
		//Printf(L"m.ProcessMachine=0x%X", m.ProcessMachine);
		auto k = m.ProcessMachine;
		return k == IMAGE_FILE_MACHINE_I386 ? 1 : k == IMAGE_FILE_MACHINE_AMD64 ? 2 : k == IMAGE_FILE_MACHINE_ARM64 ? 3 : 0;
	} else if(dlapi.IsWow64Process2) {
		//never mind: not tested on Win10 ARM64.

		USHORT processArch = 0, osArch = 0;
		BOOL ok = dlapi.IsWow64Process2(hp, &processArch, &osArch);
		CloseHandle(hp);
		if (!ok) return 0;
		return processArch != 0 ? 1 : osArch == IMAGE_FILE_MACHINE_ARM64 ? 3 : 2; //3 on ARM64 OS because Windows 10 ARM64 does not support x64 processes
	} else {
		BOOL is32, ok = IsWow64Process(hp, &is32);
		CloseHandle(hp);
		if (!ok) return 0;
		return is32 ? 1 : 2;
	}
}

namespace wn {
	bool ClassName(HWND w, out Bstr& s) {
		WCHAR b[260];
		int n = GetClassNameW(w, b, 260);
		if (n == 0) {
			if (s) s.Empty();
			return false;
		}
		s.Assign(b, n);
		return true;
	}

	int ClassNameIs(HWND w, std::initializer_list<STR> a) {
		WCHAR b[260];
		int n = GetClassNameW(w, b, 260);
		if (n == 0) return 0;
		int i = 1;
		for (const STR* p = a.begin(); p < a.end(); p++, i++) if (str::Like(b, n, *p, wcslen(*p), true)) return i;
		return 0;
	}

	bool ClassNameIs(HWND w, STR s) {
		WCHAR b[260];
		int n = GetClassNameW(w, b, 260);
		return n > 0 && str::Like(b, n, s, wcslen(s), true);
	}

	bool ClassNameIs(HWND w, const str::Wildex& s) {
		WCHAR b[260];
		int n = GetClassNameW(w, b, 260);
		return n > 0 && s.Match(b, n);
	}

	bool Name(HWND w, out Bstr& s) {
		bool R = false;
		if (w) {
			Buffer<WCHAR, 1000> m;
			for (int na = 1000; na <= 10'000'000; na *= 10) {
				int nr = InternalGetWindowText(w, m.Alloc(na), na);
				if (nr < na - 1) {
					if (nr > 0) {
						s.Assign(m, nr);
						return true;
					}
					R = GetLastError() != 0;
					break;
				}
			}
		}
		if (s) s.Empty();
		return R;
	}

	//Like IsWindowVisible, but does not check wTL visibility.
	//Slower, but does not make EnumChildWindows significantly slower. Eg 550 -> 570-590 mcs.
	bool IsVisibleInWindow(HWND c, HWND wTL) {
		if (IsWindowVisible(c)) return true; //these two make faster in most cases (when wTL is visible)
		if (IsWindowVisible(wTL)) return false;
		int i;
		for (i = 0; i < 10000; i++) {
			//PrintWnd(c);
			if (!(wn::Style(c) & WS_VISIBLE)) return false;
			c = (HWND)(LPARAM)GetWindowLongPtrW(c, GWLP_HWNDPARENT);
			if (c == wTL) return true;
			if (c == 0) break;
		}
		assert(false);
		return false;
	}

	BOOL EnumChildWindows(HWND w, WNDENUMPROCL& callback) {
		return ::EnumChildWindows(w, [](HWND c, LPARAM p) { return (BOOL)(*(WNDENUMPROCL*)p)(c); }, (LPARAM)&callback);
	}

	//className - wildcard.
	HWND FindChildByClassName(HWND w, STR className, bool visible) {
		HWND R = 0;
		wn::EnumChildWindows(w, [&R, className, visible, w](HWND c) {
			if (visible && !IsVisibleInWindow(c, w)) return 1;
			if (!wn::ClassNameIs(c, className)) return 1;
			R = c;
			return 0;
			});
		return R;
	}

	HWND FindChildByClassName(HWND w, STR className1, STR className2, OUT bool& second, bool visible) {
		HWND R = 0;
		wn::EnumChildWindows(w, [&R, className1, className2, &second, visible, w](HWND c) {
			if (visible && !IsVisibleInWindow(c, w)) return 1;
			int i = wn::ClassNameIs(c, { className1, className2 });
			if (i == 0) return 1;
			second = i == 2;
			R = c;
			return 0;
			});
		return R;
	}

	HWND FindWndEx(HWND wParent, HWND wAfter, STR cn, STR name) {
		//see comments in Api.FindWindowEx.
		//never mind: should repeat only on Win11. Anyway I guess MS soon will fix it.
		for (int i = 5; --i >= 0;) {
			HWND w = ::FindWindowEx(wParent, wAfter, cn, name);
			if (w) return w;
		}
		return 0;
	}

	HWND FindWnd(STR cn, STR name) {
		return FindWndEx(0, 0, cn, name);
	}

	HWND FindWndExVisible(HWND wParent, STR cn) {
		HWND c = FindWndEx(wParent, 0, cn, null);
		while (c && !IsWindowVisible(c)) c = FindWndEx(wParent, c, cn, null);
		return c;
	}

	bool WinformsNameIs(HWND w, STR name) {
		static UINT WM_GETCONTROLNAME = RegisterWindowMessageW(L"WM_GETCONTROLNAME");
		const int c_bufChars = 1024;

		DWORD pid; if (0 == GetWindowThreadProcessId(w, &pid)) return false;
		wchar_t b[c_bufChars]; int len;
		if (pid == GetCurrentProcessId()) {
			len = (int)SendMessageW(w, WM_GETCONTROLNAME, c_bufChars, (LPARAM)b) - 1; if (len < 0) return false;
		} else {
			HANDLE hp = OpenProcess(PROCESS_VM_OPERATION | PROCESS_VM_READ, false, pid); if (!hp) return false;
			void* pm = VirtualAllocEx(hp, null, c_bufChars * 2, MEM_RESERVE | MEM_COMMIT, PAGE_EXECUTE_READWRITE);
			__try {
				if (pm == null) return false;
				DWORD_PTR n1; if (!SendMessageTimeoutW(w, WM_GETCONTROLNAME, c_bufChars, (LPARAM)pm, SMTO_ABORTIFHUNG, 10000, &n1) || --n1 < 0) return false;
				len = (int)n1; n1 *= 2;
				SIZE_T n2; if (n1 > 0 && !(ReadProcessMemory(hp, pm, b, n1, &n2) && n2 == n1)) return false;
			}
			__finally {
				if (pm != null) VirtualFreeEx(hp, pm, 0, MEM_RELEASE);
				CloseHandle(hp);
			}
		}
		//b[len] = 0; Print(len); Print(b);
		return str::Equals(name, str::Len(name), b, len);

		//note: don't need to cache the process handle and memory. It is several times faster than sendmessage. Anyway, inproc is rarely used with acc.
		//info: also there is WM_GETCONTROLTYPE, like "PaintDotNet.Controls.AppWorkspace, PaintDotNet, Version=4.21.6589.7045, Culture=neutral, PublicKeyToken=null"
	}

#if TRACE
	void PrintWnd(HWND w) {
		Bstr sc, sn;
		if (!w) {
			Print(L"<0 HWND>");
		} else if (!ClassName(w, out sc)) {
			Print(L"<invalid HWND>");
		} else {
			Name(w, out sn);
			RECT r = {}; GetWindowRect(w, &r);
			STR inv = IsWindowVisible(w) ? L"" : L" invisible";
			DWORD style = (DWORD)GetWindowLong(w, GWL_STYLE);
			Printf(L"%i %s \"%s\" {L=%i T=%i W=%i H=%i}%s style=0x%X",
				(int)(LPARAM)w, sc, sn, r.left, r.top, r.right - r.left, r.bottom - r.top, inv, style);
		}
	}
#endif
}

//Gets pointer to other interface through iserviceprovider.
//Use guidService if it is different than iid.
bool QueryService_(IUnknown* iFrom, OUT void** iTo, REFIID iid, const GUID* guidService/*=null*/) {
	*iTo = null;
	if (!guidService) guidService = &iid;
	Smart<IServiceProvider> sp;
	return 0 == iFrom->QueryInterface(&sp) && 0 == sp->QueryService(*guidService, iid, iTo) && *iTo;
}

//void DoEvents()
//{
//	MSG m;
//	while(PeekMessageW(&m, 0, 0, 0, PM_REMOVE)) {
//		//while(PeekMessageW(&m, 0, 0, 0, PM_REMOVE| PM_QS_SENDMESSAGE)) { //does not work
//		//Print(m.message);
//		//Bstr s; if(wn::ClassName(m.hwnd, s)) Print(s);
//		if(m.message == WM_QUIT) { PostQuitMessage((int)m.wParam); return; }
//		TranslateMessage(&m);
//		DispatchMessageW(&m);
//	}
//}
//
////void DoEvents2()
////{
////	DWORD signaledIndex;
////	auto hr = CoWaitForMultipleHandles(0, 0, 0, null, &signaledIndex); //fails, invalid parameter
////	Print((uint)hr);
////}
//
//void SleepDoEvents(int milliseconds)
//{
//	if(milliseconds == 0) { DoEvents(); return; }
//	for(;;) {
//		ULONGLONG t = 0;
//		int timeSlice = 100; //we call API in loop with small timeout to make it respond to Thread.Abort
//		if(milliseconds > 0) {
//			if(milliseconds < timeSlice) timeSlice = milliseconds;
//			t = GetTickCount64();
//		}
//
//		DWORD k = MsgWaitForMultipleObjectsEx(0, null, timeSlice, QS_ALLINPUT, MWMO_ALERTABLE);
//		//info: k can be 0 (message etc), WAIT_TIMEOUT, WAIT_IO_COMPLETION, WAIT_FAILED.
//		if(k == WAIT_FAILED) return; //unlikely, because not using handles
//		if(k == 0) DoEvents();
//
//		if(milliseconds > 0) {
//			milliseconds -= (int)(GetTickCount64() - t);
//			if(milliseconds <= 0) break;
//		}
//	}
//}


================================================
FILE: Cpp/acc bridge.cpp
================================================
#include "stdafx.h"
#include "cpp.h"
#include "acc.h"

HRESULT AccFind(AccFindCallback& callback, HWND w, Cpp_Acc* aParent, const Cpp_AccFindParams& ap, out BSTR& errStr);
HRESULT AccFromPoint(POINT p, HWND wFP, eXYFlags flags, eSpecWnd specWnd, out Cpp_Acc& aResult);
HRESULT AccGetFocused(HWND w, eFocusedFlags flags, out Cpp_Acc& aResult);
HRESULT AccNavigate(Cpp_Acc aFrom, STR navig, out Cpp_Acc& aResult);
HRESULT AccGetProp(Cpp_Acc a, WCHAR what, out BSTR& sResult);

namespace {

#pragma region marshal

	//Used for marshaling 'find AO' (IPA_AccFind) parameters when calling the get_accHelpTopic hook function.
	//A flat variable-size memory structure (strings follow the fixed-size part).
	struct MarshalParams_AccFind {
		struct _FlatStr { int offs, len; };

		MarshalParams_Header hdr;
		int hwnd; //not HWND, because it must be of same size in 32 and 64 bit process
		eAF2 flags2;
	private:
		//these are the same as Cpp_AccFindParams, except is used int instead of STR. Cannot use STR because its size can be 32 or 64 bit.
		_FlatStr _role, _name, _prop;
		eAF _flags;
		int _skip;
		WCHAR _resultProp;

		LPWSTR _SetString(STR s, int len, LPWSTR dest, out _FlatStr& r) {
			if (!s) {
				r.len = r.offs = 0;
				return dest;
			}
			memcpy(dest, s, len * 2); dest[len] = 0;
			r.offs = (int)(dest - (STR)this); r.len = len;
			return dest + len + 1;
		}

		STR _GetString(_FlatStr r, out int& len) {
			len = r.len;
			if (!r.offs) return null;
			return (STR)this + r.offs;
		}
	public:
		static int CalcMemSize(const Cpp_AccFindParams& ap) {
			return sizeof(MarshalParams_AccFind) + (ap.roleLength + ap.nameLength + ap.propLength + 3) * 2;
		}

		void Marshal(HWND w, const Cpp_AccFindParams& ap) {
			hwnd = (int)(LPARAM)w;

			auto s = (LPWSTR)(this + 1);
			s = _SetString(ap.role, ap.roleLength, s, out _role);
			s = _SetString(ap.name, ap.nameLength, s, out _name);
			s = _SetString(ap.prop, ap.propLength, s, out _prop);
			_flags = ap.flags;
			_skip = ap.skip;
			_resultProp = ap.resultProp;
			flags2 = ap.flags2;
		}

		void Unmarshal(out Cpp_AccFindParams& ap) {
			ap.role = _GetString(_role, out ap.roleLength);
			ap.name = _GetString(_name, out ap.nameLength);
			ap.prop = _GetString(_prop, out ap.propLength);
			ap.flags = _flags;
			ap.skip = _skip;
			ap.resultProp = _resultProp;
			ap.flags2 = flags2;
		}
	};

	static long s_accMarshalWrapperCount;

	//This is used as a workaround when CoMarshalInterface fails.
	//More comments in WriteAccToStream.
	class AccessibleMarshalWrapper : public IAccessible {
		IAccessible* _a;
	public:
		bool ignoreQI;

		AccessibleMarshalWrapper(IAccessible* a) {
			_a = a;
			ignoreQI = true;

			InterlockedIncrement(&s_accMarshalWrapperCount);
		}

		~AccessibleMarshalWrapper() {
			InterlockedDecrement(&s_accMarshalWrapperCount);
		}

		virtual STDMETHODIMP QueryInterface(REFIID riid, void** ppvObject) override {
			if (riid == IID_IAccessible || riid == IID_IUnknown || riid == IID_IDispatch) {
				_a->AddRef();
				*ppvObject = this;
				return 0;
				//Old Firefox bug: TEXT AOs return E_NOINTERFACE for IID_IUnknown, that is why CoMarshalInterface fails.
				//	Also they don't give custom IMarshal, although all other AOs do.
			}
			if (ignoreQI) { //don't give IMarshal and other interfaces while in CoMarshalInterface
				*ppvObject = null;
				return E_NOINTERFACE;
			}

			return _a->QueryInterface(riid, ppvObject);
		}
		virtual STDMETHODIMP_(ULONG) AddRef(void) override {
			return _a->AddRef();
		}
		virtual STDMETHODIMP_(ULONG) Release(void) override {
			auto r = _a->Release();
			//Print((int)r);
			if (r == 0) delete this;
			return r;
		}
#pragma region IAccessible
		virtual STDMETHODIMP GetTypeInfoCount(UINT* pctinfo) override {
			return E_NOTIMPL;
		}
		virtual STDMETHODIMP GetTypeInfo(UINT iTInfo, LCID lcid, ITypeInfo** ppTInfo) override {
			return E_NOTIMPL;
		}
		virtual STDMETHODIMP GetIDsOfNames(REFIID riid, LPOLESTR* rgszNames, UINT cNames, LCID lcid, DISPID* rgDispId) override {
			return E_NOTIMPL;
		}
		virtual STDMETHODIMP Invoke(DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS* pDispParams, VARIANT* pVarResult, EXCEPINFO* pExcepInfo, UINT* puArgErr) override {
			return E_NOTIMPL;
		}
		virtual STDMETHODIMP get_accParent(IDispatch** ppdispParent) override {
			return _a->get_accParent(ppdispParent);
		}
		virtual STDMETHODIMP get_accChildCount(long* pcountChildren) override {
			return _a->get_accChildCount(pcountChildren);
		}
		virtual STDMETHODIMP get_accChild(VARIANT varChild, IDispatch** ppdispChild) override {
			return _a->get_accChild(varChild, ppdispChild);
		}
		virtual STDMETHODIMP get_accName(VARIANT varChild, BSTR* pszName) override {
			return _a->get_accName(varChild, pszName);
		}
		virtual STDMETHODIMP get_accValue(VARIANT varChild, BSTR* pszValue) override {
			return _a->get_accValue(varChild, pszValue);
		}
		virtual STDMETHODIMP get_accDescription(VARIANT varChild, BSTR* pszDescription) override {
			return _a->get_accDescription(varChild, pszDescription);
		}
		virtual STDMETHODIMP get_accRole(VARIANT varChild, VARIANT* pvarRole) override {
			return _a->get_accRole(varChild, pvarRole);
		}
		virtual STDMETHODIMP get_accState(VARIANT varChild, VARIANT* pvarState) override {
			return _a->get_accState(varChild, pvarState);
		}
		virtual STDMETHODIMP get_accHelp(VARIANT varChild, BSTR* pszHelp) override {
			return _a->get_accHelp(varChild, pszHelp);
		}
		virtual STDMETHODIMP get_accHelpTopic(BSTR* pszHelpFile, VARIANT varChild, long* pidTopic) override {
			return E_NOTIMPL;
		}
		virtual STDMETHODIMP get_accKeyboardShortcut(VARIANT varChild, BSTR* pszKeyboardShortcut) override {
			return _a->get_accKeyboardShortcut(varChild, pszKeyboardShortcut);
		}
		virtual STDMETHODIMP get_accFocus(VARIANT* pvarChild) override {
			return _a->get_accFocus(pvarChild);
		}
		virtual STDMETHODIMP get_accSelection(VARIANT* pvarChildren) override {
			return _a->get_accSelection(pvarChildren);
		}
		virtual STDMETHODIMP get_accDefaultAction(VARIANT varChild, BSTR* pszDefaultAction) override {
			return _a->get_accDefaultAction(varChild, pszDefaultAction);
		}
		virtual STDMETHODIMP accSelect(long flagsSelect, VARIANT varChild) override {
			return _a->accSelect(flagsSelect, varChild);
		}
		virtual STDMETHODIMP accLocation(long* pxLeft, long* pyTop, long* pcxWidth, long* pcyHeight, VARIANT varChild) override {
			return _a->accLocation(pxLeft, pyTop, pcxWidth, pcyHeight, varChild);
		}
		virtual STDMETHODIMP accNavigate(long navDir, VARIANT varStart, VARIANT* pvarEndUpAt) override {
			return _a->accNavigate(navDir, varStart, pvarEndUpAt);
		}
		virtual STDMETHODIMP accHitTest(long xLeft, long yTop, VARIANT* pvarChild) override {
			return _a->accHitTest(xLeft, yTop, pvarChild);
		}
		virtual STDMETHODIMP accDoDefaultAction(VARIANT varChild) override {
			return _a->accDoDefaultAction(varChild);
		}
		virtual STDMETHODIMP put_accName(VARIANT varChild, BSTR szName) override {
			return _a->put_accName(varChild, szName);
		}
		virtual STDMETHODIMP put_accValue(VARIANT varChild, BSTR szValue) override {
			return _a->put_accValue(varChild, szValue);
		}
#pragma endregion
	};

	//The BSTR returned by our get_accHelpTopic hook contains data of one or more accessible objects (AO).
	//	Each AO data can have IAccessible object data (created by CoMarshalInterface), child element id, level, role, rect.
	//	These flags tell what is in the data.
	//[Flags]
	enum class eAccResult {
		Elem = 1,
		Role = 2,
		Level = 4,
		Rect = 8,
		UsePrevAcc = 0x40,
		UsePrevLevel = 0x80,
	};
	ENABLE_BITMASK_OPERATORS(eAccResult);

	bool WriteAccToStream(ref Smart<IStream>& stream, Cpp_Acc a, Cpp_Acc* aPrev = null, RECT* rect = null) {
		eAccResult has = {};
		if (aPrev != null) {
			if (a.acc == aPrev->acc && a.elem != 0) has |= eAccResult::UsePrevAcc; else aPrev->acc = a.acc;
			if (a.misc.level != 0) has |= a.misc.level == aPrev->misc.level ? eAccResult::UsePrevLevel : eAccResult::Level;
			aPrev->misc.level = a.misc.level;
		} else {
			if (a.misc.level != 0) has |= eAccResult::Level;
		}
		if (a.elem != 0) has |= eAccResult::Elem;
		if (a.misc.roleByte != 0) has |= eAccResult::Role;
		if (rect != null) has |= eAccResult::Rect;

		if (0 != stream->Write(&has, 1, null)) return false;

		a.misc.flags |= eAccMiscFlags::InProc;

		if (!(has & eAccResult::UsePrevAcc)) {
			//problem: with some AO the hook is not called when we try to do something inproc, eg get all props.
			//	They use a custom IMarshal, which redirects to another (not hooked) IAccessible interface. In most cases it is even in another process.
			//	Known apps: 1. Old Firefox, when multiprocess not disabled. 2. Some hidden AO in IE. 3. Windows store apps, but we don't use inproc.
			//	Known apps where is custom IMarshal but the hook works: 1. Task Scheduler MMC: controls of other process.
			//	Workarounds:
			//		Tested, fails: replace CoMarshalInterface with CoGetStandardMarshal/MarshalInterface. Chrome works, old Firefox crashes.
			//		Old, rejected: remove InProc flag. But with some old Firefox versions then all AOs are not inproc.
			//		Now using: wrap the AO in AccessibleMarshalWrapper and marshal it instead.
			HRESULT hr = 1;
			IMarshal* m = null;
			if (0 == a.acc->QueryInterface(&m)) m->Release();
			else hr = CoMarshalInterface(stream, IID_IAccessible, a.acc, MSHCTX_LOCAL, null, MSHLFLAGS_NORMAL);
			//ao::PrintAcc(a.acc, a.elem); Print((DWORD)hr);
			if (hr != 0) {
#if true
				HRESULT hr1 = hr;
				auto wrap = new AccessibleMarshalWrapper(a.acc);
				a.acc = wrap;
				hr = CoMarshalInterface(stream, IID_IAccessible, a.acc, MSHCTX_LOCAL, null, MSHLFLAGS_NORMAL);
				if (hr == 0) wrap->ignoreQI = false; else delete wrap;
				//Print((UINT)hr);

				if (hr) PRINTF(L"failed to marshal AO: 0x%X 0x%X", hr1, hr);
#endif
				//ao::PrintAcc(a.acc, a.elem);
			} //else Print(L"OK");
			if (hr != 0) return false;
			inproc::s_hookIAcc.Hook(a.acc);
		}

		if (!!(has & eAccResult::Elem))
			if (stream->Write(&a.elem, 4, null)) return false;

		if (stream->Write(&a.misc.flags, 1, null)) return false;

		if (!!(has & eAccResult::Role))
			if (stream->Write(&a.misc.roleByte, 1, null)) return false;

		if (!!(has & eAccResult::Level))
			if (stream->Write(&a.misc.level, 2, null)) return false;

		if (!!(has & eAccResult::Rect))
			if (stream->Write(rect, 16, null)) return false;

		return true;
	}

#pragma endregion

	struct _AccRect {
		Cpp_Acc a;
		RECT r;
		int state, nSiblings;

		int role() const { return a.misc.roleByte; }
		int level() const { return a.misc.level; }

		static bool Skip(ref Cpp_Acc& a, int state) {
			if (!(state & (STATE_SYSTEM_OFFSCREEN | STATE_SYSTEM_INVISIBLE))) return false;
			if (a.elem != 0) return true;

			bool skip = true;
			int role = a.misc.roleByte;
			if (!!(state & STATE_SYSTEM_OFFSCREEN)) {
				bool mayHaveVisibleChildren = (state & STATE_SYSTEM_EXPANDED) || IsIn(role, ROLE_SYSTEM_PAGETAB, ROLE_SYSTEM_PAGETABLIST);
				skip = !mayHaveVisibleChildren;
			}

			//workaround for bugs in some apps where a hidden control has visible acc descendants, eg in WinUI3 windows like Win11 mspaint.
			//	If it's the only child of a visible parent, likely its acc descendants are visible.
			if (skip && IsIn(role, ROLE_SYSTEM_WINDOW, ROLE_SYSTEM_CLIENT, ROLE_SYSTEM_PANE)) {
				HWND w = 0;
				if (0 == WindowFromAccessibleObject(a.acc, &w) && w) {
					if ((wn::Style(w) & WS_CHILD) != 0 && IsWindowVisible(GetParent(w)) && GetWindow(w, GW_HWNDNEXT) == 0 && GetWindow(w, GW_HWNDPREV) == 0) {
						skip = false;
					}
					//note: don't compare rect, it may be empty
				}
			}

			return skip;
		}

		static void FilterRects(ref std::vector<_AccRect>& a) {
			//remove all GROUPING that don't contain descendants other than GROUPING. And PANE too.
			int nRemove = 0;
			for (int n = (int)a.size(), i = n; --i >= 0; ) {
				auto& v = a[i];
				if (IsIn(v.role(), ROLE_SYSTEM_GROUPING, ROLE_SYSTEM_PANE)) {
					bool noChildren = i == n - 1;
					if (!noChildren) {
						auto& v2 = a[i + 1];
						int levelPlus = v2.level() - v.level();
						noChildren = levelPlus <= 0 || (levelPlus == 1 && v2.nSiblings == 0); //v2 is not child, or is removed child
					}
					if (noChildren) {
						v.nSiblings = 0;
						nRemove++;
					}
				}
			}
			if (nRemove > 0) {
				//auto len1 = a.size();
				a.erase(std::remove_if(a.begin(), a.end(), [](const _AccRect& v) { return v.nSiblings == 0; }), a.end());
				//Printf(L"erase: %i, %i", (int)len1, (int)a.size());
			}

			for (int n = (int)a.size(), i = n; --i >= 0; ) {
				auto& v = a[i];
				//exclude STATICTEXT etc if it is single child in parent and does not have non-removed children
				if (v.nSiblings == 1 && v.level() > 0) { //single child in parent
					int role = v.role();
					bool isStatic = role == ROLE_SYSTEM_STATICTEXT || role == ROLE_SYSTEM_GRAPHIC || role == ROLE_SYSTEM_GROUPING || (role == ROLE_SYSTEM_TEXT && 0 == (v.state & (STATE_SYSTEM_FOCUSABLE | STATE_SYSTEM_UNAVAILABLE)));
					if (isStatic) {
						bool noChildren = i == n - 1;
						if (!noChildren) {
							auto& v2 = a[i + 1];
							int levelPlus = v2.level() - v.level();
							noChildren = levelPlus <= 0 || (levelPlus == 1 && v2.nSiblings == 0); //v2 is not child, or is removed child
						}
						if (noChildren) { //does not have non-removed children (in window rect)
							v.nSiblings = 0; //mark to exclude
							continue;
						}
					}
				}
				//maybe re-include previously excluded descendants
				if (i < n - 1 && a[i + 1].nSiblings == 0) {
					bool reInclude = v.role() == ROLE_SYSTEM_GROUPING;
					if (!(reInclude || ao::IsLinkOrButton(v.role()))) {
						Bstr bn;
						reInclude = !((0 == v.a.acc->get_accName(ao::VE(), &bn)) && bn && bn.Length() > 0); //no name
					}
					if (reInclude) {
						for (int j = i + 1; j < n && a[j].nSiblings == 0 && a[j].level() - a[j - 1].level() == 1; j++) {
							a[j].nSiblings = 1;
						}
					}
				}
			}
		}
	};

} //namespace

namespace inproc {

	//Called from the hook to find or get AO.
	//Common for Cpp_AccFind, Cpp_AccFromWindow and other functions that return AO.
	HRESULT AccFindOrGet(MarshalParams_Header* h, IAccessible* iacc, out BSTR& sResult) {
		Smart<IStream> stream;
		if (0 != CreateStreamOnHGlobal(0, true, &stream)) return RPC_E_SERVER_CANTMARSHAL_DATA;

		auto action = h->action;
		if (action == InProcAction::IPA_AccNavigate) {
			auto p = (MarshalParams_AccElem*)h;
			Cpp_Acc aFrom(iacc, p->elem, h->miscFlags), aResult;

			HRESULT hr = AccNavigate(aFrom, (STR)(p + 1), out aResult);
			if (hr != 0) return hr;
			aResult.SetRoleByte();

			if (!WriteAccToStream(ref stream, aResult)) return RPC_E_SERVER_CANTMARSHAL_DATA;

			if (aResult.acc != iacc) aResult.acc->Release();
		} else if (action == InProcAction::IPA_AccFromWindow) {
			auto p = (MarshalParams_AccFromWindow*)h;
			Smart<IAccessible> a;

			HRESULT hr = ao::AccFromWindowSR((HWND)(LPARAM)p->hwnd, p->objid, &a);
			if (hr != 0) return hr;

			if (p->flags & 2) { //get name
				return a->get_accName(ao::VE(), out & sResult);
			}

			Cpp_Acc aResult(a, 0);
			aResult.SetRoleByte();

			if (!WriteAccToStream(ref stream, aResult)) return RPC_E_SERVER_CANTMARSHAL_DATA;

		} else if (action == InProcAction::IPA_AccFromPoint) {
			auto x = (MarshalParams_AccFromPoint*)h;
			Cpp_Acc aResult;
			HRESULT hr = AccFromPoint(x->p, (HWND)(LPARAM)x->wFP, x->flags, x->specWnd, out aResult);
			if (hr != 0) return hr;
			if (!WriteAccToStream(ref stream, aResult)) return RPC_E_SERVER_CANTMARSHAL_DATA;

			//Workaround for AO leak: the final Release called in the client process somehow does not release the true AO. Releases only the proxy.
			//	But FromWindow() and Find() work well without this Release, although use the same marshaling code etc.
			//	Tested raw AccessibleObjectFromPoint, the same.
			//	Actually there are 2 proxies: one is created on WM_GETOBJECT, other by marshaling to the client process. Probably the first proxy would leak too.
			//aResult.acc->Release(); aResult.acc->Release(); //somehow works even with this. But FromWindow() still works with 1 less Release.
			//Printf(L"----- %i", aResult.acc->Release());//3
			aResult.acc->Release();

		} else if (action == InProcAction::IPA_AccFocused) {
			auto x = (MarshalParams_AccFocused*)h;
			Cpp_Acc aResult;
			HRESULT hr = AccGetFocused((HWND)(LPARAM)x->hwnd, x->flags, out aResult);
			if (hr != 0) return hr;
			if (!WriteAccToStream(ref stream, aResult)) return RPC_E_SERVER_CANTMARSHAL_DATA;
			aResult.acc->Release();

		} else { //IPA_AccFind
			Cpp_AccFindParams ap;
			auto p = (MarshalParams_AccFind*)h; p->Unmarshal(out ap);
			HWND w = (HWND)(LPARAM)p->hwnd;
			eAF2 flags2 = p->flags2;
			bool findAll = !!(flags2 & eAF2::FindAll), getRects = !!(flags2 & eAF2::GetRects);
			int skip = ap.skip;
			HRESULT hr = (HRESULT)eError::NotFound;
			Cpp_Acc aParent(iacc, 0, h->miscFlags), aPrev;
			DpiElmScaling des(getRects, w, null);
			std::vector<_AccRect> agr;

			HRESULT hr2 = AccFind(
				[&](Cpp_Acc a, int state, int nSiblings) mutable {
					if (!findAll && skip-- > 0) return eAccFindCallbackResult::Continue;

					if (ap.resultProp) {
						if (ap.resultProp != '-') {
							a.misc.flags |= eAccMiscFlags::InProc;
							AccGetProp(a, ap.resultProp, out sResult);
						}
					} else if (getRects) { //Delm in "capture smaller" mode uses it together with findAll to get all AO and their rects when inproc
						if (!(ap.flags & eAF::HiddenToo)) {
							if (_AccRect::Skip(ref a, state)) return eAccFindCallbackResult::SkipChildren;
						}
						RECT rect = { };
						if (0 != ao::accLocation(out rect, a.acc, a.elem)) return eAccFindCallbackResult::Continue;
						int scaleResult = des.ScaleIfNeed(ref rect, true);
						if (scaleResult == 1) return eAccFindCallbackResult::Continue; //not in window rect

						agr.emplace_back(a, rect, state, nSiblings);
						a.acc->AddRef();
					} else if (findAll) {
						DWORD pos = 0; istream::GetPos(stream, out pos);

						if (!WriteAccToStream(ref stream, a, &aPrev)) {
							stream->Seek(istream::LI(pos), STREAM_SEEK_SET, null);
						}
					} else {
						if (!WriteAccToStream(ref stream, a, &aPrev)) goto ge;
					}

					hr = 0;
					return findAll ? eAccFindCallbackResult::Continue : eAccFindCallbackResult::StopFound;
				ge:
					hr = RPC_E_SERVER_CANTMARSHAL_DATA;
					return eAccFindCallbackResult::StopNotFound;
				}, w, w ? null : &aParent, ref ap, out sResult);

			if (hr2 != 0 && hr2 != (HRESULT)eError::NotFound) return hr2;
			if (hr != 0) return hr;

			if (getRects) {
				_AccRect::FilterRects(ref agr);
				for (auto& k : agr) {
					if (k.nSiblings > 0) { //else removed
						DWORD pos = 0; istream::GetPos(stream, out pos);
						if (!WriteAccToStream(ref stream, k.a, &aPrev, &k.r)) {
							stream->Seek(istream::LI(pos), STREAM_SEEK_SET, null);
						}
					}
					k.a.acc->Release();
				}
			} else {
				if (ap.resultProp) return 0;
			}
		}

		DWORD streamSize, readSize;
		if (istream::GetPos(stream, out streamSize) && istream::ResetPos(stream)) {
			sResult = SysAllocStringByteLen(null, streamSize);
			if (0 == stream->Read(sResult, streamSize, &readSize) && readSize == streamSize) return 0;
			SysFreeString(sResult); sResult = null;
		}
		return RPC_E_SERVER_CANTMARSHAL_DATA;
	}

	//Returns false if there are AccessibleMarshalWrapper objects in this process.
	//Then cannot unload this dll, because later will be called Release and this process would crash if unloaded.
	//Could not find a way to prevent Release. Even if client does not call it, COM calls it after 6 minutes. CoDisconnectObject prevents only other method calls.
	bool AccDisconnectWrappers() {
		PRINTF_IF(s_accMarshalWrapperCount != 0, L"cannot unload dll because of %i alive acc marshal wrappers.  %s", s_accMarshalWrapperCount, GetCommandLineW());
		return s_accMarshalWrapperCount == 0;
	}

} //namespace inproc

namespace outproc {
	//Reads one AO from results.
	//When FindAll, the caller must call this in loop, until returns a non-zero. If returns NotFound, there are no more AO to read.
	//a - receives the AO, elem, etc. When FindAll, the caller must use the same variable for all, because this function uses it as an input parameter too (previous AO).
	//dontNeedAO - don't need AO. Only release marshal data if need.
	HRESULT InProcCall::ReadResultAcc(ref Cpp_Acc& a, bool dontNeedAO/* = false*/, RECT* rect/* =null*/) {
		if (!_stream) {
			_resultSize = _br.ByteLength(); if (_resultSize == 0) return RPC_E_CLIENT_CANTUNMARSHAL_DATA;
			HGLOBAL hg = GlobalAlloc(GMEM_MOVEABLE, _resultSize); if (hg == 0) return RPC_E_CLIENT_CANTUNMARSHAL_DATA;
			LPVOID mem = GlobalLock(hg); memcpy(mem, _br, _resultSize); GlobalUnlock(mem);
			if (0 != CreateStreamOnHGlobal(hg, true, &_stream)) return RPC_E_CLIENT_CANTUNMARSHAL_DATA;
			//Print(_resultSize);
		}

		DWORD pos; if (istream::GetPos(_stream, out pos) && pos == _resultSize) return (HRESULT)eError::NotFound; //no more results when FindAll. Fast.

		eAccResult has = {};
		if (0 != _stream->Read(&has, 1, null)) return RPC_E_CLIENT_CANTUNMARSHAL_DATA;

		if (!(has & eAccResult::UsePrevAcc)) {
			HRESULT hr;
			if (dontNeedAO) {
				//Perf.First();
				hr = CoReleaseMarshalData(_stream);
				//Perf.NW(); //slow, because calls Release in the server process
				a.acc = null;
			} else {
				hr = CoUnmarshalInterface(_stream, IID_IAccessible, (void**)&a.acc);
			}
			if (hr) return RPC_E_CLIENT_CANTUNMARSHAL_DATA;
		} else if (!dontNeedAO) {
			assert(!!(has & eAccResult::Elem));
			a.acc->AddRef();
		}

		if (!(has & eAccResult::Elem)) a.elem = 0;
		else if (_stream->Read(&a.elem, 4, null)) return RPC_E_CLIENT_CANTUNMARSHAL_DATA;

		if (_stream->Read(&a.misc.flags, 1, null)) return RPC_E_CLIENT_CANTUNMARSHAL_DATA;

		if (!(has & eAccResult::Role)) a.misc.roleByte = 0;
		else if (_stream->Read(&a.misc.roleByte, 1, null)) return RPC_E_CLIENT_CANTUNMARSHAL_DATA;

		if (!(has & eAccResult::UsePrevLevel)) {
			if (!(has & eAccResult::Level)) a.misc.level = 0;
			else if (_stream->Read(&a.misc.level, 2, null)) return RPC_E_CLIENT_CANTUNMARSHAL_DATA;
		}

		if (!!(has & eAccResult::Rect)) {
			if (_stream->Read(rect, 16, null)) return RPC_E_CLIENT_CANTUNMARSHAL_DATA;
		}

		return 0;
	}

	//Gets AO of window (calls AccessibleObjectFromWindow).
	//flags:
	//	1 - not inproc. If used this flag, or if failed to inject dll, the returned AO will not be suitable for in-proc search.
	//	2 - get name instead. Results: aResult = empty, sResult = name.
	EXPORT HRESULT Cpp_AccFromWindow(DWORD flags, HWND w, DWORD objid, out Cpp_Acc& aResult, out BSTR& sResult) {
		aResult.Zero(); sResult = null;

		if (objid == OBJID_JAVA) {
			auto iacc = AccJavaFromWindow(w);
			if (iacc == null) return 1;
			aResult.acc = iacc;
			aResult.misc.flags = eAccMiscFlags::Java;
			return 0;
		} else if (objid == OBJID_UIA) {
			HRESULT hr = AccUiaFromWindow(w, &aResult.acc);
			if (hr == 0) aResult.misc.flags = eAccMiscFlags::UIA;
			return hr;
			//never mind: inproc. Maybe in the future.
		}

		HRESULT R;
	g1:
		if (flags & 1) { //not inproc
			R = ao::AccFromWindowSR(w, objid, &aResult.acc);
			if (R == 0 && flags & 2) {
				R = aResult.acc->get_accName(ao::VE(), out & sResult);
				aResult.acc->Release(); aResult.acc = null;
			}
			return R;
		}

		//Perf.First();
		Cpp_Acc_Agent aAgent;
		if (0 != (R = InjectDllAndGetAgent(w, out aAgent.acc))) {
			switch ((eError)R) {
			case eError::WindowOfThisThread: case eError::UseNotInProc: case eError::Inject: break;
			default: return R;
			}
			flags |= 1; goto g1;
		}
		//Perf.Next();

		InProcCall ic;
		auto p = (MarshalParams_AccFromWindow*)ic.AllocParams(&aAgent, InProcAction::IPA_AccFromWindow, sizeof(MarshalParams_AccFromWindow));
		p->hwnd = (int)(LPARAM)w;
		p->objid = objid;
		p->flags = flags;
		if (0 != (R = ic.Call())) return R;
		//Perf.Next();
		if (flags & 2) sResult = ic.DetachResultBSTR();
		else R = ic.ReadResultAcc(ref aResult);
		//Perf.NW();
		return R;
	}

	//Finds a descendant AO of w or aParent.
	//By default searches in the target process. If flag NotInProc (or if cannot inject), searches from this process (slow); then the returned AO will not be suitable for in-proc search.
	//w - parent window or 0 (if aParent used).
	//aParent - parent AO or null (if w used). Must be retrieved in-proc.
	//ap - AO parameters.
	//also - if not null, this func calls the callback function for each matching AO.
	//	Need to Release the AO, preferably later, maybe in another thread.
	//	If the callback returns true, it is not called again (unless 'skip' is used), and this function returns 0 (found).
	//	If the callback always returns false, this function returns eError::NotFound.
	//aResult - receives the found AO (if this function returns 0 (found)).
	//	Need to Release.
	//	If used 'also', it can be the same AO as the callback received the last time. Need to Release both.
	//	It is empty if this func returns not 0 or if used ap.resultProp.
	//sResult - error string or a property of the found AO.
	//	When this func returns eError::InvalidParameter, it is error string.
	//	When this func returns 0 and used ap.resultProp, it is the property (string, or binary struct); null if '-'.
	//	Else null.
	//getRects - if inproc, get all rectangles too. Use with 'also'.
	EXPORT HRESULT Cpp_AccFind(HWND w, Cpp_Acc* aParent, Cpp_AccFindParams ap, Cpp_AccFindCallbackT also, out Cpp_Acc& aResult, out BSTR& sResult, bool getRects) {
		//Perf.First();
		aResult.Zero(); sResult = null;
		bool inProc = !(ap.flags & eAF::NotInProc), findAll = (also != null), useWnd = (aParent == null);
		if (findAll) ap.flags2 |= eAF2::FindAll;
		if (getRects) ap.flags2 |= eAF2::GetRects;
		HRESULT R;

		assert(!!w == !aParent);
		assert(!ap.resultProp || !findAll);
		assert(!getRects || findAll);

		if (useWnd) {
			if ((ap.flags2 & (eAF2::InWebPage | eAF2::InChromePage | eAF2::InFirefoxPage | eAF2::InIES)) == eAF2::InWebPage) {
				//this is used only if could not detect browser type by w classname
				bool chrome = false;
				HWND c = wn::FindChildByClassName(w, c_IES, c_CRW, OUT chrome, true);
				if (c) {
					ap.flags2 |= chrome ? eAF2::InChromePage : eAF2::InIES;
					if (!chrome) w = c; //info: in Internet Explorer the web browser control is in another process.
				}
			}
		}

		Cpp_Acc_Agent aAgent;
		if (inProc && useWnd) {
			IAccessible* iagent = null;
			if (0 != (R = InjectDllAndGetAgent(w, out iagent))) {
				switch ((eError)R) {
				case eError::WindowOfThisThread: case eError::UseNotInProc: case eError::Inject: break;
				default: return R;
				}
				inProc = false;
			} else {
				aAgent.acc = iagent;
				aParent = &aAgent;
			}
			//Perf.Next();
		}

		if (inProc) {
			InProcCall ic;
			auto sizeofParams = MarshalParams_AccFind::CalcMemSize(ref ap);
			auto p = (MarshalParams_AccFind*)ic.AllocParams(aParent, InProcAction::IPA_AccFind, sizeofParams);
			p->Marshal(useWnd ? w : 0, ref ap);

			if (0 != (R = ic.Call())) {
				if (R == (HRESULT)eError::InvalidParameter) sResult = ic.DetachResultBSTR();
			} else if (!findAll) {
				if (!ap.resultProp) R = ic.ReadResultAcc(ref aResult);
				else if (ap.resultProp != '-') sResult = ic.DetachResultBSTR();
			} else {
				Cpp_Acc a;
				RECT rect = {};
				int skip = ap.skip;
				for (;;) {
					R = ic.ReadResultAcc(ref a, false, &rect);
					if (R) break; //NotFound when end of stream
					if (!also(a, &rect)) continue; //must Release u.acc, preferably later
					if (skip-- == 0) {
						a.acc->AddRef();
						aResult = a;
						break;
					}
				}
				//release the marshal data of remaining AO
				for (auto k = R; k == 0; ) k = ic.ReadResultAcc(ref a, true, &rect);
			}
			//Perf.Next();
		} else {
			ap.flags2 |= eAF2::NotInProc;
			bool found = false;
			int skip = ap.skip;
			std::vector<_AccRect> agr;
			RECT rWin = {}; if (getRects) GetWindowRect(w, &rWin);

			R = AccFind(
				[&](Cpp_Acc a, int state, int nSiblings) mutable {
					if (getRects) {
						if (!(ap.flags & eAF::HiddenToo)) {
							if (_AccRect::Skip(ref a, state)) return eAccFindCallbackResult::SkipChildren;
						}
						RECT rect = { };
						if (0 != ao::accLocation(out rect, a.acc, a.elem)) return eAccFindCallbackResult::Continue;
						if (!IntersectRect(&rect, &rect, &rWin)) return eAccFindCallbackResult::Continue;
						agr.emplace_back(a, rect, state, nSiblings);
						a.acc->AddRef();
						return eAccFindCallbackResult::Continue;
					}

					if (also) {
						a.acc->AddRef(); //of proxy (fast)
						if (!also(a, null)) return eAccFindCallbackResult::Continue;
					}

					if (skip-- > 0) return eAccFindCallbackResult::Continue;
					found = true;

					if (ap.resultProp) {
						if (ap.resultProp != '-') AccGetProp(a, ap.resultProp, out sResult);
					} else {
						aResult = a;
						a.acc->AddRef();
					}

					return eAccFindCallbackResult::StopFound;
				}, w, aParent, ref ap, out sResult);

			if (getRects) {
				if (R != (HRESULT)eError::NotFound) return R;
				_AccRect::FilterRects(ref agr);
				for (auto& k : agr) {
					if (k.nSiblings > 0) { //else removed
						also(k.a, &k.r);
					}
				}
			} else {
				if (R == 0 && !found) R = (HRESULT)eError::NotFound;
			}
		}
		//Perf.NW();

		return R;
	}

} //namespace outproc


================================================
FILE: Cpp/acc find.cpp
================================================
//TODO2: in some windows not-in-proc finds much slower than QM. Eg 5 times slower in Resource Monitor -> Memory. UIA much slower.
//	I guess: maybe looks in hidden child windows, and QM doesn't.
//	In other windows not-in-proc LA similar speed, sometimes 2 times faster.

#include "stdafx.h"
#include "cpp.h"
#include "acc.h"
#include "IAccessible2.h"

#pragma comment(lib, "oleacc.lib")

bool AccMatchHtmlAttributes(IAccessible* iacc, NameValue* prop, int count);
bool AccChromeEnableHtml(IAccessible* aDoc);

class AccFinder {
	//these have ctors
	AccContext _context; //shared memory buffer and maxcc
	str::Wildex _controlClass; //used when the prop parameter has "class=x". Then _flags2 has eAF2::InControls.
	str::Wildex _name; //name. If the name parameter is null, _name.Is()==false.
	//Bstr _roleStrings; //a copy of the input role string when eg need to parse (modify) the string
	Bstr _propStrings; //a copy of the input prop string when eg need to parse (modify) the string
	str::Wildex _url; //Chrome DOCUMENT URL. Specified in the prop parameter. Used by FindDocumentSimple_.

	//our ctor ZEROTHISFROM(_callback)
	AccFindCallback* _callback; //receives found AO
	STR _role; //null if used path or if the role parameter is null
	NameValue* _prop; //other string properties and HTML attributes. Specified in the prop parameter, like L"value=XXX\0 @id=YYY".
	STR _controlWF; //WinForms name. Used when the prop parameter has "id=x" where x is not a number. Then _flags2 has eAF2::InControls.
	STR* _notin; //when searching, skip descendants of AO of these roles. Specified in the prop parameter.
	int _propCount; //_prop array element count
	int _notinCount; //_notin array element count
	int _controlId; //used when the prop parameter has "id=x" wherex x is a number. Then _flags2 has eAF2::InControls|IsId.
	int _minLevel, _maxLevel; //min and max level to search in the object subtree. Specified in the prop parameter. Default 0 1000.
	int _stateYes, _stateNo; //the AO must have all _stateYes flags and none of _stateNo flags. Specified in the prop parameter.
	int _elem; //simple element id. Specified in the prop parameter. _flags2 has IsElem.
	RECTWH _rect; //AO location. Specified in the prop parameter. _flags2 has IsRect.
	eAF _flags; //user
	eAF2 _flags2; //internal
	bool _found; //true when the AO has been found
	void* _findDOCUMENT; //used by FindDocumentSimple_, else null
	BSTR* _errStr; //error string, when a parameter is invalid
	HWND _wTL; //window in which currently searching

	bool _Error(STR es) {
		if (_errStr) *_errStr = SysAllocString(es);
		return false;
	}

	HRESULT _ErrorHR(STR es) {
		_Error(es);
		return (HRESULT)eError::InvalidParameter;
	}

	void _ParseNotin(LPWSTR s, LPWSTR eos) {
		_notinCount = (int)std::count(s, eos, ',') + 1;
		_notin = new STR[_notinCount];
		int i = 0;
		for (LPWSTR start = s; s <= eos; ) {
			if (*s == ',' || s == eos) {
				_notin[i++] = start;
				*s++ = 0; if (*s == ' ') s++;
				start = s;
			} else s++;
		}

		//Print(_notinCount); for(i = 0; i < _notinCount; i++) Print(_notin[i]);
	}

	bool _ParseState(LPWSTR s, LPWSTR eos) {
		for (LPWSTR start = s; s <= eos; ) {
			if (*s == ',' || s == eos) {
				bool nott = false; if (*start == '!') { start++; nott = true; }
				int state;
				if (s > start && *start >= '0' && *start <= '9') {
					LPWSTR se;
					state = strtoi(start, &se);
					if (se != s) return false;
				} else {
					state = ao::StateFromString(start, s - start);
					if (state == 0) return _Error(L"Unknown state name.");
				}
				if (nott) _stateNo |= state; else _stateYes |= state;
				if (*++s == ' ') s++;
				start = s;
			} else s++;
		}
		//Printf(L"0x%X  0x%X", _stateYes, _stateNo);
		return true;
	}

	bool _ParseRect(LPWSTR s, LPWSTR eos) {
		if (*s++ != '{' || *(--eos) != '}') goto ge;
		for (; s < eos; s++) {
			LPWSTR s1 = s++, s2;
			if (*s++ != '=') goto ge; //FUTURE: support operators < > etc. Also Coord. Example: {L>=0.5 T<^20}
			int t = strtoi(s, &s2);
			if (s2 == s) goto ge; s = s2;
			switch (*s1) {
			case 'L': _rect.L = t; _flags2 |= eAF2::IsRectL; break;
			case 'T': _rect.T = t; _flags2 |= eAF2::IsRectT; break;
			case 'W': _rect.W = t; _flags2 |= eAF2::IsRectW; break;
			case 'H': _rect.H = t; _flags2 |= eAF2::IsRectH; break;
			default: goto ge;
			}
		}
		return true;
	ge:
		return _Error(L"Invalid rect format.");
	}

	bool _ParseProp(STR prop, int propLen) {
		if (prop == null) return true;

		int elemCount = (int)std::count(prop, prop + propLen, '\0') + 1;
		_prop = new NameValue[elemCount]; _propCount = 0; //info: finally can be _propCount<elemCount, ie not all elements used
		LPWSTR s0 = _propStrings.Assign(prop, propLen), s2, s3;
		for (LPWSTR s = s0, na = s0, va = null, eos = s0 + propLen; s <= eos; s++) {
			auto c = *s;
			if (c == 0) {
				if (s > s0) {
					if (va == null) return _Error(L"Missing = in prop string.");
					//Printf(L"na='%s' va='%s'    naLen=%i vaLen=%i", na, va, va - 1 - na, s - va);

					bool addToProp = true;
					if (na[0] != '@') { //HTML attribute names have prefix "@"
						int i = str::Switch(na, va - 1 - na, {
							L"value", L"desc", L"help", L"action", L"key", L"uiaid", L"uiacn", //string props
							L"state", L"level", L"maxcc", L"notin", L"rect", L"item",
							L"class", L"id", //control
							L"url"
							});

						if (i == 0) return _Error(L"Unknown name in prop. For HTML attributes use prefix @.");
						const int nStrProp = 7;
						if (i > nStrProp) {
							i -= nStrProp;
							int len = (int)(s - va); if (len == 0 && i != 8) goto ge; //winforms name can be empty
							addToProp = false;
							switch (i) {
							case 1:
								if (!_ParseState(va, s)) return false;
								break;
							case 2:
								_minLevel = strtoi(va, &s2);
								if (s2 == va || _minLevel < 0) goto ge;
								if (s2 == s) _maxLevel = _minLevel;
								else if (s2 < s && *s2 == ' ') {
									_maxLevel = strtoi(++s2, &s3);
									if (s3 != s || _maxLevel < _minLevel) goto ge;
								} else goto ge;
								break;
							case 3:
								_context.maxcc = strtoi(va, &s2);
								if (_context.maxcc < 1 || s2 != s) goto ge;
								break;
							case 4:
								_ParseNotin(va, s);
								break;
							case 5:
								if (!_ParseRect(va, s)) return false;
								break;
							case 6:
								_elem = strtoi(va, &s2); if (s2 != s) goto ge;
								_flags2 |= eAF2::IsElem;
								break;
							case 7:
								if (!_controlClass.Parse(va, len, true, _errStr)) return false;
								_flags2 |= eAF2::InControls;
								break;
							case 8:
								if (len > 0) {
									int cid = strtoi(va, &s2);
									if (s2 == s) { _controlId = cid; _flags2 |= eAF2::IsId; } else _controlWF = va;
								} else _controlWF = va;
								_flags2 |= eAF2::InControls;
								break;
							case 9:
								if (!_url.Parse(va, len, true, _errStr)) return false;
								break;
							}
						}
					}
					if (addToProp) {
						assert(_propCount < elemCount);
						NameValue& x = _prop[_propCount++];
						x.name = na;
						if (!x.value.Parse(va, s - va, true, _errStr)) return false;
					}
				}
				while (++s <= eos && *s <= ' '); //allow space before name, eg "name1=value1\0 name2=..."
				na = s--;
				va = null;
			} else if (c == '=' && va == null) {
				*s = 0;
				va = s + 1;
			}
		}

		return true;
	ge: return _Error(L"Invalid prop string.");
	}

public:

	AccFinder(BSTR* errStr = null) {
		ZEROTHISFROM(_callback);
		_errStr = errStr;
		_maxLevel = 1000;
	}

	~AccFinder() {
		delete[] _prop;
		delete[] _notin;
	}

	bool SetParams(const Cpp_AccFindParams& ap) {
		_flags = ap.flags;
		_flags2 = ap.flags2;
		//if(!_ParseRole(ap.role, ap.roleLength)) return false;
		_role = ap.role;
		if (ap.name != null && !_name.Parse(ap.name, ap.nameLength, true, _errStr)) return false;
		if (!_ParseProp(ap.prop, ap.propLength)) return false;

		if (!!(_flags2 & eAF2::InWebPage)) {
			_flags |= eAF::MenuToo;
			if (!!(_flags & (eAF::UIA | eAF::ClientArea))
				|| !!(_flags2 & eAF2::InControls)
				) return _Error(L"role prefix cannot be used with: flag UIA, flag ClientArea, prop 'class', prop 'id'.");
		}

		return true;
	}

	HRESULT Find(HWND w, const Cpp_Acc* a, AccFindCallback* callback) {
		assert(!!w == !a);
		_callback = callback;

		if (a) {
			if (!!(_flags2 & eAF2::InWebPage)) return _ErrorHR(L"Don't use role prefix when searching in elm.");
			if (!!(_flags2 & eAF2::InControls)) return _ErrorHR(L"Don't use class/id when searching in elm.");
			assert(!(_flags & (eAF::UIA | eAF::ClientArea))); //checked in C#

			_FindInAcc(ref * a, 0);
		} else if (!!(_flags2 & eAF2::InWebPage)) {
			if (!!(_flags2 & eAF2::InIES)) { //info: Cpp_AccFind finds IES control and adds this flag
				_FindInWnd(w, false, false);
				//info: the hierarchy is WINDOW/CLIENT/PANE, therefore PANE will be at level 0
			} else {
				AccDtorIfElem0 aDoc;
				//Perf.First();
				HRESULT hr = _FindDocument(w, out aDoc);
				//Perf.NW();
				if (hr) return hr;

				switch (_Match(ref aDoc, 0)) {
				case _eMatchResult::SkipChildren: return (HRESULT)eError::NotFound;
				case _eMatchResult::Continue: _FindInAcc(ref aDoc, 1);
				}
			}
		} else {
			bool isJava = !(_flags & eAF::UIA) && (_role == null || (_role[0] >= 'a' && _role[0] <= 'z')) && wn::ClassNameIs(w, L"SunAwt*"); //note: can be control. I know only 1 such app - Sweet Home 3D.
			if (!!(_flags2 & eAF2::InControls)) {
				wn::EnumChildWindows(w, [this, w, isJava](HWND c) {
					if (!(_flags & eAF::HiddenToo) && !wn::IsVisibleInWindow(c, w)) return true; //not IsWindowVisible, because we want to find controls in invisible windows
					if (!!(_flags2 & eAF2::IsId) && GetDlgCtrlID(c) != _controlId) return true;
					if (_controlClass.Is() && !wn::ClassNameIs(c, _controlClass)) return true;
					if (_controlWF != null && !wn::WinformsNameIs(c, _controlWF)) return true;
					return 0 != _FindInWnd(c, true, isJava && wn::ClassNameIs(c, L"SunAwt*"));
					});
			} else {
				_wTL = (wn::Style(w) & WS_CHILD) ? 0 : w;
				if (_wTL && !(_flags & eAF::UIA) && !isJava) {
					if (wn::ClassNameIs(w, L"Mozilla*")) _flags2 |= eAF2::InFirefoxNotWebNotUIA; //skip background tabs
				}
				_FindInWnd(w, false, isJava);
			}
		}

		return _found ? 0 : (HRESULT)eError::NotFound;
	}

private:
	HRESULT _FindInWnd(HWND w, bool isControl, bool isJava) {
		if (isJava) {
			AccDtorIfElem0 aj(AccJavaFromWindow(w), 0, eAccMiscFlags::Java);
			if (aj.acc) return _FindInAcc(ref aj, 0) ? 0 : (HRESULT)eError::NotFound;
		}

		AccDtorIfElem0 aw;
		HRESULT hr;
		if (!!(_flags & eAF::UIA)) {
			hr = AccUiaFromWindow(w, &aw.acc);
			aw.misc.flags = eAccMiscFlags::UIA;
			//FUTURE: to make faster, add option to use IUIAutomationElement::FindFirst or FindAll.
			//	Problems: 1. No Level. 2. Cannot apply many flags; then in some cases can be slower or less reliable.
			//	Not very important. Now fast enough. JavaFX almost same speed (inproc).
		} else {
			bool inCLIENT = !!(_flags & eAF::ClientArea);
			hr = ao::AccFromWindowSR(w, inCLIENT ? OBJID_CLIENT : OBJID_WINDOW, &aw.acc);
			aw.misc.roleByte = inCLIENT ? ROLE_SYSTEM_CLIENT : ROLE_SYSTEM_WINDOW; //not important: can be not CLIENT (eg DIALOG)
		}
		if (hr) return hr;

		//isControl is true when is specified class or id. Now caller is enumerating controls. Need _Match for control's WINDOW, not only for descendants.
		int level = 0;
		if (isControl) {
			switch (_Match(ref aw, level++)) {
			case _eMatchResult::Stop: return 0;
			case _eMatchResult::SkipChildren: goto gnf;
			}
		}

		if (_FindInAcc(ref aw, level)) return 0; //note: caller also must check _found; this is just for EnumChildWindows.
	gnf:
		return (HRESULT)eError::NotFound;
	}

	//Returns true to stop.
	bool _FindInAcc(const Cpp_Acc& aParent, int level) {
		int startIndex = 0; bool exactIndex = false;

		AccChildren c(ref _context, ref aParent, startIndex, exactIndex, !!(_flags & eAF::Reverse));
		//Printf(L"%i  %i", level, c.Count());
		if (c.Count() == 0) {
			//rejected: enable Chrome web AOs. Difficult to implement (lazy, etc). Let use prefix "web:".
			//if(_wTL) {
			//	if(level == (!!(_flags & eAF::ClientArea) ? 0 : 1) && aParent.misc.roleByte == ROLE_SYSTEM_CLIENT) {
			//	}
			//}
			return false;
		}
		for (;;) {
			AccDtorIfElem0 aChild;
			if (!c.GetNext(out aChild)) break;

			switch (_Match(ref aChild, level, c.Count())) {
			case _eMatchResult::Stop: return true;
			case _eMatchResult::SkipChildren: continue;
			}

			if (_FindInAcc(ref aChild, level + 1)) return true;
		} //now a.a is released if a.elem==0
		return false;
	}

	enum class _eMatchResult { Continue, Stop, SkipChildren };

	_eMatchResult _Match(ref AccDtorIfElem0& a, int level, int nSiblings = 0) {
		if (_findDOCUMENT && a.elem != 0) return _eMatchResult::SkipChildren;

		bool skipChildren = a.elem != 0 || level >= _maxLevel;
		bool hiddenToo = !!(_flags & eAF::HiddenToo);
		_AccState state(ref a);

		_variant_t varRole;
		BYTE role = a.GetRoleByteAndVariant(out varRole);
		a.misc.roleByte = role;
		a.SetLevel(level);

		//a.PrintAcc();

		//skip Firefox background tabs.
		//	Searching without "web:" could take minutes. With "web:" would find wrong DOCUMENT when the fast way fails.
		//	In recent versions: DOCUMENT's state does not have invisible/offscreen flags; parent browser and PROPERTYPEGE have OFFSCREEN.
		//	Never mind UIA. Roles Custom/PANE/DOCUMENT instead of PROPERTYPAGE/browser/DOCUMENT. Also cannot be used "web:".
		if (!!(_flags2 & eAF2::InFirefoxNotWebNotUIA) && role == ROLE_SYSTEM_PROPERTYPAGE && !skipChildren && level < 5) {
			if (state.State() & (STATE_SYSTEM_INVISIBLE | STATE_SYSTEM_OFFSCREEN)) {
				//Print(level); //2 in Firefox and Thunderbird
				return _eMatchResult::SkipChildren;
			}
		}

		if (_findDOCUMENT) {
			auto fdr = _FindDocumentCallback(ref a);
			if (skipChildren && fdr == _eMatchResult::Continue) fdr = _eMatchResult::SkipChildren;
			return fdr;
		}

		if (!!(_flags2 & eAF2::GetRects)) {
			switch ((*_callback)(a, state.State(), nSiblings)) {
			case eAccFindCallbackResult::Continue: return skipChildren ? _eMatchResult::SkipChildren : _eMatchResult::Continue;
			case eAccFindCallbackResult::SkipChildren: return _eMatchResult::SkipChildren;
			}
			return _eMatchResult::Stop;
		}

		//skip children of AO of user-specified roles
		STR roleString = null;
		if (_notin && !skipChildren) {
			roleString = ao::RoleToString(ref varRole);
			for (int i = 0; i < _notinCount; i++) if (!wcscmp(_notin[i], roleString)) {
				skipChildren = true;
				break;
			}
		}

		STR roleNeeded = _role;

		if (level >= _minLevel) {
			//If eAF::Mark, the caller is getting all AO using callback, and wants us to add eAccMiscFlags::Marked to AOs that match role, rect, name and state.
			//	If some of these props does not match, we set mark = -1, to avoid comparing other props.
			int mark = !!(_flags & eAF::Mark) ? 1 : 0;
			if (mark && !!(_flags & eAF::Marked_)) {
				//Currently the caller needs single marked object. Used internally.
				//	To make faster, don't compare properties of other objects. Some AO are very slow, eg .NET DataGridView with 10 columns and 1000 rows.
				mark = -1;
			}

			if (mark >= 0) {
				if (roleNeeded != null) {
					if (!roleString) roleString = ao::RoleToString(ref varRole);
					if (wcscmp(roleNeeded, roleString)) {
						if (mark) mark = -1;
						else goto gr;
					}
				}
			}

			if (!!(_flags2 & eAF2::IsElem) && a.elem != _elem) goto gr;

			if (mark > 0 && !_MatchRect(ref a)) mark = -1;

			if (_name.Is() && mark >= 0 && !a.MatchStringProp(L"name", ref _name)) {
				if (mark) mark = -1; else goto gr;
			}

			if (!hiddenToo) {
				int iiv = state.IsInvisible();
				switch (iiv) {
				case 2: //INVISISBLE and OFFSCREEN
					if (!_IsRoleToSkipIfInvisible(role)) break;
					[[fallthrough]];
				case 1: //only INVISIBLE
					if (_IsRoleTopLevelClient(role, level)) break; //rare
					return _eMatchResult::SkipChildren;
				}

				//never mind: MSAA bug of child windows classnamed "Windows.UI.Input.InputSite.WindowClass": WINDOW has INVISIBLE, although descendants are visible.
				//	It breaks MSAA in some Win11 apps, eg taskbar, terminal, paint. UIA OK.
				//  Could apply a workaround here, but:
				//	1. Also need a workaround in "elm from point" code. Difficult.
				//	2. The tool auto-switches to UIA, and it's even faster.
			}

			if (!!(_stateYes | _stateNo) && mark >= 0) {
				int k = state.State();
				if ((k & _stateYes) != _stateYes || !!(k & _stateNo)) {
					if (mark) mark = -1; else goto gr;
				}
			}

			if (!mark && !_MatchRect(ref a))  goto gr;

			if (_propCount) {
				bool hasHTML = false;
				for (int i = 0; i < _propCount; i++) {
					NameValue& p = _prop[i];
					if (p.name[0] == '@') hasHTML = true;
					else if (!a.MatchStringProp(p.name, ref p.value)) goto gr;
				}
				if (hasHTML) {
					if (a.elem || !AccMatchHtmlAttributes(a.acc, _prop, _propCount)) goto gr;
				}
			}

			if (mark > 0) {
				a.misc.flags |= eAccMiscFlags::Marked;
				_flags |= eAF::Marked_;
			}

			switch ((*_callback)(a, 0, 0)) {
			case eAccFindCallbackResult::Continue: goto gr;
			case eAccFindCallbackResult::SkipChildren: return _eMatchResult::SkipChildren;
			case eAccFindCallbackResult::StopFound: _found = true;
				//case eAccFindCallbackResult::StopNotFound: break;
			}
			return _eMatchResult::Stop;
		}
	gr:
		if (!skipChildren) {
			//flag MenuToo
			skipChildren = role == ROLE_SYSTEM_MENUITEM && !(_flags & eAF::MenuToo) && !str::Switch(roleNeeded, { L"MENUITEM", L"MENUPOPUP" });

			//skip children of invisible AO that often have many descendants (eg DOCUMENT, WINDOW)
			if (!skipChildren && !hiddenToo && _IsRoleToSkipIfInvisible(role) && !_IsRoleTopLevelClient(role, level)) skipChildren = state.IsInvisible();
		}

		return skipChildren ? _eMatchResult::SkipChildren : _eMatchResult::Continue;
	}

	//Gets AO state.
	//The first time calls get_accState. Later returns cached value.
	class _AccState {
		const AccRaw& _a;
		long _state;
	public:
		_AccState(ref const AccRaw& a) : _a(a) { _state = -1; }

		int State() {
			if (_state == -1) _a.get_accState(out _state);
			return _state;
		}

		//Returns: 1 INVISIBLE and not OFFSCREEN, 2 INVISIBLE and OFFSCREEN, 0 none.
		int IsInvisible() {
			switch (State() & (STATE_SYSTEM_INVISIBLE | STATE_SYSTEM_OFFSCREEN)) {
			case STATE_SYSTEM_INVISIBLE: return 1;
			case STATE_SYSTEM_INVISIBLE | STATE_SYSTEM_OFFSCREEN: return 2;
			}
			return 0;
		}
	};

	static bool _IsRoleToSkipIfInvisible(int roleE) {
		switch (roleE) {
			//case ROLE_SYSTEM_MENUBAR: case ROLE_SYSTEM_TITLEBAR: case ROLE_SYSTEM_SCROLLBAR: case ROLE_SYSTEM_GRIP: //nonclient, already skipped
		case ROLE_SYSTEM_WINDOW: //child control
		case ROLE_SYSTEM_DOCUMENT: //web page in Firefox, Chrome
		case ROLE_SYSTEM_PROPERTYPAGE: //page in multi-tab dialog or window
		case ROLE_SYSTEM_GROUPING: //eg some objects in Firefox
		case ROLE_SYSTEM_ALERT: //eg web browser message box. In Firefox can be some invisible alerts.
		case ROLE_SYSTEM_MENUPOPUP: //eg in Firefox.
			return true;
			//note: these roles must be the same as in elm.IsInvisible
		}
		return false;
		//note: don't add CLIENT. It is often used as default role. Although in some windows it can make faster.
		//note: don't add PANE. Too often used for various purposes.

		//problem: some frameworks mark visible offscreen objects as invisible. Eg IE, WPF, Windows controls. Not Firefox, Chrome.
		//	Can be even parent marked as invisible when child not. Then we'll not find child if parent's role is one of above.
		//	Never mind. This probably will be rare with these roles. Then user can add flag HiddenToo.
		//	But code tools should somehow detect it and add the flag.
	}

	//Returns true if the AO is most likely the client area of the top-level window.
	bool _IsRoleTopLevelClient(int role, int level) {
		if (_wTL && level == 0 && !(_flags & eAF::ClientArea)) {
			switch (role) {
			case ROLE_SYSTEM_MENUBAR: case ROLE_SYSTEM_TITLEBAR: case ROLE_SYSTEM_SCROLLBAR: case ROLE_SYSTEM_GRIP: break;
			default: return true;
			}
		}
		return false;
	}

	bool _MatchRect(ref AccDtorIfElem0& a) {
		if (!!(_flags2 & eAF2::IsRect)) {
			long L, T, W, H;
			if (0 != a.acc->accLocation(&L, &T, &W, &H, ao::VE(a.elem))) L = T = W = H = 0;

			//note: _rect is raw AO rect, relative to the screen, not to the window/control/page. Its right/bottom actually are width/height.
			//	It is useful when you want to find AO in the object tree when you already have its another IAccessible eg retrieved from point.
			//	For example, Delm uses it to select the captured AO in the tree.
			//	Do not try to make it relative to window etc. Don't need to encourage users to use unreliable ways to find AO.

			if (!!(_flags2 & eAF2::IsRectL) && L != _rect.L) return false;
			if (!!(_flags2 & eAF2::IsRectT) && T != _rect.T) return false;
			if (!!(_flags2 & eAF2::IsRectW) && W != _rect.W) return false;
			if (!!(_flags2 & eAF2::IsRectH) && H != _rect.H) return false;
		}
		return true;
	}

	//Finds DOCUMENT of Firefox, Chrome or some other program.
	//Returns 0, NotFound.
	//Called if _flags2 & eAF2::InWebPage.
	HRESULT _FindDocument(HWND w, out AccRaw& ar) {
		assert(ar.IsEmpty());

		AccDtorIfElem0 ap_;
		if (0 != AccessibleObjectFromWindow(w, OBJID_CLIENT, IID_IAccessible, (void**)&ap_.acc)) return (HRESULT)eError::NotFound;
		IAccessible* ap = ap_.acc;

		if (!!(_flags2 & eAF2::InFirefoxPage)) {
			//To get DOCUMENT, use Navigate(0x1009). It is documented and tested on FF>=2.
			_variant_t vNav;
			int hr = ap->accNavigate(0x1009, ao::VE(), out & vNav);
			if (hr == 0 && vNav.vt == VT_DISPATCH && vNav.pdispVal && 0 == vNav.pdispVal->QueryInterface(&ar.acc) && ar.acc) {
				return 0;
				//note: don't check BUSY state, it's unreliable.
			}

			PRINTS(L"failed Firefox accNavigate(0x1009). It's OK first time after Firefox starts.");
			//Fails when calling first time after starting Firefox. FindDocumentSimple_ too. Never mind, it is documented, let use Wait.
			//In some Firefox versions (56, 57) accNavigate(0x1009) is broken.
			//Also occasionally fails in some pages, even if page is loaded, maybe when executing scripts.
			//	Also fails in some tool windows, eg Browser Console. Sometimes always fails in full-screen mode.
			//	Then FindDocumentSimple_ finds it.
		} else if (!!(_flags2 & eAF2::InChromePage)) {
			if ((wn::Style(w) & WS_CHILD) && wn::ClassNameIs(w, c_CRW)) {
				//ao::PrintAcc(ap);
				ar.acc = ap;
				ap_.acc = null;
				return 0;
				//note: this cannot be used with Chrome. ap is a DOCUMENT, but it's a random document, not the active.
			}

			//tested: 0 relations.
			//IAccessible2* aw2 = null;
			//if (QueryService(ap, &aw2, &IID_IAccessible)) {
			//	long n = 0; auto r = aw2->get_nRelations(&n);
			//	Printf(L"0x%X, %i", r, n);
			//	aw2->Release();
			//}
		}

		return FindDocumentSimple_(ap, out ar, _flags2, this);
	}

	struct _DocumentFindData {
		CComPtr<IAccessible> doc;
		CComPtr<IAccessible> docs[2];
		int nDocs = 0;
		AccFinder* mainFinder = null;
	};

public:
	//Finds DOCUMENT with AccFinder::Find. Skips TREE etc.
	//Returns 0 or NotFound.
	static HRESULT FindDocumentSimple_(IAccessible* ap, out AccRaw& ar, eAF2 flags2, AccFinder* mainFinder = null) {
		AccFinder f;
		_DocumentFindData d; d.mainFinder = mainFinder;
		f._findDOCUMENT = &d;
		f._flags2 = flags2 & (eAF2::InChromePage | eAF2::InFirefoxPage);
		if (!!(flags2 & eAF2::InFirefoxPage)) f._flags2 |= eAF2::InFirefoxNotWebNotUIA; //skip background tabs
		else if (!!(flags2 & eAF2::InChromePage)) f._flags |= eAF::Reverse; //~20% faster
		f._maxLevel = 30;
		Cpp_Acc a(ap, 0);
		if (0 == f.Find(0, &a, null)) {
			ar.acc = d.doc.Detach();
			return 0;
		}

		//fbc. If there are no DOCUMENT with URL starting with "https:" etc, use the most likely DOCUMENT. New scripts should use prop url instead.
		if (d.nDocs > 0) {
			if (d.nDocs == 1) {
				ar.acc = d.docs[0].Detach();
				return 0;
			} else { //2 DOCUMENT. Use the one that matches the window name. Probably the other is the side panel.
				HWND w1 = 0;
				if (0 == WindowFromAccessibleObject(d.docs[0], &w1)) {
					if (wn::ClassNameIs(w1, c_CRW)) w1 = GetParent(w1);
					Bstr wName;
					if (wn::Name(w1, ref wName)) {
						size_t lenW = wName.Length(), lenA;
						for (int i = 0; i < 2; i++) {
							Bstr aName;
							if (0 == d.docs[i]->get_accName(ao::VE(), &aName) && (lenA = aName.Length()) > 0 && lenA < lenW && wName[lenA] == ' ' && !wcsncmp(wName, aName, lenA)) {
								ar.acc = d.docs[i].Detach();
								return 0;
							}
						}
					}
				}
			}
		}

		return (HRESULT)eError::NotFound;

		//when outproc, sometimes fails to get DOCUMENT role while enabling Chrome AOs. The caller will wait/retry.
	}
private:

	//Used by FindDocumentSimple_.
	_eMatchResult _FindDocumentCallback(ref const AccRaw& a) {
		//a.PrintAcc();
		int role = a.misc.roleByte;
		if (role == ROLE_SYSTEM_DOCUMENT) {
			long state; if (0 != a.get_accState(out state) || !!(state & STATE_SYSTEM_INVISIBLE)) return _eMatchResult::SkipChildren;

			_DocumentFindData& d = *(_DocumentFindData*)_findDOCUMENT;

			if (!!(_flags2 & eAF2::InChromePage)) {
				//tested: IAccessible2, ISimpleDOMDocument and IAccessibleApplication can't help to detect document type (web page, side panel etc)
				//IAccessible2* aw2 = null;
				//if(QueryService(a.acc, &aw2, &IID_IAccessible)) {
				//	//Bstr b;
				//	//auto r = aw2->get_attributes(&b);
				//	//auto r = aw2->get_extendedRole(&b);
				//	//auto r = aw2->get_localizedExtendedRole(&b);
				//	//Printf(L"0x%X, %s", r, b.m_str);
				//	//long n = 0; auto r = aw2->get_nExtendedStates(&n);
				//	//long n = 0; auto r = aw2->get_nRelations(&n);
				//	//long n = 0; auto r = aw2->get_uniqueID(&n);
				//	//long n = 0; auto r = aw2->role(&n);
				//	//long n = 0; auto r = aw2->get_indexInParent(&n);
				//	//Printf(L"0x%X, %i", r, n);
				//	aw2->Release();
				//}

				//ISimpleDOMDocument* isd = null;
				//if (QueryService(a.acc, &isd, &IID_IAccessible)) {
				//	Bstr s1, s2, s3, s4;
				//	if (0 == isd->get_URL(&s1)) Printf(L"URL=%s", s1.m_str);
				//	if (0 == isd->get_title(&s2)) Printf(L"title=%s", s2.m_str);
				//	if (0 == isd->get_docType(&s3)) Printf(L"docType=%s", s3.m_str);
				//	if (0 == isd->get_mimeType(&s4)) Printf(L"mimeType=%s", s4.m_str);
				//	//if (0 == isd->get_nameSpaceURIForID(&s1)) Printf(L"=%s", s1.m_str);

				//	isd->Release();
				//}

				//IAccessibleApplication* iaa=null;
				//if (QueryService(a.acc, &iaa, &IID_IAccessible)) {
				//	Bstr s1, s2, s3, s4;
				//	if(0==iaa->get_appName(&s1)) Printf(L"appName=%s", s1.m_str);
				//	if(0==iaa->get_appVersion(&s2)) Printf(L"appVersion=%s", s2.m_str);
				//	if(0==iaa->get_toolkitName(&s3)) Printf(L"toolkitName=%s", s3.m_str);
				//	if(0==iaa->get_toolkitVersion(&s4)) Printf(L"toolkitVersion=%s", s4.m_str);
				//	iaa->Release();
				//}

				if (d.mainFinder != null) { //else called by AccEnableChrome2 (can be any DOCUMENT)
					Bstr b;
					if (!(0 == a.acc->get_accValue(ao::VE(), &b) && b && b.Length() > 0)) return _eMatchResult::SkipChildren;

					if (d.mainFinder->_url.Is()) {
						if (!d.mainFinder->_url.Match(b, b.Length())) return _eMatchResult::SkipChildren;
					} else {
						if (b.Length() < 6 || (wcsncmp(b, L"https:", 6) && wcsncmp(b, L"http:", 5) && wcsncmp(b, L"file:", 5))) {
							//fbc. If there are no DOCUMENT with URL starting with "https:" etc, use the most likely DOCUMENT. New scripts should use prop url instead.
							if (d.nDocs < 2 && wcsncmp(b, L"devtools:", 9)) {
								d.docs[d.nDocs++] = a.acc; //AddRef
							}

							return _eMatchResult::SkipChildren;
						}
					}
				}
				//note: sync with Delm._IsVisibleWebPage.
			}

			d.doc = a.acc; //AddRef
			_found = true;
			return _eMatchResult::Stop;
		}

		static const BYTE b[] = { ROLE_SYSTEM_MENUBAR, ROLE_SYSTEM_TITLEBAR, ROLE_SYSTEM_MENUPOPUP, ROLE_SYSTEM_TOOLBAR,
			ROLE_SYSTEM_STATUSBAR, ROLE_SYSTEM_OUTLINE, ROLE_SYSTEM_LIST, ROLE_SYSTEM_SCROLLBAR, ROLE_SYSTEM_GRIP,
			ROLE_SYSTEM_SEPARATOR, ROLE_SYSTEM_PUSHBUTTON, ROLE_SYSTEM_TEXT, ROLE_SYSTEM_TOOLTIP,
			ROLE_SYSTEM_TABLE,
			//ROLE_SYSTEM_STATICTEXT, //no, eg WebView2 uses a Static container control
		};
		for (int i = 0; i < _countof(b); i++) if (role == b[i]) return _eMatchResult::SkipChildren;
		return _eMatchResult::Continue;
	}
};

HRESULT AccFind(AccFindCallback& callback, HWND w, Cpp_Acc* aParent, const Cpp_AccFindParams& ap, out BSTR& errStr) {
	AccFinder f(&errStr);
	if (!f.SetParams(ref ap)) return (HRESULT)eError::InvalidParameter;
	return f.Find(w, aParent, &callback);
}

HRESULT AccEnableChrome2(HWND w, int i, HWND c) {
	Smart<IAccessible> aw, aDoc;
	HRESULT hr;

	if (i == 0 || c == 0) {
		hr = AccessibleObjectFromWindow(w, OBJID_CLIENT, IID_IAccessible, (void**)&aw);
		if (hr != 0) return (HRESULT)eError::NotFound;
	}

	if (i == 0) {
		IAccessible2* aw2 = null;
		if (QueryService(aw, &aw2, &IID_IAccessible)) aw2->Release();
		//tested: the IAccessible2 does not have relations or something that would give the document

		Smart<IUIAutomationElement> e1, e2;
		Smart<IUIAutomationCondition> cond1;
		if (c) {
			if (0 != UIA()->ElementFromHandle(c, &e1)) return (HRESULT)eError::NotFound;
			UIA()->get_RawViewCondition(&cond1);
			e1->FindFirst(TreeScope::TreeScope_Children, cond1, &e2);
		} else {
			if (0 != UIA()->ElementFromHandle(w, &e1)) return (HRESULT)eError::NotFound;
			UIA()->CreateFalseCondition(&cond1);
			e1->FindFirst(TreeScope::TreeScope_Descendants, cond1, &e2);
		}
	}

	if (c) {
		hr = AccessibleObjectFromWindow(c, OBJID_CLIENT, IID_IAccessible, (void**)&aDoc);
		if (hr != 0) return (HRESULT)eError::NotFound;
	} else { //the child control is detached if the window is not visible to the user, eg completely covered by other windows
		RECT r;
		if (GetClientRect(w, &r)) { //note: aDoc.accLocation fails
			MapWindowPoints(w, 0, (LPPOINT)&r, 2);
			int x = (r.left + r.right) / 2, y = r.bottom - 10;
			int j = i - 4;
			if (j >= 0) { //try to find x y in web page. Does not work if in a side panel or devtools.
				j %= 16;
				r.top += 80; //never mind DPI
				int wid = r.right - r.left, hei = r.bottom - r.top;
				x = (j % 4) * (wid / 4) + wid / 8 + r.left;
				y = (j / 4) * (hei / 4) + hei / 8 + r.top;
			}
			VARIANT v = {};
			if (0 == aw->accHitTest(x, y, &v)) { //need to call at least 2 times
				VariantClear(&v);
			}
			//never mind: does not work when the window is minimized.
		}

		AccRaw ar;
		hr = AccFinder::FindDocumentSimple_(aw, out ar, eAF2::InChromePage);
		if (hr != 0) return (HRESULT)eError::NotFound;
		aDoc.Attach(ar.acc);
	}

	long cc = 0;
	bool isEnabled = 0 == aDoc->get_accChildCount(&cc) && cc > 0;
	//Printf(L"isEnabled=%i, i=%i", isEnabled, i);

	if (i == 0) {
		Bstr name;
		if (!isEnabled) aDoc->get_accName(ao::VE(), &name); //enables everything except HTML, get_accDefaultAction and maybe more
	}

	//Enable HTML, get_accDefaultAction and maybe some other properties.
	//	Else they will be unavailable when queried first time or several times, until Chrome enables them lazily.
	//Note: not before isEnabled true.
	//	Then sometimes no aDoc->get_accValue and ISimpleDOMDocument.URL. Randomly, about every 5-th time, more often with large pages.
	//	Value is very important. Without it fails with "web:" etc.
	if (isEnabled) {
		//Bstr action; aDoc->get_accDefaultAction(ao::VE(), &action);
		AccChromeEnableHtml(aDoc);
		//any of these enables both

		//rejected: wait.
		// Unreliable. Can make much slower. Can't rely on AccChromeEnableHtml returning correct result.
		// If somebody needs HTML etc ASAP, let use --force-renderer-accessibility.
		// The tool now works well with most pages.
		//isEnabled = AccChromeEnableHtml(aDoc);
		//if (!AccChromeEnableHtml(aDoc)) return (HRESULT)eError::WaitChromeEnabledPartially;
	}

	return isEnabled ? 0 : (HRESULT)eError::WaitChromeDisabled;

	//note: some of these are obsolete. Eg in current Chrome need to get UIA element of the control and get its children.
	//I know these ways to auto-enable Chrome web page AOs:
	//1. Call get_accName of any AO, eg of main window or document.
	//	Need to wait. Also need to call some other functions to enable HTML and all acc properties.
	//	In current Chrome works alone. In Edge, WebView2 and old Chrome also need 2.
	//2. Try to QS IAccessible2 from the client IAccessible of the main window.
	//	It's undocumented. I found it in Chromium source code, and later on the internet.
	//		One Chromium developer suggested to use it instead of the broken WM_GETOBJECT way.
	//  Works inproc and outproc. If outproc, the QS fails, but enables anyway.
	//	It may not enable by itself. Or very slowly. Then need to call get_accName. It's undocumented.
	//	Need to wait. The time depends on how big is the webpage. May be even 1 s.
	//	When used in certain way, used to kill Chrome process on Win7 (or it depends on Chrome settings etc). Current code works well.
	//3. (tested loong time ago) Get a UIA element.
	//	Chrome: of main window.
	//	WebView2: of the legacy control. Then call its FindFirst with "true" condition. With Chrome it does not work.
	//		Or from point.
	//		It enables for entire process (or thread, not tested). Eg the window may have multiple WebView2 controls; need to enable just for one.
	//	Bad: UIA at first is slow. And undocumented.
	//	Need to wait like always.
	//4. Edge enables if SPI_SETSCREENREADER. Not Chrome.
	//5. (obsolete, now does not work) Send WM_GETOBJECT(0, 1) to the legacy control (child window classnamed "Chrome_RenderWidgetHostHWND").
	//  Documented: Chrome calls NotifyWinEvent(ALERT) when starts, and enables if then receives WM_GETOBJECT with its arguments.
	//	Does not work with current Chrome. Maybe works only if called soon after NotifyWinEvent; not tested.
}

namespace outproc {
	using Cpp_HelperCallbackT = BOOL(__stdcall*)(int action, HWND w);
	static Cpp_HelperCallbackT s_helperCallback;

	EXPORT void Cpp_SetHelperCallback(Cpp_HelperCallbackT callback) {
		s_helperCallback = callback;
	}

	void AccEnableChrome(HWND w, HWND c = 0) {
		if (!!(WinFlags::Get(w) & eWinFlags::AccEnabled)) return;

		assert(!(wn::Style(w) & WS_CHILD));
		HWND wTL = w;

		if (c) {
			w = GetParent(c); //eg WebView2
			if (!w) return;
			PRINTS_IF(!wn::ClassNameIs(w, L"Chrome_WidgetWin_1"), L"parent not Chrome_WidgetWin_1");
		} else {
			c = wn::FindWndExVisible(w, c_CRW);
			if (!c) { //eg WebView2. //tested: enables in all WebView2 in that window.
				c = wn::FindChildByClassName(w, c_CRW, true);
				if (c) w = GetParent(c);
			}

			if (!c) {
				//Ideally should not need to enable, because there is no web content (and no DOCUMENT).
				//But need to enable anyway, because:
				// 1. In the future Chrome may remove the legacy control.
				// 2. Some Chrome/Edge versions detach the control when the browser window isn't visible, eg completely covered by other windows.

				DWORD style = (DWORD)GetWindowLong(w, GWL_STYLE);
				if (0 != (style & WS_POPUP) || style == 0) return; //a popup window, eg menu, tooltip, new bookmark. Or invalid window handle.
#ifdef TRACE
				if (w == GetForegroundWindow()) {
					PRINTS(L"no Chrome_RenderWidgetHostHWND in:");
					wn::PrintWnd(w); //eg Task Manager
				}
#endif
			}
		}

		//return if Chrome started with --force-renderer-accessibility.
		if (s_helperCallback(1, wTL)) { //here in C++ we don't have a function to get command line
			WinFlags::Set(wTL, eWinFlags::AccEnabled);
			return;
		}
		auto t1 = GetTickCount64();

		//notinproc FindDocumentSimple_ is very slow
		Cpp_Acc_Agent aAgent;
		bool inProc = 0 == InjectDllAndGetAgent(w, out aAgent.acc);

		for (int i = 0, iTo = inProc ? 70 : 25, nNoDoc = 0, nPartially = 0; i < iTo; i++) { //max 3 s
			HRESULT hr;
			//Perf.First();
			if (inProc) {
				InProcCall ic;
				auto p = (MarshalParams_AccInt4*)ic.AllocParams(&aAgent, InProcAction::IPA_AccEnableChrome, sizeof(MarshalParams_AccInt4));
				p->i0 = (int)(LPARAM)w;
				p->i1 = i;
				p->i2 = (int)(LPARAM)c;
				hr = ic.Call();
			} else {
				hr = AccEnableChrome2(w, i, c);
			}
			//Perf.NW();

			if (hr == (HRESULT)eError::NotFound) {
				if (!IsWindow(w)) return;
				if (!c) break;
			}

			if (hr == (HRESULT)eError::WaitChromeDisabled && i == iTo - 1 && !c && wTL != GetForegroundWindow())
				return; //allow to retry later. See comments above about detached control.

			//if (hr == (HRESULT)eError::WaitChromeEnabledPartially) if (!inProc || !c || nPartially++ >= (i - nPartially) / 2 + 5) hr = 0;

			Sleep((inProc ? 10 : 100) + i);

			if (hr == 0) break;
			if (hr != (HRESULT)eError::NotFound) nNoDoc = 0; else if (++nNoDoc < 20) i = -1; else break;
		}
		//never mind: possible timeout with large pages or at Chrome startup. Can't wait so long here. Let scripts wait.

		WinFlags::Set(wTL, eWinFlags::AccEnabled);

		if (GetTickCount64() - t1 > 500) s_helperCallback(2, wTL); //print warning "start browser with --force-renderer-accessibility". Regardless whether enabled or not.
	}

	//Called by elmFinder before find or find-wait in window (not in elm).
	//If s is a role prefix like "web:", detects/returns browser type flags for Cpp_AccFindParams::flags2.
	//Else returns 0.
	//If detects Chrome, enables its acc.
	EXPORT eAF2 Cpp_AccRolePrefix(STR s, int len, HWND w) {
		eAF2 R = {};
		HWND c = 0;
		int prefix = str::Switch(s, len, { L"web", L"chrome", L"firefox" });
		if (prefix > 0) {
			switch (prefix) {
			case 1:
				R |= eAF2::InWebPage;
				if (wn::Style(w) & WS_CHILD) {
					switch (wn::ClassNameIs(w, { c_CRW, c_IES })) {
					case 1: R |= eAF2::InChromePage; c = w; break;
					case 2: R |= eAF2::InIES; break;
					}
				} else {
					switch (wn::ClassNameIs(w, { L"Chrome*", L"Mozilla*" })) {
					case 1: R |= eAF2::InChromePage; break;
					case 2: R |= eAF2::InFirefoxPage; break;
					}
				}
				//info: if no InIES|InChromePage|InFirefoxPage, Cpp_AccFind will try to find IES or CRW in w and use it instead of w.
				//	Not here, because need to seach in each Cpp_AccFind when waiting.
				break;
			case 2:
				R |= eAF2::InChromePage | eAF2::InWebPage;
				if ((wn::Style(w) & WS_CHILD) && wn::ClassNameIs(w, c_CRW)) c = w;
				break;
			case 3:
				R |= eAF2::InFirefoxPage | eAF2::InWebPage;
				break;
			}

			if (!!(R & eAF2::InChromePage)) {
				if (c) w = GetAncestor(c, GA_ROOT);
				AccEnableChrome(w, c);
			}
		}
		return R;
	}

}


================================================
FILE: Cpp/acc func.cpp
================================================
#include "stdafx.h"
#include "cpp.h"
#include "acc.h"

void Cpp_Acc::SetRoleByte() { misc.roleByte = ao::GetRoleByte(acc, elem); }

#pragma region navigate

namespace {

	struct NavdirAndCount {
		int navDir, count;
	};

	//Converts navigation string to NavdirAndCount[n] array. Will need to delete[] it.
	//Positive values - NAVDIR_X
	//Returns null if s is invalid, eg contains unknown strings or invalid count.
	NavdirAndCount* Navig_Parse(STR s, out int& n) {
		auto len = str::Len(s); if (len < 2) return null;
		STR eos = s + len;
		n = (int)std::count(s, eos, ' ') + 1;
		auto a = new NavdirAndCount[n];
		int i = 0;
		for (STR start = s; s <= eos; ) {
			if (*s == ' ' || s == eos) {
				int navDir, count; STR s2, s3;
				if (*start == '#') { //custom, or by numeric value
					navDir = strtoi(++start, (LPWSTR*)&s2);
					if (s2 == start) goto ge;
				} else {
					//find the end of the name part, because it can be followed by a number, like "child3" or ne,3"
					s2 = start; while (s2 < s && *s2 >= 'a' && *s2 <= 'z') s2++;
					navDir = str::Switch(start, s2 - start, { L"ne", L"pr", L"fi", L"la", L"pa", L"ch", L"next", L"previous", L"first", L"last", L"parent", L"child" });
					if (navDir > 0) navDir += (navDir < 7) ? 4 : -2;
					else { //rarely supported/used
						navDir = str::Switch(start, s2 - start, { L"up", L"do", L"le", L"ri", L"down", L"left", L"right" });
						if (navDir == 0) goto ge;
						if (navDir >= 5) navDir -= 3;
					}
				}
				if (s2 < s) {
					if (*s2 == ',') s2++;
					count = strtoi(s2, (LPWSTR*)&s3);
					if (s3 != s || count == 0 || (count < 0 && navDir != NAVDIR_CHILD)) goto ge;
				} else count = 1;
				NavdirAndCount x = { navDir, count };
				a[i++] = x;
				start = ++s;
			} else s++;
		}
		assert(i == n);
		//for(int i = 0; i < n; i++) Printf(L"%i %i", a[i].navDir, a[i].count);
		return a;
	ge:
		delete[] a;
		n = 0;
		return null;
	}

	//Compares an AO with other AOs using some properties - rectangle, role.
	struct AccComparer {
	private:
		RECT _rect;
		Bstr _roleStr;
		int _roleInt;
		int _inited; //0 no, 1 yes, -1 failed
	public:
		AccComparer() noexcept { ZEROTHIS; }

		//Gets properties of the AO that will be compared with other AOs.
		//Does nothing if already done (can be called multiple times).
		//Returns false if failed to get properties.
		bool Init(AccRaw a) {
			if (_inited == 0) {
				_inited = -1;
				if (0 != a.accLocation(out _rect) || IsRectEmpty(&_rect)) return false;
				if (!a.GetRoleIntOrString(out _roleInt, out _roleStr.m_str)) return false;
				_inited = 1;
			}
			return _inited == 1;
		}

		//Compares properties of another AO with properties of the Init AO.
		//Returns true if they match.
		//Init must be called and succeeded (asserts).
		bool Match(AccRaw a) {
			assert(_inited == 1); if (_inited != 1) return false;
			RECT rect2;
			if (0 != a.accLocation(out rect2) || !EqualRect(&rect2, &_rect)) return false;
			int ri; Bstr rs; if (!a.GetRoleIntOrString(out ri, out rs.m_str)) return false;
			if (ri != _roleInt) return false;
			if (rs && !rs.Equals(_roleStr, false)) return false;
			return true;
		}
	};

	bool Navig_Alt(AccContext& context, int navDir, AccRaw af, out AccRaw& ar) {
		ar.acc = null; ar.elem = 0;
		bool R = false;
		if (navDir == NAVDIR_FIRSTCHILD || navDir == NAVDIR_LASTCHILD) {
			if (af.elem != 0) return false;
			AccChildren c(ref context, ref af, navDir == NAVDIR_FIRSTCHILD ? 1 : -1, true);
			R = c.GetNext(out ar);
		} else if (navDir == NAVDIR_NEXT || navDir == NAVDIR_PREVIOUS) {

			//Get parent, then enum its children to find af by rect/role and get next.
			//	note: cannot compare IAccessibles, they always different.

			Cpp_Acc aParent;
			bool releaseParent;
			if (af.elem != 0) {
				aParent.acc = af.acc;
				releaseParent = false;
				//never mind: faster would be just to use af.elem-1 or af.elem+1 (with get_accChildCount) and try get_accChild. But less reliable (for some AO get_accChild fails). Anyway, non-0 af.elem is quite rare.
			} else {
				if (0 != ao::get_accParent(af.acc, out aParent.acc)) return false;
				releaseParent = true;
				//note: will get wrong AO if get_accParent is broken.
				//	For example WinForms TOOLBAR gets parent WINDOW which does not exist in the tree (must get parent of that WINDOW).
				//		Then this func gets WINDOW's child MENUBAR or SCROLLBAR which does not exist in the tree.
				//		Noticed it in our editor.
				//	We cannot detect/workaround it, or it would be too difficult/unreliable/slow. Better let the user try another way.
			}

			int retry = false; int foundAt = -1;
		g1:
			{
				AccChildren c(ref context, ref aParent, 0, false, navDir == NAVDIR_PREVIOUS);
				AccComparer acomp;
				for (int i = 0;; i++) {
					AccDtorIfElem0 t;
					if (!c.GetNext(out t)) break;
					if (foundAt < 0) {
						if (!acomp.Init(af)) break;
						if (!acomp.Match(t)) continue;
						foundAt = i;
					} else {
						if (t.acc == aParent.acc) releaseParent = false;
						ar = t; t.acc = null;
						R = true;
						break;
					}
				}
			}

			//Workaround for bugs of some AO: get_accParent returns WINDOW that does not exist in the tree.
			//Try with parent of aParent.acc.
			//When foundAt==0, aParent.acc has single child, and it is af.
			if (!R && !retry && foundAt == 0 && af.elem == 0 && ao::GetRoleByte(aParent.acc) == ROLE_SYSTEM_WINDOW) {
				IAccessible* p2;
				if (0 == ao::get_accParent(aParent.acc, out p2)) {
					aParent.acc->Release(); aParent.acc = p2;
					retry = true; goto g1;
				}
			}
			if (releaseParent) aParent.acc->Release();
		}
		//if(R) Print("<><c 0x8000>" + t.a.ToString(t.elem) + "</c>");
		return R;
	}

	HRESULT Navig_Parent(const ref Cpp_Acc& af, ref Cpp_Acc& ar) {
		if (af.elem != 0) {
			ar.acc = af.acc; //caller must AddRef if need
		} else {
			HRESULT hr = ao::get_accParent(af.acc, out ar.acc);
			if (hr != 0) return hr;
		}
		ar.misc.flags = af.misc.flags & eAccMiscFlags::InheritMask; //InProc | UIA | Java
		if (af.elem == 0 && !!(af.misc.flags & eAccMiscFlags::Java) && *(void**)ar.acc != *(void**)af.acc) ar.misc.flags &= ~eAccMiscFlags::Java; //"frame" -> WINDOW
		return 0;
	}

	HRESULT Navig_Hresult(HRESULT hr) {
		switch (hr) {
		case DISP_E_MEMBERNOTFOUND: case E_NOTIMPL: case E_INVALIDARG: case E_FAIL: case E_NOINTERFACE: hr = 1; break;
		}
		return hr;
	}

	HRESULT Navig_Step(AccContext& context, int navDir, int childIndex, AccRaw af, out AccRaw& ar) {
		ar.acc = null; ar.elem = 0;

		if (navDir == NAVDIR_PARENT) return Navig_Parent(ref af, ref ar);

		if (af.elem != 0) if (navDir == NAVDIR_CHILD || navDir == NAVDIR_FIRSTCHILD || navDir == NAVDIR_LASTCHILD) return 1;

		HRESULT hr = 0;
		if (navDir == NAVDIR_CHILD) {
			AccChildren c(ref context, ref af, childIndex, true);
			if (!c.GetNext(out ar)) hr = 1;
			//note: for it cannot be used get_accChild. Its purpose is different. It accepts child id, not child index, which may be not the same.
		} else {
			hr = af.Navigate(navDir, out ar);
			if (hr != 0 && !(af.misc.flags & (eAccMiscFlags::UIA | eAccMiscFlags::Java))) {
				//Perf.First();
				if (Navig_Alt(ref context, navDir, af, out ar)) hr = 0;
				//Perf.NW();
			}
		}
		assert((hr != 0) == (ar.acc == null));
		if (hr == 0) {
			ar.misc.flags = af.misc.flags & eAccMiscFlags::InheritMask; //InProc | UIA | Java
		}
		return hr;
	}

} //namespace

HRESULT AccNavigate(Cpp_Acc aFrom, STR navig, out Cpp_Acc& aResult) {
	aResult.Zero();
	int n;
	auto a = Navig_Parse(navig, out n);
	if (a == null) return (HRESULT)eError::InvalidParameter;

	HRESULT hr = 0;
	AccContext context;
	AccRaw af(aFrom), ar;
	for (int i = 0; i < n; i++) {
		NavdirAndCount x = a[i];
		for (int nTimes = (x.navDir == NAVDIR_CHILD) ? 1 : x.count; nTimes > 0; nTimes--, af = ar) {
			hr = Navig_Step(ref context, x.navDir, x.count, af, out ar);
			if (af.acc != aFrom.acc && af.acc != ar.acc) af.acc->Release(); //release intermediate AOs
			if (hr != 0) goto gBreak;
		}
	}
gBreak:
	delete a;
	//ar.PrintAcc();
	if (hr != 0) return Navig_Hresult(hr);
	if (ar.acc == aFrom.acc) ar.acc->AddRef(); //"pa" when aFrom.elem!=0, or eg "fi" when ar.elem!=0
	aResult = ar;
	return 0;
}

namespace outproc {
	EXPORT HRESULT Cpp_AccNavigate(Cpp_Acc aFrom, STR navig, out Cpp_Acc& aResult) {
		HRESULT hr;

		//optimize "pa". Eg used by elm.Parent.
#if true //only if elem!=0
		if (aFrom.elem != 0 && navig[0] == 'p' && navig[1] == 'a' && (navig[2] == 0 || 0 == wcscmp(navig, L"parent"))) {
			aResult.Zero();
			Navig_Parent(ref aFrom, ref aResult);
			aFrom.acc->AddRef();
			return 0;
		}
#else //does not work with AccessibleMarshalWrapper: the returned object isn't wrapped and therefore invalid. And somehow slower (tested only with Chrome).
		if (navig[0] == 'p' && navig[1] == 'a' && (navig[2] == 0 || 0 == wcscmp(navig, L"parent"))) {
			aResult.Zero();
			hr = Navig_Parent(ref aFrom, ref aResult);
			if (hr != 0) return Navig_Hresult(hr);
			if (aResult.acc == aFrom.acc) aFrom.acc->AddRef();
			return hr;
		}
#endif

		if (!(aFrom.misc.flags & eAccMiscFlags::InProc)) {
			hr = AccNavigate(aFrom, navig, aResult);
		} else {
			aResult.Zero();
			InProcCall ic;
			auto len = str::Len(navig);
			auto memSize = sizeof(MarshalParams_AccElem) + (len + 1) * 2;
			auto p = (MarshalParams_AccElem*)ic.AllocParams(&aFrom, InProcAction::IPA_AccNavigate, memSize);
			p->elem = aFrom.elem;
			auto s = (LPWSTR)(p + 1); memcpy(s, navig, len * 2); s[len] = 0;
			hr = ic.Call();
			if (hr) return hr;
			hr = ic.ReadResultAcc(ref aResult);
		}
		return hr;
	}
}

#pragma endregion

#pragma region get prop

HRESULT AccWeb(IAccessible* iacc, STR what, out BSTR& sResult);

HRESULT AccGetProp(Cpp_Acc a, WCHAR prop, out BSTR& sResult) {
	sResult = null;
	auto acc = a.acc;
	_variant_t v; ao::VE ve(a.elem);
	STR role; long state, cc; RECT rect; HWND w;
	HRESULT hr = 0;

	switch (prop) {
	case 'o': case 'i': case '@':
		if (a.elem || (a.misc.flags & (eAccMiscFlags::InProc | eAccMiscFlags::UIA | eAccMiscFlags::Java)) != eAccMiscFlags::InProc) return 1;
		break;
	}

	switch (prop) {
	case 'R':
		hr = acc->get_accRole(ve, &v); if (hr != 0) break;
		role = ao::RoleToString(ref v);
		sResult = v.vt == VT_BSTR ? v.Detach().bstrVal : SysAllocString(role);
		break;
	case 'n': hr = acc->get_accName(ve, &sResult); break;
	case 'v': hr = acc->get_accValue(ve, &sResult); break;
	case 'd': hr = acc->get_accDescription(ve, &sResult); break;
	case 'h': hr = acc->get_accHelp(ve, &sResult); break;
	case 'u': //uiaid
	case 'U': //uiacn
		if (!(a.misc.flags & eAccMiscFlags::UIA)) return 1;
		ve.vt = VT_I1; ve.cVal = (char)prop; hr = acc->get_accHelp(ve, &sResult);
		break;
	case 'a': hr = acc->get_accDefaultAction(ve, &sResult); break;
	case 'k': hr = acc->get_accKeyboardShortcut(ve, &sResult); break;
	case 's':
		hr = ao::get_accState(out state, acc, a.elem);
		if (hr == 0) sResult = SysAllocStringByteLen((LPCSTR)&state, 4);
		break;
	case 'r':
	case 'D':
		hr = ao::accLocation(out rect, acc, a.elem);
		if (hr == 0) {
			if (prop == 'D' && !!(a.misc.flags & eAccMiscFlags::InProc)) {
				DpiElmScaling des(true, 0, acc);
				des.ScaleIfNeed(ref rect);
			}
			sResult = SysAllocStringByteLen((LPCSTR)&rect, 16);
		}
		break;
	case 'c':
		if (a.elem) return 1;
		hr = acc->get_accChildCount(out & cc);
		if (hr == 0) sResult = SysAllocStringByteLen((LPCSTR)&cc, 4);
		break;
	case 'w':
		hr = WindowFromAccessibleObject(acc, &w);
		if (hr == 0) sResult = SysAllocStringByteLen((LPCSTR)&w, 4);
		break;
	case 'o':
		hr = AccWeb(acc, L"'o", out sResult);
		break;
	case 'i':
		hr = AccWeb(acc, L"'i", out sResult);
		break;
	case '@':
		hr = AccWeb(acc, L"'a", out sResult);
		break;
	default: assert(false); hr = (HRESULT)eError::InvalidParameter;
	}

	if (hr != 0) {
		if (sResult != null) { SysFreeString(sResult); sResult = null; } //rare, but noticed few
	switch (hr) { case DISP_E_MEMBERNOTFOUND: case E_NOTIMPL: hr = 1; break; }
											//DISP_E_MEMBERNOTFOUND: many many. E_NOTIMPL: many.
											//note: 0x80070005 (access denied) when trying to get value of a password field.
	}
	return hr;
}

HRESULT AccGetProps(Cpp_Acc a, STR props, out BSTR& sResult) {
	sResult = null;
	str::StringBuilder s;
	s.AppendChar(0, (int)str::Len(props) * 4); //reserve for offsets
	for (int i = 0; *props; props++, i++) {
		Bstr b;
		HRESULT hr = AccGetProp(a, *props, out b.m_str);
		((int*)(LPWSTR)s)[i] = (int)s.Length(); //offset
		if (hr) {
			if (hr == (HRESULT)eError::InvalidParameter) return hr;
			continue;
		}
		s.AppendBSTR(b);
	}
	sResult = s.ToBSTR();
	return 0;
}

namespace outproc {
	//note: don't need inproc to call methods of AO that were found inproc.
	//	Call simply. Everything works as if we explicitly call inproc.
	//	Same speed, no bugs (toolbar button name, focusing standard controls).
	//	Call inproc only if may need multiple calls (Cpp_AccNavigate, Cpp_AccGetProps) or if works only inproc (Cpp_AccWeb).

	//this is called only for standard string props, like Name, Value. Not for rect, HTML attributes, etc.
	EXPORT HRESULT Cpp_AccGetStringProp(Cpp_Acc a, WCHAR prop, out BSTR& sResult) {
		return ::AccGetProp(a, prop, sResult);
	}

	EXPORT HRESULT Cpp_AccGetProps(Cpp_Acc a, STR props, out BSTR& sResult) {
		if (!(a.misc.flags & eAccMiscFlags::InProc)) return AccGetProps(a, props, out sResult);

		sResult = null;
		InProcCall ic;
		auto len = str::Len(props);
		auto memSize = sizeof(MarshalParams_AccElem) + (len + 1) * 2;
		auto p = (MarshalParams_AccElem*)ic.AllocParams(&a, InProcAction::IPA_AccGetProps, memSize);
		p->elem = a.elem;
		auto s = (LPWSTR)(p + 1); memcpy(s, props, len * 2); s[len] = 0;
		HRESULT hr = ic.Call();
		if (hr) return hr;
		sResult = ic.DetachResultBSTR();
		return 0;
	}

	//If a found inproc, gets raw rect (DPI-unscaled). To get physical rect use Cpp_AccGetProps('D').
	EXPORT HRESULT Cpp_AccGetRect(Cpp_Acc a, out RECT& r) {
		return ao::accLocation(out r, a.acc, a.elem);
	}

	EXPORT HRESULT Cpp_AccGetRole(Cpp_Acc a, out int& roleInt, out BSTR& roleStr) {
		roleInt = 0; roleStr = null;
		assert(a.misc.roleByte == 0 || a.misc.roleByte == ROLE_CUSTOM);
		_variant_t vr;
		HRESULT hr = ao::GetRoleIntAndVariant(a.acc, a.elem, out roleInt, out vr);
		if (hr == 0 && vr.vt == VT_BSTR) {
			ao::RoleToString(ref vr); //lcase if need
			roleStr = vr.Detach().bstrVal;
		}
		return hr;
	}

	EXPORT HRESULT Cpp_AccGetInt(Cpp_Acc a, WCHAR what, out long& R) {
		R = 0;
		switch (what) {
		case 's': return ao::get_accState(out R, a.acc, a.elem);
		case 'c': return a.acc->get_accChildCount(&R);
		case 'w': goto g1;
		}
		return E_INVALIDARG;
	g1:
		//Outproc WindowFromAccessibleObject is very slow when the AO retrieved using navigation.
		//	Then MSAA walks ancestors until finds WINDOW. Makes many RPC if outproc.

		if (!(a.misc.flags & eAccMiscFlags::InProc)) {
			HWND w; HRESULT hr = WindowFromAccessibleObject(a.acc, &w);
			if (hr == 0) R = (long)(LPARAM)w;
			return hr;
		}

		InProcCall ic;
		ic.AllocParams(&a, InProcAction::IPA_AccGetWindow, sizeof(MarshalParams_Header));
		HRESULT hr = ic.Call();
		if (hr) return hr;
		R = *(long*)ic.GetResultBSTR();
		return 0;
	}

	namespace {
		void AGS_Add(Cpp_Acc a, ref VARIANT& v, ref CSimpleArray<AccRaw>& t) {
			AccRaw r;
			if (0 == r.FromVARIANT(a.acc, ref v, true)) {
				if (r.elem) r.acc->AddRef();
				r.misc.flags = a.misc.flags & eAccMiscFlags::InheritMask;
				t.Add(r);
			}
		}
	}

	EXPORT HRESULT Cpp_AccGetSelection(Cpp_Acc a, out BSTR& sResult) {
		//info: here we don't call inproc because usually the speed is not important.

		sResult = null;
		assert(a.elem == 0);
		_variant_t v;
		HRESULT hr = a.acc->get_accSelection(&v);
		if (hr == 0 && v.vt != 0) {
			CSimpleArray<AccRaw> t;
			if (v.vt == VT_UNKNOWN) {
				Smart<IEnumVARIANT> e;
				if (0 == v.punkVal->QueryInterface(&e)) {
					for (;;) {
						_variant_t vv; ULONG n;
						if (e->Next(1, &vv, &n) || n != 1) break;
						AGS_Add(a, ref vv, ref t);
					}
				}
			} else {
				AGS_Add(a, ref v, ref t);
			}
			if (t.GetSize() > 0) sResult = SysAllocStringLen((STR)t.GetData(), t.GetSize() * sizeof(AccRaw));
		}

		return hr;
	}
} //namespace outproc

#pragma endregion

#pragma region actions

namespace outproc {
	//action: 'a' accDoDefaultAction, 'v' put_accValue(param), 's' scrollto (only UIA)
	EXPORT HRESULT Cpp_AccAction(Cpp_Acc a, WCHAR action, BSTR param) {
		VARIANT ve = {}; ve.vt = VT_I4; ve.lVal = a.elem;
		HRESULT hr;
		switch (action) {
		case 'a':
			if (param) { //Java action
				assert(!!(a.misc.flags & eAccMiscFlags::Java));
				ve.vt = VT_BSTR; ve.bstrVal = param;
			}
			hr = a.acc->accDoDefaultAction(ve);
			break;
		case 'v':
			hr = a.acc->put_accValue(ve, param);
			break;
		case 's': //ScrollTo
		case 'c': //Check
		case 'E': //Expand(true)
		case 'e': //Expand(false)
			assert(!!(a.misc.flags & eAccMiscFlags::UIA));
			ve.vt = VT_I1; ve.cVal = (char)action;
			hr = a.acc->accDoDefaultAction(ve);
			break;
		default: assert(false); hr = (HRESULT)eError::InvalidParameter;
		}

		if (hr == DISP_E_MEMBERNOTFOUND) hr = 1;
		return hr;
	}

	EXPORT HRESULT Cpp_AccSelect(Cpp_Acc a, long flagsSelect) {
		return a.acc->accSelect(flagsSelect, ao::VE(a.elem));
	}
}

#pragma endregion


================================================
FILE: Cpp/acc get.cpp
================================================
#include "stdafx.h"
#include "cpp.h"
#include "acc.h"

namespace outproc {
	void AccEnableChrome(HWND w, HWND c = 0);
}

namespace {

	eSpecWnd _IsSpecWnd(HWND wTL, HWND w) {
		if (w != wTL) {
			switch (wn::ClassNameIs(w, { c_CRW, L"Chrome_WidgetWin_1" })) {
			case 1: return eSpecWnd::ChromeControl; //eg WebView2
			case 2: return eSpecWnd::ChromeControl2;
			}
		}
		int i = wn::ClassNameIs(wTL, { L"Chrome*", L"SunAwt*", L"SAL*FRAME", L"Mozilla*" });
		if (i > 0 && w != wTL && i != (int)_IsSpecWnd(w, w)) i = 0; //if control, ignore if classname not similar
		return (eSpecWnd)i;
	}

	bool _IsContainer(BYTE role) {
		switch (role) {
		case ROLE_SYSTEM_APPLICATION:
		case ROLE_SYSTEM_CLIENT:
		case ROLE_SYSTEM_DIALOG:
			//case ROLE_SYSTEM_DOCUMENT: //often either empty or contains many slow elements
		case ROLE_SYSTEM_GROUPING:
		case ROLE_SYSTEM_PAGETABLIST:
		case ROLE_SYSTEM_PANE:
		case ROLE_SYSTEM_PROPERTYPAGE:
		case ROLE_SYSTEM_WINDOW:
			return true;
		}
		return false;
	}

	bool _IsStaticTextImage(int role, IAccessible* iacc) {
		if (role == ROLE_SYSTEM_STATICTEXT || role == ROLE_SYSTEM_GRAPHIC) return true;
		if (role != ROLE_SYSTEM_TEXT) return false;
		long state = 0;
		return 0 == ao::get_accState(state, iacc) && 0 == (state & (STATE_SYSTEM_FOCUSABLE | STATE_SYSTEM_UNAVAILABLE));
	}

	void _FromPoint_GetLink(ref IAccessible*& a, ref long& elem, ref BYTE& role, bool isUIA) {
		//note: the child AO of LINK/BUTTON can be anything except LINK/BUTTON, although usually TEXT, STATICTEXT, IMAGE.
		if (ao::IsLinkOrButton(role)) return;
		IAccessible* parent = null;
		if (elem != 0) parent = a; else if (0 != ao::get_accParent(a, out parent)) return;
		BYTE role2 = ao::GetRoleByte(parent);
		bool useParent = ao::IsLinkOrButton(role2);
		if (!useParent) {
			switch (role2) {
			case ROLE_SYSTEM_STATICTEXT:
				useParent = role == ROLE_SYSTEM_STATICTEXT; //eg WPF label control
				break;
			case 0: case ROLE_CUSTOM: case ROLE_SYSTEM_GROUPING: case ROLE_SYSTEM_GRAPHIC:
				break;
			default:
				if (!isUIA || role2 == ROLE_SYSTEM_LISTITEM || role2 == ROLE_SYSTEM_OUTLINEITEM || role2 == ROLE_SYSTEM_MENUITEM) {
					if (_IsStaticTextImage(role, a)) {
						long cc = 0;
						//Perf.First();
						//get_accChildCount can be very slow if UIA, eg in Firefox big pages.
						//	TODO3: if UIA, try something faster, eg get next/previous sibling of a. See UIAccessible::accNavigate.
						useParent = 0 == parent->get_accChildCount(&cc) && cc == 1;
						//Perf.NW();
						if (useParent) {
							Bstr bn;
							useParent = (0 == parent->get_accName(ao::VE(), &bn)) && bn && bn.Length() > 0;
						}

					}
				}
				break;
			}
		}
		if (useParent) {
			//bug in old Chrome and secondary windows of Firefox: AO retrieved with get_accParent is invalid, eg cannot get its window.
			HWND wp;
			if (elem == 0 && 0 != WindowFromAccessibleObject(parent, &wp)) {
				PRINTF(L"Cannot get parent LINK because WindowFromAccessibleObject would fail.");
				useParent = false;
			}
			if (useParent) {
				if (elem != 0) elem = 0; else util::Swap(ref a, ref parent);
				role = role2;
			}
		}
		if (parent != a) parent->Release();
		//rejected: support > 1 level. The capturing tool in C# supports it.
	}

	//Get UIA element from same point. If its size is < 0.5 than of the AO, use it. Dirty, but in most cases works well.
	bool _FromPoint_UiaWorkaround(POINT p, ref Smart<IAccessible>& iacc, ref long& elem, BYTE role) {
		//note: don't ignore when has children. Eg can be WINDOW, and its child count is not 0.

		Smart<IAccessible> auia;
		if (0 != AccUiaFromPoint(p, &auia)) return false; //speed: same inproc and outproc. AOFP usually inproc faster, outproc similar or slower.
		//Perf.Next('u');

		ao::VE ve; long x1, y1, x2, y2, wid1, hei1, wid2, hei2;
		if (0 != iacc->accLocation(&x1, &y1, &wid1, &hei1, ao::VE(elem)) || 0 != auia->accLocation(&x2, &y2, &wid2, &hei2, ve)) return false;
		__int64 sq1 = (__int64)wid1 * hei1, sq2 = (__int64)wid2 * hei2;
		if (!(sq2 < sq1 / 2 && sq2 > 0)) return false;

		//auia may be DOCUMENT with rect = the visible page area, whereas iacc is eg a much bigger GROUPING.
		if (ao::GetRoleByte(auia, 0) == ROLE_SYSTEM_DOCUMENT) return false;

		//Printf(L"{%i %i %i %i} {%i %i %i %i} 0x%X 0x%X", x1, y1, wid1, hei1, x2, y2, wid2, hei2, role, ao::GetRoleByte(auia, 0));

		//TODO3: although smaller, in some cases it can be not a descendant. Often cannot detect it reliably. Some reasons:
		// 1. UIA filters out some objects.
		// 2. UIA sometimes gets different rect for same object. Eg clips treeitem if part of its text is offscreen.
		//Print("--------");
		//ao::PrintAcc(iacc);
		//for(IAccessible* a = auia, *pa = null; ; a = pa) {
		//	ao::PrintAcc(a);
		//	bool ok = 0 == a->get_accParent((IDispatch**)&pa);
		//	if(a != auia) a->Release();
		//	if(!ok) return false;
		//	if(//ao::GetRoleByte(pa) == role && //no, can be different, eg iacc CLIENT but pa WINDOW
		//		0 == pa->accLocation(&x2, &y2, &wid2, &hei2, ve) && x2 == x1 && y2 == y1 && wid2 == wid1 && hei2 == hei1) { //does not work too
		//		Print("OK");
		//		pa->Release();
		//		break;
		//	}
		//}

		iacc.Swap(ref auia);
		elem = 0;
		return true;
	}

#define E_FP_RETRY 0x2001

	//Sometimes, while we are injecting dll etc, window from point changes. Then need to retry.
	//	Else can be incorrect result; in some cases Delm and this thread can deadlock, eg when AccUiaFromPoint tries to get element from Delm.
	bool _FromPoint_ChangedWindow(HWND w, POINT p) {
		HWND w2 = WindowFromPoint(p);
		if (w2 == w || GetWindowThreadProcessId(w2, nullptr) == GetCurrentThreadId()) return false;
		//wn::PrintWnd(w2);
		PRINTS_IF(IsWindowVisible(w) && GetKeyState(1) >= 0, L"changed window from point. It's OK if occasionally, eg when resizing or moving."); //often when closing or resizing w
		return true;
		//This isn't fast and very reliable, but probably better than nothing. Maybe will need to reject after more testing.
		//	Window from point can change between WindowFromPoint and AccUiaFromPoint. Never seen, but possible.
		//	PhysicalToLogicalPoint isn't perfect. Bugs, 1-pixel error.
	}
#define RETRY_IF_CHANGED_WINDOW if(inProc && _FromPoint_ChangedWindow(wFP, p)) return E_FP_RETRY

	HRESULT _AccFromPoint(POINT p, HWND wFP, eXYFlags flags, eSpecWnd specWnd, out Cpp_Acc& aResult) {
		//Perf.First();
		Smart<IAccessible> iacc; long elem = 0;
		eAccMiscFlags miscFlags = {};
		BYTE role = 0;
		bool inProc = !(flags & eXYFlags::NotInProc);
	g1:
		RETRY_IF_CHANGED_WINDOW;
		//Perf.Next('w');
		if (!!(flags & eXYFlags::UIA)) {
			HRESULT hr = AccUiaFromPoint(p, &iacc);
			if (hr != 0) return hr;
			miscFlags |= eAccMiscFlags::UIA;
			//Perf.Next('p');
		} else {
			VARIANT v;
			HRESULT hr = AccessibleObjectFromPoint(p, &iacc, &v);
			if (hr == 0 && !iacc) hr = E_FAIL;
			if (hr != 0) { //rare. Examples: treeview in HtmlHelp 2; Windows Security. Then UIA works.
				if (!!(flags & eXYFlags::OrUIA)) { flags |= eXYFlags::UIA; goto g1; }
				return hr;
			}
			assert(v.vt == VT_I4 || v.vt == 0);
			elem = v.vt == VT_I4 ? v.lVal : 0;
			//Perf.Next('p');

			role = ao::GetRoleByte(iacc, elem);
			//Perf.Next('r');

			//UIA?
			if (specWnd == eSpecWnd::None && role != ROLE_CUSTOM && !!(flags & eXYFlags::OrUIA) && _IsContainer(role)) { //and ignore elem
				RETRY_IF_CHANGED_WINDOW;
				if (_FromPoint_UiaWorkaround(p, ref iacc, ref elem, role)) {
					miscFlags |= eAccMiscFlags::UIA;
					//PRINTF(L"switched to UIA.  p={%i, %i}  role=0x%X  w=%i  cl=%s", p.x, p.y, role, (int)(LPARAM)wFP, GetCommandLineW());
				}
				//Perf.Next('X');
			}
		}
		RETRY_IF_CHANGED_WINDOW;
		//Perf.Next('w');

		bool isUIA = !!(miscFlags & eAccMiscFlags::UIA);
		if (isUIA) role = ao::GetRoleByte(iacc);
		if (!!(flags & eXYFlags::PreferLink)) _FromPoint_GetLink(ref iacc.p, ref elem, ref role, isUIA);
		//Perf.NW('Z');

		aResult.acc = iacc.Detach(); aResult.elem = elem;
		aResult.misc.flags = miscFlags;
		aResult.misc.roleByte = role;
		return 0;
	}

#pragma comment(lib, "comctl32.lib")

	LRESULT CALLBACK _FromPoint_Subclass(HWND w, UINT m, WPARAM wParam, LPARAM lParam, UINT_PTR uIdSubclass, DWORD_PTR dwRefData) {
		auto R = DefSubclassProc(w, m, wParam, lParam);
		if (m == WM_NCHITTEST && R == HTTRANSPARENT) R = HTCLIENT;
		return R;
	}
} //namespace

HRESULT AccFromPoint(POINT p, HWND wFP, eXYFlags flags, eSpecWnd specWnd, out Cpp_Acc& aResult) {
	//Workaround for: WindowFromPoint (and AccessibleObjectFromPoint etc) works differently inproc.
	//	Inproc it sends WM_NCHITTEST and skips that window if returns HTTRANSPARENT.
	//	Then the API gets wrong window, which even can be of another thread (then inproc has no sense).
	//	Workaround: subclass the window and disable HTTRANSPARENT.
	//		But only if another thread. Else skips controls covered by a transparent groupbox etc.
	bool transp = !(flags & eXYFlags::NotInProc)
		&& SendMessage(wFP, WM_NCHITTEST, 0, MAKELPARAM(p.x, p.y)) == HTTRANSPARENT
		&& GetWindowThreadProcessId(WindowFromPoint(p), null) != GetCurrentThreadId();
	if (transp) SetWindowSubclass(wFP, _FromPoint_Subclass, 1, 0);
	HRESULT hr;
	__try { hr = _AccFromPoint(p, wFP, flags, specWnd, out aResult); }
	__finally { if (transp) RemoveWindowSubclass(wFP, _FromPoint_Subclass, 1); }
	return hr;
}

namespace outproc {
	EXPORT HRESULT Cpp_AccFromPoint(POINT p, eXYFlags flags, Cpp_AccFromPointCallbackT callback, out Cpp_Acc& aResult) {
		//Perf.First();
		aResult.Zero();

		HRESULT R;
		auto flags0 = flags;
		POINT p0 = p;

		//About WindowFromPhysicalPoint:
		//	On Win8.1+ it's the same as WindowFromPoint. In DPI-aware thread uses physical point, in unaware logical.
		//	On Win7/8 WindowFromPhysicalPoint uses physical point, WindowFromPoint logical (when in a scaled window).
		HWND wFP = WindowFromPhysicalPoint(p); //never mind: skips disabled controls. It's even better with Chrome and Firefox.
	gRetry:
		HWND wTL = GetAncestor(wFP, GA_ROOT);
		if (!wTL) return 1; //let the caller retry

		ao::TempSetScreenReader tsr;
		eSpecWnd specWnd = _IsSpecWnd(wTL, wFP);
		if (specWnd == eSpecWnd::Java) {
			WINDOWINFO wi = { sizeof(wi) };
			if (GetWindowInfo(wFP, &wi) && PtInRect(&wi.rcClient, p)) {
				auto ja = AccJavaFromPoint(p, wFP);
				if (ja != null) {
					aResult.acc = ja;
					aResult.misc.flags = eAccMiscFlags::Java;
					aResult.misc.roleByte = ROLE_CUSTOM;
					return 0;
				}
			}
			//specWnd = eSpecWnd::None;
		} else if (specWnd == eSpecWnd::Chrome) {
			AccEnableChrome(wTL);
			//note: now can get wrong AO, although the above func waits for new good DOCUMENT (max 3 s).
			//	Chrome updates web page AOs lazily. The speed depends on web page. Can get wrong AO even after loong time.
			//	Or eg can be good AO, but some its properties are still not set.
			//	This func doesn't know what AO must be there, and cannot wait.
			//	Instead, where need such reliability, the caller script can eg wait for certain AO (role LINK etc) at that point.
		} else if (specWnd == eSpecWnd::ChromeControl) {
			AccEnableChrome(wTL, wFP);
		} else if (specWnd == eSpecWnd::OO) { //OpenOffice, LibreOffice
			tsr.Set(wTL);
			//OpenOffice bug: crashes on exit if AccessibleObjectFromPoint or AccessibleObjectFromWindow called with SPI_GETSCREENREADER.
			//	Could not find a workaround.
			//	Inspect.exe too.
			//	Does not if SPI_GETSCREENREADER was when starting OO.
			//	Does not if we get certain AO (eg DOCUMENT), eiher from point or when searching, now or later. Crashes eg if the AO is a toolbar button.
			//	Tested only with Writer.
			//	tested: inproc does not help.
			//	This info is old, maybe now something changed. Anyway, OpenOffice often crashes when using its AO.
		}

		//The caller may want to modify flags depending on window. Also need to detect DPI-scaled windows (I don't want to duplicate the code here).
		//	Use callback because this func can retry with another window.
		flags = callback(flags0, wFP, wTL);
		if (!!(flags & eXYFlags::Fail_)) return 1;

		//If the window is DPI-scaled, if inproc, convert physical to logical point.
		if (!!(flags & eXYFlags::DpiScaled_)) {
			assert(dlapi.minWin81 ? !(flags & eXYFlags::NotInProc) : !!(flags & eXYFlags::UIA));
			p = p0;
			if (!dlapi.PhysicalToLogicalPoint(wFP, &p)) {
				PRINTS(L"PhysicalToLogicalPoint failed");
				return E_FAIL;
				//The API fails when:
				//	- The point is not in the window. After WindowFromPhysicalPoint the window could be moved, resized or closed.
				//		Here could retry WindowFromPhysicalPoint. But it never happened when testing. Never mind.
				//	- The DPI-scaled window is in 2 screens and the point is in certain area in wrong screen.
				//		Never mind. It's rare and usually temporary.
				//		With flags NotInProc+UIA (Win8.1+) often works, but not always. In this case it's better to fail.
				//API bug: in some cases when the window is in 2 screens, the API scales the point although the window isn't scaled.
				//	Good: on Win10 then skips this code because the callback reliably detects DPI-scaled windows.
			}
			//Printf(L"phy={%i %i}  log={%i %i}", p0.x, p0.y, p.x, p.y);
		}
		//How 'from point' and 'get rect' API work with DPI-scaled windows:
		//Win10 and 8.1:
		//	MSAA/inproc - good. For 'from point' need logical coord. After 'get rect' need to convert logical to physical.
		//	MSAA/notinproc - bad, random, unusable.
		//	UIA/inproc - good. For 'from point' need logical coord. After 'get rect' need to convert logical to physical.
		//	UIA/notinproc - good.
		//Win7 and 8.0:
		//	MSAA/inproc - good in most cases. With some elements bad 'get rect', especially if found not by 'from point'.
		//	MSAA/notinproc - same as inproc.
		//	UIA/inproc - bad, random, almost unusable. For 'from point' need logical coord. Randomly bad 'get rect' (we don't scale it).
		//	UIA/notinproc - same as inproc.

	gNotinproc:
		if (!!(flags & eXYFlags::NotInProc)) {
			if (!!(flags & eXYFlags::DpiScaled_)) {
				if (dlapi.minWin81) flags |= eXYFlags::UIA;
				else p0 = p; //UIA
			}

			R = AccFromPoint(p0, wFP, flags, specWnd, out aResult);
			return R;
		}

		Cpp_Acc_Agent aAgent;
		if (0 != (R = InjectDllAndGetAgent(wFP, out aAgent.acc))) {
			switch ((eError)R) {
			case eError::WindowOfThisThread: case eError::UseNotInProc: case eError::Inject: break;
			default: return R;
			}
			flags |= eXYFlags::NotInProc; goto gNotinproc;
		}

		InProcCall ic;
		auto x = (MarshalParams_AccFromPoint*)ic.AllocParams(&aAgent, InProcAction::IPA_AccFromPoint, sizeof(MarshalParams_AccFromPoint));
		x->p = p;
		x->flags = flags;
		x->specWnd = specWnd;
		x->wFP = (int)(LPARAM)wFP;
		if (0 != (R = ic.Call())) {
			if (R == E_FP_RETRY) {
				HWND w2 = WindowFromPhysicalPoint(p);
				if (w2 != wFP) { wFP = w2; goto gRetry; }
				flags |= eXYFlags::NotInProc; goto gNotinproc;
			}
			return R;
		}
		//Perf.Next();
		R = ic.ReadResultAcc(ref aResult);
		//Perf.NW();
		return R;
	}
} //namespace outproc

HRESULT AccGetFocused(HWND w, eFocusedFlags flags, out Cpp_Acc& aResult) {
	if (!!(flags & eFocusedFlags::UIA)) {
		HRESULT hr = AccUiaFocused(&aResult.acc);
		if (hr != 0) return hr;
		aResult.misc.flags = eAccMiscFlags::UIA;
	} else {
		Smart<IAccessible> aw;
		HRESULT hr = AccessibleObjectFromWindow(w, OBJID_CLIENT, IID_IAccessible, (void**)&aw);
		if (hr != 0) return hr;

		AccRaw a1(aw, 0), a2; bool isThis;
		hr = a1.DescendantFocused(out a2, out isThis); if (hr != 0) return hr;
		if (isThis) {
			aw.Detach();
			aResult = a1;
		} else {
			aResult = a2;

			//never mind: cannot get focused AO of UIA-only windows, eg Java FX.
		}
	}
	return 0;
}

namespace outproc {
	//w - must be the focused control or window.
	EXPORT HRESULT Cpp_AccGetFocused(HWND w, eFocusedFlags flags, out Cpp_Acc& aResult) {
		aResult.Zero();

		HWND wTL = GetAncestor(w, GA_ROOT);
		//if(!wTL || wTL != GetForegroundWindow()) return 1; //return quickly, anyway would fail. No, does not work with some windows.
		if (!wTL) return 1;

		ao::TempSetScreenReader tsr;
		eSpecWnd specWnd = _IsSpecWnd(wTL, w);
		if (specWnd == eSpecWnd::Java) {
			auto ja = AccJavaFromWindow(w, true);
			if (ja != null) {
				aResult.acc = ja;
				aResult.misc.flags = eAccMiscFlags::Java;
				return 0;
			}
		} else if (specWnd == eSpecWnd::Chrome) {
			AccEnableChrome(w);
		} else if (specWnd == eSpecWnd::ChromeControl) {
			AccEnableChrome(wTL, w);
		} else if (specWnd == eSpecWnd::ChromeControl2) {
			//if WebView, focused is parent control (class Chrome_WidgetWin_1) of the c_CRW control. Need c_CRW to enable AO.
			HWND w2 = wn::FindWndExVisible(w, c_CRW);
			if (w2) AccEnableChrome(wTL, w2);
		} else if (specWnd == eSpecWnd::OO) { //OpenOffice, LibreOffice
			tsr.Set(wTL);
			//OpenOffice bug: crashes. More info in Cpp_AccFromPoint.
		}

	gNotinproc:
		if (!!(flags & eFocusedFlags::NotInProc)) {
			return AccGetFocused(w, flags, out aResult);
		}

		HRESULT R = 0;
		Cpp_Acc_Agent aAgent;
		if (0 != (R = InjectDllAndGetAgent(w, out aAgent.acc))) {
			switch ((eError)R) {
			case eError::WindowOfThisThread: case eError::UseNotInProc: case eError::Inject: break;
			default: return R;
			}
			flags |= eFocusedFlags::NotInProc; goto gNotinproc;
		}

		InProcCall ic;
		auto x = (MarshalParams_AccFocused*)ic.AllocParams(&aAgent, InProcAction::IPA_AccFocused, sizeof(MarshalParams_AccFocused));
		x->hwnd = (int)(LPARAM)w;
		x->flags = flags;
		if (0 != (R = ic.Call())) return R;
		return ic.ReadResultAcc(ref aResult);
	}
} //namespace outproc


================================================
FILE: Cpp/acc java.cpp
================================================
#include "stdafx.h"
#include "cpp.h"
#include "acc.h"
#include "JAB.h"

//Tested Java Swing apps:
//	Java Control Panel. Installed with Java.
//	Android Studio. Large.
//	PyCharm. Similar to Android Studio.
//	NetBeans.
//	Sweet Home 3D. Has a child control with HWND. Tested 32-bit with the ini workaround; failed to start 64-bit.
//	muCommander. Its listviews are detached from tree and cannot be found, but "from point" works.
//	RuneLite. Has 2 child controls.
//	FreeMind, JDiskReport, Art Of Illusion. Nothing special.
//High DPI: Most are system-aware. PyCharm and muCommander are PM-aware, but need scaling anyway. NetBeans marks itself as DPI-aware but is unscaled.
//Also would like to test Matlab and some Oracle apps, but failed to download. And not freeware.
//More can be found here: https://wiki.archlinux.org/title/list_of_applications

//Tested JavaFX apps: BlueJ and two other. For JavaFX need UIA, not JAB. MSAA does not work.

namespace jab
{
_JApi s_api;

struct _DPI_INFO { int wX, wY, jX, jY; double f; };
bool _GetDpiInfo(out _DPI_INFO& d, HWND w, long vmID, JObject frame);

#ifdef _DEBUG
void _PrintElem(long vmID, JObject j, STR prefix = L"") {
	AccessibleContextInfo c;
	if(j == 0) Print("j 0");
	else if(s_api.getAccessibleContextInfo(vmID, j, &c)) {
		HWND w = s_api.getHWNDFromAccessibleContext(vmID, j);
		Printf(L"%s%s  {%i %i %i %i}  cc=%i  hwnd=%i", prefix, c.role_en_US, c.x, c.y, c.width, c.height, c.childrenCount, (int)(LPARAM)w);
	} else Print("getAccessibleContextInfo failed");
}

void _PrintElemAndAncestors(long vmID, JObject j) {
	for(auto v = j; v;) {
		_PrintElem(vmID, v);
		HWND h = s_api.getHWNDFromAccessibleContext(vmID, v);
		if(h) wn::PrintWnd(h);
		auto t = v; v = s_api.getAccessibleParentFromContext(vmID, v);
		if(t != j) s_api.releaseJavaObject(vmID, t);
	}
}
#endif

class JAccessible : public IAccessible
{
	long _cRef;
	long _vmID;
	JObject _jo;
	HWND _hwnd; //need this field not only for speed, but also because getHWNDFromAccessibleContext in some cases cannot be used, for example when this object or an ancestor is disconnected from the tree

public:
#pragma region ctor, dtor
	JAccessible(JObject jo, int vmID, HWND hwnd)
	{
		//PRINTS(L"JAccessible");
		_cRef = 1;
		_jo = jo; _vmID = vmID; _hwnd = hwnd;
	}

	~JAccessible()
	{
		//PRINTS(L"~JAccessible");
		s_api.releaseJavaObject(_vmID, _jo);
		_ReleaseObjectInfoCache(); //a new variable may be allocated in the same place soon
	}
#pragma endregion

#pragma region IDispatch
	STDMETHODIMP QueryInterface(REFIID iid, void** ppv)
	{
		if(iid == IID_IAccessible || iid == IID_IDispatch || iid == IID_IUnknown) {
			InterlockedIncrement(&_cRef);
			*ppv = this;
			return 0;
		}
		*ppv = 0;
		return E_NOINTERFACE;
	}

	STDMETHODIMP_(ULONG) AddRef()
	{
		return InterlockedIncrement(&_cRef);
	}

	STDMETHODIMP_(ULONG) Release()
	{
		long ret = InterlockedDecrement(&_cRef);
		if(!ret) delete this;
		return ret;
	}

	STDMETHODIMP GetTypeInfoCount(UINT* pctinfo) { return E_NOTIMPL; }

	STDMETHODIMP GetTypeInfo(UINT iTInfo, LCID lcid, ITypeInfo** ppTInfo) { return E_NOTIMPL; }

	STDMETHODIMP GetIDsOfNames(REFIID riid, LPOLESTR* rgszNames, UINT cNames, LCID lcid, __RPC__out_ecount_full(cNames) DISPID* rgDispId) { return E_NOTIMPL; }

	STDMETHODIMP Invoke(DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS* pDispParams, VARIANT* pVarResult, EXCEPINFO* pExcepInfo, UINT* puArgErr) { return E_NOTIMPL; }
#pragma endregion

#pragma region IAccessible
	STDMETHODIMP get_accParent(IDispatch** ppdispParent)
	{
		//PRINTS(__FUNCTIONW__);
		*ppdispParent = null;

		//For owned dialogs etc GetAccessibleParentFromContext(dialog) gets a half-valid object of the owner window.
		//Instead get standard WINDOW object. May need it for WindowFromAccessibleObject.
		auto w = s_api.getHWNDFromAccessibleContext(_vmID, _jo);
		if(w) {
			return AccessibleObjectFromWindow(w, OBJID_WINDOW, IID_IAccessible, (void**)ppdispParent);
			//never mind: if control...
		}

		auto jo = s_api.getAccessibleParentFromContext(_vmID, _jo); if(!jo) return 1;
		*ppdispParent = new JAccessible(jo, _vmID, _hwnd); //never mind: may need to update hwnd. Cannot get it reliably.
		return 0;
	}

	STDMETHODIMP get_accChildCount(long* pcountChildren)
	{
		//PRINTS(__FUNCTIONW__);
		auto k = _GetObjectInfo(); if(k == null) return E_FAIL;
		*pcountChildren = k->childrenCount;
		return 0;
	}

	STDMETHODIMP get_accChild(VARIANT varChild, IDispatch** ppdispChild)
	{
		//PRINTS(__FUNCTIONW__);
		int i = varChild.lVal - 1;
		if(varChild.vt != VT_I4 || i < 0) return E_INVALIDARG;
		auto jo = s_api.getAccessibleChildFromContext(_vmID, _jo, i);
		if(jo == 0) {
			auto k = _GetObjectInfo();
			if(k != null && i >= k->childrenCount) return E_INVALIDARG;
			return E_FAIL;
		}
		*ppdispChild = new JAccessible(jo, _vmID, _hwnd); //can use same hwnd, because the tree does not have controls
		return 0;
	}

	STDMETHODIMP get_accName(VARIANT varChild, out BSTR* pszName)
	{
		//PRINTS(__FUNCTIONW__);
		if(_InvalidVarChildParam(ref varChild)) return E_INVALIDARG;
		WCHAR m[MAX_STRING_SIZE];
		if(!s_api.getVirtualAccessibleName(_vmID, _jo, m, MAX_STRING_SIZE)) return E_FAIL;
		*pszName = SysAllocString(m);
		return 0;

		//getVirtualAccessibleName is better than getAccessibleContextInfo (GACI).
		//It gets names of toolbar buttons. With GACI, name empty, we can use description.
		//It gets name of related control - adjacent label etc.
		//Much faster than GACI.
		//Makes searching ~10% slower when GACI is cached, but not when role used (not called if role does not match).
	}

	STDMETHODIMP get_accValue(VARIANT varChild, out BSTR* pszValue)
	{
		//PRINTS(__FUNCTIONW__);
		if(_InvalidVarChildParam(ref varChild)) return E_INVALIDARG;
		auto k = _GetObjectInfo(); if(k == null) return E_FAIL;
		*pszValue = null;
		if(k->accessibleValue) {
			WCHAR m[MAX_STRING_SIZE];
			if(s_api.getCurrentAccessibleValueFromContext(_vmID, _jo, m, MAX_STRING_SIZE)) //speed: 20 times faster than getAccessibleContextInfo
				*pszValue = SysAllocString(m);
		} else {
			AccessibleTextInfo ati;
			if(k->accessibleText && s_api.getAccessibleTextInfo(_vmID, _jo, &ati, 0, 0)) { //slow
				auto b = SysAllocStringLen(null, ati.charCount);
				if(ati.charCount == 0 || s_api.getAccessibleTextRange(_vmID, _jo, 0, ati.charCount - 1, b, ati.charCount)) *pszValue = b;
				else SysFreeString(b);
			}
		}
		return *pszValue == null ? 1 : 0;

		//tested: most objects don't have value/text. Value usually is numeric, eg "1" for checked checkbox. Text objects don't have value, therefore we get text instead.
		//AccessibleContextInfo::accessibleInterfaces flags, from AccessibleBridgePackages.h (cAccessibleValueInterface etc):
		//	1 value, 2 actions, 4 component, 8 selection, 0x10 table, 0x20 text, 0x40 hypertext.
	}

	STDMETHODIMP get_accDescription(VARIANT varChild, out BSTR* pszDescription)
	{
		//PRINTS(__FUNCTIONW__);
		if(_InvalidVarChildParam(ref varChild)) return E_INVALIDARG;
		auto k = _GetObjectInfo(); if(k == null) return E_FAIL;
		*pszDescription = k->description.Copy();
		return 0;
	}

	STDMETHODIMP get_accRole(VARIANT varChild, out VARIANT* pvarRole)
	{
		//PRINTS(__FUNCTIONW__);
		if(_InvalidVarChildParam(ref varChild)) return E_INVALIDARG;
		auto k = _GetObjectInfo(); if(k == null) return E_FAIL;
		return k->role.CopyTo(pvarRole);
	}

	STDMETHODIMP get_accState(VARIANT varChild, out VARIANT* pvarState)
	{
		//PRINTS(__FUNCTIONW__);
		if(_InvalidVarChildParam(ref varChild)) return E_INVALIDARG;
		auto k = _GetObjectInfo(); if(k == null) return E_FAIL;
		pvarState->vt = VT_I4;
		pvarState->lVal = k->state;
		return 0;
	}

	STDMETHODIMP get_accHelp(VARIANT varChild, out BSTR* pszHelp) { return E_NOTIMPL; }

	STDMETHODIMP get_accHelpTopic(BSTR* pszHelpFile, VARIANT varChild, long* pidTopic) { return E_NOTIMPL; }

	STDMETHODIMP get_accKeyboardShortcut(VARIANT varChild, out BSTR* pszKeyboardShortcut) { return E_NOTIMPL; }

	STDMETHODIMP get_accFocus(out VARIANT* pvarChild) { return E_NOTIMPL; }
	//Difficult to implement so that would work correctly, ie return direct child even if focused is another descendant.
	//getAccessibleContextWithFocus is unstable. More often does not work than works.
	//Rarely used.

	STDMETHODIMP get_accSelection(out VARIANT* pvarChildren) { return E_NOTIMPL; }
	//Rarely used.

	STDMETHODIMP get_accDefaultAction(VARIANT varChild, out BSTR* pszDefaultAction)
	{
		//PRINTS(__FUNCTIONW__);
		if(_InvalidVarChildParam(ref varChild)) return E_INVALIDARG;
		return _get_accDefaultAction(out * pszDefaultAction, true);
	}

	HRESULT _get_accDefaultAction(out BSTR& b, bool getList)
	{
		b = null;
		auto k = _GetObjectInfo(); if(k == null) return E_FAIL;
		if(!k->accessibleAction) return 1;
		std::unique_ptr<AccessibleActions> actions(new(AccessibleActions)); //130 KB
		HRESULT hr = 1; int n;
		if(s_api.getAccessibleActions(_vmID, _jo, actions.get()) && (n = actions->actionsCount) > 0 && n <= MAX_ACTION_INFO) {
			hr = 0;
			if(!getList || n == 1) b = SysAllocString(actions->actionInfo[0].name);
			else {
				str::StringBuilder t;
				for(int i = 0; i < n; i++) {
					if(i) t << L", ";
					t << actions->actionInfo[i].name;
				}
				b = t.ToBSTR();
			}
		}
		return hr;
	}

	STDMETHODIMP accSelect(long flagsSelect, VARIANT varChild)
	{
		//PRINTS(__FUNCTIONW__);
		if(_InvalidVarChildParam(ref varChild)) return E_INVALIDARG;
		if(flagsSelect & SELFLAG_EXTENDSELECTION) return E_INVALIDARG;
		if(flagsSelect & (SELFLAG_TAKESELECTION | SELFLAG_ADDSELECTION | SELFLAG_REMOVESELECTION)) {
			auto k = _GetObjectInfo(); if(k == null) return E_FAIL;
			auto ap = s_api.getAccessibleParentFromContext(_vmID, _jo); if(ap == 0) return E_FAIL;
			_ReleaseObjectInfoCache(); //the action changes object state
			int i = k->indexInParent;
			if(flagsSelect & SELFLAG_TAKESELECTION) s_api.clearAccessibleSelectionFromContext(_vmID, ap);
			if(flagsSelect & (SELFLAG_TAKESELECTION | SELFLAG_ADDSELECTION)) s_api.addAccessibleSelectionFromContext(_vmID, ap, i);
			if(flagsSelect & SELFLAG_REMOVESELECTION) s_api.removeAccessibleSelectionFromContext(_vmID, ap, i);
			s_api.releaseJavaObject(_vmID, ap);
		}
		if(flagsSelect & SELFLAG_TAKEFOCUS) {
			_ReleaseObjectInfoCache(); //the action changes object state
			if(!s_api.requestFocus(_vmID, _jo)) return E_FAIL;
		}
		return 0;
	}

	STDMETHODIMP accLocation(out long* pxLeft, out long* pyTop, out long* pcxWidth, out long* pcyHeight, VARIANT varChild)
	{
		//PRINTS(__FUNCTIONW__);
		if(_InvalidVarChildParam(ref varChild)) return E_INVALIDARG;
		auto k = _GetObjectInfo(); if(k == null) return E_FAIL;
		*pxLeft = k->x; *pyTop = k->y; *pcxWidth = k->width; *pcyHeight = k->height;

		//DPI-scale if need. Without it this func is useless when high DPI.
		//	In all tested apps the API gets logical coord. The physical view is scaled either by OS or by Java. In some not scaled (NetBeans).
		//	Makes >2 times slower, eg 4 -> 9 ms. Cannot use any faster ways, because apps use different scaling (offsets etc).
		long vmID; AccessibleContext jw;
		if(s_api.getAccessibleContextFromHWND(_hwnd, &vmID, &jw)) { //note: getTopLevelObject faster, but in some cases gets wrong object
			_DPI_INFO d;
			if(_GetDpiInfo(out d, _hwnd, vmID, jw)) {
				*pxLeft = d.wX + (int)round((*pxLeft - d.jX) * d.f);
				*pyTop = d.wY + (int)round((*pyTop - d.jY) * d.f);
				*pcxWidth = (int)round(*pcxWidth * d.f);
				*pcyHeight = (int)round(*pcyHeight * d.f);
			}
			s_api.releaseJavaObject(vmID, jw);
		}

		return 0;
	}

	STDMETHODIMP accNavigate(long navDir, VARIANT varStart, out VARIANT* pvarEndUpAt)
	{
		//Print("accNavigate", navDir, varStart.vt, varStart.value);

		//WindowFromAccessibleObject (WFAO) at first calls this with an undocumented navDir 10.
		//	tested: accNavigate(10) for a standard Windows control returns VARIANT(VT_I4, hwnd).
		//	If we return window handle, WFAO does not call get_accParent. Else also calls it for each ancestor.
		if(navDir == 10 && varStart.vt == VT_I4) {
			pvarEndUpAt->vt = VT_I4;
			pvarEndUpAt->lVal = (int)(LPARAM)_hwnd;
			return 0;
		}

		if(navDir < NAVDIR_UP || navDir > NAVDIR_LASTCHILD) return E_INVALIDARG;
		if(_InvalidVarChildParam(ref varStart)) return E_INVALIDARG;
		JObject ac = 0;

		if(navDir >= NAVDIR_NEXT && navDir <= NAVDIR_LASTCHILD) {
			int iChild = -1; JObject ap = 0; _JObjectInfo* k = null;
			if(navDir != NAVDIR_FIRSTCHILD && null == (k = _GetObjectInfo())) return 1;
			switch(navDir) {
			case NAVDIR_FIRSTCHILD: iChild = 0; ap = _jo; break; //GetAccessibleChildFromContext will fail if this does not have children
			case NAVDIR_LASTCHILD: iChild = k->childrenCount - 1; ap = _jo; break;
			case NAVDIR_NEXT: iChild = k->indexInParent + 1; break; //GetAccessibleChildFromContext will fail if this is the last
			case NAVDIR_PREVIOUS: iChild = k->indexInParent - 1; break;
			}
			if(iChild >= 0) {
				if(ap == 0) ap = s_api.getAccessibleParentFromContext(_vmID, _jo);
				if(ap != 0) { ac = s_api.getAccessibleChildFromContext(_vmID, ap, iChild); if(ap != _jo) s_api.releaseJavaObject(_vmID, ap); }
			}
		}

		if(ac == 0) return 1;
		pvarEndUpAt->pdispVal = new JAccessible(ac, _vmID, _hwnd); //can use same hwnd, because the tree does not have controls
		pvarEndUpAt->vt = VT_DISPATCH;
		return 0;
	}

	STDMETHODIMP accHitTest(long xLeft, long yTop, out VARIANT* pvarChild) { return E_NOTIMPL; }
	//Rarely used.

	STDMETHODIMP accDoDefaultAction(VARIANT varChild)
	{
		BSTR name = null; int len = 0; Bstr name_;
		if(varChild.vt == VT_BSTR) {
			len = SysStringLen(name = varChild.bstrVal);
			if(len >= SHORT_STRING_SIZE) return E_INVALIDARG;
		} else if(_InvalidVarChildParam(ref varChild)) return E_INVALIDARG;

		if(len == 0) {
			if(_InvalidVarChildParam(ref varChild)) return E_INVALIDARG;
			int hr = _get_accDefaultAction(out name, false);
			if(hr != 0) return hr == 1 ? DISP_E_MEMBERNOTFOUND : E_FAIL;
			name_.Attach(name);
			len = name_.Length();
		}
		_ReleaseObjectInfoCache(); //the action may change object props
		AccessibleActionsToDo atd; //16 KB
		atd.actionsCount = 1;
		memcpy(atd.actions, name, (len + 1) * 2);
		jint failure;
		if(!s_api.doAccessibleActions(_vmID, _jo, &atd, &failure)) {
			//PRINTI(failure); //0-based index of the first action that failed or is unknown, or -1 if not action-related
			return E_FAIL;
		}
		return 0;
	}

	STDMETHODIMP put_accName(VARIANT varChild, BSTR szName) { return E_NOTIMPL; }
	//Rarely used, deprecated.

	STDMETHODIMP put_accValue(VARIANT varChild, BSTR szValue)
	{
		if(_InvalidVarChildParam(ref varChild)) return E_INVALIDARG;
		if(!s_api.setTextContents(_vmID, _jo, szValue)) return 1;
		_ReleaseObjectInfoCache();
		return 0;
	}
#pragma endregion

#pragma region get object info

	//s_api.getAccessibleContextInfo gets multiple properties (name, state, etc) that are then used by multiple JAccessible functions.
	//It is slow etc. We call it once and store the retrieved/converted properties in a thread-static variable t_joInfo. Not in JAccessible because big.
	//t_joInfo is used for all JAccessible instances, but owned by a single JAccessible instance at a time.

	//internal
	struct _JObjectInfo
	{
		Bstr /*name,*/ description, role;
		int indexInParent, childrenCount;
		int x, y, width, height;
		bool accessibleComponent, accessibleAction, accessibleSelection, accessibleText, accessibleValue;
		int state;
		LONGLONG time;
		JAccessible* owner;

		void Init(const AccessibleContextInfo& c)
		{
			//name = c.name;
			description = c.description;
			role = c.role_en_US;
			indexInParent = c.indexInParent; childrenCount = c.childrenCount;
			x = c.x; y = c.y; width = c.width; height = c.height;
			accessibleComponent = c.accessibleComponent != 0; accessibleAction = c.accessibleAction != 0; accessibleSelection = c.accessibleSelection != 0; accessibleText = c.accessibleText != 0;
			accessibleValue = (c.accessibleInterfaces & 1) != 0;

			state = STATE_SYSTEM_READONLY | STATE_SYSTEM_UNAVAILABLE | STATE_SYSTEM_INVISIBLE;
			for(STR s = c.states_en_US; *s;) {
				STR se = s; while(*se && *se != ',') se++;
				switch(str::Switch(s, (int)(se - s), { L"busy",L"checked",L"collapsed",L"editable",L"enabled",L"expanded",L"focusable",L"focused",L"indeterminate",L"modal",L"multiselectable",L"pressed",L"resizable",L"selectable",L"selected",L"showing",L"visible" })) {
				case 1: state |= STATE_SYSTEM_BUSY; break;
				case 2: state |= STATE_SYSTEM_CHECKED; break;
				case 3: state |= STATE_SYSTEM_COLLAPSED; break;
				case 4: state &= ~STATE_SYSTEM_READONLY; break;
				case 5: state &= ~STATE_SYSTEM_UNAVAILABLE; break;
				case 6: state |= STATE_SYSTEM_EXPANDED; break;
				case 7: state |= STATE_SYSTEM_FOCUSABLE; break;
				case 8: state |= STATE_SYSTEM_FOCUSED; break;
				case 9: state |= STATE_SYSTEM_INDETERMINATE; break;
				case 10: state |= STATE_SYSTEM_HASPOPUP; break;
				case 11: state |= STATE_SYSTEM_MULTISELECTABLE; break;
				case 12: state |= STATE_SYSTEM_PRESSED; break;
				case 13: state |= STATE_SYSTEM_SIZEABLE; break;
				case 14: state |= STATE_SYSTEM_SELECTABLE; break;
				case 15: state |= STATE_SYSTEM_SELECTED; break;
				case 16: state &= ~STATE_SYSTEM_INVISIBLE; break;
				case 17: if(width > 0 && height > 0) state &= ~STATE_SYSTEM_INVISIBLE; break;
				}
				if(*se == 0) break;
				s = se + 1;
			}
		}
	};

	static _JObjectInfo& __JoInfo() {
		thread_local static _JObjectInfo t_joInfo;
		return t_joInfo;
	}

	_JObjectInfo* _GetObjectInfo()
	{
		_JObjectInfo& k = __JoInfo();
		if(k.owner != this || GetTickCount64() - k.time > 10) {
			AccessibleContextInfo c;
			if(!s_api.getAccessibleContextInfo(_vmID, _jo, &c)) return null;
			k.Init(ref c);
			k.time = GetTickCount64();
			k.owner = this;
		}
		return &k;
	}

	bool _IsObjectInfoCached()
	{
		_JObjectInfo& k = __JoInfo();
		return k.owner == this && GetTickCount64() - k.time <= 10;
	}

	void _ReleaseObjectInfoCache()
	{
		_JObjectInfo& k = __JoInfo();
		if(k.owner == this) k.owner = null;
	}

#pragma endregion

#pragma region private
private:
	bool _InvalidVarChildParam(const VARIANT& v)
	{
		if(v.vt == 0) return false; //forgive
		return v.vt != VT_I4 || v.lVal != 0;
	}

	//HWND _GetHWND()
	//{
	//	if(_hwnd) return _hwnd;

	//	auto joTL = s_api.getTopLevelObject(_vmID, _jo);
	//	if(joTL != 0) {
	//		//_PrintElem(_vmID, joTL);

	//		HWND w = s_api.getHWNDFromAccessibleContext(_vmID, joTL);
	//		s_api.releaseJavaObject(_vmID, joTL);
	//		return _hwnd = w;
	//	}
	//	return 0;
	//}
#pragma endregion
};

int s_inited;

DWORD WINAPI _JabThread(LPVOID param)
{
	//How JAB works:
	//_InitJab loads JAB dll and functions, and calls Windows_run.
	//Windows_run creates a hidden dialog "Access Bridge status" and posts "AccessBridge-FromJava-Hello" messages to all top-level windows.
	//Java JAB-enabled processes also have hidden "Access Bridge status" dialogs. They run in a separate thread.
	//These dialogs, when received our hello message, post back the message to our dialog. wParam is poster dialog hwnd.
	//Only when our dialog receives these messages, we can get accessible context of that Java windows.
	//Therefore we must have a message loop etc. We use this thread for it.
	//Alternatively, each thread could call Windows_run and DoEvents etc, but then we would have multiple dialogs. Also would need DoEvents before each GetAccessibleContextFromHWND etc, or it would fail with Java windows created later.
	//Note: JAB events work only in thread that called Windows_run. Currently not using events. Not tested much. When tested with JavaFerret, most events either didn't work or used to stop working etc.

	UINT m1 = RegisterWindowMessageW(L"AccessBridge-FromWindows-Hello"); //received by our hidden "Access Bridge status" dialog once after _InitJab
	UINT m2 = RegisterWindowMessageW(L"AccessBridge-FromJava-Hello"); //received by the dialog from each JAB-enabled Java window
	ChangeWindowMessageFilter(m1, 1); ChangeWindowMessageFilter(m2, 1);

	s_api.Windows_run(); //the slowest part, ~10 ms when warm CPU, else 10-33 ms

	int i, nmsg; MSG msg;
	for(i = 0; i < 10; i++) {
		for(nmsg = 0; PeekMessageW(&msg, 0, 0, 0, PM_REMOVE); nmsg++) DispatchMessageW(&msg);
		if(nmsg == 0 && i > 0) break; //non-Java windows that use JAB (probably as client) don't post back the message
		Sleep(1);
	}
	PRINTF_IF(i > 2, L"i=%i", i); //test reliability in stress conditions. When testing, was 1 almost always, rarely 2, once >2.

	s_inited = 1;
	SetEvent(param);

	while(GetMessageW(&msg, 0, 0, 0) > 0) DispatchMessageW(&msg);
	s_inited = 0;

	return 0;
}

bool _InitJab()
{
	if(s_inited == 0) {
		static CComAutoCriticalSection _cs; CComCritSecLock<CComAutoCriticalSection> lock(_cs);
		if(s_inited == 0) {
			s_inited = -1;
			s_api.Load();
			if(s_api.IsLoaded()) {
				//FUTURE: Time.LibSleepPrecision.LibTempSet1(1);
				CHandle ev(CreateEventW(null, true, false, null));
				DWORD tid;
				HANDLE ht = CreateThread(null, 0, _JabThread, ev, 0, &tid);
				if(ht) {
					HANDLE ha[2] = { ev, ht };
					WaitForMultipleObjects(2, ha, false, INFINITE);
					CloseHandle(ht);
				}
			}
		}
	}
	return s_inited > 0;
}

bool _NoJab() { return s_inited < 0; }

//Returns true if w process has a JAB hidden dialog ("Access Bridge status", "#32770").
//It can be a Java window or a JAB client, but not a window of this process.
//speed: faster than AccessibleObjectFromWindow. Much faster than _JApi::isJavaWindow, and don't need to load dll etc.
//w class name must match "SunAwt*" (asserts).
bool _IsJavaWindow(HWND w)
{
	//if(wn::Style(w) & WS_CHILD) return false; //no, some Java windows have controls with similar classname
	assert(wn::ClassNameIs(w, L"SunAwt*") || !::IsWindow(w));

	auto wf = WinFlags::Get(w);
	if(!!(wf & eWinFlags::AccJavaYes)) return true;
	if(!!(wf & eWinFlags::AccJavaNo)) return false;

	bool yes = false; DWORD pid = 0, pidJAB = 0;
	for(HWND wJAB = 0; wJAB = wn::FindWndEx(0, wJAB, L"#32770", L"Access Bridge status");) {
		if(pid == 0 && !GetWindowThreadProcessId(w, &pid)) break;
		GetWindowThreadProcessId(wJAB, &pidJAB); if(pidJAB != pid) continue;
		yes = pid != GetCurrentProcessId();
		break;
	}

	WinFlags::Set(w, yes ? eWinFlags::AccJavaYes : eWinFlags::AccJavaNo);
	return yes;
}

JObject _JObjectFromWindow(HWND w, out long& vmID, bool getFocused = false)
{
	vmID = 0;
	if(!_IsJavaWindow(w)) return 0;
	if(!_InitJab()) return 0;
	JObject jo;
	auto f = getFocused ? s_api.getAccessibleContextWithFocus : s_api.getAccessibleContextFromHWND;
	if(!f(w, &vmID, &jo)) return 0;

	//In tested Java window with controls the API gets wrong object. Then cannot find etc. Should be its parent.
	//  This code fixes it.
	//  Note: don't use getTopLevelObject. It randomly gets the same object as now or the window's root frame (bad).
	if(!getFocused && (wn::Style(w) & WS_CHILD)) {
		AccessibleContextInfo ci;
		if(s_api.getAccessibleContextInfo(vmID, jo, &ci) && ci.childrenCount == 0) {
			auto pa = s_api.getAccessibleParentFromContext(vmID, jo);
			if(pa) {
				int x = ci.x, y = ci.y, wid = ci.width, hei = ci.height;
				if(s_api.getAccessibleContextInfo(vmID, pa, &ci) && ci.childrenCount > 0 && ci.x == x && ci.y == y && ci.width == wid && ci.height == hei) {
					auto bad = jo; jo = pa; s_api.releaseJavaObject(vmID, bad);
				} else s_api.releaseJavaObject(vmID, pa);
			}
		}
	}

	return jo;
}

IAccessible* AccFromWindow(HWND w, bool getFocused = false)
{
	if(_NoJab()) return null;
	long vmID;
	JObject jo = _JObjectFromWindow(w, out vmID, getFocused); if(jo == 0) return null;
	return new JAccessible(jo, vmID, w);
}

//Gets window rect info for DPI correction: physical and JAB-logical x, y and scaling factor.
//Returns false if fails or if don't need DPI correction.
bool _GetDpiInfo(out _DPI_INFO& d, HWND w, long vmID, JObject frame) {
	thread_local static struct _DPI_CACHE {
		HWND w;
		RECT rw;
		LONGLONG time;
		_DPI_INFO d;
	} t_cache; //use cache because getAccessibleContextInfo is slow

	RECT rw;
	if(GetWindowRect(w, &rw)) {
		if(t_cache.w == w && !memcmp(&t_cache.rw, &rw, 16) && GetTickCount64() - t_cache.time < 5000) {
			d = t_cache.d;
			return d.f != 1.0;
		}

		AccessibleContextInfo ci;
		if(s_api.getAccessibleContextInfo(vmID, frame, &ci)) {
			//Printf(L"{%i %i %i %i}  {%i %i %i %i}", ci.x, ci.y, ci.width, ci.height, rw.left, rw.top, rw.right-rw.left, rw.bottom-rw.top);
			d.wX = rw.left; d.wY = rw.top;
			d.jX = ci.x; d.jY = ci.y;
			int wK = (rw.right - rw.left) + (rw.bottom - rw.top), jK = ci.width + ci.height;
			bool scaled = jK != wK && jK >= 16 && wK >= 16;
			d.f = scaled ? round((double)wK / jK * 100.0) / 100.0 : 1.0; //eg 1.25123 to 1.25. Never mind very small windows where the error can be too big.

			t_cache.w = w;
			t_cache.rw = rw;
			t_cache.time = GetTickCount64();
			t_cache.d = d;

			return scaled;
		}
	}
	t_cache.w = 0;
	return false;
}

bool _IsPointInRect(POINT p, AccessibleContextInfo& c) {
	return p.y >= c.y && p.y < c.y + c.height && p.x >= c.x && p.x < c.x + c.width;
}

IAccessible* AccFromPoint(POINT p, HWND w)
{
	//bool test = 0 != (GetKeyState(VK_SCROLL) & 1);
	//Perf.First();
	if(_NoJab()) return null;

	long vmID = 0;
	JObject jo = 0, ap = _JObjectFromWindow(w, out vmID);
	if(ap == 0) return null;
	//Perf.Next('w');

	//DPI-unscale if need
	_DPI_INFO d;
	if(_GetDpiInfo(out d, w, vmID, ap)) {
		p.x = (int)round(d.jX + (p.x - d.wX) / d.f);
		p.y = (int)round(d.jY + (p.y - d.wY) / d.f);
		//never mind: not perfect. Sometimes 1-pixel error.
		//Print("DPI-unscaled");
	}
	//Perf.Next('d');

	//workaround for JAB bug: if ap is a popup menu, getAccessibleContextAt randomly returns an object from parent window.
	//  Especially when high DPI. Depends on mouse movements.
	//	Same with tooltips and other cn="SunAwtWindow" windows. Not with popup menus in cn="SunAwtFrame" windows.
	//	Cannot detect whether the object is good or bad. In both cases getTopLevelObject and getAccessibleParentFromContext skip ap.
	//	Therefore even don't try getAccessibleContextAt at first.
	if(wn::ClassNameIs(w, L"SunAwtWindow")) {
		std::function<AccessibleContext(AccessibleContext, int)> func;
		func = [&func, vmID, p](AccessibleContext ac, int level) -> AccessibleContext {
			AccessibleContextInfo c;
			if(!s_api.getAccessibleContextInfo(vmID, ac, &c)) return 0;
			bool notThis = false;
			if(!_IsPointInRect(p, c)) {
				if(c.childrenCount == 0 || wcscmp(c.role_en_US, L"page tab")) return 0;
				//Usually page tab's rect is just the button, and children are in the page below.
				//	Any object can have such children. Eg tree view. But enumerating all would be too slow.
				notThis = true;
			}
			if(!wcsstr(c.states_en_US, L"showing")) return 0; //s_api.getVisibleChildren checks this state
			//Printf(L"%i %i %s  states=%s", level, c.childrenCount, c.role_en_US, c.states_en_US);
			if(c.childrenCount > 0 && c.childrenCount <= 100 && wcscmp(c.role_en_US, L"menu")) {
				//Enumerate in reverse order, because:
				// 1. Else could find the first child of the root pane, eg in Android Studio Settings.
				// 2. Finds links in paragraphs.
				// The root pane usually has 2 children, and the first is an invisible zero-rect pane. But in some windows it has properties like visible.
				// Actually should be used algorithm "find smallest object containing p". This algorithm is "find first object containing p".
				// But that algorithm would be slower, because need to enum entire tree in all cases.
				// What is really important, this algorithm works well with all tested menus. Other windows not so important.
				//for(int i = 0; i < c.childrenCount; i++) {
				for(int i = c.childrenCount; --i >= 0; ) {
					auto k = s_api.getAccessibleChildFromContext(vmID, ac, i);
					if(k) {
						auto v = func(k, level + 1);
						if(k != v) s_api.releaseJavaObject(vmID, k);
						if(v) return v;
					}
				}
			}
			return notThis ? 0 : ac;
		};
		jo = func(ap, 0);
		//if(jo) _PrintElem(vmID, jo);
		//Perf.Next('m');
	}

	if(!jo) {
		if(!s_api.getAccessibleContextAt(vmID, ap, p.x, p.y, &jo)) {
			jo = 0;
			PRINTS(L"failed 1");
		} else if(jo == 0) {
			PRINTS(L"failed 2");
			//JAB bug: jo is 0 if the window never received a mouse message.
			//	Could post message now, but it's too dirty.
			//  Randomly fails in other cases too, and the workaround does not help then, but can cause blinking etc.
			//	Never mind.
			//PostMessageW(w, WM_MOUSEMOVE, 0, 0);
			//for(int i = 0; i < 10; i++) {
			//	Sleep(15); SendMessageTimeoutW(w, 0, 0, 0, SMTO_ABORTIFHUNG, 1000, null);
			//	if(s_api.getAccessibleContextAt(vmID, ap, p.x, p.y, &jo) && jo != 0) break; jo=0;
			//}
		} else {
			//Perf.Next('p');
			//_PrintElem(vmID, ap, L"----- ");
			//_PrintElemAndAncestors(vmID, jo);

			//workaround for:
			//	1. JAB gives empty rect for some objects. Some such objects also are disconnected from DOM and therefore cannot be found. Then use parent.
			//	2. If on a menubar item, jo often is the first item of the popup menu. Then wrong _hwnd etc.
			AccessibleContextInfo ci;
			if(s_api.getAccessibleContextInfo(vmID, jo, &ci) && !_IsPointInRect(p, ci)) {
				auto pa = s_api.getAccessibleParentFromContext(vmID, jo);
				//_PrintElem(vmID, pa);
				if(pa) {
					if(s_api.getAccessibleContextInfo(vmID, pa, &ci) && _IsPointInRect(p, ci)) {
						auto bad = jo; jo = pa; s_api.releaseJavaObject(vmID, bad);
					} else s_api.releaseJavaObject(vmID, pa);
				}
			}
		}
	}
	//Perf.Next('P');

	s_api.releaseJavaObject(vmID, ap);
	//Perf.NW('r');

	if(!jo) return null;
	return new JAccessible(jo, vmID, w);
}

} //namespace jab

IAccessible* AccJavaFromWindow(HWND w, bool getFocused /*= false*/)
{
	return jab::AccFromWindow(w, getFocused);
}

//Gets Java accessible object from point.
//p - point in screen coordinates.
//w - window containing the point.
//alt - enumerate descendants. Slow.
IAccessible* AccJavaFromPoint(POINT p, HWND w)
{
	return jab::AccFromPoint(p, w);
}

//TODO3: when Delm creates tree and tries to find the captured object, use isSameObject, not rect+role. If possible and faster.


================================================
FILE: Cpp/acc uia.cpp
================================================
#include "stdafx.h"
#include "cpp.h"
#include "acc.h"

namespace uia {
#ifdef _DEBUG
	void PrintGuid(const GUID& g) {
		LPOLESTR os = null;
		StringFromIID(g, &os);
		Print(os);
		CoTaskMemFree(os);
	}

	void PrintUiaElem(IUIAutomationElement* e) {
		RECT r = {};
		auto hr = e->get_CurrentBoundingRectangle(&r);
		if (hr != 0) Print("bad"); else Printf(L"{%i %i %i %i}", r.left, r.top, r.right - r.left, r.bottom - r.top);
	}
#endif

	struct ThreadVar {
		Smart<IUIAutomation> uia;
		Smart<IUIAutomationCondition> rawCond;
		Smart<IUIAutomationTreeWalker> rawWalk;
	};
	thread_local ThreadVar t_var;

	IUIAutomation* UIA() {
		ThreadVar& tv = t_var;
		if (!tv.uia) tv.uia.CoCreateInstance(osVer.minWin8() ? __uuidof(CUIAutomation8) : __uuidof(CUIAutomation), null, CLSCTX_INPROC_SERVER);
		return tv.uia;
	}

	//Used in get_accChildCount with FindAll.
	IUIAutomationCondition* CondAll() {
		ThreadVar& tv = t_var;
		//if(!t_var.rawCond) UIA()->get_RawViewCondition(&t_var.rawCond); //FindFirst/FirstAll ignores this and uses control view instead
		if (!t_var.rawCond) UIA()->get_ControlViewCondition(&t_var.rawCond);
		return t_var.rawCond;
	}

	//Used in get_accParent, accNavigate, _GetHWND.
	IUIAutomationTreeWalker* WalkAll() {
		ThreadVar& tv = t_var;
		//if(!tv.rawWalk) UIA()->get_RawViewWalker(&tv.rawWalk); //don't use this because must be consistent with FindFirst/FirstAll
		if (!tv.rawWalk) UIA()->get_ControlViewWalker(&tv.rawWalk);
		return tv.rawWalk;
	}

	static long s_uiaWrapperCount;

	//Returns false if there are UIAccessible objects in this process.
	//Then cannot unload this dll, because later will be called Release and this process would crash if unloaded.
	//Could not find a way to prevent Release. Even if client does not call it, COM calls it after 6 minutes. CoDisconnectObject prevents only other method calls.
	bool UiaDisconnectWrappers() {
		PRINTF_IF(s_uiaWrapperCount != 0, L"cannot unload dll because of %i alive UIA wrappers.  %s", s_uiaWrapperCount, GetCommandLineW());
		return s_uiaWrapperCount == 0;
	}

	class UIAccessible : public IAccessible, IEnumVARIANT {
		long _cRef;
		int _next;
		IUIAutomationElement* _ae;
		IUIAutomationElementArray* _children;
		ULONGLONG _timeOfChildren;

	public:
		UIAccessible(IUIAutomationElement* ae) {
			//PRINTF(L"+ %p", _ae);
			//ae->AddRef(); Printf(L"+ %p ref=%i tid=%i", ae, ae->Release(), GetCurrentThreadId());
			InterlockedIncrement(&s_uiaWrapperCount);

			_cRef = 1;
			_next = 0;
			_ae = ae;
			_children = null;
			_timeOfChildren = 0;
			assert(_ae != null);

		}

		~UIAccessible() {
			if (_children) _children->Release();
			_ae->Release();
			//Printf(L"- %p ref=%i tid=%i", _ae, _ae->Release(), GetCurrentThreadId());
			//note: intermediate elements still have refcount 1, because they are referenced by parent's IUIAutomationElementArray.

			//PRINTF(L"- %p", _ae);
			InterlockedDecrement(&s_uiaWrapperCount);
		}

#pragma region IUnknown, IDispatch
		STDMETHODIMP QueryInterface(REFIID iid, void** ppv) {
			//PrintGuid(iid);

			if (iid == IID_IAccessible || iid == IID_IDispatch || iid == IID_IUnknown) {
				InterlockedIncrement(&_cRef);
				*ppv = this;
				return 0;
			} else if (iid == IID_IEnumVARIANT) {
				InterlockedIncrement(&_cRef);
				*ppv = (IEnumVARIANT*)this;
				return 0;
			}
			//else if(iid == IID_IUIAutomationElement) {
			//	//note: does not work for inproc AO. This func is called, but QI (of proxy) fails. If need, try QS, not tested.
			//	//tested: IUIAutomation.ElementFromIAccessible does not QI/QS IUIAutomationElement.
			//	//Print("--UIA");
			//	_ae->AddRef();
			//	*ppv = _ae;
			//	return 0;
			//}
			//else if(iid == IID_IServiceProvider) {
			//	InterlockedIncrement(&_cRef);
			//	*ppv = (IServiceProvider*)this;
			//	return 0;
			//}

			//if(iid == IID_IOleWindow) Print("IID_IOleWindow");
			//else if(iid == IID_IServiceProvider) Print("IID_IServiceProvider");
			//else PrintGuid(iid);

			*ppv = 0;
			return E_NOINTERFACE;
		}

		STDMETHODIMP_(ULONG) AddRef() {
			return InterlockedIncrement(&_cRef);
		}

		STDMETHODIMP_(ULONG) Release() {
			long ret = InterlockedDecrement(&_cRef);
			if (!ret) delete this;
			return ret;
		}

		STDMETHODIMP GetTypeInfoCount(UINT* pctinfo) { return E_NOTIMPL; }

		STDMETHODIMP GetTypeInfo(UINT iTInfo, LCID lcid, ITypeInfo** ppTInfo) { return E_NOTIMPL; }

		STDMETHODIMP GetIDsOfNames(REFIID riid, LPOLESTR* rgszNames, UINT cNames, LCID lcid, __RPC__out_ecount_full(cNames) DISPID* rgDispId) { return E_NOTIMPL; }

		STDMETHODIMP Invoke(DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS* pDispParams, VARIANT* pVarResult, EXCEPINFO* pExcepInfo, UINT* puArgErr) { return E_NOTIMPL; }
#pragma endregion

#pragma region IEnumVARIANT
		STDMETHODIMP Next(ULONG celt, VARIANT* rgVar, ULONG* pCeltFetched) {
			//PRINTS(__FUNCTIONW__);
			if (pCeltFetched) *pCeltFetched = 0;
			long cc;
			HRESULT hr = get_accChildCount(&cc); if (hr != 0) return hr;
			//Printf(__FUNCTIONW__ L" %i %i", celt, cc);
			for (ULONG i = 0; i < celt; i++, _next++) {
				if (_next >= cc) return 1;
				IUIAutomationElement* e = null;
				HRESULT hr = _children->GetElement(_next, &e); if (hr != 0) return hr;
				rgVar[i].pdispVal = new UIAccessible(e);
				rgVar[i].vt = VT_DISPATCH;
				if (pCeltFetched) (*pCeltFetched)++;
			}
			return 0;
		}
		STDMETHODIMP Skip(ULONG celt) {
			PRINTS(__FUNCTIONW__);
			return E_NOTIMPL;
		}
		STDMETHODIMP Reset(void) {
			_next = 0;
			return 0;
		}
		STDMETHODIMP Clone(IEnumVARIANT** ppEnum) {
			PRINTS(__FUNCTIONW__);
			return E_NOTIMPL;
		}
#pragma endregion

#pragma region IAccessible
		STDMETHODIMP get_accParent(IDispatch** ppdispParent) {
			//PRINTS(__FUNCTIONW__);
			*ppdispParent = null;
			IUIAutomationElement* p = null;
			HRESULT hr = WalkAll()->GetParentElement(_ae, &p);
			//Printf(L"0x%X %p", hr, p);
			if (hr == 0 && p == null) hr = 1;
			if (hr == 0) *ppdispParent = new UIAccessible(p);
			return hr;
		}

		STDMETHODIMP get_accChildCount(long* pcountChildren) {
			//PRINTS(__FUNCTIONW__);
			//Perf.First();
			*pcountChildren = 0;
			HRESULT hr;
			if (!_children || GetTickCount64() - _timeOfChildren > 40) {
				if (_children) { _children->Release(); _children = null; }
				hr = _ae->FindAll(TreeScope::TreeScope_Children, CondAll(), &_children);
				//Printf(L"0x%X %p", hr, _children.p);
				if (hr != 0 || !_children) return hr; //msdn lies: "NULL is returned if no matching element is found"
				_timeOfChildren = GetTickCount64();
			}
			//Perf.Next(); //in some cases very slow, eg in Firefox big pages
			hr = _children->get_Length((int*)pcountChildren);
			//Perf.NW(); //0-1
			return hr;
		}

		STDMETHODIMP get_accChild(VARIANT varChild, IDispatch** ppdispChild) {
			//PRINTS(__FUNCTIONW__);
			*ppdispChild = null;
			if (varChild.vt != VT_I4) return E_INVALIDARG;
			long cc;
			HRESULT hr = get_accChildCount(&cc); if (hr != 0) return hr;
			long i = varChild.lVal - 1; if ((DWORD)i >= (DWORD)cc) return E_INVALIDARG;
			IUIAutomationElement* e = null;
			hr = _children->GetElement(i, &e);
			if (hr == 0) *ppdispChild = new UIAccessible(e);
			return hr;
		}

		STDMETHODIMP get_accName(VARIANT varChild, out BSTR* pszName) {
			//PRINTS(__FUNCTIONW__);
			if (_InvalidVarChildParam(ref varChild)) return E_INVALIDARG;
			return _ae->get_CurrentName(pszName);
		}

		STDMETHODIMP get_accValue(VARIANT varChild, out BSTR* pszValue) {
			return _GetProp(varChild, 'v', pszValue);
		}

		STDMETHODIMP get_accDescription(VARIANT varChild, out BSTR* pszDescription) {
			return _GetProp(varChild, 'd', pszDescription);
		}

		STDMETHODIMP get_accRole(VARIANT varChild, out VARIANT* pvarRole) {
			//PRINTS(__FUNCTIONW__);
			if (_InvalidVarChildParam(ref varChild)) return E_INVALIDARG;
			CONTROLTYPEID t;
			HRESULT hr = _ae->get_CurrentControlType(&t);
			if (hr == 0) {
				//https://learn.microsoft.com/en-us/windows/win32/winauto/appendix-g--active-accessibility-bridge-to-ui-automation
				int i = 0; STR s = L"unknown";
				switch (t) {
				case UIA_ButtonControlTypeId: i = ROLE_SYSTEM_PUSHBUTTON; break;
				case UIA_CalendarControlTypeId: s = L"Calendar"; break;
				case UIA_CheckBoxControlTypeId: i = ROLE_SYSTEM_CHECKBUTTON; break;
				case UIA_ComboBoxControlTypeId: i = ROLE_SYSTEM_COMBOBOX; break;
				case UIA_EditControlTypeId: i = ROLE_SYSTEM_TEXT; break;
				case UIA_HyperlinkControlTypeId: i = ROLE_SYSTEM_LINK; break;
				case UIA_ImageControlTypeId: i = ROLE_SYSTEM_GRAPHIC; break;
				case UIA_ListItemControlTypeId: i = ROLE_SYSTEM_LISTITEM; break;
				case UIA_ListControlTypeId: i = ROLE_SYSTEM_LIST; break;
				case UIA_MenuControlTypeId: i = ROLE_SYSTEM_MENUPOPUP; break;
				case UIA_MenuBarControlTypeId: i = ROLE_SYSTEM_MENUBAR; break;
				case UIA_MenuItemControlTypeId: i = ROLE_SYSTEM_MENUITEM; break;
				case UIA_ProgressBarControlTypeId: i = ROLE_SYSTEM_PROGRESSBAR; break;
				case UIA_RadioButtonControlTypeId: i = ROLE_SYSTEM_RADIOBUTTON; break;
				case UIA_ScrollBarControlTypeId: i = ROLE_SYSTEM_SCROLLBAR; break;
				case UIA_SliderControlTypeId: i = ROLE_SYSTEM_SLIDER; break;
				case UIA_SpinnerControlTypeId: i = ROLE_SYSTEM_SPINBUTTON; break;
				case UIA_StatusBarControlTypeId: i = ROLE_SYSTEM_STATUSBAR; break;
				case UIA_TabControlTypeId: i = ROLE_SYSTEM_PAGETABLIST; break;
				case UIA_TabItemControlTypeId: i = ROLE_SYSTEM_PAGETAB; break;
				case UIA_TextControlTypeId: i = ROLE_SYSTEM_STATICTEXT; break;
				case UIA_ToolBarControlTypeId: i = ROLE_SYSTEM_TOOLBAR; break;
				case UIA_ToolTipControlTypeId: i = ROLE_SYSTEM_TOOLTIP; break;
				case UIA_TreeControlTypeId: i = ROLE_SYSTEM_OUTLINE; break;
				case UIA_TreeItemControlTypeId: i = ROLE_SYSTEM_OUTLINEITEM; break;
				case UIA_CustomControlTypeId: i = ROLE_SYSTEM_CLIENT; break; //documented as the default MSAA role. And it's good for _IsContainer.
				case UIA_GroupControlTypeId: i = ROLE_SYSTEM_GROUPING; break;
				case UIA_ThumbControlTypeId: i = ROLE_SYSTEM_INDICATOR; break;
				case UIA_DataGridControlTypeId: i = ROLE_SYSTEM_LIST; break;
				case UIA_DataItemControlTypeId: i = ROLE_SYSTEM_LISTITEM; break;
				case UIA_DocumentControlTypeId: i = ROLE_SYSTEM_DOCUMENT; break;
				case UIA_SplitButtonControlTypeId: i = ROLE_SYSTEM_SPLITBUTTON; break;
				case UIA_WindowControlTypeId: i = ROLE_SYSTEM_WINDOW; break;
				case UIA_PaneControlTypeId: i = ROLE_SYSTEM_PANE; break;
				case UIA_HeaderControlTypeId: i = ROLE_SYSTEM_LIST; break;
				case UIA_HeaderItemControlTypeId: i = ROLE_SYSTEM_COLUMNHEADER; break;
				case UIA_TableControlTypeId: i = ROLE_SYSTEM_TABLE; break;
				case UIA_TitleBarControlTypeId: i = ROLE_SYSTEM_TITLEBAR; break;
				case UIA_SeparatorControlTypeId: i = ROLE_SYSTEM_SEPARATOR; break;
				case UIA_SemanticZoomControlTypeId: s = L"SemanticZoom"; break;
				case UIA_AppBarControlTypeId: s = L"AppBar"; break;
				}
				if (i) {
					pvarRole->vt = VT_I4;
					pvarRole->lVal = i;
				} else {
					pvarRole->vt = VT_BSTR;
					pvarRole->bstrVal = SysAllocString(s);
				}
			}
			return hr;
		}

		STDMETHODIMP get_accState(VARIANT varChild, out VARIANT* pvarState) {
			//PRINTS(__FUNCTIONW__);
			long state;
			HRESULT hr = _GetProp(varChild, 's', &state);
			if (hr == 0) {
				pvarState->vt = VT_I4;
				pvarState->lVal = state;
			}
			return hr;
		}

		STDMETHODIMP get_accHelp(VARIANT varChild, out BSTR* pszHelp) {
			if (varChild.vt == VT_I1) { //prop uiaid, uiacn
				switch (varChild.cVal) {
				case 'u': return _ae->get_CurrentAutomationId(pszHelp);
				case 'U': return _ae->get_CurrentClassName(pszHelp);
				}
			}
			return _GetProp(varChild, 'h', pszHelp);
		}

		STDMETHODIMP get_accHelpTopic(BSTR* pszHelpFile, VARIANT varChild, long* pidTopic) {
			return E_NOTIMPL;
		}

		STDMETHODIMP get_accKeyboardShortcut(VARIANT varChild, out BSTR* pszKeyboardShortcut) {
			return _GetProp(varChild, 'k', pszKeyboardShortcut);
		}

		STDMETHODIMP get_accFocus(out VARIANT* pvarChild) {
			return E_NOTIMPL;
			//Rarely used.
		}

		class UIAccessibleSelectedChildren : public IEnumVARIANT {
			long _cRef;
			int _next, _count;
			Smart<IUIAutomationElementArray> _a;

		public:
			UIAccessibleSelectedChildren(IUIAutomationElementArray* a, int count) : _a(a, false) {
				//PRINTS(__FUNCTIONW__);
				_cRef = 1;
				_next = 0;
				_count = count;
			}

			//~UIAccessibleSelectedChildren()
			//{
			//	PRINTS(__FUNCTIONW__);
			//}

			STDMETHODIMP QueryInterface(REFIID riid, void** ppvObject) {
				if (riid == IID_IEnumVARIANT || riid == IID_IUnknown) {
					++_cRef;
					*ppvObject = this;
					return 0;
				}
				*ppvObject = null;
				return E_NOINTERFACE;
			}
			STDMETHODIMP_(ULONG) AddRef(void) {
				return ++_cRef;
			}
			STDMETHODIMP_(ULONG) Release(void) {
				long ret = --_cRef;
				if (!ret) delete this;
				return ret;
			}
			STDMETHODIMP Next(ULONG celt, VARIANT* rgVar, ULONG* pCeltFetched) {
				if (pCeltFetched) *pCeltFetched = 0;
				for (ULONG i = 0; i < celt; i++, _next++) {
					if (_next == _count) return 1;
					IUIAutomationElement* e = null;
					HRESULT hr = _a->GetElement(_next, &e); if (hr != 0) return hr;
					rgVar[i].pdispVal = new UIAccessible(e);
					rgVar[i].vt = VT_DISPATCH;
					if (pCeltFetched) (*pCeltFetched)++;
				}
				return 0;
			}
			STDMETHODIMP Skip(ULONG celt) {
				return E_NOTIMPL;
			}
			STDMETHODIMP Reset(void) {
				_next = 0;
				return 0;
			}
			STDMETHODIMP Clone(IEnumVARIANT** ppEnum) {
				return E_NOTIMPL;
			}
		};

		STDMETHODIMP get_accSelection(out VARIANT* pvarChildren) {
			Smart<IUIAutomationSelectionPattern> p;
			HRESULT hr = _ae->GetCurrentPatternAs(UIA_SelectionPatternId, IID_PPV_ARGS(&p)); if (hr == 0 && !p) hr = 1;
			if (hr == 0) {
				Smart<IUIAutomationElementArray> a;
				hr = p->GetCurrentSelection(&a);
				if (hr == 0) {
					pvarChildren->vt = 0;
					int n; hr = a->get_Length(&n); if (hr != 0) n = 0;
					if (n == 1) {
						IUIAutomationElement* e = null;
						hr = a->GetElement(0, &e);
						if (hr == 0) {
							pvarChildren->pdispVal = new UIAccessible(e);
							pvarChildren->vt = VT_DISPATCH;
						}
					} else if (n > 1) {
						pvarChildren->punkVal = new UIAccessibleSelectedChildren(a.Detach(), n);
						pvarChildren->vt = VT_UNKNOWN;
					}
				}
			}
			return hr;
		}

		STDMETHODIMP get_accDefaultAction(VARIANT varChild, out BSTR* pszDefaultAction) {
			return _GetProp(varChild, 'a', pszDefaultAction);
		}

		STDMETHODIMP accSelect(long flagsSelect, VARIANT varChild) {
			if (_InvalidVarChildParam(ref varChild)) return E_INVALIDARG;
			if (flagsSelect & SELFLAG_EXTENDSELECTION) return E_INVALIDARG;
			HRESULT hr = 0;
			if (flagsSelect & (SELFLAG_TAKESELECTION | SELFLAG_ADDSELECTION | SELFLAG_REMOVESELECTION)) {
				Smart<IUIAutomationSelectionItemPattern> p;
				hr = _ae->GetCurrentPatternAs(UIA_SelectionItemPatternId, IID_PPV_ARGS(&p)); if (hr == 0 && !p) hr = 1;
				if (hr == 0) {
					if (flagsSelect & SELFLAG_TAKESELECTION) hr = p->Select();
					if (flagsSelect & SELFLAG_ADDSELECTION && hr == 0) hr = p->AddToSelection();
					if (flagsSelect & SELFLAG_REMOVESELECTION && hr == 0) hr = p->RemoveFromSelection();
				}
			}
			if (flagsSelect & SELFLAG_TAKEFOCUS && hr == 0) {
				hr = _ae->SetFocus();
			}
			return hr;
		}

		STDMETHODIMP accLocation(out long* pxLeft, out long* pyTop, out long* pcxWidth, out long* pcyHeight, VARIANT varChild) {
			//PRINTS(__FUNCTIONW__);
			if (_InvalidVarChildParam(ref varChild)) return E_INVALIDARG;
			RECT r;
			HRESULT hr = _ae->get_CurrentBoundingRectangle(&r);
			if (hr == 0) {
				*pxLeft = r.left; *pyTop = r.top; *pcxWidth = r.right - r.left; *pcyHeight = r.bottom - r.top;
			}
			return hr;
		}

		STDMETHODIMP accNavigate(long navDir, VARIANT varStart, out VARIANT* pvarEndUpAt) {
			//Print("accNavigate", navDir, varStart.vt, varStart.value);

			//WindowFromAccessibleObject (WFAO) at first calls this with an undocumented navDir 10.
			//	tested: accNavigate(10) for a standard Windows control returns VARIANT(VT_I4, hwnd).
			//	If we return window handle, WFAO does not call get_accParent. Else also calls it for each ancestor.
			//	Currently WFAO cannot get hwnd when calling our get_accParent.
			if (navDir == 10 && varStart.vt == VT_I4) {
				//Perf.First();
				HWND w = _GetHWND();
				//Perf.NW();
				if (w == 0) return 1;
				pvarEndUpAt->vt = VT_I4;
				pvarEndUpAt->lVal = (int)(LPARAM)w;
				return 0;
			}

			if (navDir < NAVDIR_UP || navDir > NAVDIR_LASTCHILD) return E_INVALIDARG;
			if (_InvalidVarChildParam(ref varStart)) return E_INVALIDARG;

			auto walker = WalkAll();
			IUIAutomationElement* p = null;
			HRESULT hr = 0;
			switch (navDir) {
			case NAVDIR_NEXT: hr = walker->GetNextSiblingElement(_ae, &p); break;
			case NAVDIR_PREVIOUS: hr = walker->GetPreviousSiblingElement(_ae, &p); break;
			case NAVDIR_FIRSTCHILD: hr = walker->GetFirstChildElement(_ae, &p); break;
			case NAVDIR_LASTCHILD: hr = walker->GetLastChildElement(_ae, &p); break;
			}
			if (hr == 0 && p == null) hr = 1;
			if (hr == 0) {
				pvarEndUpAt->pdispVal = new UIAccessible(p);
				pvarEndUpAt->vt = VT_DISPATCH;
			}
			return hr;
		}

		STDMETHODIMP accHitTest(long xLeft, long yTop, out VARIANT* pvarChild) {
			return E_NOTIMPL;
			//Rarely used.
		}

		//The _DDA_x functions try to get a pattern and call its method. They return true if pattern available, even if method failed.
		bool _DDA_InvokeUIA(ref HRESULT& hr) {
			Smart<IUIAutomationInvokePattern> p;
			hr = _ae->GetCurrentPatternAs(UIA_InvokePatternId, IID_PPV_ARGS(&p)); if (hr == 0 && !p) hr = 1;
			if (hr != 0) return false;
			//Print("Invoke");/
			hr = p->Invoke();
			return true;
		}

		bool _DDA_Toggle(ref HRESULT& hr) {
			Smart<IUIAutomationTogglePattern> p;
			hr = _ae->GetCurrentPatternAs(UIA_TogglePatternId, IID_PPV_ARGS(&p)); if (hr == 0 && !p) hr = 1;
			if (hr != 0) return false;
			//Print("Toggle");
			hr = p->Toggle();
			return true;
		}

		//expand: 0 collapse, 1 expand, 2 toggle
		bool _DDA_Expand(ref HRESULT& hr, int expand) {
			Smart<IUIAutomationExpandCollapsePattern> p;
			hr = _ae->GetCurrentPatternAs(UIA_ExpandCollapsePatternId, IID_PPV_ARGS(&p)); if (hr == 0 && !p) hr = 1;
			if (hr != 0) return false;
			//Print("Expand");
			if (expand == 2) {
				ExpandCollapseState ecs = ExpandCollapseState_LeafNode;
				if (0 == p->get_CurrentExpandCollapseState(&ecs)) {
					if (ecs == ExpandCollapseState_Expanded) expand = 0;
					else if (ecs != ExpandCollapseState_LeafNode) expand = 1; //collapsed or partially expanded
				} else hr = 1;
			}
			if (expand == 1) hr = p->Expand(); else if (expand == 0) hr = p->Collapse();
			return true;
		}

		bool _DDA_Select(ref HRESULT& hr) {
			Smart<IUIAutomationSelectionItemPattern> p;
			hr = _ae->GetCurrentPatternAs(UIA_SelectionItemPatternId, IID_PPV_ARGS(&p)); if (hr == 0 && !p) hr = 1;
			if (hr != 0) return false;
			//Print("Select");
			hr = p->Select();
			return true;
		}

		bool _DDA_InvokeMSAA(ref HRESULT& hr) {
			Smart<IUIAutomationLegacyIAccessiblePattern> p;
			hr = _ae->GetCurrentPatternAs(UIA_LegacyIAccessiblePatternId, IID_PPV_ARGS(&p)); if (hr == 0 && !p) hr = 1;
			if (hr != 0) return false;
			//Print("DoDefaultAction");
			hr = p->DoDefaultAction();
			return true;
		}

		STDMETHODIMP accDoDefaultAction(VARIANT varChild) {
			HRESULT hr = 1;

			if (varChild.vt == VT_I1) { //specified action
				if (varChild.cVal == 's') { //ScrollTo
					Smart<IUIAutomationScrollItemPattern> p;
					hr = _ae->GetCurrentPatternAs(UIA_ScrollItemPatternId, IID_PPV_ARGS(&p)); if (hr == 0 && !p) hr = 1;
					if (hr == 0) hr = p->ScrollIntoView();
				} else if (varChild.cVal == 'c') { //Check(true/false)
					bool ok = _DDA_Toggle(ref hr)
						|| _DDA_InvokeUIA(ref hr);
				} else if (varChild.cVal == 'E' || varChild.cVal == 'e') { //Expand(true/false)
					bool ok = _DDA_Expand(ref hr, varChild.cVal == 'E' ? 1 : 0) //treeitem, combobox
						|| _DDA_Toggle(ref hr); //some expanders
				}
			} else { //default action
				if (_InvalidVarChildParam(ref varChild)) return E_INVALIDARG;
				bool ok = _DDA_InvokeUIA(ref hr)
					|| _DDA_Toggle(ref hr)
					|| _DDA_Expand(ref hr, 2)
					|| _DDA_Select(ref hr)
					|| _DDA_InvokeMSAA(ref hr);
				//Print((DWORD)hr);

				//Many UIA elements don't have Invoke pattern but have some other pattern that can be used instead.
				//Many have IAccessible pattern, but often its DoDefaultAction doesn't work.
			}
			return hr;
		}

		STDMETHODIMP put_accName(VARIANT varChild, BSTR szName) {
			return E_NOTIMPL;
			//Rarely used, deprecated.
		}

		STDMETHODIMP put_accValue(VARIANT varChild, BSTR szValue) {
			if (_InvalidVarChildParam(ref varChild)) return E_INVALIDARG;
			Smart<IUIAutomationValuePattern> p;
			HRESULT hr = _ae->GetCurrentPatternAs(UIA_ValuePatternId, IID_PPV_ARGS(&p));
			if (hr == 0 && !p) hr = 1;
			if (hr == 0) hr = p->SetValue(szValue);
			return hr;
		}
#pragma endregion

#pragma region private
	private:
		bool _InvalidVarChildParam(const VARIANT& v) {
			if (v.vt == 0) return false; //forgive
			return v.vt != VT_I4 || v.lVal != 0;
		}

		HRESULT _GetProp(const VARIANT& varChild, WCHAR prop, void* R) {
			if (_InvalidVarChildParam(ref varChild)) return E_INVALIDARG;

			HRESULT hr = 1;
#if true
			bool useMSAA = false;
			if (prop == 'd') { //tested: most either msaa or uia; some same
				VARIANT v = {};
				hr = _ae->GetCurrentPropertyValue(UIA_FullDescriptionPropertyId, &v);
				if (hr == 0) {
					if (v.vt != VT_BSTR) { hr = 1; VariantClear(&v); } else if (SysStringLen(v.bstrVal) == 0) useMSAA = true;
					else *(BSTR*)R = v.bstrVal;
				}
			} else if (prop == 'v') { //tested: most same (msaa and uia); some only msaa (eg scrollbar arrow, rarely useful)
				Smart<IUIAutomationValuePattern> p;
				hr = _ae->GetCurrentPatternAs(UIA_ValuePatternId, IID_PPV_ARGS(&p));
				if (hr == 0 && !p) hr = 1;
				if (hr == 0) hr = p->get_CurrentValue((BSTR*)R);
			} else if (prop == 'h') { //tested: all same
				hr = _ae->get_CurrentHelpText((BSTR*)R);
			} else if (prop == 'k') { //tested: most either msaa or uia; some diff (uia better); get_CurrentAccessKey all == get_CurrentKeyboardShortcut
				hr = _ae->get_CurrentAcceleratorKey((BSTR*)R);
				if (hr == 0 && SysStringLen(*(BSTR*)R) == 0) hr = _ae->get_CurrentAccessKey((BSTR*)R);
			} else useMSAA = true;

			if (useMSAA) {
				Smart<IUIAutomationLegacyIAccessiblePattern> p;
				hr = _ae->GetCurrentPatternAs(UIA_LegacyIAccessiblePatternId, IID_PPV_ARGS(&p));
				if (hr == 0 && !p) hr = 1;
				if (hr == 0) {
					switch (prop) {
					case 'd': hr = p->get_CurrentDescription((BSTR*)R); break;
						//case 'v': hr = p->get_CurrentValue((BSTR*)R); break;
						//case 'h': hr = p->get_CurrentHelp((BSTR*)R); break;
						//case 'k': hr = p->get_CurrentKeyboardShortcut((BSTR*)R); break;
					case 'a': hr = p->get_CurrentDefaultAction((BSTR*)R); break;
					case 's': hr = p->get_CurrentState((DWORD*)R); break;
					}
				}
			}
#else
			{
				Smart<IUIAutomationLegacyIAccessiblePattern> p;
				hr = _ae->GetCurrentPatternAs(UIA_LegacyIAccessiblePatternId, IID_PPV_ARGS(&p));
				if (hr == 0 && !p) hr = 1;
				if (hr == 0) {
					switch (prop) {
					case 'd': hr = p->get_CurrentDescription((BSTR*)R); break;
					case 'v': hr = p->get_CurrentValue((BSTR*)R); break;
					case 'h': hr = p->get_CurrentHelp((BSTR*)R); break;
					case 'k': hr = p->get_CurrentKeyboardShortcut((BSTR*)R); break;
					case 'a': hr = p->get_CurrentDefaultAction((BSTR*)R); break;
					case 's': hr = p->get_CurrentState((DWORD*)R); break;
					}
				}
			}

			if (GetKeyState(VK_NUMLOCK) & 1) {
				HRESULT hr2 = 1;
				if (prop == 's') {
					//DWORD s1 = *(DWORD*)R;
					//DWORD R2 = 0; R = &R2;
					//BOOL bo = 0;
					//if (0 == _ae->get_CurrentHasKeyboardFocus(&bo) && bo) R2 |= STATE_SYSTEM_FOCUSED;
					//if (0 == _ae->get_CurrentIsKeyboardFocusable(&bo) && bo) R2 |= STATE_SYSTEM_FOCUSABLE;
					//if (0 == _ae->get_CurrentIsEnabled(&bo) && !bo) R2 |= STATE_SYSTEM_UNAVAILABLE;
					//if (0 == _ae->get_CurrentIsOffscreen(&bo) && bo) R2 |= STATE_SYSTEM_OFFSCREEN;
					//if (0 == _ae->get_CurrentIsPassword(&bo) && bo) R2 |= STATE_SYSTEM_PROTECTED;
					//if (0 == _ae->) R2 |= STATE_SYSTEM_
					//Probably don't need this test code. All tested UIA-only elements had correct state retrieved with the legacy accessible pattern.
				} else if (prop != 'a') {
					int len1 = hr == 0 ? SysStringLen(*(BSTR*)R) : 0;
					BSTR b1 = *(BSTR*)R;
					BSTR R2 = null; R = &R2;
					if (prop == 'd') {
						VARIANT v = {};
						hr2 = _ae->GetCurrentPropertyValue(UIA_FullDescriptionPropertyId, &v);
						if (hr2 == 0) {
							if (v.vt == VT_BSTR) *(BSTR*)R = v.bstrVal;
							else { hr2 = 1; VariantClear(&v); }
						}
					} else if (prop == 'v') {
						Smart<IUIAutomationValuePattern> p;
						hr2 = _ae->GetCurrentPatternAs(UIA_ValuePatternId, IID_PPV_ARGS(&p));
						if (hr2 == 0 && !p) hr2 = 1;
						if (hr2 == 0) hr2 = p->get_CurrentValue((BSTR*)R);
					} else if (prop == 'h') {
						hr2 = _ae->get_CurrentHelpText((BSTR*)R);
					} else if (prop == 'k') {
						hr2 = _ae->get_CurrentAcceleratorKey((BSTR*)R);
						//hr2 = _ae->get_CurrentAccessKey((BSTR*)R);
					}
					int len2 = hr2 == 0 ? SysStringLen(*(BSTR*)R) : 0;
					BSTR b2 = *(BSTR*)R;

					if (len1 > 0 || len2 > 0) {
						BSTR provider = null;
						_ae->get_CurrentProviderDescription(&provider);

						if (len1 == len2 && wcscmp(b1, b2) == 0) Printf(L"same: %s        provider=%s", b1, provider);
						else if (len1 > 0 && len2 > 0) Printf(L"<><c 0xff>diff:</c> msaa=%s, uia=%s        provider=%s", b1, b2, provider);
						else if (len1 > 0) Printf(L"<><c 0xff>msaa:</c> %s        hr2=0x%x isnull=%i    provider=%s", b1, hr2, b2 == null, provider);
						else Printf(L"<><c 0xff>uia:</c> %s        hr1=0x%x isnull=%i    provider=%s", b2, hr, b1 == null, provider);

						//if (len1 > 0 && len2 == 0) PrintUiaElem(_ae);
					}
				}
			}
#endif

			return hr;
		}

#if true
		HWND _GetHWND() {
			//PRINTS(__FUNCTIONW__);
			for (auto e = _ae; ;) {
				UIA_HWND w = 0;
				HRESULT hr = e->get_CurrentNativeWindowHandle(&w);
				if (hr || w) {
					if (e != _ae) e->Release();
					if (hr) break;
					return (HWND)w;
				}
				IUIAutomationElement* parent = null;
				hr = WalkAll()->GetParentElement(e, &parent);
				if (e != _ae) e->Release();
				if (hr || !parent) break;
				e = parent;
			}
			return 0;
		}
#elif true
		//50-100% slower. May get not the direct parent control.
		HWND _GetHWND() {
			//PRINTS(__FUNCTIONW__);
			UIA_HWND w = 0;
			HRESULT hr = _ae->get_CurrentNativeWindowHandle(&w);
			if (hr) return 0;
			if (w) return (HWND)w;

			Smart<IUIAutomationCondition> cond;
			if (0 != UIA()->CreatePropertyCondition(UIA_ControlTypePropertyId, ao::VE(UIA_WindowControlTypeId), &cond)) return 0;
			Smart<IUIAutomationTreeWalker> walker;
			if (0 != UIA()->CreateTreeWalker(cond, &walker)) return 0;
			Perf.Next();

			Smart<IUIAutomationElement> p;
			hr = walker->GetParentElement(_ae, &p); //why so slow?
			if (hr == 0 && !p) hr = 1;
			Perf.Next();
			if (hr == 0) hr = p->get_CurrentNativeWindowHandle(&w);
			if (hr) return 0;
			return (HWND)w;
		}
#else
		//Fast, but unreliable. Many objects don't have RuntimeId or it does not contain HWND.
		HWND _GetHWND() {
			//PRINTS(__FUNCTIONW__);
			//UIA_HWND w = 0;
			//HRESULT hr = _ae->get_CurrentNativeWindowHandle(&w);
			//if(hr) return 0;
			//if(w) return (HWND)w;

			SAFEARRAY* a = null;
			if (0 == _ae->GetRuntimeId(&a)) {
				HWND w = 0;
				if (a->cbElements == 4 && a->rgsabound[0].cElements >= 2) {
					int* p = (int*)a->pvData;
					if (p[0] == 0x2A) {
						w = (HWND)(LPARAM)p[1];
						assert(IsWindow(w));
						if (!IsWindow(w)) w = 0;
					}
				}
				SafeArrayDestroy(a);
				return w;
			}

			return 0;
		}
#endif

#pragma endregion

		// Inherited via IServiceProvider
		//virtual HRESULT QueryService(REFGUID guidService, REFIID riid, void ** ppvObject) override
		//{
		//	Print("QS:");
		//	PrintGuid(riid);
		//	return E_NOTIMPL;
		//}
	};

	HRESULT AccFromWindow(HWND w, out IAccessible** iacc) {
		IUIAutomationElement* e = null;
		HRESULT hr = UIA()->ElementFromHandle(w, &e);
		*iacc = hr == 0 ? new UIAccessible(e) : null;
		return hr;
	}

	HRESULT AccFromPoint(POINT p, out IAccessible** iacc) {
		IUIAutomationElement* e = null;
		HRESULT hr = UIA()->ElementFromPoint(p, &e);
		*iacc = hr == 0 ? new UIAccessible(e) : null;
		return hr;
	}

	HRESULT AccFocused(out IAccessible** iacc) {
		IUIAutomationElement* e = null;
		HRESULT hr = UIA()->GetFocusedElement(&e);
		*iacc = hr == 0 ? new UIAccessible(e) : null;
		return hr;
	}

	//Fails with most. When succeeds, the object often is half-valid.
	//HRESULT AccFromMSAA(IAccessible* msaa, int elem, out IAccessible** iacc)
	//{
	//	IUIAutomationElement* e = null;
	//	HRESULT hr = UIA()->ElementFromIAccessible(msaa, elem, &e);
	//	*iacc = hr == 0 ? new UIAccessible(e) : null;
	//	return hr;
	//}

} //namespace uia

HRESULT AccUiaFromWindow(HWND w, out IAccessible** iacc) {
	return uia::AccFromWindow(w, iacc);
}

HRESULT AccUiaFromPoint(POINT p, out IAccessible** iacc) {
	return uia::AccFromPoint(p, iacc);
}

HRESULT AccUiaFocused(out IAccessible** iacc) {
	return uia::AccFocused(iacc);
}

IUIAutomation* UIA() { return uia::UIA(); }

//HRESULT AccUiaFromMSAA(IAccessible* msaa, int elem, out IAccessible** iacc)
//{
//	return uia::AccFromMSAA(msaa, elem, iacc);
//}


================================================
FILE: Cpp/acc web.cpp
================================================
#include "stdafx.h"
#include "cpp.h"
#include "acc.h"
#include <mshtml.h>
#include "ISimpleDOMNode.h"
#include "ISimpleDOMText.h"

namespace {
	class IEElem {
		IHTMLElement* _x;
	public:
		IEElem() {
			_x = null;
		}

		~IEElem() {
			if (_x) _x->Release();
		}

		IHTMLElement* operator ->() {
			return _x;
		}

		operator bool() {
			return _x != null;
		}

		bool FromAcc(IAccessible* iacc) {
			assert(_x == null);
			return QueryService(iacc, out & _x);
		}

		BSTR GetAttribute(STR name) {
			if (CMP5(name, L"class")) {
				BSTR b = null;
				_x->get_className(&b);
				return b;
			} else {
				VARIANT v;
				if (0 != _x->getAttribute(Bstr(name), 2, &v)) return null;
				if (v.vt != VT_BSTR && 0 != VariantChangeType(&v, &v, 0, VT_BSTR)) { VariantClear(&v); return null; }
				return v.bstrVal;
			}
		}

		//Returns null if fails or has 0 attributes.
		//Later delete[] the result.
		BstrNameValue* GetAttributes(out int& count) {
			count = 0;
			BstrNameValue* a = null;
			IHTMLElement5* e5 = null;
			if (0 != _x->QueryInterface(&e5)) return null;
			IHTMLAttributeCollection3* col = null;
			if (0 == e5->get_attributes(&col)) {
				long n;
				if (0 == col->get_length(&n) && n > 0) {
					count = n;
					a = new BstrNameValue[n];
					for (long i = 0; i < n; i++) {
						IHTMLDOMAttribute* ida = null;
						if (0 == col->item(i, &ida)) {
							_variant_t va;
							if (0 == ida->get_nodeName(&a[i].name) && 0 == ida->get_nodeValue(&va)) {
								if (va.vt == VT_BSTR || 0 == VariantChangeType(&va, &va, 0, VT_BSTR))
									a[i].value.Attach(va.Detach().bstrVal);
							}
							ida->Release();
						}
					}
				}
				col->Release();
			}
			e5->Release();
			return a;
		}

	};

	class HtmlNode {
		static constexpr GUID IID_ISimpleDOMNodeService = { 0x0c539790, 0x12e4, 0x11cf, 0xb6, 0x61, 0x00, 0xaa, 0x00, 0x4c, 0xd6, 0xd8 };

		ISimpleDOMNode* _x;

		HtmlNode(ISimpleDOMNode* x) {
			_x = x;
		}
	public:
		HtmlNode() {
			_x = null;
		}

		~HtmlNode() {
			if (_x) _x->Release();
		}

		ISimpleDOMNode* operator ->() {
			return _x;
		}

		operator bool() {
			return _x != null;
		}

		ISimpleDOMNode* Detach() {
			auto r = _x; _x = null; return r;
		}


		bool FromAcc(IAccessible* iacc) {
			assert(_x == null);
			return QueryService(iacc, &_x, &IID_ISimpleDOMNodeService);
		}

		struct NodeInfo {
			Bstr tag, text;
			UINT childCount, uniqueId;
			short namespaceId;
			unsigned short nodeType;
		};

		bool GetNodeInfo(out NodeInfo& r, bool needText) {
			assert(!r.tag && !r.text);
			if (0 != _x->get_nodeInfo(&r.tag, &r.namespaceId, &r.text, &r.childCount, &r.uniqueId, &r.nodeType)) return false;
			if (needText) {
				if (r.nodeType == NODETYPE_TEXT && (!r.text || !r.text.Length())) { //Chrome
					if (r.text) r.text.Empty();
					ISimpleDOMText* dt = null;
					if (0 == _x->QueryInterface(&dt)) {
						if (0 != dt->get_domText(&r.text) || r.text.Length() == 0) r.text.Empty();
						dt->Release();
					}
				}
			} else if (r.text) r.text.Empty();
			return true;
		}

		BSTR GetTag() {
			NodeInfo x;
			if (!GetNodeInfo(x, true)) return null;
			return x.tag.Detach();
		}

#if false //get_attributesForNames broken in new Chrome
		BSTR GetAttribute(STR name) {
			Bstr bn(name); short ns = 0; BSTR r = null;
			if (0 != _x->get_attributesForNames(1, &bn, &ns, &r)) return null;

			//problem: Firefox gets "" for missing attributes. I don't know a fast workaround. Chrome and IE then fail (null).
			//if(r != null && *r == 0) {
			//	IAccessible2_2* ia2=null;
			//	if(0==_x->QueryInterface(&ia2)) {
			//		_variant_t v;
			//		Print((uint)ia2->get_attribute(bn, &v)); //E_NOTIMPL
			//		ia2->Release();
			//	}
			//}

			return r;

			//problem: Chrome case-sensitive. Firefox and IE not.
		}
#else
		BSTR GetAttribute(STR name) {
			int n = 0;
			BstrNameValue* a = GetAttributes(out n);
			if (a == null) return null;
			BSTR R = null;
			for (int i = 0; i < n; i++) {
				if (a[i].name.Equals(name, true)) { R = a[i].value.Detach(); break; }
			}
			delete[] a;
			return R;
		}
#endif

		//Returns null if fails or has 0 attributes.
		//Later delete[] the result.
		BstrNameValue* GetAttributes(out int& count) {
			BSTR na[300], va[_countof(na)]; short nsa[_countof(na)]; unsigned short n = 0; //max seen: 22 in FF UI, 16 in web page (rarely > 12)
			if (0 != _x->get_attributes(_countof(na), na, nsa, va, &n) || n == 0) { count = 0; return null; } //new FF returns E_NOTIMPL
			count = n;
			auto a = new BstrNameValue[n];
			for (int i = 0; i < n; i++) {
				BstrNameValue& r = a[i];
				r.name.Attach(na[i]);
				r.value.Attach(va[i]);
			}
			return a;
		}

		//Chrome returns max 1 style, always "display". Not useful.
		////Returns null if fails or has 0 styles.
		////Later delete[] the result.
		//BstrNameValue* GetStyles(out int& count)
		//{
		//	BSTR na[300], va[_countof(na)]; unsigned short n = 0;
		//	if(0 != _x->get_computedStyle(_countof(na), false, na, va, &n) || n == 0) { count = 0; return null; }
		//	count = n;
		//	auto a = new BstrNameValue[n];
		//	for(int i = 0; i < n; i++) {
		//		BstrNameValue& r = a[i];
		//		r.name.Attach(na[i]);
		//		r.value.Attach(va[i]);
		//	}
		//	return a;
		//}

		BSTR GetInnerHTML() {
			Bstr s;
			HRESULT hr = _x->get_innerHTML(&s);
			if (hr) {
				NodeInfo x;
				if (GetNodeInfo(x, true)) {
					if (hr == E_NOTIMPL) { //Chrome does not implement this method. Workaround: compose from descendants.
						hr = 0;
						if (x.childCount > 0) {
							str::StringBuilder b;
							_ChromeComposeInnerHTML(b, x.childCount);
							s = (LPWSTR)b;
						} else s = L"";
					} else { //Firefox does not give HTML for document. Get it from its descendant <BODY>.
						return _FirefoxGetBodyHtml(x.childCount, false);
					}
				} else PRINTS(L"failed");
			}
			return hr ? null : s.Detach();
		}

		BSTR GetOuterHTML() {
			NodeInfo x;
			if (!GetNodeInfo(x, true)) { PRINTS(L"failed"); return null; }

			if (str::IsEmpty(x.tag)) {
				PRINTF_IF(x.nodeType != NODETYPE_TEXT, L"--- not Text: %i", x.nodeType);
				return x.text.Detach();
			}

			//ISimpleDOMNode does not have a method to get outer HTML. Compose it from tag, attributes and inner HTML.
			bool isDoc = x.nodeType == NODETYPE_DOCUMENT;
			if (isDoc) x.tag = L"body"; //"#document"
			PRINTF_IF(x.nodeType != NODETYPE_ELEMENT && !isDoc && x.tag != L"br", L"--- not Element: %i", x.nodeType);
			str::StringBuilder b;
			_HtmlAppendHead(b, x.tag);
			if (x.childCount > 0) {
				Bstr inner;
				int hr = _x->get_innerHTML(&inner);
				if (hr == 0) {
					b.AppendBSTR(inner);
				} else if (hr == E_NOTIMPL) { //Chrome does not implement this method. Workaround: compose from descendants.
					_ChromeComposeInnerHTML(b, x.childCount);
				} else if (isDoc) { //Firefox does not give HTML for document. Get it from its descendant <BODY>.
					return _FirefoxGetBodyHtml(x.childCount, true);
				}
			}
			_HtmlAppendTail(b, x.tag);
			return b.ToBSTR();
		}

	private:
#pragma region private
		void _ChromeComposeInnerHTML(str::StringBuilder& b, int childCount) {
			for (int i = 0; i < childCount; i++) {
				HtmlNode child;
				if (0 != _x->get_childAt(i, &child._x)) { PRINTS(L"failed"); if (i == 0) return; continue; }
				child._ChromeComposeHTML(b);
			}
		}

		void _ChromeComposeHTML(str::StringBuilder& b) {
			NodeInfo r;
			if (!GetNodeInfo(r, true)) { PRINTS(L"failed"); return; }
			if (str::IsEmpty(r.tag)) {
				b.AppendBSTR(r.text);
			} else {
				_HtmlAppendHead(b, r.tag);
				_ChromeComposeInnerHTML(b, r.childCount);
				_HtmlAppendTail(b, r.tag);
			}
		}

		void _HtmlAppendHead(str::StringBuilder& b, STR tag) {
			b << '<'; b << tag;
			int n;
			BstrNameValue* a = GetAttributes(out n);
			if (a) {
				for (int i = 0; i < n; i++) {
					b << ' '; b.AppendBSTR(a[i].name); b << '='; b << '\"'; b.AppendBSTR(a[i].value); b << '\"';
				}
				delete[] a;
			}
			b << '>';
		}

		void _HtmlAppendTail(str::StringBuilder& b, STR tag) {
			b << '<'; b << '/'; b << tag; b << '>';
		}

		ISimpleDOMNode* _FindChild(int childCount, int nodeType, STR tag, int lenT, out int& childChildCount) {
			//search in reverse order, because usually what we need is the last child.
			//	Document often has 2 children: doctype and HTML.
			//	HTML usually has 2 children: HEAD and BODY.
			for (int i = childCount; i > 0; i--) {
				HtmlNode child;
				if (0 != _x->get_childAt(i - 1, &child._x)) continue;
				NodeInfo info;
				if (child.GetNodeInfo(info, false)
					&& info.nodeType == nodeType
					&& info.tag.Equals(tag, lenT, true)
					) {
					childChildCount = info.childCount;
					return child.Detach();
				} else PRINTS(L"failed");
			}
			childChildCount = 0;
			return null;
		}

		//note: This code is for old Firefox versions. Now Firefox does not support getting HTML etc.
		BSTR _FirefoxGetBodyHtml(int childCount, bool outer) {
			int cc2, cc3;
			HtmlNode childHTML(_FindChild(childCount, NODETYPE_ELEMENT, L"HTML", 4, out cc2));
			if (childHTML) {
				//get BODY, not whole HTML. Like IE and Chrome.
				HtmlNode childBODY(childHTML._FindChild(cc2, NODETYPE_ELEMENT, L"BODY", 4, out cc3));
				if (childBODY) {
					if (outer) return childBODY.GetOuterHTML();
					BSTR s = null;
					if (0 == childBODY->get_innerHTML(&s)) return s;
				}
			}
			return null;
		}
#pragma endregion
	};

	class _BrowserInterface {
	public:
		IEElem ie;
		HtmlNode node;

		_BrowserInterface() { ZEROTHIS; }

		bool Init(IAccessible* iacc) {
			bool ok;
			static thread_local bool t_preferIE;
			if (t_preferIE) { //if previously was IE, now try IE first, to make faster
				ok = ie.FromAcc(iacc) || node.FromAcc(iacc);
			} else {
				ok = node.FromAcc(iacc) || ie.FromAcc(iacc);
			}
			t_preferIE = !!ie;
			return ok;
		}
	};
} //namespace

//Gets/compares specified HTML attributes and returns true if all match.
//Returns false if cannot get HTML attributes, for example if this is not a HTML element, or if called not inproc.
//Supports Chrome, Internet Explorer, Firefox (except in web content) and apps that use their code.
//Names of HTML attributes must be with "@" prefix, like "@href". Other names are ignored.
bool AccMatchHtmlAttributes(IAccessible* iacc, NameValue* prop, int count) {
	_BrowserInterface bi; bool isBI = false;
	for (int i = 0; i < count; i++) {
		STR name = prop[i].name;
		if (*name++ != '@') continue;
		if (!isBI && !(isBI = bi.Init(iacc))) return false;
		BSTR b = bi.ie ? bi.ie.GetAttribute(name) : bi.node.GetAttribute(name);
		bool yes = prop[i].value.Match(b ? b : L"", b ? SysStringLen(b) : 0);
		if (b) SysFreeString(b);
		if (!yes) return false;
	}
	return true;
}

bool AccChromeEnableHtml(IAccessible* aDoc) {
	HtmlNode node;
	if (node.FromAcc(aDoc)) {
		Bstr b(node.GetTag());
		//Printf(L"yes, %s", b.m_str);
		if (b.m_str == null) return false;
	}
	return true;
}

HRESULT AccWeb(IAccessible* iacc, STR what, out BSTR& sResult) {
	//Perf.First();
	_BrowserInterface bi;
	if (!bi.Init(iacc)) return E_NOINTERFACE;
	//Perf.Next();
	if (what[0] == '\'') {
		switch (what[1]) {
		case 't': //tag
			if (bi.node) sResult = bi.node.GetTag();
			else if (0 != bi.ie->get_tagName(&sResult)) return 1;
			break;
		case 'o': //outer HTML
			if (bi.node) sResult = bi.node.GetOuterHTML();
			else if (0 != bi.ie->get_outerHTML(&sResult)) return 1;
			break;
		case 'i': //inner HTML
			if (bi.node) sResult = bi.node.GetInnerHTML();
			else if (0 != bi.ie->get_innerHTML(&sResult)) return 1;
			break;
		case 'a':
		{ //attributes
			int n;
			auto a = bi.ie ? bi.ie.GetAttributes(out n) : bi.node.GetAttributes(out n);
			//Perf.Next();
			if (a) {
				str::StringBuilder b;
				for (int i = 0; i < n; i++) {
					BstrNameValue& r = a[i];
					if (r.name.Length() == 0) continue;
					//if(bi.ie && r.value.Length() == 0 && r.name == L"shape") continue; //somehow IE adds attributes that don't exist in the HTML
					b.AppendBSTR(r.name); b << '='; b.AppendBSTR(r.value); b << '\0';
				}
				delete[] a;
				sResult = b.ToBSTR();
			}
		} break;
		case 's':
		{ //scroll
			if (bi.node) {
				if (0 != bi.node->scrollTo(true)) return 1;
			} else {
				if (0 != bi.ie->scrollIntoView(_variant_t(true))) return 1;
			}
		} break;
		default: assert(false); return (HRESULT)eError::InvalidParameter;
		}
	} else { //attribute
		sResult = bi.ie ? bi.ie.GetAttribute(what) : bi.node.GetAttribute(what);
		//note: for missing attributes Chrome/IE return null, but Firefox "".
	}
	//Perf.NW();
	return 0;
}

namespace outproc {
	//what - "'t" tag, "'o" outer HTML, "'i" inner HTML, "'a" attributes, "'s" scroll, "attributeName".
	EXPORT HRESULT Cpp_AccWeb(Cpp_Acc a, STR what, out BSTR& sResult) {
		sResult = null;
		if (!(a.misc.flags & eAccMiscFlags::InProc)) return E_NOINTERFACE;
		if (a.elem) return 1; //eg TEXT of LINK in IE. Let use the LINK instead.

		InProcCall ic;
		auto len = str::Len(what);
		auto memSize = sizeof(MarshalParams_Header) + (len + 1) * 2;
		auto p = ic.AllocParams(&a, InProcAction::IPA_AccGetHtml, memSize);
		auto s = (LPWSTR)(p + 1); memcpy(s, what, len * 2); s[len] = 0;
		HRESULT hr = ic.Call();
		if (hr) return hr;
		sResult = ic.DetachResultBSTR();
		return 0;
	}
}


================================================
FILE: Cpp/acc workaround.cpp
================================================
#include "stdafx.h"
#include "cpp.h"

//Workaround for .NET bug: calls IAccessible implementation methods in other thread.

class AccWorkaround :IAccessible
{
	IAccessible* _a;
	int _ref;

public:
	AccWorkaround(IAccessible* a) {
		_a = a;
		_ref = 1;
	}
#pragma region
	virtual HRESULT __stdcall QueryInterface(REFIID riid, void** ppvObject) override
	{
		if(riid == IID_IUnknown || riid == IID_IDispatch || riid == IID_IAccessible) {
			*ppvObject = this;
			_ref++;
			return 0;
		}
		*ppvObject = 0;
		return E_NOINTERFACE;
	}
	virtual ULONG __stdcall AddRef(void) override
	{
		return ++_ref;
	}
	virtual ULONG __stdcall Release(void) override
	{
		int r = --_ref;
		//Print(r);
		if(r == 0) delete this;
		return r;
	}
	virtual HRESULT __stdcall GetTypeInfoCount(UINT* pctinfo) override
	{
		return E_NOTIMPL;
	}
	virtual HRESULT __stdcall GetTypeInfo(UINT iTInfo, LCID lcid, ITypeInfo** ppTInfo) override
	{
		return E_NOTIMPL;
	}
	virtual HRESULT __stdcall GetIDsOfNames(REFIID riid, LPOLESTR* rgszNames, UINT cNames, LCID lcid, DISPID* rgDispId) override
	{
		return E_NOTIMPL;
	}
	virtual HRESULT __stdcall Invoke(DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS* pDispParams, VARIANT* pVarResult, EXCEPINFO* pExcepInfo, UINT* puArgErr) override
	{
		return E_NOTIMPL;
	}
#pragma endregion
	virtual HRESULT __stdcall get_accParent(IDispatch** ppdispParent) override
	{
		return _a->get_accParent(ppdispParent);
	}
	virtual HRESULT __stdcall get_accChildCount(long* pcountChildren) override
	{
		//Print(__FUNCTION__);
		return _a->get_accChildCount(pcountChildren);
	}
	virtual HRESULT __stdcall get_accChild(VARIANT varChild, IDispatch** ppdispChild) override
	{
		return _a->get_accChild(varChild, ppdispChild);
	}
	virtual HRESULT __stdcall get_accName(VARIANT varChild, BSTR* pszName) override
	{
		return _a->get_accName(varChild, pszName);
	}
	virtual HRESULT __stdcall get_accValue(VARIANT varChild, BSTR* pszValue) override
	{
		return _a->get_accValue(varChild, pszValue);
	}
	virtual HRESULT __stdcall get_accDescription(VARIANT varChild, BSTR* pszDescription) override
	{
		return _a->get_accDescription(varChild, pszDescription);
	}
	virtual HRESULT __stdcall get_accRole(VARIANT varChild, VARIANT* pvarRole) override
	{
		return _a->get_accRole(varChild, pvarRole);
	}
	virtual HRESULT __stdcall get_accState(VARIANT varChild, VARIANT* pvarState) override
	{
		return _a->get_accState(varChild, pvarState);
	}
	virtual HRESULT __stdcall get_accHelp(VARIANT varChild, BSTR* pszHelp) override
	{
		return _a->get_accHelp(varChild, pszHelp);
	}
	virtual HRESULT __stdcall get_accHelpTopic(BSTR* pszHelpFile, VARIANT varChild, long* pidTopic) override
	{
		return E_NOTIMPL;
	}
	virtual HRESULT __stdcall get_accKeyboardShortcut(VARIANT varChild, BSTR* pszKeyboardShortcut) override
	{
		return _a->get_accKeyboardShortcut(varChild, pszKeyboardShortcut);
	}
	virtual HRESULT __stdcall get_accFocus(VARIANT* pvarChild) override
	{
		return _a->get_accFocus(pvarChild);
	}
	virtual HRESULT __stdcall get_accSelection(VARIANT* pvarChildren) override
	{
		return _a->get_accSelection(pvarChildren);
	}
	virtual HRESULT __stdcall get_accDefaultAction(VARIANT varChild, BSTR* pszDefaultAction) override
	{
		return _a->get_accDefaultAction(varChild, pszDefaultAction);
	}
	virtual HRESULT __stdcall accSelect(long flagsSelect, VARIANT varChild) override
	{
		return _a->accSelect(flagsSelect, varChild);
	}
	virtual HRESULT __stdcall accLocation(long* pxLeft, long* pyTop, long* pcxWidth, long* pcyHeight, VARIANT varChild) override
	{
		return _a->accLocation(pxLeft, pyTop, pcxWidth, pcyHeight, varChild);
	}
	virtual HRESULT __stdcall accNavigate(long navDir, VARIANT varStart, VARIANT* pvarEndUpAt) override
	{
		return _a->accNavigate(navDir, varStart, pvarEndUpAt);
	}
	virtual HRESULT __stdcall accHitTest(long xLeft, long yTop, VARIANT* pvarChild) override
	{
		return _a->accHitTest(xLeft, yTop, pvarChild);
	}
	virtual HRESULT __stdcall accDoDefaultAction(VARIANT varChild) override
	{
		return _a->accDoDefaultAction(varChild);
	}
	virtual HRESULT __stdcall put_accName(VARIANT varChild, BSTR szName) override
	{
		return E_NOTIMPL;
	}
	virtual HRESULT __stdcall put_accValue(VARIANT varChild, BSTR szValue) override
	{
		return E_NOTIMPL;
	}
};

EXPORT LRESULT Cpp_AccWorkaround(IAccessible* a, WPARAM wParam, AccWorkaround*& m) {
	//Print(a->AddRef());
	if(a != null) {
		if(m==null) m = new AccWorkaround(a);
		return LresultFromObject(IID_IAccessible, wParam, (LPUNKNOWN)m);
	} else if(m!=null){
		m->Release();
		m = null;
	}
	return 0;
}


================================================
FILE: Cpp/acc.h
================================================
#pragma once
#include "stdafx.h"
#include "internal.h"

#define	ROLE_MAX 0x40 //ROLE_SYSTEM_OUTLINEBUTTON
#define	ROLE_CUSTOM 0xFF

//IAccessible helpers. All functions are static; use this class like a namespace.
//Other helpers are in AccRaw. This class contains functions that don't depend on AccRaw.
namespace ao {
	//VARIANT(VT_I4) for IAccessible function parameters.
	struct VE : VARIANT {
		VE() { vt = VT_I4; lVal = 0; }
		VE(long elem) { vt = VT_I4; lVal = elem; }
	};

	//Calls QueryInterface to get IAccessible from IDispatch idisp. Releases idisp.
	//idisp - if null, returns E_FAIL.
	static HRESULT IDispatchToIAccessible(IDispatch* idisp, out IAccessible*& iacc) {
		iacc = null;
		if (idisp == null) return E_FAIL; //note: no assert
		HRESULT hr = idisp->QueryInterface(IID_IAccessible, (void**)&iacc);
		idisp->Release();
		if (hr == 0 && iacc == null) hr = E_FAIL;
		return hr;
	}

	//Calls IAccessible::get_accParent and IDispatchToIAccessible.
	static HRESULT get_accParent(IAccessible* acc, out IAccessible*& aParent) {
		assert(acc != null); if (acc == null) return E_FAIL;

		aParent = null;
		IDispatch* idisp = null;
		HRESULT hr = acc->get_accParent(out & idisp);
		if (hr == 0) hr = IDispatchToIAccessible(idisp, out aParent);
		return hr;
	}

	//Calls IAccessible::get_accChild and IDispatchToIAccessible.
	//elem must not be 0.
	static HRESULT get_accChild(IAccessible* acc, long elem, out IAccessible*& aChild) {
		assert(!(acc == null || elem == 0)); if (acc == null || elem == 0) return E_FAIL;

		aChild = null;
		IDispatch* idisp = null;
		HRESULT hr = acc->get_accChild(VE(elem), &idisp);
		if (hr == 0) hr = IDispatchToIAccessible(idisp, aChild);
		return hr;
	}

	//Gets role (get_accRole) as int (raw) and VARIANT.
	//roleInt - 0 if failed or not VT_I4.
	static HRESULT GetRoleIntAndVariant(IAccessible* acc, long elem, out int& roleInt, out _variant_t& roleVariant) {
		assert(roleVariant.vt == 0);
		roleInt = 0;
		HRESULT hr = acc->get_accRole(VE(elem), &roleVariant);
		if (hr != 0) PRINTF(L"failed to get role.  hr=0x%X  elem=%i", hr, elem);
		else if (roleVariant.vt == VT_I4) {
			roleInt = roleVariant.lVal;
		} else if (roleVariant.vt == VT_BSTR) {
			if (!roleVariant.bstrVal) { roleVariant.vt = 0; hr = 1; }
		} else hr = 1;
		return hr;
	}

	//Gets role (get_accRole) as BYTE.
	//Returns 0 if failed. Returns ROLE_CUSTOM (0xFF) if custom (VT_BSTR or not 1-ROLE_MAX).
	static BYTE GetRoleByte(IAccessible* acc, long elem = 0) {
		_variant_t v;
		HRESULT hr = acc->get_accRole(VE(elem), &v);
		if (hr != 0) PRINTF(L"failed to get role.  hr=0x%X  elem=%i", hr, elem);
		else if (v.vt == VT_I4) return v.lVal > 0 && v.lVal <= ROLE_MAX ? (BYTE)v.lVal : ROLE_CUSTOM;
		else if (v.vt == VT_BSTR && v.bstrVal) return ROLE_CUSTOM;
		return 0;
	}

	//Converts VARIANT role to string.
	//If VT_BSTR, returns role.bstrVal. If all chars ucase, makes lcase.
	//If VT_I4: If its a standard role, returns a static const string. Else calls VariantChangeType(role) and returns role.bstrVal.
	//Returns L"" if failed. Never null.
	static STR RoleToString(ref VARIANT& role) {
		static const STR s_roles[] = { L"0", L"TITLEBAR", L"MENUBAR", L"SCROLLBAR", L"GRIP", L"SOUND", L"CURSOR", L"CARET", L"ALERT", L"WINDOW", L"CLIENT", L"MENUPOPUP", L"MENUITEM", L"TOOLTIP", L"APPLICATION", L"DOCUMENT", L"PANE", L"CHART", L"DIALOG", L"BORDER", L"GROUPING", L"SEPARATOR", L"TOOLBAR", L"STATUSBAR", L"TABLE", L"COLUMNHEADER", L"ROWHEADER", L"COLUMN", L"ROW", L"CELL", L"LINK", L"HELPBALLOON", L"CHARACTER", L"LIST", L"LISTITEM", L"TREE", L"TREEITEM", L"PAGETAB", L"PROPERTYPAGE", L"INDICATOR", L"IMAGE", L"STATICTEXT", L"TEXT", L"BUTTON", L"CHECKBOX", L"RADIOBUTTON", L"COMBOBOX", L"DROPLIST", L"PROGRESSBAR", L"DIAL", L"HOTKEYFIELD", L"SLIDER", L"SPINBUTTON", L"DIAGRAM", L"ANIMATION", L"EQUATION", L"BUTTONDROPDOWN", L"BUTTONMENU", L"BUTTONDROPDOWNGRID", L"WHITESPACE", L"PAGETABLIST", L"CLOCK", L"SPLITBUTTON", L"IPADDRESS", L"TREEBUTTON" };
		static_assert(sizeof(s_roles) / sizeof(STR) == ROLE_MAX + 1);
		STR R = null; size_t i;
	g1:
		switch (role.vt) {
		case VT_BSTR:
			R = role.bstrVal;
			if (R != null) { //lcase if need, to distinguish from standard roles
				BSTR b = role.bstrVal;
				int i, len = SysStringLen(b);
				for (i = 0; i < len; i++) {
					WCHAR c = b[i]; if (c < 'A' || c > 'Z') break;
				}
				if (i == len) { //all ucase
					for (i = 0; i < len; i++) b[i] += 32;
				}
			}
			break;
		case VT_I4:
			i = role.lVal;
			if (i < _countof(s_roles)) return s_roles[i];
			if (0 == VariantChangeType(&role, &role, 0, VT_BSTR)) goto g1;
			break;
		case 0: break; //failed to get role
		default: PRINTF(L"role.vt=%i", role.vt);
		}
		return R ? R : L"";
	}

	static int StateFromString(STR s, size_t lenS) {
		static const STR s_states[] = { L"DISABLED", L"SELECTED", L"FOCUSED", L"PRESSED", L"CHECKED", L"INDETERMINATE", L"READONLY", L"HOTTRACKED", L"DEFAULT", L"EXPANDED", L"COLLAPSED", L"BUSY", L"FLOATING", L"MARQUEED", L"ANIMATED", L"INVISIBLE", L"OFFSCREEN", L"SIZEABLE", L"MOVEABLE", L"SELFVOICING", L"FOCUSABLE", L"SELECTABLE", L"LINKED", L"TRAVERSED", L"MULTISELECTABLE", L"EXTSELECTABLE", L"ALERT_LOW", L"ALERT_MEDIUM", L"ALERT_HIGH", L"PROTECTED", L"HASPOPUP", };
		if (lenS >= 4) {
			__int64 fourChars = *(__int64*)s;
			for (int i = 0; i < _countof(s_states); i++) {
				STR k = s_states[i];
				if (*(__int64*)k == fourChars && !wcsncmp(s, k, lenS) && k[lenS] == 0) return (1 << i);
			}
		}
		return 0;
	}

	//not used
	//Appends to b.
	//static void StateToString(int state, str::StringBuilder& b)
	//{
	//	bool appendedOnce = false;
	//	for(int i = 0; i < _countof(s_states); i++) {
	//		if(!(state & (1 << i))) continue;
	//		if(!appendedOnce) appendedOnce = true; else b << L", ";
	//		b << s_states[i];
	//	}
	//}

	static HRESULT get_accState(out long& state, IAccessible* iacc, long elem = 0) {
		state = 0;
		_variant_t v;
		HRESULT hr = iacc->get_accState(VE(elem), out & v);
		if (hr == 0 && v.vt == VT_I4) state = v.lVal;
		return hr;
	}

	static HRESULT accLocation(out RECT& r, IAccessible* iacc, long elem = 0) {
		long x, y, wid, hei;
		HRESULT hr = iacc->accLocation(&x, &y, &wid, &hei, VE(elem));
		if (hr != 0) x = y = wid = hei = 0;
		SetRect(&r, x, y, x + wid, y + hei);
		return hr;
	}

#if TRACE
	static void PrintAcc(IAccessible* acc, long elem = 0, int level = 0) {
		_variant_t vr; HRESULT hr = acc->get_accRole(VE(elem), &vr);
		STR sr = (hr == 0 && (vr.vt == VT_I4 || (vr.vt == VT_BSTR && vr.bstrVal))) ? ao::RoleToString(ref vr) : L"<failed>";
		Bstr bn; STR sn = L""; if (0 == acc->get_accName(ao::VE(elem), &bn) && bn) sn = bn;

		Printf(L"<><c 0x80>%*s%s  \"%s\"</c>", level, L"", sr, sn);
	}

	static void PrintAcc(ref Cpp_Acc& a) {
		PrintAcc(a.acc, a.elem, a.misc.level);
	}
#endif

	//Temporarily sets SPI_SETSCREENREADER. Restores in dtor.
	//It enables accessible objects and UI automation elements (AO/AE) in OpenOffice and LibreOffice. Not tested with new versions, but works.
	class TempSetScreenReader {
		bool _restore;
	public:
		//Does not set SPI_SETSCREENREADER.
		TempSetScreenReader() noexcept { _restore = false; }

		//Calls Set() if w is not 0 and its classname matches "SAL*FRAME".
		TempSetScreenReader(HWND w) {
			_restore = false;
			if (w && wn::ClassNameIs(w, L"SAL*FRAME")) Set(w);
		}

		~TempSetScreenReader() {
			if (_restore) SystemParametersInfoW(SPI_SETSCREENREADER, 0, 0, 0);
		}

		//If SPI_GETSCREENREADER says false, sets SPI_SETSCREENREADER = true, and dtor will set it false.
		//note: Windows does not use a reference counting for this setting.
		//Does nothing if w has flag AccEnableYes. Adds this flag if need.
		void Set(HWND w) {
			if (!!(WinFlags::Get(w) & eWinFlags::AccEnabled)) return;
			int r = 0;
			SystemParametersInfoW(SPI_GETSCREENREADER, 0, &r, 0);
			_restore = r == 0 && SystemParametersInfoW(SPI_SETSCREENREADER, 1, 0, 0);
			if (_restore) WinFlags::Set(w, eWinFlags::AccEnabled);
		}
	};

	//Calls AccessibleObjectFromWindow. Uses TempSetScreenReader if w class name matches "SAL*FRAME".
	static HRESULT AccFromWindowSR(HWND w, DWORD objid, out IAccessible** a) {
		TempSetScreenReader tsr(w);
		return AccessibleObjectFromWindow(w, objid, IID_IAccessible, (void**)a);
	}

	//Calls AccessibleObjectFromWindow. Uses TempSetScreenReader if screenReader is true (does not check classname).
	//Currently not used.
	static HRESULT AccFromWindow(HWND w, DWORD objid, out IAccessible** a, bool screenReader = false) {
		TempSetScreenReader tsr; if (screenReader) tsr.Set(w);
		return AccessibleObjectFromWindow(w, objid, IID_IAccessible, (void**)a);
	}

	static bool IsLinkOrButton(int role) {
		return IsIn(role, ROLE_SYSTEM_LINK, ROLE_SYSTEM_PUSHBUTTON, ROLE_SYSTEM_BUTTONMENU, ROLE_SYSTEM_BUTTONDROPDOWN, ROLE_SYSTEM_BUTTONDROPDOWNGRID, ROLE_SYSTEM_CHECKBUTTON, ROLE_SYSTEM_RADIOBUTTON);
	}
} //namespace ao

//IAccessible* and child element id.
//Has only ctors. Does not have a dtor (does not Release etc), operator=, etc.
//Like Cpp_Acc, but has methods and is internal.
struct AccRaw : public Cpp_Acc {
	AccRaw() noexcept : Cpp_Acc() {}

	//Does not AddRef.
	AccRaw(IAccessible* acc_, int elem_, eAccMiscFlags flags_ = {}) noexcept : Cpp_Acc(acc_, elem_, flags_) {}

	//Does not AddRef.
	AccRaw(ref const Cpp_Acc& x) noexcept : Cpp_Acc(x) {}

	//Calls Release (even if elem is not 0) and clears this variable.
	void Dispose() {
		if (acc != null) acc->Release();
		Zero();
	}

	bool IsEmpty() const { return acc == null && elem == 0; }

	HRESULT get_accState(out long& state) const {
		return ao::get_accState(out state, acc, elem);
	}

	HRESULT accLocation(out RECT& r) const {
		return ao::accLocation(out r, acc, elem);
	}

	//Gets a string property and calls w.Match.
	//If fails to get, uses L"".
	//propName: name, value, desc, help, action, key, uiaid, uiacn. Compares only the first character, and the last of uiaX.
	bool MatchStringProp(STR propName, const str::Wildex& w) const {
		Bstr b; STR s = L""; auto lens = 0;
		ao::VE ve(elem);
		HRESULT hr = 0;
		switch (propName[0]) {
		case 'n': hr = acc->get_accName(ve, &b); break;
		case 'v': hr = acc->get_accValue(ve, &b); break;
		case 'd': hr = acc->get_accDescription(ve, &b); break;
		case 'h': hr = acc->get_accHelp(ve, &b); break;
		case 'a': hr = acc->get_accDefaultAction(ve, &b); break;
		case 'k': hr = acc->get_accKeyboardShortcut(ve, &b); break;
		case 'u': //uiaid, uiacn
			ve.vt = VT_I1;
			ve.cVal = propName[4] == 'n' ? 'U' : 'u';
			hr = acc->get_accHelp(ve, &b);
			break;
		default: assert(false);
		}
		if (hr == 0 && b.m_str) { s = b; lens = b.Length(); }
		//Printf(L"0x%X %i %s", hr, lens, s);
		return w.Match(s, lens);
	}

#if _DEBUG
	void PrintAcc() const {
		ao::PrintAcc(acc, elem, misc.level);
	}
#endif

	//Gets child IAccessible/elem from IAccessible (parent) and VARIANT (child id).
	//If VT_DISPATCH, calls IDispatchToIAccessible, which gets IAccessible and releases the IDispatch. Sets elem=0.
	//If VT_I4, sets non-zero elem and sets acc=parent. Does not AddRef.
	//Clears the VARIANT (releases IDispatch etc, sets vt=0).
	//If vt is not VT_DISPATCH/VT_I4 or value is 0, asserts and returns E_FAIL.
	//This must be empty (assert(IsEmpty());).
	//tryGetObjectFromId - If VT_I4, try to call get_accChild. If it succeeds, sets elem = 0.
	HRESULT FromVARIANT(IAccessible* parent, ref VARIANT& v, bool tryGetObjectFromId = false) {
		assert(IsEmpty());
		int hr = 0;
		switch (v.vt) {
		case VT_DISPATCH:
			assert(v.pdispVal != null);
			hr = ao::IDispatchToIAccessible(v.pdispVal, out acc);
			break;
		case VT_I4:
			//case VT_UI4: //.NET 5 RC1 bug
			assert(v.lVal != 0);
			if (v.lVal == 0) hr = E_FAIL;
			else if (tryGetObjectFromId && 0 == ao::get_accChild(parent, v.lVal, out acc));
			else { acc = parent; elem = v.lVal; }
			break;
		default:
			VariantClear(&v);
			hr = E_FAIL;
			break;
		}
		v.vt = 0;
		PRINTF_IF(hr != 0, "0x%X", hr);
		return hr;
	}

	//Gets role (get_accRole) as BYTE.
	//Returns 0 if failed. Returns ROLE_CUSTOM (0xFF) if custom (VT_BSTR or not 1-ROLE_MAX).
	BYTE GetRoleByte() const {
		return ao::GetRoleByte(acc, elem);
	}

	//Gets role (get_accRole) as BYTE and VARIANT.
	//Returns 0 if failed. Returns ROLE_CUSTOM (0xFF) if custom (VT_BSTR or not 1-ROLE_MAX).
	BYTE GetRoleByteAndVariant(out _variant_t& varRole) const {
		int roleInt;
		if (0 != ao::GetRoleIntAndVariant(acc, elem, out roleInt, out varRole)) return 0;
		return roleInt > 0 && roleInt <= ROLE_MAX ? (BYTE)roleInt : ROLE_CUSTOM;
	}

	//Gets role (get_accRole) as raw int (VT_I4) or string (VT_BSTR).
	//If string, roleStr will be not null. Will need to free it.
	bool GetRoleIntOrString(out int& roleInt, out BSTR& roleStr) const {
		roleStr = null;
		_variant_t v;
		if (0 != ao::GetRoleIntAndVariant(acc, elem, out roleInt, out v)) return false;
		if (v.vt == VT_BSTR) roleStr = v.Detach().bstrVal;
		return true;
	}

	//Calls acc->accNavigate and gets IAccessible/elem from VARIANT using standard pattern which may involve get_accParent/get_accChild.
	//Does not support PARENT and CHILD (asserts). If NAVDIR_FIRSTCHILD or NAVDIR_LASTCHILD, elem must be 0 (asserts).
	//Does not set a.misc.flags.
	HRESULT Navigate(int navDir, out AccRaw& a) const {
		assert(!(navDir == NAVDIR_PARENT || navDir == NAVDIR_CHILD)); //our special navdirs
		assert(!(elem != 0 && (navDir == NAVDIR_FIRSTCHILD || navDir == NAVDIR_LASTCHILD)));

		a.acc = null; a.elem = 0;
		_variant_t v;
		int hr = acc->accNavigate(navDir, ao::VE(elem), out & v);
		if (hr == 0 && v.vt != 0) {
			if (elem == 0 && v.vt == VT_I4 && v.lVal != 0 && navDir >= NAVDIR_UP && navDir <= NAVDIR_PREVIOUS) {
				IAccessible* aParent;
				hr = ao::get_accParent(acc, out aParent);
				if (hr == 0) {
					hr = ao::get_accChild(aParent, v.lVal, out a.acc);
					if (hr == 0) aParent->Release();
					else { hr = 0; a.acc = aParent; a.elem = v.lVal; } //note: some AO return wrong childid. Then a will be invalid. Noticed only 1 such object. hr are various. Never mind.
				}
			} else {
				if (v.vt == VT_I4 && v.lVal == 0) PRINTS(L"AO bug: VT_I4 value 0"); //eg .NET submenu-item
				else hr = a.FromVARIANT(acc, ref v, true);
			}
		}
		if (hr == 0 && a.acc == null) hr = S_FALSE;
		return hr;
	}

private:
	/// Gets focused object, which can be a direct child or this.
	/// If neither a child or this is focused, sets a.acc=0 and a.elem=0. Returns 1.
	/// Else if focused is this, sets a.acc=acc and a.elem=0. Does not AddRef.
	/// Else if focused is a simple element, sets a.acc=this and a.elem!=0. Does not AddRef.
	/// Else sets a.acc=child and a.elem=0. Will need to release a.acc.
	HRESULT _get_accFocus(out AccRaw& a) {
		a.Zero();
		_variant_t v;
		HRESULT hr = acc->get_accFocus(out & v);
		if (hr == 0) {
			if (v.vt == 0) hr = 1;
			else if (v.vt == VT_I4 && v.lVal == 0) a.acc = acc;
			else hr = a.FromVARIANT(acc, ref v, true);
		}
		return hr;
	}
public:

	/// Gets focused descendant or this.
	/// Returns 1 if nothing is focused in this. Returns !0 if fails.
	/// If isThis receives true, does not AddRef. Else does AddRef even if ar.a==this.a.
	/// <param name="isThis">Receives true if ar is this.</param>
	HRESULT DescendantFocused(out AccRaw& ar, out bool& isThis, bool directChild = false) {
		isThis = false;
		int hr = _get_accFocus(out ar);
		if (hr != 0) return hr;
		if (ar.acc == acc) {
			if (ar.elem == elem) {
				isThis = true;
				return 0;
			}
			ar.acc->AddRef();
		} else if (!directChild) {
			AccRaw t; bool isThis2;
			if (0 == ar.DescendantFocused(out t, out isThis2) && !isThis2) {
				util::Swap(ref ar, ref t);
				t.Dispose();
			}
		}
		return 0;
	}

};

//The same as AccRaw, but has a dtor which releases the acc, but only if elem is 0. Also does not allow to copy.
class AccDtorIfElem0 : public AccRaw {
	AccDtorIfElem0(AccDtorIfElem0&&) = delete; //disable copying
public:

	AccDtorIfElem0() noexcept {}

	//Does not AddRef.
	AccDtorIfElem0(IAccessible* acc_, int elem_, eAccMiscFlags flags_ = {}) noexcept : AccRaw(acc_, elem_, flags_) {}

	//Does not AddRef.
	AccDtorIfElem0(ref const AccRaw& x) noexcept : AccRaw(x) {}

	//Does not AddRef.
	AccDtorIfElem0(ref const Cpp_Acc& x) noexcept : AccRaw(x) {}

	//Calls Release if elem is 0. Else acc is considered not owned by this.
	~AccDtorIfElem0() {
		if (acc != null && elem == 0) {
			//Perf.First();
			acc->Release();
			//Perf.NW('~');
		}
	}
};

//Provides a memory buffer for AccessibleChildren that can be reused by multiple AccChildren instances.
class AccContext {
public:
	VARIANT* buffer;
	int lenBuffer, maxcc;

	explicit AccContext(int maxcc_ = 10000) noexcept {
		buffer = null;
		lenBuffer = 0;
		maxcc = maxcc_;
	}

	bool Init() {
		if (buffer == null) {
			lenBuffer = min(maxcc, 1000000) + 1;
			do {
				buffer = (VARIANT*)VirtualAlloc(null, lenBuffer * sizeof(VARIANT), MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
			} while (buffer == null && (lenBuffer /= 2) > 5000);
			if (buffer == null) {
				maxcc = lenBuffer = 0;
				return false;
			}
			maxcc = lenBuffer - 1;
		}
		return true;
	}

	~AccContext() {
		if (buffer != null) {
			VirtualFree(buffer, 0, MEM_RELEASE);
			buffer = null;
		}
	}
};

//Gets child AOs.
class AccChildren {
	IAccessible* _parent;
	VARIANT* _v;
	int _count, _i, _startAtIndex;
	bool _exactIndex, _reverse;
	eAccMiscFlags _miscFlags;

public:
	AccChildren(AccContext& context, const Cpp_Acc& parent, int startAtIndex = 0, bool exactIndex = false, bool reverse = false) {
		_parent = parent.acc;
		_miscFlags = parent.misc.flags & eAccMiscFlags::InheritMask;
		_v = null;
		_count = -1;
		_i = 0;
		_exactIndex = exactIndex;
		_reverse = reverse;
		_startAtIndex = startAtIndex;

		//With get_accChildCount was faster in most tested cases, usually 10-20%, sometimes 50%, sometimes same speed, Chrome 30%, WPF 50%, never slower.
		//	Note: get_accChildCount can return different count than AccessibleChildren. Usually more. With this code bad is only when incorrectly returns 0 or >maxcc.
		//	Never mind: with VS 2022 Preview get_accChildCount occasionally hangs when parent is PAGETABLIST of document. OK with only AccessibleChildren.

		//For AccessibleChildren we use buffer of maxcc+1 size.
		//	The buffer is in *context*. Reused by all AccChildren instances of that main function (find, navigate, etc).
		//	Max possible maxcc is 1000000 (24 MB in 64-bit process, 16 MB in 32-bit). If fails to allocate, sets smaller maxcc.

		//Perf.First();
		long n = 0;
#if true
		if (0 == _parent->get_accChildCount(&n) && n > 0 && n <= context.maxcc && context.Init()) {
			n = 0;
			int hr = AccessibleChildren(_parent, 0, context.lenBuffer, context.buffer, &n);
			if (hr < 0) { //rare
				n = 0;
				//PRINTHEX(hr);
				//ao::PrintAcc(_parent);
			} else if (n > 0) {
				//Printf(L"A %i", n);
				if (!(parent.misc.flags & (eAccMiscFlags::UIA | eAccMiscFlags::Java))) {
					n = _RemoveInvisibleNonclient(context.buffer, n, parent.misc.roleByte);
				}

				int memSize = n * sizeof(VARIANT);
				_v = (VARIANT*)malloc(memSize);
				if (_v != null) memcpy(_v, context.buffer, memSize);
				else while (n > 0) VariantClear(&context.buffer[--n]);
			}
		} else n = 0;
#else //bad: Slow anyway when there are >maxcc children. And slower in most cases.
		if (context.Init()) { //else failed to allocate memory, unlikely
			int hr = AccessibleChildren(_parent, 0, context.lenBuffer, context.buffer, &n);
			if (hr < 0) { //rare
				n = 0;
				//PRINTHEX(hr);
				//ao::PrintAcc(_parent);
			} else if (n > 0) {
				if (n <= context.maxcc) { //maxcc default 10000, max 1000000
					//Printf(L"A %i", n);
					if (!(parent.misc.flags & (eAccMiscFlags::UIA | eAccMiscFlags::Java))) {
						n = _RemoveInvisibleNonclient(context.buffer, n, parent.misc.roleByte);
					}

					int memSize = n * sizeof(VARIANT);
					_v = (VARIANT*)malloc(memSize);
					if (_v != null) memcpy(_v, context.buffer, memSize);
				} else {
					//Print(n);
					n = min(n, context.lenBuffer);
				}

				if (_v == null) while (n > 0) VariantClear(&context.buffer[--n]);
			}
		}
#endif
		//Perf.NW();

		_count = n;
		if (n > 0 && _startAtIndex != 0) {
			if (_startAtIndex < 0) _startAtIndex = n + _startAtIndex; else _startAtIndex--; //if < 0, it is index from end
			int i = _startAtIndex; if (i < 0) i = 0; else if (i >= n) i = n - 1;
			if (_exactIndex && i != _startAtIndex) _startAtIndex = -1; else _startAtIndex = i;
		} else _startAtIndex = -1; //not used

		//speed: AccessibleChildren same as IEnumVARIANT with array. IEnumVARIANT.Next(1, ...) much slower (if out-proc).

		//50% AO have 0 children. 20% have 1 child. Few have > 7.
	}

	~AccChildren() {
		if (_v != null) {
			while (_count > 0) VariantClear(&_v[--_count]); //info: it's OK to clear variants for which FromVARIANT was called because then vt is 0
			free(_v); _v = null;
		}
	}

	int Count() { return _count; }

	bool GetNext(out AccRaw& a) {
		assert(a.IsEmpty());
		if (_count == 0) return false;
		if (_exactIndex) {
			int i = _startAtIndex; _startAtIndex = -1;
			if (i < 0 || 0 != a.FromVARIANT(_parent, _v[i])) return false;
		} else {
		g1:
			if (_startAtIndex < 0) { //_startAtIndex is -1 if not used
				if (_i >= _count) return false;
				int i = _i++; if (_reverse) i = _count - i - 1;
				if (0 != a.FromVARIANT(_parent, _v[i])) goto g1;
			} else { //_startAtIndex is in _count range
				int i = _startAtIndex + _i;
				if (i < 0 || i >= _count) return false; //no more
				//calculate next i
				if (_i >= 0) {
					_i = -(_i + 1);
					if (_startAtIndex + _i < 0) _i = -_i;
				} else {
					_i = -_i;
					if (_startAtIndex + _i >= _count) _i = -(_i + 1);
				}
				if (0 != a.FromVARIANT(_parent, _v[i])) goto g1;
			}
		}
		a.misc.flags = _miscFlags;
		return true;
	}

private:
	//Removes invisible nonclient children of WINDOW. They are annoying and make slower.
	int _RemoveInvisibleNonclient(VARIANT* v, int n, int role) {
		if (n == 7 && (role == ROLE_SYSTEM_WINDOW || role == 0)) {
			for (int i = 0; i < 7; i++) if (v[i].vt != VT_DISPATCH) goto gr;
			//Perf.First();
			if (role == 0 && ao::GetRoleByte(_parent) != ROLE_SYSTEM_WINDOW) goto gr;
			HWND w; if (0 != WindowFromAccessibleObject(_parent, &w)) goto gr;

			//is it native WINDOW AO? Eg WPF uses role WINDOW instead of CLIENT.
			//Perf.Next();
			{
				//this way is fast, even if not inproc. Tried 2 other ways, both slow.
				//	Bad: the identity string is undocumented, and "clients should not attempt to dissect it or otherwise interpret it manually".
				Smart<IAccIdentity> aid; DWORD* k = nullptr; DWORD len = 0;
				if (0 != _parent->QueryInterface(&aid) || 0 != aid->GetIdentityString(0, (BYTE**)&k, &len)) goto gr;
				//Printf(L"0x%X 0x%X 0x%X 0x%X  w=0x%X", k[0], k[1], k[2], k[3], (int)w);
				bool ok = len == 16 && k[0] == 0x80000001 && k[1] == (DWORD)(LPARAM)w && k[2] == 0 && k[3] == 0; //0x80000001, hwnd, objid (OBJID_WINDOW is 0), childid
				CoTaskMemFree(k);
				if (!ok) goto gr;
			}
			//Perf.Next();

			DWORD bits = 1 << 3; //CLIENT

			DWORD style = wn::Style(w);
			if (style & WS_VSCROLL) bits |= 1 << 4;
			if (style & WS_HSCROLL) bits |= 1 << 5;
			if ((style & (WS_VSCROLL | WS_HSCROLL)) == (WS_VSCROLL | WS_HSCROLL)) bits |= 1 << 6; //GRIP

			if (style & WS_CHILD) {
				//note: child windows cannot have app MENUBAR.
				//note: assume system MENUBAR always visible if TITLEBAR visible; it depends on WS_SYSMENU + on don't know what.
				if ((style & WS_CAPTION) == WS_CAPTION) bits |= 3; //system MENUBAR, TITLEBAR
			} else {
				//With top-level windows don't use style/GetWindowLongPtrW(w, GWL_ID)/GetMenu. Can be custom MENUBAR etc. Here the speed is not so important.
				for (int i = 0; i < 3; i++) {
					Smart<IAccessible> iacc; long state;
					if (0 != v[i].pdispVal->QueryInterface(&iacc)) continue;
					if (0 != ao::get_accState(out state, iacc) || !(state & STATE_SYSTEM_INVISIBLE)) bits |= 1 << i;
				}
			}

			//wn::PrintWnd(w); Print((uint)bits);

			int iMoveTo = 0;
			for (int i = 0; i < 7; i++) {
				if (bits & (1 << i)) {
					if (i != iMoveTo) memmove(v + iMoveTo, v + i, sizeof(VARIANT));
					iMoveTo++;
				} else {
					VariantClear(v + i);
					n--;
				}
			}
			//Perf.NW();
		}
	gr:	return n;

		//never mind: does not remove invisible children of TITLEBAR, SCROLLBAR etc. It could be a custom TITLEBAR etc. Not so important.
	}
};

IAccessible* AccJavaFromWindow(HWND w, bool getFocused = false);
IAccessible* AccJavaFromPoint(POINT p, HWND w);
HRESULT AccUiaFromWindow(HWND w, out IAccessible** iacc);
HRESULT AccUiaFromPoint(POINT p, out IAccessible** iacc);
HRESULT AccUiaFocused(out IAccessible** iacc);
IUIAutomation* UIA();
//HRESULT AccUiaFromMSAA(IAccessible* msaa, int elem, out IAccessible** iacc);


================================================
FILE: Cpp/in-proc.cpp
================================================
//This file contains DllMain and code that injects this dll into other processes and calls functions there.

//Dll injection is used for finding accessible objects (AO). Much faster when runs in the target thread.
//For example, can find an AO in Chrome web page about 60 times faster.
//It seems UI Automation also searches inproc, but somehow it manages to find the same object only 2-3 times faster (instead of 60) than outproc MSAA, and in some cases slower. Also its loading is very slow.
//	Tested: UI Automation is slightly faster when we call it inproc. Depends on window. Can be eg 2 times faster, or same speed.

//The main entry functions to find/get AO are Cpp_AccFind and Cpp_AccFromWindow (in "acc bridge.cpp").
//They call InjectDllAndGetAgent, which injects this dll into the target process (if not already done). Then they call the real 'find AO' etc function in the target thread.

//To inject dll, temporarily sets a WH_CALLWNDPROC hook and sends a message to the target window.
//When injected, creates a message-only window ("agent"), in each target thread. It is used for several purposes:
//	To detect whether the dll is injected into the target process and is ready to call functions in the target thread.
//	To get a proxy COM object that is used to call functions in that process/thread.
//	To unload this dll from processes when need (dll development, setup).

//To call functions in the target process/thread, we hook and call IAccessible::get_accHelpTopic.
//It is probably the easiest way.
//	COM automatically marshals parameters and the returned data (as BSTR).
//	It does not marshal IAccessible objects. For it we use CoMarshalInterface/CoUnmarshalInterface.
//		We don't use LresultFromObject/ObjectFromLresult because it is slower and unreliable (fails when returning multiple objects).
//Another possible way - send message. I tested and rejected it. Slightly faster, but has 2 problems:
//	1. Quite big code, need PostMessage (not SendMessage), shared memory, event, 2-3 mutexes, etc, and therefore can be less reliable. Better let COM do all it.
//	2. It can be used to find AO in window. But to find AO in AO would need the hook anyway (I could not find another way, or it would be too complicated).
//	Also, I expected to make 'find all' much faster, because then can search and send/unmarshal results at the same time on different CPU cores. But it made faster only by 15%. Also, calling the final callback function before finishing searching is not a good idea, because then the finder must DoEvents because the callback would probably call object's methods.

//Cannot inject dll into some processes, including:
//	Windows Store apps;
//	Console (not useful anyway);
//	Protected processes (eg antivirus);
//	Processes of higher UAC integrity level (unless this process is uiAccess);
//Tested: works with processes running as another user, if UAC allows it.

//When 'find all', the slowest part is releasing all found AO (if many), because calls the server process for each AO.
//	Partial solution: when used in C#, let GC release later in other thread.
//	However when using 'also' callback, and it says 'stop', remaining objects are released synchronously, which makes much slower.

//For more details, read the code below and code in "acc bridge.cpp".

#include "stdafx.h"
#include "cpp.h"

//#ifdef _DEBUG
//void InProcAccTest(IAccessible* a);
//#endif

HMODULE s_moduleHandle; //module handle of this dll

namespace {
	const STR c_agentWindowClassName = L"AuCpp_IPA_1"; //in-proc agent window class name
	const int c_agentWndExtra = 200; //size of agent window's extra memory, which contains its AO marshal data
}

//Namespace inproc contains code used only in the server process.
//Namespace outproc contains code used only in the client process.
namespace inproc {
	long s_nAgentThreads; //how many threads in this process have our agent window
	ATOM s_agentWindowClassAtom;
	thread_local HWND t_agentWnd;
}
namespace outproc {
#ifdef AGENTCACHE
	void HwndTidCache_OnThreadDetach();
#endif
}

namespace str::pcre {
	void thread_detach();
}

BOOL APIENTRY DllMain(HMODULE hModule, DWORD ul_reason_for_call, LPVOID lpReserved) {
	switch (ul_reason_for_call) {
	case DLL_PROCESS_ATTACH:
//	{
//#if _M_ARM64EC //currently not used
//		STR arch = L"ARM64EC";
//#elif _M_ARM64
//		STR arch = L"ARM64";
//#elif _M_X64
//		STR arch = L"x64";
//#else
//		STR arch = L"x86";
//#endif
//		wchar_t b[500];
//		GetModuleFileNameW(hModule, b, 500);
//		Printf(L"P+  %i %s    tid=%i   arch=%s  dll=%s", GetCurrentProcessId(), GetCommandLineW(), GetCurrentThreadId(), arch, b);
//	}
	s_moduleHandle = hModule;
	break;
	//case DLL_PROCESS_DETACH:
	//	Printf(L"P-  %i %s    tid=%i", GetCurrentProcessId(), GetCommandLineW(), GetCurrentThreadId());
	//	break;
	//case DLL_THREAD_ATTACH:
	//	Printf(L"T+  %i %i", GetCurrentProcessId(), GetCurrentThreadId());
	//	break;
	case DLL_THREAD_DETACH:
		//Printf(L"T-  %i %i", GetCurrentProcessId(), GetCurrentThreadId());
		HWND wAgent = inproc::t_agentWnd;
		if (wAgent) DestroyWindow(wAgent);
#ifdef AGENTCACHE
		outproc::HwndTidCache_OnThreadDetach();
#endif
		str::pcre::thread_detach();
		break;
	}
	return TRUE;
}

HRESULT AccGetProps(Cpp_Acc a, STR props, out BSTR& sResult);
HRESULT AccGetProp(Cpp_Acc a, WCHAR prop, out BSTR& sResult);
HRESULT AccWeb(IAccessible* iacc, STR what, out BSTR& sResult);
HRESULT AccEnableChrome2(HWND w, int i, HWND c);

namespace inproc {
	HRESULT AccFindOrGet(MarshalParams_Header* h, IAccessible* iacc, out BSTR& sResult);
	HRESULT ShellExec(MarshalParams_Header* h, out BSTR& sResult);

	//Our hook of get_accHelpTopic.
	HRESULT STDMETHODCALLTYPE Hook_get_accHelpTopic(IAccessible* iacc, out BSTR& sResult, VARIANT vParams, long* pMagic) {
		if (vParams.vt == VT_BSTR) {
			//try {
			auto size = SysStringByteLen(vParams.bstrVal);
			if (size >= sizeof(MarshalParams_Header)) {
				*pMagic = c_magic;
				auto h = (MarshalParams_Header*)vParams.bstrVal;
				auto p = (MarshalParams_AccElem*)h;
				if (h->magic == c_magic) {
					sResult = null;
					HRESULT hr = 0;
					switch (h->action) {
						//#ifdef _DEBUG
						//				case InProcAction::IPA_AccTest:
						//					InProcAccTest(iacc);
						//					break;
						//#endif
					case InProcAction::IPA_AccFind:
					case InProcAction::IPA_AccFromWindow:
					case InProcAction::IPA_AccFromPoint:
					case InProcAction::IPA_AccFocused:
					case InProcAction::IPA_AccNavigate:
						hr = AccFindOrGet(h, iacc, sResult);
						break;
					case InProcAction::IPA_AccGetProps:
						hr = AccGetProps(Cpp_Acc(iacc, p->elem, h->miscFlags), (STR)(p + 1), out sResult);
						break;
					case InProcAction::IPA_AccGetWindow:
						hr = AccGetProp(Cpp_Acc(iacc, 0, h->miscFlags), 'w', out sResult);
						break;
					case InProcAction::IPA_AccGetHtml:
						hr = AccWeb(iacc, (STR)(h + 1), sResult);
						break;
					case InProcAction::IPA_AccEnableChrome:
						hr = AccEnableChrome2((HWND)(LPARAM)((MarshalParams_AccInt4*)h)->i0, ((MarshalParams_AccInt4*)h)->i1, (HWND)(LPARAM)((MarshalParams_AccInt4*)h)->i2);
						break;
					case InProcAction::IPA_ShellExec:
						hr = ShellExec(h, out sResult);
						break;
					}
					return hr;
				}
			}
			//} catch(...) { PRINTS(L"exception"); }
			//don't need try/catch. COM catches SEH and C++ exceptions and returns hresult "The server threw an exception".
			//	Also don't need /EHa. We don't throw and don't expect any exceptions.
		}
		return E_NOTIMPL;
		//never mind: we don't call the old method. Nobody implement or use it. MSDN: "is deprecated and should not be used".
	}
} //namespace inproc

#pragma region marshal unmarshal agent IAccessible

namespace inproc {
	HookIAccessible s_hookIAcc;

	//Gets wAgent AO, hooks its IAccessible interface, calls CoMarshalInterface, writes the data to the window extra memory (SetWindowLong).
	IStream* MarshalAgentIAccessible(HWND wAgent) {
		//Perf.First();
		Smart<IAccessible> iacc;
		if (AccessibleObjectFromWindow(wAgent, OBJID_WINDOW, IID_IAccessible, (void**)&iacc)) return null;
		if (!s_hookIAcc.Hook(iacc)) return null;

		Smart<IStream> stream;
		CreateStreamOnHGlobal(0, true, &stream);
		if (CoMarshalInterface(stream, IID_IAccessible, iacc, MSHCTX_LOCAL, null, MSHLFLAGS_TABLESTRONG)) return null;

		DWORD streamSize, readSize;
		if (!istream::GetPos(stream, out streamSize)) return null;
		//Print((int)streamSize); //68
		assert(streamSize <= c_agentWndExtra / 2); //c_agentWndExtra=200
		if (streamSize > c_agentWndExtra - 4) return null;

		long b[c_agentWndExtra / 4];
		if (!istream::ResetPos(stream) || stream->Read(b, streamSize, &readSize) || readSize != streamSize || !istream::ResetPos(stream)) return null;

		SetWindowLongW(wAgent, 0, streamSize);
		for (DWORD i = 0; i < streamSize; i += 4) SetWindowLongW(wAgent, i + 4, b[i / 4]);

		return stream.Detach();
		//Perf.NW(); //190
	}
}

namespace outproc {
	//Reads wAgent AO marshal data from the window extra memory (GetWindowLongPtrW), calls CoUnmarshalInterface.
	bool UnmarshalAgentIAccessible(HWND wAgent, out IAccessible*& iacc) {
		iacc = null;

		DWORD streamSize = (DWORD)GetWindowLongPtrW(wAgent, 0); if (streamSize == 0) return false;
		long b[c_agentWndExtra / 4];
		for (DWORD i = 0; i < streamSize; i += 4) b[i / 4] = (long)GetWindowLongPtrW(wAgent, i + 4);

		HGLOBAL hg = GlobalAlloc(GMEM_MOVEABLE, streamSize); if (hg == 0) return false;
		LPVOID mem = GlobalLock(hg); memcpy(mem, b, streamSize); GlobalUnlock(mem);

		Smart<IStream> stream;
		CreateStreamOnHGlobal(hg, true, &stream);
		if (CoUnmarshalInterface(stream, IID_IAccessible, (void**)&iacc)) return false;
		//TODO3: once run.it in TT process started to always print warning "Failed to run as non-admin.".
		//	Attached debugger shows that CoUnmarshalInterface fails.
		//	OK in other processes. OK after restarting TT. Can't reproduce.

		return true;
	}
}
#pragma endregion

namespace uia { bool UiaDisconnectWrappers(); }

namespace inproc {
	//Thread proc that unloads this dll.
	//Waits while all agent windows closed, unregisters agent window class, calls FreeLibraryAndExitThread.
	DWORD WINAPI UnloadDllThreadProc(LPVOID lpParameter) {
		Sleep(15);
		//MSDN: "No window classes registered by a DLL are unregistered when the DLL is unloaded. A DLL must explicitly unregister its classes when it is unloaded."
		while (s_agentWindowClassAtom && !UnregisterClassW((STR)s_agentWindowClassAtom, s_moduleHandle) && GetLastError() != ERROR_CLASS_DOES_NOT_EXIST) {
			Printf(L"UnregisterClass failed. Error 0x%X", GetLastError());
			Sleep(50);
		}
		s_agentWindowClassAtom = 0;
		Sleep(100);
		if (!AccDisconnectWrappers() | !uia::UiaDisconnectWrappers()) return 0;

		FreeLibraryAndExitThread(s_moduleHandle, 0);
		return 0;
	}

	//Agent window procedure.
	LRESULT WINAPI AgentWndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) {
		//agent window's AO marshal data, to pass to CoReleaseMarshalData on WM_NCDESTROY, because marshaled with MSHLFLAGS_TABLESTRONG
		static thread_local IStream* t_agentStream;

		switch (msg) {
		case WM_CREATE:
		{
			if (!(t_agentStream = MarshalAgentIAccessible(hwnd))) return -1; //-1 destroys the window
		} break;
		} //else Print(msg);

		auto R = DefWindowProcW(hwnd, msg, wParam, lParam);

		if (msg == WM_NCDESTROY) {
			//this normally happens in two cases:
			//	1. This thread is ending. Then our DllMain calls DestroyWindow.
			//	2. Called Cpp_Unload. It closes all agent windows.

			if (t_agentStream) {
				//release marshal data, because marshaled with MSHLFLAGS_TABLESTRONG
				HRESULT hr = CoReleaseMarshalData(t_agentStream); if (hr) PRINTHEX(hr);
				t_agentStream->Release(); t_agentStream = null;
			}
			t_agentWnd = 0;

			if (0 == InterlockedDecrement(&s_nAgentThreads)) {
				//unload dll
				CloseHandle(CreateThread(null, 64 * 1024, UnloadDllThreadProc, null, 0, null));
			}
		}

		return R;
	}

	//Creates agent window.
	//First time in process registers window class and increments dll refcount.
	HWND CreateAgentWindow() {
		if (!t_agentWnd) {
			if (1 == InterlockedIncrement(&s_nAgentThreads)) {
				//increment dll refcount to prevent unloading this dll when the caller process unhooks this hook
				HMODULE hm = 0;
				GetModuleHandleEx(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (STR)s_moduleHandle, &hm);

				WNDCLASS c = { };
				c.hInstance = s_moduleHandle;
				c.lpfnWndProc = AgentWndProc;
				c.lpszClassName = c_agentWindowClassName;
				c.cbWndExtra = c_agentWndExtra; //for IAccessible marshaling data
				s_agentWindowClassAtom = RegisterClassW(&c);
				if (!s_agentWindowClassAtom) PRINTF(L"failed to register class. Error 0x%X", GetLastError());
			}

			wchar_t name[12]; _itow(GetCurrentThreadId(), name, 10);
			t_agentWnd = CreateWindowExW(WS_EX_NOACTIVATE, (STR)s_agentWindowClassAtom, name, WS_POPUP, 0, 0, 0, 0, HWND_MESSAGE, 0, 0, 0);
		}
		//Printf(L"s_nAgentThreads=%i t_agentWnd=%i s_agentWindowClassAtom=%i", s_nAgentThreads, (int)t_agentWnd, s_agentWindowClassAtom);
		return t_agentWnd;
	}

	//SetWindowsHookEx(WH_CALLWNDPROC) hook procedure.
	//If message==WM_NULL and wParam==c_magic, creates agent window and returns its handle.
	LRESULT WINAPI HookCallWndProc(int nCode, WPARAM wParam, LPARAM lParam) {
		CWPSTRUCT& m = *(CWPSTRUCT*)lParam;

		if (m.message == WM_NULL && m.wParam == c_magic) {
			HWND wAgent = CreateAgentWindow();
			ReplyMessage((LRESULT)wAgent);
			return 1;
			//tested: not faster if we unhook before creating window
		} //else Print(m.message);

		return CallNextHookEx(0, nCode, wParam, lParam);
	}
} //namespace inproc

namespace outproc {
	//Injects this dll into the target process/thread.
	//Uses the SetWindowsHookEx/SendMessage method.
	//w - a window in the target thread.
	//tid, pid - target thread/process id. This func could call GetWindowThreadProcessId, but the caller already did it.
	//Returns: agent window.
	HWND InjectDll(HWND w, DWORD tid, DWORD pid) {
		auto hh = SetWindowsHookExW(WH_CALLWNDPROC, inproc::HookCallWndProc, s_moduleHandle, tid);
		if (hh == 0) return 0;
		HWND wAgent = (HWND)SendMessageW(w, 0, c_magic, 0);
		UnhookWindowsHookEx(hh);
		return wAgent;

		//problem: does not work with windows of class "Windows.UI.Core.CoreWindow", ie Windows Store app processes.
		//	SetWindowsHookEx succeeds, but the hook proc is never called, and the dll is not injected.
		//	But SendMessage works, eg WM_CLOSE closes the app.
		//	The CreateRemoteThread(LoadLibrary) method fails too. LoadLibrary returns 0.
		//	Found some info on the internet. The dll must be signed etc. Or it can be in system directory, and with LoadLibrary use just file name.
		//	Also there are other protected processes, for example some system processes, antivirus, protected processes of web browsers.

		//Also does not work with console windows. Not a problem, because there are no useful AO.
		//	SetWindowsHookEx sets error 0x57, "The parameter is incorrect".
		//	The console window actually belongs to the conhost process, and GetWindowThreadProcessId lies.
	}

#pragma region transition 64/32 bit or 64/arm64

	//Called by Au.DllHost.exe.
	//Calls InjectDll.
	EXPORT void Cpp_Arch(STR a0, STR a1) {
		HWND w = (HWND)(LPARAM)strtoi(a0);
		HANDLE ev = (HANDLE)(LPARAM)strtoi(a1);
		DWORD pid, tid = GetWindowThreadProcessId(w, &pid); if (tid == 0) return;
		HWND wa = InjectDll(w, tid, pid);
		if (wa) SetEvent(ev);
	}

	//Finds and executes Au.DllHost.exe for arch architecture (1 32-bit, 2 x64, 3 ARM64), which calls InjectDll.
	bool SwitchArchAndInjectDll(HWND w, int arch) {
		str::StringBuilder b;
		b << L"\"";
		auto m = b.GetBufferToAppend();
		b.FixBuffer(GetModuleFileNameW(s_moduleHandle, m.p, m.n) - 10); //eg "program\64"
		int len = b.Length();
		LPWSTR s = b, end = s + len;

#if _M_ARM64 //this dll is ARM64 on ARM64 OS. Find dir of x86 (arch 1) or x64 (arch 2).
		if (b.EndsI(LR"(\64\ARM)")) {
			b.ReplaceTail(6, arch == 1 ? L"32" : L"64");
		} else if (b.EndsI(LR"(\runtimes\win-arm64\native)")) { //using Au nuget
			b.ReplaceTail(12, arch == 1 ? L"x86\\native" : L"x64\\native");
		} else { //probably in app dir, eg in temp dir when published single-file
			b << (arch == 1 ? L"\\32" : L"\\64");
		}
#elif _WIN64 //this dll is x64 on any OS. Find dir of x86 (arch 1) or ARM64 (arch 3).
		if (s[len - 3] == '\\' && s[len - 2] == '6' && s[len - 1] == '4') {
			b.ReplaceTail(2, arch == 1 ? L"32" : L"64\\ARM");
		} else if (b.EndsI(LR"(\runtimes\win-x64\native)")) { //using Au nuget
			b.ReplaceTail(10, arch == 1 ? L"x86\\native" : L"arm64\\native");
		} else { //probably in app dir, eg in temp dir when published single-file
			b << (arch == 1 ? L"\\32" : L"\\64\\ARM");
		}
#else //this dll is x86 on any OS. Find dir of x64 (arch 2) or ARM64 (arch 3).
		if (s[len - 3] == '\\' && s[len - 2] == '3' && s[len - 1] == '2') {
			b.ReplaceTail(2, arch == 2 ? L"64" : L"64\\ARM");
		} else if (b.EndsI(LR"(\runtimes\win-x86\native)")) { //using Au nuget
			b.ReplaceTail(10, arch == 2 ? L"x64\\native" : L"arm64\\native");
		} else { //probably in app dir, eg in temp dir when published single-file
			b << (arch == 2 ? L"\\64" : L"\\64\\ARM");
		}
#endif

		b << L"\\Au.DllHost.exe";
		//Printf(L"run: %s", (wchar_t*)b);
		if (GetFileAttributes(b + 1) == INVALID_FILE_ATTRIBUTES) return 0;
		b << L"\" ";

		SECURITY_ATTRIBUTES sa = { }; sa.bInheritHandle = true;
		CHandle ev(CreateEventW(&sa, false, false, null)); //not necessary, but makes faster

		b << (__int64)w << ' ' << (__int64)ev.m_h;

		STARTUPINFOW si = { }; si.cb = sizeof(si); si.dwFlags = STARTF_FORCEOFFFEEDBACK;
		PROCESS_INFORMATION pi;
		bool ok = CreateProcessW(null, b, null, null, true, 0, null, null, &si, &pi);
		if (ok) {
			CloseHandle(pi.hThread);
			HANDLE ha[] = { ev, pi.hProcess };
			ok = WAIT_OBJECT_0 == WaitForMultipleObjects(2, ha, false, INFINITE);
			CloseHandle(pi.hProcess);
		}
		return ok;
	}

#pragma endregion

	//Simple cache of a window, its thread id and optionally AO.
	//Can make faster, for example when waiting.
	//Use thread_local.
	class HwndTidCache {
		DWORD _tid, _hwnd;
		ULONGLONG _time;
#ifdef AGENTCACHE
		IAccessible* _iaccAgent; //rejected. Too many problems. The speed improvement in many cases is very small.
#endif
	public:
		HwndTidCache() noexcept {
			ZEROTHIS;
		}

#ifdef AGENTCACHE
		//~HwndTidCache() {
		//	if(_iaccAgent) _iaccAgent->Release();
		//	//if(_iaccAgent) {
		//	//	Print(1);
		//	//	_iaccAgent->Release();
		//	//	Print(2);
		//	//}
		//}
		//shoulddo: release _iaccAgent always. Now dtor is disabled because of this problem:
		//	Release hangs.
		//	Conditions:
		//		Win7 (tested only on the virtual PC).
		//		.NET primary STA thread. Only when primary, only when STA, only of primary appdomain.
		//	Possible reasons (I guess):
		//		dtor is called while unloading this dll.
		//		.NET uninitializes COM before dtor is called.

		//this is a workaround for the above problem.
		//called on DLL_THREAD_DETACH, which is not called for the primary thread.
		//now we will not have memory leaks in most cases, and in other cases it is not so important.
		void OnThreadDetach() {
			if (_iaccAgent) {
				//Print(1);
				_iaccAgent->Release();
				//Print(2);
				_iaccAgent = null;
			}
		}
		//is dtor always called? No. Eg not called for threadpool threads. Called for the primary thread and for threads that end before the process ends.
		//~HwndTidCache() {
		//	if(_iaccAgent) Printf(L"dtor, %i", GetCurrentThreadId());
		//}

		bool Get(DWORD tid, out HWND& w, out IAccessible** iaccAgent = null) {
			if (tid != _tid) return false;
			ULONGLONG time = GetTickCount64(); if (time - _time > 5000) return false;
			HWND wCached = (HWND)(LPARAM)_hwnd;
			if (tid != GetWindowThreadProcessId(wCached, null)) return false;
			_time = time;
			w = wCached;
			if (iaccAgent) *iaccAgent = _iaccAgent;
			return true;
		}

		void Set(DWORD tid, HWND w, IAccessible* iaccAgent = null) {
			_tid = tid;
			_hwnd = (int)(LPARAM)w;
			if (_iaccAgent) _iaccAgent->Release(); //problem: hangs if agent's thread now is in a blocked wait function or busy.
			_iaccAgent = iaccAgent;
			_time = GetTickCount64();
		}
#else

		bool Get(DWORD tid, out HWND& w) {
			if (tid != _tid) return false;
			ULONGLONG time = GetTickCount64(); if (time - _time > 5000) return false;
			HWND wCached = (HWND)(LPARAM)_hwnd;
			if (tid != GetWindowThreadProcessId(wCached, null)) return false;
			_time = time;
			w = wCached;
			return true;
		}

		void Set(DWORD tid, HWND w) {
			_tid = tid;
			_hwnd = (int)(LPARAM)w;
			_time = GetTickCount64();
		}
#endif
	};

#ifdef AGENTCACHE
	thread_local HwndTidCache t_agentCache, t_failedCache;

	void HwndTidCache_OnThreadDetach() {
		t_agentCache.OnThreadDetach();
	}
#else
	thread_local HwndTidCache t_failedCache;
#endif

	//Finds agent window and gets its AO.
	//If dll still not injected, injects and creates agent window.
	//w - a window in the target process/thread.
	//iaccAgent - receives agent's AO. Don't Release, it's cached.
	//wAgent - receives agent window. Optional.
	//Returns: 0, eError::WindowClosed, eError::WindowOfThisThread, eError::UseNotInProc, eError::Inject.
	HRESULT InjectDllAndGetAgent(HWND w, out IAccessible*& iaccAgent, out HWND* wAgent /*= null*/) {
		HWND wa = 0;
		DWORD pid, tid = GetWindowThreadProcessId(w, &pid); if (tid == 0) return (HRESULT)eError::WindowClosed;

		//use a simple cache to make faster, for example when waiting for AO in w
#ifdef AGENTCACHE
		if (t_agentCache.Get(tid, out wa, out & iaccAgent)) {
			if (wAgent) *wAgent = wa;
			return 0;
		}
#endif
		HWND wFailed; if (t_failedCache.Get(tid, out wFailed)) return (HRESULT)eError::Inject;

		if (tid == GetCurrentThreadId()) return (HRESULT)eError::WindowOfThisThread;

		//problem: cannot inject dll into Store processes.
		//	tested: uiAccess does not help.
		//	tested: SetProcessRestrictionExemption always returns true, but dll injection fails. We cannot know whether a license exists.
		//		MSDN says "This function only succeeds if a developer license is present on the system.". Probably the API does not work as documented.
		//		tested: AcquireDeveloperLicense. It opens the Settings app -> security. No options to acquire a license.
		//		see also: https://superuser.com/questions/496104/windows-8-developer-license
		//	note: the child Windows.UI.Core.CoreWindow runs in other process than its host ApplicationFrameWindow. We need to inject into the control's process. Injection into the host's process succeeds but is useless.
		if (wn::ClassNameIs(GetAncestor(w, GA_ROOT), { L"ApplicationFrameWindow", L"Windows.UI.Core.CoreWindow", L"ConsoleWindowClass", L"SunAwt*" }))
			return (HRESULT)eError::UseNotInProc;

		static CHandle s_mutex(CreateMutexW(SecurityAttributes::Common(), false, L"AuCpp_MutexGAW"));
		DWORD wfso = WaitForSingleObject(s_mutex, INFINITE);
		assert(wfso == 0 || wfso == WAIT_ABANDONED);
		AutoReleaseMutex arm(s_mutex);

		//Perf.First();
		wchar_t name[12]; _itow(tid, name, 10);
		wa = wn::FindWndEx(HWND_MESSAGE, 0, c_agentWindowClassName, name);
		//Perf.Next();
		if (!wa) {
			int arch = Cpp_GetProcessArchitecture(pid);
			//Printf(L"arch=%i", arch);
			//Perf.Next();
			bool ok = arch > 0;
			if (ok) {
				if (arch == GetProcessArchitecture()) {
					wa = InjectDll(w, tid, pid);
				} else if (SwitchArchAndInjectDll(w, arch)) {
					wa = wn::FindWndEx(HWND_MESSAGE, 0, c_agentWindowClassName, name);
				}
				ok = !!wa;
			}
			//Perf.Next();

			if (!ok) {
				if (!IsWindow(w)) return (HRESULT)eError::WindowClosed;
				t_failedCache.Set(tid, w);
				return (HRESULT)eError::Inject;
			}
		}
		//Perf.Write();

		if (!UnmarshalAgentIAccessible(wa, iaccAgent)) {
			t_failedCache.Set(tid, w);
			return (HRESULT)eError::Inject;
		}

#ifdef AGENTCACHE
		t_agentCache.Set(tid, wa, iaccAgent);
#endif

		if (wAgent) *wAgent = wa;
		return 0;
	}

#ifdef _DEBUG
	EXPORT void Cpp_InProcTest(IAccessible* a) {
		InProcCall ic;
		ic.AllocParams(a, InProcAction::IPA_AccTest, sizeof(MarshalParams_Header));
	}
#endif

} //namespace outproc


================================================
FILE: Cpp/internal.h
================================================
//This file is #included in all cpp files through Cpp.h.

#pragma once
#include "stdafx.h"


//Internal flags used by 'find AO' functions.
enum class eAF2 {
	//these are from role prefix
	InWebPage = 1, //"web:", "firefox:" or "chrome:"
	InFirefoxPage = 2, //"firefox:", or "web:" and detected Firefox
	InChromePage = 4, //"chrome:", or "web:" and detected Chrome
	InIES = 8, //"web:", detected IE web browser control

	NotInProc = 0x100, //from eAF::NotInProc
	FindAll = 0x200,
	GetRects = 0x400,

	//these are from prop parameter
	InControls = 0x40, //"class=x" or "id=x"
	IsRectL = 0x1000,
	IsRectT = 0x2000,
	IsRectW = 0x4000,
	IsRectH = 0x8000,
	IsRect = 0xF000,
	IsElem = 0x10000,
	IsId = 0x20000, //"id=x", where x is a number

	InFirefoxNotWebNotUIA = 0x100000,
};
ENABLE_BITMASK_OPERATORS(eAF2);

struct RECTWH { long L; long T; long W; long H; };

//AccFindCallback return type.
enum class eAccFindCallbackResult { Continue, SkipChildren, StopFound, StopNotFound };

//Type of callback functor that receives results of the AO finder.
using AccFindCallback = const std::function <eAccFindCallbackResult(Cpp_Acc a, int state, int nSiblings)>;

//STR name and str::Wildex value.
struct NameValue {
	STR name;
	str::Wildex value;
};

const STR c_IES = L"Internet Explorer_Server";
const STR c_CRW = L"Chrome_RenderWidgetHostHWND";

enum class eSpecWnd { None, Chrome, Java, OO, Mozilla, ChromeControl, ChromeControl2 };

//wParam of the injection message.
//Also MarshalParams_Header::magic.
const long c_magic = -1'572'289'143;

//MarshalParams_Header::action. Action for the get_accHelpTopic hook function.
enum InProcAction : char {
#ifdef _DEBUG
	IPA_AccTest,
#endif
	IPA_AccFind = 1,
	IPA_AccFromWindow,
	IPA_AccFromPoint,
	IPA_AccFocused,
	IPA_AccNavigate,
	IPA_AccGetProps,
	IPA_AccGetWindow,
	IPA_AccGetHtml,
	IPA_AccEnableChrome,

	IPA_ShellExec = 100,
};

//Common fields of parameters-marshaling structures.
struct MarshalParams_Header {
	int magic;
	InProcAction action;
	eAccMiscFlags miscFlags;
};

//Used for marshaling parameters of Cpp_AccFromWindow when calling the get_accHelpTopic hook function.
struct MarshalParams_AccFromWindow {
	MarshalParams_Header hdr;
	int hwnd; //not HWND, because it must be of same size in 32 and 64 bit process
	DWORD objid;
	DWORD flags; //2 - get name instead of AO
};

//Used for marshaling parameters of Cpp_AccFromPoint when calling the get_accHelpTopic hook function.
struct MarshalParams_AccFromPoint {
	MarshalParams_Header hdr;
	POINT p;
	eXYFlags flags;
	eSpecWnd specWnd;
	int wFP;
};

//Used for marshaling parameters of Cpp_AccFocused when calling the get_accHelpTopic hook function.
struct MarshalParams_AccFocused {
	MarshalParams_Header hdr;
	int hwnd;
	eFocusedFlags flags;
};

//Used for marshaling parameters of Cpp_AccNavigate, Cpp_AccGetProps, etc when calling the get_accHelpTopic hook function.
struct MarshalParams_AccElem {
	MarshalParams_Header hdr;
	long elem;
};

//Used for marshaling 1-4 int parameters when calling the get_accHelpTopic hook function.
struct MarshalParams_AccInt4 {
	MarshalParams_Header hdr;
	int i0, i1, i2, i3;
};

namespace outproc {
	HRESULT InjectDllAndGetAgent(HWND w, out IAccessible*& iaccAgent, out HWND* wAgent = null);

	//Calls the hooked get_accHelpTopic in the target process.
	//Packs some parameters, unpacks the returned data.
	class InProcCall {
		IAccessible* _a;
		_variant_t _vParams;
		Bstr _br;
		Smart<IStream> _stream;
		DWORD _resultSize;
	public:
		//Allocates memory to pass parameters.
		//Writes MarshalParams_Header fields. Then let the caller cast the return value to MarshalParams_AccFind* etc and write other fields.
		MarshalParams_Header* AllocParams(Cpp_Acc* a, InProcAction action, size_t size) {
			_a = a->acc;
			_vParams.bstrVal = SysAllocStringByteLen(null, (UINT)size);
			_vParams.vt = VT_BSTR;
			auto h = (MarshalParams_Header*)_vParams.bstrVal;
			h->magic = c_magic;
			h->action = action;
			h->miscFlags = a->misc.flags;
			return h;
		}

		//Allocates memory to pass parameters.
		//Writes MarshalParams_Header fields. Then let the caller cast the return value to MarshalParams_AccFind* etc and write other fields.
		MarshalParams_Header* AllocParams(IAccessible* iacc, InProcAction action, size_t size) {
			Cpp_Acc a(iacc, 0);
			return AllocParams(&a, action, size);
		}

		//Calls the hooked get_accHelpTopic in the target process.
		//Returns 0 if successful. Else returns (HRESULT)eError::X (>0x1000), or a standard COM error code, eg exception, disconnected, etc.
		HRESULT Call() {
			long magic = 0;
			HRESULT hr = _a->get_accHelpTopic(&_br, _vParams, &magic);
			if (magic != c_magic) {
				//possible reasons:
				//	not hooked.
				//	exception in hook. Then magic is rejected.
				//	RPC failed, eg the object is disconnected.
				switch (hr) {
				case E_NOTIMPL: case DISP_E_MEMBERNOTFOUND: case E_INVALIDARG: case S_FALSE: case 0: //guess
					hr = E_NOINTERFACE;
					break;
				}
			}
			return hr;
		}

		HRESULT ReadResultAcc(ref Cpp_Acc& a, bool dontNeedAO = false, RECT* rect = null);

		BSTR DetachResultBSTR() {
			return _br.Detach();
		}

		BSTR GetResultBSTR() {
			return _br;
		}
	};
} //namespace outproc

namespace inproc {
	HRESULT STDMETHODCALLTYPE Hook_get_accHelpTopic(IAccessible* iacc, out BSTR& sResult, VARIANT vParams, long* pMagic);
	bool AccDisconnectWrappers();

	//Sets and restores get_accHelpTopic hook for all IAccessible interface tables.
	//Usually there are 1 or 2 interface tables in a process, but eg Firefox with multiple tabs can have ~10.
	class HookIAccessible {
		struct _RESTORE {
			LPVOID* place; //address of the function pointer in the interface table
			LPVOID oldFunc;
		};

		CSimpleArray<_RESTORE> _a;

		//place - address of the function pointer in the interface table.
		//func - the hook function or the old function (to unhook).
		bool _ReplaceFunctionInTable(LPVOID* place, LPVOID func) {
			DWORD oldProt = 0;
			BOOL vpOK = VirtualProtect(place, sizeof(LPVOID), PAGE_EXECUTE_READWRITE, &oldProt);
			assert(vpOK); if (!vpOK) return false;
			*place = func;
			if (oldProt != PAGE_EXECUTE_READWRITE) VirtualProtect(place, sizeof(LPVOID), oldProt, &oldProt);
			return true;
		}

	public:
		bool Hook(IAccessible* iacc) {
			LPVOID* place = *(LPVOID**)iacc + 16; //&get_accHelpTopic
			LPVOID func = *place; //get_accHelpTopic
			if (func != Hook_get_accHelpTopic) {
				//Printf(L"%p", func);
				static CComAutoCriticalSection _cs; CComCritSecLock<CComAutoCriticalSection> lock(_cs);
				for (int i = 0, n = _a.GetSize(); i < n; i++) if (_a[i].place == place) return true; //some unknown hook may be installed after ours
				if (!_ReplaceFunctionInTable(place, Hook_get_accHelpTopic)) return false;
				_RESTORE r = { place, func };
				_a.Add(r);
			}
			return true;
		}

		~HookIAccessible() {
			for (int i = _a.GetSize() - 1; i >= 0; i--) {
				_RESTORE r = _a[i];
				bool restored = _ReplaceFunctionInTable(r.place, r.oldFunc);
				//Printf(L"restored=%i, func=%p", restored, r.oldFunc);
			}
		}
	};
	extern HookIAccessible s_hookIAcc;

}

enum class eWinFlags {
	AccEnabled = 1,
	AccJavaYes = 8,
	AccJavaNo = 16,
};
ENABLE_BITMASK_OPERATORS(eWinFlags);

class WinFlags {
	CComAutoCriticalSection _cs;
	ATOM _atom;

	WinFlags(int u) {
		_atom = GlobalFindAtomW(L"PuGVNJS5Ck2lc5K/DYEUwg");
		if (_atom == 0) _atom = GlobalAddAtomW(L"PuGVNJS5Ck2lc5K/DYEUwg");
	}
	//~WinFlags() { GlobalDeleteAtom(_atom); } //don't. Deletes even if currently used by a window prop, making the prop useless.
	//FUTURE: can be simplified, because now don't need dtor

	static WinFlags& _Inst() {
		static WinFlags s_inst(0);
		return s_inst;
	}

public:
	static eWinFlags Get(HWND w) {
		return (eWinFlags)(LPARAM)GetPropW(w, (LPCWSTR)_Inst()._atom);
	}

	//Removes removeFlags flags and adds addFlags.
	static void Set(HWND w, eWinFlags addFlags, eWinFlags removeFlags = {}) {
		auto inst = _Inst();
		CComCritSecLock<CComAutoCriticalSection> lock(inst._cs);
		eWinFlags t = Get(w), t0 = t;
		t &= ~removeFlags;
		t |= addFlags;
		if (t != t0) SetPropW(w, (LPCWSTR)inst._atom, (HANDLE)(LPARAM)t);
	}
};


================================================
FILE: Cpp/other.cpp
================================================
#include "stdafx.h"
#include "cpp.h"

namespace other {
	EXPORT HMODULE Cpp_ModuleHandle() {
		return s_moduleHandle;
	}

	LRESULT CALLBACK ClipboardHook(int code, WPARAM wParam, LPARAM lParam) {
		auto m = (MSG*)lParam;
		if (code < 0) goto g1;
		if (m->message == WM_CLIPBOARDUPDATE) {
			//Print("WM_CLIPBOARDUPDATE");
			char cn[256];
			if (0 == GetClassNameA(m->hwnd, cn, sizeof(cn)) || 0 != strcmp(cn, "Au.DWP")) {
				m->message = 0;
				//Print(cn);
			}
			return 0;
		}
	g1:
		return CallNextHookEx(0, code, wParam, lParam);

		//After unhooking, this dll remains loaded until hooked threads receive messages.
		//	To unload when [un]installing, installer uses code like in Cpp_Unload (broadcasts messages).
		//	To unload when building, Cpp project's pre-link event runs BuildEvents.exe which calls Cpp_Unload.
	}

	EXPORT HHOOK Cpp_Clipboard(HHOOK hh) {
		if (hh == NULL) {
			auto hh = SetWindowsHookExW(WH_GETMESSAGE, ClipboardHook, s_moduleHandle, 0);
			return hh;
		} else {
			UnhookWindowsHookEx(hh);
		}
		return NULL;
	}

	//auto-restore the unhandled exception filter used by .NET for UnhandledException event.
	//	Some API replace or remove it. Then UnhandledException does not work.
	//	Known bad API:
	//		Common file dialog API and their wrappers. Fixed on Win11.
	//		WPF on Win11. Eg Panel.Children.Add. Not on Win10 (same .NET version).
	//	This code could be in C#, but then on exception "Unknown hard error" (not in all cases).

	static LPTOP_LEVEL_EXCEPTION_FILTER s_ueh;
	static PVOID s_veh;

	static long __stdcall _Veh(_EXCEPTION_POINTERS* ExceptionInfo) {
		SetUnhandledExceptionFilter(s_ueh);
		return 0;
	}

	EXPORT void Cpp_UEF(BOOL on) {
		if (on) { //called from AppModuleInit_
			SetUnhandledExceptionFilter(s_ueh = SetUnhandledExceptionFilter(0)); //get current UEF
			s_veh = AddVectoredExceptionHandler(1, _Veh); //restore on every exception, handled or not
		} else if (s_veh) { //called on process exit
			SetUnhandledExceptionFilter(s_ueh);
			RemoveVectoredExceptionHandler(s_veh);
			s_veh = null;
		}
	}

	static HWINEVENTHOOK s_iww_hook;

	void __stdcall _IWW_Hook(HWINEVENTHOOK hWinEventHook, DWORD event, HWND hwnd, LONG idObject, LONG idChild, DWORD idEventThread, DWORD dwmsEventTime) {
		if (!(wn::ExStyle(hwnd) & WS_EX_NOACTIVATE)) {
			//wn::PrintWnd(hwnd);
			//Print(hwnd == GetForegroundWindow());

			bool isActive = hwnd == GetForegroundWindow(), activate = !isActive && hwnd == GetActiveWindow();
			if (isActive || activate) {
				UnhookWinEvent(hWinEventHook);
				s_iww_hook = 0;
				if (activate) SetForegroundWindow(hwnd);
			}
		}
	}

	//Workaround for: miniProgram window usually is inactive (eg MessageBox), and may be even under other windows (WPF).
	//	It is because of task process preloading. OS does not activate the first window of an old process.
	//	Workaround: set EVENT_SYSTEM_FOREGROUND hook for this process. It runs whenever a window wants to be active,
	//		even if OS does not activate it. The hook activates the first window and uninstalls self.
	//		It must run in the window's thread (because uses GetActiveWindow), therefore need WINEVENT_INCONTEXT+hmodule and cannot be in C#.
	EXPORT void Cpp_InactiveWindowWorkaround(BOOL on) {
		if (on) {
			s_iww_hook = SetWinEventHook(EVENT_SYSTEM_FOREGROUND, EVENT_SYSTEM_FOREGROUND, (HMODULE)&__ImageBase, _IWW_Hook, GetCurrentProcessId(), 0, WINEVENT_INCONTEXT);
		} else if (s_iww_hook) {
			UnhookWinEvent(s_iww_hook);
			s_iww_hook = 0;
		}
	}
}

namespace {
	//Used for marshaling Cpp_ShellExec (IPA_ShellExec) parameters when calling the get_accHelpTopic hook function.
	//A flat variable-size memory structure (strings follow the fixed-size part).
	struct MarshalParams_ShellExec {
		MarshalParams_Header hdr;
	private:
		int _file, _dir, _verb, _params, _class, _idlist; //offsets
		int _nshow, _hwnd;
		ULONG _mask;

		LPWSTR _SetString(STR s, LPWSTR dest, out int& offset) {
			if (!s) {
				offset = 0;
				return dest;
			}
			int len = (int)wcslen(s);
			memcpy(dest, s, len * 2); dest[len] = 0;
			offset = (int)(dest - (STR)this);
			return dest + len + 1;
		}

		STR _GetString(int offset) {
			if (!offset) return null;
			return (STR)this + offset;
		}

		void _SetIL(void* il, LPWSTR dest, out int& offset) {
			if (!il) {
				offset = 0;
				return;
			}
			int size = ILGetSize((LPCITEMIDLIST)il);
			memcpy(dest, il, size);
			offset = (int)(dest - (STR)this);
		}

		void* _GetIL(int offset) {
			if (!offset) return null;
			return (LPWSTR)this + offset;
		}
	public:
		static int _Size(STR s) {
			return s == null ? 0 : ((int)wcslen(s) + 1) * 2;
		}
		static int _SizeIL(void* idlist) {
			return idlist == null ? 0 : ILGetSize((LPCITEMIDLIST)idlist) + 1 & ~1;
		}

		static int CalcMemSize(const SHELLEXECUTEINFO& x) {
			return sizeof(MarshalParams_ShellExec) + _SizeIL(x.lpIDList) + _Size(x.lpFile) + _Size(x.lpDirectory) + _Size(x.lpParameters) + _Size(x.lpVerb);
		}

#pragma warning(disable: 4302 4311 4312) //conversion HWND <-> int
		void Marshal(const SHELLEXECUTEINFO& x) {
			_mask = x.fMask;
			_nshow = x.nShow;
			_hwnd = (int)x.hwnd;
			auto s = (LPWSTR)(this + 1);
			s = _SetString(x.lpFile, s, out _file);
			s = _SetString(x.lpDirectory, s, out _dir);
			s = _SetString(x.lpVerb, s, out _verb);
			s = _SetString(x.lpParameters, s, out _params);
			s = _SetString(x.lpClass, s, out _class);
			_SetIL(x.lpIDList, s, out _idlist);

			//never mind: the new process does not inherit environment variables.
			//	I don't know how to pass them when using shell prcess. Canot modify its environment variables, even temporarily.
			//	It is documented.
		}

		SHELLEXECUTEINFO Unmarshal() {
			SHELLEXECUTEINFO x = { sizeof(SHELLEXECUTEINFO), _mask };
			x.nShow = _nshow;
			x.hwnd = (HWND)_hwnd;
			x.lpFile = _GetString(_file);
			x.lpDirectory = _GetString(_dir);
			x.lpVerb = _GetString(_verb);
			x.lpParameters = _GetString(_params);
			x.lpClass = _GetString(_class);
			x.lpIDList = _GetIL(_idlist);
			return x;
		}
	};
}

namespace inproc {
	HRESULT ShellExec(MarshalParams_Header* h, out BSTR& sResult) {
		sResult = null;
		auto m = (MarshalParams_ShellExec*)h;
		auto x = m->Unmarshal();
		if (!ShellExecuteExW(&x)) return GetLastError();
		if (x.hProcess) {
			DWORD pid = GetProcessId(x.hProcess);
			CloseHandle(x.hProcess);
			if (pid != 0) sResult = SysAllocStringByteLen((LPCSTR)&pid, 4);
		}
		return 0;
	}
}

namespace other {
	EXPORT bool Cpp_ShellExec(const SHELLEXECUTEINFO& x, out DWORD& pid, out HRESULT& injectError, out HRESULT& execError) {
		pid = 0; injectError = 0; execError = 0;
		Cpp_Acc_Agent aAgent;
		if (0 != (injectError = outproc::InjectDllAndGetAgent(GetShellWindow(), out aAgent.acc))) {
			return false;
		}

		outproc::InProcCall ic;
		auto p = (MarshalParams_ShellExec*)ic.AllocParams(&aAgent, InProcAction::IPA_ShellExec, MarshalParams_ShellExec::CalcMemSize(x));
		p->Marshal(x);
		if (0 != (execError = ic.Call())) return false;

		BSTR b = ic.GetResultBSTR();
		if (b) pid = *(DWORD*)b;

		return true;
	}

	//Unloads this dll (AuCpp.dll) from other processes.
	//flags: 1 wait less.
	EXPORT void Cpp_Unload(DWORD flags = 0) {
		int less = flags & 1 ? 5 : 1;
		DWORD_PTR res;
		std::vector<HWND> a;

		//close acc agent windows
		for (HWND w = 0; w = FindWindowExW(HWND_MESSAGE, w, L"AuCpp_IPA_1", nullptr); ) a.push_back(w);
		int n = (int)a.size();
		if (n > 0) {
			for (int i = 0; i < n; i++) SendMessageTimeout(a[i], WM_CLOSE, 0, 0, SMTO_ABORTIFHUNG, 5000 / less, &res);
			a.clear();
			Sleep(n * 50);
		}

		//unload from processes where loaded by the clipboard hook
		SendMessageTimeout(HWND_BROADCAST, 0, 0, 0, SMTO_ABORTIFHUNG, 1000 / less, &res);
		for (HWND w = 0; w = FindWindowExW(HWND_MESSAGE, w, nullptr, nullptr); ) a.push_back(w);
		for (int i = 0; i < (int)a.size(); i++) SendMessageTimeout(a[i], 0, 0, 0, SMTO_ABORTIFHUNG, 1000 / less, &res);
		Sleep(500 / less);
	}

	//for rundll32.exe
	EXPORT void WINAPI UnloadAuCppDll(HWND hwnd, HINSTANCE hinst, LPSTR lpszCmdLine, int nCmdShow) {
		DWORD flags = (DWORD)atoi(lpszCmdLine);
		Cpp_Unload(flags);
	}

} //namespace other


================================================
FILE: Cpp/rejected.cpp
================================================
#if false


#endif


================================================
FILE: Cpp/resource.h
================================================
//{{NO_DEPENDENCIES}}
// Microsoft Visual C++ generated include file.
// Used by Cpp.rc
//
#define IDR_RT_MANIFEST1                2

// Next default values for new objects
// 
#ifdef APSTUDIO_INVOKED
#ifndef APSTUDIO_READONLY_SYMBOLS
#define _APS_NEXT_RESOURCE_VALUE        103
#define _APS_NEXT_COMMAND_VALUE         40001
#define _APS_NEXT_CONTROL_VALUE         1001
#define _APS_NEXT_SYMED_VALUE           101
#endif
#endif


================================================
FILE: Cpp/stdafx.cpp
================================================
// stdafx.cpp : source file that includes just the standard includes for generating pre-compiled header (pch) file

#include "stdafx.h"


================================================
FILE: Cpp/stdafx.h
================================================
// stdafx.h : include file for standard system include files,
// or project specific include files that are used frequently, but
// are changed infrequently
//

#pragma once

// Including SDKDDKVer.h defines the highest available Windows platform.
// If you wish to build your application for a previous Windows platform, include WinSDKVer.h and set the _WIN32_WINNT macro to the platform you wish to support before including SDKDDKVer.h.
#include <SDKDDKVer.h>

#define WIN32_LEAN_AND_MEAN
#define _CRT_SECURE_NO_WARNINGS

#include <assert.h>
#include <string>
#include <memory>
#include <algorithm>
#include <functional>
#include <initializer_list>

#include <comdef.h>
#include <comdefsp.h> //smart pointers of many interfaces

#include <atlbase.h>
#include <atlcoll.h>
//#include <concrt.h> //critical_section

#include <windows.h>
#include <Sddl.h>
#include <OleAuto.h>
#include <OleAcc.h>
#include <UIAutomation.h>
#include <shellapi.h>
#include <shlobj.h>
#include <shellscalingapi.h>

#define PCRE2_STATIC 1
#define PCRE2_CODE_UNIT_WIDTH 16
#include "..\Libraries\pcre\pcre2.h"



#define null nullptr
#define out
#define ref

using STR = LPCWSTR;

#pragma region enum operators
//http://blog.bitwigglers.org/using-enum-classes-as-type-safe-bitmasks/

template<typename Enum>
struct EnableBitMaskOperators
{
	static const bool enable = false;
};

#define ENABLE_BITMASK_OPERATORS(x) template<> struct EnableBitMaskOperators<x> { static const bool enable = true; }

template<typename Enum> constexpr
std::enable_if_t<EnableBitMaskOperators<Enum>::enable, Enum>
operator |(Enum lhs, Enum rhs)
{
	using underlying = typename std::underlying_type<Enum>::type;
	return static_cast<Enum> (static_cast<underlying>(lhs) | static_cast<underlying>(rhs));
}

template<typename Enum> constexpr
std::enable_if_t<EnableBitMaskOperators<Enum>::enable, Enum>
operator &(Enum lhs, Enum rhs)
{
	using underlying = typename std::underlying_type<Enum>::type;
	return static_cast<Enum> (static_cast<underlying>(lhs) & static_cast<underlying>(rhs));
}

template<typename Enum> constexpr
std::enable_if_t<EnableBitMaskOperators<Enum>::enable, Enum>
operator ^(Enum lhs, Enum rhs)
{
	using underlying = typename std::underlying_type<Enum>::type;
	return static_cast<Enum> (static_cast<underlying>(lhs) ^ static_cast<underlying>(rhs));
}

template<typename Enum>
std::enable_if_t<EnableBitMaskOperators<Enum>::enable, Enum>
& operator |=(Enum& lhs, Enum rhs)
{
	using underlying = typename std::underlying_type<Enum>::type;
	return lhs = static_cast<Enum> (static_cast<underlying>(lhs) | static_cast<underlying>(rhs));
}

template<typename Enum>
std::enable_if_t<EnableBitMaskOperators<Enum>::enable, Enum>
& operator &=(Enum& lhs, Enum rhs)
{
	using underlying = typename std::underlying_type<Enum>::type;
	return lhs = static_cast<Enum> (static_cast<underlying>(lhs) & static_cast<underlying>(rhs));
}

template<typename Enum>
std::enable_if_t<EnableBitMaskOperators<Enum>::enable, Enum>
& operator ^=(Enum& lhs, Enum rhs)
{
	using underlying = typename std::underlying_type<Enum>::type;
	return lhs = static_cast<Enum> (static_cast<underlying>(lhs) ^ static_cast<underlying>(rhs));
}

template<typename Enum> constexpr
std::enable_if_t<EnableBitMaskOperators<Enum>::enable, Enum>
operator ~(Enum rhs)
{
	using underlying = typename std::underlying_type<Enum>::type;
	return static_cast<Enum> (~static_cast<underlying>(rhs));
}

//compiler error: cannot be static
//template<typename Enum>
//operator bool(Enum rhs)
//{
//	using underlying = typename std::underlying_type<Enum>::type;
//	return static_cast<underlying>(rhs) != 0;
//}

template<typename Enum> constexpr
std::enable_if_t<EnableBitMaskOperators<Enum>::enable, bool>
operator !(Enum rhs)
{
	using underlying = typename std::underlying_type<Enum>::type;
	return 0 == static_cast<underlying>(rhs);
}

////Returns true if x has all flags.
//x can be any enum or integer type of size <= 32-bit.
//template<typename E>
//bool F(E x, E flags) {
//	static_assert(sizeof(E) <= 4);
//	return ((int)x&(int)flags) == (int)flags;
//}
//
////Returns true if x has any of flags.
////x can be any enum or integer type of size <= 32-bit.
//template<typename E>
//bool F_ANY(E x, E flags) {
//	static_assert(sizeof(E) <= 4);
//	return (int)x&((int)flags);
//}

#pragma endregion

template<class T, class... Ts>
constexpr bool IsIn(const T& v, Ts... vs) {
    return ((v == vs) || ...);
}


================================================
FILE: Cpp/str.cpp
================================================
#include "stdafx.h"
#include "cpp.h"
#include "MemoryPool.h"

namespace str
{

#pragma region Like, Equals, lowercase table

static WCHAR _caseTable[0x10000];
static bool _caseTableCreated;

//Returns static WCHAR table[0x10000] containing all Unicode characters in that range. Uppercase characters converted to lowercase.
EXPORT STR Cpp_LowercaseTable()
{
	if(!_caseTableCreated) {
		LPWSTR t = _caseTable;
		for(size_t i = 0; i < 0x10000; i++) t[i] = (WCHAR)i;
		CharLowerBuff(t, 0x10000);
		_caseTableCreated = true;
	} //speed: 350
	return _caseTable;
}

inline STR _LowercaseTable() {
	return _caseTableCreated ? _caseTable : Cpp_LowercaseTable();
}

//Compares string s of length lenS with wildcard pattern w of length lenW.
//Returns true if match. Returns false if s==null. Exception if w==null.
//EXPORT //C# has own function. Calling this from C# is significantly slower when string short.
bool Like(STR s, size_t lenS, STR w, size_t lenW, bool ignoreCase /*= false*/)
{
	if(s == null) return false;
	if(lenW == 0) return lenS == 0;
	if(lenW == 1 && w[0] == '*') return true;
	if(lenS == 0) return false;

	STR table = ignoreCase ? _LowercaseTable() : null;
	STR se = s + lenS, we = w + lenW;

	//find '*' from start. Makes faster in some cases.
	for(; (w < we && s < se); w++, s++) {
		size_t cS = s[0], cW = w[0];
		if(cW == '*') goto g1;
		if(cW == cS || cW == '?') continue;
		if((table == null) || (table[cW] != table[cS])) return false;
	}
	if(w == we) return s == se; //w ended?
	goto gr; //s ended
g1:

	//find '*' from end. Makes "*text" much faster.
	for(; (we > w && se > s); we--, se--) {
		size_t cS = se[-1], cW = we[-1];
		if(cW == '*') break;
		if(cW == cS || cW == '?') continue;
		if((table == null) || (table[cW] != table[cS])) return false;
	}

	//Algorithm by Alessandro Felice Cantatore, http://xoomer.virgilio.it/acantato/dev/wildcard/wildmatch.html
	//Changes: supports '\0' in string; case-sensitive or not; restructured, in many cases faster.
	{
		size_t i = 0;
		gStar: //info: goto used because C# compiler makes the loop faster when it contains less code
		w += i + 1;
		if(w == we) return true;
		s += i;

		for(i = 0; s + i < se; i++) {
			size_t sW = w[i];
			if(sW == '*') goto gStar;
			if(sW == s[i] || sW == '?') continue;
			if((table != null) && (table[sW] == table[s[i]])) continue;
			s++; i = -1;
		}

		w += i;
	}
gr:
	while(w < we && *w == '*') w++;
	return w == we;

	//info: Could implement escape sequence ** for * and maybe *? for ?.
	//	But it makes code slower etc.
	//	Not so important.
	//	Most users would not know about it.
	//	Usually can use ? for literal * and ?.
	//	Usually can use regular expression if need such precision.
	//	Then cannot use "**options " for wildcard expressions.
	//	Could use other escape sequences, eg [*], [?] and [[], but it makes slower and is more harmful than useful.

	//The first two loops are fast, but Equals much faster when !ignoreCase. We cannot use its optimizations.
	//The slowest case is "*substring*", because then the first two loops don't help.
	//	Then similar speed as string.IndexOf(ordinal) and API <msdn>FindStringOrdinal</msdn>.
	//	Possible optimization, but need to add much code, and makes not much faster, and makes other cases slower, difficult to avoid it.
}

//Compares string s of length lenS with string w of length lenW.
//Returns true if match. Returns false if s==null. Exception if w==null.
//EXPORT //C# has own function. Calling this from C# is significantly slower when string short.
bool Equals(STR w, size_t lenW, STR s, size_t lenS, bool ignoreCase /*= false*/)
{
	if(s == null || lenS != lenW) return false;
	if(lenW == 0) return true;

	if(!ignoreCase) return 0 == memcmp(s, w, lenW * 2); //fastest

	//optimization: at first compare case-sensitive, as much as possible.
	//	never mind: in 32-bit process this is not the fastest code (too few registers). But makes much faster anyway.
	//	tested: strings don't have to be aligned at 4 or 8.
	while(lenW >= 12) {
		if(*(__int64*)w != *(__int64*)s) break;
		if(*(__int64*)(w + 4) != *(__int64*)(s + 4)) break;
		if(*(__int64*)(w + 8) != *(__int64*)(s + 8)) break;
		w += 12; s += 12; lenW -= 12;
	}

	auto table = _LowercaseTable();
	for(size_t i = 0; i < lenW; i++) {
		size_t c1 = w[i], c2 = s[i];
		if(c1 != c2 && table[c1] != table[c2]) goto gFalse;
	}
	return true; gFalse: return false;
}

//this could be used by C#, but calling unmanaged functions from C# is slow when with 'fixed', which makes much slower with short strings.
//EXPORT bool Cpp_StringEqualsI(STR a, STR b, int len)
//{
//	if(len != 0) {
//		//optimization: at first compare case-sensitive, as much as possible.
//		//	never mind: in 32-bit process this is not the fastest code (too few registers). But makes much faster anyway.
//		//	tested: strings don't have to be aligned at 4 or 8.
//		while(len >= 12) {
//			if(*(__int64*)a != *(__int64*)b) break;
//			if(*(__int64*)(a + 4) != *(__int64*)(b + 4)) break;
//			if(*(__int64*)(a + 8) != *(__int64*)(b + 8)) break;
//			a += 12; b += 12; len -= 12;
//		}
//
//		auto table = _LowercaseTable();
//
//		for(size_t i = 0; i < len; i++) {
//			size_t c1 = a[i], c2 = b[i];
//			if(c1 != c2 && table[c1] != table[c2]) goto gFalse;
//		}
//	}
//	return true; gFalse: return false;
//}

#pragma endregion

//EXPORT void Cpp_Free(void* p) {
//	if(p) free(p);
//}


namespace pcre
{

BSTR _GetErrorMessage(int code, int compileErrorOffset)
{
	WCHAR b[300]; b[0] = 0;
	auto t = b;
	if(compileErrorOffset >= 0) {
		wcscat(t, L"Regular expression error at offset "); t += wcslen(t);
		_itow((int)compileErrorOffset, t, 10); t += wcslen(t);
		wcscat(t, L": "); t += 2;
	}
	pcre2_get_error_message_16(code, t, _countof(b) - (t - b));
	return SysAllocString(b);
}

//Calls pcre2_get_error_message_16 and returns SysAllocString.
BSTR GetErrorMessage(int code) {
	return _GetErrorMessage(code, -1);
}

//Calls pcre2_compile_16.
//This version is used in this dll, eg by Wildex.
//Adds PCRE2_UTF if rx contains non-ASCII characters and flags does not contain PCRE2_UTF or PCRE2_NEVER_UTF.
//More info in Cpp_RegexCompile.
pcre2_code_16* Compile(STR rx, size_t len, __int64 flags /*= 0*/, out BSTR* errStr /*= null*/)
{
	int errCode; size_t errOffset;
	UINT f = (UINT)flags, fe = flags >> 32;
	fe &= 0xFFFFFF; //hi 8 bits are used for match flags in C#.

	//If rx contains non-ASCII characters, add PCRE2_UTF flag. Else case-insensitive does not work.
	if(!(f & (PCRE2_UTF | PCRE2_NEVER_UTF))) {
		for(size_t i = 0; i < len; i++) if(rx[i] >= 128) { f |= PCRE2_UTF; break; }
	}

	pcre2_compile_context_16* cc = null;
	if(fe) {
		cc = pcre2_compile_context_create_16(null);
		pcre2_set_compile_extra_options_16(cc, fe);
	}
	auto re = pcre2_compile_16(rx, len, f, &errCode, &errOffset, cc);
	if(cc) pcre2_compile_context_free_16(cc);
	if(re == null) {
		if(errStr)* errStr = _GetErrorMessage(errCode, (int)errOffset);
		return null;
	}
	return re;
}

//Calls/returns pcre2_compile_16. Returns null if fails (errors in regular expression etc).
//This version is called from C#. In this dll use Compile instead.
//flags is __int64 consisting of pcre2_compile_16 flags in lo 32 bits and pcre2_set_compile_extra_options_16 flags in lo 24 bits of hi 32 bits.
//	Adds PCRE2_UTF if rx contains non-ASCII characters and flags does not contain PCRE2_UTF or PCRE2_NEVER_UTF.
//codeSize receives code size (PCRE2_INFO_SIZE).
//errStr, if not null, receives error text when fails. Caller then must SysFreeString it.
EXPORT pcre2_code_16* Cpp_RegexCompile(STR rx, size_t len, __int64 flags, out int& codeSize/*, out int& nGroups*/, out BSTR* errStr = null)
{
	auto code = pcre::Compile(rx, len, flags, errStr);
	if(code != null) {
		size_t z = 0;
		pcre2_pattern_info_16(code, PCRE2_INFO_SIZE, &z);
		codeSize = (int)z;
		//pcre2_pattern_info_16(code, PCRE2_INFO_CAPTURECOUNT, &nGroups); nGroups++;
	} else {
		codeSize = 0;
		//nGroups = 0;
	}
	return code;
}

//If code is not null, calls pcre2_code_free_16 and returns code memory size (PCRE2_INFO_SIZE). Else returs 0.
//This version is called from C#. In this dll use Free instead.
EXPORT int Cpp_RegexDtor(pcre2_code_16* code)
{
	if(code == null) return 0;
	size_t codeSize = 0;
	pcre2_pattern_info_16(code, PCRE2_INFO_SIZE, &codeSize);
	pcre2_code_free_16(code);
	return (int)codeSize;
}

struct _RxMdVec { CHeapPtr<POINT> a; int n; };

//After upgrading PCRE library, this reminds to check/reapply its modifications. Then edit this line.
//More info in config.h in PCRE project.
static_assert(PCRE2_MAJOR == 10 && PCRE2_MINOR == 46);

//Cpp_RegexMatch results.
struct RegexMatch
{
	//[out] Array that receives x=from and y=to of match and submatches.
	//Func allocates thread-local memory for it. Then caller copies it ASAP and does not free.
	//tested: this is the fastest way when caller is C#.
	//Func sets it on full and partial match. Else sets null.
	POINT* vec;

	//[out] vec element count: pcre2_get_ovector_count_16 if matched, 0 if not, 1 if partial.
	int vecCount;

	//[out] pcre2_get_startchar_16.
	int indexNoK;

	//[out] pcre2_get_mark_16.
	STR mark;
};

#define FAST_MD

static void* _mp_malloc(size_t size, void* data) {
	auto mp = (AppShift::Memory::MemoryPool*)data;
	return mp->allocate(size);
}

static void _mp_free(void* block, void* data) {
	auto mp = (AppShift::Memory::MemoryPool*)data;
	mp->free(block);
}

thread_local AppShift::Memory::MemoryPool* t_mp;
thread_local pcre2_general_context_16* t_gc;

//Gets thread_local pcre2_general_context_16 that uses memory pool.
static pcre2_general_context_16* _GetGC() {
	auto gc = t_gc;
	if (gc == null) {
		t_mp = new AppShift::Memory::MemoryPool(25000); //#define START_FRAMES_SIZE 20480, and some for small allocations
		t_gc = gc = pcre2_general_context_create_16(_mp_malloc, _mp_free, t_mp);
	}
	return gc;
}

void thread_detach() {
	if (t_mp == nullptr) return;
	delete t_mp;
	t_mp = nullptr;
	t_gc = nullptr;
}

//Calls pcre2_match_16 and returns its return value. If PCRE2_ERROR_PARTIAL, returns 0.
//Allocates/frees match data in a fast way. Copies results to m, if not null.
//errStr, if not null, receives error text when fails, except when no match or partial match. Caller then must SysFreeString it.
//This version is called from C#. In this dll you can use Free; use this func when need match data (ovector etc).
EXPORT int Cpp_RegexMatch(pcre2_code_16* code, STR s, size_t len, size_t start = 0, UINT flags = 0,
	int(*callout)(pcre2_callout_block*, void*) = null, ref RegexMatch * m = null, bool needM = true, out BSTR * errStr = null)
{
	pcre2_match_data_16* md;
#ifdef FAST_MD
	md = pcre2_match_data_create_from_pattern_16(code, _GetGC());
	//tested: startScope/endScope usually makes slightly slower.
#else
	md = pcre2_match_data_create_from_pattern_16(code, null);
#endif

	int R = pcre2_match_16(code, s, len, start, flags, md, null, callout);

	assert(R != 0); //this could be if md contains too small ovector
	if(R == PCRE2_ERROR_PARTIAL) R = 0;

	if(needM) {
		//info: read PCRE API doc, section "HOW PCRE2_MATCH() RETURNS A STRING AND CAPTURED SUBSTRINGS"
		int n = R > 0 ? pcre2_get_ovector_count_16(md) : (R == 0 ? 1 : 0);
		//Printf(L"R=%i, n=%i", R, n);

		if(n == 0) {
			m->vec = null;
		} else {
			thread_local _RxMdVec t_vec; _RxMdVec& t = t_vec;
			if(t.n < n) {
				if(t.a) t.a.Free();
				if(t.a.Allocate(n)) t.n = (int)n;
				else { t.n = n = 0; R = PCRE2_ERROR_NOMEMORY; }
			}
			POINT* g = t.a;

			auto v = pcre2_get_ovector_pointer_16(md);
			for(int i = 0; i < n; i++) {
				POINT& p = g[i];
				p.x = (int)v[i * 2]; p.y = (int)v[i * 2 + 1];
			}
			m->vec = g;
		}
		m->vecCount = n;
		m->indexNoK = (int)pcre2_get_startchar_16(md);
		m->mark = pcre2_get_mark_16(md);
	}

	static_assert(PCRE2_ERROR_NOMATCH == -1 && PCRE2_ERROR_PARTIAL == -2);
	if(R < PCRE2_ERROR_PARTIAL && errStr != null) {
		*errStr = GetErrorMessage(R);
		//FUTURE: if UTF error, in error text include the offset. It seems pcre2_get_startchar_16 returns it.
	}

	pcre2_match_data_free_16(md);
	return R;
}

//Calls pcre2_match_16 and returns true if it returns >0.
//Allocates/frees match data in a fast way.
//This version is used in this dll, eg by Wildex.
bool Match(pcre2_code_16* code, STR s, size_t len, size_t start, UINT flags)
{
	pcre2_match_data_16* md;
#ifdef FAST_MD
	md = pcre2_match_data_create_from_pattern_16(code, _GetGC());
#else
	md = pcre2_match_data_create_from_pattern_16(code, null);
#endif

	int R = pcre2_match_16(code, s, len, start, flags, md, null, null);

	pcre2_match_data_free_16(md);

	return R > 0 || R == PCRE2_ERROR_PARTIAL;
}
}

#pragma region Wildex

Wildex::~Wildex()
{
	if(_text != null) {
		switch(_type) {
		case WildType::RegexPcre: pcre::Free(_regex); break;
		case WildType::Multi: delete[] _multi_array; break;
		default: if(_freeText) free(_text);
		}
		_text = null;
	}
}

//Parses wildcard expression and initializes this variable.
//On error sets errStr (if not null) and returns false.
//dontCopyString - don't allocate/free own copy of w. The caller keeps w valid while using this variable.
//Call once (asserts).
bool Wildex::Parse(STR w, size_t lenW, bool dontCopyString/* = false*/, out BSTR* errStr/* = null*/)
{
	//if(w == null) return false;
	assert(_text == null); //_text = null; _not = _freeText = false;
	_type = WildType::Wildcard;
	_ignoreCase = true;
	STR es = L"Invalid \"**options \" in wildcard expression.";
	STR split = L"||"; size_t splitLen = 2;

	if(lenW >= 3 && w[0] == '*' && w[1] == '*') {
		for(size_t i = 2, j; i < lenW; i++) {
			switch(w[i]) {
			case 't': _type = WildType::Text; break;
			case 'r': _type = WildType::RegexPcre; break;
			case 'm': _type = WildType::Multi; break;
			case 'c': _ignoreCase = false; break;
			case 'n': _not = true; break;
			case ' ': w += ++i; lenW -= i; goto g1;
			case 'R': es = L"Option R in wildcard expression. Use r instead."; //.NET Regex
			case '(':
				if(w[i - 1] != 'm') goto ge;
				for(j = ++i; j < lenW; j++) if(w[j] == ')') break;
				if(j >= lenW || j == i) goto ge;
				split = w + i; splitLen = j - i;
				i = j;
				break;
			default: goto ge;
			}
		}
	ge:
		if(errStr)* errStr = SysAllocString(es);
		return false;
	g1:
		switch(_type) {
		case WildType::RegexPcre: {
			_regex = pcre::Compile(w, lenW, _ignoreCase ? PCRE2_CASELESS : 0, out errStr);
			if(_regex == null) return false;
		} goto gr;
		case WildType::Multi: {
			int count = 1; auto eos = w + lenW; auto splitChar = split[0];
			for(auto t = w; t <= eos - splitLen; ) { //calc part count
				if(t[0] == splitChar && 0 == wcsncmp(t, split, splitLen)) { count++; t += splitLen; } else t++;
			}
			_multi_array = new Wildex[_multi_count = count];

			for(int i = 0; i < count; i++, w += splitLen) {
				STR wi = w;
				if(i == count - 1) w = eos;
				else { //find next splitter
					for(; w <= eos - splitLen; w++) if(w[0] == splitChar && 0 == wcsncmp(w, split, splitLen)) break;
				}
				if(!_multi_array[i].Parse(wi, w - wi, true, out errStr)) return false;
			}
		} goto gr;
		}
	}

	if(_type == WildType::Wildcard && !HasWildcards(w, lenW)) _type = WildType::Text;
	if(dontCopyString) _text = (LPWSTR)w;
	else {
		_text = (LPWSTR)malloc((lenW + 1) * 2); memcpy(_text, w, lenW * 2); _text[lenW] = 0;
		_freeText = true;
	}
	_text_length = (int)lenW;
gr:
	return true;
}

bool Wildex::Match(STR s, size_t lenS) const
{
	if(s == null) return false;

	bool R = false;
	switch(_type) {
	case WildType::Wildcard:
		R = Like(s, lenS, _text, _text_length, _ignoreCase);
		break;
	case WildType::Text:
		R = Equals(s, lenS, _text, _text_length, _ignoreCase);
		break;
	case WildType::RegexPcre:
		R = pcre::Match(_regex, s, lenS);
		break;
	case WildType::Multi:
		//[n] parts: all must match (with their option n applied)
		int nNot = 0;
		for(int i = 0; i < _multi_count; i++) {
			Wildex& w = _multi_array[i];
			if(w._not) {
				if(!w.Match(s, lenS)) return _not; //!v->Match(s) means 'matches if without option n applied'
				nNot++;
			}
		}
		if(nNot == _multi_count) return !_not; //there are no parts without option n

		//non-[n] parts: at least one must match
		for(int i = 0; i < _multi_count; i++) {
			Wildex& w = _multi_array[i];
			if(!w._not && w.Match(s, lenS)) return !_not;
		}
		break;
	}
	return R ^ _not;
}

/// <summary>
/// Returns true if string contains wildcard characters: '*', '?'.
/// </summary>
/// <param name="s">Can be null.</param>
/*static*/ bool Wildex::HasWildcards(STR s, size_t lenS)
{
	if(s == null) return false;
	for(size_t i = 0; i < lenS; i++) {
		auto c = s[i];
		if(c == '*' || c == '?') goto yes;
	}
	return false; yes: return true;
}

//EXPORT bool Cpp_WildexParse(Wildex& x, STR w, size_t lenW, out BSTR* errStr) {
//	return x.Parse(w, lenW, false, errStr);
//}
//
//EXPORT bool Cpp_WildexMatch(Wildex& x, STR s, size_t lenS) {
//	return x.Match(s, lenS);
//}
//
//EXPORT void Cpp_WildexDtor(Wildex& x) {
//	x.~Wildex();
//}

#pragma endregion

#pragma region Switch

//Compares string s of length lenS with a list of '\0'-terminated non-null strings, and returns 1-based index of the matched string, or 0 if none matches.
//Example: int i=str::Switch(L"two", -1, { L"one", L"two", L"three" }); //2
//If s==null, returns 0.
int Switch(STR s, size_t lenS, std::initializer_list<STR> a)
{
	if(s == null) return 0;
	int i = 1;
	for(const STR* p = a.begin(); p < a.end(); i++) {
		STR t = *p++;
		for(size_t j = 0; j < lenS; j++) {
			WCHAR c = t[j];
			if(c != s[j] || c == 0) goto g1;
		}
		if(t[lenS] == 0) return i;
	g1:;
	}
	return 0;
}

//Compares '\0'-terminated string s with a list of '\0'-terminated non-null strings, and returns 1-based index of the matched string, or 0 if none matches.
//Example: int i=str::Switch(L"two", { L"one", L"two", L"three" }); //2
//If s==null, returns 0.
int Switch(STR s, std::initializer_list<STR> a)
{
	if(s == null) return 0;
	int i = 1;
	for(const STR* p = a.begin(); p < a.end(); i++) {
		STR t = *p++;
		for(STR ss = s; ; ) {
			WCHAR c = *t++;
			if(c != *ss++) goto g1;
			if(c == 0) break;
		}
		return i;
	g1:;
	}
	return 0;
}

#pragma endregion

} //namespace str


================================================
FILE: Cpp/str.h
================================================
#pragma once
#include "stdafx.h"

#define CMP2(s, c)	((s)[0]==c[0] && (s)[1]==c[1])
#define CMP3(s, c)	(CMP2(s, c) && (s)[2]==c[2])
#define CMP4(s, c)	(CMP3(s, c) && (s)[3]==c[3])
#define CMP5(s, c)	(CMP4(s, c) && (s)[4]==c[4])
#define CMP6(s, c)	(CMP5(s, c) && (s)[5]==c[5])

//Calls _wcstoi64 and casts to int.
//Use instead of wcstol to avoid its overflow problem. Eg for "0xFFFFFFFF" it returns INT_MAX; this func returns -1.
inline int strtoi(STR s, LPWSTR* end = nullptr, int radix = 0) {
	return (int)_wcstoi64(s, end, radix);
}

//Fast memory buffer.
//Depending on required size, uses memory in fixed-size memory in this variable (eg on stack) or allocates from heap.
//Does not call ctor/dtor.
template <class T, size_t nElemOnStack = 1000>
class Buffer {
	static const size_t c_nStackBytes = nElemOnStack * sizeof(T);

	T* _p;
	BYTE _onStack[c_nStackBytes];
public:
	explicit Buffer() noexcept { _p = (T*)_onStack; } //later call Init, unless need <= elements than nElemOnStack

	__forceinline explicit Buffer(size_t nElem) noexcept { _Init(nElem); }

	~Buffer() { FreeHeapMemory(); }

	//Frees old memory and allocates new. Does not preserve.
	T* Alloc(size_t nElem) { FreeHeapMemory(); return _Init(nElem); }

	//Frees old memory, allocates new and calls memset(0). Does not preserve.
	T* AllocAndZero(size_t nElem) { FreeHeapMemory(); return _InitZ(nElem); }

	//Reallocates memory in the grow direction, preserving existing data.
	T* Realloc(size_t nElem) { if (nElem > nElemOnStack) _Realloc(nElem * sizeof(T)); return _p; }

	//Frees heap memory. Called by dtor.
	__declspec(noinline)
		void FreeHeapMemory() {
		if ((LPBYTE)_p != _onStack) {
			free(_p);
			_p = (T*)_onStack;
		}
	}

	operator T* () { return _p; }

	size_t Capacity() { return (LPBYTE)_p == _onStack ? nElemOnStack : _msize(_p) * sizeof(T); }

private:
	__forceinline T* _Init(size_t nElem) { return (T*)_Init(nElem * sizeof(T), c_nStackBytes); }

	T* _InitZ(size_t nElem) { return (T*)memset(_Init(nElem), 0, nElem * sizeof(T)); }

	__declspec(noinline)
		void* _Init(size_t requiredSize, size_t stackSize) {
		_p = (T*)_onStack;
		if (requiredSize > stackSize) _p = (T*)malloc(requiredSize);
		return _p;
	}

	__declspec(noinline)
		void _Realloc(size_t requiredSize) {
		if ((LPBYTE)_p != _onStack) {
			_p = (T*)realloc(_p, requiredSize);
		} else {
			_p = (T*)malloc(requiredSize);
			memcpy(_p, _onStack, c_nStackBytes);
		}
	}

	//tested: the __declspec(noinline) functions are added once for all T, making template instance code very small.
};

namespace str {
	//null-safe wcslen.
	inline size_t Len(STR s) { return s ? wcslen(s) : 0; }

	inline bool IsEmpty(STR s) { return s == null || *s == 0; }

	struct SBBuffer { LPWSTR p; int n; };

	//Formats string by appending strings and numbers to an internal buffer (Buffer<WCHAR, 1000>.
	//Can be used instead of std::wstringstream which adds ~130 KB to the dll size.
	class StringBuilder {
		static const size_t c_bufferSize = 1000;
		size_t _len, _all;
		Buffer<WCHAR, c_bufferSize> _b;

		void _ReallocIfNeed(size_t lenAppend) {
			auto n = _len + lenAppend;
			if (n >= _all) {
				n += _all;
				_b.Realloc(n);
				_all = n;
			}
		}
	public:
		StringBuilder() {
			_len = 0;
			_all = c_bufferSize;
			_b[0] = 0;
		}

		void Clear() {
			_b.FreeHeapMemory();
			_len = 0;
			_all = c_bufferSize;
			_b[0] = 0;
		}

		operator LPWSTR() {
			return _b;
		}

		int Length() {
			return (int)_len;
		}

		void SetLength(int len) {
			_len = (size_t)len;
		}

		BSTR ToBSTR() {
			return SysAllocStringLen(_b, (UINT)_len);
		}

		void Append(STR s, size_t lenS) {
			if (lenS > 0) {
				_ReallocIfNeed(lenS);
				memcpy(_b + _len, s, lenS * 2);
				auto n = _len + lenS;
				_b[n] = 0;
				_len = n;
			}
		}

		void Append(STR s) { Append(s, Len(s)); }

		friend StringBuilder& operator<<(StringBuilder& b, STR s) {
			b.Append(s);
			return b;
		}

		void AppendBSTR(BSTR s) { Append(s, SysStringLen(s)); }
		//note: cannot add Append and << overloads for BSTR because then compiler chooses them for LPWSTR etc.

		void Append(__int64 i, int radix = 10) {
			_ReallocIfNeed(20);
			_i64tow(i, _b + _len, radix);
			auto n = _len; while (_b[n]) n++;
			_b[n] = 0;
			_len = n;
		}

		friend StringBuilder& operator<<(StringBuilder& b, __int64 i) {
			b.Append(i);
			return b;
		}

		friend StringBuilder& operator<<(StringBuilder& b, int i) {
			b.Append((__int64)i);
			return b;
		}

		void AppendChar(WCHAR c, int count = 1) {
			if (count > 0) {
				_ReallocIfNeed(count);
				LPWSTR t = _b + _len;
				while (--count >= 0) *t++ = c;
				*t = 0;
				_len = t - _b;
			}
		}

		friend StringBuilder& operator<<(StringBuilder& b, WCHAR c) {
			b.AppendChar(c);
			return b;
		}

		friend StringBuilder& operator<<(StringBuilder& b, char c) {
			b.AppendChar((WCHAR)c);
			return b;
		}

		//Gets buffer that can be passed to an API function that needs it.
		//The buffer is after the formatted string, so the API will append text, not replace.
		//After calling the API, call FixBuffer.
		//minSize - minimal buffer size you need. Default 500.
		//Returns: p - buffer pointer; n - buffer size (>=minSize).
		SBBuffer GetBufferToAppend(int minSize = 500) {
			_ReallocIfNeed(minSize + 1);
			return { _b + _len, (int)(_all - _len - 1) };
		}

		//Sets correct length after calling GetBufferToAppend and an API function that writes to the buffer.
		//If appendLen<0, calls wcslen.
		void FixBuffer(int appendLen = -1) {
			auto n = _len + (appendLen < 0 ? wcslen(_b + _len) : appendLen);
			assert(n < _all); if (n >= _all) n = _len;
			_b[n] = 0;
			_len = n;
		}

		//Returns true if the formatted string ends with s, case-insensitive.
		bool EndsI(STR s) {
			auto n = wcslen(s);
			return _len >= n && 0 == _wcsnicmp(_b + _len - n, s, n);
		}

		//Decrements length by tailLength, and appends s.
		void ReplaceTail(int tailLength, STR s) {
			_len -= tailLength;
			Append(s);
		}
	};

	namespace pcre {

		BSTR GetErrorMessage(int code);
		pcre2_code_16* Compile(STR rx, size_t len, __int64 flags = 0, out BSTR* errStr = null);
		bool Match(pcre2_code_16* code, STR s, size_t len, size_t start = 0, UINT flags = 0);

		//If code is not null, calls pcre2_code_free_16.
		static void Free(pcre2_code_16* code) {
			if (code != null) pcre2_code_free_16(code);
		}

	};


	//Wildcard expression.
	//More info in the C# version and help file.
	class Wildex {
		Wildex(Wildex&& x) = delete; //disable copying
	public:
		/// <summary>
		/// The type of text (wildcard expression) used when creating the Wildex variable.
		/// </summary>
		enum class WildType :byte {
			/// Simple text (option t, or no *? characters and no t r options).
			Text,

			/// Wildcard (has *? characters and no t r options).
			/// Match() calls str::Like.
			Wildcard,

			/// PCRE regular expression (option r).
			RegexPcre,

			/// Multiple parts (option m).
			/// Match() calls Match() for each part and returns true if all negative (option n) parts return true (or there are no such parts) and some positive (no option n) part returns true (or there are no such parts).
			Multi,
		};

	private:
		union {
			LPWSTR _text;
			pcre2_code_16* _regex;
			Wildex* _multi_array;
		};
		union {
			int _text_length;
			int _multi_count;
		};
		WildType _type;
		bool _ignoreCase;
		bool _not;
		bool _freeText;

	public:
		Wildex() { ZEROTHIS; }
		~Wildex();
		bool Parse(STR w, size_t lenW, bool dontCopyString = false, out BSTR* errStr = null);
		bool Match(STR s, size_t lenS) const;
		//Returns true if not null.
		bool Is() const { return _text != null; }

		static bool HasWildcards(STR s, size_t lenS);
	};

	EXPORT STR Cpp_LowercaseTable();
	bool Like(STR s, size_t lenS, STR w, size_t lenW, bool ignoreCase = false);
	bool Equals(STR w, size_t lenW, STR s, size_t lenS, bool ignoreCase = false);

	int Switch(STR s, size_t lenS, std::initializer_list<STR> a);
	int Switch(STR s, std::initializer_list<STR> a);


} //namespace str


class Bstr : public CComBSTR {
public:
	using CComBSTR::CComBSTR; //inherit ctors

	//Calls Attach(SysAllocStringLen(s, len)) and returns m_str.
	BSTR Assign(STR s, int len) {
		Attach(SysAllocStringLen(s, len));
		return m_str;
	}

	bool Equals(STR s, int lenS, bool ignoreCase) {
		if (m_str == null) return s == null;
		return str::Equals(m_str, Length(), s, lenS);
	}

	bool Equals(STR s, bool ignoreCase) {
		if (m_str == null) return s == null;
		return str::Equals(m_str, Length(), s, str::Len(s));
	}

	bool Equals(BSTR s, bool ignoreCase) {
		if (m_str == null) return s == null;
		return str::Equals(m_str, Length(), s, SysStringLen(s));
	}
};

struct BstrNameValue {
	Bstr name;
	Bstr value;
};


================================================
FILE: Cpp/test Uia.cpp
================================================
#include "stdafx.h"
#include "cpp.h"

bool ElementFromWindow(IUIAutomation* f, HWND w, Smart<IUIAutomationElement>& e)
{
	if(f->ElementFromHandle(w, &e)) return false;
	return true;
}

class UiaFinder
{
	Smart<IUIAutomation> _f;
	Bstr _name;
	Smart<IUIAutomationCondition> _condRaw;
public:
	Smart<IUIAutomationElement> eFound;

	UiaFinder() {
		if(_f.CoCreateInstance(__uuidof(CUIAutomation8), null, CLSCTX_INPROC_SERVER)) return;
		if(_f->get_RawViewCondition(&_condRaw)) return;
	}

	int Find(HWND w, STR name) {
		if(!_f) return 1;

		Smart<IUIAutomationElement> ew;
		if(!ElementFromWindow(_f, w, ew)) return 2;

		return Find(ew, name);
	}

	//int Find(IUIAutomationElement* ew, STR name) {

	//	IUIAutomationCondition> cond;
	//	if (_f->CreatePropertyCondition(UIA_NamePropertyId, _variant_t(name), &cond)) return 3;

	//	if (ew->FindFirst(TreeScope_Descendants, cond, &eFound)) return 4;

	//	return 0;
	//}

	int Find(IUIAutomationElement* ew, STR name) {
		if(!_f) return 1;
		_name = name;

		return _Find(ew, 0);
	}

private:
	int _Find(IUIAutomationElement* ew, int level) {

		Smart<IUIAutomationElementArray> a;
		if(ew->FindAll(TreeScope_Children, _condRaw, &a)) return 4;

		int n = 0;
		if(a->get_Length(&n)) return 5;

		for(int i = 0; i < n; i++) {
			Smart<IUIAutomationElement> e;
			if(a->GetElement(i, &e)) return 6;

			Bstr b;
			if(0 == e->get_CurrentName(&b)) {
				//Printf(L"%i %s", level, (STR)b);
				if(b == _name) {
					eFound.Attach(e.Detach());
					break;
				}
			}

			int k = _Find(e, level + 1);
			if(k) return k;
			if(eFound) break;
		}

		return 0;
	}
};

#if true
LRESULT TestUia(HWND w)
{
	UiaFinder x;
	int err = x.Find(w, L"Untitled");
	if(err) return err;

	if(x.eFound) {
		Bstr b;
		if(x.eFound->get_CurrentName(&b)) return 50;
		Print(b);
	} else Print(L"not found");

	return 0;
}
#else
LRESULT TestUia(HWND w)
{
	//Print(L"TestUia");

	//_TODO: CoInitialize if need.

	//Smart<IUIAutomation> f(__uuidof(CUIAutomation8), null, CLSCTX_INPROC_SERVER);
	Smart<IUIAutomation> f;
	if(f.CreateInstance(__uuidof(CUIAutomation8), null, CLSCTX_INPROC_SERVER)) return 1;
	//Print((__int64)f.p);

	Smart<IUIAutomationElement> ew;
	if(!ElementFromWindow(f, w, ew)) return 2;

	Smart<IUIAutomationCondition> cond;
	if(f->CreatePropertyCondition(UIA_NamePropertyId, _variant_t(L"Untitled"), &cond)) return 3;

	Smart<IUIAutomationElement> e;
	if(ew->FindFirst(TreeScope_Descendants, cond, &e)) return 4;
	if(!e) return 100;

	_bstr_t b;
	if(e->get_CurrentName(&b.GetBSTR())) return 5;

	Print(b);

	return 0;
}
#endif


================================================
FILE: Cpp/test.cpp
================================================
#include "stdafx.h"
#include "cpp.h"
//#include "ISimpleDOMNode.h"

//#include <sphelper.h>
//#include <taskschd.h>

#if _DEBUG

//#if 1

__interface __declspec(uuid("3AB5235E-2768-47A2-909A-B5852A9D1868"))
	IInterface : IUnknown {
	int __stdcall Add(int a, int b);
	HRESULT __stdcall put_Prop(int r);
	HRESULT __stdcall get_Prop(int* r);
	HRESULT __stdcall put_Prop2(IUnknown* r);
	HRESULT __stdcall get_Prop2(IUnknown** r);
};

class Inter :public IInterface {
public:
	int __stdcall Add(int a, int b) {
		return a + b;
	}

	// Inherited via IInterface
	virtual HRESULT __stdcall QueryInterface(REFIID riid, void** ppvObject) override {
		if (riid == __uuidof(IInterface) || riid == __uuidof(IUnknown)) {
			Printf(L"QueryInterface(%s)", riid == __uuidof(IInterface) ? L"IInterface" : L"IUnknown");
			*ppvObject = this;
			return 0;
		}
		*ppvObject = nullptr;
		return E_NOINTERFACE;
	}
	virtual ULONG __stdcall AddRef(void) override {
		Print(L"AddRef");
		return 1;
	}
	virtual ULONG __stdcall Release(void) override {
		Print(L"Release");
		return 1;
	}

	HRESULT __stdcall put_Prop(int r) { Print(r); return 0; }
	HRESULT __stdcall get_Prop(int* r) { *r = 3; return 0; }

	HRESULT __stdcall put_Prop2(IUnknown* r) { Print(r->AddRef()); return 0; }
	HRESULT __stdcall get_Prop2(IUnknown** r) { *r = this; return 0; }
};

EXPORT IInterface* Cpp_GetInterface() { return new Inter(); }






LRESULT CALLBACK KeyHookProc(int code, WPARAM wParam, LPARAM lParam) {
	if (code < 0) goto g1;
	if (wParam == 0x8F) {
		//Print(L"<hook>");
		HANDLE ev = OpenEventW(EVENT_MODIFY_STATE, false, L"ee57812345hh");
		if (ev == 0) {
			PRINTS(L"key sync hook: OpenEventW failed");
			goto g1;
		}
		SetEvent(ev);
		CloseHandle(ev);
	}
g1:
	return CallNextHookEx(0, code, wParam, lParam);
}

EXPORT HHOOK Cpp_KeyboardHook(int action, int tid, HHOOK hh) {
	if (action == 1) {
		auto hh = SetWindowsHookExW(WH_KEYBOARD, KeyHookProc, s_moduleHandle, tid);
		if (hh == 0 && tid != 0) hh = SetWindowsHookExW(WH_KEYBOARD, KeyHookProc, s_moduleHandle, 0); //console. GetWindowThreadProcessId lies. To get real id probably need to enumerate threads and call EnumThreadWindows for each. Too slow.
		return hh;
	} else if (action == 2) {
		UnhookWindowsHookEx(hh);
	}
	return 0;
}
//
//LRESULT CALLBACK ForegroundIdleProc(int code, WPARAM wParam, LPARAM lParam)
//{
//	//Print(code);
//	if(code < 0) goto g1;
//	HANDLE ev = OpenEventW(EVENT_MODIFY_STATE, false, L"ee57812345hh");
//	if(ev == 0) {
//		Print(L"failed");
//		goto g1;
//	}
//	SetEvent(ev);
//	CloseHandle(ev);
//
//	g1:
//	return CallNextHookEx(0, code, wParam, lParam);
//}
//
//EXPORT HHOOK Cpp_InputSync(int action, int tid, HHOOK hh)
//{
//	if(action == 1) {
//		return SetWindowsHookExW(WH_FOREGROUNDIDLE, ForegroundIdleProc, GetCurrentModuleHandle(), 0);
//	} else if(action == 2) {
//		UnhookWindowsHookEx(hh);
//	}
//	return 0;
//}

//#define IID_IThreadExitEvent __uuidof(IThreadExitEvent)
//__interface  __declspec(uuid("57017F56-E7CA-4A7B-A8F8-2AE36077F50D"))
//	IThreadExitEvent :IUnknown
//{
//	STDMETHODIMP Unsubscribe();
//};
//
//class ThreadExitEvent :public IThreadExitEvent
//{
//	long _cRef;
//	FARPROC _callback;
//	STD_IUNKNOWN_METHODS(IThreadExitEvent)
//public:
//	ThreadExitEvent(FARPROC callback) {
//		_cRef = 1;
//		_callback = callback;
//	}
//
//	~ThreadExitEvent() {
//		if(_callback == null) return;
//		Print(GetCurrentThreadId());
//		_callback();
//	}
//
//	STDMETHODIMP Unsubscribe() {
//		_callback = null;
//		return 0;
//	}
//};
//
//EXPORT
//IThreadExitEvent* Cpp_ThreadExitEvent(FARPROC callback)
//{
//	return new ThreadExitEvent(callback);
//}
//
//FARPROC s_callback;
//
//EXPORT
//void Cpp_ThreadExitEvent2(FARPROC callback)
//{
//	s_callback = callback;
//}
//
//void OnThreadExit()
//{
//	Print(GetCurrentThreadId());
//	if(s_callback) s_callback();
//}


//#include <atlstr.h>
//#include <atlfile.h>

extern HMODULE s_moduleHandle;

//void TestStringBuilder() {
//	Perf.First();
//	str::StringBuilder b;
//	//b.Append(L"one ");
//	//b.Append(50);
//	//b.Append(L" four", 2);
//	//b.Append(L" 0x");
//	//b.Append(10, 16);
//	//b.AppendChar(' ');
//	//b.AppendChar('A');
//	//b.AppendChar(' ', 4);
//	//b.AppendChar('A');
//
//	HWND ww = 0;
//
//	static const STR rundll = L"\\SysWOW64\\rundll32.exe \"";
//	static const STR bits = L"32";
//
//	b << L"kkk" << L' ' << 5 << ',';
//	b.AppendChar(' ');
//	b.AppendChar(L' ');
//
//	LPWSTR t; int n;
//	t = b.GetBufferToAppend(out n); b.FixBuffer(GetWindowsDirectoryW(t, n));
//	b << rundll;
//	t = b.GetBufferToAppend(out n); b.FixBuffer(GetModuleFileNameW(s_moduleHandle, t, n));
//	auto u = wcsrchr(t, '\\') - 5; u[0] = bits[0]; u[1] = bits[1]; //"32" to "64" or vice versa
//	if (GetFileAttributes(t) == INVALID_FILE_ATTRIBUTES) return; //avoid messagebox when our antimatter dll does not exist
//	b << L"\",Cpp_RunDll " << (__int64)ww; //note: without W
//
//	b << 'A';
//	b.AppendChar('.', 4);
//
//	Perf.Next();
//	Print(b);
//	Perf.NW();
//}

EXPORT void Cpp_TestWildex(STR s, STR w) {
	auto lenS = wcslen(s);
	auto lenW = wcslen(w);

	Perf.First();
	str::Wildex x;
	Bstr es;
	if (!x.Parse(w, lenW, false, &es)) { Print(es); return; }
	Perf.Next();

	bool yes;
	for (int i = 0; i < 1000; i++) yes = x.Match(s, lenS);
	Perf.NW();

	Print(yes);
}

EXPORT void Cpp_TestPCRE(STR s, STR p, DWORD flags) {
	int rc = 0;

	Perf.First();
	int errNum; size_t errOffs;
	auto re = pcre2_compile(p, -1, flags | PCRE2_UTF, &errNum, &errOffs, null);
	if (re == null) {
		PCRE2_UCHAR buffer[256];
		pcre2_get_error_message(errNum, buffer, _countof(buffer));
		Printf(L"error %s at %i", buffer, errOffs);
		return;
	}

#if false
	Perf.Next();
	LPBYTE ser = null; size_t serSize = 0;
	pcre2_code* a[2] = { re,re };
	rc = pcre2_serialize_encode((const pcre2_code_16**)a, 2, &ser, &serSize, null);
	if (rc <= 0) {
		Print(L"pcre2_serialize_encode error");
		return;
	}
	pcre2_code_free(re); re = null;
	Perf.Next();

	Print(serSize);

	rc = pcre2_serialize_decode(&re, 1, ser, null);
	if (rc <= 0) {
		Print(L"pcre2_serialize_decode error");
		return;
	}

	pcre2_serialize_free(ser);
#endif

	Perf.Next();
	auto m = pcre2_match_data_create_from_pattern(re, null);
	auto len = wcslen(s);

	for (int i = 0; i < 1000; i++) {
		rc = pcre2_match(re, s, len, 0, 0, m, null, null);
		if (rc <= 0) {
			Print(rc);
			return;
		}
	}

	Perf.Next();

	//auto v = pcre2_get_ovector_pointer(m);
	//for(int i = 0; i < rc; i++) {
	//	PCRE2_SPTR substring_start = s + v[2 * i];
	//	size_t substring_length = v[2 * i + 1] - v[2 * i];
	//	Printf(L"%i: %.*s", i, (int)substring_length, (char *)substring_start);
	//}

	pcre2_match_data_free(m);
	pcre2_code_free(re);
	Perf.NW();
}


//class TestTL {
//public:
//	TestTL() {
//		Printf(L"+ %p %i", this, GetCurrentThreadId());
//	}
//
//	~TestTL() {
//		Printf(L"- %p %i", this, GetCurrentThreadId());
//	}
//};
//
//void Voo(LPWSTR s) {
//	//std::wstring k(s);
//	//Print(k.c_str() == null);
//	CString g(s);
//	//Print(g.GetString() == null);
//	//Print((STR)g == null);
//}
//
//enum
//	//class
//	eTest {
//	One = 1,
//	Two = 2,
//	Four = 4,
//};
//ENABLE_BITMASK_OPERATORS(eTest);
//
//#include <vector>
//#include <array>
//
//STR s_testSTR = L"te";
//
//struct eKKK {
//	enum {
//		One = 1,
//		Two = 2,
//		Four = 4,
//	};
//
//	//static const int One = 1;
//	//static const int Two = 2;
//	//static const int Four = 4;
//};
//
//enum class eKKK {
//	One = 1,
//	Two = 2,
//	Four = 4,
//	Eight = 8,
//};
//ENABLE_BITMASK_OPERATORS(eKKK);

EXPORT
int Cpp_TestInt(int a) {
	return sizeof(VARIANT);
}

EXPORT
int Cpp_TestString(STR a) {
	return 1;
}


#define IID_ICppTest __uuidof(ICppTest)
__interface  __declspec(uuid("3426CF3C-F7C2-4322-A292-463DB8729B54"))
	ICppTest :IUnknown {
	STDMETHODIMP TestInt(int a, int b, int c);
	STDMETHODIMP TestString(STR a, int b, int c);
	STDMETHODIMP TestBSTR(BSTR a, int b, int c);
};

class CppTest :public ICppTest {
	STD_IUNKNOWN_METHODS_SIMPLE(ICppTest)
public:
	STDMETHODIMP TestInt(int a, int b, int c) {
		return E_NOTIMPL;
	}
	STDMETHODIMP TestString(STR a, int b, int c) {
		return E_NOTIMPL;
	}
	STDMETHODIMP TestBSTR(BSTR a, int b, int c) {
		return E_NOTIMPL;
	}
};

EXPORT
ICppTest* Cpp_Interface() {
	return new CppTest();
}

//#include <OCIdl.h>
//#include <DispEx.h>
//
//
//EXPORT
//void TestSimple()
//{
//	//throw 5;
//	int* p = 0;
//	Print(*p);
//}
//
//EXPORT
//void TestUnmanaged(int& k, int& g)
//{
////MessageBox(0, L"", L"bb", 0);
//}
//
//EXPORT
//void TestStructBlit(POINT& p)
//{
//	Print(p.x);
//	p.y = 8;
//}
//
//struct STSTR
//{
//	int k;
//	LPWSTR s;
//};
//
//EXPORT
//void TestStructString(STSTR& p)
//{
//	Print(p.s);
//	Print(p.k);
//	//p.s = L"retstr";
//	//p.s = SysAllocString(L"retstr");
//	//p.s = (LPWSTR)CoTaskMemAlloc(10); CopyMemory(p.s, L"retstr", sizeof(L"retstr"));
//	p.s[0] = 'A';
//	p.k = 8;
//	Print(L"returning");
//}
//
//EXPORT
//void TestArray(int* p)
//{
//	Print(p[0]);
//	p[0] = 5;
//}
//
//EXPORT
//void TestArrayStr(LPWSTR* p)
//{
//	Print(p[0]);
//	*p[0] = 'A';
//}
//
//__interface __declspec(uuid("3AB5235E-2768-47A2-909A-B5852A9D1868"))
//	ITest :IUnknown
//{
//	HRESULT STDMETHODCALLTYPE Test1(int i);
//	//HRESULT STDMETHODCALLTYPE Test2(int* p);
//	HRESULT STDMETHODCALLTYPE TestOL(int* p);
//	HRESULT STDMETHODCALLTYPE TestNext(char* p);
//};
//
//class CTest :public ITest
//{
//	int _refCount;
//
//public:
//	CTest() {
//		_refCount = 1;
//	}
//
//	~CTest() {
//		Printf(L"dtor thread: %i", GetCurrentThreadId());
//		//Print(L"dtor");
//	}
//
//	HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void** ppvObject) {
//		//wchar_t* name = L"?"; //info: QM2 has DebugGetInterfaceName
//		//if (riid == __uuidof(ITest)) name = L"ITest"; //called
//		//else if (riid == __uuidof(IUnknown)) name = L"IUnknown"; //called
//		//else if (riid == __uuidof(IProvideClassInfo)) name = L"IProvideClassInfo"; //called
//		//else if (riid == __uuidof(IDispatch)) name = L"IDispatch";
//		//else if (riid == __uuidof(IDispatchEx)) name = L"IDispatchEx";
//		//else if (riid == __uuidof(IErrorInfo)) name = L"IErrorInfo";
//		//else if (riid == __uuidof(IEnumVARIANT)) name = L"IEnumVARIANT";
//		//else if (riid == __uuidof(IConnectionPoint)) name = L"IConnectionPoint";
//		//else if (riid == __uuidof(IConnectionPointContainer)) name = L"IConnectionPointContainer";
//
//		//Printf(L"QueryInterface: %s", name);
//
//		if (riid != __uuidof(ITest) && riid != __uuidof(IUnknown)) {
//			*ppvObject = 0;
//			return E_NOINTERFACE;
//		}
//		_refCount++;
//		*ppvObject = this;
//		return 0;
//	}
//	ULONG STDMETHODCALLTYPE AddRef() {
//		++_refCount;
//		//Printf(L"AddRef, %i", _refCount);
//		return _refCount;
//	}
//	ULONG STDMETHODCALLTYPE Release() {
//		_refCount--;
//		//Printf(L"Release, %i", _refCount);
//		if (_refCount == 0) delete this;
//		return _refCount;
//	}
//
//	HRESULT STDMETHODCALLTYPE Test1(int i)
//	{
//		Print(L"Test1");
//		return 0;
//	}
//
//	//HRESULT STDMETHODCALLTYPE Test2(int* p)
//	//{
//	//	Print(p[0]);
//	//	return 0;
//	//}
//
//	HRESULT STDMETHODCALLTYPE TestOL(int* p)
//	{
//		Print(1);
//		return 0;
//	}
//
//	HRESULT STDMETHODCALLTYPE TestNext(char* p)
//	{
//		Print(2);
//		return 0;
//	}
//};
//
//EXPORT
//ITest* CreateTestInterface()
//{
//	return new CTest();
//}
//
//EXPORT void CreateTestInterface2(ITest*& t)
//{
//	t = new CTest();
//}
//
//
//
//
//
//
//#include <OleAuto.h>
//#include <oleacc.h>
//#pragma comment(lib, "oleacc.lib")
//
//
//EXPORT
//void DllTestAcc()
//{
//	POINT p = { 257, 1138 };
//	IAccessible* a = 0; VARIANT vc = {};
//	HRESULT hr = AccessibleObjectFromPoint(p, &a, &vc);
//	if (hr != 0) {
//		Print((uint)hr); return;
//	}
//	try {
//		BSTR s = 0;
//		hr = a->get_accName(vc, &s);
//		if (hr != 0) {
//			Print((uint)hr); return;
//		}
//
//		Print(s);
//		//Print((__int64)s);
//		//SysFreeString(s);
//
//	}
//	catch (...) {
//		a->Release();
//		Print(L"exception");
//	}
//}

class One {
public:
	int m;
	One() {
		m = 1;
	}
	virtual ~One() {
		Printf(L"~One, %i", m);
	}
};

class Two : public One {
public:
	~Two() {
		Print(L"~Two");
		m = 0;
	}
};

class Move {
public:
	int m;

	Move() {
		m = 1;
	}

	//~Move() {
	//	Printf(L"~Move, %i", m);
	//}

	Move(Move& x) {
		m = x.m;
	}

	Move(Move&& x) {
		m = x.m;
		x.m = 0;
	}

	Move& operator=(Move& x) {
		m = x.m;
		return *this;
	}

	Move& operator=(Move&& x) {
		m = x.m;
		x.m = 0;
		return *this;
	}
};

class Move2 :public Move {
public:
	Move2() : Move() {}

	~Move2() {
		Printf(L"~Move2, %i", m);
	}

	Move2(Move2& x) {
		m = x.m;
	}

	Move2(Move2&& x) {
		m = x.m;
		x.m = 0;
	}

	Move2& operator=(Move2& x) {
		m = x.m;
		return *this;
	}

	Move2& operator=(Move2&& x) {
		Move::operator=(std::move(x));
		return *this;
	}
};

void _TestIAccessibleImpl();

void _test1(HWND w) {
	DWORD pid = 0;
	GetWindowThreadProcessId(w, &pid);
	Print(Cpp_GetProcessArchitecture(pid));
}

EXPORT void Cpp_Test() {
	//_test1(FindWindow(L"QM_Editor", null));
	//_test1(FindWindow(null, L"LibreAutomate"));
	//_test1(FindWindow(L"Shell_TrayWnd", null));
	//_test1(FindWindow(L"#32770", L"test"));

#if _M_ARM64EC
		STR arch = L"ARM64EC";
#elif _M_ARM64
		STR arch = L"ARM64";
#elif _M_X64
		STR arch = L"x64";
#else
		STR arch = L"x86";
#endif
	Printf(L"major=%i minor=%i min10=%i min11=%i is32=%i arch=%s", osVer.major(), osVer.minor(), osVer.minWin10(), osVer.minWin11(), osVer.is32BitOS(), arch);

	//auto hh = SetWinEventHook(EVENT_SYSTEM_FOREGROUND, EVENT_SYSTEM_FOREGROUND, 0, _Wineventproc, GetCurrentProcessId(), 0, 0);
	//auto hh = SetWinEventHook(EVENT_SYSTEM_FOREGROUND, EVENT_SYSTEM_FOREGROUND, (HMODULE)&__ImageBase, _Wineventproc, GetCurrentProcessId(), 0, WINEVENT_INCONTEXT);

	//TestFileDialog();


	//_TestIAccessibleImpl();
		//CHandle hRead, hWrite;
		//if(!CreatePipe(&hRead.m_h, &hWrite.m_h, null, 0)) return;
		//Printf(L"%p %p", hRead.m_h, hWrite.m_h);


		//HWND w = FindWindowW(L"QM_Editor", null);
		//wn::PrintWnd(w);
		////Print(wn::ClassNameIs(w, L"QM_Editor"));
		////Print(wn::ClassNameIs(w, L"QM_Edito"));
		////Print(wn::ClassNameIs(w, L"QM_*"));
		////Print(wn::ClassNameIs(w, L"-QM_*"));

		//str::Wildex x;
		////STR s = L"**k kkk";
		////STR s = L"**r (kkk";
		//STR s = L"QM_Editor";
		//s=L"**t QM_Editor";
		////s=L"**r .+r$";
		//s=L"**m moo||QM_Editor";
		//s=L"**n QM_Editor-";
		//s=L"**m *_Editor";
		//s=L"**m moo||**r .+r$";
		//s=L"**m moo||**r .+r$||**n *i*";
		//Bstr es;
		//if(!x.Parse(s, wcslen(s), true, &es)) {
		//	Print(es); return;
		//}
		//Print(wn::ClassNameIs(w, x));
		//Print(x.Match(L"QM_Editor", 9));

		//str::StringBuilder t;
		////STR s = L"TEST";
		//LPWSTR s = L"TEST";
		//t.Append(s);
		//Print(t);

		//Move2 t1;
		//t1.m = 5;

		////Move2 t2 = t1;
		////Move2 t2; t2 = t1;

		////Move2 t2 = std::move(t1);
		//Move2 t2; t2 = std::move(t1);

		//Printf(L"%i %i", t1.m, t2.m);

		//str::StringBuilder b;
		////b.Append(L"---");
		////b.Append(L"123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 ");
		//for(int i = 0; i < 1000; i++) {
		//	b << i;
		//	b << L"    ";
		//}
		//
		//Print(b);

		//for(int i = 0; i < 5; i++) {
		//	Sleep(100);
		//	Perf.First();
		//	Smart<IStream> x;
		//	CreateStreamOnHGlobal(0, true, &x);
		//	for(int j = 0; j < 100000; j++) if(x->Write("abcdefgh", 8, null)) { Print("failed"); return; }

		//	Perf.NW();

		//	DWORD size = 0; istream::GetSize(x, size); Print(size);
		//}


		//eKKK e = eKKK::One | eKKK::Two;
		//eKKK e = eKKK::One;

		//Print(!!e);

		////if(e&eKKK::One) Print(1);
		//if((bool)(e & eKKK::One)) Print(1);
		//if(ALL(e, eKKK::One)) Print(2);
		//if((bool)(e & (eKKK::One | eKKK::Four))) Print(3);
		////if(ANY(e, eKKK::One, eKKK::Four)) Print(4);
		//if(ANY(e, eKKK::One | eKKK::Four)) Print(4);

		//eAF2 f = eAF::eAF2::InWebPage| eAF::eAF2::Java;

		//Printf(L"%*sa", 4, L"");

		//HWND w = FindWindowW(L"QM_Editor", null);
		////int x = 7;
		////wn::EnumChildWindows(w, [](HWND c) { wn::PrintWnd(c); return true; });

		//STR s_testSTR = L"thames";

		//Print(str::Switch(s_testSTR, 6, { L"moo", L"te", L"thames", L"notin" }));

		////Print(wn::ClassNameIs(w, { L"moo", L"qm_*itor", L"khy" }));

		//TestStringBuilder();

		//Bstr b1;
		//Print((void*)b1.m_str);
		//Bstr b2(L"test");
		//Print(b2);

		//Bstr s;
		//Print(wn::ClassName(w, s));
		//Print(s);
		//Print(wn::Name(w, s));
		//Print(s);

		//Print(sizeof(CSimpleArray<int>));
		//Print(sizeof(CAtlArray<int>));
		//Print(sizeof(std::vector<int>));
		//Print(sizeof(std::array<int, 100>));

		//Print(str::Switch(L"two", 3, L"one", L"two", L"three", null));

		//#if true
		//	eTest t = eTest::One | eTest::Two;
		//	//eTest t = eTest::Two;
		//	//t = {};
		//	Print(t); //error if 'enum class'
		//	Print((int)t);
		//
		//	if(t) Print("t is not 0"); //error if 'enum class'
		//	if(t&eTest::Two) Print("has Two"); //error if 'enum class'
		//	if(!t) Print("t is 0");
		//	if(!!t) Print("t is not 0");
		//	if(!!(t&eTest::Two)) Print("has Two");
		//
		//	if((t&eTest::Two) == eTest::Two) Print("has Two");
		//	t |= eTest::Four;
		//	if((t&(eTest::Two | eTest::Four)) == (eTest::Two | eTest::Four)) Print("has (Two|Four)");
		//	Print((int)(t&~eTest::Two));
		//#else
		//	eTest t = One | Two;
		//	//eTest t = Two;
		//	Print(t);
		//	if(t&Two) Print("has Two");
		//	if(t&Two == Two) Print("has Two");
		//	t |= Four;
		//	if(t&(Two | Four) == (Two | Four)) Print("has (Two|Four)");
		//	Print(t&~Two);
		//#endif
		//
		//	POINT p = {}, pp=p;
		//	//int p = 5, pp = p;
		//	//p |= pp;
		//	//if(!p) Print(1);

		//Print(sizeof(std::wstring));
		//Print(sizeof(CString));

		//Perf.First();
		//for(size_t i = 0; i < 100000; i++) {
		////for(size_t i = 0; i < 1; i++) {
		//	Voo(L"1234567890");
		//	//Voo(null);
		//}
		//Perf.NW();

		//static TestTL s;
		//static thread_local TestTL t;

		//CSimpleMap<int, int> m;
		//m.Add(1, 10);
		//m.Add(2, 20);
		//Print(m.FindKey(2));

		//void* p = null;
		//for(int i = 1; i < 20; i++) {
		//	p = _recalloc(p, i, 8);
		//	Printf(L"%i %p", i, p);
		//}

		//CAtlMap<int, int> m;


		//CAtlList<int> _a;
		//_a.AddTail(1);
		//_a.AddTail(2);
		//for(auto pos = _a.GetHeadPosition(); pos != null;) {
		//	Print(_a.GetNext(ref pos));
		//}

		//PRINTHEX(10);
		//PRINTF(L"%s %i", L"MOO", 10);

		////Print(IsOS64Bit());

		////HWND w = FindWindow(L"Chrome_WidgetWin_1", null);
		//HWND w = FindWindow(L"QM_Editor", null);
		//if(!w) {
		//	Print("window not found");
		//	return;
		//}
		//DWORD pid, tid = GetWindowThreadProcessId(w, &pid);
		////bool is64bit, ok = IsProcess64Bit(pid, is64bit);
		////Printf(L"ok=%i is64=%i", ok, is64bit);

		//Bstr s;

}

//#include "IAccessible2.h"
//
//void InProcAccTest(IAccessible* a)
//{
//	//Print(L"TEST");
//	Smart<IAccessible2> a2;
//	if(!QueryService(a, &a2, &IID_IAccessible)) { Print("QS failed"); return; }
//
//	//AccessibleStates states;
//	//if(a2->get_states(&states)) { Print("get_states failed"); return; }
//	//Print((uint)states);
//
//	//long n;
//	//if(a2->get_nExtendedStates(&n)) { Print("get_nExtendedStates failed"); return; } //fails
//	//Print(n);
//}

class MyAcc :IAccessible {
	HWND _w;
	int _ref;

public:
	MyAcc(HWND w) {
		_w = w;
		_ref = 1;
	}
#pragma region
	// Inherited via IAccessible
	virtual HRESULT __stdcall QueryInterface(REFIID riid, void** ppvObject) override {
		if (riid == IID_IUnknown || riid == IID_IDispatch || riid == IID_IAccessible) {
			*ppvObject = this;
			_ref++;
			return 0;
		}
		*ppvObject = 0;
		return E_NOINTERFACE;
	}
	virtual ULONG __stdcall AddRef(void) override {
		_ref++;
		return 1;
	}
	virtual ULONG __stdcall Release(void) override {
		_ref--;
		Printf(L"Release: %i", _ref);
		return 1;
	}
	virtual HRESULT __stdcall GetTypeInfoCount(UINT* pctinfo) override {
		return E_NOTIMPL;
	}
	virtual HRESULT __stdcall GetTypeInfo(UINT iTInfo, LCID lcid, ITypeInfo** ppTInfo) override {
		return E_NOTIMPL;
	}
	virtual HRESULT __stdcall GetIDsOfNames(REFIID riid, LPOLESTR* rgszNames, UINT cNames, LCID lcid, DISPID* rgDispId) override {
		return E_NOTIMPL;
	}
	virtual HRESULT __stdcall Invoke(DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS* pDispParams, VARIANT* pVarResult, EXCEPINFO* pExcepInfo, UINT* puArgErr) override {
		return E_NOTIMPL;
	}
#pragma endregion
	virtual HRESULT __stdcall get_accParent(IDispatch** ppdispParent) override {
		//Print(__FUNCTION__);
		return AccessibleObjectFromWindow(_w, 0, IID_IAccessible, (void**)ppdispParent);
	}
	virtual HRESULT __stdcall get_accChildCount(long* pcountChildren) override {
		//Print(__FUNCTION__);
		*pcountChildren = 0;
		return 0;
	}
	virtual HRESULT __stdcall get_accChild(VARIANT varChild, IDispatch** ppdispChild) override {
		//Print(__FUNCTION__);
		*ppdispChild = 0;
		if (varChild.vt != VT_I4)return E_INVALIDARG;
		return S_FALSE;
	}
	virtual HRESULT __stdcall get_accName(VARIANT varChild, BSTR* pszName) override {
		return E_NOTIMPL;
	}
	virtual HRESULT __stdcall get_accValue(VARIANT varChild, BSTR* pszValue) override {
		return E_NOTIMPL;
	}
	virtual HRESULT __stdcall get_accDescription(VARIANT varChild, BSTR* pszDescription) override {
		return E_NOTIMPL;
	}
	virtual HRESULT __stdcall get_accRole(VARIANT varChild, VARIANT* pvarRole) override {
		//Print(__FUNCTION__);
		pvarRole->vt = VT_I4; pvarRole->lVal = varChild.lVal == 0 ? ROLE_SYSTEM_LIST : ROLE_SYSTEM_LISTITEM;
		return 0;
	}
	virtual HRESULT __stdcall get_accState(VARIANT varChild, VARIANT* pvarState) override {
		//Print(__FUNCTION__);
		return E_NOTIMPL;
	}
	virtual HRESULT __stdcall get_accHelp(VARIANT varChild, BSTR* pszHelp) override {
		return E_NOTIMPL;
	}
	virtual HRESULT __stdcall get_accHelpTopic(BSTR* pszHelpFile, VARIANT varChild, long* pidTopic) override {
		return E_NOTIMPL;
	}
	virtual HRESULT __stdcall get_accKeyboardShortcut(VARIANT varChild, BSTR* pszKeyboardShortcut) override {
		return E_NOTIMPL;
	}
	virtual HRESULT __stdcall get_accFocus(VARIANT* pvarChild) override {
		return E_NOTIMPL;
	}
	virtual HRESULT __stdcall get_accSelection(VARIANT* pvarChildren) override {
		return E_NOTIMPL;
	}
	virtual HRESULT __stdcall get_accDefaultAction(VARIANT varChild, BSTR* pszDefaultAction) override {
		return E_NOTIMPL;
	}
	virtual HRESULT __stdcall accSelect(long flagsSelect, VARIANT varChild) override {
		return E_NOTIMPL;
	}
	virtual HRESULT __stdcall accLocation(long* pxLeft, long* pyTop, long* pcxWidth, long* pcyHeight, VARIANT varChild) override {
		//Print(__FUNCTION__);
		WINDOWINFO wi = { sizeof(WINDOWINFO) }; GetWindowInfo(_w, &wi);
		*pxLeft = wi.rcClient.left;
		*pyTop = wi.rcClient.top;
		*pcxWidth = wi.rcClient.right - wi.rcClient.left;
		*pcyHeight = wi.rcClient.bottom - wi.rcClient.top;
		return 0;
	}
	virtual HRESULT __stdcall accNavigate(long navDir, VARIANT varStart, VARIANT* pvarEndUpAt) override {
		return E_NOTIMPL;
	}
	virtual HRESULT __stdcall accHitTest(long xLeft, long yTop, VARIANT* pvarChild) override {
		//Print(__FUNCTION__);
		pvarChild->vt = VT_I4;
		pvarChild->lVal = 0;
		return 0;
	}
	virtual HRESULT __stdcall accDoDefaultAction(VARIANT varChild) override {
		return E_NOTIMPL;
	}
	virtual HRESULT __stdcall put_accName(VARIANT varChild, BSTR szName) override {
		return E_NOTIMPL;
	}
	virtual HRESULT __stdcall put_accValue(VARIANT varChild, BSTR szValue) override {
		return E_NOTIMPL;
	}
};

MyAcc* m;

LRESULT __stdcall _WndProc(HWND w, UINT msg, WPARAM wParam, LPARAM lParam) {

	//Print(msg);
	switch (msg) {
	case WM_DESTROY:
		m = null;
		//PostQuitMessage(0);
		PostMessage(w, WM_APP + 127, 0, 0);
		break;
	case WM_GETOBJECT:
		//Print((int)lParam);
		if ((int)lParam == OBJID_CLIENT) {
			Print("WM_GETOBJECT");
			if (m == null) m = new MyAcc(w);
			return LresultFromObject(IID_IAccessible, wParam, (LPUNKNOWN)m);
		}
		break;
	}

	return DefWindowProcW(w, msg, wParam, lParam);
}

void _TestIAccessibleImpl() {

	WNDCLASSEXW x = {};
	x.cbSize = sizeof(x);
	x.hbrBackground = (HBRUSH)(COLOR_BTNFACE + 1);
	x.hCursor = LoadCursor(0, (STR)IDC_ARROW);
	x.lpszClassName = L"Montejo";
	x.lpfnWndProc = _WndProc;
	auto atom = RegisterClassExW(&x);
	auto w = CreateWindowExW(WS_EX_TOPMOST, (STR)atom, L"Gooo", WS_VISIBLE | WS_POPUPWINDOW | WS_CAPTION, 500, 300, 300, 300, 0, 0, 0, 0);
	MSG m;
	while (GetMessageW(&m, 0, 0, 0) > 0) {
		if (m.message == WM_APP + 127) break;
		TranslateMessage(&m);
		DispatchMessageW(&m);
	}
}

#endif //#if _DEBUG


================================================
FILE: Cpp/util.h
================================================
#pragma once
#include "stdafx.h"

#define ZEROTHIS memset(this, 0, sizeof(*this))
#define ZEROTHISFROM(member) memset((LPBYTE)this+((LPBYTE)&member-(LPBYTE)this), 0, sizeof(*this)-((LPBYTE)&member-(LPBYTE)this))

#if _DEBUG
#define TRACE 1
#endif

#if TRACE

void Print(STR s);
void Printf(STR frm, ...);

inline void Print(LPCSTR s) { Printf(L"%S", s); }
inline void Print(const std::wstring& s) { Print(s.c_str()); }
inline void Print(int i) { Printf(L"%i", i); }
inline void Print(unsigned int i) { Printf(L"0x%X", i); }
inline void Print(long i) { Print((int)i); }
inline void Print(unsigned long i) { Print((unsigned int)i); }
inline void Print(__int64 i) { Printf(L"%I64i", i); }
inline void Print(unsigned __int64 i) { Printf(L"0x%I64X", i); }
inline void Print(void* i) { Printf(sizeof(void*) == 8 ? L"%I64i" : L"%i", i); }

#define PRINTI(x) Printf(L"debug: " __FILEW__ "(" _CRT_STRINGIZE(__LINE__) "):  %i", x)
#define PRINTS(x) Printf(L"debug: " __FILEW__ "(" _CRT_STRINGIZE(__LINE__) "):  %s", x)
#define PRINTHEX(x) Printf(L"debug: " __FILEW__ "(" _CRT_STRINGIZE(__LINE__) "):  0x%X", x)
#define PRINTF(formatString, ...) Printf(L"debug: " __FILEW__ "(" _CRT_STRINGIZE(__LINE__) "):  " formatString, __VA_ARGS__)
#define PRINTF_IF(condition, formatString, ...) { if(condition) PRINTF(formatString, __VA_ARGS__); }
#define PRINTS_IF(condition, x) { if(condition) PRINTS(x); }

inline void PrintComRefCount(IUnknown* u) {
	if (u) {
		u->AddRef();
		int i = u->Release();
		Printf(L"%p  %i", u, i);
	} else Print(L"null");
}

#else
#define Print __noop
#define Printf __noop
#define PRINTI __noop
#define PRINTS __noop
#define PRINTHEX __noop
#define PRINTF __noop
#define PRINTF_IF __noop
#define PRINTS_IF __noop
#define PrintComRefCount __noop
#endif

#if TRACE

struct Perf_Inst {
private:
	int _counter;
	bool _incremental;
	int _nMeasurements; //used with incremental to display n measurements and average times
	__int64 _time0;
	static const int _nElem = 16;
	__int64 _a[_nElem];
	wchar_t _aMark[_nElem];

public:
	//Perf_Inst() noexcept { ZEROTHIS; } //not used because then does not work shared data section
	Perf_Inst() {}
	Perf_Inst(bool isLocal) { if (isLocal) ZEROTHIS; }

	void First();
	void Next(char cMark = '\0');
	void Write();

	void NW(char cMark = '\0') { Next(cMark); Write(); }

	void SetIncremental(bool yes) {
		if (_incremental = yes) {
			for (int i = 0; i < _nElem; i++) _a[i] = 0;
			_nMeasurements = 0;
		}
	}
};

extern Perf_Inst Perf;

class PerfLocal {
	Perf_Inst _p;
public:
	PerfLocal() : _p(true) { _p.First(); }
	~PerfLocal() { _p.NW(); }
	void Next(char mark = '\0') { _p.Next(mark); }
};

#endif

#include "str.h"


class OSVersion {
	DWORD _major, _minor, _winver, _win10build;
public:
	OSVersion() noexcept {
		typedef int(WINAPI* tRtlGetVersion)(RTL_OSVERSIONINFOW*);
		auto RtlGetVersion = (tRtlGetVersion)GetProcAddress(GetModuleHandleA("ntdll"), "RtlGetVersion");

		RTL_OSVERSIONINFOW x = { sizeof(RTL_OSVERSIONINFOW) };
		RtlGetVersion(&x);
		_winver = MAKEWORD(_minor = x.dwMinorVersion, _major = x.dwMajorVersion);
		if (_major >= 10) _win10build = x.dwBuildNumber;
	}

	int major() { return _major; }

	int minor() { return _minor; }

	int winver() { return _winver; }

	bool minWin8() { return _winver >= 0x602; }

	bool minWin10() { return _major >= 10; }

	bool minWin11() { return _win10build >= 22000; }

	bool is32BitOS() {
#ifdef _WIN64
		return false;
#else
		static int r;
		if (!r) {
			if (IsWow64Process(GetCurrentProcess(), &r)) r = r ? 1 : -1;
		}
		return r < 0;
#endif
	}
};
extern OSVersion osVer;

extern HMODULE s_moduleHandle;

//returns: 1 32, 2 x64, 3 arm64
inline int GetProcessArchitecture() {
#if _M_ARM64
	return 3;
#elif _WIN64
	return 2;
#else
	return 1;
#endif
}

EXPORT int Cpp_GetProcessArchitecture(DWORD pid);


//Standard IUnknown implementation with thread-unsafe refcounting.
#define STD_IUNKNOWN_METHODS(iface) \
STDMETHODIMP QueryInterface(REFIID iid, void** ppv)\
{\
	if(iid == IID_IUnknown || iid == IID_##iface) { _cRef++; *ppv = this; return S_OK; }\
	else { *ppv = nullptr; return E_NOINTERFACE; }\
}\
STDMETHODIMP_(ULONG) AddRef()\
{\
	return ++_cRef;\
}\
STDMETHODIMP_(ULONG) Release()\
{\
	long ret=--_cRef;\
	if(!ret) delete this;\
	return ret;\
}


//Standard IUnknown implementation without refcounting.
#define STD_IUNKNOWN_METHODS_SIMPLE(iface) \
STDMETHODIMP QueryInterface(REFIID iid, void** ppv)\
{\
	if(iid == IID_IUnknown || iid == IID_##iface) { *ppv = this; return S_OK; }\
	else { *ppv = nullptr; return E_NOINTERFACE; }\
}\
STDMETHODIMP_(ULONG) AddRef() { return 1; }\
STDMETHODIMP_(ULONG) Release() { return 1; }


//Smart pointer that extends CComPtr.
//I don't use _com_ptr_t because: 1. Can throw. 2. Intellisense bug after upgrading VS: shows many false errors.
template <class T>
class Smart : public CComPtr<T> {
public:
	Smart() throw() {
	}
	Smart(_Inout_opt_ T* lp, bool addRef) throw() {
		this->p = lp;
		if (addRef) this->p->AddRef();
	}
	Smart(_Inout_ const Smart<T>& lp) throw() : CComPtr<T>(lp.p) {
	}

	void Swap(CComPtrBase<T>& other) {
		T* pTemp = this->p;
		this->p = other.p;
		other.p = pTemp;
	}

};


//Delay-loaded API pointers.
struct DelayLoadedApi {
	bool minWin81, minWin10;

	//user32
	BOOL(WINAPI* PhysicalToLogicalPoint)(HWND hWnd, LPPOINT lpPoint);
	BOOL(WINAPI* LogicalToPhysicalPoint)(HWND hWnd, LPPOINT lpPoint);
	DPI_AWARENESS_CONTEXT(WINAPI* GetWindowDpiAwarenessContext)(HWND hwnd);
	DPI_AWARENESS(WINAPI* GetAwarenessFromDpiAwarenessContext)(DPI_AWARENESS_CONTEXT value);
	DPI_AWARENESS_CONTEXT(WINAPI* SetThreadDpiAwarenessContext)(DPI_AWARENESS_CONTEXT dpiContext);

	//shcore
	HRESULT(__stdcall* GetProcessDpiAwareness)(HANDLE hprocess, PROCESS_DPI_AWARENESS* value);

	//kernel32
	BOOL(WINAPI* IsWow64Process2)(HANDLE hProcess, USHORT* pProcessMachine, USHORT* pNativeMachine);
	BOOL(WINAPI* GetProcessInformation)(HANDLE hProcess, PROCESS_INFORMATION_CLASS ProcessInformationClass, LPVOID ProcessInformation, DWORD ProcessInformationSize);

#define GPA(hm, f) *(FARPROC*)&f=GetProcAddress(hm, #f)
#define GPA2(hm, f, name) *(FARPROC*)&f=GetProcAddress(hm, name)
	DelayLoadedApi() noexcept {
		minWin81 = minWin10 = false;
		auto hKernel = GetModuleHandle(L"kernel32.dll");
		auto hUser = GetModuleHandle(L"user32.dll");
		GPA2(hUser, PhysicalToLogicalPoint, "PhysicalToLogicalPointForPerMonitorDPI");
		if (minWin81 = PhysicalToLogicalPoint) { //Win8.1+
			GPA2(hUser, LogicalToPhysicalPoint, "LogicalToPhysicalPointForPerMonitorDPI");

			GPA(hUser, GetWindowDpiAwarenessContext);
			if (minWin10 = GetWindowDpiAwarenessContext) { //Win10 1607+
				GPA(hUser, GetAwarenessFromDpiAwarenessContext);
				GPA(hUser, SetThreadDpiAwarenessContext);

				GPA(hKernel, IsWow64Process2); //Win10 1709+
				GPA(hKernel, GetProcessInformation); //Win8, but only on Win11 supports what we need
			} else {
				auto hShcore = GetModuleHandle(L"shcore.dll");
				GPA(hShcore, GetProcessDpiAwareness);
			}


		} else { //Win7/8
			GPA(hUser, PhysicalToLogicalPoint);
			//GPA(hUser, LogicalToPhysicalPoint);

		}
	}
};
extern DelayLoadedApi dlapi;


//SECURITY_ATTRIBUTES that allows UAC low integrity level processes to open the kernel object.
//can instead use CSecurityAttributes/CSecurityDesc, but this added before including ATL, and don't want to change now.
class SecurityAttributes {
	DWORD nLength;
	LPVOID lpSecurityDescriptor;
	BOOL bInheritHandle;
public:

	SecurityAttributes() {
		nLength = sizeof(SecurityAttributes);
		bInheritHandle = false;
		lpSecurityDescriptor = null;
		BOOL ok = ConvertStringSecurityDescriptorToSecurityDescriptorW(L"D:NO_ACCESS_CONTROLS:(ML;;NW;;;LW)", 1, &lpSecurityDescriptor, null);
		assert(ok);
	}

	~SecurityAttributes() {
		LocalFree(lpSecurityDescriptor);
	}

	//SECURITY_ATTRIBUTES* operator&() {
	//	return (SECURITY_ATTRIBUTES*)this;
	//}

	static SECURITY_ATTRIBUTES* Common() {
		static SecurityAttributes s_sa;
		return (SECURITY_ATTRIBUTES*)&s_sa;
	}
};

class AutoReleaseMutex {
	HANDLE _mutex;
public:
	AutoReleaseMutex(HANDLE mutex) noexcept {
		_mutex = mutex;
	}

	~AutoReleaseMutex() {
		if (_mutex) ReleaseMutex(_mutex);
	}

	void ReleaseNow() {
		if (_mutex) ReleaseMutex(_mutex);
		_mutex = 0;
	}
};

//class ProcessMemory
//{
//	LPBYTE m_mem;
//	HANDLE m_hproc;
//public:
//	ProcessMemory() { ZEROTHIS; }
//	~ProcessMemory() { Free(); }
//	LPBYTE Alloc(HWND hWnd, DWORD nBytes, DWORD flags = 0);
//};

//currently not used.
////can instead use CAtlFileMappingBase from atlfile.h, but this added before including ATL, and don't want to change now.
//class SharedMemory
//{
//	HANDLE _hmapfile;
//	LPBYTE _mem;
//public:
//	SharedMemory() { _hmapfile = 0; _mem = 0; }
//	~SharedMemory() { Close(); }
//
//	bool Create(STR name, DWORD size)
//	{
//		Close();
//		_hmapfile = CreateFileMappingW((HANDLE)(-1), SecurityAttributes::Common(), PAGE_READWRITE, 0, size, name);
//		if(!_hmapfile) return false;
//		_mem = (LPBYTE)MapViewOfFile(_hmapfile, FILE_MAP_ALL_ACCESS, 0, 0, 0);
//		return _mem != null;
//	}
//
//	bool Open(STR name)
//	{
//		Close();
//		_hmapfile = OpenFileMappingW(FILE_MAP_ALL_ACCESS, 0, name);
//		if(!_hmapfile) return false;
//		_mem = (LPBYTE)MapViewOfFile(_hmapfile, FILE_MAP_ALL_ACCESS, 0, 0, 0);
//		return _mem != null;
//	}
//
//	void Close()
//	{
//		if(_mem) { UnmapViewOfFile(_mem); _mem = 0; }
//		if(_hmapfile) { CloseHandle(_hmapfile); _hmapfile = 0; }
//	}
//
//	LPBYTE Mem() { return _mem; }
//
//	bool Is0() { return _mem == null; }
//};

//currently not used.
//template<class T>
//class AutoResetVariable
//{
//	T* _b;
//public:
//	AutoResetVariable(T* b, T value) { _b = b; *b = value; }
//	~AutoResetVariable() { *_b = 0; }
//};

//IStream helpers.
class istream {
public:
	static LARGE_INTEGER LI(__int64 i) {
		LARGE_INTEGER r; r.QuadPart = i;
		return r;
	}

	static ULARGE_INTEGER ULI(__int64 i) {
		ULARGE_INTEGER r; r.QuadPart = i;
		return r;
	}

	static bool ResetPos(IStream* x) {
		return 0 == x->Seek(LI(0), STREAM_SEEK_SET, null);
	}

	static bool GetPos(IStream* x, out DWORD& pos) {
		pos = 0;
		__int64 pos64;
		if (x->Seek(LI(0), STREAM_SEEK_CUR, (ULARGE_INTEGER*)&pos64)) return false;
		pos = (DWORD)pos64;
		return true;
	}

	//static bool GetSize(IStream* x, out DWORD& size) {
	//	size = 0;
	//	STATSTG stat;
	//	if(x->Stat(&stat, STATFLAG_NONAME)) return false;
	//	size = stat.cbSize.LowPart;
	//	return true;
	//}

	static bool Clear(IStream* x) {
		return 0 == x->SetSize(ULI(0));
	}
};

//Use inproc to DPI-scale elm rect from logical to physical.
class DpiElmScaling {
	HWND _w;
	RECT _rw;
	bool _scaled;
	bool _haveRect;
public:
	//Use w or acc. If acc not null, ignores w and calls WindowFromAccessibleObject.
	DpiElmScaling(bool use, HWND w, IAccessible* acc) {
		ZEROTHIS;
		if (!use || !dlapi.minWin81) return; //on Win7/8 we get physical rect

		if (acc != null) {
			if (!(0 == WindowFromAccessibleObject(acc, &w) && w)) { //TODO3: if w specified too in the props string, don't call twice. Same with r/D.
				PRINTS(L"failed WindowFromAccessibleObject");
				return;
			}
		}
		_w = w;

		auto da = DPI_AWARENESS::DPI_AWARENESS_SYSTEM_AWARE;
		if (dlapi.GetWindowDpiAwarenessContext) { //Win10 1607
			da = dlapi.GetAwarenessFromDpiAwarenessContext(dlapi.GetWindowDpiAwarenessContext(w)); //fast
			if (da != DPI_AWARENESS::DPI_AWARENESS_SYSTEM_AWARE && da != DPI_AWARENESS::DPI_AWARENESS_UNAWARE) return;
		} else { //Win8.1
			PROCESS_DPI_AWARENESS pda;
			if (0 == dlapi.GetProcessDpiAwareness(GetCurrentProcess(), &pda) && pda == PROCESS_DPI_AWARENESS::PROCESS_PER_MONITOR_DPI_AWARE) return;
		}

		if (!(_haveRect = GetWindowRect(_w, &_rw))) { _w = 0; return; }

		//On Win10+ we can easily, quickly and reliably detect whether the window is DPI-scaled.
		if (dlapi.SetThreadDpiAwarenessContext) { //Win10 1607
			auto ac = dlapi.SetThreadDpiAwarenessContext(DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2); //fast
			RECT r2;
			_scaled = GetWindowRect(_w, &r2) && memcmp(&_rw, &r2, 16);
			dlapi.SetThreadDpiAwarenessContext(ac);
		} else _scaled = true; //on Win8.1 assume need scaling, it does not harm
	}

	//Returns: 0 don't need to scale, 1 r is not in the window, 2 scaled ok, -1 failed to scale.
	//needReturn1 - even if don't need to scale, return 1 if r is not in the window.
	int ScaleIfNeed(ref RECT& r, bool needReturn1 = false) {
		if (!_scaled) {
			if (needReturn1 && _w) {
				if (!_haveRect && !(_haveRect = GetWindowRect(_w, &_rw))) { _w = 0; return 0; }
				if (!IntersectRect(&r, &r, &_rw)) return 1;
			}
			return 0;
		}

		//The API fails if the point is not in the window rect, except when touches it at the right/bottom.
		//Tried workaround: create a hidden window with same DPI awareness and use it with the API instead of w.
		//	In most cases it works, but often does not scale if the point is outside the top-level window.
		//Current workaround: use r intersection with the container window rect.
		if (!IntersectRect(&r, &r, &_rw)) return 1;

		POINT p1 = { r.left, r.top }, p2 = { r.right, r.bottom };
		if (dlapi.LogicalToPhysicalPoint(_w, &p1) && dlapi.LogicalToPhysicalPoint(_w, &p2)) {
			SetRect(&r, p1.x, p1.y, p2.x, p2.y);
			return 2;
		} else {
			PRINTS(L"failed LogicalToPhysicalPoint");
			return -1;
		}
	}
};

namespace wn {
	inline DWORD Style(HWND w) { return (DWORD)GetWindowLongPtrW(w, GWL_STYLE); }
	inline DWORD ExStyle(HWND w) { return (DWORD)GetWindowLongPtrW(w, GWL_EXSTYLE); }
	bool ClassName(HWND w, out Bstr& s);
	int ClassNameIs(HWND w, std::initializer_list<STR> a);
	bool ClassNameIs(HWND w, STR s);
	bool ClassNameIs(HWND w, const str::Wildex& s);
	bool Name(HWND w, out Bstr& s);
	bool IsVisibleInWindow(HWND c, HWND wTL);

	using WNDENUMPROCL = const std::function <bool(HWND c)>;

	BOOL EnumChildWindows(HWND w, WNDENUMPROCL& callback);
	HWND FindChildByClassName(HWND w, STR className, bool visible);
	HWND FindChildByClassName(HWND w, STR className1, STR className2, OUT bool& second, bool visible);
	HWND FindWndEx(HWND wParent, HWND wAfter, STR cn, STR name = null);
	HWND FindWnd(STR cn, STR name = null);
	HWND FindWndExVisible(HWND wParent, STR cn);
	bool WinformsNameIs(HWND w, STR name);

#if TRACE
	void PrintWnd(HWND w);
#else
#define PrintWnd __noop
#endif
}

bool QueryService_(IUnknown* iFrom, OUT void** iTo, REFIID iid, const GUID* guidService = null);

template<class T>
bool QueryService(IUnknown* iFrom, OUT T** iTo, const GUID* guidService = null) {
	return QueryService_(iFrom, (void**)iTo, __uuidof(T), guidService);
}

namespace util {
	//Swaps values of variables a and b: <c>T t = a; a = b; b = t;</c>
	template<class T>
	void Swap(ref T& a, ref T& b) {
		T t = a; a = b; b = t;
	}

}


================================================
FILE: LICENSE.txt
================================================
MIT License

Copyright (c) 2025 Gintaras Didžgalvis

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.


================================================
FILE: Libraries/PCRE/PCRE.vcxproj
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <ItemGroup Label="ProjectConfigurations">
    <ProjectConfiguration Include="Debug|ARM64">
      <Configuration>Debug</Configuration>
      <Platform>ARM64</Platform>
    </ProjectConfiguration>
    <ProjectConfiguration Include="Debug|Win32">
      <Configuration>Debug</Configuration>
      <Platform>Win32</Platform>
    </ProjectConfiguration>
    <ProjectConfiguration Include="Release|ARM64">
      <Configuration>Release</Configuration>
      <Platform>ARM64</Platform>
    </ProjectConfiguration>
    <ProjectConfiguration Include="Release|Win32">
      <Configuration>Release</Configuration>
      <Platform>Win32</Platform>
    </ProjectConfiguration>
    <ProjectConfiguration Include="Debug|x64">
      <Configuration>Debug</Configuration>
      <Platform>x64</Platform>
    </ProjectConfiguration>
    <ProjectConfiguration Include="Release|x64">
      <Configuration>Release</Configuration>
      <Platform>x64</Platform>
    </ProjectConfiguration>
  </ItemGroup>
  <PropertyGroup Label="Globals">
    <VCProjectVersion>15.0</VCProjectVersion>
    <ProjectGuid>{190BC611-EE00-4B10-87F2-A7E73B639E59}</ProjectGuid>
    <Keyword>Win32Proj</Keyword>
    <RootNamespace>PCRE</RootNamespace>
    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
  </PropertyGroup>
  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
    <ConfigurationType>StaticLibrary</ConfigurationType>
    <UseDebugLibraries>true</UseDebugLibraries>
    <PlatformToolset>v143</PlatformToolset>
    <CharacterSet>Unicode</CharacterSet>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
    <ConfigurationType>StaticLibrary</ConfigurationType>
    <UseDebugLibraries>false</UseDebugLibraries>
    <PlatformToolset>v143</PlatformToolset>
    <CharacterSet>Unicode</CharacterSet>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
    <ConfigurationType>StaticLibrary</ConfigurationType>
    <UseDebugLibraries>true</UseDebugLibraries>
    <PlatformToolset>v143</PlatformToolset>
    <CharacterSet>Unicode</CharacterSet>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM64'" Label="Configuration">
    <ConfigurationType>StaticLibrary</ConfigurationType>
    <UseDebugLibraries>true</UseDebugLibraries>
    <PlatformToolset>v143</PlatformToolset>
    <CharacterSet>Unicode</CharacterSet>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
    <ConfigurationType>StaticLibrary</ConfigurationType>
    <UseDebugLibraries>false</UseDebugLibraries>
    <PlatformToolset>v143</PlatformToolset>
    <CharacterSet>Unicode</CharacterSet>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'" Label="Configuration">
    <ConfigurationType>StaticLibrary</ConfigurationType>
    <UseDebugLibraries>false</UseDebugLibraries>
    <PlatformToolset>v143</PlatformToolset>
    <CharacterSet>Unicode</CharacterSet>
  </PropertyGroup>
  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
  <ImportGroup Label="ExtensionSettings">
  </ImportGroup>
  <ImportGroup Label="Shared">
  </ImportGroup>
  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
  </ImportGroup>
  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
  </ImportGroup>
  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
  </ImportGroup>
  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM64'" Label="PropertySheets">
    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
  </ImportGroup>
  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
  </ImportGroup>
  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'" Label="PropertySheets">
    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
  </ImportGroup>
  <PropertyGroup Label="UserMacros" />
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
    <LinkIncremental>true</LinkIncremental>
    <OutDir>bin\$(Platform)\$(Configuration)\</OutDir>
    <IntDir>obj\$(Platform)\$(Configuration)\</IntDir>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
    <LinkIncremental>true</LinkIncremental>
    <OutDir>bin\$(Platform)\$(Configuration)\</OutDir>
    <IntDir>obj\$(Platform)\$(Configuration)\</IntDir>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM64'">
    <LinkIncremental>true</LinkIncremental>
    <OutDir>bin\$(Platform)\$(Configuration)\</OutDir>
    <IntDir>obj\$(Platform)\$(Configuration)\</IntDir>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
    <LinkIncremental>false</LinkIncremental>
    <OutDir>bin\$(Platform)\$(Configuration)\</OutDir>
    <IntDir>obj\$(Platform)\$(Configuration)\</IntDir>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
    <LinkIncremental>false</LinkIncremental>
    <OutDir>bin\$(Platform)\$(Configuration)\</OutDir>
    <IntDir>obj\$(Platform)\$(Configuration)\</IntDir>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'">
    <LinkIncremental>false</LinkIncremental>
    <OutDir>bin\$(Platform)\$(Configuration)\</OutDir>
    <IntDir>obj\$(Platform)\$(Configuration)\</IntDir>
  </PropertyGroup>
  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
    <ClCompile>
      <WarningLevel>Level3</WarningLevel>
      <Optimization>Disabled</Optimization>
      <PreprocessorDefinitions>WIN32;_DEBUG;_LIB;%(PreprocessorDefinitions);HAVE_CONFIG_H;PCRE2_CODE_UNIT_WIDTH=16</PreprocessorDefinitions>
      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
    </ClCompile>
    <Link>
      <SubSystem>Windows</SubSystem>
      <GenerateDebugInformation>true</GenerateDebugInformation>
    </Link>
  </ItemDefinitionGroup>
  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
    <ClCompile>
      <WarningLevel>Level3</WarningLevel>
      <Optimization>Disabled</Optimization>
      <PreprocessorDefinitions>_DEBUG;_LIB;%(PreprocessorDefinitions);HAVE_CONFIG_H;PCRE2_CODE_UNIT_WIDTH=16</PreprocessorDefinitions>
      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
    </ClCompile>
    <Link>
      <SubSystem>Windows</SubSystem>
      <GenerateDebugInformation>true</GenerateDebugInformation>
    </Link>
  </ItemDefinitionGroup>
  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM64'">
    <ClCompile>
      <WarningLevel>Level3</WarningLevel>
      <Optimization>Disabled</Optimization>
      <PreprocessorDefinitions>_DEBUG;_LIB;%(PreprocessorDefinitions);HAVE_CONFIG_H;PCRE2_CODE_UNIT_WIDTH=16</PreprocessorDefinitions>
      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
    </ClCompile>
    <Link>
      <SubSystem>Windows</SubSystem>
      <GenerateDebugInformation>true</GenerateDebugInformation>
    </Link>
  </ItemDefinitionGroup>
  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
    <ClCompile>
      <WarningLevel>Level3</WarningLevel>
      <Optimization>MaxSpeed</Optimization>
      <FunctionLevelLinking>true</FunctionLevelLinking>
      <IntrinsicFunctions>true</IntrinsicFunctions>
      <PreprocessorDefinitions>WIN32;NDEBUG;_LIB;%(PreprocessorDefinitions);HAVE_CONFIG_H;PCRE2_CODE_UNIT_WIDTH=16</PreprocessorDefinitions>
      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
      <BufferSecurityCheck>false</BufferSecurityCheck>
    </ClCompile>
    <Link>
      <SubSystem>Windows</SubSystem>
      <EnableCOMDATFolding>true</EnableCOMDATFolding>
      <OptimizeReferences>true</OptimizeReferences>
      <GenerateDebugInformation>true</GenerateDebugInformation>
    </Link>
  </ItemDefinitionGroup>
  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
    <ClCompile>
      <WarningLevel>Level3</WarningLevel>
      <Optimization>MaxSpeed</Optimization>
      <FunctionLevelLinking>true</FunctionLevelLinking>
      <IntrinsicFunctions>true</IntrinsicFunctions>
      <PreprocessorDefinitions>NDEBUG;_LIB;%(PreprocessorDefinitions);HAVE_CONFIG_H;PCRE2_CODE_UNIT_WIDTH=16</PreprocessorDefinitions>
      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
      <BufferSecurityCheck>false</BufferSecurityCheck>
    </ClCompile>
    <Link>
      <SubSystem>Windows</SubSystem>
      <EnableCOMDATFolding>true</EnableCOMDATFolding>
      <OptimizeReferences>true</OptimizeReferences>
      <GenerateDebugInformation>true</GenerateDebugInformation>
    </Link>
  </ItemDefinitionGroup>
  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'">
    <ClCompile>
      <WarningLevel>Level3</WarningLevel>
      <Optimization>MaxSpeed</Optimization>
      <FunctionLevelLinking>true</FunctionLevelLinking>
      <IntrinsicFunctions>true</IntrinsicFunctions>
      <PreprocessorDefinitions>NDEBUG;_LIB;%(PreprocessorDefinitions);HAVE_CONFIG_H;PCRE2_CODE_UNIT_WIDTH=16</PreprocessorDefinitions>
      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
      <BufferSecurityCheck>false</BufferSecurityCheck>
    </ClCompile>
    <Link>
      <SubSystem>Windows</SubSystem>
      <EnableCOMDATFolding>true</EnableCOMDATFolding>
      <OptimizeReferences>true</OptimizeReferences>
      <GenerateDebugInformation>true</GenerateDebugInformation>
    </Link>
  </ItemDefinitionGroup>
  <ItemGroup>
    <ClCompile Include="pcre2_auto_possess.c" />
    <ClCompile Include="pcre2_chartables.c" />
    <ClCompile Include="pcre2_chkdint.c" />
    <ClCompile Include="pcre2_compile.c" />
    <ClCompile Include="pcre2_compile_class.c" />
    <ClCompile Include="pcre2_config.c" />
    <ClCompile Include="pcre2_context.c" />
    <ClCompile Include="pcre2_dfa_match.c">
      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</ExcludedFromBuild>
      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</ExcludedFromBuild>
      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</ExcludedFromBuild>
      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|ARM64'">true</ExcludedFromBuild>
      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</ExcludedFromBuild>
      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'">true</ExcludedFromBuild>
    </ClCompile>
    <ClCompile Include="pcre2_error.c" />
    <ClCompile Include="pcre2_extuni.c" />
    <ClCompile Include="pcre2_find_bracket.c" />
    <ClCompile Include="pcre2_maketables.c" />
    <ClCompile Include="pcre2_match.c" />
    <ClCompile Include="pcre2_match_data.c" />
    <ClCompile Include="pcre2_newline.c" />
    <ClCompile Include="pcre2_ord2utf.c" />
    <ClCompile Include="pcre2_pattern_info.c" />
    <ClCompile Include="pcre2_script_run.c" />
    <ClCompile Include="pcre2_serialize.c" />
    <ClCompile Include="pcre2_string_utils.c" />
    <ClCompile Include="pcre2_study.c" />
    <ClCompile Include="pcre2_substitute.c">
      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</ExcludedFromBuild>
      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</ExcludedFromBuild>
      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</ExcludedFromBuild>
      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|ARM64'">true</ExcludedFromBuild>
      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</ExcludedFromBuild>
      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'">true</ExcludedFromBuild>
    </ClCompile>
    <ClCompile Include="pcre2_substring.c" />
    <ClCompile Include="pcre2_tables.c" />
    <ClCompile Include="pcre2_ucd.c" />
    <ClCompile Include="pcre2_ucptables.c" />
    <ClCompile Include="pcre2_valid_utf.c" />
    <ClCompile Include="pcre2_xclass.c" />
  </ItemGroup>
  <ItemGroup>
    <ClInclude Include="config.h" />
    <ClInclude Include="pcre2.h" />
    <ClInclude Include="pcre2_compile.h" />
    <ClInclude Include="pcre2_internal.h" />
    <ClInclude Include="pcre2_intmodedep.h" />
    <ClInclude Include="pcre2_ucp.h" />
    <ClInclude Include="pcre2_util.h" />
  </ItemGroup>
  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
  <ImportGroup Label="ExtensionTargets">
  </ImportGroup>
</Project>

================================================
FILE: Libraries/PCRE/PCRE.vcxproj.filters
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <ItemGroup>
    <Filter Include="Source Files">
      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
    </Filter>
    <Filter Include="Header Files">
      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
      <Extensions>h;hh;hpp;hxx;hm;inl;inc;xsd</Extensions>
    </Filter>
    <Filter Include="Resource Files">
      <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
      <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
    </Filter>
    <Filter Include="Source Files\excluded">
      <UniqueIdentifier>{db256fb5-df1c-4de2-8315-4927b4223fa1}</UniqueIdentifier>
    </Filter>
  </ItemGroup>
  <ItemGroup>
    <ClCompile Include="pcre2_auto_possess.c">
      <Filter>Source Files</Filter>
    </ClCompile>
    <ClCompile Include="pcre2_compile.c">
      <Filter>Source Files</Filter>
    </ClCompile>
    <ClCompile Include="pcre2_config.c">
      <Filter>Source Files</Filter>
    </ClCompile>
    <ClCompile Include="pcre2_context.c">
      <Filter>Source Files</Filter>
    </ClCompile>
    <ClCompile Include="pcre2_error.c">
      <Filter>Source Files</Filter>
    </ClCompile>
    <ClCompile Include="pcre2_find_bracket.c">
      <Filter>Source Files</Filter>
    </ClCompile>
    <ClCompile Include="pcre2_maketables.c">
      <Filter>Source Files</Filter>
    </ClCompile>
    <ClCompile Include="pcre2_match.c">
      <Filter>Source Files</Filter>
    </ClCompile>
    <ClCompile Include="pcre2_match_data.c">
      <Filter>Source Files</Filter>
    </ClCompile>
    <ClCompile Include="pcre2_newline.c">
      <Filter>Source Files</Filter>
    </ClCompile>
    <ClCompile Include="pcre2_ord2utf.c">
      <Filter>Source Files</Filter>
    </ClCompile>
    <ClCompile Include="pcre2_pattern_info.c">
      <Filter>Source Files</Filter>
    </ClCompile>
    <ClCompile Include="pcre2_serialize.c">
      <Filter>Source Files</Filter>
    </ClCompile>
    <ClCompile Include="pcre2_string_utils.c">
      <Filter>Source Files</Filter>
    </ClCompile>
    <ClCompile Include="pcre2_study.c">
      <Filter>Source Files</Filter>
    </ClCompile>
    <ClCompile Include="pcre2_substring.c">
      <Filter>Source Files</Filter>
    </ClCompile>
    <ClCompile Include="pcre2_tables.c">
      <Filter>Source Files</Filter>
    </ClCompile>
    <ClCompile Include="pcre2_ucd.c">
      <Filter>Source Files</Filter>
    </ClCompile>
    <ClCompile Include="pcre2_valid_utf.c">
      <Filter>Source Files</Filter>
    </ClCompile>
    <ClCompile Include="pcre2_xclass.c">
      <Filter>Source Files</Filter>
    </ClCompile>
    <ClCompile Include="pcre2_chartables.c">
      <Filter>Source Files</Filter>
    </ClCompile>
    <ClCompile Include="pcre2_dfa_match.c">
      <Filter>Source Files\excluded</Filter>
    </ClCompile>
    <ClCompile Include="pcre2_extuni.c">
      <Filter>Source Files</Filter>
    </ClCompile>
    <ClCompile Include="pcre2_script_run.c">
      <Filter>Source Files</Filter>
    </ClCompile>
    <ClCompile Include="pcre2_substitute.c">
      <Filter>Source Files\excluded</Filter>
    </ClCompile>
    <ClCompile Include="pcre2_ucptables.c">
      <Filter>Source Files</Filter>
    </ClCompile>
    <ClCompile Include="pcre2_chkdint.c">
      <Filter>Source Files</Filter>
    </ClCompile>
    <ClCompile Include="pcre2_compile_class.c">
      <Filter>Source Files</Filter>
    </ClCompile>
  </ItemGroup>
  <ItemGroup>
    <ClInclude Include="pcre2_internal.h">
      <Filter>Header Files</Filter>
    </ClInclude>
    <ClInclude Include="pcre2_intmodedep.h">
      <Filter>Header Files</Filter>
    </ClInclude>
    <ClInclude Include="pcre2_ucp.h">
      <Filter>Header Files</Filter>
    </ClInclude>
    <ClInclude Include="config.h">
      <Filter>Header Files</Filter>
    </ClInclude>
    <ClInclude Include="pcre2.h">
      <Filter>Header Files</Filter>
    </ClInclude>
    <ClInclude Include="pcre2_compile.h">
      <Filter>Header Files</Filter>
    </ClInclude>
    <ClInclude Include="pcre2_util.h">
      <Filter>Header Files</Filter>
    </ClInclude>
  </ItemGroup>
</Project>

================================================
FILE: Libraries/PCRE/config.h
================================================
/* src/config.h.  Generated from config.h.in by configure.  */
/* src/config.h.in.  Generated from configure.ac by autoheader.  */

/* PCRE2 is written in Standard C, but there are a few non-standard things it
can cope with, allowing it to run on SunOS4 and other "close to standard"
systems.

In environments that support the GNU autotools, config.h.in is converted into
config.h by the "configure" script. In environments that use CMake,
config-cmake.in is converted into config.h. If you are going to build PCRE2 "by
hand" without using "configure" or CMake, you should copy the distributed
config.h.generic to config.h, and edit the macro definitions to be the way you
need them. You must then add -DHAVE_CONFIG_H to all of your compile commands,
so that config.h is included at the start of every source.

Alternatively, you can avoid editing by using -D on the compiler command line
to set the macro values. In this case, you do not have to set -DHAVE_CONFIG_H,
but if you do, default values will be taken from config.h for non-boolean
macros that are not defined on the command line.

Boolean macros such as HAVE_STDLIB_H and SUPPORT_PCRE2_8 should either be
defined (conventionally to 1) for TRUE, and not defined at all for FALSE. All
such macros are listed as a commented #undef in config.h.generic. Macros such
as MATCH_LIMIT, whose actual value is relevant, have defaults defined, but are
surrounded by #ifndef/#endif lines so that the value can be overridden by -D.

PCRE2 uses memmove() if HAVE_MEMMOVE is defined; otherwise it uses bcopy() if
HAVE_BCOPY is defined. If your system has neither bcopy() nor memmove(), make
sure both macros are undefined; an emulation function will then be used. */

/* By default, the \R escape sequence matches any Unicode line ending
   character or sequence of characters. If BSR_ANYCRLF is defined (to any
   value), this is changed so that backslash-R matches only CR, LF, or CRLF.
   The build-time default can be overridden by the user of PCRE2 at runtime.
   */
#define BSR_ANYCRLF 1

/* Define to any value to disable the use of the z and t modifiers in
   formatting settings such as %zu or %td (this is rarely needed). */
/* #undef DISABLE_PERCENT_ZT */

/* If you are compiling for a system that uses EBCDIC instead of ASCII
   character codes, define this macro to any value. When EBCDIC is set, PCRE2
   assumes that all input strings are in EBCDIC. If you do not define this
   macro, PCRE2 will assume input strings are ASCII or UTF-8/16/32 Unicode. It
   is not possible to build a version of PCRE2 that supports both EBCDIC and
   UTF-8/16/32. */
/* #undef EBCDIC */

/* In an EBCDIC environment, define this macro to any value to arrange for the
   NL character to be 0x25 instead of the default 0x15. NL plays the role that
   LF does in an ASCII/Unicode environment. */
/* #undef EBCDIC_NL25 */

/* Define to 1 if you have the <assert.h> header file. */
/* #undef HAVE_ASSERT_H */

/* Define this if your compiler supports __attribute__((uninitialized)) */
/* #undef HAVE_ATTRIBUTE_UNINITIALIZED */

/* Define to 1 if you have the `bcopy' function. */
/* #undef HAVE_BCOPY */

/* Define this if your compiler provides __assume() */
/* #undef HAVE_BUILTIN_ASSUME */

/* Define this if your compiler provides __builtin_mul_overflow() */
/* #undef HAVE_BUILTIN_MUL_OVERFLOW */

/* Define this if your compiler provides __builtin_unreachable() */
/* #undef HAVE_BUILTIN_UNREACHABLE */

/* Define to 1 if you have the <bzlib.h> header file. */
/* #undef HAVE_BZLIB_H */

/* Define to 1 if you have the <dirent.h> header file. */
/* #undef HAVE_DIRENT_H */

/* Define to 1 if you have the <dlfcn.h> header file. */
/* #undef HAVE_DLFCN_H */

/* Define to 1 if you have the <editline/readline.h> header file. */
/* #undef HAVE_EDITLINE_READLINE_H */

/* Define to 1 if you have the <edit/readline/readline.h> header file. */
/* #undef HAVE_EDIT_READLINE_READLINE_H */

/* Define to 1 if you have the <inttypes.h> header file. */
#define HAVE_INTTYPES_H

/* Define to 1 if you have the <limits.h> header file. */
#define HAVE_LIMITS_H 1

/* Define to 1 if you have the `memfd_create' function. */
/* #undef HAVE_MEMFD_CREATE */

/* Define to 1 if you have the `memmove' function. */
#define HAVE_MEMMOVE 1

/* Define to 1 if you have the <minix/config.h> header file. */
/* #undef HAVE_MINIX_CONFIG_H */

/* Define to 1 if you have the `mkostemp' function. */
/* #undef HAVE_MKOSTEMP */

/* Define if you have POSIX threads libraries and header files. */
/* #undef HAVE_PTHREAD */

/* Have PTHREAD_PRIO_INHERIT. */
/* #undef HAVE_PTHREAD_PRIO_INHERIT */

/* Define to 1 if you have the <readline.h> header file. */
/* #undef HAVE_READLINE_H */

/* Define to 1 if you have the <readline/history.h> header file. */
/* #undef HAVE_READLINE_HISTORY_H */

/* Define to 1 if you have the <readline/readline.h> header file. */
/* #undef HAVE_READLINE_READLINE_H */

/* Define to 1 if you have the `realpath' function. */
/* #undef HAVE_REALPATH */

/* Define to 1 if you have the `secure_getenv' function. */
/* #undef HAVE_SECURE_GETENV */

/* Define to 1 if you have the <stdint.h> header file. */
#define HAVE_STDINT_H 1

/* Define to 1 if you have the <stdio.h> header file. */
#define HAVE_STDIO_H 1

/* Define to 1 if you have the <stdlib.h> header file. */
#define HAVE_STDLIB_H 1

/* Define to 1 if you have the `strerror' function. */
/* #undef HAVE_STRERROR */

/* Define to 1 if you have the <strings.h> header file. */
/* #undef HAVE_STRINGS_H */

/* Define to 1 if you have the <string.h> header file. */
#define HAVE_STRING_H 1

/* Define to 1 if you have the <sys/stat.h> header file. */
#define HAVE_SYS_STAT_H 1

/* Define to 1 if you have the <sys/types.h> header file. */
#define HAVE_SYS_TYPES_H 1

/* Define to 1 if you have the <sys/wait.h> header file. */
/* #undef HAVE_SYS_WAIT_H */

/* Define to 1 if you have the <unistd.h> header file. */
/* #undef HAVE_UNISTD_H */

/* Define to 1 if the compiler supports GCC compatible visibility
   declarations. */
/* #undef HAVE_VISIBILITY */

/* Define to 1 if you have the <wchar.h> header file. */
#define HAVE_WCHAR_H

/* Define to 1 if you have the <windows.h> header file. */
#define HAVE_WINDOWS_H 1

/* Define to 1 if you have the <zlib.h> header file. */
/* #undef HAVE_ZLIB_H */

/* This limits the amount of memory that may be used while matching a pattern.
   It applies to both pcre2_match() and pcre2_dfa_match(). It does not apply
   to JIT matching. The value is in kibibytes (units of 1024 bytes). */
#ifndef HEAP_LIMIT
#define HEAP_LIMIT 20000000
#endif

/* The value of LINK_SIZE determines the number of bytes used to store links
   as offsets within the compiled regex. The default is 2, which allows for
   compiled patterns up to 65535 code units long. This covers the vast
   majority of cases. However, PCRE2 can also be compiled to use 3 or 4 bytes
   instead. This allows for longer patterns in extreme cases. */
#ifndef LINK_SIZE
#define LINK_SIZE 2
#endif

/* Define to the sub-directory where libtool stores uninstalled libraries. */
/* This is ignored unless you are using libtool. */
#ifndef LT_OBJDIR
#define LT_OBJDIR ".libs/"
#endif

/* The value of MATCH_LIMIT determines the default number of times the
   pcre2_match() function can record a backtrack position during a single
   matching attempt. The value is also used to limit a loop counter in
   pcre2_dfa_match(). There is a runtime interface for setting a different
   limit. The limit exists in order to catch runaway regular expressions that
   take forever to determine that they do not match. The default is set very
   large so that it does not accidentally catch legitimate cases. */
#ifndef MATCH_LIMIT
#define MATCH_LIMIT 10000000
#endif

/* The above limit applies to all backtracks, whether or not they are nested.
   In some environments it is desirable to limit the nesting of backtracking
   (that is, the depth of tree that is searched) more strictly, in order to
   restrict the maximum amount of heap memory that is used. The value of
   MATCH_LIMIT_DEPTH provides this facility. To have any useful effect, it
   must be less than the value of MATCH_LIMIT. The default is to use the same
   value as MATCH_LIMIT. There is a runtime method for setting a different
   limit. In the case of pcre2_dfa_match(), this limit controls the depth of
   the internal nested function calls that are used for pattern recursions,
   lookarounds, and atomic groups. */
#ifndef MATCH_LIMIT_DEPTH
#define MATCH_LIMIT_DEPTH MATCH_LIMIT
#endif

/* This limit is parameterized just in case anybody ever wants to change it.
   Care must be taken if it is increased, because it guards against integer
   overflow caused by enormously large patterns. */
#ifndef MAX_NAME_COUNT
#define MAX_NAME_COUNT 10000
#endif

/* This limit is parameterized just in case anybody ever wants to change it.
   Care must be taken if it is increased, because it guards against integer
   overflow caused by enormously large patterns. */
#ifndef MAX_NAME_SIZE
#define MAX_NAME_SIZE 128
#endif

/* The value of MAX_VARLOOKBEHIND specifies the default maximum length, in
   characters, for a variable-length lookbehind assertion. */
#ifndef MAX_VARLOOKBEHIND
#define MAX_VARLOOKBEHIND 255
#endif

/* Defining NEVER_BACKSLASH_C locks out the use of \C in all patterns. */
/* #undef NEVER_BACKSLASH_C */

/* The value of NEWLINE_DEFAULT determines the default newline character
   sequence. PCRE2 client programs can override this by selecting other values
   at run time. The valid values are 1 (CR), 2 (LF), 3 (CRLF), 4 (ANY), 5
   (ANYCRLF), and 6 (NUL). */
#ifndef NEWLINE_DEFAULT
#define NEWLINE_DEFAULT 5
#endif

/* Name of package */
#define PACKAGE "pcre2"

/* Define to the address where bug reports for this package should be sent. */
#define PACKAGE_BUGREPORT ""

/* Define to the full name of this package. */
#define PACKAGE_NAME "PCRE2"

/* Define to the full name and version of this package. */
#define PACKAGE_STRING "PCRE2 10.46"

/* Define to the one symbol short name of this package. */
#define PACKAGE_TARNAME "pcre2"

/* Define to the home page for this package. */
#define PACKAGE_URL ""

/* Define to the version of this package. */
#define PACKAGE_VERSION "10.46"

/* The value of PARENS_NEST_LIMIT specifies the maximum depth of nested
   parentheses (of any kind) in a pattern. This limits the amount of system
   stack that is used while compiling a pattern. */
#ifndef PARENS_NEST_LIMIT
#define PARENS_NEST_LIMIT 250
#endif

/* The value of PCRE2GREP_BUFSIZE is the starting size of the buffer used by
   pcre2grep to hold parts of the file it is searching. The buffer will be
   expanded up to PCRE2GREP_MAX_BUFSIZE if necessary, for files containing
   very long lines. The actual amount of memory used by pcre2grep is three
   times this number, because it allows for the buffering of "before" and
   "after" lines. */
#ifndef PCRE2GREP_BUFSIZE
#define PCRE2GREP_BUFSIZE 20480
#endif

/* The value of PCRE2GREP_MAX_BUFSIZE specifies the maximum size of the buffer
   used by pcre2grep to hold parts of the file it is searching. The actual
   amount of memory used by pcre2grep is three times this number, because it
   allows for the buffering of "before" and "after" lines. */
#ifndef PCRE2GREP_MAX_BUFSIZE
#define PCRE2GREP_MAX_BUFSIZE 1048576
#endif

/* Define to any value to include debugging code. */
/* #undef PCRE2_DEBUG */

/* to make a symbol visible */
#define PCRE2_EXPORT

/* If you are compiling for a system other than a Unix-like system or
   Win32, and it needs some magic to be inserted before the definition
   of a function that is exported by the library, define this macro to
   contain the relevant magic. If you do not define this macro, a suitable
   __declspec value is used for Windows systems; in other environments
   a compiler relevant "extern" is used with any "visibility" related
   attributes from PCRE2_EXPORT included.
   This macro apears at the start of every exported function that is part
   of the external API. It does not appear on functions that are "external"
   in the C sense, but which are internal to the library. */
/* #undef PCRE2_EXP_DEFN */

/* Define to any value if linking statically (TODO: make nice with Libtool) */
#define PCRE2_STATIC 1

/* Define to necessary symbol if this constant uses a non-standard name on
   your system. */
/* #undef PTHREAD_CREATE_JOINABLE */

/* Define to any non-zero number to enable support for SELinux compatible
   executable memory allocator in JIT. Note that this will have no effect
   unless SUPPORT_JIT is also defined. */
/* #undef SLJIT_PROT_EXECUTABLE_ALLOCATOR */

/* Define to 1 if all of the C90 standard headers exist (not just the ones
   required in a freestanding environment). This macro is provided for
   backward compatibility; new code need not use it. */
/* #undef STDC_HEADERS */

/* Define to any value to enable differential fuzzing support. */
/* #undef SUPPORT_DIFF_FUZZ */

/* Define to any value to enable support for Just-In-Time compiling. */
/* #undef SUPPORT_JIT */

/* Define to any value to allow pcre2grep to be linked with libbz2, so that it
   is able to handle .bz2 files. */
/* #undef SUPPORT_LIBBZ2 */

/* Define to any value to allow pcre2test to be linked with libedit. */
/* #undef SUPPORT_LIBEDIT */

/* Define to any value to allow pcre2test to be linked with libreadline. */
/* #undef SUPPORT_LIBREADLINE */

/* Define to any value to allow pcre2grep to be linked with libz, so that it
   is able to handle .gz files. */
/* #undef SUPPORT_LIBZ */

/* Define to any value to enable callout script support in pcre2grep. */
/* #undef SUPPORT_PCRE2GREP_CALLOUT */

/* Define to any value to enable fork support in pcre2grep callout scripts.
   This will have no effect unless SUPPORT_PCRE2GREP_CALLOUT is also defined.
   */
/* #undef SUPPORT_PCRE2GREP_CALLOUT_FORK */

/* Define to any value to enable JIT support in pcre2grep. Note that this will
   have no effect unless SUPPORT_JIT is also defined. */
/* #undef SUPPORT_PCRE2GREP_JIT */

/* Define to any value to enable the 16 bit PCRE2 library. */
#define SUPPORT_PCRE2_16

/* Define to any value to enable the 32 bit PCRE2 library. */
/* #undef SUPPORT_PCRE2_32 */

/* Define to any value to enable the 8 bit PCRE2 library. */
/* #undef SUPPORT_PCRE2_8 */

/* Define to any value to enable support for Unicode and UTF encoding. This
   will work even in an EBCDIC environment, but it is incompatible with the
   EBCDIC macro. That is, PCRE2 can support *either* EBCDIC code *or*
   ASCII/Unicode, but not both at once. */
#define SUPPORT_UNICODE

/* Define to any value for valgrind support to find invalid memory reads. */
/* #undef SUPPORT_VALGRIND */

/* Enable extensions on AIX 3, Interix.  */
#ifndef _ALL_SOURCE
# define _ALL_SOURCE 1
#endif
/* Enable general extensions on macOS.  */
#ifndef _DARWIN_C_SOURCE
# define _DARWIN_C_SOURCE 1
#endif
/* Enable general extensions on Solaris.  */
#ifndef __EXTENSIONS__
# define __EXTENSIONS__ 1
#endif
/* Enable GNU extensions on systems that have them.  */
#ifndef _GNU_SOURCE
# define _GNU_SOURCE 1
#endif
/* Enable X/Open compliant socket functions that do not require linking
   with -lxnet on HP-UX 11.11.  */
#ifndef _HPUX_ALT_XOPEN_SOCKET_API
# define _HPUX_ALT_XOPEN_SOCKET_API 1
#endif
/* Identify the host operating system as Minix.
   This macro does not affect the system headers' behavior.
   A future release of Autoconf may stop defining this macro.  */
#ifndef _MINIX
/* # undef _MINIX */
#endif
/* Enable general extensions on NetBSD.
   Enable NetBSD compatibility extensions on Minix.  */
#ifndef _NETBSD_SOURCE
# define _NETBSD_SOURCE 1
#endif
/* Enable OpenBSD compatibility extensions on NetBSD.
   Oddly enough, this does nothing on OpenBSD.  */
#ifndef _OPENBSD_SOURCE
# define _OPENBSD_SOURCE 1
#endif
/* Define to 1 if needed for POSIX-compatible behavior.  */
#ifndef _POSIX_SOURCE
/* # undef _POSIX_SOURCE */
#endif
/* Define to 2 if needed for POSIX-compatible behavior.  */
#ifndef _POSIX_1_SOURCE
/* # undef _POSIX_1_SOURCE */
#endif
/* Enable POSIX-compatible threading on Solaris.  */
#ifndef _POSIX_PTHREAD_SEMANTICS
# define _POSIX_PTHREAD_SEMANTICS 1
#endif
/* Enable extensions specified by ISO/IEC TS 18661-5:2014.  */
#ifndef __STDC_WANT_IEC_60559_ATTRIBS_EXT__
# define __STDC_WANT_IEC_60559_ATTRIBS_EXT__ 1
#endif
/* Enable extensions specified by ISO/IEC TS 18661-1:2014.  */
#ifndef __STDC_WANT_IEC_60559_BFP_EXT__
# define __STDC_WANT_IEC_60559_BFP_EXT__ 1
#endif
/* Enable extensions specified by ISO/IEC TS 18661-2:2015.  */
#ifndef __STDC_WANT_IEC_60559_DFP_EXT__
# define __STDC_WANT_IEC_60559_DFP_EXT__ 1
#endif
/* Enable extensions specified by ISO/IEC TS 18661-4:2015.  */
#ifndef __STDC_WANT_IEC_60559_FUNCS_EXT__
# define __STDC_WANT_IEC_60559_FUNCS_EXT__ 1
#endif
/* Enable extensions specified by ISO/IEC TS 18661-3:2015.  */
#ifndef __STDC_WANT_IEC_60559_TYPES_EXT__
# define __STDC_WANT_IEC_60559_TYPES_EXT__ 1
#endif
/* Enable extensions specified by ISO/IEC TR 24731-2:2010.  */
#ifndef __STDC_WANT_LIB_EXT2__
# define __STDC_WANT_LIB_EXT2__ 1
#endif
/* Enable extensions specified by ISO/IEC 24747:2009.  */
#ifndef __STDC_WANT_MATH_SPEC_FUNCS__
# define __STDC_WANT_MATH_SPEC_FUNCS__ 1
#endif
/* Enable extensions on HP NonStop.  */
#ifndef _TANDEM_SOURCE
# define _TANDEM_SOURCE 1
#endif
/* Enable X/Open extensions.  Define to 500 only if necessary
   to make mbstate_t available.  */
#ifndef _XOPEN_SOURCE
/* # undef _XOPEN_SOURCE */
#endif

/* Version number of package */
#define VERSION "10.46"

/* Number of bits in a file offset, on hosts where this is settable. */
/* #undef _FILE_OFFSET_BITS */

/* Define for large files, on AIX-style hosts. */
/* #undef _LARGE_FILES */

/* Define to empty if `const' does not conform to ANSI C. */
/* #undef const */

/* Define to the type of a signed integer type of width exactly 64 bits if
   such a type exists and the standard includes do not define it. */
/* #undef int64_t */

/* Define to `unsigned int' if <sys/types.h> does not define. */
/* #undef size_t */

// -----------------------

//disable conversion different-size integer warnings
#pragma warning(disable: 4244)
#pragma warning(disable: 4267)

// -----------------------

//PCRE library code modifications made for the Au library have comment "//au".

// -----------------------

//PCRE project settings:

//Output dir (all config): bin\$(Platform)\$(Configuration)\
//Static lib, unicode.
//Preprocessor: ...;HAVE_CONFIG_H;PCRE2_CODE_UNIT_WIDTH=16
//Run-time lib: multithreaded
//Disable security checks
//Warning level 3

// -----------------------

//Exclude files moved to the `excluded` dir.



================================================
FILE: Libraries/PCRE/pcre2.h
================================================
/*************************************************
*       Perl-Compatible Regular Expressions      *
*************************************************/

/* This is the public header file for the PCRE library, second API, to be
#included by applications that call PCRE2 functions.

           Copyright (c) 2016-2024 University of Cambridge

-----------------------------------------------------------------------------
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

    * Redistributions of source code must retain the above copyright notice,
      this list of conditions and the following disclaimer.

    * Redistributions in binary form must reproduce the above copyright
      notice, this list of conditions and the following disclaimer in the
      documentation and/or other materials provided with the distribution.

    * Neither the name of the University of Cambridge nor the names of its
      contributors may be used to endorse or promote products derived from
      this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
-----------------------------------------------------------------------------
*/

#ifndef PCRE2_H_IDEMPOTENT_GUARD
#define PCRE2_H_IDEMPOTENT_GUARD

/* The current PCRE version information. */

#define PCRE2_MAJOR           10
#define PCRE2_MINOR           46
#define PCRE2_PRERELEASE      
#define PCRE2_DATE            2025-08-27

/* When an application links to a PCRE DLL in Windows, the symbols that are
imported have to be identified as such. When building PCRE2, the appropriate
export setting is defined in pcre2_internal.h, which includes this file. So we
don't change existing definitions of PCRE2_EXP_DECL. */

#if defined(_WIN32) && !defined(PCRE2_STATIC)
#  ifndef PCRE2_EXP_DECL
#    define PCRE2_EXP_DECL  extern __declspec(dllimport)
#  endif
#endif

/* By default, we use the standard "extern" declarations. */

#ifndef PCRE2_EXP_DECL
#  ifdef __cplusplus
#    define PCRE2_EXP_DECL  extern "C"
#  else
#    define PCRE2_EXP_DECL  extern
#  endif
#endif

/* When compiling with the MSVC compiler, it is sometimes necessary to include
a "calling convention" before exported function names. (This is secondhand
information; I know nothing about MSVC myself). For example, something like

  void __cdecl function(....)

might be needed. In order so make this easy, all the exported functions have
PCRE2_CALL_CONVENTION just before their names. It is rarely needed; if not
set, we ensure here that it has no effect. */

#ifndef PCRE2_CALL_CONVENTION
#define PCRE2_CALL_CONVENTION
#endif

/* Have to include limits.h, stdlib.h, and inttypes.h to ensure that size_t and
uint8_t, UCHAR_MAX, etc are defined. Some systems that do have inttypes.h do
not have stdint.h, which is why we use inttypes.h, which according to the C
standard is a superset of stdint.h. If inttypes.h is not available the build
will break and the relevant values must be provided by some other means. */

#include <limits.h>
#include <stdlib.h>
#include <inttypes.h>

/* Allow for C++ users compiling this directly. */

#ifdef __cplusplus
extern "C" {
#endif

/* The following option bits can be passed to pcre2_compile(), pcre2_match(),
or pcre2_dfa_match(). PCRE2_NO_UTF_CHECK affects only the function to which it
is passed. Put these bits at the most significant end of the options word so
others can be added next to them */

#define PCRE2_ANCHORED            0x80000000u
#define PCRE2_NO_UTF_CHECK        0x40000000u
#define PCRE2_ENDANCHORED         0x20000000u

/* The following option bits can be passed only to pcre2_compile(). However,
they may affect compilation, JIT compilation, and/or interpretive execution.
The following tags indicate which:

C   alters what is compiled by pcre2_compile()
J   alters what is compiled by pcre2_jit_compile()
M   is inspected during pcre2_match() execution
D   is inspected during pcre2_dfa_match() execution
*/

#define PCRE2_ALLOW_EMPTY_CLASS   0x00000001u  /* C       */
#define PCRE2_ALT_BSUX            0x00000002u  /* C       */
#define PCRE2_AUTO_CALLOUT        0x00000004u  /* C       */
#define PCRE2_CASELESS            0x00000008u  /* C       */
#define PCRE2_DOLLAR_ENDONLY      0x00000010u  /*   J M D */
#define PCRE2_DOTALL              0x00000020u  /* C       */
#define PCRE2_DUPNAMES            0x00000040u  /* C       */
#define PCRE2_EXTENDED            0x00000080u  /* C       */
#define PCRE2_FIRSTLINE           0x00000100u  /*   J M D */
#define PCRE2_MATCH_UNSET_BACKREF 0x00000200u  /* C J M   */
#define PCRE2_MULTILINE           0x00000400u  /* C       */
#define PCRE2_NEVER_UCP           0x00000800u  /* C       */
#define PCRE2_NEVER_UTF           0x00001000u  /* C       */
#define PCRE2_NO_AUTO_CAPTURE     0x00002000u  /* C       */
#define PCRE2_NO_AUTO_POSSESS     0x00004000u  /* C       */
#define PCRE2_NO_DOTSTAR_ANCHOR   0x00008000u  /* C       */
#define PCRE2_NO_START_OPTIMIZE   0x00010000u  /*   J M D */
#define PCRE2_UCP                 0x00020000u  /* C J M D */
#define PCRE2_UNGREEDY            0x00040000u  /* C       */
#define PCRE2_UTF                 0x00080000u  /* C J M D */
#define PCRE2_NEVER_BACKSLASH_C   0x00100000u  /* C       */
#define PCRE2_ALT_CIRCUMFLEX      0x00200000u  /*   J M D */
#define PCRE2_ALT_VERBNAMES       0x00400000u  /* C       */
#define PCRE2_USE_OFFSET_LIMIT    0x00800000u  /*   J M D */
#define PCRE2_EXTENDED_MORE       0x01000000u  /* C       */
#define PCRE2_LITERAL             0x02000000u  /* C       */
#define PCRE2_MATCH_INVALID_UTF   0x04000000u  /*   J M D */
#define PCRE2_ALT_EXTENDED_CLASS  0x08000000u  /* C       */

/* An additional compile options word is available in the compile context. */

#define PCRE2_EXTRA_ALLOW_SURROGATE_ESCAPES  0x00000001u  /* C */
#define PCRE2_EXTRA_BAD_ESCAPE_IS_LITERAL    0x00000002u  /* C */
#define PCRE2_EXTRA_MATCH_WORD               0x00000004u  /* C */
#define PCRE2_EXTRA_MATCH_LINE               0x00000008u  /* C */
#define PCRE2_EXTRA_ESCAPED_CR_IS_LF         0x00000010u  /* C */
#define PCRE2_EXTRA_ALT_BSUX                 0x00000020u  /* C */
#define PCRE2_EXTRA_ALLOW_LOOKAROUND_BSK     0x00000040u  /* C */
#define PCRE2_EXTRA_CASELESS_RESTRICT        0x00000080u  /* C */
#define PCRE2_EXTRA_ASCII_BSD                0x00000100u  /* C */
#define PCRE2_EXTRA_ASCII_BSS                0x00000200u  /* C */
#define PCRE2_EXTRA_ASCII_BSW                0x00000400u  /* C */
#define PCRE2_EXTRA_ASCII_POSIX              0x00000800u  /* C */
#define PCRE2_EXTRA_ASCII_DIGIT              0x00001000u  /* C */
#define PCRE2_EXTRA_PYTHON_OCTAL             0x00002000u  /* C */
#define PCRE2_EXTRA_NO_BS0                   0x00004000u  /* C */
#define PCRE2_EXTRA_NEVER_CALLOUT            0x00008000u  /* C */
#define PCRE2_EXTRA_TURKISH_CASING           0x00010000u  /* C */

/* These are for pcre2_jit_compile(). */

#define PCRE2_JIT_COMPLETE        0x00000001u  /* For full matching */
#define PCRE2_JIT_PARTIAL_SOFT    0x00000002u
#define PCRE2_JIT_PARTIAL_HARD    0x00000004u
#define PCRE2_JIT_INVALID_UTF     0x00000100u
#define PCRE2_JIT_TEST_ALLOC      0x00000200u

/* These are for pcre2_match(), pcre2_dfa_match(), pcre2_jit_match(), and
pcre2_substitute(). Some are allowed only for one of the functions, and in
these cases it is noted below. Note that PCRE2_ANCHORED, PCRE2_ENDANCHORED and
PCRE2_NO_UTF_CHECK can also be passed to these functions (though
pcre2_jit_match() ignores the latter since it bypasses all sanity checks). */

#define PCRE2_NOTBOL                      0x00000001u
#define PCRE2_NOTEOL                      0x00000002u
#define PCRE2_NOTEMPTY                    0x00000004u  /* ) These two must be kept */
#define PCRE2_NOTEMPTY_ATSTART            0x00000008u  /* ) adjacent to each other. */
#define PCRE2_PARTIAL_SOFT                0x00000010u
#define PCRE2_PARTIAL_HARD                0x00000020u
#define PCRE2_DFA_RESTART                 0x00000040u  /* pcre2_dfa_match() only */
#define PCRE2_DFA_SHORTEST                0x00000080u  /* pcre2_dfa_match() only */
#define PCRE2_SUBSTITUTE_GLOBAL           0x00000100u  /* pcre2_substitute() only */
#define PCRE2_SUBSTITUTE_EXTENDED         0x00000200u  /* pcre2_substitute() only */
#define PCRE2_SUBSTITUTE_UNSET_EMPTY      0x00000400u  /* pcre2_substitute() only */
#define PCRE2_SUBSTITUTE_UNKNOWN_UNSET    0x00000800u  /* pcre2_substitute() only */
#define PCRE2_SUBSTITUTE_OVERFLOW_LENGTH  0x00001000u  /* pcre2_substitute() only */
#define PCRE2_NO_JIT                      0x00002000u  /* not for pcre2_dfa_match() */
#define PCRE2_COPY_MATCHED_SUBJECT        0x00004000u
#define PCRE2_SUBSTITUTE_LITERAL          0x00008000u  /* pcre2_substitute() only */
#define PCRE2_SUBSTITUTE_MATCHED          0x00010000u  /* pcre2_substitute() only */
#define PCRE2_SUBSTITUTE_REPLACEMENT_ONLY 0x00020000u  /* pcre2_substitute() only */
#define PCRE2_DISABLE_RECURSELOOP_CHECK   0x00040000u  /* not for pcre2_dfa_match() or pcre2_jit_match() */

/* Options for pcre2_pattern_convert(). */

#define PCRE2_CONVERT_UTF                    0x00000001u
#define PCRE2_CONVERT_NO_UTF_CHECK           0x00000002u
#define PCRE2_CONVERT_POSIX_BASIC            0x00000004u
#define PCRE2_CONVERT_POSIX_EXTENDED         0x00000008u
#define PCRE2_CONVERT_GLOB                   0x00000010u
#define PCRE2_CONVERT_GLOB_NO_WILD_SEPARATOR 0x00000030u
#define PCRE2_CONVERT_GLOB_NO_STARSTAR       0x00000050u

/* Newline and \R settings, for use in compile contexts. The newline values
must be kept in step with values set in config.h and both sets must all be
greater than zero. */

#define PCRE2_NEWLINE_CR          1
#define PCRE2_NEWLINE_LF          2
#define PCRE2_NEWLINE_CRLF        3
#define PCRE2_NEWLINE_ANY         4
#define PCRE2_NEWLINE_ANYCRLF     5
#define PCRE2_NEWLINE_NUL         6

#define PCRE2_BSR_UNICODE         1
#define PCRE2_BSR_ANYCRLF         2

/* Error codes for pcre2_compile(). Some of these are also used by
pcre2_pattern_convert(). */

#define PCRE2_ERROR_END_BACKSLASH                  101
#define PCRE2_ERROR_END_BACKSLASH_C                102
#define PCRE2_ERROR_UNKNOWN_ESCAPE                 103
#define PCRE2_ERROR_QUANTIFIER_OUT_OF_ORDER        104
#define PCRE2_ERROR_QUANTIFIER_TOO_BIG             105
#define PCRE2_ERROR_MISSING_SQUARE_BRACKET         106
#define PCRE2_ERROR_ESCAPE_INVALID_IN_CLASS        107
#define PCRE2_ERROR_CLASS_RANGE_ORDER              108
#define PCRE2_ERROR_QUANTIFIER_INVALID             109
#define PCRE2_ERROR_INTERNAL_UNEXPECTED_REPEAT     110
#define PCRE2_ERROR_INVALID_AFTER_PARENS_QUERY     111
#define PCRE2_ERROR_POSIX_CLASS_NOT_IN_CLASS       112
#define PCRE2_ERROR_POSIX_NO_SUPPORT_COLLATING     113
#define PCRE2_ERROR_MISSING_CLOSING_PARENTHESIS    114
#define PCRE2_ERROR_BAD_SUBPATTERN_REFERENCE       115
#define PCRE2_ERROR_NULL_PATTERN                   116
#define PCRE2_ERROR_BAD_OPTIONS                    117
#define PCRE2_ERROR_MISSING_COMMENT_CLOSING        118
#define PCRE2_ERROR_PARENTHESES_NEST_TOO_DEEP      119
#define PCRE2_ERROR_PATTERN_TOO_LARGE              120
#define PCRE2_ERROR_HEAP_FAILED                    121
#define PCRE2_ERROR_UNMATCHED_CLOSING_PARENTHESIS  122
#define PCRE2_ERROR_INTERNAL_CODE_OVERFLOW         123
#define PCRE2_ERROR_MISSING_CONDITION_CLOSING      124
#define PCRE2_ERROR_LOOKBEHIND_NOT_FIXED_LENGTH    125
#define PCRE2_ERROR_ZERO_RELATIVE_REFERENCE        126
#define PCRE2_ERROR_TOO_MANY_CONDITION_BRANCHES    127
#define PCRE2_ERROR_CONDITION_ASSERTION_EXPECTED   128
#define PCRE2_ERROR_BAD_RELATIVE_REFERENCE         129
#define PCRE2_ERROR_UNKNOWN_POSIX_CLASS            130
#define PCRE2_ERROR_INTERNAL_STUDY_ERROR           131
#define PCRE2_ERROR_UNICODE_NOT_SUPPORTED          132
#define PCRE2_ERROR_PARENTHESES_STACK_CHECK        133
#define PCRE2_ERROR_CODE_POINT_TOO_BIG             134
#define PCRE2_ERROR_LOOKBEHIND_TOO_COMPLICATED     135
#define PCRE2_ERROR_LOOKBEHIND_INVALID_BACKSLASH_C 136
#define PCRE2_ERROR_UNSUPPORTED_ESCAPE_SEQUENCE    137
#define PCRE2_ERROR_CALLOUT_NUMBER_TOO_BIG         138
#define PCRE2_ERROR_MISSING_CALLOUT_CLOSING        139
#define PCRE2_ERROR_ESCAPE_INVALID_IN_VERB         140
#define PCRE2_ERROR_UNRECOGNIZED_AFTER_QUERY_P     141
#define PCRE2_ERROR_MISSING_NAME_TERMINATOR        142
#define PCRE2_ERROR_DUPLICATE_SUBPATTERN_NAME      143
#define PCRE2_ERROR_INVALID_SUBPATTERN_NAME        144
#define PCRE2_ERROR_UNICODE_PROPERTIES_UNAVAILABLE 145
#define PCRE2_ERROR_MALFORMED_UNICODE_PROPERTY     146
#define PCRE2_ERROR_UNKNOWN_UNICODE_PROPERTY       147
#define PCRE2_ERROR_SUBPATTERN_NAME_TOO_LONG       148
#define PCRE2_ERROR_TOO_MANY_NAMED_SUBPATTERNS     149
#define PCRE2_ERROR_CLASS_INVALID_RANGE            150
#define PCRE2_ERROR_OCTAL_BYTE_TOO_BIG             151
#define PCRE2_ERROR_INTERNAL_OVERRAN_WORKSPACE     152
#define PCRE2_ERROR_INTERNAL_MISSING_SUBPATTERN    153
#define PCRE2_ERROR_DEFINE_TOO_MANY_BRANCHES       154
#define PCRE2_ERROR_BACKSLASH_O_MISSING_BRACE      155
#define PCRE2_ERROR_INTERNAL_UNKNOWN_NEWLINE       156
#define PCRE2_ERROR_BACKSLASH_G_SYNTAX             157
#define PCRE2_ERROR_PARENS_QUERY_R_MISSING_CLOSING 158
/* Error 159 is obsolete and should now never occur */
#define PCRE2_ERROR_VERB_ARGUMENT_NOT_ALLOWED      159
#define PCRE2_ERROR_VERB_UNKNOWN                   160
#define PCRE2_ERROR_SUBPATTERN_NUMBER_TOO_BIG      161
#define PCRE2_ERROR_SUBPATTERN_NAME_EXPECTED       162
#define PCRE2_ERROR_INTERNAL_PARSED_OVERFLOW       163
#define PCRE2_ERROR_INVALID_OCTAL                  164
#define PCRE2_ERROR_SUBPATTERN_NAMES_MISMATCH      165
#define PCRE2_ERROR_MARK_MISSING_ARGUMENT          166
#define PCRE2_ERROR_INVALID_HEXADECIMAL            167
#define PCRE2_ERROR_BACKSLASH_C_SYNTAX             168
#define PCRE2_ERROR_BACKSLASH_K_SYNTAX             169
#define PCRE2_ERROR_INTERNAL_BAD_CODE_LOOKBEHINDS  170
#define PCRE2_ERROR_BACKSLASH_N_IN_CLASS           171
#define PCRE2_ERROR_CALLOUT_STRING_TOO_LONG        172
#define PCRE2_ERROR_UNICODE_DISALLOWED_CODE_POINT  173
#define PCRE2_ERROR_UTF_IS_DISABLED                174
#define PCRE2_ERROR_UCP_IS_DISABLED                175
#define PCRE2_ERROR_VERB_NAME_TOO_LONG             176
#define PCRE2_ERROR_BACKSLASH_U_CODE_POINT_TOO_BIG 177
#define PCRE2_ERROR_MISSING_OCTAL_OR_HEX_DIGITS    178
#define PCRE2_ERROR_VERSION_CONDITION_SYNTAX       179
#define PCRE2_ERROR_INTERNAL_BAD_CODE_AUTO_POSSESS 180
#define PCRE2_ERROR_CALLOUT_NO_STRING_DELIMITER    181
#define PCRE2_ERROR_CALLOUT_BAD_STRING_DELIMITER   182
#define PCRE2_ERROR_BACKSLASH_C_CALLER_DISABLED    183
#define PCRE2_ERROR_QUERY_BARJX_NEST_TOO_DEEP      184
#define PCRE2_ERROR_BACKSLASH_C_LIBRARY_DISABLED   185
#define PCRE2_ERROR_PATTERN_TOO_COMPLICATED        186
#define PCRE2_ERROR_LOOKBEHIND_TOO_LONG            187
#define PCRE2_ERROR_PATTERN_STRING_TOO_LONG        188
#define PCRE2_ERROR_INTERNAL_BAD_CODE              189
#define PCRE2_ERROR_INTERNAL_BAD_CODE_IN_SKIP      190
#define PCRE2_ERROR_NO_SURROGATES_IN_UTF16         191
#define PCRE2_ERROR_BAD_LITERAL_OPTIONS            192
#define PCRE2_ERROR_SUPPORTED_ONLY_IN_UNICODE      193
#define PCRE2_ERROR_INVALID_HYPHEN_IN_OPTIONS      194
#define PCRE2_ERROR_ALPHA_ASSERTION_UNKNOWN        195
#define PCRE2_ERROR_SCRIPT_RUN_NOT_AVAILABLE       196
#define PCRE2_ERROR_TOO_MANY_CAPTURES              197
#define PCRE2_ERROR_MISSING_OCTAL_DIGIT            198
#define PCRE2_ERROR_BACKSLASH_K_IN_LOOKAROUND      199
#define PCRE2_ERROR_MAX_VAR_LOOKBEHIND_EXCEEDED    200
#define PCRE2_ERROR_PATTERN_COMPILED_SIZE_TOO_BIG  201
#define PCRE2_ERROR_OVERSIZE_PYTHON_OCTAL          202
#define PCRE2_ERROR_CALLOUT_CALLER_DISABLED        203
#define PCRE2_ERROR_EXTRA_CASING_REQUIRES_UNICODE  204
#define PCRE2_ERROR_TURKISH_CASING_REQUIRES_UTF    205
#define PCRE2_ERROR_EXTRA_CASING_INCOMPATIBLE      206
#define PCRE2_ERROR_ECLASS_NEST_TOO_DEEP           207
#define PCRE2_ERROR_ECLASS_INVALID_OPERATOR        208
#define PCRE2_ERROR_ECLASS_UNEXPECTED_OPERATOR     209
#define PCRE2_ERROR_ECLASS_EXPECTED_OPERAND        210
#define PCRE2_ERROR_ECLASS_MIXED_OPERATORS         211
#define PCRE2_ERROR_ECLASS_HINT_SQUARE_BRACKET     212
#define PCRE2_ERROR_PERL_ECLASS_UNEXPECTED_EXPR    213
#define PCRE2_ERROR_PERL_ECLASS_EMPTY_EXPR         214
#define PCRE2_ERROR_PERL_ECLASS_MISSING_CLOSE      215
#define PCRE2_ERROR_PERL_ECLASS_UNEXPECTED_CHAR    216

/* "Expected" matching error codes: no match and partial match. */

#define PCRE2_ERROR_NOMATCH          (-1)
#define PCRE2_ERROR_PARTIAL          (-2)

/* Error codes for UTF-8 validity checks */

#define PCRE2_ERROR_UTF8_ERR1        (-3)
#define PCRE2_ERROR_UTF8_ERR2        (-4)
#define PCRE2_ERROR_UTF8_ERR3        (-5)
#define PCRE2_ERROR_UTF8_ERR4        (-6)
#define PCRE2_ERROR_UTF8_ERR5        (-7)
#define PCRE2_ERROR_UTF8_ERR6        (-8)
#define PCRE2_ERROR_UTF8_ERR7        (-9)
#define PCRE2_ERROR_UTF8_ERR8       (-10)
#define PCRE2_ERROR_UTF8_ERR9       (-11)
#define PCRE2_ERROR_UTF8_ERR10      (-12)
#define PCRE2_ERROR_UTF8_ERR11      (-13)
#define PCRE2_ERROR_UTF8_ERR12      (-14)
#define PCRE2_ERROR_UTF8_ERR13      (-15)
#define PCRE2_ERROR_UTF8_ERR14      (-16)
#define PCRE2_ERROR_UTF8_ERR15      (-17)
#define PCRE2_ERROR_UTF8_ERR16      (-18)
#define PCRE2_ERROR_UTF8_ERR17      (-19)
#define PCRE2_ERROR_UTF8_ERR18      (-20)
#define PCRE2_ERROR_UTF8_ERR19      (-21)
#define PCRE2_ERROR_UTF8_ERR20      (-22)
#define PCRE2_ERROR_UTF8_ERR21      (-23)

/* Error codes for UTF-16 validity checks */

#define PCRE2_ERROR_UTF16_ERR1      (-24)
#define PCRE2_ERROR_UTF16_ERR2      (-25)
#define PCRE2_ERROR_UTF16_ERR3      (-26)

/* Error codes for UTF-32 validity checks */

#define PCRE2_ERROR_UTF32_ERR1      (-27)
#define PCRE2_ERROR_UTF32_ERR2      (-28)

/* Miscellaneous error codes for pcre2[_dfa]_match(), substring extraction
functions, context functions, and serializing functions. They are in numerical
order. Originally they were in alphabetical order too, but now that PCRE2 is
released, the numbers must not be changed. */

#define PCRE2_ERROR_BADDATA           (-29)
#define PCRE2_ERROR_MIXEDTABLES       (-30)  /* Name was changed */
#define PCRE2_ERROR_BADMAGIC          (-31)
#define PCRE2_ERROR_BADMODE           (-32)
#define PCRE2_ERROR_BADOFFSET         (-33)
#define PCRE2_ERROR_BADOPTION         (-34)
#define PCRE2_ERROR_BADREPLACEMENT    (-35)
#define PCRE2_ERROR_BADUTFOFFSET      (-36)
#define PCRE2_ERROR_CALLOUT           (-37)  /* Never used by PCRE2 itself */
#define PCRE2_ERROR_DFA_BADRESTART    (-38)
#define PCRE2_ERROR_DFA_RECURSE       (-39)
#define PCRE2_ERROR_DFA_UCOND         (-40)
#define PCRE2_ERROR_DFA_UFUNC         (-41)
#define PCRE2_ERROR_DFA_UITEM         (-42)
#define PCRE2_ERROR_DFA_WSSIZE        (-43)
#define PCRE2_ERROR_INTERNAL          (-44)
#define PCRE2_ERROR_JIT_BADOPTION     (-45)
#define PCRE2_ERROR_JIT_STACKLIMIT    (-46)
#define PCRE2_ERROR_MATCHLIMIT        (-47)
#define PCRE2_ERROR_NOMEMORY          (-48)
#define PCRE2_ERROR_NOSUBSTRING       (-49)
#define PCRE2_ERROR_NOUNIQUESUBSTRING (-50)
#define PCRE2_ERROR_NULL              (-51)
#define PCRE2_ERROR_RECURSELOOP       (-52)
#define PCRE2_ERROR_DEPTHLIMIT        (-53)
#define PCRE2_ERROR_RECURSIONLIMIT    (-53)  /* Obsolete synonym */
#define PCRE2_ERROR_UNAVAILABLE       (-54)
#define PCRE2_ERROR_UNSET             (-55)
#define PCRE2_ERROR_BADOFFSETLIMIT    (-56)
#define PCRE2_ERROR_BADREPESCAPE      (-57)
#define PCRE2_ERROR_REPMISSINGBRACE   (-58)
#define PCRE2_ERROR_BADSUBSTITUTION   (-59)
#define PCRE2_ERROR_BADSUBSPATTERN    (-60)
#define PCRE2_ERROR_TOOMANYREPLACE    (-61)
#define PCRE2_ERROR_BADSERIALIZEDDATA (-62)
#define PCRE2_ERROR_HEAPLIMIT         (-63)
#define PCRE2_ERROR_CONVERT_SYNTAX    (-64)
#define PCRE2_ERROR_INTERNAL_DUPMATCH (-65)
#define PCRE2_ERROR_DFA_UINVALID_UTF  (-66)
#define PCRE2_ERROR_INVALIDOFFSET     (-67)
#define PCRE2_ERROR_JIT_UNSUPPORTED   (-68)
#define PCRE2_ERROR_REPLACECASE       (-69)
#define PCRE2_ERROR_TOOLARGEREPLACE   (-70)


/* Request types for pcre2_pattern_info() */

#define PCRE2_INFO_ALLOPTIONS            0
#define PCRE2_INFO_ARGOPTIONS            1
#define PCRE2_INFO_BACKREFMAX            2
#define PCRE2_INFO_BSR                   3
#define PCRE2_INFO_CAPTURECOUNT          4
#define PCRE2_INFO_FIRSTCODEUNIT         5
#define PCRE2_INFO_FIRSTCODETYPE         6
#define PCRE2_INFO_FIRSTBITMAP           7
#define PCRE2_INFO_HASCRORLF             8
#define PCRE2_INFO_JCHANGED              9
#define PCRE2_INFO_JITSIZE              10
#define PCRE2_INFO_LASTCODEUNIT         11
#define PCRE2_INFO_LASTCODETYPE         12
#define PCRE2_INFO_MATCHEMPTY           13
#define PCRE2_INFO_MATCHLIMIT           14
#define PCRE2_INFO_MAXLOOKBEHIND        15
#define PCRE2_INFO_MINLENGTH            16
#define PCRE2_INFO_NAMECOUNT            17
#define PCRE2_INFO_NAMEENTRYSIZE        18
#define PCRE2_INFO_NAMETABLE            19
#define PCRE2_INFO_NEWLINE              20
#define PCRE2_INFO_DEPTHLIMIT           21
#define PCRE2_INFO_RECURSIONLIMIT       21  /* Obsolete synonym */
#define PCRE2_INFO_SIZE                 22
#define PCRE2_INFO_HASBACKSLASHC        23
#define PCRE2_INFO_FRAMESIZE            24
#define PCRE2_INFO_HEAPLIMIT            25
#define PCRE2_INFO_EXTRAOPTIONS         26

/* Request types for pcre2_config(). */

#define PCRE2_CONFIG_BSR                     0
#define PCRE2_CONFIG_JIT                     1
#define PCRE2_CONFIG_JITTARGET               2
#define PCRE2_CONFIG_LINKSIZE                3
#define PCRE2_CONFIG_MATCHLIMIT              4
#define PCRE2_CONFIG_NEWLINE                 5
#define PCRE2_CONFIG_PARENSLIMIT             6
#define PCRE2_CONFIG_DEPTHLIMIT              7
#define PCRE2_CONFIG_RECURSIONLIMIT          7  /* Obsolete synonym */
#define PCRE2_CONFIG_STACKRECURSE            8  /* Obsolete */
#define PCRE2_CONFIG_UNICODE                 9
#define PCRE2_CONFIG_UNICODE_VERSION        10
#define PCRE2_CONFIG_VERSION                11
#define PCRE2_CONFIG_HEAPLIMIT              12
#define PCRE2_CONFIG_NEVER_BACKSLASH_C      13
#define PCRE2_CONFIG_COMPILED_WIDTHS        14
#define PCRE2_CONFIG_TABLES_LENGTH          15

/* Optimization directives for pcre2_set_optimize().
For binary compatibility, only add to this list; do not renumber. */

#define PCRE2_OPTIMIZATION_NONE    0
#define PCRE2_OPTIMIZATION_FULL    1

#define PCRE2_AUTO_POSSESS         64
#define PCRE2_AUTO_POSSESS_OFF     65
#define PCRE2_DOTSTAR_ANCHOR       66
#define PCRE2_DOTSTAR_ANCHOR_OFF   67
#define PCRE2_START_OPTIMIZE       68
#define PCRE2_START_OPTIMIZE_OFF   69

/* Types used in pcre2_set_substitute_case_callout().

PCRE2_SUBSTITUTE_CASE_LOWER and PCRE2_SUBSTITUTE_CASE_UPPER are passed to the
callout to indicate that the case of the entire callout input should be
case-transformed. PCRE2_SUBSTITUTE_CASE_TITLE_FIRST is passed to indicate that
only the first character or glyph should be transformed to Unicode titlecase,
and the rest to lowercase. */

#define PCRE2_SUBSTITUTE_CASE_LOWER        1
#define PCRE2_SUBSTITUTE_CASE_UPPER        2
#define PCRE2_SUBSTITUTE_CASE_TITLE_FIRST  3

/* Types for code units in patterns and subject strings. */

typedef uint8_t  PCRE2_UCHAR8;

//au:
//typedef uint16_t PCRE2_UCHAR16;
typedef wchar_t PCRE2_UCHAR16;

typedef uint32_t PCRE2_UCHAR32;

typedef const PCRE2_UCHAR8  *PCRE2_SPTR8;
typedef const PCRE2_UCHAR16 *PCRE2_SPTR16;
typedef const PCRE2_UCHAR32 *PCRE2_SPTR32;

/* The PCRE2_SIZE type is used for all string lengths and offsets in PCRE2,
including pattern offsets for errors and subject offsets after a match. We
define special values to indicate zero-terminated strings and unset offsets in
the offset vector (ovector). */

#define PCRE2_SIZE            size_t
#define PCRE2_SIZE_MAX        SIZE_MAX
#define PCRE2_ZERO_TERMINATED (~(PCRE2_SIZE)0)
#define PCRE2_UNSET           (~(PCRE2_SIZE)0)

/* Generic types for opaque structures and JIT callback functions. These
declarations are defined in a macro that is expanded for each width later. */

#define PCRE2_TYPES_LIST \
struct pcre2_real_general_context; \
typedef struct pcre2_real_general_context pcre2_general_context; \
\
struct pcre2_real_compile_context; \
typedef struct pcre2_real_compile_context pcre2_compile_context; \
\
struct pcre2_real_match_context; \
typedef struct pcre2_real_match_context pcre2_match_context; \
\
struct pcre2_real_convert_context; \
typedef struct pcre2_real_convert_context pcre2_convert_context; \
\
struct pcre2_real_code; \
typedef struct pcre2_real_code pcre2_code; \
\
struct pcre2_real_match_data; \
typedef struct pcre2_real_match_data pcre2_match_data; \
\
struct pcre2_real_jit_stack; \
typedef struct pcre2_real_jit_stack pcre2_jit_stack; \
\
typedef pcre2_jit_stack *(*pcre2_jit_callback)(void *);


/* The structures for passing out data via callout functions. We use structures
so that new fields can be added on the end in future versions, without changing
the API of the function, thereby allowing old clients to work without
modification. Define the generic versions in a macro; the width-specific
versions are generated from this macro below. */

/* Flags for the callout_flags field. These are cleared after a callout. */

#define PCRE2_CALLOUT_STARTMATCH    0x00000001u  /* Set for each bumpalong */
#define PCRE2_CALLOUT_BACKTRACK     0x00000002u  /* Set after a backtrack */

#define PCRE2_STRUCTURE_LIST \
typedef struct pcre2_callout_block { \
  uint32_t      version;           /* Identifies version of block */ \
  /* ------------------------ Version 0 ------------------------------- */ \
  uint32_t      callout_number;    /* Number compiled into pattern */ \
  uint32_t      capture_top;       /* Max current capture */ \
  uint32_t      capture_last;      /* Most recently closed capture */ \
  PCRE2_SIZE   *offset_vector;     /* The offset vector */ \
  PCRE2_SPTR    mark;              /* Pointer to current mark or NULL */ \
  PCRE2_SPTR    subject;           /* The subject being matched */ \
  PCRE2_SIZE    subject_length;    /* The length of the subject */ \
  PCRE2_SIZE    start_match;       /* Offset to start of this match attempt */ \
  PCRE2_SIZE    current_position;  /* Where we currently are in the subject */ \
  PCRE2_SIZE    pattern_position;  /* Offset to next item in the pattern */ \
  PCRE2_SIZE    next_item_length;  /* Length of next item in the pattern */ \
  /* ------------------- Added for Version 1 -------------------------- */ \
  PCRE2_SIZE    callout_string_offset; /* Offset to string within pattern */ \
  PCRE2_SIZE    callout_string_length; /* Length of string compiled into pattern */ \
  PCRE2_SPTR    callout_string;    /* String compiled into pattern */ \
  /* ------------------- Added for Version 2 -------------------------- */ \
  uint32_t      callout_flags;     /* See above for list */ \
  /* ------------------------------------------------------------------ */ \
} pcre2_callout_block; \
\
typedef struct pcre2_callout_enumerate_block { \
  uint32_t      version;           /* Identifies version of block */ \
  /* ------------------------ Version 0 ------------------------------- */ \
  PCRE2_SIZE    pattern_position;  /* Offset to next item in the pattern */ \
  PCRE2_SIZE    next_item_length;  /* Length of next item in the pattern */ \
  uint32_t      callout_number;    /* Number compiled into pattern */ \
  PCRE2_SIZE    callout_string_offset; /* Offset to string within pattern */ \
  PCRE2_SIZE    callout_string_length; /* Length of string compiled into pattern */ \
  PCRE2_SPTR    callout_string;    /* String compiled into pattern */ \
  /* ------------------------------------------------------------------ */ \
} pcre2_callout_enumerate_block; \
\
typedef struct pcre2_substitute_callout_block { \
  uint32_t      version;           /* Identifies version of block */ \
  /* ------------------------ Version 0 ------------------------------- */ \
  PCRE2_SPTR    input;             /* Pointer to input subject string */ \
  PCRE2_SPTR    output;            /* Pointer to output buffer */ \
  PCRE2_SIZE    output_offsets[2]; /* Changed portion of the output */ \
  PCRE2_SIZE   *ovector;           /* Pointer to current ovector */ \
  uint32_t      oveccount;         /* Count of pairs set in ovector */ \
  uint32_t      subscount;         /* Substitution number */ \
  /* ------------------------------------------------------------------ */ \
} pcre2_substitute_callout_block;


/* List the generic forms of all other functions in macros, which will be
expanded for each width below. Start with functions that give general
information. */

#define PCRE2_GENERAL_INFO_FUNCTIONS \
PCRE2_EXP_DECL int PCRE2_CALL_CONVENTION pcre2_config(uint32_t, void *);


/* Functions for manipulating contexts. */

#define PCRE2_GENERAL_CONTEXT_FUNCTIONS \
PCRE2_EXP_DECL pcre2_general_context *PCRE2_CALL_CONVENTION \
  pcre2_general_context_copy(pcre2_general_context *); \
PCRE2_EXP_DECL pcre2_general_context *PCRE2_CALL_CONVENTION \
  pcre2_general_context_create(void *(*)(size_t, void *), \
    void (*)(void *, void *), void *); \
PCRE2_EXP_DECL void PCRE2_CALL_CONVENTION \
  pcre2_general_context_free(pcre2_general_context *);

#define PCRE2_COMPILE_CONTEXT_FUNCTIONS \
PCRE2_EXP_DECL pcre2_compile_context *PCRE2_CALL_CONVENTION \
  pcre2_compile_context_copy(pcre2_compile_context *); \
PCRE2_EXP_DECL pcre2_compile_context *PCRE2_CALL_CONVENTION \
  pcre2_compile_context_create(pcre2_general_context *);\
PCRE2_EXP_DECL void PCRE2_CALL_CONVENTION \
  pcre2_compile_context_free(pcre2_compile_context *); \
PCRE2_EXP_DECL int PCRE2_CALL_CONVENTION \
  pcre2_set_bsr(pcre2_compile_context *, uint32_t); \
PCRE2_EXP_DECL int PCRE2_CALL_CONVENTION \
  pcre2_set_character_tables(pcre2_compile_context *, const uint8_t *); \
PCRE2_EXP_DECL int PCRE2_CALL_CONVENTION \
  pcre2_set_compile_extra_options(pcre2_compile_context *, uint32_t); \
PCRE2_EXP_DECL int PCRE2_CALL_CONVENTION \
  pcre2_set_max_pattern_length(pcre2_compile_context *, PCRE2_SIZE); \
PCRE2_EXP_DECL int PCRE2_CALL_CONVENTION \
  pcre2_set_max_pattern_compiled_length(pcre2_compile_context *, PCRE2_SIZE); \
PCRE2_EXP_DECL int PCRE2_CALL_CONVENTION \
  pcre2_set_max_varlookbehind(pcre2_compile_context *, uint32_t); \
PCRE2_EXP_DECL int PCRE2_CALL_CONVENTION \
  pcre2_set_newline(pcre2_compile_context *, uint32_t); \
PCRE2_EXP_DECL int PCRE2_CALL_CONVENTION \
  pcre2_set_parens_nest_limit(pcre2_compile_context *, uint32_t); \
PCRE2_EXP_DECL int PCRE2_CALL_CONVENTION \
  pcre2_set_compile_recursion_guard(pcre2_compile_context *, \
    int (*)(uint32_t, void *), void *); \
PCRE2_EXP_DECL int PCRE2_CALL_CONVENTION \
  pcre2_set_optimize(pcre2_compile_context *, uint32_t);

#define PCRE2_MATCH_CONTEXT_FUNCTIONS \
PCRE2_EXP_DECL pcre2_match_context *PCRE2_CALL_CONVENTION \
  pcre2_match_context_copy(pcre2_match_context *); \
PCRE2_EXP_DECL pcre2_match_context *PCRE2_CALL_CONVENTION \
  pcre2_match_context_create(pcre2_general_context *); \
PCRE2_EXP_DECL void PCRE2_CALL_CONVENTION \
  pcre2_match_context_free(pcre2_match_context *); \
PCRE2_EXP_DECL int PCRE2_CALL_CONVENTION \
  pcre2_set_callout(pcre2_match_context *, \
    int (*)(pcre2_callout_block *, void *), void *); \
PCRE2_EXP_DECL int PCRE2_CALL_CONVENTION \
  pcre2_set_substitute_callout(pcre2_match_context *, \
    int (*)(pcre2_substitute_callout_block *, void *), void *); \
PCRE2_EXP_DECL int PCRE2_CALL_CONVENTION \
  pcre2_set_substitute_case_callout(pcre2_match_context *, \
    PCRE2_SIZE (*)(PCRE2_SPTR, PCRE2_SIZE, PCRE2_UCHAR *, PCRE2_SIZE, int, \
                   void *), \
    void *); \
PCRE2_EXP_DECL int PCRE2_CALL_CONVENTION \
  pcre2_set_depth_limit(pcre2_match_context *, uint32_t); \
PCRE2_EXP_DECL int PCRE2_CALL_CONVENTION \
  pcre2_set_heap_limit(pcre2_match_context *, uint32_t); \
PCRE2_EXP_DECL int PCRE2_CALL_CONVENTION \
  pcre2_set_match_limit(pcre2_match_context *, uint32_t); \
PCRE2_EXP_DECL int PCRE2_CALL_CONVENTION \
  pcre2_set_offset_limit(pcre2_match_context *, PCRE2_SIZE); \
PCRE2_EXP_DECL int PCRE2_CALL_CONVENTION \
  pcre2_set_recursion_limit(pcre2_match_context *, uint32_t); \
PCRE2_EXP_DECL int PCRE2_CALL_CONVENTION \
  pcre2_set_recursion_memory_management(pcre2_match_context *, \
    void *(*)(size_t, void *), void (*)(void *, void *), void *);

#define PCRE2_CONVERT_CONTEXT_FUNCTIONS \
PCRE2_EXP_DECL pcre2_convert_context *PCRE2_CALL_CONVENTION \
  pcre2_convert_context_copy(pcre2_convert_context *); \
PCRE2_EXP_DECL pcre2_convert_context *PCRE2_CALL_CONVENTION \
  pcre2_convert_context_create(pcre2_general_context *); \
PCRE2_EXP_DECL void PCRE2_CALL_CONVENTION \
  pcre2_convert_context_free(pcre2_convert_context *); \
PCRE2_EXP_DECL int PCRE2_CALL_CONVENTION \
  pcre2_set_glob_escape(pcre2_convert_context *, uint32_t); \
PCRE2_EXP_DECL int PCRE2_CALL_CONVENTION \
  pcre2_set_glob_separator(pcre2_convert_context *, uint32_t);


/* Functions concerned with compiling a pattern to PCRE internal code. */

#define PCRE2_COMPILE_FUNCTIONS \
PCRE2_EXP_DECL pcre2_code *PCRE2_CALL_CONVENTION \
  pcre2_compile(PCRE2_SPTR, PCRE2_SIZE, uint32_t, int *, PCRE2_SIZE *, \
    pcre2_compile_context *); \
PCRE2_EXP_DECL void PCRE2_CALL_CONVENTION \
  pcre2_code_free(pcre2_code *); \
PCRE2_EXP_DECL pcre2_code *PCRE2_CALL_CONVENTION \
  pcre2_code_copy(const pcre2_code *); \
PCRE2_EXP_DECL pcre2_code *PCRE2_CALL_CONVENTION \
  pcre2_code_copy_with_tables(const pcre2_code *);


/* Functions that give information about a compiled pattern. */

#define PCRE2_PATTERN_INFO_FUNCTIONS \
PCRE2_EXP_DECL int PCRE2_CALL_CONVENTION \
  pcre2_pattern_info(const pcre2_code *, uint32_t, void *); \
PCRE2_EXP_DECL int PCRE2_CALL_CONVENTION \
  pcre2_callout_enumerate(const pcre2_code *, \
    int (*)(pcre2_callout_enumerate_block *, void *), void *);


/* Functions for running a match and inspecting the result. */

#define PCRE2_MATCH_FUNCTIONS \
PCRE2_EXP_DECL pcre2_match_data *PCRE2_CALL_CONVENTION \
  pcre2_match_data_create(uint32_t, pcre2_general_context *); \
PCRE2_EXP_DECL pcre2_match_data *PCRE2_CALL_CONVENTION \
  pcre2_match_data_create_from_pattern(const pcre2_code *, \
    pcre2_general_context *); \
PCRE2_EXP_DECL int PCRE2_CALL_CONVENTION \
  pcre2_dfa_match(const pcre2_code *, PCRE2_SPTR, PCRE2_SIZE, PCRE2_SIZE, \
    uint32_t, pcre2_match_data *, pcre2_match_context *, int *, PCRE2_SIZE); \
PCRE2_EXP_DECL int PCRE2_CALL_CONVENTION \
  pcre2_match(const pcre2_code *, PCRE2_SPTR, PCRE2_SIZE, PCRE2_SIZE, \
    uint32_t, pcre2_match_data *, pcre2_match_context *, int(*callout)(pcre2_callout_block *, void *)); \
PCRE2_EXP_DECL void PCRE2_CALL_CONVENTION \
  pcre2_match_data_free(pcre2_match_data *); \
PCRE2_EXP_DECL PCRE2_SPTR PCRE2_CALL_CONVENTION \
  pcre2_get_mark(pcre2_match_data *); \
PCRE2_EXP_DECL PCRE2_SIZE PCRE2_CALL_CONVENTION \
  pcre2_get_match_data_size(pcre2_match_data *); \
PCRE2_EXP_DECL PCRE2_SIZE PCRE2_CALL_CONVENTION \
  pcre2_get_match_data_heapframes_size(pcre2_match_data *); \
PCRE2_EXP_DECL uint32_t PCRE2_CALL_CONVENTION \
  pcre2_get_ovector_count(pcre2_match_data *); \
PCRE2_EXP_DECL PCRE2_SIZE *PCRE2_CALL_CONVENTION \
  pcre2_get_ovector_pointer(pcre2_match_data *); \
PCRE2_EXP_DECL PCRE2_SIZE PCRE2_CALL_CONVENTION \
  pcre2_get_startchar(pcre2_match_data *);

//au: added pcre2_match parameter: , int(*callout)(pcre2_callout_block *, void *)

/* Convenience functions for handling matched substrings. */

#define PCRE2_SUBSTRING_FUNCTIONS \
PCRE2_EXP_DECL int PCRE2_CALL_CONVENTION \
  pcre2_substring_copy_byname(pcre2_match_data *, PCRE2_SPTR, PCRE2_UCHAR *, \
    PCRE2_SIZE *); \
PCRE2_EXP_DECL int PCRE2_CALL_CONVENTION \
  pcre2_substring_copy_bynumber(pcre2_match_data *, uint32_t, PCRE2_UCHAR *, \
    PCRE2_SIZE *); \
PCRE2_EXP_DECL void PCRE2_CALL_CONVENTION \
  pcre2_substring_free(PCRE2_UCHAR *); \
PCRE2_EXP_DECL int PCRE2_CALL_CONVENTION \
  pcre2_substring_get_byname(pcre2_match_data *, PCRE2_SPTR, PCRE2_UCHAR **, \
    PCRE2_SIZE *); \
PCRE2_EXP_DECL int PCRE2_CALL_CONVENTION \
  pcre2_substring_get_bynumber(pcre2_match_data *, uint32_t, PCRE2_UCHAR **, \
    PCRE2_SIZE *); \
PCRE2_EXP_DECL int PCRE2_CALL_CONVENTION \
  pcre2_substring_length_byname(pcre2_match_data *, PCRE2_SPTR, PCRE2_SIZE *); \
PCRE2_EXP_DECL int PCRE2_CALL_CONVENTION \
  pcre2_substring_length_bynumber(pcre2_match_data *, uint32_t, PCRE2_SIZE *); \
PCRE2_EXP_DECL int PCRE2_CALL_CONVENTION \
  pcre2_substring_nametable_scan(const pcre2_code *, PCRE2_SPTR, PCRE2_SPTR *, \
    PCRE2_SPTR *); \
PCRE2_EXP_DECL int PCRE2_CALL_CONVENTION \
  pcre2_substring_number_from_name(const pcre2_code *, PCRE2_SPTR); \
PCRE2_EXP_DECL void PCRE2_CALL_CONVENTION \
  pcre2_substring_list_free(PCRE2_UCHAR **); \
PCRE2_EXP_DECL int PCRE2_CALL_CONVENTION \
  pcre2_substring_list_get(pcre2_match_data *, PCRE2_UCHAR ***, PCRE2_SIZE **);


/* Functions for serializing / deserializing compiled patterns. */

#define PCRE2_SERIALIZE_FUNCTIONS \
PCRE2_EXP_DECL int32_t PCRE2_CALL_CONVENTION \
  pcre2_serialize_encode(const pcre2_code **, int32_t, uint8_t **, \
    PCRE2_SIZE *, pcre2_general_context *); \
PCRE2_EXP_DECL int32_t PCRE2_CALL_CONVENTION \
  pcre2_serialize_decode(pcre2_code **, int32_t, const uint8_t *, \
    pcre2_general_context *); \
PCRE2_EXP_DECL int32_t PCRE2_CALL_CONVENTION \
  pcre2_serialize_get_number_of_codes(const uint8_t *); \
PCRE2_EXP_DECL void PCRE2_CALL_CONVENTION \
  pcre2_serialize_free(uint8_t *);


/* Convenience function for match + substitute. */

#define PCRE2_SUBSTITUTE_FUNCTION \
PCRE2_EXP_DECL int PCRE2_CALL_CONVENTION \
  pcre2_substitute(const pcre2_code *, PCRE2_SPTR, PCRE2_SIZE, PCRE2_SIZE, \
    uint32_t, pcre2_match_data *, pcre2_match_context *, PCRE2_SPTR, \
    PCRE2_SIZE, PCRE2_UCHAR *, PCRE2_SIZE *);


/* Functions for converting pattern source strings. */

#define PCRE2_CONVERT_FUNCTIONS \
PCRE2_EXP_DECL int PCRE2_CALL_CONVENTION \
  pcre2_pattern_convert(PCRE2_SPTR, PCRE2_SIZE, uint32_t, PCRE2_UCHAR **, \
    PCRE2_SIZE *, pcre2_convert_context *); \
PCRE2_EXP_DECL void PCRE2_CALL_CONVENTION \
  pcre2_converted_pattern_free(PCRE2_UCHAR *);


/* Functions for JIT processing */

#define PCRE2_JIT_FUNCTIONS \
PCRE2_EXP_DECL int PCRE2_CALL_CONVENTION \
  pcre2_jit_compile(pcre2_code *, uint32_t); \
PCRE2_EXP_DECL int PCRE2_CALL_CONVENTION \
  pcre2_jit_match(const pcre2_code *, PCRE2_SPTR, PCRE2_SIZE, PCRE2_SIZE, \
    uint32_t, pcre2_match_data *, pcre2_match_context *); \
PCRE2_EXP_DECL void PCRE2_CALL_CONVENTION \
  pcre2_jit_free_unused_memory(pcre2_general_context *); \
PCRE2_EXP_DECL pcre2_jit_stack *PCRE2_CALL_CONVENTION \
  pcre2_jit_stack_create(size_t, size_t, pcre2_general_context *); \
PCRE2_EXP_DECL void PCRE2_CALL_CONVENTION \
  pcre2_jit_stack_assign(pcre2_match_context *, pcre2_jit_callback, void *); \
PCRE2_EXP_DECL void PCRE2_CALL_CONVENTION \
  pcre2_jit_stack_free(pcre2_jit_stack *);


/* Other miscellaneous functions. */

#define PCRE2_OTHER_FUNCTIONS \
PCRE2_EXP_DECL int PCRE2_CALL_CONVENTION \
  pcre2_get_error_message(int, PCRE2_UCHAR *, PCRE2_SIZE); \
PCRE2_EXP_DECL const uint8_t *PCRE2_CALL_CONVENTION \
  pcre2_maketables(pcre2_general_context *); \
PCRE2_EXP_DECL void PCRE2_CALL_CONVENTION \
  pcre2_maketables_free(pcre2_general_context *, const uint8_t *);

/* Define macros that generate width-specific names from generic versions. The
three-level macro scheme is necessary to get the macros expanded when we want
them to be. First we get the width from PCRE2_LOCAL_WIDTH, which is used for
generating three versions of everything below. After that, PCRE2_SUFFIX will be
re-defined to use PCRE2_CODE_UNIT_WIDTH, for use when macros such as
pcre2_compile are called by application code. */

#define PCRE2_JOIN(a,b) a ## b
#define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b)
#define PCRE2_SUFFIX(a) PCRE2_GLUE(a,PCRE2_LOCAL_WIDTH)


/* Data types */

#define PCRE2_UCHAR                 PCRE2_SUFFIX(PCRE2_UCHAR)
#define PCRE2_SPTR                  PCRE2_SUFFIX(PCRE2_SPTR)

#define pcre2_code                  PCRE2_SUFFIX(pcre2_code_)
#define pcre2_jit_callback          PCRE2_SUFFIX(pcre2_jit_callback_)
#define pcre2_jit_stack             PCRE2_SUFFIX(pcre2_jit_stack_)

#define pcre2_real_code             PCRE2_SUFFIX(pcre2_real_code_)
#define pcre2_real_general_context  PCRE2_SUFFIX(pcre2_real_general_context_)
#define pcre2_real_compile_context  PCRE2_SUFFIX(pcre2_real_compile_context_)
#define pcre2_real_convert_context  PCRE2_SUFFIX(pcre2_real_convert_context_)
#define pcre2_real_match_context    PCRE2_SUFFIX(pcre2_real_match_context_)
#define pcre2_real_jit_stack        PCRE2_SUFFIX(pcre2_real_jit_stack_)
#define pcre2_real_match_data       PCRE2_SUFFIX(pcre2_real_match_data_)


/* Data blocks */

#define pcre2_callout_block            PCRE2_SUFFIX(pcre2_callout_block_)
#define pcre2_callout_enumerate_block  PCRE2_SUFFIX(pcre2_callout_enumerate_block_)
#define pcre2_substitute_callout_block PCRE2_SUFFIX(pcre2_substitute_callout_block_)
#define pcre2_general_context          PCRE2_SUFFIX(pcre2_general_context_)
#define pcre2_compile_context          PCRE2_SUFFIX(pcre2_compile_context_)
#define pcre2_convert_context          PCRE2_SUFFIX(pcre2_convert_context_)
#define pcre2_match_context            PCRE2_SUFFIX(pcre2_match_context_)
#define pcre2_match_data               PCRE2_SUFFIX(pcre2_match_data_)


/* Functions: the complete list in alphabetical order */

#define pcre2_callout_enumerate               PCRE2_SUFFIX(pcre2_callout_enumerate_)
#define pcre2_code_copy                       PCRE2_SUFFIX(pcre2_code_copy_)
#define pcre2_code_copy_with_tables           PCRE2_SUFFIX(pcre2_code_copy_with_tables_)
#define pcre2_code_free                       PCRE2_SUFFIX(pcre2_code_free_)
#define pcre2_compile                         PCRE2_SUFFIX(pcre2_compile_)
#define pcre2_compile_context_copy            PCRE2_SUFFIX(pcre2_compile_context_copy_)
#define pcre2_compile_context_create          PCRE2_SUFFIX(pcre2_compile_context_create_)
#define pcre2_compile_context_free            PCRE2_SUFFIX(pcre2_compile_context_free_)
#define pcre2_config                          PCRE2_SUFFIX(pcre2_config_)
#define pcre2_convert_context_copy            PCRE2_SUFFIX(pcre2_convert_context_copy_)
#define pcre2_convert_context_create          PCRE2_SUFFIX(pcre2_convert_context_create_)
#define pcre2_convert_context_free            PCRE2_SUFFIX(pcre2_convert_context_free_)
#define pcre2_converted_pattern_free          PCRE2_SUFFIX(pcre2_converted_pattern_free_)
#define pcre2_dfa_match                       PCRE2_SUFFIX(pcre2_dfa_match_)
#define pcre2_general_context_copy            PCRE2_SUFFIX(pcre2_general_context_copy_)
#define pcre2_general_context_create          PCRE2_SUFFIX(pcre2_general_context_create_)
#define pcre2_general_context_free            PCRE2_SUFFIX(pcre2_general_context_free_)
#define pcre2_get_error_message               PCRE2_SUFFIX(pcre2_get_error_message_)
#define pcre2_get_mark                        PCRE2_SUFFIX(pcre2_get_mark_)
#define pcre2_get_match_data_heapframes_size  PCRE2_SUFFIX(pcre2_get_match_data_heapframes_size_)
#define pcre2_get_match_data_size             PCRE2_SUFFIX(pcre2_get_match_data_size_)
#define pcre2_get_ovector_pointer             PCRE2_SUFFIX(pcre2_get_ovector_pointer_)
#define pcre2_get_ovector_count               PCRE2_SUFFIX(pcre2_get_ovector_count_)
#define pcre2_get_startchar                   PCRE2_SUFFIX(pcre2_get_startchar_)
#define pcre2_jit_compile                     PCRE2_SUFFIX(pcre2_jit_compile_)
#define pcre2_jit_match                       PCRE2_SUFFIX(pcre2_jit_match_)
#define pcre2_jit_free_unused_memory          PCRE2_SUFFIX(pcre2_jit_free_unused_memory_)
#define pcre2_jit_stack_assign                PCRE2_SUFFIX(pcre2_jit_stack_assign_)
#define pcre2_jit_stack_create                PCRE2_SUFFIX(pcre2_jit_stack_create_)
#define pcre2_jit_stack_free                  PCRE2_SUFFIX(pcre2_jit_stack_free_)
#define pcre2_maketables                      PCRE2_SUFFIX(pcre2_maketables_)
#define pcre2_maketables_free                 PCRE2_SUFFIX(pcre2_maketables_free_)
#define pcre2_match                           PCRE2_SUFFIX(pcre2_match_)
#define pcre2_match_context_copy              PCRE2_SUFFIX(pcre2_match_context_copy_)
#define pcre2_match_context_create            PCRE2_SUFFIX(pcre2_match_context_create_)
#define pcre2_match_context_free              PCRE2_SUFFIX(pcre2_match_context_free_)
#define pcre2_match_data_create               PCRE2_SUFFIX(pcre2_match_data_create_)
#define pcre2_match_data_create_from_pattern  PCRE2_SUFFIX(pcre2_match_data_create_from_pattern_)
#define pcre2_match_data_free                 PCRE2_SUFFIX(pcre2_match_data_free_)
#define pcre2_pattern_convert                 PCRE2_SUFFIX(pcre2_pattern_convert_)
#define pcre2_pattern_info                    PCRE2_SUFFIX(pcre2_pattern_info_)
#define pcre2_serialize_decode                PCRE2_SUFFIX(pcre2_serialize_decode_)
#define pcre2_serialize_encode                PCRE2_SUFFIX(pcre2_serialize_encode_)
#define pcre2_serialize_free                  PCRE2_SUFFIX(pcre2_serialize_free_)
#define pcre2_serialize_get_number_of_codes   PCRE2_SUFFIX(pcre2_serialize_get_number_of_codes_)
#define pcre2_set_bsr                         PCRE2_SUFFIX(pcre2_set_bsr_)
#define pcre2_set_callout                     PCRE2_SUFFIX(pcre2_set_callout_)
#define pcre2_set_character_tables            PCRE2_SUFFIX(pcre2_set_character_tables_)
#define pcre2_set_compile_extra_options       PCRE2_SUFFIX(pcre2_set_compile_extra_options_)
#define pcre2_set_compile_recursion_guard     PCRE2_SUFFIX(pcre2_set_compile_recursion_guard_)
#define pcre2_set_depth_limit                 PCRE2_SUFFIX(pcre2_set_depth_limit_)
#define pcre2_set_glob_escape                 PCRE2_SUFFIX(pcre2_set_glob_escape_)
#define pcre2_set_glob_separator              PCRE2_SUFFIX(pcre2_set_glob_separator_)
#define pcre2_set_heap_limit                  PCRE2_SUFFIX(pcre2_set_heap_limit_)
#define pcre2_set_match_limit                 PCRE2_SUFFIX(pcre2_set_match_limit_)
#define pcre2_set_max_varlookbehind           PCRE2_SUFFIX(pcre2_set_max_varlookbehind_)
#define pcre2_set_max_pattern_length          PCRE2_SUFFIX(pcre2_set_max_pattern_length_)
#define pcre2_set_max_pattern_compiled_length PCRE2_SUFFIX(pcre2_set_max_pattern_compiled_length_)
#define pcre2_set_newline                     PCRE2_SUFFIX(pcre2_set_newline_)
#define pcre2_set_parens_nest_limit           PCRE2_SUFFIX(pcre2_set_parens_nest_limit_)
#define pcre2_set_offset_limit                PCRE2_SUFFIX(pcre2_set_offset_limit_)
#define pcre2_set_optimize                    PCRE2_SUFFIX(pcre2_set_optimize_)
#define pcre2_set_substitute_callout          PCRE2_SUFFIX(pcre2_set_substitute_callout_)
#define pcre2_set_substitute_case_callout     PCRE2_SUFFIX(pcre2_set_substitute_case_callout_)
#define pcre2_substitute                      PCRE2_SUFFIX(pcre2_substitute_)
#define pcre2_substring_copy_byname           PCRE2_SUFFIX(pcre2_substring_copy_byname_)
#define pcre2_substring_copy_bynumber         PCRE2_SUFFIX(pcre2_substring_copy_bynumber_)
#define pcre2_substring_free                  PCRE2_SUFFIX(pcre2_substring_free_)
#define pcre2_substring_get_byname            PCRE2_SUFFIX(pcre2_substring_get_byname_)
#define pcre2_substring_get_bynumber          PCRE2_SUFFIX(pcre2_substring_get_bynumber_)
#define pcre2_substring_length_byname         PCRE2_SUFFIX(pcre2_substring_length_byname_)
#define pcre2_substring_length_bynumber       PCRE2_SUFFIX(pcre2_substring_length_bynumber_)
#define pcre2_substring_list_get              PCRE2_SUFFIX(pcre2_substring_list_get_)
#define pcre2_substring_list_free             PCRE2_SUFFIX(pcre2_substring_list_free_)
#define pcre2_substring_nametable_scan        PCRE2_SUFFIX(pcre2_substring_nametable_scan_)
#define pcre2_substring_number_from_name      PCRE2_SUFFIX(pcre2_substring_number_from_name_)

/* Keep this old function name for backwards compatibility */
#define pcre2_set_recursion_limit PCRE2_SUFFIX(pcre2_set_recursion_limit_)

/* Keep this obsolete function for backwards compatibility: it is now a noop. */
#define pcre2_set_recursion_memory_management PCRE2_SUFFIX(pcre2_set_recursion_memory_management_)

/* Now generate all three sets of width-specific structures and function
prototypes. */

#define PCRE2_TYPES_STRUCTURES_AND_FUNCTIONS \
PCRE2_TYPES_LIST \
PCRE2_STRUCTURE_LIST \
PCRE2_GENERAL_INFO_FUNCTIONS \
PCRE2_GENERAL_CONTEXT_FUNCTIONS \
PCRE2_COMPILE_CONTEXT_FUNCTIONS \
PCRE2_CONVERT_CONTEXT_FUNCTIONS \
PCRE2_CONVERT_FUNCTIONS \
PCRE2_MATCH_CONTEXT_FUNCTIONS \
PCRE2_COMPILE_FUNCTIONS \
PCRE2_PATTERN_INFO_FUNCTIONS \
PCRE2_MATCH_FUNCTIONS \
PCRE2_SUBSTRING_FUNCTIONS \
PCRE2_SERIALIZE_FUNCTIONS \
PCRE2_SUBSTITUTE_FUNCTION \
PCRE2_JIT_FUNCTIONS \
PCRE2_OTHER_FUNCTIONS

#define PCRE2_LOCAL_WIDTH 8
PCRE2_TYPES_STRUCTURES_AND_FUNCTIONS
#undef PCRE2_LOCAL_WIDTH

#define PCRE2_LOCAL_WIDTH 16
PCRE2_TYPES_STRUCTURES_AND_FUNCTIONS
#undef PCRE2_LOCAL_WIDTH

#define PCRE2_LOCAL_WIDTH 32
PCRE2_TYPES_STRUCTURES_AND_FUNCTIONS
#undef PCRE2_LOCAL_WIDTH

/* Undefine the list macros; they are no longer needed. */

#undef PCRE2_TYPES_LIST
#undef PCRE2_STRUCTURE_LIST
#undef PCRE2_GENERAL_INFO_FUNCTIONS
#undef PCRE2_GENERAL_CONTEXT_FUNCTIONS
#undef PCRE2_COMPILE_CONTEXT_FUNCTIONS
#undef PCRE2_CONVERT_CONTEXT_FUNCTIONS
#undef PCRE2_MATCH_CONTEXT_FUNCTIONS
#undef PCRE2_COMPILE_FUNCTIONS
#undef PCRE2_PATTERN_INFO_FUNCTIONS
#undef PCRE2_MATCH_FUNCTIONS
#undef PCRE2_SUBSTRING_FUNCTIONS
#undef PCRE2_SERIALIZE_FUNCTIONS
#undef PCRE2_SUBSTITUTE_FUNCTION
#undef PCRE2_JIT_FUNCTIONS
#undef PCRE2_OTHER_FUNCTIONS
#undef PCRE2_TYPES_STRUCTURES_AND_FUNCTIONS

/* PCRE2_CODE_UNIT_WIDTH must be defined. If it is 8, 16, or 32, redefine
PCRE2_SUFFIX to use it. If it is 0, undefine the other macros and make
PCRE2_SUFFIX a no-op. Otherwise, generate an error. */

#undef PCRE2_SUFFIX
#ifndef PCRE2_CODE_UNIT_WIDTH
#error PCRE2_CODE_UNIT_WIDTH must be defined before including pcre2.h.
#error Use 8, 16, or 32; or 0 for a multi-width application.
#else  /* PCRE2_CODE_UNIT_WIDTH is defined */
#if PCRE2_CODE_UNIT_WIDTH == 8 || \
    PCRE2_CODE_UNIT_WIDTH == 16 || \
    PCRE2_CODE_UNIT_WIDTH == 32
#define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH)
#elif PCRE2_CODE_UNIT_WIDTH == 0
#undef PCRE2_JOIN
#undef PCRE2_GLUE
#define PCRE2_SUFFIX(a) a
#else
#error PCRE2_CODE_UNIT_WIDTH must be 0, 8, 16, or 32.
#endif
#endif  /* PCRE2_CODE_UNIT_WIDTH is defined */

#ifdef __cplusplus
}  /* extern "C" */
#endif

#endif  /* PCRE2_H_IDEMPOTENT_GUARD */

/* End of pcre2.h */


================================================
FILE: Libraries/PCRE/pcre2_auto_possess.c
================================================
/*************************************************
*      Perl-Compatible Regular Expressions       *
*************************************************/

/* PCRE is a library of functions to support regular expressions whose syntax
and semantics are as close as possible to those of the Perl 5 language.

                       Written by Philip Hazel
     Original API code Copyright (c) 1997-2012 University of Cambridge
          New API code Copyright (c) 2016-2024 University of Cambridge

-----------------------------------------------------------------------------
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

    * Redistributions of source code must retain the above copyright notice,
      this list of conditions and the following disclaimer.

    * Redistributions in binary form must reproduce the above copyright
      notice, this list of conditions and the following disclaimer in the
      documentation and/or other materials provided with the distribution.

    * Neither the name of the University of Cambridge nor the names of its
      contributors may be used to endorse or promote products derived from
      this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
-----------------------------------------------------------------------------
*/

/* This module contains functions that scan a compiled pattern and change
repeats into possessive repeats where possible. */


#ifdef HAVE_CONFIG_H
#include "config.h"
#endif


#include "pcre2_internal.h"

/* This macro represents the max size of list[] and that is used to keep
track of UCD info in several places, it should be kept on sync with the
value used by GenerateUcd.py */
#define MAX_LIST 8

/*************************************************
*        Tables for auto-possessification        *
*************************************************/

/* This table is used to check whether auto-possessification is possible
between adjacent character-type opcodes. The left-hand (repeated) opcode is
used to select the row, and the right-hand opcode is use to select the column.
A value of 1 means that auto-possessification is OK. For example, the second
value in the first row means that \D+\d can be turned into \D++\d.

The Unicode property types (\P and \p) have to be present to fill out the table
because of what their opcode values are, but the table values should always be
zero because property types are handled separately in the code. The last four
columns apply to items that cannot be repeated, so there is no need to have
rows for them. Note that OP_DIGIT etc. are generated only when PCRE2_UCP is
*not* set. When it is set, \d etc. are converted into OP_(NOT_)PROP codes. */

#define APTROWS (LAST_AUTOTAB_LEFT_OP - FIRST_AUTOTAB_OP + 1)
#define APTCOLS (LAST_AUTOTAB_RIGHT_OP - FIRST_AUTOTAB_OP + 1)

static const uint8_t autoposstab[APTROWS][APTCOLS] = {
/* \D \d \S \s \W \w  . .+ \C \P \p \R \H \h \V \v \X \Z \z  $ $M */
  { 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 },  /* \D */
  { 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1 },  /* \d */
  { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1 },  /* \S */
  { 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 },  /* \s */
  { 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 },  /* \W */
  { 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1 },  /* \w */
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0 },  /* .  */
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 },  /* .+ */
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 },  /* \C */
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },  /* \P */
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },  /* \p */
  { 0, 1, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 },  /* \R */
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 },  /* \H */
  { 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0 },  /* \h */
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0 },  /* \V */
  { 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0 },  /* \v */
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 }   /* \X */
};

#ifdef SUPPORT_UNICODE
/* This table is used to check whether auto-possessification is possible
between adjacent Unicode property opcodes (OP_PROP and OP_NOTPROP). The
left-hand (repeated) opcode is used to select the row, and the right-hand
opcode is used to select the column. The values are as follows:

  0   Always return FALSE (never auto-possessify)
  1   Character groups are distinct (possessify if both are OP_PROP)
  2   Check character categories in the same group (general or particular)
  3   TRUE if the two opcodes are not the same (PROP vs NOTPROP)

  4   Check left general category vs right particular category
  5   Check right general category vs left particular category

  6   Left alphanum vs right general category
  7   Left space vs right general category
  8   Left word vs right general category

  9   Right alphanum vs left general category
 10   Right space vs left general category
 11   Right word vs left general category

 12   Left alphanum vs right particular category
 13   Left space vs right particular category
 14   Left word vs right particular category

 15   Right alphanum vs left particular category
 16   Right space vs left particular category
 17   Right word vs left particular category
*/

static const uint8_t propposstab[PT_TABSIZE][PT_TABSIZE] = {
/* LAMP GC  PC  SC  SCX ALNUM SPACE PXSPACE WORD CLIST UCNC BIDICL BOOL */
  { 3,  0,  0,  0,   0,    3,    1,      1,   0,    0,   0,    0,    0 },  /* PT_LAMP */
  { 0,  2,  4,  0,   0,    9,   10,     10,  11,    0,   0,    0,    0 },  /* PT_GC */
  { 0,  5,  2,  0,   0,   15,   16,     16,  17,    0,   0,    0,    0 },  /* PT_PC */
  { 0,  0,  0,  2,   2,    0,    0,      0,   0,    0,   0,    0,    0 },  /* PT_SC */
  { 0,  0,  0,  2,   2,    0,    0,      0,   0,    0,   0,    0,    0 },  /* PT_SCX */
  { 3,  6, 12,  0,   0,    3,    1,      1,   0,    0,   0,    0,    0 },  /* PT_ALNUM */
  { 1,  7, 13,  0,   0,    1,    3,      3,   1,    0,   0,    0,    0 },  /* PT_SPACE */
  { 1,  7, 13,  0,   0,    1,    3,      3,   1,    0,   0,    0,    0 },  /* PT_PXSPACE */
  { 0,  8, 14,  0,   0,    0,    1,      1,   3,    0,   0,    0,    0 },  /* PT_WORD */
  { 0,  0,  0,  0,   0,    0,    0,      0,   0,    0,   0,    0,    0 },  /* PT_CLIST */
  { 0,  0,  0,  0,   0,    0,    0,      0,   0,    0,   3,    0,    0 },  /* PT_UCNC */
  { 0,  0,  0,  0,   0,    0,    0,      0,   0,    0,   0,    0,    0 },  /* PT_BIDICL */
  { 0,  0,  0,  0,   0,    0,    0,      0,   0,    0,   0,    0,    0 }   /* PT_BOOL */
  /* PT_ANY does not need a record. */
};

/* This table is used to check whether auto-possessification is possible
between adjacent Unicode property opcodes (OP_PROP and OP_NOTPROP) when one
specifies a general category and the other specifies a particular category. The
row is selected by the general category and the column by the particular
category. The value is 1 if the particular category is not part of the general
category. */

static const uint8_t catposstab[7][30] = {
/* Cc Cf Cn Co Cs Ll Lm Lo Lt Lu Mc Me Mn Nd Nl No Pc Pd Pe Pf Pi Po Ps Sc Sk Sm So Zl Zp Zs */
  { 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },  /* C */
  { 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },  /* L */
  { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },  /* M */
  { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },  /* N */
  { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1 },  /* P */
  { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1 },  /* S */
  { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0 }   /* Z */
};

/* This table is used when checking ALNUM, (PX)SPACE, SPACE, and WORD against
a general or particular category. The properties in each row are those
that apply to the character set in question. Duplication means that a little
unnecessary work is done when checking, but this keeps things much simpler
because they can all use the same code. For more details see the comment where
this table is used.

Note: SPACE and PXSPACE used to be different because Perl excluded VT from
"space", but from Perl 5.18 it's included, so both categories are treated the
same here. */

static const uint8_t posspropstab[3][4] = {
  { ucp_L, ucp_N, ucp_N, ucp_Nl },  /* ALNUM, 3rd and 4th values redundant */
  { ucp_Z, ucp_Z, ucp_C, ucp_Cc },  /* SPACE and PXSPACE, 2nd value redundant */
  { ucp_L, ucp_N, ucp_P, ucp_Po }   /* WORD */
};
#endif  /* SUPPORT_UNICODE */



#ifdef SUPPORT_UNICODE
/*************************************************
*        Check a character and a property        *
*************************************************/

/* This function is called by compare_opcodes() when a property item is
adjacent to a fixed character.

Arguments:
  c            the character
  ptype        the property type
  pdata        the data for the type
  negated      TRUE if it's a negated property (\P or \p{^)

Returns:       TRUE if auto-possessifying is OK
*/

static BOOL
check_char_prop(uint32_t c, unsigned int ptype, unsigned int pdata,
  BOOL negated)
{
BOOL ok, rc;
const uint32_t *p;
const ucd_record *prop = GET_UCD(c);

switch(ptype)
  {
  case PT_LAMP:
  return (prop->chartype == ucp_Lu ||
          prop->chartype == ucp_Ll ||
          prop->chartype == ucp_Lt) == negated;

  case PT_GC:
  return (pdata == PRIV(ucp_gentype)[prop->chartype]) == negated;

  case PT_PC:
  return (pdata == prop->chartype) == negated;

  case PT_SC:
  return (pdata == prop->script) == negated;

  case PT_SCX:
  ok = (pdata == prop->script
        || MAPBIT(PRIV(ucd_script_sets) + UCD_SCRIPTX_PROP(prop), pdata) != 0);
  return ok == negated;

  /* These are specials */

  case PT_ALNUM:
  return (PRIV(ucp_gentype)[prop->chartype] == ucp_L ||
          PRIV(ucp_gentype)[prop->chartype] == ucp_N) == negated;

  /* Perl space used to exclude VT, but from Perl 5.18 it is included, which
  means that Perl space and POSIX space are now identical. PCRE was changed
  at release 8.34. */

  case PT_SPACE:    /* Perl space */
  case PT_PXSPACE:  /* POSIX space */
  switch(c)
    {
    HSPACE_CASES:
    VSPACE_CASES:
    rc = negated;
    break;

    default:
    rc = (PRIV(ucp_gentype)[prop->chartype] == ucp_Z) == negated;
    }
  return rc;

  case PT_WORD:
  return (PRIV(ucp_gentype)[prop->chartype] == ucp_L ||
          PRIV(ucp_gentype)[prop->chartype] == ucp_N ||
          c == CHAR_UNDERSCORE) == negated;

  case PT_CLIST:
  p = PRIV(ucd_caseless_sets) + prop->caseset;
  for (;;)
    {
    if (c < *p) return !negated;
    if (c == *p++) return negated;
    }
  PCRE2_DEBUG_UNREACHABLE(); /* Control should never reach here */
  break;

  /* Haven't yet thought these through. */

  case PT_BIDICL:
  return FALSE;

  case PT_BOOL:
  return FALSE;
  }

return FALSE;
}
#endif  /* SUPPORT_UNICODE */



/*************************************************
*        Base opcode of repeated opcodes         *
*************************************************/

/* Returns the base opcode for repeated single character type opcodes. If the
opcode is not a repeated character type, it returns with the original value.

Arguments:  c opcode
Returns:    base opcode for the type
*/

static PCRE2_UCHAR
get_repeat_base(PCRE2_UCHAR c)
{
return (c > OP_TYPEPOSUPTO)? c :
       (c >= OP_TYPESTAR)?   OP_TYPESTAR :
       (c >= OP_NOTSTARI)?   OP_NOTSTARI :
       (c >= OP_NOTSTAR)?    OP_NOTSTAR :
       (c >= OP_STARI)?      OP_STARI :
                             OP_STAR;
}


/*************************************************
*        Fill the character property list        *
*************************************************/

/* Checks whether the code points to an opcode that can take part in auto-
possessification, and if so, fills a list with its properties.

Arguments:
  code        points to start of expression
  utf         TRUE if in UTF mode
  ucp         TRUE if in UCP mode
  fcc         points to the case-flipping table
  list        points to output list
              list[0] will be filled with the opcode
              list[1] will be non-zero if this opcode
                can match an empty character string
              list[2..7] depends on the opcode

Returns:      points to the start of the next opcode if *code is accepted
              NULL if *code is not accepted
*/

static PCRE2_SPTR
get_chr_property_list(PCRE2_SPTR code, BOOL utf, BOOL ucp, const uint8_t *fcc,
  uint32_t *list)
{
PCRE2_UCHAR c = *code;
PCRE2_UCHAR base;
PCRE2_SPTR end;
PCRE2_SPTR class_end;
uint32_t chr;

#ifdef SUPPORT_UNICODE
uint32_t *clist_dest;
const uint32_t *clist_src;
#else
(void)utf;    /* Suppress "unused parameter" compiler warnings */
(void)ucp;
#endif

list[0] = c;
list[1] = FALSE;
code++;

if (c >= OP_STAR && c <= OP_TYPEPOSUPTO)
  {
  base = get_repeat_base(c);
  c -= (base - OP_STAR);

  if (c == OP_UPTO || c == OP_MINUPTO || c == OP_EXACT || c == OP_POSUPTO)
    code += IMM2_SIZE;

  list[1] = (c != OP_PLUS && c != OP_MINPLUS && c != OP_EXACT &&
             c != OP_POSPLUS);

  switch(base)
    {
    case OP_STAR:
    list[0] = OP_CHAR;
    break;

    case OP_STARI:
    list[0] = OP_CHARI;
    break;

    case OP_NOTSTAR:
    list[0] = OP_NOT;
    break;

    case OP_NOTSTARI:
    list[0] = OP_NOTI;
    break;

    case OP_TYPESTAR:
    list[0] = *code;
    code++;
    break;
    }
  c = list[0];
  }

switch(c)
  {
  case OP_NOT_DIGIT:
  case OP_DIGIT:
  case OP_NOT_WHITESPACE:
  case OP_WHITESPACE:
  case OP_NOT_WORDCHAR:
  case OP_WORDCHAR:
  case OP_ANY:
  case OP_ALLANY:
  case OP_ANYNL:
  case OP_NOT_HSPACE:
  case OP_HSPACE:
  case OP_NOT_VSPACE:
  case OP_VSPACE:
  case OP_EXTUNI:
  case OP_EODN:
  case OP_EOD:
  case OP_DOLL:
  case OP_DOLLM:
  return code;

  case OP_CHAR:
  case OP_NOT:
  GETCHARINCTEST(chr, code);
  list[2] = chr;
  list[3] = NOTACHAR;
  return code;

  case OP_CHARI:
  case OP_NOTI:
  list[0] = (c == OP_CHARI) ? OP_CHAR : OP_NOT;
  GETCHARINCTEST(chr, code);
  list[2] = chr;

#ifdef SUPPORT_UNICODE
  if (chr < 128 || (chr < 256 && !utf && !ucp))
    list[3] = fcc[chr];
  else
    list[3] = UCD_OTHERCASE(chr);
#elif defined SUPPORT_WIDE_CHARS
  list[3] = (chr < 256) ? fcc[chr] : chr;
#else
  list[3] = fcc[chr];
#endif

  /* The othercase might be the same value. */

  if (chr == list[3])
    list[3] = NOTACHAR;
  else
    list[4] = NOTACHAR;
  return code;

#ifdef SUPPORT_UNICODE
  case OP_PROP:
  case OP_NOTPROP:
  if (code[0] != PT_CLIST)
    {
    list[2] = code[0];
    list[3] = code[1];
    return code + 2;
    }

  /* Convert only if we have enough space. */

  clist_src = PRIV(ucd_caseless_sets) + code[1];
  clist_dest = list + 2;
  code += 2;

  do {
     if (clist_dest >= list + MAX_LIST)
       {
       /* Early return if there is not enough space. GenerateUcd.py
       generated a list with more than 5 characters and something
       must be done about that going forward. */
       PCRE2_DEBUG_UNREACHABLE();   /* Remove if it ever triggers */
       list[2] = code[0];
       list[3] = code[1];
       return code;
       }
     *clist_dest++ = *clist_src;
     }
  while(*clist_src++ != NOTACHAR);

  /* All characters are stored. The terminating NOTACHAR is copied from the
  clist itself. */

  list[0] = (c == OP_PROP) ? OP_CHAR : OP_NOT;
  return code;
#endif

  case OP_NCLASS:
  case OP_CLASS:
#ifdef SUPPORT_WIDE_CHARS
  case OP_XCLASS:
  case OP_ECLASS:
  if (c == OP_XCLASS || c == OP_ECLASS)
    end = code + GET(code, 0) - 1;
  else
#endif
    end = code + 32 / sizeof(PCRE2_UCHAR);
  class_end = end;

  switch(*end)
    {
    case OP_CRSTAR:
    case OP_CRMINSTAR:
    case OP_CRQUERY:
    case OP_CRMINQUERY:
    case OP_CRPOSSTAR:
    case OP_CRPOSQUERY:
    list[1] = TRUE;
    end++;
    break;

    case OP_CRPLUS:
    case OP_CRMINPLUS:
    case OP_CRPOSPLUS:
    end++;
    break;

    case OP_CRRANGE:
    case OP_CRMINRANGE:
    case OP_CRPOSRANGE:
    list[1] = (GET2(end, 1) == 0);
    end += 1 + 2 * IMM2_SIZE;
    break;
    }
  list[2] = (uint32_t)(end - code);
  list[3] = (uint32_t)(end - class_end);
  return end;
  }

return NULL;    /* Opcode not accepted */
}



/*************************************************
*    Scan further character sets for match       *
*************************************************/

/* Checks whether the base and the current opcode have a common character, in
which case the base cannot be possessified.

Arguments:
  code        points to the byte code
  utf         TRUE in UTF mode
  ucp         TRUE in UCP mode
  cb          compile data block
  base_list   the data list of the base opcode
  base_end    the end of the base opcode
  rec_limit   points to recursion depth counter

Returns:      TRUE if the auto-possessification is possible
*/

static BOOL
compare_opcodes(PCRE2_SPTR code, BOOL utf, BOOL ucp, const compile_block *cb,
  const uint32_t *base_list, PCRE2_SPTR base_end, int *rec_limit)
{
PCRE2_UCHAR c;
uint32_t list[MAX_LIST];
const uint32_t *chr_ptr;
const uint32_t *ochr_ptr;
const uint32_t *list_ptr;
PCRE2_SPTR next_code;
#ifdef SUPPORT_WIDE_CHARS
PCRE2_SPTR xclass_flags;
#endif
const uint8_t *class_bitset;
const uint8_t *set1, *set2, *set_end;
uint32_t chr;
BOOL accepted, invert_bits;
BOOL entered_a_group = FALSE;

if (--(*rec_limit) <= 0) return FALSE;  /* Recursion has gone too deep */

/* Note: the base_list[1] contains whether the current opcode has a greedy
(represented by a non-zero value) quantifier. This is a different from
other character type lists, which store here that the character iterator
matches to an empty string (also represented by a non-zero value). */

for(;;)
  {
  PCRE2_SPTR bracode;

  /* All operations move the code pointer forward.
  Therefore infinite recursions are not possible. */

  c = *code;

  /* Skip over callouts */

  if (c == OP_CALLOUT)
    {
    code += PRIV(OP_lengths)[c];
    continue;
    }

  if (c == OP_CALLOUT_STR)
    {
    code += GET(code, 1 + 2*LINK_SIZE);
    continue;
    }

  /* At the end of a branch, skip to the end of the group and process it. */

  if (c == OP_ALT)
    {
    do code += GET(code, 1); while (*code == OP_ALT);
    c = *code;
    }

  /* Inspect the next opcode. */

  switch(c)
    {
    /* We can always possessify a greedy iterator at the end of the pattern,
    which is reached after skipping over the final OP_KET. A non-greedy
    iterator must never be possessified. */

    case OP_END:
    return base_list[1] != 0;

    /* When an iterator is at the end of certain kinds of group we can inspect
    what follows the group by skipping over the closing ket. Note that this
    does not apply to OP_KETRMAX or OP_KETRMIN because what follows any given
    iteration is variable (could be another iteration or could be the next
    item). As these two opcodes are not listed in the next switch, they will
    end up as the next code to inspect, and return FALSE by virtue of being
    unsupported. */

    case OP_KET:
    case OP_KETRPOS:
    /* The non-greedy case cannot be converted to a possessive form. */

    if (base_list[1] == 0) return FALSE;

    /* If the bracket is capturing it might be referenced by an OP_RECURSE
    so its last iterator can never be possessified if the pattern contains
    recursions. (This could be improved by keeping a list of group numbers that
    are called by recursion.) */

    bracode = code - GET(code, 1);
    switch(*bracode)
      {
      case OP_CBRA:
      case OP_SCBRA:
      case OP_CBRAPOS:
      case OP_SCBRAPOS:
      if (cb->had_recurse) return FALSE;
      break;

      /* A script run might have to backtrack if the iterated item can match
      characters from more than one script. So give up unless repeating an
      explicit character. */

      case OP_SCRIPT_RUN:
      if (base_list[0] != OP_CHAR && base_list[0] != OP_CHARI)
        return FALSE;
      break;

      /* Atomic sub-patterns and forward assertions can always auto-possessify
      their last iterator. However, if the group was entered as a result of
      checking a previous iterator, this is not possible. */

      case OP_ASSERT:
      case OP_ASSERT_NOT:
      case OP_ONCE:
      return !entered_a_group;

      /* Fixed-length lookbehinds can be treated the same way, but variable
      length lookbehinds must not auto-possessify their last iterator. Note
      that in order to identify a variable length lookbehind we must check
      through all branches, because some may be of fixed length. */

      case OP_ASSERTBACK:
      case OP_ASSERTBACK_NOT:
      do
        {
        if (bracode[1+LINK_SIZE] == OP_VREVERSE) return FALSE;  /* Variable */
        bracode += GET(bracode, 1);
        }
      while (*bracode == OP_ALT);
      return !entered_a_group;  /* Not variable length */

      /* Non-atomic assertions - don't possessify last iterator. This needs
      more thought. */

      case OP_ASSERT_NA:
      case OP_ASSERTBACK_NA:
      return FALSE;
      }

    /* Skip over the bracket and inspect what comes next. */

    code += PRIV(OP_lengths)[c];
    continue;

    /* Handle cases where the next item is a group. */

    case OP_ONCE:
    case OP_BRA:
    case OP_CBRA:
    next_code = code + GET(code, 1);
    code += PRIV(OP_lengths)[c];

    /* Check each branch. We have to recurse a level for all but the last
    branch. */

    while (*next_code == OP_ALT)
      {
      if (!compare_opcodes(code, utf, ucp, cb, base_list, base_end, rec_limit))
        return FALSE;
      code = next_code + 1 + LINK_SIZE;
      next_code += GET(next_code, 1);
      }

    entered_a_group = TRUE;
    continue;

    case OP_BRAZERO:
    case OP_BRAMINZERO:

    next_code = code + 1;
    if (*next_code != OP_BRA && *next_code != OP_CBRA &&
        *next_code != OP_ONCE) return FALSE;

    do next_code += GET(next_code, 1); while (*next_code == OP_ALT);

    /* The bracket content will be checked by the OP_BRA/OP_CBRA case above. */

    next_code += 1 + LINK_SIZE;
    if (!compare_opcodes(next_code, utf, ucp, cb, base_list, base_end,
         rec_limit))
      return FALSE;

    code += PRIV(OP_lengths)[c];
    continue;

    /* The next opcode does not need special handling; fall through and use it
    to see if the base can be possessified. */

    default:
    break;
    }

  /* We now have the next appropriate opcode to compare with the base. Check
  for a supported opcode, and load its properties. */

  code = get_chr_property_list(code, utf, ucp, cb->fcc, list);
  if (code == NULL) return FALSE;    /* Unsupported */

  /* If either opcode is a small character list, set pointers for comparing
  characters from that list with another list, or with a property. */

  if (base_list[0] == OP_CHAR)
    {
    chr_ptr = base_list + 2;
    list_ptr = list;
    }
  else if (list[0] == OP_CHAR)
    {
    chr_ptr = list + 2;
    list_ptr = base_list;
    }

  /* Character bitsets can also be compared to certain opcodes. */

  else if (base_list[0] == OP_CLASS || list[0] == OP_CLASS
#if PCRE2_CODE_UNIT_WIDTH == 8
      /* In 8 bit, non-UTF mode, OP_CLASS and OP_NCLASS are the same. */
      || (!utf && (base_list[0] == OP_NCLASS || list[0] == OP_NCLASS))
#endif
      )
    {
#if PCRE2_CODE_UNIT_WIDTH == 8
    if (base_list[0] == OP_CLASS || (!utf && base_list[0] == OP_NCLASS))
#else
    if (base_list[0] == OP_CLASS)
#endif
      {
      set1 = (const uint8_t *)(base_end - base_list[2]);
      list_ptr = list;
      }
    else
      {
      set1 = (const uint8_t *)(code - list[2]);
      list_ptr = base_list;
      }

    invert_bits = FALSE;
    switch(list_ptr[0])
      {
      case OP_CLASS:
      case OP_NCLASS:
      set2 = (const uint8_t *)
        ((list_ptr == list ? code : base_end) - list_ptr[2]);
      break;

#ifdef SUPPORT_WIDE_CHARS
      case OP_XCLASS:
      xclass_flags = (list_ptr == list ? code : base_end) -
        list_ptr[2] + LINK_SIZE;
      if ((*xclass_flags & XCL_HASPROP) != 0) return FALSE;
      if ((*xclass_flags & XCL_MAP) == 0)
        {
        /* No bits are set for characters < 256. */
        if (list[1] == 0) return (*xclass_flags & XCL_NOT) == 0;
        /* Might be an empty repeat. */
        continue;
        }
      set2 = (const uint8_t *)(xclass_flags + 1);
      break;
#endif

      case OP_NOT_DIGIT:
      invert_bits = TRUE;
      /* Fall through */
      case OP_DIGIT:
      set2 = (const uint8_t *)(cb->cbits + cbit_digit);
      break;

      case OP_NOT_WHITESPACE:
      invert_bits = TRUE;
      /* Fall through */
      case OP_WHITESPACE:
      set2 = (const uint8_t *)(cb->cbits + cbit_space);
      break;

      case OP_NOT_WORDCHAR:
      invert_bits = TRUE;
      /* Fall through */
      case OP_WORDCHAR:
      set2 = (const uint8_t *)(cb->cbits + cbit_word);
      break;

      default:
      return FALSE;
      }

    /* Because the bit sets are unaligned bytes, we need to perform byte
    comparison here. */

    set_end = set1 + 32;
    if (invert_bits)
      {
      do
        {
        if ((*set1++ & ~(*set2++)) != 0) return FALSE;
        }
      while (set1 < set_end);
      }
    else
      {
      do
        {
        if ((*set1++ & *set2++) != 0) return FALSE;
        }
      while (set1 < set_end);
      }

    if (list[1] == 0) return TRUE;
    /* Might be an empty repeat. */
    continue;
    }

  /* Some property combinations also acceptable. Unicode property opcodes are
  processed specially; the rest can be handled with a lookup table. */

  else
    {
    uint32_t leftop, rightop;

    leftop = base_list[0];
    rightop = list[0];

#ifdef SUPPORT_UNICODE
    accepted = FALSE; /* Always set in non-unicode case. */
    if (leftop == OP_PROP || leftop == OP_NOTPROP)
      {
      if (rightop == OP_EOD)
        accepted = TRUE;
      else if (rightop == OP_PROP || rightop == OP_NOTPROP)
        {
        int n;
        const uint8_t *p;
        BOOL same = leftop == rightop;
        BOOL lisprop = leftop == OP_PROP;
        BOOL risprop = rightop == OP_PROP;
        BOOL bothprop = lisprop && risprop;

        /* There's a table that specifies how each combination is to be
        processed:
          0   Always return FALSE (never auto-possessify)
          1   Character groups are distinct (possessify if both are OP_PROP)
          2   Check character categories in the same group (general or particular)
          3   Return TRUE if the two opcodes are not the same
          ... see comments below
        */

        n = propposstab[base_list[2]][list[2]];
        switch(n)
          {
          case 0: break;
          case 1: accepted = bothprop; break;
          case 2: accepted = (base_list[3] == list[3]) != same; break;
          case 3: accepted = !same; break;

          case 4:  /* Left general category, right particular category */
          accepted = risprop && catposstab[base_list[3]][list[3]] == same;
          break;

          case 5:  /* Right general category, left particular category */
          accepted = lisprop && catposstab[list[3]][base_list[3]] == same;
          break;

          /* This code is logically tricky. Think hard before fiddling with it.
          The posspropstab table has four entries per row. Each row relates to
          one of PCRE's special properties such as ALNUM or SPACE or WORD.
          Only WORD actually needs all four entries, but using repeats for the
          others means they can all use the same code below.

          The first two entries in each row are Unicode general categories, and
          apply always, because all the characters they include are part of the
          PCRE character set. The third and fourth entries are a general and a
          particular category, respectively, that include one or more relevant
          characters. One or the other is used, depending on whether the check
          is for a general or a particular category. However, in both cases the
          category contains more characters than the specials that are defined
          for the property being tested against. Therefore, it cannot be used
          in a NOTPROP case.

          Example: the row for WORD contains ucp_L, ucp_N, ucp_P, ucp_Po.
          Underscore is covered by ucp_P or ucp_Po. */

          case 6:  /* Left alphanum vs right general category */
          case 7:  /* Left space vs right general category */
          case 8:  /* Left word vs right general category */
          p = posspropstab[n-6];
          accepted = risprop && lisprop ==
            (list[3] != p[0] &&
             list[3] != p[1] &&
            (list[3] != p[2] || !lisprop));
          break;

          case 9:   /* Right alphanum vs left general category */
          case 10:  /* Right space vs left general category */
          case 11:  /* Right word vs left general category */
          p = posspropstab[n-9];
          accepted = lisprop && risprop ==
            (base_list[3] != p[0] &&
             base_list[3] != p[1] &&
            (base_list[3] != p[2] || !risprop));
          break;

          case 12:  /* Left alphanum vs right particular category */
          case 13:  /* Left space vs right particular category */
          case 14:  /* Left word vs right particular category */
          p = posspropstab[n-12];
          accepted = risprop && lisprop ==
            (catposstab[p[0]][list[3]] &&
             catposstab[p[1]][list[3]] &&
            (list[3] != p[3] || !lisprop));
          break;

          case 15:  /* Right alphanum vs left particular category */
          case 16:  /* Right space vs left particular category */
          case 17:  /* Right word vs left particular category */
          p = posspropstab[n-15];
          accepted = lisprop && risprop ==
            (catposstab[p[0]][base_list[3]] &&
             catposstab[p[1]][base_list[3]] &&
            (base_list[3] != p[3] || !risprop));
          break;
          }
        }
      }

    else
#endif  /* SUPPORT_UNICODE */

    accepted = leftop >= FIRST_AUTOTAB_OP && leftop <= LAST_AUTOTAB_LEFT_OP &&
           rightop >= FIRST_AUTOTAB_OP && rightop <= LAST_AUTOTAB_RIGHT_OP &&
           autoposstab[leftop - FIRST_AUTOTAB_OP][rightop - FIRST_AUTOTAB_OP];

    if (!accepted) return FALSE;

    if (list[1] == 0) return TRUE;
    /* Might be an empty repeat. */
    continue;
    }

  /* Control reaches here only if one of the items is a small character list.
  All characters are checked against the other side. */

  do
    {
    chr = *chr_ptr;

    switch(list_ptr[0])
      {
      case OP_CHAR:
      ochr_ptr = list_ptr + 2;
      do
        {
        if (chr == *ochr_ptr) return FALSE;
        ochr_ptr++;
        }
      while(*ochr_ptr != NOTACHAR);
      break;

      case OP_NOT:
      ochr_ptr = list_ptr + 2;
      do
        {
        if (chr == *ochr_ptr)
          break;
        ochr_ptr++;
        }
      while(*ochr_ptr != NOTACHAR);
      if (*ochr_ptr == NOTACHAR) return FALSE;   /* Not found */
      break;

      /* Note that OP_DIGIT etc. are generated only when PCRE2_UCP is *not*
      set. When it is set, \d etc. are converted into OP_(NOT_)PROP codes. */

      case OP_DIGIT:
      if (chr < 256 && (cb->ctypes[chr] & ctype_digit) != 0) return FALSE;
      break;

      case OP_NOT_DIGIT:
      if (chr > 255 || (cb->ctypes[chr] & ctype_digit) == 0) return FALSE;
      break;

      case OP_WHITESPACE:
      if (chr < 256 && (cb->ctypes[chr] & ctype_space) != 0) return FALSE;
      break;

      case OP_NOT_WHITESPACE:
      if (chr > 255 || (cb->ctypes[chr] & ctype_space) == 0) return FALSE;
      break;

      case OP_WORDCHAR:
      if (chr < 255 && (cb->ctypes[chr] & ctype_word) != 0) return FALSE;
      break;

      case OP_NOT_WORDCHAR:
      if (chr > 255 || (cb->ctypes[chr] & ctype_word) == 0) return FALSE;
      break;

      case OP_HSPACE:
      switch(chr)
        {
        HSPACE_CASES: return FALSE;
        default: break;
        }
      break;

      case OP_NOT_HSPACE:
      switch(chr)
        {
        HSPACE_CASES: break;
        default: return FALSE;
        }
      break;

      case OP_ANYNL:
      case OP_VSPACE:
      switch(chr)
        {
        VSPACE_CASES: return FALSE;
        default: break;
        }
      break;

      case OP_NOT_VSPACE:
      switch(chr)
        {
        VSPACE_CASES: break;
        default: return FALSE;
        }
      break;

      case OP_DOLL:
      case OP_EODN:
      switch (chr)
        {
        case CHAR_CR:
        case CHAR_LF:
        case CHAR_VT:
        case CHAR_FF:
        case CHAR_NEL:
#ifndef EBCDIC
        case 0x2028:
        case 0x2029:
#endif  /* Not EBCDIC */
        return FALSE;
        }
      break;

      case OP_EOD:    /* Can always possessify before \z */
      break;

#ifdef SUPPORT_UNICODE
      case OP_PROP:
      case OP_NOTPROP:
      if (!check_char_prop(chr, list_ptr[2], list_ptr[3],
            list_ptr[0] == OP_NOTPROP))
        return FALSE;
      break;
#endif

      case OP_NCLASS:
      if (chr > 255) return FALSE;
      /* Fall through */

      case OP_CLASS:
      if (chr > 255) break;
      class_bitset = (const uint8_t *)
        ((list_ptr == list ? code : base_end) - list_ptr[2]);
      if ((class_bitset[chr >> 3] & (1u << (chr & 7))) != 0) return FALSE;
      break;

#ifdef SUPPORT_WIDE_CHARS
      case OP_XCLASS:
      if (PRIV(xclass)(chr, (list_ptr == list ? code : base_end) -
          list_ptr[2] + LINK_SIZE, (const uint8_t*)cb->start_code, utf))
        return FALSE;
      break;

      case OP_ECLASS:
      if (PRIV(eclass)(chr,
          (list_ptr == list ? code : base_end) - list_ptr[2] + LINK_SIZE,
          (list_ptr == list ? code : base_end) - list_ptr[3],
          (const uint8_t*)cb->start_code, utf))
        return FALSE;
      break;
#endif /* SUPPORT_WIDE_CHARS */

      default:
      return FALSE;
      }

    chr_ptr++;
    }
  while(*chr_ptr != NOTACHAR);

  /* At least one character must be matched from this opcode. */

  if (list[1] == 0) return TRUE;
  }

PCRE2_DEBUG_UNREACHABLE(); /* Control should never reach here */
return FALSE;              /* Avoid compiler warnings */
}



/*************************************************
*    Scan compiled regex for auto-possession     *
*************************************************/

/* Replaces single character iterations with their possessive alternatives
if appropriate. This function modifies the compiled opcode! Hitting a
non-existent opcode may indicate a bug in PCRE2, but it can also be caused if a
bad UTF string was compiled with PCRE2_NO_UTF_CHECK. The rec_limit catches
overly complicated or large patterns. In these cases, the check just stops,
leaving the remainder of the pattern unpossessified.

Arguments:
  code        points to start of the byte code
  cb          compile data block

Returns:      0 for success
              -1 if a non-existant opcode is encountered
*/

int
PRIV(auto_possessify)(PCRE2_UCHAR *code, const compile_block *cb)
{
PCRE2_UCHAR c;
PCRE2_SPTR end;
PCRE2_UCHAR *repeat_opcode;
uint32_t list[MAX_LIST];
int rec_limit = 1000;  /* Was 10,000 but clang+ASAN uses a lot of stack. */
BOOL utf = (cb->external_options & PCRE2_UTF) != 0;
BOOL ucp = (cb->external_options & PCRE2_UCP) != 0;

for (;;)
  {
  c = *code;

  if (c >= OP_TABLE_LENGTH)
    {
    PCRE2_DEBUG_UNREACHABLE();
    return -1;   /* Something gone wrong */
    }

  if (c >= OP_STAR && c <= OP_TYPEPOSUPTO)
    {
    c -= get_repeat_base(c) - OP_STAR;
    end = (c <= OP_MINUPTO) ?
      get_chr_property_list(code, utf, ucp, cb->fcc, list) : NULL;
    list[1] = c == OP_STAR || c == OP_PLUS || c == OP_QUERY || c == OP_UPTO;

    if (end != NULL && compare_opcodes(end, utf, ucp, cb, list, end,
        &rec_limit))
      {
      switch(c)
        {
        case OP_STAR:
        *code += OP_POSSTAR - OP_STAR;
        break;

        case OP_MINSTAR:
        *code += OP_POSSTAR - OP_MINSTAR;
        break;

        case OP_PLUS:
        *code += OP_POSPLUS - OP_PLUS;
        break;

        case OP_MINPLUS:
        *code += OP_POSPLUS - OP_MINPLUS;
        break;

        case OP_QUERY:
        *code += OP_POSQUERY - OP_QUERY;
        break;

        case OP_MINQUERY:
        *code += OP_POSQUERY - OP_MINQUERY;
        break;

        case OP_UPTO:
        *code += OP_POSUPTO - OP_UPTO;
        break;

        case OP_MINUPTO:
        *code += OP_POSUPTO - OP_MINUPTO;
        break;
        }
      }
    c = *code;
    }
  else if (c == OP_CLASS || c == OP_NCLASS
#ifdef SUPPORT_WIDE_CHARS
           || c == OP_XCLASS || c == OP_ECLASS
#endif
           )
    {
#ifdef SUPPORT_WIDE_CHARS
    if (c == OP_XCLASS || c == OP_ECLASS)
      repeat_opcode = code + GET(code, 1);
    else
#endif
      repeat_opcode = code + 1 + (32 / sizeof(PCRE2_UCHAR));

    c = *repeat_opcode;
    if (c >= OP_CRSTAR && c <= OP_CRMINRANGE)
      {
      /* The return from get_chr_property_list() will never be NULL when
      *code (aka c) is one of the four class opcodes. However, gcc with
      -fanalyzer notes that a NULL return is possible, and grumbles. Hence we
      put in a check. */

      end = get_chr_property_list(code, utf, ucp, cb->fcc, list);
      list[1] = (c & 1) == 0;

      if (end != NULL &&
          compare_opcodes(end, utf, ucp, cb, list, end, &rec_limit))
        {
        switch (c)
          {
          case OP_CRSTAR:
          case OP_CRMINSTAR:
          *repeat_opcode = OP_CRPOSSTAR;
          break;

          case OP_CRPLUS:
          case OP_CRMINPLUS:
          *repeat_opcode = OP_CRPOSPLUS;
          break;

          case OP_CRQUERY:
          case OP_CRMINQUERY:
          *repeat_opcode = OP_CRPOSQUERY;
          break;

          case OP_CRRANGE:
          case OP_CRMINRANGE:
          *repeat_opcode = OP_CRPOSRANGE;
          break;
          }
        }
      }
    c = *code;
    }

  switch(c)
    {
    case OP_END:
    return 0;

    case OP_TYPESTAR:
    case OP_TYPEMINSTAR:
    case OP_TYPEPLUS:
    case OP_TYPEMINPLUS:
    case OP_TYPEQUERY:
    case OP_TYPEMINQUERY:
    case OP_TYPEPOSSTAR:
    case OP_TYPEPOSPLUS:
    case OP_TYPEPOSQUERY:
    if (code[1] == OP_PROP || code[1] == OP_NOTPROP) code += 2;
    break;

    case OP_TYPEUPTO:
    case OP_TYPEMINUPTO:
    case OP_TYPEEXACT:
    case OP_TYPEPOSUPTO:
    if (code[1 + IMM2_SIZE] == OP_PROP || code[1 + IMM2_SIZE] == OP_NOTPROP)
      code += 2;
    break;

    case OP_CALLOUT_STR:
    code += GET(code, 1 + 2*LINK_SIZE);
    break;

#ifdef SUPPORT_WIDE_CHARS
    case OP_XCLASS:
    case OP_ECLASS:
    code += GET(code, 1);
    break;
#endif

    case OP_MARK:
    case OP_COMMIT_ARG:
    case OP_PRUNE_ARG:
    case OP_SKIP_ARG:
    case OP_THEN_ARG:
    code += code[1];
    break;
    }

  /* Add in the fixed length from the table */

  code += PRIV(OP_lengths)[c];

  /* In UTF-8 and UTF-16 modes, opcodes that are followed by a character may be
  followed by a multi-byte character. The length in the table is a minimum, so
  we have to arrange to skip the extra code units. */

#ifdef MAYBE_UTF_MULTI
  if (utf) switch(c)
    {
    case OP_CHAR:
    case OP_CHARI:
    case OP_NOT:
    case OP_NOTI:
    case OP_STAR:
    case OP_MINSTAR:
    case OP_PLUS:
    case OP_MINPLUS:
    case OP_QUERY:
    case OP_MINQUERY:
    case OP_UPTO:
    case OP_MINUPTO:
    case OP_EXACT:
    case OP_POSSTAR:
    case OP_POSPLUS:
    case OP_POSQUERY:
    case OP_POSUPTO:
    case OP_STARI:
    case OP_MINSTARI:
    case OP_PLUSI:
    case OP_MINPLUSI:
    case OP_QUERYI:
    case OP_MINQUERYI:
    case OP_UPTOI:
    case OP_MINUPTOI:
    case OP_EXACTI:
    case OP_POSSTARI:
    case OP_POSPLUSI:
    case OP_POSQUERYI:
    case OP_POSUPTOI:
    case OP_NOTSTAR:
    case OP_NOTMINSTAR:
    case OP_NOTPLUS:
    case OP_NOTMINPLUS:
    case OP_NOTQUERY:
    case OP_NOTMINQUERY:
    case OP_NOTUPTO:
    case OP_NOTMINUPTO:
    case OP_NOTEXACT:
    case OP_NOTPOSSTAR:
    case OP_NOTPOSPLUS:
    case OP_NOTPOSQUERY:
    case OP_NOTPOSUPTO:
    case OP_NOTSTARI:
    case OP_NOTMINSTARI:
    case OP_NOTPLUSI:
    case OP_NOTMINPLUSI:
    case OP_NOTQUERYI:
    case OP_NOTMINQUERYI:
    case OP_NOTUPTOI:
    case OP_NOTMINUPTOI:
    case OP_NOTEXACTI:
    case OP_NOTPOSSTARI:
    case OP_NOTPOSPLUSI:
    case OP_NOTPOSQUERYI:
    case OP_NOTPOSUPTOI:
    if (HAS_EXTRALEN(code[-1])) code += GET_EXTRALEN(code[-1]);
    break;
    }
#else
  (void)(utf);  /* Keep compiler happy by referencing function argument */
#endif  /* SUPPORT_WIDE_CHARS */
  }
}

/* End of pcre2_auto_possess.c */


================================================
FILE: Libraries/PCRE/pcre2_chartables.c
================================================
/*************************************************
*      Perl-Compatible Regular Expressions       *
*************************************************/

/* This file was automatically written by the pcre2_dftables auxiliary
program. It contains character tables that are used when no external
tables are passed to PCRE2 by the application that calls it. The tables
are used only for characters whose code values are less than 256, and
only relevant if not in UCP mode. */

/* This set of tables was written in the C locale. */

/* The pcre2_ftables program (which is distributed with PCRE2) can be used
to build alternative versions of this file. This is necessary if you are
running in an EBCDIC environment, or if you want to default to a different
encoding, for example ISO-8859-1. When pcre2_dftables is run, it creates
these tables in the "C" locale by default. This happens automatically if
PCRE2 is configured with --enable-rebuild-chartables. However, you can run
pcre2_dftables manually with the -L option to build tables using the LC_ALL
locale. */

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include "pcre2_internal.h"

const uint8_t PRIV(default_tables)[] = {

/* This table is a lower casing table. */

    0,  1,  2,  3,  4,  5,  6,  7,
    8,  9, 10, 11, 12, 13, 14, 15,
   16, 17, 18, 19, 20, 21, 22, 23,
   24, 25, 26, 27, 28, 29, 30, 31,
   32, 33, 34, 35, 36, 37, 38, 39,
   40, 41, 42, 43, 44, 45, 46, 47,
   48, 49, 50, 51, 52, 53, 54, 55,
   56, 57, 58, 59, 60, 61, 62, 63,
   64, 97, 98, 99,100,101,102,103,
  104,105,106,107,108,109,110,111,
  112,113,114,115,116,117,118,119,
  120,121,122, 91, 92, 93, 94, 95,
   96, 97, 98, 99,100,101,102,103,
  104,105,106,107,108,109,110,111,
  112,113,114,115,116,117,118,119,
  120,121,122,123,124,125,126,127,
  128,129,130,131,132,133,134,135,
  136,137,138,139,140,141,142,143,
  144,145,146,147,148,149,150,151,
  152,153,154,155,156,157,158,159,
  160,161,162,163,164,165,166,167,
  168,169,170,171,172,173,174,175,
  176,177,178,179,180,181,182,183,
  184,185,186,187,188,189,190,191,
  192,193,194,195,196,197,198,199,
  200,201,202,203,204,205,206,207,
  208,209,210,211,212,213,214,215,
  216,217,218,219,220,221,222,223,
  224,225,226,227,228,229,230,231,
  232,233,234,235,236,237,238,239,
  240,241,242,243,244,245,246,247,
  248,249,250,251,252,253,254,255,

/* This table is a case flipping table. */

    0,  1,  2,  3,  4,  5,  6,  7,
    8,  9, 10, 11, 12, 13, 14, 15,
   16, 17, 18, 19, 20, 21, 22, 23,
   24, 25, 26, 27, 28, 29, 30, 31,
   32, 33, 34, 35, 36, 37, 38, 39,
   40, 41, 42, 43, 44, 45, 46, 47,
   48, 49, 50, 51, 52, 53, 54, 55,
   56, 57, 58, 59, 60, 61, 62, 63,
   64, 97, 98, 99,100,101,102,103,
  104,105,106,107,108,109,110,111,
  112,113,114,115,116,117,118,119,
  120,121,122, 91, 92, 93, 94, 95,
   96, 65, 66, 67, 68, 69, 70, 71,
   72, 73, 74, 75, 76, 77, 78, 79,
   80, 81, 82, 83, 84, 85, 86, 87,
   88, 89, 90,123,124,125,126,127,
  128,129,130,131,132,133,134,135,
  136,137,138,139,140,141,142,143,
  144,145,146,147,148,149,150,151,
  152,153,154,155,156,157,158,159,
  160,161,162,163,164,165,166,167,
  168,169,170,171,172,173,174,175,
  176,177,178,179,180,181,182,183,
  184,185,186,187,188,189,190,191,
  192,193,194,195,196,197,198,199,
  200,201,202,203,204,205,206,207,
  208,209,210,211,212,213,214,215,
  216,217,218,219,220,221,222,223,
  224,225,226,227,228,229,230,231,
  232,233,234,235,236,237,238,239,
  240,241,242,243,244,245,246,247,
  248,249,250,251,252,253,254,255,

/* This table contains bit maps for various character classes. Each map is 32
bytes long and the bits run from the least significant end of each byte. The
classes that have their own maps are: space, xdigit, digit, upper, lower, word,
graph, print, punct, and cntrl. Other classes are built from combinations. */

  0x00,0x3e,0x00,0x00,0x01,0x00,0x00,0x00,  /* space */
  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,

  0x00,0x00,0x00,0x00,0x00,0x00,0xff,0x03,  /* xdigit */
  0x7e,0x00,0x00,0x00,0x7e,0x00,0x00,0x00,
  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,

  0x00,0x00,0x00,0x00,0x00,0x00,0xff,0x03,  /* digit */
  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,

  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,  /* upper */
  0xfe,0xff,0xff,0x07,0x00,0x00,0x00,0x00,
  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,

  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,  /* lower */
  0x00,0x00,0x00,0x00,0xfe,0xff,0xff,0x07,
  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,

  0x00,0x00,0x00,0x00,0x00,0x00,0xff,0x03,  /* word */
  0xfe,0xff,0xff,0x87,0xfe,0xff,0xff,0x07,
  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,

  0x00,0x00,0x00,0x00,0xfe,0xff,0xff,0xff,  /* graph */
  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x7f,
  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,

  0x00,0x00,0x00,0x00,0xff,0xff,0xff,0xff,  /* print */
  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x7f,
  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,

  0x00,0x00,0x00,0x00,0xfe,0xff,0x00,0xfc,  /* punct */
  0x01,0x00,0x00,0xf8,0x01,0x00,0x00,0x78,
  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,

  0xff,0xff,0xff,0xff,0x00,0x00,0x00,0x00,  /* cntrl */
  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x80,
  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,

/* This table identifies various classes of character by individual bits:
  0x01   white space character
  0x02   letter
  0x04   lower case letter
  0x08   decimal digit
  0x10   word (alphanumeric or '_')
*/

  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*   0-  7 */
  0x00,0x01,0x01,0x01,0x01,0x01,0x00,0x00, /*   8- 15 */
  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  16- 23 */
  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  24- 31 */
  0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*    - '  */
  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  ( - /  */
  0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18, /*  0 - 7  */
  0x18,0x18,0x00,0x00,0x00,0x00,0x00,0x00, /*  8 - ?  */
  0x00,0x12,0x12,0x12,0x12,0x12,0x12,0x12, /*  @ - G  */
  0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12, /*  H - O  */
  0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12, /*  P - W  */
  0x12,0x12,0x12,0x00,0x00,0x00,0x00,0x10, /*  X - _  */
  0x00,0x16,0x16,0x16,0x16,0x16,0x16,0x16, /*  ` - g  */
  0x16,0x16,0x16,0x16,0x16,0x16,0x16,0x16, /*  h - o  */
  0x16,0x16,0x16,0x16,0x16,0x16,0x16,0x16, /*  p - w  */
  0x16,0x16,0x16,0x00,0x00,0x00,0x00,0x00, /*  x -127 */
  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 128-135 */
  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 136-143 */
  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 144-151 */
  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 152-159 */
  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 160-167 */
  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 168-175 */
  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 176-183 */
  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 184-191 */
  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 192-199 */
  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 200-207 */
  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 208-215 */
  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 216-223 */
  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 224-231 */
  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 232-239 */
  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 240-247 */
  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};/* 248-255 */

/* End of pcre2_chartables.c */


================================================
FILE: Libraries/PCRE/pcre2_chkdint.c
================================================
/*************************************************
*      Perl-Compatible Regular Expressions       *
*************************************************/

/* PCRE is a library of functions to support regular expressions whose syntax
and semantics are as close as possible to those of the Perl 5 language.

                     Written by Philip Hazel
            Copyright (c) 2023 University of Cambridge

-----------------------------------------------------------------------------
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

    * Redistributions of source code must retain the above copyright notice,
      this list of conditions and the following disclaimer.

    * Redistributions in binary form must reproduce the above copyright
      notice, this list of conditions and the following disclaimer in the
      documentation and/or other materials provided with the distribution.

    * Neither the name of the University of Cambridge nor the names of its
      contributors may be used to endorse or promote products derived from
      this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
-----------------------------------------------------------------------------
*/

/* This file contains functions to implement checked integer operation */

#ifndef PCRE2_PCRE2TEST
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include "pcre2_internal.h"
#endif

/*************************************************
*        Checked Integer Multiplication          *
*************************************************/

/*
Arguments:
  r         A pointer to PCRE2_SIZE to store the answer
  a, b      Two integers

Returns:    Bool indicating if the operation overflows

It is modeled after C23's <stdckdint.h> interface
The INT64_OR_DOUBLE type is a 64-bit integer type when available,
otherwise double. */

BOOL
PRIV(ckd_smul)(PCRE2_SIZE *r, int a, int b)
{
#ifdef HAVE_BUILTIN_MUL_OVERFLOW
PCRE2_SIZE m;

if (__builtin_mul_overflow(a, b, &m)) return TRUE;

*r = m;
#else
INT64_OR_DOUBLE m;

PCRE2_ASSERT(a >= 0 && b >= 0);

m = (INT64_OR_DOUBLE)a * (INT64_OR_DOUBLE)b;

#if defined INT64_MAX || defined int64_t
if (sizeof(m) > sizeof(*r) && m > (INT64_OR_DOUBLE)PCRE2_SIZE_MAX) return TRUE;
*r = (PCRE2_SIZE)m;
#else
if (m > PCRE2_SIZE_MAX) return TRUE;
*r = m;
#endif

#endif

return FALSE;
}

/* End of pcre2_chkdint.c */


================================================
FILE: Libraries/PCRE/pcre2_compile.c
================================================
/*************************************************
*      Perl-Compatible Regular Expressions       *
*************************************************/

/* PCRE is a library of functions to support regular expressions whose syntax
and semantics are as close as possible to those of the Perl 5 language.

                       Written by Philip Hazel
     Original API code Copyright (c) 1997-2012 University of Cambridge
          New API code Copyright (c) 2016-2024 University of Cambridge

-----------------------------------------------------------------------------
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

    * Redistributions of source code must retain the above copyright notice,
      this list of conditions and the following disclaimer.

    * Redistributions in binary form must reproduce the above copyright
      notice, this list of conditions and the following disclaimer in the
      documentation and/or other materials provided with the distribution.

    * Neither the name of the University of Cambridge nor the names of its
      contributors may be used to endorse or promote products derived from
      this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
-----------------------------------------------------------------------------
*/


#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#define NLBLOCK cb             /* Block containing newline information */
#define PSSTART start_pattern  /* Field containing processed string start */
#define PSEND   end_pattern    /* Field containing processed string end */

#include "pcre2_compile.h"

/* In rare error cases debugging might require calling pcre2_printint(). */

#if 0
#ifdef EBCDIC
#define PRINTABLE(c) ((c) >= 64 && (c) < 255)
#else
#define PRINTABLE(c) ((c) >= 32 && (c) < 127)
#endif
#include "pcre2_printint.c"
#define DEBUG_CALL_PRINTINT
#endif

/* Other debugging code can be enabled by these defines. */

/* #define DEBUG_SHOW_CAPTURES */
/* #define DEBUG_SHOW_PARSED */

/* There are a few things that vary with different code unit sizes. Handle them
by defining macros in order to minimize #if usage. */

#if PCRE2_CODE_UNIT_WIDTH == 8
#define STRING_UTFn_RIGHTPAR     STRING_UTF8_RIGHTPAR, 5
#define XDIGIT(c)                xdigitab[c]

#else  /* Either 16-bit or 32-bit */
#define XDIGIT(c)                (MAX_255(c)? xdigitab[c] : 0xff)

#if PCRE2_CODE_UNIT_WIDTH == 16
#define STRING_UTFn_RIGHTPAR     STRING_UTF16_RIGHTPAR, 6

#else  /* 32-bit */
#define STRING_UTFn_RIGHTPAR     STRING_UTF32_RIGHTPAR, 6
#endif
#endif

/* Macros to store and retrieve a PCRE2_SIZE value in the parsed pattern, which
consists of uint32_t elements. Assume that if uint32_t can't hold it, two of
them will be able to (i.e. assume a 64-bit world). */

#if PCRE2_SIZE_MAX <= UINT32_MAX
#define PUTOFFSET(s,p) *p++ = s
#define GETOFFSET(s,p) s = *p++
#define GETPLUSOFFSET(s,p) s = *(++p)
#define READPLUSOFFSET(s,p) s = p[1]
#define SKIPOFFSET(p) p++
#define SIZEOFFSET 1
#else
#define PUTOFFSET(s,p) \
  { *p++ = (uint32_t)(s >> 32); *p++ = (uint32_t)(s & 0xffffffff); }
#define GETOFFSET(s,p) \
  { s = ((PCRE2_SIZE)p[0] << 32) | (PCRE2_SIZE)p[1]; p += 2; }
#define GETPLUSOFFSET(s,p) \
  { s = ((PCRE2_SIZE)p[1] << 32) | (PCRE2_SIZE)p[2]; p += 2; }
#define READPLUSOFFSET(s,p) \
  { s = ((PCRE2_SIZE)p[1] << 32) | (PCRE2_SIZE)p[2]; }
#define SKIPOFFSET(p) p += 2
#define SIZEOFFSET 2
#endif

/* Function definitions to allow mutual recursion */

static int
  compile_regex(uint32_t, uint32_t, PCRE2_UCHAR **, uint32_t **, int *,
    uint32_t, uint32_t *, uint32_t *, uint32_t *, uint32_t *, branch_chain *,
    open_capitem *, compile_block *, PCRE2_SIZE *);

static int
  get_branchlength(uint32_t **, int *, int *, int *, parsed_recurse_check *,
    compile_block *);

static BOOL
  set_lookbehind_lengths(uint32_t **, int *, int *, parsed_recurse_check *,
    compile_block *);

static int
  check_lookbehinds(uint32_t *, uint32_t **, parsed_recurse_check *,
    compile_block *, int *);


/*************************************************
*      Code parameters and static tables         *
*************************************************/

#define MAX_GROUP_NUMBER   65535u
#define MAX_REPEAT_COUNT   65535u
#define REPEAT_UNLIMITED   (MAX_REPEAT_COUNT+1)

/* COMPILE_WORK_SIZE specifies the size of stack workspace, which is used in
different ways in the different pattern scans. The parsing and group-
identifying pre-scan uses it to handle nesting, and needs it to be 16-bit
aligned for this. Having defined the size in code units, we set up
C16_WORK_SIZE as the number of elements in the 16-bit vector.

During the first compiling phase, when determining how much memory is required,
the regex is partly compiled into this space, but the compiled parts are
discarded as soon as they can be, so that hopefully there will never be an
overrun. The code does, however, check for an overrun, which can occur for
pathological patterns. The size of the workspace depends on LINK_SIZE because
the length of compiled items varies with this.

In the real compile phase, this workspace is not currently used. */

#define COMPILE_WORK_SIZE (3000*LINK_SIZE)   /* Size in code units */

#define C16_WORK_SIZE \
  ((COMPILE_WORK_SIZE * sizeof(PCRE2_UCHAR))/sizeof(uint16_t))

/* A uint32_t vector is used for caching information about the size of
capturing groups, to improve performance. A default is created on the stack of
this size. */

#define GROUPINFO_DEFAULT_SIZE 256

/* The overrun tests check for a slightly smaller size so that they detect the
overrun before it actually does run off the end of the data block. */

#define WORK_SIZE_SAFETY_MARGIN (100)

/* This value determines the size of the initial vector that is used for
remembering named groups during the pre-compile. It is allocated on the stack,
but if it is too small, it is expanded, in a similar way to the workspace. The
value is the number of slots in the list. */

#define NAMED_GROUP_LIST_SIZE  20

/* The pre-compiling pass over the pattern creates a parsed pattern in a vector
of uint32_t. For short patterns this lives on the stack, with this size. Heap
memory is used for longer patterns. */

#define PARSED_PATTERN_DEFAULT_SIZE 1024

/* Maximum length value to check against when making sure that the variable
that holds the compiled pattern length does not overflow. We make it a bit less
than INT_MAX to allow for adding in group terminating code units, so that we
don't have to check them every time. */

#define OFLOW_MAX (INT_MAX - 20)

/* Table of extra lengths for each of the meta codes. Must be kept in step with
the definitions above. For some items these values are a basic length to which
a variable amount has to be added. */

static unsigned char meta_extra_lengths[] = {
  0,             /* META_END */
  0,             /* META_ALT */
  0,             /* META_ATOMIC */
  0,             /* META_BACKREF - more if group is >= 10 */
  1+SIZEOFFSET,  /* META_BACKREF_BYNAME */
  1,             /* META_BIGVALUE */
  3,             /* META_CALLOUT_NUMBER */
  3+SIZEOFFSET,  /* META_CALLOUT_STRING */
  0,             /* META_CAPTURE */
  0,             /* META_CIRCUMFLEX */
  0,             /* META_CLASS */
  0,             /* META_CLASS_EMPTY */
  0,             /* META_CLASS_EMPTY_NOT */
  0,             /* META_CLASS_END */
  0,             /* META_CLASS_NOT */
  0,             /* META_COND_ASSERT */
  SIZEOFFSET,    /* META_COND_DEFINE */
  1+SIZEOFFSET,  /* META_COND_NAME */
  1+SIZEOFFSET,  /* META_COND_NUMBER */
  1+SIZEOFFSET,  /* META_COND_RNAME */
  1+SIZEOFFSET,  /* META_COND_RNUMBER */
  3,             /* META_COND_VERSION */
  SIZEOFFSET,    /* META_OFFSET */
  0,             /* META_SCS */
  1,             /* META_SCS_NAME */
  1,             /* META_SCS_NUMBER */
  0,             /* META_DOLLAR */
  0,             /* META_DOT */
  0,             /* META_ESCAPE - one more for ESC_P and ESC_p */
  0,             /* META_KET */
  0,             /* META_NOCAPTURE */
  2,             /* META_OPTIONS */
  1,             /* META_POSIX */
  1,             /* META_POSIX_NEG */
  0,             /* META_RANGE_ESCAPED */
  0,             /* META_RANGE_LITERAL */
  SIZEOFFSET,    /* META_RECURSE */
  1+SIZEOFFSET,  /* META_RECURSE_BYNAME */
  0,             /* META_SCRIPT_RUN */
  0,             /* META_LOOKAHEAD */
  0,             /* META_LOOKAHEADNOT */
  SIZEOFFSET,    /* META_LOOKBEHIND */
  SIZEOFFSET,    /* META_LOOKBEHINDNOT */
  0,             /* META_LOOKAHEAD_NA */
  SIZEOFFSET,    /* META_LOOKBEHIND_NA */
  1,             /* META_MARK - plus the string length */
  0,             /* META_ACCEPT */
  0,             /* META_FAIL */
  0,             /* META_COMMIT */
  1,             /* META_COMMIT_ARG - plus the string length */
  0,             /* META_PRUNE */
  1,             /* META_PRUNE_ARG - plus the string length */
  0,             /* META_SKIP */
  1,             /* META_SKIP_ARG - plus the string length */
  0,             /* META_THEN */
  1,             /* META_THEN_ARG - plus the string length */
  0,             /* META_ASTERISK */
  0,             /* META_ASTERISK_PLUS */
  0,             /* META_ASTERISK_QUERY */
  0,             /* META_PLUS */
  0,             /* META_PLUS_PLUS */
  0,             /* META_PLUS_QUERY */
  0,             /* META_QUERY */
  0,             /* META_QUERY_PLUS */
  0,             /* META_QUERY_QUERY */
  2,             /* META_MINMAX */
  2,             /* META_MINMAX_PLUS */
  2,             /* META_MINMAX_QUERY */
  0,             /* META_ECLASS_AND */
  0,             /* META_ECLASS_OR */
  0,             /* META_ECLASS_SUB */
  0,             /* META_ECLASS_XOR */
  0              /* META_ECLASS_NOT */
};

/* Types for skipping parts of a parsed pattern. */

enum { PSKIP_ALT, PSKIP_CLASS, PSKIP_KET };

/* Values and flags for the unsigned xxcuflags variables that accompany xxcu
variables, which are concerned with first and required code units. A value
greater than or equal to REQ_NONE means "no code unit set"; otherwise the
matching xxcu variable is set, and the low valued bits are relevant. */

#define REQ_UNSET     0xffffffffu  /* Not yet found anything */
#define REQ_NONE      0xfffffffeu  /* Found not fixed character */
#define REQ_CASELESS  0x00000001u  /* Code unit in xxcu is caseless */
#define REQ_VARY      0x00000002u  /* Code unit is followed by non-literal */

/* These flags are used in the groupinfo vector. */

#define GI_SET_FIXED_LENGTH    0x80000000u
#define GI_NOT_FIXED_LENGTH    0x40000000u
#define GI_FIXED_LENGTH_MASK   0x0000ffffu

/* This simple test for a decimal digit works for both ASCII/Unicode and EBCDIC
and is fast (a good compiler can turn it into a subtraction and unsigned
comparison). */

#define IS_DIGIT(x) ((x) >= CHAR_0 && (x) <= CHAR_9)

/* Table to identify hex digits. The tables in chartables are dependent on the
locale, and may mark arbitrary characters as digits. We want to recognize only
0-9, a-z, and A-Z as hex digits, which is why we have a private table here. It
costs 256 bytes, but it is a lot faster than doing character value tests (at
least in some simple cases I timed), and in some applications one wants PCRE2
to compile efficiently as well as match efficiently. The value in the table is
the binary hex digit value, or 0xff for non-hex digits. */

/* This is the "normal" case, for ASCII systems, and EBCDIC systems running in
UTF-8 mode. */

#ifndef EBCDIC
static const uint8_t xdigitab[] =
  {
  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*   0-  7 */
  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*   8- 15 */
  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*  16- 23 */
  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*  24- 31 */
  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*    - '  */
  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*  ( - /  */
  0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07, /*  0 - 7  */
  0x08,0x09,0xff,0xff,0xff,0xff,0xff,0xff, /*  8 - ?  */
  0xff,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,0xff, /*  @ - G  */
  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*  H - O  */
  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*  P - W  */
  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*  X - _  */
  0xff,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,0xff, /*  ` - g  */
  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*  h - o  */
  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*  p - w  */
  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*  x -127 */
  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /* 128-135 */
  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /* 136-143 */
  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /* 144-151 */
  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /* 152-159 */
  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /* 160-167 */
  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /* 168-175 */
  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /* 176-183 */
  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /* 184-191 */
  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /* 192-199 */
  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /* 2ff-207 */
  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /* 208-215 */
  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /* 216-223 */
  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /* 224-231 */
  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /* 232-239 */
  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /* 240-247 */
  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff};/* 248-255 */

#else

/* This is the "abnormal" case, for EBCDIC systems not running in UTF-8 mode. */

static const uint8_t xdigitab[] =
  {
  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*   0-  7  0 */
  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*   8- 15    */
  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*  16- 23 10 */
  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*  24- 31    */
  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*  32- 39 20 */
  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*  40- 47    */
  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*  48- 55 30 */
  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*  56- 63    */
  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*    - 71 40 */
  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*  72- |     */
  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*  & - 87 50 */
  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*  88- 95    */
  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*  - -103 60 */
  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /* 104- ?     */
  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /* 112-119 70 */
  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /* 120- "     */
  0xff,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,0xff, /* 128- g  80 */
  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*  h -143    */
  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /* 144- p  90 */
  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*  q -159    */
  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /* 160- x  A0 */
  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*  y -175    */
  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*  ^ -183 B0 */
  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /* 184-191    */
  0xff,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,0xff, /*  { - G  C0 */
  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*  H -207    */
  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*  } - P  D0 */
  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*  Q -223    */
  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*  \ - X  E0 */
  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /*  Y -239    */
  0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07, /*  0 - 7  F0 */
  0x08,0x09,0xff,0xff,0xff,0xff,0xff,0xff};/*  8 -255    */
#endif  /* EBCDIC */


/* Table for handling alphanumeric escaped characters. Positive returns are
simple data values; negative values are for special things like \d and so on.
Zero means further processing is needed (for things like \x), or the escape is
invalid. */

/* This is the "normal" table for ASCII systems or for EBCDIC systems running
in UTF-8 mode. It runs from '0' to 'z'. */

#ifndef EBCDIC
#define ESCAPES_FIRST       CHAR_0
#define ESCAPES_LAST        CHAR_z
#define UPPER_CASE(c)       (c-32)

static const short int escapes[] = {
    /* 0 */ 0,                       /* 1 */ 0,
    /* 2 */ 0,                       /* 3 */ 0,
    /* 4 */ 0,                       /* 5 */ 0,
    /* 6 */ 0,                       /* 7 */ 0,
    /* 8 */ 0,                       /* 9 */ 0,
    /* : */ CHAR_COLON,              /* ; */ CHAR_SEMICOLON,
    /* < */ CHAR_LESS_THAN_SIGN,     /* = */ CHAR_EQUALS_SIGN,
    /* > */ CHAR_GREATER_THAN_SIGN,  /* ? */ CHAR_QUESTION_MARK,
    /* @ */ CHAR_COMMERCIAL_AT,      /* A */ -ESC_A,
    /* B */ -ESC_B,                  /* C */ -ESC_C,
    /* D */ -ESC_D,                  /* E */ -ESC_E,
    /* F */ 0,                       /* G */ -ESC_G,
    /* H */ -ESC_H,                  /* I */ 0,
    /* J */ 0,                       /* K */ -ESC_K,
    /* L */ 0,                       /* M */ 0,
    /* N */ -ESC_N,                  /* O */ 0,
    /* P */ -ESC_P,                  /* Q */ -ESC_Q,
    /* R */ -ESC_R,                  /* S */ -ESC_S,
    /* T */ 0,                       /* U */ 0,
    /* V */ -ESC_V,                  /* W */ -ESC_W,
    /* X */ -ESC_X,                  /* Y */ 0,
    /* Z */ -ESC_Z,                  /* [ */ CHAR_LEFT_SQUARE_BRACKET,
    /* \ */ CHAR_BACKSLASH,          /* ] */ CHAR_RIGHT_SQUARE_BRACKET,
    /* ^ */ CHAR_CIRCUMFLEX_ACCENT,  /* _ */ CHAR_UNDERSCORE,
    /* ` */ CHAR_GRAVE_ACCENT,       /* a */ CHAR_BEL,
    /* b */ -ESC_b,                  /* c */ 0,
    /* d */ -ESC_d,                  /* e */ CHAR_ESC,
    /* f */ CHAR_FF,                 /* g */ 0,
    /* h */ -ESC_h,                  /* i */ 0,
    /* j */ 0,                       /* k */ -ESC_k,
    /* l */ 0,                       /* m */ 0,
    /* n */ CHAR_LF,                 /* o */ 0,
    /* p */ -ESC_p,                  /* q */ 0,
    /* r */ CHAR_CR,                 /* s */ -ESC_s,
    /* t */ CHAR_HT,                 /* u */ 0,
    /* v */ -ESC_v,                  /* w */ -ESC_w,
    /* x */ 0,                       /* y */ 0,
    /* z */ -ESC_z
};

#else

/* This is the "abnormal" table for EBCDIC systems without UTF-8 support.
It runs from 'a' to '9'. For some minimal testing of EBCDIC features, the code
is sometimes compiled on an ASCII system. In this case, we must not use CHAR_a
because it is defined as 'a', which of course picks up the ASCII value. */

#if 'a' == 0x81                    /* Check for a real EBCDIC environment */
#define ESCAPES_FIRST       CHAR_a
#define ESCAPES_LAST        CHAR_9
#define UPPER_CASE(c)       (c+64)
#else                              /* Testing in an ASCII environment */
#define ESCAPES_FIRST  ((unsigned char)'\x81')   /* EBCDIC 'a' */
#define ESCAPES_LAST   ((unsigned char)'\xf9')   /* EBCDIC '9' */
#define UPPER_CASE(c)  (c-32)
#endif

static const short int escapes[] = {
/*  80 */         CHAR_BEL, -ESC_b,       0, -ESC_d, CHAR_ESC, CHAR_FF,      0,
/*  88 */ -ESC_h,        0,      0,     '{',      0,        0,       0,      0,
/*  90 */      0,        0, -ESC_k,       0,      0,  CHAR_LF,       0, -ESC_p,
/*  98 */      0,  CHAR_CR,      0,     '}',      0,        0,       0,      0,
/*  A0 */      0,      '~', -ESC_s, CHAR_HT,      0,   -ESC_v,  -ESC_w,      0,
/*  A8 */      0,   -ESC_z,      0,       0,      0,      '[',       0,      0,
/*  B0 */      0,        0,      0,       0,      0,        0,       0,      0,
/*  B8 */      0,        0,      0,       0,      0,      ']',     '=',    '-',
/*  C0 */    '{',   -ESC_A, -ESC_B,  -ESC_C, -ESC_D,   -ESC_E,       0, -ESC_G,
/*  C8 */ -ESC_H,        0,      0,       0,      0,        0,       0,      0,
/*  D0 */    '}',        0, -ESC_K,       0,      0,   -ESC_N,       0, -ESC_P,
/*  D8 */ -ESC_Q,   -ESC_R,      0,       0,      0,        0,       0,      0,
/*  E0 */   '\\',        0, -ESC_S,       0,      0,   -ESC_V,  -ESC_W, -ESC_X,
/*  E8 */      0,   -ESC_Z,      0,       0,      0,        0,       0,      0,
/*  F0 */      0,        0,      0,       0,      0,        0,       0,      0,
/*  F8 */      0,        0
};

/* We also need a table of characters that may follow \c in an EBCDIC
environment for characters 0-31. */

static unsigned char ebcdic_escape_c[] = "@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_";

#endif   /* EBCDIC */


/* Table of special "verbs" like (*PRUNE). This is a short table, so it is
searched linearly. Put all the names into a single string, in order to reduce
the number of relocations when a shared library is dynamically linked. The
string is built from string macros so that it works in UTF-8 mode on EBCDIC
platforms. */

typedef struct verbitem {
  unsigned int len;          /* Length of verb name */
  uint32_t meta;             /* Base META_ code */
  int has_arg;               /* Argument requirement */
} verbitem;

static const char verbnames[] =
  "\0"                       /* Empty name is a shorthand for MARK */
  STRING_MARK0
  STRING_ACCEPT0
  STRING_F0
  STRING_FAIL0
  STRING_COMMIT0
  STRING_PRUNE0
  STRING_SKIP0
  STRING_THEN;

static const verbitem verbs[] = {
  { 0, META_MARK,   +1 },  /* > 0 => must have an argument */
  { 4, META_MARK,   +1 },
  { 6, META_ACCEPT, -1 },  /* < 0 => Optional argument, convert to pre-MARK */
  { 1, META_FAIL,   -1 },
  { 4, META_FAIL,   -1 },
  { 6, META_COMMIT,  0 },
  { 5, META_PRUNE,   0 },  /* Optional argument; bump META code if found */
  { 4, META_SKIP,    0 },
  { 4, META_THEN,    0 }
};

static const int verbcount = sizeof(verbs)/sizeof(verbitem);

/* Verb opcodes, indexed by their META code offset from META_MARK. */

static const uint32_t verbops[] = {
  OP_MARK, OP_ACCEPT, OP_FAIL, OP_COMMIT, OP_COMMIT_ARG, OP_PRUNE,
  OP_PRUNE_ARG, OP_SKIP, OP_SKIP_ARG, OP_THEN, OP_THEN_ARG };

/* Table of "alpha assertions" like (*pla:...), similar to the (*VERB) table. */

typedef struct alasitem {
  unsigned int len;          /* Length of name */
  uint32_t meta;             /* Base META_ code */
} alasitem;

static const char alasnames[] =
  STRING_pla0
  STRING_plb0
  STRING_napla0
  STRING_naplb0
  STRING_nla0
  STRING_nlb0
  STRING_positive_lookahead0
  STRING_positive_lookbehind0
  STRING_non_atomic_positive_lookahead0
  STRING_non_atomic_positive_lookbehind0
  STRING_negative_lookahead0
  STRING_negative_lookbehind0
  STRING_scs0
  STRING_scan_substring0
  STRING_atomic0
  STRING_sr0
  STRING_asr0
  STRING_script_run0
  STRING_atomic_script_run;

static const alasitem alasmeta[] = {
  {  3, META_LOOKAHEAD         },
  {  3, META_LOOKBEHIND        },
  {  5, META_LOOKAHEAD_NA      },
  {  5, META_LOOKBEHIND_NA     },
  {  3, META_LOOKAHEADNOT      },
  {  3, META_LOOKBEHINDNOT     },
  { 18, META_LOOKAHEAD         },
  { 19, META_LOOKBEHIND        },
  { 29, META_LOOKAHEAD_NA      },
  { 30, META_LOOKBEHIND_NA     },
  { 18, META_LOOKAHEADNOT      },
  { 19, META_LOOKBEHINDNOT     },
  {  3, META_SCS               },
  { 14, META_SCS               },
  {  6, META_ATOMIC            },
  {  2, META_SCRIPT_RUN        }, /* sr = script run */
  {  3, META_ATOMIC_SCRIPT_RUN }, /* asr = atomic script run */
  { 10, META_SCRIPT_RUN        }, /* script run */
  { 17, META_ATOMIC_SCRIPT_RUN }  /* atomic script run */
};

static const int alascount = sizeof(alasmeta)/sizeof(alasitem);

/* Offsets from OP_STAR for case-independent and negative repeat opcodes. */

static uint32_t chartypeoffset[] = {
  OP_STAR - OP_STAR,    OP_STARI - OP_STAR,
  OP_NOTSTAR - OP_STAR, OP_NOTSTARI - OP_STAR };

/* Tables of names of POSIX character classes and their lengths. The names are
now all in a single string, to reduce the number of relocations when a shared
library is dynamically loaded. The list of lengths is terminated by a zero
length entry. The first three must be alpha, lower, upper, as this is assumed
for handling case independence.

The indices for several classes are stored in pcre2_compile.h - these must
be kept in sync with posix_names, posix_name_lengths, posix_class_maps,
and posix_substitutes. */

static const char posix_names[] =
  STRING_alpha0 STRING_lower0 STRING_upper0 STRING_alnum0
  STRING_ascii0 STRING_blank0 STRING_cntrl0 STRING_digit0
  STRING_graph0 STRING_print0 STRING_punct0 STRING_space0
  STRING_word0  STRING_xdigit;

static const uint8_t posix_name_lengths[] = {
  5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 4, 6, 0 };

/* Table of class bit maps for each POSIX class. Each class is formed from a
base map, with an optional addition or removal of another map. Then, for some
classes, there is some additional tweaking: for [:blank:] the vertical space
characters are removed, and for [:alpha:] and [:alnum:] the underscore
character is removed. The triples in the table consist of the base map offset,
second map offset or -1 if no second map, and a non-negative value for map
addition or a negative value for map subtraction (if there are two maps). The
absolute value of the third field has these meanings: 0 => no tweaking, 1 =>
remove vertical space characters, 2 => remove underscore. */

const int PRIV(posix_class_maps)[] = {
  cbit_word,   cbit_digit, -2,            /* alpha */
  cbit_lower,  -1,          0,            /* lower */
  cbit_upper,  -1,          0,            /* upper */
  cbit_word,   -1,          2,            /* alnum - word without underscore */
  cbit_print,  cbit_cntrl,  0,            /* ascii */
  cbit_space,  -1,          1,            /* blank - a GNU extension */
  cbit_cntrl,  -1,          0,            /* cntrl */
  cbit_digit,  -1,          0,            /* digit */
  cbit_graph,  -1,          0,            /* graph */
  cbit_print,  -1,          0,            /* print */
  cbit_punct,  -1,          0,            /* punct */
  cbit_space,  -1,          0,            /* space */
  cbit_word,   -1,          0,            /* word - a Perl extension */
  cbit_xdigit, -1,          0             /* xdigit */
};

#ifdef SUPPORT_UNICODE

/* The POSIX class Unicode property substitutes that are used in UCP mode must
be in the order of the POSIX class names, defined above. */

static int posix_substitutes[] = {
  PT_GC, ucp_L,     /* alpha */
  PT_PC, ucp_Ll,    /* lower */
  PT_PC, ucp_Lu,    /* upper */
  PT_ALNUM, 0,      /* alnum */
  -1, 0,            /* ascii, treat as non-UCP */
  -1, 1,            /* blank, treat as \h */
  PT_PC, ucp_Cc,    /* cntrl */
  PT_PC, ucp_Nd,    /* digit */
  PT_PXGRAPH, 0,    /* graph */
  PT_PXPRINT, 0,    /* print */
  PT_PXPUNCT, 0,    /* punct */
  PT_PXSPACE, 0,    /* space */   /* Xps is POSIX space, but from 8.34 */
  PT_WORD, 0,       /* word  */   /* Perl and POSIX space are the same */
  PT_PXXDIGIT, 0    /* xdigit */  /* Perl has additional hex digits */
};
#endif  /* SUPPORT_UNICODE */

/* Masks for checking option settings. When PCRE2_LITERAL is set, only a subset
are allowed. */

#define PUBLIC_LITERAL_COMPILE_OPTIONS \
  (PCRE2_ANCHORED|PCRE2_AUTO_CALLOUT|PCRE2_CASELESS|PCRE2_ENDANCHORED| \
   PCRE2_FIRSTLINE|PCRE2_LITERAL|PCRE2_MATCH_INVALID_UTF| \
   PCRE2_NO_START_OPTIMIZE|PCRE2_NO_UTF_CHECK|PCRE2_USE_OFFSET_LIMIT|PCRE2_UTF)

#define PUBLIC_COMPILE_OPTIONS \
  (PUBLIC_LITERAL_COMPILE_OPTIONS| \
   PCRE2_ALLOW_EMPTY_CLASS|PCRE2_ALT_BSUX|PCRE2_ALT_CIRCUMFLEX| \
   PCRE2_ALT_VERBNAMES|PCRE2_DOLLAR_ENDONLY|PCRE2_DOTALL|PCRE2_DUPNAMES| \
   PCRE2_EXTENDED|PCRE2_EXTENDED_MORE|PCRE2_MATCH_UNSET_BACKREF| \
   PCRE2_MULTILINE|PCRE2_NEVER_BACKSLASH_C|PCRE2_NEVER_UCP| \
   PCRE2_NEVER_UTF|PCRE2_NO_AUTO_CAPTURE|PCRE2_NO_AUTO_POSSESS| \
   PCRE2_NO_DOTSTAR_ANCHOR|PCRE2_UCP|PCRE2_UNGREEDY|PCRE2_ALT_EXTENDED_CLASS)

#define PUBLIC_LITERAL_COMPILE_EXTRA_OPTIONS \
   (PCRE2_EXTRA_MATCH_LINE|PCRE2_EXTRA_MATCH_WORD| \
    PCRE2_EXTRA_CASELESS_RESTRICT|PCRE2_EXTRA_TURKISH_CASING)

#define PUBLIC_COMPILE_EXTRA_OPTIONS \
   (PUBLIC_LITERAL_COMPILE_EXTRA_OPTIONS| \
    PCRE2_EXTRA_ALLOW_SURROGATE_ESCAPES|PCRE2_EXTRA_BAD_ESCAPE_IS_LITERAL| \
    PCRE2_EXTRA_ESCAPED_CR_IS_LF|PCRE2_EXTRA_ALT_BSUX| \
    PCRE2_EXTRA_ALLOW_LOOKAROUND_BSK|PCRE2_EXTRA_ASCII_BSD| \
    PCRE2_EXTRA_ASCII_BSS|PCRE2_EXTRA_ASCII_BSW|PCRE2_EXTRA_ASCII_POSIX| \
    PCRE2_EXTRA_ASCII_DIGIT|PCRE2_EXTRA_PYTHON_OCTAL|PCRE2_EXTRA_NO_BS0| \
    PCRE2_EXTRA_NEVER_CALLOUT)

/* This is a table of start-of-pattern options such as (*UTF) and settings such
as (*LIMIT_MATCH=nnnn) and (*CRLF). For completeness and backward
compatibility, (*UTFn) is supported in the relevant libraries, but (*UTF) is
generic and always supported. */

enum { PSO_OPT,     /* Value is an option bit */
       PSO_XOPT,    /* Value is an xoption bit */
       PSO_FLG,     /* Value is a flag bit */
       PSO_NL,      /* Value is a newline type */
       PSO_BSR,     /* Value is a \R type */
       PSO_LIMH,    /* Read integer value for heap limit */
       PSO_LIMM,    /* Read integer value for match limit */
       PSO_LIMD,    /* Read integer value for depth limit */
       PSO_OPTMZ    /* Value is an optimization bit */
     };

typedef struct pso {
  const char *name;
  uint16_t length;
  uint16_t type;
  uint32_t value;
} pso;

/* NB: STRING_UTFn_RIGHTPAR contains the length as well */

static const pso pso_list[] = {
  { STRING_UTFn_RIGHTPAR,                  PSO_OPT, PCRE2_UTF },
  { STRING_UTF_RIGHTPAR,                4, PSO_OPT, PCRE2_UTF },
  { STRING_UCP_RIGHTPAR,                4, PSO_OPT, PCRE2_UCP },
  { STRING_EC_RIGHTPAR,                 3, PSO_OPT, PCRE2_ALT_EXTENDED_CLASS }, //au
  { STRING_NOTEMPTY_RIGHTPAR,           9, PSO_FLG, PCRE2_NOTEMPTY_SET },
  { STRING_NOTEMPTY_ATSTART_RIGHTPAR,  17, PSO_FLG, PCRE2_NE_ATST_SET },
  { STRING_NO_AUTO_POSSESS_RIGHTPAR,   16, PSO_OPTMZ, PCRE2_OPTIM_AUTO_POSSESS },
  { STRING_NO_DOTSTAR_ANCHOR_RIGHTPAR, 18, PSO_OPTMZ, PCRE2_OPTIM_DOTSTAR_ANCHOR },
  { STRING_NO_JIT_RIGHTPAR,             7, PSO_FLG, PCRE2_NOJIT },
  { STRING_NO_START_OPT_RIGHTPAR,      13, PSO_OPTMZ, PCRE2_OPTIM_START_OPTIMIZE },
  { STRING_CASELESS_RESTRICT_RIGHTPAR, 18, PSO_XOPT, PCRE2_EXTRA_CASELESS_RESTRICT },
  { STRING_TURKISH_CASING_RIGHTPAR,    15, PSO_XOPT, PCRE2_EXTRA_TURKISH_CASING },
  { STRING_LIMIT_HEAP_EQ,              11, PSO_LIMH, 0 },
  { STRING_LIMIT_MATCH_EQ,             12, PSO_LIMM, 0 },
  { STRING_LIMIT_DEPTH_EQ,             12, PSO_LIMD, 0 },
  { STRING_LIMIT_RECURSION_EQ,         16, PSO_LIMD, 0 },
  { STRING_CR_RIGHTPAR,                 3, PSO_NL,  PCRE2_NEWLINE_CR },
  { STRING_LF_RIGHTPAR,                 3, PSO_NL,  PCRE2_NEWLINE_LF },
  { STRING_CRLF_RIGHTPAR,               5, PSO_NL,  PCRE2_NEWLINE_CRLF },
  { STRING_ANY_RIGHTPAR,                4, PSO_NL,  PCRE2_NEWLINE_ANY },
  { STRING_NUL_RIGHTPAR,                4, PSO_NL,  PCRE2_NEWLINE_NUL },
  { STRING_ANYCRLF_RIGHTPAR,            8, PSO_NL,  PCRE2_NEWLINE_ANYCRLF },
  { STRING_BSR_ANYCRLF_RIGHTPAR,       12, PSO_BSR, PCRE2_BSR_ANYCRLF },
  { STRING_BSR_UNICODE_RIGHTPAR,       12, PSO_BSR, PCRE2_BSR_UNICODE }
};

/* This table is used when converting repeating opcodes into possessified
versions as a result of an explicit possessive quantifier such as ++. A zero
value means there is no possessified version - in those cases the item in
question must be wrapped in ONCE brackets. The table is truncated at OP_CALLOUT
because all relevant opcodes are less than that. */

static const uint8_t opcode_possessify[] = {
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   /* 0 - 15  */
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   /* 16 - 31 */

  0,                       /* NOTI */
  OP_POSSTAR, 0,           /* STAR, MINSTAR */
  OP_POSPLUS, 0,           /* PLUS, MINPLUS */
  OP_POSQUERY, 0,          /* QUERY, MINQUERY */
  OP_POSUPTO, 0,           /* UPTO, MINUPTO */
  0,                       /* EXACT */
  0, 0, 0, 0,              /* POS{STAR,PLUS,QUERY,UPTO} */

  OP_POSSTARI, 0,          /* STARI, MINSTARI */
  OP_POSPLUSI, 0,          /* PLUSI, MINPLUSI */
  OP_POSQUERYI, 0,         /* QUERYI, MINQUERYI */
  OP_POSUPTOI, 0,          /* UPTOI, MINUPTOI */
  0,                       /* EXACTI */
  0, 0, 0, 0,              /* POS{STARI,PLUSI,QUERYI,UPTOI} */

  OP_NOTPOSSTAR, 0,        /* NOTSTAR, NOTMINSTAR */
  OP_NOTPOSPLUS, 0,        /* NOTPLUS, NOTMINPLUS */
  OP_NOTPOSQUERY, 0,       /* NOTQUERY, NOTMINQUERY */
  OP_NOTPOSUPTO, 0,        /* NOTUPTO, NOTMINUPTO */
  0,                       /* NOTEXACT */
  0, 0, 0, 0,              /* NOTPOS{STAR,PLUS,QUERY,UPTO} */

  OP_NOTPOSSTARI, 0,       /* NOTSTARI, NOTMINSTARI */
  OP_NOTPOSPLUSI, 0,       /* NOTPLUSI, NOTMINPLUSI */
  OP_NOTPOSQUERYI, 0,      /* NOTQUERYI, NOTMINQUERYI */
  OP_NOTPOSUPTOI, 0,       /* NOTUPTOI, NOTMINUPTOI */
  0,                       /* NOTEXACTI */
  0, 0, 0, 0,              /* NOTPOS{STARI,PLUSI,QUERYI,UPTOI} */

  OP_TYPEPOSSTAR, 0,       /* TYPESTAR, TYPEMINSTAR */
  OP_TYPEPOSPLUS, 0,       /* TYPEPLUS, TYPEMINPLUS */
  OP_TYPEPOSQUERY, 0,      /* TYPEQUERY, TYPEMINQUERY */
  OP_TYPEPOSUPTO, 0,       /* TYPEUPTO, TYPEMINUPTO */
  0,                       /* TYPEEXACT */
  0, 0, 0, 0,              /* TYPEPOS{STAR,PLUS,QUERY,UPTO} */

  OP_CRPOSSTAR, 0,         /* CRSTAR, CRMINSTAR */
  OP_CRPOSPLUS, 0,         /* CRPLUS, CRMINPLUS */
  OP_CRPOSQUERY, 0,        /* CRQUERY, CRMINQUERY */
  OP_CRPOSRANGE, 0,        /* CRRANGE, CRMINRANGE */
  0, 0, 0, 0,              /* CRPOS{STAR,PLUS,QUERY,RANGE} */

  0, 0, 0, 0,              /* CLASS, NCLASS, XCLASS, ECLASS */
  0, 0,                    /* REF, REFI */
  0, 0,                    /* DNREF, DNREFI */
  0, 0,                    /* RECURSE, CALLOUT */
};

/* Compile-time check that the table has the correct size. */
STATIC_ASSERT(sizeof(opcode_possessify) == OP_CALLOUT+1, opcode_possessify);


#ifdef DEBUG_SHOW_PARSED
/*************************************************
*     Show the parsed pattern for debugging      *
*************************************************/

/* For debugging the pre-scan, this code, which outputs the parsed data vector,
can be enabled. */

static void show_parsed(compile_block *cb)
{
uint32_t *pptr = cb->parsed_pattern;

for (;;)
  {
  int max, min;
  PCRE2_SIZE offset;
  uint32_t i;
  uint32_t length;
  uint32_t meta_arg = META_DATA(*pptr);

  fprintf(stderr, "+++ %02d %.8x ", (int)(pptr - cb->parsed_pattern), *pptr);

  if (*pptr < META_END)
    {
    if (*pptr > 32 && *pptr < 128) fprintf(stderr, "%c", *pptr);
    pptr++;
    }

  else switch (META_CODE(*pptr++))
    {
    default:
    fprintf(stderr, "**** OOPS - unknown META value - giving up ****\n");
    return;

    case META_END:
    fprintf(stderr, "META_END\n");
    return;

    case META_CAPTURE:
    fprintf(stderr, "META_CAPTURE %d", meta_arg);
    break;

    case META_RECURSE:
    GETOFFSET(offset, pptr);
    fprintf(stderr, "META_RECURSE %d %zd", meta_arg, offset);
    break;

    case META_BACKREF:
    if (meta_arg < 10)
      offset = cb->small_ref_offset[meta_arg];
    else
      GETOFFSET(offset, pptr);
    fprintf(stderr, "META_BACKREF %d %zd", meta_arg, offset);
    break;

    case META_ESCAPE:
    if (meta_arg == ESC_P || meta_arg == ESC_p)
      {
      uint32_t ptype = *pptr >> 16;
      uint32_t pvalue = *pptr++ & 0xffff;
      fprintf(stderr, "META \\%c %d %d", (meta_arg == ESC_P)? CHAR_P:CHAR_p,
        ptype, pvalue);
      }
    else
      {
      uint32_t cc;
      /* There's just one escape we might have here that isn't negated in the
      escapes table. */
      if (meta_arg == ESC_g) cc = CHAR_g;
      else for (cc = ESCAPES_FIRST; cc <= ESCAPES_LAST; cc++)
        {
        if (meta_arg == (uint32_t)(-escapes[cc - ESCAPES_FIRST])) break;
        }
      if (cc > ESCAPES_LAST) cc = CHAR_QUESTION_MARK;
      fprintf(stderr, "META \\%c", cc);
      }
    break;

    case META_MINMAX:
    min = *pptr++;
    max = *pptr++;
    if (max != REPEAT_UNLIMITED)
      fprintf(stderr, "META {%d,%d}", min, max);
    else
      fprintf(stderr, "META {%d,}", min);
    break;

    case META_MINMAX_QUERY:
    min = *pptr++;
    max = *pptr++;
    if (max != REPEAT_UNLIMITED)
      fprintf(stderr, "META {%d,%d}?", min, max);
    else
      fprintf(stderr, "META {%d,}?", min);
    break;

    case META_MINMAX_PLUS:
    min = *pptr++;
    max = *pptr++;
    if (max != REPEAT_UNLIMITED)
      fprintf(stderr, "META {%d,%d}+", min, max);
    else
      fprintf(stderr, "META {%d,}+", min);
    break;

    case META_BIGVALUE: fprintf(stderr, "META_BIGVALUE %.8x", *pptr++); break;
    case META_CIRCUMFLEX: fprintf(stderr, "META_CIRCUMFLEX"); break;
    case META_COND_ASSERT: fprintf(stderr, "META_COND_ASSERT"); break;
    case META_DOLLAR: fprintf(stderr, "META_DOLLAR"); break;
    case META_DOT: fprintf(stderr, "META_DOT"); break;
    case META_ASTERISK: fprintf(stderr, "META *"); break;
    case META_ASTERISK_QUERY: fprintf(stderr, "META *?"); break;
    case META_ASTERISK_PLUS: fprintf(stderr, "META *+"); break;
    case META_PLUS: fprintf(stderr, "META +"); break;
    case META_PLUS_QUERY: fprintf(stderr, "META +?"); break;
    case META_PLUS_PLUS: fprintf(stderr, "META ++"); break;
    case META_QUERY: fprintf(stderr, "META ?"); break;
    case META_QUERY_QUERY: fprintf(stderr, "META ??"); break;
    case META_QUERY_PLUS: fprintf(stderr, "META ?+"); break;

    case META_ATOMIC: fprintf(stderr, "META (?>"); break;
    case META_NOCAPTURE: fprintf(stderr, "META (?:"); break;
    case META_LOOKAHEAD: fprintf(stderr, "META (?="); break;
    case META_LOOKAHEADNOT: fprintf(stderr, "META (?!"); break;
    case META_LOOKAHEAD_NA: fprintf(stderr, "META (*napla:"); break;
    case META_SCRIPT_RUN: fprintf(stderr, "META (*sr:"); break;
    case META_KET: fprintf(stderr, "META )"); break;
    case META_ALT: fprintf(stderr, "META | %d", meta_arg); break;

    case META_CLASS: fprintf(stderr, "META ["); break;
    case META_CLASS_NOT: fprintf(stderr, "META [^"); break;
    case META_CLASS_END: fprintf(stderr, "META ]"); break;
    case META_CLASS_EMPTY: fprintf(stderr, "META []"); break;
    case META_CLASS_EMPTY_NOT: fprintf(stderr, "META [^]"); break;

    case META_RANGE_LITERAL: fprintf(stderr, "META - (literal)"); break;
    case META_RANGE_ESCAPED: fprintf(stderr, "META - (escaped)"); break;

    case META_POSIX: fprintf(stderr, "META_POSIX %d", *pptr++); break;
    case META_POSIX_NEG: fprintf(stderr, "META_POSIX_NEG %d", *pptr++); break;

    case META_ACCEPT: fprintf(stderr, "META (*ACCEPT)"); break;
    case META_FAIL: fprintf(stderr, "META (*FAIL)"); break;
    case META_COMMIT: fprintf(stderr, "META (*COMMIT)"); break;
    case META_PRUNE: fprintf(stderr, "META (*PRUNE)"); break;
    case META_SKIP: fprintf(stderr, "META (*SKIP)"); break;
    case META_THEN: fprintf(stderr, "META (*THEN)"); break;

    case META_OPTIONS:
    fprintf(stderr, "META_OPTIONS 0x%08x 0x%08x", pptr[0], pptr[1]);
    pptr += 2;
    break;

    case META_LOOKBEHIND:
    fprintf(stderr, "META (?<= %d %d", meta_arg, *pptr);
    pptr += 2;
    break;

    case META_LOOKBEHIND_NA:
    fprintf(stderr, "META (*naplb: %d %d", meta_arg, *pptr);
    pptr += 2;
    break;

    case META_LOOKBEHINDNOT:
    fprintf(stderr, "META (?<! %d %d", meta_arg, *pptr);
    pptr += 2;
    break;

    case META_CALLOUT_NUMBER:
    fprintf(stderr, "META (?C%d) next=%d/%d", pptr[2], pptr[0],
       pptr[1]);
    pptr += 3;
    break;

    case META_CALLOUT_STRING:
      {
      uint32_t patoffset = *pptr++;    /* Offset of next pattern item */
      uint32_t patlength = *pptr++;    /* Length of next pattern item */
      fprintf(stderr, "META (?Cstring) length=%d offset=", *pptr++);
      GETOFFSET(offset, pptr);
      fprintf(stderr, "%zd next=%d/%d", offset, patoffset, patlength);
      }
    break;

    case META_RECURSE_BYNAME:
    fprintf(stderr, "META (?(&name) length=%d offset=", *pptr++);
    GETOFFSET(offset, pptr);
    fprintf(stderr, "%zd", offset);
    break;

    case META_BACKREF_BYNAME:
    fprintf(stderr, "META_BACKREF_BYNAME length=%d offset=", *pptr++);
    GETOFFSET(offset, pptr);
    fprintf(stderr, "%zd", offset);
    break;

    case META_COND_NUMBER:
    fprintf(stderr, "META_COND_NUMBER %d offset=", pptr[SIZEOFFSET]);
    GETOFFSET(offset, pptr);
    fprintf(stderr, "%zd", offset);
    pptr++;
    break;

    case META_COND_DEFINE:
    fprintf(stderr, "META (?(DEFINE) offset=");
    GETOFFSET(offset, pptr);
    fprintf(stderr, "%zd", offset);
    break;

    case META_COND_VERSION:
    fprintf(stderr, "META (?(VERSION%s", (*pptr++ == 0)? "=" : ">=");
    fprintf(stderr, "%d.", *pptr++);
    fprintf(stderr, "%d)", *pptr++);
    break;

    case META_COND_NAME:
    fprintf(stderr, "META (?(<name>) length=%d offset=", *pptr++);
    GETOFFSET(offset, pptr);
    fprintf(stderr, "%zd", offset);
    break;

    case META_COND_RNAME:
    fprintf(stderr, "META (?(R&name) length=%d offset=", *pptr++);
    GETOFFSET(offset, pptr);
    fprintf(stderr, "%zd", offset);
    break;

    /* This is kept as a name, because it might be. */

    case META_COND_RNUMBER:
    fprintf(stderr, "META (?(Rnumber) length=%d offset=", *pptr++);
    GETOFFSET(offset, pptr);
    fprintf(stderr, "%zd", offset);
    break;

    case META_OFFSET:
    fprintf(stderr, "META_OFFSET offset=");
    GETOFFSET(offset, pptr);
    fprintf(stderr, "%zd", offset);
    break;

    case META_SCS:
    fprintf(stderr, "META (*scan_substring:");
    break;

    case META_SCS_NAME:
    fprintf(stderr, "META_SCS_NAME length=%d relative_offset=%d", *pptr++, (int)meta_arg);
    break;

    case META_SCS_NUMBER:
    fprintf(stderr, "META_SCS_NUMBER %d relative_offset=%d", *pptr++, (int)meta_arg);
    break;

    case META_MARK:
    fprintf(stderr, "META (*MARK:");
    goto SHOWARG;

    case META_COMMIT_ARG:
    fprintf(stderr, "META (*COMMIT:");
    goto SHOWARG;

    case META_PRUNE_ARG:
    fprintf(stderr, "META (*PRUNE:");
    goto SHOWARG;

    case META_SKIP_ARG:
    fprintf(stderr, "META (*SKIP:");
    goto SHOWARG;

    case META_THEN_ARG:
    fprintf(stderr, "META (*THEN:");
    SHOWARG:
    length = *pptr++;
    for (i = 0; i < length; i++)
      {
      uint32_t cc = *pptr++;
      if (cc > 32 && cc < 128) fprintf(stderr, "%c", cc);
        else fprintf(stderr, "\\x{%x}", cc);
      }
    fprintf(stderr, ") length=%u", length);
    break;

    case META_ECLASS_AND: fprintf(stderr, "META_ECLASS_AND"); break;
    case META_ECLASS_OR: fprintf(stderr, "META_ECLASS_OR"); break;
    case META_ECLASS_SUB: fprintf(stderr, "META_ECLASS_SUB"); break;
    case META_ECLASS_XOR: fprintf(stderr, "META_ECLASS_XOR"); break;
    case META_ECLASS_NOT: fprintf(stderr, "META_ECLASS_NOT"); break;
    }
  fprintf(stderr, "\n");
  }
return;
}
#endif  /* DEBUG_SHOW_PARSED */



/*************************************************
*               Copy compiled code               *
*************************************************/

/* Compiled JIT code cannot be copied, so the new compiled block has no
associated JIT data. */

PCRE2_EXP_DEFN pcre2_code * PCRE2_CALL_CONVENTION
pcre2_code_copy(const pcre2_code *code)
{
PCRE2_SIZE *ref_count;
pcre2_code *newcode;

if (code == NULL) return NULL;
newcode = code->memctl.malloc(code->blocksize, code->memctl.memory_data);
if (newcode == NULL) return NULL;
memcpy(newcode, code, code->blocksize);
newcode->executable_jit = NULL;

/* If the code is one that has been deserialized, increment the reference count
in the decoded tables. */

if ((code->flags & PCRE2_DEREF_TABLES) != 0)
  {
  ref_count = (PCRE2_SIZE *)(code->tables + TABLES_LENGTH);
  (*ref_count)++;
  }

return newcode;
}



/*************************************************
*     Copy compiled code and character tables    *
*************************************************/

/* Compiled JIT code cannot be copied, so the new compiled block has no
associated JIT data. This version of code_copy also makes a separate copy of
the character tables. */

PCRE2_EXP_DEFN pcre2_code * PCRE2_CALL_CONVENTION
pcre2_code_copy_with_tables(const pcre2_code *code)
{
PCRE2_SIZE* ref_count;
pcre2_code *newcode;
uint8_t *newtables;

if (code == NULL) return NULL;
newcode = code->memctl.malloc(code->blocksize, code->memctl.memory_data);
if (newcode == NULL) return NULL;
memcpy(newcode, code, code->blocksize);
newcode->executable_jit = NULL;

newtables = code->memctl.malloc(TABLES_LENGTH + sizeof(PCRE2_SIZE),
  code->memctl.memory_data);
if (newtables == NULL)
  {
  code->memctl.free((void *)newcode, code->memctl.memory_data);
  return NULL;
  }
memcpy(newtables, code->tables, TABLES_LENGTH);
ref_count = (PCRE2_SIZE *)(newtables + TABLES_LENGTH);
*ref_count = 1;

newcode->tables = newtables;
newcode->flags |= PCRE2_DEREF_TABLES;
return newcode;
}



/*************************************************
*               Free compiled code               *
*************************************************/

PCRE2_EXP_DEFN void PCRE2_CALL_CONVENTION
pcre2_code_free(pcre2_code *code)
{
PCRE2_SIZE* ref_count;

if (code != NULL)
  {
#ifdef SUPPORT_JIT
  if (code->executable_jit != NULL)
    PRIV(jit_free)(code->executable_jit, &code->memctl);
#endif

  if ((code->flags & PCRE2_DEREF_TABLES) != 0)
    {
    /* Decoded tables belong to the codes after deserialization, and they must
    be freed when there are no more references to them. The *ref_count should
    always be > 0. */

    ref_count = (PCRE2_SIZE *)(code->tables + TABLES_LENGTH);
    if (*ref_count > 0)
      {
      (*ref_count)--;
      if (*ref_count == 0)
        code->memctl.free((void *)code->tables, code->memctl.memory_data);
      }
    }

  code->memctl.free(code, code->memctl.memory_data);
  }
}



/*************************************************
*         Read a number, possibly signed         *
*************************************************/

/* This function is used to read numbers in the pattern. The initial pointer
must be at the sign or first digit of the number. When relative values
(introduced by + or -) are allowed, they are relative group numbers, and the
result must be greater than zero.

Arguments:
  ptrptr      points to the character pointer variable
  ptrend      points to the end of the input string
  allow_sign  if < 0, sign not allowed; if >= 0, sign is relative to this
  max_value   the largest number allowed;
              you must not pass a value for max_value larger than
              INT_MAX/10 - 1 because this function relies on max_value to
              avoid integer overflow
  max_error   the error to give for an over-large number
  intptr      where to put the result
  errcodeptr  where to put an error code

Returns:      TRUE  - a number was read
              FALSE - errorcode == 0 => no number was found
                      errorcode != 0 => an error occurred
*/

static BOOL
read_number(PCRE2_SPTR *ptrptr, PCRE2_SPTR ptrend, int32_t allow_sign,
  uint32_t max_value, uint32_t max_error, int *intptr, int *errorcodeptr)
{
int sign = 0;
uint32_t n = 0;
PCRE2_SPTR ptr = *ptrptr;
BOOL yield = FALSE;

PCRE2_ASSERT(max_value <= INT_MAX/10 - 1);

*errorcodeptr = 0;

if (allow_sign >= 0 && ptr < ptrend)
  {
  if (*ptr == CHAR_PLUS)
    {
    sign = +1;
    max_value -= allow_sign;
    ptr++;
    }
  else if (*ptr == CHAR_MINUS)
    {
    sign = -1;
    ptr++;
    }
  }

if (ptr >= ptrend || !IS_DIGIT(*ptr)) return FALSE;
while (ptr < ptrend && IS_DIGIT(*ptr))
  {
  n = n * 10 + (*ptr++ - CHAR_0);
  if (n > max_value)
    {
    *errorcodeptr = max_error;
    while (ptr < ptrend && IS_DIGIT(*ptr)) ptr++;
    goto EXIT;
    }
  }

if (allow_sign >= 0 && sign != 0)
  {
  if (n == 0)
    {
    *errorcodeptr = ERR26;  /* +0 and -0 are not allowed */
    goto EXIT;
    }

  if (sign > 0) n += allow_sign;
  else if (n > (uint32_t)allow_sign)
    {
    *errorcodeptr = ERR15;  /* Non-existent subpattern */
    goto EXIT;
    }
  else n = allow_sign + 1 - n;
  }

yield = TRUE;

EXIT:
*intptr = n;
*ptrptr = ptr;
return yield;
}



/*************************************************
*         Read repeat counts                     *
*************************************************/

/* Read an item of the form {n,m} and return the values when non-NULL pointers
are supplied. Repeat counts must be less than 65536 (MAX_REPEAT_COUNT); a
larger value is used for "unlimited". We have to use signed arguments for
read_number() because it is capable of returning a signed value. As of Perl
5.34.0 either n or m may be absent, but not both. Perl also allows spaces and
tabs after { and before } and between the numbers and the comma, so we do too.

Arguments:
  ptrptr         points to pointer to character after '{'
  ptrend         pointer to end of input
  minp           if not NULL, pointer to int for min
  maxp           if not NULL, pointer to int for max
  errorcodeptr   points to error code variable

Returns:         FALSE if not a repeat quantifier, errorcode set zero
                 FALSE on error, with errorcode set non-zero
                 TRUE on success, with pointer updated to point after '}'
*/

static BOOL
read_repeat_counts(PCRE2_SPTR *ptrptr, PCRE2_SPTR ptrend, uint32_t *minp,
  uint32_t *maxp, int *errorcodeptr)
{
PCRE2_SPTR p = *ptrptr;
PCRE2_SPTR pp;
BOOL yield = FALSE;
BOOL had_minimum = FALSE;
int32_t min = 0;
int32_t max = REPEAT_UNLIMITED; /* This value is larger than MAX_REPEAT_COUNT */

*errorcodeptr = 0;
while (p < ptrend && (*p == CHAR_SPACE || *p == CHAR_HT)) p++;

/* Check the syntax before interpreting. Otherwise, a non-quantifier sequence
such as "X{123456ABC" would incorrectly give a "number too big in quantifier"
error. */

pp = p;
if (pp < ptrend && IS_DIGIT(*pp))
  {
  had_minimum = TRUE;
  while (++pp < ptrend && IS_DIGIT(*pp)) {}
  }

while (pp < ptrend && (*pp == CHAR_SPACE || *pp == CHAR_HT)) pp++;
if (pp >= ptrend) return FALSE;

if (*pp == CHAR_RIGHT_CURLY_BRACKET)
  {
  if (!had_minimum) return FALSE;
  }
else
  {
  if (*pp++ != CHAR_COMMA) return FALSE;
  while (pp < ptrend && (*pp == CHAR_SPACE || *pp == CHAR_HT)) pp++;
  if (pp >= ptrend) return FALSE;
  if (IS_DIGIT(*pp))
    {
    while (++pp < ptrend && IS_DIGIT(*pp)) {}
    }
  else if (!had_minimum) return FALSE;
  while (pp < ptrend && (*pp == CHAR_SPACE || *pp == CHAR_HT)) pp++;
  if (pp >= ptrend || *pp != CHAR_RIGHT_CURLY_BRACKET) return FALSE;
  }

/* Now process the quantifier for real. We know it must be {n} or {n,} or {,m}
or {n,m}. The only error that read_number() can return is for a number that is
too big. If *errorcodeptr is returned as zero it means no number was found. */

/* Deal with {,m} or n too big. If we successfully read m there is no need to
check m >= n because n defaults to zero. */

if (!read_number(&p, ptrend, -1, MAX_REPEAT_COUNT, ERR5, &min, errorcodeptr))
  {
  if (*errorcodeptr != 0) goto EXIT;    /* n too big */
  p++;  /* Skip comma and subsequent spaces */
  while (p < ptrend && (*p == CHAR_SPACE || *p == CHAR_HT)) p++;
  if (!read_number(&p, ptrend, -1, MAX_REPEAT_COUNT, ERR5, &max, errorcodeptr))
    {
    if (*errorcodeptr != 0) goto EXIT;  /* m too big */
    }
  }

/* Have read one number. Deal with {n} or {n,} or {n,m} */

else
  {
  while (p < ptrend && (*p == CHAR_SPACE || *p == CHAR_HT)) p++;
  if (*p == CHAR_RIGHT_CURLY_BRACKET)
    {
    max = min;
    }
  else   /* Handle {n,} or {n,m} */
    {
    p++;    /* Skip comma and subsequent spaces */
    while (p < ptrend && (*p == CHAR_SPACE || *p == CHAR_HT)) p++;
    if (!read_number(&p, ptrend, -1, MAX_REPEAT_COUNT, ERR5, &max, errorcodeptr))
      {
      if (*errorcodeptr != 0) goto EXIT;   /* m too big */
      }

    if (max < min)
      {
      *errorcodeptr = ERR4;
      goto EXIT;
      }
    }
  }

/* Valid quantifier exists */

while (p < ptrend && (*p == CHAR_SPACE || *p == CHAR_HT)) p++;
p++;
yield = TRUE;
if (minp != NULL) *minp = (uint32_t)min;
if (maxp != NULL) *maxp = (uint32_t)max;

/* Update the pattern pointer */

EXIT:
*ptrptr = p;
return yield;
}



/*************************************************
*            Handle escapes                      *
*************************************************/

/* This function is called when a \ has been encountered. It either returns a
positive value for a simple escape such as \d, or 0 for a data character, which
is placed in chptr. A backreference to group n is returned as -(n+1). On
entry, ptr is pointing at the character after \. On exit, it points after the
final code unit of the escape sequence.

This function is also called from pcre2_substitute() to handle escape sequences
in replacement strings. In this case, the cb argument is NULL, and in the case
of escapes that have further processing, only sequences that define a data
character are recognised. The options argument is the final value of the
compiled pattern's options.

Arguments:
  ptrptr         points to the input position pointer
  ptrend         points to the end of the input
  chptr          points to a returned data character
  errorcodeptr   points to the errorcode variable (containing zero)
  options        the current options bits
  xoptions       the current extra options bits
  bracount       the number of capturing parentheses encountered so far
  isclass        TRUE if in a character class
  cb             compile data block or NULL when called from pcre2_substitute()

Returns:         zero => a data character
                 positive => a special escape sequence
                 negative => a numerical back reference
                 on error, errorcodeptr is set non-zero
*/

int
PRIV(check_escape)(PCRE2_SPTR *ptrptr, PCRE2_SPTR ptrend, uint32_t *chptr,
  int *errorcodeptr, uint32_t options, uint32_t xoptions, uint32_t bracount,
  BOOL isclass, compile_block *cb)
{
BOOL utf = (options & PCRE2_UTF) != 0;
BOOL alt_bsux =
  ((options & PCRE2_ALT_BSUX) | (xoptions & PCRE2_EXTRA_ALT_BSUX)) != 0;
PCRE2_SPTR ptr = *ptrptr;
uint32_t c, cc;
int escape = 0;
int i;

/* If backslash is at the end of the string, it's an error. */

if (ptr >= ptrend)
  {
  *errorcodeptr = ERR1;
  return 0;
  }

GETCHARINCTEST(c, ptr);         /* Get character value, increment pointer */
*errorcodeptr = 0;              /* Be optimistic */

/* Non-alphanumerics are literals, so we just leave the value in c. An initial
value test saves a memory lookup for code points outside the alphanumeric
range. */

if (c < ESCAPES_FIRST || c > ESCAPES_LAST) {}  /* Definitely literal */

/* Otherwise, do a table lookup. Non-zero values need little processing here. A
positive value is a literal value for something like \n. A negative value is
the negation of one of the ESC_ macros that is passed back for handling by the
calling function. Some extra checking is needed for \N because only \N{U+dddd}
is supported. If the value is zero, further processing is handled below. */

else if ((i = escapes[c - ESCAPES_FIRST]) != 0)
  {
  if (i > 0)
    {
    c = (uint32_t)i;
    if (c == CHAR_CR && (xoptions & PCRE2_EXTRA_ESCAPED_CR_IS_LF) != 0)
      c = CHAR_LF;
    }
  else  /* Negative table entry */
    {
    escape = -i;                    /* Else return a special escape */
    if (cb != NULL && (escape == ESC_P || escape == ESC_p || escape == ESC_X))
      cb->external_flags |= PCRE2_HASBKPORX;   /* Note \P, \p, or \X */

    /* Perl supports \N{name} for character names and \N{U+dddd} for numerical
    Unicode code points, as well as plain \N for "not newline". PCRE does not
    support \N{name}. However, it does support quantification such as \N{2,3},
    so if \N{ is not followed by U+dddd we check for a quantifier. */

    if (escape == ESC_N && ptr < ptrend && *ptr == CHAR_LEFT_CURLY_BRACKET)
      {
      PCRE2_SPTR p = ptr + 1;

      /* Perl ignores spaces and tabs after { */

      while (p < ptrend && (*p == CHAR_SPACE || *p == CHAR_HT)) p++;

      /* \N{U+ can be handled by the \x{ code. However, this construction is
      not valid in EBCDIC environments because it specifies a Unicode
      character, not a codepoint in the local code. For example \N{U+0041}
      must be "A" in all environments. Also, in Perl, \N{U+ forces Unicode
      casing semantics for the entire pattern, so allow it only in UTF (i.e.
      Unicode) mode. */

      if (ptrend - p > 1 && *p == CHAR_U && p[1] == CHAR_PLUS)
        {
#ifndef EBCDIC
        if (utf)
          {
          ptr = p + 2;
          escape = 0;   /* Not a fancy escape after all */
          goto COME_FROM_NU;
          }
#endif
        *errorcodeptr = ERR93;
        }

      /* Give an error in contexts where quantifiers are not allowed
      (character classes; substitution strings). */

      else if (isclass || cb == NULL)
        {
        *errorcodeptr = ERR37;
        }

      /* Give an error if what follows is not a quantifier, but don't override
      an error set by the quantifier reader (e.g. number overflow). */

      else
        {
        if (!read_repeat_counts(&p, ptrend, NULL, NULL, errorcodeptr) &&
             *errorcodeptr == 0)
          *errorcodeptr = ERR37;
        }
      }
    }
  }

/* Escapes that need further processing, including those that are unknown, have
a zero entry in the lookup table. When called from pcre2_substitute(), only \c,
\o, and \x are recognized (\u and \U can never appear as they are used for case
forcing). */

else
  {
  int s;
  PCRE2_SPTR oldptr;
  BOOL overflow;

  /* Filter calls from pcre2_substitute(). */

  if (cb == NULL)
    {
    if (c < CHAR_0 ||
       (c > CHAR_9 && (c != CHAR_c && c != CHAR_o && c != CHAR_x && c != CHAR_g)))
      {
      *errorcodeptr = ERR3;
      return 0;
      }
    alt_bsux = FALSE;   /* Do not modify \x handling */
    }

  switch (c)
    {
    /* A number of Perl escapes are not handled by PCRE. We give an explicit
    error. */

    case CHAR_F:
    case CHAR_l:
    case CHAR_L:
    *errorcodeptr = ERR37;
    break;

    /* \u is unrecognized when neither PCRE2_ALT_BSUX nor PCRE2_EXTRA_ALT_BSUX
    is set. Otherwise, \u must be followed by exactly four hex digits or, if
    PCRE2_EXTRA_ALT_BSUX is set, by any number of hex digits in braces.
    Otherwise it is a lowercase u letter. This gives some compatibility with
    ECMAScript (aka JavaScript). Unlike other braced items, white space is NOT
    allowed. When \u{ is not followed by hex digits, a special return is given
    because otherwise \u{ 12} (for example) would be treated as u{12}. */

    case CHAR_u:
    if (!alt_bsux) *errorcodeptr = ERR37; else
      {
      uint32_t xc;

      if (ptr >= ptrend) break;
      if (*ptr == CHAR_LEFT_CURLY_BRACKET &&
          (xoptions & PCRE2_EXTRA_ALT_BSUX) != 0)
        {
        PCRE2_SPTR hptr = ptr + 1;

        cc = 0;
        while (hptr < ptrend && (xc = XDIGIT(*hptr)) != 0xff)
          {
          if ((cc & 0xf0000000) != 0)  /* Test for 32-bit overflow */
            {
            *errorcodeptr = ERR77;
            ptr = hptr;   /* Show where */
            break;        /* *hptr != } will cause another break below */
            }
          cc = (cc << 4) | xc;
          hptr++;
          }

        if (hptr == ptr + 1 ||   /* No hex digits */
            hptr >= ptrend ||    /* Hit end of input */
            *hptr != CHAR_RIGHT_CURLY_BRACKET)  /* No } terminator */
          {
          if (isclass) break; /* In a class, just treat as '\u' literal */
          escape = ESC_ub;    /* Special return */
          ptr++;              /* Skip { */
          break;              /* Hex escape not recognized */
          }

        c = cc;          /* Accept the code point */
        ptr = hptr + 1;
        }

      else  /* Must be exactly 4 hex digits */
        {
        if (ptrend - ptr < 4) break;               /* Less than 4 chars */
        if ((cc = XDIGIT(ptr[0])) == 0xff) break;  /* Not a hex digit */
        if ((xc = XDIGIT(ptr[1])) == 0xff) break;  /* Not a hex digit */
        cc = (cc << 4) | xc;
        if ((xc = XDIGIT(ptr[2])) == 0xff) break;  /* Not a hex digit */
        cc = (cc << 4) | xc;
        if ((xc = XDIGIT(ptr[3])) == 0xff) break;  /* Not a hex digit */
        c = (cc << 4) | xc;
        ptr += 4;
        }

      if (utf)
        {
        if (c > 0x10ffffU) *errorcodeptr = ERR77;
        else
          if (c >= 0xd800 && c <= 0xdfff &&
              (xoptions & PCRE2_EXTRA_ALLOW_SURROGATE_ESCAPES) == 0)
                *errorcodeptr = ERR73;
        }
      else if (c > MAX_NON_UTF_CHAR) *errorcodeptr = ERR77;
      }
    break;

    /* \U is unrecognized unless PCRE2_ALT_BSUX or PCRE2_EXTRA_ALT_BSUX is set,
    in which case it is an upper case letter. */

    case CHAR_U:
    if (!alt_bsux) *errorcodeptr = ERR37;
    break;

    /* In a character class, \g is just a literal "g". Outside a character
    class, \g must be followed by one of a number of specific things:

    (1) A number, either plain or braced. If positive, it is an absolute
    backreference. If negative, it is a relative backreference. This is a Perl
    5.10 feature.

    (2) Perl 5.10 also supports \g{name} as a reference to a named group. This
    is part of Perl's movement towards a unified syntax for back references. As
    this is synonymous with \k{name}, we fudge it up by pretending it really
    was \k{name}.

    (3) For Oniguruma compatibility we also support \g followed by a name or a
    number either in angle brackets or in single quotes. However, these are
    (possibly recursive) subroutine calls, _not_ backreferences. We return
    the ESC_g code.

    Summary: Return a negative number for a numerical back reference (offset
    by 1), ESC_k for a named back reference, and ESC_g for a named or
    numbered subroutine call.

    The above describes the \g behaviour inside patterns. Inside replacement
    strings (pcre2_substitute) we support only \g<nameornum> for Python
    compatibility. Return ESG_g for the named case, and -(num+1) for the
    numbered case.
    */

    case CHAR_g:
    if (isclass) break;

    if (ptr >= ptrend)
      {
      *errorcodeptr = ERR57;
      break;
      }

    if (cb == NULL)
      {
      PCRE2_SPTR p;
      /* Substitution strings */
      if (*ptr != CHAR_LESS_THAN_SIGN)
        {
        *errorcodeptr = ERR57;
        break;
        }

      p = ptr + 1;

      if (!read_number(&p, ptrend, -1, MAX_GROUP_NUMBER, ERR61, &s,
          errorcodeptr))
        {
        if (*errorcodeptr == 0) escape = ESC_g;  /* No number found */
        break;
        }

      if (p >= ptrend || *p != CHAR_GREATER_THAN_SIGN)
        {
        /* not advancing ptr; report error at the \g character */
        *errorcodeptr = ERR57;
        break;
        }

      /* This is the reason that back references are returned as -(s+1) rather
      than just -s. In a pattern, \0 is not a back reference, but \g<0> is
      valid in a substitution string, so this must be representable. */
      ptr = p + 1;
      escape = -(s+1);
      break;
      }

    if (*ptr == CHAR_LESS_THAN_SIGN || *ptr == CHAR_APOSTROPHE)
      {
      escape = ESC_g;
      break;
      }

    /* If there is a brace delimiter, try to read a numerical reference. If
    there isn't one, assume we have a name and treat it as \k. */

    if (*ptr == CHAR_LEFT_CURLY_BRACKET)
      {
      PCRE2_SPTR p = ptr + 1;

      while (p < ptrend && (*p == CHAR_SPACE || *p == CHAR_HT)) p++;
      if (!read_number(&p, ptrend, bracount, MAX_GROUP_NUMBER, ERR61, &s,
          errorcodeptr))
        {
        if (*errorcodeptr == 0) escape = ESC_k;  /* No number found */
        break;
        }
      while (p < ptrend && (*p == CHAR_SPACE || *p == CHAR_HT)) p++;

      if (p >= ptrend || *p != CHAR_RIGHT_CURLY_BRACKET)
        {
        /* not advancing ptr; report error at the \g character */
        *errorcodeptr = ERR57;
        break;
        }
      ptr = p + 1;
      }

    /* Read an undelimited number */

    else
      {
      if (!read_number(&ptr, ptrend, bracount, MAX_GROUP_NUMBER, ERR61, &s,
          errorcodeptr))
        {
        if (*errorcodeptr == 0) *errorcodeptr = ERR57;  /* No number found */
        break;
        }
      }

    if (s <= 0)
      {
      *errorcodeptr = ERR15;
      break;
      }

    escape = -(s+1);
    break;

    /* The handling of escape sequences consisting of a string of digits
    starting with one that is not zero is not straightforward. Perl has changed
    over the years. Nowadays \g{} for backreferences and \o{} for octal are
    recommended to avoid the ambiguities in the old syntax.

    Outside a character class, the digits are read as a decimal number. If the
    number is less than 10, or if there are that many previous extracting left
    brackets, it is a back reference. Otherwise, up to three octal digits are
    read to form an escaped character code. Thus \123 is likely to be octal 123
    (cf \0123, which is octal 012 followed by the literal 3). This is the "Perl
    style" of handling ambiguous octal/backrefences such as \12.

    There is an alternative disambiguation strategy, selected by
    PCRE2_EXTRA_PYTHON_OCTAL, which follows Python's behaviour. An octal must
    have either a leading zero, or exactly three octal digits; otherwise it's
    a backreference. The disambiguation is stable, and does not depend on how
    many capture groups are defined (it's simply an invalid backreference if
    there is no corresponding capture group). Additionally, octal values above
    \377 (\xff) are rejected.

    Inside a character class, \ followed by a digit is always either a literal
    8 or 9 or an octal number. */

    case CHAR_1: case CHAR_2: case CHAR_3: case CHAR_4: case CHAR_5:
    case CHAR_6: case CHAR_7: case CHAR_8: case CHAR_9:

    if (isclass)
      {
      /* Fall through to octal handling; never a backreference inside a class. */
      }
    else if ((xoptions & PCRE2_EXTRA_PYTHON_OCTAL) != 0)
      {
      /* Python-style disambiguation. */
      if (ptr[-1] <= CHAR_7 && ptr + 1 < ptrend && ptr[0] >= CHAR_0 &&
          ptr[0] <= CHAR_7 && ptr[1] >= CHAR_0 && ptr[1] <= CHAR_7)
        {
        /* We peeked a three-digit octal, so fall through */
        }
      else
        {
        /* We are at a digit, so the only possible error from read_number() is
        a number that is too large. */
        ptr--;   /* Back to the digit */

        if (!read_number(&ptr, ptrend, -1, MAX_GROUP_NUMBER, 0, &s, errorcodeptr))
          {
          *errorcodeptr = ERR61;
          break;
          }

        escape = -(s+1);
        break;
        }
      }
    else
      {
      /* Perl-style disambiguation. */
      oldptr = ptr;
      ptr--;   /* Back to the digit */

      /* As we know we are at a digit, the only possible error from
      read_number() is a number that is too large to be a group number. Because
      that number might be still valid if read as an octal, errorcodeptr is not
      set on failure and therefore a sentinel value of INT_MAX is used instead
      of the original value, and will be used later to properly set the error,
      if not falling through. */

      if (!read_number(&ptr, ptrend, -1, MAX_GROUP_NUMBER, 0, &s, errorcodeptr))
        s = INT_MAX;

      /* \1 to \9 are always back references. \8x and \9x are too; \1x to \7x
      are octal escapes if there are not that many previous captures. */

      if (s < 10 || c >= CHAR_8 || (unsigned)s <= bracount)
        {
        /* s > MAX_GROUP_NUMBER should not be possible because of read_number(),
        but we keep it just to be safe and because it will also catch the
        sentinel value that was set on failure by that function. */

        if ((unsigned)s > MAX_GROUP_NUMBER)
          {
          PCRE2_ASSERT(s == INT_MAX);
          *errorcodeptr = ERR61;
          }
        else escape = -(s+1);     /* Indicates a back reference */
        break;
        }

      ptr = oldptr;      /* Put the pointer back and fall through */
      }

    /* Handle a digit following \ when the number is not a back reference, or
    we are within a character class. If the first digit is 8 or 9, Perl used to
    generate a binary zero and then treat the digit as a following literal. At
    least by Perl 5.18 this changed so as not to insert the binary zero. */

    if (c >= CHAR_8) break;

    /* Fall through */

    /* \0 always starts an octal number, but we may drop through to here with a
    larger first octal digit. The original code used just to take the least
    significant 8 bits of octal numbers (I think this is what early Perls used
    to do). Nowadays we allow for larger numbers in UTF-8 mode and 16/32-bit mode,
    but no more than 3 octal digits. */

    case CHAR_0:
    c -= CHAR_0;
    while(i++ < 2 && ptr < ptrend && *ptr >= CHAR_0 && *ptr <= CHAR_7)
        c = c * 8 + *ptr++ - CHAR_0;
    if (c > 0xff)
      {
      if ((xoptions & PCRE2_EXTRA_PYTHON_OCTAL) != 0) *errorcodeptr = ERR102;
#if PCRE2_CODE_UNIT_WIDTH == 8
      else if (!utf) *errorcodeptr = ERR51;
#endif
      }

    /* PCRE2_EXTRA_NO_BS0 disables the NUL escape '\0' but doesn't affect
    two- or three-character octal escapes \00 and \000, nor \x00. */

    if ((xoptions & PCRE2_EXTRA_NO_BS0) != 0 && c == 0 && i == 1)
        *errorcodeptr = ERR98;
    break;

    /* \o is a relatively new Perl feature, supporting a more general way of
    specifying character codes in octal. The only supported form is \o{ddd},
    with optional spaces or tabs after { and before }. */

    case CHAR_o:
    if (ptr >= ptrend || *ptr++ != CHAR_LEFT_CURLY_BRACKET)
      {
      ptr--;
      *errorcodeptr = ERR55;
      break;
      }

    while (ptr < ptrend && (*ptr == CHAR_SPACE || *ptr == CHAR_HT)) ptr++;
    if (ptr >= ptrend || *ptr == CHAR_RIGHT_CURLY_BRACKET)
      {
      *errorcodeptr = ERR78;
      break;
      }

    c = 0;
    overflow = FALSE;
    while (ptr < ptrend && *ptr >= CHAR_0 && *ptr <= CHAR_7)
      {
      cc = *ptr++;
      if (c == 0 && cc == CHAR_0) continue;     /* Leading zeroes */
#if PCRE2_CODE_UNIT_WIDTH == 32
      if (c >= 0x20000000u) { overflow = TRUE; break; }
#endif
      c = (c << 3) + (cc - CHAR_0);
#if PCRE2_CODE_UNIT_WIDTH == 8
      if (c > (utf ? 0x10ffffU : 0xffU)) { overflow = TRUE; break; }
#elif PCRE2_CODE_UNIT_WIDTH == 16
      if (c > (utf ? 0x10ffffU : 0xffffU)) { overflow = TRUE; break; }
#elif PCRE2_CODE_UNIT_WIDTH == 32
      if (utf && c > 0x10ffffU) { overflow = TRUE; break; }
#endif
      }

    while (ptr < ptrend && (*ptr == CHAR_SPACE || *ptr == CHAR_HT)) ptr++;

    if (overflow)
      {
      while (ptr < ptrend && *ptr >= CHAR_0 && *ptr <= CHAR_7) ptr++;
      *errorcodeptr = ERR34;
      }
    else if (ptr < ptrend && *ptr++ == CHAR_RIGHT_CURLY_BRACKET)
      {
      if (utf && c >= 0xd800 && c <= 0xdfff &&
          (xoptions & PCRE2_EXTRA_ALLOW_SURROGATE_ESCAPES) == 0)
        {
        ptr--;
        *errorcodeptr = ERR73;
        }
      }
    else
      {
      ptr--;
      *errorcodeptr = ERR64;
      }
    break;

    /* When PCRE2_ALT_BSUX or PCRE2_EXTRA_ALT_BSUX is set, \x must be followed
    by two hexadecimal digits. Otherwise it is a lowercase x letter. */

    case CHAR_x:
    if (alt_bsux)
      {
      uint32_t xc;
      if (ptrend - ptr < 2) break;               /* Less than 2 characters */
      if ((cc = XDIGIT(ptr[0])) == 0xff) break;  /* Not a hex digit */
      if ((xc = XDIGIT(ptr[1])) == 0xff) break;  /* Not a hex digit */
      c = (cc << 4) | xc;
      ptr += 2;
      }

    /* Handle \x in Perl's style. \x{ddd} is a character code which can be
    greater than 0xff in UTF-8 or non-8bit mode, but only if the ddd are hex
    digits. If not, { used to be treated as a data character. However, Perl
    seems to read hex digits up to the first non-such, and ignore the rest, so
    that, for example \x{zz} matches a binary zero. This seems crazy, so PCRE
    now gives an error. */

    else
      {
      if (ptr < ptrend && *ptr == CHAR_LEFT_CURLY_BRACKET)
        {
        ptr++;
        while (ptr < ptrend && (*ptr == CHAR_SPACE || *ptr == CHAR_HT)) ptr++;

#ifndef EBCDIC
        COME_FROM_NU:
#endif
        if (ptr >= ptrend || *ptr == CHAR_RIGHT_CURLY_BRACKET)
          {
          *errorcodeptr = ERR78;
          break;
          }
        c = 0;
        overflow = FALSE;

        while (ptr < ptrend && (cc = XDIGIT(*ptr)) != 0xff)
          {
          ptr++;
          if (c == 0 && cc == 0) continue;   /* Leading zeroes */
#if PCRE2_CODE_UNIT_WIDTH == 32
          if (c >= 0x10000000l) { overflow = TRUE; break; }
#endif
          c = (c << 4) | cc;
          if ((utf && c > 0x10ffffU) || (!utf && c > MAX_NON_UTF_CHAR))
            {
            overflow = TRUE;
            break;
            }
          }

        /* Perl ignores spaces and tabs before } */

        while (ptr < ptrend && (*ptr == CHAR_SPACE || *ptr == CHAR_HT)) ptr++;

        /* On overflow, skip remaining hex digits */

        if (overflow)
          {
          while (ptr < ptrend && XDIGIT(*ptr) != 0xff) ptr++;
          *errorcodeptr = ERR34;
          }
        else if (ptr < ptrend && *ptr++ == CHAR_RIGHT_CURLY_BRACKET)
          {
          if (utf && c >= 0xd800 && c <= 0xdfff &&
              (xoptions & PCRE2_EXTRA_ALLOW_SURROGATE_ESCAPES) == 0)
            {
            ptr--;
            *errorcodeptr = ERR73;
            }
          }

        /* If the sequence of hex digits (followed by optional space) does not
        end with '}', give an error. We used just to recognize this construct
        and fall through to the normal \x handling, but nowadays Perl gives an
        error, which seems much more sensible, so we do too. */

        else
          {
          ptr--;
          *errorcodeptr = ERR67;
          }
        }   /* End of \x{} processing */

      /* Read a up to two hex digits after \x */

      else
        {
        /* Perl has the surprising/broken behaviour that \x without following
        hex digits is treated as an escape for NUL. Their source code laments
        this but keeps it for backwards compatibility. A warning is printed
        when "use warnings" is enabled. Because we don't have warnings, we
        simply forbid it. */
        if (ptr >= ptrend || (cc = XDIGIT(*ptr)) == 0xff)
          {
          /* Not a hex digit */
          *errorcodeptr = ERR78;
          break;
          }
        ptr++;
        c = cc;

        /* With "use re 'strict'" Perl actually requires exactly two digits (error
        for \x, \xA and \xAAA). While \x was already rejected, this seems overly
        strict, and there seems little incentive to align with that, given the
        backwards-compatibility cost.

        For comparison, note that other engines disagree. For example:
          - Java allows 1 or 2 hex digits. Error if 0 digits. No error if >2 digits
          - .NET requires 2 hex digits. Error if 0, 1 digits. No error if >2 digits.
        */
        if (ptr >= ptrend || (cc = XDIGIT(*ptr)) == 0xff) break;  /* Not a hex digit */
        ptr++;
        c = (c << 4) | cc;
        }     /* End of \xdd handling */
      }       /* End of Perl-style \x handling */
    break;

    /* The handling of \c is different in ASCII and EBCDIC environments. In an
    ASCII (or Unicode) environment, an error is given if the character
    following \c is not a printable ASCII character. Otherwise, the following
    character is upper-cased if it is a letter, and after that the 0x40 bit is
    flipped. The result is the value of the escape.

    In an EBCDIC environment the handling of \c is compatible with the
    specification in the perlebcdic document. The following character must be
    a letter or one of small number of special characters. These provide a
    means of defining the character values 0-31.

    For testing the EBCDIC handling of \c in an ASCII environment, recognize
    the EBCDIC value of 'c' explicitly. */

#if defined EBCDIC && 'a' != 0x81
    case 0x83:
#else
    case CHAR_c:
#endif
    if (ptr >= ptrend)
      {
      *errorcodeptr = ERR2;
      break;
      }
    c = *ptr;
    if (c >= CHAR_a && c <= CHAR_z) c = UPPER_CASE(c);

    /* Handle \c in an ASCII/Unicode environment. */

#ifndef EBCDIC    /* ASCII/UTF-8 coding */
    if (c < 32 || c > 126)  /* Excludes all non-printable ASCII */
      {
      *errorcodeptr = ERR68;
      break;
      }
    c ^= 0x40;

    /* Handle \c in an EBCDIC environment. The special case \c? is converted to
    255 (0xff) or 95 (0x5f) if other characters suggest we are using the
    POSIX-BC encoding. (This is the way Perl indicates that it handles \c?.)
    The other valid sequences correspond to a list of specific characters. */

#else
    if (c == CHAR_QUESTION_MARK)
      c = ('\\' == 188 && '`' == 74)? 0x5f : 0xff;
    else
      {
      for (i = 0; i < 32; i++)
        {
        if (c == ebcdic_escape_c[i]) break;
        }
      if (i < 32) c = i; else *errorcodeptr = ERR68;
      }
#endif  /* EBCDIC */

    ptr++;
    break;

    /* Any other alphanumeric following \ is an error. Perl gives an error only
    if in warning mode, but PCRE doesn't have a warning mode. */

    default:
    *errorcodeptr = ERR3;
    *ptrptr = ptr - 1;     /* Point to the character at fault */
    return 0;
    }
  }

/* Set the pointer to the next character before returning. */

*ptrptr = ptr;
*chptr = c;
return escape;
}



#ifdef SUPPORT_UNICODE
/*************************************************
*               Handle \P and \p                 *
*************************************************/

/* This function is called after \P or \p has been encountered, provided that
PCRE2 is compiled with support for UTF and Unicode properties. On entry, the
contents of ptrptr are pointing after the P or p. On exit, it is left pointing
after the final code unit of the escape sequence.

Arguments:
  ptrptr         the pattern position pointer
  negptr         a boolean that is set TRUE for negation else FALSE
  ptypeptr       an unsigned int that is set to the type value
  pdataptr       an unsigned int that is set to the detailed property value
  errorcodeptr   the error code variable
  cb             the compile data

Returns:         TRUE if the type value was found, or FALSE for an invalid type
*/

static BOOL
get_ucp(PCRE2_SPTR *ptrptr, BOOL *negptr, uint16_t *ptypeptr,
  uint16_t *pdataptr, int *errorcodeptr, compile_block *cb)
{
PCRE2_UCHAR c;
PCRE2_SIZE i, bot, top;
PCRE2_SPTR ptr = *ptrptr;
PCRE2_UCHAR name[50];
PCRE2_UCHAR *vptr = NULL;
uint16_t ptscript = PT_NOTSCRIPT;

if (ptr >= cb->end_pattern) goto ERROR_RETURN;
c = *ptr++;
*negptr = FALSE;

/* \P or \p can be followed by a name in {}, optionally preceded by ^ for
negation. We must be handling Unicode encoding here, though we may be compiling
for UTF-8 input in an EBCDIC environment. (PCRE2 does not support both EBCDIC
input and Unicode input in the same build.) In accordance with Unicode's "loose
matching" rules, ASCII white space, hyphens, and underscores are ignored. We
don't use isspace() or tolower() because (a) code points may be greater than
255, and (b) they wouldn't work when compiling for Unicode in an EBCDIC
environment. */

if (c == CHAR_LEFT_CURLY_BRACKET)
  {
  if (ptr >= cb->end_pattern) goto ERROR_RETURN;

  for (i = 0; i < (int)(sizeof(name) / sizeof(PCRE2_UCHAR)) - 1; i++)
    {
    REDO:

    if (ptr >= cb->end_pattern) goto ERROR_RETURN;
    c = *ptr++;

    /* Skip ignorable Unicode characters. */

    while (c == CHAR_UNDERSCORE || c == CHAR_MINUS || c == CHAR_SPACE ||
          (c >= CHAR_HT && c <= CHAR_CR))
      {
      if (ptr >= cb->end_pattern) goto ERROR_RETURN;
      c = *ptr++;
      }

    /* The first significant character being circumflex negates the meaning of
    the item. */

    if (i == 0 && !*negptr && c == CHAR_CIRCUMFLEX_ACCENT)
      {
      *negptr = TRUE;
      goto REDO;
      }

    if (c == CHAR_RIGHT_CURLY_BRACKET) break;

    /* Names consist of ASCII letters and digits, but equals and colon may also
    occur as a name/value separator. We must also allow for \p{L&}. A simple
    check for a value between '&' and 'z' suffices because anything else in a
    name or value will cause an "unknown property" error anyway. */

    if (c < CHAR_AMPERSAND || c > CHAR_z) goto ERROR_RETURN;

    /* Lower case a capital letter or remember where the name/value separator
    is. */

    if (c >= CHAR_A && c <= CHAR_Z) c |= 0x20;
    else if ((c == CHAR_COLON || c == CHAR_EQUALS_SIGN) && vptr == NULL)
      vptr = name + i;

    name[i] = c;
    }

  /* Error if the loop didn't end with '}' - either we hit the end of the
  pattern or the name was longer than any legal property name. */

  if (c != CHAR_RIGHT_CURLY_BRACKET) goto ERROR_RETURN;
  name[i] = 0;
  }

/* If { doesn't follow \p or \P there is just one following character, which
must be an ASCII letter. */

else if (c >= CHAR_A && c <= CHAR_Z)
  {
  name[0] = c | 0x20;  /* Lower case */
  name[1] = 0;
  }
else if (c >= CHAR_a && c <= CHAR_z)
  {
  name[0] = c;
  name[1] = 0;
  }
else goto ERROR_RETURN;

*ptrptr = ptr;   /* Update pattern pointer */

/* If the property contains ':' or '=' we have class name and value separately
specified. The following are supported:

  . Bidi_Class (synonym bc), for which the property names are "bidi<name>".
  . Script (synonym sc) for which the property name is the script name
  . Script_Extensions (synonym scx), ditto

As this is a small number, we currently just check the names directly. If this
grows, a sorted table and a switch will be neater.

For both the script properties, set a PT_xxx value so that (1) they can be
distinguished and (2) invalid script names that happen to be the name of
another property can be diagnosed. */

if (vptr != NULL)
  {
  int offset = 0;
  PCRE2_UCHAR sname[8];

  *vptr = 0;   /* Terminate property name */
  if (PRIV(strcmp_c8)(name, STRING_bidiclass) == 0 ||
      PRIV(strcmp_c8)(name, STRING_bc) == 0)
    {
    offset = 4;
    sname[0] = CHAR_b;
    sname[1] = CHAR_i;  /* There is no strcpy_c8 function */
    sname[2] = CHAR_d;
    sname[3] = CHAR_i;
    }

  else if (PRIV(strcmp_c8)(name, STRING_script) == 0 ||
           PRIV(strcmp_c8)(name, STRING_sc) == 0)
    ptscript = PT_SC;

  else if (PRIV(strcmp_c8)(name, STRING_scriptextensions) == 0 ||
           PRIV(strcmp_c8)(name, STRING_scx) == 0)
    ptscript = PT_SCX;

  else
    {
    *errorcodeptr = ERR47;
    return FALSE;
    }

  /* Adjust the string in name[] as needed */

  memmove(name + offset, vptr + 1, (name + i - vptr)*sizeof(PCRE2_UCHAR));
  if (offset != 0) memmove(name, sname, offset*sizeof(PCRE2_UCHAR));
  }

/* Search for a recognized property using binary chop. */

bot = 0;
top = PRIV(utt_size);

while (bot < top)
  {
  int r;
  i = (bot + top) >> 1;
  r = PRIV(strcmp_c8)(name, PRIV(utt_names) + PRIV(utt)[i].name_offset);

  /* When a matching property is found, some extra checking is needed when the
  \p{xx:yy} syntax is used and xx is either sc or scx. */

  if (r == 0)
    {
    *pdataptr = PRIV(utt)[i].value;
    if (vptr == NULL || ptscript == PT_NOTSCRIPT)
      {
      *ptypeptr = PRIV(utt)[i].type;
      return TRUE;
      }

    switch (PRIV(utt)[i].type)
      {
      case PT_SC:
      *ptypeptr = PT_SC;
      return TRUE;

      case PT_SCX:
      *ptypeptr = ptscript;
      return TRUE;
      }

    break;  /* Non-script found */
    }

  if (r > 0) bot = i + 1; else top = i;
  }

*errorcodeptr = ERR47;   /* Unrecognized property */
return FALSE;

ERROR_RETURN:            /* Malformed \P or \p */
*errorcodeptr = ERR46;
*ptrptr = ptr;
return FALSE;
}
#endif



/*************************************************
*           Check for POSIX class syntax         *
*************************************************/

/* This function is called when the sequence "[:" or "[." or "[=" is
encountered in a character class. It checks whether this is followed by a
sequence of characters terminated by a matching ":]" or ".]" or "=]". If we
reach an unescaped ']' without the special preceding character, return FALSE.

Originally, this function only recognized a sequence of letters between the
terminators, but it seems that Perl recognizes any sequence of characters,
though of course unknown POSIX names are subsequently rejected. Perl gives an
"Unknown POSIX class" error for [:f\oo:] for example, where previously PCRE
didn't consider this to be a POSIX class. Likewise for [:1234:].

The problem in trying to be exactly like Perl is in the handling of escapes. We
have to be sure that [abc[:x\]pqr] is *not* treated as containing a POSIX
class, but [abc[:x\]pqr:]] is (so that an error can be generated). The code
below handles the special cases \\ and \], but does not try to do any other
escape processing. This makes it different from Perl for cases such as
[:l\ower:] where Perl recognizes it as the POSIX class "lower" but PCRE does
not recognize "l\ower". This is a lesser evil than not diagnosing bad classes
when Perl does, I think.

A user pointed out that PCRE was rejecting [:a[:digit:]] whereas Perl was not.
It seems that the appearance of a nested POSIX class supersedes an apparent
external class. For example, [:a[:digit:]b:] matches "a", "b", ":", or
a digit. This is handled by returning FALSE if the start of a new group with
the same terminator is encountered, since the next closing sequence must close
the nested group, not the outer one.

In Perl, unescaped square brackets may also appear as part of class names. For
example, [:a[:abc]b:] gives unknown POSIX class "[:abc]b:]". However, for
[:a[:abc]b][b:] it gives unknown POSIX class "[:abc]b][b:]", which does not
seem right at all. PCRE does not allow closing square brackets in POSIX class
names.

Arguments:
  ptr      pointer to the character after the initial [ (colon, dot, equals)
  ptrend   pointer to the end of the pattern
  endptr   where to return a pointer to the terminating ':', '.', or '='

Returns:   TRUE or FALSE
*/

static BOOL
check_posix_syntax(PCRE2_SPTR ptr, PCRE2_SPTR ptrend, PCRE2_SPTR *endptr)
{
PCRE2_UCHAR terminator;  /* Don't combine these lines; the Solaris cc */
terminator = *ptr++;     /* compiler warns about "non-constant" initializer. */

for (; ptrend - ptr >= 2; ptr++)
  {
  if (*ptr == CHAR_BACKSLASH &&
      (ptr[1] == CHAR_RIGHT_SQUARE_BRACKET || ptr[1] == CHAR_BACKSLASH))
    ptr++;

  else if ((*ptr == CHAR_LEFT_SQUARE_BRACKET && ptr[1] == terminator) ||
            *ptr == CHAR_RIGHT_SQUARE_BRACKET) return FALSE;

  else if (*ptr == terminator && ptr[1] == CHAR_RIGHT_SQUARE_BRACKET)
    {
    *endptr = ptr;
    return TRUE;
    }
  }

return FALSE;
}



/*************************************************
*          Check POSIX class name                *
*************************************************/

/* This function is called to check the name given in a POSIX-style class entry
such as [:alnum:].

Arguments:
  ptr        points to the first letter
  len        the length of the name

Returns:     a value representing the name, or -1 if unknown
*/

static int
check_posix_name(PCRE2_SPTR ptr, int len)
{
const char *pn = posix_names;
int yield = 0;
while (posix_name_lengths[yield] != 0)
  {
  if (len == posix_name_lengths[yield] &&
    PRIV(strncmp_c8)(ptr, pn, (unsigned int)len) == 0) return yield;
  pn += posix_name_lengths[yield] + 1;
  yield++;
  }
return -1;
}



/*************************************************
*       Read a subpattern or VERB name           *
*************************************************/

/* This function is called from parse_regex() below whenever it needs to read
the name of a subpattern or a (*VERB) or an (*alpha_assertion). The initial
pointer must be to the preceding character. If that character is '*' we are
reading a verb or alpha assertion name. The pointer is updated to point after
the name, for a VERB or alpha assertion name, or after tha name's terminator
for a subpattern name. Returning both the offset and the name pointer is
redundant information, but some callers use one and some the other, so it is
simplest just to return both. When the name is in braces, spaces and tabs are
allowed (and ignored) at either end.

Arguments:
  ptrptr      points to the character pointer variable
  ptrend      points to the end of the input string
  utf         true if the input is UTF-encoded
  terminator  the terminator of a subpattern name must be this
  offsetptr   where to put the offset from the start of the pattern
  nameptr     where to put a pointer to the name in the input
  namelenptr  where to put the length of the name
  errcodeptr  where to put an error code
  cb          pointer to the compile data block

Returns:    TRUE if a name was read
            FALSE otherwise, with error code set
*/

static BOOL
read_name(PCRE2_SPTR *ptrptr, PCRE2_SPTR ptrend, BOOL utf, uint32_t terminator,
  PCRE2_SIZE *offsetptr, PCRE2_SPTR *nameptr, uint32_t *namelenptr,
  int *errorcodeptr, compile_block *cb)
{
PCRE2_SPTR ptr = *ptrptr;
BOOL is_group = (*ptr++ != CHAR_ASTERISK);
BOOL is_braced = terminator == CHAR_RIGHT_CURLY_BRACKET;

if (is_braced)
  while (ptr < ptrend && (*ptr == CHAR_SPACE || *ptr == CHAR_HT)) ptr++;

if (ptr >= ptrend)                 /* No characters in name */
  {
  *errorcodeptr = is_group? ERR62: /* Subpattern name expected */
                            ERR60; /* Verb not recognized or malformed */
  goto FAILED;
  }

*nameptr = ptr;
*offsetptr = (PCRE2_SIZE)(ptr - cb->start_pattern);

/* If this logic were ever to change, the matching function in pcre2_substitute.c
ought to be updated to match. */

/* In UTF mode, a group name may contain letters and decimal digits as defined
by Unicode properties, and underscores, but must not start with a digit. */

#ifdef SUPPORT_UNICODE
if (utf && is_group)
  {
  uint32_t c, type;

  GETCHAR(c, ptr);
  type = UCD_CHARTYPE(c);

  if (type == ucp_Nd)
    {
    *errorcodeptr = ERR44;
    goto FAILED;
    }

  for(;;)
    {
    if (type != ucp_Nd && PRIV(ucp_gentype)[type] != ucp_L &&
        c != CHAR_UNDERSCORE) break;
    ptr++;
    FORWARDCHARTEST(ptr, ptrend);
    if (ptr >= ptrend) break;
    GETCHAR(c, ptr);
    type = UCD_CHARTYPE(c);
    }
  }
else
#else
(void)utf;  /* Avoid compiler warning */
#endif      /* SUPPORT_UNICODE */

/* Handle non-group names and group names in non-UTF modes. A group name must
not start with a digit. If either of the others start with a digit it just
won't be recognized. */

  {
  if (is_group && IS_DIGIT(*ptr))
    {
    *errorcodeptr = ERR44;
    goto FAILED;
    }

  while (ptr < ptrend && MAX_255(*ptr) && (cb->ctypes[*ptr] & ctype_word) != 0)
    {
    ptr++;
    }
  }

/* Check name length */

if (ptr > *nameptr + MAX_NAME_SIZE)
  {
  *errorcodeptr = ERR48;
  goto FAILED;
  }
*namelenptr = (uint32_t)(ptr - *nameptr);

/* Subpattern names must not be empty, and their terminator is checked here.
(What follows a verb or alpha assertion name is checked separately.) */

if (is_group)
  {
  if (ptr == *nameptr)
    {
    *errorcodeptr = ERR62;   /* Subpattern name expected */
    goto FAILED;
    }
  if (is_braced)
    while (ptr < ptrend && (*ptr == CHAR_SPACE || *ptr == CHAR_HT)) ptr++;
  if (ptr >= ptrend || *ptr != (PCRE2_UCHAR)terminator)
    {
    *errorcodeptr = ERR42;
    goto FAILED;
    }
  ptr++;
  }

*ptrptr = ptr;
return TRUE;

FAILED:
*ptrptr = ptr;
return FALSE;
}



/*************************************************
*          Manage callouts at start of cycle     *
*************************************************/

/* At the start of a new item in parse_regex() we are able to record the
details of the previous item in a prior callout, and also to set up an
automatic callout if enabled. Avoid having two adjacent automatic callouts,
which would otherwise happen for items such as \Q that contribute nothing to
the parsed pattern.

Arguments:
  ptr              current pattern pointer
  pcalloutptr      points to a pointer to previous callout, or NULL
  auto_callout     TRUE if auto_callouts are enabled
  parsed_pattern   the parsed pattern pointer
  cb               compile block

Returns: possibly updated parsed_pattern pointer.
*/

static uint32_t *
manage_callouts(PCRE2_SPTR ptr, uint32_t **pcalloutptr, BOOL auto_callout,
  uint32_t *parsed_pattern, compile_block *cb)
{
uint32_t *previous_callout = *pcalloutptr;

if (previous_callout != NULL) previous_callout[2] = (uint32_t)(ptr -
  cb->start_pattern - (PCRE2_SIZE)previous_callout[1]);

if (!auto_callout) previous_callout = NULL; else
  {
  if (previous_callout == NULL ||
      previous_callout != parsed_pattern - 4 ||
      previous_callout[3] != 255)
    {
    previous_callout = parsed_pattern;  /* Set up new automatic callout */
    parsed_pattern += 4;
    previous_callout[0] = META_CALLOUT_NUMBER;
    previous_callout[2] = 0;
    previous_callout[3] = 255;
    }
  previous_callout[1] = (uint32_t)(ptr - cb->start_pattern);
  }

*pcalloutptr = previous_callout;
return parsed_pattern;
}



/*************************************************
*          Handle \d, \D, \s, \S, \w, \W         *
*************************************************/

/* This function is called from parse_regex() below, both for freestanding
escapes, and those within classes, to handle those escapes that may change when
Unicode property support is requested. Note that PCRE2_UCP will never be set
without Unicode support because that is checked when pcre2_compile() is called.

Arguments:
  escape          the ESC_... value
  parsed_pattern  where to add the code
  options         options bits
  xoptions        extra options bits

Returns:          updated value of parsed_pattern
*/
static uint32_t *
handle_escdsw(int escape, uint32_t *parsed_pattern, uint32_t options,
  uint32_t xoptions)
{
uint32_t ascii_option = 0;
uint32_t prop = ESC_p;

switch(escape)
  {
  case ESC_D:
  prop = ESC_P;
  /* Fall through */
  case ESC_d:
  ascii_option = PCRE2_EXTRA_ASCII_BSD;
  break;

  case ESC_S:
  prop = ESC_P;
  /* Fall through */
  case ESC_s:
  ascii_option = PCRE2_EXTRA_ASCII_BSS;
  break;

  case ESC_W:
  prop = ESC_P;
  /* Fall through */
  case ESC_w:
  ascii_option = PCRE2_EXTRA_ASCII_BSW;
  break;
  }

if ((options & PCRE2_UCP) == 0 || (xoptions & ascii_option) != 0)
  {
  *parsed_pattern++ = META_ESCAPE + escape;
  }
else
  {
  *parsed_pattern++ = META_ESCAPE + prop;
  switch(escape)
    {
    case ESC_d:
    case ESC_D:
    *parsed_pattern++ = (PT_PC << 16) | ucp_Nd;
    break;

    case ESC_s:
    case ESC_S:
    *parsed_pattern++ = PT_SPACE << 16;
    break;

    case ESC_w:
    case ESC_W:
    *parsed_pattern++ = PT_WORD << 16;
    break;
    }
  }

return parsed_pattern;
}



/*************************************************
* Maximum size of parsed_pattern for given input *
*************************************************/

/* This function is called from parse_regex() below, to determine the amount
of memory to allocate for parsed_pattern. It is also called to check whether
the amount of data written respects the amount of memory allocated.

Arguments:
  ptr             points to the start of the pattern
  ptrend          points to the end of the pattern
  utf             TRUE in UTF mode
  options         the options bits

Returns:          the number of uint32_t units for parsed_pattern
*/
static ptrdiff_t
max_parsed_pattern(PCRE2_SPTR ptr, PCRE2_SPTR ptrend, BOOL utf,
  uint32_t options)
{
PCRE2_SIZE big32count = 0;
ptrdiff_t parsed_size_needed;

/* When PCRE2_AUTO_CALLOUT is not set, in all but one case the number of
unsigned 32-bit ints written out to the parsed pattern is bounded by the length
of the pattern. The exceptional case is when running in 32-bit, non-UTF mode,
when literal characters greater than META_END (0x80000000) have to be coded as
two units. In this case, therefore, we scan the pattern to check for such
values. */

#if PCRE2_CODE_UNIT_WIDTH == 32
if (!utf)
  {
  PCRE2_SPTR p;
  for (p = ptr; p < ptrend; p++) if (*p >= META_END) big32count++;
  }
#else
(void)utf;  /* Avoid compiler warning */
#endif

parsed_size_needed = (ptrend - ptr) + big32count;

/* When PCRE2_AUTO_CALLOUT is set we have to assume a numerical callout (4
elements) for each character. This is overkill, but memory is plentiful these
days. */

if ((options & PCRE2_AUTO_CALLOUT) != 0)
  parsed_size_needed += (ptrend - ptr) * 4;

return parsed_size_needed;
}



/*************************************************
*      Parse regex and identify named groups     *
*************************************************/

/* This function is called first of all. It scans the pattern and does two
things: (1) It identifies capturing groups and makes a table of named capturing
groups so that information about them is fully available to both the compiling
scans. (2) It writes a parsed version of the pattern with comments omitted and
escapes processed into the parsed_pattern vector.

Arguments:
  ptr             points to the start of the pattern
  options         compiling dynamic options (may change during the scan)
  has_lookbehind  points to a boolean, set TRUE if a lookbehind is found
  cb              pointer to the compile data block

Returns:   zero on success or a non-zero error code, with the
             error offset placed in the cb field
*/

/* A structure and some flags for dealing with nested groups. */

typedef struct nest_save {
  uint16_t  nest_depth;
  uint16_t  reset_group;
  uint16_t  max_group;
  uint16_t  flags;
  uint32_t  options;
  uint32_t  xoptions;
} nest_save;

#define NSF_RESET          0x0001u
#define NSF_CONDASSERT     0x0002u
#define NSF_ATOMICSR       0x0004u

/* Options that are changeable within the pattern must be tracked during
parsing. Some (e.g. PCRE2_EXTENDED) are implemented entirely during parsing,
but all must be tracked so that META_OPTIONS items set the correct values for
the main compiling phase. */

#define PARSE_TRACKED_OPTIONS (PCRE2_CASELESS|PCRE2_DOTALL|PCRE2_DUPNAMES| \
  PCRE2_EXTENDED|PCRE2_EXTENDED_MORE|PCRE2_MULTILINE|PCRE2_NO_AUTO_CAPTURE| \
  PCRE2_UNGREEDY)

#define PARSE_TRACKED_EXTRA_OPTIONS (PCRE2_EXTRA_CASELESS_RESTRICT| \
  PCRE2_EXTRA_ASCII_BSD|PCRE2_EXTRA_ASCII_BSS|PCRE2_EXTRA_ASCII_BSW| \
  PCRE2_EXTRA_ASCII_DIGIT|PCRE2_EXTRA_ASCII_POSIX)

/* States used for analyzing ranges in character classes. The two OK values
must be last. */

enum {
  RANGE_NO, /* State after '[' (initial), or '[a-z'; hyphen is literal */
  RANGE_STARTED, /* State after '[1-'; last-emitted code is META_RANGE_XYZ */
  RANGE_FORBID_NO, /* State after '[\d'; '-]' is allowed but not '-1]' */
  RANGE_FORBID_STARTED, /* State after '[\d-'*/
  RANGE_OK_ESCAPED, /* State after '[\1'; hyphen may be a range */
  RANGE_OK_LITERAL /* State after '[1'; hyphen may be a range */
};

/* States used for analyzing operators and operands in extended character
classes. */

enum {
  CLASS_OP_EMPTY, /* At start of an expression; empty previous contents */
  CLASS_OP_OPERAND, /* Have preceding operand; after "z" a "--" can follow */
  CLASS_OP_OPERATOR /* Have preceding operator; after "--" operand must follow */
};

/* States used for determining the parse mode in character classes. The two
PERL_EXT values must be last. */

enum {
  CLASS_MODE_NORMAL, /* Ordinary PCRE2 '[...]' class. */
  CLASS_MODE_ALT_EXT, /* UTS#18-style extended '[...]' class. */
  CLASS_MODE_PERL_EXT, /* Perl extended '(?[...])' class. */
  CLASS_MODE_PERL_EXT_LEAF /* Leaf within extended '(?[ [...] ])' class. */
};

/* Only in 32-bit mode can there be literals > META_END. A macro encapsulates
the storing of literal values in the main parsed pattern, where they can always
be quantified. */

#if PCRE2_CODE_UNIT_WIDTH == 32
#define PARSED_LITERAL(c, p) \
  { \
  if (c >= META_END) *p++ = META_BIGVALUE; \
  *p++ = c; \
  okquantifier = TRUE; \
  }
#else
#define PARSED_LITERAL(c, p) *p++ = c; okquantifier = TRUE;
#endif

/* Here's the actual function. */

static int parse_regex(PCRE2_SPTR ptr, uint32_t options, uint32_t xoptions,
  BOOL *has_lookbehind, compile_block *cb)
{
uint32_t c;
uint32_t delimiter;
uint32_t namelen;
uint32_t class_range_state;
uint32_t class_op_state;
uint32_t class_mode_state;
uint32_t *class_start;
uint32_t *verblengthptr = NULL;     /* Value avoids compiler warning */
uint32_t *verbstartptr = NULL;
uint32_t *previous_callout = NULL;
uint32_t *parsed_pattern = cb->parsed_pattern;
uint32_t *parsed_pattern_end = cb->parsed_pattern_end;
uint32_t *this_parsed_item = NULL;
uint32_t *prev_parsed_item = NULL;
uint32_t meta_quantifier = 0;
uint32_t add_after_mark = 0;
uint16_t nest_depth = 0;
int16_t class_depth_m1 = -1; /* The m1 means minus 1. */
int16_t class_maxdepth_m1 = -1;
int after_manual_callout = 0;
int expect_cond_assert = 0;
int errorcode = 0;
int escape;
int i;
BOOL inescq = FALSE;
BOOL inverbname = FALSE;
BOOL utf = (options & PCRE2_UTF) != 0;
BOOL auto_callout = (options & PCRE2_AUTO_CALLOUT) != 0;
BOOL isdupname;
BOOL negate_class;
BOOL okquantifier = FALSE;
PCRE2_SPTR thisptr;
PCRE2_SPTR name;
PCRE2_SPTR ptrend = cb->end_pattern;
PCRE2_SPTR verbnamestart = NULL;    /* Value avoids compiler warning */
PCRE2_SPTR class_range_forbid_ptr = NULL;
named_group *ng;
nest_save *top_nest, *end_nests;
#ifdef PCRE2_DEBUG
uint32_t *parsed_pattern_check;
ptrdiff_t parsed_pattern_extra = 0;
ptrdiff_t parsed_pattern_extra_check = 0;
PCRE2_SPTR ptr_check;
#endif

PCRE2_ASSERT(parsed_pattern != NULL);

/* Insert leading items for word and line matching (features provided for the
benefit of pcre2grep). */

if ((xoptions & PCRE2_EXTRA_MATCH_LINE) != 0)
  {
  *parsed_pattern++ = META_CIRCUMFLEX;
  *parsed_pattern++ = META_NOCAPTURE;
  }
else if ((xoptions & PCRE2_EXTRA_MATCH_WORD) != 0)
  {
  *parsed_pattern++ = META_ESCAPE + ESC_b;
  *parsed_pattern++ = META_NOCAPTURE;
  }

#ifdef PCRE2_DEBUG
parsed_pattern_check = parsed_pattern;
ptr_check = ptr;
#endif

/* If the pattern is actually a literal string, process it separately to avoid
cluttering up the main loop. */

if ((options & PCRE2_LITERAL) != 0)
  {
  while (ptr < ptrend)
    {
    if (parsed_pattern >= parsed_pattern_end)
      {
      PCRE2_DEBUG_UNREACHABLE();
      errorcode = ERR63;  /* Internal error (parsed pattern overflow) */
      goto FAILED;
      }
    thisptr = ptr;
    GETCHARINCTEST(c, ptr);
    if (auto_callout)
      parsed_pattern = manage_callouts(thisptr, &previous_callout,
        auto_callout, parsed_pattern, cb);
    PARSED_LITERAL(c, parsed_pattern);
    }
  goto PARSED_END;
  }

/* Process a real regex which may contain meta-characters. */

top_nest = NULL;
end_nests = (nest_save *)(cb->start_workspace + cb->workspace_size);

/* The size of the nest_save structure might not be a factor of the size of the
workspace. Therefore we must round down end_nests so as to correctly avoid
creating a nest_save that spans the end of the workspace. */

end_nests = (nest_save *)((char *)end_nests -
  ((cb->workspace_size * sizeof(PCRE2_UCHAR)) % sizeof(nest_save)));

/* PCRE2_EXTENDED_MORE implies PCRE2_EXTENDED */

if ((options & PCRE2_EXTENDED_MORE) != 0) options |= PCRE2_EXTENDED;

/* Now scan the pattern */

while (ptr < ptrend)
  {
  int prev_expect_cond_assert;
  uint32_t min_repeat = 0, max_repeat = 0;
  uint32_t set, unset, *optset;
  uint32_t xset, xunset, *xoptset;
  uint32_t terminator;
  uint32_t prev_meta_quantifier;
  BOOL prev_okquantifier;
  PCRE2_SPTR tempptr;
  PCRE2_SIZE offset;

  if (nest_depth > cb->cx->parens_nest_limit)
    {
    errorcode = ERR19;
    goto FAILED;        /* Parentheses too deeply nested */
    }

  /* Check that we haven't emitted too much into parsed_pattern. We allocate
  a suitably-sized buffer upfront, then do unchecked writes to it. If we only
  write a little bit too much, everything will appear to be OK, because the
  upfront size is an overestimate... but a malicious pattern could end up
  forcing a write past the buffer end. We must catch this during
  development. */

#ifdef PCRE2_DEBUG
  /* Strong post-write check. Won't help in release builds - at this point
  the write has already occurred so it's too late. However, should stop us
  committing unsafe code. */
  PCRE2_ASSERT((parsed_pattern - parsed_pattern_check) +
               (parsed_pattern_extra - parsed_pattern_extra_check) <=
                 max_parsed_pattern(ptr_check, ptr, utf, options));
  parsed_pattern_check = parsed_pattern;
  parsed_pattern_extra_check = parsed_pattern_extra;
  ptr_check = ptr;
#endif

  if (parsed_pattern >= parsed_pattern_end)
    {
    /* Weak pre-write check; only ensures parsed_pattern[0] is writeable
    (but the code below can write many chars). Better than nothing. */
    PCRE2_DEBUG_UNREACHABLE();
    errorcode = ERR63;  /* Internal error (parsed pattern overflow) */
    goto FAILED;
    }

  /* If the last time round this loop something was added, parsed_pattern will
  no longer be equal to this_parsed_item. Remember where the previous item
  started and reset for the next item. Note that sometimes round the loop,
  nothing gets added (e.g. for ignored white space). */

  if (this_parsed_item != parsed_pattern)
    {
    prev_parsed_item = this_parsed_item;
    this_parsed_item = parsed_pattern;
    }

  /* Get next input character, save its position for callout handling. */

  thisptr = ptr;
  GETCHARINCTEST(c, ptr);

  /* Copy quoted literals until \E, allowing for the possibility of automatic
  callouts, except when processing a (*VERB) "name".  */

  if (inescq)
    {
    if (c == CHAR_BACKSLASH && ptr < ptrend && *ptr == CHAR_E)
      {
      inescq = FALSE;
      ptr++;   /* Skip E */
      }
    else
      {
      if (expect_cond_assert > 0)   /* A literal is not allowed if we are */
        {                           /* expecting a conditional assertion, */
        ptr--;                      /* but an empty \Q\E sequence is OK.  */
        errorcode = ERR28;
        goto FAILED;
        }
      if (inverbname)
        {                          /* Don't use PARSED_LITERAL() because it */
#if PCRE2_CODE_UNIT_WIDTH == 32    /* sets okquantifier. */
        if (c >= META_END) *parsed_pattern++ = META_BIGVALUE;
#endif
        *parsed_pattern++ = c;
        }
      else
        {
        if (after_manual_callout-- <= 0)
          parsed_pattern = manage_callouts(thisptr, &previous_callout,
            auto_callout, parsed_pattern, cb);
        PARSED_LITERAL(c, parsed_pattern);
        }
      meta_quantifier = 0;
      }
    continue;  /* Next character */
    }

  /* If we are processing the "name" part of a (*VERB:NAME) item, all
  characters up to the closing parenthesis are literals except when
  PCRE2_ALT_VERBNAMES is set. That causes backslash interpretation, but only \Q
  and \E and escaped characters are allowed (no character types such as \d). If
  PCRE2_EXTENDED is also set, we must ignore white space and # comments. Do
  this by not entering the special (*VERB:NAME) processing - they are then
  picked up below. Note that c is a character, not a code unit, so we must not
  use MAX_255 to test its size because MAX_255 tests code units and is assumed
  TRUE in 8-bit mode. */

  if (inverbname &&
       (
        /* EITHER: not both options set */
        ((options & (PCRE2_EXTENDED | PCRE2_ALT_VERBNAMES)) !=
                    (PCRE2_EXTENDED | PCRE2_ALT_VERBNAMES)) ||
#ifdef SUPPORT_UNICODE
        /* OR: character > 255 AND not Unicode Pattern White Space */
        (c > 255 && (c|1) != 0x200f && (c|1) != 0x2029) ||
#endif
        /* OR: not a # comment or isspace() white space */
        (c < 256 && c != CHAR_NUMBER_SIGN && (cb->ctypes[c] & ctype_space) == 0
#ifdef SUPPORT_UNICODE
        /* and not CHAR_NEL when Unicode is supported */
          && c != CHAR_NEL
#endif
       )))
    {
    PCRE2_SIZE verbnamelength;

    switch(c)
      {
      default:                     /* Don't use PARSED_LITERAL() because it */
#if PCRE2_CODE_UNIT_WIDTH == 32    /* sets okquantifier. */
      if (c >= META_END) *parsed_pattern++ = META_BIGVALUE;
#endif
      *parsed_pattern++ = c;
      break;

      case CHAR_RIGHT_PARENTHESIS:
      inverbname = FALSE;
      /* This is the length in characters */
      verbnamelength = (PCRE2_SIZE)(parsed_pattern - verblengthptr - 1);
      /* But the limit on the length is in code units */
      if (ptr - verbnamestart - 1 > (int)MAX_MARK)
        {
        ptr--;
        errorcode = ERR76;
        goto FAILED;
        }
      *verblengthptr = (uint32_t)verbnamelength;

      /* If this name was on a verb such as (*ACCEPT) which does not continue,
      a (*MARK) was generated for the name. We now add the original verb as the
      next item. */

      if (add_after_mark != 0)
        {
        *parsed_pattern++ = add_after_mark;
        add_after_mark = 0;
        }
      break;

      case CHAR_BACKSLASH:
      if ((options & PCRE2_ALT_VERBNAMES) != 0)
        {
        escape = PRIV(check_escape)(&ptr, ptrend, &c, &errorcode, options,
          xoptions, cb->bracount, FALSE, cb);
        if (errorcode != 0) goto FAILED;
        }
      else escape = 0;   /* Treat all as literal */

      switch(escape)
        {
        case 0:                    /* Don't use PARSED_LITERAL() because it */
#if PCRE2_CODE_UNIT_WIDTH == 32    /* sets okquantifier. */
        if (c >= META_END) *parsed_pattern++ = META_BIGVALUE;
#endif
        *parsed_pattern++ = c;
        break;

        case ESC_ub:
        *parsed_pattern++ = CHAR_u;
        PARSED_LITERAL(CHAR_LEFT_CURLY_BRACKET, parsed_pattern);
        break;

        case ESC_Q:
        inescq = TRUE;
        break;

        case ESC_E:           /* Ignore */
        break;

        default:
        errorcode = ERR40;    /* Invalid in verb name */
        goto FAILED;
        }
      }
    continue;   /* Next character in pattern */
    }

  /* Not a verb name character. At this point we must process everything that
  must not change the quantification state. This is mainly comments, but we
  handle \Q and \E here as well, so that an item such as A\Q\E+ is treated as
  A+, as in Perl. An isolated \E is ignored. */

  if (c == CHAR_BACKSLASH && ptr < ptrend)
    {
    if (*ptr == CHAR_Q || *ptr == CHAR_E)
      {
      inescq = *ptr == CHAR_Q;
      ptr++;
      continue;
      }
    }

  /* Skip over whitespace and # comments in extended mode. Note that c is a
  character, not a code unit, so we must not use MAX_255 to test its size
  because MAX_255 tests code units and is assumed TRUE in 8-bit mode. The
  whitespace characters are those designated as "Pattern White Space" by
  Unicode, which are the isspace() characters plus CHAR_NEL (newline), which is
  U+0085 in Unicode, plus U+200E, U+200F, U+2028, and U+2029. These are a
  subset of space characters that match \h and \v. */

  if ((options & PCRE2_EXTENDED) != 0)
    {
    if (c < 256 && (cb->ctypes[c] & ctype_space) != 0) continue;
#ifdef SUPPORT_UNICODE
    if (c == CHAR_NEL || (c|1) == 0x200f || (c|1) == 0x2029) continue;
#endif
    if (c == CHAR_NUMBER_SIGN)
      {
      while (ptr < ptrend)
        {
        if (IS_NEWLINE(ptr))      /* For non-fixed-length newline cases, */
          {                       /* IS_NEWLINE sets cb->nllen. */
          ptr += cb->nllen;
          break;
          }
        ptr++;
#ifdef SUPPORT_UNICODE
        if (utf) FORWARDCHARTEST(ptr, ptrend);
#endif
        }
      continue;  /* Next character in pattern */
      }
    }

  /* Skip over bracketed comments */

  if (c == CHAR_LEFT_PARENTHESIS && ptrend - ptr >= 2 &&
      ptr[0] == CHAR_QUESTION_MARK && ptr[1] == CHAR_NUMBER_SIGN)
    {
    while (++ptr < ptrend && *ptr != CHAR_RIGHT_PARENTHESIS);
    if (ptr >= ptrend)
      {
      errorcode = ERR18;  /* A special error for missing ) in a comment */
      goto FAILED;        /* to make it easier to debug. */
      }
    ptr++;
    continue;  /* Next character in pattern */
    }

  /* If the next item is not a quantifier, fill in length of any previous
  callout and create an auto callout if required. */

  if (c != CHAR_ASTERISK && c != CHAR_PLUS && c != CHAR_QUESTION_MARK &&
       (c != CHAR_LEFT_CURLY_BRACKET ||
         (tempptr = ptr,
         !read_repeat_counts(&tempptr, ptrend, NULL, NULL, &errorcode))))
    {
    if (after_manual_callout-- <= 0)
      {
      parsed_pattern = manage_callouts(thisptr, &previous_callout, auto_callout,
        parsed_pattern, cb);
      this_parsed_item = parsed_pattern;  /* New start for current item */
      }
    }

  /* If expect_cond_assert is 2, we have just passed (?( and are expecting an
  assertion, possibly preceded by a callout. If the value is 1, we have just
  had the callout and expect an assertion. There must be at least 3 more
  characters in all cases. When expect_cond_assert is 2, we know that the
  current character is an opening parenthesis, as otherwise we wouldn't be
  here. However, when it is 1, we need to check, and it's easiest just to check
  always. Note that expect_cond_assert may be negative, since all callouts just
  decrement it. */

  if (expect_cond_assert > 0)
    {
    BOOL ok = c == CHAR_LEFT_PARENTHESIS && ptrend - ptr >= 3 &&
              (ptr[0] == CHAR_QUESTION_MARK || ptr[0] == CHAR_ASTERISK);
    if (ok)
      {
      if (ptr[0] == CHAR_ASTERISK)  /* New alpha assertion format, possibly */
        {
        ok = MAX_255(ptr[1]) && (cb->ctypes[ptr[1]] & ctype_lcletter) != 0;
        }
      else switch(ptr[1])  /* Traditional symbolic format */
        {
        case CHAR_C:
        ok = expect_cond_assert == 2;
        break;

        case CHAR_EQUALS_SIGN:
        case CHAR_EXCLAMATION_MARK:
        break;

        case CHAR_LESS_THAN_SIGN:
        ok = ptr[2] == CHAR_EQUALS_SIGN || ptr[2] == CHAR_EXCLAMATION_MARK;
        break;

        default:
        ok = FALSE;
        }
      }

    if (!ok)
      {
      ptr--;   /* Adjust error offset */
      errorcode = ERR28;
      goto FAILED;
      }
    }

  /* Remember whether we are expecting a conditional assertion, and set the
  default for this item. */

  prev_expect_cond_assert = expect_cond_assert;
  expect_cond_assert = 0;

  /* Remember quantification status for the previous significant item, then set
  default for this item. */

  prev_okquantifier = okquantifier;
  prev_meta_quantifier = meta_quantifier;
  okquantifier = FALSE;
  meta_quantifier = 0;

  /* If the previous significant item was a quantifier, adjust the parsed code
  if there is a following modifier. The base meta value is always followed by
  the PLUS and QUERY values, in that order. We do this here rather than after
  reading a quantifier so that intervening comments and /x whitespace can be
  ignored without having to replicate code. */

  if (prev_meta_quantifier != 0 && (c == CHAR_QUESTION_MARK || c == CHAR_PLUS))
    {
    parsed_pattern[(prev_meta_quantifier == META_MINMAX)? -3 : -1] =
      prev_meta_quantifier + ((c == CHAR_QUESTION_MARK)?
        0x00020000u : 0x00010000u);
    continue;  /* Next character in pattern */
    }

  /* Process the next item in the main part of a pattern. */

  switch(c)
    {
    default:              /* Non-special character */
    PARSED_LITERAL(c, parsed_pattern);
    break;


    /* ---- Escape sequence ---- */

    case CHAR_BACKSLASH:
    tempptr = ptr;
    escape = PRIV(check_escape)(&ptr, ptrend, &c, &errorcode, options,
      xoptions, cb->bracount, FALSE, cb);
    if (errorcode != 0)
      {
      ESCAPE_FAILED:
      if ((xoptions & PCRE2_EXTRA_BAD_ESCAPE_IS_LITERAL) == 0)
        goto FAILED;
      ptr = tempptr;
      if (ptr >= ptrend) c = CHAR_BACKSLASH; else
        {
        GETCHARINCTEST(c, ptr);   /* Get character value, increment pointer */
        }
      escape = 0;                 /* Treat as literal character */
      }

    /* The escape was a data escape or literal character. */

    if (escape == 0)
      {
      PARSED_LITERAL(c, parsed_pattern);
      }

    /* The escape was a back (or forward) reference. We keep the offset in
    order to give a more useful diagnostic for a bad forward reference. For
    references to groups numbered less than 10 we can't use more than two items
    in parsed_pattern because they may be just two characters in the input (and
    in a 64-bit world an offset may need two elements). So for them, the offset
    of the first occurrent is held in a special vector. */

    else if (escape < 0)
      {
      offset = (PCRE2_SIZE)(ptr - cb->start_pattern - 1);
      escape = -escape - 1;
      *parsed_pattern++ = META_BACKREF | (uint32_t)escape;
      if (escape < 10)
        {
        if (cb->small_ref_offset[escape] == PCRE2_UNSET)
          cb->small_ref_offset[escape] = offset;
        }
      else
        {
        PUTOFFSET(offset, parsed_pattern);
        }
      okquantifier = TRUE;
      }

    /* The escape was a character class such as \d etc. or other special
    escape indicator such as \A or \X. Most of them generate just a single
    parsed item, but \P and \p are followed by a 16-bit type and a 16-bit
    value. They are supported only when Unicode is available. The type and
    value are packed into a single 32-bit value so that the whole sequences
    uses only two elements in the parsed_vector. This is because the same
    coding is used if \d (for example) is turned into \p{Nd} when PCRE2_UCP is
    set.

    There are also some cases where the escape sequence is followed by a name:
    \k{name}, \k<name>, and \k'name' are backreferences by name, and \g<name>
    and \g'name' are subroutine calls by name; \g{name} is a synonym for
    \k{name}. Note that \g<number> and \g'number' are handled by check_escape()
    and returned as a negative value (handled above). A name is coded as an
    offset into the pattern and a length. */

    else switch (escape)
      {
      case ESC_C:
#ifdef NEVER_BACKSLASH_C
      errorcode = ERR85;
      goto ESCAPE_FAILED;
#else
      if ((options & PCRE2_NEVER_BACKSLASH_C) != 0)
        {
        errorcode = ERR83;
        goto ESCAPE_FAILED;
        }
#endif
      okquantifier = TRUE;
      *parsed_pattern++ = META_ESCAPE + escape;
      break;

      /* This is a special return that happens only in EXTRA_ALT_BSUX mode,
      when \u{ is not followed by hex digits and }. It requests two literal
      characters, u and { and we need this, as otherwise \u{ 12} (for example)
      would be treated as u{12} now that spaces are allowed in quantifiers. */

      case ESC_ub:
      *parsed_pattern++ = CHAR_u;
      PARSED_LITERAL(CHAR_LEFT_CURLY_BRACKET, parsed_pattern);
      break;

      case ESC_X:
#ifndef SUPPORT_UNICODE
      errorcode = ERR45;   /* Supported only with Unicode support */
      goto ESCAPE_FAILED;
#endif
      case ESC_H:
      case ESC_h:
      case ESC_N:
      case ESC_R:
      case ESC_V:
      case ESC_v:
      okquantifier = TRUE;
      *parsed_pattern++ = META_ESCAPE + escape;
      break;

      default:  /* \A, \B, \b, \G, \K, \Z, \z cannot be quantified. */
      *parsed_pattern++ = META_ESCAPE + escape;
      break;

      /* Escapes that may change in UCP mode. */

      case ESC_d:
      case ESC_D:
      case ESC_s:
      case ESC_S:
      case ESC_w:
      case ESC_W:
      okquantifier = TRUE;
      parsed_pattern = handle_escdsw(escape, parsed_pattern, options,
        xoptions);
      break;

      /* Unicode property matching */

      case ESC_P:
      case ESC_p:
#ifdef SUPPORT_UNICODE
        {
        BOOL negated;
        uint16_t ptype = 0, pdata = 0;
        if (!get_ucp(&ptr, &negated, &ptype, &pdata, &errorcode, cb))
          goto ESCAPE_FAILED;
        if (negated) escape = (escape == ESC_P)? ESC_p : ESC_P;
        *parsed_pattern++ = META_ESCAPE + escape;
        *parsed_pattern++ = (ptype << 16) | pdata;
        okquantifier = TRUE;
        }
#else
      errorcode = ERR45;
      goto ESCAPE_FAILED;
#endif
      break;  /* End \P and \p */

      /* When \g is used with quotes or angle brackets as delimiters, it is a
      numerical or named subroutine call, and control comes here. When used
      with brace delimiters it is a numerical back reference and does not come
      here because check_escape() returns it directly as a reference. \k is
      always a named back reference. */

      case ESC_g:
      case ESC_k:
      if (ptr >= ptrend || (*ptr != CHAR_LEFT_CURLY_BRACKET &&
          *ptr != CHAR_LESS_THAN_SIGN && *ptr != CHAR_APOSTROPHE))
        {
        errorcode = (escape == ESC_g)? ERR57 : ERR69;
        goto ESCAPE_FAILED;
        }
      terminator = (*ptr == CHAR_LESS_THAN_SIGN)?
        CHAR_GREATER_THAN_SIGN : (*ptr == CHAR_APOSTROPHE)?
        CHAR_APOSTROPHE : CHAR_RIGHT_CURLY_BRACKET;

      /* For a non-braced \g, check for a numerical recursion. */

      if (escape == ESC_g && terminator != CHAR_RIGHT_CURLY_BRACKET)
        {
        PCRE2_SPTR p = ptr + 1;

        if (read_number(&p, ptrend, cb->bracount, MAX_GROUP_NUMBER, ERR61, &i,
            &errorcode))
          {
          if (p >= ptrend || *p != terminator)
            {
            errorcode = ERR57;
            goto ESCAPE_FAILED;
            }
          ptr = p;
          goto SET_RECURSION;
          }
        if (errorcode != 0) goto ESCAPE_FAILED;
        }

      /* Not a numerical recursion. Perl allows spaces and tabs after { and
      before } but not for other delimiters. */

      if (!read_name(&ptr, ptrend, utf, terminator, &offset, &name, &namelen,
          &errorcode, cb)) goto ESCAPE_FAILED;

      /* \k and \g when used with braces are back references, whereas \g used
      with quotes or angle brackets is a recursion */

      *parsed_pattern++ =
        (escape == ESC_k || terminator == CHAR_RIGHT_CURLY_BRACKET)?
          META_BACKREF_BYNAME : META_RECURSE_BYNAME;
      *parsed_pattern++ = namelen;

      PUTOFFSET(offset, parsed_pattern);
      okquantifier = TRUE;
      break;  /* End special escape processing */
      }
    break;    /* End escape sequence processing */


    /* ---- Single-character special items ---- */

    case CHAR_CIRCUMFLEX_ACCENT:
    *parsed_pattern++ = META_CIRCUMFLEX;
    break;

    case CHAR_DOLLAR_SIGN:
    *parsed_pattern++ = META_DOLLAR;
    break;

    case CHAR_DOT:
    *parsed_pattern++ = META_DOT;
    okquantifier = TRUE;
    break;


    /* ---- Single-character quantifiers ---- */

    case CHAR_ASTERISK:
    meta_quantifier = META_ASTERISK;
    goto CHECK_QUANTIFIER;

    case CHAR_PLUS:
    meta_quantifier = META_PLUS;
    goto CHECK_QUANTIFIER;

    case CHAR_QUESTION_MARK:
    meta_quantifier = META_QUERY;
    goto CHECK_QUANTIFIER;


    /* ---- Potential {n,m} quantifier ---- */

    case CHAR_LEFT_CURLY_BRACKET:
    if (!read_repeat_counts(&ptr, ptrend, &min_repeat, &max_repeat,
        &errorcode))
      {
      if (errorcode != 0) goto FAILED;     /* Error in quantifier. */
      PARSED_LITERAL(c, parsed_pattern);   /* Not a quantifier */
      break;                               /* No more quantifier processing */
      }
    meta_quantifier = META_MINMAX;
    /* Fall through */


    /* ---- Quantifier post-processing ---- */

    /* Check that a quantifier is allowed after the previous item. This
    guarantees that there is a previous item. */

    CHECK_QUANTIFIER:
    if (!prev_okquantifier)
      {
      errorcode = ERR9;
      goto FAILED_BACK;  // TODO https://github.com/PCRE2Project/pcre2/issues/549
      }

    /* Most (*VERB)s are not allowed to be quantified, but an ungreedy
    quantifier can be useful for (*ACCEPT) - meaning "succeed on backtrack", a
    sort of negated (*COMMIT). We therefore allow (*ACCEPT) to be quantified by
    wrapping it in non-capturing brackets, but we have to allow for a preceding
    (*MARK) for when (*ACCEPT) has an argument. */

    if (*prev_parsed_item == META_ACCEPT)
      {
      uint32_t *p;
      for (p = parsed_pattern - 1; p >= verbstartptr; p--) p[1] = p[0];
      *verbstartptr = META_NOCAPTURE;
      parsed_pattern[1] = META_KET;
      parsed_pattern += 2;

#ifdef PCRE2_DEBUG
      PCRE2_ASSERT(parsed_pattern_extra >= 2);
      parsed_pattern_extra -= 2;
#endif
      }

    /* Now we can put the quantifier into the parsed pattern vector. At this
    stage, we have only the basic quantifier. The check for a following + or ?
    modifier happens at the top of the loop, after any intervening comments
    have been removed. */

    *parsed_pattern++ = meta_quantifier;
    if (c == CHAR_LEFT_CURLY_BRACKET)
      {
      *parsed_pattern++ = min_repeat;
      *parsed_pattern++ = max_repeat;
      }
    break;


    /* ---- Character class ---- */

    case CHAR_LEFT_SQUARE_BRACKET:

    /* In another (POSIX) regex library, the ugly syntax [[:<:]] and [[:>:]] is
    used for "start of word" and "end of word". As these are otherwise illegal
    sequences, we don't break anything by recognizing them. They are replaced
    by \b(?=\w) and \b(?<=\w) respectively. Sequences like [a[:<:]] are
    erroneous and are handled by the normal code below. */

    if (ptrend - ptr >= 6 &&
         (PRIV(strncmp_c8)(ptr, STRING_WEIRD_STARTWORD, 6) == 0 ||
          PRIV(strncmp_c8)(ptr, STRING_WEIRD_ENDWORD, 6) == 0))
      {
      *parsed_pattern++ = META_ESCAPE + ESC_b;

      if (ptr[2] == CHAR_LESS_THAN_SIGN)
        {
        *parsed_pattern++ = META_LOOKAHEAD;
        }
      else
        {
        *parsed_pattern++ = META_LOOKBEHIND;
        *has_lookbehind = TRUE;

        /* The offset is used only for the "non-fixed length" error; this won't
        occur here, so just store zero. */

        PUTOFFSET((PCRE2_SIZE)0, parsed_pattern);
        }

      if ((options & PCRE2_UCP) == 0)
        *parsed_pattern++ = META_ESCAPE + ESC_w;
      else
        {
        *parsed_pattern++ = META_ESCAPE + ESC_p;
        *parsed_pattern++ = PT_WORD << 16;
        }
      *parsed_pattern++ = META_KET;
      ptr += 6;
      okquantifier = TRUE;
      break;
      }

    /* PCRE supports POSIX class stuff inside a class. Perl gives an error if
    they are encountered at the top level, so we'll do that too. */

    if (ptr < ptrend && (*ptr == CHAR_COLON || *ptr == CHAR_DOT ||
         *ptr == CHAR_EQUALS_SIGN) &&
        check_posix_syntax(ptr, ptrend, &tempptr))
      {
      errorcode = (*ptr-- == CHAR_COLON)? ERR12 : ERR13;
      goto FAILED;
      }

    class_mode_state = ((options & PCRE2_ALT_EXTENDED_CLASS) != 0)?
        CLASS_MODE_ALT_EXT : CLASS_MODE_NORMAL;

    /* Jump here from '(?[...])'. That jump must initialize class_mode_state,
    set c to the '[' character, and ptr to just after the '['. */

    FROM_PERL_EXTENDED_CLASS:
    okquantifier = TRUE;

    /* In an EBCDIC environment, Perl treats alphabetic ranges specially
    because there are holes in the encoding, and simply using the range A-Z
    (for example) would include the characters in the holes. This applies only
    to ranges where both values are literal; [\xC1-\xE9] is different to [A-Z]
    in this respect. In order to accommodate this, we keep track of whether
    character values are literal or not, and a state variable for handling
    ranges. */

    /* Loop for the contents of the class. Classes may be nested, if
    PCRE2_ALT_EXTENDED_CLASS is set, or the class is of the form (?[...]). */

    /* c is still set to '[' so the loop will handle the start of the class. */

    class_depth_m1 = -1;
    class_maxdepth_m1 = -1;
    class_range_state = RANGE_NO;
    class_op_state = CLASS_OP_EMPTY;
    class_start = NULL;

    for (;;)
      {
      BOOL char_is_literal = TRUE;

      /* Inside \Q...\E everything is literal except \E */

      if (inescq)
        {
        if (c == CHAR_BACKSLASH && ptr < ptrend && *ptr == CHAR_E)
          {
          inescq = FALSE;                   /* Reset literal state */
          ptr++;                            /* Skip the 'E' */
          goto CLASS_CONTINUE;
          }

        /* Surprisingly, you cannot use \Q..\E to escape a character inside a
        Perl extended class. However, empty \Q\E sequences are allowed, so here
        were're only giving an error if the \Q..\E is non-empty. */

        if (class_mode_state == CLASS_MODE_PERL_EXT)
          {
          errorcode = ERR116;
          goto FAILED;
          }

        goto CLASS_LITERAL;
        }

      /* Skip over space and tab (only) in extended-more mode, or anywhere
      inside a Perl extended class (which implies /xx). */

      if ((c == CHAR_SPACE || c == CHAR_HT) &&
          ((options & PCRE2_EXTENDED_MORE) != 0 ||
           class_mode_state >= CLASS_MODE_PERL_EXT))
        goto CLASS_CONTINUE;

      /* Handle POSIX class names. Perl allows a negation extension of the
      form [:^name:]. A square bracket that doesn't match the syntax is
      treated as a literal. We also recognize the POSIX constructions
      [.ch.] and [=ch=] ("collating elements") and fault them, as Perl
      5.6 and 5.8 do. */

      if (class_depth_m1 >= 0 &&
          c == CHAR_LEFT_SQUARE_BRACKET &&
          ptrend - ptr >= 3 &&
          (*ptr == CHAR_COLON || *ptr == CHAR_DOT ||
           *ptr == CHAR_EQUALS_SIGN) &&
          check_posix_syntax(ptr, ptrend, &tempptr))
        {
        BOOL posix_negate = FALSE;
        int posix_class;

        /* Perl treats a hyphen before a POSIX class as a literal, not the
        start of a range. However, it gives a warning in its warning mode. PCRE
        does not have a warning mode, so we give an error, because this is
        likely an error on the user's part. */

        if (class_range_state == RANGE_STARTED)
          {
          ptr = tempptr + 2;
          errorcode = ERR50;
          goto FAILED;
          }

        /* Perl treats a hyphen after a POSIX class as a literal, not the
        start of a range. However, it gives a warning in its warning mode
        unless the hyphen is the last character in the class. PCRE does not
        have a warning mode, so we give an error, because this is likely an
        error on the user's part.

        Roll back to the hyphen for the error position. */

        if (class_range_state == RANGE_FORBID_STARTED)
          {
          ptr = class_range_forbid_ptr;
          errorcode = ERR50;
          goto FAILED;
          }

        /* Disallow implicit union in Perl extended classes. */

        if (class_op_state == CLASS_OP_OPERAND &&
            class_mode_state == CLASS_MODE_PERL_EXT)
          {
          ptr = tempptr + 2;
          errorcode = ERR113;
          goto FAILED;
          }

        if (*ptr != CHAR_COLON)
          {
          ptr = tempptr + 2;
          errorcode = ERR13;
          goto FAILED;
          }

        if (*(++ptr) == CHAR_CIRCUMFLEX_ACCENT)
          {
          posix_negate = TRUE;
          ptr++;
          }

        posix_class = check_posix_name(ptr, (int)(tempptr - ptr));
        ptr = tempptr + 2;
        if (posix_class < 0)
          {
          errorcode = ERR30;
          goto FAILED;
          }

        /* Set "a hyphen is forbidden to be the start of a range". For the '-]'
        case, the hyphen is treated as a literal, but for '-1' it is disallowed
        (because it would be interpreted as range). */

        class_range_state = RANGE_FORBID_NO;
        class_op_state = CLASS_OP_OPERAND;

        /* When PCRE2_UCP is set, unless PCRE2_EXTRA_ASCII_POSIX is set, some
        of the POSIX classes are converted to use Unicode properties \p or \P
        or, in one case, \h or \H. The substitutes table has two values per
        class, containing the type and value of a \p or \P item. The special
        cases are specified with a negative type: a non-zero value causes \h or
        \H to be used, and a zero value falls through to behave like a non-UCP
        POSIX class. There are now also some extra options that force ASCII for
        some classes. */

#ifdef SUPPORT_UNICODE
        if ((options & PCRE2_UCP) != 0 &&
            (xoptions & PCRE2_EXTRA_ASCII_POSIX) == 0 &&
            !((xoptions & PCRE2_EXTRA_ASCII_DIGIT) != 0 &&
              (posix_class == PC_DIGIT || posix_class == PC_XDIGIT)))
          {
          int ptype = posix_substitutes[2*posix_class];
          int pvalue = posix_substitutes[2*posix_class + 1];

          if (ptype >= 0)
            {
            *parsed_pattern++ = META_ESCAPE + (posix_negate? ESC_P : ESC_p);
            *parsed_pattern++ = (ptype << 16) | pvalue;
            goto CLASS_CONTINUE;
            }

          if (pvalue != 0)
            {
            *parsed_pattern++ = META_ESCAPE + (posix_negate? ESC_H : ESC_h);
            goto CLASS_CONTINUE;
            }

          /* Fall through */
          }
#endif  /* SUPPORT_UNICODE */

        /* Non-UCP POSIX class */

        *parsed_pattern++ = posix_negate? META_POSIX_NEG : META_POSIX;
        *parsed_pattern++ = posix_class;
        }

      /* Check for the start of the outermost class, or the start of a nested class. */

      else if ((c == CHAR_LEFT_SQUARE_BRACKET &&
                (class_depth_m1 < 0 || class_mode_state == CLASS_MODE_ALT_EXT ||
                 class_mode_state == CLASS_MODE_PERL_EXT)) ||
               (c == CHAR_LEFT_PARENTHESIS &&
                class_mode_state == CLASS_MODE_PERL_EXT))
        {
        uint32_t start_c = c;
        uint32_t new_class_mode_state;

        /* Update the class mode, if moving into a 'leaf' inside a Perl extended
        class. */

        if (start_c == CHAR_LEFT_SQUARE_BRACKET &&
            class_mode_state == CLASS_MODE_PERL_EXT && class_depth_m1 >= 0)
          new_class_mode_state = CLASS_MODE_PERL_EXT_LEAF;
        else
          new_class_mode_state = class_mode_state;

        /* Tidy up the other class before starting the nested class. */
        /* -[ beginning a nested class is a literal '-' */

        if (class_range_state == RANGE_STARTED)
          parsed_pattern[-1] = CHAR_MINUS;

        /* Disallow implicit union in Perl extended classes. */

        if (class_op_state == CLASS_OP_OPERAND &&
            class_mode_state == CLASS_MODE_PERL_EXT)
          {
          errorcode = ERR113;
          goto FAILED;
          }

        /* Validate nesting depth */
        if (class_depth_m1 >= ECLASS_NEST_LIMIT - 1)
          {
          errorcode = ERR107;
          goto FAILED;        /* Classes too deeply nested */
          }

        /* Process the character class start. If the first character is '^', set
        the negation flag. If the first few characters (either before or after ^)
        are \Q\E or \E or space or tab in extended-more mode, we skip them too.
        This makes for compatibility with Perl. */

        negate_class = FALSE;
        for (;;)
          {
          if (ptr >= ptrend)
            {
            if (start_c == CHAR_LEFT_PARENTHESIS)
              errorcode = ERR14;  /* Missing terminating ')' */
            else
              errorcode = ERR6;   /* Missing terminating ']' */
            goto FAILED;
            }

          GETCHARINCTEST(c, ptr);
          if (new_class_mode_state == CLASS_MODE_PERL_EXT) break;
          else if (c == CHAR_BACKSLASH)
            {
            if (ptr < ptrend && *ptr == CHAR_E) ptr++;
            else if (ptrend - ptr >= 3 &&
                PRIV(strncmp_c8)(ptr, STR_Q STR_BACKSLASH STR_E, 3) == 0)
              ptr += 3;
            else
              break;
            }
          else if ((c == CHAR_SPACE || c == CHAR_HT) &&  /* Note: just these two */
                   ((options & PCRE2_EXTENDED_MORE) != 0 ||
                    new_class_mode_state >= CLASS_MODE_PERL_EXT))
            continue;
          else if (!negate_class && c == CHAR_CIRCUMFLEX_ACCENT)
            negate_class = TRUE;
          else break;
          }

        /* Now the real contents of the class; c has the first "real" character.
        Empty classes are permitted only if the option is set, and if it's not
        a Perl-extended class. */

        if (c == CHAR_RIGHT_SQUARE_BRACKET &&
            (cb->external_options & PCRE2_ALLOW_EMPTY_CLASS) != 0 &&
            new_class_mode_state < CLASS_MODE_PERL_EXT)
          {
          PCRE2_ASSERT(start_c == CHAR_LEFT_SQUARE_BRACKET);

          if (class_start != NULL)
            {
            PCRE2_ASSERT(class_depth_m1 >= 0);
            /* Represents that the class is an extended class. */
            *class_start |= CLASS_IS_ECLASS;
            class_start = NULL;
            }

          *parsed_pattern++ = negate_class? META_CLASS_EMPTY_NOT : META_CLASS_EMPTY;

          /* Leave nesting depth unchanged; but check for zero depth to handle the
          very first (top-level) class being empty. */
          if (class_depth_m1 < 0) break;

          class_range_state = RANGE_NO; /* for processing the containing class */
          class_op_state = CLASS_OP_OPERAND;
          goto CLASS_CONTINUE;
          }

        /* Enter a non-empty class. */

        if (class_start != NULL)
          {
          PCRE2_ASSERT(class_depth_m1 >= 0);
          /* Represents that the class is an extended class. */
          *class_start |= CLASS_IS_ECLASS;
          class_start = NULL;
          }

        class_start = parsed_pattern;
        *parsed_pattern++ = negate_class? META_CLASS_NOT : META_CLASS;
        class_range_state = RANGE_NO;
        class_op_state = CLASS_OP_EMPTY;
        class_mode_state = new_class_mode_state;
        ++class_depth_m1;
        if (class_maxdepth_m1 < class_depth_m1)
          class_maxdepth_m1 = class_depth_m1;
        /* Reset; no op seen yet at new depth. */
        cb->class_op_used[class_depth_m1] = 0;

        /* Implement the special start-of-class literal meaning of ']'. */
        if (c == CHAR_RIGHT_SQUARE_BRACKET &&
            new_class_mode_state != CLASS_MODE_PERL_EXT)
          {
          class_range_state = RANGE_OK_LITERAL;
          class_op_state = CLASS_OP_OPERAND;
          PARSED_LITERAL(c, parsed_pattern);
          goto CLASS_CONTINUE;
          }

        continue;  /* We have already loaded c with the next character */
        }

      /* Check for the end of the class. */

      else if (c == CHAR_RIGHT_SQUARE_BRACKET ||
               (c == CHAR_RIGHT_PARENTHESIS && class_mode_state == CLASS_MODE_PERL_EXT))
        {
        /* In Perl extended mode, the ']' can only be used to match the
        opening '[', and ')' must match an opening parenthesis. */
        if (class_mode_state == CLASS_MODE_PERL_EXT)
          {
          if (c == CHAR_RIGHT_SQUARE_BRACKET && class_depth_m1 != 0)
            {
            errorcode = ERR14;
            goto FAILED_BACK;
            }
          if (c == CHAR_RIGHT_PARENTHESIS && class_depth_m1 < 1)
            {
            errorcode = ERR22;
            goto FAILED;
            }
          }

        /* Check no trailing operator. */
        if (class_op_state == CLASS_OP_OPERATOR)
          {
          errorcode = ERR110;
          goto FAILED;
          }

        /* Check no empty expression for Perl extended expressions. */
        if (class_mode_state == CLASS_MODE_PERL_EXT &&
            class_op_state == CLASS_OP_EMPTY)
          {
          errorcode = ERR114;
          goto FAILED;
          }

        /* -] at the end of a class is a literal '-' */
        if (class_range_state == RANGE_STARTED)
          parsed_pattern[-1] = CHAR_MINUS;

        *parsed_pattern++ = META_CLASS_END;

        if (--class_depth_m1 < 0)
          {
          /* Check for and consume ')' after '(?[...]'. */
          PCRE2_ASSERT(class_mode_state != CLASS_MODE_PERL_EXT_LEAF);
          if (class_mode_state == CLASS_MODE_PERL_EXT)
            {
            if (ptr >= ptrend || *ptr != CHAR_RIGHT_PARENTHESIS)
              {
              errorcode = ERR115;
              goto FAILED;
              }

            ptr++;
            }

          break;
          }

        class_range_state = RANGE_NO; /* for processing the containing class */
        class_op_state = CLASS_OP_OPERAND;
        if (class_mode_state == CLASS_MODE_PERL_EXT_LEAF)
          class_mode_state = CLASS_MODE_PERL_EXT;
        /* The extended class flag has already
        been set for the parent class. */
        class_start = NULL;
        }

      /* Handle a Perl set binary operator */

      else if (class_mode_state == CLASS_MODE_PERL_EXT &&
               (c == CHAR_PLUS || c == CHAR_VERTICAL_LINE || c == CHAR_MINUS ||
                c == CHAR_AMPERSAND || c == CHAR_CIRCUMFLEX_ACCENT))
        {
        /* Check that there was a preceding operand. */
        if (class_op_state != CLASS_OP_OPERAND)
          {
          errorcode = ERR109;
          goto FAILED;
          }

        if (class_start != NULL)
          {
          PCRE2_ASSERT(class_depth_m1 >= 0);
          /* Represents that the class is an extended class. */
          *class_start |= CLASS_IS_ECLASS;
          class_start = NULL;
          }

        PCRE2_ASSERT(class_range_state != RANGE_STARTED &&
                     class_range_state != RANGE_FORBID_STARTED);

        *parsed_pattern++ = c == CHAR_PLUS? META_ECLASS_OR :
                            c == CHAR_VERTICAL_LINE? META_ECLASS_OR :
                            c == CHAR_MINUS? META_ECLASS_SUB :
                            c == CHAR_AMPERSAND? META_ECLASS_AND :
                            META_ECLASS_XOR;
        class_range_state = RANGE_NO;
        class_op_state = CLASS_OP_OPERATOR;
        }

      /* Handle a Perl set unary operator */

      else if (class_mode_state == CLASS_MODE_PERL_EXT &&
               c == CHAR_EXCLAMATION_MARK)
        {
        /* Check that the "!" has not got a preceding operand (i.e. it's the
        start of the class, or follows an operator). */
        if (class_op_state == CLASS_OP_OPERAND)
          {
          errorcode = ERR113;
          goto FAILED;
          }

        if (class_start != NULL)
          {
          PCRE2_ASSERT(class_depth_m1 >= 0);
          /* Represents that the class is an extended class. */
          *class_start |= CLASS_IS_ECLASS;
          class_start = NULL;
          }

        PCRE2_ASSERT(class_range_state != RANGE_STARTED &&
                     class_range_state != RANGE_FORBID_STARTED);

        *parsed_pattern++ = META_ECLASS_NOT;
        class_range_state = RANGE_NO;
        class_op_state = CLASS_OP_OPERATOR;
        }

      /* Handle a UTS#18 set operator */

      else if (class_mode_state == CLASS_MODE_ALT_EXT &&
               (c == CHAR_VERTICAL_LINE || c == CHAR_MINUS ||
                c == CHAR_AMPERSAND || c == CHAR_TILDE) &&
               ptr < ptrend && *ptr == c)
        {
        ++ptr;

        /* Check there isn't a triple-repetition. */
        if (ptr < ptrend && *ptr == c)
          {
          while (ptr < ptrend && *ptr == c) ++ptr;  /* Improve error offset. */
          errorcode = ERR108;
          goto FAILED;
          }

        /* Check for a preceding operand. */
        if (class_op_state != CLASS_OP_OPERAND)
          {
          errorcode = ERR109;
          goto FAILED;
          }

        /* Check for mixed precedence. Forbid [A--B&&C]. */
        if (cb->class_op_used[class_depth_m1] != 0 &&
            cb->class_op_used[class_depth_m1] != (uint8_t)c)
          {
          errorcode = ERR111;
          goto FAILED;
          }

        if (class_start != NULL)
          {
          PCRE2_ASSERT(class_depth_m1 >= 0);
          /* Represents that the class is an extended class. */
          *class_start |= CLASS_IS_ECLASS;
          class_start = NULL;
          }

        /* Dangling '-' before an operator is a literal */
        if (class_range_state == RANGE_STARTED)
          parsed_pattern[-1] = CHAR_MINUS;

        *parsed_pattern++ = c == CHAR_VERTICAL_LINE? META_ECLASS_OR :
                            c == CHAR_MINUS? META_ECLASS_SUB :
                            c == CHAR_AMPERSAND? META_ECLASS_AND :
                            META_ECLASS_XOR;
        class_range_state = RANGE_NO;
        class_op_state = CLASS_OP_OPERATOR;
        cb->class_op_used[class_depth_m1] = (uint8_t)c;
        }

      /* Handle escapes in a class */

      else if (c == CHAR_BACKSLASH)
        {
        tempptr = ptr;
        escape = PRIV(check_escape)(&ptr, ptrend, &c, &errorcode, options,
          xoptions, cb->bracount, TRUE, cb);

        if (errorcode != 0)
          {
          if ((xoptions & PCRE2_EXTRA_BAD_ESCAPE_IS_LITERAL) == 0 ||
              class_mode_state >= CLASS_MODE_PERL_EXT)
            goto FAILED;
          ptr = tempptr;
          if (ptr >= ptrend) c = CHAR_BACKSLASH; else
            {
            GETCHARINCTEST(c, ptr);   /* Get character value, increment pointer */
            }
          escape = 0;                 /* Treat as literal character */
          }

        switch(escape)
          {
          case 0:  /* Escaped character code point is in c */
          char_is_literal = FALSE;
          goto CLASS_LITERAL;      /* (a few lines above) */

          case ESC_b:
          c = CHAR_BS;    /* \b is backspace in a class */
          char_is_literal = FALSE;
          goto CLASS_LITERAL;

          case ESC_k:
          c = CHAR_k;     /* \k is not special in a class, just like \g */
          char_is_literal = FALSE;
          goto CLASS_LITERAL;

          case ESC_Q:
          inescq = TRUE;  /* Enter literal mode */
          goto CLASS_CONTINUE;

          case ESC_E:     /* Ignore orphan \E */
          goto CLASS_CONTINUE;

          case ESC_B:     /* Always an error in a class */
          case ESC_R:
          case ESC_X:
          errorcode = ERR7;
          ptr--;  // TODO https://github.com/PCRE2Project/pcre2/issues/549
          goto FAILED;

          case ESC_N:     /* Not permitted by Perl either */
          errorcode = ERR71;
          goto FAILED;

          case ESC_H:
          case ESC_h:
          case ESC_V:
          case ESC_v:
          *parsed_pattern++ = META_ESCAPE + escape;
          break;

          /* These escapes may be converted to Unicode property tests when
          PCRE2_UCP is set. */

          case ESC_d:
          case ESC_D:
          case ESC_s:
          case ESC_S:
          case ESC_w:
          case ESC_W:
          parsed_pattern = handle_escdsw(escape, parsed_pattern, options,
            xoptions);
          break;

          /* Explicit Unicode property matching */

          case ESC_P:
          case ESC_p:
#ifdef SUPPORT_UNICODE
            {
            BOOL negated;
            uint16_t ptype = 0, pdata = 0;
            if (!get_ucp(&ptr, &negated, &ptype, &pdata, &errorcode, cb))
              goto FAILED;

            /* In caseless matching, particular characteristics Lu, Ll, and Lt
            get converted to the general characteristic L&. That is, upper,
            lower, and title case letters are all conflated. */

            if ((options & PCRE2_CASELESS) != 0 && ptype == PT_PC &&
                (pdata == ucp_Lu || pdata == ucp_Ll || pdata == ucp_Lt))
              {
              ptype = PT_LAMP;
              pdata = 0;
              }

            if (negated) escape = (escape == ESC_P)? ESC_p : ESC_P;
            *parsed_pattern++ = META_ESCAPE + escape;
            *parsed_pattern++ = (ptype << 16) | pdata;
            }
#else
          errorcode = ERR45;
          goto FAILED;
#endif
          break;  /* End \P and \p */

          /* All others are not allowed in a class */

          default:
          PCRE2_DEBUG_UNREACHABLE();
          /* Fall through */

          case ESC_A:
          case ESC_Z:
          case ESC_z:
          case ESC_G:
          case ESC_K:
          case ESC_C:
          errorcode = ERR7;
          ptr--;  // TODO https://github.com/PCRE2Project/pcre2/issues/549
          goto FAILED;
          }

        /* All the switch-cases above which end in "break" describe a set
        of characters. None may start a range. */

        /* The second part of a range can be a single-character escape
        sequence (detected above), but not any of the other escapes. Perl
        treats a hyphen as a literal in such circumstances. However, in Perl's
        warning mode, a warning is given, so PCRE now faults it, as it is
        almost certainly a mistake on the user's part. */

        if (class_range_state == RANGE_STARTED)
          {
          errorcode = ERR50;
          goto FAILED;
          }

        /* Perl gives a warning unless the hyphen following a multi-character
        escape is the last character in the class. PCRE throws an error. */

        if (class_range_state == RANGE_FORBID_STARTED)
          {
          ptr = class_range_forbid_ptr;
          errorcode = ERR50;
          goto FAILED;
          }

        /* Disallow implicit union in Perl extended classes. */

        if (class_op_state == CLASS_OP_OPERAND &&
            class_mode_state == CLASS_MODE_PERL_EXT)
          {
          errorcode = ERR113;
          goto FAILED;
          }

        class_range_state = RANGE_FORBID_NO;
        class_op_state = CLASS_OP_OPERAND;
        }

      /* Forbid unescaped literals, and the special meaning of '-', inside a
      Perl extended class. */

      else if (class_mode_state == CLASS_MODE_PERL_EXT)
        {
        errorcode = ERR116;
        goto FAILED;
        }

      /* Handle potential start of range */

      else if (c == CHAR_MINUS && class_range_state >= RANGE_OK_ESCAPED)
        {
        *parsed_pattern++ = (class_range_state == RANGE_OK_LITERAL)?
          META_RANGE_LITERAL : META_RANGE_ESCAPED;
        class_range_state = RANGE_STARTED;
        }

      /* Handle forbidden start of range */

      else if (c == CHAR_MINUS && class_range_state == RANGE_FORBID_NO)
        {
        *parsed_pattern++ = CHAR_MINUS;
        class_range_state = RANGE_FORBID_STARTED;
        class_range_forbid_ptr = ptr;
        }

      /* Handle a literal character */

      else
        {
        CLASS_LITERAL:

        /* Disallow implicit union in Perl extended classes. */

        if (class_op_state == CLASS_OP_OPERAND &&
            class_mode_state == CLASS_MODE_PERL_EXT)
          {
          errorcode = ERR113;
          goto FAILED;
          }

        if (class_range_state == RANGE_STARTED)
          {
          if (c == parsed_pattern[-2])       /* Optimize one-char range */
            parsed_pattern--;
          else if (parsed_pattern[-2] > c)   /* Check range is in order */
            {
            errorcode = ERR8;
            goto FAILED_BACK;  // TODO https://github.com/PCRE2Project/pcre2/issues/549
            }
          else
            {
            if (!char_is_literal && parsed_pattern[-1] == META_RANGE_LITERAL)
              parsed_pattern[-1] = META_RANGE_ESCAPED;
            PARSED_LITERAL(c, parsed_pattern);
            }
          class_range_state = RANGE_NO;
          class_op_state = CLASS_OP_OPERAND;
          }
        else if (class_range_state == RANGE_FORBID_STARTED)
          {
          ptr = class_range_forbid_ptr;
          errorcode = ERR50;
          goto FAILED;
          }
        else  /* Potential start of range */
          {
          class_range_state = char_is_literal?
            RANGE_OK_LITERAL : RANGE_OK_ESCAPED;
          class_op_state = CLASS_OP_OPERAND;
          PARSED_LITERAL(c, parsed_pattern);
          }
        }

      /* Proceed to next thing in the class. */

      CLASS_CONTINUE:
      if (ptr >= ptrend)
        {
        if (class_mode_state == CLASS_MODE_PERL_EXT && class_depth_m1 > 0)
          errorcode = ERR14;   /* Missing terminating ')' */
        if (class_mode_state == CLASS_MODE_ALT_EXT &&
            class_depth_m1 == 0 && class_maxdepth_m1 == 1)
          errorcode = ERR112;  /* Missing terminating ']', but we saw '[ [ ]...' */
        else
          errorcode = ERR6;    /* Missing terminating ']' */
        goto FAILED;
        }
      GETCHARINCTEST(c, ptr);
      }     /* End of class-processing loop */

    break;  /* End of character class */


    /* ---- Opening parenthesis ---- */

    case CHAR_LEFT_PARENTHESIS:
    if (ptr >= ptrend) goto UNCLOSED_PARENTHESIS;

    /* If ( is not followed by ? it is either a capture or a special verb or an
    alpha assertion or a positive non-atomic lookahead. */

    if (*ptr != CHAR_QUESTION_MARK)
      {
      const char *vn;

      /* Handle capturing brackets (or non-capturing if auto-capture is turned
      off). */

      if (*ptr != CHAR_ASTERISK)
        {
        nest_depth++;
        if ((options & PCRE2_NO_AUTO_CAPTURE) == 0)
          {
          if (cb->bracount >= MAX_GROUP_NUMBER)
            {
            errorcode = ERR97;
            goto FAILED;
            }
          cb->bracount++;
          *parsed_pattern++ = META_CAPTURE | cb->bracount;
          }
        else *parsed_pattern++ = META_NOCAPTURE;
        }

      /* Do nothing for (* followed by end of pattern or ) so it gives a "bad
      quantifier" error rather than "(*MARK) must have an argument". */

      else if (ptrend - ptr <= 1 || (c = ptr[1]) == CHAR_RIGHT_PARENTHESIS)
        break;

      /* Handle "alpha assertions" such as (*pla:...). Most of these are
      synonyms for the historical symbolic assertions, but the script run and
      non-atomic lookaround ones are new. They are distinguished by starting
      with a lower case letter. Checking both ends of the alphabet makes this
      work in all character codes. */

      else if (CHMAX_255(c) && (cb->ctypes[c] & ctype_lcletter) != 0)
        {
        uint32_t meta;

        vn = alasnames;
        if (!read_name(&ptr, ptrend, utf, 0, &offset, &name, &namelen,
          &errorcode, cb)) goto FAILED;
        if (ptr >= ptrend || *ptr != CHAR_COLON)
          {
          errorcode = ERR95;  /* Malformed */
          goto FAILED;
          }

        /* Scan the table of alpha assertion names */

        for (i = 0; i < alascount; i++)
          {
          if (namelen == alasmeta[i].len &&
              PRIV(strncmp_c8)(name, vn, namelen) == 0)
            break;
          vn += alasmeta[i].len + 1;
          }

        if (i >= alascount)
          {
          errorcode = ERR95;  /* Alpha assertion not recognized */
          goto FAILED;
          }

        /* Check for expecting an assertion condition. If so, only atomic
        lookaround assertions are valid. */

        meta = alasmeta[i].meta;
        if (prev_expect_cond_assert > 0 &&
            (meta < META_LOOKAHEAD || meta > META_LOOKBEHINDNOT))
          {
          errorcode = ERR28;  /* Atomic assertion expected */
          goto FAILED;
          }

        /* The lookaround alphabetic synonyms can mostly be handled by jumping
        to the code that handles the traditional symbolic forms. */

        switch(meta)
          {
          default:
          PCRE2_DEBUG_UNREACHABLE();
          errorcode = ERR89;  /* Unknown code; should never occur because */
          goto FAILED;        /* the meta values come from a table above. */

          case META_ATOMIC:
          goto ATOMIC_GROUP;

          case META_LOOKAHEAD:
          goto POSITIVE_LOOK_AHEAD;

          case META_LOOKAHEAD_NA:
          goto POSITIVE_NONATOMIC_LOOK_AHEAD;

          case META_LOOKAHEADNOT:
          goto NEGATIVE_LOOK_AHEAD;

          case META_SCS:
          if (++ptr >= ptrend) goto UNCLOSED_PARENTHESIS;

          if (*ptr != CHAR_LEFT_PARENTHESIS)
            {
            errorcode = ERR15;
            goto FAILED;
            }

          ptr++;
          *parsed_pattern++ = META_SCS;
          /* Temporary variable, zero in the first iteration. */
          offset = 0;

          for (;;)
            {
            PCRE2_SIZE next_offset = (PCRE2_SIZE)(ptr - cb->start_pattern);

            /* Handle (scan_substring:([+-]number)... */
            if (read_number(&ptr, ptrend, cb->bracount, MAX_GROUP_NUMBER, ERR61,
                &i, &errorcode))
              {
              PCRE2_ASSERT(i >= 0);
              if (i <= 0)
                {
                errorcode = ERR15;
                goto FAILED;
                }
              meta = META_SCS_NUMBER;
              namelen = (uint32_t)i;
              }
            else if (errorcode != 0) goto FAILED;   /* Number too big */
            else
              {
              if (ptr >= ptrend) goto UNCLOSED_PARENTHESIS;

              /* Handle (*scan_substring:('name') or (*scan_substring:(<name>) */
              if (*ptr == CHAR_LESS_THAN_SIGN)
                terminator = CHAR_GREATER_THAN_SIGN;
              else if (*ptr == CHAR_APOSTROPHE)
                terminator = CHAR_APOSTROPHE;
              else
                {
                errorcode = ERR15;
                goto FAILED;
                }

              if (!read_name(&ptr, ptrend, utf, terminator, &next_offset,
                  &name, &namelen, &errorcode, cb)) goto FAILED;

              meta = META_SCS_NAME;
              }

            PCRE2_ASSERT(next_offset > 0);
            if (offset == 0 || (next_offset - offset) >= 0x10000)
              {
              *parsed_pattern++ = META_OFFSET;
              PUTOFFSET(next_offset, parsed_pattern);
              offset = next_offset;
              }

            /* The offset is encoded as a relative offset, because for some
            inputs such as ",2" in (*scs:(1,2,3)...), we only have space for
            two uint32_t values, and an opcode and absolute offset may require
            three uint32_t values. */
            *parsed_pattern++ = meta | (uint32_t)(next_offset - offset);
            *parsed_pattern++ = namelen;
            offset = next_offset;

            if (ptr >= ptrend) goto UNCLOSED_PARENTHESIS;

            if (*ptr == CHAR_RIGHT_PARENTHESIS) break;

            if (*ptr != CHAR_COMMA)
              {
              errorcode = ERR24;
              goto FAILED;
              }

            ptr++;
            }
          ptr++;
          goto POST_ASSERTION;

          case META_LOOKBEHIND:
          case META_LOOKBEHINDNOT:
          case META_LOOKBEHIND_NA:
          *parsed_pattern++ = meta;
          ptr--;
          goto POST_LOOKBEHIND;

          /* The script run facilities are handled here. Unicode support is
          required (give an error if not, as this is a security issue). Always
          record a META_SCRIPT_RUN item. Then, for the atomic version, insert
          META_ATOMIC and remember that we need two META_KETs at the end. */

          case META_SCRIPT_RUN:
          case META_ATOMIC_SCRIPT_RUN:
#ifdef SUPPORT_UNICODE
          *parsed_pattern++ = META_SCRIPT_RUN;
          nest_depth++;
          ptr++;
          if (meta == META_ATOMIC_SCRIPT_RUN)
            {
            *parsed_pattern++ = META_ATOMIC;
            if (top_nest == NULL) top_nest = (nest_save *)(cb->start_workspace);
            else if (++top_nest >= end_nests)
              {
              errorcode = ERR84;
              goto FAILED;
              }
            top_nest->nest_depth = nest_depth;
            top_nest->flags = NSF_ATOMICSR;
            top_nest->options = options & PARSE_TRACKED_OPTIONS;
            top_nest->xoptions = xoptions & PARSE_TRACKED_EXTRA_OPTIONS;

#ifdef PCRE2_DEBUG
            /* We'll write out two META_KETs for a single ")" in the input
            pattern, so we reserve space for that in our bounds check. */
            parsed_pattern_extra++;
#endif
            }
          break;
#else  /* SUPPORT_UNICODE */
          errorcode = ERR96;
          goto FAILED;
#endif
          }
        }


      /* ---- Handle (*VERB) and (*VERB:NAME) ---- */

      else
        {
        vn = verbnames;
        if (!read_name(&ptr, ptrend, utf, 0, &offset, &name, &namelen,
          &errorcode, cb)) goto FAILED;
        if (ptr >= ptrend || (*ptr != CHAR_COLON &&
                              *ptr != CHAR_RIGHT_PARENTHESIS))
          {
          errorcode = ERR60;  /* Malformed */
          goto FAILED;
          }

        /* Scan the table of verb names */

        for (i = 0; i < verbcount; i++)
          {
          if (namelen == verbs[i].len &&
              PRIV(strncmp_c8)(name, vn, namelen) == 0)
            break;
          vn += verbs[i].len + 1;
          }

        if (i >= verbcount)
          {
          errorcode = ERR60;  /* Verb not recognized */
          goto FAILED;
          }

        /* An empty argument is treated as no argument. */

        if (*ptr == CHAR_COLON && ptr + 1 < ptrend &&
             ptr[1] == CHAR_RIGHT_PARENTHESIS)
          ptr++;    /* Advance to the closing parens */

        /* Check for mandatory non-empty argument; this is (*MARK) */

        if (verbs[i].has_arg > 0 && *ptr != CHAR_COLON)
          {
          errorcode = ERR66;
          goto FAILED;
          }

        /* Remember where this verb, possibly with a preceding (*MARK), starts,
        for handling quantified (*ACCEPT). */

        verbstartptr = parsed_pattern;
        okquantifier = (verbs[i].meta == META_ACCEPT);
#ifdef PCRE2_DEBUG
        /* Reserve space in our bounds check for optionally wrapping the (*ACCEPT)
        with a non-capturing bracket, if there is a following quantifier. */
        if (okquantifier) parsed_pattern_extra += 2;
#endif

        /* It appears that Perl allows any characters whatsoever, other than a
        closing parenthesis, to appear in arguments ("names"), so we no longer
        insist on letters, digits, and underscores. Perl does not, however, do
        any interpretation within arguments, and has no means of including a
        closing parenthesis. PCRE supports escape processing but only when it
        is requested by an option. We set inverbname TRUE here, and let the
        main loop take care of this so that escape and \x processing is done by
        the main code above. */

        if (*ptr++ == CHAR_COLON)   /* Skip past : or ) */
          {
          /* Some optional arguments can be treated as a preceding (*MARK) */

          if (verbs[i].has_arg < 0)
            {
            add_after_mark = verbs[i].meta;
            *parsed_pattern++ = META_MARK;
            }

          /* The remaining verbs with arguments (except *MARK) need a different
          opcode. */

          else
            {
            *parsed_pattern++ = verbs[i].meta +
              ((verbs[i].meta != META_MARK)? 0x00010000u:0);
            }

          /* Set up for reading the name in the main loop. */

          verblengthptr = parsed_pattern++;
          verbnamestart = ptr;
          inverbname = TRUE;
          }
        else  /* No verb "name" argument */
          {
          *parsed_pattern++ = verbs[i].meta;
          }
        }     /* End of (*VERB) handling */
      break;  /* Done with this parenthesis */
      }       /* End of groups that don't start with (? */


    /* ---- Items starting (? ---- */

    /* The type of item is determined by what follows (?. Handle (?| and option
    changes under "default" because both need a new block on the nest stack.
    Comments starting with (?# are handled above. Note that there is some
    ambiguity about the sequence (?- because if a digit follows it's a relative
    recursion or subroutine call whereas otherwise it's an option unsetting. */

    if (++ptr >= ptrend) goto UNCLOSED_PARENTHESIS;

    switch(*ptr)
      {
      default:
      if (*ptr == CHAR_MINUS && ptrend - ptr > 1 && IS_DIGIT(ptr[1]))
        goto RECURSION_BYNUMBER;  /* The + case is handled by CHAR_PLUS */

      /* We now have either (?| or a (possibly empty) option setting,
      optionally followed by a non-capturing group. */

      nest_depth++;
      if (top_nest == NULL) top_nest = (nest_save *)(cb->start_workspace);
      else if (++top_nest >= end_nests)
        {
        errorcode = ERR84;
        goto FAILED;
        }
      top_nest->nest_depth = nest_depth;
      top_nest->flags = 0;
      top_nest->options = options & PARSE_TRACKED_OPTIONS;
      top_nest->xoptions = xoptions & PARSE_TRACKED_EXTRA_OPTIONS;

      /* Start of non-capturing group that resets the capture count for each
      branch. */

      if (*ptr == CHAR_VERTICAL_LINE)
        {
        top_nest->reset_group = (uint16_t)cb->bracount;
        top_nest->max_group = (uint16_t)cb->bracount;
        top_nest->flags |= NSF_RESET;
        cb->external_flags |= PCRE2_DUPCAPUSED;
        *parsed_pattern++ = META_NOCAPTURE;
        ptr++;
        }

      /* Scan for options imnrsxJU to be set or unset. */

      else
        {
        BOOL hyphenok = TRUE;
        uint32_t oldoptions = options;
        uint32_t oldxoptions = xoptions;

        top_nest->reset_group = 0;
        top_nest->max_group = 0;
        set = unset = 0;
        optset = &set;
        xset = xunset = 0;
        xoptset = &xset;

        /* ^ at the start unsets irmnsx and disables the subsequent use of - */

        if (ptr < ptrend && *ptr == CHAR_CIRCUMFLEX_ACCENT)
          {
          options &= ~(PCRE2_CASELESS|PCRE2_MULTILINE|PCRE2_NO_AUTO_CAPTURE|
                       PCRE2_DOTALL|PCRE2_EXTENDED|PCRE2_EXTENDED_MORE);
          xoptions &= ~(PCRE2_EXTRA_CASELESS_RESTRICT);
          hyphenok = FALSE;
          ptr++;
          }

        while (ptr < ptrend && *ptr != CHAR_RIGHT_PARENTHESIS &&
                               *ptr != CHAR_COLON)
          {
          switch (*ptr++)
            {
            case CHAR_MINUS:
            if (!hyphenok)
              {
              errorcode = ERR94;
              ptr--;  /* Correct the offset */
              goto FAILED;
              }
            optset = &unset;
            xoptset = &xunset;
            hyphenok = FALSE;
            break;

            /* There are some two-character sequences that start with 'a'. */

            case CHAR_a:
            if (ptr < ptrend)
              {
              if (*ptr == CHAR_D)
                {
                *xoptset |= PCRE2_EXTRA_ASCII_BSD;
                ptr++;
                break;
                }
              if (*ptr == CHAR_P)
                {
                *xoptset |= (PCRE2_EXTRA_ASCII_POSIX|PCRE2_EXTRA_ASCII_DIGIT);
                ptr++;
                break;
                }
              if (*ptr == CHAR_S)
                {
                *xoptset |= PCRE2_EXTRA_ASCII_BSS;
                ptr++;
                break;
                }
              if (*ptr == CHAR_T)
                {
                *xoptset |= PCRE2_EXTRA_ASCII_DIGIT;
                ptr++;
                break;
                }
              if (*ptr == CHAR_W)
                {
                *xoptset |= PCRE2_EXTRA_ASCII_BSW;
                ptr++;
                break;
                }
              }
            *xoptset |= PCRE2_EXTRA_ASCII_BSD|PCRE2_EXTRA_ASCII_BSS|
                        PCRE2_EXTRA_ASCII_BSW|
                        PCRE2_EXTRA_ASCII_DIGIT|PCRE2_EXTRA_ASCII_POSIX;
            break;

            case CHAR_J:  /* Record that it changed in the external options */
            *optset |= PCRE2_DUPNAMES;
            cb->external_flags |= PCRE2_JCHANGED;
            break;

            case CHAR_i: *optset |= PCRE2_CASELESS; break;
            case CHAR_m: *optset |= PCRE2_MULTILINE; break;
            case CHAR_n: *optset |= PCRE2_NO_AUTO_CAPTURE; break;
            case CHAR_r: *xoptset|= PCRE2_EXTRA_CASELESS_RESTRICT; break;
            case CHAR_s: *optset |= PCRE2_DOTALL; break;
            case CHAR_U: *optset |= PCRE2_UNGREEDY; break;

            /* If x appears twice it sets the extended extended option. */

            case CHAR_x:
            *optset |= PCRE2_EXTENDED;
            if (ptr < ptrend && *ptr == CHAR_x)
              {
              *optset |= PCRE2_EXTENDED_MORE;
              ptr++;
              }
            break;

            default:
            errorcode = ERR11;
            ptr--;    /* Correct the offset */
            goto FAILED;
            }
          }

        /* If we are setting extended without extended-more, ensure that any
        existing extended-more gets unset. Also, unsetting extended must also
        unset extended-more. */

        if ((set & (PCRE2_EXTENDED|PCRE2_EXTENDED_MORE)) == PCRE2_EXTENDED ||
            (unset & PCRE2_EXTENDED) != 0)
          unset |= PCRE2_EXTENDED_MORE;

        options = (options | set) & (~unset);
        xoptions = (xoptions | xset) & (~xunset);

        /* If the options ended with ')' this is not the start of a nested
        group with option changes, so the options change at this level.
        In this case, if the previous level set up a nest block, discard the
        one we have just created. Otherwise adjust it for the previous level.
        If the options ended with ':' we are starting a non-capturing group,
        possibly with an options setting. */

        if (ptr >= ptrend) goto UNCLOSED_PARENTHESIS;
        if (*ptr++ == CHAR_RIGHT_PARENTHESIS)
          {
          nest_depth--;  /* This is not a nested group after all. */
          if (top_nest > (nest_save *)(cb->start_workspace) &&
              (top_nest-1)->nest_depth == nest_depth) top_nest--;
          else top_nest->nest_depth = nest_depth;
          }
        else *parsed_pattern++ = META_NOCAPTURE;

        /* If nothing changed, no need to record. */

        if (options != oldoptions || xoptions != oldxoptions)
          {
          *parsed_pattern++ = META_OPTIONS;
          *parsed_pattern++ = options;
          *parsed_pattern++ = xoptions;
          }
        }     /* End options processing */
      break;  /* End default case after (? */


      /* ---- Python syntax support ---- */

      case CHAR_P:
      if (++ptr >= ptrend) goto UNCLOSED_PARENTHESIS;

      /* (?P<name> is the same as (?<name>, which defines a named group. */

      if (*ptr == CHAR_LESS_THAN_SIGN)
        {
        terminator = CHAR_GREATER_THAN_SIGN;
        goto DEFINE_NAME;
        }

      /* (?P>name) is the same as (?&name), which is a recursion or subroutine
      call. */

      if (*ptr == CHAR_GREATER_THAN_SIGN) goto RECURSE_BY_NAME;

      /* (?P=name) is the same as \k<name>, a back reference by name. Anything
      else after (?P is an error. */

      if (*ptr != CHAR_EQUALS_SIGN)
        {
        errorcode = ERR41;
        goto FAILED;
        }
      if (!read_name(&ptr, ptrend, utf, CHAR_RIGHT_PARENTHESIS, &offset, &name,
          &namelen, &errorcode, cb)) goto FAILED;
      *parsed_pattern++ = META_BACKREF_BYNAME;
      *parsed_pattern++ = namelen;
      PUTOFFSET(offset, parsed_pattern);
      okquantifier = TRUE;
      break;   /* End of (?P processing */


      /* ---- Recursion/subroutine calls by number ---- */

      case CHAR_R:
      i = 0;         /* (?R) == (?R0) */
      ptr++;
      if (ptr >= ptrend || *ptr != CHAR_RIGHT_PARENTHESIS)
        {
        errorcode = ERR58;
        goto FAILED;
        }
      goto SET_RECURSION;

      /* An item starting (?- followed by a digit comes here via the "default"
      case because (?- followed by a non-digit is an options setting. */

      case CHAR_PLUS:
      if (ptrend - ptr < 2 || !IS_DIGIT(ptr[1]))
        {
        errorcode = ERR29;   /* Missing number */
        goto FAILED;
        }
      /* Fall through */

      case CHAR_0: case CHAR_1: case CHAR_2: case CHAR_3: case CHAR_4:
      case CHAR_5: case CHAR_6: case CHAR_7: case CHAR_8: case CHAR_9:
      RECURSION_BYNUMBER:
      if (!read_number(&ptr, ptrend,
          (IS_DIGIT(*ptr))? -1:(int)(cb->bracount), /* + and - are relative */
          MAX_GROUP_NUMBER, ERR61,
          &i, &errorcode)) goto FAILED;
      PCRE2_ASSERT(i >= 0);  /* NB (?0) is permitted, represented by i=0 */
      if (ptr >= ptrend || *ptr != CHAR_RIGHT_PARENTHESIS)
        goto UNCLOSED_PARENTHESIS;

      SET_RECURSION:
      *parsed_pattern++ = META_RECURSE | (uint32_t)i;
      offset = (PCRE2_SIZE)(ptr - cb->start_pattern);
      ptr++;
      PUTOFFSET(offset, parsed_pattern);
      okquantifier = TRUE;
      break;  /* End of recursive call by number handling */


      /* ---- Recursion/subroutine calls by name ---- */

      case CHAR_AMPERSAND:
      RECURSE_BY_NAME:
      if (!read_name(&ptr, ptrend, utf, CHAR_RIGHT_PARENTHESIS, &offset, &name,
          &namelen, &errorcode, cb)) goto FAILED;
      *parsed_pattern++ = META_RECURSE_BYNAME;
      *parsed_pattern++ = namelen;
      PUTOFFSET(offset, parsed_pattern);
      okquantifier = TRUE;
      break;

      /* ---- Callout with numerical or string argument ---- */

      case CHAR_C:
      if ((xoptions & PCRE2_EXTRA_NEVER_CALLOUT) != 0)
        {
        errorcode = ERR103;
        goto FAILED;
        }

      if (++ptr >= ptrend) goto UNCLOSED_PARENTHESIS;

      /* If the previous item was a condition starting (?(? an assertion,
      optionally preceded by a callout, is expected. This is checked later on,
      during actual compilation. However we need to identify this kind of
      assertion in this pass because it must not be qualified. The value of
      expect_cond_assert is set to 2 after (?(? is processed. We decrement it
      for a callout - still leaving a positive value that identifies the
      assertion. Multiple callouts or any other items will make it zero or
      less, which doesn't matter because they will cause an error later. */

      expect_cond_assert = prev_expect_cond_assert - 1;

      /* If previous_callout is not NULL, it means this follows a previous
      callout. If it was a manual callout, do nothing; this means its "length
      of next pattern item" field will remain zero. If it was an automatic
      callout, abolish it. */

      if (previous_callout != NULL && (options & PCRE2_AUTO_CALLOUT) != 0 &&
          previous_callout == parsed_pattern - 4 &&
          parsed_pattern[-1] == 255)
        parsed_pattern = previous_callout;

      /* Save for updating next pattern item length, and skip one item before
      completing. */

      previous_callout = parsed_pattern;
      after_manual_callout = 1;

      /* Handle a string argument; specific delimiter is required. */

      if (*ptr != CHAR_RIGHT_PARENTHESIS && !IS_DIGIT(*ptr))
        {
        PCRE2_SIZE calloutlength;
        PCRE2_SPTR startptr = ptr;

        delimiter = 0;
        for (i = 0; PRIV(callout_start_delims)[i] != 0; i++)
          {
          if (*ptr == PRIV(callout_start_delims)[i])
            {
            delimiter = PRIV(callout_end_delims)[i];
            break;
            }
          }
        if (delimiter == 0)
          {
          errorcode = ERR82;
          goto FAILED;
          }

        *parsed_pattern = META_CALLOUT_STRING;
        parsed_pattern += 3;   /* Skip pattern info */

        for (;;)
          {
          if (++ptr >= ptrend)
            {
            errorcode = ERR81;
            ptr = startptr;   /* To give a more useful message */
            goto FAILED;
            }
          if (*ptr == delimiter && (++ptr >= ptrend || *ptr != delimiter))
            break;
          }

        calloutlength = (PCRE2_SIZE)(ptr - startptr);
        if (calloutlength > UINT32_MAX)
          {
          errorcode = ERR72;
          goto FAILED;
          }
        *parsed_pattern++ = (uint32_t)calloutlength;
        offset = (PCRE2_SIZE)(startptr - cb->start_pattern);
        PUTOFFSET(offset, parsed_pattern);
        }

      /* Handle a callout with an optional numerical argument, which must be
      less than or equal to 255. A missing argument gives 0. */

      else
        {
        int n = 0;
        *parsed_pattern = META_CALLOUT_NUMBER;     /* Numerical callout */
        parsed_pattern += 3;                       /* Skip pattern info */
        while (ptr < ptrend && IS_DIGIT(*ptr))
          {
          n = n * 10 + (*ptr++ - CHAR_0);
          if (n > 255)
            {
            errorcode = ERR38;
            goto FAILED;
            }
          }
        *parsed_pattern++ = n;
        }

      /* Both formats must have a closing parenthesis */

      if (ptr >= ptrend || *ptr != CHAR_RIGHT_PARENTHESIS)
        {
        errorcode = ERR39;
        goto FAILED;
        }
      ptr++;

      /* Remember the offset to the next item in the pattern, and set a default
      length. This should get updated after the next item is read. */

      previous_callout[1] = (uint32_t)(ptr - cb->start_pattern);
      previous_callout[2] = 0;
      break;                  /* End callout */


      /* ---- Conditional group ---- */

      /* A condition can be an assertion, a number (referring to a numbered
      group's having been set), a name (referring to a named group), or 'R',
      referring to overall recursion. R<digits> and R&name are also permitted
      for recursion state tests. Numbers may be preceded by + or - to specify a
      relative group number.

      There are several syntaxes for testing a named group: (?(name)) is used
      by Python; Perl 5.10 onwards uses (?(<name>) or (?('name')).

      There are two unfortunate ambiguities. 'R' can be the recursive thing or
      the name 'R' (and similarly for 'R' followed by digits). 'DEFINE' can be
      the Perl DEFINE feature or the Python named test. We look for a name
      first; if not found, we try the other case.

      For compatibility with auto-callouts, we allow a callout to be specified
      before a condition that is an assertion. */

      case CHAR_LEFT_PARENTHESIS:
      if (++ptr >= ptrend) goto UNCLOSED_PARENTHESIS;
      nest_depth++;

      /* If the next character is ? or * there must be an assertion next
      (optionally preceded by a callout). We do not check this here, but
      instead we set expect_cond_assert to 2. If this is still greater than
      zero (callouts decrement it) when the next assertion is read, it will be
      marked as a condition that must not be repeated. A value greater than
      zero also causes checking that an assertion (possibly with callout)
      follows. */

      if (*ptr == CHAR_QUESTION_MARK || *ptr == CHAR_ASTERISK)
        {
        *parsed_pattern++ = META_COND_ASSERT;
        ptr--;   /* Pull pointer back to the opening parenthesis. */
        expect_cond_assert = 2;
        break;  /* End of conditional */
        }

      /* Handle (?([+-]number)... */

      if (read_number(&ptr, ptrend, cb->bracount, MAX_GROUP_NUMBER, ERR61, &i,
          &errorcode))
        {
        PCRE2_ASSERT(i >= 0);
        if (i <= 0)
          {
          errorcode = ERR15;
          goto FAILED;
          }
        *parsed_pattern++ = META_COND_NUMBER;
        offset = (PCRE2_SIZE)(ptr - cb->start_pattern - 2);
        PUTOFFSET(offset, parsed_pattern);
        *parsed_pattern++ = i;
        }
      else if (errorcode != 0) goto FAILED;   /* Number too big */

      /* No number found. Handle the special case (?(VERSION[>]=n.m)... */

      else if (ptrend - ptr >= 10 &&
               PRIV(strncmp_c8)(ptr, STRING_VERSION, 7) == 0 &&
               ptr[7] != CHAR_RIGHT_PARENTHESIS)
        {
        uint32_t ge = 0;
        int major = 0;
        int minor = 0;

        ptr += 7;
        if (*ptr == CHAR_GREATER_THAN_SIGN)
          {
          ge = 1;
          ptr++;
          }

        /* NOTE: cannot write IS_DIGIT(*(++ptr)) here because IS_DIGIT
        references its argument twice. */

        if (*ptr != CHAR_EQUALS_SIGN || (ptr++, !IS_DIGIT(*ptr)))
          goto BAD_VERSION_CONDITION;

        if (!read_number(&ptr, ptrend, -1, 1000, ERR79, &major, &errorcode))
          goto FAILED;

        if (ptr >= ptrend) goto BAD_VERSION_CONDITION;
        if (*ptr == CHAR_DOT)
          {
          if (++ptr >= ptrend || !IS_DIGIT(*ptr)) goto BAD_VERSION_CONDITION;
          minor = (*ptr++ - CHAR_0) * 10;
          if (ptr >= ptrend) goto BAD_VERSION_CONDITION;
          if (IS_DIGIT(*ptr)) minor += *ptr++ - CHAR_0;
          if (ptr >= ptrend || *ptr != CHAR_RIGHT_PARENTHESIS)
            goto BAD_VERSION_CONDITION;
          }

        *parsed_pattern++ = META_COND_VERSION;
        *parsed_pattern++ = ge;
        *parsed_pattern++ = major;
        *parsed_pattern++ = minor;
        }

      /* All the remaining cases now require us to read a name. We cannot at
      this stage distinguish ambiguous cases such as (?(R12) which might be a
      recursion test by number or a name, because the named groups have not yet
      all been identified. Those cases are treated as names, but given a
      different META code. */

      else
        {
        BOOL was_r_ampersand = FALSE;

        if (*ptr == CHAR_R && ptrend - ptr > 1 && ptr[1] == CHAR_AMPERSAND)
          {
          terminator = CHAR_RIGHT_PARENTHESIS;
          was_r_ampersand = TRUE;
          ptr++;
          }
        else if (*ptr == CHAR_LESS_THAN_SIGN)
          terminator = CHAR_GREATER_THAN_SIGN;
        else if (*ptr == CHAR_APOSTROPHE)
          terminator = CHAR_APOSTROPHE;
        else
          {
          terminator = CHAR_RIGHT_PARENTHESIS;
          ptr--;   /* Point to char before name */
          }
        if (!read_name(&ptr, ptrend, utf, terminator, &offset, &name, &namelen,
            &errorcode, cb)) goto FAILED;

        /* Handle (?(R&name) */

        if (was_r_ampersand)
          {
          *parsed_pattern = META_COND_RNAME;
          ptr--;   /* Back to closing parens */
          }

        /* Handle (?(name). If the name is "DEFINE" we identify it with a
        special code. Likewise if the name consists of R followed only by
        digits. Otherwise, handle it like a quoted name. */

        else if (terminator == CHAR_RIGHT_PARENTHESIS)
          {
          if (namelen == 6 && PRIV(strncmp_c8)(name, STRING_DEFINE, 6) == 0)
            *parsed_pattern = META_COND_DEFINE;
          else
            {
            for (i = 1; i < (int)namelen; i++)
              if (!IS_DIGIT(name[i])) break;
            *parsed_pattern = (*name == CHAR_R && i >= (int)namelen)?
              META_COND_RNUMBER : META_COND_NAME;
            }
          ptr--;   /* Back to closing parens */
          }

        /* Handle (?('name') or (?(<name>) */

        else *parsed_pattern = META_COND_NAME;

        /* All these cases except DEFINE end with the name length and offset;
        DEFINE just has an offset (for the "too many branches" error). */

        if (*parsed_pattern++ != META_COND_DEFINE) *parsed_pattern++ = namelen;
        PUTOFFSET(offset, parsed_pattern);
        }  /* End cases that read a name */

      /* Check the closing parenthesis of the condition */

      if (ptr >= ptrend || *ptr != CHAR_RIGHT_PARENTHESIS)
        {
        errorcode = ERR24;
        goto FAILED;
        }
      ptr++;
      break;  /* End of condition processing */


      /* ---- Atomic group ---- */

      case CHAR_GREATER_THAN_SIGN:
      ATOMIC_GROUP:                          /* Come from (*atomic: */
      *parsed_pattern++ = META_ATOMIC;
      nest_depth++;
      ptr++;
      break;


      /* ---- Lookahead assertions ---- */

      case CHAR_EQUALS_SIGN:
      POSITIVE_LOOK_AHEAD:                   /* Come from (*pla: */
      *parsed_pattern++ = META_LOOKAHEAD;
      ptr++;
      goto POST_ASSERTION;

      case CHAR_ASTERISK:
      POSITIVE_NONATOMIC_LOOK_AHEAD:         /* Come from (*napla: */
      *parsed_pattern++ = META_LOOKAHEAD_NA;
      ptr++;
      goto POST_ASSERTION;

      case CHAR_EXCLAMATION_MARK:
      NEGATIVE_LOOK_AHEAD:                   /* Come from (*nla: */
      *parsed_pattern++ = META_LOOKAHEADNOT;
      ptr++;
      goto POST_ASSERTION;


      /* ---- Lookbehind assertions ---- */

      /* (?< followed by = or ! or * is a lookbehind assertion. Otherwise (?<
      is the start of the name of a capturing group. */

      case CHAR_LESS_THAN_SIGN:
      if (ptrend - ptr <= 1 ||
         (ptr[1] != CHAR_EQUALS_SIGN &&
          ptr[1] != CHAR_EXCLAMATION_MARK &&
          ptr[1] != CHAR_ASTERISK))
        {
        terminator = CHAR_GREATER_THAN_SIGN;
        goto DEFINE_NAME;
        }
      *parsed_pattern++ = (ptr[1] == CHAR_EQUALS_SIGN)?
        META_LOOKBEHIND : (ptr[1] == CHAR_EXCLAMATION_MARK)?
        META_LOOKBEHINDNOT : META_LOOKBEHIND_NA;

      POST_LOOKBEHIND:           /* Come from (*plb: (*naplb: and (*nlb: */
      *has_lookbehind = TRUE;
      offset = (PCRE2_SIZE)(ptr - cb->start_pattern - 2);
      PUTOFFSET(offset, parsed_pattern);
      ptr += 2;
      /* Fall through */

      /* If the previous item was a condition starting (?(? an assertion,
      optionally preceded by a callout, is expected. This is checked later on,
      during actual compilation. However we need to identify this kind of
      assertion in this pass because it must not be qualified. The value of
      expect_cond_assert is set to 2 after (?(? is processed. We decrement it
      for a callout - still leaving a positive value that identifies the
      assertion. Multiple callouts or any other items will make it zero or
      less, which doesn't matter because they will cause an error later. */

      POST_ASSERTION:
      nest_depth++;
      if (prev_expect_cond_assert > 0)
        {
        if (top_nest == NULL) top_nest = (nest_save *)(cb->start_workspace);
        else if (++top_nest >= end_nests)
          {
          errorcode = ERR84;
          goto FAILED;
          }
        top_nest->nest_depth = nest_depth;
        top_nest->flags = NSF_CONDASSERT;
        top_nest->options = options & PARSE_TRACKED_OPTIONS;
        top_nest->xoptions = xoptions & PARSE_TRACKED_EXTRA_OPTIONS;
        }
      break;


      /* ---- Define a named group ---- */

      /* A named group may be defined as (?'name') or (?<name>). In the latter
      case we jump to DEFINE_NAME from the disambiguation of (?< above with the
      terminator set to '>'. */

      case CHAR_APOSTROPHE:
      terminator = CHAR_APOSTROPHE;    /* Terminator */

      DEFINE_NAME:
      if (!read_name(&ptr, ptrend, utf, terminator, &offset, &name, &namelen,
          &errorcode, cb)) goto FAILED;

      /* We have a name for this capturing group. It is also assigned a number,
      which is its primary means of identification. */

      if (cb->bracount >= MAX_GROUP_NUMBER)
        {
        errorcode = ERR97;
        goto FAILED;
        }
      cb->bracount++;
      *parsed_pattern++ = META_CAPTURE | cb->bracount;
      nest_depth++;

      /* Check not too many names */

      if (cb->names_found >= MAX_NAME_COUNT)
        {
        errorcode = ERR49;
        goto FAILED;
        }

      /* Adjust the entry size to accommodate the longest name found. */

      if (namelen + IMM2_SIZE + 1 > cb->name_entry_size)
        cb->name_entry_size = (uint16_t)(namelen + IMM2_SIZE + 1);

      /* Scan the list to check for duplicates. For duplicate names, if the
      number is the same, break the loop, which causes the name to be
      discarded; otherwise, if DUPNAMES is not set, give an error.
      If it is set, allow the name with a different number, but continue
      scanning in case this is a duplicate with the same number. For
      non-duplicate names, give an error if the number is duplicated. */

      isdupname = FALSE;
      ng = cb->named_groups;
      for (i = 0; i < cb->names_found; i++, ng++)
        {
        if (namelen == ng->length &&
            PRIV(strncmp)(name, ng->name, (PCRE2_SIZE)namelen) == 0)
          {
          if (ng->number == cb->bracount) break;
          if ((options & PCRE2_DUPNAMES) == 0)
            {
            errorcode = ERR43;
            goto FAILED;
            }
          isdupname = ng->isdup = TRUE;     /* Mark as a duplicate */
          cb->dupnames = TRUE;              /* Duplicate names exist */
          }
        else if (ng->number == cb->bracount)
          {
          errorcode = ERR65;
          goto FAILED;
          }
        }

      if (i < cb->names_found) break;   /* Ignore duplicate with same number */

      /* Increase the list size if necessary */

      if (cb->names_found >= cb->named_group_list_size)
        {
        uint32_t newsize = cb->named_group_list_size * 2;
        named_group *newspace =
          cb->cx->memctl.malloc(newsize * sizeof(named_group),
          cb->cx->memctl.memory_data);
        if (newspace == NULL)
          {
          errorcode = ERR21;
          goto FAILED;
          }

        memcpy(newspace, cb->named_groups,
          cb->named_group_list_size * sizeof(named_group));
        if (cb->named_group_list_size > NAMED_GROUP_LIST_SIZE)
          cb->cx->memctl.free((void *)cb->named_groups,
          cb->cx->memctl.memory_data);
        cb->named_groups = newspace;
        cb->named_group_list_size = newsize;
        }

      /* Add this name to the list */

      cb->named_groups[cb->names_found].name = name;
      cb->named_groups[cb->names_found].length = (uint16_t)namelen;
      cb->named_groups[cb->names_found].number = cb->bracount;
      cb->named_groups[cb->names_found].isdup = (uint16_t)isdupname;
      cb->names_found++;
      break;


      /* ---- Perl extended character class ---- */

      /* These are of the form '(?[...])'. We handle these via the same parser
      that consumes ordinary '[...]' classes, but with a flag set to activate
      the extended behaviour. */

      case CHAR_LEFT_SQUARE_BRACKET:
      class_mode_state = CLASS_MODE_PERL_EXT;
      c = *ptr++;
      goto FROM_PERL_EXTENDED_CLASS;
      }        /* End of (? switch */
    break;     /* End of ( handling */


    /* ---- Branch terminators ---- */

    /* Alternation: reset the capture count if we are in a (?| group. */

    case CHAR_VERTICAL_LINE:
    if (top_nest != NULL && top_nest->nest_depth == nest_depth &&
        (top_nest->flags & NSF_RESET) != 0)
      {
      if (cb->bracount > top_nest->max_group)
        top_nest->max_group = (uint16_t)cb->bracount;
      cb->bracount = top_nest->reset_group;
      }
    *parsed_pattern++ = META_ALT;
    break;

    /* End of group; reset the capture count to the maximum if we are in a (?|
    group and/or reset the options that are tracked during parsing. Disallow
    quantifier for a condition that is an assertion. */

    case CHAR_RIGHT_PARENTHESIS:
    okquantifier = TRUE;
    if (top_nest != NULL && top_nest->nest_depth == nest_depth)
      {
      options = (options & ~PARSE_TRACKED_OPTIONS) | top_nest->options;
      xoptions = (xoptions & ~PARSE_TRACKED_EXTRA_OPTIONS) | top_nest->xoptions;
      if ((top_nest->flags & NSF_RESET) != 0 &&
          top_nest->max_group > cb->bracount)
        cb->bracount = top_nest->max_group;
      if ((top_nest->flags & NSF_CONDASSERT) != 0)
        okquantifier = FALSE;

      if ((top_nest->flags & NSF_ATOMICSR) != 0)
        {
        *parsed_pattern++ = META_KET;

#ifdef PCRE2_DEBUG
        PCRE2_ASSERT(parsed_pattern_extra > 0);
        parsed_pattern_extra--;
#endif
        }

      if (top_nest == (nest_save *)(cb->start_workspace)) top_nest = NULL;
        else top_nest--;
      }
    if (nest_depth == 0)    /* Unmatched closing parenthesis */
      {
      errorcode = ERR22;
      goto FAILED_BACK;  // TODO https://github.com/PCRE2Project/pcre2/issues/549
      }
    nest_depth--;
    *parsed_pattern++ = META_KET;
    break;
    }  /* End of switch on pattern character */
  }    /* End of main character scan loop */

/* End of pattern reached. Check for missing ) at the end of a verb name. */

if (inverbname && ptr >= ptrend)
  {
  errorcode = ERR60;
  goto FAILED;
  }


PARSED_END:

PCRE2_ASSERT((parsed_pattern - parsed_pattern_check) +
             (parsed_pattern_extra - parsed_pattern_extra_check) <=
               max_parsed_pattern(ptr_check, ptr, utf, options));

/* Manage callout for the final item */

parsed_pattern = manage_callouts(ptr, &previous_callout, auto_callout,
  parsed_pattern, cb);

/* Insert trailing items for word and line matching (features provided for the
benefit of pcre2grep). */

if ((xoptions & PCRE2_EXTRA_MATCH_LINE) != 0)
  {
  *parsed_pattern++ = META_KET;
  *parsed_pattern++ = META_DOLLAR;
  }
else if ((xoptions & PCRE2_EXTRA_MATCH_WORD) != 0)
  {
  *parsed_pattern++ = META_KET;
  *parsed_pattern++ = META_ESCAPE + ESC_b;
  }

/* Terminate the parsed pattern, then return success if all groups are closed.
Otherwise we have unclosed parentheses. */

if (parsed_pattern >= parsed_pattern_end)
  {
  PCRE2_DEBUG_UNREACHABLE();
  errorcode = ERR63;  /* Internal error (parsed pattern overflow) */
  goto FAILED;
  }

*parsed_pattern = META_END;
if (nest_depth == 0) return 0;

UNCLOSED_PARENTHESIS:
errorcode = ERR14;

/* Come here for all failures. */

FAILED:
cb->erroroffset = (PCRE2_SIZE)(ptr - cb->start_pattern);
return errorcode;

/* Some errors need to indicate the previous character. */

FAILED_BACK:
ptr--;
goto FAILED;

/* This failure happens several times. */

BAD_VERSION_CONDITION:
errorcode = ERR79;
goto FAILED;
}



/*************************************************
*       Find first significant opcode            *
*************************************************/

/* This is called by several functions that scan a compiled expression looking
for a fixed first character, or an anchoring opcode etc. It skips over things
that do not influence this. For some calls, it makes sense to skip negative
forward and all backward assertions, and also the \b assertion; for others it
does not.

Arguments:
  code         pointer to the start of the group
  skipassert   TRUE if certain assertions are to be skipped

Returns:       pointer to the first significant opcode
*/

static const PCRE2_UCHAR*
first_significant_code(PCRE2_SPTR code, BOOL skipassert)
{
for (;;)
  {
  switch ((int)*code)
    {
    case OP_ASSERT_NOT:
    case OP_ASSERTBACK:
    case OP_ASSERTBACK_NOT:
    case OP_ASSERTBACK_NA:
    if (!skipassert) return code;
    do code += GET(code, 1); while (*code == OP_ALT);
    code += PRIV(OP_lengths)[*code];
    break;

    case OP_WORD_BOUNDARY:
    case OP_NOT_WORD_BOUNDARY:
    case OP_UCP_WORD_BOUNDARY:
    case OP_NOT_UCP_WORD_BOUNDARY:
    if (!skipassert) return code;
    /* Fall through */

    case OP_CALLOUT:
    case OP_CREF:
    case OP_DNCREF:
    case OP_RREF:
    case OP_DNRREF:
    case OP_FALSE:
    case OP_TRUE:
    code += PRIV(OP_lengths)[*code];
    break;

    case OP_CALLOUT_STR:
    code += GET(code, 1 + 2*LINK_SIZE);
    break;

    case OP_SKIPZERO:
    code += 2 + GET(code, 2) + LINK_SIZE;
    break;

    case OP_COND:
    case OP_SCOND:
    if (code[1+LINK_SIZE] != OP_FALSE ||   /* Not DEFINE */
        code[GET(code, 1)] != OP_KET)      /* More than one branch */
      return code;
    code += GET(code, 1) + 1 + LINK_SIZE;
    break;

    case OP_MARK:
    case OP_COMMIT_ARG:
    case OP_PRUNE_ARG:
    case OP_SKIP_ARG:
    case OP_THEN_ARG:
    code += code[1] + PRIV(OP_lengths)[*code];
    break;

    default:
    return code;
    }
  }

PCRE2_DEBUG_UNREACHABLE(); /* Control should never reach here */
}



/*************************************************
*    Find details of duplicate group names       *
*************************************************/

/* This is called from compile_branch() when it needs to know the index and
count of duplicates in the names table when processing named backreferences,
either directly, or as conditions.

Arguments:
  name          points to the name
  length        the length of the name
  indexptr      where to put the index
  countptr      where to put the count of duplicates
  errorcodeptr  where to put an error code
  cb            the compile block

Returns:        TRUE if OK, FALSE if not, error code set
*/

static BOOL
find_dupname_details(PCRE2_SPTR name, uint32_t length, int *indexptr,
  int *countptr, int *errorcodeptr, compile_block *cb)
{
uint32_t i, groupnumber;
int count;
PCRE2_UCHAR *slot = cb->name_table;

/* Find the first entry in the table */

for (i = 0; i < cb->names_found; i++)
  {
  if (PRIV(strncmp)(name, slot+IMM2_SIZE, length) == 0 &&
      slot[IMM2_SIZE+length] == 0) break;
  slot += cb->name_entry_size;
  }

/* This should not occur, because this function is called only when we know we
have duplicate names. Give an internal error. */

if (i >= cb->names_found)
  {
  PCRE2_DEBUG_UNREACHABLE();
  *errorcodeptr = ERR53;
  cb->erroroffset = name - cb->start_pattern;
  return FALSE;
  }

/* Record the index and then see how many duplicates there are, updating the
backref map and maximum back reference as we do. */

*indexptr = i;
count = 0;

for (;;)
  {
  count++;
  groupnumber = GET2(slot,0);
  cb->backref_map |= (groupnumber < 32)? (1u << groupnumber) : 1;
  if (groupnumber > cb->top_backref) cb->top_backref = groupnumber;
  if (++i >= cb->names_found) break;
  slot += cb->name_entry_size;
  if (PRIV(strncmp)(name, slot+IMM2_SIZE, length) != 0 ||
    (slot+IMM2_SIZE)[length] != 0) break;
  }

*countptr = count;
return TRUE;
}



/*************************************************
*           Compile one branch                   *
*************************************************/

/* Scan the parsed pattern, compiling it into the a vector of PCRE2_UCHAR. If
the options are changed during the branch, the pointer is used to change the
external options bits. This function is used during the pre-compile phase when
we are trying to find out the amount of memory needed, as well as during the
real compile phase. The value of lengthptr distinguishes the two phases.

Arguments:
  optionsptr        pointer to the option bits
  xoptionsptr       pointer to the extra option bits
  codeptr           points to the pointer to the current code point
  pptrptr           points to the current parsed pattern pointer
  errorcodeptr      points to error code variable
  firstcuptr        place to put the first required code unit
  firstcuflagsptr   place to put the first code unit flags
  reqcuptr          place to put the last required code unit
  reqcuflagsptr     place to put the last required code unit flags
  bcptr             points to current branch chain
  open_caps         points to current capitem
  cb                contains pointers to tables etc.
  lengthptr         NULL during the real compile phase
                    points to length accumulator during pre-compile phase

Returns:            0 There's been an error, *errorcodeptr is non-zero
                   +1 Success, this branch must match at least one character
                   -1 Success, this branch may match an empty string
*/

static int
compile_branch(uint32_t *optionsptr, uint32_t *xoptionsptr,
  PCRE2_UCHAR **codeptr, uint32_t **pptrptr, int *errorcodeptr,
  uint32_t *firstcuptr, uint32_t *firstcuflagsptr, uint32_t *reqcuptr,
  uint32_t *reqcuflagsptr, branch_chain *bcptr, open_capitem *open_caps,
  compile_block *cb, PCRE2_SIZE *lengthptr)
{
int bravalue = 0;
int okreturn = -1;
int group_return = 0;
uint32_t repeat_min = 0, repeat_max = 0;      /* To please picky compilers */
uint32_t greedy_default, greedy_non_default;
uint32_t repeat_type, op_type;
uint32_t options = *optionsptr;               /* May change dynamically */
uint32_t xoptions = *xoptionsptr;             /* May change dynamically */
uint32_t firstcu, reqcu;
uint32_t zeroreqcu, zerofirstcu;
uint32_t *pptr = *pptrptr;
uint32_t meta, meta_arg;
uint32_t firstcuflags, reqcuflags;
uint32_t zeroreqcuflags, zerofirstcuflags;
uint32_t req_caseopt, reqvary, tempreqvary;
/* Some opcodes, such as META_SCS_NUMBER or META_SCS_NAME,
depends on the previous value of offset. */
PCRE2_SIZE offset = 0;
PCRE2_SIZE length_prevgroup = 0;
PCRE2_UCHAR *code = *codeptr;
PCRE2_UCHAR *last_code = code;
PCRE2_UCHAR *orig_code = code;
PCRE2_UCHAR *tempcode;
PCRE2_UCHAR *previous = NULL;
PCRE2_UCHAR op_previous;
BOOL groupsetfirstcu = FALSE;
BOOL had_accept = FALSE;
BOOL matched_char = FALSE;
BOOL previous_matched_char = FALSE;
BOOL reset_caseful = FALSE;

/* We can fish out the UTF setting once and for all into a BOOL, but we must
not do this for other options (e.g. PCRE2_EXTENDED) that may change dynamically
as we process the pattern. */

#ifdef SUPPORT_UNICODE
BOOL utf = (options & PCRE2_UTF) != 0;
BOOL ucp = (options & PCRE2_UCP) != 0;
#else  /* No Unicode support */
BOOL utf = FALSE;
#endif

/* Set up the default and non-default settings for greediness */

greedy_default = ((options & PCRE2_UNGREEDY) != 0);
greedy_non_default = greedy_default ^ 1;

/* Initialize no first unit, no required unit. REQ_UNSET means "no char
matching encountered yet". It gets changed to REQ_NONE if we hit something that
matches a non-fixed first unit; reqcu just remains unset if we never find one.

When we hit a repeat whose minimum is zero, we may have to adjust these values
to take the zero repeat into account. This is implemented by setting them to
zerofirstcu and zeroreqcu when such a repeat is encountered. The individual
item types that can be repeated set these backoff variables appropriately. */

firstcu = reqcu = zerofirstcu = zeroreqcu = 0;
firstcuflags = reqcuflags = zerofirstcuflags = zeroreqcuflags = REQ_UNSET;

/* The variable req_caseopt contains either the REQ_CASELESS bit or zero,
according to the current setting of the caseless flag. The REQ_CASELESS value
leaves the lower 28 bit empty. It is added into the firstcu or reqcu variables
to record the case status of the value. This is used only for ASCII characters.
*/

req_caseopt = ((options & PCRE2_CASELESS) != 0)? REQ_CASELESS : 0;

/* Switch on next META item until the end of the branch */

for (;; pptr++)
  {
  BOOL possessive_quantifier;
  BOOL note_group_empty;
  uint32_t mclength;
  uint32_t skipunits;
  uint32_t subreqcu, subfirstcu;
  uint32_t groupnumber;
  uint32_t verbarglen, verbculen;
  uint32_t subreqcuflags, subfirstcuflags;
  open_capitem *oc;
  PCRE2_UCHAR mcbuffer[8];

  /* Get next META item in the pattern and its potential argument. */

  meta = META_CODE(*pptr);
  meta_arg = META_DATA(*pptr);

  /* If we are in the pre-compile phase, accumulate the length used for the
  previous cycle of this loop, unless the next item is a quantifier. */

  if (lengthptr != NULL)
    {
    if (code > cb->start_workspace + cb->workspace_size -
        WORK_SIZE_SAFETY_MARGIN)                       /* Check for overrun */
      {
      if (code >= cb->start_workspace + cb->workspace_size)
        {
        PCRE2_DEBUG_UNREACHABLE();
        *errorcodeptr = ERR52;  /* Over-ran workspace - internal error */
        }
      else
        *errorcodeptr = ERR86;
      return 0;
      }

    /* There is at least one situation where code goes backwards: this is the
    case of a zero quantifier after a class (e.g. [ab]{0}). When the quantifier
    is processed, the whole class is eliminated. However, it is created first,
    so we have to allow memory for it. Therefore, don't ever reduce the length
    at this point. */

    if (code < last_code) code = last_code;

    /* If the next thing is not a quantifier, we add the length of the previous
    item into the total, and reset the code pointer to the start of the
    workspace. Otherwise leave the previous item available to be quantified. */

    if (meta < META_ASTERISK || meta > META_MINMAX_QUERY)
      {
      if (OFLOW_MAX - *lengthptr < (PCRE2_SIZE)(code - orig_code))
        {
        *errorcodeptr = ERR20;   /* Integer overflow */
        return 0;
        }
      *lengthptr += (PCRE2_SIZE)(code - orig_code);
      if (*lengthptr > MAX_PATTERN_SIZE)
        {
        *errorcodeptr = ERR20;   /* Pattern is too large */
        return 0;
        }
      code = orig_code;
      }

    /* Remember where this code item starts so we can catch the "backwards"
    case above next time round. */

    last_code = code;
    }

  /* Process the next parsed pattern item. If it is not a quantifier, remember
  where it starts so that it can be quantified when a quantifier follows.
  Checking for the legality of quantifiers happens in parse_regex(), except for
  a quantifier after an assertion that is a condition. */

  if (meta < META_ASTERISK || meta > META_MINMAX_QUERY)
    {
    previous = code;
    if (matched_char && !had_accept) okreturn = 1;
    }

  previous_matched_char = matched_char;
  matched_char = FALSE;
  note_group_empty = FALSE;
  skipunits = 0;         /* Default value for most subgroups */

  switch(meta)
    {
    /* ===================================================================*/
    /* The branch terminates at pattern end or | or ) */

    case META_END:
    case META_ALT:
    case META_KET:
    *firstcuptr = firstcu;
    *firstcuflagsptr = firstcuflags;
    *reqcuptr = reqcu;
    *reqcuflagsptr = reqcuflags;
    *codeptr = code;
    *pptrptr = pptr;
    return okreturn;


    /* ===================================================================*/
    /* Handle single-character metacharacters. In multiline mode, ^ disables
    the setting of any following char as a first character. */

    case META_CIRCUMFLEX:
    if ((options & PCRE2_MULTILINE) != 0)
      {
      if (firstcuflags == REQ_UNSET)
        zerofirstcuflags = firstcuflags = REQ_NONE;
      *code++ = OP_CIRCM;
      }
    else *code++ = OP_CIRC;
    break;

    case META_DOLLAR:
    *code++ = ((options & PCRE2_MULTILINE) != 0)? OP_DOLLM : OP_DOLL;
    break;

    /* There can never be a first char if '.' is first, whatever happens about
    repeats. The value of reqcu doesn't change either. */

    case META_DOT:
    matched_char = TRUE;
    if (firstcuflags == REQ_UNSET) firstcuflags = REQ_NONE;
    zerofirstcu = firstcu;
    zerofirstcuflags = firstcuflags;
    zeroreqcu = reqcu;
    zeroreqcuflags = reqcuflags;
    *code++ = ((options & PCRE2_DOTALL) != 0)? OP_ALLANY: OP_ANY;
    break;


    /* ===================================================================*/
    /* Empty character classes are allowed if PCRE2_ALLOW_EMPTY_CLASS is set.
    Otherwise, an initial ']' is taken as a data character. When empty classes
    are allowed, [] must generate an empty class - we have no dedicated opcode
    to optimise the representation, but it's a rare case (the '(*FAIL)'
    construct would be a clearer way for a pattern author to represent a
    non-matching branch, but it does have different semantics to '[]' if both
    are followed by a quantifier). The empty-negated [^] matches any character,
    so is useful: generate OP_ALLANY for this. */

    case META_CLASS_EMPTY:
    case META_CLASS_EMPTY_NOT:
    matched_char = TRUE;
    if (meta == META_CLASS_EMPTY_NOT) *code++ = OP_ALLANY;
    else
      {
      *code++ = OP_CLASS;
      memset(code, 0, 32);
      code += 32 / sizeof(PCRE2_UCHAR);
      }

    if (firstcuflags == REQ_UNSET) firstcuflags = REQ_NONE;
    zerofirstcu = firstcu;
    zerofirstcuflags = firstcuflags;
    break;


    /* ===================================================================*/
    /* Non-empty character class. If the included characters are all < 256, we
    build a 32-byte bitmap of the permitted characters, except in the special
    case where there is only one such character. For negated classes, we build
    the map as usual, then invert it at the end. However, we use a different
    opcode so that data characters > 255 can be handled correctly.

    If the class contains characters outside the 0-255 range, a different
    opcode is compiled. It may optionally have a bit map for characters < 256,
    but those above are explicitly listed afterwards. A flag code unit tells
    whether the bitmap is present, and whether this is a negated class or
    not. */

    case META_CLASS_NOT:
    case META_CLASS:
    matched_char = TRUE;

    /* Check for complex extended classes and handle them separately. */

    if ((*pptr & CLASS_IS_ECLASS) != 0)
      {
      if (!PRIV(compile_class_nested)(options, xoptions, &pptr, &code,
                                      errorcodeptr, cb, lengthptr))
        return 0;
      goto CLASS_END_PROCESSING;
      }

    /* We can optimize the case of a single character in a class by generating
    OP_CHAR or OP_CHARI if it's positive, or OP_NOT or OP_NOTI if it's
    negative. In the negative case there can be no first char if this item is
    first, whatever repeat count may follow. In the case of reqcu, save the
    previous value for reinstating. */

    /* NOTE: at present this optimization is not effective if the only
    character in a class in 32-bit, non-UCP mode has its top bit set. */

    if (pptr[1] < META_END && pptr[2] == META_CLASS_END)
      {
      uint32_t c = pptr[1];

      pptr += 2;                 /* Move on to class end */
      if (meta == META_CLASS)    /* A positive one-char class can be */
        {                        /* handled as a normal literal character. */
        meta = c;                /* Set up the character */
        goto NORMAL_CHAR_SET;
        }

      /* Handle a negative one-character class */

      zeroreqcu = reqcu;
      zeroreqcuflags = reqcuflags;
      if (firstcuflags == REQ_UNSET) firstcuflags = REQ_NONE;
      zerofirstcu = firstcu;
      zerofirstcuflags = firstcuflags;

      /* For caseless UTF or UCP mode, check whether this character has more
      than one other case. If so, generate a special OP_NOTPROP item instead of
      OP_NOTI. When restricted by PCRE2_EXTRA_CASELESS_RESTRICT, ignore any
      caseless set that starts with an ASCII character. If the character is
      affected by the special Turkish rules, hardcode the not-matching
      characters using a caseset. */

#ifdef SUPPORT_UNICODE
      if ((utf||ucp) && (options & PCRE2_CASELESS) != 0)
        {
        uint32_t caseset;

        if ((xoptions & (PCRE2_EXTRA_TURKISH_CASING|PCRE2_EXTRA_CASELESS_RESTRICT)) ==
              PCRE2_EXTRA_TURKISH_CASING &&
            UCD_ANY_I(c))
          {
          caseset = PRIV(ucd_turkish_dotted_i_caseset) + (UCD_DOTTED_I(c)? 0 : 3);
          }
        else if ((caseset = UCD_CASESET(c)) != 0 &&
                 (xoptions & PCRE2_EXTRA_CASELESS_RESTRICT) != 0 &&
                 PRIV(ucd_caseless_sets)[caseset] < 128)
          {
          caseset = 0;  /* Ignore the caseless set if it's restricted. */
          }

        if (caseset != 0)
          {
          *code++ = OP_NOTPROP;
          *code++ = PT_CLIST;
          *code++ = caseset;
          break;   /* We are finished with this class */
          }
        }
#endif
      /* Char has only one other (usable) case, or UCP not available */

      *code++ = ((options & PCRE2_CASELESS) != 0)? OP_NOTI: OP_NOT;
      code += PUTCHAR(c, code);
      break;   /* We are finished with this class */
      }        /* End of 1-char optimization */

    /* Handle character classes that contain more than just one literal
    character. If there are exactly two characters in a positive class, see if
    they are case partners. This can be optimized to generate a caseless single
    character match (which also sets first/required code units if relevant).
    When casing restrictions apply, ignore a caseless set if both characters
    are ASCII. When Turkish casing applies, an 'i' does not match its normal
    Unicode "othercase". */

    if (meta == META_CLASS && pptr[1] < META_END && pptr[2] < META_END &&
        pptr[3] == META_CLASS_END)
      {
      uint32_t c = pptr[1];

#ifdef SUPPORT_UNICODE
      if ((UCD_CASESET(c) == 0 ||
           ((xoptions & PCRE2_EXTRA_CASELESS_RESTRICT) != 0 &&
            c < 128 && pptr[2] < 128)) &&
          !((xoptions & (PCRE2_EXTRA_TURKISH_CASING|PCRE2_EXTRA_CASELESS_RESTRICT)) ==
              PCRE2_EXTRA_TURKISH_CASING &&
            UCD_ANY_I(c)))
#endif
        {
        uint32_t d;

#ifdef SUPPORT_UNICODE
        if ((utf || ucp) && c > 127) d = UCD_OTHERCASE(c); else
#endif
          {
#if PCRE2_CODE_UNIT_WIDTH != 8
          if (c > 255) d = c; else
#endif
          d = TABLE_GET(c, cb->fcc, c);
          }

        if (c != d && pptr[2] == d)
          {
          pptr += 3;                 /* Move on to class end */
          meta = c;
          if ((options & PCRE2_CASELESS) == 0)
            {
            reset_caseful = TRUE;
            options |= PCRE2_CASELESS;
            req_caseopt = REQ_CASELESS;
            }
          goto CLASS_CASELESS_CHAR;
          }
        }
      }

    /* Now emit the OP_CLASS/OP_NCLASS/OP_XCLASS/OP_ALLANY opcode. */

    pptr = PRIV(compile_class_not_nested)(options, xoptions, pptr + 1,
                                          &code, meta == META_CLASS_NOT, NULL,
                                          errorcodeptr, cb, lengthptr);
    if (pptr == NULL) return 0;
    PCRE2_ASSERT(*pptr == META_CLASS_END);

    CLASS_END_PROCESSING:

    /* If this class is the first thing in the branch, there can be no first
    char setting, whatever the repeat count. Any reqcu setting must remain
    unchanged after any kind of repeat. */

    if (firstcuflags == REQ_UNSET) firstcuflags = REQ_NONE;
    zerofirstcu = firstcu;
    zerofirstcuflags = firstcuflags;
    zeroreqcu = reqcu;
    zeroreqcuflags = reqcuflags;
    break;  /* End of class processing */


    /* ===================================================================*/
    /* Deal with (*VERB)s. */

    /* Check for open captures before ACCEPT and close those that are within
    the same assertion level, also converting ACCEPT to ASSERT_ACCEPT in an
    assertion. In the first pass, just accumulate the length required;
    otherwise hitting (*ACCEPT) inside many nested parentheses can cause
    workspace overflow. Do not set firstcu after *ACCEPT. */

    case META_ACCEPT:
    cb->had_accept = had_accept = TRUE;
    for (oc = open_caps;
         oc != NULL && oc->assert_depth >= cb->assert_depth;
         oc = oc->next)
      {
      if (lengthptr != NULL)
        {
        *lengthptr += CU2BYTES(1) + IMM2_SIZE;
        }
      else
        {
        *code++ = OP_CLOSE;
        PUT2INC(code, 0, oc->number);
        }
      }
    *code++ = (cb->assert_depth > 0)? OP_ASSERT_ACCEPT : OP_ACCEPT;
    if (firstcuflags == REQ_UNSET) firstcuflags = REQ_NONE;
    break;

    case META_PRUNE:
    case META_SKIP:
    cb->had_pruneorskip = TRUE;
    /* Fall through */
    case META_COMMIT:
    case META_FAIL:
    *code++ = verbops[(meta - META_MARK) >> 16];
    break;

    case META_THEN:
    cb->external_flags |= PCRE2_HASTHEN;
    *code++ = OP_THEN;
    break;

    /* Handle verbs with arguments. Arguments can be very long, especially in
    16- and 32-bit modes, and can overflow the workspace in the first pass.
    However, the argument length is constrained to be small enough to fit in
    one code unit. This check happens in parse_regex(). In the first pass,
    instead of putting the argument into memory, we just update the length
    counter and set up an empty argument. */

    case META_THEN_ARG:
    cb->external_flags |= PCRE2_HASTHEN;
    goto VERB_ARG;

    case META_PRUNE_ARG:
    case META_SKIP_ARG:
    cb->had_pruneorskip = TRUE;
    /* Fall through */
    case META_MARK:
    case META_COMMIT_ARG:
    VERB_ARG:
    *code++ = verbops[(meta - META_MARK) >> 16];
    /* The length is in characters. */
    verbarglen = *(++pptr);
    verbculen = 0;
    tempcode = code++;
    for (int i = 0; i < (int)verbarglen; i++)
      {
      meta = *(++pptr);
#ifdef SUPPORT_UNICODE
      if (utf) mclength = PRIV(ord2utf)(meta, mcbuffer); else
#endif
        {
        mclength = 1;
        mcbuffer[0] = meta;
        }
      if (lengthptr != NULL) *lengthptr += mclength; else
        {
        memcpy(code, mcbuffer, CU2BYTES(mclength));
        code += mclength;
        verbculen += mclength;
        }
      }

    *tempcode = verbculen;   /* Fill in the code unit length */
    *code++ = 0;             /* Terminating zero */
    break;


    /* ===================================================================*/
    /* Handle options change. The new setting must be passed back for use in
    subsequent branches. Reset the greedy defaults and the case value for
    firstcu and reqcu. */

    case META_OPTIONS:
    *optionsptr = options = *(++pptr);
    *xoptionsptr = xoptions = *(++pptr);
    greedy_default = ((options & PCRE2_UNGREEDY) != 0);
    greedy_non_default = greedy_default ^ 1;
    req_caseopt = ((options & PCRE2_CASELESS) != 0)? REQ_CASELESS : 0;
    break;

    case META_OFFSET:
    GETPLUSOFFSET(offset, pptr);
    break;

    case META_SCS:
    bravalue = OP_ASSERT_SCS;
    cb->assert_depth += 1;
    goto GROUP_PROCESS;


    /* ===================================================================*/
    /* Handle conditional subpatterns. The case of (?(Rdigits) is ambiguous
    because it could be a numerical check on recursion, or a name check on a
    group's being set. The pre-pass sets up META_COND_RNUMBER as a name so that
    we can handle it either way. We first try for a name; if not found, process
    the number. */

    case META_COND_RNUMBER:   /* (?(Rdigits) */
    case META_COND_NAME:      /* (?(name) or (?'name') or ?(<name>) */
    case META_COND_RNAME:     /* (?(R&name) - test for recursion */
    case META_SCS_NAME:       /* Name of scan substring */
    bravalue = OP_COND;
      {
      int count, index;
      unsigned int i;
      PCRE2_SPTR name;
      named_group *ng = cb->named_groups;
      uint32_t length = *(++pptr);

      if (meta == META_SCS_NAME)
        offset += meta_arg;
      else
        GETPLUSOFFSET(offset, pptr);
      name = cb->start_pattern + offset;

      /* In the first pass, the names generated in the pre-pass are available,
      but the main name table has not yet been created. Scan the list of names
      generated in the pre-pass in order to get a number and whether or not
      this name is duplicated. If it is not duplicated, we can handle it as a
      numerical group. */

      for (i = 0; i < cb->names_found; i++, ng++)
        if (length == ng->length &&
            PRIV(strncmp)(name, ng->name, length) == 0) break;

      if (i >= cb->names_found)
        {
        /* If the name was not found we have a bad reference, unless we are
        dealing with R<digits>, which is treated as a recursion test by
        number. */

        groupnumber = 0;
        if (meta == META_COND_RNUMBER)
          {
          for (i = 1; i < length; i++)
            {
            groupnumber = groupnumber * 10 + (name[i] - CHAR_0);
            if (groupnumber > MAX_GROUP_NUMBER)
              {
              *errorcodeptr = ERR61;
              cb->erroroffset = offset + i;
              return 0;
              }
            }
          }

        if (meta != META_COND_RNUMBER || groupnumber > cb->bracount)
          {
          *errorcodeptr = ERR15;
          cb->erroroffset = offset;
          return 0;
          }

        /* (?Rdigits) treated as a recursion reference by number. A value of
        zero (which is the result of both (?R) and (?R0)) means "any", and is
        translated into RREF_ANY (which is 0xffff). */

        if (groupnumber == 0) groupnumber = RREF_ANY;
        code[1+LINK_SIZE] = OP_RREF;
        PUT2(code, 2+LINK_SIZE, groupnumber);
        skipunits = 1+IMM2_SIZE;
        goto GROUP_PROCESS_NOTE_EMPTY;
        }
      else if (!ng->isdup)
        {
        /* Otherwise found a duplicated name */
        if (ng->number > cb->top_backref) cb->top_backref = ng->number;

        if (meta == META_SCS_NAME)
          {
          code[0] = OP_CREF;
          PUT2(code, 1, ng->number);
          code += 1+IMM2_SIZE;
          break;
          }

        code[1+LINK_SIZE] = (meta == META_COND_RNAME)? OP_RREF : OP_CREF;
        PUT2(code, 2+LINK_SIZE, ng->number);
        skipunits = 1+IMM2_SIZE;
        if (meta != META_SCS_NAME) goto GROUP_PROCESS_NOTE_EMPTY;
        cb->assert_depth += 1;
        goto GROUP_PROCESS;
        }

      /* We have a duplicated name. In the compile pass we have to search the
      main table in order to get the index and count values. */

      count = 0;  /* Values for first pass (avoids compiler warning) */
      index = 0;
      if (lengthptr == NULL && !find_dupname_details(name, length, &index,
            &count, errorcodeptr, cb)) return 0;

      if (meta == META_SCS_NAME)
        {
        code[0] = OP_DNCREF;
        PUT2(code, 1, index);
        PUT2(code, 1+IMM2_SIZE, count);
        code += 1+2*IMM2_SIZE;
        break;
        }

      /* A duplicated name was found. Note that if an R<digits> name is found
      (META_COND_RNUMBER), it is a reference test, not a recursion test. */

      code[1+LINK_SIZE] = (meta == META_COND_RNAME)? OP_DNRREF : OP_DNCREF;

      /* Insert appropriate data values. */
      skipunits = 1+2*IMM2_SIZE;
      PUT2(code, 2+LINK_SIZE, index);
      PUT2(code, 2+LINK_SIZE+IMM2_SIZE, count);
      }

    PCRE2_ASSERT(meta != META_SCS_NAME);
    goto GROUP_PROCESS_NOTE_EMPTY;

    /* The DEFINE condition is always false. Its internal groups may never
    be called, so matched_char must remain false, hence the jump to
    GROUP_PROCESS rather than GROUP_PROCESS_NOTE_EMPTY. */

    case META_COND_DEFINE:
    bravalue = OP_COND;
    GETPLUSOFFSET(offset, pptr);
    code[1+LINK_SIZE] = OP_DEFINE;
    skipunits = 1;
    goto GROUP_PROCESS;

    /* Conditional test of a group's being set. */

    case META_COND_NUMBER:
    case META_SCS_NUMBER:
    bravalue = OP_COND;
    if (meta == META_SCS_NUMBER)
      offset += meta_arg;
    else
      GETPLUSOFFSET(offset, pptr);

    groupnumber = *(++pptr);
    if (groupnumber > cb->bracount)
      {
      *errorcodeptr = ERR15;
      cb->erroroffset = offset;
      return 0;
      }
    if (groupnumber > cb->top_backref) cb->top_backref = groupnumber;

    if (meta == META_SCS_NUMBER)
      {
      code[0] = OP_CREF;
      PUT2(code, 1, groupnumber);
      code += 1+IMM2_SIZE;
      break;
      }

    /* Point at initial ( for too many branches error */
    offset -= 2;
    code[1+LINK_SIZE] = OP_CREF;
    skipunits = 1+IMM2_SIZE;
    PUT2(code, 2+LINK_SIZE, groupnumber);
    goto GROUP_PROCESS_NOTE_EMPTY;

    /* Test for the PCRE2 version. */

    case META_COND_VERSION:
    bravalue = OP_COND;
    if (pptr[1] > 0)
      code[1+LINK_SIZE] = ((PCRE2_MAJOR > pptr[2]) ||
        (PCRE2_MAJOR == pptr[2] && PCRE2_MINOR >= pptr[3]))?
          OP_TRUE : OP_FALSE;
    else
      code[1+LINK_SIZE] = (PCRE2_MAJOR == pptr[2] && PCRE2_MINOR == pptr[3])?
        OP_TRUE : OP_FALSE;
    skipunits = 1;
    pptr += 3;
    goto GROUP_PROCESS_NOTE_EMPTY;

    /* The condition is an assertion, possibly preceded by a callout. */

    case META_COND_ASSERT:
    bravalue = OP_COND;
    goto GROUP_PROCESS_NOTE_EMPTY;


    /* ===================================================================*/
    /* Handle all kinds of nested bracketed groups. The non-capturing,
    non-conditional cases are here; others come to GROUP_PROCESS via goto. */

    case META_LOOKAHEAD:
    bravalue = OP_ASSERT;
    cb->assert_depth += 1;
    goto GROUP_PROCESS;

    case META_LOOKAHEAD_NA:
    bravalue = OP_ASSERT_NA;
    cb->assert_depth += 1;
    goto GROUP_PROCESS;

    /* Optimize (?!) to (*FAIL) unless it is quantified - which is a weird
    thing to do, but Perl allows all assertions to be quantified, and when
    they contain capturing parentheses there may be a potential use for
    this feature. Not that that applies to a quantified (?!) but we allow
    it for uniformity. */

    case META_LOOKAHEADNOT:
    if (pptr[1] == META_KET &&
         (pptr[2] < META_ASTERISK || pptr[2] > META_MINMAX_QUERY))
      {
      *code++ = OP_FAIL;
      pptr++;
      }
    else
      {
      bravalue = OP_ASSERT_NOT;
      cb->assert_depth += 1;
      goto GROUP_PROCESS;
      }
    break;

    case META_LOOKBEHIND:
    bravalue = OP_ASSERTBACK;
    cb->assert_depth += 1;
    goto GROUP_PROCESS;

    case META_LOOKBEHINDNOT:
    bravalue = OP_ASSERTBACK_NOT;
    cb->assert_depth += 1;
    goto GROUP_PROCESS;

    case META_LOOKBEHIND_NA:
    bravalue = OP_ASSERTBACK_NA;
    cb->assert_depth += 1;
    goto GROUP_PROCESS;

    case META_ATOMIC:
    bravalue = OP_ONCE;
    goto GROUP_PROCESS_NOTE_EMPTY;

    case META_SCRIPT_RUN:
    bravalue = OP_SCRIPT_RUN;
    goto GROUP_PROCESS_NOTE_EMPTY;

    case META_NOCAPTURE:
    bravalue = OP_BRA;
    /* Fall through */

    /* Process nested bracketed regex. The nesting depth is maintained for the
    benefit of the stackguard function. The test for too deep nesting is now
    done in parse_regex(). Assertion and DEFINE groups come to GROUP_PROCESS;
    others come to GROUP_PROCESS_NOTE_EMPTY, to indicate that we need to take
    note of whether or not they may match an empty string. */

    GROUP_PROCESS_NOTE_EMPTY:
    note_group_empty = TRUE;

    GROUP_PROCESS:
    cb->parens_depth += 1;
    *code = bravalue;
    pptr++;
    tempcode = code;
    tempreqvary = cb->req_varyopt;        /* Save value before group */
    length_prevgroup = 0;                 /* Initialize for pre-compile phase */

    if ((group_return =
         compile_regex(
         options,                         /* The options state */
         xoptions,                        /* The extra options state */
         &tempcode,                       /* Where to put code (updated) */
         &pptr,                           /* Input pointer (updated) */
         errorcodeptr,                    /* Where to put an error message */
         skipunits,                       /* Skip over bracket number */
         &subfirstcu,                     /* For possible first char */
         &subfirstcuflags,
         &subreqcu,                       /* For possible last char */
         &subreqcuflags,
         bcptr,                           /* Current branch chain */
         open_caps,                       /* Pointer to capture stack */
         cb,                              /* Compile data block */
         (lengthptr == NULL)? NULL :      /* Actual compile phase */
           &length_prevgroup              /* Pre-compile phase */
         )) == 0)
      return 0;  /* Error */

    cb->parens_depth -= 1;

    /* If that was a non-conditional significant group (not an assertion, not a
    DEFINE) that matches at least one character, then the current item matches
    a character. Conditionals are handled below. */

    if (note_group_empty && bravalue != OP_COND && group_return > 0)
      matched_char = TRUE;

    /* If we've just compiled an assertion, pop the assert depth. */

    if (bravalue >= OP_ASSERT && bravalue <= OP_ASSERT_SCS)
      cb->assert_depth -= 1;

    /* At the end of compiling, code is still pointing to the start of the
    group, while tempcode has been updated to point past the end of the group.
    The parsed pattern pointer (pptr) is on the closing META_KET.

    If this is a conditional bracket, check that there are no more than
    two branches in the group, or just one if it's a DEFINE group. We do this
    in the real compile phase, not in the pre-pass, where the whole group may
    not be available. */

    if (bravalue == OP_COND && lengthptr == NULL)
      {
      PCRE2_UCHAR *tc = code;
      int condcount = 0;

      do {
         condcount++;
         tc += GET(tc,1);
         }
      while (*tc != OP_KET);

      /* A DEFINE group is never obeyed inline (the "condition" is always
      false). It must have only one branch. Having checked this, change the
      opcode to OP_FALSE. */

      if (code[LINK_SIZE+1] == OP_DEFINE)
        {
        if (condcount > 1)
          {
          cb->erroroffset = offset;
          *errorcodeptr = ERR54;
          return 0;
          }
        code[LINK_SIZE+1] = OP_FALSE;
        bravalue = OP_DEFINE;   /* A flag to suppress char handling below */
        }

      /* A "normal" conditional group. If there is just one branch, we must not
      make use of its firstcu or reqcu, because this is equivalent to an
      empty second branch. Also, it may match an empty string. If there are two
      branches, this item must match a character if the group must. */

      else
        {
        if (condcount > 2)
          {
          cb->erroroffset = offset;
          *errorcodeptr = ERR27;
          return 0;
          }
        if (condcount == 1) subfirstcuflags = subreqcuflags = REQ_NONE;
          else if (group_return > 0) matched_char = TRUE;
        }
      }

    /* In the pre-compile phase, update the length by the length of the group,
    less the brackets at either end. Then reduce the compiled code to just a
    set of non-capturing brackets so that it doesn't use much memory if it is
    duplicated by a quantifier.*/

    if (lengthptr != NULL)
      {
      if (OFLOW_MAX - *lengthptr < length_prevgroup - 2 - 2*LINK_SIZE)
        {
        *errorcodeptr = ERR20;
        return 0;
        }
      *lengthptr += length_prevgroup - 2 - 2*LINK_SIZE;
      code++;   /* This already contains bravalue */
      PUTINC(code, 0, 1 + LINK_SIZE);
      *code++ = OP_KET;
      PUTINC(code, 0, 1 + LINK_SIZE);
      break;    /* No need to waste time with special character handling */
      }

    /* Otherwise update the main code pointer to the end of the group. */

    code = tempcode;

    /* For a DEFINE group, required and first character settings are not
    relevant. */

    if (bravalue == OP_DEFINE) break;

    /* Handle updating of the required and first code units for other types of
    group. Update for normal brackets of all kinds, and conditions with two
    branches (see code above). If the bracket is followed by a quantifier with
    zero repeat, we have to back off. Hence the definition of zeroreqcu and
    zerofirstcu outside the main loop so that they can be accessed for the back
    off. */

    zeroreqcu = reqcu;
    zeroreqcuflags = reqcuflags;
    zerofirstcu = firstcu;
    zerofirstcuflags = firstcuflags;
    groupsetfirstcu = FALSE;

    if (bravalue >= OP_ONCE)  /* Not an assertion */
      {
      /* If we have not yet set a firstcu in this branch, take it from the
      subpattern, remembering that it was set here so that a repeat of more
      than one can replicate it as reqcu if necessary. If the subpattern has
      no firstcu, set "none" for the whole branch. In both cases, a zero
      repeat forces firstcu to "none". */

      if (firstcuflags == REQ_UNSET && subfirstcuflags != REQ_UNSET)
        {
        if (subfirstcuflags < REQ_NONE)
          {
          firstcu = subfirstcu;
          firstcuflags = subfirstcuflags;
          groupsetfirstcu = TRUE;
          }
        else firstcuflags = REQ_NONE;
        zerofirstcuflags = REQ_NONE;
        }

      /* If firstcu was previously set, convert the subpattern's firstcu
      into reqcu if there wasn't one, using the vary flag that was in
      existence beforehand. */

      else if (subfirstcuflags < REQ_NONE && subreqcuflags >= REQ_NONE)
        {
        subreqcu = subfirstcu;
        subreqcuflags = subfirstcuflags | tempreqvary;
        }

      /* If the subpattern set a required code unit (or set a first code unit
      that isn't really the first code unit - see above), set it. */

      if (subreqcuflags < REQ_NONE)
        {
        reqcu = subreqcu;
        reqcuflags = subreqcuflags;
        }
      }

    /* For a forward assertion, we take the reqcu, if set, provided that the
    group has also set a firstcu. This can be helpful if the pattern that
    follows the assertion doesn't set a different char. For example, it's
    useful for /(?=abcde).+/. We can't set firstcu for an assertion, however
    because it leads to incorrect effect for patterns such as /(?=a)a.+/ when
    the "real" "a" would then become a reqcu instead of a firstcu. This is
    overcome by a scan at the end if there's no firstcu, looking for an
    asserted first char. A similar effect for patterns like /(?=.*X)X$/ means
    we must only take the reqcu when the group also set a firstcu. Otherwise,
    in that example, 'X' ends up set for both. */

    else if ((bravalue == OP_ASSERT || bravalue == OP_ASSERT_NA) &&
             subreqcuflags < REQ_NONE && subfirstcuflags < REQ_NONE)
      {
      reqcu = subreqcu;
      reqcuflags = subreqcuflags;
      }

    break;  /* End of nested group handling */


    /* ===================================================================*/
    /* Handle named backreferences and recursions. */

    case META_BACKREF_BYNAME:
    case META_RECURSE_BYNAME:
      {
      int count, index;
      PCRE2_SPTR name;
      BOOL is_dupname = FALSE;
      named_group *ng = cb->named_groups;
      uint32_t length = *(++pptr);

      GETPLUSOFFSET(offset, pptr);
      name = cb->start_pattern + offset;

      /* In the first pass, the names generated in the pre-pass are available,
      but the main name table has not yet been created. Scan the list of names
      generated in the pre-pass in order to get a number and whether or not
      this name is duplicated. */

      groupnumber = 0;
      for (unsigned int i = 0; i < cb->names_found; i++, ng++)
        {
        if (length == ng->length &&
            PRIV(strncmp)(name, ng->name, length) == 0)
          {
          is_dupname = ng->isdup;
          groupnumber = ng->number;

          /* For a recursion, that's all that is needed. We can now go to
          the code that handles numerical recursion, applying it to the first
          group with the given name. */

          if (meta == META_RECURSE_BYNAME)
            {
            meta_arg = groupnumber;
            goto HANDLE_NUMERICAL_RECURSION;
            }

          /* For a back reference, update the back reference map and the
          maximum back reference. */

          cb->backref_map |= (groupnumber < 32)? (1u << groupnumber) : 1;
          if (groupnumber > cb->top_backref)
            cb->top_backref = groupnumber;
          }
        }

      /* If the name was not found we have a bad reference. */

      if (groupnumber == 0)
        {
        *errorcodeptr = ERR15;
        cb->erroroffset = offset;
        return 0;
        }

      /* If a back reference name is not duplicated, we can handle it as
      a numerical reference. */

      if (!is_dupname)
        {
        meta_arg = groupnumber;
        goto HANDLE_SINGLE_REFERENCE;
        }

      /* If a back reference name is duplicated, we generate a different
      opcode to a numerical back reference. In the second pass we must
      search for the index and count in the final name table. */

      count = 0;  /* Values for first pass (avoids compiler warning) */
      index = 0;
      if (lengthptr == NULL && !find_dupname_details(name, length, &index,
            &count, errorcodeptr, cb)) return 0;

      if (firstcuflags == REQ_UNSET) firstcuflags = REQ_NONE;
      *code++ = ((options & PCRE2_CASELESS) != 0)? OP_DNREFI : OP_DNREF;
      PUT2INC(code, 0, index);
      PUT2INC(code, 0, count);
      if ((options & PCRE2_CASELESS) != 0)
        *code++ = (((xoptions & PCRE2_EXTRA_CASELESS_RESTRICT) != 0)?
                   REFI_FLAG_CASELESS_RESTRICT : 0) |
                  (((xoptions & PCRE2_EXTRA_TURKISH_CASING) != 0)?
                   REFI_FLAG_TURKISH_CASING : 0);
      }
    break;


    /* ===================================================================*/
    /* Handle a numerical callout. */

    case META_CALLOUT_NUMBER:
    code[0] = OP_CALLOUT;
    PUT(code, 1, pptr[1]);               /* Offset to next pattern item */
    PUT(code, 1 + LINK_SIZE, pptr[2]);   /* Length of next pattern item */
    code[1 + 2*LINK_SIZE] = pptr[3];
    pptr += 3;
    code += PRIV(OP_lengths)[OP_CALLOUT];
    break;


    /* ===================================================================*/
    /* Handle a callout with a string argument. In the pre-pass we just compute
    the length without generating anything. The length in pptr[3] includes both
    delimiters; in the actual compile only the first one is copied, but a
    terminating zero is added. Any doubled delimiters within the string make
    this an overestimate, but it is not worth bothering about. */

    case META_CALLOUT_STRING:
    if (lengthptr != NULL)
      {
      *lengthptr += pptr[3] + (1 + 4*LINK_SIZE);
      pptr += 3;
      SKIPOFFSET(pptr);
      }

    /* In the real compile we can copy the string. The starting delimiter is
     included so that the client can discover it if they want. We also pass the
     start offset to help a script language give better error messages. */

    else
      {
      PCRE2_SPTR pp;
      uint32_t delimiter;
      uint32_t length = pptr[3];
      PCRE2_UCHAR *callout_string = code + (1 + 4*LINK_SIZE);

      code[0] = OP_CALLOUT_STR;
      PUT(code, 1, pptr[1]);               /* Offset to next pattern item */
      PUT(code, 1 + LINK_SIZE, pptr[2]);   /* Length of next pattern item */

      pptr += 3;
      GETPLUSOFFSET(offset, pptr);         /* Offset to string in pattern */
      pp = cb->start_pattern + offset;
      delimiter = *callout_string++ = *pp++;
      if (delimiter == CHAR_LEFT_CURLY_BRACKET)
        delimiter = CHAR_RIGHT_CURLY_BRACKET;
      PUT(code, 1 + 3*LINK_SIZE, (int)(offset + 1));  /* One after delimiter */

      /* The syntax of the pattern was checked in the parsing scan. The length
      includes both delimiters, but we have passed the opening one just above,
      so we reduce length before testing it. The test is for > 1 because we do
      not want to copy the final delimiter. This also ensures that pp[1] is
      accessible. */

      while (--length > 1)
        {
        if (*pp == delimiter && pp[1] == delimiter)
          {
          *callout_string++ = delimiter;
          pp += 2;
          length--;
          }
        else *callout_string++ = *pp++;
        }
      *callout_string++ = CHAR_NUL;

      /* Set the length of the entire item, the advance to its end. */

      PUT(code, 1 + 2*LINK_SIZE, (int)(callout_string - code));
      code = callout_string;
      }
    break;


    /* ===================================================================*/
    /* Handle repetition. The different types are all sorted out in the parsing
    pass. */

    case META_MINMAX_PLUS:
    case META_MINMAX_QUERY:
    case META_MINMAX:
    repeat_min = *(++pptr);
    repeat_max = *(++pptr);
    goto REPEAT;

    case META_ASTERISK:
    case META_ASTERISK_PLUS:
    case META_ASTERISK_QUERY:
    repeat_min = 0;
    repeat_max = REPEAT_UNLIMITED;
    goto REPEAT;

    case META_PLUS:
    case META_PLUS_PLUS:
    case META_PLUS_QUERY:
    repeat_min = 1;
    repeat_max = REPEAT_UNLIMITED;
    goto REPEAT;

    case META_QUERY:
    case META_QUERY_PLUS:
    case META_QUERY_QUERY:
    repeat_min = 0;
    repeat_max = 1;

    REPEAT:
    if (previous_matched_char && repeat_min > 0) matched_char = TRUE;

    /* Remember whether this is a variable length repeat, and default to
    single-char opcodes. */

    reqvary = (repeat_min == repeat_max)? 0 : REQ_VARY;

    /* Adjust first and required code units for a zero repeat. */

    if (repeat_min == 0)
      {
      firstcu = zerofirstcu;
      firstcuflags = zerofirstcuflags;
      reqcu = zeroreqcu;
      reqcuflags = zeroreqcuflags;
      }

    /* Note the greediness and possessiveness. */

    switch (meta)
      {
      case META_MINMAX_PLUS:
      case META_ASTERISK_PLUS:
      case META_PLUS_PLUS:
      case META_QUERY_PLUS:
      repeat_type = 0;                  /* Force greedy */
      possessive_quantifier = TRUE;
      break;

      case META_MINMAX_QUERY:
      case META_ASTERISK_QUERY:
      case META_PLUS_QUERY:
      case META_QUERY_QUERY:
      repeat_type = greedy_non_default;
      possessive_quantifier = FALSE;
      break;

      default:
      repeat_type = greedy_default;
      possessive_quantifier = FALSE;
      break;
      }

    /* Save start of previous item, in case we have to move it up in order to
    insert something before it, and remember what it was. */

    PCRE2_ASSERT(previous != NULL);
    tempcode = previous;
    op_previous = *previous;

    /* Now handle repetition for the different types of item. If the repeat
    minimum and the repeat maximum are both 1, we can ignore the quantifier for
    non-parenthesized items, as they have only one alternative. For anything in
    parentheses, we must not ignore if {1} is possessive. */

    switch (op_previous)
      {
      /* If previous was a character or negated character match, abolish the
      item and generate a repeat item instead. If a char item has a minimum of
      more than one, ensure that it is set in reqcu - it might not be if a
      sequence such as x{3} is the first thing in a branch because the x will
      have gone into firstcu instead.  */

      case OP_CHAR:
      case OP_CHARI:
      case OP_NOT:
      case OP_NOTI:
      if (repeat_max == 1 && repeat_min == 1) goto END_REPEAT;
      op_type = chartypeoffset[op_previous - OP_CHAR];

      /* Deal with UTF characters that take up more than one code unit. */

#ifdef MAYBE_UTF_MULTI
      if (utf && NOT_FIRSTCU(code[-1]))
        {
        PCRE2_UCHAR *lastchar = code - 1;
        BACKCHAR(lastchar);
        mclength = (uint32_t)(code - lastchar);   /* Length of UTF character */
        memcpy(mcbuffer, lastchar, CU2BYTES(mclength));  /* Save the char */
        }
      else
#endif  /* MAYBE_UTF_MULTI */

      /* Handle the case of a single code unit - either with no UTF support, or
      with UTF disabled, or for a single-code-unit UTF character. In the latter
      case, for a repeated positive match, get the caseless flag for the
      required code unit from the previous character, because a class like [Aa]
      sets a caseless A but by now the req_caseopt flag has been reset. */

        {
        mcbuffer[0] = code[-1];
        mclength = 1;
        if (op_previous <= OP_CHARI && repeat_min > 1)
          {
          reqcu = mcbuffer[0];
          reqcuflags = cb->req_varyopt;
          if (op_previous == OP_CHARI) reqcuflags |= REQ_CASELESS;
          }
        }
      goto OUTPUT_SINGLE_REPEAT;  /* Code shared with single character types */

      /* If previous was a character class or a back reference, we put the
      repeat stuff after it, but just skip the item if the repeat was {0,0}. */

#ifdef SUPPORT_WIDE_CHARS
      case OP_XCLASS:
      case OP_ECLASS:
#endif
      case OP_CLASS:
      case OP_NCLASS:
      case OP_REF:
      case OP_REFI:
      case OP_DNREF:
      case OP_DNREFI:

      if (repeat_max == 0)
        {
        code = previous;
        goto END_REPEAT;
        }
      if (repeat_max == 1 && repeat_min == 1) goto END_REPEAT;

      if (repeat_min == 0 && repeat_max == REPEAT_UNLIMITED)
        *code++ = OP_CRSTAR + repeat_type;
      else if (repeat_min == 1 && repeat_max == REPEAT_UNLIMITED)
        *code++ = OP_CRPLUS + repeat_type;
      else if (repeat_min == 0 && repeat_max == 1)
        *code++ = OP_CRQUERY + repeat_type;
      else
        {
        *code++ = OP_CRRANGE + repeat_type;
        PUT2INC(code, 0, repeat_min);
        if (repeat_max == REPEAT_UNLIMITED) repeat_max = 0;  /* 2-byte encoding for max */
        PUT2INC(code, 0, repeat_max);
        }
      break;

      /* Prior to 10.30, repeated recursions were wrapped in OP_ONCE brackets
      because pcre2_match() could not handle backtracking into recursively
      called groups. Now that this backtracking is available, we no longer need
      to do this. However, we still need to replicate recursions as we do for
      groups so as to have independent backtracking points. We can replicate
      for the minimum number of repeats directly. For optional repeats we now
      wrap the recursion in OP_BRA brackets and make use of the bracket
      repetition. */

      case OP_RECURSE:
      if (repeat_max == 1 && repeat_min == 1 && !possessive_quantifier)
        goto END_REPEAT;

      /* Generate unwrapped repeats for a non-zero minimum, except when the
      minimum is 1 and the maximum unlimited, because that can be handled with
      OP_BRA terminated by OP_KETRMAX/MIN. When the maximum is equal to the
      minimum, we just need to generate the appropriate additional copies.
      Otherwise we need to generate one more, to simulate the situation when
      the minimum is zero. */

      if (repeat_min > 0 && (repeat_min != 1 || repeat_max != REPEAT_UNLIMITED))
        {
        int replicate = repeat_min;
        if (repeat_min == repeat_max) replicate--;

        /* In the pre-compile phase, we don't actually do the replication. We
        just adjust the length as if we had. Do some paranoid checks for
        potential integer overflow. */

        if (lengthptr != NULL)
          {
          PCRE2_SIZE delta;
          if (PRIV(ckd_smul)(&delta, replicate, 1 + LINK_SIZE) ||
              OFLOW_MAX - *lengthptr < delta)
            {
            *errorcodeptr = ERR20;
            return 0;
            }
          *lengthptr += delta;
          }

        else for (int i = 0; i < replicate; i++)
          {
          memcpy(code, previous, CU2BYTES(1 + LINK_SIZE));
          previous = code;
          code += 1 + LINK_SIZE;
          }

        /* If the number of repeats is fixed, we are done. Otherwise, adjust
        the counts and fall through. */

        if (repeat_min == repeat_max) break;
        if (repeat_max != REPEAT_UNLIMITED) repeat_max -= repeat_min;
        repeat_min = 0;
        }

      /* Wrap the recursion call in OP_BRA brackets. */

      (void)memmove(previous + 1 + LINK_SIZE, previous, CU2BYTES(1 + LINK_SIZE));
      op_previous = *previous = OP_BRA;
      PUT(previous, 1, 2 + 2*LINK_SIZE);
      previous[2 + 2*LINK_SIZE] = OP_KET;
      PUT(previous, 3 + 2*LINK_SIZE, 2 + 2*LINK_SIZE);
      code += 2 + 2 * LINK_SIZE;
      length_prevgroup = 3 + 3*LINK_SIZE;
      group_return = -1;  /* Set "may match empty string" */

      /* Now treat as a repeated OP_BRA. */
      /* Fall through */

      /* If previous was a bracket group, we may have to replicate it in
      certain cases. Note that at this point we can encounter only the "basic"
      bracket opcodes such as BRA and CBRA, as this is the place where they get
      converted into the more special varieties such as BRAPOS and SBRA.
      Originally, PCRE did not allow repetition of assertions, but now it does,
      for Perl compatibility. */

      case OP_ASSERT:
      case OP_ASSERT_NOT:
      case OP_ASSERT_NA:
      case OP_ASSERTBACK:
      case OP_ASSERTBACK_NOT:
      case OP_ASSERTBACK_NA:
      case OP_ASSERT_SCS:
      case OP_ONCE:
      case OP_SCRIPT_RUN:
      case OP_BRA:
      case OP_CBRA:
      case OP_COND:
        {
        int len = (int)(code - previous);
        PCRE2_UCHAR *bralink = NULL;
        PCRE2_UCHAR *brazeroptr = NULL;

        if (repeat_max == 1 && repeat_min == 1 && !possessive_quantifier)
          goto END_REPEAT;

        /* Repeating a DEFINE group (or any group where the condition is always
        FALSE and there is only one branch) is pointless, but Perl allows the
        syntax, so we just ignore the repeat. */

        if (op_previous == OP_COND && previous[LINK_SIZE+1] == OP_FALSE &&
            previous[GET(previous, 1)] != OP_ALT)
          goto END_REPEAT;

        /* Perl allows all assertions to be quantified, and when they contain
        capturing parentheses and/or are optional there are potential uses for
        this feature. PCRE2 used to force the maximum quantifier to 1 on the
        invalid grounds that further repetition was never useful. This was
        always a bit pointless, since an assertion could be wrapped with a
        repeated group to achieve the effect. General repetition is now
        permitted, but if the maximum is unlimited it is set to one more than
        the minimum. */

        if (op_previous < OP_ONCE)    /* Assertion */
          {
          if (repeat_max == REPEAT_UNLIMITED) repeat_max = repeat_min + 1;
          }

        /* The case of a zero minimum is special because of the need to stick
        OP_BRAZERO in front of it, and because the group appears once in the
        data, whereas in other cases it appears the minimum number of times. For
        this reason, it is simplest to treat this case separately, as otherwise
        the code gets far too messy. There are several special subcases when the
        minimum is zero. */

        if (repeat_min == 0)
          {
          /* If the maximum is also zero, we used to just omit the group from
          the output altogether, like this:

          ** if (repeat_max == 0)
          **   {
          **   code = previous;
          **   goto END_REPEAT;
          **   }

          However, that fails when a group or a subgroup within it is
          referenced as a subroutine from elsewhere in the pattern, so now we
          stick in OP_SKIPZERO in front of it so that it is skipped on
          execution. As we don't have a list of which groups are referenced, we
          cannot do this selectively.

          If the maximum is 1 or unlimited, we just have to stick in the
          BRAZERO and do no more at this point. */

          if (repeat_max <= 1 || repeat_max == REPEAT_UNLIMITED)
            {
            (void)memmove(previous + 1, previous, CU2BYTES(len));
            code++;
            if (repeat_max == 0)
              {
              *previous++ = OP_SKIPZERO;
              goto END_REPEAT;
              }
            brazeroptr = previous;    /* Save for possessive optimizing */
            *previous++ = OP_BRAZERO + repeat_type;
            }

          /* If the maximum is greater than 1 and limited, we have to replicate
          in a nested fashion, sticking OP_BRAZERO before each set of brackets.
          The first one has to be handled carefully because it's the original
          copy, which has to be moved up. The remainder can be handled by code
          that is common with the non-zero minimum case below. We have to
          adjust the value or repeat_max, since one less copy is required. */

          else
            {
            int linkoffset;
            (void)memmove(previous + 2 + LINK_SIZE, previous, CU2BYTES(len));
            code += 2 + LINK_SIZE;
            *previous++ = OP_BRAZERO + repeat_type;
            *previous++ = OP_BRA;

            /* We chain together the bracket link offset fields that have to be
            filled in later when the ends of the brackets are reached. */

            linkoffset = (bralink == NULL)? 0 : (int)(previous - bralink);
            bralink = previous;
            PUTINC(previous, 0, linkoffset);
            }

          if (repeat_max != REPEAT_UNLIMITED) repeat_max--;
          }

        /* If the minimum is greater than zero, replicate the group as many
        times as necessary, and adjust the maximum to the number of subsequent
        copies that we need. */

        else
          {
          if (repeat_min > 1)
            {
            /* In the pre-compile phase, we don't actually do the replication.
            We just adjust the length as if we had. Do some paranoid checks for
            potential integer overflow. */

            if (lengthptr != NULL)
              {
              PCRE2_SIZE delta;
              if (PRIV(ckd_smul)(&delta, repeat_min - 1,
                                 (int)length_prevgroup) ||
                  OFLOW_MAX - *lengthptr < delta)
                {
                *errorcodeptr = ERR20;
                return 0;
                }
              *lengthptr += delta;
              }

            /* This is compiling for real. If there is a set first code unit
            for the group, and we have not yet set a "required code unit", set
            it. */

            else
              {
              if (groupsetfirstcu && reqcuflags >= REQ_NONE)
                {
                reqcu = firstcu;
                reqcuflags = firstcuflags;
                }
              for (uint32_t i = 1; i < repeat_min; i++)
                {
                memcpy(code, previous, CU2BYTES(len));
                code += len;
                }
              }
            }

          if (repeat_max != REPEAT_UNLIMITED) repeat_max -= repeat_min;
          }

        /* This code is common to both the zero and non-zero minimum cases. If
        the maximum is limited, it replicates the group in a nested fashion,
        remembering the bracket starts on a stack. In the case of a zero
        minimum, the first one was set up above. In all cases the repeat_max
        now specifies the number of additional copies needed. Again, we must
        remember to replicate entries on the forward reference list. */

        if (repeat_max != REPEAT_UNLIMITED)
          {
          /* In the pre-compile phase, we don't actually do the replication. We
          just adjust the length as if we had. For each repetition we must add
          1 to the length for BRAZERO and for all but the last repetition we
          must add 2 + 2*LINKSIZE to allow for the nesting that occurs. Do some
          paranoid checks to avoid integer overflow. */

          if (lengthptr != NULL && repeat_max > 0)
            {
            PCRE2_SIZE delta;
            if (PRIV(ckd_smul)(&delta, repeat_max,
                               (int)length_prevgroup + 1 + 2 + 2*LINK_SIZE) ||
                OFLOW_MAX + (2 + 2*LINK_SIZE) - *lengthptr < delta)
              {
              *errorcodeptr = ERR20;
              return 0;
              }
            delta -= (2 + 2*LINK_SIZE);   /* Last one doesn't nest */
            *lengthptr += delta;
            }

          /* This is compiling for real */

          else for (uint32_t i = repeat_max; i >= 1; i--)
            {
            *code++ = OP_BRAZERO + repeat_type;

            /* All but the final copy start a new nesting, maintaining the
            chain of brackets outstanding. */

            if (i != 1)
              {
              int linkoffset;
              *code++ = OP_BRA;
              linkoffset = (bralink == NULL)? 0 : (int)(code - bralink);
              bralink = code;
              PUTINC(code, 0, linkoffset);
              }

            memcpy(code, previous, CU2BYTES(len));
            code += len;
            }

          /* Now chain through the pending brackets, and fill in their length
          fields (which are holding the chain links pro tem). */

          while (bralink != NULL)
            {
            int oldlinkoffset;
            int linkoffset = (int)(code - bralink + 1);
            PCRE2_UCHAR *bra = code - linkoffset;
            oldlinkoffset = GET(bra, 1);
            bralink = (oldlinkoffset == 0)? NULL : bralink - oldlinkoffset;
            *code++ = OP_KET;
            PUTINC(code, 0, linkoffset);
            PUT(bra, 1, linkoffset);
            }
          }

        /* If the maximum is unlimited, set a repeater in the final copy. For
        SCRIPT_RUN and ONCE brackets, that's all we need to do. However,
        possessively repeated ONCE brackets can be converted into non-capturing
        brackets, as the behaviour of (?:xx)++ is the same as (?>xx)++ and this
        saves having to deal with possessive ONCEs specially.

        Otherwise, when we are doing the actual compile phase, check to see
        whether this group is one that could match an empty string. If so,
        convert the initial operator to the S form (e.g. OP_BRA -> OP_SBRA) so
        that runtime checking can be done. [This check is also applied to ONCE
        and SCRIPT_RUN groups at runtime, but in a different way.]

        Then, if the quantifier was possessive and the bracket is not a
        conditional, we convert the BRA code to the POS form, and the KET code
        to KETRPOS. (It turns out to be convenient at runtime to detect this
        kind of subpattern at both the start and at the end.) The use of
        special opcodes makes it possible to reduce greatly the stack usage in
        pcre2_match(). If the group is preceded by OP_BRAZERO, convert this to
        OP_BRAPOSZERO.

        Then, if the minimum number of matches is 1 or 0, cancel the possessive
        flag so that the default action below, of wrapping everything inside
        atomic brackets, does not happen. When the minimum is greater than 1,
        there will be earlier copies of the group, and so we still have to wrap
        the whole thing. */

        else
          {
          PCRE2_UCHAR *ketcode = code - 1 - LINK_SIZE;
          PCRE2_UCHAR *bracode = ketcode - GET(ketcode, 1);

          /* Convert possessive ONCE brackets to non-capturing */

          if (*bracode == OP_ONCE && possessive_quantifier) *bracode = OP_BRA;

          /* For non-possessive ONCE and for SCRIPT_RUN brackets, all we need
          to do is to set the KET. */

          if (*bracode == OP_ONCE || *bracode == OP_SCRIPT_RUN)
            *ketcode = OP_KETRMAX + repeat_type;

          /* Handle non-SCRIPT_RUN and non-ONCE brackets and possessive ONCEs
          (which have been converted to non-capturing above). */

          else
            {
            /* In the compile phase, adjust the opcode if the group can match
            an empty string. For a conditional group with only one branch, the
            value of group_return will not show "could be empty", so we must
            check that separately. */

            if (lengthptr == NULL)
              {
              if (group_return < 0) *bracode += OP_SBRA - OP_BRA;
              if (*bracode == OP_COND && bracode[GET(bracode,1)] != OP_ALT)
                *bracode = OP_SCOND;
              }

            /* Handle possessive quantifiers. */

            if (possessive_quantifier)
              {
              /* For COND brackets, we wrap the whole thing in a possessively
              repeated non-capturing bracket, because we have not invented POS
              versions of the COND opcodes. */

              if (*bracode == OP_COND || *bracode == OP_SCOND)
                {
                int nlen = (int)(code - bracode);
                (void)memmove(bracode + 1 + LINK_SIZE, bracode, CU2BYTES(nlen));
                code += 1 + LINK_SIZE;
                nlen += 1 + LINK_SIZE;
                *bracode = (*bracode == OP_COND)? OP_BRAPOS : OP_SBRAPOS;
                *code++ = OP_KETRPOS;
                PUTINC(code, 0, nlen);
                PUT(bracode, 1, nlen);
                }

              /* For non-COND brackets, we modify the BRA code and use KETRPOS. */

              else
                {
                *bracode += 1;              /* Switch to xxxPOS opcodes */
                *ketcode = OP_KETRPOS;
                }

              /* If the minimum is zero, mark it as possessive, then unset the
              possessive flag when the minimum is 0 or 1. */

              if (brazeroptr != NULL) *brazeroptr = OP_BRAPOSZERO;
              if (repeat_min < 2) possessive_quantifier = FALSE;
              }

            /* Non-possessive quantifier */

            else *ketcode = OP_KETRMAX + repeat_type;
            }
          }
        }
      break;

      /* If previous was a character type match (\d or similar), abolish it and
      create a suitable repeat item. The code is shared with single-character
      repeats by setting op_type to add a suitable offset into repeat_type.
      Note the the Unicode property types will be present only when
      SUPPORT_UNICODE is defined, but we don't wrap the little bits of code
      here because it just makes it horribly messy. */

      default:
      if (op_previous >= OP_EODN || op_previous <= OP_WORD_BOUNDARY)
        {
        PCRE2_DEBUG_UNREACHABLE();
        *errorcodeptr = ERR10;  /* Not a character type - internal error */
        return 0;
        }
      else
        {
        int prop_type, prop_value;
        PCRE2_UCHAR *oldcode;

        if (repeat_max == 1 && repeat_min == 1) goto END_REPEAT;

        op_type = OP_TYPESTAR - OP_STAR;      /* Use type opcodes */
        mclength = 0;                         /* Not a character */

        if (op_previous == OP_PROP || op_previous == OP_NOTPROP)
          {
          prop_type = previous[1];
          prop_value = previous[2];
          }
        else
          {
          /* Come here from just above with a character in mcbuffer/mclength.
          You must also set op_type before the jump. */
          OUTPUT_SINGLE_REPEAT:
          prop_type = prop_value = -1;
          }

        /* At this point, if prop_type == prop_value == -1 we either have a
        character in mcbuffer when mclength is greater than zero, or we have
        mclength zero, in which case there is a non-property character type in
        op_previous. If prop_type/value are not negative, we have a property
        character type in op_previous. */

        oldcode = code;                   /* Save where we were */
        code = previous;                  /* Usually overwrite previous item */

        /* If the maximum is zero then the minimum must also be zero; Perl allows
        this case, so we do too - by simply omitting the item altogether. */

        if (repeat_max == 0) goto END_REPEAT;

        /* Combine the op_type with the repeat_type */

        repeat_type += op_type;

        /* A minimum of zero is handled either as the special case * or ?, or as
        an UPTO, with the maximum given. */

        if (repeat_min == 0)
          {
          if (repeat_max == REPEAT_UNLIMITED) *code++ = OP_STAR + repeat_type;
            else if (repeat_max == 1) *code++ = OP_QUERY + repeat_type;
          else
            {
            *code++ = OP_UPTO + repeat_type;
            PUT2INC(code, 0, repeat_max);
            }
          }

        /* A repeat minimum of 1 is optimized into some special cases. If the
        maximum is unlimited, we use OP_PLUS. Otherwise, the original item is
        left in place and, if the maximum is greater than 1, we use OP_UPTO with
        one less than the maximum. */

        else if (repeat_min == 1)
          {
          if (repeat_max == REPEAT_UNLIMITED)
            *code++ = OP_PLUS + repeat_type;
          else
            {
            code = oldcode;  /* Leave previous item in place */
            if (repeat_max == 1) goto END_REPEAT;
            *code++ = OP_UPTO + repeat_type;
            PUT2INC(code, 0, repeat_max - 1);
            }
          }

        /* The case {n,n} is just an EXACT, while the general case {n,m} is
        handled as an EXACT followed by an UPTO or STAR or QUERY. */

        else
          {
          *code++ = OP_EXACT + op_type;  /* NB EXACT doesn't have repeat_type */
          PUT2INC(code, 0, repeat_min);

          /* Unless repeat_max equals repeat_min, fill in the data for EXACT,
          and then generate the second opcode. For a repeated Unicode property
          match, there are two extra values that define the required property,
          and mclength is set zero to indicate this. */

          if (repeat_max != repeat_min)
            {
            if (mclength > 0)
              {
              memcpy(code, mcbuffer, CU2BYTES(mclength));
              code += mclength;
              }
            else
              {
              *code++ = op_previous;
              if (prop_type >= 0)
                {
                *code++ = prop_type;
                *code++ = prop_value;
                }
              }

            /* Now set up the following opcode */

            if (repeat_max == REPEAT_UNLIMITED)
              *code++ = OP_STAR + repeat_type;
            else
              {
              repeat_max -= repeat_min;
              if (repeat_max == 1)
                {
                *code++ = OP_QUERY + repeat_type;
                }
              else
                {
                *code++ = OP_UPTO + repeat_type;
                PUT2INC(code, 0, repeat_max);
                }
              }
            }
          }

        /* Fill in the character or character type for the final opcode. */

        if (mclength > 0)
          {
          memcpy(code, mcbuffer, CU2BYTES(mclength));
          code += mclength;
          }
        else
          {
          *code++ = op_previous;
          if (prop_type >= 0)
            {
            *code++ = prop_type;
            *code++ = prop_value;
            }
          }
        }
      break;
      }  /* End of switch on different op_previous values */


    /* If the character following a repeat is '+', possessive_quantifier is
    TRUE. For some opcodes, there are special alternative opcodes for this
    case. For anything else, we wrap the entire repeated item inside OP_ONCE
    brackets. Logically, the '+' notation is just syntactic sugar, taken from
    Sun's Java package, but the special opcodes can optimize it.

    Some (but not all) possessively repeated subpatterns have already been
    completely handled in the code just above. For them, possessive_quantifier
    is always FALSE at this stage. Note that the repeated item starts at
    tempcode, not at previous, which might be the first part of a string whose
    (former) last char we repeated. */

    if (possessive_quantifier)
      {
      int len;

      /* Possessifying an EXACT quantifier has no effect, so we can ignore it.
      However, QUERY, STAR, or UPTO may follow (for quantifiers such as {5,6},
      {5,}, or {5,10}). We skip over an EXACT item; if the length of what
      remains is greater than zero, there's a further opcode that can be
      handled. If not, do nothing, leaving the EXACT alone. */

      switch(*tempcode)
        {
        case OP_TYPEEXACT:
        tempcode += PRIV(OP_lengths)[*tempcode] +
          ((tempcode[1 + IMM2_SIZE] == OP_PROP
          || tempcode[1 + IMM2_SIZE] == OP_NOTPROP)? 2 : 0);
        break;

        /* CHAR opcodes are used for exacts whose count is 1. */

        case OP_CHAR:
        case OP_CHARI:
        case OP_NOT:
        case OP_NOTI:
        case OP_EXACT:
        case OP_EXACTI:
        case OP_NOTEXACT:
        case OP_NOTEXACTI:
        tempcode += PRIV(OP_lengths)[*tempcode];
#ifdef SUPPORT_UNICODE
        if (utf && HAS_EXTRALEN(tempcode[-1]))
          tempcode += GET_EXTRALEN(tempcode[-1]);
#endif
        break;

        /* For the class opcodes, the repeat operator appears at the end;
        adjust tempcode to point to it. */

        case OP_CLASS:
        case OP_NCLASS:
        tempcode += 1 + 32/sizeof(PCRE2_UCHAR);
        break;

#ifdef SUPPORT_WIDE_CHARS
        case OP_XCLASS:
        case OP_ECLASS:
        tempcode += GET(tempcode, 1);
        break;
#endif
        }

      /* If tempcode is equal to code (which points to the end of the repeated
      item), it means we have skipped an EXACT item but there is no following
      QUERY, STAR, or UPTO; the value of len will be 0, and we do nothing. In
      all other cases, tempcode will be pointing to the repeat opcode, and will
      be less than code, so the value of len will be greater than 0. */

      len = (int)(code - tempcode);
      if (len > 0)
        {
        unsigned int repcode = *tempcode;

        /* There is a table for possessifying opcodes, all of which are less
        than OP_CALLOUT. A zero entry means there is no possessified version.
        */

        if (repcode < OP_CALLOUT && opcode_possessify[repcode] > 0)
          *tempcode = opcode_possessify[repcode];

        /* For opcode without a special possessified version, wrap the item in
        ONCE brackets. */

        else
          {
          (void)memmove(tempcode + 1 + LINK_SIZE, tempcode, CU2BYTES(len));
          code += 1 + LINK_SIZE;
          len += 1 + LINK_SIZE;
          tempcode[0] = OP_ONCE;
          *code++ = OP_KET;
          PUTINC(code, 0, len);
          PUT(tempcode, 1, len);
          }
        }
      }

    /* We set the "follows varying string" flag for subsequently encountered
    reqcus if it isn't already set and we have just passed a varying length
    item. */

    END_REPEAT:
    cb->req_varyopt |= reqvary;
    break;


    /* ===================================================================*/
    /* Handle a 32-bit data character with a value greater than META_END. */

    case META_BIGVALUE:
    pptr++;
    goto NORMAL_CHAR;


    /* ===============================================================*/
    /* Handle a back reference by number, which is the meta argument. The
    pattern offsets for back references to group numbers less than 10 are held
    in a special vector, to avoid using more than two parsed pattern elements
    in 64-bit environments. We only need the offset to the first occurrence,
    because if that doesn't fail, subsequent ones will also be OK. */

    case META_BACKREF:
    if (meta_arg < 10) offset = cb->small_ref_offset[meta_arg];
      else GETPLUSOFFSET(offset, pptr);

    if (meta_arg > cb->bracount)
      {
      cb->erroroffset = offset;
      *errorcodeptr = ERR15;  /* Non-existent subpattern */
      return 0;
      }

    /* Come here from named backref handling when the reference is to a
    single group (that is, not to a duplicated name). The back reference
    data will have already been updated. We must disable firstcu if not
    set, to cope with cases like (?=(\w+))\1: which would otherwise set ':'
    later. */

    HANDLE_SINGLE_REFERENCE:
    if (firstcuflags == REQ_UNSET) zerofirstcuflags = firstcuflags = REQ_NONE;
    *code++ = ((options & PCRE2_CASELESS) != 0)? OP_REFI : OP_REF;
    PUT2INC(code, 0, meta_arg);
    if ((options & PCRE2_CASELESS) != 0)
      *code++ = (((xoptions & PCRE2_EXTRA_CASELESS_RESTRICT) != 0)?
                 REFI_FLAG_CASELESS_RESTRICT : 0) |
                (((xoptions & PCRE2_EXTRA_TURKISH_CASING) != 0)?
                 REFI_FLAG_TURKISH_CASING : 0);

    /* Update the map of back references, and keep the highest one. We
    could do this in parse_regex() for numerical back references, but not
    for named back references, because we don't know the numbers to which
    named back references refer. So we do it all in this function. */

    cb->backref_map |= (meta_arg < 32)? (1u << meta_arg) : 1;
    if (meta_arg > cb->top_backref) cb->top_backref = meta_arg;
    break;


    /* ===============================================================*/
    /* Handle recursion by inserting the number of the called group (which is
    the meta argument) after OP_RECURSE. At the end of compiling the pattern is
    scanned and these numbers are replaced by offsets within the pattern. It is
    done like this to avoid problems with forward references and adjusting
    offsets when groups are duplicated and moved (as discovered in previous
    implementations). Note that a recursion does not have a set first
    character. */

    case META_RECURSE:
    GETPLUSOFFSET(offset, pptr);
    if (meta_arg > cb->bracount)
      {
      cb->erroroffset = offset;
      *errorcodeptr = ERR15;  /* Non-existent subpattern */
      return 0;
      }
    HANDLE_NUMERICAL_RECURSION:
    *code = OP_RECURSE;
    PUT(code, 1, meta_arg);
    code += 1 + LINK_SIZE;
    groupsetfirstcu = FALSE;
    cb->had_recurse = TRUE;
    if (firstcuflags == REQ_UNSET) firstcuflags = REQ_NONE;
    zerofirstcu = firstcu;
    zerofirstcuflags = firstcuflags;
    break;


    /* ===============================================================*/
    /* Handle capturing parentheses; the number is the meta argument. */

    case META_CAPTURE:
    bravalue = OP_CBRA;
    skipunits = IMM2_SIZE;
    PUT2(code, 1+LINK_SIZE, meta_arg);
    cb->lastcapture = meta_arg;
    goto GROUP_PROCESS_NOTE_EMPTY;


    /* ===============================================================*/
    /* Handle escape sequence items. For ones like \d, the ESC_values are
    arranged to be the same as the corresponding OP_values in the default case
    when PCRE2_UCP is not set (which is the only case in which they will appear
    here).

    Note: \Q and \E are never seen here, as they were dealt with in
    parse_pattern(). Neither are numerical back references or recursions, which
    were turned into META_BACKREF or META_RECURSE items, respectively. \k and
    \g, when followed by names, are turned into META_BACKREF_BYNAME or
    META_RECURSE_BYNAME. */

    case META_ESCAPE:

    /* We can test for escape sequences that consume a character because their
    values lie between ESC_b and ESC_Z; this may have to change if any new ones
    are ever created. For these sequences, we disable the setting of a first
    character if it hasn't already been set. */

    if (meta_arg > ESC_b && meta_arg < ESC_Z)
      {
      matched_char = TRUE;
      if (firstcuflags == REQ_UNSET) firstcuflags = REQ_NONE;
      }

    /* Set values to reset to if this is followed by a zero repeat. */

    zerofirstcu = firstcu;
    zerofirstcuflags = firstcuflags;
    zeroreqcu = reqcu;
    zeroreqcuflags = reqcuflags;

    /* If Unicode is not supported, \P and \p are not allowed and are
    faulted at parse time, so will never appear here. */

#ifdef SUPPORT_UNICODE
    if (meta_arg == ESC_P || meta_arg == ESC_p)
      {
      uint32_t ptype = *(++pptr) >> 16;
      uint32_t pdata = *pptr & 0xffff;

      /* In caseless matching, particular characteristics Lu, Ll, and Lt get
      converted to the general characteristic L&. That is, upper, lower, and
      title case letters are all conflated. */

      if ((options & PCRE2_CASELESS) != 0 && ptype == PT_PC &&
          (pdata == ucp_Lu || pdata == ucp_Ll || pdata == ucp_Lt))
        {
        ptype = PT_LAMP;
        pdata = 0;
        }

      /* The special case of \p{Any} is compiled to OP_ALLANY and \P{Any}
      is compiled to [] so as to benefit from the auto-anchoring code. */

      if (ptype == PT_ANY)
        {
        if (meta_arg == ESC_P)
          {
          *code++ = OP_CLASS;
          memset(code, 0, 32);
          code += 32 / sizeof(PCRE2_UCHAR);
          }
        else
          *code++ = OP_ALLANY;
        }
      else
        {
        *code++ = (meta_arg == ESC_p)? OP_PROP : OP_NOTPROP;
        *code++ = ptype;
        *code++ = pdata;
        }
      break;  /* End META_ESCAPE */
      }
#endif

    /* \K is forbidden in lookarounds since 10.38 because that's what Perl has
    done. However, there's an option, in case anyone was relying on it. */

    if (cb->assert_depth > 0 && meta_arg == ESC_K &&
        (xoptions & PCRE2_EXTRA_ALLOW_LOOKAROUND_BSK) == 0)
      {
      *errorcodeptr = ERR99;
      return 0;
      }

    /* For the rest (including \X when Unicode is supported - if not it's
    faulted at parse time), the OP value is the escape value when PCRE2_UCP is
    not set; if it is set, most of them do not show up here because they are
    converted into Unicode property tests in parse_regex().

    In non-UTF mode, and for both 32-bit modes, we turn \C into OP_ALLANY
    instead of OP_ANYBYTE so that it works in DFA mode and in lookbehinds.
    There are special UCP codes for \B and \b which are used in UCP mode unless
    "word" matching is being forced to ASCII.

    Note that \b and \B do a one-character lookbehind, and \A also behaves as
    if it does. */

    switch(meta_arg)
      {
      case ESC_C:
      cb->external_flags |= PCRE2_HASBKC;  /* Record */
#if PCRE2_CODE_UNIT_WIDTH == 32
      meta_arg = OP_ALLANY;
#else
      if (!utf) meta_arg = OP_ALLANY;
#endif
      break;

      case ESC_B:
      case ESC_b:
      if ((options & PCRE2_UCP) != 0 && (xoptions & PCRE2_EXTRA_ASCII_BSW) == 0)
        meta_arg = (meta_arg == ESC_B)? OP_NOT_UCP_WORD_BOUNDARY :
          OP_UCP_WORD_BOUNDARY;
      /* Fall through */

      case ESC_A:
      if (cb->max_lookbehind == 0) cb->max_lookbehind = 1;
      break;
      }

    *code++ = meta_arg;
    break;  /* End META_ESCAPE */


    /* ===================================================================*/
    /* Handle an unrecognized meta value. A parsed pattern value less than
    META_END is a literal. Otherwise we have a problem. */

    default:
    if (meta >= META_END)
      {
      PCRE2_DEBUG_UNREACHABLE();
      *errorcodeptr = ERR89;  /* Internal error - unrecognized. */
      return 0;
      }

    /* Handle a literal character. We come here by goto in the case of a
    32-bit, non-UTF character whose value is greater than META_END. */

    NORMAL_CHAR:
    meta = *pptr;     /* Get the full 32 bits */
    NORMAL_CHAR_SET:  /* Character is already in meta */
    matched_char = TRUE;

    /* For caseless UTF or UCP mode, check whether this character has more than
    one other case. If so, generate a special OP_PROP item instead of OP_CHARI.
    When casing restrictions apply, ignore caseless sets that start with an
    ASCII character. If the character is affected by the special Turkish rules,
    hardcode the matching characters using a caseset. */

#ifdef SUPPORT_UNICODE
    if ((utf||ucp) && (options & PCRE2_CASELESS) != 0)
      {
      uint32_t caseset;

      if ((xoptions & (PCRE2_EXTRA_TURKISH_CASING|PCRE2_EXTRA_CASELESS_RESTRICT)) ==
            PCRE2_EXTRA_TURKISH_CASING &&
          UCD_ANY_I(meta))
        {
        caseset = PRIV(ucd_turkish_dotted_i_caseset) + (UCD_DOTTED_I(meta)? 0 : 3);
        }
      else if ((caseset = UCD_CASESET(meta)) != 0 &&
               (xoptions & PCRE2_EXTRA_CASELESS_RESTRICT) != 0 &&
               PRIV(ucd_caseless_sets)[caseset] < 128)
        {
        caseset = 0;  /* Ignore the caseless set if it's restricted. */
        }

      if (caseset != 0)
        {
        *code++ = OP_PROP;
        *code++ = PT_CLIST;
        *code++ = caseset;
        if (firstcuflags == REQ_UNSET)
          firstcuflags = zerofirstcuflags = REQ_NONE;
        break;  /* End handling this meta item */
        }
      }
#endif

    /* Caseful matches, or caseless and not one of the multicase characters. We
    come here by goto in the case of a positive class that contains only
    case-partners of a character with just two cases; matched_char has already
    been set TRUE and options fudged if necessary. */

    CLASS_CASELESS_CHAR:

    /* Get the character's code units into mcbuffer, with the length in
    mclength. When not in UTF mode, the length is always 1. */

#ifdef SUPPORT_UNICODE
    if (utf) mclength = PRIV(ord2utf)(meta, mcbuffer); else
#endif
      {
      mclength = 1;
      mcbuffer[0] = meta;
      }

    /* Generate the appropriate code */

    *code++ = ((options & PCRE2_CASELESS) != 0)? OP_CHARI : OP_CHAR;
    memcpy(code, mcbuffer, CU2BYTES(mclength));
    code += mclength;

    /* Remember if \r or \n were seen */

    if (mcbuffer[0] == CHAR_CR || mcbuffer[0] == CHAR_NL)
      cb->external_flags |= PCRE2_HASCRORLF;

    /* Set the first and required code units appropriately. If no previous
    first code unit, set it from this character, but revert to none on a zero
    repeat. Otherwise, leave the firstcu value alone, and don't change it on
    a zero repeat. */

    if (firstcuflags == REQ_UNSET)
      {
      zerofirstcuflags = REQ_NONE;
      zeroreqcu = reqcu;
      zeroreqcuflags = reqcuflags;

      /* If the character is more than one code unit long, we can set a single
      firstcu only if it is not to be matched caselessly. Multiple possible
      starting code units may be picked up later in the studying code. */

      if (mclength == 1 || req_caseopt == 0)
        {
        firstcu = mcbuffer[0];
        firstcuflags = req_caseopt;
        if (mclength != 1)
          {
          reqcu = code[-1];
          reqcuflags = cb->req_varyopt;
          }
        }
      else firstcuflags = reqcuflags = REQ_NONE;
      }

    /* firstcu was previously set; we can set reqcu only if the length is
    1 or the matching is caseful. */

    else
      {
      zerofirstcu = firstcu;
      zerofirstcuflags = firstcuflags;
      zeroreqcu = reqcu;
      zeroreqcuflags = reqcuflags;
      if (mclength == 1 || req_caseopt == 0)
        {
        reqcu = code[-1];
        reqcuflags = req_caseopt | cb->req_varyopt;
        }
      }

    /* If caselessness was temporarily instated, reset it. */

    if (reset_caseful)
      {
      options &= ~PCRE2_CASELESS;
      req_caseopt = 0;
      reset_caseful = FALSE;
      }

    break;    /* End literal character handling */
    }         /* End of big switch */
  }           /* End of big loop */

PCRE2_DEBUG_UNREACHABLE(); /* Control should never reach here */
return 0;                  /* Avoid compiler warnings */
}



/*************************************************
*   Compile regex: a sequence of alternatives    *
*************************************************/

/* On entry, pptr is pointing past the bracket meta, but on return it points to
the closing bracket or META_END. The code variable is pointing at the code unit
into which the BRA operator has been stored. This function is used during the
pre-compile phase when we are trying to find out the amount of memory needed,
as well as during the real compile phase. The value of lengthptr distinguishes
the two phases.

Arguments:
  options           option bits, including any changes for this subpattern
  xoptions          extra option bits, ditto
  codeptr           -> the address of the current code pointer
  pptrptr           -> the address of the current parsed pattern pointer
  errorcodeptr      -> pointer to error code variable
  skipunits         skip this many code units at start (for brackets and OP_COND)
  firstcuptr        place to put the first required code unit
  firstcuflagsptr   place to put the first code unit flags
  reqcuptr          place to put the last required code unit
  reqcuflagsptr     place to put the last required code unit flags
  bcptr             pointer to the chain of currently open branches
  cb                points to the data block with tables pointers etc.
  lengthptr         NULL during the real compile phase
                    points to length accumulator during pre-compile phase

Returns:            0 There has been an error
                   +1 Success, this group must match at least one character
                   -1 Success, this group may match an empty string
*/

static int
compile_regex(uint32_t options, uint32_t xoptions, PCRE2_UCHAR **codeptr,
  uint32_t **pptrptr, int *errorcodeptr, uint32_t skipunits,
  uint32_t *firstcuptr, uint32_t *firstcuflagsptr, uint32_t *reqcuptr,
  uint32_t *reqcuflagsptr, branch_chain *bcptr, open_capitem *open_caps,
  compile_block *cb, PCRE2_SIZE *lengthptr)
{
PCRE2_UCHAR *code = *codeptr;
PCRE2_UCHAR *last_branch = code;
PCRE2_UCHAR *start_bracket = code;
BOOL lookbehind;
open_capitem capitem;
int capnumber = 0;
int okreturn = 1;
uint32_t *pptr = *pptrptr;
uint32_t firstcu, reqcu;
uint32_t lookbehindlength;
uint32_t lookbehindminlength;
uint32_t firstcuflags, reqcuflags;
PCRE2_SIZE length;
branch_chain bc;

/* If set, call the external function that checks for stack availability. */

if (cb->cx->stack_guard != NULL &&
    cb->cx->stack_guard(cb->parens_depth, cb->cx->stack_guard_data))
  {
  *errorcodeptr= ERR33;
  return 0;
  }

/* Miscellaneous initialization */

bc.outer = bcptr;
bc.current_branch = code;

firstcu = reqcu = 0;
firstcuflags = reqcuflags = REQ_UNSET;

/* Accumulate the length for use in the pre-compile phase. Start with the
length of the BRA and KET and any extra code units that are required at the
beginning. We accumulate in a local variable to save frequent testing of
lengthptr for NULL. We cannot do this by looking at the value of 'code' at the
start and end of each alternative, because compiled items are discarded during
the pre-compile phase so that the workspace is not exceeded. */

length = 2 + 2*LINK_SIZE + skipunits;

/* Remember if this is a lookbehind assertion, and if it is, save its length
and skip over the pattern offset. */

lookbehind = *code == OP_ASSERTBACK ||
             *code == OP_ASSERTBACK_NOT ||
             *code == OP_ASSERTBACK_NA;

if (lookbehind)
  {
  lookbehindlength = META_DATA(pptr[-1]);
  lookbehindminlength = *pptr;
  pptr += SIZEOFFSET;
  }
else lookbehindlength = lookbehindminlength = 0;

/* If this is a capturing subpattern, add to the chain of open capturing items
so that we can detect them if (*ACCEPT) is encountered. Note that only OP_CBRA
need be tested here; changing this opcode to one of its variants, e.g.
OP_SCBRAPOS, happens later, after the group has been compiled. */

if (*code == OP_CBRA)
  {
  capnumber = GET2(code, 1 + LINK_SIZE);
  capitem.number = capnumber;
  capitem.next = open_caps;
  capitem.assert_depth = cb->assert_depth;
  open_caps = &capitem;
  }

/* Offset is set zero to mark that this bracket is still open */

PUT(code, 1, 0);
code += 1 + LINK_SIZE + skipunits;

/* Loop for each alternative branch */

for (;;)
  {
  int branch_return;
  uint32_t branchfirstcu = 0, branchreqcu = 0;
  uint32_t branchfirstcuflags = REQ_UNSET, branchreqcuflags = REQ_UNSET;

  /* Insert OP_REVERSE or OP_VREVERSE if this is a lookbehind assertion. There
  is only a single minimum length for the whole assertion. When the minimum
  length is LOOKBEHIND_MAX it means that all branches are of fixed length,
  though not necessarily the same length. In this case, the original OP_REVERSE
  can be used. It can also be used if a branch in a variable length lookbehind
  has the same maximum and minimum. Otherwise, use OP_VREVERSE, which has both
  maximum and minimum values. */

  if (lookbehind && lookbehindlength > 0)
    {
    if (lookbehindminlength == LOOKBEHIND_MAX ||
        lookbehindminlength == lookbehindlength)
      {
      *code++ = OP_REVERSE;
      PUT2INC(code, 0, lookbehindlength);
      length += 1 + IMM2_SIZE;
      }
    else
      {
      *code++ = OP_VREVERSE;
      PUT2INC(code, 0, lookbehindminlength);
      PUT2INC(code, 0, lookbehindlength);
      length += 1 + 2*IMM2_SIZE;
      }
    }

  /* Now compile the branch; in the pre-compile phase its length gets added
  into the length. */

  if ((branch_return =
        compile_branch(&options, &xoptions, &code, &pptr, errorcodeptr,
          &branchfirstcu, &branchfirstcuflags, &branchreqcu, &branchreqcuflags,
          &bc, open_caps, cb, (lengthptr == NULL)? NULL : &length)) == 0)
    return 0;

  /* If a branch can match an empty string, so can the whole group. */

  if (branch_return < 0) okreturn = -1;

  /* In the real compile phase, there is some post-processing to be done. */

  if (lengthptr == NULL)
    {
    /* If this is the first branch, the firstcu and reqcu values for the
    branch become the values for the regex. */

    if (*last_branch != OP_ALT)
      {
      firstcu = branchfirstcu;
      firstcuflags = branchfirstcuflags;
      reqcu = branchreqcu;
      reqcuflags = branchreqcuflags;
      }

    /* If this is not the first branch, the first char and reqcu have to
    match the values from all the previous branches, except that if the
    previous value for reqcu didn't have REQ_VARY set, it can still match,
    and we set REQ_VARY for the group from this branch's value. */

    else
      {
      /* If we previously had a firstcu, but it doesn't match the new branch,
      we have to abandon the firstcu for the regex, but if there was
      previously no reqcu, it takes on the value of the old firstcu. */

      if (firstcuflags != branchfirstcuflags || firstcu != branchfirstcu)
        {
        if (firstcuflags < REQ_NONE)
          {
          if (reqcuflags >= REQ_NONE)
            {
            reqcu = firstcu;
            reqcuflags = firstcuflags;
            }
          }
        firstcuflags = REQ_NONE;
        }

      /* If we (now or from before) have no firstcu, a firstcu from the
      branch becomes a reqcu if there isn't a branch reqcu. */

      if (firstcuflags >= REQ_NONE && branchfirstcuflags < REQ_NONE &&
          branchreqcuflags >= REQ_NONE)
        {
        branchreqcu = branchfirstcu;
        branchreqcuflags = branchfirstcuflags;
        }

      /* Now ensure that the reqcus match */

      if (((reqcuflags & ~REQ_VARY) != (branchreqcuflags & ~REQ_VARY)) ||
          reqcu != branchreqcu)
        reqcuflags = REQ_NONE;
      else
        {
        reqcu = branchreqcu;
        reqcuflags |= branchreqcuflags; /* To "or" REQ_VARY if present */
        }
      }
    }

  /* Handle reaching the end of the expression, either ')' or end of pattern.
  In the real compile phase, go back through the alternative branches and
  reverse the chain of offsets, with the field in the BRA item now becoming an
  offset to the first alternative. If there are no alternatives, it points to
  the end of the group. The length in the terminating ket is always the length
  of the whole bracketed item. Return leaving the pointer at the terminating
  char. */

  if (META_CODE(*pptr) != META_ALT)
    {
    if (lengthptr == NULL)
      {
      uint32_t branch_length = (uint32_t)(code - last_branch);
      do
        {
        uint32_t prev_length = GET(last_branch, 1);
        PUT(last_branch, 1, branch_length);
        branch_length = prev_length;
        last_branch -= branch_length;
        }
      while (branch_length > 0);
      }

    /* Fill in the ket */

    *code = OP_KET;
    PUT(code, 1, (uint32_t)(code - start_bracket));
    code += 1 + LINK_SIZE;

    /* Set values to pass back */

    *codeptr = code;
    *pptrptr = pptr;
    *firstcuptr = firstcu;
    *firstcuflagsptr = firstcuflags;
    *reqcuptr = reqcu;
    *reqcuflagsptr = reqcuflags;
    if (lengthptr != NULL)
      {
      if (OFLOW_MAX - *lengthptr < length)
        {
        *errorcodeptr = ERR20;
        return 0;
        }
      *lengthptr += length;
      }
    return okreturn;
    }

  /* Another branch follows. In the pre-compile phase, we can move the code
  pointer back to where it was for the start of the first branch. (That is,
  pretend that each branch is the only one.)

  In the real compile phase, insert an ALT node. Its length field points back
  to the previous branch while the bracket remains open. At the end the chain
  is reversed. It's done like this so that the start of the bracket has a
  zero offset until it is closed, making it possible to detect recursion. */

  if (lengthptr != NULL)
    {
    code = *codeptr + 1 + LINK_SIZE + skipunits;
    length += 1 + LINK_SIZE;
    }
  else
    {
    *code = OP_ALT;
    PUT(code, 1, (int)(code - last_branch));
    bc.current_branch = last_branch = code;
    code += 1 + LINK_SIZE;
    }

  /* Set the maximum lookbehind length for the next branch (if not in a
  lookbehind the value will be zero) and then advance past the vertical bar. */

  lookbehindlength = META_DATA(*pptr);
  pptr++;
  }

PCRE2_DEBUG_UNREACHABLE(); /* Control should never reach here */
return 0;                  /* Avoid compiler warnings */
}



/*************************************************
*          Check for anchored pattern            *
*************************************************/

/* Try to find out if this is an anchored regular expression. Consider each
alternative branch. If they all start with OP_SOD or OP_CIRC, or with a bracket
all of whose alternatives start with OP_SOD or OP_CIRC (recurse ad lib), then
it's anchored. However, if this is a multiline pattern, then only OP_SOD will
be found, because ^ generates OP_CIRCM in that mode.

We can also consider a regex to be anchored if OP_SOM starts all its branches.
This is the code for \G, which means "match at start of match position, taking
into account the match offset".

A branch is also implicitly anchored if it starts with .* and DOTALL is set,
because that will try the rest of the pattern at all possible matching points,
so there is no point trying again.... er ....

.... except when the .* appears inside capturing parentheses, and there is a
subsequent back reference to those parentheses. We haven't enough information
to catch that case precisely.

At first, the best we could do was to detect when .* was in capturing brackets
and the highest back reference was greater than or equal to that level.
However, by keeping a bitmap of the first 31 back references, we can catch some
of the more common cases more precisely.

... A second exception is when the .* appears inside an atomic group, because
this prevents the number of characters it matches from being adjusted.

Arguments:
  code           points to start of the compiled pattern
  bracket_map    a bitmap of which brackets we are inside while testing; this
                   handles up to substring 31; after that we just have to take
                   the less precise approach
  cb             points to the compile data block
  atomcount      atomic group level
  inassert       TRUE if in an assertion
  dotstar_anchor TRUE if automatic anchoring optimization is enabled

Returns:     TRUE or FALSE
*/

static BOOL
is_anchored(PCRE2_SPTR code, uint32_t bracket_map, compile_block *cb,
  int atomcount, BOOL inassert, BOOL dotstar_anchor)
{
do {
   PCRE2_SPTR scode = first_significant_code(
     code + PRIV(OP_lengths)[*code], FALSE);
   int op = *scode;

   /* Non-capturing brackets */

   if (op == OP_BRA  || op == OP_BRAPOS ||
       op == OP_SBRA || op == OP_SBRAPOS)
     {
     if (!is_anchored(scode, bracket_map, cb, atomcount, inassert, dotstar_anchor))
       return FALSE;
     }

   /* Capturing brackets */

   else if (op == OP_CBRA  || op == OP_CBRAPOS ||
            op == OP_SCBRA || op == OP_SCBRAPOS)
     {
     int n = GET2(scode, 1+LINK_SIZE);
     uint32_t new_map = bracket_map | ((n < 32)? (1u << n) : 1);
     if (!is_anchored(scode, new_map, cb, atomcount, inassert, dotstar_anchor)) return FALSE;
     }

   /* Positive forward assertion */

   else if (op == OP_ASSERT || op == OP_ASSERT_NA)
     {
     if (!is_anchored(scode, bracket_map, cb, atomcount, TRUE, dotstar_anchor)) return FALSE;
     }

   /* Condition. If there is no second branch, it can't be anchored. */

   else if (op == OP_COND || op == OP_SCOND)
     {
     if (scode[GET(scode,1)] != OP_ALT) return FALSE;
     if (!is_anchored(scode, bracket_map, cb, atomcount, inassert, dotstar_anchor))
       return FALSE;
     }

   /* Atomic groups */

   else if (op == OP_ONCE)
     {
     if (!is_anchored(scode, bracket_map, cb, atomcount + 1, inassert, dotstar_anchor))
       return FALSE;
     }

   /* .* is not anchored unless DOTALL is set (which generates OP_ALLANY) and
   it isn't in brackets that are or may be referenced or inside an atomic
   group or an assertion. Also the pattern must not contain *PRUNE or *SKIP,
   because these break the feature. Consider, for example, /(?s).*?(*PRUNE)b/
   with the subject "aab", which matches "b", i.e. not at the start of a line.
   There is also an option that disables auto-anchoring. */

   else if ((op == OP_TYPESTAR || op == OP_TYPEMINSTAR ||
             op == OP_TYPEPOSSTAR))
     {
     if (scode[1] != OP_ALLANY || (bracket_map & cb->backref_map) != 0 ||
         atomcount > 0 || cb->had_pruneorskip || inassert || !dotstar_anchor)
       return FALSE;
     }

   /* Check for explicit anchoring */

   else if (op != OP_SOD && op != OP_SOM && op != OP_CIRC) return FALSE;

   code += GET(code, 1);
   }
while (*code == OP_ALT);   /* Loop for each alternative */
return TRUE;
}



/*************************************************
*         Check for starting with ^ or .*        *
*************************************************/

/* This is called to find out if every branch starts with ^ or .* so that
"first char" processing can be done to speed things up in multiline
matching and for non-DOTALL patterns that start with .* (which must start at
the beginning or after \n). As in the case of is_anchored() (see above), we
have to take account of back references to capturing brackets that contain .*
because in that case we can't make the assumption. Also, the appearance of .*
inside atomic brackets or in an assertion, or in a pattern that contains *PRUNE
or *SKIP does not count, because once again the assumption no longer holds.

Arguments:
  code           points to start of the compiled pattern or a group
  bracket_map    a bitmap of which brackets we are inside while testing; this
                   handles up to substring 31; after that we just have to take
                   the less precise approach
  cb             points to the compile data
  atomcount      atomic group level
  inassert       TRUE if in an assertion
  dotstar_anchor TRUE if automatic anchoring optimization is enabled

Returns:         TRUE or FALSE
*/

static BOOL
is_startline(PCRE2_SPTR code, unsigned int bracket_map, compile_block *cb,
  int atomcount, BOOL inassert, BOOL dotstar_anchor)
{
do {
   PCRE2_SPTR scode = first_significant_code(
     code + PRIV(OP_lengths)[*code], FALSE);
   int op = *scode;

   /* If we are at the start of a conditional assertion group, *both* the
   conditional assertion *and* what follows the condition must satisfy the test
   for start of line. Other kinds of condition fail. Note that there may be an
   auto-callout at the start of a condition. */

   if (op == OP_COND)
     {
     scode += 1 + LINK_SIZE;

     if (*scode == OP_CALLOUT) scode += PRIV(OP_lengths)[OP_CALLOUT];
       else if (*scode == OP_CALLOUT_STR) scode += GET(scode, 1 + 2*LINK_SIZE);

     switch (*scode)
       {
       case OP_CREF:
       case OP_DNCREF:
       case OP_RREF:
       case OP_DNRREF:
       case OP_FAIL:
       case OP_FALSE:
       case OP_TRUE:
       return FALSE;

       default:     /* Assertion */
       if (!is_startline(scode, bracket_map, cb, atomcount, TRUE, dotstar_anchor))
         return FALSE;
       do scode += GET(scode, 1); while (*scode == OP_ALT);
       scode += 1 + LINK_SIZE;
       break;
       }
     scode = first_significant_code(scode, FALSE);
     op = *scode;
     }

   /* Non-capturing brackets */

   if (op == OP_BRA  || op == OP_BRAPOS ||
       op == OP_SBRA || op == OP_SBRAPOS)
     {
     if (!is_startline(scode, bracket_map, cb, atomcount, inassert, dotstar_anchor))
       return FALSE;
     }

   /* Capturing brackets */

   else if (op == OP_CBRA  || op == OP_CBRAPOS ||
            op == OP_SCBRA || op == OP_SCBRAPOS)
     {
     int n = GET2(scode, 1+LINK_SIZE);
     unsigned int new_map = bracket_map | ((n < 32)? (1u << n) : 1);
     if (!is_startline(scode, new_map, cb, atomcount, inassert, dotstar_anchor))
       return FALSE;
     }

   /* Positive forward assertions */

   else if (op == OP_ASSERT || op == OP_ASSERT_NA)
     {
     if (!is_startline(scode, bracket_map, cb, atomcount, TRUE, dotstar_anchor))
       return FALSE;
     }

   /* Atomic brackets */

   else if (op == OP_ONCE)
     {
     if (!is_startline(scode, bracket_map, cb, atomcount + 1, inassert, dotstar_anchor))
       return FALSE;
     }

   /* .* means "start at start or after \n" if it isn't in atomic brackets or
   brackets that may be referenced or an assertion, and as long as the pattern
   does not contain *PRUNE or *SKIP, because these break the feature. Consider,
   for example, /.*?a(*PRUNE)b/ with the subject "aab", which matches "ab",
   i.e. not at the start of a line. There is also an option that disables this
   optimization. */

   else if (op == OP_TYPESTAR || op == OP_TYPEMINSTAR || op == OP_TYPEPOSSTAR)
     {
     if (scode[1] != OP_ANY || (bracket_map & cb->backref_map) != 0 ||
         atomcount > 0 || cb->had_pruneorskip || inassert || !dotstar_anchor)
       return FALSE;
     }

   /* Check for explicit circumflex; anything else gives a FALSE result. Note
   in particular that this includes atomic brackets OP_ONCE because the number
   of characters matched by .* cannot be adjusted inside them. */

   else if (op != OP_CIRC && op != OP_CIRCM) return FALSE;

   /* Move on to the next alternative */

   code += GET(code, 1);
   }
while (*code == OP_ALT);  /* Loop for each alternative */
return TRUE;
}



/*************************************************
*   Scan compiled regex for recursion reference  *
*************************************************/

/* This function scans through a compiled pattern until it finds an instance of
OP_RECURSE.

Arguments:
  code        points to start of expression
  utf         TRUE in UTF mode

Returns:      pointer to the opcode for OP_RECURSE, or NULL if not found
*/

static PCRE2_UCHAR *
find_recurse(PCRE2_UCHAR *code, BOOL utf)
{
for (;;)
  {
  PCRE2_UCHAR c = *code;
  if (c == OP_END) return NULL;
  if (c == OP_RECURSE) return code;

  /* XCLASS is used for classes that cannot be represented just by a bit map.
  This includes negated single high-valued characters. ECLASS is used for
  classes that use set operations internally. CALLOUT_STR is used for
  callouts with string arguments. In each case the length in the table is
  zero; the actual length is stored in the compiled code. */

  if (c == OP_XCLASS || c == OP_ECLASS) code += GET(code, 1);
  else if (c == OP_CALLOUT_STR) code += GET(code, 1 + 2*LINK_SIZE);

  /* Otherwise, we can get the item's length from the table, except that for
  repeated character types, we have to test for \p and \P, which have an extra
  two code units of parameters, and for MARK/PRUNE/SKIP/THEN with an argument,
  we must add in its length. */

  else
    {
    switch(c)
      {
      case OP_TYPESTAR:
      case OP_TYPEMINSTAR:
      case OP_TYPEPLUS:
      case OP_TYPEMINPLUS:
      case OP_TYPEQUERY:
      case OP_TYPEMINQUERY:
      case OP_TYPEPOSSTAR:
      case OP_TYPEPOSPLUS:
      case OP_TYPEPOSQUERY:
      if (code[1] == OP_PROP || code[1] == OP_NOTPROP) code += 2;
      break;

      case OP_TYPEPOSUPTO:
      case OP_TYPEUPTO:
      case OP_TYPEMINUPTO:
      case OP_TYPEEXACT:
      if (code[1 + IMM2_SIZE] == OP_PROP || code[1 + IMM2_SIZE] == OP_NOTPROP)
        code += 2;
      break;

      case OP_MARK:
      case OP_COMMIT_ARG:
      case OP_PRUNE_ARG:
      case OP_SKIP_ARG:
      case OP_THEN_ARG:
      code += code[1];
      break;
      }

    /* Add in the fixed length from the table */

    code += PRIV(OP_lengths)[c];

    /* In UTF-8 and UTF-16 modes, opcodes that are followed by a character may
    be followed by a multi-unit character. The length in the table is a
    minimum, so we have to arrange to skip the extra units. */

#ifdef MAYBE_UTF_MULTI
    if (utf) switch(c)
      {
      case OP_CHAR:
      case OP_CHARI:
      case OP_NOT:
      case OP_NOTI:
      case OP_EXACT:
      case OP_EXACTI:
      case OP_NOTEXACT:
      case OP_NOTEXACTI:
      case OP_UPTO:
      case OP_UPTOI:
      case OP_NOTUPTO:
      case OP_NOTUPTOI:
      case OP_MINUPTO:
      case OP_MINUPTOI:
      case OP_NOTMINUPTO:
      case OP_NOTMINUPTOI:
      case OP_POSUPTO:
      case OP_POSUPTOI:
      case OP_NOTPOSUPTO:
      case OP_NOTPOSUPTOI:
      case OP_STAR:
      case OP_STARI:
      case OP_NOTSTAR:
      case OP_NOTSTARI:
      case OP_MINSTAR:
      case OP_MINSTARI:
      case OP_NOTMINSTAR:
      case OP_NOTMINSTARI:
      case OP_POSSTAR:
      case OP_POSSTARI:
      case OP_NOTPOSSTAR:
      case OP_NOTPOSSTARI:
      case OP_PLUS:
      case OP_PLUSI:
      case OP_NOTPLUS:
      case OP_NOTPLUSI:
      case OP_MINPLUS:
      case OP_MINPLUSI:
      case OP_NOTMINPLUS:
      case OP_NOTMINPLUSI:
      case OP_POSPLUS:
      case OP_POSPLUSI:
      case OP_NOTPOSPLUS:
      case OP_NOTPOSPLUSI:
      case OP_QUERY:
      case OP_QUERYI:
      case OP_NOTQUERY:
      case OP_NOTQUERYI:
      case OP_MINQUERY:
      case OP_MINQUERYI:
      case OP_NOTMINQUERY:
      case OP_NOTMINQUERYI:
      case OP_POSQUERY:
      case OP_POSQUERYI:
      case OP_NOTPOSQUERY:
      case OP_NOTPOSQUERYI:
      if (HAS_EXTRALEN(code[-1])) code += GET_EXTRALEN(code[-1]);
      break;
      }
#else
    (void)(utf);  /* Keep compiler happy by referencing function argument */
#endif  /* MAYBE_UTF_MULTI */
    }
  }
}



/*************************************************
*    Check for asserted fixed first code unit    *
*************************************************/

/* During compilation, the "first code unit" settings from forward assertions
are discarded, because they can cause conflicts with actual literals that
follow. However, if we end up without a first code unit setting for an
unanchored pattern, it is worth scanning the regex to see if there is an
initial asserted first code unit. If all branches start with the same asserted
code unit, or with a non-conditional bracket all of whose alternatives start
with the same asserted code unit (recurse ad lib), then we return that code
unit, with the flags set to zero or REQ_CASELESS; otherwise return zero with
REQ_NONE in the flags.

Arguments:
  code       points to start of compiled pattern
  flags      points to the first code unit flags
  inassert   non-zero if in an assertion

Returns:     the fixed first code unit, or 0 with REQ_NONE in flags
*/

static uint32_t
find_firstassertedcu(PCRE2_SPTR code, uint32_t *flags, uint32_t inassert)
{
uint32_t c = 0;
uint32_t cflags = REQ_NONE;

*flags = REQ_NONE;
do {
   uint32_t d;
   uint32_t dflags;
   int xl = (*code == OP_CBRA || *code == OP_SCBRA ||
             *code == OP_CBRAPOS || *code == OP_SCBRAPOS)? IMM2_SIZE:0;
   PCRE2_SPTR scode = first_significant_code(code + 1+LINK_SIZE + xl, TRUE);
   PCRE2_UCHAR op = *scode;

   switch(op)
     {
     default:
     return 0;

     case OP_BRA:
     case OP_BRAPOS:
     case OP_CBRA:
     case OP_SCBRA:
     case OP_CBRAPOS:
     case OP_SCBRAPOS:
     case OP_ASSERT:
     case OP_ASSERT_NA:
     case OP_ONCE:
     case OP_SCRIPT_RUN:
     d = find_firstassertedcu(scode, &dflags, inassert +
       ((op == OP_ASSERT || op == OP_ASSERT_NA)?1:0));
     if (dflags >= REQ_NONE) return 0;
     if (cflags >= REQ_NONE) { c = d; cflags = dflags; }
       else if (c != d || cflags != dflags) return 0;
     break;

     case OP_EXACT:
     scode += IMM2_SIZE;
     /* Fall through */

     case OP_CHAR:
     case OP_PLUS:
     case OP_MINPLUS:
     case OP_POSPLUS:
     if (inassert == 0) return 0;
     if (cflags >= REQ_NONE) { c = scode[1]; cflags = 0; }
       else if (c != scode[1]) return 0;
     break;

     case OP_EXACTI:
     scode += IMM2_SIZE;
     /* Fall through */

     case OP_CHARI:
     case OP_PLUSI:
     case OP_MINPLUSI:
     case OP_POSPLUSI:
     if (inassert == 0) return 0;

     /* If the character is more than one code unit long, we cannot set its
     first code unit when matching caselessly. Later scanning may pick up
     multiple code units. */

#ifdef SUPPORT_UNICODE
#if PCRE2_CODE_UNIT_WIDTH == 8
     if (scode[1] >= 0x80) return 0;
#elif PCRE2_CODE_UNIT_WIDTH == 16
     if (scode[1] >= 0xd800 && scode[1] <= 0xdfff) return 0;
#endif
#endif

     if (cflags >= REQ_NONE) { c = scode[1]; cflags = REQ_CASELESS; }
       else if (c != scode[1]) return 0;
     break;
     }

   code += GET(code, 1);
   }
while (*code == OP_ALT);

*flags = cflags;
return c;
}



/*************************************************
*     Add an entry to the name/number table      *
*************************************************/

/* This function is called between compiling passes to add an entry to the
name/number table, maintaining alphabetical order. Checking for permitted
and forbidden duplicates has already been done.

Arguments:
  cb           the compile data block
  name         the name to add
  length       the length of the name
  groupno      the group number
  tablecount   the count of names in the table so far

Returns:       nothing
*/

static void
add_name_to_table(compile_block *cb, PCRE2_SPTR name, int length,
  unsigned int groupno, uint32_t tablecount)
{
uint32_t i;
PCRE2_UCHAR *slot = cb->name_table;

for (i = 0; i < tablecount; i++)
  {
  int crc = memcmp(name, slot+IMM2_SIZE, CU2BYTES(length));
  if (crc == 0 && slot[IMM2_SIZE+length] != 0)
    crc = -1; /* Current name is a substring */

  /* Make space in the table and break the loop for an earlier name. For a
  duplicate or later name, carry on. We do this for duplicates so that in the
  simple case (when ?(| is not used) they are in order of their numbers. In all
  cases they are in the order in which they appear in the pattern. */

  if (crc < 0)
    {
    (void)memmove(slot + cb->name_entry_size, slot,
      CU2BYTES((tablecount - i) * cb->name_entry_size));
    break;
    }

  /* Continue the loop for a later or duplicate name */

  slot += cb->name_entry_size;
  }

PUT2(slot, 0, groupno);
memcpy(slot + IMM2_SIZE, name, CU2BYTES(length));

/* Add a terminating zero and fill the rest of the slot with zeroes so that
the memory is all initialized. Otherwise valgrind moans about uninitialized
memory when saving serialized compiled patterns. */

memset(slot + IMM2_SIZE + length, 0,
  CU2BYTES(cb->name_entry_size - length - IMM2_SIZE));
}



/*************************************************
*             Skip in parsed pattern             *
*************************************************/

/* This function is called to skip parts of the parsed pattern when finding the
length of a lookbehind branch. It is called after (*ACCEPT) and (*FAIL) to find
the end of the branch, it is called to skip over an internal lookaround or
(DEFINE) group, and it is also called to skip to the end of a class, during
which it will never encounter nested groups (but there's no need to have
special code for that).

When called to find the end of a branch or group, pptr must point to the first
meta code inside the branch, not the branch-starting code. In other cases it
can point to the item that causes the function to be called.

Arguments:
  pptr       current pointer to skip from
  skiptype   PSKIP_CLASS when skipping to end of class
             PSKIP_ALT when META_ALT ends the skip
             PSKIP_KET when only META_KET ends the skip

Returns:     new value of pptr
             NULL if META_END is reached - should never occur
               or for an unknown meta value - likewise
*/

static uint32_t *
parsed_skip(uint32_t *pptr, uint32_t skiptype)
{
uint32_t nestlevel = 0;

for (;; pptr++)
  {
  uint32_t meta = META_CODE(*pptr);

  switch(meta)
    {
    default:  /* Just skip over most items */
    if (meta < META_END) continue;  /* Literal */
    break;

    case META_END:

    /* The parsed regex is malformed; we have reached the end and did
    not find the end of the construct which we are skipping over. */

    PCRE2_DEBUG_UNREACHABLE();
    return NULL;

    /* The data for these items is variable in length. */

    case META_BACKREF:  /* Offset is present only if group >= 10 */
    if (META_DATA(*pptr) >= 10) pptr += SIZEOFFSET;
    break;

    case META_ESCAPE:
    if (*pptr - META_ESCAPE == ESC_P || *pptr - META_ESCAPE == ESC_p)
      pptr += 1;     /* Skip prop data */
    break;

    case META_MARK:     /* Add the length of the name. */
    case META_COMMIT_ARG:
    case META_PRUNE_ARG:
    case META_SKIP_ARG:
    case META_THEN_ARG:
    pptr += pptr[1];
    break;

    /* These are the "active" items in this loop. */

    case META_CLASS_END:
    if (skiptype == PSKIP_CLASS) return pptr;
    break;

    case META_ATOMIC:
    case META_CAPTURE:
    case META_COND_ASSERT:
    case META_COND_DEFINE:
    case META_COND_NAME:
    case META_COND_NUMBER:
    case META_COND_RNAME:
    case META_COND_RNUMBER:
    case META_COND_VERSION:
    case META_SCS:
    case META_LOOKAHEAD:
    case META_LOOKAHEADNOT:
    case META_LOOKAHEAD_NA:
    case META_LOOKBEHIND:
    case META_LOOKBEHINDNOT:
    case META_LOOKBEHIND_NA:
    case META_NOCAPTURE:
    case META_SCRIPT_RUN:
    nestlevel++;
    break;

    case META_ALT:
    if (nestlevel == 0 && skiptype == PSKIP_ALT) return pptr;
    break;

    case META_KET:
    if (nestlevel == 0) return pptr;
    nestlevel--;
    break;
    }

  /* The extra data item length for each meta is in a table. */

  meta = (meta >> 16) & 0x7fff;
  if (meta >= sizeof(meta_extra_lengths)) return NULL;
  pptr += meta_extra_lengths[meta];
  }

PCRE2_UNREACHABLE(); /* Control never reaches here */
}



/*************************************************
*       Find length of a parsed group            *
*************************************************/

/* This is called for nested groups within a branch of a lookbehind whose
length is being computed. On entry, the pointer must be at the first element
after the group initializing code. On exit it points to OP_KET. Caching is used
to improve processing speed when the same capturing group occurs many times.

Arguments:
  pptrptr     pointer to pointer in the parsed pattern
  minptr      where to return the minimum length
  isinline    FALSE if a reference or recursion; TRUE for inline group
  errcodeptr  pointer to the errorcode
  lcptr       pointer to the loop counter
  group       number of captured group or -1 for a non-capturing group
  recurses    chain of recurse_check to catch mutual recursion
  cb          pointer to the compile data

Returns:      the maximum group length or a negative number
*/

static int
get_grouplength(uint32_t **pptrptr, int *minptr, BOOL isinline, int *errcodeptr,
  int *lcptr, int group, parsed_recurse_check *recurses, compile_block *cb)
{
uint32_t *gi = cb->groupinfo + 2 * group;
int branchlength, branchminlength;
int grouplength = -1;
int groupminlength = INT_MAX;

/* The cache can be used only if there is no possibility of there being two
groups with the same number. We do not need to set the end pointer for a group
that is being processed as a back reference or recursion, but we must do so for
an inline group. */

if (group > 0 && (cb->external_flags & PCRE2_DUPCAPUSED) == 0)
  {
  uint32_t groupinfo = gi[0];
  if ((groupinfo & GI_NOT_FIXED_LENGTH) != 0) return -1;
  if ((groupinfo & GI_SET_FIXED_LENGTH) != 0)
    {
    if (isinline) *pptrptr = parsed_skip(*pptrptr, PSKIP_KET);
    *minptr = gi[1];
    return groupinfo & GI_FIXED_LENGTH_MASK;
    }
  }

/* Scan the group. In this case we find the end pointer of necessity. */

for(;;)
  {
  branchlength = get_branchlength(pptrptr, &branchminlength, errcodeptr, lcptr,
    recurses, cb);
  if (branchlength < 0) goto ISNOTFIXED;
  if (branchlength > grouplength) grouplength = branchlength;
  if (branchminlength < groupminlength) groupminlength = branchminlength;
  if (**pptrptr == META_KET) break;
  *pptrptr += 1;   /* Skip META_ALT */
  }

if (group > 0)
  {
  gi[0] |= (uint32_t)(GI_SET_FIXED_LENGTH | grouplength);
  gi[1] = groupminlength;
  }

*minptr = groupminlength;
return grouplength;

ISNOTFIXED:
if (group > 0) gi[0] |= GI_NOT_FIXED_LENGTH;
return -1;
}



/*************************************************
*        Find length of a parsed branch          *
*************************************************/

/* Return fixed maximum and minimum lengths for a branch in a lookbehind,
giving an error if the length is not limited. On entry, *pptrptr points to the
first element inside the branch. On exit it is set to point to the ALT or KET.

Arguments:
  pptrptr     pointer to pointer in the parsed pattern
  minptr      where to return the minimum length
  errcodeptr  pointer to error code
  lcptr       pointer to loop counter
  recurses    chain of recurse_check to catch mutual recursion
  cb          pointer to compile block

Returns:      the maximum length, or a negative value on error
*/

static int
get_branchlength(uint32_t **pptrptr, int *minptr, int *errcodeptr, int *lcptr,
  parsed_recurse_check *recurses, compile_block *cb)
{
int branchlength = 0;
int branchminlength = 0;
int grouplength, groupminlength;
uint32_t lastitemlength = 0;
uint32_t lastitemminlength = 0;
uint32_t *pptr = *pptrptr;
PCRE2_SIZE offset;
parsed_recurse_check this_recurse;

/* A large and/or complex regex can take too long to process. This can happen
more often when (?| groups are present in the pattern because their length
cannot be cached. */

if ((*lcptr)++ > 2000)
  {
  *errcodeptr = ERR35;  /* Lookbehind is too complicated */
  return -1;
  }

/* Scan the branch, accumulating the length. */

for (;; pptr++)
  {
  parsed_recurse_check *r;
  uint32_t *gptr, *gptrend;
  uint32_t escape;
  uint32_t min, max;
  uint32_t group = 0;
  uint32_t itemlength = 0;
  uint32_t itemminlength = 0;

  if (*pptr < META_END)
    {
    itemlength = itemminlength = 1;
    }

  else switch (META_CODE(*pptr))
    {
    case META_KET:
    case META_ALT:
    goto EXIT;

    /* (*ACCEPT) and (*FAIL) terminate the branch, but we must skip to the
    actual termination. */

    case META_ACCEPT:
    case META_FAIL:
    pptr = parsed_skip(pptr, PSKIP_ALT);
    if (pptr == NULL) goto PARSED_SKIP_FAILED;
    goto EXIT;

    case META_MARK:
    case META_COMMIT_ARG:
    case META_PRUNE_ARG:
    case META_SKIP_ARG:
    case META_THEN_ARG:
    pptr += pptr[1] + 1;
    break;

    case META_CIRCUMFLEX:
    case META_COMMIT:
    case META_DOLLAR:
    case META_PRUNE:
    case META_SKIP:
    case META_THEN:
    break;

    case META_OPTIONS:
    pptr += 2;
    break;

    case META_BIGVALUE:
    itemlength = itemminlength = 1;
    pptr += 1;
    break;

    case META_CLASS:
    case META_CLASS_NOT:
    itemlength = itemminlength = 1;
    pptr = parsed_skip(pptr, PSKIP_CLASS);
    if (pptr == NULL) goto PARSED_SKIP_FAILED;
    break;

    case META_CLASS_EMPTY_NOT:
    case META_DOT:
    itemlength = itemminlength = 1;
    break;

    case META_CALLOUT_NUMBER:
    pptr += 3;
    break;

    case META_CALLOUT_STRING:
    pptr += 3 + SIZEOFFSET;
    break;

    /* Only some escapes consume a character. Of those, \R can match one or two
    characters, but \X is never allowed because it matches an unknown number of
    characters. \C is allowed only in 32-bit and non-UTF 8/16-bit modes. */

    case META_ESCAPE:
    escape = META_DATA(*pptr);
    if (escape == ESC_X) return -1;
    if (escape == ESC_R)
      {
      itemminlength = 1;
      itemlength = 2;
      }
    else if (escape > ESC_b && escape < ESC_Z)
      {
#if PCRE2_CODE_UNIT_WIDTH != 32
      if ((cb->external_options & PCRE2_UTF) != 0 && escape == ESC_C)
        {
        *errcodeptr = ERR36;
        return -1;
        }
#endif
      itemlength = itemminlength = 1;
      if (escape == ESC_p || escape == ESC_P) pptr++;  /* Skip prop data */
      }
    break;

    /* Lookaheads do not contribute to the length of this branch, but they may
    contain lookbehinds within them whose lengths need to be set. */

    case META_LOOKAHEAD:
    case META_LOOKAHEADNOT:
    case META_LOOKAHEAD_NA:
    case META_SCS:
    *errcodeptr = check_lookbehinds(pptr + 1, &pptr, recurses, cb, lcptr);
    if (*errcodeptr != 0) return -1;

    /* Ignore any qualifiers that follow a lookahead assertion. */

    switch (pptr[1])
      {
      case META_ASTERISK:
      case META_ASTERISK_PLUS:
      case META_ASTERISK_QUERY:
      case META_PLUS:
      case META_PLUS_PLUS:
      case META_PLUS_QUERY:
      case META_QUERY:
      case META_QUERY_PLUS:
      case META_QUERY_QUERY:
      pptr++;
      break;

      case META_MINMAX:
      case META_MINMAX_PLUS:
      case META_MINMAX_QUERY:
      pptr += 3;
      break;

      default:
      break;
      }
    break;

    /* A nested lookbehind does not contribute any length to this lookbehind,
    but must itself be checked and have its lengths set. Note that
    set_lookbehind_lengths() updates pptr, leaving it pointing to the final ket
    of the group, so no need to update it here. */

    case META_LOOKBEHIND:
    case META_LOOKBEHINDNOT:
    case META_LOOKBEHIND_NA:
    if (!set_lookbehind_lengths(&pptr, errcodeptr, lcptr, recurses, cb))
      return -1;
    break;

    /* Back references and recursions are handled by very similar code. At this
    stage, the names generated in the parsing pass are available, but the main
    name table has not yet been created. So for the named varieties, scan the
    list of names in order to get the number of the first one in the pattern,
    and whether or not this name is duplicated. */

    case META_BACKREF_BYNAME:
    if ((cb->external_options & PCRE2_MATCH_UNSET_BACKREF) != 0)
      goto ISNOTFIXED;
    /* Fall through */

    case META_RECURSE_BYNAME:
      {
      int i;
      PCRE2_SPTR name;
      BOOL is_dupname = FALSE;
      named_group *ng = cb->named_groups;
      uint32_t meta_code = META_CODE(*pptr);
      uint32_t length = *(++pptr);

      GETPLUSOFFSET(offset, pptr);
      name = cb->start_pattern + offset;
      for (i = 0; i < cb->names_found; i++, ng++)
        {
        if (length == ng->length && PRIV(strncmp)(name, ng->name, length) == 0)
          {
          group = ng->number;
          is_dupname = ng->isdup;
          break;
          }
        }

      if (group == 0)
        {
        *errcodeptr = ERR15;  /* Non-existent subpattern */
        cb->erroroffset = offset;
        return -1;
        }

      /* A numerical back reference can be fixed length if duplicate capturing
      groups are not being used. A non-duplicate named back reference can also
      be handled. */

      if (meta_code == META_RECURSE_BYNAME ||
          (!is_dupname && (cb->external_flags & PCRE2_DUPCAPUSED) == 0))
        goto RECURSE_OR_BACKREF_LENGTH;  /* Handle as a numbered version. */
      }
    goto ISNOTFIXED;                     /* Duplicate name or number */

    /* The offset values for back references < 10 are in a separate vector
    because otherwise they would use more than two parsed pattern elements on
    64-bit systems. */

    case META_BACKREF:
    if ((cb->external_options & PCRE2_MATCH_UNSET_BACKREF) != 0 ||
        (cb->external_flags & PCRE2_DUPCAPUSED) != 0)
      goto ISNOTFIXED;
    group = META_DATA(*pptr);
    if (group < 10)
      {
      offset = cb->small_ref_offset[group];
      goto RECURSE_OR_BACKREF_LENGTH;
      }

    /* Fall through */
    /* For groups >= 10 - picking up group twice does no harm. */

    /* A true recursion implies not fixed length, but a subroutine call may
    be OK. Back reference "recursions" are also failed. */

    case META_RECURSE:
    group = META_DATA(*pptr);
    GETPLUSOFFSET(offset, pptr);

    RECURSE_OR_BACKREF_LENGTH:
    if (group > cb->bracount)
      {
      cb->erroroffset = offset;
      *errcodeptr = ERR15;  /* Non-existent subpattern */
      return -1;
      }
    if (group == 0) goto ISNOTFIXED;  /* Local recursion */
    for (gptr = cb->parsed_pattern; *gptr != META_END; gptr++)
      {
      if (META_CODE(*gptr) == META_BIGVALUE) gptr++;
        else if (*gptr == (META_CAPTURE | group)) break;
      }

    /* We must start the search for the end of the group at the first meta code
    inside the group. Otherwise it will be treated as an enclosed group. */

    gptrend = parsed_skip(gptr + 1, PSKIP_KET);
    if (gptrend == NULL) goto PARSED_SKIP_FAILED;
    if (pptr > gptr && pptr < gptrend) goto ISNOTFIXED;  /* Local recursion */
    for (r = recurses; r != NULL; r = r->prev) if (r->groupptr == gptr) break;
    if (r != NULL) goto ISNOTFIXED;   /* Mutual recursion */
    this_recurse.prev = recurses;
    this_recurse.groupptr = gptr;

    /* We do not need to know the position of the end of the group, that is,
    gptr is not used after the call to get_grouplength(). Setting the second
    argument FALSE stops it scanning for the end when the length can be found
    in the cache. */

    gptr++;
    grouplength = get_grouplength(&gptr, &groupminlength, FALSE, errcodeptr,
      lcptr, group, &this_recurse, cb);
    if (grouplength < 0)
      {
      if (*errcodeptr == 0) goto ISNOTFIXED;
      return -1;  /* Error already set */
      }
    itemlength = grouplength;
    itemminlength = groupminlength;
    break;

    /* A (DEFINE) group is never obeyed inline and so it does not contribute to
    the length of this branch. Skip from the following item to the next
    unpaired ket. */

    case META_COND_DEFINE:
    pptr = parsed_skip(pptr + 1, PSKIP_KET);
    break;

    /* Check other nested groups - advance past the initial data for each type
    and then seek a fixed length with get_grouplength(). */

    case META_COND_NAME:
    case META_COND_NUMBER:
    case META_COND_RNAME:
    case META_COND_RNUMBER:
    pptr += 2 + SIZEOFFSET;
    goto CHECK_GROUP;

    case META_COND_ASSERT:
    pptr += 1;
    goto CHECK_GROUP;

    case META_COND_VERSION:
    pptr += 4;
    goto CHECK_GROUP;

    case META_CAPTURE:
    group = META_DATA(*pptr);
    /* Fall through */

    case META_ATOMIC:
    case META_NOCAPTURE:
    case META_SCRIPT_RUN:
    pptr++;
    CHECK_GROUP:
    grouplength = get_grouplength(&pptr, &groupminlength, TRUE, errcodeptr,
      lcptr, group, recurses, cb);
    if (grouplength < 0) return -1;
    itemlength = grouplength;
    itemminlength = groupminlength;
    break;

    case META_QUERY:
    case META_QUERY_PLUS:
    case META_QUERY_QUERY:
    min = 0;
    max = 1;
    goto REPETITION;

    /* Exact repetition is OK; variable repetition is not. A repetition of zero
    must subtract the length that has already been added. */

    case META_MINMAX:
    case META_MINMAX_PLUS:
    case META_MINMAX_QUERY:
    min = pptr[1];
    max = pptr[2];
    pptr += 2;

    REPETITION:
    if (max != REPEAT_UNLIMITED)
      {
      if (lastitemlength != 0 &&  /* Should not occur, but just in case */
          max != 0 &&
          (INT_MAX - branchlength)/lastitemlength < max - 1)
        {
        *errcodeptr = ERR87;  /* Integer overflow; lookbehind too big */
        return -1;
        }
      if (min == 0) branchminlength -= lastitemminlength;
        else itemminlength = (min - 1) * lastitemminlength;
      if (max == 0) branchlength -= lastitemlength;
        else itemlength = (max - 1) * lastitemlength;
      break;
      }
    /* Fall through */

    /* Any other item means this branch does not have a fixed length. */

    default:
    ISNOTFIXED:
    *errcodeptr = ERR25;   /* Not fixed length */
    return -1;
    }

  /* Add the item length to the branchlength, checking for integer overflow and
  for the branch length exceeding the overall limit. Later, if there is at
  least one variable-length branch in the group, there is a test for the
  (smaller) variable-length branch length limit. */

  if (INT_MAX - branchlength < (int)itemlength ||
      (branchlength += itemlength) > LOOKBEHIND_MAX)
    {
    *errcodeptr = ERR87;
    return -1;
    }

  branchminlength += itemminlength;

  /* Save this item length for use if the next item is a quantifier. */

  lastitemlength = itemlength;
  lastitemminlength = itemminlength;
  }

EXIT:
*pptrptr = pptr;
*minptr = branchminlength;
return branchlength;

PARSED_SKIP_FAILED:
PCRE2_DEBUG_UNREACHABLE();
*errcodeptr = ERR90;  /* Unhandled META code - internal error */
return -1;
}



/*************************************************
*        Set lengths in a lookbehind             *
*************************************************/

/* This function is called for each lookbehind, to set the lengths in its
branches. An error occurs if any branch does not have a limited maximum length
that is less than the limit (65535). On exit, the pointer must be left on the
final ket.

The function also maintains the max_lookbehind value. Any lookbehind branch
that contains a nested lookbehind may actually look further back than the
length of the branch. The additional amount is passed back from
get_branchlength() as an "extra" value.

Arguments:
  pptrptr     pointer to pointer in the parsed pattern
  errcodeptr  pointer to error code
  lcptr       pointer to loop counter
  recurses    chain of recurse_check to catch mutual recursion
  cb          pointer to compile block

Returns:      TRUE if all is well
              FALSE otherwise, with error code and offset set
*/

static BOOL
set_lookbehind_lengths(uint32_t **pptrptr, int *errcodeptr, int *lcptr,
  parsed_recurse_check *recurses, compile_block *cb)
{
PCRE2_SIZE offset;
uint32_t *bptr = *pptrptr;
uint32_t *gbptr = bptr;
int maxlength = 0;
int minlength = INT_MAX;
BOOL variable = FALSE;

READPLUSOFFSET(offset, bptr);  /* Offset for error messages */
*pptrptr += SIZEOFFSET;

/* Each branch can have a different maximum length, but we can keep only a
single minimum for the whole group, because there's nowhere to save individual
values in the META_ALT item. */

do
  {
  int branchlength, branchminlength;

  *pptrptr += 1;
  branchlength = get_branchlength(pptrptr, &branchminlength, errcodeptr, lcptr,
    recurses, cb);

  if (branchlength < 0)
    {
    /* The errorcode and offset may already be set from a nested lookbehind. */
    if (*errcodeptr == 0) *errcodeptr = ERR25;
    if (cb->erroroffset == PCRE2_UNSET) cb->erroroffset = offset;
    return FALSE;
    }

  if (branchlength != branchminlength) variable = TRUE;
  if (branchminlength < minlength) minlength = branchminlength;
  if (branchlength > maxlength) maxlength = branchlength;
  if (branchlength > cb->max_lookbehind) cb->max_lookbehind = branchlength;
  *bptr |= branchlength;  /* branchlength never more than 65535 */
  bptr = *pptrptr;
  }
while (META_CODE(*bptr) == META_ALT);

/* If any branch is of variable length, the whole lookbehind is of variable
length. If the maximum length of any branch exceeds the maximum for variable
lookbehinds, give an error. Otherwise, the minimum length is set in the word
that follows the original group META value. For a fixed-length lookbehind, this
is set to LOOKBEHIND_MAX, to indicate that each branch is of a fixed (but
possibly different) length. */

if (variable)
  {
  gbptr[1] = minlength;
  if ((PCRE2_SIZE)maxlength > cb->max_varlookbehind)
    {
    *errcodeptr = ERR100;
    cb->erroroffset = offset;
    return FALSE;
    }
  }
else gbptr[1] = LOOKBEHIND_MAX;

return TRUE;
}



/*************************************************
*         Check parsed pattern lookbehinds       *
*************************************************/

/* This function is called at the end of parsing a pattern if any lookbehinds
were encountered. It scans the parsed pattern for them, calling
set_lookbehind_lengths() for each one. At the start, the errorcode is zero and
the error offset is marked unset. The enables the functions above not to
override settings from deeper nestings.

This function is called recursively from get_branchlength() for lookaheads in
order to process any lookbehinds that they may contain. It stops when it hits a
non-nested closing parenthesis in this case, returning a pointer to it.

Arguments
  pptr      points to where to start (start of pattern or start of lookahead)
  retptr    if not NULL, return the ket pointer here
  recurses  chain of recurse_check to catch mutual recursion
  cb        points to the compile block
  lcptr     points to loop counter

Returns:    0 on success, or an errorcode (cb->erroroffset will be set)
*/

static int
check_lookbehinds(uint32_t *pptr, uint32_t **retptr,
  parsed_recurse_check *recurses, compile_block *cb, int *lcptr)
{
int errorcode = 0;
int nestlevel = 0;

cb->erroroffset = PCRE2_UNSET;

for (; *pptr != META_END; pptr++)
  {
  if (*pptr < META_END) continue;  /* Literal */

  switch (META_CODE(*pptr))
    {
    default:

    /* The following erroroffset is a bogus but safe value. This branch should
    be avoided by providing a proper implementation for all supported cases
    below. */

    PCRE2_DEBUG_UNREACHABLE();
    cb->erroroffset = 0;
    return ERR70;  /* Unrecognized meta code */

    case META_ESCAPE:
    if (*pptr - META_ESCAPE == ESC_P || *pptr - META_ESCAPE == ESC_p)
      pptr += 1;    /* Skip prop data */
    break;

    case META_KET:
    if (--nestlevel < 0)
      {
      if (retptr != NULL) *retptr = pptr;
      return 0;
      }
    break;

    case META_ATOMIC:
    case META_CAPTURE:
    case META_COND_ASSERT:
    case META_SCS:
    case META_LOOKAHEAD:
    case META_LOOKAHEADNOT:
    case META_LOOKAHEAD_NA:
    case META_NOCAPTURE:
    case META_SCRIPT_RUN:
    nestlevel++;
    break;

    case META_ACCEPT:
    case META_ALT:
    case META_ASTERISK:
    case META_ASTERISK_PLUS:
    case META_ASTERISK_QUERY:
    case META_BACKREF:
    case META_CIRCUMFLEX:
    case META_CLASS:
    case META_CLASS_EMPTY:
    case META_CLASS_EMPTY_NOT:
    case META_CLASS_END:
    case META_CLASS_NOT:
    case META_COMMIT:
    case META_DOLLAR:
    case META_DOT:
    case META_FAIL:
    case META_PLUS:
    case META_PLUS_PLUS:
    case META_PLUS_QUERY:
    case META_PRUNE:
    case META_QUERY:
    case META_QUERY_PLUS:
    case META_QUERY_QUERY:
    case META_RANGE_ESCAPED:
    case META_RANGE_LITERAL:
    case META_SKIP:
    case META_THEN:
    break;

    case META_OFFSET:
    case META_RECURSE:
    pptr += SIZEOFFSET;
    break;

    case META_BACKREF_BYNAME:
    case META_RECURSE_BYNAME:
    pptr += 1 + SIZEOFFSET;
    break;

    case META_COND_DEFINE:
    pptr += SIZEOFFSET;
    nestlevel++;
    break;

    case META_COND_NAME:
    case META_COND_NUMBER:
    case META_COND_RNAME:
    case META_COND_RNUMBER:
    pptr += 1 + SIZEOFFSET;
    nestlevel++;
    break;

    case META_COND_VERSION:
    pptr += 3;
    nestlevel++;
    break;

    case META_CALLOUT_STRING:
    pptr += 3 + SIZEOFFSET;
    break;

    case META_BIGVALUE:
    case META_POSIX:
    case META_POSIX_NEG:
    case META_SCS_NAME:
    case META_SCS_NUMBER:
    pptr += 1;
    break;

    case META_MINMAX:
    case META_MINMAX_QUERY:
    case META_MINMAX_PLUS:
    case META_OPTIONS:
    pptr += 2;
    break;

    case META_CALLOUT_NUMBER:
    pptr += 3;
    break;

    case META_MARK:
    case META_COMMIT_ARG:
    case META_PRUNE_ARG:
    case META_SKIP_ARG:
    case META_THEN_ARG:
    pptr += 1 + pptr[1];
    break;

    /* Note that set_lookbehind_lengths() updates pptr, leaving it pointing to
    the final ket of the group, so no need to update it here. */

    case META_LOOKBEHIND:
    case META_LOOKBEHINDNOT:
    case META_LOOKBEHIND_NA:
    if (!set_lookbehind_lengths(&pptr, &errorcode, lcptr, recurses, cb))
      return errorcode;
    break;
    }
  }

return 0;
}



/*************************************************
*     External function to compile a pattern     *
*************************************************/

/* This function reads a regular expression in the form of a string and returns
a pointer to a block of store holding a compiled version of the expression.

Arguments:
  pattern       the regular expression
  patlen        the length of the pattern, or PCRE2_ZERO_TERMINATED
  options       option bits
  errorptr      pointer to errorcode
  erroroffset   pointer to error offset
  ccontext      points to a compile context or is NULL

Returns:        pointer to compiled data block, or NULL on error,
                with errorcode and erroroffset set
*/

PCRE2_EXP_DEFN pcre2_code * PCRE2_CALL_CONVENTION
pcre2_compile(PCRE2_SPTR pattern, PCRE2_SIZE patlen, uint32_t options,
   int *errorptr, PCRE2_SIZE *erroroffset, pcre2_compile_context *ccontext)
{
BOOL utf;                             /* Set TRUE for UTF mode */
BOOL ucp;                             /* Set TRUE for UCP mode */
BOOL has_lookbehind = FALSE;          /* Set TRUE if a lookbehind is found */
BOOL zero_terminated;                 /* Set TRUE for zero-terminated pattern */
pcre2_real_code *re = NULL;           /* What we will return */
compile_block cb;                     /* "Static" compile-time data */
const uint8_t *tables;                /* Char tables base pointer */

PCRE2_UCHAR *code;                    /* Current pointer in compiled code */
PCRE2_UCHAR * codestart;              /* Start of compiled code */
PCRE2_SPTR ptr;                       /* Current pointer in pattern */
uint32_t *pptr;                       /* Current pointer in parsed pattern */

PCRE2_SIZE length = 1;                /* Allow for final END opcode */
PCRE2_SIZE usedlength;                /* Actual length used */
PCRE2_SIZE re_blocksize;              /* Size of memory block */
PCRE2_SIZE parsed_size_needed;        /* Needed for parsed pattern */

uint32_t firstcuflags, reqcuflags;    /* Type of first/req code unit */
uint32_t firstcu, reqcu;              /* Value of first/req code unit */
uint32_t setflags = 0;                /* NL and BSR set flags */
uint32_t xoptions;                    /* Flags from context, modified */

uint32_t skipatstart;                 /* When checking (*UTF) etc */
uint32_t limit_heap  = UINT32_MAX;
uint32_t limit_match = UINT32_MAX;    /* Unset match limits */
uint32_t limit_depth = UINT32_MAX;

int newline = 0;                      /* Unset; can be set by the pattern */
int bsr = 0;                          /* Unset; can be set by the pattern */
int errorcode = 0;                    /* Initialize to avoid compiler warn */
int regexrc;                          /* Return from compile */

uint32_t i;                           /* Local loop counter */

/* Enable all optimizations by default. */
uint32_t optim_flags = ccontext != NULL ? ccontext->optimization_flags :
                                          PCRE2_OPTIMIZATION_ALL;

/* Comments at the head of this file explain about these variables. */

uint32_t stack_groupinfo[GROUPINFO_DEFAULT_SIZE];
uint32_t stack_parsed_pattern[PARSED_PATTERN_DEFAULT_SIZE];
named_group named_groups[NAMED_GROUP_LIST_SIZE];

/* The workspace is used in different ways in the different compiling phases.
It needs to be 16-bit aligned for the preliminary parsing scan. */

uint32_t c16workspace[C16_WORK_SIZE];
PCRE2_UCHAR *cworkspace = (PCRE2_UCHAR *)c16workspace;


/* -------------- Check arguments and set up the pattern ----------------- */

/* There must be error code and offset pointers. */

if (errorptr == NULL || erroroffset == NULL) return NULL;
*errorptr = ERR0;
*erroroffset = 0;

/* There must be a pattern, but NULL is allowed with zero length. */

if (pattern == NULL)
  {
  if (patlen == 0) pattern = (PCRE2_SPTR)""; else
    {
    *errorptr = ERR16;
    return NULL;
    }
  }

/* A NULL compile context means "use a default context" */

if (ccontext == NULL)
  ccontext = (pcre2_compile_context *)(&PRIV(default_compile_context));

/* PCRE2_MATCH_INVALID_UTF implies UTF */

if ((options & PCRE2_MATCH_INVALID_UTF) != 0) options |= PCRE2_UTF;

/* Check that all undefined public option bits are zero. */

if ((options & ~PUBLIC_COMPILE_OPTIONS) != 0 ||
    (ccontext->extra_options & ~PUBLIC_COMPILE_EXTRA_OPTIONS) != 0)
  {
  *errorptr = ERR17;
  return NULL;
  }

if ((options & PCRE2_LITERAL) != 0 &&
    ((options & ~PUBLIC_LITERAL_COMPILE_OPTIONS) != 0 ||
     (ccontext->extra_options & ~PUBLIC_LITERAL_COMPILE_EXTRA_OPTIONS) != 0))
  {
  *errorptr = ERR92;
  return NULL;
  }

/* A zero-terminated pattern is indicated by the special length value
PCRE2_ZERO_TERMINATED. Check for an overlong pattern. */

if ((zero_terminated = (patlen == PCRE2_ZERO_TERMINATED)))
  patlen = PRIV(strlen)(pattern);
(void)zero_terminated; /* Silence compiler; only used if Valgrind enabled */

if (patlen > ccontext->max_pattern_length)
  {
  *errorptr = ERR88;
  return NULL;
  }

/* Optimization flags in 'options' can override those in the compile context.
This is because some options to disable optimizations were added before the
optimization flags word existed, and we need to continue supporting them
for backwards compatibility. */

if ((options & PCRE2_NO_AUTO_POSSESS) != 0)
  optim_flags &= ~PCRE2_OPTIM_AUTO_POSSESS;
if ((options & PCRE2_NO_DOTSTAR_ANCHOR) != 0)
  optim_flags &= ~PCRE2_OPTIM_DOTSTAR_ANCHOR;
if ((options & PCRE2_NO_START_OPTIMIZE) != 0)
  optim_flags &= ~PCRE2_OPTIM_START_OPTIMIZE;

/* From here on, all returns from this function should end up going via the
EXIT label. */


/* ------------ Initialize the "static" compile data -------------- */

tables = (ccontext->tables != NULL)? ccontext->tables : PRIV(default_tables);

cb.lcc = tables + lcc_offset;          /* Individual */
cb.fcc = tables + fcc_offset;          /*   character */
cb.cbits = tables + cbits_offset;      /*      tables */
cb.ctypes = tables + ctypes_offset;

cb.assert_depth = 0;
cb.bracount = 0;
cb.cx = ccontext;
cb.dupnames = FALSE;
cb.end_pattern = pattern + patlen;
cb.erroroffset = 0;
cb.external_flags = 0;
cb.external_options = options;
cb.groupinfo = stack_groupinfo;
cb.had_recurse = FALSE;
cb.lastcapture = 0;
cb.max_lookbehind = 0;                               /* Max encountered */
cb.max_varlookbehind = ccontext->max_varlookbehind;  /* Limit */
cb.name_entry_size = 0;
cb.name_table = NULL;
cb.named_groups = named_groups;
cb.named_group_list_size = NAMED_GROUP_LIST_SIZE;
cb.names_found = 0;
cb.parens_depth = 0;
cb.parsed_pattern = stack_parsed_pattern;
cb.req_varyopt = 0;
cb.start_code = cworkspace;
cb.start_pattern = pattern;
cb.start_workspace = cworkspace;
cb.workspace_size = COMPILE_WORK_SIZE;
#ifdef SUPPORT_WIDE_CHARS
cb.cranges = NULL;
cb.next_cranges = NULL;
cb.char_lists_size = 0;
#endif

/* Maximum back reference and backref bitmap. The bitmap records up to 31 back
references to help in deciding whether (.*) can be treated as anchored or not.
*/

cb.top_backref = 0;
cb.backref_map = 0;

/* Escape sequences \1 to \9 are always back references, but as they are only
two characters long, only two elements can be used in the parsed_pattern
vector. The first contains the reference, and we'd like to use the second to
record the offset in the pattern, so that forward references to non-existent
groups can be diagnosed later with an offset. However, on 64-bit systems,
PCRE2_SIZE won't fit. Instead, we have a vector of offsets for the first
occurrence of \1 to \9, indexed by the second parsed_pattern value. All other
references have enough space for the offset to be put into the parsed pattern.
*/

for (i = 0; i < 10; i++) cb.small_ref_offset[i] = PCRE2_UNSET;


/* --------------- Start looking at the pattern --------------- */

/* Unless PCRE2_LITERAL is set, check for global one-time option settings at
the start of the pattern, and remember the offset to the actual regex. With
valgrind support, make the terminator of a zero-terminated pattern
inaccessible. This catches bugs that would otherwise only show up for
non-zero-terminated patterns. */

#ifdef SUPPORT_VALGRIND
if (zero_terminated) VALGRIND_MAKE_MEM_NOACCESS(pattern + patlen, CU2BYTES(1));
#endif

xoptions = ccontext->extra_options;
ptr = pattern;
skipatstart = 0;

if ((options & PCRE2_LITERAL) == 0)
  {
  while (patlen - skipatstart >= 2 &&
         ptr[skipatstart] == CHAR_LEFT_PARENTHESIS &&
         ptr[skipatstart+1] == CHAR_ASTERISK)
    {
    for (i = 0; i < sizeof(pso_list)/sizeof(pso); i++)
      {
      const pso *p = pso_list + i;

      if (patlen - skipatstart - 2 >= p->length &&
          PRIV(strncmp_c8)(ptr + skipatstart + 2, p->name, p->length) == 0)
        {
        uint32_t c, pp;

        skipatstart += p->length + 2;
        switch(p->type)
          {
          case PSO_OPT:
          cb.external_options |= p->value;
          break;

          case PSO_XOPT:
          xoptions |= p->value;
          break;

          case PSO_FLG:
          setflags |= p->value;
          break;

          case PSO_NL:
          newline = p->value;
          setflags |= PCRE2_NL_SET;
          break;

          case PSO_BSR:
          bsr = p->value;
          setflags |= PCRE2_BSR_SET;
          break;

          case PSO_LIMM:
          case PSO_LIMD:
          case PSO_LIMH:
          c = 0;
          pp = skipatstart;
          while (pp < patlen && IS_DIGIT(ptr[pp]))
            {
            if (c > UINT32_MAX / 10 - 1) break;   /* Integer overflow */
            c = c*10 + (ptr[pp++] - CHAR_0);
            }
          if (pp >= patlen || pp == skipatstart || ptr[pp] != CHAR_RIGHT_PARENTHESIS)
            {
            errorcode = ERR60;
            ptr += pp;
            goto HAD_EARLY_ERROR;
            }
          if (p->type == PSO_LIMH) limit_heap = c;
            else if (p->type == PSO_LIMM) limit_match = c;
            else limit_depth = c;
          skipatstart = ++pp;
          break;

          case PSO_OPTMZ:
          optim_flags &= ~(p->value);

          /* For backward compatibility the three original VERBs to disable
          optimizations need to also update the corresponding bit in the
          external options. */

          switch(p->value)
            {
            case PCRE2_OPTIM_AUTO_POSSESS:
            cb.external_options |= PCRE2_NO_AUTO_POSSESS;
            break;

            case PCRE2_OPTIM_DOTSTAR_ANCHOR:
            cb.external_options |= PCRE2_NO_DOTSTAR_ANCHOR;
            break;

            case PCRE2_OPTIM_START_OPTIMIZE:
            cb.external_options |= PCRE2_NO_START_OPTIMIZE;
            break;
            }

          break;

          default:
          /* All values in the enum need an explicit entry for this switch
          but until a better way to prevent coding mistakes is invented keep
          a catch all that triggers a debug build assert as a failsafe */
          PCRE2_DEBUG_UNREACHABLE();
          }
        break;   /* Out of the table scan loop */
        }
      }
    if (i >= sizeof(pso_list)/sizeof(pso)) break;   /* Out of pso loop */
    }
    PCRE2_ASSERT(skipatstart <= patlen);
  }

/* End of pattern-start options; advance to start of real regex. */

ptr += skipatstart;

/* Can't support UTF or UCP if PCRE2 was built without Unicode support. */

#ifndef SUPPORT_UNICODE
if ((cb.external_options & (PCRE2_UTF|PCRE2_UCP)) != 0)
  {
  errorcode = ERR32;
  goto HAD_EARLY_ERROR;
  }
#endif

/* Check UTF. We have the original options in 'options', with that value as
modified by (*UTF) etc in cb->external_options. The extra option
PCRE2_EXTRA_ALLOW_SURROGATE_ESCAPES is not permitted in UTF-16 mode because the
surrogate code points cannot be represented in UTF-16. */

utf = (cb.external_options & PCRE2_UTF) != 0;
if (utf)
  {
  if ((options & PCRE2_NEVER_UTF) != 0)
    {
    errorcode = ERR74;
    goto HAD_EARLY_ERROR;
    }
  if ((options & PCRE2_NO_UTF_CHECK) == 0 &&
       (errorcode = PRIV(valid_utf)(pattern, patlen, erroroffset)) != 0)
    goto HAD_ERROR;  /* Offset was set by valid_utf() */

#if PCRE2_CODE_UNIT_WIDTH == 16
  if ((ccontext->extra_options & PCRE2_EXTRA_ALLOW_SURROGATE_ESCAPES) != 0)
    {
    errorcode = ERR91;
    goto HAD_EARLY_ERROR;
    }
#endif
  }

/* Check UCP lockout. */

ucp = (cb.external_options & PCRE2_UCP) != 0;
if (ucp && (cb.external_options & PCRE2_NEVER_UCP) != 0)
  {
  errorcode = ERR75;
  goto HAD_EARLY_ERROR;
  }

/* PCRE2_EXTRA_TURKISH_CASING checks */

if ((xoptions & PCRE2_EXTRA_TURKISH_CASING) != 0)
  {
  if (!utf && !ucp)
    {
    errorcode = ERR104;
    goto HAD_EARLY_ERROR;
    }

#if PCRE2_CODE_UNIT_WIDTH == 8
  if (!utf)
    {
    errorcode = ERR105;
    goto HAD_EARLY_ERROR;
    }
#endif

  if ((xoptions & PCRE2_EXTRA_CASELESS_RESTRICT) != 0)
    {
    errorcode = ERR106;
    goto HAD_EARLY_ERROR;
    }
  }

/* Process the BSR setting. */

if (bsr == 0) bsr = ccontext->bsr_convention;

/* Process the newline setting. */

if (newline == 0) newline = ccontext->newline_convention;
cb.nltype = NLTYPE_FIXED;
switch(newline)
  {
  case PCRE2_NEWLINE_CR:
  cb.nllen = 1;
  cb.nl[0] = CHAR_CR;
  break;

  case PCRE2_NEWLINE_LF:
  cb.nllen = 1;
  cb.nl[0] = CHAR_NL;
  break;

  case PCRE2_NEWLINE_NUL:
  cb.nllen = 1;
  cb.nl[0] = CHAR_NUL;
  break;

  case PCRE2_NEWLINE_CRLF:
  cb.nllen = 2;
  cb.nl[0] = CHAR_CR;
  cb.nl[1] = CHAR_NL;
  break;

  case PCRE2_NEWLINE_ANY:
  cb.nltype = NLTYPE_ANY;
  break;

  case PCRE2_NEWLINE_ANYCRLF:
  cb.nltype = NLTYPE_ANYCRLF;
  break;

  default:
  PCRE2_DEBUG_UNREACHABLE();
  errorcode = ERR56;
  goto HAD_EARLY_ERROR;
  }

/* Pre-scan the pattern to do two things: (1) Discover the named groups and
their numerical equivalents, so that this information is always available for
the remaining processing. (2) At the same time, parse the pattern and put a
processed version into the parsed_pattern vector. This has escapes interpreted
and comments removed (amongst other things). */

/* Ensure that the parsed pattern buffer is big enough. For many smaller
patterns the vector on the stack (which was set up above) can be used. */

parsed_size_needed = max_parsed_pattern(ptr, cb.end_pattern, utf, options);

/* Allow for 2x uint32_t at the start and 2 at the end, for
PCRE2_EXTRA_MATCH_WORD or PCRE2_EXTRA_MATCH_LINE (which are exclusive). */

if ((ccontext->extra_options &
     (PCRE2_EXTRA_MATCH_WORD|PCRE2_EXTRA_MATCH_LINE)) != 0)
  parsed_size_needed += 4;

/* When PCRE2_AUTO_CALLOUT is set we allow for one callout at the end. */

if ((options & PCRE2_AUTO_CALLOUT) != 0)
  parsed_size_needed += 4;

parsed_size_needed += 1;  /* For the final META_END */

if (parsed_size_needed > PARSED_PATTERN_DEFAULT_SIZE)
  {
  uint32_t *heap_parsed_pattern = ccontext->memctl.malloc(
    parsed_size_needed * sizeof(uint32_t), ccontext->memctl.memory_data);
  if (heap_parsed_pattern == NULL)
    {
    *errorptr = ERR21;
    goto EXIT;
    }
  cb.parsed_pattern = heap_parsed_pattern;
  }
cb.parsed_pattern_end = cb.parsed_pattern + parsed_size_needed;

/* Do the parsing scan. */

errorcode = parse_regex(ptr, cb.external_options, xoptions, &has_lookbehind, &cb);
if (errorcode != 0) goto HAD_CB_ERROR;

/* If there are any lookbehinds, scan the parsed pattern to figure out their
lengths. Workspace is needed to remember whether numbered groups are or are not
of limited length, and if limited, what the minimum and maximum lengths are.
This caching saves re-computing the length of any group that is referenced more
than once, which is particularly relevant when recursion is involved.
Unnumbered groups do not have this exposure because they cannot be referenced.
If there are sufficiently few groups, the default index vector on the stack, as
set up above, can be used. Otherwise we have to get/free some heap memory. The
vector must be initialized to zero. */

if (has_lookbehind)
  {
  int loopcount = 0;
  if (cb.bracount >= GROUPINFO_DEFAULT_SIZE/2)
    {
    cb.groupinfo = ccontext->memctl.malloc(
      (2 * (cb.bracount + 1))*sizeof(uint32_t), ccontext->memctl.memory_data);
    if (cb.groupinfo == NULL)
      {
      errorcode = ERR21;
      cb.erroroffset = 0;
      goto HAD_CB_ERROR;
      }
    }
  memset(cb.groupinfo, 0, (2 * cb.bracount + 1) * sizeof(uint32_t));
  errorcode = check_lookbehinds(cb.parsed_pattern, NULL, NULL, &cb, &loopcount);
  if (errorcode != 0) goto HAD_CB_ERROR;
  }

/* For debugging, there is a function that shows the parsed pattern vector. */

#ifdef DEBUG_SHOW_PARSED
fprintf(stderr, "+++ Pre-scan complete:\n");
show_parsed(&cb);
#endif

/* For debugging capturing information this code can be enabled. */

#ifdef DEBUG_SHOW_CAPTURES
  {
  named_group *ng = cb.named_groups;
  fprintf(stderr, "+++Captures: %d\n", cb.bracount);
  for (i = 0; i < cb.names_found; i++, ng++)
    {
    fprintf(stderr, "+++%3d %.*s\n", ng->number, ng->length, ng->name);
    }
  }
#endif

/* Pretend to compile the pattern while actually just accumulating the amount
of memory required in the 'length' variable. This behaviour is triggered by
passing a non-NULL final argument to compile_regex(). We pass a block of
workspace (cworkspace) for it to compile parts of the pattern into; the
compiled code is discarded when it is no longer needed, so hopefully this
workspace will never overflow, though there is a test for its doing so.

On error, errorcode will be set non-zero, so we don't need to look at the
result of the function. The initial options have been put into the cb block,
but we still have to pass a separate options variable (the first argument)
because the options may change as the pattern is processed. */

cb.erroroffset = patlen;   /* For any subsequent errors that do not set it */
pptr = cb.parsed_pattern;
code = cworkspace;
*code = OP_BRA;

(void)compile_regex(cb.external_options, xoptions, &code, &pptr,
   &errorcode, 0, &firstcu, &firstcuflags, &reqcu, &reqcuflags, NULL, NULL,
   &cb, &length);

if (errorcode != 0) goto HAD_CB_ERROR;  /* Offset is in cb.erroroffset */

/* This should be caught in compile_regex(), but just in case... */

#if defined SUPPORT_WIDE_CHARS
PCRE2_ASSERT((cb.char_lists_size & 0x3) == 0);
if (length > MAX_PATTERN_SIZE ||
    MAX_PATTERN_SIZE - length < (cb.char_lists_size / sizeof(PCRE2_UCHAR)))
#else
if (length > MAX_PATTERN_SIZE)
#endif
  {
  errorcode = ERR20;
  goto HAD_CB_ERROR;
  }

/* Compute the size of, then, if not too large, get and initialize the data
block for storing the compiled pattern and names table. Integer overflow should
no longer be possible because nowadays we limit the maximum value of
cb.names_found and cb.name_entry_size. */

re_blocksize =
  CU2BYTES((PCRE2_SIZE)cb.names_found * (PCRE2_SIZE)cb.name_entry_size);

#if defined SUPPORT_WIDE_CHARS
if (cb.char_lists_size != 0)
  {
#if PCRE2_CODE_UNIT_WIDTH != 32
  /* Align to 32 bit first. This ensures the
  allocated area will also be 32 bit aligned. */
  re_blocksize = (PCRE2_SIZE)CLIST_ALIGN_TO(re_blocksize, sizeof(uint32_t));
#endif
  re_blocksize += cb.char_lists_size;
  }
#endif

re_blocksize += CU2BYTES(length);

if (re_blocksize > ccontext->max_pattern_compiled_length)
  {
  errorcode = ERR101;
  goto HAD_CB_ERROR;
  }

re_blocksize += sizeof(pcre2_real_code);
re = (pcre2_real_code *)
  ccontext->memctl.malloc(re_blocksize, ccontext->memctl.memory_data);
if (re == NULL)
  {
  errorcode = ERR21;
  goto HAD_CB_ERROR;
  }

/* The compiler may put padding at the end of the pcre2_real_code structure in
order to round it up to a multiple of 4 or 8 bytes. This means that when a
compiled pattern is copied (for example, when serialized) undefined bytes are
read, and this annoys debuggers such as valgrind. To avoid this, we explicitly
write to the last 8 bytes of the structure before setting the fields. */

memset((char *)re + sizeof(pcre2_real_code) - 8, 0, 8);
re->memctl = ccontext->memctl;
re->tables = tables;
re->executable_jit = NULL;
memset(re->start_bitmap, 0, 32 * sizeof(uint8_t));
re->blocksize = re_blocksize;
re->code_start = re_blocksize - CU2BYTES(length);
re->magic_number = MAGIC_NUMBER;
re->compile_options = options;
re->overall_options = cb.external_options;
re->extra_options = xoptions;
re->flags = PCRE2_CODE_UNIT_WIDTH/8 | cb.external_flags | setflags;
re->limit_heap = limit_heap;
re->limit_match = limit_match;
re->limit_depth = limit_depth;
re->first_codeunit = 0;
re->last_codeunit = 0;
re->bsr_convention = bsr;
re->newline_convention = newline;
re->max_lookbehind = 0;
re->minlength = 0;
re->top_bracket = 0;
re->top_backref = 0;
re->name_entry_size = cb.name_entry_size;
re->name_count = cb.names_found;
re->optimization_flags = optim_flags;

/* The basic block is immediately followed by the name table, and the compiled
code follows after that. */

codestart = (PCRE2_UCHAR *)((uint8_t *)re + re->code_start);

/* Update the compile data block for the actual compile. The starting points of
the name/number translation table and of the code are passed around in the
compile data block. The start/end pattern and initial options are already set
from the pre-compile phase, as is the name_entry_size field. */

cb.parens_depth = 0;
cb.assert_depth = 0;
cb.lastcapture = 0;
cb.name_table = (PCRE2_UCHAR *)((uint8_t *)re + sizeof(pcre2_real_code));
cb.start_code = codestart;
cb.req_varyopt = 0;
cb.had_accept = FALSE;
cb.had_pruneorskip = FALSE;
#ifdef SUPPORT_WIDE_CHARS
cb.char_lists_size = 0;
#endif


/* If any named groups were found, create the name/number table from the list
created in the pre-pass. */

if (cb.names_found > 0)
  {
  named_group *ng = cb.named_groups;
  for (i = 0; i < cb.names_found; i++, ng++)
    add_name_to_table(&cb, ng->name, ng->length, ng->number, i);
  }

/* Set up a starting, non-extracting bracket, then compile the expression. On
error, errorcode will be set non-zero, so we don't need to look at the result
of the function here. */

pptr = cb.parsed_pattern;
code = (PCRE2_UCHAR *)codestart;
*code = OP_BRA;
regexrc = compile_regex(re->overall_options, re->extra_options, &code,
  &pptr, &errorcode, 0, &firstcu, &firstcuflags, &reqcu, &reqcuflags, NULL,
  NULL, &cb, NULL);
if (regexrc < 0) re->flags |= PCRE2_MATCH_EMPTY;
re->top_bracket = cb.bracount;
re->top_backref = cb.top_backref;
re->max_lookbehind = cb.max_lookbehind;

if (cb.had_accept)
  {
  reqcu = 0;                     /* Must disable after (*ACCEPT) */
  reqcuflags = REQ_NONE;
  re->flags |= PCRE2_HASACCEPT;  /* Disables minimum length */
  }

/* Fill in the final opcode and check for disastrous overflow. If no overflow,
but the estimated length exceeds the really used length, adjust the value of
re->blocksize, and if valgrind support is configured, mark the extra allocated
memory as unaddressable, so that any out-of-bound reads can be detected. */

*code++ = OP_END;
usedlength = code - codestart;
if (usedlength > length)
  {
  PCRE2_DEBUG_UNREACHABLE();
  errorcode = ERR23;  /* Overflow of code block - internal error */
  }
else
  {
  re->blocksize -= CU2BYTES(length - usedlength);
#ifdef SUPPORT_VALGRIND
  VALGRIND_MAKE_MEM_NOACCESS(code, CU2BYTES(length - usedlength));
#endif
  }

/* Scan the pattern for recursion/subroutine calls and convert the group
numbers into offsets. Maintain a small cache so that repeated groups containing
recursions are efficiently handled. */

#define RSCAN_CACHE_SIZE 8

if (errorcode == 0 && cb.had_recurse)
  {
  PCRE2_UCHAR *rcode;
  PCRE2_SPTR rgroup;
  unsigned int ccount = 0;
  int start = RSCAN_CACHE_SIZE;
  recurse_cache rc[RSCAN_CACHE_SIZE];

  for (rcode = find_recurse(codestart, utf);
       rcode != NULL;
       rcode = find_recurse(rcode + 1 + LINK_SIZE, utf))
    {
    int p, groupnumber;

    groupnumber = (int)GET(rcode, 1);
    if (groupnumber == 0) rgroup = codestart; else
      {
      PCRE2_SPTR search_from = codestart;
      rgroup = NULL;
      for (i = 0, p = start; i < ccount; i++, p = (p + 1) & 7)
        {
        if (groupnumber == rc[p].groupnumber)
          {
          rgroup = rc[p].group;
          break;
          }

        /* Group n+1 must always start to the right of group n, so we can save
        search time below when the new group number is greater than any of the
        previously found groups. */

        if (groupnumber > rc[p].groupnumber) search_from = rc[p].group;
        }

      if (rgroup == NULL)
        {
        rgroup = PRIV(find_bracket)(search_from, utf, groupnumber);
        if (rgroup == NULL)
          {
          PCRE2_DEBUG_UNREACHABLE();
          errorcode = ERR53;
          break;
          }
        if (--start < 0) start = RSCAN_CACHE_SIZE - 1;
        rc[start].groupnumber = groupnumber;
        rc[start].group = rgroup;
        if (ccount < RSCAN_CACHE_SIZE) ccount++;
        }
      }

    PUT(rcode, 1, (uint32_t)(rgroup - codestart));
    }
  }

/* In rare debugging situations we sometimes need to look at the compiled code
at this stage. */

#ifdef DEBUG_CALL_PRINTINT
pcre2_printint(re, stderr, TRUE);
fprintf(stderr, "Length=%lu Used=%lu\n", length, usedlength);
#endif

/* Unless disabled, check whether any single character iterators can be
auto-possessified. The function overwrites the appropriate opcode values, so
the type of the pointer must be cast. NOTE: the intermediate variable "temp" is
used in this code because at least one compiler gives a warning about loss of
"const" attribute if the cast (PCRE2_UCHAR *)codestart is used directly in the
function call. */

if (errorcode == 0 && (optim_flags & PCRE2_OPTIM_AUTO_POSSESS) != 0)
  {
  PCRE2_UCHAR *temp = (PCRE2_UCHAR *)codestart;
  if (PRIV(auto_possessify)(temp, &cb) != 0)
    {
    PCRE2_DEBUG_UNREACHABLE();
    errorcode = ERR80;
    }
  }

/* Failed to compile, or error while post-processing. */

if (errorcode != 0) goto HAD_CB_ERROR;

/* Successful compile. If the anchored option was not passed, set it if
we can determine that the pattern is anchored by virtue of ^ characters or \A
or anything else, such as starting with non-atomic .* when DOTALL is set and
there are no occurrences of *PRUNE or *SKIP (though there is an option to
disable this case). */

if ((re->overall_options & PCRE2_ANCHORED) == 0)
  {
  BOOL dotstar_anchor = ((optim_flags & PCRE2_OPTIM_DOTSTAR_ANCHOR) != 0);
  if (is_anchored(codestart, 0, &cb, 0, FALSE, dotstar_anchor))
    re->overall_options |= PCRE2_ANCHORED;
  }

/* Set up the first code unit or startline flag, the required code unit, and
then study the pattern. This code need not be obeyed if PCRE2_OPTIM_START_OPTIMIZE
is disabled, as the data it would create will not be used. Note that a first code
unit (but not the startline flag) is useful for anchored patterns because it
can still give a quick "no match" and also avoid searching for a last code
unit. */

if ((optim_flags & PCRE2_OPTIM_START_OPTIMIZE) != 0)
  {
  int minminlength = 0;  /* For minimal minlength from first/required CU */

  /* If we do not have a first code unit, see if there is one that is asserted
  (these are not saved during the compile because they can cause conflicts with
  actual literals that follow). */

  if (firstcuflags >= REQ_NONE) {
    uint32_t assertedcuflags = 0;
    uint32_t assertedcu = find_firstassertedcu(codestart, &assertedcuflags, 0);
    /* It would be wrong to use the asserted first code unit as `firstcu` for
     * regexes which are able to match a 1-character string (e.g. /(?=a)b?a/)
     * For that example, if we set both firstcu and reqcu to 'a', it would mean
     * the subject string needs to be at least 2 characters long, which is wrong.
     * With more analysis, we would be able to set firstcu in more cases. */
    if (assertedcuflags < REQ_NONE && assertedcu != reqcu) {
      firstcu = assertedcu;
      firstcuflags = assertedcuflags;
    }
  }

  /* Save the data for a first code unit. The existence of one means the
  minimum length must be at least 1. */

  if (firstcuflags < REQ_NONE)
    {
    re->first_codeunit = firstcu;
    re->flags |= PCRE2_FIRSTSET;
    minminlength++;

    /* Handle caseless first code units. */

    if ((firstcuflags & REQ_CASELESS) != 0)
      {
      if (firstcu < 128 || (!utf && !ucp && firstcu < 255))
        {
        if (cb.fcc[firstcu] != firstcu) re->flags |= PCRE2_FIRSTCASELESS;
        }

      /* The first code unit is > 128 in UTF or UCP mode, or > 255 otherwise.
      In 8-bit UTF mode, code units in the range 128-255 are introductory code
      units and cannot have another case, but if UCP is set they may do. */

#ifdef SUPPORT_UNICODE
#if PCRE2_CODE_UNIT_WIDTH == 8
      else if (ucp && !utf && UCD_OTHERCASE(firstcu) != firstcu)
        re->flags |= PCRE2_FIRSTCASELESS;
#else
      else if ((utf || ucp) && firstcu <= MAX_UTF_CODE_POINT &&
               UCD_OTHERCASE(firstcu) != firstcu)
        re->flags |= PCRE2_FIRSTCASELESS;
#endif
#endif  /* SUPPORT_UNICODE */
      }
    }

  /* When there is no first code unit, for non-anchored patterns, see if we can
  set the PCRE2_STARTLINE flag. This is helpful for multiline matches when all
  branches start with ^ and also when all branches start with non-atomic .* for
  non-DOTALL matches when *PRUNE and SKIP are not present. (There is an option
  that disables this case.) */

  else if ((re->overall_options & PCRE2_ANCHORED) == 0)
    {
    BOOL dotstar_anchor = ((optim_flags & PCRE2_OPTIM_DOTSTAR_ANCHOR) != 0);
    if (is_startline(codestart, 0, &cb, 0, FALSE, dotstar_anchor))
      re->flags |= PCRE2_STARTLINE;
    }

  /* Handle the "required code unit", if one is set. In the UTF case we can
  increment the minimum minimum length only if we are sure this really is a
  different character and not a non-starting code unit of the first character,
  because the minimum length count is in characters, not code units. */

  if (reqcuflags < REQ_NONE)
    {
#if PCRE2_CODE_UNIT_WIDTH == 16
    if ((re->overall_options & PCRE2_UTF) == 0 ||   /* Not UTF */
        firstcuflags >= REQ_NONE ||                 /* First not set */
        (firstcu & 0xf800) != 0xd800 ||             /* First not surrogate */
        (reqcu & 0xfc00) != 0xdc00)                 /* Req not low surrogate */
#elif PCRE2_CODE_UNIT_WIDTH == 8
    if ((re->overall_options & PCRE2_UTF) == 0 ||   /* Not UTF */
        firstcuflags >= REQ_NONE ||                 /* First not set */
        (firstcu & 0x80) == 0 ||                    /* First is ASCII */
        (reqcu & 0x80) == 0)                        /* Req is ASCII */
#endif
      {
      minminlength++;
      }

    /* In the case of an anchored pattern, set up the value only if it follows
    a variable length item in the pattern. */

    if ((re->overall_options & PCRE2_ANCHORED) == 0 ||
        (reqcuflags & REQ_VARY) != 0)
      {
      re->last_codeunit = reqcu;
      re->flags |= PCRE2_LASTSET;

      /* Handle caseless required code units as for first code units (above). */

      if ((reqcuflags & REQ_CASELESS) != 0)
        {
        if (reqcu < 128 || (!utf && !ucp && reqcu < 255))
          {
          if (cb.fcc[reqcu] != reqcu) re->flags |= PCRE2_LASTCASELESS;
          }
#ifdef SUPPORT_UNICODE
#if PCRE2_CODE_UNIT_WIDTH == 8
      else if (ucp && !utf && UCD_OTHERCASE(reqcu) != reqcu)
        re->flags |= PCRE2_LASTCASELESS;
#else
      else if ((utf || ucp) && reqcu <= MAX_UTF_CODE_POINT &&
               UCD_OTHERCASE(reqcu) != reqcu)
        re->flags |= PCRE2_LASTCASELESS;
#endif
#endif  /* SUPPORT_UNICODE */
        }
      }
    }

  /* Study the compiled pattern to set up information such as a bitmap of
  starting code units and a minimum matching length. */

  if (PRIV(study)(re) != 0)
    {
    PCRE2_DEBUG_UNREACHABLE();
    errorcode = ERR31;
    goto HAD_CB_ERROR;
    }

  /* If study() set a bitmap of starting code units, it implies a minimum
  length of at least one. */

  if ((re->flags & PCRE2_FIRSTMAPSET) != 0 && minminlength == 0)
    minminlength = 1;

  /* If the minimum length set (or not set) by study() is less than the minimum
  implied by required code units, override it. */

  if (re->minlength < minminlength) re->minlength = minminlength;
  }   /* End of start-of-match optimizations. */

/* Control ends up here in all cases. When running under valgrind, make a
pattern's terminating zero defined again. If memory was obtained for the parsed
version of the pattern, free it before returning. Also free the list of named
groups if a larger one had to be obtained, and likewise the group information
vector. */

#ifdef SUPPORT_UNICODE
PCRE2_ASSERT(cb.cranges == NULL);
#endif

EXIT:
#ifdef SUPPORT_VALGRIND
if (zero_terminated) VALGRIND_MAKE_MEM_DEFINED(pattern + patlen, CU2BYTES(1));
#endif
if (cb.parsed_pattern != stack_parsed_pattern)
  ccontext->memctl.free(cb.parsed_pattern, ccontext->memctl.memory_data);
if (cb.named_group_list_size > NAMED_GROUP_LIST_SIZE)
  ccontext->memctl.free((void *)cb.named_groups, ccontext->memctl.memory_data);
if (cb.groupinfo != stack_groupinfo)
  ccontext->memctl.free((void *)cb.groupinfo, ccontext->memctl.memory_data);

return re;    /* Will be NULL after an error */

/* Errors discovered in parse_regex() set the offset value in the compile
block. Errors discovered before it is called must compute it from the ptr
value. After parse_regex() is called, the offset in the compile block is set to
the end of the pattern, but certain errors in compile_regex() may reset it if
an offset is available in the parsed pattern. */

HAD_CB_ERROR:
ptr = pattern + cb.erroroffset;

HAD_EARLY_ERROR:
PCRE2_ASSERT(ptr >= pattern); /* Ensure we don't return invalid erroroffset */
PCRE2_ASSERT(ptr <= (pattern + patlen));
*erroroffset = ptr - pattern;

HAD_ERROR:
*errorptr = errorcode;
pcre2_code_free(re);
re = NULL;

#ifdef SUPPORT_WIDE_CHARS
if (cb.cranges != NULL)
  {
  class_ranges* cranges = cb.cranges;
  do
    {
    class_ranges* next_cranges = cranges->next;
    cb.cx->memctl.free(cranges, cb.cx->memctl.memory_data);
    cranges = next_cranges;
    }
  while (cranges != NULL);
  }
#endif
goto EXIT;
}

/* These #undefs are here to enable unity builds with CMake. */

#undef NLBLOCK /* Block containing newline information */
#undef PSSTART /* Field containing processed string start */
#undef PSEND   /* Field containing processed string end */

/* End of pcre2_compile.c */


================================================
FILE: Libraries/PCRE/pcre2_compile.h
================================================
/*************************************************
*      Perl-Compatible Regular Expressions       *
*************************************************/

/* PCRE2 is a library of functions to support regular expressions whose syntax
and semantics are as close as possible to those of the Perl 5 language.

                       Written by Philip Hazel
     Original API code Copyright (c) 1997-2012 University of Cambridge
          New API code Copyright (c) 2016-2024 University of Cambridge

-----------------------------------------------------------------------------
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

    * Redistributions of source code must retain the above copyright notice,
      this list of conditions and the following disclaimer.

    * Redistributions in binary form must reproduce the above copyright
      notice, this list of conditions and the following disclaimer in the
      documentation and/or other materials provided with the distribution.

    * Neither the name of the University of Cambridge nor the names of its
      contributors may be used to endorse or promote products derived from
      this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
-----------------------------------------------------------------------------
*/

#ifndef PCRE2_COMPILE_H_IDEMPOTENT_GUARD
#define PCRE2_COMPILE_H_IDEMPOTENT_GUARD

#include "pcre2_internal.h"

/* Compile time error code numbers. They are given names so that they can more
easily be tracked. When a new number is added, the tables called eint1 and
eint2 in pcre2posix.c may need to be updated, and a new error text must be
added to compile_error_texts in pcre2_error.c. Also, the error codes in
pcre2.h.in must be updated - their values are exactly 100 greater than these
values. */

enum { ERR0 = COMPILE_ERROR_BASE,
       ERR1,  ERR2,  ERR3,  ERR4,  ERR5,  ERR6,  ERR7,  ERR8,  ERR9,  ERR10,
       ERR11, ERR12, ERR13, ERR14, ERR15, ERR16, ERR17, ERR18, ERR19, ERR20,
       ERR21, ERR22, ERR23, ERR24, ERR25, ERR26, ERR27, ERR28, ERR29, ERR30,
       ERR31, ERR32, ERR33, ERR34, ERR35, ERR36, ERR37, ERR38, ERR39, ERR40,
       ERR41, ERR42, ERR43, ERR44, ERR45, ERR46, ERR47, ERR48, ERR49, ERR50,
       ERR51, ERR52, ERR53, ERR54, ERR55, ERR56, ERR57, ERR58, ERR59, ERR60,
       ERR61, ERR62, ERR63, ERR64, ERR65, ERR66, ERR67, ERR68, ERR69, ERR70,
       ERR71, ERR72, ERR73, ERR74, ERR75, ERR76, ERR77, ERR78, ERR79, ERR80,
       ERR81, ERR82, ERR83, ERR84, ERR85, ERR86, ERR87, ERR88, ERR89, ERR90,
       ERR91, ERR92, ERR93, ERR94, ERR95, ERR96, ERR97, ERR98, ERR99, ERR100,
       ERR101,ERR102,ERR103,ERR104,ERR105,ERR106,ERR107,ERR108,ERR109,ERR110,
       ERR111,ERR112,ERR113,ERR114,ERR115,ERR116 };

/* Code values for parsed patterns, which are stored in a vector of 32-bit
unsigned ints. Values less than META_END are literal data values. The coding
for identifying the item is in the top 16-bits, leaving 16 bits for the
additional data that some of them need. The META_CODE, META_DATA, and META_DIFF
macros are used to manipulate parsed pattern elements.

NOTE: When these definitions are changed, the table of extra lengths for each
code (meta_extra_lengths) must be updated to remain in step. */

#define META_END              0x80000000u  /* End of pattern */

#define META_ALT              0x80010000u  /* alternation */
#define META_ATOMIC           0x80020000u  /* atomic group */
#define META_BACKREF          0x80030000u  /* Back ref */
#define META_BACKREF_BYNAME   0x80040000u  /* \k'name' */
#define META_BIGVALUE         0x80050000u  /* Next is a literal > META_END */
#define META_CALLOUT_NUMBER   0x80060000u  /* (?C with numerical argument */
#define META_CALLOUT_STRING   0x80070000u  /* (?C with string argument */
#define META_CAPTURE          0x80080000u  /* Capturing parenthesis */
#define META_CIRCUMFLEX       0x80090000u  /* ^ metacharacter */
#define META_CLASS            0x800a0000u  /* start non-empty class */
#define META_CLASS_EMPTY      0x800b0000u  /* empty class */
#define META_CLASS_EMPTY_NOT  0x800c0000u  /* negative empty class */
#define META_CLASS_END        0x800d0000u  /* end of non-empty class */
#define META_CLASS_NOT        0x800e0000u  /* start non-empty negative class */
#define META_COND_ASSERT      0x800f0000u  /* (?(?assertion)... */
#define META_COND_DEFINE      0x80100000u  /* (?(DEFINE)... */
#define META_COND_NAME        0x80110000u  /* (?(<name>)... */
#define META_COND_NUMBER      0x80120000u  /* (?(digits)... */
#define META_COND_RNAME       0x80130000u  /* (?(R&name)... */
#define META_COND_RNUMBER     0x80140000u  /* (?(Rdigits)... */
#define META_COND_VERSION     0x80150000u  /* (?(VERSION<op>x.y)... */
#define META_OFFSET           0x80160000u  /* Setting offset for various
                                              META codes (e.g. META_SCS_NAME) */
#define META_SCS              0x80170000u  /* (*scan_substring:... */
#define META_SCS_NAME         0x80180000u  /* Next <name> of scan_substring */
#define META_SCS_NUMBER       0x80190000u  /* Next digits of scan_substring */
#define META_DOLLAR           0x801a0000u  /* $ metacharacter */
#define META_DOT              0x801b0000u  /* . metacharacter */
#define META_ESCAPE           0x801c0000u  /* \d and friends */
#define META_KET              0x801d0000u  /* closing parenthesis */
#define META_NOCAPTURE        0x801e0000u  /* no capture parens */
#define META_OPTIONS          0x801f0000u  /* (?i) and friends */
#define META_POSIX            0x80200000u  /* POSIX class item */
#define META_POSIX_NEG        0x80210000u  /* negative POSIX class item */
#define META_RANGE_ESCAPED    0x80220000u  /* range with at least one escape */
#define META_RANGE_LITERAL    0x80230000u  /* range defined literally */
#define META_RECURSE          0x80240000u  /* Recursion */
#define META_RECURSE_BYNAME   0x80250000u  /* (?&name) */
#define META_SCRIPT_RUN       0x80260000u  /* (*script_run:...) */

/* These must be kept together to make it easy to check that an assertion
is present where expected in a conditional group. */

#define META_LOOKAHEAD        0x80270000u  /* (?= */
#define META_LOOKAHEADNOT     0x80280000u  /* (?! */
#define META_LOOKBEHIND       0x80290000u  /* (?<= */
#define META_LOOKBEHINDNOT    0x802a0000u  /* (?<! */

/* These cannot be conditions */

#define META_LOOKAHEAD_NA     0x802b0000u  /* (*napla: */
#define META_LOOKBEHIND_NA    0x802c0000u  /* (*naplb: */

/* These must be kept in this order, with consecutive values, and the _ARG
versions of COMMIT, PRUNE, SKIP, and THEN immediately after their non-argument
versions. */

#define META_MARK             0x802d0000u  /* (*MARK) */
#define META_ACCEPT           0x802e0000u  /* (*ACCEPT) */
#define META_FAIL             0x802f0000u  /* (*FAIL) */
#define META_COMMIT           0x80300000u  /* These               */
#define META_COMMIT_ARG       0x80310000u  /*   pairs             */
#define META_PRUNE            0x80320000u  /*     must            */
#define META_PRUNE_ARG        0x80330000u  /*       be            */
#define META_SKIP             0x80340000u  /*         kept        */
#define META_SKIP_ARG         0x80350000u  /*           in        */
#define META_THEN             0x80360000u  /*             this    */
#define META_THEN_ARG         0x80370000u  /*               order */

/* These must be kept in groups of adjacent 3 values, and all together. */

#define META_ASTERISK         0x80380000u  /* *  */
#define META_ASTERISK_PLUS    0x80390000u  /* *+ */
#define META_ASTERISK_QUERY   0x803a0000u  /* *? */
#define META_PLUS             0x803b0000u  /* +  */
#define META_PLUS_PLUS        0x803c0000u  /* ++ */
#define META_PLUS_QUERY       0x803d0000u  /* +? */
#define META_QUERY            0x803e0000u  /* ?  */
#define META_QUERY_PLUS       0x803f0000u  /* ?+ */
#define META_QUERY_QUERY      0x80400000u  /* ?? */
#define META_MINMAX           0x80410000u  /* {n,m}  repeat */
#define META_MINMAX_PLUS      0x80420000u  /* {n,m}+ repeat */
#define META_MINMAX_QUERY     0x80430000u  /* {n,m}? repeat */

/* These meta codes must be kept in a group, with the OR/SUB/XOR in
this order, and AND/NOT at the start/end. */

#define META_ECLASS_AND       0x80440000u  /* && (or &) in a class */
#define META_ECLASS_OR        0x80450000u  /* || (or |, +) in a class */
#define META_ECLASS_SUB       0x80460000u  /* -- (or -) in a class */
#define META_ECLASS_XOR       0x80470000u  /* ~~ (or ^) in a class */
#define META_ECLASS_NOT       0x80480000u  /* ! in a class */

/* Convenience aliases. */

#define META_FIRST_QUANTIFIER META_ASTERISK
#define META_LAST_QUANTIFIER  META_MINMAX_QUERY

/* This is a special "meta code" that is used only to distinguish (*asr: from
(*sr: in the table of alphabetic assertions. It is never stored in the parsed
pattern because (*asr: is turned into (*sr:(*atomic: at that stage. There is
therefore no need for it to have a length entry, so use a high value. */

#define META_ATOMIC_SCRIPT_RUN 0x8fff0000u

/* Macros for manipulating elements of the parsed pattern vector. */

#define META_CODE(x)   (x & 0xffff0000u)
#define META_DATA(x)   (x & 0x0000ffffu)
#define META_DIFF(x,y) ((x-y)>>16)

/* Extended class management flags. */

#define CLASS_IS_ECLASS 0x1

/* Macro for the highest character value. */

#if PCRE2_CODE_UNIT_WIDTH == 8
#define MAX_UCHAR_VALUE 0xffu
#elif PCRE2_CODE_UNIT_WIDTH == 16
#define MAX_UCHAR_VALUE 0xffffu
#else
#define MAX_UCHAR_VALUE 0xffffffffu
#endif

#define GET_MAX_CHAR_VALUE(utf) \
  ((utf) ? MAX_UTF_CODE_POINT : MAX_UCHAR_VALUE)

/* Macro for setting individual bits in class bitmaps. */

#define SETBIT(a,b) a[(b) >> 3] |= (uint8_t)(1u << ((b) & 0x7))

/* Macro for 8 bit specific checks. */
#if PCRE2_CODE_UNIT_WIDTH == 8
#define SELECT_VALUE8(value8, value) (value8)
#else
#define SELECT_VALUE8(value8, value) (value)
#endif

/* Macro for aligning data. */
#define CLIST_ALIGN_TO(base, align) \
  ((base + ((size_t)(align) - 1)) & ~((size_t)(align) - 1))

/* Structure for holding information about an OP_ECLASS internal operand.
An "operand" here could be just a single OP_[X]CLASS, or it could be some
complex expression; but it's some sequence of ECL_* codes which pushes one
value to the stack. */
typedef struct {
  /* The position of the operand - or NULL if (lengthptr != NULL). */
  PCRE2_UCHAR *code_start;
  PCRE2_SIZE length;
  /* The operand's type if it is a single code (ECL_XCLASS, ECL_ANY, ECL_NONE);
  otherwise zero if the operand is not atomic. */
  uint8_t op_single_type;
  /* Regardless of whether it's a single code or not, we fully constant-fold
  the bitmap for code points < 256. */
  class_bits_storage bits;
} eclass_op_info;

/* Macros for the definitions below, to prevent name collisions. */

#define _pcre2_posix_class_maps          PCRE2_SUFFIX(_pcre2_posix_class_maps)
#define _pcre2_update_classbits          PCRE2_SUFFIX(_pcre2_update_classbits_)
#define _pcre2_compile_class_nested      PCRE2_SUFFIX(_pcre2_compile_class_nested_)
#define _pcre2_compile_class_not_nested  PCRE2_SUFFIX(_pcre2_compile_class_not_nested_)


/* Indices of the POSIX classes in posix_names, posix_name_lengths,
posix_class_maps, and posix_substitutes. They must be kept in sync. */

#define PC_DIGIT   7
#define PC_GRAPH   8
#define PC_PRINT   9
#define PC_PUNCT  10
#define PC_XDIGIT 13

extern const int PRIV(posix_class_maps)[];


/* Set bits in classbits according to the property type */

void PRIV(update_classbits)(uint32_t ptype, uint32_t pdata, BOOL negated,
  uint8_t *classbits);

/* Compile the META codes from start_ptr...end_ptr, writing a single OP_CLASS
OP_CLASS, OP_NCLASS, OP_XCLASS, or OP_ALLANY into pcode. */

uint32_t *PRIV(compile_class_not_nested)(uint32_t options, uint32_t xoptions,
  uint32_t *start_ptr, PCRE2_UCHAR **pcode, BOOL negate_class, BOOL* has_bitmap,
  int *errorcodeptr, compile_block *cb, PCRE2_SIZE *lengthptr);

/* Compile the META codes in pptr into opcodes written to pcode. The pptr must
start at a META_CLASS or META_CLASS_NOT.

The pptr will be left pointing at the matching META_CLASS_END. */

BOOL PRIV(compile_class_nested)(uint32_t options, uint32_t xoptions,
  uint32_t **pptr, PCRE2_UCHAR **pcode, int *errorcodeptr,
  compile_block *cb, PCRE2_SIZE *lengthptr);

#endif  /* PCRE2_COMPILE_H_IDEMPOTENT_GUARD */

/* End of pcre2_compile.h */


================================================
FILE: Libraries/PCRE/pcre2_compile_class.c
================================================
/*************************************************
*      Perl-Compatible Regular Expressions       *
*************************************************/

/* PCRE is a library of functions to support regular expressions whose syntax
and semantics are as close as possible to those of the Perl 5 language.

                       Written by Philip Hazel
     Original API code Copyright (c) 1997-2012 University of Cambridge
          New API code Copyright (c) 2016-2024 University of Cambridge

-----------------------------------------------------------------------------
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

    * Redistributions of source code must retain the above copyright notice,
      this list of conditions and the following disclaimer.

    * Redistributions in binary form must reproduce the above copyright
      notice, this list of conditions and the following disclaimer in the
      documentation and/or other materials provided with the distribution.

    * Neither the name of the University of Cambridge nor the names of its
      contributors may be used to endorse or promote products derived from
      this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
-----------------------------------------------------------------------------
*/

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include "pcre2_compile.h"

typedef struct {
  /* Option bits for eclass. */
  uint32_t options;
  uint32_t xoptions;
  /* Rarely used members. */
  int *errorcodeptr;
  compile_block *cb;
  /* Bitmap is needed. */
  BOOL needs_bitmap;
} eclass_context;

/* Checks the allowed tokens at the end of a class structure in debug mode.
When a new token is not processed by all loops, and the token is equals to
a) one of the cases here:
   the compiler will complain about a duplicated case value.
b) none of the cases here:
   the loop without the handler will stop with an assertion failure. */

#ifdef PCRE2_DEBUG
#define CLASS_END_CASES(meta) \
  default: \
  PCRE2_ASSERT((meta) <= META_END); \
  /* Fall through */ \
  case META_CLASS: \
  case META_CLASS_NOT: \
  case META_CLASS_EMPTY: \
  case META_CLASS_EMPTY_NOT: \
  case META_CLASS_END: \
  case META_ECLASS_AND: \
  case META_ECLASS_OR: \
  case META_ECLASS_SUB: \
  case META_ECLASS_XOR: \
  case META_ECLASS_NOT:
#else
#define CLASS_END_CASES(meta) \
  default:
#endif

#ifdef SUPPORT_WIDE_CHARS

/* Heapsort algorithm. */

static void do_heapify(uint32_t *buffer, size_t size, size_t i)
{
size_t max;
size_t left;
size_t right;
uint32_t tmp1, tmp2;

while (TRUE)
  {
  max = i;
  left = (i << 1) + 2;
  right = left + 2;

  if (left < size && buffer[left] > buffer[max]) max = left;
  if (right < size && buffer[right] > buffer[max]) max = right;
  if (i == max) return;

  /* Swap items. */
  tmp1 = buffer[i];
  tmp2 = buffer[i + 1];
  buffer[i] = buffer[max];
  buffer[i + 1] = buffer[max + 1];
  buffer[max] = tmp1;
  buffer[max + 1] = tmp2;
  i = max;
  }
}

#ifdef SUPPORT_UNICODE

#define PARSE_CLASS_UTF               0x1
#define PARSE_CLASS_CASELESS_UTF      0x2
#define PARSE_CLASS_RESTRICTED_UTF    0x4
#define PARSE_CLASS_TURKISH_UTF       0x8

/* Get the range of nocase characters which includes the
'c' character passed as argument, or directly follows 'c'. */

static const uint32_t*
get_nocase_range(uint32_t c)
{
uint32_t left = 0;
uint32_t right = PRIV(ucd_nocase_ranges_size);
uint32_t middle;

if (c > MAX_UTF_CODE_POINT) return PRIV(ucd_nocase_ranges) + right;

while (TRUE)
  {
  /* Range end of the middle element. */
  middle = ((left + right) >> 1) | 0x1;

  if (PRIV(ucd_nocase_ranges)[middle] <= c)
    left = middle + 1;
  else if (middle > 1 && PRIV(ucd_nocase_ranges)[middle - 2] > c)
    right = middle - 1;
  else
    return PRIV(ucd_nocase_ranges) + (middle - 1);
  }
}

/* Get the list of othercase characters, which belongs to the passed range.
Create ranges from these characters, and append them to the buffer argument. */

static size_t
utf_caseless_extend(uint32_t start, uint32_t end, uint32_t options,
  uint32_t *buffer)
{
uint32_t new_start = start;
uint32_t new_end = end;
uint32_t c = start;
const uint32_t *list;
uint32_t tmp[3];
size_t result = 2;
const uint32_t *skip_range = get_nocase_range(c);
uint32_t skip_start = skip_range[0];

#if PCRE2_CODE_UNIT_WIDTH == 8
PCRE2_ASSERT(options & PARSE_CLASS_UTF);
#endif

#if PCRE2_CODE_UNIT_WIDTH == 32
if (end > MAX_UTF_CODE_POINT) end = MAX_UTF_CODE_POINT;
#endif

while (c <= end)
  {
  uint32_t co;

  if (c > skip_start)
    {
    c = skip_range[1];
    skip_range += 2;
    skip_start = skip_range[0];
    continue;
    }

  /* Compute caseless set. */

  if ((options & (PARSE_CLASS_TURKISH_UTF|PARSE_CLASS_RESTRICTED_UTF)) ==
        PARSE_CLASS_TURKISH_UTF &&
      UCD_ANY_I(c))
    {
    co = PRIV(ucd_turkish_dotted_i_caseset) + (UCD_DOTTED_I(c)? 0 : 3);
    }
  else if ((co = UCD_CASESET(c)) != 0 &&
           (options & PARSE_CLASS_RESTRICTED_UTF) != 0 &&
           PRIV(ucd_caseless_sets)[co] < 128)
    {
    co = 0;  /* Ignore the caseless set if it's restricted. */
    }

  if (co != 0)
    list = PRIV(ucd_caseless_sets) + co;
  else
    {
    co = UCD_OTHERCASE(c);
    list = tmp;
    tmp[0] = c;
    tmp[1] = NOTACHAR;

    if (co != c)
      {
      tmp[1] = co;
      tmp[2] = NOTACHAR;
      }
    }
  c++;

  /* Add characters. */
  do
    {
#if PCRE2_CODE_UNIT_WIDTH == 16
    if (!(options & PARSE_CLASS_UTF) && *list > 0xffff) continue;
#endif

    if (*list < new_start)
      {
      if (*list + 1 == new_start)
        {
        new_start--;
        continue;
        }
      }
    else if (*list > new_end)
      {
      if (*list - 1 == new_end)
        {
        new_end++;
        continue;
        }
      }
    else continue;

    result += 2;
    if (buffer != NULL)
      {
      buffer[0] = *list;
      buffer[1] = *list;
      buffer += 2;
      }
    }
  while (*(++list) != NOTACHAR);
  }

  if (buffer != NULL)
    {
    buffer[0] = new_start;
    buffer[1] = new_end;
    buffer += 2;
    (void)buffer;
    }
  return result;
}

#endif

/* Add a character list to a buffer. */

static size_t
append_char_list(const uint32_t *p, uint32_t *buffer)
{
const uint32_t *n;
size_t result = 0;

while (*p != NOTACHAR)
  {
  n = p;
  while (n[0] == n[1] - 1) n++;

  PCRE2_ASSERT(*p < 0xffff);

  if (buffer != NULL)
    {
    buffer[0] = *p;
    buffer[1] = *n;
    buffer += 2;
    }

  result += 2;
  p = n + 1;
  }

  return result;
}

static uint32_t
get_highest_char(uint32_t options)
{
(void)options; /* Avoid compiler warning. */

#if PCRE2_CODE_UNIT_WIDTH == 8
return MAX_UTF_CODE_POINT;
#else
#ifdef SUPPORT_UNICODE
return GET_MAX_CHAR_VALUE((options & PARSE_CLASS_UTF) != 0);
#else
return MAX_UCHAR_VALUE;
#endif
#endif
}

/* Add a negated character list to a buffer. */
static size_t
append_negated_char_list(const uint32_t *p, uint32_t options, uint32_t *buffer)
{
const uint32_t *n;
uint32_t start = 0;
size_t result = 2;

PCRE2_ASSERT(*p > 0);

while (*p != NOTACHAR)
  {
  n = p;
  while (n[0] == n[1] - 1) n++;

  PCRE2_ASSERT(*p < 0xffff);

  if (buffer != NULL)
    {
    buffer[0] = start;
    buffer[1] = *p - 1;
    buffer += 2;
    }

  result += 2;
  start = *n + 1;
  p = n + 1;
  }

  if (buffer != NULL)
    {
    buffer[0] = start;
    buffer[1] = get_highest_char(options);
    buffer += 2;
    (void)buffer;
    }

  return result;
}

static uint32_t *
append_non_ascii_range(uint32_t options, uint32_t *buffer)
{
  if (buffer == NULL) return NULL;

  buffer[0] = 0x100;
  buffer[1] = get_highest_char(options);
  return buffer + 2;
}

static size_t
parse_class(uint32_t *ptr, uint32_t options, uint32_t *buffer)
{
size_t total_size = 0;
size_t size;
uint32_t meta_arg;
uint32_t start_char;

while (TRUE)
  {
  switch (META_CODE(*ptr))
    {
    case META_ESCAPE:
      meta_arg = META_DATA(*ptr);
      switch (meta_arg)
        {
        case ESC_D:
        case ESC_W:
        case ESC_S:
        buffer = append_non_ascii_range(options, buffer);
        total_size += 2;
        break;

        case ESC_h:
        size = append_char_list(PRIV(hspace_list), buffer);
        total_size += size;
        if (buffer != NULL) buffer += size;
        break;

        case ESC_H:
        size = append_negated_char_list(PRIV(hspace_list), options, buffer);
        total_size += size;
        if (buffer != NULL) buffer += size;
        break;

        case ESC_v:
        size = append_char_list(PRIV(vspace_list), buffer);
        total_size += size;
        if (buffer != NULL) buffer += size;
        break;

        case ESC_V:
        size = append_negated_char_list(PRIV(vspace_list), options, buffer);
        total_size += size;
        if (buffer != NULL) buffer += size;
        break;

        case ESC_p:
        case ESC_P:
        ptr++;
        if (meta_arg == ESC_p && (*ptr >> 16) == PT_ANY)
          {
          if (buffer != NULL)
            {
            buffer[0] = 0;
            buffer[1] = get_highest_char(options);
            buffer += 2;
            }
          total_size += 2;
          }
        break;
        }
      ptr++;
      continue;
    case META_POSIX_NEG:
      buffer = append_non_ascii_range(options, buffer);
      total_size += 2;
      ptr += 2;
      continue;
    case META_POSIX:
      ptr += 2;
      continue;
    case META_BIGVALUE:
      /* Character literal */
      ptr++;
      break;
    CLASS_END_CASES(*ptr)
      if (*ptr >= META_END) return total_size;
      break;
    }

    start_char = *ptr;

    if (ptr[1] == META_RANGE_LITERAL || ptr[1] == META_RANGE_ESCAPED)
      {
      ptr += 2;
      PCRE2_ASSERT(*ptr < META_END || *ptr == META_BIGVALUE);

      if (*ptr == META_BIGVALUE) ptr++;

#ifdef EBCDIC
#error "Missing EBCDIC support"
#endif
      }

#ifdef SUPPORT_UNICODE
    if (options & PARSE_CLASS_CASELESS_UTF)
      {
      size = utf_caseless_extend(start_char, *ptr++, options, buffer);
      if (buffer != NULL) buffer += size;
      total_size += size;
      continue;
      }
#endif

    if (buffer != NULL)
      {
      buffer[0] = start_char;
      buffer[1] = *ptr;
      buffer += 2;
      }

    ptr++;
    total_size += 2;
  }

  return total_size;
}

/* Extra uint32_t values for storing the lengths of range lists in
the worst case. Two uint32_t lengths and a range end for a range
starting before 255 */
#define CHAR_LIST_EXTRA_SIZE 3

/* Starting character values for each character list. */

static const uint32_t char_list_starts[] = {
#if PCRE2_CODE_UNIT_WIDTH == 32
  XCL_CHAR_LIST_HIGH_32_START,
#endif
#if PCRE2_CODE_UNIT_WIDTH == 32 || defined SUPPORT_UNICODE
  XCL_CHAR_LIST_LOW_32_START,
#endif
  XCL_CHAR_LIST_HIGH_16_START,
  /* Must be terminated by XCL_CHAR_LIST_LOW_16_START,
  which also represents the end of the bitset. */
  XCL_CHAR_LIST_LOW_16_START,
};

static class_ranges *
compile_optimize_class(uint32_t *start_ptr, uint32_t options,
  uint32_t xoptions, compile_block *cb)
{
class_ranges* cranges;
uint32_t *ptr;
uint32_t *buffer;
uint32_t *dst;
uint32_t class_options = 0;
size_t range_list_size = 0, total_size, i;
uint32_t tmp1, tmp2;
const uint32_t *char_list_next;
uint16_t *next_char;
uint32_t char_list_start, char_list_end;
uint32_t range_start, range_end;

#ifdef SUPPORT_UNICODE
if (options & PCRE2_UTF)
  class_options |= PARSE_CLASS_UTF;

if ((options & PCRE2_CASELESS) && (options & (PCRE2_UTF|PCRE2_UCP)))
  class_options |= PARSE_CLASS_CASELESS_UTF;

if (xoptions & PCRE2_EXTRA_CASELESS_RESTRICT)
  class_options |= PARSE_CLASS_RESTRICTED_UTF;

if (xoptions & PCRE2_EXTRA_TURKISH_CASING)
  class_options |= PARSE_CLASS_TURKISH_UTF;
#endif

/* Compute required space for the range. */

range_list_size = parse_class(start_ptr, class_options, NULL);
PCRE2_ASSERT((range_list_size & 0x1) == 0);

/* Allocate buffer. The total_size also represents the end of the buffer. */

total_size = range_list_size +
   ((range_list_size >= 2) ? CHAR_LIST_EXTRA_SIZE : 0);

cranges = cb->cx->memctl.malloc(
  sizeof(class_ranges) + total_size * sizeof(uint32_t),
  cb->cx->memctl.memory_data);

if (cranges == NULL) return NULL;

cranges->next = NULL;
cranges->range_list_size = (uint16_t)range_list_size;
cranges->char_lists_types = 0;
cranges->char_lists_size = 0;
cranges->char_lists_start = 0;

if (range_list_size == 0) return cranges;

buffer = (uint32_t*)(cranges + 1);
parse_class(start_ptr, class_options, buffer);

/* Using <= instead of == to help static analysis. */
if (range_list_size <= 2) return cranges;

/* In-place sorting of ranges. */

i = (((range_list_size >> 2) - 1) << 1);
while (TRUE)
  {
  do_heapify(buffer, range_list_size, i);
  if (i == 0) break;
  i -= 2;
  }

i = range_list_size - 2;
while (TRUE)
  {
  tmp1 = buffer[i];
  tmp2 = buffer[i + 1];
  buffer[i] = buffer[0];
  buffer[i + 1] = buffer[1];
  buffer[0] = tmp1;
  buffer[1] = tmp2;

  do_heapify(buffer, i, 0);
  if (i == 0) break;
  i -= 2;
  }

/* Merge ranges whenever possible. */
dst = buffer;
ptr = buffer + 2;
range_list_size -= 2;

/* The second condition is a very rare corner case, where the end of the last
range is the maximum character. This range cannot be extended further. */

while (range_list_size > 0 && dst[1] != ~(uint32_t)0)
  {
  if (dst[1] + 1 < ptr[0])
    {
    dst += 2;
    dst[0] = ptr[0];
    dst[1] = ptr[1];
    }
  else if (dst[1] < ptr[1]) dst[1] = ptr[1];

  ptr += 2;
  range_list_size -= 2;
  }

PCRE2_ASSERT(dst[1] <= get_highest_char(class_options));

/* When the number of ranges are less than six,
they are not converted to range lists. */

ptr = buffer;
while (ptr < dst && ptr[1] < 0x100) ptr += 2;
if (dst - ptr < (2 * (6 - 1)))
  {
  cranges->range_list_size = (uint16_t)(dst + 2 - buffer);
  return cranges;
  }

/* Compute character lists structures. */

char_list_next = char_list_starts;
char_list_start = *char_list_next++;
#if PCRE2_CODE_UNIT_WIDTH == 32
char_list_end = XCL_CHAR_LIST_HIGH_32_END;
#elif defined SUPPORT_UNICODE
char_list_end = XCL_CHAR_LIST_LOW_32_END;
#else
char_list_end = XCL_CHAR_LIST_HIGH_16_END;
#endif
next_char = (uint16_t*)(buffer + total_size);

tmp1 = 0;
tmp2 = ((sizeof(char_list_starts) / sizeof(uint32_t)) - 1) * XCL_TYPE_BIT_LEN;
PCRE2_ASSERT(tmp2 <= 3 * XCL_TYPE_BIT_LEN && tmp2 >= XCL_TYPE_BIT_LEN);
range_start = dst[0];
range_end = dst[1];

while (TRUE)
  {
  if (range_start >= char_list_start)
    {
    if (range_start == range_end || range_end < char_list_end)
      {
      tmp1++;
      next_char--;

      if (char_list_start < XCL_CHAR_LIST_LOW_32_START)
        *next_char = (uint16_t)((range_end << XCL_CHAR_SHIFT) | XCL_CHAR_END);
      else
        *(uint32_t*)(--next_char) =
          (range_end << XCL_CHAR_SHIFT) | XCL_CHAR_END;
      }

    if (range_start < range_end)
      {
      if (range_start > char_list_start)
        {
        tmp1++;
        next_char--;

        if (char_list_start < XCL_CHAR_LIST_LOW_32_START)
          *next_char = (uint16_t)(range_start << XCL_CHAR_SHIFT);
        else
          *(uint32_t*)(--next_char) = (range_start << XCL_CHAR_SHIFT);
        }
      else
        cranges->char_lists_types |= XCL_BEGIN_WITH_RANGE << tmp2;
      }

    PCRE2_ASSERT((uint32_t*)next_char >= dst + 2);

    if (dst > buffer)
      {
      dst -= 2;
      range_start = dst[0];
      range_end = dst[1];
      continue;
      }

    range_start = 0;
    range_end = 0;
    }

  if (range_end >= char_list_start)
    {
    PCRE2_ASSERT(range_start < char_list_start);

    if (range_end < char_list_end)
      {
      tmp1++;
      next_char--;

      if (char_list_start < XCL_CHAR_LIST_LOW_32_START)
        *next_char = (uint16_t)((range_end << XCL_CHAR_SHIFT) | XCL_CHAR_END);
      else
        *(uint32_t*)(--next_char) =
          (range_end << XCL_CHAR_SHIFT) | XCL_CHAR_END;

      PCRE2_ASSERT((uint32_t*)next_char >= dst + 2);
      }

    cranges->char_lists_types |= XCL_BEGIN_WITH_RANGE << tmp2;
    }

  if (tmp1 >= XCL_ITEM_COUNT_MASK)
    {
    cranges->char_lists_types |= XCL_ITEM_COUNT_MASK << tmp2;
    next_char--;

    if (char_list_start < XCL_CHAR_LIST_LOW_32_START)
      *next_char = (uint16_t)tmp1;
    else
      *(uint32_t*)(--next_char) = tmp1;
    }
  else
    cranges->char_lists_types |= tmp1 << tmp2;

  if (range_start < XCL_CHAR_LIST_LOW_16_START) break;

  PCRE2_ASSERT(tmp2 >= XCL_TYPE_BIT_LEN);
  char_list_end = char_list_start - 1;
  char_list_start = *char_list_next++;
  tmp1 = 0;
  tmp2 -= XCL_TYPE_BIT_LEN;
  }

if (dst[0] < XCL_CHAR_LIST_LOW_16_START) dst += 2;
PCRE2_ASSERT((uint16_t*)dst <= next_char);

cranges->char_lists_size =
  (size_t)((uint8_t*)(buffer + total_size) - (uint8_t*)next_char);
cranges->char_lists_start = (size_t)((uint8_t*)next_char - (uint8_t*)buffer);
cranges->range_list_size = (uint16_t)(dst - buffer);
return cranges;
}

#endif /* SUPPORT_WIDE_CHARS */

#ifdef SUPPORT_UNICODE

void PRIV(update_classbits)(uint32_t ptype, uint32_t pdata, BOOL negated,
  uint8_t *classbits)
{
/* Update PRIV(xclass) when this function is changed. */
int c, chartype;
const ucd_record *prop;
uint32_t gentype;
BOOL set_bit;

if (ptype == PT_ANY)
  {
  if (!negated) memset(classbits, 0xff, 32);
  return;
  }

for (c = 0; c < 256; c++)
  {
  prop = GET_UCD(c);
  set_bit = FALSE;
  (void)set_bit;

  switch (ptype)
    {
    case PT_LAMP:
    chartype = prop->chartype;
    set_bit = (chartype == ucp_Lu || chartype == ucp_Ll || chartype == ucp_Lt);
    break;

    case PT_GC:
    set_bit = (PRIV(ucp_gentype)[prop->chartype] == pdata);
    break;

    case PT_PC:
    set_bit = (prop->chartype == pdata);
    break;

    case PT_SC:
    set_bit = (prop->script == pdata);
    break;

    case PT_SCX:
    set_bit = (prop->script == pdata ||
      MAPBIT(PRIV(ucd_script_sets) + UCD_SCRIPTX_PROP(prop), pdata) != 0);
    break;

    case PT_ALNUM:
    gentype = PRIV(ucp_gentype)[prop->chartype];
    set_bit = (gentype == ucp_L || gentype == ucp_N);
    break;

    case PT_SPACE:    /* Perl space */
    case PT_PXSPACE:  /* POSIX space */
    switch(c)
      {
      HSPACE_BYTE_CASES:
      VSPACE_BYTE_CASES:
      set_bit = TRUE;
      break;

      default:
      set_bit = (PRIV(ucp_gentype)[prop->chartype] == ucp_Z);
      break;
      }
    break;

    case PT_WORD:
    chartype = prop->chartype;
    gentype = PRIV(ucp_gentype)[chartype];
    set_bit = (gentype == ucp_L || gentype == ucp_N ||
               chartype == ucp_Mn || chartype == ucp_Pc);
    break;

    case PT_UCNC:
    set_bit = (c == CHAR_DOLLAR_SIGN || c == CHAR_COMMERCIAL_AT ||
               c == CHAR_GRAVE_ACCENT || c >= 0xa0);
    break;

    case PT_BIDICL:
    set_bit = (UCD_BIDICLASS_PROP(prop) == pdata);
    break;

    case PT_BOOL:
    set_bit = MAPBIT(PRIV(ucd_boolprop_sets) +
                     UCD_BPROPS_PROP(prop), pdata) != 0;
    break;

    case PT_PXGRAPH:
    chartype = prop->chartype;
    gentype = PRIV(ucp_gentype)[chartype];
    set_bit = (gentype != ucp_Z && (gentype != ucp_C || chartype == ucp_Cf));
    break;

    case PT_PXPRINT:
    chartype = prop->chartype;
    set_bit = (chartype != ucp_Zl && chartype != ucp_Zp &&
       (PRIV(ucp_gentype)[chartype] != ucp_C || chartype == ucp_Cf));
    break;

    case PT_PXPUNCT:
    gentype = PRIV(ucp_gentype)[prop->chartype];
    set_bit = (gentype == ucp_P || (c < 128 && gentype == ucp_S));
    break;

    default:
    PCRE2_ASSERT(ptype == PT_PXXDIGIT);
    set_bit = (c >= CHAR_0 && c <= CHAR_9) ||
              (c >= CHAR_A && c <= CHAR_F) ||
              (c >= CHAR_a && c <= CHAR_f);
    break;
    }

  if (negated) set_bit = !set_bit;
  if (set_bit) *classbits |= (uint8_t)(1 << (c & 0x7));
  if ((c & 0x7) == 0x7) classbits++;
  }
}

#endif /* SUPPORT_UNICODE */



#ifdef SUPPORT_WIDE_CHARS

/*************************************************
*           XClass related properties            *
*************************************************/

/* XClass needs to be generated. */
#define XCLASS_REQUIRED 0x1
/* XClass has 8 bit character. */
#define XCLASS_HAS_8BIT_CHARS 0x2
/* XClass has properties. */
#define XCLASS_HAS_PROPS 0x4
/* XClass has character lists. */
#define XCLASS_HAS_CHAR_LISTS 0x8
/* XClass matches to all >= 256 characters. */
#define XCLASS_HIGH_ANY 0x10

#endif


/*************************************************
*   Internal entry point for add range to class  *
*************************************************/

/* This function sets the overall range for characters < 256.
It also handles non-utf case folding.

Arguments:
  options       the options bits
  xoptions      the extra options bits
  cb            compile data
  start         start of range character
  end           end of range character

Returns:        cb->classbits is updated
*/

static void
add_to_class(uint32_t options, uint32_t xoptions, compile_block *cb,
  uint32_t start, uint32_t end)
{
uint8_t *classbits = cb->classbits.classbits;
uint32_t c, byte_start, byte_end;
uint32_t classbits_end = (end <= 0xff ? end : 0xff);

/* If caseless matching is required, scan the range and process alternate
cases. In Unicode, there are 8-bit characters that have alternate cases that
are greater than 255 and vice-versa (though these may be ignored if caseless
restriction is in force). Sometimes we can just extend the original range. */

if ((options & PCRE2_CASELESS) != 0)
  {
#ifdef SUPPORT_UNICODE
  /* UTF mode. This branch is taken if we don't support wide characters (e.g.
  8-bit library, without UTF), but we do treat those characters as Unicode
  (if UCP flag is set). In this case, we only need to expand the character class
  set to include the case pairs which are in the 0-255 codepoint range. */
  if ((options & (PCRE2_UTF|PCRE2_UCP)) != 0)
    {
      BOOL turkish_i = (xoptions & (PCRE2_EXTRA_TURKISH_CASING|PCRE2_EXTRA_CASELESS_RESTRICT)) ==
        PCRE2_EXTRA_TURKISH_CASING;
      if (start < 128)
        {
        uint32_t lo_end = (classbits_end < 127 ? classbits_end : 127);
        for (c = start; c <= lo_end; c++)
          {
          if (turkish_i && UCD_ANY_I(c)) continue;
          SETBIT(classbits, cb->fcc[c]);
          }
        }
      if (classbits_end >= 128)
        {
        uint32_t hi_start = (start > 128 ? start : 128);
        for (c = hi_start; c <= classbits_end; c++)
          {
          uint32_t co = UCD_OTHERCASE(c);
          if (co <= 0xff) SETBIT(classbits, co);
          }
        }
    }

  else
#endif  /* SUPPORT_UNICODE */

  /* Not UTF mode */
    {
    for (c = start; c <= classbits_end; c++)
      SETBIT(classbits, cb->fcc[c]);
    }
  }

/* Use the bitmap for characters < 256. Otherwise use extra data. */

byte_start = (start + 7) >> 3;
byte_end = (classbits_end + 1) >> 3;

if (byte_start >= byte_end)
  {
  for (c = start; c <= classbits_end; c++)
    /* Regardless of start, c will always be <= 255. */
    SETBIT(classbits, c);
  return;
  }

for (c = byte_start; c < byte_end; c++)
  classbits[c] = 0xff;

byte_start <<= 3;
byte_end <<= 3;

for (c = start; c < byte_start; c++)
  SETBIT(classbits, c);

for (c = byte_end; c <= classbits_end; c++)
  SETBIT(classbits, c);
}


#if PCRE2_CODE_UNIT_WIDTH == 8
/*************************************************
*   Internal entry point for add list to class   *
*************************************************/

/* This function is used for adding a list of horizontal or vertical whitespace
characters to a class. The list must be in order so that ranges of characters
can be detected and handled appropriately. This function sets the overall range
so that the internal functions can try to avoid duplication when handling
case-independence.

Arguments:
  options       the options bits
  xoptions      the extra options bits
  cb            contains pointers to tables etc.
  p             points to row of 32-bit values, terminated by NOTACHAR

Returns:        cb->classbits is updated
*/

static void
add_list_to_class(uint32_t options, uint32_t xoptions, compile_block *cb,
  const uint32_t *p)
{
while (p[0] < 256)
  {
  unsigned int n = 0;

  while(p[n+1] == p[0] + n + 1) n++;
  add_to_class(options, xoptions, cb, p[0], p[n]);

  p += n + 1;
  }
}



/*************************************************
*    Add characters not in a list to a class     *
*************************************************/

/* This function is used for adding the complement of a list of horizontal or
vertical whitespace to a class. The list must be in order.

Arguments:
  options       the options bits
  xoptions      the extra options bits
  cb            contains pointers to tables etc.
  p             points to row of 32-bit values, terminated by NOTACHAR

Returns:        cb->classbits is updated
*/

static void
add_not_list_to_class(uint32_t options, uint32_t xoptions, compile_block *cb,
  const uint32_t *p)
{
if (p[0] > 0)
  add_to_class(options, xoptions, cb, 0, p[0] - 1);
while (p[0] < 256)
  {
  while (p[1] == p[0] + 1) p++;
  add_to_class(options, xoptions, cb, p[0] + 1, (p[1] > 255) ? 255 : p[1] - 1);
  p++;
  }
}
#endif /* PCRE2_CODE_UNIT_WIDTH == 8 */



/*************************************************
*  Main entry-point to compile a character class *
*************************************************/

/* This function consumes a "leaf", which is a set of characters that will
become a single OP_CLASS OP_NCLASS, OP_XCLASS, or OP_ALLANY. */

uint32_t *
PRIV(compile_class_not_nested)(uint32_t options, uint32_t xoptions,
  uint32_t *start_ptr, PCRE2_UCHAR **pcode, BOOL negate_class, BOOL* has_bitmap,
  int *errorcodeptr, compile_block *cb, PCRE2_SIZE *lengthptr)
{
uint32_t *pptr = start_ptr;
PCRE2_UCHAR *code = *pcode;
BOOL should_flip_negation;
const uint8_t *cbits = cb->cbits;
/* Some functions such as add_to_class() or eclass processing
expects that the bitset is stored in cb->classbits.classbits. */
uint8_t *const classbits = cb->classbits.classbits;

#ifdef SUPPORT_UNICODE
BOOL utf = (options & PCRE2_UTF) != 0;
#else  /* No Unicode support */
BOOL utf = FALSE;
#endif

/* Helper variables for OP_XCLASS opcode (for characters > 255). */

#ifdef SUPPORT_WIDE_CHARS
uint32_t xclass_props;
PCRE2_UCHAR *class_uchardata;
class_ranges* cranges;
#endif

/* If an XClass contains a negative special such as \S, we need to flip the
negation flag at the end, so that support for characters > 255 works correctly
(they are all included in the class). An XClass may need to insert specific
matching or non-matching code for wide characters.
*/

should_flip_negation = FALSE;

/* XClass will be used when characters > 255 might match. */

#ifdef SUPPORT_WIDE_CHARS
xclass_props = 0;

#if PCRE2_CODE_UNIT_WIDTH == 8
cranges = NULL;

if (utf)
#endif
  {
  if (lengthptr != NULL)
    {
    cranges = compile_optimize_class(pptr, options, xoptions, cb);

    if (cranges == NULL)
      {
      *errorcodeptr = ERR21;
      return NULL;
      }

    /* Caching the pre-processed character ranges. */
    if (cb->next_cranges != NULL)
      cb->next_cranges->next = cranges;
    else
      cb->cranges = cranges;

    cb->next_cranges = cranges;
    }
  else
    {
    /* Reuse the pre-processed character ranges. */
    cranges = cb->cranges;
    PCRE2_ASSERT(cranges != NULL);
    cb->cranges = cranges->next;
    }

  if (cranges->range_list_size > 0)
    {
    const uint32_t *ranges = (const uint32_t*)(cranges + 1);

    if (ranges[0] <= 255)
      xclass_props |= XCLASS_HAS_8BIT_CHARS;

    if (ranges[cranges->range_list_size - 1] == GET_MAX_CHAR_VALUE(utf) &&
        ranges[cranges->range_list_size - 2] <= 256)
      xclass_props |= XCLASS_HIGH_ANY;
    }
  }

class_uchardata = code + LINK_SIZE + 2;   /* For XCLASS items */
#endif /* SUPPORT_WIDE_CHARS */

/* Initialize the 256-bit (32-byte) bit map to all zeros. We build the map
in a temporary bit of memory, in case the class contains fewer than two
8-bit characters because in that case the compiled code doesn't use the bit
map. */

memset(classbits, 0, 32);

/* Process items until end_ptr is reached. */

while (TRUE)
  {
  uint32_t meta = *(pptr++);
  BOOL local_negate;
  int posix_class;
  int taboffset, tabopt;
  class_bits_storage pbits;
  uint32_t escape, c;

  /* Handle POSIX classes such as [:alpha:] etc. */
  switch (META_CODE(meta))
    {
    case META_POSIX:
    case META_POSIX_NEG:

    local_negate = (meta == META_POSIX_NEG);
    posix_class = *(pptr++);

    if (local_negate) should_flip_negation = TRUE;  /* Note negative special */

    /* If matching is caseless, upper and lower are converted to alpha.
    This relies on the fact that the class table starts with alpha,
    lower, upper as the first 3 entries. */

    if ((options & PCRE2_CASELESS) != 0 && posix_class <= 2)
      posix_class = 0;

    /* When PCRE2_UCP is set, some of the POSIX classes are converted to
    different escape sequences that use Unicode properties \p or \P.
    Others that are not available via \p or \P have to generate
    XCL_PROP/XCL_NOTPROP directly, which is done here. */

#ifdef SUPPORT_UNICODE
    /* TODO This entire block of code here appears to be unreachable!? I simply
    can't see how it can be hit, given that the frontend parser doesn't emit
    META_POSIX for GRAPH/PRINT/PUNCT when UCP is set. */
    if ((options & PCRE2_UCP) != 0 &&
        (xoptions & PCRE2_EXTRA_ASCII_POSIX) == 0)
      {
      uint32_t ptype;

      switch(posix_class)
        {
        case PC_GRAPH:
        case PC_PRINT:
        case PC_PUNCT:
        ptype = (posix_class == PC_GRAPH)? PT_PXGRAPH :
                (posix_class == PC_PRINT)? PT_PXPRINT : PT_PXPUNCT;

        PRIV(update_classbits)(ptype, 0, local_negate, classbits);

        if ((xclass_props & XCLASS_HIGH_ANY) == 0)
          {
          if (lengthptr != NULL)
            *lengthptr += 3;
          else
            {
            *class_uchardata++ = local_negate? XCL_NOTPROP : XCL_PROP;
            *class_uchardata++ = (PCRE2_UCHAR)ptype;
            *class_uchardata++ = 0;
            }
          xclass_props |= XCLASS_REQUIRED | XCLASS_HAS_PROPS;
          }
        continue;

        /* For the other POSIX classes (ex: ascii) we are going to
        fall through to the non-UCP case and build a bit map for
        characters with code points less than 256. However, if we are in
        a negated POSIX class, characters with code points greater than
        255 must either all match or all not match, depending on whether
        the whole class is not or is negated. For example, for
        [[:^ascii:]... they must all match, whereas for [^[:^ascii:]...
        they must not.

        In the special case where there are no xclass items, this is
        automatically handled by the use of OP_CLASS or OP_NCLASS, but an
        explicit range is needed for OP_XCLASS. Setting a flag here
        causes the range to be generated later when it is known that
        OP_XCLASS is required. In the 8-bit library this is relevant only in
        utf mode, since no wide characters can exist otherwise. */

        default:
        break;
        }
      }
#endif  /* SUPPORT_UNICODE */

    /* In the non-UCP case, or when UCP makes no difference, we build the
    bit map for the POSIX class in a chunk of local store because we may
    be adding and subtracting from it, and we don't want to subtract bits
    that may be in the main map already. At the end we or the result into
    the bit map that is being built. */

    posix_class *= 3;

    /* Copy in the first table (always present) */

    memcpy(pbits.classbits, cbits + PRIV(posix_class_maps)[posix_class], 32);

    /* If there is a second table, add or remove it as required. */

    taboffset = PRIV(posix_class_maps)[posix_class + 1];
    tabopt = PRIV(posix_class_maps)[posix_class + 2];

    if (taboffset >= 0)
      {
      if (tabopt >= 0)
        for (int i = 0; i < 32; i++)
          pbits.classbits[i] |= cbits[i + taboffset];
      else
        for (int i = 0; i < 32; i++)
          pbits.classbits[i] &= (uint8_t)(~cbits[i + taboffset]);
      }

    /* Now see if we need to remove any special characters. An option
    value of 1 removes vertical space and 2 removes underscore. */

    if (tabopt < 0) tabopt = -tabopt;
    if (tabopt == 1) pbits.classbits[1] &= ~0x3c;
      else if (tabopt == 2) pbits.classbits[11] &= 0x7f;

    /* Add the POSIX table or its complement into the main table that is
    being built and we are done. */

      {
      uint32_t *classwords = cb->classbits.classwords;

      if (local_negate)
        for (int i = 0; i < 8; i++)
          classwords[i] |= (uint32_t)(~pbits.classwords[i]);
      else
        for (int i = 0; i < 8; i++)
          classwords[i] |= pbits.classwords[i];
      }

#ifdef SUPPORT_WIDE_CHARS
    /* Every class contains at least one < 256 character. */
    xclass_props |= XCLASS_HAS_8BIT_CHARS;
#endif
    continue;               /* End of POSIX handling */

    /* Other than POSIX classes, the only items we should encounter are
    \d-type escapes and literal characters (possibly as ranges). */
    case META_BIGVALUE:
    meta = *(pptr++);
    break;

    case META_ESCAPE:
    escape = META_DATA(meta);

    switch(escape)
      {
      case ESC_d:
      for (int i = 0; i < 32; i++) classbits[i] |= cbits[i+cbit_digit];
      break;

      case ESC_D:
      should_flip_negation = TRUE;
      for (int i = 0; i < 32; i++)
        classbits[i] |= (uint8_t)(~cbits[i+cbit_digit]);
      break;

      case ESC_w:
      for (int i = 0; i < 32; i++) classbits[i] |= cbits[i+cbit_word];
      break;

      case ESC_W:
      should_flip_negation = TRUE;
      for (int i = 0; i < 32; i++)
        classbits[i] |= (uint8_t)(~cbits[i+cbit_word]);
      break;

      /* Perl 5.004 onwards omitted VT from \s, but restored it at Perl
      5.18. Before PCRE 8.34, we had to preserve the VT bit if it was
      previously set by something earlier in the character class.
      Luckily, the value of CHAR_VT is 0x0b in both ASCII and EBCDIC, so
      we could just adjust the appropriate bit. From PCRE 8.34 we no
      longer treat \s and \S specially. */

      case ESC_s:
      for (int i = 0; i < 32; i++) classbits[i] |= cbits[i+cbit_space];
      break;

      case ESC_S:
      should_flip_negation = TRUE;
      for (int i = 0; i < 32; i++)
        classbits[i] |= (uint8_t)(~cbits[i+cbit_space]);
      break;

      /* When adding the horizontal or vertical space lists to a class, or
      their complements, disable PCRE2_CASELESS, because it justs wastes
      time, and in the "not-x" UTF cases can create unwanted duplicates in
      the XCLASS list (provoked by characters that have more than one other
      case and by both cases being in the same "not-x" sublist). */

      case ESC_h:
#if PCRE2_CODE_UNIT_WIDTH == 8
#ifdef SUPPORT_UNICODE
      if (cranges != NULL) break;
#endif
      add_list_to_class(options & ~PCRE2_CASELESS, xoptions,
        cb, PRIV(hspace_list));
#else
      PCRE2_ASSERT(cranges != NULL);
#endif
      break;

      case ESC_H:
#if PCRE2_CODE_UNIT_WIDTH == 8
#ifdef SUPPORT_UNICODE
      if (cranges != NULL) break;
#endif
      add_not_list_to_class(options & ~PCRE2_CASELESS, xoptions,
        cb, PRIV(hspace_list));
#else
      PCRE2_ASSERT(cranges != NULL);
#endif
      break;

      case ESC_v:
#if PCRE2_CODE_UNIT_WIDTH == 8
#ifdef SUPPORT_UNICODE
      if (cranges != NULL) break;
#endif
      add_list_to_class(options & ~PCRE2_CASELESS, xoptions,
        cb, PRIV(vspace_list));
#else
      PCRE2_ASSERT(cranges != NULL);
#endif
      break;

      case ESC_V:
#if PCRE2_CODE_UNIT_WIDTH == 8
#ifdef SUPPORT_UNICODE
      if (cranges != NULL) break;
#endif
      add_not_list_to_class(options & ~PCRE2_CASELESS, xoptions,
        cb, PRIV(vspace_list));
#else
      PCRE2_ASSERT(cranges != NULL);
#endif
      break;

      /* If Unicode is not supported, \P and \p are not allowed and are
      faulted at parse time, so will never appear here. */

#ifdef SUPPORT_UNICODE
      case ESC_p:
      case ESC_P:
        {
        uint32_t ptype = *pptr >> 16;
        uint32_t pdata = *(pptr++) & 0xffff;

        /* The "Any" is processed by PRIV(update_classbits)(). */
        if (ptype == PT_ANY)
          {
#if PCRE2_CODE_UNIT_WIDTH == 8
          if (!utf && escape == ESC_p) memset(classbits, 0xff, 32);
#endif
          continue;
          }

        PRIV(update_classbits)(ptype, pdata, (escape == ESC_P), classbits);

        if ((xclass_props & XCLASS_HIGH_ANY) == 0)
          {
          if (lengthptr != NULL)
            *lengthptr += 3;
          else
            {
            *class_uchardata++ = (escape == ESC_p)? XCL_PROP : XCL_NOTPROP;
            *class_uchardata++ = ptype;
            *class_uchardata++ = pdata;
            }
          xclass_props |= XCLASS_REQUIRED | XCLASS_HAS_PROPS;
          }
        }
      continue;
#endif
      }

#ifdef SUPPORT_WIDE_CHARS
    /* Every non-property class contains at least one < 256 character. */
    xclass_props |= XCLASS_HAS_8BIT_CHARS;
#endif
    /* End handling \d-type escapes */
    continue;

    CLASS_END_CASES(meta)
    /* Literals. */
    if (meta < META_END) break;
    /* Non-literals: end of class contents. */
    goto END_PROCESSING;
    }

  /* A literal character may be followed by a range meta. At parse time
  there are checks for out-of-order characters, for ranges where the two
  characters are equal, and for hyphens that cannot indicate a range. At
  this point, therefore, no checking is needed. */

  c = meta;

  /* Remember if \r or \n were explicitly used */

  if (c == CHAR_CR || c == CHAR_NL) cb->external_flags |= PCRE2_HASCRORLF;

  /* Process a character range */

  if (*pptr == META_RANGE_LITERAL || *pptr == META_RANGE_ESCAPED)
    {
    uint32_t d;

#ifdef EBCDIC
    BOOL range_is_literal = (*pptr == META_RANGE_LITERAL);
#endif
    ++pptr;
    d = *(pptr++);
    if (d == META_BIGVALUE) d = *(pptr++);

    /* Remember an explicit \r or \n, and add the range to the class. */

    if (d == CHAR_CR || d == CHAR_NL) cb->external_flags |= PCRE2_HASCRORLF;

#if PCRE2_CODE_UNIT_WIDTH == 8
#ifdef SUPPORT_UNICODE
    if (cranges != NULL) continue;
    xclass_props |= XCLASS_HAS_8BIT_CHARS;
#endif

    /* In an EBCDIC environment, Perl treats alphabetic ranges specially
    because there are holes in the encoding, and simply using the range
    A-Z (for example) would include the characters in the holes. This
    applies only to literal ranges; [\xC1-\xE9] is different to [A-Z]. */

#ifdef EBCDIC
    if (range_is_literal &&
         (cb->ctypes[c] & ctype_letter) != 0 &&
         (cb->ctypes[d] & ctype_letter) != 0 &&
         (c <= CHAR_z) == (d <= CHAR_z))
      {
      uint32_t uc = (d <= CHAR_z)? 0 : 64;
      uint32_t C = c - uc;
      uint32_t D = d - uc;

      if (C <= CHAR_i)
        {
        add_to_class(options, xoptions, cb, C + uc,
          ((D < CHAR_i)? D : CHAR_i) + uc);
        C = CHAR_j;
        }

      if (C <= D && C <= CHAR_r)
        {
        add_to_class(options, xoptions, cb, C + uc,
          ((D < CHAR_r)? D : CHAR_r) + uc);
        C = CHAR_s;
        }

      if (C <= D)
        add_to_class(options, xoptions, cb, C + uc, D + uc);
      }
    else
#endif
    /* Not an EBCDIC special range */

    add_to_class(options, xoptions, cb, c, d);
#else
    PCRE2_ASSERT(cranges != NULL);
#endif
    continue;
    }  /* End of range handling */

  /* Character ranges are ignored when class_ranges is present. */
#if PCRE2_CODE_UNIT_WIDTH == 8
#ifdef SUPPORT_UNICODE
  if (cranges != NULL) continue;
  xclass_props |= XCLASS_HAS_8BIT_CHARS;
#endif
  /* Handle a single character. */

  add_to_class(options, xoptions, cb, meta, meta);
#else
  PCRE2_ASSERT(cranges != NULL);
#endif
  }   /* End of main class-processing loop */

END_PROCESSING:

#ifdef SUPPORT_WIDE_CHARS
PCRE2_ASSERT((xclass_props & XCLASS_HAS_PROPS) == 0 ||
             (xclass_props & XCLASS_HIGH_ANY) == 0);

if (cranges != NULL)
  {
  uint32_t *range = (uint32_t*)(cranges + 1);
  uint32_t *end = range + cranges->range_list_size;

  while (range < end && range[0] < 256)
    {
    PCRE2_ASSERT((xclass_props & XCLASS_HAS_8BIT_CHARS) != 0);
    /* Add range to bitset. If we are in UTF or UCP mode, then clear the
    caseless bit, because the cranges handle caselessness (only) in this
    condition; see the condition for PARSE_CLASS_CASELESS_UTF in
    compile_optimize_class(). */
    add_to_class(((options & (PCRE2_UTF|PCRE2_UCP)) != 0)?
        (options & ~PCRE2_CASELESS) : options, xoptions, cb, range[0], range[1]);

    if (range[1] > 255) break;
    range += 2;
    }

  if (cranges->char_lists_size > 0)
    {
    /* The cranges structure is still used and freed later. */
    PCRE2_ASSERT((xclass_props & XCLASS_HIGH_ANY) == 0);
    xclass_props |= XCLASS_REQUIRED | XCLASS_HAS_CHAR_LISTS;
    }
  else
    {
    if ((xclass_props & XCLASS_HIGH_ANY) != 0)
      {
      PCRE2_ASSERT(range + 2 == end && range[0] <= 256 &&
        range[1] >= GET_MAX_CHAR_VALUE(utf));
      should_flip_negation = TRUE;
      range = end;
      }

    while (range < end)
      {
      uint32_t range_start = range[0];
      uint32_t range_end = range[1];

      range += 2;
      xclass_props |= XCLASS_REQUIRED;

      if (range_start < 256) range_start = 256;

      if (lengthptr != NULL)
        {
#ifdef SUPPORT_UNICODE
        if (utf)
          {
          *lengthptr += 1;

          if (range_start < range_end)
            *lengthptr += PRIV(ord2utf)(range_start, class_uchardata);

          *lengthptr += PRIV(ord2utf)(range_end, class_uchardata);
          continue;
          }
#endif  /* SUPPORT_UNICODE */

        *lengthptr += range_start < range_end ? 3 : 2;
        continue;
        }

#ifdef SUPPORT_UNICODE
      if (utf)
        {
        if (range_start < range_end)
          {
          *class_uchardata++ = XCL_RANGE;
          class_uchardata += PRIV(ord2utf)(range_start, class_uchardata);
          }
        else
          *class_uchardata++ = XCL_SINGLE;

        class_uchardata += PRIV(ord2utf)(range_end, class_uchardata);
        continue;
        }
#endif  /* SUPPORT_UNICODE */

      /* Without UTF support, character values are constrained
      by the bit length, and can only be > 256 for 16-bit and
      32-bit libraries. */
#if PCRE2_CODE_UNIT_WIDTH != 8
      if (range_start < range_end)
        {
        *class_uchardata++ = XCL_RANGE;
        *class_uchardata++ = range_start;
        }
      else
        *class_uchardata++ = XCL_SINGLE;

      *class_uchardata++ = range_end;
#endif  /* PCRE2_CODE_UNIT_WIDTH == 8 */
      }

    if (lengthptr == NULL)
      cb->cx->memctl.free(cranges, cb->cx->memctl.memory_data);
    }
  }
#endif /* SUPPORT_WIDE_CHARS */

/* If there are characters with values > 255, or Unicode property settings
(\p or \P), we have to compile an extended class, with its own opcode,
unless there were no property settings and there was a negated special such
as \S in the class, and PCRE2_UCP is not set, because in that case all
characters > 255 are in or not in the class, so any that were explicitly
given as well can be ignored.

In the UCP case, if certain negated POSIX classes (ex: [:^ascii:]) were
were present in a class, we either have to match or not match all wide
characters (depending on whether the whole class is or is not negated).
This requirement is indicated by match_all_or_no_wide_chars being true.
We do this by including an explicit range, which works in both cases.
This applies only in UTF and 16-bit and 32-bit non-UTF modes, since there
cannot be any wide characters in 8-bit non-UTF mode.

When there *are* properties in a positive UTF-8 or any 16-bit or 32_bit
class where \S etc is present without PCRE2_UCP, causing an extended class
to be compiled, we make sure that all characters > 255 are included by
forcing match_all_or_no_wide_chars to be true.

If, when generating an xclass, there are no characters < 256, we can omit
the bitmap in the actual compiled code. */

#ifdef SUPPORT_WIDE_CHARS  /* Defined for 16/32 bits, or 8-bit with Unicode */
if ((xclass_props & XCLASS_REQUIRED) != 0)
  {
  PCRE2_UCHAR *previous = code;

  if ((xclass_props & XCLASS_HAS_CHAR_LISTS) == 0)
    *class_uchardata++ = XCL_END;    /* Marks the end of extra data */
  *code++ = OP_XCLASS;
  code += LINK_SIZE;
  *code = negate_class? XCL_NOT:0;
  if ((xclass_props & XCLASS_HAS_PROPS) != 0) *code |= XCL_HASPROP;

  /* If the map is required, move up the extra data to make room for it;
  otherwise just move the code pointer to the end of the extra data. */

  if ((xclass_props & XCLASS_HAS_8BIT_CHARS) != 0 || has_bitmap != NULL)
    {
    if (negate_class)
      {
      uint32_t *classwords = cb->classbits.classwords;
      for (int i = 0; i < 8; i++) classwords[i] = ~classwords[i];
      }

    if (has_bitmap == NULL)
      {
      *code++ |= XCL_MAP;
      (void)memmove(code + (32 / sizeof(PCRE2_UCHAR)), code,
        CU2BYTES(class_uchardata - code));
      memcpy(code, classbits, 32);
      code = class_uchardata + (32 / sizeof(PCRE2_UCHAR));
      }
    else
      {
      code = class_uchardata;
      if ((xclass_props & XCLASS_HAS_8BIT_CHARS) != 0)
        *has_bitmap = TRUE;
      }
    }
  else code = class_uchardata;

  if ((xclass_props & XCLASS_HAS_CHAR_LISTS) != 0)
    {
    /* Char lists size is an even number, because all items are 16 or 32
    bit values. The character list data is always aligned to 32 bits. */
    size_t char_lists_size = cranges->char_lists_size;
    PCRE2_ASSERT((char_lists_size & 0x1) == 0 &&
                 (cb->char_lists_size & 0x3) == 0);

    if (lengthptr != NULL)
      {
      char_lists_size = CLIST_ALIGN_TO(char_lists_size, sizeof(uint32_t));

#if PCRE2_CODE_UNIT_WIDTH == 8
      *lengthptr += 2 + LINK_SIZE;
#else
      *lengthptr += 1 + LINK_SIZE;
#endif

      cb->char_lists_size += char_lists_size;

      char_lists_size /= sizeof(PCRE2_UCHAR);

      /* Storage space for character lists is included
      in the maximum pattern size. */
      if (*lengthptr > MAX_PATTERN_SIZE ||
          MAX_PATTERN_SIZE - *lengthptr < char_lists_size)
        {
        *errorcodeptr = ERR20;   /* Pattern is too large */
        return NULL;
        }
      }
    else
      {
      uint8_t *data;

      PCRE2_ASSERT(cranges->char_lists_types <= XCL_TYPE_MASK);
#if PCRE2_CODE_UNIT_WIDTH == 8
      /* Encode as high / low bytes. */
      code[0] = (uint8_t)(XCL_LIST |
        (cranges->char_lists_types >> 8));
      code[1] = (uint8_t)cranges->char_lists_types;
      code += 2;
#else
      *code++ = (PCRE2_UCHAR)(XCL_LIST | cranges->char_lists_types);
#endif

      /* Character lists are stored in backwards direction from
      byte code start. The non-dfa/dfa matchers can access these
      lists using the byte code start stored in match blocks.
      Each list is aligned to 32 bit with an optional unused
      16 bit value at the beginning of the character list. */

      cb->char_lists_size += char_lists_size;
      data = (uint8_t*)cb->start_code - cb->char_lists_size;

      memcpy(data, (uint8_t*)(cranges + 1) + cranges->char_lists_start,
        char_lists_size);

      /* Since character lists total size is less than MAX_PATTERN_SIZE,
      their starting offset fits into a value which size is LINK_SIZE. */

      char_lists_size = cb->char_lists_size;
      PUT(code, 0, (uint32_t)(char_lists_size >> 1));
      code += LINK_SIZE;

#if defined PCRE2_DEBUG || defined SUPPORT_VALGRIND
      if ((char_lists_size & 0x2) != 0)
        {
        /* In debug the unused 16 bit value is set
        to a fixed value and marked unused. */
        ((uint16_t*)data)[-1] = 0x5555;
#ifdef SUPPORT_VALGRIND
        VALGRIND_MAKE_MEM_NOACCESS(data - 2, 2);
#endif
        }
#endif

      cb->char_lists_size =
        CLIST_ALIGN_TO(char_lists_size, sizeof(uint32_t));

      cb->cx->memctl.free(cranges, cb->cx->memctl.memory_data);
      }
    }

  /* Now fill in the complete length of the item */

  PUT(previous, 1, (int)(code - previous));
  goto DONE;   /* End of class handling */
  }
#endif  /* SUPPORT_WIDE_CHARS */

/* If there are no characters > 255, or they are all to be included or
excluded, set the opcode to OP_CLASS or OP_NCLASS, depending on whether the
whole class was negated and whether there were negative specials such as \S
(non-UCP) in the class. Then copy the 32-byte map into the code vector,
negating it if necessary. */

if (negate_class)
  {
  uint32_t *classwords = cb->classbits.classwords;

  for (int i = 0; i < 8; i++) classwords[i] = ~classwords[i];
  }

if ((SELECT_VALUE8(!utf, 0) || negate_class != should_flip_negation) &&
    cb->classbits.classwords[0] == ~(uint32_t)0)
  {
  const uint32_t *classwords = cb->classbits.classwords;
  int i;

  for (i = 0; i < 8; i++)
    if (classwords[i] != ~(uint32_t)0) break;

  if (i == 8)
    {
    *code++ = OP_ALLANY;
    goto DONE;   /* End of class handling */
    }
  }

*code++ = (negate_class == should_flip_negation) ? OP_CLASS : OP_NCLASS;
memcpy(code, classbits, 32);
code += 32 / sizeof(PCRE2_UCHAR);

DONE:
*pcode = code;
return pptr - 1;
}



/* ===================================================================*/
/* Here follows a block of ECLASS-compiling functions. You may well want to
read them from top to bottom; they are ordered from leafmost (at the top) to
outermost parser (at the bottom of the file). */

/* This function folds one operand using the negation operator.
The new, combined chunk of stack code is written out to *pop_info. */

static void
fold_negation(eclass_op_info *pop_info, PCRE2_SIZE *lengthptr,
  BOOL preserve_classbits)
{
/* If the chunk of stack code is already composed of multiple ops, we won't
descend in and try and propagate the negation down the tree. (That would lead
to O(n^2) compile-time, which could be exploitable with a malicious regex -
although maybe that's not really too much of a worry in a library that offers
an exponential-time matching function!) */

if (pop_info->op_single_type == 0)
  {
  if (lengthptr != NULL)
    *lengthptr += 1;
  else
    pop_info->code_start[pop_info->length] = ECL_NOT;
  pop_info->length += 1;
  }

/* Otherwise, it's a nice single-op item, so we can easily fold in the negation
without needing to produce an ECL_NOT. */

else if (pop_info->op_single_type == ECL_ANY ||
         pop_info->op_single_type == ECL_NONE)
  {
  pop_info->op_single_type = (pop_info->op_single_type == ECL_NONE)?
      ECL_ANY : ECL_NONE;
  if (lengthptr == NULL)
    *(pop_info->code_start) = pop_info->op_single_type;
  }
else
  {
  PCRE2_ASSERT(pop_info->op_single_type == ECL_XCLASS &&
               pop_info->length >= 1 + LINK_SIZE + 1);
  if (lengthptr == NULL)
    pop_info->code_start[1 + LINK_SIZE] ^= XCL_NOT;
  }

if (!preserve_classbits)
  {
  for (int i = 0; i < 8; i++)
    pop_info->bits.classwords[i] = ~pop_info->bits.classwords[i];
  }
}



/* This function folds together two operands using a binary operator.
The new, combined chunk of stack code is written out to *lhs_op_info. */

static void
fold_binary(int op, eclass_op_info *lhs_op_info, eclass_op_info *rhs_op_info,
  PCRE2_SIZE *lengthptr)
{
switch (op)
  {
  /* ECL_AND truth table:

     LHS  RHS  RESULT
     ----------------
     ANY  *    RHS
     *    ANY  LHS
     NONE *    NONE
     *    NONE NONE
     X    Y    X & Y
  */

  case ECL_AND:
  if (rhs_op_info->op_single_type == ECL_ANY)
    {
    /* no-op: drop the RHS */
    }
  else if (lhs_op_info->op_single_type == ECL_ANY)
    {
    /* no-op: drop the LHS, and memmove the RHS into its place */
    if (lengthptr == NULL)
      memmove(lhs_op_info->code_start, rhs_op_info->code_start,
              CU2BYTES(rhs_op_info->length));
    lhs_op_info->length = rhs_op_info->length;
    lhs_op_info->op_single_type = rhs_op_info->op_single_type;
    }
  else if (rhs_op_info->op_single_type == ECL_NONE)
    {
    /* the result is ECL_NONE: write into the LHS */
    if (lengthptr == NULL)
      lhs_op_info->code_start[0] = ECL_NONE;
    lhs_op_info->length = 1;
    lhs_op_info->op_single_type = ECL_NONE;
    }
  else if (lhs_op_info->op_single_type == ECL_NONE)
    {
    /* the result is ECL_NONE: drop the RHS */
    }
  else
    {
    /* Both of LHS & RHS are either ECL_XCLASS, or compound operations. */
    if (lengthptr != NULL)
      *lengthptr += 1;
    else
      {
      PCRE2_ASSERT(rhs_op_info->code_start ==
          lhs_op_info->code_start + lhs_op_info->length);
      rhs_op_info->code_start[rhs_op_info->length] = ECL_AND;
      }
    lhs_op_info->length += rhs_op_info->length + 1;
    lhs_op_info->op_single_type = 0;
    }

  for (int i = 0; i < 8; i++)
    lhs_op_info->bits.classwords[i] &= rhs_op_info->bits.classwords[i];
  break;

  /* ECL_OR truth table:

     LHS  RHS  RESULT
     ----------------
     ANY  *    ANY
     *    ANY  ANY
     NONE *    RHS
     *    NONE LHS
     X    Y    X | Y
  */

  case ECL_OR:
  if (rhs_op_info->op_single_type == ECL_NONE)
    {
    /* no-op: drop the RHS */
    }
  else if (lhs_op_info->op_single_type == ECL_NONE)
    {
    /* no-op: drop the LHS, and memmove the RHS into its place */
    if (lengthptr == NULL)
      memmove(lhs_op_info->code_start, rhs_op_info->code_start,
              CU2BYTES(rhs_op_info->length));
    lhs_op_info->length = rhs_op_info->length;
    lhs_op_info->op_single_type = rhs_op_info->op_single_type;
    }
  else if (rhs_op_info->op_single_type == ECL_ANY)
    {
    /* the result is ECL_ANY: write into the LHS */
    if (lengthptr == NULL)
      lhs_op_info->code_start[0] = ECL_ANY;
    lhs_op_info->length = 1;
    lhs_op_info->op_single_type = ECL_ANY;
    }
  else if (lhs_op_info->op_single_type == ECL_ANY)
    {
    /* the result is ECL_ANY: drop the RHS */
    }
  else
    {
    /* Both of LHS & RHS are either ECL_XCLASS, or compound operations. */
    if (lengthptr != NULL)
      *lengthptr += 1;
    else
      {
      PCRE2_ASSERT(rhs_op_info->code_start ==
          lhs_op_info->code_start + lhs_op_info->length);
      rhs_op_info->code_start[rhs_op_info->length] = ECL_OR;
      }
    lhs_op_info->length += rhs_op_info->length + 1;
    lhs_op_info->op_single_type = 0;
    }

  for (int i = 0; i < 8; i++)
    lhs_op_info->bits.classwords[i] |= rhs_op_info->bits.classwords[i];
  break;

  /* ECL_XOR truth table:

     LHS  RHS  RESULT
     ----------------
     ANY  *    !RHS
     *    ANY  !LHS
     NONE *    RHS
     *    NONE LHS
     X    Y    X ^ Y
  */

  case ECL_XOR:
  if (rhs_op_info->op_single_type == ECL_NONE)
    {
    /* no-op: drop the RHS */
    }
  else if (lhs_op_info->op_single_type == ECL_NONE)
    {
    /* no-op: drop the LHS, and memmove the RHS into its place */
    if (lengthptr == NULL)
      memmove(lhs_op_info->code_start, rhs_op_info->code_start,
              CU2BYTES(rhs_op_info->length));
    lhs_op_info->length = rhs_op_info->length;
    lhs_op_info->op_single_type = rhs_op_info->op_single_type;
    }
  else if (rhs_op_info->op_single_type == ECL_ANY)
    {
    /* the result is !LHS: fold in the negation, and drop the RHS */
    /* Preserve the classbits, because we promise to deal with them later. */
    fold_negation(lhs_op_info, lengthptr, TRUE);
    }
  else if (lhs_op_info->op_single_type == ECL_ANY)
    {
    /* the result is !RHS: drop the LHS, memmove the RHS into its place, and
    fold in the negation */
    if (lengthptr == NULL)
      memmove(lhs_op_info->code_start, rhs_op_info->code_start,
              CU2BYTES(rhs_op_info->length));
    lhs_op_info->length = rhs_op_info->length;
    lhs_op_info->op_single_type = rhs_op_info->op_single_type;

    /* Preserve the classbits, because we promise to deal with them later. */
    fold_negation(lhs_op_info, lengthptr, TRUE);
    }
  else
    {
    /* Both of LHS & RHS are either ECL_XCLASS, or compound operations. */
    if (lengthptr != NULL)
      *lengthptr += 1;
    else
      {
      PCRE2_ASSERT(rhs_op_info->code_start ==
          lhs_op_info->code_start + lhs_op_info->length);
      rhs_op_info->code_start[rhs_op_info->length] = ECL_XOR;
      }
    lhs_op_info->length += rhs_op_info->length + 1;
    lhs_op_info->op_single_type = 0;
    }

  for (int i = 0; i < 8; i++)
    lhs_op_info->bits.classwords[i] ^= rhs_op_info->bits.classwords[i];
  break;

  default:
  PCRE2_DEBUG_UNREACHABLE();
  break;
  }
}



static BOOL
compile_eclass_nested(eclass_context *context, BOOL negated,
  uint32_t **pptr, PCRE2_UCHAR **pcode,
  eclass_op_info *pop_info, PCRE2_SIZE *lengthptr);

/* This function consumes a group of implicitly-unioned class elements.
These can be characters, ranges, properties, or nested classes, as long
as they are all joined by being placed adjacently. */

static BOOL
compile_class_operand(eclass_context *context, BOOL negated,
  uint32_t **pptr, PCRE2_UCHAR **pcode, eclass_op_info *pop_info,
  PCRE2_SIZE *lengthptr)
{
uint32_t *ptr = *pptr;
uint32_t *prev_ptr;
PCRE2_UCHAR *code = *pcode;
PCRE2_UCHAR *code_start = code;
PCRE2_SIZE prev_length = (lengthptr != NULL)? *lengthptr : 0;
PCRE2_SIZE extra_length;
uint32_t meta = META_CODE(*ptr);

switch (meta)
  {
  case META_CLASS_EMPTY_NOT:
  case META_CLASS_EMPTY:
  ++ptr;
  pop_info->length = 1;
  if ((meta == META_CLASS_EMPTY) == negated)
    {
    *code++ = pop_info->op_single_type = ECL_ANY;
    memset(pop_info->bits.classbits, 0xff, 32);
    }
  else
    {
    *code++ = pop_info->op_single_type = ECL_NONE;
    memset(pop_info->bits.classbits, 0, 32);
    }
  break;

  case META_CLASS:
  case META_CLASS_NOT:
  if ((*ptr & CLASS_IS_ECLASS) != 0)
    {
    if (!compile_eclass_nested(context, negated, &ptr, &code,
                               pop_info, lengthptr))
      return FALSE;

    PCRE2_ASSERT(*ptr == META_CLASS_END);
    ptr++;
    goto DONE;
    }

  ptr++;
  /* Fall through */

  default:
  /* Scan forward characters, ranges, and properties.
  For example: inside [a-z_ -- m] we don't have brackets around "a-z_" but
  we still need to collect that fragment up into a "leaf" OP_CLASS. */

  prev_ptr = ptr;
  ptr = PRIV(compile_class_not_nested)(
    context->options, context->xoptions, ptr, &code,
    (meta != META_CLASS_NOT) == negated, &context->needs_bitmap,
    context->errorcodeptr, context->cb, lengthptr);
  if (ptr == NULL) return FALSE;

  /* We must have a 100% guarantee that ptr increases when
  compile_class_operand() returns, even on Release builds, so that we can
  statically prove our loops terminate. */
  if (ptr <= prev_ptr)
    {
    PCRE2_DEBUG_UNREACHABLE();
    return FALSE;
    }

  /* If we fell through above, consume the closing ']'. */
  if (meta == META_CLASS || meta == META_CLASS_NOT)
    {
    PCRE2_ASSERT(*ptr == META_CLASS_END);
    ptr++;
    }

  /* Regardless of whether (lengthptr == NULL), some data will still be written
  out to *pcode, which we need: we have to peek at it, to transform the opcode
  into the ECLASS version (since we need to hoist up the bitmaps). */
  PCRE2_ASSERT(code > code_start);
  extra_length = (lengthptr != NULL)? *lengthptr - prev_length : 0;

  /* Easiest case: convert OP_ALLANY to ECL_ANY */

  if (*code_start == OP_ALLANY)
    {
    PCRE2_ASSERT(code - code_start == 1 && extra_length == 0);
    pop_info->length = 1;
    *code_start = pop_info->op_single_type = ECL_ANY;
    memset(pop_info->bits.classbits, 0xff, 32);
    }

  /* For OP_CLASS and OP_NCLASS, we hoist out the bitmap and convert to
  ECL_NONE / ECL_ANY respectively. */

  else if (*code_start == OP_CLASS || *code_start == OP_NCLASS)
    {
    PCRE2_ASSERT(code - code_start == 1 + 32 / sizeof(PCRE2_UCHAR) &&
                 extra_length == 0);
    pop_info->length = 1;
    *code_start = pop_info->op_single_type =
        (*code_start == OP_CLASS)? ECL_NONE : ECL_ANY;
    memcpy(pop_info->bits.classbits, code_start + 1, 32);
    /* Rewind the code pointer, but make sure we adjust *lengthptr, because we
    do need to reserve that space (even though we only use it temporarily). */
    if (lengthptr != NULL)
      *lengthptr += code - (code_start + 1);
    code = code_start + 1;

    if (!context->needs_bitmap && *code_start == ECL_NONE)
      {
      uint32_t *classwords = pop_info->bits.classwords;

      for (int i = 0; i < 8; i++)
        if (classwords[i] != 0)
          {
          context->needs_bitmap = TRUE;
          break;
          }
      }
    else
      context->needs_bitmap = TRUE;
    }

  /* Finally, for OP_XCLASS we hoist out the bitmap (if any), and convert to
  ECL_XCLASS. */

  else
    {
    PCRE2_ASSERT(*code_start == OP_XCLASS);
    *code_start = pop_info->op_single_type = ECL_XCLASS;

    PCRE2_ASSERT(code - code_start >= 1 + LINK_SIZE + 1);

    memcpy(pop_info->bits.classbits, context->cb->classbits.classbits, 32);
    pop_info->length = (code - code_start) + extra_length;
    }

  break;
  }  /* End of switch(meta) */

pop_info->code_start = (lengthptr == NULL)? code_start : NULL;

if (lengthptr != NULL)
  {
  *lengthptr += code - code_start;
  code = code_start;
  }

DONE:
PCRE2_ASSERT(lengthptr == NULL || (code == code_start));

*pptr = ptr;
*pcode = code;
return TRUE;
}



/* This function consumes a group of implicitly-unioned class elements.
These can be characters, ranges, properties, or nested classes, as long
as they are all joined by being placed adjacently. */

static BOOL
compile_class_juxtaposition(eclass_context *context, BOOL negated,
  uint32_t **pptr, PCRE2_UCHAR **pcode, eclass_op_info *pop_info,
  PCRE2_SIZE *lengthptr)
{
uint32_t *ptr = *pptr;
PCRE2_UCHAR *code = *pcode;
#ifdef PCRE2_DEBUG
PCRE2_UCHAR *start_code = *pcode;
#endif

/* See compile_class_binary_loose() for comments on compile-time folding of
the "negated" flag. */

/* Because it's a non-empty class, there must be an operand at the start. */
if (!compile_class_operand(context, negated, &ptr, &code, pop_info, lengthptr))
  return FALSE;

while (*ptr != META_CLASS_END &&
       !(*ptr >= META_ECLASS_AND && *ptr <= META_ECLASS_NOT))
  {
  uint32_t op;
  BOOL rhs_negated;
  eclass_op_info rhs_op_info;

  if (negated)
    {
    /* !(A juxtapose B)  ->  !A && !B */
    op = ECL_AND;
    rhs_negated = TRUE;
    }
  else
    {
    /* A juxtapose B  ->  A || B */
    op = ECL_OR;
    rhs_negated = FALSE;
    }

  /* An operand must follow the operator. */
  if (!compile_class_operand(context, rhs_negated, &ptr, &code,
                             &rhs_op_info, lengthptr))
    return FALSE;

  /* Convert infix to postfix (RPN). */
  fold_binary(op, pop_info, &rhs_op_info, lengthptr);
  if (lengthptr == NULL)
    code = pop_info->code_start + pop_info->length;
  }

PCRE2_ASSERT(lengthptr == NULL || code == start_code);

*pptr = ptr;
*pcode = code;
return TRUE;
}



/* This function consumes unary prefix operators. */

static BOOL
compile_class_unary(eclass_context *context, BOOL negated,
  uint32_t **pptr, PCRE2_UCHAR **pcode, eclass_op_info *pop_info,
  PCRE2_SIZE *lengthptr)
{
uint32_t *ptr = *pptr;
#ifdef PCRE2_DEBUG
PCRE2_UCHAR *start_code = *pcode;
#endif

while (*ptr == META_ECLASS_NOT)
  {
  ++ptr;
  negated = !negated;
  }

*pptr = ptr;
/* Because it's a non-empty class, there must be an operand. */
if (!compile_class_juxtaposition(context, negated, pptr, pcode,
                                 pop_info, lengthptr))
  return FALSE;

PCRE2_ASSERT(lengthptr == NULL || *pcode == start_code);
return TRUE;
}



/* This function consumes tightly-binding binary operators. */

static BOOL
compile_class_binary_tight(eclass_context *context, BOOL negated,
  uint32_t **pptr, PCRE2_UCHAR **pcode, eclass_op_info *pop_info,
  PCRE2_SIZE *lengthptr)
{
uint32_t *ptr = *pptr;
PCRE2_UCHAR *code = *pcode;
#ifdef PCRE2_DEBUG
PCRE2_UCHAR *start_code = *pcode;
#endif

/* See compile_class_binary_loose() for comments on compile-time folding of
the "negated" flag. */

/* Because it's a non-empty class, there must be an operand at the start. */
if (!compile_class_unary(context, negated, &ptr, &code, pop_info, lengthptr))
  return FALSE;

while (*ptr == META_ECLASS_AND)
  {
  uint32_t op;
  BOOL rhs_negated;
  eclass_op_info rhs_op_info;

  if (negated)
    {
    /* !(A && B)  ->  !A || !B */
    op = ECL_OR;
    rhs_negated = TRUE;
    }
  else
    {
    /* A && B  ->  A && B */
    op = ECL_AND;
    rhs_negated = FALSE;
    }

  ++ptr;

  /* An operand must follow the operator. */
  if (!compile_class_unary(context, rhs_negated, &ptr, &code,
                           &rhs_op_info, lengthptr))
    return FALSE;

  /* Convert infix to postfix (RPN). */
  fold_binary(op, pop_info, &rhs_op_info, lengthptr);
  if (lengthptr == NULL)
    code = pop_info->code_start + pop_info->length;
  }

PCRE2_ASSERT(lengthptr == NULL || code == start_code);

*pptr = ptr;
*pcode = code;
return TRUE;
}



/* This function consumes loosely-binding binary operators. */

static BOOL
compile_class_binary_loose(eclass_context *context, BOOL negated,
  uint32_t **pptr, PCRE2_UCHAR **pcode, eclass_op_info *pop_info,
  PCRE2_SIZE *lengthptr)
{
uint32_t *ptr = *pptr;
PCRE2_UCHAR *code = *pcode;
#ifdef PCRE2_DEBUG
PCRE2_UCHAR *start_code = *pcode;
#endif

/* We really want to fold the negation operator, if at all possible, so that
simple cases can be reduced down. In particular, in 8-bit no-UTF mode, we want
to produce a fully-folded expression, so that we can guarantee not to emit any
OP_ECLASS codes (in the same way that we never emit OP_XCLASS in this mode).

This has the consequence that with a little ingenuity, we can in fact avoid
emitting (nearly...) all cases of the "NOT" operator. Imagine that we have:
    !(A ...
We have parsed the preceding "!", and we are about to parse the "A" operand. We
don't know yet whether there will even be a following binary operand! Both of
these are possibilities for what follows:
    !(A && B)
    !(A)
However, we can still fold the "!" into the "A" operand, because no matter what
the following binary operator will be, we can produce an expression which is
equivalent. */

/* Because it's a non-empty class, there must be an operand at the start. */
if (!compile_class_binary_tight(context, negated, &ptr, &code,
                                pop_info, lengthptr))
  return FALSE;

while (*ptr >= META_ECLASS_OR && *ptr <= META_ECLASS_XOR)
  {
  uint32_t op;
  BOOL op_neg;
  BOOL rhs_negated;
  eclass_op_info rhs_op_info;

  if (negated)
    {
    /* The whole expression is being negated; we respond by unconditionally
    negating the LHS A, before seeing what follows. And hooray! We can recover,
    no matter what follows. */
    /* !(A || B)   ->  !A && !B                     */
    /* !(A -- B)   ->  !(A && !B)    ->  !A || B    */
    /* !(A XOR B)  ->  !(!A XOR !B)  ->  !A XNOR !B */
    op = (*ptr == META_ECLASS_OR )? ECL_AND :
         (*ptr == META_ECLASS_SUB)? ECL_OR  :
         /*ptr == META_ECLASS_XOR*/ ECL_XOR;
    op_neg = (*ptr == META_ECLASS_XOR);
    rhs_negated = *ptr != META_ECLASS_SUB;
    }
  else
    {
    /* A || B   ->  A || B  */
    /* A -- B   ->  A && !B */
    /* A XOR B  ->  A XOR B */
    op = (*ptr == META_ECLASS_OR )? ECL_OR  :
         (*ptr == META_ECLASS_SUB)? ECL_AND :
         /*ptr == META_ECLASS_XOR*/ ECL_XOR;
    op_neg = FALSE;
    rhs_negated = *ptr == META_ECLASS_SUB;
    }

  ++ptr;

  /* An operand must follow the operator. */
  if (!compile_class_binary_tight(context, rhs_negated, &ptr, &code,
                                  &rhs_op_info, lengthptr))
    return FALSE;

  /* Convert infix to postfix (RPN). */
  fold_binary(op, pop_info, &rhs_op_info, lengthptr);
  if (op_neg) fold_negation(pop_info, lengthptr, FALSE);
  if (lengthptr == NULL)
    code = pop_info->code_start + pop_info->length;
  }

PCRE2_ASSERT(lengthptr == NULL || code == start_code);

*pptr = ptr;
*pcode = code;
return TRUE;
}



/* This function converts the META codes in pptr into opcodes written to
pcode. The pptr must start at a META_CLASS or META_CLASS_NOT.

The class is compiled as a left-associative sequence of operator
applications.

The pptr will be left pointing at the matching META_CLASS_END. */

static BOOL
compile_eclass_nested(eclass_context *context, BOOL negated,
  uint32_t **pptr, PCRE2_UCHAR **pcode,
  eclass_op_info *pop_info, PCRE2_SIZE *lengthptr)
{
uint32_t *ptr = *pptr;
#ifdef PCRE2_DEBUG
PCRE2_UCHAR *start_code = *pcode;
#endif

/* The CLASS_IS_ECLASS bit must be set since it is a nested class. */
PCRE2_ASSERT(*ptr == (META_CLASS | CLASS_IS_ECLASS) ||
             *ptr == (META_CLASS_NOT | CLASS_IS_ECLASS));

if (*ptr++ == (META_CLASS_NOT | CLASS_IS_ECLASS))
  negated = !negated;

(*pptr)++;

/* Because it's a non-empty class, there must be an operand at the start. */
if (!compile_class_binary_loose(context, negated, pptr, pcode,
                                pop_info, lengthptr))
  return FALSE;

PCRE2_ASSERT(**pptr == META_CLASS_END);
PCRE2_ASSERT(lengthptr == NULL || *pcode == start_code);
return TRUE;
}

BOOL
PRIV(compile_class_nested)(uint32_t options, uint32_t xoptions,
  uint32_t **pptr, PCRE2_UCHAR **pcode, int *errorcodeptr,
  compile_block *cb, PCRE2_SIZE *lengthptr)
{
eclass_context context;
eclass_op_info op_info;
PCRE2_SIZE previous_length = (lengthptr != NULL)? *lengthptr : 0;
PCRE2_UCHAR *code = *pcode;
PCRE2_UCHAR *previous;
BOOL allbitsone = TRUE;

context.needs_bitmap = FALSE;
context.options = options;
context.xoptions = xoptions;
context.errorcodeptr = errorcodeptr;
context.cb = cb;

previous = code;
*code++ = OP_ECLASS;
code += LINK_SIZE;
*code++ = 0;  /* Flags, currently zero. */
if (!compile_eclass_nested(&context, FALSE, pptr, &code, &op_info, lengthptr))
  return FALSE;

if (lengthptr != NULL)
  {
  *lengthptr += code - previous;
  code = previous;
  /* (*lengthptr - previous_length) now holds the amount of buffer that
  we require to make the call to compile_class_nested() with
  lengthptr = NULL, and including the (1+LINK_SIZE+1) that we write out
  before that call. */
  }

/* Do some useful counting of what's in the bitmap. */
for (int i = 0; i < 8; i++)
  if (op_info.bits.classwords[i] != 0xffffffff)
    {
    allbitsone = FALSE;
    break;
    }

/* After constant-folding the extended class syntax, it may turn out to be
a simple class after all. In that case, we can unwrap it from the
OP_ECLASS container - and in fact, we must do so, because in 8-bit
no-Unicode mode the matcher is compiled without support for OP_ECLASS. */

#ifndef SUPPORT_WIDE_CHARS
PCRE2_ASSERT(op_info.op_single_type != 0);
#else
if (op_info.op_single_type != 0)
#endif
  {
  /* Rewind back over the OP_ECLASS. */
  code = previous;

  /* If the bits are all ones, and the "high characters" are all matched
  too, we use a special-cased encoding of OP_ALLANY. */

  if (op_info.op_single_type == ECL_ANY && allbitsone)
    {
    /* Advancing code means rewinding lengthptr, at this point. */
    if (lengthptr != NULL) *lengthptr -= 1;
    *code++ = OP_ALLANY;
    }

  /* If the high bits are all matched / all not-matched, then we emit an
  OP_NCLASS/OP_CLASS respectively. */

  else if (op_info.op_single_type == ECL_ANY ||
           op_info.op_single_type == ECL_NONE)
    {
    PCRE2_SIZE required_len = 1 + (32 / sizeof(PCRE2_UCHAR));

    if (lengthptr != NULL)
      {
      if (required_len > (*lengthptr - previous_length))
      *lengthptr = previous_length + required_len;
      }

    /* Advancing code means rewinding lengthptr, at this point. */
    if (lengthptr != NULL) *lengthptr -= required_len;
    *code++ = (op_info.op_single_type == ECL_ANY)? OP_NCLASS : OP_CLASS;
    memcpy(code, op_info.bits.classbits, 32);
    code += 32 / sizeof(PCRE2_UCHAR);
    }

  /* Otherwise, we have an ECL_XCLASS, so we have the OP_XCLASS data
  there, but, we pulled out its bitmap into op_info, so now we have to
  put that back into the OP_XCLASS. */

  else
    {
#ifndef SUPPORT_WIDE_CHARS
    PCRE2_DEBUG_UNREACHABLE();
#else
    BOOL need_map = context.needs_bitmap;
    PCRE2_SIZE required_len;

    PCRE2_ASSERT(op_info.op_single_type == ECL_XCLASS);
    required_len = op_info.length + (need_map? 32/sizeof(PCRE2_UCHAR) : 0);

    if (lengthptr != NULL)
      {
      /* Don't unconditionally request all the space we need - we may
      already have asked for more during processing of the ECLASS. */
      if (required_len > (*lengthptr - previous_length))
        *lengthptr = previous_length + required_len;

      /* The code we write out here won't be ignored, even during the
      (lengthptr != NULL) phase, because if there's a following quantifier
      it will peek backwards. So we do have to write out a (truncated)
      OP_XCLASS, even on this branch. */
      *lengthptr -= 1 + LINK_SIZE + 1;
      *code++ = OP_XCLASS;
      PUT(code, 0, 1 + LINK_SIZE + 1);
      code += LINK_SIZE;
      *code++ = 0;
      }
    else
      {
      PCRE2_UCHAR *rest;
      PCRE2_SIZE rest_len;
      PCRE2_UCHAR flags;

      /* 1 unit: OP_XCLASS | LINK_SIZE units | 1 unit: flags | ...rest */
      PCRE2_ASSERT(op_info.length >= 1 + LINK_SIZE + 1);
      rest = op_info.code_start + 1 + LINK_SIZE + 1;
      rest_len = (op_info.code_start + op_info.length) - rest;

      /* First read any data we use, before memmove splats it. */
      flags = op_info.code_start[1 + LINK_SIZE];
      PCRE2_ASSERT((flags & XCL_MAP) == 0);

      /* Next do the memmove before any writes. */
      memmove(code + 1 + LINK_SIZE + 1 + (need_map? 32/sizeof(PCRE2_UCHAR) : 0),
              rest, CU2BYTES(rest_len));

      /* Finally write the header data. */
      *code++ = OP_XCLASS;
      PUT(code, 0, (int)required_len);
      code += LINK_SIZE;
      *code++ = flags | (need_map? XCL_MAP : 0);
      if (need_map)
        {
        memcpy(code, op_info.bits.classbits, 32);
        code += 32 / sizeof(PCRE2_UCHAR);
        }
      code += rest_len;
      }
#endif /* SUPPORT_WIDE_CHARS */
    }
  }

/* Otherwise, we're going to keep the OP_ECLASS. However, again we need
to do some adjustment to insert the bitmap if we have one. */

#ifdef SUPPORT_WIDE_CHARS
else
  {
  BOOL need_map = context.needs_bitmap;
  PCRE2_SIZE required_len =
    1 + LINK_SIZE + 1 + (need_map? 32/sizeof(PCRE2_UCHAR) : 0) + op_info.length;

  if (lengthptr != NULL)
    {
    if (required_len > (*lengthptr - previous_length))
      *lengthptr = previous_length + required_len;

    /* As for the XCLASS branch above, we do have to write out a dummy
    OP_ECLASS, because of the backwards peek by the quantifier code. Write
    out a (truncated) OP_ECLASS, even on this branch. */
    *lengthptr -= 1 + LINK_SIZE + 1;
    *code++ = OP_ECLASS;
    PUT(code, 0, 1 + LINK_SIZE + 1);
    code += LINK_SIZE;
    *code++ = 0;
    }
  else
    {
    if (need_map)
      {
      PCRE2_UCHAR *map_start = previous + 1 + LINK_SIZE + 1;
      previous[1 + LINK_SIZE] |= ECL_MAP;
      memmove(map_start + 32/sizeof(PCRE2_UCHAR), map_start,
              CU2BYTES(code - map_start));
      memcpy(map_start, op_info.bits.classbits, 32);
      code += 32 / sizeof(PCRE2_UCHAR);
      }
    PUT(previous, 1, (int)(code - previous));
    }
  }
#endif /* SUPPORT_WIDE_CHARS */

*pcode = code;
return TRUE;
}

/* End of pcre2_compile_class.c */


================================================
FILE: Libraries/PCRE/pcre2_config.c
================================================
/*************************************************
*      Perl-Compatible Regular Expressions       *
*************************************************/

/* PCRE is a library of functions to support regular expressions whose syntax
and semantics are as close as possible to those of the Perl 5 language.

                       Written by Philip Hazel
     Original API code Copyright (c) 1997-2012 University of Cambridge
          New API code Copyright (c) 2016-2020 University of Cambridge

-----------------------------------------------------------------------------
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

    * Redistributions of source code must retain the above copyright notice,
      this list of conditions and the following disclaimer.

    * Redistributions in binary form must reproduce the above copyright
      notice, this list of conditions and the following disclaimer in the
      documentation and/or other materials provided with the distribution.

    * Neither the name of the University of Cambridge nor the names of its
      contributors may be used to endorse or promote products derived from
      this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
-----------------------------------------------------------------------------
*/

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

/* Save the configured link size, which is in bytes. In 16-bit and 32-bit modes
its value gets changed by pcre2_intmodedep.h (included by pcre2_internal.h) to
be in code units. */

static int configured_link_size = LINK_SIZE;

#include "pcre2_internal.h"

/* These macros are the standard way of turning unquoted text into C strings.
They allow macros like PCRE2_MAJOR to be defined without quotes, which is
convenient for user programs that want to test their values. */

#define STRING(a)  # a
#define XSTRING(s) STRING(s)


/*************************************************
* Return info about what features are configured *
*************************************************/

/* If where is NULL, the length of memory required is returned.

Arguments:
  what             what information is required
  where            where to put the information

Returns:           0 if a numerical value is returned
                   >= 0 if a string value
                   PCRE2_ERROR_BADOPTION if "where" not recognized
                     or JIT target requested when JIT not enabled
*/

PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
pcre2_config(uint32_t what, void *where)
{
if (where == NULL)  /* Requests a length */
  {
  switch(what)
    {
    default:
    return PCRE2_ERROR_BADOPTION;

    case PCRE2_CONFIG_BSR:
    case PCRE2_CONFIG_COMPILED_WIDTHS:
    case PCRE2_CONFIG_DEPTHLIMIT:
    case PCRE2_CONFIG_HEAPLIMIT:
    case PCRE2_CONFIG_JIT:
    case PCRE2_CONFIG_LINKSIZE:
    case PCRE2_CONFIG_MATCHLIMIT:
    case PCRE2_CONFIG_NEVER_BACKSLASH_C:
    case PCRE2_CONFIG_NEWLINE:
    case PCRE2_CONFIG_PARENSLIMIT:
    case PCRE2_CONFIG_STACKRECURSE:    /* Obsolete */
    case PCRE2_CONFIG_TABLES_LENGTH:
    case PCRE2_CONFIG_UNICODE:
    return sizeof(uint32_t);

    /* These are handled below */

    case PCRE2_CONFIG_JITTARGET:
    case PCRE2_CONFIG_UNICODE_VERSION:
    case PCRE2_CONFIG_VERSION:
    break;
    }
  }

switch (what)
  {
  default:
  return PCRE2_ERROR_BADOPTION;

  case PCRE2_CONFIG_BSR:
#ifdef BSR_ANYCRLF
  *((uint32_t *)where) = PCRE2_BSR_ANYCRLF;
#else
  *((uint32_t *)where) = PCRE2_BSR_UNICODE;
#endif
  break;

  case PCRE2_CONFIG_COMPILED_WIDTHS:
  *((uint32_t *)where) = 0
#ifdef SUPPORT_PCRE2_8
  + 1
#endif
#ifdef SUPPORT_PCRE2_16
  + 2
#endif
#ifdef SUPPORT_PCRE2_32
  + 4
#endif
  ;
  break;

  case PCRE2_CONFIG_DEPTHLIMIT:
  *((uint32_t *)where) = MATCH_LIMIT_DEPTH;
  break;

  case PCRE2_CONFIG_HEAPLIMIT:
  *((uint32_t *)where) = HEAP_LIMIT;
  break;

  case PCRE2_CONFIG_JIT:
#ifdef SUPPORT_JIT
  *((uint32_t *)where) = 1;
#else
  *((uint32_t *)where) = 0;
#endif
  break;

  case PCRE2_CONFIG_JITTARGET:
#ifdef SUPPORT_JIT
    {
    const char *v = PRIV(jit_get_target)();
    return (int)(1 + ((where == NULL)?
      strlen(v) : PRIV(strcpy_c8)((PCRE2_UCHAR *)where, v)));
    }
#else
  return PCRE2_ERROR_BADOPTION;
#endif

  case PCRE2_CONFIG_LINKSIZE:
  *((uint32_t *)where) = (uint32_t)configured_link_size;
  break;

  case PCRE2_CONFIG_MATCHLIMIT:
  *((uint32_t *)where) = MATCH_LIMIT;
  break;

  case PCRE2_CONFIG_NEWLINE:
  *((uint32_t *)where) = NEWLINE_DEFAULT;
  break;

  case PCRE2_CONFIG_NEVER_BACKSLASH_C:
#ifdef NEVER_BACKSLASH_C
  *((uint32_t *)where) = 1;
#else
  *((uint32_t *)where) = 0;
#endif
  break;

  case PCRE2_CONFIG_PARENSLIMIT:
  *((uint32_t *)where) = PARENS_NEST_LIMIT;
  break;

  /* This is now obsolete. The stack is no longer used via recursion for
  handling backtracking in pcre2_match(). */

  case PCRE2_CONFIG_STACKRECURSE:
  *((uint32_t *)where) = 0;
  break;

  case PCRE2_CONFIG_TABLES_LENGTH:
  *((uint32_t *)where) = TABLES_LENGTH;
  break;

  case PCRE2_CONFIG_UNICODE_VERSION:
    {
#if defined SUPPORT_UNICODE
    const char *v = PRIV(unicode_version);
#else
    const char *v = "Unicode not supported";
#endif
    return (int)(1 + ((where == NULL)?
      strlen(v) : PRIV(strcpy_c8)((PCRE2_UCHAR *)where, v)));
   }
  break;

  case PCRE2_CONFIG_UNICODE:
#if defined SUPPORT_UNICODE
  *((uint32_t *)where) = 1;
#else
  *((uint32_t *)where) = 0;
#endif
  break;

  /* The hackery in setting "v" below is to cope with the case when
  PCRE2_PRERELEASE is set to an empty string (which it is for real releases).
  If the second alternative is used in this case, it does not leave a space
  before the date. On the other hand, if all four macros are put into a single
  XSTRING when PCRE2_PRERELEASE is not empty, an unwanted space is inserted.
  There are problems using an "obvious" approach like this:

     XSTRING(PCRE2_MAJOR) "." XSTRING(PCRE2_MINOR)
     XSTRING(PCRE2_PRERELEASE) " " XSTRING(PCRE2_DATE)

  because, when PCRE2_PRERELEASE is empty, this leads to an attempted expansion
  of STRING(). The C standard states: "If (before argument substitution) any
  argument consists of no preprocessing tokens, the behavior is undefined." It
  turns out the gcc treats this case as a single empty string - which is what
  we really want - but Visual C grumbles about the lack of an argument for the
  macro. Unfortunately, both are within their rights. As there seems to be no
  way to test for a macro's value being empty at compile time, we have to
  resort to a runtime test. */

  case PCRE2_CONFIG_VERSION:
    {
    const char *v = (XSTRING(Z PCRE2_PRERELEASE)[1] == 0)?
      XSTRING(PCRE2_MAJOR.PCRE2_MINOR PCRE2_DATE) :
      XSTRING(PCRE2_MAJOR.PCRE2_MINOR) XSTRING(PCRE2_PRERELEASE PCRE2_DATE);
    return (int)(1 + ((where == NULL)?
      strlen(v) : PRIV(strcpy_c8)((PCRE2_UCHAR *)where, v)));
    }
  }

return 0;
}

/* End of pcre2_config.c */


================================================
FILE: Libraries/PCRE/pcre2_context.c
================================================
/*************************************************
*      Perl-Compatible Regular Expressions       *
*************************************************/

/* PCRE is a library of functions to support regular expressions whose syntax
and semantics are as close as possible to those of the Perl 5 language.

                       Written by Philip Hazel
     Original API code Copyright (c) 1997-2012 University of Cambridge
          New API code Copyright (c) 2016-2024 University of Cambridge

-----------------------------------------------------------------------------
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

    * Redistributions of source code must retain the above copyright notice,
      this list of conditions and the following disclaimer.

    * Redistributions in binary form must reproduce the above copyright
      notice, this list of conditions and the following disclaimer in the
      documentation and/or other materials provided with the distribution.

    * Neither the name of the University of Cambridge nor the names of its
      contributors may be used to endorse or promote products derived from
      this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
-----------------------------------------------------------------------------
*/


#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include "pcre2_internal.h"



/*************************************************
*          Default malloc/free functions         *
*************************************************/

/* Ignore the "user data" argument in each case. */

static void *default_malloc(size_t size, void *data)
{
(void)data;
return malloc(size);
}


static void default_free(void *block, void *data)
{
(void)data;
free(block);
}



/*************************************************
*        Get a block and save memory control     *
*************************************************/

/* This internal function is called to get a block of memory in which the
memory control data is to be stored at the start for future use.

Arguments:
  size        amount of memory required
  memctl      pointer to a memctl block or NULL

Returns:      pointer to memory or NULL on failure
*/

extern void *
PRIV(memctl_malloc)(size_t size, pcre2_memctl *memctl)
{
pcre2_memctl *newmemctl;
void *yield = (memctl == NULL)? malloc(size) :
  memctl->malloc(size, memctl->memory_data);
if (yield == NULL) return NULL;
newmemctl = (pcre2_memctl *)yield;
if (memctl == NULL)
  {
  newmemctl->malloc = default_malloc;
  newmemctl->free = default_free;
  newmemctl->memory_data = NULL;
  }
else *newmemctl = *memctl;
return yield;
}



/*************************************************
*          Create and initialize contexts        *
*************************************************/

/* Initializing for compile and match contexts is done in separate, private
functions so that these can be called from functions such as pcre2_compile()
when an external context is not supplied. The initializing functions have an
option to set up default memory management. */

PCRE2_EXP_DEFN pcre2_general_context * PCRE2_CALL_CONVENTION
pcre2_general_context_create(void *(*private_malloc)(size_t, void *),
  void (*private_free)(void *, void *), void *memory_data)
{
pcre2_general_context *gcontext;
if (private_malloc == NULL) private_malloc = default_malloc;
if (private_free == NULL) private_free = default_free;
gcontext = private_malloc(sizeof(pcre2_real_general_context), memory_data);
if (gcontext == NULL) return NULL;
gcontext->memctl.malloc = private_malloc;
gcontext->memctl.free = private_free;
gcontext->memctl.memory_data = memory_data;
return gcontext;
}


/* A default compile context is set up to save having to initialize at run time
when no context is supplied to the compile function. */

pcre2_compile_context PRIV(default_compile_context) = {
  { default_malloc, default_free, NULL },    /* Default memory handling */
  NULL,                                      /* Stack guard */
  NULL,                                      /* Stack guard data */
  PRIV(default_tables),                      /* Character tables */
  PCRE2_UNSET,                               /* Max pattern length */
  PCRE2_UNSET,                               /* Max pattern compiled length */
  BSR_DEFAULT,                               /* Backslash R default */
  NEWLINE_DEFAULT,                           /* Newline convention */
  PARENS_NEST_LIMIT,                         /* As it says */
  0,                                         /* Extra options */
  MAX_VARLOOKBEHIND,                         /* As it says */
  PCRE2_OPTIMIZATION_ALL                     /* All optimizations enabled */
  };

/* The create function copies the default into the new memory, but must
override the default memory handling functions if a gcontext was provided. */

PCRE2_EXP_DEFN pcre2_compile_context * PCRE2_CALL_CONVENTION
pcre2_compile_context_create(pcre2_general_context *gcontext)
{
pcre2_compile_context *ccontext = PRIV(memctl_malloc)(
  sizeof(pcre2_real_compile_context), (pcre2_memctl *)gcontext);
if (ccontext == NULL) return NULL;
*ccontext = PRIV(default_compile_context);
if (gcontext != NULL)
  *((pcre2_memctl *)ccontext) = *((pcre2_memctl *)gcontext);
return ccontext;
}


/* A default match context is set up to save having to initialize at run time
when no context is supplied to a match function. */

pcre2_match_context PRIV(default_match_context) = {
  { default_malloc, default_free, NULL },
#ifdef SUPPORT_JIT
  NULL,          /* JIT callback */
  NULL,          /* JIT callback data */
#endif
  NULL,          /* Callout function */
  NULL,          /* Callout data */
  NULL,          /* Substitute callout function */
  NULL,          /* Substitute callout data */
  NULL,          /* Substitute case callout function */
  NULL,          /* Substitute case callout data */
  PCRE2_UNSET,   /* Offset limit */
  HEAP_LIMIT,
  MATCH_LIMIT,
  MATCH_LIMIT_DEPTH };

/* The create function copies the default into the new memory, but must
override the default memory handling functions if a gcontext was provided. */

PCRE2_EXP_DEFN pcre2_match_context * PCRE2_CALL_CONVENTION
pcre2_match_context_create(pcre2_general_context *gcontext)
{
pcre2_match_context *mcontext = PRIV(memctl_malloc)(
  sizeof(pcre2_real_match_context), (pcre2_memctl *)gcontext);
if (mcontext == NULL) return NULL;
*mcontext = PRIV(default_match_context);
if (gcontext != NULL)
  *((pcre2_memctl *)mcontext) = *((pcre2_memctl *)gcontext);
return mcontext;
}


/* A default convert context is set up to save having to initialize at run time
when no context is supplied to the convert function. */

pcre2_convert_context PRIV(default_convert_context) = {
  { default_malloc, default_free, NULL },    /* Default memory handling */
#ifdef _WIN32
  CHAR_BACKSLASH,                            /* Default path separator */
  CHAR_GRAVE_ACCENT                          /* Default escape character */
#else  /* Not Windows */
  CHAR_SLASH,                                /* Default path separator */
  CHAR_BACKSLASH                             /* Default escape character */
#endif
  };

/* The create function copies the default into the new memory, but must
override the default memory handling functions if a gcontext was provided. */

PCRE2_EXP_DEFN pcre2_convert_context * PCRE2_CALL_CONVENTION
pcre2_convert_context_create(pcre2_general_context *gcontext)
{
pcre2_convert_context *ccontext = PRIV(memctl_malloc)(
  sizeof(pcre2_real_convert_context), (pcre2_memctl *)gcontext);
if (ccontext == NULL) return NULL;
*ccontext = PRIV(default_convert_context);
if (gcontext != NULL)
  *((pcre2_memctl *)ccontext) = *((pcre2_memctl *)gcontext);
return ccontext;
}


/*************************************************
*              Context copy functions            *
*************************************************/

PCRE2_EXP_DEFN pcre2_general_context * PCRE2_CALL_CONVENTION
pcre2_general_context_copy(pcre2_general_context *gcontext)
{
pcre2_general_context *newcontext =
  gcontext->memctl.malloc(sizeof(pcre2_real_general_context),
  gcontext->memctl.memory_data);
if (newcontext == NULL) return NULL;
memcpy(newcontext, gcontext, sizeof(pcre2_real_general_context));
return newcontext;
}


PCRE2_EXP_DEFN pcre2_compile_context * PCRE2_CALL_CONVENTION
pcre2_compile_context_copy(pcre2_compile_context *ccontext)
{
pcre2_compile_context *newcontext =
  ccontext->memctl.malloc(sizeof(pcre2_real_compile_context),
  ccontext->memctl.memory_data);
if (newcontext == NULL) return NULL;
memcpy(newcontext, ccontext, sizeof(pcre2_real_compile_context));
return newcontext;
}


PCRE2_EXP_DEFN pcre2_match_context * PCRE2_CALL_CONVENTION
pcre2_match_context_copy(pcre2_match_context *mcontext)
{
pcre2_match_context *newcontext =
  mcontext->memctl.malloc(sizeof(pcre2_real_match_context),
  mcontext->memctl.memory_data);
if (newcontext == NULL) return NULL;
memcpy(newcontext, mcontext, sizeof(pcre2_real_match_context));
return newcontext;
}


PCRE2_EXP_DEFN pcre2_convert_context * PCRE2_CALL_CONVENTION
pcre2_convert_context_copy(pcre2_convert_context *ccontext)
{
pcre2_convert_context *newcontext =
  ccontext->memctl.malloc(sizeof(pcre2_real_convert_context),
  ccontext->memctl.memory_data);
if (newcontext == NULL) return NULL;
memcpy(newcontext, ccontext, sizeof(pcre2_real_convert_context));
return newcontext;
}


/*************************************************
*              Context free functions            *
*************************************************/

PCRE2_EXP_DEFN void PCRE2_CALL_CONVENTION
pcre2_general_context_free(pcre2_general_context *gcontext)
{
if (gcontext != NULL)
  gcontext->memctl.free(gcontext, gcontext->memctl.memory_data);
}


PCRE2_EXP_DEFN void PCRE2_CALL_CONVENTION
pcre2_compile_context_free(pcre2_compile_context *ccontext)
{
if (ccontext != NULL)
  ccontext->memctl.free(ccontext, ccontext->memctl.memory_data);
}


PCRE2_EXP_DEFN void PCRE2_CALL_CONVENTION
pcre2_match_context_free(pcre2_match_context *mcontext)
{
if (mcontext != NULL)
  mcontext->memctl.free(mcontext, mcontext->memctl.memory_data);
}


PCRE2_EXP_DEFN void PCRE2_CALL_CONVENTION
pcre2_convert_context_free(pcre2_convert_context *ccontext)
{
if (ccontext != NULL)
  ccontext->memctl.free(ccontext, ccontext->memctl.memory_data);
}


/*************************************************
*             Set values in contexts             *
*************************************************/

/* All these functions return 0 for success or PCRE2_ERROR_BADDATA if invalid
data is given. Only some of the functions are able to test the validity of the
data. */


/* ------------ Compile context ------------ */

PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
pcre2_set_character_tables(pcre2_compile_context *ccontext,
  const uint8_t *tables)
{
ccontext->tables = tables;
return 0;
}

PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
pcre2_set_bsr(pcre2_compile_context *ccontext, uint32_t value)
{
switch(value)
  {
  case PCRE2_BSR_ANYCRLF:
  case PCRE2_BSR_UNICODE:
  ccontext->bsr_convention = value;
  return 0;

  default:
  return PCRE2_ERROR_BADDATA;
  }
}

PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
pcre2_set_max_pattern_length(pcre2_compile_context *ccontext, PCRE2_SIZE length)
{
ccontext->max_pattern_length = length;
return 0;
}

PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
pcre2_set_max_pattern_compiled_length(pcre2_compile_context *ccontext, PCRE2_SIZE length)
{
ccontext->max_pattern_compiled_length = length;
return 0;
}

PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
pcre2_set_newline(pcre2_compile_context *ccontext, uint32_t newline)
{
switch(newline)
  {
  case PCRE2_NEWLINE_CR:
  case PCRE2_NEWLINE_LF:
  case PCRE2_NEWLINE_CRLF:
  case PCRE2_NEWLINE_ANY:
  case PCRE2_NEWLINE_ANYCRLF:
  case PCRE2_NEWLINE_NUL:
  ccontext->newline_convention = newline;
  return 0;

  default:
  return PCRE2_ERROR_BADDATA;
  }
}

PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
pcre2_set_max_varlookbehind(pcre2_compile_context *ccontext, uint32_t limit)
{
ccontext->max_varlookbehind = limit;
return 0;
}

PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
pcre2_set_parens_nest_limit(pcre2_compile_context *ccontext, uint32_t limit)
{
ccontext->parens_nest_limit = limit;
return 0;
}

PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
pcre2_set_compile_extra_options(pcre2_compile_context *ccontext, uint32_t options)
{
ccontext->extra_options = options;
return 0;
}

PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
pcre2_set_compile_recursion_guard(pcre2_compile_context *ccontext,
  int (*guard)(uint32_t, void *), void *user_data)
{
ccontext->stack_guard = guard;
ccontext->stack_guard_data = user_data;
return 0;
}

PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
pcre2_set_optimize(pcre2_compile_context *ccontext, uint32_t directive)
{
if (ccontext == NULL)
  return PCRE2_ERROR_NULL;

switch (directive)
  {
  case PCRE2_OPTIMIZATION_NONE:
  ccontext->optimization_flags = 0;
  break;

  case PCRE2_OPTIMIZATION_FULL:
  ccontext->optimization_flags = PCRE2_OPTIMIZATION_ALL;
  break;

  default:
  if (directive >= PCRE2_AUTO_POSSESS && directive <= PCRE2_START_OPTIMIZE_OFF)
    {
    /* Even directive numbers starting from 64 switch a bit on;
     * Odd directive numbers starting from 65 switch a bit off */
    if ((directive & 1) != 0)
      ccontext->optimization_flags &= ~(1u << ((directive >> 1) - 32));
    else
      ccontext->optimization_flags |= 1u << ((directive >> 1) - 32);
    return 0;
    }
  return PCRE2_ERROR_BADOPTION;
  }

return 0;
}

/* ------------ Match context ------------ */

PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
pcre2_set_callout(pcre2_match_context *mcontext,
  int (*callout)(pcre2_callout_block *, void *), void *callout_data)
{
mcontext->callout = callout;
mcontext->callout_data = callout_data;
return 0;
}

PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
pcre2_set_substitute_callout(pcre2_match_context *mcontext,
  int (*substitute_callout)(pcre2_substitute_callout_block *, void *),
  void *substitute_callout_data)
{
mcontext->substitute_callout = substitute_callout;
mcontext->substitute_callout_data = substitute_callout_data;
return 0;
}

PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
pcre2_set_substitute_case_callout(pcre2_match_context *mcontext,
  PCRE2_SIZE (*substitute_case_callout)(PCRE2_SPTR, PCRE2_SIZE, PCRE2_UCHAR *,
                                        PCRE2_SIZE, int, void *),
  void *substitute_case_callout_data)
{
mcontext->substitute_case_callout = substitute_case_callout;
mcontext->substitute_case_callout_data = substitute_case_callout_data;
return 0;
}

PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
pcre2_set_heap_limit(pcre2_match_context *mcontext, uint32_t limit)
{
mcontext->heap_limit = limit;
return 0;
}

PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
pcre2_set_match_limit(pcre2_match_context *mcontext, uint32_t limit)
{
mcontext->match_limit = limit;
return 0;
}

PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
pcre2_set_depth_limit(pcre2_match_context *mcontext, uint32_t limit)
{
mcontext->depth_limit = limit;
return 0;
}

PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
pcre2_set_offset_limit(pcre2_match_context *mcontext, PCRE2_SIZE limit)
{
mcontext->offset_limit = limit;
return 0;
}

/* These functions became obsolete at release 10.30. The first is kept as a
synonym for backwards compatibility. The second now does nothing. Exclude both
from coverage reports. */

/* LCOV_EXCL_START */

PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
pcre2_set_recursion_limit(pcre2_match_context *mcontext, uint32_t limit)
{
return pcre2_set_depth_limit(mcontext, limit);
}

PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
pcre2_set_recursion_memory_management(pcre2_match_context *mcontext,
  void *(*mymalloc)(size_t, void *), void (*myfree)(void *, void *),
  void *mydata)
{
(void)mcontext;
(void)mymalloc;
(void)myfree;
(void)mydata;
return 0;
}

/* LCOV_EXCL_STOP */


/* ------------ Convert context ------------ */

PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
pcre2_set_glob_separator(pcre2_convert_context *ccontext, uint32_t separator)
{
if (separator != CHAR_SLASH && separator != CHAR_BACKSLASH &&
    separator != CHAR_DOT) return PCRE2_ERROR_BADDATA;
ccontext->glob_separator = separator;
return 0;
}

PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
pcre2_set_glob_escape(pcre2_convert_context *ccontext, uint32_t escape)
{
if (escape > 255 || (escape != 0 && !ispunct(escape)))
  return PCRE2_ERROR_BADDATA;
ccontext->glob_escape = escape;
return 0;
}

/* End of pcre2_context.c */



================================================
FILE: Libraries/PCRE/pcre2_error.c
================================================
/*************************************************
*      Perl-Compatible Regular Expressions       *
*************************************************/

/* PCRE is a library of functions to support regular expressions whose syntax
and semantics are as close as possible to those of the Perl 5 language.

                       Written by Philip Hazel
     Original API code Copyright (c) 1997-2012 University of Cambridge
          New API code Copyright (c) 2016-2024 University of Cambridge

-----------------------------------------------------------------------------
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

    * Redistributions of source code must retain the above copyright notice,
      this list of conditions and the following disclaimer.

    * Redistributions in binary form must reproduce the above copyright
      notice, this list of conditions and the following disclaimer in the
      documentation and/or other materials provided with the distribution.

    * Neither the name of the University of Cambridge nor the names of its
      contributors may be used to endorse or promote products derived from
      this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
-----------------------------------------------------------------------------
*/


#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include "pcre2_internal.h"

#define STRING(a)  # a
#define XSTRING(s) STRING(s)

/* The texts of compile-time error messages. Compile-time error numbers start
at COMPILE_ERROR_BASE (100).

This used to be a table of strings, but in order to reduce the number of
relocations needed when a shared library is loaded dynamically, it is now one
long string. We cannot use a table of offsets, because the lengths of inserts
such as XSTRING(MAX_NAME_SIZE) are not known. Instead,
pcre2_get_error_message() counts through to the one it wants - this isn't a
performance issue because these strings are used only when there is an error.

Each substring ends with \0 to insert a null character. This includes the final
substring, so that the whole string ends with \0\0, which can be detected when
counting through. */

static const unsigned char compile_error_texts[] =
  "no error\0"
  "\\ at end of pattern\0"
  "\\c at end of pattern\0"
  "unrecognized character follows \\\0"
  "numbers out of order in {} quantifier\0"
  /* 5 */
  "number too big in {} quantifier\0"
  "missing terminating ] for character class\0"
  "escape sequence is invalid in character class\0"
  "range out of order in character class\0"
  "quantifier does not follow a repeatable item\0"
  /* 10 */
  "internal error: unexpected repeat\0"
  "unrecognized character after (? or (?-\0"
  "POSIX named classes are supported only within a class\0"
  "POSIX collating elements are not supported\0"
  "missing closing parenthesis\0"
  /* 15 */
  "reference to non-existent subpattern\0"
  "pattern passed as NULL with non-zero length\0"
  "unrecognised compile-time option bit(s)\0"
  "missing ) after (?# comment\0"
  "parentheses are too deeply nested\0"
  /* 20 */
  "regular expression is too large\0"
  "failed to allocate heap memory\0"
  "unmatched closing parenthesis\0"
  "internal error: code overflow\0"
  "missing closing parenthesis for condition\0"
  /* 25 */
  "length of lookbehind assertion is not limited\0"
  "a relative value of zero is not allowed\0"
  "conditional subpattern contains more than two branches\0"
  "atomic assertion expected after (?( or (?(?C)\0"
  "digit expected after (?+ or (?-\0"
  /* 30 */
  "unknown POSIX class name\0"
  "internal error in pcre2_study(): should not occur\0"
  "this version of PCRE2 does not have Unicode support\0"
  "parentheses are too deeply nested (stack check)\0"
  "character code point value in \\x{} or \\o{} is too large\0"
  /* 35 */
  "lookbehind is too complicated\0"
  "\\C is not allowed in a lookbehind assertion in UTF-" XSTRING(PCRE2_CODE_UNIT_WIDTH) " mode\0"
  "PCRE2 does not support \\F, \\L, \\l, \\N{name}, \\U, or \\u\0"
  "number after (?C is greater than 255\0"
  "closing parenthesis for (?C expected\0"
  /* 40 */
  "invalid escape sequence in (*VERB) name\0"
  "unrecognized character after (?P\0"
  "syntax error in subpattern name (missing terminator?)\0"
  "two named subpatterns have the same name (PCRE2_DUPNAMES not set)\0"
  "subpattern name must start with a non-digit\0"
  /* 45 */
  "this version of PCRE2 does not have support for \\P, \\p, or \\X\0"
  "malformed \\P or \\p sequence\0"
  "unknown property after \\P or \\p\0"
  "subpattern name is too long (maximum " XSTRING(MAX_NAME_SIZE) " code units)\0"
  "too many named subpatterns (maximum " XSTRING(MAX_NAME_COUNT) ")\0"
  /* 50 */
  "invalid range in character class\0"
  "octal value is greater than \\377 in 8-bit non-UTF-8 mode\0"
  "internal error: overran compiling workspace\0"
  "internal error: previously-checked referenced subpattern not found\0"
  "DEFINE subpattern contains more than one branch\0"
  /* 55 */
  "missing opening brace after \\o\0"
  "internal error: unknown newline setting\0"
  "\\g is not followed by a braced, angle-bracketed, or quoted name/number or by a plain number\0"
  "(?R (recursive pattern call) must be followed by a closing parenthesis\0"
  /* "an argument is not allowed for (*ACCEPT), (*FAIL), or (*COMMIT)\0" */
  "obsolete error (should not occur)\0"  /* Was the above */
  /* 60 */
  "(*VERB) not recognized or malformed\0"
  "subpattern number is too big\0"
  "subpattern name expected\0"
  "internal error: parsed pattern overflow\0"
  "non-octal character in \\o{} (closing brace missing?)\0"
  /* 65 */
  "different names for subpatterns of the same number are not allowed\0"
  "(*MARK) must have an argument\0"
  "non-hex character in \\x{} (closing brace missing?)\0"
#ifndef EBCDIC
  "\\c must be followed by a printable ASCII character\0"
#else
  "\\c must be followed by a letter or one of [\\]^_?\0"
#endif
  "\\k is not followed by a braced, angle-bracketed, or quoted name\0"
  /* 70 */
  "internal error: unknown meta code in check_lookbehinds()\0"
  "\\N is not supported in a class\0"
  "callout string is too long\0"
  "disallowed Unicode code point (>= 0xd800 && <= 0xdfff)\0"
  "using UTF is disabled by the application\0"
  /* 75 */
  "using UCP is disabled by the application\0"
  "name is too long in (*MARK), (*PRUNE), (*SKIP), or (*THEN)\0"
  "character code point value in \\u.... sequence is too large\0"
  "digits missing after \\x or in \\x{} or \\o{} or \\N{U+}\0"
  "syntax error or number too big in (?(VERSION condition\0"
  /* 80 */
  "internal error: unknown opcode in auto_possessify()\0"
  "missing terminating delimiter for callout with string argument\0"
  "unrecognized string delimiter follows (?C\0"
  "using \\C is disabled by the application\0"
  "(?| and/or (?J: or (?x: parentheses are too deeply nested\0"
  /* 85 */
  "using \\C is disabled in this PCRE2 library\0"
  "regular expression is too complicated\0"
  "lookbehind assertion is too long\0"
  "pattern string is longer than the limit set by the application\0"
  "internal error: unknown code in parsed pattern\0"
  /* 90 */
  "internal error: bad code value in parsed_skip()\0"
  "PCRE2_EXTRA_ALLOW_SURROGATE_ESCAPES is not allowed in UTF-16 mode\0"
  "invalid option bits with PCRE2_LITERAL\0"
  "\\N{U+dddd} is supported only in Unicode (UTF) mode\0"
  "invalid hyphen in option setting\0"
  /* 95 */
  "(*alpha_assertion) not recognized\0"
  "script runs require Unicode support, which this version of PCRE2 does not have\0"
  "too many capturing groups (maximum 65535)\0"
  "octal digit missing after \\0 (PCRE2_EXTRA_NO_BS0 is set)\0"
  "\\K is not allowed in lookarounds (but see PCRE2_EXTRA_ALLOW_LOOKAROUND_BSK)\0"
  /* 100 */
  "branch too long in variable-length lookbehind assertion\0"
  "compiled pattern would be longer than the limit set by the application\0"
  "octal value given by \\ddd is greater than \\377 (forbidden by PCRE2_EXTRA_PYTHON_OCTAL)\0"
  "using callouts is disabled by the application\0"
  "PCRE2_EXTRA_TURKISH_CASING require Unicode (UTF or UCP) mode\0"
  /* 105 */
  "PCRE2_EXTRA_TURKISH_CASING requires UTF in 8-bit mode\0"
  "PCRE2_EXTRA_TURKISH_CASING and PCRE2_EXTRA_CASELESS_RESTRICT are not compatible\0"
  "extended character class nesting is too deep\0"
  "invalid operator in extended character class\0"
  "unexpected operator in extended character class (no preceding operand)\0"
  /* 110 */
  "expected operand after operator in extended character class\0"
  "square brackets needed to clarify operator precedence in extended character class\0"
  "missing terminating ] for extended character class (note '[' must be escaped under PCRE2_ALT_EXTENDED_CLASS)\0"
  "unexpected expression in extended character class (no preceding operator)\0"
  "empty expression in extended character class\0"
  /* 115 */
  "terminating ] with no following closing parenthesis in (?[...]\0"
  "unexpected character in (?[...]) extended character class\0"
  ;

/* Match-time and UTF error texts are in the same format. */

static const unsigned char match_error_texts[] =
  "no error\0"
  "no match\0"
  "partial match\0"
  "UTF-8 error: 1 byte missing at end\0"
  "UTF-8 error: 2 bytes missing at end\0"
  /* 5 */
  "UTF-8 error: 3 bytes missing at end\0"
  "UTF-8 error: 4 bytes missing at end\0"
  "UTF-8 error: 5 bytes missing at end\0"
  "UTF-8 error: byte 2 top bits not 0x80\0"
  "UTF-8 error: byte 3 top bits not 0x80\0"
  /* 10 */
  "UTF-8 error: byte 4 top bits not 0x80\0"
  "UTF-8 error: byte 5 top bits not 0x80\0"
  "UTF-8 error: byte 6 top bits not 0x80\0"
  "UTF-8 error: 5-byte character is not allowed (RFC 3629)\0"
  "UTF-8 error: 6-byte character is not allowed (RFC 3629)\0"
  /* 15 */
  "UTF-8 error: code points greater than 0x10ffff are not defined\0"
  "UTF-8 error: code points 0xd800-0xdfff are not defined\0"
  "UTF-8 error: overlong 2-byte sequence\0"
  "UTF-8 error: overlong 3-byte sequence\0"
  "UTF-8 error: overlong 4-byte sequence\0"
  /* 20 */
  "UTF-8 error: overlong 5-byte sequence\0"
  "UTF-8 error: overlong 6-byte sequence\0"
  "UTF-8 error: isolated byte with 0x80 bit set\0"
  "UTF-8 error: illegal byte (0xfe or 0xff)\0"
  "UTF-16 error: missing low surrogate at end\0"
  /* 25 */
  "UTF-16 error: invalid low surrogate\0"
  "UTF-16 error: isolated low surrogate\0"
  "UTF-32 error: code points 0xd800-0xdfff are not defined\0"
  "UTF-32 error: code points greater than 0x10ffff are not defined\0"
  "bad data value\0"
  /* 30 */
  "patterns do not all use the same character tables\0"
  "magic number missing\0"
  "pattern compiled in wrong mode: 8/16/32-bit error\0"
  "bad offset value\0"
  "bad option value\0"
  /* 35 */
  "invalid replacement string\0"
  "bad offset into UTF string\0"
  "callout error code\0"              /* Never returned by PCRE2 itself */
  "invalid data in workspace for DFA restart\0"
  "too much recursion for DFA matching\0"
  /* 40 */
  "backreference condition or recursion test is not supported for DFA matching\0"
  "function is not supported for DFA matching\0"
  "pattern contains an item that is not supported for DFA matching\0"
  "workspace size exceeded in DFA matching\0"
  "internal error - pattern overwritten?\0"
  /* 45 */
  "bad JIT option\0"
  "JIT stack limit reached\0"
  "match limit exceeded\0"
  "no more memory\0"
  "unknown substring\0"
  /* 50 */
  "non-unique substring name\0"
  "NULL argument passed with non-zero length\0"
  "nested recursion at the same subject position\0"
  "matching depth limit exceeded\0"
  "requested value is not available\0"
  /* 55 */
  "requested value is not set\0"
  "offset limit set without PCRE2_USE_OFFSET_LIMIT\0"
  "bad escape sequence in replacement string\0"
  "expected closing curly bracket in replacement string\0"
  "bad substitution in replacement string\0"
  /* 60 */
  "match with end before start or start moved backwards is not supported\0"
  "too many replacements (more than INT_MAX)\0"
  "bad serialized data\0"
  "heap limit exceeded\0"
  "invalid syntax\0"
  /* 65 */
  "internal error - duplicate substitution match\0"
  "PCRE2_MATCH_INVALID_UTF is not supported for DFA matching\0"
  "INTERNAL ERROR: invalid substring offset\0"
  "feature is not supported by the JIT compiler\0"
  "error performing replacement case transformation\0"
  /* 70 */
  "replacement too large (longer than PCRE2_SIZE)\0"
  ;


/*************************************************
*            Return error message                *
*************************************************/

/* This function copies an error message into a buffer whose units are of an
appropriate width. Error numbers are positive for compile-time errors, and
negative for match-time errors (except for UTF errors), but the numbers are all
distinct.

Arguments:
  enumber       error number
  buffer        where to put the message (zero terminated)
  size          size of the buffer in code units

Returns:        length of message if all is well
                negative on error
*/

PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
pcre2_get_error_message(int enumber, PCRE2_UCHAR *buffer, PCRE2_SIZE size)
{
const unsigned char *message;
PCRE2_SIZE i;
int n;

if (size == 0) return PCRE2_ERROR_NOMEMORY;

if (enumber >= COMPILE_ERROR_BASE)  /* Compile error */
  {
  message = compile_error_texts;
  n = enumber - COMPILE_ERROR_BASE;
  }
else if (enumber < 0)               /* Match or UTF error */
  {
  message = match_error_texts;
  n = -enumber;
  }
else                                /* Invalid error number */
  {
  message = (const unsigned char *)"\0";  /* Empty message list */
  n = 1;
  }

for (; n > 0; n--)
  {
  while (*message++ != CHAR_NUL) {};
  if (*message == CHAR_NUL) return PCRE2_ERROR_BADDATA;
  }

for (i = 0; *message != 0; i++)
  {
  if (i >= size - 1)
    {
    buffer[i] = 0;     /* Terminate partial message */
    return PCRE2_ERROR_NOMEMORY;
    }
  buffer[i] = *message++;
  }

buffer[i] = 0;
return (int)i;
}

/* End of pcre2_error.c */


================================================
FILE: Libraries/PCRE/pcre2_extuni.c
================================================
/*************************************************
*      Perl-Compatible Regular Expressions       *
*************************************************/

/* PCRE is a library of functions to support regular expressions whose syntax
and semantics are as close as possible to those of the Perl 5 language.

                       Written by Philip Hazel
     Original API code Copyright (c) 1997-2012 University of Cambridge
          New API code Copyright (c) 2016-2024 University of Cambridge

-----------------------------------------------------------------------------
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

    * Redistributions of source code must retain the above copyright notice,
      this list of conditions and the following disclaimer.

    * Redistributions in binary form must reproduce the above copyright
      notice, this list of conditions and the following disclaimer in the
      documentation and/or other materials provided with the distribution.

    * Neither the name of the University of Cambridge nor the names of its
      contributors may be used to endorse or promote products derived from
      this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
-----------------------------------------------------------------------------
*/

/* This module contains an internal function that is used to match a Unicode
extended grapheme sequence. It is used by both pcre2_match() and
pcre2_dfa_match(). However, it is called only when Unicode support is being
compiled. Nevertheless, we provide a dummy function when there is no Unicode
support, because some compilers do not like functionless source files. */


#ifdef HAVE_CONFIG_H
#include "config.h"
#endif


#include "pcre2_internal.h"


/* Dummy function */

#ifndef SUPPORT_UNICODE
PCRE2_SPTR
PRIV(extuni)(uint32_t c, PCRE2_SPTR eptr, PCRE2_SPTR start_subject,
  PCRE2_SPTR end_subject, BOOL utf, int *xcount)
{
(void)c;
(void)eptr;
(void)start_subject;
(void)end_subject;
(void)utf;
(void)xcount;
return NULL;
}
#else


/*************************************************
*      Match an extended grapheme sequence       *
*************************************************/

/* NOTE: The logic contained in this function is replicated in three special-
purpose functions in the pcre2_jit_compile.c module. If the logic below is
changed, they must be kept in step so that the interpreter and the JIT have the
same behaviour.

Arguments:
  c              the first character
  eptr           pointer to next character
  start_subject  pointer to start of subject
  end_subject    pointer to end of subject
  utf            TRUE if in UTF mode
  xcount         pointer to count of additional characters,
                   or NULL if count not needed

Returns:         pointer after the end of the sequence
*/

PCRE2_SPTR
PRIV(extuni)(uint32_t c, PCRE2_SPTR eptr, PCRE2_SPTR start_subject,
  PCRE2_SPTR end_subject, BOOL utf, int *xcount)
{
BOOL was_ep_ZWJ = FALSE;
int lgb = UCD_GRAPHBREAK(c);

while (eptr < end_subject)
  {
  int rgb;
  int len = 1;
  if (!utf) c = *eptr; else { GETCHARLEN(c, eptr, len); }
  rgb = UCD_GRAPHBREAK(c);
  if ((PRIV(ucp_gbtable)[lgb] & (1u << rgb)) == 0) break;

  /* ZWJ followed by Extended Pictographic is allowed only if the ZWJ was
  preceded by Extended Pictographic. */

  if (lgb == ucp_gbZWJ && rgb == ucp_gbExtended_Pictographic && !was_ep_ZWJ)
    break;

  /* Not breaking between Regional Indicators is allowed only if there
  are an even number of preceding RIs. */

  if (lgb == ucp_gbRegional_Indicator && rgb == ucp_gbRegional_Indicator)
    {
    int ricount = 0;
    PCRE2_SPTR bptr = eptr - 1;
    if (utf) BACKCHAR(bptr);

    /* bptr is pointing to the left-hand character */

    while (bptr > start_subject)
      {
      bptr--;
      if (utf)
        {
        BACKCHAR(bptr);
        GETCHAR(c, bptr);
        }
      else
      c = *bptr;
      if (UCD_GRAPHBREAK(c) != ucp_gbRegional_Indicator) break;
      ricount++;
      }
    if ((ricount & 1) != 0) break;  /* Grapheme break required */
    }

  /* Set a flag when ZWJ follows Extended Pictographic (with optional Extend in
  between; see next statement). */

  was_ep_ZWJ = (lgb == ucp_gbExtended_Pictographic && rgb == ucp_gbZWJ);

  /* If Extend follows Extended_Pictographic, do not update lgb; this allows
  any number of them before a following ZWJ. */

  if (rgb != ucp_gbExtend || lgb != ucp_gbExtended_Pictographic) lgb = rgb;

  eptr += len;
  if (xcount != NULL) *xcount += 1;
  }

return eptr;
}

#endif  /* SUPPORT_UNICODE */

/* End of pcre2_extuni.c */


================================================
FILE: Libraries/PCRE/pcre2_find_bracket.c
================================================
/*************************************************
*      Perl-Compatible Regular Expressions       *
*************************************************/

/* PCRE is a library of functions to support regular expressions whose syntax
and semantics are as close as possible to those of the Perl 5 language.

                       Written by Philip Hazel
     Original API code Copyright (c) 1997-2012 University of Cambridge
          New API code Copyright (c) 2016-2024 University of Cambridge

-----------------------------------------------------------------------------
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

    * Redistributions of source code must retain the above copyright notice,
      this list of conditions and the following disclaimer.

    * Redistributions in binary form must reproduce the above copyright
      notice, this list of conditions and the following disclaimer in the
      documentation and/or other materials provided with the distribution.

    * Neither the name of the University of Cambridge nor the names of its
      contributors may be used to endorse or promote products derived from
      this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
-----------------------------------------------------------------------------
*/


/* This module contains a single function that scans through a compiled pattern
until it finds a capturing bracket with the given number, or, if the number is
negative, an instance of OP_REVERSE or OP_VREVERSE for a lookbehind. The
function is called from pcre2_compile.c and also from pcre2_study.c when
finding the minimum matching length. */


#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include "pcre2_internal.h"


/*************************************************
*    Scan compiled regex for specific bracket    *
*************************************************/

/*
Arguments:
  code        points to start of expression
  utf         TRUE in UTF mode
  number      the required bracket number or negative to find a lookbehind

Returns:      pointer to the opcode for the bracket, or NULL if not found
*/

PCRE2_SPTR
PRIV(find_bracket)(PCRE2_SPTR code, BOOL utf, int number)
{
for (;;)
  {
  PCRE2_UCHAR c = *code;

  if (c == OP_END) return NULL;

  /* XCLASS is used for classes that cannot be represented just by a bit map.
  This includes negated single high-valued characters. ECLASS is used for
  classes that use set operations internally. CALLOUT_STR is used for
  callouts with string arguments. In each case the length in the table is
  zero; the actual length is stored in the compiled code. */

  if (c == OP_XCLASS || c == OP_ECLASS) code += GET(code, 1);
  else if (c == OP_CALLOUT_STR) code += GET(code, 1 + 2*LINK_SIZE);

  /* Handle lookbehind */

  else if (c == OP_REVERSE || c == OP_VREVERSE)
    {
    if (number < 0) return code;
    code += PRIV(OP_lengths)[c];
    }

  /* Handle capturing bracket */

  else if (c == OP_CBRA || c == OP_SCBRA ||
           c == OP_CBRAPOS || c == OP_SCBRAPOS)
    {
    int n = (int)GET2(code, 1+LINK_SIZE);
    if (n == number) return code;
    code += PRIV(OP_lengths)[c];
    }

  /* Otherwise, we can get the item's length from the table, except that for
  repeated character types, we have to test for \p and \P, which have an extra
  two bytes of parameters, and for MARK/PRUNE/SKIP/THEN with an argument, we
  must add in its length. */

  else
    {
    switch(c)
      {
      case OP_TYPESTAR:
      case OP_TYPEMINSTAR:
      case OP_TYPEPLUS:
      case OP_TYPEMINPLUS:
      case OP_TYPEQUERY:
      case OP_TYPEMINQUERY:
      case OP_TYPEPOSSTAR:
      case OP_TYPEPOSPLUS:
      case OP_TYPEPOSQUERY:
      if (code[1] == OP_PROP || code[1] == OP_NOTPROP) code += 2;
      break;

      case OP_TYPEUPTO:
      case OP_TYPEMINUPTO:
      case OP_TYPEEXACT:
      case OP_TYPEPOSUPTO:
      if (code[1 + IMM2_SIZE] == OP_PROP || code[1 + IMM2_SIZE] == OP_NOTPROP)
        code += 2;
      break;

      case OP_MARK:
      case OP_COMMIT_ARG:
      case OP_PRUNE_ARG:
      case OP_SKIP_ARG:
      case OP_THEN_ARG:
      code += code[1];
      break;
      }

    /* Add in the fixed length from the table */

    code += PRIV(OP_lengths)[c];

  /* In UTF-8 and UTF-16 modes, opcodes that are followed by a character may be
  followed by a multi-byte character. The length in the table is a minimum, so
  we have to arrange to skip the extra bytes. */

#ifdef MAYBE_UTF_MULTI
    if (utf) switch(c)
      {
      case OP_CHAR:
      case OP_CHARI:
      case OP_NOT:
      case OP_NOTI:
      case OP_EXACT:
      case OP_EXACTI:
      case OP_NOTEXACT:
      case OP_NOTEXACTI:
      case OP_UPTO:
      case OP_UPTOI:
      case OP_NOTUPTO:
      case OP_NOTUPTOI:
      case OP_MINUPTO:
      case OP_MINUPTOI:
      case OP_NOTMINUPTO:
      case OP_NOTMINUPTOI:
      case OP_POSUPTO:
      case OP_POSUPTOI:
      case OP_NOTPOSUPTO:
      case OP_NOTPOSUPTOI:
      case OP_STAR:
      case OP_STARI:
      case OP_NOTSTAR:
      case OP_NOTSTARI:
      case OP_MINSTAR:
      case OP_MINSTARI:
      case OP_NOTMINSTAR:
      case OP_NOTMINSTARI:
      case OP_POSSTAR:
      case OP_POSSTARI:
      case OP_NOTPOSSTAR:
      case OP_NOTPOSSTARI:
      case OP_PLUS:
      case OP_PLUSI:
      case OP_NOTPLUS:
      case OP_NOTPLUSI:
      case OP_MINPLUS:
      case OP_MINPLUSI:
      case OP_NOTMINPLUS:
      case OP_NOTMINPLUSI:
      case OP_POSPLUS:
      case OP_POSPLUSI:
      case OP_NOTPOSPLUS:
      case OP_NOTPOSPLUSI:
      case OP_QUERY:
      case OP_QUERYI:
      case OP_NOTQUERY:
      case OP_NOTQUERYI:
      case OP_MINQUERY:
      case OP_MINQUERYI:
      case OP_NOTMINQUERY:
      case OP_NOTMINQUERYI:
      case OP_POSQUERY:
      case OP_POSQUERYI:
      case OP_NOTPOSQUERY:
      case OP_NOTPOSQUERYI:
      if (HAS_EXTRALEN(code[-1])) code += GET_EXTRALEN(code[-1]);
      break;
      }
#else
    (void)(utf);  /* Keep compiler happy by referencing function argument */
#endif  /* MAYBE_UTF_MULTI */
    }
  }
}

/* End of pcre2_find_bracket.c */


================================================
FILE: Libraries/PCRE/pcre2_internal.h
================================================
/*************************************************
*      Perl-Compatible Regular Expressions       *
*************************************************/

/* PCRE2 is a library of functions to support regular expressions whose syntax
and semantics are as close as possible to those of the Perl 5 language.

                       Written by Philip Hazel
     Original API code Copyright (c) 1997-2012 University of Cambridge
          New API code Copyright (c) 2016-2024 University of Cambridge

-----------------------------------------------------------------------------
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

    * Redistributions of source code must retain the above copyright notice,
      this list of conditions and the following disclaimer.

    * Redistributions in binary form must reproduce the above copyright
      notice, this list of conditions and the following disclaimer in the
      documentation and/or other materials provided with the distribution.

    * Neither the name of the University of Cambridge nor the names of its
      contributors may be used to endorse or promote products derived from
      this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
-----------------------------------------------------------------------------
*/

#ifndef PCRE2_INTERNAL_H_IDEMPOTENT_GUARD
#define PCRE2_INTERNAL_H_IDEMPOTENT_GUARD

/* We do not support both EBCDIC and Unicode at the same time. The "configure"
script prevents both being selected, but not everybody uses "configure". EBCDIC
is only supported for the 8-bit library, but the check for this has to be later
in this file, because the first part is not width-dependent, and is included by
pcre2test.c with CODE_UNIT_WIDTH == 0. */

#if defined EBCDIC && defined SUPPORT_UNICODE
#error The use of both EBCDIC and SUPPORT_UNICODE is not supported.
#endif

/* When compiling one of the libraries, the value of PCRE2_CODE_UNIT_WIDTH must
be 8, 16, or 32. AutoTools and CMake ensure that this is always the case, but
other other building methods may not, so here is a check. It is cut out when
building pcre2test, bcause that sets the value to zero. No other source should
be including this file. There is no explicit way of forcing a compile to be
abandoned, but trying to include a non-existent file seems cleanest. Otherwise
there will be many irrelevant consequential errors. */

#if (!defined PCRE2_BUILDING_PCRE2TEST && !defined PCRE2_DFTABLES) && \
  (!defined PCRE2_CODE_UNIT_WIDTH ||     \
    (PCRE2_CODE_UNIT_WIDTH != 8 &&       \
     PCRE2_CODE_UNIT_WIDTH != 16 &&      \
     PCRE2_CODE_UNIT_WIDTH != 32))
#error PCRE2_CODE_UNIT_WIDTH must be defined as 8, 16, or 32.
#include <AbandonCompile>
#endif


/* Standard C headers */

#include <ctype.h>
#include <limits.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

/* Macros to make boolean values more obvious. The #ifndef is to pacify
compiler warnings in environments where these macros are defined elsewhere.
Unfortunately, there is no way to do the same for the typedef. */

typedef int BOOL;
#ifndef FALSE
#define FALSE   0
#define TRUE    1
#endif

/* Helper macro for static (compile-time) assertions. Can be used inside
functions, or at the top-level of a file. */
#define STATIC_ASSERT_JOIN(a,b) a ## b
#define STATIC_ASSERT(cond, msg) \
  typedef int STATIC_ASSERT_JOIN(static_assertion_,msg)[(cond)?1:-1]

/* Valgrind (memcheck) support */

#ifdef SUPPORT_VALGRIND
#include <valgrind/memcheck.h>
#endif

/* -ftrivial-auto-var-init support supports initializing all local variables
to avoid some classes of bug, but this can cause an unacceptable slowdown
for large on-stack arrays in hot functions. This macro lets us annotate
such arrays. */

#ifdef HAVE_ATTRIBUTE_UNINITIALIZED
#define PCRE2_KEEP_UNINITIALIZED __attribute__((uninitialized))
#else
#define PCRE2_KEEP_UNINITIALIZED
#endif

/* Older versions of MSVC lack snprintf(). This define allows for
warning/error-free compilation and testing with MSVC compilers back to at least
MSVC 10/2010. Except for VC6 (which is missing some fundamentals and fails). */

#if defined(_MSC_VER) && (_MSC_VER < 1900)
#define snprintf _snprintf
#endif

/* When compiling a DLL for Windows, the exported symbols have to be declared
using some MS magic. I found some useful information on this web page:
http://msdn2.microsoft.com/en-us/library/y4h7bcy6(VS.80).aspx. According to the
information there, using __declspec(dllexport) without "extern" we have a
definition; with "extern" we have a declaration. The settings here override the
setting in pcre2.h (which is included below); it defines only PCRE2_EXP_DECL,
which is all that is needed for applications (they just import the symbols). We
use:

  PCRE2_EXP_DECL    for declarations
  PCRE2_EXP_DEFN    for definitions

The reason for wrapping this in #ifndef PCRE2_EXP_DECL is so that pcre2test,
which is an application, but needs to import this file in order to "peek" at
internals, can #include pcre2.h first to get an application's-eye view.

In principle, people compiling for non-Windows, non-Unix-like (i.e. uncommon,
special-purpose environments) might want to stick other stuff in front of
exported symbols. That's why, in the non-Windows case, we set PCRE2_EXP_DEFN
only if it is not already set. */

#ifndef PCRE2_EXP_DECL
#  ifdef _WIN32
#    ifndef PCRE2_STATIC
#      define PCRE2_EXP_DECL		extern __declspec(dllexport)
#      define PCRE2_EXP_DEFN		__declspec(dllexport)
#    else
#      define PCRE2_EXP_DECL		extern PCRE2_EXPORT
#      define PCRE2_EXP_DEFN
#    endif
#  else
#    ifdef __cplusplus
#      define PCRE2_EXP_DECL		extern "C" PCRE2_EXPORT
#    else
#      define PCRE2_EXP_DECL		extern PCRE2_EXPORT
#    endif
#    ifndef PCRE2_EXP_DEFN
#      define PCRE2_EXP_DEFN		PCRE2_EXP_DECL
#    endif
#  endif
#endif

/* Include the public PCRE2 header and the definitions of UCP character
property values. This must follow the setting of PCRE2_EXP_DECL above. */

#include "pcre2.h"
#include "pcre2_ucp.h"

/* When PCRE2 is compiled as a C++ library, the subject pointer can be replaced
with a custom type. This makes it possible, for example, to allow pcre2_match()
to process subject strings that are discontinuous by using a smart pointer
class. It must always be possible to inspect all of the subject string in
pcre2_match() because of the way it backtracks. */

/* WARNING: This is as yet untested for PCRE2. */

#ifdef CUSTOM_SUBJECT_PTR
#undef PCRE2_SPTR
#define PCRE2_SPTR CUSTOM_SUBJECT_PTR
#endif

/* When checking for integer overflow, we need to handle large integers.
If a 64-bit integer type is available, we can use that.
Otherwise we have to cast to double, which of course requires floating point
arithmetic. Handle this by defining a macro for the appropriate type. */

#if defined INT64_MAX || defined int64_t
#define INT64_OR_DOUBLE int64_t
#else
#define INT64_OR_DOUBLE double
#endif

/* External (in the C sense) functions and tables that are private to the
libraries are always referenced using the PRIV macro. This makes it possible
for pcre2test.c to include some of the source files from the libraries using a
different PRIV definition to avoid name clashes. It also makes it clear in the
code that a non-static object is being referenced. */

#ifndef PRIV
#define PRIV(name) _pcre2_##name
#endif

/* When compiling for use with the Virtual Pascal compiler, these functions
need to have their names changed. PCRE2 must be compiled with the -DVPCOMPAT
option on the command line. */

#ifdef VPCOMPAT
#define strlen(s)        _strlen(s)
#define strncmp(s1,s2,m) _strncmp(s1,s2,m)
#define memcmp(s,c,n)    _memcmp(s,c,n)
#define memcpy(d,s,n)    _memcpy(d,s,n)
#define memmove(d,s,n)   _memmove(d,s,n)
#define memset(s,c,n)    _memset(s,c,n)
#else  /* VPCOMPAT */

/* Otherwise, to cope with SunOS4 and other systems that lack memmove(), define
a macro that calls an emulating function. */

#ifndef HAVE_MEMMOVE
#undef  memmove          /* Some systems may have a macro */
#define memmove(a, b, c) PRIV(memmove)(a, b, c)
#endif   /* not HAVE_MEMMOVE */
#endif   /* not VPCOMPAT */

/* This is an unsigned int value that no UTF character can ever have, as
Unicode doesn't go beyond 0x0010ffff. */

#define NOTACHAR 0xffffffff

/* This is the largest valid UTF/Unicode code point. */

#define MAX_UTF_CODE_POINT 0x10ffff

/* Compile-time positive error numbers (all except UTF errors, which are
negative) start at this value. It should probably never be changed, in case
some application is checking for specific numbers. There is a copy of this
#define in pcre2posix.c (which now no longer includes this file). Ideally, a
way of having a single definition should be found, but as the number is
unlikely to change, this is not a pressing issue. The original reason for
having a base other than 0 was to keep the absolute values of compile-time and
run-time error numbers numerically different, but in the event the code does
not rely on this. */

#define COMPILE_ERROR_BASE 100

/* The initial frames vector for remembering pcre2_match() backtracking points
is allocated on the heap, of this size (bytes) or ten times the frame size if
larger, unless the heap limit is smaller. Typical frame sizes are a few hundred
bytes (it depends on the number of capturing parentheses) so 20KiB handles
quite a few frames. A larger vector on the heap is obtained for matches that
need more frames, subject to the heap limit. */

#define START_FRAMES_SIZE 20480

/* For DFA matching, an initial internal workspace vector is allocated on the
stack. The heap is used only if this turns out to be too small. */

#define DFA_START_RWS_SIZE 30720

/* Define the default BSR convention. */

#ifdef BSR_ANYCRLF
#define BSR_DEFAULT PCRE2_BSR_ANYCRLF
#else
#define BSR_DEFAULT PCRE2_BSR_UNICODE
#endif


/* ---------------- Basic UTF-8 macros ---------------- */

/* These UTF-8 macros are always defined because they are used in pcre2test for
handling wide characters in 16-bit and 32-bit modes, even if an 8-bit library
is not supported. */

/* Tests whether a UTF-8 code point needs extra bytes to decode. */

#define HASUTF8EXTRALEN(c) ((c) >= 0xc0)

/* The following macros were originally written in the form of loops that used
data from the tables whose names start with PRIV(utf8_table). They were
rewritten by a user so as not to use loops, because in some environments this
gives a significant performance advantage, and it seems never to do any harm.
*/

/* Base macro to pick up the remaining bytes of a UTF-8 character, not
advancing the pointer. */

#define GETUTF8(c, eptr) \
    { \
    if ((c & 0x20u) == 0) \
      c = ((c & 0x1fu) << 6) | (eptr[1] & 0x3fu); \
    else if ((c & 0x10u) == 0) \
      c = ((c & 0x0fu) << 12) | ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \
    else if ((c & 0x08u) == 0) \
      c = ((c & 0x07u) << 18) | ((eptr[1] & 0x3fu) << 12) | \
      ((eptr[2] & 0x3fu) << 6) | (eptr[3] & 0x3fu); \
    else if ((c & 0x04u) == 0) \
      c = ((c & 0x03u) << 24) | ((eptr[1] & 0x3fu) << 18) | \
          ((eptr[2] & 0x3fu) << 12) | ((eptr[3] & 0x3fu) << 6) | \
          (eptr[4] & 0x3fu); \
    else \
      c = ((c & 0x01u) << 30) | ((eptr[1] & 0x3fu) << 24) | \
          ((eptr[2] & 0x3fu) << 18) | ((eptr[3] & 0x3fu) << 12) | \
          ((eptr[4] & 0x3fu) << 6) | (eptr[5] & 0x3fu); \
    }

/* Base macro to pick up the remaining bytes of a UTF-8 character, advancing
the pointer. */

#define GETUTF8INC(c, eptr) \
    { \
    if ((c & 0x20u) == 0) \
      c = ((c & 0x1fu) << 6) | (*eptr++ & 0x3fu); \
    else if ((c & 0x10u) == 0) \
      { \
      c = ((c & 0x0fu) << 12) | ((*eptr & 0x3fu) << 6) | (eptr[1] & 0x3fu); \
      eptr += 2; \
      } \
    else if ((c & 0x08u) == 0) \
      { \
      c = ((c & 0x07u) << 18) | ((*eptr & 0x3fu) << 12) | \
          ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \
      eptr += 3; \
      } \
    else if ((c & 0x04u) == 0) \
      { \
      c = ((c & 0x03u) << 24) | ((*eptr & 0x3fu) << 18) | \
          ((eptr[1] & 0x3fu) << 12) | ((eptr[2] & 0x3fu) << 6) | \
          (eptr[3] & 0x3fu); \
      eptr += 4; \
      } \
    else \
      { \
      c = ((c & 0x01u) << 30) | ((*eptr & 0x3fu) << 24) | \
          ((eptr[1] & 0x3fu) << 18) | ((eptr[2] & 0x3fu) << 12) | \
          ((eptr[3] & 0x3fu) << 6) | (eptr[4] & 0x3fu); \
      eptr += 5; \
      } \
    }

/* Base macro to pick up the remaining bytes of a UTF-8 character, not
advancing the pointer, incrementing the length. */

#define GETUTF8LEN(c, eptr, len) \
    { \
    if ((c & 0x20u) == 0) \
      { \
      c = ((c & 0x1fu) << 6) | (eptr[1] & 0x3fu); \
      len++; \
      } \
    else if ((c & 0x10u)  == 0) \
      { \
      c = ((c & 0x0fu) << 12) | ((eptr[1] & 0x3fu) << 6) | (eptr[2] & 0x3fu); \
      len += 2; \
      } \
    else if ((c & 0x08u)  == 0) \
      {\
      c = ((c & 0x07u) << 18) | ((eptr[1] & 0x3fu) << 12) | \
          ((eptr[2] & 0x3fu) << 6) | (eptr[3] & 0x3fu); \
      len += 3; \
      } \
    else if ((c & 0x04u)  == 0) \
      { \
      c = ((c & 0x03u) << 24) | ((eptr[1] & 0x3fu) << 18) | \
          ((eptr[2] & 0x3fu) << 12) | ((eptr[3] & 0x3fu) << 6) | \
          (eptr[4] & 0x3fu); \
      len += 4; \
      } \
    else \
      {\
      c = ((c & 0x01u) << 30) | ((eptr[1] & 0x3fu) << 24) | \
          ((eptr[2] & 0x3fu) << 18) | ((eptr[3] & 0x3fu) << 12) | \
          ((eptr[4] & 0x3fu) << 6) | (eptr[5] & 0x3fu); \
      len += 5; \
      } \
    }

/* --------------- Whitespace macros ---------------- */

/* Tests for Unicode horizontal and vertical whitespace characters must check a
number of different values. Using a switch statement for this generates the
fastest code (no loop, no memory access), and there are several places in the
interpreter code where this happens. In order to ensure that all the case lists
remain in step, we use macros so that there is only one place where the lists
are defined.

These values are also required as lists in pcre2_compile.c when processing \h,
\H, \v and \V in a character class. The lists are defined in pcre2_tables.c,
but macros that define the values are here so that all the definitions are
together. The lists must be in ascending character order, terminated by
NOTACHAR (which is 0xffffffff).

Any changes should ensure that the various macros are kept in step with each
other. NOTE: The values also appear in pcre2_jit_compile.c. */

/* -------------- ASCII/Unicode environments -------------- */

#ifndef EBCDIC

/* Character U+180E (Mongolian Vowel Separator) is not included in the list of
spaces in the Unicode file PropList.txt, and Perl does not recognize it as a
space. However, in many other sources it is listed as a space and has been in
PCRE (both APIs) for a long time. */

#define HSPACE_LIST \
  CHAR_HT, CHAR_SPACE, CHAR_NBSP, \
  0x1680, 0x180e, 0x2000, 0x2001, 0x2002, 0x2003, 0x2004, 0x2005, \
  0x2006, 0x2007, 0x2008, 0x2009, 0x200A, 0x202f, 0x205f, 0x3000, \
  NOTACHAR

#define HSPACE_MULTIBYTE_CASES \
  case 0x1680:  /* OGHAM SPACE MARK */ \
  case 0x180e:  /* MONGOLIAN VOWEL SEPARATOR */ \
  case 0x2000:  /* EN QUAD */ \
  case 0x2001:  /* EM QUAD */ \
  case 0x2002:  /* EN SPACE */ \
  case 0x2003:  /* EM SPACE */ \
  case 0x2004:  /* THREE-PER-EM SPACE */ \
  case 0x2005:  /* FOUR-PER-EM SPACE */ \
  case 0x2006:  /* SIX-PER-EM SPACE */ \
  case 0x2007:  /* FIGURE SPACE */ \
  case 0x2008:  /* PUNCTUATION SPACE */ \
  case 0x2009:  /* THIN SPACE */ \
  case 0x200A:  /* HAIR SPACE */ \
  case 0x202f:  /* NARROW NO-BREAK SPACE */ \
  case 0x205f:  /* MEDIUM MATHEMATICAL SPACE */ \
  case 0x3000   /* IDEOGRAPHIC SPACE */

#define HSPACE_BYTE_CASES \
  case CHAR_HT: \
  case CHAR_SPACE: \
  case CHAR_NBSP

#define HSPACE_CASES \
  HSPACE_BYTE_CASES: \
  HSPACE_MULTIBYTE_CASES

#define VSPACE_LIST \
  CHAR_LF, CHAR_VT, CHAR_FF, CHAR_CR, CHAR_NEL, 0x2028, 0x2029, NOTACHAR

#define VSPACE_MULTIBYTE_CASES \
  case 0x2028:    /* LINE SEPARATOR */ \
  case 0x2029     /* PARAGRAPH SEPARATOR */

#define VSPACE_BYTE_CASES \
  case CHAR_LF: \
  case CHAR_VT: \
  case CHAR_FF: \
  case CHAR_CR: \
  case CHAR_NEL

#define VSPACE_CASES \
  VSPACE_BYTE_CASES: \
  VSPACE_MULTIBYTE_CASES

/* -------------- EBCDIC environments -------------- */

#else
#define HSPACE_LIST CHAR_HT, CHAR_SPACE, CHAR_NBSP, NOTACHAR

#define HSPACE_BYTE_CASES \
  case CHAR_HT: \
  case CHAR_SPACE: \
  case CHAR_NBSP

#define HSPACE_CASES HSPACE_BYTE_CASES

#ifdef EBCDIC_NL25
#define VSPACE_LIST \
  CHAR_VT, CHAR_FF, CHAR_CR, CHAR_NEL, CHAR_LF, NOTACHAR
#else
#define VSPACE_LIST \
  CHAR_VT, CHAR_FF, CHAR_CR, CHAR_LF, CHAR_NEL, NOTACHAR
#endif

#define VSPACE_BYTE_CASES \
  case CHAR_LF: \
  case CHAR_VT: \
  case CHAR_FF: \
  case CHAR_CR: \
  case CHAR_NEL

#define VSPACE_CASES VSPACE_BYTE_CASES
#endif  /* EBCDIC */

/* -------------- End of whitespace macros -------------- */


/* PCRE2 is able to support several different kinds of newline (CR, LF, CRLF,
"any" and "anycrlf" at present). The following macros are used to package up
testing for newlines. NLBLOCK, PSSTART, and PSEND are defined in the various
modules to indicate in which datablock the parameters exist, and what the
start/end of string field names are. */

#define NLTYPE_FIXED    0     /* Newline is a fixed length string */
#define NLTYPE_ANY      1     /* Newline is any Unicode line ending */
#define NLTYPE_ANYCRLF  2     /* Newline is CR, LF, or CRLF */

/* This macro checks for a newline at the given position */

#define IS_NEWLINE(p) \
  ((NLBLOCK->nltype != NLTYPE_FIXED)? \
    ((p) < NLBLOCK->PSEND && \
     PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \
       &(NLBLOCK->nllen), utf)) \
    : \
    ((p) <= NLBLOCK->PSEND - NLBLOCK->nllen && \
     UCHAR21TEST(p) == NLBLOCK->nl[0] && \
     (NLBLOCK->nllen == 1 || UCHAR21TEST(p+1) == NLBLOCK->nl[1])       \
    ) \
  )

/* This macro checks for a newline immediately preceding the given position */

#define WAS_NEWLINE(p) \
  ((NLBLOCK->nltype != NLTYPE_FIXED)? \
    ((p) > NLBLOCK->PSSTART && \
     PRIV(was_newline)((p), NLBLOCK->nltype, NLBLOCK->PSSTART, \
       &(NLBLOCK->nllen), utf)) \
    : \
    ((p) >= NLBLOCK->PSSTART + NLBLOCK->nllen && \
     UCHAR21TEST(p - NLBLOCK->nllen) == NLBLOCK->nl[0] &&              \
     (NLBLOCK->nllen == 1 || UCHAR21TEST(p - NLBLOCK->nllen + 1) == NLBLOCK->nl[1]) \
    ) \
  )

/* Private flags containing information about the compiled pattern. The first
three must not be changed, because whichever is set is actually the number of
bytes in a code unit in that mode. */

#define PCRE2_MODE8         0x00000001u /* compiled in 8 bit mode */
#define PCRE2_MODE16        0x00000002u /* compiled in 16 bit mode */
#define PCRE2_MODE32        0x00000004u /* compiled in 32 bit mode */
#define PCRE2_FIRSTSET      0x00000010u /* first_code unit is set */
#define PCRE2_FIRSTCASELESS 0x00000020u /* caseless first code unit */
#define PCRE2_FIRSTMAPSET   0x00000040u /* bitmap of first code units is set */
#define PCRE2_LASTSET       0x00000080u /* last code unit is set */
#define PCRE2_LASTCASELESS  0x00000100u /* caseless last code unit */
#define PCRE2_STARTLINE     0x00000200u /* start after \n for multiline */
#define PCRE2_JCHANGED      0x00000400u /* j option used in pattern */
#define PCRE2_HASCRORLF     0x00000800u /* explicit \r or \n in pattern */
#define PCRE2_HASTHEN       0x00001000u /* pattern contains (*THEN) */
#define PCRE2_MATCH_EMPTY   0x00002000u /* pattern can match empty string */
#define PCRE2_BSR_SET       0x00004000u /* BSR was set in the pattern */
#define PCRE2_NL_SET        0x00008000u /* newline was set in the pattern */
#define PCRE2_NOTEMPTY_SET  0x00010000u /* (*NOTEMPTY) used        ) keep */
#define PCRE2_NE_ATST_SET   0x00020000u /* (*NOTEMPTY_ATSTART) used) together */
#define PCRE2_DEREF_TABLES  0x00040000u /* release character tables */
#define PCRE2_NOJIT         0x00080000u /* (*NOJIT) used */
#define PCRE2_HASBKPORX     0x00100000u /* contains \P, \p, or \X */
#define PCRE2_DUPCAPUSED    0x00200000u /* contains (?| */
#define PCRE2_HASBKC        0x00400000u /* contains \C */
#define PCRE2_HASACCEPT     0x00800000u /* contains (*ACCEPT) */

#define PCRE2_MODE_MASK     (PCRE2_MODE8 | PCRE2_MODE16 | PCRE2_MODE32)

/* Values for the matchedby field in a match data block. */

enum { PCRE2_MATCHEDBY_INTERPRETER,     /* pcre2_match() */
       PCRE2_MATCHEDBY_DFA_INTERPRETER, /* pcre2_dfa_match() */
       PCRE2_MATCHEDBY_JIT };           /* pcre2_jit_match() */

/* Values for the flags field in a match data block. */

#define PCRE2_MD_COPIED_SUBJECT  0x01u

/* Magic number to provide a small check against being handed junk. */

#define MAGIC_NUMBER  0x50435245UL   /* 'PCRE' */

/* The maximum remaining length of subject we are prepared to search for a
req_unit match from an anchored pattern. In 8-bit mode, memchr() is used and is
much faster than the search loop that has to be used in 16-bit and 32-bit
modes. */

#if PCRE2_CODE_UNIT_WIDTH == 8
#define REQ_CU_MAX       5000
#else
#define REQ_CU_MAX       2000
#endif

/* The maximum nesting depth for Unicode character class sets.
Currently fixed. Warning: the interpreter relies on this so it can encode
the operand stack in a uint32_t. A nesting limit of 15 implies (15*2+1)=31
stack operands required, due to the fact that we have two (and only two)
levels of operator precedence. In the UTS#18 syntax, you can write 'x&&y[z]'
and in Perl syntax you can write '(?[ x - y & (z) ])', both of which imply
pushing the match results for x & y to the stack. */

#define ECLASS_NEST_LIMIT  15

/* Offsets for the bitmap tables in the cbits set of tables. Each table
contains a set of bits for a class map. Some classes are built by combining
these tables. */

#define cbit_space     0      /* [:space:] or \s */
#define cbit_xdigit   32      /* [:xdigit:] */
#define cbit_digit    64      /* [:digit:] or \d */
#define cbit_upper    96      /* [:upper:] */
#define cbit_lower   128      /* [:lower:] */
#define cbit_word    160      /* [:word:] or \w */
#define cbit_graph   192      /* [:graph:] */
#define cbit_print   224      /* [:print:] */
#define cbit_punct   256      /* [:punct:] */
#define cbit_cntrl   288      /* [:cntrl:] */
#define cbit_length  320      /* Length of the cbits table */

/* Bit definitions for entries in the ctypes table. Do not change these values
without checking pcre2_jit_compile.c, which has an assertion to ensure that
ctype_word has the value 16. */

#define ctype_space    0x01
#define ctype_letter   0x02
#define ctype_lcletter 0x04
#define ctype_digit    0x08
#define ctype_word     0x10    /* alphanumeric or '_' */

/* Offsets of the various tables from the base tables pointer, and
total length of the tables. */

#define lcc_offset      0                           /* Lower case */
#define fcc_offset    256                           /* Flip case */
#define cbits_offset  512                           /* Character classes */
#define ctypes_offset (cbits_offset + cbit_length)  /* Character types */
#define TABLES_LENGTH (ctypes_offset + 256)

/* Private flags used in compile_context.optimization_flags */

#define PCRE2_OPTIM_AUTO_POSSESS    0x00000001u
#define PCRE2_OPTIM_DOTSTAR_ANCHOR  0x00000002u
#define PCRE2_OPTIM_START_OPTIMIZE  0x00000004u

#define PCRE2_OPTIMIZATION_ALL      0x00000007u

/* -------------------- Character and string names ------------------------ */

/* If PCRE2 is to support UTF-8 on EBCDIC platforms, we cannot use normal
character constants like '*' because the compiler would emit their EBCDIC code,
which is different from their ASCII/UTF-8 code. Instead we define macros for
the characters so that they always use the ASCII/UTF-8 code when UTF-8 support
is enabled. When UTF-8 support is not enabled, the definitions use character
literals. Both character and string versions of each character are needed, and
there are some longer strings as well.

This means that, on EBCDIC platforms, the PCRE2 library can handle either
EBCDIC, or UTF-8, but not both. To support both in the same compiled library
would need different lookups depending on whether PCRE2_UTF was set or not.
This would make it impossible to use characters in switch/case statements,
which would reduce performance. For a theoretical use (which nobody has asked
for) in a minority area (EBCDIC platforms), this is not sensible. Any
application that did need both could compile two versions of the library, using
macros to give the functions distinct names. */

#ifndef SUPPORT_UNICODE

/* UTF-8 support is not enabled; use the platform-dependent character literals
so that PCRE2 works in both ASCII and EBCDIC environments, but only in non-UTF
mode. Newline characters are problematic in EBCDIC. Though it has CR and LF
characters, a common practice has been to use its NL (0x15) character as the
line terminator in C-like processing environments. However, sometimes the LF
(0x25) character is used instead, according to this Unicode document:

http://unicode.org/standard/reports/tr13/tr13-5.html

PCRE2 defaults EBCDIC NL to 0x15, but has a build-time option to select 0x25
instead. Whichever is *not* chosen is defined as NEL.

In both ASCII and EBCDIC environments, CHAR_NL and CHAR_LF are synonyms for the
same code point. */

#ifdef EBCDIC

#ifndef EBCDIC_NL25
#define CHAR_NL                     '\x15'
#define CHAR_NEL                    '\x25'
#define STR_NL                      "\x15"
#define STR_NEL                     "\x25"
#else
#define CHAR_NL                     '\x25'
#define CHAR_NEL                    '\x15'
#define STR_NL                      "\x25"
#define STR_NEL                     "\x15"
#endif

#define CHAR_LF                     CHAR_NL
#define STR_LF                      STR_NL

#define CHAR_ESC                    '\047'
#define CHAR_DEL                    '\007'
#define CHAR_NBSP                   ((unsigned char)'\x41')
#define STR_ESC                     "\047"
#define STR_DEL                     "\007"

#else  /* Not EBCDIC */

/* In ASCII/Unicode, linefeed is '\n' and we equate this to NL for
compatibility. NEL is the Unicode newline character; make sure it is
a positive value. */

#define CHAR_LF                     '\n'
#define CHAR_NL                     CHAR_LF
#define CHAR_NEL                    ((unsigned char)'\x85')
#define CHAR_ESC                    '\033'
#define CHAR_DEL                    '\177'
#define CHAR_NBSP                   ((unsigned char)'\xa0')

#define STR_LF                      "\n"
#define STR_NL                      STR_LF
#define STR_NEL                     "\x85"
#define STR_ESC                     "\033"
#define STR_DEL                     "\177"

#endif  /* EBCDIC */

/* The remaining definitions work in both environments. */

#define CHAR_NUL                    '\0'
#define CHAR_HT                     '\t'
#define CHAR_VT                     '\v'
#define CHAR_FF                     '\f'
#define CHAR_CR                     '\r'
#define CHAR_BS                     '\b'
#define CHAR_BEL                    '\a'

#define CHAR_SPACE                  ' '
#define CHAR_EXCLAMATION_MARK       '!'
#define CHAR_QUOTATION_MARK         '"'
#define CHAR_NUMBER_SIGN            '#'
#define CHAR_DOLLAR_SIGN            '$'
#define CHAR_PERCENT_SIGN           '%'
#define CHAR_AMPERSAND              '&'
#define CHAR_APOSTROPHE             '\''
#define CHAR_LEFT_PARENTHESIS       '('
#define CHAR_RIGHT_PARENTHESIS      ')'
#define CHAR_ASTERISK               '*'
#define CHAR_PLUS                   '+'
#define CHAR_COMMA                  ','
#define CHAR_MINUS                  '-'
#define CHAR_DOT                    '.'
#define CHAR_SLASH                  '/'
#define CHAR_0                      '0'
#define CHAR_1                      '1'
#define CHAR_2                      '2'
#define CHAR_3                      '3'
#define CHAR_4                      '4'
#define CHAR_5                      '5'
#define CHAR_6                      '6'
#define CHAR_7                      '7'
#define CHAR_8                      '8'
#define CHAR_9                      '9'
#define CHAR_COLON                  ':'
#define CHAR_SEMICOLON              ';'
#define CHAR_LESS_THAN_SIGN         '<'
#define CHAR_EQUALS_SIGN            '='
#define CHAR_GREATER_THAN_SIGN      '>'
#define CHAR_QUESTION_MARK          '?'
#define CHAR_COMMERCIAL_AT          '@'
#define CHAR_A                      'A'
#define CHAR_B                      'B'
#define CHAR_C                      'C'
#define CHAR_D                      'D'
#define CHAR_E                      'E'
#define CHAR_F                      'F'
#define CHAR_G                      'G'
#define CHAR_H                      'H'
#define CHAR_I                      'I'
#define CHAR_J                      'J'
#define CHAR_K                      'K'
#define CHAR_L                      'L'
#define CHAR_M                      'M'
#define CHAR_N                      'N'
#define CHAR_O                      'O'
#define CHAR_P                      'P'
#define CHAR_Q                      'Q'
#define CHAR_R                      'R'
#define CHAR_S                      'S'
#define CHAR_T                      'T'
#define CHAR_U                      'U'
#define CHAR_V                      'V'
#define CHAR_W                      'W'
#define CHAR_X                      'X'
#define CHAR_Y                      'Y'
#define CHAR_Z                      'Z'
#define CHAR_LEFT_SQUARE_BRACKET    '['
#define CHAR_BACKSLASH              '\\'
#define CHAR_RIGHT_SQUARE_BRACKET   ']'
#define CHAR_CIRCUMFLEX_ACCENT      '^'
#define CHAR_UNDERSCORE             '_'
#define CHAR_GRAVE_ACCENT           '`'
#define CHAR_a                      'a'
#define CHAR_b                      'b'
#define CHAR_c                      'c'
#define CHAR_d                      'd'
#define CHAR_e                      'e'
#define CHAR_f                      'f'
#define CHAR_g                      'g'
#define CHAR_h                      'h'
#define CHAR_i                      'i'
#define CHAR_j                      'j'
#define CHAR_k                      'k'
#define CHAR_l                      'l'
#define CHAR_m                      'm'
#define CHAR_n                      'n'
#define CHAR_o                      'o'
#define CHAR_p                      'p'
#define CHAR_q                      'q'
#define CHAR_r                      'r'
#define CHAR_s                      's'
#define CHAR_t                      't'
#define CHAR_u                      'u'
#define CHAR_v                      'v'
#define CHAR_w                      'w'
#define CHAR_x                      'x'
#define CHAR_y                      'y'
#define CHAR_z                      'z'
#define CHAR_LEFT_CURLY_BRACKET     '{'
#define CHAR_VERTICAL_LINE          '|'
#define CHAR_RIGHT_CURLY_BRACKET    '}'
#define CHAR_TILDE                  '~'

#define STR_HT                      "\t"
#define STR_VT                      "\v"
#define STR_FF                      "\f"
#define STR_CR                      "\r"
#define STR_BS                      "\b"
#define STR_BEL                     "\a"

#define STR_SPACE                   " "
#define STR_EXCLAMATION_MARK        "!"
#define STR_QUOTATION_MARK          "\""
#define STR_NUMBER_SIGN             "#"
#define STR_DOLLAR_SIGN             "$"
#define STR_PERCENT_SIGN            "%"
#define STR_AMPERSAND               "&"
#define STR_APOSTROPHE              "'"
#define STR_LEFT_PARENTHESIS        "("
#define STR_RIGHT_PARENTHESIS       ")"
#define STR_ASTERISK                "*"
#define STR_PLUS                    "+"
#define STR_COMMA                   ","
#define STR_MINUS                   "-"
#define STR_DOT                     "."
#define STR_SLASH                   "/"
#define STR_0                       "0"
#define STR_1                       "1"
#define STR_2                       "2"
#define STR_3                       "3"
#define STR_4                       "4"
#define STR_5                       "5"
#define STR_6                       "6"
#define STR_7                       "7"
#define STR_8                       "8"
#define STR_9                       "9"
#define STR_COLON                   ":"
#define STR_SEMICOLON               ";"
#define STR_LESS_THAN_SIGN          "<"
#define STR_EQUALS_SIGN             "="
#define STR_GREATER_THAN_SIGN       ">"
#define STR_QUESTION_MARK           "?"
#define STR_COMMERCIAL_AT           "@"
#define STR_A                       "A"
#define STR_B                       "B"
#define STR_C                       "C"
#define STR_D                       "D"
#define STR_E                       "E"
#define STR_F                       "F"
#define STR_G                       "G"
#define STR_H                       "H"
#define STR_I                       "I"
#define STR_J                       "J"
#define STR_K                       "K"
#define STR_L                       "L"
#define STR_M                       "M"
#define STR_N                       "N"
#define STR_O                       "O"
#define STR_P                       "P"
#define STR_Q                       "Q"
#define STR_R                       "R"
#define STR_S                       "S"
#define STR_T                       "T"
#define STR_U                       "U"
#define STR_V                       "V"
#define STR_W                       "W"
#define STR_X                       "X"
#define STR_Y                       "Y"
#define STR_Z                       "Z"
#define STR_LEFT_SQUARE_BRACKET     "["
#define STR_BACKSLASH               "\\"
#define STR_RIGHT_SQUARE_BRACKET    "]"
#define STR_CIRCUMFLEX_ACCENT       "^"
#define STR_UNDERSCORE              "_"
#define STR_GRAVE_ACCENT            "`"
#define STR_a                       "a"
#define STR_b                       "b"
#define STR_c                       "c"
#define STR_d                       "d"
#define STR_e                       "e"
#define STR_f                       "f"
#define STR_g                       "g"
#define STR_h                       "h"
#define STR_i                       "i"
#define STR_j                       "j"
#define STR_k                       "k"
#define STR_l                       "l"
#define STR_m                       "m"
#define STR_n                       "n"
#define STR_o                       "o"
#define STR_p                       "p"
#define STR_q                       "q"
#define STR_r                       "r"
#define STR_s                       "s"
#define STR_t                       "t"
#define STR_u                       "u"
#define STR_v                       "v"
#define STR_w                       "w"
#define STR_x                       "x"
#define STR_y                       "y"
#define STR_z                       "z"
#define STR_LEFT_CURLY_BRACKET      "{"
#define STR_VERTICAL_LINE           "|"
#define STR_RIGHT_CURLY_BRACKET     "}"
#define STR_TILDE                   "~"

#define STRING_ACCEPT0               "ACCEPT\0"
#define STRING_COMMIT0               "COMMIT\0"
#define STRING_F0                    "F\0"
#define STRING_FAIL0                 "FAIL\0"
#define STRING_MARK0                 "MARK\0"
#define STRING_PRUNE0                "PRUNE\0"
#define STRING_SKIP0                 "SKIP\0"
#define STRING_THEN                  "THEN"

#define STRING_atomic0               "atomic\0"
#define STRING_pla0                  "pla\0"
#define STRING_plb0                  "plb\0"
#define STRING_napla0                "napla\0"
#define STRING_naplb0                "naplb\0"
#define STRING_nla0                  "nla\0"
#define STRING_nlb0                  "nlb\0"
#define STRING_scs0                  "scs\0"
#define STRING_sr0                   "sr\0"
#define STRING_asr0                  "asr\0"
#define STRING_positive_lookahead0   "positive_lookahead\0"
#define STRING_positive_lookbehind0  "positive_lookbehind\0"
#define STRING_non_atomic_positive_lookahead0   "non_atomic_positive_lookahead\0"
#define STRING_non_atomic_positive_lookbehind0  "non_atomic_positive_lookbehind\0"
#define STRING_negative_lookahead0   "negative_lookahead\0"
#define STRING_negative_lookbehind0  "negative_lookbehind\0"
#define STRING_script_run0           "script_run\0"
#define STRING_atomic_script_run     "atomic_script_run"
#define STRING_scan_substring0       "scan_substring\0"

#define STRING_alpha0                "alpha\0"
#define STRING_lower0                "lower\0"
#define STRING_upper0                "upper\0"
#define STRING_alnum0                "alnum\0"
#define STRING_ascii0                "ascii\0"
#define STRING_blank0                "blank\0"
#define STRING_cntrl0                "cntrl\0"
#define STRING_digit0                "digit\0"
#define STRING_graph0                "graph\0"
#define STRING_print0                "print\0"
#define STRING_punct0                "punct\0"
#define STRING_space0                "space\0"
#define STRING_word0                 "word\0"
#define STRING_xdigit                "xdigit"

#define STRING_DEFINE                "DEFINE"
#define STRING_VERSION               "VERSION"
#define STRING_WEIRD_STARTWORD       "[:<:]]"
#define STRING_WEIRD_ENDWORD         "[:>:]]"

#define STRING_CR_RIGHTPAR                "CR)"
#define STRING_LF_RIGHTPAR                "LF)"
#define STRING_CRLF_RIGHTPAR              "CRLF)"
#define STRING_ANY_RIGHTPAR               "ANY)"
#define STRING_ANYCRLF_RIGHTPAR           "ANYCRLF)"
#define STRING_NUL_RIGHTPAR               "NUL)"
#define STRING_BSR_ANYCRLF_RIGHTPAR       "BSR_ANYCRLF)"
#define STRING_BSR_UNICODE_RIGHTPAR       "BSR_UNICODE)"
#define STRING_UTF8_RIGHTPAR              "UTF8)"
#define STRING_UTF16_RIGHTPAR             "UTF16)"
#define STRING_UTF32_RIGHTPAR             "UTF32)"
#define STRING_UTF_RIGHTPAR               "UTF)"
#define STRING_UCP_RIGHTPAR               "UCP)"
#define STRING_NO_AUTO_POSSESS_RIGHTPAR   "NO_AUTO_POSSESS)"
#define STRING_NO_DOTSTAR_ANCHOR_RIGHTPAR "NO_DOTSTAR_ANCHOR)"
#define STRING_NO_JIT_RIGHTPAR            "NO_JIT)"
#define STRING_NO_START_OPT_RIGHTPAR      "NO_START_OPT)"
#define STRING_NOTEMPTY_RIGHTPAR          "NOTEMPTY)"
#define STRING_NOTEMPTY_ATSTART_RIGHTPAR  "NOTEMPTY_ATSTART)"
#define STRING_CASELESS_RESTRICT_RIGHTPAR "CASELESS_RESTRICT)"
#define STRING_TURKISH_CASING_RIGHTPAR    "TURKISH_CASING)"
#define STRING_LIMIT_HEAP_EQ              "LIMIT_HEAP="
#define STRING_LIMIT_MATCH_EQ             "LIMIT_MATCH="
#define STRING_LIMIT_DEPTH_EQ             "LIMIT_DEPTH="
#define STRING_LIMIT_RECURSION_EQ         "LIMIT_RECURSION="
#define STRING_MARK                       "MARK"

#define STRING_bc                         "bc"
#define STRING_bidiclass                  "bidiclass"
#define STRING_sc                         "sc"
#define STRING_script                     "script"
#define STRING_scriptextensions           "scriptextensions"
#define STRING_scx                        "scx"

#else  /* SUPPORT_UNICODE */

/* UTF-8 support is enabled; always use UTF-8 (=ASCII) character codes. This
works in both modes non-EBCDIC platforms, and on EBCDIC platforms in UTF-8 mode
only. */

#define CHAR_HT                     '\011'
#define CHAR_VT                     '\013'
#define CHAR_FF                     '\014'
#define CHAR_CR                     '\015'
#define CHAR_LF                     '\012'
#define CHAR_NL                     CHAR_LF
#define CHAR_NEL                    ((unsigned char)'\x85')
#define CHAR_BS                     '\010'
#define CHAR_BEL                    '\007'
#define CHAR_ESC                    '\033'
#define CHAR_DEL                    '\177'

#define CHAR_NUL                    '\0'
#define CHAR_SPACE                  '\040'
#define CHAR_EXCLAMATION_MARK       '\041'
#define CHAR_QUOTATION_MARK         '\042'
#define CHAR_NUMBER_SIGN            '\043'
#define CHAR_DOLLAR_SIGN            '\044'
#define CHAR_PERCENT_SIGN           '\045'
#define CHAR_AMPERSAND              '\046'
#define CHAR_APOSTROPHE             '\047'
#define CHAR_LEFT_PARENTHESIS       '\050'
#define CHAR_RIGHT_PARENTHESIS      '\051'
#define CHAR_ASTERISK               '\052'
#define CHAR_PLUS                   '\053'
#define CHAR_COMMA                  '\054'
#define CHAR_MINUS                  '\055'
#define CHAR_DOT                    '\056'
#define CHAR_SLASH                  '\057'
#define CHAR_0                      '\060'
#define CHAR_1                      '\061'
#define CHAR_2                      '\062'
#define CHAR_3                      '\063'
#define CHAR_4                      '\064'
#define CHAR_5                      '\065'
#define CHAR_6                      '\066'
#define CHAR_7                      '\067'
#define CHAR_8                      '\070'
#define CHAR_9                      '\071'
#define CHAR_COLON                  '\072'
#define CHAR_SEMICOLON              '\073'
#define CHAR_LESS_THAN_SIGN         '\074'
#define CHAR_EQUALS_SIGN            '\075'
#define CHAR_GREATER_THAN_SIGN      '\076'
#define CHAR_QUESTION_MARK          '\077'
#define CHAR_COMMERCIAL_AT          '\100'
#define CHAR_A                      '\101'
#define CHAR_B                      '\102'
#define CHAR_C                      '\103'
#define CHAR_D                      '\104'
#define CHAR_E                      '\105'
#define CHAR_F                      '\106'
#define CHAR_G                      '\107'
#define CHAR_H                      '\110'
#define CHAR_I                      '\111'
#define CHAR_J                      '\112'
#define CHAR_K                      '\113'
#define CHAR_L                      '\114'
#define CHAR_M                      '\115'
#define CHAR_N                      '\116'
#define CHAR_O                      '\117'
#define CHAR_P                      '\120'
#define CHAR_Q                      '\121'
#define CHAR_R                      '\122'
#define CHAR_S                      '\123'
#define CHAR_T                      '\124'
#define CHAR_U                      '\125'
#define CHAR_V                      '\126'
#define CHAR_W                      '\127'
#define CHAR_X                      '\130'
#define CHAR_Y                      '\131'
#define CHAR_Z                      '\132'
#define CHAR_LEFT_SQUARE_BRACKET    '\133'
#define CHAR_BACKSLASH              '\134'
#define CHAR_RIGHT_SQUARE_BRACKET   '\135'
#define CHAR_CIRCUMFLEX_ACCENT      '\136'
#define CHAR_UNDERSCORE             '\137'
#define CHAR_GRAVE_ACCENT           '\140'
#define CHAR_a                      '\141'
#define CHAR_b                      '\142'
#define CHAR_c                      '\143'
#define CHAR_d                      '\144'
#define CHAR_e                      '\145'
#define CHAR_f                      '\146'
#define CHAR_g                      '\147'
#define CHAR_h                      '\150'
#define CHAR_i                      '\151'
#define CHAR_j                      '\152'
#define CHAR_k                      '\153'
#define CHAR_l                      '\154'
#define CHAR_m                      '\155'
#define CHAR_n                      '\156'
#define CHAR_o                      '\157'
#define CHAR_p                      '\160'
#define CHAR_q                      '\161'
#define CHAR_r                      '\162'
#define CHAR_s                      '\163'
#define CHAR_t                      '\164'
#define CHAR_u                      '\165'
#define CHAR_v                      '\166'
#define CHAR_w                      '\167'
#define CHAR_x                      '\170'
#define CHAR_y                      '\171'
#define CHAR_z                      '\172'
#define CHAR_LEFT_CURLY_BRACKET     '\173'
#define CHAR_VERTICAL_LINE          '\174'
#define CHAR_RIGHT_CURLY_BRACKET    '\175'
#define CHAR_TILDE                  '\176'
#define CHAR_NBSP                   ((unsigned char)'\xa0')

#define STR_HT                      "\011"
#define STR_VT                      "\013"
#define STR_FF                      "\014"
#define STR_CR                      "\015"
#define STR_NL                      "\012"
#define STR_BS                      "\010"
#define STR_BEL                     "\007"
#define STR_ESC                     "\033"
#define STR_DEL                     "\177"

#define STR_SPACE                   "\040"
#define STR_EXCLAMATION_MARK        "\041"
#define STR_QUOTATION_MARK          "\042"
#define STR_NUMBER_SIGN             "\043"
#define STR_DOLLAR_SIGN             "\044"
#define STR_PERCENT_SIGN            "\045"
#define STR_AMPERSAND               "\046"
#define STR_APOSTROPHE              "\047"
#define STR_LEFT_PARENTHESIS        "\050"
#define STR_RIGHT_PARENTHESIS       "\051"
#define STR_ASTERISK                "\052"
#define STR_PLUS                    "\053"
#define STR_COMMA                   "\054"
#define STR_MINUS                   "\055"
#define STR_DOT                     "\056"
#define STR_SLASH                   "\057"
#define STR_0                       "\060"
#define STR_1                       "\061"
#define STR_2                       "\062"
#define STR_3                       "\063"
#define STR_4                       "\064"
#define STR_5                       "\065"
#define STR_6                       "\066"
#define STR_7                       "\067"
#define STR_8                       "\070"
#define STR_9                       "\071"
#define STR_COLON                   "\072"
#define STR_SEMICOLON               "\073"
#define STR_LESS_THAN_SIGN          "\074"
#define STR_EQUALS_SIGN             "\075"
#define STR_GREATER_THAN_SIGN       "\076"
#define STR_QUESTION_MARK           "\077"
#define STR_COMMERCIAL_AT           "\100"
#define STR_A                       "\101"
#define STR_B                       "\102"
#define STR_C                       "\103"
#define STR_D                       "\104"
#define STR_E                       "\105"
#define STR_F                       "\106"
#define STR_G                       "\107"
#define STR_H                       "\110"
#define STR_I                       "\111"
#define STR_J                       "\112"
#define STR_K                       "\113"
#define STR_L                       "\114"
#define STR_M                       "\115"
#define STR_N                       "\116"
#define STR_O                       "\117"
#define STR_P                       "\120"
#define STR_Q                       "\121"
#define STR_R                       "\122"
#define STR_S                       "\123"
#define STR_T                       "\124"
#define STR_U                       "\125"
#define STR_V                       "\126"
#define STR_W                       "\127"
#define STR_X                       "\130"
#define STR_Y                       "\131"
#define STR_Z                       "\132"
#define STR_LEFT_SQUARE_BRACKET     "\133"
#define STR_BACKSLASH               "\134"
#define STR_RIGHT_SQUARE_BRACKET    "\135"
#define STR_CIRCUMFLEX_ACCENT       "\136"
#define STR_UNDERSCORE              "\137"
#define STR_GRAVE_ACCENT            "\140"
#define STR_a                       "\141"
#define STR_b                       "\142"
#define STR_c                       "\143"
#define STR_d                       "\144"
#define STR_e                       "\145"
#define STR_f                       "\146"
#define STR_g                       "\147"
#define STR_h                       "\150"
#define STR_i                       "\151"
#define STR_j                       "\152"
#define STR_k                       "\153"
#define STR_l                       "\154"
#define STR_m                       "\155"
#define STR_n                       "\156"
#define STR_o                       "\157"
#define STR_p                       "\160"
#define STR_q                       "\161"
#define STR_r                       "\162"
#define STR_s                       "\163"
#define STR_t                       "\164"
#define STR_u                       "\165"
#define STR_v                       "\166"
#define STR_w                       "\167"
#define STR_x                       "\170"
#define STR_y                       "\171"
#define STR_z                       "\172"
#define STR_LEFT_CURLY_BRACKET      "\173"
#define STR_VERTICAL_LINE           "\174"
#define STR_RIGHT_CURLY_BRACKET     "\175"
#define STR_TILDE                   "\176"

#define STRING_ACCEPT0               STR_A STR_C STR_C STR_E STR_P STR_T "\0"
#define STRING_COMMIT0               STR_C STR_O STR_M STR_M STR_I STR_T "\0"
#define STRING_F0                    STR_F "\0"
#define STRING_FAIL0                 STR_F STR_A STR_I STR_L "\0"
#define STRING_MARK0                 STR_M STR_A STR_R STR_K "\0"
#define STRING_PRUNE0                STR_P STR_R STR_U STR_N STR_E "\0"
#define STRING_SKIP0                 STR_S STR_K STR_I STR_P "\0"
#define STRING_THEN                  STR_T STR_H STR_E STR_N

#define STRING_atomic0               STR_a STR_t STR_o STR_m STR_i STR_c "\0"
#define STRING_pla0                  STR_p STR_l STR_a "\0"
#define STRING_plb0                  STR_p STR_l STR_b "\0"
#define STRING_napla0                STR_n STR_a STR_p STR_l STR_a "\0"
#define STRING_naplb0                STR_n STR_a STR_p STR_l STR_b "\0"
#define STRING_nla0                  STR_n STR_l STR_a "\0"
#define STRING_nlb0                  STR_n STR_l STR_b "\0"
#define STRING_scs0                  STR_s STR_c STR_s "\0"
#define STRING_sr0                   STR_s STR_r "\0"
#define STRING_asr0                  STR_a STR_s STR_r "\0"
#define STRING_positive_lookahead0   STR_p STR_o STR_s STR_i STR_t STR_i STR_v STR_e STR_UNDERSCORE STR_l STR_o STR_o STR_k STR_a STR_h STR_e STR_a STR_d "\0"
#define STRING_positive_lookbehind0  STR_p STR_o STR_s STR_i STR_t STR_i STR_v STR_e STR_UNDERSCORE STR_l STR_o STR_o STR_k STR_b STR_e STR_h STR_i STR_n STR_d "\0"
#define STRING_non_atomic_positive_lookahead0   STR_n STR_o STR_n STR_UNDERSCORE STR_a STR_t STR_o STR_m STR_i STR_c STR_UNDERSCORE STR_p STR_o STR_s STR_i STR_t STR_i STR_v STR_e STR_UNDERSCORE STR_l STR_o STR_o STR_k STR_a STR_h STR_e STR_a STR_d "\0"
#define STRING_non_atomic_positive_lookbehind0  STR_n STR_o STR_n STR_UNDERSCORE STR_a STR_t STR_o STR_m STR_i STR_c STR_UNDERSCORE STR_p STR_o STR_s STR_i STR_t STR_i STR_v STR_e STR_UNDERSCORE STR_l STR_o STR_o STR_k STR_b STR_e STR_h STR_i STR_n STR_d "\0"
#define STRING_negative_lookahead0   STR_n STR_e STR_g STR_a STR_t STR_i STR_v STR_e STR_UNDERSCORE STR_l STR_o STR_o STR_k STR_a STR_h STR_e STR_a STR_d "\0"
#define STRING_negative_lookbehind0  STR_n STR_e STR_g STR_a STR_t STR_i STR_v STR_e STR_UNDERSCORE STR_l STR_o STR_o STR_k STR_b STR_e STR_h STR_i STR_n STR_d "\0"
#define STRING_script_run0           STR_s STR_c STR_r STR_i STR_p STR_t STR_UNDERSCORE STR_r STR_u STR_n "\0"
#define STRING_atomic_script_run     STR_a STR_t STR_o STR_m STR_i STR_c STR_UNDERSCORE STR_s STR_c STR_r STR_i STR_p STR_t STR_UNDERSCORE STR_r STR_u STR_n
#define STRING_scan_substring0       STR_s STR_c STR_a STR_n STR_UNDERSCORE STR_s STR_u STR_b STR_s STR_t STR_r STR_i STR_n STR_g "\0"

#define STRING_alpha0                STR_a STR_l STR_p STR_h STR_a "\0"
#define STRING_lower0                STR_l STR_o STR_w STR_e STR_r "\0"
#define STRING_upper0                STR_u STR_p STR_p STR_e STR_r "\0"
#define STRING_alnum0                STR_a STR_l STR_n STR_u STR_m "\0"
#define STRING_ascii0                STR_a STR_s STR_c STR_i STR_i "\0"
#define STRING_blank0                STR_b STR_l STR_a STR_n STR_k "\0"
#define STRING_cntrl0                STR_c STR_n STR_t STR_r STR_l "\0"
#define STRING_digit0                STR_d STR_i STR_g STR_i STR_t "\0"
#define STRING_graph0                STR_g STR_r STR_a STR_p STR_h "\0"
#define STRING_print0                STR_p STR_r STR_i STR_n STR_t "\0"
#define STRING_punct0                STR_p STR_u STR_n STR_c STR_t "\0"
#define STRING_space0                STR_s STR_p STR_a STR_c STR_e "\0"
#define STRING_word0                 STR_w STR_o STR_r STR_d       "\0"
#define STRING_xdigit                STR_x STR_d STR_i STR_g STR_i STR_t

#define STRING_DEFINE                STR_D STR_E STR_F STR_I STR_N STR_E
#define STRING_VERSION               STR_V STR_E STR_R STR_S STR_I STR_O STR_N
#define STRING_WEIRD_STARTWORD       STR_LEFT_SQUARE_BRACKET STR_COLON STR_LESS_THAN_SIGN STR_COLON STR_RIGHT_SQUARE_BRACKET STR_RIGHT_SQUARE_BRACKET
#define STRING_WEIRD_ENDWORD         STR_LEFT_SQUARE_BRACKET STR_COLON STR_GREATER_THAN_SIGN STR_COLON STR_RIGHT_SQUARE_BRACKET STR_RIGHT_SQUARE_BRACKET

#define STRING_CR_RIGHTPAR                STR_C STR_R STR_RIGHT_PARENTHESIS
#define STRING_LF_RIGHTPAR                STR_L STR_F STR_RIGHT_PARENTHESIS
#define STRING_CRLF_RIGHTPAR              STR_C STR_R STR_L STR_F STR_RIGHT_PARENTHESIS
#define STRING_ANY_RIGHTPAR               STR_A STR_N STR_Y STR_RIGHT_PARENTHESIS
#define STRING_ANYCRLF_RIGHTPAR           STR_A STR_N STR_Y STR_C STR_R STR_L STR_F STR_RIGHT_PARENTHESIS
#define STRING_NUL_RIGHTPAR               STR_N STR_U STR_L STR_RIGHT_PARENTHESIS
#define STRING_BSR_ANYCRLF_RIGHTPAR       STR_B STR_S STR_R STR_UNDERSCORE STR_A STR_N STR_Y STR_C STR_R STR_L STR_F STR_RIGHT_PARENTHESIS
#define STRING_BSR_UNICODE_RIGHTPAR       STR_B STR_S STR_R STR_UNDERSCORE STR_U STR_N STR_I STR_C STR_O STR_D STR_E STR_RIGHT_PARENTHESIS
#define STRING_UTF8_RIGHTPAR              STR_U STR_T STR_F STR_8 STR_RIGHT_PARENTHESIS
#define STRING_UTF16_RIGHTPAR             STR_U STR_T STR_F STR_1 STR_6 STR_RIGHT_PARENTHESIS
#define STRING_UTF32_RIGHTPAR             STR_U STR_T STR_F STR_3 STR_2 STR_RIGHT_PARENTHESIS
#define STRING_UTF_RIGHTPAR               STR_U STR_T STR_F STR_RIGHT_PARENTHESIS
#define STRING_UCP_RIGHTPAR               STR_U STR_C STR_P STR_RIGHT_PARENTHESIS
#define STRING_EC_RIGHTPAR                STR_E STR_C STR_RIGHT_PARENTHESIS //au
#define STRING_NO_AUTO_POSSESS_RIGHTPAR   STR_N STR_O STR_UNDERSCORE STR_A STR_U STR_T STR_O STR_UNDERSCORE STR_P STR_O STR_S STR_S STR_E STR_S STR_S STR_RIGHT_PARENTHESIS
#define STRING_NO_DOTSTAR_ANCHOR_RIGHTPAR STR_N STR_O STR_UNDERSCORE STR_D STR_O STR_T STR_S STR_T STR_A STR_R STR_UNDERSCORE STR_A STR_N STR_C STR_H STR_O STR_R STR_RIGHT_PARENTHESIS
#define STRING_NO_JIT_RIGHTPAR            STR_N STR_O STR_UNDERSCORE STR_J STR_I STR_T STR_RIGHT_PARENTHESIS
#define STRING_NO_START_OPT_RIGHTPAR      STR_N STR_O STR_UNDERSCORE STR_S STR_T STR_A STR_R STR_T STR_UNDERSCORE STR_O STR_P STR_T STR_RIGHT_PARENTHESIS
#define STRING_NOTEMPTY_RIGHTPAR          STR_N STR_O STR_T STR_E STR_M STR_P STR_T STR_Y STR_RIGHT_PARENTHESIS
#define STRING_NOTEMPTY_ATSTART_RIGHTPAR  STR_N STR_O STR_T STR_E STR_M STR_P STR_T STR_Y STR_UNDERSCORE STR_A STR_T STR_S STR_T STR_A STR_R STR_T STR_RIGHT_PARENTHESIS
#define STRING_CASELESS_RESTRICT_RIGHTPAR STR_C STR_A STR_S STR_E STR_L STR_E STR_S STR_S STR_UNDERSCORE STR_R STR_E STR_S STR_T STR_R STR_I STR_C STR_T STR_RIGHT_PARENTHESIS
#define STRING_TURKISH_CASING_RIGHTPAR    STR_T STR_U STR_R STR_K STR_I STR_S STR_H STR_UNDERSCORE STR_C STR_A STR_S STR_I STR_N STR_G STR_RIGHT_PARENTHESIS
#define STRING_LIMIT_HEAP_EQ              STR_L STR_I STR_M STR_I STR_T STR_UNDERSCORE STR_H STR_E STR_A STR_P STR_EQUALS_SIGN
#define STRING_LIMIT_MATCH_EQ             STR_L STR_I STR_M STR_I STR_T STR_UNDERSCORE STR_M STR_A STR_T STR_C STR_H STR_EQUALS_SIGN
#define STRING_LIMIT_DEPTH_EQ             STR_L STR_I STR_M STR_I STR_T STR_UNDERSCORE STR_D STR_E STR_P STR_T STR_H STR_EQUALS_SIGN
#define STRING_LIMIT_RECURSION_EQ         STR_L STR_I STR_M STR_I STR_T STR_UNDERSCORE STR_R STR_E STR_C STR_U STR_R STR_S STR_I STR_O STR_N STR_EQUALS_SIGN
#define STRING_MARK                       STR_M STR_A STR_R STR_K

#define STRING_bc                         STR_b STR_c
#define STRING_bidiclass                  STR_b STR_i STR_d STR_i STR_c STR_l STR_a STR_s STR_s
#define STRING_sc                         STR_s STR_c
#define STRING_script                     STR_s STR_c STR_r STR_i STR_p STR_t
#define STRING_scriptextensions           STR_s STR_c STR_r STR_i STR_p STR_t STR_e STR_x STR_t STR_e STR_n STR_s STR_i STR_o STR_n STR_s
#define STRING_scx                        STR_s STR_c STR_x


#endif  /* SUPPORT_UNICODE */

/* -------------------- End of character and string names -------------------*/

/* -------------------- Definitions for compiled patterns -------------------*/

/* Codes for different types of Unicode property. If these definitions are
changed, the autopossessifying table in pcre2_auto_possess.c must be updated to
match. */

#define PT_LAMP       0    /* L& - the union of Lu, Ll, Lt */
#define PT_GC         1    /* Specified general characteristic (e.g. L) */
#define PT_PC         2    /* Specified particular characteristic (e.g. Lu) */
#define PT_SC         3    /* Script only (e.g. Han) */
#define PT_SCX        4    /* Script extensions (includes SC) */
#define PT_ALNUM      5    /* Alphanumeric - the union of L and N */
#define PT_SPACE      6    /* Perl space - general category Z plus 9,10,12,13 */
#define PT_PXSPACE    7    /* POSIX space - Z plus 9,10,11,12,13 */
#define PT_WORD       8    /* Word - L, N, Mn, or Pc */
#define PT_CLIST      9    /* Pseudo-property: match character list */
#define PT_UCNC      10    /* Universal Character nameable character */
#define PT_BIDICL    11    /* Specified bidi class */
#define PT_BOOL      12    /* Boolean property */
#define PT_ANY       13    /* Must be the last entry!
                              Any property - matches all chars */
#define PT_TABSIZE PT_ANY  /* Size of square table for autopossessify tests */

/* The following special properties are used only in XCLASS items, when POSIX
classes are specified and PCRE2_UCP is set - in other words, for Unicode
handling of these classes. They are not available via the \p or \P escapes like
those in the above list, and so they do not take part in the autopossessifying
table. */

#define PT_PXGRAPH   14    /* [:graph:] - characters that mark the paper */
#define PT_PXPRINT   15    /* [:print:] - [:graph:] plus non-control spaces */
#define PT_PXPUNCT   16    /* [:punct:] - punctuation characters */
#define PT_PXXDIGIT  17    /* [:xdigit:] - hex digits */

/* This value is used when parsing \p and \P escapes to indicate that neither
\p{script:...} nor \p{scx:...} has been encountered. */

#define PT_NOTSCRIPT 255

/* Flag bits and data types for the extended class (OP_XCLASS) for classes that
contain characters with values greater than 255. */

#define XCL_NOT      0x01  /* Flag: this is a negative class */
#define XCL_MAP      0x02  /* Flag: a 32-byte map is present */
#define XCL_HASPROP  0x04  /* Flag: property checks are present. */

#define XCL_END      0     /* Marks end of individual items */
#define XCL_SINGLE   1     /* Single item (one multibyte char) follows */
#define XCL_RANGE    2     /* A range (two multibyte chars) follows */
#define XCL_PROP     3     /* Unicode property (2-byte property code follows) */
#define XCL_NOTPROP  4     /* Unicode inverted property (ditto) */
/* This value represents the beginning of character lists. The value
is 16 bit long, and stored as a high and low byte pair in 8 bit mode.
The lower 12 bit contains information about character lists (see later). */
#define XCL_LIST     (sizeof(PCRE2_UCHAR) == 1 ? 0x10 : 0x1000)

/* When a character class contains many characters/ranges,
they are stored in character lists. There are four character
lists which contain characters/ranges within a given range.

The name, character range and item size for each list:
Low16    [0x100 - 0x7fff]            16 bit items
High16   [0x8000 - 0xffff]           16 bit items
Low32    [0x10000 - 0x7fffffff]      32 bit items
High32   [0x80000000 - 0xffffffff]   32 bit items

The Low32 character list is used only when utf encoding or 32 bit
character width is enabled, and the High32 character is used only
when 32 bit character width is enabled.

Each character list contain items. The lowest bit represents that
an item is the beginning of a range (bit is cleared), or not (bit
is set). The other bits represent the character shifted left by
one, so its highest bit is discarded. Due to the layout of character
lists, the highest bit of a character is always known:

Low16 and Low32: the highest bit is always zero
High16 and High32: the highest bit is always one

The items are ordered in increasing order, so binary search can be
used to find the lower bound of an input character. The lower bound
is the highest item, which value is less or equal than the input
character. If the lower bit of the item is cleard, or the character
stored in the item equals to the input character, the input
character is in the character list. */

/* Character list constants. */
#define XCL_CHAR_LIST_LOW_16_START 0x100
#define XCL_CHAR_LIST_LOW_16_END 0x7fff
#define XCL_CHAR_LIST_LOW_16_ADD 0x0

#define XCL_CHAR_LIST_HIGH_16_START 0x8000
#define XCL_CHAR_LIST_HIGH_16_END 0xffff
#define XCL_CHAR_LIST_HIGH_16_ADD 0x8000

#define XCL_CHAR_LIST_LOW_32_START 0x10000
#define XCL_CHAR_LIST_LOW_32_END 0x7fffffff
#define XCL_CHAR_LIST_LOW_32_ADD 0x0

#define XCL_CHAR_LIST_HIGH_32_START 0x80000000
#define XCL_CHAR_LIST_HIGH_32_END 0xffffffff
#define XCL_CHAR_LIST_HIGH_32_ADD 0x80000000

/* Mask for getting the descriptors of character list ranges.
Each descriptor has XCL_TYPE_BIT_LEN bits, and can be processed
by XCL_BEGIN_WITH_RANGE and XCL_ITEM_COUNT_MASK macros. */
#define XCL_TYPE_MASK 0xfff
#define XCL_TYPE_BIT_LEN 3
/* If this bit is set, the first item of the character list is the
end of a range, which started before the starting character of the
character list. */
#define XCL_BEGIN_WITH_RANGE 0x4
/* Number of items in the character list: 0, 1, or 2. The value 3
represents that the item count is stored at the begining of the
character list. The item count has the same width as the items
in the character list (e.g. 16 bit for Low16 and High16 lists). */
#define XCL_ITEM_COUNT_MASK 0x3
/* Shift and flag for constructing character list items. The XCL_CHAR_END
is set, when the item is not the beginning of a range. The XCL_CHAR_SHIFT
can be used to encode / decode the character value stored in an item. */
#define XCL_CHAR_END 0x1
#define XCL_CHAR_SHIFT 1

/* Flag bits for an extended class (OP_ECLASS), which is used for complex
character matches such as [\p{Greek} && \p{Ll}]. */

#define ECL_MAP     0x01  /* Flag: a 32-byte map is present */

/* Type tags for the items stored in an extended class (OP_ECLASS). These items
follow the OP_ECLASS's flag char and bitmap, and represent a Reverse Polish
Notation list of operands and operators manipulating a stack of bits. */

#define ECL_AND     1 /* Pop two from the stack, AND, and push result. */
#define ECL_OR      2 /* Pop two from the stack, OR, and push result. */
#define ECL_XOR     3 /* Pop two from the stack, XOR, and push result. */
#define ECL_NOT     4 /* Pop one from the stack, NOT, and push result. */
#define ECL_XCLASS  5 /* XCLASS nested within ECLASS; match and push result. */
#define ECL_ANY     6 /* Temporary, only used during compilation. */
#define ECL_NONE    7 /* Temporary, only used during compilation. */

/* These are escaped items that aren't just an encoding of a particular data
value such as \n. They must have non-zero values, as check_escape() returns 0
for a data character. In the escapes[] table in pcre2_compile.c their values
are negated in order to distinguish them from data values.

They must appear here in the same order as in the opcode definitions below, up
to ESC_z. There's a dummy for OP_ALLANY because it corresponds to "." in DOTALL
mode rather than an escape sequence. It is also used for [^] in JavaScript
compatibility mode, and for \C in non-utf mode. In non-DOTALL mode, "." behaves
like \N.

ESC_ub is a special return from check_escape() when, in BSUX mode, \u{ is not
followed by hex digits and }, in which case it should mean a literal "u"
followed by a literal "{". This hack is necessary for cases like \u{ 12}
because without it, this is interpreted as u{12} now that spaces are allowed in
quantifiers.

Negative numbers are used to encode a backreference (\1, \2, \3, etc.) in
check_escape(). There are tests in the code for an escape greater than ESC_b
and less than ESC_Z to detect the types that may be repeated. These are the
types that consume characters. If any new escapes are put in between that don't
consume a character, that code will have to change. */

enum { ESC_A = 1, ESC_G, ESC_K, ESC_B, ESC_b, ESC_D, ESC_d, ESC_S, ESC_s,
       ESC_W, ESC_w, ESC_N, ESC_dum, ESC_C, ESC_P, ESC_p, ESC_R, ESC_H,
       ESC_h, ESC_V, ESC_v, ESC_X, ESC_Z, ESC_z,
       ESC_E, ESC_Q, ESC_g, ESC_k, ESC_ub };


/********************** Opcode definitions ******************/

/****** NOTE NOTE NOTE ******

Starting from 1 (i.e. after OP_END), the values up to OP_EOD must correspond in
order to the list of escapes immediately above. Furthermore, values up to
OP_DOLLM must not be changed without adjusting the table called autoposstab in
pcre2_auto_possess.c.

Whenever this list is updated, the two macro definitions that follow must be
updated to match. The possessification table called "opcode_possessify" in
pcre2_compile.c must also be updated, and also the tables called "coptable"
and "poptable" in pcre2_dfa_match.c.

****** NOTE NOTE NOTE ******/


/* The values between FIRST_AUTOTAB_OP and LAST_AUTOTAB_RIGHT_OP, inclusive,
are used in a table for deciding whether a repeated character type can be
auto-possessified. */

#define FIRST_AUTOTAB_OP       OP_NOT_DIGIT
#define LAST_AUTOTAB_LEFT_OP   OP_EXTUNI
#define LAST_AUTOTAB_RIGHT_OP  OP_DOLLM

enum {
  OP_END,            /* 0 End of pattern */

  /* Values corresponding to backslashed metacharacters */

  OP_SOD,            /* 1 Start of data: \A */
  OP_SOM,            /* 2 Start of match (subject + offset): \G */
  OP_SET_SOM,        /* 3 Set start of match (\K) */
  OP_NOT_WORD_BOUNDARY,  /*  4 \B -- see also OP_NOT_UCP_WORD_BOUNDARY */
  OP_WORD_BOUNDARY,      /*  5 \b -- see also OP_UCP_WORD_BOUNDARY */
  OP_NOT_DIGIT,          /*  6 \D */
  OP_DIGIT,              /*  7 \d */
  OP_NOT_WHITESPACE,     /*  8 \S */
  OP_WHITESPACE,         /*  9 \s */
  OP_NOT_WORDCHAR,       /* 10 \W */
  OP_WORDCHAR,           /* 11 \w */

  OP_ANY,            /* 12 Match any character except newline (\N) */
  OP_ALLANY,         /* 13 Match any character */
  OP_ANYBYTE,        /* 14 Match any byte (\C); different to OP_ANY for UTF-8 */
  OP_NOTPROP,        /* 15 \P (not Unicode property) */
  OP_PROP,           /* 16 \p (Unicode property) */
  OP_ANYNL,          /* 17 \R (any newline sequence) */
  OP_NOT_HSPACE,     /* 18 \H (not horizontal whitespace) */
  OP_HSPACE,         /* 19 \h (horizontal whitespace) */
  OP_NOT_VSPACE,     /* 20 \V (not vertical whitespace) */
  OP_VSPACE,         /* 21 \v (vertical whitespace) */
  OP_EXTUNI,         /* 22 \X (extended Unicode sequence */
  OP_EODN,           /* 23 End of data or \n at end of data (\Z) */
  OP_EOD,            /* 24 End of data (\z) */

  /* Line end assertions */

  OP_DOLL,           /* 25 End of line - not multiline */
  OP_DOLLM,          /* 26 End of line - multiline */
  OP_CIRC,           /* 27 Start of line - not multiline */
  OP_CIRCM,          /* 28 Start of line - multiline */

  /* Single characters; caseful must precede the caseless ones, and these
  must remain in this order, and adjacent. */

  OP_CHAR,           /* 29 Match one character, casefully */
  OP_CHARI,          /* 30 Match one character, caselessly */
  OP_NOT,            /* 31 Match one character, not the given one, casefully */
  OP_NOTI,           /* 32 Match one character, not the given one, caselessly */

  /* The following sets of 13 opcodes must always be kept in step because
  the offset from the first one is used to generate the others. */

  /* Repeated characters; caseful must precede the caseless ones */

  OP_STAR,           /* 33 The maximizing and minimizing versions of */
  OP_MINSTAR,        /* 34 these six opcodes must come in pairs, with */
  OP_PLUS,           /* 35 the minimizing one second. */
  OP_MINPLUS,        /* 36 */
  OP_QUERY,          /* 37 */
  OP_MINQUERY,       /* 38 */

  OP_UPTO,           /* 39 From 0 to n matches of one character, caseful*/
  OP_MINUPTO,        /* 40 */
  OP_EXACT,          /* 41 Exactly n matches */

  OP_POSSTAR,        /* 42 Possessified star, caseful */
  OP_POSPLUS,        /* 43 Possessified plus, caseful */
  OP_POSQUERY,       /* 44 Posesssified query, caseful */
  OP_POSUPTO,        /* 45 Possessified upto, caseful */

  /* Repeated characters; caseless must follow the caseful ones */

  OP_STARI,          /* 46 */
  OP_MINSTARI,       /* 47 */
  OP_PLUSI,          /* 48 */
  OP_MINPLUSI,       /* 49 */
  OP_QUERYI,         /* 50 */
  OP_MINQUERYI,      /* 51 */

  OP_UPTOI,          /* 52 From 0 to n matches of one character, caseless */
  OP_MINUPTOI,       /* 53 */
  OP_EXACTI,         /* 54 */

  OP_POSSTARI,       /* 55 Possessified star, caseless */
  OP_POSPLUSI,       /* 56 Possessified plus, caseless */
  OP_POSQUERYI,      /* 57 Posesssified query, caseless */
  OP_POSUPTOI,       /* 58 Possessified upto, caseless */

  /* The negated ones must follow the non-negated ones, and match them */
  /* Negated repeated character, caseful; must precede the caseless ones */

  OP_NOTSTAR,        /* 59 The maximizing and minimizing versions of */
  OP_NOTMINSTAR,     /* 60 these six opcodes must come in pairs, with */
  OP_NOTPLUS,        /* 61 the minimizing one second. They must be in */
  OP_NOTMINPLUS,     /* 62 exactly the same order as those above. */
  OP_NOTQUERY,       /* 63 */
  OP_NOTMINQUERY,    /* 64 */

  OP_NOTUPTO,        /* 65 From 0 to n matches, caseful */
  OP_NOTMINUPTO,     /* 66 */
  OP_NOTEXACT,       /* 67 Exactly n matches */

  OP_NOTPOSSTAR,     /* 68 Possessified versions, caseful */
  OP_NOTPOSPLUS,     /* 69 */
  OP_NOTPOSQUERY,    /* 70 */
  OP_NOTPOSUPTO,     /* 71 */

  /* Negated repeated character, caseless; must follow the caseful ones */

  OP_NOTSTARI,       /* 72 */
  OP_NOTMINSTARI,    /* 73 */
  OP_NOTPLUSI,       /* 74 */
  OP_NOTMINPLUSI,    /* 75 */
  OP_NOTQUERYI,      /* 76 */
  OP_NOTMINQUERYI,   /* 77 */

  OP_NOTUPTOI,       /* 78 From 0 to n matches, caseless */
  OP_NOTMINUPTOI,    /* 79 */
  OP_NOTEXACTI,      /* 80 Exactly n matches */

  OP_NOTPOSSTARI,    /* 81 Possessified versions, caseless */
  OP_NOTPOSPLUSI,    /* 82 */
  OP_NOTPOSQUERYI,   /* 83 */
  OP_NOTPOSUPTOI,    /* 84 */

  /* Character types */

  OP_TYPESTAR,       /* 85 The maximizing and minimizing versions of */
  OP_TYPEMINSTAR,    /* 86 these six opcodes must come in pairs, with */
  OP_TYPEPLUS,       /* 87 the minimizing one second. These codes must */
  OP_TYPEMINPLUS,    /* 88 be in exactly the same order as those above. */
  OP_TYPEQUERY,      /* 89 */
  OP_TYPEMINQUERY,   /* 90 */

  OP_TYPEUPTO,       /* 91 From 0 to n matches */
  OP_TYPEMINUPTO,    /* 92 */
  OP_TYPEEXACT,      /* 93 Exactly n matches */

  OP_TYPEPOSSTAR,    /* 94 Possessified versions */
  OP_TYPEPOSPLUS,    /* 95 */
  OP_TYPEPOSQUERY,   /* 96 */
  OP_TYPEPOSUPTO,    /* 97 */

  /* These are used for character classes and back references; only the
  first six are the same as the sets above. */

  OP_CRSTAR,         /* 98 The maximizing and minimizing versions of */
  OP_CRMINSTAR,      /* 99 all these opcodes must come in pairs, with */
  OP_CRPLUS,         /* 100 the minimizing one second. These codes must */
  OP_CRMINPLUS,      /* 101 be in exactly the same order as those above. */
  OP_CRQUERY,        /* 102 */
  OP_CRMINQUERY,     /* 103 */

  OP_CRRANGE,        /* 104 These are different to the three sets above. */
  OP_CRMINRANGE,     /* 105 */

  OP_CRPOSSTAR,      /* 106 Possessified versions */
  OP_CRPOSPLUS,      /* 107 */
  OP_CRPOSQUERY,     /* 108 */
  OP_CRPOSRANGE,     /* 109 */

  /* End of quantifier opcodes */

  OP_CLASS,          /* 110 Match a character class, chars < 256 only */
  OP_NCLASS,         /* 111 Same, but the bitmap was created from a negative
                              class - the difference is relevant only when a
                              character > 255 is encountered. */
  OP_XCLASS,         /* 112 Extended class for handling > 255 chars within the
                              class. This does both positive and negative. */
  OP_ECLASS,         /* 113 Really-extended class, for handling logical
                              expressions computed over characters. */
  OP_REF,            /* 114 Match a back reference, casefully */
  OP_REFI,           /* 115 Match a back reference, caselessly */
  OP_DNREF,          /* 116 Match a duplicate name backref, casefully */
  OP_DNREFI,         /* 117 Match a duplicate name backref, caselessly */
  OP_RECURSE,        /* 118 Match a numbered subpattern (possibly recursive) */
  OP_CALLOUT,        /* 119 Call out to external function if provided */
  OP_CALLOUT_STR,    /* 120 Call out with string argument */

  OP_ALT,            /* 121 Start of alternation */
  OP_KET,            /* 122 End of group that doesn't have an unbounded repeat */
  OP_KETRMAX,        /* 123 These two must remain together and in this */
  OP_KETRMIN,        /* 124 order. They are for groups the repeat for ever. */
  OP_KETRPOS,        /* 125 Possessive unlimited repeat. */

  /* The assertions must come before BRA, CBRA, ONCE, and COND. */

  OP_REVERSE,        /* 126 Move pointer back - used in lookbehind assertions */
  OP_VREVERSE,       /* 127 Move pointer back - variable */
  OP_ASSERT,         /* 128 Positive lookahead */
  OP_ASSERT_NOT,     /* 129 Negative lookahead */
  OP_ASSERTBACK,     /* 130 Positive lookbehind */
  OP_ASSERTBACK_NOT, /* 131 Negative lookbehind */
  OP_ASSERT_NA,      /* 132 Positive non-atomic lookahead */
  OP_ASSERTBACK_NA,  /* 133 Positive non-atomic lookbehind */
  OP_ASSERT_SCS,     /* 134 Scan substring */

  /* ONCE, SCRIPT_RUN, BRA, BRAPOS, CBRA, CBRAPOS, and COND must come
  immediately after the assertions, with ONCE first, as there's a test for >=
  ONCE for a subpattern that isn't an assertion. The POS versions must
  immediately follow the non-POS versions in each case. */

  OP_ONCE,           /* 135 Atomic group, contains captures */
  OP_SCRIPT_RUN,     /* 136 Non-capture, but check characters' scripts */
  OP_BRA,            /* 137 Start of non-capturing bracket */
  OP_BRAPOS,         /* 138 Ditto, with unlimited, possessive repeat */
  OP_CBRA,           /* 139 Start of capturing bracket */
  OP_CBRAPOS,        /* 140 Ditto, with unlimited, possessive repeat */
  OP_COND,           /* 141 Conditional group */

  /* These five must follow the previous five, in the same order. There's a
  check for >= SBRA to distinguish the two sets. */

  OP_SBRA,           /* 142 Start of non-capturing bracket, check empty  */
  OP_SBRAPOS,        /* 143 Ditto, with unlimited, possessive repeat */
  OP_SCBRA,          /* 144 Start of capturing bracket, check empty */
  OP_SCBRAPOS,       /* 145 Ditto, with unlimited, possessive repeat */
  OP_SCOND,          /* 146 Conditional group, check empty */

  /* The next two pairs must (respectively) be kept together. */

  OP_CREF,           /* 147 Used to hold a capture number as condition */
  OP_DNCREF,         /* 148 Used to point to duplicate names as a condition */
  OP_RREF,           /* 149 Used to hold a recursion number as condition */
  OP_DNRREF,         /* 150 Used to point to duplicate names as a condition */
  OP_FALSE,          /* 151 Always false (used by DEFINE and VERSION) */
  OP_TRUE,           /* 152 Always true (used by VERSION) */

  OP_BRAZERO,        /* 153 These two must remain together and in this */
  OP_BRAMINZERO,     /* 154 order. */
  OP_BRAPOSZERO,     /* 155 */

  /* These are backtracking control verbs */

  OP_MARK,           /* 156 always has an argument */
  OP_PRUNE,          /* 157 */
  OP_PRUNE_ARG,      /* 158 same, but with argument */
  OP_SKIP,           /* 159 */
  OP_SKIP_ARG,       /* 160 same, but with argument */
  OP_THEN,           /* 161 */
  OP_THEN_ARG,       /* 162 same, but with argument */
  OP_COMMIT,         /* 163 */
  OP_COMMIT_ARG,     /* 164 same, but with argument */

  /* These are forced failure and success verbs. FAIL and ACCEPT do accept an
  argument, but these cases can be compiled as, for example, (*MARK:X)(*FAIL)
  without the need for a special opcode. */

  OP_FAIL,           /* 165 */
  OP_ACCEPT,         /* 166 */
  OP_ASSERT_ACCEPT,  /* 167 Used inside assertions */
  OP_CLOSE,          /* 168 Used before OP_ACCEPT to close open captures */

  /* This is used to skip a subpattern with a {0} quantifier */

  OP_SKIPZERO,       /* 169 */

  /* This is used to identify a DEFINE group during compilation so that it can
  be checked for having only one branch. It is changed to OP_FALSE before
  compilation finishes. */

  OP_DEFINE,         /* 170 */

  /* These opcodes replace their normal counterparts in UCP mode when
  PCRE2_EXTRA_ASCII_BSW is not set. */

  OP_NOT_UCP_WORD_BOUNDARY, /* 171 */
  OP_UCP_WORD_BOUNDARY,     /* 172 */

  /* This is not an opcode, but is used to check that tables indexed by opcode
  are the correct length, in order to catch updating errors - there have been
  some in the past. */

  OP_TABLE_LENGTH

};

/* *** NOTE NOTE NOTE *** Whenever the list above is updated, the two macro
definitions that follow must also be updated to match. There are also tables
called "opcode_possessify" in pcre2_compile.c and "coptable" and "poptable" in
pcre2_dfa_match.c that must be updated. */


/* This macro defines textual names for all the opcodes. These are used only
for debugging, and some of them are only partial names. The macro is referenced
only in pcre2_printint.c, which fills out the full names in many cases (and in
some cases doesn't actually use these names at all). */

#define OP_NAME_LIST \
  "End", "\\A", "\\G", "\\K", "\\B", "\\b", "\\D", "\\d",         \
  "\\S", "\\s", "\\W", "\\w", "Any", "AllAny", "Anybyte",         \
  "notprop", "prop", "\\R", "\\H", "\\h", "\\V", "\\v",           \
  "extuni",  "\\Z", "\\z",                                        \
  "$", "$", "^", "^", "char", "chari", "not", "noti",             \
  "*", "*?", "+", "+?", "?", "??",                                \
  "{", "{", "{",                                                  \
  "*+","++", "?+", "{",                                           \
  "*", "*?", "+", "+?", "?", "??",                                \
  "{", "{", "{",                                                  \
  "*+","++", "?+", "{",                                           \
  "*", "*?", "+", "+?", "?", "??",                                \
  "{", "{", "{",                                                  \
  "*+","++", "?+", "{",                                           \
  "*", "*?", "+", "+?", "?", "??",                                \
  "{", "{", "{",                                                  \
  "*+","++", "?+", "{",                                           \
  "*", "*?", "+", "+?", "?", "??", "{", "{", "{",                 \
  "*+","++", "?+", "{",                                           \
  "*", "*?", "+", "+?", "?", "??", "{", "{",                      \
  "*+","++", "?+", "{",                                           \
  "class", "nclass", "xclass", "eclass",                          \
  "Ref", "Refi", "DnRef", "DnRefi",                               \
  "Recurse", "Callout", "CalloutStr",                             \
  "Alt", "Ket", "KetRmax", "KetRmin", "KetRpos",                  \
  "Reverse", "VReverse", "Assert", "Assert not",                  \
  "Assert back", "Assert back not",                               \
  "Non-atomic assert", "Non-atomic assert back",                  \
  "Scan substring",                                               \
  "Once",                                                         \
  "Script run",                                                   \
  "Bra", "BraPos", "CBra", "CBraPos",                             \
  "Cond",                                                         \
  "SBra", "SBraPos", "SCBra", "SCBraPos",                         \
  "SCond",                                                        \
  "Capture ref", "Capture dnref", "Cond rec", "Cond dnrec",       \
  "Cond false", "Cond true",                                      \
  "Brazero", "Braminzero", "Braposzero",                          \
  "*MARK", "*PRUNE", "*PRUNE", "*SKIP", "*SKIP",                  \
  "*THEN", "*THEN", "*COMMIT", "*COMMIT", "*FAIL",                \
  "*ACCEPT", "*ASSERT_ACCEPT",                                    \
  "Close", "Skip zero", "Define", "\\B (ucp)", "\\b (ucp)"


/* This macro defines the length of fixed length operations in the compiled
regex. The lengths are used when searching for specific things, and also in the
debugging printing of a compiled regex. We use a macro so that it can be
defined close to the definitions of the opcodes themselves.

As things have been extended, some of these are no longer fixed lenths, but are
minima instead. For example, the length of a single-character repeat may vary
in UTF-8 mode. The code that uses this table must know about such things. */

#define OP_LENGTHS \
  1,                             /* End                                    */ \
  1, 1, 1, 1, 1,                 /* \A, \G, \K, \B, \b                     */ \
  1, 1, 1, 1, 1, 1,              /* \D, \d, \S, \s, \W, \w                 */ \
  1, 1, 1,                       /* Any, AllAny, Anybyte                   */ \
  3, 3,                          /* \P, \p                                 */ \
  1, 1, 1, 1, 1,                 /* \R, \H, \h, \V, \v                     */ \
  1,                             /* \X                                     */ \
  1, 1, 1, 1, 1, 1,              /* \Z, \z, $, $M ^, ^M                    */ \
  2,                             /* Char  - the minimum length             */ \
  2,                             /* Chari  - the minimum length            */ \
  2,                             /* not                                    */ \
  2,                             /* noti                                   */ \
  /* Positive single-char repeats                             ** These are */ \
  2, 2, 2, 2, 2, 2,              /* *, *?, +, +?, ?, ??       ** minima in */ \
  2+IMM2_SIZE, 2+IMM2_SIZE,      /* upto, minupto             ** mode      */ \
  2+IMM2_SIZE,                   /* exact                                  */ \
  2, 2, 2, 2+IMM2_SIZE,          /* *+, ++, ?+, upto+                      */ \
  2, 2, 2, 2, 2, 2,              /* *I, *?I, +I, +?I, ?I, ??I ** UTF-8     */ \
  2+IMM2_SIZE, 2+IMM2_SIZE,      /* upto I, minupto I                      */ \
  2+IMM2_SIZE,                   /* exact I                                */ \
  2, 2, 2, 2+IMM2_SIZE,          /* *+I, ++I, ?+I, upto+I                  */ \
  /* Negative single-char repeats - only for chars < 256                   */ \
  2, 2, 2, 2, 2, 2,              /* NOT *, *?, +, +?, ?, ??                */ \
  2+IMM2_SIZE, 2+IMM2_SIZE,      /* NOT upto, minupto                      */ \
  2+IMM2_SIZE,                   /* NOT exact                              */ \
  2, 2, 2, 2+IMM2_SIZE,          /* Possessive NOT *, +, ?, upto           */ \
  2, 2, 2, 2, 2, 2,              /* NOT *I, *?I, +I, +?I, ?I, ??I          */ \
  2+IMM2_SIZE, 2+IMM2_SIZE,      /* NOT upto I, minupto I                  */ \
  2+IMM2_SIZE,                   /* NOT exact I                            */ \
  2, 2, 2, 2+IMM2_SIZE,          /* Possessive NOT *I, +I, ?I, upto I      */ \
  /* Positive type repeats                                                 */ \
  2, 2, 2, 2, 2, 2,              /* Type *, *?, +, +?, ?, ??               */ \
  2+IMM2_SIZE, 2+IMM2_SIZE,      /* Type upto, minupto                     */ \
  2+IMM2_SIZE,                   /* Type exact                             */ \
  2, 2, 2, 2+IMM2_SIZE,          /* Possessive *+, ++, ?+, upto+           */ \
  /* Character class & ref repeats                                         */ \
  1, 1, 1, 1, 1, 1,              /* *, *?, +, +?, ?, ??                    */ \
  1+2*IMM2_SIZE, 1+2*IMM2_SIZE,  /* CRRANGE, CRMINRANGE                    */ \
  1, 1, 1, 1+2*IMM2_SIZE,        /* Possessive *+, ++, ?+, CRPOSRANGE      */ \
  1+(32/sizeof(PCRE2_UCHAR)),    /* CLASS                                  */ \
  1+(32/sizeof(PCRE2_UCHAR)),    /* NCLASS                                 */ \
  0,                             /* XCLASS - variable length               */ \
  0,                             /* ECLASS - variable length               */ \
  1+IMM2_SIZE,                   /* REF                                    */ \
  1+IMM2_SIZE+1,                 /* REFI                                   */ \
  1+2*IMM2_SIZE,                 /* DNREF                                  */ \
  1+2*IMM2_SIZE+1,               /* DNREFI                                 */ \
  1+LINK_SIZE,                   /* RECURSE                                */ \
  1+2*LINK_SIZE+1,               /* CALLOUT                                */ \
  0,                             /* CALLOUT_STR - variable length          */ \
  1+LINK_SIZE,                   /* Alt                                    */ \
  1+LINK_SIZE,                   /* Ket                                    */ \
  1+LINK_SIZE,                   /* KetRmax                                */ \
  1+LINK_SIZE,                   /* KetRmin                                */ \
  1+LINK_SIZE,                   /* KetRpos                                */ \
  1+IMM2_SIZE,                   /* Reverse                                */ \
  1+2*IMM2_SIZE,                 /* VReverse                               */ \
  1+LINK_SIZE,                   /* Assert                                 */ \
  1+LINK_SIZE,                   /* Assert not                             */ \
  1+LINK_SIZE,                   /* Assert behind                          */ \
  1+LINK_SIZE,                   /* Assert behind not                      */ \
  1+LINK_SIZE,                   /* NA Assert                              */ \
  1+LINK_SIZE,                   /* NA Assert behind                       */ \
  1+LINK_SIZE,                   /* Scan substring                         */ \
  1+LINK_SIZE,                   /* ONCE                                   */ \
  1+LINK_SIZE,                   /* SCRIPT_RUN                             */ \
  1+LINK_SIZE,                   /* BRA                                    */ \
  1+LINK_SIZE,                   /* BRAPOS                                 */ \
  1+LINK_SIZE+IMM2_SIZE,         /* CBRA                                   */ \
  1+LINK_SIZE+IMM2_SIZE,         /* CBRAPOS                                */ \
  1+LINK_SIZE,                   /* COND                                   */ \
  1+LINK_SIZE,                   /* SBRA                                   */ \
  1+LINK_SIZE,                   /* SBRAPOS                                */ \
  1+LINK_SIZE+IMM2_SIZE,         /* SCBRA                                  */ \
  1+LINK_SIZE+IMM2_SIZE,         /* SCBRAPOS                               */ \
  1+LINK_SIZE,                   /* SCOND                                  */ \
  1+IMM2_SIZE, 1+2*IMM2_SIZE,    /* CREF, DNCREF                           */ \
  1+IMM2_SIZE, 1+2*IMM2_SIZE,    /* RREF, DNRREF                           */ \
  1, 1,                          /* FALSE, TRUE                            */ \
  1, 1, 1,                       /* BRAZERO, BRAMINZERO, BRAPOSZERO        */ \
  3, 1, 3,                       /* MARK, PRUNE, PRUNE_ARG                 */ \
  1, 3,                          /* SKIP, SKIP_ARG                         */ \
  1, 3,                          /* THEN, THEN_ARG                         */ \
  1, 3,                          /* COMMIT, COMMIT_ARG                     */ \
  1, 1, 1,                       /* FAIL, ACCEPT, ASSERT_ACCEPT            */ \
  1+IMM2_SIZE, 1,                /* CLOSE, SKIPZERO                        */ \
  1,                             /* DEFINE                                 */ \
  1, 1                           /* \B and \b in UCP mode                  */

/* A magic value for OP_RREF to indicate the "any recursion" condition. */

#define RREF_ANY  0xffff

/* Constants used by OP_REFI and OP_DNREFI to control matching behaviour. */

#define REFI_FLAG_CASELESS_RESTRICT  0x1
#define REFI_FLAG_TURKISH_CASING     0x2


/* ---------- Private structures that are mode-independent. ---------- */

/* Structure to hold data for custom memory management. */

typedef struct pcre2_memctl {
  void *    (*malloc)(size_t, void *);
  void      (*free)(void *, void *);
  void      *memory_data;
} pcre2_memctl;

/* Structure for building a chain of open capturing subpatterns during
compiling, so that instructions to close them can be compiled when (*ACCEPT) is
encountered. */

typedef struct open_capitem {
  struct open_capitem *next;    /* Chain link */
  uint16_t number;              /* Capture number */
  uint16_t assert_depth;        /* Assertion depth when opened */
} open_capitem;

/* Layout of the UCP type table that translates property names into types and
codes. Each entry used to point directly to a name, but to reduce the number of
relocations in shared libraries, it now has an offset into a single string
instead. */

typedef struct {
  uint16_t name_offset;
  uint16_t type;
  uint16_t value;
} ucp_type_table;

/* Unicode character database (UCD) record format */

typedef struct {
  uint8_t script;     /* ucp_Arabic, etc. */
  uint8_t chartype;   /* ucp_Cc, etc. (general categories) */
  uint8_t gbprop;     /* ucp_gbControl, etc. (grapheme break property) */
  uint8_t caseset;    /* offset to multichar other cases or zero */
  int32_t other_case; /* offset to other case, or zero if none */
  uint16_t scriptx_bidiclass; /* script extension (11 bit) and bidi class (5 bit) values */
  uint16_t bprops;    /* binary properties offset */
} ucd_record;

/* UCD access macros */

#define UCD_BLOCK_SIZE 128
#define REAL_GET_UCD(ch) (PRIV(ucd_records) + \
        PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \
        UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE])

#if PCRE2_CODE_UNIT_WIDTH == 32
#define GET_UCD(ch) ((ch > MAX_UTF_CODE_POINT)? \
  PRIV(dummy_ucd_record) : REAL_GET_UCD(ch))
#else
#define GET_UCD(ch) REAL_GET_UCD(ch)
#endif

#define UCD_SCRIPTX_MASK 0x3ff
#define UCD_BIDICLASS_SHIFT 11
#define UCD_BPROPS_MASK 0xfff

#define UCD_SCRIPTX_PROP(prop) ((prop)->scriptx_bidiclass & UCD_SCRIPTX_MASK)
#define UCD_BIDICLASS_PROP(prop) ((prop)->scriptx_bidiclass >> UCD_BIDICLASS_SHIFT)
#define UCD_BPROPS_PROP(prop) ((prop)->bprops & UCD_BPROPS_MASK)

#define UCD_CHARTYPE(ch)    GET_UCD(ch)->chartype
#define UCD_SCRIPT(ch)      GET_UCD(ch)->script
#define UCD_CATEGORY(ch)    PRIV(ucp_gentype)[UCD_CHARTYPE(ch)]
#define UCD_GRAPHBREAK(ch)  GET_UCD(ch)->gbprop
#define UCD_CASESET(ch)     GET_UCD(ch)->caseset
#define UCD_OTHERCASE(ch)   ((uint32_t)((int)ch + (int)(GET_UCD(ch)->other_case)))
#define UCD_SCRIPTX(ch)     UCD_SCRIPTX_PROP(GET_UCD(ch))
#define UCD_BPROPS(ch)      UCD_BPROPS_PROP(GET_UCD(ch))
#define UCD_BIDICLASS(ch)   UCD_BIDICLASS_PROP(GET_UCD(ch))
#define UCD_ANY_I(ch) \
  /* match any of the four characters 'i', 'I', U+0130, U+0131 */ \
  (((uint32_t)(ch) | 0x20u) == 0x69u || ((uint32_t)(ch) | 1u) == 0x0131u)
#define UCD_DOTTED_I(ch) \
  ((uint32_t)(ch) == 0x69u || (uint32_t)(ch) == 0x0130u)
#define UCD_FOLD_I_TURKISH(ch) \
  ((uint32_t)(ch) == 0x0130u ?   0x69u : \
   (uint32_t)(ch) ==   0x49u ? 0x0131u : (uint32_t)(ch))

/* The "scriptx" and bprops fields contain offsets into vectors of 32-bit words
that form a bitmap representing a list of scripts or boolean properties. These
macros test or set a bit in the map by number. */

#define MAPBIT(map,n) ((map)[(n)/32]&(1u<<((n)%32)))
#define MAPSET(map,n) ((map)[(n)/32]|=(1u<<((n)%32)))

/* Header for serialized pcre2 codes. */

typedef struct pcre2_serialized_data {
  uint32_t magic;
  uint32_t version;
  uint32_t config;
  int32_t  number_of_codes;
} pcre2_serialized_data;



/* ----------------- Items that need PCRE2_CODE_UNIT_WIDTH ----------------- */

/* When this file is included by pcre2test, PCRE2_CODE_UNIT_WIDTH is defined as
0, so the following items are omitted. */

#if defined PCRE2_CODE_UNIT_WIDTH && PCRE2_CODE_UNIT_WIDTH != 0

/* EBCDIC is supported only for the 8-bit library. */

#if defined EBCDIC && PCRE2_CODE_UNIT_WIDTH != 8
#error EBCDIC is not supported for the 16-bit or 32-bit libraries
#endif

/* This is the largest non-UTF code point. */

#define MAX_NON_UTF_CHAR (0xffffffffU >> (32 - PCRE2_CODE_UNIT_WIDTH))

/* Internal shared data tables and variables. These are used by more than one
of the exported public functions. They have to be "external" in the C sense,
but are not part of the PCRE2 public API. Although the data for some of them is
identical in all libraries, they must have different names so that multiple
libraries can be simultaneously linked to a single application. However, UTF-8
tables are needed only when compiling the 8-bit library. */

#if PCRE2_CODE_UNIT_WIDTH == 8
extern const int              PRIV(utf8_table1)[];
extern const int              PRIV(utf8_table1_size);
extern const int              PRIV(utf8_table2)[];
extern const int              PRIV(utf8_table3)[];
extern const uint8_t          PRIV(utf8_table4)[];
#endif

#define _pcre2_OP_lengths              PCRE2_SUFFIX(_pcre2_OP_lengths_)
#define _pcre2_callout_end_delims      PCRE2_SUFFIX(_pcre2_callout_end_delims_)
#define _pcre2_callout_start_delims    PCRE2_SUFFIX(_pcre2_callout_start_delims_)
#define _pcre2_default_compile_context PCRE2_SUFFIX(_pcre2_default_compile_context_)
#define _pcre2_default_convert_context PCRE2_SUFFIX(_pcre2_default_convert_context_)
#define _pcre2_default_match_context   PCRE2_SUFFIX(_pcre2_default_match_context_)
#define _pcre2_default_tables          PCRE2_SUFFIX(_pcre2_default_tables_)
#if PCRE2_CODE_UNIT_WIDTH == 32
#define _pcre2_dummy_ucd_record        PCRE2_SUFFIX(_pcre2_dummy_ucd_record_)
#endif
#define _pcre2_hspace_list             PCRE2_SUFFIX(_pcre2_hspace_list_)
#define _pcre2_vspace_list             PCRE2_SUFFIX(_pcre2_vspace_list_)
#define _pcre2_ucd_boolprop_sets       PCRE2_SUFFIX(_pcre2_ucd_boolprop_sets_)
#define _pcre2_ucd_caseless_sets       PCRE2_SUFFIX(_pcre2_ucd_caseless_sets_)
#define _pcre2_ucd_turkish_dotted_i_caseset  PCRE2_SUFFIX(_pcre2_ucd_turkish_dotted_i_caseset_)
#define _pcre2_ucd_nocase_ranges       PCRE2_SUFFIX(_pcre2_ucd_nocase_ranges_)
#define _pcre2_ucd_nocase_ranges_size  PCRE2_SUFFIX(_pcre2_ucd_nocase_ranges_size_)
#define _pcre2_ucd_digit_sets          PCRE2_SUFFIX(_pcre2_ucd_digit_sets_)
#define _pcre2_ucd_script_sets         PCRE2_SUFFIX(_pcre2_ucd_script_sets_)
#define _pcre2_ucd_records             PCRE2_SUFFIX(_pcre2_ucd_records_)
#define _pcre2_ucd_stage1              PCRE2_SUFFIX(_pcre2_ucd_stage1_)
#define _pcre2_ucd_stage2              PCRE2_SUFFIX(_pcre2_ucd_stage2_)
#define _pcre2_ucp_gbtable             PCRE2_SUFFIX(_pcre2_ucp_gbtable_)
#define _pcre2_ucp_gentype             PCRE2_SUFFIX(_pcre2_ucp_gentype_)
#define _pcre2_ucp_typerange           PCRE2_SUFFIX(_pcre2_ucp_typerange_)
#define _pcre2_unicode_version         PCRE2_SUFFIX(_pcre2_unicode_version_)
#define _pcre2_utt                     PCRE2_SUFFIX(_pcre2_utt_)
#define _pcre2_utt_names               PCRE2_SUFFIX(_pcre2_utt_names_)
#define _pcre2_utt_size                PCRE2_SUFFIX(_pcre2_utt_size_)

extern const uint8_t                   PRIV(OP_lengths)[];
extern const uint32_t                  PRIV(callout_end_delims)[];
extern const uint32_t                  PRIV(callout_start_delims)[];
extern pcre2_compile_context           PRIV(default_compile_context);
extern pcre2_convert_context           PRIV(default_convert_context);
extern pcre2_match_context             PRIV(default_match_context);
extern const uint8_t                   PRIV(default_tables)[];
extern const uint32_t                  PRIV(hspace_list)[];
extern const uint32_t                  PRIV(vspace_list)[];
extern const uint32_t                  PRIV(ucd_boolprop_sets)[];
extern const uint32_t                  PRIV(ucd_caseless_sets)[];
extern const uint32_t                  PRIV(ucd_turkish_dotted_i_caseset);
extern const uint32_t                  PRIV(ucd_nocase_ranges)[];
extern const uint32_t                  PRIV(ucd_nocase_ranges_size);
extern const uint32_t                  PRIV(ucd_digit_sets)[];
extern const uint32_t                  PRIV(ucd_script_sets)[];
extern const ucd_record                PRIV(ucd_records)[];
#if PCRE2_CODE_UNIT_WIDTH == 32
extern const ucd_record                PRIV(dummy_ucd_record)[];
#endif
extern const uint16_t                  PRIV(ucd_stage1)[];
extern const uint16_t                  PRIV(ucd_stage2)[];
extern const uint32_t                  PRIV(ucp_gbtable)[];
extern const uint32_t                  PRIV(ucp_gentype)[];
#ifdef SUPPORT_JIT
extern const int                       PRIV(ucp_typerange)[];
#endif
extern const char                     *PRIV(unicode_version);
extern const ucp_type_table            PRIV(utt)[];
extern const char                      PRIV(utt_names)[];
extern const size_t                    PRIV(utt_size);

/* Mode-dependent macros and hidden and private structures are defined in a
separate file so that pcre2test can include them at all supported widths. When
compiling the library, PCRE2_CODE_UNIT_WIDTH will be defined, and we can
include them at the appropriate width, after setting up suffix macros for the
private structures. */

#define branch_chain                 PCRE2_SUFFIX(branch_chain_)
#define compile_block                PCRE2_SUFFIX(compile_block_)
#define dfa_match_block              PCRE2_SUFFIX(dfa_match_block_)
#define match_block                  PCRE2_SUFFIX(match_block_)
#define named_group                  PCRE2_SUFFIX(named_group_)

#include "pcre2_intmodedep.h"

/* Private "external" functions. These are internal functions that are called
from modules other than the one in which they are defined. They have to be
"external" in the C sense, but are not part of the PCRE2 public API. They are
not referenced from pcre2test, and must not be defined when no code unit width
is available. */

#define _pcre2_auto_possessify       PCRE2_SUFFIX(_pcre2_auto_possessify_)
#define _pcre2_check_escape          PCRE2_SUFFIX(_pcre2_check_escape_)
#define _pcre2_extuni                PCRE2_SUFFIX(_pcre2_extuni_)
#define _pcre2_find_bracket          PCRE2_SUFFIX(_pcre2_find_bracket_)
#define _pcre2_is_newline            PCRE2_SUFFIX(_pcre2_is_newline_)
#define _pcre2_jit_free_rodata       PCRE2_SUFFIX(_pcre2_jit_free_rodata_)
#define _pcre2_jit_free              PCRE2_SUFFIX(_pcre2_jit_free_)
#define _pcre2_jit_get_size          PCRE2_SUFFIX(_pcre2_jit_get_size_)
#define _pcre2_jit_get_target        PCRE2_SUFFIX(_pcre2_jit_get_target_)
#define _pcre2_memctl_malloc         PCRE2_SUFFIX(_pcre2_memctl_malloc_)
#define _pcre2_ord2utf               PCRE2_SUFFIX(_pcre2_ord2utf_)
#define _pcre2_script_run            PCRE2_SUFFIX(_pcre2_script_run_)
#define _pcre2_strcmp                PCRE2_SUFFIX(_pcre2_strcmp_)
#define _pcre2_strcmp_c8             PCRE2_SUFFIX(_pcre2_strcmp_c8_)
#define _pcre2_strcpy_c8             PCRE2_SUFFIX(_pcre2_strcpy_c8_)
#define _pcre2_strlen                PCRE2_SUFFIX(_pcre2_strlen_)
#define _pcre2_strncmp               PCRE2_SUFFIX(_pcre2_strncmp_)
#define _pcre2_strncmp_c8            PCRE2_SUFFIX(_pcre2_strncmp_c8_)
#define _pcre2_study                 PCRE2_SUFFIX(_pcre2_study_)
#define _pcre2_valid_utf             PCRE2_SUFFIX(_pcre2_valid_utf_)
#define _pcre2_was_newline           PCRE2_SUFFIX(_pcre2_was_newline_)
#define _pcre2_xclass                PCRE2_SUFFIX(_pcre2_xclass_)
#define _pcre2_eclass                PCRE2_SUFFIX(_pcre2_eclass_)

extern int          _pcre2_auto_possessify(PCRE2_UCHAR *,
                      const compile_block *);
extern int          _pcre2_check_escape(PCRE2_SPTR *, PCRE2_SPTR, uint32_t *,
                      int *, uint32_t, uint32_t, uint32_t, BOOL, compile_block *);
extern PCRE2_SPTR   _pcre2_extuni(uint32_t, PCRE2_SPTR, PCRE2_SPTR, PCRE2_SPTR,
                      BOOL, int *);
extern PCRE2_SPTR   _pcre2_find_bracket(PCRE2_SPTR, BOOL, int);
extern BOOL         _pcre2_is_newline(PCRE2_SPTR, uint32_t, PCRE2_SPTR,
                      uint32_t *, BOOL);
extern void         _pcre2_jit_free_rodata(void *, void *);
extern void         _pcre2_jit_free(void *, pcre2_memctl *);
extern size_t       _pcre2_jit_get_size(void *);
const char *        _pcre2_jit_get_target(void);
extern void *       _pcre2_memctl_malloc(size_t, pcre2_memctl *);
extern unsigned int _pcre2_ord2utf(uint32_t, PCRE2_UCHAR *);
extern BOOL         _pcre2_script_run(PCRE2_SPTR, PCRE2_SPTR, BOOL);
extern int          _pcre2_strcmp(PCRE2_SPTR, PCRE2_SPTR);
extern int          _pcre2_strcmp_c8(PCRE2_SPTR, const char *);
extern PCRE2_SIZE   _pcre2_strcpy_c8(PCRE2_UCHAR *, const char *);
extern PCRE2_SIZE   _pcre2_strlen(PCRE2_SPTR);
extern int          _pcre2_strncmp(PCRE2_SPTR, PCRE2_SPTR, size_t);
extern int          _pcre2_strncmp_c8(PCRE2_SPTR, const char *, size_t);
extern int          _pcre2_study(pcre2_real_code *);
extern int          _pcre2_valid_utf(PCRE2_SPTR, PCRE2_SIZE, PCRE2_SIZE *);
extern BOOL         _pcre2_was_newline(PCRE2_SPTR, uint32_t, PCRE2_SPTR,
                      uint32_t *, BOOL);
extern BOOL         _pcre2_xclass(uint32_t, PCRE2_SPTR, const uint8_t *, BOOL);
extern BOOL         _pcre2_eclass(uint32_t, PCRE2_SPTR, PCRE2_SPTR,
                      const uint8_t *, BOOL);

/* This function is needed only when memmove() is not available. */

#if !defined(VPCOMPAT) && !defined(HAVE_MEMMOVE)
#define _pcre2_memmove               PCRE2_SUFFIX(_pcre2_memmove)
extern void *       _pcre2_memmove(void *, const void *, size_t);
#endif

#endif  /* PCRE2_CODE_UNIT_WIDTH */

extern BOOL         PRIV(ckd_smul)(PCRE2_SIZE *, int, int);

#include "pcre2_util.h"

#endif  /* PCRE2_INTERNAL_H_IDEMPOTENT_GUARD */

/* End of pcre2_internal.h */


================================================
FILE: Libraries/PCRE/pcre2_intmodedep.h
================================================
/*************************************************
*      Perl-Compatible Regular Expressions       *
*************************************************/

/* PCRE is a library of functions to support regular expressions whose syntax
and semantics are as close as possible to those of the Perl 5 language.

                       Written by Philip Hazel
     Original API code Copyright (c) 1997-2012 University of Cambridge
          New API code Copyright (c) 2016-2024 University of Cambridge

-----------------------------------------------------------------------------
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

    * Redistributions of source code must retain the above copyright notice,
      this list of conditions and the following disclaimer.

    * Redistributions in binary form must reproduce the above copyright
      notice, this list of conditions and the following disclaimer in the
      documentation and/or other materials provided with the distribution.

    * Neither the name of the University of Cambridge nor the names of its
      contributors may be used to endorse or promote products derived from
      this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
-----------------------------------------------------------------------------
*/


/* This module contains mode-dependent macro and structure definitions. The
file is #included by pcre2_internal.h if PCRE2_CODE_UNIT_WIDTH is defined.
These mode-dependent items are kept in a separate file so that they can also be
#included multiple times for different code unit widths by pcre2test in order
to have access to the hidden structures at all supported widths.

Some of the mode-dependent macros are required at different widths for
different parts of the pcre2test code (in particular, the included
pcre2_printint.c file). We undefine them here so that they can be re-defined for
multiple inclusions. Not all of these are used in pcre2test, but it's easier
just to undefine them all. */

#undef ACROSSCHAR
#undef BACKCHAR
#undef BYTES2CU
#undef CHMAX_255
#undef CU2BYTES
#undef FORWARDCHAR
#undef FORWARDCHARTEST
#undef GET
#undef GET2
#undef GETCHAR
#undef GETCHARINC
#undef GETCHARINCTEST
#undef GETCHARLEN
#undef GETCHARLENTEST
#undef GETCHARTEST
#undef GET_EXTRALEN
#undef HAS_EXTRALEN
#undef IMM2_SIZE
#undef MAX_255
#undef MAX_MARK
#undef MAX_PATTERN_SIZE
#undef MAX_UTF_SINGLE_CU
#undef NOT_FIRSTCU
#undef PUT
#undef PUT2
#undef PUT2INC
#undef PUTCHAR
#undef PUTINC
#undef TABLE_GET



/* -------------------------- MACROS ----------------------------- */

/* PCRE keeps offsets in its compiled code as at least 16-bit quantities
(always stored in big-endian order in 8-bit mode) by default. These are used,
for example, to link from the start of a subpattern to its alternatives and its
end. The use of 16 bits per offset limits the size of an 8-bit compiled regex
to around 64K, which is big enough for almost everybody. However, I received a
request for an even bigger limit. For this reason, and also to make the code
easier to maintain, the storing and loading of offsets from the compiled code
unit string is now handled by the macros that are defined here.

The macros are controlled by the value of LINK_SIZE. This defaults to 2, but
values of 3 or 4 are also supported. */

/* ------------------- 8-bit support  ------------------ */

#if PCRE2_CODE_UNIT_WIDTH == 8

#if LINK_SIZE == 2
#define PUT(a,n,d)   \
  (a[n] = (PCRE2_UCHAR)((d) >> 8)), \
  (a[(n)+1] = (PCRE2_UCHAR)((d) & 255))
#define GET(a,n) \
  (unsigned int)(((a)[n] << 8) | (a)[(n)+1])
#define MAX_PATTERN_SIZE (1 << 16)

#elif LINK_SIZE == 3
#define PUT(a,n,d)       \
  (a[n] = (PCRE2_UCHAR)((d) >> 16)),    \
  (a[(n)+1] = (PCRE2_UCHAR)((d) >> 8)), \
  (a[(n)+2] = (PCRE2_UCHAR)((d) & 255))
#define GET(a,n) \
  (unsigned int)(((a)[n] << 16) | ((a)[(n)+1] << 8) | (a)[(n)+2])
#define MAX_PATTERN_SIZE (1 << 24)

#elif LINK_SIZE == 4
#define PUT(a,n,d)        \
  (a[n] = (PCRE2_UCHAR)((d) >> 24)),     \
  (a[(n)+1] = (PCRE2_UCHAR)((d) >> 16)), \
  (a[(n)+2] = (PCRE2_UCHAR)((d) >> 8)),  \
  (a[(n)+3] = (PCRE2_UCHAR)((d) & 255))
#define GET(a,n) \
  (unsigned int)(((a)[n] << 24) | ((a)[(n)+1] << 16) | ((a)[(n)+2] << 8) | (a)[(n)+3])
#define MAX_PATTERN_SIZE (1 << 30)   /* Keep it positive */

#else
#error LINK_SIZE must be 2, 3, or 4
#endif


/* ------------------- 16-bit support  ------------------ */

#elif PCRE2_CODE_UNIT_WIDTH == 16

#if LINK_SIZE == 2
#undef LINK_SIZE
#define LINK_SIZE 1
#define PUT(a,n,d)   \
  (a[n] = (PCRE2_UCHAR)(d))
#define GET(a,n) \
  (a[n])
#define MAX_PATTERN_SIZE (1 << 16)

#elif LINK_SIZE == 3 || LINK_SIZE == 4
#undef LINK_SIZE
#define LINK_SIZE 2
#define PUT(a,n,d)   \
  (a[n] = (PCRE2_UCHAR)((d) >> 16)), \
  (a[(n)+1] = (PCRE2_UCHAR)((d) & 65535))
#define GET(a,n) \
  (unsigned int)(((a)[n] << 16) | (a)[(n)+1])
#define MAX_PATTERN_SIZE (1 << 30)  /* Keep it positive */

#else
#error LINK_SIZE must be 2, 3, or 4
#endif


/* ------------------- 32-bit support  ------------------ */

#elif PCRE2_CODE_UNIT_WIDTH == 32
#undef LINK_SIZE
#define LINK_SIZE 1
#define PUT(a,n,d)   \
  (a[n] = (d))
#define GET(a,n) \
  (a[n])
#define MAX_PATTERN_SIZE (1 << 30)  /* Keep it positive */

#else
#error Unsupported compiling mode
#endif


/* --------------- Other mode-specific macros ----------------- */

/* PCRE uses some other (at least) 16-bit quantities that do not change when
the size of offsets changes. There are used for repeat counts and for other
things such as capturing parenthesis numbers in back references.

Define the number of code units required to hold a 16-bit count/offset, and
macros to load and store such a value. For reasons that I do not understand,
the expression in the 8-bit GET2 macro is treated by gcc as a signed
expression, even when a is declared as unsigned. It seems that any kind of
arithmetic results in a signed value. Hence the cast. */

#if PCRE2_CODE_UNIT_WIDTH == 8
#define IMM2_SIZE 2
#define GET2(a,n) (unsigned int)(((a)[n] << 8) | (a)[(n)+1])
#define PUT2(a,n,d) a[n] = (d) >> 8, a[(n)+1] = (d) & 255

#else  /* Code units are 16 or 32 bits */
#define IMM2_SIZE 1
#define GET2(a,n) a[n]
#define PUT2(a,n,d) a[n] = d
#endif

/* Other macros that are different for 8-bit mode. The MAX_255 macro checks
whether its argument, which is assumed to be one code unit, is less than 256.
The CHMAX_255 macro does not assume one code unit. The maximum length of a MARK
name must fit in one code unit; currently it is set to 255 or 65535. The
TABLE_GET macro is used to access elements of tables containing exactly 256
items. Its argument is a code unit. When code points can be greater than 255, a
check is needed before accessing these tables. */

#if PCRE2_CODE_UNIT_WIDTH == 8
#define MAX_255(c) TRUE
#define MAX_MARK ((1u << 8) - 1)
#define TABLE_GET(c, table, default) ((table)[c])
#ifdef SUPPORT_UNICODE
#define SUPPORT_WIDE_CHARS
#define CHMAX_255(c) ((c) <= 255u)
#else
#define CHMAX_255(c) TRUE
#endif  /* SUPPORT_UNICODE */

#else  /* Code units are 16 or 32 bits */
#define CHMAX_255(c) ((c) <= 255u)
#define MAX_255(c) ((c) <= 255u)
#define MAX_MARK ((1u << 16) - 1)
#define SUPPORT_WIDE_CHARS
#define TABLE_GET(c, table, default) (MAX_255(c)? ((table)[c]):(default))
#endif


/* ----------------- Character-handling macros ----------------- */

/* There is a proposed future special "UTF-21" mode, in which only the lowest
21 bits of a 32-bit character are interpreted as UTF, with the remaining 11
high-order bits available to the application for other uses. In preparation for
the future implementation of this mode, there are macros that load a data item
and, if in this special mode, mask it to 21 bits. These macros all have names
starting with UCHAR21. In all other modes, including the normal 32-bit
library, the macros all have the same simple definitions. When the new mode is
implemented, it is expected that these definitions will be varied appropriately
using #ifdef when compiling the library that supports the special mode. */

#define UCHAR21(eptr)        (*(eptr))
#define UCHAR21TEST(eptr)    (*(eptr))
#define UCHAR21INC(eptr)     (*(eptr)++)
#define UCHAR21INCTEST(eptr) (*(eptr)++)

/* When UTF encoding is being used, a character is no longer just a single
byte in 8-bit mode or a single short in 16-bit mode. The macros for character
handling generate simple sequences when used in the basic mode, and more
complicated ones for UTF characters. GETCHARLENTEST and other macros are not
used when UTF is not supported. To make sure they can never even appear when
UTF support is omitted, we don't even define them. */

#ifndef SUPPORT_UNICODE

/* #define MAX_UTF_SINGLE_CU */
/* #define HAS_EXTRALEN(c) */
/* #define GET_EXTRALEN(c) */
/* #define NOT_FIRSTCU(c) */
#define GETCHAR(c, eptr) c = *eptr;
#define GETCHARTEST(c, eptr) c = *eptr;
#define GETCHARINC(c, eptr) c = *eptr++;
#define GETCHARINCTEST(c, eptr) c = *eptr++;
#define GETCHARLEN(c, eptr, len) c = *eptr;
#define PUTCHAR(c, p) (*p = c, 1)
/* #define GETCHARLENTEST(c, eptr, len) */
/* #define BACKCHAR(eptr) */
/* #define FORWARDCHAR(eptr) */
/* #define FORWARCCHARTEST(eptr,end) */
/* #define ACROSSCHAR(condition, eptr, action) */

#else   /* SUPPORT_UNICODE */

/* ------------------- 8-bit support  ------------------ */

#if PCRE2_CODE_UNIT_WIDTH == 8
#define MAYBE_UTF_MULTI          /* UTF chars may use multiple code units */

/* The largest UTF code point that can be encoded as a single code unit. */

#define MAX_UTF_SINGLE_CU 127

/* Tests whether the code point needs extra characters to decode. */

#define HAS_EXTRALEN(c) HASUTF8EXTRALEN(c)

/* Returns with the additional number of characters if IS_MULTICHAR(c) is TRUE.
Otherwise it has an undefined behaviour. */

#define GET_EXTRALEN(c) (PRIV(utf8_table4)[(c) & 0x3fu])

/* Returns TRUE, if the given value is not the first code unit of a UTF
sequence. */

#define NOT_FIRSTCU(c) (((c) & 0xc0u) == 0x80u)

/* Get the next UTF-8 character, not advancing the pointer. This is called when
we know we are in UTF-8 mode. */

#define GETCHAR(c, eptr) \
  c = *eptr; \
  if (c >= 0xc0u) GETUTF8(c, eptr);

/* Get the next UTF-8 character, testing for UTF-8 mode, and not advancing the
pointer. */

#define GETCHARTEST(c, eptr) \
  c = *eptr; \
  if (utf && c >= 0xc0u) GETUTF8(c, eptr);

/* Get the next UTF-8 character, advancing the pointer. This is called when we
know we are in UTF-8 mode. */

#define GETCHARINC(c, eptr) \
  c = *eptr++; \
  if (c >= 0xc0u) GETUTF8INC(c, eptr);

/* Get the next character, testing for UTF-8 mode, and advancing the pointer.
This is called when we don't know if we are in UTF-8 mode. */

#define GETCHARINCTEST(c, eptr) \
  c = *eptr++; \
  if (utf && c >= 0xc0u) GETUTF8INC(c, eptr);

/* Get the next UTF-8 character, not advancing the pointer, incrementing length
if there are extra bytes. This is called when we know we are in UTF-8 mode. */

#define GETCHARLEN(c, eptr, len) \
  c = *eptr; \
  if (c >= 0xc0u) GETUTF8LEN(c, eptr, len);

/* Get the next UTF-8 character, testing for UTF-8 mode, not advancing the
pointer, incrementing length if there are extra bytes. This is called when we
do not know if we are in UTF-8 mode. */

#define GETCHARLENTEST(c, eptr, len) \
  c = *eptr; \
  if (utf && c >= 0xc0u) GETUTF8LEN(c, eptr, len);

/* If the pointer is not at the start of a character, move it back until
it is. This is called only in UTF-8 mode - we don't put a test within the macro
because almost all calls are already within a block of UTF-8 only code. */

#define BACKCHAR(eptr) while((*eptr & 0xc0u) == 0x80u) eptr--

/* Same as above, just in the other direction. */
#define FORWARDCHAR(eptr) while((*eptr & 0xc0u) == 0x80u) eptr++
#define FORWARDCHARTEST(eptr,end) while(eptr < end && (*eptr & 0xc0u) == 0x80u) eptr++

/* Same as above, but it allows a fully customizable form. */
#define ACROSSCHAR(condition, eptr, action) \
  while((condition) && ((*eptr) & 0xc0u) == 0x80u) action

/* Deposit a character into memory, returning the number of code units. */

#define PUTCHAR(c, p) ((utf && c > MAX_UTF_SINGLE_CU)? \
  PRIV(ord2utf)(c,p) : (*p = c, 1))


/* ------------------- 16-bit support  ------------------ */

#elif PCRE2_CODE_UNIT_WIDTH == 16
#define MAYBE_UTF_MULTI          /* UTF chars may use multiple code units */

/* The largest UTF code point that can be encoded as a single code unit. */

#define MAX_UTF_SINGLE_CU 65535

/* Tests whether the code point needs extra characters to decode. */

#define HAS_EXTRALEN(c) (((c) & 0xfc00u) == 0xd800u)

/* Returns with the additional number of characters if IS_MULTICHAR(c) is TRUE.
Otherwise it has an undefined behaviour. */

#define GET_EXTRALEN(c) 1

/* Returns TRUE, if the given value is not the first code unit of a UTF
sequence. */

#define NOT_FIRSTCU(c) (((c) & 0xfc00u) == 0xdc00u)

/* Base macro to pick up the low surrogate of a UTF-16 character, not
advancing the pointer. */

#define GETUTF16(c, eptr) \
   { c = (((c & 0x3ffu) << 10) | (eptr[1] & 0x3ffu)) + 0x10000u; }

/* Get the next UTF-16 character, not advancing the pointer. This is called when
we know we are in UTF-16 mode. */

#define GETCHAR(c, eptr) \
  c = *eptr; \
  if ((c & 0xfc00u) == 0xd800u) GETUTF16(c, eptr);

/* Get the next UTF-16 character, testing for UTF-16 mode, and not advancing the
pointer. */

#define GETCHARTEST(c, eptr) \
  c = *eptr; \
  if (utf && (c & 0xfc00u) == 0xd800u) GETUTF16(c, eptr);

/* Base macro to pick up the low surrogate of a UTF-16 character, advancing
the pointer. */

#define GETUTF16INC(c, eptr) \
   { c = (((c & 0x3ffu) << 10) | (*eptr++ & 0x3ffu)) + 0x10000u; }

/* Get the next UTF-16 character, advancing the pointer. This is called when we
know we are in UTF-16 mode. */

#define GETCHARINC(c, eptr) \
  c = *eptr++; \
  if ((c & 0xfc00u) == 0xd800u) GETUTF16INC(c, eptr);

/* Get the next character, testing for UTF-16 mode, and advancing the pointer.
This is called when we don't know if we are in UTF-16 mode. */

#define GETCHARINCTEST(c, eptr) \
  c = *eptr++; \
  if (utf && (c & 0xfc00u) == 0xd800u) GETUTF16INC(c, eptr);

/* Base macro to pick up the low surrogate of a UTF-16 character, not
advancing the pointer, incrementing the length. */

#define GETUTF16LEN(c, eptr, len) \
   { c = (((c & 0x3ffu) << 10) | (eptr[1] & 0x3ffu)) + 0x10000u; len++; }

/* Get the next UTF-16 character, not advancing the pointer, incrementing
length if there is a low surrogate. This is called when we know we are in
UTF-16 mode. */

#define GETCHARLEN(c, eptr, len) \
  c = *eptr; \
  if ((c & 0xfc00u) == 0xd800u) GETUTF16LEN(c, eptr, len);

/* Get the next UTF-16 character, testing for UTF-16 mode, not advancing the
pointer, incrementing length if there is a low surrogate. This is called when
we do not know if we are in UTF-16 mode. */

#define GETCHARLENTEST(c, eptr, len) \
  c = *eptr; \
  if (utf && (c & 0xfc00u) == 0xd800u) GETUTF16LEN(c, eptr, len);

/* If the pointer is not at the start of a character, move it back until
it is. This is called only in UTF-16 mode - we don't put a test within the
macro because almost all calls are already within a block of UTF-16 only
code. */

#define BACKCHAR(eptr) if ((*eptr & 0xfc00u) == 0xdc00u) eptr--

/* Same as above, just in the other direction. */
#define FORWARDCHAR(eptr) if ((*eptr & 0xfc00u) == 0xdc00u) eptr++
#define FORWARDCHARTEST(eptr,end) if (eptr < end && (*eptr & 0xfc00u) == 0xdc00u) eptr++

/* Same as above, but it allows a fully customizable form. */
#define ACROSSCHAR(condition, eptr, action) \
  if ((condition) && ((*eptr) & 0xfc00u) == 0xdc00u) action

/* Deposit a character into memory, returning the number of code units. */

#define PUTCHAR(c, p) ((utf && c > MAX_UTF_SINGLE_CU)? \
  PRIV(ord2utf)(c,p) : (*p = c, 1))


/* ------------------- 32-bit support  ------------------ */

#else

/* These are trivial for the 32-bit library, since all UTF-32 characters fit
into one PCRE2_UCHAR unit. */

#define MAX_UTF_SINGLE_CU (0x10ffffu)
#define HAS_EXTRALEN(c) (0)
#define GET_EXTRALEN(c) (0)
#define NOT_FIRSTCU(c) (0)

/* Get the next UTF-32 character, not advancing the pointer. This is called when
we know we are in UTF-32 mode. */

#define GETCHAR(c, eptr) \
  c = *(eptr);

/* Get the next UTF-32 character, testing for UTF-32 mode, and not advancing the
pointer. */

#define GETCHARTEST(c, eptr) \
  c = *(eptr);

/* Get the next UTF-32 character, advancing the pointer. This is called when we
know we are in UTF-32 mode. */

#define GETCHARINC(c, eptr) \
  c = *((eptr)++);

/* Get the next character, testing for UTF-32 mode, and advancing the pointer.
This is called when we don't know if we are in UTF-32 mode. */

#define GETCHARINCTEST(c, eptr) \
  c = *((eptr)++);

/* Get the next UTF-32 character, not advancing the pointer, not incrementing
length (since all UTF-32 is of length 1). This is called when we know we are in
UTF-32 mode. */

#define GETCHARLEN(c, eptr, len) \
  GETCHAR(c, eptr)

/* Get the next UTF-32character, testing for UTF-32 mode, not advancing the
pointer, not incrementing the length (since all UTF-32 is of length 1).
This is called when we do not know if we are in UTF-32 mode. */

#define GETCHARLENTEST(c, eptr, len) \
  GETCHARTEST(c, eptr)

/* If the pointer is not at the start of a character, move it back until
it is. This is called only in UTF-32 mode - we don't put a test within the
macro because almost all calls are already within a block of UTF-32 only
code.

These are all no-ops since all UTF-32 characters fit into one PCRE2_UCHAR. */

#define BACKCHAR(eptr) do { } while (0)

/* Same as above, just in the other direction. */

#define FORWARDCHAR(eptr) do { } while (0)
#define FORWARDCHARTEST(eptr,end) do { } while (0)

/* Same as above, but it allows a fully customizable form. */

#define ACROSSCHAR(condition, eptr, action) do { } while (0)

/* Deposit a character into memory, returning the number of code units. */

#define PUTCHAR(c, p) (*p = c, 1)

#endif  /* UTF-32 character handling */
#endif  /* SUPPORT_UNICODE */


/* Mode-dependent macros that have the same definition in all modes. */

#define CU2BYTES(x)     ((x)*((PCRE2_CODE_UNIT_WIDTH/8)))
#define BYTES2CU(x)     ((x)/((PCRE2_CODE_UNIT_WIDTH/8)))
#define PUTINC(a,n,d)   PUT(a,n,d), a += LINK_SIZE
#define PUT2INC(a,n,d)  PUT2(a,n,d), a += IMM2_SIZE


/* ----------------------- HIDDEN STRUCTURES ----------------------------- */

/* NOTE: All these structures *must* start with a pcre2_memctl structure. The
code that uses them is simpler because it assumes this. */

/* The real general context structure. At present it holds only data for custom
memory control. */

/* WARNING: if this is ever changed, code in pcre2_substitute.c will have to be
changed because it builds a general context "by hand" in order to avoid the
malloc() call in pcre2_general_context)_create(). There is also code in
pcre2_match.c that makes the same assumption. */

typedef struct pcre2_real_general_context {
  pcre2_memctl memctl;
} pcre2_real_general_context;

/* The real compile context structure */

typedef struct pcre2_real_compile_context {
  pcre2_memctl memctl;
  int (*stack_guard)(uint32_t, void *);
  void *stack_guard_data;
  const uint8_t *tables;
  PCRE2_SIZE max_pattern_length;
  PCRE2_SIZE max_pattern_compiled_length;
  uint16_t bsr_convention;
  uint16_t newline_convention;
  uint32_t parens_nest_limit;
  uint32_t extra_options;
  uint32_t max_varlookbehind;
  uint32_t optimization_flags;
} pcre2_real_compile_context;

/* The real match context structure. */

typedef struct pcre2_real_match_context {
  pcre2_memctl memctl;
#ifdef SUPPORT_JIT
  pcre2_jit_callback jit_callback;
  void *jit_callback_data;
#endif
  int        (*callout)(pcre2_callout_block *, void *);
  void        *callout_data;
  int        (*substitute_callout)(pcre2_substitute_callout_block *, void *);
  void        *substitute_callout_data;
  PCRE2_SIZE (*substitute_case_callout)(PCRE2_SPTR, PCRE2_SIZE, PCRE2_UCHAR *,
                                        PCRE2_SIZE, int, void *);
  void        *substitute_case_callout_data;
  PCRE2_SIZE offset_limit;
  uint32_t heap_limit;
  uint32_t match_limit;
  uint32_t depth_limit;
} pcre2_real_match_context;

/* The real convert context structure. */

typedef struct pcre2_real_convert_context {
  pcre2_memctl memctl;
  uint32_t glob_separator;
  uint32_t glob_escape;
} pcre2_real_convert_context;

/* The real compiled code structure. The type for the blocksize field is
defined specially because it is required in pcre2_serialize_decode() when
copying the size from possibly unaligned memory into a variable of the same
type. Use a macro rather than a typedef to avoid compiler warnings when this
file is included multiple times by pcre2test. LOOKBEHIND_MAX specifies the
largest lookbehind that is supported. (OP_REVERSE and OP_VREVERSE in a pattern
have 16-bit arguments in 8-bit and 16-bit modes, so we need no more than a
16-bit field here.) */

#undef  CODE_BLOCKSIZE_TYPE
#define CODE_BLOCKSIZE_TYPE PCRE2_SIZE

#undef  LOOKBEHIND_MAX
#define LOOKBEHIND_MAX UINT16_MAX

typedef struct pcre2_real_code {
  pcre2_memctl memctl;            /* Memory control fields */
  const uint8_t *tables;          /* The character tables */
  void    *executable_jit;        /* Pointer to JIT code */
  uint8_t  start_bitmap[32];      /* Bitmap for starting code unit < 256 */
  CODE_BLOCKSIZE_TYPE blocksize;  /* Total (bytes) that was malloc-ed */
  CODE_BLOCKSIZE_TYPE code_start; /* Byte code start offset */
  uint32_t magic_number;          /* Paranoid and endianness check */
  uint32_t compile_options;       /* Options passed to pcre2_compile() */
  uint32_t overall_options;       /* Options after processing the pattern */
  uint32_t extra_options;         /* Taken from compile_context */
  uint32_t flags;                 /* Various state flags */
  uint32_t limit_heap;            /* Limit set in the pattern */
  uint32_t limit_match;           /* Limit set in the pattern */
  uint32_t limit_depth;           /* Limit set in the pattern */
  uint32_t first_codeunit;        /* Starting code unit */
  uint32_t last_codeunit;         /* This codeunit must be seen */
  uint16_t bsr_convention;        /* What \R matches */
  uint16_t newline_convention;    /* What is a newline? */
  uint16_t max_lookbehind;        /* Longest lookbehind (characters) */
  uint16_t minlength;             /* Minimum length of match */
  uint16_t top_bracket;           /* Highest numbered group */
  uint16_t top_backref;           /* Highest numbered back reference */
  uint16_t name_entry_size;       /* Size (code units) of table entries */
  uint16_t name_count;            /* Number of name entries in the table */
  uint32_t optimization_flags;    /* Optimizations enabled at compile time */
} pcre2_real_code;

/* The real match data structure. Define ovector as large as it can ever
actually be so that array bound checkers don't grumble. Memory for this
structure is obtained by calling pcre2_match_data_create(), which sets the size
as the offset of ovector plus a pair of elements for each capturable string, so
the size varies from call to call. As the maximum number of capturing
subpatterns is 65535 we must allow for 65536 strings to include the overall
match. (See also the heapframe structure below.) */

struct heapframe;  /* Forward reference */

typedef struct pcre2_real_match_data {
  pcre2_memctl     memctl;           /* Memory control fields */
  const pcre2_real_code *code;       /* The pattern used for the match */
  PCRE2_SPTR       subject;          /* The subject that was matched */
  PCRE2_SPTR       mark;             /* Pointer to last mark */
  struct heapframe *heapframes;      /* Backtracking frames heap memory */
  PCRE2_SIZE       heapframes_size;  /* Malloc-ed size */
  PCRE2_SIZE       subject_length;   /* Subject length */
  PCRE2_SIZE       leftchar;         /* Offset to leftmost code unit */
  PCRE2_SIZE       rightchar;        /* Offset to rightmost code unit */
  PCRE2_SIZE       startchar;        /* Offset to starting code unit */
  uint8_t          matchedby;        /* Type of match (normal, JIT, DFA) */
  uint8_t          flags;            /* Various flags */
  uint16_t         oveccount;        /* Number of pairs */
  int              rc;               /* The return code from the match */
  PCRE2_SIZE       ovector[131072];  /* Must be last in the structure */
} pcre2_real_match_data;


/* ----------------------- PRIVATE STRUCTURES ----------------------------- */

/* These structures are not needed for pcre2test. */

#ifndef PCRE2_PCRE2TEST

/* Structures for checking for mutual function recursion when scanning compiled
or parsed code. */

typedef struct recurse_check {
  struct recurse_check *prev;
  PCRE2_SPTR group;
} recurse_check;

typedef struct parsed_recurse_check {
  struct parsed_recurse_check *prev;
  uint32_t *groupptr;
} parsed_recurse_check;

/* Structure for building a cache when filling in pattern recursion offsets. */

typedef struct recurse_cache {
  PCRE2_SPTR group;
  int groupnumber;
} recurse_cache;

/* Structure for maintaining a chain of pointers to the currently incomplete
branches, for testing for left recursion while compiling. */

typedef struct branch_chain {
  struct branch_chain *outer;
  PCRE2_UCHAR *current_branch;
} branch_chain;

/* Structure for building a list of named groups during the first pass of
compiling. */

typedef struct named_group {
  PCRE2_SPTR   name;          /* Points to the name in the pattern */
  uint32_t     number;        /* Group number */
  uint16_t     length;        /* Length of the name */
  uint16_t     isdup;         /* TRUE if a duplicate */
} named_group;

/* Structure for caching sorted ranges. This improves the performance
of translating META code to byte code. */

typedef struct class_ranges {
  struct class_ranges *next;       /* Next class ranges */
  size_t char_lists_size;          /* Total size of encoded char lists */
  size_t char_lists_start;         /* Start offset of encoded char lists */
  uint16_t range_list_size;        /* Size of ranges array */
  uint16_t char_lists_types;       /* The XCL_LIST header of char lists */
  /* Followed by the list of ranges (start/end pairs) */
} class_ranges;

typedef union class_bits_storage {
  uint8_t classbits[32];
  uint32_t classwords[8];
} class_bits_storage;

/* Structure for passing "static" information around between the functions
doing the compiling, so that they are thread-safe. */

typedef struct compile_block {
  pcre2_real_compile_context *cx;  /* Points to the compile context */
  const uint8_t *lcc;              /* Points to lower casing table */
  const uint8_t *fcc;              /* Points to case-flipping table */
  const uint8_t *cbits;            /* Points to character type table */
  const uint8_t *ctypes;           /* Points to table of type maps */
  PCRE2_UCHAR *start_workspace;    /* The start of working space */
  PCRE2_UCHAR *start_code;         /* The start of the compiled code */
  PCRE2_SPTR start_pattern;        /* The start of the pattern */
  PCRE2_SPTR end_pattern;          /* The end of the pattern */
  PCRE2_UCHAR *name_table;         /* The name/number table */
  PCRE2_SIZE workspace_size;       /* Size of workspace */
  PCRE2_SIZE small_ref_offset[10]; /* Offsets for \1 to \9 */
  PCRE2_SIZE erroroffset;          /* Offset of error in pattern */
  class_bits_storage classbits;    /* Temporary store for classbits */
  uint16_t names_found;            /* Number of entries so far */
  uint16_t name_entry_size;        /* Size of each entry */
  uint16_t parens_depth;           /* Depth of nested parentheses */
  uint16_t assert_depth;           /* Depth of nested assertions */
  named_group *named_groups;       /* Points to vector in pre-compile */
  uint32_t named_group_list_size;  /* Number of entries in the list */
  uint32_t external_options;       /* External (initial) options */
  uint32_t external_flags;         /* External flag bits to be set */
  uint32_t bracount;               /* Count of capturing parentheses */
  uint32_t lastcapture;            /* Last capture encountered */
  uint32_t *parsed_pattern;        /* Parsed pattern buffer */
  uint32_t *parsed_pattern_end;    /* Parsed pattern should not get here */
  uint32_t *groupinfo;             /* Group info vector */
  uint32_t top_backref;            /* Maximum back reference */
  uint32_t backref_map;            /* Bitmap of low back refs */
  uint32_t nltype;                 /* Newline type */
  uint32_t nllen;                  /* Newline string length */
  PCRE2_UCHAR nl[4];               /* Newline string when fixed length */
  uint8_t class_op_used[ECLASS_NEST_LIMIT]; /* Operation used for
                                               extended classes */
  uint32_t req_varyopt;            /* "After variable item" flag for reqbyte */
  uint32_t max_varlookbehind;      /* Limit for variable lookbehinds */
  int  max_lookbehind;             /* Maximum lookbehind encountered (characters) */
  BOOL had_accept;                 /* (*ACCEPT) encountered */
  BOOL had_pruneorskip;            /* (*PRUNE) or (*SKIP) encountered */
  BOOL had_recurse;                /* Had a pattern recursion or subroutine call */
  BOOL dupnames;                   /* Duplicate names exist */
#ifdef SUPPORT_WIDE_CHARS
  class_ranges *cranges;           /* First class range. */
  class_ranges *next_cranges;      /* Next class range. */
  size_t char_lists_size;          /* Current size of character lists */
#endif
} compile_block;

/* Structure for keeping the properties of the in-memory stack used
by the JIT matcher. */

typedef struct pcre2_real_jit_stack {
  pcre2_memctl memctl;
  void* stack;
} pcre2_real_jit_stack;

/* Structure for items in a linked list that represents an explicit recursive
call within the pattern when running pcre2_dfa_match(). */

typedef struct dfa_recursion_info {
  struct dfa_recursion_info *prevrec;
  PCRE2_SPTR subject_position;
  PCRE2_SPTR last_used_ptr;
  uint32_t group_num;
} dfa_recursion_info;

/* Structure for "stack" frames that are used for remembering backtracking
positions during matching. As these are used in a vector, with the ovector item
being extended, the size of the structure must be a multiple of PCRE2_SIZE. The
only way to check this at compile time is to force an error by generating an
array with a negative size. By putting this in a typedef (which is never used),
we don't generate any code when all is well. */

typedef struct heapframe {

  /* The first set of fields are variables that have to be preserved over calls
  to RRMATCH(), but which do not need to be copied to new frames. */

  PCRE2_SPTR ecode;          /* The current position in the pattern */
  PCRE2_SPTR temp_sptr[2];   /* Used for short-term PCRE2_SPTR values */
  PCRE2_SIZE length;         /* Used for character, string, or code lengths */
  PCRE2_SIZE back_frame;     /* Amount to subtract on RRETURN */
  PCRE2_SIZE temp_size;      /* Used for short-term PCRE2_SIZE values */
  uint32_t rdepth;           /* Function "recursion" depth within pcre2_match() */
  uint32_t group_frame_type; /* Type information for group frames */
  uint32_t temp_32[4];       /* Used for short-term 32-bit or BOOL values */
  uint8_t return_id;         /* Where to go on in internal "return" */
  uint8_t op;                /* Processing opcode */

  /* At this point, the structure is 16-bit aligned. On most architectures
  the alignment requirement for a pointer will ensure that the eptr field below
  is 32-bit or 64-bit aligned. However, on m68k it is fine to have a pointer
  that is 16-bit aligned. We must therefore ensure that what comes between here
  and eptr is an odd multiple of 16 bits so as to get back into 32-bit
  alignment. This happens naturally when PCRE2_UCHAR is 8 bits wide, but needs
  fudges in the other cases. In the 32-bit case the padding comes first so that
  the occu field itself is 32-bit aligned. Without the padding, this structure
  is no longer a multiple of PCRE2_SIZE on m68k, and the check below fails. */

#if PCRE2_CODE_UNIT_WIDTH == 8
  PCRE2_UCHAR occu[6];       /* Used for other case code units */
#elif PCRE2_CODE_UNIT_WIDTH == 16
  PCRE2_UCHAR occu[2];       /* Used for other case code units */
  uint8_t unused[2];         /* Ensure 32-bit alignment (see above) */
#else
  uint8_t unused[2];         /* Ensure 32-bit alignment (see above) */
  PCRE2_UCHAR occu[1];       /* Used for other case code units */
#endif

  /* The rest have to be copied from the previous frame whenever a new frame
  becomes current. The final field is specified as a large vector so that
  runtime array bound checks don't catch references to it. However, for any
  specific call to pcre2_match() the memory allocated for each frame structure
  allows for exactly the right size ovector for the number of capturing
  parentheses. (See also the comment for pcre2_real_match_data above.) */

  PCRE2_SPTR eptr;              /* MUST BE FIRST */
  PCRE2_SPTR start_match;       /* Can be adjusted by \K */
  PCRE2_SPTR mark;              /* Most recent mark on the success path */
  PCRE2_SPTR recurse_last_used; /* Last character used at time of pattern recursion */
  uint32_t current_recurse;     /* Group number of current (deepest) pattern recursion */
  uint32_t capture_last;        /* Most recent capture */
  PCRE2_SIZE last_group_offset; /* Saved offset to most recent group frame */
  PCRE2_SIZE offset_top;        /* Offset after highest capture */
  PCRE2_SIZE ovector[131072];   /* Must be last in the structure */
} heapframe;

/* Assert that the size of the heapframe structure is a multiple of PCRE2_SIZE.
See various comments above. */

STATIC_ASSERT((sizeof(heapframe) % sizeof(PCRE2_SIZE)) == 0, heapframe_size);

/* Structure for computing the alignment of heapframe. */

typedef struct heapframe_align {
  char unalign;    /* Completely unalign the current offset */
  heapframe frame; /* Offset is its alignment */
} heapframe_align;

/* This define is the minimum alignment required for a heapframe, in bytes. */

#define HEAPFRAME_ALIGNMENT offsetof(heapframe_align, frame)

/* Structure for passing "static" information around between the functions
doing traditional NFA matching (pcre2_match() and friends). */

typedef struct match_block {
  pcre2_memctl memctl;            /* For general use */
  uint32_t heap_limit;            /* As it says */
  uint32_t match_limit;           /* As it says */
  uint32_t match_limit_depth;     /* As it says */
  uint32_t match_call_count;      /* Number of times a new frame is created */
  BOOL hitend;                    /* Hit the end of the subject at some point */
  BOOL hasthen;                   /* Pattern contains (*THEN) */
  BOOL allowemptypartial;         /* Allow empty hard partial */
  const uint8_t *lcc;             /* Points to lower casing table */
  const uint8_t *fcc;             /* Points to case-flipping table */
  const uint8_t *ctypes;          /* Points to table of type maps */
  PCRE2_SIZE start_offset;        /* The start offset value */
  PCRE2_SIZE end_offset_top;      /* Highwater mark at end of match */
  uint16_t partial;               /* PARTIAL options */
  uint16_t bsr_convention;        /* \R interpretation */
  uint16_t name_count;            /* Number of names in name table */
  uint16_t name_entry_size;       /* Size of entry in names table */
  PCRE2_SPTR name_table;          /* Table of group names */
  PCRE2_SPTR start_code;          /* For use in pattern recursion */
  PCRE2_SPTR start_subject;       /* Start of the subject string */
  PCRE2_SPTR check_subject;       /* Where UTF-checked from */
  PCRE2_SPTR end_subject;         /* Usable end of the subject string */
  PCRE2_SPTR true_end_subject;    /* Actual end of the subject string */
  PCRE2_SPTR end_match_ptr;       /* Subject position at end match */
  PCRE2_SPTR start_used_ptr;      /* Earliest consulted character */
  PCRE2_SPTR last_used_ptr;       /* Latest consulted character */
  PCRE2_SPTR mark;                /* Mark pointer to pass back on success */
  PCRE2_SPTR nomatch_mark;        /* Mark pointer to pass back on failure */
  PCRE2_SPTR verb_ecode_ptr;      /* For passing back info */
  PCRE2_SPTR verb_skip_ptr;       /* For passing back a (*SKIP) name */
  uint32_t verb_current_recurse;  /* Current recursion group when (*VERB) happens */
  uint32_t moptions;              /* Match options */
  uint32_t poptions;              /* Pattern options */
  uint32_t skip_arg_count;        /* For counting SKIP_ARGs */
  uint32_t ignore_skip_arg;       /* For re-run when SKIP arg name not found */
  uint32_t nltype;                /* Newline type */
  uint32_t nllen;                 /* Newline string length */
  PCRE2_UCHAR nl[4];              /* Newline string when fixed */
  pcre2_callout_block *cb;        /* Points to a callout block */
  void  *callout_data;            /* To pass back to callouts */
  int (*callout)(pcre2_callout_block *,void *);  /* Callout function or NULL */
} match_block;

/* A similar structure is used for the same purpose by the DFA matching
functions. */

typedef struct dfa_match_block {
  pcre2_memctl memctl;            /* For general use */
  PCRE2_SPTR start_code;          /* Start of the compiled pattern */
  PCRE2_SPTR start_subject ;      /* Start of the subject string */
  PCRE2_SPTR end_subject;         /* End of subject string */
  PCRE2_SPTR start_used_ptr;      /* Earliest consulted character */
  PCRE2_SPTR last_used_ptr;       /* Latest consulted character */
  const uint8_t *tables;          /* Character tables */
  PCRE2_SIZE start_offset;        /* The start offset value */
  uint32_t heap_limit;            /* As it says */
  PCRE2_SIZE heap_used;           /* As it says */
  uint32_t match_limit;           /* As it says */
  uint32_t match_limit_depth;     /* As it says */
  uint32_t match_call_count;      /* Number of calls of internal function */
  uint32_t moptions;              /* Match options */
  uint32_t poptions;              /* Pattern options */
  uint32_t nltype;                /* Newline type */
  uint32_t nllen;                 /* Newline string length */
  BOOL allowemptypartial;         /* Allow empty hard partial */
  PCRE2_UCHAR nl[4];              /* Newline string when fixed */
  uint16_t bsr_convention;        /* \R interpretation */
  pcre2_callout_block *cb;        /* Points to a callout block */
  void *callout_data;             /* To pass back to callouts */
  int (*callout)(pcre2_callout_block *,void *);  /* Callout function or NULL */
  dfa_recursion_info *recursive;  /* Linked list of pattern recursion data */
} dfa_match_block;

#endif  /* PCRE2_PCRE2TEST */

/* End of pcre2_intmodedep.h */


================================================
FILE: Libraries/PCRE/pcre2_maketables.c
================================================
/*************************************************
*      Perl-Compatible Regular Expressions       *
*************************************************/

/* PCRE is a library of functions to support regular expressions whose syntax
and semantics are as close as possible to those of the Perl 5 language.

                       Written by Philip Hazel
     Original API code Copyright (c) 1997-2012 University of Cambridge
          New API code Copyright (c) 2016-2024 University of Cambridge

-----------------------------------------------------------------------------
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

    * Redistributions of source code must retain the above copyright notice,
      this list of conditions and the following disclaimer.

    * Redistributions in binary form must reproduce the above copyright
      notice, this list of conditions and the following disclaimer in the
      documentation and/or other materials provided with the distribution.

    * Neither the name of the University of Cambridge nor the names of its
      contributors may be used to endorse or promote products derived from
      this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
-----------------------------------------------------------------------------
*/


/* This module contains the external function pcre2_maketables(), which builds
character tables for PCRE2 in the current locale. The file is compiled on its
own as part of the PCRE2 library. It is also included in the compilation of
pcre2_dftables.c as a freestanding program, in which case the macro
PCRE2_DFTABLES is defined. */

#ifndef PCRE2_DFTABLES    /* Compiling the library */
#  ifdef HAVE_CONFIG_H
#  include "config.h"
#  endif
#  include "pcre2_internal.h"
#endif

/*************************************************
*           Create PCRE2 character tables        *
*************************************************/

/* This function builds a set of character tables for use by PCRE2 and returns
a pointer to them. They are build using the ctype functions, and consequently
their contents will depend upon the current locale setting. When compiled as
part of the library, the store is obtained via a general context malloc, if
supplied, but when PCRE2_DFTABLES is defined (when compiling the pcre2_dftables
freestanding auxiliary program) malloc() is used, and the function has a
different name so as not to clash with the prototype in pcre2.h.

Arguments:   none when PCRE2_DFTABLES is defined
               else a PCRE2 general context or NULL
Returns:     pointer to the contiguous block of data
               else NULL if memory allocation failed
*/

#ifdef PCRE2_DFTABLES  /* Included in freestanding pcre2_dftables program */
static const uint8_t *maketables(void)
{
uint8_t *yield = (uint8_t *)malloc(TABLES_LENGTH);

#else  /* Not PCRE2_DFTABLES, that is, compiling the library */
PCRE2_EXP_DEFN const uint8_t * PCRE2_CALL_CONVENTION
pcre2_maketables(pcre2_general_context *gcontext)
{
uint8_t *yield = (uint8_t *)((gcontext != NULL)?
  gcontext->memctl.malloc(TABLES_LENGTH, gcontext->memctl.memory_data) :
  malloc(TABLES_LENGTH));
#endif  /* PCRE2_DFTABLES */

int i;
uint8_t *p;

if (yield == NULL) return NULL;
p = yield;

/* First comes the lower casing table */

for (i = 0; i < 256; i++) *p++ = tolower(i);

/* Next the case-flipping table */

for (i = 0; i < 256; i++)
  {
  int c = islower(i)? toupper(i) : tolower(i);
  *p++ = (c < 256)? c : i;
  }

/* Then the character class tables. Don't try to be clever and save effort on
exclusive ones - in some locales things may be different.

Note that the table for "space" includes everything "isspace" gives, including
VT in the default locale. This makes it work for the POSIX class [:space:].
From PCRE1 release 8.34 and for all PCRE2 releases it is also correct for Perl
space, because Perl added VT at release 5.18.

Note also that it is possible for a character to be alnum or alpha without
being lower or upper, such as "male and female ordinals" (\xAA and \xBA) in the
fr_FR locale (at least under Debian Linux's locales as of 12/2005). So we must
test for alnum specially. */

memset(p, 0, cbit_length);
for (i = 0; i < 256; i++)
  {
  if (isdigit(i))  p[cbit_digit  + i/8] |= 1u << (i&7);
  if (isupper(i))  p[cbit_upper  + i/8] |= 1u << (i&7);
  if (islower(i))  p[cbit_lower  + i/8] |= 1u << (i&7);
  if (isalnum(i))  p[cbit_word   + i/8] |= 1u << (i&7);
  if (i == '_')    p[cbit_word   + i/8] |= 1u << (i&7);
  if (isspace(i))  p[cbit_space  + i/8] |= 1u << (i&7);
  if (isxdigit(i)) p[cbit_xdigit + i/8] |= 1u << (i&7);
  if (isgraph(i))  p[cbit_graph  + i/8] |= 1u << (i&7);
  if (isprint(i))  p[cbit_print  + i/8] |= 1u << (i&7);
  if (ispunct(i))  p[cbit_punct  + i/8] |= 1u << (i&7);
  if (iscntrl(i))  p[cbit_cntrl  + i/8] |= 1u << (i&7);
  }
p += cbit_length;

/* Finally, the character type table. In this, we used to exclude VT from the
white space chars, because Perl didn't recognize it as such for \s and for
comments within regexes. However, Perl changed at release 5.18, so PCRE1
changed at release 8.34 and it's always been this way for PCRE2. */

for (i = 0; i < 256; i++)
  {
  int x = 0;
  if (isspace(i)) x += ctype_space;
  if (isalpha(i)) x += ctype_letter;
  if (islower(i)) x += ctype_lcletter;
  if (isdigit(i)) x += ctype_digit;
  if (isalnum(i) || i == '_') x += ctype_word;
  *p++ = x;
  }

return yield;
}

#ifndef PCRE2_DFTABLES   /* Compiling the library */
PCRE2_EXP_DEFN void PCRE2_CALL_CONVENTION
pcre2_maketables_free(pcre2_general_context *gcontext, const uint8_t *tables)
{
if (gcontext != NULL)
  gcontext->memctl.free((void *)tables, gcontext->memctl.memory_data);
else
  free((void *)tables);
}
#endif

/* End of pcre2_maketables.c */


================================================
FILE: Libraries/PCRE/pcre2_match.c
================================================
/*************************************************
*      Perl-Compatible Regular Expressions       *
*************************************************/

/* PCRE is a library of functions to support regular expressions whose syntax
and semantics are as close as possible to those of the Perl 5 language.

                       Written by Philip Hazel
     Original API code Copyright (c) 1997-2012 University of Cambridge
          New API code Copyright (c) 2015-2024 University of Cambridge

-----------------------------------------------------------------------------
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

    * Redistributions of source code must retain the above copyright notice,
      this list of conditions and the following disclaimer.

    * Redistributions in binary form must reproduce the above copyright
      notice, this list of conditions and the following disclaimer in the
      documentation and/or other materials provided with the distribution.

    * Neither the name of the University of Cambridge nor the names of its
      contributors may be used to endorse or promote products derived from
      this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
-----------------------------------------------------------------------------
*/


#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include "pcre2_internal.h"

/* These defines enable debugging code */

/* #define DEBUG_FRAMES_DISPLAY */
/* #define DEBUG_SHOW_OPS */
/* #define DEBUG_SHOW_RMATCH */

#ifdef DEBUG_FRAMES_DISPLAY
#include <stdarg.h>
#endif

#ifdef DEBUG_SHOW_OPS
static const char *OP_names[] = { OP_NAME_LIST };
#endif

/* These defines identify the name of the block containing "static"
information, and fields within it. */

#define NLBLOCK mb              /* Block containing newline information */
#define PSSTART start_subject   /* Field containing processed string start */
#define PSEND   end_subject     /* Field containing processed string end */

#define RECURSE_UNSET 0xffffffffu  /* Bigger than max group number */

/* Masks for identifying the public options that are permitted at match time. */

#define PUBLIC_MATCH_OPTIONS \
  (PCRE2_ANCHORED|PCRE2_ENDANCHORED|PCRE2_NOTBOL|PCRE2_NOTEOL|PCRE2_NOTEMPTY| \
   PCRE2_NOTEMPTY_ATSTART|PCRE2_NO_UTF_CHECK|PCRE2_PARTIAL_HARD| \
   PCRE2_PARTIAL_SOFT|PCRE2_NO_JIT|PCRE2_COPY_MATCHED_SUBJECT| \
   PCRE2_DISABLE_RECURSELOOP_CHECK)

#define PUBLIC_JIT_MATCH_OPTIONS \
   (PCRE2_NO_UTF_CHECK|PCRE2_NOTBOL|PCRE2_NOTEOL|PCRE2_NOTEMPTY|\
    PCRE2_NOTEMPTY_ATSTART|PCRE2_PARTIAL_SOFT|PCRE2_PARTIAL_HARD|\
    PCRE2_COPY_MATCHED_SUBJECT)

/* Non-error returns from and within the match() function. Error returns are
externally defined PCRE2_ERROR_xxx codes, which are all negative. */

#define MATCH_MATCH        1
#define MATCH_NOMATCH      0

/* Special internal returns used in the match() function. Make them
sufficiently negative to avoid the external error codes. */

#define MATCH_ACCEPT       (-999)
#define MATCH_KETRPOS      (-998)
/* The next 5 must be kept together and in sequence so that a test that checks
for any one of them can use a range. */
#define MATCH_COMMIT       (-997)
#define MATCH_PRUNE        (-996)
#define MATCH_SKIP         (-995)
#define MATCH_SKIP_ARG     (-994)
#define MATCH_THEN         (-993)
#define MATCH_BACKTRACK_MAX MATCH_THEN
#define MATCH_BACKTRACK_MIN MATCH_COMMIT

/* Group frame type values. Zero means the frame is not a group frame. The
lower 16 bits are used for data (e.g. the capture number). Group frames are
used for most groups so that information about the start is easily available at
the end without having to scan back through intermediate frames (backtrack
points). */

#define GF_CAPTURE     0x00010000u
#define GF_NOCAPTURE   0x00020000u
#define GF_CONDASSERT  0x00030000u
#define GF_RECURSE     0x00040000u

/* Masks for the identity and data parts of the group frame type. */

#define GF_IDMASK(a)   ((a) & 0xffff0000u)
#define GF_DATAMASK(a) ((a) & 0x0000ffffu)

/* Repetition types */

enum { REPTYPE_MIN, REPTYPE_MAX, REPTYPE_POS };

/* Min and max values for the common repeats; a maximum of UINT32_MAX =>
infinity. */

static const uint32_t rep_min[] = {
  0, 0,       /* * and *? */
  1, 1,       /* + and +? */
  0, 0,       /* ? and ?? */
  0, 0,       /* dummy placefillers for OP_CR[MIN]RANGE */
  0, 1, 0 };  /* OP_CRPOS{STAR, PLUS, QUERY} */

static const uint32_t rep_max[] = {
  UINT32_MAX, UINT32_MAX,      /* * and *? */
  UINT32_MAX, UINT32_MAX,      /* + and +? */
  1, 1,                        /* ? and ?? */
  0, 0,                        /* dummy placefillers for OP_CR[MIN]RANGE */
  UINT32_MAX, UINT32_MAX, 1 }; /* OP_CRPOS{STAR, PLUS, QUERY} */

/* Repetition types - must include OP_CRPOSRANGE (not needed above) */

static const uint32_t rep_typ[] = {
  REPTYPE_MAX, REPTYPE_MIN,    /* * and *? */
  REPTYPE_MAX, REPTYPE_MIN,    /* + and +? */
  REPTYPE_MAX, REPTYPE_MIN,    /* ? and ?? */
  REPTYPE_MAX, REPTYPE_MIN,    /* OP_CRRANGE and OP_CRMINRANGE */
  REPTYPE_POS, REPTYPE_POS,    /* OP_CRPOSSTAR, OP_CRPOSPLUS */
  REPTYPE_POS, REPTYPE_POS };  /* OP_CRPOSQUERY, OP_CRPOSRANGE */

/* Numbers for RMATCH calls at backtracking points. When these lists are
changed, the code at RETURN_SWITCH below must be updated in sync.  */

enum { RM1=1, RM2,  RM3,  RM4,  RM5,  RM6,  RM7,  RM8,  RM9,  RM10,
       RM11,  RM12, RM13, RM14, RM15, RM16, RM17, RM18, RM19, RM20,
       RM21,  RM22, RM23, RM24, RM25, RM26, RM27, RM28, RM29, RM30,
       RM31,  RM32, RM33, RM34, RM35, RM36, RM37, RM38, RM39 };

#ifdef SUPPORT_WIDE_CHARS
enum { RM100=100, RM101, RM102, RM103 };
#endif

#ifdef SUPPORT_UNICODE
enum { RM200=200, RM201, RM202, RM203, RM204, RM205, RM206, RM207,
       RM208,     RM209, RM210, RM211, RM212, RM213, RM214, RM215,
       RM216,     RM217, RM218, RM219, RM220, RM221, RM222, RM223,
       RM224 };
#endif

/* Define short names for general fields in the current backtrack frame, which
is always pointed to by the F variable. Occasional references to fields in
other frames are written out explicitly. There are also some fields in the
current frame whose names start with "temp" that are used for short-term,
localised backtracking memory. These are #defined with Lxxx names at the point
of use and undefined afterwards. */

#define Fback_frame        F->back_frame
#define Fcapture_last      F->capture_last
#define Fcurrent_recurse   F->current_recurse
#define Fecode             F->ecode
#define Feptr              F->eptr
#define Fgroup_frame_type  F->group_frame_type
#define Flast_group_offset F->last_group_offset
#define Flength            F->length
#define Fmark              F->mark
#define Frdepth            F->rdepth
#define Fstart_match       F->start_match
#define Foffset_top        F->offset_top
#define Foccu              F->occu
#define Fop                F->op
#define Fovector           F->ovector
#define Freturn_id         F->return_id


#ifdef DEBUG_FRAMES_DISPLAY
/*************************************************
*      Display current frames and contents       *
*************************************************/

/* This debugging function displays the current set of frames and their
contents. It is not called automatically from anywhere, the intention being
that calls can be inserted where necessary when debugging frame-related
problems.

Arguments:
  f           the file to write to
  F           the current top frame
  P           a previous frame of interest
  frame_size  the frame size
  mb          points to the match block
  match_data  points to the match data block
  s           identification text

Returns:    nothing
*/

static void
display_frames(FILE *f, heapframe *F, heapframe *P, PCRE2_SIZE frame_size,
  match_block *mb, pcre2_match_data *match_data, const char *s, ...)
{
uint32_t i;
heapframe *Q;
va_list ap;
va_start(ap, s);

fprintf(f, "FRAMES ");
vfprintf(f, s, ap);
va_end(ap);

if (P != NULL) fprintf(f, " P=%lu",
  ((char *)P - (char *)(match_data->heapframes))/frame_size);
fprintf(f, "\n");

for (i = 0, Q = match_data->heapframes;
     Q <= F;
     i++, Q = (heapframe *)((char *)Q + frame_size))
  {
  fprintf(f, "Frame %d type=%x subj=%lu code=%d back=%lu id=%d",
    i, Q->group_frame_type, Q->eptr - mb->start_subject, *(Q->ecode),
    Q->back_frame, Q->return_id);

  if (Q->last_group_offset == PCRE2_UNSET)
    fprintf(f, " lgoffset=unset\n");
  else
    fprintf(f, " lgoffset=%lu\n",  Q->last_group_offset/frame_size);
  }
}

#endif



/*************************************************
*                Process a callout               *
*************************************************/

/* This function is called for all callouts, whether "standalone" or at the
start of a conditional group. Feptr will be pointing to either OP_CALLOUT or
OP_CALLOUT_STR. A callout block is allocated in pcre2_match() and initialized
with fixed values.

Arguments:
  F          points to the current backtracking frame
  mb         points to the match block
  lengthptr  where to return the length of the callout item

Returns:     the return from the callout
             or 0 if no callout function exists
*/

static int
do_callout(heapframe *F, match_block *mb, PCRE2_SIZE *lengthptr)
{
int rc;
PCRE2_SIZE save0, save1;
PCRE2_SIZE *callout_ovector;
pcre2_callout_block *cb;

*lengthptr = (*Fecode == OP_CALLOUT)?
  PRIV(OP_lengths)[OP_CALLOUT] : GET(Fecode, 1 + 2*LINK_SIZE);

if (mb->callout == NULL) return 0;   /* No callout function provided */

/* The original matching code (pre 10.30) worked directly with the ovector
passed by the user, and this was passed to callouts. Now that the working
ovector is in the backtracking frame, it no longer needs to reserve space for
the overall match offsets (which would waste space in the frame). For backward
compatibility, however, we pass capture_top and offset_vector to the callout as
if for the extended ovector, and we ensure that the first two slots are unset
by preserving and restoring their current contents. Picky compilers complain if
references such as Fovector[-2] are use directly, so we set up a separate
pointer. */

callout_ovector = (PCRE2_SIZE *)(Fovector) - 2;

/* The cb->version, cb->subject, cb->subject_length, and cb->start_match fields
are set externally. The first 3 never change; the last is updated for each
bumpalong. */

cb = mb->cb;
cb->capture_top      = (uint32_t)Foffset_top/2 + 1;
cb->capture_last     = Fcapture_last;
cb->offset_vector    = callout_ovector;
cb->mark             = mb->nomatch_mark;
cb->current_position = (PCRE2_SIZE)(Feptr - mb->start_subject);
cb->pattern_position = GET(Fecode, 1);
cb->next_item_length = GET(Fecode, 1 + LINK_SIZE);

if (*Fecode == OP_CALLOUT)  /* Numerical callout */
  {
  cb->callout_number = Fecode[1 + 2*LINK_SIZE];
  cb->callout_string_offset = 0;
  cb->callout_string = NULL;
  cb->callout_string_length = 0;
  }
else  /* String callout */
  {
  cb->callout_number = 0;
  cb->callout_string_offset = GET(Fecode, 1 + 3*LINK_SIZE);
  cb->callout_string = Fecode + (1 + 4*LINK_SIZE) + 1;
  cb->callout_string_length =
    *lengthptr - (1 + 4*LINK_SIZE) - 2;
  }

save0 = callout_ovector[0];
save1 = callout_ovector[1];
callout_ovector[0] = callout_ovector[1] = PCRE2_UNSET;
rc = mb->callout(cb, mb->callout_data);
callout_ovector[0] = save0;
callout_ovector[1] = save1;
cb->callout_flags = 0;
return rc;
}



/*************************************************
*          Match a back-reference                *
*************************************************/

/* This function is called only when it is known that the offset lies within
the offsets that have so far been used in the match. Note that in caseless
UTF-8 mode, the number of subject bytes matched may be different to the number
of reference bytes. (In theory this could also happen in UTF-16 mode, but it
seems unlikely.)

Arguments:
  offset      index into the offset vector
  caseless    TRUE if caseless
  caseopts    bitmask of REFI_FLAG_XYZ values
  F           the current backtracking frame pointer
  mb          points to match block
  lengthptr   pointer for returning the length matched

Returns:      = 0 sucessful match; number of code units matched is set
              < 0 no match
              > 0 partial match
*/

static int
match_ref(PCRE2_SIZE offset, BOOL caseless, int caseopts, heapframe *F,
  match_block *mb, PCRE2_SIZE *lengthptr)
{
PCRE2_SPTR p;
PCRE2_SIZE length;
PCRE2_SPTR eptr;
PCRE2_SPTR eptr_start;

/* Deal with an unset group. The default is no match, but there is an option to
match an empty string. */

if (offset >= Foffset_top || Fovector[offset] == PCRE2_UNSET)
  {
  if ((mb->poptions & PCRE2_MATCH_UNSET_BACKREF) != 0)
    {
    *lengthptr = 0;
    return 0;      /* Match */
    }
  else return -1;  /* No match */
  }

/* Separate the caseless and UTF cases for speed. */

eptr = eptr_start = Feptr;
p = mb->start_subject + Fovector[offset];
length = Fovector[offset+1] - Fovector[offset];

if (caseless)
  {
#if defined SUPPORT_UNICODE
  BOOL utf = (mb->poptions & PCRE2_UTF) != 0;
  BOOL caseless_restrict = (caseopts & REFI_FLAG_CASELESS_RESTRICT) != 0;
  BOOL turkish_casing = !caseless_restrict && (caseopts & REFI_FLAG_TURKISH_CASING) != 0;

  if (utf || (mb->poptions & PCRE2_UCP) != 0)
    {
    PCRE2_SPTR endptr = p + length;

    /* Match characters up to the end of the reference. NOTE: the number of
    code units matched may differ, because in UTF-8 there are some characters
    whose upper and lower case codes have different numbers of bytes. For
    example, U+023A (2 bytes in UTF-8) is the upper case version of U+2C65 (3
    bytes in UTF-8); a sequence of 3 of the former uses 6 bytes, as does a
    sequence of two of the latter. It is important, therefore, to check the
    length along the reference, not along the subject (earlier code did this
    wrong). UCP without uses Unicode properties but without UTF encoding. */

    while (p < endptr)
      {
      uint32_t c, d;
      const ucd_record *ur;
      if (eptr >= mb->end_subject) return 1;   /* Partial match */

      if (utf)
        {
        GETCHARINC(c, eptr);
        GETCHARINC(d, p);
        }
      else
        {
        c = *eptr++;
        d = *p++;
        }

      if (turkish_casing && UCD_ANY_I(d))
        {
        c = UCD_FOLD_I_TURKISH(c);
        d = UCD_FOLD_I_TURKISH(d);
        if (c != d) return -1;  /* No match */
        }
      else if (c != d && c != (uint32_t)((int)d + (ur = GET_UCD(d))->other_case))
        {
        const uint32_t *pp = PRIV(ucd_caseless_sets) + ur->caseset;

        /* When PCRE2_EXTRA_CASELESS_RESTRICT is set, ignore any caseless sets
        that start with an ASCII character. */
        if (caseless_restrict && *pp < 128) return -1;  /* No match */

        for (;;)
          {
          if (c < *pp) return -1;  /* No match */
          if (c == *pp++) break;
          }
        }
      }
    }
  else
#endif

  /* Not in UTF or UCP mode */
    {
    for (; length > 0; length--)
      {
      uint32_t cc, cp;
      if (eptr >= mb->end_subject) return 1;   /* Partial match */
      cc = UCHAR21TEST(eptr);
      cp = UCHAR21TEST(p);
      if (TABLE_GET(cp, mb->lcc, cp) != TABLE_GET(cc, mb->lcc, cc))
        return -1;  /* No match */
      p++;
      eptr++;
      }
    }
  }

/* In the caseful case, we can just compare the code units, whether or not we
are in UTF and/or UCP mode. When partial matching, we have to do this unit by
unit. */

else
  {
  if (mb->partial != 0)
    {
    for (; length > 0; length--)
      {
      if (eptr >= mb->end_subject) return 1;   /* Partial match */
      if (UCHAR21INCTEST(p) != UCHAR21INCTEST(eptr)) return -1;  /* No match */
      }
    }

  /* Not partial matching */

  else
    {
    if ((PCRE2_SIZE)(mb->end_subject - eptr) < length) return 1; /* Partial */
    if (memcmp(p, eptr, CU2BYTES(length)) != 0) return -1;  /* No match */
    eptr += length;
    }
  }

*lengthptr = eptr - eptr_start;
return 0;  /* Match */
}



/******************************************************************************
*******************************************************************************
                   "Recursion" in the match() function

The original match() function was highly recursive, but this proved to be the
source of a number of problems over the years, mostly because of the relatively
small system stacks that are commonly found. As new features were added to
patterns, various kludges were invented to reduce the amount of stack used,
making the code hard to understand in places.

A version did exist that used individual frames on the heap instead of calling
match() recursively, but this ran substantially slower. The current version is
a refactoring that uses a vector of frames to remember backtracking points.
This runs no slower, and possibly even a bit faster than the original recursive
implementation.

At first, an initial vector of size START_FRAMES_SIZE (enough for maybe 50
frames) was allocated on the system stack. If this was not big enough, the heap
was used for a larger vector. However, it turns out that there are environments
where taking as little as 20KiB from the system stack is an embarrassment.
After another refactoring, the heap is used exclusively, but a pointer the
frames vector and its size are cached in the match_data block, so that there is
no new memory allocation if the same match_data block is used for multiple
matches (unless the frames vector has to be extended).
*******************************************************************************
******************************************************************************/




/*************************************************
*       Macros for the match() function          *
*************************************************/

/* These macros pack up tests that are used for partial matching several times
in the code. The second one is used when we already know we are past the end of
the subject. We set the "hit end" flag if the pointer is at the end of the
subject and either (a) the pointer is past the earliest inspected character
(i.e. something has been matched, even if not part of the actual matched
string), or (b) the pattern contains a lookbehind. These are the conditions for
which adding more characters may allow the current match to continue.

For hard partial matching, we immediately return a partial match. Otherwise,
carrying on means that a complete match on the current subject will be sought.
A partial match is returned only if no complete match can be found. */

#define CHECK_PARTIAL() \
  do { \
     if (Feptr >= mb->end_subject) \
       { \
       SCHECK_PARTIAL(); \
       } \
     } \
  while (0)

#define SCHECK_PARTIAL() \
  do { \
     if (mb->partial != 0 && \
         (Feptr > mb->start_used_ptr || mb->allowemptypartial)) \
       { \
       mb->hitend = TRUE; \
       if (mb->partial > 1) return PCRE2_ERROR_PARTIAL; \
       } \
     } \
  while (0)


/* These macros are used to implement backtracking. They simulate a recursive
call to the match() function by means of a local vector of frames which
remember the backtracking points. */

#define RMATCH(ra,rb) \
  do { \
     start_ecode = ra; \
     Freturn_id = rb; \
     goto MATCH_RECURSE; \
     L_##rb:; \
     } \
  while (0)

#define RRETURN(ra) \
  do { \
     rrc = ra; \
     goto RETURN_SWITCH; \
     } \
  while (0)



/*************************************************
*         Match from current position            *
*************************************************/

/* This function is called to run one match attempt at a single starting point
in the subject.

Performance note: It might be tempting to extract commonly used fields from the
mb structure (e.g. end_subject) into individual variables to improve
performance. Tests using gcc on a SPARC disproved this; in the first case, it
made performance worse.

Arguments:
   start_eptr   starting character in subject
   start_ecode  starting position in compiled code
   top_bracket  number of capturing parentheses in the pattern
   frame_size   size of each backtracking frame
   match_data   pointer to the match_data block
   mb           pointer to "static" variables block

Returns:        MATCH_MATCH if matched            )  these values are >= 0
                MATCH_NOMATCH if failed to match  )
                negative MATCH_xxx value for PRUNE, SKIP, etc
                negative PCRE2_ERROR_xxx value if aborted by an error condition
                (e.g. stopped by repeated call or depth limit)
*/

static int
match(PCRE2_SPTR start_eptr, PCRE2_SPTR start_ecode, uint16_t top_bracket,
  PCRE2_SIZE frame_size, pcre2_match_data *match_data, match_block *mb)
{
/* Frame-handling variables */

heapframe *F;           /* Current frame pointer */
heapframe *N = NULL;    /* Temporary frame pointers */
heapframe *P = NULL;

heapframe *frames_top;  /* End of frames vector */
heapframe *assert_accept_frame = NULL;  /* For passing back a frame with captures */
PCRE2_SIZE frame_copy_size;   /* Amount to copy when creating a new frame */

/* Local variables that do not need to be preserved over calls to RRMATCH(). */

PCRE2_SPTR branch_end = NULL;
PCRE2_SPTR branch_start;
PCRE2_SPTR bracode;     /* Temp pointer to start of group */
PCRE2_SIZE offset;      /* Used for group offsets */
PCRE2_SIZE length;      /* Used for various length calculations */

int rrc;                /* Return from functions & backtracking "recursions" */
#ifdef SUPPORT_UNICODE
int proptype;           /* Type of character property */
#endif

uint32_t i;             /* Used for local loops */
uint32_t fc;            /* Character values */
uint32_t number;        /* Used for group and other numbers */
uint32_t reptype = 0;   /* Type of repetition (0 to avoid compiler warning) */
uint32_t group_frame_type;  /* Specifies type for new group frames */

BOOL condition;         /* Used in conditional groups */
BOOL cur_is_word;       /* Used in "word" tests */
BOOL prev_is_word;      /* Used in "word" tests */

/* UTF and UCP flags */

#ifdef SUPPORT_UNICODE
BOOL utf = (mb->poptions & PCRE2_UTF) != 0;
BOOL ucp = (mb->poptions & PCRE2_UCP) != 0;
#else
BOOL utf = FALSE;  /* Required for convenience even when no Unicode support */
#endif

/* This is the length of the last part of a backtracking frame that must be
copied when a new frame is created. */

frame_copy_size = frame_size - offsetof(heapframe, eptr);

/* Set up the first frame and the end of the frames vector. */

F = match_data->heapframes;
frames_top = (heapframe *)((char *)F + match_data->heapframes_size);

Frdepth = 0;                        /* "Recursion" depth */
Fcapture_last = 0;                  /* Number of most recent capture */
Fcurrent_recurse = RECURSE_UNSET;   /* Not pattern recursing. */
Fstart_match = Feptr = start_eptr;  /* Current data pointer and start match */
Fmark = NULL;                       /* Most recent mark */
Foffset_top = 0;                    /* End of captures within the frame */
Flast_group_offset = PCRE2_UNSET;   /* Saved frame of most recent group */
group_frame_type = 0;               /* Not a start of group frame */
goto NEW_FRAME;                     /* Start processing with this frame */

/* Come back here when we want to create a new frame for remembering a
backtracking point. */

MATCH_RECURSE:

/* Set up a new backtracking frame. If the vector is full, get a new one,
doubling the size, but constrained by the heap limit (which is in KiB). */

N = (heapframe *)((char *)F + frame_size);
if ((heapframe *)((char *)N + frame_size) >= frames_top)
  {
  heapframe *new;
  PCRE2_SIZE newsize;
  PCRE2_SIZE usedsize = (char *)N - (char *)(match_data->heapframes);

  if (match_data->heapframes_size >= PCRE2_SIZE_MAX / 2)
    {
    if (match_data->heapframes_size == PCRE2_SIZE_MAX - 1)
      return PCRE2_ERROR_NOMEMORY;
    newsize = PCRE2_SIZE_MAX - 1;
    }
  else
    newsize = match_data->heapframes_size * 2;

  if (newsize / 1024 >= mb->heap_limit)
    {
    PCRE2_SIZE old_size = match_data->heapframes_size / 1024;
    if (mb->heap_limit <= old_size)
      return PCRE2_ERROR_HEAPLIMIT;
    else
      {
      PCRE2_SIZE max_delta = 1024 * (mb->heap_limit - old_size);
      int over_bytes = match_data->heapframes_size % 1024;
      if (over_bytes) max_delta -= (1024 - over_bytes);
      newsize = match_data->heapframes_size + max_delta;
      }
    }

  /* With a heap limit set, the permitted additional size may not be enough for
  another frame, so do a final check. */

  if (newsize - usedsize < frame_size) return PCRE2_ERROR_HEAPLIMIT;
  new = match_data->memctl.malloc(newsize, match_data->memctl.memory_data);
  if (new == NULL) return PCRE2_ERROR_NOMEMORY;
  memcpy(new, match_data->heapframes, usedsize);

  N = (heapframe *)((char *)new + usedsize);
  F = (heapframe *)((char *)N - frame_size);

  match_data->memctl.free(match_data->heapframes, match_data->memctl.memory_data);
  match_data->heapframes = new;
  match_data->heapframes_size = newsize;
  frames_top = (heapframe *)((char *)new + newsize);
  }

#ifdef DEBUG_SHOW_RMATCH
fprintf(stderr, "++ RMATCH %d frame=%d", Freturn_id, Frdepth + 1);
if (group_frame_type != 0)
  {
  fprintf(stderr, " type=%x ", group_frame_type);
  switch (GF_IDMASK(group_frame_type))
    {
    case GF_CAPTURE:
    fprintf(stderr, "capture=%d", GF_DATAMASK(group_frame_type));
    break;

    case GF_NOCAPTURE:
    fprintf(stderr, "nocapture op=%d", GF_DATAMASK(group_frame_type));
    break;

    case GF_CONDASSERT:
    fprintf(stderr, "condassert op=%d", GF_DATAMASK(group_frame_type));
    break;

    case GF_RECURSE:
    fprintf(stderr, "recurse=%d", GF_DATAMASK(group_frame_type));
    break;

    default:
    fprintf(stderr, "*** unknown ***");
    break;
    }
  }
fprintf(stderr, "\n");
#endif

/* Copy those fields that must be copied into the new frame, increase the
"recursion" depth (i.e. the new frame's index) and then make the new frame
current. */

memcpy((char *)N + offsetof(heapframe, eptr),
       (char *)F + offsetof(heapframe, eptr),
       frame_copy_size);

N->rdepth = Frdepth + 1;
F = N;

/* Carry on processing with a new frame. */

NEW_FRAME:
Fgroup_frame_type = group_frame_type;
Fecode = start_ecode;      /* Starting code pointer */
Fback_frame = frame_size;  /* Default is go back one frame */

/* If this is a special type of group frame, remember its offset for quick
access at the end of the group. If this is a recursion, set a new current
recursion value. */

if (group_frame_type != 0)
  {
  Flast_group_offset = (char *)F - (char *)match_data->heapframes;
  if (GF_IDMASK(group_frame_type) == GF_RECURSE)
    Fcurrent_recurse = GF_DATAMASK(group_frame_type);
  group_frame_type = 0;
  }


/* ========================================================================= */
/* This is the main processing loop. First check that we haven't recorded too
many backtracks (search tree is too large), or that we haven't exceeded the
recursive depth limit (used too many backtracking frames). If not, process the
opcodes. */

if (mb->match_call_count++ >= mb->match_limit) return PCRE2_ERROR_MATCHLIMIT;
if (Frdepth >= mb->match_limit_depth) return PCRE2_ERROR_DEPTHLIMIT;

#ifdef DEBUG_SHOW_OPS
fprintf(stderr, "\n++ New frame: type=0x%x subject offset %ld\n",
  GF_IDMASK(Fgroup_frame_type), Feptr - mb->start_subject);
#endif

for (;;)
  {
#ifdef DEBUG_SHOW_OPS
fprintf(stderr, "++ %2ld op=%3d %s\n", Fecode - mb->start_code, *Fecode,
  OP_names[*Fecode]);
#endif

  Fop = (uint8_t)(*Fecode);  /* Cast needed for 16-bit and 32-bit modes */
  switch(Fop)
    {
    /* ===================================================================== */
    /* Before OP_ACCEPT there may be any number of OP_CLOSE opcodes, to close
    any currently open capturing brackets. Unlike reaching the end of a group,
    where we know the starting frame is at the top of the chained frames, in
    this case we have to search back for the relevant frame in case other types
    of group that use chained frames have intervened. Multiple OP_CLOSEs always
    come innermost first, which matches the chain order. We can ignore this in
    a recursion, because captures are not passed out of recursions. */

    case OP_CLOSE:
    if (Fcurrent_recurse == RECURSE_UNSET)
      {
      number = GET2(Fecode, 1);
      offset = Flast_group_offset;
      for(;;)
        {
        /* Corrupted heapframes?. Trigger an assert and return an error */
        PCRE2_ASSERT(offset != PCRE2_UNSET);
        if (offset == PCRE2_UNSET) return PCRE2_ERROR_INTERNAL;

        N = (heapframe *)((char *)match_data->heapframes + offset);
        P = (heapframe *)((char *)N - frame_size);
        if (N->group_frame_type == (GF_CAPTURE | number)) break;
        offset = P->last_group_offset;
        }
      offset = (number << 1) - 2;
      Fcapture_last = number;
      Fovector[offset] = P->eptr - mb->start_subject;
      Fovector[offset+1] = Feptr - mb->start_subject;
      if (offset >= Foffset_top) Foffset_top = offset + 2;
      }
    Fecode += PRIV(OP_lengths)[*Fecode];
    break;


    /* ===================================================================== */
    /* Real or forced end of the pattern, assertion, or recursion. In an
    assertion ACCEPT, update the last used pointer and remember the current
    frame so that the captures and mark can be fished out of it. */

    case OP_ASSERT_ACCEPT:
    if (Feptr > mb->last_used_ptr) mb->last_used_ptr = Feptr;
    assert_accept_frame = F;
    RRETURN(MATCH_ACCEPT);

    /* For ACCEPT within a recursion, we have to find the most recent
    recursion. If not in a recursion, fall through to code that is common with
    OP_END. */

    case OP_ACCEPT:
    if (Fcurrent_recurse != RECURSE_UNSET)
      {
#ifdef DEBUG_SHOW_OPS
      fprintf(stderr, "++ Accept within recursion\n");
#endif
      offset = Flast_group_offset;
      for(;;)
        {
        /* Corrupted heapframes?. Trigger an assert and return an error */
        PCRE2_ASSERT(offset != PCRE2_UNSET);
        if (offset == PCRE2_UNSET) return PCRE2_ERROR_INTERNAL;

        N = (heapframe *)((char *)match_data->heapframes + offset);
        P = (heapframe *)((char *)N - frame_size);
        if (GF_IDMASK(N->group_frame_type) == GF_RECURSE) break;
        offset = P->last_group_offset;
        }

      /* N is now the frame of the recursion; the previous frame is at the
      OP_RECURSE position. Go back there, copying the current subject position
      and mark, and the start_match position (\K might have changed it), and
      then move on past the OP_RECURSE. */

      P->eptr = Feptr;
      P->mark = Fmark;
      P->start_match = Fstart_match;
      F = P;
      Fecode += 1 + LINK_SIZE;
      continue;
      }
    /* Fall through */

    /* OP_END itself can never be reached within a recursion because that is
    picked up when the OP_KET that always precedes OP_END is reached. */

    case OP_END:

    /* Fail for an empty string match if either PCRE2_NOTEMPTY is set, or if
    PCRE2_NOTEMPTY_ATSTART is set and we have matched at the start of the
    subject. In both cases, backtracking will then try other alternatives, if
    any. */

    if (Feptr == Fstart_match &&
         ((mb->moptions & PCRE2_NOTEMPTY) != 0 ||
           ((mb->moptions & PCRE2_NOTEMPTY_ATSTART) != 0 &&
             Fstart_match == mb->start_subject + mb->start_offset)))
      {
#ifdef DEBUG_SHOW_OPS
      fprintf(stderr, "++ Backtrack because empty string\n");
#endif
      RRETURN(MATCH_NOMATCH);
      }

    /* Fail if PCRE2_ENDANCHORED is set and the end of the match is not
    the end of the subject. After (*ACCEPT) we fail the entire match (at this
    position) but backtrack if we've reached the end of the pattern. This
    applies whether or not we are in a recursion. */

    if (Feptr < mb->end_subject &&
        ((mb->moptions | mb->poptions) & PCRE2_ENDANCHORED) != 0)
      {
      if (Fop == OP_END)
        {
#ifdef DEBUG_SHOW_OPS
        fprintf(stderr, "++ Backtrack because not at end (endanchored set)\n");
#endif
        RRETURN(MATCH_NOMATCH);
        }

#ifdef DEBUG_SHOW_OPS
      fprintf(stderr, "++ Failed ACCEPT not at end (endanchnored set)\n");
#endif
      return MATCH_NOMATCH;   /* (*ACCEPT) */
      }

    /* We have a successful match of the whole pattern. Record the result and
    then do a direct return from the function. If there is space in the offset
    vector, set any pairs that follow the highest-numbered captured string but
    are less than the number of capturing groups in the pattern to PCRE2_UNSET.
    It is documented that this happens. "Gaps" are set to PCRE2_UNSET
    dynamically. It is only those at the end that need setting here. */

    mb->end_match_ptr = Feptr;           /* Record where we ended */
    mb->end_offset_top = Foffset_top;    /* and how many extracts were taken */
    mb->mark = Fmark;                    /* and the last success mark */
    if (Feptr > mb->last_used_ptr) mb->last_used_ptr = Feptr;

    match_data->ovector[0] = Fstart_match - mb->start_subject;
    match_data->ovector[1] = Feptr - mb->start_subject;

    /* Set i to the smaller of the sizes of the external and frame ovectors. */

    i = 2 * ((top_bracket + 1 > match_data->oveccount)?
      match_data->oveccount : top_bracket + 1);
    memcpy(match_data->ovector + 2, Fovector, (i - 2) * sizeof(PCRE2_SIZE));
    while (--i >= Foffset_top + 2) match_data->ovector[i] = PCRE2_UNSET;
    return MATCH_MATCH;  /* Note: NOT RRETURN */


    /*===================================================================== */
    /* Match any single character type except newline; have to take care with
    CRLF newlines and partial matching. */

    case OP_ANY:
    if (IS_NEWLINE(Feptr)) RRETURN(MATCH_NOMATCH);
    if (mb->partial != 0 &&
        Feptr == mb->end_subject - 1 &&
        NLBLOCK->nltype == NLTYPE_FIXED &&
        NLBLOCK->nllen == 2 &&
        UCHAR21TEST(Feptr) == NLBLOCK->nl[0])
      {
      mb->hitend = TRUE;
      if (mb->partial > 1) return PCRE2_ERROR_PARTIAL;
      }
    /* Fall through */

    /* Match any single character whatsoever. */

    case OP_ALLANY:
    if (Feptr >= mb->end_subject)  /* DO NOT merge the Feptr++ here; it must */
      {                            /* not be updated before SCHECK_PARTIAL. */
      SCHECK_PARTIAL();
      RRETURN(MATCH_NOMATCH);
      }
    Feptr++;
#ifdef SUPPORT_UNICODE
    if (utf) ACROSSCHAR(Feptr < mb->end_subject, Feptr, Feptr++);
#endif
    Fecode++;
    break;


    /* ===================================================================== */
    /* Match a single code unit, even in UTF mode. This opcode really does
    match any code unit, even newline. (It really should be called ANYCODEUNIT,
    of course - the byte name is from pre-16 bit days.) */

    case OP_ANYBYTE:
    if (Feptr >= mb->end_subject)   /* DO NOT merge the Feptr++ here; it must */
      {                             /* not be updated before SCHECK_PARTIAL. */
      SCHECK_PARTIAL();
      RRETURN(MATCH_NOMATCH);
      }
    Feptr++;
    Fecode++;
    break;


    /* ===================================================================== */
    /* Match a single character, casefully */

    case OP_CHAR:
#ifdef SUPPORT_UNICODE
    if (utf)
      {
      Flength = 1;
      Fecode++;
      GETCHARLEN(fc, Fecode, Flength);
      if (Flength > (PCRE2_SIZE)(mb->end_subject - Feptr))
        {
        CHECK_PARTIAL();             /* Not SCHECK_PARTIAL() */
        RRETURN(MATCH_NOMATCH);
        }
      for (; Flength > 0; Flength--)
        {
        if (*Fecode++ != UCHAR21INC(Feptr)) RRETURN(MATCH_NOMATCH);
        }
      }
    else
#endif

    /* Not UTF mode */
      {
      if (mb->end_subject - Feptr < 1)
        {
        SCHECK_PARTIAL();            /* This one can use SCHECK_PARTIAL() */
        RRETURN(MATCH_NOMATCH);
        }
      if (Fecode[1] != *Feptr++) RRETURN(MATCH_NOMATCH);
      Fecode += 2;
      }
    break;


    /* ===================================================================== */
    /* Match a single character, caselessly. If we are at the end of the
    subject, give up immediately. We get here only when the pattern character
    has at most one other case. Characters with more than two cases are coded
    as OP_PROP with the pseudo-property PT_CLIST. */

    case OP_CHARI:
    if (Feptr >= mb->end_subject)
      {
      SCHECK_PARTIAL();
      RRETURN(MATCH_NOMATCH);
      }

#ifdef SUPPORT_UNICODE
    if (utf)
      {
      Flength = 1;
      Fecode++;
      GETCHARLEN(fc, Fecode, Flength);

      /* If the pattern character's value is < 128, we know that its other case
      (if any) is also < 128 (and therefore only one code unit long in all
      code-unit widths), so we can use the fast lookup table. We checked above
      that there is at least one character left in the subject. */

      if (fc < 128)
        {
        uint32_t cc = UCHAR21(Feptr);
        if (mb->lcc[fc] != TABLE_GET(cc, mb->lcc, cc)) RRETURN(MATCH_NOMATCH);
        Fecode++;
        Feptr++;
        }

      /* Otherwise we must pick up the subject character and use Unicode
      property support to test its other case. Note that we cannot use the
      value of "Flength" to check for sufficient bytes left, because the other
      case of the character may have more or fewer code units. */

      else
        {
        uint32_t dc;
        GETCHARINC(dc, Feptr);
        Fecode += Flength;
        if (dc != fc && dc != UCD_OTHERCASE(fc)) RRETURN(MATCH_NOMATCH);
        }
      }

    /* If UCP is set without UTF we must do the same as above, but with one
    character per code unit. */

    else if (ucp)
      {
      uint32_t cc = UCHAR21(Feptr);
      fc = Fecode[1];
      if (fc < 128)
        {
        if (mb->lcc[fc] != TABLE_GET(cc, mb->lcc, cc)) RRETURN(MATCH_NOMATCH);
        }
      else
        {
        if (cc != fc && cc != UCD_OTHERCASE(fc)) RRETURN(MATCH_NOMATCH);
        }
      Feptr++;
      Fecode += 2;
      }

    else
#endif   /* SUPPORT_UNICODE */

    /* Not UTF or UCP mode; use the table for characters < 256. */
      {
      if (TABLE_GET(Fecode[1], mb->lcc, Fecode[1])
          != TABLE_GET(*Feptr, mb->lcc, *Feptr)) RRETURN(MATCH_NOMATCH);
      Feptr++;
      Fecode += 2;
      }
    break;


    /* ===================================================================== */
    /* Match not a single character. */

    case OP_NOT:
    case OP_NOTI:
    if (Feptr >= mb->end_subject)
      {
      SCHECK_PARTIAL();
      RRETURN(MATCH_NOMATCH);
      }

#ifdef SUPPORT_UNICODE
    if (utf)
      {
      uint32_t ch;
      Fecode++;
      GETCHARINC(ch, Fecode);
      GETCHARINC(fc, Feptr);
      if (ch == fc)
        {
        RRETURN(MATCH_NOMATCH);  /* Caseful match */
        }
      else if (Fop == OP_NOTI)   /* If caseless */
        {
        if (ch > 127)
          ch = UCD_OTHERCASE(ch);
        else
          ch = (mb->fcc)[ch];
        if (ch == fc) RRETURN(MATCH_NOMATCH);
        }
      }

    /* UCP without UTF is as above, but with one character per code unit. */

    else if (ucp)
      {
      uint32_t ch;
      fc = UCHAR21INC(Feptr);
      ch = Fecode[1];
      Fecode += 2;

      if (ch == fc)
        {
        RRETURN(MATCH_NOMATCH);  /* Caseful match */
        }
      else if (Fop == OP_NOTI)   /* If caseless */
        {
        if (ch > 127)
          ch = UCD_OTHERCASE(ch);
        else
          ch = (mb->fcc)[ch];
        if (ch == fc) RRETURN(MATCH_NOMATCH);
        }
      }

    else
#endif  /* SUPPORT_UNICODE */

    /* Neither UTF nor UCP is set */

      {
      uint32_t ch = Fecode[1];
      fc = UCHAR21INC(Feptr);
      if (ch == fc || (Fop == OP_NOTI && TABLE_GET(ch, mb->fcc, ch) == fc))
        RRETURN(MATCH_NOMATCH);
      Fecode += 2;
      }
    break;


    /* ===================================================================== */
    /* Match a single character repeatedly. */

#define Loclength    F->temp_size
#define Lstart_eptr  F->temp_sptr[0]
#define Lcharptr     F->temp_sptr[1]
#define Lmin         F->temp_32[0]
#define Lmax         F->temp_32[1]
#define Lc           F->temp_32[2]
#define Loc          F->temp_32[3]

    case OP_EXACT:
    case OP_EXACTI:
    Lmin = Lmax = GET2(Fecode, 1);
    Fecode += 1 + IMM2_SIZE;
    goto REPEATCHAR;

    case OP_POSUPTO:
    case OP_POSUPTOI:
    reptype = REPTYPE_POS;
    Lmin = 0;
    Lmax = GET2(Fecode, 1);
    Fecode += 1 + IMM2_SIZE;
    goto REPEATCHAR;

    case OP_UPTO:
    case OP_UPTOI:
    reptype = REPTYPE_MAX;
    Lmin = 0;
    Lmax = GET2(Fecode, 1);
    Fecode += 1 + IMM2_SIZE;
    goto REPEATCHAR;

    case OP_MINUPTO:
    case OP_MINUPTOI:
    reptype = REPTYPE_MIN;
    Lmin = 0;
    Lmax = GET2(Fecode, 1);
    Fecode += 1 + IMM2_SIZE;
    goto REPEATCHAR;

    case OP_POSSTAR:
    case OP_POSSTARI:
    reptype = REPTYPE_POS;
    Lmin = 0;
    Lmax = UINT32_MAX;
    Fecode++;
    goto REPEATCHAR;

    case OP_POSPLUS:
    case OP_POSPLUSI:
    reptype = REPTYPE_POS;
    Lmin = 1;
    Lmax = UINT32_MAX;
    Fecode++;
    goto REPEATCHAR;

    case OP_POSQUERY:
    case OP_POSQUERYI:
    reptype = REPTYPE_POS;
    Lmin = 0;
    Lmax = 1;
    Fecode++;
    goto REPEATCHAR;

    case OP_STAR:
    case OP_STARI:
    case OP_MINSTAR:
    case OP_MINSTARI:
    case OP_PLUS:
    case OP_PLUSI:
    case OP_MINPLUS:
    case OP_MINPLUSI:
    case OP_QUERY:
    case OP_QUERYI:
    case OP_MINQUERY:
    case OP_MINQUERYI:
    fc = *Fecode++ - ((Fop < OP_STARI)? OP_STAR : OP_STARI);
    Lmin = rep_min[fc];
    Lmax = rep_max[fc];
    reptype = rep_typ[fc];

    /* Common code for all repeated single-character matches. We first check
    for the minimum number of characters. If the minimum equals the maximum, we
    are done. Otherwise, if minimizing, check the rest of the pattern for a
    match; if there isn't one, advance up to the maximum, one character at a
    time.

    If maximizing, advance up to the maximum number of matching characters,
    until Feptr is past the end of the maximum run. If possessive, we are
    then done (no backing up). Otherwise, match at this position; anything
    other than no match is immediately returned. For nomatch, back up one
    character, unless we are matching \R and the last thing matched was
    \r\n, in which case, back up two code units until we reach the first
    optional character position.

    The various UTF/non-UTF and caseful/caseless cases are handled separately,
    for speed. */

    REPEATCHAR:
#ifdef SUPPORT_UNICODE
    if (utf)
      {
      Flength = 1;
      Lcharptr = Fecode;
      GETCHARLEN(fc, Fecode, Flength);
      Fecode += Flength;

      /* Handle multi-code-unit character matching, caseful and caseless. */

      if (Flength > 1)
        {
        uint32_t othercase;

        if (Fop >= OP_STARI &&     /* Caseless */
            (othercase = UCD_OTHERCASE(fc)) != fc)
          Loclength = PRIV(ord2utf)(othercase, Foccu);
        else Loclength = 0;

        for (i = 1; i <= Lmin; i++)
          {
          if (Feptr <= mb->end_subject - Flength &&
            memcmp(Feptr, Lcharptr, CU2BYTES(Flength)) == 0) Feptr += Flength;
          else if (Loclength > 0 &&
                   Feptr <= mb->end_subject - Loclength &&
                   memcmp(Feptr, Foccu, CU2BYTES(Loclength)) == 0)
            Feptr += Loclength;
          else
            {
            CHECK_PARTIAL();
            RRETURN(MATCH_NOMATCH);
            }
          }

        if (Lmin == Lmax) continue;

        if (reptype == REPTYPE_MIN)
          {
          for (;;)
            {
            RMATCH(Fecode, RM202);
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
            if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH);
            if (Feptr <= mb->end_subject - Flength &&
              memcmp(Feptr, Lcharptr, CU2BYTES(Flength)) == 0) Feptr += Flength;
            else if (Loclength > 0 &&
                     Feptr <= mb->end_subject - Loclength &&
                     memcmp(Feptr, Foccu, CU2BYTES(Loclength)) == 0)
              Feptr += Loclength;
            else
              {
              CHECK_PARTIAL();
              RRETURN(MATCH_NOMATCH);
              }
            }
          PCRE2_UNREACHABLE(); /* Control never reaches here */
          }

        else  /* Maximize */
          {
          Lstart_eptr = Feptr;
          for (i = Lmin; i < Lmax; i++)
            {
            if (Feptr <= mb->end_subject - Flength &&
                memcmp(Feptr, Lcharptr, CU2BYTES(Flength)) == 0)
              Feptr += Flength;
            else if (Loclength > 0 &&
                     Feptr <= mb->end_subject - Loclength &&
                     memcmp(Feptr, Foccu, CU2BYTES(Loclength)) == 0)
              Feptr += Loclength;
            else
              {
              CHECK_PARTIAL();
              break;
              }
            }

          /* After \C in UTF mode, Lstart_eptr might be in the middle of a
          Unicode character. Use <= Lstart_eptr to ensure backtracking doesn't
          go too far. */

          if (reptype != REPTYPE_POS) for(;;)
            {
            if (Feptr <= Lstart_eptr) break;
            RMATCH(Fecode, RM203);
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
            Feptr--;
            BACKCHAR(Feptr);
            }
          }
        break;   /* End of repeated wide character handling */
        }

      /* Length of UTF character is 1. Put it into the preserved variable and
      fall through to the non-UTF code. */

      Lc = fc;
      }
    else
#endif  /* SUPPORT_UNICODE */

    /* When not in UTF mode, load a single-code-unit character. Then proceed as
    above, using Unicode casing if either UTF or UCP is set. */

    Lc = *Fecode++;

    /* Caseless comparison */

    if (Fop >= OP_STARI)
      {
#if PCRE2_CODE_UNIT_WIDTH == 8
#ifdef SUPPORT_UNICODE
      if (ucp && !utf && Lc > 127) Loc = UCD_OTHERCASE(Lc);
      else
#endif  /* SUPPORT_UNICODE */
      /* Lc will be < 128 in UTF-8 mode. */
      Loc = mb->fcc[Lc];
#else /* 16-bit & 32-bit */
#ifdef SUPPORT_UNICODE
      if ((utf || ucp) && Lc > 127) Loc = UCD_OTHERCASE(Lc);
      else
#endif  /* SUPPORT_UNICODE */
      Loc = TABLE_GET(Lc, mb->fcc, Lc);
#endif  /* PCRE2_CODE_UNIT_WIDTH == 8 */

      for (i = 1; i <= Lmin; i++)
        {
        uint32_t cc;                 /* Faster than PCRE2_UCHAR */
        if (Feptr >= mb->end_subject)
          {
          SCHECK_PARTIAL();
          RRETURN(MATCH_NOMATCH);
          }
        cc = UCHAR21TEST(Feptr);
        if (Lc != cc && Loc != cc) RRETURN(MATCH_NOMATCH);
        Feptr++;
        }
      if (Lmin == Lmax) continue;

      if (reptype == REPTYPE_MIN)
        {
        for (;;)
          {
          uint32_t cc;               /* Faster than PCRE2_UCHAR */
          RMATCH(Fecode, RM25);
          if (rrc != MATCH_NOMATCH) RRETURN(rrc);
          if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH);
          if (Feptr >= mb->end_subject)
            {
            SCHECK_PARTIAL();
            RRETURN(MATCH_NOMATCH);
            }
          cc = UCHAR21TEST(Feptr);
          if (Lc != cc && Loc != cc) RRETURN(MATCH_NOMATCH);
          Feptr++;
          }
        PCRE2_UNREACHABLE(); /* Control never reaches here */
        }

      else  /* Maximize */
        {
        Lstart_eptr = Feptr;
        for (i = Lmin; i < Lmax; i++)
          {
          uint32_t cc;               /* Faster than PCRE2_UCHAR */
          if (Feptr >= mb->end_subject)
            {
            SCHECK_PARTIAL();
            break;
            }
          cc = UCHAR21TEST(Feptr);
          if (Lc != cc && Loc != cc) break;
          Feptr++;
          }
        if (reptype != REPTYPE_POS) for (;;)
          {
          if (Feptr == Lstart_eptr) break;
          RMATCH(Fecode, RM26);
          Feptr--;
          if (rrc != MATCH_NOMATCH) RRETURN(rrc);
          }
        }
      }

    /* Caseful comparisons (includes all multi-byte characters) */

    else
      {
      for (i = 1; i <= Lmin; i++)
        {
        if (Feptr >= mb->end_subject)
          {
          SCHECK_PARTIAL();
          RRETURN(MATCH_NOMATCH);
          }
        if (Lc != UCHAR21INCTEST(Feptr)) RRETURN(MATCH_NOMATCH);
        }

      if (Lmin == Lmax) continue;

      if (reptype == REPTYPE_MIN)
        {
        for (;;)
          {
          RMATCH(Fecode, RM27);
          if (rrc != MATCH_NOMATCH) RRETURN(rrc);
          if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH);
          if (Feptr >= mb->end_subject)
            {
            SCHECK_PARTIAL();
            RRETURN(MATCH_NOMATCH);
            }
          if (Lc != UCHAR21INCTEST(Feptr)) RRETURN(MATCH_NOMATCH);
          }
        PCRE2_UNREACHABLE(); /* Control never reaches here */
        }
      else  /* Maximize */
        {
        Lstart_eptr = Feptr;
        for (i = Lmin; i < Lmax; i++)
          {
          if (Feptr >= mb->end_subject)
            {
            SCHECK_PARTIAL();
            break;
            }

          if (Lc != UCHAR21TEST(Feptr)) break;
          Feptr++;
          }

        if (reptype != REPTYPE_POS) for (;;)
          {
          if (Feptr <= Lstart_eptr) break;
          RMATCH(Fecode, RM28);
          Feptr--;
          if (rrc != MATCH_NOMATCH) RRETURN(rrc);
          }
        }
      }
    break;

#undef Loclength
#undef Lstart_eptr
#undef Lcharptr
#undef Lmin
#undef Lmax
#undef Lc
#undef Loc


    /* ===================================================================== */
    /* Match a negated single one-byte character repeatedly. This is almost a
    repeat of the code for a repeated single character, but I haven't found a
    nice way of commoning these up that doesn't require a test of the
    positive/negative option for each character match. Maybe that wouldn't add
    very much to the time taken, but character matching *is* what this is all
    about... */

#define Lstart_eptr  F->temp_sptr[0]
#define Lmin         F->temp_32[0]
#define Lmax         F->temp_32[1]
#define Lc           F->temp_32[2]
#define Loc          F->temp_32[3]

    case OP_NOTEXACT:
    case OP_NOTEXACTI:
    Lmin = Lmax = GET2(Fecode, 1);
    Fecode += 1 + IMM2_SIZE;
    goto REPEATNOTCHAR;

    case OP_NOTUPTO:
    case OP_NOTUPTOI:
    Lmin = 0;
    Lmax = GET2(Fecode, 1);
    reptype = REPTYPE_MAX;
    Fecode += 1 + IMM2_SIZE;
    goto REPEATNOTCHAR;

    case OP_NOTMINUPTO:
    case OP_NOTMINUPTOI:
    Lmin = 0;
    Lmax = GET2(Fecode, 1);
    reptype = REPTYPE_MIN;
    Fecode += 1 + IMM2_SIZE;
    goto REPEATNOTCHAR;

    case OP_NOTPOSSTAR:
    case OP_NOTPOSSTARI:
    reptype = REPTYPE_POS;
    Lmin = 0;
    Lmax = UINT32_MAX;
    Fecode++;
    goto REPEATNOTCHAR;

    case OP_NOTPOSPLUS:
    case OP_NOTPOSPLUSI:
    reptype = REPTYPE_POS;
    Lmin = 1;
    Lmax = UINT32_MAX;
    Fecode++;
    goto REPEATNOTCHAR;

    case OP_NOTPOSQUERY:
    case OP_NOTPOSQUERYI:
    reptype = REPTYPE_POS;
    Lmin = 0;
    Lmax = 1;
    Fecode++;
    goto REPEATNOTCHAR;

    case OP_NOTPOSUPTO:
    case OP_NOTPOSUPTOI:
    reptype = REPTYPE_POS;
    Lmin = 0;
    Lmax = GET2(Fecode, 1);
    Fecode += 1 + IMM2_SIZE;
    goto REPEATNOTCHAR;

    case OP_NOTSTAR:
    case OP_NOTSTARI:
    case OP_NOTMINSTAR:
    case OP_NOTMINSTARI:
    case OP_NOTPLUS:
    case OP_NOTPLUSI:
    case OP_NOTMINPLUS:
    case OP_NOTMINPLUSI:
    case OP_NOTQUERY:
    case OP_NOTQUERYI:
    case OP_NOTMINQUERY:
    case OP_NOTMINQUERYI:
    fc = *Fecode++ - ((Fop >= OP_NOTSTARI)? OP_NOTSTARI: OP_NOTSTAR);
    Lmin = rep_min[fc];
    Lmax = rep_max[fc];
    reptype = rep_typ[fc];

    /* Common code for all repeated single-character non-matches. */

    REPEATNOTCHAR:
    GETCHARINCTEST(Lc, Fecode);

    /* The code is duplicated for the caseless and caseful cases, for speed,
    since matching characters is likely to be quite common. First, ensure the
    minimum number of matches are present. If Lmin = Lmax, we are done.
    Otherwise, if minimizing, keep trying the rest of the expression and
    advancing one matching character if failing, up to the maximum.
    Alternatively, if maximizing, find the maximum number of characters and
    work backwards. */

    if (Fop >= OP_NOTSTARI)     /* Caseless */
      {
#ifdef SUPPORT_UNICODE
      if ((utf || ucp) && Lc > 127)
        Loc = UCD_OTHERCASE(Lc);
      else
#endif /* SUPPORT_UNICODE */

      Loc = TABLE_GET(Lc, mb->fcc, Lc);  /* Other case from table */

#ifdef SUPPORT_UNICODE
      if (utf)
        {
        uint32_t d;
        for (i = 1; i <= Lmin; i++)
          {
          if (Feptr >= mb->end_subject)
            {
            SCHECK_PARTIAL();
            RRETURN(MATCH_NOMATCH);
            }
          GETCHARINC(d, Feptr);
          if (Lc == d || Loc == d) RRETURN(MATCH_NOMATCH);
          }
        }
      else
#endif  /* SUPPORT_UNICODE */

      /* Not UTF mode */
        {
        for (i = 1; i <= Lmin; i++)
          {
          if (Feptr >= mb->end_subject)
            {
            SCHECK_PARTIAL();
            RRETURN(MATCH_NOMATCH);
            }
          if (Lc == *Feptr || Loc == *Feptr) RRETURN(MATCH_NOMATCH);
          Feptr++;
          }
        }

      if (Lmin == Lmax) continue;  /* Finished for exact count */

      if (reptype == REPTYPE_MIN)
        {
#ifdef SUPPORT_UNICODE
        if (utf)
          {
          uint32_t d;
          for (;;)
            {
            RMATCH(Fecode, RM204);
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
            if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH);
            if (Feptr >= mb->end_subject)
              {
              SCHECK_PARTIAL();
              RRETURN(MATCH_NOMATCH);
              }
            GETCHARINC(d, Feptr);
            if (Lc == d || Loc == d) RRETURN(MATCH_NOMATCH);
            }
          }
        else
#endif  /*SUPPORT_UNICODE */

        /* Not UTF mode */
          {
          for (;;)
            {
            RMATCH(Fecode, RM29);
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
            if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH);
            if (Feptr >= mb->end_subject)
              {
              SCHECK_PARTIAL();
              RRETURN(MATCH_NOMATCH);
              }
            if (Lc == *Feptr || Loc == *Feptr) RRETURN(MATCH_NOMATCH);
            Feptr++;
            }
          }
        PCRE2_UNREACHABLE(); /* Control never reaches here */
        }

      /* Maximize case */

      else
        {
        Lstart_eptr = Feptr;

#ifdef SUPPORT_UNICODE
        if (utf)
          {
          uint32_t d;
          for (i = Lmin; i < Lmax; i++)
            {
            int len = 1;
            if (Feptr >= mb->end_subject)
              {
              SCHECK_PARTIAL();
              break;
              }
            GETCHARLEN(d, Feptr, len);
            if (Lc == d || Loc == d) break;
            Feptr += len;
            }

          /* After \C in UTF mode, Lstart_eptr might be in the middle of a
          Unicode character. Use <= Lstart_eptr to ensure backtracking doesn't
          go too far. */

          if (reptype != REPTYPE_POS) for(;;)
            {
            if (Feptr <= Lstart_eptr) break;
            RMATCH(Fecode, RM205);
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
            Feptr--;
            BACKCHAR(Feptr);
            }
          }
        else
#endif  /* SUPPORT_UNICODE */

        /* Not UTF mode */
          {
          for (i = Lmin; i < Lmax; i++)
            {
            if (Feptr >= mb->end_subject)
              {
              SCHECK_PARTIAL();
              break;
              }
            if (Lc == *Feptr || Loc == *Feptr) break;
            Feptr++;
            }
          if (reptype != REPTYPE_POS) for (;;)
            {
            if (Feptr == Lstart_eptr) break;
            RMATCH(Fecode, RM30);
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
            Feptr--;
            }
          }
        }
      }

    /* Caseful comparisons */

    else
      {
#ifdef SUPPORT_UNICODE
      if (utf)
        {
        uint32_t d;
        for (i = 1; i <= Lmin; i++)
          {
          if (Feptr >= mb->end_subject)
            {
            SCHECK_PARTIAL();
            RRETURN(MATCH_NOMATCH);
            }
          GETCHARINC(d, Feptr);
          if (Lc == d) RRETURN(MATCH_NOMATCH);
          }
        }
      else
#endif
      /* Not UTF mode */
        {
        for (i = 1; i <= Lmin; i++)
          {
          if (Feptr >= mb->end_subject)
            {
            SCHECK_PARTIAL();
            RRETURN(MATCH_NOMATCH);
            }
          if (Lc == *Feptr++) RRETURN(MATCH_NOMATCH);
          }
        }

      if (Lmin == Lmax) continue;

      if (reptype == REPTYPE_MIN)
        {
#ifdef SUPPORT_UNICODE
        if (utf)
          {
          uint32_t d;
          for (;;)
            {
            RMATCH(Fecode, RM206);
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
            if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH);
            if (Feptr >= mb->end_subject)
              {
              SCHECK_PARTIAL();
              RRETURN(MATCH_NOMATCH);
              }
            GETCHARINC(d, Feptr);
            if (Lc == d) RRETURN(MATCH_NOMATCH);
            }
          }
        else
#endif
        /* Not UTF mode */
          {
          for (;;)
            {
            RMATCH(Fecode, RM31);
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
            if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH);
            if (Feptr >= mb->end_subject)
              {
              SCHECK_PARTIAL();
              RRETURN(MATCH_NOMATCH);
              }
            if (Lc == *Feptr++) RRETURN(MATCH_NOMATCH);
            }
          }
        PCRE2_UNREACHABLE(); /* Control never reaches here */
        }

      /* Maximize case */

      else
        {
        Lstart_eptr = Feptr;

#ifdef SUPPORT_UNICODE
        if (utf)
          {
          uint32_t d;
          for (i = Lmin; i < Lmax; i++)
            {
            int len = 1;
            if (Feptr >= mb->end_subject)
              {
              SCHECK_PARTIAL();
              break;
              }
            GETCHARLEN(d, Feptr, len);
            if (Lc == d) break;
            Feptr += len;
            }

          /* After \C in UTF mode, Lstart_eptr might be in the middle of a
          Unicode character. Use <= Lstart_eptr to ensure backtracking doesn't
          go too far. */

          if (reptype != REPTYPE_POS) for(;;)
            {
            if (Feptr <= Lstart_eptr) break;
            RMATCH(Fecode, RM207);
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
            Feptr--;
            BACKCHAR(Feptr);
            }
          }
        else
#endif
        /* Not UTF mode */
          {
          for (i = Lmin; i < Lmax; i++)
            {
            if (Feptr >= mb->end_subject)
              {
              SCHECK_PARTIAL();
              break;
              }
            if (Lc == *Feptr) break;
            Feptr++;
            }
          if (reptype != REPTYPE_POS) for (;;)
            {
            if (Feptr == Lstart_eptr) break;
            RMATCH(Fecode, RM32);
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
            Feptr--;
            }
          }
        }
      }
    break;

#undef Lstart_eptr
#undef Lmin
#undef Lmax
#undef Lc
#undef Loc


    /* ===================================================================== */
    /* Match a bit-mapped character class, possibly repeatedly. These opcodes
    are used when all the characters in the class have values in the range
    0-255, and either the matching is caseful, or the characters are in the
    range 0-127 when UTF processing is enabled. The only difference between
    OP_CLASS and OP_NCLASS occurs when a data character outside the range is
    encountered. */

#define Lmin               F->temp_32[0]
#define Lmax               F->temp_32[1]
#define Lstart_eptr        F->temp_sptr[0]
#define Lbyte_map_address  F->temp_sptr[1]
#define Lbyte_map          ((const unsigned char *)Lbyte_map_address)

    case OP_NCLASS:
    case OP_CLASS:
      {
      Lbyte_map_address = Fecode + 1;           /* Save for matching */
      Fecode += 1 + (32 / sizeof(PCRE2_UCHAR)); /* Advance past the item */

      /* Look past the end of the item to see if there is repeat information
      following. Then obey similar code to character type repeats. */

      switch (*Fecode)
        {
        case OP_CRSTAR:
        case OP_CRMINSTAR:
        case OP_CRPLUS:
        case OP_CRMINPLUS:
        case OP_CRQUERY:
        case OP_CRMINQUERY:
        case OP_CRPOSSTAR:
        case OP_CRPOSPLUS:
        case OP_CRPOSQUERY:
        fc = *Fecode++ - OP_CRSTAR;
        Lmin = rep_min[fc];
        Lmax = rep_max[fc];
        reptype = rep_typ[fc];
        break;

        case OP_CRRANGE:
        case OP_CRMINRANGE:
        case OP_CRPOSRANGE:
        Lmin = GET2(Fecode, 1);
        Lmax = GET2(Fecode, 1 + IMM2_SIZE);
        if (Lmax == 0) Lmax = UINT32_MAX;       /* Max 0 => infinity */
        reptype = rep_typ[*Fecode - OP_CRSTAR];
        Fecode += 1 + 2 * IMM2_SIZE;
        break;

        default:               /* No repeat follows */
        Lmin = Lmax = 1;
        break;
        }

      /* First, ensure the minimum number of matches are present. */

#ifdef SUPPORT_UNICODE
      if (utf)
        {
        for (i = 1; i <= Lmin; i++)
          {
          if (Feptr >= mb->end_subject)
            {
            SCHECK_PARTIAL();
            RRETURN(MATCH_NOMATCH);
            }
          GETCHARINC(fc, Feptr);
          if (fc > 255)
            {
            if (Fop == OP_CLASS) RRETURN(MATCH_NOMATCH);
            }
          else
            if ((Lbyte_map[fc/8] & (1u << (fc&7))) == 0) RRETURN(MATCH_NOMATCH);
          }
        }
      else
#endif
      /* Not UTF mode */
        {
        for (i = 1; i <= Lmin; i++)
          {
          if (Feptr >= mb->end_subject)
            {
            SCHECK_PARTIAL();
            RRETURN(MATCH_NOMATCH);
            }
          fc = *Feptr++;
#if PCRE2_CODE_UNIT_WIDTH != 8
          if (fc > 255)
            {
            if (Fop == OP_CLASS) RRETURN(MATCH_NOMATCH);
            }
          else
#endif
          if ((Lbyte_map[fc/8] & (1u << (fc&7))) == 0) RRETURN(MATCH_NOMATCH);
          }
        }

      /* If Lmax == Lmin we are done. Continue with main loop. */

      if (Lmin == Lmax) continue;

      /* If minimizing, keep testing the rest of the expression and advancing
      the pointer while it matches the class. */

      if (reptype == REPTYPE_MIN)
        {
#ifdef SUPPORT_UNICODE
        if (utf)
          {
          for (;;)
            {
            RMATCH(Fecode, RM200);
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
            if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH);
            if (Feptr >= mb->end_subject)
              {
              SCHECK_PARTIAL();
              RRETURN(MATCH_NOMATCH);
              }
            GETCHARINC(fc, Feptr);
            if (fc > 255)
              {
              if (Fop == OP_CLASS) RRETURN(MATCH_NOMATCH);
              }
            else
              if ((Lbyte_map[fc/8] & (1u << (fc&7))) == 0) RRETURN(MATCH_NOMATCH);
            }
          }
        else
#endif
        /* Not UTF mode */
          {
          for (;;)
            {
            RMATCH(Fecode, RM23);
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
            if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH);
            if (Feptr >= mb->end_subject)
              {
              SCHECK_PARTIAL();
              RRETURN(MATCH_NOMATCH);
              }
            fc = *Feptr++;
#if PCRE2_CODE_UNIT_WIDTH != 8
            if (fc > 255)
              {
              if (Fop == OP_CLASS) RRETURN(MATCH_NOMATCH);
              }
            else
#endif
            if ((Lbyte_map[fc/8] & (1u << (fc&7))) == 0) RRETURN(MATCH_NOMATCH);
            }
          }
        PCRE2_UNREACHABLE(); /* Control never reaches here */
        }

      /* If maximizing, find the longest possible run, then work backwards. */

      else
        {
        Lstart_eptr = Feptr;

#ifdef SUPPORT_UNICODE
        if (utf)
          {
          for (i = Lmin; i < Lmax; i++)
            {
            int len = 1;
            if (Feptr >= mb->end_subject)
              {
              SCHECK_PARTIAL();
              break;
              }
            GETCHARLEN(fc, Feptr, len);
            if (fc > 255)
              {
              if (Fop == OP_CLASS) break;
              }
            else
              if ((Lbyte_map[fc/8] & (1u << (fc&7))) == 0) break;
            Feptr += len;
            }

          if (reptype == REPTYPE_POS) continue;    /* No backtracking */

          /* After \C in UTF mode, Lstart_eptr might be in the middle of a
          Unicode character. Use <= Lstart_eptr to ensure backtracking doesn't
          go too far. */

          for (;;)
            {
            RMATCH(Fecode, RM201);
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
            if (Feptr-- <= Lstart_eptr) break;  /* Tried at original position */
            BACKCHAR(Feptr);
            }
          }
        else
#endif
          /* Not UTF mode */
          {
          for (i = Lmin; i < Lmax; i++)
            {
            if (Feptr >= mb->end_subject)
              {
              SCHECK_PARTIAL();
              break;
              }
            fc = *Feptr;
#if PCRE2_CODE_UNIT_WIDTH != 8
            if (fc > 255)
              {
              if (Fop == OP_CLASS) break;
              }
            else
#endif
            if ((Lbyte_map[fc/8] & (1u << (fc&7))) == 0) break;
            Feptr++;
            }

          if (reptype == REPTYPE_POS) continue;    /* No backtracking */

          while (Feptr >= Lstart_eptr)
            {
            RMATCH(Fecode, RM24);
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
            Feptr--;
            }
          }

        RRETURN(MATCH_NOMATCH);
        }
      }

    PCRE2_UNREACHABLE(); /* Control never reaches here */

#undef Lbyte_map_address
#undef Lbyte_map
#undef Lstart_eptr
#undef Lmin
#undef Lmax


    /* ===================================================================== */
    /* Match an extended character class. In the 8-bit library, this opcode is
    encountered only when UTF-8 mode mode is supported. In the 16-bit and
    32-bit libraries, codepoints greater than 255 may be encountered even when
    UTF is not supported. */

#define Lstart_eptr  F->temp_sptr[0]
#define Lxclass_data F->temp_sptr[1]
#define Lmin         F->temp_32[0]
#define Lmax         F->temp_32[1]

#ifdef SUPPORT_WIDE_CHARS
    case OP_XCLASS:
      {
      Lxclass_data = Fecode + 1 + LINK_SIZE;  /* Save for matching */
      Fecode += GET(Fecode, 1);               /* Advance past the item */

      switch (*Fecode)
        {
        case OP_CRSTAR:
        case OP_CRMINSTAR:
        case OP_CRPLUS:
        case OP_CRMINPLUS:
        case OP_CRQUERY:
        case OP_CRMINQUERY:
        case OP_CRPOSSTAR:
        case OP_CRPOSPLUS:
        case OP_CRPOSQUERY:
        fc = *Fecode++ - OP_CRSTAR;
        Lmin = rep_min[fc];
        Lmax = rep_max[fc];
        reptype = rep_typ[fc];
        break;

        case OP_CRRANGE:
        case OP_CRMINRANGE:
        case OP_CRPOSRANGE:
        Lmin = GET2(Fecode, 1);
        Lmax = GET2(Fecode, 1 + IMM2_SIZE);
        if (Lmax == 0) Lmax = UINT32_MAX;  /* Max 0 => infinity */
        reptype = rep_typ[*Fecode - OP_CRSTAR];
        Fecode += 1 + 2 * IMM2_SIZE;
        break;

        default:               /* No repeat follows */
        Lmin = Lmax = 1;
        break;
        }

      /* First, ensure the minimum number of matches are present. */

      for (i = 1; i <= Lmin; i++)
        {
        if (Feptr >= mb->end_subject)
          {
          SCHECK_PARTIAL();
          RRETURN(MATCH_NOMATCH);
          }
        GETCHARINCTEST(fc, Feptr);
        if (!PRIV(xclass)(fc, Lxclass_data,
            (const uint8_t*)mb->start_code, utf))
          RRETURN(MATCH_NOMATCH);
        }

      /* If Lmax == Lmin we can just continue with the main loop. */

      if (Lmin == Lmax) continue;

      /* If minimizing, keep testing the rest of the expression and advancing
      the pointer while it matches the class. */

      if (reptype == REPTYPE_MIN)
        {
        for (;;)
          {
          RMATCH(Fecode, RM100);
          if (rrc != MATCH_NOMATCH) RRETURN(rrc);
          if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH);
          if (Feptr >= mb->end_subject)
            {
            SCHECK_PARTIAL();
            RRETURN(MATCH_NOMATCH);
            }
          GETCHARINCTEST(fc, Feptr);
          if (!PRIV(xclass)(fc, Lxclass_data,
              (const uint8_t*)mb->start_code, utf))
            RRETURN(MATCH_NOMATCH);
          }
        PCRE2_UNREACHABLE(); /* Control never reaches here */
        }

      /* If maximizing, find the longest possible run, then work backwards. */

      else
        {
        Lstart_eptr = Feptr;
        for (i = Lmin; i < Lmax; i++)
          {
          int len = 1;
          if (Feptr >= mb->end_subject)
            {
            SCHECK_PARTIAL();
            break;
            }
#ifdef SUPPORT_UNICODE
          GETCHARLENTEST(fc, Feptr, len);
#else
          fc = *Feptr;
#endif
          if (!PRIV(xclass)(fc, Lxclass_data,
              (const uint8_t*)mb->start_code, utf)) break;
          Feptr += len;
          }

        if (reptype == REPTYPE_POS) continue;    /* No backtracking */

        /* After \C in UTF mode, Lstart_eptr might be in the middle of a
        Unicode character. Use <= Lstart_eptr to ensure backtracking doesn't
        go too far. */

        for(;;)
          {
          RMATCH(Fecode, RM101);
          if (rrc != MATCH_NOMATCH) RRETURN(rrc);
          if (Feptr-- <= Lstart_eptr) break;  /* Tried at original position */
#ifdef SUPPORT_UNICODE
          if (utf) BACKCHAR(Feptr);
#endif
          }
        RRETURN(MATCH_NOMATCH);
        }

      PCRE2_UNREACHABLE(); /* Control never reaches here */
      }
#endif  /* SUPPORT_WIDE_CHARS: end of XCLASS */

#undef Lstart_eptr
#undef Lxclass_data
#undef Lmin
#undef Lmax


    /* ===================================================================== */
    /* Match a complex, set-based character class. This opcodes are used when
    there is complex nesting or logical operations within the character
    class. */

#define Lstart_eptr  F->temp_sptr[0]
#define Leclass_data F->temp_sptr[1]
#define Leclass_len  F->temp_size
#define Lmin         F->temp_32[0]
#define Lmax         F->temp_32[1]

#ifdef SUPPORT_WIDE_CHARS
    case OP_ECLASS:
      {
      Leclass_data = Fecode + 1 + LINK_SIZE;  /* Save for matching */
      Fecode += GET(Fecode, 1);               /* Advance past the item */
      Leclass_len = (PCRE2_SIZE)(Fecode - Leclass_data);

      switch (*Fecode)
        {
        case OP_CRSTAR:
        case OP_CRMINSTAR:
        case OP_CRPLUS:
        case OP_CRMINPLUS:
        case OP_CRQUERY:
        case OP_CRMINQUERY:
        case OP_CRPOSSTAR:
        case OP_CRPOSPLUS:
        case OP_CRPOSQUERY:
        fc = *Fecode++ - OP_CRSTAR;
        Lmin = rep_min[fc];
        Lmax = rep_max[fc];
        reptype = rep_typ[fc];
        break;

        case OP_CRRANGE:
        case OP_CRMINRANGE:
        case OP_CRPOSRANGE:
        Lmin = GET2(Fecode, 1);
        Lmax = GET2(Fecode, 1 + IMM2_SIZE);
        if (Lmax == 0) Lmax = UINT32_MAX;  /* Max 0 => infinity */
        reptype = rep_typ[*Fecode - OP_CRSTAR];
        Fecode += 1 + 2 * IMM2_SIZE;
        break;

        default:               /* No repeat follows */
        Lmin = Lmax = 1;
        break;
        }

      /* First, ensure the minimum number of matches are present. */

      for (i = 1; i <= Lmin; i++)
        {
        if (Feptr >= mb->end_subject)
          {
          SCHECK_PARTIAL();
          RRETURN(MATCH_NOMATCH);
          }
        GETCHARINCTEST(fc, Feptr);
        if (!PRIV(eclass)(fc, Leclass_data, Leclass_data + Leclass_len,
                          (const uint8_t*)mb->start_code, utf))
          RRETURN(MATCH_NOMATCH);
        }

      /* If Lmax == Lmin we can just continue with the main loop. */

      if (Lmin == Lmax) continue;

      /* If minimizing, keep testing the rest of the expression and advancing
      the pointer while it matches the class. */

      if (reptype == REPTYPE_MIN)
        {
        for (;;)
          {
          RMATCH(Fecode, RM102);
          if (rrc != MATCH_NOMATCH) RRETURN(rrc);
          if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH);
          if (Feptr >= mb->end_subject)
            {
            SCHECK_PARTIAL();
            RRETURN(MATCH_NOMATCH);
            }
          GETCHARINCTEST(fc, Feptr);
          if (!PRIV(eclass)(fc, Leclass_data, Leclass_data + Leclass_len,
                            (const uint8_t*)mb->start_code, utf))
            RRETURN(MATCH_NOMATCH);
          }
        PCRE2_UNREACHABLE(); /* Control never reaches here */
        }

      /* If maximizing, find the longest possible run, then work backwards. */

      else
        {
        Lstart_eptr = Feptr;
        for (i = Lmin; i < Lmax; i++)
          {
          int len = 1;
          if (Feptr >= mb->end_subject)
            {
            SCHECK_PARTIAL();
            break;
            }
#ifdef SUPPORT_UNICODE
          GETCHARLENTEST(fc, Feptr, len);
#else
          fc = *Feptr;
#endif
          if (!PRIV(eclass)(fc, Leclass_data, Leclass_data + Leclass_len,
                            (const uint8_t*)mb->start_code, utf))
            break;
          Feptr += len;
          }

        if (reptype == REPTYPE_POS) continue;    /* No backtracking */

        /* After \C in UTF mode, Lstart_eptr might be in the middle of a
        Unicode character. Use <= Lstart_eptr to ensure backtracking doesn't
        go too far. */

        for(;;)
          {
          RMATCH(Fecode, RM103);
          if (rrc != MATCH_NOMATCH) RRETURN(rrc);
          if (Feptr-- <= Lstart_eptr) break;  /* Tried at original position */
#ifdef SUPPORT_UNICODE
          if (utf) BACKCHAR(Feptr);
#endif
          }
        RRETURN(MATCH_NOMATCH);
        }

      PCRE2_UNREACHABLE(); /* Control never reaches here */
      }
#endif  /* SUPPORT_WIDE_CHARS: end of ECLASS */

#undef Lstart_eptr
#undef Leclass_data
#undef Leclass_len
#undef Lmin
#undef Lmax


    /* ===================================================================== */
    /* Match various character types when PCRE2_UCP is not set. These opcodes
    are not generated when PCRE2_UCP is set - instead appropriate property
    tests are compiled. */

    case OP_NOT_DIGIT:
    if (Feptr >= mb->end_subject)
      {
      SCHECK_PARTIAL();
      RRETURN(MATCH_NOMATCH);
      }
    GETCHARINCTEST(fc, Feptr);
    if (CHMAX_255(fc) && (mb->ctypes[fc] & ctype_digit) != 0)
      RRETURN(MATCH_NOMATCH);
    Fecode++;
    break;

    case OP_DIGIT:
    if (Feptr >= mb->end_subject)
      {
      SCHECK_PARTIAL();
      RRETURN(MATCH_NOMATCH);
      }
    GETCHARINCTEST(fc, Feptr);
    if (!CHMAX_255(fc) || (mb->ctypes[fc] & ctype_digit) == 0)
      RRETURN(MATCH_NOMATCH);
    Fecode++;
    break;

    case OP_NOT_WHITESPACE:
    if (Feptr >= mb->end_subject)
      {
      SCHECK_PARTIAL();
      RRETURN(MATCH_NOMATCH);
      }
    GETCHARINCTEST(fc, Feptr);
    if (CHMAX_255(fc) && (mb->ctypes[fc] & ctype_space) != 0)
      RRETURN(MATCH_NOMATCH);
    Fecode++;
    break;

    case OP_WHITESPACE:
    if (Feptr >= mb->end_subject)
      {
      SCHECK_PARTIAL();
      RRETURN(MATCH_NOMATCH);
      }
    GETCHARINCTEST(fc, Feptr);
    if (!CHMAX_255(fc) || (mb->ctypes[fc] & ctype_space) == 0)
      RRETURN(MATCH_NOMATCH);
    Fecode++;
    break;

    case OP_NOT_WORDCHAR:
    if (Feptr >= mb->end_subject)
      {
      SCHECK_PARTIAL();
      RRETURN(MATCH_NOMATCH);
      }
    GETCHARINCTEST(fc, Feptr);
    if (CHMAX_255(fc) && (mb->ctypes[fc] & ctype_word) != 0)
      RRETURN(MATCH_NOMATCH);
    Fecode++;
    break;

    case OP_WORDCHAR:
    if (Feptr >= mb->end_subject)
      {
      SCHECK_PARTIAL();
      RRETURN(MATCH_NOMATCH);
      }
    GETCHARINCTEST(fc, Feptr);
    if (!CHMAX_255(fc) || (mb->ctypes[fc] & ctype_word) == 0)
      RRETURN(MATCH_NOMATCH);
    Fecode++;
    break;

    case OP_ANYNL:
    if (Feptr >= mb->end_subject)
      {
      SCHECK_PARTIAL();
      RRETURN(MATCH_NOMATCH);
      }
    GETCHARINCTEST(fc, Feptr);
    switch(fc)
      {
      default: RRETURN(MATCH_NOMATCH);

      case CHAR_CR:
      if (Feptr >= mb->end_subject)
        {
        SCHECK_PARTIAL();
        }
      else if (UCHAR21TEST(Feptr) == CHAR_LF) Feptr++;
      break;

      case CHAR_LF:
      break;

      case CHAR_VT:
      case CHAR_FF:
      case CHAR_NEL:
#ifndef EBCDIC
      case 0x2028:
      case 0x2029:
#endif  /* Not EBCDIC */
      if (mb->bsr_convention == PCRE2_BSR_ANYCRLF) RRETURN(MATCH_NOMATCH);
      break;
      }
    Fecode++;
    break;

    case OP_NOT_HSPACE:
    if (Feptr >= mb->end_subject)
      {
      SCHECK_PARTIAL();
      RRETURN(MATCH_NOMATCH);
      }
    GETCHARINCTEST(fc, Feptr);
    switch(fc)
      {
      HSPACE_CASES: RRETURN(MATCH_NOMATCH);  /* Byte and multibyte cases */
      default: break;
      }
    Fecode++;
    break;

    case OP_HSPACE:
    if (Feptr >= mb->end_subject)
      {
      SCHECK_PARTIAL();
      RRETURN(MATCH_NOMATCH);
      }
    GETCHARINCTEST(fc, Feptr);
    switch(fc)
      {
      HSPACE_CASES: break;  /* Byte and multibyte cases */
      default: RRETURN(MATCH_NOMATCH);
      }
    Fecode++;
    break;

    case OP_NOT_VSPACE:
    if (Feptr >= mb->end_subject)
      {
      SCHECK_PARTIAL();
      RRETURN(MATCH_NOMATCH);
      }
    GETCHARINCTEST(fc, Feptr);
    switch(fc)
      {
      VSPACE_CASES: RRETURN(MATCH_NOMATCH);
      default: break;
      }
    Fecode++;
    break;

    case OP_VSPACE:
    if (Feptr >= mb->end_subject)
      {
      SCHECK_PARTIAL();
      RRETURN(MATCH_NOMATCH);
      }
    GETCHARINCTEST(fc, Feptr);
    switch(fc)
      {
      VSPACE_CASES: break;
      default: RRETURN(MATCH_NOMATCH);
      }
    Fecode++;
    break;


#ifdef SUPPORT_UNICODE

    /* ===================================================================== */
    /* Check the next character by Unicode property. We will get here only
    if the support is in the binary; otherwise a compile-time error occurs. */

    case OP_PROP:
    case OP_NOTPROP:
    if (Feptr >= mb->end_subject)
      {
      SCHECK_PARTIAL();
      RRETURN(MATCH_NOMATCH);
      }
    GETCHARINCTEST(fc, Feptr);
      {
      const uint32_t *cp;
      uint32_t chartype;
      const ucd_record *prop = GET_UCD(fc);
      BOOL notmatch = Fop == OP_NOTPROP;

      switch(Fecode[1])
        {
        case PT_LAMP:
        chartype = prop->chartype;
        if ((chartype == ucp_Lu ||
             chartype == ucp_Ll ||
             chartype == ucp_Lt) == notmatch)
          RRETURN(MATCH_NOMATCH);
        break;

        case PT_GC:
        if ((Fecode[2] == PRIV(ucp_gentype)[prop->chartype]) == notmatch)
          RRETURN(MATCH_NOMATCH);
        break;

        case PT_PC:
        if ((Fecode[2] == prop->chartype) == notmatch)
          RRETURN(MATCH_NOMATCH);
        break;

        case PT_SC:
        if ((Fecode[2] == prop->script) == notmatch)
          RRETURN(MATCH_NOMATCH);
        break;

        case PT_SCX:
          {
          BOOL ok = (Fecode[2] == prop->script ||
                     MAPBIT(PRIV(ucd_script_sets) + UCD_SCRIPTX_PROP(prop), Fecode[2]) != 0);
          if (ok == notmatch) RRETURN(MATCH_NOMATCH);
          }
        break;

        /* These are specials */

        case PT_ALNUM:
        chartype = prop->chartype;
        if ((PRIV(ucp_gentype)[chartype] == ucp_L ||
             PRIV(ucp_gentype)[chartype] == ucp_N) == notmatch)
          RRETURN(MATCH_NOMATCH);
        break;

        /* Perl space used to exclude VT, but from Perl 5.18 it is included,
        which means that Perl space and POSIX space are now identical. PCRE
        was changed at release 8.34. */

        case PT_SPACE:    /* Perl space */
        case PT_PXSPACE:  /* POSIX space */
        switch(fc)
          {
          HSPACE_CASES:
          VSPACE_CASES:
          if (notmatch) RRETURN(MATCH_NOMATCH);
          break;

          default:
          if ((PRIV(ucp_gentype)[prop->chartype] == ucp_Z) == notmatch)
            RRETURN(MATCH_NOMATCH);
          break;
          }
        break;

        case PT_WORD:
        chartype = prop->chartype;
        if ((PRIV(ucp_gentype)[chartype] == ucp_L ||
             PRIV(ucp_gentype)[chartype] == ucp_N ||
             chartype == ucp_Mn ||
             chartype == ucp_Pc) == notmatch)
          RRETURN(MATCH_NOMATCH);
        break;

        case PT_CLIST:
#if PCRE2_CODE_UNIT_WIDTH == 32
            if (fc > MAX_UTF_CODE_POINT)
              {
              if (notmatch) break;;
              RRETURN(MATCH_NOMATCH);
              }
#endif
        cp = PRIV(ucd_caseless_sets) + Fecode[2];
        for (;;)
          {
          if (fc < *cp)
            { if (notmatch) break; else { RRETURN(MATCH_NOMATCH); } }
          if (fc == *cp++)
            { if (notmatch) { RRETURN(MATCH_NOMATCH); } else break; }
          }
        break;

        case PT_UCNC:
        if ((fc == CHAR_DOLLAR_SIGN || fc == CHAR_COMMERCIAL_AT ||
             fc == CHAR_GRAVE_ACCENT || (fc >= 0xa0 && fc <= 0xd7ff) ||
             fc >= 0xe000) == notmatch)
          RRETURN(MATCH_NOMATCH);
        break;

        case PT_BIDICL:
        if ((UCD_BIDICLASS_PROP(prop) == Fecode[2]) == notmatch)
          RRETURN(MATCH_NOMATCH);
        break;

        case PT_BOOL:
          {
          BOOL ok = MAPBIT(PRIV(ucd_boolprop_sets) +
            UCD_BPROPS_PROP(prop), Fecode[2]) != 0;
          if (ok == notmatch) RRETURN(MATCH_NOMATCH);
          }
        break;

        /* This should never occur */

        default:
        PCRE2_DEBUG_UNREACHABLE();
        return PCRE2_ERROR_INTERNAL;
        }

      Fecode += 3;
      }
    break;


    /* ===================================================================== */
    /* Match an extended Unicode sequence. We will get here only if the support
    is in the binary; otherwise a compile-time error occurs. */

    case OP_EXTUNI:
    if (Feptr >= mb->end_subject)
      {
      SCHECK_PARTIAL();
      RRETURN(MATCH_NOMATCH);
      }
    else
      {
      GETCHARINCTEST(fc, Feptr);
      Feptr = PRIV(extuni)(fc, Feptr, mb->start_subject, mb->end_subject, utf,
        NULL);
      }
    CHECK_PARTIAL();
    Fecode++;
    break;

#endif  /* SUPPORT_UNICODE */


    /* ===================================================================== */
    /* Match a single character type repeatedly. Note that the property type
    does not need to be in a stack frame as it is not used within an RMATCH()
    loop. */

#define Lstart_eptr  F->temp_sptr[0]
#define Lmin         F->temp_32[0]
#define Lmax         F->temp_32[1]
#define Lctype       F->temp_32[2]
#define Lpropvalue   F->temp_32[3]

    case OP_TYPEEXACT:
    Lmin = Lmax = GET2(Fecode, 1);
    Fecode += 1 + IMM2_SIZE;
    goto REPEATTYPE;

    case OP_TYPEUPTO:
    case OP_TYPEMINUPTO:
    Lmin = 0;
    Lmax = GET2(Fecode, 1);
    reptype = (*Fecode == OP_TYPEMINUPTO)? REPTYPE_MIN : REPTYPE_MAX;
    Fecode += 1 + IMM2_SIZE;
    goto REPEATTYPE;

    case OP_TYPEPOSSTAR:
    reptype = REPTYPE_POS;
    Lmin = 0;
    Lmax = UINT32_MAX;
    Fecode++;
    goto REPEATTYPE;

    case OP_TYPEPOSPLUS:
    reptype = REPTYPE_POS;
    Lmin = 1;
    Lmax = UINT32_MAX;
    Fecode++;
    goto REPEATTYPE;

    case OP_TYPEPOSQUERY:
    reptype = REPTYPE_POS;
    Lmin = 0;
    Lmax = 1;
    Fecode++;
    goto REPEATTYPE;

    case OP_TYPEPOSUPTO:
    reptype = REPTYPE_POS;
    Lmin = 0;
    Lmax = GET2(Fecode, 1);
    Fecode += 1 + IMM2_SIZE;
    goto REPEATTYPE;

    case OP_TYPESTAR:
    case OP_TYPEMINSTAR:
    case OP_TYPEPLUS:
    case OP_TYPEMINPLUS:
    case OP_TYPEQUERY:
    case OP_TYPEMINQUERY:
    fc = *Fecode++ - OP_TYPESTAR;
    Lmin = rep_min[fc];
    Lmax = rep_max[fc];
    reptype = rep_typ[fc];

    /* Common code for all repeated character type matches. */

    REPEATTYPE:
    Lctype = *Fecode++;      /* Code for the character type */

#ifdef SUPPORT_UNICODE
    if (Lctype == OP_PROP || Lctype == OP_NOTPROP)
      {
      proptype = *Fecode++;
      Lpropvalue = *Fecode++;
      }
    else proptype = -1;
#endif

    /* First, ensure the minimum number of matches are present. Use inline
    code for maximizing the speed, and do the type test once at the start
    (i.e. keep it out of the loops). As there are no calls to RMATCH in the
    loops, we can use an ordinary variable for "notmatch". The code for UTF
    mode is separated out for tidiness, except for Unicode property tests. */

    if (Lmin > 0)
      {
#ifdef SUPPORT_UNICODE
      if (proptype >= 0)  /* Property tests in all modes */
        {
        BOOL notmatch = Lctype == OP_NOTPROP;
        switch(proptype)
          {
          case PT_LAMP:
          for (i = 1; i <= Lmin; i++)
            {
            int chartype;
            if (Feptr >= mb->end_subject)
              {
              SCHECK_PARTIAL();
              RRETURN(MATCH_NOMATCH);
              }
            GETCHARINCTEST(fc, Feptr);
            chartype = UCD_CHARTYPE(fc);
            if ((chartype == ucp_Lu ||
                 chartype == ucp_Ll ||
                 chartype == ucp_Lt) == notmatch)
              RRETURN(MATCH_NOMATCH);
            }
          break;

          case PT_GC:
          for (i = 1; i <= Lmin; i++)
            {
            if (Feptr >= mb->end_subject)
              {
              SCHECK_PARTIAL();
              RRETURN(MATCH_NOMATCH);
              }
            GETCHARINCTEST(fc, Feptr);
            if ((UCD_CATEGORY(fc) == Lpropvalue) == notmatch)
              RRETURN(MATCH_NOMATCH);
            }
          break;

          case PT_PC:
          for (i = 1; i <= Lmin; i++)
            {
            if (Feptr >= mb->end_subject)
              {
              SCHECK_PARTIAL();
              RRETURN(MATCH_NOMATCH);
              }
            GETCHARINCTEST(fc, Feptr);
            if ((UCD_CHARTYPE(fc) == Lpropvalue) == notmatch)
              RRETURN(MATCH_NOMATCH);
            }
          break;

          case PT_SC:
          for (i = 1; i <= Lmin; i++)
            {
            if (Feptr >= mb->end_subject)
              {
              SCHECK_PARTIAL();
              RRETURN(MATCH_NOMATCH);
              }
            GETCHARINCTEST(fc, Feptr);
            if ((UCD_SCRIPT(fc) == Lpropvalue) == notmatch)
              RRETURN(MATCH_NOMATCH);
            }
          break;

          case PT_SCX:
          for (i = 1; i <= Lmin; i++)
            {
            BOOL ok;
            const ucd_record *prop;
            if (Feptr >= mb->end_subject)
              {
              SCHECK_PARTIAL();
              RRETURN(MATCH_NOMATCH);
              }
            GETCHARINCTEST(fc, Feptr);
            prop = GET_UCD(fc);
            ok = (prop->script == Lpropvalue ||
                  MAPBIT(PRIV(ucd_script_sets) + UCD_SCRIPTX_PROP(prop), Lpropvalue) != 0);
            if (ok == notmatch)
              RRETURN(MATCH_NOMATCH);
            }
          break;

          case PT_ALNUM:
          for (i = 1; i <= Lmin; i++)
            {
            int category;
            if (Feptr >= mb->end_subject)
              {
              SCHECK_PARTIAL();
              RRETURN(MATCH_NOMATCH);
              }
            GETCHARINCTEST(fc, Feptr);
            category = UCD_CATEGORY(fc);
            if ((category == ucp_L || category == ucp_N) == notmatch)
              RRETURN(MATCH_NOMATCH);
            }
          break;

          /* Perl space used to exclude VT, but from Perl 5.18 it is included,
          which means that Perl space and POSIX space are now identical. PCRE
          was changed at release 8.34. */

          case PT_SPACE:    /* Perl space */
          case PT_PXSPACE:  /* POSIX space */
          for (i = 1; i <= Lmin; i++)
            {
            if (Feptr >= mb->end_subject)
              {
              SCHECK_PARTIAL();
              RRETURN(MATCH_NOMATCH);
              }
            GETCHARINCTEST(fc, Feptr);
            switch(fc)
              {
              HSPACE_CASES:
              VSPACE_CASES:
              if (notmatch) RRETURN(MATCH_NOMATCH);
              break;

              default:
              if ((UCD_CATEGORY(fc) == ucp_Z) == notmatch)
                RRETURN(MATCH_NOMATCH);
              break;
              }
            }
          break;

          case PT_WORD:
          for (i = 1; i <= Lmin; i++)
            {
            int chartype, category;
            if (Feptr >= mb->end_subject)
              {
              SCHECK_PARTIAL();
              RRETURN(MATCH_NOMATCH);
              }
            GETCHARINCTEST(fc, Feptr);
            chartype = UCD_CHARTYPE(fc);
            category = PRIV(ucp_gentype)[chartype];
            if ((category == ucp_L || category == ucp_N ||
                 chartype == ucp_Mn || chartype == ucp_Pc) == notmatch)
              RRETURN(MATCH_NOMATCH);
            }
          break;

          case PT_CLIST:
          for (i = 1; i <= Lmin; i++)
            {
            const uint32_t *cp;
            if (Feptr >= mb->end_subject)
              {
              SCHECK_PARTIAL();
              RRETURN(MATCH_NOMATCH);
              }
            GETCHARINCTEST(fc, Feptr);
#if PCRE2_CODE_UNIT_WIDTH == 32
            if (fc > MAX_UTF_CODE_POINT)
              {
              if (notmatch) continue;
              RRETURN(MATCH_NOMATCH);
              }
#endif
            cp = PRIV(ucd_caseless_sets) + Lpropvalue;
            for (;;)
              {
              if (fc < *cp)
                {
                if (notmatch) break;
                RRETURN(MATCH_NOMATCH);
                }
              if (fc == *cp++)
                {
                if (notmatch) RRETURN(MATCH_NOMATCH);
                break;
                }
              }
            }
          break;

          case PT_UCNC:
          for (i = 1; i <= Lmin; i++)
            {
            if (Feptr >= mb->end_subject)
              {
              SCHECK_PARTIAL();
              RRETURN(MATCH_NOMATCH);
              }
            GETCHARINCTEST(fc, Feptr);
            if ((fc == CHAR_DOLLAR_SIGN || fc == CHAR_COMMERCIAL_AT ||
                 fc == CHAR_GRAVE_ACCENT || (fc >= 0xa0 && fc <= 0xd7ff) ||
                 fc >= 0xe000) == notmatch)
              RRETURN(MATCH_NOMATCH);
            }
          break;

          case PT_BIDICL:
          for (i = 1; i <= Lmin; i++)
            {
            if (Feptr >= mb->end_subject)
              {
              SCHECK_PARTIAL();
              RRETURN(MATCH_NOMATCH);
              }
            GETCHARINCTEST(fc, Feptr);
            if ((UCD_BIDICLASS(fc) == Lpropvalue) == notmatch)
              RRETURN(MATCH_NOMATCH);
            }
          break;

          case PT_BOOL:
          for (i = 1; i <= Lmin; i++)
            {
            BOOL ok;
            const ucd_record *prop;
            if (Feptr >= mb->end_subject)
              {
              SCHECK_PARTIAL();
              RRETURN(MATCH_NOMATCH);
              }
            GETCHARINCTEST(fc, Feptr);
            prop = GET_UCD(fc);
            ok = MAPBIT(PRIV(ucd_boolprop_sets) +
              UCD_BPROPS_PROP(prop), Lpropvalue) != 0;
            if (ok == notmatch)
              RRETURN(MATCH_NOMATCH);
            }
          break;

          /* This should not occur */

          default:
          PCRE2_DEBUG_UNREACHABLE();
          return PCRE2_ERROR_INTERNAL;
          }
        }

      /* Match extended Unicode sequences. We will get here only if the
      support is in the binary; otherwise a compile-time error occurs. */

      else if (Lctype == OP_EXTUNI)
        {
        for (i = 1; i <= Lmin; i++)
          {
          if (Feptr >= mb->end_subject)
            {
            SCHECK_PARTIAL();
            RRETURN(MATCH_NOMATCH);
            }
          else
            {
            GETCHARINCTEST(fc, Feptr);
            Feptr = PRIV(extuni)(fc, Feptr, mb->start_subject,
              mb->end_subject, utf, NULL);
            }
          CHECK_PARTIAL();
          }
        }
      else
#endif     /* SUPPORT_UNICODE */

/* Handle all other cases in UTF mode */

#ifdef SUPPORT_UNICODE
      if (utf) switch(Lctype)
        {
        case OP_ANY:
        for (i = 1; i <= Lmin; i++)
          {
          if (Feptr >= mb->end_subject)
            {
            SCHECK_PARTIAL();
            RRETURN(MATCH_NOMATCH);
            }
          if (IS_NEWLINE(Feptr)) RRETURN(MATCH_NOMATCH);
          if (mb->partial != 0 &&
              Feptr + 1 >= mb->end_subject &&
              NLBLOCK->nltype == NLTYPE_FIXED &&
              NLBLOCK->nllen == 2 &&
              UCHAR21(Feptr) == NLBLOCK->nl[0])
            {
            mb->hitend = TRUE;
            if (mb->partial > 1) return PCRE2_ERROR_PARTIAL;
            }
          Feptr++;
          ACROSSCHAR(Feptr < mb->end_subject, Feptr, Feptr++);
          }
        break;

        case OP_ALLANY:
        for (i = 1; i <= Lmin; i++)
          {
          if (Feptr >= mb->end_subject)
            {
            SCHECK_PARTIAL();
            RRETURN(MATCH_NOMATCH);
            }
          Feptr++;
          ACROSSCHAR(Feptr < mb->end_subject, Feptr, Feptr++);
          }
        break;

        case OP_ANYBYTE:
        if (Feptr > mb->end_subject - Lmin) RRETURN(MATCH_NOMATCH);
        Feptr += Lmin;
        break;

        case OP_ANYNL:
        for (i = 1; i <= Lmin; i++)
          {
          if (Feptr >= mb->end_subject)
            {
            SCHECK_PARTIAL();
            RRETURN(MATCH_NOMATCH);
            }
          GETCHARINC(fc, Feptr);
          switch(fc)
            {
            default: RRETURN(MATCH_NOMATCH);

            case CHAR_CR:
            if (Feptr < mb->end_subject && UCHAR21(Feptr) == CHAR_LF) Feptr++;
            break;

            case CHAR_LF:
            break;

            case CHAR_VT:
            case CHAR_FF:
            case CHAR_NEL:
#ifndef EBCDIC
            case 0x2028:
            case 0x2029:
#endif  /* Not EBCDIC */
            if (mb->bsr_convention == PCRE2_BSR_ANYCRLF) RRETURN(MATCH_NOMATCH);
            break;
            }
          }
        break;

        case OP_NOT_HSPACE:
        for (i = 1; i <= Lmin; i++)
          {
          if (Feptr >= mb->end_subject)
            {
            SCHECK_PARTIAL();
            RRETURN(MATCH_NOMATCH);
            }
          GETCHARINC(fc, Feptr);
          switch(fc)
            {
            HSPACE_CASES: RRETURN(MATCH_NOMATCH);
            default: break;
            }
          }
        break;

        case OP_HSPACE:
        for (i = 1; i <= Lmin; i++)
          {
          if (Feptr >= mb->end_subject)
            {
            SCHECK_PARTIAL();
            RRETURN(MATCH_NOMATCH);
            }
          GETCHARINC(fc, Feptr);
          switch(fc)
            {
            HSPACE_CASES: break;
            default: RRETURN(MATCH_NOMATCH);
            }
          }
        break;

        case OP_NOT_VSPACE:
        for (i = 1; i <= Lmin; i++)
          {
          if (Feptr >= mb->end_subject)
            {
            SCHECK_PARTIAL();
            RRETURN(MATCH_NOMATCH);
            }
          GETCHARINC(fc, Feptr);
          switch(fc)
            {
            VSPACE_CASES: RRETURN(MATCH_NOMATCH);
            default: break;
            }
          }
        break;

        case OP_VSPACE:
        for (i = 1; i <= Lmin; i++)
          {
          if (Feptr >= mb->end_subject)
            {
            SCHECK_PARTIAL();
            RRETURN(MATCH_NOMATCH);
            }
          GETCHARINC(fc, Feptr);
          switch(fc)
            {
            VSPACE_CASES: break;
            default: RRETURN(MATCH_NOMATCH);
            }
          }
        break;

        case OP_NOT_DIGIT:
        for (i = 1; i <= Lmin; i++)
          {
          if (Feptr >= mb->end_subject)
            {
            SCHECK_PARTIAL();
            RRETURN(MATCH_NOMATCH);
            }
          GETCHARINC(fc, Feptr);
          if (fc < 128 && (mb->ctypes[fc] & ctype_digit) != 0)
            RRETURN(MATCH_NOMATCH);
          }
        break;

        case OP_DIGIT:
        for (i = 1; i <= Lmin; i++)
          {
          uint32_t cc;
          if (Feptr >= mb->end_subject)
            {
            SCHECK_PARTIAL();
            RRETURN(MATCH_NOMATCH);
            }
          cc = UCHAR21(Feptr);
          if (cc >= 128 || (mb->ctypes[cc] & ctype_digit) == 0)
            RRETURN(MATCH_NOMATCH);
          Feptr++;
          /* No need to skip more code units - we know it has only one. */
          }
        break;

        case OP_NOT_WHITESPACE:
        for (i = 1; i <= Lmin; i++)
          {
          uint32_t cc;
          if (Feptr >= mb->end_subject)
            {
            SCHECK_PARTIAL();
            RRETURN(MATCH_NOMATCH);
            }
          cc = UCHAR21(Feptr);
          if (cc < 128 && (mb->ctypes[cc] & ctype_space) != 0)
            RRETURN(MATCH_NOMATCH);
          Feptr++;
          ACROSSCHAR(Feptr < mb->end_subject, Feptr, Feptr++);
          }
        break;

        case OP_WHITESPACE:
        for (i = 1; i <= Lmin; i++)
          {
          uint32_t cc;
          if (Feptr >= mb->end_subject)
            {
            SCHECK_PARTIAL();
            RRETURN(MATCH_NOMATCH);
            }
          cc = UCHAR21(Feptr);
          if (cc >= 128 || (mb->ctypes[cc] & ctype_space) == 0)
            RRETURN(MATCH_NOMATCH);
          Feptr++;
          /* No need to skip more code units - we know it has only one. */
          }
        break;

        case OP_NOT_WORDCHAR:
        for (i = 1; i <= Lmin; i++)
          {
          uint32_t cc;
          if (Feptr >= mb->end_subject)
            {
            SCHECK_PARTIAL();
            RRETURN(MATCH_NOMATCH);
            }
          cc = UCHAR21(Feptr);
          if (cc < 128 && (mb->ctypes[cc] & ctype_word) != 0)
            RRETURN(MATCH_NOMATCH);
          Feptr++;
          ACROSSCHAR(Feptr < mb->end_subject, Feptr, Feptr++);
          }
        break;

        case OP_WORDCHAR:
        for (i = 1; i <= Lmin; i++)
          {
          uint32_t cc;
          if (Feptr >= mb->end_subject)
            {
            SCHECK_PARTIAL();
            RRETURN(MATCH_NOMATCH);
            }
          cc = UCHAR21(Feptr);
          if (cc >= 128 || (mb->ctypes[cc] & ctype_word) == 0)
            RRETURN(MATCH_NOMATCH);
          Feptr++;
          /* No need to skip more code units - we know it has only one. */
          }
        break;

        default:
        PCRE2_DEBUG_UNREACHABLE();
        return PCRE2_ERROR_INTERNAL;
        }  /* End switch(Lctype) */

      else
#endif     /* SUPPORT_UNICODE */

      /* Code for the non-UTF case for minimum matching of operators other
      than OP_PROP and OP_NOTPROP. */

      switch(Lctype)
        {
        case OP_ANY:
        for (i = 1; i <= Lmin; i++)
          {
          if (Feptr >= mb->end_subject)
            {
            SCHECK_PARTIAL();
            RRETURN(MATCH_NOMATCH);
            }
          if (IS_NEWLINE(Feptr)) RRETURN(MATCH_NOMATCH);
          if (mb->partial != 0 &&
              Feptr + 1 >= mb->end_subject &&
              NLBLOCK->nltype == NLTYPE_FIXED &&
              NLBLOCK->nllen == 2 &&
              *Feptr == NLBLOCK->nl[0])
            {
            mb->hitend = TRUE;
            if (mb->partial > 1) return PCRE2_ERROR_PARTIAL;
            }
          Feptr++;
          }
        break;

        case OP_ALLANY:
        if (Feptr > mb->end_subject - Lmin)
          {
          SCHECK_PARTIAL();
          RRETURN(MATCH_NOMATCH);
          }
        Feptr += Lmin;
        break;

        /* This OP_ANYBYTE case will never be reached because \C gets turned
        into OP_ALLANY in non-UTF mode. Cut out the code so that coverage
        reports don't complain about it's never being used. */

/*        case OP_ANYBYTE:
*        if (Feptr > mb->end_subject - Lmin)
*          {
*          SCHECK_PARTIAL();
*          RRETURN(MATCH_NOMATCH);
*          }
*        Feptr += Lmin;
*        break;
*/
        case OP_ANYNL:
        for (i = 1; i <= Lmin; i++)
          {
          if (Feptr >= mb->end_subject)
            {
            SCHECK_PARTIAL();
            RRETURN(MATCH_NOMATCH);
            }
          switch(*Feptr++)
            {
            default: RRETURN(MATCH_NOMATCH);

            case CHAR_CR:
            if (Feptr < mb->end_subject && *Feptr == CHAR_LF) Feptr++;
            break;

            case CHAR_LF:
            break;

            case CHAR_VT:
            case CHAR_FF:
            case CHAR_NEL:
#if PCRE2_CODE_UNIT_WIDTH != 8
            case 0x2028:
            case 0x2029:
#endif
            if (mb->bsr_convention == PCRE2_BSR_ANYCRLF) RRETURN(MATCH_NOMATCH);
            break;
            }
          }
        break;

        case OP_NOT_HSPACE:
        for (i = 1; i <= Lmin; i++)
          {
          if (Feptr >= mb->end_subject)
            {
            SCHECK_PARTIAL();
            RRETURN(MATCH_NOMATCH);
            }
          switch(*Feptr++)
            {
            default: break;
            HSPACE_BYTE_CASES:
#if PCRE2_CODE_UNIT_WIDTH != 8
            HSPACE_MULTIBYTE_CASES:
#endif
            RRETURN(MATCH_NOMATCH);
            }
          }
        break;

        case OP_HSPACE:
        for (i = 1; i <= Lmin; i++)
          {
          if (Feptr >= mb->end_subject)
            {
            SCHECK_PARTIAL();
            RRETURN(MATCH_NOMATCH);
            }
          switch(*Feptr++)
            {
            default: RRETURN(MATCH_NOMATCH);
            HSPACE_BYTE_CASES:
#if PCRE2_CODE_UNIT_WIDTH != 8
            HSPACE_MULTIBYTE_CASES:
#endif
            break;
            }
          }
        break;

        case OP_NOT_VSPACE:
        for (i = 1; i <= Lmin; i++)
          {
          if (Feptr >= mb->end_subject)
            {
            SCHECK_PARTIAL();
            RRETURN(MATCH_NOMATCH);
            }
          switch(*Feptr++)
            {
            VSPACE_BYTE_CASES:
#if PCRE2_CODE_UNIT_WIDTH != 8
            VSPACE_MULTIBYTE_CASES:
#endif
            RRETURN(MATCH_NOMATCH);
            default: break;
            }
          }
        break;

        case OP_VSPACE:
        for (i = 1; i <= Lmin; i++)
          {
          if (Feptr >= mb->end_subject)
            {
            SCHECK_PARTIAL();
            RRETURN(MATCH_NOMATCH);
            }
          switch(*Feptr++)
            {
            default: RRETURN(MATCH_NOMATCH);
            VSPACE_BYTE_CASES:
#if PCRE2_CODE_UNIT_WIDTH != 8
            VSPACE_MULTIBYTE_CASES:
#endif
            break;
            }
          }
        break;

        case OP_NOT_DIGIT:
        for (i = 1; i <= Lmin; i++)
          {
          if (Feptr >= mb->end_subject)
            {
            SCHECK_PARTIAL();
            RRETURN(MATCH_NOMATCH);
            }
          if (MAX_255(*Feptr) && (mb->ctypes[*Feptr] & ctype_digit) != 0)
            RRETURN(MATCH_NOMATCH);
          Feptr++;
          }
        break;

        case OP_DIGIT:
        for (i = 1; i <= Lmin; i++)
          {
          if (Feptr >= mb->end_subject)
            {
            SCHECK_PARTIAL();
            RRETURN(MATCH_NOMATCH);
            }
          if (!MAX_255(*Feptr) || (mb->ctypes[*Feptr] & ctype_digit) == 0)
            RRETURN(MATCH_NOMATCH);
          Feptr++;
          }
        break;

        case OP_NOT_WHITESPACE:
        for (i = 1; i <= Lmin; i++)
          {
          if (Feptr >= mb->end_subject)
            {
            SCHECK_PARTIAL();
            RRETURN(MATCH_NOMATCH);
            }
          if (MAX_255(*Feptr) && (mb->ctypes[*Feptr] & ctype_space) != 0)
            RRETURN(MATCH_NOMATCH);
          Feptr++;
          }
        break;

        case OP_WHITESPACE:
        for (i = 1; i <= Lmin; i++)
          {
          if (Feptr >= mb->end_subject)
            {
            SCHECK_PARTIAL();
            RRETURN(MATCH_NOMATCH);
            }
          if (!MAX_255(*Feptr) || (mb->ctypes[*Feptr] & ctype_space) == 0)
            RRETURN(MATCH_NOMATCH);
          Feptr++;
          }
        break;

        case OP_NOT_WORDCHAR:
        for (i = 1; i <= Lmin; i++)
          {
          if (Feptr >= mb->end_subject)
            {
            SCHECK_PARTIAL();
            RRETURN(MATCH_NOMATCH);
            }
          if (MAX_255(*Feptr) && (mb->ctypes[*Feptr] & ctype_word) != 0)
            RRETURN(MATCH_NOMATCH);
          Feptr++;
          }
        break;

        case OP_WORDCHAR:
        for (i = 1; i <= Lmin; i++)
          {
          if (Feptr >= mb->end_subject)
            {
            SCHECK_PARTIAL();
            RRETURN(MATCH_NOMATCH);
            }
          if (!MAX_255(*Feptr) || (mb->ctypes[*Feptr] & ctype_word) == 0)
            RRETURN(MATCH_NOMATCH);
          Feptr++;
          }
        break;

        default:
        PCRE2_DEBUG_UNREACHABLE();
        return PCRE2_ERROR_INTERNAL;
        }
      }

    /* If Lmin = Lmax we are done. Continue with the main loop. */

    if (Lmin == Lmax) continue;

    /* If minimizing, we have to test the rest of the pattern before each
    subsequent match. This means we cannot use a local "notmatch" variable as
    in the other cases. As all 4 temporary 32-bit values in the frame are
    already in use, just test the type each time. */

    if (reptype == REPTYPE_MIN)
      {
#ifdef SUPPORT_UNICODE
      if (proptype >= 0)
        {
        switch(proptype)
          {
          case PT_LAMP:
          for (;;)
            {
            int chartype;
            RMATCH(Fecode, RM208);
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
            if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH);
            if (Feptr >= mb->end_subject)
              {
              SCHECK_PARTIAL();
              RRETURN(MATCH_NOMATCH);
              }
            GETCHARINCTEST(fc, Feptr);
            chartype = UCD_CHARTYPE(fc);
            if ((chartype == ucp_Lu ||
                 chartype == ucp_Ll ||
                 chartype == ucp_Lt) == (Lctype == OP_NOTPROP))
              RRETURN(MATCH_NOMATCH);
            }
          PCRE2_UNREACHABLE(); /* Control never reaches here */

          case PT_GC:
          for (;;)
            {
            RMATCH(Fecode, RM209);
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
            if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH);
            if (Feptr >= mb->end_subject)
              {
              SCHECK_PARTIAL();
              RRETURN(MATCH_NOMATCH);
              }
            GETCHARINCTEST(fc, Feptr);
            if ((UCD_CATEGORY(fc) == Lpropvalue) == (Lctype == OP_NOTPROP))
              RRETURN(MATCH_NOMATCH);
            }
          PCRE2_UNREACHABLE(); /* Control never reaches here */

          case PT_PC:
          for (;;)
            {
            RMATCH(Fecode, RM210);
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
            if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH);
            if (Feptr >= mb->end_subject)
              {
              SCHECK_PARTIAL();
              RRETURN(MATCH_NOMATCH);
              }
            GETCHARINCTEST(fc, Feptr);
            if ((UCD_CHARTYPE(fc) == Lpropvalue) == (Lctype == OP_NOTPROP))
              RRETURN(MATCH_NOMATCH);
            }
          PCRE2_UNREACHABLE(); /* Control never reaches here */

          case PT_SC:
          for (;;)
            {
            RMATCH(Fecode, RM211);
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
            if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH);
            if (Feptr >= mb->end_subject)
              {
              SCHECK_PARTIAL();
              RRETURN(MATCH_NOMATCH);
              }
            GETCHARINCTEST(fc, Feptr);
            if ((UCD_SCRIPT(fc) == Lpropvalue) == (Lctype == OP_NOTPROP))
              RRETURN(MATCH_NOMATCH);
            }
          PCRE2_UNREACHABLE(); /* Control never reaches here */

          case PT_SCX:
          for (;;)
            {
            BOOL ok;
            const ucd_record *prop;
            RMATCH(Fecode, RM224);
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
            if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH);
            if (Feptr >= mb->end_subject)
              {
              SCHECK_PARTIAL();
              RRETURN(MATCH_NOMATCH);
              }
            GETCHARINCTEST(fc, Feptr);
            prop = GET_UCD(fc);
            ok = (prop->script == Lpropvalue
                  || MAPBIT(PRIV(ucd_script_sets) + UCD_SCRIPTX_PROP(prop), Lpropvalue) != 0);
            if (ok == (Lctype == OP_NOTPROP))
              RRETURN(MATCH_NOMATCH);
            }
          PCRE2_UNREACHABLE(); /* Control never reaches here */

          case PT_ALNUM:
          for (;;)
            {
            int category;
            RMATCH(Fecode, RM212);
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
            if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH);
            if (Feptr >= mb->end_subject)
              {
              SCHECK_PARTIAL();
              RRETURN(MATCH_NOMATCH);
              }
            GETCHARINCTEST(fc, Feptr);
            category = UCD_CATEGORY(fc);
            if ((category == ucp_L || category == ucp_N) == (Lctype == OP_NOTPROP))
              RRETURN(MATCH_NOMATCH);
            }
          PCRE2_UNREACHABLE(); /* Control never reaches here */

          /* Perl space used to exclude VT, but from Perl 5.18 it is included,
          which means that Perl space and POSIX space are now identical. PCRE
          was changed at release 8.34. */

          case PT_SPACE:    /* Perl space */
          case PT_PXSPACE:  /* POSIX space */
          for (;;)
            {
            RMATCH(Fecode, RM213);
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
            if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH);
            if (Feptr >= mb->end_subject)
              {
              SCHECK_PARTIAL();
              RRETURN(MATCH_NOMATCH);
              }
            GETCHARINCTEST(fc, Feptr);
            switch(fc)
              {
              HSPACE_CASES:
              VSPACE_CASES:
              if (Lctype == OP_NOTPROP) RRETURN(MATCH_NOMATCH);
              break;

              default:
              if ((UCD_CATEGORY(fc) == ucp_Z) == (Lctype == OP_NOTPROP))
                RRETURN(MATCH_NOMATCH);
              break;
              }
            }
          PCRE2_UNREACHABLE(); /* Control never reaches here */

          case PT_WORD:
          for (;;)
            {
            int chartype, category;
            RMATCH(Fecode, RM214);
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
            if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH);
            if (Feptr >= mb->end_subject)
              {
              SCHECK_PARTIAL();
              RRETURN(MATCH_NOMATCH);
              }
            GETCHARINCTEST(fc, Feptr);
            chartype = UCD_CHARTYPE(fc);
            category = PRIV(ucp_gentype)[chartype];
            if ((category == ucp_L ||
                 category == ucp_N ||
                 chartype == ucp_Mn ||
                 chartype == ucp_Pc) == (Lctype == OP_NOTPROP))
              RRETURN(MATCH_NOMATCH);
            }
          PCRE2_UNREACHABLE(); /* Control never reaches here */

          case PT_CLIST:
          for (;;)
            {
            const uint32_t *cp;
            RMATCH(Fecode, RM215);
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
            if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH);
            if (Feptr >= mb->end_subject)
              {
              SCHECK_PARTIAL();
              RRETURN(MATCH_NOMATCH);
              }
            GETCHARINCTEST(fc, Feptr);
#if PCRE2_CODE_UNIT_WIDTH == 32
            if (fc > MAX_UTF_CODE_POINT)
              {
              if (Lctype == OP_NOTPROP) continue;
              RRETURN(MATCH_NOMATCH);
              }
#endif
            cp = PRIV(ucd_caseless_sets) + Lpropvalue;
            for (;;)
              {
              if (fc < *cp)
                {
                if (Lctype == OP_NOTPROP) break;
                RRETURN(MATCH_NOMATCH);
                }
              if (fc == *cp++)
                {
                if (Lctype == OP_NOTPROP) RRETURN(MATCH_NOMATCH);
                break;
                }
              }
            }
          PCRE2_UNREACHABLE(); /* Control never reaches here */

          case PT_UCNC:
          for (;;)
            {
            RMATCH(Fecode, RM216);
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
            if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH);
            if (Feptr >= mb->end_subject)
              {
              SCHECK_PARTIAL();
              RRETURN(MATCH_NOMATCH);
              }
            GETCHARINCTEST(fc, Feptr);
            if ((fc == CHAR_DOLLAR_SIGN || fc == CHAR_COMMERCIAL_AT ||
                 fc == CHAR_GRAVE_ACCENT || (fc >= 0xa0 && fc <= 0xd7ff) ||
                 fc >= 0xe000) == (Lctype == OP_NOTPROP))
              RRETURN(MATCH_NOMATCH);
            }
          PCRE2_UNREACHABLE(); /* Control never reaches here */

          case PT_BIDICL:
          for (;;)
            {
            RMATCH(Fecode, RM223);
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
            if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH);
            if (Feptr >= mb->end_subject)
              {
              SCHECK_PARTIAL();
              RRETURN(MATCH_NOMATCH);
              }
            GETCHARINCTEST(fc, Feptr);
            if ((UCD_BIDICLASS(fc) == Lpropvalue) == (Lctype == OP_NOTPROP))
              RRETURN(MATCH_NOMATCH);
            }
          PCRE2_UNREACHABLE(); /* Control never reaches here */

          case PT_BOOL:
          for (;;)
            {
            BOOL ok;
            const ucd_record *prop;
            RMATCH(Fecode, RM222);
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
            if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH);
            if (Feptr >= mb->end_subject)
              {
              SCHECK_PARTIAL();
              RRETURN(MATCH_NOMATCH);
              }
            GETCHARINCTEST(fc, Feptr);
            prop = GET_UCD(fc);
            ok = MAPBIT(PRIV(ucd_boolprop_sets) +
              UCD_BPROPS_PROP(prop), Lpropvalue) != 0;
            if (ok == (Lctype == OP_NOTPROP))
              RRETURN(MATCH_NOMATCH);
            }
          PCRE2_UNREACHABLE(); /* Control never reaches here */

          /* This should never occur */
          default:
          PCRE2_DEBUG_UNREACHABLE();
          return PCRE2_ERROR_INTERNAL;
          }
        }

      /* Match extended Unicode sequences. We will get here only if the
      support is in the binary; otherwise a compile-time error occurs. */

      else if (Lctype == OP_EXTUNI)
        {
        for (;;)
          {
          RMATCH(Fecode, RM217);
          if (rrc != MATCH_NOMATCH) RRETURN(rrc);
          if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH);
          if (Feptr >= mb->end_subject)
            {
            SCHECK_PARTIAL();
            RRETURN(MATCH_NOMATCH);
            }
          else
            {
            GETCHARINCTEST(fc, Feptr);
            Feptr = PRIV(extuni)(fc, Feptr, mb->start_subject, mb->end_subject,
              utf, NULL);
            }
          CHECK_PARTIAL();
          }
        }
      else
#endif     /* SUPPORT_UNICODE */

      /* UTF mode for non-property testing character types. */

#ifdef SUPPORT_UNICODE
      if (utf)
        {
        for (;;)
          {
          RMATCH(Fecode, RM218);
          if (rrc != MATCH_NOMATCH) RRETURN(rrc);
          if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH);
          if (Feptr >= mb->end_subject)
            {
            SCHECK_PARTIAL();
            RRETURN(MATCH_NOMATCH);
            }
          if (Lctype == OP_ANY && IS_NEWLINE(Feptr)) RRETURN(MATCH_NOMATCH);
          GETCHARINC(fc, Feptr);
          switch(Lctype)
            {
            case OP_ANY:               /* This is the non-NL case */
            if (mb->partial != 0 &&    /* Take care with CRLF partial */
                Feptr >= mb->end_subject &&
                NLBLOCK->nltype == NLTYPE_FIXED &&
                NLBLOCK->nllen == 2 &&
                fc == NLBLOCK->nl[0])
              {
              mb->hitend = TRUE;
              if (mb->partial > 1) return PCRE2_ERROR_PARTIAL;
              }
            break;

            case OP_ALLANY:
            case OP_ANYBYTE:
            break;

            case OP_ANYNL:
            switch(fc)
              {
              default: RRETURN(MATCH_NOMATCH);

              case CHAR_CR:
              if (Feptr < mb->end_subject && UCHAR21(Feptr) == CHAR_LF) Feptr++;
              break;

              case CHAR_LF:
              break;

              case CHAR_VT:
              case CHAR_FF:
              case CHAR_NEL:
#ifndef EBCDIC
              case 0x2028:
              case 0x2029:
#endif  /* Not EBCDIC */
              if (mb->bsr_convention == PCRE2_BSR_ANYCRLF)
                RRETURN(MATCH_NOMATCH);
              break;
              }
            break;

            case OP_NOT_HSPACE:
            switch(fc)
              {
              HSPACE_CASES: RRETURN(MATCH_NOMATCH);
              default: break;
              }
            break;

            case OP_HSPACE:
            switch(fc)
              {
              HSPACE_CASES: break;
              default: RRETURN(MATCH_NOMATCH);
              }
            break;

            case OP_NOT_VSPACE:
            switch(fc)
              {
              VSPACE_CASES: RRETURN(MATCH_NOMATCH);
              default: break;
              }
            break;

            case OP_VSPACE:
            switch(fc)
              {
              VSPACE_CASES: break;
              default: RRETURN(MATCH_NOMATCH);
              }
            break;

            case OP_NOT_DIGIT:
            if (fc < 256 && (mb->ctypes[fc] & ctype_digit) != 0)
              RRETURN(MATCH_NOMATCH);
            break;

            case OP_DIGIT:
            if (fc >= 256 || (mb->ctypes[fc] & ctype_digit) == 0)
              RRETURN(MATCH_NOMATCH);
            break;

            case OP_NOT_WHITESPACE:
            if (fc < 256 && (mb->ctypes[fc] & ctype_space) != 0)
              RRETURN(MATCH_NOMATCH);
            break;

            case OP_WHITESPACE:
            if (fc >= 256 || (mb->ctypes[fc] & ctype_space) == 0)
              RRETURN(MATCH_NOMATCH);
            break;

            case OP_NOT_WORDCHAR:
            if (fc < 256 && (mb->ctypes[fc] & ctype_word) != 0)
              RRETURN(MATCH_NOMATCH);
            break;

            case OP_WORDCHAR:
            if (fc >= 256 || (mb->ctypes[fc] & ctype_word) == 0)
              RRETURN(MATCH_NOMATCH);
            break;

            default:
            PCRE2_DEBUG_UNREACHABLE();
            return PCRE2_ERROR_INTERNAL;
            }
          }
        }
      else
#endif  /* SUPPORT_UNICODE */

      /* Not UTF mode */
        {
        for (;;)
          {
          RMATCH(Fecode, RM33);
          if (rrc != MATCH_NOMATCH) RRETURN(rrc);
          if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH);
          if (Feptr >= mb->end_subject)
            {
            SCHECK_PARTIAL();
            RRETURN(MATCH_NOMATCH);
            }
          if (Lctype == OP_ANY && IS_NEWLINE(Feptr))
            RRETURN(MATCH_NOMATCH);
          fc = *Feptr++;
          switch(Lctype)
            {
            case OP_ANY:               /* This is the non-NL case */
            if (mb->partial != 0 &&    /* Take care with CRLF partial */
                Feptr >= mb->end_subject &&
                NLBLOCK->nltype == NLTYPE_FIXED &&
                NLBLOCK->nllen == 2 &&
                fc == NLBLOCK->nl[0])
              {
              mb->hitend = TRUE;
              if (mb->partial > 1) return PCRE2_ERROR_PARTIAL;
              }
            break;

            case OP_ALLANY:
            case OP_ANYBYTE:
            break;

            case OP_ANYNL:
            switch(fc)
              {
              default: RRETURN(MATCH_NOMATCH);

              case CHAR_CR:
              if (Feptr < mb->end_subject && *Feptr == CHAR_LF) Feptr++;
              break;

              case CHAR_LF:
              break;

              case CHAR_VT:
              case CHAR_FF:
              case CHAR_NEL:
#if PCRE2_CODE_UNIT_WIDTH != 8
              case 0x2028:
              case 0x2029:
#endif
              if (mb->bsr_convention == PCRE2_BSR_ANYCRLF)
                RRETURN(MATCH_NOMATCH);
              break;
              }
            break;

            case OP_NOT_HSPACE:
            switch(fc)
              {
              default: break;
              HSPACE_BYTE_CASES:
#if PCRE2_CODE_UNIT_WIDTH != 8
              HSPACE_MULTIBYTE_CASES:
#endif
              RRETURN(MATCH_NOMATCH);
              }
            break;

            case OP_HSPACE:
            switch(fc)
              {
              default: RRETURN(MATCH_NOMATCH);
              HSPACE_BYTE_CASES:
#if PCRE2_CODE_UNIT_WIDTH != 8
              HSPACE_MULTIBYTE_CASES:
#endif
              break;
              }
            break;

            case OP_NOT_VSPACE:
            switch(fc)
              {
              default: break;
              VSPACE_BYTE_CASES:
#if PCRE2_CODE_UNIT_WIDTH != 8
              VSPACE_MULTIBYTE_CASES:
#endif
              RRETURN(MATCH_NOMATCH);
              }
            break;

            case OP_VSPACE:
            switch(fc)
              {
              default: RRETURN(MATCH_NOMATCH);
              VSPACE_BYTE_CASES:
#if PCRE2_CODE_UNIT_WIDTH != 8
              VSPACE_MULTIBYTE_CASES:
#endif
              break;
              }
            break;

            case OP_NOT_DIGIT:
            if (MAX_255(fc) && (mb->ctypes[fc] & ctype_digit) != 0)
              RRETURN(MATCH_NOMATCH);
            break;

            case OP_DIGIT:
            if (!MAX_255(fc) || (mb->ctypes[fc] & ctype_digit) == 0)
              RRETURN(MATCH_NOMATCH);
            break;

            case OP_NOT_WHITESPACE:
            if (MAX_255(fc) && (mb->ctypes[fc] & ctype_space) != 0)
              RRETURN(MATCH_NOMATCH);
            break;

            case OP_WHITESPACE:
            if (!MAX_255(fc) || (mb->ctypes[fc] & ctype_space) == 0)
              RRETURN(MATCH_NOMATCH);
            break;

            case OP_NOT_WORDCHAR:
            if (MAX_255(fc) && (mb->ctypes[fc] & ctype_word) != 0)
              RRETURN(MATCH_NOMATCH);
            break;

            case OP_WORDCHAR:
            if (!MAX_255(fc) || (mb->ctypes[fc] & ctype_word) == 0)
              RRETURN(MATCH_NOMATCH);
            break;

            default:
            PCRE2_DEBUG_UNREACHABLE();
            return PCRE2_ERROR_INTERNAL;
            }
          }
        }

      PCRE2_DEBUG_UNREACHABLE(); /* Control should never reach here */
      }

    /* If maximizing, it is worth using inline code for speed, doing the type
    test once at the start (i.e. keep it out of the loops). Once again,
    "notmatch" can be an ordinary local variable because the loops do not call
    RMATCH. */

    else
      {
      Lstart_eptr = Feptr;  /* Remember where we started */

#ifdef SUPPORT_UNICODE
      if (proptype >= 0)
        {
        BOOL notmatch = Lctype == OP_NOTPROP;
        switch(proptype)
          {
          case PT_LAMP:
          for (i = Lmin; i < Lmax; i++)
            {
            int chartype;
            int len = 1;
            if (Feptr >= mb->end_subject)
              {
              SCHECK_PARTIAL();
              break;
              }
            GETCHARLENTEST(fc, Feptr, len);
            chartype = UCD_CHARTYPE(fc);
            if ((chartype == ucp_Lu ||
                 chartype == ucp_Ll ||
                 chartype == ucp_Lt) == notmatch)
              break;
            Feptr+= len;
            }
          break;

          case PT_GC:
          for (i = Lmin; i < Lmax; i++)
            {
            int len = 1;
            if (Feptr >= mb->end_subject)
              {
              SCHECK_PARTIAL();
              break;
              }
            GETCHARLENTEST(fc, Feptr, len);
            if ((UCD_CATEGORY(fc) == Lpropvalue) == notmatch) break;
            Feptr+= len;
            }
          break;

          case PT_PC:
          for (i = Lmin; i < Lmax; i++)
            {
            int len = 1;
            if (Feptr >= mb->end_subject)
              {
              SCHECK_PARTIAL();
              break;
              }
            GETCHARLENTEST(fc, Feptr, len);
            if ((UCD_CHARTYPE(fc) == Lpropvalue) == notmatch) break;
            Feptr+= len;
            }
          break;

          case PT_SC:
          for (i = Lmin; i < Lmax; i++)
            {
            int len = 1;
            if (Feptr >= mb->end_subject)
              {
              SCHECK_PARTIAL();
              break;
              }
            GETCHARLENTEST(fc, Feptr, len);
            if ((UCD_SCRIPT(fc) == Lpropvalue) == notmatch) break;
            Feptr+= len;
            }
          break;

          case PT_SCX:
          for (i = Lmin; i < Lmax; i++)
            {
            BOOL ok;
            const ucd_record *prop;
            int len = 1;
            if (Feptr >= mb->end_subject)
              {
              SCHECK_PARTIAL();
              break;
              }
            GETCHARLENTEST(fc, Feptr, len);
            prop = GET_UCD(fc);
            ok = (prop->script == Lpropvalue ||
                  MAPBIT(PRIV(ucd_script_sets) + UCD_SCRIPTX_PROP(prop), Lpropvalue) != 0);
            if (ok == notmatch) break;
            Feptr+= len;
            }
          break;

          case PT_ALNUM:
          for (i = Lmin; i < Lmax; i++)
            {
            int category;
            int len = 1;
            if (Feptr >= mb->end_subject)
              {
              SCHECK_PARTIAL();
              break;
              }
            GETCHARLENTEST(fc, Feptr, len);
            category = UCD_CATEGORY(fc);
            if ((category == ucp_L || category == ucp_N) == notmatch)
              break;
            Feptr+= len;
            }
          break;

          /* Perl space used to exclude VT, but from Perl 5.18 it is included,
          which means that Perl space and POSIX space are now identical. PCRE
          was changed at release 8.34. */

          case PT_SPACE:    /* Perl space */
          case PT_PXSPACE:  /* POSIX space */
          for (i = Lmin; i < Lmax; i++)
            {
            int len = 1;
            if (Feptr >= mb->end_subject)
              {
              SCHECK_PARTIAL();
              break;
              }
            GETCHARLENTEST(fc, Feptr, len);
            switch(fc)
              {
              HSPACE_CASES:
              VSPACE_CASES:
              if (notmatch) goto ENDLOOP99;  /* Break the loop */
              break;

              default:
              if ((UCD_CATEGORY(fc) == ucp_Z) == notmatch)
                goto ENDLOOP99;   /* Break the loop */
              break;
              }
            Feptr+= len;
            }
          ENDLOOP99:
          break;

          case PT_WORD:
          for (i = Lmin; i < Lmax; i++)
            {
            int chartype, category;
            int len = 1;
            if (Feptr >= mb->end_subject)
              {
              SCHECK_PARTIAL();
              break;
              }
            GETCHARLENTEST(fc, Feptr, len);
            chartype = UCD_CHARTYPE(fc);
            category = PRIV(ucp_gentype)[chartype];
            if ((category == ucp_L ||
                 category == ucp_N ||
                 chartype == ucp_Mn ||
                 chartype == ucp_Pc) == notmatch)
              break;
            Feptr+= len;
            }
          break;

          case PT_CLIST:
          for (i = Lmin; i < Lmax; i++)
            {
            const uint32_t *cp;
            int len = 1;
            if (Feptr >= mb->end_subject)
              {
              SCHECK_PARTIAL();
              break;
              }
            GETCHARLENTEST(fc, Feptr, len);
#if PCRE2_CODE_UNIT_WIDTH == 32
            if (fc > MAX_UTF_CODE_POINT)
              {
              if (!notmatch) goto GOT_MAX;
              }
            else
#endif
              {
              cp = PRIV(ucd_caseless_sets) + Lpropvalue;
              for (;;)
                {
                if (fc < *cp)
                  { if (notmatch) break; else goto GOT_MAX; }
                if (fc == *cp++)
                  { if (notmatch) goto GOT_MAX; else break; }
                }
              }

            Feptr += len;
            }
          GOT_MAX:
          break;

          case PT_UCNC:
          for (i = Lmin; i < Lmax; i++)
            {
            int len = 1;
            if (Feptr >= mb->end_subject)
              {
              SCHECK_PARTIAL();
              break;
              }
            GETCHARLENTEST(fc, Feptr, len);
            if ((fc == CHAR_DOLLAR_SIGN || fc == CHAR_COMMERCIAL_AT ||
                 fc == CHAR_GRAVE_ACCENT || (fc >= 0xa0 && fc <= 0xd7ff) ||
                 fc >= 0xe000) == notmatch)
              break;
            Feptr += len;
            }
          break;

          case PT_BIDICL:
          for (i = Lmin; i < Lmax; i++)
            {
            int len = 1;
            if (Feptr >= mb->end_subject)
              {
              SCHECK_PARTIAL();
              break;
              }
            GETCHARLENTEST(fc, Feptr, len);
            if ((UCD_BIDICLASS(fc) == Lpropvalue) == notmatch) break;
            Feptr+= len;
            }
          break;

          case PT_BOOL:
          for (i = Lmin; i < Lmax; i++)
            {
            BOOL ok;
            const ucd_record *prop;
            int len = 1;
            if (Feptr >= mb->end_subject)
              {
              SCHECK_PARTIAL();
              break;
              }
            GETCHARLENTEST(fc, Feptr, len);
            prop = GET_UCD(fc);
            ok = MAPBIT(PRIV(ucd_boolprop_sets) +
              UCD_BPROPS_PROP(prop), Lpropvalue) != 0;
            if (ok == notmatch) break;
            Feptr+= len;
            }
          break;

          default:
          PCRE2_DEBUG_UNREACHABLE();
          return PCRE2_ERROR_INTERNAL;
          }

        /* Feptr is now past the end of the maximum run */

        if (reptype == REPTYPE_POS) continue;    /* No backtracking */

        /* After \C in UTF mode, Lstart_eptr might be in the middle of a
        Unicode character. Use <= Lstart_eptr to ensure backtracking doesn't
        go too far. */

        for(;;)
          {
          if (Feptr <= Lstart_eptr) break;
          RMATCH(Fecode, RM221);
          if (rrc != MATCH_NOMATCH) RRETURN(rrc);
          Feptr--;
          if (utf) BACKCHAR(Feptr);
          }
        }

      /* Match extended Unicode grapheme clusters. We will get here only if the
      support is in the binary; otherwise a compile-time error occurs. */

      else if (Lctype == OP_EXTUNI)
        {
        for (i = Lmin; i < Lmax; i++)
          {
          if (Feptr >= mb->end_subject)
            {
            SCHECK_PARTIAL();
            break;
            }
          else
            {
            GETCHARINCTEST(fc, Feptr);
            Feptr = PRIV(extuni)(fc, Feptr, mb->start_subject, mb->end_subject,
              utf, NULL);
            }
          CHECK_PARTIAL();
          }

        /* Feptr is now past the end of the maximum run */

        if (reptype == REPTYPE_POS) continue;    /* No backtracking */

        /* We use <= Lstart_eptr rather than == Lstart_eptr to detect the start
        of the run while backtracking because the use of \C in UTF mode can
        cause BACKCHAR to move back past Lstart_eptr. This is just palliative;
        the use of \C in UTF mode is fraught with danger. */

        for(;;)
          {
          int lgb, rgb;
          PCRE2_SPTR fptr;

          if (Feptr <= Lstart_eptr) break;   /* At start of char run */
          RMATCH(Fecode, RM219);
          if (rrc != MATCH_NOMATCH) RRETURN(rrc);

          /* Backtracking over an extended grapheme cluster involves inspecting
          the previous two characters (if present) to see if a break is
          permitted between them. */

          Feptr--;
          if (!utf) fc = *Feptr; else
            {
            BACKCHAR(Feptr);
            GETCHAR(fc, Feptr);
            }
          rgb = UCD_GRAPHBREAK(fc);

          for (;;)
            {
            if (Feptr <= Lstart_eptr) break;   /* At start of char run */
            fptr = Feptr - 1;
            if (!utf) fc = *fptr; else
              {
              BACKCHAR(fptr);
              GETCHAR(fc, fptr);
              }
            lgb = UCD_GRAPHBREAK(fc);
            if ((PRIV(ucp_gbtable)[lgb] & (1u << rgb)) == 0) break;
            Feptr = fptr;
            rgb = lgb;
            }
          }
        }

      else
#endif   /* SUPPORT_UNICODE */

#ifdef SUPPORT_UNICODE
      if (utf)
        {
        switch(Lctype)
          {
          case OP_ANY:
          for (i = Lmin; i < Lmax; i++)
            {
            if (Feptr >= mb->end_subject)
              {
              SCHECK_PARTIAL();
              break;
              }
            if (IS_NEWLINE(Feptr)) break;
            if (mb->partial != 0 &&    /* Take care with CRLF partial */
                Feptr + 1 >= mb->end_subject &&
                NLBLOCK->nltype == NLTYPE_FIXED &&
                NLBLOCK->nllen == 2 &&
                UCHAR21(Feptr) == NLBLOCK->nl[0])
              {
              mb->hitend = TRUE;
              if (mb->partial > 1) return PCRE2_ERROR_PARTIAL;
              }
            Feptr++;
            ACROSSCHAR(Feptr < mb->end_subject, Feptr, Feptr++);
            }
          break;

          case OP_ALLANY:
          if (Lmax < UINT32_MAX)
            {
            for (i = Lmin; i < Lmax; i++)
              {
              if (Feptr >= mb->end_subject)
                {
                SCHECK_PARTIAL();
                break;
                }
              Feptr++;
              ACROSSCHAR(Feptr < mb->end_subject, Feptr, Feptr++);
              }
            }
          else
            {
            Feptr = mb->end_subject;   /* Unlimited UTF-8 repeat */
            SCHECK_PARTIAL();
            }
          break;

          /* The "byte" (i.e. "code unit") case is the same as non-UTF */

          case OP_ANYBYTE:
          fc = Lmax - Lmin;
          if (fc > (uint32_t)(mb->end_subject - Feptr))
            {
            Feptr = mb->end_subject;
            SCHECK_PARTIAL();
            }
          else Feptr += fc;
          break;

          case OP_ANYNL:
          for (i = Lmin; i < Lmax; i++)
            {
            int len = 1;
            if (Feptr >= mb->end_subject)
              {
              SCHECK_PARTIAL();
              break;
              }
            GETCHARLEN(fc, Feptr, len);
            if (fc == CHAR_CR)
              {
              if (++Feptr >= mb->end_subject) break;
              if (UCHAR21(Feptr) == CHAR_LF) Feptr++;
              }
            else
              {
              if (fc != CHAR_LF &&
                  (mb->bsr_convention == PCRE2_BSR_ANYCRLF ||
                   (fc != CHAR_VT && fc != CHAR_FF && fc != CHAR_NEL
#ifndef EBCDIC
                    && fc != 0x2028 && fc != 0x2029
#endif  /* Not EBCDIC */
                    )))
                break;
              Feptr += len;
              }
            }
          break;

          case OP_NOT_HSPACE:
          case OP_HSPACE:
          for (i = Lmin; i < Lmax; i++)
            {
            BOOL gotspace;
            int len = 1;
            if (Feptr >= mb->end_subject)
              {
              SCHECK_PARTIAL();
              break;
              }
            GETCHARLEN(fc, Feptr, len);
            switch(fc)
              {
              HSPACE_CASES: gotspace = TRUE; break;
              default: gotspace = FALSE; break;
              }
            if (gotspace == (Lctype == OP_NOT_HSPACE)) break;
            Feptr += len;
            }
          break;

          case OP_NOT_VSPACE:
          case OP_VSPACE:
          for (i = Lmin; i < Lmax; i++)
            {
            BOOL gotspace;
            int len = 1;
            if (Feptr >= mb->end_subject)
              {
              SCHECK_PARTIAL();
              break;
              }
            GETCHARLEN(fc, Feptr, len);
            switch(fc)
              {
              VSPACE_CASES: gotspace = TRUE; break;
              default: gotspace = FALSE; break;
              }
            if (gotspace == (Lctype == OP_NOT_VSPACE)) break;
            Feptr += len;
            }
          break;

          case OP_NOT_DIGIT:
          for (i = Lmin; i < Lmax; i++)
            {
            int len = 1;
            if (Feptr >= mb->end_subject)
              {
              SCHECK_PARTIAL();
              break;
              }
            GETCHARLEN(fc, Feptr, len);
            if (fc < 256 && (mb->ctypes[fc] & ctype_digit) != 0) break;
            Feptr+= len;
            }
          break;

          case OP_DIGIT:
          for (i = Lmin; i < Lmax; i++)
            {
            int len = 1;
            if (Feptr >= mb->end_subject)
              {
              SCHECK_PARTIAL();
              break;
              }
            GETCHARLEN(fc, Feptr, len);
            if (fc >= 256 ||(mb->ctypes[fc] & ctype_digit) == 0) break;
            Feptr+= len;
            }
          break;

          case OP_NOT_WHITESPACE:
          for (i = Lmin; i < Lmax; i++)
            {
            int len = 1;
            if (Feptr >= mb->end_subject)
              {
              SCHECK_PARTIAL();
              break;
              }
            GETCHARLEN(fc, Feptr, len);
            if (fc < 256 && (mb->ctypes[fc] & ctype_space) != 0) break;
            Feptr+= len;
            }
          break;

          case OP_WHITESPACE:
          for (i = Lmin; i < Lmax; i++)
            {
            int len = 1;
            if (Feptr >= mb->end_subject)
              {
              SCHECK_PARTIAL();
              break;
              }
            GETCHARLEN(fc, Feptr, len);
            if (fc >= 256 ||(mb->ctypes[fc] & ctype_space) == 0) break;
            Feptr+= len;
            }
          break;

          case OP_NOT_WORDCHAR:
          for (i = Lmin; i < Lmax; i++)
            {
            int len = 1;
            if (Feptr >= mb->end_subject)
              {
              SCHECK_PARTIAL();
              break;
              }
            GETCHARLEN(fc, Feptr, len);
            if (fc < 256 && (mb->ctypes[fc] & ctype_word) != 0) break;
            Feptr+= len;
            }
          break;

          case OP_WORDCHAR:
          for (i = Lmin; i < Lmax; i++)
            {
            int len = 1;
            if (Feptr >= mb->end_subject)
              {
              SCHECK_PARTIAL();
              break;
              }
            GETCHARLEN(fc, Feptr, len);
            if (fc >= 256 || (mb->ctypes[fc] & ctype_word) == 0) break;
            Feptr+= len;
            }
          break;

          default:
          PCRE2_DEBUG_UNREACHABLE();
          return PCRE2_ERROR_INTERNAL;
          }

        if (reptype == REPTYPE_POS) continue;    /* No backtracking */

        /* After \C in UTF mode, Lstart_eptr might be in the middle of a
        Unicode character. Use <= Lstart_eptr to ensure backtracking doesn't go
        too far. */

        for(;;)
          {
          if (Feptr <= Lstart_eptr) break;
          RMATCH(Fecode, RM220);
          if (rrc != MATCH_NOMATCH) RRETURN(rrc);
          Feptr--;
          BACKCHAR(Feptr);
          if (Lctype == OP_ANYNL && Feptr > Lstart_eptr &&
              UCHAR21(Feptr) == CHAR_NL && UCHAR21(Feptr - 1) == CHAR_CR)
            Feptr--;
          }
        }
      else
#endif  /* SUPPORT_UNICODE */

      /* Not UTF mode */
        {
        switch(Lctype)
          {
          case OP_ANY:
          for (i = Lmin; i < Lmax; i++)
            {
            if (Feptr >= mb->end_subject)
              {
              SCHECK_PARTIAL();
              break;
              }
            if (IS_NEWLINE(Feptr)) break;
            if (mb->partial != 0 &&    /* Take care with CRLF partial */
                Feptr + 1 >= mb->end_subject &&
                NLBLOCK->nltype == NLTYPE_FIXED &&
                NLBLOCK->nllen == 2 &&
                *Feptr == NLBLOCK->nl[0])
              {
              mb->hitend = TRUE;
              if (mb->partial > 1) return PCRE2_ERROR_PARTIAL;
              }
            Feptr++;
            }
          break;

          case OP_ALLANY:
          case OP_ANYBYTE:
          fc = Lmax - Lmin;
          if (fc > (uint32_t)(mb->end_subject - Feptr))
            {
            Feptr = mb->end_subject;
            SCHECK_PARTIAL();
            }
          else Feptr += fc;
          break;

          case OP_ANYNL:
          for (i = Lmin; i < Lmax; i++)
            {
            if (Feptr >= mb->end_subject)
              {
              SCHECK_PARTIAL();
              break;
              }
            fc = *Feptr;
            if (fc == CHAR_CR)
              {
              if (++Feptr >= mb->end_subject) break;
              if (*Feptr == CHAR_LF) Feptr++;
              }
            else
              {
              if (fc != CHAR_LF && (mb->bsr_convention == PCRE2_BSR_ANYCRLF ||
                 (fc != CHAR_VT && fc != CHAR_FF && fc != CHAR_NEL
#if PCRE2_CODE_UNIT_WIDTH != 8
                 && fc != 0x2028 && fc != 0x2029
#endif
                 ))) break;
              Feptr++;
              }
            }
          break;

          case OP_NOT_HSPACE:
          for (i = Lmin; i < Lmax; i++)
            {
            if (Feptr >= mb->end_subject)
              {
              SCHECK_PARTIAL();
              break;
              }
            switch(*Feptr)
              {
              default: Feptr++; break;
              HSPACE_BYTE_CASES:
#if PCRE2_CODE_UNIT_WIDTH != 8
              HSPACE_MULTIBYTE_CASES:
#endif
              goto ENDLOOP00;
              }
            }
          ENDLOOP00:
          break;

          case OP_HSPACE:
          for (i = Lmin; i < Lmax; i++)
            {
            if (Feptr >= mb->end_subject)
              {
              SCHECK_PARTIAL();
              break;
              }
            switch(*Feptr)
              {
              default: goto ENDLOOP01;
              HSPACE_BYTE_CASES:
#if PCRE2_CODE_UNIT_WIDTH != 8
              HSPACE_MULTIBYTE_CASES:
#endif
              Feptr++; break;
              }
            }
          ENDLOOP01:
          break;

          case OP_NOT_VSPACE:
          for (i = Lmin; i < Lmax; i++)
            {
            if (Feptr >= mb->end_subject)
              {
              SCHECK_PARTIAL();
              break;
              }
            switch(*Feptr)
              {
              default: Feptr++; break;
              VSPACE_BYTE_CASES:
#if PCRE2_CODE_UNIT_WIDTH != 8
              VSPACE_MULTIBYTE_CASES:
#endif
              goto ENDLOOP02;
              }
            }
          ENDLOOP02:
          break;

          case OP_VSPACE:
          for (i = Lmin; i < Lmax; i++)
            {
            if (Feptr >= mb->end_subject)
              {
              SCHECK_PARTIAL();
              break;
              }
            switch(*Feptr)
              {
              default: goto ENDLOOP03;
              VSPACE_BYTE_CASES:
#if PCRE2_CODE_UNIT_WIDTH != 8
              VSPACE_MULTIBYTE_CASES:
#endif
              Feptr++; break;
              }
            }
          ENDLOOP03:
          break;

          case OP_NOT_DIGIT:
          for (i = Lmin; i < Lmax; i++)
            {
            if (Feptr >= mb->end_subject)
              {
              SCHECK_PARTIAL();
              break;
              }
            if (MAX_255(*Feptr) && (mb->ctypes[*Feptr] & ctype_digit) != 0)
              break;
            Feptr++;
            }
          break;

          case OP_DIGIT:
          for (i = Lmin; i < Lmax; i++)
            {
            if (Feptr >= mb->end_subject)
              {
              SCHECK_PARTIAL();
              break;
              }
            if (!MAX_255(*Feptr) || (mb->ctypes[*Feptr] & ctype_digit) == 0)
              break;
            Feptr++;
            }
          break;

          case OP_NOT_WHITESPACE:
          for (i = Lmin; i < Lmax; i++)
            {
            if (Feptr >= mb->end_subject)
              {
              SCHECK_PARTIAL();
              break;
              }
            if (MAX_255(*Feptr) && (mb->ctypes[*Feptr] & ctype_space) != 0)
              break;
            Feptr++;
            }
          break;

          case OP_WHITESPACE:
          for (i = Lmin; i < Lmax; i++)
            {
            if (Feptr >= mb->end_subject)
              {
              SCHECK_PARTIAL();
              break;
              }
            if (!MAX_255(*Feptr) || (mb->ctypes[*Feptr] & ctype_space) == 0)
              break;
            Feptr++;
            }
          break;

          case OP_NOT_WORDCHAR:
          for (i = Lmin; i < Lmax; i++)
            {
            if (Feptr >= mb->end_subject)
              {
              SCHECK_PARTIAL();
              break;
              }
            if (MAX_255(*Feptr) && (mb->ctypes[*Feptr] & ctype_word) != 0)
              break;
            Feptr++;
            }
          break;

          case OP_WORDCHAR:
          for (i = Lmin; i < Lmax; i++)
            {
            if (Feptr >= mb->end_subject)
              {
              SCHECK_PARTIAL();
              break;
              }
            if (!MAX_255(*Feptr) || (mb->ctypes[*Feptr] & ctype_word) == 0)
              break;
            Feptr++;
            }
          break;

          default:
          PCRE2_DEBUG_UNREACHABLE();
          return PCRE2_ERROR_INTERNAL;
          }

        if (reptype == REPTYPE_POS) continue;    /* No backtracking */

        for (;;)
          {
          if (Feptr == Lstart_eptr) break;
          RMATCH(Fecode, RM34);
          if (rrc != MATCH_NOMATCH) RRETURN(rrc);
          Feptr--;
          if (Lctype == OP_ANYNL && Feptr > Lstart_eptr && *Feptr == CHAR_LF &&
              Feptr[-1] == CHAR_CR) Feptr--;
          }
        }
      }
    break;  /* End of repeat character type processing */

#undef Lstart_eptr
#undef Lmin
#undef Lmax
#undef Lctype
#undef Lpropvalue


    /* ===================================================================== */
    /* Match a back reference, possibly repeatedly. Look past the end of the
    item to see if there is repeat information following. The OP_REF and
    OP_REFI opcodes are used for a reference to a numbered group or to a
    non-duplicated named group. For a duplicated named group, OP_DNREF and
    OP_DNREFI are used. In this case we must scan the list of groups to which
    the name refers, and use the first one that is set. */

#define Lmin      F->temp_32[0]
#define Lmax      F->temp_32[1]
#define Lcaseless F->temp_32[2]
#define Lcaseopts F->temp_32[3]
#define Lstart    F->temp_sptr[0]
#define Loffset   F->temp_size

    case OP_DNREF:
    case OP_DNREFI:
    Lcaseless = (Fop == OP_DNREFI);
    Lcaseopts = (Fop == OP_DNREFI)? Fecode[1 + 2*IMM2_SIZE] : 0;
      {
      int count = GET2(Fecode, 1+IMM2_SIZE);
      PCRE2_SPTR slot = mb->name_table + GET2(Fecode, 1) * mb->name_entry_size;
      Fecode += 1 + 2*IMM2_SIZE + (Fop == OP_DNREFI? 1 : 0);

      while (count-- > 0)
        {
        Loffset = (GET2(slot, 0) << 1) - 2;
        if (Loffset < Foffset_top && Fovector[Loffset] != PCRE2_UNSET) break;
        slot += mb->name_entry_size;
        }
      }
    goto REF_REPEAT;

    case OP_REF:
    case OP_REFI:
    Lcaseless = (Fop == OP_REFI);
    Lcaseopts = (Fop == OP_REFI)? Fecode[1 + IMM2_SIZE] : 0;
    Loffset = (GET2(Fecode, 1) << 1) - 2;
    Fecode += 1 + IMM2_SIZE + (Fop == OP_REFI? 1 : 0);

    /* Set up for repetition, or handle the non-repeated case. The maximum and
    minimum must be in the heap frame, but as they are short-term values, we
    use temporary fields. */

    REF_REPEAT:
    switch (*Fecode)
      {
      case OP_CRSTAR:
      case OP_CRMINSTAR:
      case OP_CRPLUS:
      case OP_CRMINPLUS:
      case OP_CRQUERY:
      case OP_CRMINQUERY:
      fc = *Fecode++ - OP_CRSTAR;
      Lmin = rep_min[fc];
      Lmax = rep_max[fc];
      reptype = rep_typ[fc];
      break;

      case OP_CRRANGE:
      case OP_CRMINRANGE:
      Lmin = GET2(Fecode, 1);
      Lmax = GET2(Fecode, 1 + IMM2_SIZE);
      reptype = rep_typ[*Fecode - OP_CRSTAR];
      if (Lmax == 0) Lmax = UINT32_MAX;  /* Max 0 => infinity */
      Fecode += 1 + 2 * IMM2_SIZE;
      break;

      default:                  /* No repeat follows */
        {
        rrc = match_ref(Loffset, Lcaseless, Lcaseopts, F, mb, &length);
        if (rrc != 0)
          {
          if (rrc > 0) Feptr = mb->end_subject;   /* Partial match */
          CHECK_PARTIAL();
          RRETURN(MATCH_NOMATCH);
          }
        }
      Feptr += length;
      continue;              /* With the main loop */
      }

    /* Handle repeated back references. If a set group has length zero, just
    continue with the main loop, because it matches however many times. For an
    unset reference, if the minimum is zero, we can also just continue. We can
    also continue if PCRE2_MATCH_UNSET_BACKREF is set, because this makes unset
    group behave as a zero-length group. For any other unset cases, carrying
    on will result in NOMATCH. */

    if (Loffset < Foffset_top && Fovector[Loffset] != PCRE2_UNSET)
      {
      if (Fovector[Loffset] == Fovector[Loffset + 1]) continue;
      }
    else  /* Group is not set */
      {
      if (Lmin == 0 || (mb->poptions & PCRE2_MATCH_UNSET_BACKREF) != 0)
        continue;
      }

    /* First, ensure the minimum number of matches are present. */

    for (i = 1; i <= Lmin; i++)
      {
      PCRE2_SIZE slength;
      rrc = match_ref(Loffset, Lcaseless, Lcaseopts, F, mb, &slength);
      if (rrc != 0)
        {
        if (rrc > 0) Feptr = mb->end_subject;   /* Partial match */
        CHECK_PARTIAL();
        RRETURN(MATCH_NOMATCH);
        }
      Feptr += slength;
      }

    /* If min = max, we are done. They are not both allowed to be zero. */

    if (Lmin == Lmax) continue;

    /* If minimizing, keep trying and advancing the pointer. */

    if (reptype == REPTYPE_MIN)
      {
      for (;;)
        {
        PCRE2_SIZE slength;
        RMATCH(Fecode, RM20);
        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
        if (Lmin++ >= Lmax) RRETURN(MATCH_NOMATCH);
        rrc = match_ref(Loffset, Lcaseless, Lcaseopts, F, mb, &slength);
        if (rrc != 0)
          {
          if (rrc > 0) Feptr = mb->end_subject;   /* Partial match */
          CHECK_PARTIAL();
          RRETURN(MATCH_NOMATCH);
          }
        Feptr += slength;
        }

      PCRE2_UNREACHABLE(); /* Control never reaches here */
      }

    /* If maximizing, find the longest string and work backwards, as long as
    the matched lengths for each iteration are the same. */

    else
      {
      BOOL samelengths = TRUE;
      Lstart = Feptr;     /* Starting position */
      Flength = Fovector[Loffset+1] - Fovector[Loffset];

      for (i = Lmin; i < Lmax; i++)
        {
        PCRE2_SIZE slength;
        rrc = match_ref(Loffset, Lcaseless, Lcaseopts, F, mb, &slength);
        if (rrc != 0)
          {
          /* Can't use CHECK_PARTIAL because we don't want to update Feptr in
          the soft partial matching case. */

          if (rrc > 0 && mb->partial != 0 &&
              mb->end_subject > mb->start_used_ptr)
            {
            mb->hitend = TRUE;
            if (mb->partial > 1) return PCRE2_ERROR_PARTIAL;
            }
          break;
          }

        if (slength != Flength) samelengths = FALSE;
        Feptr += slength;
        }

      /* If the length matched for each repetition is the same as the length of
      the captured group, we can easily work backwards. This is the normal
      case. However, in caseless UTF-8 mode there are pairs of case-equivalent
      characters whose lengths (in terms of code units) differ. However, this
      is very rare, so we handle it by re-matching fewer and fewer times. */

      if (samelengths)
        {
        while (Feptr >= Lstart)
          {
          RMATCH(Fecode, RM21);
          if (rrc != MATCH_NOMATCH) RRETURN(rrc);
          Feptr -= Flength;
          }
        }

      /* The rare case of non-matching lengths. Re-scan the repetition for each
      iteration. We know that match_ref() will succeed every time. */

      else
        {
        Lmax = i;
        for (;;)
          {
          RMATCH(Fecode, RM22);
          if (rrc != MATCH_NOMATCH) RRETURN(rrc);
          if (Feptr == Lstart) break; /* Failed after minimal repetition */
          Feptr = Lstart;
          Lmax--;
          for (i = Lmin; i < Lmax; i++)
            {
            PCRE2_SIZE slength;
            (void)match_ref(Loffset, Lcaseless, Lcaseopts, F, mb, &slength);
            Feptr += slength;
            }
          }
        }

      RRETURN(MATCH_NOMATCH);
      }

    PCRE2_DEBUG_UNREACHABLE(); /* Control should never reach here */

#undef Lcaseless
#undef Lmin
#undef Lmax
#undef Lstart
#undef Loffset



/* ========================================================================= */
/*           Opcodes for the start of various parenthesized items            */
/* ========================================================================= */

    /* In all cases, if the result of RMATCH() is MATCH_THEN, check whether the
    (*THEN) is within the current branch by comparing the address of OP_THEN
    that is passed back with the end of the branch. If (*THEN) is within the
    current branch, and the branch is one of two or more alternatives (it
    either starts or ends with OP_ALT), we have reached the limit of THEN's
    action, so convert the return code to NOMATCH, which will cause normal
    backtracking to happen from now on. Otherwise, THEN is passed back to an
    outer alternative. This implements Perl's treatment of parenthesized
    groups, where a group not containing | does not affect the current
    alternative, that is, (X) is NOT the same as (X|(*F)). */


    /* ===================================================================== */
    /* BRAZERO, BRAMINZERO and SKIPZERO occur just before a non-possessive
    bracket group, indicating that it may occur zero times. It may repeat
    infinitely, or not at all - i.e. it could be ()* or ()? or even (){0} in
    the pattern. Brackets with fixed upper repeat limits are compiled as a
    number of copies, with the optional ones preceded by BRAZERO or BRAMINZERO.
    Possessive groups with possible zero repeats are preceded by BRAPOSZERO. */

#define Lnext_ecode F->temp_sptr[0]

    case OP_BRAZERO:
    Lnext_ecode = Fecode + 1;
    RMATCH(Lnext_ecode, RM9);
    if (rrc != MATCH_NOMATCH) RRETURN(rrc);
    do Lnext_ecode += GET(Lnext_ecode, 1); while (*Lnext_ecode == OP_ALT);
    Fecode = Lnext_ecode + 1 + LINK_SIZE;
    break;

    case OP_BRAMINZERO:
    Lnext_ecode = Fecode + 1;
    do Lnext_ecode += GET(Lnext_ecode, 1); while (*Lnext_ecode == OP_ALT);
    RMATCH(Lnext_ecode + 1 + LINK_SIZE, RM10);
    if (rrc != MATCH_NOMATCH) RRETURN(rrc);
    Fecode++;
    break;

#undef Lnext_ecode

    case OP_SKIPZERO:
    Fecode++;
    do Fecode += GET(Fecode,1); while (*Fecode == OP_ALT);
    Fecode += 1 + LINK_SIZE;
    break;


    /* ===================================================================== */
    /* Handle possessive brackets with an unlimited repeat. The end of these
    brackets will always be OP_KETRPOS, which returns MATCH_KETRPOS without
    going further in the pattern. */

#define Lframe_type    F->temp_32[0]
#define Lmatched_once  F->temp_32[1]
#define Lzero_allowed  F->temp_32[2]
#define Lstart_eptr    F->temp_sptr[0]
#define Lstart_group   F->temp_sptr[1]

    case OP_BRAPOSZERO:
    Lzero_allowed = TRUE;                /* Zero repeat is allowed */
    Fecode += 1;
    if (*Fecode == OP_CBRAPOS || *Fecode == OP_SCBRAPOS)
      goto POSSESSIVE_CAPTURE;
    goto POSSESSIVE_NON_CAPTURE;

    case OP_BRAPOS:
    case OP_SBRAPOS:
    Lzero_allowed = FALSE;               /* Zero repeat not allowed */

    POSSESSIVE_NON_CAPTURE:
    Lframe_type = GF_NOCAPTURE;          /* Remembered frame type */
    goto POSSESSIVE_GROUP;

    case OP_CBRAPOS:
    case OP_SCBRAPOS:
    Lzero_allowed = FALSE;               /* Zero repeat not allowed */

    POSSESSIVE_CAPTURE:
    number = GET2(Fecode, 1+LINK_SIZE);
    Lframe_type = GF_CAPTURE | number;   /* Remembered frame type */

    POSSESSIVE_GROUP:
    Lmatched_once = FALSE;               /* Never matched */
    Lstart_group = Fecode;               /* Start of this group */

    for (;;)
      {
      Lstart_eptr = Feptr;               /* Position at group start */
      group_frame_type = Lframe_type;
      RMATCH(Fecode + PRIV(OP_lengths)[*Fecode], RM8);
      if (rrc == MATCH_KETRPOS)
        {
        Lmatched_once = TRUE;            /* Matched at least once */
        if (Feptr == Lstart_eptr)        /* Empty match; skip to end */
          {
          do Fecode += GET(Fecode, 1); while (*Fecode == OP_ALT);
          break;
          }

        Fecode = Lstart_group;
        continue;
        }

      /* See comment above about handling THEN. */

      if (rrc == MATCH_THEN)
        {
        PCRE2_SPTR next_ecode = Fecode + GET(Fecode,1);
        if (mb->verb_ecode_ptr < next_ecode &&
            (*Fecode == OP_ALT || *next_ecode == OP_ALT))
          rrc = MATCH_NOMATCH;
        }

      if (rrc != MATCH_NOMATCH) RRETURN(rrc);
      Fecode += GET(Fecode, 1);
      if (*Fecode != OP_ALT) break;
      }

    /* Success if matched something or zero repeat allowed */

    if (Lmatched_once || Lzero_allowed)
      {
      Fecode += 1 + LINK_SIZE;
      break;
      }

    RRETURN(MATCH_NOMATCH);

#undef Lmatched_once
#undef Lzero_allowed
#undef Lframe_type
#undef Lstart_eptr
#undef Lstart_group


    /* ===================================================================== */
    /* Handle non-capturing brackets that cannot match an empty string. When we
    get to the final alternative within the brackets, as long as there are no
    THEN's in the pattern, we can optimize by not recording a new backtracking
    point. (Ideally we should test for a THEN within this group, but we don't
    have that information.) Don't do this if we are at the very top level,
    however, because that would make handling assertions and once-only brackets
    messier when there is nothing to go back to. */

#define Lframe_type F->temp_32[0]     /* Set for all that use GROUPLOOP */
#define Lnext_branch F->temp_sptr[0]  /* Used only in OP_BRA handling */

    case OP_BRA:
    if (mb->hasthen || Frdepth == 0)
      {
      Lframe_type = 0;
      goto GROUPLOOP;
      }

    for (;;)
      {
      Lnext_branch = Fecode + GET(Fecode, 1);
      if (*Lnext_branch != OP_ALT) break;

      /* This is never the final branch. We do not need to test for MATCH_THEN
      here because this code is not used when there is a THEN in the pattern. */

      RMATCH(Fecode + PRIV(OP_lengths)[*Fecode], RM1);
      if (rrc != MATCH_NOMATCH) RRETURN(rrc);
      Fecode = Lnext_branch;
      }

    /* Hit the start of the final branch. Continue at this level. */

    Fecode += PRIV(OP_lengths)[*Fecode];
    break;

#undef Lnext_branch


    /* ===================================================================== */
    /* Handle a capturing bracket, other than those that are possessive with an
    unlimited repeat. */

    case OP_CBRA:
    case OP_SCBRA:
    Lframe_type = GF_CAPTURE | GET2(Fecode, 1+LINK_SIZE);
    goto GROUPLOOP;


    /* ===================================================================== */
    /* Atomic groups and non-capturing brackets that can match an empty string
    must record a backtracking point and also set up a chained frame. */

    case OP_ONCE:
    case OP_SCRIPT_RUN:
    case OP_SBRA:
    Lframe_type = GF_NOCAPTURE | Fop;

    GROUPLOOP:
    for (;;)
      {
      group_frame_type = Lframe_type;
      RMATCH(Fecode + PRIV(OP_lengths)[*Fecode], RM2);
      if (rrc == MATCH_THEN)
        {
        PCRE2_SPTR next_ecode = Fecode + GET(Fecode,1);
        if (mb->verb_ecode_ptr < next_ecode &&
            (*Fecode == OP_ALT || *next_ecode == OP_ALT))
          rrc = MATCH_NOMATCH;
        }
      if (rrc != MATCH_NOMATCH) RRETURN(rrc);
      Fecode += GET(Fecode, 1);
      if (*Fecode != OP_ALT) RRETURN(MATCH_NOMATCH);
      }
    PCRE2_UNREACHABLE(); /* Control never reaches here */

#undef Lframe_type


    /* ===================================================================== */
    /* Pattern recursion either matches the current regex, or some
    subexpression. The offset data is the offset to the starting bracket from
    the start of the whole pattern. This is so that it works from duplicated
    subpatterns. For a whole-pattern recursion, we have to infer the number
    zero. */

#define Lframe_type F->temp_32[0]
#define Lstart_branch F->temp_sptr[0]

    case OP_RECURSE:
    bracode = mb->start_code + GET(Fecode, 1);
    number = (bracode == mb->start_code)? 0 : GET2(bracode, 1 + LINK_SIZE);

    /* If we are already in a pattern recursion, check for repeating the same
    one without changing the subject pointer or the last referenced character
    in the subject. This should catch convoluted mutual recursions; some
    simple cases are caught at compile time. However, there are rare cases when
    this check needs to be turned off. In this case, actual recursion loops
    will be caught by the match or heap limits. */

    if (Fcurrent_recurse != RECURSE_UNSET)
      {
      offset = Flast_group_offset;
      while (offset != PCRE2_UNSET)
        {
        N = (heapframe *)((char *)match_data->heapframes + offset);
        P = (heapframe *)((char *)N - frame_size);
        if (N->group_frame_type == (GF_RECURSE | number))
          {
          if (Feptr == P->eptr && mb->last_used_ptr == P->recurse_last_used &&
               (mb->moptions & PCRE2_DISABLE_RECURSELOOP_CHECK) == 0)
            return PCRE2_ERROR_RECURSELOOP;
          break;
          }
        offset = P->last_group_offset;
        }
      }

    /* Remember the current last referenced character and then run the
    recursion branch by branch. */

    F->recurse_last_used = mb->last_used_ptr;
    Lstart_branch = bracode;
    Lframe_type = GF_RECURSE | number;

    for (;;)
      {
      PCRE2_SPTR next_ecode;

      group_frame_type = Lframe_type;
      RMATCH(Lstart_branch + PRIV(OP_lengths)[*Lstart_branch], RM11);
      next_ecode = Lstart_branch + GET(Lstart_branch,1);

      /* Handle backtracking verbs, which are defined in a range that can
      easily be tested for. PCRE does not allow THEN, SKIP, PRUNE or COMMIT to
      escape beyond a recursion; they cause a NOMATCH for the entire recursion.

      When one of these verbs triggers, the current recursion group number is
      recorded. If it matches the recursion we are processing, the verb
      happened within the recursion and we must deal with it. Otherwise it must
      have happened after the recursion completed, and so has to be passed
      back. See comment above about handling THEN. */

      if (rrc >= MATCH_BACKTRACK_MIN && rrc <= MATCH_BACKTRACK_MAX &&
          mb->verb_current_recurse == (Lframe_type ^ GF_RECURSE))
        {
        if (rrc == MATCH_THEN && mb->verb_ecode_ptr < next_ecode &&
            (*Lstart_branch == OP_ALT || *next_ecode == OP_ALT))
          rrc = MATCH_NOMATCH;
        else RRETURN(MATCH_NOMATCH);
        }

      /* Note that carrying on after (*ACCEPT) in a recursion is handled in the
      OP_ACCEPT code. Nothing needs to be done here. */

      if (rrc != MATCH_NOMATCH) RRETURN(rrc);
      Lstart_branch = next_ecode;
      if (*Lstart_branch != OP_ALT) RRETURN(MATCH_NOMATCH);
      }
    PCRE2_UNREACHABLE(); /* Control never reaches here */

#undef Lframe_type
#undef Lstart_branch


    /* ===================================================================== */
    /* Positive assertions are like other groups except that PCRE doesn't allow
    the effect of (*THEN) to escape beyond an assertion; it is therefore
    treated as NOMATCH. (*ACCEPT) is treated as successful assertion, with its
    captures and mark retained. Any other return is an error. */

#define Lframe_type  F->temp_32[0]

    case OP_ASSERT:
    case OP_ASSERTBACK:
    case OP_ASSERT_NA:
    case OP_ASSERTBACK_NA:
    Lframe_type = GF_NOCAPTURE | Fop;
    for (;;)
      {
      group_frame_type = Lframe_type;
      RMATCH(Fecode + PRIV(OP_lengths)[*Fecode], RM3);
      if (rrc == MATCH_ACCEPT)
        {
        memcpy(Fovector,
              (char *)assert_accept_frame + offsetof(heapframe, ovector),
              assert_accept_frame->offset_top * sizeof(PCRE2_SIZE));
        Foffset_top = assert_accept_frame->offset_top;
        Fmark = assert_accept_frame->mark;
        break;
        }
      if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
      Fecode += GET(Fecode, 1);
      if (*Fecode != OP_ALT) RRETURN(MATCH_NOMATCH);
      }

    do Fecode += GET(Fecode, 1); while (*Fecode == OP_ALT);
    Fecode += 1 + LINK_SIZE;
    break;

#undef Lframe_type


    /* ===================================================================== */
    /* Handle negative assertions. Loop for each non-matching branch as for
    positive assertions. */

#define Lframe_type  F->temp_32[0]

    case OP_ASSERT_NOT:
    case OP_ASSERTBACK_NOT:
    Lframe_type  = GF_NOCAPTURE | Fop;

    for (;;)
      {
      group_frame_type = Lframe_type;
      RMATCH(Fecode + PRIV(OP_lengths)[*Fecode], RM4);
      switch(rrc)
        {
        case MATCH_ACCEPT:   /* Assertion matched, therefore it fails. */
        case MATCH_MATCH:
        RRETURN (MATCH_NOMATCH);

        case MATCH_NOMATCH:  /* Branch failed, try next if present. */
        case MATCH_THEN:
        Fecode += GET(Fecode, 1);
        if (*Fecode != OP_ALT) goto ASSERT_NOT_FAILED;
        break;

        case MATCH_COMMIT:   /* Assertion forced to fail, therefore continue. */
        case MATCH_SKIP:
        case MATCH_PRUNE:
        do Fecode += GET(Fecode, 1); while (*Fecode == OP_ALT);
        goto ASSERT_NOT_FAILED;

        default:             /* Pass back any other return */
        RRETURN(rrc);
        }
      }

    /* None of the branches have matched or there was a backtrack to (*COMMIT),
    (*SKIP), (*PRUNE), or (*THEN) in the last branch. This is success for a
    negative assertion, so carry on. */

    ASSERT_NOT_FAILED:
    Fecode += 1 + LINK_SIZE;
    break;

#undef Lframe_type

    /* ===================================================================== */
    /* Handle scan substring operation. */

#define Lframe_type          F->temp_32[0]
#define Lextra_size          F->temp_32[1]
#define Lsaved_moptions      F->temp_32[2]
#define Lsaved_end_subject   F->temp_sptr[0]
#define Lsaved_eptr          F->temp_sptr[1]
#define Ltrue_end_extra      F->temp_size

    case OP_ASSERT_SCS:
      {
      PCRE2_SPTR ecode = Fecode + 1 + LINK_SIZE;
      uint32_t extra_size = 0;
      int count;
      PCRE2_SPTR slot;

      /* Disable compiler warning. */
      offset = 0;
      (void)offset;

      for (;;)
        {
        if (*ecode == OP_CREF)
          {
          extra_size += 1+IMM2_SIZE;
          offset = (GET2(ecode, 1) << 1) - 2;
          ecode += 1+IMM2_SIZE;
          if (offset < Foffset_top && Fovector[offset] != PCRE2_UNSET)
            goto SCS_OFFSET_FOUND;
          continue;
          }

        if (*ecode != OP_DNCREF) RRETURN(MATCH_NOMATCH);

        count = GET2(ecode, 1 + IMM2_SIZE);
        slot = mb->name_table + GET2(ecode, 1) * mb->name_entry_size;
        extra_size += 1+2*IMM2_SIZE;
        ecode += 1+2*IMM2_SIZE;

        while (count > 0)
          {
          offset = (GET2(slot, 0) << 1) - 2;
          if (offset < Foffset_top && Fovector[offset] != PCRE2_UNSET)
            goto SCS_OFFSET_FOUND;
          slot += mb->name_entry_size;
          count--;
          }
        }

      SCS_OFFSET_FOUND:

      /* Skip remaining options. */
      for (;;)
        {
        if (*ecode == OP_CREF)
          {
          extra_size += 1+IMM2_SIZE;
          ecode += 1+IMM2_SIZE;
          }
        else if (*ecode == OP_DNCREF)
          {
          extra_size += 1+2*IMM2_SIZE;
          ecode += 1+2*IMM2_SIZE;
          }
        else break;
        }

      Lextra_size = extra_size;
      }

    Lsaved_end_subject = mb->end_subject;
    Ltrue_end_extra = mb->true_end_subject - mb->end_subject;
    Lsaved_eptr = Feptr;
    Lsaved_moptions = mb->moptions;

    Feptr = mb->start_subject + Fovector[offset];
    mb->true_end_subject = mb->end_subject =
      mb->start_subject + Fovector[offset + 1];
    mb->moptions &= ~PCRE2_NOTEOL;

    Lframe_type = GF_NOCAPTURE | Fop;
    for (;;)
      {
      group_frame_type = Lframe_type;
      RMATCH(Fecode + 1 + LINK_SIZE + Lextra_size, RM38);
      if (rrc == MATCH_ACCEPT)
        {
        memcpy(Fovector,
              (char *)assert_accept_frame + offsetof(heapframe, ovector),
              assert_accept_frame->offset_top * sizeof(PCRE2_SIZE));
        Foffset_top = assert_accept_frame->offset_top;
        Fmark = assert_accept_frame->mark;
        mb->end_subject = Lsaved_end_subject;
        mb->true_end_subject = mb->end_subject + Ltrue_end_extra;
        mb->moptions = Lsaved_moptions;
        break;
        }

      if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN)
        {
        mb->end_subject = Lsaved_end_subject;
        mb->true_end_subject = mb->end_subject + Ltrue_end_extra;
        mb->moptions = Lsaved_moptions;
        RRETURN(rrc);
        }

      Fecode += GET(Fecode, 1);
      if (*Fecode != OP_ALT)
        {
        mb->end_subject = Lsaved_end_subject;
        mb->true_end_subject = mb->end_subject + Ltrue_end_extra;
        mb->moptions = Lsaved_moptions;
        RRETURN(MATCH_NOMATCH);
        }
      Lextra_size = 0;
      }

    do Fecode += GET(Fecode, 1); while (*Fecode == OP_ALT);
    Fecode += 1 + LINK_SIZE;
    Feptr = Lsaved_eptr;
    break;

#undef Lframe_type
#undef Lextra_size
#undef Lsaved_end_subject
#undef Lsaved_eptr
#undef Ltrue_end_extra
#undef Lsave_moptions

    /* ===================================================================== */
    /* The callout item calls an external function, if one is provided, passing
    details of the match so far. This is mainly for debugging, though the
    function is able to force a failure. */

    case OP_CALLOUT:
    case OP_CALLOUT_STR:
    rrc = do_callout(F, mb, &length);
    if (rrc > 0) RRETURN(MATCH_NOMATCH);
    if (rrc < 0) RRETURN(rrc);
    Fecode += length;
    break;


    /* ===================================================================== */
    /* Conditional group: compilation checked that there are no more than two
    branches. If the condition is false, skipping the first branch takes us
    past the end of the item if there is only one branch, but that's exactly
    what we want. */

    case OP_COND:
    case OP_SCOND:

    /* The variable Flength will be added to Fecode when the condition is
    false, to get to the second branch. Setting it to the offset to the ALT or
    KET, then incrementing Fecode achieves this effect. However, if the second
    branch is non-existent, we must point to the KET so that the end of the
    group is correctly processed. We now have Fecode pointing to the condition
    or callout. */

    Flength = GET(Fecode, 1);    /* Offset to the second branch */
    if (Fecode[Flength] != OP_ALT) Flength -= 1 + LINK_SIZE;
    Fecode += 1 + LINK_SIZE;     /* From this opcode */

    /* Because of the way auto-callout works during compile, a callout item is
    inserted between OP_COND and an assertion condition. Such a callout can
    also be inserted manually. */

    if (*Fecode == OP_CALLOUT || *Fecode == OP_CALLOUT_STR)
      {
      rrc = do_callout(F, mb, &length);
      if (rrc > 0) RRETURN(MATCH_NOMATCH);
      if (rrc < 0) RRETURN(rrc);

      /* Advance Fecode past the callout, so it now points to the condition. We
      must adjust Flength so that the value of Fecode+Flength is unchanged. */

      Fecode += length;
      Flength -= length;
      }

    /* Test the various possible conditions */

    condition = FALSE;
    switch(*Fecode)
      {
      case OP_RREF:                  /* Group recursion test */
      if (Fcurrent_recurse != RECURSE_UNSET)
        {
        number = GET2(Fecode, 1);
        condition = (number == RREF_ANY || number == Fcurrent_recurse);
        }
      break;

      case OP_DNRREF:       /* Duplicate named group recursion test */
      if (Fcurrent_recurse != RECURSE_UNSET)
        {
        int count = GET2(Fecode, 1 + IMM2_SIZE);
        PCRE2_SPTR slot = mb->name_table + GET2(Fecode, 1) * mb->name_entry_size;
        while (count-- > 0)
          {
          number = GET2(slot, 0);
          condition = number == Fcurrent_recurse;
          if (condition) break;
          slot += mb->name_entry_size;
          }
        }
      break;

      case OP_CREF:                         /* Numbered group used test */
      offset = (GET2(Fecode, 1) << 1) - 2;  /* Doubled ref number */
      condition = offset < Foffset_top && Fovector[offset] != PCRE2_UNSET;
      break;

      case OP_DNCREF:      /* Duplicate named group used test */
        {
        int count = GET2(Fecode, 1 + IMM2_SIZE);
        PCRE2_SPTR slot = mb->name_table + GET2(Fecode, 1) * mb->name_entry_size;
        while (count-- > 0)
          {
          offset = (GET2(slot, 0) << 1) - 2;
          condition = offset < Foffset_top && Fovector[offset] != PCRE2_UNSET;
          if (condition) break;
          slot += mb->name_entry_size;
          }
        }
      break;

      case OP_FALSE:
      case OP_FAIL:   /* The assertion (?!) becomes OP_FAIL */
      break;

      case OP_TRUE:
      condition = TRUE;
      break;

      /* The condition is an assertion. Run code similar to the assertion code
      above. */

#define Lpositive      F->temp_32[0]
#define Lstart_branch  F->temp_sptr[0]

      default:
      Lpositive = (*Fecode == OP_ASSERT || *Fecode == OP_ASSERTBACK);
      Lstart_branch = Fecode;

      for (;;)
        {
        group_frame_type = GF_CONDASSERT | *Fecode;
        RMATCH(Lstart_branch + PRIV(OP_lengths)[*Lstart_branch], RM5);

        switch(rrc)
          {
          case MATCH_ACCEPT:  /* Save captures */
          memcpy(Fovector,
                (char *)assert_accept_frame + offsetof(heapframe, ovector),
                assert_accept_frame->offset_top * sizeof(PCRE2_SIZE));
          Foffset_top = assert_accept_frame->offset_top;

          /* Fall through */
          /* In the case of a match, the captures have already been put into
          the current frame. */

          case MATCH_MATCH:
          condition = Lpositive;   /* TRUE for positive assertion */
          break;

          /* PCRE doesn't allow the effect of (*THEN) to escape beyond an
          assertion; it is therefore always treated as NOMATCH. */

          case MATCH_NOMATCH:
          case MATCH_THEN:
          Lstart_branch += GET(Lstart_branch, 1);
          if (*Lstart_branch == OP_ALT) continue;  /* Try next branch */
          condition = !Lpositive;  /* TRUE for negative assertion */
          break;

          /* These force no match without checking other branches. */

          case MATCH_COMMIT:
          case MATCH_SKIP:
          case MATCH_PRUNE:
          condition = !Lpositive;
          break;

          default:
          RRETURN(rrc);
          }
        break;  /* Out of the branch loop */
        }

      /* If the condition is true, find the end of the assertion so that
      advancing past it gets us to the start of the first branch. */

      if (condition)
        {
        do Fecode += GET(Fecode, 1); while (*Fecode == OP_ALT);
        }
      break;  /* End of assertion condition */
      }

#undef Lpositive
#undef Lstart_branch

    /* Choose branch according to the condition. */

    Fecode += condition? PRIV(OP_lengths)[*Fecode] : Flength;

    /* If the opcode is OP_SCOND it means we are at a repeated conditional
    group that might match an empty string. We must therefore descend a level
    so that the start is remembered for checking. For OP_COND we can just
    continue at this level. */

    if (Fop == OP_SCOND)
      {
      group_frame_type  = GF_NOCAPTURE | Fop;
      RMATCH(Fecode, RM35);
      RRETURN(rrc);
      }
    break;



/* ========================================================================= */
/*                  End of start of parenthesis opcodes                      */
/* ========================================================================= */


    /* ===================================================================== */
    /* Move the subject pointer back by one fixed amount. This occurs at the
    start of each branch that has a fixed length in a lookbehind assertion. If
    we are too close to the start to move back, fail. When working with UTF-8
    we move back a number of characters, not bytes. */

    case OP_REVERSE:
    number = GET2(Fecode, 1);
#ifdef SUPPORT_UNICODE
    if (utf)
      {
      /* We used to do a simpler `while (number-- > 0)` but that triggers
      clang's unsigned integer overflow sanitizer. */
      while (number > 0)
        {
        --number;
        if (Feptr <= mb->check_subject) RRETURN(MATCH_NOMATCH);
        Feptr--;
        BACKCHAR(Feptr);
        }
      }
    else
#endif

    /* No UTF support, or not in UTF mode: count is code unit count */

      {
      if ((ptrdiff_t)number > Feptr - mb->start_subject) RRETURN(MATCH_NOMATCH);
      Feptr -= number;
      }

    /* Save the earliest consulted character, then skip to next opcode */

    if (Feptr < mb->start_used_ptr) mb->start_used_ptr = Feptr;
    Fecode += 1 + IMM2_SIZE;
    break;


    /* ===================================================================== */
    /* Move the subject pointer back by a variable amount. This occurs at the
    start of each branch of a lookbehind assertion when the branch has a
    variable, but limited, length. A loop is needed to try matching the branch
    after moving back different numbers of characters. If we are too close to
    the start to move back even the minimum amount, fail. When working with
    UTF-8 we move back a number of characters, not bytes. */

#define Lmin F->temp_32[0]
#define Lmax F->temp_32[1]
#define Leptr F->temp_sptr[0]

    case OP_VREVERSE:
    Lmin = GET2(Fecode, 1);
    Lmax = GET2(Fecode, 1 + IMM2_SIZE);
    Leptr = Feptr;

    /* Move back by the maximum branch length and then work forwards. This
    ensures that items such as \d{3,5} get the maximum length, which is
    relevant for captures, and makes for Perl compatibility. */

#ifdef SUPPORT_UNICODE
    if (utf)
      {
      for (i = 0; i < Lmax; i++)
        {
        if (Feptr == mb->start_subject)
          {
          if (i < Lmin) RRETURN(MATCH_NOMATCH);
          Lmax = i;
          break;
          }
        Feptr--;
        BACKCHAR(Feptr);
        }
      }
    else
#endif

    /* No UTF support or not in UTF mode */

      {
      ptrdiff_t diff = Feptr - mb->start_subject;
      uint32_t available = (diff > 65535)? 65535 : ((diff > 0)? (int)diff : 0);
      if (Lmin > available) RRETURN(MATCH_NOMATCH);
      if (Lmax > available) Lmax = available;
      Feptr -= Lmax;
      }

    /* Now try matching, moving forward one character on failure, until we
    reach the minimum back length. */

    for (;;)
      {
      RMATCH(Fecode + 1 + 2 * IMM2_SIZE, RM37);
      if (rrc != MATCH_NOMATCH) RRETURN(rrc);
      if (Lmax-- <= Lmin) RRETURN(MATCH_NOMATCH);
      Feptr++;
#ifdef SUPPORT_UNICODE
      if (utf) { FORWARDCHARTEST(Feptr, mb->end_subject); }
#endif
      }
    PCRE2_UNREACHABLE(); /* Control never reaches here */

#undef Lmin
#undef Lmax
#undef Leptr

    /* ===================================================================== */
    /* An alternation is the end of a branch; scan along to find the end of the
    bracketed group. */

    case OP_ALT:
    branch_end = Fecode;
    do Fecode += GET(Fecode,1); while (*Fecode == OP_ALT);
    break;


    /* ===================================================================== */
    /* The end of a parenthesized group. For all but OP_BRA and OP_COND, the
    starting frame was added to the chained frames in order to remember the
    starting subject position for the group. (Not true for OP_BRA when it's a
    whole pattern recursion, but that is handled separately below.)*/

    case OP_KET:
    case OP_KETRMIN:
    case OP_KETRMAX:
    case OP_KETRPOS:

    bracode = Fecode - GET(Fecode, 1);

    if (branch_end == NULL) branch_end = Fecode;
    branch_start = bracode;
    while (branch_start + GET(branch_start, 1) != branch_end)
      branch_start += GET(branch_start, 1);
    branch_end = NULL;

    /* Point N to the frame at the start of the most recent group, and P to its
    predecessor. Remember the subject pointer at the start of the group. */

    if (*bracode != OP_BRA && *bracode != OP_COND)
      {
      N = (heapframe *)((char *)match_data->heapframes + Flast_group_offset);
      P = (heapframe *)((char *)N - frame_size);
      Flast_group_offset = P->last_group_offset;

#ifdef DEBUG_SHOW_RMATCH
      fprintf(stderr, "++ KET for frame=%d type=%x prev char offset=%lu\n",
        N->rdepth, N->group_frame_type,
        (char *)P->eptr - (char *)mb->start_subject);
#endif

      /* If we are at the end of an assertion that is a condition, first check
      to see if we are at the end of a variable-length branch in a lookbehind.
      If this is the case and we have not landed on the current character,
      return no match. Compare code below for non-condition lookbehinds. In
      other cases, return a match, discarding any intermediate backtracking
      points. Copy back the mark setting and the captures into the frame before
      N so that they are set on return. Doing this for all assertions, both
      positive and negative, seems to match what Perl does. */

      if (GF_IDMASK(N->group_frame_type) == GF_CONDASSERT)
        {
        if ((*bracode == OP_ASSERTBACK || *bracode == OP_ASSERTBACK_NOT) &&
            branch_start[1 + LINK_SIZE] == OP_VREVERSE && Feptr != P->eptr)
          RRETURN(MATCH_NOMATCH);
        memcpy((char *)P + offsetof(heapframe, ovector), Fovector,
          Foffset_top * sizeof(PCRE2_SIZE));
        P->offset_top = Foffset_top;
        P->mark = Fmark;
        Fback_frame = (char *)F - (char *)P;
        RRETURN(MATCH_MATCH);
        }
      }
    else P = NULL;   /* Indicates starting frame not recorded */

    /* The group was not a conditional assertion. */

    switch (*bracode)
      {
      /* Whole pattern recursion is handled as a recursion into group 0, but
      the entire pattern is wrapped in OP_BRA/OP_KET rather than a capturing
      group - a design mistake: it should perhaps have been capture group 0.
      Anyway, that means the end of such recursion must be handled here. It is
      detected by checking for an immediately following OP_END when we are
      recursing in group 0. If this is not the end of a whole-pattern
      recursion, there is nothing to be done. */

      case OP_BRA:
      if (Fcurrent_recurse != 0 || Fecode[1+LINK_SIZE] != OP_END) break;

      /* It is the end of whole-pattern recursion. */

      offset = Flast_group_offset;

      /* Corrupted heapframes?. Trigger an assert and return an error */
      PCRE2_ASSERT(offset != PCRE2_UNSET);
      if (offset == PCRE2_UNSET) return PCRE2_ERROR_INTERNAL;

      N = (heapframe *)((char *)match_data->heapframes + offset);
      P = (heapframe *)((char *)N - frame_size);
      Flast_group_offset = P->last_group_offset;

      /* Reinstate the previous set of captures and then carry on after the
      recursion call. */

      memcpy((char *)F + offsetof(heapframe, ovector), P->ovector,
        Foffset_top * sizeof(PCRE2_SIZE));
      Foffset_top = P->offset_top;
      Fcapture_last = P->capture_last;
      Fcurrent_recurse = P->current_recurse;
      Fecode = P->ecode + 1 + LINK_SIZE;
      continue;  /* With next opcode */

      case OP_COND:     /* No need to do anything for these */
      case OP_SCOND:
      break;

      /* Non-atomic positive assertions are like OP_BRA, except that the
      subject pointer must be put back to where it was at the start of the
      assertion. For a variable lookbehind, check its end point. */

      case OP_ASSERTBACK_NA:
      if (branch_start[1 + LINK_SIZE] == OP_VREVERSE && Feptr != P->eptr)
        RRETURN(MATCH_NOMATCH);
      /* Fall through */

      case OP_ASSERT_NA:
      if (Feptr > mb->last_used_ptr) mb->last_used_ptr = Feptr;
      Feptr = P->eptr;
      break;

      /* Atomic positive assertions are like OP_ONCE, except that in addition
      the subject pointer must be put back to where it was at the start of the
      assertion. For a variable lookbehind, check its end point. */

      case OP_ASSERTBACK:
      if (branch_start[1 + LINK_SIZE] == OP_VREVERSE && Feptr != P->eptr)
        RRETURN(MATCH_NOMATCH);
      /* Fall through */

      case OP_ASSERT:
      if (Feptr > mb->last_used_ptr) mb->last_used_ptr = Feptr;
      Feptr = P->eptr;
      /* Fall through */

      /* For an atomic group, discard internal backtracking points. We must
      also ensure that any remaining branches within the top-level of the group
      are not tried. Do this by adjusting the code pointer within the backtrack
      frame so that it points to the final branch. */

      case OP_ONCE:
      Fback_frame = ((char *)F - (char *)P);
      for (;;)
        {
        uint32_t y = GET(P->ecode,1);
        if ((P->ecode)[y] != OP_ALT) break;
        P->ecode += y;
        }
      break;

      /* A matching negative assertion returns MATCH, which is turned into
      NOMATCH at the assertion level. For a variable lookbehind, check its end
      point. */

      case OP_ASSERTBACK_NOT:
      if (branch_start[1 + LINK_SIZE] == OP_VREVERSE && Feptr != P->eptr)
        RRETURN(MATCH_NOMATCH);
      /* Fall through */

      case OP_ASSERT_NOT:
      RRETURN(MATCH_MATCH);

      /* A scan substring group must preserve the current end_subject,
      and restore it before the backtracking is performed into its sub
      pattern. */

      case OP_ASSERT_SCS:
      F->temp_sptr[0] = mb->end_subject;
      mb->end_subject = P->temp_sptr[0];
      mb->true_end_subject = mb->end_subject + P->temp_size;
      Feptr = P->temp_sptr[1];

      RMATCH(Fecode + 1 + LINK_SIZE, RM39);

      mb->end_subject = F->temp_sptr[0];
      mb->true_end_subject = mb->end_subject;
      RRETURN(rrc);
      break;

      /* At the end of a script run, apply the script-checking rules. This code
      will never by exercised if Unicode support it not compiled, because in
      that environment script runs cause an error at compile time. */

      case OP_SCRIPT_RUN:
      if (!PRIV(script_run)(P->eptr, Feptr, utf)) RRETURN(MATCH_NOMATCH);
      break;

      /* Whole-pattern recursion is coded as a recurse into group 0, and is
      handled with OP_BRA above. Other recursion is handled here. */

      case OP_CBRA:
      case OP_CBRAPOS:
      case OP_SCBRA:
      case OP_SCBRAPOS:
      number = GET2(bracode, 1+LINK_SIZE);

      /* Handle a recursively called group. We reinstate the previous set of
      captures and then carry on after the recursion call. */

      if (Fcurrent_recurse == number)
        {
        P = (heapframe *)((char *)N - frame_size);
        memcpy((char *)F + offsetof(heapframe, ovector), P->ovector,
          Foffset_top * sizeof(PCRE2_SIZE));
        Foffset_top = P->offset_top;
        Fcapture_last = P->capture_last;
        Fcurrent_recurse = P->current_recurse;
        Fecode = P->ecode + 1 + LINK_SIZE;
        continue;  /* With next opcode */
        }

      /* Deal with actual capturing. */

      offset = (number << 1) - 2;
      Fcapture_last = number;
      Fovector[offset] = P->eptr - mb->start_subject;
      Fovector[offset+1] = Feptr - mb->start_subject;
      if (offset >= Foffset_top) Foffset_top = offset + 2;
      break;
      }  /* End actions relating to the starting opcode */

    /* OP_KETRPOS is a possessive repeating ket. Remember the current position,
    and return the MATCH_KETRPOS. This makes it possible to do the repeats one
    at a time from the outer level. This must precede the empty string test -
    in this case that test is done at the outer level. */

    if (*Fecode == OP_KETRPOS)
      {
      memcpy((char *)P + offsetof(heapframe, eptr),
             (char *)F + offsetof(heapframe, eptr),
             frame_copy_size);
      RRETURN(MATCH_KETRPOS);
      }

    /* Handle the different kinds of closing brackets. A non-repeating ket
    needs no special action, just continuing at this level. This also happens
    for the repeating kets if the group matched no characters, in order to
    forcibly break infinite loops. Otherwise, the repeating kets try the rest
    of the pattern or restart from the preceding bracket, in the appropriate
    order. */

    if (Fop != OP_KET && (P == NULL || Feptr != P->eptr))
      {
      if (Fop == OP_KETRMIN)
        {
        RMATCH(Fecode + 1 + LINK_SIZE, RM6);
        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
        Fecode -= GET(Fecode, 1);
        break;   /* End of ket processing */
        }

      /* Repeat the maximum number of times (KETRMAX) */

      RMATCH(bracode, RM7);
      if (rrc != MATCH_NOMATCH) RRETURN(rrc);
      }

    /* Carry on at this level for a non-repeating ket, or after matching an
    empty string, or after repeating for a maximum number of times. */

    Fecode += 1 + LINK_SIZE;
    break;


    /* ===================================================================== */
    /* Start and end of line assertions, not multiline mode. */

    case OP_CIRC:   /* Start of line, unless PCRE2_NOTBOL is set. */
    if (Feptr != mb->start_subject || (mb->moptions & PCRE2_NOTBOL) != 0)
      RRETURN(MATCH_NOMATCH);
    Fecode++;
    break;

    case OP_SOD:    /* Unconditional start of subject */
    if (Feptr != mb->start_subject) RRETURN(MATCH_NOMATCH);
    Fecode++;
    break;

    /* When PCRE2_NOTEOL is unset, assert before the subject end, or a
    terminating newline unless PCRE2_DOLLAR_ENDONLY is set. */

    case OP_DOLL:
    if ((mb->moptions & PCRE2_NOTEOL) != 0) RRETURN(MATCH_NOMATCH);
    if ((mb->poptions & PCRE2_DOLLAR_ENDONLY) == 0) goto ASSERT_NL_OR_EOS;

    /* Fall through */
    /* Unconditional end of subject assertion (\z). */

    case OP_EOD:
    if (Feptr < mb->true_end_subject) RRETURN(MATCH_NOMATCH);
    if (mb->partial != 0)
      {
      mb->hitend = TRUE;
      if (mb->partial > 1) return PCRE2_ERROR_PARTIAL;
      }
    Fecode++;
    break;

    /* End of subject or ending \n assertion (\Z) */

    case OP_EODN:
    ASSERT_NL_OR_EOS:
    if (Feptr < mb->true_end_subject &&
        (!IS_NEWLINE(Feptr) || Feptr != mb->true_end_subject - mb->nllen))
      {
      if (mb->partial != 0 &&
          Feptr + 1 >= mb->end_subject &&
          NLBLOCK->nltype == NLTYPE_FIXED &&
          NLBLOCK->nllen == 2 &&
          UCHAR21TEST(Feptr) == NLBLOCK->nl[0])
        {
        mb->hitend = TRUE;
        if (mb->partial > 1) return PCRE2_ERROR_PARTIAL;
        }
      RRETURN(MATCH_NOMATCH);
      }

    /* Either at end of string or \n before end. */

    if (mb->partial != 0)
      {
      mb->hitend = TRUE;
      if (mb->partial > 1) return PCRE2_ERROR_PARTIAL;
      }
    Fecode++;
    break;


    /* ===================================================================== */
    /* Start and end of line assertions, multiline mode. */

    /* Start of subject unless notbol, or after any newline except for one at
    the very end, unless PCRE2_ALT_CIRCUMFLEX is set. */

    case OP_CIRCM:
    if ((mb->moptions & PCRE2_NOTBOL) != 0 && Feptr == mb->start_subject)
      RRETURN(MATCH_NOMATCH);
    if (Feptr != mb->start_subject &&
        ((Feptr == mb->end_subject &&
           (mb->poptions & PCRE2_ALT_CIRCUMFLEX) == 0) ||
         !WAS_NEWLINE(Feptr)))
      RRETURN(MATCH_NOMATCH);
    Fecode++;
    break;

    /* Assert before any newline, or before end of subject unless noteol is
    set. */

    case OP_DOLLM:
    if (Feptr < mb->end_subject)
      {
      if (!IS_NEWLINE(Feptr))
        {
        if (mb->partial != 0 &&
            Feptr + 1 >= mb->end_subject &&
            NLBLOCK->nltype == NLTYPE_FIXED &&
            NLBLOCK->nllen == 2 &&
            UCHAR21TEST(Feptr) == NLBLOCK->nl[0])
          {
          mb->hitend = TRUE;
          if (mb->partial > 1) return PCRE2_ERROR_PARTIAL;
          }
        RRETURN(MATCH_NOMATCH);
        }
      }
    else
      {
      if ((mb->moptions & PCRE2_NOTEOL) != 0) RRETURN(MATCH_NOMATCH);
      SCHECK_PARTIAL();
      }
    Fecode++;
    break;


    /* ===================================================================== */
    /* Start of match assertion */

    case OP_SOM:
    if (Feptr != mb->start_subject + mb->start_offset) RRETURN(MATCH_NOMATCH);
    Fecode++;
    break;


    /* ===================================================================== */
    /* Reset the start of match point */

    case OP_SET_SOM:
    Fstart_match = Feptr;
    Fecode++;
    break;


    /* ===================================================================== */
    /* Word boundary assertions. Find out if the previous and current
    characters are "word" characters. It takes a bit more work in UTF mode.
    Characters > 255 are assumed to be "non-word" characters when PCRE2_UCP is
    not set. When it is set, use Unicode properties if available, even when not
    in UTF mode. Remember the earliest and latest consulted characters. */

    case OP_NOT_WORD_BOUNDARY:
    case OP_WORD_BOUNDARY:
    case OP_NOT_UCP_WORD_BOUNDARY:
    case OP_UCP_WORD_BOUNDARY:
    if (Feptr == mb->check_subject) prev_is_word = FALSE; else
      {
      PCRE2_SPTR lastptr = Feptr - 1;
#ifdef SUPPORT_UNICODE
      if (utf)
        {
        BACKCHAR(lastptr);
        GETCHAR(fc, lastptr);
        }
      else
#endif  /* SUPPORT_UNICODE */
      fc = *lastptr;
      if (lastptr < mb->start_used_ptr) mb->start_used_ptr = lastptr;
#ifdef SUPPORT_UNICODE
      if (Fop == OP_UCP_WORD_BOUNDARY || Fop == OP_NOT_UCP_WORD_BOUNDARY)
        {
        int chartype = UCD_CHARTYPE(fc);
        int category = PRIV(ucp_gentype)[chartype];
        prev_is_word = (category == ucp_L || category == ucp_N ||
          chartype == ucp_Mn || chartype == ucp_Pc);
        }
      else
#endif  /* SUPPORT_UNICODE */
      prev_is_word = CHMAX_255(fc) && (mb->ctypes[fc] & ctype_word) != 0;
      }

    /* Get status of next character */

    if (Feptr >= mb->end_subject)
      {
      SCHECK_PARTIAL();
      cur_is_word = FALSE;
      }
    else
      {
      PCRE2_SPTR nextptr = Feptr + 1;
#ifdef SUPPORT_UNICODE
      if (utf)
        {
        FORWARDCHARTEST(nextptr, mb->end_subject);
        GETCHAR(fc, Feptr);
        }
      else
#endif  /* SUPPORT_UNICODE */
      fc = *Feptr;
      if (nextptr > mb->last_used_ptr) mb->last_used_ptr = nextptr;
#ifdef SUPPORT_UNICODE
      if (Fop == OP_UCP_WORD_BOUNDARY || Fop == OP_NOT_UCP_WORD_BOUNDARY)
        {
        int chartype = UCD_CHARTYPE(fc);
        int category = PRIV(ucp_gentype)[chartype];
        cur_is_word = (category == ucp_L || category == ucp_N ||
          chartype == ucp_Mn || chartype == ucp_Pc);
        }
      else
#endif  /* SUPPORT_UNICODE */
      cur_is_word = CHMAX_255(fc) && (mb->ctypes[fc] & ctype_word) != 0;
      }

    /* Now see if the situation is what we want */

    if ((*Fecode++ == OP_WORD_BOUNDARY || Fop == OP_UCP_WORD_BOUNDARY)?
         cur_is_word == prev_is_word : cur_is_word != prev_is_word)
      RRETURN(MATCH_NOMATCH);
    break;


    /* ===================================================================== */
    /* Backtracking (*VERB)s, with and without arguments. Note that if the
    pattern is successfully matched, we do not come back from RMATCH. */

    case OP_MARK:
    Fmark = mb->nomatch_mark = Fecode + 2;
    RMATCH(Fecode + PRIV(OP_lengths)[*Fecode] + Fecode[1], RM12);

    /* A return of MATCH_SKIP_ARG means that matching failed at SKIP with an
    argument, and we must check whether that argument matches this MARK's
    argument. It is passed back in mb->verb_skip_ptr. If it does match, we
    return MATCH_SKIP with mb->verb_skip_ptr now pointing to the subject
    position that corresponds to this mark. Otherwise, pass back the return
    code unaltered. */

    if (rrc == MATCH_SKIP_ARG &&
             PRIV(strcmp)(Fecode + 2, mb->verb_skip_ptr) == 0)
      {
      mb->verb_skip_ptr = Feptr;   /* Pass back current position */
      RRETURN(MATCH_SKIP);
      }
    RRETURN(rrc);

    case OP_FAIL:
    RRETURN(MATCH_NOMATCH);

    /* Record the current recursing group number in mb->verb_current_recurse
    when a backtracking return such as MATCH_COMMIT is given. This enables the
    recurse processing to catch verbs from within the recursion. */

    case OP_COMMIT:
    RMATCH(Fecode + PRIV(OP_lengths)[*Fecode], RM13);
    if (rrc != MATCH_NOMATCH) RRETURN(rrc);
    mb->verb_current_recurse = Fcurrent_recurse;
    RRETURN(MATCH_COMMIT);

    case OP_COMMIT_ARG:
    Fmark = mb->nomatch_mark = Fecode + 2;
    RMATCH(Fecode + PRIV(OP_lengths)[*Fecode] + Fecode[1], RM36);
    if (rrc != MATCH_NOMATCH) RRETURN(rrc);
    mb->verb_current_recurse = Fcurrent_recurse;
    RRETURN(MATCH_COMMIT);

    case OP_PRUNE:
    RMATCH(Fecode + PRIV(OP_lengths)[*Fecode], RM14);
    if (rrc != MATCH_NOMATCH) RRETURN(rrc);
    mb->verb_current_recurse = Fcurrent_recurse;
    RRETURN(MATCH_PRUNE);

    case OP_PRUNE_ARG:
    Fmark = mb->nomatch_mark = Fecode + 2;
    RMATCH(Fecode + PRIV(OP_lengths)[*Fecode] + Fecode[1], RM15);
    if (rrc != MATCH_NOMATCH) RRETURN(rrc);
    mb->verb_current_recurse = Fcurrent_recurse;
    RRETURN(MATCH_PRUNE);

    case OP_SKIP:
    RMATCH(Fecode + PRIV(OP_lengths)[*Fecode], RM16);
    if (rrc != MATCH_NOMATCH) RRETURN(rrc);
    mb->verb_skip_ptr = Feptr;   /* Pass back current position */
    mb->verb_current_recurse = Fcurrent_recurse;
    RRETURN(MATCH_SKIP);

    /* Note that, for Perl compatibility, SKIP with an argument does NOT set
    nomatch_mark. When a pattern match ends with a SKIP_ARG for which there was
    not a matching mark, we have to re-run the match, ignoring the SKIP_ARG
    that failed and any that precede it (either they also failed, or were not
    triggered). To do this, we maintain a count of executed SKIP_ARGs. If a
    SKIP_ARG gets to top level, the match is re-run with mb->ignore_skip_arg
    set to the count of the one that failed. */

    case OP_SKIP_ARG:
    mb->skip_arg_count++;
    if (mb->skip_arg_count <= mb->ignore_skip_arg)
      {
      Fecode += PRIV(OP_lengths)[*Fecode] + Fecode[1];
      break;
      }
    RMATCH(Fecode + PRIV(OP_lengths)[*Fecode] + Fecode[1], RM17);
    if (rrc != MATCH_NOMATCH) RRETURN(rrc);

    /* Pass back the current skip name and return the special MATCH_SKIP_ARG
    return code. This will either be caught by a matching MARK, or get to the
    top, where it causes a rematch with mb->ignore_skip_arg set to the value of
    mb->skip_arg_count. */

    mb->verb_skip_ptr = Fecode + 2;
    mb->verb_current_recurse = Fcurrent_recurse;
    RRETURN(MATCH_SKIP_ARG);

    /* For THEN (and THEN_ARG) we pass back the address of the opcode, so that
    the branch in which it occurs can be determined. */

    case OP_THEN:
    RMATCH(Fecode + PRIV(OP_lengths)[*Fecode], RM18);
    if (rrc != MATCH_NOMATCH) RRETURN(rrc);
    mb->verb_ecode_ptr = Fecode;
    mb->verb_current_recurse = Fcurrent_recurse;
    RRETURN(MATCH_THEN);

    case OP_THEN_ARG:
    Fmark = mb->nomatch_mark = Fecode + 2;
    RMATCH(Fecode + PRIV(OP_lengths)[*Fecode] + Fecode[1], RM19);
    if (rrc != MATCH_NOMATCH) RRETURN(rrc);
    mb->verb_ecode_ptr = Fecode;
    mb->verb_current_recurse = Fcurrent_recurse;
    RRETURN(MATCH_THEN);


    /* ===================================================================== */
    /* There's been some horrible disaster. Arrival here can only mean there is
    something seriously wrong in the code above or the OP_xxx definitions. */

    default:
    PCRE2_DEBUG_UNREACHABLE();
    return PCRE2_ERROR_INTERNAL;
    }

  /* Do not insert any code in here without much thought; it is assumed
  that "continue" in the code above comes out to here to repeat the main
  loop. */

  }  /* End of main loop */

PCRE2_DEBUG_UNREACHABLE(); /* Control should never reach here */

/* ========================================================================= */
/* The RRETURN() macro jumps here. The number that is saved in Freturn_id
indicates which label we actually want to return to. The value in Frdepth is
the index number of the frame in the vector. The return value has been placed
in rrc. */

#define LBL(val) case val: goto L_RM##val;

RETURN_SWITCH:
if (Feptr > mb->last_used_ptr) mb->last_used_ptr = Feptr;
if (Frdepth == 0) return rrc;                     /* Exit from the top level */
F = (heapframe *)((char *)F - Fback_frame);       /* Backtrack */
mb->cb->callout_flags |= PCRE2_CALLOUT_BACKTRACK; /* Note for callouts */

#ifdef DEBUG_SHOW_RMATCH
fprintf(stderr, "++ RETURN %d to RM%d\n", rrc, Freturn_id);
#endif

switch (Freturn_id)
  {
  LBL( 1) LBL( 2) LBL( 3) LBL( 4) LBL( 5) LBL( 6) LBL( 7) LBL( 8)
  LBL( 9) LBL(10) LBL(11) LBL(12) LBL(13) LBL(14) LBL(15) LBL(16)
  LBL(17) LBL(18) LBL(19) LBL(20) LBL(21) LBL(22) LBL(23) LBL(24)
  LBL(25) LBL(26) LBL(27) LBL(28) LBL(29) LBL(30) LBL(31) LBL(32)
  LBL(33) LBL(34) LBL(35) LBL(36) LBL(37) LBL(38) LBL(39)

#ifdef SUPPORT_WIDE_CHARS
  LBL(100) LBL(101) LBL(102) LBL(103)
#endif

#ifdef SUPPORT_UNICODE
  LBL(200) LBL(201) LBL(202) LBL(203) LBL(204) LBL(205) LBL(206)
  LBL(207) LBL(208) LBL(209) LBL(210) LBL(211) LBL(212) LBL(213)
  LBL(214) LBL(215) LBL(216) LBL(217) LBL(218) LBL(219) LBL(220)
  LBL(221) LBL(222) LBL(223) LBL(224)
#endif

  default:
  PCRE2_DEBUG_UNREACHABLE();
  return PCRE2_ERROR_INTERNAL;
  }
#undef LBL
}


/*************************************************
*           Match a Regular Expression           *
*************************************************/

/* This function applies a compiled pattern to a subject string and picks out
portions of the string if it matches. Two elements in the vector are set for
each substring: the offsets to the start and end of the substring.

Arguments:
  code            points to the compiled expression
  subject         points to the subject string
  length          length of subject string (may contain binary zeros)
  start_offset    where to start in the subject string
  options         option bits
  match_data      points to a match_data block
  mcontext        points a PCRE2 context

Returns:          > 0 => success; value is the number of ovector pairs filled
                  = 0 => success, but ovector is not big enough
                  = -1 => failed to match (PCRE2_ERROR_NOMATCH)
                  = -2 => partial match (PCRE2_ERROR_PARTIAL)
                  < -2 => some kind of unexpected problem
*/

//au: added parameter: , int(*callout)(pcre2_callout_block *, void *)

PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
pcre2_match(const pcre2_code *code, PCRE2_SPTR subject, PCRE2_SIZE length,
  PCRE2_SIZE start_offset, uint32_t options, pcre2_match_data *match_data,
  pcre2_match_context *mcontext, int(*callout)(pcre2_callout_block*, void*))
{
int rc;
int was_zero_terminated = 0;
const uint8_t *start_bits = NULL;
const pcre2_real_code *re = (const pcre2_real_code *)code;

BOOL anchored;
BOOL firstline;
BOOL has_first_cu = FALSE;
BOOL has_req_cu = FALSE;
BOOL startline;

#if PCRE2_CODE_UNIT_WIDTH == 8
PCRE2_SPTR memchr_found_first_cu;
PCRE2_SPTR memchr_found_first_cu2;
#endif

PCRE2_UCHAR first_cu = 0;
PCRE2_UCHAR first_cu2 = 0;
PCRE2_UCHAR req_cu = 0;
PCRE2_UCHAR req_cu2 = 0;

PCRE2_SPTR bumpalong_limit;
PCRE2_SPTR end_subject;
PCRE2_SPTR true_end_subject;
PCRE2_SPTR start_match;
PCRE2_SPTR req_cu_ptr;
PCRE2_SPTR start_partial;
PCRE2_SPTR match_partial;

#ifdef SUPPORT_JIT
BOOL use_jit;
#endif

/* This flag is needed even when Unicode is not supported for convenience
(it is used by the IS_NEWLINE macro). */

BOOL utf = FALSE;

#ifdef SUPPORT_UNICODE
BOOL ucp = FALSE;
BOOL allow_invalid;
uint32_t fragment_options = 0;
#ifdef SUPPORT_JIT
BOOL jit_checked_utf = FALSE;
#endif
#endif  /* SUPPORT_UNICODE */

PCRE2_SIZE frame_size;
PCRE2_SIZE heapframes_size;

/* We need to have mb as a pointer to a match block, because the IS_NEWLINE
macro is used below, and it expects NLBLOCK to be defined as a pointer. */

pcre2_callout_block cb;
match_block actual_match_block;
match_block *mb = &actual_match_block;

/* Recognize NULL, length 0 as an empty string. */

if (subject == NULL && length == 0) subject = (PCRE2_SPTR)"";

/* Plausibility checks */

if ((options & ~PUBLIC_MATCH_OPTIONS) != 0) return PCRE2_ERROR_BADOPTION;
if (code == NULL || subject == NULL || match_data == NULL)
  return PCRE2_ERROR_NULL;

start_match = subject + start_offset;
req_cu_ptr = start_match - 1;
if (length == PCRE2_ZERO_TERMINATED)
  {
  length = PRIV(strlen)(subject);
  was_zero_terminated = 1;
  }
true_end_subject = end_subject = subject + length;

if (start_offset > length) return PCRE2_ERROR_BADOFFSET;

/* Check that the first field in the block is the magic number. */

if (re->magic_number != MAGIC_NUMBER) return PCRE2_ERROR_BADMAGIC;

/* Check the code unit width. */

if ((re->flags & PCRE2_MODE_MASK) != PCRE2_CODE_UNIT_WIDTH/8)
  return PCRE2_ERROR_BADMODE;

/* PCRE2_NOTEMPTY and PCRE2_NOTEMPTY_ATSTART are match-time flags in the
options variable for this function. Users of PCRE2 who are not calling the
function directly would like to have a way of setting these flags, in the same
way that they can set pcre2_compile() flags like PCRE2_NO_AUTO_POSSESS with
constructions like (*NO_AUTOPOSSESS). To enable this, (*NOTEMPTY) and
(*NOTEMPTY_ATSTART) set bits in the pattern's "flag" function which we now
transfer to the options for this function. The bits are guaranteed to be
adjacent, but do not have the same values. This bit of Boolean trickery assumes
that the match-time bits are not more significant than the flag bits. If by
accident this is not the case, a compile-time division by zero error will
occur. */

#define FF (PCRE2_NOTEMPTY_SET|PCRE2_NE_ATST_SET)
#define OO (PCRE2_NOTEMPTY|PCRE2_NOTEMPTY_ATSTART)
options |= (re->flags & FF) / ((FF & (~FF+1)) / (OO & (~OO+1)));
#undef FF
#undef OO

/* If the pattern was successfully studied with JIT support, we will run the
JIT executable instead of the rest of this function. Most options must be set
at compile time for the JIT code to be usable. */

#ifdef SUPPORT_JIT
use_jit = (re->executable_jit != NULL &&
          (options & ~PUBLIC_JIT_MATCH_OPTIONS) == 0);
#endif

/* Initialize UTF/UCP parameters. */

#ifdef SUPPORT_UNICODE
utf = (re->overall_options & PCRE2_UTF) != 0;
allow_invalid = (re->overall_options & PCRE2_MATCH_INVALID_UTF) != 0;
ucp = (re->overall_options & PCRE2_UCP) != 0;
#endif  /* SUPPORT_UNICODE */

/* Convert the partial matching flags into an integer. */

mb->partial = ((options & PCRE2_PARTIAL_HARD) != 0)? 2 :
              ((options & PCRE2_PARTIAL_SOFT) != 0)? 1 : 0;

/* Partial matching and PCRE2_ENDANCHORED are currently not allowed at the same
time. */

if (mb->partial != 0 &&
   ((re->overall_options | options) & PCRE2_ENDANCHORED) != 0)
  return PCRE2_ERROR_BADOPTION;

/* It is an error to set an offset limit without setting the flag at compile
time. */

if (mcontext != NULL && mcontext->offset_limit != PCRE2_UNSET &&
     (re->overall_options & PCRE2_USE_OFFSET_LIMIT) == 0)
  return PCRE2_ERROR_BADOFFSETLIMIT;

/* If the match data block was previously used with PCRE2_COPY_MATCHED_SUBJECT,
free the memory that was obtained. Set the field to NULL for no match cases. */

if ((match_data->flags & PCRE2_MD_COPIED_SUBJECT) != 0)
  {
  match_data->memctl.free((void *)match_data->subject,
    match_data->memctl.memory_data);
  match_data->flags &= ~PCRE2_MD_COPIED_SUBJECT;
  }
match_data->subject = NULL;

/* Zero the error offset in case the first code unit is invalid UTF. */

match_data->startchar = 0;


/* ============================= JIT matching ============================== */

/* Prepare for JIT matching. Check a UTF string for validity unless no check is
requested or invalid UTF can be handled. We check only the portion of the
subject that might be be inspected during matching - from the offset minus the
maximum lookbehind to the given length. This saves time when a small part of a
large subject is being matched by the use of a starting offset. Note that the
maximum lookbehind is a number of characters, not code units. */

#ifdef SUPPORT_JIT
if (use_jit)
  {
#ifdef SUPPORT_UNICODE
  if (utf && (options & PCRE2_NO_UTF_CHECK) == 0 && !allow_invalid)
    {

    /* For 8-bit and 16-bit UTF, check that the first code unit is a valid
    character start. */

#if PCRE2_CODE_UNIT_WIDTH != 32
    if (start_match < end_subject && NOT_FIRSTCU(*start_match))
      {
      if (start_offset > 0) return PCRE2_ERROR_BADUTFOFFSET;
#if PCRE2_CODE_UNIT_WIDTH == 8
      return PCRE2_ERROR_UTF8_ERR20;  /* Isolated 0x80 byte */
#else
      return PCRE2_ERROR_UTF16_ERR3;  /* Isolated low surrogate */
#endif
      }
#endif  /* WIDTH != 32 */

    /* Move back by the maximum lookbehind, just in case it happens at the very
    start of matching. */

#if PCRE2_CODE_UNIT_WIDTH != 32
    for (unsigned int i = re->max_lookbehind; i > 0 && start_match > subject; i--)
      {
      start_match--;
      while (start_match > subject &&
#if PCRE2_CODE_UNIT_WIDTH == 8
      (*start_match & 0xc0) == 0x80)
#else  /* 16-bit */
      (*start_match & 0xfc00) == 0xdc00)
#endif
        start_match--;
      }
#else  /* PCRE2_CODE_UNIT_WIDTH != 32 */

    /* In the 32-bit library, one code unit equals one character. However,
    we cannot just subtract the lookbehind and then compare pointers, because
    a very large lookbehind could create an invalid pointer. */

    if (start_offset >= re->max_lookbehind)
      start_match -= re->max_lookbehind;
    else
      start_match = subject;
#endif  /* PCRE2_CODE_UNIT_WIDTH != 32 */

    /* Validate the relevant portion of the subject. Adjust the offset of an
    invalid code point to be an absolute offset in the whole string. */

    match_data->rc = PRIV(valid_utf)(start_match,
      length - (start_match - subject), &(match_data->startchar));
    if (match_data->rc != 0)
      {
      match_data->startchar += start_match - subject;
      return match_data->rc;
      }
    jit_checked_utf = TRUE;
    }
#endif  /* SUPPORT_UNICODE */

  /* If JIT returns BADOPTION, which means that the selected complete or
  partial matching mode was not compiled, fall through to the interpreter. */

  rc = pcre2_jit_match(code, subject, length, start_offset, options,
    match_data, mcontext);
  if (rc != PCRE2_ERROR_JIT_BADOPTION)
    {
    match_data->subject_length = length;
    if (rc >= 0 && (options & PCRE2_COPY_MATCHED_SUBJECT) != 0)
      {
      length = CU2BYTES(length + was_zero_terminated);
      match_data->subject = match_data->memctl.malloc(length,
        match_data->memctl.memory_data);
      if (match_data->subject == NULL) return PCRE2_ERROR_NOMEMORY;
      memcpy((void *)match_data->subject, subject, length);
      match_data->flags |= PCRE2_MD_COPIED_SUBJECT;
      }
    return rc;
    }
  }
#endif  /* SUPPORT_JIT */

/* ========================= End of JIT matching ========================== */


/* Proceed with non-JIT matching. The default is to allow lookbehinds to the
start of the subject. A UTF check when there is a non-zero offset may change
this. */

mb->check_subject = subject;

/* If a UTF subject string was not checked for validity in the JIT code above,
check it here, and handle support for invalid UTF strings. The check above
happens only when invalid UTF is not supported and PCRE2_NO_CHECK_UTF is unset.
If we get here in those circumstances, it means the subject string is valid,
but for some reason JIT matching was not successful. There is no need to check
the subject again.

We check only the portion of the subject that might be be inspected during
matching - from the offset minus the maximum lookbehind to the given length.
This saves time when a small part of a large subject is being matched by the
use of a starting offset. Note that the maximum lookbehind is a number of
characters, not code units.

Note also that support for invalid UTF forces a check, overriding the setting
of PCRE2_NO_CHECK_UTF. */

#ifdef SUPPORT_UNICODE
if (utf &&
#ifdef SUPPORT_JIT
    !jit_checked_utf &&
#endif
    ((options & PCRE2_NO_UTF_CHECK) == 0 || allow_invalid))
  {
#if PCRE2_CODE_UNIT_WIDTH != 32
  BOOL skipped_bad_start = FALSE;
#endif

  /* For 8-bit and 16-bit UTF, check that the first code unit is a valid
  character start. If we are handling invalid UTF, just skip over such code
  units. Otherwise, give an appropriate error. */

#if PCRE2_CODE_UNIT_WIDTH != 32
  if (allow_invalid)
    {
    while (start_match < end_subject && NOT_FIRSTCU(*start_match))
      {
      start_match++;
      skipped_bad_start = TRUE;
      }
    }
  else if (start_match < end_subject && NOT_FIRSTCU(*start_match))
    {
    if (start_offset > 0) return PCRE2_ERROR_BADUTFOFFSET;
#if PCRE2_CODE_UNIT_WIDTH == 8
    return PCRE2_ERROR_UTF8_ERR20;  /* Isolated 0x80 byte */
#else
    return PCRE2_ERROR_UTF16_ERR3;  /* Isolated low surrogate */
#endif
    }
#endif  /* WIDTH != 32 */

  /* The mb->check_subject field points to the start of UTF checking;
  lookbehinds can go back no further than this. */

  mb->check_subject = start_match;

  /* Move back by the maximum lookbehind, just in case it happens at the very
  start of matching, but don't do this if we skipped bad 8-bit or 16-bit code
  units above. */

#if PCRE2_CODE_UNIT_WIDTH != 32
  if (!skipped_bad_start)
    {
    unsigned int i;
    for (i = re->max_lookbehind; i > 0 && mb->check_subject > subject; i--)
      {
      mb->check_subject--;
      while (mb->check_subject > subject &&
#if PCRE2_CODE_UNIT_WIDTH == 8
      (*mb->check_subject & 0xc0) == 0x80)
#else  /* 16-bit */
      (*mb->check_subject & 0xfc00) == 0xdc00)
#endif
        mb->check_subject--;
      }
    }
#else  /* PCRE2_CODE_UNIT_WIDTH != 32 */

  /* In the 32-bit library, one code unit equals one character. However,
  we cannot just subtract the lookbehind and then compare pointers, because
  a very large lookbehind could create an invalid pointer. */

  if (start_offset >= re->max_lookbehind)
    mb->check_subject -= re->max_lookbehind;
  else
    mb->check_subject = subject;
#endif  /* PCRE2_CODE_UNIT_WIDTH != 32 */

  /* Validate the relevant portion of the subject. There's a loop in case we
  encounter bad UTF in the characters preceding start_match which we are
  scanning because of a lookbehind. */

  for (;;)
    {
    match_data->rc = PRIV(valid_utf)(mb->check_subject,
      length - (mb->check_subject - subject), &(match_data->startchar));

    if (match_data->rc == 0) break;   /* Valid UTF string */

    /* Invalid UTF string. Adjust the offset to be an absolute offset in the
    whole string. If we are handling invalid UTF strings, set end_subject to
    stop before the bad code unit, and set the options to "not end of line".
    Otherwise return the error. */

    match_data->startchar += mb->check_subject - subject;
    if (!allow_invalid || match_data->rc > 0) return match_data->rc;
    end_subject = subject + match_data->startchar;

    /* If the end precedes start_match, it means there is invalid UTF in the
    extra code units we reversed over because of a lookbehind. Advance past the
    first bad code unit, and then skip invalid character starting code units in
    8-bit and 16-bit modes, and try again with the original end point. */

    if (end_subject < start_match)
      {
      mb->check_subject = end_subject + 1;
#if PCRE2_CODE_UNIT_WIDTH != 32
      while (mb->check_subject < start_match && NOT_FIRSTCU(*mb->check_subject))
        mb->check_subject++;
#endif
      end_subject = true_end_subject;
      }

    /* Otherwise, set the not end of line option, and do the match. */

    else
      {
      fragment_options = PCRE2_NOTEOL;
      break;
      }
    }
  }
#endif  /* SUPPORT_UNICODE */

/* A NULL match context means "use a default context", but we take the memory
control functions from the pattern. */

if (mcontext == NULL)
  {
  mcontext = (pcre2_match_context *)(&PRIV(default_match_context));
  mb->memctl = re->memctl;
  }
else mb->memctl = mcontext->memctl;

anchored = ((re->overall_options | options) & PCRE2_ANCHORED) != 0;
firstline = !anchored && (re->overall_options & PCRE2_FIRSTLINE) != 0;
startline = (re->flags & PCRE2_STARTLINE) != 0;
bumpalong_limit = (mcontext->offset_limit == PCRE2_UNSET)?
  true_end_subject : subject + mcontext->offset_limit;

/* Initialize and set up the fixed fields in the callout block, with a pointer
in the match block. */

mb->cb = &cb;
cb.version = 2;
cb.subject = subject;
cb.subject_length = (PCRE2_SIZE)(end_subject - subject);
cb.callout_flags = 0;

/* Fill in the remaining fields in the match block, except for moptions, which
gets set later. */

//au: use callout parameter instead of match context
mb->callout = callout;
//mb->callout = mcontext->callout;
//mb->callout_data = mcontext->callout_data;

mb->start_subject = subject;
mb->start_offset = start_offset;
mb->end_subject = end_subject;
mb->true_end_subject = true_end_subject;
mb->hasthen = (re->flags & PCRE2_HASTHEN) != 0;
mb->allowemptypartial = (re->max_lookbehind > 0) ||
    (re->flags & PCRE2_MATCH_EMPTY) != 0;
mb->poptions = re->overall_options;          /* Pattern options */
mb->ignore_skip_arg = 0;
mb->mark = mb->nomatch_mark = NULL;          /* In case never set */

/* The name table is needed for finding all the numbers associated with a
given name, for condition testing. The code follows the name table. */

mb->name_table = (PCRE2_SPTR)((const uint8_t *)re + sizeof(pcre2_real_code));
mb->name_count = re->name_count;
mb->name_entry_size = re->name_entry_size;
mb->start_code = (PCRE2_SPTR)((const uint8_t *)re + re->code_start);

/* Process the \R and newline settings. */

mb->bsr_convention = re->bsr_convention;
mb->nltype = NLTYPE_FIXED;
switch(re->newline_convention)
  {
  case PCRE2_NEWLINE_CR:
  mb->nllen = 1;
  mb->nl[0] = CHAR_CR;
  break;

  case PCRE2_NEWLINE_LF:
  mb->nllen = 1;
  mb->nl[0] = CHAR_NL;
  break;

  case PCRE2_NEWLINE_NUL:
  mb->nllen = 1;
  mb->nl[0] = CHAR_NUL;
  break;

  case PCRE2_NEWLINE_CRLF:
  mb->nllen = 2;
  mb->nl[0] = CHAR_CR;
  mb->nl[1] = CHAR_NL;
  break;

  case PCRE2_NEWLINE_ANY:
  mb->nltype = NLTYPE_ANY;
  break;

  case PCRE2_NEWLINE_ANYCRLF:
  mb->nltype = NLTYPE_ANYCRLF;
  break;

  default:
  PCRE2_DEBUG_UNREACHABLE();
  return PCRE2_ERROR_INTERNAL;
  }

/* The backtracking frames have fixed data at the front, and a PCRE2_SIZE
vector at the end, whose size depends on the number of capturing parentheses in
the pattern. It is not used at all if there are no capturing parentheses.

  frame_size                   is the total size of each frame
  match_data->heapframes       is the pointer to the frames vector
  match_data->heapframes_size  is the allocated size of the vector

We must pad the frame_size for alignment to ensure subsequent frames are as
aligned as heapframe. Whilst ovector is word-aligned due to being a PCRE2_SIZE
array, that does not guarantee it is suitably aligned for pointers, as some
architectures have pointers that are larger than a size_t. */

frame_size = (offsetof(heapframe, ovector) +
  re->top_bracket * 2 * sizeof(PCRE2_SIZE) + HEAPFRAME_ALIGNMENT - 1) &
  ~(HEAPFRAME_ALIGNMENT - 1);

/* Limits set in the pattern override the match context only if they are
smaller. */

mb->heap_limit = ((mcontext->heap_limit < re->limit_heap)?
  mcontext->heap_limit : re->limit_heap);

mb->match_limit = (mcontext->match_limit < re->limit_match)?
  mcontext->match_limit : re->limit_match;

mb->match_limit_depth = (mcontext->depth_limit < re->limit_depth)?
  mcontext->depth_limit : re->limit_depth;

/* If a pattern has very many capturing parentheses, the frame size may be very
large. Set the initial frame vector size to ensure that there are at least 10
available frames, but enforce a minimum of START_FRAMES_SIZE. If this is
greater than the heap limit, get as large a vector as possible. */

heapframes_size = frame_size * 10;
if (heapframes_size < START_FRAMES_SIZE) heapframes_size = START_FRAMES_SIZE;
if (heapframes_size / 1024 > mb->heap_limit)
  {
  PCRE2_SIZE max_size = 1024 * mb->heap_limit;
  if (max_size < frame_size) return PCRE2_ERROR_HEAPLIMIT;
  heapframes_size = max_size;
  }

/* If an existing frame vector in the match_data block is large enough, we can
use it. Otherwise, free any pre-existing vector and get a new one. */

if (match_data->heapframes_size < heapframes_size)
  {
  match_data->memctl.free(match_data->heapframes,
    match_data->memctl.memory_data);
  match_data->heapframes = match_data->memctl.malloc(heapframes_size,
    match_data->memctl.memory_data);
  if (match_data->heapframes == NULL)
    {
    match_data->heapframes_size = 0;
    return PCRE2_ERROR_NOMEMORY;
    }
  match_data->heapframes_size = heapframes_size;
  }

/* Write to the ovector within the first frame to mark every capture unset and
to avoid uninitialized memory read errors when it is copied to a new frame. */

memset((char *)(match_data->heapframes) + offsetof(heapframe, ovector), 0xff,
  frame_size - offsetof(heapframe, ovector));

/* Pointers to the individual character tables */

mb->lcc = re->tables + lcc_offset;
mb->fcc = re->tables + fcc_offset;
mb->ctypes = re->tables + ctypes_offset;

/* Set up the first code unit to match, if available. If there's no first code
unit there may be a bitmap of possible first characters. */

if ((re->flags & PCRE2_FIRSTSET) != 0)
  {
  has_first_cu = TRUE;
  first_cu = first_cu2 = (PCRE2_UCHAR)(re->first_codeunit);
  if ((re->flags & PCRE2_FIRSTCASELESS) != 0)
    {
    first_cu2 = TABLE_GET(first_cu, mb->fcc, first_cu);
#ifdef SUPPORT_UNICODE
#if PCRE2_CODE_UNIT_WIDTH == 8
    if (first_cu > 127 && ucp && !utf) first_cu2 = UCD_OTHERCASE(first_cu);
#else
    if (first_cu > 127 && (utf || ucp)) first_cu2 = UCD_OTHERCASE(first_cu);
#endif
#endif  /* SUPPORT_UNICODE */
    }
  }
else
  if (!startline && (re->flags & PCRE2_FIRSTMAPSET) != 0)
    start_bits = re->start_bitmap;

/* There may also be a "last known required character" set. */

if ((re->flags & PCRE2_LASTSET) != 0)
  {
  has_req_cu = TRUE;
  req_cu = req_cu2 = (PCRE2_UCHAR)(re->last_codeunit);
  if ((re->flags & PCRE2_LASTCASELESS) != 0)
    {
    req_cu2 = TABLE_GET(req_cu, mb->fcc, req_cu);
#ifdef SUPPORT_UNICODE
#if PCRE2_CODE_UNIT_WIDTH == 8
    if (req_cu > 127 && ucp && !utf) req_cu2 = UCD_OTHERCASE(req_cu);
#else
    if (req_cu > 127 && (utf || ucp)) req_cu2 = UCD_OTHERCASE(req_cu);
#endif
#endif  /* SUPPORT_UNICODE */
    }
  }


/* ==========================================================================*/

/* Loop for handling unanchored repeated matching attempts; for anchored regexs
the loop runs just once. */

#ifdef SUPPORT_UNICODE
FRAGMENT_RESTART:
#endif

start_partial = match_partial = NULL;
mb->hitend = FALSE;

#if PCRE2_CODE_UNIT_WIDTH == 8
memchr_found_first_cu = NULL;
memchr_found_first_cu2 = NULL;
#endif

for(;;)
  {
  PCRE2_SPTR new_start_match;

  /* ----------------- Start of match optimizations ---------------- */

  /* There are some optimizations that avoid running the match if a known
  starting point is not found, or if a known later code unit is not present.
  However, there is an option (settable at compile time) that disables these,
  for testing and for ensuring that all callouts do actually occur. */

  if ((re->optimization_flags & PCRE2_OPTIM_START_OPTIMIZE) != 0)
    {
    /* If firstline is TRUE, the start of the match is constrained to the first
    line of a multiline string. That is, the match must be before or at the
    first newline following the start of matching. Temporarily adjust
    end_subject so that we stop the scans for a first code unit at a newline.
    If the match fails at the newline, later code breaks the loop. */

    if (firstline)
      {
      PCRE2_SPTR t = start_match;
#ifdef SUPPORT_UNICODE
      if (utf)
        {
        while (t < end_subject && !IS_NEWLINE(t))
          {
          t++;
          ACROSSCHAR(t < end_subject, t, t++);
          }
        }
      else
#endif
      while (t < end_subject && !IS_NEWLINE(t)) t++;
      end_subject = t;
      }

    /* Anchored: check the first code unit if one is recorded. This may seem
    pointless but it can help in detecting a no match case without scanning for
    the required code unit. */

    if (anchored)
      {
      if (has_first_cu || start_bits != NULL)
        {
        BOOL ok = start_match < end_subject;
        if (ok)
          {
          PCRE2_UCHAR c = UCHAR21TEST(start_match);
          ok = has_first_cu && (c == first_cu || c == first_cu2);
          if (!ok && start_bits != NULL)
            {
#if PCRE2_CODE_UNIT_WIDTH != 8
            if (c > 255) c = 255;
#endif
            ok = (start_bits[c/8] & (1u << (c&7))) != 0;
            }
          }
        if (!ok)
          {
          rc = MATCH_NOMATCH;
          break;
          }
        }
      }

    /* Not anchored. Advance to a unique first code unit if there is one. */

    else
      {
      if (has_first_cu)
        {
        if (first_cu != first_cu2)  /* Caseless */
          {
          /* In 16-bit and 32_bit modes we have to do our own search, so can
          look for both cases at once. */

#if PCRE2_CODE_UNIT_WIDTH != 8
          PCRE2_UCHAR smc;
          while (start_match < end_subject &&
                (smc = UCHAR21TEST(start_match)) != first_cu &&
                 smc != first_cu2)
            start_match++;
#else
          /* In 8-bit mode, the use of memchr() gives a big speed up, even
          though we have to call it twice in order to find the earliest
          occurrence of the code unit in either of its cases. Caching is used
          to remember the positions of previously found code units. This can
          make a huge difference when the strings are very long and only one
          case is actually present. */

          PCRE2_SPTR pp1 = NULL;
          PCRE2_SPTR pp2 = NULL;
          PCRE2_SIZE searchlength = end_subject - start_match;

          /* If we haven't got a previously found position for first_cu, or if
          the current starting position is later, we need to do a search. If
          the code unit is not found, set it to the end. */

          if (memchr_found_first_cu == NULL ||
              start_match > memchr_found_first_cu)
            {
            pp1 = memchr(start_match, first_cu, searchlength);
            memchr_found_first_cu = (pp1 == NULL)? end_subject : pp1;
            }

          /* If the start is before a previously found position, use the
          previous position, or NULL if a previous search failed. */

          else pp1 = (memchr_found_first_cu == end_subject)? NULL :
            memchr_found_first_cu;

          /* Do the same thing for the other case. */

          if (memchr_found_first_cu2 == NULL ||
              start_match > memchr_found_first_cu2)
            {
            pp2 = memchr(start_match, first_cu2, searchlength);
            memchr_found_first_cu2 = (pp2 == NULL)? end_subject : pp2;
            }

          else pp2 = (memchr_found_first_cu2 == end_subject)? NULL :
            memchr_found_first_cu2;

          /* Set the start to the end of the subject if neither case was found.
          Otherwise, use the earlier found point. */

          if (pp1 == NULL)
            start_match = (pp2 == NULL)? end_subject : pp2;
          else
            start_match = (pp2 == NULL || pp1 < pp2)? pp1 : pp2;

#endif  /* 8-bit handling */
          }

        /* The caseful case is much simpler. */

        else
          {
#if PCRE2_CODE_UNIT_WIDTH != 8
          while (start_match < end_subject && UCHAR21TEST(start_match) !=
                 first_cu)
            start_match++;
#else
          start_match = memchr(start_match, first_cu, end_subject - start_match);
          if (start_match == NULL) start_match = end_subject;
#endif
          }

        /* If we can't find the required first code unit, having reached the
        true end of the subject, break the bumpalong loop, to force a match
        failure, except when doing partial matching, when we let the next cycle
        run at the end of the subject. To see why, consider the pattern
        /(?<=abc)def/, which partially matches "abc", even though the string
        does not contain the starting character "d". If we have not reached the
        true end of the subject (PCRE2_FIRSTLINE caused end_subject to be
        temporarily modified) we also let the cycle run, because the matching
        string is legitimately allowed to start with the first code unit of a
        newline. */

        if (mb->partial == 0 && start_match >= mb->end_subject)
          {
          rc = MATCH_NOMATCH;
          break;
          }
        }

      /* If there's no first code unit, advance to just after a linebreak for a
      multiline match if required. */

      else if (startline)
        {
        if (start_match > mb->start_subject + start_offset)
          {
#ifdef SUPPORT_UNICODE
          if (utf)
            {
            while (start_match < end_subject && !WAS_NEWLINE(start_match))
              {
              start_match++;
              ACROSSCHAR(start_match < end_subject, start_match, start_match++);
              }
            }
          else
#endif
          while (start_match < end_subject && !WAS_NEWLINE(start_match))
            start_match++;

          /* If we have just passed a CR and the newline option is ANY or
          ANYCRLF, and we are now at a LF, advance the match position by one
          more code unit. */

          if (start_match[-1] == CHAR_CR &&
               (mb->nltype == NLTYPE_ANY || mb->nltype == NLTYPE_ANYCRLF) &&
               start_match < end_subject &&
               UCHAR21TEST(start_match) == CHAR_NL)
            start_match++;
          }
        }

      /* If there's no first code unit or a requirement for a multiline line
      start, advance to a non-unique first code unit if any have been
      identified. The bitmap contains only 256 bits. When code units are 16 or
      32 bits wide, all code units greater than 254 set the 255 bit. */

      else if (start_bits != NULL)
        {
        while (start_match < end_subject)
          {
          uint32_t c = UCHAR21TEST(start_match);
#if PCRE2_CODE_UNIT_WIDTH != 8
          if (c > 255) c = 255;
#endif
          if ((start_bits[c/8] & (1u << (c&7))) != 0) break;
          start_match++;
          }

        /* See comment above in first_cu checking about the next few lines. */

        if (mb->partial == 0 && start_match >= mb->end_subject)
          {
          rc = MATCH_NOMATCH;
          break;
          }
        }
      }   /* End first code unit handling */

    /* Restore fudged end_subject */

    end_subject = mb->end_subject;

    /* The following two optimizations must be disabled for partial matching. */

    if (mb->partial == 0)
      {
      PCRE2_SPTR p;

      /* The minimum matching length is a lower bound; no string of that length
      may actually match the pattern. Although the value is, strictly, in
      characters, we treat it as code units to avoid spending too much time in
      this optimization. */

      if (end_subject - start_match < re->minlength)
        {
        rc = MATCH_NOMATCH;
        break;
        }

      /* If req_cu is set, we know that that code unit must appear in the
      subject for the (non-partial) match to succeed. If the first code unit is
      set, req_cu must be later in the subject; otherwise the test starts at
      the match point. This optimization can save a huge amount of backtracking
      in patterns with nested unlimited repeats that aren't going to match.
      Writing separate code for caseful/caseless versions makes it go faster,
      as does using an autoincrement and backing off on a match. As in the case
      of the first code unit, using memchr() in the 8-bit library gives a big
      speed up. Unlike the first_cu check above, we do not need to call
      memchr() twice in the caseless case because we only need to check for the
      presence of the character in either case, not find the first occurrence.

      The search can be skipped if the code unit was found later than the
      current starting point in a previous iteration of the bumpalong loop.

      HOWEVER: when the subject string is very, very long, searching to its end
      can take a long time, and give bad performance on quite ordinary
      anchored patterns. This showed up when somebody was matching something
      like /^\d+C/ on a 32-megabyte string... so we don't do this when the
      string is sufficiently long, but it's worth searching a lot more for
      unanchored patterns. */

      p = start_match + (has_first_cu? 1:0);
      if (has_req_cu && p > req_cu_ptr)
        {
        PCRE2_SIZE check_length = end_subject - start_match;

        if (check_length < REQ_CU_MAX ||
              (!anchored && check_length < REQ_CU_MAX * 1000))
          {
          if (req_cu != req_cu2)  /* Caseless */
            {
#if PCRE2_CODE_UNIT_WIDTH != 8
            while (p < end_subject)
              {
              uint32_t pp = UCHAR21INCTEST(p);
              if (pp == req_cu || pp == req_cu2) { p--; break; }
              }
#else  /* 8-bit code units */
            PCRE2_SPTR pp = p;
            p = memchr(pp, req_cu, end_subject - pp);
            if (p == NULL)
              {
              p = memchr(pp, req_cu2, end_subject - pp);
              if (p == NULL) p = end_subject;
              }
#endif /* PCRE2_CODE_UNIT_WIDTH != 8 */
            }

          /* The caseful case */

          else
            {
#if PCRE2_CODE_UNIT_WIDTH != 8
            while (p < end_subject)
              {
              if (UCHAR21INCTEST(p) == req_cu) { p--; break; }
              }

#else  /* 8-bit code units */
            p = memchr(p, req_cu, end_subject - p);
            if (p == NULL) p = end_subject;
#endif
            }

          /* If we can't find the required code unit, break the bumpalong loop,
          forcing a match failure. */

          if (p >= end_subject)
            {
            rc = MATCH_NOMATCH;
            break;
            }

          /* If we have found the required code unit, save the point where we
          found it, so that we don't search again next time round the bumpalong
          loop if the start hasn't yet passed this code unit. */

          req_cu_ptr = p;
          }
        }
      }
    }

  /* ------------ End of start of match optimizations ------------ */

  /* Give no match if we have passed the bumpalong limit. */

  if (start_match > bumpalong_limit)
    {
    rc = MATCH_NOMATCH;
    break;
    }

  /* OK, we can now run the match. If "hitend" is set afterwards, remember the
  first starting point for which a partial match was found. */

  cb.start_match = (PCRE2_SIZE)(start_match - subject);
  cb.callout_flags |= PCRE2_CALLOUT_STARTMATCH;

  mb->start_used_ptr = start_match;
  mb->last_used_ptr = start_match;
#ifdef SUPPORT_UNICODE
  mb->moptions = options | fragment_options;
#else
  mb->moptions = options;
#endif
  mb->match_call_count = 0;
  mb->end_offset_top = 0;
  mb->skip_arg_count = 0;

#ifdef DEBUG_SHOW_OPS
  fprintf(stderr, "++ Calling match()\n");
#endif

  rc = match(start_match, mb->start_code, re->top_bracket, frame_size,
    match_data, mb);

#ifdef DEBUG_SHOW_OPS
  fprintf(stderr, "++ match() returned %d\n\n", rc);
#endif

  if (mb->hitend && start_partial == NULL)
    {
    start_partial = mb->start_used_ptr;
    match_partial = start_match;
    }

  switch(rc)
    {
    /* If MATCH_SKIP_ARG reaches this level it means that a MARK that matched
    the SKIP's arg was not found. In this circumstance, Perl ignores the SKIP
    entirely. The only way we can do that is to re-do the match at the same
    point, with a flag to force SKIP with an argument to be ignored. Just
    treating this case as NOMATCH does not work because it does not check other
    alternatives in patterns such as A(*SKIP:A)B|AC when the subject is AC. */

    case MATCH_SKIP_ARG:
    new_start_match = start_match;
    mb->ignore_skip_arg = mb->skip_arg_count;
    break;

    /* SKIP passes back the next starting point explicitly, but if it is no
    greater than the match we have just done, treat it as NOMATCH. */

    case MATCH_SKIP:
    if (mb->verb_skip_ptr > start_match)
      {
      new_start_match = mb->verb_skip_ptr;
      break;
      }
    /* Fall through */

    /* NOMATCH and PRUNE advance by one character. THEN at this level acts
    exactly like PRUNE. Unset ignore SKIP-with-argument. */

    case MATCH_NOMATCH:
    case MATCH_PRUNE:
    case MATCH_THEN:
    mb->ignore_skip_arg = 0;
    new_start_match = start_match + 1;
#ifdef SUPPORT_UNICODE
    if (utf)
      ACROSSCHAR(new_start_match < end_subject, new_start_match,
        new_start_match++);
#endif
    break;

    /* COMMIT disables the bumpalong, but otherwise behaves as NOMATCH. */

    case MATCH_COMMIT:
    rc = MATCH_NOMATCH;
    goto ENDLOOP;

    /* Any other return is either a match, or some kind of error. */

    default:
    goto ENDLOOP;
    }

  /* Control reaches here for the various types of "no match at this point"
  result. Reset the code to MATCH_NOMATCH for subsequent checking. */

  rc = MATCH_NOMATCH;

  /* If PCRE2_FIRSTLINE is set, the match must happen before or at the first
  newline in the subject (though it may continue over the newline). Therefore,
  if we have just failed to match, starting at a newline, do not continue. */

  if (firstline && IS_NEWLINE(start_match)) break;

  /* Advance to new matching position */

  start_match = new_start_match;

  /* Break the loop if the pattern is anchored or if we have passed the end of
  the subject. */

  if (anchored || start_match > end_subject) break;

  /* If we have just passed a CR and we are now at a LF, and the pattern does
  not contain any explicit matches for \r or \n, and the newline option is CRLF
  or ANY or ANYCRLF, advance the match position by one more code unit. In
  normal matching start_match will aways be greater than the first position at
  this stage, but a failed *SKIP can cause a return at the same point, which is
  why the first test exists. */

  if (start_match > subject + start_offset &&
      start_match[-1] == CHAR_CR &&
      start_match < end_subject &&
      *start_match == CHAR_NL &&
      (re->flags & PCRE2_HASCRORLF) == 0 &&
        (mb->nltype == NLTYPE_ANY ||
         mb->nltype == NLTYPE_ANYCRLF ||
         mb->nllen == 2))
    start_match++;

  mb->mark = NULL;   /* Reset for start of next match attempt */
  }                  /* End of for(;;) "bumpalong" loop */

/* ==========================================================================*/

/* When we reach here, one of the following stopping conditions is true:

(1) The match succeeded, either completely, or partially;

(2) The pattern is anchored or the match was failed after (*COMMIT);

(3) We are past the end of the subject or the bumpalong limit;

(4) PCRE2_FIRSTLINE is set and we have failed to match at a newline, because
    this option requests that a match occur at or before the first newline in
    the subject.

(5) Some kind of error occurred.

*/

ENDLOOP:

/* If end_subject != true_end_subject, it means we are handling invalid UTF,
and have just processed a non-terminal fragment. If this resulted in no match
or a partial match we must carry on to the next fragment (a partial match is
returned to the caller only at the very end of the subject). A loop is used to
avoid trying to match against empty fragments; if the pattern can match an
empty string it would have done so already. */

#ifdef SUPPORT_UNICODE
if (utf && end_subject != true_end_subject &&
    (rc == MATCH_NOMATCH || rc == PCRE2_ERROR_PARTIAL))
  {
  for (;;)
    {
    /* Advance past the first bad code unit, and then skip invalid character
    starting code units in 8-bit and 16-bit modes. */

    start_match = end_subject + 1;

#if PCRE2_CODE_UNIT_WIDTH != 32
    while (start_match < true_end_subject && NOT_FIRSTCU(*start_match))
      start_match++;
#endif

    /* If we have hit the end of the subject, there isn't another non-empty
    fragment, so give up. */

    if (start_match >= true_end_subject)
      {
      rc = MATCH_NOMATCH;  /* In case it was partial */
      match_partial = NULL;
      break;
      }

    /* Check the rest of the subject */

    mb->check_subject = start_match;
    rc = PRIV(valid_utf)(start_match, length - (start_match - subject),
      &(match_data->startchar));

    /* The rest of the subject is valid UTF. */

    if (rc == 0)
      {
      mb->end_subject = end_subject = true_end_subject;
      fragment_options = PCRE2_NOTBOL;
      goto FRAGMENT_RESTART;
      }

    /* A subsequent UTF error has been found; if the next fragment is
    non-empty, set up to process it. Otherwise, let the loop advance. */

    else if (rc < 0)
      {
      mb->end_subject = end_subject = start_match + match_data->startchar;
      if (end_subject > start_match)
        {
        fragment_options = PCRE2_NOTBOL|PCRE2_NOTEOL;
        goto FRAGMENT_RESTART;
        }
      }
    }
  }
#endif  /* SUPPORT_UNICODE */

/* Fill in fields that are always returned in the match data. */

match_data->code = re;
match_data->mark = mb->mark;
match_data->matchedby = PCRE2_MATCHEDBY_INTERPRETER;

/* Handle a fully successful match. Set the return code to the number of
captured strings, or 0 if there were too many to fit into the ovector, and then
set the remaining returned values before returning. Make a copy of the subject
string if requested. */

if (rc == MATCH_MATCH)
  {
  match_data->rc = ((int)mb->end_offset_top >= 2 * match_data->oveccount)?
    0 : (int)mb->end_offset_top/2 + 1;
  match_data->subject_length = length;
  match_data->startchar = start_match - subject;
  match_data->leftchar = mb->start_used_ptr - subject;
  match_data->rightchar = ((mb->last_used_ptr > mb->end_match_ptr)?
    mb->last_used_ptr : mb->end_match_ptr) - subject;
  if ((options & PCRE2_COPY_MATCHED_SUBJECT) != 0)
    {
    length = CU2BYTES(length + was_zero_terminated);
    match_data->subject = match_data->memctl.malloc(length,
      match_data->memctl.memory_data);
    if (match_data->subject == NULL) return PCRE2_ERROR_NOMEMORY;
    memcpy((void *)match_data->subject, subject, length);
    match_data->flags |= PCRE2_MD_COPIED_SUBJECT;
    }
  else match_data->subject = subject;

  return match_data->rc;
  }

/* Control gets here if there has been a partial match, an error, or if the
overall match attempt has failed at all permitted starting positions. Any mark
data is in the nomatch_mark field. */

match_data->mark = mb->nomatch_mark;

/* For anything other than nomatch or partial match, just return the code. */

if (rc != MATCH_NOMATCH && rc != PCRE2_ERROR_PARTIAL) match_data->rc = rc;

/* Handle a partial match. If a "soft" partial match was requested, searching
for a complete match will have continued, and the value of rc at this point
will be MATCH_NOMATCH. For a "hard" partial match, it will already be
PCRE2_ERROR_PARTIAL. */

else if (match_partial != NULL)
  {
  match_data->subject = subject;
  match_data->subject_length = length;
  match_data->ovector[0] = match_partial - subject;
  match_data->ovector[1] = end_subject - subject;
  match_data->startchar = match_partial - subject;
  match_data->leftchar = start_partial - subject;
  match_data->rightchar = end_subject - subject;
  match_data->rc = PCRE2_ERROR_PARTIAL;
  }

/* Else this is the classic nomatch case. */

else match_data->rc = PCRE2_ERROR_NOMATCH;

return match_data->rc;
}

/* These #undefs are here to enable unity builds with CMake. */

#undef NLBLOCK /* Block containing newline information */
#undef PSSTART /* Field containing processed string start */
#undef PSEND   /* Field containing processed string end */

/* End of pcre2_match.c */


================================================
FILE: Libraries/PCRE/pcre2_match_data.c
================================================
/*************************************************
*      Perl-Compatible Regular Expressions       *
*************************************************/

/* PCRE is a library of functions to support regular expressions whose syntax
and semantics are as close as possible to those of the Perl 5 language.

                       Written by Philip Hazel
     Original API code Copyright (c) 1997-2012 University of Cambridge
          New API code Copyright (c) 2016-2024 University of Cambridge

-----------------------------------------------------------------------------
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

    * Redistributions of source code must retain the above copyright notice,
      this list of conditions and the following disclaimer.

    * Redistributions in binary form must reproduce the above copyright
      notice, this list of conditions and the following disclaimer in the
      documentation and/or other materials provided with the distribution.

    * Neither the name of the University of Cambridge nor the names of its
      contributors may be used to endorse or promote products derived from
      this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
-----------------------------------------------------------------------------
*/

//au
//#define USE_PRINT
#ifdef USE_PRINT

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <Windows.h>

HWND s_QM2;
#define STR const wchar_t*

void Print(STR s) {
    if (!IsWindow(s_QM2)) {
        s_QM2 = FindWindowW(L"QM_Editor", 0); if (!s_QM2) return;
    }
    DWORD_PTR res;
    SendMessageTimeoutW(s_QM2, WM_SETTEXT, -1, (LPARAM)(s ? s : L""), SMTO_BLOCK | SMTO_ABORTIFHUNG, 5000, &res);
}

void Printf(STR frm, ...) {
    wchar_t b[10000];
    _vsnwprintf(b, 9990, frm, (va_list)(&frm + 1));
    Print(b);
}

#endif


#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include "pcre2_internal.h"



/*************************************************
*  Create a match data block given ovector size  *
*************************************************/

/* A minimum of 1 is imposed on the number of ovector pairs. A maximum is also
imposed because the oveccount field in a match data block is uintt6_t. */

PCRE2_EXP_DEFN pcre2_match_data * PCRE2_CALL_CONVENTION
pcre2_match_data_create(uint32_t oveccount, pcre2_general_context *gcontext)
{
pcre2_match_data *yield;
if (oveccount < 1) oveccount = 1;
if (oveccount > UINT16_MAX) oveccount = UINT16_MAX;
yield = PRIV(memctl_malloc)(
  offsetof(pcre2_match_data, ovector) + 2*oveccount*sizeof(PCRE2_SIZE),
  (pcre2_memctl *)gcontext);
if (yield == NULL) return NULL;
yield->oveccount = oveccount;
yield->flags = 0;
yield->heapframes = NULL;
yield->heapframes_size = 0;
return yield;
}



/*************************************************
*  Create a match data block using pattern data  *
*************************************************/

/* If no context is supplied, use the memory allocator from the code. This code
assumes that a general context contains nothing other than a memory allocator.
If that ever changes, this code will need fixing. */

PCRE2_EXP_DEFN pcre2_match_data * PCRE2_CALL_CONVENTION
pcre2_match_data_create_from_pattern(const pcre2_code *code,
  pcre2_general_context *gcontext)
{
if (gcontext == NULL) gcontext = (pcre2_general_context *)code;
return pcre2_match_data_create(((const pcre2_real_code *)code)->top_bracket + 1,
  gcontext);
}



/*************************************************
*            Free a match data block             *
*************************************************/

PCRE2_EXP_DEFN void PCRE2_CALL_CONVENTION
pcre2_match_data_free(pcre2_match_data *match_data)
{
if (match_data != NULL)
  {
  if (match_data->heapframes != NULL)
    match_data->memctl.free(match_data->heapframes,
      match_data->memctl.memory_data);
  if ((match_data->flags & PCRE2_MD_COPIED_SUBJECT) != 0)
    match_data->memctl.free((void *)match_data->subject,
      match_data->memctl.memory_data);
  match_data->memctl.free(match_data, match_data->memctl.memory_data);
  }
}



/*************************************************
*         Get last mark in match                 *
*************************************************/

PCRE2_EXP_DEFN PCRE2_SPTR PCRE2_CALL_CONVENTION
pcre2_get_mark(pcre2_match_data *match_data)
{
return match_data->mark;
}



/*************************************************
*          Get pointer to ovector                *
*************************************************/

PCRE2_EXP_DEFN PCRE2_SIZE * PCRE2_CALL_CONVENTION
pcre2_get_ovector_pointer(pcre2_match_data *match_data)
{
return match_data->ovector;
}



/*************************************************
*          Get number of ovector slots           *
*************************************************/

PCRE2_EXP_DEFN uint32_t PCRE2_CALL_CONVENTION
pcre2_get_ovector_count(pcre2_match_data *match_data)
{
return match_data->oveccount;
}



/*************************************************
*         Get starting code unit in match        *
*************************************************/

PCRE2_EXP_DEFN PCRE2_SIZE PCRE2_CALL_CONVENTION
pcre2_get_startchar(pcre2_match_data *match_data)
{
return match_data->startchar;
}



/*************************************************
*         Get size of match data block           *
*************************************************/

PCRE2_EXP_DEFN PCRE2_SIZE PCRE2_CALL_CONVENTION
pcre2_get_match_data_size(pcre2_match_data *match_data)
{
return offsetof(pcre2_match_data, ovector) +
  2 * (match_data->oveccount) * sizeof(PCRE2_SIZE);
}



/*************************************************
*             Get heapframes size                *
*************************************************/

PCRE2_EXP_DEFN PCRE2_SIZE PCRE2_CALL_CONVENTION
pcre2_get_match_data_heapframes_size(pcre2_match_data *match_data)
{
return match_data->heapframes_size;
}

/* End of pcre2_match_data.c */


================================================
FILE: Libraries/PCRE/pcre2_newline.c
================================================
/*************************************************
*      Perl-Compatible Regular Expressions       *
*************************************************/

/* PCRE is a library of functions to support regular expressions whose syntax
and semantics are as close as possible to those of the Perl 5 language.

                       Written by Philip Hazel
     Original API code Copyright (c) 1997-2012 University of Cambridge
         New API code Copyright (c) 2016 University of Cambridge

-----------------------------------------------------------------------------
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

    * Redistributions of source code must retain the above copyright notice,
      this list of conditions and the following disclaimer.

    * Redistributions in binary form must reproduce the above copyright
      notice, this list of conditions and the following disclaimer in the
      documentation and/or other materials provided with the distribution.

    * Neither the name of the University of Cambridge nor the names of its
      contributors may be used to endorse or promote products derived from
      this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
-----------------------------------------------------------------------------
*/


/* This module contains internal functions for testing newlines when more than
one kind of newline is to be recognized. When a newline is found, its length is
returned. In principle, we could implement several newline "types", each
referring to a different set of newline characters. At present, PCRE2 supports
only NLTYPE_FIXED, which gets handled without these functions, NLTYPE_ANYCRLF,
and NLTYPE_ANY. The full list of Unicode newline characters is taken from
http://unicode.org/unicode/reports/tr18/. */


#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include "pcre2_internal.h"



/*************************************************
*      Check for newline at given position       *
*************************************************/

/* This function is called only via the IS_NEWLINE macro, which does so only
when the newline type is NLTYPE_ANY or NLTYPE_ANYCRLF. The case of a fixed
newline (NLTYPE_FIXED) is handled inline. It is guaranteed that the code unit
pointed to by ptr is less than the end of the string.

Arguments:
  ptr          pointer to possible newline
  type         the newline type
  endptr       pointer to the end of the string
  lenptr       where to return the length
  utf          TRUE if in utf mode

Returns:       TRUE or FALSE
*/

BOOL
PRIV(is_newline)(PCRE2_SPTR ptr, uint32_t type, PCRE2_SPTR endptr,
  uint32_t *lenptr, BOOL utf)
{
uint32_t c;

#ifdef SUPPORT_UNICODE
if (utf) { GETCHAR(c, ptr); } else c = *ptr;
#else
(void)utf;
c = *ptr;
#endif  /* SUPPORT_UNICODE */

if (type == NLTYPE_ANYCRLF) switch(c)
  {
  case CHAR_LF:
  *lenptr = 1;
  return TRUE;

  case CHAR_CR:
  *lenptr = (ptr < endptr - 1 && ptr[1] == CHAR_LF)? 2 : 1;
  return TRUE;

  default:
  return FALSE;
  }

/* NLTYPE_ANY */

else switch(c)
  {
#ifdef EBCDIC
  case CHAR_NEL:
#endif
  case CHAR_LF:
  case CHAR_VT:
  case CHAR_FF:
  *lenptr = 1;
  return TRUE;

  case CHAR_CR:
  *lenptr = (ptr < endptr - 1 && ptr[1] == CHAR_LF)? 2 : 1;
  return TRUE;

#ifndef EBCDIC
#if PCRE2_CODE_UNIT_WIDTH == 8
  case CHAR_NEL:
  *lenptr = utf? 2 : 1;
  return TRUE;

  case 0x2028:   /* LS */
  case 0x2029:   /* PS */
  *lenptr = 3;
  return TRUE;

#else  /* 16-bit or 32-bit code units */
  case CHAR_NEL:
  case 0x2028:   /* LS */
  case 0x2029:   /* PS */
  *lenptr = 1;
  return TRUE;
#endif
#endif /* Not EBCDIC */

  default:
  return FALSE;
  }
}



/*************************************************
*     Check for newline at previous position     *
*************************************************/

/* This function is called only via the WAS_NEWLINE macro, which does so only
when the newline type is NLTYPE_ANY or NLTYPE_ANYCRLF. The case of a fixed
newline (NLTYPE_FIXED) is handled inline. It is guaranteed that the initial
value of ptr is greater than the start of the string that is being processed.

Arguments:
  ptr          pointer to possible newline
  type         the newline type
  startptr     pointer to the start of the string
  lenptr       where to return the length
  utf          TRUE if in utf mode

Returns:       TRUE or FALSE
*/

BOOL
PRIV(was_newline)(PCRE2_SPTR ptr, uint32_t type, PCRE2_SPTR startptr,
  uint32_t *lenptr, BOOL utf)
{
uint32_t c;
ptr--;

#ifdef SUPPORT_UNICODE
if (utf)
  {
  BACKCHAR(ptr);
  GETCHAR(c, ptr);
  }
else c = *ptr;
#else
(void)utf;
c = *ptr;
#endif  /* SUPPORT_UNICODE */

if (type == NLTYPE_ANYCRLF) switch(c)
  {
  case CHAR_LF:
  *lenptr = (ptr > startptr && ptr[-1] == CHAR_CR)? 2 : 1;
  return TRUE;

  case CHAR_CR:
  *lenptr = 1;
  return TRUE;

  default:
  return FALSE;
  }

/* NLTYPE_ANY */

else switch(c)
  {
  case CHAR_LF:
  *lenptr = (ptr > startptr && ptr[-1] == CHAR_CR)? 2 : 1;
  return TRUE;

#ifdef EBCDIC
  case CHAR_NEL:
#endif
  case CHAR_VT:
  case CHAR_FF:
  case CHAR_CR:
  *lenptr = 1;
  return TRUE;

#ifndef EBCDIC
#if PCRE2_CODE_UNIT_WIDTH == 8
  case CHAR_NEL:
  *lenptr = utf? 2 : 1;
  return TRUE;

  case 0x2028:   /* LS */
  case 0x2029:   /* PS */
  *lenptr = 3;
  return TRUE;

#else /* 16-bit or 32-bit code units */
  case CHAR_NEL:
  case 0x2028:   /* LS */
  case 0x2029:   /* PS */
  *lenptr = 1;
  return TRUE;
#endif
#endif /* Not EBCDIC */

  default:
  return FALSE;
  }
}

/* End of pcre2_newline.c */


================================================
FILE: Libraries/PCRE/pcre2_ord2utf.c
================================================
/*************************************************
*      Perl-Compatible Regular Expressions       *
*************************************************/

/* PCRE is a library of functions to support regular expressions whose syntax
and semantics are as close as possible to those of the Perl 5 language.

                       Written by Philip Hazel
     Original API code Copyright (c) 1997-2012 University of Cambridge
         New API code Copyright (c) 2016 University of Cambridge

-----------------------------------------------------------------------------
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

    * Redistributions of source code must retain the above copyright notice,
      this list of conditions and the following disclaimer.

    * Redistributions in binary form must reproduce the above copyright
      notice, this list of conditions and the following disclaimer in the
      documentation and/or other materials provided with the distribution.

    * Neither the name of the University of Cambridge nor the names of its
      contributors may be used to endorse or promote products derived from
      this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
-----------------------------------------------------------------------------
*/


/* This file contains a function that converts a Unicode character code point
into a UTF string. The behaviour is different for each code unit width. */


#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include "pcre2_internal.h"


/* If SUPPORT_UNICODE is not defined, this function will never be called.
Supply a dummy function because some compilers do not like empty source
modules. */

#ifndef SUPPORT_UNICODE
unsigned int
PRIV(ord2utf)(uint32_t cvalue, PCRE2_UCHAR *buffer)
{
(void)(cvalue);
(void)(buffer);
return 0;
}
#else  /* SUPPORT_UNICODE */


/*************************************************
*          Convert code point to UTF             *
*************************************************/

/*
Arguments:
  cvalue     the character value
  buffer     pointer to buffer for result

Returns:     number of code units placed in the buffer
*/

unsigned int
PRIV(ord2utf)(uint32_t cvalue, PCRE2_UCHAR *buffer)
{
/* Convert to UTF-8 */

#if PCRE2_CODE_UNIT_WIDTH == 8
int i, j;
for (i = 0; i < PRIV(utf8_table1_size); i++)
  if ((int)cvalue <= PRIV(utf8_table1)[i]) break;
buffer += i;
for (j = i; j > 0; j--)
 {
 *buffer-- = 0x80 | (cvalue & 0x3f);
 cvalue >>= 6;
 }
*buffer = PRIV(utf8_table2)[i] | cvalue;
return i + 1;

/* Convert to UTF-16 */

#elif PCRE2_CODE_UNIT_WIDTH == 16
if (cvalue <= 0xffff)
  {
  *buffer = (PCRE2_UCHAR)cvalue;
  return 1;
  }
cvalue -= 0x10000;
*buffer++ = 0xd800 | (cvalue >> 10);
*buffer = 0xdc00 | (cvalue & 0x3ff);
return 2;

/* Convert to UTF-32 */

#else
*buffer = (PCRE2_UCHAR)cvalue;
return 1;
#endif
}
#endif  /* SUPPORT_UNICODE */

/* End of pcre2_ord2utf.c */


================================================
FILE: Libraries/PCRE/pcre2_pattern_info.c
================================================
/*************************************************
*      Perl-Compatible Regular Expressions       *
*************************************************/

/* PCRE is a library of functions to support regular expressions whose syntax
and semantics are as close as possible to those of the Perl 5 language.

                       Written by Philip Hazel
     Original API code Copyright (c) 1997-2012 University of Cambridge
          New API code Copyright (c) 2016-2024 University of Cambridge

-----------------------------------------------------------------------------
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

    * Redistributions of source code must retain the above copyright notice,
      this list of conditions and the following disclaimer.

    * Redistributions in binary form must reproduce the above copyright
      notice, this list of conditions and the following disclaimer in the
      documentation and/or other materials provided with the distribution.

    * Neither the name of the University of Cambridge nor the names of its
      contributors may be used to endorse or promote products derived from
      this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
-----------------------------------------------------------------------------
*/


#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include "pcre2_internal.h"


/*************************************************
*        Return info about compiled pattern      *
*************************************************/

/*
Arguments:
  code          points to compiled code
  what          what information is required
  where         where to put the information; if NULL, return length

Returns:        0 when data returned
                > 0 when length requested
                < 0 on error or unset value
*/

PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
pcre2_pattern_info(const pcre2_code *code, uint32_t what, void *where)
{
const pcre2_real_code *re = (const pcre2_real_code *)code;

if (where == NULL)   /* Requests field length */
  {
  switch(what)
    {
    case PCRE2_INFO_ALLOPTIONS:
    case PCRE2_INFO_ARGOPTIONS:
    case PCRE2_INFO_BACKREFMAX:
    case PCRE2_INFO_BSR:
    case PCRE2_INFO_CAPTURECOUNT:
    case PCRE2_INFO_DEPTHLIMIT:
    case PCRE2_INFO_EXTRAOPTIONS:
    case PCRE2_INFO_FIRSTCODETYPE:
    case PCRE2_INFO_FIRSTCODEUNIT:
    case PCRE2_INFO_HASBACKSLASHC:
    case PCRE2_INFO_HASCRORLF:
    case PCRE2_INFO_HEAPLIMIT:
    case PCRE2_INFO_JCHANGED:
    case PCRE2_INFO_LASTCODETYPE:
    case PCRE2_INFO_LASTCODEUNIT:
    case PCRE2_INFO_MATCHEMPTY:
    case PCRE2_INFO_MATCHLIMIT:
    case PCRE2_INFO_MAXLOOKBEHIND:
    case PCRE2_INFO_MINLENGTH:
    case PCRE2_INFO_NAMEENTRYSIZE:
    case PCRE2_INFO_NAMECOUNT:
    case PCRE2_INFO_NEWLINE:
    return sizeof(uint32_t);

    case PCRE2_INFO_FIRSTBITMAP:
    return sizeof(const uint8_t *);

    case PCRE2_INFO_JITSIZE:
    case PCRE2_INFO_SIZE:
    case PCRE2_INFO_FRAMESIZE:
    return sizeof(size_t);

    case PCRE2_INFO_NAMETABLE:
    return sizeof(PCRE2_SPTR);
    }
  }

if (re == NULL) return PCRE2_ERROR_NULL;

/* Check that the first field in the block is the magic number. If it is not,
return with PCRE2_ERROR_BADMAGIC. */

if (re->magic_number != MAGIC_NUMBER) return PCRE2_ERROR_BADMAGIC;

/* Check that this pattern was compiled in the correct bit mode */

if ((re->flags & (PCRE2_CODE_UNIT_WIDTH/8)) == 0) return PCRE2_ERROR_BADMODE;

switch(what)
  {
  case PCRE2_INFO_ALLOPTIONS:
  *((uint32_t *)where) = re->overall_options;
  break;

  case PCRE2_INFO_ARGOPTIONS:
  *((uint32_t *)where) = re->compile_options;
  break;

  case PCRE2_INFO_BACKREFMAX:
  *((uint32_t *)where) = re->top_backref;
  break;

  case PCRE2_INFO_BSR:
  *((uint32_t *)where) = re->bsr_convention;
  break;

  case PCRE2_INFO_CAPTURECOUNT:
  *((uint32_t *)where) = re->top_bracket;
  break;

  case PCRE2_INFO_DEPTHLIMIT:
  *((uint32_t *)where) = re->limit_depth;
  if (re->limit_depth == UINT32_MAX) return PCRE2_ERROR_UNSET;
  break;

  case PCRE2_INFO_EXTRAOPTIONS:
  *((uint32_t *)where) = re->extra_options;
  break;

  case PCRE2_INFO_FIRSTCODETYPE:
  *((uint32_t *)where) = ((re->flags & PCRE2_FIRSTSET) != 0)? 1 :
                         ((re->flags & PCRE2_STARTLINE) != 0)? 2 : 0;
  break;

  case PCRE2_INFO_FIRSTCODEUNIT:
  *((uint32_t *)where) = ((re->flags & PCRE2_FIRSTSET) != 0)?
    re->first_codeunit : 0;
  break;

  case PCRE2_INFO_FIRSTBITMAP:
  *((const uint8_t **)where) = ((re->flags & PCRE2_FIRSTMAPSET) != 0)?
    &(re->start_bitmap[0]) : NULL;
  break;

  case PCRE2_INFO_FRAMESIZE:
  *((size_t *)where) = offsetof(heapframe, ovector) +
    re->top_bracket * 2 * sizeof(PCRE2_SIZE);
  break;

  case PCRE2_INFO_HASBACKSLASHC:
  *((uint32_t *)where) = (re->flags & PCRE2_HASBKC) != 0;
  break;

  case PCRE2_INFO_HASCRORLF:
  *((uint32_t *)where) = (re->flags & PCRE2_HASCRORLF) != 0;
  break;

  case PCRE2_INFO_HEAPLIMIT:
  *((uint32_t *)where) = re->limit_heap;
  if (re->limit_heap == UINT32_MAX) return PCRE2_ERROR_UNSET;
  break;

  case PCRE2_INFO_JCHANGED:
  *((uint32_t *)where) = (re->flags & PCRE2_JCHANGED) != 0;
  break;

  case PCRE2_INFO_JITSIZE:
#ifdef SUPPORT_JIT
  *((size_t *)where) = (re->executable_jit != NULL)?
    PRIV(jit_get_size)(re->executable_jit) : 0;
#else
  *((size_t *)where) = 0;
#endif
  break;

  case PCRE2_INFO_LASTCODETYPE:
  *((uint32_t *)where) = ((re->flags & PCRE2_LASTSET) != 0)? 1 : 0;
  break;

  case PCRE2_INFO_LASTCODEUNIT:
  *((uint32_t *)where) = ((re->flags & PCRE2_LASTSET) != 0)?
    re->last_codeunit : 0;
  break;

  case PCRE2_INFO_MATCHEMPTY:
  *((uint32_t *)where) = (re->flags & PCRE2_MATCH_EMPTY) != 0;
  break;

  case PCRE2_INFO_MATCHLIMIT:
  *((uint32_t *)where) = re->limit_match;
  if (re->limit_match == UINT32_MAX) return PCRE2_ERROR_UNSET;
  break;

  case PCRE2_INFO_MAXLOOKBEHIND:
  *((uint32_t *)where) = re->max_lookbehind;
  break;

  case PCRE2_INFO_MINLENGTH:
  *((uint32_t *)where) = re->minlength;
  break;

  case PCRE2_INFO_NAMEENTRYSIZE:
  *((uint32_t *)where) = re->name_entry_size;
  break;

  case PCRE2_INFO_NAMECOUNT:
  *((uint32_t *)where) = re->name_count;
  break;

  case PCRE2_INFO_NAMETABLE:
  *((PCRE2_SPTR *)where) = (PCRE2_SPTR)((const char *)re +
    sizeof(pcre2_real_code));
  break;

  case PCRE2_INFO_NEWLINE:
  *((uint32_t *)where) = re->newline_convention;
  break;

  case PCRE2_INFO_SIZE:
  *((size_t *)where) = re->blocksize;
  break;

  default: return PCRE2_ERROR_BADOPTION;
  }

return 0;
}



/*************************************************
*              Callout enumerator                *
*************************************************/

/*
Arguments:
  code          points to compiled code
  callback      function called for each callout block
  callout_data  user data passed to the callback

Returns:        0 when successfully completed
                < 0 on local error
               != 0 for callback error
*/

PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
pcre2_callout_enumerate(const pcre2_code *code,
  int (*callback)(pcre2_callout_enumerate_block *, void *), void *callout_data)
{
const pcre2_real_code *re = (const pcre2_real_code *)code;
pcre2_callout_enumerate_block cb;
PCRE2_SPTR cc;
#ifdef SUPPORT_UNICODE
BOOL utf;
#endif

if (re == NULL) return PCRE2_ERROR_NULL;

#ifdef SUPPORT_UNICODE
utf = (re->overall_options & PCRE2_UTF) != 0;
#endif

/* Check that the first field in the block is the magic number. If it is not,
return with PCRE2_ERROR_BADMAGIC. */

if (re->magic_number != MAGIC_NUMBER) return PCRE2_ERROR_BADMAGIC;

/* Check that this pattern was compiled in the correct bit mode */

if ((re->flags & (PCRE2_CODE_UNIT_WIDTH/8)) == 0) return PCRE2_ERROR_BADMODE;

cb.version = 0;
cc = (PCRE2_SPTR)((const uint8_t *)re + sizeof(pcre2_real_code))
     + re->name_count * re->name_entry_size;

while (TRUE)
  {
  int rc;
  switch (*cc)
    {
    case OP_END:
    return 0;

    case OP_CHAR:
    case OP_CHARI:
    case OP_NOT:
    case OP_NOTI:
    case OP_STAR:
    case OP_MINSTAR:
    case OP_PLUS:
    case OP_MINPLUS:
    case OP_QUERY:
    case OP_MINQUERY:
    case OP_UPTO:
    case OP_MINUPTO:
    case OP_EXACT:
    case OP_POSSTAR:
    case OP_POSPLUS:
    case OP_POSQUERY:
    case OP_POSUPTO:
    case OP_STARI:
    case OP_MINSTARI:
    case OP_PLUSI:
    case OP_MINPLUSI:
    case OP_QUERYI:
    case OP_MINQUERYI:
    case OP_UPTOI:
    case OP_MINUPTOI:
    case OP_EXACTI:
    case OP_POSSTARI:
    case OP_POSPLUSI:
    case OP_POSQUERYI:
    case OP_POSUPTOI:
    case OP_NOTSTAR:
    case OP_NOTMINSTAR:
    case OP_NOTPLUS:
    case OP_NOTMINPLUS:
    case OP_NOTQUERY:
    case OP_NOTMINQUERY:
    case OP_NOTUPTO:
    case OP_NOTMINUPTO:
    case OP_NOTEXACT:
    case OP_NOTPOSSTAR:
    case OP_NOTPOSPLUS:
    case OP_NOTPOSQUERY:
    case OP_NOTPOSUPTO:
    case OP_NOTSTARI:
    case OP_NOTMINSTARI:
    case OP_NOTPLUSI:
    case OP_NOTMINPLUSI:
    case OP_NOTQUERYI:
    case OP_NOTMINQUERYI:
    case OP_NOTUPTOI:
    case OP_NOTMINUPTOI:
    case OP_NOTEXACTI:
    case OP_NOTPOSSTARI:
    case OP_NOTPOSPLUSI:
    case OP_NOTPOSQUERYI:
    case OP_NOTPOSUPTOI:
    cc += PRIV(OP_lengths)[*cc];
#ifdef SUPPORT_UNICODE
    if (utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
#endif
    break;

    case OP_TYPESTAR:
    case OP_TYPEMINSTAR:
    case OP_TYPEPLUS:
    case OP_TYPEMINPLUS:
    case OP_TYPEQUERY:
    case OP_TYPEMINQUERY:
    case OP_TYPEUPTO:
    case OP_TYPEMINUPTO:
    case OP_TYPEEXACT:
    case OP_TYPEPOSSTAR:
    case OP_TYPEPOSPLUS:
    case OP_TYPEPOSQUERY:
    case OP_TYPEPOSUPTO:
    cc += PRIV(OP_lengths)[*cc];
#ifdef SUPPORT_UNICODE
    if (cc[-1] == OP_PROP || cc[-1] == OP_NOTPROP) cc += 2;
#endif
    break;

#ifdef SUPPORT_WIDE_CHARS
    case OP_XCLASS:
    case OP_ECLASS:
    cc += GET(cc, 1);
    break;
#endif

    case OP_MARK:
    case OP_COMMIT_ARG:
    case OP_PRUNE_ARG:
    case OP_SKIP_ARG:
    case OP_THEN_ARG:
    cc += PRIV(OP_lengths)[*cc] + cc[1];
    break;

    case OP_CALLOUT:
    cb.pattern_position = GET(cc, 1);
    cb.next_item_length = GET(cc, 1 + LINK_SIZE);
    cb.callout_number = cc[1 + 2*LINK_SIZE];
    cb.callout_string_offset = 0;
    cb.callout_string_length = 0;
    cb.callout_string = NULL;
    rc = callback(&cb, callout_data);
    if (rc != 0) return rc;
    cc += PRIV(OP_lengths)[*cc];
    break;

    case OP_CALLOUT_STR:
    cb.pattern_position = GET(cc, 1);
    cb.next_item_length = GET(cc, 1 + LINK_SIZE);
    cb.callout_number = 0;
    cb.callout_string_offset = GET(cc, 1 + 3*LINK_SIZE);
    cb.callout_string_length =
      GET(cc, 1 + 2*LINK_SIZE) - (1 + 4*LINK_SIZE) - 2;
    cb.callout_string = cc + (1 + 4*LINK_SIZE) + 1;
    rc = callback(&cb, callout_data);
    if (rc != 0) return rc;
    cc += GET(cc, 1 + 2*LINK_SIZE);
    break;

    default:
    cc += PRIV(OP_lengths)[*cc];
    break;
    }
  }
}

/* End of pcre2_pattern_info.c */


================================================
FILE: Libraries/PCRE/pcre2_script_run.c
================================================
/*************************************************
*      Perl-Compatible Regular Expressions       *
*************************************************/

/* PCRE is a library of functions to support regular expressions whose syntax
and semantics are as close as possible to those of the Perl 5 language.

                       Written by Philip Hazel
     Original API code Copyright (c) 1997-2012 University of Cambridge
          New API code Copyright (c) 2016-2021 University of Cambridge

-----------------------------------------------------------------------------
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

    * Redistributions of source code must retain the above copyright notice,
      this list of conditions and the following disclaimer.

    * Redistributions in binary form must reproduce the above copyright
      notice, this list of conditions and the following disclaimer in the
      documentation and/or other materials provided with the distribution.

    * Neither the name of the University of Cambridge nor the names of its
      contributors may be used to endorse or promote products derived from
      this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
-----------------------------------------------------------------------------
*/

/* This module contains the function for checking a script run. */

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include "pcre2_internal.h"


/*************************************************
*                Check script run                *
*************************************************/

/* A script run is conceptually a sequence of characters all in the same
Unicode script. However, it isn't quite that simple. There are special rules
for scripts that are commonly used together, and also special rules for digits.
This function implements the appropriate checks, which is possible only when
PCRE2 is compiled with Unicode support. The function returns TRUE if there is
no Unicode support; however, it should never be called in that circumstance
because an error is given by pcre2_compile() if a script run is called for in a
version of PCRE2 compiled without Unicode support.

Arguments:
  pgr       point to the first character
  endptr    point after the last character
  utf       TRUE if in UTF mode

Returns:    TRUE if this is a valid script run
*/

/* These are states in the checking process. */

enum { SCRIPT_UNSET,          /* Requirement as yet unknown */
       SCRIPT_MAP,            /* Bitmap contains acceptable scripts */
       SCRIPT_HANPENDING,     /* Have had only Han characters */
       SCRIPT_HANHIRAKATA,    /* Expect Han or Hirikata */
       SCRIPT_HANBOPOMOFO,    /* Expect Han or Bopomofo */
       SCRIPT_HANHANGUL       /* Expect Han or Hangul */
       };

#define UCD_MAPSIZE (ucp_Unknown/32 + 1)
#define FULL_MAPSIZE (ucp_Script_Count/32 + 1)

BOOL
PRIV(script_run)(PCRE2_SPTR ptr, PCRE2_SPTR endptr, BOOL utf)
{
#ifdef SUPPORT_UNICODE
uint32_t require_state = SCRIPT_UNSET;
uint32_t require_map[FULL_MAPSIZE];
uint32_t map[FULL_MAPSIZE];
uint32_t require_digitset = 0;
uint32_t c;

#if PCRE2_CODE_UNIT_WIDTH == 32
(void)utf;    /* Avoid compiler warning */
#endif

/* Any string containing fewer than 2 characters is a valid script run. */

if (ptr >= endptr) return TRUE;
GETCHARINCTEST(c, ptr);
if (ptr >= endptr) return TRUE;

/* Initialize the require map. This is a full-size bitmap that has a bit for
every script, as opposed to the maps in ucd_script_sets, which only have bits
for scripts less than ucp_Unknown - those that appear in script extension
lists. */

for (int i = 0; i < FULL_MAPSIZE; i++) require_map[i] = 0;

/* Scan strings of two or more characters, checking the Unicode characteristics
of each code point. There is special code for scripts that can be combined with
characters from the Han Chinese script. This may be used in conjunction with
four other scripts in these combinations:

. Han with Hiragana and Katakana is allowed (for Japanese).
. Han with Bopomofo is allowed (for Taiwanese Mandarin).
. Han with Hangul is allowed (for Korean).

If the first significant character's script is one of the four, the required
script type is immediately known. However, if the first significant
character's script is Han, we have to keep checking for a non-Han character.
Hence the SCRIPT_HANPENDING state. */

for (;;)
  {
  const ucd_record *ucd = GET_UCD(c);
  uint32_t script = ucd->script;

  /* If the script is Unknown, the string is not a valid script run. Such
  characters can only form script runs of length one (see test above). */

  if (script == ucp_Unknown) return FALSE;

  /* A character without any script extensions whose script is Inherited or
  Common is always accepted with any script. If there are extensions, the
  following processing happens for all scripts. */

  if (UCD_SCRIPTX_PROP(ucd) != 0 || (script != ucp_Inherited && script != ucp_Common))
    {
    BOOL OK;

    /* Set up a full-sized map for this character that can include bits for all
    scripts. Copy the scriptx map for this character (which covers those
    scripts that appear in script extension lists), set the remaining values to
    zero, and then, except for Common or Inherited, add this script's bit to
    the map. */

    memcpy(map, PRIV(ucd_script_sets) + UCD_SCRIPTX_PROP(ucd), UCD_MAPSIZE * sizeof(uint32_t));
    memset(map + UCD_MAPSIZE, 0, (FULL_MAPSIZE - UCD_MAPSIZE) * sizeof(uint32_t));
    if (script != ucp_Common && script != ucp_Inherited) MAPSET(map, script);

    /* Handle the different checking states */

    switch(require_state)
      {
      /* First significant character - it might follow Common or Inherited
      characters that do not have any script extensions. */

      case SCRIPT_UNSET:
      switch(script)
        {
        case ucp_Han:
        require_state = SCRIPT_HANPENDING;
        break;

        case ucp_Hiragana:
        case ucp_Katakana:
        require_state = SCRIPT_HANHIRAKATA;
        break;

        case ucp_Bopomofo:
        require_state = SCRIPT_HANBOPOMOFO;
        break;

        case ucp_Hangul:
        require_state = SCRIPT_HANHANGUL;
        break;

        default:
        memcpy(require_map, map, FULL_MAPSIZE * sizeof(uint32_t));
        require_state = SCRIPT_MAP;
        break;
        }
      break;

      /* The first significant character was Han. An inspection of the Unicode
      11.0.0 files shows that there are the following types of Script Extension
      list that involve the Han, Bopomofo, Hiragana, Katakana, and Hangul
      scripts:

      . Bopomofo + Han
      . Han + Hiragana + Katakana
      . Hiragana + Katakana
      . Bopopmofo + Hangul + Han + Hiragana + Katakana

      The following code tries to make sense of this. */

#define FOUND_BOPOMOFO 1
#define FOUND_HIRAGANA 2
#define FOUND_KATAKANA 4
#define FOUND_HANGUL   8

      case SCRIPT_HANPENDING:
      if (script != ucp_Han)   /* Another Han does nothing */
        {
        uint32_t chspecial = 0;

        if (MAPBIT(map, ucp_Bopomofo) != 0) chspecial |= FOUND_BOPOMOFO;
        if (MAPBIT(map, ucp_Hiragana) != 0) chspecial |= FOUND_HIRAGANA;
        if (MAPBIT(map, ucp_Katakana) != 0) chspecial |= FOUND_KATAKANA;
        if (MAPBIT(map, ucp_Hangul) != 0)   chspecial |= FOUND_HANGUL;

        if (chspecial == 0) return FALSE;   /* Not allowed with Han */

        if (chspecial == FOUND_BOPOMOFO)
          require_state = SCRIPT_HANBOPOMOFO;
        else if (chspecial == (FOUND_HIRAGANA|FOUND_KATAKANA))
          require_state = SCRIPT_HANHIRAKATA;

        /* Otherwise this character must be allowed with all of them, so remain
        in the pending state. */
        }
      break;

      /* Previously encountered one of the "with Han" scripts. Check that
      this character is appropriate. */

      case SCRIPT_HANHIRAKATA:
      if (MAPBIT(map, ucp_Han) + MAPBIT(map, ucp_Hiragana) +
          MAPBIT(map, ucp_Katakana) == 0) return FALSE;
      break;

      case SCRIPT_HANBOPOMOFO:
      if (MAPBIT(map, ucp_Han) + MAPBIT(map, ucp_Bopomofo) == 0) return FALSE;
      break;

      case SCRIPT_HANHANGUL:
      if (MAPBIT(map, ucp_Han) + MAPBIT(map, ucp_Hangul) == 0) return FALSE;
      break;

      /* Previously encountered one or more characters that are allowed with a
      list of scripts. */

      case SCRIPT_MAP:
      OK = FALSE;

      for (int i = 0; i < FULL_MAPSIZE; i++)
        {
        if ((require_map[i] & map[i]) != 0)
          {
          OK = TRUE;
          break;
          }
        }

      if (!OK) return FALSE;

      /* The rest of the string must be in this script, but we have to
      allow for the Han complications. */

      switch(script)
        {
        case ucp_Han:
        require_state = SCRIPT_HANPENDING;
        break;

        case ucp_Hiragana:
        case ucp_Katakana:
        require_state = SCRIPT_HANHIRAKATA;
        break;

        case ucp_Bopomofo:
        require_state = SCRIPT_HANBOPOMOFO;
        break;

        case ucp_Hangul:
        require_state = SCRIPT_HANHANGUL;
        break;

        /* Compute the intersection of the required list of scripts and the
        allowed scripts for this character. */

        default:
        for (int i = 0; i < FULL_MAPSIZE; i++) require_map[i] &= map[i];
        break;
        }

      break;
      }
    }   /* End checking character's script and extensions. */

  /* The character is in an acceptable script. We must now ensure that all
  decimal digits in the string come from the same set. Some scripts (e.g.
  Common, Arabic) have more than one set of decimal digits. This code does
  not allow mixing sets, even within the same script. The vector called
  PRIV(ucd_digit_sets)[] contains, in its first element, the number of
  following elements, and then, in ascending order, the code points of the
  '9' characters in every set of 10 digits. Each set is identified by the
  offset in the vector of its '9' character. An initial check of the first
  value picks up ASCII digits quickly. Otherwise, a binary chop is used. */

  if (ucd->chartype == ucp_Nd)
    {
    uint32_t digitset;

    if (c <= PRIV(ucd_digit_sets)[1]) digitset = 1; else
      {
      int mid;
      int bot = 1;
      int top = PRIV(ucd_digit_sets)[0];
      for (;;)
        {
        if (top <= bot + 1)    /* <= rather than == is paranoia */
          {
          digitset = top;
          break;
          }
        mid = (top + bot) / 2;
        if (c <= PRIV(ucd_digit_sets)[mid]) top = mid; else bot = mid;
        }
      }

    /* A required value of 0 means "unset". */

    if (require_digitset == 0) require_digitset = digitset;
      else if (digitset != require_digitset) return FALSE;
    }   /* End digit handling */

  /* If we haven't yet got to the end, pick up the next character. */

  if (ptr >= endptr) return TRUE;
  GETCHARINCTEST(c, ptr);
  }  /* End checking loop */

#else   /* NOT SUPPORT_UNICODE */
(void)ptr;
(void)endptr;
(void)utf;
return TRUE;
#endif  /* SUPPORT_UNICODE */
}

/* End of pcre2_script_run.c */


================================================
FILE: Libraries/PCRE/pcre2_serialize.c
================================================
/*************************************************
*      Perl-Compatible Regular Expressions       *
*************************************************/

/* PCRE is a library of functions to support regular expressions whose syntax
and semantics are as close as possible to those of the Perl 5 language.

                       Written by Philip Hazel
     Original API code Copyright (c) 1997-2012 University of Cambridge
          New API code Copyright (c) 2016-2024 University of Cambridge

-----------------------------------------------------------------------------
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

    * Redistributions of source code must retain the above copyright notice,
      this list of conditions and the following disclaimer.

    * Redistributions in binary form must reproduce the above copyright
      notice, this list of conditions and the following disclaimer in the
      documentation and/or other materials provided with the distribution.

    * Neither the name of the University of Cambridge nor the names of its
      contributors may be used to endorse or promote products derived from
      this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
-----------------------------------------------------------------------------
*/

/* This module contains functions for serializing and deserializing
a sequence of compiled codes. */


#ifdef HAVE_CONFIG_H
#include "config.h"
#endif


#include "pcre2_internal.h"

/* Magic number to provide a small check against being handed junk. */

#define SERIALIZED_DATA_MAGIC 0x50523253u

/* Deserialization is limited to the current PCRE version and
character width. */

#define SERIALIZED_DATA_VERSION \
  ((PCRE2_MAJOR) | ((PCRE2_MINOR) << 16))

#define SERIALIZED_DATA_CONFIG \
  (sizeof(PCRE2_UCHAR) | ((sizeof(void*)) << 8) | ((sizeof(PCRE2_SIZE)) << 16))



/*************************************************
*           Serialize compiled patterns          *
*************************************************/

PCRE2_EXP_DEFN int32_t PCRE2_CALL_CONVENTION
pcre2_serialize_encode(const pcre2_code **codes, int32_t number_of_codes,
   uint8_t **serialized_bytes, PCRE2_SIZE *serialized_size,
   pcre2_general_context *gcontext)
{
uint8_t *bytes;
uint8_t *dst_bytes;
int32_t i;
PCRE2_SIZE total_size;
const pcre2_real_code *re;
const uint8_t *tables;
pcre2_serialized_data *data;

const pcre2_memctl *memctl = (gcontext != NULL) ?
  &gcontext->memctl : &PRIV(default_compile_context).memctl;

if (codes == NULL || serialized_bytes == NULL || serialized_size == NULL)
  return PCRE2_ERROR_NULL;

if (number_of_codes <= 0) return PCRE2_ERROR_BADDATA;

/* Compute total size. */
total_size = sizeof(pcre2_serialized_data) + TABLES_LENGTH;
tables = NULL;

for (i = 0; i < number_of_codes; i++)
  {
  if (codes[i] == NULL) return PCRE2_ERROR_NULL;
  re = (const pcre2_real_code *)(codes[i]);
  if (re->magic_number != MAGIC_NUMBER) return PCRE2_ERROR_BADMAGIC;
  if (tables == NULL)
    tables = re->tables;
  else if (tables != re->tables)
    return PCRE2_ERROR_MIXEDTABLES;
  total_size += re->blocksize;
  }

/* Initialize the byte stream. */
bytes = memctl->malloc(total_size + sizeof(pcre2_memctl), memctl->memory_data);
if (bytes == NULL) return PCRE2_ERROR_NOMEMORY;

/* The controller is stored as a hidden parameter. */
memcpy(bytes, memctl, sizeof(pcre2_memctl));
bytes += sizeof(pcre2_memctl);

data = (pcre2_serialized_data *)bytes;
data->magic = SERIALIZED_DATA_MAGIC;
data->version = SERIALIZED_DATA_VERSION;
data->config = SERIALIZED_DATA_CONFIG;
data->number_of_codes = number_of_codes;

/* Copy all compiled code data. */
dst_bytes = bytes + sizeof(pcre2_serialized_data);
memcpy(dst_bytes, tables, TABLES_LENGTH);
dst_bytes += TABLES_LENGTH;

for (i = 0; i < number_of_codes; i++)
  {
  re = (const pcre2_real_code *)(codes[i]);
  (void)memcpy(dst_bytes, (const char *)re, re->blocksize);

  /* Certain fields in the compiled code block are re-set during
  deserialization. In order to ensure that the serialized data stream is always
  the same for the same pattern, set them to zero here. We can't assume the
  copy of the pattern is correctly aligned for accessing the fields as part of
  a structure. Note the use of sizeof(void *) in the second of these, to
  specify the size of a pointer. If sizeof(uint8_t *) is used (tables is a
  pointer to uint8_t), gcc gives a warning because the first argument is also a
  pointer to uint8_t. Casting the first argument to (void *) can stop this, but
  it didn't stop Coverity giving the same complaint. */

  (void)memset(dst_bytes + offsetof(pcre2_real_code, memctl), 0,
    sizeof(pcre2_memctl));
  (void)memset(dst_bytes + offsetof(pcre2_real_code, tables), 0,
    sizeof(void *));
  (void)memset(dst_bytes + offsetof(pcre2_real_code, executable_jit), 0,
    sizeof(void *));

  dst_bytes += re->blocksize;
  }

*serialized_bytes = bytes;
*serialized_size = total_size;
return number_of_codes;
}


/*************************************************
*          Deserialize compiled patterns         *
*************************************************/

PCRE2_EXP_DEFN int32_t PCRE2_CALL_CONVENTION
pcre2_serialize_decode(pcre2_code **codes, int32_t number_of_codes,
   const uint8_t *bytes, pcre2_general_context *gcontext)
{
const pcre2_serialized_data *data = (const pcre2_serialized_data *)bytes;
const pcre2_memctl *memctl = (gcontext != NULL) ?
  &gcontext->memctl : &PRIV(default_compile_context).memctl;

const uint8_t *src_bytes;
pcre2_real_code *dst_re;
uint8_t *tables;
int32_t i, j;

/* Sanity checks. */

if (data == NULL || codes == NULL) return PCRE2_ERROR_NULL;
if (number_of_codes <= 0) return PCRE2_ERROR_BADDATA;
if (data->number_of_codes <= 0) return PCRE2_ERROR_BADSERIALIZEDDATA;
if (data->magic != SERIALIZED_DATA_MAGIC) return PCRE2_ERROR_BADMAGIC;
if (data->version != SERIALIZED_DATA_VERSION) return PCRE2_ERROR_BADMODE;
if (data->config != SERIALIZED_DATA_CONFIG) return PCRE2_ERROR_BADMODE;

if (number_of_codes > data->number_of_codes)
  number_of_codes = data->number_of_codes;

src_bytes = bytes + sizeof(pcre2_serialized_data);

/* Decode tables. The reference count for the tables is stored immediately
following them. */

tables = memctl->malloc(TABLES_LENGTH + sizeof(PCRE2_SIZE), memctl->memory_data);
if (tables == NULL) return PCRE2_ERROR_NOMEMORY;

memcpy(tables, src_bytes, TABLES_LENGTH);
*(PCRE2_SIZE *)(tables + TABLES_LENGTH) = number_of_codes;
src_bytes += TABLES_LENGTH;

/* Decode the byte stream. We must not try to read the size from the compiled
code block in the stream, because it might be unaligned, which causes errors on
hardware such as Sparc-64 that doesn't like unaligned memory accesses. The type
of the blocksize field is given its own name to ensure that it is the same here
as in the block. */

for (i = 0; i < number_of_codes; i++)
  {
  CODE_BLOCKSIZE_TYPE blocksize;
  memcpy(&blocksize, src_bytes + offsetof(pcre2_real_code, blocksize),
    sizeof(CODE_BLOCKSIZE_TYPE));
  if (blocksize <= sizeof(pcre2_real_code))
    return PCRE2_ERROR_BADSERIALIZEDDATA;

  /* The allocator provided by gcontext replaces the original one. */

  dst_re = (pcre2_real_code *)PRIV(memctl_malloc)(blocksize,
    (pcre2_memctl *)gcontext);
  if (dst_re == NULL)
    {
    memctl->free(tables, memctl->memory_data);
    for (j = 0; j < i; j++)
      {
      memctl->free(codes[j], memctl->memory_data);
      codes[j] = NULL;
      }
    return PCRE2_ERROR_NOMEMORY;
    }

  /* The new allocator must be preserved. */

  memcpy(((uint8_t *)dst_re) + sizeof(pcre2_memctl),
    src_bytes + sizeof(pcre2_memctl), blocksize - sizeof(pcre2_memctl));
  if (dst_re->magic_number != MAGIC_NUMBER ||
      dst_re->name_entry_size > MAX_NAME_SIZE + IMM2_SIZE + 1 ||
      dst_re->name_count > MAX_NAME_COUNT)
    {
    memctl->free(dst_re, memctl->memory_data);
    return PCRE2_ERROR_BADSERIALIZEDDATA;
    }

  /* At the moment only one table is supported. */

  dst_re->tables = tables;
  dst_re->executable_jit = NULL;
  dst_re->flags |= PCRE2_DEREF_TABLES;

  codes[i] = dst_re;
  src_bytes += blocksize;
  }

return number_of_codes;
}


/*************************************************
*    Get the number of serialized patterns       *
*************************************************/

PCRE2_EXP_DEFN int32_t PCRE2_CALL_CONVENTION
pcre2_serialize_get_number_of_codes(const uint8_t *bytes)
{
const pcre2_serialized_data *data = (const pcre2_serialized_data *)bytes;

if (data == NULL) return PCRE2_ERROR_NULL;
if (data->magic != SERIALIZED_DATA_MAGIC) return PCRE2_ERROR_BADMAGIC;
if (data->version != SERIALIZED_DATA_VERSION) return PCRE2_ERROR_BADMODE;
if (data->config != SERIALIZED_DATA_CONFIG) return PCRE2_ERROR_BADMODE;

return data->number_of_codes;
}


/*************************************************
*            Free the allocated stream           *
*************************************************/

PCRE2_EXP_DEFN void PCRE2_CALL_CONVENTION
pcre2_serialize_free(uint8_t *bytes)
{
if (bytes != NULL)
  {
  pcre2_memctl *memctl = (pcre2_memctl *)(bytes - sizeof(pcre2_memctl));
  memctl->free(memctl, memctl->memory_data);
  }
}

/* End of pcre2_serialize.c */


================================================
FILE: Libraries/PCRE/pcre2_string_utils.c
================================================
/*************************************************
*      Perl-Compatible Regular Expressions       *
*************************************************/

/* PCRE is a library of functions to support regular expressions whose syntax
and semantics are as close as possible to those of the Perl 5 language.

                       Written by Philip Hazel
     Original API code Copyright (c) 1997-2012 University of Cambridge
          New API code Copyright (c) 2018-2021 University of Cambridge

-----------------------------------------------------------------------------
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

    * Redistributions of source code must retain the above copyright notice,
      this list of conditions and the following disclaimer.

    * Redistributions in binary form must reproduce the above copyright
      notice, this list of conditions and the following disclaimer in the
      documentation and/or other materials provided with the distribution.

    * Neither the name of the University of Cambridge nor the names of its
      contributors may be used to endorse or promote products derived from
      this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
-----------------------------------------------------------------------------
*/

/* This module contains internal functions for comparing and finding the length
of strings. These are used instead of strcmp() etc because the standard
functions work only on 8-bit data. */


#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include "pcre2_internal.h"


/*************************************************
*    Emulated memmove() for systems without it   *
*************************************************/

/* This function can make use of bcopy() if it is available. Otherwise do it by
steam, as there some non-Unix environments that lack both memmove() and
bcopy(). */

#if !defined(VPCOMPAT) && !defined(HAVE_MEMMOVE)
void *
PRIV(memmove)(void *d, const void *s, size_t n)
{
#ifdef HAVE_BCOPY
bcopy(s, d, n);
return d;
#else
size_t i;
unsigned char *dest = (unsigned char *)d;
const unsigned char *src = (const unsigned char *)s;
if (dest > src)
  {
  dest += n;
  src += n;
  for (i = 0; i < n; ++i) *(--dest) = *(--src);
  return (void *)dest;
  }
else
  {
  for (i = 0; i < n; ++i) *dest++ = *src++;
  return (void *)(dest - n);
  }
#endif   /* not HAVE_BCOPY */
}
#endif   /* not VPCOMPAT && not HAVE_MEMMOVE */


/*************************************************
*    Compare two zero-terminated PCRE2 strings   *
*************************************************/

/*
Arguments:
  str1        first string
  str2        second string

Returns:      0, 1, or -1
*/

int
PRIV(strcmp)(PCRE2_SPTR str1, PCRE2_SPTR str2)
{
PCRE2_UCHAR c1, c2;
while (*str1 != '\0' || *str2 != '\0')
  {
  c1 = *str1++;
  c2 = *str2++;
  if (c1 != c2) return ((c1 > c2) << 1) - 1;
  }
return 0;
}


/*************************************************
*  Compare zero-terminated PCRE2 & 8-bit strings *
*************************************************/

/* As the 8-bit string is almost always a literal, its type is specified as
const char *.

Arguments:
  str1        first string
  str2        second string

Returns:      0, 1, or -1
*/

int
PRIV(strcmp_c8)(PCRE2_SPTR str1, const char *str2)
{
PCRE2_UCHAR c1, c2;
while (*str1 != '\0' || *str2 != '\0')
  {
  c1 = *str1++;
  c2 = *str2++;
  if (c1 != c2) return ((c1 > c2) << 1) - 1;
  }
return 0;
}


/*************************************************
*    Compare two PCRE2 strings, given a length   *
*************************************************/

/*
Arguments:
  str1        first string
  str2        second string
  len         the length

Returns:      0, 1, or -1
*/

int
PRIV(strncmp)(PCRE2_SPTR str1, PCRE2_SPTR str2, size_t len)
{
PCRE2_UCHAR c1, c2;
for (; len > 0; len--)
  {
  c1 = *str1++;
  c2 = *str2++;
  if (c1 != c2) return ((c1 > c2) << 1) - 1;
  }
return 0;
}


/*************************************************
* Compare PCRE2 string to 8-bit string by length *
*************************************************/

/* As the 8-bit string is almost always a literal, its type is specified as
const char *.

Arguments:
  str1        first string
  str2        second string
  len         the length

Returns:      0, 1, or -1
*/

int
PRIV(strncmp_c8)(PCRE2_SPTR str1, const char *str2, size_t len)
{
PCRE2_UCHAR c1, c2;
for (; len > 0; len--)
  {
  c1 = *str1++;
  c2 = *str2++;
  if (c1 != c2) return ((c1 > c2) << 1) - 1;
  }
return 0;
}


/*************************************************
*        Find the length of a PCRE2 string       *
*************************************************/

/*
Argument:    the string
Returns:     the length
*/

PCRE2_SIZE
PRIV(strlen)(PCRE2_SPTR str)
{
PCRE2_SIZE c = 0;
while (*str++ != 0) c++;
return c;
}


/*************************************************
* Copy 8-bit 0-terminated string to PCRE2 string *
*************************************************/

/* Arguments:
  str1     buffer to receive the string
  str2     8-bit string to be copied

Returns:   the number of code units used (excluding trailing zero)
*/

PCRE2_SIZE
PRIV(strcpy_c8)(PCRE2_UCHAR *str1, const char *str2)
{
PCRE2_UCHAR *t = str1;
while (*str2 != 0) *t++ = *str2++;
*t = 0;
return t - str1;
}

/* End of pcre2_string_utils.c */


================================================
FILE: Libraries/PCRE/pcre2_study.c
================================================
/*************************************************
*      Perl-Compatible Regular Expressions       *
*************************************************/

/* PCRE is a library of functions to support regular expressions whose syntax
and semantics are as close as possible to those of the Perl 5 language.

                       Written by Philip Hazel
     Original API code Copyright (c) 1997-2012 University of Cambridge
          New API code Copyright (c) 2016-2024 University of Cambridge

-----------------------------------------------------------------------------
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

    * Redistributions of source code must retain the above copyright notice,
      this list of conditions and the following disclaimer.

    * Redistributions in binary form must reproduce the above copyright
      notice, this list of conditions and the following disclaimer in the
      documentation and/or other materials provided with the distribution.

    * Neither the name of the University of Cambridge nor the names of its
      contributors may be used to endorse or promote products derived from
      this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
-----------------------------------------------------------------------------
*/

/* This module contains functions for scanning a compiled pattern and
collecting data (e.g. minimum matching length). */


#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include "pcre2_internal.h"

/* The maximum remembered capturing brackets minimum. */

#define MAX_CACHE_BACKREF 128

/* Set a bit in the starting code unit bit map. */

#define SET_BIT(c) re->start_bitmap[(c)/8] |= (1u << ((c)&7))

/* Returns from set_start_bits() */

enum { SSB_FAIL, SSB_DONE, SSB_CONTINUE, SSB_UNKNOWN, SSB_TOODEEP };


/*************************************************
*   Find the minimum subject length for a group  *
*************************************************/

/* Scan a parenthesized group and compute the minimum length of subject that
is needed to match it. This is a lower bound; it does not mean there is a
string of that length that matches. In UTF mode, the result is in characters
rather than code units. The field in a compiled pattern for storing the minimum
length is 16-bits long (on the grounds that anything longer than that is
pathological), so we give up when we reach that amount. This also means that
integer overflow for really crazy patterns cannot happen.

Backreference minimum lengths are cached to speed up multiple references. This
function is called only when the highest back reference in the pattern is less
than or equal to MAX_CACHE_BACKREF, which is one less than the size of the
caching vector. The zeroth element contains the number of the highest set
value.

Arguments:
  re              compiled pattern block
  code            pointer to start of group (the bracket)
  startcode       pointer to start of the whole pattern's code
  utf             UTF flag
  recurses        chain of recurse_check to catch mutual recursion
  countptr        pointer to call count (to catch over complexity)
  backref_cache   vector for caching back references.

This function is no longer called when the pattern contains (*ACCEPT); however,
the old code for returning -1 is retained, just in case.

Returns:   the minimum length
           -1 \C in UTF-8 mode
              or (*ACCEPT)
              or pattern too complicated
           -2 internal error (missing capturing bracket)
           -3 internal error (opcode not listed)
*/

static int
find_minlength(const pcre2_real_code *re, PCRE2_SPTR code,
  PCRE2_SPTR startcode, BOOL utf, recurse_check *recurses, int *countptr,
  int *backref_cache)
{
int length = -1;
int branchlength = 0;
int prev_cap_recno = -1;
int prev_cap_d = 0;
int prev_recurse_recno = -1;
int prev_recurse_d = 0;
uint32_t once_fudge = 0;
BOOL had_recurse = FALSE;
BOOL dupcapused = (re->flags & PCRE2_DUPCAPUSED) != 0;
PCRE2_SPTR nextbranch = code + GET(code, 1);
PCRE2_SPTR cc = code + 1 + LINK_SIZE;
recurse_check this_recurse;

/* If this is a "could be empty" group, its minimum length is 0. */

if (*code >= OP_SBRA && *code <= OP_SCOND) return 0;

/* Skip over capturing bracket number */

if (*code == OP_CBRA || *code == OP_CBRAPOS) cc += IMM2_SIZE;

/* A large and/or complex regex can take too long to process. */

if ((*countptr)++ > 1000) return -1;

/* Scan along the opcodes for this branch. If we get to the end of the branch,
check the length against that of the other branches. If the accumulated length
passes 16-bits, reset to that value and skip the rest of the branch. */

for (;;)
  {
  int d, min, recno;
  PCRE2_UCHAR op;
  PCRE2_SPTR cs, ce;

  if (branchlength >= UINT16_MAX)
    {
    branchlength = UINT16_MAX;
    cc = nextbranch;
    }

  op = *cc;
  switch (op)
    {
    case OP_COND:
    case OP_SCOND:

    /* If there is only one branch in a condition, the implied branch has zero
    length, so we don't add anything. This covers the DEFINE "condition"
    automatically. If there are two branches we can treat it the same as any
    other non-capturing subpattern. */

    cs = cc + GET(cc, 1);
    if (*cs != OP_ALT)
      {
      cc = cs + 1 + LINK_SIZE;
      break;
      }
    goto PROCESS_NON_CAPTURE;

    case OP_BRA:
    /* There's a special case of OP_BRA, when it is wrapped round a repeated
    OP_RECURSE. We'd like to process the latter at this level so that
    remembering the value works for repeated cases. So we do nothing, but
    set a fudge value to skip over the OP_KET after the recurse. */

    if (cc[1+LINK_SIZE] == OP_RECURSE && cc[2*(1+LINK_SIZE)] == OP_KET)
      {
      once_fudge = 1 + LINK_SIZE;
      cc += 1 + LINK_SIZE;
      break;
      }
    /* Fall through */

    case OP_ONCE:
    case OP_SCRIPT_RUN:
    case OP_SBRA:
    case OP_BRAPOS:
    case OP_SBRAPOS:
    PROCESS_NON_CAPTURE:
    d = find_minlength(re, cc, startcode, utf, recurses, countptr,
      backref_cache);
    if (d < 0) return d;
    branchlength += d;
    do cc += GET(cc, 1); while (*cc == OP_ALT);
    cc += 1 + LINK_SIZE;
    break;

    /* To save time for repeated capturing subpatterns, we remember the
    length of the previous one. Unfortunately we can't do the same for
    the unnumbered ones above. Nor can we do this if (?| is present in the
    pattern because captures with the same number are not then identical. */

    case OP_CBRA:
    case OP_SCBRA:
    case OP_CBRAPOS:
    case OP_SCBRAPOS:
    recno = (int)GET2(cc, 1+LINK_SIZE);
    if (dupcapused || recno != prev_cap_recno)
      {
      prev_cap_recno = recno;
      prev_cap_d = find_minlength(re, cc, startcode, utf, recurses, countptr,
        backref_cache);
      if (prev_cap_d < 0) return prev_cap_d;
      }
    branchlength += prev_cap_d;
    do cc += GET(cc, 1); while (*cc == OP_ALT);
    cc += 1 + LINK_SIZE;
    break;

    /* ACCEPT makes things far too complicated; we have to give up. In fact,
    from 10.34 onwards, if a pattern contains (*ACCEPT), this function is not
    used. However, leave the code in place, just in case. */

    case OP_ACCEPT:
    case OP_ASSERT_ACCEPT:
    return -1;

    /* Reached end of a branch; if it's a ket it is the end of a nested
    call. If it's ALT it is an alternation in a nested call. If it is END it's
    the end of the outer call. All can be handled by the same code. If the
    length of any branch is zero, there is no need to scan any subsequent
    branches. */

    case OP_ALT:
    case OP_KET:
    case OP_KETRMAX:
    case OP_KETRMIN:
    case OP_KETRPOS:
    case OP_END:
    if (length < 0 || (!had_recurse && branchlength < length))
      length = branchlength;
    if (op != OP_ALT || length == 0) return length;
    nextbranch = cc + GET(cc, 1);
    cc += 1 + LINK_SIZE;
    branchlength = 0;
    had_recurse = FALSE;
    break;

    /* Skip over assertive subpatterns */

    case OP_ASSERT:
    case OP_ASSERT_NOT:
    case OP_ASSERTBACK:
    case OP_ASSERTBACK_NOT:
    case OP_ASSERT_NA:
    case OP_ASSERT_SCS:
    case OP_ASSERTBACK_NA:
    do cc += GET(cc, 1); while (*cc == OP_ALT);
    /* Fall through */

    /* Skip over things that don't match chars */

    case OP_REVERSE:
    case OP_VREVERSE:
    case OP_CREF:
    case OP_DNCREF:
    case OP_RREF:
    case OP_DNRREF:
    case OP_FALSE:
    case OP_TRUE:
    case OP_CALLOUT:
    case OP_SOD:
    case OP_SOM:
    case OP_EOD:
    case OP_EODN:
    case OP_CIRC:
    case OP_CIRCM:
    case OP_DOLL:
    case OP_DOLLM:
    case OP_NOT_WORD_BOUNDARY:
    case OP_WORD_BOUNDARY:
    case OP_NOT_UCP_WORD_BOUNDARY:
    case OP_UCP_WORD_BOUNDARY:
    cc += PRIV(OP_lengths)[*cc];
    break;

    case OP_CALLOUT_STR:
    cc += GET(cc, 1 + 2*LINK_SIZE);
    break;

    /* Skip over a subpattern that has a {0} or {0,x} quantifier */

    case OP_BRAZERO:
    case OP_BRAMINZERO:
    case OP_BRAPOSZERO:
    case OP_SKIPZERO:
    cc += PRIV(OP_lengths)[*cc];
    do cc += GET(cc, 1); while (*cc == OP_ALT);
    cc += 1 + LINK_SIZE;
    break;

    /* Handle literal characters and + repetitions */

    case OP_CHAR:
    case OP_CHARI:
    case OP_NOT:
    case OP_NOTI:
    case OP_PLUS:
    case OP_PLUSI:
    case OP_MINPLUS:
    case OP_MINPLUSI:
    case OP_POSPLUS:
    case OP_POSPLUSI:
    case OP_NOTPLUS:
    case OP_NOTPLUSI:
    case OP_NOTMINPLUS:
    case OP_NOTMINPLUSI:
    case OP_NOTPOSPLUS:
    case OP_NOTPOSPLUSI:
    branchlength++;
    cc += 2;
#ifdef SUPPORT_UNICODE
    if (utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
#endif
    break;

    case OP_TYPEPLUS:
    case OP_TYPEMINPLUS:
    case OP_TYPEPOSPLUS:
    branchlength++;
    cc += (cc[1] == OP_PROP || cc[1] == OP_NOTPROP)? 4 : 2;
    break;

    /* Handle exact repetitions. The count is already in characters, but we
    may need to skip over a multibyte character in UTF mode.  */

    case OP_EXACT:
    case OP_EXACTI:
    case OP_NOTEXACT:
    case OP_NOTEXACTI:
    branchlength += GET2(cc,1);
    cc += 2 + IMM2_SIZE;
#ifdef SUPPORT_UNICODE
    if (utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
#endif
    break;

    case OP_TYPEEXACT:
    branchlength += GET2(cc,1);
    cc += 2 + IMM2_SIZE + ((cc[1 + IMM2_SIZE] == OP_PROP
      || cc[1 + IMM2_SIZE] == OP_NOTPROP)? 2 : 0);
    break;

    /* Handle single-char non-literal matchers */

    case OP_PROP:
    case OP_NOTPROP:
    cc += 2;
    /* Fall through */

    case OP_NOT_DIGIT:
    case OP_DIGIT:
    case OP_NOT_WHITESPACE:
    case OP_WHITESPACE:
    case OP_NOT_WORDCHAR:
    case OP_WORDCHAR:
    case OP_ANY:
    case OP_ALLANY:
    case OP_EXTUNI:
    case OP_HSPACE:
    case OP_NOT_HSPACE:
    case OP_VSPACE:
    case OP_NOT_VSPACE:
    branchlength++;
    cc++;
    break;

    /* "Any newline" might match two characters, but it also might match just
    one. */

    case OP_ANYNL:
    branchlength += 1;
    cc++;
    break;

    /* The single-byte matcher means we can't proceed in UTF mode. (In
    non-UTF mode \C will actually be turned into OP_ALLANY, so won't ever
    appear, but leave the code, just in case.) */

    case OP_ANYBYTE:
#ifdef SUPPORT_UNICODE
    if (utf) return -1;
#endif
    branchlength++;
    cc++;
    break;

    /* For repeated character types, we have to test for \p and \P, which have
    an extra two bytes of parameters. */

    case OP_TYPESTAR:
    case OP_TYPEMINSTAR:
    case OP_TYPEQUERY:
    case OP_TYPEMINQUERY:
    case OP_TYPEPOSSTAR:
    case OP_TYPEPOSQUERY:
    if (cc[1] == OP_PROP || cc[1] == OP_NOTPROP) cc += 2;
    cc += PRIV(OP_lengths)[op];
    break;

    case OP_TYPEUPTO:
    case OP_TYPEMINUPTO:
    case OP_TYPEPOSUPTO:
    if (cc[1 + IMM2_SIZE] == OP_PROP
      || cc[1 + IMM2_SIZE] == OP_NOTPROP) cc += 2;
    cc += PRIV(OP_lengths)[op];
    break;

    /* Check a class for variable quantification */

    case OP_CLASS:
    case OP_NCLASS:
#ifdef SUPPORT_WIDE_CHARS
    case OP_XCLASS:
    case OP_ECLASS:
    /* The original code caused an unsigned overflow in 64 bit systems,
    so now we use a conditional statement. */
    if (op == OP_XCLASS || op == OP_ECLASS)
      cc += GET(cc, 1);
    else
#endif
      cc += PRIV(OP_lengths)[OP_CLASS];

    switch (*cc)
      {
      case OP_CRPLUS:
      case OP_CRMINPLUS:
      case OP_CRPOSPLUS:
      branchlength++;
      /* Fall through */

      case OP_CRSTAR:
      case OP_CRMINSTAR:
      case OP_CRQUERY:
      case OP_CRMINQUERY:
      case OP_CRPOSSTAR:
      case OP_CRPOSQUERY:
      cc++;
      break;

      case OP_CRRANGE:
      case OP_CRMINRANGE:
      case OP_CRPOSRANGE:
      branchlength += GET2(cc,1);
      cc += 1 + 2 * IMM2_SIZE;
      break;

      default:
      branchlength++;
      break;
      }
    break;

    /* Backreferences and subroutine calls (OP_RECURSE) are treated in the same
    way: we find the minimum length for the subpattern. A recursion
    (backreference or subroutine) causes an a flag to be set that causes the
    length of this branch to be ignored. The logic is that a recursion can only
    make sense if there is another alternative that stops the recursing. That
    will provide the minimum length (when no recursion happens).

    If PCRE2_MATCH_UNSET_BACKREF is set, a backreference to an unset bracket
    matches an empty string (by default it causes a matching failure), so in
    that case we must set the minimum length to zero.

    For backreferenes, if duplicate numbers are present in the pattern we check
    for a reference to a duplicate. If it is, we don't know which version will
    be referenced, so we have to set the minimum length to zero. */

    /* Duplicate named pattern back reference. */

    case OP_DNREF:
    case OP_DNREFI:
    if (!dupcapused && (re->overall_options & PCRE2_MATCH_UNSET_BACKREF) == 0)
      {
      int count = GET2(cc, 1+IMM2_SIZE);
      PCRE2_SPTR slot =
        (PCRE2_SPTR)((const uint8_t *)re + sizeof(pcre2_real_code)) +
          GET2(cc, 1) * re->name_entry_size;

      d = INT_MAX;

      /* Scan all groups with the same name; find the shortest. */

      while (count-- > 0)
        {
        int dd, i;
        recno = GET2(slot, 0);

        if (recno <= backref_cache[0] && backref_cache[recno] >= 0)
          dd = backref_cache[recno];
        else
          {
          ce = cs = PRIV(find_bracket)(startcode, utf, recno);
          if (cs == NULL) return -2;
          do ce += GET(ce, 1); while (*ce == OP_ALT);

          dd = 0;
          if (!dupcapused || PRIV(find_bracket)(ce, utf, recno) == NULL)
            {
            if (cc > cs && cc < ce)    /* Simple recursion */
              {
              had_recurse = TRUE;
              }
            else
              {
              recurse_check *r = recurses;
              for (r = recurses; r != NULL; r = r->prev)
                if (r->group == cs) break;
              if (r != NULL)           /* Mutual recursion */
                {
                had_recurse = TRUE;
                }
              else
                {
                this_recurse.prev = recurses;  /* No recursion */
                this_recurse.group = cs;
                dd = find_minlength(re, cs, startcode, utf, &this_recurse,
                  countptr, backref_cache);
                if (dd < 0) return dd;
                }
              }
            }

          backref_cache[recno] = dd;
          for (i = backref_cache[0] + 1; i < recno; i++) backref_cache[i] = -1;
          backref_cache[0] = recno;
          }

        if (dd < d) d = dd;
        if (d <= 0) break;    /* No point looking at any more */
        slot += re->name_entry_size;
        }
      }
    else d = 0;
    cc += PRIV(OP_lengths)[*cc];
    goto REPEAT_BACK_REFERENCE;

    /* Single back reference by number. References by name are converted to by
    number when there is no duplication. */

    case OP_REF:
    case OP_REFI:
    recno = GET2(cc, 1);
    if (recno <= backref_cache[0] && backref_cache[recno] >= 0)
      d = backref_cache[recno];
    else
      {
      int i;
      d = 0;

      if ((re->overall_options & PCRE2_MATCH_UNSET_BACKREF) == 0)
        {
        ce = cs = PRIV(find_bracket)(startcode, utf, recno);
        if (cs == NULL) return -2;
        do ce += GET(ce, 1); while (*ce == OP_ALT);

        if (!dupcapused || PRIV(find_bracket)(ce, utf, recno) == NULL)
          {
          if (cc > cs && cc < ce)    /* Simple recursion */
            {
            had_recurse = TRUE;
            }
          else
            {
            recurse_check *r = recurses;
            for (r = recurses; r != NULL; r = r->prev) if (r->group == cs) break;
            if (r != NULL)           /* Mutual recursion */
              {
              had_recurse = TRUE;
              }
            else                     /* No recursion */
              {
              this_recurse.prev = recurses;
              this_recurse.group = cs;
              d = find_minlength(re, cs, startcode, utf, &this_recurse, countptr,
                backref_cache);
              if (d < 0) return d;
              }
            }
          }
        }

      backref_cache[recno] = d;
      for (i = backref_cache[0] + 1; i < recno; i++) backref_cache[i] = -1;
      backref_cache[0] = recno;
      }

    cc += PRIV(OP_lengths)[*cc];

    /* Handle repeated back references */

    REPEAT_BACK_REFERENCE:
    switch (*cc)
      {
      case OP_CRSTAR:
      case OP_CRMINSTAR:
      case OP_CRQUERY:
      case OP_CRMINQUERY:
      case OP_CRPOSSTAR:
      case OP_CRPOSQUERY:
      min = 0;
      cc++;
      break;

      case OP_CRPLUS:
      case OP_CRMINPLUS:
      case OP_CRPOSPLUS:
      min = 1;
      cc++;
      break;

      case OP_CRRANGE:
      case OP_CRMINRANGE:
      case OP_CRPOSRANGE:
      min = GET2(cc, 1);
      cc += 1 + 2 * IMM2_SIZE;
      break;

      default:
      min = 1;
      break;
      }

     /* Take care not to overflow: (1) min and d are ints, so check that their
     product is not greater than INT_MAX. (2) branchlength is limited to
     UINT16_MAX (checked at the top of the loop). */

    if ((d > 0 && (INT_MAX/d) < min) || UINT16_MAX - branchlength < min*d)
      branchlength = UINT16_MAX;
    else branchlength += min * d;
    break;

    /* Recursion always refers to the first occurrence of a subpattern with a
    given number. Therefore, we can always make use of caching, even when the
    pattern contains multiple subpatterns with the same number. */

    case OP_RECURSE:
    cs = ce = startcode + GET(cc, 1);
    recno = GET2(cs, 1+LINK_SIZE);
    if (recno == prev_recurse_recno)
      {
      branchlength += prev_recurse_d;
      }
    else
      {
      do ce += GET(ce, 1); while (*ce == OP_ALT);
      if (cc > cs && cc < ce)    /* Simple recursion */
        had_recurse = TRUE;
      else
        {
        recurse_check *r = recurses;
        for (r = recurses; r != NULL; r = r->prev) if (r->group == cs) break;
        if (r != NULL)          /* Mutual recursion */
          had_recurse = TRUE;
        else
          {
          this_recurse.prev = recurses;
          this_recurse.group = cs;
          prev_recurse_d = find_minlength(re, cs, startcode, utf, &this_recurse,
            countptr, backref_cache);
          if (prev_recurse_d < 0) return prev_recurse_d;
          prev_recurse_recno = recno;
          branchlength += prev_recurse_d;
          }
        }
      }
    cc += 1 + LINK_SIZE + once_fudge;
    once_fudge = 0;
    break;

    /* Anything else does not or need not match a character. We can get the
    item's length from the table, but for those that can match zero occurrences
    of a character, we must take special action for UTF-8 characters. As it
    happens, the "NOT" versions of these opcodes are used at present only for
    ASCII characters, so they could be omitted from this list. However, in
    future that may change, so we include them here so as not to leave a
    gotcha for a future maintainer. */

    case OP_UPTO:
    case OP_UPTOI:
    case OP_NOTUPTO:
    case OP_NOTUPTOI:
    case OP_MINUPTO:
    case OP_MINUPTOI:
    case OP_NOTMINUPTO:
    case OP_NOTMINUPTOI:
    case OP_POSUPTO:
    case OP_POSUPTOI:
    case OP_NOTPOSUPTO:
    case OP_NOTPOSUPTOI:

    case OP_STAR:
    case OP_STARI:
    case OP_NOTSTAR:
    case OP_NOTSTARI:
    case OP_MINSTAR:
    case OP_MINSTARI:
    case OP_NOTMINSTAR:
    case OP_NOTMINSTARI:
    case OP_POSSTAR:
    case OP_POSSTARI:
    case OP_NOTPOSSTAR:
    case OP_NOTPOSSTARI:

    case OP_QUERY:
    case OP_QUERYI:
    case OP_NOTQUERY:
    case OP_NOTQUERYI:
    case OP_MINQUERY:
    case OP_MINQUERYI:
    case OP_NOTMINQUERY:
    case OP_NOTMINQUERYI:
    case OP_POSQUERY:
    case OP_POSQUERYI:
    case OP_NOTPOSQUERY:
    case OP_NOTPOSQUERYI:

    cc += PRIV(OP_lengths)[op];
#ifdef SUPPORT_UNICODE
    if (utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
#endif
    break;

    /* Skip these, but we need to add in the name length. */

    case OP_MARK:
    case OP_COMMIT_ARG:
    case OP_PRUNE_ARG:
    case OP_SKIP_ARG:
    case OP_THEN_ARG:
    cc += PRIV(OP_lengths)[op] + cc[1];
    break;

    /* The remaining opcodes are just skipped over. */

    case OP_CLOSE:
    case OP_COMMIT:
    case OP_FAIL:
    case OP_PRUNE:
    case OP_SET_SOM:
    case OP_SKIP:
    case OP_THEN:
    cc += PRIV(OP_lengths)[op];
    break;

    /* This should not occur: we list all opcodes explicitly so that when
    new ones get added they are properly considered. */

    default:
    PCRE2_DEBUG_UNREACHABLE();
    return -3;
    }
  }

PCRE2_DEBUG_UNREACHABLE(); /* Control should never reach here */
return -3;                 /* Avoid compiler warnings */
}



/*************************************************
*      Set a bit and maybe its alternate case    *
*************************************************/

/* Given a character, set its first code unit's bit in the table, and also the
corresponding bit for the other version of a letter if we are caseless.

Arguments:
  re            points to the regex block
  p             points to the first code unit of the character
  caseless      TRUE if caseless
  utf           TRUE for UTF mode
  ucp           TRUE for UCP mode

Returns:        pointer after the character
*/

static PCRE2_SPTR
set_table_bit(pcre2_real_code *re, PCRE2_SPTR p, BOOL caseless, BOOL utf,
  BOOL ucp)
{
uint32_t c = *p++;   /* First code unit */

(void)utf;           /* Stop compiler warnings when UTF not supported */
(void)ucp;

/* In 16-bit and 32-bit modes, code units greater than 0xff set the bit for
0xff. */

#if PCRE2_CODE_UNIT_WIDTH != 8
if (c > 0xff) SET_BIT(0xff); else
#endif

SET_BIT(c);

/* In UTF-8 or UTF-16 mode, pick up the remaining code units in order to find
the end of the character, even when caseless. */

#ifdef SUPPORT_UNICODE
if (utf)
  {
#if PCRE2_CODE_UNIT_WIDTH == 8
  if (c >= 0xc0) GETUTF8INC(c, p);
#elif PCRE2_CODE_UNIT_WIDTH == 16
  if ((c & 0xfc00) == 0xd800) GETUTF16INC(c, p);
#endif
  }
#endif  /* SUPPORT_UNICODE */

/* If caseless, handle the other case of the character. */

if (caseless)
  {
#ifdef SUPPORT_UNICODE
  if (utf || ucp)
    {
    c = UCD_OTHERCASE(c);
#if PCRE2_CODE_UNIT_WIDTH == 8
    if (utf)
      {
      PCRE2_UCHAR buff[6];
      (void)PRIV(ord2utf)(c, buff);
      SET_BIT(buff[0]);
      }
    else if (c < 256) SET_BIT(c);
#else  /* 16-bit or 32-bit mode */
    if (c > 0xff) SET_BIT(0xff); else SET_BIT(c);
#endif
    }

  else
#endif  /* SUPPORT_UNICODE */

  /* Not UTF or UCP */

  if (MAX_255(c)) SET_BIT(re->tables[fcc_offset + c]);
  }

return p;
}



/*************************************************
*     Set bits for a positive character type     *
*************************************************/

/* This function sets starting bits for a character type. In UTF-8 mode, we can
only do a direct setting for bytes less than 128, as otherwise there can be
confusion with bytes in the middle of UTF-8 characters. In a "traditional"
environment, the tables will only recognize ASCII characters anyway, but in at
least one Windows environment, some higher bytes bits were set in the tables.
So we deal with that case by considering the UTF-8 encoding.

Arguments:
  re             the regex block
  cbit type      the type of character wanted
  table_limit    32 for non-UTF-8; 16 for UTF-8

Returns:         nothing
*/

static void
set_type_bits(pcre2_real_code *re, int cbit_type, unsigned int table_limit)
{
uint32_t c;
for (c = 0; c < table_limit; c++)
  re->start_bitmap[c] |= re->tables[c+cbits_offset+cbit_type];
#if defined SUPPORT_UNICODE && PCRE2_CODE_UNIT_WIDTH == 8
if (table_limit == 32) return;
for (c = 128; c < 256; c++)
  {
  if ((re->tables[cbits_offset + c/8] & (1u << (c&7))) != 0)
    {
    PCRE2_UCHAR buff[6];
    (void)PRIV(ord2utf)(c, buff);
    SET_BIT(buff[0]);
    }
  }
#endif  /* UTF-8 */
}


/*************************************************
*     Set bits for a negative character type     *
*************************************************/

/* This function sets starting bits for a negative character type such as \D.
In UTF-8 mode, we can only do a direct setting for bytes less than 128, as
otherwise there can be confusion with bytes in the middle of UTF-8 characters.
Unlike in the positive case, where we can set appropriate starting bits for
specific high-valued UTF-8 characters, in this case we have to set the bits for
all high-valued characters. The lowest is 0xc2, but we overkill by starting at
0xc0 (192) for simplicity.

Arguments:
  re             the regex block
  cbit type      the type of character wanted
  table_limit    32 for non-UTF-8; 16 for UTF-8

Returns:         nothing
*/

static void
set_nottype_bits(pcre2_real_code *re, int cbit_type, unsigned int table_limit)
{
uint32_t c;
for (c = 0; c < table_limit; c++)
  re->start_bitmap[c] |= (uint8_t)(~(re->tables[c+cbits_offset+cbit_type]));
#if defined SUPPORT_UNICODE && PCRE2_CODE_UNIT_WIDTH == 8
if (table_limit != 32) for (c = 24; c < 32; c++) re->start_bitmap[c] = 0xff;
#endif
}



#if defined SUPPORT_UNICODE && PCRE2_CODE_UNIT_WIDTH == 8
/*************************************************
*     Set starting bits for a character list.    *
*************************************************/

/* This function sets starting bits for a character list. It enumerates
all characters and character ranges in the character list, and sets
the starting bits accordingly.

Arguments:
  code           pointer to the code
  start_bitmap   pointer to the starting bitmap

Returns:         nothing
*/
static void
study_char_list(PCRE2_SPTR code, uint8_t *start_bitmap,
  const uint8_t *char_lists_end)
{
uint32_t type, list_ind;
uint32_t char_list_add = XCL_CHAR_LIST_LOW_16_ADD;
uint32_t range_start = ~(uint32_t)0, range_end = 0;
const uint8_t *next_char;
PCRE2_UCHAR start_buffer[6], end_buffer[6];
PCRE2_UCHAR start, end;

/* Only needed in 8-bit mode at the moment. */
type = (uint32_t)(code[0] << 8) | code[1];
code += 2;

/* Align characters. */
next_char = char_lists_end - (GET(code, 0) << 1);
type &= XCL_TYPE_MASK;
list_ind = 0;

if ((type & XCL_BEGIN_WITH_RANGE) != 0)
  range_start = XCL_CHAR_LIST_LOW_16_START;

while (type > 0)
  {
  uint32_t item_count = type & XCL_ITEM_COUNT_MASK;

  if (item_count == XCL_ITEM_COUNT_MASK)
    {
    if (list_ind <= 1)
      {
      item_count = *(const uint16_t*)next_char;
      next_char += 2;
      }
    else
      {
      item_count = *(const uint32_t*)next_char;
      next_char += 4;
      }
    }

  while (item_count > 0)
    {
    if (list_ind <= 1)
      {
      range_end = *(const uint16_t*)next_char;
      next_char += 2;
      }
    else
      {
      range_end = *(const uint32_t*)next_char;
      next_char += 4;
      }

    if ((range_end & XCL_CHAR_END) != 0)
      {
      range_end = char_list_add + (range_end >> XCL_CHAR_SHIFT);

      PRIV(ord2utf)(range_end, end_buffer);
      end = end_buffer[0];

      if (range_start < range_end)
        {
        PRIV(ord2utf)(range_start, start_buffer);
        for (start = start_buffer[0]; start <= end; start++)
          start_bitmap[start / 8] |= (1u << (start & 7));
        }
      else
        start_bitmap[end / 8] |= (1u << (end & 7));

      range_start = ~(uint32_t)0;
      }
    else
      range_start = char_list_add + (range_end >> XCL_CHAR_SHIFT);

    item_count--;
    }

  list_ind++;
  type >>= XCL_TYPE_BIT_LEN;

  if (range_start == ~(uint32_t)0)
    {
    if ((type & XCL_BEGIN_WITH_RANGE) != 0)
      {
      /* In 8 bit mode XCL_CHAR_LIST_HIGH_32_START is not possible. */
      if (list_ind == 1) range_start = XCL_CHAR_LIST_HIGH_16_START;
      else range_start = XCL_CHAR_LIST_LOW_32_START;
      }
    }
  else if ((type & XCL_BEGIN_WITH_RANGE) == 0)
    {
    PRIV(ord2utf)(range_start, start_buffer);

    /* In 8 bit mode XCL_CHAR_LIST_LOW_32_END and
    XCL_CHAR_LIST_HIGH_32_END are not possible. */
    if (list_ind == 1) range_end = XCL_CHAR_LIST_LOW_16_END;
    else range_end = XCL_CHAR_LIST_HIGH_16_END;

    PRIV(ord2utf)(range_end, end_buffer);
    end = end_buffer[0];

    for (start = start_buffer[0]; start <= end; start++)
      start_bitmap[start / 8] |= (1u << (start & 7));

    range_start = ~(uint32_t)0;
    }

  /* In 8 bit mode XCL_CHAR_LIST_HIGH_32_ADD is not possible. */
  if (list_ind == 1) char_list_add = XCL_CHAR_LIST_HIGH_16_ADD;
  else char_list_add = XCL_CHAR_LIST_LOW_32_ADD;
  }
}
#endif



/*************************************************
*      Create bitmap of starting code units      *
*************************************************/

/* This function scans a compiled unanchored expression recursively and
attempts to build a bitmap of the set of possible starting code units whose
values are less than 256. In 16-bit and 32-bit mode, values above 255 all cause
the 255 bit to be set. When calling set[_not]_type_bits() in UTF-8 (sic) mode
we pass a value of 16 rather than 32 as the final argument. (See comments in
those functions for the reason.)

The SSB_CONTINUE return is useful for parenthesized groups in patterns such as
(a*)b where the group provides some optional starting code units but scanning
must continue at the outer level to find at least one mandatory code unit. At
the outermost level, this function fails unless the result is SSB_DONE.

We restrict recursion (for nested groups) to 1000 to avoid stack overflow
issues.

Arguments:
  re           points to the compiled regex block
  code         points to an expression
  utf          TRUE if in UTF mode
  ucp          TRUE if in UCP mode
  depthptr     pointer to recurse depth

Returns:       SSB_FAIL     => Failed to find any starting code units
               SSB_DONE     => Found mandatory starting code units
               SSB_CONTINUE => Found optional starting code units
               SSB_UNKNOWN  => Hit an unrecognized opcode
               SSB_TOODEEP  => Recursion is too deep
*/

static int
set_start_bits(pcre2_real_code *re, PCRE2_SPTR code, BOOL utf, BOOL ucp,
  int *depthptr)
{
uint32_t c;
int yield = SSB_DONE;

#if defined SUPPORT_UNICODE && PCRE2_CODE_UNIT_WIDTH == 8
int table_limit = utf? 16:32;
#else
int table_limit = 32;
#endif

*depthptr += 1;
if (*depthptr > 1000) return SSB_TOODEEP;

do
  {
  BOOL try_next = TRUE;
  PCRE2_SPTR tcode = code + 1 + LINK_SIZE;

  if (*code == OP_CBRA || *code == OP_SCBRA ||
      *code == OP_CBRAPOS || *code == OP_SCBRAPOS) tcode += IMM2_SIZE;

  while (try_next)    /* Loop for items in this branch */
    {
    int rc;
    PCRE2_SPTR ncode;
    const uint8_t *classmap = NULL;
#ifdef SUPPORT_WIDE_CHARS
    PCRE2_UCHAR xclassflags;
#endif

    switch(*tcode)
      {
      /* If we reach something we don't understand, it means a new opcode has
      been created that hasn't been added to this function. Hopefully this
      problem will be discovered during testing. */

      default:
      return SSB_UNKNOWN;

      /* Fail for a valid opcode that implies no starting bits. */

      case OP_ACCEPT:
      case OP_ASSERT_ACCEPT:
      case OP_ALLANY:
      case OP_ANY:
      case OP_ANYBYTE:
      case OP_CIRCM:
      case OP_CLOSE:
      case OP_COMMIT:
      case OP_COMMIT_ARG:
      case OP_COND:
      case OP_CREF:
      case OP_FALSE:
      case OP_TRUE:
      case OP_DNCREF:
      case OP_DNREF:
      case OP_DNREFI:
      case OP_DNRREF:
      case OP_DOLL:
      case OP_DOLLM:
      case OP_END:
      case OP_EOD:
      case OP_EODN:
      case OP_EXTUNI:
      case OP_FAIL:
      case OP_MARK:
      case OP_NOT:
      case OP_NOTEXACT:
      case OP_NOTEXACTI:
      case OP_NOTI:
      case OP_NOTMINPLUS:
      case OP_NOTMINPLUSI:
      case OP_NOTMINQUERY:
      case OP_NOTMINQUERYI:
      case OP_NOTMINSTAR:
      case OP_NOTMINSTARI:
      case OP_NOTMINUPTO:
      case OP_NOTMINUPTOI:
      case OP_NOTPLUS:
      case OP_NOTPLUSI:
      case OP_NOTPOSPLUS:
      case OP_NOTPOSPLUSI:
      case OP_NOTPOSQUERY:
      case OP_NOTPOSQUERYI:
      case OP_NOTPOSSTAR:
      case OP_NOTPOSSTARI:
      case OP_NOTPOSUPTO:
      case OP_NOTPOSUPTOI:
      case OP_NOTPROP:
      case OP_NOTQUERY:
      case OP_NOTQUERYI:
      case OP_NOTSTAR:
      case OP_NOTSTARI:
      case OP_NOTUPTO:
      case OP_NOTUPTOI:
      case OP_NOT_HSPACE:
      case OP_NOT_VSPACE:
      case OP_PRUNE:
      case OP_PRUNE_ARG:
      case OP_RECURSE:
      case OP_REF:
      case OP_REFI:
      case OP_REVERSE:
      case OP_VREVERSE:
      case OP_RREF:
      case OP_SCOND:
      case OP_SET_SOM:
      case OP_SKIP:
      case OP_SKIP_ARG:
      case OP_SOD:
      case OP_SOM:
      case OP_THEN:
      case OP_THEN_ARG:
      return SSB_FAIL;

      /* OP_CIRC happens only at the start of an anchored branch (multiline ^
      uses OP_CIRCM). Skip over it. */

      case OP_CIRC:
      tcode += PRIV(OP_lengths)[OP_CIRC];
      break;

      /* A "real" property test implies no starting bits, but the fake property
      PT_CLIST identifies a list of characters. These lists are short, as they
      are used for characters with more than one "other case", so there is no
      point in recognizing them for OP_NOTPROP. */

      case OP_PROP:
      if (tcode[1] != PT_CLIST) return SSB_FAIL;
        {
        const uint32_t *p = PRIV(ucd_caseless_sets) + tcode[2];
        while ((c = *p++) < NOTACHAR)
          {
#if defined SUPPORT_UNICODE && PCRE2_CODE_UNIT_WIDTH == 8
          if (utf)
            {
            PCRE2_UCHAR buff[6];
            (void)PRIV(ord2utf)(c, buff);
            c = buff[0];
            }
#endif
          if (c > 0xff) SET_BIT(0xff); else SET_BIT(c);
          }
        }
      try_next = FALSE;
      break;

      /* We can ignore word boundary tests. */

      case OP_WORD_BOUNDARY:
      case OP_NOT_WORD_BOUNDARY:
      case OP_UCP_WORD_BOUNDARY:
      case OP_NOT_UCP_WORD_BOUNDARY:
      tcode++;
      break;

      /* For a positive lookahead assertion, inspect what immediately follows,
      ignoring intermediate assertions and callouts. If the next item is one
      that sets a mandatory character, skip this assertion. Otherwise, treat it
      the same as other bracket groups. */

      case OP_ASSERT:
      case OP_ASSERT_NA:
      ncode = tcode + GET(tcode, 1);
      while (*ncode == OP_ALT) ncode += GET(ncode, 1);
      ncode += 1 + LINK_SIZE;

      /* Skip irrelevant items */

      for (BOOL done = FALSE; !done;)
        {
        switch (*ncode)
          {
          case OP_ASSERT:
          case OP_ASSERT_NOT:
          case OP_ASSERTBACK:
          case OP_ASSERTBACK_NOT:
          case OP_ASSERT_NA:
          case OP_ASSERTBACK_NA:
          case OP_ASSERT_SCS:
          ncode += GET(ncode, 1);
          while (*ncode == OP_ALT) ncode += GET(ncode, 1);
          ncode += 1 + LINK_SIZE;
          break;

          case OP_WORD_BOUNDARY:
          case OP_NOT_WORD_BOUNDARY:
          case OP_UCP_WORD_BOUNDARY:
          case OP_NOT_UCP_WORD_BOUNDARY:
          ncode++;
          break;

          case OP_CALLOUT:
          ncode += PRIV(OP_lengths)[OP_CALLOUT];
          break;

          case OP_CALLOUT_STR:
          ncode += GET(ncode, 1 + 2*LINK_SIZE);
          break;

          default:
          done = TRUE;
          break;
          }
        }

      /* Now check the next significant item. */

      switch(*ncode)
        {
        default:
        break;

        case OP_PROP:
        if (ncode[1] != PT_CLIST) break;
        /* Fall through */
        case OP_ANYNL:
        case OP_CHAR:
        case OP_CHARI:
        case OP_EXACT:
        case OP_EXACTI:
        case OP_HSPACE:
        case OP_MINPLUS:
        case OP_MINPLUSI:
        case OP_PLUS:
        case OP_PLUSI:
        case OP_POSPLUS:
        case OP_POSPLUSI:
        case OP_VSPACE:
        /* Note that these types will only be present in non-UCP mode. */
        case OP_DIGIT:
        case OP_NOT_DIGIT:
        case OP_WORDCHAR:
        case OP_NOT_WORDCHAR:
        case OP_WHITESPACE:
        case OP_NOT_WHITESPACE:
        tcode = ncode;
        continue;   /* With the following significant opcode */
        }
      /* Fall through */

      /* For a group bracket or a positive assertion without an immediately
      following mandatory setting, recurse to set bits from within the
      subpattern. If it can't find anything, we have to give up. If it finds
      some mandatory character(s), we are done for this branch. Otherwise,
      carry on scanning after the subpattern. */

      case OP_BRA:
      case OP_SBRA:
      case OP_CBRA:
      case OP_SCBRA:
      case OP_BRAPOS:
      case OP_SBRAPOS:
      case OP_CBRAPOS:
      case OP_SCBRAPOS:
      case OP_ONCE:
      case OP_SCRIPT_RUN:
      rc = set_start_bits(re, tcode, utf, ucp, depthptr);
      if (rc == SSB_DONE)
        {
        try_next = FALSE;
        }
      else if (rc == SSB_CONTINUE)
        {
        do tcode += GET(tcode, 1); while (*tcode == OP_ALT);
        tcode += 1 + LINK_SIZE;
        }
      else return rc;   /* FAIL, UNKNOWN, or TOODEEP */
      break;

      /* If we hit ALT or KET, it means we haven't found anything mandatory in
      this branch, though we might have found something optional. For ALT, we
      continue with the next alternative, but we have to arrange that the final
      result from subpattern is SSB_CONTINUE rather than SSB_DONE. For KET,
      return SSB_CONTINUE: if this is the top level, that indicates failure,
      but after a nested subpattern, it causes scanning to continue. */

      case OP_ALT:
      yield = SSB_CONTINUE;
      try_next = FALSE;
      break;

      case OP_KET:
      case OP_KETRMAX:
      case OP_KETRMIN:
      case OP_KETRPOS:
      return SSB_CONTINUE;

      /* Skip over callout */

      case OP_CALLOUT:
      tcode += PRIV(OP_lengths)[OP_CALLOUT];
      break;

      case OP_CALLOUT_STR:
      tcode += GET(tcode, 1 + 2*LINK_SIZE);
      break;

      /* Skip over lookbehind, negative lookahead, and scan substring
      assertions */

      case OP_ASSERT_NOT:
      case OP_ASSERTBACK:
      case OP_ASSERTBACK_NOT:
      case OP_ASSERTBACK_NA:
      case OP_ASSERT_SCS:
      do tcode += GET(tcode, 1); while (*tcode == OP_ALT);
      tcode += 1 + LINK_SIZE;
      break;

      /* BRAZERO does the bracket, but carries on. */

      case OP_BRAZERO:
      case OP_BRAMINZERO:
      case OP_BRAPOSZERO:
      rc = set_start_bits(re, ++tcode, utf, ucp, depthptr);
      if (rc == SSB_FAIL || rc == SSB_UNKNOWN || rc == SSB_TOODEEP) return rc;
      do tcode += GET(tcode,1); while (*tcode == OP_ALT);
      tcode += 1 + LINK_SIZE;
      break;

      /* SKIPZERO skips the bracket. */

      case OP_SKIPZERO:
      tcode++;
      do tcode += GET(tcode,1); while (*tcode == OP_ALT);
      tcode += 1 + LINK_SIZE;
      break;

      /* Single-char * or ? sets the bit and tries the next item */

      case OP_STAR:
      case OP_MINSTAR:
      case OP_POSSTAR:
      case OP_QUERY:
      case OP_MINQUERY:
      case OP_POSQUERY:
      tcode = set_table_bit(re, tcode + 1, FALSE, utf, ucp);
      break;

      case OP_STARI:
      case OP_MINSTARI:
      case OP_POSSTARI:
      case OP_QUERYI:
      case OP_MINQUERYI:
      case OP_POSQUERYI:
      tcode = set_table_bit(re, tcode + 1, TRUE, utf, ucp);
      break;

      /* Single-char upto sets the bit and tries the next */

      case OP_UPTO:
      case OP_MINUPTO:
      case OP_POSUPTO:
      tcode = set_table_bit(re, tcode + 1 + IMM2_SIZE, FALSE, utf, ucp);
      break;

      case OP_UPTOI:
      case OP_MINUPTOI:
      case OP_POSUPTOI:
      tcode = set_table_bit(re, tcode + 1 + IMM2_SIZE, TRUE, utf, ucp);
      break;

      /* At least one single char sets the bit and stops */

      case OP_EXACT:
      tcode += IMM2_SIZE;
      /* Fall through */
      case OP_CHAR:
      case OP_PLUS:
      case OP_MINPLUS:
      case OP_POSPLUS:
      (void)set_table_bit(re, tcode + 1, FALSE, utf, ucp);
      try_next = FALSE;
      break;

      case OP_EXACTI:
      tcode += IMM2_SIZE;
      /* Fall through */
      case OP_CHARI:
      case OP_PLUSI:
      case OP_MINPLUSI:
      case OP_POSPLUSI:
      (void)set_table_bit(re, tcode + 1, TRUE, utf, ucp);
      try_next = FALSE;
      break;

      /* Special spacing and line-terminating items. These recognize specific
      lists of characters. The difference between VSPACE and ANYNL is that the
      latter can match the two-character CRLF sequence, but that is not
      relevant for finding the first character, so their code here is
      identical. */

      case OP_HSPACE:
      SET_BIT(CHAR_HT);
      SET_BIT(CHAR_SPACE);

      /* For the 16-bit and 32-bit libraries (which can never be EBCDIC), set
      the bits for 0xA0 and for code units >= 255, independently of UTF. */

#if PCRE2_CODE_UNIT_WIDTH != 8
      SET_BIT(0xA0);
      SET_BIT(0xFF);
#else
      /* For the 8-bit library in UTF-8 mode, set the bits for the first code
      units of horizontal space characters. */

#ifdef SUPPORT_UNICODE
      if (utf)
        {
        SET_BIT(0xC2);  /* For U+00A0 */
        SET_BIT(0xE1);  /* For U+1680, U+180E */
        SET_BIT(0xE2);  /* For U+2000 - U+200A, U+202F, U+205F */
        SET_BIT(0xE3);  /* For U+3000 */
        }
      else
#endif
      /* For the 8-bit library not in UTF-8 mode, set the bit for 0xA0, unless
      the code is EBCDIC. */
        {
#ifndef EBCDIC
        SET_BIT(0xA0);
#endif  /* Not EBCDIC */
        }
#endif  /* 8-bit support */

      try_next = FALSE;
      break;

      case OP_ANYNL:
      case OP_VSPACE:
      SET_BIT(CHAR_LF);
      SET_BIT(CHAR_VT);
      SET_BIT(CHAR_FF);
      SET_BIT(CHAR_CR);

      /* For the 16-bit and 32-bit libraries (which can never be EBCDIC), set
      the bits for NEL and for code units >= 255, independently of UTF. */

#if PCRE2_CODE_UNIT_WIDTH != 8
      SET_BIT(CHAR_NEL);
      SET_BIT(0xFF);
#else
      /* For the 8-bit library in UTF-8 mode, set the bits for the first code
      units of vertical space characters. */

#ifdef SUPPORT_UNICODE
      if (utf)
        {
        SET_BIT(0xC2);  /* For U+0085 (NEL) */
        SET_BIT(0xE2);  /* For U+2028, U+2029 */
        }
      else
#endif
      /* For the 8-bit library not in UTF-8 mode, set the bit for NEL. */
        {
        SET_BIT(CHAR_NEL);
        }
#endif  /* 8-bit support */

      try_next = FALSE;
      break;

      /* Single character types set the bits and stop. Note that if PCRE2_UCP
      is set, we do not see these opcodes because \d etc are converted to
      properties. Therefore, these apply in the case when only characters less
      than 256 are recognized to match the types. */

      case OP_NOT_DIGIT:
      set_nottype_bits(re, cbit_digit, table_limit);
      try_next = FALSE;
      break;

      case OP_DIGIT:
      set_type_bits(re, cbit_digit, table_limit);
      try_next = FALSE;
      break;

      case OP_NOT_WHITESPACE:
      set_nottype_bits(re, cbit_space, table_limit);
      try_next = FALSE;
      break;

      case OP_WHITESPACE:
      set_type_bits(re, cbit_space, table_limit);
      try_next = FALSE;
      break;

      case OP_NOT_WORDCHAR:
      set_nottype_bits(re, cbit_word, table_limit);
      try_next = FALSE;
      break;

      case OP_WORDCHAR:
      set_type_bits(re, cbit_word, table_limit);
      try_next = FALSE;
      break;

      /* One or more character type fudges the pointer and restarts, knowing
      it will hit a single character type and stop there. */

      case OP_TYPEPLUS:
      case OP_TYPEMINPLUS:
      case OP_TYPEPOSPLUS:
      tcode++;
      break;

      case OP_TYPEEXACT:
      tcode += 1 + IMM2_SIZE;
      break;

      /* Zero or more repeats of character types set the bits and then
      try again. */

      case OP_TYPEUPTO:
      case OP_TYPEMINUPTO:
      case OP_TYPEPOSUPTO:
      tcode += IMM2_SIZE;  /* Fall through */

      case OP_TYPESTAR:
      case OP_TYPEMINSTAR:
      case OP_TYPEPOSSTAR:
      case OP_TYPEQUERY:
      case OP_TYPEMINQUERY:
      case OP_TYPEPOSQUERY:
      switch(tcode[1])
        {
        default:
        case OP_ANY:
        case OP_ALLANY:
        return SSB_FAIL;

        case OP_HSPACE:
        SET_BIT(CHAR_HT);
        SET_BIT(CHAR_SPACE);

        /* For the 16-bit and 32-bit libraries (which can never be EBCDIC), set
        the bits for 0xA0 and for code units >= 255, independently of UTF. */

#if PCRE2_CODE_UNIT_WIDTH != 8
        SET_BIT(0xA0);
        SET_BIT(0xFF);
#else
        /* For the 8-bit library in UTF-8 mode, set the bits for the first code
        units of horizontal space characters. */

#ifdef SUPPORT_UNICODE
        if (utf)
          {
          SET_BIT(0xC2);  /* For U+00A0 */
          SET_BIT(0xE1);  /* For U+1680, U+180E */
          SET_BIT(0xE2);  /* For U+2000 - U+200A, U+202F, U+205F */
          SET_BIT(0xE3);  /* For U+3000 */
          }
        else
#endif
        /* For the 8-bit library not in UTF-8 mode, set the bit for 0xA0, unless
        the code is EBCDIC. */
          {
#ifndef EBCDIC
          SET_BIT(0xA0);
#endif  /* Not EBCDIC */
          }
#endif  /* 8-bit support */
        break;

        case OP_ANYNL:
        case OP_VSPACE:
        SET_BIT(CHAR_LF);
        SET_BIT(CHAR_VT);
        SET_BIT(CHAR_FF);
        SET_BIT(CHAR_CR);

        /* For the 16-bit and 32-bit libraries (which can never be EBCDIC), set
        the bits for NEL and for code units >= 255, independently of UTF. */

#if PCRE2_CODE_UNIT_WIDTH != 8
        SET_BIT(CHAR_NEL);
        SET_BIT(0xFF);
#else
        /* For the 8-bit library in UTF-8 mode, set the bits for the first code
        units of vertical space characters. */

#ifdef SUPPORT_UNICODE
        if (utf)
          {
          SET_BIT(0xC2);  /* For U+0085 (NEL) */
          SET_BIT(0xE2);  /* For U+2028, U+2029 */
          }
        else
#endif
        /* For the 8-bit library not in UTF-8 mode, set the bit for NEL. */
          {
          SET_BIT(CHAR_NEL);
          }
#endif  /* 8-bit support */
        break;

        case OP_NOT_DIGIT:
        set_nottype_bits(re, cbit_digit, table_limit);
        break;

        case OP_DIGIT:
        set_type_bits(re, cbit_digit, table_limit);
        break;

        case OP_NOT_WHITESPACE:
        set_nottype_bits(re, cbit_space, table_limit);
        break;

        case OP_WHITESPACE:
        set_type_bits(re, cbit_space, table_limit);
        break;

        case OP_NOT_WORDCHAR:
        set_nottype_bits(re, cbit_word, table_limit);
        break;

        case OP_WORDCHAR:
        set_type_bits(re, cbit_word, table_limit);
        break;
        }

      tcode += 2;
      break;

      /* Set-based ECLASS: treat it the same as a "complex" XCLASS; give up. */

#ifdef SUPPORT_WIDE_CHARS
      case OP_ECLASS:
      return SSB_FAIL;
#endif

      /* Extended class: if there are any property checks, or if this is a
      negative XCLASS without a map, give up. If there are no property checks,
      there must be wide characters on the XCLASS list, because otherwise an
      XCLASS would not have been created. This means that code points >= 255
      are potential starters. In the UTF-8 case we can scan them and set bits
      for the relevant leading bytes. */

#ifdef SUPPORT_WIDE_CHARS
      case OP_XCLASS:
      xclassflags = tcode[1 + LINK_SIZE];
      if ((xclassflags & XCL_HASPROP) != 0 ||
          (xclassflags & (XCL_MAP|XCL_NOT)) == XCL_NOT)
        return SSB_FAIL;

      /* We have a positive XCLASS or a negative one without a map. Set up the
      map pointer if there is one, and fall through. */

      classmap = ((xclassflags & XCL_MAP) == 0)? NULL :
        (const uint8_t *)(tcode + 1 + LINK_SIZE + 1);

      /* In UTF-8 mode, scan the character list and set bits for leading bytes,
      then jump to handle the map. */

#if PCRE2_CODE_UNIT_WIDTH == 8
      if (utf && (xclassflags & XCL_NOT) == 0)
        {
        PCRE2_UCHAR b, e;
        PCRE2_SPTR p = tcode + 1 + LINK_SIZE + 1 + ((classmap == NULL)? 0:32);
        tcode += GET(tcode, 1);

        if (*p >= XCL_LIST)
          {
          study_char_list(p, re->start_bitmap,
            ((const uint8_t *)re + re->code_start));
          goto HANDLE_CLASSMAP;
          }

        for (;;) switch (*p++)
          {
          case XCL_SINGLE:
          b = *p++;
          while ((*p & 0xc0) == 0x80) p++;
          re->start_bitmap[b/8] |= (1u << (b&7));
          break;

          case XCL_RANGE:
          b = *p++;
          while ((*p & 0xc0) == 0x80) p++;
          e = *p++;
          while ((*p & 0xc0) == 0x80) p++;
          for (; b <= e; b++)
            re->start_bitmap[b/8] |= (1u << (b&7));
          break;

          case XCL_END:
          goto HANDLE_CLASSMAP;

          default:
          PCRE2_DEBUG_UNREACHABLE();
          return SSB_UNKNOWN;   /* Internal error, should not occur */
          }
        }
#endif  /* SUPPORT_UNICODE && PCRE2_CODE_UNIT_WIDTH == 8 */
#endif  /* SUPPORT_WIDE_CHARS */

      /* It seems that the fall through comment must be outside the #ifdef if
      it is to avoid the gcc compiler warning. */

      /* Fall through */

      /* Enter here for a negative non-XCLASS. In the 8-bit library, if we are
      in UTF mode, any byte with a value >= 0xc4 is a potentially valid starter
      because it starts a character with a value > 255. In 8-bit non-UTF mode,
      there is no difference between CLASS and NCLASS. In all other wide
      character modes, set the 0xFF bit to indicate code units >= 255. */

      case OP_NCLASS:
#if defined SUPPORT_UNICODE && PCRE2_CODE_UNIT_WIDTH == 8
      if (utf)
        {
        re->start_bitmap[24] |= 0xf0;            /* Bits for 0xc4 - 0xc8 */
        memset(re->start_bitmap+25, 0xff, 7);    /* Bits for 0xc9 - 0xff */
        }
#elif PCRE2_CODE_UNIT_WIDTH != 8
      SET_BIT(0xFF);                             /* For characters >= 255 */
#endif
      /* Fall through */

      /* Enter here for a positive non-XCLASS. If we have fallen through from
      an XCLASS, classmap will already be set; just advance the code pointer.
      Otherwise, set up classmap for a a non-XCLASS and advance past it. */

      case OP_CLASS:
      if (*tcode == OP_XCLASS) tcode += GET(tcode, 1); else
        {
        classmap = (const uint8_t *)(++tcode);
        tcode += 32 / sizeof(PCRE2_UCHAR);
        }

      /* When wide characters are supported, classmap may be NULL. In UTF-8
      (sic) mode, the bits in a class bit map correspond to character values,
      not to byte values. However, the bit map we are constructing is for byte
      values. So we have to do a conversion for characters whose code point is
      greater than 127. In fact, there are only two possible starting bytes for
      characters in the range 128 - 255. */

#if defined SUPPORT_WIDE_CHARS && PCRE2_CODE_UNIT_WIDTH == 8
      HANDLE_CLASSMAP:
#endif
      if (classmap != NULL)
        {
#if defined SUPPORT_UNICODE && PCRE2_CODE_UNIT_WIDTH == 8
        if (utf)
          {
          for (c = 0; c < 16; c++) re->start_bitmap[c] |= classmap[c];
          for (c = 128; c < 256; c++)
            {
            if ((classmap[c/8] & (1u << (c&7))) != 0)
              {
              int d = (c >> 6) | 0xc0;                 /* Set bit for this starter */
              re->start_bitmap[d/8] |= (1u << (d&7));  /* and then skip on to the */
              c = (c & 0xc0) + 0x40 - 1;               /* next relevant character. */
              }
            }
          }
        else
#endif
        /* In all modes except UTF-8, the two bit maps are compatible. */

          {
          for (c = 0; c < 32; c++) re->start_bitmap[c] |= classmap[c];
          }
        }

      /* Act on what follows the class. For a zero minimum repeat, continue;
      otherwise stop processing. */

      switch (*tcode)
        {
        case OP_CRSTAR:
        case OP_CRMINSTAR:
        case OP_CRQUERY:
        case OP_CRMINQUERY:
        case OP_CRPOSSTAR:
        case OP_CRPOSQUERY:
        tcode++;
        break;

        case OP_CRRANGE:
        case OP_CRMINRANGE:
        case OP_CRPOSRANGE:
        if (GET2(tcode, 1) == 0) tcode += 1 + 2 * IMM2_SIZE;
          else try_next = FALSE;
        break;

        default:
        try_next = FALSE;
        break;
        }
      break; /* End of class handling case */
      }      /* End of switch for opcodes */
    }        /* End of try_next loop */

  code += GET(code, 1);   /* Advance to next branch */
  }
while (*code == OP_ALT);

return yield;
}



/*************************************************
*          Study a compiled expression           *
*************************************************/

/* This function is handed a compiled expression that it must study to produce
information that will speed up the matching.

Argument:
  re       points to the compiled expression

Returns:   0 normally; non-zero should never normally occur
           1 unknown opcode in set_start_bits
           2 missing capturing bracket
           3 unknown opcode in find_minlength
*/

int
PRIV(study)(pcre2_real_code *re)
{
int count = 0;
PCRE2_UCHAR *code;
BOOL utf = (re->overall_options & PCRE2_UTF) != 0;
BOOL ucp = (re->overall_options & PCRE2_UCP) != 0;

/* Find start of compiled code */

code = (PCRE2_UCHAR *)((uint8_t *)re + re->code_start);

/* For a pattern that has a first code unit, or a multiline pattern that
matches only at "line start", there is no point in seeking a list of starting
code units. */

if ((re->flags & (PCRE2_FIRSTSET|PCRE2_STARTLINE)) == 0)
  {
  int depth = 0;
  int rc = set_start_bits(re, code, utf, ucp, &depth);
  if (rc == SSB_UNKNOWN)
    {
    PCRE2_DEBUG_UNREACHABLE();
    return 1;
    }

  /* If a list of starting code units was set up, scan the list to see if only
  one or two were listed. Having only one listed is rare because usually a
  single starting code unit will have been recognized and PCRE2_FIRSTSET set.
  If two are listed, see if they are caseless versions of the same character;
  if so we can replace the list with a caseless first code unit. This gives
  better performance and is plausibly worth doing for patterns such as [Ww]ord
  or (word|WORD). */

  if (rc == SSB_DONE)
    {
    int i;
    int a = -1;
    int b = -1;
    uint8_t *p = re->start_bitmap;
    uint32_t flags = PCRE2_FIRSTMAPSET;

    for (i = 0; i < 256; p++, i += 8)
      {
      uint8_t x = *p;
      if (x != 0)
        {
        int c;
        uint8_t y = x & (~x + 1);   /* Least significant bit */
        if (y != x) goto DONE;      /* More than one bit set */

        /* In the 16-bit and 32-bit libraries, the bit for 0xff means "0xff and
        all wide characters", so we cannot use it here. */

#if PCRE2_CODE_UNIT_WIDTH != 8
        if (i == 248 && x == 0x80) goto DONE;
#endif

        /* Compute the character value */

        c = i;
        switch (x)
          {
          case 1:   break;
          case 2:   c += 1; break;  case 4:  c += 2; break;
          case 8:   c += 3; break;  case 16: c += 4; break;
          case 32:  c += 5; break;  case 64: c += 6; break;
          case 128: c += 7; break;
          }

        /* c contains the code unit value, in the range 0-255. In 8-bit UTF
        mode, only values < 128 can be used. In all the other cases, c is a
        character value. */

#if PCRE2_CODE_UNIT_WIDTH == 8
        if (utf && c > 127) goto DONE;
#endif
        if (a < 0) a = c;   /* First one found, save in a */
        else if (b < 0)     /* Second one found */
          {
          int d = TABLE_GET((unsigned int)c, re->tables + fcc_offset, c);

#ifdef SUPPORT_UNICODE
          if (utf || ucp)
            {
            if (UCD_CASESET(c) != 0) goto DONE;     /* Multiple case set */
            if (c > 127) d = UCD_OTHERCASE(c);
            }
#endif  /* SUPPORT_UNICODE */

          if (d != a) goto DONE;   /* Not the other case of a */
          b = c;                   /* Save second in b */
          }
        else goto DONE;   /* More than two characters found */
        }
      }

    /* Replace the start code unit bits with a first code unit. If it is the
    same as a required later code unit, then clear the required later code
    unit. This is because a search for a required code unit starts after an
    explicit first code unit, but at a code unit found from the bitmap.
    Patterns such as /a*a/ don't work if both the start unit and required
    unit are the same. */

    if (a >= 0) {
      if ((re->flags & PCRE2_LASTSET) && (re->last_codeunit == (uint32_t)a || (b >= 0 && re->last_codeunit == (uint32_t)b))) {
        re->flags &= ~(PCRE2_LASTSET | PCRE2_LASTCASELESS);
        re->last_codeunit = 0;
      }
      re->first_codeunit = a;
      flags = PCRE2_FIRSTSET;
      if (b >= 0) flags |= PCRE2_FIRSTCASELESS;
    }

    DONE:
    re->flags |= flags;
    }
  }

/* Find the minimum length of subject string. If the pattern can match an empty
string, the minimum length is already known. If the pattern contains (*ACCEPT)
all bets are off, and we don't even try to find a minimum length. If there are
more back references than the size of the vector we are going to cache them in,
do nothing. A pattern that complicated will probably take a long time to
analyze and may in any case turn out to be too complicated. Note that back
reference minima are held as 16-bit numbers. */

if ((re->flags & (PCRE2_MATCH_EMPTY|PCRE2_HASACCEPT)) == 0 &&
     re->top_backref <= MAX_CACHE_BACKREF)
  {
  int min;
  int backref_cache[MAX_CACHE_BACKREF+1];
  backref_cache[0] = 0;    /* Highest one that is set */
  min = find_minlength(re, code, code, utf, NULL, &count, backref_cache);
  switch(min)
    {
    case -1:  /* \C in UTF mode or over-complex regex */
    break;    /* Leave minlength unchanged (will be zero) */

    case -2:
    PCRE2_DEBUG_UNREACHABLE();
    return 2; /* missing capturing bracket */

    case -3:
    PCRE2_DEBUG_UNREACHABLE();
    return 3; /* unrecognized opcode */

    default:
    re->minlength = (min > UINT16_MAX)? UINT16_MAX : min;
    break;
    }
  }

return 0;
}

/* End of pcre2_study.c */


================================================
FILE: Libraries/PCRE/pcre2_substring.c
================================================
/*************************************************
*      Perl-Compatible Regular Expressions       *
*************************************************/

/* PCRE is a library of functions to support regular expressions whose syntax
and semantics are as close as possible to those of the Perl 5 language.

                       Written by Philip Hazel
     Original API code Copyright (c) 1997-2012 University of Cambridge
          New API code Copyright (c) 2016-2024 University of Cambridge

-----------------------------------------------------------------------------
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

    * Redistributions of source code must retain the above copyright notice,
      this list of conditions and the following disclaimer.

    * Redistributions in binary form must reproduce the above copyright
      notice, this list of conditions and the following disclaimer in the
      documentation and/or other materials provided with the distribution.

    * Neither the name of the University of Cambridge nor the names of its
      contributors may be used to endorse or promote products derived from
      this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
-----------------------------------------------------------------------------
*/


#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include "pcre2_internal.h"



/*************************************************
*   Copy named captured string to given buffer   *
*************************************************/

/* This function copies a single captured substring into a given buffer,
identifying it by name. If the regex permits duplicate names, the first
substring that is set is chosen.

Arguments:
  match_data     points to the match data
  stringname     the name of the required substring
  buffer         where to put the substring
  sizeptr        the size of the buffer, updated to the size of the substring

Returns:         if successful: zero
                 if not successful, a negative error code:
                   (1) an error from nametable_scan()
                   (2) an error from copy_bynumber()
                   (3) PCRE2_ERROR_UNAVAILABLE: no group is in ovector
                   (4) PCRE2_ERROR_UNSET: all named groups in ovector are unset
*/

PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
pcre2_substring_copy_byname(pcre2_match_data *match_data, PCRE2_SPTR stringname,
  PCRE2_UCHAR *buffer, PCRE2_SIZE *sizeptr)
{
PCRE2_SPTR first, last, entry;
int failrc, entrysize;
if (match_data->matchedby == PCRE2_MATCHEDBY_DFA_INTERPRETER)
  return PCRE2_ERROR_DFA_UFUNC;
entrysize = pcre2_substring_nametable_scan(match_data->code, stringname,
  &first, &last);
if (entrysize < 0) return entrysize;
failrc = PCRE2_ERROR_UNAVAILABLE;
for (entry = first; entry <= last; entry += entrysize)
  {
  uint32_t n = GET2(entry, 0);
  if (n < match_data->oveccount)
    {
    if (match_data->ovector[n*2] != PCRE2_UNSET)
      return pcre2_substring_copy_bynumber(match_data, n, buffer, sizeptr);
    failrc = PCRE2_ERROR_UNSET;
    }
  }
return failrc;
}



/*************************************************
*  Copy numbered captured string to given buffer *
*************************************************/

/* This function copies a single captured substring into a given buffer,
identifying it by number.

Arguments:
  match_data     points to the match data
  stringnumber   the number of the required substring
  buffer         where to put the substring
  sizeptr        the size of the buffer, updated to the size of the substring

Returns:         if successful: 0
                 if not successful, a negative error code:
                   PCRE2_ERROR_NOMEMORY: buffer too small
                   PCRE2_ERROR_NOSUBSTRING: no such substring
                   PCRE2_ERROR_UNAVAILABLE: ovector too small
                   PCRE2_ERROR_UNSET: substring is not set
*/

PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
pcre2_substring_copy_bynumber(pcre2_match_data *match_data,
  uint32_t stringnumber, PCRE2_UCHAR *buffer, PCRE2_SIZE *sizeptr)
{
int rc;
PCRE2_SIZE size;
rc = pcre2_substring_length_bynumber(match_data, stringnumber, &size);
if (rc < 0) return rc;
if (size + 1 > *sizeptr) return PCRE2_ERROR_NOMEMORY;
memcpy(buffer, match_data->subject + match_data->ovector[stringnumber*2],
  CU2BYTES(size));
buffer[size] = 0;
*sizeptr = size;
return 0;
}



/*************************************************
*          Extract named captured string         *
*************************************************/

/* This function copies a single captured substring, identified by name, into
new memory. If the regex permits duplicate names, the first substring that is
set is chosen.

Arguments:
  match_data     pointer to match_data
  stringname     the name of the required substring
  stringptr      where to put the pointer to the new memory
  sizeptr        where to put the length of the substring

Returns:         if successful: zero
                 if not successful, a negative value:
                   (1) an error from nametable_scan()
                   (2) an error from get_bynumber()
                   (3) PCRE2_ERROR_UNAVAILABLE: no group is in ovector
                   (4) PCRE2_ERROR_UNSET: all named groups in ovector are unset
*/

PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
pcre2_substring_get_byname(pcre2_match_data *match_data,
  PCRE2_SPTR stringname, PCRE2_UCHAR **stringptr, PCRE2_SIZE *sizeptr)
{
PCRE2_SPTR first, last, entry;
int failrc, entrysize;
if (match_data->matchedby == PCRE2_MATCHEDBY_DFA_INTERPRETER)
  return PCRE2_ERROR_DFA_UFUNC;
entrysize = pcre2_substring_nametable_scan(match_data->code, stringname,
  &first, &last);
if (entrysize < 0) return entrysize;
failrc = PCRE2_ERROR_UNAVAILABLE;
for (entry = first; entry <= last; entry += entrysize)
  {
  uint32_t n = GET2(entry, 0);
  if (n < match_data->oveccount)
    {
    if (match_data->ovector[n*2] != PCRE2_UNSET)
      return pcre2_substring_get_bynumber(match_data, n, stringptr, sizeptr);
    failrc = PCRE2_ERROR_UNSET;
    }
  }
return failrc;
}



/*************************************************
*      Extract captured string to new memory     *
*************************************************/

/* This function copies a single captured substring into a piece of new
memory.

Arguments:
  match_data     points to match data
  stringnumber   the number of the required substring
  stringptr      where to put a pointer to the new memory
  sizeptr        where to put the size of the substring

Returns:         if successful: 0
                 if not successful, a negative error code:
                   PCRE2_ERROR_NOMEMORY: failed to get memory
                   PCRE2_ERROR_NOSUBSTRING: no such substring
                   PCRE2_ERROR_UNAVAILABLE: ovector too small
                   PCRE2_ERROR_UNSET: substring is not set
*/

PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
pcre2_substring_get_bynumber(pcre2_match_data *match_data,
  uint32_t stringnumber, PCRE2_UCHAR **stringptr, PCRE2_SIZE *sizeptr)
{
int rc;
PCRE2_SIZE size;
PCRE2_UCHAR *yield;
rc = pcre2_substring_length_bynumber(match_data, stringnumber, &size);
if (rc < 0) return rc;
yield = PRIV(memctl_malloc)(sizeof(pcre2_memctl) +
  (size + 1)*PCRE2_CODE_UNIT_WIDTH, (pcre2_memctl *)match_data);
if (yield == NULL) return PCRE2_ERROR_NOMEMORY;
yield = (PCRE2_UCHAR *)(((char *)yield) + sizeof(pcre2_memctl));
memcpy(yield, match_data->subject + match_data->ovector[stringnumber*2],
  CU2BYTES(size));
yield[size] = 0;
*stringptr = yield;
*sizeptr = size;
return 0;
}



/*************************************************
*       Free memory obtained by get_substring    *
*************************************************/

/*
Argument:     the result of a previous pcre2_substring_get_byxxx()
Returns:      nothing
*/

PCRE2_EXP_DEFN void PCRE2_CALL_CONVENTION
pcre2_substring_free(PCRE2_UCHAR *string)
{
if (string != NULL)
  {
  pcre2_memctl *memctl = (pcre2_memctl *)((char *)string - sizeof(pcre2_memctl));
  memctl->free(memctl, memctl->memory_data);
  }
}



/*************************************************
*         Get length of a named substring        *
*************************************************/

/* This function returns the length of a named captured substring. If the regex
permits duplicate names, the first substring that is set is chosen.

Arguments:
  match_data      pointer to match data
  stringname      the name of the required substring
  sizeptr         where to put the length

Returns:          0 if successful, else a negative error number
*/

PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
pcre2_substring_length_byname(pcre2_match_data *match_data,
  PCRE2_SPTR stringname, PCRE2_SIZE *sizeptr)
{
PCRE2_SPTR first, last, entry;
int failrc, entrysize;
if (match_data->matchedby == PCRE2_MATCHEDBY_DFA_INTERPRETER)
  return PCRE2_ERROR_DFA_UFUNC;
entrysize = pcre2_substring_nametable_scan(match_data->code, stringname,
  &first, &last);
if (entrysize < 0) return entrysize;
failrc = PCRE2_ERROR_UNAVAILABLE;
for (entry = first; entry <= last; entry += entrysize)
  {
  uint32_t n = GET2(entry, 0);
  if (n < match_data->oveccount)
    {
    if (match_data->ovector[n*2] != PCRE2_UNSET)
      return pcre2_substring_length_bynumber(match_data, n, sizeptr);
    failrc = PCRE2_ERROR_UNSET;
    }
  }
return failrc;
}



/*************************************************
*        Get length of a numbered substring      *
*************************************************/

/* This function returns the length of a captured substring. If the start is
beyond the end (which can happen when \K is used in an assertion), it sets the
length to zero.

Arguments:
  match_data      pointer to match data
  stringnumber    the number of the required substring
  sizeptr         where to put the length, if not NULL

Returns:         if successful: 0
                 if not successful, a negative error code:
                   PCRE2_ERROR_NOSUBSTRING: no such substring
                   PCRE2_ERROR_UNAVAILABLE: ovector is too small
                   PCRE2_ERROR_UNSET: substring is not set
                   PCRE2_ERROR_INVALIDOFFSET: internal error, should not occur
*/

PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
pcre2_substring_length_bynumber(pcre2_match_data *match_data,
  uint32_t stringnumber, PCRE2_SIZE *sizeptr)
{
PCRE2_SIZE left, right;
int count = match_data->rc;
if (count == PCRE2_ERROR_PARTIAL)
  {
  if (stringnumber > 0) return PCRE2_ERROR_PARTIAL;
  count = 0;
  }
else if (count < 0) return count;            /* Match failed */

if (match_data->matchedby != PCRE2_MATCHEDBY_DFA_INTERPRETER)
  {
  if (stringnumber > match_data->code->top_bracket)
    return PCRE2_ERROR_NOSUBSTRING;
  if (stringnumber >= match_data->oveccount)
    return PCRE2_ERROR_UNAVAILABLE;
  if (match_data->ovector[stringnumber*2] == PCRE2_UNSET)
    return PCRE2_ERROR_UNSET;
  }
else  /* Matched using pcre2_dfa_match() */
  {
  if (stringnumber >= match_data->oveccount) return PCRE2_ERROR_UNAVAILABLE;
  if (count != 0 && stringnumber >= (uint32_t)count) return PCRE2_ERROR_UNSET;
  }

left = match_data->ovector[stringnumber*2];
right = match_data->ovector[stringnumber*2+1];
if (left > match_data->subject_length || right > match_data->subject_length)
  return PCRE2_ERROR_INVALIDOFFSET;
if (sizeptr != NULL) *sizeptr = (left > right)? 0 : right - left;
return 0;
}



/*************************************************
*    Extract all captured strings to new memory  *
*************************************************/

/* This function gets one chunk of memory and builds a list of pointers and all
the captured substrings in it. A NULL pointer is put on the end of the list.
The substrings are zero-terminated, but also, if the final argument is
non-NULL, a list of lengths is also returned. This allows binary data to be
handled.

Arguments:
  match_data     points to the match data
  listptr        set to point to the list of pointers
  lengthsptr     set to point to the list of lengths (may be NULL)

Returns:         if successful: 0
                 if not successful, a negative error code:
                   PCRE2_ERROR_NOMEMORY: failed to get memory,
                   or a match failure code
*/

PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
pcre2_substring_list_get(pcre2_match_data *match_data, PCRE2_UCHAR ***listptr,
  PCRE2_SIZE **lengthsptr)
{
int i, count, count2;
PCRE2_SIZE size;
PCRE2_SIZE *lensp;
pcre2_memctl *memp;
PCRE2_UCHAR **listp;
PCRE2_UCHAR *sp;
PCRE2_SIZE *ovector;

if ((count = match_data->rc) < 0) return count;   /* Match failed */
if (count == 0) count = match_data->oveccount;    /* Ovector too small */

count2 = 2*count;
ovector = match_data->ovector;
size = sizeof(pcre2_memctl) + sizeof(PCRE2_UCHAR *);      /* For final NULL */
if (lengthsptr != NULL) size += sizeof(PCRE2_SIZE) * count;  /* For lengths */

for (i = 0; i < count2; i += 2)
  {
  size += sizeof(PCRE2_UCHAR *) + CU2BYTES(1);
  if (ovector[i+1] > ovector[i]) size += CU2BYTES(ovector[i+1] - ovector[i]);
  }

memp = PRIV(memctl_malloc)(size, (pcre2_memctl *)match_data);
if (memp == NULL) return PCRE2_ERROR_NOMEMORY;

*listptr = listp = (PCRE2_UCHAR **)((char *)memp + sizeof(pcre2_memctl));
lensp = (PCRE2_SIZE *)((char *)listp + sizeof(PCRE2_UCHAR *) * (count + 1));

if (lengthsptr == NULL)
  {
  sp = (PCRE2_UCHAR *)lensp;
  lensp = NULL;
  }
else
  {
  *lengthsptr = lensp;
  sp = (PCRE2_UCHAR *)((char *)lensp + sizeof(PCRE2_SIZE) * count);
  }

for (i = 0; i < count2; i += 2)
  {
  size = (ovector[i+1] > ovector[i])? (ovector[i+1] - ovector[i]) : 0;

  /* Size == 0 includes the case when the capture is unset. Avoid adding
  PCRE2_UNSET to match_data->subject because it overflows, even though with
  zero size calling memcpy() is harmless. */

  if (size != 0) memcpy(sp, match_data->subject + ovector[i], CU2BYTES(size));
  *listp++ = sp;
  if (lensp != NULL) *lensp++ = size;
  sp += size;
  *sp++ = 0;
  }

*listp = NULL;
return 0;
}



/*************************************************
*   Free memory obtained by substring_list_get   *
*************************************************/

/*
Argument:     the result of a previous pcre2_substring_list_get()
Returns:      nothing
*/

PCRE2_EXP_DEFN void PCRE2_CALL_CONVENTION
pcre2_substring_list_free(PCRE2_UCHAR **list)
{
if (list != NULL)
  {
  pcre2_memctl *memctl = (pcre2_memctl *)((char *)list - sizeof(pcre2_memctl));
  memctl->free(memctl, memctl->memory_data);
  }
}



/*************************************************
*     Find (multiple) entries for named string   *
*************************************************/

/* This function scans the nametable for a given name, using binary chop. It
returns either two pointers to the entries in the table, or, if no pointers are
given, the number of a unique group with the given name. If duplicate names are
permitted, and the name is not unique, an error is generated.

Arguments:
  code        the compiled regex
  stringname  the name whose entries required
  firstptr    where to put the pointer to the first entry
  lastptr     where to put the pointer to the last entry

Returns:      PCRE2_ERROR_NOSUBSTRING if the name is not found
              otherwise, if firstptr and lastptr are NULL:
                a group number for a unique substring
                else PCRE2_ERROR_NOUNIQUESUBSTRING
              otherwise:
                the length of each entry, having set firstptr and lastptr
*/

PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
pcre2_substring_nametable_scan(const pcre2_code *code, PCRE2_SPTR stringname,
  PCRE2_SPTR *firstptr, PCRE2_SPTR *lastptr)
{
uint16_t bot = 0;
uint16_t top = code->name_count;
uint16_t entrysize = code->name_entry_size;
PCRE2_SPTR nametable = (PCRE2_SPTR)((const char *)code + sizeof(pcre2_real_code));

while (top > bot)
  {
  uint16_t mid = (top + bot) / 2;
  PCRE2_SPTR entry = nametable + entrysize*mid;
  int c = PRIV(strcmp)(stringname, entry + IMM2_SIZE);
  if (c == 0)
    {
    PCRE2_SPTR first;
    PCRE2_SPTR last;
    PCRE2_SPTR lastentry;
    lastentry = nametable + entrysize * (code->name_count - 1);
    first = last = entry;
    while (first > nametable)
      {
      if (PRIV(strcmp)(stringname, (first - entrysize + IMM2_SIZE)) != 0) break;
      first -= entrysize;
      }
    while (last < lastentry)
      {
      if (PRIV(strcmp)(stringname, (last + entrysize + IMM2_SIZE)) != 0) break;
      last += entrysize;
      }
    if (firstptr == NULL) return (first == last)?
      (int)GET2(entry, 0) : PCRE2_ERROR_NOUNIQUESUBSTRING;
    *firstptr = first;
    *lastptr = last;
    return entrysize;
    }
  if (c > 0) bot = mid + 1; else top = mid;
  }

return PCRE2_ERROR_NOSUBSTRING;
}


/*************************************************
*           Find number for named string         *
*************************************************/

/* This function is a convenience wrapper for pcre2_substring_nametable_scan()
when it is known that names are unique. If there are duplicate names, it is not
defined which number is returned.

Arguments:
  code        the compiled regex
  stringname  the name whose number is required

Returns:      the number of the named parenthesis, or a negative number
                PCRE2_ERROR_NOSUBSTRING if not found
                PCRE2_ERROR_NOUNIQUESUBSTRING if not unique
*/

PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
pcre2_substring_number_from_name(const pcre2_code *code,
  PCRE2_SPTR stringname)
{
return pcre2_substring_nametable_scan(code, stringname, NULL, NULL);
}

/* End of pcre2_substring.c */


================================================
FILE: Libraries/PCRE/pcre2_tables.c
================================================
/*************************************************
*      Perl-Compatible Regular Expressions       *
*************************************************/

/* PCRE is a library of functions to support regular expressions whose syntax
and semantics are as close as possible to those of the Perl 5 language.

                       Written by Philip Hazel
     Original API code Copyright (c) 1997-2012 University of Cambridge
          New API code Copyright (c) 2016-2024 University of Cambridge

-----------------------------------------------------------------------------
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

    * Redistributions of source code must retain the above copyright notice,
      this list of conditions and the following disclaimer.

    * Redistributions in binary form must reproduce the above copyright
      notice, this list of conditions and the following disclaimer in the
      documentation and/or other materials provided with the distribution.

    * Neither the name of the University of Cambridge nor the names of its
      contributors may be used to endorse or promote products derived from
      this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
-----------------------------------------------------------------------------
*/

/* This module contains some fixed tables that are used by more than one of the
PCRE2 code modules. The tables are also #included by the pcre2test program,
which uses macros to change their names from _pcre2_xxx to xxxx, thereby
avoiding name clashes with the library. In this case, PCRE2_PCRE2TEST is
defined. */

#ifndef PCRE2_PCRE2TEST           /* We're compiling the library */
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "pcre2_internal.h"
#endif /* PCRE2_PCRE2TEST */

/* Table of sizes for the fixed-length opcodes. It's defined in a macro so that
the definition is next to the definition of the opcodes in pcre2_internal.h.
This is mode-dependent, so it is skipped when this file is included by
pcre2test. */

#ifndef PCRE2_PCRE2TEST
const uint8_t PRIV(OP_lengths)[] = { OP_LENGTHS };
#endif

/* Tables of horizontal and vertical whitespace characters, suitable for
adding to classes. */

const uint32_t PRIV(hspace_list)[] = { HSPACE_LIST };
const uint32_t PRIV(vspace_list)[] = { VSPACE_LIST };

/* These tables are the pairs of delimiters that are valid for callout string
arguments. For each starting delimiter there must be a matching ending
delimiter, which in fact is different only for bracket-like delimiters. */

const uint32_t PRIV(callout_start_delims)[] = {
  CHAR_GRAVE_ACCENT, CHAR_APOSTROPHE, CHAR_QUOTATION_MARK,
  CHAR_CIRCUMFLEX_ACCENT, CHAR_PERCENT_SIGN, CHAR_NUMBER_SIGN,
  CHAR_DOLLAR_SIGN, CHAR_LEFT_CURLY_BRACKET, 0 };

const uint32_t PRIV(callout_end_delims[]) = {
  CHAR_GRAVE_ACCENT, CHAR_APOSTROPHE, CHAR_QUOTATION_MARK,
  CHAR_CIRCUMFLEX_ACCENT, CHAR_PERCENT_SIGN, CHAR_NUMBER_SIGN,
  CHAR_DOLLAR_SIGN, CHAR_RIGHT_CURLY_BRACKET, 0 };


/*************************************************
*           Tables for UTF-8 support             *
*************************************************/

/* These tables are required by pcre2test in 16- or 32-bit mode, as well
as for the library in 8-bit mode, because pcre2test uses UTF-8 internally for
handling wide characters. */

#if defined PCRE2_PCRE2TEST || \
   (defined SUPPORT_UNICODE && \
    defined PCRE2_CODE_UNIT_WIDTH && \
    PCRE2_CODE_UNIT_WIDTH == 8)

/* These are the breakpoints for different numbers of bytes in a UTF-8
character. */

const int PRIV(utf8_table1)[] =
  { 0x7f, 0x7ff, 0xffff, 0x1fffff, 0x3ffffff, 0x7fffffff};

const int PRIV(utf8_table1_size) = sizeof(PRIV(utf8_table1)) / sizeof(int);

/* These are the indicator bits and the mask for the data bits to set in the
first byte of a character, indexed by the number of additional bytes. */

const int PRIV(utf8_table2)[] = { 0,    0xc0, 0xe0, 0xf0, 0xf8, 0xfc};
const int PRIV(utf8_table3)[] = { 0xff, 0x1f, 0x0f, 0x07, 0x03, 0x01};

/* Table of the number of extra bytes, indexed by the first byte masked with
0x3f. The highest number for a valid UTF-8 first byte is in fact 0x3d. */

const uint8_t PRIV(utf8_table4)[] = {
  1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
  1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
  2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
  3,3,3,3,3,3,3,3,4,4,4,4,5,5,5,5 };

#endif /* UTF-8 support needed */

/* Tables concerned with Unicode properties are relevant only when Unicode
support is enabled. See also the pcre2_ucptables.c file, which is generated by
a Python script from Unicode data files. */

#ifdef SUPPORT_UNICODE

/* Table to translate from particular type value to the general value. */

const uint32_t PRIV(ucp_gentype)[] = {
  ucp_C, ucp_C, ucp_C, ucp_C, ucp_C,  /* Cc, Cf, Cn, Co, Cs */
  ucp_L, ucp_L, ucp_L, ucp_L, ucp_L,  /* Ll, Lu, Lm, Lo, Lt */
  ucp_M, ucp_M, ucp_M,                /* Mc, Me, Mn */
  ucp_N, ucp_N, ucp_N,                /* Nd, Nl, No */
  ucp_P, ucp_P, ucp_P, ucp_P, ucp_P,  /* Pc, Pd, Pe, Pf, Pi */
  ucp_P, ucp_P,                       /* Ps, Po */
  ucp_S, ucp_S, ucp_S, ucp_S,         /* Sc, Sk, Sm, So */
  ucp_Z, ucp_Z, ucp_Z                 /* Zl, Zp, Zs */
};

/* This table encodes the rules for finding the end of an extended grapheme
cluster. Every code point has a grapheme break property which is one of the
ucp_gbXX values defined in pcre2_ucp.h. These changed between Unicode versions
10 and 11. The 2-dimensional table is indexed by the properties of two adjacent
code points. The left property selects a word from the table, and the right
property selects a bit from that word like this:

  PRIV(ucp_gbtable)[left-property] & (1u << right-property)

The value is non-zero if a grapheme break is NOT permitted between the relevant
two code points. The breaking rules are as follows:

1. Break at the start and end of text (pretty obviously).

2. Do not break between a CR and LF; otherwise, break before and after
   controls.

3. Do not break Hangul syllable sequences, the rules for which are:

    L may be followed by L, V, LV or LVT
    LV or V may be followed by V or T
    LVT or T may be followed by T

4. Do not break before extending characters or zero-width-joiner (ZWJ).

The following rules are only for extended grapheme clusters (but that's what we
are implementing).

5. Do not break before SpacingMarks.

6. Do not break after Prepend characters.

7. Do not break within emoji modifier sequences or emoji zwj sequences. That
   is, do not break between characters with the Extended_Pictographic property
   if a ZWJ intervenes. Extend characters are allowed between the characters;
   this cannot be represented in this table, the code has to deal with it.

8. Do not break within emoji flag sequences. That is, do not break between
   regional indicator (RI) symbols if there are an odd number of RI characters
   before the break point. This table encodes "join RI characters"; the code
   has to deal with checking for previous adjoining RIs.

9. Otherwise, break everywhere.
*/

#define ESZ (1<<ucp_gbExtend)|(1<<ucp_gbSpacingMark)|(1<<ucp_gbZWJ)

const uint32_t PRIV(ucp_gbtable)[] = {
   (1u<<ucp_gbLF),                                      /*  0 CR */
   0,                                                   /*  1 LF */
   0,                                                   /*  2 Control */
   ESZ,                                                 /*  3 Extend */
   ESZ|(1u<<ucp_gbPrepend)|                             /*  4 Prepend */
       (1u<<ucp_gbL)|(1u<<ucp_gbV)|(1u<<ucp_gbT)|
       (1u<<ucp_gbLV)|(1u<<ucp_gbLVT)|(1u<<ucp_gbOther)|
       (1u<<ucp_gbRegional_Indicator),
   ESZ,                                                 /*  5 SpacingMark */
   ESZ|(1u<<ucp_gbL)|(1u<<ucp_gbV)|(1u<<ucp_gbLV)|      /*  6 L */
       (1u<<ucp_gbLVT),
   ESZ|(1u<<ucp_gbV)|(1u<<ucp_gbT),                     /*  7 V */
   ESZ|(1u<<ucp_gbT),                                   /*  8 T */
   ESZ|(1u<<ucp_gbV)|(1u<<ucp_gbT),                     /*  9 LV */
   ESZ|(1u<<ucp_gbT),                                   /* 10 LVT */
   (1u<<ucp_gbRegional_Indicator),                      /* 11 Regional Indicator */
   ESZ,                                                 /* 12 Other */
   ESZ|(1u<<ucp_gbExtended_Pictographic),               /* 13 ZWJ */
   ESZ                                                  /* 14 Extended Pictographic */
};

#undef ESZ

#ifdef SUPPORT_JIT
/* This table reverses PRIV(ucp_gentype). We can save the cost
of a memory load. */

const int PRIV(ucp_typerange)[] = {
  ucp_Cc, ucp_Cs,
  ucp_Ll, ucp_Lu,
  ucp_Mc, ucp_Mn,
  ucp_Nd, ucp_No,
  ucp_Pc, ucp_Ps,
  ucp_Sc, ucp_So,
  ucp_Zl, ucp_Zs,
};
#endif /* SUPPORT_JIT */

/* Finally, include the tables that are auto-generated from the Unicode data
files. */

#include "pcre2_ucptables.c"

#endif /* SUPPORT_UNICODE */

/* End of pcre2_tables.c */


================================================
FILE: Libraries/PCRE/pcre2_ucd.c
================================================
/*************************************************
*      Perl-Compatible Regular Expressions       *
*************************************************/

/* PCRE is a library of functions to support regular expressions whose syntax
and semantics are as close as possible to those of the Perl 5 language.

                       Written by Philip Hazel
     Original API code Copyright (c) 1997-2012 University of Cambridge
          New API code Copyright (c) 2016-2022 University of Cambridge

This module is auto-generated from Unicode data files. DO NOT EDIT MANUALLY!
Instead, modify the maint/GenerateUcd.py script and run it to generate
a new version of this code.

-----------------------------------------------------------------------------
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

    * Redistributions of source code must retain the above copyright notice,
      this list of conditions and the following disclaimer.

    * Redistributions in binary form must reproduce the above copyright
      notice, this list of conditions and the following disclaimer in the
      documentation and/or other materials provided with the distribution.

    * Neither the name of the University of Cambridge nor the names of its
      contributors may be used to endorse or promote products derived from
      this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
-----------------------------------------------------------------------------
*/

/* This file contains tables of Unicode properties that are extracted from
Unicode data files. See the comments at the start of maint/GenerateUcd.py for
details.

As well as being part of the PCRE2 library, this file is #included by the
pcre2test program, which redefines the PRIV macro to change table names from
_pcre2_xxx to xxxx, thereby avoiding name clashes with the library. At present,
just one of these tables is actually needed. When compiling the library, some
headers are needed. */

#ifndef PCRE2_PCRE2TEST
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "pcre2_internal.h"
#endif /* PCRE2_PCRE2TEST */

/* The tables herein are needed only when UCP support is built, and in PCRE2
that happens automatically with UTF support. This module should not be
referenced otherwise, so it should not matter whether it is compiled or not.
However a comment was received about space saving - maybe the guy linked all
the modules rather than using a library - so we include a condition to cut out
the tables when not needed. But don't leave a totally empty module because some
compilers barf at that. Instead, just supply some small dummy tables. */

#ifndef SUPPORT_UNICODE
const ucd_record PRIV(ucd_records)[] = {{0,0,0,0,0,0,0}};
const uint16_t PRIV(ucd_stage1)[] = {0};
const uint16_t PRIV(ucd_stage2)[] = {0};
const uint32_t PRIV(ucd_caseless_sets)[] = {0};
const uint32_t PRIV(ucd_nocase_ranges)[] = {0};
const uint32_t PRIV(ucd_nocase_ranges_size) = 0;
#else

/* Total size: 116564 bytes, block size: 128. */

const char *PRIV(unicode_version) = "16.0.0";

/* When recompiling tables with a new Unicode version, please check the types
in this structure definition with those in pcre2_internal.h (the actual field
names will be different).

typedef struct {
uint8_t property_0;
uint8_t property_1;
uint8_t property_2;
uint8_t property_3;
int32_t property_4;
uint16_t property_5;
uint16_t property_6;
} ucd_record;
*/

/* If the 32-bit library is run in non-32-bit mode, character values greater
than 0x10ffff may be encountered. For these we set up a special record. */

#if PCRE2_CODE_UNIT_WIDTH == 32
const ucd_record PRIV(dummy_ucd_record)[] = {{
  ucp_Unknown,    /* script */
  ucp_Cn,         /* type unassigned */
  ucp_gbOther,    /* grapheme break property */
  0,              /* case set */
  0,              /* other case */
  0 | (ucp_bidiL << UCD_BIDICLASS_SHIFT), /* script extension and bidi class */
  0,              /* bool properties offset */
  }};
#endif

/* This table contains lists of characters that are caseless sets of
more than one character. Each list is terminated by NOTACHAR. */

const uint32_t PRIV(ucd_caseless_sets)[] = {
  NOTACHAR,
  0x0053,  0x0073,  0x017f,  NOTACHAR,
  0x01c4,  0x01c5,  0x01c6,  NOTACHAR,
  0x01c7,  0x01c8,  0x01c9,  NOTACHAR,
  0x01ca,  0x01cb,  0x01cc,  NOTACHAR,
  0x01f1,  0x01f2,  0x01f3,  NOTACHAR,
  0x0345,  0x0399,  0x03b9,  0x1fbe,  NOTACHAR,
  0x00b5,  0x039c,  0x03bc,  NOTACHAR,
  0x03a3,  0x03c2,  0x03c3,  NOTACHAR,
  0x0392,  0x03b2,  0x03d0,  NOTACHAR,
  0x0398,  0x03b8,  0x03d1,  0x03f4,  NOTACHAR,
  0x03a6,  0x03c6,  0x03d5,  NOTACHAR,
  0x03a0,  0x03c0,  0x03d6,  NOTACHAR,
  0x039a,  0x03ba,  0x03f0,  NOTACHAR,
  0x03a1,  0x03c1,  0x03f1,  NOTACHAR,
  0x0395,  0x03b5,  0x03f5,  NOTACHAR,
  0x0412,  0x0432,  0x1c80,  NOTACHAR,
  0x0414,  0x0434,  0x1c81,  NOTACHAR,
  0x041e,  0x043e,  0x1c82,  NOTACHAR,
  0x0421,  0x0441,  0x1c83,  NOTACHAR,
  0x0422,  0x0442,  0x1c84,  0x1c85,  NOTACHAR,
  0x042a,  0x044a,  0x1c86,  NOTACHAR,
  0x0462,  0x0463,  0x1c87,  NOTACHAR,
  0x1e60,  0x1e61,  0x1e9b,  NOTACHAR,
  0x03a9,  0x03c9,  0x2126,  NOTACHAR,
  0x004b,  0x006b,  0x212a,  NOTACHAR,
  0x00c5,  0x00e5,  0x212b,  NOTACHAR,
  0x1c88,  0xa64a,  0xa64b,  NOTACHAR,
  0x0069,  0x0130,  NOTACHAR,
  0x0049,  0x0131,  NOTACHAR,
};

/* This is the index, within ucd_caseless_sets, of the additional
Turkish case-equivalences. The dotted I ones are this offset; the
dotless I are +3 from here. */

const uint32_t PRIV(ucd_turkish_dotted_i_caseset) = 112;

/* When #included in pcre2test, we don't need the table of digit sets, nor the
the large main UCD tables. */

#ifndef PCRE2_PCRE2TEST

/* This table contains character ranges, where the characters in the range have
no other case. Both start and end values are excluded from the range. */

const uint32_t PRIV(ucd_nocase_ranges)[] = {
  0x0000, 0x0041, /* 64 */
  0x007a, 0x00b5, /* 58 */
  0x00b5, 0x00c0, /* 10 */
  0x0292, 0x029d, /* 10 */
  0x029e, 0x0345, /* 166 */
  0x0345, 0x0370, /* 42 */
  0x0481, 0x048a, /* 8 */
  0x0556, 0x0561, /* 10 */
  0x0586, 0x10a0, /* 2841 */
  0x10ff, 0x13a0, /* 672 */
  0x13fd, 0x1c80, /* 2178 */
  0x1cbf, 0x1d79, /* 185 */
  0x1d7d, 0x1d8e, /* 16 */
  0x1d8e, 0x1e00, /* 113 */
  0x1ffc, 0x2126, /* 297 */
  0x2132, 0x214e, /* 27 */
  0x214e, 0x2160, /* 17 */
  0x2184, 0x24b6, /* 817 */
  0x24e9, 0x2c00, /* 1814 */
  0x2cf3, 0x2d00, /* 12 */
  0x2d2d, 0xa640, /* 30994 */
  0xa66d, 0xa680, /* 18 */
  0xa69b, 0xa722, /* 134 */
  0xa76f, 0xa779, /* 9 */
  0xa7dc, 0xa7f5, /* 24 */
  0xa7f6, 0xab53, /* 860 */
  0xab53, 0xab70, /* 28 */
  0xabbf, 0xfb05, /* 20293 */
  0xfb06, 0xff21, /* 1050 */
  0xff5a, 0x10400, /* 1189 */
  0x1044f, 0x104b0, /* 96 */
  0x104fb, 0x10570, /* 116 */
  0x105bc, 0x10c80, /* 1731 */
  0x10cb2, 0x10cc0, /* 13 */
  0x10cf2, 0x10d50, /* 93 */
  0x10d65, 0x10d70, /* 10 */
  0x10d85, 0x118a0, /* 2842 */
  0x118df, 0x16e40, /* 21856 */
  0x16e7f, 0x1e900, /* 31360 */
  0x1e943, 0x110000, /* 988860 */
  0xffffffff, 0xffffffff /* terminator */
};

/* Total: 1110933 characters. */
const uint32_t PRIV(ucd_nocase_ranges_size) = 80;

/* This table lists the code points for the '9' characters in each set of
decimal digits. It is used to ensure that all the digits in a script run come
from the same set. */

const uint32_t PRIV(ucd_digit_sets)[] = {
  76,  /* Number of subsequent values */
  0x00039, 0x00669, 0x006f9, 0x007c9, 0x0096f, 0x009ef, 0x00a6f, 0x00aef,
  0x00b6f, 0x00bef, 0x00c6f, 0x00cef, 0x00d6f, 0x00def, 0x00e59, 0x00ed9,
  0x00f29, 0x01049, 0x01099, 0x017e9, 0x01819, 0x0194f, 0x019d9, 0x01a89,
  0x01a99, 0x01b59, 0x01bb9, 0x01c49, 0x01c59, 0x0a629, 0x0a8d9, 0x0a909,
  0x0a9d9, 0x0a9f9, 0x0aa59, 0x0abf9, 0x0ff19, 0x104a9, 0x10d39, 0x10d49,
  0x1106f, 0x110f9, 0x1113f, 0x111d9, 0x112f9, 0x11459, 0x114d9, 0x11659,
  0x116c9, 0x116d9, 0x116e3, 0x11739, 0x118e9, 0x11959, 0x11bf9, 0x11c59,
  0x11d59, 0x11da9, 0x11f59, 0x16139, 0x16a69, 0x16ac9, 0x16b59, 0x16d79,
  0x1ccf9, 0x1d7d7, 0x1d7e1, 0x1d7eb, 0x1d7f5, 0x1d7ff, 0x1e149, 0x1e2f9,
  0x1e4f9, 0x1e5fa, 0x1e959, 0x1fbf9,
};

/* This vector is a list of script bitsets for the Script Extension property.
The number of 32-bit words in each bitset is #defined in pcre2_ucp.h as
ucd_script_sets_item_size. */

const uint32_t PRIV(ucd_script_sets)[] = {
 0x00000000u, 0x00000000u, 0x00000000u, 0x00000000u,
 0x40200003u, 0x00381901u, 0x00100246u, 0x00000000u,
 0x00040305u, 0x00800000u, 0x08000000u, 0x00000000u,
 0x20000001u, 0x00000000u, 0x00000000u, 0x00000000u,
 0x00000001u, 0x00800000u, 0x00000000u, 0x00000000u,
 0x00040001u, 0x00000000u, 0x00000000u, 0x00000000u,
 0x01000007u, 0x00000840u, 0x80000200u, 0x00000000u,
 0x01000007u, 0x00000040u, 0x80010000u, 0x00000001u,
 0x01000005u, 0x00002000u, 0x00000000u, 0x00000000u,
 0x00040041u, 0x00001000u, 0x80000000u, 0x00000000u,
 0x01000047u, 0x00002801u, 0x00010001u, 0x00000001u,
 0x10000001u, 0x00001801u, 0x00000004u, 0x00000000u,
 0x00000007u, 0x00000000u, 0x00000200u, 0x00000000u,
 0x00000051u, 0x00002840u, 0x00000202u, 0x00000001u,
 0x0000005fu, 0x00000041u, 0x00000202u, 0x00000000u,
 0x00000001u, 0x00002000u, 0x00000000u, 0x00000000u,
 0x00000041u, 0x00000000u, 0x00000002u, 0x00000000u,
 0x01000005u, 0x00000000u, 0x00010000u, 0x00000000u,
 0x01000001u, 0x00000040u, 0x00000000u, 0x00000000u,
 0x00000001u, 0x00000000u, 0x80000000u, 0x00000000u,
 0x00800001u, 0x00000000u, 0x00000000u, 0x00000000u,
 0x00000005u, 0x00000000u, 0x00000000u, 0x00000001u,
 0x00000003u, 0x00000000u, 0x00000200u, 0x00000001u,
 0x00000041u, 0x00000000u, 0x00000000u, 0x00000000u,
 0x11000041u, 0x00000000u, 0x00000002u, 0x00000000u,
 0x01000041u, 0x00000000u, 0x00000002u, 0x00000000u,
 0x00000041u, 0x00000000u, 0x80000000u, 0x00000000u,
 0x01000041u, 0x00000000u, 0x00000000u, 0x00000000u,
 0x01040001u, 0x00000001u, 0x80000001u, 0x00000000u,
 0x00000002u, 0x00000000u, 0x00000000u, 0x00000000u,
 0x00000001u, 0x00000000u, 0x00010000u, 0x00000000u,
 0x00000001u, 0x00000000u, 0x00000001u, 0x00000001u,
 0x00000001u, 0x00000000u, 0x00000000u, 0x00000000u,
 0x00000002u, 0x00000800u, 0x00000000u, 0x00000000u,
 0x00000004u, 0x00000000u, 0x00000200u, 0x00000000u,
 0x00000004u, 0x00001000u, 0x00000000u, 0x00000000u,
 0x00000005u, 0x00000000u, 0x00000000u, 0x00000000u,
 0x00200008u, 0x00001000u, 0x00000000u, 0x00000000u,
 0x000000e0u, 0x00010000u, 0x11200000u, 0x00000000u,
 0x000000e0u, 0x00000000u, 0x00000000u, 0x00000000u,
 0x000000e0u, 0x00010000u, 0x11208000u, 0x00000000u,
 0x00000060u, 0x08000000u, 0x04608480u, 0x00000000u,
 0x00000060u, 0x00000000u, 0x00000000u, 0x00000000u,
 0x000000a0u, 0x00000000u, 0x01000000u, 0x00000000u,
 0x00000020u, 0x00000000u, 0x00200000u, 0x00000000u,
 0x0001ff01u, 0x40000000u, 0x00001008u, 0x00000000u,
 0x0001ff01u, 0x00000000u, 0x00001008u, 0x00000000u,
 0x0003ff00u, 0x80004000u, 0x409c1848u, 0x00000000u,
 0x0003ff00u, 0x80004020u, 0x609c1848u, 0x00000000u,
 0x00000100u, 0x04000000u, 0x00080040u, 0x00000000u,
 0x00000200u, 0x10004000u, 0x00000000u, 0x00000000u,
 0x00000400u, 0x00000000u, 0x00002000u, 0x00000000u,
 0x00000800u, 0x00000000u, 0x00000010u, 0x00000000u,
 0x00002000u, 0x00000000u, 0x00000008u, 0x00000000u,
 0x00008000u, 0x00000000u, 0x00800000u, 0x00000002u,
 0x00100000u, 0x10000040u, 0x00000000u, 0x00000000u,
 0x00200001u, 0x00001000u, 0x00000000u, 0x00000000u,
 0x02000000u, 0x00000000u, 0x00000000u, 0x00000000u,
 0x00000000u, 0x0000001eu, 0x00000000u, 0x00000000u,
 0x04000000u, 0x00008000u, 0x00000000u, 0x00000000u,
 0x00008300u, 0x00000000u, 0x00000008u, 0x00000000u,
 0x00000100u, 0x00000000u, 0x00000000u, 0x00000000u,
 0x00008100u, 0x00000000u, 0x00000008u, 0x00000000u,
 0x00000300u, 0x00000000u, 0x00000000u, 0x00000000u,
 0x00000100u, 0x40000000u, 0x00000000u, 0x00000000u,
 0x0001f100u, 0x00000000u, 0x00000000u, 0x00000000u,
 0x00000100u, 0x00000000u, 0x00800000u, 0x00000000u,
 0x0003d300u, 0x00000000u, 0x00801008u, 0x00000002u,
 0x00000100u, 0x00000000u, 0x00000008u, 0x00000000u,
 0x00008100u, 0x00000000u, 0x00000008u, 0x00000002u,
 0x00000200u, 0x00000000u, 0x00000000u, 0x00000000u,
 0x00000000u, 0x00000000u, 0x00800000u, 0x00000000u,
 0x00000045u, 0x00000000u, 0x00000000u, 0x00000000u,
 0x00000040u, 0x00000000u, 0x00000000u, 0x00000000u,
 0x04000001u, 0x00008000u, 0x00000000u, 0x00000000u,
 0x00000020u, 0x00000000u, 0x00008000u, 0x00000000u,
 0x00200000u, 0x020c1000u, 0x00004000u, 0x00000000u,
 0x00000002u, 0x20080000u, 0x00004000u, 0x00000000u,
 0x00000101u, 0x00000000u, 0x00000008u, 0x00000000u,
 0x00000001u, 0x00000800u, 0x00000000u, 0x00000000u,
 0x00000000u, 0x02200000u, 0x00000000u, 0x00000000u,
 0x00200000u, 0x04780000u, 0x00004000u, 0x00000000u,
 0x00000000u, 0x00000000u, 0x00000002u, 0x00000000u,
 0x00000020u, 0x00000000u, 0x0000c000u, 0x00000000u,
 0x40000000u, 0x00000000u, 0x00020000u, 0x00000000u,
 0xfc400000u, 0x00000000u, 0x00000000u, 0x00000000u,
 0xfc400000u, 0x00008000u, 0x00000000u, 0x00000000u,
 0x78400000u, 0x00000000u, 0x00000000u, 0x00000000u,
 0x40000000u, 0x00000000u, 0x00000000u, 0x00000000u,
 0xfc480000u, 0x00000000u, 0x00000000u, 0x00000000u,
 0xfc480000u, 0x00800000u, 0x00000000u, 0x00000000u,
 0xf8400000u, 0x00000000u, 0x00000000u, 0x00000000u,
 0x60000000u, 0x00000000u, 0x00000000u, 0x00000000u,
 0x18000000u, 0x00000000u, 0x00000000u, 0x00000000u,
 0x58000000u, 0x00000000u, 0x00000000u, 0x00000000u,
 0x40000001u, 0x00000000u, 0x00000000u, 0x00000000u,
 0x00018d00u, 0xc4000000u, 0x00881950u, 0x00000002u,
 0x00008d00u, 0xc4000000u, 0x00881950u, 0x00000002u,
 0x00000d00u, 0x84000000u, 0x00081950u, 0x00000000u,
 0x00000d00u, 0xc4000000u, 0x00081950u, 0x00000000u,
 0x00000300u, 0x00000000u, 0x00000000u, 0x00000002u,
 0x00002100u, 0x00000000u, 0x00000000u, 0x00000000u,
 0x00100001u, 0x00020000u, 0x00000000u, 0x00000000u,
 0x00000000u, 0x01000400u, 0x00000000u, 0x00000000u,
 0x00000020u, 0x00010000u, 0x00000000u, 0x00000000u,
 0x000000a0u, 0x00000000u, 0x00000000u, 0x00000000u,
 0x00000000u, 0x00000280u, 0x02000000u, 0x00000000u,
 0x00000000u, 0x00000280u, 0x00000000u, 0x00000000u,
 0x00000000u, 0x00000280u, 0x00000020u, 0x00000000u,
 0x00000020u, 0x00000800u, 0x00000000u, 0x00000000u,
 0x00000000u, 0x00000000u, 0x04000080u, 0x00000000u,
};

/* This vector is a list of bitsets for Boolean properties. The number of
32_bit words in each bitset is #defined as ucd_boolprop_sets_item_size in
pcre2_ucp.h. */

const uint32_t PRIV(ucd_boolprop_sets)[] = {
 0x00000000u, 0x00000000u,
 0x00000001u, 0x00000000u,
 0x00000001u, 0x00400800u,
 0x00800001u, 0x00400800u,
 0x00800001u, 0x00050400u,
 0x00800001u, 0x00002400u,
 0x00830001u, 0x00000400u,
 0x00800001u, 0x00000400u,
 0x00800021u, 0x00002400u,
 0x00800011u, 0x00000400u,
 0x00800001u, 0x00000480u,
 0x00800001u, 0x00040400u,
 0x00801001u, 0x00000400u,
 0x00800021u, 0x00050400u,
 0x04830003u, 0x00800001u,
 0x00800021u, 0x00040400u,
 0x00800011u, 0x00000480u,
 0x048003c7u, 0x01900003u,
 0x008003c5u, 0x01900003u,
 0x00808021u, 0x00000480u,
 0x00800001u, 0x00800001u,
 0x00808021u, 0x00000400u,
 0x04800d47u, 0x01800043u,
 0x00800d45u, 0x01800043u,
 0x00800d45u, 0x01820043u,
 0x00000000u, 0x00400800u,
 0x00800000u, 0x00400000u,
 0x00800000u, 0x00000400u,
 0x00808020u, 0x00000000u,
 0x00a10000u, 0x00000400u,
 0x00800044u, 0x01800043u,
 0x00800010u, 0x00002400u,
 0x00800000u, 0x00000480u,
 0x00002020u, 0x00000000u,
 0x40800000u, 0x00000000u,
 0x00800dc4u, 0x01800043u,
 0x00c08020u, 0x00800001u,
 0x00800000u, 0x00000000u,
 0x008003c4u, 0x01900003u,
 0x00800d44u, 0x01800043u,
 0x00800d44u, 0x01820043u,
 0x00804dc4u, 0x01800043u,
 0x00800004u, 0x01800003u,
 0x008007c4u, 0x01900003u,
 0x00800bc4u, 0x01800003u,
 0x00808064u, 0x01800043u,
 0x00808064u, 0x01820043u,
 0x00808024u, 0x01800003u,
 0x00c08024u, 0x01800003u,
 0x01008020u, 0x00800009u,
 0x01008de4u, 0x00800049u,
 0x01002020u, 0x00800009u,
 0x01000020u, 0x00800009u,
 0x01000024u, 0x00800009u,
 0x00808064u, 0x00000043u,
 0x00800000u, 0x00040000u,
 0x00800020u, 0x00840001u,
 0x00800dc4u, 0x018000c3u,
 0x00800044u, 0x01900083u,
 0x00800044u, 0x01900003u,
 0x008003c4u, 0x01900083u,
 0x00800000u, 0x00000080u,
 0x01000020u, 0x00000008u,
 0x00800020u, 0x00000000u,
 0x00800000u, 0x00050000u,
 0x00801000u, 0x00000000u,
 0x01008024u, 0x00800009u,
 0x00000020u, 0x00001000u,
 0x00002028u, 0x00000000u,
 0x00c00024u, 0x01800003u,
 0x01000024u, 0x00800109u,
 0x01008020u, 0x00800109u,
 0x00800000u, 0x00800001u,
 0x00804004u, 0x01800003u,
 0x00800024u, 0x01800003u,
 0x01000020u, 0x00800109u,
 0x01008024u, 0x00800109u,
 0x00800004u, 0x00800001u,
 0x00800004u, 0x0180000bu,
 0x03008020u, 0x00800009u,
 0x01000004u, 0x00800009u,
 0x01400024u, 0x00800009u,
 0x01408020u, 0x00800009u,
 0x00800004u, 0x00800003u,
 0x03008024u, 0x00800009u,
 0x00800004u, 0x01800023u,
 0x00800010u, 0x00000000u,
 0x00808000u, 0x00800001u,
 0x01004024u, 0x00800009u,
 0x00808004u, 0x00800001u,
 0x00800944u, 0x01800043u,
 0x00800064u, 0x01800043u,
 0x00802004u, 0x01800003u,
 0x00800344u, 0x01900003u,
 0x03008000u, 0x00800009u,
 0x00c00000u, 0x00000000u,
 0x01002020u, 0x00a00009u,
 0x01000024u, 0x0180000bu,
 0x01008020u, 0x00000008u,
 0x01408024u, 0x00800009u,
 0x00808000u, 0x00000000u,
 0x00800044u, 0x01820043u,
 0x00800064u, 0x01820043u,
 0x01002020u, 0x00800011u,
 0x00022020u, 0x00800019u,
 0x00002028u, 0x00000800u,
 0x00801000u, 0x00000400u,
 0x00800020u, 0x00002400u,
 0x00800000u, 0x00002400u,
 0x00800020u, 0x00050400u,
 0x00800020u, 0x00000400u,
 0x00a10000u, 0x00050400u,
 0x00800000u, 0x00050400u,
 0x00800000u, 0x00800081u,
 0x00800010u, 0x00000400u,
 0x00002020u, 0x00000080u,
 0x00002000u, 0x00000000u,
 0x00006020u, 0x00000000u,
 0x40800000u, 0x00000080u,
 0x40801000u, 0x00000080u,
 0x40800010u, 0x00000080u,
 0x01000020u, 0x00800089u,
 0x01020020u, 0x00000008u,
 0x00800044u, 0x018000c3u,
 0x00800000u, 0x01800083u,
 0x00a10000u, 0x00000000u,
 0x00800000u, 0x01800003u,
 0x00800004u, 0x01800083u,
 0x00a10044u, 0x01800043u,
 0x00800044u, 0x018200c3u,
 0x00a10000u, 0x00000480u,
 0xc0800000u, 0x00000480u,
 0x00800010u, 0x00000480u,
 0x00801000u, 0x00000480u,
 0x00b10000u, 0x00000400u,
 0x00804010u, 0x00000400u,
 0x00a00000u, 0x00000400u,
 0x00000000u, 0x00000400u,
 0x008003c4u, 0x00100000u,
 0x00a103c4u, 0x00100000u,
 0x00800d44u, 0x00000040u,
 0x00b10000u, 0x00000480u,
 0x00a00000u, 0x00000480u,
 0x00a90000u, 0x00000400u,
 0x00b90000u, 0x00000400u,
 0x03000020u, 0x00800009u,
 0x00808024u, 0x00000400u,
 0x00800000u, 0x00040400u,
 0x00800000u, 0x00004000u,
 0x08800000u, 0x00000000u,
 0x10800000u, 0x00000000u,
 0x20800000u, 0x00000000u,
 0x00800004u, 0x01800007u,
 0x01008000u, 0x00800009u,
 0x00a11000u, 0x00000400u,
 0x00808020u, 0x00000003u,
 0x00800004u, 0x01880007u,
 0x00808004u, 0x01800003u,
 0x00800004u, 0x00000003u,
 0x00000000u, 0x00000200u,
 0x01022020u, 0x00a00009u,
 0x00800000u, 0x00002000u,
 0x00800020u, 0x00050000u,
 0x00800020u, 0x00040000u,
 0x00801000u, 0x00000080u,
 0x00800010u, 0x00000080u,
 0x00800020u, 0x00002000u,
 0x04800000u, 0x00800001u,
 0x048003c4u, 0x01900003u,
 0x00808020u, 0x00000080u,
 0x04800d44u, 0x01800043u,
 0x00800010u, 0x00002000u,
 0x01008024u, 0x0080000bu,
 0x00000020u, 0x00000000u,
 0x00c00004u, 0x01800003u,
 0x00c08004u, 0x01800003u,
 0x01400020u, 0x00800009u,
 0x01000020u, 0x0080000du,
 0x01008004u, 0x00800009u,
 0x01000000u, 0x00800009u,
 0xc0800000u, 0x00000080u,
 0x00a00000u, 0x00000000u,
 0x00b10000u, 0x00000000u,
 0x00200000u, 0x00000000u,
 0x00800044u, 0x00100000u,
 0x00a10044u, 0x00100000u,
 0x00930000u, 0x00008000u,
 0x00b90000u, 0x00000000u,
 0x00a90000u, 0x00000000u,
 0x00970020u, 0x00000008u,
 0x00b30000u, 0x00000000u,
 0x01022020u, 0x00000008u,
};

/* These are the main two-stage UCD tables. The fields in each record are:
script (8 bits), character type (8 bits), grapheme break property (8 bits),
offset to multichar other cases or zero (8 bits), offset to other case or zero
(32 bits, signed), bidi class (5 bits) and script extension (11 bits) packed
into a 16-bit field, and offset in binary properties table (16 bits). */

const ucd_record PRIV(ucd_records)[] = { /* 18516 bytes, record size 12 */
  {    99,      0,      2,      0,      0,   6144,      2, }, /*   0 */
  {    99,      0,      2,      0,      0,  43008,      4, }, /*   1 */
  {    99,      0,      1,      0,      0,   4096,      4, }, /*   2 */
  {    99,      0,      2,      0,      0,  45056,      4, }, /*   3 */
  {    99,      0,      0,      0,      0,   4096,      4, }, /*   4 */
  {    99,      0,      2,      0,      0,   4096,      2, }, /*   5 */
  {    99,      0,      2,      0,      0,  43008,      2, }, /*   6 */
  {    99,     29,     12,      0,      0,  45056,      6, }, /*   7 */
  {    99,     21,     12,      0,      0,  28672,      8, }, /*   8 */
  {    99,     21,     12,      0,      0,  28672,     10, }, /*   9 */
  {    99,     21,     12,      0,      0,  14336,     12, }, /*  10 */
  {    99,     23,     12,      0,      0,  14336,     14, }, /*  11 */
  {    99,     21,     12,      0,      0,  14336,     14, }, /*  12 */
  {    99,     21,     12,      0,      0,  28672,     14, }, /*  13 */
  {    99,     21,     12,      0,      0,  28672,     16, }, /*  14 */
  {    99,     22,     12,      0,      0,  28672,     18, }, /*  15 */
  {    99,     18,     12,      0,      0,  28672,     18, }, /*  16 */
  {    99,     21,     12,      0,      0,  28672,     12, }, /*  17 */
  {    99,     25,     12,      0,      0,  12288,     20, }, /*  18 */
  {    99,     21,     12,      0,      0,   8192,     22, }, /*  19 */
  {    99,     17,     12,      0,      0,  12288,     24, }, /*  20 */
  {    99,     21,     12,      0,      0,   8192,     26, }, /*  21 */
  {    99,     21,     12,      0,      0,   8192,     14, }, /*  22 */
  {    99,     13,     12,      0,      0,  10240,     28, }, /*  23 */
  {    99,     21,     12,      0,      0,   8192,     30, }, /*  24 */
  {    99,     21,     12,      0,      0,  28672,     22, }, /*  25 */
  {    99,     25,     12,      0,      0,  28672,     32, }, /*  26 */
  {    99,     25,     12,      0,      0,  28672,     20, }, /*  27 */
  {     0,      9,     12,      0,     32,  18432,     34, }, /*  28 */
  {     0,      9,     12,      0,     32,  18432,     36, }, /*  29 */
  {     0,      9,     12,    100,     32,  18432,     36, }, /*  30 */
  {     0,      9,     12,      1,     32,  18432,     36, }, /*  31 */
  {    99,     24,     12,      0,      0,  28672,     38, }, /*  32 */
  {    99,     16,     12,      0,      0,  28672,     40, }, /*  33 */
  {    99,     24,     12,      0,      0,  28672,     42, }, /*  34 */
  {     0,      5,     12,      0,    -32,  18432,     44, }, /*  35 */
  {     0,      5,     12,      0,    -32,  18432,     46, }, /*  36 */
  {     0,      5,     12,      0,    -32,  18432,     48, }, /*  37 */
  {     0,      5,     12,    100,    -32,  18432,     46, }, /*  38 */
  {     0,      5,     12,      1,    -32,  18432,     46, }, /*  39 */
  {    99,      0,      2,      0,      0,   6144,      0, }, /*  40 */
  {    99,      0,      2,      0,      0,   4096,     50, }, /*  41 */
  {    99,     29,     12,      0,      0,   8192,     52, }, /*  42 */
  {    99,     21,     12,      0,      0,  28672,     54, }, /*  43 */
  {    99,     23,     12,      0,      0,  14336,     54, }, /*  44 */
  {    99,     26,     12,      0,      0,  28672,     54, }, /*  45 */
  {    99,     24,     12,      0,      0,  28672,     56, }, /*  46 */
  {    99,     26,     14,      0,      0,  28672,     58, }, /*  47 */
  {     0,      7,     12,      0,      0,  18432,     60, }, /*  48 */
  {    99,     20,     12,      0,      0,  28672,     62, }, /*  49 */
  {    99,     25,     12,      0,      0,  28672,     64, }, /*  50 */
  {    99,      1,      2,      0,      0,   6144,     66, }, /*  51 */
  {    99,     26,     12,      0,      0,  14336,     54, }, /*  52 */
  {    99,     25,     12,      0,      0,  14336,     64, }, /*  53 */
  {    99,     15,     12,      0,      0,  10240,     68, }, /*  54 */
  {    99,      5,     12,     26,    775,  18432,     70, }, /*  55 */
  {    99,     21,     12,      0,      0,  28676,     72, }, /*  56 */
  {    99,     19,     12,      0,      0,  28672,     62, }, /*  57 */
  {    99,     15,     12,      0,      0,  28672,     74, }, /*  58 */
  {     0,      9,     12,      0,     32,  18432,     76, }, /*  59 */
  {     0,      9,     12,    104,     32,  18432,     76, }, /*  60 */
  {     0,      5,     12,      0,   7615,  18432,     70, }, /*  61 */
  {     0,      5,     12,      0,    -32,  18432,     78, }, /*  62 */
  {     0,      5,     12,    104,    -32,  18432,     78, }, /*  63 */
  {     0,      5,     12,      0,    121,  18432,     78, }, /*  64 */
  {     0,      9,     12,      0,      1,  18432,     76, }, /*  65 */
  {     0,      5,     12,      0,     -1,  18432,     78, }, /*  66 */
  {     0,      5,     12,      0,     -1,  18432,     80, }, /*  67 */
  {     0,      9,     12,      0,      0,  18432,     76, }, /*  68 */
  {     0,      5,     12,      0,      0,  18432,     78, }, /*  69 */
  {     0,      5,     12,      0,      0,  18432,     60, }, /*  70 */
  {     0,      5,     12,      0,      0,  18432,     82, }, /*  71 */
  {     0,      9,     12,      0,   -121,  18432,     76, }, /*  72 */
  {     0,      5,     12,      1,      0,  18432,     70, }, /*  73 */
  {     0,      5,     12,      0,    195,  18432,     78, }, /*  74 */
  {     0,      9,     12,      0,    210,  18432,     76, }, /*  75 */
  {     0,      9,     12,      0,    206,  18432,     76, }, /*  76 */
  {     0,      9,     12,      0,    205,  18432,     76, }, /*  77 */
  {     0,      9,     12,      0,     79,  18432,     76, }, /*  78 */
  {     0,      9,     12,      0,    202,  18432,     76, }, /*  79 */
  {     0,      9,     12,      0,    203,  18432,     76, }, /*  80 */
  {     0,      9,     12,      0,    207,  18432,     76, }, /*  81 */
  {     0,      5,     12,      0,     97,  18432,     78, }, /*  82 */
  {     0,      9,     12,      0,    211,  18432,     76, }, /*  83 */
  {     0,      9,     12,      0,    209,  18432,     76, }, /*  84 */
  {     0,      5,     12,      0,    163,  18432,     78, }, /*  85 */
  {     0,      5,     12,      0,  42561,  18432,     78, }, /*  86 */
  {     0,      9,     12,      0,    213,  18432,     76, }, /*  87 */
  {     0,      5,     12,      0,    130,  18432,     78, }, /*  88 */
  {     0,      9,     12,      0,    214,  18432,     76, }, /*  89 */
  {     0,      9,     12,      0,    218,  18432,     76, }, /*  90 */
  {     0,      9,     12,      0,    217,  18432,     76, }, /*  91 */
  {     0,      9,     12,      0,    219,  18432,     76, }, /*  92 */
  {     0,      7,     12,      0,      0,  18432,     84, }, /*  93 */
  {     0,      5,     12,      0,     56,  18432,     78, }, /*  94 */
  {     0,      9,     12,      5,      2,  18432,     86, }, /*  95 */
  {     0,      8,     12,      5,      1,  18432,     88, }, /*  96 */
  {     0,      5,     12,      5,     -2,  18432,     78, }, /*  97 */
  {     0,      9,     12,      9,      2,  18432,     86, }, /*  98 */
  {     0,      8,     12,      9,      1,  18432,     88, }, /*  99 */
  {     0,      5,     12,      9,     -2,  18432,     78, }, /* 100 */
  {     0,      9,     12,     13,      2,  18432,     86, }, /* 101 */
  {     0,      8,     12,     13,      1,  18432,     88, }, /* 102 */
  {     0,      5,     12,     13,     -2,  18432,     78, }, /* 103 */
  {     0,      5,     12,      0,    -79,  18432,     78, }, /* 104 */
  {     0,      9,     12,     17,      2,  18432,     86, }, /* 105 */
  {     0,      8,     12,     17,      1,  18432,     88, }, /* 106 */
  {     0,      5,     12,     17,     -2,  18432,     78, }, /* 107 */
  {     0,      9,     12,      0,    -97,  18432,     76, }, /* 108 */
  {     0,      9,     12,      0,    -56,  18432,     76, }, /* 109 */
  {     0,      9,     12,      0,   -130,  18432,     76, }, /* 110 */
  {     0,      9,     12,      0,  10795,  18432,     76, }, /* 111 */
  {     0,      9,     12,      0,   -163,  18432,     76, }, /* 112 */
  {     0,      9,     12,      0,  10792,  18432,     76, }, /* 113 */
  {     0,      5,     12,      0,  10815,  18432,     78, }, /* 114 */
  {     0,      9,     12,      0,   -195,  18432,     76, }, /* 115 */
  {     0,      9,     12,      0,     69,  18432,     76, }, /* 116 */
  {     0,      9,     12,      0,     71,  18432,     76, }, /* 117 */
  {     0,      5,     12,      0,  10783,  18432,     78, }, /* 118 */
  {     0,      5,     12,      0,  10780,  18432,     78, }, /* 119 */
  {     0,      5,     12,      0,  10782,  18432,     78, }, /* 120 */
  {     0,      5,     12,      0,   -210,  18432,     78, }, /* 121 */
  {     0,      5,     12,      0,   -206,  18432,     78, }, /* 122 */
  {     0,      5,     12,      0,   -205,  18432,     78, }, /* 123 */
  {     0,      5,     12,      0,   -202,  18432,     78, }, /* 124 */
  {     0,      5,     12,      0,   -203,  18432,     78, }, /* 125 */
  {     0,      5,     12,      0,  42319,  18432,     78, }, /* 126 */
  {     0,      5,     12,      0,  42315,  18432,     78, }, /* 127 */
  {     0,      5,     12,      0,   -207,  18432,     78, }, /* 128 */
  {     0,      5,     12,      0,  42343,  18432,     78, }, /* 129 */
  {     0,      5,     12,      0,  42280,  18432,     78, }, /* 130 */
  {     0,      5,     12,      0,  42308,  18432,     78, }, /* 131 */
  {     0,      5,     12,      0,   -209,  18432,     80, }, /* 132 */
  {     0,      5,     12,      0,   -211,  18432,     78, }, /* 133 */
  {     0,      5,     12,      0,  10743,  18432,     78, }, /* 134 */
  {     0,      5,     12,      0,  42305,  18432,     78, }, /* 135 */
  {     0,      5,     12,      0,  10749,  18432,     78, }, /* 136 */
  {     0,      5,     12,      0,   -213,  18432,     78, }, /* 137 */
  {     0,      5,     12,      0,   -214,  18432,     78, }, /* 138 */
  {     0,      5,     12,      0,  10727,  18432,     78, }, /* 139 */
  {     0,      5,     12,      0,   -218,  18432,     78, }, /* 140 */
  {     0,      5,     12,      0,  42307,  18432,     78, }, /* 141 */
  {     0,      5,     12,      0,  42282,  18432,     78, }, /* 142 */
  {     0,      5,     12,      0,    -69,  18432,     78, }, /* 143 */
  {     0,      5,     12,      0,   -217,  18432,     78, }, /* 144 */
  {     0,      5,     12,      0,    -71,  18432,     78, }, /* 145 */
  {     0,      5,     12,      0,   -219,  18432,     78, }, /* 146 */
  {     0,      5,     12,      0,  42261,  18432,     80, }, /* 147 */
  {     0,      5,     12,      0,  42258,  18432,     78, }, /* 148 */
  {     0,      6,     12,      0,      0,  18432,     90, }, /* 149 */
  {     0,      6,     12,      0,      0,  18432,     92, }, /* 150 */
  {    99,      6,     12,      0,      0,  28672,     94, }, /* 151 */
  {    99,      6,     12,      0,      0,  18432,     94, }, /* 152 */
  {    99,      6,     12,      0,      0,  18440,     94, }, /* 153 */
  {    99,      6,     12,      0,      0,  18432,     90, }, /* 154 */
  {    99,      6,     12,      0,      0,  28684,     94, }, /* 155 */
  {    99,      6,     12,      0,      0,  28688,     94, }, /* 156 */
  {    99,      6,     12,      0,      0,  18432,     96, }, /* 157 */
  {    99,     24,     12,      0,      0,  28692,     56, }, /* 158 */
  {    99,     24,     12,      0,      0,  28684,     56, }, /* 159 */
  {    29,     24,     12,      0,      0,  28672,     56, }, /* 160 */
  {   106,     12,      3,      0,      0,  26648,     98, }, /* 161 */
  {   106,     12,      3,      0,      0,  26652,     98, }, /* 162 */
  {   106,     12,      3,      0,      0,  26656,     98, }, /* 163 */
  {   106,     12,      3,      0,      0,  26660,     98, }, /* 164 */
  {   106,     12,      3,      0,      0,  26664,     98, }, /* 165 */
  {   106,     12,      3,      0,      0,  26668,     98, }, /* 166 */
  {   106,     12,      3,      0,      0,  26672,     98, }, /* 167 */
  {   106,     12,      3,      0,      0,  26676,     98, }, /* 168 */
  {   106,     12,      3,      0,      0,  26680,     98, }, /* 169 */
  {   106,     12,      3,      0,      0,  26684,     98, }, /* 170 */
  {   106,     12,      3,      0,      0,  26688,     98, }, /* 171 */
  {   106,     12,      3,      0,      0,  26692,     98, }, /* 172 */
  {   106,     12,      3,      0,      0,  26696,     98, }, /* 173 */
  {   106,     12,      3,      0,      0,  26700,     98, }, /* 174 */
  {   106,     12,      3,      0,      0,  26704,     98, }, /* 175 */
  {   106,     12,      3,      0,      0,  26624,     98, }, /* 176 */
  {   106,     12,      3,      0,      0,  26708,     98, }, /* 177 */
  {   106,     12,      3,      0,      0,  26712,     98, }, /* 178 */
  {   106,     12,      3,      0,      0,  26716,     98, }, /* 179 */
  {   106,     12,      3,      0,      0,  26720,     98, }, /* 180 */
  {   106,     12,      3,      0,      0,  26724,     98, }, /* 181 */
  {   106,     12,      3,      0,      0,  26728,     98, }, /* 182 */
  {   106,     12,      3,      0,      0,  26732,     98, }, /* 183 */
  {   106,     12,      3,      0,      0,  26736,     98, }, /* 184 */
  {   106,     12,      3,      0,      0,  26740,     98, }, /* 185 */
  {   106,     12,      3,     21,    116,  26740,    100, }, /* 186 */
  {   106,     12,      3,      0,      0,  26624,    102, }, /* 187 */
  {   106,     12,      3,      0,      0,  26744,    104, }, /* 188 */
  {   106,     12,      3,      0,      0,  26624,    104, }, /* 189 */
  {   106,     12,      3,      0,      0,  26748,     98, }, /* 190 */
  {   106,     12,      3,      0,      0,  26752,    106, }, /* 191 */
  {     1,      9,     12,      0,      1,  18432,     76, }, /* 192 */
  {     1,      5,     12,      0,     -1,  18432,     78, }, /* 193 */
  {    99,      6,     12,      0,      0,  28804,     94, }, /* 194 */
  {     1,     24,     12,      0,      0,  28804,     56, }, /* 195 */
  {    98,      2,     12,      0,      0,  18432,      0, }, /* 196 */
  {     1,      6,     12,      0,      0,  18432,    108, }, /* 197 */
  {     1,      5,     12,      0,    130,  18432,     78, }, /* 198 */
  {    99,     21,     12,      0,      0,  28672,    110, }, /* 199 */
  {     1,      9,     12,      0,    116,  18432,     76, }, /* 200 */
  {     1,     24,     12,      0,      0,  28672,     56, }, /* 201 */
  {     1,      9,     12,      0,     38,  18432,     76, }, /* 202 */
  {    99,     21,     12,      0,      0,  28672,    112, }, /* 203 */
  {     1,      9,     12,      0,     37,  18432,     76, }, /* 204 */
  {     1,      9,     12,      0,     64,  18432,     76, }, /* 205 */
  {     1,      9,     12,      0,     63,  18432,     76, }, /* 206 */
  {     1,      5,     12,      0,   7235,  18432,     78, }, /* 207 */
  {     1,      9,     12,      0,     32,  18432,     76, }, /* 208 */
  {     1,      9,     12,     34,     32,  18432,     76, }, /* 209 */
  {     1,      9,     12,     59,     32,  18432,     76, }, /* 210 */
  {     1,      9,     12,     38,     32,  18432,     76, }, /* 211 */
  {     1,      9,     12,     21,     32,  18432,     76, }, /* 212 */
  {     1,      9,     12,     51,     32,  18432,     76, }, /* 213 */
  {     1,      9,     12,     26,     32,  18432,     76, }, /* 214 */
  {     1,      9,     12,     47,     32,  18432,     76, }, /* 215 */
  {     1,      9,     12,     55,     32,  18432,     76, }, /* 216 */
  {     1,      9,     12,     30,     32,  18432,     76, }, /* 217 */
  {     1,      9,     12,     43,     32,  18432,     76, }, /* 218 */
  {     1,      9,     12,     96,     32,  18432,     76, }, /* 219 */
  {     1,      5,     12,      0,    -38,  18432,     78, }, /* 220 */
  {     1,      5,     12,      0,    -37,  18432,     78, }, /* 221 */
  {     1,      5,     12,      0,   7219,  18432,     78, }, /* 222 */
  {     1,      5,     12,      0,    -32,  18432,     78, }, /* 223 */
  {     1,      5,     12,     34,    -32,  18432,     78, }, /* 224 */
  {     1,      5,     12,     59,    -32,  18432,     78, }, /* 225 */
  {     1,      5,     12,     38,    -32,  18432,     78, }, /* 226 */
  {     1,      5,     12,     21,   -116,  18432,     78, }, /* 227 */
  {     1,      5,     12,     51,    -32,  18432,     78, }, /* 228 */
  {     1,      5,     12,     26,   -775,  18432,     78, }, /* 229 */
  {     1,      5,     12,     47,    -32,  18432,     78, }, /* 230 */
  {     1,      5,     12,     55,    -32,  18432,     78, }, /* 231 */
  {     1,      5,     12,     30,      1,  18432,     70, }, /* 232 */
  {     1,      5,     12,     30,    -32,  18432,     78, }, /* 233 */
  {     1,      5,     12,     43,    -32,  18432,     78, }, /* 234 */
  {     1,      5,     12,     96,    -32,  18432,     78, }, /* 235 */
  {     1,      5,     12,      0,    -64,  18432,     78, }, /* 236 */
  {     1,      5,     12,      0,    -63,  18432,     78, }, /* 237 */
  {     1,      9,     12,      0,      8,  18432,     76, }, /* 238 */
  {     1,      5,     12,     34,    -30,  18432,    114, }, /* 239 */
  {     1,      5,     12,     38,    -25,  18432,    114, }, /* 240 */
  {     1,      9,     12,      0,      0,  18432,    116, }, /* 241 */
  {     1,      9,     12,      0,      0,  18432,    118, }, /* 242 */
  {     1,      5,     12,     43,    -15,  18432,    114, }, /* 243 */
  {     1,      5,     12,     47,    -22,  18432,     70, }, /* 244 */
  {     1,      5,     12,      0,     -8,  18432,     78, }, /* 245 */
  {    43,      9,     12,      0,      1,  18432,     76, }, /* 246 */
  {    43,      5,     12,      0,     -1,  18432,     78, }, /* 247 */
  {     1,      5,     12,     51,    -54,  18432,    114, }, /* 248 */
  {     1,      5,     12,     55,    -48,  18432,    114, }, /* 249 */
  {     1,      5,     12,      0,      7,  18432,     78, }, /* 250 */
  {     1,      5,     12,      0,   -116,  18432,     80, }, /* 251 */
  {     1,      9,     12,     38,    -60,  18432,    120, }, /* 252 */
  {     1,      5,     12,     59,    -64,  18432,    114, }, /* 253 */
  {     1,     25,     12,      0,      0,  28672,    122, }, /* 254 */
  {     1,      9,     12,      0,     -7,  18432,     76, }, /* 255 */
  {     1,      5,     12,      0,      0,  18432,     60, }, /* 256 */
  {     1,      9,     12,      0,   -130,  18432,     76, }, /* 257 */
  {     2,      9,     12,      0,     80,  18432,     76, }, /* 258 */
  {     2,      9,     12,      0,     32,  18432,     76, }, /* 259 */
  {     2,      9,     12,     63,     32,  18432,     76, }, /* 260 */
  {     2,      9,     12,     67,     32,  18432,     76, }, /* 261 */
  {     2,      9,     12,     71,     32,  18432,     76, }, /* 262 */
  {     2,      9,     12,     75,     32,  18432,     76, }, /* 263 */
  {     2,      9,     12,     79,     32,  18432,     76, }, /* 264 */
  {     2,      9,     12,     84,     32,  18432,     76, }, /* 265 */
  {     2,      5,     12,      0,    -32,  18432,     78, }, /* 266 */
  {     2,      5,     12,     63,    -32,  18432,     78, }, /* 267 */
  {     2,      5,     12,     67,    -32,  18432,     78, }, /* 268 */
  {     2,      5,     12,     71,    -32,  18432,     78, }, /* 269 */
  {     2,      5,     12,     75,    -32,  18432,     78, }, /* 270 */
  {     2,      5,     12,     79,    -32,  18432,     78, }, /* 271 */
  {     2,      5,     12,     84,    -32,  18432,     78, }, /* 272 */
  {     2,      5,     12,      0,    -80,  18432,     78, }, /* 273 */
  {     2,      5,     12,      0,    -80,  18432,     80, }, /* 274 */
  {     2,      9,     12,      0,      1,  18432,     76, }, /* 275 */
  {     2,      5,     12,      0,     -1,  18432,     78, }, /* 276 */
  {     2,      9,     12,     88,      1,  18432,     76, }, /* 277 */
  {     2,      5,     12,     88,     -1,  18432,     78, }, /* 278 */
  {     2,     26,     12,      0,      0,  18432,     74, }, /* 279 */
  {     2,     12,      3,      0,      0,  26760,     98, }, /* 280 */
  {     2,     12,      3,      0,      0,  26764,     98, }, /* 281 */
  {   106,     12,      3,      0,      0,  26768,     98, }, /* 282 */
  {     2,     11,      3,      0,      0,  26624,    124, }, /* 283 */
  {     2,      9,     12,      0,     15,  18432,     76, }, /* 284 */
  {     2,      5,     12,      0,    -15,  18432,     78, }, /* 285 */
  {     3,      9,     12,      0,     48,  18432,     76, }, /* 286 */
  {     3,      6,     12,      0,      0,  18432,     94, }, /* 287 */
  {     3,     21,     12,      0,      0,  18432,     74, }, /* 288 */
  {     3,     21,     12,      0,      0,  18432,    126, }, /* 289 */
  {     3,      5,     12,      0,      0,  18432,     60, }, /* 290 */
  {     3,      5,     12,      0,    -48,  18432,     78, }, /* 291 */
  {     3,      5,     12,      0,      0,  18432,     70, }, /* 292 */
  {     3,     21,     12,      0,      0,  18580,    128, }, /* 293 */
  {     3,     17,     12,      0,      0,  28672,    130, }, /* 294 */
  {     3,     26,     12,      0,      0,  28672,     74, }, /* 295 */
  {     3,     23,     12,      0,      0,  14336,     74, }, /* 296 */
  {    98,      2,     12,      0,      0,  34816,      0, }, /* 297 */
  {     4,     12,      3,      0,      0,  26624,     98, }, /* 298 */
  {     4,     12,      3,      0,      0,  26624,    104, }, /* 299 */
  {     4,     12,      3,      0,      0,  26624,    132, }, /* 300 */
  {     4,     17,     12,      0,      0,  34816,    130, }, /* 301 */
  {     4,     21,     12,      0,      0,  34816,     74, }, /* 302 */
  {     4,     21,     12,      0,      0,  34816,    110, }, /* 303 */
  {     4,     12,      3,      0,      0,  26624,    106, }, /* 304 */
  {     4,      7,     12,      0,      0,  34816,     84, }, /* 305 */
  {     4,     21,     12,      0,      0,  34816,    126, }, /* 306 */
  {     5,      1,      4,      0,      0,   2048,    134, }, /* 307 */
  {    99,      1,      4,      0,      0,   2048,    134, }, /* 308 */
  {     5,     25,     12,      0,      0,  28672,    122, }, /* 309 */
  {     5,     25,     12,      0,      0,      0,    122, }, /* 310 */
  {     5,     21,     12,      0,      0,  14336,     74, }, /* 311 */
  {     5,     23,     12,      0,      0,      0,     74, }, /* 312 */
  {    99,     21,     12,      0,      0,   8344,    110, }, /* 313 */
  {     5,     21,     12,      0,      0,      0,     74, }, /* 314 */
  {     5,     26,     12,      0,      0,  28672,     74, }, /* 315 */
  {     5,     12,      3,      0,      0,  26624,    106, }, /* 316 */
  {    99,     21,     12,      0,      0,    152,    110, }, /* 317 */
  {     5,      1,      2,      0,      0,    156,    136, }, /* 318 */
  {     5,     21,     12,      0,      0,      0,    128, }, /* 319 */
  {    99,     21,     12,      0,      0,    160,    128, }, /* 320 */
  {     5,      7,     12,      0,      0,      0,     84, }, /* 321 */
  {    99,      6,     12,      0,      0,    164,    138, }, /* 322 */
  {   106,     12,      3,      0,      0,  26792,    132, }, /* 323 */
  {   106,     12,      3,      0,      0,  26792,    106, }, /* 324 */
  {   106,     12,      3,      0,      0,  26792,    140, }, /* 325 */
  {     5,     12,      3,      0,      0,  26624,    132, }, /* 326 */
  {     5,     12,      3,      0,      0,  26624,    142, }, /* 327 */
  {     5,     13,     12,      0,      0,   2220,    144, }, /* 328 */
  {     5,     21,     12,      0,      0,   2048,     74, }, /* 329 */
  {     5,      7,     12,      0,      0,      0,    146, }, /* 330 */
  {     5,     21,     12,      0,      0,    176,    128, }, /* 331 */
  {     5,     12,      3,      0,      0,  26624,    140, }, /* 332 */
  {     5,     12,      3,      0,      0,  26624,     98, }, /* 333 */
  {     5,      6,     12,      0,      0,      0,     94, }, /* 334 */
  {     5,     13,     12,      0,      0,  10240,    144, }, /* 335 */
  {     5,     26,     12,      0,      0,      0,     74, }, /* 336 */
  {     6,     21,     12,      0,      0,      0,    128, }, /* 337 */
  {     6,     21,     12,      0,      0,      0,    110, }, /* 338 */
  {     6,     21,     12,      0,      0,      0,     74, }, /* 339 */
  {    98,      2,     12,      0,      0,      0,      0, }, /* 340 */
  {     6,      1,      4,      0,      0,      0,    134, }, /* 341 */
  {     6,      7,     12,      0,      0,      0,     84, }, /* 342 */
  {     6,     12,      3,      0,      0,  26624,    106, }, /* 343 */
  {     6,     12,      3,      0,      0,  26624,    132, }, /* 344 */
  {     6,     12,      3,      0,      0,  26624,     98, }, /* 345 */
  {     7,      7,     12,      0,      0,      0,     84, }, /* 346 */
  {     7,     12,      3,      0,      0,  26624,    132, }, /* 347 */
  {    48,     13,     12,      0,      0,  34816,    144, }, /* 348 */
  {    48,      7,     12,      0,      0,  34816,     84, }, /* 349 */
  {    48,     12,      3,      0,      0,  26624,     98, }, /* 350 */
  {    48,      6,     12,      0,      0,  34816,     94, }, /* 351 */
  {    48,     26,     12,      0,      0,  28672,     74, }, /* 352 */
  {    48,     21,     12,      0,      0,  28672,     74, }, /* 353 */
  {    48,     21,     12,      0,      0,  28672,    110, }, /* 354 */
  {    48,     21,     12,      0,      0,  28672,    128, }, /* 355 */
  {    48,      6,     12,      0,      0,  34816,    138, }, /* 356 */
  {    48,     12,      3,      0,      0,  26624,    104, }, /* 357 */
  {    48,     23,     12,      0,      0,  34816,     74, }, /* 358 */
  {    54,      7,     12,      0,      0,  34816,     84, }, /* 359 */
  {    54,     12,      3,      0,      0,  26624,    106, }, /* 360 */
  {    54,     12,      3,      0,      0,  26624,     98, }, /* 361 */
  {    54,      6,     12,      0,      0,  34816,    148, }, /* 362 */
  {    54,     12,      3,      0,      0,  26624,    104, }, /* 363 */
  {    54,     21,     12,      0,      0,  34816,    110, }, /* 364 */
  {    54,     21,     12,      0,      0,  34816,     74, }, /* 365 */
  {    54,     21,     12,      0,      0,  34816,    128, }, /* 366 */
  {    59,      7,     12,      0,      0,  34816,     84, }, /* 367 */
  {    59,     12,      3,      0,      0,  26624,    104, }, /* 368 */
  {    59,     21,     12,      0,      0,  34816,    110, }, /* 369 */
  {     5,     24,     12,      0,      0,      0,    126, }, /* 370 */
  {     5,     12,      3,      0,      0,  26624,    150, }, /* 371 */
  {     5,     12,      3,      0,      0,  26624,    104, }, /* 372 */
  {     5,     12,      3,      0,      0,  26624,    152, }, /* 373 */
  {     8,     12,      3,      0,      0,  26624,    106, }, /* 374 */
  {     8,     10,      5,      0,      0,  18432,    154, }, /* 375 */
  {     8,      7,     12,      0,      0,  18432,     84, }, /* 376 */
  {     8,      7,     12,      0,      0,  18432,    156, }, /* 377 */
  {     8,     12,      3,      0,      0,  26624,     98, }, /* 378 */
  {     8,     12,      3,      0,      0,  26624,    158, }, /* 379 */
  {   106,     12,      3,      0,      0,  26804,     98, }, /* 380 */
  {   106,     12,      3,      0,      0,  26808,     98, }, /* 381 */
  {    99,     21,     12,      0,      0,  18620,    128, }, /* 382 */
  {    99,     21,     12,      0,      0,  18624,    128, }, /* 383 */
  {     8,     13,     12,      0,      0,  18628,    144, }, /* 384 */
  {     8,     21,     12,      0,      0,  18432,     74, }, /* 385 */
  {     8,      6,     12,      0,      0,  18432,     94, }, /* 386 */
  {     9,      7,     12,      0,      0,  18432,     84, }, /* 387 */
  {     9,     12,      3,      0,      0,  26624,    106, }, /* 388 */
  {     9,     10,      5,      0,      0,  18432,    154, }, /* 389 */
  {     9,      7,     12,      0,      0,  18432,    156, }, /* 390 */
  {     9,     12,      3,      0,      0,  26624,     98, }, /* 391 */
  {     9,     10,      3,      0,      0,  18432,    160, }, /* 392 */
  {     9,     12,      3,      0,      0,  26624,    158, }, /* 393 */
  {     9,     13,     12,      0,      0,  18632,    144, }, /* 394 */
  {     9,     23,     12,      0,      0,  14336,     74, }, /* 395 */
  {     9,     15,     12,      0,      0,  18432,     74, }, /* 396 */
  {     9,     26,     12,      0,      0,  18432,     74, }, /* 397 */
  {     9,     21,     12,      0,      0,  18432,     74, }, /* 398 */
  {     9,     12,      3,      0,      0,  26624,    104, }, /* 399 */
  {    10,     12,      3,      0,      0,  26624,    106, }, /* 400 */
  {    10,     10,      5,      0,      0,  18432,    154, }, /* 401 */
  {    10,      7,     12,      0,      0,  18432,     84, }, /* 402 */
  {    10,     12,      3,      0,      0,  26624,     98, }, /* 403 */
  {    10,     12,      3,      0,      0,  26624,    158, }, /* 404 */
  {    10,     13,     12,      0,      0,  18636,    144, }, /* 405 */
  {    10,     12,      3,      0,      0,  26624,    162, }, /* 406 */
  {    10,     21,     12,      0,      0,  18432,     74, }, /* 407 */
  {    11,     12,      3,      0,      0,  26624,    106, }, /* 408 */
  {    11,     10,      5,      0,      0,  18432,    154, }, /* 409 */
  {    11,      7,     12,      0,      0,  18432,     84, }, /* 410 */
  {    11,      7,     12,      0,      0,  18432,    156, }, /* 411 */
  {    11,     12,      3,      0,      0,  26624,     98, }, /* 412 */
  {    11,     12,      3,      0,      0,  26624,    158, }, /* 413 */
  {    11,     13,     12,      0,      0,  18640,    144, }, /* 414 */
  {    11,     21,     12,      0,      0,  18432,     74, }, /* 415 */
  {    11,     23,     12,      0,      0,  14336,     74, }, /* 416 */
  {    11,     12,      3,      0,      0,  26624,    162, }, /* 417 */
  {    12,     12,      3,      0,      0,  26624,    106, }, /* 418 */
  {    12,     10,      5,      0,      0,  18432,    154, }, /* 419 */
  {    12,      7,     12,      0,      0,  18432,     84, }, /* 420 */
  {    12,      7,     12,      0,      0,  18432,    156, }, /* 421 */
  {    12,     12,      3,      0,      0,  26624,     98, }, /* 422 */
  {    12,     10,      3,      0,      0,  18432,    160, }, /* 423 */
  {    12,     12,      3,      0,      0,  26624,    158, }, /* 424 */
  {    12,     12,      3,      0,      0,  26624,    164, }, /* 425 */
  {    12,     13,     12,      0,      0,  18432,    144, }, /* 426 */
  {    12,     26,     12,      0,      0,  18432,     74, }, /* 427 */
  {    12,     15,     12,      0,      0,  18432,     74, }, /* 428 */
  {    13,     12,      3,      0,      0,  26624,    106, }, /* 429 */
  {    13,      7,     12,      0,      0,  18432,     84, }, /* 430 */
  {    13,     10,      3,      0,      0,  18432,    160, }, /* 431 */
  {    13,     10,      5,      0,      0,  18432,    154, }, /* 432 */
  {    13,     12,      3,      0,      0,  26624,    158, }, /* 433 */
  {    13,     13,     12,      0,      0,  18644,    144, }, /* 434 */
  {    13,     15,     12,      0,      0,  18644,     74, }, /* 435 */
  {    13,     26,     12,      0,      0,  28884,     74, }, /* 436 */
  {    13,     26,     12,      0,      0,  28672,     74, }, /* 437 */
  {    13,     23,     12,      0,      0,  14336,     74, }, /* 438 */
  {    14,     12,      3,      0,      0,  26624,    106, }, /* 439 */
  {    14,     10,      5,      0,      0,  18432,    154, }, /* 440 */
  {    14,      7,     12,      0,      0,  18432,     84, }, /* 441 */
  {    14,      7,     12,      0,      0,  18432,    156, }, /* 442 */
  {    14,     12,      3,      0,      0,  26624,     98, }, /* 443 */
  {    14,     12,      3,      0,      0,  26624,    158, }, /* 444 */
  {    14,     13,     12,      0,      0,  18432,    144, }, /* 445 */
  {    14,     21,     12,      0,      0,  18432,     74, }, /* 446 */
  {    14,     15,     12,      0,      0,  28672,     74, }, /* 447 */
  {    14,     26,     12,      0,      0,  18432,     74, }, /* 448 */
  {    15,      7,     12,      0,      0,  18432,     84, }, /* 449 */
  {    15,     12,      3,      0,      0,  26624,    106, }, /* 450 */
  {    15,     10,      5,      0,      0,  18432,    154, }, /* 451 */
  {    15,     21,     12,      0,      0,  18432,     74, }, /* 452 */
  {    15,     12,      3,      0,      0,  26624,     98, }, /* 453 */
  {    15,     12,      3,      0,      0,  18432,    106, }, /* 454 */
  {    15,     10,      3,      0,      0,  18432,    160, }, /* 455 */
  {    15,     12,      3,      0,      0,  26624,    158, }, /* 456 */
  {    15,     13,     12,      0,      0,  18648,    144, }, /* 457 */
  {    16,     12,      3,      0,      0,  26624,    106, }, /* 458 */
  {    16,     10,      5,      0,      0,  18432,    154, }, /* 459 */
  {    16,      7,     12,      0,      0,  18432,     84, }, /* 460 */
  {    16,      7,     12,      0,      0,  18432,    156, }, /* 461 */
  {    16,     12,      3,      0,      0,  26624,    158, }, /* 462 */
  {    16,     10,      3,      0,      0,  18432,    160, }, /* 463 */
  {    16,      7,      4,      0,      0,  18432,     84, }, /* 464 */
  {    16,     26,     12,      0,      0,  18432,     74, }, /* 465 */
  {    16,     15,     12,      0,      0,  18432,     74, }, /* 466 */
  {    16,     13,     12,      0,      0,  18432,    144, }, /* 467 */
  {    17,     12,      3,      0,      0,  26624,    106, }, /* 468 */
  {    17,     10,      5,      0,      0,  18432,    154, }, /* 469 */
  {    17,      7,     12,      0,      0,  18432,     84, }, /* 470 */
  {    17,     12,      3,      0,      0,  26624,    158, }, /* 471 */
  {    17,     10,      3,      0,      0,  18432,    160, }, /* 472 */
  {    17,     13,     12,      0,      0,  18432,    144, }, /* 473 */
  {    17,     21,     12,      0,      0,  18432,     74, }, /* 474 */
  {    18,      7,     12,      0,      0,  18432,     84, }, /* 475 */
  {    18,     12,      3,      0,      0,  26624,    106, }, /* 476 */
  {    18,      7,      5,      0,      0,  18432,    166, }, /* 477 */
  {    18,     12,      3,      0,      0,  26624,    168, }, /* 478 */
  {    99,     23,     12,      0,      0,  14336,     74, }, /* 479 */
  {    18,      7,     12,      0,      0,  18432,    170, }, /* 480 */
  {    18,      6,     12,      0,      0,  18432,    138, }, /* 481 */
  {    18,     12,      3,      0,      0,  26624,     98, }, /* 482 */
  {    18,     21,     12,      0,      0,  18432,     74, }, /* 483 */
  {    18,     13,     12,      0,      0,  18432,    144, }, /* 484 */
  {    18,     21,     12,      0,      0,  18432,    110, }, /* 485 */
  {   100,      7,     12,      0,      0,  18432,     84, }, /* 486 */
  {   100,     12,      3,      0,      0,  26624,    106, }, /* 487 */
  {   100,      7,      5,      0,      0,  18432,    166, }, /* 488 */
  {   100,     12,      3,      0,      0,  26624,    158, }, /* 489 */
  {   100,      7,     12,      0,      0,  18432,    170, }, /* 490 */
  {   100,      6,     12,      0,      0,  18432,    138, }, /* 491 */
  {   100,     12,      3,      0,      0,  26624,     98, }, /* 492 */
  {   100,     12,      3,      0,      0,  26624,    104, }, /* 493 */
  {   100,     13,     12,      0,      0,  18432,    144, }, /* 494 */
  {    19,      7,     12,      0,      0,  18432,     84, }, /* 495 */
  {    19,     26,     12,      0,      0,  18432,     74, }, /* 496 */
  {    19,     21,     12,      0,      0,  18432,     74, }, /* 497 */
  {    19,     21,     12,      0,      0,  18432,    110, }, /* 498 */
  {    19,     12,      3,      0,      0,  26624,     98, }, /* 499 */
  {    19,     13,     12,      0,      0,  18432,    144, }, /* 500 */
  {    19,     15,     12,      0,      0,  18432,     74, }, /* 501 */
  {    19,     22,     12,      0,      0,  28672,    172, }, /* 502 */
  {    19,     18,     12,      0,      0,  28672,    172, }, /* 503 */
  {    19,     10,      5,      0,      0,  18432,    174, }, /* 504 */
  {    19,     12,      3,      0,      0,  26624,    106, }, /* 505 */
  {    19,     12,      3,      0,      0,  26624,    176, }, /* 506 */
  {    19,     10,      5,      0,      0,  18432,    154, }, /* 507 */
  {    19,     12,      3,      0,      0,  26624,    132, }, /* 508 */
  {    19,     12,      3,      0,      0,  26624,    158, }, /* 509 */
  {    99,     26,     12,      0,      0,  18432,     74, }, /* 510 */
  {    20,      7,     12,      0,      0,  18432,     84, }, /* 511 */
  {    20,     10,     12,      0,      0,  18432,    154, }, /* 512 */
  {    20,     12,      3,      0,      0,  26624,    106, }, /* 513 */
  {    20,     10,      5,      0,      0,  18432,    154, }, /* 514 */
  {    20,     12,      3,      0,      0,  26624,     98, }, /* 515 */
  {    20,     12,      3,      0,      0,  26624,    158, }, /* 516 */
  {    20,     13,     12,      0,      0,  18652,    144, }, /* 517 */
  {    20,     21,     12,      0,      0,  18432,    128, }, /* 518 */
  {    20,     21,     12,      0,      0,  18432,     74, }, /* 519 */
  {    20,     10,     12,      0,      0,  18432,    178, }, /* 520 */
  {    20,     12,      3,      0,      0,  26624,    132, }, /* 521 */
  {    20,     13,     12,      0,      0,  18432,    144, }, /* 522 */
  {    20,     26,     12,      0,      0,  18432,     74, }, /* 523 */
  {    21,      9,     12,      0,   7264,  18432,     76, }, /* 524 */
  {    21,      5,     12,      0,   3008,  18432,    180, }, /* 525 */
  {    99,     21,     12,      0,      0,  18656,     74, }, /* 526 */
  {    21,      6,     12,      0,      0,  18432,    182, }, /* 527 */
  {    22,      7,      6,      0,      0,  18432,     84, }, /* 528 */
  {    22,      7,      6,      0,      0,  18432,    184, }, /* 529 */
  {    22,      7,      7,      0,      0,  18432,    184, }, /* 530 */
  {    22,      7,      7,      0,      0,  18432,     84, }, /* 531 */
  {    22,      7,      8,      0,      0,  18432,     84, }, /* 532 */
  {    23,      7,     12,      0,      0,  18432,     84, }, /* 533 */
  {    23,     12,      3,      0,      0,  26624,     98, }, /* 534 */
  {    23,     21,     12,      0,      0,  18432,     74, }, /* 535 */
  {    23,     21,     12,      0,      0,  18432,    110, }, /* 536 */
  {    23,     21,     12,      0,      0,  18432,    128, }, /* 537 */
  {    23,     15,     12,      0,      0,  18432,    144, }, /* 538 */
  {    23,     15,     12,      0,      0,  18432,     74, }, /* 539 */
  {    23,     26,     12,      0,      0,  28672,     74, }, /* 540 */
  {    24,      9,     12,      0,  38864,  18432,    186, }, /* 541 */
  {    24,      9,     12,      0,      8,  18432,    186, }, /* 542 */
  {    24,      5,     12,      0,     -8,  18432,     70, }, /* 543 */
  {   101,     17,     12,      0,      0,  28672,    130, }, /* 544 */
  {   101,      7,     12,      0,      0,  18432,     84, }, /* 545 */
  {   101,     26,     12,      0,      0,  18432,     74, }, /* 546 */
  {   101,     21,     12,      0,      0,  18432,    128, }, /* 547 */
  {   102,     29,     12,      0,      0,  45056,     52, }, /* 548 */
  {   102,      7,     12,      0,      0,  18432,     84, }, /* 549 */
  {   102,     22,     12,      0,      0,  28672,    172, }, /* 550 */
  {   102,     18,     12,      0,      0,  28672,    172, }, /* 551 */
  {    25,      7,     12,      0,      0,  18432,     84, }, /* 552 */
  {    99,     21,     12,      0,      0,  18660,    110, }, /* 553 */
  {    25,     14,     12,      0,      0,  18432,     84, }, /* 554 */
  {    33,      7,     12,      0,      0,  18432,     84, }, /* 555 */
  {    33,     12,      3,      0,      0,  26624,    106, }, /* 556 */
  {    33,     12,      3,      0,      0,  26624,    158, }, /* 557 */
  {    33,     10,      3,      0,      0,  18432,    188, }, /* 558 */
  {    34,      7,     12,      0,      0,  18432,     84, }, /* 559 */
  {    34,     12,      3,      0,      0,  26624,    106, }, /* 560 */
  {    34,     10,      3,      0,      0,  18432,    188, }, /* 561 */
  {    99,     21,     12,      0,      0,  18664,    128, }, /* 562 */
  {    35,      7,     12,      0,      0,  18432,     84, }, /* 563 */
  {    35,     12,      3,      0,      0,  26624,    106, }, /* 564 */
  {    36,      7,     12,      0,      0,  18432,     84, }, /* 565 */
  {    36,     12,      3,      0,      0,  26624,    106, }, /* 566 */
  {   103,      7,     12,      0,      0,  18432,     84, }, /* 567 */
  {   103,      7,     12,      0,      0,  18432,    146, }, /* 568 */
  {   103,     12,      3,      0,      0,  26624,    102, }, /* 569 */
  {   103,     10,      5,      0,      0,  18432,    154, }, /* 570 */
  {   103,     12,      3,      0,      0,  26624,    106, }, /* 571 */
  {   103,     12,      3,      0,      0,  26624,     98, }, /* 572 */
  {   103,     12,      3,      0,      0,  26624,    158, }, /* 573 */
  {   103,     21,     12,      0,      0,  18432,    128, }, /* 574 */
  {   103,     21,     12,      0,      0,  18432,    110, }, /* 575 */
  {   103,      6,     12,      0,      0,  18432,    148, }, /* 576 */
  {   103,     21,     12,      0,      0,  18432,     74, }, /* 577 */
  {   103,     23,     12,      0,      0,  14336,     74, }, /* 578 */
  {   103,     13,     12,      0,      0,  18432,    144, }, /* 579 */
  {   103,     15,     12,      0,      0,  28672,     74, }, /* 580 */
  {    26,     21,     12,      0,      0,  28672,     74, }, /* 581 */
  {    99,     21,     12,      0,      0,  28908,    110, }, /* 582 */
  {    99,     21,     12,      0,      0,  28908,    128, }, /* 583 */
  {    26,     21,     12,      0,      0,  28672,    110, }, /* 584 */
  {    26,     17,     12,      0,      0,  28672,    130, }, /* 585 */
  {    26,     21,     12,      0,      0,  28672,    128, }, /* 586 */
  {    26,     21,     12,      0,      0,  28672,    190, }, /* 587 */
  {    26,     12,      3,      0,      0,  26624,    192, }, /* 588 */
  {    26,      1,      2,      0,      0,   6144,     66, }, /* 589 */
  {    26,     13,     12,      0,      0,  18432,    144, }, /* 590 */
  {    26,      7,     12,      0,      0,  18432,     84, }, /* 591 */
  {    26,      6,     12,      0,      0,  18432,    138, }, /* 592 */
  {    26,     12,      3,      0,      0,  26624,    194, }, /* 593 */
  {    26,     12,      3,      0,      0,  26624,    106, }, /* 594 */
  {    37,      7,     12,      0,      0,  18432,     84, }, /* 595 */
  {    37,     12,      3,      0,      0,  26624,    106, }, /* 596 */
  {    37,     10,      5,      0,      0,  18432,    154, }, /* 597 */
  {    37,     12,      3,      0,      0,  26624,     98, }, /* 598 */
  {    37,     26,     12,      0,      0,  28672,     74, }, /* 599 */
  {    37,     21,     12,      0,      0,  28672,    128, }, /* 600 */
  {    37,     13,     12,      0,      0,  18432,    144, }, /* 601 */
  {    38,      7,     12,      0,      0,  18432,     84, }, /* 602 */
  {   110,      7,     12,      0,      0,  18432,     84, }, /* 603 */
  {   110,      7,     12,      0,      0,  18432,    170, }, /* 604 */
  {   110,     13,     12,      0,      0,  18432,    144, }, /* 605 */
  {   110,     15,     12,      0,      0,  18432,    144, }, /* 606 */
  {   110,     26,     12,      0,      0,  28672,     74, }, /* 607 */
  {   103,     26,     12,      0,      0,  28672,     74, }, /* 608 */
  {    42,      7,     12,      0,      0,  18432,     84, }, /* 609 */
  {    42,     12,      3,      0,      0,  26624,    106, }, /* 610 */
  {    42,     10,      5,      0,      0,  18432,    154, }, /* 611 */
  {    42,     21,     12,      0,      0,  18432,     74, }, /* 612 */
  {   123,      7,     12,      0,      0,  18432,     84, }, /* 613 */
  {   123,     10,      5,      0,      0,  18432,    154, }, /* 614 */
  {   123,     12,      3,      0,      0,  26624,    106, }, /* 615 */
  {   123,     12,      3,      0,      0,  26624,    158, }, /* 616 */
  {   123,     10,     12,      0,      0,  18432,    154, }, /* 617 */
  {   123,     12,      3,      0,      0,  26624,     98, }, /* 618 */
  {   123,     13,     12,      0,      0,  18432,    144, }, /* 619 */
  {   123,     21,     12,      0,      0,  18432,     74, }, /* 620 */
  {   123,      6,     12,      0,      0,  18432,    138, }, /* 621 */
  {   123,     21,     12,      0,      0,  18432,    128, }, /* 622 */
  {   106,     11,      3,      0,      0,  26624,    196, }, /* 623 */
  {   106,     12,      3,      0,      0,  26624,    106, }, /* 624 */
  {   113,     12,      3,      0,      0,  26624,    106, }, /* 625 */
  {   113,     10,      5,      0,      0,  18432,    154, }, /* 626 */
  {   113,      7,     12,      0,      0,  18432,     84, }, /* 627 */
  {   113,     12,      3,      0,      0,  26624,     98, }, /* 628 */
  {   113,     10,      3,      0,      0,  18432,    160, }, /* 629 */
  {   113,     10,      3,      0,      0,  18432,    188, }, /* 630 */
  {   113,     21,     12,      0,      0,  18432,    128, }, /* 631 */
  {   113,     13,     12,      0,      0,  18432,    144, }, /* 632 */
  {   113,     21,     12,      0,      0,  18432,     74, }, /* 633 */
  {   113,     21,     12,      0,      0,  18432,    110, }, /* 634 */
  {   113,     26,     12,      0,      0,  18432,     74, }, /* 635 */
  {   116,     12,      3,      0,      0,  26624,    106, }, /* 636 */
  {   116,     10,      5,      0,      0,  18432,    154, }, /* 637 */
  {   116,      7,     12,      0,      0,  18432,     84, }, /* 638 */
  {   116,     10,      3,      0,      0,  18432,    188, }, /* 639 */
  {   116,     12,      3,      0,      0,  26624,    158, }, /* 640 */
  {   116,     13,     12,      0,      0,  18432,    144, }, /* 641 */
  {   132,      7,     12,      0,      0,  18432,     84, }, /* 642 */
  {   132,     12,      3,      0,      0,  26624,     98, }, /* 643 */
  {   132,     10,      5,      0,      0,  18432,    154, }, /* 644 */
  {   132,     12,      3,      0,      0,  26624,    106, }, /* 645 */
  {   132,     10,      3,      0,      0,  18432,    188, }, /* 646 */
  {   132,     21,     12,      0,      0,  18432,     74, }, /* 647 */
  {   117,      7,     12,      0,      0,  18432,     84, }, /* 648 */
  {   117,     10,      5,      0,      0,  18432,    154, }, /* 649 */
  {   117,     12,      3,      0,      0,  26624,    106, }, /* 650 */
  {   117,     12,      3,      0,      0,  26624,    198, }, /* 651 */
  {   117,     12,      3,      0,      0,  26624,     98, }, /* 652 */
  {   117,     21,     12,      0,      0,  18432,    128, }, /* 653 */
  {   117,     21,     12,      0,      0,  18432,    110, }, /* 654 */
  {   117,     13,     12,      0,      0,  18432,    144, }, /* 655 */
  {   118,     13,     12,      0,      0,  18432,    144, }, /* 656 */
  {   118,      7,     12,      0,      0,  18432,     84, }, /* 657 */
  {   118,      6,     12,      0,      0,  18432,     94, }, /* 658 */
  {   118,      6,     12,      0,      0,  18432,     96, }, /* 659 */
  {   118,     21,     12,      0,      0,  18432,    128, }, /* 660 */
  {     2,      5,     12,     63,  -6222,  18432,     70, }, /* 661 */
  {     2,      5,     12,     67,  -6221,  18432,     70, }, /* 662 */
  {     2,      5,     12,     71,  -6212,  18432,     70, }, /* 663 */
  {     2,      5,     12,     75,  -6210,  18432,     70, }, /* 664 */
  {     2,      5,     12,     79,  -6210,  18432,     70, }, /* 665 */
  {     2,      5,     12,     79,  -6211,  18432,     70, }, /* 666 */
  {     2,      5,     12,     84,  -6204,  18432,     70, }, /* 667 */
  {     2,      5,     12,     88,  -6180,  18432,     70, }, /* 668 */
  {     2,      5,     12,    108,  35267,  18432,     70, }, /* 669 */
  {    21,      9,     12,      0,  -3008,  18432,     76, }, /* 670 */
  {   116,     21,     12,      0,      0,  18432,     74, }, /* 671 */
  {   106,     12,      3,      0,      0,  26864,     98, }, /* 672 */
  {   106,     12,      3,      0,      0,  26868,     98, }, /* 673 */
  {    99,     21,     12,      0,      0,  18680,    200, }, /* 674 */
  {   106,     12,      3,      0,      0,  26876,     98, }, /* 675 */
  {   106,     12,      3,      0,      0,  26880,     98, }, /* 676 */
  {   106,     12,      3,      0,      0,  26884,     98, }, /* 677 */
  {    99,     10,      5,      0,      0,  18684,    174, }, /* 678 */
  {    99,      7,     12,      0,      0,  18696,     84, }, /* 679 */
  {    99,      7,     12,      0,      0,  18684,     84, }, /* 680 */
  {    99,      7,     12,      0,      0,  18676,     84, }, /* 681 */
  {    99,      7,     12,      0,      0,  18700,     84, }, /* 682 */
  {    99,      7,     12,      0,      0,  18704,     84, }, /* 683 */
  {   106,     12,      3,      0,      0,  26900,     98, }, /* 684 */
  {    99,     10,      5,      0,      0,  18712,    174, }, /* 685 */
  {   106,     12,      3,      0,      0,  26896,     98, }, /* 686 */
  {    99,      7,     12,      0,      0,  18716,     84, }, /* 687 */
  {     2,      5,     12,      0,      0,  18432,     60, }, /* 688 */
  {     1,      6,     12,      0,      0,  18432,     90, }, /* 689 */
  {     2,      6,     12,      0,      0,  18432,    182, }, /* 690 */
  {     0,      5,     12,      0,  35332,  18432,     78, }, /* 691 */
  {     0,      5,     12,      0,   3814,  18432,     78, }, /* 692 */
  {     0,      5,     12,      0,  35384,  18432,     78, }, /* 693 */
  {     0,      5,     12,      0,      0,  18432,    202, }, /* 694 */
  {     0,      6,     12,      0,      0,  18432,    182, }, /* 695 */
  {     0,      6,     12,      0,      0,  18432,    204, }, /* 696 */
  {     1,      6,     12,      0,      0,  18432,    182, }, /* 697 */
  {   106,     12,      3,      0,      0,  26740,    104, }, /* 698 */
  {   106,     12,      3,      0,      0,  26912,     98, }, /* 699 */
  {   106,     12,      3,      0,      0,  26916,     98, }, /* 700 */
  {     0,      9,     12,     92,      1,  18432,     76, }, /* 701 */
  {     0,      5,     12,     92,     -1,  18432,     78, }, /* 702 */
  {     0,      5,     12,      0,      0,  18432,     70, }, /* 703 */
  {     0,      5,     12,     92,    -58,  18432,     70, }, /* 704 */
  {     0,      9,     12,      0,  -7615,  18432,     76, }, /* 705 */
  {     1,      5,     12,      0,      8,  18432,     78, }, /* 706 */
  {     1,      9,     12,      0,     -8,  18432,     76, }, /* 707 */
  {     1,      5,     12,      0,      0,  18432,     78, }, /* 708 */
  {     1,      5,     12,      0,     74,  18432,     78, }, /* 709 */
  {     1,      5,     12,      0,     86,  18432,     78, }, /* 710 */
  {     1,      5,     12,      0,    100,  18432,     78, }, /* 711 */
  {     1,      5,     12,      0,    128,  18432,     78, }, /* 712 */
  {     1,      5,     12,      0,    112,  18432,     78, }, /* 713 */
  {     1,      5,     12,      0,    126,  18432,     78, }, /* 714 */
  {     1,      5,     12,      0,      8,  18432,     70, }, /* 715 */
  {     1,      8,     12,      0,     -8,  18432,     88, }, /* 716 */
  {     1,      5,     12,      0,      0,  18432,     70, }, /* 717 */
  {     1,      5,     12,      0,      9,  18432,     70, }, /* 718 */
  {     1,      9,     12,      0,    -74,  18432,     76, }, /* 719 */
  {     1,      8,     12,      0,     -9,  18432,     88, }, /* 720 */
  {     1,      5,     12,     21,  -7173,  18432,     78, }, /* 721 */
  {     1,      9,     12,      0,    -86,  18432,     76, }, /* 722 */
  {     1,      5,     12,      0,  -7235,  18432,     78, }, /* 723 */
  {     1,      9,     12,      0,   -100,  18432,     76, }, /* 724 */
  {     1,      5,     12,      0,  -7219,  18432,     78, }, /* 725 */
  {     1,      9,     12,      0,   -112,  18432,     76, }, /* 726 */
  {     1,      9,     12,      0,   -128,  18432,     76, }, /* 727 */
  {     1,      9,     12,      0,   -126,  18432,     76, }, /* 728 */
  {    99,     29,     12,      0,      0,  45056,     52, }, /* 729 */
  {   106,      1,      3,      0,      0,   6144,    206, }, /* 730 */
  {   106,      1,     13,      0,      0,   6144,    208, }, /* 731 */
  {    99,      1,      2,      0,      0,  18432,    210, }, /* 732 */
  {    99,      1,      2,      0,      0,  34816,    210, }, /* 733 */
  {    99,     17,     12,      0,      0,  28672,    212, }, /* 734 */
  {    99,     21,     12,      0,      0,  28672,     64, }, /* 735 */
  {    99,     20,     12,      0,      0,  28672,    214, }, /* 736 */
  {    99,     19,     12,      0,      0,  28672,    214, }, /* 737 */
  {    99,     22,     12,      0,      0,  28672,    216, }, /* 738 */
  {    99,     20,     12,      0,      0,  28672,    216, }, /* 739 */
  {    99,     19,     12,      0,      0,  28672,    216, }, /* 740 */
  {    99,     21,     12,      0,      0,  28672,    218, }, /* 741 */
  {    99,     21,     12,      0,      0,  28672,    220, }, /* 742 */
  {    99,     27,      2,      0,      0,  45056,     50, }, /* 743 */
  {    99,     28,      2,      0,      0,   4096,     50, }, /* 744 */
  {    99,      1,      2,      0,      0,  20480,    136, }, /* 745 */
  {    99,      1,      2,      0,      0,  36864,    136, }, /* 746 */
  {    99,      1,      2,      0,      0,  30720,    136, }, /* 747 */
  {    99,      1,      2,      0,      0,  24576,    136, }, /* 748 */
  {    99,      1,      2,      0,      0,  40960,    136, }, /* 749 */
  {    99,     29,     12,      0,      0,   8488,     52, }, /* 750 */
  {    99,     21,     12,      0,      0,  14336,     54, }, /* 751 */
  {    99,     21,     12,      0,      0,  14336,     64, }, /* 752 */
  {    99,     21,     14,      0,      0,  28672,    222, }, /* 753 */
  {    99,     21,     12,      0,      0,  28672,    224, }, /* 754 */
  {    99,     16,     12,      0,      0,  28672,    144, }, /* 755 */
  {    99,     16,     12,      0,      0,  28672,    226, }, /* 756 */
  {    99,     25,     12,      0,      0,   8192,     64, }, /* 757 */
  {    99,     22,     12,      0,      0,  28672,    228, }, /* 758 */
  {    99,     18,     12,      0,      0,  28672,    228, }, /* 759 */
  {    99,     21,     12,      0,      0,  28972,     54, }, /* 760 */
  {    99,     21,     12,      0,      0,  28672,    212, }, /* 761 */
  {    99,     21,     12,      0,      0,  28976,     54, }, /* 762 */
  {    99,     21,     12,      0,      0,  28980,     54, }, /* 763 */
  {    99,      1,      2,      0,      0,   6144,    230, }, /* 764 */
  {    98,      2,      2,      0,      0,   6144,    232, }, /* 765 */
  {    99,      1,      2,      0,      0,  22528,    136, }, /* 766 */
  {    99,      1,      2,      0,      0,  38912,    136, }, /* 767 */
  {    99,      1,      2,      0,      0,  16384,    136, }, /* 768 */
  {    99,      1,      2,      0,      0,  32768,    136, }, /* 769 */
  {    99,      1,      2,      0,      0,   6144,    234, }, /* 770 */
  {    99,     25,     12,      0,      0,  12288,    236, }, /* 771 */
  {    99,     25,     12,      0,      0,  12288,    238, }, /* 772 */
  {    99,     25,     12,      0,      0,  28672,    236, }, /* 773 */
  {    99,     22,     12,      0,      0,  28672,    240, }, /* 774 */
  {    99,     18,     12,      0,      0,  28672,    240, }, /* 775 */
  {    98,      2,     12,      0,      0,  14336,      0, }, /* 776 */
  {   106,     12,      3,      0,      0,  26624,    242, }, /* 777 */
  {   106,     11,      3,      0,      0,  26624,    124, }, /* 778 */
  {   106,     11,      3,      0,      0,  26624,    244, }, /* 779 */
  {   106,     12,      3,      0,      0,  26936,    104, }, /* 780 */
  {    99,     26,     12,      0,      0,  28672,     74, }, /* 781 */
  {    99,      9,     12,      0,      0,  18432,    116, }, /* 782 */
  {    99,      5,     12,      0,      0,  18432,    246, }, /* 783 */
  {    99,     25,     12,      0,      0,  28672,    248, }, /* 784 */
  {    99,     26,     14,      0,      0,  28672,    250, }, /* 785 */
  {     1,      9,     12,     96,  -7517,  18432,     76, }, /* 786 */
  {    99,     26,     12,      0,      0,  28672,    122, }, /* 787 */
  {     0,      9,     12,    100,      0,  18432,     76, }, /* 788 */
  {     0,      9,     12,    104,  -8262,  18432,     76, }, /* 789 */
  {    99,     26,     12,      0,      0,  14336,    252, }, /* 790 */
  {     0,      9,     12,      0,     28,  18432,     76, }, /* 791 */
  {    99,      7,     12,      0,      0,  18432,    254, }, /* 792 */
  {    99,      5,     14,      0,      0,  18432,    256, }, /* 793 */
  {    99,     25,     12,      0,      0,  28672,    122, }, /* 794 */
  {    99,      5,     12,      0,      0,  18432,    258, }, /* 795 */
  {     0,      5,     12,      0,    -28,  18432,     78, }, /* 796 */
  {     0,     14,     12,      0,     16,  18432,     76, }, /* 797 */
  {     0,     14,     12,      0,    -16,  18432,     78, }, /* 798 */
  {     0,     14,     12,      0,      0,  18432,     84, }, /* 799 */
  {    99,     25,     14,      0,      0,  28672,    260, }, /* 800 */
  {    99,     26,     14,      0,      0,  28672,    260, }, /* 801 */
  {    99,     26,     12,      0,      0,  28672,     64, }, /* 802 */
  {    99,     25,     12,      0,      0,  28672,    262, }, /* 803 */
  {    99,     25,     12,      0,      0,  28672,    264, }, /* 804 */
  {    99,     25,     12,      0,      0,  12288,    266, }, /* 805 */
  {    99,     22,     12,      0,      0,  28672,    264, }, /* 806 */
  {    99,     18,     12,      0,      0,  28672,    264, }, /* 807 */
  {    99,     26,     14,      0,      0,  28672,    268, }, /* 808 */
  {    99,     22,     12,      0,      0,  28672,    270, }, /* 809 */
  {    99,     18,     12,      0,      0,  28672,    270, }, /* 810 */
  {    99,     26,     12,      0,      0,  18432,     54, }, /* 811 */
  {    99,     26,     14,      0,      0,  28672,    272, }, /* 812 */
  {    98,      2,     12,      0,      0,  18432,    274, }, /* 813 */
  {    99,     15,     12,      0,      0,  10240,     74, }, /* 814 */
  {    99,     26,     12,      0,     26,  18432,    276, }, /* 815 */
  {    99,     26,     14,      0,     26,  18432,    278, }, /* 816 */
  {    99,     26,     12,      0,    -26,  18432,    280, }, /* 817 */
  {    99,     25,     14,      0,      0,  28672,    282, }, /* 818 */
  {    99,     26,     14,      0,      0,  28672,    284, }, /* 819 */
  {    99,     26,     14,      0,      0,  28672,    286, }, /* 820 */
  {    99,     25,     14,      0,      0,  28672,    284, }, /* 821 */
  {    99,     26,     14,      0,      0,  18432,    272, }, /* 822 */
  {    99,     26,     14,      0,      0,  28672,    288, }, /* 823 */
  {   109,     26,     12,      0,      0,  18432,     54, }, /* 824 */
  {    99,     26,     12,      0,      0,  28672,    228, }, /* 825 */
  {    44,      9,     12,      0,     48,  18432,     76, }, /* 826 */
  {    44,      5,     12,      0,    -48,  18432,     78, }, /* 827 */
  {     0,      9,     12,      0, -10743,  18432,     76, }, /* 828 */
  {     0,      9,     12,      0,  -3814,  18432,     76, }, /* 829 */
  {     0,      9,     12,      0, -10727,  18432,     76, }, /* 830 */
  {     0,      5,     12,      0, -10795,  18432,     78, }, /* 831 */
  {     0,      5,     12,      0, -10792,  18432,     78, }, /* 832 */
  {     0,      9,     12,      0, -10780,  18432,     76, }, /* 833 */
  {     0,      9,     12,      0, -10749,  18432,     76, }, /* 834 */
  {     0,      9,     12,      0, -10783,  18432,     76, }, /* 835 */
  {     0,      9,     12,      0, -10782,  18432,     76, }, /* 836 */
  {     0,      9,     12,      0, -10815,  18432,     76, }, /* 837 */
  {    43,      5,     12,      0,      0,  18432,     60, }, /* 838 */
  {    43,     26,     12,      0,      0,  28672,     74, }, /* 839 */
  {    43,     12,      3,      0,      0,  26624,     98, }, /* 840 */
  {    43,     21,     12,      0,      0,  28672,    128, }, /* 841 */
  {    43,     21,     12,      0,      0,  28672,     74, }, /* 842 */
  {    43,     15,     12,      0,      0,  28672,     74, }, /* 843 */
  {    21,      5,     12,      0,  -7264,  18432,     78, }, /* 844 */
  {    45,      7,     12,      0,      0,  18432,     84, }, /* 845 */
  {    45,      6,     12,      0,      0,  18432,    148, }, /* 846 */
  {    45,     21,     12,      0,      0,  18432,     74, }, /* 847 */
  {    45,     12,      3,      0,      0,  26624,    290, }, /* 848 */
  {     2,     12,      3,      0,      0,  26624,    106, }, /* 849 */
  {    99,     20,     12,      0,      0,  28672,    228, }, /* 850 */
  {    99,     19,     12,      0,      0,  28672,    228, }, /* 851 */
  {    99,     17,     12,      0,      0,  28988,    212, }, /* 852 */
  {    99,      6,     12,      0,      0,  28672,    292, }, /* 853 */
  {    99,     21,     12,      0,      0,  28992,     54, }, /* 854 */
  {    99,     21,     12,      0,      0,  28996,     54, }, /* 855 */
  {    99,     21,     12,      0,      0,  29000,    224, }, /* 856 */
  {    99,     21,     12,      0,      0,  29004,    294, }, /* 857 */
  {    99,     21,     12,      0,      0,  28812,     54, }, /* 858 */
  {    99,     21,     12,      0,      0,  28672,    294, }, /* 859 */
  {    30,     26,     12,      0,      0,  28672,    296, }, /* 860 */
  {    99,     26,     12,      0,      0,  29008,    298, }, /* 861 */
  {    99,     26,     12,      0,      0,  29008,    300, }, /* 862 */
  {    99,     26,     12,      0,      0,  29008,    302, }, /* 863 */
  {    99,     21,     12,      0,      0,  29012,    294, }, /* 864 */
  {    99,     21,     12,      0,      0,  29016,    224, }, /* 865 */
  {    99,     21,     12,      0,      0,  29020,     54, }, /* 866 */
  {    30,      6,     12,      0,      0,  18432,    138, }, /* 867 */
  {    99,      7,     12,      0,      0,  18784,    304, }, /* 868 */
  {    30,     14,     12,      0,      0,  18432,    304, }, /* 869 */
  {    99,     22,     12,      0,      0,  29028,    228, }, /* 870 */
  {    99,     18,     12,      0,      0,  29028,    228, }, /* 871 */
  {    99,     22,     12,      0,      0,  29032,    228, }, /* 872 */
  {    99,     18,     12,      0,      0,  29032,    228, }, /* 873 */
  {    99,     22,     12,      0,      0,  29036,     62, }, /* 874 */
  {    99,     18,     12,      0,      0,  29036,     62, }, /* 875 */
  {    99,     22,     12,      0,      0,  29036,    228, }, /* 876 */
  {    99,     18,     12,      0,      0,  29036,    228, }, /* 877 */
  {    99,     26,     12,      0,      0,  29020,     54, }, /* 878 */
  {    99,     17,     12,      0,      0,  29020,    212, }, /* 879 */
  {    99,     22,     12,      0,      0,  29020,    216, }, /* 880 */
  {    99,     18,     12,      0,      0,  29020,    216, }, /* 881 */
  {   106,     12,      3,      0,      0,  26992,     98, }, /* 882 */
  {    22,     10,      3,      0,      0,  18432,    306, }, /* 883 */
  {    99,     17,     14,      0,      0,  29020,    308, }, /* 884 */
  {    99,      6,     12,      0,      0,  18804,    138, }, /* 885 */
  {    99,     26,     12,      0,      0,  29020,     74, }, /* 886 */
  {    30,      6,     12,      0,      0,  18432,    148, }, /* 887 */
  {    99,      7,     12,      0,      0,  18808,     84, }, /* 888 */
  {    99,     21,     14,      0,      0,  29048,    250, }, /* 889 */
  {    99,     26,     12,      0,      0,  29024,     74, }, /* 890 */
  {    27,      7,     12,      0,      0,  18432,     84, }, /* 891 */
  {   106,     12,      3,      0,      0,  26996,     98, }, /* 892 */
  {    99,     24,     12,      0,      0,  29044,    310, }, /* 893 */
  {    27,      6,     12,      0,      0,  18432,    138, }, /* 894 */
  {    99,     17,     12,      0,      0,  29044,    130, }, /* 895 */
  {    28,      7,     12,      0,      0,  18432,     84, }, /* 896 */
  {    99,     21,     12,      0,      0,  29036,    144, }, /* 897 */
  {    99,      6,     12,      0,      0,  18804,     96, }, /* 898 */
  {    28,      6,     12,      0,      0,  18432,    138, }, /* 899 */
  {    29,      7,     12,      0,      0,  18432,     84, }, /* 900 */
  {    22,      7,     12,      0,      0,  18432,     84, }, /* 901 */
  {    22,      7,     12,      0,      0,  18432,    184, }, /* 902 */
  {    99,     26,     12,      0,      0,  18784,     74, }, /* 903 */
  {    99,     15,     12,      0,      0,  18784,     74, }, /* 904 */
  {    22,     26,     12,      0,      0,  18432,     74, }, /* 905 */
  {    22,     26,     12,      0,      0,  28672,     74, }, /* 906 */
  {    99,     15,     12,      0,      0,  18432,     74, }, /* 907 */
  {    99,     26,     14,      0,      0,  18784,    250, }, /* 908 */
  {    28,     26,     12,      0,      0,  18432,     74, }, /* 909 */
  {    30,      7,     12,      0,      0,  18432,    312, }, /* 910 */
  {    31,      7,     12,      0,      0,  18432,     84, }, /* 911 */
  {    31,      6,     12,      0,      0,  18432,    138, }, /* 912 */
  {    31,     26,     12,      0,      0,  28672,     74, }, /* 913 */
  {    55,      7,     12,      0,      0,  18432,     84, }, /* 914 */
  {    55,      6,     12,      0,      0,  18432,    148, }, /* 915 */
  {    55,     21,     12,      0,      0,  18432,    110, }, /* 916 */
  {    55,     21,     12,      0,      0,  18432,    128, }, /* 917 */
  {   119,      7,     12,      0,      0,  18432,     84, }, /* 918 */
  {   119,      6,     12,      0,      0,  18432,    138, }, /* 919 */
  {   119,     21,     12,      0,      0,  28672,    110, }, /* 920 */
  {   119,     21,     12,      0,      0,  28672,    128, }, /* 921 */
  {   119,     13,     12,      0,      0,  18432,    144, }, /* 922 */
  {     2,      9,     12,    108,      1,  18432,     76, }, /* 923 */
  {     2,      5,     12,    108, -35267,  18432,     78, }, /* 924 */
  {     2,      7,     12,      0,      0,  18432,     84, }, /* 925 */
  {     2,     21,     12,      0,      0,  28672,     74, }, /* 926 */
  {     2,     12,      3,      0,      0,  26624,     98, }, /* 927 */
  {     2,      6,     12,      0,      0,  28672,     94, }, /* 928 */
  {     2,      6,     12,      0,      0,  18432,     90, }, /* 929 */
  {   126,      7,     12,      0,      0,  18432,     84, }, /* 930 */
  {   126,     14,     12,      0,      0,  18432,     84, }, /* 931 */
  {   126,     12,      3,      0,      0,  26624,     98, }, /* 932 */
  {   126,     21,     12,      0,      0,  18432,     74, }, /* 933 */
  {   126,     21,     12,      0,      0,  18432,    128, }, /* 934 */
  {   126,     21,     12,      0,      0,  18432,    110, }, /* 935 */
  {    99,     24,     12,      0,      0,  29052,     56, }, /* 936 */
  {     0,      9,     12,      0, -35332,  18432,     76, }, /* 937 */
  {    99,     24,     12,      0,      0,  18432,     56, }, /* 938 */
  {     0,      9,     12,      0, -42280,  18432,     76, }, /* 939 */
  {     0,      5,     12,      0,     48,  18432,     78, }, /* 940 */
  {     0,      9,     12,      0, -42308,  18432,     76, }, /* 941 */
  {     0,      9,     12,      0, -42319,  18432,     76, }, /* 942 */
  {     0,      9,     12,      0, -42315,  18432,     76, }, /* 943 */
  {     0,      9,     12,      0, -42305,  18432,     76, }, /* 944 */
  {     0,      9,     12,      0, -42258,  18432,     76, }, /* 945 */
  {     0,      9,     12,      0, -42282,  18432,     76, }, /* 946 */
  {     0,      9,     12,      0, -42261,  18432,     76, }, /* 947 */
  {     0,      9,     12,      0,    928,  18432,     76, }, /* 948 */
  {     0,      9,     12,      0,    -48,  18432,     76, }, /* 949 */
  {     0,      9,     12,      0, -42307,  18432,     76, }, /* 950 */
  {     0,      9,     12,      0, -35384,  18432,     76, }, /* 951 */
  {     0,      9,     12,      0, -42343,  18432,     76, }, /* 952 */
  {     0,      9,     12,      0, -42561,  18432,     76, }, /* 953 */
  {    46,      7,     12,      0,      0,  18432,     84, }, /* 954 */
  {    46,     12,      3,      0,      0,  26624,    106, }, /* 955 */
  {    46,     12,      3,      0,      0,  26624,    158, }, /* 956 */
  {    46,     10,      5,      0,      0,  18432,    154, }, /* 957 */
  {    46,     26,     12,      0,      0,  28672,     74, }, /* 958 */
  {    99,     15,     12,      0,      0,  18816,     74, }, /* 959 */
  {    99,     15,     12,      0,      0,  18820,     74, }, /* 960 */
  {    99,     26,     12,      0,      0,  18824,     74, }, /* 961 */
  {    99,     23,     12,      0,      0,  14732,     74, }, /* 962 */
  {    99,     26,     12,      0,      0,  14728,     74, }, /* 963 */
  {    47,      7,     12,      0,      0,  18432,     84, }, /* 964 */
  {    47,     21,     12,      0,      0,  28672,     74, }, /* 965 */
  {    47,     21,     12,      0,      0,  28672,    128, }, /* 966 */
  {   120,     10,      5,      0,      0,  18432,    154, }, /* 967 */
  {   120,      7,     12,      0,      0,  18432,     84, }, /* 968 */
  {   120,     12,      3,      0,      0,  26624,    158, }, /* 969 */
  {   120,     12,      3,      0,      0,  26624,    106, }, /* 970 */
  {   120,     21,     12,      0,      0,  18432,    128, }, /* 971 */
  {   120,     13,     12,      0,      0,  18432,    144, }, /* 972 */
  {     8,     12,      3,      0,      0,  27024,     98, }, /* 973 */
  {     8,      7,     12,      0,      0,  18836,     84, }, /* 974 */
  {    49,     13,     12,      0,      0,  18432,    144, }, /* 975 */
  {    49,      7,     12,      0,      0,  18432,     84, }, /* 976 */
  {    49,     12,      3,      0,      0,  26624,    106, }, /* 977 */
  {    49,     12,      3,      0,      0,  26624,     98, }, /* 978 */
  {    99,     21,     12,      0,      0,  18840,    200, }, /* 979 */
  {    49,     21,     12,      0,      0,  18432,    128, }, /* 980 */
  {   121,      7,     12,      0,      0,  18432,     84, }, /* 981 */
  {   121,     12,      3,      0,      0,  26624,    106, }, /* 982 */
  {   121,     10,      5,      0,      0,  18432,    154, }, /* 983 */
  {   121,     10,      3,      0,      0,  18432,    188, }, /* 984 */
  {   121,     21,     12,      0,      0,  18432,     74, }, /* 985 */
  {    56,     12,      3,      0,      0,  26624,    106, }, /* 986 */
  {    56,     10,      5,      0,      0,  18432,    154, }, /* 987 */
  {    56,      7,     12,      0,      0,  18432,     84, }, /* 988 */
  {    56,     12,      3,      0,      0,  26624,     98, }, /* 989 */
  {    56,     10,      3,      0,      0,  18432,    188, }, /* 990 */
  {    56,     21,     12,      0,      0,  18432,     74, }, /* 991 */
  {    56,     21,     12,      0,      0,  18432,    110, }, /* 992 */
  {    56,     21,     12,      0,      0,  18432,    128, }, /* 993 */
  {    99,      6,     12,      0,      0,  18844,    138, }, /* 994 */
  {    56,     13,     12,      0,      0,  18432,    144, }, /* 995 */
  {    20,      6,     12,      0,      0,  18432,    138, }, /* 996 */
  {   122,      7,     12,      0,      0,  18432,     84, }, /* 997 */
  {   122,     12,      3,      0,      0,  26624,    106, }, /* 998 */
  {   122,     10,      5,      0,      0,  18432,    154, }, /* 999 */
  {   122,     13,     12,      0,      0,  18432,    144, }, /* 1000 */
  {   122,     21,     12,      0,      0,  18432,     74, }, /* 1001 */
  {   122,     21,     12,      0,      0,  18432,    128, }, /* 1002 */
  {   124,      7,     12,      0,      0,  18432,     84, }, /* 1003 */
  {   124,     12,      3,      0,      0,  26624,    106, }, /* 1004 */
  {   124,      7,     12,      0,      0,  18432,    170, }, /* 1005 */
  {   124,     12,      3,      0,      0,  26624,     98, }, /* 1006 */
  {   124,      7,     12,      0,      0,  18432,    314, }, /* 1007 */
  {   124,      6,     12,      0,      0,  18432,    138, }, /* 1008 */
  {   124,     21,     12,      0,      0,  18432,     74, }, /* 1009 */
  {   124,     21,     12,      0,      0,  18432,    110, }, /* 1010 */
  {   127,      7,     12,      0,      0,  18432,     84, }, /* 1011 */
  {   127,     10,      5,      0,      0,  18432,    154, }, /* 1012 */
  {   127,     12,      3,      0,      0,  26624,    106, }, /* 1013 */
  {   127,     21,     12,      0,      0,  18432,    128, }, /* 1014 */
  {   127,      6,     12,      0,      0,  18432,    138, }, /* 1015 */
  {   127,     12,      3,      0,      0,  26624,    158, }, /* 1016 */
  {     0,      5,     12,      0,   -928,  18432,     78, }, /* 1017 */
  {    24,      5,     12,      0, -38864,  18432,     70, }, /* 1018 */
  {   127,     10,      5,      0,      0,  18432,    174, }, /* 1019 */
  {   127,     13,     12,      0,      0,  18432,    144, }, /* 1020 */
  {    22,      7,      9,      0,      0,  18432,     84, }, /* 1021 */
  {    22,      7,     10,      0,      0,  18432,     84, }, /* 1022 */
  {    98,      4,     12,      0,      0,  18432,      0, }, /* 1023 */
  {    98,      3,     12,      0,      0,  18432,      0, }, /* 1024 */
  {    30,      7,     12,      0,      0,  18432,    304, }, /* 1025 */
  {     0,      5,     12,      0,      1,  18432,     70, }, /* 1026 */
  {     0,      5,     12,      0,     -1,  18432,     70, }, /* 1027 */
  {     4,     25,     12,      0,      0,  12288,    122, }, /* 1028 */
  {     5,      7,     12,      0,      0,      0,    316, }, /* 1029 */
  {    99,     18,     12,      0,      0,  29088,     54, }, /* 1030 */
  {    99,     22,     12,      0,      0,  29088,     54, }, /* 1031 */
  {    98,      2,     12,      0,      0,   6144,    318, }, /* 1032 */
  {     5,      7,     12,      0,      0,    420,     84, }, /* 1033 */
  {     5,     26,     12,      0,      0,  29092,     74, }, /* 1034 */
  {   106,     12,      3,      0,      0,  26624,    192, }, /* 1035 */
  {   106,     12,      3,      0,      0,  26624,    320, }, /* 1036 */
  {    99,     21,     12,      0,      0,  28672,     74, }, /* 1037 */
  {    99,     21,     12,      0,      0,  28672,    128, }, /* 1038 */
  {    99,     21,     12,      0,      0,  28672,    126, }, /* 1039 */
  {    99,     22,     12,      0,      0,  28672,     74, }, /* 1040 */
  {    99,     18,     12,      0,      0,  28672,     74, }, /* 1041 */
  {    99,     17,     12,      0,      0,  28672,    130, }, /* 1042 */
  {    99,     22,     12,      0,      0,  28672,    322, }, /* 1043 */
  {    99,     18,     12,      0,      0,  28672,    322, }, /* 1044 */
  {    99,     21,     12,      0,      0,   8192,    110, }, /* 1045 */
  {    99,     21,     12,      0,      0,   8192,    324, }, /* 1046 */
  {    99,     21,     12,      0,      0,   8192,    326, }, /* 1047 */
  {    99,     22,     12,      0,      0,  28672,    172, }, /* 1048 */
  {    99,     18,     12,      0,      0,  28672,    172, }, /* 1049 */
  {    99,     21,     12,      0,      0,  14336,     74, }, /* 1050 */
  {    99,     21,     12,      0,      0,  28672,    122, }, /* 1051 */
  {    99,     25,     12,      0,      0,  12288,    122, }, /* 1052 */
  {    99,     17,     12,      0,      0,  12288,    328, }, /* 1053 */
  {    99,     25,     12,      0,      0,  28672,    330, }, /* 1054 */
  {    99,     21,     12,      0,      0,  28672,    322, }, /* 1055 */
  {    99,     21,     12,      0,      0,  28672,    332, }, /* 1056 */
  {    99,     17,     12,      0,      0,  12288,    130, }, /* 1057 */
  {    99,     21,     12,      0,      0,   8192,     74, }, /* 1058 */
  {    99,     13,     12,      0,      0,  10240,    334, }, /* 1059 */
  {     0,      9,     12,      0,     32,  18432,    336, }, /* 1060 */
  {    99,     24,     12,      0,      0,  28672,    338, }, /* 1061 */
  {     0,      5,     12,      0,    -32,  18432,    340, }, /* 1062 */
  {    99,     21,     12,      0,      0,  29036,    128, }, /* 1063 */
  {    99,     22,     12,      0,      0,  29036,    342, }, /* 1064 */
  {    99,     18,     12,      0,      0,  29036,    342, }, /* 1065 */
  {    99,     21,     12,      0,      0,  29036,    110, }, /* 1066 */
  {    99,      6,      3,      0,      0,  18804,    344, }, /* 1067 */
  {    99,      1,      2,      0,      0,  28672,    346, }, /* 1068 */
  {    39,      7,     12,      0,      0,  18432,     84, }, /* 1069 */
  {    99,     21,     12,      0,      0,  18856,     74, }, /* 1070 */
  {    99,     21,     12,      0,      0,  29096,     74, }, /* 1071 */
  {    99,     21,     12,      0,      0,  18860,     74, }, /* 1072 */
  {    99,     15,     12,      0,      0,  18864,     74, }, /* 1073 */
  {    99,     26,     12,      0,      0,  18860,     74, }, /* 1074 */
  {     1,     14,     12,      0,      0,  28672,     84, }, /* 1075 */
  {     1,     15,     12,      0,      0,  28672,     74, }, /* 1076 */
  {     1,     26,     12,      0,      0,  28672,     74, }, /* 1077 */
  {     1,     26,     12,      0,      0,  18432,     74, }, /* 1078 */
  {    50,      7,     12,      0,      0,  18432,     84, }, /* 1079 */
  {    51,      7,     12,      0,      0,  18432,     84, }, /* 1080 */
  {   106,     12,      3,      0,      0,  27060,     98, }, /* 1081 */
  {    99,     15,     12,      0,      0,  10676,     74, }, /* 1082 */
  {   104,      7,     12,      0,      0,  18432,     84, }, /* 1083 */
  {   104,     15,     12,      0,      0,  18432,     74, }, /* 1084 */
  {    32,      7,     12,      0,      0,  18432,     84, }, /* 1085 */
  {    32,     14,     12,      0,      0,  18432,     84, }, /* 1086 */
  {    73,      7,     12,      0,      0,  18432,     84, }, /* 1087 */
  {    73,     12,      3,      0,      0,  26624,    106, }, /* 1088 */
  {   107,      7,     12,      0,      0,  18432,     84, }, /* 1089 */
  {   107,     21,     12,      0,      0,  18432,    110, }, /* 1090 */
  {   111,      7,     12,      0,      0,  18432,     84, }, /* 1091 */
  {   111,     21,     12,      0,      0,  18432,    110, }, /* 1092 */
  {   111,     14,     12,      0,      0,  18432,     84, }, /* 1093 */
  {   105,      9,     12,      0,     40,  18432,     76, }, /* 1094 */
  {   105,      5,     12,      0,    -40,  18432,     78, }, /* 1095 */
  {    40,      7,     12,      0,      0,  18432,     84, }, /* 1096 */
  {   108,      7,     12,      0,      0,  18432,     84, }, /* 1097 */
  {   108,     13,     12,      0,      0,  18432,    144, }, /* 1098 */
  {    80,      9,     12,      0,     40,  18432,     76, }, /* 1099 */
  {    80,      5,     12,      0,    -40,  18432,     78, }, /* 1100 */
  {    66,      7,     12,      0,      0,  18432,     84, }, /* 1101 */
  {    64,      7,     12,      0,      0,  18432,     84, }, /* 1102 */
  {    64,     21,     12,      0,      0,  18432,     74, }, /* 1103 */
  {   167,      9,     12,      0,     39,  18432,     76, }, /* 1104 */
  {   167,      5,     12,      0,    -39,  18432,     78, }, /* 1105 */
  {    96,      7,     12,      0,      0,  18432,     84, }, /* 1106 */
  {    69,      7,     12,      0,      0,  18432,     84, }, /* 1107 */
  {     0,      6,     12,      0,      0,  18432,     96, }, /* 1108 */
  {    41,      7,     12,      0,      0,  34816,     84, }, /* 1109 */
  {   128,      7,     12,      0,      0,  34816,     84, }, /* 1110 */
  {   128,     21,     12,      0,      0,  34816,    110, }, /* 1111 */
  {   128,     15,     12,      0,      0,  34816,     74, }, /* 1112 */
  {   143,      7,     12,      0,      0,  34816,     84, }, /* 1113 */
  {   143,     26,     12,      0,      0,  34816,     74, }, /* 1114 */
  {   143,     15,     12,      0,      0,  34816,     74, }, /* 1115 */
  {   142,      7,     12,      0,      0,  34816,     84, }, /* 1116 */
  {   142,     15,     12,      0,      0,  34816,     74, }, /* 1117 */
  {   149,      7,     12,      0,      0,  34816,     84, }, /* 1118 */
  {   149,     15,     12,      0,      0,  34816,     74, }, /* 1119 */
  {   115,      7,     12,      0,      0,  34816,     84, }, /* 1120 */
  {   115,     15,     12,      0,      0,  34816,     74, }, /* 1121 */
  {   115,     21,     12,      0,      0,  28672,    110, }, /* 1122 */
  {    52,      7,     12,      0,      0,  34816,     84, }, /* 1123 */
  {    52,     21,     12,      0,      0,  34816,     74, }, /* 1124 */
  {    61,      7,     12,      0,      0,  34816,     84, }, /* 1125 */
  {   134,      7,     12,      0,      0,  34816,     84, }, /* 1126 */
  {   134,     15,     12,      0,      0,  34816,     74, }, /* 1127 */
  {   112,      7,     12,      0,      0,  34816,     84, }, /* 1128 */
  {   112,     12,      3,      0,      0,  26624,    106, }, /* 1129 */
  {   112,     12,      3,      0,      0,  26624,     98, }, /* 1130 */
  {   112,     12,      3,      0,      0,  26624,    158, }, /* 1131 */
  {   112,     15,     12,      0,      0,  34816,     74, }, /* 1132 */
  {   112,     21,     12,      0,      0,  34816,     74, }, /* 1133 */
  {   112,     21,     12,      0,      0,  34816,    128, }, /* 1134 */
  {   129,      7,     12,      0,      0,  34816,     84, }, /* 1135 */
  {   129,     15,     12,      0,      0,  34816,     74, }, /* 1136 */
  {   129,     21,     12,      0,      0,  34816,     74, }, /* 1137 */
  {   141,      7,     12,      0,      0,  34816,     84, }, /* 1138 */
  {   141,     15,     12,      0,      0,  34816,     74, }, /* 1139 */
  {    71,      7,     12,      0,      0,  34816,     84, }, /* 1140 */
  {    71,     26,     12,      0,      0,  34816,     74, }, /* 1141 */
  {    71,     12,      3,      0,      0,  26624,     98, }, /* 1142 */
  {    71,     15,     12,      0,      0,  34816,     74, }, /* 1143 */
  {    71,     21,     12,      0,      0,  34816,    110, }, /* 1144 */
  {    71,     21,     12,      0,      0,  35256,    110, }, /* 1145 */
  {    71,     21,     12,      0,      0,  34816,     74, }, /* 1146 */
  {    53,      7,     12,      0,      0,  34816,     84, }, /* 1147 */
  {    53,     21,     12,      0,      0,  28672,     74, }, /* 1148 */
  {    53,     21,     12,      0,      0,  28672,    110, }, /* 1149 */
  {   130,      7,     12,      0,      0,  34816,     84, }, /* 1150 */
  {   130,     15,     12,      0,      0,  34816,     74, }, /* 1151 */
  {   131,      7,     12,      0,      0,  34816,     84, }, /* 1152 */
  {   131,     15,     12,      0,      0,  34816,     74, }, /* 1153 */
  {    74,      7,     12,      0,      0,  34816,     84, }, /* 1154 */
  {    74,     21,     12,      0,      0,  34816,    110, }, /* 1155 */
  {    74,     15,     12,      0,      0,  34816,     74, }, /* 1156 */
  {    57,      7,     12,      0,      0,  34816,     84, }, /* 1157 */
  {    78,      9,     12,      0,     64,  34816,     76, }, /* 1158 */
  {    78,      5,     12,      0,    -64,  34816,     78, }, /* 1159 */
  {    78,     15,     12,      0,      0,  34816,     74, }, /* 1160 */
  {    85,      7,     12,      0,      0,      0,     84, }, /* 1161 */
  {    85,      7,     12,      0,      0,      0,    314, }, /* 1162 */
  {    85,     12,      3,      0,      0,  26624,    132, }, /* 1163 */
  {    85,     13,     12,      0,      0,   2048,    144, }, /* 1164 */
  {    92,     13,     12,      0,      0,   2048,    144, }, /* 1165 */
  {    92,      7,     12,      0,      0,  34816,     84, }, /* 1166 */
  {    92,      6,     12,      0,      0,  34816,     96, }, /* 1167 */
  {    92,      9,     12,      0,     32,  34816,     76, }, /* 1168 */
  {    92,     12,      3,      0,      0,  26624,    132, }, /* 1169 */
  {    92,     12,      3,      0,      0,  26624,    164, }, /* 1170 */
  {    92,     12,      3,      0,      0,  26624,     98, }, /* 1171 */
  {    92,     17,     12,      0,      0,  28672,    130, }, /* 1172 */
  {    92,      6,     12,      0,      0,  34816,    138, }, /* 1173 */
  {    92,      5,     12,      0,    -32,  34816,     78, }, /* 1174 */
  {    92,     25,     12,      0,      0,  34816,    122, }, /* 1175 */
  {     5,     15,     12,      0,      0,   2048,     74, }, /* 1176 */
  {    88,      7,     12,      0,      0,  34816,     84, }, /* 1177 */
  {    88,     12,      3,      0,      0,  26624,    106, }, /* 1178 */
  {    88,     17,     12,      0,      0,  34816,    130, }, /* 1179 */
  {   159,      7,     12,      0,      0,  34816,     84, }, /* 1180 */
  {   159,     15,     12,      0,      0,  34816,     74, }, /* 1181 */
  {    86,      7,     12,      0,      0,      0,     84, }, /* 1182 */
  {    86,     12,      3,      0,      0,  26624,     98, }, /* 1183 */
  {    86,     15,     12,      0,      0,      0,     74, }, /* 1184 */
  {    86,     21,     12,      0,      0,      0,    128, }, /* 1185 */
  {    90,      7,     12,      0,      0,  34816,     84, }, /* 1186 */
  {    90,     12,      3,      0,      0,  26624,     98, }, /* 1187 */
  {    90,     21,     12,      0,      0,  34816,    128, }, /* 1188 */
  {   163,      7,     12,      0,      0,  34816,     84, }, /* 1189 */
  {   163,     15,     12,      0,      0,  34816,     74, }, /* 1190 */
  {   160,      7,     12,      0,      0,  34816,     84, }, /* 1191 */
  {   133,     10,      5,      0,      0,  18432,    154, }, /* 1192 */
  {   133,     12,      3,      0,      0,  26624,    106, }, /* 1193 */
  {   133,      7,     12,      0,      0,  18432,     84, }, /* 1194 */
  {   133,     12,      3,      0,      0,  26624,    158, }, /* 1195 */
  {   133,     21,     12,      0,      0,  18432,    128, }, /* 1196 */
  {   133,     21,     12,      0,      0,  18432,    110, }, /* 1197 */
  {   133,     15,     12,      0,      0,  28672,     74, }, /* 1198 */
  {   133,     13,     12,      0,      0,  18432,    144, }, /* 1199 */
  {   133,     12,      3,      0,      0,  26624,    290, }, /* 1200 */
  {    58,     12,      3,      0,      0,  26624,    106, }, /* 1201 */
  {    58,     10,      5,      0,      0,  18432,    154, }, /* 1202 */
  {    58,      7,     12,      0,      0,  18432,     84, }, /* 1203 */
  {    58,     12,      3,      0,      0,  26624,    158, }, /* 1204 */
  {    58,     12,      3,      0,      0,  26624,     98, }, /* 1205 */
  {    58,     21,     12,      0,      0,  18432,     74, }, /* 1206 */
  {    58,      1,      4,      0,      0,  18432,    134, }, /* 1207 */
  {    58,     21,     12,      0,      0,  18432,    128, }, /* 1208 */
  {   136,      7,     12,      0,      0,  18432,     84, }, /* 1209 */
  {   136,     13,     12,      0,      0,  18432,    144, }, /* 1210 */
  {    60,     12,      3,      0,      0,  26624,    106, }, /* 1211 */
  {    60,      7,     12,      0,      0,  18432,     84, }, /* 1212 */
  {    60,     10,      5,      0,      0,  18432,    154, }, /* 1213 */
  {    60,     12,      3,      0,      0,  26624,    158, }, /* 1214 */
  {    60,     13,     12,      0,      0,  18432,    144, }, /* 1215 */
  {    60,     21,     12,      0,      0,  18432,     74, }, /* 1216 */
  {    60,     21,     12,      0,      0,  18432,    128, }, /* 1217 */
  {    70,      7,     12,      0,      0,  18432,     84, }, /* 1218 */
  {    70,     12,      3,      0,      0,  26624,     98, }, /* 1219 */
  {    70,     21,     12,      0,      0,  18432,     74, }, /* 1220 */
  {    62,     12,      3,      0,      0,  26624,    106, }, /* 1221 */
  {    62,     10,      5,      0,      0,  18432,    154, }, /* 1222 */
  {    62,      7,     12,      0,      0,  18432,     84, }, /* 1223 */
  {    62,     10,      3,      0,      0,  18432,    188, }, /* 1224 */
  {    62,      7,      4,      0,      0,  18432,     84, }, /* 1225 */
  {    62,     21,     12,      0,      0,  18432,    128, }, /* 1226 */
  {    62,     21,     12,      0,      0,  18432,     74, }, /* 1227 */
  {    62,     12,      3,      0,      0,  26624,    104, }, /* 1228 */
  {    62,     12,      3,      0,      0,  26624,     98, }, /* 1229 */
  {    62,     13,     12,      0,      0,  18432,    144, }, /* 1230 */
  {    17,     15,     12,      0,      0,  18432,     74, }, /* 1231 */
  {    68,      7,     12,      0,      0,  18432,     84, }, /* 1232 */
  {    68,     10,      5,      0,      0,  18432,    154, }, /* 1233 */
  {    68,     12,      3,      0,      0,  26624,    106, }, /* 1234 */
  {    68,     10,      3,      0,      0,  18432,    188, }, /* 1235 */
  {    68,     12,      3,      0,      0,  26624,     98, }, /* 1236 */
  {    68,     12,      3,      0,      0,  26624,    162, }, /* 1237 */
  {    68,     21,     12,      0,      0,  18432,    128, }, /* 1238 */
  {    68,     21,     12,      0,      0,  18432,    110, }, /* 1239 */
  {    68,     21,     12,      0,      0,  18432,     74, }, /* 1240 */
  {    77,      7,     12,      0,      0,  18432,     84, }, /* 1241 */
  {    77,     21,     12,      0,      0,  18432,    128, }, /* 1242 */
  {    75,      7,     12,      0,      0,  18432,     84, }, /* 1243 */
  {    75,     12,      3,      0,      0,  26624,    106, }, /* 1244 */
  {    75,     10,      5,      0,      0,  18432,    154, }, /* 1245 */
  {    75,     12,      3,      0,      0,  26624,     98, }, /* 1246 */
  {    75,     12,      3,      0,      0,  26624,    158, }, /* 1247 */
  {    75,     13,     12,      0,      0,  18432,    144, }, /* 1248 */
  {    67,     12,      3,      0,      0,  26624,    106, }, /* 1249 */
  {    67,     12,      3,      0,      0,  26836,    106, }, /* 1250 */
  {    67,     10,      5,      0,      0,  18432,    154, }, /* 1251 */
  {    67,     10,      5,      0,      0,  18644,    154, }, /* 1252 */
  {    67,      7,     12,      0,      0,  18432,     84, }, /* 1253 */
  {   106,     12,      3,      0,      0,  26836,     98, }, /* 1254 */
  {    67,     12,      3,      0,      0,  26836,     98, }, /* 1255 */
  {    67,     10,      3,      0,      0,  18432,    160, }, /* 1256 */
  {    67,     10,      3,      0,      0,  18432,    188, }, /* 1257 */
  {    67,      7,     12,      0,      0,  18432,    348, }, /* 1258 */
  {    67,     12,      3,      0,      0,  26624,     98, }, /* 1259 */
  {    97,      7,     12,      0,      0,  18432,     84, }, /* 1260 */
  {    97,     10,      3,      0,      0,  18432,    160, }, /* 1261 */
  {    97,     10,      5,      0,      0,  18432,    154, }, /* 1262 */
  {    97,     12,      3,      0,      0,  26624,    106, }, /* 1263 */
  {    97,     12,      3,      0,      0,  26624,    158, }, /* 1264 */
  {    97,     10,      3,      0,      0,  18432,    188, }, /* 1265 */
  {    97,      7,      4,      0,      0,  18432,     84, }, /* 1266 */
  {    97,     12,      3,      0,      0,  26624,    164, }, /* 1267 */
  {    97,      7,     12,      0,      0,  18432,    350, }, /* 1268 */
  {    97,     21,     12,      0,      0,  18432,    128, }, /* 1269 */
  {    97,     21,     12,      0,      0,  18432,     74, }, /* 1270 */
  {    97,     12,      3,      0,      0,  26624,     98, }, /* 1271 */
  {   153,      7,     12,      0,      0,  18432,     84, }, /* 1272 */
  {   153,     10,      5,      0,      0,  18432,    154, }, /* 1273 */
  {   153,     12,      3,      0,      0,  26624,    106, }, /* 1274 */
  {   153,     12,      3,      0,      0,  26624,    158, }, /* 1275 */
  {   153,     12,      3,      0,      0,  26624,     98, }, /* 1276 */
  {   153,     21,     12,      0,      0,  18432,    128, }, /* 1277 */
  {   153,     21,     12,      0,      0,  18432,    110, }, /* 1278 */
  {   153,     21,     12,      0,      0,  18432,     74, }, /* 1279 */
  {   153,     13,     12,      0,      0,  18432,    144, }, /* 1280 */
  {   153,     12,      3,      0,      0,  26624,    104, }, /* 1281 */
  {    76,      7,     12,      0,      0,  18432,     84, }, /* 1282 */
  {    76,     10,      3,      0,      0,  18432,    160, }, /* 1283 */
  {    76,     10,      5,      0,      0,  18432,    154, }, /* 1284 */
  {    76,     12,      3,      0,      0,  26624,    106, }, /* 1285 */
  {    76,     12,      3,      0,      0,  26624,    158, }, /* 1286 */
  {    76,     12,      3,      0,      0,  26624,     98, }, /* 1287 */
  {    76,     21,     12,      0,      0,  18432,     74, }, /* 1288 */
  {    76,     13,     12,      0,      0,  18432,    144, }, /* 1289 */
  {   145,      7,     12,      0,      0,  18432,     84, }, /* 1290 */
  {   145,     10,      3,      0,      0,  18432,    160, }, /* 1291 */
  {   145,     10,      5,      0,      0,  18432,    154, }, /* 1292 */
  {   145,     12,      3,      0,      0,  26624,    106, }, /* 1293 */
  {   145,     12,      3,      0,      0,  26624,    158, }, /* 1294 */
  {   145,     12,      3,      0,      0,  26624,     98, }, /* 1295 */
  {   145,     21,     12,      0,      0,  18432,     74, }, /* 1296 */
  {   145,     21,     12,      0,      0,  18432,    128, }, /* 1297 */
  {   145,     21,     12,      0,      0,  18432,    110, }, /* 1298 */
  {   145,     21,     12,      0,      0,  18432,    190, }, /* 1299 */
  {    72,      7,     12,      0,      0,  18432,     84, }, /* 1300 */
  {    72,     10,      5,      0,      0,  18432,    154, }, /* 1301 */
  {    72,     12,      3,      0,      0,  26624,    106, }, /* 1302 */
  {    72,     12,      3,      0,      0,  26624,    158, }, /* 1303 */
  {    72,     21,     12,      0,      0,  18432,    128, }, /* 1304 */
  {    72,     21,     12,      0,      0,  18432,     74, }, /* 1305 */
  {    72,     13,     12,      0,      0,  18432,    144, }, /* 1306 */
  {    63,      7,     12,      0,      0,  18432,     84, }, /* 1307 */
  {    63,     12,      3,      0,      0,  26624,    106, }, /* 1308 */
  {    63,     10,      5,      0,      0,  18432,    154, }, /* 1309 */
  {    63,     10,      3,      0,      0,  18432,    188, }, /* 1310 */
  {    63,     12,      3,      0,      0,  26624,     98, }, /* 1311 */
  {    63,     21,     12,      0,      0,  18432,     74, }, /* 1312 */
  {    63,     13,     12,      0,      0,  18432,    144, }, /* 1313 */
  {   147,      7,     12,      0,      0,  18432,     84, }, /* 1314 */
  {   147,     12,      3,      0,      0,  26624,    106, }, /* 1315 */
  {   147,     10,      5,      0,      0,  18432,    154, }, /* 1316 */
  {   147,     10,     12,      0,      0,  18432,    154, }, /* 1317 */
  {   147,     12,      3,      0,      0,  26624,    158, }, /* 1318 */
  {   147,     13,     12,      0,      0,  18432,    144, }, /* 1319 */
  {   147,     15,     12,      0,      0,  18432,     74, }, /* 1320 */
  {   147,     21,     12,      0,      0,  18432,    128, }, /* 1321 */
  {   147,     26,     12,      0,      0,  18432,     74, }, /* 1322 */
  {    83,      7,     12,      0,      0,  18432,     84, }, /* 1323 */
  {    83,     10,      5,      0,      0,  18432,    154, }, /* 1324 */
  {    83,     12,      3,      0,      0,  26624,    106, }, /* 1325 */
  {    83,     12,      3,      0,      0,  26624,    158, }, /* 1326 */
  {    83,     12,      3,      0,      0,  26624,     98, }, /* 1327 */
  {    83,     21,     12,      0,      0,  18432,     74, }, /* 1328 */
  {   146,      9,     12,      0,     32,  18432,     76, }, /* 1329 */
  {   146,      5,     12,      0,    -32,  18432,     78, }, /* 1330 */
  {   146,     13,     12,      0,      0,  18432,    144, }, /* 1331 */
  {   146,     15,     12,      0,      0,  18432,     74, }, /* 1332 */
  {   146,      7,     12,      0,      0,  18432,     84, }, /* 1333 */
  {   164,      7,     12,      0,      0,  18432,     84, }, /* 1334 */
  {   164,     10,      3,      0,      0,  18432,    160, }, /* 1335 */
  {   164,     10,      5,      0,      0,  18432,    154, }, /* 1336 */
  {   164,     12,      3,      0,      0,  26624,    106, }, /* 1337 */
  {   164,     10,      3,      0,      0,  18432,    188, }, /* 1338 */
  {   164,     12,      3,      0,      0,  26624,    158, }, /* 1339 */
  {   164,      7,      4,      0,      0,  18432,     84, }, /* 1340 */
  {   164,     12,      3,      0,      0,  26624,     98, }, /* 1341 */
  {   164,     21,     12,      0,      0,  18432,    128, }, /* 1342 */
  {   164,     21,     12,      0,      0,  18432,     74, }, /* 1343 */
  {   164,     13,     12,      0,      0,  18432,    144, }, /* 1344 */
  {    87,      7,     12,      0,      0,  18432,     84, }, /* 1345 */
  {    87,     10,      5,      0,      0,  18432,    154, }, /* 1346 */
  {    87,     12,      3,      0,      0,  26624,    106, }, /* 1347 */
  {    87,     12,      3,      0,      0,  26624,    158, }, /* 1348 */
  {    87,     21,     12,      0,      0,  18432,     74, }, /* 1349 */
  {   156,      7,     12,      0,      0,  18432,     84, }, /* 1350 */
  {   156,     12,      3,      0,      0,  26624,    106, }, /* 1351 */
  {   156,     12,      3,      0,      0,  18432,    106, }, /* 1352 */
  {   156,     12,      3,      0,      0,  26624,    104, }, /* 1353 */
  {   156,     12,      3,      0,      0,  26624,    158, }, /* 1354 */
  {   156,     10,      5,      0,      0,  18432,    154, }, /* 1355 */
  {   156,      7,      4,      0,      0,  18432,     84, }, /* 1356 */
  {   156,     21,     12,      0,      0,  18432,     74, }, /* 1357 */
  {   156,     21,     12,      0,      0,  18432,    128, }, /* 1358 */
  {   155,      7,     12,      0,      0,  18432,     84, }, /* 1359 */
  {   155,     12,      3,      0,      0,  26624,    106, }, /* 1360 */
  {   155,     10,      5,      0,      0,  18432,    154, }, /* 1361 */
  {   155,      7,      4,      0,      0,  18432,     84, }, /* 1362 */
  {   155,     12,      3,      0,      0,  26624,    352, }, /* 1363 */
  {   155,     12,      3,      0,      0,  26624,    158, }, /* 1364 */
  {   155,     21,     12,      0,      0,  18432,     74, }, /* 1365 */
  {   155,     21,     12,      0,      0,  18432,    128, }, /* 1366 */
  {   155,     21,     12,      0,      0,  18432,    110, }, /* 1367 */
  {   144,      7,     12,      0,      0,  18432,     84, }, /* 1368 */
  {    95,      7,     12,      0,      0,  18432,     84, }, /* 1369 */
  {    95,     21,     12,      0,      0,  18432,     74, }, /* 1370 */
  {    95,     13,     12,      0,      0,  18432,    144, }, /* 1371 */
  {   151,      7,     12,      0,      0,  18432,     84, }, /* 1372 */
  {   151,     10,      5,      0,      0,  18432,    154, }, /* 1373 */
  {   151,     12,      3,      0,      0,  26624,    106, }, /* 1374 */
  {   151,     12,      3,      0,      0,  18432,    158, }, /* 1375 */
  {   151,     21,     12,      0,      0,  18432,    128, }, /* 1376 */
  {   151,     21,     12,      0,      0,  18432,    110, }, /* 1377 */
  {   151,     21,     12,      0,      0,  18432,     74, }, /* 1378 */
  {   151,     13,     12,      0,      0,  18432,    144, }, /* 1379 */
  {   151,     15,     12,      0,      0,  18432,     74, }, /* 1380 */
  {   152,     21,     12,      0,      0,  18432,     74, }, /* 1381 */
  {   152,     21,     12,      0,      0,  18432,    110, }, /* 1382 */
  {   152,      7,     12,      0,      0,  18432,     84, }, /* 1383 */
  {   152,     12,      3,      0,      0,  26624,    106, }, /* 1384 */
  {   152,     10,      5,      0,      0,  18432,    154, }, /* 1385 */
  {    82,      7,     12,      0,      0,  18432,     84, }, /* 1386 */
  {    82,     12,      3,      0,      0,  26624,    106, }, /* 1387 */
  {    82,     12,      3,      0,      0,  26624,     98, }, /* 1388 */
  {    82,     12,      3,      0,      0,  26624,    158, }, /* 1389 */
  {    82,      7,      4,      0,      0,  18432,     84, }, /* 1390 */
  {    82,     13,     12,      0,      0,  18432,    144, }, /* 1391 */
  {    84,      7,     12,      0,      0,  18432,     84, }, /* 1392 */
  {    84,     10,      5,      0,      0,  18432,    154, }, /* 1393 */
  {    84,     12,      3,      0,      0,  26624,    106, }, /* 1394 */
  {    84,     12,      3,      0,      0,  26624,    158, }, /* 1395 */
  {    84,     13,     12,      0,      0,  18432,    144, }, /* 1396 */
  {   157,      7,     12,      0,      0,  18432,     84, }, /* 1397 */
  {   157,     12,      3,      0,      0,  26624,    106, }, /* 1398 */
  {   157,     10,      5,      0,      0,  18432,    154, }, /* 1399 */
  {   157,     21,     12,      0,      0,  18432,    128, }, /* 1400 */
  {   168,     12,      3,      0,      0,  26624,    106, }, /* 1401 */
  {   168,      7,      4,      0,      0,  18432,     84, }, /* 1402 */
  {   168,     10,      5,      0,      0,  18432,    154, }, /* 1403 */
  {   168,      7,     12,      0,      0,  18432,     84, }, /* 1404 */
  {   168,     10,      3,      0,      0,  18432,    188, }, /* 1405 */
  {   168,     12,      3,      0,      0,  26624,    158, }, /* 1406 */
  {   168,     21,     12,      0,      0,  18432,    128, }, /* 1407 */
  {   168,     21,     12,      0,      0,  18432,     74, }, /* 1408 */
  {   168,     13,     12,      0,      0,  18432,    144, }, /* 1409 */
  {   168,     12,      3,      0,      0,  26624,     98, }, /* 1410 */
  {    13,     15,     12,      0,      0,  18432,     74, }, /* 1411 */
  {    13,     21,     12,      0,      0,  18432,     74, }, /* 1412 */
  {   114,      7,     12,      0,      0,  18432,     84, }, /* 1413 */
  {   114,     14,     12,      0,      0,  18432,     84, }, /* 1414 */
  {   114,     21,     12,      0,      0,  18432,    110, }, /* 1415 */
  {    89,      7,     12,      0,      0,  18432,     84, }, /* 1416 */
  {    89,     21,     12,      0,      0,  18432,     74, }, /* 1417 */
  {   125,      7,     12,      0,      0,  18432,     84, }, /* 1418 */
  {   125,      1,      2,      0,      0,  18432,    346, }, /* 1419 */
  {   125,     12,      3,      0,      0,  26624,    104, }, /* 1420 */
  {   125,     12,      3,      0,      0,  26624,     98, }, /* 1421 */
  {   148,      7,     12,      0,      0,  18432,     84, }, /* 1422 */
  {    93,      7,     12,      0,      0,  18432,     84, }, /* 1423 */
  {    93,     12,      3,      0,      0,  26624,    106, }, /* 1424 */
  {    93,     10,      5,      0,      0,  18432,    154, }, /* 1425 */
  {    93,     12,      3,      0,      0,  26624,    158, }, /* 1426 */
  {    93,     13,     12,      0,      0,  18432,    144, }, /* 1427 */
  {   140,      7,     12,      0,      0,  18432,     84, }, /* 1428 */
  {   140,     13,     12,      0,      0,  18432,    144, }, /* 1429 */
  {   140,     21,     12,      0,      0,  18432,    128, }, /* 1430 */
  {   166,      7,     12,      0,      0,  18432,     84, }, /* 1431 */
  {   166,     13,     12,      0,      0,  18432,    144, }, /* 1432 */
  {   137,      7,     12,      0,      0,  18432,     84, }, /* 1433 */
  {   137,     12,      3,      0,      0,  26624,     98, }, /* 1434 */
  {   137,     21,     12,      0,      0,  18432,    128, }, /* 1435 */
  {   138,      7,     12,      0,      0,  18432,     84, }, /* 1436 */
  {   138,     12,      3,      0,      0,  26624,     98, }, /* 1437 */
  {   138,     21,     12,      0,      0,  18432,    128, }, /* 1438 */
  {   138,     21,     12,      0,      0,  18432,    110, }, /* 1439 */
  {   138,     21,     12,      0,      0,  18432,     74, }, /* 1440 */
  {   138,     26,     12,      0,      0,  18432,     74, }, /* 1441 */
  {   138,      6,     12,      0,      0,  18432,    148, }, /* 1442 */
  {   138,      6,     12,      0,      0,  18432,    138, }, /* 1443 */
  {   138,     13,     12,      0,      0,  18432,    144, }, /* 1444 */
  {   138,     15,     12,      0,      0,  18432,     74, }, /* 1445 */
  {   170,      6,     12,      0,      0,  18432,    148, }, /* 1446 */
  {   170,      7,     12,      0,      0,  18432,     84, }, /* 1447 */
  {   170,      7,      7,      0,      0,  18432,     84, }, /* 1448 */
  {   170,      6,     12,      0,      0,  18432,     94, }, /* 1449 */
  {   170,     21,     12,      0,      0,  18432,     74, }, /* 1450 */
  {   170,     21,     12,      0,      0,  18432,    128, }, /* 1451 */
  {   170,     13,     12,      0,      0,  18432,    144, }, /* 1452 */
  {   158,      9,     12,      0,     32,  18432,     76, }, /* 1453 */
  {   158,      5,     12,      0,    -32,  18432,     78, }, /* 1454 */
  {   158,     15,     12,      0,      0,  18432,     74, }, /* 1455 */
  {   158,     21,     12,      0,      0,  18432,    110, }, /* 1456 */
  {   158,     21,     12,      0,      0,  18432,    128, }, /* 1457 */
  {   158,     21,     12,      0,      0,  18432,     74, }, /* 1458 */
  {   135,      7,     12,      0,      0,  18432,     84, }, /* 1459 */
  {   135,     12,      3,      0,      0,  26624,    106, }, /* 1460 */
  {   135,     10,      5,      0,      0,  18432,    154, }, /* 1461 */
  {   135,     12,      3,      0,      0,  26624,    132, }, /* 1462 */
  {   135,      6,     12,      0,      0,  18432,     94, }, /* 1463 */
  {    81,      6,     12,      0,      0,  18432,    138, }, /* 1464 */
  {   154,      6,     12,      0,      0,  18432,    138, }, /* 1465 */
  {    30,     21,     12,      0,      0,  28672,     74, }, /* 1466 */
  {   165,     12,      3,      0,      0,  26624,    354, }, /* 1467 */
  {    30,     10,      3,      0,      0,  18432,    356, }, /* 1468 */
  {    81,      7,     12,      0,      0,  18432,    304, }, /* 1469 */
  {   165,      7,     12,      0,      0,  18432,    304, }, /* 1470 */
  {    28,      6,     12,      0,      0,  18432,     94, }, /* 1471 */
  {   154,      7,     12,      0,      0,  18432,    304, }, /* 1472 */
  {    65,      7,     12,      0,      0,  18432,     84, }, /* 1473 */
  {    65,     26,     12,      0,      0,  18432,     74, }, /* 1474 */
  {    65,     12,      3,      0,      0,  26624,    104, }, /* 1475 */
  {    65,     12,      3,      0,      0,  26624,    106, }, /* 1476 */
  {    65,     21,     12,      0,      0,  18432,    128, }, /* 1477 */
  {    99,      1,      2,      0,      0,   6472,     66, }, /* 1478 */
  {    99,     13,     12,      0,      0,  10240,    144, }, /* 1479 */
  {    99,     10,      3,      0,      0,  18432,    358, }, /* 1480 */
  {    99,     10,      3,      0,      0,  18432,    306, }, /* 1481 */
  {     1,     12,      3,      0,      0,  26624,    104, }, /* 1482 */
  {    99,     25,     12,      0,      0,  28672,    360, }, /* 1483 */
  {    99,     13,     12,      0,      0,  10240,    226, }, /* 1484 */
  {   150,     26,     12,      0,      0,  18432,     74, }, /* 1485 */
  {   150,     12,      3,      0,      0,  26624,    104, }, /* 1486 */
  {   150,     21,     12,      0,      0,  18432,    110, }, /* 1487 */
  {   150,     21,     12,      0,      0,  18432,    128, }, /* 1488 */
  {   150,     21,     12,      0,      0,  18432,     74, }, /* 1489 */
  {    44,     12,      3,      0,      0,  26624,    106, }, /* 1490 */
  {     2,      6,     12,      0,      0,  18432,     92, }, /* 1491 */
  {   161,      7,     12,      0,      0,  18432,     84, }, /* 1492 */
  {   161,     12,      3,      0,      0,  26624,     98, }, /* 1493 */
  {   161,      6,     12,      0,      0,  18432,    148, }, /* 1494 */
  {   161,      6,     12,      0,      0,  18432,    138, }, /* 1495 */
  {   161,     13,     12,      0,      0,  18432,    144, }, /* 1496 */
  {   161,     26,     12,      0,      0,  18432,     74, }, /* 1497 */
  {    91,      7,     12,      0,      0,  18432,     84, }, /* 1498 */
  {    91,     12,      3,      0,      0,  26624,     98, }, /* 1499 */
  {   162,      7,     12,      0,      0,  18432,     84, }, /* 1500 */
  {   162,     12,      3,      0,      0,  26624,     98, }, /* 1501 */
  {   162,     13,     12,      0,      0,  18432,    144, }, /* 1502 */
  {   162,     23,     12,      0,      0,  14336,     74, }, /* 1503 */
  {   169,      7,     12,      0,      0,  18432,     84, }, /* 1504 */
  {   169,      6,     12,      0,      0,  18432,    148, }, /* 1505 */
  {   169,     12,      3,      0,      0,  26624,    104, }, /* 1506 */
  {   169,     13,     12,      0,      0,  18432,    144, }, /* 1507 */
  {    94,      7,     12,      0,      0,  18432,     84, }, /* 1508 */
  {    94,     12,      3,      0,      0,  26624,     98, }, /* 1509 */
  {    94,     12,      3,      0,      0,  26624,    164, }, /* 1510 */
  {    94,     13,     12,      0,      0,  18432,    144, }, /* 1511 */
  {    94,     21,     12,      0,      0,  18432,     74, }, /* 1512 */
  {   139,      7,     12,      0,      0,  34816,     84, }, /* 1513 */
  {   139,     15,     12,      0,      0,  34816,     74, }, /* 1514 */
  {   139,     12,      3,      0,      0,  26624,     98, }, /* 1515 */
  {    79,      9,     12,      0,     34,  34816,     76, }, /* 1516 */
  {    79,      5,     12,      0,    -34,  34816,     78, }, /* 1517 */
  {    79,     12,      3,      0,      0,  26624,    164, }, /* 1518 */
  {    79,     12,      3,      0,      0,  26624,    106, }, /* 1519 */
  {    79,     12,      3,      0,      0,  26624,     98, }, /* 1520 */
  {    79,      6,     12,      0,      0,  34816,    148, }, /* 1521 */
  {    79,     13,     12,      0,      0,  34816,    144, }, /* 1522 */
  {    79,     21,     12,      0,      0,  34816,     74, }, /* 1523 */
  {    99,     15,     12,      0,      0,      0,     74, }, /* 1524 */
  {    99,     26,     12,      0,      0,      0,     74, }, /* 1525 */
  {    99,     23,     12,      0,      0,      0,     74, }, /* 1526 */
  {     5,      7,     12,      0,      0,      0,    254, }, /* 1527 */
  {    99,     26,     14,      0,      0,  28672,    362, }, /* 1528 */
  {    99,     26,     14,      0,      0,  28672,    364, }, /* 1529 */
  {    98,      2,     14,      0,      0,  18432,    366, }, /* 1530 */
  {    99,     26,     12,      0,      0,  18432,    368, }, /* 1531 */
  {    99,     26,     14,      0,      0,  18432,    370, }, /* 1532 */
  {    99,     26,     14,      0,      0,  18432,    364, }, /* 1533 */
  {    99,     26,     11,      0,      0,  18432,    372, }, /* 1534 */
  {    27,     26,     12,      0,      0,  18432,     74, }, /* 1535 */
  {    99,     26,     14,      0,      0,  18432,    250, }, /* 1536 */
  {    99,     26,     14,      0,      0,  18784,    364, }, /* 1537 */
  {    99,     26,     14,      0,      0,  28672,    374, }, /* 1538 */
  {    99,     26,     14,      0,      0,  28672,    376, }, /* 1539 */
  {    99,     24,      3,      0,      0,  28672,    378, }, /* 1540 */
  {    99,     26,     14,      0,      0,  28672,    380, }, /* 1541 */
  {    99,      1,      3,      0,      0,   6144,    382, }, /* 1542 */
};

const uint16_t PRIV(ucd_stage1)[] = { /* 17408 bytes */
  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, /* U+0000 */
 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, /* U+0800 */
 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 41, 41, 42, 43, 44, 45, /* U+1000 */
 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, /* U+1800 */
 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, /* U+2000 */
 78, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, /* U+2800 */
 93, 94, 95, 96, 97, 98, 99,100,101,101,101,101,101,101,101,101, /* U+3000 */
101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101, /* U+3800 */
101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101, /* U+4000 */
101,101,101,101,101,101,101,101,101,101,101,102,101,101,101,101, /* U+4800 */
101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101, /* U+5000 */
101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101, /* U+5800 */
101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101, /* U+6000 */
101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101, /* U+6800 */
101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101, /* U+7000 */
101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101, /* U+7800 */
101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101, /* U+8000 */
101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101, /* U+8800 */
101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101, /* U+9000 */
101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101, /* U+9800 */
103,104,104,104,104,104,104,104,104,105,106,106,107,108,109,110, /* U+A000 */
111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,119, /* U+A800 */
120,121,122,123,124,125,119,120,121,122,123,124,125,119,120,121, /* U+B000 */
122,123,124,125,119,120,121,122,123,124,125,119,120,121,122,123, /* U+B800 */
124,125,119,120,121,122,123,124,125,119,120,121,122,123,124,125, /* U+C000 */
119,120,121,122,123,124,125,119,120,121,122,123,124,125,119,120, /* U+C800 */
121,122,123,124,125,119,120,121,122,123,124,125,119,120,121,126, /* U+D000 */
127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127, /* U+D800 */
128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128, /* U+E000 */
128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128, /* U+E800 */
128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128, /* U+F000 */
128,128,129,129,130,131,132,133,134,135,136,137,138,139,140,141, /* U+F800 */
142,143,144,145,146,147,148,149,150,151,152,153,154,154,155,156, /* U+10000 */
157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172, /* U+10800 */
173,174,175,176,177,178,179,180,181,182,146,183,184,185,186,146, /* U+11000 */
187,188,189,190,191,192,193,194,195,196,197,198,146,199,200,201, /* U+11800 */
202,202,202,202,202,202,202,203,204,202,205,146,146,146,146,146, /* U+12000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,206, /* U+12800 */
207,207,207,207,207,207,207,207,208,207,207,207,207,207,207,207, /* U+13000 */
207,207,207,207,207,207,207,207,207,207,207,207,207,207,207,207, /* U+13800 */
207,207,207,207,207,207,207,209,210,210,210,210,211,146,146,146, /* U+14000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+14800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+15000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+15800 */
146,146,212,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+16000 */
213,213,213,213,214,215,216,217,146,146,218,146,219,220,221,222, /* U+16800 */
223,223,223,223,223,223,223,223,223,223,223,223,223,223,223,223, /* U+17000 */
223,223,223,223,223,223,223,223,223,223,223,223,223,223,223,223, /* U+17800 */
223,223,223,223,223,223,223,223,223,223,223,223,223,223,223,224, /* U+18000 */
223,223,223,223,223,223,225,225,225,226,227,146,146,146,146,146, /* U+18800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+19000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+19800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+1A000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,228, /* U+1A800 */
229,230,231,232,232,233,146,146,146,146,146,146,146,146,146,146, /* U+1B000 */
146,146,146,146,146,146,146,146,234,235,146,146,146,146,146,146, /* U+1B800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+1C000 */
146,146,146,146,146,146,146,146,236,237,236,236,236,238,239,240, /* U+1C800 */
241,242,243,244,245,246,247,146,248,249,250,251,252,253,254,255, /* U+1D000 */
256,256,256,256,257,258,146,146,146,146,146,146,146,146,259,146, /* U+1D800 */
260,261,262,146,146,263,146,146,146,264,146,265,146,146,146,266, /* U+1E000 */
267,268,269,270,270,270,270,270,271,272,273,270,274,275,270,270, /* U+1E800 */
276,277,278,279,280,281,282,283,284,285,286,287,288,289,290,291, /* U+1F000 */
292,293,294,295,296,297,236,298,281,281,281,281,281,281,281,299, /* U+1F800 */
101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101, /* U+20000 */
101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101, /* U+20800 */
101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101, /* U+21000 */
101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101, /* U+21800 */
101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101, /* U+22000 */
101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101, /* U+22800 */
101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101, /* U+23000 */
101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101, /* U+23800 */
101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101, /* U+24000 */
101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101, /* U+24800 */
101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101, /* U+25000 */
101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101, /* U+25800 */
101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101, /* U+26000 */
101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101, /* U+26800 */
101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101, /* U+27000 */
101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101, /* U+27800 */
101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101, /* U+28000 */
101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101, /* U+28800 */
101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101, /* U+29000 */
101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101, /* U+29800 */
101,101,101,101,101,101,101,101,101,101,101,101,101,300,101,101, /* U+2A000 */
101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101, /* U+2A800 */
101,101,101,101,101,101,101,101,101,101,101,101,101,101,301,101, /* U+2B000 */
302,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101, /* U+2B800 */
101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101, /* U+2C000 */
101,101,101,101,101,101,101,101,101,101,101,101,101,303,101,101, /* U+2C800 */
101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101, /* U+2D000 */
101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101, /* U+2D800 */
101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101, /* U+2E000 */
101,101,101,101,101,101,101,304,101,101,101,101,305,146,146,146, /* U+2E800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+2F000 */
129,129,129,129,306,146,146,146,146,146,146,146,146,146,146,307, /* U+2F800 */
101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101, /* U+30000 */
101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101, /* U+30800 */
101,101,101,101,101,101,308,101,101,101,101,101,101,101,101,101, /* U+31000 */
101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101, /* U+31800 */
101,101,101,101,101,101,101,309,146,146,146,146,146,146,146,146, /* U+32000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+32800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+33000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+33800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+34000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+34800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+35000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+35800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+36000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+36800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+37000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+37800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+38000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+38800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+39000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+39800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+3A000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+3A800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+3B000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+3B800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+3C000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+3C800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+3D000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+3D800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+3E000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+3E800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+3F000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,307, /* U+3F800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+40000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+40800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+41000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+41800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+42000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+42800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+43000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+43800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+44000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+44800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+45000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+45800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+46000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+46800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+47000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+47800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+48000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+48800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+49000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+49800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+4A000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+4A800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+4B000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+4B800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+4C000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+4C800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+4D000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+4D800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+4E000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+4E800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+4F000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,307, /* U+4F800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+50000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+50800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+51000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+51800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+52000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+52800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+53000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+53800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+54000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+54800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+55000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+55800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+56000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+56800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+57000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+57800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+58000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+58800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+59000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+59800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+5A000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+5A800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+5B000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+5B800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+5C000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+5C800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+5D000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+5D800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+5E000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+5E800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+5F000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,307, /* U+5F800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+60000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+60800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+61000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+61800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+62000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+62800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+63000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+63800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+64000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+64800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+65000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+65800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+66000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+66800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+67000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+67800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+68000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+68800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+69000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+69800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+6A000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+6A800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+6B000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+6B800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+6C000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+6C800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+6D000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+6D800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+6E000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+6E800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+6F000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,307, /* U+6F800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+70000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+70800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+71000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+71800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+72000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+72800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+73000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+73800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+74000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+74800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+75000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+75800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+76000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+76800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+77000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+77800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+78000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+78800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+79000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+79800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+7A000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+7A800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+7B000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+7B800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+7C000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+7C800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+7D000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+7D800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+7E000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+7E800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+7F000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,307, /* U+7F800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+80000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+80800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+81000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+81800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+82000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+82800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+83000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+83800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+84000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+84800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+85000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+85800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+86000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+86800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+87000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+87800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+88000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+88800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+89000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+89800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+8A000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+8A800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+8B000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+8B800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+8C000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+8C800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+8D000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+8D800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+8E000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+8E800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+8F000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,307, /* U+8F800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+90000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+90800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+91000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+91800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+92000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+92800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+93000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+93800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+94000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+94800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+95000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+95800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+96000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+96800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+97000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+97800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+98000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+98800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+99000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+99800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+9A000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+9A800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+9B000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+9B800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+9C000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+9C800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+9D000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+9D800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+9E000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+9E800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+9F000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,307, /* U+9F800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+A0000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+A0800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+A1000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+A1800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+A2000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+A2800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+A3000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+A3800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+A4000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+A4800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+A5000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+A5800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+A6000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+A6800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+A7000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+A7800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+A8000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+A8800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+A9000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+A9800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+AA000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+AA800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+AB000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+AB800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+AC000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+AC800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+AD000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+AD800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+AE000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+AE800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+AF000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,307, /* U+AF800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+B0000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+B0800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+B1000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+B1800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+B2000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+B2800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+B3000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+B3800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+B4000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+B4800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+B5000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+B5800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+B6000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+B6800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+B7000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+B7800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+B8000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+B8800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+B9000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+B9800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+BA000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+BA800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+BB000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+BB800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+BC000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+BC800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+BD000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+BD800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+BE000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+BE800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+BF000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,307, /* U+BF800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+C0000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+C0800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+C1000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+C1800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+C2000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+C2800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+C3000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+C3800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+C4000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+C4800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+C5000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+C5800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+C6000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+C6800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+C7000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+C7800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+C8000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+C8800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+C9000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+C9800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+CA000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+CA800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+CB000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+CB800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+CC000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+CC800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+CD000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+CD800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+CE000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+CE800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+CF000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,307, /* U+CF800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+D0000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+D0800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+D1000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+D1800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+D2000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+D2800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+D3000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+D3800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+D4000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+D4800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+D5000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+D5800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+D6000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+D6800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+D7000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+D7800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+D8000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+D8800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+D9000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+D9800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+DA000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+DA800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+DB000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+DB800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+DC000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+DC800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+DD000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+DD800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+DE000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+DE800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+DF000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,307, /* U+DF800 */
310,311,312,313,311,311,311,311,311,311,311,311,311,311,311,311, /* U+E0000 */
311,311,311,311,311,311,311,311,311,311,311,311,311,311,311,311, /* U+E0800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+E1000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+E1800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+E2000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+E2800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+E3000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+E3800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+E4000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+E4800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+E5000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+E5800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+E6000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+E6800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+E7000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+E7800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+E8000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+E8800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+E9000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+E9800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+EA000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+EA800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+EB000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+EB800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+EC000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+EC800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+ED000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+ED800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+EE000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+EE800 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,146, /* U+EF000 */
146,146,146,146,146,146,146,146,146,146,146,146,146,146,146,307, /* U+EF800 */
128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128, /* U+F0000 */
128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128, /* U+F0800 */
128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128, /* U+F1000 */
128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128, /* U+F1800 */
128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128, /* U+F2000 */
128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128, /* U+F2800 */
128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128, /* U+F3000 */
128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128, /* U+F3800 */
128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128, /* U+F4000 */
128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128, /* U+F4800 */
128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128, /* U+F5000 */
128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128, /* U+F5800 */
128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128, /* U+F6000 */
128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128, /* U+F6800 */
128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128, /* U+F7000 */
128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128, /* U+F7800 */
128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128, /* U+F8000 */
128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128, /* U+F8800 */
128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128, /* U+F9000 */
128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128, /* U+F9800 */
128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128, /* U+FA000 */
128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128, /* U+FA800 */
128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128, /* U+FB000 */
128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128, /* U+FB800 */
128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128, /* U+FC000 */
128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128, /* U+FC800 */
128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128, /* U+FD000 */
128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128, /* U+FD800 */
128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128, /* U+FE000 */
128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128, /* U+FE800 */
128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128, /* U+FF000 */
128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,314, /* U+FF800 */
128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128, /* U+100000 */
128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128, /* U+100800 */
128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128, /* U+101000 */
128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128, /* U+101800 */
128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128, /* U+102000 */
128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128, /* U+102800 */
128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128, /* U+103000 */
128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128, /* U+103800 */
128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128, /* U+104000 */
128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128, /* U+104800 */
128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128, /* U+105000 */
128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128, /* U+105800 */
128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128, /* U+106000 */
128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128, /* U+106800 */
128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128, /* U+107000 */
128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128, /* U+107800 */
128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128, /* U+108000 */
128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128, /* U+108800 */
128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128, /* U+109000 */
128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128, /* U+109800 */
128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128, /* U+10A000 */
128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128, /* U+10A800 */
128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128, /* U+10B000 */
128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128, /* U+10B800 */
128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128, /* U+10C000 */
128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128, /* U+10C800 */
128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128, /* U+10D000 */
128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128, /* U+10D800 */
128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128, /* U+10E000 */
128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128, /* U+10E800 */
128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128, /* U+10F000 */
128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,314, /* U+10F800 */
};

const uint16_t PRIV(ucd_stage2)[] = { /* 80640 bytes, block = 128 */

/* block 0 */
  0,  0,  0,  0,  0,  0,  0,  0,  0,  1,  2,  1,  3,  4,  0,  0,
  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  5,  5,  5,  6,
  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22,
 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 24, 25, 26, 27, 26,  8,
 13, 28, 28, 28, 28, 28, 28, 29, 29, 29, 29, 30, 29, 29, 29, 29,
 29, 29, 29, 31, 29, 29, 29, 29, 29, 29, 29, 15, 13, 16, 32, 33,
 34, 35, 35, 35, 35, 35, 35, 36, 36, 37, 37, 38, 36, 36, 36, 36,
 36, 36, 36, 39, 36, 36, 36, 36, 36, 36, 36, 15, 27, 16, 27,  0,

/* block 1 */
 40, 40, 40, 40, 40, 41, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
 42, 43, 44, 44, 44, 44, 45, 43, 46, 47, 48, 49, 50, 51, 47, 46,
 52, 53, 54, 54, 46, 55, 43, 56, 46, 54, 48, 57, 58, 58, 58, 43,
 59, 59, 59, 59, 59, 60, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
 59, 59, 59, 59, 59, 59, 59, 50, 59, 59, 59, 59, 59, 59, 59, 61,
 62, 62, 62, 62, 62, 63, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62,
 62, 62, 62, 62, 62, 62, 62, 50, 62, 62, 62, 62, 62, 62, 62, 64,

/* block 2 */
 65, 66, 65, 66, 65, 66, 65, 66, 65, 66, 65, 66, 65, 66, 65, 66,
 65, 66, 65, 66, 65, 66, 65, 66, 65, 66, 65, 66, 65, 66, 65, 66,
 65, 66, 65, 66, 65, 66, 65, 66, 65, 66, 65, 66, 65, 66, 65, 67,
 68, 69, 65, 66, 65, 66, 65, 66, 70, 65, 66, 65, 66, 65, 66, 65,
 66, 65, 66, 65, 66, 65, 66, 65, 66, 71, 65, 66, 65, 66, 65, 66,
 65, 66, 65, 66, 65, 66, 65, 66, 65, 66, 65, 66, 65, 66, 65, 66,
 65, 66, 65, 66, 65, 66, 65, 66, 65, 66, 65, 66, 65, 66, 65, 66,
 65, 66, 65, 66, 65, 66, 65, 66, 72, 65, 66, 65, 66, 65, 66, 73,

/* block 3 */
 74, 75, 65, 66, 65, 66, 76, 65, 66, 77, 77, 65, 66, 70, 78, 79,
 80, 65, 66, 77, 81, 82, 83, 84, 65, 66, 85, 86, 83, 87, 88, 89,
 65, 66, 65, 66, 65, 66, 90, 65, 66, 90, 70, 70, 65, 66, 90, 65,
 66, 91, 91, 65, 66, 65, 66, 92, 65, 66, 70, 93, 65, 66, 70, 94,
 93, 93, 93, 93, 95, 96, 97, 98, 99,100,101,102,103, 65, 66, 65,
 66, 65, 66, 65, 66, 65, 66, 65, 66, 65, 66, 65, 66,104, 65, 66,
 65, 66, 65, 66, 65, 66, 65, 66, 65, 66, 65, 66, 65, 66, 65, 66,
 69,105,106,107, 65, 66,108,109, 65, 66, 65, 66, 65, 66, 65, 66,

/* block 4 */
 65, 66, 65, 66, 65, 66, 65, 66, 65, 66, 65, 66, 65, 66, 65, 66,
 65, 66, 65, 66, 65, 66, 65, 66, 65, 66, 65, 66, 65, 66, 65, 66,
110, 70, 65, 66, 65, 66, 65, 66, 65, 66, 65, 66, 65, 66, 65, 66,
 65, 66, 65, 66, 70, 70, 70, 70, 70, 70,111, 65, 66,112,113,114,
114, 65, 66,115,116,117, 65, 66, 65, 67, 65, 66, 65, 66, 65, 66,
118,119,120,121,122, 70,123,123, 70,124, 70,125,126, 70, 70, 70,
123,127, 70,128,129,130,131, 70,132,133,131,134,135, 70, 70,133,
 70,136,137, 70, 70,138, 70, 70, 70, 70, 70, 70, 70,139, 70, 70,

/* block 5 */
140, 70,141,140, 70, 70, 70,142,140,143,144,144,145, 70, 70, 70,
 70, 70,146, 70, 93, 70, 70, 70, 70, 70, 70, 70, 70,147,148, 70,
 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70,
149,149,150,149,149,149,149,149,149,151,151,152,153,152,152,152,
154,154, 46, 46, 46, 46,151,155,151,155,155,155,151,156,151,151,
157,157, 46, 46, 46, 46, 46,158, 46,159, 46, 46, 46, 46, 46, 46,
149,149,149,149,149, 46, 46, 46, 46, 46,160,160,151, 46,152, 46,
 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,

/* block 6 */
161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,
174,177,176,178,176,176,176,176,176,176,176,176,176,176,176,176,
179,176,176,180,181,179,176,176,176,176,176,176,176,182,179,176,
183,184,176,176,176,176,176,176,176,176,176,176,176,176,176,176,
176,176,185,176,176,186,176,176,176,176,176,176,176,176,176,187,
176,176,176,176,176,176,176,176,188,189,189,189,189,176,190,176,
176,176,176,191,191,191,191,191,191,191,191,191,191,191,191,191,
192,193,192,193,194,195,192,193,196,196,197,198,198,198,199,200,

/* block 7 */
196,196,196,196,201, 46,202,203,204,204,204,196,205,196,206,206,
207,208,209,208,208,210,208,208,211,212,213,208,214,208,208,208,
215,216,196,217,208,208,218,208,208,219,208,208,220,221,221,221,
222,223,224,223,223,225,223,223,226,227,228,223,229,223,223,223,
230,231,232,233,223,223,234,223,223,235,223,223,236,237,237,238,
239,240,241,242,242,243,244,245,192,193,192,193,192,193,192,193,
192,193,246,247,246,247,246,247,246,247,246,247,246,247,246,247,
248,249,250,251,252,253,254,192,193,255,192,193,256,257,257,257,

/* block 8 */
258,258,258,258,258,258,258,258,258,258,258,258,258,258,258,258,
259,259,260,259,261,259,259,259,259,259,259,259,259,259,262,259,
259,263,264,259,259,259,259,259,259,259,265,259,259,259,259,259,
266,266,267,266,268,266,266,266,266,266,266,266,266,266,269,266,
266,270,271,266,266,266,266,266,266,266,272,266,266,266,266,266,
273,273,273,273,273,273,274,273,274,273,273,273,273,273,273,273,
275,276,277,278,275,276,275,276,275,276,275,276,275,276,275,276,
275,276,275,276,275,276,275,276,275,276,275,276,275,276,275,276,

/* block 9 */
275,276,279,280,281,282,282,281,283,283,275,276,275,276,275,276,
275,276,275,276,275,276,275,276,275,276,275,276,275,276,275,276,
275,276,275,276,275,276,275,276,275,276,275,276,275,276,275,276,
275,276,275,276,275,276,275,276,275,276,275,276,275,276,275,276,
284,275,276,275,276,275,276,275,276,275,276,275,276,275,276,285,
275,276,275,276,275,276,275,276,275,276,275,276,275,276,275,276,
275,276,275,276,275,276,275,276,275,276,275,276,275,276,275,276,
275,276,275,276,275,276,275,276,275,276,275,276,275,276,275,276,

/* block 10 */
275,276,275,276,275,276,275,276,275,276,275,276,275,276,275,276,
275,276,275,276,275,276,275,276,275,276,275,276,275,276,275,276,
275,276,275,276,275,276,275,276,275,276,275,276,275,276,275,276,
196,286,286,286,286,286,286,286,286,286,286,286,286,286,286,286,
286,286,286,286,286,286,286,286,286,286,286,286,286,286,286,286,
286,286,286,286,286,286,286,196,196,287,288,288,288,288,288,289,
290,291,291,291,291,291,291,291,291,291,291,291,291,291,291,291,
291,291,291,291,291,291,291,291,291,291,291,291,291,291,291,291,

/* block 11 */
291,291,291,291,291,291,291,292,290,293,294,196,196,295,295,296,
297,298,298,298,298,298,298,298,298,298,298,298,298,298,298,298,
298,298,299,298,298,298,298,298,298,298,298,298,298,298,298,298,
300,300,300,300,300,300,300,300,300,300,300,300,300,300,301,300,
302,300,300,303,300,304,302,304,297,297,297,297,297,297,297,297,
305,305,305,305,305,305,305,305,305,305,305,305,305,305,305,305,
305,305,305,305,305,305,305,305,305,305,305,297,297,297,297,305,
305,305,305,302,306,297,297,297,297,297,297,297,297,297,297,297,

/* block 12 */
307,307,307,307,307,308,309,309,310,311,311,312,313,314,315,315,
316,316,316,316,316,316,316,316,316,316,316,317,318,319,319,320,
321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,
321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,
322,321,321,321,321,321,321,321,321,321,321,323,323,323,323,323,
323,323,323,324,325,325,316,326,327,316,316,316,316,316,316,316,
328,328,328,328,328,328,328,328,328,328,311,329,329,314,321,321,
324,321,321,330,321,321,321,321,321,321,321,321,321,321,321,321,

/* block 13 */
321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,
321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,
321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,
321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,
321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,
321,321,321,321,331,321,316,316,316,316,316,316,332,308,315,333,
333,316,316,332,316,334,334,332,332,315,333,333,333,316,321,321,
335,335,335,335,335,335,335,335,335,335,321,321,321,336,336,321,

/* block 14 */
337,337,337,338,338,338,338,338,338,338,338,339,338,339,340,341,
342,343,342,342,342,342,342,342,342,342,342,342,342,342,342,342,
342,342,342,342,342,342,342,342,342,342,342,342,342,342,342,342,
344,344,344,344,344,344,344,344,344,344,344,344,344,344,344,344,
345,345,345,345,345,345,345,345,345,345,345,340,340,342,342,342,
321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,
321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,
321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,

/* block 15 */
346,346,346,346,346,346,346,346,346,346,346,346,346,346,346,346,
346,346,346,346,346,346,346,346,346,346,346,346,346,346,346,346,
346,346,346,346,346,346,347,347,347,347,347,347,347,347,347,347,
347,346,340,340,340,340,340,340,340,340,340,340,340,340,340,340,
348,348,348,348,348,348,348,348,348,348,349,349,349,349,349,349,
349,349,349,349,349,349,349,349,349,349,349,349,349,349,349,349,
349,349,349,349,349,349,349,349,349,349,349,350,350,350,350,350,
350,350,350,350,351,351,352,353,354,355,356,297,297,357,358,358,

/* block 16 */
359,359,359,359,359,359,359,359,359,359,359,359,359,359,359,359,
359,359,359,359,359,359,360,360,361,361,362,360,360,360,360,360,
360,360,360,360,362,360,360,360,362,360,360,360,360,363,297,297,
364,364,364,364,364,364,365,366,364,366,364,364,364,366,366,297,
367,367,367,367,367,367,367,367,367,367,367,367,367,367,367,367,
367,367,367,367,367,367,367,367,367,368,368,368,297,297,369,297,
342,342,342,342,342,342,342,342,342,342,342,340,340,340,340,340,
321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,

/* block 17 */
321,321,321,321,321,321,321,321,370,321,321,321,321,321,321,340,
307,307,340,340,340,340,340,316,333,333,333,333,333,333,333,333,
321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,
321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,
321,321,321,321,321,321,321,321,321,334,327,327,333,327,327,327,
333,333,333,371,316,316,316,316,316,316,316,316,316,316,316,316,
372,372,308,326,326,326,326,326,326,326,333,333,333,333,333,333,
326,326,326,373,326,326,326,326,326,326,326,326,326,326,326,316,

/* block 18 */
374,374,374,375,376,376,376,376,376,376,376,376,376,376,376,376,
376,376,376,376,376,377,377,377,377,377,377,377,377,377,377,377,
377,377,377,377,377,377,377,377,377,377,377,377,377,377,377,377,
377,377,377,377,377,377,377,377,377,377,374,375,378,376,375,375,
375,374,374,374,374,374,374,374,374,375,375,375,375,379,375,375,
376,380,381,176,176,374,374,374,377,377,377,377,377,377,377,377,
376,376,374,374,382,383,384,384,384,384,384,384,384,384,384,384,
385,386,376,376,376,376,376,376,377,377,377,377,377,377,377,377,

/* block 19 */
387,388,389,389,196,387,387,387,387,387,387,387,387,196,196,387,
387,196,196,387,387,390,390,390,390,390,390,390,390,390,390,390,
390,390,390,390,390,390,390,390,390,196,390,390,390,390,390,390,
390,196,390,196,196,196,390,390,390,390,196,196,391,387,392,389,
389,388,388,388,388,196,196,389,389,196,196,389,389,393,387,196,
196,196,196,196,196,196,196,392,196,196,196,196,390,390,196,390,
387,387,388,388,196,196,394,394,394,394,394,394,394,394,394,394,
390,390,395,395,396,396,396,396,396,396,397,395,387,398,399,196,

/* block 20 */
196,400,400,401,196,402,402,402,402,402,402,196,196,196,196,402,
402,196,196,402,402,402,402,402,402,402,402,402,402,402,402,402,
402,402,402,402,402,402,402,402,402,196,402,402,402,402,402,402,
402,196,402,402,196,402,402,196,402,402,196,196,403,196,401,401,
401,400,400,196,196,196,196,400,400,196,196,400,400,404,196,196,
196,400,196,196,196,196,196,196,196,402,402,402,402,196,402,196,
196,196,196,196,196,196,405,405,405,405,405,405,405,405,405,405,
400,406,402,402,402,400,407,196,196,196,196,196,196,196,196,196,

/* block 21 */
196,408,408,409,196,410,410,410,410,410,410,410,410,410,196,410,
410,410,196,410,410,411,411,411,411,411,411,411,411,411,411,411,
411,411,411,411,411,411,411,411,411,196,411,411,411,411,411,411,
411,196,411,411,196,411,411,411,411,411,196,196,412,410,409,409,
409,408,408,408,408,408,196,408,408,409,196,409,409,413,196,196,
410,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
410,410,408,408,196,196,414,414,414,414,414,414,414,414,414,414,
415,416,196,196,196,196,196,196,196,411,408,417,408,412,412,412,

/* block 22 */
196,418,419,419,196,420,420,420,420,420,420,420,420,196,196,420,
420,196,196,420,420,421,421,421,421,421,421,421,421,421,421,421,
421,421,421,421,421,421,421,421,421,196,421,421,421,421,421,421,
421,196,421,421,196,421,421,421,421,421,196,196,422,420,423,418,
419,418,418,418,418,196,196,419,419,196,196,419,419,424,196,196,
196,196,196,196,196,425,418,423,196,196,196,196,421,421,196,421,
420,420,418,418,196,196,426,426,426,426,426,426,426,426,426,426,
427,421,428,428,428,428,428,428,196,196,196,196,196,196,196,196,

/* block 23 */
196,196,429,430,196,430,430,430,430,430,430,196,196,196,430,430,
430,196,430,430,430,430,196,196,196,430,430,196,430,196,430,430,
196,196,196,430,430,196,196,196,430,430,430,196,196,196,430,430,
430,430,430,430,430,430,430,430,430,430,196,196,196,196,431,432,
429,432,432,196,196,196,432,432,432,196,432,432,432,433,196,196,
430,196,196,196,196,196,196,431,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,434,434,434,434,434,434,434,434,434,434,
435,435,435,436,437,437,437,437,437,438,437,196,196,196,196,196,

/* block 24 */
439,440,440,440,439,441,441,441,441,441,441,441,441,196,441,441,
441,196,441,441,441,442,442,442,442,442,442,442,442,442,442,442,
442,442,442,442,442,442,442,442,442,196,442,442,442,442,442,442,
442,442,442,442,442,442,442,442,442,442,196,196,443,441,439,439,
439,440,440,440,440,196,439,439,439,196,439,439,439,444,196,196,
196,196,196,196,196,439,439,196,442,442,442,196,196,441,196,196,
441,441,439,439,196,196,445,445,445,445,445,445,445,445,445,445,
196,196,196,196,196,196,196,446,447,447,447,447,447,447,447,448,

/* block 25 */
449,450,451,451,452,449,449,449,449,449,449,449,449,196,449,449,
449,196,449,449,449,449,449,449,449,449,449,449,449,449,449,449,
449,449,449,449,449,449,449,449,449,196,449,449,449,449,449,449,
449,449,449,449,196,449,449,449,449,449,196,196,453,449,451,454,
455,451,455,451,451,196,454,455,455,196,455,455,450,456,196,196,
196,196,196,196,196,455,455,196,196,196,196,196,196,449,449,196,
449,449,450,450,196,196,457,457,457,457,457,457,457,457,457,457,
196,449,449,451,196,196,196,196,196,196,196,196,196,196,196,196,

/* block 26 */
458,458,459,459,460,460,460,460,460,460,460,460,460,196,460,460,
460,196,460,460,460,461,461,461,461,461,461,461,461,461,461,461,
461,461,461,461,461,461,461,461,461,461,461,461,461,461,461,461,
461,461,461,461,461,461,461,461,461,461,461,462,462,460,463,459,
459,458,458,458,458,196,459,459,459,196,459,459,459,462,464,465,
196,196,196,196,460,460,460,463,466,466,466,466,466,466,466,460,
460,460,458,458,196,196,467,467,467,467,467,467,467,467,467,467,
466,466,466,466,466,466,466,466,466,465,460,460,460,460,460,460,

/* block 27 */
196,468,469,469,196,470,470,470,470,470,470,470,470,470,470,470,
470,470,470,470,470,470,470,196,196,196,470,470,470,470,470,470,
470,470,470,470,470,470,470,470,470,470,470,470,470,470,470,470,
470,470,196,470,470,470,470,470,470,470,470,470,196,470,196,196,
470,470,470,470,470,470,470,196,196,196,471,196,196,196,196,472,
469,469,468,468,468,196,468,196,469,469,469,469,469,469,469,472,
196,196,196,196,196,196,473,473,473,473,473,473,473,473,473,473,
196,196,469,469,474,196,196,196,196,196,196,196,196,196,196,196,

/* block 28 */
196,475,475,475,475,475,475,475,475,475,475,475,475,475,475,475,
475,475,475,475,475,475,475,475,475,475,475,475,475,475,475,475,
475,475,475,475,475,475,475,475,475,475,475,475,475,475,475,475,
475,476,475,477,476,476,476,476,476,476,478,196,196,196,196,479,
480,480,480,480,480,475,481,482,482,482,482,482,482,476,482,483,
484,484,484,484,484,484,484,484,484,484,485,485,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,

/* block 29 */
196,486,486,196,486,196,486,486,486,486,486,196,486,486,486,486,
486,486,486,486,486,486,486,486,486,486,486,486,486,486,486,486,
486,486,486,486,196,486,196,486,486,486,486,486,486,486,486,486,
486,487,486,488,487,487,487,487,487,487,489,487,487,486,196,196,
490,490,490,490,490,196,491,196,492,492,492,492,492,487,493,196,
494,494,494,494,494,494,494,494,494,494,196,196,486,486,486,486,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,

/* block 30 */
495,496,496,496,497,497,497,497,498,497,497,497,497,498,498,498,
498,498,498,496,497,496,496,496,499,499,496,496,496,496,496,496,
500,500,500,500,500,500,500,500,500,500,501,501,501,501,501,501,
501,501,501,501,496,499,496,499,496,499,502,503,502,503,504,504,
495,495,495,495,495,495,495,495,196,495,495,495,495,495,495,495,
495,495,495,495,495,495,495,495,495,495,495,495,495,495,495,495,
495,495,495,495,495,495,495,495,495,495,495,495,495,196,196,196,
196,505,505,505,505,505,505,506,505,506,505,505,505,505,505,507,

/* block 31 */
505,505,508,508,509,497,499,499,495,495,495,495,495,505,505,505,
505,505,505,505,505,505,505,505,196,505,505,505,505,505,505,505,
505,505,505,505,505,505,505,505,505,505,505,505,505,505,505,505,
505,505,505,505,505,505,505,505,505,505,505,505,505,196,496,496,
496,496,496,496,496,496,499,496,496,496,496,496,496,196,496,496,
497,497,497,497,497,510,510,510,510,497,497,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,

/* block 32 */
511,511,511,511,511,511,511,511,511,511,511,511,511,511,511,511,
511,511,511,511,511,511,511,511,511,511,511,511,511,511,511,511,
511,511,511,511,511,511,511,511,511,511,511,512,512,513,513,513,
513,514,513,513,513,513,513,515,512,516,516,514,514,513,513,511,
517,517,517,517,517,517,517,517,517,517,518,518,519,519,519,519,
511,511,511,511,511,511,514,514,513,513,511,511,511,511,513,513,
513,511,512,520,520,511,511,512,512,520,520,520,520,520,511,511,
511,513,513,513,513,511,511,511,511,511,511,511,511,511,511,511,

/* block 33 */
511,511,513,512,514,513,513,520,520,520,520,520,520,521,511,520,
522,522,522,522,522,522,522,522,522,522,520,520,512,513,523,523,
524,524,524,524,524,524,524,524,524,524,524,524,524,524,524,524,
524,524,524,524,524,524,524,524,524,524,524,524,524,524,524,524,
524,524,524,524,524,524,196,524,196,196,196,196,196,524,196,196,
525,525,525,525,525,525,525,525,525,525,525,525,525,525,525,525,
525,525,525,525,525,525,525,525,525,525,525,525,525,525,525,525,
525,525,525,525,525,525,525,525,525,525,525,526,527,525,525,525,

/* block 34 */
528,528,528,528,528,528,528,528,528,528,528,528,528,528,528,528,
528,528,528,528,528,528,528,528,528,528,528,528,528,528,528,528,
528,528,528,528,528,528,528,528,528,528,528,528,528,528,528,528,
528,528,528,528,528,528,528,528,528,528,528,528,528,528,528,528,
528,528,528,528,528,528,528,528,528,528,528,528,528,528,528,528,
528,528,528,528,528,528,528,528,528,528,528,528,528,528,528,529,
530,531,531,531,531,531,531,531,531,531,531,531,531,531,531,531,
531,531,531,531,531,531,531,531,531,531,531,531,531,531,531,531,

/* block 35 */
531,531,531,531,531,531,531,531,531,531,531,531,531,531,531,531,
531,531,531,531,531,531,531,531,531,531,531,531,531,531,531,531,
531,531,531,531,531,531,531,531,532,532,532,532,532,532,532,532,
532,532,532,532,532,532,532,532,532,532,532,532,532,532,532,532,
532,532,532,532,532,532,532,532,532,532,532,532,532,532,532,532,
532,532,532,532,532,532,532,532,532,532,532,532,532,532,532,532,
532,532,532,532,532,532,532,532,532,532,532,532,532,532,532,532,
532,532,532,532,532,532,532,532,532,532,532,532,532,532,532,532,

/* block 36 */
533,533,533,533,533,533,533,533,533,533,533,533,533,533,533,533,
533,533,533,533,533,533,533,533,533,533,533,533,533,533,533,533,
533,533,533,533,533,533,533,533,533,533,533,533,533,533,533,533,
533,533,533,533,533,533,533,533,533,533,533,533,533,533,533,533,
533,533,533,533,533,533,533,533,533,196,533,533,533,533,196,196,
533,533,533,533,533,533,533,196,533,196,533,533,533,533,196,196,
533,533,533,533,533,533,533,533,533,533,533,533,533,533,533,533,
533,533,533,533,533,533,533,533,533,533,533,533,533,533,533,533,

/* block 37 */
533,533,533,533,533,533,533,533,533,196,533,533,533,533,196,196,
533,533,533,533,533,533,533,533,533,533,533,533,533,533,533,533,
533,533,533,533,533,533,533,533,533,533,533,533,533,533,533,533,
533,196,533,533,533,533,196,196,533,533,533,533,533,533,533,196,
533,196,533,533,533,533,196,196,533,533,533,533,533,533,533,533,
533,533,533,533,533,533,533,196,533,533,533,533,533,533,533,533,
533,533,533,533,533,533,533,533,533,533,533,533,533,533,533,533,
533,533,533,533,533,533,533,533,533,533,533,533,533,533,533,533,

/* block 38 */
533,533,533,533,533,533,533,533,533,533,533,533,533,533,533,533,
533,196,533,533,533,533,196,196,533,533,533,533,533,533,533,533,
533,533,533,533,533,533,533,533,533,533,533,533,533,533,533,533,
533,533,533,533,533,533,533,533,533,533,533,533,533,533,533,533,
533,533,533,533,533,533,533,533,533,533,533,533,533,533,533,533,
533,533,533,533,533,533,533,533,533,533,533,196,196,534,534,534,
535,536,537,536,536,536,536,537,537,538,538,538,538,538,538,538,
538,538,539,539,539,539,539,539,539,539,539,539,539,196,196,196,

/* block 39 */
533,533,533,533,533,533,533,533,533,533,533,533,533,533,533,533,
540,540,540,540,540,540,540,540,540,540,196,196,196,196,196,196,
541,541,541,541,541,541,541,541,541,541,541,541,541,541,541,541,
541,541,541,541,541,541,541,541,541,541,541,541,541,541,541,541,
541,541,541,541,541,541,541,541,541,541,541,541,541,541,541,541,
541,541,541,541,541,541,541,541,541,541,541,541,541,541,541,541,
541,541,541,541,541,541,541,541,541,541,541,541,541,541,541,541,
542,542,542,542,542,542,196,196,543,543,543,543,543,543,196,196,

/* block 40 */
544,545,545,545,545,545,545,545,545,545,545,545,545,545,545,545,
545,545,545,545,545,545,545,545,545,545,545,545,545,545,545,545,
545,545,545,545,545,545,545,545,545,545,545,545,545,545,545,545,
545,545,545,545,545,545,545,545,545,545,545,545,545,545,545,545,
545,545,545,545,545,545,545,545,545,545,545,545,545,545,545,545,
545,545,545,545,545,545,545,545,545,545,545,545,545,545,545,545,
545,545,545,545,545,545,545,545,545,545,545,545,545,545,545,545,
545,545,545,545,545,545,545,545,545,545,545,545,545,545,545,545,

/* block 41 */
545,545,545,545,545,545,545,545,545,545,545,545,545,545,545,545,
545,545,545,545,545,545,545,545,545,545,545,545,545,545,545,545,
545,545,545,545,545,545,545,545,545,545,545,545,545,545,545,545,
545,545,545,545,545,545,545,545,545,545,545,545,545,545,545,545,
545,545,545,545,545,545,545,545,545,545,545,545,545,545,545,545,
545,545,545,545,545,545,545,545,545,545,545,545,545,545,545,545,
545,545,545,545,545,545,545,545,545,545,545,545,545,545,545,545,
545,545,545,545,545,545,545,545,545,545,545,545,545,545,545,545,

/* block 42 */
545,545,545,545,545,545,545,545,545,545,545,545,545,545,545,545,
545,545,545,545,545,545,545,545,545,545,545,545,545,545,545,545,
545,545,545,545,545,545,545,545,545,545,545,545,545,545,545,545,
545,545,545,545,545,545,545,545,545,545,545,545,545,545,545,545,
545,545,545,545,545,545,545,545,545,545,545,545,545,545,545,545,
545,545,545,545,545,545,545,545,545,545,545,545,545,545,545,545,
545,545,545,545,545,545,545,545,545,545,545,545,545,546,547,545,
545,545,545,545,545,545,545,545,545,545,545,545,545,545,545,545,

/* block 43 */
548,549,549,549,549,549,549,549,549,549,549,549,549,549,549,549,
549,549,549,549,549,549,549,549,549,549,549,550,551,196,196,196,
552,552,552,552,552,552,552,552,552,552,552,552,552,552,552,552,
552,552,552,552,552,552,552,552,552,552,552,552,552,552,552,552,
552,552,552,552,552,552,552,552,552,552,552,552,552,552,552,552,
552,552,552,552,552,552,552,552,552,552,552,552,552,552,552,552,
552,552,552,552,552,552,552,552,552,552,552,553,553,553,554,554,
554,552,552,552,552,552,552,552,552,196,196,196,196,196,196,196,

/* block 44 */
555,555,555,555,555,555,555,555,555,555,555,555,555,555,555,555,
555,555,556,556,557,558,196,196,196,196,196,196,196,196,196,555,
559,559,559,559,559,559,559,559,559,559,559,559,559,559,559,559,
559,559,560,560,561,562,562,196,196,196,196,196,196,196,196,196,
563,563,563,563,563,563,563,563,563,563,563,563,563,563,563,563,
563,563,564,564,196,196,196,196,196,196,196,196,196,196,196,196,
565,565,565,565,565,565,565,565,565,565,565,565,565,196,565,565,
565,196,566,566,196,196,196,196,196,196,196,196,196,196,196,196,

/* block 45 */
567,567,567,567,567,567,567,567,567,567,567,567,567,567,567,567,
567,567,567,567,567,567,567,567,567,567,567,567,567,567,567,567,
567,567,567,568,568,567,567,567,567,567,567,567,567,567,567,567,
567,567,567,567,569,569,570,571,571,571,571,571,571,571,570,570,
570,570,570,570,570,570,571,570,570,572,572,572,572,572,572,572,
572,572,573,572,574,574,575,576,577,577,575,578,567,572,196,196,
579,579,579,579,579,579,579,579,579,579,196,196,196,196,196,196,
580,580,580,580,580,580,580,580,580,580,196,196,196,196,196,196,

/* block 46 */
581,581,582,583,584,582,585,581,584,586,587,588,588,588,589,588,
590,590,590,590,590,590,590,590,590,590,196,196,196,196,196,196,
591,591,591,591,591,591,591,591,591,591,591,591,591,591,591,591,
591,591,591,591,591,591,591,591,591,591,591,591,591,591,591,591,
591,591,591,592,591,591,591,591,591,591,591,591,591,591,591,591,
591,591,591,591,591,591,591,591,591,591,591,591,591,591,591,591,
591,591,591,591,591,591,591,591,591,591,591,591,591,591,591,591,
591,591,591,591,591,591,591,591,591,196,196,196,196,196,196,196,

/* block 47 */
591,591,591,591,591,593,593,591,591,591,591,591,591,591,591,591,
591,591,591,591,591,591,591,591,591,591,591,591,591,591,591,591,
591,591,591,591,591,591,591,591,591,594,591,196,196,196,196,196,
545,545,545,545,545,545,545,545,545,545,545,545,545,545,545,545,
545,545,545,545,545,545,545,545,545,545,545,545,545,545,545,545,
545,545,545,545,545,545,545,545,545,545,545,545,545,545,545,545,
545,545,545,545,545,545,545,545,545,545,545,545,545,545,545,545,
545,545,545,545,545,545,196,196,196,196,196,196,196,196,196,196,

/* block 48 */
595,595,595,595,595,595,595,595,595,595,595,595,595,595,595,595,
595,595,595,595,595,595,595,595,595,595,595,595,595,595,595,196,
596,596,596,597,597,597,597,596,596,597,597,597,196,196,196,196,
597,597,596,597,597,597,597,597,597,598,598,598,196,196,196,196,
599,196,196,196,600,600,601,601,601,601,601,601,601,601,601,601,
602,602,602,602,602,602,602,602,602,602,602,602,602,602,602,602,
602,602,602,602,602,602,602,602,602,602,602,602,602,602,196,196,
602,602,602,602,602,196,196,196,196,196,196,196,196,196,196,196,

/* block 49 */
603,603,603,603,603,603,603,603,603,603,603,603,603,603,603,603,
603,603,603,603,603,603,603,603,603,603,603,603,603,603,603,603,
603,603,603,603,603,603,603,603,603,603,603,603,196,196,196,196,
603,603,603,603,603,604,604,604,603,603,604,603,603,603,603,603,
603,603,603,603,603,603,603,603,603,603,196,196,196,196,196,196,
605,605,605,605,605,605,605,605,605,605,606,196,196,196,607,607,
608,608,608,608,608,608,608,608,608,608,608,608,608,608,608,608,
608,608,608,608,608,608,608,608,608,608,608,608,608,608,608,608,

/* block 50 */
609,609,609,609,609,609,609,609,609,609,609,609,609,609,609,609,
609,609,609,609,609,609,609,610,610,611,611,610,196,196,612,612,
613,613,613,613,613,613,613,613,613,613,613,613,613,613,613,613,
613,613,613,613,613,613,613,613,613,613,613,613,613,613,613,613,
613,613,613,613,613,613,613,613,613,613,613,613,613,613,613,613,
613,613,613,613,613,614,615,614,615,615,615,615,615,615,615,196,
616,617,615,617,617,615,615,615,615,615,615,615,615,614,614,614,
614,614,614,615,615,618,618,618,618,618,618,618,618,196,196,618,

/* block 51 */
619,619,619,619,619,619,619,619,619,619,196,196,196,196,196,196,
619,619,619,619,619,619,619,619,619,619,196,196,196,196,196,196,
620,620,620,620,620,620,620,621,622,622,622,622,620,620,196,196,
176,176,176,176,176,176,176,176,176,176,176,176,176,176,623,624,
624,176,176,176,176,176,176,176,176,176,176,176,624,624,624,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,

/* block 52 */
625,625,625,625,626,627,627,627,627,627,627,627,627,627,627,627,
627,627,627,627,627,627,627,627,627,627,627,627,627,627,627,627,
627,627,627,627,627,627,627,627,627,627,627,627,627,627,627,627,
627,627,627,627,628,629,625,625,625,625,625,629,625,629,626,626,
626,626,625,629,630,627,627,627,627,627,627,627,627,196,631,631,
632,632,632,632,632,632,632,632,632,632,631,631,633,634,631,631,
633,635,635,635,635,635,635,635,635,635,635,628,628,628,628,628,
628,628,628,628,635,635,635,635,635,635,635,635,635,631,631,631,

/* block 53 */
636,636,637,638,638,638,638,638,638,638,638,638,638,638,638,638,
638,638,638,638,638,638,638,638,638,638,638,638,638,638,638,638,
638,637,636,636,636,636,637,637,636,636,639,640,636,636,638,638,
641,641,641,641,641,641,641,641,641,641,638,638,638,638,638,638,
642,642,642,642,642,642,642,642,642,642,642,642,642,642,642,642,
642,642,642,642,642,642,642,642,642,642,642,642,642,642,642,642,
642,642,642,642,642,642,643,644,645,645,644,644,644,645,644,645,
645,645,646,646,196,196,196,196,196,196,196,196,647,647,647,647,

/* block 54 */
648,648,648,648,648,648,648,648,648,648,648,648,648,648,648,648,
648,648,648,648,648,648,648,648,648,648,648,648,648,648,648,648,
648,648,648,648,649,649,649,649,649,649,649,649,650,650,650,650,
650,650,650,650,649,649,651,652,196,196,196,653,653,654,654,654,
655,655,655,655,655,655,655,655,655,655,196,196,196,648,648,648,
656,656,656,656,656,656,656,656,656,656,657,657,657,657,657,657,
657,657,657,657,657,657,657,657,657,657,657,657,657,657,657,657,
657,657,657,657,657,657,657,657,658,658,658,659,658,658,660,660,

/* block 55 */
661,662,663,664,665,666,667,668,669,275,276,196,196,196,196,196,
670,670,670,670,670,670,670,670,670,670,670,670,670,670,670,670,
670,670,670,670,670,670,670,670,670,670,670,670,670,670,670,670,
670,670,670,670,670,670,670,670,670,670,670,196,196,670,670,670,
671,671,671,671,671,671,671,671,196,196,196,196,196,196,196,196,
672,673,672,674,673,675,675,676,675,676,677,673,676,676,673,673,
676,678,673,673,673,673,673,673,673,679,680,681,681,675,681,681,
681,681,682,683,684,680,680,685,686,686,687,196,196,196,196,196,

/* block 56 */
 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70,
 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70,
 70, 70, 70, 70, 70, 70,256,256,256,256,256,688,149,149,149,149,
149,149,149,149,149,149,149,149,149,149,149,149,149,149,149,149,
149,149,149,149,149,149,149,149,149,149,149,149,149,149,149,149,
149,149,149,149,149,149,149,149,149,149,149,149,149,689,689,689,
689,689,150,149,149,149,689,689,689,689,689, 70, 70, 70, 70, 70,
 70, 70, 70, 70, 70, 70, 70, 70,690,691, 70, 70, 70,692, 70, 70,

/* block 57 */
 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70,693, 70,
 70, 70, 70, 70, 70, 70,694, 70, 70, 70, 70,695,695,695,695,695,
695,695,695,695,696,695,695,695,696,695,695,695,695,695,695,695,
695,695,695,695,695,695,695,695,695,695,695,695,695,695,695,697,
698,698,189,189,176,176,176,176,176,176,176,176,176,176,176,176,
189,189,189,624,624,624,624,624,624,624,624,624,624,624,624,624,
624,624,624,624,624,624,624,624,624,624,624,624,624,624,624,624,
624,624,624,624,624,176,176,176,699,176,700,176,176,176,176,176,

/* block 58 */
 65, 66, 65, 66, 65, 66, 65, 66, 65, 66, 65, 66, 65, 66, 65, 66,
 65, 66, 65, 66, 65, 66, 65, 66, 65, 66, 65, 66, 65, 66, 65, 66,
 65, 66, 65, 66, 65, 66, 65, 66, 65, 66, 65, 66, 65, 67, 65, 66,
 65, 66, 65, 66, 65, 66, 65, 66, 65, 66, 65, 66, 65, 66, 65, 66,
 65, 66, 65, 66, 65, 66, 65, 66, 65, 66, 65, 66, 65, 66, 65, 66,
 65, 66, 65, 66, 65, 66, 65, 66, 65, 66, 65, 66, 65, 66, 65, 66,
701,702, 65, 66, 65, 66, 65, 66, 65, 66, 65, 66, 65, 66, 65, 66,
 65, 66, 65, 66, 65, 66, 65, 66, 65, 66, 65, 66, 65, 66, 65, 66,

/* block 59 */
 65, 66, 65, 66, 65, 66, 65, 66, 65, 66, 65, 66, 65, 66, 65, 66,
 65, 66, 65, 66, 65, 66, 69, 69, 69, 69,703,704, 70, 70,705, 70,
 65, 66, 65, 66, 65, 66, 65, 66, 65, 66, 65, 66, 65, 66, 65, 66,
 65, 66, 65, 66, 65, 66, 65, 66, 65, 66, 65, 66, 65, 66, 65, 66,
 65, 66, 65, 66, 65, 66, 65, 66, 65, 66, 65, 67, 65, 66, 65, 66,
 65, 66, 65, 66, 65, 66, 65, 66, 65, 66, 65, 66, 65, 66, 65, 66,
 65, 66, 65, 66, 65, 66, 65, 66, 65, 66, 65, 66, 65, 66, 65, 66,
 65, 66, 65, 66, 65, 66, 65, 66, 65, 66, 65, 66, 65, 66, 65, 66,

/* block 60 */
706,706,706,706,706,706,706,706,707,707,707,707,707,707,707,707,
706,706,706,706,706,706,196,196,707,707,707,707,707,707,196,196,
706,706,706,706,706,706,706,706,707,707,707,707,707,707,707,707,
706,706,706,706,706,706,706,706,707,707,707,707,707,707,707,707,
706,706,706,706,706,706,196,196,707,707,707,707,707,707,196,196,
708,706,708,706,708,706,708,706,196,707,196,707,196,707,196,707,
706,706,706,706,706,706,706,706,707,707,707,707,707,707,707,707,
709,709,710,710,710,710,711,711,712,712,713,713,714,714,196,196,

/* block 61 */
715,715,715,715,715,715,715,715,716,716,716,716,716,716,716,716,
715,715,715,715,715,715,715,715,716,716,716,716,716,716,716,716,
715,715,715,715,715,715,715,715,716,716,716,716,716,716,716,716,
706,706,717,718,717,196,708,717,707,707,719,719,720,201,721,201,
201,201,717,718,717,196,708,717,722,722,722,722,720,201,201,201,
706,706,708,723,196,196,708,708,707,707,724,724,196,201,201,201,
706,706,708,725,708,250,708,708,707,707,726,726,255,201,201,201,
196,196,717,718,717,196,708,717,727,727,728,728,720,201,201,196,

/* block 62 */
729,729,729,729,729,729,729,729,729,729,729, 51,730,731,732,733,
734,734,734,734,734,734,735, 43,736,737,738,739,739,740,738,739,
 43, 43, 43, 43,741, 43, 43,742,743,744,745,746,747,748,749,750,
751,751,752,752,752, 43, 43, 43, 43, 49, 57, 43,753,754, 43,755,
756, 43, 43, 43,757,758,759,754,754,753, 43, 43, 43, 43, 43,760,
 43, 43, 50,761,755, 43, 43, 43, 43, 43,762, 43, 43,763, 43,729,
 51,764,764,764,764,765,766,767,768,769,770,770,770,770,770,770,
 54,696,196,196, 54, 54, 54, 54, 54, 54,771,772,773,774,775,695,

/* block 63 */
 54, 54, 54, 54, 54, 54, 54, 54, 54, 54,771,772,773,774,775,196,
695,695,695,695,695,695,695,695,695,695,695,695,695,196,196,196,
479,479,479,479,479,479,479,479,479,479,479,479,479,479,479,479,
479,479,479,479,479,479,479,479,479,479,479,479,479,479,479,479,
479,776,776,776,776,776,776,776,776,776,776,776,776,776,776,776,
777,777,777,777,777,777,777,777,777,777,777,777,777,778,778,778,
778,777,778,779,778,777,777,189,189,189,189,777,777,777,777,777,
780,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,

/* block 64 */
781,781,782,781,781,781,781,782,781,781,783,782,782,782,783,783,
782,782,782,783,781,782,781,781,784,782,782,782,782,782,781,781,
781,781,785,781,782,781,786,781,782,787,788,789,782,782,790,783,
782,782,791,782,783,792,792,792,792,793,781,781,783,783,782,782,
794,794,794,794,794,782,783,783,795,795,781,794,781,781,796,510,
 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
797,797,797,797,797,797,797,797,797,797,797,797,797,797,797,797,
798,798,798,798,798,798,798,798,798,798,798,798,798,798,798,798,

/* block 65 */
799,799,799, 65, 66,799,799,799,799, 58,781,781,196,196,196,196,
 50, 50, 50, 50,800,801,801,801,801,801, 50, 50,802,802,802,802,
 50,802,802, 50,802,802, 50,802, 45,801,801,802,802,802, 50, 45,
802,802, 45, 45, 45, 45,802,802, 45, 45, 45, 45,802,802,802,802,
802,802,802,802,802,802,802,802,802,802,802,802,802,802, 50, 50,
802,802, 50,802, 50,802,802,802,802,802,802,802, 45,802, 45, 45,
 45, 45, 45, 45,802,802, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
 45, 45, 45, 45, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50,

/* block 66 */
 50, 50,803, 50, 50, 50, 50,803,804,804,804,804,804,804, 50, 50,
 50, 50,805, 53, 50,804, 50, 50, 50, 50, 50, 50, 50, 50,803,804,
804,804,804, 50,804, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50,
 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50,804,804, 50, 50,
 50, 50, 50,804, 50,804, 50, 50, 50, 50, 50, 50,804, 50, 50, 50,
 50, 50,804,804,804,804, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50,
 50, 50, 50, 50,804,804,804,804,804,804,804,804, 50, 50,804,804,
804,804,804,804,804,804,804,804,804,804,804,804,804,804,804,804,

/* block 67 */
804,804,804,804,804,804,804,804,804,804,804,804, 50, 50, 50,804,
804,804,804, 50, 50, 50, 50, 50,804, 50, 50, 50, 50, 50, 50, 50,
 50, 50,804,804, 50, 50,804, 50,804,804, 50,804, 50, 50, 50, 50,
804,804,804,804,804,804,804,804,804, 50, 50, 50, 50, 50, 50, 50,
 50, 50, 50, 50, 50, 50, 50, 50, 50,804,804,804,804,804, 50, 50,
804,804, 50, 50, 50, 50,804,804,804,804,804,804,804,804,804,804,
804,804,804,804,804,804,804,804,804,804,804,804,804,804, 50, 50,
804,804,804,804,804, 50,804,804, 50, 50,804,804,804,804,804, 50,

/* block 68 */
 45, 45, 45, 45, 45, 45, 45, 45,806,807,806,807, 45, 45, 45, 45,
 45, 45, 45, 45, 45, 45, 45, 45, 45, 45,808,808, 45, 45, 45, 45,
 50, 50, 45, 45, 45, 45, 45, 45, 47,809,810, 45, 45, 45, 45, 45,
 45, 45, 45, 45, 45, 45,811,811,811,811,811,811,811,811,811,811,
811,811,811,811,811,811,811,811,811,811,811,811,811,811,811,811,
811,811,811,811,811,811,811,811,811,811,811,811,811,811,811,811,
811,811,811,811,811,811,811,811,811,811,811,811,811,811,811,811,
811,811,811,811,811,811,811,811,811,811,811, 45, 50, 45, 45, 45,

/* block 69 */
 45, 45, 45, 45, 45, 45, 45, 45,812, 45, 45, 45, 45, 45, 45, 45,
 45, 45, 45, 45, 45,811, 45, 45, 45, 45, 45, 50, 50, 50, 50, 50,
 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50,
 50, 50, 50, 50,802,802, 45,802, 45, 45, 45, 45, 45, 45, 45, 45,
 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 47,
802, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 50, 50, 50, 50,
 50, 50,802, 45, 45, 45, 45, 45, 45,808,808,808,808, 47, 47, 47,
808, 47, 47,808, 45, 45, 45, 45, 47, 47, 47, 45, 45, 45, 45, 45,

/* block 70 */
 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
 45, 45, 45, 45, 45, 45, 45, 45, 45, 45,813,813,813,813,813,813,
813,813,813,813,813,813,813,813,813,813,813,813,813,813,813,813,
 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45,813,813,813,813,813,
813,813,813,813,813,813,813,813,813,813,813,813,813,813,813,813,
 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58,

/* block 71 */
 58, 58, 58, 58, 58, 58, 58, 58,814,814,814,814,814,814,814,814,
814,814,814,814,814,814,814,814,814,814,814,814,510,510,510,510,
510,510,510,510,510,510,510,510,510,510,510,510,510,510,510,510,
510,510,510,510,510,510,815,815,815,815,815,815,815,815,815,815,
815,815,816,815,815,815,815,815,815,815,815,815,815,815,815,815,
817,817,817,817,817,817,817,817,817,817,817,817,817,817,817,817,
817,817,817,817,817,817,817,817,817,817, 58, 58, 58, 58, 58, 58,
 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58,

/* block 72 */
 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45,

/* block 73 */
 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
802,802, 45, 45, 45, 45, 45, 45, 45, 45, 47, 47, 45, 45,802,802,
802,802,802,802,802,802,801, 50, 45, 45, 45, 45,802,802,802,802,
801, 50, 45, 45, 45, 45,802,802, 45, 45,802,802, 45, 45, 45,802,
802,802,802,802, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
 45, 45,802, 45,802, 45, 45,802,802,802,802,802,802, 45, 45, 45,
 45, 45, 45, 45, 45, 45, 45, 45, 50, 50, 50,800,800,818,818, 50,

/* block 74 */
 47, 47, 47, 47, 47,819,802,812,812,812,812,812,812,812, 47,812,
812, 47,812, 45,808,808,812,812, 47,812,812,812,812,820,812,812,
 47,812, 47, 47,812,812, 47,812,812,812, 47,812,812,812, 47, 47,
812,812,812,812,812,812,812,812, 47, 47, 47,812,812,812,812,812,
801,812,801,812,812,812,812,812,808,808,808,808,808,808,808,808,
808,808,808,808,812,812,812,812,812,812,812,812,812,812,812, 47,
801,819,819,801,812, 47, 47,812, 47,812,812,812,812,819,819,821,
812,812,812,812,812,812,812,812,812,812,812, 47,812,812, 47,808,

/* block 75 */
812,812,812,812,812,812, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
812,812, 47,808, 47, 47, 47, 47,812, 47,812, 47, 47,812,812,812,
 47,808,812,812,812,812,812, 47,812,812,808,808,822,812,812,812,
 47, 47,812,812,812,812,812,812,812,812,812,812,812,808,808,812,
812,812,812,812,808,808,812,812, 47,812,812,812,812,812,808, 47,
812, 47,812, 47,808,812,812,812,812,812,812,812,812,812,812,812,
812,812,812,812,812,812,812,812,812, 47,808,812,812,812,812,812,
 47, 47,808,808, 47,808,812, 47, 47,820,808,812,812,808,812,812,

/* block 76 */
812,812, 47,812,812,808, 45, 45, 47, 47,823,823,820,820,812, 47,
812,812, 47, 45, 47, 45, 47, 45, 45, 45, 45, 45, 45, 47, 45, 45,
 45, 47, 45, 45, 45, 45, 45, 45,808, 45, 45, 45, 45, 45, 45, 45,
 45, 45, 45, 47, 47, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
 45, 45, 45, 45, 47, 45, 45, 47, 45, 45, 45, 45,808, 45,808, 45,
 45, 45, 45,808,808,808, 45,808, 45, 45, 45, 45, 45, 45, 45, 45,
 45, 45, 45, 47, 47,812,812,812,758,759,758,759,758,759,758,759,
758,759,758,759,758,759, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58,

/* block 77 */
 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
 58, 58, 58, 58, 45,808,808,808, 45, 45, 45, 45, 45, 45, 45, 45,
 45, 47, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
808, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45,808,
 50, 50, 50,804,804,806,807, 50,804,804, 50,804, 50,804, 50, 50,
 50, 50, 50, 50, 50,804,804, 50, 50, 50, 50, 50,804,804,804, 50,
 50, 50,804,804,804,804,806,807,806,807,806,807,806,807,806,807,
 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50,

/* block 78 */
824,824,824,824,824,824,824,824,824,824,824,824,824,824,824,824,
824,824,824,824,824,824,824,824,824,824,824,824,824,824,824,824,
824,824,824,824,824,824,824,824,824,824,824,824,824,824,824,824,
824,824,824,824,824,824,824,824,824,824,824,824,824,824,824,824,
824,824,824,824,824,824,824,824,824,824,824,824,824,824,824,824,
824,824,824,824,824,824,824,824,824,824,824,824,824,824,824,824,
824,824,824,824,824,824,824,824,824,824,824,824,824,824,824,824,
824,824,824,824,824,824,824,824,824,824,824,824,824,824,824,824,

/* block 79 */
 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50,
 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50,
 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50,
 50, 50, 50, 50,800,800, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50,
 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50,
 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50,
 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50,
 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50,

/* block 80 */
 50, 50, 50,806,807,806,807,806,807,806,807,806,807,806,807,806,
807,806,807,806,807,806,807,806,807, 50, 50,804, 50, 50, 50, 50,
804, 50, 50,804,804,804, 50, 50,804,804,804,804,804,804,804,804,
 50, 50, 50, 50, 50, 50, 50, 50,804, 50, 50, 50, 50, 50, 50, 50,
804,804, 50, 50,804,804, 50, 50, 50, 50, 50, 50, 50, 50, 50,804,
804,804,804, 50,804,804, 50, 50,806,807,806,807, 50, 50, 50, 50,
 50, 50, 50, 50, 50, 50, 50, 50,804,804, 50, 50, 50, 50, 50, 50,
 50, 50, 50, 50, 50,804, 50, 50,804,804, 50, 50,806,807, 50, 50,

/* block 81 */
 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50,
 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50,
 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50,804,804,804,804, 50,
 50, 50, 50, 50,804,804, 50, 50, 50, 50, 50, 50,804,804, 50, 50,
 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50,
 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50,
 50, 50, 50, 50,804,804, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50,
 50, 50, 50, 50, 50, 50, 50, 50, 50,804,804,804,804,804,804,804,

/* block 82 */
804,804,804,804,804,804,804,804,804,804,804,804,804,804,804,804,
804,804,804,804,804,804,804,804,804,804,804,804,804,804,804,804,
804,804,804, 50, 50, 50,804,804,804,804,804,804,804,804, 50,804,
804,804,804,804,804,804,804,804,804,804,804,804,804,804,804,804,
804,804,804,804,804,804,804,804,804,804,804,804,804,804,804,804,
804,804,804,804,804,804,804, 50, 50, 50, 50, 50, 50, 50,804, 50,
 50, 50, 50,804,804,804, 50, 50, 50, 50, 50, 50,804,804,804, 50,
 50, 50, 50, 50, 50, 50, 50,804,804,804,804, 50, 50, 50, 50, 50,

/* block 83 */
 45, 45, 45, 45, 45, 47, 47, 47, 45, 45, 45, 45, 45, 45, 45, 45,
 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45,808,808, 45, 45, 45,
 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50,
 50, 50, 50, 50, 50, 45, 45, 50, 50, 50, 50, 50, 50, 45, 45, 45,
808, 45, 45, 45, 45,808, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
 45, 45, 45, 45,813,813, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45,

/* block 84 */
 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
 45, 45, 45, 45, 45, 45,813, 45, 45, 45, 45, 45, 45, 45, 45, 45,
 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45,825, 45,

/* block 85 */
826,826,826,826,826,826,826,826,826,826,826,826,826,826,826,826,
826,826,826,826,826,826,826,826,826,826,826,826,826,826,826,826,
826,826,826,826,826,826,826,826,826,826,826,826,826,826,826,826,
827,827,827,827,827,827,827,827,827,827,827,827,827,827,827,827,
827,827,827,827,827,827,827,827,827,827,827,827,827,827,827,827,
827,827,827,827,827,827,827,827,827,827,827,827,827,827,827,827,
 65, 66,828,829,830,831,832, 65, 66, 65, 66, 65, 66,833,834,835,
836, 70, 65, 66, 70, 65, 66, 70, 70, 70, 70, 70,696,695,837,837,

/* block 86 */
246,247,246,247,246,247,246,247,246,247,246,247,246,247,246,247,
246,247,246,247,246,247,246,247,246,247,246,247,246,247,246,247,
246,247,246,247,246,247,246,247,246,247,246,247,246,247,246,247,
246,247,246,247,246,247,246,247,246,247,246,247,246,247,246,247,
246,247,246,247,246,247,246,247,246,247,246,247,246,247,246,247,
246,247,246,247,246,247,246,247,246,247,246,247,246,247,246,247,
246,247,246,247,838,839,839,839,839,839,839,246,247,246,247,840,
840,840,246,247,196,196,196,196,196,841,841,841,842,843,842,842,

/* block 87 */
844,844,844,844,844,844,844,844,844,844,844,844,844,844,844,844,
844,844,844,844,844,844,844,844,844,844,844,844,844,844,844,844,
844,844,844,844,844,844,196,844,196,196,196,196,196,844,196,196,
845,845,845,845,845,845,845,845,845,845,845,845,845,845,845,845,
845,845,845,845,845,845,845,845,845,845,845,845,845,845,845,845,
845,845,845,845,845,845,845,845,845,845,845,845,845,845,845,845,
845,845,845,845,845,845,845,845,196,196,196,196,196,196,196,846,
847,196,196,196,196,196,196,196,196,196,196,196,196,196,196,848,

/* block 88 */
533,533,533,533,533,533,533,533,533,533,533,533,533,533,533,533,
533,533,533,533,533,533,533,196,196,196,196,196,196,196,196,196,
533,533,533,533,533,533,533,196,533,533,533,533,533,533,533,196,
533,533,533,533,533,533,533,196,533,533,533,533,533,533,533,196,
533,533,533,533,533,533,533,196,533,533,533,533,533,533,533,196,
533,533,533,533,533,533,533,196,533,533,533,533,533,533,533,196,
849,849,849,849,849,849,849,849,849,849,849,849,849,849,849,849,
849,849,849,849,849,849,849,849,849,849,849,849,849,849,849,849,

/* block 89 */
 43, 43,850,851,850,851, 43, 43, 43,850,851, 43,850,851, 43, 43,
 43, 43, 43, 43, 43, 43, 43,852, 43, 43,734, 43,850,851, 43, 43,
850,851,758,759,758,759,758,759,758,759, 43, 43, 43, 43,754,853,
854,855, 43, 43, 43, 43, 43, 43, 43, 43,734,734,856, 43, 43, 43,
734,857,738,858, 43, 43, 43, 43, 43, 43, 43, 43,859, 43,859,859,
 45, 45, 43,754,754,758,759,758,759,758,759,758,759,734,813,813,
813,813,813,813,813,813,813,813,813,813,813,813,813,813,813,813,
813,813,813,813,813,813,813,813,813,813,813,813,813,813,813,813,

/* block 90 */
860,860,860,860,860,860,860,860,860,860,860,860,860,860,860,860,
860,860,860,860,860,860,860,860,860,860,196,860,860,860,860,860,
860,860,860,860,860,860,860,860,860,860,860,860,860,860,860,860,
860,860,860,860,860,860,860,860,860,860,860,860,860,860,860,860,
860,860,860,860,860,860,860,860,860,860,860,860,860,860,860,860,
860,860,860,860,860,860,860,860,860,860,860,860,860,860,860,860,
860,860,860,860,860,860,860,860,860,860,860,860,860,860,860,860,
860,860,860,860,196,196,196,196,196,196,196,196,196,196,196,196,

/* block 91 */
860,860,860,860,860,860,860,860,860,860,860,860,860,860,860,860,
860,860,860,860,860,860,860,860,860,860,860,860,860,860,860,860,
860,860,860,860,860,860,860,860,860,860,860,860,860,860,860,860,
860,860,860,860,860,860,860,860,860,860,860,860,860,860,860,860,
860,860,860,860,860,860,860,860,860,860,860,860,860,860,860,860,
860,860,860,860,860,860,860,860,860,860,860,860,860,860,860,860,
860,860,860,860,860,860,860,860,860,860,860,860,860,860,860,860,
860,860,860,860,860,860,860,860,860,860,860,860,860,860,860,860,

/* block 92 */
860,860,860,860,860,860,860,860,860,860,860,860,860,860,860,860,
860,860,860,860,860,860,860,860,860,860,860,860,860,860,860,860,
860,860,860,860,860,860,860,860,860,860,860,860,860,860,860,860,
860,860,860,860,860,860,860,860,860,860,860,860,860,860,860,860,
860,860,860,860,860,860,860,860,860,860,860,860,860,860,860,860,
860,860,860,860,860,860,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
861,861,862,862,861,861,861,861,861,861,861,861,861,861,863,863,

/* block 93 */
729,864,865,866,781,867,868,869,870,871,872,873,874,875,874,875,
876,877, 45,878,876,877,876,877,876,877,876,877,879,880,881,881,
 45,869,869,869,869,869,869,869,869,869,882,882,882,882,883,883,
884,885,885,885,885,885,781,886,869,869,869,887,888,889,890,890,
196,891,891,891,891,891,891,891,891,891,891,891,891,891,891,891,
891,891,891,891,891,891,891,891,891,891,891,891,891,891,891,891,
891,891,891,891,891,891,891,891,891,891,891,891,891,891,891,891,
891,891,891,891,891,891,891,891,891,891,891,891,891,891,891,891,

/* block 94 */
891,891,891,891,891,891,891,891,891,891,891,891,891,891,891,891,
891,891,891,891,891,891,891,196,196,892,892,893,893,894,894,891,
895,896,896,896,896,896,896,896,896,896,896,896,896,896,896,896,
896,896,896,896,896,896,896,896,896,896,896,896,896,896,896,896,
896,896,896,896,896,896,896,896,896,896,896,896,896,896,896,896,
896,896,896,896,896,896,896,896,896,896,896,896,896,896,896,896,
896,896,896,896,896,896,896,896,896,896,896,896,896,896,896,896,
896,896,896,896,896,896,896,896,896,896,896,897,898,899,899,896,

/* block 95 */
196,196,196,196,196,900,900,900,900,900,900,900,900,900,900,900,
900,900,900,900,900,900,900,900,900,900,900,900,900,900,900,900,
900,900,900,900,900,900,900,900,900,900,900,900,900,900,900,900,
196,901,901,901,901,901,901,901,901,901,901,901,901,901,901,901,
901,901,901,901,901,901,901,901,901,901,901,901,901,901,901,901,
901,901,901,901,901,901,901,901,901,901,901,901,901,901,901,901,
901,901,901,901,902,901,901,901,901,901,901,901,901,901,901,901,
901,901,901,901,901,901,901,901,901,901,901,901,901,901,901,901,

/* block 96 */
901,901,901,901,901,901,901,901,901,901,901,901,901,901,901,196,
903,903,904,904,904,904,903,903,903,903,903,903,903,903,903,903,
900,900,900,900,900,900,900,900,900,900,900,900,900,900,900,900,
900,900,900,900,900,900,900,900,900,900,900,900,900,900,900,900,
890,890,890,890,890,890,890,890,890,890,890,890,890,890,890,890,
890,890,890,890,890,890,890,890,890,890,890,890,890,890,890,890,
890,890,890,890,890,890,196,196,196,196,196,196,196,196,196,861,
896,896,896,896,896,896,896,896,896,896,896,896,896,896,896,896,

/* block 97 */
905,905,905,905,905,905,905,905,905,905,905,905,905,905,905,905,
905,905,905,905,905,905,905,905,905,905,905,905,905,906,906,196,
904,904,904,904,904,904,904,904,904,904,903,903,903,903,903,903,
903,903,903,903,903,903,903,903,903,903,903,903,903,903,903,903,
903,903,903,903,903,903,903,903,907,907,907,907,907,907,907,907,
781, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
905,905,905,905,905,905,905,905,905,905,905,905,905,905,905,905,
905,905,905,905,905,905,905,905,905,905,905,905,906,906,906,510,

/* block 98 */
904,904,904,904,904,904,904,904,904,904,903,903,903,903,903,903,
903,903,903,903,903,903,903,908,903,908,903,903,903,903,903,903,
903,903,903,903,903,903,903,903,903,903,903,903,903,903,903,903,
903, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
903,903,903,903,903,903,903,903,903,903,903,903,781,781,781,781,
909,909,909,909,909,909,909,909,909,909,909,909,909,909,909,909,
909,909,909,909,909,909,909,909,909,909,909,909,909,909,909,909,
909,909,909,909,909,909,909,909,909,909,909,909,909,909,909,903,

/* block 99 */
909,909,909,909,909,909,909,909,909,909,909,909,909,909,909,909,
909,909,909,909,909,909,909,909,909,909,909,909,909,909,909,909,
909,909,909,909,909,909,909,909,909,909,909,909,909,909,909,909,
909,909,909,909,909,909,909,909,909,909,909,909,909,909,909,909,
909,909,909,909,909,909,909,909,909,909,909,909,909,909,909,909,
909,909,909,909,909,909,909,909,903,903,903,903,903,903,903,903,
903,903,903,903,903,903,903,903,903,903,903,903,903,903,903,903,
903,510,510,510,510,510,510,781,781,781,781,903,903,903,903,903,

/* block 100 */
510,510,510,510,510,510,510,510,510,510,510,510,510,510,510,510,
510,510,510,510,510,510,510,510,510,510,510,510,510,510,510,510,
510,510,510,510,510,510,510,510,510,510,510,510,510,510,510,510,
510,510,510,510,510,510,510,510,510,510,510,510,510,510,510,510,
510,510,510,510,510,510,510,510,510,510,510,510,510,510,510,510,
510,510,510,510,510,510,510,510,510,510,510,510,510,510,781,781,
903,903,903,903,903,903,903,903,903,903,903,903,903,903,903,903,
903,903,903,903,903,903,903,903,903,903,903,903,903,903,903,781,

/* block 101 */
910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,
910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,
910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,
910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,
910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,
910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,
910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,
910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,

/* block 102 */
910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,
910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,
910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,
910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,
781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,
781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,
781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,
781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,

/* block 103 */
911,911,911,911,911,911,911,911,911,911,911,911,911,911,911,911,
911,911,911,911,911,912,911,911,911,911,911,911,911,911,911,911,
911,911,911,911,911,911,911,911,911,911,911,911,911,911,911,911,
911,911,911,911,911,911,911,911,911,911,911,911,911,911,911,911,
911,911,911,911,911,911,911,911,911,911,911,911,911,911,911,911,
911,911,911,911,911,911,911,911,911,911,911,911,911,911,911,911,
911,911,911,911,911,911,911,911,911,911,911,911,911,911,911,911,
911,911,911,911,911,911,911,911,911,911,911,911,911,911,911,911,

/* block 104 */
911,911,911,911,911,911,911,911,911,911,911,911,911,911,911,911,
911,911,911,911,911,911,911,911,911,911,911,911,911,911,911,911,
911,911,911,911,911,911,911,911,911,911,911,911,911,911,911,911,
911,911,911,911,911,911,911,911,911,911,911,911,911,911,911,911,
911,911,911,911,911,911,911,911,911,911,911,911,911,911,911,911,
911,911,911,911,911,911,911,911,911,911,911,911,911,911,911,911,
911,911,911,911,911,911,911,911,911,911,911,911,911,911,911,911,
911,911,911,911,911,911,911,911,911,911,911,911,911,911,911,911,

/* block 105 */
911,911,911,911,911,911,911,911,911,911,911,911,911,196,196,196,
913,913,913,913,913,913,913,913,913,913,913,913,913,913,913,913,
913,913,913,913,913,913,913,913,913,913,913,913,913,913,913,913,
913,913,913,913,913,913,913,913,913,913,913,913,913,913,913,913,
913,913,913,913,913,913,913,196,196,196,196,196,196,196,196,196,
914,914,914,914,914,914,914,914,914,914,914,914,914,914,914,914,
914,914,914,914,914,914,914,914,914,914,914,914,914,914,914,914,
914,914,914,914,914,914,914,914,915,915,915,915,915,915,916,917,

/* block 106 */
918,918,918,918,918,918,918,918,918,918,918,918,918,918,918,918,
918,918,918,918,918,918,918,918,918,918,918,918,918,918,918,918,
918,918,918,918,918,918,918,918,918,918,918,918,918,918,918,918,
918,918,918,918,918,918,918,918,918,918,918,918,918,918,918,918,
918,918,918,918,918,918,918,918,918,918,918,918,918,918,918,918,
918,918,918,918,918,918,918,918,918,918,918,918,918,918,918,918,
918,918,918,918,918,918,918,918,918,918,918,918,918,918,918,918,
918,918,918,918,918,918,918,918,918,918,918,918,918,918,918,918,

/* block 107 */
918,918,918,918,918,918,918,918,918,918,918,918,919,920,921,921,
918,918,918,918,918,918,918,918,918,918,918,918,918,918,918,918,
922,922,922,922,922,922,922,922,922,922,918,918,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
275,276,275,276,275,276,275,276,275,276,923,924,275,276,275,276,
275,276,275,276,275,276,275,276,275,276,275,276,275,276,275,276,
275,276,275,276,275,276,275,276,275,276,275,276,275,276,925,281,
283,283,283,926,849,849,849,849,849,849,849,849,927,927,926,928,

/* block 108 */
275,276,275,276,275,276,275,276,275,276,275,276,275,276,275,276,
275,276,275,276,275,276,275,276,275,276,275,276,929,929,849,849,
930,930,930,930,930,930,930,930,930,930,930,930,930,930,930,930,
930,930,930,930,930,930,930,930,930,930,930,930,930,930,930,930,
930,930,930,930,930,930,930,930,930,930,930,930,930,930,930,930,
930,930,930,930,930,930,930,930,930,930,930,930,930,930,930,930,
930,930,930,930,930,930,931,931,931,931,931,931,931,931,931,931,
932,932,933,934,935,935,935,934,196,196,196,196,196,196,196,196,

/* block 109 */
936,936,936,936,936,936,936,936, 46, 46, 46, 46, 46, 46, 46, 46,
 46, 46, 46, 46, 46, 46, 46,151,151,151,151,151,151,151,151,151,
 46, 46, 65, 66, 65, 66, 65, 66, 65, 66, 65, 66, 65, 66, 65, 66,
 70, 70, 65, 66, 65, 66, 65, 66, 65, 66, 65, 66, 65, 66, 65, 66,
 65, 66, 65, 66, 65, 66, 65, 66, 65, 66, 65, 66, 65, 66, 65, 66,
 65, 66, 65, 66, 65, 66, 65, 66, 65, 66, 65, 66, 65, 66, 65, 66,
 65, 66, 65, 66, 65, 66, 65, 66, 65, 66, 65, 66, 65, 66, 65, 66,
695, 70, 70, 70, 70, 70, 70, 70, 70, 65, 66, 65, 66,937, 65, 66,

/* block 110 */
 65, 66, 65, 66, 65, 66, 65, 66,151,938,938, 65, 66,939, 70, 93,
 65, 66, 65, 66,940, 70, 65, 66, 65, 66, 65, 66, 65, 66, 65, 66,
 65, 66, 65, 66, 65, 66, 65, 66, 65, 66,941,942,943,944,941, 70,
945,946,947,948, 65, 66, 65, 66, 65, 66, 65, 66, 65, 66, 65, 66,
 65, 66, 65, 66,949,950,951, 65, 66, 65, 66,952, 65, 66,196,196,
 65, 66,196, 70,196, 70, 65, 66, 65, 66, 65, 66,953,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,695,695,695, 65, 66, 93,149,149, 70, 93, 93, 93, 93, 93,

/* block 111 */
954,954,955,954,954,954,956,954,954,954,954,955,954,954,954,954,
954,954,954,954,954,954,954,954,954,954,954,954,954,954,954,954,
954,954,954,957,957,955,955,957,958,958,958,958,956,196,196,196,
959,959,959,960,960,960,961,961,962,963,196,196,196,196,196,196,
964,964,964,964,964,964,964,964,964,964,964,964,964,964,964,964,
964,964,964,964,964,964,964,964,964,964,964,964,964,964,964,964,
964,964,964,964,964,964,964,964,964,964,964,964,964,964,964,964,
964,964,964,964,965,965,966,966,196,196,196,196,196,196,196,196,

/* block 112 */
967,967,968,968,968,968,968,968,968,968,968,968,968,968,968,968,
968,968,968,968,968,968,968,968,968,968,968,968,968,968,968,968,
968,968,968,968,968,968,968,968,968,968,968,968,968,968,968,968,
968,968,968,968,967,967,967,967,967,967,967,967,967,967,967,967,
967,967,967,967,969,970,196,196,196,196,196,196,196,196,971,971,
972,972,972,972,972,972,972,972,972,972,196,196,196,196,196,196,
378,378,378,378,378,378,378,378,378,378,378,378,378,378,378,378,
378,973,376,974,376,376,376,376,385,385,385,376,385,376,376,374,

/* block 113 */
975,975,975,975,975,975,975,975,975,975,976,976,976,976,976,976,
976,976,976,976,976,976,976,976,976,976,976,976,976,976,976,976,
976,976,976,976,976,976,977,977,977,977,977,978,978,978,979,980,
981,981,981,981,981,981,981,981,981,981,981,981,981,981,981,981,
981,981,981,981,981,981,981,982,982,982,982,982,982,982,982,982,
982,982,983,984,196,196,196,196,196,196,196,196,196,196,196,985,
528,528,528,528,528,528,528,528,528,528,528,528,528,528,528,528,
528,528,528,528,528,528,528,528,528,528,528,528,528,196,196,196,

/* block 114 */
986,986,986,987,988,988,988,988,988,988,988,988,988,988,988,988,
988,988,988,988,988,988,988,988,988,988,988,988,988,988,988,988,
988,988,988,988,988,988,988,988,988,988,988,988,988,988,988,988,
988,988,988,989,987,987,986,986,986,986,987,987,986,986,987,987,
990,991,991,991,991,991,991,992,993,993,991,991,991,991,196,994,
995,995,995,995,995,995,995,995,995,995,196,196,196,196,991,991,
511,511,511,511,511,521,996,511,511,511,511,511,511,511,511,511,
522,522,522,522,522,522,522,522,522,522,511,511,511,511,511,196,

/* block 115 */
997,997,997,997,997,997,997,997,997,997,997,997,997,997,997,997,
997,997,997,997,997,997,997,997,997,997,997,997,997,997,997,997,
997,997,997,997,997,997,997,997,997,998,998,998,998,998,998,999,
999,998,998,999,999,998,998,196,196,196,196,196,196,196,196,196,
997,997,997,998,997,997,997,997,997,997,997,997,998,999,196,196,
1000,1000,1000,1000,1000,1000,1000,1000,1000,1000,196,196,1001,1002,1002,1002,
511,511,511,511,511,511,511,511,511,511,511,511,511,511,511,511,
996,511,511,511,511,511,511,523,523,523,511,520,521,520,511,511,

/* block 116 */
1003,1003,1003,1003,1003,1003,1003,1003,1003,1003,1003,1003,1003,1003,1003,1003,
1003,1003,1003,1003,1003,1003,1003,1003,1003,1003,1003,1003,1003,1003,1003,1003,
1003,1003,1003,1003,1003,1003,1003,1003,1003,1003,1003,1003,1003,1003,1003,1003,
1004,1003,1004,1004,1004,1005,1005,1004,1004,1005,1003,1005,1005,1003,1004,1006,
1007,1006,1007,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,1003,1003,1008,1009,1010,
1011,1011,1011,1011,1011,1011,1011,1011,1011,1011,1011,1012,1013,1013,1012,1012,
1014,1014,1011,1015,1015,1012,1016,196,196,196,196,196,196,196,196,196,

/* block 117 */
196,533,533,533,533,533,533,196,196,533,533,533,533,533,533,196,
196,533,533,533,533,533,533,196,196,196,196,196,196,196,196,196,
533,533,533,533,533,533,533,196,533,533,533,533,533,533,533,196,
 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70,
 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70,
 70, 70, 70,1017, 70, 70, 70, 70, 70, 70, 70,938,149,149,149,149,
 70, 70, 70, 70, 70,256, 70, 70, 70,149, 46, 46,196,196,196,196,
1018,1018,1018,1018,1018,1018,1018,1018,1018,1018,1018,1018,1018,1018,1018,1018,

/* block 118 */
1018,1018,1018,1018,1018,1018,1018,1018,1018,1018,1018,1018,1018,1018,1018,1018,
1018,1018,1018,1018,1018,1018,1018,1018,1018,1018,1018,1018,1018,1018,1018,1018,
1018,1018,1018,1018,1018,1018,1018,1018,1018,1018,1018,1018,1018,1018,1018,1018,
1018,1018,1018,1018,1018,1018,1018,1018,1018,1018,1018,1018,1018,1018,1018,1018,
1011,1011,1011,1011,1011,1011,1011,1011,1011,1011,1011,1011,1011,1011,1011,1011,
1011,1011,1011,1011,1011,1011,1011,1011,1011,1011,1011,1011,1011,1011,1011,1011,
1011,1011,1011,1012,1012,1013,1012,1012,1013,1012,1012,1014,1019,1016,196,196,
1020,1020,1020,1020,1020,1020,1020,1020,1020,1020,196,196,196,196,196,196,

/* block 119 */
1021,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,
1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1021,1022,1022,1022,
1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,
1022,1022,1022,1022,1022,1022,1022,1022,1021,1022,1022,1022,1022,1022,1022,1022,
1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,
1022,1022,1022,1022,1021,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,
1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,
1021,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,

/* block 120 */
1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1021,1022,1022,1022,
1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,
1022,1022,1022,1022,1022,1022,1022,1022,1021,1022,1022,1022,1022,1022,1022,1022,
1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,
1022,1022,1022,1022,1021,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,
1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,
1021,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,
1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1021,1022,1022,1022,

/* block 121 */
1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,
1022,1022,1022,1022,1022,1022,1022,1022,1021,1022,1022,1022,1022,1022,1022,1022,
1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,
1022,1022,1022,1022,1021,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,
1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,
1021,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,
1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1021,1022,1022,1022,
1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,

/* block 122 */
1022,1022,1022,1022,1022,1022,1022,1022,1021,1022,1022,1022,1022,1022,1022,1022,
1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,
1022,1022,1022,1022,1021,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,
1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,
1021,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,
1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1021,1022,1022,1022,
1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,
1022,1022,1022,1022,1022,1022,1022,1022,1021,1022,1022,1022,1022,1022,1022,1022,

/* block 123 */
1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,
1022,1022,1022,1022,1021,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,
1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,
1021,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,
1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1021,1022,1022,1022,
1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,
1022,1022,1022,1022,1022,1022,1022,1022,1021,1022,1022,1022,1022,1022,1022,1022,
1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,

/* block 124 */
1022,1022,1022,1022,1021,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,
1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,
1021,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,
1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1021,1022,1022,1022,
1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,
1022,1022,1022,1022,1022,1022,1022,1022,1021,1022,1022,1022,1022,1022,1022,1022,
1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,
1022,1022,1022,1022,1021,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,

/* block 125 */
1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,
1021,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,
1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1021,1022,1022,1022,
1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,
1022,1022,1022,1022,1022,1022,1022,1022,1021,1022,1022,1022,1022,1022,1022,1022,
1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,
1022,1022,1022,1022,1021,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,
1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,

/* block 126 */
1022,1022,1022,1022,1022,1022,1022,1022,1021,1022,1022,1022,1022,1022,1022,1022,
1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,1022,
1022,1022,1022,1022,196,196,196,196,196,196,196,196,196,196,196,196,
531,531,531,531,531,531,531,531,531,531,531,531,531,531,531,531,
531,531,531,531,531,531,531,196,196,196,196,532,532,532,532,532,
532,532,532,532,532,532,532,532,532,532,532,532,532,532,532,532,
532,532,532,532,532,532,532,532,532,532,532,532,532,532,532,532,
532,532,532,532,532,532,532,532,532,532,532,532,196,196,196,196,

/* block 127 */
1023,1023,1023,1023,1023,1023,1023,1023,1023,1023,1023,1023,1023,1023,1023,1023,
1023,1023,1023,1023,1023,1023,1023,1023,1023,1023,1023,1023,1023,1023,1023,1023,
1023,1023,1023,1023,1023,1023,1023,1023,1023,1023,1023,1023,1023,1023,1023,1023,
1023,1023,1023,1023,1023,1023,1023,1023,1023,1023,1023,1023,1023,1023,1023,1023,
1023,1023,1023,1023,1023,1023,1023,1023,1023,1023,1023,1023,1023,1023,1023,1023,
1023,1023,1023,1023,1023,1023,1023,1023,1023,1023,1023,1023,1023,1023,1023,1023,
1023,1023,1023,1023,1023,1023,1023,1023,1023,1023,1023,1023,1023,1023,1023,1023,
1023,1023,1023,1023,1023,1023,1023,1023,1023,1023,1023,1023,1023,1023,1023,1023,

/* block 128 */
1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,
1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,
1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,
1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,
1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,
1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,
1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,
1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,

/* block 129 */
1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,
1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,
1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,
1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,
1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,
1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,
1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,
1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,

/* block 130 */
1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,910,910,
1025,910,1025,910,910,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,910,
1025,910,1025,910,910,1025,1025,910,910,910,1025,1025,1025,1025,1025,1025,
1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,
1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,
1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,
1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,196,196,
1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,

/* block 131 */
1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,
1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,
1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,
1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,
1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,
1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,

/* block 132 */
703,703,703,703,703,1026,1027,196,196,196,196,196,196,196,196,196,
196,196,196,292,292,292,292,292,196,196,196,196,196,305,300,305,
305,305,305,305,305,305,305,305,305,1028,305,305,305,305,305,305,
305,305,305,305,305,305,305,297,305,305,305,305,305,297,305,297,
305,305,297,305,305,297,305,305,305,305,305,305,305,305,305,305,
321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,
321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,
321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,

/* block 133 */
321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,
321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,
321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,
321,321,370,370,370,370,370,370,370,370,370,370,370,370,370,370,
370,370,370,340,340,340,340,340,340,340,340,340,340,340,340,340,
340,340,340,321,321,321,321,321,321,321,321,321,321,321,321,321,
321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,
321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,

/* block 134 */
321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,
321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,
321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,
321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,
321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,
321,321,321,321,321,321,321,321,321,321,321,321,321,321,1029,1029,
1029,1029,1029,1029,321,321,321,321,321,321,321,321,321,321,321,321,
321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,

/* block 135 */
321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,
321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,
321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,
321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,
321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,
321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,
321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,
321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,

/* block 136 */
321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,
321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,
321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,
321,321,321,321,321,321,321,321,321,321,321,321,321,321,1030,1031,
315,315,315,315,315,315,315,315,315,315,315,315,315,315,315,315,
321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,
321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,
321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,

/* block 137 */
321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,
340,340,321,321,321,321,321,321,321,321,321,321,321,321,321,321,
321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,
321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,
321,321,321,321,321,321,321,321,340,340,340,340,340,340,340,315,
1032,1032,1032,1032,1032,1032,1032,1032,1032,1032,1032,1032,1032,1032,1032,1032,
1032,1032,1032,1032,1032,1032,1032,1032,1032,1032,1032,1032,1032,1032,1032,1032,
321,321,1033,321,321,321,321,321,321,321,1029,1029,312,1034,315,315,

/* block 138 */
1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1036,
1037,1037,1038,1039,1037,1038,1038,1040,1041,1037,196,196,196,196,196,196,
176,176,176,176,176,176,176,176,176,176,176,176,176,176,927,927,
1037,1042,1042,755,755,1040,1041,1040,1041,1040,1041,1040,1041,1040,1041,1040,
1041,1043,1044,1043,1044,866,866,1040,1041,1037,1037,1037,1037,755,755,755,
1045,199,1046,196,199,1047,1038,1038,1042,1048,1049,1048,1049,1048,1049,1050,
1037,1051,1052,1053,1054,1054,794,196,1051,479,1050,1037,196,196,196,196,
1029,321,1029,321,1029,340,1029,321,1029,321,1029,321,1029,321,1029,321,

/* block 139 */
321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,
321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,
321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,
321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,
321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,
321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,
321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,
321,321,321,321,321,321,321,321,321,321,321,321,321,340,340, 51,

/* block 140 */
196,1038,1055,1050,479,1050,1037,1056,1048,1049,1037,1052,1045,1057,1046,1058,
1059,1059,1059,1059,1059,1059,1059,1059,1059,1059,1047,199,1054,794,1054,1038,
1037,1060,1060,1060,1060,1060,1060, 59, 59, 59, 59, 59, 59, 59, 59, 59,
 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59,1048,1051,1049,1061,755,
 46,1062,1062,1062,1062,1062,1062, 62, 62, 62, 62, 62, 62, 62, 62, 62,
 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62,1048,794,1049,794,1048,
1049,1063,1064,1065,1066,897,896,896,896,896,896,896,896,896,896,896,
898,896,896,896,896,896,896,896,896,896,896,896,896,896,896,896,

/* block 141 */
896,896,896,896,896,896,896,896,896,896,896,896,896,896,896,896,
896,896,896,896,896,896,896,896,896,896,896,896,896,896,1067,1067,
902,901,901,901,901,901,901,901,901,901,901,901,901,901,901,901,
901,901,901,901,901,901,901,901,901,901,901,901,901,901,901,196,
196,196,901,901,901,901,901,901,196,196,901,901,901,901,901,901,
196,196,901,901,901,901,901,901,196,196,901,901,901,196,196,196,
479,479,794, 46,781,479,479,196,781,794,794,794,794,781,781,196,
765,765,765,765,765,765,765,765,765,1068,1068,1068,781,781,1032,1032,

/* block 142 */
1069,1069,1069,1069,1069,1069,1069,1069,1069,1069,1069,1069,196,1069,1069,1069,
1069,1069,1069,1069,1069,1069,1069,1069,1069,1069,1069,1069,1069,1069,1069,1069,
1069,1069,1069,1069,1069,1069,1069,196,1069,1069,1069,1069,1069,1069,1069,1069,
1069,1069,1069,1069,1069,1069,1069,1069,1069,1069,1069,196,1069,1069,196,1069,
1069,1069,1069,1069,1069,1069,1069,1069,1069,1069,1069,1069,1069,1069,196,196,
1069,1069,1069,1069,1069,1069,1069,1069,1069,1069,1069,1069,1069,1069,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,

/* block 143 */
1069,1069,1069,1069,1069,1069,1069,1069,1069,1069,1069,1069,1069,1069,1069,1069,
1069,1069,1069,1069,1069,1069,1069,1069,1069,1069,1069,1069,1069,1069,1069,1069,
1069,1069,1069,1069,1069,1069,1069,1069,1069,1069,1069,1069,1069,1069,1069,1069,
1069,1069,1069,1069,1069,1069,1069,1069,1069,1069,1069,1069,1069,1069,1069,1069,
1069,1069,1069,1069,1069,1069,1069,1069,1069,1069,1069,1069,1069,1069,1069,1069,
1069,1069,1069,1069,1069,1069,1069,1069,1069,1069,1069,1069,1069,1069,1069,1069,
1069,1069,1069,1069,1069,1069,1069,1069,1069,1069,1069,1069,1069,1069,1069,1069,
1069,1069,1069,1069,1069,1069,1069,1069,1069,1069,1069,196,196,196,196,196,

/* block 144 */
1070,1071,1072,196,196,196,196,1073,1073,1073,1073,1073,1073,1073,1073,1073,
1073,1073,1073,1073,1073,1073,1073,1073,1073,1073,1073,1073,1073,1073,1073,1073,
1073,1073,1073,1073,1073,1073,1073,1073,1073,1073,1073,1073,1073,1073,1073,1073,
1073,1073,1073,1073,196,196,196,1074,1074,1074,1074,1074,1074,1074,1074,1074,
1075,1075,1075,1075,1075,1075,1075,1075,1075,1075,1075,1075,1075,1075,1075,1075,
1075,1075,1075,1075,1075,1075,1075,1075,1075,1075,1075,1075,1075,1075,1075,1075,
1075,1075,1075,1075,1075,1075,1075,1075,1075,1075,1075,1075,1075,1075,1075,1075,
1075,1075,1075,1075,1075,1076,1076,1076,1076,1077,1077,1077,1077,1077,1077,1077,

/* block 145 */
1077,1077,1077,1077,1077,1077,1077,1077,1077,1077,1076,1076,1077,1078,1078,196,
781,781,781,781,781,781,781,781,781,781,781,781,781,196,196,196,
1077,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
510,510,510,510,510,510,510,510,510,510,510,510,510,510,510,510,
510,510,510,510,510,510,510,510,510,510,510,510,510,510,510,510,
510,510,510,510,510,510,510,510,510,510,510,510,510,189,196,196,

/* block 146 */
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,

/* block 147 */
1079,1079,1079,1079,1079,1079,1079,1079,1079,1079,1079,1079,1079,1079,1079,1079,
1079,1079,1079,1079,1079,1079,1079,1079,1079,1079,1079,1079,1079,196,196,196,
1080,1080,1080,1080,1080,1080,1080,1080,1080,1080,1080,1080,1080,1080,1080,1080,
1080,1080,1080,1080,1080,1080,1080,1080,1080,1080,1080,1080,1080,1080,1080,1080,
1080,1080,1080,1080,1080,1080,1080,1080,1080,1080,1080,1080,1080,1080,1080,1080,
1080,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
1081,1082,1082,1082,1082,1082,1082,1082,1082,1082,1082,1082,1082,1082,1082,1082,
1082,1082,1082,1082,1082,1082,1082,1082,1082,1082,1082,1082,196,196,196,196,

/* block 148 */
1083,1083,1083,1083,1083,1083,1083,1083,1083,1083,1083,1083,1083,1083,1083,1083,
1083,1083,1083,1083,1083,1083,1083,1083,1083,1083,1083,1083,1083,1083,1083,1083,
1084,1084,1084,1084,196,196,196,196,196,196,196,196,196,1083,1083,1083,
1085,1085,1085,1085,1085,1085,1085,1085,1085,1085,1085,1085,1085,1085,1085,1085,
1085,1086,1085,1085,1085,1085,1085,1085,1085,1085,1086,196,196,196,196,196,
1087,1087,1087,1087,1087,1087,1087,1087,1087,1087,1087,1087,1087,1087,1087,1087,
1087,1087,1087,1087,1087,1087,1087,1087,1087,1087,1087,1087,1087,1087,1087,1087,
1087,1087,1087,1087,1087,1087,1088,1088,1088,1088,1088,196,196,196,196,196,

/* block 149 */
1089,1089,1089,1089,1089,1089,1089,1089,1089,1089,1089,1089,1089,1089,1089,1089,
1089,1089,1089,1089,1089,1089,1089,1089,1089,1089,1089,1089,1089,1089,196,1090,
1091,1091,1091,1091,1091,1091,1091,1091,1091,1091,1091,1091,1091,1091,1091,1091,
1091,1091,1091,1091,1091,1091,1091,1091,1091,1091,1091,1091,1091,1091,1091,1091,
1091,1091,1091,1091,196,196,196,196,1091,1091,1091,1091,1091,1091,1091,1091,
1092,1093,1093,1093,1093,1093,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,

/* block 150 */
1094,1094,1094,1094,1094,1094,1094,1094,1094,1094,1094,1094,1094,1094,1094,1094,
1094,1094,1094,1094,1094,1094,1094,1094,1094,1094,1094,1094,1094,1094,1094,1094,
1094,1094,1094,1094,1094,1094,1094,1094,1095,1095,1095,1095,1095,1095,1095,1095,
1095,1095,1095,1095,1095,1095,1095,1095,1095,1095,1095,1095,1095,1095,1095,1095,
1095,1095,1095,1095,1095,1095,1095,1095,1095,1095,1095,1095,1095,1095,1095,1095,
1096,1096,1096,1096,1096,1096,1096,1096,1096,1096,1096,1096,1096,1096,1096,1096,
1096,1096,1096,1096,1096,1096,1096,1096,1096,1096,1096,1096,1096,1096,1096,1096,
1096,1096,1096,1096,1096,1096,1096,1096,1096,1096,1096,1096,1096,1096,1096,1096,

/* block 151 */
1097,1097,1097,1097,1097,1097,1097,1097,1097,1097,1097,1097,1097,1097,1097,1097,
1097,1097,1097,1097,1097,1097,1097,1097,1097,1097,1097,1097,1097,1097,196,196,
1098,1098,1098,1098,1098,1098,1098,1098,1098,1098,196,196,196,196,196,196,
1099,1099,1099,1099,1099,1099,1099,1099,1099,1099,1099,1099,1099,1099,1099,1099,
1099,1099,1099,1099,1099,1099,1099,1099,1099,1099,1099,1099,1099,1099,1099,1099,
1099,1099,1099,1099,196,196,196,196,1100,1100,1100,1100,1100,1100,1100,1100,
1100,1100,1100,1100,1100,1100,1100,1100,1100,1100,1100,1100,1100,1100,1100,1100,
1100,1100,1100,1100,1100,1100,1100,1100,1100,1100,1100,1100,196,196,196,196,

/* block 152 */
1101,1101,1101,1101,1101,1101,1101,1101,1101,1101,1101,1101,1101,1101,1101,1101,
1101,1101,1101,1101,1101,1101,1101,1101,1101,1101,1101,1101,1101,1101,1101,1101,
1101,1101,1101,1101,1101,1101,1101,1101,196,196,196,196,196,196,196,196,
1102,1102,1102,1102,1102,1102,1102,1102,1102,1102,1102,1102,1102,1102,1102,1102,
1102,1102,1102,1102,1102,1102,1102,1102,1102,1102,1102,1102,1102,1102,1102,1102,
1102,1102,1102,1102,1102,1102,1102,1102,1102,1102,1102,1102,1102,1102,1102,1102,
1102,1102,1102,1102,196,196,196,196,196,196,196,196,196,196,196,1103,
1104,1104,1104,1104,1104,1104,1104,1104,1104,1104,1104,196,1104,1104,1104,1104,

/* block 153 */
1104,1104,1104,1104,1104,1104,1104,1104,1104,1104,1104,196,1104,1104,1104,1104,
1104,1104,1104,196,1104,1104,196,1105,1105,1105,1105,1105,1105,1105,1105,1105,
1105,1105,196,1105,1105,1105,1105,1105,1105,1105,1105,1105,1105,1105,1105,1105,
1105,1105,196,1105,1105,1105,1105,1105,1105,1105,196,1105,1105,196,196,196,
1106,1106,1106,1106,1106,1106,1106,1106,1106,1106,1106,1106,1106,1106,1106,1106,
1106,1106,1106,1106,1106,1106,1106,1106,1106,1106,1106,1106,1106,1106,1106,1106,
1106,1106,1106,1106,1106,1106,1106,1106,1106,1106,1106,1106,1106,1106,1106,1106,
1106,1106,1106,1106,196,196,196,196,196,196,196,196,196,196,196,196,

/* block 154 */
1107,1107,1107,1107,1107,1107,1107,1107,1107,1107,1107,1107,1107,1107,1107,1107,
1107,1107,1107,1107,1107,1107,1107,1107,1107,1107,1107,1107,1107,1107,1107,1107,
1107,1107,1107,1107,1107,1107,1107,1107,1107,1107,1107,1107,1107,1107,1107,1107,
1107,1107,1107,1107,1107,1107,1107,1107,1107,1107,1107,1107,1107,1107,1107,1107,
1107,1107,1107,1107,1107,1107,1107,1107,1107,1107,1107,1107,1107,1107,1107,1107,
1107,1107,1107,1107,1107,1107,1107,1107,1107,1107,1107,1107,1107,1107,1107,1107,
1107,1107,1107,1107,1107,1107,1107,1107,1107,1107,1107,1107,1107,1107,1107,1107,
1107,1107,1107,1107,1107,1107,1107,1107,1107,1107,1107,1107,1107,1107,1107,1107,

/* block 155 */
1107,1107,1107,1107,1107,1107,1107,1107,1107,1107,1107,1107,1107,1107,1107,1107,
1107,1107,1107,1107,1107,1107,1107,1107,1107,1107,1107,1107,1107,1107,1107,1107,
1107,1107,1107,1107,1107,1107,1107,1107,1107,1107,1107,1107,1107,1107,1107,1107,
1107,1107,1107,1107,1107,1107,1107,196,196,196,196,196,196,196,196,196,
1107,1107,1107,1107,1107,1107,1107,1107,1107,1107,1107,1107,1107,1107,1107,1107,
1107,1107,1107,1107,1107,1107,196,196,196,196,196,196,196,196,196,196,
1107,1107,1107,1107,1107,1107,1107,1107,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,

/* block 156 */
149,1108,1108,149,149,149,196,149,149,149,149,149,149,149,149,149,
149,149,149,149,149,149,149,149,149,149,149,149,149,149,149,149,
149,149,149,149,149,149,149,149,149,149,149,149,149,149,149,149,
149,196,149,149,149,149,149,149,149,149,149,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,

/* block 157 */
1109,1109,1109,1109,1109,1109,297,297,1109,297,1109,1109,1109,1109,1109,1109,
1109,1109,1109,1109,1109,1109,1109,1109,1109,1109,1109,1109,1109,1109,1109,1109,
1109,1109,1109,1109,1109,1109,1109,1109,1109,1109,1109,1109,1109,1109,1109,1109,
1109,1109,1109,1109,1109,1109,297,1109,1109,297,297,297,1109,297,297,1109,
1110,1110,1110,1110,1110,1110,1110,1110,1110,1110,1110,1110,1110,1110,1110,1110,
1110,1110,1110,1110,1110,1110,297,1111,1112,1112,1112,1112,1112,1112,1112,1112,
1113,1113,1113,1113,1113,1113,1113,1113,1113,1113,1113,1113,1113,1113,1113,1113,
1113,1113,1113,1113,1113,1113,1113,1114,1114,1115,1115,1115,1115,1115,1115,1115,

/* block 158 */
1116,1116,1116,1116,1116,1116,1116,1116,1116,1116,1116,1116,1116,1116,1116,1116,
1116,1116,1116,1116,1116,1116,1116,1116,1116,1116,1116,1116,1116,1116,1116,297,
297,297,297,297,297,297,297,1117,1117,1117,1117,1117,1117,1117,1117,1117,
297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,
297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,
297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,
1118,1118,1118,1118,1118,1118,1118,1118,1118,1118,1118,1118,1118,1118,1118,1118,
1118,1118,1118,297,1118,1118,297,297,297,297,297,1119,1119,1119,1119,1119,

/* block 159 */
1120,1120,1120,1120,1120,1120,1120,1120,1120,1120,1120,1120,1120,1120,1120,1120,
1120,1120,1120,1120,1120,1120,1121,1121,1121,1121,1121,1121,297,297,297,1122,
1123,1123,1123,1123,1123,1123,1123,1123,1123,1123,1123,1123,1123,1123,1123,1123,
1123,1123,1123,1123,1123,1123,1123,1123,1123,1123,297,297,297,297,297,1124,
297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,
297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,
297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,
297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,

/* block 160 */
1125,1125,1125,1125,1125,1125,1125,1125,1125,1125,1125,1125,1125,1125,1125,1125,
1125,1125,1125,1125,1125,1125,1125,1125,1125,1125,1125,1125,1125,1125,1125,1125,
1126,1126,1126,1126,1126,1126,1126,1126,1126,1126,1126,1126,1126,1126,1126,1126,
1126,1126,1126,1126,1126,1126,1126,1126,297,297,297,297,1127,1127,1126,1126,
1127,1127,1127,1127,1127,1127,1127,1127,1127,1127,1127,1127,1127,1127,1127,1127,
297,297,1127,1127,1127,1127,1127,1127,1127,1127,1127,1127,1127,1127,1127,1127,
1127,1127,1127,1127,1127,1127,1127,1127,1127,1127,1127,1127,1127,1127,1127,1127,
1127,1127,1127,1127,1127,1127,1127,1127,1127,1127,1127,1127,1127,1127,1127,1127,

/* block 161 */
1128,1129,1129,1129,297,1129,1129,297,297,297,297,297,1129,1129,1129,1129,
1128,1128,1128,1128,297,1128,1128,1128,297,1128,1128,1128,1128,1128,1128,1128,
1128,1128,1128,1128,1128,1128,1128,1128,1128,1128,1128,1128,1128,1128,1128,1128,
1128,1128,1128,1128,1128,1128,297,297,1130,1130,1130,297,297,297,297,1131,
1132,1132,1132,1132,1132,1132,1132,1132,1132,297,297,297,297,297,297,297,
1133,1133,1133,1133,1133,1133,1134,1134,1133,297,297,297,297,297,297,297,
1135,1135,1135,1135,1135,1135,1135,1135,1135,1135,1135,1135,1135,1135,1135,1135,
1135,1135,1135,1135,1135,1135,1135,1135,1135,1135,1135,1135,1135,1136,1136,1137,

/* block 162 */
1138,1138,1138,1138,1138,1138,1138,1138,1138,1138,1138,1138,1138,1138,1138,1138,
1138,1138,1138,1138,1138,1138,1138,1138,1138,1138,1138,1138,1138,1139,1139,1139,
297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,
297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,
1140,1140,1140,1140,1140,1140,1140,1140,1141,1140,1140,1140,1140,1140,1140,1140,
1140,1140,1140,1140,1140,1140,1140,1140,1140,1140,1140,1140,1140,1140,1140,1140,
1140,1140,1140,1140,1140,1142,1142,297,297,297,297,1143,1143,1143,1143,1143,
1144,1144,1145,1144,1144,1144,1146,297,297,297,297,297,297,297,297,297,

/* block 163 */
1147,1147,1147,1147,1147,1147,1147,1147,1147,1147,1147,1147,1147,1147,1147,1147,
1147,1147,1147,1147,1147,1147,1147,1147,1147,1147,1147,1147,1147,1147,1147,1147,
1147,1147,1147,1147,1147,1147,1147,1147,1147,1147,1147,1147,1147,1147,1147,1147,
1147,1147,1147,1147,1147,1147,297,297,297,1148,1149,1149,1149,1149,1149,1149,
1150,1150,1150,1150,1150,1150,1150,1150,1150,1150,1150,1150,1150,1150,1150,1150,
1150,1150,1150,1150,1150,1150,297,297,1151,1151,1151,1151,1151,1151,1151,1151,
1152,1152,1152,1152,1152,1152,1152,1152,1152,1152,1152,1152,1152,1152,1152,1152,
1152,1152,1152,297,297,297,297,297,1153,1153,1153,1153,1153,1153,1153,1153,

/* block 164 */
1154,1154,1154,1154,1154,1154,1154,1154,1154,1154,1154,1154,1154,1154,1154,1154,
1154,1154,297,297,297,297,297,297,297,1155,1155,1155,1155,297,297,297,
297,297,297,297,297,297,297,297,297,1156,1156,1156,1156,1156,1156,1156,
297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,
297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,
297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,
297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,
297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,

/* block 165 */
1157,1157,1157,1157,1157,1157,1157,1157,1157,1157,1157,1157,1157,1157,1157,1157,
1157,1157,1157,1157,1157,1157,1157,1157,1157,1157,1157,1157,1157,1157,1157,1157,
1157,1157,1157,1157,1157,1157,1157,1157,1157,1157,1157,1157,1157,1157,1157,1157,
1157,1157,1157,1157,1157,1157,1157,1157,1157,1157,1157,1157,1157,1157,1157,1157,
1157,1157,1157,1157,1157,1157,1157,1157,1157,297,297,297,297,297,297,297,
297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,
297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,
297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,

/* block 166 */
1158,1158,1158,1158,1158,1158,1158,1158,1158,1158,1158,1158,1158,1158,1158,1158,
1158,1158,1158,1158,1158,1158,1158,1158,1158,1158,1158,1158,1158,1158,1158,1158,
1158,1158,1158,1158,1158,1158,1158,1158,1158,1158,1158,1158,1158,1158,1158,1158,
1158,1158,1158,297,297,297,297,297,297,297,297,297,297,297,297,297,
1159,1159,1159,1159,1159,1159,1159,1159,1159,1159,1159,1159,1159,1159,1159,1159,
1159,1159,1159,1159,1159,1159,1159,1159,1159,1159,1159,1159,1159,1159,1159,1159,
1159,1159,1159,1159,1159,1159,1159,1159,1159,1159,1159,1159,1159,1159,1159,1159,
1159,1159,1159,297,297,297,297,297,297,297,1160,1160,1160,1160,1160,1160,

/* block 167 */
1161,1161,1161,1161,1161,1161,1161,1161,1161,1161,1161,1161,1161,1161,1161,1161,
1161,1161,1161,1161,1161,1161,1161,1161,1161,1161,1161,1161,1161,1161,1161,1161,
1161,1161,1162,1162,1163,1163,1163,1163,340,340,340,340,340,340,340,340,
1164,1164,1164,1164,1164,1164,1164,1164,1164,1164,340,340,340,340,340,340,
1165,1165,1165,1165,1165,1165,1165,1165,1165,1165,1166,1166,1166,1166,1167,1166,
1168,1168,1168,1168,1168,1168,1168,1168,1168,1168,1168,1168,1168,1168,1168,1168,
1168,1168,1168,1168,1168,1168,297,297,297,1169,1170,1171,1171,1171,1172,1173,
1174,1174,1174,1174,1174,1174,1174,1174,1174,1174,1174,1174,1174,1174,1174,1174,

/* block 168 */
1174,1174,1174,1174,1174,1174,297,297,297,297,297,297,297,297,1175,1175,
297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,
297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,
297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,
297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,
297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,
297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,
297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,

/* block 169 */
297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,
297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,
297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,
297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,
297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,
297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,
1176,1176,1176,1176,1176,1176,1176,1176,1176,1176,1176,1176,1176,1176,1176,1176,
1176,1176,1176,1176,1176,1176,1176,1176,1176,1176,1176,1176,1176,1176,1176,297,

/* block 170 */
1177,1177,1177,1177,1177,1177,1177,1177,1177,1177,1177,1177,1177,1177,1177,1177,
1177,1177,1177,1177,1177,1177,1177,1177,1177,1177,1177,1177,1177,1177,1177,1177,
1177,1177,1177,1177,1177,1177,1177,1177,1177,1177,297,1178,1178,1179,297,297,
1177,1177,297,297,297,297,297,297,297,297,297,297,297,297,297,297,
340,340,321,321,321,340,340,340,340,340,340,340,340,340,340,340,
340,340,340,340,340,340,340,340,340,340,340,340,340,340,340,340,
340,340,340,340,340,340,340,340,340,340,340,340,340,340,340,340,
340,340,340,340,340,340,340,340,340,340,340,340,316,333,333,333,

/* block 171 */
1180,1180,1180,1180,1180,1180,1180,1180,1180,1180,1180,1180,1180,1180,1180,1180,
1180,1180,1180,1180,1180,1180,1180,1180,1180,1180,1180,1180,1180,1181,1181,1181,
1181,1181,1181,1181,1181,1181,1181,1180,297,297,297,297,297,297,297,297,
1182,1182,1182,1182,1182,1182,1182,1182,1182,1182,1182,1182,1182,1182,1182,1182,
1182,1182,1182,1182,1182,1182,1183,1183,1183,1183,1183,1183,1183,1183,1183,1183,
1183,1184,1184,1184,1184,1185,1185,1185,1185,1185,340,340,340,340,340,340,
340,340,340,340,340,340,340,340,340,340,340,340,340,340,340,340,
1186,1186,1186,1186,1186,1186,1186,1186,1186,1186,1186,1186,1186,1186,1186,1186,

/* block 172 */
1186,1186,1187,1187,1187,1187,1188,1188,1188,1188,297,297,297,297,297,297,
297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,
297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,
1189,1189,1189,1189,1189,1189,1189,1189,1189,1189,1189,1189,1189,1189,1189,1189,
1189,1189,1189,1189,1189,1190,1190,1190,1190,1190,1190,1190,297,297,297,297,
297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,
1191,1191,1191,1191,1191,1191,1191,1191,1191,1191,1191,1191,1191,1191,1191,1191,
1191,1191,1191,1191,1191,1191,1191,297,297,297,297,297,297,297,297,297,

/* block 173 */
1192,1193,1192,1194,1194,1194,1194,1194,1194,1194,1194,1194,1194,1194,1194,1194,
1194,1194,1194,1194,1194,1194,1194,1194,1194,1194,1194,1194,1194,1194,1194,1194,
1194,1194,1194,1194,1194,1194,1194,1194,1194,1194,1194,1194,1194,1194,1194,1194,
1194,1194,1194,1194,1194,1194,1194,1194,1193,1193,1193,1193,1193,1193,1193,1193,
1193,1193,1193,1193,1193,1193,1195,1196,1196,1197,1197,1197,1197,1197,196,196,
196,196,1198,1198,1198,1198,1198,1198,1198,1198,1198,1198,1198,1198,1198,1198,
1198,1198,1198,1198,1198,1198,1199,1199,1199,1199,1199,1199,1199,1199,1199,1199,
1195,1194,1194,1193,1193,1194,196,196,196,196,196,196,196,196,196,1200,

/* block 174 */
1201,1201,1202,1203,1203,1203,1203,1203,1203,1203,1203,1203,1203,1203,1203,1203,
1203,1203,1203,1203,1203,1203,1203,1203,1203,1203,1203,1203,1203,1203,1203,1203,
1203,1203,1203,1203,1203,1203,1203,1203,1203,1203,1203,1203,1203,1203,1203,1203,
1202,1202,1202,1201,1201,1201,1201,1202,1202,1204,1205,1206,1206,1207,1208,1208,
1208,1208,1201,196,196,196,196,196,196,196,196,196,196,1207,196,196,
1209,1209,1209,1209,1209,1209,1209,1209,1209,1209,1209,1209,1209,1209,1209,1209,
1209,1209,1209,1209,1209,1209,1209,1209,1209,196,196,196,196,196,196,196,
1210,1210,1210,1210,1210,1210,1210,1210,1210,1210,196,196,196,196,196,196,

/* block 175 */
1211,1211,1211,1212,1212,1212,1212,1212,1212,1212,1212,1212,1212,1212,1212,1212,
1212,1212,1212,1212,1212,1212,1212,1212,1212,1212,1212,1212,1212,1212,1212,1212,
1212,1212,1212,1212,1212,1212,1212,1211,1211,1211,1211,1211,1213,1211,1211,1211,
1211,1211,1211,1214,1214,196,1215,1215,1215,1215,1215,1215,1215,1215,1215,1215,
1216,1217,1217,1217,1212,1213,1213,1212,196,196,196,196,196,196,196,196,
1218,1218,1218,1218,1218,1218,1218,1218,1218,1218,1218,1218,1218,1218,1218,1218,
1218,1218,1218,1218,1218,1218,1218,1218,1218,1218,1218,1218,1218,1218,1218,1218,
1218,1218,1218,1219,1220,1220,1218,196,196,196,196,196,196,196,196,196,

/* block 176 */
1221,1221,1222,1223,1223,1223,1223,1223,1223,1223,1223,1223,1223,1223,1223,1223,
1223,1223,1223,1223,1223,1223,1223,1223,1223,1223,1223,1223,1223,1223,1223,1223,
1223,1223,1223,1223,1223,1223,1223,1223,1223,1223,1223,1223,1223,1223,1223,1223,
1223,1223,1223,1222,1222,1222,1221,1221,1221,1221,1221,1221,1221,1221,1221,1222,
1224,1223,1225,1225,1223,1226,1226,1227,1227,1228,1229,1229,1229,1226,1222,1221,
1230,1230,1230,1230,1230,1230,1230,1230,1230,1230,1223,1227,1223,1227,1226,1226,
196,1231,1231,1231,1231,1231,1231,1231,1231,1231,1231,1231,1231,1231,1231,1231,
1231,1231,1231,1231,1231,196,196,196,196,196,196,196,196,196,196,196,

/* block 177 */
1232,1232,1232,1232,1232,1232,1232,1232,1232,1232,1232,1232,1232,1232,1232,1232,
1232,1232,196,1232,1232,1232,1232,1232,1232,1232,1232,1232,1232,1232,1232,1232,
1232,1232,1232,1232,1232,1232,1232,1232,1232,1232,1232,1232,1233,1233,1233,1234,
1234,1234,1233,1233,1234,1235,1236,1237,1238,1238,1239,1238,1238,1240,1234,1232,
1232,1234,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,

/* block 178 */
1241,1241,1241,1241,1241,1241,1241,196,1241,196,1241,1241,1241,1241,196,1241,
1241,1241,1241,1241,1241,1241,1241,1241,1241,1241,1241,1241,1241,1241,196,1241,
1241,1241,1241,1241,1241,1241,1241,1241,1241,1242,196,196,196,196,196,196,
1243,1243,1243,1243,1243,1243,1243,1243,1243,1243,1243,1243,1243,1243,1243,1243,
1243,1243,1243,1243,1243,1243,1243,1243,1243,1243,1243,1243,1243,1243,1243,1243,
1243,1243,1243,1243,1243,1243,1243,1243,1243,1243,1243,1243,1243,1243,1243,1244,
1245,1245,1245,1244,1244,1244,1244,1244,1244,1246,1247,196,196,196,196,196,
1248,1248,1248,1248,1248,1248,1248,1248,1248,1248,196,196,196,196,196,196,

/* block 179 */
1249,1250,1251,1252,196,1253,1253,1253,1253,1253,1253,1253,1253,196,196,1253,
1253,196,196,1253,1253,1253,1253,1253,1253,1253,1253,1253,1253,1253,1253,1253,
1253,1253,1253,1253,1253,1253,1253,1253,1253,196,1253,1253,1253,1253,1253,1253,
1253,196,1253,1253,196,1253,1253,1253,1253,1253,196,1254,1255,1253,1256,1251,
1249,1251,1251,1251,1251,196,196,1251,1251,196,196,1251,1251,1257,196,196,
1253,196,196,196,196,196,196,1256,196,196,196,196,196,1258,1253,1253,
1253,1253,1251,1251,196,196,1259,1259,1259,1259,1259,1259,1259,196,196,196,
1259,1259,1259,1259,1259,196,196,196,196,196,196,196,196,196,196,196,

/* block 180 */
1260,1260,1260,1260,1260,1260,1260,1260,1260,1260,196,1260,196,196,1260,196,
1260,1260,1260,1260,1260,1260,1260,1260,1260,1260,1260,1260,1260,1260,1260,1260,
1260,1260,1260,1260,1260,1260,1260,1260,1260,1260,1260,1260,1260,1260,1260,1260,
1260,1260,1260,1260,1260,1260,196,1260,1261,1262,1262,1263,1263,1263,1263,1263,
1263,196,1261,196,196,1261,196,1261,1261,1261,1262,196,1262,1262,1264,1265,
1264,1266,1267,1268,1269,1269,196,1270,1270,196,196,196,196,196,196,196,
196,1271,1271,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,

/* block 181 */
1272,1272,1272,1272,1272,1272,1272,1272,1272,1272,1272,1272,1272,1272,1272,1272,
1272,1272,1272,1272,1272,1272,1272,1272,1272,1272,1272,1272,1272,1272,1272,1272,
1272,1272,1272,1272,1272,1272,1272,1272,1272,1272,1272,1272,1272,1272,1272,1272,
1272,1272,1272,1272,1272,1273,1273,1273,1274,1274,1274,1274,1274,1274,1274,1274,
1273,1273,1275,1274,1274,1273,1276,1272,1272,1272,1272,1277,1277,1278,1279,1279,
1280,1280,1280,1280,1280,1280,1280,1280,1280,1280,1278,1278,196,1279,1281,1272,
1272,1272,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,

/* block 182 */
1282,1282,1282,1282,1282,1282,1282,1282,1282,1282,1282,1282,1282,1282,1282,1282,
1282,1282,1282,1282,1282,1282,1282,1282,1282,1282,1282,1282,1282,1282,1282,1282,
1282,1282,1282,1282,1282,1282,1282,1282,1282,1282,1282,1282,1282,1282,1282,1282,
1283,1284,1284,1285,1285,1285,1285,1285,1285,1284,1285,1284,1284,1283,1284,1285,
1285,1284,1286,1287,1282,1282,1288,1282,196,196,196,196,196,196,196,196,
1289,1289,1289,1289,1289,1289,1289,1289,1289,1289,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,

/* block 183 */
1290,1290,1290,1290,1290,1290,1290,1290,1290,1290,1290,1290,1290,1290,1290,1290,
1290,1290,1290,1290,1290,1290,1290,1290,1290,1290,1290,1290,1290,1290,1290,1290,
1290,1290,1290,1290,1290,1290,1290,1290,1290,1290,1290,1290,1290,1290,1290,1291,
1292,1292,1293,1293,1293,1293,196,196,1292,1292,1292,1292,1293,1293,1292,1294,
1295,1296,1297,1297,1298,1298,1299,1299,1299,1297,1297,1297,1297,1297,1297,1297,
1297,1297,1297,1297,1297,1297,1297,1297,1290,1290,1290,1290,1293,1293,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,

/* block 184 */
1300,1300,1300,1300,1300,1300,1300,1300,1300,1300,1300,1300,1300,1300,1300,1300,
1300,1300,1300,1300,1300,1300,1300,1300,1300,1300,1300,1300,1300,1300,1300,1300,
1300,1300,1300,1300,1300,1300,1300,1300,1300,1300,1300,1300,1300,1300,1300,1300,
1301,1301,1301,1302,1302,1302,1302,1302,1302,1302,1302,1301,1301,1302,1301,1303,
1302,1304,1304,1305,1300,196,196,196,196,196,196,196,196,196,196,196,
1306,1306,1306,1306,1306,1306,1306,1306,1306,1306,196,196,196,196,196,196,
581,581,581,581,581,581,581,581,581,581,581,581,581,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,

/* block 185 */
1307,1307,1307,1307,1307,1307,1307,1307,1307,1307,1307,1307,1307,1307,1307,1307,
1307,1307,1307,1307,1307,1307,1307,1307,1307,1307,1307,1307,1307,1307,1307,1307,
1307,1307,1307,1307,1307,1307,1307,1307,1307,1307,1307,1308,1309,1308,1309,1309,
1308,1308,1308,1308,1308,1308,1310,1311,1307,1312,196,196,196,196,196,196,
1313,1313,1313,1313,1313,1313,1313,1313,1313,1313,196,196,196,196,196,196,
522,522,522,522,522,522,522,522,522,522,522,522,522,522,522,522,
522,522,522,522,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,

/* block 186 */
1314,1314,1314,1314,1314,1314,1314,1314,1314,1314,1314,1314,1314,1314,1314,1314,
1314,1314,1314,1314,1314,1314,1314,1314,1314,1314,1314,196,196,1315,1316,1315,
1317,1317,1315,1315,1315,1315,1316,1315,1315,1315,1315,1318,196,196,196,196,
1319,1319,1319,1319,1319,1319,1319,1319,1319,1319,1320,1320,1321,1321,1321,1322,
1314,1314,1314,1314,1314,1314,1314,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,

/* block 187 */
1323,1323,1323,1323,1323,1323,1323,1323,1323,1323,1323,1323,1323,1323,1323,1323,
1323,1323,1323,1323,1323,1323,1323,1323,1323,1323,1323,1323,1323,1323,1323,1323,
1323,1323,1323,1323,1323,1323,1323,1323,1323,1323,1323,1323,1324,1324,1324,1325,
1325,1325,1325,1325,1325,1325,1325,1325,1324,1326,1327,1328,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,

/* block 188 */
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
1329,1329,1329,1329,1329,1329,1329,1329,1329,1329,1329,1329,1329,1329,1329,1329,
1329,1329,1329,1329,1329,1329,1329,1329,1329,1329,1329,1329,1329,1329,1329,1329,
1330,1330,1330,1330,1330,1330,1330,1330,1330,1330,1330,1330,1330,1330,1330,1330,
1330,1330,1330,1330,1330,1330,1330,1330,1330,1330,1330,1330,1330,1330,1330,1330,
1331,1331,1331,1331,1331,1331,1331,1331,1331,1331,1332,1332,1332,1332,1332,1332,
1332,1332,1332,196,196,196,196,196,196,196,196,196,196,196,196,1333,

/* block 189 */
1334,1334,1334,1334,1334,1334,1334,196,196,1334,196,196,1334,1334,1334,1334,
1334,1334,1334,1334,196,1334,1334,196,1334,1334,1334,1334,1334,1334,1334,1334,
1334,1334,1334,1334,1334,1334,1334,1334,1334,1334,1334,1334,1334,1334,1334,1334,
1335,1336,1336,1336,1336,1336,196,1336,1336,196,196,1337,1337,1338,1339,1340,
1336,1340,1336,1341,1342,1343,1342,196,196,196,196,196,196,196,196,196,
1344,1344,1344,1344,1344,1344,1344,1344,1344,1344,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,

/* block 190 */
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
1345,1345,1345,1345,1345,1345,1345,1345,196,196,1345,1345,1345,1345,1345,1345,
1345,1345,1345,1345,1345,1345,1345,1345,1345,1345,1345,1345,1345,1345,1345,1345,
1345,1345,1345,1345,1345,1345,1345,1345,1345,1345,1345,1345,1345,1345,1345,1345,
1345,1346,1346,1346,1347,1347,1347,1347,196,196,1347,1347,1346,1346,1346,1346,
1348,1345,1349,1345,1346,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,

/* block 191 */
1350,1351,1351,1351,1351,1351,1351,1352,1352,1351,1351,1350,1350,1350,1350,1350,
1350,1350,1350,1350,1350,1350,1350,1350,1350,1350,1350,1350,1350,1350,1350,1350,
1350,1350,1350,1350,1350,1350,1350,1350,1350,1350,1350,1350,1350,1350,1350,1350,
1350,1350,1350,1353,1354,1351,1351,1351,1351,1355,1356,1351,1351,1351,1351,1357,
1357,1357,1358,1358,1357,1357,1357,1354,196,196,196,196,196,196,196,196,
1359,1360,1360,1360,1360,1360,1360,1361,1361,1360,1360,1360,1359,1359,1359,1359,
1359,1359,1359,1359,1359,1359,1359,1359,1359,1359,1359,1359,1359,1359,1359,1359,
1359,1359,1359,1359,1359,1359,1359,1359,1359,1359,1359,1359,1359,1359,1359,1359,

/* block 192 */
1359,1359,1359,1359,1362,1362,1362,1362,1362,1362,1360,1360,1360,1360,1360,1360,
1360,1360,1360,1360,1360,1360,1360,1361,1363,1364,1365,1366,1366,1359,1365,1365,
1365,1367,1367,196,196,196,196,196,196,196,196,196,196,196,196,196,
545,545,545,545,545,545,545,545,545,545,545,545,545,545,545,545,
1368,1368,1368,1368,1368,1368,1368,1368,1368,1368,1368,1368,1368,1368,1368,1368,
1368,1368,1368,1368,1368,1368,1368,1368,1368,1368,1368,1368,1368,1368,1368,1368,
1368,1368,1368,1368,1368,1368,1368,1368,1368,1368,1368,1368,1368,1368,1368,1368,
1368,1368,1368,1368,1368,1368,1368,1368,1368,196,196,196,196,196,196,196,

/* block 193 */
385,385,385,385,385,385,385,385,385,385,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,

/* block 194 */
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
1369,1369,1369,1369,1369,1369,1369,1369,1369,1369,1369,1369,1369,1369,1369,1369,
1369,1369,1369,1369,1369,1369,1369,1369,1369,1369,1369,1369,1369,1369,1369,1369,
1369,1370,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
1371,1371,1371,1371,1371,1371,1371,1371,1371,1371,196,196,196,196,196,196,

/* block 195 */
1372,1372,1372,1372,1372,1372,1372,1372,1372,196,1372,1372,1372,1372,1372,1372,
1372,1372,1372,1372,1372,1372,1372,1372,1372,1372,1372,1372,1372,1372,1372,1372,
1372,1372,1372,1372,1372,1372,1372,1372,1372,1372,1372,1372,1372,1372,1372,1373,
1374,1374,1374,1374,1374,1374,1374,196,1374,1374,1374,1374,1374,1374,1373,1375,
1372,1376,1376,1377,1378,1378,196,196,196,196,196,196,196,196,196,196,
1379,1379,1379,1379,1379,1379,1379,1379,1379,1379,1380,1380,1380,1380,1380,1380,
1380,1380,1380,1380,1380,1380,1380,1380,1380,1380,1380,1380,1380,196,196,196,
1381,1382,1383,1383,1383,1383,1383,1383,1383,1383,1383,1383,1383,1383,1383,1383,

/* block 196 */
1383,1383,1383,1383,1383,1383,1383,1383,1383,1383,1383,1383,1383,1383,1383,1383,
196,196,1384,1384,1384,1384,1384,1384,1384,1384,1384,1384,1384,1384,1384,1384,
1384,1384,1384,1384,1384,1384,1384,1384,196,1385,1384,1384,1384,1384,1384,1384,
1384,1385,1384,1384,1385,1384,1384,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,

/* block 197 */
1386,1386,1386,1386,1386,1386,1386,196,1386,1386,196,1386,1386,1386,1386,1386,
1386,1386,1386,1386,1386,1386,1386,1386,1386,1386,1386,1386,1386,1386,1386,1386,
1386,1386,1386,1386,1386,1386,1386,1386,1386,1386,1386,1386,1386,1386,1386,1386,
1386,1387,1387,1387,1387,1387,1387,196,196,196,1387,196,1387,1387,196,1387,
1387,1387,1388,1387,1389,1389,1390,1387,196,196,196,196,196,196,196,196,
1391,1391,1391,1391,1391,1391,1391,1391,1391,1391,196,196,196,196,196,196,
1392,1392,1392,1392,1392,1392,196,1392,1392,196,1392,1392,1392,1392,1392,1392,
1392,1392,1392,1392,1392,1392,1392,1392,1392,1392,1392,1392,1392,1392,1392,1392,

/* block 198 */
1392,1392,1392,1392,1392,1392,1392,1392,1392,1392,1393,1393,1393,1393,1393,196,
1394,1394,196,1393,1393,1394,1393,1395,1392,196,196,196,196,196,196,196,
1396,1396,1396,1396,1396,1396,1396,1396,1396,1396,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,

/* block 199 */
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
1397,1397,1397,1397,1397,1397,1397,1397,1397,1397,1397,1397,1397,1397,1397,1397,
1397,1397,1397,1398,1398,1399,1399,1400,1400,196,196,196,196,196,196,196,

/* block 200 */
1401,1401,1402,1403,1404,1404,1404,1404,1404,1404,1404,1404,1404,1404,1404,1404,
1404,196,1404,1404,1404,1404,1404,1404,1404,1404,1404,1404,1404,1404,1404,1404,
1404,1404,1404,1404,1404,1404,1404,1404,1404,1404,1404,1404,1404,1404,1404,1404,
1404,1404,1404,1404,1403,1403,1401,1401,1401,1401,1401,196,196,196,1403,1403,
1401,1405,1406,1407,1407,1408,1408,1408,1408,1408,1408,1408,1408,1408,1408,1408,
1409,1409,1409,1409,1409,1409,1409,1409,1409,1409,1410,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,

/* block 201 */
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
914,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
1411,1411,1411,1411,1411,1411,1411,1411,1411,1411,1411,1411,1411,1411,1411,1411,
435,435,1411,435,1411,437,437,437,437,437,437,437,437,438,438,438,
438,437,437,437,437,437,437,437,437,437,437,437,437,437,437,437,
437,437,196,196,196,196,196,196,196,196,196,196,196,196,196,1412,

/* block 202 */
1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,
1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,
1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,
1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,
1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,
1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,
1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,
1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,

/* block 203 */
1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,
1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,

/* block 204 */
1414,1414,1414,1414,1414,1414,1414,1414,1414,1414,1414,1414,1414,1414,1414,1414,
1414,1414,1414,1414,1414,1414,1414,1414,1414,1414,1414,1414,1414,1414,1414,1414,
1414,1414,1414,1414,1414,1414,1414,1414,1414,1414,1414,1414,1414,1414,1414,1414,
1414,1414,1414,1414,1414,1414,1414,1414,1414,1414,1414,1414,1414,1414,1414,1414,
1414,1414,1414,1414,1414,1414,1414,1414,1414,1414,1414,1414,1414,1414,1414,1414,
1414,1414,1414,1414,1414,1414,1414,1414,1414,1414,1414,1414,1414,1414,1414,1414,
1414,1414,1414,1414,1414,1414,1414,1414,1414,1414,1414,1414,1414,1414,1414,196,
1415,1415,1415,1415,1415,196,196,196,196,196,196,196,196,196,196,196,

/* block 205 */
1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,
1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,
1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,
1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,1413,
1413,1413,1413,1413,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,

/* block 206 */
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
1416,1416,1416,1416,1416,1416,1416,1416,1416,1416,1416,1416,1416,1416,1416,1416,
1416,1416,1416,1416,1416,1416,1416,1416,1416,1416,1416,1416,1416,1416,1416,1416,
1416,1416,1416,1416,1416,1416,1416,1416,1416,1416,1416,1416,1416,1416,1416,1416,
1416,1416,1416,1416,1416,1416,1416,1416,1416,1416,1416,1416,1416,1416,1416,1416,
1416,1416,1416,1416,1416,1416,1416,1416,1416,1416,1416,1416,1416,1416,1416,1416,
1416,1416,1416,1416,1416,1416,1416,1416,1416,1416,1416,1416,1416,1416,1416,1416,
1416,1417,1417,196,196,196,196,196,196,196,196,196,196,196,196,196,

/* block 207 */
1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,
1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,
1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,
1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,
1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,
1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,
1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,
1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,

/* block 208 */
1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,
1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,
1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,
1419,1419,1419,1419,1419,1419,1419,1419,1419,1419,1419,1419,1419,1419,1419,1419,
1420,1418,1418,1418,1418,1418,1418,1421,1421,1421,1421,1421,1421,1421,1421,1421,
1421,1421,1421,1421,1421,1421,196,196,196,196,196,196,196,196,196,196,
1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,
1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,

/* block 209 */
1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,
1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,
1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,
1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,
1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,
1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,
1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,
1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,1418,196,196,196,196,196,

/* block 210 */
1422,1422,1422,1422,1422,1422,1422,1422,1422,1422,1422,1422,1422,1422,1422,1422,
1422,1422,1422,1422,1422,1422,1422,1422,1422,1422,1422,1422,1422,1422,1422,1422,
1422,1422,1422,1422,1422,1422,1422,1422,1422,1422,1422,1422,1422,1422,1422,1422,
1422,1422,1422,1422,1422,1422,1422,1422,1422,1422,1422,1422,1422,1422,1422,1422,
1422,1422,1422,1422,1422,1422,1422,1422,1422,1422,1422,1422,1422,1422,1422,1422,
1422,1422,1422,1422,1422,1422,1422,1422,1422,1422,1422,1422,1422,1422,1422,1422,
1422,1422,1422,1422,1422,1422,1422,1422,1422,1422,1422,1422,1422,1422,1422,1422,
1422,1422,1422,1422,1422,1422,1422,1422,1422,1422,1422,1422,1422,1422,1422,1422,

/* block 211 */
1422,1422,1422,1422,1422,1422,1422,1422,1422,1422,1422,1422,1422,1422,1422,1422,
1422,1422,1422,1422,1422,1422,1422,1422,1422,1422,1422,1422,1422,1422,1422,1422,
1422,1422,1422,1422,1422,1422,1422,1422,1422,1422,1422,1422,1422,1422,1422,1422,
1422,1422,1422,1422,1422,1422,1422,1422,1422,1422,1422,1422,1422,1422,1422,1422,
1422,1422,1422,1422,1422,1422,1422,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,

/* block 212 */
1423,1423,1423,1423,1423,1423,1423,1423,1423,1423,1423,1423,1423,1423,1423,1423,
1423,1423,1423,1423,1423,1423,1423,1423,1423,1423,1423,1423,1423,1423,1424,1424,
1424,1424,1424,1424,1424,1424,1424,1424,1424,1424,1425,1425,1425,1424,1424,1426,
1427,1427,1427,1427,1427,1427,1427,1427,1427,1427,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,

/* block 213 */
930,930,930,930,930,930,930,930,930,930,930,930,930,930,930,930,
930,930,930,930,930,930,930,930,930,930,930,930,930,930,930,930,
930,930,930,930,930,930,930,930,930,930,930,930,930,930,930,930,
930,930,930,930,930,930,930,930,930,930,930,930,930,930,930,930,
930,930,930,930,930,930,930,930,930,930,930,930,930,930,930,930,
930,930,930,930,930,930,930,930,930,930,930,930,930,930,930,930,
930,930,930,930,930,930,930,930,930,930,930,930,930,930,930,930,
930,930,930,930,930,930,930,930,930,930,930,930,930,930,930,930,

/* block 214 */
930,930,930,930,930,930,930,930,930,930,930,930,930,930,930,930,
930,930,930,930,930,930,930,930,930,930,930,930,930,930,930,930,
930,930,930,930,930,930,930,930,930,930,930,930,930,930,930,930,
930,930,930,930,930,930,930,930,930,196,196,196,196,196,196,196,
1428,1428,1428,1428,1428,1428,1428,1428,1428,1428,1428,1428,1428,1428,1428,1428,
1428,1428,1428,1428,1428,1428,1428,1428,1428,1428,1428,1428,1428,1428,1428,196,
1429,1429,1429,1429,1429,1429,1429,1429,1429,1429,196,196,196,196,1430,1430,
1431,1431,1431,1431,1431,1431,1431,1431,1431,1431,1431,1431,1431,1431,1431,1431,

/* block 215 */
1431,1431,1431,1431,1431,1431,1431,1431,1431,1431,1431,1431,1431,1431,1431,1431,
1431,1431,1431,1431,1431,1431,1431,1431,1431,1431,1431,1431,1431,1431,1431,1431,
1431,1431,1431,1431,1431,1431,1431,1431,1431,1431,1431,1431,1431,1431,1431,1431,
1431,1431,1431,1431,1431,1431,1431,1431,1431,1431,1431,1431,1431,1431,1431,196,
1432,1432,1432,1432,1432,1432,1432,1432,1432,1432,196,196,196,196,196,196,
1433,1433,1433,1433,1433,1433,1433,1433,1433,1433,1433,1433,1433,1433,1433,1433,
1433,1433,1433,1433,1433,1433,1433,1433,1433,1433,1433,1433,1433,1433,196,196,
1434,1434,1434,1434,1434,1435,196,196,196,196,196,196,196,196,196,196,

/* block 216 */
1436,1436,1436,1436,1436,1436,1436,1436,1436,1436,1436,1436,1436,1436,1436,1436,
1436,1436,1436,1436,1436,1436,1436,1436,1436,1436,1436,1436,1436,1436,1436,1436,
1436,1436,1436,1436,1436,1436,1436,1436,1436,1436,1436,1436,1436,1436,1436,1436,
1437,1437,1437,1437,1437,1437,1437,1438,1438,1439,1440,1440,1441,1441,1441,1441,
1442,1442,1443,1443,1438,1441,196,196,196,196,196,196,196,196,196,196,
1444,1444,1444,1444,1444,1444,1444,1444,1444,1444,196,1445,1445,1445,1445,1445,
1445,1445,196,1436,1436,1436,1436,1436,1436,1436,1436,1436,1436,1436,1436,1436,
1436,1436,1436,1436,1436,1436,1436,1436,196,196,196,196,196,1436,1436,1436,

/* block 217 */
1436,1436,1436,1436,1436,1436,1436,1436,1436,1436,1436,1436,1436,1436,1436,1436,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,

/* block 218 */
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
1446,1446,1446,1447,1447,1447,1447,1447,1447,1447,1447,1447,1447,1447,1447,1447,
1447,1447,1447,1447,1447,1447,1447,1447,1447,1447,1447,1447,1447,1447,1447,1447,
1447,1447,1447,1448,1447,1447,1447,1448,1448,1448,1448,1449,1449,1450,1451,1451,
1452,1452,1452,1452,1452,1452,1452,1452,1452,1452,196,196,196,196,196,196,

/* block 219 */
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
1453,1453,1453,1453,1453,1453,1453,1453,1453,1453,1453,1453,1453,1453,1453,1453,
1453,1453,1453,1453,1453,1453,1453,1453,1453,1453,1453,1453,1453,1453,1453,1453,
1454,1454,1454,1454,1454,1454,1454,1454,1454,1454,1454,1454,1454,1454,1454,1454,
1454,1454,1454,1454,1454,1454,1454,1454,1454,1454,1454,1454,1454,1454,1454,1454,

/* block 220 */
1455,1455,1455,1455,1455,1455,1455,1455,1455,1455,1455,1455,1455,1455,1455,1455,
1455,1455,1455,1455,1455,1455,1455,1456,1457,1458,1458,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,

/* block 221 */
1459,1459,1459,1459,1459,1459,1459,1459,1459,1459,1459,1459,1459,1459,1459,1459,
1459,1459,1459,1459,1459,1459,1459,1459,1459,1459,1459,1459,1459,1459,1459,1459,
1459,1459,1459,1459,1459,1459,1459,1459,1459,1459,1459,1459,1459,1459,1459,1459,
1459,1459,1459,1459,1459,1459,1459,1459,1459,1459,1459,1459,1459,1459,1459,1459,
1459,1459,1459,1459,1459,1459,1459,1459,1459,1459,1459,196,196,196,196,1460,
1459,1461,1461,1461,1461,1461,1461,1461,1461,1461,1461,1461,1461,1461,1461,1461,
1461,1461,1461,1461,1461,1461,1461,1461,1461,1461,1461,1461,1461,1461,1461,1461,
1461,1461,1461,1461,1461,1461,1461,1461,1461,1461,1461,1461,1461,1461,1461,1461,

/* block 222 */
1461,1461,1461,1461,1461,1461,1461,1461,196,196,196,196,196,196,196,1462,
1462,1462,1462,1463,1463,1463,1463,1463,1463,1463,1463,1463,1463,1463,1463,1463,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
1464,1465,1466,867,1467,196,196,196,196,196,196,196,196,196,196,196,
1468,1468,196,196,196,196,196,196,196,196,196,196,196,196,196,196,

/* block 223 */
1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,
1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,
1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,
1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,
1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,
1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,
1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,
1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,

/* block 224 */
1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,
1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,
1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,
1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,
1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,
1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,
1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,1469,
1469,1469,1469,1469,1469,1469,1469,1469,196,196,196,196,196,196,196,196,

/* block 225 */
1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,
1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,
1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,
1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,
1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,
1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,
1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,
1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,

/* block 226 */
1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,
1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,
1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,
1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,
1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,1470,
1470,1470,1470,1470,1470,1470,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,1470,

/* block 227 */
1469,1469,1469,1469,1469,1469,1469,1469,1469,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,

/* block 228 */
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
1471,1471,1471,1471,196,1471,1471,1471,1471,1471,1471,1471,196,1471,1471,196,

/* block 229 */
896,891,891,891,891,891,891,891,891,891,891,891,891,891,891,891,
891,891,891,891,891,891,891,891,891,891,891,891,891,891,891,891,
891,891,891,891,891,891,891,891,891,891,891,891,891,891,891,891,
891,891,891,891,891,891,891,891,891,891,891,891,891,891,891,891,
891,891,891,891,891,891,891,891,891,891,891,891,891,891,891,891,
891,891,891,891,891,891,891,891,891,891,891,891,891,891,891,891,
891,891,891,891,891,891,891,891,891,891,891,891,891,891,891,891,
891,891,891,891,891,891,891,891,891,891,891,891,891,891,891,891,

/* block 230 */
891,891,891,891,891,891,891,891,891,891,891,891,891,891,891,891,
891,891,891,891,891,891,891,891,891,891,891,891,891,891,891,891,
891,891,891,891,891,891,891,891,891,891,891,891,891,891,891,891,
891,891,891,891,891,891,891,891,891,891,891,891,891,891,891,891,
891,891,891,891,891,891,891,891,891,891,891,891,891,891,891,891,
891,891,891,891,891,891,891,891,891,891,891,891,891,891,891,891,
891,891,891,891,891,891,891,891,891,891,891,891,891,891,891,891,
891,891,891,891,891,891,891,891,891,891,891,891,891,891,891,891,

/* block 231 */
891,891,891,891,891,891,891,891,891,891,891,891,891,891,891,891,
891,891,891,891,891,891,891,891,891,891,891,891,891,891,891,891,
896,896,896,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,891,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
891,891,891,196,196,896,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,896,896,896,896,196,196,196,196,196,196,196,196,
1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,

/* block 232 */
1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,
1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,
1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,
1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,
1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,
1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,
1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,
1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,

/* block 233 */
1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,
1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,
1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,
1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,
1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,
1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,
1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,
1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,1472,196,196,196,196,

/* block 234 */
1473,1473,1473,1473,1473,1473,1473,1473,1473,1473,1473,1473,1473,1473,1473,1473,
1473,1473,1473,1473,1473,1473,1473,1473,1473,1473,1473,1473,1473,1473,1473,1473,
1473,1473,1473,1473,1473,1473,1473,1473,1473,1473,1473,1473,1473,1473,1473,1473,
1473,1473,1473,1473,1473,1473,1473,1473,1473,1473,1473,1473,1473,1473,1473,1473,
1473,1473,1473,1473,1473,1473,1473,1473,1473,1473,1473,1473,1473,1473,1473,1473,
1473,1473,1473,1473,1473,1473,1473,1473,1473,1473,1473,1473,1473,1473,1473,1473,
1473,1473,1473,1473,1473,1473,1473,1473,1473,1473,1473,196,196,196,196,196,
1473,1473,1473,1473,1473,1473,1473,1473,1473,1473,1473,1473,1473,196,196,196,

/* block 235 */
1473,1473,1473,1473,1473,1473,1473,1473,1473,196,196,196,196,196,196,196,
1473,1473,1473,1473,1473,1473,1473,1473,1473,1473,196,196,1474,1475,1476,1477,
1478,1478,1478,1478,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,

/* block 236 */
781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,
781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,
781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,
781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,
781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,
781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,
781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,
781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,

/* block 237 */
781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,
781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,
781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,
781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,
781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,
781,781,781,781,781,781,510,510,510,510,510,510,510,510,510,510,
510,510,510,510,510,510,510,510,510,510,510,510,510,510,510,510,
1479,1479,1479,1479,1479,1479,1479,1479,1479,1479,196,196,196,196,196,196,

/* block 238 */
781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,
781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,
781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,
781,781,781,781,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,

/* block 239 */
176,176,176,176,176,176,176,176,176,176,176,176,176,176,176,176,
176,176,176,176,176,176,176,176,176,176,176,176,176,176,176,176,
176,176,176,176,176,176,176,176,176,176,176,176,176,176,196,196,
176,176,176,176,176,176,176,176,176,176,176,176,176,176,176,176,
176,176,176,176,176,176,176,196,196,196,196,196,196,196,196,196,
510,510,510,510,510,510,510,510,510,510,510,510,510,510,510,510,
510,510,510,510,510,510,510,510,510,510,510,510,510,510,510,510,
510,510,510,510,510,510,510,510,510,510,510,510,510,510,510,510,

/* block 240 */
510,510,510,510,510,510,510,510,510,510,510,510,510,510,510,510,
510,510,510,510,510,510,510,510,510,510,510,510,510,510,510,510,
510,510,510,510,510,510,510,510,510,510,510,510,510,510,510,510,
510,510,510,510,510,510,510,510,510,510,510,510,510,510,510,510,
510,510,510,510,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,

/* block 241 */
510,510,510,510,510,510,510,510,510,510,510,510,510,510,510,510,
510,510,510,510,510,510,510,510,510,510,510,510,510,510,510,510,
510,510,510,510,510,510,510,510,510,510,510,510,510,510,510,510,
510,510,510,510,510,510,510,510,510,510,510,510,510,510,510,510,
510,510,510,510,510,510,510,510,510,510,510,510,510,510,510,510,
510,510,510,510,510,510,510,510,510,510,510,510,510,510,510,510,
510,510,510,510,510,510,510,510,510,510,510,510,510,510,510,510,
510,510,510,510,510,510,510,510,510,510,510,510,510,510,510,510,

/* block 242 */
510,510,510,510,510,510,510,510,510,510,510,510,510,510,510,510,
510,510,510,510,510,510,510,510,510,510,510,510,510,510,510,510,
510,510,510,510,510,510,510,510,510,510,510,510,510,510,510,510,
510,510,510,510,510,510,510,510,510,510,510,510,510,510,510,510,
510,510,510,510,510,510,510,510,510,510,510,510,510,510,510,510,
510,510,510,510,510,510,510,510,510,510,510,510,510,510,510,510,
510,510,510,510,510,510,510,510,510,510,510,510,510,510,510,510,
510,510,510,510,510,510,196,196,196,196,196,196,196,196,196,196,

/* block 243 */
510,510,510,510,510,510,510,510,510,510,510,510,510,510,510,510,
510,510,510,510,510,510,510,510,510,510,510,510,510,510,510,510,
510,510,510,510,510,510,510,196,196,510,510,510,510,510,510,510,
510,510,510,510,510,510,510,510,510,510,510,510,510,510,510,510,
510,510,510,510,510,510,510,510,510,510,510,510,510,510,510,510,
510,510,510,510,510,510,510,510,510,510,510,510,510,510,510,510,
510,510,510,510,510,1480,1480,176,176,176,510,510,510,1481,1481,1481,
1481,1481,1481, 51, 51, 51, 51, 51, 51, 51, 51,176,176,176,176,176,

/* block 244 */
176,176,176,510,510,176,176,176,176,176,176,176,510,510,510,510,
510,510,510,510,510,510,510,510,510,510,510,510,510,510,510,510,
510,510,510,510,510,510,510,510,510,510,176,176,176,176,510,510,
510,510,510,510,510,510,510,510,510,510,510,510,510,510,510,510,
510,510,510,510,510,510,510,510,510,510,510,510,510,510,510,510,
510,510,510,510,510,510,510,510,510,510,510,510,510,510,510,510,
510,510,510,510,510,510,510,510,510,781,781,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,

/* block 245 */
1077,1077,1077,1077,1077,1077,1077,1077,1077,1077,1077,1077,1077,1077,1077,1077,
1077,1077,1077,1077,1077,1077,1077,1077,1077,1077,1077,1077,1077,1077,1077,1077,
1077,1077,1077,1077,1077,1077,1077,1077,1077,1077,1077,1077,1077,1077,1077,1077,
1077,1077,1077,1077,1077,1077,1077,1077,1077,1077,1077,1077,1077,1077,1077,1077,
1077,1077,1482,1482,1482,1077,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,

/* block 246 */
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
907,907,907,907,907,907,907,907,907,907,907,907,907,907,907,907,
907,907,907,907,196,196,196,196,196,196,196,196,196,196,196,196,
907,907,907,907,907,907,907,907,907,907,907,907,907,907,907,907,
907,907,907,907,196,196,196,196,196,196,196,196,196,196,196,196,

/* block 247 */
781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,
781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,
781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,
781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,
781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,
781,781,781,781,781,781,781,196,196,196,196,196,196,196,196,196,
904,904,904,904,904,904,904,904,904,904,904,904,904,904,904,904,
904,904,907,907,907,907,907,907,907,196,196,196,196,196,196,196,

/* block 248 */
782,782,782,782,782,782,782,782,782,782,782,782,782,782,782,782,
782,782,782,782,782,782,782,782,782,782,783,783,783,783,783,783,
783,783,795,795,783,783,783,783,783,783,783,783,783,783,783,783,
783,783,783,783,782,782,782,782,782,782,782,782,782,782,782,782,
782,782,782,782,782,782,782,782,782,782,782,782,782,782,783,783,
783,783,783,783,783,196,795,795,783,783,783,783,783,783,783,783,
783,783,783,783,783,783,783,783,782,782,782,782,782,782,782,782,
782,782,782,782,782,782,782,782,782,782,782,782,782,782,782,782,

/* block 249 */
782,782,783,783,783,783,783,783,783,783,795,795,783,783,783,783,
783,783,783,783,783,783,783,783,783,783,783,783,782,196,782,782,
196,196,782,196,196,782,782,196,196,782,782,782,782,196,782,782,
782,782,782,782,782,782,783,783,783,783,196,783,196,783,795,795,
783,783,783,783,196,783,783,783,783,783,783,783,783,783,783,783,
782,782,782,782,782,782,782,782,782,782,782,782,782,782,782,782,
782,782,782,782,782,782,782,782,782,782,783,783,783,783,783,783,
783,783,795,795,783,783,783,783,783,783,783,783,783,783,783,783,

/* block 250 */
783,783,783,783,782,782,196,782,782,782,782,196,196,782,782,782,
782,782,782,782,782,196,782,782,782,782,782,782,782,196,783,783,
783,783,783,783,783,783,795,795,783,783,783,783,783,783,783,783,
783,783,783,783,783,783,783,783,782,782,196,782,782,782,782,196,
782,782,782,782,782,196,782,196,196,196,782,782,782,782,782,782,
782,196,783,783,783,783,783,783,783,783,795,795,783,783,783,783,
783,783,783,783,783,783,783,783,783,783,783,783,782,782,782,782,
782,782,782,782,782,782,782,782,782,782,782,782,782,782,782,782,

/* block 251 */
782,782,782,782,782,782,783,783,783,783,783,783,783,783,795,795,
783,783,783,783,783,783,783,783,783,783,783,783,783,783,783,783,
782,782,782,782,782,782,782,782,782,782,782,782,782,782,782,782,
782,782,782,782,782,782,782,782,782,782,783,783,783,783,783,783,
783,783,795,795,783,783,783,783,783,783,783,783,783,783,783,783,
783,783,783,783,782,782,782,782,782,782,782,782,782,782,782,782,
782,782,782,782,782,782,782,782,782,782,782,782,782,782,783,783,
783,783,783,783,783,783,795,795,783,783,783,783,783,783,783,783,

/* block 252 */
783,783,783,783,783,783,783,783,782,782,782,782,782,782,782,782,
782,782,782,782,782,782,782,782,782,782,782,782,782,782,782,782,
782,782,783,783,783,783,783,783,783,783,795,795,783,783,783,783,
783,783,783,783,783,783,783,783,783,783,783,783,782,782,782,782,
782,782,782,782,782,782,782,782,782,782,782,782,782,782,782,782,
782,782,782,782,782,782,783,783,783,783,783,783,783,783,795,795,
783,783,783,783,783,783,783,783,783,783,783,783,783,783,783,783,
782,782,782,782,782,782,782,782,782,782,782,782,782,782,782,782,

/* block 253 */
782,782,782,782,782,782,782,782,782,782,783,783,783,783,783,783,
783,783,795,795,783,783,783,783,783,783,783,783,783,783,783,783,
783,783,783,783,783,783,196,196,782,782,782,782,782,782,782,782,
782,782,782,782,782,782,782,782,782,782,782,782,782,782,782,782,
782,1483,783,783,783,783,783,783,783,783,783,783,783,783,783,783,
783,783,783,783,783,783,783,783,783,783,783,1483,783,783,783,783,
783,783,782,782,782,782,782,782,782,782,782,782,782,782,782,782,
782,782,782,782,782,782,782,782,782,782,782,1483,783,783,783,783,

/* block 254 */
783,783,783,783,783,783,783,783,783,783,783,783,783,783,783,783,
783,783,783,783,783,1483,783,783,783,783,783,783,782,782,782,782,
782,782,782,782,782,782,782,782,782,782,782,782,782,782,782,782,
782,782,782,782,782,1483,783,783,783,783,783,783,783,783,783,783,
783,783,783,783,783,783,783,783,783,783,783,783,783,783,783,1483,
783,783,783,783,783,783,782,782,782,782,782,782,782,782,782,782,
782,782,782,782,782,782,782,782,782,782,782,782,782,782,782,1483,
783,783,783,783,783,783,783,783,783,783,783,783,783,783,783,783,

/* block 255 */
783,783,783,783,783,783,783,783,783,1483,783,783,783,783,783,783,
782,782,782,782,782,782,782,782,782,782,782,782,782,782,782,782,
782,782,782,782,782,782,782,782,782,1483,783,783,783,783,783,783,
783,783,783,783,783,783,783,783,783,783,783,783,783,783,783,783,
783,783,783,1483,783,783,783,783,783,783,782,783,196,196,1484,1484,
1484,1484,1484,1484,1484,1484,1484,1484,1484,1484,1484,1484,1484,1484,1484,1484,
1484,1484,1484,1484,1484,1484,1484,1484,1484,1484,1484,1484,1484,1484,1484,1484,
1484,1484,1484,1484,1484,1484,1484,1484,1484,1484,1484,1484,1484,1484,1484,1484,

/* block 256 */
1485,1485,1485,1485,1485,1485,1485,1485,1485,1485,1485,1485,1485,1485,1485,1485,
1485,1485,1485,1485,1485,1485,1485,1485,1485,1485,1485,1485,1485,1485,1485,1485,
1485,1485,1485,1485,1485,1485,1485,1485,1485,1485,1485,1485,1485,1485,1485,1485,
1485,1485,1485,1485,1485,1485,1485,1485,1485,1485,1485,1485,1485,1485,1485,1485,
1485,1485,1485,1485,1485,1485,1485,1485,1485,1485,1485,1485,1485,1485,1485,1485,
1485,1485,1485,1485,1485,1485,1485,1485,1485,1485,1485,1485,1485,1485,1485,1485,
1485,1485,1485,1485,1485,1485,1485,1485,1485,1485,1485,1485,1485,1485,1485,1485,
1485,1485,1485,1485,1485,1485,1485,1485,1485,1485,1485,1485,1485,1485,1485,1485,

/* block 257 */
1486,1486,1486,1486,1486,1486,1486,1486,1486,1486,1486,1486,1486,1486,1486,1486,
1486,1486,1486,1486,1486,1486,1486,1486,1486,1486,1486,1486,1486,1486,1486,1486,
1486,1486,1486,1486,1486,1486,1486,1486,1486,1486,1486,1486,1486,1486,1486,1486,
1486,1486,1486,1486,1486,1486,1486,1485,1485,1485,1485,1486,1486,1486,1486,1486,
1486,1486,1486,1486,1486,1486,1486,1486,1486,1486,1486,1486,1486,1486,1486,1486,
1486,1486,1486,1486,1486,1486,1486,1486,1486,1486,1486,1486,1486,1486,1486,1486,
1486,1486,1486,1486,1486,1486,1486,1486,1486,1486,1486,1486,1486,1485,1485,1485,
1485,1485,1485,1485,1485,1486,1485,1485,1485,1485,1485,1485,1485,1485,1485,1485,

/* block 258 */
1485,1485,1485,1485,1486,1485,1485,1487,1488,1487,1487,1489,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,1486,1486,1486,1486,1486,
196,1486,1486,1486,1486,1486,1486,1486,1486,1486,1486,1486,1486,1486,1486,1486,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,

/* block 259 */
 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 93, 70, 70, 70, 70, 70,
 70, 70, 70, 70, 70, 70, 70, 70, 70, 70,694, 70, 70, 70, 70,196,
196,196,196,196,196, 70, 70, 70, 70, 70, 70,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,

/* block 260 */
1490,1490,1490,1490,1490,1490,1490,196,1490,1490,1490,1490,1490,1490,1490,1490,
1490,1490,1490,1490,1490,1490,1490,1490,1490,196,196,1490,1490,1490,1490,1490,
1490,1490,196,1490,1490,196,1490,1490,1490,1490,1490,196,196,196,196,196,
929,929,929,929,929,929,929,929,929,929,929,929,929,929,929,929,
929,929,929,929,929,929,929,929,929,929,929,929,1491,1491,929,929,
929,929,929,929,929,929,929,929,929,929,929,929,929,929,929,929,
929,929,929,929,929,929,929,929,1491,929,929,929,929,929,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,

/* block 261 */
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,849,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,

/* block 262 */
1492,1492,1492,1492,1492,1492,1492,1492,1492,1492,1492,1492,1492,1492,1492,1492,
1492,1492,1492,1492,1492,1492,1492,1492,1492,1492,1492,1492,1492,1492,1492,1492,
1492,1492,1492,1492,1492,1492,1492,1492,1492,1492,1492,1492,1492,196,196,196,
1493,1493,1493,1493,1493,1493,1493,1494,1494,1494,1494,1494,1495,1495,196,196,
1496,1496,1496,1496,1496,1496,1496,1496,1496,1496,196,196,196,196,1492,1497,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,

/* block 263 */
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
1498,1498,1498,1498,1498,1498,1498,1498,1498,1498,1498,1498,1498,1498,1498,1498,
1498,1498,1498,1498,1498,1498,1498,1498,1498,1498,1498,1498,1498,1498,1499,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
1500,1500,1500,1500,1500,1500,1500,1500,1500,1500,1500,1500,1500,1500,1500,1500,
1500,1500,1500,1500,1500,1500,1500,1500,1500,1500,1500,1500,1500,1500,1500,1500,
1500,1500,1500,1500,1500,1500,1500,1500,1500,1500,1500,1500,1501,1501,1501,1501,
1502,1502,1502,1502,1502,1502,1502,1502,1502,1502,196,196,196,196,196,1503,

/* block 264 */
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
1504,1504,1504,1504,1504,1504,1504,1504,1504,1504,1504,1504,1504,1504,1504,1504,
1504,1504,1504,1504,1504,1504,1504,1504,1504,1504,1504,1505,1506,1506,1506,1506,
1507,1507,1507,1507,1507,1507,1507,1507,1507,1507,196,196,196,196,196,196,

/* block 265 */
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
1508,1508,1508,1508,1508,1508,1508,1508,1508,1508,1508,1508,1508,1508,1508,1508,
1508,1508,1508,1508,1508,1508,1508,1508,1508,1508,1508,1508,1508,1508,1509,1510,
1508,1511,1511,1511,1511,1511,1511,1511,1511,1511,1511,196,196,196,196,1512,

/* block 266 */
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
533,533,533,533,533,533,533,196,533,533,533,533,196,533,533,196,
533,533,533,533,533,533,533,533,533,533,533,533,533,533,533,196,

/* block 267 */
1513,1513,1513,1513,1513,1513,1513,1513,1513,1513,1513,1513,1513,1513,1513,1513,
1513,1513,1513,1513,1513,1513,1513,1513,1513,1513,1513,1513,1513,1513,1513,1513,
1513,1513,1513,1513,1513,1513,1513,1513,1513,1513,1513,1513,1513,1513,1513,1513,
1513,1513,1513,1513,1513,1513,1513,1513,1513,1513,1513,1513,1513,1513,1513,1513,
1513,1513,1513,1513,1513,1513,1513,1513,1513,1513,1513,1513,1513,1513,1513,1513,
1513,1513,1513,1513,1513,1513,1513,1513,1513,1513,1513,1513,1513,1513,1513,1513,
1513,1513,1513,1513,1513,1513,1513,1513,1513,1513,1513,1513,1513,1513,1513,1513,
1513,1513,1513,1513,1513,1513,1513,1513,1513,1513,1513,1513,1513,1513,1513,1513,

/* block 268 */
1513,1513,1513,1513,1513,1513,1513,1513,1513,1513,1513,1513,1513,1513,1513,1513,
1513,1513,1513,1513,1513,1513,1513,1513,1513,1513,1513,1513,1513,1513,1513,1513,
1513,1513,1513,1513,1513,1513,1513,1513,1513,1513,1513,1513,1513,1513,1513,1513,
1513,1513,1513,1513,1513,1513,1513,1513,1513,1513,1513,1513,1513,1513,1513,1513,
1513,1513,1513,1513,1513,297,297,1514,1514,1514,1514,1514,1514,1514,1514,1514,
1515,1515,1515,1515,1515,1515,1515,297,297,297,297,297,297,297,297,297,
297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,
297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,

/* block 269 */
1516,1516,1516,1516,1516,1516,1516,1516,1516,1516,1516,1516,1516,1516,1516,1516,
1516,1516,1516,1516,1516,1516,1516,1516,1516,1516,1516,1516,1516,1516,1516,1516,
1516,1516,1517,1517,1517,1517,1517,1517,1517,1517,1517,1517,1517,1517,1517,1517,
1517,1517,1517,1517,1517,1517,1517,1517,1517,1517,1517,1517,1517,1517,1517,1517,
1517,1517,1517,1517,1518,1518,1518,1519,1520,1520,1520,1521,297,297,297,297,
1522,1522,1522,1522,1522,1522,1522,1522,1522,1522,297,297,297,297,1523,1523,
297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,
297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,

/* block 270 */
297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,
297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,
297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,
297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,
297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,
297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,
297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,
297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,

/* block 271 */
297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,
297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,
297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,
297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,
297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,
297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,
297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,
340,1524,1524,1524,1524,1524,1524,1524,1524,1524,1524,1524,1524,1524,1524,1524,

/* block 272 */
1524,1524,1524,1524,1524,1524,1524,1524,1524,1524,1524,1524,1524,1524,1524,1524,
1524,1524,1524,1524,1524,1524,1524,1524,1524,1524,1524,1524,1524,1524,1524,1524,
1524,1524,1524,1524,1524,1524,1524,1524,1524,1524,1524,1524,1525,1524,1524,1524,
1526,1524,1524,1524,1524,340,340,340,340,340,340,340,340,340,340,340,
297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,
297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,
297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,
297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,

/* block 273 */
340,1524,1524,1524,1524,1524,1524,1524,1524,1524,1524,1524,1524,1524,1524,1524,
1524,1524,1524,1524,1524,1524,1524,1524,1524,1524,1524,1524,1524,1524,1524,1524,
1524,1524,1524,1524,1524,1524,1524,1524,1524,1524,1524,1524,1524,1524,1525,1524,
1524,1524,1524,1524,1524,1524,1524,1524,1524,1524,1524,1524,1524,1524,340,340,
340,340,340,340,340,340,340,340,340,340,340,340,340,340,340,340,
297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,
297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,
297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,297,

/* block 274 */
1527,1527,1527,1527,340,1527,1527,1527,1527,1527,1527,1527,1527,1527,1527,1527,
1527,1527,1527,1527,1527,1527,1527,1527,1527,1527,1527,1527,1527,1527,1527,1527,
340,1527,1527,340,1527,340,340,1527,340,1527,1527,1527,1527,1527,1527,1527,
1527,1527,1527,340,1527,1527,1527,1527,340,1527,340,1527,340,340,340,340,
340,340,1527,340,340,340,340,1527,340,1527,340,1527,340,1527,1527,1527,
340,1527,1527,340,1527,340,340,1527,340,1527,340,1527,340,1527,340,1527,
340,1527,1527,340,1527,340,340,1527,1527,1527,1527,340,1527,1527,1527,1527,
1527,1527,1527,340,1527,1527,1527,1527,340,1527,1527,1527,1527,340,1527,340,

/* block 275 */
1527,1527,1527,1527,1527,1527,1527,1527,1527,1527,340,1527,1527,1527,1527,1527,
1527,1527,1527,1527,1527,1527,1527,1527,1527,1527,1527,1527,340,340,340,340,
340,1527,1527,1527,340,1527,1527,1527,1527,1527,340,1527,1527,1527,1527,1527,
1527,1527,1527,1527,1527,1527,1527,1527,1527,1527,1527,1527,340,340,340,340,
340,340,340,340,340,340,340,340,340,340,340,340,340,340,340,340,
340,340,340,340,340,340,340,340,340,340,340,340,340,340,340,340,
340,340,340,340,340,340,340,340,340,340,340,340,340,340,340,340,
309,309,340,340,340,340,340,340,340,340,340,340,340,340,340,340,

/* block 276 */
1528,1528,1528,1528,1529,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,
1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,
1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1530,1530,1530,1530,
1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,
1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,
1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,
1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,
1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,

/* block 277 */
1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,
1528,1528,1528,1528,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,
1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1530,
1530,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,
1530,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1529,
1530,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,
1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,
1528,1528,1528,1528,1528,1528,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,

/* block 278 */
814,814,814,814,814,814,814,814,814,814,814, 58, 58,1528,1528,1528,
510,510,510,510,510,510,510,510,510,510,510,510,510,510,510,510,
510,510,510,510,510,510,510,510,510,510,510,510,510,510,510,1528,
1531,1531,1531,1531,1531,1531,1531,1531,1531,1531,1531,1531,1531,1531,1531,1531,
1531,1531,1531,1531,1531,1531,1531,1531,1531,1531,510,510,510,510,510,510,
1531,1531,1531,1531,1531,1531,1531,1531,1531,1531,1531,1531,1531,1531,1531,1531,
1531,1531,1531,1531,1531,1531,1531,1531,1531,1531,781,781,1528,1528,1528,1528,
1532,1532,1531,1531,1531,1531,1531,1531,1531,1531,1531,1531,1531,1531,1532,1532,

/* block 279 */
1531,1531,1531,1531,1531,1531,1531,1531,1531,1531,510,510,510,510,1533,510,
510,1533,1533,1533,1533,1533,1533,1533,1533,1533,1533,510,510,510,510,510,
510,510,510,510,510,510,510,510,510,510,510,510,510,1528,1530,1530,
1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,
1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,
1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,
1530,1530,1530,1530,1530,1530,1534,1534,1534,1534,1534,1534,1534,1534,1534,1534,
1534,1534,1534,1534,1534,1534,1534,1534,1534,1534,1534,1534,1534,1534,1534,1534,

/* block 280 */
1535,1533,1536,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,
510,510,510,510,510,510,510,510,510,510,1533,510,510,510,510,510,
510,510,510,510,510,510,510,510,510,510,510,510,510,510,510,1533,
510,510,1533,1533,1533,1533,1533,1536,1533,1533,1533,510,1530,1530,1530,1530,
510,510,510,510,510,510,510,510,510,1530,1530,1530,1530,1530,1530,1530,
1537,1537,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,
1528,1528,1528,1528,1528,1528,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,
1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,

/* block 281 */
1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,
1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,
1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,
1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,
1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,
1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,
1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,
1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,

/* block 282 */
1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,
1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,
1529,785,1528,1528,785,785,785,785,785,785,785,785,785,1529,1529,1529,
1529,1529,1529,1529,1529,1529,785,1529,1529,1529,1529,1529,1529,1529,1529,1529,
1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,
1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,
1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,
1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,785,1529,1529,

/* block 283 */
1529,1529,1529,1529,1529,1538,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,
1529,1529,1529,1529,1528,1528,785,785,1528,785,785,785,1528,1528,785,785,
1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,
1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,
1529,1529,1538,1538,1538,1529,1529,1538,1529,1529,1538,1539,1539,785,785,1529,
1529,1529,1529,1529,785,785,785,785,785,785,785,785,785,785,785,785,
1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,
1529,1528,1528,785,1529,785,1528,785,1529,1529,1529,1540,1540,1540,1540,1540,

/* block 284 */
1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,
1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,
1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,
1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,785,
1529,785,1538,1538,1529,1529,1538,1538,1538,1538,1538,1538,1538,1538,1538,1538,
1538,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,
1529,1529,1529,1529,1529,1529,1538,1538,1538,1538,1538,1538,1538,1538,1538,1538,
1538,1538,1538,1538,1538,1538,1538,1538,1538,1529,1529,1529,1538,1529,1529,1529,

/* block 285 */
1529,1538,1538,1538,1529,1538,1538,1538,1529,1529,1529,1529,1529,1529,1529,1538,
1529,1538,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,
1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1538,1529,1529,1529,1529,1529,
1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,
1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,
1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,
1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,
1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,785,1528,1529,

/* block 286 */
1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,
1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,
1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,
1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,781,781,
781,781,781,781,781,781,1528,1528,1528,785,785,1529,1529,1529,1529,1528,
1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,
1529,1529,1529,1529,1529,1529,1529,1529,1528,1528,1528,1528,1528,1528,1528,785,
785,1528,1528,785,1539,1539,785,785,785,785,1538,1528,1528,1528,1528,1528,

/* block 287 */
1528,1528,1528,1528,1528,1528,1528,785,1528,1528,785,785,785,785,1528,1528,
1539,1528,1528,1528,1528,1538,1538,1528,1528,1528,1528,1528,1528,1528,1528,1528,
1528,1528,1528,1528,1529,785,1528,1528,785,1528,1528,1528,1528,1528,1528,1528,
1528,785,785,1528,1528,1528,1528,1528,1528,1528,1528,1528,785,1528,1528,1528,
1528,1528,785,785,785,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,
1528,785,785,785,1528,1528,1528,1528,1528,1528,1528,1528,785,785,785,1528,
1528,785,1528,785,1528,1528,1528,1528,785,1528,1528,1528,1528,1528,1528,785,
1528,1528,1528,785,1528,1528,1528,1528,1528,1528,785,1529,1529,1529,1529,1529,

/* block 288 */
1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,
1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,
1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,
1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,
1529,1529,1529,1529,1529,1538,1538,1538,1529,1529,1529,1538,1538,1538,1538,1538,
781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,
781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,
781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,

/* block 289 */
1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,
1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,
1529,1529,1529,1538,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,
1529,1529,1529,1529,1538,1538,1538,1529,1529,1529,1529,1529,1529,1529,1529,1529,
1538,1529,1529,1529,1529,1529,1528,1528,1528,1528,1528,785,1538,785,785,785,
1529,1529,1529,1528,1528,1529,1529,1529,1530,1530,1530,1530,1529,1529,1529,1529,
785,785,785,785,785,785,1528,1528,1528,785,1528,1529,1529,1530,1530,1530,
785,1528,1528,785,1529,1529,1529,1529,1529,1529,1529,1529,1529,1530,1530,1530,

/* block 290 */
781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,
781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,
781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,
781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,
781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,
781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,
781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,
781,781,781,781,1528,1528,1528,1530,1530,1530,1530,1528,1528,1528,1528,1528,

/* block 291 */
781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,
781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,
781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,
781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,
781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,
781,781,781,781,781,1528,1528,1528,1528,1528,1530,1530,1530,1530,1530,1530,
1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1530,1530,1530,1530,
1529,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,

/* block 292 */
781,781,781,781,781,781,781,781,781,781,781,781,1530,1530,1530,1530,
781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,
781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,
781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,
781,781,781,781,781,781,781,781,1530,1530,1530,1530,1530,1530,1530,1530,
781,781,781,781,781,781,781,781,781,781,1530,1530,1530,1530,1530,1530,
781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,
781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,

/* block 293 */
781,781,781,781,781,781,781,781,1530,1530,1530,1530,1530,1530,1530,1530,
781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,
781,781,781,781,781,781,781,781,781,781,781,781,781,781,1530,1530,
1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1530,1530,1530,1530,
1528,1528,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,
1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,
1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,
1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,

/* block 294 */
781,781,781,781,781,781,781,781,781,781,781,781,1538,1529,1529,1538,
1529,1529,1529,1529,1529,1529,1529,1529,1538,1538,1538,1538,1538,1538,1538,1538,
1529,1529,1529,1529,1529,1529,1538,1529,1529,1529,1529,1529,1529,1529,1529,1529,
1538,1538,1538,1538,1538,1538,1538,1538,1538,1538,1529,781,1538,1538,1538,1529,
1529,1529,1529,1529,1529,1529,781,1529,1529,1529,1529,1529,1529,1529,1529,1529,
1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,
1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,
1529,1529,1529,1529,1529,1529,1529,1538,1529,1529,1529,1529,1529,1529,1529,1529,

/* block 295 */
1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,
1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,
1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,
1541,1541,1541,1541,1529,1538,1538,1529,1538,1538,1529,1538,1529,1529,1529,1529,
1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1538,1538,1538,
1529,1538,1538,1538,1538,1538,1538,1538,1538,1538,1538,1538,1538,1538,1529,1529,
1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,
1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,

/* block 296 */
1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,
1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,
1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,
1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,
1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,
1528,1528,1528,1528,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,
1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1528,1530,1530,
1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1530,1530,1530,

/* block 297 */
1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1530,1530,1530,1530,1530,1529,
1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,
1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,
1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,
1529,1529,1529,1538,1538,1538,1529,1530,1530,1530,1530,1530,1530,1530,1529,1529,
1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1530,1530,1529,
1529,1529,1529,1529,1529,1529,1529,1529,1529,1529,1530,1530,1530,1530,1530,1530,
1538,1538,1538,1538,1538,1538,1538,1538,1538,1530,1530,1530,1530,1530,1530,1530,

/* block 298 */
781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,
781,781,781,196,781,781,781,781,781,781,781,781,781,781,781,781,
781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,
781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,
781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,
781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,
781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,781,
1479,1479,1479,1479,1479,1479,1479,1479,1479,1479,196,196,196,196,196,196,

/* block 299 */
1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,
1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,
1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,
1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,
1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,
1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,
1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,
1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1530,1032,1032,

/* block 300 */
910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,
910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,
910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,
910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,
910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,
910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,

/* block 301 */
910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,
910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,
910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,
910,910,910,910,910,910,910,910,910,910,196,196,196,196,196,196,
910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,
910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,
910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,
910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,

/* block 302 */
910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,
910,910,910,910,910,910,910,910,910,910,910,910,910,910,196,196,
910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,
910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,
910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,
910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,
910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,
910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,

/* block 303 */
910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,
910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,
910,910,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,
910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,
910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,
910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,
910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,

/* block 304 */
910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,
910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,
910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,
910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,
910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,
910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,
910,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,

/* block 305 */
910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,
910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,
910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,
910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,
910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,
910,910,910,910,910,910,910,910,910,910,910,910,910,910,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,

/* block 306 */
1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,
1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,1025,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,

/* block 307 */
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,1032,1032,

/* block 308 */
910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,
910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,
910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,
910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,
910,910,910,910,910,910,910,910,910,910,910,196,196,196,196,196,
910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,
910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,
910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,

/* block 309 */
910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,
910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,
910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,910,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,

/* block 310 */
765,770,765,765,765,765,765,765,765,765,765,765,765,765,765,765,
765,765,765,765,765,765,765,765,765,765,765,765,765,765,765,765,
1542,1542,1542,1542,1542,1542,1542,1542,1542,1542,1542,1542,1542,1542,1542,1542,
1542,1542,1542,1542,1542,1542,1542,1542,1542,1542,1542,1542,1542,1542,1542,1542,
1542,1542,1542,1542,1542,1542,1542,1542,1542,1542,1542,1542,1542,1542,1542,1542,
1542,1542,1542,1542,1542,1542,1542,1542,1542,1542,1542,1542,1542,1542,1542,1542,
1542,1542,1542,1542,1542,1542,1542,1542,1542,1542,1542,1542,1542,1542,1542,1542,
1542,1542,1542,1542,1542,1542,1542,1542,1542,1542,1542,1542,1542,1542,1542,1542,

/* block 311 */
765,765,765,765,765,765,765,765,765,765,765,765,765,765,765,765,
765,765,765,765,765,765,765,765,765,765,765,765,765,765,765,765,
765,765,765,765,765,765,765,765,765,765,765,765,765,765,765,765,
765,765,765,765,765,765,765,765,765,765,765,765,765,765,765,765,
765,765,765,765,765,765,765,765,765,765,765,765,765,765,765,765,
765,765,765,765,765,765,765,765,765,765,765,765,765,765,765,765,
765,765,765,765,765,765,765,765,765,765,765,765,765,765,765,765,
765,765,765,765,765,765,765,765,765,765,765,765,765,765,765,765,

/* block 312 */
1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,
1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,
1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,
1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,
1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,
1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,
1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,
1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,

/* block 313 */
1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,
1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,
1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,
1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,
1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,
1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,
1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,1035,
765,765,765,765,765,765,765,765,765,765,765,765,765,765,765,765,

/* block 314 */
1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,
1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,
1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,
1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,
1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,
1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,
1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,
1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1024,1032,1032,
};

#if UCD_BLOCK_SIZE != 128
#error Please correct UCD_BLOCK_SIZE in pcre2_internal.h
#endif
#endif  /* SUPPORT_UNICODE */

#endif  /* PCRE2_PCRE2TEST */

/* End of pcre2_ucd.c */


================================================
FILE: Libraries/PCRE/pcre2_ucp.h
================================================
/*************************************************
*      Perl-Compatible Regular Expressions       *
*************************************************/

/* PCRE is a library of functions to support regular expressions whose syntax
and semantics are as close as possible to those of the Perl 5 language.

                       Written by Philip Hazel
     Original API code Copyright (c) 1997-2012 University of Cambridge
          New API code Copyright (c) 2016-2022 University of Cambridge

This module is auto-generated from Unicode data files. DO NOT EDIT MANUALLY!
Instead, modify the maint/GenerateUcpHeader.py script and run it to generate
a new version of this code.

-----------------------------------------------------------------------------
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

    * Redistributions of source code must retain the above copyright notice,
      this list of conditions and the following disclaimer.

    * Redistributions in binary form must reproduce the above copyright
      notice, this list of conditions and the following disclaimer in the
      documentation and/or other materials provided with the distribution.

    * Neither the name of the University of Cambridge nor the names of its
      contributors may be used to endorse or promote products derived from
      this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
-----------------------------------------------------------------------------
*/

#ifndef PCRE2_UCP_H_IDEMPOTENT_GUARD
#define PCRE2_UCP_H_IDEMPOTENT_GUARD

/* This file contains definitions of the Unicode property values that are
returned by the UCD access macros and used throughout PCRE2.

IMPORTANT: The specific values of the first two enums (general and particular
character categories) are assumed by the table called catposstab in the file
pcre2_auto_possess.c. They are unlikely to change, but should be checked after
an update. */

/* These are the general character categories. */

enum {
  ucp_C,
  ucp_L,
  ucp_M,
  ucp_N,
  ucp_P,
  ucp_S,
  ucp_Z,
};

/* These are the particular character categories. */

enum {
  ucp_Cc,    /* Control */
  ucp_Cf,    /* Format */
  ucp_Cn,    /* Unassigned */
  ucp_Co,    /* Private use */
  ucp_Cs,    /* Surrogate */
  ucp_Ll,    /* Lower case letter */
  ucp_Lm,    /* Modifier letter */
  ucp_Lo,    /* Other letter */
  ucp_Lt,    /* Title case letter */
  ucp_Lu,    /* Upper case letter */
  ucp_Mc,    /* Spacing mark */
  ucp_Me,    /* Enclosing mark */
  ucp_Mn,    /* Non-spacing mark */
  ucp_Nd,    /* Decimal number */
  ucp_Nl,    /* Letter number */
  ucp_No,    /* Other number */
  ucp_Pc,    /* Connector punctuation */
  ucp_Pd,    /* Dash punctuation */
  ucp_Pe,    /* Close punctuation */
  ucp_Pf,    /* Final punctuation */
  ucp_Pi,    /* Initial punctuation */
  ucp_Po,    /* Other punctuation */
  ucp_Ps,    /* Open punctuation */
  ucp_Sc,    /* Currency symbol */
  ucp_Sk,    /* Modifier symbol */
  ucp_Sm,    /* Mathematical symbol */
  ucp_So,    /* Other symbol */
  ucp_Zl,    /* Line separator */
  ucp_Zp,    /* Paragraph separator */
  ucp_Zs,    /* Space separator */
};

/* These are Boolean properties. */

enum {
  ucp_ASCII,
  ucp_ASCII_Hex_Digit,
  ucp_Alphabetic,
  ucp_Bidi_Control,
  ucp_Bidi_Mirrored,
  ucp_Case_Ignorable,
  ucp_Cased,
  ucp_Changes_When_Casefolded,
  ucp_Changes_When_Casemapped,
  ucp_Changes_When_Lowercased,
  ucp_Changes_When_Titlecased,
  ucp_Changes_When_Uppercased,
  ucp_Dash,
  ucp_Default_Ignorable_Code_Point,
  ucp_Deprecated,
  ucp_Diacritic,
  ucp_Emoji,
  ucp_Emoji_Component,
  ucp_Emoji_Modifier,
  ucp_Emoji_Modifier_Base,
  ucp_Emoji_Presentation,
  ucp_Extended_Pictographic,
  ucp_Extender,
  ucp_Grapheme_Base,
  ucp_Grapheme_Extend,
  ucp_Grapheme_Link,
  ucp_Hex_Digit,
  ucp_IDS_Binary_Operator,
  ucp_IDS_Trinary_Operator,
  ucp_IDS_Unary_Operator,
  ucp_ID_Compat_Math_Continue,
  ucp_ID_Compat_Math_Start,
  ucp_ID_Continue,
  ucp_ID_Start,
  ucp_Ideographic,
  ucp_InCB,
  ucp_Join_Control,
  ucp_Logical_Order_Exception,
  ucp_Lowercase,
  ucp_Math,
  ucp_Modifier_Combining_Mark,
  ucp_Noncharacter_Code_Point,
  ucp_Pattern_Syntax,
  ucp_Pattern_White_Space,
  ucp_Prepended_Concatenation_Mark,
  ucp_Quotation_Mark,
  ucp_Radical,
  ucp_Regional_Indicator,
  ucp_Sentence_Terminal,
  ucp_Soft_Dotted,
  ucp_Terminal_Punctuation,
  ucp_Unified_Ideograph,
  ucp_Uppercase,
  ucp_Variation_Selector,
  ucp_White_Space,
  ucp_XID_Continue,
  ucp_XID_Start,
  /* This must be last */
  ucp_Bprop_Count
};

/* Size of entries in ucd_boolprop_sets[] */

#define ucd_boolprop_sets_item_size 2

/* These are the bidi class values. */

enum {
  ucp_bidiAL,   /* Arabic_Letter */
  ucp_bidiAN,   /* Arabic_Number */
  ucp_bidiB,    /* Paragraph_Separator */
  ucp_bidiBN,   /* Boundary_Neutral */
  ucp_bidiCS,   /* Common_Separator */
  ucp_bidiEN,   /* European_Number */
  ucp_bidiES,   /* European_Separator */
  ucp_bidiET,   /* European_Terminator */
  ucp_bidiFSI,  /* First_Strong_Isolate */
  ucp_bidiL,    /* Left_To_Right */
  ucp_bidiLRE,  /* Left_To_Right_Embedding */
  ucp_bidiLRI,  /* Left_To_Right_Isolate */
  ucp_bidiLRO,  /* Left_To_Right_Override */
  ucp_bidiNSM,  /* Nonspacing_Mark */
  ucp_bidiON,   /* Other_Neutral */
  ucp_bidiPDF,  /* Pop_Directional_Format */
  ucp_bidiPDI,  /* Pop_Directional_Isolate */
  ucp_bidiR,    /* Right_To_Left */
  ucp_bidiRLE,  /* Right_To_Left_Embedding */
  ucp_bidiRLI,  /* Right_To_Left_Isolate */
  ucp_bidiRLO,  /* Right_To_Left_Override */
  ucp_bidiS,    /* Segment_Separator */
  ucp_bidiWS,   /* White_Space */
};

/* These are grapheme break properties. The Extended Pictographic property
comes from the emoji-data.txt file. */

enum {
  ucp_gbCR,                    /*  0 */
  ucp_gbLF,                    /*  1 */
  ucp_gbControl,               /*  2 */
  ucp_gbExtend,                /*  3 */
  ucp_gbPrepend,               /*  4 */
  ucp_gbSpacingMark,           /*  5 */
  ucp_gbL,                     /*  6 Hangul syllable type L */
  ucp_gbV,                     /*  7 Hangul syllable type V */
  ucp_gbT,                     /*  8 Hangul syllable type T */
  ucp_gbLV,                    /*  9 Hangul syllable type LV */
  ucp_gbLVT,                   /* 10 Hangul syllable type LVT */
  ucp_gbRegional_Indicator,    /* 11 */
  ucp_gbOther,                 /* 12 */
  ucp_gbZWJ,                   /* 13 */
  ucp_gbExtended_Pictographic, /* 14 */
};

/* These are the script identifications. */

enum {
  /* Scripts which has characters in other scripts. */
  ucp_Latin,
  ucp_Greek,
  ucp_Cyrillic,
  ucp_Armenian,
  ucp_Hebrew,
  ucp_Arabic,
  ucp_Syriac,
  ucp_Thaana,
  ucp_Devanagari,
  ucp_Bengali,
  ucp_Gurmukhi,
  ucp_Gujarati,
  ucp_Oriya,
  ucp_Tamil,
  ucp_Telugu,
  ucp_Kannada,
  ucp_Malayalam,
  ucp_Sinhala,
  ucp_Thai,
  ucp_Tibetan,
  ucp_Myanmar,
  ucp_Georgian,
  ucp_Hangul,
  ucp_Ethiopic,
  ucp_Cherokee,
  ucp_Runic,
  ucp_Mongolian,
  ucp_Hiragana,
  ucp_Katakana,
  ucp_Bopomofo,
  ucp_Han,
  ucp_Yi,
  ucp_Gothic,
  ucp_Tagalog,
  ucp_Hanunoo,
  ucp_Buhid,
  ucp_Tagbanwa,
  ucp_Limbu,
  ucp_Tai_Le,
  ucp_Linear_B,
  ucp_Shavian,
  ucp_Cypriot,
  ucp_Buginese,
  ucp_Coptic,
  ucp_Glagolitic,
  ucp_Tifinagh,
  ucp_Syloti_Nagri,
  ucp_Phags_Pa,
  ucp_Nko,
  ucp_Kayah_Li,
  ucp_Lycian,
  ucp_Carian,
  ucp_Lydian,
  ucp_Avestan,
  ucp_Samaritan,
  ucp_Lisu,
  ucp_Javanese,
  ucp_Old_Turkic,
  ucp_Kaithi,
  ucp_Mandaic,
  ucp_Chakma,
  ucp_Meroitic_Hieroglyphs,
  ucp_Sharada,
  ucp_Takri,
  ucp_Caucasian_Albanian,
  ucp_Duployan,
  ucp_Elbasan,
  ucp_Grantha,
  ucp_Khojki,
  ucp_Linear_A,
  ucp_Mahajani,
  ucp_Manichaean,
  ucp_Modi,
  ucp_Old_Permic,
  ucp_Psalter_Pahlavi,
  ucp_Khudawadi,
  ucp_Tirhuta,
  ucp_Multani,
  ucp_Old_Hungarian,
  ucp_Adlam,
  ucp_Osage,
  ucp_Tangut,
  ucp_Masaram_Gondi,
  ucp_Dogra,
  ucp_Gunjala_Gondi,
  ucp_Hanifi_Rohingya,
  ucp_Sogdian,
  ucp_Nandinagari,
  ucp_Yezidi,
  ucp_Cypro_Minoan,
  ucp_Old_Uyghur,
  ucp_Toto,
  ucp_Garay,
  ucp_Gurung_Khema,
  ucp_Ol_Onal,
  ucp_Sunuwar,
  ucp_Todhri,
  ucp_Tulu_Tigalari,

  /* Scripts which has no characters in other scripts. */
  ucp_Unknown,
  ucp_Common,
  ucp_Lao,
  ucp_Canadian_Aboriginal,
  ucp_Ogham,
  ucp_Khmer,
  ucp_Old_Italic,
  ucp_Deseret,
  ucp_Inherited,
  ucp_Ugaritic,
  ucp_Osmanya,
  ucp_Braille,
  ucp_New_Tai_Lue,
  ucp_Old_Persian,
  ucp_Kharoshthi,
  ucp_Balinese,
  ucp_Cuneiform,
  ucp_Phoenician,
  ucp_Sundanese,
  ucp_Lepcha,
  ucp_Ol_Chiki,
  ucp_Vai,
  ucp_Saurashtra,
  ucp_Rejang,
  ucp_Cham,
  ucp_Tai_Tham,
  ucp_Tai_Viet,
  ucp_Egyptian_Hieroglyphs,
  ucp_Bamum,
  ucp_Meetei_Mayek,
  ucp_Imperial_Aramaic,
  ucp_Old_South_Arabian,
  ucp_Inscriptional_Parthian,
  ucp_Inscriptional_Pahlavi,
  ucp_Batak,
  ucp_Brahmi,
  ucp_Meroitic_Cursive,
  ucp_Miao,
  ucp_Sora_Sompeng,
  ucp_Bassa_Vah,
  ucp_Pahawh_Hmong,
  ucp_Mende_Kikakui,
  ucp_Mro,
  ucp_Old_North_Arabian,
  ucp_Nabataean,
  ucp_Palmyrene,
  ucp_Pau_Cin_Hau,
  ucp_Siddham,
  ucp_Warang_Citi,
  ucp_Ahom,
  ucp_Anatolian_Hieroglyphs,
  ucp_Hatran,
  ucp_SignWriting,
  ucp_Bhaiksuki,
  ucp_Marchen,
  ucp_Newa,
  ucp_Nushu,
  ucp_Soyombo,
  ucp_Zanabazar_Square,
  ucp_Makasar,
  ucp_Medefaidrin,
  ucp_Old_Sogdian,
  ucp_Elymaic,
  ucp_Nyiakeng_Puachue_Hmong,
  ucp_Wancho,
  ucp_Chorasmian,
  ucp_Dives_Akuru,
  ucp_Khitan_Small_Script,
  ucp_Tangsa,
  ucp_Vithkuqi,
  ucp_Kawi,
  ucp_Nag_Mundari,
  ucp_Kirat_Rai,

  /* This must be last */
  ucp_Script_Count
};

/* Size of entries in ucd_script_sets[] */

#define ucd_script_sets_item_size 4

#endif  /* PCRE2_UCP_H_IDEMPOTENT_GUARD */

/* End of pcre2_ucp.h */


================================================
FILE: Libraries/PCRE/pcre2_ucptables.c
================================================
/*************************************************
*      Perl-Compatible Regular Expressions       *
*************************************************/

/* PCRE is a library of functions to support regular expressions whose syntax
and semantics are as close as possible to those of the Perl 5 language.

                       Written by Philip Hazel
     Original API code Copyright (c) 1997-2012 University of Cambridge
          New API code Copyright (c) 2016-2022 University of Cambridge

This module is auto-generated from Unicode data files. DO NOT EDIT MANUALLY!
Instead, modify the maint/GenerateUcpTables.py script and run it to generate
a new version of this code.

-----------------------------------------------------------------------------
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

    * Redistributions of source code must retain the above copyright notice,
      this list of conditions and the following disclaimer.

    * Redistributions in binary form must reproduce the above copyright
      notice, this list of conditions and the following disclaimer in the
      documentation and/or other materials provided with the distribution.

    * Neither the name of the University of Cambridge nor the names of its
      contributors may be used to endorse or promote products derived from
      this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
-----------------------------------------------------------------------------
*/

#ifdef SUPPORT_UNICODE

/* The PRIV(utt)[] table below translates Unicode property names into type and
code values. It is searched by binary chop, so must be in collating sequence of
name. Originally, the table contained pointers to the name strings in the first
field of each entry. However, that leads to a large number of relocations when
a shared library is dynamically loaded. A significant reduction is made by
putting all the names into a single, large string and using offsets instead.
All letters are lower cased, and underscores are removed, in accordance with
the "loose matching" rules that Unicode advises and Perl uses. */

#define STRING_adlam0 STR_a STR_d STR_l STR_a STR_m "\0"
#define STRING_adlm0 STR_a STR_d STR_l STR_m "\0"
#define STRING_aghb0 STR_a STR_g STR_h STR_b "\0"
#define STRING_ahex0 STR_a STR_h STR_e STR_x "\0"
#define STRING_ahom0 STR_a STR_h STR_o STR_m "\0"
#define STRING_alpha0 STR_a STR_l STR_p STR_h STR_a "\0"
#define STRING_alphabetic0 STR_a STR_l STR_p STR_h STR_a STR_b STR_e STR_t STR_i STR_c "\0"
#define STRING_anatolianhieroglyphs0 STR_a STR_n STR_a STR_t STR_o STR_l STR_i STR_a STR_n STR_h STR_i STR_e STR_r STR_o STR_g STR_l STR_y STR_p STR_h STR_s "\0"
#define STRING_any0 STR_a STR_n STR_y "\0"
#define STRING_arab0 STR_a STR_r STR_a STR_b "\0"
#define STRING_arabic0 STR_a STR_r STR_a STR_b STR_i STR_c "\0"
#define STRING_armenian0 STR_a STR_r STR_m STR_e STR_n STR_i STR_a STR_n "\0"
#define STRING_armi0 STR_a STR_r STR_m STR_i "\0"
#define STRING_armn0 STR_a STR_r STR_m STR_n "\0"
#define STRING_ascii0 STR_a STR_s STR_c STR_i STR_i "\0"
#define STRING_asciihexdigit0 STR_a STR_s STR_c STR_i STR_i STR_h STR_e STR_x STR_d STR_i STR_g STR_i STR_t "\0"
#define STRING_avestan0 STR_a STR_v STR_e STR_s STR_t STR_a STR_n "\0"
#define STRING_avst0 STR_a STR_v STR_s STR_t "\0"
#define STRING_bali0 STR_b STR_a STR_l STR_i "\0"
#define STRING_balinese0 STR_b STR_a STR_l STR_i STR_n STR_e STR_s STR_e "\0"
#define STRING_bamu0 STR_b STR_a STR_m STR_u "\0"
#define STRING_bamum0 STR_b STR_a STR_m STR_u STR_m "\0"
#define STRING_bass0 STR_b STR_a STR_s STR_s "\0"
#define STRING_bassavah0 STR_b STR_a STR_s STR_s STR_a STR_v STR_a STR_h "\0"
#define STRING_batak0 STR_b STR_a STR_t STR_a STR_k "\0"
#define STRING_batk0 STR_b STR_a STR_t STR_k "\0"
#define STRING_beng0 STR_b STR_e STR_n STR_g "\0"
#define STRING_bengali0 STR_b STR_e STR_n STR_g STR_a STR_l STR_i "\0"
#define STRING_bhaiksuki0 STR_b STR_h STR_a STR_i STR_k STR_s STR_u STR_k STR_i "\0"
#define STRING_bhks0 STR_b STR_h STR_k STR_s "\0"
#define STRING_bidial0 STR_b STR_i STR_d STR_i STR_a STR_l "\0"
#define STRING_bidian0 STR_b STR_i STR_d STR_i STR_a STR_n "\0"
#define STRING_bidib0 STR_b STR_i STR_d STR_i STR_b "\0"
#define STRING_bidibn0 STR_b STR_i STR_d STR_i STR_b STR_n "\0"
#define STRING_bidic0 STR_b STR_i STR_d STR_i STR_c "\0"
#define STRING_bidicontrol0 STR_b STR_i STR_d STR_i STR_c STR_o STR_n STR_t STR_r STR_o STR_l "\0"
#define STRING_bidics0 STR_b STR_i STR_d STR_i STR_c STR_s "\0"
#define STRING_bidien0 STR_b STR_i STR_d STR_i STR_e STR_n "\0"
#define STRING_bidies0 STR_b STR_i STR_d STR_i STR_e STR_s "\0"
#define STRING_bidiet0 STR_b STR_i STR_d STR_i STR_e STR_t "\0"
#define STRING_bidifsi0 STR_b STR_i STR_d STR_i STR_f STR_s STR_i "\0"
#define STRING_bidil0 STR_b STR_i STR_d STR_i STR_l "\0"
#define STRING_bidilre0 STR_b STR_i STR_d STR_i STR_l STR_r STR_e "\0"
#define STRING_bidilri0 STR_b STR_i STR_d STR_i STR_l STR_r STR_i "\0"
#define STRING_bidilro0 STR_b STR_i STR_d STR_i STR_l STR_r STR_o "\0"
#define STRING_bidim0 STR_b STR_i STR_d STR_i STR_m "\0"
#define STRING_bidimirrored0 STR_b STR_i STR_d STR_i STR_m STR_i STR_r STR_r STR_o STR_r STR_e STR_d "\0"
#define STRING_bidinsm0 STR_b STR_i STR_d STR_i STR_n STR_s STR_m "\0"
#define STRING_bidion0 STR_b STR_i STR_d STR_i STR_o STR_n "\0"
#define STRING_bidipdf0 STR_b STR_i STR_d STR_i STR_p STR_d STR_f "\0"
#define STRING_bidipdi0 STR_b STR_i STR_d STR_i STR_p STR_d STR_i "\0"
#define STRING_bidir0 STR_b STR_i STR_d STR_i STR_r "\0"
#define STRING_bidirle0 STR_b STR_i STR_d STR_i STR_r STR_l STR_e "\0"
#define STRING_bidirli0 STR_b STR_i STR_d STR_i STR_r STR_l STR_i "\0"
#define STRING_bidirlo0 STR_b STR_i STR_d STR_i STR_r STR_l STR_o "\0"
#define STRING_bidis0 STR_b STR_i STR_d STR_i STR_s "\0"
#define STRING_bidiws0 STR_b STR_i STR_d STR_i STR_w STR_s "\0"
#define STRING_bopo0 STR_b STR_o STR_p STR_o "\0"
#define STRING_bopomofo0 STR_b STR_o STR_p STR_o STR_m STR_o STR_f STR_o "\0"
#define STRING_brah0 STR_b STR_r STR_a STR_h "\0"
#define STRING_brahmi0 STR_b STR_r STR_a STR_h STR_m STR_i "\0"
#define STRING_brai0 STR_b STR_r STR_a STR_i "\0"
#define STRING_braille0 STR_b STR_r STR_a STR_i STR_l STR_l STR_e "\0"
#define STRING_bugi0 STR_b STR_u STR_g STR_i "\0"
#define STRING_buginese0 STR_b STR_u STR_g STR_i STR_n STR_e STR_s STR_e "\0"
#define STRING_buhd0 STR_b STR_u STR_h STR_d "\0"
#define STRING_buhid0 STR_b STR_u STR_h STR_i STR_d "\0"
#define STRING_c0 STR_c "\0"
#define STRING_cakm0 STR_c STR_a STR_k STR_m "\0"
#define STRING_canadianaboriginal0 STR_c STR_a STR_n STR_a STR_d STR_i STR_a STR_n STR_a STR_b STR_o STR_r STR_i STR_g STR_i STR_n STR_a STR_l "\0"
#define STRING_cans0 STR_c STR_a STR_n STR_s "\0"
#define STRING_cari0 STR_c STR_a STR_r STR_i "\0"
#define STRING_carian0 STR_c STR_a STR_r STR_i STR_a STR_n "\0"
#define STRING_cased0 STR_c STR_a STR_s STR_e STR_d "\0"
#define STRING_caseignorable0 STR_c STR_a STR_s STR_e STR_i STR_g STR_n STR_o STR_r STR_a STR_b STR_l STR_e "\0"
#define STRING_caucasianalbanian0 STR_c STR_a STR_u STR_c STR_a STR_s STR_i STR_a STR_n STR_a STR_l STR_b STR_a STR_n STR_i STR_a STR_n "\0"
#define STRING_cc0 STR_c STR_c "\0"
#define STRING_cf0 STR_c STR_f "\0"
#define STRING_chakma0 STR_c STR_h STR_a STR_k STR_m STR_a "\0"
#define STRING_cham0 STR_c STR_h STR_a STR_m "\0"
#define STRING_changeswhencasefolded0 STR_c STR_h STR_a STR_n STR_g STR_e STR_s STR_w STR_h STR_e STR_n STR_c STR_a STR_s STR_e STR_f STR_o STR_l STR_d STR_e STR_d "\0"
#define STRING_changeswhencasemapped0 STR_c STR_h STR_a STR_n STR_g STR_e STR_s STR_w STR_h STR_e STR_n STR_c STR_a STR_s STR_e STR_m STR_a STR_p STR_p STR_e STR_d "\0"
#define STRING_changeswhenlowercased0 STR_c STR_h STR_a STR_n STR_g STR_e STR_s STR_w STR_h STR_e STR_n STR_l STR_o STR_w STR_e STR_r STR_c STR_a STR_s STR_e STR_d "\0"
#define STRING_changeswhentitlecased0 STR_c STR_h STR_a STR_n STR_g STR_e STR_s STR_w STR_h STR_e STR_n STR_t STR_i STR_t STR_l STR_e STR_c STR_a STR_s STR_e STR_d "\0"
#define STRING_changeswhenuppercased0 STR_c STR_h STR_a STR_n STR_g STR_e STR_s STR_w STR_h STR_e STR_n STR_u STR_p STR_p STR_e STR_r STR_c STR_a STR_s STR_e STR_d "\0"
#define STRING_cher0 STR_c STR_h STR_e STR_r "\0"
#define STRING_cherokee0 STR_c STR_h STR_e STR_r STR_o STR_k STR_e STR_e "\0"
#define STRING_chorasmian0 STR_c STR_h STR_o STR_r STR_a STR_s STR_m STR_i STR_a STR_n "\0"
#define STRING_chrs0 STR_c STR_h STR_r STR_s "\0"
#define STRING_ci0 STR_c STR_i "\0"
#define STRING_cn0 STR_c STR_n "\0"
#define STRING_co0 STR_c STR_o "\0"
#define STRING_common0 STR_c STR_o STR_m STR_m STR_o STR_n "\0"
#define STRING_copt0 STR_c STR_o STR_p STR_t "\0"
#define STRING_coptic0 STR_c STR_o STR_p STR_t STR_i STR_c "\0"
#define STRING_cpmn0 STR_c STR_p STR_m STR_n "\0"
#define STRING_cprt0 STR_c STR_p STR_r STR_t "\0"
#define STRING_cs0 STR_c STR_s "\0"
#define STRING_cuneiform0 STR_c STR_u STR_n STR_e STR_i STR_f STR_o STR_r STR_m "\0"
#define STRING_cwcf0 STR_c STR_w STR_c STR_f "\0"
#define STRING_cwcm0 STR_c STR_w STR_c STR_m "\0"
#define STRING_cwl0 STR_c STR_w STR_l "\0"
#define STRING_cwt0 STR_c STR_w STR_t "\0"
#define STRING_cwu0 STR_c STR_w STR_u "\0"
#define STRING_cypriot0 STR_c STR_y STR_p STR_r STR_i STR_o STR_t "\0"
#define STRING_cyprominoan0 STR_c STR_y STR_p STR_r STR_o STR_m STR_i STR_n STR_o STR_a STR_n "\0"
#define STRING_cyrillic0 STR_c STR_y STR_r STR_i STR_l STR_l STR_i STR_c "\0"
#define STRING_cyrl0 STR_c STR_y STR_r STR_l "\0"
#define STRING_dash0 STR_d STR_a STR_s STR_h "\0"
#define STRING_defaultignorablecodepoint0 STR_d STR_e STR_f STR_a STR_u STR_l STR_t STR_i STR_g STR_n STR_o STR_r STR_a STR_b STR_l STR_e STR_c STR_o STR_d STR_e STR_p STR_o STR_i STR_n STR_t "\0"
#define STRING_dep0 STR_d STR_e STR_p "\0"
#define STRING_deprecated0 STR_d STR_e STR_p STR_r STR_e STR_c STR_a STR_t STR_e STR_d "\0"
#define STRING_deseret0 STR_d STR_e STR_s STR_e STR_r STR_e STR_t "\0"
#define STRING_deva0 STR_d STR_e STR_v STR_a "\0"
#define STRING_devanagari0 STR_d STR_e STR_v STR_a STR_n STR_a STR_g STR_a STR_r STR_i "\0"
#define STRING_di0 STR_d STR_i "\0"
#define STRING_dia0 STR_d STR_i STR_a "\0"
#define STRING_diacritic0 STR_d STR_i STR_a STR_c STR_r STR_i STR_t STR_i STR_c "\0"
#define STRING_diak0 STR_d STR_i STR_a STR_k "\0"
#define STRING_divesakuru0 STR_d STR_i STR_v STR_e STR_s STR_a STR_k STR_u STR_r STR_u "\0"
#define STRING_dogr0 STR_d STR_o STR_g STR_r "\0"
#define STRING_dogra0 STR_d STR_o STR_g STR_r STR_a "\0"
#define STRING_dsrt0 STR_d STR_s STR_r STR_t "\0"
#define STRING_dupl0 STR_d STR_u STR_p STR_l "\0"
#define STRING_duployan0 STR_d STR_u STR_p STR_l STR_o STR_y STR_a STR_n "\0"
#define STRING_ebase0 STR_e STR_b STR_a STR_s STR_e "\0"
#define STRING_ecomp0 STR_e STR_c STR_o STR_m STR_p "\0"
#define STRING_egyp0 STR_e STR_g STR_y STR_p "\0"
#define STRING_egyptianhieroglyphs0 STR_e STR_g STR_y STR_p STR_t STR_i STR_a STR_n STR_h STR_i STR_e STR_r STR_o STR_g STR_l STR_y STR_p STR_h STR_s "\0"
#define STRING_elba0 STR_e STR_l STR_b STR_a "\0"
#define STRING_elbasan0 STR_e STR_l STR_b STR_a STR_s STR_a STR_n "\0"
#define STRING_elym0 STR_e STR_l STR_y STR_m "\0"
#define STRING_elymaic0 STR_e STR_l STR_y STR_m STR_a STR_i STR_c "\0"
#define STRING_emod0 STR_e STR_m STR_o STR_d "\0"
#define STRING_emoji0 STR_e STR_m STR_o STR_j STR_i "\0"
#define STRING_emojicomponent0 STR_e STR_m STR_o STR_j STR_i STR_c STR_o STR_m STR_p STR_o STR_n STR_e STR_n STR_t "\0"
#define STRING_emojimodifier0 STR_e STR_m STR_o STR_j STR_i STR_m STR_o STR_d STR_i STR_f STR_i STR_e STR_r "\0"
#define STRING_emojimodifierbase0 STR_e STR_m STR_o STR_j STR_i STR_m STR_o STR_d STR_i STR_f STR_i STR_e STR_r STR_b STR_a STR_s STR_e "\0"
#define STRING_emojipresentation0 STR_e STR_m STR_o STR_j STR_i STR_p STR_r STR_e STR_s STR_e STR_n STR_t STR_a STR_t STR_i STR_o STR_n "\0"
#define STRING_epres0 STR_e STR_p STR_r STR_e STR_s "\0"
#define STRING_ethi0 STR_e STR_t STR_h STR_i "\0"
#define STRING_ethiopic0 STR_e STR_t STR_h STR_i STR_o STR_p STR_i STR_c "\0"
#define STRING_ext0 STR_e STR_x STR_t "\0"
#define STRING_extendedpictographic0 STR_e STR_x STR_t STR_e STR_n STR_d STR_e STR_d STR_p STR_i STR_c STR_t STR_o STR_g STR_r STR_a STR_p STR_h STR_i STR_c "\0"
#define STRING_extender0 STR_e STR_x STR_t STR_e STR_n STR_d STR_e STR_r "\0"
#define STRING_extpict0 STR_e STR_x STR_t STR_p STR_i STR_c STR_t "\0"
#define STRING_gara0 STR_g STR_a STR_r STR_a "\0"
#define STRING_garay0 STR_g STR_a STR_r STR_a STR_y "\0"
#define STRING_geor0 STR_g STR_e STR_o STR_r "\0"
#define STRING_georgian0 STR_g STR_e STR_o STR_r STR_g STR_i STR_a STR_n "\0"
#define STRING_glag0 STR_g STR_l STR_a STR_g "\0"
#define STRING_glagolitic0 STR_g STR_l STR_a STR_g STR_o STR_l STR_i STR_t STR_i STR_c "\0"
#define STRING_gong0 STR_g STR_o STR_n STR_g "\0"
#define STRING_gonm0 STR_g STR_o STR_n STR_m "\0"
#define STRING_goth0 STR_g STR_o STR_t STR_h "\0"
#define STRING_gothic0 STR_g STR_o STR_t STR_h STR_i STR_c "\0"
#define STRING_gran0 STR_g STR_r STR_a STR_n "\0"
#define STRING_grantha0 STR_g STR_r STR_a STR_n STR_t STR_h STR_a "\0"
#define STRING_graphemebase0 STR_g STR_r STR_a STR_p STR_h STR_e STR_m STR_e STR_b STR_a STR_s STR_e "\0"
#define STRING_graphemeextend0 STR_g STR_r STR_a STR_p STR_h STR_e STR_m STR_e STR_e STR_x STR_t STR_e STR_n STR_d "\0"
#define STRING_graphemelink0 STR_g STR_r STR_a STR_p STR_h STR_e STR_m STR_e STR_l STR_i STR_n STR_k "\0"
#define STRING_grbase0 STR_g STR_r STR_b STR_a STR_s STR_e "\0"
#define STRING_greek0 STR_g STR_r STR_e STR_e STR_k "\0"
#define STRING_grek0 STR_g STR_r STR_e STR_k "\0"
#define STRING_grext0 STR_g STR_r STR_e STR_x STR_t "\0"
#define STRING_grlink0 STR_g STR_r STR_l STR_i STR_n STR_k "\0"
#define STRING_gujarati0 STR_g STR_u STR_j STR_a STR_r STR_a STR_t STR_i "\0"
#define STRING_gujr0 STR_g STR_u STR_j STR_r "\0"
#define STRING_gukh0 STR_g STR_u STR_k STR_h "\0"
#define STRING_gunjalagondi0 STR_g STR_u STR_n STR_j STR_a STR_l STR_a STR_g STR_o STR_n STR_d STR_i "\0"
#define STRING_gurmukhi0 STR_g STR_u STR_r STR_m STR_u STR_k STR_h STR_i "\0"
#define STRING_guru0 STR_g STR_u STR_r STR_u "\0"
#define STRING_gurungkhema0 STR_g STR_u STR_r STR_u STR_n STR_g STR_k STR_h STR_e STR_m STR_a "\0"
#define STRING_han0 STR_h STR_a STR_n "\0"
#define STRING_hang0 STR_h STR_a STR_n STR_g "\0"
#define STRING_hangul0 STR_h STR_a STR_n STR_g STR_u STR_l "\0"
#define STRING_hani0 STR_h STR_a STR_n STR_i "\0"
#define STRING_hanifirohingya0 STR_h STR_a STR_n STR_i STR_f STR_i STR_r STR_o STR_h STR_i STR_n STR_g STR_y STR_a "\0"
#define STRING_hano0 STR_h STR_a STR_n STR_o "\0"
#define STRING_hanunoo0 STR_h STR_a STR_n STR_u STR_n STR_o STR_o "\0"
#define STRING_hatr0 STR_h STR_a STR_t STR_r "\0"
#define STRING_hatran0 STR_h STR_a STR_t STR_r STR_a STR_n "\0"
#define STRING_hebr0 STR_h STR_e STR_b STR_r "\0"
#define STRING_hebrew0 STR_h STR_e STR_b STR_r STR_e STR_w "\0"
#define STRING_hex0 STR_h STR_e STR_x "\0"
#define STRING_hexdigit0 STR_h STR_e STR_x STR_d STR_i STR_g STR_i STR_t "\0"
#define STRING_hira0 STR_h STR_i STR_r STR_a "\0"
#define STRING_hiragana0 STR_h STR_i STR_r STR_a STR_g STR_a STR_n STR_a "\0"
#define STRING_hluw0 STR_h STR_l STR_u STR_w "\0"
#define STRING_hmng0 STR_h STR_m STR_n STR_g "\0"
#define STRING_hmnp0 STR_h STR_m STR_n STR_p "\0"
#define STRING_hung0 STR_h STR_u STR_n STR_g "\0"
#define STRING_idc0 STR_i STR_d STR_c "\0"
#define STRING_idcompatmathcontinue0 STR_i STR_d STR_c STR_o STR_m STR_p STR_a STR_t STR_m STR_a STR_t STR_h STR_c STR_o STR_n STR_t STR_i STR_n STR_u STR_e "\0"
#define STRING_idcompatmathstart0 STR_i STR_d STR_c STR_o STR_m STR_p STR_a STR_t STR_m STR_a STR_t STR_h STR_s STR_t STR_a STR_r STR_t "\0"
#define STRING_idcontinue0 STR_i STR_d STR_c STR_o STR_n STR_t STR_i STR_n STR_u STR_e "\0"
#define STRING_ideo0 STR_i STR_d STR_e STR_o "\0"
#define STRING_ideographic0 STR_i STR_d STR_e STR_o STR_g STR_r STR_a STR_p STR_h STR_i STR_c "\0"
#define STRING_ids0 STR_i STR_d STR_s "\0"
#define STRING_idsb0 STR_i STR_d STR_s STR_b "\0"
#define STRING_idsbinaryoperator0 STR_i STR_d STR_s STR_b STR_i STR_n STR_a STR_r STR_y STR_o STR_p STR_e STR_r STR_a STR_t STR_o STR_r "\0"
#define STRING_idst0 STR_i STR_d STR_s STR_t "\0"
#define STRING_idstart0 STR_i STR_d STR_s STR_t STR_a STR_r STR_t "\0"
#define STRING_idstrinaryoperator0 STR_i STR_d STR_s STR_t STR_r STR_i STR_n STR_a STR_r STR_y STR_o STR_p STR_e STR_r STR_a STR_t STR_o STR_r "\0"
#define STRING_idsu0 STR_i STR_d STR_s STR_u "\0"
#define STRING_idsunaryoperator0 STR_i STR_d STR_s STR_u STR_n STR_a STR_r STR_y STR_o STR_p STR_e STR_r STR_a STR_t STR_o STR_r "\0"
#define STRING_imperialaramaic0 STR_i STR_m STR_p STR_e STR_r STR_i STR_a STR_l STR_a STR_r STR_a STR_m STR_a STR_i STR_c "\0"
#define STRING_incb0 STR_i STR_n STR_c STR_b "\0"
#define STRING_inherited0 STR_i STR_n STR_h STR_e STR_r STR_i STR_t STR_e STR_d "\0"
#define STRING_inscriptionalpahlavi0 STR_i STR_n STR_s STR_c STR_r STR_i STR_p STR_t STR_i STR_o STR_n STR_a STR_l STR_p STR_a STR_h STR_l STR_a STR_v STR_i "\0"
#define STRING_inscriptionalparthian0 STR_i STR_n STR_s STR_c STR_r STR_i STR_p STR_t STR_i STR_o STR_n STR_a STR_l STR_p STR_a STR_r STR_t STR_h STR_i STR_a STR_n "\0"
#define STRING_ital0 STR_i STR_t STR_a STR_l "\0"
#define STRING_java0 STR_j STR_a STR_v STR_a "\0"
#define STRING_javanese0 STR_j STR_a STR_v STR_a STR_n STR_e STR_s STR_e "\0"
#define STRING_joinc0 STR_j STR_o STR_i STR_n STR_c "\0"
#define STRING_joincontrol0 STR_j STR_o STR_i STR_n STR_c STR_o STR_n STR_t STR_r STR_o STR_l "\0"
#define STRING_kaithi0 STR_k STR_a STR_i STR_t STR_h STR_i "\0"
#define STRING_kali0 STR_k STR_a STR_l STR_i "\0"
#define STRING_kana0 STR_k STR_a STR_n STR_a "\0"
#define STRING_kannada0 STR_k STR_a STR_n STR_n STR_a STR_d STR_a "\0"
#define STRING_katakana0 STR_k STR_a STR_t STR_a STR_k STR_a STR_n STR_a "\0"
#define STRING_kawi0 STR_k STR_a STR_w STR_i "\0"
#define STRING_kayahli0 STR_k STR_a STR_y STR_a STR_h STR_l STR_i "\0"
#define STRING_khar0 STR_k STR_h STR_a STR_r "\0"
#define STRING_kharoshthi0 STR_k STR_h STR_a STR_r STR_o STR_s STR_h STR_t STR_h STR_i "\0"
#define STRING_khitansmallscript0 STR_k STR_h STR_i STR_t STR_a STR_n STR_s STR_m STR_a STR_l STR_l STR_s STR_c STR_r STR_i STR_p STR_t "\0"
#define STRING_khmer0 STR_k STR_h STR_m STR_e STR_r "\0"
#define STRING_khmr0 STR_k STR_h STR_m STR_r "\0"
#define STRING_khoj0 STR_k STR_h STR_o STR_j "\0"
#define STRING_khojki0 STR_k STR_h STR_o STR_j STR_k STR_i "\0"
#define STRING_khudawadi0 STR_k STR_h STR_u STR_d STR_a STR_w STR_a STR_d STR_i "\0"
#define STRING_kiratrai0 STR_k STR_i STR_r STR_a STR_t STR_r STR_a STR_i "\0"
#define STRING_kits0 STR_k STR_i STR_t STR_s "\0"
#define STRING_knda0 STR_k STR_n STR_d STR_a "\0"
#define STRING_krai0 STR_k STR_r STR_a STR_i "\0"
#define STRING_kthi0 STR_k STR_t STR_h STR_i "\0"
#define STRING_l0 STR_l "\0"
#define STRING_l_AMPERSAND0 STR_l STR_AMPERSAND "\0"
#define STRING_lana0 STR_l STR_a STR_n STR_a "\0"
#define STRING_lao0 STR_l STR_a STR_o "\0"
#define STRING_laoo0 STR_l STR_a STR_o STR_o "\0"
#define STRING_latin0 STR_l STR_a STR_t STR_i STR_n "\0"
#define STRING_latn0 STR_l STR_a STR_t STR_n "\0"
#define STRING_lc0 STR_l STR_c "\0"
#define STRING_lepc0 STR_l STR_e STR_p STR_c "\0"
#define STRING_lepcha0 STR_l STR_e STR_p STR_c STR_h STR_a "\0"
#define STRING_limb0 STR_l STR_i STR_m STR_b "\0"
#define STRING_limbu0 STR_l STR_i STR_m STR_b STR_u "\0"
#define STRING_lina0 STR_l STR_i STR_n STR_a "\0"
#define STRING_linb0 STR_l STR_i STR_n STR_b "\0"
#define STRING_lineara0 STR_l STR_i STR_n STR_e STR_a STR_r STR_a "\0"
#define STRING_linearb0 STR_l STR_i STR_n STR_e STR_a STR_r STR_b "\0"
#define STRING_lisu0 STR_l STR_i STR_s STR_u "\0"
#define STRING_ll0 STR_l STR_l "\0"
#define STRING_lm0 STR_l STR_m "\0"
#define STRING_lo0 STR_l STR_o "\0"
#define STRING_loe0 STR_l STR_o STR_e "\0"
#define STRING_logicalorderexception0 STR_l STR_o STR_g STR_i STR_c STR_a STR_l STR_o STR_r STR_d STR_e STR_r STR_e STR_x STR_c STR_e STR_p STR_t STR_i STR_o STR_n "\0"
#define STRING_lower0 STR_l STR_o STR_w STR_e STR_r "\0"
#define STRING_lowercase0 STR_l STR_o STR_w STR_e STR_r STR_c STR_a STR_s STR_e "\0"
#define STRING_lt0 STR_l STR_t "\0"
#define STRING_lu0 STR_l STR_u "\0"
#define STRING_lyci0 STR_l STR_y STR_c STR_i "\0"
#define STRING_lycian0 STR_l STR_y STR_c STR_i STR_a STR_n "\0"
#define STRING_lydi0 STR_l STR_y STR_d STR_i "\0"
#define STRING_lydian0 STR_l STR_y STR_d STR_i STR_a STR_n "\0"
#define STRING_m0 STR_m "\0"
#define STRING_mahajani0 STR_m STR_a STR_h STR_a STR_j STR_a STR_n STR_i "\0"
#define STRING_mahj0 STR_m STR_a STR_h STR_j "\0"
#define STRING_maka0 STR_m STR_a STR_k STR_a "\0"
#define STRING_makasar0 STR_m STR_a STR_k STR_a STR_s STR_a STR_r "\0"
#define STRING_malayalam0 STR_m STR_a STR_l STR_a STR_y STR_a STR_l STR_a STR_m "\0"
#define STRING_mand0 STR_m STR_a STR_n STR_d "\0"
#define STRING_mandaic0 STR_m STR_a STR_n STR_d STR_a STR_i STR_c "\0"
#define STRING_mani0 STR_m STR_a STR_n STR_i "\0"
#define STRING_manichaean0 STR_m STR_a STR_n STR_i STR_c STR_h STR_a STR_e STR_a STR_n "\0"
#define STRING_marc0 STR_m STR_a STR_r STR_c "\0"
#define STRING_marchen0 STR_m STR_a STR_r STR_c STR_h STR_e STR_n "\0"
#define STRING_masaramgondi0 STR_m STR_a STR_s STR_a STR_r STR_a STR_m STR_g STR_o STR_n STR_d STR_i "\0"
#define STRING_math0 STR_m STR_a STR_t STR_h "\0"
#define STRING_mc0 STR_m STR_c "\0"
#define STRING_mcm0 STR_m STR_c STR_m "\0"
#define STRING_me0 STR_m STR_e "\0"
#define STRING_medefaidrin0 STR_m STR_e STR_d STR_e STR_f STR_a STR_i STR_d STR_r STR_i STR_n "\0"
#define STRING_medf0 STR_m STR_e STR_d STR_f "\0"
#define STRING_meeteimayek0 STR_m STR_e STR_e STR_t STR_e STR_i STR_m STR_a STR_y STR_e STR_k "\0"
#define STRING_mend0 STR_m STR_e STR_n STR_d "\0"
#define STRING_mendekikakui0 STR_m STR_e STR_n STR_d STR_e STR_k STR_i STR_k STR_a STR_k STR_u STR_i "\0"
#define STRING_merc0 STR_m STR_e STR_r STR_c "\0"
#define STRING_mero0 STR_m STR_e STR_r STR_o "\0"
#define STRING_meroiticcursive0 STR_m STR_e STR_r STR_o STR_i STR_t STR_i STR_c STR_c STR_u STR_r STR_s STR_i STR_v STR_e "\0"
#define STRING_meroitichieroglyphs0 STR_m STR_e STR_r STR_o STR_i STR_t STR_i STR_c STR_h STR_i STR_e STR_r STR_o STR_g STR_l STR_y STR_p STR_h STR_s "\0"
#define STRING_miao0 STR_m STR_i STR_a STR_o "\0"
#define STRING_mlym0 STR_m STR_l STR_y STR_m "\0"
#define STRING_mn0 STR_m STR_n "\0"
#define STRING_modi0 STR_m STR_o STR_d STR_i "\0"
#define STRING_modifiercombiningmark0 STR_m STR_o STR_d STR_i STR_f STR_i STR_e STR_r STR_c STR_o STR_m STR_b STR_i STR_n STR_i STR_n STR_g STR_m STR_a STR_r STR_k "\0"
#define STRING_mong0 STR_m STR_o STR_n STR_g "\0"
#define STRING_mongolian0 STR_m STR_o STR_n STR_g STR_o STR_l STR_i STR_a STR_n "\0"
#define STRING_mro0 STR_m STR_r STR_o "\0"
#define STRING_mroo0 STR_m STR_r STR_o STR_o "\0"
#define STRING_mtei0 STR_m STR_t STR_e STR_i "\0"
#define STRING_mult0 STR_m STR_u STR_l STR_t "\0"
#define STRING_multani0 STR_m STR_u STR_l STR_t STR_a STR_n STR_i "\0"
#define STRING_myanmar0 STR_m STR_y STR_a STR_n STR_m STR_a STR_r "\0"
#define STRING_mymr0 STR_m STR_y STR_m STR_r "\0"
#define STRING_n0 STR_n "\0"
#define STRING_nabataean0 STR_n STR_a STR_b STR_a STR_t STR_a STR_e STR_a STR_n "\0"
#define STRING_nagm0 STR_n STR_a STR_g STR_m "\0"
#define STRING_nagmundari0 STR_n STR_a STR_g STR_m STR_u STR_n STR_d STR_a STR_r STR_i "\0"
#define STRING_nand0 STR_n STR_a STR_n STR_d "\0"
#define STRING_nandinagari0 STR_n STR_a STR_n STR_d STR_i STR_n STR_a STR_g STR_a STR_r STR_i "\0"
#define STRING_narb0 STR_n STR_a STR_r STR_b "\0"
#define STRING_nbat0 STR_n STR_b STR_a STR_t "\0"
#define STRING_nchar0 STR_n STR_c STR_h STR_a STR_r "\0"
#define STRING_nd0 STR_n STR_d "\0"
#define STRING_newa0 STR_n STR_e STR_w STR_a "\0"
#define STRING_newtailue0 STR_n STR_e STR_w STR_t STR_a STR_i STR_l STR_u STR_e "\0"
#define STRING_nko0 STR_n STR_k STR_o "\0"
#define STRING_nkoo0 STR_n STR_k STR_o STR_o "\0"
#define STRING_nl0 STR_n STR_l "\0"
#define STRING_no0 STR_n STR_o "\0"
#define STRING_noncharactercodepoint0 STR_n STR_o STR_n STR_c STR_h STR_a STR_r STR_a STR_c STR_t STR_e STR_r STR_c STR_o STR_d STR_e STR_p STR_o STR_i STR_n STR_t "\0"
#define STRING_nshu0 STR_n STR_s STR_h STR_u "\0"
#define STRING_nushu0 STR_n STR_u STR_s STR_h STR_u "\0"
#define STRING_nyiakengpuachuehmong0 STR_n STR_y STR_i STR_a STR_k STR_e STR_n STR_g STR_p STR_u STR_a STR_c STR_h STR_u STR_e STR_h STR_m STR_o STR_n STR_g "\0"
#define STRING_ogam0 STR_o STR_g STR_a STR_m "\0"
#define STRING_ogham0 STR_o STR_g STR_h STR_a STR_m "\0"
#define STRING_olchiki0 STR_o STR_l STR_c STR_h STR_i STR_k STR_i "\0"
#define STRING_olck0 STR_o STR_l STR_c STR_k "\0"
#define STRING_oldhungarian0 STR_o STR_l STR_d STR_h STR_u STR_n STR_g STR_a STR_r STR_i STR_a STR_n "\0"
#define STRING_olditalic0 STR_o STR_l STR_d STR_i STR_t STR_a STR_l STR_i STR_c "\0"
#define STRING_oldnortharabian0 STR_o STR_l STR_d STR_n STR_o STR_r STR_t STR_h STR_a STR_r STR_a STR_b STR_i STR_a STR_n "\0"
#define STRING_oldpermic0 STR_o STR_l STR_d STR_p STR_e STR_r STR_m STR_i STR_c "\0"
#define STRING_oldpersian0 STR_o STR_l STR_d STR_p STR_e STR_r STR_s STR_i STR_a STR_n "\0"
#define STRING_oldsogdian0 STR_o STR_l STR_d STR_s STR_o STR_g STR_d STR_i STR_a STR_n "\0"
#define STRING_oldsoutharabian0 STR_o STR_l STR_d STR_s STR_o STR_u STR_t STR_h STR_a STR_r STR_a STR_b STR_i STR_a STR_n "\0"
#define STRING_oldturkic0 STR_o STR_l STR_d STR_t STR_u STR_r STR_k STR_i STR_c "\0"
#define STRING_olduyghur0 STR_o STR_l STR_d STR_u STR_y STR_g STR_h STR_u STR_r "\0"
#define STRING_olonal0 STR_o STR_l STR_o STR_n STR_a STR_l "\0"
#define STRING_onao0 STR_o STR_n STR_a STR_o "\0"
#define STRING_oriya0 STR_o STR_r STR_i STR_y STR_a "\0"
#define STRING_orkh0 STR_o STR_r STR_k STR_h "\0"
#define STRING_orya0 STR_o STR_r STR_y STR_a "\0"
#define STRING_osage0 STR_o STR_s STR_a STR_g STR_e "\0"
#define STRING_osge0 STR_o STR_s STR_g STR_e "\0"
#define STRING_osma0 STR_o STR_s STR_m STR_a "\0"
#define STRING_osmanya0 STR_o STR_s STR_m STR_a STR_n STR_y STR_a "\0"
#define STRING_ougr0 STR_o STR_u STR_g STR_r "\0"
#define STRING_p0 STR_p "\0"
#define STRING_pahawhhmong0 STR_p STR_a STR_h STR_a STR_w STR_h STR_h STR_m STR_o STR_n STR_g "\0"
#define STRING_palm0 STR_p STR_a STR_l STR_m "\0"
#define STRING_palmyrene0 STR_p STR_a STR_l STR_m STR_y STR_r STR_e STR_n STR_e "\0"
#define STRING_patsyn0 STR_p STR_a STR_t STR_s STR_y STR_n "\0"
#define STRING_patternsyntax0 STR_p STR_a STR_t STR_t STR_e STR_r STR_n STR_s STR_y STR_n STR_t STR_a STR_x "\0"
#define STRING_patternwhitespace0 STR_p STR_a STR_t STR_t STR_e STR_r STR_n STR_w STR_h STR_i STR_t STR_e STR_s STR_p STR_a STR_c STR_e "\0"
#define STRING_patws0 STR_p STR_a STR_t STR_w STR_s "\0"
#define STRING_pauc0 STR_p STR_a STR_u STR_c "\0"
#define STRING_paucinhau0 STR_p STR_a STR_u STR_c STR_i STR_n STR_h STR_a STR_u "\0"
#define STRING_pc0 STR_p STR_c "\0"
#define STRING_pcm0 STR_p STR_c STR_m "\0"
#define STRING_pd0 STR_p STR_d "\0"
#define STRING_pe0 STR_p STR_e "\0"
#define STRING_perm0 STR_p STR_e STR_r STR_m "\0"
#define STRING_pf0 STR_p STR_f "\0"
#define STRING_phag0 STR_p STR_h STR_a STR_g "\0"
#define STRING_phagspa0 STR_p STR_h STR_a STR_g STR_s STR_p STR_a "\0"
#define STRING_phli0 STR_p STR_h STR_l STR_i "\0"
#define STRING_phlp0 STR_p STR_h STR_l STR_p "\0"
#define STRING_phnx0 STR_p STR_h STR_n STR_x "\0"
#define STRING_phoenician0 STR_p STR_h STR_o STR_e STR_n STR_i STR_c STR_i STR_a STR_n "\0"
#define STRING_pi0 STR_p STR_i "\0"
#define STRING_plrd0 STR_p STR_l STR_r STR_d "\0"
#define STRING_po0 STR_p STR_o "\0"
#define STRING_prependedconcatenationmark0 STR_p STR_r STR_e STR_p STR_e STR_n STR_d STR_e STR_d STR_c STR_o STR_n STR_c STR_a STR_t STR_e STR_n STR_a STR_t STR_i STR_o STR_n STR_m STR_a STR_r STR_k "\0"
#define STRING_prti0 STR_p STR_r STR_t STR_i "\0"
#define STRING_ps0 STR_p STR_s "\0"
#define STRING_psalterpahlavi0 STR_p STR_s STR_a STR_l STR_t STR_e STR_r STR_p STR_a STR_h STR_l STR_a STR_v STR_i "\0"
#define STRING_qaac0 STR_q STR_a STR_a STR_c "\0"
#define STRING_qaai0 STR_q STR_a STR_a STR_i "\0"
#define STRING_qmark0 STR_q STR_m STR_a STR_r STR_k "\0"
#define STRING_quotationmark0 STR_q STR_u STR_o STR_t STR_a STR_t STR_i STR_o STR_n STR_m STR_a STR_r STR_k "\0"
#define STRING_radical0 STR_r STR_a STR_d STR_i STR_c STR_a STR_l "\0"
#define STRING_regionalindicator0 STR_r STR_e STR_g STR_i STR_o STR_n STR_a STR_l STR_i STR_n STR_d STR_i STR_c STR_a STR_t STR_o STR_r "\0"
#define STRING_rejang0 STR_r STR_e STR_j STR_a STR_n STR_g "\0"
#define STRING_ri0 STR_r STR_i "\0"
#define STRING_rjng0 STR_r STR_j STR_n STR_g "\0"
#define STRING_rohg0 STR_r STR_o STR_h STR_g "\0"
#define STRING_runic0 STR_r STR_u STR_n STR_i STR_c "\0"
#define STRING_runr0 STR_r STR_u STR_n STR_r "\0"
#define STRING_s0 STR_s "\0"
#define STRING_samaritan0 STR_s STR_a STR_m STR_a STR_r STR_i STR_t STR_a STR_n "\0"
#define STRING_samr0 STR_s STR_a STR_m STR_r "\0"
#define STRING_sarb0 STR_s STR_a STR_r STR_b "\0"
#define STRING_saur0 STR_s STR_a STR_u STR_r "\0"
#define STRING_saurashtra0 STR_s STR_a STR_u STR_r STR_a STR_s STR_h STR_t STR_r STR_a "\0"
#define STRING_sc0 STR_s STR_c "\0"
#define STRING_sd0 STR_s STR_d "\0"
#define STRING_sentenceterminal0 STR_s STR_e STR_n STR_t STR_e STR_n STR_c STR_e STR_t STR_e STR_r STR_m STR_i STR_n STR_a STR_l "\0"
#define STRING_sgnw0 STR_s STR_g STR_n STR_w "\0"
#define STRING_sharada0 STR_s STR_h STR_a STR_r STR_a STR_d STR_a "\0"
#define STRING_shavian0 STR_s STR_h STR_a STR_v STR_i STR_a STR_n "\0"
#define STRING_shaw0 STR_s STR_h STR_a STR_w "\0"
#define STRING_shrd0 STR_s STR_h STR_r STR_d "\0"
#define STRING_sidd0 STR_s STR_i STR_d STR_d "\0"
#define STRING_siddham0 STR_s STR_i STR_d STR_d STR_h STR_a STR_m "\0"
#define STRING_signwriting0 STR_s STR_i STR_g STR_n STR_w STR_r STR_i STR_t STR_i STR_n STR_g "\0"
#define STRING_sind0 STR_s STR_i STR_n STR_d "\0"
#define STRING_sinh0 STR_s STR_i STR_n STR_h "\0"
#define STRING_sinhala0 STR_s STR_i STR_n STR_h STR_a STR_l STR_a "\0"
#define STRING_sk0 STR_s STR_k "\0"
#define STRING_sm0 STR_s STR_m "\0"
#define STRING_so0 STR_s STR_o "\0"
#define STRING_softdotted0 STR_s STR_o STR_f STR_t STR_d STR_o STR_t STR_t STR_e STR_d "\0"
#define STRING_sogd0 STR_s STR_o STR_g STR_d "\0"
#define STRING_sogdian0 STR_s STR_o STR_g STR_d STR_i STR_a STR_n "\0"
#define STRING_sogo0 STR_s STR_o STR_g STR_o "\0"
#define STRING_sora0 STR_s STR_o STR_r STR_a "\0"
#define STRING_sorasompeng0 STR_s STR_o STR_r STR_a STR_s STR_o STR_m STR_p STR_e STR_n STR_g "\0"
#define STRING_soyo0 STR_s STR_o STR_y STR_o "\0"
#define STRING_soyombo0 STR_s STR_o STR_y STR_o STR_m STR_b STR_o "\0"
#define STRING_space0 STR_s STR_p STR_a STR_c STR_e "\0"
#define STRING_sterm0 STR_s STR_t STR_e STR_r STR_m "\0"
#define STRING_sund0 STR_s STR_u STR_n STR_d "\0"
#define STRING_sundanese0 STR_s STR_u STR_n STR_d STR_a STR_n STR_e STR_s STR_e "\0"
#define STRING_sunu0 STR_s STR_u STR_n STR_u "\0"
#define STRING_sunuwar0 STR_s STR_u STR_n STR_u STR_w STR_a STR_r "\0"
#define STRING_sylo0 STR_s STR_y STR_l STR_o "\0"
#define STRING_sylotinagri0 STR_s STR_y STR_l STR_o STR_t STR_i STR_n STR_a STR_g STR_r STR_i "\0"
#define STRING_syrc0 STR_s STR_y STR_r STR_c "\0"
#define STRING_syriac0 STR_s STR_y STR_r STR_i STR_a STR_c "\0"
#define STRING_tagalog0 STR_t STR_a STR_g STR_a STR_l STR_o STR_g "\0"
#define STRING_tagb0 STR_t STR_a STR_g STR_b "\0"
#define STRING_tagbanwa0 STR_t STR_a STR_g STR_b STR_a STR_n STR_w STR_a "\0"
#define STRING_taile0 STR_t STR_a STR_i STR_l STR_e "\0"
#define STRING_taitham0 STR_t STR_a STR_i STR_t STR_h STR_a STR_m "\0"
#define STRING_taiviet0 STR_t STR_a STR_i STR_v STR_i STR_e STR_t "\0"
#define STRING_takr0 STR_t STR_a STR_k STR_r "\0"
#define STRING_takri0 STR_t STR_a STR_k STR_r STR_i "\0"
#define STRING_tale0 STR_t STR_a STR_l STR_e "\0"
#define STRING_talu0 STR_t STR_a STR_l STR_u "\0"
#define STRING_tamil0 STR_t STR_a STR_m STR_i STR_l "\0"
#define STRING_taml0 STR_t STR_a STR_m STR_l "\0"
#define STRING_tang0 STR_t STR_a STR_n STR_g "\0"
#define STRING_tangsa0 STR_t STR_a STR_n STR_g STR_s STR_a "\0"
#define STRING_tangut0 STR_t STR_a STR_n STR_g STR_u STR_t "\0"
#define STRING_tavt0 STR_t STR_a STR_v STR_t "\0"
#define STRING_telu0 STR_t STR_e STR_l STR_u "\0"
#define STRING_telugu0 STR_t STR_e STR_l STR_u STR_g STR_u "\0"
#define STRING_term0 STR_t STR_e STR_r STR_m "\0"
#define STRING_terminalpunctuation0 STR_t STR_e STR_r STR_m STR_i STR_n STR_a STR_l STR_p STR_u STR_n STR_c STR_t STR_u STR_a STR_t STR_i STR_o STR_n "\0"
#define STRING_tfng0 STR_t STR_f STR_n STR_g "\0"
#define STRING_tglg0 STR_t STR_g STR_l STR_g "\0"
#define STRING_thaa0 STR_t STR_h STR_a STR_a "\0"
#define STRING_thaana0 STR_t STR_h STR_a STR_a STR_n STR_a "\0"
#define STRING_thai0 STR_t STR_h STR_a STR_i "\0"
#define STRING_tibetan0 STR_t STR_i STR_b STR_e STR_t STR_a STR_n "\0"
#define STRING_tibt0 STR_t STR_i STR_b STR_t "\0"
#define STRING_tifinagh0 STR_t STR_i STR_f STR_i STR_n STR_a STR_g STR_h "\0"
#define STRING_tirh0 STR_t STR_i STR_r STR_h "\0"
#define STRING_tirhuta0 STR_t STR_i STR_r STR_h STR_u STR_t STR_a "\0"
#define STRING_tnsa0 STR_t STR_n STR_s STR_a "\0"
#define STRING_todhri0 STR_t STR_o STR_d STR_h STR_r STR_i "\0"
#define STRING_todr0 STR_t STR_o STR_d STR_r "\0"
#define STRING_toto0 STR_t STR_o STR_t STR_o "\0"
#define STRING_tulutigalari0 STR_t STR_u STR_l STR_u STR_t STR_i STR_g STR_a STR_l STR_a STR_r STR_i "\0"
#define STRING_tutg0 STR_t STR_u STR_t STR_g "\0"
#define STRING_ugar0 STR_u STR_g STR_a STR_r "\0"
#define STRING_ugaritic0 STR_u STR_g STR_a STR_r STR_i STR_t STR_i STR_c "\0"
#define STRING_uideo0 STR_u STR_i STR_d STR_e STR_o "\0"
#define STRING_unifiedideograph0 STR_u STR_n STR_i STR_f STR_i STR_e STR_d STR_i STR_d STR_e STR_o STR_g STR_r STR_a STR_p STR_h "\0"
#define STRING_unknown0 STR_u STR_n STR_k STR_n STR_o STR_w STR_n "\0"
#define STRING_upper0 STR_u STR_p STR_p STR_e STR_r "\0"
#define STRING_uppercase0 STR_u STR_p STR_p STR_e STR_r STR_c STR_a STR_s STR_e "\0"
#define STRING_vai0 STR_v STR_a STR_i "\0"
#define STRING_vaii0 STR_v STR_a STR_i STR_i "\0"
#define STRING_variationselector0 STR_v STR_a STR_r STR_i STR_a STR_t STR_i STR_o STR_n STR_s STR_e STR_l STR_e STR_c STR_t STR_o STR_r "\0"
#define STRING_vith0 STR_v STR_i STR_t STR_h "\0"
#define STRING_vithkuqi0 STR_v STR_i STR_t STR_h STR_k STR_u STR_q STR_i "\0"
#define STRING_vs0 STR_v STR_s "\0"
#define STRING_wancho0 STR_w STR_a STR_n STR_c STR_h STR_o "\0"
#define STRING_wara0 STR_w STR_a STR_r STR_a "\0"
#define STRING_warangciti0 STR_w STR_a STR_r STR_a STR_n STR_g STR_c STR_i STR_t STR_i "\0"
#define STRING_wcho0 STR_w STR_c STR_h STR_o "\0"
#define STRING_whitespace0 STR_w STR_h STR_i STR_t STR_e STR_s STR_p STR_a STR_c STR_e "\0"
#define STRING_wspace0 STR_w STR_s STR_p STR_a STR_c STR_e "\0"
#define STRING_xan0 STR_x STR_a STR_n "\0"
#define STRING_xidc0 STR_x STR_i STR_d STR_c "\0"
#define STRING_xidcontinue0 STR_x STR_i STR_d STR_c STR_o STR_n STR_t STR_i STR_n STR_u STR_e "\0"
#define STRING_xids0 STR_x STR_i STR_d STR_s "\0"
#define STRING_xidstart0 STR_x STR_i STR_d STR_s STR_t STR_a STR_r STR_t "\0"
#define STRING_xpeo0 STR_x STR_p STR_e STR_o "\0"
#define STRING_xps0 STR_x STR_p STR_s "\0"
#define STRING_xsp0 STR_x STR_s STR_p "\0"
#define STRING_xsux0 STR_x STR_s STR_u STR_x "\0"
#define STRING_xuc0 STR_x STR_u STR_c "\0"
#define STRING_xwd0 STR_x STR_w STR_d "\0"
#define STRING_yezi0 STR_y STR_e STR_z STR_i "\0"
#define STRING_yezidi0 STR_y STR_e STR_z STR_i STR_d STR_i "\0"
#define STRING_yi0 STR_y STR_i "\0"
#define STRING_yiii0 STR_y STR_i STR_i STR_i "\0"
#define STRING_z0 STR_z "\0"
#define STRING_zanabazarsquare0 STR_z STR_a STR_n STR_a STR_b STR_a STR_z STR_a STR_r STR_s STR_q STR_u STR_a STR_r STR_e "\0"
#define STRING_zanb0 STR_z STR_a STR_n STR_b "\0"
#define STRING_zinh0 STR_z STR_i STR_n STR_h "\0"
#define STRING_zl0 STR_z STR_l "\0"
#define STRING_zp0 STR_z STR_p "\0"
#define STRING_zs0 STR_z STR_s "\0"
#define STRING_zyyy0 STR_z STR_y STR_y STR_y "\0"
#define STRING_zzzz0 STR_z STR_z STR_z STR_z "\0"

const char PRIV(utt_names)[] =
  STRING_adlam0
  STRING_adlm0
  STRING_aghb0
  STRING_ahex0
  STRING_ahom0
  STRING_alpha0
  STRING_alphabetic0
  STRING_anatolianhieroglyphs0
  STRING_any0
  STRING_arab0
  STRING_arabic0
  STRING_armenian0
  STRING_armi0
  STRING_armn0
  STRING_ascii0
  STRING_asciihexdigit0
  STRING_avestan0
  STRING_avst0
  STRING_bali0
  STRING_balinese0
  STRING_bamu0
  STRING_bamum0
  STRING_bass0
  STRING_bassavah0
  STRING_batak0
  STRING_batk0
  STRING_beng0
  STRING_bengali0
  STRING_bhaiksuki0
  STRING_bhks0
  STRING_bidial0
  STRING_bidian0
  STRING_bidib0
  STRING_bidibn0
  STRING_bidic0
  STRING_bidicontrol0
  STRING_bidics0
  STRING_bidien0
  STRING_bidies0
  STRING_bidiet0
  STRING_bidifsi0
  STRING_bidil0
  STRING_bidilre0
  STRING_bidilri0
  STRING_bidilro0
  STRING_bidim0
  STRING_bidimirrored0
  STRING_bidinsm0
  STRING_bidion0
  STRING_bidipdf0
  STRING_bidipdi0
  STRING_bidir0
  STRING_bidirle0
  STRING_bidirli0
  STRING_bidirlo0
  STRING_bidis0
  STRING_bidiws0
  STRING_bopo0
  STRING_bopomofo0
  STRING_brah0
  STRING_brahmi0
  STRING_brai0
  STRING_braille0
  STRING_bugi0
  STRING_buginese0
  STRING_buhd0
  STRING_buhid0
  STRING_c0
  STRING_cakm0
  STRING_canadianaboriginal0
  STRING_cans0
  STRING_cari0
  STRING_carian0
  STRING_cased0
  STRING_caseignorable0
  STRING_caucasianalbanian0
  STRING_cc0
  STRING_cf0
  STRING_chakma0
  STRING_cham0
  STRING_changeswhencasefolded0
  STRING_changeswhencasemapped0
  STRING_changeswhenlowercased0
  STRING_changeswhentitlecased0
  STRING_changeswhenuppercased0
  STRING_cher0
  STRING_cherokee0
  STRING_chorasmian0
  STRING_chrs0
  STRING_ci0
  STRING_cn0
  STRING_co0
  STRING_common0
  STRING_copt0
  STRING_coptic0
  STRING_cpmn0
  STRING_cprt0
  STRING_cs0
  STRING_cuneiform0
  STRING_cwcf0
  STRING_cwcm0
  STRING_cwl0
  STRING_cwt0
  STRING_cwu0
  STRING_cypriot0
  STRING_cyprominoan0
  STRING_cyrillic0
  STRING_cyrl0
  STRING_dash0
  STRING_defaultignorablecodepoint0
  STRING_dep0
  STRING_deprecated0
  STRING_deseret0
  STRING_deva0
  STRING_devanagari0
  STRING_di0
  STRING_dia0
  STRING_diacritic0
  STRING_diak0
  STRING_divesakuru0
  STRING_dogr0
  STRING_dogra0
  STRING_dsrt0
  STRING_dupl0
  STRING_duployan0
  STRING_ebase0
  STRING_ecomp0
  STRING_egyp0
  STRING_egyptianhieroglyphs0
  STRING_elba0
  STRING_elbasan0
  STRING_elym0
  STRING_elymaic0
  STRING_emod0
  STRING_emoji0
  STRING_emojicomponent0
  STRING_emojimodifier0
  STRING_emojimodifierbase0
  STRING_emojipresentation0
  STRING_epres0
  STRING_ethi0
  STRING_ethiopic0
  STRING_ext0
  STRING_extendedpictographic0
  STRING_extender0
  STRING_extpict0
  STRING_gara0
  STRING_garay0
  STRING_geor0
  STRING_georgian0
  STRING_glag0
  STRING_glagolitic0
  STRING_gong0
  STRING_gonm0
  STRING_goth0
  STRING_gothic0
  STRING_gran0
  STRING_grantha0
  STRING_graphemebase0
  STRING_graphemeextend0
  STRING_graphemelink0
  STRING_grbase0
  STRING_greek0
  STRING_grek0
  STRING_grext0
  STRING_grlink0
  STRING_gujarati0
  STRING_gujr0
  STRING_gukh0
  STRING_gunjalagondi0
  STRING_gurmukhi0
  STRING_guru0
  STRING_gurungkhema0
  STRING_han0
  STRING_hang0
  STRING_hangul0
  STRING_hani0
  STRING_hanifirohingya0
  STRING_hano0
  STRING_hanunoo0
  STRING_hatr0
  STRING_hatran0
  STRING_hebr0
  STRING_hebrew0
  STRING_hex0
  STRING_hexdigit0
  STRING_hira0
  STRING_hiragana0
  STRING_hluw0
  STRING_hmng0
  STRING_hmnp0
  STRING_hung0
  STRING_idc0
  STRING_idcompatmathcontinue0
  STRING_idcompatmathstart0
  STRING_idcontinue0
  STRING_ideo0
  STRING_ideographic0
  STRING_ids0
  STRING_idsb0
  STRING_idsbinaryoperator0
  STRING_idst0
  STRING_idstart0
  STRING_idstrinaryoperator0
  STRING_idsu0
  STRING_idsunaryoperator0
  STRING_imperialaramaic0
  STRING_incb0
  STRING_inherited0
  STRING_inscriptionalpahlavi0
  STRING_inscriptionalparthian0
  STRING_ital0
  STRING_java0
  STRING_javanese0
  STRING_joinc0
  STRING_joincontrol0
  STRING_kaithi0
  STRING_kali0
  STRING_kana0
  STRING_kannada0
  STRING_katakana0
  STRING_kawi0
  STRING_kayahli0
  STRING_khar0
  STRING_kharoshthi0
  STRING_khitansmallscript0
  STRING_khmer0
  STRING_khmr0
  STRING_khoj0
  STRING_khojki0
  STRING_khudawadi0
  STRING_kiratrai0
  STRING_kits0
  STRING_knda0
  STRING_krai0
  STRING_kthi0
  STRING_l0
  STRING_l_AMPERSAND0
  STRING_lana0
  STRING_lao0
  STRING_laoo0
  STRING_latin0
  STRING_latn0
  STRING_lc0
  STRING_lepc0
  STRING_lepcha0
  STRING_limb0
  STRING_limbu0
  STRING_lina0
  STRING_linb0
  STRING_lineara0
  STRING_linearb0
  STRING_lisu0
  STRING_ll0
  STRING_lm0
  STRING_lo0
  STRING_loe0
  STRING_logicalorderexception0
  STRING_lower0
  STRING_lowercase0
  STRING_lt0
  STRING_lu0
  STRING_lyci0
  STRING_lycian0
  STRING_lydi0
  STRING_lydian0
  STRING_m0
  STRING_mahajani0
  STRING_mahj0
  STRING_maka0
  STRING_makasar0
  STRING_malayalam0
  STRING_mand0
  STRING_mandaic0
  STRING_mani0
  STRING_manichaean0
  STRING_marc0
  STRING_marchen0
  STRING_masaramgondi0
  STRING_math0
  STRING_mc0
  STRING_mcm0
  STRING_me0
  STRING_medefaidrin0
  STRING_medf0
  STRING_meeteimayek0
  STRING_mend0
  STRING_mendekikakui0
  STRING_merc0
  STRING_mero0
  STRING_meroiticcursive0
  STRING_meroitichieroglyphs0
  STRING_miao0
  STRING_mlym0
  STRING_mn0
  STRING_modi0
  STRING_modifiercombiningmark0
  STRING_mong0
  STRING_mongolian0
  STRING_mro0
  STRING_mroo0
  STRING_mtei0
  STRING_mult0
  STRING_multani0
  STRING_myanmar0
  STRING_mymr0
  STRING_n0
  STRING_nabataean0
  STRING_nagm0
  STRING_nagmundari0
  STRING_nand0
  STRING_nandinagari0
  STRING_narb0
  STRING_nbat0
  STRING_nchar0
  STRING_nd0
  STRING_newa0
  STRING_newtailue0
  STRING_nko0
  STRING_nkoo0
  STRING_nl0
  STRING_no0
  STRING_noncharactercodepoint0
  STRING_nshu0
  STRING_nushu0
  STRING_nyiakengpuachuehmong0
  STRING_ogam0
  STRING_ogham0
  STRING_olchiki0
  STRING_olck0
  STRING_oldhungarian0
  STRING_olditalic0
  STRING_oldnortharabian0
  STRING_oldpermic0
  STRING_oldpersian0
  STRING_oldsogdian0
  STRING_oldsoutharabian0
  STRING_oldturkic0
  STRING_olduyghur0
  STRING_olonal0
  STRING_onao0
  STRING_oriya0
  STRING_orkh0
  STRING_orya0
  STRING_osage0
  STRING_osge0
  STRING_osma0
  STRING_osmanya0
  STRING_ougr0
  STRING_p0
  STRING_pahawhhmong0
  STRING_palm0
  STRING_palmyrene0
  STRING_patsyn0
  STRING_patternsyntax0
  STRING_patternwhitespace0
  STRING_patws0
  STRING_pauc0
  STRING_paucinhau0
  STRING_pc0
  STRING_pcm0
  STRING_pd0
  STRING_pe0
  STRING_perm0
  STRING_pf0
  STRING_phag0
  STRING_phagspa0
  STRING_phli0
  STRING_phlp0
  STRING_phnx0
  STRING_phoenician0
  STRING_pi0
  STRING_plrd0
  STRING_po0
  STRING_prependedconcatenationmark0
  STRING_prti0
  STRING_ps0
  STRING_psalterpahlavi0
  STRING_qaac0
  STRING_qaai0
  STRING_qmark0
  STRING_quotationmark0
  STRING_radical0
  STRING_regionalindicator0
  STRING_rejang0
  STRING_ri0
  STRING_rjng0
  STRING_rohg0
  STRING_runic0
  STRING_runr0
  STRING_s0
  STRING_samaritan0
  STRING_samr0
  STRING_sarb0
  STRING_saur0
  STRING_saurashtra0
  STRING_sc0
  STRING_sd0
  STRING_sentenceterminal0
  STRING_sgnw0
  STRING_sharada0
  STRING_shavian0
  STRING_shaw0
  STRING_shrd0
  STRING_sidd0
  STRING_siddham0
  STRING_signwriting0
  STRING_sind0
  STRING_sinh0
  STRING_sinhala0
  STRING_sk0
  STRING_sm0
  STRING_so0
  STRING_softdotted0
  STRING_sogd0
  STRING_sogdian0
  STRING_sogo0
  STRING_sora0
  STRING_sorasompeng0
  STRING_soyo0
  STRING_soyombo0
  STRING_space0
  STRING_sterm0
  STRING_sund0
  STRING_sundanese0
  STRING_sunu0
  STRING_sunuwar0
  STRING_sylo0
  STRING_sylotinagri0
  STRING_syrc0
  STRING_syriac0
  STRING_tagalog0
  STRING_tagb0
  STRING_tagbanwa0
  STRING_taile0
  STRING_taitham0
  STRING_taiviet0
  STRING_takr0
  STRING_takri0
  STRING_tale0
  STRING_talu0
  STRING_tamil0
  STRING_taml0
  STRING_tang0
  STRING_tangsa0
  STRING_tangut0
  STRING_tavt0
  STRING_telu0
  STRING_telugu0
  STRING_term0
  STRING_terminalpunctuation0
  STRING_tfng0
  STRING_tglg0
  STRING_thaa0
  STRING_thaana0
  STRING_thai0
  STRING_tibetan0
  STRING_tibt0
  STRING_tifinagh0
  STRING_tirh0
  STRING_tirhuta0
  STRING_tnsa0
  STRING_todhri0
  STRING_todr0
  STRING_toto0
  STRING_tulutigalari0
  STRING_tutg0
  STRING_ugar0
  STRING_ugaritic0
  STRING_uideo0
  STRING_unifiedideograph0
  STRING_unknown0
  STRING_upper0
  STRING_uppercase0
  STRING_vai0
  STRING_vaii0
  STRING_variationselector0
  STRING_vith0
  STRING_vithkuqi0
  STRING_vs0
  STRING_wancho0
  STRING_wara0
  STRING_warangciti0
  STRING_wcho0
  STRING_whitespace0
  STRING_wspace0
  STRING_xan0
  STRING_xidc0
  STRING_xidcontinue0
  STRING_xids0
  STRING_xidstart0
  STRING_xpeo0
  STRING_xps0
  STRING_xsp0
  STRING_xsux0
  STRING_xuc0
  STRING_xwd0
  STRING_yezi0
  STRING_yezidi0
  STRING_yi0
  STRING_yiii0
  STRING_z0
  STRING_zanabazarsquare0
  STRING_zanb0
  STRING_zinh0
  STRING_zl0
  STRING_zp0
  STRING_zs0
  STRING_zyyy0
  STRING_zzzz0;

const ucp_type_table PRIV(utt)[] = {
  {   0, PT_SCX, ucp_Adlam },
  {   6, PT_SCX, ucp_Adlam },
  {  11, PT_SCX, ucp_Caucasian_Albanian },
  {  16, PT_BOOL, ucp_ASCII_Hex_Digit },
  {  21, PT_SC, ucp_Ahom },
  {  26, PT_BOOL, ucp_Alphabetic },
  {  32, PT_BOOL, ucp_Alphabetic },
  {  43, PT_SC, ucp_Anatolian_Hieroglyphs },
  {  64, PT_ANY, 0 },
  {  68, PT_SCX, ucp_Arabic },
  {  73, PT_SCX, ucp_Arabic },
  {  80, PT_SCX, ucp_Armenian },
  {  89, PT_SC, ucp_Imperial_Aramaic },
  {  94, PT_SCX, ucp_Armenian },
  {  99, PT_BOOL, ucp_ASCII },
  { 105, PT_BOOL, ucp_ASCII_Hex_Digit },
  { 119, PT_SCX, ucp_Avestan },
  { 127, PT_SCX, ucp_Avestan },
  { 132, PT_SC, ucp_Balinese },
  { 137, PT_SC, ucp_Balinese },
  { 146, PT_SC, ucp_Bamum },
  { 151, PT_SC, ucp_Bamum },
  { 157, PT_SC, ucp_Bassa_Vah },
  { 162, PT_SC, ucp_Bassa_Vah },
  { 171, PT_SC, ucp_Batak },
  { 177, PT_SC, ucp_Batak },
  { 182, PT_SCX, ucp_Bengali },
  { 187, PT_SCX, ucp_Bengali },
  { 195, PT_SC, ucp_Bhaiksuki },
  { 205, PT_SC, ucp_Bhaiksuki },
  { 210, PT_BIDICL, ucp_bidiAL },
  { 217, PT_BIDICL, ucp_bidiAN },
  { 224, PT_BIDICL, ucp_bidiB },
  { 230, PT_BIDICL, ucp_bidiBN },
  { 237, PT_BOOL, ucp_Bidi_Control },
  { 243, PT_BOOL, ucp_Bidi_Control },
  { 255, PT_BIDICL, ucp_bidiCS },
  { 262, PT_BIDICL, ucp_bidiEN },
  { 269, PT_BIDICL, ucp_bidiES },
  { 276, PT_BIDICL, ucp_bidiET },
  { 283, PT_BIDICL, ucp_bidiFSI },
  { 291, PT_BIDICL, ucp_bidiL },
  { 297, PT_BIDICL, ucp_bidiLRE },
  { 305, PT_BIDICL, ucp_bidiLRI },
  { 313, PT_BIDICL, ucp_bidiLRO },
  { 321, PT_BOOL, ucp_Bidi_Mirrored },
  { 327, PT_BOOL, ucp_Bidi_Mirrored },
  { 340, PT_BIDICL, ucp_bidiNSM },
  { 348, PT_BIDICL, ucp_bidiON },
  { 355, PT_BIDICL, ucp_bidiPDF },
  { 363, PT_BIDICL, ucp_bidiPDI },
  { 371, PT_BIDICL, ucp_bidiR },
  { 377, PT_BIDICL, ucp_bidiRLE },
  { 385, PT_BIDICL, ucp_bidiRLI },
  { 393, PT_BIDICL, ucp_bidiRLO },
  { 401, PT_BIDICL, ucp_bidiS },
  { 407, PT_BIDICL, ucp_bidiWS },
  { 414, PT_SCX, ucp_Bopomofo },
  { 419, PT_SCX, ucp_Bopomofo },
  { 428, PT_SC, ucp_Brahmi },
  { 433, PT_SC, ucp_Brahmi },
  { 440, PT_SC, ucp_Braille },
  { 445, PT_SC, ucp_Braille },
  { 453, PT_SCX, ucp_Buginese },
  { 458, PT_SCX, ucp_Buginese },
  { 467, PT_SCX, ucp_Buhid },
  { 472, PT_SCX, ucp_Buhid },
  { 478, PT_GC, ucp_C },
  { 480, PT_SCX, ucp_Chakma },
  { 485, PT_SC, ucp_Canadian_Aboriginal },
  { 504, PT_SC, ucp_Canadian_Aboriginal },
  { 509, PT_SCX, ucp_Carian },
  { 514, PT_SCX, ucp_Carian },
  { 521, PT_BOOL, ucp_Cased },
  { 527, PT_BOOL, ucp_Case_Ignorable },
  { 541, PT_SCX, ucp_Caucasian_Albanian },
  { 559, PT_PC, ucp_Cc },
  { 562, PT_PC, ucp_Cf },
  { 565, PT_SCX, ucp_Chakma },
  { 572, PT_SC, ucp_Cham },
  { 577, PT_BOOL, ucp_Changes_When_Casefolded },
  { 599, PT_BOOL, ucp_Changes_When_Casemapped },
  { 621, PT_BOOL, ucp_Changes_When_Lowercased },
  { 643, PT_BOOL, ucp_Changes_When_Titlecased },
  { 665, PT_BOOL, ucp_Changes_When_Uppercased },
  { 687, PT_SCX, ucp_Cherokee },
  { 692, PT_SCX, ucp_Cherokee },
  { 701, PT_SC, ucp_Chorasmian },
  { 712, PT_SC, ucp_Chorasmian },
  { 717, PT_BOOL, ucp_Case_Ignorable },
  { 720, PT_PC, ucp_Cn },
  { 723, PT_PC, ucp_Co },
  { 726, PT_SC, ucp_Common },
  { 733, PT_SCX, ucp_Coptic },
  { 738, PT_SCX, ucp_Coptic },
  { 745, PT_SCX, ucp_Cypro_Minoan },
  { 750, PT_SCX, ucp_Cypriot },
  { 755, PT_PC, ucp_Cs },
  { 758, PT_SC, ucp_Cuneiform },
  { 768, PT_BOOL, ucp_Changes_When_Casefolded },
  { 773, PT_BOOL, ucp_Changes_When_Casemapped },
  { 778, PT_BOOL, ucp_Changes_When_Lowercased },
  { 782, PT_BOOL, ucp_Changes_When_Titlecased },
  { 786, PT_BOOL, ucp_Changes_When_Uppercased },
  { 790, PT_SCX, ucp_Cypriot },
  { 798, PT_SCX, ucp_Cypro_Minoan },
  { 810, PT_SCX, ucp_Cyrillic },
  { 819, PT_SCX, ucp_Cyrillic },
  { 824, PT_BOOL, ucp_Dash },
  { 829, PT_BOOL, ucp_Default_Ignorable_Code_Point },
  { 855, PT_BOOL, ucp_Deprecated },
  { 859, PT_BOOL, ucp_Deprecated },
  { 870, PT_SC, ucp_Deseret },
  { 878, PT_SCX, ucp_Devanagari },
  { 883, PT_SCX, ucp_Devanagari },
  { 894, PT_BOOL, ucp_Default_Ignorable_Code_Point },
  { 897, PT_BOOL, ucp_Diacritic },
  { 901, PT_BOOL, ucp_Diacritic },
  { 911, PT_SC, ucp_Dives_Akuru },
  { 916, PT_SC, ucp_Dives_Akuru },
  { 927, PT_SCX, ucp_Dogra },
  { 932, PT_SCX, ucp_Dogra },
  { 938, PT_SC, ucp_Deseret },
  { 943, PT_SCX, ucp_Duployan },
  { 948, PT_SCX, ucp_Duployan },
  { 957, PT_BOOL, ucp_Emoji_Modifier_Base },
  { 963, PT_BOOL, ucp_Emoji_Component },
  { 969, PT_SC, ucp_Egyptian_Hieroglyphs },
  { 974, PT_SC, ucp_Egyptian_Hieroglyphs },
  { 994, PT_SCX, ucp_Elbasan },
  { 999, PT_SCX, ucp_Elbasan },
  { 1007, PT_SC, ucp_Elymaic },
  { 1012, PT_SC, ucp_Elymaic },
  { 1020, PT_BOOL, ucp_Emoji_Modifier },
  { 1025, PT_BOOL, ucp_Emoji },
  { 1031, PT_BOOL, ucp_Emoji_Component },
  { 1046, PT_BOOL, ucp_Emoji_Modifier },
  { 1060, PT_BOOL, ucp_Emoji_Modifier_Base },
  { 1078, PT_BOOL, ucp_Emoji_Presentation },
  { 1096, PT_BOOL, ucp_Emoji_Presentation },
  { 1102, PT_SCX, ucp_Ethiopic },
  { 1107, PT_SCX, ucp_Ethiopic },
  { 1116, PT_BOOL, ucp_Extender },
  { 1120, PT_BOOL, ucp_Extended_Pictographic },
  { 1141, PT_BOOL, ucp_Extender },
  { 1150, PT_BOOL, ucp_Extended_Pictographic },
  { 1158, PT_SCX, ucp_Garay },
  { 1163, PT_SCX, ucp_Garay },
  { 1169, PT_SCX, ucp_Georgian },
  { 1174, PT_SCX, ucp_Georgian },
  { 1183, PT_SCX, ucp_Glagolitic },
  { 1188, PT_SCX, ucp_Glagolitic },
  { 1199, PT_SCX, ucp_Gunjala_Gondi },
  { 1204, PT_SCX, ucp_Masaram_Gondi },
  { 1209, PT_SCX, ucp_Gothic },
  { 1214, PT_SCX, ucp_Gothic },
  { 1221, PT_SCX, ucp_Grantha },
  { 1226, PT_SCX, ucp_Grantha },
  { 1234, PT_BOOL, ucp_Grapheme_Base },
  { 1247, PT_BOOL, ucp_Grapheme_Extend },
  { 1262, PT_BOOL, ucp_Grapheme_Link },
  { 1275, PT_BOOL, ucp_Grapheme_Base },
  { 1282, PT_SCX, ucp_Greek },
  { 1288, PT_SCX, ucp_Greek },
  { 1293, PT_BOOL, ucp_Grapheme_Extend },
  { 1299, PT_BOOL, ucp_Grapheme_Link },
  { 1306, PT_SCX, ucp_Gujarati },
  { 1315, PT_SCX, ucp_Gujarati },
  { 1320, PT_SCX, ucp_Gurung_Khema },
  { 1325, PT_SCX, ucp_Gunjala_Gondi },
  { 1338, PT_SCX, ucp_Gurmukhi },
  { 1347, PT_SCX, ucp_Gurmukhi },
  { 1352, PT_SCX, ucp_Gurung_Khema },
  { 1364, PT_SCX, ucp_Han },
  { 1368, PT_SCX, ucp_Hangul },
  { 1373, PT_SCX, ucp_Hangul },
  { 1380, PT_SCX, ucp_Han },
  { 1385, PT_SCX, ucp_Hanifi_Rohingya },
  { 1400, PT_SCX, ucp_Hanunoo },
  { 1405, PT_SCX, ucp_Hanunoo },
  { 1413, PT_SC, ucp_Hatran },
  { 1418, PT_SC, ucp_Hatran },
  { 1425, PT_SCX, ucp_Hebrew },
  { 1430, PT_SCX, ucp_Hebrew },
  { 1437, PT_BOOL, ucp_Hex_Digit },
  { 1441, PT_BOOL, ucp_Hex_Digit },
  { 1450, PT_SCX, ucp_Hiragana },
  { 1455, PT_SCX, ucp_Hiragana },
  { 1464, PT_SC, ucp_Anatolian_Hieroglyphs },
  { 1469, PT_SC, ucp_Pahawh_Hmong },
  { 1474, PT_SC, ucp_Nyiakeng_Puachue_Hmong },
  { 1479, PT_SCX, ucp_Old_Hungarian },
  { 1484, PT_BOOL, ucp_ID_Continue },
  { 1488, PT_BOOL, ucp_ID_Compat_Math_Continue },
  { 1509, PT_BOOL, ucp_ID_Compat_Math_Start },
  { 1527, PT_BOOL, ucp_ID_Continue },
  { 1538, PT_BOOL, ucp_Ideographic },
  { 1543, PT_BOOL, ucp_Ideographic },
  { 1555, PT_BOOL, ucp_ID_Start },
  { 1559, PT_BOOL, ucp_IDS_Binary_Operator },
  { 1564, PT_BOOL, ucp_IDS_Binary_Operator },
  { 1582, PT_BOOL, ucp_IDS_Trinary_Operator },
  { 1587, PT_BOOL, ucp_ID_Start },
  { 1595, PT_BOOL, ucp_IDS_Trinary_Operator },
  { 1614, PT_BOOL, ucp_IDS_Unary_Operator },
  { 1619, PT_BOOL, ucp_IDS_Unary_Operator },
  { 1636, PT_SC, ucp_Imperial_Aramaic },
  { 1652, PT_BOOL, ucp_InCB },
  { 1657, PT_SC, ucp_Inherited },
  { 1667, PT_SC, ucp_Inscriptional_Pahlavi },
  { 1688, PT_SC, ucp_Inscriptional_Parthian },
  { 1710, PT_SC, ucp_Old_Italic },
  { 1715, PT_SCX, ucp_Javanese },
  { 1720, PT_SCX, ucp_Javanese },
  { 1729, PT_BOOL, ucp_Join_Control },
  { 1735, PT_BOOL, ucp_Join_Control },
  { 1747, PT_SCX, ucp_Kaithi },
  { 1754, PT_SCX, ucp_Kayah_Li },
  { 1759, PT_SCX, ucp_Katakana },
  { 1764, PT_SCX, ucp_Kannada },
  { 1772, PT_SCX, ucp_Katakana },
  { 1781, PT_SC, ucp_Kawi },
  { 1786, PT_SCX, ucp_Kayah_Li },
  { 1794, PT_SC, ucp_Kharoshthi },
  { 1799, PT_SC, ucp_Kharoshthi },
  { 1810, PT_SC, ucp_Khitan_Small_Script },
  { 1828, PT_SC, ucp_Khmer },
  { 1834, PT_SC, ucp_Khmer },
  { 1839, PT_SCX, ucp_Khojki },
  { 1844, PT_SCX, ucp_Khojki },
  { 1851, PT_SCX, ucp_Khudawadi },
  { 1861, PT_SC, ucp_Kirat_Rai },
  { 1870, PT_SC, ucp_Khitan_Small_Script },
  { 1875, PT_SCX, ucp_Kannada },
  { 1880, PT_SC, ucp_Kirat_Rai },
  { 1885, PT_SCX, ucp_Kaithi },
  { 1890, PT_GC, ucp_L },
  { 1892, PT_LAMP, 0 },
  { 1895, PT_SC, ucp_Tai_Tham },
  { 1900, PT_SC, ucp_Lao },
  { 1904, PT_SC, ucp_Lao },
  { 1909, PT_SCX, ucp_Latin },
  { 1915, PT_SCX, ucp_Latin },
  { 1920, PT_LAMP, 0 },
  { 1923, PT_SC, ucp_Lepcha },
  { 1928, PT_SC, ucp_Lepcha },
  { 1935, PT_SCX, ucp_Limbu },
  { 1940, PT_SCX, ucp_Limbu },
  { 1946, PT_SCX, ucp_Linear_A },
  { 1951, PT_SCX, ucp_Linear_B },
  { 1956, PT_SCX, ucp_Linear_A },
  { 1964, PT_SCX, ucp_Linear_B },
  { 1972, PT_SCX, ucp_Lisu },
  { 1977, PT_PC, ucp_Ll },
  { 1980, PT_PC, ucp_Lm },
  { 1983, PT_PC, ucp_Lo },
  { 1986, PT_BOOL, ucp_Logical_Order_Exception },
  { 1990, PT_BOOL, ucp_Logical_Order_Exception },
  { 2012, PT_BOOL, ucp_Lowercase },
  { 2018, PT_BOOL, ucp_Lowercase },
  { 2028, PT_PC, ucp_Lt },
  { 2031, PT_PC, ucp_Lu },
  { 2034, PT_SCX, ucp_Lycian },
  { 2039, PT_SCX, ucp_Lycian },
  { 2046, PT_SCX, ucp_Lydian },
  { 2051, PT_SCX, ucp_Lydian },
  { 2058, PT_GC, ucp_M },
  { 2060, PT_SCX, ucp_Mahajani },
  { 2069, PT_SCX, ucp_Mahajani },
  { 2074, PT_SC, ucp_Makasar },
  { 2079, PT_SC, ucp_Makasar },
  { 2087, PT_SCX, ucp_Malayalam },
  { 2097, PT_SCX, ucp_Mandaic },
  { 2102, PT_SCX, ucp_Mandaic },
  { 2110, PT_SCX, ucp_Manichaean },
  { 2115, PT_SCX, ucp_Manichaean },
  { 2126, PT_SC, ucp_Marchen },
  { 2131, PT_SC, ucp_Marchen },
  { 2139, PT_SCX, ucp_Masaram_Gondi },
  { 2152, PT_BOOL, ucp_Math },
  { 2157, PT_PC, ucp_Mc },
  { 2160, PT_BOOL, ucp_Modifier_Combining_Mark },
  { 2164, PT_PC, ucp_Me },
  { 2167, PT_SC, ucp_Medefaidrin },
  { 2179, PT_SC, ucp_Medefaidrin },
  { 2184, PT_SC, ucp_Meetei_Mayek },
  { 2196, PT_SC, ucp_Mende_Kikakui },
  { 2201, PT_SC, ucp_Mende_Kikakui },
  { 2214, PT_SC, ucp_Meroitic_Cursive },
  { 2219, PT_SCX, ucp_Meroitic_Hieroglyphs },
  { 2224, PT_SC, ucp_Meroitic_Cursive },
  { 2240, PT_SCX, ucp_Meroitic_Hieroglyphs },
  { 2260, PT_SC, ucp_Miao },
  { 2265, PT_SCX, ucp_Malayalam },
  { 2270, PT_PC, ucp_Mn },
  { 2273, PT_SCX, ucp_Modi },
  { 2278, PT_BOOL, ucp_Modifier_Combining_Mark },
  { 2300, PT_SCX, ucp_Mongolian },
  { 2305, PT_SCX, ucp_Mongolian },
  { 2315, PT_SC, ucp_Mro },
  { 2319, PT_SC, ucp_Mro },
  { 2324, PT_SC, ucp_Meetei_Mayek },
  { 2329, PT_SCX, ucp_Multani },
  { 2334, PT_SCX, ucp_Multani },
  { 2342, PT_SCX, ucp_Myanmar },
  { 2350, PT_SCX, ucp_Myanmar },
  { 2355, PT_GC, ucp_N },
  { 2357, PT_SC, ucp_Nabataean },
  { 2367, PT_SC, ucp_Nag_Mundari },
  { 2372, PT_SC, ucp_Nag_Mundari },
  { 2383, PT_SCX, ucp_Nandinagari },
  { 2388, PT_SCX, ucp_Nandinagari },
  { 2400, PT_SC, ucp_Old_North_Arabian },
  { 2405, PT_SC, ucp_Nabataean },
  { 2410, PT_BOOL, ucp_Noncharacter_Code_Point },
  { 2416, PT_PC, ucp_Nd },
  { 2419, PT_SC, ucp_Newa },
  { 2424, PT_SC, ucp_New_Tai_Lue },
  { 2434, PT_SCX, ucp_Nko },
  { 2438, PT_SCX, ucp_Nko },
  { 2443, PT_PC, ucp_Nl },
  { 2446, PT_PC, ucp_No },
  { 2449, PT_BOOL, ucp_Noncharacter_Code_Point },
  { 2471, PT_SC, ucp_Nushu },
  { 2476, PT_SC, ucp_Nushu },
  { 2482, PT_SC, ucp_Nyiakeng_Puachue_Hmong },
  { 2503, PT_SC, ucp_Ogham },
  { 2508, PT_SC, ucp_Ogham },
  { 2514, PT_SC, ucp_Ol_Chiki },
  { 2522, PT_SC, ucp_Ol_Chiki },
  { 2527, PT_SCX, ucp_Old_Hungarian },
  { 2540, PT_SC, ucp_Old_Italic },
  { 2550, PT_SC, ucp_Old_North_Arabian },
  { 2566, PT_SCX, ucp_Old_Permic },
  { 2576, PT_SC, ucp_Old_Persian },
  { 2587, PT_SC, ucp_Old_Sogdian },
  { 2598, PT_SC, ucp_Old_South_Arabian },
  { 2614, PT_SCX, ucp_Old_Turkic },
  { 2624, PT_SCX, ucp_Old_Uyghur },
  { 2634, PT_SCX, ucp_Ol_Onal },
  { 2641, PT_SCX, ucp_Ol_Onal },
  { 2646, PT_SCX, ucp_Oriya },
  { 2652, PT_SCX, ucp_Old_Turkic },
  { 2657, PT_SCX, ucp_Oriya },
  { 2662, PT_SCX, ucp_Osage },
  { 2668, PT_SCX, ucp_Osage },
  { 2673, PT_SC, ucp_Osmanya },
  { 2678, PT_SC, ucp_Osmanya },
  { 2686, PT_SCX, ucp_Old_Uyghur },
  { 2691, PT_GC, ucp_P },
  { 2693, PT_SC, ucp_Pahawh_Hmong },
  { 2705, PT_SC, ucp_Palmyrene },
  { 2710, PT_SC, ucp_Palmyrene },
  { 2720, PT_BOOL, ucp_Pattern_Syntax },
  { 2727, PT_BOOL, ucp_Pattern_Syntax },
  { 2741, PT_BOOL, ucp_Pattern_White_Space },
  { 2759, PT_BOOL, ucp_Pattern_White_Space },
  { 2765, PT_SC, ucp_Pau_Cin_Hau },
  { 2770, PT_SC, ucp_Pau_Cin_Hau },
  { 2780, PT_PC, ucp_Pc },
  { 2783, PT_BOOL, ucp_Prepended_Concatenation_Mark },
  { 2787, PT_PC, ucp_Pd },
  { 2790, PT_PC, ucp_Pe },
  { 2793, PT_SCX, ucp_Old_Permic },
  { 2798, PT_PC, ucp_Pf },
  { 2801, PT_SCX, ucp_Phags_Pa },
  { 2806, PT_SCX, ucp_Phags_Pa },
  { 2814, PT_SC, ucp_Inscriptional_Pahlavi },
  { 2819, PT_SCX, ucp_Psalter_Pahlavi },
  { 2824, PT_SC, ucp_Phoenician },
  { 2829, PT_SC, ucp_Phoenician },
  { 2840, PT_PC, ucp_Pi },
  { 2843, PT_SC, ucp_Miao },
  { 2848, PT_PC, ucp_Po },
  { 2851, PT_BOOL, ucp_Prepended_Concatenation_Mark },
  { 2878, PT_SC, ucp_Inscriptional_Parthian },
  { 2883, PT_PC, ucp_Ps },
  { 2886, PT_SCX, ucp_Psalter_Pahlavi },
  { 2901, PT_SCX, ucp_Coptic },
  { 2906, PT_SC, ucp_Inherited },
  { 2911, PT_BOOL, ucp_Quotation_Mark },
  { 2917, PT_BOOL, ucp_Quotation_Mark },
  { 2931, PT_BOOL, ucp_Radical },
  { 2939, PT_BOOL, ucp_Regional_Indicator },
  { 2957, PT_SC, ucp_Rejang },
  { 2964, PT_BOOL, ucp_Regional_Indicator },
  { 2967, PT_SC, ucp_Rejang },
  { 2972, PT_SCX, ucp_Hanifi_Rohingya },
  { 2977, PT_SCX, ucp_Runic },
  { 2983, PT_SCX, ucp_Runic },
  { 2988, PT_GC, ucp_S },
  { 2990, PT_SCX, ucp_Samaritan },
  { 3000, PT_SCX, ucp_Samaritan },
  { 3005, PT_SC, ucp_Old_South_Arabian },
  { 3010, PT_SC, ucp_Saurashtra },
  { 3015, PT_SC, ucp_Saurashtra },
  { 3026, PT_PC, ucp_Sc },
  { 3029, PT_BOOL, ucp_Soft_Dotted },
  { 3032, PT_BOOL, ucp_Sentence_Terminal },
  { 3049, PT_SC, ucp_SignWriting },
  { 3054, PT_SCX, ucp_Sharada },
  { 3062, PT_SCX, ucp_Shavian },
  { 3070, PT_SCX, ucp_Shavian },
  { 3075, PT_SCX, ucp_Sharada },
  { 3080, PT_SC, ucp_Siddham },
  { 3085, PT_SC, ucp_Siddham },
  { 3093, PT_SC, ucp_SignWriting },
  { 3105, PT_SCX, ucp_Khudawadi },
  { 3110, PT_SCX, ucp_Sinhala },
  { 3115, PT_SCX, ucp_Sinhala },
  { 3123, PT_PC, ucp_Sk },
  { 3126, PT_PC, ucp_Sm },
  { 3129, PT_PC, ucp_So },
  { 3132, PT_BOOL, ucp_Soft_Dotted },
  { 3143, PT_SCX, ucp_Sogdian },
  { 3148, PT_SCX, ucp_Sogdian },
  { 3156, PT_SC, ucp_Old_Sogdian },
  { 3161, PT_SC, ucp_Sora_Sompeng },
  { 3166, PT_SC, ucp_Sora_Sompeng },
  { 3178, PT_SC, ucp_Soyombo },
  { 3183, PT_SC, ucp_Soyombo },
  { 3191, PT_BOOL, ucp_White_Space },
  { 3197, PT_BOOL, ucp_Sentence_Terminal },
  { 3203, PT_SC, ucp_Sundanese },
  { 3208, PT_SC, ucp_Sundanese },
  { 3218, PT_SCX, ucp_Sunuwar },
  { 3223, PT_SCX, ucp_Sunuwar },
  { 3231, PT_SCX, ucp_Syloti_Nagri },
  { 3236, PT_SCX, ucp_Syloti_Nagri },
  { 3248, PT_SCX, ucp_Syriac },
  { 3253, PT_SCX, ucp_Syriac },
  { 3260, PT_SCX, ucp_Tagalog },
  { 3268, PT_SCX, ucp_Tagbanwa },
  { 3273, PT_SCX, ucp_Tagbanwa },
  { 3282, PT_SCX, ucp_Tai_Le },
  { 3288, PT_SC, ucp_Tai_Tham },
  { 3296, PT_SC, ucp_Tai_Viet },
  { 3304, PT_SCX, ucp_Takri },
  { 3309, PT_SCX, ucp_Takri },
  { 3315, PT_SCX, ucp_Tai_Le },
  { 3320, PT_SC, ucp_New_Tai_Lue },
  { 3325, PT_SCX, ucp_Tamil },
  { 3331, PT_SCX, ucp_Tamil },
  { 3336, PT_SCX, ucp_Tangut },
  { 3341, PT_SC, ucp_Tangsa },
  { 3348, PT_SCX, ucp_Tangut },
  { 3355, PT_SC, ucp_Tai_Viet },
  { 3360, PT_SCX, ucp_Telugu },
  { 3365, PT_SCX, ucp_Telugu },
  { 3372, PT_BOOL, ucp_Terminal_Punctuation },
  { 3377, PT_BOOL, ucp_Terminal_Punctuation },
  { 3397, PT_SCX, ucp_Tifinagh },
  { 3402, PT_SCX, ucp_Tagalog },
  { 3407, PT_SCX, ucp_Thaana },
  { 3412, PT_SCX, ucp_Thaana },
  { 3419, PT_SCX, ucp_Thai },
  { 3424, PT_SCX, ucp_Tibetan },
  { 3432, PT_SCX, ucp_Tibetan },
  { 3437, PT_SCX, ucp_Tifinagh },
  { 3446, PT_SCX, ucp_Tirhuta },
  { 3451, PT_SCX, ucp_Tirhuta },
  { 3459, PT_SC, ucp_Tangsa },
  { 3464, PT_SCX, ucp_Todhri },
  { 3471, PT_SCX, ucp_Todhri },
  { 3476, PT_SCX, ucp_Toto },
  { 3481, PT_SCX, ucp_Tulu_Tigalari },
  { 3494, PT_SCX, ucp_Tulu_Tigalari },
  { 3499, PT_SC, ucp_Ugaritic },
  { 3504, PT_SC, ucp_Ugaritic },
  { 3513, PT_BOOL, ucp_Unified_Ideograph },
  { 3519, PT_BOOL, ucp_Unified_Ideograph },
  { 3536, PT_SC, ucp_Unknown },
  { 3544, PT_BOOL, ucp_Uppercase },
  { 3550, PT_BOOL, ucp_Uppercase },
  { 3560, PT_SC, ucp_Vai },
  { 3564, PT_SC, ucp_Vai },
  { 3569, PT_BOOL, ucp_Variation_Selector },
  { 3587, PT_SC, ucp_Vithkuqi },
  { 3592, PT_SC, ucp_Vithkuqi },
  { 3601, PT_BOOL, ucp_Variation_Selector },
  { 3604, PT_SC, ucp_Wancho },
  { 3611, PT_SC, ucp_Warang_Citi },
  { 3616, PT_SC, ucp_Warang_Citi },
  { 3627, PT_SC, ucp_Wancho },
  { 3632, PT_BOOL, ucp_White_Space },
  { 3643, PT_BOOL, ucp_White_Space },
  { 3650, PT_ALNUM, 0 },
  { 3654, PT_BOOL, ucp_XID_Continue },
  { 3659, PT_BOOL, ucp_XID_Continue },
  { 3671, PT_BOOL, ucp_XID_Start },
  { 3676, PT_BOOL, ucp_XID_Start },
  { 3685, PT_SC, ucp_Old_Persian },
  { 3690, PT_PXSPACE, 0 },
  { 3694, PT_SPACE, 0 },
  { 3698, PT_SC, ucp_Cuneiform },
  { 3703, PT_UCNC, 0 },
  { 3707, PT_WORD, 0 },
  { 3711, PT_SCX, ucp_Yezidi },
  { 3716, PT_SCX, ucp_Yezidi },
  { 3723, PT_SCX, ucp_Yi },
  { 3726, PT_SCX, ucp_Yi },
  { 3731, PT_GC, ucp_Z },
  { 3733, PT_SC, ucp_Zanabazar_Square },
  { 3749, PT_SC, ucp_Zanabazar_Square },
  { 3754, PT_SC, ucp_Inherited },
  { 3759, PT_PC, ucp_Zl },
  { 3762, PT_PC, ucp_Zp },
  { 3765, PT_PC, ucp_Zs },
  { 3768, PT_SC, ucp_Common },
  { 3773, PT_SC, ucp_Unknown }
};

const size_t PRIV(utt_size) = sizeof(PRIV(utt)) / sizeof(ucp_type_table);

#endif /* SUPPORT_UNICODE */

/* End of pcre2_ucptables.c */


================================================
FILE: Libraries/PCRE/pcre2_util.h
================================================
/*************************************************
*      Perl-Compatible Regular Expressions       *
*************************************************/

/* PCRE2 is a library of functions to support regular expressions whose syntax
and semantics are as close as possible to those of the Perl 5 language.

                       Written by Philip Hazel
     Original API code Copyright (c) 1997-2012 University of Cambridge
          New API code Copyright (c) 2016-2024 University of Cambridge

-----------------------------------------------------------------------------
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

    * Redistributions of source code must retain the above copyright notice,
      this list of conditions and the following disclaimer.

    * Redistributions in binary form must reproduce the above copyright
      notice, this list of conditions and the following disclaimer in the
      documentation and/or other materials provided with the distribution.

    * Neither the name of the University of Cambridge nor the names of its
      contributors may be used to endorse or promote products derived from
      this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
-----------------------------------------------------------------------------
*/

#ifndef PCRE2_UTIL_H_IDEMPOTENT_GUARD
#define PCRE2_UTIL_H_IDEMPOTENT_GUARD

/* Assertion macros */

#ifdef PCRE2_DEBUG

#if defined(HAVE_ASSERT_H) && !defined(NDEBUG)
#include <assert.h>
#endif

/* PCRE2_ASSERT(x) can be used to inject an assert() for conditions
that the code below doesn't support. It is a NOP for non debug builds
but in debug builds will print information about the location of the
code where it triggered and crash.

It is meant to work like assert(), and therefore the expression used
should indicate what the expected state is, and shouldn't have any
side-effects. */

#if defined(HAVE_ASSERT_H) && !defined(NDEBUG)
#define PCRE2_ASSERT(x) assert(x)
#else
#define PCRE2_ASSERT(x) do                                            \
{                                                                     \
  if (!(x))                                                           \
  {                                                                   \
  fprintf(stderr, "Assertion failed at " __FILE__ ":%d\n", __LINE__); \
  abort();                                                            \
  }                                                                   \
} while(0)
#endif

/* PCRE2_UNREACHABLE() can be used to mark locations on the code that
shouldn't be reached. In non debug builds is defined as a hint for
the compiler to eliminate any code after it, so it is useful also for
performance reasons, but should be used with care because if it is
ever reached will trigger Undefined Behaviour and if you are lucky a
crash. In debug builds it will report the location where it was triggered
and crash. One important point to consider when using this macro, is
that it is only implemented for a few compilers, and therefore can't
be relied on to always be active either, so if it is followed by some
code it is important to make sure that the whole thing is safe to
use even if the macro is not there (ex: make sure there is a `break`
after it if used at the end of a `case`) and to test your code also
with a configuration where the macro will be a NOP. */

#if defined(HAVE_ASSERT_H) && !defined(NDEBUG)
#define PCRE2_UNREACHABLE()                                         \
assert(((void)"Execution reached unexpected point", 0))
#else
#define PCRE2_UNREACHABLE() do                                      \
{                                                                   \
fprintf(stderr, "Execution reached unexpected point at " __FILE__   \
                ":%d\n", __LINE__);                                 \
abort();                                                            \
} while(0)
#endif

/* PCRE2_DEBUG_UNREACHABLE() is a debug only version of the previous
macro. It is meant to be used in places where the code is handling
an error situation in code that shouldn't be reached, but that has
some sort of fallback code to normally handle the error. When in
doubt you should use this instead of the previous macro. Like in
the previous case, it is a good idea to document as much as possible
the reason and the actions that should be taken if it ever triggers. */

#define PCRE2_DEBUG_UNREACHABLE() PCRE2_UNREACHABLE()

#endif /* PCRE2_DEBUG */

#ifndef PCRE2_DEBUG_UNREACHABLE
#define PCRE2_DEBUG_UNREACHABLE() do {} while(0)
#endif

#ifndef PCRE2_UNREACHABLE
#ifdef HAVE_BUILTIN_UNREACHABLE
#define PCRE2_UNREACHABLE() __builtin_unreachable()
#elif defined(HAVE_BUILTIN_ASSUME)
#define PCRE2_UNREACHABLE() __assume(0)
#else
#define PCRE2_UNREACHABLE() do {} while(0)
#endif
#endif /* !PCRE2_UNREACHABLE */

#ifndef PCRE2_ASSERT
#define PCRE2_ASSERT(x) do {} while(0)
#endif

#endif /* PCRE2_UTIL_H_IDEMPOTENT_GUARD */

/* End of pcre2_util.h */


================================================
FILE: Libraries/PCRE/pcre2_valid_utf.c
================================================
/*************************************************
*      Perl-Compatible Regular Expressions       *
*************************************************/

/* PCRE is a library of functions to support regular expressions whose syntax
and semantics are as close as possible to those of the Perl 5 language.

                       Written by Philip Hazel
     Original API code Copyright (c) 1997-2012 University of Cambridge
          New API code Copyright (c) 2016-2020 University of Cambridge

-----------------------------------------------------------------------------
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

    * Redistributions of source code must retain the above copyright notice,
      this list of conditions and the following disclaimer.

    * Redistributions in binary form must reproduce the above copyright
      notice, this list of conditions and the following disclaimer in the
      documentation and/or other materials provided with the distribution.

    * Neither the name of the University of Cambridge nor the names of its
      contributors may be used to endorse or promote products derived from
      this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
-----------------------------------------------------------------------------
*/


/* This module contains an internal function for validating UTF character
strings. This file is also #included by the pcre2test program, which uses
macros to change names from _pcre2_xxx to xxxx, thereby avoiding name clashes
with the library. In this case, PCRE2_PCRE2TEST is defined. */

#ifndef PCRE2_PCRE2TEST           /* We're compiling the library */
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "pcre2_internal.h"
#endif /* PCRE2_PCRE2TEST */


#ifndef SUPPORT_UNICODE
/*************************************************
*  Dummy function when Unicode is not supported  *
*************************************************/

/* This function should never be called when Unicode is not supported. */

int
PRIV(valid_utf)(PCRE2_SPTR string, PCRE2_SIZE length, PCRE2_SIZE *erroroffset)
{
(void)string;
(void)length;
(void)erroroffset;
return 0;
}
#else  /* UTF is supported */



/*************************************************
*           Validate a UTF string                *
*************************************************/

/* This function is called (optionally) at the start of compile or match, to
check that a supposed UTF string is actually valid. The early check means
that subsequent code can assume it is dealing with a valid string. The check
can be turned off for maximum performance, but the consequences of supplying an
invalid string are then undefined.

Arguments:
  string       points to the string
  length       length of string
  errp         pointer to an error position offset variable

Returns:       == 0    if the string is a valid UTF string
               != 0    otherwise, setting the offset of the bad character
*/

int
PRIV(valid_utf)(PCRE2_SPTR string, PCRE2_SIZE length, PCRE2_SIZE *erroroffset)
{
PCRE2_SPTR p;
uint32_t c;

/* ----------------- Check a UTF-8 string ----------------- */

#if PCRE2_CODE_UNIT_WIDTH == 8

/* Originally, this function checked according to RFC 2279, allowing for values
in the range 0 to 0x7fffffff, up to 6 bytes long, but ensuring that they were
in the canonical format. Once somebody had pointed out RFC 3629 to me (it
obsoletes 2279), additional restrictions were applied. The values are now
limited to be between 0 and 0x0010ffff, no more than 4 bytes long, and the
subrange 0xd000 to 0xdfff is excluded. However, the format of 5-byte and 6-byte
characters is still checked. Error returns are as follows:

PCRE2_ERROR_UTF8_ERR1   Missing 1 byte at the end of the string
PCRE2_ERROR_UTF8_ERR2   Missing 2 bytes at the end of the string
PCRE2_ERROR_UTF8_ERR3   Missing 3 bytes at the end of the string
PCRE2_ERROR_UTF8_ERR4   Missing 4 bytes at the end of the string
PCRE2_ERROR_UTF8_ERR5   Missing 5 bytes at the end of the string
PCRE2_ERROR_UTF8_ERR6   2nd-byte's two top bits are not 0x80
PCRE2_ERROR_UTF8_ERR7   3rd-byte's two top bits are not 0x80
PCRE2_ERROR_UTF8_ERR8   4th-byte's two top bits are not 0x80
PCRE2_ERROR_UTF8_ERR9   5th-byte's two top bits are not 0x80
PCRE2_ERROR_UTF8_ERR10  6th-byte's two top bits are not 0x80
PCRE2_ERROR_UTF8_ERR11  5-byte character is not permitted by RFC 3629
PCRE2_ERROR_UTF8_ERR12  6-byte character is not permitted by RFC 3629
PCRE2_ERROR_UTF8_ERR13  4-byte character with value > 0x10ffff is not permitted
PCRE2_ERROR_UTF8_ERR14  3-byte character with value 0xd800-0xdfff is not permitted
PCRE2_ERROR_UTF8_ERR15  Overlong 2-byte sequence
PCRE2_ERROR_UTF8_ERR16  Overlong 3-byte sequence
PCRE2_ERROR_UTF8_ERR17  Overlong 4-byte sequence
PCRE2_ERROR_UTF8_ERR18  Overlong 5-byte sequence (won't ever occur)
PCRE2_ERROR_UTF8_ERR19  Overlong 6-byte sequence (won't ever occur)
PCRE2_ERROR_UTF8_ERR20  Isolated 0x80 byte (not within UTF-8 character)
PCRE2_ERROR_UTF8_ERR21  Byte with the illegal value 0xfe or 0xff
*/

for (p = string; length > 0; p++)
  {
  uint32_t ab, d;

  c = *p;
  length--;

  if (c < 128) continue;                /* ASCII character */

  if (c < 0xc0)                         /* Isolated 10xx xxxx byte */
    {
    *erroroffset = (PCRE2_SIZE)(p - string);
    return PCRE2_ERROR_UTF8_ERR20;
    }

  if (c >= 0xfe)                        /* Invalid 0xfe or 0xff bytes */
    {
    *erroroffset = (PCRE2_SIZE)(p - string);
    return PCRE2_ERROR_UTF8_ERR21;
    }

  ab = PRIV(utf8_table4)[c & 0x3f];     /* Number of additional bytes (1-5) */
  if (length < ab)                      /* Missing bytes */
    {
    *erroroffset = (PCRE2_SIZE)(p - string);
    switch(ab - length)
      {
      case 1: return PCRE2_ERROR_UTF8_ERR1;
      case 2: return PCRE2_ERROR_UTF8_ERR2;
      case 3: return PCRE2_ERROR_UTF8_ERR3;
      case 4: return PCRE2_ERROR_UTF8_ERR4;
      case 5: return PCRE2_ERROR_UTF8_ERR5;
      }
    }
  length -= ab;                         /* Length remaining */

  /* Check top bits in the second byte */

  if (((d = *(++p)) & 0xc0) != 0x80)
    {
    *erroroffset = (PCRE2_SIZE)(p - string) - 1;
    return PCRE2_ERROR_UTF8_ERR6;
    }

  /* For each length, check that the remaining bytes start with the 0x80 bit
  set and not the 0x40 bit. Then check for an overlong sequence, and for the
  excluded range 0xd800 to 0xdfff. */

  switch (ab)
    {
    /* 2-byte character. No further bytes to check for 0x80. Check first byte
    for for xx00 000x (overlong sequence). */

    case 1: if ((c & 0x3e) == 0)
      {
      *erroroffset = (PCRE2_SIZE)(p - string) - 1;
      return PCRE2_ERROR_UTF8_ERR15;
      }
    break;

    /* 3-byte character. Check third byte for 0x80. Then check first 2 bytes
      for 1110 0000, xx0x xxxx (overlong sequence) or
          1110 1101, 1010 xxxx (0xd800 - 0xdfff) */

    case 2:
    if ((*(++p) & 0xc0) != 0x80)     /* Third byte */
      {
      *erroroffset = (PCRE2_SIZE)(p - string) - 2;
      return PCRE2_ERROR_UTF8_ERR7;
      }
    if (c == 0xe0 && (d & 0x20) == 0)
      {
      *erroroffset = (PCRE2_SIZE)(p - string) - 2;
      return PCRE2_ERROR_UTF8_ERR16;
      }
    if (c == 0xed && d >= 0xa0)
      {
      *erroroffset = (PCRE2_SIZE)(p - string) - 2;
      return PCRE2_ERROR_UTF8_ERR14;
      }
    break;

    /* 4-byte character. Check 3rd and 4th bytes for 0x80. Then check first 2
       bytes for for 1111 0000, xx00 xxxx (overlong sequence), then check for a
       character greater than 0x0010ffff (f4 8f bf bf) */

    case 3:
    if ((*(++p) & 0xc0) != 0x80)     /* Third byte */
      {
      *erroroffset = (PCRE2_SIZE)(p - string) - 2;
      return PCRE2_ERROR_UTF8_ERR7;
      }
    if ((*(++p) & 0xc0) != 0x80)     /* Fourth byte */
      {
      *erroroffset = (PCRE2_SIZE)(p - string) - 3;
      return PCRE2_ERROR_UTF8_ERR8;
      }
    if (c == 0xf0 && (d & 0x30) == 0)
      {
      *erroroffset = (PCRE2_SIZE)(p - string) - 3;
      return PCRE2_ERROR_UTF8_ERR17;
      }
    if (c > 0xf4 || (c == 0xf4 && d > 0x8f))
      {
      *erroroffset = (PCRE2_SIZE)(p - string) - 3;
      return PCRE2_ERROR_UTF8_ERR13;
      }
    break;

    /* 5-byte and 6-byte characters are not allowed by RFC 3629, and will be
    rejected by the length test below. However, we do the appropriate tests
    here so that overlong sequences get diagnosed, and also in case there is
    ever an option for handling these larger code points. */

    /* 5-byte character. Check 3rd, 4th, and 5th bytes for 0x80. Then check for
    1111 1000, xx00 0xxx */

    case 4:
    if ((*(++p) & 0xc0) != 0x80)     /* Third byte */
      {
      *erroroffset = (PCRE2_SIZE)(p - string) - 2;
      return PCRE2_ERROR_UTF8_ERR7;
      }
    if ((*(++p) & 0xc0) != 0x80)     /* Fourth byte */
      {
      *erroroffset = (PCRE2_SIZE)(p - string) - 3;
      return PCRE2_ERROR_UTF8_ERR8;
      }
    if ((*(++p) & 0xc0) != 0x80)     /* Fifth byte */
      {
      *erroroffset = (PCRE2_SIZE)(p - string) - 4;
      return PCRE2_ERROR_UTF8_ERR9;
      }
    if (c == 0xf8 && (d & 0x38) == 0)
      {
      *erroroffset = (PCRE2_SIZE)(p - string) - 4;
      return PCRE2_ERROR_UTF8_ERR18;
      }
    break;

    /* 6-byte character. Check 3rd-6th bytes for 0x80. Then check for
    1111 1100, xx00 00xx. */

    case 5:
    if ((*(++p) & 0xc0) != 0x80)     /* Third byte */
      {
      *erroroffset = (PCRE2_SIZE)(p - string) - 2;
      return PCRE2_ERROR_UTF8_ERR7;
      }
    if ((*(++p) & 0xc0) != 0x80)     /* Fourth byte */
      {
      *erroroffset = (PCRE2_SIZE)(p - string) - 3;
      return PCRE2_ERROR_UTF8_ERR8;
      }
    if ((*(++p) & 0xc0) != 0x80)     /* Fifth byte */
      {
      *erroroffset = (PCRE2_SIZE)(p - string) - 4;
      return PCRE2_ERROR_UTF8_ERR9;
      }
    if ((*(++p) & 0xc0) != 0x80)     /* Sixth byte */
      {
      *erroroffset = (PCRE2_SIZE)(p - string) - 5;
      return PCRE2_ERROR_UTF8_ERR10;
      }
    if (c == 0xfc && (d & 0x3c) == 0)
      {
      *erroroffset = (PCRE2_SIZE)(p - string) - 5;
      return PCRE2_ERROR_UTF8_ERR19;
      }
    break;
    }

  /* Character is valid under RFC 2279, but 4-byte and 5-byte characters are
  excluded by RFC 3629. The pointer p is currently at the last byte of the
  character. */

  if (ab > 3)
    {
    *erroroffset = (PCRE2_SIZE)(p - string) - ab;
    return (ab == 4)? PCRE2_ERROR_UTF8_ERR11 : PCRE2_ERROR_UTF8_ERR12;
    }
  }
return 0;


/* ----------------- Check a UTF-16 string ----------------- */

#elif PCRE2_CODE_UNIT_WIDTH == 16

/* There's not so much work, nor so many errors, for UTF-16.
PCRE2_ERROR_UTF16_ERR1  Missing low surrogate at the end of the string
PCRE2_ERROR_UTF16_ERR2  Invalid low surrogate
PCRE2_ERROR_UTF16_ERR3  Isolated low surrogate
*/

for (p = string; length > 0; p++)
  {
  c = *p;
  length--;

  if ((c & 0xf800) != 0xd800)
    {
    /* Normal UTF-16 code point. Neither high nor low surrogate. */
    }
  else if ((c & 0x0400) == 0)
    {
    /* High surrogate. Must be a followed by a low surrogate. */
    if (length == 0)
      {
      *erroroffset = (PCRE2_SIZE)(p - string);
      return PCRE2_ERROR_UTF16_ERR1;
      }
    p++;
    length--;
    if ((*p & 0xfc00) != 0xdc00)
      {
      *erroroffset = (PCRE2_SIZE)(p - string) - 1;
      return PCRE2_ERROR_UTF16_ERR2;
      }
    }
  else
    {
    /* Isolated low surrogate. Always an error. */
    *erroroffset = (PCRE2_SIZE)(p - string);
    return PCRE2_ERROR_UTF16_ERR3;
    }
  }
return 0;



/* ----------------- Check a UTF-32 string ----------------- */

#else

/* There is very little to do for a UTF-32 string.
PCRE2_ERROR_UTF32_ERR1  Surrogate character
PCRE2_ERROR_UTF32_ERR2  Character > 0x10ffff
*/

for (p = string; length > 0; length--, p++)
  {
  c = *p;
  if ((c & 0xfffff800u) != 0xd800u)
    {
    /* Normal UTF-32 code point. Neither high nor low surrogate. */
    if (c > 0x10ffffu)
      {
      *erroroffset = (PCRE2_SIZE)(p - string);
      return PCRE2_ERROR_UTF32_ERR2;
      }
    }
  else
    {
    /* A surrogate */
    *erroroffset = (PCRE2_SIZE)(p - string);
    return PCRE2_ERROR_UTF32_ERR1;
    }
  }
return 0;
#endif  /* CODE_UNIT_WIDTH */
}
#endif  /* SUPPORT_UNICODE */

/* End of pcre2_valid_utf.c */


================================================
FILE: Libraries/PCRE/pcre2_xclass.c
================================================
/*************************************************
*      Perl-Compatible Regular Expressions       *
*************************************************/

/* PCRE is a library of functions to support regular expressions whose syntax
and semantics are as close as possible to those of the Perl 5 language.

                       Written by Philip Hazel
     Original API code Copyright (c) 1997-2012 University of Cambridge
          New API code Copyright (c) 2016-2024 University of Cambridge

-----------------------------------------------------------------------------
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

    * Redistributions of source code must retain the above copyright notice,
      this list of conditions and the following disclaimer.

    * Redistributions in binary form must reproduce the above copyright
      notice, this list of conditions and the following disclaimer in the
      documentation and/or other materials provided with the distribution.

    * Neither the name of the University of Cambridge nor the names of its
      contributors may be used to endorse or promote products derived from
      this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
-----------------------------------------------------------------------------
*/

/* This module contains two internal functions that are used to match
OP_XCLASS and OP_ECLASS. It is used by pcre2_auto_possessify() and by both
pcre2_match() and pcre2_dfa_match(). */


#ifdef HAVE_CONFIG_H
#include "config.h"
#endif


#include "pcre2_internal.h"

/*************************************************
*       Match character against an XCLASS        *
*************************************************/

/* This function is called to match a character against an extended class that
might contain codepoints above 255 and/or Unicode properties.

Arguments:
  c           the character
  data        points to the flag code unit of the XCLASS data
  utf         TRUE if in UTF mode

Returns:      TRUE if character matches, else FALSE
*/

BOOL
PRIV(xclass)(uint32_t c, PCRE2_SPTR data, const uint8_t *char_lists_end, BOOL utf)
{
/* Update PRIV(update_classbits) when this function is changed. */
PCRE2_UCHAR t;
BOOL not_negated = (*data & XCL_NOT) == 0;
uint32_t type, max_index, min_index, value;
const uint8_t *next_char;

#if PCRE2_CODE_UNIT_WIDTH == 8
/* In 8 bit mode, this must always be TRUE. Help the compiler to know that. */
utf = TRUE;
#endif

/* Code points < 256 are matched against a bitmap, if one is present. */

if ((*data++ & XCL_MAP) != 0)
  {
  if (c < 256)
    return (((const uint8_t *)data)[c/8] & (1u << (c&7))) != 0;
  /* Skip bitmap. */
  data += 32 / sizeof(PCRE2_UCHAR);
  }

/* Match against the list of Unicode properties. We won't ever
encounter XCL_PROP or XCL_NOTPROP when UTF support is not compiled. */
#ifdef SUPPORT_UNICODE
if (*data == XCL_PROP || *data == XCL_NOTPROP)
  {
  /* The UCD record is the same for all properties. */
  const ucd_record *prop = GET_UCD(c);

  do
    {
    int chartype;
    BOOL isprop = (*data++) == XCL_PROP;
    BOOL ok;

    switch(*data)
      {
      case PT_LAMP:
      chartype = prop->chartype;
      if ((chartype == ucp_Lu || chartype == ucp_Ll ||
           chartype == ucp_Lt) == isprop) return not_negated;
      break;

      case PT_GC:
      if ((data[1] == PRIV(ucp_gentype)[prop->chartype]) == isprop)
        return not_negated;
      break;

      case PT_PC:
      if ((data[1] == prop->chartype) == isprop) return not_negated;
      break;

      case PT_SC:
      if ((data[1] == prop->script) == isprop) return not_negated;
      break;

      case PT_SCX:
      ok = (data[1] == prop->script ||
            MAPBIT(PRIV(ucd_script_sets) + UCD_SCRIPTX_PROP(prop), data[1]) != 0);
      if (ok == isprop) return not_negated;
      break;

      case PT_ALNUM:
      chartype = prop->chartype;
      if ((PRIV(ucp_gentype)[chartype] == ucp_L ||
           PRIV(ucp_gentype)[chartype] == ucp_N) == isprop)
        return not_negated;
      break;

      /* Perl space used to exclude VT, but from Perl 5.18 it is included,
      which means that Perl space and POSIX space are now identical. PCRE
      was changed at release 8.34. */

      case PT_SPACE:    /* Perl space */
      case PT_PXSPACE:  /* POSIX space */
      switch(c)
        {
        HSPACE_CASES:
        VSPACE_CASES:
        if (isprop) return not_negated;
        break;

        default:
        if ((PRIV(ucp_gentype)[prop->chartype] == ucp_Z) == isprop)
          return not_negated;
        break;
        }
      break;

      case PT_WORD:
      chartype = prop->chartype;
      if ((PRIV(ucp_gentype)[chartype] == ucp_L ||
           PRIV(ucp_gentype)[chartype] == ucp_N ||
           chartype == ucp_Mn || chartype == ucp_Pc) == isprop)
        return not_negated;
      break;

      case PT_UCNC:
      if (c < 0xa0)
        {
        if ((c == CHAR_DOLLAR_SIGN || c == CHAR_COMMERCIAL_AT ||
             c == CHAR_GRAVE_ACCENT) == isprop)
          return not_negated;
        }
      else
        {
        if ((c < 0xd800 || c > 0xdfff) == isprop)
          return not_negated;
        }
      break;

      case PT_BIDICL:
      if ((UCD_BIDICLASS_PROP(prop) == data[1]) == isprop)
        return not_negated;
      break;

      case PT_BOOL:
      ok = MAPBIT(PRIV(ucd_boolprop_sets) +
        UCD_BPROPS_PROP(prop), data[1]) != 0;
      if (ok == isprop) return not_negated;
      break;

      /* The following three properties can occur only in an XCLASS, as there
      is no \p or \P coding for them. */

      /* Graphic character. Implement this as not Z (space or separator) and
      not C (other), except for Cf (format) with a few exceptions. This seems
      to be what Perl does. The exceptional characters are:

      U+061C           Arabic Letter Mark
      U+180E           Mongolian Vowel Separator
      U+2066 - U+2069  Various "isolate"s
      */

      case PT_PXGRAPH:
      chartype = prop->chartype;
      if ((PRIV(ucp_gentype)[chartype] != ucp_Z &&
            (PRIV(ucp_gentype)[chartype] != ucp_C ||
              (chartype == ucp_Cf &&
                c != 0x061c && c != 0x180e && (c < 0x2066 || c > 0x2069))
         )) == isprop)
        return not_negated;
      break;

      /* Printable character: same as graphic, with the addition of Zs, i.e.
      not Zl and not Zp, and U+180E. */

      case PT_PXPRINT:
      chartype = prop->chartype;
      if ((chartype != ucp_Zl &&
           chartype != ucp_Zp &&
            (PRIV(ucp_gentype)[chartype] != ucp_C ||
              (chartype == ucp_Cf &&
                c != 0x061c && (c < 0x2066 || c > 0x2069))
         )) == isprop)
        return not_negated;
      break;

      /* Punctuation: all Unicode punctuation, plus ASCII characters that
      Unicode treats as symbols rather than punctuation, for Perl
      compatibility (these are $+<=>^`|~). */

      case PT_PXPUNCT:
      chartype = prop->chartype;
      if ((PRIV(ucp_gentype)[chartype] == ucp_P ||
            (c < 128 && PRIV(ucp_gentype)[chartype] == ucp_S)) == isprop)
        return not_negated;
      break;

      /* Perl has two sets of hex digits */

      case PT_PXXDIGIT:
      if (((c >= CHAR_0 && c <= CHAR_9) ||
           (c >= CHAR_A && c <= CHAR_F) ||
           (c >= CHAR_a && c <= CHAR_f) ||
           (c >= 0xff10 && c <= 0xff19) ||  /* Fullwidth digits */
           (c >= 0xff21 && c <= 0xff26) ||  /* Fullwidth letters */
           (c >= 0xff41 && c <= 0xff46)) == isprop)
        return not_negated;
      break;

      /* This should never occur, but compilers may mutter if there is no
      default. */

      default:
      PCRE2_DEBUG_UNREACHABLE();
      return FALSE;
      }

    data += 2;
    }
  while (*data == XCL_PROP || *data == XCL_NOTPROP);
  }
#else
  (void)utf;  /* Avoid compiler warning */
#endif  /* SUPPORT_UNICODE */

/* Match against large chars or ranges that end with a large char. */
if (*data < XCL_LIST)
  {
  while ((t = *data++) != XCL_END)
    {
    uint32_t x, y;

#ifdef SUPPORT_UNICODE
    if (utf)
      {
      GETCHARINC(x, data); /* macro generates multiple statements */
      }
    else
#endif
      x = *data++;

    if (t == XCL_SINGLE)
      {
      /* Since character ranges follow the properties, and they are
      sorted, early return is possible for all characters <= x. */
      if (c <= x) return (c == x) ? not_negated : !not_negated;
      continue;
      }

    PCRE2_ASSERT(t == XCL_RANGE);
#ifdef SUPPORT_UNICODE
    if (utf)
      {
      GETCHARINC(y, data); /* macro generates multiple statements */
      }
    else
#endif
      y = *data++;

    /* Since character ranges follow the properties, and they are
    sorted, early return is possible for all characters <= y. */
    if (c <= y) return (c >= x) ? not_negated : !not_negated;
    }

  return !not_negated;   /* char did not match */
  }

#if PCRE2_CODE_UNIT_WIDTH == 8
type = (uint32_t)(data[0] << 8) | data[1];
data += 2;
#else
type = data[0];
data++;
#endif  /* CODE_UNIT_WIDTH */

/* Align characters. */
next_char = char_lists_end - (GET(data, 0) << 1);
type &= XCL_TYPE_MASK;

/* Alignment check. */
PCRE2_ASSERT(((uintptr_t)next_char & 0x1) == 0);

if (c >= XCL_CHAR_LIST_HIGH_16_START)
  {
  max_index = type & XCL_ITEM_COUNT_MASK;
  if (max_index == XCL_ITEM_COUNT_MASK)
    {
    max_index = *(const uint16_t*)next_char;
    PCRE2_ASSERT(max_index >= XCL_ITEM_COUNT_MASK);
    next_char += 2;
    }

  next_char += max_index << 1;
  type >>= XCL_TYPE_BIT_LEN;
  }

if (c < XCL_CHAR_LIST_LOW_32_START)
  {
  max_index = type & XCL_ITEM_COUNT_MASK;

  c = (uint16_t)((c << XCL_CHAR_SHIFT) | XCL_CHAR_END);

  if (max_index == XCL_ITEM_COUNT_MASK)
    {
    max_index = *(const uint16_t*)next_char;
    PCRE2_ASSERT(max_index >= XCL_ITEM_COUNT_MASK);
    next_char += 2;
    }

  if (max_index == 0 || c < *(const uint16_t*)next_char)
    return ((type & XCL_BEGIN_WITH_RANGE) != 0) == not_negated;

  min_index = 0;
  value = ((const uint16_t*)next_char)[--max_index];
  if (c >= value)
    return (value == c || (value & XCL_CHAR_END) == 0) == not_negated;

  max_index--;

  /* Binary search of a range. */
  while (TRUE)
    {
    uint32_t mid_index = (min_index + max_index) >> 1;
    value = ((const uint16_t*)next_char)[mid_index];

    if (c < value)
      max_index = mid_index - 1;
    else if (((const uint16_t*)next_char)[mid_index + 1] <= c)
      min_index = mid_index + 1;
    else
      return (value == c || (value & XCL_CHAR_END) == 0) == not_negated;
    }
  }

/* Skip the 16 bit ranges. */
max_index = type & XCL_ITEM_COUNT_MASK;
if (max_index == XCL_ITEM_COUNT_MASK)
  {
  max_index = *(const uint16_t*)next_char;
  PCRE2_ASSERT(max_index >= XCL_ITEM_COUNT_MASK);
  next_char += 2;
  }

next_char += (max_index << 1);
type >>= XCL_TYPE_BIT_LEN;

/* Alignment check. */
PCRE2_ASSERT(((uintptr_t)next_char & 0x3) == 0);

max_index = type & XCL_ITEM_COUNT_MASK;

#if PCRE2_CODE_UNIT_WIDTH == 32
if (c >= XCL_CHAR_LIST_HIGH_32_START)
  {
  if (max_index == XCL_ITEM_COUNT_MASK)
    {
    max_index = *(const uint32_t*)next_char;
    PCRE2_ASSERT(max_index >= XCL_ITEM_COUNT_MASK);
    next_char += 4;
    }

  next_char += max_index << 2;
  type >>= XCL_TYPE_BIT_LEN;
  max_index = type & XCL_ITEM_COUNT_MASK;
  }
#endif

c = (uint32_t)((c << XCL_CHAR_SHIFT) | XCL_CHAR_END);

if (max_index == XCL_ITEM_COUNT_MASK)
  {
  max_index = *(const uint32_t*)next_char;
  next_char += 4;
  }

if (max_index == 0 || c < *(const uint32_t*)next_char)
  return ((type & XCL_BEGIN_WITH_RANGE) != 0) == not_negated;

min_index = 0;
value = ((const uint32_t*)next_char)[--max_index];
if (c >= value)
  return (value == c || (value & XCL_CHAR_END) == 0) == not_negated;

max_index--;

/* Binary search of a range. */
while (TRUE)
  {
  uint32_t mid_index = (min_index + max_index) >> 1;
  value = ((const uint32_t*)next_char)[mid_index];

  if (c < value)
    max_index = mid_index - 1;
  else if (((const uint32_t*)next_char)[mid_index + 1] <= c)
    min_index = mid_index + 1;
  else
    return (value == c || (value & XCL_CHAR_END) == 0) == not_negated;
  }
}



/*************************************************
*       Match character against an ECLASS        *
*************************************************/

/* This function is called to match a character against an extended class
used for describing characters using boolean operations on sets.

Arguments:
  c           the character
  data_start  points to the start of the ECLASS data
  data_end    points one-past-the-last of the ECLASS data
  utf         TRUE if in UTF mode

Returns:      TRUE if character matches, else FALSE
*/

BOOL
PRIV(eclass)(uint32_t c, PCRE2_SPTR data_start, PCRE2_SPTR data_end,
  const uint8_t *char_lists_end, BOOL utf)
{
PCRE2_SPTR ptr = data_start;
PCRE2_UCHAR flags;
uint32_t stack = 0;
int stack_depth = 0;

PCRE2_ASSERT(data_start < data_end);
flags = *ptr++;
PCRE2_ASSERT((flags & ECL_MAP) == 0 ||
             (data_end - ptr) >= 32 / (int)sizeof(PCRE2_UCHAR));

/* Code points < 256 are matched against a bitmap, if one is present.
Otherwise all codepoints are checked later. */

if ((flags & ECL_MAP) != 0)
  {
  if (c < 256)
    return (((const uint8_t *)ptr)[c/8] & (1u << (c&7))) != 0;

  /* Skip the bitmap. */
  ptr += 32 / sizeof(PCRE2_UCHAR);
  }

/* Do a little loop, until we reach the end of the ECLASS. */
while (ptr < data_end)
  {
  switch (*ptr)
    {
    case ECL_AND:
    ++ptr;
    stack = (stack >> 1) & (stack | ~(uint32_t)1u);
    PCRE2_ASSERT(stack_depth >= 2);
    --stack_depth;
    break;

    case ECL_OR:
    ++ptr;
    stack = (stack >> 1) | (stack & (uint32_t)1u);
    PCRE2_ASSERT(stack_depth >= 2);
    --stack_depth;
    break;

    case ECL_XOR:
    ++ptr;
    stack = (stack >> 1) ^ (stack & (uint32_t)1u);
    PCRE2_ASSERT(stack_depth >= 2);
    --stack_depth;
    break;

    case ECL_NOT:
    ++ptr;
    stack ^= (uint32_t)1u;
    PCRE2_ASSERT(stack_depth >= 1);
    break;

    case ECL_XCLASS:
      {
      uint32_t matched = PRIV(xclass)(c, ptr + 1 + LINK_SIZE, char_lists_end, utf);

      ptr += GET(ptr, 1);
      stack = (stack << 1) | matched;
      ++stack_depth;
      break;
      }

    /* This should never occur, but compilers may mutter if there is no
    default. */

    default:
    PCRE2_DEBUG_UNREACHABLE();
    return FALSE;
    }
  }

PCRE2_ASSERT(stack_depth == 1);
(void)stack_depth;  /* Ignore unused variable, if assertions are disabled. */

/* The final bit left on the stack now holds the match result. */
return (stack & 1u) != 0;
}

/* End of pcre2_xclass.c */


================================================
FILE: Libraries/scintilla/.editorconfig
================================================
root = true

[**]
indent_style = tab


================================================
FILE: Libraries/scintilla/include/ILexer.h
================================================
// Scintilla source code edit control
/** @file ILexer.h
 ** Interface between Scintilla and lexers.
 **/
// Copyright 1998-2010 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#ifndef ILEXER_H
#define ILEXER_H

#include "Sci_Position.h"

namespace Scintilla {

enum { dvRelease4=2 };

class IDocument {
public:
	virtual int SCI_METHOD Version() const = 0;
	virtual void SCI_METHOD SetErrorStatus(int status) = 0;
	virtual Sci_Position SCI_METHOD Length() const = 0;
	virtual void SCI_METHOD GetCharRange(char *buffer, Sci_Position position, Sci_Position lengthRetrieve) const = 0;
	virtual char SCI_METHOD StyleAt(Sci_Position position) const = 0;
	virtual Sci_Position SCI_METHOD LineFromPosition(Sci_Position position) const = 0;
	virtual Sci_Position SCI_METHOD LineStart(Sci_Position line) const = 0;
	virtual int SCI_METHOD GetLevel(Sci_Position line) const = 0;
	virtual int SCI_METHOD SetLevel(Sci_Position line, int level) = 0;
	virtual int SCI_METHOD GetLineState(Sci_Position line) const = 0;
	virtual int SCI_METHOD SetLineState(Sci_Position line, int state) = 0;
	virtual void SCI_METHOD StartStyling(Sci_Position position) = 0;
	virtual bool SCI_METHOD SetStyleFor(Sci_Position length, char style) = 0;
	virtual bool SCI_METHOD SetStyles(Sci_Position length, const char *styles) = 0;
	virtual void SCI_METHOD DecorationSetCurrentIndicator(int indicator) = 0;
	virtual void SCI_METHOD DecorationFillRange(Sci_Position position, int value, Sci_Position fillLength) = 0;
	virtual void SCI_METHOD ChangeLexerState(Sci_Position start, Sci_Position end) = 0;
	virtual int SCI_METHOD CodePage() const = 0;
	virtual bool SCI_METHOD IsDBCSLeadByte(char ch) const = 0;
	virtual const char * SCI_METHOD BufferPointer() = 0;
	virtual int SCI_METHOD GetLineIndentation(Sci_Position line) = 0;
	virtual Sci_Position SCI_METHOD LineEnd(Sci_Position line) const = 0;
	virtual Sci_Position SCI_METHOD GetRelativePosition(Sci_Position positionStart, Sci_Position characterOffset) const = 0;
	virtual int SCI_METHOD GetCharacterAndWidth(Sci_Position position, Sci_Position *pWidth) const = 0;
};

enum { lvRelease4=2, lvRelease5=3 };

class ILexer4 {
public:
	virtual int SCI_METHOD Version() const = 0;
	virtual void SCI_METHOD Release() = 0;
	virtual const char * SCI_METHOD PropertyNames() = 0;
	virtual int SCI_METHOD PropertyType(const char *name) = 0;
	virtual const char * SCI_METHOD DescribeProperty(const char *name) = 0;
	virtual Sci_Position SCI_METHOD PropertySet(const char *key, const char *val) = 0;
	virtual const char * SCI_METHOD DescribeWordListSets() = 0;
	virtual Sci_Position SCI_METHOD WordListSet(int n, const char *wl) = 0;
	virtual void SCI_METHOD Lex(Sci_PositionU startPos, Sci_Position lengthDoc, int initStyle, IDocument *pAccess) = 0;
	virtual void SCI_METHOD Fold(Sci_PositionU startPos, Sci_Position lengthDoc, int initStyle, IDocument *pAccess) = 0;
	virtual void * SCI_METHOD PrivateCall(int operation, void *pointer) = 0;
	virtual int SCI_METHOD LineEndTypesSupported() = 0;
	virtual int SCI_METHOD AllocateSubStyles(int styleBase, int numberStyles) = 0;
	virtual int SCI_METHOD SubStylesStart(int styleBase) = 0;
	virtual int SCI_METHOD SubStylesLength(int styleBase) = 0;
	virtual int SCI_METHOD StyleFromSubStyle(int subStyle) = 0;
	virtual int SCI_METHOD PrimaryStyleFromStyle(int style) = 0;
	virtual void SCI_METHOD FreeSubStyles() = 0;
	virtual void SCI_METHOD SetIdentifiers(int style, const char *identifiers) = 0;
	virtual int SCI_METHOD DistanceToSecondaryStyles() = 0;
	virtual const char * SCI_METHOD GetSubStyleBases() = 0;
	virtual int SCI_METHOD NamedStyles() = 0;
	virtual const char * SCI_METHOD NameOfStyle(int style) = 0;
	virtual const char * SCI_METHOD TagsOfStyle(int style) = 0;
	virtual const char * SCI_METHOD DescriptionOfStyle(int style) = 0;
};

class ILexer5 : public ILexer4 {
public:
	virtual const char * SCI_METHOD GetName() = 0;
	virtual int SCI_METHOD  GetIdentifier() = 0;
	virtual const char * SCI_METHOD PropertyGet(const char *key) = 0;
};

}

#endif


================================================
FILE: Libraries/scintilla/include/ILoader.h
================================================
// Scintilla source code edit control
/** @file ILoader.h
 ** Interface for loading into a Scintilla document from a background thread.
 ** Interface for manipulating a document without a view.
 **/
// Copyright 1998-2017 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#ifndef ILOADER_H
#define ILOADER_H

#include "Sci_Position.h"

namespace Scintilla {

class ILoader {
public:
	virtual int SCI_METHOD Release() = 0;
	// Returns a status code from SC_STATUS_*
	virtual int SCI_METHOD AddData(const char *data, Sci_Position length) = 0;
	virtual void * SCI_METHOD ConvertToDocument() = 0;
};

static constexpr int deRelease0 = 0;

class IDocumentEditable {
public:
	// Allow this interface to add methods over time and discover whether new methods available.
	virtual int SCI_METHOD DEVersion() const noexcept = 0;

	// Lifetime control
	virtual int SCI_METHOD AddRef() noexcept = 0;
	virtual int SCI_METHOD Release() = 0;
};

}

#endif


================================================
FILE: Libraries/scintilla/include/Sci_Position.h
================================================
// Scintilla source code edit control
/** @file Sci_Position.h
 ** Define the Sci_Position type used in Scintilla's external interfaces.
 ** These need to be available to clients written in C so are not in a C++ namespace.
 **/
// Copyright 2015 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#ifndef SCI_POSITION_H
#define SCI_POSITION_H

#include <stddef.h>

// Basic signed type used throughout interface
typedef ptrdiff_t Sci_Position;

// Unsigned variant used for ILexer::Lex and ILexer::Fold
typedef size_t Sci_PositionU;

// For Sci_CharacterRange  which is defined as long to be compatible with Win32 CHARRANGE
typedef long Sci_PositionCR;

#ifdef _WIN32
	#define SCI_METHOD __stdcall
#else
	#define SCI_METHOD
#endif

#endif


================================================
FILE: Libraries/scintilla/include/Scintilla.iface
================================================
## First line may be used for shbang

## This file defines the interface to Scintilla

## Copyright 2000-2003 by Neil Hodgson <neilh@scintilla.org>
## The License.txt file describes the conditions under which this software may be distributed.

## A line starting with ## is a pure comment and should be stripped by readers.
## A line starting with #! is for future shbang use
## A line starting with # followed by a space is a documentation comment and refers
## to the next feature definition.

## Each feature is defined by a line starting with fun, get, set, val, evt, enu, lex, or ali.
##     cat -> start a category
##     fun -> a function
##     get -> a property get function
##     set -> a property set function
##     val -> definition of a constant
##     evt -> an event
##     enu -> associate an enumeration with a set of vals with a prefix
##     lex -> associate a lexer with the lexical classes it produces
##     ali -> add an alias for a val, commonly adding '_' to separate words
##
## All other feature names should be ignored. They may be defined in the future.
## A property may have a set function, a get function or both. Each will have
## "Get" or "Set" in their names and the corresponding name will have the obvious switch.
## A property may be subscripted, in which case the first parameter is the subscript.
## fun, get, and set features have a strict syntax:
## <featureType><ws><returnType><ws><name>[=<number](<param>,<param>)
## where <ws> stands for white space.
## param may be empty (null value) or is <paramType><ws><paramName>[=<value>]
## Additional white space is allowed between elements.
## The syntax for evt is <featureType><ws><returnType><ws><name>[=<number]([<param>[,<param>]*])
## Feature names that contain an underscore are defined by Windows, so in these
## cases, using the Windows definition is preferred where available.
## The feature numbers are stable so features will not be renumbered.
## Features may be removed but they will go through a period of deprecation
## before removal which is signalled by moving them into the Deprecated category.
##
## enu has the syntax enu<ws><enumeration>=<prefix>[<ws><prefix>]* where all the val
## features in this file starting with a given <prefix> are considered part of the
## enumeration.
##
## lex has the syntax lex<ws><name>=<lexerVal><ws><prefix>[<ws><prefix>]*
## where name is a reasonably capitalised (Python, XML) identifier or UI name,
## lexerVal is the val used to specify the lexer, and the list of prefixes is similar
## to enu. The name may not be the same as that used within the lexer so the lexerVal
## should be used to tie these entities together.

## Types: Never start with a capital letter
##     void
##     int
##     bool -> integer, 1=true, 0=false
##     position -> intptr_t position in a document
##     line -> intptr_t line in a document
##     colour -> colour integer containing red, green, and blue bytes with red as least-significant and blue as most.
##     colouralpha -> colour integer containing red, green, blue, and alpha bytes with red as least-significant and alpha as most.
##     string -> pointer to const character
##     stringresult -> pointer to character, NULL-> return size of result
##     cells -> pointer to array of cells, each cell containing a style byte and character byte
##     pointer -> void* pointer that may point to a document, loader, internal text storage or similar
##     textrange -> range of a min and a max position with an output string
##     textrangefull -> range of a min and a max position with an output string - supports 64-bit
##     findtext -> searchrange, text -> foundposition
##     findtextfull -> searchrange, text -> foundposition
##     keymod -> integer containing key in low half and modifiers in high half
##     formatrange
##     formatrangefull
## Enumeration types always start with a capital letter
## Types no longer used:
##     findtextex -> searchrange
##     charrange -> range of a min and a max position
##     charrangeresult -> like charrange, but output param
##     countedstring
##     point -> x,y
##     pointresult  -> like point, but output param
##     rectangle -> left,top,right,bottom
## Client code should ignore definitions containing types it does not understand, except
## for possibly #defining the constants

## Line numbers and positions start at 0.
## String arguments may contain NUL ('\0') characters where the calls provide a length
## argument and retrieve NUL characters. APIs marked as NUL-terminated also have a
## NUL appended but client code should calculate the size that will be returned rather
## than relying upon the NUL whenever possible. Allow for the extra NUL character when
## allocating buffers. The size to allocate for a stringresult (not including NUL) can be
## determined by calling with a NULL (0) pointer.

cat Basics

################################################
## For Scintilla.h
val INVALID_POSITION=-1
# Define start of Scintilla messages to be greater than all Windows edit (EM_*) messages
# as many EM_ messages can be used although that use is deprecated.
val SCI_START=2000
val SCI_OPTIONAL_START=3000
val SCI_LEXER_START=4000

# Add text to the document at current position.
fun void AddText=2001(position length, string text)

# Add array of cells to document.
fun void AddStyledText=2002(position length, cells c)

# Insert string at a position.
fun void InsertText=2003(position pos, string text)

# Change the text that is being inserted in response to SC_MOD_INSERTCHECK
fun void ChangeInsertion=2672(position length, string text)

# Delete all text in the document.
fun void ClearAll=2004(,)

# Delete a range of text in the document.
fun void DeleteRange=2645(position start, position lengthDelete)

# Set all style bytes to 0, remove all folding information.
fun void ClearDocumentStyle=2005(,)

# Returns the number of bytes in the document.
get position GetLength=2006(,)

# Returns the character byte at the position.
get int GetCharAt=2007(position pos,)

# Returns the position of the caret.
get position GetCurrentPos=2008(,)

# Returns the position of the opposite end of the selection to the caret.
get position GetAnchor=2009(,)

# Returns the style byte at the position.
get int GetStyleAt=2010(position pos,)

# Returns the unsigned style byte at the position.
get int GetStyleIndexAt=2038(position pos,)

# Redoes the next action on the undo history.
fun void Redo=2011(,)

# Choose between collecting actions into the undo
# history and discarding them.
set void SetUndoCollection=2012(bool collectUndo,)

# Select all the text in the document.
fun void SelectAll=2013(,)

# Remember the current position in the undo history as the position
# at which the document was saved.
fun void SetSavePoint=2014(,)

# Retrieve a buffer of cells.
# Returns the number of bytes in the buffer not including terminating NULs.
fun position GetStyledText=2015(, textrange tr)

# Retrieve a buffer of cells that can be past 2GB.
# Returns the number of bytes in the buffer not including terminating NULs.
fun position GetStyledTextFull=2778(, textrangefull tr)

# Are there any redoable actions in the undo history?
fun bool CanRedo=2016(,)

# Retrieve the line number at which a particular marker is located.
fun line MarkerLineFromHandle=2017(int markerHandle,)

# Delete a marker.
fun void MarkerDeleteHandle=2018(int markerHandle,)

# Retrieve marker handles of a line
fun int MarkerHandleFromLine=2732(line line, int which)

# Retrieve marker number of a marker handle
fun int MarkerNumberFromLine=2733(line line, int which)

# Is undo history being collected?
get bool GetUndoCollection=2019(,)

enu WhiteSpace=SCWS_
val SCWS_INVISIBLE=0
val SCWS_VISIBLEALWAYS=1
val SCWS_VISIBLEAFTERINDENT=2
val SCWS_VISIBLEONLYININDENT=3

ali SCWS_VISIBLEALWAYS=VISIBLE_ALWAYS
ali SCWS_VISIBLEAFTERINDENT=VISIBLE_AFTER_INDENT
ali SCWS_VISIBLEONLYININDENT=VISIBLE_ONLY_IN_INDENT

# Are white space characters currently visible?
# Returns one of SCWS_* constants.
get WhiteSpace GetViewWS=2020(,)

# Make white space characters invisible, always visible or visible outside indentation.
set void SetViewWS=2021(WhiteSpace viewWS,)

enu TabDrawMode=SCTD_
val SCTD_LONGARROW=0
val SCTD_STRIKEOUT=1

ali SCTD_LONGARROW=LONG_ARROW
ali SCTD_STRIKEOUT=STRIKE_OUT

# Retrieve the current tab draw mode.
# Returns one of SCTD_* constants.
get TabDrawMode GetTabDrawMode=2698(,)

# Set how tabs are drawn when visible.
set void SetTabDrawMode=2699(TabDrawMode tabDrawMode,)

# Find the position from a point within the window.
fun position PositionFromPoint=2022(int x, int y)

# Find the position from a point within the window but return
# INVALID_POSITION if not close to text.
fun position PositionFromPointClose=2023(int x, int y)

# Set caret to start of a line and ensure it is visible.
fun void GotoLine=2024(line line,)

# Set caret to a position and ensure it is visible.
fun void GotoPos=2025(position caret,)

# Set the selection anchor to a position. The anchor is the opposite
# end of the selection from the caret.
set void SetAnchor=2026(position anchor,)

# Retrieve the text of the line containing the caret.
# Returns the index of the caret on the line.
# Result is NUL-terminated.
fun position GetCurLine=2027(position length, stringresult text)

# Retrieve the position of the last correctly styled character.
get position GetEndStyled=2028(,)

enu EndOfLine=SC_EOL_
val SC_EOL_CRLF=0
val SC_EOL_CR=1
val SC_EOL_LF=2

ali SC_EOL_CRLF=CR_LF

# Convert all line endings in the document to one mode.
fun void ConvertEOLs=2029(EndOfLine eolMode,)

# Retrieve the current end of line mode - one of CRLF, CR, or LF.
get EndOfLine GetEOLMode=2030(,)

# Set the current end of line mode.
set void SetEOLMode=2031(EndOfLine eolMode,)

# Set the current styling position to start.
# The unused parameter is no longer used and should be set to 0.
fun void StartStyling=2032(position start, int unused)

# Change style from current styling position for length characters to a style
# and move the current styling position to after this newly styled segment.
fun void SetStyling=2033(position length, int style)

# Is drawing done first into a buffer or direct to the screen?
get bool GetBufferedDraw=2034(,)

# If drawing is buffered then each line of text is drawn into a bitmap buffer
# before drawing it to the screen to avoid flicker.
set void SetBufferedDraw=2035(bool buffered,)

# Change the visible size of a tab to be a multiple of the width of a space character.
set void SetTabWidth=2036(int tabWidth,)

# Retrieve the visible size of a tab.
get int GetTabWidth=2121(,)

# Set the minimum visual width of a tab.
set void SetTabMinimumWidth=2724(int pixels,)

# Get the minimum visual width of a tab.
get int GetTabMinimumWidth=2725(,)

# Clear explicit tabstops on a line.
fun void ClearTabStops=2675(line line,)

# Add an explicit tab stop for a line.
fun void AddTabStop=2676(line line, int x)

# Find the next explicit tab stop position on a line after a position.
fun int GetNextTabStop=2677(line line, int x)

# The SC_CP_UTF8 value can be used to enter Unicode mode.
# This is the same value as CP_UTF8 in Windows
val SC_CP_UTF8=65001

# Set the code page used to interpret the bytes of the document as characters.
# The SC_CP_UTF8 value can be used to enter Unicode mode.
set void SetCodePage=2037(int codePage,)

# Set the locale for displaying text.
set void SetFontLocale=2760(, string localeName)

# Get the locale for displaying text.
get int GetFontLocale=2761(, stringresult localeName)

enu IMEInteraction=SC_IME_
val SC_IME_WINDOWED=0
val SC_IME_INLINE=1

# Is the IME displayed in a window or inline?
get IMEInteraction GetIMEInteraction=2678(,)

# Choose to display the IME in a window or inline.
set void SetIMEInteraction=2679(IMEInteraction imeInteraction,)

enu Alpha=SC_ALPHA_
val SC_ALPHA_TRANSPARENT=0
val SC_ALPHA_OPAQUE=255
val SC_ALPHA_NOALPHA=256

ali SC_ALPHA_NOALPHA=NO_ALPHA

enu CursorShape=SC_CURSOR
val SC_CURSORNORMAL=-1
val SC_CURSORARROW=2
val SC_CURSORWAIT=4
val SC_CURSORREVERSEARROW=7

ali SC_CURSORREVERSEARROW=REVERSE_ARROW

enu MarkerSymbol=SC_MARK_
val MARKER_MAX=31
val SC_MARK_CIRCLE=0
val SC_MARK_ROUNDRECT=1
val SC_MARK_ARROW=2
val SC_MARK_SMALLRECT=3
val SC_MARK_SHORTARROW=4
val SC_MARK_EMPTY=5
val SC_MARK_ARROWDOWN=6
val SC_MARK_MINUS=7
val SC_MARK_PLUS=8

# Shapes used for outlining column.
val SC_MARK_VLINE=9
val SC_MARK_LCORNER=10
val SC_MARK_TCORNER=11
val SC_MARK_BOXPLUS=12
val SC_MARK_BOXPLUSCONNECTED=13
val SC_MARK_BOXMINUS=14
val SC_MARK_BOXMINUSCONNECTED=15
val SC_MARK_LCORNERCURVE=16
val SC_MARK_TCORNERCURVE=17
val SC_MARK_CIRCLEPLUS=18
val SC_MARK_CIRCLEPLUSCONNECTED=19
val SC_MARK_CIRCLEMINUS=20
val SC_MARK_CIRCLEMINUSCONNECTED=21

# Invisible mark that only sets the line background colour.
val SC_MARK_BACKGROUND=22
val SC_MARK_DOTDOTDOT=23
val SC_MARK_ARROWS=24
val SC_MARK_PIXMAP=25
val SC_MARK_FULLRECT=26
val SC_MARK_LEFTRECT=27
val SC_MARK_AVAILABLE=28
val SC_MARK_UNDERLINE=29
val SC_MARK_RGBAIMAGE=30
val SC_MARK_BOOKMARK=31
val SC_MARK_VERTICALBOOKMARK=32
val SC_MARK_BAR=33

val SC_MARK_CHARACTER=10000

ali SC_MARK_ROUNDRECT=ROUND_RECT
ali SC_MARK_SMALLRECT=SMALL_RECT
ali SC_MARK_SHORTARROW=SHORT_ARROW
ali SC_MARK_ARROWDOWN=ARROW_DOWN
ali SC_MARK_VLINE=V_LINE
ali SC_MARK_LCORNER=L_CORNER
ali SC_MARK_TCORNER=T_CORNER
ali SC_MARK_BOXPLUS=BOX_PLUS
ali SC_MARK_BOXPLUSCONNECTED=BOX_PLUS_CONNECTED
ali SC_MARK_BOXMINUS=BOX_MINUS
ali SC_MARK_BOXMINUSCONNECTED=BOX_MINUS_CONNECTED
ali SC_MARK_LCORNERCURVE=L_CORNER_CURVE
ali SC_MARK_TCORNERCURVE=T_CORNER_CURVE
ali SC_MARK_CIRCLEPLUS=CIRCLE_PLUS
ali SC_MARK_CIRCLEPLUSCONNECTED=CIRCLE_PLUS_CONNECTED
ali SC_MARK_CIRCLEMINUS=CIRCLE_MINUS
ali SC_MARK_CIRCLEMINUSCONNECTED=CIRCLE_MINUS_CONNECTED
ali SC_MARK_DOTDOTDOT=DOT_DOT_DOT
ali SC_MARK_FULLRECT=FULL_RECT
ali SC_MARK_LEFTRECT=LEFT_RECT
ali SC_MARK_RGBAIMAGE=RGBA_IMAGE
ali SC_MARK_VERTICALBOOKMARK=VERTICAL_BOOKMARK

enu MarkerOutline=SC_MARKNUM_
# Markers used for outlining and change history columns.
val SC_MARKNUM_HISTORY_REVERTED_TO_ORIGIN=21
val SC_MARKNUM_HISTORY_SAVED=22
val SC_MARKNUM_HISTORY_MODIFIED=23
val SC_MARKNUM_HISTORY_REVERTED_TO_MODIFIED=24
val SC_MARKNUM_FOLDEREND=25
val SC_MARKNUM_FOLDEROPENMID=26
val SC_MARKNUM_FOLDERMIDTAIL=27
val SC_MARKNUM_FOLDERTAIL=28
val SC_MARKNUM_FOLDERSUB=29
val SC_MARKNUM_FOLDER=30
val SC_MARKNUM_FOLDEROPEN=31

ali SC_MARKNUM_FOLDEREND=FOLDER_END
ali SC_MARKNUM_FOLDEROPENMID=FOLDER_OPEN_MID
ali SC_MARKNUM_FOLDERMIDTAIL=FOLDER_MID_TAIL
ali SC_MARKNUM_FOLDERTAIL=FOLDER_TAIL
ali SC_MARKNUM_FOLDERSUB=FOLDER_SUB
ali SC_MARKNUM_FOLDEROPEN=FOLDER_OPEN

val SC_MASK_HISTORY=0x01E00000

# SC_MASK_FOLDERS doesn't go in an enumeration as larger than max 32-bit positive integer
val SC_MASK_FOLDERS=0xFE000000

# Set the symbol used for a particular marker number.
fun void MarkerDefine=2040(int markerNumber, MarkerSymbol markerSymbol)

# Set the foreground colour used for a particular marker number.
set void MarkerSetFore=2041(int markerNumber, colour fore)

# Set the background colour used for a particular marker number.
set void MarkerSetBack=2042(int markerNumber, colour back)

# Set the background colour used for a particular marker number when its folding block is selected.
set void MarkerSetBackSelected=2292(int markerNumber, colour back)

# Set the foreground colour used for a particular marker number.
set void MarkerSetForeTranslucent=2294(int markerNumber, colouralpha fore)

# Set the background colour used for a particular marker number.
set void MarkerSetBackTranslucent=2295(int markerNumber, colouralpha back)

# Set the background colour used for a particular marker number when its folding block is selected.
set void MarkerSetBackSelectedTranslucent=2296(int markerNumber, colouralpha back)

# Set the width of strokes used in .01 pixels so 50  = 1/2 pixel width.
set void MarkerSetStrokeWidth=2297(int markerNumber, int hundredths)

# Enable/disable highlight for current folding block (smallest one that contains the caret)
fun void MarkerEnableHighlight=2293(bool enabled,)

# Add a marker to a line, returning an ID which can be used to find or delete the marker.
fun int MarkerAdd=2043(line line, int markerNumber)

# Delete a marker from a line.
fun void MarkerDelete=2044(line line, int markerNumber)

# Delete all markers with a particular number from all lines.
fun void MarkerDeleteAll=2045(int markerNumber,)

# Get a bit mask of all the markers set on a line.
fun int MarkerGet=2046(line line,)

# Find the next line at or after lineStart that includes a marker in mask.
# Return -1 when no more lines.
fun line MarkerNext=2047(line lineStart, int markerMask)

# Find the previous line before lineStart that includes a marker in mask.
fun line MarkerPrevious=2048(line lineStart, int markerMask)

# Define a marker from a pixmap.
fun void MarkerDefinePixmap=2049(int markerNumber, string pixmap)

# Add a set of markers to a line.
fun void MarkerAddSet=2466(line line, int markerSet)

# Set the alpha used for a marker that is drawn in the text area, not the margin.
set void MarkerSetAlpha=2476(int markerNumber, Alpha alpha)

# Get the layer used for a marker that is drawn in the text area, not the margin.
get Layer MarkerGetLayer=2734(int markerNumber,)

# Set the layer used for a marker that is drawn in the text area, not the margin.
set void MarkerSetLayer=2735(int markerNumber, Layer layer)

val SC_MAX_MARGIN=4

enu MarginType=SC_MARGIN_
val SC_MARGIN_SYMBOL=0
val SC_MARGIN_NUMBER=1
val SC_MARGIN_BACK=2
val SC_MARGIN_FORE=3
val SC_MARGIN_TEXT=4
val SC_MARGIN_RTEXT=5
val SC_MARGIN_COLOUR=6

ali SC_MARGIN_RTEXT=R_TEXT

# Set a margin to be either numeric or symbolic.
set void SetMarginTypeN=2240(int margin, MarginType marginType)

# Retrieve the type of a margin.
get MarginType GetMarginTypeN=2241(int margin,)

# Set the width of a margin to a width expressed in pixels.
set void SetMarginWidthN=2242(int margin, int pixelWidth)

# Retrieve the width of a margin in pixels.
get int GetMarginWidthN=2243(int margin,)

# Set a mask that determines which markers are displayed in a margin.
set void SetMarginMaskN=2244(int margin, int mask)

# Retrieve the marker mask of a margin.
get int GetMarginMaskN=2245(int margin,)

# Make a margin sensitive or insensitive to mouse clicks.
set void SetMarginSensitiveN=2246(int margin, bool sensitive)

# Retrieve the mouse click sensitivity of a margin.
get bool GetMarginSensitiveN=2247(int margin,)

# Set the cursor shown when the mouse is inside a margin.
set void SetMarginCursorN=2248(int margin, CursorShape cursor)

# Retrieve the cursor shown in a margin.
get CursorShape GetMarginCursorN=2249(int margin,)

# Set the background colour of a margin. Only visible for SC_MARGIN_COLOUR.
set void SetMarginBackN=2250(int margin, colour back)

# Retrieve the background colour of a margin
get colour GetMarginBackN=2251(int margin,)

# Allocate a non-standard number of margins.
set void SetMargins=2252(int margins,)

# How many margins are there?.
get int GetMargins=2253(,)

# Styles in range 32..39 are predefined for parts of the UI and are not used as normal styles.
enu StylesCommon=STYLE_
val STYLE_DEFAULT=32
val STYLE_LINENUMBER=33
val STYLE_BRACELIGHT=34
val STYLE_BRACEBAD=35
val STYLE_CONTROLCHAR=36
val STYLE_INDENTGUIDE=37
val STYLE_CALLTIP=38
val STYLE_FOLDDISPLAYTEXT=39
val STYLE_LASTPREDEFINED=39
val STYLE_MAX=255

ali STYLE_LINENUMBER=LINE_NUMBER
ali STYLE_BRACELIGHT=BRACE_LIGHT
ali STYLE_BRACEBAD=BRACE_BAD
ali STYLE_CONTROLCHAR=CONTROL_CHAR
ali STYLE_INDENTGUIDE=INDENT_GUIDE
ali STYLE_CALLTIP=CALL_TIP
ali STYLE_FOLDDISPLAYTEXT=FOLD_DISPLAY_TEXT
ali STYLE_LASTPREDEFINED=LAST_PREDEFINED

# Character set identifiers are used in StyleSetCharacterSet.
# The values are the same as the Windows *_CHARSET values.
enu CharacterSet=SC_CHARSET_
val SC_CHARSET_ANSI=0
val SC_CHARSET_DEFAULT=1
val SC_CHARSET_BALTIC=186
val SC_CHARSET_CHINESEBIG5=136
val SC_CHARSET_EASTEUROPE=238
val SC_CHARSET_GB2312=134
val SC_CHARSET_GREEK=161
val SC_CHARSET_HANGUL=129
val SC_CHARSET_MAC=77
val SC_CHARSET_OEM=255
val SC_CHARSET_RUSSIAN=204
val SC_CHARSET_OEM866=866
val SC_CHARSET_CYRILLIC=1251
val SC_CHARSET_SHIFTJIS=128
val SC_CHARSET_SYMBOL=2
val SC_CHARSET_TURKISH=162
val SC_CHARSET_JOHAB=130
val SC_CHARSET_HEBREW=177
val SC_CHARSET_ARABIC=178
val SC_CHARSET_VIETNAMESE=163
val SC_CHARSET_THAI=222
val SC_CHARSET_8859_15=1000

ali SC_CHARSET_CHINESEBIG5=CHINESE_BIG5
ali SC_CHARSET_EASTEUROPE=EAST_EUROPE
ali SC_CHARSET_GB2312=G_B_2312
ali SC_CHARSET_OEM866=OEM_866
ali SC_CHARSET_SHIFTJIS=SHIFT_JIS
ali SC_CHARSET_8859_15=ISO_8859_15

# Clear all the styles and make equivalent to the global default style.
fun void StyleClearAll=2050(,)

# Set the foreground colour of a style.
set void StyleSetFore=2051(int style, colour fore)

# Set the background colour of a style.
set void StyleSetBack=2052(int style, colour back)

# Set a style to be bold or not.
set void StyleSetBold=2053(int style, bool bold)

# Set a style to be italic or not.
set void StyleSetItalic=2054(int style, bool italic)

# Set the size of characters of a style.
set void StyleSetSize=2055(int style, int sizePoints)

# Set the font of a style.
set void StyleSetFont=2056(int style, string fontName)

# Set a style to have its end of line filled or not.
set void StyleSetEOLFilled=2057(int style, bool eolFilled)

# Reset the default style to its state at startup
fun void StyleResetDefault=2058(,)

# Set a style to be underlined or not.
set void StyleSetUnderline=2059(int style, bool underline)

enu CaseVisible=SC_CASE_
val SC_CASE_MIXED=0
val SC_CASE_UPPER=1
val SC_CASE_LOWER=2
val SC_CASE_CAMEL=3

# Get the foreground colour of a style.
get colour StyleGetFore=2481(int style,)

# Get the background colour of a style.
get colour StyleGetBack=2482(int style,)

# Get is a style bold or not.
get bool StyleGetBold=2483(int style,)

# Get is a style italic or not.
get bool StyleGetItalic=2484(int style,)

# Get the size of characters of a style.
get int StyleGetSize=2485(int style,)

# Get the font of a style.
# Returns the length of the fontName
# Result is NUL-terminated.
get int StyleGetFont=2486(int style, stringresult fontName)

# Get is a style to have its end of line filled or not.
get bool StyleGetEOLFilled=2487(int style,)

# Get is a style underlined or not.
get bool StyleGetUnderline=2488(int style,)

# Get is a style mixed case, or to force upper or lower case.
get CaseVisible StyleGetCase=2489(int style,)

# Get the character get of the font in a style.
get CharacterSet StyleGetCharacterSet=2490(int style,)

# Get is a style visible or not.
get bool StyleGetVisible=2491(int style,)

# Get is a style changeable or not (read only).
# Experimental feature, currently buggy.
get bool StyleGetChangeable=2492(int style,)

# Get is a style a hotspot or not.
get bool StyleGetHotSpot=2493(int style,)

# Set a style to be mixed case, or to force upper or lower case.
set void StyleSetCase=2060(int style, CaseVisible caseVisible)

val SC_FONT_SIZE_MULTIPLIER=100

# Set the size of characters of a style. Size is in points multiplied by 100.
set void StyleSetSizeFractional=2061(int style, int sizeHundredthPoints)

# Get the size of characters of a style in points multiplied by 100
get int StyleGetSizeFractional=2062(int style,)

enu FontWeight=SC_WEIGHT_
val SC_WEIGHT_NORMAL=400
val SC_WEIGHT_SEMIBOLD=600
val SC_WEIGHT_BOLD=700

ali SC_WEIGHT_SEMIBOLD=SEMI_BOLD

# Set the weight of characters of a style.
set void StyleSetWeight=2063(int style, FontWeight weight)

# Get the weight of characters of a style.
get FontWeight StyleGetWeight=2064(int style,)

# Set the character set of the font in a style.
set void StyleSetCharacterSet=2066(int style, CharacterSet characterSet)

# Set a style to be a hotspot or not.
set void StyleSetHotSpot=2409(int style, bool hotspot)

# Indicate that a style may be monospaced over ASCII graphics characters which enables optimizations.
set void StyleSetCheckMonospaced=2254(int style, bool checkMonospaced)

# Get whether a style may be monospaced.
get bool StyleGetCheckMonospaced=2255(int style,)

enu FontStretch=SC_STRETCH_
val SC_STRETCH_ULTRA_CONDENSED=1
val SC_STRETCH_EXTRA_CONDENSED=2
val SC_STRETCH_CONDENSED=3
val SC_STRETCH_SEMI_CONDENSED=4
val SC_STRETCH_NORMAL=5
val SC_STRETCH_SEMI_EXPANDED=6
val SC_STRETCH_EXPANDED=7
val SC_STRETCH_EXTRA_EXPANDED=8
val SC_STRETCH_ULTRA_EXPANDED=9

# Set the stretch of characters of a style.
set void StyleSetStretch=2258(int style, FontStretch stretch)

# Get the stretch of characters of a style.
get FontStretch StyleGetStretch=2259(int style,)

# Set the invisible representation for a style.
set void StyleSetInvisibleRepresentation=2256(int style, string representation)

# Get the invisible representation for a style.
get int StyleGetInvisibleRepresentation=2257(int style, stringresult representation)

enu Element=SC_ELEMENT_
val SC_ELEMENT_LIST=0
val SC_ELEMENT_LIST_BACK=1
val SC_ELEMENT_LIST_SELECTED=2
val SC_ELEMENT_LIST_SELECTED_BACK=3
val SC_ELEMENT_SELECTION_TEXT=10
val SC_ELEMENT_SELECTION_BACK=11
val SC_ELEMENT_SELECTION_ADDITIONAL_TEXT=12
val SC_ELEMENT_SELECTION_ADDITIONAL_BACK=13
val SC_ELEMENT_SELECTION_SECONDARY_TEXT=14
val SC_ELEMENT_SELECTION_SECONDARY_BACK=15
val SC_ELEMENT_SELECTION_INACTIVE_TEXT=16
val SC_ELEMENT_SELECTION_INACTIVE_BACK=17
val SC_ELEMENT_SELECTION_INACTIVE_ADDITIONAL_TEXT=18
val SC_ELEMENT_SELECTION_INACTIVE_ADDITIONAL_BACK=19
val SC_ELEMENT_CARET=40
val SC_ELEMENT_CARET_ADDITIONAL=41
val SC_ELEMENT_CARET_LINE_BACK=50
val SC_ELEMENT_WHITE_SPACE=60
val SC_ELEMENT_WHITE_SPACE_BACK=61
val SC_ELEMENT_HOT_SPOT_ACTIVE=70
val SC_ELEMENT_HOT_SPOT_ACTIVE_BACK=71
val SC_ELEMENT_FOLD_LINE=80
val SC_ELEMENT_HIDDEN_LINE=81

# Set the colour of an element. Translucency (alpha) may or may not be significant
# and this may depend on the platform. The alpha byte should commonly be 0xff for opaque.
set void SetElementColour=2753(Element element, colouralpha colourElement)

# Get the colour of an element.
get colouralpha GetElementColour=2754(Element element,)

# Use the default or platform-defined colour for an element.
fun void ResetElementColour=2755(Element element,)

# Get whether an element has been set by SetElementColour.
# When false, a platform-defined or default colour is used.
get bool GetElementIsSet=2756(Element element,)

# Get whether an element supports translucency.
get bool GetElementAllowsTranslucent=2757(Element element,)

# Get the colour of an element.
get colouralpha GetElementBaseColour=2758(Element element,)

# Set the foreground colour of the main and additional selections and whether to use this setting.
fun void SetSelFore=2067(bool useSetting, colour fore)

# Set the background colour of the main and additional selections and whether to use this setting.
fun void SetSelBack=2068(bool useSetting, colour back)

# Get the alpha of the selection.
get Alpha GetSelAlpha=2477(,)

# Set the alpha of the selection.
set void SetSelAlpha=2478(Alpha alpha,)

# Is the selection end of line filled?
get bool GetSelEOLFilled=2479(,)

# Set the selection to have its end of line filled or not.
set void SetSelEOLFilled=2480(bool filled,)

enu Layer=SC_LAYER_
val SC_LAYER_BASE=0
val SC_LAYER_UNDER_TEXT=1
val SC_LAYER_OVER_TEXT=2

# Get the layer for drawing selections
get Layer GetSelectionLayer=2762(,)

# Set the layer for drawing selections: either opaquely on base layer or translucently over text
set void SetSelectionLayer=2763(Layer layer,)

# Get the layer of the background of the line containing the caret.
get Layer GetCaretLineLayer=2764(,)

# Set the layer of the background of the line containing the caret.
set void SetCaretLineLayer=2765(Layer layer,)

# Get only highlighting subline instead of whole line.
get bool GetCaretLineHighlightSubLine=2773(,)

# Set only highlighting subline instead of whole line.
set void SetCaretLineHighlightSubLine=2774(bool subLine,)

# Set the foreground colour of the caret.
set void SetCaretFore=2069(colour fore,)

# When key+modifier combination keyDefinition is pressed perform sciCommand.
fun void AssignCmdKey=2070(keymod keyDefinition, int sciCommand)

# When key+modifier combination keyDefinition is pressed do nothing.
fun void ClearCmdKey=2071(keymod keyDefinition,)

# Drop all key mappings.
fun void ClearAllCmdKeys=2072(,)

# Set the styles for a segment of the document.
fun void SetStylingEx=2073(position length, string styles)

# Set a style to be visible or not.
set void StyleSetVisible=2074(int style, bool visible)

# Get the time in milliseconds that the caret is on and off.
get int GetCaretPeriod=2075(,)

# Get the time in milliseconds that the caret is on and off. 0 = steady on.
set void SetCaretPeriod=2076(int periodMilliseconds,)

# Set the set of characters making up words for when moving or selecting by word.
# First sets defaults like SetCharsDefault.
set void SetWordChars=2077(, string characters)

# Get the set of characters making up words for when moving or selecting by word.
# Returns the number of characters
get int GetWordChars=2646(, stringresult characters)

# Set the number of characters to have directly indexed categories
set void SetCharacterCategoryOptimization=2720(int countCharacters,)

# Get the number of characters to have directly indexed categories
get int GetCharacterCategoryOptimization=2721(,)

# Start a sequence of actions that is undone and redone as a unit.
# May be nested.
fun void BeginUndoAction=2078(,)

# End a sequence of actions that is undone and redone as a unit.
fun void EndUndoAction=2079(,)

# Is an undo sequence active?
get int GetUndoSequence=2799(,)

# How many undo actions are in the history?
get int GetUndoActions=2790(,)

# Set action as the save point
set void SetUndoSavePoint=2791(int action,)

# Which action is the save point?
get int GetUndoSavePoint=2792(,)

# Set action as the detach point
set void SetUndoDetach=2793(int action,)

# Which action is the detach point?
get int GetUndoDetach=2794(,)

# Set action as the tentative point
set void SetUndoTentative=2795(int action,)

# Which action is the tentative point?
get int GetUndoTentative=2796(,)

# Set action as the current point
set void SetUndoCurrent=2797(int action,)

# Which action is the current point?
get int GetUndoCurrent=2798(,)

# Push one action onto undo history with no text
fun void PushUndoActionType=2800(int type, position pos)

# Set the text and length of the most recently pushed action
fun void ChangeLastUndoActionText=2801(position length, string text)

# What is the type of an action?
get int GetUndoActionType=2802(int action,)

# What is the position of an action?
get position GetUndoActionPosition=2803(int action,)

# What is the text of an action?
get int GetUndoActionText=2804(int action, stringresult text)

# Indicator style enumeration and some constants
enu IndicatorStyle=INDIC_
val INDIC_PLAIN=0
val INDIC_SQUIGGLE=1
val INDIC_TT=2
val INDIC_DIAGONAL=3
val INDIC_STRIKE=4
val INDIC_HIDDEN=5
val INDIC_BOX=6
val INDIC_ROUNDBOX=7
val INDIC_STRAIGHTBOX=8
val INDIC_DASH=9
val INDIC_DOTS=10
val INDIC_SQUIGGLELOW=11
val INDIC_DOTBOX=12
val INDIC_SQUIGGLEPIXMAP=13
val INDIC_COMPOSITIONTHICK=14
val INDIC_COMPOSITIONTHIN=15
val INDIC_FULLBOX=16
val INDIC_TEXTFORE=17
val INDIC_POINT=18
val INDIC_POINTCHARACTER=19
val INDIC_GRADIENT=20
val INDIC_GRADIENTCENTRE=21
val INDIC_POINT_TOP=22

# INDIC_CONTAINER, INDIC_IME, INDIC_IME_MAX, and INDIC_MAX are indicator numbers,
# not IndicatorStyles so should not really be in the INDIC_ enumeration.
# They are redeclared in IndicatorNumbers INDICATOR_.
val INDIC_CONTAINER=8
val INDIC_IME=32
val INDIC_IME_MAX=35
val INDIC_MAX=35

enu IndicatorNumbers=INDICATOR_
val INDICATOR_CONTAINER=8
val INDICATOR_IME=32
val INDICATOR_IME_MAX=35
val INDICATOR_HISTORY_REVERTED_TO_ORIGIN_INSERTION=36
val INDICATOR_HISTORY_REVERTED_TO_ORIGIN_DELETION=37
val INDICATOR_HISTORY_SAVED_INSERTION=38
val INDICATOR_HISTORY_SAVED_DELETION=39
val INDICATOR_HISTORY_MODIFIED_INSERTION=40
val INDICATOR_HISTORY_MODIFIED_DELETION=41
val INDICATOR_HISTORY_REVERTED_TO_MODIFIED_INSERTION=42
val INDICATOR_HISTORY_REVERTED_TO_MODIFIED_DELETION=43
val INDICATOR_MAX=43

ali INDIC_TT=T_T
ali INDIC_ROUNDBOX=ROUND_BOX
ali INDIC_STRAIGHTBOX=STRAIGHT_BOX
ali INDIC_SQUIGGLELOW=SQUIGGLE_LOW
ali INDIC_DOTBOX=DOT_BOX
ali INDIC_SQUIGGLEPIXMAP=SQUIGGLE_PIXMAP
ali INDIC_COMPOSITIONTHICK=COMPOSITION_THICK
ali INDIC_COMPOSITIONTHIN=COMPOSITION_THIN
ali INDIC_FULLBOX=FULL_BOX
ali INDIC_TEXTFORE=TEXT_FORE
ali INDIC_POINTCHARACTER=POINT_CHARACTER
ali INDIC_GRADIENTCENTRE=GRADIENT_CENTRE

# Set an indicator to plain, squiggle or TT.
set void IndicSetStyle=2080(int indicator, IndicatorStyle indicatorStyle)

# Retrieve the style of an indicator.
get IndicatorStyle IndicGetStyle=2081(int indicator,)

# Set the foreground colour of an indicator.
set void IndicSetFore=2082(int indicator, colour fore)

# Retrieve the foreground colour of an indicator.
get colour IndicGetFore=2083(int indicator,)

# Set an indicator to draw under text or over(default).
set void IndicSetUnder=2510(int indicator, bool under)

# Retrieve whether indicator drawn under or over text.
get bool IndicGetUnder=2511(int indicator,)

# Set a hover indicator to plain, squiggle or TT.
set void IndicSetHoverStyle=2680(int indicator, IndicatorStyle indicatorStyle)

# Retrieve the hover style of an indicator.
get IndicatorStyle IndicGetHoverStyle=2681(int indicator,)

# Set the foreground hover colour of an indicator.
set void IndicSetHoverFore=2682(int indicator, colour fore)

# Retrieve the foreground hover colour of an indicator.
get colour IndicGetHoverFore=2683(int indicator,)

enu IndicValue=SC_INDICVALUE
val SC_INDICVALUEBIT=0x1000000
val SC_INDICVALUEMASK=0xFFFFFF

enu IndicFlag=SC_INDICFLAG_
val SC_INDICFLAG_NONE=0
val SC_INDICFLAG_VALUEFORE=1

ali SC_INDICFLAG_VALUEFORE=VALUE_FORE

# Set the attributes of an indicator.
set void IndicSetFlags=2684(int indicator, IndicFlag flags)

# Retrieve the attributes of an indicator.
get IndicFlag IndicGetFlags=2685(int indicator,)

# Set the stroke width of an indicator in hundredths of a pixel.
set void IndicSetStrokeWidth=2751(int indicator, int hundredths)

# Retrieve the stroke width of an indicator.
get int IndicGetStrokeWidth=2752(int indicator,)

# Set the foreground colour of all whitespace and whether to use this setting.
fun void SetWhitespaceFore=2084(bool useSetting, colour fore)

# Set the background colour of all whitespace and whether to use this setting.
fun void SetWhitespaceBack=2085(bool useSetting, colour back)

# Set the size of the dots used to mark space characters.
set void SetWhitespaceSize=2086(int size,)

# Get the size of the dots used to mark space characters.
get int GetWhitespaceSize=2087(,)

# Used to hold extra styling information for each line.
set void SetLineState=2092(line line, int state)

# Retrieve the extra styling information for a line.
get int GetLineState=2093(line line,)

# Retrieve the last line number that has line state.
get int GetMaxLineState=2094(,)

# Is the background of the line containing the caret in a different colour?
get bool GetCaretLineVisible=2095(,)

# Display the background of the line containing the caret in a different colour.
set void SetCaretLineVisible=2096(bool show,)

# Get the colour of the background of the line containing the caret.
get colour GetCaretLineBack=2097(,)

# Set the colour of the background of the line containing the caret.
set void SetCaretLineBack=2098(colour back,)

# Retrieve the caret line frame width.
# Width = 0 means this option is disabled.
get int GetCaretLineFrame=2704(,)

# Display the caret line framed.
# Set width != 0 to enable this option and width = 0 to disable it.
set void SetCaretLineFrame=2705(int width,)

# Set a style to be changeable or not (read only).
# Experimental feature, currently buggy.
set void StyleSetChangeable=2099(int style, bool changeable)

# Display a auto-completion list.
# The lengthEntered parameter indicates how many characters before
# the caret should be used to provide context.
fun void AutoCShow=2100(position lengthEntered, string itemList)

# Remove the auto-completion list from the screen.
fun void AutoCCancel=2101(,)

# Is there an auto-completion list visible?
fun bool AutoCActive=2102(,)

# Retrieve the position of the caret when the auto-completion list was displayed.
fun position AutoCPosStart=2103(,)

# User has selected an item so remove the list and insert the selection.
fun void AutoCComplete=2104(,)

# Define a set of character that when typed cancel the auto-completion list.
fun void AutoCStops=2105(, string characterSet)

# Change the separator character in the string setting up an auto-completion list.
# Default is space but can be changed if items contain space.
set void AutoCSetSeparator=2106(int separatorCharacter,)

# Retrieve the auto-completion list separator character.
get int AutoCGetSeparator=2107(,)

# Select the item in the auto-completion list that starts with a string.
fun void AutoCSelect=2108(, string select)

# Should the auto-completion list be cancelled if the user backspaces to a
# position before where the box was created.
set void AutoCSetCancelAtStart=2110(bool cancel,)

# Retrieve whether auto-completion cancelled by backspacing before start.
get bool AutoCGetCancelAtStart=2111(,)

# Define a set of characters that when typed will cause the autocompletion to
# choose the selected item.
set void AutoCSetFillUps=2112(, string characterSet)

# Should a single item auto-completion list automatically choose the item.
set void AutoCSetChooseSingle=2113(bool chooseSingle,)

# Retrieve whether a single item auto-completion list automatically choose the item.
get bool AutoCGetChooseSingle=2114(,)

# Set whether case is significant when performing auto-completion searches.
set void AutoCSetIgnoreCase=2115(bool ignoreCase,)

# Retrieve state of ignore case flag.
get bool AutoCGetIgnoreCase=2116(,)

# Display a list of strings and send notification when user chooses one.
fun void UserListShow=2117(int listType, string itemList)

# Set whether or not autocompletion is hidden automatically when nothing matches.
set void AutoCSetAutoHide=2118(bool autoHide,)

# Retrieve whether or not autocompletion is hidden automatically when nothing matches.
get bool AutoCGetAutoHide=2119(,)

# Define option flags for autocompletion lists
enu AutoCompleteOption=SC_AUTOCOMPLETE_
val SC_AUTOCOMPLETE_NORMAL=0
# Win32 specific:
val SC_AUTOCOMPLETE_FIXED_SIZE=1
# Always select the first item in the autocompletion list:
val SC_AUTOCOMPLETE_SELECT_FIRST_ITEM=2

# Set autocompletion options.
set void AutoCSetOptions=2638(AutoCompleteOption options,)

# Retrieve autocompletion options.
get AutoCompleteOption AutoCGetOptions=2639(,)

# Set whether or not autocompletion deletes any word characters
# after the inserted text upon completion.
set void AutoCSetDropRestOfWord=2270(bool dropRestOfWord,)

# Retrieve whether or not autocompletion deletes any word characters
# after the inserted text upon completion.
get bool AutoCGetDropRestOfWord=2271(,)

# Register an XPM image for use in autocompletion lists.
fun void RegisterImage=2405(int type, string xpmData)

# Clear all the registered XPM images.
fun void ClearRegisteredImages=2408(,)

# Retrieve the auto-completion list type-separator character.
get int AutoCGetTypeSeparator=2285(,)

# Change the type-separator character in the string setting up an auto-completion list.
# Default is '?' but can be changed if items contain '?'.
set void AutoCSetTypeSeparator=2286(int separatorCharacter,)

# Set the maximum width, in characters, of auto-completion and user lists.
# Set to 0 to autosize to fit longest item, which is the default.
set void AutoCSetMaxWidth=2208(int characterCount,)

# Get the maximum width, in characters, of auto-completion and user lists.
get int AutoCGetMaxWidth=2209(,)

# Set the maximum height, in rows, of auto-completion and user lists.
# The default is 5 rows.
set void AutoCSetMaxHeight=2210(int rowCount,)

# Set the maximum height, in rows, of auto-completion and user lists.
get int AutoCGetMaxHeight=2211(,)

# Set the style number used for auto-completion and user lists fonts.
set void AutoCSetStyle=2109(int style,)

# Get the style number used for auto-completion and user lists fonts.
get int AutoCGetStyle=2120(,)

# Set the scale factor in percent for auto-completion list images.
set void AutoCSetImageScale=2815(int scalePercent,)

# Get the scale factor in percent for auto-completion list images.
get int AutoCGetImageScale=2816(,)

# Set the number of spaces used for one level of indentation.
set void SetIndent=2122(int indentSize,)

# Retrieve indentation size.
get int GetIndent=2123(,)

# Indentation will only use space characters if useTabs is false, otherwise
# it will use a combination of tabs and spaces.
set void SetUseTabs=2124(bool useTabs,)

# Retrieve whether tabs will be used in indentation.
get bool GetUseTabs=2125(,)

# Change the indentation of a line to a number of columns.
set void SetLineIndentation=2126(line line, int indentation)

# Retrieve the number of columns that a line is indented.
get int GetLineIndentation=2127(line line,)

# Retrieve the position before the first non indentation character on a line.
get position GetLineIndentPosition=2128(line line,)

# Retrieve the column number of a position, taking tab width into account.
get position GetColumn=2129(position pos,)

# Count characters between two positions.
fun position CountCharacters=2633(position start, position end)

# Count code units between two positions.
fun position CountCodeUnits=2715(position start, position end)

# Show or hide the horizontal scroll bar.
set void SetHScrollBar=2130(bool visible,)
# Is the horizontal scroll bar visible?
get bool GetHScrollBar=2131(,)

enu IndentView=SC_IV_
val SC_IV_NONE=0
val SC_IV_REAL=1
val SC_IV_LOOKFORWARD=2
val SC_IV_LOOKBOTH=3

ali SC_IV_LOOKFORWARD=LOOK_FORWARD
ali SC_IV_LOOKBOTH=LOOK_BOTH

# Show or hide indentation guides.
set void SetIndentationGuides=2132(IndentView indentView,)

# Are the indentation guides visible?
get IndentView GetIndentationGuides=2133(,)

# Set the highlighted indentation guide column.
# 0 = no highlighted guide.
set void SetHighlightGuide=2134(position column,)

# Get the highlighted indentation guide column.
get position GetHighlightGuide=2135(,)

# Get the position after the last visible characters on a line.
get position GetLineEndPosition=2136(line line,)

# Get the code page used to interpret the bytes of the document as characters.
get int GetCodePage=2137(,)

# Get the foreground colour of the caret.
get colour GetCaretFore=2138(,)

# In read-only mode?
get bool GetReadOnly=2140(,)

# Sets the position of the caret.
set void SetCurrentPos=2141(position caret,)

# Sets the position that starts the selection - this becomes the anchor.
set void SetSelectionStart=2142(position anchor,)

# Returns the position at the start of the selection.
get position GetSelectionStart=2143(,)

# Sets the position that ends the selection - this becomes the caret.
set void SetSelectionEnd=2144(position caret,)

# Returns the position at the end of the selection.
get position GetSelectionEnd=2145(,)

# Set caret to a position, while removing any existing selection.
fun void SetEmptySelection=2556(position caret,)

# Sets the print magnification added to the point size of each style for printing.
set void SetPrintMagnification=2146(int magnification,)

# Returns the print magnification.
get int GetPrintMagnification=2147(,)

enu PrintOption=SC_PRINT_
# PrintColourMode - use same colours as screen.
# with the exception of line number margins, which use a white background
val SC_PRINT_NORMAL=0
# PrintColourMode - invert the light value of each style for printing.
val SC_PRINT_INVERTLIGHT=1
# PrintColourMode - force black text on white background for printing.
val SC_PRINT_BLACKONWHITE=2
# PrintColourMode - text stays coloured, but all background is forced to be white for printing.
val SC_PRINT_COLOURONWHITE=3
# PrintColourMode - only the default-background is forced to be white for printing.
val SC_PRINT_COLOURONWHITEDEFAULTBG=4
# PrintColourMode - use same colours as screen, including line number margins.
val SC_PRINT_SCREENCOLOURS=5

ali SC_PRINT_INVERTLIGHT=INVERT_LIGHT
ali SC_PRINT_BLACKONWHITE=BLACK_ON_WHITE
ali SC_PRINT_COLOURONWHITE=COLOUR_ON_WHITE
ali SC_PRINT_COLOURONWHITEDEFAULTBG=COLOUR_ON_WHITE_DEFAULT_B_G
ali SC_PRINT_SCREENCOLOURS=SCREEN_COLOURS

# Modify colours when printing for clearer printed text.
set void SetPrintColourMode=2148(PrintOption mode,)

# Returns the print colour mode.
get PrintOption GetPrintColourMode=2149(,)

enu FindOption=SCFIND_
val SCFIND_NONE=0x0
val SCFIND_WHOLEWORD=0x2
val SCFIND_MATCHCASE=0x4
val SCFIND_WORDSTART=0x00100000
val SCFIND_REGEXP=0x00200000
val SCFIND_POSIX=0x00400000
val SCFIND_CXX11REGEX=0x00800000

ali SCFIND_WHOLEWORD=WHOLE_WORD
ali SCFIND_MATCHCASE=MATCH_CASE
ali SCFIND_WORDSTART=WORD_START
ali SCFIND_REGEXP=REG_EXP
ali SCFIND_CXX11REGEX=CXX11_REG_EX

# Find some text in the document.
fun position FindText=2150(FindOption searchFlags, findtext ft)

# Find some text in the document.
fun position FindTextFull=2196(FindOption searchFlags, findtextfull ft)

# Draw the document into a display context such as a printer.
fun position FormatRange=2151(bool draw, formatrange fr)

# Draw the document into a display context such as a printer.
fun position FormatRangeFull=2777(bool draw, formatrangefull fr)

enu ChangeHistoryOption=SC_CHANGE_HISTORY_
val SC_CHANGE_HISTORY_DISABLED=0
val SC_CHANGE_HISTORY_ENABLED=1
val SC_CHANGE_HISTORY_MARKERS=2
val SC_CHANGE_HISTORY_INDICATORS=4

# Enable or disable change history.
set void SetChangeHistory=2780(ChangeHistoryOption changeHistory,)

# Report change history status.
get ChangeHistoryOption GetChangeHistory=2781(,)

enu UndoSelectionHistoryOption=SC_UNDO_SELECTION_HISTORY_
val SC_UNDO_SELECTION_HISTORY_DISABLED=0
val SC_UNDO_SELECTION_HISTORY_ENABLED=1
val SC_UNDO_SELECTION_HISTORY_SCROLL=2

# Enable or disable undo selection history.
set void SetUndoSelectionHistory=2782(UndoSelectionHistoryOption undoSelectionHistory,)

# Report undo selection history status.
get UndoSelectionHistoryOption GetUndoSelectionHistory=2783(,)

# Set selection from serialized form.
set void SetSelectionSerialized=2784(, string selectionString)

# Retrieve serialized form of selection.
get position GetSelectionSerialized=2785(, stringresult selectionString)

# Retrieve the display line at the top of the display.
get line GetFirstVisibleLine=2152(,)

# Retrieve the contents of a line.
# Returns the length of the line.
fun position GetLine=2153(line line, stringresult text)

# Returns the number of lines in the document. There is always at least one.
get line GetLineCount=2154(,)

# Enlarge the number of lines allocated.
set void AllocateLines=2089(line lines,)

# Sets the size in pixels of the left margin.
set void SetMarginLeft=2155(, int pixelWidth)

# Returns the size in pixels of the left margin.
get int GetMarginLeft=2156(,)

# Sets the size in pixels of the right margin.
set void SetMarginRight=2157(, int pixelWidth)

# Returns the size in pixels of the right margin.
get int GetMarginRight=2158(,)

# Is the document different from when it was last saved?
get bool GetModify=2159(,)

# Select a range of text.
fun void SetSel=2160(position anchor, position caret)

# Retrieve the selected text.
# Return the length of the text.
# Result is NUL-terminated.
fun position GetSelText=2161(, stringresult text)

# Retrieve a range of text.
# Return the length of the text.
fun position GetTextRange=2162(, textrange tr)

# Retrieve a range of text that can be past 2GB.
# Return the length of the text.
fun position GetTextRangeFull=2039(, textrangefull tr)

# Draw the selection either highlighted or in normal (non-highlighted) style.
fun void HideSelection=2163(bool hide,)

#Is the selection visible or hidden?
get bool GetSelectionHidden=2088(,)

# Retrieve the x value of the point in the window where a position is displayed.
fun int PointXFromPosition=2164(, position pos)

# Retrieve the y value of the point in the window where a position is displayed.
fun int PointYFromPosition=2165(, position pos)

# Retrieve the line containing a position.
fun line LineFromPosition=2166(position pos,)

# Retrieve the position at the start of a line.
fun position PositionFromLine=2167(line line,)

# Scroll horizontally and vertically.
fun void LineScroll=2168(position columns, line lines)

# Scroll vertically with allowance for wrapping.
fun void ScrollVertical=2817(line docLine, line subLine)

# Ensure the caret is visible.
fun void ScrollCaret=2169(,)

# Scroll the argument positions and the range between them into view giving
# priority to the primary position then the secondary position.
# This may be used to make a search match visible.
fun void ScrollRange=2569(position secondary, position primary)

# Replace the selected text with the argument text.
fun void ReplaceSel=2170(, string text)

# Set to read only or read write.
set void SetReadOnly=2171(bool readOnly,)

# Null operation.
fun void Null=2172(,)

# Will a paste succeed?
fun bool CanPaste=2173(,)

# Are there any undoable actions in the undo history?
fun bool CanUndo=2174(,)

# Delete the undo history.
fun void EmptyUndoBuffer=2175(,)

# Undo one action in the undo history.
fun void Undo=2176(,)

# Cut the selection to the clipboard.
fun void Cut=2177(,)

# Copy the selection to the clipboard.
fun void Copy=2178(,)

# Paste the contents of the clipboard into the document replacing the selection.
fun void Paste=2179(,)

# Clear the selection.
fun void Clear=2180(,)

# Replace the contents of the document with the argument text.
fun void SetText=2181(, string text)

# Retrieve all the text in the document.
# Returns number of characters retrieved.
# Result is NUL-terminated.
fun position GetText=2182(position length, stringresult text)

# Retrieve the number of characters in the document.
get position GetTextLength=2183(,)

# Retrieve a pointer to a function that processes messages for this Scintilla.
get pointer GetDirectFunction=2184(,)

# Retrieve a pointer to a function that processes messages for this Scintilla and returns status.
get pointer GetDirectStatusFunction=2772(,)

# Retrieve a pointer value to use as the first argument when calling
# the function returned by GetDirectFunction.
get pointer GetDirectPointer=2185(,)

# Set to overtype (true) or insert mode.
set void SetOvertype=2186(bool overType,)

# Returns true if overtype mode is active otherwise false is returned.
get bool GetOvertype=2187(,)

# Set the width of the insert mode caret.
set void SetCaretWidth=2188(int pixelWidth,)

# Returns the width of the insert mode caret.
get int GetCaretWidth=2189(,)

# Sets the position that starts the target which is used for updating the
# document without affecting the scroll position.
set void SetTargetStart=2190(position start,)

# Get the position that starts the target.
get position GetTargetStart=2191(,)

# Sets the virtual space of the target start
set void SetTargetStartVirtualSpace=2728(position space,)

# Get the virtual space of the target start
get position GetTargetStartVirtualSpace=2729(,)

# Sets the position that ends the target which is used for updating the
# document without affecting the scroll position.
set void SetTargetEnd=2192(position end,)

# Get the position that ends the target.
get position GetTargetEnd=2193(,)

# Sets the virtual space of the target end
set void SetTargetEndVirtualSpace=2730(position space,)

# Get the virtual space of the target end
get position GetTargetEndVirtualSpace=2731(,)

# Sets both the start and end of the target in one call.
fun void SetTargetRange=2686(position start, position end)

# Retrieve the text in the target.
get position GetTargetText=2687(, stringresult text)

# Make the target range start and end be the same as the selection range start and end.
fun void TargetFromSelection=2287(,)

# Sets the target to the whole document.
fun void TargetWholeDocument=2690(,)

# Replace the target text with the argument text.
# Text is counted so it can contain NULs.
# Returns the length of the replacement text.
fun position ReplaceTarget=2194(position length, string text)

# Replace the target text with the argument text after \d processing.
# Text is counted so it can contain NULs.
# Looks for \d where d is between 1 and 9 and replaces these with the strings
# matched in the last search operation which were surrounded by \( and \).
# Returns the length of the replacement text including any change
# caused by processing the \d patterns.
fun position ReplaceTargetRE=2195(position length, string text)

# Replace the target text with the argument text but ignore prefix and suffix that
# are the same as current.
fun position ReplaceTargetMinimal=2779(position length, string text)

# Search for a counted string in the target and set the target to the found
# range. Text is counted so it can contain NULs.
# Returns start of found range or -1 for failure in which case target is not moved.
fun position SearchInTarget=2197(position length, string text)

# Set the search flags used by SearchInTarget.
set void SetSearchFlags=2198(FindOption searchFlags,)

# Get the search flags used by SearchInTarget.
get FindOption GetSearchFlags=2199(,)

# Show a call tip containing a definition near position pos.
fun void CallTipShow=2200(position pos, string definition)

# Remove the call tip from the screen.
fun void CallTipCancel=2201(,)

# Is there an active call tip?
fun bool CallTipActive=2202(,)

# Retrieve the position where the caret was before displaying the call tip.
get position CallTipPosStart=2203(,)

# Set the start position in order to change when backspacing removes the calltip.
set void CallTipSetPosStart=2214(position posStart,)

# Highlight a segment of the definition.
fun void CallTipSetHlt=2204(position highlightStart, position highlightEnd)

# Set the background colour for the call tip.
set void CallTipSetBack=2205(colour back,)

# Set the foreground colour for the call tip.
set void CallTipSetFore=2206(colour fore,)

# Set the foreground colour for the highlighted part of the call tip.
set void CallTipSetForeHlt=2207(colour fore,)

# Enable use of STYLE_CALLTIP and set call tip tab size in pixels.
set void CallTipUseStyle=2212(int tabSize,)

# Set position of calltip, above or below text.
set void CallTipSetPosition=2213(bool above,)

# Find the display line of a document line taking hidden lines into account.
fun line VisibleFromDocLine=2220(line docLine,)

# Find the document line of a display line taking hidden lines into account.
fun line DocLineFromVisible=2221(line displayLine,)

# The number of display lines needed to wrap a document line
fun line WrapCount=2235(line docLine,)

enu FoldLevel=SC_FOLDLEVEL
val SC_FOLDLEVELNONE=0x0
val SC_FOLDLEVELBASE=0x400
val SC_FOLDLEVELWHITEFLAG=0x1000
val SC_FOLDLEVELHEADERFLAG=0x2000
val SC_FOLDLEVELNUMBERMASK=0x0FFF

ali SC_FOLDLEVELWHITEFLAG=WHITE_FLAG
ali SC_FOLDLEVELHEADERFLAG=HEADER_FLAG
ali SC_FOLDLEVELNUMBERMASK=NUMBER_MASK

# Set the fold level of a line.
# This encodes an integer level along with flags indicating whether the
# line is a header and whether it is effectively white space.
set void SetFoldLevel=2222(line line, FoldLevel level)

# Retrieve the fold level of a line.
get FoldLevel GetFoldLevel=2223(line line,)

# Find the last child line of a header line.
get line GetLastChild=2224(line line, FoldLevel level)

# Find the parent line of a child line.
get line GetFoldParent=2225(line line,)

# Make a range of lines visible.
fun void ShowLines=2226(line lineStart, line lineEnd)

# Make a range of lines invisible.
fun void HideLines=2227(line lineStart, line lineEnd)

# Is a line visible?
get bool GetLineVisible=2228(line line,)

# Are all lines visible?
get bool GetAllLinesVisible=2236(,)

# Show the children of a header line.
set void SetFoldExpanded=2229(line line, bool expanded)

# Is a header line expanded?
get bool GetFoldExpanded=2230(line line,)

# Switch a header line between expanded and contracted.
fun void ToggleFold=2231(line line,)

# Switch a header line between expanded and contracted and show some text after the line.
fun void ToggleFoldShowText=2700(line line, string text)

enu FoldDisplayTextStyle=SC_FOLDDISPLAYTEXT_
val SC_FOLDDISPLAYTEXT_HIDDEN=0
val SC_FOLDDISPLAYTEXT_STANDARD=1
val SC_FOLDDISPLAYTEXT_BOXED=2

# Set the style of fold display text.
set void FoldDisplayTextSetStyle=2701(FoldDisplayTextStyle style,)

# Get the style of fold display text.
get FoldDisplayTextStyle FoldDisplayTextGetStyle=2707(,)

# Set the default fold display text.
fun void SetDefaultFoldDisplayText=2722(, string text)

# Get the default fold display text.
fun int GetDefaultFoldDisplayText=2723(, stringresult text)

enu FoldAction=SC_FOLDACTION_
val SC_FOLDACTION_CONTRACT=0
val SC_FOLDACTION_EXPAND=1
val SC_FOLDACTION_TOGGLE=2
val SC_FOLDACTION_CONTRACT_EVERY_LEVEL=4

# Expand or contract a fold header.
fun void FoldLine=2237(line line, FoldAction action)

# Expand or contract a fold header and its children.
fun void FoldChildren=2238(line line, FoldAction action)

# Expand a fold header and all children. Use the level argument instead of the line's current level.
fun void ExpandChildren=2239(line line, FoldLevel level)

# Expand or contract all fold headers.
fun void FoldAll=2662(FoldAction action,)

# Ensure a particular line is visible by expanding any header line hiding it.
fun void EnsureVisible=2232(line line,)

enu AutomaticFold=SC_AUTOMATICFOLD_
val SC_AUTOMATICFOLD_NONE=0x0000
val SC_AUTOMATICFOLD_SHOW=0x0001
val SC_AUTOMATICFOLD_CLICK=0x0002
val SC_AUTOMATICFOLD_CHANGE=0x0004

# Set automatic folding behaviours.
set void SetAutomaticFold=2663(AutomaticFold automaticFold,)

# Get automatic folding behaviours.
get AutomaticFold GetAutomaticFold=2664(,)

enu FoldFlag=SC_FOLDFLAG_
val SC_FOLDFLAG_NONE=0x0000
val SC_FOLDFLAG_LINEBEFORE_EXPANDED=0x0002
val SC_FOLDFLAG_LINEBEFORE_CONTRACTED=0x0004
val SC_FOLDFLAG_LINEAFTER_EXPANDED=0x0008
val SC_FOLDFLAG_LINEAFTER_CONTRACTED=0x0010
val SC_FOLDFLAG_LEVELNUMBERS=0x0040
val SC_FOLDFLAG_LINESTATE=0x0080

ali SC_FOLDFLAG_LINEBEFORE_EXPANDED=LINE_BEFORE_EXPANDED
ali SC_FOLDFLAG_LINEBEFORE_CONTRACTED=LINE_BEFORE_CONTRACTED
ali SC_FOLDFLAG_LINEAFTER_EXPANDED=LINE_AFTER_EXPANDED
ali SC_FOLDFLAG_LINEAFTER_CONTRACTED=LINE_AFTER_CONTRACTED
ali SC_FOLDFLAG_LEVELNUMBERS=LEVEL_NUMBERS
ali SC_FOLDFLAG_LINESTATE=LINE_STATE

# Set some style options for folding.
set void SetFoldFlags=2233(FoldFlag flags,)

# Ensure a particular line is visible by expanding any header line hiding it.
# Use the currently set visibility policy to determine which range to display.
fun void EnsureVisibleEnforcePolicy=2234(line line,)

# Sets whether a tab pressed when caret is within indentation indents.
set void SetTabIndents=2260(bool tabIndents,)

# Does a tab pressed when caret is within indentation indent?
get bool GetTabIndents=2261(,)

# Sets whether a backspace pressed when caret is within indentation unindents.
set void SetBackSpaceUnIndents=2262(bool bsUnIndents,)

# Does a backspace pressed when caret is within indentation unindent?
get bool GetBackSpaceUnIndents=2263(,)

val SC_TIME_FOREVER=10000000

# Sets the time the mouse must sit still to generate a mouse dwell event.
set void SetMouseDwellTime=2264(int periodMilliseconds,)

# Retrieve the time the mouse must sit still to generate a mouse dwell event.
get int GetMouseDwellTime=2265(,)

# Get position of start of word.
fun position WordStartPosition=2266(position pos, bool onlyWordCharacters)

# Get position of end of word.
fun position WordEndPosition=2267(position pos, bool onlyWordCharacters)

# Is the range start..end considered a word?
fun bool IsRangeWord=2691(position start, position end)

enu IdleStyling=SC_IDLESTYLING_
val SC_IDLESTYLING_NONE=0
val SC_IDLESTYLING_TOVISIBLE=1
val SC_IDLESTYLING_AFTERVISIBLE=2
val SC_IDLESTYLING_ALL=3

ali SC_IDLESTYLING_TOVISIBLE=TO_VISIBLE
ali SC_IDLESTYLING_AFTERVISIBLE=AFTER_VISIBLE

# Sets limits to idle styling.
set void SetIdleStyling=2692(IdleStyling idleStyling,)

# Retrieve the limits to idle styling.
get IdleStyling GetIdleStyling=2693(,)

enu Wrap=SC_WRAP_
val SC_WRAP_NONE=0
val SC_WRAP_WORD=1
val SC_WRAP_CHAR=2
val SC_WRAP_WHITESPACE=3

ali SC_WRAP_WHITESPACE=WHITE_SPACE

# Sets whether text is word wrapped.
set void SetWrapMode=2268(Wrap wrapMode,)

# Retrieve whether text is word wrapped.
get Wrap GetWrapMode=2269(,)

enu WrapVisualFlag=SC_WRAPVISUALFLAG_
val SC_WRAPVISUALFLAG_NONE=0x0000
val SC_WRAPVISUALFLAG_END=0x0001
val SC_WRAPVISUALFLAG_START=0x0002
val SC_WRAPVISUALFLAG_MARGIN=0x0004

# Set the display mode of visual flags for wrapped lines.
set void SetWrapVisualFlags=2460(WrapVisualFlag wrapVisualFlags,)

# Retrive the display mode of visual flags for wrapped lines.
get WrapVisualFlag GetWrapVisualFlags=2461(,)

enu WrapVisualLocation=SC_WRAPVISUALFLAGLOC_
val SC_WRAPVISUALFLAGLOC_DEFAULT=0x0000
val SC_WRAPVISUALFLAGLOC_END_BY_TEXT=0x0001
val SC_WRAPVISUALFLAGLOC_START_BY_TEXT=0x0002

# Set the location of visual flags for wrapped lines.
set void SetWrapVisualFlagsLocation=2462(WrapVisualLocation wrapVisualFlagsLocation,)

# Retrive the location of visual flags for wrapped lines.
get WrapVisualLocation GetWrapVisualFlagsLocation=2463(,)

# Set the start indent for wrapped lines.
set void SetWrapStartIndent=2464(int indent,)

# Retrive the start indent for wrapped lines.
get int GetWrapStartIndent=2465(,)

enu WrapIndentMode=SC_WRAPINDENT_
val SC_WRAPINDENT_FIXED=0
val SC_WRAPINDENT_SAME=1
val SC_WRAPINDENT_INDENT=2
val SC_WRAPINDENT_DEEPINDENT=3

ali SC_WRAPINDENT_DEEPINDENT=DEEP_INDENT

# Sets how wrapped sublines are placed. Default is fixed.
set void SetWrapIndentMode=2472(WrapIndentMode wrapIndentMode,)

# Retrieve how wrapped sublines are placed. Default is fixed.
get WrapIndentMode GetWrapIndentMode=2473(,)

enu LineCache=SC_CACHE_
val SC_CACHE_NONE=0
val SC_CACHE_CARET=1
val SC_CACHE_PAGE=2
val SC_CACHE_DOCUMENT=3

# Sets the degree of caching of layout information.
set void SetLayoutCache=2272(LineCache cacheMode,)

# Retrieve the degree of caching of layout information.
get LineCache GetLayoutCache=2273(,)

# Sets the document width assumed for scrolling.
set void SetScrollWidth=2274(int pixelWidth,)

# Retrieve the document width assumed for scrolling.
get int GetScrollWidth=2275(,)

# Sets whether the maximum width line displayed is used to set scroll width.
set void SetScrollWidthTracking=2516(bool tracking,)

# Retrieve whether the scroll width tracks wide lines.
get bool GetScrollWidthTracking=2517(,)

# Measure the pixel width of some text in a particular style.
# NUL terminated text argument.
# Does not handle tab or control characters.
fun int TextWidth=2276(int style, string text)

# Sets the scroll range so that maximum scroll position has
# the last line at the bottom of the view (default).
# Setting this to false allows scrolling one page below the last line.
set void SetEndAtLastLine=2277(bool endAtLastLine,)

# Retrieve whether the maximum scroll position has the last
# line at the bottom of the view.
get bool GetEndAtLastLine=2278(,)

# Retrieve the height of a particular line of text in pixels.
fun int TextHeight=2279(line line,)

# Show or hide the vertical scroll bar.
set void SetVScrollBar=2280(bool visible,)

# Is the vertical scroll bar visible?
get bool GetVScrollBar=2281(,)

# Append a string to the end of the document without changing the selection.
fun void AppendText=2282(position length, string text)

enu PhasesDraw=SC_PHASES_
val SC_PHASES_ONE=0
val SC_PHASES_TWO=1
val SC_PHASES_MULTIPLE=2

# How many phases is drawing done in?
get PhasesDraw GetPhasesDraw=2673(,)

# In one phase draw, text is drawn in a series of rectangular blocks with no overlap.
# In two phase draw, text is drawn in a series of lines allowing runs to overlap horizontally.
# In multiple phase draw, each element is drawn over the whole drawing area, allowing text
# to overlap from one line to the next.
set void SetPhasesDraw=2674(PhasesDraw phases,)

# Control font anti-aliasing.

enu FontQuality=SC_EFF_
val SC_EFF_QUALITY_MASK=0xF
val SC_EFF_QUALITY_DEFAULT=0
val SC_EFF_QUALITY_NON_ANTIALIASED=1
val SC_EFF_QUALITY_ANTIALIASED=2
val SC_EFF_QUALITY_LCD_OPTIMIZED=3

# Choose the quality level for text from the FontQuality enumeration.
set void SetFontQuality=2611(FontQuality fontQuality,)

# Retrieve the quality level for text.
get FontQuality GetFontQuality=2612(,)

# Scroll so that a display line is at the top of the display.
set void SetFirstVisibleLine=2613(line displayLine,)

enu MultiPaste=SC_MULTIPASTE_
val SC_MULTIPASTE_ONCE=0
val SC_MULTIPASTE_EACH=1

# Change the effect of pasting when there are multiple selections.
set void SetMultiPaste=2614(MultiPaste multiPaste,)

# Retrieve the effect of pasting when there are multiple selections.
get MultiPaste GetMultiPaste=2615(,)

# Retrieve the value of a tag from a regular expression search.
# Result is NUL-terminated.
get int GetTag=2616(int tagNumber, stringresult tagValue)

# Join the lines in the target.
fun void LinesJoin=2288(,)

# Split the lines in the target into lines that are less wide than pixelWidth
# where possible.
fun void LinesSplit=2289(int pixelWidth,)

# Set one of the colours used as a chequerboard pattern in the fold margin
fun void SetFoldMarginColour=2290(bool useSetting, colour back)
# Set the other colour used as a chequerboard pattern in the fold margin
fun void SetFoldMarginHiColour=2291(bool useSetting, colour fore)

enu Accessibility=SC_ACCESSIBILITY_
val SC_ACCESSIBILITY_DISABLED=0
val SC_ACCESSIBILITY_ENABLED=1

# Enable or disable accessibility.
set void SetAccessibility=2702(Accessibility accessibility,)

# Report accessibility status.
get Accessibility GetAccessibility=2703(,)

## New messages go here

## Start of key messages
# Move caret down one line.
fun void LineDown=2300(,)

# Move caret down one line extending selection to new caret position.
fun void LineDownExtend=2301(,)

# Move caret up one line.
fun void LineUp=2302(,)

# Move caret up one line extending selection to new caret position.
fun void LineUpExtend=2303(,)

# Move caret left one character.
fun void CharLeft=2304(,)

# Move caret left one character extending selection to new caret position.
fun void CharLeftExtend=2305(,)

# Move caret right one character.
fun void CharRight=2306(,)

# Move caret right one character extending selection to new caret position.
fun void CharRightExtend=2307(,)

# Move caret left one word.
fun void WordLeft=2308(,)

# Move caret left one word extending selection to new caret position.
fun void WordLeftExtend=2309(,)

# Move caret right one word.
fun void WordRight=2310(,)

# Move caret right one word extending selection to new caret position.
fun void WordRightExtend=2311(,)

# Move caret to first position on line.
fun void Home=2312(,)

# Move caret to first position on line extending selection to new caret position.
fun void HomeExtend=2313(,)

# Move caret to last position on line.
fun void LineEnd=2314(,)

# Move caret to last position on line extending selection to new caret position.
fun void LineEndExtend=2315(,)

# Move caret to first position in document.
fun void DocumentStart=2316(,)

# Move caret to first position in document extending selection to new caret position.
fun void DocumentStartExtend=2317(,)

# Move caret to last position in document.
fun void DocumentEnd=2318(,)

# Move caret to last position in document extending selection to new caret position.
fun void DocumentEndExtend=2319(,)

# Move caret one page up.
fun void PageUp=2320(,)

# Move caret one page up extending selection to new caret position.
fun void PageUpExtend=2321(,)

# Move caret one page down.
fun void PageDown=2322(,)

# Move caret one page down extending selection to new caret position.
fun void PageDownExtend=2323(,)

# Switch from insert to overtype mode or the reverse.
fun void EditToggleOvertype=2324(,)

# Cancel any modes such as call tip or auto-completion list display.
fun void Cancel=2325(,)

# Delete the selection or if no selection, the character before the caret.
fun void DeleteBack=2326(,)

# If selection is empty or all on one line replace the selection with a tab character.
# If more than one line selected, indent the lines.
fun void Tab=2327(,)

# Indent the current and selected lines.
fun void LineIndent=2813(,)

# If selection is empty or all on one line dedent the line if caret is at start, else move caret.
# If more than one line selected, dedent the lines.
fun void BackTab=2328(,)

# Dedent the current and selected lines.
fun void LineDedent=2814(,)

# Insert a new line, may use a CRLF, CR or LF depending on EOL mode.
fun void NewLine=2329(,)

# Insert a Form Feed character.
fun void FormFeed=2330(,)

# Move caret to before first visible character on line.
# If already there move to first character on line.
fun void VCHome=2331(,)

# Like VCHome but extending selection to new caret position.
fun void VCHomeExtend=2332(,)

# Magnify the displayed text by increasing the sizes by 1 point.
fun void ZoomIn=2333(,)

# Make the displayed text smaller by decreasing the sizes by 1 point.
fun void ZoomOut=2334(,)

# Delete the word to the left of the caret.
fun void DelWordLeft=2335(,)

# Delete the word to the right of the caret.
fun void DelWordRight=2336(,)

# Delete the word to the right of the caret, but not the trailing non-word characters.
fun void DelWordRightEnd=2518(,)

# Cut the line containing the caret.
fun void LineCut=2337(,)

# Delete the line containing the caret.
fun void LineDelete=2338(,)

# Switch the current line with the previous.
fun void LineTranspose=2339(,)

# Reverse order of selected lines.
fun void LineReverse=2354(,)

# Duplicate the current line.
fun void LineDuplicate=2404(,)

# Transform the selection to lower case.
fun void LowerCase=2340(,)

# Transform the selection to upper case.
fun void UpperCase=2341(,)

# Scroll the document down, keeping the caret visible.
fun void LineScrollDown=2342(,)

# Scroll the document up, keeping the caret visible.
fun void LineScrollUp=2343(,)

# Delete the selection or if no selection, the character before the caret.
# Will not delete the character before at the start of a line.
fun void DeleteBackNotLine=2344(,)

# Move caret to first position on display line.
fun void HomeDisplay=2345(,)

# Move caret to first position on display line extending selection to
# new caret position.
fun void HomeDisplayExtend=2346(,)

# Move caret to last position on display line.
fun void LineEndDisplay=2347(,)

# Move caret to last position on display line extending selection to new
# caret position.
fun void LineEndDisplayExtend=2348(,)

# Like Home but when word-wrap is enabled goes first to start of display line
# HomeDisplay, then to start of document line Home.
fun void HomeWrap=2349(,)

# Like HomeExtend but when word-wrap is enabled extends first to start of display line
# HomeDisplayExtend, then to start of document line HomeExtend.
fun void HomeWrapExtend=2450(,)

# Like LineEnd but when word-wrap is enabled goes first to end of display line
# LineEndDisplay, then to start of document line LineEnd.
fun void LineEndWrap=2451(,)

# Like LineEndExtend but when word-wrap is enabled extends first to end of display line
# LineEndDisplayExtend, then to start of document line LineEndExtend.
fun void LineEndWrapExtend=2452(,)

# Like VCHome but when word-wrap is enabled goes first to start of display line
# VCHomeDisplay, then behaves like VCHome.
fun void VCHomeWrap=2453(,)

# Like VCHomeExtend but when word-wrap is enabled extends first to start of display line
# VCHomeDisplayExtend, then behaves like VCHomeExtend.
fun void VCHomeWrapExtend=2454(,)

# Copy the line containing the caret.
fun void LineCopy=2455(,)

# Move the caret inside current view if it's not there already.
fun void MoveCaretInsideView=2401(,)

# How many characters are on a line, including end of line characters?
fun position LineLength=2350(line line,)

# Highlight the characters at two positions.
fun void BraceHighlight=2351(position posA, position posB)

# Use specified indicator to highlight matching braces instead of changing their style.
fun void BraceHighlightIndicator=2498(bool useSetting, int indicator)

# Highlight the character at a position indicating there is no matching brace.
fun void BraceBadLight=2352(position pos,)

# Use specified indicator to highlight non matching brace instead of changing its style.
fun void BraceBadLightIndicator=2499(bool useSetting, int indicator)

# Find the position of a matching brace or INVALID_POSITION if no match.
# The maxReStyle must be 0 for now. It may be defined in a future release.
fun position BraceMatch=2353(position pos, int maxReStyle)

# Similar to BraceMatch, but matching starts at the explicit start position.
fun position BraceMatchNext=2369(position pos, position startPos)

# Are the end of line characters visible?
get bool GetViewEOL=2355(,)

# Make the end of line characters visible or invisible.
set void SetViewEOL=2356(bool visible,)

# Retrieve a pointer to the document object.
get pointer GetDocPointer=2357(,)

# Change the document object used.
set void SetDocPointer=2358(, pointer doc)

# Set which document modification events are sent to the container.
set void SetModEventMask=2359(ModificationFlags eventMask,)

enu EdgeVisualStyle=EDGE_
val EDGE_NONE=0
val EDGE_LINE=1
val EDGE_BACKGROUND=2
val EDGE_MULTILINE=3

ali EDGE_MULTILINE=MULTI_LINE

# Retrieve the column number which text should be kept within.
get position GetEdgeColumn=2360(,)

# Set the column number of the edge.
# If text goes past the edge then it is highlighted.
set void SetEdgeColumn=2361(position column,)

# Retrieve the edge highlight mode.
get EdgeVisualStyle GetEdgeMode=2362(,)

# The edge may be displayed by a line (EDGE_LINE/EDGE_MULTILINE) or by highlighting text that
# goes beyond it (EDGE_BACKGROUND) or not displayed at all (EDGE_NONE).
set void SetEdgeMode=2363(EdgeVisualStyle edgeMode,)

# Retrieve the colour used in edge indication.
get colour GetEdgeColour=2364(,)

# Change the colour used in edge indication.
set void SetEdgeColour=2365(colour edgeColour,)

# Add a new vertical edge to the view.
fun void MultiEdgeAddLine=2694(position column, colour edgeColour)

# Clear all vertical edges.
fun void MultiEdgeClearAll=2695(,)

# Get multi edge positions.
get position GetMultiEdgeColumn=2749(int which,)

# Sets the current caret position to be the search anchor.
fun void SearchAnchor=2366(,)

# Find some text starting at the search anchor.
# Does not ensure the selection is visible.
fun position SearchNext=2367(FindOption searchFlags, string text)

# Find some text starting at the search anchor and moving backwards.
# Does not ensure the selection is visible.
fun position SearchPrev=2368(FindOption searchFlags, string text)

# Retrieves the number of lines completely visible.
get line LinesOnScreen=2370(,)

enu PopUp=SC_POPUP_
val SC_POPUP_NEVER=0
val SC_POPUP_ALL=1
val SC_POPUP_TEXT=2

# Set whether a pop up menu is displayed automatically when the user presses
# the wrong mouse button on certain areas.
fun void UsePopUp=2371(PopUp popUpMode,)

# Is the selection rectangular? The alternative is the more common stream selection.
get bool SelectionIsRectangle=2372(,)

# Set the zoom level. This number of points is added to the size of all fonts.
# It may be positive to magnify or negative to reduce.
set void SetZoom=2373(int zoomInPoints,)
# Retrieve the zoom level.
get int GetZoom=2374(,)

enu DocumentOption=SC_DOCUMENTOPTION_
val SC_DOCUMENTOPTION_DEFAULT=0
val SC_DOCUMENTOPTION_STYLES_NONE=0x1
val SC_DOCUMENTOPTION_TEXT_LARGE=0x100

# Create a new document object.
# Starts with reference count of 1 and not selected into editor.
fun pointer CreateDocument=2375(position bytes, DocumentOption documentOptions)
# Extend life of document.
fun void AddRefDocument=2376(, pointer doc)
# Release a reference to the document, deleting document if it fades to black.
fun void ReleaseDocument=2377(, pointer doc)

# Get which document options are set.
get DocumentOption GetDocumentOptions=2379(,)

# Get which document modification events are sent to the container.
get ModificationFlags GetModEventMask=2378(,)

# Set whether command events are sent to the container.
set void SetCommandEvents=2717(bool commandEvents,)

# Get whether command events are sent to the container.
get bool GetCommandEvents=2718(,)

# Change internal focus flag.
set void SetFocus=2380(bool focus,)
# Get internal focus flag.
get bool GetFocus=2381(,)

enu Status=SC_STATUS_
val SC_STATUS_OK=0
val SC_STATUS_FAILURE=1
val SC_STATUS_BADALLOC=2
val SC_STATUS_WARN_START=1000
val SC_STATUS_WARN_REGEX=1001

ali SC_STATUS_BADALLOC=BAD_ALLOC
ali SC_STATUS_WARN_REGEX=REG_EX

# Change error status - 0 = OK.
set void SetStatus=2382(Status status,)
# Get error status.
get Status GetStatus=2383(,)

# Set whether the mouse is captured when its button is pressed.
set void SetMouseDownCaptures=2384(bool captures,)
# Get whether mouse gets captured.
get bool GetMouseDownCaptures=2385(,)

# Set whether the mouse wheel can be active outside the window.
set void SetMouseWheelCaptures=2696(bool captures,)
# Get whether mouse wheel can be active outside the window.
get bool GetMouseWheelCaptures=2697(,)

# Sets the cursor to one of the SC_CURSOR* values.
set void SetCursor=2386(CursorShape cursorType,)
# Get cursor type.
get CursorShape GetCursor=2387(,)

# Change the way control characters are displayed:
# If symbol is < 32, keep the drawn way, else, use the given character.
set void SetControlCharSymbol=2388(int symbol,)
# Get the way control characters are displayed.
get int GetControlCharSymbol=2389(,)

# Move to the previous change in capitalisation.
fun void WordPartLeft=2390(,)
# Move to the previous change in capitalisation extending selection
# to new caret position.
fun void WordPartLeftExtend=2391(,)
# Move to the change next in capitalisation.
fun void WordPartRight=2392(,)
# Move to the next change in capitalisation extending selection
# to new caret position.
fun void WordPartRightExtend=2393(,)

# Constants for use with SetVisiblePolicy, similar to SetCaretPolicy.
enu VisiblePolicy=VISIBLE_
val VISIBLE_SLOP=0x01
val VISIBLE_STRICT=0x04

# Set the way the display area is determined when a particular line
# is to be moved to by Find, FindNext, GotoLine, etc.
fun void SetVisiblePolicy=2394(VisiblePolicy visiblePolicy, int visibleSlop)

# Delete back from the current position to the start of the line.
fun void DelLineLeft=2395(,)

# Delete forwards from the current position to the end of the line.
fun void DelLineRight=2396(,)

# Set the xOffset (ie, horizontal scroll position).
set void SetXOffset=2397(int xOffset,)

# Get the xOffset (ie, horizontal scroll position).
get int GetXOffset=2398(,)

# Set the last x chosen value to be the caret x position.
fun void ChooseCaretX=2399(,)

# Set the focus to this Scintilla widget.
fun void GrabFocus=2400(,)

enu CaretPolicy=CARET_
# Caret policy, used by SetXCaretPolicy and SetYCaretPolicy.
# If CARET_SLOP is set, we can define a slop value: caretSlop.
# This value defines an unwanted zone (UZ) where the caret is... unwanted.
# This zone is defined as a number of pixels near the vertical margins,
# and as a number of lines near the horizontal margins.
# By keeping the caret away from the edges, it is seen within its context,
# so it is likely that the identifier that the caret is on can be completely seen,
# and that the current line is seen with some of the lines following it which are
# often dependent on that line.
val CARET_SLOP=0x01
# If CARET_STRICT is set, the policy is enforced... strictly.
# The caret is centred on the display if slop is not set,
# and cannot go in the UZ if slop is set.
val CARET_STRICT=0x04
# If CARET_JUMPS is set, the display is moved more energetically
# so the caret can move in the same direction longer before the policy is applied again.
val CARET_JUMPS=0x10
# If CARET_EVEN is not set, instead of having symmetrical UZs,
# the left and bottom UZs are extended up to right and top UZs respectively.
# This way, we favour the displaying of useful information: the beginning of lines,
# where most code reside, and the lines after the caret, eg. the body of a function.
val CARET_EVEN=0x08

# Set the way the caret is kept visible when going sideways.
# The exclusion zone is given in pixels.
fun void SetXCaretPolicy=2402(CaretPolicy caretPolicy, int caretSlop)

# Set the way the line the caret is on is kept visible.
# The exclusion zone is given in lines.
fun void SetYCaretPolicy=2403(CaretPolicy caretPolicy, int caretSlop)

# Set printing to line wrapped (SC_WRAP_WORD) or not line wrapped (SC_WRAP_NONE).
set void SetPrintWrapMode=2406(Wrap wrapMode,)

# Is printing line wrapped?
get Wrap GetPrintWrapMode=2407(,)

# Set a fore colour for active hotspots.
set void SetHotspotActiveFore=2410(bool useSetting, colour fore)

# Get the fore colour for active hotspots.
get colour GetHotspotActiveFore=2494(,)

# Set a back colour for active hotspots.
set void SetHotspotActiveBack=2411(bool useSetting, colour back)

# Get the back colour for active hotspots.
get colour GetHotspotActiveBack=2495(,)

# Enable / Disable underlining active hotspots.
set void SetHotspotActiveUnderline=2412(bool underline,)

# Get whether underlining for active hotspots.
get bool GetHotspotActiveUnderline=2496(,)

# Limit hotspots to single line so hotspots on two lines don't merge.
set void SetHotspotSingleLine=2421(bool singleLine,)

# Get the HotspotSingleLine property
get bool GetHotspotSingleLine=2497(,)

# Move caret down one paragraph (delimited by empty lines).
fun void ParaDown=2413(,)

# Extend selection down one paragraph (delimited by empty lines).
fun void ParaDownExtend=2414(,)

# Move caret up one paragraph (delimited by empty lines).
fun void ParaUp=2415(,)

# Extend selection up one paragraph (delimited by empty lines).
fun void ParaUpExtend=2416(,)

# Given a valid document position, return the previous position taking code
# page into account. Returns 0 if passed 0.
fun position PositionBefore=2417(position pos,)

# Given a valid document position, return the next position taking code
# page into account. Maximum value returned is the last position in the document.
fun position PositionAfter=2418(position pos,)

# Given a valid document position, return a position that differs in a number
# of characters. Returned value is always between 0 and last position in document.
fun position PositionRelative=2670(position pos, position relative)

# Given a valid document position, return a position that differs in a number
# of UTF-16 code units. Returned value is always between 0 and last position in document.
# The result may point half way (2 bytes) inside a non-BMP character.
fun position PositionRelativeCodeUnits=2716(position pos, position relative)

# Copy a range of text to the clipboard. Positions are clipped into the document.
fun void CopyRange=2419(position start, position end)

# Copy argument text to the clipboard.
fun void CopyText=2420(position length, string text)

enu SelectionMode=SC_SEL_
val SC_SEL_STREAM=0
val SC_SEL_RECTANGLE=1
val SC_SEL_LINES=2
val SC_SEL_THIN=3

# Set the selection mode to stream (SC_SEL_STREAM) or rectangular (SC_SEL_RECTANGLE/SC_SEL_THIN) or
# by lines (SC_SEL_LINES).
set void SetSelectionMode=2422(SelectionMode selectionMode,)

# Set the selection mode to stream (SC_SEL_STREAM) or rectangular (SC_SEL_RECTANGLE/SC_SEL_THIN) or
# by lines (SC_SEL_LINES) without changing MoveExtendsSelection.
fun void ChangeSelectionMode=2659(SelectionMode selectionMode,)

# Get the mode of the current selection.
get SelectionMode GetSelectionMode=2423(,)

# Set whether or not regular caret moves will extend or reduce the selection.
set void SetMoveExtendsSelection=2719(bool moveExtendsSelection,)

# Get whether or not regular caret moves will extend or reduce the selection.
get bool GetMoveExtendsSelection=2706(,)

# Retrieve the position of the start of the selection at the given line (INVALID_POSITION if no selection on this line).
fun position GetLineSelStartPosition=2424(line line,)

# Retrieve the position of the end of the selection at the given line (INVALID_POSITION if no selection on this line).
fun position GetLineSelEndPosition=2425(line line,)

## RectExtended rectangular selection moves
# Move caret down one line, extending rectangular selection to new caret position.
fun void LineDownRectExtend=2426(,)

# Move caret up one line, extending rectangular selection to new caret position.
fun void LineUpRectExtend=2427(,)

# Move caret left one character, extending rectangular selection to new caret position.
fun void CharLeftRectExtend=2428(,)

# Move caret right one character, extending rectangular selection to new caret position.
fun void CharRightRectExtend=2429(,)

# Move caret to first position on line, extending rectangular selection to new caret position.
fun void HomeRectExtend=2430(,)

# Move caret to before first visible character on line.
# If already there move to first character on line.
# In either case, extend rectangular selection to new caret position.
fun void VCHomeRectExtend=2431(,)

# Move caret to last position on line, extending rectangular selection to new caret position.
fun void LineEndRectExtend=2432(,)

# Move caret one page up, extending rectangular selection to new caret position.
fun void PageUpRectExtend=2433(,)

# Move caret one page down, extending rectangular selection to new caret position.
fun void PageDownRectExtend=2434(,)


# Move caret to top of page, or one page up if already at top of page.
fun void StutteredPageUp=2435(,)

# Move caret to top of page, or one page up if already at top of page, extending selection to new caret position.
fun void StutteredPageUpExtend=2436(,)

# Move caret to bottom of page, or one page down if already at bottom of page.
fun void StutteredPageDown=2437(,)

# Move caret to bottom of page, or one page down if already at bottom of page, extending selection to new caret position.
fun void StutteredPageDownExtend=2438(,)


# Move caret left one word, position cursor at end of word.
fun void WordLeftEnd=2439(,)

# Move caret left one word, position cursor at end of word, extending selection to new caret position.
fun void WordLeftEndExtend=2440(,)

# Move caret right one word, position cursor at end of word.
fun void WordRightEnd=2441(,)

# Move caret right one word, position cursor at end of word, extending selection to new caret position.
fun void WordRightEndExtend=2442(,)

# Set the set of characters making up whitespace for when moving or selecting by word.
# Should be called after SetWordChars.
set void SetWhitespaceChars=2443(, string characters)

# Get the set of characters making up whitespace for when moving or selecting by word.
get int GetWhitespaceChars=2647(, stringresult characters)

# Set the set of characters making up punctuation characters
# Should be called after SetWordChars.
set void SetPunctuationChars=2648(, string characters)

# Get the set of characters making up punctuation characters
get int GetPunctuationChars=2649(, stringresult characters)

# Reset the set of characters for whitespace and word characters to the defaults.
fun void SetCharsDefault=2444(,)

# Get currently selected item position in the auto-completion list
get int AutoCGetCurrent=2445(,)

# Get currently selected item text in the auto-completion list
# Returns the length of the item text
# Result is NUL-terminated.
get int AutoCGetCurrentText=2610(, stringresult text)

enu CaseInsensitiveBehaviour=SC_CASEINSENSITIVEBEHAVIOUR_
val SC_CASEINSENSITIVEBEHAVIOUR_RESPECTCASE=0
val SC_CASEINSENSITIVEBEHAVIOUR_IGNORECASE=1

ali SC_CASEINSENSITIVEBEHAVIOUR_RESPECTCASE=RESPECT_CASE
ali SC_CASEINSENSITIVEBEHAVIOUR_IGNORECASE=IGNORE_CASE

# Set auto-completion case insensitive behaviour to either prefer case-sensitive matches or have no preference.
set void AutoCSetCaseInsensitiveBehaviour=2634(CaseInsensitiveBehaviour behaviour,)

# Get auto-completion case insensitive behaviour.
get CaseInsensitiveBehaviour AutoCGetCaseInsensitiveBehaviour=2635(,)

enu MultiAutoComplete=SC_MULTIAUTOC_
val SC_MULTIAUTOC_ONCE=0
val SC_MULTIAUTOC_EACH=1

# Change the effect of autocompleting when there are multiple selections.
set void AutoCSetMulti=2636(MultiAutoComplete multi,)

# Retrieve the effect of autocompleting when there are multiple selections.
get MultiAutoComplete AutoCGetMulti=2637(,)

enu Ordering=SC_ORDER_
val SC_ORDER_PRESORTED=0
val SC_ORDER_PERFORMSORT=1
val SC_ORDER_CUSTOM=2

ali SC_ORDER_PRESORTED=PRE_SORTED
ali SC_ORDER_PERFORMSORT=PERFORM_SORT

# Set the way autocompletion lists are ordered.
set void AutoCSetOrder=2660(Ordering order,)

# Get the way autocompletion lists are ordered.
get Ordering AutoCGetOrder=2661(,)

# Enlarge the document to a particular size of text bytes.
fun void Allocate=2446(position bytes,)

# Returns the target converted to UTF8.
# Return the length in bytes.
fun position TargetAsUTF8=2447(, stringresult s)

# Set the length of the utf8 argument for calling EncodedFromUTF8.
# Set to -1 and the string will be measured to the first nul.
fun void SetLengthForEncode=2448(position bytes,)

# Translates a UTF8 string into the document encoding.
# Return the length of the result in bytes.
# On error return 0.
fun position EncodedFromUTF8=2449(string utf8, stringresult encoded)

# Find the position of a column on a line taking into account tabs and
# multi-byte characters. If beyond end of line, return line end position.
fun position FindColumn=2456(line line, position column)

enu CaretSticky=SC_CARETSTICKY_
val SC_CARETSTICKY_OFF=0
val SC_CARETSTICKY_ON=1
val SC_CARETSTICKY_WHITESPACE=2

ali SC_CARETSTICKY_WHITESPACE=WHITE_SPACE

# Can the caret preferred x position only be changed by explicit movement commands?
get CaretSticky GetCaretSticky=2457(,)

# Stop the caret preferred x position changing when the user types.
set void SetCaretSticky=2458(CaretSticky useCaretStickyBehaviour,)

# Switch between sticky and non-sticky: meant to be bound to a key.
fun void ToggleCaretSticky=2459(,)

# Enable/Disable convert-on-paste for line endings
set void SetPasteConvertEndings=2467(bool convert,)

# Get convert-on-paste setting
get bool GetPasteConvertEndings=2468(,)

# Replace the selection with text like a rectangular paste.
fun void ReplaceRectangular=2771(position length, string text)

# Duplicate the selection. If selection empty duplicate the line containing the caret.
fun void SelectionDuplicate=2469(,)

# Set background alpha of the caret line.
set void SetCaretLineBackAlpha=2470(Alpha alpha,)

# Get the background alpha of the caret line.
get Alpha GetCaretLineBackAlpha=2471(,)

enu CaretStyle=CARETSTYLE_
val CARETSTYLE_INVISIBLE=0
val CARETSTYLE_LINE=1
val CARETSTYLE_BLOCK=2
val CARETSTYLE_OVERSTRIKE_BAR=0
val CARETSTYLE_OVERSTRIKE_BLOCK=0x10
val CARETSTYLE_CURSES=0x20
val CARETSTYLE_INS_MASK=0xF
val CARETSTYLE_BLOCK_AFTER=0x100

# Set the style of the caret to be drawn.
set void SetCaretStyle=2512(CaretStyle caretStyle,)

# Returns the current style of the caret.
get CaretStyle GetCaretStyle=2513(,)

# Set the indicator used for IndicatorFillRange and IndicatorClearRange
set void SetIndicatorCurrent=2500(int indicator,)

# Get the current indicator
get int GetIndicatorCurrent=2501(,)

# Set the value used for IndicatorFillRange
set void SetIndicatorValue=2502(int value,)

# Get the current indicator value
get int GetIndicatorValue=2503(,)

# Turn a indicator on over a range.
fun void IndicatorFillRange=2504(position start, position lengthFill)

# Turn a indicator off over a range.
fun void IndicatorClearRange=2505(position start, position lengthClear)

# Are any indicators present at pos?
fun int IndicatorAllOnFor=2506(position pos,)

# What value does a particular indicator have at a position?
fun int IndicatorValueAt=2507(int indicator, position pos)

# Where does a particular indicator start?
fun position IndicatorStart=2508(int indicator, position pos)

# Where does a particular indicator end?
fun position IndicatorEnd=2509(int indicator, position pos)

# Set number of entries in position cache
set void SetPositionCache=2514(int size,)

# How many entries are allocated to the position cache?
get int GetPositionCache=2515(,)

# Set maximum number of threads used for layout
set void SetLayoutThreads=2775(int threads,)

# Get maximum number of threads used for layout
get int GetLayoutThreads=2776(,)

# Copy the selection, if selection empty copy the line with the caret
fun void CopyAllowLine=2519(,)

# Cut the selection, if selection empty cut the line with the caret
fun void CutAllowLine=2810(,)

# Set the string to separate parts when copying a multiple selection.
set void SetCopySeparator=2811(, string separator)

# Get the string to separate parts when copying a multiple selection.
get int GetCopySeparator=2812(, stringresult separator)

# Compact the document buffer and return a read-only pointer to the
# characters in the document.
get pointer GetCharacterPointer=2520(,)

# Return a read-only pointer to a range of characters in the document.
# May move the gap so that the range is contiguous, but will only move up
# to lengthRange bytes.
get pointer GetRangePointer=2643(position start, position lengthRange)

# Return a position which, to avoid performance costs, should not be within
# the range of a call to GetRangePointer.
get position GetGapPosition=2644(,)

# Set the alpha fill colour of the given indicator.
set void IndicSetAlpha=2523(int indicator, Alpha alpha)

# Get the alpha fill colour of the given indicator.
get Alpha IndicGetAlpha=2524(int indicator,)

# Set the alpha outline colour of the given indicator.
set void IndicSetOutlineAlpha=2558(int indicator, Alpha alpha)

# Get the alpha outline colour of the given indicator.
get Alpha IndicGetOutlineAlpha=2559(int indicator,)

# Set extra ascent for each line
set void SetExtraAscent=2525(int extraAscent,)

# Get extra ascent for each line
get int GetExtraAscent=2526(,)

# Set extra descent for each line
set void SetExtraDescent=2527(int extraDescent,)

# Get extra descent for each line
get int GetExtraDescent=2528(,)

# Which symbol was defined for markerNumber with MarkerDefine
fun MarkerSymbol MarkerSymbolDefined=2529(int markerNumber,)

# Set the text in the text margin for a line
set void MarginSetText=2530(line line, string text)

# Get the text in the text margin for a line
get int MarginGetText=2531(line line, stringresult text)

# Set the style number for the text margin for a line
set void MarginSetStyle=2532(line line, int style)

# Get the style number for the text margin for a line
get int MarginGetStyle=2533(line line,)

# Set the style in the text margin for a line
set void MarginSetStyles=2534(line line, string styles)

# Get the styles in the text margin for a line
get int MarginGetStyles=2535(line line, stringresult styles)

# Clear the margin text on all lines
fun void MarginTextClearAll=2536(,)

# Get the start of the range of style numbers used for margin text
set void MarginSetStyleOffset=2537(int style,)

# Get the start of the range of style numbers used for margin text
get int MarginGetStyleOffset=2538(,)

enu MarginOption=SC_MARGINOPTION_
val SC_MARGINOPTION_NONE=0
val SC_MARGINOPTION_SUBLINESELECT=1

ali SC_MARGINOPTION_SUBLINESELECT=SUB_LINE_SELECT

# Set the margin options.
set void SetMarginOptions=2539(MarginOption marginOptions,)

# Get the margin options.
get MarginOption GetMarginOptions=2557(,)

# Set the annotation text for a line
set void AnnotationSetText=2540(line line, string text)

# Get the annotation text for a line
get int AnnotationGetText=2541(line line, stringresult text)

# Set the style number for the annotations for a line
set void AnnotationSetStyle=2542(line line, int style)

# Get the style number for the annotations for a line
get int AnnotationGetStyle=2543(line line,)

# Set the annotation styles for a line
set void AnnotationSetStyles=2544(line line, string styles)

# Get the annotation styles for a line
get int AnnotationGetStyles=2545(line line, stringresult styles)

# Get the number of annotation lines for a line
get int AnnotationGetLines=2546(line line,)

# Clear the annotations from all lines
fun void AnnotationClearAll=2547(,)

enu AnnotationVisible=ANNOTATION_
val ANNOTATION_HIDDEN=0
val ANNOTATION_STANDARD=1
val ANNOTATION_BOXED=2
val ANNOTATION_INDENTED=3

# Set the visibility for the annotations for a view
set void AnnotationSetVisible=2548(AnnotationVisible visible,)

# Get the visibility for the annotations for a view
get AnnotationVisible AnnotationGetVisible=2549(,)

# Get the start of the range of style numbers used for annotations
set void AnnotationSetStyleOffset=2550(int style,)

# Get the start of the range of style numbers used for annotations
get int AnnotationGetStyleOffset=2551(,)

# Release all extended (>255) style numbers
fun void ReleaseAllExtendedStyles=2552(,)

# Allocate some extended (>255) style numbers and return the start of the range
fun int AllocateExtendedStyles=2553(int numberStyles,)

enu UndoFlags=UNDO_
val UNDO_NONE=0
val UNDO_MAY_COALESCE=1

# Add a container action to the undo stack
fun void AddUndoAction=2560(int token, UndoFlags flags)

# Find the position of a character from a point within the window.
fun position CharPositionFromPoint=2561(int x, int y)

# Find the position of a character from a point within the window.
# Return INVALID_POSITION if not close to text.
fun position CharPositionFromPointClose=2562(int x, int y)

# Set whether switching to rectangular mode while selecting with the mouse is allowed.
set void SetMouseSelectionRectangularSwitch=2668(bool mouseSelectionRectangularSwitch,)

# Whether switching to rectangular mode while selecting with the mouse is allowed.
get bool GetMouseSelectionRectangularSwitch=2669(,)

# Set whether multiple selections can be made
set void SetMultipleSelection=2563(bool multipleSelection,)

# Whether multiple selections can be made
get bool GetMultipleSelection=2564(,)

# Set whether typing can be performed into multiple selections
set void SetAdditionalSelectionTyping=2565(bool additionalSelectionTyping,)

# Whether typing can be performed into multiple selections
get bool GetAdditionalSelectionTyping=2566(,)

# Set whether additional carets will blink
set void SetAdditionalCaretsBlink=2567(bool additionalCaretsBlink,)

# Whether additional carets will blink
get bool GetAdditionalCaretsBlink=2568(,)

# Set whether additional carets are visible
set void SetAdditionalCaretsVisible=2608(bool additionalCaretsVisible,)

# Whether additional carets are visible
get bool GetAdditionalCaretsVisible=2609(,)

# How many selections are there?
get int GetSelections=2570(,)

# Is every selected range empty?
get bool GetSelectionEmpty=2650(,)

# Clear selections to a single empty stream selection
fun void ClearSelections=2571(,)

# Set a simple selection
fun void SetSelection=2572(position caret, position anchor)

# Add a selection
fun void AddSelection=2573(position caret, position anchor)

# Find the selection index for a point. -1 when not at a selection.
fun int SelectionFromPoint=2474(int x, int y)

# Drop one selection
fun void DropSelectionN=2671(int selection,)

# Set the main selection
set void SetMainSelection=2574(int selection,)

# Which selection is the main selection
get int GetMainSelection=2575(,)

# Set the caret position of the nth selection.
set void SetSelectionNCaret=2576(int selection, position caret)

# Return the caret position of the nth selection.
get position GetSelectionNCaret=2577(int selection,)

# Set the anchor position of the nth selection.
set void SetSelectionNAnchor=2578(int selection, position anchor)

# Return the anchor position of the nth selection.
get position GetSelectionNAnchor=2579(int selection,)

# Set the virtual space of the caret of the nth selection.
set void SetSelectionNCaretVirtualSpace=2580(int selection, position space)

# Return the virtual space of the caret of the nth selection.
get position GetSelectionNCaretVirtualSpace=2581(int selection,)

# Set the virtual space of the anchor of the nth selection.
set void SetSelectionNAnchorVirtualSpace=2582(int selection, position space)

# Return the virtual space of the anchor of the nth selection.
get position GetSelectionNAnchorVirtualSpace=2583(int selection,)

# Sets the position that starts the selection - this becomes the anchor.
set void SetSelectionNStart=2584(int selection, position anchor)

# Returns the position at the start of the selection.
get position GetSelectionNStart=2585(int selection,)

# Returns the virtual space at the start of the selection.
get position GetSelectionNStartVirtualSpace=2726(int selection,)

# Sets the position that ends the selection - this becomes the currentPosition.
set void SetSelectionNEnd=2586(int selection, position caret)

# Returns the virtual space at the end of the selection.
get position GetSelectionNEndVirtualSpace=2727(int selection,)

# Returns the position at the end of the selection.
get position GetSelectionNEnd=2587(int selection,)

# Set the caret position of the rectangular selection.
set void SetRectangularSelectionCaret=2588(position caret,)

# Return the caret position of the rectangular selection.
get position GetRectangularSelectionCaret=2589(,)

# Set the anchor position of the rectangular selection.
set void SetRectangularSelectionAnchor=2590(position anchor,)

# Return the anchor position of the rectangular selection.
get position GetRectangularSelectionAnchor=2591(,)

# Set the virtual space of the caret of the rectangular selection.
set void SetRectangularSelectionCaretVirtualSpace=2592(position space,)

# Return the virtual space of the caret of the rectangular selection.
get position GetRectangularSelectionCaretVirtualSpace=2593(,)

# Set the virtual space of the anchor of the rectangular selection.
set void SetRectangularSelectionAnchorVirtualSpace=2594(position space,)

# Return the virtual space of the anchor of the rectangular selection.
get position GetRectangularSelectionAnchorVirtualSpace=2595(,)

enu VirtualSpace=SCVS_
val SCVS_NONE=0
val SCVS_RECTANGULARSELECTION=1
val SCVS_USERACCESSIBLE=2
val SCVS_NOWRAPLINESTART=4

ali SCVS_RECTANGULARSELECTION=RECTANGULAR_SELECTION
ali SCVS_USERACCESSIBLE=USER_ACCESSIBLE
ali SCVS_NOWRAPLINESTART=NO_WRAP_LINE_START

# Set options for virtual space behaviour.
set void SetVirtualSpaceOptions=2596(VirtualSpace virtualSpaceOptions,)

# Return options for virtual space behaviour.
get VirtualSpace GetVirtualSpaceOptions=2597(,)

# On GTK, allow selecting the modifier key to use for mouse-based
# rectangular selection. Often the window manager requires Alt+Mouse Drag
# for moving windows.
# Valid values are SCMOD_CTRL(default), SCMOD_ALT, or SCMOD_SUPER.

set void SetRectangularSelectionModifier=2598(int modifier,)

# Get the modifier key used for rectangular selection.
get int GetRectangularSelectionModifier=2599(,)

# Set the foreground colour of additional selections.
# Must have previously called SetSelFore with non-zero first argument for this to have an effect.
set void SetAdditionalSelFore=2600(colour fore,)

# Set the background colour of additional selections.
# Must have previously called SetSelBack with non-zero first argument for this to have an effect.
set void SetAdditionalSelBack=2601(colour back,)

# Set the alpha of the selection.
set void SetAdditionalSelAlpha=2602(Alpha alpha,)

# Get the alpha of the selection.
get Alpha GetAdditionalSelAlpha=2603(,)

# Set the foreground colour of additional carets.
set void SetAdditionalCaretFore=2604(colour fore,)

# Get the foreground colour of additional carets.
get colour GetAdditionalCaretFore=2605(,)

# Set the main selection to the next selection.
fun void RotateSelection=2606(,)

# Swap that caret and anchor of the main selection.
fun void SwapMainAnchorCaret=2607(,)

# Add the next occurrence of the main selection to the set of selections as main.
# If the current selection is empty then select word around caret.
fun void MultipleSelectAddNext=2688(,)

# Add each occurrence of the main selection in the target to the set of selections.
# If the current selection is empty then select word around caret.
fun void MultipleSelectAddEach=2689(,)

# Indicate that the internal state of a lexer has changed over a range and therefore
# there may be a need to redraw.
fun int ChangeLexerState=2617(position start, position end)

# Find the next line at or after lineStart that is a contracted fold header line.
# Return -1 when no more lines.
fun line ContractedFoldNext=2618(line lineStart,)

# Centre current line in window.
fun void VerticalCentreCaret=2619(,)

# Move the selected lines up one line, shifting the line above after the selection
fun void MoveSelectedLinesUp=2620(,)

# Move the selected lines down one line, shifting the line below before the selection
fun void MoveSelectedLinesDown=2621(,)

# Set the identifier reported as idFrom in notification messages.
set void SetIdentifier=2622(int identifier,)

# Get the identifier.
get int GetIdentifier=2623(,)

# Set the width for future RGBA image data.
set void RGBAImageSetWidth=2624(int width,)

# Set the height for future RGBA image data.
set void RGBAImageSetHeight=2625(int height,)

# Set the scale factor in percent for future RGBA image data.
set void RGBAImageSetScale=2651(int scalePercent,)

# Define a marker from RGBA data.
# It has the width and height from RGBAImageSetWidth/Height
fun void MarkerDefineRGBAImage=2626(int markerNumber, string pixels)

# Register an RGBA image for use in autocompletion lists.
# It has the width and height from RGBAImageSetWidth/Height
fun void RegisterRGBAImage=2627(int type, string pixels)

# Scroll to start of document.
fun void ScrollToStart=2628(,)

# Scroll to end of document.
fun void ScrollToEnd=2629(,)

enu Technology=SC_TECHNOLOGY_
val SC_TECHNOLOGY_DEFAULT=0
val SC_TECHNOLOGY_DIRECTWRITE=1
val SC_TECHNOLOGY_DIRECTWRITERETAIN=2
val SC_TECHNOLOGY_DIRECTWRITEDC=3
val SC_TECHNOLOGY_DIRECT_WRITE_1=4

ali SC_TECHNOLOGY_DIRECTWRITE=DIRECT_WRITE
ali SC_TECHNOLOGY_DIRECTWRITERETAIN=DIRECT_WRITE_RETAIN
ali SC_TECHNOLOGY_DIRECTWRITEDC=DIRECT_WRITE_D_C

# Set the technology used.
set void SetTechnology=2630(Technology technology,)

# Get the tech.
get Technology GetTechnology=2631(,)

# Create an ILoader*.
fun pointer CreateLoader=2632(position bytes, DocumentOption documentOptions)

# On macOS, show a find indicator.
fun void FindIndicatorShow=2640(position start, position end)

# On macOS, flash a find indicator, then fade out.
fun void FindIndicatorFlash=2641(position start, position end)

# On macOS, hide the find indicator.
fun void FindIndicatorHide=2642(,)

# Move caret to before first visible character on display line.
# If already there move to first character on display line.
fun void VCHomeDisplay=2652(,)

# Like VCHomeDisplay but extending selection to new caret position.
fun void VCHomeDisplayExtend=2653(,)

# Is the caret line always visible?
get bool GetCaretLineVisibleAlways=2654(,)

# Sets the caret line to always visible.
set void SetCaretLineVisibleAlways=2655(bool alwaysVisible,)

# Line end types which may be used in addition to LF, CR, and CRLF
# SC_LINE_END_TYPE_UNICODE includes U+2028 Line Separator,
# U+2029 Paragraph Separator, and U+0085 Next Line
enu LineEndType=SC_LINE_END_TYPE_
val SC_LINE_END_TYPE_DEFAULT=0
val SC_LINE_END_TYPE_UNICODE=1

# Set the line end types that the application wants to use. May not be used if incompatible with lexer or encoding.
set void SetLineEndTypesAllowed=2656(LineEndType lineEndBitSet,)

# Get the line end types currently allowed.
get LineEndType GetLineEndTypesAllowed=2657(,)

# Get the line end types currently recognised. May be a subset of the allowed types due to lexer limitation.
get LineEndType GetLineEndTypesActive=2658(,)

# Set the way a character is drawn.
set void SetRepresentation=2665(string encodedCharacter, string representation)

# Get the way a character is drawn.
# Result is NUL-terminated.
get int GetRepresentation=2666(string encodedCharacter, stringresult representation)

# Remove a character representation.
fun void ClearRepresentation=2667(string encodedCharacter,)

# Clear representations to default.
fun void ClearAllRepresentations=2770(,)

# Can draw representations in various ways
enu RepresentationAppearance=SC_REPRESENTATION
val SC_REPRESENTATION_PLAIN=0
val SC_REPRESENTATION_BLOB=1
val SC_REPRESENTATION_COLOUR=0x10

# Set the appearance of a representation.
set void SetRepresentationAppearance=2766(string encodedCharacter, RepresentationAppearance appearance)

# Get the appearance of a representation.
get RepresentationAppearance GetRepresentationAppearance=2767(string encodedCharacter,)

# Set the colour of a representation.
set void SetRepresentationColour=2768(string encodedCharacter, colouralpha colour)

# Get the colour of a representation.
get colouralpha GetRepresentationColour=2769(string encodedCharacter,)

# Set the end of line annotation text for a line
set void EOLAnnotationSetText=2740(line line, string text)

# Get the end of line annotation text for a line
get int EOLAnnotationGetText=2741(line line, stringresult text)

# Set the style number for the end of line annotations for a line
set void EOLAnnotationSetStyle=2742(line line, int style)

# Get the style number for the end of line annotations for a line
get int EOLAnnotationGetStyle=2743(line line,)

# Clear the end of annotations from all lines
fun void EOLAnnotationClearAll=2744(,)

enu EOLAnnotationVisible=EOLANNOTATION_
val EOLANNOTATION_HIDDEN=0x0
val EOLANNOTATION_STANDARD=0x1
val EOLANNOTATION_BOXED=0x2
val EOLANNOTATION_STADIUM=0x100
val EOLANNOTATION_FLAT_CIRCLE=0x101
val EOLANNOTATION_ANGLE_CIRCLE=0x102
val EOLANNOTATION_CIRCLE_FLAT=0x110
val EOLANNOTATION_FLATS=0x111
val EOLANNOTATION_ANGLE_FLAT=0x112
val EOLANNOTATION_CIRCLE_ANGLE=0x120
val EOLANNOTATION_FLAT_ANGLE=0x121
val EOLANNOTATION_ANGLES=0x122

# Set the visibility for the end of line annotations for a view
set void EOLAnnotationSetVisible=2745(EOLAnnotationVisible visible,)

# Get the visibility for the end of line annotations for a view
get EOLAnnotationVisible EOLAnnotationGetVisible=2746(,)

# Get the start of the range of style numbers used for end of line annotations
set void EOLAnnotationSetStyleOffset=2747(int style,)

# Get the start of the range of style numbers used for end of line annotations
get int EOLAnnotationGetStyleOffset=2748(,)

enu Supports=SC_SUPPORTS_
val SC_SUPPORTS_LINE_DRAWS_FINAL=0
val SC_SUPPORTS_PIXEL_DIVISIONS=1
val SC_SUPPORTS_FRACTIONAL_STROKE_WIDTH=2
val SC_SUPPORTS_TRANSLUCENT_STROKE=3
val SC_SUPPORTS_PIXEL_MODIFICATION=4
val SC_SUPPORTS_THREAD_SAFE_MEASURE_WIDTHS=5

# Get whether a feature is supported
get bool SupportsFeature=2750(Supports feature,)

enu LineCharacterIndexType=SC_LINECHARACTERINDEX_
val SC_LINECHARACTERINDEX_NONE=0
val SC_LINECHARACTERINDEX_UTF32=1
val SC_LINECHARACTERINDEX_UTF16=2

# Retrieve line character index state.
get LineCharacterIndexType GetLineCharacterIndex=2710(,)

# Request line character index be created or its use count increased.
fun void AllocateLineCharacterIndex=2711(LineCharacterIndexType lineCharacterIndex,)

# Decrease use count of line character index and remove if 0.
fun void ReleaseLineCharacterIndex=2712(LineCharacterIndexType lineCharacterIndex,)

# Retrieve the document line containing a position measured in index units.
fun line LineFromIndexPosition=2713(position pos, LineCharacterIndexType lineCharacterIndex)

# Retrieve the position measured in index units at the start of a document line.
fun position IndexPositionFromLine=2714(line line, LineCharacterIndexType lineCharacterIndex)

# Start notifying the container of all key presses and commands.
fun void StartRecord=3001(,)

# Stop notifying the container of all key presses and commands.
fun void StopRecord=3002(,)

# Retrieve the lexing language of the document.
get int GetLexer=4002(,)

# Colourise a segment of the document using the current lexing language.
fun void Colourise=4003(position start, position end)

# Set up a value that may be used by a lexer for some optional feature.
set void SetProperty=4004(string key, string value)

# Maximum value of keywordSet parameter of SetKeyWords.
val KEYWORDSET_MAX=8

# Set up the key words used by the lexer.
set void SetKeyWords=4005(int keyWordSet, string keyWords)

# Retrieve a "property" value previously set with SetProperty.
# Result is NUL-terminated.
get int GetProperty=4008(string key, stringresult value)

# Retrieve a "property" value previously set with SetProperty,
# with "$()" variable replacement on returned buffer.
# Result is NUL-terminated.
get int GetPropertyExpanded=4009(string key, stringresult value)

# Retrieve a "property" value previously set with SetProperty,
# interpreted as an int AFTER any "$()" variable replacement.
get int GetPropertyInt=4010(string key, int defaultValue)

# Retrieve the name of the lexer.
# Return the length of the text.
# Result is NUL-terminated.
get int GetLexerLanguage=4012(, stringresult language)

# For private communication between an application and a known lexer.
fun pointer PrivateLexerCall=4013(int operation, pointer pointer)

# Retrieve a '\n' separated list of properties understood by the current lexer.
# Result is NUL-terminated.
fun int PropertyNames=4014(, stringresult names)

enu TypeProperty=SC_TYPE_
val SC_TYPE_BOOLEAN=0
val SC_TYPE_INTEGER=1
val SC_TYPE_STRING=2

# Retrieve the type of a property.
fun TypeProperty PropertyType=4015(string name,)

# Describe a property.
# Result is NUL-terminated.
fun int DescribeProperty=4016(string name, stringresult description)

# Retrieve a '\n' separated list of descriptions of the keyword sets understood by the current lexer.
# Result is NUL-terminated.
fun int DescribeKeyWordSets=4017(, stringresult descriptions)

# Bit set of LineEndType enumertion for which line ends beyond the standard
# LF, CR, and CRLF are supported by the lexer.
get LineEndType GetLineEndTypesSupported=4018(,)

# Allocate a set of sub styles for a particular base style, returning start of range
fun int AllocateSubStyles=4020(int styleBase, int numberStyles)

# The starting style number for the sub styles associated with a base style
get int GetSubStylesStart=4021(int styleBase,)

# The number of sub styles associated with a base style
get int GetSubStylesLength=4022(int styleBase,)

# For a sub style, return the base style, else return the argument.
get int GetStyleFromSubStyle=4027(int subStyle,)

# For a secondary style, return the primary style, else return the argument.
get int GetPrimaryStyleFromStyle=4028(int style,)

# Free allocated sub styles
fun void FreeSubStyles=4023(,)

# Set the identifiers that are shown in a particular style
set void SetIdentifiers=4024(int style, string identifiers)

# Where styles are duplicated by a feature such as active/inactive code
# return the distance between the two types.
get int DistanceToSecondaryStyles=4025(,)

# Get the set of base styles that can be extended with sub styles
# Result is NUL-terminated.
get int GetSubStyleBases=4026(, stringresult styles)

# Retrieve the number of named styles for the lexer.
get int GetNamedStyles=4029(,)

# Retrieve the name of a style.
# Result is NUL-terminated.
fun int NameOfStyle=4030(int style, stringresult name)

# Retrieve a ' ' separated list of style tags like "literal quoted string".
# Result is NUL-terminated.
fun int TagsOfStyle=4031(int style, stringresult tags)

# Retrieve a description of a style.
# Result is NUL-terminated.
fun int DescriptionOfStyle=4032(int style, stringresult description)

# Set the lexer from an ILexer*.
set void SetILexer=4033(, pointer ilexer)

# Notifications
# Type of modification and the action which caused the modification.
# These are defined as a bit mask to make it easy to specify which notifications are wanted.
# One bit is set from each of SC_MOD_* and SC_PERFORMED_*.
enu ModificationFlags=SC_MOD_ SC_PERFORMED_ SC_MULTISTEPUNDOREDO SC_LASTSTEPINUNDOREDO SC_MULTILINEUNDOREDO SC_STARTACTION SC_MODEVENTMASKALL
val SC_MOD_NONE=0x0
val SC_MOD_INSERTTEXT=0x1
val SC_MOD_DELETETEXT=0x2
val SC_MOD_CHANGESTYLE=0x4
val SC_MOD_CHANGEFOLD=0x8
val SC_PERFORMED_USER=0x10
val SC_PERFORMED_UNDO=0x20
val SC_PERFORMED_REDO=0x40
val SC_MULTISTEPUNDOREDO=0x80
val SC_LASTSTEPINUNDOREDO=0x100
val SC_MOD_CHANGEMARKER=0x200
val SC_MOD_BEFOREINSERT=0x400
val SC_MOD_BEFOREDELETE=0x800
val SC_MULTILINEUNDOREDO=0x1000
val SC_STARTACTION=0x2000
val SC_MOD_CHANGEINDICATOR=0x4000
val SC_MOD_CHANGELINESTATE=0x8000
val SC_MOD_CHANGEMARGIN=0x10000
val SC_MOD_CHANGEANNOTATION=0x20000
val SC_MOD_CONTAINER=0x40000
val SC_MOD_LEXERSTATE=0x80000
val SC_MOD_INSERTCHECK=0x100000
val SC_MOD_CHANGETABSTOPS=0x200000
val SC_MOD_CHANGEEOLANNOTATION=0x400000
val SC_MODEVENTMASKALL=0x7FFFFF

ali SC_MOD_INSERTTEXT=INSERT_TEXT
ali SC_MOD_DELETETEXT=DELETE_TEXT
ali SC_MOD_CHANGESTYLE=CHANGE_STYLE
ali SC_MOD_CHANGEFOLD=CHANGE_FOLD
ali SC_MULTISTEPUNDOREDO=MULTI_STEP_UNDO_REDO
ali SC_LASTSTEPINUNDOREDO=LAST_STEP_IN_UNDO_REDO
ali SC_MOD_CHANGEMARKER=CHANGE_MARKER
ali SC_MOD_BEFOREINSERT=BEFORE_INSERT
ali SC_MOD_BEFOREDELETE=BEFORE_DELETE
ali SC_MULTILINEUNDOREDO=MULTILINE_UNDO_REDO
ali SC_STARTACTION=START_ACTION
ali SC_MOD_CHANGEINDICATOR=CHANGE_INDICATOR
ali SC_MOD_CHANGELINESTATE=CHANGE_LINE_STATE
ali SC_MOD_CHANGEMARGIN=CHANGE_MARGIN
ali SC_MOD_CHANGEANNOTATION=CHANGE_ANNOTATION
ali SC_MOD_LEXERSTATE=LEXER_STATE
ali SC_MOD_INSERTCHECK=INSERT_CHECK
ali SC_MOD_CHANGETABSTOPS=CHANGE_TAB_STOPS
ali SC_MOD_CHANGEEOLANNOTATION=CHANGE_E_O_L_ANNOTATION
ali SC_MODEVENTMASKALL=EVENT_MASK_ALL

enu Update=SC_UPDATE_
val SC_UPDATE_NONE=0x0
val SC_UPDATE_CONTENT=0x1
val SC_UPDATE_SELECTION=0x2
val SC_UPDATE_V_SCROLL=0x4
val SC_UPDATE_H_SCROLL=0x8

# For compatibility, these go through the COMMAND notification rather than NOTIFY
# and should have had exactly the same values as the EN_* constants.
# Unfortunately the SETFOCUS and KILLFOCUS are flipped over from EN_*
# As clients depend on these constants, this will not be changed.
enu FocusChange=SCEN_
val SCEN_CHANGE=768
val SCEN_SETFOCUS=512
val SCEN_KILLFOCUS=256

# Symbolic key codes and modifier flags.
# ASCII and other printable characters below 256.
# Extended keys above 300.

enu Keys=SCK_
val SCK_DOWN=300
val SCK_UP=301
val SCK_LEFT=302
val SCK_RIGHT=303
val SCK_HOME=304
val SCK_END=305
val SCK_PRIOR=306
val SCK_NEXT=307
val SCK_DELETE=308
val SCK_INSERT=309
val SCK_ESCAPE=7
val SCK_BACK=8
val SCK_TAB=9
val SCK_RETURN=13
val SCK_ADD=310
val SCK_SUBTRACT=311
val SCK_DIVIDE=312
val SCK_WIN=313
val SCK_RWIN=314
val SCK_MENU=315

ali SCK_RWIN=R_WIN

enu KeyMod=SCMOD_
val SCMOD_NORM=0
val SCMOD_SHIFT=1
val SCMOD_CTRL=2
val SCMOD_ALT=4
val SCMOD_SUPER=8
val SCMOD_META=16

enu CompletionMethods=SC_AC_
val SC_AC_FILLUP=1
val SC_AC_DOUBLECLICK=2
val SC_AC_TAB=3
val SC_AC_NEWLINE=4
val SC_AC_COMMAND=5
val SC_AC_SINGLE_CHOICE=6

ali SC_AC_FILLUP=FILL_UP
ali SC_AC_DOUBLECLICK=DOUBLE_CLICK

# characterSource for SCN_CHARADDED
enu CharacterSource=SC_CHARACTERSOURCE_
# Direct input characters.
val SC_CHARACTERSOURCE_DIRECT_INPUT=0
# IME (inline mode) or dead key tentative input characters.
val SC_CHARACTERSOURCE_TENTATIVE_INPUT=1
# IME (either inline or windowed mode) full composited string.
val SC_CHARACTERSOURCE_IME_RESULT=2

# Events

evt void StyleNeeded=2000(int position)
evt void CharAdded=2001(int ch, int characterSource)
evt void SavePointReached=2002(void)
evt void SavePointLeft=2003(void)
evt void ModifyAttemptRO=2004(void)
# GTK Specific to work around focus and accelerator problems:
evt void Key=2005(int ch, int modifiers)
evt void DoubleClick=2006(int modifiers, int position, int line)
evt void UpdateUI=2007(int updated)
evt void Modified=2008(int position, int modificationType, string text, int length, int linesAdded, int line, int foldLevelNow, int foldLevelPrev, int token, int annotationLinesAdded)
evt void MacroRecord=2009(int message, int wParam, int lParam)
evt void MarginClick=2010(int modifiers, int position, int margin)
evt void NeedShown=2011(int position, int length)
evt void Painted=2013(void)
evt void UserListSelection=2014(int listType, string text, int position, int ch, CompletionMethods listCompletionMethod)
evt void URIDropped=2015(string text)
evt void DwellStart=2016(int position, int x, int y)
evt void DwellEnd=2017(int position, int x, int y)
evt void Zoom=2018(void)
evt void HotSpotClick=2019(int modifiers, int position)
evt void HotSpotDoubleClick=2020(int modifiers, int position)
evt void CallTipClick=2021(int position)
evt void AutoCSelection=2022(string text, int position, int ch, CompletionMethods listCompletionMethod)
evt void IndicatorClick=2023(int modifiers, int position)
evt void IndicatorRelease=2024(int modifiers, int position)
evt void AutoCCancelled=2025(void)
evt void AutoCCharDeleted=2026(void)
evt void HotSpotReleaseClick=2027(int modifiers, int position)
evt void FocusIn=2028(void)
evt void FocusOut=2029(void)
evt void AutoCCompleted=2030(string text, int position, int ch, CompletionMethods listCompletionMethod)
evt void MarginRightClick=2031(int modifiers, int position, int margin)
evt void AutoCSelectionChange=2032(int listType, string text, int position)

cat Provisional

enu Bidirectional=SC_BIDIRECTIONAL_
val SC_BIDIRECTIONAL_DISABLED=0
val SC_BIDIRECTIONAL_L2R=1
val SC_BIDIRECTIONAL_R2L=2

# Retrieve bidirectional text display state.
get Bidirectional GetBidirectional=2708(,)

# Set bidirectional text display state.
set void SetBidirectional=2709(Bidirectional bidirectional,)

cat Deprecated

# Divide each styling byte into lexical class bits (default: 5) and indicator
# bits (default: 3). If a lexer requires more than 32 lexical states, then this
# is used to expand the possible states.
set void SetStyleBits=2090(int bits,)

# Retrieve number of bits in style bytes used to hold the lexical state.
get int GetStyleBits=2091(,)

# Retrieve the number of bits the current lexer needs for styling.
get int GetStyleBitsNeeded=4011(,)

# Deprecated in 3.5.5

# Always interpret keyboard input as Unicode
set void SetKeysUnicode=2521(bool keysUnicode,)

# Are keys always interpreted as Unicode?
get bool GetKeysUnicode=2522(,)

# Is drawing done in two phases with backgrounds drawn before foregrounds?
get bool GetTwoPhaseDraw=2283(,)

# In twoPhaseDraw mode, drawing is performed in two phases, first the background
# and then the foreground. This avoids chopping off characters that overlap the next run.
set void SetTwoPhaseDraw=2284(bool twoPhase,)

val INDIC0_MASK=0x20
val INDIC1_MASK=0x40
val INDIC2_MASK=0x80
val INDICS_MASK=0xE0


================================================
FILE: Libraries/scintilla/include/ScintillaCall.h
================================================
// SciTE - Scintilla based Text Editor
/** @file ScintillaCall.h
 ** Interface to calling a Scintilla instance.
 **/
// Copyright 1998-2019 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

/* Most of this file is automatically generated from the Scintilla.iface interface definition
 * file which contains any comments about the definitions. APIFacer.py does the generation. */

#ifndef SCINTILLACALL_H
#define SCINTILLACALL_H

namespace Scintilla {

enum class Message;	// Declare in case ScintillaMessages.h not included

// Declare in case ScintillaStructures.h not included
struct TextRangeFull;
struct TextToFindFull;
struct RangeToFormatFull;

class IDocumentEditable;

using FunctionDirect = intptr_t(*)(intptr_t ptr, unsigned int iMessage, uintptr_t wParam, intptr_t lParam, int *pStatus);

struct Failure {
	Scintilla::Status status;
	explicit Failure(Scintilla::Status status_) noexcept : status(status_) {
	}
};

struct Span {
	// An ordered range
	// end may be less than start when, for example, searching backwards
	Position start;
	Position end;
	explicit Span(Position position) noexcept : start(position), end(position) {
	}
	Span(Position start_, Position end_) noexcept : start(start_), end(end_) {
	}
	Position Length() const noexcept {
		if (end > start)
			return end - start;
		else
			return start - end;
	}
	bool operator==(const Span &other) const noexcept {
		return (other.start == start) && (other.end == end);
	}
};

class ScintillaCall {
	FunctionDirect fn;
	intptr_t ptr;
	intptr_t CallPointer(Message msg, uintptr_t wParam, void *s);
	intptr_t CallString(Message msg, uintptr_t wParam, const char *s);
	std::string CallReturnString(Message msg, uintptr_t wParam);
public:
	Scintilla::Status statusLastCall;
	ScintillaCall() noexcept;
	// All standard methods are fine

	void SetFnPtr(FunctionDirect fn_, intptr_t ptr_) noexcept;
	bool IsValid() const noexcept;
	intptr_t Call(Message msg, uintptr_t wParam=0, intptr_t lParam=0);

	// Common APIs made more structured and type-safe
	Position LineStart(Line line);
	Position LineEnd(Line line);
	Span SelectionSpan();
	Span TargetSpan();
	void SetTarget(Span span);
	void ColouriseAll();
	char CharacterAt(Position position);
	int UnsignedStyleAt(Position position);
	std::string StringOfSpan(Span span);
	std::string StringOfRange(Span span);
	Position ReplaceTarget(std::string_view text);
	Position ReplaceTargetRE(std::string_view text);
	Position ReplaceTargetMinimal(std::string_view text);
	Position SearchInTarget(std::string_view text);
	Span SpanSearchInTarget(std::string_view text);

	// Generated APIs
//++Autogenerated -- start of section automatically generated from Scintilla.iface
//**\(\*\n\)
	void AddText(Position length, const char *text);
	void AddStyledText(Position length, const char *c);
	void InsertText(Position pos, const char *text);
	void ChangeInsertion(Position length, const char *text);
	void ClearAll();
	void DeleteRange(Position start, Position lengthDelete);
	void ClearDocumentStyle();
	Position Length();
	int CharAt(Position pos);
	Position CurrentPos();
	Position Anchor();
	int StyleAt(Position pos);
	int StyleIndexAt(Position pos);
	void Redo();
	void SetUndoCollection(bool collectUndo);
	void SelectAll();
	void SetSavePoint();
	Position GetStyledText(void *tr);
	Position GetStyledTextFull(TextRangeFull *tr);
	bool CanRedo();
	Line MarkerLineFromHandle(int markerHandle);
	void MarkerDeleteHandle(int markerHandle);
	int MarkerHandleFromLine(Line line, int which);
	int MarkerNumberFromLine(Line line, int which);
	bool UndoCollection();
	Scintilla::WhiteSpace ViewWS();
	void SetViewWS(Scintilla::WhiteSpace viewWS);
	Scintilla::TabDrawMode TabDrawMode();
	void SetTabDrawMode(Scintilla::TabDrawMode tabDrawMode);
	Position PositionFromPoint(int x, int y);
	Position PositionFromPointClose(int x, int y);
	void GotoLine(Line line);
	void GotoPos(Position caret);
	void SetAnchor(Position anchor);
	Position GetCurLine(Position length, char *text);
	std::string GetCurLine(Position length);
	Position EndStyled();
	void ConvertEOLs(Scintilla::EndOfLine eolMode);
	Scintilla::EndOfLine EOLMode();
	void SetEOLMode(Scintilla::EndOfLine eolMode);
	void StartStyling(Position start, int unused);
	void SetStyling(Position length, int style);
	bool BufferedDraw();
	void SetBufferedDraw(bool buffered);
	void SetTabWidth(int tabWidth);
	int TabWidth();
	void SetTabMinimumWidth(int pixels);
	int TabMinimumWidth();
	void ClearTabStops(Line line);
	void AddTabStop(Line line, int x);
	int GetNextTabStop(Line line, int x);
	void SetCodePage(int codePage);
	void SetFontLocale(const char *localeName);
	int FontLocale(char *localeName);
	std::string FontLocale();
	Scintilla::IMEInteraction IMEInteraction();
	void SetIMEInteraction(Scintilla::IMEInteraction imeInteraction);
	void MarkerDefine(int markerNumber, Scintilla::MarkerSymbol markerSymbol);
	void MarkerSetFore(int markerNumber, Colour fore);
	void MarkerSetBack(int markerNumber, Colour back);
	void MarkerSetBackSelected(int markerNumber, Colour back);
	void MarkerSetForeTranslucent(int markerNumber, ColourAlpha fore);
	void MarkerSetBackTranslucent(int markerNumber, ColourAlpha back);
	void MarkerSetBackSelectedTranslucent(int markerNumber, ColourAlpha back);
	void MarkerSetStrokeWidth(int markerNumber, int hundredths);
	void MarkerEnableHighlight(bool enabled);
	int MarkerAdd(Line line, int markerNumber);
	void MarkerDelete(Line line, int markerNumber);
	void MarkerDeleteAll(int markerNumber);
	int MarkerGet(Line line);
	Line MarkerNext(Line lineStart, int markerMask);
	Line MarkerPrevious(Line lineStart, int markerMask);
	void MarkerDefinePixmap(int markerNumber, const char *pixmap);
	void MarkerAddSet(Line line, int markerSet);
	void MarkerSetAlpha(int markerNumber, Scintilla::Alpha alpha);
	Scintilla::Layer MarkerGetLayer(int markerNumber);
	void MarkerSetLayer(int markerNumber, Scintilla::Layer layer);
	void SetMarginTypeN(int margin, Scintilla::MarginType marginType);
	Scintilla::MarginType MarginTypeN(int margin);
	void SetMarginWidthN(int margin, int pixelWidth);
	int MarginWidthN(int margin);
	void SetMarginMaskN(int margin, int mask);
	int MarginMaskN(int margin);
	void SetMarginSensitiveN(int margin, bool sensitive);
	bool MarginSensitiveN(int margin);
	void SetMarginCursorN(int margin, Scintilla::CursorShape cursor);
	Scintilla::CursorShape MarginCursorN(int margin);
	void SetMarginBackN(int margin, Colour back);
	Colour MarginBackN(int margin);
	void SetMargins(int margins);
	int Margins();
	void StyleClearAll();
	void StyleSetFore(int style, Colour fore);
	void StyleSetBack(int style, Colour back);
	void StyleSetBold(int style, bool bold);
	void StyleSetItalic(int style, bool italic);
	void StyleSetSize(int style, int sizePoints);
	void StyleSetFont(int style, const char *fontName);
	void StyleSetEOLFilled(int style, bool eolFilled);
	void StyleResetDefault();
	void StyleSetUnderline(int style, bool underline);
	Colour StyleGetFore(int style);
	Colour StyleGetBack(int style);
	bool StyleGetBold(int style);
	bool StyleGetItalic(int style);
	int StyleGetSize(int style);
	int StyleGetFont(int style, char *fontName);
	std::string StyleGetFont(int style);
	bool StyleGetEOLFilled(int style);
	bool StyleGetUnderline(int style);
	Scintilla::CaseVisible StyleGetCase(int style);
	Scintilla::CharacterSet StyleGetCharacterSet(int style);
	bool StyleGetVisible(int style);
	bool StyleGetChangeable(int style);
	bool StyleGetHotSpot(int style);
	void StyleSetCase(int style, Scintilla::CaseVisible caseVisible);
	void StyleSetSizeFractional(int style, int sizeHundredthPoints);
	int StyleGetSizeFractional(int style);
	void StyleSetWeight(int style, Scintilla::FontWeight weight);
	Scintilla::FontWeight StyleGetWeight(int style);
	void StyleSetCharacterSet(int style, Scintilla::CharacterSet characterSet);
	void StyleSetHotSpot(int style, bool hotspot);
	void StyleSetCheckMonospaced(int style, bool checkMonospaced);
	bool StyleGetCheckMonospaced(int style);
	void StyleSetStretch(int style, Scintilla::FontStretch stretch);
	Scintilla::FontStretch StyleGetStretch(int style);
	void StyleSetInvisibleRepresentation(int style, const char *representation);
	int StyleGetInvisibleRepresentation(int style, char *representation);
	std::string StyleGetInvisibleRepresentation(int style);
	void SetElementColour(Scintilla::Element element, ColourAlpha colourElement);
	ColourAlpha ElementColour(Scintilla::Element element);
	void ResetElementColour(Scintilla::Element element);
	bool ElementIsSet(Scintilla::Element element);
	bool ElementAllowsTranslucent(Scintilla::Element element);
	ColourAlpha ElementBaseColour(Scintilla::Element element);
	void SetSelFore(bool useSetting, Colour fore);
	void SetSelBack(bool useSetting, Colour back);
	Scintilla::Alpha SelAlpha();
	void SetSelAlpha(Scintilla::Alpha alpha);
	bool SelEOLFilled();
	void SetSelEOLFilled(bool filled);
	Scintilla::Layer SelectionLayer();
	void SetSelectionLayer(Scintilla::Layer layer);
	Scintilla::Layer CaretLineLayer();
	void SetCaretLineLayer(Scintilla::Layer layer);
	bool CaretLineHighlightSubLine();
	void SetCaretLineHighlightSubLine(bool subLine);
	void SetCaretFore(Colour fore);
	void AssignCmdKey(int keyDefinition, int sciCommand);
	void ClearCmdKey(int keyDefinition);
	void ClearAllCmdKeys();
	void SetStylingEx(Position length, const char *styles);
	void StyleSetVisible(int style, bool visible);
	int CaretPeriod();
	void SetCaretPeriod(int periodMilliseconds);
	void SetWordChars(const char *characters);
	int WordChars(char *characters);
	std::string WordChars();
	void SetCharacterCategoryOptimization(int countCharacters);
	int CharacterCategoryOptimization();
	void BeginUndoAction();
	void EndUndoAction();
	int UndoSequence();
	int UndoActions();
	void SetUndoSavePoint(int action);
	int UndoSavePoint();
	void SetUndoDetach(int action);
	int UndoDetach();
	void SetUndoTentative(int action);
	int UndoTentative();
	void SetUndoCurrent(int action);
	int UndoCurrent();
	void PushUndoActionType(int type, Position pos);
	void ChangeLastUndoActionText(Position length, const char *text);
	int UndoActionType(int action);
	Position UndoActionPosition(int action);
	int UndoActionText(int action, char *text);
	std::string UndoActionText(int action);
	void IndicSetStyle(int indicator, Scintilla::IndicatorStyle indicatorStyle);
	Scintilla::IndicatorStyle IndicGetStyle(int indicator);
	void IndicSetFore(int indicator, Colour fore);
	Colour IndicGetFore(int indicator);
	void IndicSetUnder(int indicator, bool under);
	bool IndicGetUnder(int indicator);
	void IndicSetHoverStyle(int indicator, Scintilla::IndicatorStyle indicatorStyle);
	Scintilla::IndicatorStyle IndicGetHoverStyle(int indicator);
	void IndicSetHoverFore(int indicator, Colour fore);
	Colour IndicGetHoverFore(int indicator);
	void IndicSetFlags(int indicator, Scintilla::IndicFlag flags);
	Scintilla::IndicFlag IndicGetFlags(int indicator);
	void IndicSetStrokeWidth(int indicator, int hundredths);
	int IndicGetStrokeWidth(int indicator);
	void SetWhitespaceFore(bool useSetting, Colour fore);
	void SetWhitespaceBack(bool useSetting, Colour back);
	void SetWhitespaceSize(int size);
	int WhitespaceSize();
	void SetLineState(Line line, int state);
	int LineState(Line line);
	int MaxLineState();
	bool CaretLineVisible();
	void SetCaretLineVisible(bool show);
	Colour CaretLineBack();
	void SetCaretLineBack(Colour back);
	int CaretLineFrame();
	void SetCaretLineFrame(int width);
	void StyleSetChangeable(int style, bool changeable);
	void AutoCShow(Position lengthEntered, const char *itemList);
	void AutoCCancel();
	bool AutoCActive();
	Position AutoCPosStart();
	void AutoCComplete();
	void AutoCStops(const char *characterSet);
	void AutoCSetSeparator(int separatorCharacter);
	int AutoCGetSeparator();
	void AutoCSelect(const char *select);
	void AutoCSetCancelAtStart(bool cancel);
	bool AutoCGetCancelAtStart();
	void AutoCSetFillUps(const char *characterSet);
	void AutoCSetChooseSingle(bool chooseSingle);
	bool AutoCGetChooseSingle();
	void AutoCSetIgnoreCase(bool ignoreCase);
	bool AutoCGetIgnoreCase();
	void UserListShow(int listType, const char *itemList);
	void AutoCSetAutoHide(bool autoHide);
	bool AutoCGetAutoHide();
	void AutoCSetOptions(Scintilla::AutoCompleteOption options);
	Scintilla::AutoCompleteOption AutoCGetOptions();
	void AutoCSetDropRestOfWord(bool dropRestOfWord);
	bool AutoCGetDropRestOfWord();
	void RegisterImage(int type, const char *xpmData);
	void ClearRegisteredImages();
	int AutoCGetTypeSeparator();
	void AutoCSetTypeSeparator(int separatorCharacter);
	void AutoCSetMaxWidth(int characterCount);
	int AutoCGetMaxWidth();
	void AutoCSetMaxHeight(int rowCount);
	int AutoCGetMaxHeight();
	void AutoCSetStyle(int style);
	int AutoCGetStyle();
	void AutoCSetImageScale(int scalePercent);
	int AutoCGetImageScale();
	void SetIndent(int indentSize);
	int Indent();
	void SetUseTabs(bool useTabs);
	bool UseTabs();
	void SetLineIndentation(Line line, int indentation);
	int LineIndentation(Line line);
	Position LineIndentPosition(Line line);
	Position Column(Position pos);
	Position CountCharacters(Position start, Position end);
	Position CountCodeUnits(Position start, Position end);
	void SetHScrollBar(bool visible);
	bool HScrollBar();
	void SetIndentationGuides(Scintilla::IndentView indentView);
	Scintilla::IndentView IndentationGuides();
	void SetHighlightGuide(Position column);
	Position HighlightGuide();
	Position LineEndPosition(Line line);
	int CodePage();
	Colour CaretFore();
	bool ReadOnly();
	void SetCurrentPos(Position caret);
	void SetSelectionStart(Position anchor);
	Position SelectionStart();
	void SetSelectionEnd(Position caret);
	Position SelectionEnd();
	void SetEmptySelection(Position caret);
	void SetPrintMagnification(int magnification);
	int PrintMagnification();
	void SetPrintColourMode(Scintilla::PrintOption mode);
	Scintilla::PrintOption PrintColourMode();
	Position FindText(Scintilla::FindOption searchFlags, void *ft);
	Position FindTextFull(Scintilla::FindOption searchFlags, TextToFindFull *ft);
	Position FormatRange(bool draw, void *fr);
	Position FormatRangeFull(bool draw, RangeToFormatFull *fr);
	void SetChangeHistory(Scintilla::ChangeHistoryOption changeHistory);
	Scintilla::ChangeHistoryOption ChangeHistory();
	void SetUndoSelectionHistory(Scintilla::UndoSelectionHistoryOption undoSelectionHistory);
	Scintilla::UndoSelectionHistoryOption UndoSelectionHistory();
	void SetSelectionSerialized(const char *selectionString);
	Position SelectionSerialized(char *selectionString);
	std::string SelectionSerialized();
	Line FirstVisibleLine();
	Position GetLine(Line line, char *text);
	std::string GetLine(Line line);
	Line LineCount();
	void AllocateLines(Line lines);
	void SetMarginLeft(int pixelWidth);
	int MarginLeft();
	void SetMarginRight(int pixelWidth);
	int MarginRight();
	bool Modify();
	void SetSel(Position anchor, Position caret);
	Position GetSelText(char *text);
	std::string GetSelText();
	Position GetTextRange(void *tr);
	Position GetTextRangeFull(TextRangeFull *tr);
	void HideSelection(bool hide);
	bool SelectionHidden();
	int PointXFromPosition(Position pos);
	int PointYFromPosition(Position pos);
	Line LineFromPosition(Position pos);
	Position PositionFromLine(Line line);
	void LineScroll(Position columns, Line lines);
	void ScrollVertical(Line docLine, Line subLine);
	void ScrollCaret();
	void ScrollRange(Position secondary, Position primary);
	void ReplaceSel(const char *text);
	void SetReadOnly(bool readOnly);
	void Null();
	bool CanPaste();
	bool CanUndo();
	void EmptyUndoBuffer();
	void Undo();
	void Cut();
	void Copy();
	void Paste();
	void Clear();
	void SetText(const char *text);
	Position GetText(Position length, char *text);
	std::string GetText(Position length);
	Position TextLength();
	void *DirectFunction();
	void *DirectStatusFunction();
	void *DirectPointer();
	void SetOvertype(bool overType);
	bool Overtype();
	void SetCaretWidth(int pixelWidth);
	int CaretWidth();
	void SetTargetStart(Position start);
	Position TargetStart();
	void SetTargetStartVirtualSpace(Position space);
	Position TargetStartVirtualSpace();
	void SetTargetEnd(Position end);
	Position TargetEnd();
	void SetTargetEndVirtualSpace(Position space);
	Position TargetEndVirtualSpace();
	void SetTargetRange(Position start, Position end);
	Position TargetText(char *text);
	std::string TargetText();
	void TargetFromSelection();
	void TargetWholeDocument();
	Position ReplaceTarget(Position length, const char *text);
	Position ReplaceTargetRE(Position length, const char *text);
	Position ReplaceTargetMinimal(Position length, const char *text);
	Position SearchInTarget(Position length, const char *text);
	void SetSearchFlags(Scintilla::FindOption searchFlags);
	Scintilla::FindOption SearchFlags();
	void CallTipShow(Position pos, const char *definition);
	void CallTipCancel();
	bool CallTipActive();
	Position CallTipPosStart();
	void CallTipSetPosStart(Position posStart);
	void CallTipSetHlt(Position highlightStart, Position highlightEnd);
	void CallTipSetBack(Colour back);
	void CallTipSetFore(Colour fore);
	void CallTipSetForeHlt(Colour fore);
	void CallTipUseStyle(int tabSize);
	void CallTipSetPosition(bool above);
	Line VisibleFromDocLine(Line docLine);
	Line DocLineFromVisible(Line displayLine);
	Line WrapCount(Line docLine);
	void SetFoldLevel(Line line, Scintilla::FoldLevel level);
	Scintilla::FoldLevel FoldLevel(Line line);
	Line LastChild(Line line, Scintilla::FoldLevel level);
	Line FoldParent(Line line);
	void ShowLines(Line lineStart, Line lineEnd);
	void HideLines(Line lineStart, Line lineEnd);
	bool LineVisible(Line line);
	bool AllLinesVisible();
	void SetFoldExpanded(Line line, bool expanded);
	bool FoldExpanded(Line line);
	void ToggleFold(Line line);
	void ToggleFoldShowText(Line line, const char *text);
	void FoldDisplayTextSetStyle(Scintilla::FoldDisplayTextStyle style);
	Scintilla::FoldDisplayTextStyle FoldDisplayTextGetStyle();
	void SetDefaultFoldDisplayText(const char *text);
	int GetDefaultFoldDisplayText(char *text);
	std::string GetDefaultFoldDisplayText();
	void FoldLine(Line line, Scintilla::FoldAction action);
	void FoldChildren(Line line, Scintilla::FoldAction action);
	void ExpandChildren(Line line, Scintilla::FoldLevel level);
	void FoldAll(Scintilla::FoldAction action);
	void EnsureVisible(Line line);
	void SetAutomaticFold(Scintilla::AutomaticFold automaticFold);
	Scintilla::AutomaticFold AutomaticFold();
	void SetFoldFlags(Scintilla::FoldFlag flags);
	void EnsureVisibleEnforcePolicy(Line line);
	void SetTabIndents(bool tabIndents);
	bool TabIndents();
	void SetBackSpaceUnIndents(bool bsUnIndents);
	bool BackSpaceUnIndents();
	void SetMouseDwellTime(int periodMilliseconds);
	int MouseDwellTime();
	Position WordStartPosition(Position pos, bool onlyWordCharacters);
	Position WordEndPosition(Position pos, bool onlyWordCharacters);
	bool IsRangeWord(Position start, Position end);
	void SetIdleStyling(Scintilla::IdleStyling idleStyling);
	Scintilla::IdleStyling IdleStyling();
	void SetWrapMode(Scintilla::Wrap wrapMode);
	Scintilla::Wrap WrapMode();
	void SetWrapVisualFlags(Scintilla::WrapVisualFlag wrapVisualFlags);
	Scintilla::WrapVisualFlag WrapVisualFlags();
	void SetWrapVisualFlagsLocation(Scintilla::WrapVisualLocation wrapVisualFlagsLocation);
	Scintilla::WrapVisualLocation WrapVisualFlagsLocation();
	void SetWrapStartIndent(int indent);
	int WrapStartIndent();
	void SetWrapIndentMode(Scintilla::WrapIndentMode wrapIndentMode);
	Scintilla::WrapIndentMode WrapIndentMode();
	void SetLayoutCache(Scintilla::LineCache cacheMode);
	Scintilla::LineCache LayoutCache();
	void SetScrollWidth(int pixelWidth);
	int ScrollWidth();
	void SetScrollWidthTracking(bool tracking);
	bool ScrollWidthTracking();
	int TextWidth(int style, const char *text);
	void SetEndAtLastLine(bool endAtLastLine);
	bool EndAtLastLine();
	int TextHeight(Line line);
	void SetVScrollBar(bool visible);
	bool VScrollBar();
	void AppendText(Position length, const char *text);
	Scintilla::PhasesDraw PhasesDraw();
	void SetPhasesDraw(Scintilla::PhasesDraw phases);
	void SetFontQuality(Scintilla::FontQuality fontQuality);
	Scintilla::FontQuality FontQuality();
	void SetFirstVisibleLine(Line displayLine);
	void SetMultiPaste(Scintilla::MultiPaste multiPaste);
	Scintilla::MultiPaste MultiPaste();
	int Tag(int tagNumber, char *tagValue);
	std::string Tag(int tagNumber);
	void LinesJoin();
	void LinesSplit(int pixelWidth);
	void SetFoldMarginColour(bool useSetting, Colour back);
	void SetFoldMarginHiColour(bool useSetting, Colour fore);
	void SetAccessibility(Scintilla::Accessibility accessibility);
	Scintilla::Accessibility Accessibility();
	void LineDown();
	void LineDownExtend();
	void LineUp();
	void LineUpExtend();
	void CharLeft();
	void CharLeftExtend();
	void CharRight();
	void CharRightExtend();
	void WordLeft();
	void WordLeftExtend();
	void WordRight();
	void WordRightExtend();
	void Home();
	void HomeExtend();
	void LineEnd();
	void LineEndExtend();
	void DocumentStart();
	void DocumentStartExtend();
	void DocumentEnd();
	void DocumentEndExtend();
	void PageUp();
	void PageUpExtend();
	void PageDown();
	void PageDownExtend();
	void EditToggleOvertype();
	void Cancel();
	void DeleteBack();
	void Tab();
	void LineIndent();
	void BackTab();
	void LineDedent();
	void NewLine();
	void FormFeed();
	void VCHome();
	void VCHomeExtend();
	void ZoomIn();
	void ZoomOut();
	void DelWordLeft();
	void DelWordRight();
	void DelWordRightEnd();
	void LineCut();
	void LineDelete();
	void LineTranspose();
	void LineReverse();
	void LineDuplicate();
	void LowerCase();
	void UpperCase();
	void LineScrollDown();
	void LineScrollUp();
	void DeleteBackNotLine();
	void HomeDisplay();
	void HomeDisplayExtend();
	void LineEndDisplay();
	void LineEndDisplayExtend();
	void HomeWrap();
	void HomeWrapExtend();
	void LineEndWrap();
	void LineEndWrapExtend();
	void VCHomeWrap();
	void VCHomeWrapExtend();
	void LineCopy();
	void MoveCaretInsideView();
	Position LineLength(Line line);
	void BraceHighlight(Position posA, Position posB);
	void BraceHighlightIndicator(bool useSetting, int indicator);
	void BraceBadLight(Position pos);
	void BraceBadLightIndicator(bool useSetting, int indicator);
	Position BraceMatch(Position pos, int maxReStyle);
	Position BraceMatchNext(Position pos, Position startPos);
	bool ViewEOL();
	void SetViewEOL(bool visible);
	IDocumentEditable *DocPointer();
	void SetDocPointer(IDocumentEditable *doc);
	void SetModEventMask(Scintilla::ModificationFlags eventMask);
	Position EdgeColumn();
	void SetEdgeColumn(Position column);
	Scintilla::EdgeVisualStyle EdgeMode();
	void SetEdgeMode(Scintilla::EdgeVisualStyle edgeMode);
	Colour EdgeColour();
	void SetEdgeColour(Colour edgeColour);
	void MultiEdgeAddLine(Position column, Colour edgeColour);
	void MultiEdgeClearAll();
	Position MultiEdgeColumn(int which);
	void SearchAnchor();
	Position SearchNext(Scintilla::FindOption searchFlags, const char *text);
	Position SearchPrev(Scintilla::FindOption searchFlags, const char *text);
	Line LinesOnScreen();
	void UsePopUp(Scintilla::PopUp popUpMode);
	bool SelectionIsRectangle();
	void SetZoom(int zoomInPoints);
	int Zoom();
	IDocumentEditable *CreateDocument(Position bytes, Scintilla::DocumentOption documentOptions);
	void AddRefDocument(IDocumentEditable *doc);
	void ReleaseDocument(IDocumentEditable *doc);
	Scintilla::DocumentOption DocumentOptions();
	Scintilla::ModificationFlags ModEventMask();
	void SetCommandEvents(bool commandEvents);
	bool CommandEvents();
	void SetFocus(bool focus);
	bool Focus();
	void SetStatus(Scintilla::Status status);
	Scintilla::Status Status();
	void SetMouseDownCaptures(bool captures);
	bool MouseDownCaptures();
	void SetMouseWheelCaptures(bool captures);
	bool MouseWheelCaptures();
	void SetCursor(Scintilla::CursorShape cursorType);
	Scintilla::CursorShape Cursor();
	void SetControlCharSymbol(int symbol);
	int ControlCharSymbol();
	void WordPartLeft();
	void WordPartLeftExtend();
	void WordPartRight();
	void WordPartRightExtend();
	void SetVisiblePolicy(Scintilla::VisiblePolicy visiblePolicy, int visibleSlop);
	void DelLineLeft();
	void DelLineRight();
	void SetXOffset(int xOffset);
	int XOffset();
	void ChooseCaretX();
	void GrabFocus();
	void SetXCaretPolicy(Scintilla::CaretPolicy caretPolicy, int caretSlop);
	void SetYCaretPolicy(Scintilla::CaretPolicy caretPolicy, int caretSlop);
	void SetPrintWrapMode(Scintilla::Wrap wrapMode);
	Scintilla::Wrap PrintWrapMode();
	void SetHotspotActiveFore(bool useSetting, Colour fore);
	Colour HotspotActiveFore();
	void SetHotspotActiveBack(bool useSetting, Colour back);
	Colour HotspotActiveBack();
	void SetHotspotActiveUnderline(bool underline);
	bool HotspotActiveUnderline();
	void SetHotspotSingleLine(bool singleLine);
	bool HotspotSingleLine();
	void ParaDown();
	void ParaDownExtend();
	void ParaUp();
	void ParaUpExtend();
	Position PositionBefore(Position pos);
	Position PositionAfter(Position pos);
	Position PositionRelative(Position pos, Position relative);
	Position PositionRelativeCodeUnits(Position pos, Position relative);
	void CopyRange(Position start, Position end);
	void CopyText(Position length, const char *text);
	void SetSelectionMode(Scintilla::SelectionMode selectionMode);
	void ChangeSelectionMode(Scintilla::SelectionMode selectionMode);
	Scintilla::SelectionMode SelectionMode();
	void SetMoveExtendsSelection(bool moveExtendsSelection);
	bool MoveExtendsSelection();
	Position GetLineSelStartPosition(Line line);
	Position GetLineSelEndPosition(Line line);
	void LineDownRectExtend();
	void LineUpRectExtend();
	void CharLeftRectExtend();
	void CharRightRectExtend();
	void HomeRectExtend();
	void VCHomeRectExtend();
	void LineEndRectExtend();
	void PageUpRectExtend();
	void PageDownRectExtend();
	void StutteredPageUp();
	void StutteredPageUpExtend();
	void StutteredPageDown();
	void StutteredPageDownExtend();
	void WordLeftEnd();
	void WordLeftEndExtend();
	void WordRightEnd();
	void WordRightEndExtend();
	void SetWhitespaceChars(const char *characters);
	int WhitespaceChars(char *characters);
	std::string WhitespaceChars();
	void SetPunctuationChars(const char *characters);
	int PunctuationChars(char *characters);
	std::string PunctuationChars();
	void SetCharsDefault();
	int AutoCGetCurrent();
	int AutoCGetCurrentText(char *text);
	std::string AutoCGetCurrentText();
	void AutoCSetCaseInsensitiveBehaviour(Scintilla::CaseInsensitiveBehaviour behaviour);
	Scintilla::CaseInsensitiveBehaviour AutoCGetCaseInsensitiveBehaviour();
	void AutoCSetMulti(Scintilla::MultiAutoComplete multi);
	Scintilla::MultiAutoComplete AutoCGetMulti();
	void AutoCSetOrder(Scintilla::Ordering order);
	Scintilla::Ordering AutoCGetOrder();
	void Allocate(Position bytes);
	Position TargetAsUTF8(char *s);
	std::string TargetAsUTF8();
	void SetLengthForEncode(Position bytes);
	Position EncodedFromUTF8(const char *utf8, char *encoded);
	std::string EncodedFromUTF8(const char *utf8);
	Position FindColumn(Line line, Position column);
	Scintilla::CaretSticky CaretSticky();
	void SetCaretSticky(Scintilla::CaretSticky useCaretStickyBehaviour);
	void ToggleCaretSticky();
	void SetPasteConvertEndings(bool convert);
	bool PasteConvertEndings();
	void ReplaceRectangular(Position length, const char *text);
	void SelectionDuplicate();
	void SetCaretLineBackAlpha(Scintilla::Alpha alpha);
	Scintilla::Alpha CaretLineBackAlpha();
	void SetCaretStyle(Scintilla::CaretStyle caretStyle);
	Scintilla::CaretStyle CaretStyle();
	void SetIndicatorCurrent(int indicator);
	int IndicatorCurrent();
	void SetIndicatorValue(int value);
	int IndicatorValue();
	void IndicatorFillRange(Position start, Position lengthFill);
	void IndicatorClearRange(Position start, Position lengthClear);
	int IndicatorAllOnFor(Position pos);
	int IndicatorValueAt(int indicator, Position pos);
	Position IndicatorStart(int indicator, Position pos);
	Position IndicatorEnd(int indicator, Position pos);
	void SetPositionCache(int size);
	int PositionCache();
	void SetLayoutThreads(int threads);
	int LayoutThreads();
	void CopyAllowLine();
	void CutAllowLine();
	void SetCopySeparator(const char *separator);
	int CopySeparator(char *separator);
	std::string CopySeparator();
	void *CharacterPointer();
	void *RangePointer(Position start, Position lengthRange);
	Position GapPosition();
	void IndicSetAlpha(int indicator, Scintilla::Alpha alpha);
	Scintilla::Alpha IndicGetAlpha(int indicator);
	void IndicSetOutlineAlpha(int indicator, Scintilla::Alpha alpha);
	Scintilla::Alpha IndicGetOutlineAlpha(int indicator);
	void SetExtraAscent(int extraAscent);
	int ExtraAscent();
	void SetExtraDescent(int extraDescent);
	int ExtraDescent();
	Scintilla::MarkerSymbol MarkerSymbolDefined(int markerNumber);
	void MarginSetText(Line line, const char *text);
	int MarginGetText(Line line, char *text);
	std::string MarginGetText(Line line);
	void MarginSetStyle(Line line, int style);
	int MarginGetStyle(Line line);
	void MarginSetStyles(Line line, const char *styles);
	int MarginGetStyles(Line line, char *styles);
	std::string MarginGetStyles(Line line);
	void MarginTextClearAll();
	void MarginSetStyleOffset(int style);
	int MarginGetStyleOffset();
	void SetMarginOptions(Scintilla::MarginOption marginOptions);
	Scintilla::MarginOption MarginOptions();
	void AnnotationSetText(Line line, const char *text);
	int AnnotationGetText(Line line, char *text);
	std::string AnnotationGetText(Line line);
	void AnnotationSetStyle(Line line, int style);
	int AnnotationGetStyle(Line line);
	void AnnotationSetStyles(Line line, const char *styles);
	int AnnotationGetStyles(Line line, char *styles);
	std::string AnnotationGetStyles(Line line);
	int AnnotationGetLines(Line line);
	void AnnotationClearAll();
	void AnnotationSetVisible(Scintilla::AnnotationVisible visible);
	Scintilla::AnnotationVisible AnnotationGetVisible();
	void AnnotationSetStyleOffset(int style);
	int AnnotationGetStyleOffset();
	void ReleaseAllExtendedStyles();
	int AllocateExtendedStyles(int numberStyles);
	void AddUndoAction(int token, Scintilla::UndoFlags flags);
	Position CharPositionFromPoint(int x, int y);
	Position CharPositionFromPointClose(int x, int y);
	void SetMouseSelectionRectangularSwitch(bool mouseSelectionRectangularSwitch);
	bool MouseSelectionRectangularSwitch();
	void SetMultipleSelection(bool multipleSelection);
	bool MultipleSelection();
	void SetAdditionalSelectionTyping(bool additionalSelectionTyping);
	bool AdditionalSelectionTyping();
	void SetAdditionalCaretsBlink(bool additionalCaretsBlink);
	bool AdditionalCaretsBlink();
	void SetAdditionalCaretsVisible(bool additionalCaretsVisible);
	bool AdditionalCaretsVisible();
	int Selections();
	bool SelectionEmpty();
	void ClearSelections();
	void SetSelection(Position caret, Position anchor);
	void AddSelection(Position caret, Position anchor);
	int SelectionFromPoint(int x, int y);
	void DropSelectionN(int selection);
	void SetMainSelection(int selection);
	int MainSelection();
	void SetSelectionNCaret(int selection, Position caret);
	Position SelectionNCaret(int selection);
	void SetSelectionNAnchor(int selection, Position anchor);
	Position SelectionNAnchor(int selection);
	void SetSelectionNCaretVirtualSpace(int selection, Position space);
	Position SelectionNCaretVirtualSpace(int selection);
	void SetSelectionNAnchorVirtualSpace(int selection, Position space);
	Position SelectionNAnchorVirtualSpace(int selection);
	void SetSelectionNStart(int selection, Position anchor);
	Position SelectionNStart(int selection);
	Position SelectionNStartVirtualSpace(int selection);
	void SetSelectionNEnd(int selection, Position caret);
	Position SelectionNEndVirtualSpace(int selection);
	Position SelectionNEnd(int selection);
	void SetRectangularSelectionCaret(Position caret);
	Position RectangularSelectionCaret();
	void SetRectangularSelectionAnchor(Position anchor);
	Position RectangularSelectionAnchor();
	void SetRectangularSelectionCaretVirtualSpace(Position space);
	Position RectangularSelectionCaretVirtualSpace();
	void SetRectangularSelectionAnchorVirtualSpace(Position space);
	Position RectangularSelectionAnchorVirtualSpace();
	void SetVirtualSpaceOptions(Scintilla::VirtualSpace virtualSpaceOptions);
	Scintilla::VirtualSpace VirtualSpaceOptions();
	void SetRectangularSelectionModifier(int modifier);
	int RectangularSelectionModifier();
	void SetAdditionalSelFore(Colour fore);
	void SetAdditionalSelBack(Colour back);
	void SetAdditionalSelAlpha(Scintilla::Alpha alpha);
	Scintilla::Alpha AdditionalSelAlpha();
	void SetAdditionalCaretFore(Colour fore);
	Colour AdditionalCaretFore();
	void RotateSelection();
	void SwapMainAnchorCaret();
	void MultipleSelectAddNext();
	void MultipleSelectAddEach();
	int ChangeLexerState(Position start, Position end);
	Line ContractedFoldNext(Line lineStart);
	void VerticalCentreCaret();
	void MoveSelectedLinesUp();
	void MoveSelectedLinesDown();
	void SetIdentifier(int identifier);
	int Identifier();
	void RGBAImageSetWidth(int width);
	void RGBAImageSetHeight(int height);
	void RGBAImageSetScale(int scalePercent);
	void MarkerDefineRGBAImage(int markerNumber, const char *pixels);
	void RegisterRGBAImage(int type, const char *pixels);
	void ScrollToStart();
	void ScrollToEnd();
	void SetTechnology(Scintilla::Technology technology);
	Scintilla::Technology Technology();
	void *CreateLoader(Position bytes, Scintilla::DocumentOption documentOptions);
	void FindIndicatorShow(Position start, Position end);
	void FindIndicatorFlash(Position start, Position end);
	void FindIndicatorHide();
	void VCHomeDisplay();
	void VCHomeDisplayExtend();
	bool CaretLineVisibleAlways();
	void SetCaretLineVisibleAlways(bool alwaysVisible);
	void SetLineEndTypesAllowed(Scintilla::LineEndType lineEndBitSet);
	Scintilla::LineEndType LineEndTypesAllowed();
	Scintilla::LineEndType LineEndTypesActive();
	void SetRepresentation(const char *encodedCharacter, const char *representation);
	int Representation(const char *encodedCharacter, char *representation);
	std::string Representation(const char *encodedCharacter);
	void ClearRepresentation(const char *encodedCharacter);
	void ClearAllRepresentations();
	void SetRepresentationAppearance(const char *encodedCharacter, Scintilla::RepresentationAppearance appearance);
	Scintilla::RepresentationAppearance RepresentationAppearance(const char *encodedCharacter);
	void SetRepresentationColour(const char *encodedCharacter, ColourAlpha colour);
	ColourAlpha RepresentationColour(const char *encodedCharacter);
	void EOLAnnotationSetText(Line line, const char *text);
	int EOLAnnotationGetText(Line line, char *text);
	std::string EOLAnnotationGetText(Line line);
	void EOLAnnotationSetStyle(Line line, int style);
	int EOLAnnotationGetStyle(Line line);
	void EOLAnnotationClearAll();
	void EOLAnnotationSetVisible(Scintilla::EOLAnnotationVisible visible);
	Scintilla::EOLAnnotationVisible EOLAnnotationGetVisible();
	void EOLAnnotationSetStyleOffset(int style);
	int EOLAnnotationGetStyleOffset();
	bool SupportsFeature(Scintilla::Supports feature);
	Scintilla::LineCharacterIndexType LineCharacterIndex();
	void AllocateLineCharacterIndex(Scintilla::LineCharacterIndexType lineCharacterIndex);
	void ReleaseLineCharacterIndex(Scintilla::LineCharacterIndexType lineCharacterIndex);
	Line LineFromIndexPosition(Position pos, Scintilla::LineCharacterIndexType lineCharacterIndex);
	Position IndexPositionFromLine(Line line, Scintilla::LineCharacterIndexType lineCharacterIndex);
	void StartRecord();
	void StopRecord();
	int Lexer();
	void Colourise(Position start, Position end);
	void SetProperty(const char *key, const char *value);
	void SetKeyWords(int keyWordSet, const char *keyWords);
	int Property(const char *key, char *value);
	std::string Property(const char *key);
	int PropertyExpanded(const char *key, char *value);
	std::string PropertyExpanded(const char *key);
	int PropertyInt(const char *key, int defaultValue);
	int LexerLanguage(char *language);
	std::string LexerLanguage();
	void *PrivateLexerCall(int operation, void *pointer);
	int PropertyNames(char *names);
	std::string PropertyNames();
	Scintilla::TypeProperty PropertyType(const char *name);
	int DescribeProperty(const char *name, char *description);
	std::string DescribeProperty(const char *name);
	int DescribeKeyWordSets(char *descriptions);
	std::string DescribeKeyWordSets();
	Scintilla::LineEndType LineEndTypesSupported();
	int AllocateSubStyles(int styleBase, int numberStyles);
	int SubStylesStart(int styleBase);
	int SubStylesLength(int styleBase);
	int StyleFromSubStyle(int subStyle);
	int PrimaryStyleFromStyle(int style);
	void FreeSubStyles();
	void SetIdentifiers(int style, const char *identifiers);
	int DistanceToSecondaryStyles();
	int SubStyleBases(char *styles);
	std::string SubStyleBases();
	int NamedStyles();
	int NameOfStyle(int style, char *name);
	std::string NameOfStyle(int style);
	int TagsOfStyle(int style, char *tags);
	std::string TagsOfStyle(int style);
	int DescriptionOfStyle(int style, char *description);
	std::string DescriptionOfStyle(int style);
	void SetILexer(void *ilexer);
	Scintilla::Bidirectional Bidirectional();
	void SetBidirectional(Scintilla::Bidirectional bidirectional);

//--Autogenerated -- end of section automatically generated from Scintilla.iface

};

}

#endif


================================================
FILE: Libraries/scintilla/include/ScintillaMessages.h
================================================
// Scintilla source code edit control
/** @file ScintillaMessages.h
 ** Enumerate the messages that can be sent to Scintilla.
 **/
// Copyright 1998-2019 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

/* Most of this file is automatically generated from the Scintilla.iface interface definition
 * file which contains any comments about the definitions. ScintillaAPIFacer.py does the generation. */

#ifndef SCINTILLAMESSAGES_H
#define SCINTILLAMESSAGES_H

namespace Scintilla {

// Enumerations
//++Autogenerated -- start of section automatically generated from Scintilla.iface
enum class Message {
	AddText = 2001,
	AddStyledText = 2002,
	InsertText = 2003,
	ChangeInsertion = 2672,
	ClearAll = 2004,
	DeleteRange = 2645,
	ClearDocumentStyle = 2005,
	GetLength = 2006,
	GetCharAt = 2007,
	GetCurrentPos = 2008,
	GetAnchor = 2009,
	GetStyleAt = 2010,
	GetStyleIndexAt = 2038,
	Redo = 2011,
	SetUndoCollection = 2012,
	SelectAll = 2013,
	SetSavePoint = 2014,
	GetStyledText = 2015,
	GetStyledTextFull = 2778,
	CanRedo = 2016,
	MarkerLineFromHandle = 2017,
	MarkerDeleteHandle = 2018,
	MarkerHandleFromLine = 2732,
	MarkerNumberFromLine = 2733,
	GetUndoCollection = 2019,
	GetViewWS = 2020,
	SetViewWS = 2021,
	GetTabDrawMode = 2698,
	SetTabDrawMode = 2699,
	PositionFromPoint = 2022,
	PositionFromPointClose = 2023,
	GotoLine = 2024,
	GotoPos = 2025,
	SetAnchor = 2026,
	GetCurLine = 2027,
	GetEndStyled = 2028,
	ConvertEOLs = 2029,
	GetEOLMode = 2030,
	SetEOLMode = 2031,
	StartStyling = 2032,
	SetStyling = 2033,
	GetBufferedDraw = 2034,
	SetBufferedDraw = 2035,
	SetTabWidth = 2036,
	GetTabWidth = 2121,
	SetTabMinimumWidth = 2724,
	GetTabMinimumWidth = 2725,
	ClearTabStops = 2675,
	AddTabStop = 2676,
	GetNextTabStop = 2677,
	SetCodePage = 2037,
	SetFontLocale = 2760,
	GetFontLocale = 2761,
	GetIMEInteraction = 2678,
	SetIMEInteraction = 2679,
	MarkerDefine = 2040,
	MarkerSetFore = 2041,
	MarkerSetBack = 2042,
	MarkerSetBackSelected = 2292,
	MarkerSetForeTranslucent = 2294,
	MarkerSetBackTranslucent = 2295,
	MarkerSetBackSelectedTranslucent = 2296,
	MarkerSetStrokeWidth = 2297,
	MarkerEnableHighlight = 2293,
	MarkerAdd = 2043,
	MarkerDelete = 2044,
	MarkerDeleteAll = 2045,
	MarkerGet = 2046,
	MarkerNext = 2047,
	MarkerPrevious = 2048,
	MarkerDefinePixmap = 2049,
	MarkerAddSet = 2466,
	MarkerSetAlpha = 2476,
	MarkerGetLayer = 2734,
	MarkerSetLayer = 2735,
	SetMarginTypeN = 2240,
	GetMarginTypeN = 2241,
	SetMarginWidthN = 2242,
	GetMarginWidthN = 2243,
	SetMarginMaskN = 2244,
	GetMarginMaskN = 2245,
	SetMarginSensitiveN = 2246,
	GetMarginSensitiveN = 2247,
	SetMarginCursorN = 2248,
	GetMarginCursorN = 2249,
	SetMarginBackN = 2250,
	GetMarginBackN = 2251,
	SetMargins = 2252,
	GetMargins = 2253,
	StyleClearAll = 2050,
	StyleSetFore = 2051,
	StyleSetBack = 2052,
	StyleSetBold = 2053,
	StyleSetItalic = 2054,
	StyleSetSize = 2055,
	StyleSetFont = 2056,
	StyleSetEOLFilled = 2057,
	StyleResetDefault = 2058,
	StyleSetUnderline = 2059,
	StyleGetFore = 2481,
	StyleGetBack = 2482,
	StyleGetBold = 2483,
	StyleGetItalic = 2484,
	StyleGetSize = 2485,
	StyleGetFont = 2486,
	StyleGetEOLFilled = 2487,
	StyleGetUnderline = 2488,
	StyleGetCase = 2489,
	StyleGetCharacterSet = 2490,
	StyleGetVisible = 2491,
	StyleGetChangeable = 2492,
	StyleGetHotSpot = 2493,
	StyleSetCase = 2060,
	StyleSetSizeFractional = 2061,
	StyleGetSizeFractional = 2062,
	StyleSetWeight = 2063,
	StyleGetWeight = 2064,
	StyleSetCharacterSet = 2066,
	StyleSetHotSpot = 2409,
	StyleSetCheckMonospaced = 2254,
	StyleGetCheckMonospaced = 2255,
	StyleSetStretch = 2258,
	StyleGetStretch = 2259,
	StyleSetInvisibleRepresentation = 2256,
	StyleGetInvisibleRepresentation = 2257,
	SetElementColour = 2753,
	GetElementColour = 2754,
	ResetElementColour = 2755,
	GetElementIsSet = 2756,
	GetElementAllowsTranslucent = 2757,
	GetElementBaseColour = 2758,
	SetSelFore = 2067,
	SetSelBack = 2068,
	GetSelAlpha = 2477,
	SetSelAlpha = 2478,
	GetSelEOLFilled = 2479,
	SetSelEOLFilled = 2480,
	GetSelectionLayer = 2762,
	SetSelectionLayer = 2763,
	GetCaretLineLayer = 2764,
	SetCaretLineLayer = 2765,
	GetCaretLineHighlightSubLine = 2773,
	SetCaretLineHighlightSubLine = 2774,
	SetCaretFore = 2069,
	AssignCmdKey = 2070,
	ClearCmdKey = 2071,
	ClearAllCmdKeys = 2072,
	SetStylingEx = 2073,
	StyleSetVisible = 2074,
	GetCaretPeriod = 2075,
	SetCaretPeriod = 2076,
	SetWordChars = 2077,
	GetWordChars = 2646,
	SetCharacterCategoryOptimization = 2720,
	GetCharacterCategoryOptimization = 2721,
	BeginUndoAction = 2078,
	EndUndoAction = 2079,
	GetUndoSequence = 2799,
	GetUndoActions = 2790,
	SetUndoSavePoint = 2791,
	GetUndoSavePoint = 2792,
	SetUndoDetach = 2793,
	GetUndoDetach = 2794,
	SetUndoTentative = 2795,
	GetUndoTentative = 2796,
	SetUndoCurrent = 2797,
	GetUndoCurrent = 2798,
	PushUndoActionType = 2800,
	ChangeLastUndoActionText = 2801,
	GetUndoActionType = 2802,
	GetUndoActionPosition = 2803,
	GetUndoActionText = 2804,
	IndicSetStyle = 2080,
	IndicGetStyle = 2081,
	IndicSetFore = 2082,
	IndicGetFore = 2083,
	IndicSetUnder = 2510,
	IndicGetUnder = 2511,
	IndicSetHoverStyle = 2680,
	IndicGetHoverStyle = 2681,
	IndicSetHoverFore = 2682,
	IndicGetHoverFore = 2683,
	IndicSetFlags = 2684,
	IndicGetFlags = 2685,
	IndicSetStrokeWidth = 2751,
	IndicGetStrokeWidth = 2752,
	SetWhitespaceFore = 2084,
	SetWhitespaceBack = 2085,
	SetWhitespaceSize = 2086,
	GetWhitespaceSize = 2087,
	SetLineState = 2092,
	GetLineState = 2093,
	GetMaxLineState = 2094,
	GetCaretLineVisible = 2095,
	SetCaretLineVisible = 2096,
	GetCaretLineBack = 2097,
	SetCaretLineBack = 2098,
	GetCaretLineFrame = 2704,
	SetCaretLineFrame = 2705,
	StyleSetChangeable = 2099,
	AutoCShow = 2100,
	AutoCCancel = 2101,
	AutoCActive = 2102,
	AutoCPosStart = 2103,
	AutoCComplete = 2104,
	AutoCStops = 2105,
	AutoCSetSeparator = 2106,
	AutoCGetSeparator = 2107,
	AutoCSelect = 2108,
	AutoCSetCancelAtStart = 2110,
	AutoCGetCancelAtStart = 2111,
	AutoCSetFillUps = 2112,
	AutoCSetChooseSingle = 2113,
	AutoCGetChooseSingle = 2114,
	AutoCSetIgnoreCase = 2115,
	AutoCGetIgnoreCase = 2116,
	UserListShow = 2117,
	AutoCSetAutoHide = 2118,
	AutoCGetAutoHide = 2119,
	AutoCSetOptions = 2638,
	AutoCGetOptions = 2639,
	AutoCSetDropRestOfWord = 2270,
	AutoCGetDropRestOfWord = 2271,
	RegisterImage = 2405,
	ClearRegisteredImages = 2408,
	AutoCGetTypeSeparator = 2285,
	AutoCSetTypeSeparator = 2286,
	AutoCSetMaxWidth = 2208,
	AutoCGetMaxWidth = 2209,
	AutoCSetMaxHeight = 2210,
	AutoCGetMaxHeight = 2211,
	AutoCSetStyle = 2109,
	AutoCGetStyle = 2120,
	AutoCSetImageScale = 2815,
	AutoCGetImageScale = 2816,
	SetIndent = 2122,
	GetIndent = 2123,
	SetUseTabs = 2124,
	GetUseTabs = 2125,
	SetLineIndentation = 2126,
	GetLineIndentation = 2127,
	GetLineIndentPosition = 2128,
	GetColumn = 2129,
	CountCharacters = 2633,
	CountCodeUnits = 2715,
	SetHScrollBar = 2130,
	GetHScrollBar = 2131,
	SetIndentationGuides = 2132,
	GetIndentationGuides = 2133,
	SetHighlightGuide = 2134,
	GetHighlightGuide = 2135,
	GetLineEndPosition = 2136,
	GetCodePage = 2137,
	GetCaretFore = 2138,
	GetReadOnly = 2140,
	SetCurrentPos = 2141,
	SetSelectionStart = 2142,
	GetSelectionStart = 2143,
	SetSelectionEnd = 2144,
	GetSelectionEnd = 2145,
	SetEmptySelection = 2556,
	SetPrintMagnification = 2146,
	GetPrintMagnification = 2147,
	SetPrintColourMode = 2148,
	GetPrintColourMode = 2149,
	FindText = 2150,
	FindTextFull = 2196,
	FormatRange = 2151,
	FormatRangeFull = 2777,
	SetChangeHistory = 2780,
	GetChangeHistory = 2781,
	SetUndoSelectionHistory = 2782,
	GetUndoSelectionHistory = 2783,
	SetSelectionSerialized = 2784,
	GetSelectionSerialized = 2785,
	GetFirstVisibleLine = 2152,
	GetLine = 2153,
	GetLineCount = 2154,
	AllocateLines = 2089,
	SetMarginLeft = 2155,
	GetMarginLeft = 2156,
	SetMarginRight = 2157,
	GetMarginRight = 2158,
	GetModify = 2159,
	SetSel = 2160,
	GetSelText = 2161,
	GetTextRange = 2162,
	GetTextRangeFull = 2039,
	HideSelection = 2163,
	GetSelectionHidden = 2088,
	PointXFromPosition = 2164,
	PointYFromPosition = 2165,
	LineFromPosition = 2166,
	PositionFromLine = 2167,
	LineScroll = 2168,
	ScrollVertical = 2817,
	ScrollCaret = 2169,
	ScrollRange = 2569,
	ReplaceSel = 2170,
	SetReadOnly = 2171,
	Null = 2172,
	CanPaste = 2173,
	CanUndo = 2174,
	EmptyUndoBuffer = 2175,
	Undo = 2176,
	Cut = 2177,
	Copy = 2178,
	Paste = 2179,
	Clear = 2180,
	SetText = 2181,
	GetText = 2182,
	GetTextLength = 2183,
	GetDirectFunction = 2184,
	GetDirectStatusFunction = 2772,
	GetDirectPointer = 2185,
	SetOvertype = 2186,
	GetOvertype = 2187,
	SetCaretWidth = 2188,
	GetCaretWidth = 2189,
	SetTargetStart = 2190,
	GetTargetStart = 2191,
	SetTargetStartVirtualSpace = 2728,
	GetTargetStartVirtualSpace = 2729,
	SetTargetEnd = 2192,
	GetTargetEnd = 2193,
	SetTargetEndVirtualSpace = 2730,
	GetTargetEndVirtualSpace = 2731,
	SetTargetRange = 2686,
	GetTargetText = 2687,
	TargetFromSelection = 2287,
	TargetWholeDocument = 2690,
	ReplaceTarget = 2194,
	ReplaceTargetRE = 2195,
	ReplaceTargetMinimal = 2779,
	SearchInTarget = 2197,
	SetSearchFlags = 2198,
	GetSearchFlags = 2199,
	CallTipShow = 2200,
	CallTipCancel = 2201,
	CallTipActive = 2202,
	CallTipPosStart = 2203,
	CallTipSetPosStart = 2214,
	CallTipSetHlt = 2204,
	CallTipSetBack = 2205,
	CallTipSetFore = 2206,
	CallTipSetForeHlt = 2207,
	CallTipUseStyle = 2212,
	CallTipSetPosition = 2213,
	VisibleFromDocLine = 2220,
	DocLineFromVisible = 2221,
	WrapCount = 2235,
	SetFoldLevel = 2222,
	GetFoldLevel = 2223,
	GetLastChild = 2224,
	GetFoldParent = 2225,
	ShowLines = 2226,
	HideLines = 2227,
	GetLineVisible = 2228,
	GetAllLinesVisible = 2236,
	SetFoldExpanded = 2229,
	GetFoldExpanded = 2230,
	ToggleFold = 2231,
	ToggleFoldShowText = 2700,
	FoldDisplayTextSetStyle = 2701,
	FoldDisplayTextGetStyle = 2707,
	SetDefaultFoldDisplayText = 2722,
	GetDefaultFoldDisplayText = 2723,
	FoldLine = 2237,
	FoldChildren = 2238,
	ExpandChildren = 2239,
	FoldAll = 2662,
	EnsureVisible = 2232,
	SetAutomaticFold = 2663,
	GetAutomaticFold = 2664,
	SetFoldFlags = 2233,
	EnsureVisibleEnforcePolicy = 2234,
	SetTabIndents = 2260,
	GetTabIndents = 2261,
	SetBackSpaceUnIndents = 2262,
	GetBackSpaceUnIndents = 2263,
	SetMouseDwellTime = 2264,
	GetMouseDwellTime = 2265,
	WordStartPosition = 2266,
	WordEndPosition = 2267,
	IsRangeWord = 2691,
	SetIdleStyling = 2692,
	GetIdleStyling = 2693,
	SetWrapMode = 2268,
	GetWrapMode = 2269,
	SetWrapVisualFlags = 2460,
	GetWrapVisualFlags = 2461,
	SetWrapVisualFlagsLocation = 2462,
	GetWrapVisualFlagsLocation = 2463,
	SetWrapStartIndent = 2464,
	GetWrapStartIndent = 2465,
	SetWrapIndentMode = 2472,
	GetWrapIndentMode = 2473,
	SetLayoutCache = 2272,
	GetLayoutCache = 2273,
	SetScrollWidth = 2274,
	GetScrollWidth = 2275,
	SetScrollWidthTracking = 2516,
	GetScrollWidthTracking = 2517,
	TextWidth = 2276,
	SetEndAtLastLine = 2277,
	GetEndAtLastLine = 2278,
	TextHeight = 2279,
	SetVScrollBar = 2280,
	GetVScrollBar = 2281,
	AppendText = 2282,
	GetPhasesDraw = 2673,
	SetPhasesDraw = 2674,
	SetFontQuality = 2611,
	GetFontQuality = 2612,
	SetFirstVisibleLine = 2613,
	SetMultiPaste = 2614,
	GetMultiPaste = 2615,
	GetTag = 2616,
	LinesJoin = 2288,
	LinesSplit = 2289,
	SetFoldMarginColour = 2290,
	SetFoldMarginHiColour = 2291,
	SetAccessibility = 2702,
	GetAccessibility = 2703,
	LineDown = 2300,
	LineDownExtend = 2301,
	LineUp = 2302,
	LineUpExtend = 2303,
	CharLeft = 2304,
	CharLeftExtend = 2305,
	CharRight = 2306,
	CharRightExtend = 2307,
	WordLeft = 2308,
	WordLeftExtend = 2309,
	WordRight = 2310,
	WordRightExtend = 2311,
	Home = 2312,
	HomeExtend = 2313,
	LineEnd = 2314,
	LineEndExtend = 2315,
	DocumentStart = 2316,
	DocumentStartExtend = 2317,
	DocumentEnd = 2318,
	DocumentEndExtend = 2319,
	PageUp = 2320,
	PageUpExtend = 2321,
	PageDown = 2322,
	PageDownExtend = 2323,
	EditToggleOvertype = 2324,
	Cancel = 2325,
	DeleteBack = 2326,
	Tab = 2327,
	LineIndent = 2813,
	BackTab = 2328,
	LineDedent = 2814,
	NewLine = 2329,
	FormFeed = 2330,
	VCHome = 2331,
	VCHomeExtend = 2332,
	ZoomIn = 2333,
	ZoomOut = 2334,
	DelWordLeft = 2335,
	DelWordRight = 2336,
	DelWordRightEnd = 2518,
	LineCut = 2337,
	LineDelete = 2338,
	LineTranspose = 2339,
	LineReverse = 2354,
	LineDuplicate = 2404,
	LowerCase = 2340,
	UpperCase = 2341,
	LineScrollDown = 2342,
	LineScrollUp = 2343,
	DeleteBackNotLine = 2344,
	HomeDisplay = 2345,
	HomeDisplayExtend = 2346,
	LineEndDisplay = 2347,
	LineEndDisplayExtend = 2348,
	HomeWrap = 2349,
	HomeWrapExtend = 2450,
	LineEndWrap = 2451,
	LineEndWrapExtend = 2452,
	VCHomeWrap = 2453,
	VCHomeWrapExtend = 2454,
	LineCopy = 2455,
	MoveCaretInsideView = 2401,
	LineLength = 2350,
	BraceHighlight = 2351,
	BraceHighlightIndicator = 2498,
	BraceBadLight = 2352,
	BraceBadLightIndicator = 2499,
	BraceMatch = 2353,
	BraceMatchNext = 2369,
	GetViewEOL = 2355,
	SetViewEOL = 2356,
	GetDocPointer = 2357,
	SetDocPointer = 2358,
	SetModEventMask = 2359,
	GetEdgeColumn = 2360,
	SetEdgeColumn = 2361,
	GetEdgeMode = 2362,
	SetEdgeMode = 2363,
	GetEdgeColour = 2364,
	SetEdgeColour = 2365,
	MultiEdgeAddLine = 2694,
	MultiEdgeClearAll = 2695,
	GetMultiEdgeColumn = 2749,
	SearchAnchor = 2366,
	SearchNext = 2367,
	SearchPrev = 2368,
	LinesOnScreen = 2370,
	UsePopUp = 2371,
	SelectionIsRectangle = 2372,
	SetZoom = 2373,
	GetZoom = 2374,
	CreateDocument = 2375,
	AddRefDocument = 2376,
	ReleaseDocument = 2377,
	GetDocumentOptions = 2379,
	GetModEventMask = 2378,
	SetCommandEvents = 2717,
	GetCommandEvents = 2718,
	SetFocus = 2380,
	GetFocus = 2381,
	SetStatus = 2382,
	GetStatus = 2383,
	SetMouseDownCaptures = 2384,
	GetMouseDownCaptures = 2385,
	SetMouseWheelCaptures = 2696,
	GetMouseWheelCaptures = 2697,
	SetCursor = 2386,
	GetCursor = 2387,
	SetControlCharSymbol = 2388,
	GetControlCharSymbol = 2389,
	WordPartLeft = 2390,
	WordPartLeftExtend = 2391,
	WordPartRight = 2392,
	WordPartRightExtend = 2393,
	SetVisiblePolicy = 2394,
	DelLineLeft = 2395,
	DelLineRight = 2396,
	SetXOffset = 2397,
	GetXOffset = 2398,
	ChooseCaretX = 2399,
	GrabFocus = 2400,
	SetXCaretPolicy = 2402,
	SetYCaretPolicy = 2403,
	SetPrintWrapMode = 2406,
	GetPrintWrapMode = 2407,
	SetHotspotActiveFore = 2410,
	GetHotspotActiveFore = 2494,
	SetHotspotActiveBack = 2411,
	GetHotspotActiveBack = 2495,
	SetHotspotActiveUnderline = 2412,
	GetHotspotActiveUnderline = 2496,
	SetHotspotSingleLine = 2421,
	GetHotspotSingleLine = 2497,
	ParaDown = 2413,
	ParaDownExtend = 2414,
	ParaUp = 2415,
	ParaUpExtend = 2416,
	PositionBefore = 2417,
	PositionAfter = 2418,
	PositionRelative = 2670,
	PositionRelativeCodeUnits = 2716,
	CopyRange = 2419,
	CopyText = 2420,
	SetSelectionMode = 2422,
	ChangeSelectionMode = 2659,
	GetSelectionMode = 2423,
	SetMoveExtendsSelection = 2719,
	GetMoveExtendsSelection = 2706,
	GetLineSelStartPosition = 2424,
	GetLineSelEndPosition = 2425,
	LineDownRectExtend = 2426,
	LineUpRectExtend = 2427,
	CharLeftRectExtend = 2428,
	CharRightRectExtend = 2429,
	HomeRectExtend = 2430,
	VCHomeRectExtend = 2431,
	LineEndRectExtend = 2432,
	PageUpRectExtend = 2433,
	PageDownRectExtend = 2434,
	StutteredPageUp = 2435,
	StutteredPageUpExtend = 2436,
	StutteredPageDown = 2437,
	StutteredPageDownExtend = 2438,
	WordLeftEnd = 2439,
	WordLeftEndExtend = 2440,
	WordRightEnd = 2441,
	WordRightEndExtend = 2442,
	SetWhitespaceChars = 2443,
	GetWhitespaceChars = 2647,
	SetPunctuationChars = 2648,
	GetPunctuationChars = 2649,
	SetCharsDefault = 2444,
	AutoCGetCurrent = 2445,
	AutoCGetCurrentText = 2610,
	AutoCSetCaseInsensitiveBehaviour = 2634,
	AutoCGetCaseInsensitiveBehaviour = 2635,
	AutoCSetMulti = 2636,
	AutoCGetMulti = 2637,
	AutoCSetOrder = 2660,
	AutoCGetOrder = 2661,
	Allocate = 2446,
	TargetAsUTF8 = 2447,
	SetLengthForEncode = 2448,
	EncodedFromUTF8 = 2449,
	FindColumn = 2456,
	GetCaretSticky = 2457,
	SetCaretSticky = 2458,
	ToggleCaretSticky = 2459,
	SetPasteConvertEndings = 2467,
	GetPasteConvertEndings = 2468,
	ReplaceRectangular = 2771,
	SelectionDuplicate = 2469,
	SetCaretLineBackAlpha = 2470,
	GetCaretLineBackAlpha = 2471,
	SetCaretStyle = 2512,
	GetCaretStyle = 2513,
	SetIndicatorCurrent = 2500,
	GetIndicatorCurrent = 2501,
	SetIndicatorValue = 2502,
	GetIndicatorValue = 2503,
	IndicatorFillRange = 2504,
	IndicatorClearRange = 2505,
	IndicatorAllOnFor = 2506,
	IndicatorValueAt = 2507,
	IndicatorStart = 2508,
	IndicatorEnd = 2509,
	SetPositionCache = 2514,
	GetPositionCache = 2515,
	SetLayoutThreads = 2775,
	GetLayoutThreads = 2776,
	CopyAllowLine = 2519,
	CutAllowLine = 2810,
	SetCopySeparator = 2811,
	GetCopySeparator = 2812,
	GetCharacterPointer = 2520,
	GetRangePointer = 2643,
	GetGapPosition = 2644,
	IndicSetAlpha = 2523,
	IndicGetAlpha = 2524,
	IndicSetOutlineAlpha = 2558,
	IndicGetOutlineAlpha = 2559,
	SetExtraAscent = 2525,
	GetExtraAscent = 2526,
	SetExtraDescent = 2527,
	GetExtraDescent = 2528,
	MarkerSymbolDefined = 2529,
	MarginSetText = 2530,
	MarginGetText = 2531,
	MarginSetStyle = 2532,
	MarginGetStyle = 2533,
	MarginSetStyles = 2534,
	MarginGetStyles = 2535,
	MarginTextClearAll = 2536,
	MarginSetStyleOffset = 2537,
	MarginGetStyleOffset = 2538,
	SetMarginOptions = 2539,
	GetMarginOptions = 2557,
	AnnotationSetText = 2540,
	AnnotationGetText = 2541,
	AnnotationSetStyle = 2542,
	AnnotationGetStyle = 2543,
	AnnotationSetStyles = 2544,
	AnnotationGetStyles = 2545,
	AnnotationGetLines = 2546,
	AnnotationClearAll = 2547,
	AnnotationSetVisible = 2548,
	AnnotationGetVisible = 2549,
	AnnotationSetStyleOffset = 2550,
	AnnotationGetStyleOffset = 2551,
	ReleaseAllExtendedStyles = 2552,
	AllocateExtendedStyles = 2553,
	AddUndoAction = 2560,
	CharPositionFromPoint = 2561,
	CharPositionFromPointClose = 2562,
	SetMouseSelectionRectangularSwitch = 2668,
	GetMouseSelectionRectangularSwitch = 2669,
	SetMultipleSelection = 2563,
	GetMultipleSelection = 2564,
	SetAdditionalSelectionTyping = 2565,
	GetAdditionalSelectionTyping = 2566,
	SetAdditionalCaretsBlink = 2567,
	GetAdditionalCaretsBlink = 2568,
	SetAdditionalCaretsVisible = 2608,
	GetAdditionalCaretsVisible = 2609,
	GetSelections = 2570,
	GetSelectionEmpty = 2650,
	ClearSelections = 2571,
	SetSelection = 2572,
	AddSelection = 2573,
	SelectionFromPoint = 2474,
	DropSelectionN = 2671,
	SetMainSelection = 2574,
	GetMainSelection = 2575,
	SetSelectionNCaret = 2576,
	GetSelectionNCaret = 2577,
	SetSelectionNAnchor = 2578,
	GetSelectionNAnchor = 2579,
	SetSelectionNCaretVirtualSpace = 2580,
	GetSelectionNCaretVirtualSpace = 2581,
	SetSelectionNAnchorVirtualSpace = 2582,
	GetSelectionNAnchorVirtualSpace = 2583,
	SetSelectionNStart = 2584,
	GetSelectionNStart = 2585,
	GetSelectionNStartVirtualSpace = 2726,
	SetSelectionNEnd = 2586,
	GetSelectionNEndVirtualSpace = 2727,
	GetSelectionNEnd = 2587,
	SetRectangularSelectionCaret = 2588,
	GetRectangularSelectionCaret = 2589,
	SetRectangularSelectionAnchor = 2590,
	GetRectangularSelectionAnchor = 2591,
	SetRectangularSelectionCaretVirtualSpace = 2592,
	GetRectangularSelectionCaretVirtualSpace = 2593,
	SetRectangularSelectionAnchorVirtualSpace = 2594,
	GetRectangularSelectionAnchorVirtualSpace = 2595,
	SetVirtualSpaceOptions = 2596,
	GetVirtualSpaceOptions = 2597,
	SetRectangularSelectionModifier = 2598,
	GetRectangularSelectionModifier = 2599,
	SetAdditionalSelFore = 2600,
	SetAdditionalSelBack = 2601,
	SetAdditionalSelAlpha = 2602,
	GetAdditionalSelAlpha = 2603,
	SetAdditionalCaretFore = 2604,
	GetAdditionalCaretFore = 2605,
	RotateSelection = 2606,
	SwapMainAnchorCaret = 2607,
	MultipleSelectAddNext = 2688,
	MultipleSelectAddEach = 2689,
	ChangeLexerState = 2617,
	ContractedFoldNext = 2618,
	VerticalCentreCaret = 2619,
	MoveSelectedLinesUp = 2620,
	MoveSelectedLinesDown = 2621,
	SetIdentifier = 2622,
	GetIdentifier = 2623,
	RGBAImageSetWidth = 2624,
	RGBAImageSetHeight = 2625,
	RGBAImageSetScale = 2651,
	MarkerDefineRGBAImage = 2626,
	RegisterRGBAImage = 2627,
	ScrollToStart = 2628,
	ScrollToEnd = 2629,
	SetTechnology = 2630,
	GetTechnology = 2631,
	CreateLoader = 2632,
	FindIndicatorShow = 2640,
	FindIndicatorFlash = 2641,
	FindIndicatorHide = 2642,
	VCHomeDisplay = 2652,
	VCHomeDisplayExtend = 2653,
	GetCaretLineVisibleAlways = 2654,
	SetCaretLineVisibleAlways = 2655,
	SetLineEndTypesAllowed = 2656,
	GetLineEndTypesAllowed = 2657,
	GetLineEndTypesActive = 2658,
	SetRepresentation = 2665,
	GetRepresentation = 2666,
	ClearRepresentation = 2667,
	ClearAllRepresentations = 2770,
	SetRepresentationAppearance = 2766,
	GetRepresentationAppearance = 2767,
	SetRepresentationColour = 2768,
	GetRepresentationColour = 2769,
	EOLAnnotationSetText = 2740,
	EOLAnnotationGetText = 2741,
	EOLAnnotationSetStyle = 2742,
	EOLAnnotationGetStyle = 2743,
	EOLAnnotationClearAll = 2744,
	EOLAnnotationSetVisible = 2745,
	EOLAnnotationGetVisible = 2746,
	EOLAnnotationSetStyleOffset = 2747,
	EOLAnnotationGetStyleOffset = 2748,
	SupportsFeature = 2750,
	GetLineCharacterIndex = 2710,
	AllocateLineCharacterIndex = 2711,
	ReleaseLineCharacterIndex = 2712,
	LineFromIndexPosition = 2713,
	IndexPositionFromLine = 2714,
	StartRecord = 3001,
	StopRecord = 3002,
	GetLexer = 4002,
	Colourise = 4003,
	SetProperty = 4004,
	SetKeyWords = 4005,
	GetProperty = 4008,
	GetPropertyExpanded = 4009,
	GetPropertyInt = 4010,
	GetLexerLanguage = 4012,
	PrivateLexerCall = 4013,
	PropertyNames = 4014,
	PropertyType = 4015,
	DescribeProperty = 4016,
	DescribeKeyWordSets = 4017,
	GetLineEndTypesSupported = 4018,
	AllocateSubStyles = 4020,
	GetSubStylesStart = 4021,
	GetSubStylesLength = 4022,
	GetStyleFromSubStyle = 4027,
	GetPrimaryStyleFromStyle = 4028,
	FreeSubStyles = 4023,
	SetIdentifiers = 4024,
	DistanceToSecondaryStyles = 4025,
	GetSubStyleBases = 4026,
	GetNamedStyles = 4029,
	NameOfStyle = 4030,
	TagsOfStyle = 4031,
	DescriptionOfStyle = 4032,
	SetILexer = 4033,
	GetBidirectional = 2708,
	SetBidirectional = 2709,

	//Au
	SCI_MARGINSTYLENEXT = 9502,
	SCI_SETNOTIFYCALLBACK = 9503,
	SCI_SETANNOTATIONDRAWCALLBACK = 9504,
	SCI_SETMARGINDRAWCALLBACK = 9505,
	SCI_ISXINMARGIN = 9506,
	SCI_DRAGDROP = 9507,
};
//--Autogenerated -- end of section automatically generated from Scintilla.iface

}

#endif


================================================
FILE: Libraries/scintilla/include/ScintillaStructures.h
================================================
// Scintilla source code edit control
/** @file ScintillaStructures.h
 ** Structures used to communicate with Scintilla.
 ** The same structures are defined for C in Scintilla.h.
 ** Uses definitions from ScintillaTypes.h.
 **/
// Copyright 2021 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#ifndef SCINTILLASTRUCTURES_H
#define SCINTILLASTRUCTURES_H

namespace Scintilla {

using PositionCR = long;

struct CharacterRange {
	PositionCR cpMin;
	PositionCR cpMax;
};

struct CharacterRangeFull {
	Position cpMin;
	Position cpMax;
};

struct TextRange {
	CharacterRange chrg;
	char *lpstrText;
};

struct TextRangeFull {
	CharacterRangeFull chrg;
	char *lpstrText;
};

struct TextToFind {
	CharacterRange chrg;
	const char *lpstrText;
	CharacterRange chrgText;
};

struct TextToFindFull {
	CharacterRangeFull chrg;
	const char *lpstrText;
	CharacterRangeFull chrgText;
};

using SurfaceID = void *;

struct Rectangle {
	int left;
	int top;
	int right;
	int bottom;
};

/* This structure is used in printing. Not needed by most client code. */

struct RangeToFormat {
	SurfaceID hdc;
	SurfaceID hdcTarget;
	Rectangle rc;
	Rectangle rcPage;
	CharacterRange chrg;
};

struct RangeToFormatFull {
	SurfaceID hdc;
	SurfaceID hdcTarget;
	Rectangle rc;
	Rectangle rcPage;
	CharacterRangeFull chrg;
};

struct NotifyHeader {
	/* Compatible with Windows NMHDR.
	 * hwndFrom is really an environment specific window handle or pointer
	 * but most clients of Scintilla.h do not have this type visible. */
	void *hwndFrom;
	uptr_t idFrom;
	Notification code;
};

enum class Message;	// Declare in case ScintillaMessages.h not included

struct NotificationData {
	NotifyHeader nmhdr;
	Position position;
	/* SCN_STYLENEEDED, SCN_DOUBLECLICK, SCN_MODIFIED, SCN_MARGINCLICK, */
	/* SCN_MARGINRIGHTCLICK, SCN_NEEDSHOWN, SCN_DWELLSTART, SCN_DWELLEND, */
	/* SCN_CALLTIPCLICK, */
	/* SCN_HOTSPOTCLICK, SCN_HOTSPOTDOUBLECLICK, SCN_HOTSPOTRELEASECLICK, */
	/* SCN_INDICATORCLICK, SCN_INDICATORRELEASE, */
	/* SCN_USERLISTSELECTION, SCN_AUTOCCOMPLETED, SCN_AUTOCSELECTION, */
	/* SCN_AUTOCSELECTIONCHANGE */

	int ch;
	/* SCN_CHARADDED, SCN_KEY, SCN_AUTOCCOMPLETED, SCN_AUTOCSELECTION, */
	/* SCN_USERLISTSELECTION */
	KeyMod modifiers;
	/* SCN_KEY, SCN_DOUBLECLICK, SCN_HOTSPOTCLICK, SCN_HOTSPOTDOUBLECLICK, */
	/* SCN_HOTSPOTRELEASECLICK, SCN_INDICATORCLICK, SCN_INDICATORRELEASE, */
	/* SCN_MARGINCLICK, SCN_MARGINRIGHTCLICK */

	ModificationFlags modificationType;	/* SCN_MODIFIED */
	const char *text;
	/* SCN_MODIFIED, SCN_USERLISTSELECTION, SCN_URIDROPPED, */
	/* SCN_AUTOCCOMPLETED, SCN_AUTOCSELECTION, SCN_AUTOCSELECTIONCHANGE */

	Position length;		/* SCN_MODIFIED */
	Position linesAdded;	/* SCN_MODIFIED */
	Message message;	/* SCN_MACRORECORD */
	uptr_t wParam;	/* SCN_MACRORECORD */
	sptr_t lParam;	/* SCN_MACRORECORD */
	Position line;		/* SCN_MODIFIED */
	FoldLevel foldLevelNow;	/* SCN_MODIFIED */
	FoldLevel foldLevelPrev;	/* SCN_MODIFIED */
	int margin;		/* SCN_MARGINCLICK, SCN_MARGINRIGHTCLICK */
	int listType;	/* SCN_USERLISTSELECTION, SCN_AUTOCSELECTIONCHANGE */
	int x;			/* SCN_DWELLSTART, SCN_DWELLEND */
	int y;		/* SCN_DWELLSTART, SCN_DWELLEND */
	int token;		/* SCN_MODIFIED with SC_MOD_CONTAINER */
	Position annotationLinesAdded;	/* SCN_MODIFIED with SC_MOD_CHANGEANNOTATION */
	Update updated;	/* SCN_UPDATEUI */
	CompletionMethods listCompletionMethod;
	/* SCN_AUTOCSELECTION, SCN_AUTOCCOMPLETED, SCN_USERLISTSELECTION */
	CharacterSource characterSource;	/* SCN_CHARADDED */
};

}

#endif


================================================
FILE: Libraries/scintilla/include/ScintillaTypes.h
================================================
// Scintilla source code edit control
/** @file ScintillaTypes.h
 ** Types used to communicate with Scintilla.
 **/
// Copyright 1998-2019 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

/* Most of this file is automatically generated from the Scintilla.iface interface definition
 * file which contains any comments about the definitions. ScintillaAPIFacer.py does the generation. */

#ifndef SCINTILLATYPES_H
#define SCINTILLATYPES_H

namespace Scintilla {

// Enumerations
//++Autogenerated -- start of section automatically generated from Scintilla.iface

enum class WhiteSpace {
	Invisible = 0,
	VisibleAlways = 1,
	VisibleAfterIndent = 2,
	VisibleOnlyInIndent = 3,
};

enum class TabDrawMode {
	LongArrow = 0,
	StrikeOut = 1,
};

enum class EndOfLine {
	CrLf = 0,
	Cr = 1,
	Lf = 2,
};

enum class IMEInteraction {
	Windowed = 0,
	Inline = 1,
};

enum class Alpha {
	Transparent = 0,
	Opaque = 255,
	NoAlpha = 256,
};

enum class CursorShape {
	Normal = -1,
	Arrow = 2,
	Wait = 4,
	ReverseArrow = 7,
};

enum class MarkerSymbol {
	Circle = 0,
	RoundRect = 1,
	Arrow = 2,
	SmallRect = 3,
	ShortArrow = 4,
	Empty = 5,
	ArrowDown = 6,
	Minus = 7,
	Plus = 8,
	VLine = 9,
	LCorner = 10,
	TCorner = 11,
	BoxPlus = 12,
	BoxPlusConnected = 13,
	BoxMinus = 14,
	BoxMinusConnected = 15,
	LCornerCurve = 16,
	TCornerCurve = 17,
	CirclePlus = 18,
	CirclePlusConnected = 19,
	CircleMinus = 20,
	CircleMinusConnected = 21,
	Background = 22,
	DotDotDot = 23,
	Arrows = 24,
	Pixmap = 25,
	FullRect = 26,
	LeftRect = 27,
	Available = 28,
	Underline = 29,
	RgbaImage = 30,
	Bookmark = 31,
	VerticalBookmark = 32,
	Bar = 33,
	Character = 10000,
};

enum class MarkerOutline {
	HistoryRevertedToOrigin = 21,
	HistorySaved = 22,
	HistoryModified = 23,
	HistoryRevertedToModified = 24,
	FolderEnd = 25,
	FolderOpenMid = 26,
	FolderMidTail = 27,
	FolderTail = 28,
	FolderSub = 29,
	Folder = 30,
	FolderOpen = 31,
};

enum class MarginType {
	Symbol = 0,
	Number = 1,
	Back = 2,
	Fore = 3,
	Text = 4,
	RText = 5,
	Colour = 6,
};

enum class StylesCommon {
	Default = 32,
	LineNumber = 33,
	BraceLight = 34,
	BraceBad = 35,
	ControlChar = 36,
	IndentGuide = 37,
	CallTip = 38,
	FoldDisplayText = 39,
	LastPredefined = 39,
	Max = 255,
};

enum class CharacterSet {
	Ansi = 0,
	Default = 1,
	Baltic = 186,
	ChineseBig5 = 136,
	EastEurope = 238,
	GB2312 = 134,
	Greek = 161,
	Hangul = 129,
	Mac = 77,
	Oem = 255,
	Russian = 204,
	Oem866 = 866,
	Cyrillic = 1251,
	ShiftJis = 128,
	Symbol = 2,
	Turkish = 162,
	Johab = 130,
	Hebrew = 177,
	Arabic = 178,
	Vietnamese = 163,
	Thai = 222,
	Iso8859_15 = 1000,
};

enum class CaseVisible {
	Mixed = 0,
	Upper = 1,
	Lower = 2,
	Camel = 3,
};

enum class FontWeight {
	Normal = 400,
	SemiBold = 600,
	Bold = 700,
};

enum class FontStretch {
	UltraCondensed = 1,
	ExtraCondensed = 2,
	Condensed = 3,
	SemiCondensed = 4,
	Normal = 5,
	SemiExpanded = 6,
	Expanded = 7,
	ExtraExpanded = 8,
	UltraExpanded = 9,
};

enum class Element {
	List = 0,
	ListBack = 1,
	ListSelected = 2,
	ListSelectedBack = 3,
	SelectionText = 10,
	SelectionBack = 11,
	SelectionAdditionalText = 12,
	SelectionAdditionalBack = 13,
	SelectionSecondaryText = 14,
	SelectionSecondaryBack = 15,
	SelectionInactiveText = 16,
	SelectionInactiveBack = 17,
	SelectionInactiveAdditionalText = 18,
	SelectionInactiveAdditionalBack = 19,
	Caret = 40,
	CaretAdditional = 41,
	CaretLineBack = 50,
	WhiteSpace = 60,
	WhiteSpaceBack = 61,
	HotSpotActive = 70,
	HotSpotActiveBack = 71,
	FoldLine = 80,
	HiddenLine = 81,
};

enum class Layer {
	Base = 0,
	UnderText = 1,
	OverText = 2,
};

enum class IndicatorStyle {
	Plain = 0,
	Squiggle = 1,
	TT = 2,
	Diagonal = 3,
	Strike = 4,
	Hidden = 5,
	Box = 6,
	RoundBox = 7,
	StraightBox = 8,
	Dash = 9,
	Dots = 10,
	SquiggleLow = 11,
	DotBox = 12,
	SquigglePixmap = 13,
	CompositionThick = 14,
	CompositionThin = 15,
	FullBox = 16,
	TextFore = 17,
	Point = 18,
	PointCharacter = 19,
	Gradient = 20,
	GradientCentre = 21,
	PointTop = 22,
};

enum class IndicatorNumbers {
	Container = 8,
	Ime = 32,
	ImeMax = 35,
	HistoryRevertedToOriginInsertion = 36,
	HistoryRevertedToOriginDeletion = 37,
	HistorySavedInsertion = 38,
	HistorySavedDeletion = 39,
	HistoryModifiedInsertion = 40,
	HistoryModifiedDeletion = 41,
	HistoryRevertedToModifiedInsertion = 42,
	HistoryRevertedToModifiedDeletion = 43,
	Max = 43,
};

enum class IndicValue {
	Bit = 0x1000000,
	Mask = 0xFFFFFF,
};

enum class IndicFlag {
	None = 0,
	ValueFore = 1,
};

enum class AutoCompleteOption {
	Normal = 0,
	FixedSize = 1,
	SelectFirstItem = 2,
};

enum class IndentView {
	None = 0,
	Real = 1,
	LookForward = 2,
	LookBoth = 3,
};

enum class PrintOption {
	Normal = 0,
	InvertLight = 1,
	BlackOnWhite = 2,
	ColourOnWhite = 3,
	ColourOnWhiteDefaultBG = 4,
	ScreenColours = 5,
};

enum class FindOption {
	None = 0x0,
	WholeWord = 0x2,
	MatchCase = 0x4,
	WordStart = 0x00100000,
	RegExp = 0x00200000,
	Posix = 0x00400000,
	Cxx11RegEx = 0x00800000,
};

enum class ChangeHistoryOption {
	Disabled = 0,
	Enabled = 1,
	Markers = 2,
	Indicators = 4,
};

enum class UndoSelectionHistoryOption {
	Disabled = 0,
	Enabled = 1,
	Scroll = 2,
};

enum class FoldLevel {
	None = 0x0,
	Base = 0x400,
	WhiteFlag = 0x1000,
	HeaderFlag = 0x2000,
	NumberMask = 0x0FFF,
};

enum class FoldDisplayTextStyle {
	Hidden = 0,
	Standard = 1,
	Boxed = 2,
};

enum class FoldAction {
	Contract = 0,
	Expand = 1,
	Toggle = 2,
	ContractEveryLevel = 4,
};

enum class AutomaticFold {
	None = 0x0000,
	Show = 0x0001,
	Click = 0x0002,
	Change = 0x0004,
};

enum class FoldFlag {
	None = 0x0000,
	LineBeforeExpanded = 0x0002,
	LineBeforeContracted = 0x0004,
	LineAfterExpanded = 0x0008,
	LineAfterContracted = 0x0010,
	LevelNumbers = 0x0040,
	LineState = 0x0080,
};

enum class IdleStyling {
	None = 0,
	ToVisible = 1,
	AfterVisible = 2,
	All = 3,
};

enum class Wrap {
	None = 0,
	Word = 1,
	Char = 2,
	WhiteSpace = 3,
};

enum class WrapVisualFlag {
	None = 0x0000,
	End = 0x0001,
	Start = 0x0002,
	Margin = 0x0004,
};

enum class WrapVisualLocation {
	Default = 0x0000,
	EndByText = 0x0001,
	StartByText = 0x0002,
};

enum class WrapIndentMode {
	Fixed = 0,
	Same = 1,
	Indent = 2,
	DeepIndent = 3,
};

enum class LineCache {
	None = 0,
	Caret = 1,
	Page = 2,
	Document = 3,
};

enum class PhasesDraw {
	One = 0,
	Two = 1,
	Multiple = 2,
};

enum class FontQuality {
	QualityMask = 0xF,
	QualityDefault = 0,
	QualityNonAntialiased = 1,
	QualityAntialiased = 2,
	QualityLcdOptimized = 3,
};

enum class MultiPaste {
	Once = 0,
	Each = 1,
};

enum class Accessibility {
	Disabled = 0,
	Enabled = 1,
};

enum class EdgeVisualStyle {
	None = 0,
	Line = 1,
	Background = 2,
	MultiLine = 3,
};

enum class PopUp {
	Never = 0,
	All = 1,
	Text = 2,
};

enum class DocumentOption {
	Default = 0,
	StylesNone = 0x1,
	TextLarge = 0x100,
};

enum class Status {
	Ok = 0,
	Failure = 1,
	BadAlloc = 2,
	WarnStart = 1000,
	RegEx = 1001,
};

enum class VisiblePolicy {
	Slop = 0x01,
	Strict = 0x04,
};

enum class CaretPolicy {
	Slop = 0x01,
	Strict = 0x04,
	Jumps = 0x10,
	Even = 0x08,
};

enum class SelectionMode {
	Stream = 0,
	Rectangle = 1,
	Lines = 2,
	Thin = 3,
};

enum class CaseInsensitiveBehaviour {
	RespectCase = 0,
	IgnoreCase = 1,
};

enum class MultiAutoComplete {
	Once = 0,
	Each = 1,
};

enum class Ordering {
	PreSorted = 0,
	PerformSort = 1,
	Custom = 2,
};

enum class CaretSticky {
	Off = 0,
	On = 1,
	WhiteSpace = 2,
};

enum class CaretStyle {
	Invisible = 0,
	Line = 1,
	Block = 2,
	OverstrikeBar = 0,
	OverstrikeBlock = 0x10,
	Curses = 0x20,
	InsMask = 0xF,
	BlockAfter = 0x100,
};

enum class MarginOption {
	None = 0,
	SubLineSelect = 1,
};

enum class AnnotationVisible {
	Hidden = 0,
	Standard = 1,
	Boxed = 2,
	Indented = 3,
};

enum class UndoFlags {
	None = 0,
	MayCoalesce = 1,
};

enum class VirtualSpace {
	None = 0,
	RectangularSelection = 1,
	UserAccessible = 2,
	NoWrapLineStart = 4,
};

enum class Technology {
	Default = 0,
	DirectWrite = 1,
	DirectWriteRetain = 2,
	DirectWriteDC = 3,
	DirectWrite1 = 4,
};

enum class LineEndType {
	//Default = 0,
	Default = 1, //Au
	Unicode = 1,
};

enum class RepresentationAppearance {
	Plain = 0,
	Blob = 1,
	Colour = 0x10,
};

enum class EOLAnnotationVisible {
	Hidden = 0x0,
	Standard = 0x1,
	Boxed = 0x2,
	Stadium = 0x100,
	FlatCircle = 0x101,
	AngleCircle = 0x102,
	CircleFlat = 0x110,
	Flats = 0x111,
	AngleFlat = 0x112,
	CircleAngle = 0x120,
	FlatAngle = 0x121,
	Angles = 0x122,
};

enum class Supports {
	LineDrawsFinal = 0,
	PixelDivisions = 1,
	FractionalStrokeWidth = 2,
	TranslucentStroke = 3,
	PixelModification = 4,
	ThreadSafeMeasureWidths = 5,
};

enum class LineCharacterIndexType {
	None = 0,
	Utf32 = 1,
	Utf16 = 2,
};

enum class TypeProperty {
	Boolean = 0,
	Integer = 1,
	String = 2,
};

enum class ModificationFlags {
	None = 0x0,
	InsertText = 0x1,
	DeleteText = 0x2,
	ChangeStyle = 0x4,
	ChangeFold = 0x8,
	User = 0x10,
	Undo = 0x20,
	Redo = 0x40,
	MultiStepUndoRedo = 0x80,
	LastStepInUndoRedo = 0x100,
	ChangeMarker = 0x200,
	BeforeInsert = 0x400,
	BeforeDelete = 0x800,
	MultilineUndoRedo = 0x1000,
	StartAction = 0x2000,
	ChangeIndicator = 0x4000,
	ChangeLineState = 0x8000,
	ChangeMargin = 0x10000,
	ChangeAnnotation = 0x20000,
	Container = 0x40000,
	LexerState = 0x80000,
	InsertCheck = 0x100000,
	ChangeTabStops = 0x200000,
	ChangeEOLAnnotation = 0x400000,
	EventMaskAll = 0x7FFFFF,
};

enum class Update {
	None = 0x0,
	Content = 0x1,
	Selection = 0x2,
	VScroll = 0x4,
	HScroll = 0x8,
};

enum class FocusChange {
	Change = 768,
	Setfocus = 512,
	Killfocus = 256,
};

enum class Keys {
	Down = 300,
	Up = 301,
	Left = 302,
	Right = 303,
	Home = 304,
	End = 305,
	Prior = 306,
	Next = 307,
	Delete = 308,
	Insert = 309,
	Escape = 7,
	Back = 8,
	Tab = 9,
	Return = 13,
	Add = 310,
	Subtract = 311,
	Divide = 312,
	Win = 313,
	RWin = 314,
	Menu = 315,
};

enum class KeyMod {
	Norm = 0,
	Shift = 1,
	Ctrl = 2,
	Alt = 4,
	Super = 8,
	Meta = 16,
};

enum class CompletionMethods {
	FillUp = 1,
	DoubleClick = 2,
	Tab = 3,
	Newline = 4,
	Command = 5,
	SingleChoice = 6,
};

enum class CharacterSource {
	DirectInput = 0,
	TentativeInput = 1,
	ImeResult = 2,
};

enum class Bidirectional {
	Disabled = 0,
	L2R = 1,
	R2L = 2,
};

enum class Notification {
	StyleNeeded = 2000,
	CharAdded = 2001,
	SavePointReached = 2002,
	SavePointLeft = 2003,
	ModifyAttemptRO = 2004,
	Key = 2005,
	DoubleClick = 2006,
	UpdateUI = 2007,
	Modified = 2008,
	MacroRecord = 2009,
	MarginClick = 2010,
	NeedShown = 2011,
	Painted = 2013,
	UserListSelection = 2014,
	URIDropped = 2015,
	DwellStart = 2016,
	DwellEnd = 2017,
	Zoom = 2018,
	HotSpotClick = 2019,
	HotSpotDoubleClick = 2020,
	CallTipClick = 2021,
	AutoCSelection = 2022,
	IndicatorClick = 2023,
	IndicatorRelease = 2024,
	AutoCCancelled = 2025,
	AutoCCharDeleted = 2026,
	HotSpotReleaseClick = 2027,
	FocusIn = 2028,
	FocusOut = 2029,
	AutoCCompleted = 2030,
	MarginRightClick = 2031,
	AutoCSelectionChange = 2032,
};
//--Autogenerated -- end of section automatically generated from Scintilla.iface

using Position = intptr_t;
using Line = intptr_t;
using Colour = int;
using ColourAlpha = int;
using uptr_t = uintptr_t;
using sptr_t = intptr_t;

//++Autogenerated -- start of section automatically generated from Scintilla.iface
//**1 \(\*\n\)
constexpr Position InvalidPosition = -1;
constexpr int CpUtf8 = 65001;
constexpr int MarkerMax = 31;
constexpr int MaskHistory = 0x01E00000;
constexpr int MaskFolders = 0xFE000000;
constexpr int MaxMargin = 4;
constexpr int FontSizeMultiplier = 100;
constexpr int TimeForever = 10000000;
constexpr int KeywordsetMax = 8;

//--Autogenerated -- end of section automatically generated from Scintilla.iface

constexpr int IndicatorMax = static_cast<int>(IndicatorNumbers::Max);

// Functions to manipulate fields from a MarkerOutline

inline int operator<<(int i, MarkerOutline marker) noexcept {
	return i << static_cast<int>(marker);
}

// Functions to manipulate fields from a FindOption

constexpr FindOption operator|(FindOption a, FindOption b) noexcept {
	return static_cast<FindOption>(static_cast<int>(a) | static_cast<int>(b));
}

inline FindOption &operator|=(FindOption &self, FindOption a) noexcept {
	self = self | a;
	return self;
}

// Functions to retrieve and manipulate fields from a FoldLevel

constexpr FoldLevel operator&(FoldLevel lhs, FoldLevel rhs) noexcept {
	return static_cast<FoldLevel>(static_cast<int>(lhs) & static_cast<int>(rhs));
}

constexpr FoldLevel LevelNumberPart(FoldLevel level) noexcept {
	return level & FoldLevel::NumberMask;
}

constexpr int LevelNumber(FoldLevel level) noexcept {
	return static_cast<int>(LevelNumberPart(level));
}

constexpr bool LevelIsHeader(FoldLevel level) noexcept {
	return (level & FoldLevel::HeaderFlag) == FoldLevel::HeaderFlag;
}

constexpr bool LevelIsWhitespace(FoldLevel level) noexcept {
	return (level & FoldLevel::WhiteFlag) == FoldLevel::WhiteFlag;
}

// Functions to manipulate fields from a FoldFlag

constexpr FoldFlag operator|(FoldFlag a, FoldFlag b) noexcept {
	return static_cast<FoldFlag>(static_cast<int>(a) | static_cast<int>(b));
}

// Functions to manipulate fields from a FontQuality

constexpr FontQuality operator&(FontQuality a, FontQuality b) noexcept {
	return static_cast<FontQuality>(static_cast<int>(a) & static_cast<int>(b));
}

// Functions to manipulate fields from a DocumentOption

constexpr DocumentOption operator|(DocumentOption a, DocumentOption b) noexcept {
	return static_cast<DocumentOption>(static_cast<int>(a) | static_cast<int>(b));
}

// Functions to manipulate fields from a CaretPolicy

constexpr CaretPolicy operator|(CaretPolicy a, CaretPolicy b) noexcept {
	return static_cast<CaretPolicy>(static_cast<int>(a) | static_cast<int>(b));
}

// Functions to manipulate fields from a CaretStyle

constexpr CaretStyle operator|(CaretStyle a, CaretStyle b) noexcept {
	return static_cast<CaretStyle>(static_cast<int>(a) | static_cast<int>(b));
}

constexpr CaretStyle operator&(CaretStyle a, CaretStyle b) noexcept {
	return static_cast<CaretStyle>(static_cast<int>(a) & static_cast<int>(b));
}

// Functions to manipulate fields from a LineEndType

constexpr LineEndType operator&(LineEndType a, LineEndType b) noexcept {
	return static_cast<LineEndType>(static_cast<int>(a) & static_cast<int>(b));
}

// Functions to manipulate fields from a RepresentationAppearance

constexpr RepresentationAppearance operator|(RepresentationAppearance a, RepresentationAppearance b) noexcept {
	return static_cast<RepresentationAppearance>(static_cast<int>(a) | static_cast<int>(b));
}

// Functions to manipulate fields from a LineCharacterIndexType

constexpr LineCharacterIndexType operator|(LineCharacterIndexType a, LineCharacterIndexType b) noexcept {
	return static_cast<LineCharacterIndexType>(static_cast<int>(a) | static_cast<int>(b));
}

// Functions to manipulate fields from a ModificationFlags

constexpr ModificationFlags operator|(ModificationFlags a, ModificationFlags b) noexcept {
	return static_cast<ModificationFlags>(static_cast<int>(a) | static_cast<int>(b));
}

constexpr ModificationFlags operator&(ModificationFlags a, ModificationFlags b) noexcept {
	return static_cast<ModificationFlags>(static_cast<int>(a) & static_cast<int>(b));
}

inline ModificationFlags &operator|=(ModificationFlags &self, ModificationFlags a) noexcept {
	self = self | a;
	return self;
}

// Functions to manipulate fields from a Update

constexpr Update operator|(Update a, Update b) noexcept {
	return static_cast<Update>(static_cast<int>(a) | static_cast<int>(b));
}

// Functions to manipulate fields from a KeyMod

constexpr KeyMod operator|(KeyMod a, KeyMod b) noexcept {
	return static_cast<KeyMod>(static_cast<int>(a) | static_cast<int>(b));
}

constexpr KeyMod operator&(KeyMod a, KeyMod b) noexcept {
	return static_cast<KeyMod>(static_cast<int>(a) & static_cast<int>(b));
}

constexpr KeyMod ModifierFlags(bool shift, bool ctrl, bool alt, bool meta=false, bool super=false) noexcept {
	return
		(shift ? KeyMod::Shift : KeyMod::Norm) |
		(ctrl ? KeyMod::Ctrl : KeyMod::Norm) |
		(alt ? KeyMod::Alt : KeyMod::Norm) |
		(meta ? KeyMod::Meta : KeyMod::Norm) |
		(super ? KeyMod::Super : KeyMod::Norm);
}

// Test if an enum class value has some bit flag(s) of test set.
template <typename T>
constexpr bool FlagSet(T value, T test) {
	return (static_cast<int>(value) & static_cast<int>(test)) != 0;
}

//Au

typedef void(__stdcall* Sci_NotifyCallback)(void* cbParam, struct NotificationData& n);

struct _RECT { int left, top, right, bottom; };

struct Sci_AnnotationDrawCallbackData
{
	int step; void* hdc; _RECT rect; const char* text; int textLen, line, annotLine;
};
typedef int(__stdcall* Sci_AnnotationDrawCallback)(void* cbParam, Sci_AnnotationDrawCallbackData& c);

struct Sci_MarginDrawCallbackData
{
	void* hdc; _RECT rect; int margin, firstLine, lastLine;
};
typedef void(__stdcall* Sci_MarginDrawCallback)(Sci_MarginDrawCallbackData& c);

struct Sci_DragDropData
{
	int x, y;
	char* text;
	int len;
	int copy; //bool
};

}

#endif


================================================
FILE: Libraries/scintilla/include/ScintillaWidget.h
================================================
/* Scintilla source code edit control */
/* @file ScintillaWidget.h
 * Definition of Scintilla widget for GTK+.
 * Only needed by GTK+ code but is harmless on other platforms.
 * This comment is not a doc-comment as that causes warnings from g-ir-scanner.
 */
/* Copyright 1998-2001 by Neil Hodgson <neilh@scintilla.org>
 * The License.txt file describes the conditions under which this software may be distributed. */

#ifndef SCINTILLAWIDGET_H
#define SCINTILLAWIDGET_H

#if defined(GTK)

#ifdef __cplusplus
extern "C" {
#endif

#define SCINTILLA(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, scintilla_get_type (), ScintillaObject)
#define SCINTILLA_CLASS(klass)  G_TYPE_CHECK_CLASS_CAST (klass, scintilla_get_type (), ScintillaClass)
#define IS_SCINTILLA(obj)       G_TYPE_CHECK_INSTANCE_TYPE (obj, scintilla_get_type ())

#define SCINTILLA_TYPE_OBJECT             (scintilla_object_get_type())
#define SCINTILLA_OBJECT(obj)             (G_TYPE_CHECK_INSTANCE_CAST((obj), SCINTILLA_TYPE_OBJECT, ScintillaObject))
#define SCINTILLA_IS_OBJECT(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SCINTILLA_TYPE_OBJECT))
#define SCINTILLA_OBJECT_CLASS(klass)     (G_TYPE_CHECK_CLASS_CAST((klass), SCINTILLA_TYPE_OBJECT, ScintillaObjectClass))
#define SCINTILLA_IS_OBJECT_CLASS(klass)  (G_TYPE_CHECK_CLASS_TYPE((klass), SCINTILLA_TYPE_OBJECT))
#define SCINTILLA_OBJECT_GET_CLASS(obj)   (G_TYPE_INSTANCE_GET_CLASS((obj), SCINTILLA_TYPE_OBJECT, ScintillaObjectClass))

typedef struct _ScintillaObject ScintillaObject;
typedef struct _ScintillaClass  ScintillaObjectClass;

struct _ScintillaObject {
	GtkContainer cont;
	void *pscin;
};

struct _ScintillaClass {
	GtkContainerClass parent_class;

	void (* command) (ScintillaObject *sci, int cmd, GtkWidget *window);
	void (* notify) (ScintillaObject *sci, int id, SCNotification *scn);
};

GType		scintilla_object_get_type		(void);
GtkWidget*	scintilla_object_new			(void);
gintptr		scintilla_object_send_message	(ScintillaObject *sci, unsigned int iMessage, guintptr wParam, gintptr lParam);


GType		scnotification_get_type			(void);
#define SCINTILLA_TYPE_NOTIFICATION        (scnotification_get_type())

#ifndef G_IR_SCANNING
/* The legacy names confuse the g-ir-scanner program */
typedef struct _ScintillaClass  ScintillaClass;

GType		scintilla_get_type	(void);
GtkWidget*	scintilla_new		(void);
void		scintilla_set_id	(ScintillaObject *sci, uptr_t id);
sptr_t		scintilla_send_message	(ScintillaObject *sci,unsigned int iMessage, uptr_t wParam, sptr_t lParam);
void		scintilla_release_resources(void);
#endif

#define SCINTILLA_NOTIFY "sci-notify"

#ifdef __cplusplus
}
#endif

#endif

#endif


================================================
FILE: Libraries/scintilla/include/scintilla.h
================================================
/* Scintilla source code edit control */
/** @file Scintilla.h
 ** Interface to the edit control.
 **/
/* Copyright 1998-2003 by Neil Hodgson <neilh@scintilla.org>
 * The License.txt file describes the conditions under which this software may be distributed. */

/* Most of this file is automatically generated from the Scintilla.iface interface definition
 * file which contains any comments about the definitions. HFacer.py does the generation. */

#ifndef SCINTILLA_H
#define SCINTILLA_H

#ifdef __cplusplus
extern "C" {
#endif

#if defined(_WIN32)
/* Return false on failure: */
int Scintilla_RegisterClasses(void *hInstance);
int Scintilla_ReleaseResources(void);
#endif

#ifdef __cplusplus
}
#endif

// Include header that defines basic numeric types.
#include <stdint.h>

// Define uptr_t, an unsigned integer type large enough to hold a pointer.
typedef uintptr_t uptr_t;
// Define sptr_t, a signed integer large enough to hold a pointer.
typedef intptr_t sptr_t;

#include "Sci_Position.h"

typedef sptr_t (*SciFnDirect)(sptr_t ptr, unsigned int iMessage, uptr_t wParam, sptr_t lParam);
typedef sptr_t (*SciFnDirectStatus)(sptr_t ptr, unsigned int iMessage, uptr_t wParam, sptr_t lParam, int *pStatus);

#ifndef SCI_DISABLE_AUTOGENERATED

/* ++Autogenerated -- start of section automatically generated from Scintilla.iface */
#define INVALID_POSITION -1
#define SCI_START 2000
#define SCI_OPTIONAL_START 3000
#define SCI_LEXER_START 4000
#define SCI_ADDTEXT 2001
#define SCI_ADDSTYLEDTEXT 2002
#define SCI_INSERTTEXT 2003
#define SCI_CHANGEINSERTION 2672
#define SCI_CLEARALL 2004
#define SCI_DELETERANGE 2645
#define SCI_CLEARDOCUMENTSTYLE 2005
#define SCI_GETLENGTH 2006
#define SCI_GETCHARAT 2007
#define SCI_GETCURRENTPOS 2008
#define SCI_GETANCHOR 2009
#define SCI_GETSTYLEAT 2010
#define SCI_GETSTYLEINDEXAT 2038
#define SCI_REDO 2011
#define SCI_SETUNDOCOLLECTION 2012
#define SCI_SELECTALL 2013
#define SCI_SETSAVEPOINT 2014
#define SCI_GETSTYLEDTEXT 2015
#define SCI_GETSTYLEDTEXTFULL 2778
#define SCI_CANREDO 2016
#define SCI_MARKERLINEFROMHANDLE 2017
#define SCI_MARKERDELETEHANDLE 2018
#define SCI_MARKERHANDLEFROMLINE 2732
#define SCI_MARKERNUMBERFROMLINE 2733
#define SCI_GETUNDOCOLLECTION 2019
#define SCWS_INVISIBLE 0
#define SCWS_VISIBLEALWAYS 1
#define SCWS_VISIBLEAFTERINDENT 2
#define SCWS_VISIBLEONLYININDENT 3
#define SCI_GETVIEWWS 2020
#define SCI_SETVIEWWS 2021
#define SCTD_LONGARROW 0
#define SCTD_STRIKEOUT 1
#define SCI_GETTABDRAWMODE 2698
#define SCI_SETTABDRAWMODE 2699
#define SCI_POSITIONFROMPOINT 2022
#define SCI_POSITIONFROMPOINTCLOSE 2023
#define SCI_GOTOLINE 2024
#define SCI_GOTOPOS 2025
#define SCI_SETANCHOR 2026
#define SCI_GETCURLINE 2027
#define SCI_GETENDSTYLED 2028
#define SC_EOL_CRLF 0
#define SC_EOL_CR 1
#define SC_EOL_LF 2
#define SCI_CONVERTEOLS 2029
#define SCI_GETEOLMODE 2030
#define SCI_SETEOLMODE 2031
#define SCI_STARTSTYLING 2032
#define SCI_SETSTYLING 2033
#define SCI_GETBUFFEREDDRAW 2034
#define SCI_SETBUFFEREDDRAW 2035
#define SCI_SETTABWIDTH 2036
#define SCI_GETTABWIDTH 2121
#define SCI_SETTABMINIMUMWIDTH 2724
#define SCI_GETTABMINIMUMWIDTH 2725
#define SCI_CLEARTABSTOPS 2675
#define SCI_ADDTABSTOP 2676
#define SCI_GETNEXTTABSTOP 2677
#define SC_CP_UTF8 65001
#define SCI_SETCODEPAGE 2037
#define SCI_SETFONTLOCALE 2760
#define SCI_GETFONTLOCALE 2761
#define SC_IME_WINDOWED 0
#define SC_IME_INLINE 1
#define SCI_GETIMEINTERACTION 2678
#define SCI_SETIMEINTERACTION 2679
#define SC_ALPHA_TRANSPARENT 0
#define SC_ALPHA_OPAQUE 255
#define SC_ALPHA_NOALPHA 256
#define SC_CURSORNORMAL -1
#define SC_CURSORARROW 2
#define SC_CURSORWAIT 4
#define SC_CURSORREVERSEARROW 7
#define MARKER_MAX 31
#define SC_MARK_CIRCLE 0
#define SC_MARK_ROUNDRECT 1
#define SC_MARK_ARROW 2
#define SC_MARK_SMALLRECT 3
#define SC_MARK_SHORTARROW 4
#define SC_MARK_EMPTY 5
#define SC_MARK_ARROWDOWN 6
#define SC_MARK_MINUS 7
#define SC_MARK_PLUS 8
#define SC_MARK_VLINE 9
#define SC_MARK_LCORNER 10
#define SC_MARK_TCORNER 11
#define SC_MARK_BOXPLUS 12
#define SC_MARK_BOXPLUSCONNECTED 13
#define SC_MARK_BOXMINUS 14
#define SC_MARK_BOXMINUSCONNECTED 15
#define SC_MARK_LCORNERCURVE 16
#define SC_MARK_TCORNERCURVE 17
#define SC_MARK_CIRCLEPLUS 18
#define SC_MARK_CIRCLEPLUSCONNECTED 19
#define SC_MARK_CIRCLEMINUS 20
#define SC_MARK_CIRCLEMINUSCONNECTED 21
#define SC_MARK_BACKGROUND 22
#define SC_MARK_DOTDOTDOT 23
#define SC_MARK_ARROWS 24
#define SC_MARK_PIXMAP 25
#define SC_MARK_FULLRECT 26
#define SC_MARK_LEFTRECT 27
#define SC_MARK_AVAILABLE 28
#define SC_MARK_UNDERLINE 29
#define SC_MARK_RGBAIMAGE 30
#define SC_MARK_BOOKMARK 31
#define SC_MARK_VERTICALBOOKMARK 32
#define SC_MARK_BAR 33
#define SC_MARK_CHARACTER 10000
#define SC_MARKNUM_HISTORY_REVERTED_TO_ORIGIN 21
#define SC_MARKNUM_HISTORY_SAVED 22
#define SC_MARKNUM_HISTORY_MODIFIED 23
#define SC_MARKNUM_HISTORY_REVERTED_TO_MODIFIED 24
#define SC_MARKNUM_FOLDEREND 25
#define SC_MARKNUM_FOLDEROPENMID 26
#define SC_MARKNUM_FOLDERMIDTAIL 27
#define SC_MARKNUM_FOLDERTAIL 28
#define SC_MARKNUM_FOLDERSUB 29
#define SC_MARKNUM_FOLDER 30
#define SC_MARKNUM_FOLDEROPEN 31
#define SC_MASK_HISTORY 0x01E00000
#define SC_MASK_FOLDERS 0xFE000000
#define SCI_MARKERDEFINE 2040
#define SCI_MARKERSETFORE 2041
#define SCI_MARKERSETBACK 2042
#define SCI_MARKERSETBACKSELECTED 2292
#define SCI_MARKERSETFORETRANSLUCENT 2294
#define SCI_MARKERSETBACKTRANSLUCENT 2295
#define SCI_MARKERSETBACKSELECTEDTRANSLUCENT 2296
#define SCI_MARKERSETSTROKEWIDTH 2297
#define SCI_MARKERENABLEHIGHLIGHT 2293
#define SCI_MARKERADD 2043
#define SCI_MARKERDELETE 2044
#define SCI_MARKERDELETEALL 2045
#define SCI_MARKERGET 2046
#define SCI_MARKERNEXT 2047
#define SCI_MARKERPREVIOUS 2048
#define SCI_MARKERDEFINEPIXMAP 2049
#define SCI_MARKERADDSET 2466
#define SCI_MARKERSETALPHA 2476
#define SCI_MARKERGETLAYER 2734
#define SCI_MARKERSETLAYER 2735
#define SC_MAX_MARGIN 4
#define SC_MARGIN_SYMBOL 0
#define SC_MARGIN_NUMBER 1
#define SC_MARGIN_BACK 2
#define SC_MARGIN_FORE 3
#define SC_MARGIN_TEXT 4
#define SC_MARGIN_RTEXT 5
#define SC_MARGIN_COLOUR 6
#define SCI_SETMARGINTYPEN 2240
#define SCI_GETMARGINTYPEN 2241
#define SCI_SETMARGINWIDTHN 2242
#define SCI_GETMARGINWIDTHN 2243
#define SCI_SETMARGINMASKN 2244
#define SCI_GETMARGINMASKN 2245
#define SCI_SETMARGINSENSITIVEN 2246
#define SCI_GETMARGINSENSITIVEN 2247
#define SCI_SETMARGINCURSORN 2248
#define SCI_GETMARGINCURSORN 2249
#define SCI_SETMARGINBACKN 2250
#define SCI_GETMARGINBACKN 2251
#define SCI_SETMARGINS 2252
#define SCI_GETMARGINS 2253
#define STYLE_DEFAULT 32
#define STYLE_LINENUMBER 33
#define STYLE_BRACELIGHT 34
#define STYLE_BRACEBAD 35
#define STYLE_CONTROLCHAR 36
#define STYLE_INDENTGUIDE 37
#define STYLE_CALLTIP 38
#define STYLE_FOLDDISPLAYTEXT 39
#define STYLE_LASTPREDEFINED 39
#define STYLE_MAX 255
#define SC_CHARSET_ANSI 0
#define SC_CHARSET_DEFAULT 1
#define SC_CHARSET_BALTIC 186
#define SC_CHARSET_CHINESEBIG5 136
#define SC_CHARSET_EASTEUROPE 238
#define SC_CHARSET_GB2312 134
#define SC_CHARSET_GREEK 161
#define SC_CHARSET_HANGUL 129
#define SC_CHARSET_MAC 77
#define SC_CHARSET_OEM 255
#define SC_CHARSET_RUSSIAN 204
#define SC_CHARSET_OEM866 866
#define SC_CHARSET_CYRILLIC 1251
#define SC_CHARSET_SHIFTJIS 128
#define SC_CHARSET_SYMBOL 2
#define SC_CHARSET_TURKISH 162
#define SC_CHARSET_JOHAB 130
#define SC_CHARSET_HEBREW 177
#define SC_CHARSET_ARABIC 178
#define SC_CHARSET_VIETNAMESE 163
#define SC_CHARSET_THAI 222
#define SC_CHARSET_8859_15 1000
#define SCI_STYLECLEARALL 2050
#define SCI_STYLESETFORE 2051
#define SCI_STYLESETBACK 2052
#define SCI_STYLESETBOLD 2053
#define SCI_STYLESETITALIC 2054
#define SCI_STYLESETSIZE 2055
#define SCI_STYLESETFONT 2056
#define SCI_STYLESETEOLFILLED 2057
#define SCI_STYLERESETDEFAULT 2058
#define SCI_STYLESETUNDERLINE 2059
#define SC_CASE_MIXED 0
#define SC_CASE_UPPER 1
#define SC_CASE_LOWER 2
#define SC_CASE_CAMEL 3
#define SCI_STYLEGETFORE 2481
#define SCI_STYLEGETBACK 2482
#define SCI_STYLEGETBOLD 2483
#define SCI_STYLEGETITALIC 2484
#define SCI_STYLEGETSIZE 2485
#define SCI_STYLEGETFONT 2486
#define SCI_STYLEGETEOLFILLED 2487
#define SCI_STYLEGETUNDERLINE 2488
#define SCI_STYLEGETCASE 2489
#define SCI_STYLEGETCHARACTERSET 2490
#define SCI_STYLEGETVISIBLE 2491
#define SCI_STYLEGETCHANGEABLE 2492
#define SCI_STYLEGETHOTSPOT 2493
#define SCI_STYLESETCASE 2060
#define SC_FONT_SIZE_MULTIPLIER 100
#define SCI_STYLESETSIZEFRACTIONAL 2061
#define SCI_STYLEGETSIZEFRACTIONAL 2062
#define SC_WEIGHT_NORMAL 400
#define SC_WEIGHT_SEMIBOLD 600
#define SC_WEIGHT_BOLD 700
#define SCI_STYLESETWEIGHT 2063
#define SCI_STYLEGETWEIGHT 2064
#define SCI_STYLESETCHARACTERSET 2066
#define SCI_STYLESETHOTSPOT 2409
#define SCI_STYLESETCHECKMONOSPACED 2254
#define SCI_STYLEGETCHECKMONOSPACED 2255
#define SC_STRETCH_ULTRA_CONDENSED 1
#define SC_STRETCH_EXTRA_CONDENSED 2
#define SC_STRETCH_CONDENSED 3
#define SC_STRETCH_SEMI_CONDENSED 4
#define SC_STRETCH_NORMAL 5
#define SC_STRETCH_SEMI_EXPANDED 6
#define SC_STRETCH_EXPANDED 7
#define SC_STRETCH_EXTRA_EXPANDED 8
#define SC_STRETCH_ULTRA_EXPANDED 9
#define SCI_STYLESETSTRETCH 2258
#define SCI_STYLEGETSTRETCH 2259
#define SCI_STYLESETINVISIBLEREPRESENTATION 2256
#define SCI_STYLEGETINVISIBLEREPRESENTATION 2257
#define SC_ELEMENT_LIST 0
#define SC_ELEMENT_LIST_BACK 1
#define SC_ELEMENT_LIST_SELECTED 2
#define SC_ELEMENT_LIST_SELECTED_BACK 3
#define SC_ELEMENT_SELECTION_TEXT 10
#define SC_ELEMENT_SELECTION_BACK 11
#define SC_ELEMENT_SELECTION_ADDITIONAL_TEXT 12
#define SC_ELEMENT_SELECTION_ADDITIONAL_BACK 13
#define SC_ELEMENT_SELECTION_SECONDARY_TEXT 14
#define SC_ELEMENT_SELECTION_SECONDARY_BACK 15
#define SC_ELEMENT_SELECTION_INACTIVE_TEXT 16
#define SC_ELEMENT_SELECTION_INACTIVE_BACK 17
#define SC_ELEMENT_SELECTION_INACTIVE_ADDITIONAL_TEXT 18
#define SC_ELEMENT_SELECTION_INACTIVE_ADDITIONAL_BACK 19
#define SC_ELEMENT_CARET 40
#define SC_ELEMENT_CARET_ADDITIONAL 41
#define SC_ELEMENT_CARET_LINE_BACK 50
#define SC_ELEMENT_WHITE_SPACE 60
#define SC_ELEMENT_WHITE_SPACE_BACK 61
#define SC_ELEMENT_HOT_SPOT_ACTIVE 70
#define SC_ELEMENT_HOT_SPOT_ACTIVE_BACK 71
#define SC_ELEMENT_FOLD_LINE 80
#define SC_ELEMENT_HIDDEN_LINE 81
#define SCI_SETELEMENTCOLOUR 2753
#define SCI_GETELEMENTCOLOUR 2754
#define SCI_RESETELEMENTCOLOUR 2755
#define SCI_GETELEMENTISSET 2756
#define SCI_GETELEMENTALLOWSTRANSLUCENT 2757
#define SCI_GETELEMENTBASECOLOUR 2758
#define SCI_SETSELFORE 2067
#define SCI_SETSELBACK 2068
#define SCI_GETSELALPHA 2477
#define SCI_SETSELALPHA 2478
#define SCI_GETSELEOLFILLED 2479
#define SCI_SETSELEOLFILLED 2480
#define SC_LAYER_BASE 0
#define SC_LAYER_UNDER_TEXT 1
#define SC_LAYER_OVER_TEXT 2
#define SCI_GETSELECTIONLAYER 2762
#define SCI_SETSELECTIONLAYER 2763
#define SCI_GETCARETLINELAYER 2764
#define SCI_SETCARETLINELAYER 2765
#define SCI_GETCARETLINEHIGHLIGHTSUBLINE 2773
#define SCI_SETCARETLINEHIGHLIGHTSUBLINE 2774
#define SCI_SETCARETFORE 2069
#define SCI_ASSIGNCMDKEY 2070
#define SCI_CLEARCMDKEY 2071
#define SCI_CLEARALLCMDKEYS 2072
#define SCI_SETSTYLINGEX 2073
#define SCI_STYLESETVISIBLE 2074
#define SCI_GETCARETPERIOD 2075
#define SCI_SETCARETPERIOD 2076
#define SCI_SETWORDCHARS 2077
#define SCI_GETWORDCHARS 2646
#define SCI_SETCHARACTERCATEGORYOPTIMIZATION 2720
#define SCI_GETCHARACTERCATEGORYOPTIMIZATION 2721
#define SCI_BEGINUNDOACTION 2078
#define SCI_ENDUNDOACTION 2079
#define SCI_GETUNDOSEQUENCE 2799
#define SCI_GETUNDOACTIONS 2790
#define SCI_SETUNDOSAVEPOINT 2791
#define SCI_GETUNDOSAVEPOINT 2792
#define SCI_SETUNDODETACH 2793
#define SCI_GETUNDODETACH 2794
#define SCI_SETUNDOTENTATIVE 2795
#define SCI_GETUNDOTENTATIVE 2796
#define SCI_SETUNDOCURRENT 2797
#define SCI_GETUNDOCURRENT 2798
#define SCI_PUSHUNDOACTIONTYPE 2800
#define SCI_CHANGELASTUNDOACTIONTEXT 2801
#define SCI_GETUNDOACTIONTYPE 2802
#define SCI_GETUNDOACTIONPOSITION 2803
#define SCI_GETUNDOACTIONTEXT 2804
#define INDIC_PLAIN 0
#define INDIC_SQUIGGLE 1
#define INDIC_TT 2
#define INDIC_DIAGONAL 3
#define INDIC_STRIKE 4
#define INDIC_HIDDEN 5
#define INDIC_BOX 6
#define INDIC_ROUNDBOX 7
#define INDIC_STRAIGHTBOX 8
#define INDIC_DASH 9
#define INDIC_DOTS 10
#define INDIC_SQUIGGLELOW 11
#define INDIC_DOTBOX 12
#define INDIC_SQUIGGLEPIXMAP 13
#define INDIC_COMPOSITIONTHICK 14
#define INDIC_COMPOSITIONTHIN 15
#define INDIC_FULLBOX 16
#define INDIC_TEXTFORE 17
#define INDIC_POINT 18
#define INDIC_POINTCHARACTER 19
#define INDIC_GRADIENT 20
#define INDIC_GRADIENTCENTRE 21
#define INDIC_POINT_TOP 22
#define INDIC_CONTAINER 8
#define INDIC_IME 32
#define INDIC_IME_MAX 35
#define INDIC_MAX 35
#define INDICATOR_CONTAINER 8
#define INDICATOR_IME 32
#define INDICATOR_IME_MAX 35
#define INDICATOR_HISTORY_REVERTED_TO_ORIGIN_INSERTION 36
#define INDICATOR_HISTORY_REVERTED_TO_ORIGIN_DELETION 37
#define INDICATOR_HISTORY_SAVED_INSERTION 38
#define INDICATOR_HISTORY_SAVED_DELETION 39
#define INDICATOR_HISTORY_MODIFIED_INSERTION 40
#define INDICATOR_HISTORY_MODIFIED_DELETION 41
#define INDICATOR_HISTORY_REVERTED_TO_MODIFIED_INSERTION 42
#define INDICATOR_HISTORY_REVERTED_TO_MODIFIED_DELETION 43
#define INDICATOR_MAX 43
#define SCI_INDICSETSTYLE 2080
#define SCI_INDICGETSTYLE 2081
#define SCI_INDICSETFORE 2082
#define SCI_INDICGETFORE 2083
#define SCI_INDICSETUNDER 2510
#define SCI_INDICGETUNDER 2511
#define SCI_INDICSETHOVERSTYLE 2680
#define SCI_INDICGETHOVERSTYLE 2681
#define SCI_INDICSETHOVERFORE 2682
#define SCI_INDICGETHOVERFORE 2683
#define SC_INDICVALUEBIT 0x1000000
#define SC_INDICVALUEMASK 0xFFFFFF
#define SC_INDICFLAG_NONE 0
#define SC_INDICFLAG_VALUEFORE 1
#define SCI_INDICSETFLAGS 2684
#define SCI_INDICGETFLAGS 2685
#define SCI_INDICSETSTROKEWIDTH 2751
#define SCI_INDICGETSTROKEWIDTH 2752
#define SCI_SETWHITESPACEFORE 2084
#define SCI_SETWHITESPACEBACK 2085
#define SCI_SETWHITESPACESIZE 2086
#define SCI_GETWHITESPACESIZE 2087
#define SCI_SETLINESTATE 2092
#define SCI_GETLINESTATE 2093
#define SCI_GETMAXLINESTATE 2094
#define SCI_GETCARETLINEVISIBLE 2095
#define SCI_SETCARETLINEVISIBLE 2096
#define SCI_GETCARETLINEBACK 2097
#define SCI_SETCARETLINEBACK 2098
#define SCI_GETCARETLINEFRAME 2704
#define SCI_SETCARETLINEFRAME 2705
#define SCI_STYLESETCHANGEABLE 2099
#define SCI_AUTOCSHOW 2100
#define SCI_AUTOCCANCEL 2101
#define SCI_AUTOCACTIVE 2102
#define SCI_AUTOCPOSSTART 2103
#define SCI_AUTOCCOMPLETE 2104
#define SCI_AUTOCSTOPS 2105
#define SCI_AUTOCSETSEPARATOR 2106
#define SCI_AUTOCGETSEPARATOR 2107
#define SCI_AUTOCSELECT 2108
#define SCI_AUTOCSETCANCELATSTART 2110
#define SCI_AUTOCGETCANCELATSTART 2111
#define SCI_AUTOCSETFILLUPS 2112
#define SCI_AUTOCSETCHOOSESINGLE 2113
#define SCI_AUTOCGETCHOOSESINGLE 2114
#define SCI_AUTOCSETIGNORECASE 2115
#define SCI_AUTOCGETIGNORECASE 2116
#define SCI_USERLISTSHOW 2117
#define SCI_AUTOCSETAUTOHIDE 2118
#define SCI_AUTOCGETAUTOHIDE 2119
#define SC_AUTOCOMPLETE_NORMAL 0
#define SC_AUTOCOMPLETE_FIXED_SIZE 1
#define SC_AUTOCOMPLETE_SELECT_FIRST_ITEM 2
#define SCI_AUTOCSETOPTIONS 2638
#define SCI_AUTOCGETOPTIONS 2639
#define SCI_AUTOCSETDROPRESTOFWORD 2270
#define SCI_AUTOCGETDROPRESTOFWORD 2271
#define SCI_REGISTERIMAGE 2405
#define SCI_CLEARREGISTEREDIMAGES 2408
#define SCI_AUTOCGETTYPESEPARATOR 2285
#define SCI_AUTOCSETTYPESEPARATOR 2286
#define SCI_AUTOCSETMAXWIDTH 2208
#define SCI_AUTOCGETMAXWIDTH 2209
#define SCI_AUTOCSETMAXHEIGHT 2210
#define SCI_AUTOCGETMAXHEIGHT 2211
#define SCI_AUTOCSETSTYLE 2109
#define SCI_AUTOCGETSTYLE 2120
#define SCI_AUTOCSETIMAGESCALE 2815
#define SCI_AUTOCGETIMAGESCALE 2816
#define SCI_SETINDENT 2122
#define SCI_GETINDENT 2123
#define SCI_SETUSETABS 2124
#define SCI_GETUSETABS 2125
#define SCI_SETLINEINDENTATION 2126
#define SCI_GETLINEINDENTATION 2127
#define SCI_GETLINEINDENTPOSITION 2128
#define SCI_GETCOLUMN 2129
#define SCI_COUNTCHARACTERS 2633
#define SCI_COUNTCODEUNITS 2715
#define SCI_SETHSCROLLBAR 2130
#define SCI_GETHSCROLLBAR 2131
#define SC_IV_NONE 0
#define SC_IV_REAL 1
#define SC_IV_LOOKFORWARD 2
#define SC_IV_LOOKBOTH 3
#define SCI_SETINDENTATIONGUIDES 2132
#define SCI_GETINDENTATIONGUIDES 2133
#define SCI_SETHIGHLIGHTGUIDE 2134
#define SCI_GETHIGHLIGHTGUIDE 2135
#define SCI_GETLINEENDPOSITION 2136
#define SCI_GETCODEPAGE 2137
#define SCI_GETCARETFORE 2138
#define SCI_GETREADONLY 2140
#define SCI_SETCURRENTPOS 2141
#define SCI_SETSELECTIONSTART 2142
#define SCI_GETSELECTIONSTART 2143
#define SCI_SETSELECTIONEND 2144
#define SCI_GETSELECTIONEND 2145
#define SCI_SETEMPTYSELECTION 2556
#define SCI_SETPRINTMAGNIFICATION 2146
#define SCI_GETPRINTMAGNIFICATION 2147
#define SC_PRINT_NORMAL 0
#define SC_PRINT_INVERTLIGHT 1
#define SC_PRINT_BLACKONWHITE 2
#define SC_PRINT_COLOURONWHITE 3
#define SC_PRINT_COLOURONWHITEDEFAULTBG 4
#define SC_PRINT_SCREENCOLOURS 5
#define SCI_SETPRINTCOLOURMODE 2148
#define SCI_GETPRINTCOLOURMODE 2149
#define SCFIND_NONE 0x0
#define SCFIND_WHOLEWORD 0x2
#define SCFIND_MATCHCASE 0x4
#define SCFIND_WORDSTART 0x00100000
#define SCFIND_REGEXP 0x00200000
#define SCFIND_POSIX 0x00400000
#define SCFIND_CXX11REGEX 0x00800000
#define SCI_FINDTEXT 2150
#define SCI_FINDTEXTFULL 2196
#define SCI_FORMATRANGE 2151
#define SCI_FORMATRANGEFULL 2777
#define SC_CHANGE_HISTORY_DISABLED 0
#define SC_CHANGE_HISTORY_ENABLED 1
#define SC_CHANGE_HISTORY_MARKERS 2
#define SC_CHANGE_HISTORY_INDICATORS 4
#define SCI_SETCHANGEHISTORY 2780
#define SCI_GETCHANGEHISTORY 2781
#define SC_UNDO_SELECTION_HISTORY_DISABLED 0
#define SC_UNDO_SELECTION_HISTORY_ENABLED 1
#define SC_UNDO_SELECTION_HISTORY_SCROLL 2
#define SCI_SETUNDOSELECTIONHISTORY 2782
#define SCI_GETUNDOSELECTIONHISTORY 2783
#define SCI_SETSELECTIONSERIALIZED 2784
#define SCI_GETSELECTIONSERIALIZED 2785
#define SCI_GETFIRSTVISIBLELINE 2152
#define SCI_GETLINE 2153
#define SCI_GETLINECOUNT 2154
#define SCI_ALLOCATELINES 2089
#define SCI_SETMARGINLEFT 2155
#define SCI_GETMARGINLEFT 2156
#define SCI_SETMARGINRIGHT 2157
#define SCI_GETMARGINRIGHT 2158
#define SCI_GETMODIFY 2159
#define SCI_SETSEL 2160
#define SCI_GETSELTEXT 2161
#define SCI_GETTEXTRANGE 2162
#define SCI_GETTEXTRANGEFULL 2039
#define SCI_HIDESELECTION 2163
#define SCI_GETSELECTIONHIDDEN 2088
#define SCI_POINTXFROMPOSITION 2164
#define SCI_POINTYFROMPOSITION 2165
#define SCI_LINEFROMPOSITION 2166
#define SCI_POSITIONFROMLINE 2167
#define SCI_LINESCROLL 2168
#define SCI_SCROLLVERTICAL 2817
#define SCI_SCROLLCARET 2169
#define SCI_SCROLLRANGE 2569
#define SCI_REPLACESEL 2170
#define SCI_SETREADONLY 2171
#define SCI_NULL 2172
#define SCI_CANPASTE 2173
#define SCI_CANUNDO 2174
#define SCI_EMPTYUNDOBUFFER 2175
#define SCI_UNDO 2176
#define SCI_CUT 2177
#define SCI_COPY 2178
#define SCI_PASTE 2179
#define SCI_CLEAR 2180
#define SCI_SETTEXT 2181
#define SCI_GETTEXT 2182
#define SCI_GETTEXTLENGTH 2183
#define SCI_GETDIRECTFUNCTION 2184
#define SCI_GETDIRECTSTATUSFUNCTION 2772
#define SCI_GETDIRECTPOINTER 2185
#define SCI_SETOVERTYPE 2186
#define SCI_GETOVERTYPE 2187
#define SCI_SETCARETWIDTH 2188
#define SCI_GETCARETWIDTH 2189
#define SCI_SETTARGETSTART 2190
#define SCI_GETTARGETSTART 2191
#define SCI_SETTARGETSTARTVIRTUALSPACE 2728
#define SCI_GETTARGETSTARTVIRTUALSPACE 2729
#define SCI_SETTARGETEND 2192
#define SCI_GETTARGETEND 2193
#define SCI_SETTARGETENDVIRTUALSPACE 2730
#define SCI_GETTARGETENDVIRTUALSPACE 2731
#define SCI_SETTARGETRANGE 2686
#define SCI_GETTARGETTEXT 2687
#define SCI_TARGETFROMSELECTION 2287
#define SCI_TARGETWHOLEDOCUMENT 2690
#define SCI_REPLACETARGET 2194
#define SCI_REPLACETARGETRE 2195
#define SCI_REPLACETARGETMINIMAL 2779
#define SCI_SEARCHINTARGET 2197
#define SCI_SETSEARCHFLAGS 2198
#define SCI_GETSEARCHFLAGS 2199
#define SCI_CALLTIPSHOW 2200
#define SCI_CALLTIPCANCEL 2201
#define SCI_CALLTIPACTIVE 2202
#define SCI_CALLTIPPOSSTART 2203
#define SCI_CALLTIPSETPOSSTART 2214
#define SCI_CALLTIPSETHLT 2204
#define SCI_CALLTIPSETBACK 2205
#define SCI_CALLTIPSETFORE 2206
#define SCI_CALLTIPSETFOREHLT 2207
#define SCI_CALLTIPUSESTYLE 2212
#define SCI_CALLTIPSETPOSITION 2213
#define SCI_VISIBLEFROMDOCLINE 2220
#define SCI_DOCLINEFROMVISIBLE 2221
#define SCI_WRAPCOUNT 2235
#define SC_FOLDLEVELNONE 0x0
#define SC_FOLDLEVELBASE 0x400
#define SC_FOLDLEVELWHITEFLAG 0x1000
#define SC_FOLDLEVELHEADERFLAG 0x2000
#define SC_FOLDLEVELNUMBERMASK 0x0FFF
#define SCI_SETFOLDLEVEL 2222
#define SCI_GETFOLDLEVEL 2223
#define SCI_GETLASTCHILD 2224
#define SCI_GETFOLDPARENT 2225
#define SCI_SHOWLINES 2226
#define SCI_HIDELINES 2227
#define SCI_GETLINEVISIBLE 2228
#define SCI_GETALLLINESVISIBLE 2236
#define SCI_SETFOLDEXPANDED 2229
#define SCI_GETFOLDEXPANDED 2230
#define SCI_TOGGLEFOLD 2231
#define SCI_TOGGLEFOLDSHOWTEXT 2700
#define SC_FOLDDISPLAYTEXT_HIDDEN 0
#define SC_FOLDDISPLAYTEXT_STANDARD 1
#define SC_FOLDDISPLAYTEXT_BOXED 2
#define SCI_FOLDDISPLAYTEXTSETSTYLE 2701
#define SCI_FOLDDISPLAYTEXTGETSTYLE 2707
#define SCI_SETDEFAULTFOLDDISPLAYTEXT 2722
#define SCI_GETDEFAULTFOLDDISPLAYTEXT 2723
#define SC_FOLDACTION_CONTRACT 0
#define SC_FOLDACTION_EXPAND 1
#define SC_FOLDACTION_TOGGLE 2
#define SC_FOLDACTION_CONTRACT_EVERY_LEVEL 4
#define SCI_FOLDLINE 2237
#define SCI_FOLDCHILDREN 2238
#define SCI_EXPANDCHILDREN 2239
#define SCI_FOLDALL 2662
#define SCI_ENSUREVISIBLE 2232
#define SC_AUTOMATICFOLD_NONE 0x0000
#define SC_AUTOMATICFOLD_SHOW 0x0001
#define SC_AUTOMATICFOLD_CLICK 0x0002
#define SC_AUTOMATICFOLD_CHANGE 0x0004
#define SCI_SETAUTOMATICFOLD 2663
#define SCI_GETAUTOMATICFOLD 2664
#define SC_FOLDFLAG_NONE 0x0000
#define SC_FOLDFLAG_LINEBEFORE_EXPANDED 0x0002
#define SC_FOLDFLAG_LINEBEFORE_CONTRACTED 0x0004
#define SC_FOLDFLAG_LINEAFTER_EXPANDED 0x0008
#define SC_FOLDFLAG_LINEAFTER_CONTRACTED 0x0010
#define SC_FOLDFLAG_LEVELNUMBERS 0x0040
#define SC_FOLDFLAG_LINESTATE 0x0080
#define SCI_SETFOLDFLAGS 2233
#define SCI_ENSUREVISIBLEENFORCEPOLICY 2234
#define SCI_SETTABINDENTS 2260
#define SCI_GETTABINDENTS 2261
#define SCI_SETBACKSPACEUNINDENTS 2262
#define SCI_GETBACKSPACEUNINDENTS 2263
#define SC_TIME_FOREVER 10000000
#define SCI_SETMOUSEDWELLTIME 2264
#define SCI_GETMOUSEDWELLTIME 2265
#define SCI_WORDSTARTPOSITION 2266
#define SCI_WORDENDPOSITION 2267
#define SCI_ISRANGEWORD 2691
#define SC_IDLESTYLING_NONE 0
#define SC_IDLESTYLING_TOVISIBLE 1
#define SC_IDLESTYLING_AFTERVISIBLE 2
#define SC_IDLESTYLING_ALL 3
#define SCI_SETIDLESTYLING 2692
#define SCI_GETIDLESTYLING 2693
#define SC_WRAP_NONE 0
#define SC_WRAP_WORD 1
#define SC_WRAP_CHAR 2
#define SC_WRAP_WHITESPACE 3
#define SCI_SETWRAPMODE 2268
#define SCI_GETWRAPMODE 2269
#define SC_WRAPVISUALFLAG_NONE 0x0000
#define SC_WRAPVISUALFLAG_END 0x0001
#define SC_WRAPVISUALFLAG_START 0x0002
#define SC_WRAPVISUALFLAG_MARGIN 0x0004
#define SCI_SETWRAPVISUALFLAGS 2460
#define SCI_GETWRAPVISUALFLAGS 2461
#define SC_WRAPVISUALFLAGLOC_DEFAULT 0x0000
#define SC_WRAPVISUALFLAGLOC_END_BY_TEXT 0x0001
#define SC_WRAPVISUALFLAGLOC_START_BY_TEXT 0x0002
#define SCI_SETWRAPVISUALFLAGSLOCATION 2462
#define SCI_GETWRAPVISUALFLAGSLOCATION 2463
#define SCI_SETWRAPSTARTINDENT 2464
#define SCI_GETWRAPSTARTINDENT 2465
#define SC_WRAPINDENT_FIXED 0
#define SC_WRAPINDENT_SAME 1
#define SC_WRAPINDENT_INDENT 2
#define SC_WRAPINDENT_DEEPINDENT 3
#define SCI_SETWRAPINDENTMODE 2472
#define SCI_GETWRAPINDENTMODE 2473
#define SC_CACHE_NONE 0
#define SC_CACHE_CARET 1
#define SC_CACHE_PAGE 2
#define SC_CACHE_DOCUMENT 3
#define SCI_SETLAYOUTCACHE 2272
#define SCI_GETLAYOUTCACHE 2273
#define SCI_SETSCROLLWIDTH 2274
#define SCI_GETSCROLLWIDTH 2275
#define SCI_SETSCROLLWIDTHTRACKING 2516
#define SCI_GETSCROLLWIDTHTRACKING 2517
#define SCI_TEXTWIDTH 2276
#define SCI_SETENDATLASTLINE 2277
#define SCI_GETENDATLASTLINE 2278
#define SCI_TEXTHEIGHT 2279
#define SCI_SETVSCROLLBAR 2280
#define SCI_GETVSCROLLBAR 2281
#define SCI_APPENDTEXT 2282
#define SC_PHASES_ONE 0
#define SC_PHASES_TWO 1
#define SC_PHASES_MULTIPLE 2
#define SCI_GETPHASESDRAW 2673
#define SCI_SETPHASESDRAW 2674
#define SC_EFF_QUALITY_MASK 0xF
#define SC_EFF_QUALITY_DEFAULT 0
#define SC_EFF_QUALITY_NON_ANTIALIASED 1
#define SC_EFF_QUALITY_ANTIALIASED 2
#define SC_EFF_QUALITY_LCD_OPTIMIZED 3
#define SCI_SETFONTQUALITY 2611
#define SCI_GETFONTQUALITY 2612
#define SCI_SETFIRSTVISIBLELINE 2613
#define SC_MULTIPASTE_ONCE 0
#define SC_MULTIPASTE_EACH 1
#define SCI_SETMULTIPASTE 2614
#define SCI_GETMULTIPASTE 2615
#define SCI_GETTAG 2616
#define SCI_LINESJOIN 2288
#define SCI_LINESSPLIT 2289
#define SCI_SETFOLDMARGINCOLOUR 2290
#define SCI_SETFOLDMARGINHICOLOUR 2291
#define SC_ACCESSIBILITY_DISABLED 0
#define SC_ACCESSIBILITY_ENABLED 1
#define SCI_SETACCESSIBILITY 2702
#define SCI_GETACCESSIBILITY 2703
#define SCI_LINEDOWN 2300
#define SCI_LINEDOWNEXTEND 2301
#define SCI_LINEUP 2302
#define SCI_LINEUPEXTEND 2303
#define SCI_CHARLEFT 2304
#define SCI_CHARLEFTEXTEND 2305
#define SCI_CHARRIGHT 2306
#define SCI_CHARRIGHTEXTEND 2307
#define SCI_WORDLEFT 2308
#define SCI_WORDLEFTEXTEND 2309
#define SCI_WORDRIGHT 2310
#define SCI_WORDRIGHTEXTEND 2311
#define SCI_HOME 2312
#define SCI_HOMEEXTEND 2313
#define SCI_LINEEND 2314
#define SCI_LINEENDEXTEND 2315
#define SCI_DOCUMENTSTART 2316
#define SCI_DOCUMENTSTARTEXTEND 2317
#define SCI_DOCUMENTEND 2318
#define SCI_DOCUMENTENDEXTEND 2319
#define SCI_PAGEUP 2320
#define SCI_PAGEUPEXTEND 2321
#define SCI_PAGEDOWN 2322
#define SCI_PAGEDOWNEXTEND 2323
#define SCI_EDITTOGGLEOVERTYPE 2324
#define SCI_CANCEL 2325
#define SCI_DELETEBACK 2326
#define SCI_TAB 2327
#define SCI_LINEINDENT 2813
#define SCI_BACKTAB 2328
#define SCI_LINEDEDENT 2814
#define SCI_NEWLINE 2329
#define SCI_FORMFEED 2330
#define SCI_VCHOME 2331
#define SCI_VCHOMEEXTEND 2332
#define SCI_ZOOMIN 2333
#define SCI_ZOOMOUT 2334
#define SCI_DELWORDLEFT 2335
#define SCI_DELWORDRIGHT 2336
#define SCI_DELWORDRIGHTEND 2518
#define SCI_LINECUT 2337
#define SCI_LINEDELETE 2338
#define SCI_LINETRANSPOSE 2339
#define SCI_LINEREVERSE 2354
#define SCI_LINEDUPLICATE 2404
#define SCI_LOWERCASE 2340
#define SCI_UPPERCASE 2341
#define SCI_LINESCROLLDOWN 2342
#define SCI_LINESCROLLUP 2343
#define SCI_DELETEBACKNOTLINE 2344
#define SCI_HOMEDISPLAY 2345
#define SCI_HOMEDISPLAYEXTEND 2346
#define SCI_LINEENDDISPLAY 2347
#define SCI_LINEENDDISPLAYEXTEND 2348
#define SCI_HOMEWRAP 2349
#define SCI_HOMEWRAPEXTEND 2450
#define SCI_LINEENDWRAP 2451
#define SCI_LINEENDWRAPEXTEND 2452
#define SCI_VCHOMEWRAP 2453
#define SCI_VCHOMEWRAPEXTEND 2454
#define SCI_LINECOPY 2455
#define SCI_MOVECARETINSIDEVIEW 2401
#define SCI_LINELENGTH 2350
#define SCI_BRACEHIGHLIGHT 2351
#define SCI_BRACEHIGHLIGHTINDICATOR 2498
#define SCI_BRACEBADLIGHT 2352
#define SCI_BRACEBADLIGHTINDICATOR 2499
#define SCI_BRACEMATCH 2353
#define SCI_BRACEMATCHNEXT 2369
#define SCI_GETVIEWEOL 2355
#define SCI_SETVIEWEOL 2356
#define SCI_GETDOCPOINTER 2357
#define SCI_SETDOCPOINTER 2358
#define SCI_SETMODEVENTMASK 2359
#define EDGE_NONE 0
#define EDGE_LINE 1
#define EDGE_BACKGROUND 2
#define EDGE_MULTILINE 3
#define SCI_GETEDGECOLUMN 2360
#define SCI_SETEDGECOLUMN 2361
#define SCI_GETEDGEMODE 2362
#define SCI_SETEDGEMODE 2363
#define SCI_GETEDGECOLOUR 2364
#define SCI_SETEDGECOLOUR 2365
#define SCI_MULTIEDGEADDLINE 2694
#define SCI_MULTIEDGECLEARALL 2695
#define SCI_GETMULTIEDGECOLUMN 2749
#define SCI_SEARCHANCHOR 2366
#define SCI_SEARCHNEXT 2367
#define SCI_SEARCHPREV 2368
#define SCI_LINESONSCREEN 2370
#define SC_POPUP_NEVER 0
#define SC_POPUP_ALL 1
#define SC_POPUP_TEXT 2
#define SCI_USEPOPUP 2371
#define SCI_SELECTIONISRECTANGLE 2372
#define SCI_SETZOOM 2373
#define SCI_GETZOOM 2374
#define SC_DOCUMENTOPTION_DEFAULT 0
#define SC_DOCUMENTOPTION_STYLES_NONE 0x1
#define SC_DOCUMENTOPTION_TEXT_LARGE 0x100
#define SCI_CREATEDOCUMENT 2375
#define SCI_ADDREFDOCUMENT 2376
#define SCI_RELEASEDOCUMENT 2377
#define SCI_GETDOCUMENTOPTIONS 2379
#define SCI_GETMODEVENTMASK 2378
#define SCI_SETCOMMANDEVENTS 2717
#define SCI_GETCOMMANDEVENTS 2718
#define SCI_SETFOCUS 2380
#define SCI_GETFOCUS 2381
#define SC_STATUS_OK 0
#define SC_STATUS_FAILURE 1
#define SC_STATUS_BADALLOC 2
#define SC_STATUS_WARN_START 1000
#define SC_STATUS_WARN_REGEX 1001
#define SCI_SETSTATUS 2382
#define SCI_GETSTATUS 2383
#define SCI_SETMOUSEDOWNCAPTURES 2384
#define SCI_GETMOUSEDOWNCAPTURES 2385
#define SCI_SETMOUSEWHEELCAPTURES 2696
#define SCI_GETMOUSEWHEELCAPTURES 2697
#define SCI_SETCURSOR 2386
#define SCI_GETCURSOR 2387
#define SCI_SETCONTROLCHARSYMBOL 2388
#define SCI_GETCONTROLCHARSYMBOL 2389
#define SCI_WORDPARTLEFT 2390
#define SCI_WORDPARTLEFTEXTEND 2391
#define SCI_WORDPARTRIGHT 2392
#define SCI_WORDPARTRIGHTEXTEND 2393
#define VISIBLE_SLOP 0x01
#define VISIBLE_STRICT 0x04
#define SCI_SETVISIBLEPOLICY 2394
#define SCI_DELLINELEFT 2395
#define SCI_DELLINERIGHT 2396
#define SCI_SETXOFFSET 2397
#define SCI_GETXOFFSET 2398
#define SCI_CHOOSECARETX 2399
#define SCI_GRABFOCUS 2400
#define CARET_SLOP 0x01
#define CARET_STRICT 0x04
#define CARET_JUMPS 0x10
#define CARET_EVEN 0x08
#define SCI_SETXCARETPOLICY 2402
#define SCI_SETYCARETPOLICY 2403
#define SCI_SETPRINTWRAPMODE 2406
#define SCI_GETPRINTWRAPMODE 2407
#define SCI_SETHOTSPOTACTIVEFORE 2410
#define SCI_GETHOTSPOTACTIVEFORE 2494
#define SCI_SETHOTSPOTACTIVEBACK 2411
#define SCI_GETHOTSPOTACTIVEBACK 2495
#define SCI_SETHOTSPOTACTIVEUNDERLINE 2412
#define SCI_GETHOTSPOTACTIVEUNDERLINE 2496
#define SCI_SETHOTSPOTSINGLELINE 2421
#define SCI_GETHOTSPOTSINGLELINE 2497
#define SCI_PARADOWN 2413
#define SCI_PARADOWNEXTEND 2414
#define SCI_PARAUP 2415
#define SCI_PARAUPEXTEND 2416
#define SCI_POSITIONBEFORE 2417
#define SCI_POSITIONAFTER 2418
#define SCI_POSITIONRELATIVE 2670
#define SCI_POSITIONRELATIVECODEUNITS 2716
#define SCI_COPYRANGE 2419
#define SCI_COPYTEXT 2420
#define SC_SEL_STREAM 0
#define SC_SEL_RECTANGLE 1
#define SC_SEL_LINES 2
#define SC_SEL_THIN 3
#define SCI_SETSELECTIONMODE 2422
#define SCI_CHANGESELECTIONMODE 2659
#define SCI_GETSELECTIONMODE 2423
#define SCI_SETMOVEEXTENDSSELECTION 2719
#define SCI_GETMOVEEXTENDSSELECTION 2706
#define SCI_GETLINESELSTARTPOSITION 2424
#define SCI_GETLINESELENDPOSITION 2425
#define SCI_LINEDOWNRECTEXTEND 2426
#define SCI_LINEUPRECTEXTEND 2427
#define SCI_CHARLEFTRECTEXTEND 2428
#define SCI_CHARRIGHTRECTEXTEND 2429
#define SCI_HOMERECTEXTEND 2430
#define SCI_VCHOMERECTEXTEND 2431
#define SCI_LINEENDRECTEXTEND 2432
#define SCI_PAGEUPRECTEXTEND 2433
#define SCI_PAGEDOWNRECTEXTEND 2434
#define SCI_STUTTEREDPAGEUP 2435
#define SCI_STUTTEREDPAGEUPEXTEND 2436
#define SCI_STUTTEREDPAGEDOWN 2437
#define SCI_STUTTEREDPAGEDOWNEXTEND 2438
#define SCI_WORDLEFTEND 2439
#define SCI_WORDLEFTENDEXTEND 2440
#define SCI_WORDRIGHTEND 2441
#define SCI_WORDRIGHTENDEXTEND 2442
#define SCI_SETWHITESPACECHARS 2443
#define SCI_GETWHITESPACECHARS 2647
#define SCI_SETPUNCTUATIONCHARS 2648
#define SCI_GETPUNCTUATIONCHARS 2649
#define SCI_SETCHARSDEFAULT 2444
#define SCI_AUTOCGETCURRENT 2445
#define SCI_AUTOCGETCURRENTTEXT 2610
#define SC_CASEINSENSITIVEBEHAVIOUR_RESPECTCASE 0
#define SC_CASEINSENSITIVEBEHAVIOUR_IGNORECASE 1
#define SCI_AUTOCSETCASEINSENSITIVEBEHAVIOUR 2634
#define SCI_AUTOCGETCASEINSENSITIVEBEHAVIOUR 2635
#define SC_MULTIAUTOC_ONCE 0
#define SC_MULTIAUTOC_EACH 1
#define SCI_AUTOCSETMULTI 2636
#define SCI_AUTOCGETMULTI 2637
#define SC_ORDER_PRESORTED 0
#define SC_ORDER_PERFORMSORT 1
#define SC_ORDER_CUSTOM 2
#define SCI_AUTOCSETORDER 2660
#define SCI_AUTOCGETORDER 2661
#define SCI_ALLOCATE 2446
#define SCI_TARGETASUTF8 2447
#define SCI_SETLENGTHFORENCODE 2448
#define SCI_ENCODEDFROMUTF8 2449
#define SCI_FINDCOLUMN 2456
#define SC_CARETSTICKY_OFF 0
#define SC_CARETSTICKY_ON 1
#define SC_CARETSTICKY_WHITESPACE 2
#define SCI_GETCARETSTICKY 2457
#define SCI_SETCARETSTICKY 2458
#define SCI_TOGGLECARETSTICKY 2459
#define SCI_SETPASTECONVERTENDINGS 2467
#define SCI_GETPASTECONVERTENDINGS 2468
#define SCI_REPLACERECTANGULAR 2771
#define SCI_SELECTIONDUPLICATE 2469
#define SCI_SETCARETLINEBACKALPHA 2470
#define SCI_GETCARETLINEBACKALPHA 2471
#define CARETSTYLE_INVISIBLE 0
#define CARETSTYLE_LINE 1
#define CARETSTYLE_BLOCK 2
#define CARETSTYLE_OVERSTRIKE_BAR 0
#define CARETSTYLE_OVERSTRIKE_BLOCK 0x10
#define CARETSTYLE_CURSES 0x20
#define CARETSTYLE_INS_MASK 0xF
#define CARETSTYLE_BLOCK_AFTER 0x100
#define SCI_SETCARETSTYLE 2512
#define SCI_GETCARETSTYLE 2513
#define SCI_SETINDICATORCURRENT 2500
#define SCI_GETINDICATORCURRENT 2501
#define SCI_SETINDICATORVALUE 2502
#define SCI_GETINDICATORVALUE 2503
#define SCI_INDICATORFILLRANGE 2504
#define SCI_INDICATORCLEARRANGE 2505
#define SCI_INDICATORALLONFOR 2506
#define SCI_INDICATORVALUEAT 2507
#define SCI_INDICATORSTART 2508
#define SCI_INDICATOREND 2509
#define SCI_SETPOSITIONCACHE 2514
#define SCI_GETPOSITIONCACHE 2515
#define SCI_SETLAYOUTTHREADS 2775
#define SCI_GETLAYOUTTHREADS 2776
#define SCI_COPYALLOWLINE 2519
#define SCI_CUTALLOWLINE 2810
#define SCI_SETCOPYSEPARATOR 2811
#define SCI_GETCOPYSEPARATOR 2812
#define SCI_GETCHARACTERPOINTER 2520
#define SCI_GETRANGEPOINTER 2643
#define SCI_GETGAPPOSITION 2644
#define SCI_INDICSETALPHA 2523
#define SCI_INDICGETALPHA 2524
#define SCI_INDICSETOUTLINEALPHA 2558
#define SCI_INDICGETOUTLINEALPHA 2559
#define SCI_SETEXTRAASCENT 2525
#define SCI_GETEXTRAASCENT 2526
#define SCI_SETEXTRADESCENT 2527
#define SCI_GETEXTRADESCENT 2528
#define SCI_MARKERSYMBOLDEFINED 2529
#define SCI_MARGINSETTEXT 2530
#define SCI_MARGINGETTEXT 2531
#define SCI_MARGINSETSTYLE 2532
#define SCI_MARGINGETSTYLE 2533
#define SCI_MARGINSETSTYLES 2534
#define SCI_MARGINGETSTYLES 2535
#define SCI_MARGINTEXTCLEARALL 2536
#define SCI_MARGINSETSTYLEOFFSET 2537
#define SCI_MARGINGETSTYLEOFFSET 2538
#define SC_MARGINOPTION_NONE 0
#define SC_MARGINOPTION_SUBLINESELECT 1
#define SCI_SETMARGINOPTIONS 2539
#define SCI_GETMARGINOPTIONS 2557
#define SCI_ANNOTATIONSETTEXT 2540
#define SCI_ANNOTATIONGETTEXT 2541
#define SCI_ANNOTATIONSETSTYLE 2542
#define SCI_ANNOTATIONGETSTYLE 2543
#define SCI_ANNOTATIONSETSTYLES 2544
#define SCI_ANNOTATIONGETSTYLES 2545
#define SCI_ANNOTATIONGETLINES 2546
#define SCI_ANNOTATIONCLEARALL 2547
#define ANNOTATION_HIDDEN 0
#define ANNOTATION_STANDARD 1
#define ANNOTATION_BOXED 2
#define ANNOTATION_INDENTED 3
#define SCI_ANNOTATIONSETVISIBLE 2548
#define SCI_ANNOTATIONGETVISIBLE 2549
#define SCI_ANNOTATIONSETSTYLEOFFSET 2550
#define SCI_ANNOTATIONGETSTYLEOFFSET 2551
#define SCI_RELEASEALLEXTENDEDSTYLES 2552
#define SCI_ALLOCATEEXTENDEDSTYLES 2553
#define UNDO_NONE 0
#define UNDO_MAY_COALESCE 1
#define SCI_ADDUNDOACTION 2560
#define SCI_CHARPOSITIONFROMPOINT 2561
#define SCI_CHARPOSITIONFROMPOINTCLOSE 2562
#define SCI_SETMOUSESELECTIONRECTANGULARSWITCH 2668
#define SCI_GETMOUSESELECTIONRECTANGULARSWITCH 2669
#define SCI_SETMULTIPLESELECTION 2563
#define SCI_GETMULTIPLESELECTION 2564
#define SCI_SETADDITIONALSELECTIONTYPING 2565
#define SCI_GETADDITIONALSELECTIONTYPING 2566
#define SCI_SETADDITIONALCARETSBLINK 2567
#define SCI_GETADDITIONALCARETSBLINK 2568
#define SCI_SETADDITIONALCARETSVISIBLE 2608
#define SCI_GETADDITIONALCARETSVISIBLE 2609
#define SCI_GETSELECTIONS 2570
#define SCI_GETSELECTIONEMPTY 2650
#define SCI_CLEARSELECTIONS 2571
#define SCI_SETSELECTION 2572
#define SCI_ADDSELECTION 2573
#define SCI_SELECTIONFROMPOINT 2474
#define SCI_DROPSELECTIONN 2671
#define SCI_SETMAINSELECTION 2574
#define SCI_GETMAINSELECTION 2575
#define SCI_SETSELECTIONNCARET 2576
#define SCI_GETSELECTIONNCARET 2577
#define SCI_SETSELECTIONNANCHOR 2578
#define SCI_GETSELECTIONNANCHOR 2579
#define SCI_SETSELECTIONNCARETVIRTUALSPACE 2580
#define SCI_GETSELECTIONNCARETVIRTUALSPACE 2581
#define SCI_SETSELECTIONNANCHORVIRTUALSPACE 2582
#define SCI_GETSELECTIONNANCHORVIRTUALSPACE 2583
#define SCI_SETSELECTIONNSTART 2584
#define SCI_GETSELECTIONNSTART 2585
#define SCI_GETSELECTIONNSTARTVIRTUALSPACE 2726
#define SCI_SETSELECTIONNEND 2586
#define SCI_GETSELECTIONNENDVIRTUALSPACE 2727
#define SCI_GETSELECTIONNEND 2587
#define SCI_SETRECTANGULARSELECTIONCARET 2588
#define SCI_GETRECTANGULARSELECTIONCARET 2589
#define SCI_SETRECTANGULARSELECTIONANCHOR 2590
#define SCI_GETRECTANGULARSELECTIONANCHOR 2591
#define SCI_SETRECTANGULARSELECTIONCARETVIRTUALSPACE 2592
#define SCI_GETRECTANGULARSELECTIONCARETVIRTUALSPACE 2593
#define SCI_SETRECTANGULARSELECTIONANCHORVIRTUALSPACE 2594
#define SCI_GETRECTANGULARSELECTIONANCHORVIRTUALSPACE 2595
#define SCVS_NONE 0
#define SCVS_RECTANGULARSELECTION 1
#define SCVS_USERACCESSIBLE 2
#define SCVS_NOWRAPLINESTART 4
#define SCI_SETVIRTUALSPACEOPTIONS 2596
#define SCI_GETVIRTUALSPACEOPTIONS 2597
#define SCI_SETRECTANGULARSELECTIONMODIFIER 2598
#define SCI_GETRECTANGULARSELECTIONMODIFIER 2599
#define SCI_SETADDITIONALSELFORE 2600
#define SCI_SETADDITIONALSELBACK 2601
#define SCI_SETADDITIONALSELALPHA 2602
#define SCI_GETADDITIONALSELALPHA 2603
#define SCI_SETADDITIONALCARETFORE 2604
#define SCI_GETADDITIONALCARETFORE 2605
#define SCI_ROTATESELECTION 2606
#define SCI_SWAPMAINANCHORCARET 2607
#define SCI_MULTIPLESELECTADDNEXT 2688
#define SCI_MULTIPLESELECTADDEACH 2689
#define SCI_CHANGELEXERSTATE 2617
#define SCI_CONTRACTEDFOLDNEXT 2618
#define SCI_VERTICALCENTRECARET 2619
#define SCI_MOVESELECTEDLINESUP 2620
#define SCI_MOVESELECTEDLINESDOWN 2621
#define SCI_SETIDENTIFIER 2622
#define SCI_GETIDENTIFIER 2623
#define SCI_RGBAIMAGESETWIDTH 2624
#define SCI_RGBAIMAGESETHEIGHT 2625
#define SCI_RGBAIMAGESETSCALE 2651
#define SCI_MARKERDEFINERGBAIMAGE 2626
#define SCI_REGISTERRGBAIMAGE 2627
#define SCI_SCROLLTOSTART 2628
#define SCI_SCROLLTOEND 2629
#define SC_TECHNOLOGY_DEFAULT 0
#define SC_TECHNOLOGY_DIRECTWRITE 1
#define SC_TECHNOLOGY_DIRECTWRITERETAIN 2
#define SC_TECHNOLOGY_DIRECTWRITEDC 3
#define SC_TECHNOLOGY_DIRECT_WRITE_1 4
#define SCI_SETTECHNOLOGY 2630
#define SCI_GETTECHNOLOGY 2631
#define SCI_CREATELOADER 2632
#define SCI_FINDINDICATORSHOW 2640
#define SCI_FINDINDICATORFLASH 2641
#define SCI_FINDINDICATORHIDE 2642
#define SCI_VCHOMEDISPLAY 2652
#define SCI_VCHOMEDISPLAYEXTEND 2653
#define SCI_GETCARETLINEVISIBLEALWAYS 2654
#define SCI_SETCARETLINEVISIBLEALWAYS 2655
#define SC_LINE_END_TYPE_DEFAULT 0
#define SC_LINE_END_TYPE_UNICODE 1
#define SCI_SETLINEENDTYPESALLOWED 2656
#define SCI_GETLINEENDTYPESALLOWED 2657
#define SCI_GETLINEENDTYPESACTIVE 2658
#define SCI_SETREPRESENTATION 2665
#define SCI_GETREPRESENTATION 2666
#define SCI_CLEARREPRESENTATION 2667
#define SCI_CLEARALLREPRESENTATIONS 2770
#define SC_REPRESENTATION_PLAIN 0
#define SC_REPRESENTATION_BLOB 1
#define SC_REPRESENTATION_COLOUR 0x10
#define SCI_SETREPRESENTATIONAPPEARANCE 2766
#define SCI_GETREPRESENTATIONAPPEARANCE 2767
#define SCI_SETREPRESENTATIONCOLOUR 2768
#define SCI_GETREPRESENTATIONCOLOUR 2769
#define SCI_EOLANNOTATIONSETTEXT 2740
#define SCI_EOLANNOTATIONGETTEXT 2741
#define SCI_EOLANNOTATIONSETSTYLE 2742
#define SCI_EOLANNOTATIONGETSTYLE 2743
#define SCI_EOLANNOTATIONCLEARALL 2744
#define EOLANNOTATION_HIDDEN 0x0
#define EOLANNOTATION_STANDARD 0x1
#define EOLANNOTATION_BOXED 0x2
#define EOLANNOTATION_STADIUM 0x100
#define EOLANNOTATION_FLAT_CIRCLE 0x101
#define EOLANNOTATION_ANGLE_CIRCLE 0x102
#define EOLANNOTATION_CIRCLE_FLAT 0x110
#define EOLANNOTATION_FLATS 0x111
#define EOLANNOTATION_ANGLE_FLAT 0x112
#define EOLANNOTATION_CIRCLE_ANGLE 0x120
#define EOLANNOTATION_FLAT_ANGLE 0x121
#define EOLANNOTATION_ANGLES 0x122
#define SCI_EOLANNOTATIONSETVISIBLE 2745
#define SCI_EOLANNOTATIONGETVISIBLE 2746
#define SCI_EOLANNOTATIONSETSTYLEOFFSET 2747
#define SCI_EOLANNOTATIONGETSTYLEOFFSET 2748
#define SC_SUPPORTS_LINE_DRAWS_FINAL 0
#define SC_SUPPORTS_PIXEL_DIVISIONS 1
#define SC_SUPPORTS_FRACTIONAL_STROKE_WIDTH 2
#define SC_SUPPORTS_TRANSLUCENT_STROKE 3
#define SC_SUPPORTS_PIXEL_MODIFICATION 4
#define SC_SUPPORTS_THREAD_SAFE_MEASURE_WIDTHS 5
#define SCI_SUPPORTSFEATURE 2750
#define SC_LINECHARACTERINDEX_NONE 0
#define SC_LINECHARACTERINDEX_UTF32 1
#define SC_LINECHARACTERINDEX_UTF16 2
#define SCI_GETLINECHARACTERINDEX 2710
#define SCI_ALLOCATELINECHARACTERINDEX 2711
#define SCI_RELEASELINECHARACTERINDEX 2712
#define SCI_LINEFROMINDEXPOSITION 2713
#define SCI_INDEXPOSITIONFROMLINE 2714
#define SCI_STARTRECORD 3001
#define SCI_STOPRECORD 3002
#define SCI_GETLEXER 4002
#define SCI_COLOURISE 4003
#define SCI_SETPROPERTY 4004
#define KEYWORDSET_MAX 8
#define SCI_SETKEYWORDS 4005
#define SCI_GETPROPERTY 4008
#define SCI_GETPROPERTYEXPANDED 4009
#define SCI_GETPROPERTYINT 4010
#define SCI_GETLEXERLANGUAGE 4012
#define SCI_PRIVATELEXERCALL 4013
#define SCI_PROPERTYNAMES 4014
#define SC_TYPE_BOOLEAN 0
#define SC_TYPE_INTEGER 1
#define SC_TYPE_STRING 2
#define SCI_PROPERTYTYPE 4015
#define SCI_DESCRIBEPROPERTY 4016
#define SCI_DESCRIBEKEYWORDSETS 4017
#define SCI_GETLINEENDTYPESSUPPORTED 4018
#define SCI_ALLOCATESUBSTYLES 4020
#define SCI_GETSUBSTYLESSTART 4021
#define SCI_GETSUBSTYLESLENGTH 4022
#define SCI_GETSTYLEFROMSUBSTYLE 4027
#define SCI_GETPRIMARYSTYLEFROMSTYLE 4028
#define SCI_FREESUBSTYLES 4023
#define SCI_SETIDENTIFIERS 4024
#define SCI_DISTANCETOSECONDARYSTYLES 4025
#define SCI_GETSUBSTYLEBASES 4026
#define SCI_GETNAMEDSTYLES 4029
#define SCI_NAMEOFSTYLE 4030
#define SCI_TAGSOFSTYLE 4031
#define SCI_DESCRIPTIONOFSTYLE 4032
#define SCI_SETILEXER 4033
#define SC_MOD_NONE 0x0
#define SC_MOD_INSERTTEXT 0x1
#define SC_MOD_DELETETEXT 0x2
#define SC_MOD_CHANGESTYLE 0x4
#define SC_MOD_CHANGEFOLD 0x8
#define SC_PERFORMED_USER 0x10
#define SC_PERFORMED_UNDO 0x20
#define SC_PERFORMED_REDO 0x40
#define SC_MULTISTEPUNDOREDO 0x80
#define SC_LASTSTEPINUNDOREDO 0x100
#define SC_MOD_CHANGEMARKER 0x200
#define SC_MOD_BEFOREINSERT 0x400
#define SC_MOD_BEFOREDELETE 0x800
#define SC_MULTILINEUNDOREDO 0x1000
#define SC_STARTACTION 0x2000
#define SC_MOD_CHANGEINDICATOR 0x4000
#define SC_MOD_CHANGELINESTATE 0x8000
#define SC_MOD_CHANGEMARGIN 0x10000
#define SC_MOD_CHANGEANNOTATION 0x20000
#define SC_MOD_CONTAINER 0x40000
#define SC_MOD_LEXERSTATE 0x80000
#define SC_MOD_INSERTCHECK 0x100000
#define SC_MOD_CHANGETABSTOPS 0x200000
#define SC_MOD_CHANGEEOLANNOTATION 0x400000
#define SC_MODEVENTMASKALL 0x7FFFFF
#define SC_UPDATE_NONE 0x0
#define SC_UPDATE_CONTENT 0x1
#define SC_UPDATE_SELECTION 0x2
#define SC_UPDATE_V_SCROLL 0x4
#define SC_UPDATE_H_SCROLL 0x8
#define SCEN_CHANGE 768
#define SCEN_SETFOCUS 512
#define SCEN_KILLFOCUS 256
#define SCK_DOWN 300
#define SCK_UP 301
#define SCK_LEFT 302
#define SCK_RIGHT 303
#define SCK_HOME 304
#define SCK_END 305
#define SCK_PRIOR 306
#define SCK_NEXT 307
#define SCK_DELETE 308
#define SCK_INSERT 309
#define SCK_ESCAPE 7
#define SCK_BACK 8
#define SCK_TAB 9
#define SCK_RETURN 13
#define SCK_ADD 310
#define SCK_SUBTRACT 311
#define SCK_DIVIDE 312
#define SCK_WIN 313
#define SCK_RWIN 314
#define SCK_MENU 315
#define SCMOD_NORM 0
#define SCMOD_SHIFT 1
#define SCMOD_CTRL 2
#define SCMOD_ALT 4
#define SCMOD_SUPER 8
#define SCMOD_META 16
#define SC_AC_FILLUP 1
#define SC_AC_DOUBLECLICK 2
#define SC_AC_TAB 3
#define SC_AC_NEWLINE 4
#define SC_AC_COMMAND 5
#define SC_AC_SINGLE_CHOICE 6
#define SC_CHARACTERSOURCE_DIRECT_INPUT 0
#define SC_CHARACTERSOURCE_TENTATIVE_INPUT 1
#define SC_CHARACTERSOURCE_IME_RESULT 2
#define SCN_STYLENEEDED 2000
#define SCN_CHARADDED 2001
#define SCN_SAVEPOINTREACHED 2002
#define SCN_SAVEPOINTLEFT 2003
#define SCN_MODIFYATTEMPTRO 2004
#define SCN_KEY 2005
#define SCN_DOUBLECLICK 2006
#define SCN_UPDATEUI 2007
#define SCN_MODIFIED 2008
#define SCN_MACRORECORD 2009
#define SCN_MARGINCLICK 2010
#define SCN_NEEDSHOWN 2011
#define SCN_PAINTED 2013
#define SCN_USERLISTSELECTION 2014
#define SCN_URIDROPPED 2015
#define SCN_DWELLSTART 2016
#define SCN_DWELLEND 2017
#define SCN_ZOOM 2018
#define SCN_HOTSPOTCLICK 2019
#define SCN_HOTSPOTDOUBLECLICK 2020
#define SCN_CALLTIPCLICK 2021
#define SCN_AUTOCSELECTION 2022
#define SCN_INDICATORCLICK 2023
#define SCN_INDICATORRELEASE 2024
#define SCN_AUTOCCANCELLED 2025
#define SCN_AUTOCCHARDELETED 2026
#define SCN_HOTSPOTRELEASECLICK 2027
#define SCN_FOCUSIN 2028
#define SCN_FOCUSOUT 2029
#define SCN_AUTOCCOMPLETED 2030
#define SCN_MARGINRIGHTCLICK 2031
#define SCN_AUTOCSELECTIONCHANGE 2032
#ifndef SCI_DISABLE_PROVISIONAL
#define SC_BIDIRECTIONAL_DISABLED 0
#define SC_BIDIRECTIONAL_L2R 1
#define SC_BIDIRECTIONAL_R2L 2
#define SCI_GETBIDIRECTIONAL 2708
#define SCI_SETBIDIRECTIONAL 2709
#endif
/* --Autogenerated -- end of section automatically generated from Scintilla.iface */

#endif

//Au -------------------
#define SCI_MARGINSTYLENEXT 9502
#define SCI_SETNOTIFYCALLBACK 9503
#define SCI_SETANNOTATIONDRAWCALLBACK 9504
#define SCI_SETMARGINDRAWCALLBACK 9505
#define SCI_ISXINMARGIN 9506
#define SCI_DRAGDROP 9507
//#define SCI_DOCUMENT_USERDATA_OFFSET 9509 //was used by QM2

//----------------------

/* These structures are defined to be exactly the same shape as the Win32
 * CHARRANGE, TEXTRANGE, FINDTEXTEX, FORMATRANGE, and NMHDR structs.
 * So older code that treats Scintilla as a RichEdit will work. */

struct Sci_CharacterRange {
	Sci_PositionCR cpMin;
	Sci_PositionCR cpMax;
};

struct Sci_CharacterRangeFull {
	Sci_Position cpMin;
	Sci_Position cpMax;
};

struct Sci_TextRange {
	struct Sci_CharacterRange chrg;
	char *lpstrText;
};

struct Sci_TextRangeFull {
	struct Sci_CharacterRangeFull chrg;
	char *lpstrText;
};

struct Sci_TextToFind {
	struct Sci_CharacterRange chrg;
	const char *lpstrText;
	struct Sci_CharacterRange chrgText;
};

struct Sci_TextToFindFull {
	struct Sci_CharacterRangeFull chrg;
	const char *lpstrText;
	struct Sci_CharacterRangeFull chrgText;
};

typedef void *Sci_SurfaceID;

struct Sci_Rectangle {
	int left;
	int top;
	int right;
	int bottom;
};

/* This structure is used in printing and requires some of the graphics types
 * from Platform.h.  Not needed by most client code. */

struct Sci_RangeToFormat {
	Sci_SurfaceID hdc;
	Sci_SurfaceID hdcTarget;
	struct Sci_Rectangle rc;
	struct Sci_Rectangle rcPage;
	struct Sci_CharacterRange chrg;
};

struct Sci_RangeToFormatFull {
	Sci_SurfaceID hdc;
	Sci_SurfaceID hdcTarget;
	struct Sci_Rectangle rc;
	struct Sci_Rectangle rcPage;
	struct Sci_CharacterRangeFull chrg;
};

#ifndef __cplusplus
/* For the GTK+ platform, g-ir-scanner needs to have these typedefs. This
 * is not required in C++ code and has caused problems in the past. */
typedef struct Sci_NotifyHeader Sci_NotifyHeader;
typedef struct SCNotification SCNotification;
#endif

struct Sci_NotifyHeader {
	/* Compatible with Windows NMHDR.
	 * hwndFrom is really an environment specific window handle or pointer
	 * but most clients of Scintilla.h do not have this type visible. */
	void *hwndFrom;
	uptr_t idFrom;
	unsigned int code;
};

struct SCNotification {
	Sci_NotifyHeader nmhdr;
	Sci_Position position;
	/* SCN_STYLENEEDED, SCN_DOUBLECLICK, SCN_MODIFIED, SCN_MARGINCLICK, */
	/* SCN_MARGINRIGHTCLICK, SCN_NEEDSHOWN, SCN_DWELLSTART, SCN_DWELLEND, */
	/* SCN_CALLTIPCLICK, */
	/* SCN_HOTSPOTCLICK, SCN_HOTSPOTDOUBLECLICK, SCN_HOTSPOTRELEASECLICK, */
	/* SCN_INDICATORCLICK, SCN_INDICATORRELEASE, */
	/* SCN_USERLISTSELECTION, SCN_AUTOCCOMPLETED, SCN_AUTOCSELECTION, */
	/* SCN_AUTOCSELECTIONCHANGE */

	int ch;
	/* SCN_CHARADDED, SCN_KEY, SCN_AUTOCCOMPLETED, SCN_AUTOCSELECTION, */
	/* SCN_USERLISTSELECTION */
	int modifiers;
	/* SCN_KEY, SCN_DOUBLECLICK, SCN_HOTSPOTCLICK, SCN_HOTSPOTDOUBLECLICK, */
	/* SCN_HOTSPOTRELEASECLICK, SCN_INDICATORCLICK, SCN_INDICATORRELEASE, */
	/* SCN_MARGINCLICK, SCN_MARGINRIGHTCLICK */

	int modificationType;	/* SCN_MODIFIED */
	const char *text;
	/* SCN_MODIFIED, SCN_USERLISTSELECTION, SCN_URIDROPPED, */
	/* SCN_AUTOCCOMPLETED, SCN_AUTOCSELECTION, SCN_AUTOCSELECTIONCHANGE */

	Sci_Position length;		/* SCN_MODIFIED */
	Sci_Position linesAdded;	/* SCN_MODIFIED */
	int message;	/* SCN_MACRORECORD */
	uptr_t wParam;	/* SCN_MACRORECORD */
	sptr_t lParam;	/* SCN_MACRORECORD */
	Sci_Position line;		/* SCN_MODIFIED */
	int foldLevelNow;	/* SCN_MODIFIED */
	int foldLevelPrev;	/* SCN_MODIFIED */
	int margin;		/* SCN_MARGINCLICK, SCN_MARGINRIGHTCLICK */
	int listType;	/* SCN_USERLISTSELECTION, SCN_AUTOCSELECTIONCHANGE */
	int x;			/* SCN_DWELLSTART, SCN_DWELLEND */
	int y;		/* SCN_DWELLSTART, SCN_DWELLEND */
	int token;		/* SCN_MODIFIED with SC_MOD_CONTAINER */
	Sci_Position annotationLinesAdded;	/* SCN_MODIFIED with SC_MOD_CHANGEANNOTATION */
	int updated;	/* SCN_UPDATEUI */
	int listCompletionMethod;
	/* SCN_AUTOCSELECTION, SCN_AUTOCCOMPLETED, SCN_USERLISTSELECTION */
	int characterSource;	/* SCN_CHARADDED */
};

#ifdef INCLUDE_DEPRECATED_FEATURES

#define SCI_SETKEYSUNICODE 2521
#define SCI_GETKEYSUNICODE 2522

#define SCI_GETTWOPHASEDRAW 2283
#define SCI_SETTWOPHASEDRAW 2284

#define CharacterRange Sci_CharacterRange
#define TextRange Sci_TextRange
#define TextToFind Sci_TextToFind
#define RangeToFormat Sci_RangeToFormat
#define NotifyHeader Sci_NotifyHeader

#define SCI_SETSTYLEBITS 2090
#define SCI_GETSTYLEBITS 2091
#define SCI_GETSTYLEBITSNEEDED 4011

#define INDIC0_MASK 0x20
#define INDIC1_MASK 0x40
#define INDIC2_MASK 0x80
#define INDICS_MASK 0xE0

#endif

#endif


================================================
FILE: Libraries/scintilla/src/AutoComplete.cxx
================================================
// Scintilla source code edit control
/** @file AutoComplete.cxx
 ** Defines the auto completion list box.
 **/
// Copyright 1998-2003 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#include <cstddef>
#include <cstdlib>
#include <cstdint>
#include <cassert>
#include <cstring>
#include <cstdio>

#include <stdexcept>
#include <string>
#include <string_view>
#include <vector>
#include <optional>
#include <algorithm>
#include <memory>

#include "ScintillaTypes.h"
#include "ScintillaMessages.h"

#include "Debugging.h"
#include "Geometry.h"
#include "Platform.h"

#include "CharacterType.h"
#include "Position.h"
#include "AutoComplete.h"

using namespace Scintilla;
using namespace Scintilla::Internal;

AutoComplete::AutoComplete() :
	active(false),
	separator(' '),
	typesep('?'),
	ignoreCase(false),
	chooseSingle(false),
	options(AutoCompleteOption::Normal),
	imageScale(1.0),
	posStart(0),
	startLen(0),
	cancelAtStartPos(true),
	autoHide(true),
	dropRestOfWord(false),
	ignoreCaseBehaviour(CaseInsensitiveBehaviour::RespectCase),
	widthLBDefault(100),
	heightLBDefault(100),
	autoSort(Ordering::PreSorted) {
	lb = ListBox::Allocate();
}

AutoComplete::~AutoComplete() {
	if (lb) {
		lb->Destroy();
	}
}

bool AutoComplete::Active() const noexcept {
	return active;
}

void AutoComplete::Start(Window &parent, int ctrlID,
	Sci::Position position, Point location, Sci::Position startLen_,
	int lineHeight, bool unicodeMode, Technology technology, ListOptions listOptions) {
	if (active) {
		Cancel();
	}
	lb->SetOptions(listOptions);
	lb->Create(parent, ctrlID, location, lineHeight, unicodeMode, technology);
	lb->Clear();
	active = true;
	startLen = startLen_;
	posStart = position;
}

void AutoComplete::SetStopChars(const char *stopChars_) {
	stopChars = stopChars_;
}

bool AutoComplete::IsStopChar(char ch) const noexcept {
	return ch && (stopChars.find(ch) != std::string::npos);
}

void AutoComplete::SetFillUpChars(const char *fillUpChars_) {
	fillUpChars = fillUpChars_;
}

bool AutoComplete::IsFillUpChar(char ch) const noexcept {
	return ch && (fillUpChars.find(ch) != std::string::npos);
}

void AutoComplete::SetSeparator(char separator_) noexcept {
	separator = separator_;
}

char AutoComplete::GetSeparator() const noexcept {
	return separator;
}

void AutoComplete::SetTypesep(char separator_) noexcept {
	typesep = separator_;
}

char AutoComplete::GetTypesep() const noexcept {
	return typesep;
}

namespace {

struct Sorter {
	const bool ignoreCase;
	const char *list;
	std::vector<int> indices;

	Sorter(const AutoComplete *ac, const char *list_) : ignoreCase(ac->ignoreCase), list(list_) {
		int i = 0;
		if (!list[i]) {
			// Empty list has a single empty member
			indices.push_back(i); // word start
			indices.push_back(i); // word end
		}
		const char separator = ac->GetSeparator();
		const char typesep = ac->GetTypesep();
		while (list[i]) {
			indices.push_back(i); // word start
			while (list[i] != typesep && list[i] != separator && list[i])
				++i;
			indices.push_back(i); // word end
			if (list[i] == typesep) {
				while (list[i] != separator && list[i])
					++i;
			}
			if (list[i] == separator) {
				++i;
				// preserve trailing separator as blank entry
				if (!list[i]) {
					indices.push_back(i);
					indices.push_back(i);
				}
			}
		}
		indices.push_back(i); // index of last position
	}

	bool operator()(int a, int b) const noexcept {
		const unsigned indexA = a * 2;
		const unsigned indexB = b * 2;
		const int lenA = indices[indexA + 1] - indices[indexA];
		const int lenB = indices[indexB + 1] - indices[indexB];
		const int len  = std::min(lenA, lenB);
		int cmp;
		if (ignoreCase)
			cmp = CompareNCaseInsensitive(list + indices[indexA], list + indices[indexB], len);
		else
			cmp = strncmp(list + indices[indexA], list + indices[indexB], len);
		if (cmp == 0)
			cmp = lenA - lenB;
		return cmp < 0;
	}
};

void FillSortMatrix(std::vector<int> &sortMatrix, int itemCount) {
	sortMatrix.clear();
	for (int i = 0; i < itemCount; i++) {
		sortMatrix.push_back(i);
	}
}

}

void AutoComplete::SetList(const char *list) {
	if (autoSort == Ordering::PreSorted) {
		lb->SetList(list, separator, typesep);
		FillSortMatrix(sortMatrix, lb->Length());
		return;
	}

	const Sorter IndexSort(this, list);
	FillSortMatrix(sortMatrix, static_cast<int>(IndexSort.indices.size() / 2));
	std::sort(sortMatrix.begin(), sortMatrix.end(), IndexSort);
	if (autoSort == Ordering::Custom || sortMatrix.size() < 2) {
		lb->SetList(list, separator, typesep);
		PLATFORM_ASSERT(lb->Length() == static_cast<int>(sortMatrix.size()));
		return;
	}

	std::string sortedList;
	for (size_t i = 0; i < sortMatrix.size(); ++i) {
		const unsigned index = sortMatrix[i] * 2;
		sortMatrix[i] = static_cast<int>(i);
		// word length include trailing typesep and separator
		const int wordLen = IndexSort.indices[index + 2] - IndexSort.indices[index];
		const std::string_view item(list + IndexSort.indices[index], wordLen);
		sortedList += item;
		if ((i + 1) == sortMatrix.size()) {
			// Last item so remove separator if present
			if (!item.empty() && item.back() == separator) {
				sortedList.pop_back();
			}
		} else {
			// Item before last needs a separator
			if (item.empty() || item.back() != separator) {
				sortedList += separator;
			}
		}
	}
	lb->SetList(sortedList.c_str(), separator, typesep);
}

int AutoComplete::GetSelection() const {
	return lb->GetSelection();
}

std::string AutoComplete::GetValue(int item) const {
	return lb->GetValue(item);
}

void AutoComplete::Show(bool show) {
	lb->Show(show);
	if (show)
		lb->Select(0);
}

void AutoComplete::Cancel() noexcept {
	if (lb->Created()) {
		lb->Clear();
		lb->Destroy();
		active = false;
	}
}


void AutoComplete::Move(int delta) {
	const int count = lb->Length();
	int current = lb->GetSelection();
	current += delta;
	if (current >= count)
		current = count - 1;
	if (current < 0)
		current = 0;
	lb->Select(current);
}

void AutoComplete::Select(const char *word) {
	const size_t lenWord = strlen(word);
	int location = -1;
	int start = 0; // lower bound of the api array block to search
	int end = lb->Length() - 1; // upper bound of the api array block to search
	while ((start <= end) && (location == -1)) { // Binary searching loop
		int pivot = (start + end) / 2;
		std::string item = GetValue(sortMatrix[pivot]);
		int cond;
		if (ignoreCase)
			cond = CompareNCaseInsensitive(word, item.c_str(), lenWord);
		else
			cond = strncmp(word, item.c_str(), lenWord);
		if (!cond) {
			// Find first match
			while (pivot > start) {
				item = lb->GetValue(sortMatrix[pivot-1]);
				if (ignoreCase)
					cond = CompareNCaseInsensitive(word, item.c_str(), lenWord);
				else
					cond = strncmp(word, item.c_str(), lenWord);
				if (0 != cond)
					break;
				--pivot;
			}
			location = pivot;
			if (ignoreCase
				&& ignoreCaseBehaviour == CaseInsensitiveBehaviour::RespectCase) {
				// Check for exact-case match
				for (; pivot <= end; pivot++) {
					item = lb->GetValue(sortMatrix[pivot]);
					if (!strncmp(word, item.c_str(), lenWord)) {
						location = pivot;
						break;
					}
					if (CompareNCaseInsensitive(word, item.c_str(), lenWord))
						break;
				}
			}
		} else if (cond < 0) {
			end = pivot - 1;
		} else { // cond > 0
			start = pivot + 1;
		}
	}
	if (location == -1) {
		if (autoHide)
			Cancel();
		else
			lb->Select(-1);
	} else {
		if (autoSort == Ordering::Custom) {
			// Check for a logically earlier match
			for (int i = location + 1; i <= end; ++i) {
				const std::string item = lb->GetValue(sortMatrix[i]);
				if (CompareNCaseInsensitive(word, item.c_str(), lenWord))
					break;
				if (sortMatrix[i] < sortMatrix[location] && !strncmp(word, item.c_str(), lenWord))
					location = i;
			}
		}
		lb->Select(sortMatrix[location]);
	}
}



================================================
FILE: Libraries/scintilla/src/AutoComplete.h
================================================
// Scintilla source code edit control
/** @file AutoComplete.h
 ** Defines the auto completion list box.
 **/
// Copyright 1998-2003 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#ifndef AUTOCOMPLETE_H
#define AUTOCOMPLETE_H

namespace Scintilla::Internal {

/**
 */
class AutoComplete {
	bool active;
	std::string stopChars;
	std::string fillUpChars;
	char separator;
	char typesep; // Type separator
	std::vector<int> sortMatrix;

public:

	bool ignoreCase;
	bool chooseSingle;
	AutoCompleteOption options;
	float imageScale;
	std::unique_ptr<ListBox> lb;
	Sci::Position posStart;
	Sci::Position startLen;
	/// Should autocompletion be cancelled if editor's currentPos <= startPos?
	bool cancelAtStartPos;
	bool autoHide;
	bool dropRestOfWord;
	Scintilla::CaseInsensitiveBehaviour ignoreCaseBehaviour;
	int widthLBDefault;
	int heightLBDefault;
	/** Ordering::PreSorted:   Assume the list is presorted; selection will fail if it is not alphabetical<br />
	 *  Ordering::PerformSort: Sort the list alphabetically; start up performance cost for sorting<br />
	 *  Ordering::Custom:      Handle non-alphabetical entries; start up performance cost for generating a sorted lookup table
	 */
	Scintilla::Ordering autoSort;

	AutoComplete();
	// Deleted so AutoComplete objects can not be copied.
	AutoComplete(const AutoComplete &) = delete;
	AutoComplete(AutoComplete &&) = delete;
	AutoComplete &operator=(const AutoComplete &) = delete;
	AutoComplete &operator=(AutoComplete &&) = delete;
	~AutoComplete();

	/// Is the auto completion list displayed?
	bool Active() const noexcept;

	/// Display the auto completion list positioned to be near a character position
	void Start(Window &parent, int ctrlID, Sci::Position position, Point location,
		Sci::Position startLen_, int lineHeight, bool unicodeMode, Scintilla::Technology technology,
		ListOptions listOptions);

	/// The stop chars are characters which, when typed, cause the auto completion list to disappear
	void SetStopChars(const char *stopChars_);
	bool IsStopChar(char ch) const noexcept;

	/// The fillup chars are characters which, when typed, fill up the selected word
	void SetFillUpChars(const char *fillUpChars_);
	bool IsFillUpChar(char ch) const noexcept;

	/// The separator character is used when interpreting the list in SetList
	void SetSeparator(char separator_) noexcept;
	char GetSeparator() const noexcept;

	/// The typesep character is used for separating the word from the type
	void SetTypesep(char separator_) noexcept;
	char GetTypesep() const noexcept;

	/// The list string contains a sequence of words separated by the separator character
	void SetList(const char *list);

	/// Return the position of the currently selected list item
	int GetSelection() const;

	/// Return the value of an item in the list
	std::string GetValue(int item) const;

	void Show(bool show);
	void Cancel() noexcept;

	/// Move the current list element by delta, scrolling appropriately
	void Move(int delta);

	/// Select a list element that starts with word as the current element
	void Select(const char *word);
};

}

#endif


================================================
FILE: Libraries/scintilla/src/CallTip.cxx
================================================
// Scintilla source code edit control
/** @file CallTip.cxx
 ** Code for displaying call tips.
 **/
// Copyright 1998-2001 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#include <cstddef>
#include <cstdlib>
#include <cstdint>
#include <cassert>
#include <cstring>
#include <cstdio>
#include <cmath>

#include <stdexcept>
#include <string>
#include <string_view>
#include <vector>
#include <optional>
#include <algorithm>
#include <memory>

#include "ScintillaTypes.h"
#include "ScintillaMessages.h"

#include "Debugging.h"
#include "Geometry.h"
#include "Platform.h"

#include "Position.h"
#include "CallTip.h"

using namespace Scintilla;
using namespace Scintilla::Internal;

size_t Chunk::Length() const noexcept {
	return end - start;
}

namespace {

#ifdef __APPLE__
// Archaic macOS colours for the default: black on light yellow
constexpr ColourRGBA colourTextAndArrow(black);
constexpr ColourRGBA colourBackground(0xff, 0xff, 0xc6);
#else
// Grey on white
constexpr ColourRGBA colourTextAndArrow(0x80, 0x80, 0x80);
constexpr ColourRGBA colourBackground(white);
#endif

constexpr ColourRGBA silver(0xc0, 0xc0, 0xc0);

}

CallTip::CallTip() noexcept {
	wCallTip = {};
	inCallTipMode = false;
	posStartCallTip = 0;
	rectUp = PRectangle(0,0,0,0);
	rectDown = PRectangle(0,0,0,0);
	lineHeight = 1;
	offsetMain = 0;
	tabSize = 0;
	above = false;
	useStyleCallTip = false;    // for backwards compatibility

	insetX = 5;
	widthArrow = 14;
	borderHeight = 2; // Extra line for border and an empty line at top and bottom.
	verticalOffset = 1;

	colourBG = colourBackground;
	colourUnSel = colourTextAndArrow;

	colourSel = ColourRGBA(0, 0, 0x80);
	colourShade = black;
	colourLight = silver;
	codePage = 0;
	clickPlace = 0;
}

CallTip::~CallTip() {
	wCallTip.Destroy();
}

// We ignore tabs unless a tab width has been set.
bool CallTip::IsTabCharacter(char ch) const noexcept {
	return (tabSize > 0) && (ch == '\t');
}

int CallTip::NextTabPos(int x) const noexcept {
	if (tabSize > 0) {              // paranoia... not called unless this is true
		x -= insetX;                // position relative to text
		x = (x + tabSize) / tabSize;  // tab "number"
		return tabSize*x + insetX;  // position of next tab
	}
	return x + 1;                 // arbitrary
}

namespace {

// Although this test includes 0, we should never see a \0 character.
constexpr bool IsArrowCharacter(char ch) noexcept {
	return (ch == 0) || (ch == '\001') || (ch == '\002');
}

void DrawArrow(Surface *surface, const PRectangle &rc, bool upArrow, ColourRGBA colourBG, ColourRGBA colourUnSel) {
	surface->FillRectangle(rc, colourBG);
	const PRectangle rcClientInner = Clamp(rc.Inset(1), Edge::right, rc.right - 2);
	surface->FillRectangle(rcClientInner, colourUnSel);

	const XYPOSITION width = std::floor(rcClientInner.Width());
	const XYPOSITION halfWidth = std::floor(width / 2) - 1;
	const XYPOSITION quarterWidth = std::floor(halfWidth / 2);
	const XYPOSITION centreX = rcClientInner.left + width / 2;
	const XYPOSITION centreY = std::floor((rcClientInner.top + rcClientInner.bottom) / 2);

	constexpr XYPOSITION pixelMove = 0.0f;
	if (upArrow) {      // Up arrow
		const Point pts[] = {
			Point(centreX - halfWidth + pixelMove, centreY + quarterWidth + 0.5f),
			Point(centreX + halfWidth + pixelMove, centreY + quarterWidth + 0.5f),
			Point(centreX + pixelMove, centreY - halfWidth + quarterWidth + 0.5f),
		};
		surface->Polygon(pts, std::size(pts), FillStroke(colourBG));
	} else {            // Down arrow
		const Point pts[] = {
			Point(centreX - halfWidth + pixelMove, centreY - quarterWidth + 0.5f),
			Point(centreX + halfWidth + pixelMove, centreY - quarterWidth + 0.5f),
			Point(centreX + pixelMove, centreY + halfWidth - quarterWidth + 0.5f),
		};
		surface->Polygon(pts, std::size(pts), FillStroke(colourBG));
	}
}

}

// Draw a section of the call tip that does not include \n in one colour.
// The text may include tabs or arrow characters.
int CallTip::DrawChunk(Surface *surface, int x, std::string_view sv,
	int ytext, PRectangle rcClient, bool asHighlight, bool draw) {

	if (sv.empty()) {
		return x;
	}

	// Divide the text into sections that are all text, or that are
	// single arrows or single tab characters (if tabSize > 0).
	// Start with single element 0 to simplify append checks.
	std::vector<size_t> ends(1);
	for (size_t i=0; i<sv.length(); i++) {
		if (IsArrowCharacter(sv[i]) || IsTabCharacter(sv[i])) {
			if (ends.back() != i)
				ends.push_back(i);
			ends.push_back(i+1);
		}
	}
	if (ends.back() != sv.length())
		ends.push_back(sv.length());
	ends.erase(ends.begin());	// Remove initial 0.

	size_t startSeg = 0;
	for (const size_t endSeg : ends) {
		assert(endSeg > 0);
		int xEnd = 0;
		if (IsArrowCharacter(sv[startSeg])) {
			xEnd = x + widthArrow;
			const bool upArrow = sv[startSeg] == '\001';
			rcClient.left = static_cast<XYPOSITION>(x);
			rcClient.right = static_cast<XYPOSITION>(xEnd);
			if (draw) {
				DrawArrow(surface, rcClient, upArrow, colourBG, colourUnSel);
			}
			offsetMain = xEnd;
			if (upArrow) {
				rectUp = rcClient;
			} else {
				rectDown = rcClient;
			}
		} else if (IsTabCharacter(sv[startSeg])) {
			xEnd = NextTabPos(x);
		} else {
			const std::string_view segText = sv.substr(startSeg, endSeg - startSeg);
			xEnd = x + static_cast<int>(std::lround(surface->WidthText(font.get(), segText)));
			if (draw) {
				rcClient.left = static_cast<XYPOSITION>(x);
				rcClient.right = static_cast<XYPOSITION>(xEnd);
				surface->DrawTextTransparent(rcClient, font.get(), static_cast<XYPOSITION>(ytext),
									segText, asHighlight ? colourSel : colourUnSel);
			}
		}
		x = xEnd;
		startSeg = endSeg;
	}
	return x;
}

int CallTip::PaintContents(Surface *surfaceWindow, bool draw) {
	const PRectangle rcClientPos = wCallTip.GetClientPosition();
	const PRectangle rcClientSize(0.0f, 0.0f, rcClientPos.right - rcClientPos.left,
	                        rcClientPos.bottom - rcClientPos.top);
	PRectangle rcClient(1.0f, 1.0f, rcClientSize.right - 1, rcClientSize.bottom - 1);

	// To make a nice small call tip window, it is only sized to fit most normal characters without accents
	const int ascent = static_cast<int>(std::round(surfaceWindow->Ascent(font.get()) - surfaceWindow->InternalLeading(font.get())));

	// For each line...
	// Draw the definition in three parts: before highlight, highlighted, after highlight
	int ytext = static_cast<int>(rcClient.top) + ascent + 1;
	rcClient.bottom = ytext + surfaceWindow->Descent(font.get()) + 1;
	std::string_view remaining(val);
	int maxWidth = 0;
	size_t lineStart = 0;
	while (!remaining.empty()) {
		const std::string_view chunkVal = remaining.substr(0, remaining.find_first_of('\n'));
		remaining.remove_prefix(chunkVal.length());
		if (!remaining.empty()) {
			remaining.remove_prefix(1);	// Skip \n
		}

		const Chunk chunkLine(lineStart, lineStart + chunkVal.length());
		Chunk chunkHighlight(
			std::clamp(highlight.start, chunkLine.start, chunkLine.end),
			std::clamp(highlight.end, chunkLine.start, chunkLine.end)
		);
		chunkHighlight.start -= lineStart;
		chunkHighlight.end -= lineStart;

		const int top = ytext - ascent - 1;
		rcClient.top = top;

		int x = insetX;     // start each line at this inset

		x = DrawChunk(surfaceWindow, x,
			chunkVal.substr(0, chunkHighlight.start),
			ytext, rcClient, false, draw);
		x = DrawChunk(surfaceWindow, x,
			chunkVal.substr(chunkHighlight.start, chunkHighlight.Length()),
			ytext, rcClient, true, draw);
		x = DrawChunk(surfaceWindow, x,
			chunkVal.substr(chunkHighlight.end),
			ytext, rcClient, false, draw);

		ytext += lineHeight;
		rcClient.bottom += lineHeight;
		maxWidth = std::max(maxWidth, x);
		lineStart += chunkVal.length() + 1;
	}
	return maxWidth;
}

void CallTip::PaintCT(Surface *surfaceWindow) {
	if (val.empty())
		return;
	const PRectangle rcClientPos = wCallTip.GetClientPosition();
	const PRectangle rcClientSize(0.0f, 0.0f, rcClientPos.right - rcClientPos.left,
	                        rcClientPos.bottom - rcClientPos.top);
	const PRectangle rcClient(1.0f, 1.0f, rcClientSize.right - 1, rcClientSize.bottom - 1);

	surfaceWindow->FillRectangle(rcClient, colourBG);

	offsetMain = insetX;    // initial alignment assuming no arrows
	PaintContents(surfaceWindow, true);

#if !defined(__APPLE__) && !PLAT_CURSES
	// OSX doesn't put borders on "help tags"
	// Draw a raised border around the edges of the window
	constexpr XYPOSITION border = 1.0f;
	surfaceWindow->FillRectangle(Side(rcClientSize, Edge::left, border), colourLight);
	surfaceWindow->FillRectangle(Side(rcClientSize, Edge::right, border), colourShade);
	surfaceWindow->FillRectangle(Side(rcClientSize, Edge::bottom, border), colourShade);
	surfaceWindow->FillRectangle(Side(rcClientSize, Edge::top, border), colourLight);
#endif
}

void CallTip::MouseClick(Point pt) noexcept {
	clickPlace = 0;
	if (rectUp.Contains(pt))
		clickPlace = 1;
	if (rectDown.Contains(pt))
		clickPlace = 2;
}

PRectangle CallTip::CallTipStart(Sci::Position pos, Point pt, int textHeight, const char *defn,
                                 int codePage_, Surface *surfaceMeasure, const std::shared_ptr<Font> &font_) {
	clickPlace = 0;
	val = defn;
	codePage = codePage_;
	highlight = Chunk();
	inCallTipMode = true;
	posStartCallTip = pos;
	font = font_;
	// Look for multiple lines in the text
	// Only support \n here - simply means container must avoid \r!
	const int numLines = 1 + static_cast<int>(std::count(val.begin(), val.end(), '\n'));
	rectUp = PRectangle(0,0,0,0);
	rectDown = PRectangle(0,0,0,0);
	offsetMain = insetX;            // changed to right edge of any arrows
	lineHeight = static_cast<int>(std::lround(surfaceMeasure->Height(font.get())));
#if !PLAT_CURSES
	widthArrow = lineHeight * 9 / 10;
#endif
	const int width = PaintContents(surfaceMeasure, false) + insetX;

	// The returned
	// rectangle is aligned to the right edge of the last arrow encountered in
	// the tip text, else to the tip text left edge.
	const int height = lineHeight * numLines - static_cast<int>(surfaceMeasure->InternalLeading(font.get())) + borderHeight * 2;
	if (above) {
		return PRectangle(pt.x - offsetMain, pt.y - verticalOffset - height, pt.x + width - offsetMain, pt.y - verticalOffset);
	} else {
		return PRectangle(pt.x - offsetMain, pt.y + verticalOffset + textHeight, pt.x + width - offsetMain, pt.y + verticalOffset + textHeight + height);
	}
}

void CallTip::CallTipCancel() noexcept {
	inCallTipMode = false;
	if (wCallTip.Created()) {
		wCallTip.Destroy();
	}
}

void CallTip::SetHighlight(size_t start, size_t end) {
	// Avoid flashing by checking something has really changed
	if ((start != highlight.start) || (end != highlight.end)) {
		highlight.start = start;
		highlight.end = (end > start) ? end : start;
		if (wCallTip.Created()) {
			wCallTip.InvalidateAll();
		}
	}
}

// Set the tab size (sizes > 0 enable the use of tabs). This also enables the
// use of the StyleCallTip.
void CallTip::SetTabSize(int tabSz) noexcept {
	tabSize = tabSz;
	useStyleCallTip = true;
}

// Set the calltip position, below the text by default or if above is false
// else above the text.
void CallTip::SetPosition(bool aboveText) noexcept {
	above = aboveText;
}

bool CallTip::UseStyleCallTip() const noexcept {
	return useStyleCallTip;
}

// It might be better to have two access functions for this and to use
// them for all settings of colours.
void CallTip::SetForeBack(ColourRGBA fore, ColourRGBA back) noexcept {
	colourBG = back;
	colourUnSel = fore;
}


================================================
FILE: Libraries/scintilla/src/CallTip.h
================================================
// Scintilla source code edit control
/** @file CallTip.h
 ** Interface to the call tip control.
 **/
// Copyright 1998-2001 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#ifndef CALLTIP_H
#define CALLTIP_H

namespace Scintilla::Internal {

struct Chunk {
	size_t start;
	size_t end;
	constexpr Chunk(size_t start_=0, size_t end_=0) noexcept : start(start_), end(end_) {
		assert(start <= end);
	}
	size_t Length() const noexcept;
};

/**
 */
class CallTip {
	Chunk highlight;    // character offset to start and end of highlighted text
	std::string val;
	std::shared_ptr<Font> font;
	PRectangle rectUp;      // rectangle of last up angle in the tip
	PRectangle rectDown;    // rectangle of last down arrow in the tip
	int lineHeight;         // vertical line spacing
	int offsetMain;         // The alignment point of the call tip
	int tabSize;            // Tab size in pixels, <=0 no TAB expand
	bool useStyleCallTip;   // if true, StyleCallTip should be used
	bool above;		// if true, display calltip above text

	int DrawChunk(Surface *surface, int x, std::string_view sv,
		int ytext, PRectangle rcClient, bool asHighlight, bool draw);
	int PaintContents(Surface *surfaceWindow, bool draw);
	bool IsTabCharacter(char ch) const noexcept;
	int NextTabPos(int x) const noexcept;

public:
	Window wCallTip;
	Window wDraw;
	bool inCallTipMode;
	Sci::Position posStartCallTip;
	ColourRGBA colourBG;
	ColourRGBA colourUnSel;
	ColourRGBA colourSel;
	ColourRGBA colourShade;
	ColourRGBA colourLight;
	int codePage;
	int clickPlace;

	int insetX; // text inset in x from calltip border
	int widthArrow;
	int borderHeight;
	int verticalOffset; // pixel offset up or down of the calltip with respect to the line

	CallTip() noexcept;
	// Deleted so CallTip objects can not be copied.
	CallTip(const CallTip &) = delete;
	CallTip(CallTip &&) = delete;
	CallTip &operator=(const CallTip &) = delete;
	CallTip &operator=(CallTip &&) = delete;
	~CallTip();

	void PaintCT(Surface *surfaceWindow);

	void MouseClick(Point pt) noexcept;

	/// Setup the calltip and return a rectangle of the area required.
	PRectangle CallTipStart(Sci::Position pos, Point pt, int textHeight, const char *defn,
		int codePage_, Surface *surfaceMeasure, const std::shared_ptr<Font> &font_);

	void CallTipCancel() noexcept;

	/// Set a range of characters to be displayed in a highlight style.
	/// Commonly used to highlight the current parameter.
	void SetHighlight(size_t start, size_t end);

	/// Set the tab size in pixels for the call tip. 0 or -ve means no tab expand.
	void SetTabSize(int tabSz) noexcept;

	/// Set calltip position.
	void SetPosition(bool aboveText) noexcept;

	/// Used to determine which STYLE_xxxx to use for call tip information
	bool UseStyleCallTip() const noexcept;

	// Modify foreground and background colours
	void SetForeBack(ColourRGBA fore, ColourRGBA back) noexcept;
};

}

#endif


================================================
FILE: Libraries/scintilla/src/CaseConvert.cxx
================================================
// Scintilla source code edit control
// Encoding: UTF-8
/** @file CaseConvert.cxx
 ** Case fold characters and convert them to upper or lower case.
 ** Tables automatically regenerated by scripts/GenerateCaseConvert.py
 ** Should only be rarely regenerated for new versions of Unicode.
 **/
// Copyright 2013 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#include <cassert>
#include <cstring>

#include <stdexcept>
#include <string>
#include <string_view>
#include <vector>
#include <algorithm>

#include "CaseConvert.h"
#include "UniConversion.h"

using namespace Scintilla::Internal;

namespace {
	// Use an unnamed namespace to protect the declarations from name conflicts

// Unicode code points are ordered by groups and follow patterns.
// Most characters (pitch==1) are in ranges for a particular alphabet and their
// upper case forms are a fixed distance away.
// Another pattern (pitch==2) is where each lower case letter is preceded by
// the upper case form. These are also grouped into ranges.

constexpr int symmetricCaseConversionRanges[] = {
//lower, upper, range length, range pitch
//++Autogenerated -- start of section automatically generated
//**\(\*\n\)
97,65,26,1,
224,192,23,1,
248,216,7,1,
257,256,24,2,
314,313,8,2,
331,330,23,2,
462,461,8,2,
479,478,9,2,
505,504,20,2,
547,546,9,2,
583,582,5,2,
945,913,17,1,
963,931,9,1,
985,984,12,2,
1072,1040,32,1,
1104,1024,16,1,
1121,1120,17,2,
1163,1162,27,2,
1218,1217,7,2,
1233,1232,48,2,
1377,1329,38,1,
4304,7312,43,1,
7681,7680,75,2,
7841,7840,48,2,
7936,7944,8,1,
7952,7960,6,1,
7968,7976,8,1,
7984,7992,8,1,
8000,8008,6,1,
8032,8040,8,1,
8560,8544,16,1,
9424,9398,26,1,
11312,11264,48,1,
11393,11392,50,2,
11520,4256,38,1,
42561,42560,23,2,
42625,42624,14,2,
42787,42786,7,2,
42803,42802,31,2,
42879,42878,5,2,
42903,42902,10,2,
42933,42932,8,2,
65345,65313,26,1,
66600,66560,40,1,
66776,66736,36,1,
66967,66928,11,1,
66979,66940,15,1,
66995,66956,7,1,
68800,68736,51,1,
71872,71840,32,1,
93792,93760,32,1,
125218,125184,34,1,

//--Autogenerated -- end of section automatically generated
};

// Code points that are symmetric but don't fit into a range of similar characters
// are listed here.

constexpr int symmetricCaseConversions[] = {
//lower, upper
//++Autogenerated -- start of section automatically generated
//**1 \(\*\n\)
255,376,
307,306,
309,308,
311,310,
378,377,
380,379,
382,381,
384,579,
387,386,
389,388,
392,391,
396,395,
402,401,
405,502,
409,408,
410,573,
414,544,
417,416,
419,418,
421,420,
424,423,
429,428,
432,431,
436,435,
438,437,
441,440,
445,444,
447,503,
454,452,
457,455,
460,458,
477,398,
499,497,
501,500,
572,571,
575,11390,
576,11391,
578,577,
592,11375,
593,11373,
594,11376,
595,385,
596,390,
598,393,
599,394,
601,399,
603,400,
604,42923,
608,403,
609,42924,
611,404,
613,42893,
614,42922,
616,407,
617,406,
618,42926,
619,11362,
620,42925,
623,412,
625,11374,
626,413,
629,415,
637,11364,
640,422,
642,42949,
643,425,
647,42929,
648,430,
649,580,
650,433,
651,434,
652,581,
658,439,
669,42930,
670,42928,
881,880,
883,882,
887,886,
891,1021,
892,1022,
893,1023,
940,902,
941,904,
942,905,
943,906,
972,908,
973,910,
974,911,
983,975,
1010,1017,
1011,895,
1016,1015,
1019,1018,
1231,1216,
4349,7357,
4350,7358,
4351,7359,
7545,42877,
7549,11363,
7566,42950,
8017,8025,
8019,8027,
8021,8029,
8023,8031,
8048,8122,
8049,8123,
8050,8136,
8051,8137,
8052,8138,
8053,8139,
8054,8154,
8055,8155,
8056,8184,
8057,8185,
8058,8170,
8059,8171,
8060,8186,
8061,8187,
8112,8120,
8113,8121,
8144,8152,
8145,8153,
8160,8168,
8161,8169,
8165,8172,
8526,8498,
8580,8579,
11361,11360,
11365,570,
11366,574,
11368,11367,
11370,11369,
11372,11371,
11379,11378,
11382,11381,
11500,11499,
11502,11501,
11507,11506,
11559,4295,
11565,4301,
42874,42873,
42876,42875,
42892,42891,
42897,42896,
42899,42898,
42900,42948,
42952,42951,
42954,42953,
42961,42960,
42967,42966,
42969,42968,
42998,42997,
43859,42931,
67003,66964,
67004,66965,

//--Autogenerated -- end of section automatically generated
};

// Characters that have complex case conversions are listed here.
// This includes cases where more than one character is needed for a conversion,
// folding is different to lowering, or (as appropriate) upper(lower(x)) != x or
// lower(upper(x)) != x.

constexpr std::string_view complexCaseConversions =
// Original | Folded | Upper | Lower |
//++Autogenerated -- start of section automatically generated
//**2 \(\*\n\)
"\xc2\xb5|\xce\xbc|\xce\x9c||"
"\xc3\x9f|ss|SS||"
"\xc4\xb0|i\xcc\x87||i\xcc\x87|"
"\xc4\xb1||I||"
"\xc5\x89|\xca\xbcn|\xca\xbcN||"
"\xc5\xbf|s|S||"
"\xc7\x85|\xc7\x86|\xc7\x84|\xc7\x86|"
"\xc7\x88|\xc7\x89|\xc7\x87|\xc7\x89|"
"\xc7\x8b|\xc7\x8c|\xc7\x8a|\xc7\x8c|"
"\xc7\xb0|j\xcc\x8c|J\xcc\x8c||"
"\xc7\xb2|\xc7\xb3|\xc7\xb1|\xc7\xb3|"
"\xcd\x85|\xce\xb9|\xce\x99||"
"\xce\x90|\xce\xb9\xcc\x88\xcc\x81|\xce\x99\xcc\x88\xcc\x81||"
"\xce\xb0|\xcf\x85\xcc\x88\xcc\x81|\xce\xa5\xcc\x88\xcc\x81||"
"\xcf\x82|\xcf\x83|\xce\xa3||"
"\xcf\x90|\xce\xb2|\xce\x92||"
"\xcf\x91|\xce\xb8|\xce\x98||"
"\xcf\x95|\xcf\x86|\xce\xa6||"
"\xcf\x96|\xcf\x80|\xce\xa0||"
"\xcf\xb0|\xce\xba|\xce\x9a||"
"\xcf\xb1|\xcf\x81|\xce\xa1||"
"\xcf\xb4|\xce\xb8||\xce\xb8|"
"\xcf\xb5|\xce\xb5|\xce\x95||"
"\xd6\x87|\xd5\xa5\xd6\x82|\xd4\xb5\xd5\x92||"
"\xe1\x8e\xa0|||\xea\xad\xb0|"
"\xe1\x8e\xa1|||\xea\xad\xb1|"
"\xe1\x8e\xa2|||\xea\xad\xb2|"
"\xe1\x8e\xa3|||\xea\xad\xb3|"
"\xe1\x8e\xa4|||\xea\xad\xb4|"
"\xe1\x8e\xa5|||\xea\xad\xb5|"
"\xe1\x8e\xa6|||\xea\xad\xb6|"
"\xe1\x8e\xa7|||\xea\xad\xb7|"
"\xe1\x8e\xa8|||\xea\xad\xb8|"
"\xe1\x8e\xa9|||\xea\xad\xb9|"
"\xe1\x8e\xaa|||\xea\xad\xba|"
"\xe1\x8e\xab|||\xea\xad\xbb|"
"\xe1\x8e\xac|||\xea\xad\xbc|"
"\xe1\x8e\xad|||\xea\xad\xbd|"
"\xe1\x8e\xae|||\xea\xad\xbe|"
"\xe1\x8e\xaf|||\xea\xad\xbf|"
"\xe1\x8e\xb0|||\xea\xae\x80|"
"\xe1\x8e\xb1|||\xea\xae\x81|"
"\xe1\x8e\xb2|||\xea\xae\x82|"
"\xe1\x8e\xb3|||\xea\xae\x83|"
"\xe1\x8e\xb4|||\xea\xae\x84|"
"\xe1\x8e\xb5|||\xea\xae\x85|"
"\xe1\x8e\xb6|||\xea\xae\x86|"
"\xe1\x8e\xb7|||\xea\xae\x87|"
"\xe1\x8e\xb8|||\xea\xae\x88|"
"\xe1\x8e\xb9|||\xea\xae\x89|"
"\xe1\x8e\xba|||\xea\xae\x8a|"
"\xe1\x8e\xbb|||\xea\xae\x8b|"
"\xe1\x8e\xbc|||\xea\xae\x8c|"
"\xe1\x8e\xbd|||\xea\xae\x8d|"
"\xe1\x8e\xbe|||\xea\xae\x8e|"
"\xe1\x8e\xbf|||\xea\xae\x8f|"
"\xe1\x8f\x80|||\xea\xae\x90|"
"\xe1\x8f\x81|||\xea\xae\x91|"
"\xe1\x8f\x82|||\xea\xae\x92|"
"\xe1\x8f\x83|||\xea\xae\x93|"
"\xe1\x8f\x84|||\xea\xae\x94|"
"\xe1\x8f\x85|||\xea\xae\x95|"
"\xe1\x8f\x86|||\xea\xae\x96|"
"\xe1\x8f\x87|||\xea\xae\x97|"
"\xe1\x8f\x88|||\xea\xae\x98|"
"\xe1\x8f\x89|||\xea\xae\x99|"
"\xe1\x8f\x8a|||\xea\xae\x9a|"
"\xe1\x8f\x8b|||\xea\xae\x9b|"
"\xe1\x8f\x8c|||\xea\xae\x9c|"
"\xe1\x8f\x8d|||\xea\xae\x9d|"
"\xe1\x8f\x8e|||\xea\xae\x9e|"
"\xe1\x8f\x8f|||\xea\xae\x9f|"
"\xe1\x8f\x90|||\xea\xae\xa0|"
"\xe1\x8f\x91|||\xea\xae\xa1|"
"\xe1\x8f\x92|||\xea\xae\xa2|"
"\xe1\x8f\x93|||\xea\xae\xa3|"
"\xe1\x8f\x94|||\xea\xae\xa4|"
"\xe1\x8f\x95|||\xea\xae\xa5|"
"\xe1\x8f\x96|||\xea\xae\xa6|"
"\xe1\x8f\x97|||\xea\xae\xa7|"
"\xe1\x8f\x98|||\xea\xae\xa8|"
"\xe1\x8f\x99|||\xea\xae\xa9|"
"\xe1\x8f\x9a|||\xea\xae\xaa|"
"\xe1\x8f\x9b|||\xea\xae\xab|"
"\xe1\x8f\x9c|||\xea\xae\xac|"
"\xe1\x8f\x9d|||\xea\xae\xad|"
"\xe1\x8f\x9e|||\xea\xae\xae|"
"\xe1\x8f\x9f|||\xea\xae\xaf|"
"\xe1\x8f\xa0|||\xea\xae\xb0|"
"\xe1\x8f\xa1|||\xea\xae\xb1|"
"\xe1\x8f\xa2|||\xea\xae\xb2|"
"\xe1\x8f\xa3|||\xea\xae\xb3|"
"\xe1\x8f\xa4|||\xea\xae\xb4|"
"\xe1\x8f\xa5|||\xea\xae\xb5|"
"\xe1\x8f\xa6|||\xea\xae\xb6|"
"\xe1\x8f\xa7|||\xea\xae\xb7|"
"\xe1\x8f\xa8|||\xea\xae\xb8|"
"\xe1\x8f\xa9|||\xea\xae\xb9|"
"\xe1\x8f\xaa|||\xea\xae\xba|"
"\xe1\x8f\xab|||\xea\xae\xbb|"
"\xe1\x8f\xac|||\xea\xae\xbc|"
"\xe1\x8f\xad|||\xea\xae\xbd|"
"\xe1\x8f\xae|||\xea\xae\xbe|"
"\xe1\x8f\xaf|||\xea\xae\xbf|"
"\xe1\x8f\xb0|||\xe1\x8f\xb8|"
"\xe1\x8f\xb1|||\xe1\x8f\xb9|"
"\xe1\x8f\xb2|||\xe1\x8f\xba|"
"\xe1\x8f\xb3|||\xe1\x8f\xbb|"
"\xe1\x8f\xb4|||\xe1\x8f\xbc|"
"\xe1\x8f\xb5|||\xe1\x8f\xbd|"
"\xe1\x8f\xb8|\xe1\x8f\xb0|\xe1\x8f\xb0||"
"\xe1\x8f\xb9|\xe1\x8f\xb1|\xe1\x8f\xb1||"
"\xe1\x8f\xba|\xe1\x8f\xb2|\xe1\x8f\xb2||"
"\xe1\x8f\xbb|\xe1\x8f\xb3|\xe1\x8f\xb3||"
"\xe1\x8f\xbc|\xe1\x8f\xb4|\xe1\x8f\xb4||"
"\xe1\x8f\xbd|\xe1\x8f\xb5|\xe1\x8f\xb5||"
"\xe1\xb2\x80|\xd0\xb2|\xd0\x92||"
"\xe1\xb2\x81|\xd0\xb4|\xd0\x94||"
"\xe1\xb2\x82|\xd0\xbe|\xd0\x9e||"
"\xe1\xb2\x83|\xd1\x81|\xd0\xa1||"
"\xe1\xb2\x84|\xd1\x82|\xd0\xa2||"
"\xe1\xb2\x85|\xd1\x82|\xd0\xa2||"
"\xe1\xb2\x86|\xd1\x8a|\xd0\xaa||"
"\xe1\xb2\x87|\xd1\xa3|\xd1\xa2||"
"\xe1\xb2\x88|\xea\x99\x8b|\xea\x99\x8a||"
"\xe1\xba\x96|h\xcc\xb1|H\xcc\xb1||"
"\xe1\xba\x97|t\xcc\x88|T\xcc\x88||"
"\xe1\xba\x98|w\xcc\x8a|W\xcc\x8a||"
"\xe1\xba\x99|y\xcc\x8a|Y\xcc\x8a||"
"\xe1\xba\x9a|a\xca\xbe|A\xca\xbe||"
"\xe1\xba\x9b|\xe1\xb9\xa1|\xe1\xb9\xa0||"
"\xe1\xba\x9e|ss||\xc3\x9f|"
"\xe1\xbd\x90|\xcf\x85\xcc\x93|\xce\xa5\xcc\x93||"
"\xe1\xbd\x92|\xcf\x85\xcc\x93\xcc\x80|\xce\xa5\xcc\x93\xcc\x80||"
"\xe1\xbd\x94|\xcf\x85\xcc\x93\xcc\x81|\xce\xa5\xcc\x93\xcc\x81||"
"\xe1\xbd\x96|\xcf\x85\xcc\x93\xcd\x82|\xce\xa5\xcc\x93\xcd\x82||"
"\xe1\xbe\x80|\xe1\xbc\x80\xce\xb9|\xe1\xbc\x88\xce\x99||"
"\xe1\xbe\x81|\xe1\xbc\x81\xce\xb9|\xe1\xbc\x89\xce\x99||"
"\xe1\xbe\x82|\xe1\xbc\x82\xce\xb9|\xe1\xbc\x8a\xce\x99||"
"\xe1\xbe\x83|\xe1\xbc\x83\xce\xb9|\xe1\xbc\x8b\xce\x99||"
"\xe1\xbe\x84|\xe1\xbc\x84\xce\xb9|\xe1\xbc\x8c\xce\x99||"
"\xe1\xbe\x85|\xe1\xbc\x85\xce\xb9|\xe1\xbc\x8d\xce\x99||"
"\xe1\xbe\x86|\xe1\xbc\x86\xce\xb9|\xe1\xbc\x8e\xce\x99||"
"\xe1\xbe\x87|\xe1\xbc\x87\xce\xb9|\xe1\xbc\x8f\xce\x99||"
"\xe1\xbe\x88|\xe1\xbc\x80\xce\xb9|\xe1\xbc\x88\xce\x99|\xe1\xbe\x80|"
"\xe1\xbe\x89|\xe1\xbc\x81\xce\xb9|\xe1\xbc\x89\xce\x99|\xe1\xbe\x81|"
"\xe1\xbe\x8a|\xe1\xbc\x82\xce\xb9|\xe1\xbc\x8a\xce\x99|\xe1\xbe\x82|"
"\xe1\xbe\x8b|\xe1\xbc\x83\xce\xb9|\xe1\xbc\x8b\xce\x99|\xe1\xbe\x83|"
"\xe1\xbe\x8c|\xe1\xbc\x84\xce\xb9|\xe1\xbc\x8c\xce\x99|\xe1\xbe\x84|"
"\xe1\xbe\x8d|\xe1\xbc\x85\xce\xb9|\xe1\xbc\x8d\xce\x99|\xe1\xbe\x85|"
"\xe1\xbe\x8e|\xe1\xbc\x86\xce\xb9|\xe1\xbc\x8e\xce\x99|\xe1\xbe\x86|"
"\xe1\xbe\x8f|\xe1\xbc\x87\xce\xb9|\xe1\xbc\x8f\xce\x99|\xe1\xbe\x87|"
"\xe1\xbe\x90|\xe1\xbc\xa0\xce\xb9|\xe1\xbc\xa8\xce\x99||"
"\xe1\xbe\x91|\xe1\xbc\xa1\xce\xb9|\xe1\xbc\xa9\xce\x99||"
"\xe1\xbe\x92|\xe1\xbc\xa2\xce\xb9|\xe1\xbc\xaa\xce\x99||"
"\xe1\xbe\x93|\xe1\xbc\xa3\xce\xb9|\xe1\xbc\xab\xce\x99||"
"\xe1\xbe\x94|\xe1\xbc\xa4\xce\xb9|\xe1\xbc\xac\xce\x99||"
"\xe1\xbe\x95|\xe1\xbc\xa5\xce\xb9|\xe1\xbc\xad\xce\x99||"
"\xe1\xbe\x96|\xe1\xbc\xa6\xce\xb9|\xe1\xbc\xae\xce\x99||"
"\xe1\xbe\x97|\xe1\xbc\xa7\xce\xb9|\xe1\xbc\xaf\xce\x99||"
"\xe1\xbe\x98|\xe1\xbc\xa0\xce\xb9|\xe1\xbc\xa8\xce\x99|\xe1\xbe\x90|"
"\xe1\xbe\x99|\xe1\xbc\xa1\xce\xb9|\xe1\xbc\xa9\xce\x99|\xe1\xbe\x91|"
"\xe1\xbe\x9a|\xe1\xbc\xa2\xce\xb9|\xe1\xbc\xaa\xce\x99|\xe1\xbe\x92|"
"\xe1\xbe\x9b|\xe1\xbc\xa3\xce\xb9|\xe1\xbc\xab\xce\x99|\xe1\xbe\x93|"
"\xe1\xbe\x9c|\xe1\xbc\xa4\xce\xb9|\xe1\xbc\xac\xce\x99|\xe1\xbe\x94|"
"\xe1\xbe\x9d|\xe1\xbc\xa5\xce\xb9|\xe1\xbc\xad\xce\x99|\xe1\xbe\x95|"
"\xe1\xbe\x9e|\xe1\xbc\xa6\xce\xb9|\xe1\xbc\xae\xce\x99|\xe1\xbe\x96|"
"\xe1\xbe\x9f|\xe1\xbc\xa7\xce\xb9|\xe1\xbc\xaf\xce\x99|\xe1\xbe\x97|"
"\xe1\xbe\xa0|\xe1\xbd\xa0\xce\xb9|\xe1\xbd\xa8\xce\x99||"
"\xe1\xbe\xa1|\xe1\xbd\xa1\xce\xb9|\xe1\xbd\xa9\xce\x99||"
"\xe1\xbe\xa2|\xe1\xbd\xa2\xce\xb9|\xe1\xbd\xaa\xce\x99||"
"\xe1\xbe\xa3|\xe1\xbd\xa3\xce\xb9|\xe1\xbd\xab\xce\x99||"
"\xe1\xbe\xa4|\xe1\xbd\xa4\xce\xb9|\xe1\xbd\xac\xce\x99||"
"\xe1\xbe\xa5|\xe1\xbd\xa5\xce\xb9|\xe1\xbd\xad\xce\x99||"
"\xe1\xbe\xa6|\xe1\xbd\xa6\xce\xb9|\xe1\xbd\xae\xce\x99||"
"\xe1\xbe\xa7|\xe1\xbd\xa7\xce\xb9|\xe1\xbd\xaf\xce\x99||"
"\xe1\xbe\xa8|\xe1\xbd\xa0\xce\xb9|\xe1\xbd\xa8\xce\x99|\xe1\xbe\xa0|"
"\xe1\xbe\xa9|\xe1\xbd\xa1\xce\xb9|\xe1\xbd\xa9\xce\x99|\xe1\xbe\xa1|"
"\xe1\xbe\xaa|\xe1\xbd\xa2\xce\xb9|\xe1\xbd\xaa\xce\x99|\xe1\xbe\xa2|"
"\xe1\xbe\xab|\xe1\xbd\xa3\xce\xb9|\xe1\xbd\xab\xce\x99|\xe1\xbe\xa3|"
"\xe1\xbe\xac|\xe1\xbd\xa4\xce\xb9|\xe1\xbd\xac\xce\x99|\xe1\xbe\xa4|"
"\xe1\xbe\xad|\xe1\xbd\xa5\xce\xb9|\xe1\xbd\xad\xce\x99|\xe1\xbe\xa5|"
"\xe1\xbe\xae|\xe1\xbd\xa6\xce\xb9|\xe1\xbd\xae\xce\x99|\xe1\xbe\xa6|"
"\xe1\xbe\xaf|\xe1\xbd\xa7\xce\xb9|\xe1\xbd\xaf\xce\x99|\xe1\xbe\xa7|"
"\xe1\xbe\xb2|\xe1\xbd\xb0\xce\xb9|\xe1\xbe\xba\xce\x99||"
"\xe1\xbe\xb3|\xce\xb1\xce\xb9|\xce\x91\xce\x99||"
"\xe1\xbe\xb4|\xce\xac\xce\xb9|\xce\x86\xce\x99||"
"\xe1\xbe\xb6|\xce\xb1\xcd\x82|\xce\x91\xcd\x82||"
"\xe1\xbe\xb7|\xce\xb1\xcd\x82\xce\xb9|\xce\x91\xcd\x82\xce\x99||"
"\xe1\xbe\xbc|\xce\xb1\xce\xb9|\xce\x91\xce\x99|\xe1\xbe\xb3|"
"\xe1\xbe\xbe|\xce\xb9|\xce\x99||"
"\xe1\xbf\x82|\xe1\xbd\xb4\xce\xb9|\xe1\xbf\x8a\xce\x99||"
"\xe1\xbf\x83|\xce\xb7\xce\xb9|\xce\x97\xce\x99||"
"\xe1\xbf\x84|\xce\xae\xce\xb9|\xce\x89\xce\x99||"
"\xe1\xbf\x86|\xce\xb7\xcd\x82|\xce\x97\xcd\x82||"
"\xe1\xbf\x87|\xce\xb7\xcd\x82\xce\xb9|\xce\x97\xcd\x82\xce\x99||"
"\xe1\xbf\x8c|\xce\xb7\xce\xb9|\xce\x97\xce\x99|\xe1\xbf\x83|"
"\xe1\xbf\x92|\xce\xb9\xcc\x88\xcc\x80|\xce\x99\xcc\x88\xcc\x80||"
"\xe1\xbf\x93|\xce\xb9\xcc\x88\xcc\x81|\xce\x99\xcc\x88\xcc\x81||"
"\xe1\xbf\x96|\xce\xb9\xcd\x82|\xce\x99\xcd\x82||"
"\xe1\xbf\x97|\xce\xb9\xcc\x88\xcd\x82|\xce\x99\xcc\x88\xcd\x82||"
"\xe1\xbf\xa2|\xcf\x85\xcc\x88\xcc\x80|\xce\xa5\xcc\x88\xcc\x80||"
"\xe1\xbf\xa3|\xcf\x85\xcc\x88\xcc\x81|\xce\xa5\xcc\x88\xcc\x81||"
"\xe1\xbf\xa4|\xcf\x81\xcc\x93|\xce\xa1\xcc\x93||"
"\xe1\xbf\xa6|\xcf\x85\xcd\x82|\xce\xa5\xcd\x82||"
"\xe1\xbf\xa7|\xcf\x85\xcc\x88\xcd\x82|\xce\xa5\xcc\x88\xcd\x82||"
"\xe1\xbf\xb2|\xe1\xbd\xbc\xce\xb9|\xe1\xbf\xba\xce\x99||"
"\xe1\xbf\xb3|\xcf\x89\xce\xb9|\xce\xa9\xce\x99||"
"\xe1\xbf\xb4|\xcf\x8e\xce\xb9|\xce\x8f\xce\x99||"
"\xe1\xbf\xb6|\xcf\x89\xcd\x82|\xce\xa9\xcd\x82||"
"\xe1\xbf\xb7|\xcf\x89\xcd\x82\xce\xb9|\xce\xa9\xcd\x82\xce\x99||"
"\xe1\xbf\xbc|\xcf\x89\xce\xb9|\xce\xa9\xce\x99|\xe1\xbf\xb3|"
"\xe2\x84\xa6|\xcf\x89||\xcf\x89|"
"\xe2\x84\xaa|k||k|"
"\xe2\x84\xab|\xc3\xa5||\xc3\xa5|"
"\xea\xad\xb0|\xe1\x8e\xa0|\xe1\x8e\xa0||"
"\xea\xad\xb1|\xe1\x8e\xa1|\xe1\x8e\xa1||"
"\xea\xad\xb2|\xe1\x8e\xa2|\xe1\x8e\xa2||"
"\xea\xad\xb3|\xe1\x8e\xa3|\xe1\x8e\xa3||"
"\xea\xad\xb4|\xe1\x8e\xa4|\xe1\x8e\xa4||"
"\xea\xad\xb5|\xe1\x8e\xa5|\xe1\x8e\xa5||"
"\xea\xad\xb6|\xe1\x8e\xa6|\xe1\x8e\xa6||"
"\xea\xad\xb7|\xe1\x8e\xa7|\xe1\x8e\xa7||"
"\xea\xad\xb8|\xe1\x8e\xa8|\xe1\x8e\xa8||"
"\xea\xad\xb9|\xe1\x8e\xa9|\xe1\x8e\xa9||"
"\xea\xad\xba|\xe1\x8e\xaa|\xe1\x8e\xaa||"
"\xea\xad\xbb|\xe1\x8e\xab|\xe1\x8e\xab||"
"\xea\xad\xbc|\xe1\x8e\xac|\xe1\x8e\xac||"
"\xea\xad\xbd|\xe1\x8e\xad|\xe1\x8e\xad||"
"\xea\xad\xbe|\xe1\x8e\xae|\xe1\x8e\xae||"
"\xea\xad\xbf|\xe1\x8e\xaf|\xe1\x8e\xaf||"
"\xea\xae\x80|\xe1\x8e\xb0|\xe1\x8e\xb0||"
"\xea\xae\x81|\xe1\x8e\xb1|\xe1\x8e\xb1||"
"\xea\xae\x82|\xe1\x8e\xb2|\xe1\x8e\xb2||"
"\xea\xae\x83|\xe1\x8e\xb3|\xe1\x8e\xb3||"
"\xea\xae\x84|\xe1\x8e\xb4|\xe1\x8e\xb4||"
"\xea\xae\x85|\xe1\x8e\xb5|\xe1\x8e\xb5||"
"\xea\xae\x86|\xe1\x8e\xb6|\xe1\x8e\xb6||"
"\xea\xae\x87|\xe1\x8e\xb7|\xe1\x8e\xb7||"
"\xea\xae\x88|\xe1\x8e\xb8|\xe1\x8e\xb8||"
"\xea\xae\x89|\xe1\x8e\xb9|\xe1\x8e\xb9||"
"\xea\xae\x8a|\xe1\x8e\xba|\xe1\x8e\xba||"
"\xea\xae\x8b|\xe1\x8e\xbb|\xe1\x8e\xbb||"
"\xea\xae\x8c|\xe1\x8e\xbc|\xe1\x8e\xbc||"
"\xea\xae\x8d|\xe1\x8e\xbd|\xe1\x8e\xbd||"
"\xea\xae\x8e|\xe1\x8e\xbe|\xe1\x8e\xbe||"
"\xea\xae\x8f|\xe1\x8e\xbf|\xe1\x8e\xbf||"
"\xea\xae\x90|\xe1\x8f\x80|\xe1\x8f\x80||"
"\xea\xae\x91|\xe1\x8f\x81|\xe1\x8f\x81||"
"\xea\xae\x92|\xe1\x8f\x82|\xe1\x8f\x82||"
"\xea\xae\x93|\xe1\x8f\x83|\xe1\x8f\x83||"
"\xea\xae\x94|\xe1\x8f\x84|\xe1\x8f\x84||"
"\xea\xae\x95|\xe1\x8f\x85|\xe1\x8f\x85||"
"\xea\xae\x96|\xe1\x8f\x86|\xe1\x8f\x86||"
"\xea\xae\x97|\xe1\x8f\x87|\xe1\x8f\x87||"
"\xea\xae\x98|\xe1\x8f\x88|\xe1\x8f\x88||"
"\xea\xae\x99|\xe1\x8f\x89|\xe1\x8f\x89||"
"\xea\xae\x9a|\xe1\x8f\x8a|\xe1\x8f\x8a||"
"\xea\xae\x9b|\xe1\x8f\x8b|\xe1\x8f\x8b||"
"\xea\xae\x9c|\xe1\x8f\x8c|\xe1\x8f\x8c||"
"\xea\xae\x9d|\xe1\x8f\x8d|\xe1\x8f\x8d||"
"\xea\xae\x9e|\xe1\x8f\x8e|\xe1\x8f\x8e||"
"\xea\xae\x9f|\xe1\x8f\x8f|\xe1\x8f\x8f||"
"\xea\xae\xa0|\xe1\x8f\x90|\xe1\x8f\x90||"
"\xea\xae\xa1|\xe1\x8f\x91|\xe1\x8f\x91||"
"\xea\xae\xa2|\xe1\x8f\x92|\xe1\x8f\x92||"
"\xea\xae\xa3|\xe1\x8f\x93|\xe1\x8f\x93||"
"\xea\xae\xa4|\xe1\x8f\x94|\xe1\x8f\x94||"
"\xea\xae\xa5|\xe1\x8f\x95|\xe1\x8f\x95||"
"\xea\xae\xa6|\xe1\x8f\x96|\xe1\x8f\x96||"
"\xea\xae\xa7|\xe1\x8f\x97|\xe1\x8f\x97||"
"\xea\xae\xa8|\xe1\x8f\x98|\xe1\x8f\x98||"
"\xea\xae\xa9|\xe1\x8f\x99|\xe1\x8f\x99||"
"\xea\xae\xaa|\xe1\x8f\x9a|\xe1\x8f\x9a||"
"\xea\xae\xab|\xe1\x8f\x9b|\xe1\x8f\x9b||"
"\xea\xae\xac|\xe1\x8f\x9c|\xe1\x8f\x9c||"
"\xea\xae\xad|\xe1\x8f\x9d|\xe1\x8f\x9d||"
"\xea\xae\xae|\xe1\x8f\x9e|\xe1\x8f\x9e||"
"\xea\xae\xaf|\xe1\x8f\x9f|\xe1\x8f\x9f||"
"\xea\xae\xb0|\xe1\x8f\xa0|\xe1\x8f\xa0||"
"\xea\xae\xb1|\xe1\x8f\xa1|\xe1\x8f\xa1||"
"\xea\xae\xb2|\xe1\x8f\xa2|\xe1\x8f\xa2||"
"\xea\xae\xb3|\xe1\x8f\xa3|\xe1\x8f\xa3||"
"\xea\xae\xb4|\xe1\x8f\xa4|\xe1\x8f\xa4||"
"\xea\xae\xb5|\xe1\x8f\xa5|\xe1\x8f\xa5||"
"\xea\xae\xb6|\xe1\x8f\xa6|\xe1\x8f\xa6||"
"\xea\xae\xb7|\xe1\x8f\xa7|\xe1\x8f\xa7||"
"\xea\xae\xb8|\xe1\x8f\xa8|\xe1\x8f\xa8||"
"\xea\xae\xb9|\xe1\x8f\xa9|\xe1\x8f\xa9||"
"\xea\xae\xba|\xe1\x8f\xaa|\xe1\x8f\xaa||"
"\xea\xae\xbb|\xe1\x8f\xab|\xe1\x8f\xab||"
"\xea\xae\xbc|\xe1\x8f\xac|\xe1\x8f\xac||"
"\xea\xae\xbd|\xe1\x8f\xad|\xe1\x8f\xad||"
"\xea\xae\xbe|\xe1\x8f\xae|\xe1\x8f\xae||"
"\xea\xae\xbf|\xe1\x8f\xaf|\xe1\x8f\xaf||"
"\xef\xac\x80|ff|FF||"
"\xef\xac\x81|fi|FI||"
"\xef\xac\x82|fl|FL||"
"\xef\xac\x83|ffi|FFI||"
"\xef\xac\x84|ffl|FFL||"
"\xef\xac\x85|st|ST||"
"\xef\xac\x86|st|ST||"
"\xef\xac\x93|\xd5\xb4\xd5\xb6|\xd5\x84\xd5\x86||"
"\xef\xac\x94|\xd5\xb4\xd5\xa5|\xd5\x84\xd4\xb5||"
"\xef\xac\x95|\xd5\xb4\xd5\xab|\xd5\x84\xd4\xbb||"
"\xef\xac\x96|\xd5\xbe\xd5\xb6|\xd5\x8e\xd5\x86||"
"\xef\xac\x97|\xd5\xb4\xd5\xad|\xd5\x84\xd4\xbd||"

//--Autogenerated -- end of section automatically generated
;

// Maximum length of a case conversion result is 6 bytes in UTF-8
constexpr size_t maxConversionLength = 6;

class CaseConverter final : public ICaseConverter {
	struct ConversionString {
		char conversion[maxConversionLength+1]{};
	};
	// Conversions are initially store in a vector of structs but then decomposed into
	// parallel arrays as that is about 10% faster to search.
	struct CharacterConversion {
		int character = 0;
		ConversionString conversion;
		// Empty case: NUL -> "".
		CharacterConversion() noexcept = default;
		CharacterConversion(int character_, std::string_view conversion_) noexcept : character(character_) {
			assert(conversion_.length() <= maxConversionLength);
			try {
				// This can never fail as std::string_view::copy should only throw
				// std::out_of_range if pos > size() and pos == 0 here
				conversion_.copy(conversion.conversion, conversion_.length());
			} catch (...) {
				// Ignore any exception
			}
		}
		bool operator<(const CharacterConversion &other) const noexcept {
			return character < other.character;
		}
	};
	using CharacterToConversion = std::vector<CharacterConversion>;
	CharacterToConversion characterToConversion;
	// The parallel arrays
	std::vector<int> characters;
	std::vector<ConversionString> conversions;

public:
	CaseConverter() noexcept = default;
	[[nodiscard]] bool Initialised() const noexcept {
		return !characters.empty();
	}
	void Add(int character, std::string_view conversion_) {
		characterToConversion.emplace_back(character, conversion_);
	}
	const char *Find(int character) {
		const std::vector<int>::iterator it = std::lower_bound(characters.begin(), characters.end(), character);
		if (it == characters.end())
			return nullptr;
		else if (*it == character)
			return conversions[it - characters.begin()].conversion;
		else
			return nullptr;
	}
	size_t CaseConvertString(char *converted, size_t sizeConverted, const char *mixed, size_t lenMixed) override {
		size_t lenConverted = 0;
		size_t mixedPos = 0;
		unsigned char bytes[UTF8MaxBytes + 1]{};
		while (mixedPos < lenMixed) {
			const unsigned char leadByte = mixed[mixedPos];
			const char *caseConverted = nullptr;
			size_t lenMixedChar = 1;
			if (UTF8IsAscii(leadByte)) {
				caseConverted = Find(leadByte);
			} else {
				bytes[0] = leadByte;
				const int widthCharBytes = UTF8BytesOfLead[leadByte];
				for (int b=1; b<widthCharBytes; b++) {
					bytes[b] = (mixedPos+b < lenMixed) ? mixed[mixedPos+b] : 0;
				}
				const int classified = UTF8Classify(bytes, widthCharBytes);
				if (!(classified & UTF8MaskInvalid)) {
					// valid UTF-8
					lenMixedChar = classified & UTF8MaskWidth;
					const int character = UnicodeFromUTF8(bytes);
					caseConverted = Find(character);
				}
			}
			if (caseConverted) {
				// Character has a conversion so copy that conversion in
				while (*caseConverted) {
					converted[lenConverted++] = *caseConverted++;
					if (lenConverted >= sizeConverted)
						return 0;
				}
			} else {
				// Character has no conversion so copy the input to output
				for (size_t i=0; i<lenMixedChar; i++) {
					converted[lenConverted++] = mixed[mixedPos+i];
					if (lenConverted >= sizeConverted)
						return 0;
				}
			}
			mixedPos += lenMixedChar;
		}
		return lenConverted;
	}
	void FinishedAdding() {
		std::sort(characterToConversion.begin(), characterToConversion.end());
		characters.reserve(characterToConversion.size());
		conversions.reserve(characterToConversion.size());
		for (const CharacterConversion &chConv : characterToConversion) {
			characters.push_back(chConv.character);
			conversions.push_back(chConv.conversion);
		}
		// Empty the original calculated data completely
		CharacterToConversion().swap(characterToConversion);
	}
	void AddSymmetric(CaseConversion conversion, int lower, int upper);
	void SetupConversions(CaseConversion conversion);
};

CaseConverter caseConvList[3];

void CaseConverter::AddSymmetric(CaseConversion conversion, int lower, int upper) {
	const int character = (conversion == CaseConversion::upper) ? lower : upper;
	const int source = (conversion == CaseConversion::upper) ? upper : lower;
	char converted[maxConversionLength+1]{};
	UTF8FromUTF32Character(source, converted);
	Add(character, converted);
}

// Return the next '|' separated field and remove from view.
std::string_view NextField(std::string_view &view) {
	const size_t separatorPosition = view.find_first_of('|');
	const std::string_view field = view.substr(0, separatorPosition);
	if (separatorPosition == std::string_view::npos) {
		// Reached the end so empty the view
		view.remove_prefix(view.length());
	} else {
		// Remove the '|' from the view as well as the field
		view.remove_prefix(separatorPosition + 1);
	}
	return field;
}

void CaseConverter::SetupConversions(CaseConversion conversion) {
	// First initialize for the symmetric ranges
	for (size_t i=0; i<std::size(symmetricCaseConversionRanges);) {
		const int lower = symmetricCaseConversionRanges[i++];
		const int upper = symmetricCaseConversionRanges[i++];
		const int length = symmetricCaseConversionRanges[i++];
		const int pitch = symmetricCaseConversionRanges[i++];
		for (int j=0; j<length*pitch; j+=pitch) {
			AddSymmetric(conversion, lower+j, upper+j);
		}
	}
	// Add the symmetric singletons
	for (size_t i=0; i<std::size(symmetricCaseConversions);) {
		const int lower = symmetricCaseConversions[i++];
		const int upper = symmetricCaseConversions[i++];
		AddSymmetric(conversion, lower, upper);
	}
	// Add the complex cases
	std::string_view sComplex = complexCaseConversions;
	while (!sComplex.empty()) {
		const std::string_view originUTF8 = NextField(sComplex);
		const std::string_view foldedUTF8 = NextField(sComplex);
		const std::string_view upperUTF8 = NextField(sComplex);
		const std::string_view lowerUTF8 = NextField(sComplex);

		std::string_view converted;
		switch (conversion) {
		case CaseConversion::fold:
			converted = foldedUTF8;
			break;
		case CaseConversion::upper:
			converted = upperUTF8;
			break;
		case CaseConversion::lower:
		default:
			converted = lowerUTF8;
			break;
		}
		if (!converted.empty()) {
			const int character = UnicodeFromUTF8(originUTF8);
			Add(character, converted);
		}
	}

	FinishedAdding();
}

CaseConverter *ConverterForConversion(CaseConversion conversion) {
	const unsigned index = static_cast<unsigned>(conversion);
	assert(index < std::size(caseConvList));
	CaseConverter *pCaseConv = &caseConvList[index];
	if (!pCaseConv->Initialised()) {
		pCaseConv->SetupConversions(conversion);
	}
	return pCaseConv;
}

}

namespace Scintilla::Internal {

ICaseConverter *ConverterFor(CaseConversion conversion) {
	return ConverterForConversion(conversion);
}

const char *CaseConvert(int character, CaseConversion conversion) {
	CaseConverter *pCaseConv = ConverterForConversion(conversion);
	return pCaseConv->Find(character);
}

size_t CaseConvertString(char *converted, size_t sizeConverted, const char *mixed, size_t lenMixed, CaseConversion conversion) {
	CaseConverter *pCaseConv = ConverterForConversion(conversion);
	return pCaseConv->CaseConvertString(converted, sizeConverted, mixed, lenMixed);
}

std::string CaseConvertString(const std::string &s, CaseConversion conversion) {
	std::string retMapped(s.length() * maxExpansionCaseConversion, 0);
	const size_t lenMapped = CaseConvertString(retMapped.data(), retMapped.length(), s.c_str(), s.length(),
		conversion);
	retMapped.resize(lenMapped);
	return retMapped;
}

}


================================================
FILE: Libraries/scintilla/src/CaseConvert.h
================================================
// Scintilla source code edit control
// Encoding: UTF-8
/** @file CaseConvert.h
 ** Performs Unicode case conversions.
 ** Does not handle locale-sensitive case conversion.
 **/
// Copyright 2013 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#ifndef CASECONVERT_H
#define CASECONVERT_H

namespace Scintilla::Internal {

enum class CaseConversion {
	fold,
	upper,
	lower
};

class ICaseConverter {
public:
	virtual size_t CaseConvertString(char *converted, size_t sizeConverted, const char *mixed, size_t lenMixed) = 0;
};

ICaseConverter *ConverterFor(CaseConversion conversion);

// Returns a UTF-8 string. Empty when no conversion
const char *CaseConvert(int character, CaseConversion conversion);

// When performing CaseConvertString, the converted value may be up to 3 times longer than the input.
// Ligatures are often decomposed into multiple characters and long cases include:
// ΐ "\xce\x90" folds to ΐ "\xce\xb9\xcc\x88\xcc\x81"
constexpr size_t maxExpansionCaseConversion = 3;

// Converts a mixed case string using a particular conversion.
// Result may be a different length to input and the length is the return value.
// If there is not enough space then 0 is returned.
size_t CaseConvertString(char *converted, size_t sizeConverted, const char *mixed, size_t lenMixed, CaseConversion conversion);

// Converts a mixed case string using a particular conversion.
std::string CaseConvertString(const std::string &s, CaseConversion conversion);

}

#endif


================================================
FILE: Libraries/scintilla/src/CaseFolder.cxx
================================================
// Scintilla source code edit control
/** @file CaseFolder.cxx
 ** Classes for case folding.
 **/
// Copyright 1998-2013 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#include <stdexcept>
#include <vector>
#include <algorithm>

#include "CharacterType.h"
#include "CaseFolder.h"
#include "CaseConvert.h"

using namespace Scintilla::Internal;

namespace {

constexpr unsigned char IndexFromChar(char ch) {
	return static_cast<unsigned char>(ch);
}

}

CaseFolderTable::CaseFolderTable() noexcept : mapping{}  {
	StandardASCII();
}

size_t CaseFolderTable::Fold(char *folded, size_t sizeFolded, const char *mixed, size_t lenMixed) {
	if (lenMixed > sizeFolded) {
		return 0;
	}
	for (size_t i=0; i<lenMixed; i++) {
		folded[i] = mapping[IndexFromChar(mixed[i])];
	}
	return lenMixed;
}

void CaseFolderTable::SetTranslation(char ch, char chTranslation) noexcept {
	mapping[IndexFromChar(ch)] = chTranslation;
}

void CaseFolderTable::StandardASCII() noexcept {
	for (size_t iChar=0; iChar<std::size(mapping); iChar++) {
		mapping[iChar] = static_cast<char>(MakeLowerCase(iChar));
	}
}

CaseFolderUnicode::CaseFolderUnicode() {
	converter = ConverterFor(CaseConversion::fold);
}

size_t CaseFolderUnicode::Fold(char *folded, size_t sizeFolded, const char *mixed, size_t lenMixed) {
	if ((lenMixed == 1) && (sizeFolded > 0)) {
		folded[0] = mapping[IndexFromChar(mixed[0])];
		return 1;
	} else {
		return converter->CaseConvertString(folded, sizeFolded, mixed, lenMixed);
	}
}


================================================
FILE: Libraries/scintilla/src/CaseFolder.h
================================================
// Scintilla source code edit control
/** @file CaseFolder.h
 ** Classes for case folding.
 **/
// Copyright 1998-2013 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#ifndef CASEFOLDER_H
#define CASEFOLDER_H

namespace Scintilla::Internal {

class CaseFolder {
public:
	CaseFolder() = default;
	// Deleted so CaseFolder objects can not be copied.
	CaseFolder(const CaseFolder &source) = delete;
	CaseFolder(CaseFolder &&) = delete;
	CaseFolder &operator=(const CaseFolder &) = delete;
	CaseFolder &operator=(CaseFolder &&) = delete;
	virtual ~CaseFolder() = default;
	virtual size_t Fold(char *folded, size_t sizeFolded, const char *mixed, size_t lenMixed) = 0;
};

class CaseFolderTable : public CaseFolder {
protected:
	char mapping[256];
public:
	CaseFolderTable() noexcept;
	size_t Fold(char *folded, size_t sizeFolded, const char *mixed, size_t lenMixed) override;
	void SetTranslation(char ch, char chTranslation) noexcept;
	void StandardASCII() noexcept;
};

class ICaseConverter;

class CaseFolderUnicode : public CaseFolderTable {
	ICaseConverter *converter;
public:
	CaseFolderUnicode();
	size_t Fold(char *folded, size_t sizeFolded, const char *mixed, size_t lenMixed) override;
};

}

#endif


================================================
FILE: Libraries/scintilla/src/CellBuffer.cxx
================================================
// Scintilla source code edit control
/** @file CellBuffer.cxx
 ** Manages a buffer of cells.
 **/
// Copyright 1998-2001 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#include <cstddef>
#include <cstdlib>
#include <cstdint>
#include <cassert>
#include <cstring>
#include <cstdio>
#include <cstdarg>
#include <climits>

#include <stdexcept>
#include <string>
#include <string_view>
#include <vector>
#include <optional>
#include <algorithm>
#include <memory>

#include "ScintillaTypes.h"

#include "Debugging.h"

#include "Position.h"
#include "SplitVector.h"
#include "Partitioning.h"
#include "RunStyles.h"
#include "SparseVector.h"
#include "ChangeHistory.h"
#include "CellBuffer.h"
#include "UndoHistory.h"
#include "UniConversion.h"

namespace Scintilla::Internal {

struct CountWidths {
	// Measures the number of characters in a string divided into those
	// from the Base Multilingual Plane and those from other planes.
	Sci::Position countBasePlane;
	Sci::Position countOtherPlanes;
	explicit CountWidths(Sci::Position countBasePlane_=0, Sci::Position countOtherPlanes_=0) noexcept :
		countBasePlane(countBasePlane_),
		countOtherPlanes(countOtherPlanes_) {
	}
	CountWidths operator-() const noexcept {
		return CountWidths(-countBasePlane, -countOtherPlanes);
	}
	Sci::Position WidthUTF32() const noexcept {
		// All code points take one code unit in UTF-32.
		return countBasePlane + countOtherPlanes;
	}
	Sci::Position WidthUTF16() const noexcept {
		// UTF-16 takes 2 code units for other planes
		return countBasePlane + 2 * countOtherPlanes;
	}
	void CountChar(int lenChar) noexcept {
		if (lenChar == 4) {
			countOtherPlanes++;
		} else {
			countBasePlane++;
		}
	}
};

class ILineVector {
public:
	virtual void Init() = 0;
	virtual void SetPerLine(PerLine *pl) noexcept = 0;
	virtual void InsertText(Sci::Line line, Sci::Position delta) noexcept = 0;
	virtual void InsertLine(Sci::Line line, Sci::Position position, bool lineStart) = 0;
	virtual void InsertLines(Sci::Line line, const Sci::Position *positions, size_t lines, bool lineStart) = 0;
	virtual void SetLineStart(Sci::Line line, Sci::Position position) noexcept = 0;
	virtual void RemoveLine(Sci::Line line) = 0;
	virtual Sci::Line Lines() const noexcept = 0;
	virtual void AllocateLines(Sci::Line lines) = 0;
	virtual Sci::Line LineFromPosition(Sci::Position pos) const noexcept = 0;
	virtual Sci::Position LineStart(Sci::Line line) const noexcept = 0;
	virtual void InsertCharacters(Sci::Line line, CountWidths delta) noexcept = 0;
	virtual void SetLineCharactersWidth(Sci::Line line, CountWidths width) noexcept = 0;
	virtual Scintilla::LineCharacterIndexType LineCharacterIndex() const noexcept = 0;
	virtual bool AllocateLineCharacterIndex(Scintilla::LineCharacterIndexType lineCharacterIndex, Sci::Line lines) = 0;
	virtual bool ReleaseLineCharacterIndex(Scintilla::LineCharacterIndexType lineCharacterIndex) = 0;
	virtual Sci::Position IndexLineStart(Sci::Line line, Scintilla::LineCharacterIndexType lineCharacterIndex) const noexcept = 0;
	virtual Sci::Line LineFromPositionIndex(Sci::Position pos, Scintilla::LineCharacterIndexType lineCharacterIndex) const noexcept = 0;
	virtual ~ILineVector() {}
};

}

using namespace Scintilla;
using namespace Scintilla::Internal;

template <typename POS>
class LineStartIndex {
	// line_cast(): cast Sci::Line to either 32-bit or 64-bit value
	// This avoids warnings from Visual C++ Code Analysis and shortens code
	static constexpr POS line_cast(Sci::Line pos) noexcept {
		return static_cast<POS>(pos);
	}
public:
	int refCount;
	Partitioning<POS> starts;

	LineStartIndex() : refCount(0), starts(4) {
		// Minimal initial allocation
	}
	bool Allocate(Sci::Line lines) {
		refCount++;
		Sci::Position length = starts.PositionFromPartition(starts.Partitions());
		for (Sci::Line line = starts.Partitions(); line < lines; line++) {
			// Produce an ascending sequence that will be filled in with correct widths later
			length++;
			starts.InsertPartition(line_cast(line), line_cast(length));
		}
		return refCount == 1;
	}
	bool Release() {
		if (refCount == 1) {
			starts.DeleteAll();
		}
		refCount--;
		return refCount == 0;
	}
	bool Active() const noexcept {
		return refCount > 0;
	}
	Sci::Position LineWidth(Sci::Line line) const noexcept {
		return starts.PositionFromPartition(line_cast(line) + 1) -
			starts.PositionFromPartition(line_cast(line));
	}
	void SetLineWidth(Sci::Line line, Sci::Position width) noexcept {
		const Sci::Position widthCurrent = LineWidth(line);
		starts.InsertText(line_cast(line), line_cast(width - widthCurrent));
	}
	void AllocateLines(Sci::Line lines) {
		if (lines > starts.Partitions()) {
			starts.ReAllocate(lines);
		}
	}
	void InsertLines(Sci::Line line, Sci::Line lines) {
		// Insert multiple lines with each temporarily 1 character wide.
		// The line widths will be fixed up by later measuring code.
		const POS lineAsPos = line_cast(line);
		const POS lineStart = starts.PositionFromPartition(lineAsPos - 1) + 1;
		for (POS l = 0; l < line_cast(lines); l++) {
			starts.InsertPartition(lineAsPos + l, lineStart + l);
		}
	}
};

template <typename POS>
class LineVector : public ILineVector {
	Partitioning<POS> starts;
	PerLine *perLine;
	LineStartIndex<POS> startsUTF16;
	LineStartIndex<POS> startsUTF32;
	LineCharacterIndexType activeIndices;

	void SetActiveIndices() noexcept {
		activeIndices =
			  (startsUTF32.Active() ? LineCharacterIndexType::Utf32 : LineCharacterIndexType::None)
			| (startsUTF16.Active() ? LineCharacterIndexType::Utf16 : LineCharacterIndexType::None);
	}

	// pos_cast(): cast Sci::Line and Sci::Position to either 32-bit or 64-bit value
	// This avoids warnings from Visual C++ Code Analysis and shortens code
	static constexpr POS pos_cast(Sci::Position pos) noexcept {
		return static_cast<POS>(pos);
	}

	// line_from_pos_cast(): return 32-bit or 64-bit value as Sci::Line
	// This avoids warnings from Visual C++ Code Analysis and shortens code
	static constexpr Sci::Line line_from_pos_cast(POS line) noexcept {
		return static_cast<Sci::Line>(line);
	}

public:
	LineVector() : starts(256), perLine(nullptr), activeIndices(LineCharacterIndexType::None) {
	}
	void Init() override {
		starts.DeleteAll();
		if (perLine) {
			perLine->Init();
		}
		startsUTF32.starts.DeleteAll();
		startsUTF16.starts.DeleteAll();
	}
	void SetPerLine(PerLine *pl) noexcept override {
		perLine = pl;
	}
	void InsertText(Sci::Line line, Sci::Position delta) noexcept override {
		starts.InsertText(pos_cast(line), pos_cast(delta));
	}
	void InsertLine(Sci::Line line, Sci::Position position, bool lineStart) override {
		const POS lineAsPos = pos_cast(line);
		starts.InsertPartition(lineAsPos, pos_cast(position));
		if (activeIndices != LineCharacterIndexType::None) {
			if (FlagSet(activeIndices, LineCharacterIndexType::Utf32)) {
				startsUTF32.InsertLines(line, 1);
			}
			if (FlagSet(activeIndices, LineCharacterIndexType::Utf16)) {
				startsUTF16.InsertLines(line, 1);
			}
		}
		if (perLine) {
			if ((line > 0) && lineStart)
				line--;
			perLine->InsertLine(line);
		}
	}
	void InsertLines(Sci::Line line, const Sci::Position *positions, size_t lines, bool lineStart) override {
		const POS lineAsPos = pos_cast(line);
		if constexpr (sizeof(Sci::Position) == sizeof(POS)) {
			starts.InsertPartitions(lineAsPos, positions, lines);
		} else {
			starts.InsertPartitionsWithCast(lineAsPos, positions, lines);
		}
		if (activeIndices != LineCharacterIndexType::None) {
			if (FlagSet(activeIndices, LineCharacterIndexType::Utf32)) {
				startsUTF32.InsertLines(line, lines);
			}
			if (FlagSet(activeIndices, LineCharacterIndexType::Utf16)) {
				startsUTF16.InsertLines(line, lines);
			}
		}
		if (perLine) {
			if ((line > 0) && lineStart)
				line--;
			perLine->InsertLines(line, lines);
		}
	}
	void SetLineStart(Sci::Line line, Sci::Position position) noexcept override {
		starts.SetPartitionStartPosition(pos_cast(line), pos_cast(position));
	}
	void RemoveLine(Sci::Line line) override {
		starts.RemovePartition(pos_cast(line));
		if (FlagSet(activeIndices, LineCharacterIndexType::Utf32)) {
			startsUTF32.starts.RemovePartition(pos_cast(line));
		}
		if (FlagSet(activeIndices, LineCharacterIndexType::Utf16)) {
			startsUTF16.starts.RemovePartition(pos_cast(line));
		}
		if (perLine) {
			perLine->RemoveLine(line);
		}
	}
	Sci::Line Lines() const noexcept override {
		return line_from_pos_cast(starts.Partitions());
	}
	void AllocateLines(Sci::Line lines) override {
		if (lines > Lines()) {
			starts.ReAllocate(lines);
			if (FlagSet(activeIndices, LineCharacterIndexType::Utf32)) {
				startsUTF32.AllocateLines(lines);
			}
			if (FlagSet(activeIndices, LineCharacterIndexType::Utf16)) {
				startsUTF16.AllocateLines(lines);
			}
		}
	}
	Sci::Line LineFromPosition(Sci::Position pos) const noexcept override {
		return line_from_pos_cast(starts.PartitionFromPosition(pos_cast(pos)));
	}
	Sci::Position LineStart(Sci::Line line) const noexcept override {
		return starts.PositionFromPartition(pos_cast(line));
	}
	void InsertCharacters(Sci::Line line, CountWidths delta) noexcept override {
		if (FlagSet(activeIndices, LineCharacterIndexType::Utf32)) {
			startsUTF32.starts.InsertText(pos_cast(line), pos_cast(delta.WidthUTF32()));
		}
		if (FlagSet(activeIndices, LineCharacterIndexType::Utf16)) {
			startsUTF16.starts.InsertText(pos_cast(line), pos_cast(delta.WidthUTF16()));
		}
	}
	void SetLineCharactersWidth(Sci::Line line, CountWidths width) noexcept override {
		if (FlagSet(activeIndices, LineCharacterIndexType::Utf32)) {
			assert(startsUTF32.starts.Partitions() == starts.Partitions());
			startsUTF32.SetLineWidth(line, width.WidthUTF32());
		}
		if (FlagSet(activeIndices, LineCharacterIndexType::Utf16)) {
			assert(startsUTF16.starts.Partitions() == starts.Partitions());
			startsUTF16.SetLineWidth(line, width.WidthUTF16());
		}
	}

	LineCharacterIndexType LineCharacterIndex() const noexcept override {
		return activeIndices;
	}
	bool AllocateLineCharacterIndex(LineCharacterIndexType lineCharacterIndex, Sci::Line lines) override {
		const LineCharacterIndexType activeIndicesStart = activeIndices;
		if (FlagSet(lineCharacterIndex, LineCharacterIndexType::Utf32)) {
			startsUTF32.Allocate(lines);
			assert(startsUTF32.starts.Partitions() == starts.Partitions());
		}
		if (FlagSet(lineCharacterIndex, LineCharacterIndexType::Utf16)) {
			startsUTF16.Allocate(lines);
			assert(startsUTF16.starts.Partitions() == starts.Partitions());
		}
		SetActiveIndices();
		return activeIndicesStart != activeIndices;
	}
	bool ReleaseLineCharacterIndex(LineCharacterIndexType lineCharacterIndex) override {
		const LineCharacterIndexType activeIndicesStart = activeIndices;
		if (FlagSet(lineCharacterIndex, LineCharacterIndexType::Utf32)) {
			startsUTF32.Release();
		}
		if (FlagSet(lineCharacterIndex, LineCharacterIndexType::Utf16)) {
			startsUTF16.Release();
		}
		SetActiveIndices();
		return activeIndicesStart != activeIndices;
	}
	Sci::Position IndexLineStart(Sci::Line line, LineCharacterIndexType lineCharacterIndex) const noexcept override {
		if (lineCharacterIndex == LineCharacterIndexType::Utf32) {
			return startsUTF32.starts.PositionFromPartition(pos_cast(line));
		} else {
			return startsUTF16.starts.PositionFromPartition(pos_cast(line));
		}
	}
	Sci::Line LineFromPositionIndex(Sci::Position pos, LineCharacterIndexType lineCharacterIndex) const noexcept override {
		if (lineCharacterIndex == LineCharacterIndexType::Utf32) {
			return line_from_pos_cast(startsUTF32.starts.PartitionFromPosition(pos_cast(pos)));
		} else {
			return line_from_pos_cast(startsUTF16.starts.PartitionFromPosition(pos_cast(pos)));
		}
	}
};

CellBuffer::CellBuffer(bool hasStyles_, bool largeDocument_) :
	hasStyles(hasStyles_), largeDocument(largeDocument_) {
	readOnly = false;
	utf8Substance = false;
	utf8LineEnds = LineEndType::Default;
	collectingUndo = true;
	uh = std::make_unique<UndoHistory>();
	if (largeDocument)
		plv = std::make_unique<LineVector<Sci::Position>>();
	else
		plv = std::make_unique<LineVector<int>>();
}

CellBuffer::~CellBuffer() noexcept = default;

char CellBuffer::CharAt(Sci::Position position) const noexcept {
	return substance.ValueAt(position);
}

unsigned char CellBuffer::UCharAt(Sci::Position position) const noexcept {
	return substance.ValueAt(position);
}

void CellBuffer::GetCharRange(char *buffer, Sci::Position position, Sci::Position lengthRetrieve) const {
	if (lengthRetrieve <= 0)
		return;
	if (position < 0)
		return;
	if ((position + lengthRetrieve) > substance.Length()) {
		Platform::DebugPrintf("Bad GetCharRange %.0f for %.0f of %.0f\n",
				      static_cast<double>(position),
				      static_cast<double>(lengthRetrieve),
				      static_cast<double>(substance.Length()));
		return;
	}
	substance.GetRange(buffer, position, lengthRetrieve);
}

char CellBuffer::StyleAt(Sci::Position position) const noexcept {
	return hasStyles ? style.ValueAt(position) : '\0';
}

void CellBuffer::GetStyleRange(unsigned char *buffer, Sci::Position position, Sci::Position lengthRetrieve) const {
	if (lengthRetrieve < 0)
		return;
	if (position < 0)
		return;
	if (!hasStyles) {
		std::fill(buffer, buffer + lengthRetrieve, static_cast<unsigned char>(0));
		return;
	}
	if ((position + lengthRetrieve) > style.Length()) {
		Platform::DebugPrintf("Bad GetStyleRange %.0f for %.0f of %.0f\n",
				      static_cast<double>(position),
				      static_cast<double>(lengthRetrieve),
				      static_cast<double>(style.Length()));
		return;
	}
	style.GetRange(reinterpret_cast<char *>(buffer), position, lengthRetrieve);
}

const char *CellBuffer::BufferPointer() {
	return substance.BufferPointer();
}

const char *CellBuffer::RangePointer(Sci::Position position, Sci::Position rangeLength) noexcept {
	return substance.RangePointer(position, rangeLength);
}

Sci::Position CellBuffer::GapPosition() const noexcept {
	return substance.GapPosition();
}

SplitView CellBuffer::AllView() const noexcept {
	const size_t length = substance.Length();
	size_t length1 = substance.GapPosition();
	if (length1 == 0) {
		// Assign segment2 to segment1 / length1 to avoid useless test against 0 length1
		length1 = length;
	}
	return SplitView {
		substance.ElementPointer(0),
		length1,
		substance.ElementPointer(length1) - length1,
		length
	};
}

// The char* returned is to an allocation owned by the undo history
const char *CellBuffer::InsertString(Sci::Position position, const char *s, Sci::Position insertLength, bool &startSequence) {
	// InsertString and DeleteChars are the bottleneck though which all changes occur
	const char *data = s;
	if (!readOnly) {
		if (collectingUndo) {
			// Save into the undo/redo stack, but only the characters - not the formatting
			// This takes up about half load time
			data = uh->AppendAction(ActionType::insert, position, s, insertLength, startSequence);
		}

		BasicInsertString(position, s, insertLength);
		if (changeHistory) {
			changeHistory->Insert(position, insertLength, collectingUndo, uh->BeforeReachableSavePoint());
		}
	}
	return data;
}

bool CellBuffer::SetStyleAt(Sci::Position position, char styleValue) noexcept {
	if (!hasStyles) {
		return false;
	}
	const char curVal = style.ValueAt(position);
	if (curVal != styleValue) {
		style.SetValueAt(position, styleValue);
		return true;
	} else {
		return false;
	}
}

bool CellBuffer::SetStyleFor(Sci::Position position, Sci::Position lengthStyle, char styleValue) noexcept {
	if (!hasStyles) {
		return false;
	}
	bool changed = false;
	PLATFORM_ASSERT(lengthStyle == 0 ||
		(lengthStyle > 0 && lengthStyle + position <= style.Length()));
	while (lengthStyle--) {
		const char curVal = style.ValueAt(position);
		if (curVal != styleValue) {
			style.SetValueAt(position, styleValue);
			changed = true;
		}
		position++;
	}
	return changed;
}

// The char* returned is to an allocation owned by the undo history
const char *CellBuffer::DeleteChars(Sci::Position position, Sci::Position deleteLength, bool &startSequence) {
	// InsertString and DeleteChars are the bottleneck though which all changes occur
	PLATFORM_ASSERT(deleteLength > 0);
	const char *data = nullptr;
	if (!readOnly) {
		if (collectingUndo) {
			// Save into the undo/redo stack, but only the characters - not the formatting
			// The gap would be moved to position anyway for the deletion so this doesn't cost extra
			data = substance.RangePointer(position, deleteLength);
			data = uh->AppendAction(ActionType::remove, position, data, deleteLength, startSequence);
		}

		if (changeHistory) {
			changeHistory->DeleteRangeSavingHistory(position, deleteLength,
				uh->BeforeReachableSavePoint(), uh->AfterOrAtDetachPoint());
		}

		BasicDeleteChars(position, deleteLength);
	}
	return data;
}

Sci::Position CellBuffer::Length() const noexcept {
	return substance.Length();
}

void CellBuffer::Allocate(Sci::Position newSize) {
	if (!largeDocument && (newSize > INT32_MAX)) {
		throw std::runtime_error("CellBuffer::Allocate: size of standard document limited to 2G.");
	}
	substance.ReAllocate(newSize);
	if (hasStyles) {
		style.ReAllocate(newSize);
	}
}

void CellBuffer::SetUTF8Substance(bool utf8Substance_) noexcept {
	utf8Substance = utf8Substance_;
}

void CellBuffer::SetLineEndTypes(LineEndType utf8LineEnds_) {
	if (utf8LineEnds != utf8LineEnds_) {
		const LineCharacterIndexType indexes = plv->LineCharacterIndex();
		utf8LineEnds = utf8LineEnds_;
		ResetLineEnds();
		AllocateLineCharacterIndex(indexes);
	}
}

bool CellBuffer::ContainsLineEnd(const char *s, Sci::Position length) const noexcept {
	unsigned char chBeforePrev = 0;
	unsigned char chPrev = 0;
	for (Sci::Position i = 0; i < length; i++) {
		const unsigned char ch = s[i];
		if ((ch == '\r') || (ch == '\n')) {
			return true;
		} else if (utf8LineEnds == LineEndType::Unicode) {
			if (UTF8IsMultibyteLineEnd(chBeforePrev, chPrev, ch)) {
				return true;
			}
		}
		chBeforePrev = chPrev;
		chPrev = ch;
	}
	return false;
}

void CellBuffer::SetPerLine(PerLine *pl) noexcept {
	plv->SetPerLine(pl);
}

LineCharacterIndexType CellBuffer::LineCharacterIndex() const noexcept {
	return plv->LineCharacterIndex();
}

void CellBuffer::AllocateLineCharacterIndex(LineCharacterIndexType lineCharacterIndex) {
	if (utf8Substance) {
		if (plv->AllocateLineCharacterIndex(lineCharacterIndex, Lines())) {
			// Changed so recalculate whole file
			RecalculateIndexLineStarts(0, Lines() - 1);
		}
	}
}

void CellBuffer::ReleaseLineCharacterIndex(LineCharacterIndexType lineCharacterIndex) {
	plv->ReleaseLineCharacterIndex(lineCharacterIndex);
}

Sci::Line CellBuffer::Lines() const noexcept {
	return plv->Lines();
}

void CellBuffer::AllocateLines(Sci::Line lines) {
	plv->AllocateLines(lines);
}

Sci::Position CellBuffer::LineStart(Sci::Line line) const noexcept {
	if (line < 0)
		return 0;
	else if (line >= Lines())
		return Length();
	else
		return plv->LineStart(line);
}

Sci::Position CellBuffer::LineEnd(Sci::Line line) const noexcept {
	if (line >= Lines() - 1) {
		return LineStart(line + 1);
	} else {
		Sci::Position position = LineStart(line + 1);
		if (LineEndType::Unicode == GetLineEndTypes()) {
			const unsigned char bytes[] = {
				UCharAt(position - 3),
				UCharAt(position - 2),
				UCharAt(position - 1),
			};
			if (UTF8IsSeparator(bytes)) {
				return position - UTF8SeparatorLength;
			}
			if (UTF8IsNEL(bytes + 1)) {
				return position - UTF8NELLength;
			}
		}
		position--; // Back over CR or LF
		// When line terminator is CR+LF, may need to go back one more
		if ((position > LineStart(line)) && (CharAt(position - 1) == '\r')) {
			position--;
		}
		return position;
	}
}

Sci::Line CellBuffer::LineFromPosition(Sci::Position pos) const noexcept {
	return plv->LineFromPosition(pos);
}

Sci::Position CellBuffer::IndexLineStart(Sci::Line line, LineCharacterIndexType lineCharacterIndex) const noexcept {
	return plv->IndexLineStart(line, lineCharacterIndex);
}

Sci::Line CellBuffer::LineFromPositionIndex(Sci::Position pos, LineCharacterIndexType lineCharacterIndex) const noexcept {
	return plv->LineFromPositionIndex(pos, lineCharacterIndex);
}

bool CellBuffer::IsReadOnly() const noexcept {
	return readOnly;
}

void CellBuffer::SetReadOnly(bool set) noexcept {
	readOnly = set;
}

bool CellBuffer::IsLarge() const noexcept {
	return largeDocument;
}

bool CellBuffer::HasStyles() const noexcept {
	return hasStyles;
}

void CellBuffer::SetSavePoint() {
	uh->SetSavePoint();
	if (changeHistory) {
		changeHistory->SetSavePoint();
	}
}

bool CellBuffer::IsSavePoint() const noexcept {
	return uh->IsSavePoint();
}

void CellBuffer::TentativeStart() noexcept {
	uh->TentativeStart();
}

void CellBuffer::TentativeCommit() noexcept {
	uh->TentativeCommit();
}

int CellBuffer::TentativeSteps() noexcept {
	return uh->TentativeSteps();
}

bool CellBuffer::TentativeActive() const noexcept {
	return uh->TentativeActive();
}

// Without undo

void CellBuffer::InsertLine(Sci::Line line, Sci::Position position, bool lineStart) {
	plv->InsertLine(line, position, lineStart);
}

void CellBuffer::RemoveLine(Sci::Line line) {
	plv->RemoveLine(line);
}

bool CellBuffer::UTF8LineEndOverlaps(Sci::Position position) const noexcept {
	const unsigned char bytes[] = {
		static_cast<unsigned char>(substance.ValueAt(position-2)),
		static_cast<unsigned char>(substance.ValueAt(position-1)),
		static_cast<unsigned char>(substance.ValueAt(position)),
		static_cast<unsigned char>(substance.ValueAt(position+1)),
	};
	return UTF8IsSeparator(bytes) || UTF8IsSeparator(bytes+1) || UTF8IsNEL(bytes+1);
}

bool CellBuffer::UTF8IsCharacterBoundary(Sci::Position position) const {
	assert(position >= 0 && position <= Length());
	if (position > 0) {
		std::string back;
		for (int i = 0; i < UTF8MaxBytes; i++) {
			const Sci::Position posBack = position - i;
			if (posBack < 0) {
				return false;
			}
			back.insert(0, 1, substance.ValueAt(posBack));
			if (!UTF8IsTrailByte(back.front())) {
				if (i > 0) {
					// Have reached a non-trail
					const int cla = UTF8Classify(back);
					if ((cla & UTF8MaskInvalid) || (cla != i)) {
						return false;
					}
				}
				break;
			}
		}
	}
	if (position < Length()) {
		const unsigned char fore = substance.ValueAt(position);
		if (UTF8IsTrailByte(fore)) {
			return false;
		}
	}
	return true;
}

void CellBuffer::ResetLineEnds() {
	// Reinitialize line data -- too much work to preserve
	const Sci::Line lines = plv->Lines();
	plv->Init();
	plv->AllocateLines(lines);

	constexpr Sci::Position position = 0;
	const Sci::Position length = Length();
	plv->InsertText(0, length);
	Sci::Line lineInsert = 1;
	constexpr bool atLineStart = true;
	unsigned char chBeforePrev = 0;
	unsigned char chPrev = 0;
	for (Sci::Position i = 0; i < length; i++) {
		const unsigned char ch = substance.ValueAt(position + i);
		if (ch == '\r') {
			InsertLine(lineInsert, (position + i) + 1, atLineStart);
			lineInsert++;
		} else if (ch == '\n') {
			if (chPrev == '\r') {
				// Patch up what was end of line
				plv->SetLineStart(lineInsert - 1, (position + i) + 1);
			} else {
				InsertLine(lineInsert, (position + i) + 1, atLineStart);
				lineInsert++;
			}
		} else if (utf8LineEnds == LineEndType::Unicode) {
			if (UTF8IsMultibyteLineEnd(chBeforePrev, chPrev, ch)) {
				InsertLine(lineInsert, (position + i) + 1, atLineStart);
				lineInsert++;
			}
		}
		chBeforePrev = chPrev;
		chPrev = ch;
	}
}

namespace {

CountWidths CountCharacterWidthsUTF8(std::string_view sv) noexcept {
	CountWidths cw;
	size_t remaining = sv.length();
	while (remaining > 0) {
		const int utf8Status = UTF8Classify(sv);
		const int lenChar = utf8Status & UTF8MaskWidth;
		cw.CountChar(lenChar);
		sv.remove_prefix(lenChar);
		remaining -= lenChar;
	}
	return cw;
}

}

bool CellBuffer::MaintainingLineCharacterIndex() const noexcept {
	return plv->LineCharacterIndex() != LineCharacterIndexType::None;
}

void CellBuffer::RecalculateIndexLineStarts(Sci::Line lineFirst, Sci::Line lineLast) {
	std::string text;
	Sci::Position posLineEnd = LineStart(lineFirst);
	for (Sci::Line line = lineFirst; line <= lineLast; line++) {
		// Find line start and end, retrieve text of line, count characters and update line width
		const Sci::Position posLineStart = posLineEnd;
		posLineEnd = LineStart(line+1);
		const Sci::Position width = posLineEnd - posLineStart;
		text.resize(width);
		GetCharRange(text.data(), posLineStart, width);
		const CountWidths cw = CountCharacterWidthsUTF8(text);
		plv->SetLineCharactersWidth(line, cw);
	}
}

void CellBuffer::BasicInsertString(Sci::Position position, const char *s, Sci::Position insertLength) {
	if (insertLength == 0)
		return;
	PLATFORM_ASSERT(insertLength > 0);

	const unsigned char chAfter = substance.ValueAt(position);
	bool breakingUTF8LineEnd = false;
	if (utf8LineEnds == LineEndType::Unicode && UTF8IsTrailByte(chAfter)) {
		breakingUTF8LineEnd = UTF8LineEndOverlaps(position);
	}

	const Sci::Line linePosition = plv->LineFromPosition(position);
	Sci::Line lineInsert = linePosition + 1;

	// A simple insertion is one that inserts valid text on a single line at a character boundary
	bool simpleInsertion = false;

	const bool maintainingIndex = MaintainingLineCharacterIndex();

	// Check for breaking apart a UTF-8 sequence and inserting invalid UTF-8
	if (utf8Substance && maintainingIndex) {
		// Actually, don't need to check that whole insertion is valid just that there
		// are no potential fragments at ends.
		simpleInsertion = UTF8IsCharacterBoundary(position) &&
			UTF8IsValid(std::string_view(s, insertLength));
	}

	substance.InsertFromArray(position, s, 0, insertLength);
	if (hasStyles) {
		style.InsertValue(position, insertLength, 0);
	}

	const bool atLineStart = plv->LineStart(lineInsert-1) == position;
	// Point all the lines after the insertion point further along in the buffer
	plv->InsertText(lineInsert-1, insertLength);
	unsigned char chBeforePrev = substance.ValueAt(position - 2);
	unsigned char chPrev = substance.ValueAt(position - 1);
	if (chPrev == '\r' && chAfter == '\n') {
		// Splitting up a crlf pair at position
		InsertLine(lineInsert, position, false);
		lineInsert++;
	}
	if (breakingUTF8LineEnd) {
		RemoveLine(lineInsert);
	}

	constexpr size_t PositionBlockSize = 128;
	Sci::Position positions[PositionBlockSize]{};
	size_t nPositions = 0;
	const Sci::Line lineStart = lineInsert;

	// s may not NULL-terminated, ensure *ptr == '\n' or *next == '\n' is valid.
	const char *const end = s + insertLength - 1;
	const char *ptr = s;
	unsigned char ch = 0;

	if (chPrev == '\r' && *ptr == '\n') {
		++ptr;
		// Patch up what was end of line
		plv->SetLineStart(lineInsert - 1, (position + ptr - s));
		simpleInsertion = false;
	}

	if (ptr < end) {
		uint8_t eolTable[256]{};
		eolTable[static_cast<uint8_t>('\n')] = 1;
		eolTable[static_cast<uint8_t>('\r')] = 2;
		if (utf8LineEnds == LineEndType::Unicode) {
			// see UniConversion.h for LS, PS and NEL
			eolTable[0x85] = 4;
			eolTable[0xa8] = 3;
			eolTable[0xa9] = 3;
		}

		do {
			// skip to line end
			ch = *ptr++;
			uint8_t type;
			while ((type = eolTable[ch]) == 0 && ptr < end) {
				chBeforePrev = chPrev;
				chPrev = ch;
				ch = *ptr++;
			}
			switch (type) {
			case 2: // '\r'
				if (*ptr == '\n') {
					++ptr;
				}
				[[fallthrough]];
			case 1: // '\n'
				positions[nPositions++] = position + ptr - s;
				if (nPositions == PositionBlockSize) {
					plv->InsertLines(lineInsert, positions, nPositions, atLineStart);
					lineInsert += nPositions;
					nPositions = 0;
				}
				break;
			case 3:
			case 4:
				// LS, PS and NEL
				if ((type == 3 && chPrev == 0x80 && chBeforePrev == 0xe2) || (type == 4 && chPrev == 0xc2)) {
					positions[nPositions++] = position + ptr - s;
					if (nPositions == PositionBlockSize) {
						plv->InsertLines(lineInsert, positions, nPositions, atLineStart);
						lineInsert += nPositions;
						nPositions = 0;
					}
				}
				break;
			}

			chBeforePrev = chPrev;
			chPrev = ch;
		} while (ptr < end);
	}

	if (nPositions != 0) {
		plv->InsertLines(lineInsert, positions, nPositions, atLineStart);
		lineInsert += nPositions;
	}

	ch = *end;
	if (ptr == end) {
		++ptr;
		if (ch == '\r' || ch == '\n') {
			InsertLine(lineInsert, (position + ptr - s), atLineStart);
			lineInsert++;
		} else if (utf8LineEnds == LineEndType::Unicode && !UTF8IsAscii(ch)) {
			if (UTF8IsMultibyteLineEnd(chBeforePrev, chPrev, ch)) {
				InsertLine(lineInsert, (position + ptr - s), atLineStart);
				lineInsert++;
			}
		}
	}

	// Joining two lines where last insertion is cr and following substance starts with lf
	if (chAfter == '\n') {
		if (ch == '\r') {
			// End of line already in buffer so drop the newly created one
			RemoveLine(lineInsert - 1);
			simpleInsertion = false;
		}
	} else if (utf8LineEnds == LineEndType::Unicode && !UTF8IsAscii(chAfter)) {
		chBeforePrev = chPrev;
		chPrev = ch;
		// May have end of UTF-8 line end in buffer and start in insertion
		for (int j = 0; j < UTF8SeparatorLength-1; j++) {
			const unsigned char chAt = substance.ValueAt(position + insertLength + j);
			const unsigned char back3[3] = {chBeforePrev, chPrev, chAt};
			if (UTF8IsSeparator(back3)) {
				InsertLine(lineInsert, (position + insertLength + j) + 1, atLineStart);
				lineInsert++;
			}
			if ((j == 0) && UTF8IsNEL(back3+1)) {
				InsertLine(lineInsert, (position + insertLength + j) + 1, atLineStart);
				lineInsert++;
			}
			chBeforePrev = chPrev;
			chPrev = chAt;
		}
	}
	if (maintainingIndex) {
		if (simpleInsertion && (lineInsert == lineStart)) {
			const CountWidths cw = CountCharacterWidthsUTF8(std::string_view(s, insertLength));
			plv->InsertCharacters(linePosition, cw);
		} else {
			RecalculateIndexLineStarts(linePosition, lineInsert - 1);
		}
	}
}

void CellBuffer::BasicDeleteChars(Sci::Position position, Sci::Position deleteLength) {
	if (deleteLength == 0)
		return;

	Sci::Line lineRecalculateStart = Sci::invalidPosition;

	if ((position == 0) && (deleteLength == substance.Length())) {
		// If whole buffer is being deleted, faster to reinitialise lines data
		// than to delete each line.
		plv->Init();
	} else {
		// Have to fix up line positions before doing deletion as looking at text in buffer
		// to work out which lines have been removed

		const Sci::Line linePosition = plv->LineFromPosition(position);
		Sci::Line lineRemove = linePosition + 1;

		plv->InsertText(lineRemove-1, - (deleteLength));
		const unsigned char chPrev = substance.ValueAt(position - 1);
		const unsigned char chBefore = chPrev;
		unsigned char chNext = substance.ValueAt(position);

		// Check for breaking apart a UTF-8 sequence
		// Needs further checks that text is UTF-8 or that some other break apart is occurring
		if (utf8Substance && MaintainingLineCharacterIndex()) {
			const Sci::Position posEnd = position + deleteLength;
			const Sci::Line lineEndRemove = plv->LineFromPosition(posEnd);
			const bool simpleDeletion =
				(linePosition == lineEndRemove) &&
				UTF8IsCharacterBoundary(position) && UTF8IsCharacterBoundary(posEnd);
			if (simpleDeletion) {
				std::string text(deleteLength, '\0');
				GetCharRange(text.data(), position, deleteLength);
				if (UTF8IsValid(text)) {
					// Everything is good
					const CountWidths cw = CountCharacterWidthsUTF8(text);
					plv->InsertCharacters(linePosition, -cw);
				} else {
					lineRecalculateStart = linePosition;
				}
			} else {
				lineRecalculateStart = linePosition;
			}
		}

		bool ignoreNL = false;
		if (chPrev == '\r' && chNext == '\n') {
			// Move back one
			plv->SetLineStart(lineRemove, position);
			lineRemove++;
			ignoreNL = true; 	// First \n is not real deletion
		}
		if (utf8LineEnds == LineEndType::Unicode && UTF8IsTrailByte(chNext)) {
			if (UTF8LineEndOverlaps(position)) {
				RemoveLine(lineRemove);
			}
		}

		unsigned char ch = chNext;
		for (Sci::Position i = 0; i < deleteLength; i++) {
			chNext = substance.ValueAt(position + i + 1);
			if (ch == '\r') {
				if (chNext != '\n') {
					RemoveLine(lineRemove);
				}
			} else if (ch == '\n') {
				if (ignoreNL) {
					ignoreNL = false; 	// Further \n are real deletions
				} else {
					RemoveLine(lineRemove);
				}
			} else if (utf8LineEnds == LineEndType::Unicode) {
				if (!UTF8IsAscii(ch)) {
					const unsigned char next3[3] = {ch, chNext,
						static_cast<unsigned char>(substance.ValueAt(position + i + 2))};
					if (UTF8IsSeparator(next3) || UTF8IsNEL(next3)) {
						RemoveLine(lineRemove);
					}
				}
			}

			ch = chNext;
		}
		// May have to fix up end if last deletion causes cr to be next to lf
		// or removes one of a crlf pair
		const char chAfter = substance.ValueAt(position + deleteLength);
		if (chBefore == '\r' && chAfter == '\n') {
			// Using lineRemove-1 as cr ended line before start of deletion
			RemoveLine(lineRemove - 1);
			plv->SetLineStart(lineRemove - 1, position + 1);
		}
	}
	substance.DeleteRange(position, deleteLength);
	if (lineRecalculateStart >= 0) {
		RecalculateIndexLineStarts(lineRecalculateStart, lineRecalculateStart);
	}
	if (hasStyles) {
		style.DeleteRange(position, deleteLength);
	}
}

bool CellBuffer::SetUndoCollection(bool collectUndo) noexcept {
	collectingUndo = collectUndo;
	uh->DropUndoSequence();
	return collectingUndo;
}

bool CellBuffer::IsCollectingUndo() const noexcept {
	return collectingUndo;
}

void CellBuffer::BeginUndoAction(bool mayCoalesce) noexcept {
	uh->BeginUndoAction(mayCoalesce);
}

void CellBuffer::EndUndoAction() noexcept {
	uh->EndUndoAction();
}

int CellBuffer::UndoSequenceDepth() const noexcept {
	return uh->UndoSequenceDepth();
}

bool CellBuffer::AfterUndoSequenceStart() const noexcept {
	return uh->AfterUndoSequenceStart();
}

void CellBuffer::AddUndoAction(Sci::Position token, bool mayCoalesce) {
	bool startSequence = false;
	uh->AppendAction(ActionType::container, token, nullptr, 0, startSequence, mayCoalesce);
}

void CellBuffer::DeleteUndoHistory() noexcept {
	uh->DeleteUndoHistory();
}

bool CellBuffer::CanUndo() const noexcept {
	return uh->CanUndo();
}

int CellBuffer::StartUndo() noexcept {
	return uh->StartUndo();
}

Action CellBuffer::GetUndoStep() const noexcept {
	return uh->GetUndoStep();
}

void CellBuffer::PerformUndoStep() {
	const Action previousStep = uh->GetUndoStep();
	// PreviousBeforeSavePoint and AfterDetachPoint are called since acting on the previous action,
	// that is currentAction-1
	if (changeHistory && uh->PreviousBeforeSavePoint()) {
		changeHistory->StartReversion();
	}
	if (previousStep.at == ActionType::insert) {
		if (substance.Length() < previousStep.lenData) {
			throw std::runtime_error(
				"CellBuffer::PerformUndoStep: deletion must be less than document length.");
		}
		if (changeHistory) {
			changeHistory->DeleteRange(previousStep.position, previousStep.lenData,
				uh->PreviousBeforeSavePoint() && !uh->AfterDetachPoint());
		}
		BasicDeleteChars(previousStep.position, previousStep.lenData);
	} else if (previousStep.at == ActionType::remove) {
		BasicInsertString(previousStep.position, previousStep.data, previousStep.lenData);
		if (changeHistory) {
			changeHistory->UndoDeleteStep(previousStep.position, previousStep.lenData, uh->AfterDetachPoint());
		}
	}
	uh->CompletedUndoStep();
}

bool CellBuffer::CanRedo() const noexcept {
	return uh->CanRedo();
}

int CellBuffer::StartRedo() noexcept {
	return uh->StartRedo();
}

Action CellBuffer::GetRedoStep() const noexcept {
	return uh->GetRedoStep();
}

void CellBuffer::PerformRedoStep() {
	const Action actionStep = uh->GetRedoStep();
	if (actionStep.at == ActionType::insert) {
		BasicInsertString(actionStep.position, actionStep.data, actionStep.lenData);
		if (changeHistory) {
			changeHistory->Insert(actionStep.position, actionStep.lenData, collectingUndo,
				uh->BeforeSavePoint() && !uh->AfterOrAtDetachPoint());
		}
	} else if (actionStep.at == ActionType::remove) {
		if (changeHistory) {
			changeHistory->DeleteRangeSavingHistory(actionStep.position, actionStep.lenData,
				uh->BeforeReachableSavePoint(), uh->AfterOrAtDetachPoint());
		}
		BasicDeleteChars(actionStep.position, actionStep.lenData);
	}
	if (changeHistory && uh->AfterSavePoint()) {
		changeHistory->EndReversion();
	}
	uh->CompletedRedoStep();
}

int CellBuffer::UndoActions() const noexcept {
	return uh->Actions();
}

void CellBuffer::SetUndoSavePoint(int action) noexcept {
	uh->SetSavePoint(action);
}

int CellBuffer::UndoSavePoint() const noexcept {
	return uh->SavePoint();
}

void CellBuffer::SetUndoDetach(int action) noexcept {
	uh->SetDetachPoint(action);
}

int CellBuffer::UndoDetach() const noexcept {
	return uh->DetachPoint();
}

void CellBuffer::SetUndoTentative(int action) noexcept {
	uh->SetTentative(action);
}

int CellBuffer::UndoTentative() const noexcept {
	return uh->TentativePoint();
}

namespace {

void RestoreChangeHistory(const UndoHistory *uh, ChangeHistory *changeHistory) {
	// Replay all undo actions into changeHistory
	const int savePoint = uh->SavePoint();
	const int detachPoint = uh->DetachPoint();
	const int currentPoint = uh->Current();
	for (int act = 0; act < uh->Actions(); act++) {
		const ActionType type = static_cast<ActionType>(uh->Type(act) & ~coalesceFlag);
		const Sci::Position position = uh->Position(act);
		const Sci::Position length = uh->Length(act);
		const bool beforeSave = act < savePoint || ((detachPoint >= 0) && (detachPoint > act));
		const bool afterDetach = (detachPoint >= 0) && (detachPoint < act);
		switch (type) {
		case ActionType::insert:
			changeHistory->Insert(position, length, true, beforeSave);
			break;
		case ActionType::remove:
			changeHistory->DeleteRangeSavingHistory(position, length, beforeSave, afterDetach);
			break;
		default:
			// Only insertions and deletions go into change history
			break;
		}
		changeHistory->Check();
	}
	// Undo back to currentPoint, updating change history
	for (int act = uh->Actions() - 1; act >= currentPoint; act--) {
		const ActionType type = static_cast<ActionType>(uh->Type(act) & ~coalesceFlag);
		const Sci::Position position = uh->Position(act);
		const Sci::Position length = uh->Length(act);
		const bool beforeSave = act < savePoint;
		const bool afterDetach = (detachPoint >= 0) && (detachPoint < act);
		if (beforeSave) {
			changeHistory->StartReversion();
		}
		switch (type) {
		case ActionType::insert:
			changeHistory->DeleteRange(position, length, beforeSave && !afterDetach);
			break;
		case ActionType::remove:
			changeHistory->UndoDeleteStep(position, length, afterDetach);
			break;
		default:
			// Only insertions and deletions go into change history
			break;
		}
		changeHistory->Check();
	}
}

}

void CellBuffer::SetUndoCurrent(int action) {
	uh->SetCurrent(action, Length());
	if (changeHistory) {
		if ((uh->DetachPoint() >= 0) && (uh->SavePoint() >= 0)) {
			// Can't have a valid save point and a valid detach point at same time
			uh->DeleteUndoHistory();
			changeHistory.reset();
			throw std::runtime_error("UndoHistory::SetCurrent: invalid undo history.");
		}
		const intptr_t sizeChange = uh->Delta(action);
		const intptr_t lengthOriginal = Length() - sizeChange;
		// Recreate empty change history
		changeHistory = std::make_unique<ChangeHistory>(lengthOriginal);
		RestoreChangeHistory(uh.get(), changeHistory.get());
		if (Length() != changeHistory->Length()) {
			uh->DeleteUndoHistory();
			changeHistory.reset();
			throw std::runtime_error("UndoHistory::SetCurrent: invalid undo history.");
		}
	}
}

int CellBuffer::UndoCurrent() const noexcept {
	return uh->Current();
}

int CellBuffer::UndoActionType(int action) const noexcept {
	return uh->Type(action);
}

Sci::Position CellBuffer::UndoActionPosition(int action) const noexcept {
	return uh->Position(action);
}

std::string_view CellBuffer::UndoActionText(int action) const noexcept {
	return uh->Text(action);
}

void CellBuffer::PushUndoActionType(int type, Sci::Position position) {
	uh->PushUndoActionType(type, position);
}

void CellBuffer::ChangeLastUndoActionText(size_t length, const char *text) {
	uh->ChangeLastUndoActionText(length, text);
}

void CellBuffer::ChangeHistorySet(bool set) {
	if (set) {
		if (!changeHistory && !uh->CanUndo()) {
			changeHistory = std::make_unique<ChangeHistory>(Length());
		}
	} else {
		changeHistory.reset();
	}
}

int CellBuffer::EditionAt(Sci::Position pos) const noexcept {
	if (changeHistory) {
		return changeHistory->EditionAt(pos);
	}
	return 0;
}

Sci::Position CellBuffer::EditionEndRun(Sci::Position pos) const noexcept {
	if (changeHistory) {
		return changeHistory->EditionEndRun(pos);
	}
	return Length();
}

unsigned int CellBuffer::EditionDeletesAt(Sci::Position pos) const noexcept {
	if (changeHistory) {
		return changeHistory->EditionDeletesAt(pos);
	}
	return 0;
}

Sci::Position CellBuffer::EditionNextDelete(Sci::Position pos) const noexcept {
	if (changeHistory) {
		return changeHistory->EditionNextDelete(pos);
	}
	return Length() + 1;
}


================================================
FILE: Libraries/scintilla/src/CellBuffer.h
================================================
// Scintilla source code edit control
/** @file CellBuffer.h
 ** Manages the text of the document.
 **/
// Copyright 1998-2004 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#ifndef CELLBUFFER_H
#define CELLBUFFER_H

namespace Scintilla::Internal {

// Interface to per-line data that wants to see each line insertion and deletion
class PerLine {
public:
	virtual ~PerLine() {}
	virtual void Init()=0;
	virtual void InsertLine(Sci::Line line)=0;
	virtual void InsertLines(Sci::Line line, Sci::Line lines) = 0;
	virtual void RemoveLine(Sci::Line line)=0;
};

class UndoHistory;
class ChangeHistory;

/**
 * The line vector contains information about each of the lines in a cell buffer.
 */
class ILineVector;

enum class ActionType : unsigned char { insert, remove, container };

/**
 * Actions are used to return the information required to report one undo/redo step.
 */
struct Action {
	ActionType at = ActionType::insert;
	bool mayCoalesce = false;
	Sci::Position position = 0;
	const char *data = nullptr;
	Sci::Position lenData = 0;
};

struct SplitView {
	const char *segment1 = nullptr;
	size_t length1 = 0;
	const char *segment2 = nullptr;
	size_t length = 0;

	bool operator==(const SplitView &other) const noexcept {
		return segment1 == other.segment1 && length1 == other.length1 &&
			segment2 == other.segment2 && length == other.length;
	}
	bool operator!=(const SplitView &other) const noexcept {
		return !(*this == other);
	}

	char CharAt(size_t position) const noexcept {
		if (position < length1) {
			return segment1[position];
		}
		if (position < length) {
			return segment2[position];
		}
		return 0;
	}
};


/**
 * Holder for an expandable array of characters that supports undo and line markers.
 * Based on article "Data Structures in a Bit-Mapped Text Editor"
 * by Wilfred J. Hansen, Byte January 1987, page 183.
 */
class CellBuffer {
private:
	bool hasStyles;
	bool largeDocument;
	SplitVector<char> substance;
	SplitVector<char> style;
	bool readOnly;
	bool utf8Substance;
	Scintilla::LineEndType utf8LineEnds;

	bool collectingUndo;
	std::unique_ptr<UndoHistory> uh;

	std::unique_ptr<ChangeHistory> changeHistory;

	std::unique_ptr<ILineVector> plv;

	bool UTF8LineEndOverlaps(Sci::Position position) const noexcept;
	bool UTF8IsCharacterBoundary(Sci::Position position) const;
	void ResetLineEnds();
	void RecalculateIndexLineStarts(Sci::Line lineFirst, Sci::Line lineLast);
	bool MaintainingLineCharacterIndex() const noexcept;
	/// Actions without undo
	void BasicInsertString(Sci::Position position, const char *s, Sci::Position insertLength);
	void BasicDeleteChars(Sci::Position position, Sci::Position deleteLength);

public:

	CellBuffer(bool hasStyles_, bool largeDocument_);
	// Deleted so CellBuffer objects can not be copied.
	CellBuffer(const CellBuffer &) = delete;
	CellBuffer(CellBuffer &&) = delete;
	CellBuffer &operator=(const CellBuffer &) = delete;
	CellBuffer &operator=(CellBuffer &&) = delete;
	~CellBuffer() noexcept;

	/// Retrieving positions outside the range of the buffer works and returns 0
	char CharAt(Sci::Position position) const noexcept;
	unsigned char UCharAt(Sci::Position position) const noexcept;
	void GetCharRange(char *buffer, Sci::Position position, Sci::Position lengthRetrieve) const;
	char StyleAt(Sci::Position position) const noexcept;
	void GetStyleRange(unsigned char *buffer, Sci::Position position, Sci::Position lengthRetrieve) const;
	const char *BufferPointer();
	const char *RangePointer(Sci::Position position, Sci::Position rangeLength) noexcept;
	Sci::Position GapPosition() const noexcept;
	SplitView AllView() const noexcept;

	Sci::Position Length() const noexcept;
	void Allocate(Sci::Position newSize);
	void SetUTF8Substance(bool utf8Substance_) noexcept;
	Scintilla::LineEndType GetLineEndTypes() const noexcept { return utf8LineEnds; }
	void SetLineEndTypes(Scintilla::LineEndType utf8LineEnds_);
	bool ContainsLineEnd(const char *s, Sci::Position length) const noexcept;
	void SetPerLine(PerLine *pl) noexcept;
	Scintilla::LineCharacterIndexType LineCharacterIndex() const noexcept;
	void AllocateLineCharacterIndex(Scintilla::LineCharacterIndexType lineCharacterIndex);
	void ReleaseLineCharacterIndex(Scintilla::LineCharacterIndexType lineCharacterIndex);
	Sci::Line Lines() const noexcept;
	void AllocateLines(Sci::Line lines);
	Sci::Position LineStart(Sci::Line line) const noexcept;
	Sci::Position LineEnd(Sci::Line line) const noexcept;
	Sci::Position IndexLineStart(Sci::Line line, Scintilla::LineCharacterIndexType lineCharacterIndex) const noexcept;
	Sci::Line LineFromPosition(Sci::Position pos) const noexcept;
	Sci::Line LineFromPositionIndex(Sci::Position pos, Scintilla::LineCharacterIndexType lineCharacterIndex) const noexcept;
	void InsertLine(Sci::Line line, Sci::Position position, bool lineStart);
	void RemoveLine(Sci::Line line);
	const char *InsertString(Sci::Position position, const char *s, Sci::Position insertLength, bool &startSequence);

	/// Setting styles for positions outside the range of the buffer is safe and has no effect.
	/// @return true if the style of a character is changed.
	bool SetStyleAt(Sci::Position position, char styleValue) noexcept;
	bool SetStyleFor(Sci::Position position, Sci::Position lengthStyle, char styleValue) noexcept;

	const char *DeleteChars(Sci::Position position, Sci::Position deleteLength, bool &startSequence);

	bool IsReadOnly() const noexcept;
	void SetReadOnly(bool set) noexcept;
	bool IsLarge() const noexcept;
	bool HasStyles() const noexcept;

	/// The save point is a marker in the undo stack where the container has stated that
	/// the buffer was saved. Undo and redo can move over the save point.
	void SetSavePoint();
	bool IsSavePoint() const noexcept;

	void TentativeStart() noexcept;
	void TentativeCommit() noexcept;
	bool TentativeActive() const noexcept;
	int TentativeSteps() noexcept;

	bool SetUndoCollection(bool collectUndo) noexcept;
	bool IsCollectingUndo() const noexcept;
	void BeginUndoAction(bool mayCoalesce=false) noexcept;
	void EndUndoAction() noexcept;
	int UndoSequenceDepth() const noexcept;
	bool AfterUndoSequenceStart() const noexcept;
	void AddUndoAction(Sci::Position token, bool mayCoalesce);
	void DeleteUndoHistory() noexcept;

	/// To perform an undo, StartUndo is called to retrieve the number of steps, then UndoStep is
	/// called that many times. Similarly for redo.
	bool CanUndo() const noexcept;
	int StartUndo() noexcept;
	Action GetUndoStep() const noexcept;
	void PerformUndoStep();
	bool CanRedo() const noexcept;
	int StartRedo() noexcept;
	Action GetRedoStep() const noexcept;
	void PerformRedoStep();

	int UndoActions() const noexcept;
	void SetUndoSavePoint(int action) noexcept;
	int UndoSavePoint() const noexcept;
	void SetUndoDetach(int action) noexcept;
	int UndoDetach() const noexcept;
	void SetUndoTentative(int action) noexcept;
	int UndoTentative() const noexcept;
	void SetUndoCurrent(int action);
	int UndoCurrent() const noexcept;
	int UndoActionType(int action) const noexcept;
	Sci::Position UndoActionPosition(int action) const noexcept;
	std::string_view UndoActionText(int action) const noexcept;
	void PushUndoActionType(int type, Sci::Position position);
	void ChangeLastUndoActionText(size_t length, const char *text);

	void ChangeHistorySet(bool set);
	[[nodiscard]] int EditionAt(Sci::Position pos) const noexcept;
	[[nodiscard]] Sci::Position EditionEndRun(Sci::Position pos) const noexcept;
	[[nodiscard]] unsigned int EditionDeletesAt(Sci::Position pos) const noexcept;
	[[nodiscard]] Sci::Position EditionNextDelete(Sci::Position pos) const noexcept;
};

}

#endif


================================================
FILE: Libraries/scintilla/src/ChangeHistory.cxx
================================================
// Scintilla source code edit control
/** @file ChangeHistory.cxx
 ** Manages a history of changes in a document.
 **/
// Copyright 2022 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#include <cstddef>
#include <cstdlib>
#include <cstdint>
#include <cassert>

#include <stdexcept>
#include <vector>
#include <set>
#include <algorithm>
#include <memory>

#include "ScintillaTypes.h"

#include "Debugging.h"

#include "Position.h"
#include "SplitVector.h"
#include "Partitioning.h"
#include "RunStyles.h"
#include "SparseVector.h"
#include "ChangeHistory.h"

namespace Scintilla::Internal {

void ChangeStack::Clear() noexcept {
	steps.clear();
	changes.clear();
}

void ChangeStack::AddStep() {
	steps.push_back(0);
}

namespace {

constexpr bool InsertionSpanSameDeletion(const ChangeSpan &is, Sci::Position positionDeletion, int edition) {
	// Equal except for count
	return
		is.direction == ChangeSpan::Direction::deletion &&
		is.start == positionDeletion &&
		is.length == 0 &&
		is.edition == edition;
}

}

void ChangeStack::PushDeletion(Sci::Position positionDeletion, const EditionCount &ec) {
	steps.back() += ec.count;
	if (changes.empty() || !InsertionSpanSameDeletion(changes.back(), positionDeletion, ec.edition)) {
		changes.push_back({ positionDeletion, 0, ec.edition, ec.count, ChangeSpan::Direction::deletion });
	} else {
		changes.back().count += ec.count;
	}
}

void ChangeStack::PushInsertion(Sci::Position positionInsertion, Sci::Position length, int edition) {
	steps.back()++;
	changes.push_back({ positionInsertion, length, edition, 1, ChangeSpan::Direction::insertion });
}

int ChangeStack::PopStep() noexcept {
	const int spans = steps.back();
	steps.pop_back();
	return spans;
}

ChangeSpan ChangeStack::PopSpan(int maxSteps) noexcept {
	ChangeSpan span = changes.back();
	const int remove = std::min(maxSteps, span.count);
	if (span.count == remove) {
		changes.pop_back();
	} else {
		changes.back().count -= remove;
		span.count = remove;
	}
	return span;
}

void ChangeStack::SetSavePoint() noexcept {
	// Switch changeUnsaved to changeSaved
	for (ChangeSpan &x : changes) {
		if (x.edition == changeModified) {
			x.edition = changeSaved;
		}
	}
}

void ChangeStack::Check() const noexcept {
#ifdef _DEBUG
	// Ensure count in steps same as insertions;
	int sizeSteps = 0;
	for (const int c : steps) {
		sizeSteps += c;
	}
	int sizeInsertions = 0;
	for (const ChangeSpan &is: changes) {
		sizeInsertions += is.count;
	}
	assert(sizeSteps == sizeInsertions);
#endif
}

void ChangeLog::Clear(Sci::Position length) {
	changeStack.Clear();
	insertEdition.DeleteAll();
	deleteEdition.DeleteAll();
	InsertSpace(0, length);
}

void ChangeLog::InsertSpace(Sci::Position position, Sci::Position insertLength) {
	assert(insertEdition.Length() == deleteEdition.Length());
	insertEdition.InsertSpace(position, insertLength);
	deleteEdition.InsertSpace(position, insertLength);
}

void ChangeLog::DeleteRange(Sci::Position position, Sci::Position deleteLength) {
	insertEdition.DeleteRange(position, deleteLength);
	const EditionSetOwned &editions = deleteEdition.ValueAt(position);
	if (editions) {
		const EditionSet savedEditions = *editions;
		deleteEdition.DeleteRange(position, deleteLength);
		EditionSetOwned reset = std::make_unique<EditionSet>(savedEditions);
		deleteEdition.SetValueAt(position, std::move(reset));
	} else {
		deleteEdition.DeleteRange(position, deleteLength);
	}
	assert(insertEdition.Length() == deleteEdition.Length());
}

void ChangeLog::Insert(Sci::Position start, Sci::Position length, int edition) {
	insertEdition.FillRange(start, edition, length);
}

void ChangeLog::CollapseRange(Sci::Position position, Sci::Position deleteLength) {
	const Sci::Position positionMax = position + deleteLength;
	Sci::Position positionDeletion = position + 1;
	while (positionDeletion <= positionMax) {
		const EditionSetOwned &editions = deleteEdition.ValueAt(positionDeletion);
		if (editions) {
			for (const EditionCount &ec : *editions) {
				PushDeletionAt(position, ec);
			}
			EditionSetOwned empty;
			deleteEdition.SetValueAt(positionDeletion, std::move(empty));
		}
		positionDeletion = deleteEdition.PositionNext(positionDeletion);
	}
}

namespace {

// EditionSets have repeat counts on items so push and pop may just
// manipulate the count field or may push/pop items.

void EditionSetPush(EditionSet &set, EditionCount ec) {
	if (set.empty() || (set.back().edition != ec.edition)) {
		set.push_back(ec);
	} else {
		set.back().count += ec.count;
	}
}

void EditionSetPop(EditionSet &set) noexcept {
	if (set.back().count == 1) {
		set.pop_back();
	} else {
		set.back().count--;
	}
}

int EditionSetCount(const EditionSet &set) noexcept {
	int count = 0;
	for (const EditionCount &ec : set) {
		count += ec.count;
	}
	return count;
}

}

void ChangeLog::PushDeletionAt(Sci::Position position, EditionCount ec) {
	if (!deleteEdition.ValueAt(position)) {
		deleteEdition.SetValueAt(position, std::make_unique<EditionSet>());
	}
	EditionSetPush(*deleteEdition.ValueAt(position), ec);
}

void ChangeLog::InsertFrontDeletionAt(Sci::Position position, EditionCount ec) {
	if (!deleteEdition.ValueAt(position)) {
		deleteEdition.SetValueAt(position, std::make_unique<EditionSet>());
	}
	const EditionSetOwned &editions = deleteEdition.ValueAt(position);
	editions->insert(editions->begin(), ec);
}

void ChangeLog::SaveRange(Sci::Position position, Sci::Position length) {
	// Save insertEdition range into undo stack
	changeStack.AddStep();
	Sci::Position positionInsertion = position;
	const ptrdiff_t editionStart = insertEdition.ValueAt(positionInsertion);
	if (editionStart == 0) {
		positionInsertion = insertEdition.EndRun(positionInsertion);
	}
	const Sci::Position positionMax = position + length;
	while (positionInsertion < positionMax) {
		const Sci::Position positionEndInsertion = insertEdition.EndRun(positionInsertion);
		changeStack.PushInsertion(positionInsertion, std::min(positionEndInsertion, positionMax) - positionInsertion,
			insertEdition.ValueAt(positionInsertion));
		positionInsertion = insertEdition.EndRun(positionEndInsertion);
	}
	Sci::Position positionDeletion = position + 1;
	while (positionDeletion <= positionMax) {
		const EditionSetOwned &editions = deleteEdition.ValueAt(positionDeletion);
		if (editions) {
			for (const EditionCount &ec : *editions) {
				changeStack.PushDeletion(positionDeletion, ec);
			}
		}
		positionDeletion = deleteEdition.PositionNext(positionDeletion);
	}
}

void ChangeLog::PopDeletion(Sci::Position position, Sci::Position deleteLength) {
	// Just performed InsertSpace(position, deleteLength) so *this* element in
	// deleteEdition moved forward by deleteLength
	EditionSetOwned eso = deleteEdition.Extract(position + deleteLength);
	deleteEdition.SetValueAt(position, std::move(eso));
	const EditionSetOwned &editions = deleteEdition.ValueAt(position);
	assert(editions);
	EditionSetPop(*editions);
	const int inserts = changeStack.PopStep();
	for (int i = 0; i < inserts;) {
		const ChangeSpan span = changeStack.PopSpan(inserts);
		if (span.direction == ChangeSpan::Direction::insertion) {
			assert(span.count == 1);	// Insertions are never compressed
			insertEdition.FillRange(span.start, span.edition, span.length);
			i++;
		} else {
			assert(editions);
			assert(editions->back().edition == span.edition);
			for (int j = 0; j < span.count; j++) {
				EditionSetPop(*editions);
			}
			// Iterating backwards (pop) through changeStack, reverse order of insertion
			// and original deletion list.
			// Therefore need to insert at front to recreate original order.
			InsertFrontDeletionAt(span.start, { span.edition, span.count });
			i += span.count;
		}
	}

	if (editions->empty()) {
		deleteEdition.SetValueAt(position, EditionSetOwned{});
	}
}

void ChangeLog::SaveHistoryForDelete(Sci::Position position, Sci::Position deleteLength) {
	assert(position >= 0);
	assert(deleteLength >= 0);
	assert(position + deleteLength <= Length());
	SaveRange(position, deleteLength);
	CollapseRange(position, deleteLength);
}

void ChangeLog::DeleteRangeSavingHistory(Sci::Position position, Sci::Position deleteLength) {
	SaveHistoryForDelete(position, deleteLength);
	DeleteRange(position, deleteLength);
}

void ChangeLog::SetSavePoint() {
	// Switch changeUnsaved to changeSaved
	changeStack.SetSavePoint();

	const Sci::Position length = insertEdition.Length();

	for (Sci::Position startRun = 0; startRun < length;) {
		const Sci::Position endRun = insertEdition.EndRun(startRun);
		if (insertEdition.ValueAt(startRun) == changeModified) {
			insertEdition.FillRange(startRun, changeSaved, endRun - startRun);
		}
		startRun = endRun;
	}

	for (Sci::Position positionDeletion = 0; positionDeletion <= length;) {
		const EditionSetOwned &editions = deleteEdition.ValueAt(positionDeletion);
		if (editions) {
			for (EditionCount &ec : *editions) {
				if (ec.edition == changeModified) {
					ec.edition = changeSaved;
				}
			}
		}
		positionDeletion = deleteEdition.PositionNext(positionDeletion);
	}
}

Sci::Position ChangeLog::Length() const noexcept {
	return insertEdition.Length();
}

size_t ChangeLog::DeletionCount(Sci::Position start, Sci::Position length) const noexcept {
	const Sci::Position end = start + length;
	size_t count = 0;
	while (start <= end) {
		const EditionSetOwned &editions = deleteEdition.ValueAt(start);
		if (editions) {
			count += EditionSetCount(*editions);
		}
		start = deleteEdition.PositionNext(start);
	}
	return count;
}

void ChangeLog::Check() const noexcept {
	assert(insertEdition.Length() == deleteEdition.Length());
	changeStack.Check();
}

ChangeHistory::ChangeHistory(Sci::Position length) {
	changeLog.Clear(length);
}

void ChangeHistory::Insert(Sci::Position position, Sci::Position insertLength, bool collectingUndo, bool beforeSave) {
	Check();
	changeLog.InsertSpace(position, insertLength);
	const int edition = collectingUndo ? (beforeSave ? changeSaved : changeModified) :
		changeOriginal;
	changeLog.Insert(position, insertLength, edition);
	if (changeLogReversions) {
		changeLogReversions->InsertSpace(position, insertLength);
		if (beforeSave) {
			changeLogReversions->PopDeletion(position, insertLength);
		}
	}
	Check();
}

void ChangeHistory::DeleteRange(Sci::Position position, Sci::Position deleteLength, bool reverting) {
	Check();
	assert(DeletionCount(position, deleteLength-1) == 0);
	changeLog.DeleteRange(position, deleteLength);
	if (changeLogReversions) {
		changeLogReversions->DeleteRangeSavingHistory(position, deleteLength);
		if (reverting) {
			changeLogReversions->PushDeletionAt(position, { changeRevertedOriginal, 1 });
		}
	}
	Check();
}

void ChangeHistory::DeleteRangeSavingHistory(Sci::Position position, Sci::Position deleteLength, bool beforeSave, bool isDetached) {
	changeLog.DeleteRangeSavingHistory(position, deleteLength);
	changeLog.PushDeletionAt(position, { beforeSave ? changeSaved : changeModified, 1 });
	if (changeLogReversions) {
		if (isDetached) {
			changeLogReversions->SaveHistoryForDelete(position, deleteLength);
		}
		changeLogReversions->DeleteRange(position, deleteLength);
	}
	Check();
}

void ChangeHistory::StartReversion() {
	if (!changeLogReversions) {
		changeLogReversions = std::make_unique<ChangeLog>();
		changeLogReversions->Clear(changeLog.Length());
	}
	Check();
}

void ChangeHistory::EndReversion() noexcept {
	changeLogReversions.reset();
	Check();
}

void ChangeHistory::SetSavePoint() {
	changeLog.SetSavePoint();
	EndReversion();
}

void ChangeHistory::UndoDeleteStep(Sci::Position position, Sci::Position deleteLength, bool isDetached) {
	Check();
	changeLog.InsertSpace(position, deleteLength);
	changeLog.PopDeletion(position, deleteLength);
	if (changeLogReversions) {
		changeLogReversions->InsertSpace(position, deleteLength);
		if (!isDetached) {
			changeLogReversions->Insert(position, deleteLength, 1);
		}
	}
	Check();
}

Sci::Position ChangeHistory::Length() const noexcept {
	return changeLog.Length();
}

void ChangeHistory::SetEpoch(int epoch) noexcept {
	historicEpoch = epoch;
}

void ChangeHistory::EditionCreateHistory(Sci::Position start, Sci::Position length) {
	if (start <= changeLog.Length()) {
		if (length) {
			changeLog.insertEdition.FillRange(start, historicEpoch, length);
		} else {
			changeLog.PushDeletionAt(start, { historicEpoch, 1 });
		}
	}
}

// Editions:
// <0 History
// 0 Original unchanged
// 1 Reverted to origin
// 2 Saved
// 3 Unsaved
// 4 Reverted to change
int ChangeHistory::EditionAt(Sci::Position pos) const noexcept {
	const int edition = changeLog.insertEdition.ValueAt(pos);
	if (changeLogReversions) {
		const int editionReversion = changeLogReversions->insertEdition.ValueAt(pos);
		if (editionReversion) {
			if (edition < 0)	// Historical revision
				return changeRevertedOriginal;
			return edition ? changeRevertedToChange : changeRevertedOriginal;
		}
	}
	return edition;
}

Sci::Position ChangeHistory::EditionEndRun(Sci::Position pos) const noexcept {
	if (changeLogReversions) {
		assert(changeLogReversions->Length() == changeLog.Length());
		const Sci::Position nextReversion = changeLogReversions->insertEdition.EndRun(pos);
		const Sci::Position next = changeLog.insertEdition.EndRun(pos);
		return std::min(next, nextReversion);
	}
	return changeLog.insertEdition.EndRun(pos);
}

// Produce a 4-bit value from the deletions at a position
unsigned int ChangeHistory::EditionDeletesAt(Sci::Position pos) const noexcept {
	unsigned int editionSet = 0;
	const EditionSetOwned &editionSetDeletions = changeLog.deleteEdition.ValueAt(pos);
	if (editionSetDeletions) {
		for (const EditionCount &ec : *editionSetDeletions) {
			editionSet = editionSet | (1u << (ec.edition-1));
		}
	}
	if (changeLogReversions) {
		const EditionSetOwned &editionSetReversions = changeLogReversions->deleteEdition.ValueAt(pos);
		if (editionSetReversions) {
			// If there is no saved or modified -> revertedToOrigin
			if (!(editionSet & (bitSaved | bitModified))) {
				editionSet = editionSet | bitRevertedToOriginal;
			} else {
				editionSet = editionSet | bitRevertedToModified;
			}
		}
	}
	return editionSet;
}

Sci::Position ChangeHistory::EditionNextDelete(Sci::Position pos) const noexcept {
	const Sci::Position next = changeLog.deleteEdition.PositionNext(pos);
	if (changeLogReversions) {
		const Sci::Position nextReversion = changeLogReversions->deleteEdition.PositionNext(pos);
		return std::min(next, nextReversion);
	}
	return next;
}

size_t ChangeHistory::DeletionCount(Sci::Position start, Sci::Position length) const noexcept {
	return changeLog.DeletionCount(start, length);
}

EditionSet ChangeHistory::DeletionsAt(Sci::Position pos) const {
	const EditionSetOwned &editions = changeLog.deleteEdition.ValueAt(pos);
	if (editions) {
		return *editions;
	}
	return {};
}

void ChangeHistory::Check() noexcept {
	changeLog.Check();
	if (changeLogReversions) {
		changeLogReversions->Check();
		assert(changeLogReversions->Length() == changeLog.Length());
	}
}

}


================================================
FILE: Libraries/scintilla/src/ChangeHistory.h
================================================
// Scintilla source code edit control
/** @file ChangeHistory.h
 ** Manages a history of changes in a document.
 **/
// Copyright 2022 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#ifndef CHANGEHISTORY_H
#define CHANGEHISTORY_H

namespace Scintilla::Internal {

constexpr int changeOriginal = 0;
constexpr int changeRevertedOriginal = 1;
constexpr int changeSaved = 2;
constexpr int changeModified = 3;
constexpr int changeRevertedToChange = 4;

// As bit flags
constexpr unsigned int bitRevertedToOriginal = 1;
constexpr unsigned int bitSaved = 2;
constexpr unsigned int bitModified = 4;
constexpr unsigned int bitRevertedToModified = 8;

struct ChangeSpan {
	Sci::Position start;
	Sci::Position length;
	int edition;
	int count;
	enum class Direction { insertion, deletion } direction;
};

struct EditionCount {
	int edition;
	int count;
	// Used in tests.
	constexpr bool operator==(const EditionCount &other) const noexcept {
		return (edition == other.edition) && (count == other.count);
	}
};

// EditionSet is ordered from oldest to newest, its not really a set
using EditionSet = std::vector<EditionCount>;
using EditionSetOwned = std::unique_ptr<EditionSet>;

class ChangeStack {
	std::vector<int> steps;
	std::vector<ChangeSpan> changes;
public:
	void Clear() noexcept;
	void AddStep();
	void PushDeletion(Sci::Position positionDeletion, const EditionCount &ec);
	void PushInsertion(Sci::Position positionInsertion, Sci::Position length, int edition);
	[[nodiscard]] int PopStep() noexcept;
	[[nodiscard]] ChangeSpan PopSpan(int maxSteps) noexcept;
	void SetSavePoint() noexcept;
	void Check() const noexcept;
};

struct ChangeLog {
	ChangeStack changeStack;
	RunStyles<Sci::Position, int> insertEdition;
	SparseVector<EditionSetOwned> deleteEdition;

	void Clear(Sci::Position length);
	void InsertSpace(Sci::Position position, Sci::Position insertLength);
	void DeleteRange(Sci::Position position, Sci::Position deleteLength);
	void Insert(Sci::Position start, Sci::Position length, int edition);
	void CollapseRange(Sci::Position position, Sci::Position deleteLength);
	void PushDeletionAt(Sci::Position position, EditionCount ec);
	void InsertFrontDeletionAt(Sci::Position position, EditionCount ec);
	void SaveRange(Sci::Position position, Sci::Position length);
	void PopDeletion(Sci::Position position, Sci::Position deleteLength);
	void SaveHistoryForDelete(Sci::Position position, Sci::Position deleteLength);
	void DeleteRangeSavingHistory(Sci::Position position, Sci::Position deleteLength);
	void SetSavePoint();

	Sci::Position Length() const noexcept;
	[[nodiscard]] size_t DeletionCount(Sci::Position start, Sci::Position length) const noexcept;
	void Check() const noexcept;
};

enum class ReversionState { clear, reverting, detached };

class ChangeHistory {
	ChangeLog changeLog;
	std::unique_ptr<ChangeLog> changeLogReversions;
	int historicEpoch = -1;

public:
	ChangeHistory(Sci::Position length=0);

	void Insert(Sci::Position position, Sci::Position insertLength, bool collectingUndo, bool beforeSave);
	void DeleteRange(Sci::Position position, Sci::Position deleteLength, bool reverting);
	void DeleteRangeSavingHistory(Sci::Position position, Sci::Position deleteLength, bool beforeSave, bool isDetached);

	void StartReversion();
	void EndReversion() noexcept;

	void SetSavePoint();

	void UndoDeleteStep(Sci::Position position, Sci::Position deleteLength, bool isDetached);

	[[nodiscard]] Sci::Position Length() const noexcept;

	// Setting up history before this session
	void SetEpoch(int epoch) noexcept;
	void EditionCreateHistory(Sci::Position start, Sci::Position length);

	// Queries for drawing
	[[nodiscard]] int EditionAt(Sci::Position pos) const noexcept;
	[[nodiscard]] Sci::Position EditionEndRun(Sci::Position pos) const noexcept;
	[[nodiscard]] unsigned int EditionDeletesAt(Sci::Position pos) const noexcept;
	[[nodiscard]] Sci::Position EditionNextDelete(Sci::Position pos) const noexcept;

	// Testing - not used by Scintilla
	[[nodiscard]] size_t DeletionCount(Sci::Position start, Sci::Position length) const noexcept;
	EditionSet DeletionsAt(Sci::Position pos) const;
	void Check() noexcept;
};

}

#endif


================================================
FILE: Libraries/scintilla/src/CharClassify.cxx
================================================
// Scintilla source code edit control
/** @file CharClassify.cxx
 ** Character classifications used by Document and RESearch.
 **/
// Copyright 2006 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#include <cstdlib>
#include <cassert>

#include <stdexcept>

#include "CharacterType.h"
#include "CharClassify.h"

using namespace Scintilla::Internal;

CharClassify::CharClassify() : charClass{} {
	SetDefaultCharClasses(true);
}

void CharClassify::SetDefaultCharClasses(bool includeWordClass) {
	// Initialize all char classes to default values
	for (int ch = 0; ch < maxChar; ch++) {
		if (ch == '\r' || ch == '\n')
			charClass[ch] = CharacterClass::newLine;
		else if (IsControl(ch) || ch == ' ')
			charClass[ch] = CharacterClass::space;
		else if (includeWordClass && (ch >= 0x80 || IsAlphaNumeric(ch) || ch == '_'))
			charClass[ch] = CharacterClass::word;
		else
			charClass[ch] = CharacterClass::punctuation;
	}
}

void CharClassify::SetCharClasses(const unsigned char *chars, CharacterClass newCharClass) {
	// Apply the newCharClass to the specified chars
	if (chars) {
		while (*chars) {
			charClass[*chars] = newCharClass;
			chars++;
		}
	}
}

int CharClassify::GetCharsOfClass(CharacterClass characterClass, unsigned char *buffer) const noexcept {
	// Get characters belonging to the given char class; return the number
	// of characters (if the buffer is NULL, don't write to it).
	int count = 0;
	for (int ch = maxChar - 1; ch >= 0; --ch) {
		if (charClass[ch] == characterClass) {
			++count;
			if (buffer) {
				*buffer = static_cast<unsigned char>(ch);
				buffer++;
			}
		}
	}
	return count;
}


================================================
FILE: Libraries/scintilla/src/CharClassify.h
================================================
// Scintilla source code edit control
/** @file CharClassify.h
 ** Character classifications used by Document and RESearch.
 **/
// Copyright 2006-2009 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#ifndef CHARCLASSIFY_H
#define CHARCLASSIFY_H

namespace Scintilla::Internal {

enum class CharacterClass : unsigned char { space, newLine, word, punctuation };

class CharClassify {
public:
	CharClassify();

	void SetDefaultCharClasses(bool includeWordClass);
	void SetCharClasses(const unsigned char *chars, CharacterClass newCharClass);
	int GetCharsOfClass(CharacterClass characterClass, unsigned char *buffer) const noexcept;
	CharacterClass GetClass(unsigned char ch) const noexcept { return charClass[ch];}
	bool IsWord(unsigned char ch) const noexcept { return charClass[ch] == CharacterClass::word;}

private:
	static constexpr int maxChar=256;
	CharacterClass charClass[maxChar];
};

}

#endif


================================================
FILE: Libraries/scintilla/src/CharacterCategoryMap.cxx
================================================
// Scintilla source code edit control
/** @file CharacterCategoryMap.cxx
 ** Returns the Unicode general category of a character.
 ** Table automatically regenerated by scripts/GenerateCharacterCategory.py
 ** Should only be rarely regenerated for new versions of Unicode.
 ** Similar code to Lexilla's lexilla/lexlib/CharacterCategory.cxx but renamed
 ** to avoid problems with builds that statically include both Scintilla and Lexilla.
 **/
// Copyright 2013 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#include <vector>
#include <algorithm>
#include <iterator>

#include "CharacterCategoryMap.h"

namespace Scintilla::Internal {

namespace {
	// Use an unnamed namespace to protect the declarations from name conflicts

const int catRanges[] = {
//++Autogenerated -- start of section automatically generated
// Created with Python 3.13.0,  Unicode 15.1.0
25,
1046,
1073,
1171,
1201,
1293,
1326,
1361,
1394,
1425,
1452,
1489,
1544,
1873,
1938,
2033,
2080,
2925,
2961,
2990,
3028,
3051,
3092,
3105,
3949,
3986,
4014,
4050,
4089,
5142,
5169,
5203,
5333,
5361,
5396,
5429,
5444,
5487,
5522,
5562,
5589,
5620,
5653,
5682,
5706,
5780,
5793,
5841,
5908,
5930,
5956,
6000,
6026,
6129,
6144,
6898,
6912,
7137,
7922,
7937,
8192,
8225,
8256,
8289,
8320,
8353,
8384,
8417,
8448,
8481,
8512,
8545,
8576,
8609,
8640,
8673,
8704,
8737,
8768,
8801,
8832,
8865,
8896,
8929,
8960,
8993,
9024,
9057,
9088,
9121,
9152,
9185,
9216,
9249,
9280,
9313,
9344,
9377,
9408,
9441,
9472,
9505,
9536,
9569,
9600,
9633,
9664,
9697,
9728,
9761,
9792,
9825,
9856,
9889,
9920,
9953,
10016,
10049,
10080,
10113,
10144,
10177,
10208,
10241,
10272,
10305,
10336,
10369,
10400,
10433,
10464,
10497,
10560,
10593,
10624,
10657,
10688,
10721,
10752,
10785,
10816,
10849,
10880,
10913,
10944,
10977,
11008,
11041,
11072,
11105,
11136,
11169,
11200,
11233,
11264,
11297,
11328,
11361,
11392,
11425,
11456,
11489,
11520,
11553,
11584,
11617,
11648,
11681,
11712,
11745,
11776,
11809,
11840,
11873,
11904,
11937,
11968,
12001,
12032,
12097,
12128,
12161,
12192,
12225,
12320,
12385,
12416,
12449,
12480,
12545,
12576,
12673,
12736,
12865,
12896,
12961,
12992,
13089,
13184,
13249,
13280,
13345,
13376,
13409,
13440,
13473,
13504,
13569,
13600,
13633,
13696,
13729,
13760,
13825,
13856,
13953,
13984,
14017,
14048,
14113,
14180,
14208,
14241,
14340,
14464,
14498,
14529,
14560,
14594,
14625,
14656,
14690,
14721,
14752,
14785,
14816,
14849,
14880,
14913,
14944,
14977,
15008,
15041,
15072,
15105,
15136,
15169,
15200,
15233,
15296,
15329,
15360,
15393,
15424,
15457,
15488,
15521,
15552,
15585,
15616,
15649,
15680,
15713,
15744,
15777,
15808,
15841,
15904,
15938,
15969,
16000,
16033,
16064,
16161,
16192,
16225,
16256,
16289,
16320,
16353,
16384,
16417,
16448,
16481,
16512,
16545,
16576,
16609,
16640,
16673,
16704,
16737,
16768,
16801,
16832,
16865,
16896,
16929,
16960,
16993,
17024,
17057,
17088,
17121,
17152,
17185,
17216,
17249,
17280,
17313,
17344,
17377,
17408,
17441,
17472,
17505,
17536,
17569,
17600,
17633,
17664,
17697,
17728,
17761,
17792,
17825,
17856,
17889,
17920,
17953,
17984,
18017,
18240,
18305,
18336,
18401,
18464,
18497,
18528,
18657,
18688,
18721,
18752,
18785,
18816,
18849,
18880,
18913,
21124,
21153,
22019,
22612,
22723,
23124,
23555,
23732,
23939,
23988,
24003,
24052,
24581,
28160,
28193,
28224,
28257,
28291,
28340,
28352,
28385,
28445,
28483,
28513,
28625,
28640,
28701,
28820,
28864,
28913,
28928,
29053,
29056,
29117,
29120,
29185,
29216,
29789,
29792,
30081,
31200,
31233,
31296,
31393,
31488,
31521,
31552,
31585,
31616,
31649,
31680,
31713,
31744,
31777,
31808,
31841,
31872,
31905,
31936,
31969,
32000,
32033,
32064,
32097,
32128,
32161,
32192,
32225,
32384,
32417,
32466,
32480,
32513,
32544,
32609,
32672,
34305,
35840,
35873,
35904,
35937,
35968,
36001,
36032,
36065,
36096,
36129,
36160,
36193,
36224,
36257,
36288,
36321,
36352,
36385,
36416,
36449,
36480,
36513,
36544,
36577,
36608,
36641,
36672,
36705,
36736,
36769,
36800,
36833,
36864,
36897,
36949,
36965,
37127,
37184,
37217,
37248,
37281,
37312,
37345,
37376,
37409,
37440,
37473,
37504,
37537,
37568,
37601,
37632,
37665,
37696,
37729,
37760,
37793,
37824,
37857,
37888,
37921,
37952,
37985,
38016,
38049,
38080,
38113,
38144,
38177,
38208,
38241,
38272,
38305,
38336,
38369,
38400,
38433,
38464,
38497,
38528,
38561,
38592,
38625,
38656,
38689,
38720,
38753,
38784,
38817,
38848,
38881,
38912,
38977,
39008,
39041,
39072,
39105,
39136,
39169,
39200,
39233,
39264,
39297,
39328,
39361,
39424,
39457,
39488,
39521,
39552,
39585,
39616,
39649,
39680,
39713,
39744,
39777,
39808,
39841,
39872,
39905,
39936,
39969,
40000,
40033,
40064,
40097,
40128,
40161,
40192,
40225,
40256,
40289,
40320,
40353,
40384,
40417,
40448,
40481,
40512,
40545,
40576,
40609,
40640,
40673,
40704,
40737,
40768,
40801,
40832,
40865,
40896,
40929,
40960,
40993,
41024,
41057,
41088,
41121,
41152,
41185,
41216,
41249,
41280,
41313,
41344,
41377,
41408,
41441,
41472,
41505,
41536,
41569,
41600,
41633,
41664,
41697,
41728,
41761,
41792,
41825,
41856,
41889,
41920,
41953,
41984,
42017,
42048,
42081,
42112,
42145,
42176,
42209,
42240,
42273,
42304,
42337,
42368,
42401,
42432,
42465,
42525,
42528,
43773,
43811,
43857,
44033,
45361,
45388,
45437,
45493,
45555,
45597,
45605,
47052,
47077,
47121,
47141,
47217,
47237,
47313,
47333,
47389,
47620,
48509,
48612,
48753,
48829,
49178,
49362,
49457,
49523,
49553,
49621,
49669,
50033,
50074,
50097,
50180,
51203,
51236,
51557,
52232,
52561,
52676,
52741,
52772,
55953,
55972,
56005,
56250,
56277,
56293,
56483,
56549,
56629,
56645,
56772,
56840,
57156,
57269,
57316,
57361,
57821,
57850,
57860,
57893,
57924,
58885,
59773,
59812,
62661,
63012,
63069,
63496,
63812,
64869,
65155,
65237,
65265,
65347,
65405,
65445,
65491,
65540,
66245,
66371,
66405,
66691,
66725,
66819,
66853,
67037,
67089,
67581,
67588,
68389,
68509,
68561,
68605,
68612,
68989,
69124,
69908,
69924,
70141,
70170,
70237,
70405,
70660,
71971,
72005,
72794,
72805,
73830,
73860,
75589,
75622,
75653,
75684,
75718,
75813,
76070,
76197,
76230,
76292,
76325,
76548,
76869,
76945,
77000,
77329,
77347,
77380,
77861,
77894,
77981,
77988,
78269,
78308,
78397,
78436,
79165,
79172,
79421,
79428,
79485,
79556,
79709,
79749,
79780,
79814,
79909,
80061,
80102,
80189,
80230,
80293,
80324,
80381,
80614,
80669,
80772,
80861,
80868,
80965,
81053,
81096,
81412,
81491,
81546,
81749,
81779,
81796,
81841,
81861,
81917,
81957,
82022,
82077,
82084,
82301,
82404,
82493,
82532,
83261,
83268,
83517,
83524,
83613,
83620,
83709,
83716,
83805,
83845,
83901,
83910,
84005,
84093,
84197,
84285,
84325,
84445,
84517,
84573,
84772,
84925,
84932,
84989,
85192,
85509,
85572,
85669,
85713,
85757,
86053,
86118,
86173,
86180,
86493,
86500,
86621,
86628,
87357,
87364,
87613,
87620,
87709,
87716,
87901,
87941,
87972,
88006,
88101,
88285,
88293,
88358,
88413,
88422,
88485,
88541,
88580,
88637,
89092,
89157,
89245,
89288,
89617,
89651,
89693,
89892,
89925,
90141,
90149,
90182,
90269,
90276,
90557,
90596,
90685,
90724,
91453,
91460,
91709,
91716,
91805,
91812,
91997,
92037,
92068,
92102,
92133,
92166,
92197,
92349,
92390,
92477,
92518,
92581,
92637,
92837,
92902,
92957,
93060,
93149,
93156,
93253,
93341,
93384,
93717,
93732,
93770,
93981,
94277,
94308,
94365,
94372,
94589,
94660,
94781,
94788,
94941,
95012,
95101,
95108,
95165,
95172,
95261,
95332,
95421,
95492,
95613,
95684,
96093,
96198,
96261,
96294,
96381,
96454,
96573,
96582,
96677,
96733,
96772,
96829,
96998,
97053,
97480,
97802,
97909,
98099,
98133,
98173,
98309,
98342,
98437,
98468,
98749,
98756,
98877,
98884,
99645,
99652,
100189,
100229,
100260,
100293,
100390,
100541,
100549,
100669,
100677,
100829,
101029,
101117,
101124,
101245,
101284,
101341,
101380,
101445,
101533,
101576,
101917,
102129,
102154,
102389,
102404,
102437,
102470,
102545,
102564,
102845,
102852,
102973,
102980,
103741,
103748,
104093,
104100,
104285,
104325,
104356,
104390,
104421,
104454,
104637,
104645,
104678,
104765,
104774,
104837,
104925,
105126,
105213,
105380,
105469,
105476,
105541,
105629,
105672,
106013,
106020,
106086,
106141,
106501,
106566,
106628,
106941,
106948,
107069,
107076,
108389,
108452,
108486,
108581,
108733,
108742,
108861,
108870,
108965,
108996,
109045,
109085,
109188,
109286,
109322,
109540,
109637,
109725,
109768,
110090,
110389,
110404,
110621,
110629,
110662,
110749,
110756,
111357,
111428,
112221,
112228,
112541,
112548,
112605,
112644,
112893,
112965,
113021,
113126,
113221,
113341,
113349,
113405,
113414,
113693,
113864,
114205,
114246,
114321,
114365,
114724,
116261,
116292,
116357,
116605,
116723,
116740,
116931,
116965,
117233,
117256,
117585,
117661,
118820,
118909,
118916,
118973,
118980,
119165,
119172,
119965,
119972,
120029,
120036,
120357,
120388,
120453,
120740,
120797,
120836,
121021,
121027,
121085,
121093,
121341,
121352,
121693,
121732,
121885,
122884,
122933,
123025,
123509,
123537,
123573,
123653,
123733,
123912,
124234,
124565,
124581,
124629,
124645,
124693,
124709,
124749,
124782,
124813,
124846,
124870,
124932,
125213,
125220,
126397,
126501,
126950,
126981,
127153,
127173,
127236,
127397,
127773,
127781,
128957,
128981,
129221,
129269,
129469,
129493,
129553,
129717,
129841,
129917,
131076,
132454,
132517,
132646,
132677,
132870,
132901,
132966,
133029,
133092,
133128,
133457,
133636,
133830,
133893,
133956,
134085,
134180,
134214,
134308,
134374,
134596,
134693,
134820,
135237,
135270,
135333,
135398,
135589,
135620,
135654,
135688,
136006,
136101,
136149,
136192,
137437,
137440,
137501,
137632,
137693,
137729,
139121,
139139,
139169,
139268,
149821,
149828,
149981,
150020,
150269,
150276,
150333,
150340,
150493,
150532,
151869,
151876,
152029,
152068,
153149,
153156,
153309,
153348,
153597,
153604,
153661,
153668,
153821,
153860,
154365,
154372,
156221,
156228,
156381,
156420,
158589,
158629,
158737,
159018,
159677,
159748,
160277,
160605,
160768,
163549,
163585,
163805,
163852,
163876,
183733,
183761,
183780,
184342,
184356,
185197,
185230,
185277,
185348,
187761,
187849,
187940,
188221,
188420,
188997,
189094,
189149,
189412,
190021,
190086,
190129,
190205,
190468,
191045,
191133,
191492,
191933,
191940,
192061,
192069,
192157,
192516,
194181,
194246,
194277,
194502,
194757,
194790,
194853,
195217,
195299,
195345,
195443,
195460,
195493,
195549,
195592,
195933,
196106,
196445,
196625,
196812,
196849,
196965,
197082,
197093,
197128,
197469,
197636,
198755,
198788,
200509,
200708,
200869,
200932,
202021,
202052,
202109,
202244,
204509,
204804,
205821,
205829,
205926,
206053,
206118,
206237,
206342,
206405,
206438,
206629,
206749,
206869,
206909,
206993,
207048,
207364,
208349,
208388,
208573,
208900,
210333,
210436,
211293,
211464,
211786,
211837,
211925,
212996,
213733,
213798,
213861,
213917,
213969,
214020,
215718,
215749,
215782,
215813,
216061,
216069,
216102,
216133,
216166,
216229,
216486,
216677,
217021,
217061,
217096,
217437,
217608,
217949,
218129,
218339,
218385,
218589,
218629,
219079,
219109,
219645,
221189,
221318,
221348,
222853,
222886,
222917,
223078,
223109,
223142,
223301,
223334,
223396,
223677,
223752,
224081,
224309,
224613,
224917,
225201,
225277,
225285,
225350,
225380,
226342,
226373,
226502,
226565,
226630,
226661,
226756,
226824,
227140,
228549,
228582,
228613,
228678,
228773,
228806,
228837,
228934,
229021,
229265,
229380,
230534,
230789,
231046,
231109,
231197,
231281,
231432,
231773,
231844,
231944,
232260,
233219,
233425,
233473,
233789,
233984,
235389,
235424,
235537,
235805,
236037,
236145,
236165,
236582,
236613,
236836,
236965,
236996,
237189,
237220,
237286,
237317,
237380,
237437,
237569,
238979,
240993,
241411,
241441,
242531,
243717,
245760,
245793,
245824,
245857,
245888,
245921,
245952,
245985,
246016,
246049,
246080,
246113,
246144,
246177,
246208,
246241,
246272,
246305,
246336,
246369,
246400,
246433,
246464,
246497,
246528,
246561,
246592,
246625,
246656,
246689,
246720,
246753,
246784,
246817,
246848,
246881,
246912,
246945,
246976,
247009,
247040,
247073,
247104,
247137,
247168,
247201,
247232,
247265,
247296,
247329,
247360,
247393,
247424,
247457,
247488,
247521,
247552,
247585,
247616,
247649,
247680,
247713,
247744,
247777,
247808,
247841,
247872,
247905,
247936,
247969,
248000,
248033,
248064,
248097,
248128,
248161,
248192,
248225,
248256,
248289,
248320,
248353,
248384,
248417,
248448,
248481,
248512,
248545,
248576,
248609,
248640,
248673,
248704,
248737,
248768,
248801,
248832,
248865,
248896,
248929,
248960,
248993,
249024,
249057,
249088,
249121,
249152,
249185,
249216,
249249,
249280,
249313,
249344,
249377,
249408,
249441,
249472,
249505,
249536,
249569,
249600,
249633,
249664,
249697,
249728,
249761,
249792,
249825,
249856,
249889,
249920,
249953,
249984,
250017,
250048,
250081,
250112,
250145,
250176,
250209,
250240,
250273,
250304,
250337,
250368,
250401,
250432,
250465,
250496,
250529,
250816,
250849,
250880,
250913,
250944,
250977,
251008,
251041,
251072,
251105,
251136,
251169,
251200,
251233,
251264,
251297,
251328,
251361,
251392,
251425,
251456,
251489,
251520,
251553,
251584,
251617,
251648,
251681,
251712,
251745,
251776,
251809,
251840,
251873,
251904,
251937,
251968,
252001,
252032,
252065,
252096,
252129,
252160,
252193,
252224,
252257,
252288,
252321,
252352,
252385,
252416,
252449,
252480,
252513,
252544,
252577,
252608,
252641,
252672,
252705,
252736,
252769,
252800,
252833,
252864,
252897,
252928,
252961,
252992,
253025,
253056,
253089,
253120,
253153,
253184,
253217,
253248,
253281,
253312,
253345,
253376,
253409,
253440,
253473,
253504,
253537,
253568,
253601,
253632,
253665,
253696,
253729,
253760,
253793,
253824,
253857,
253888,
253921,
254208,
254465,
254685,
254720,
254941,
254977,
255232,
255489,
255744,
256001,
256221,
256256,
256477,
256513,
256797,
256800,
256861,
256864,
256925,
256928,
256989,
256992,
257025,
257280,
257537,
258013,
258049,
258306,
258561,
258818,
259073,
259330,
259585,
259773,
259777,
259840,
259970,
260020,
260033,
260084,
260161,
260285,
260289,
260352,
260482,
260532,
260609,
260765,
260801,
260864,
261021,
261044,
261121,
261376,
261556,
261661,
261697,
261821,
261825,
261888,
262018,
262068,
262141,
262166,
262522,
262668,
262865,
262927,
262960,
262989,
263023,
263088,
263117,
263151,
263185,
263447,
263480,
263514,
263670,
263697,
263983,
264016,
264049,
264171,
264241,
264338,
264365,
264398,
264433,
264786,
264817,
264843,
264881,
265206,
265242,
265405,
265434,
265738,
265763,
265821,
265866,
266066,
266157,
266190,
266211,
266250,
266578,
266669,
266702,
266749,
266755,
267197,
267283,
268349,
268805,
269223,
269349,
269383,
269477,
269885,
270357,
270400,
270453,
270560,
270613,
270657,
270688,
270785,
270848,
270945,
270997,
271008,
271061,
271122,
271136,
271317,
271488,
271541,
271552,
271605,
271616,
271669,
271680,
271829,
271841,
271872,
272001,
272036,
272161,
272213,
272257,
272320,
272402,
272544,
272577,
272725,
272754,
272789,
272833,
272885,
272906,
273417,
274528,
274561,
274601,
274730,
274773,
274845,
274962,
275125,
275282,
275349,
275474,
275509,
275570,
275605,
275666,
275701,
275922,
275957,
276946,
277013,
277074,
277109,
277138,
277173,
278162,
286741,
286989,
287022,
287053,
287086,
287125,
287762,
287829,
288045,
288078,
288117,
290706,
290741,
291698,
292501,
293778,
293973,
296189,
296981,
297341,
297994,
299925,
302410,
303125,
308978,
309013,
309298,
309333,
311058,
311317,
314866,
314901,
322829,
322862,
322893,
322926,
322957,
322990,
323021,
323054,
323085,
323118,
323149,
323182,
323213,
323246,
323274,
324245,
325650,
325805,
325838,
325874,
326861,
326894,
326925,
326958,
326989,
327022,
327053,
327086,
327117,
327150,
327186,
327701,
335890,
340077,
340110,
340141,
340174,
340205,
340238,
340269,
340302,
340333,
340366,
340397,
340430,
340461,
340494,
340525,
340558,
340589,
340622,
340653,
340686,
340717,
340750,
340786,
342797,
342830,
342861,
342894,
342930,
343949,
343982,
344018,
352277,
353810,
354485,
354546,
354741,
355997,
356053,
357085,
357109,
360448,
361985,
363520,
363553,
363584,
363681,
363744,
363777,
363808,
363841,
363872,
363905,
363936,
364065,
364096,
364129,
364192,
364225,
364419,
364480,
364577,
364608,
364641,
364672,
364705,
364736,
364769,
364800,
364833,
364864,
364897,
364928,
364961,
364992,
365025,
365056,
365089,
365120,
365153,
365184,
365217,
365248,
365281,
365312,
365345,
365376,
365409,
365440,
365473,
365504,
365537,
365568,
365601,
365632,
365665,
365696,
365729,
365760,
365793,
365824,
365857,
365888,
365921,
365952,
365985,
366016,
366049,
366080,
366113,
366144,
366177,
366208,
366241,
366272,
366305,
366336,
366369,
366400,
366433,
366464,
366497,
366528,
366561,
366592,
366625,
366656,
366689,
366720,
366753,
366784,
366817,
366848,
366881,
366912,
366945,
366976,
367009,
367040,
367073,
367104,
367137,
367168,
367201,
367232,
367265,
367296,
367329,
367360,
367393,
367424,
367457,
367488,
367521,
367552,
367585,
367616,
367649,
367680,
367713,
367797,
367968,
368001,
368032,
368065,
368101,
368192,
368225,
368285,
368433,
368554,
368593,
368641,
369885,
369889,
369949,
370081,
370141,
370180,
371997,
372195,
372241,
372285,
372709,
372740,
373501,
373764,
374013,
374020,
374269,
374276,
374525,
374532,
374781,
374788,
375037,
375044,
375293,
375300,
375549,
375556,
375805,
375813,
376849,
376911,
376944,
376975,
377008,
377041,
377135,
377168,
377201,
377231,
377264,
377297,
377580,
377617,
377676,
377713,
377743,
377776,
377809,
377871,
377904,
377933,
377966,
377997,
378030,
378061,
378094,
378125,
378158,
378193,
378339,
378385,
378700,
378769,
378892,
378929,
378957,
378993,
379413,
379473,
379565,
379598,
379629,
379662,
379693,
379726,
379757,
379790,
379820,
379869,
380949,
381789,
381813,
384669,
385045,
391901,
392725,
393238,
393265,
393365,
393379,
393412,
393449,
393485,
393518,
393549,
393582,
393613,
393646,
393677,
393710,
393741,
393774,
393813,
393869,
393902,
393933,
393966,
393997,
394030,
394061,
394094,
394124,
394157,
394190,
394261,
394281,
394565,
394694,
394764,
394787,
394965,
395017,
395107,
395140,
395185,
395221,
395293,
395300,
398077,
398117,
398196,
398243,
398308,
398348,
398372,
401265,
401283,
401380,
401437,
401572,
402973,
402980,
406013,
406037,
406090,
406229,
406532,
407573,
408733,
409077,
409092,
409621,
410621,
410634,
410965,
411914,
412181,
412202,
412693,
413706,
414037,
415274,
415765,
425988,
636949,
638980,
1311395,
1311428,
1348029,
1348117,
1349885,
1350148,
1351427,
1351633,
1351684,
1360259,
1360305,
1360388,
1360904,
1361220,
1361309,
1361920,
1361953,
1361984,
1362017,
1362048,
1362081,
1362112,
1362145,
1362176,
1362209,
1362240,
1362273,
1362304,
1362337,
1362368,
1362401,
1362432,
1362465,
1362496,
1362529,
1362560,
1362593,
1362624,
1362657,
1362688,
1362721,
1362752,
1362785,
1362816,
1362849,
1362880,
1362913,
1362944,
1362977,
1363008,
1363041,
1363072,
1363105,
1363136,
1363169,
1363200,
1363233,
1363264,
1363297,
1363328,
1363361,
1363396,
1363429,
1363463,
1363569,
1363589,
1363921,
1363939,
1363968,
1364001,
1364032,
1364065,
1364096,
1364129,
1364160,
1364193,
1364224,
1364257,
1364288,
1364321,
1364352,
1364385,
1364416,
1364449,
1364480,
1364513,
1364544,
1364577,
1364608,
1364641,
1364672,
1364705,
1364736,
1364769,
1364800,
1364833,
1364867,
1364933,
1364996,
1367241,
1367557,
1367633,
1367837,
1368084,
1368803,
1369108,
1369152,
1369185,
1369216,
1369249,
1369280,
1369313,
1369344,
1369377,
1369408,
1369441,
1369472,
1369505,
1369536,
1369569,
1369664,
1369697,
1369728,
1369761,
1369792,
1369825,
1369856,
1369889,
1369920,
1369953,
1369984,
1370017,
1370048,
1370081,
1370112,
1370145,
1370176,
1370209,
1370240,
1370273,
1370304,
1370337,
1370368,
1370401,
1370432,
1370465,
1370496,
1370529,
1370560,
1370593,
1370624,
1370657,
1370688,
1370721,
1370752,
1370785,
1370816,
1370849,
1370880,
1370913,
1370944,
1370977,
1371008,
1371041,
1371072,
1371105,
1371136,
1371169,
1371200,
1371233,
1371264,
1371297,
1371328,
1371361,
1371392,
1371425,
1371456,
1371489,
1371520,
1371553,
1371584,
1371617,
1371651,
1371681,
1371936,
1371969,
1372000,
1372033,
1372064,
1372129,
1372160,
1372193,
1372224,
1372257,
1372288,
1372321,
1372352,
1372385,
1372419,
1372468,
1372512,
1372545,
1372576,
1372609,
1372644,
1372672,
1372705,
1372736,
1372769,
1372864,
1372897,
1372928,
1372961,
1372992,
1373025,
1373056,
1373089,
1373120,
1373153,
1373184,
1373217,
1373248,
1373281,
1373312,
1373345,
1373376,
1373409,
1373440,
1373473,
1373504,
1373665,
1373696,
1373857,
1373888,
1373921,
1373952,
1373985,
1374016,
1374049,
1374080,
1374113,
1374144,
1374177,
1374208,
1374241,
1374272,
1374305,
1374336,
1374465,
1374496,
1374529,
1374589,
1374720,
1374753,
1374813,
1374817,
1374877,
1374881,
1374912,
1374945,
1374976,
1375009,
1375069,
1375811,
1375904,
1375937,
1375972,
1376003,
1376065,
1376100,
1376325,
1376356,
1376453,
1376484,
1376613,
1376644,
1377382,
1377445,
1377510,
1377557,
1377669,
1377725,
1377802,
1378005,
1378067,
1378101,
1378141,
1378308,
1379985,
1380125,
1380358,
1380420,
1382022,
1382533,
1382621,
1382865,
1382920,
1383261,
1383429,
1384004,
1384209,
1384292,
1384337,
1384356,
1384421,
1384456,
1384772,
1385669,
1385937,
1385988,
1386725,
1387078,
1387165,
1387505,
1387524,
1388477,
1388549,
1388646,
1388676,
1390181,
1390214,
1390277,
1390406,
1390469,
1390534,
1390641,
1391069,
1391075,
1391112,
1391453,
1391569,
1391620,
1391781,
1391811,
1391844,
1392136,
1392452,
1392637,
1392644,
1393957,
1394150,
1394213,
1394278,
1394341,
1394429,
1394692,
1394789,
1394820,
1395077,
1395110,
1395165,
1395208,
1395549,
1395601,
1395716,
1396227,
1396260,
1396469,
1396548,
1396582,
1396613,
1396646,
1396676,
1398277,
1398308,
1398341,
1398436,
1398501,
1398564,
1398725,
1398788,
1398821,
1398852,
1398909,
1399652,
1399715,
1399761,
1399812,
1400166,
1400197,
1400262,
1400337,
1400388,
1400419,
1400486,
1400517,
1400573,
1400868,
1401085,
1401124,
1401341,
1401380,
1401597,
1401860,
1402109,
1402116,
1402365,
1402369,
1403764,
1403779,
1403905,
1404195,
1404244,
1404317,
1404417,
1406980,
1408102,
1408165,
1408198,
1408261,
1408294,
1408369,
1408390,
1408421,
1408477,
1408520,
1408861,
1409028,
1766557,
1766916,
1767677,
1767780,
1769373,
1769499,
1835036,
2039812,
2051549,
2051588,
2055005,
2056193,
2056445,
2056801,
2056989,
2057124,
2057157,
2057188,
2057522,
2057540,
2057981,
2057988,
2058173,
2058180,
2058237,
2058244,
2058333,
2058340,
2058429,
2058436,
2061908,
2062461,
2062948,
2074574,
2074605,
2074645,
2075140,
2077213,
2077252,
2079005,
2079221,
2079261,
2080260,
2080659,
2080693,
2080773,
2081297,
2081517,
2081550,
2081585,
2081629,
2081797,
2082321,
2082348,
2082411,
2082477,
2082510,
2082541,
2082574,
2082605,
2082638,
2082669,
2082702,
2082733,
2082766,
2082797,
2082830,
2082861,
2082894,
2082925,
2082958,
2082993,
2083053,
2083086,
2083121,
2083243,
2083345,
2083453,
2083473,
2083596,
2083629,
2083662,
2083693,
2083726,
2083757,
2083790,
2083825,
2083922,
2083948,
2083986,
2084093,
2084113,
2084147,
2084177,
2084253,
2084356,
2084541,
2084548,
2088893,
2088954,
2088989,
2089009,
2089107,
2089137,
2089229,
2089262,
2089297,
2089330,
2089361,
2089388,
2089425,
2089480,
2089809,
2089874,
2089969,
2090016,
2090861,
2090897,
2090926,
2090964,
2090987,
2091028,
2091041,
2091885,
2091922,
2091950,
2091986,
2092013,
2092046,
2092081,
2092109,
2092142,
2092177,
2092228,
2092547,
2092580,
2094019,
2094084,
2095101,
2095172,
2095389,
2095428,
2095645,
2095684,
2095901,
2095940,
2096061,
2096147,
2096210,
2096244,
2096277,
2096307,
2096381,
2096405,
2096434,
2096565,
2096637,
2096954,
2097045,
2097117,
2097156,
2097565,
2097572,
2098429,
2098436,
2099069,
2099076,
2099165,
2099172,
2099677,
2099716,
2100189,
2101252,
2105213,
2105361,
2105469,
2105578,
2107037,
2107125,
2107401,
2109098,
2109237,
2109770,
2109845,
2109949,
2109973,
2110397,
2110485,
2110525,
2112021,
2113445,
2113501,
2117636,
2118589,
2118660,
2120253,
2120709,
2120746,
2121629,
2121732,
2122762,
2122909,
2123172,
2123817,
2123844,
2124105,
2124157,
2124292,
2125509,
2125693,
2125828,
2126813,
2126833,
2126852,
2128029,
2128132,
2128401,
2128425,
2128605,
2129920,
2131201,
2132484,
2135005,
2135048,
2135389,
2135552,
2136733,
2136833,
2138013,
2138116,
2139421,
2139652,
2141341,
2141681,
2141696,
2142077,
2142080,
2142589,
2142592,
2142845,
2142848,
2142941,
2142945,
2143325,
2143329,
2143837,
2143841,
2144093,
2144097,
2144189,
2146308,
2156285,
2156548,
2157277,
2157572,
2157853,
2158595,
2158813,
2158819,
2160189,
2160195,
2160509,
2162692,
2162909,
2162948,
2163005,
2163012,
2164445,
2164452,
2164541,
2164612,
2164669,
2164708,
2165469,
2165489,
2165514,
2165764,
2166517,
2166570,
2166788,
2167805,
2168042,
2168349,
2169860,
2170493,
2170500,
2170589,
2170730,
2170884,
2171594,
2171805,
2171889,
2171908,
2172765,
2172913,
2172957,
2174980,
2176797,
2176906,
2176964,
2177034,
2177565,
2177610,
2179076,
2179109,
2179229,
2179237,
2179325,
2179461,
2179588,
2179741,
2179748,
2179869,
2179876,
2180829,
2180869,
2180989,
2181093,
2181130,
2181437,
2181649,
2181949,
2182148,
2183082,
2183153,
2183172,
2184106,
2184221,
2185220,
2185493,
2185508,
2186405,
2186493,
2186602,
2186769,
2187005,
2187268,
2189021,
2189105,
2189316,
2190045,
2190090,
2190340,
2190973,
2191114,
2191364,
2191965,
2192177,
2192317,
2192682,
2192925,
2195460,
2197821,
2199552,
2201213,
2201601,
2203261,
2203466,
2203652,
2204805,
2204957,
2205192,
2205533,
2214922,
2215933,
2215940,
2217309,
2217317,
2217388,
2217437,
2217476,
2217565,
2219941,
2220036,
2220970,
2221284,
2221341,
2221572,
2222277,
2222634,
2222769,
2222941,
2223620,
2224197,
2224337,
2224477,
2225668,
2226346,
2226589,
2227204,
2227965,
2228230,
2228261,
2228294,
2228324,
2230021,
2230513,
2230749,
2230858,
2231496,
2231813,
2231844,
2231909,
2231972,
2232029,
2232293,
2232390,
2232420,
2233862,
2233957,
2234086,
2234149,
2234225,
2234298,
2234321,
2234437,
2234493,
2234810,
2234845,
2234884,
2235709,
2235912,
2236253,
2236421,
2236516,
2237669,
2237830,
2237861,
2238141,
2238152,
2238481,
2238596,
2238630,
2238692,
2238749,
2238980,
2240101,
2240145,
2240196,
2240253,
2240517,
2240582,
2240612,
2242150,
2242245,
2242534,
2242596,
2242737,
2242853,
2242993,
2243014,
2243045,
2243080,
2243396,
2243441,
2243460,
2243505,
2243613,
2243626,
2244285,
2244612,
2245213,
2245220,
2246022,
2246117,
2246214,
2246277,
2246310,
2246341,
2246417,
2246597,
2246628,
2246693,
2246749,
2248708,
2248957,
2248964,
2249021,
2249028,
2249181,
2249188,
2249693,
2249700,
2250033,
2250077,
2250244,
2251749,
2251782,
2251877,
2252157,
2252296,
2252637,
2252805,
2252870,
2252957,
2252964,
2253245,
2253284,
2253373,
2253412,
2254141,
2254148,
2254397,
2254404,
2254493,
2254500,
2254685,
2254693,
2254756,
2254790,
2254853,
2254886,
2255037,
2255078,
2255165,
2255206,
2255325,
2255364,
2255421,
2255590,
2255645,
2255780,
2255942,
2256029,
2256069,
2256317,
2256389,
2256573,
2260996,
2262694,
2262789,
2263046,
2263109,
2263206,
2263237,
2263268,
2263409,
2263560,
2263889,
2263965,
2263985,
2264005,
2264036,
2264157,
2265092,
2266630,
2266725,
2266918,
2266949,
2266982,
2267109,
2267174,
2267205,
2267268,
2267345,
2267364,
2267421,
2267656,
2267997,
2273284,
2274790,
2274885,
2275037,
2275078,
2275205,
2275270,
2275301,
2275377,
2276100,
2276229,
2276317,
2277380,
2278918,
2279013,
2279270,
2279333,
2279366,
2279397,
2279473,
2279556,
2279613,
2279944,
2280285,
2280465,
2280893,
2281476,
2282853,
2282886,
2282917,
2282950,
2283013,
2283206,
2283237,
2283268,
2283313,
2283357,
2283528,
2283869,
2285572,
2286461,
2286501,
2286598,
2286661,
2286790,
2286821,
2287005,
2287112,
2287434,
2287505,
2287605,
2287620,
2287869,
2293764,
2295174,
2295269,
2295558,
2295589,
2295665,
2295709,
2298880,
2299905,
2300936,
2301258,
2301565,
2301924,
2302205,
2302244,
2302301,
2302340,
2302621,
2302628,
2302717,
2302724,
2303494,
2303709,
2303718,
2303805,
2303845,
2303910,
2303941,
2303972,
2304006,
2304036,
2304070,
2304101,
2304145,
2304253,
2304520,
2304861,
2307076,
2307357,
2307396,
2308646,
2308741,
2308893,
2308933,
2308998,
2309125,
2309156,
2309201,
2309220,
2309254,
2309309,
2310148,
2310181,
2310500,
2311781,
2311974,
2312004,
2312037,
2312177,
2312421,
2312477,
2312708,
2312741,
2312934,
2312997,
2313092,
2314565,
2314982,
2315013,
2315089,
2315172,
2315217,
2315389,
2315780,
2318141,
2318353,
2318685,
2326532,
2326845,
2326852,
2328038,
2328069,
2328317,
2328325,
2328518,
2328549,
2328580,
2328625,
2328797,
2329096,
2329418,
2330045,
2330129,
2330180,
2331165,
2331205,
2331933,
2331942,
2331973,
2332198,
2332229,
2332294,
2332325,
2332413,
2334724,
2334973,
2334980,
2335069,
2335076,
2336293,
2336509,
2336581,
2336637,
2336645,
2336733,
2336741,
2336964,
2336997,
2337053,
2337288,
2337629,
2337796,
2338013,
2338020,
2338109,
2338116,
2339142,
2339325,
2339333,
2339421,
2339430,
2339493,
2339526,
2339557,
2339588,
2339645,
2339848,
2340189,
2350084,
2350693,
2350758,
2350833,
2350909,
2351109,
2351172,
2351206,
2351236,
2351677,
2351684,
2352774,
2352837,
2353021,
2353094,
2353157,
2353190,
2353221,
2353265,
2353672,
2354013,
2356740,
2356797,
2357258,
2357941,
2358195,
2358325,
2358877,
2359281,
2359300,
2388829,
2392073,
2395645,
2395665,
2395837,
2396164,
2402461,
2486788,
2489905,
2489981,
2490372,
2524698,
2525189,
2525220,
2525413,
2525917,
2654212,
2672893,
2949124,
2967357,
2967556,
2968573,
2968584,
2968925,
2969041,
2969092,
2971645,
2971656,
2971997,
2972164,
2973149,
2973189,
2973361,
2973405,
2973700,
2975237,
2975473,
2975637,
2975747,
2975889,
2975925,
2975965,
2976264,
2976605,
2976618,
2976861,
2976868,
2977565,
2977700,
2978333,
3000320,
3001345,
3002378,
3003121,
3003261,
3006468,
3008893,
3008997,
3009028,
3009062,
3010845,
3011045,
3011171,
3011613,
3013635,
3013713,
3013731,
3013765,
3013821,
3014150,
3014237,
3014660,
3211037,
3211268,
3250909,
3252228,
3252541,
3538435,
3538589,
3538595,
3538845,
3538851,
3538941,
3538948,
3548285,
3548740,
3548797,
3549700,
3549821,
3549860,
3549917,
3550340,
3550493,
3550724,
3563421,
3637252,
3640701,
3640836,
3641277,
3641348,
3641661,
3641860,
3642205,
3642261,
3642277,
3642353,
3642394,
3642525,
3792901,
3794397,
3794437,
3795197,
3795477,
3799197,
3801109,
3808989,
3809301,
3810557,
3810613,
3812518,
3812581,
3812693,
3812774,
3812986,
3813221,
3813493,
3813541,
3813781,
3814725,
3814869,
3816829,
3817493,
3819589,
3819701,
3819741,
3823626,
3824285,
3824650,
3825309,
3825685,
3828477,
3828746,
3829565,
3833856,
3834689,
3835520,
3836353,
3836605,
3836609,
3837184,
3838017,
3838848,
3838909,
3838912,
3839005,
3839040,
3839101,
3839136,
3839229,
3839264,
3839421,
3839424,
3839681,
3839837,
3839841,
3839901,
3839905,
3840157,
3840161,
3840512,
3841345,
3842176,
3842269,
3842272,
3842429,
3842464,
3842749,
3842752,
3843005,
3843009,
3843840,
3843933,
3843936,
3844093,
3844096,
3844285,
3844288,
3844349,
3844416,
3844669,
3844673,
3845504,
3846337,
3847168,
3848001,
3848832,
3849665,
3850496,
3851329,
3852160,
3852993,
3853824,
3854657,
3855581,
3855616,
3856434,
3856449,
3857266,
3857281,
3857472,
3858290,
3858305,
3859122,
3859137,
3859328,
3860146,
3860161,
3860978,
3860993,
3861184,
3862002,
3862017,
3862834,
3862849,
3863040,
3863858,
3863873,
3864690,
3864705,
3864896,
3864929,
3864989,
3865032,
3866645,
3883013,
3884789,
3884901,
3886517,
3886757,
3886805,
3887237,
3887285,
3887345,
3887517,
3887973,
3888157,
3888165,
3888669,
3923969,
3924292,
3924321,
3924989,
3925153,
3925373,
3932165,
3932413,
3932421,
3932989,
3933029,
3933277,
3933285,
3933373,
3933381,
3933565,
3933699,
3935709,
3936741,
3936797,
3940356,
3941821,
3941893,
3942115,
3942365,
3942408,
3942749,
3942852,
3942901,
3942941,
3953156,
3954117,
3954173,
3954692,
3956101,
3956232,
3956573,
3956723,
3956765,
3971588,
3972451,
3972485,
3972616,
3972957,
3996676,
3996925,
3996932,
3997085,
3997092,
3997181,
3997188,
3997693,
3997700,
4004029,
4004074,
4004357,
4004605,
4005888,
4006977,
4008069,
4008291,
4008349,
4008456,
4008797,
4008913,
4008989,
4034090,
4035989,
4036010,
4036115,
4036138,
4036285,
4038698,
4040149,
4040170,
4040669,
4046852,
4047005,
4047012,
4047901,
4047908,
4047997,
4048004,
4048061,
4048100,
4048157,
4048164,
4048509,
4048516,
4048669,
4048676,
4048733,
4048740,
4048797,
4048964,
4049021,
4049124,
4049181,
4049188,
4049245,
4049252,
4049309,
4049316,
4049437,
4049444,
4049533,
4049540,
4049597,
4049636,
4049693,
4049700,
4049757,
4049764,
4049821,
4049828,
4049885,
4049892,
4049949,
4049956,
4050045,
4050052,
4050109,
4050148,
4050301,
4050308,
4050557,
4050564,
4050717,
4050724,
4050877,
4050884,
4050941,
4050948,
4051293,
4051300,
4051869,
4052004,
4052125,
4052132,
4052317,
4052324,
4052893,
4054546,
4054621,
4063253,
4064669,
4064789,
4067997,
4068373,
4068861,
4068917,
4069405,
4069429,
4069917,
4069941,
4071133,
4071434,
4071861,
4077021,
4078805,
4079741,
4080149,
4081565,
4081685,
4081981,
4082197,
4082269,
4082709,
4082909,
4087829,
4095860,
4096021,
4119325,
4119445,
4119997,
4120085,
4120509,
4120597,
4124413,
4124533,
4127581,
4127765,
4128157,
4128277,
4128317,
4128789,
4129181,
4129301,
4131101,
4131349,
4131677,
4131861,
4133149,
4133397,
4134365,
4134421,
4134493,
4136981,
4147869,
4148245,
4148701,
4148757,
4149181,
4149269,
4149565,
4149781,
4151261,
4151285,
4151517,
4151765,
4152221,
4152341,
4152637,
4152853,
4153149,
4153365,
4158077,
4158101,
4159869,
4161032,
4161373,
4194308,
5561373,
5562372,
5695325,
5695492,
5702621,
5702660,
5887069,
5887492,
6126653,
6127108,
6147037,
6225924,
6243293,
6291460,
6449533,
6449668,
6583837,
29360186,
29360221,
29361178,
29364253,
29368325,
29376029,
31457308,
33554397,
33554460,
35651549,
35651613,
//--Autogenerated -- end of section automatically generated
};

constexpr int maxUnicode = 0x10ffff;
constexpr int maskCategory = 0x1F;

}

// Each element in catRanges is the start of a range of Unicode characters in
// one general category.
// The value is comprised of a 21-bit character value shifted 5 bits and a 5 bit
// category matching the CharacterCategory enumeration.
// Initial version has 3249 entries and adds about 13K to the executable.
// The array is in ascending order so can be searched using binary search.
// Therefore the average call takes log2(3249) = 12 comparisons.
// For speed, it may be useful to make a linear table for the common values,
// possibly for 0..0xff for most Western European text or 0..0xfff for most
// alphabetic languages.

CharacterCategory CategoriseCharacter(int character) noexcept {
	if (character < 0 || character > maxUnicode)
		return ccCn;
	const int baseValue = character * (maskCategory+1) + maskCategory;
	try {
		// lower_bound will never throw with these args but its not marked noexcept so add catch to pretend.
		const int *placeAfter = std::lower_bound(catRanges, std::end(catRanges), baseValue);
		return static_cast<CharacterCategory>(*(placeAfter - 1) & maskCategory);
	} catch (...) {
		return ccCn;
	}
}

// Implementation of character sets recommended for identifiers in Unicode Standard Annex #31.
// http://unicode.org/reports/tr31/

namespace {

enum class OtherID { oidNone, oidStart, oidContinue };

// Silence 'magic' number warning as these character values are not used in multiple places.

// NOLINTBEGIN(*-magic-numbers)

// Some characters are treated as valid for identifiers even
// though most characters from their category are not.
// Values copied from http://www.unicode.org/Public/9.0.0/ucd/PropList.txt
OtherID OtherIDOfCharacter(int character) noexcept {
	if (
		(character == 0x1885) ||	// MONGOLIAN LETTER ALI GALI BALUDA
		(character == 0x1886) ||	// MONGOLIAN LETTER ALI GALI THREE BALUDA
		(character == 0x2118) ||	// SCRIPT CAPITAL P
		(character == 0x212E) ||	// ESTIMATED SYMBOL
		(character == 0x309B) ||	// KATAKANA-HIRAGANA VOICED SOUND MARK
		(character == 0x309C)) {	// KATAKANA-HIRAGANA SEMI-VOICED SOUND MARK
		return OtherID::oidStart;
	} else if (
		(character == 0x00B7) ||	// MIDDLE DOT
		(character == 0x0387) ||	// GREEK ANO TELEIA
		((character >= 0x1369) && (character <= 0x1371)) ||	// ETHIOPIC DIGIT ONE..ETHIOPIC DIGIT NINE
		(character == 0x19DA)) {	// NEW TAI LUE THAM DIGIT ONE
		return OtherID::oidContinue;
	} else {
		return OtherID::oidNone;
	}
}

// Determine if a character is in  Ll|Lu|Lt|Lm|Lo|Nl|Mn|Mc|Nd|Pc and has
// Pattern_Syntax|Pattern_White_Space.
// As of Unicode 9, only VERTICAL TILDE which is in Lm and has Pattern_Syntax matches.
// Should really generate from PropList.txt a list of Pattern_Syntax and Pattern_White_Space.
constexpr bool IsIdPattern(int character) noexcept {
	return character == 0x2E2F;
}

bool OmitXidStart(int character) noexcept {
	switch (character) {
	case 0x037A:	// GREEK YPOGEGRAMMENI
	case 0x0E33:	// THAI CHARACTER SARA AM
	case 0x0EB3:	// LAO VOWEL SIGN AM
	case 0x309B:	// KATAKANA-HIRAGANA VOICED SOUND MARK
	case 0x309C:	// KATAKANA-HIRAGANA SEMI-VOICED SOUND MARK
	case 0xFC5E:	// ARABIC LIGATURE SHADDA WITH DAMMATAN ISOLATED FORM
	case 0xFC5F:	// ARABIC LIGATURE SHADDA WITH KASRATAN ISOLATED FORM
	case 0xFC60:	// ARABIC LIGATURE SHADDA WITH FATHA ISOLATED FORM
	case 0xFC61:	// ARABIC LIGATURE SHADDA WITH DAMMA ISOLATED FORM
	case 0xFC62:	// ARABIC LIGATURE SHADDA WITH KASRA ISOLATED FORM
	case 0xFC63:	// ARABIC LIGATURE SHADDA WITH SUPERSCRIPT ALEF ISOLATED FORM
	case 0xFDFA:	// ARABIC LIGATURE SALLALLAHOU ALAYHE WASALLAM
	case 0xFDFB:	// ARABIC LIGATURE JALLAJALALOUHOU
	case 0xFE70:	// ARABIC FATHATAN ISOLATED FORM
	case 0xFE72:	// ARABIC DAMMATAN ISOLATED FORM
	case 0xFE74:	// ARABIC KASRATAN ISOLATED FORM
	case 0xFE76:	// ARABIC FATHA ISOLATED FORM
	case 0xFE78:	// ARABIC DAMMA ISOLATED FORM
	case 0xFE7A:	// ARABIC KASRA ISOLATED FORM
	case 0xFE7C:	// ARABIC SHADDA ISOLATED FORM
	case 0xFE7E:	// ARABIC SUKUN ISOLATED FORM
	case 0xFF9E:	// HALFWIDTH KATAKANA VOICED SOUND MARK
	case 0xFF9F:	// HALFWIDTH KATAKANA SEMI-VOICED SOUND MARK
		return true;
	default:
		return false;
	}
}

bool OmitXidContinue(int character) noexcept {
	switch (character) {
	case 0x037A:	// GREEK YPOGEGRAMMENI
	case 0x309B:	// KATAKANA-HIRAGANA VOICED SOUND MARK
	case 0x309C:	// KATAKANA-HIRAGANA SEMI-VOICED SOUND MARK
	case 0xFC5E:	// ARABIC LIGATURE SHADDA WITH DAMMATAN ISOLATED FORM
	case 0xFC5F:	// ARABIC LIGATURE SHADDA WITH KASRATAN ISOLATED FORM
	case 0xFC60:	// ARABIC LIGATURE SHADDA WITH FATHA ISOLATED FORM
	case 0xFC61:	// ARABIC LIGATURE SHADDA WITH DAMMA ISOLATED FORM
	case 0xFC62:	// ARABIC LIGATURE SHADDA WITH KASRA ISOLATED FORM
	case 0xFC63:	// ARABIC LIGATURE SHADDA WITH SUPERSCRIPT ALEF ISOLATED FORM
	case 0xFDFA:	// ARABIC LIGATURE SALLALLAHOU ALAYHE WASALLAM
	case 0xFDFB:	// ARABIC LIGATURE JALLAJALALOUHOU
	case 0xFE70:	// ARABIC FATHATAN ISOLATED FORM
	case 0xFE72:	// ARABIC DAMMATAN ISOLATED FORM
	case 0xFE74:	// ARABIC KASRATAN ISOLATED FORM
	case 0xFE76:	// ARABIC FATHA ISOLATED FORM
	case 0xFE78:	// ARABIC DAMMA ISOLATED FORM
	case 0xFE7A:	// ARABIC KASRA ISOLATED FORM
	case 0xFE7C:	// ARABIC SHADDA ISOLATED FORM
	case 0xFE7E:	// ARABIC SUKUN ISOLATED FORM
		return true;
	default:
		return false;
	}
}

// NOLINTEND(*-magic-numbers)

}

// UAX #31 defines ID_Start as
// [[:L:][:Nl:][:Other_ID_Start:]--[:Pattern_Syntax:]--[:Pattern_White_Space:]]
bool IsIdStart(int character) noexcept {
	if (IsIdPattern(character)) {
		return false;
	}
	const OtherID oid = OtherIDOfCharacter(character);
	if (oid == OtherID::oidStart) {
		return true;
	}
	const CharacterCategory c = CategoriseCharacter(character);
	return (c == ccLl || c == ccLu || c == ccLt || c == ccLm || c == ccLo
		|| c == ccNl);
}

// UAX #31 defines ID_Continue as
// [[:ID_Start:][:Mn:][:Mc:][:Nd:][:Pc:][:Other_ID_Continue:]--[:Pattern_Syntax:]--[:Pattern_White_Space:]]
bool IsIdContinue(int character) noexcept {
	if (IsIdPattern(character)) {
		return false;
	}
	const OtherID oid = OtherIDOfCharacter(character);
	if (oid != OtherID::oidNone) {
		return true;
	}
	const CharacterCategory c = CategoriseCharacter(character);
	return (c == ccLl || c == ccLu || c == ccLt || c == ccLm || c == ccLo
		|| c == ccNl || c == ccMn || c == ccMc || c == ccNd || c == ccPc);
}

// XID_Start is ID_Start modified for Normalization Form KC in UAX #31
bool IsXidStart(int character) noexcept {
	if (OmitXidStart(character)) {
		return false;
	} else {
		return IsIdStart(character);
	}
}

// XID_Continue is ID_Continue modified for Normalization Form KC in UAX #31
bool IsXidContinue(int character) noexcept {
	if (OmitXidContinue(character)) {
		return false;
	} else {
		return IsIdContinue(character);
	}
}

CharacterCategoryMap::CharacterCategoryMap() {
	Optimize(256);
}

int CharacterCategoryMap::Size() const noexcept {
	return static_cast<int>(dense.size());
}

void CharacterCategoryMap::Optimize(int countCharacters) {
	const int characters = std::clamp(countCharacters, 256, maxUnicode + 1);
	dense.resize(characters);

	int end = 0;
	int index = 0;
	int current = catRanges[index];
	++index;
	do {
		const int next = catRanges[index];
		const unsigned char category = current & maskCategory;
		current >>= 5;
		end = std::min(characters, next >> 5);
		while (current < end) {
			dense[current++] = category;
		}
		current = next;
		++index;
	} while (characters > end);
}

}


================================================
FILE: Libraries/scintilla/src/CharacterCategoryMap.h
================================================
// Scintilla source code edit control
/** @file CharacterCategoryMap.h
 ** Returns the Unicode general category of a character.
 ** Similar code to Lexilla's lexilla/lexlib/CharacterCategory.h but renamed
 ** to avoid problems with builds that statically include both Scintilla and Lexilla.
 **/
// Copyright 2013 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#ifndef CHARACTERCATEGORYMAP_H
#define CHARACTERCATEGORYMAP_H

namespace Scintilla::Internal {

enum CharacterCategory {
	ccLu, ccLl, ccLt, ccLm, ccLo,
	ccMn, ccMc, ccMe,
	ccNd, ccNl, ccNo,
	ccPc, ccPd, ccPs, ccPe, ccPi, ccPf, ccPo,
	ccSm, ccSc, ccSk, ccSo,
	ccZs, ccZl, ccZp,
	ccCc, ccCf, ccCs, ccCo, ccCn
};

CharacterCategory CategoriseCharacter(int character) noexcept;

// Common definitions of allowable characters in identifiers from UAX #31.
bool IsIdStart(int character) noexcept;
bool IsIdContinue(int character) noexcept;
bool IsXidStart(int character) noexcept;
bool IsXidContinue(int character) noexcept;

class CharacterCategoryMap {
private:
	std::vector<unsigned char> dense;
public:
	CharacterCategoryMap();
	CharacterCategory CategoryFor(int character) const noexcept {
		if (static_cast<size_t>(character) < dense.size()) {
			return static_cast<CharacterCategory>(dense[character]);
		} else {
			// binary search through ranges
			return CategoriseCharacter(character);
		}
	}
	int Size() const noexcept;
	void Optimize(int countCharacters);
};

}

#endif


================================================
FILE: Libraries/scintilla/src/CharacterType.cxx
================================================
// Scintilla source code edit control
/** @file CharacterType.cxx
 ** Tests for character type and case-insensitive comparisons.
 **/
// Copyright 1998-2010 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#include <cstdlib>
#include <cassert>

#include "CharacterType.h"

using namespace Scintilla::Internal;

namespace Scintilla::Internal {

int CompareCaseInsensitive(const char *a, const char *b) noexcept {
	while (*a && *b) {
		if (*a != *b) {
			const char upperA = MakeUpperCase(*a);
			const char upperB = MakeUpperCase(*b);
			if (upperA != upperB)
				return upperA - upperB;
		}
		a++;
		b++;
	}
	// Either *a or *b is nul
	return *a - *b;
}

int CompareNCaseInsensitive(const char *a, const char *b, size_t len) noexcept {
	while (*a && *b && len) {
		if (*a != *b) {
			const char upperA = MakeUpperCase(*a);
			const char upperB = MakeUpperCase(*b);
			if (upperA != upperB)
				return upperA - upperB;
		}
		a++;
		b++;
		len--;
	}
	if (len == 0)
		return 0;
	else
		// Either *a or *b is nul
		return *a - *b;
}

}


================================================
FILE: Libraries/scintilla/src/CharacterType.h
================================================
// Scintilla source code edit control
/** @file CharacterType.h
 ** Tests for character type and case-insensitive comparisons.
 **/
// Copyright 2007 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#ifndef CHARACTERTYPE_H
#define CHARACTERTYPE_H

namespace Scintilla::Internal {

// Functions for classifying characters

/**
 * Check if a character is a space.
 * This is ASCII specific but is safe with chars >= 0x80.
 */
constexpr bool IsASpace(int ch) noexcept {
    return (ch == ' ') || ((ch >= 0x09) && (ch <= 0x0d));
}

constexpr bool IsSpaceOrTab(int ch) noexcept {
	return (ch == ' ') || (ch == '\t');
}

constexpr bool IsControl(int ch) noexcept {
	return ((ch >= 0) && (ch <= 0x1F)) || (ch == 0x7F);
}

constexpr bool IsEOLCharacter(int ch) noexcept {
	return ch == '\r' || ch == '\n';
}

constexpr bool IsBreakSpace(int ch) noexcept {
	// used for text breaking, treat C0 control character as space.
	// by default C0 control character is handled as special representation,
	// so not appears in normal text. 0x7F DEL is omitted to simplify the code.
	return ch >= 0 && ch <= ' ';
}

constexpr bool IsADigit(int ch) noexcept {
	return (ch >= '0') && (ch <= '9');
}

constexpr bool IsADigit(int ch, int base) noexcept {
	if (base <= 10) {
		return (ch >= '0') && (ch < '0' + base);
	} else {
		return ((ch >= '0') && (ch <= '9')) ||
		       ((ch >= 'A') && (ch < 'A' + base - 10)) ||
		       ((ch >= 'a') && (ch < 'a' + base - 10));
	}
}

constexpr bool IsASCII(int ch) noexcept {
	return (ch >= 0) && (ch < 0x80);
}

constexpr bool IsLowerCase(int ch) noexcept {
	return (ch >= 'a') && (ch <= 'z');
}

constexpr bool IsUpperCase(int ch) noexcept {
	return (ch >= 'A') && (ch <= 'Z');
}

constexpr bool IsUpperOrLowerCase(int ch) noexcept {
	return IsUpperCase(ch) || IsLowerCase(ch);
}

constexpr bool IsAlphaNumeric(int ch) noexcept {
	return
		((ch >= '0') && (ch <= '9')) ||
		((ch >= 'a') && (ch <= 'z')) ||
		((ch >= 'A') && (ch <= 'Z'));
}

constexpr bool IsPunctuation(int ch) noexcept {
	switch (ch) {
	case '!':
	case '"':
	case '#':
	case '$':
	case '%':
	case '&':
	case '\'':
	case '(':
	case ')':
	case '*':
	case '+':
	case ',':
	case '-':
	case '.':
	case '/':
	case ':':
	case ';':
	case '<':
	case '=':
	case '>':
	case '?':
	case '@':
	case '[':
	case '\\':
	case ']':
	case '^':
	case '_':
	case '`':
	case '{':
	case '|':
	case '}':
	case '~':
		return true;
	default:
		return false;
	}
}

// Simple case functions for ASCII supersets.

template <typename T>
constexpr T MakeUpperCase(T ch) noexcept {
	if (ch < 'a' || ch > 'z')
		return ch;
	else
		return ch - 'a' + 'A';
}

template <typename T>
constexpr T MakeLowerCase(T ch) noexcept {
	if (ch < 'A' || ch > 'Z')
		return ch;
	else
		return ch - 'A' + 'a';
}

int CompareCaseInsensitive(const char *a, const char *b) noexcept;
int CompareNCaseInsensitive(const char *a, const char *b, size_t len) noexcept;

}

#endif


================================================
FILE: Libraries/scintilla/src/ContractionState.cxx
================================================
// Scintilla source code edit control
/** @file ContractionState.cxx
 ** Manages visibility of lines for folding and wrapping.
 **/
// Copyright 1998-2007 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#include <cstddef>
#include <cassert>
#include <cstring>

#include <stdexcept>
#include <string_view>
#include <vector>
#include <optional>
#include <algorithm>
#include <memory>

#include "Debugging.h"

#include "Position.h"
#include "UniqueString.h"
#include "SplitVector.h"
#include "Partitioning.h"
#include "RunStyles.h"
#include "SparseVector.h"
#include "ContractionState.h"

using namespace Scintilla::Internal;

namespace {

template <typename LINE>
class ContractionState final : public IContractionState {
	// These contain 1 element for every document line.
	std::unique_ptr<RunStyles<LINE, char>> visible;
	std::unique_ptr<RunStyles<LINE, char>> expanded;
	std::unique_ptr<RunStyles<LINE, int>> heights;
	std::unique_ptr<SparseVector<UniqueString>> foldDisplayTexts;
	std::unique_ptr<Partitioning<LINE>> displayLines;
	LINE linesInDocument;

	void EnsureData();

	bool OneToOne() const noexcept {
		// True when each document line is exactly one display line so need for
		// complex data structures.
		return visible == nullptr;
	}

	void InsertLine(Sci::Line lineDoc);
	void DeleteLine(Sci::Line lineDoc);

	// line_cast(): cast Sci::Line to either 32-bit or 64-bit value
	// This avoids warnings from Visual C++ Code Analysis and shortens code
	static constexpr LINE line_cast(Sci::Line line) noexcept {
		return static_cast<LINE>(line);
	}

public:
	ContractionState() noexcept;

	void Clear() noexcept override;

	Sci::Line LinesInDoc() const noexcept override;
	Sci::Line LinesDisplayed() const noexcept override;
	Sci::Line DisplayFromDoc(Sci::Line lineDoc) const noexcept override;
	Sci::Line DisplayFromDocSub(Sci::Line lineDoc, Sci::Line lineSub) const noexcept override;
	Sci::Line DisplayLastFromDoc(Sci::Line lineDoc) const noexcept override;
	Sci::Line DocFromDisplay(Sci::Line lineDisplay) const noexcept override;

	void InsertLines(Sci::Line lineDoc, Sci::Line lineCount) override;
	void DeleteLines(Sci::Line lineDoc, Sci::Line lineCount) override;

	bool GetVisible(Sci::Line lineDoc) const noexcept override;
	bool SetVisible(Sci::Line lineDocStart, Sci::Line lineDocEnd, bool isVisible) override;
	bool HiddenLines() const noexcept override;

	const char *GetFoldDisplayText(Sci::Line lineDoc) const noexcept override;
	bool SetFoldDisplayText(Sci::Line lineDoc, const char *text) override;

	bool GetExpanded(Sci::Line lineDoc) const noexcept override;
	bool SetExpanded(Sci::Line lineDoc, bool isExpanded) override;
	bool ExpandAll() override;
	Sci::Line ContractedNext(Sci::Line lineDocStart) const noexcept override;

	int GetHeight(Sci::Line lineDoc) const noexcept override;
	bool SetHeight(Sci::Line lineDoc, int height) override;

	void ShowAll() noexcept override;

	void Check() const noexcept;
};

template <typename LINE>
ContractionState<LINE>::ContractionState() noexcept : linesInDocument(1) {
}

template <typename LINE>
void ContractionState<LINE>::EnsureData() {
	if (OneToOne()) {
		visible = std::make_unique<RunStyles<LINE, char>>();
		expanded = std::make_unique<RunStyles<LINE, char>>();
		heights = std::make_unique<RunStyles<LINE, int>>();
		foldDisplayTexts = std::make_unique<SparseVector<UniqueString>>();
		displayLines = std::make_unique<Partitioning<LINE>>(4);
		InsertLines(0, linesInDocument);
	}
}

template <typename LINE>
void ContractionState<LINE>::InsertLine(Sci::Line lineDoc) {
	if (OneToOne()) {
		linesInDocument++;
	} else {
		const LINE lineDocCast = line_cast(lineDoc);
		visible->InsertSpace(lineDocCast, 1);
		visible->SetValueAt(lineDocCast, 1);
		expanded->InsertSpace(lineDocCast, 1);
		expanded->SetValueAt(lineDocCast, 1);
		heights->InsertSpace(lineDocCast, 1);
		heights->SetValueAt(lineDocCast, 1);
		foldDisplayTexts->InsertSpace(lineDocCast, 1);
		foldDisplayTexts->SetValueAt(lineDocCast, nullptr);
		const Sci::Line lineDisplay = DisplayFromDoc(lineDoc);
		displayLines->InsertPartition(lineDocCast, line_cast(lineDisplay));
		displayLines->InsertText(lineDocCast, 1);
	}
}

template <typename LINE>
void ContractionState<LINE>::DeleteLine(Sci::Line lineDoc) {
	if (OneToOne()) {
		linesInDocument--;
	} else {
		const LINE lineDocCast = line_cast(lineDoc);
		if (GetVisible(lineDoc)) {
			displayLines->InsertText(lineDocCast, -heights->ValueAt(lineDocCast));
		}
		displayLines->RemovePartition(lineDocCast);
		visible->DeleteRange(lineDocCast, 1);
		expanded->DeleteRange(lineDocCast, 1);
		heights->DeleteRange(lineDocCast, 1);
		foldDisplayTexts->DeletePosition(lineDocCast);
	}
}

template <typename LINE>
void ContractionState<LINE>::Clear() noexcept {
	visible.reset();
	expanded.reset();
	heights.reset();
	foldDisplayTexts.reset();
	displayLines.reset();
	linesInDocument = 1;
}

template <typename LINE>
Sci::Line ContractionState<LINE>::LinesInDoc() const noexcept {
	if (OneToOne()) {
		return linesInDocument;
	} else {
		return displayLines->Partitions() - 1;
	}
}

template <typename LINE>
Sci::Line ContractionState<LINE>::LinesDisplayed() const noexcept {
	if (OneToOne()) {
		return linesInDocument;
	} else {
		return displayLines->PositionFromPartition(line_cast(LinesInDoc()));
	}
}

template <typename LINE>
Sci::Line ContractionState<LINE>::DisplayFromDoc(Sci::Line lineDoc) const noexcept {
	if (OneToOne()) {
		return (lineDoc <= linesInDocument) ? lineDoc : linesInDocument;
	} else {
		if (lineDoc > displayLines->Partitions())
			lineDoc = displayLines->Partitions();
		return displayLines->PositionFromPartition(line_cast(lineDoc));
	}
}

template <typename LINE>
Sci::Line ContractionState<LINE>::DisplayFromDocSub(Sci::Line lineDoc, Sci::Line lineSub) const noexcept {
	return DisplayFromDoc(lineDoc) +
		std::min(lineSub, static_cast<Sci::Line>(GetHeight(lineDoc) - 1));
}

template <typename LINE>
Sci::Line ContractionState<LINE>::DisplayLastFromDoc(Sci::Line lineDoc) const noexcept {
	return DisplayFromDoc(lineDoc) + GetHeight(lineDoc) - 1;
}

template <typename LINE>
Sci::Line ContractionState<LINE>::DocFromDisplay(Sci::Line lineDisplay) const noexcept {
	if (OneToOne()) {
		return lineDisplay;
	} else {
		if (lineDisplay < 0) {
			return 0;
		}
		if (lineDisplay > LinesDisplayed()) {
			return displayLines->PartitionFromPosition(line_cast(LinesDisplayed()));
		}
		const Sci::Line lineDoc = displayLines->PartitionFromPosition(line_cast(lineDisplay));
		PLATFORM_ASSERT(GetVisible(lineDoc));
		return lineDoc;
	}
}

template <typename LINE>
void ContractionState<LINE>::InsertLines(Sci::Line lineDoc, Sci::Line lineCount) {
	if (OneToOne()) {
		linesInDocument += line_cast(lineCount);
	} else {
		for (Sci::Line l = 0; l < lineCount; l++) {
			InsertLine(lineDoc + l);
		}
	}
	Check();
}

template <typename LINE>
void ContractionState<LINE>::DeleteLines(Sci::Line lineDoc, Sci::Line lineCount) {
	if (OneToOne()) {
		linesInDocument -= line_cast(lineCount);
	} else {
		for (Sci::Line l = 0; l < lineCount; l++) {
			DeleteLine(lineDoc);
		}
	}
	Check();
}

template <typename LINE>
bool ContractionState<LINE>::GetVisible(Sci::Line lineDoc) const noexcept {
	if (OneToOne()) {
		return true;
	} else {
		if (lineDoc >= visible->Length())
			return true;
		return visible->ValueAt(line_cast(lineDoc)) == 1;
	}
}

template <typename LINE>
bool ContractionState<LINE>::SetVisible(Sci::Line lineDocStart, Sci::Line lineDocEnd, bool isVisible) {
	if (OneToOne() && isVisible) {
		return false;
	} else {
		EnsureData();
		Check();
		if ((lineDocStart <= lineDocEnd) && (lineDocStart >= 0) && (lineDocEnd < LinesInDoc())) {
			bool changed = false;
			for (Sci::Line line = lineDocStart; line <= lineDocEnd; line++) {
				if (GetVisible(line) != isVisible) {
					changed = true;
					const int heightLine = heights->ValueAt(line_cast(line));
					const int difference = isVisible ? heightLine : -heightLine;
					displayLines->InsertText(line_cast(line), difference);
				}
			}
			if (changed) {
				visible->FillRange(line_cast(lineDocStart), isVisible ? 1 : 0,
					line_cast(lineDocEnd - lineDocStart) + 1);
			}
			Check();
			return changed;
		} else {
			return false;
		}
	}
}

template <typename LINE>
bool ContractionState<LINE>::HiddenLines() const noexcept {
	if (OneToOne()) {
		return false;
	} else {
		return !visible->AllSameAs(1);
	}
}

template <typename LINE>
const char *ContractionState<LINE>::GetFoldDisplayText(Sci::Line lineDoc) const noexcept {
	Check();
	return foldDisplayTexts->ValueAt(lineDoc).get();
}

template <typename LINE>
bool ContractionState<LINE>::SetFoldDisplayText(Sci::Line lineDoc, const char *text) {
	EnsureData();
	const char *foldText = foldDisplayTexts->ValueAt(lineDoc).get();
	if (!foldText || !text || 0 != strcmp(text, foldText)) {
		UniqueString uns = IsNullOrEmpty(text) ? UniqueString() : UniqueStringCopy(text);
		foldDisplayTexts->SetValueAt(lineDoc, std::move(uns));
		Check();
		return true;
	} else {
		Check();
		return false;
	}
}

template <typename LINE>
bool ContractionState<LINE>::GetExpanded(Sci::Line lineDoc) const noexcept {
	if (OneToOne()) {
		return true;
	} else {
		Check();
		return expanded->ValueAt(line_cast(lineDoc)) == 1;
	}
}

template <typename LINE>
bool ContractionState<LINE>::SetExpanded(Sci::Line lineDoc, bool isExpanded) {
	if (OneToOne() && isExpanded) {
		return false;
	} else {
		EnsureData();
		if (isExpanded != (expanded->ValueAt(line_cast(lineDoc)) == 1)) {
			expanded->SetValueAt(line_cast(lineDoc), isExpanded ? 1 : 0);
			Check();
			return true;
		} else {
			Check();
			return false;
		}
	}
}

template <typename LINE>
bool ContractionState<LINE>::ExpandAll() {
	if (OneToOne()) {
		return false;
	} else {
		const LINE lines = expanded->Length();
		const bool changed = expanded->FillRange(0, 1, lines).changed;
		Check();
		return changed;
	}
}

template <typename LINE>
Sci::Line ContractionState<LINE>::ContractedNext(Sci::Line lineDocStart) const noexcept {
	if (OneToOne()) {
		return -1;
	} else {
		Check();
		if (!expanded->ValueAt(line_cast(lineDocStart))) {
			return lineDocStart;
		} else {
			const Sci::Line lineDocNextChange = expanded->EndRun(line_cast(lineDocStart));
			if (lineDocNextChange < LinesInDoc())
				return lineDocNextChange;
			else
				return -1;
		}
	}
}

template <typename LINE>
int ContractionState<LINE>::GetHeight(Sci::Line lineDoc) const noexcept {
	if (OneToOne()) {
		return 1;
	} else {
		return heights->ValueAt(line_cast(lineDoc));
	}
}

// Set the number of display lines needed for this line.
// Return true if this is a change.
template <typename LINE>
bool ContractionState<LINE>::SetHeight(Sci::Line lineDoc, int height) {
	if (OneToOne() && (height == 1)) {
		return false;
	} else if (lineDoc < LinesInDoc()) {
		EnsureData();
		if (GetHeight(lineDoc) != height) {
			if (GetVisible(lineDoc)) {
				displayLines->InsertText(line_cast(lineDoc), height - GetHeight(lineDoc));
			}
			heights->SetValueAt(line_cast(lineDoc), height);
			Check();
			return true;
		} else {
			Check();
			return false;
		}
	} else {
		return false;
	}
}

template <typename LINE>
void ContractionState<LINE>::ShowAll() noexcept {
	const LINE lines = line_cast(LinesInDoc());
	Clear();
	linesInDocument = lines;
}

// Debugging checks

template <typename LINE>
void ContractionState<LINE>::Check() const noexcept {
#ifdef CHECK_CORRECTNESS
	for (Sci::Line vline = 0; vline < LinesDisplayed(); vline++) {
		const Sci::Line lineDoc = DocFromDisplay(vline);
		PLATFORM_ASSERT(GetVisible(lineDoc));
	}
	for (Sci::Line lineDoc = 0; lineDoc < LinesInDoc(); lineDoc++) {
		const Sci::Line displayThis = DisplayFromDoc(lineDoc);
		const Sci::Line displayNext = DisplayFromDoc(lineDoc + 1);
		const Sci::Line height = displayNext - displayThis;
		PLATFORM_ASSERT(height >= 0);
		if (GetVisible(lineDoc)) {
			PLATFORM_ASSERT(GetHeight(lineDoc) == height);
		} else {
			PLATFORM_ASSERT(0 == height);
		}
	}
#endif
}

}

namespace Scintilla::Internal {

std::unique_ptr<IContractionState> ContractionStateCreate(bool largeDocument) {
	if (largeDocument)
		return std::make_unique<ContractionState<Sci::Line>>();
	else
		return std::make_unique<ContractionState<int>>();
}

}


================================================
FILE: Libraries/scintilla/src/ContractionState.h
================================================
// Scintilla source code edit control
/** @file ContractionState.h
 ** Manages visibility of lines for folding and wrapping.
 **/
// Copyright 1998-2007 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#ifndef CONTRACTIONSTATE_H
#define CONTRACTIONSTATE_H

namespace Scintilla::Internal {

/**
*/
class IContractionState {
public:
	virtual ~IContractionState() {};

	virtual void Clear()=0;

	virtual Sci::Line LinesInDoc() const noexcept=0;
	virtual Sci::Line LinesDisplayed() const noexcept=0;
	virtual Sci::Line DisplayFromDoc(Sci::Line lineDoc) const noexcept=0;
	virtual Sci::Line DisplayFromDocSub(Sci::Line lineDoc, Sci::Line lineSub) const noexcept=0;
	virtual Sci::Line DisplayLastFromDoc(Sci::Line lineDoc) const noexcept=0;
	virtual Sci::Line DocFromDisplay(Sci::Line lineDisplay) const noexcept=0;

	virtual void InsertLines(Sci::Line lineDoc, Sci::Line lineCount)=0;
	virtual void DeleteLines(Sci::Line lineDoc, Sci::Line lineCount)=0;

	virtual bool GetVisible(Sci::Line lineDoc) const noexcept=0;
	virtual bool SetVisible(Sci::Line lineDocStart, Sci::Line lineDocEnd, bool isVisible)=0;
	virtual bool HiddenLines() const noexcept=0;

	virtual const char *GetFoldDisplayText(Sci::Line lineDoc) const noexcept=0;
	virtual bool SetFoldDisplayText(Sci::Line lineDoc, const char *text)=0;

	virtual bool GetExpanded(Sci::Line lineDoc) const noexcept=0;
	virtual bool SetExpanded(Sci::Line lineDoc, bool isExpanded)=0;
	virtual bool ExpandAll()=0;
	virtual Sci::Line ContractedNext(Sci::Line lineDocStart) const noexcept =0;

	virtual int GetHeight(Sci::Line lineDoc) const noexcept=0;
	virtual bool SetHeight(Sci::Line lineDoc, int height)=0;

	virtual void ShowAll() noexcept=0;
};

std::unique_ptr<IContractionState> ContractionStateCreate(bool largeDocument);

}

#endif


================================================
FILE: Libraries/scintilla/src/DBCS.cxx
================================================
// Scintilla source code edit control
/** @file DBCS.cxx
 ** Functions to handle DBCS double byte encodings like Shift-JIS.
 **/
// Copyright 2017 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#include <cstdint>

#include <array>
#include <map>

#include "DBCS.h"

using namespace Scintilla::Internal;

namespace Scintilla::Internal {

// Silence 'magic' number use since the set of DBCS lead and trail bytes differ
// between encodings and would require many constant declarations that would just
// obscure the behaviour.

// NOLINTBEGIN(*-magic-numbers)

bool DBCSIsLeadByte(int codePage, char ch) noexcept {
	// Byte ranges found in Wikipedia articles with relevant search strings in each case
	const unsigned char uch = ch;
	switch (codePage) {
	case cp932:
		// Shift_jis
		return ((uch >= 0x81) && (uch <= 0x9F)) ||
			((uch >= 0xE0) && (uch <= 0xFC));
		// Lead bytes F0 to FC may be a Microsoft addition.
	case cp936:
		// GBK
		return (uch >= 0x81) && (uch <= 0xFE);
	case cp949:
		// Korean Wansung KS C-5601-1987
		return (uch >= 0x81) && (uch <= 0xFE);
	case cp950:
		// Big5
		return (uch >= 0x81) && (uch <= 0xFE);
	case cp1361:
		// Korean Johab KS C-5601-1992
		return
			((uch >= 0x84) && (uch <= 0xD3)) ||
			((uch >= 0xD8) && (uch <= 0xDE)) ||
			((uch >= 0xE0) && (uch <= 0xF9));
	default:
		break;
	}
	return false;
}

bool DBCSIsTrailByte(int codePage, char ch) noexcept {
	const unsigned char trail = ch;
	switch (codePage) {
	case cp932:
		// Shift_jis
		return (trail != 0x7F) &&
			((trail >= 0x40) && (trail <= 0xFC));
	case cp936:
		// GBK
		return (trail != 0x7F) &&
			((trail >= 0x40) && (trail <= 0xFE));
	case cp949:
		// Korean Wansung KS C-5601-1987
		return
			((trail >= 0x41) && (trail <= 0x5A)) ||
			((trail >= 0x61) && (trail <= 0x7A)) ||
			((trail >= 0x81) && (trail <= 0xFE));
	case cp950:
		// Big5
		return
			((trail >= 0x40) && (trail <= 0x7E)) ||
			((trail >= 0xA1) && (trail <= 0xFE));
	case cp1361:
		// Korean Johab KS C-5601-1992
		return
			((trail >= 0x31) && (trail <= 0x7E)) ||
			((trail >= 0x81) && (trail <= 0xFE));
	default:
		break;
	}
	return false;
}

bool IsDBCSValidSingleByte(int codePage, int ch) noexcept {
	switch (codePage) {
	case cp932:
		return ch == 0x80
			|| (ch >= 0xA0 && ch <= 0xDF)
			|| (ch >= 0xFD);

	default:
		return false;
	}
}

// NOLINTEND(*-magic-numbers)

using CodePageToFoldMap = std::map<int, FoldMap>;
CodePageToFoldMap cpToFoldMap;

bool DBCSHasFoldMap(int codePage) {
	const CodePageToFoldMap::const_iterator it = cpToFoldMap.find(codePage);
	return it != cpToFoldMap.end();
}

void DBCSSetFoldMap(int codePage, const FoldMap &foldMap) {
	cpToFoldMap[codePage] = foldMap;
}

FoldMap *DBCSGetMutableFoldMap(int codePage) {
	// Constructs if needed
	return &cpToFoldMap[codePage];
}

const FoldMap *DBCSGetFoldMap(int codePage) {
	return &cpToFoldMap[codePage];
}

}


================================================
FILE: Libraries/scintilla/src/DBCS.h
================================================
// Scintilla source code edit control
/** @file DBCS.h
 ** Functions to handle DBCS double byte encodings like Shift-JIS.
 **/
// Copyright 2017 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#ifndef DBCS_H
#define DBCS_H

namespace Scintilla::Internal {

constexpr int cp932 = 932;
constexpr int cp936 = 936;
constexpr int cp949 = 949;
constexpr int cp950 = 950;
constexpr int cp1361 = 1361;

constexpr bool IsDBCSCodePage(int codePage) noexcept {
	return codePage == cp932
	       || codePage == cp936
	       || codePage == cp949
	       || codePage == cp950
	       || codePage == cp1361;
}

bool DBCSIsLeadByte(int codePage, char ch) noexcept;
bool DBCSIsTrailByte(int codePage, char ch) noexcept;
bool IsDBCSValidSingleByte(int codePage, int ch) noexcept;

// Calculate a number from a DBCS byte pair that can be used to index into an array or map.
// Should only be called with genuine DBCS character pairs which means that ch1 has top bit set.
constexpr uint16_t DBCSIndex(char ch1, char ch2) noexcept {
	const unsigned char uch1 = ch1 & 0x7F;
	const unsigned char uch2 = ch2;
	return (uch1 << 8) | uch2;
}

struct DBCSPair {
	char chars[2];
};
using FoldMap = std::array<DBCSPair, 0x8000>;

bool DBCSHasFoldMap(int codePage);
void DBCSSetFoldMap(int codePage, const FoldMap &foldMap);
FoldMap *DBCSGetMutableFoldMap(int codePage);
const FoldMap *DBCSGetFoldMap(int codePage);

}

#endif


================================================
FILE: Libraries/scintilla/src/Debugging.h
================================================
// Scintilla source code edit control
/** @file Debugging.h
 ** Assert and debug trace functions.
 ** Implemented in each platform layer.
 **/
// Copyright 1998-2009 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#ifndef DEBUGGING_H
#define DEBUGGING_H

namespace Scintilla::Internal {

#if defined(__clang__)
# if __has_feature(attribute_analyzer_noreturn)
#  define CLANG_ANALYZER_NORETURN __attribute__((analyzer_noreturn))
# else
#  define CLANG_ANALYZER_NORETURN
# endif
#else
# define CLANG_ANALYZER_NORETURN
#endif

/**
 * Platform namespace used to segregate debugging functions.
 */
namespace Platform {

void DebugDisplay(const char *s) noexcept;
void DebugPrintf(const char *format, ...) noexcept;
bool ShowAssertionPopUps(bool assertionPopUps_) noexcept;
void Assert(const char *c, const char *file, int line) noexcept CLANG_ANALYZER_NORETURN;

}

#ifdef  NDEBUG
#define PLATFORM_ASSERT(c) ((void)0)
#else
#define PLATFORM_ASSERT(c) ((c) ? (void)(0) : Scintilla::Internal::Platform::Assert(#c, __FILE__, __LINE__))
#endif

}

#endif


================================================
FILE: Libraries/scintilla/src/Decoration.cxx
================================================
/** @file Decoration.cxx
 ** Visual elements added over text.
 **/
// Copyright 1998-2007 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#include <cstddef>
#include <cstdlib>
#include <cstdint>
#include <cstring>
#include <cstdio>
#include <cstdarg>

#include <stdexcept>
#include <string_view>
#include <vector>
#include <optional>
#include <algorithm>
#include <memory>

#include "ScintillaTypes.h"

#include "Debugging.h"

#include "Position.h"
#include "SplitVector.h"
#include "Partitioning.h"
#include "RunStyles.h"
#include "Decoration.h"

using namespace Scintilla::Internal;

namespace {

template <typename POS>
class Decoration : public IDecoration {
	int indicator;

	// pos_cast(): cast Sci::Position to either 32-bit or 64-bit value
	// This avoids warnings from Visual C++ Code Analysis and shortens code
	static constexpr POS pos_cast(Sci::Position pos) noexcept {
		return static_cast<POS>(pos);
	}

public:
	RunStyles<POS, int> rs;

	explicit Decoration(int indicator_) : indicator(indicator_) {
	}

	bool Empty() const noexcept override {
		return (rs.Runs() == 1) && (rs.AllSameAs(0));
	}
	int Indicator() const noexcept override {
		return indicator;
	}
	Sci::Position Length() const noexcept override {
		return rs.Length();
	}
	int ValueAt(Sci::Position position) const noexcept override {
		return rs.ValueAt(pos_cast(position));
	}
	Sci::Position StartRun(Sci::Position position) const noexcept override {
		return rs.StartRun(pos_cast(position));
	}
	Sci::Position EndRun(Sci::Position position) const noexcept override {
		return rs.EndRun(pos_cast(position));
	}
	void SetValueAt(Sci::Position position, int value) override {
		rs.SetValueAt(pos_cast(position), value);
	}
	void InsertSpace(Sci::Position position, Sci::Position insertLength) override {
		rs.InsertSpace(pos_cast(position), pos_cast(insertLength));
	}
	Sci::Position Runs() const noexcept override {
		return rs.Runs();
	}
};

template <typename POS>
class DecorationList : public IDecorationList {
	int currentIndicator;
	int currentValue;
	Decoration<POS> *current;	// Non-owning. Cached so FillRange doesn't have to search for each call.
	Sci::Position lengthDocument;
	// Ordered by indicator
	std::vector<std::unique_ptr<Decoration<POS>>> decorationList;
	std::vector<const IDecoration*> decorationView;	// Read-only view of decorationList
	bool clickNotified;

	Decoration<POS> *DecorationFromIndicator(int indicator) noexcept;
	Decoration<POS> *Create(int indicator, Sci::Position length);
	void Delete(int indicator);
	void DeleteAnyEmpty();
	void SetView();

	// pos_cast(): cast Sci::Position to either 32-bit or 64-bit value
	// This avoids warnings from Visual C++ Code Analysis and shortens code
	static constexpr POS pos_cast(Sci::Position pos) noexcept {
		return static_cast<POS>(pos);
	}

public:

	DecorationList();

	const std::vector<const IDecoration*> &View() const noexcept override {
		return decorationView;
	}

	void SetCurrentIndicator(int indicator) override;
	int GetCurrentIndicator() const noexcept override { return currentIndicator; }

	void SetCurrentValue(int value) noexcept override;
	int GetCurrentValue() const noexcept override { return currentValue; }

	// Returns changed=true if some values may have changed
	FillResult<Sci::Position> FillRange(Sci::Position position, int value, Sci::Position fillLength) override;

	void InsertSpace(Sci::Position position, Sci::Position insertLength) override;
	void DeleteRange(Sci::Position position, Sci::Position deleteLength) override;

	void DeleteLexerDecorations() override;

	int AllOnFor(Sci::Position position) const noexcept override;
	int ValueAt(int indicator, Sci::Position position) noexcept override;
	Sci::Position Start(int indicator, Sci::Position position) noexcept override;
	Sci::Position End(int indicator, Sci::Position position) noexcept override;

	bool ClickNotified() const noexcept override {
		return clickNotified;
	}
	void SetClickNotified(bool notified) noexcept override {
		clickNotified = notified;
	}
};

template <typename POS>
DecorationList<POS>::DecorationList() : currentIndicator(0), currentValue(1), current(nullptr),
	lengthDocument(0), clickNotified(false) {
}

template <typename POS>
Decoration<POS> *DecorationList<POS>::DecorationFromIndicator(int indicator) noexcept {
	for (const std::unique_ptr<Decoration<POS>> &deco : decorationList) {
		if (deco->Indicator() == indicator) {
			return deco.get();
		}
	}
	return nullptr;
}

template <typename POS>
Decoration<POS> *DecorationList<POS>::Create(int indicator, Sci::Position length) {
	currentIndicator = indicator;
	std::unique_ptr<Decoration<POS>> decoNew = std::make_unique<Decoration<POS>>(indicator);
	decoNew->rs.InsertSpace(0, pos_cast(length));

	typename std::vector<std::unique_ptr<Decoration<POS>>>::iterator it = std::lower_bound(
		decorationList.begin(), decorationList.end(), decoNew,
		[](const std::unique_ptr<Decoration<POS>> &a, const std::unique_ptr<Decoration<POS>> &b) noexcept {
		return a->Indicator() < b->Indicator();
	});
	typename std::vector<std::unique_ptr<Decoration<POS>>>::iterator itAdded =
		decorationList.insert(it, std::move(decoNew));

	SetView();

	return itAdded->get();
}

template <typename POS>
void DecorationList<POS>::Delete(int indicator) {
	decorationList.erase(std::remove_if(decorationList.begin(), decorationList.end(),
		[indicator](const std::unique_ptr<Decoration<POS>> &deco) noexcept {
		return deco->Indicator() == indicator;
	}), decorationList.end());
	current = nullptr;
	SetView();
}

template <typename POS>
void DecorationList<POS>::SetCurrentIndicator(int indicator) {
	currentIndicator = indicator;
	current = DecorationFromIndicator(indicator);
	currentValue = 1;
}

template <typename POS>
void DecorationList<POS>::SetCurrentValue(int value) noexcept {
	currentValue = value ? value : 1;
}

template <typename POS>
FillResult<Sci::Position> DecorationList<POS>::FillRange(Sci::Position position, int value, Sci::Position fillLength) {
	if (!current) {
		current = DecorationFromIndicator(currentIndicator);
		if (!current) {
			current = Create(currentIndicator, lengthDocument);
		}
	}
	// Converting result from POS to Sci::Position as callers not polymorphic.
	const FillResult<POS> frInPOS = current->rs.FillRange(pos_cast(position), value, pos_cast(fillLength));
	const FillResult<Sci::Position> fr { frInPOS.changed, frInPOS.position, frInPOS.fillLength };
	if (current->Empty()) {
		Delete(currentIndicator);
	}
	return fr;
}

template <typename POS>
void DecorationList<POS>::InsertSpace(Sci::Position position, Sci::Position insertLength) {
	const bool atEnd = position == lengthDocument;
	lengthDocument += insertLength;
	for (const std::unique_ptr<Decoration<POS>> &deco : decorationList) {
		deco->rs.InsertSpace(pos_cast(position), pos_cast(insertLength));
		if (atEnd) {
			deco->rs.FillRange(pos_cast(position), 0, pos_cast(insertLength));
		}
	}
}

template <typename POS>
void DecorationList<POS>::DeleteRange(Sci::Position position, Sci::Position deleteLength) {
	lengthDocument -= deleteLength;
	for (const std::unique_ptr<Decoration<POS>> &deco : decorationList) {
		deco->rs.DeleteRange(pos_cast(position), pos_cast(deleteLength));
	}
	DeleteAnyEmpty();
	if (decorationList.size() != decorationView.size()) {
		// One or more empty decorations deleted so update view.
		current = nullptr;
		SetView();
	}
}

template <typename POS>
void DecorationList<POS>::DeleteLexerDecorations() {
	decorationList.erase(std::remove_if(decorationList.begin(), decorationList.end(),
		[](const std::unique_ptr<Decoration<POS>> &deco) noexcept {
		return deco->Indicator() < static_cast<int>(Scintilla::IndicatorNumbers::Container);
	}), decorationList.end());
	current = nullptr;
	SetView();
}

template <typename POS>
void DecorationList<POS>::DeleteAnyEmpty() {
	if (lengthDocument == 0) {
		decorationList.clear();
	} else {
		decorationList.erase(std::remove_if(decorationList.begin(), decorationList.end(),
			[](const std::unique_ptr<Decoration<POS>> &deco) noexcept {
			return deco->Empty();
		}), decorationList.end());
	}
}

template <typename POS>
void DecorationList<POS>::SetView() {
	decorationView.clear();
	for (const std::unique_ptr<Decoration<POS>> &deco : decorationList) {
		decorationView.push_back(deco.get());
	}
}

template <typename POS>
int DecorationList<POS>::AllOnFor(Sci::Position position) const noexcept {
	int mask = 0;
	for (const std::unique_ptr<Decoration<POS>> &deco : decorationList) {
		if (deco->rs.ValueAt(pos_cast(position))) {
			if (deco->Indicator() < static_cast<int>(Scintilla::IndicatorNumbers::Ime)) {
				mask |= 1u << deco->Indicator();
			}
		}
	}
	return mask;
}

template <typename POS>
int DecorationList<POS>::ValueAt(int indicator, Sci::Position position) noexcept {
	const Decoration<POS> *deco = DecorationFromIndicator(indicator);
	if (deco) {
		return deco->rs.ValueAt(pos_cast(position));
	}
	return 0;
}

template <typename POS>
Sci::Position DecorationList<POS>::Start(int indicator, Sci::Position position) noexcept {
	const Decoration<POS> *deco = DecorationFromIndicator(indicator);
	if (deco) {
		return deco->rs.StartRun(pos_cast(position));
	}
	return 0;
}

template <typename POS>
Sci::Position DecorationList<POS>::End(int indicator, Sci::Position position) noexcept {
	const Decoration<POS> *deco = DecorationFromIndicator(indicator);
	if (deco) {
		return deco->rs.EndRun(pos_cast(position));
	}
	return 0;
}

}

namespace Scintilla::Internal {

std::unique_ptr<IDecoration> DecorationCreate(bool largeDocument, int indicator) {
	if (largeDocument)
		return std::make_unique<Decoration<Sci::Position>>(indicator);
	else
		return std::make_unique<Decoration<int>>(indicator);
}

std::unique_ptr<IDecorationList> DecorationListCreate(bool largeDocument) {
	if (largeDocument)
		return std::make_unique<DecorationList<Sci::Position>>();
	else
		return std::make_unique<DecorationList<int>>();
}

}



================================================
FILE: Libraries/scintilla/src/Decoration.h
================================================
/** @file Decoration.h
 ** Visual elements added over text.
 **/
// Copyright 1998-2007 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#ifndef DECORATION_H
#define DECORATION_H

namespace Scintilla::Internal {

class IDecoration {
public:
	virtual ~IDecoration() {}
	virtual bool Empty() const noexcept = 0;
	virtual int Indicator() const noexcept = 0;
	virtual Sci::Position Length() const noexcept = 0;
	virtual int ValueAt(Sci::Position position) const noexcept = 0;
	virtual Sci::Position StartRun(Sci::Position position) const noexcept = 0;
	virtual Sci::Position EndRun(Sci::Position position) const noexcept = 0;
	virtual void SetValueAt(Sci::Position position, int value) = 0;
	virtual void InsertSpace(Sci::Position position, Sci::Position insertLength) = 0;
	virtual Sci::Position Runs() const noexcept = 0;
};

class IDecorationList {
public:
	virtual ~IDecorationList() {}

	virtual const std::vector<const IDecoration*> &View() const noexcept = 0;

	virtual void SetCurrentIndicator(int indicator) = 0;
	virtual int GetCurrentIndicator() const noexcept = 0;

	virtual void SetCurrentValue(int value) noexcept = 0;
	virtual int GetCurrentValue() const noexcept = 0;

	// Returns with changed=true if some values may have changed
	virtual FillResult<Sci::Position> FillRange(Sci::Position position, int value, Sci::Position fillLength) = 0;
	virtual void InsertSpace(Sci::Position position, Sci::Position insertLength) = 0;
	virtual void DeleteRange(Sci::Position position, Sci::Position deleteLength) = 0;
	virtual void DeleteLexerDecorations() = 0;

	virtual int AllOnFor(Sci::Position position) const noexcept = 0;
	virtual int ValueAt(int indicator, Sci::Position position) noexcept = 0;
	virtual Sci::Position Start(int indicator, Sci::Position position) noexcept = 0;
	virtual Sci::Position End(int indicator, Sci::Position position) noexcept = 0;

	virtual bool ClickNotified() const noexcept = 0;
	virtual void SetClickNotified(bool notified) noexcept = 0;
};

std::unique_ptr<IDecoration> DecorationCreate(bool largeDocument, int indicator);

std::unique_ptr<IDecorationList> DecorationListCreate(bool largeDocument);

}

#endif


================================================
FILE: Libraries/scintilla/src/Document.cxx
================================================
// Scintilla source code edit control
/** @file Document.cxx
 ** Text document that handles notifications, DBCS, styling, words and end of line.
 **/
// Copyright 1998-2011 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#include <cstddef>
#include <cstdlib>
#include <cstdint>
#include <cassert>
#include <cstring>
#include <cstdio>
#include <cmath>

#include <stdexcept>
#include <string>
#include <string_view>
#include <vector>
#include <array>
#include <map>
#include <forward_list>
#include <optional>
#include <algorithm>
#include <memory>
#include <chrono>

#ifndef NO_CXX11_REGEX
#include <regex>
#endif

#include "ScintillaTypes.h"
#include "ILoader.h"
#include "ILexer.h"

#include "Debugging.h"

#include "CharacterType.h"
#include "CharacterCategoryMap.h"
#include "Position.h"
#include "SplitVector.h"
#include "Partitioning.h"
#include "RunStyles.h"
#include "CellBuffer.h"
#include "PerLine.h"
#include "CharClassify.h"
#include "Decoration.h"
#include "CaseFolder.h"
#include "Document.h"
#include "RESearch.h"
#include "UniConversion.h"
#include "ElapsedPeriod.h"

using namespace Scintilla;
using namespace Scintilla::Internal;

#if defined(__GNUC__) && !defined(__clang__)
// False warnings from g++ 14.1 for UTF-8 accumulation code where UTF8MaxBytes allocated.
#pragma GCC diagnostic ignored "-Wstringop-overflow"
#endif

LexInterface::LexInterface(Document *pdoc_) noexcept : pdoc(pdoc_), performingStyle(false) {
}

LexInterface::~LexInterface() noexcept = default;

void LexInterface::SetInstance(ILexer5 *instance_) noexcept {
	instance.reset(instance_);
}

void LexInterface::Colourise(Sci::Position start, Sci::Position end) {
	if (pdoc && instance && !performingStyle) {
		// Protect against reentrance, which may occur, for example, when
		// fold points are discovered while performing styling and the folding
		// code looks for child lines which may trigger styling.
		performingStyle = true;

		const Sci::Position lengthDoc = pdoc->Length();
		if (end == -1)
			end = lengthDoc;
		const Sci::Position len = end - start;

		PLATFORM_ASSERT(len >= 0);
		PLATFORM_ASSERT(start + len <= lengthDoc);

		int styleStart = 0;
		if (start > 0)
			styleStart = pdoc->StyleAt(start - 1);

		if (len > 0) {
			instance->Lex(start, len, styleStart, pdoc);
			instance->Fold(start, len, styleStart, pdoc);
		}

		performingStyle = false;
	}
}

LineEndType LexInterface::LineEndTypesSupported() {
	if (instance) {
		return static_cast<LineEndType>(instance->LineEndTypesSupported());
	}
	return LineEndType::Default;
}

bool LexInterface::UseContainerLexing() const noexcept {
	return !instance;
}

ActionDuration::ActionDuration(double duration_, double minDuration_, double maxDuration_) noexcept :
	duration(duration_), minDuration(minDuration_), maxDuration(maxDuration_) {
}

void ActionDuration::AddSample(size_t numberActions, double durationOfActions) noexcept {
	// Only adjust for multiple actions to avoid instability
	if (numberActions < 8)
		return;

	// Alpha value for exponential smoothing.
	// Most recent value contributes 25% to smoothed value.
	constexpr double alpha = 0.25;

	const double durationOne = durationOfActions / static_cast<double>(numberActions);
	duration = std::clamp(alpha * durationOne + (1.0 - alpha) * duration,
		minDuration, maxDuration);
}

double ActionDuration::Duration() const noexcept {
	return duration;
}

size_t ActionDuration::ActionsInAllowedTime(double secondsAllowed) const noexcept {
	return std::lround(secondsAllowed / Duration());
}

const CharacterExtracted characterEmpty(unicodeReplacementChar, 0);
const CharacterExtracted characterBadByte(unicodeReplacementChar, 1);

CharacterExtracted::CharacterExtracted(const unsigned char *charBytes, size_t widthCharBytes) noexcept {
	const int utf8status = UTF8Classify(charBytes, widthCharBytes);
	if (utf8status & UTF8MaskInvalid) {
		// Treat as invalid and use up just one byte
		character = unicodeReplacementChar;
		widthBytes = 1;
	} else {
		character = UnicodeFromUTF8(charBytes);
		widthBytes = utf8status & UTF8MaskWidth;
	}
}

Document::Document(DocumentOption options) :
	refCount(0),
	cb(!FlagSet(options, DocumentOption::StylesNone), FlagSet(options, DocumentOption::TextLarge)),
	endStyled(0),
	styleClock(0),
	enteredModification(0),
	enteredStyling(0),
	enteredReadOnlyCount(0),
	insertionSet(false),
#ifdef _WIN32
	eolMode(EndOfLine::CrLf),
#else
	eolMode(EndOfLine::Lf),
#endif
	dbcsCodePage(CpUtf8),
	lineEndBitSet(LineEndType::Default),
	tabInChars(8),
	indentInChars(0),
	actualIndentInChars(8),
	useTabs(true),
	tabIndents(true),
	backspaceUnindents(false),
	durationStyleOneByte(0.000001, 0.0000001, 0.00001) {

	perLineData[ldMarkers] = std::make_unique<LineMarkers>();
	perLineData[ldLevels] = std::make_unique<LineLevels>();
	perLineData[ldState] = std::make_unique<LineState>();
	perLineData[ldMargin] = std::make_unique<LineAnnotation>();
	perLineData[ldAnnotation] = std::make_unique<LineAnnotation>();
	perLineData[ldEOLAnnotation] = std::make_unique<LineAnnotation>();

	decorations = DecorationListCreate(IsLarge());

	cb.SetPerLine(this);
	cb.SetUTF8Substance(CpUtf8 == dbcsCodePage);
}

Document::~Document() {
	for (const WatcherWithUserData &watcher : watchers) {
		watcher.watcher->NotifyDeleted(this, watcher.userData);
	}
}

// Increase reference count and return its previous value.
int SCI_METHOD Document::AddRef() noexcept {
	return refCount++;
}

// Decrease reference count and return its previous value.
// Delete the document if reference count reaches zero.
int SCI_METHOD Document::Release() {
	const int curRefCount = --refCount;
	if (curRefCount == 0)
		delete this;
	return curRefCount;
}

void Document::Init() {
	for (const std::unique_ptr<PerLine> &pl : perLineData) {
		if (pl)
			pl->Init();
	}
}

void Document::InsertLine(Sci::Line line) {
	for (const std::unique_ptr<PerLine> &pl : perLineData) {
		if (pl)
			pl->InsertLine(line);
	}
}

void Document::InsertLines(Sci::Line line, Sci::Line lines) {
	for (const auto &pl : perLineData) {
		if (pl)
			pl->InsertLines(line, lines);
	}
}

void Document::RemoveLine(Sci::Line line) {
	for (const std::unique_ptr<PerLine> &pl : perLineData) {
		if (pl)
			pl->RemoveLine(line);
	}
}

LineMarkers *Document::Markers() const noexcept {
	return static_cast<LineMarkers *>(perLineData[ldMarkers].get());
}

LineLevels *Document::Levels() const noexcept {
	return static_cast<LineLevels *>(perLineData[ldLevels].get());
}

LineState *Document::States() const noexcept {
	return static_cast<LineState *>(perLineData[ldState].get());
}

LineAnnotation *Document::Margins() const noexcept {
	return static_cast<LineAnnotation *>(perLineData[ldMargin].get());
}

LineAnnotation *Document::Annotations() const noexcept {
	return static_cast<LineAnnotation *>(perLineData[ldAnnotation].get());
}

LineAnnotation *Document::EOLAnnotations() const noexcept {
	return static_cast<LineAnnotation *>(perLineData[ldEOLAnnotation].get());
}

LineEndType Document::LineEndTypesSupported() const {
	if ((CpUtf8 == dbcsCodePage) && pli)
		return pli->LineEndTypesSupported();
	return LineEndType::Default;
}

bool Document::SetDBCSCodePage(int dbcsCodePage_) {
	if (dbcsCodePage != dbcsCodePage_) {
		dbcsCodePage = dbcsCodePage_;
		SetCaseFolder(nullptr);
		cb.SetLineEndTypes(lineEndBitSet & LineEndTypesSupported());
		cb.SetUTF8Substance(CpUtf8 == dbcsCodePage);
		ModifiedAt(0);	// Need to restyle whole document
		return true;
	}
	return false;
}

bool Document::SetLineEndTypesAllowed(LineEndType lineEndBitSet_) {
	if (lineEndBitSet != lineEndBitSet_) {
		lineEndBitSet = lineEndBitSet_;
		const LineEndType lineEndBitSetActive = lineEndBitSet & LineEndTypesSupported();
		if (lineEndBitSetActive != cb.GetLineEndTypes()) {
			ModifiedAt(0);
			cb.SetLineEndTypes(lineEndBitSetActive);
			return true;
		}
	}
	return false;
}

void Document::SetSavePoint() {
	cb.SetSavePoint();
	NotifySavePoint(true);
}

void Document::TentativeUndo() {
	if (!TentativeActive())
		return;
	CheckReadOnly();
	if (enteredModification == 0) {
		enteredModification++;
		if (!cb.IsReadOnly()) {
			const bool startSavePoint = cb.IsSavePoint();
			bool multiLine = false;
			const int steps = cb.TentativeSteps();
			//Platform::DebugPrintf("Steps=%d\n", steps);
			for (int step = 0; step < steps; step++) {
				const Sci::Line prevLinesTotal = LinesTotal();
				const Action action = cb.GetUndoStep();
				if (action.at == ActionType::remove) {
					NotifyModified(DocModification(
									ModificationFlags::BeforeInsert | ModificationFlags::Undo, action));
				} else if (action.at == ActionType::container) {
					DocModification dm(ModificationFlags::Container | ModificationFlags::Undo);
					dm.token = action.position;
					NotifyModified(dm);
				} else {
					NotifyModified(DocModification(
									ModificationFlags::BeforeDelete | ModificationFlags::Undo, action));
				}
				cb.PerformUndoStep();
				if (action.at != ActionType::container) {
					ModifiedAt(action.position);
				}

				ModificationFlags modFlags = ModificationFlags::Undo;
				// With undo, an insertion action becomes a deletion notification
				if (action.at == ActionType::remove) {
					modFlags |= ModificationFlags::InsertText;
				} else if (action.at == ActionType::insert) {
					modFlags |= ModificationFlags::DeleteText;
				}
				if (steps > 1)
					modFlags |= ModificationFlags::MultiStepUndoRedo;
				const Sci::Line linesAdded = LinesTotal() - prevLinesTotal;
				if (linesAdded != 0)
					multiLine = true;
				if (step == steps - 1) {
					modFlags |= ModificationFlags::LastStepInUndoRedo;
					if (multiLine)
						modFlags |= ModificationFlags::MultilineUndoRedo;
				}
				NotifyModified(DocModification(modFlags, action.position, action.lenData,
											   linesAdded, action.data));
			}

			const bool endSavePoint = cb.IsSavePoint();
			if (startSavePoint != endSavePoint)
				NotifySavePoint(endSavePoint);

			cb.TentativeCommit();
		}
		enteredModification--;
	}
}

int Document::UndoActions() const noexcept {
	return cb.UndoActions();
}

void Document::SetUndoSavePoint(int action) noexcept {
	cb.SetUndoSavePoint(action);
}

int Document::UndoSavePoint() const noexcept {
	return cb.UndoSavePoint();
}

void Document::SetUndoDetach(int action) noexcept {
	cb.SetUndoDetach(action);
}

int Document::UndoDetach() const noexcept {
	return cb.UndoDetach();
}

void Document::SetUndoTentative(int action) noexcept {
	cb.SetUndoTentative(action);
}

int Document::UndoTentative() const noexcept {
	return cb.UndoTentative();
}

void Document::SetUndoCurrent(int action) {
	cb.SetUndoCurrent(action);
}

int Document::UndoCurrent() const noexcept {
	return cb.UndoCurrent();
}

int Document::UndoActionType(int action) const noexcept {
	return cb.UndoActionType(action);
}

Sci::Position Document::UndoActionPosition(int action) const noexcept {
	return cb.UndoActionPosition(action);
}

std::string_view Document::UndoActionText(int action) const noexcept {
	return cb.UndoActionText(action);
}

void Document::PushUndoActionType(int type, Sci::Position position) {
	cb.PushUndoActionType(type, position);
}

void Document::ChangeLastUndoActionText(size_t length, const char *text) {
	cb.ChangeLastUndoActionText(length, text);
}

int Document::GetMark(Sci::Line line, bool includeChangeHistory) const {
	int marksHistory = 0;
	if (includeChangeHistory && (line < LinesTotal())) {
		int marksEdition = 0;

		const Sci::Position start = LineStart(line);
		const Sci::Position lineNext = LineStart(line + 1);
		for (Sci::Position position = start; position < lineNext;) {
			const int edition = EditionAt(position);
			if (edition) {
				marksEdition |= 1 << (edition-1);
			}
			position = EditionEndRun(position);
		}
		const Sci::Position lineEnd = LineEnd(line);
		for (Sci::Position position = start; position <= lineEnd;) {
			marksEdition |= EditionDeletesAt(position);
			position = EditionNextDelete(position);
		}

		/* Bits: RevertedToOrigin, Saved, Modified, RevertedToModified */
		constexpr unsigned int editionShift = static_cast<unsigned int>(MarkerOutline::HistoryRevertedToOrigin);
		marksHistory = marksEdition << editionShift;
	}

	return marksHistory | Markers()->MarkValue(line);
}

Sci::Line Document::MarkerNext(Sci::Line lineStart, int mask) const noexcept {
	return Markers()->MarkerNext(lineStart, mask);
}

int Document::AddMark(Sci::Line line, int markerNum) {
	if (line >= 0 && line < LinesTotal()) {
		const int prev = Markers()->AddMark(line, markerNum, LinesTotal());
		const DocModification mh(ModificationFlags::ChangeMarker, LineStart(line), 0, 0, nullptr, line);
		NotifyModified(mh);
		return prev;
	}
	return -1;
}

void Document::AddMarkSet(Sci::Line line, int valueSet) {
	if (line < 0 || line >= LinesTotal()) {
		return;
	}
	unsigned int m = valueSet;
	for (int i = 0; m; i++, m >>= 1) {
		if (m & 1)
			Markers()->AddMark(line, i, LinesTotal());
	}
	const DocModification mh(ModificationFlags::ChangeMarker, LineStart(line), 0, 0, nullptr, line);
	NotifyModified(mh);
}

void Document::DeleteMark(Sci::Line line, int markerNum) {
	Markers()->DeleteMark(line, markerNum, false);
	const DocModification mh(ModificationFlags::ChangeMarker, LineStart(line), 0, 0, nullptr, line);
	NotifyModified(mh);
}

void Document::DeleteMarkFromHandle(int markerHandle) {
	Markers()->DeleteMarkFromHandle(markerHandle);
	DocModification mh(ModificationFlags::ChangeMarker);
	mh.line = -1;
	NotifyModified(mh);
}

void Document::DeleteAllMarks(int markerNum) {
	bool someChanges = false;
	for (Sci::Line line = 0; line < LinesTotal(); line++) {
		if (Markers()->DeleteMark(line, markerNum, true))
			someChanges = true;
	}
	if (someChanges) {
		DocModification mh(ModificationFlags::ChangeMarker);
		mh.line = -1;
		NotifyModified(mh);
	}
}

Sci::Line Document::LineFromHandle(int markerHandle) const noexcept {
	return Markers()->LineFromHandle(markerHandle);
}

int Document::MarkerNumberFromLine(Sci::Line line, int which) const noexcept {
	return Markers()->NumberFromLine(line, which);
}

int Document::MarkerHandleFromLine(Sci::Line line, int which) const noexcept {
	return Markers()->HandleFromLine(line, which);
}

Sci_Position SCI_METHOD Document::LineStart(Sci_Position line) const {
	return cb.LineStart(line);
}

Range Document::LineRange(Sci::Line line) const noexcept {
	return {cb.LineStart(line), cb.LineStart(line + 1)};
}

bool Document::IsLineStartPosition(Sci::Position position) const noexcept {
	return LineStartPosition(position) == position;
}

Sci_Position SCI_METHOD Document::LineEnd(Sci_Position line) const {
	return cb.LineEnd(line);
}

int SCI_METHOD Document::DEVersion() const noexcept {
	return deRelease0;
}

void SCI_METHOD Document::SetErrorStatus(int status) {
	// Tell the watchers an error has occurred.
	for (const WatcherWithUserData &watcher : watchers) {
		watcher.watcher->NotifyErrorOccurred(this, watcher.userData, static_cast<Status>(status));
	}
}

Sci_Position SCI_METHOD Document::LineFromPosition(Sci_Position pos) const {
	return cb.LineFromPosition(pos);
}

Sci::Line Document::SciLineFromPosition(Sci::Position pos) const noexcept {
	// Avoids casting in callers for this very common function
	return cb.LineFromPosition(pos);
}

Sci::Position Document::LineStartPosition(Sci::Position position) const noexcept {
	return cb.LineStart(cb.LineFromPosition(position));
}

Sci::Position Document::LineEndPosition(Sci::Position position) const noexcept {
	return cb.LineEnd(cb.LineFromPosition(position));
}

bool Document::IsLineEndPosition(Sci::Position position) const noexcept {
	return LineEndPosition(position) == position;
}

bool Document::IsPositionInLineEnd(Sci::Position position) const noexcept {
	return position >= LineEndPosition(position);
}

Sci::Position Document::VCHomePosition(Sci::Position position) const {
	const Sci::Line line = SciLineFromPosition(position);
	const Sci::Position startPosition = LineStart(line);
	const Sci::Position endLine = LineEnd(line);
	Sci::Position startText = startPosition;
	while (startText < endLine && IsSpaceOrTab(cb.CharAt(startText)))
		startText++;
	if (position == startText)
		return startPosition;
	else
		return startText;
}

Sci::Position Document::IndexLineStart(Sci::Line line, LineCharacterIndexType lineCharacterIndex) const noexcept {
	return cb.IndexLineStart(line, lineCharacterIndex);
}

Sci::Line Document::LineFromPositionIndex(Sci::Position pos, LineCharacterIndexType lineCharacterIndex) const noexcept {
	return cb.LineFromPositionIndex(pos, lineCharacterIndex);
}

Sci::Line Document::LineFromPositionAfter(Sci::Line line, Sci::Position length) const noexcept {
	const Sci::Position posAfter = cb.LineStart(line) + length;
	if (posAfter >= LengthNoExcept()) {
		return LinesTotal();
	}
	const Sci::Line lineAfter = SciLineFromPosition(posAfter);
	if (lineAfter > line) {
		return lineAfter;
	} else {
		// Want to make some progress so return next line
		return lineAfter + 1;
	}
}

int SCI_METHOD Document::SetLevel(Sci_Position line, int level) {
	const int prev = Levels()->SetLevel(line, level, LinesTotal());
	if (prev != level) {
		DocModification mh(ModificationFlags::ChangeFold | ModificationFlags::ChangeMarker,
		                   LineStart(line), 0, 0, nullptr, line);
		mh.foldLevelNow = static_cast<FoldLevel>(level);
		mh.foldLevelPrev = static_cast<FoldLevel>(prev);
		NotifyModified(mh);
	}
	return prev;
}

//Au
bool SCI_METHOD Document::Sci_SetFoldLevels(int line, int lineTo, int len, int* a) {
	bool R = false;
	//code like in LexCPP.cxx function Fold().
	auto levels = Levels();
	int levelCurrent = line == 0 ? (int)FoldLevel::Base : levels->GetLevel((Sci::Line)line - 1) >> 16;
	int levelNext = levelCurrent;
	int nLines = (int)LinesTotal();
	if(lineTo < 0) lineTo = nLines;
	for(int i = 0; line < lineTo; line++) {
		int eol = (int)this->LineStart((Sci::Line)line + 1);
		if(a != nullptr) for(; i < len && (a[i] & 0x7fffffff) < eol; i++) levelNext += (a[i] & 0x80000000) ? -1 : 1;
		if(levelNext < (int)FoldLevel::Base) levelNext = (int)FoldLevel::Base;
		int lev = levelCurrent | levelNext << 16;
		if(levelNext > levelCurrent) lev |= (int)FoldLevel::HeaderFlag;
		//Print(line+1, (uint)lev, (uint)p->GetLevel(line));
		auto prevLevel = levels->GetLevel(line);
		if(lev != prevLevel) {
			//Platform::DebugPrintf("0x%x  0x%x", (int)prevLevel, (int)lev);
			if(prevLevel <= (int)FoldLevel::Base)levels->SetLevel(line, lev, nLines); //first folding. Slightly faster, but does not show hidden lines when header unset, etc.
			else SetLevel(line, lev);
			R = true;
		}
		levelCurrent = levelNext;
	}
	return R;
}

int SCI_METHOD Document::GetLevel(Sci_Position line) const {
	return Levels()->GetLevel(line);
}

FoldLevel Document::GetFoldLevel(Sci_Position line) const noexcept {
	return Levels()->GetFoldLevel(line);
}

void Document::ClearLevels() {
	Levels()->ClearLevels();
}

namespace {

constexpr bool IsSubordinate(FoldLevel levelStart, FoldLevel levelTry) noexcept {
	if (LevelIsWhitespace(levelTry))
		return true;
	return LevelNumber(levelStart) < LevelNumber(levelTry);
}

}

Sci::Line Document::GetLastChild(Sci::Line lineParent, std::optional<FoldLevel> level, Sci::Line lastLine) {
	const FoldLevel levelStart = LevelNumberPart(level ? *level : GetFoldLevel(lineParent));
	const Sci::Line maxLine = LinesTotal() - 1;
	const Sci::Line lookLastLine = (lastLine != -1) ? std::min(maxLine, lastLine) : maxLine;
	Sci::Line lineMaxSubord = lineParent;
	while (lineMaxSubord < maxLine) {
		EnsureStyledTo(LineStart(lineMaxSubord + 2));
		if (!IsSubordinate(levelStart, GetFoldLevel(lineMaxSubord + 1)))
			break;
		if ((lineMaxSubord >= lookLastLine) && !LevelIsWhitespace(GetFoldLevel(lineMaxSubord)))
			break;
		lineMaxSubord++;
	}
	if (lineMaxSubord > lineParent) {
		if (levelStart > LevelNumberPart(GetFoldLevel(lineMaxSubord + 1))) {
			// Have chewed up some whitespace that belongs to a parent so seek back
			if (LevelIsWhitespace(GetFoldLevel(lineMaxSubord))) {
				lineMaxSubord--;
			}
		}
	}
	return lineMaxSubord;
}

Sci::Line Document::GetFoldParent(Sci::Line line) const noexcept {
	return Levels()->GetFoldParent(line);
}

void Document::GetHighlightDelimiters(HighlightDelimiter &highlightDelimiter, Sci::Line line, Sci::Line lastLine) {
	const FoldLevel level = GetFoldLevel(line);
	const Sci::Line lookLastLine = std::max(line, lastLine) + 1;

	Sci::Line lookLine = line;
	FoldLevel lookLineLevel = level;
	FoldLevel lookLineLevelNum = LevelNumberPart(lookLineLevel);
	while ((lookLine > 0) && (LevelIsWhitespace(lookLineLevel) ||
		(LevelIsHeader(lookLineLevel) && (lookLineLevelNum >= LevelNumberPart(GetFoldLevel(lookLine + 1)))))) {
		lookLineLevel = GetFoldLevel(--lookLine);
		lookLineLevelNum = LevelNumberPart(lookLineLevel);
	}

	Sci::Line beginFoldBlock = LevelIsHeader(lookLineLevel) ? lookLine : GetFoldParent(lookLine);
	if (beginFoldBlock == -1) {
		highlightDelimiter.Clear();
		return;
	}

	Sci::Line endFoldBlock = GetLastChild(beginFoldBlock, {}, lookLastLine);
	Sci::Line firstChangeableLineBefore = -1;
	if (endFoldBlock < line) {
		lookLine = beginFoldBlock - 1;
		lookLineLevel = GetFoldLevel(lookLine);
		lookLineLevelNum = LevelNumberPart(lookLineLevel);
		while ((lookLine >= 0) && (lookLineLevelNum >= FoldLevel::Base)) {
			if (LevelIsHeader(lookLineLevel)) {
				if (GetLastChild(lookLine, {}, lookLastLine) == line) {
					beginFoldBlock = lookLine;
					endFoldBlock = line;
					firstChangeableLineBefore = line - 1;
				}
			}
			if ((lookLine > 0) && (lookLineLevelNum == FoldLevel::Base) && (LevelNumberPart(GetFoldLevel(lookLine - 1)) > lookLineLevelNum))
				break;
			lookLineLevel = GetFoldLevel(--lookLine);
			lookLineLevelNum = LevelNumberPart(lookLineLevel);
		}
	}
	if (firstChangeableLineBefore == -1) {
		for (lookLine = line - 1, lookLineLevel = GetFoldLevel(lookLine), lookLineLevelNum = LevelNumberPart(lookLineLevel);
			lookLine >= beginFoldBlock;
			lookLineLevel = GetFoldLevel(--lookLine), lookLineLevelNum = LevelNumberPart(lookLineLevel)) {
			if (LevelIsWhitespace(lookLineLevel) || (lookLineLevelNum > LevelNumberPart(level))) {
				firstChangeableLineBefore = lookLine;
				break;
			}
		}
	}
	if (firstChangeableLineBefore == -1)
		firstChangeableLineBefore = beginFoldBlock - 1;

	Sci::Line firstChangeableLineAfter = -1;
	for (lookLine = line + 1, lookLineLevel = GetFoldLevel(lookLine), lookLineLevelNum = LevelNumberPart(lookLineLevel);
		lookLine <= endFoldBlock;
		lookLineLevel = GetFoldLevel(++lookLine), lookLineLevelNum = LevelNumberPart(lookLineLevel)) {
		if (LevelIsHeader(lookLineLevel) && (lookLineLevelNum < LevelNumberPart(GetFoldLevel(lookLine + 1)))) {
			firstChangeableLineAfter = lookLine;
			break;
		}
	}
	if (firstChangeableLineAfter == -1)
		firstChangeableLineAfter = endFoldBlock + 1;

	highlightDelimiter.beginFoldBlock = beginFoldBlock;
	highlightDelimiter.endFoldBlock = endFoldBlock;
	highlightDelimiter.firstChangeableLineBefore = firstChangeableLineBefore;
	highlightDelimiter.firstChangeableLineAfter = firstChangeableLineAfter;
}

Sci::Position Document::ClampPositionIntoDocument(Sci::Position pos) const noexcept {
	return std::clamp<Sci::Position>(pos, 0, LengthNoExcept());
}

bool Document::IsCrLf(Sci::Position pos) const noexcept {
	if (pos < 0)
		return false;
	if (pos >= (LengthNoExcept() - 1))
		return false;
	return (cb.CharAt(pos) == '\r') && (cb.CharAt(pos + 1) == '\n');
}

int Document::LenChar(Sci::Position pos) const noexcept {
	if (pos < 0 || pos >= LengthNoExcept()) {
		// Returning 1 instead of 0 to defend against hanging with a loop that goes (or starts) out of bounds.
		return 1;
	} else if (IsCrLf(pos)) {
		return 2;
	}

	const unsigned char leadByte = cb.UCharAt(pos);
	if (!dbcsCodePage || UTF8IsAscii(leadByte)) {
		// Common case: ASCII character
		return 1;
	}
	if (CpUtf8 == dbcsCodePage) {
		const int widthCharBytes = UTF8BytesOfLead[leadByte];
		unsigned char charBytes[UTF8MaxBytes] = { leadByte, 0, 0, 0 };
		for (int b = 1; b < widthCharBytes; b++) {
			charBytes[b] = cb.UCharAt(pos + b);
		}
		const int utf8status = UTF8Classify(charBytes, widthCharBytes);
		if (utf8status & UTF8MaskInvalid) {
			// Treat as invalid and use up just one byte
			return 1;
		}
		return utf8status & UTF8MaskWidth;
	}
	if (IsDBCSLeadByteNoExcept(leadByte) && IsDBCSTrailByteNoExcept(cb.CharAt(pos + 1))) {
		return 2;
	} else {
		return 1;
	}
}

bool Document::InGoodUTF8(Sci::Position pos, Sci::Position &start, Sci::Position &end) const noexcept {
	Sci::Position trail = pos;
	while ((trail>0) && (pos-trail < UTF8MaxBytes) && UTF8IsTrailByte(cb.UCharAt(trail-1)))
		trail--;
	start = (trail > 0) ? trail-1 : trail;

	const unsigned char leadByte = cb.UCharAt(start);
	const int widthCharBytes = UTF8BytesOfLead[leadByte];
	if (widthCharBytes == 1) {
		return false;
	}
	const int trailBytes = widthCharBytes - 1;
	const Sci::Position len = pos - start;
	if (len > trailBytes)
		// pos too far from lead
		return false;
	unsigned char charBytes[UTF8MaxBytes] = {leadByte,0,0,0};
	for (Sci::Position b=1; b<widthCharBytes && ((start+b) < cb.Length()); b++)
		charBytes[b] = cb.CharAt(start+b);
	const int utf8status = UTF8Classify(charBytes, widthCharBytes);
	if (utf8status & UTF8MaskInvalid)
		return false;
	end = start + widthCharBytes;
	return true;
}

// Normalise a position so that it is not part way through a multi-byte character.
// This can occur in two situations -
// When lines are terminated with \r\n pairs which should be treated as one character.
// When displaying DBCS text such as Japanese.
// If moving, move the position in the indicated direction.
Sci::Position Document::MovePositionOutsideChar(Sci::Position pos, Sci::Position moveDir, bool checkLineEnd) const noexcept {
	//Platform::DebugPrintf("NoCRLF %d %d\n", pos, moveDir);
	// If out of range, just return minimum/maximum value.
	if (pos <= 0)
		return 0;
	if (pos >= LengthNoExcept())
		return LengthNoExcept();

	// PLATFORM_ASSERT(pos > 0 && pos < LengthNoExcept());
	if (checkLineEnd && IsCrLf(pos - 1)) {
		if (moveDir > 0)
			return pos + 1;
		else
			return pos - 1;
	}

	if (dbcsCodePage) {
		if (CpUtf8 == dbcsCodePage) {
			const unsigned char ch = cb.UCharAt(pos);
			// If ch is not a trail byte then pos is valid intercharacter position
			if (UTF8IsTrailByte(ch)) {
				Sci::Position startUTF = pos;
				Sci::Position endUTF = pos;
				if (InGoodUTF8(pos, startUTF, endUTF)) {
					// ch is a trail byte within a UTF-8 character
					if (moveDir > 0)
						pos = endUTF;
					else
						pos = startUTF;
				}
				// Else invalid UTF-8 so return position of isolated trail byte
			}
		} else {
			// Step back until a non-lead-byte is found.
			Sci::Position posCheck = pos;
			while ((posCheck > 0) && IsDBCSLeadByteNoExcept(cb.CharAt(posCheck-1)))
				posCheck--;

			// Check from known start of character.
			while (posCheck < pos) {
				const int mbsize = IsDBCSDualByteAt(posCheck) ? 2 : 1;
				if (posCheck + mbsize == pos) {
					return pos;
				} else if (posCheck + mbsize > pos) {
					if (moveDir > 0) {
						return posCheck + mbsize;
					} else {
						return posCheck;
					}
				}
				posCheck += mbsize;
			}
		}
	}

	return pos;
}

// NextPosition moves between valid positions - it can not handle a position in the middle of a
// multi-byte character. It is used to iterate through text more efficiently than MovePositionOutsideChar.
// A \r\n pair is treated as two characters.
Sci::Position Document::NextPosition(Sci::Position pos, int moveDir) const noexcept {
	// If out of range, just return minimum/maximum value.
	const int increment = (moveDir > 0) ? 1 : -1;
	if (pos + increment <= 0)
		return 0;
	if (pos + increment >= cb.Length())
		return cb.Length();

	if (dbcsCodePage) {
		if (CpUtf8 == dbcsCodePage) {
			if (increment == 1) {
				// Simple forward movement case so can avoid some checks
				const unsigned char leadByte = cb.UCharAt(pos);
				if (UTF8IsAscii(leadByte)) {
					// Single byte character or invalid
					pos++;
				} else {
					const int widthCharBytes = UTF8BytesOfLead[leadByte];
					unsigned char charBytes[UTF8MaxBytes] = {leadByte,0,0,0};
					for (int b=1; b<widthCharBytes; b++)
						charBytes[b] = cb.CharAt(pos+b);
					const int utf8status = UTF8Classify(charBytes, widthCharBytes);
					if (utf8status & UTF8MaskInvalid)
						pos++;
					else
						pos += utf8status & UTF8MaskWidth;
				}
			} else {
				// Examine byte before position
				pos--;
				const unsigned char ch = cb.UCharAt(pos);
				// If ch is not a trail byte then pos is valid intercharacter position
				if (UTF8IsTrailByte(ch)) {
					// If ch is a trail byte in a valid UTF-8 character then return start of character
					Sci::Position startUTF = pos;
					Sci::Position endUTF = pos;
					if (InGoodUTF8(pos, startUTF, endUTF)) {
						pos = startUTF;
					}
					// Else invalid UTF-8 so return position of isolated trail byte
				}
			}
		} else {
			if (moveDir > 0) {
				const int mbsize = IsDBCSDualByteAt(pos) ? 2 : 1;
				pos += mbsize;
				if (pos > cb.Length())
					pos = cb.Length();
			} else {
				// How to Go Backward in a DBCS String
				// https://msdn.microsoft.com/en-us/library/cc194792.aspx
				// DBCS-Enabled Programs vs. Non-DBCS-Enabled Programs
				// https://msdn.microsoft.com/en-us/library/cc194790.aspx
				if (IsDBCSLeadByteNoExcept(cb.CharAt(pos - 1))) {
					// Should actually be trail byte
					if (IsDBCSDualByteAt(pos - 2)) {
						return pos - 2;
					} else {
						// Invalid byte pair so treat as one byte wide
						return pos - 1;
					}
				} else {
					// Otherwise, step back until a non-lead-byte is found.
					Sci::Position posTemp = pos - 1;
					while (--posTemp >= 0 && IsDBCSLeadByteNoExcept(cb.CharAt(posTemp)))
						;
					// Now posTemp+1 must point to the beginning of a character,
					// so figure out whether we went back an even or an odd
					// number of bytes and go back 1 or 2 bytes, respectively.
					const Sci::Position widthLast = ((pos - posTemp) & 1) + 1;
					if ((widthLast == 2) && (IsDBCSDualByteAt(pos - widthLast))) {
						return pos - widthLast;
					}
					// Byte before pos may be valid character or may be an invalid second byte
					return pos - 1;
				}
			}
		}
	} else {
		pos += increment;
	}

	return pos;
}

bool Document::NextCharacter(Sci::Position &pos, int moveDir) const noexcept {
	// Returns true if pos changed
	Sci::Position posNext = NextPosition(pos, moveDir);
	if (posNext == pos) {
		return false;
	}
	pos = posNext;
	return true;
}

CharacterExtracted Document::CharacterAfter(Sci::Position position) const noexcept {
	if (position >= LengthNoExcept()) {
		return characterEmpty;
	}
	const unsigned char leadByte = cb.UCharAt(position);
	if (!dbcsCodePage || UTF8IsAscii(leadByte)) {
		// Common case: ASCII character
		return CharacterExtracted(leadByte, 1);
	}
	if (CpUtf8 == dbcsCodePage) {
		const int widthCharBytes = UTF8BytesOfLead[leadByte];
		unsigned char charBytes[UTF8MaxBytes] = { leadByte, 0, 0, 0 };
		for (int b = 1; b<widthCharBytes; b++)
			charBytes[b] = cb.UCharAt(position + b);
		return CharacterExtracted(charBytes, widthCharBytes);
	} else {
		if (IsDBCSLeadByteNoExcept(leadByte)) {
			const unsigned char trailByte = cb.UCharAt(position + 1);
			if (IsDBCSTrailByteNoExcept(trailByte)) {
				return CharacterExtracted::DBCS(leadByte, trailByte);
			}
		}
		return CharacterExtracted(leadByte, 1);
	}
}

CharacterExtracted Document::CharacterBefore(Sci::Position position) const noexcept {
	if (position <= 0) {
		return characterEmpty;
	}
	const unsigned char previousByte = cb.UCharAt(position - 1);
	if (0 == dbcsCodePage) {
		return CharacterExtracted(previousByte, 1);
	}
	if (CpUtf8 == dbcsCodePage) {
		if (UTF8IsAscii(previousByte)) {
			return CharacterExtracted(previousByte, 1);
		}
		position--;
		// If previousByte is not a trail byte then its invalid
		if (UTF8IsTrailByte(previousByte)) {
			// If previousByte is a trail byte in a valid UTF-8 character then find start of character
			Sci::Position startUTF = position;
			Sci::Position endUTF = position;
			if (InGoodUTF8(position, startUTF, endUTF)) {
				const Sci::Position widthCharBytes = endUTF - startUTF;
				unsigned char charBytes[UTF8MaxBytes] = { 0, 0, 0, 0 };
				for (Sci::Position b = 0; b<widthCharBytes; b++)
					charBytes[b] = cb.UCharAt(startUTF + b);
				return CharacterExtracted(charBytes, widthCharBytes);
			}
			// Else invalid UTF-8 so return position of isolated trail byte
		}
		return characterBadByte;
	} else {
		// Moving backwards in DBCS is complex so use NextPosition
		const Sci::Position posStartCharacter = NextPosition(position, -1);
		return CharacterAfter(posStartCharacter);
	}
}

// Return -1  on out-of-bounds
Sci_Position SCI_METHOD Document::GetRelativePosition(Sci_Position positionStart, Sci_Position characterOffset) const {
	Sci::Position pos = positionStart;
	if (dbcsCodePage) {
		const int increment = (characterOffset > 0) ? 1 : -1;
		while (characterOffset != 0) {
			const Sci::Position posNext = NextPosition(pos, increment);
			if (posNext == pos)
				return Sci::invalidPosition;
			pos = posNext;
			characterOffset -= increment;
		}
	} else {
		pos = positionStart + characterOffset;
		if ((pos < 0) || (pos > Length()))
			return Sci::invalidPosition;
	}
	return pos;
}

Sci::Position Document::GetRelativePositionUTF16(Sci::Position positionStart, Sci::Position characterOffset) const noexcept {
	Sci::Position pos = positionStart;
	if (dbcsCodePage) {
		const int increment = (characterOffset > 0) ? 1 : -1;
		while (characterOffset != 0) {
			const Sci::Position posNext = NextPosition(pos, increment);
			if (posNext == pos)
				return Sci::invalidPosition;
			if (std::abs(pos-posNext) > 3)	// 4 byte character = 2*UTF16.
				characterOffset -= increment;
			pos = posNext;
			characterOffset -= increment;
		}
	} else {
		pos = positionStart + characterOffset;
		if ((pos < 0) || (pos > LengthNoExcept()))
			return Sci::invalidPosition;
	}
	return pos;
}

int SCI_METHOD Document::GetCharacterAndWidth(Sci_Position position, Sci_Position *pWidth) const {
	int bytesInCharacter = 1;
	const unsigned char leadByte = cb.UCharAt(position);
	int character = leadByte;
	if (dbcsCodePage && !UTF8IsAscii(leadByte)) {
		if (CpUtf8 == dbcsCodePage) {
			const int widthCharBytes = UTF8BytesOfLead[leadByte];
			unsigned char charBytes[UTF8MaxBytes] = {leadByte,0,0,0};
			for (int b=1; b<widthCharBytes; b++)
				charBytes[b] = cb.UCharAt(position+b);
			const int utf8status = UTF8Classify(charBytes, widthCharBytes);
			if (utf8status & UTF8MaskInvalid) {
				// Report as singleton surrogate values which are invalid Unicode
				character =  0xDC80 + leadByte;
			} else {
				bytesInCharacter = utf8status & UTF8MaskWidth;
				character = UnicodeFromUTF8(charBytes);
			}
		} else {
			if (IsDBCSLeadByteNoExcept(leadByte)) {
				const unsigned char trailByte = cb.UCharAt(position + 1);
				if (IsDBCSTrailByteNoExcept(trailByte)) {
					bytesInCharacter = 2;
					character = (leadByte << 8) | trailByte;
				}
			}
		}
	}
	if (pWidth) {
		*pWidth = bytesInCharacter;
	}
	return character;
}

int SCI_METHOD Document::CodePage() const {
	return dbcsCodePage;
}

bool SCI_METHOD Document::IsDBCSLeadByte(char ch) const {
	// Used by lexers so must match IDocument method exactly
	return IsDBCSLeadByteNoExcept(ch);
}

// Silence 'magic' number use since the set of DBCS lead and trail bytes differ
// between encodings and would require many constant declarations that would just
// obscure the behaviour.

// NOLINTBEGIN(*-magic-numbers)

bool Document::IsDBCSLeadByteNoExcept(char ch) const noexcept {
	// Used inside core Scintilla
	// Byte ranges found in Wikipedia articles with relevant search strings in each case
	const unsigned char uch = ch;
	switch (dbcsCodePage) {
		case 932:
			// Shift_jis
			return ((uch >= 0x81) && (uch <= 0x9F)) ||
				((uch >= 0xE0) && (uch <= 0xFC));
				// Lead bytes F0 to FC may be a Microsoft addition.
		case 936:
			// GBK
			return (uch >= 0x81) && (uch <= 0xFE);
		case 949:
			// Korean Wansung KS C-5601-1987
			return (uch >= 0x81) && (uch <= 0xFE);
		case 950:
			// Big5
			return (uch >= 0x81) && (uch <= 0xFE);
		case 1361:
			// Korean Johab KS C-5601-1992
			return
				((uch >= 0x84) && (uch <= 0xD3)) ||
				((uch >= 0xD8) && (uch <= 0xDE)) ||
				((uch >= 0xE0) && (uch <= 0xF9));
	}
	return false;
}

bool Document::IsDBCSTrailByteNoExcept(char ch) const noexcept {
	const unsigned char trail = ch;
	switch (dbcsCodePage) {
	case 932:
		// Shift_jis
		return (trail != 0x7F) &&
			((trail >= 0x40) && (trail <= 0xFC));
	case 936:
		// GBK
		return (trail != 0x7F) &&
			((trail >= 0x40) && (trail <= 0xFE));
	case 949:
		// Korean Wansung KS C-5601-1987
		return
			((trail >= 0x41) && (trail <= 0x5A)) ||
			((trail >= 0x61) && (trail <= 0x7A)) ||
			((trail >= 0x81) && (trail <= 0xFE));
	case 950:
		// Big5
		return
			((trail >= 0x40) && (trail <= 0x7E)) ||
			((trail >= 0xA1) && (trail <= 0xFE));
	case 1361:
		// Korean Johab KS C-5601-1992
		return
			((trail >= 0x31) && (trail <= 0x7E)) ||
			((trail >= 0x81) && (trail <= 0xFE));
	}
	return false;
}

unsigned char Document::DBCSMinTrailByte() const noexcept {
	switch (dbcsCodePage) {
	case 932:
		// Shift_jis
		return 0x40;
	case 936:
		// GBK
		return 0x40;
	case 949:
		// Korean Wansung KS C-5601-1987
		return 0x41;
	case 950:
		// Big5
		return 0x40;
	case 1361:
		// Korean Johab KS C-5601-1992
		return 0x31;
	default:
		// UTF-8 or single byte, should not occur as not DBCS
		return 0;
	}
}

// NOLINTEND(*-magic-numbers)

int Document::DBCSDrawBytes(std::string_view text) const noexcept {
	if (text.length() <= 1) {
		return static_cast<int>(text.length());
	}
	if (IsDBCSLeadByteNoExcept(text[0])) {
		return IsDBCSTrailByteNoExcept(text[1]) ? 2 : 1;
	} else {
		return 1;
	}
}

bool Document::IsDBCSDualByteAt(Sci::Position pos) const noexcept {
	return IsDBCSLeadByteNoExcept(cb.CharAt(pos))
		&& IsDBCSTrailByteNoExcept(cb.CharAt(pos + 1));
}

namespace {

// Remove any extra bytes after the last valid character.
void DiscardEndFragment(std::string_view &text) noexcept {
	if (!text.empty()) {
		if (UTF8IsFirstByte(text.back())) {
			// Ending with start of character byte is invalid
			text.remove_suffix(1);
		} else if (UTF8IsTrailByte(text.back())) {
			// go back to the start of last character.
			constexpr int UTF8MaxTrail = UTF8MaxBytes - 1;
			const size_t maxTrail = std::max<size_t>(UTF8MaxTrail, text.length());
			size_t trail = 1;
			while (trail < maxTrail && UTF8IsTrailByte(text[text.length() - trail])) {
				trail++;
			}
			const std::string_view endPortion = text.substr(text.length() - trail);
			if (!UTF8IsValid(endPortion)) {
				text.remove_suffix(trail);
			}
		}
	}
}

constexpr bool IsBaseOfGrapheme(CharacterCategory cc) {
	switch (cc) {
		// \p{L}\p{N}\p{P}\p{Sm}\p{Sc}\p{So}\p{Zs}
	case ccLu:
	case ccLl:
	case ccLt:
	case ccLm:
	case ccLo:
	case ccNd:
	case ccNl:
	case ccNo:
	case ccPc:
	case ccPd:
	case ccPs:
	case ccPe:
	case ccPi:
	case ccPf:
	case ccPo:
	case ccSm:
	case ccSc:
	case ccSo:
	case ccZs:
		// Control
	case ccCc:
	case ccCs:
	case ccCo:
		return true;
	default:
		// ccMn, ccMc, ccMe,
		// ccSk,
		// ccZl, ccZp,
		// ccCf, ccCn
		return false;
	}
}

CharacterExtracted LastCharacter(std::string_view text) noexcept {
	if (text.empty())
		return characterEmpty;
	const size_t length = text.length();
	size_t trail = length;
	while ((trail > 0) && (length - trail < UTF8MaxBytes) && UTF8IsTrailByte(text[trail - 1]))
		trail--;
	const size_t start = (trail > 0) ? trail - 1 : trail;
	const int utf8status = UTF8Classify(text.substr(start));
	if (utf8status & UTF8MaskInvalid) {
		return characterBadByte;
	}
	return { static_cast<unsigned int>(UnicodeFromUTF8(text.substr(start))),
		static_cast<unsigned int>(utf8status & UTF8MaskWidth) };
}

constexpr Sci::Position NextTab(Sci::Position pos, Sci::Position tabSize) noexcept {
	return ((pos / tabSize) + 1) * tabSize;
}

std::string CreateIndentation(Sci::Position indent, int tabSize, bool insertSpaces) {
	std::string indentation;
	if (!insertSpaces) {
		while (indent >= tabSize) {
			indentation += '\t';
			indent -= tabSize;
		}
	}
	while (indent > 0) {
		indentation += ' ';
		indent--;
	}
	return indentation;
}

}

bool Scintilla::Internal::DiscardLastCombinedCharacter(std::string_view &text) noexcept {
	// Handle the simple common case where a base character may be followed by
	// accents and similar marks by discarding until start of base character.
	//
	// From Grapheme_Cluster_Boundaries
	// combining character sequence = ccs-base? ccs-extend+
	// ccs-base := [\p{L}\p{N}\p{P}\p{S}\p{Zs}]
	// ccs-extend := [\p{M}\p{Join_Control}]
	// Modified to move Sk (Symbol Modifier) from ccs-base to ccs-extend to preserve modified emoji
	// May break before and after Control which is defined as most of ccC? but not some of ccCf and ccCn
	// so treat ccCc, ccCs, ccCo as base for now.

	std::string_view truncated = text;
	while (truncated.length() > UTF8MaxBytes) {
		// Give up when short
		const CharacterExtracted ce = LastCharacter(truncated);
		const CharacterCategory cc = CategoriseCharacter(static_cast<int>(ce.character));
		truncated.remove_suffix(ce.widthBytes);
		if (IsBaseOfGrapheme(cc)) {
			text = truncated;
			return true;
		}
	}
	// No base character found so just leave as is
	return false;
}

// Need to break text into segments near end but taking into account the
// encoding to not break inside a UTF-8 or DBCS character and also trying
// to avoid breaking inside a pair of combining characters, or inside
// ligatures.
// TODO: implement grapheme cluster boundaries,
// see https://www.unicode.org/reports/tr29/#Grapheme_Cluster_Boundaries.
//
// The segment length must always be long enough (more than 4 bytes)
// so that there will be at least one whole character to make a segment.
// For UTF-8, text must consist only of valid whole characters.
// In preference order from best to worst:
//   1) Break before or after spaces or controls
//   2) Break at word and punctuation boundary for better kerning and ligature support
//   3) Break before letter in UTF-8 to avoid breaking combining characters
//   4) Break after whole character, this may break combining characters

size_t Document::SafeSegment(std::string_view text) const noexcept {
	// check space first as most written language use spaces.
	for (std::string_view::iterator it = text.end() - 1; it != text.begin(); --it) {
		if (IsBreakSpace(*it)) {
			return it - text.begin();
		}
	}

	if (!dbcsCodePage || dbcsCodePage == CpUtf8) {
		if (dbcsCodePage) {
			// UTF-8
			DiscardEndFragment(text);
			if (DiscardLastCombinedCharacter(text)) {
				return text.length();
			}
		}
		// backward iterate for UTF-8 and single byte encoding to find word and punctuation boundary.
		std::string_view::iterator it = text.end() - 1;
		const bool punctuation = IsPunctuation(*it);
		do {
			--it;
			if (punctuation != IsPunctuation(*it)) {
				return it - text.begin() + 1;
			}
		} while (it != text.begin());

		return text.length() - 1;
	}

	{
		// forward iterate for DBCS to find word and punctuation boundary.
		size_t lastPunctuationBreak = 0;
		size_t lastEncodingAllowedBreak = 0;
		CharacterClass ccPrev = CharacterClass::space;
		for (size_t j = 0; j < text.length();) {
			const unsigned char ch = text[j];
			lastEncodingAllowedBreak = j++;

			CharacterClass cc = CharacterClass::word;
			if (UTF8IsAscii(ch)) {
				if (IsPunctuation(ch)) {
					cc = CharacterClass::punctuation;
				}
			} else {
				j += IsDBCSLeadByteNoExcept(ch);
			}
			if (cc != ccPrev) {
				ccPrev = cc;
				lastPunctuationBreak = lastEncodingAllowedBreak;
			}
		}
		return lastPunctuationBreak ? lastPunctuationBreak : lastEncodingAllowedBreak;
	}
}

EncodingFamily Document::CodePageFamily() const noexcept {
	if (CpUtf8 == dbcsCodePage)
		return EncodingFamily::unicode;
	if (dbcsCodePage)
		return EncodingFamily::dbcs;
	return EncodingFamily::eightBit;
}

void Document::ModifiedAt(Sci::Position pos) noexcept {
	if (endStyled > pos)
		endStyled = pos;
}

void Document::CheckReadOnly() {
	if (cb.IsReadOnly() && enteredReadOnlyCount == 0) {
		enteredReadOnlyCount++;
		NotifyModifyAttempt();
		enteredReadOnlyCount--;
	}
}

void Document::TrimReplacement(std::string_view &text, Range &range) const noexcept {
	while (!text.empty() && !range.Empty() && (text.front() == CharAt(range.start))) {
		text.remove_prefix(1);
		range.start++;
	}
	while (!text.empty() && !range.Empty() && (text.back() == CharAt(range.end-1))) {
		text.remove_suffix(1);
		range.end--;
	}
}

// Document only modified by gateways DeleteChars, InsertString, Undo, Redo, and SetStyleAt.
// SetStyleAt does not change the persistent state of a document

bool Document::DeleteChars(Sci::Position pos, Sci::Position len) {
	if (pos < 0)
		return false;
	if (len <= 0)
		return false;
	if ((pos + len) > LengthNoExcept())
		return false;
	CheckReadOnly();
	if (enteredModification != 0) {
		return false;
	}
	enteredModification++;
	if (!cb.IsReadOnly()) {
		if (cb.IsCollectingUndo() && cb.CanRedo()) {
			// Abandoning some undo actions so truncate any later selections
			TruncateUndoComments(cb.UndoCurrent());
		}
		NotifyModified(
			DocModification(
			    ModificationFlags::BeforeDelete | ModificationFlags::User,
			    pos, len,
			0, nullptr));
		const Sci::Line prevLinesTotal = LinesTotal();
		const bool startSavePoint = cb.IsSavePoint();
		bool startSequence = false;
		const char *text = cb.DeleteChars(pos, len, startSequence);
		if (startSavePoint && cb.IsCollectingUndo())
			NotifySavePoint(false);
		if ((pos < LengthNoExcept()) || (pos == 0))
			ModifiedAt(pos);
		else
			ModifiedAt(pos-1);
		NotifyModified(
			DocModification(
			    ModificationFlags::DeleteText | ModificationFlags::User |
				(startSequence?ModificationFlags::StartAction:ModificationFlags::None),
			    pos, len,
			    LinesTotal() - prevLinesTotal, text));
	}
	enteredModification--;
	return !cb.IsReadOnly();
}

/**
 * Insert a string with a length.
 */
Sci::Position Document::InsertString(Sci::Position position, const char *s, Sci::Position insertLength) {
	if (insertLength <= 0) {
		return 0;
	}
	CheckReadOnly();	// Application may change read only state here
	if (cb.IsReadOnly()) {
		return 0;
	}
	if (enteredModification != 0) {
		return 0;
	}
	enteredModification++;
	insertionSet = false;
	insertion.clear();
	NotifyModified(
		DocModification(
			ModificationFlags::InsertCheck,
			position, insertLength,
			0, s));
	if (insertionSet) {
		s = insertion.c_str();
		insertLength = insertion.length();
	}
	if (cb.IsCollectingUndo() && cb.CanRedo()) {
		// Abandoning some undo actions so truncate any later selections
		TruncateUndoComments(cb.UndoCurrent());
	}
	NotifyModified(
		DocModification(
			ModificationFlags::BeforeInsert | ModificationFlags::User,
			position, insertLength,
			0, s));
	const Sci::Line prevLinesTotal = LinesTotal();
	const bool startSavePoint = cb.IsSavePoint();
	bool startSequence = false;
	const char *text = cb.InsertString(position, s, insertLength, startSequence);
	if (startSavePoint && cb.IsCollectingUndo())
		NotifySavePoint(false);
	ModifiedAt(position);
	NotifyModified(
		DocModification(
			ModificationFlags::InsertText | ModificationFlags::User |
			(startSequence?ModificationFlags::StartAction:ModificationFlags::None),
			position, insertLength,
			LinesTotal() - prevLinesTotal, text));
	if (insertionSet) {	// Free memory as could be large
		std::string().swap(insertion);
	}
	enteredModification--;
	return insertLength;
}

Sci::Position Document::InsertString(Sci::Position position, std::string_view sv) {
	return InsertString(position, sv.data(), sv.length());
}

void Document::ChangeInsertion(const char *s, Sci::Position length) {
	insertionSet = true;
	insertion.assign(s, length);
}

int SCI_METHOD Document::AddData(const char *data, Sci_Position length) {
	try {
		const Sci::Position position = Length();
		InsertString(position, data, length);
	} catch (std::bad_alloc &) {
		return static_cast<int>(Status::BadAlloc);
	} catch (...) {
		return static_cast<int>(Status::Failure);
	}
	return static_cast<int>(Status::Ok);
}

IDocumentEditable *Document::AsDocumentEditable() noexcept {
	return static_cast<IDocumentEditable *>(this);
}

void *SCI_METHOD Document::ConvertToDocument() {
	return AsDocumentEditable();
}

Sci::Position Document::Undo() {
	Sci::Position newPos = -1;
	CheckReadOnly();
	if ((enteredModification == 0) && (cb.IsCollectingUndo())) {
		enteredModification++;
		if (!cb.IsReadOnly()) {
			const bool startSavePoint = cb.IsSavePoint();
			bool multiLine = false;
			const int steps = cb.StartUndo();
			//Platform::DebugPrintf("Steps=%d\n", steps);
			Range coalescedRemove;	// Default is empty at 0
			for (int step = 0; step < steps; step++) {
				const Sci::Line prevLinesTotal = LinesTotal();
				const Action action = cb.GetUndoStep();
				if (action.at == ActionType::remove) {
					NotifyModified(DocModification(
									ModificationFlags::BeforeInsert | ModificationFlags::Undo, action));
				} else if (action.at == ActionType::container) {
					DocModification dm(ModificationFlags::Container | ModificationFlags::Undo);
					dm.token = action.position;
					NotifyModified(dm);
				} else {
					NotifyModified(DocModification(
									ModificationFlags::BeforeDelete | ModificationFlags::Undo, action));
				}
				cb.PerformUndoStep();
				if (action.at != ActionType::container) {
					ModifiedAt(action.position);
					newPos = action.position;
				}

				ModificationFlags modFlags = ModificationFlags::Undo;
				// With undo, an insertion action becomes a deletion notification
				if (action.at == ActionType::remove) {
					newPos += action.lenData;
					modFlags |= ModificationFlags::InsertText;
					if (coalescedRemove.Contains(action.position)) {
						coalescedRemove.end += action.lenData;
						newPos = coalescedRemove.end;
					} else {
						coalescedRemove = Range(action.position, action.position + action.lenData);
					}
				} else if (action.at == ActionType::insert) {
					modFlags |= ModificationFlags::DeleteText;
					coalescedRemove = Range();
				}
				if (steps > 1)
					modFlags |= ModificationFlags::MultiStepUndoRedo;
				const Sci::Line linesAdded = LinesTotal() - prevLinesTotal;
				if (linesAdded != 0)
					multiLine = true;
				if (step == steps - 1) {
					modFlags |= ModificationFlags::LastStepInUndoRedo;
					if (multiLine)
						modFlags |= ModificationFlags::MultilineUndoRedo;
				}
				NotifyModified(DocModification(modFlags, action.position, action.lenData,
											   linesAdded, action.data));
			}

			const bool endSavePoint = cb.IsSavePoint();
			if (startSavePoint != endSavePoint)
				NotifySavePoint(endSavePoint);
		}
		enteredModification--;
	}
	return newPos;
}

Sci::Position Document::Redo() {
	Sci::Position newPos = -1;
	CheckReadOnly();
	if ((enteredModification == 0) && (cb.IsCollectingUndo())) {
		enteredModification++;
		if (!cb.IsReadOnly()) {
			const bool startSavePoint = cb.IsSavePoint();
			bool multiLine = false;
			const int steps = cb.StartRedo();
			for (int step = 0; step < steps; step++) {
				const Sci::Line prevLinesTotal = LinesTotal();
				const Action action = cb.GetRedoStep();
				if (action.at == ActionType::insert) {
					NotifyModified(DocModification(
									ModificationFlags::BeforeInsert | ModificationFlags::Redo, action));
				} else if (action.at == ActionType::container) {
					DocModification dm(ModificationFlags::Container | ModificationFlags::Redo);
					dm.token = action.position;
					NotifyModified(dm);
				} else {
					NotifyModified(DocModification(
									ModificationFlags::BeforeDelete | ModificationFlags::Redo, action));
				}
				cb.PerformRedoStep();
				if (action.at != ActionType::container) {
					ModifiedAt(action.position);
					newPos = action.position;
				}

				ModificationFlags modFlags = ModificationFlags::Redo;
				if (action.at == ActionType::insert) {
					newPos += action.lenData;
					modFlags |= ModificationFlags::InsertText;
				} else if (action.at == ActionType::remove) {
					modFlags |= ModificationFlags::DeleteText;
				}
				if (steps > 1)
					modFlags |= ModificationFlags::MultiStepUndoRedo;
				const Sci::Line linesAdded = LinesTotal() - prevLinesTotal;
				if (linesAdded != 0)
					multiLine = true;
				if (step == steps - 1) {
					modFlags |= ModificationFlags::LastStepInUndoRedo;
					if (multiLine)
						modFlags |= ModificationFlags::MultilineUndoRedo;
				}
				NotifyModified(
					DocModification(modFlags, action.position, action.lenData,
									linesAdded, action.data));
			}

			const bool endSavePoint = cb.IsSavePoint();
			if (startSavePoint != endSavePoint)
				NotifySavePoint(endSavePoint);
		}
		enteredModification--;
	}
	return newPos;
}

void Document::EndUndoAction() noexcept {
	cb.EndUndoAction();
	if (UndoSequenceDepth() == 0) {
		// Broadcast notification to views to allow end of group processing.
		// NotifyGroupCompleted may throw (for memory exhaustion) but this method
		// may not as it is called in UndoGroup destructor so ignore exception.
		try {
			NotifyGroupCompleted();
		} catch (...) {
			// Ignore any exception
		}
	}
}

int Document::UndoSequenceDepth() const noexcept {
	return cb.UndoSequenceDepth();
}

void Document::DelChar(Sci::Position pos) {
	DeleteChars(pos, LenChar(pos));
}

void Document::DelCharBack(Sci::Position pos) {
	if (pos <= 0) {
		return;
	} else if (IsCrLf(pos - 2)) {
		DeleteChars(pos - 2, 2);
	} else if (dbcsCodePage) {
		const Sci::Position startChar = NextPosition(pos, -1);
		DeleteChars(startChar, pos - startChar);
	} else {
		DeleteChars(pos - 1, 1);
	}
}

int SCI_METHOD Document::GetLineIndentation(Sci_Position line) {
	int indent = 0;
	if ((line >= 0) && (line < LinesTotal())) {
		const Sci::Position lineStart = LineStart(line);
		const Sci::Position length = Length();
		for (Sci::Position i = lineStart; i < length; i++) {
			const char ch = cb.CharAt(i);
			if (ch == ' ')
				indent++;
			else if (ch == '\t')
				indent = static_cast<int>(NextTab(indent, tabInChars));
			else
				return indent;
		}
	}
	return indent;
}

Sci::Position Document::SetLineIndentation(Sci::Line line, Sci::Position indent) {
	const int indentOfLine = GetLineIndentation(line);
	if (indent < 0)
		indent = 0;
	if (indent != indentOfLine) {
		const std::string linebuf = CreateIndentation(indent, tabInChars, !useTabs);
		const Sci::Position thisLineStart = LineStart(line);
		const Sci::Position indentPos = GetLineIndentPosition(line);
		UndoGroup ug(this);
		DeleteChars(thisLineStart, indentPos - thisLineStart);
		return thisLineStart + InsertString(thisLineStart, linebuf);
	} else {
		return GetLineIndentPosition(line);
	}
}

Sci::Position Document::GetLineIndentPosition(Sci::Line line) const {
	if (line < 0)
		return 0;
	Sci::Position pos = LineStart(line);
	const Sci::Position length = Length();
	while ((pos < length) && IsSpaceOrTab(cb.CharAt(pos))) {
		pos++;
	}
	return pos;
}

Sci::Position Document::GetColumn(Sci::Position pos) const {
	Sci::Position column = 0;
	const Sci::Line line = SciLineFromPosition(pos);
	if ((line >= 0) && (line < LinesTotal())) {
		for (Sci::Position i = LineStart(line); i < pos;) {
			const char ch = cb.CharAt(i);
			if (ch == '\t') {
				column = NextTab(column, tabInChars);
				i++;
			} else if (ch == '\r') {
				return column;
			} else if (ch == '\n') {
				return column;
			} else if (i >= Length()) {
				return column;
			} else if (UTF8IsAscii(ch)) {
				column++;
				i++;
			} else {
				column++;
				i = NextPosition(i, 1);
			}
		}
	}
	return column;
}

Sci::Position Document::CountCharacters(Sci::Position startPos, Sci::Position endPos) const noexcept {
	startPos = MovePositionOutsideChar(startPos, 1, false);
	endPos = MovePositionOutsideChar(endPos, -1, false);
	Sci::Position count = 0;
	Sci::Position i = startPos;
	while (i < endPos) {
		count++;
		i = NextPosition(i, 1);
	}
	return count;
}

Sci::Position Document::CountUTF16(Sci::Position startPos, Sci::Position endPos) const noexcept {
	startPos = MovePositionOutsideChar(startPos, 1, false);
	endPos = MovePositionOutsideChar(endPos, -1, false);
	Sci::Position count = 0;
	Sci::Position i = startPos;
	while (i < endPos) {
		count++;
		const Sci::Position next = NextPosition(i, 1);
		if ((next - i) > 3)
			count++;
		i = next;
	}
	return count;
}

Sci::Position Document::FindColumn(Sci::Line line, Sci::Position column) {
	Sci::Position position = LineStart(line);
	if ((line >= 0) && (line < LinesTotal())) {
		Sci::Position columnCurrent = 0;
		while ((columnCurrent < column) && (position < Length())) {
			const char ch = cb.CharAt(position);
			if (ch == '\t') {
				columnCurrent = NextTab(columnCurrent, tabInChars);
				if (columnCurrent > column)
					return position;
				position++;
			} else if (ch == '\r') {
				return position;
			} else if (ch == '\n') {
				return position;
			} else {
				columnCurrent++;
				position = NextPosition(position, 1);
			}
		}
	}
	return position;
}

void Document::Indent(bool forwards, Sci::Line lineBottom, Sci::Line lineTop) {
	// Dedent - suck white space off the front of the line to dedent by equivalent of a tab
	for (Sci::Line line = lineBottom; line >= lineTop; line--) {
		const Sci::Position indentOfLine = GetLineIndentation(line);
		if (forwards) {
			if (LineStart(line) < LineEnd(line)) {
				SetLineIndentation(line, indentOfLine + IndentSize());
			}
		} else {
			SetLineIndentation(line, indentOfLine - IndentSize());
		}
	}
}

namespace {

constexpr std::string_view EOLForMode(EndOfLine eolMode) noexcept {
	switch (eolMode) {
	case EndOfLine::CrLf:
		return "\r\n";
	case EndOfLine::Cr:
		return "\r";
	default:
		return "\n";
	}
}

}

// Convert line endings for a piece of text to a particular mode.
// Stop at len or when a NUL is found.
std::string Document::TransformLineEnds(const char *s, size_t len, EndOfLine eolModeWanted) {
	std::string dest;
	const std::string_view eol = EOLForMode(eolModeWanted);
	for (size_t i = 0; (i < len) && (s[i]); i++) {
		if (s[i] == '\n' || s[i] == '\r') {
			dest.append(eol);
			if ((s[i] == '\r') && (i+1 < len) && (s[i+1] == '\n')) {
				i++;
			}
		} else {
			dest.push_back(s[i]);
		}
	}
	return dest;
}

void Document::ConvertLineEnds(EndOfLine eolModeSet) {
	UndoGroup ug(this);

	for (Sci::Position pos = 0; pos < Length(); pos++) {
		const char ch = cb.CharAt(pos);
		if (ch == '\r') {
			if (cb.CharAt(pos + 1) == '\n') {
				// CRLF
				if (eolModeSet == EndOfLine::Cr) {
					DeleteChars(pos + 1, 1); // Delete the LF
				} else if (eolModeSet == EndOfLine::Lf) {
					DeleteChars(pos, 1); // Delete the CR
				} else {
					pos++;
				}
			} else {
				// CR
				if (eolModeSet == EndOfLine::CrLf) {
					pos += InsertString(pos + 1, "\n", 1); // Insert LF
				} else if (eolModeSet == EndOfLine::Lf) {
					pos += InsertString(pos, "\n", 1); // Insert LF
					DeleteChars(pos, 1); // Delete CR
					pos--;
				}
			}
		} else if (ch == '\n') {
			// LF
			if (eolModeSet == EndOfLine::CrLf) {
				pos += InsertString(pos, "\r", 1); // Insert CR
			} else if (eolModeSet == EndOfLine::Cr) {
				pos += InsertString(pos, "\r", 1); // Insert CR
				DeleteChars(pos, 1); // Delete LF
				pos--;
			}
		}
	}

}

std::string_view Document::EOLString() const noexcept {
	return EOLForMode(eolMode);
}

DocumentOption Document::Options() const noexcept {
	return (IsLarge() ? DocumentOption::TextLarge : DocumentOption::Default) |
		(cb.HasStyles() ? DocumentOption::Default : DocumentOption::StylesNone);
}

bool Document::IsWhiteLine(Sci::Line line) const {
	Sci::Position currentChar = LineStart(line);
	const Sci::Position endLine = LineEnd(line);
	while (currentChar < endLine) {
		if (!IsSpaceOrTab(cb.CharAt(currentChar))) {
			return false;
		}
		++currentChar;
	}
	return true;
}

Sci::Position Document::ParaUp(Sci::Position pos) const {
	Sci::Line line = SciLineFromPosition(pos);
	const Sci::Position start = LineStart(line);
	if (pos == start) {
		line--;
	}
	while (line >= 0 && IsWhiteLine(line)) { // skip empty lines
		line--;
	}
	while (line >= 0 && !IsWhiteLine(line)) { // skip non-empty lines
		line--;
	}
	line++;
	return LineStart(line);
}

Sci::Position Document::ParaDown(Sci::Position pos) const {
	Sci::Line line = SciLineFromPosition(pos);
	while (line < LinesTotal() && !IsWhiteLine(line)) { // skip non-empty lines
		line++;
	}
	while (line < LinesTotal() && IsWhiteLine(line)) { // skip empty lines
		line++;
	}
	if (line < LinesTotal())
		return LineStart(line);
	else // end of a document
		return LineEnd(line-1);
}

CharacterClass Document::WordCharacterClass(unsigned int ch) const {
	if (dbcsCodePage && (ch >= 0x80)) {
		if (CpUtf8 == dbcsCodePage) {
			// Use hard coded Unicode class
			const CharacterCategory cc = charMap.CategoryFor(ch);
			switch (cc) {

				// Separator, Line/Paragraph
			case ccZl:
			case ccZp:
				return CharacterClass::newLine;

				// Separator, Space
			case ccZs:
				// Other
			case ccCc:
			case ccCf:
			case ccCs:
			case ccCo:
			case ccCn:
				return CharacterClass::space;

				// Letter
			case ccLu:
			case ccLl:
			case ccLt:
			case ccLm:
			case ccLo:
				// Number
			case ccNd:
			case ccNl:
			case ccNo:
				// Mark - includes combining diacritics
			case ccMn:
			case ccMc:
			case ccMe:
				return CharacterClass::word;

				// Punctuation
			case ccPc:
			case ccPd:
			case ccPs:
			case ccPe:
			case ccPi:
			case ccPf:
			case ccPo:
				// Symbol
			case ccSm:
			case ccSc:
			case ccSk:
			case ccSo:
				return CharacterClass::punctuation;

			}
		} else {
			// Asian DBCS
			return CharacterClass::word;
		}
	}
	return charClass.GetClass(static_cast<unsigned char>(ch));
}

/**
 * Used by commands that want to select whole words.
 * Finds the start of word at pos when delta < 0 or the end of the word when delta >= 0.
 */
Sci::Position Document::ExtendWordSelect(Sci::Position pos, int delta, bool onlyWordCharacters) const {
	CharacterClass ccStart = CharacterClass::word;
	if (delta < 0) {
		if (!onlyWordCharacters) {
			const CharacterExtracted ce = CharacterBefore(pos);
			ccStart = WordCharacterClass(ce.character);
		}
		while (pos > 0) {
			const CharacterExtracted ce = CharacterBefore(pos);
			if (WordCharacterClass(ce.character) != ccStart)
				break;
			pos -= ce.widthBytes;
		}
	} else {
		if (!onlyWordCharacters && pos < LengthNoExcept()) {
			const CharacterExtracted ce = CharacterAfter(pos);
			ccStart = WordCharacterClass(ce.character);
		}
		while (pos < LengthNoExcept()) {
			const CharacterExtracted ce = CharacterAfter(pos);
			if (WordCharacterClass(ce.character) != ccStart)
				break;
			pos += ce.widthBytes;
		}
	}
	return MovePositionOutsideChar(pos, delta, true);
}

/**
 * Find the start of the next word in either a forward (delta >= 0) or backwards direction
 * (delta < 0).
 * This is looking for a transition between character classes although there is also some
 * additional movement to transit white space.
 * Used by cursor movement by word commands.
 */
Sci::Position Document::NextWordStart(Sci::Position pos, int delta) const {
	if (delta < 0) {
		while (pos > 0) {
			const CharacterExtracted ce = CharacterBefore(pos);
			if (WordCharacterClass(ce.character) != CharacterClass::space)
				break;
			pos -= ce.widthBytes;
		}
		if (pos > 0) {
			CharacterExtracted ce = CharacterBefore(pos);
			const CharacterClass ccStart = WordCharacterClass(ce.character);
			while (pos > 0) {
				ce = CharacterBefore(pos);
				if (WordCharacterClass(ce.character) != ccStart)
					break;
				pos -= ce.widthBytes;
			}
		}
	} else {
		CharacterExtracted ce = CharacterAfter(pos);
		const CharacterClass ccStart = WordCharacterClass(ce.character);
		while (pos < LengthNoExcept()) {
			ce = CharacterAfter(pos);
			if (WordCharacterClass(ce.character) != ccStart)
				break;
			pos += ce.widthBytes;
		}
		while (pos < LengthNoExcept()) {
			ce = CharacterAfter(pos);
			if (WordCharacterClass(ce.character) != CharacterClass::space)
				break;
			pos += ce.widthBytes;
		}
	}
	return pos;
}

/**
 * Find the end of the next word in either a forward (delta >= 0) or backwards direction
 * (delta < 0).
 * This is looking for a transition between character classes although there is also some
 * additional movement to transit white space.
 * Used by cursor movement by word commands.
 */
Sci::Position Document::NextWordEnd(Sci::Position pos, int delta) const {
	if (delta < 0) {
		if (pos > 0) {
			CharacterExtracted ce = CharacterBefore(pos);
			const CharacterClass ccStart = WordCharacterClass(ce.character);
			if (ccStart != CharacterClass::space) {
				while (pos > 0) {
					ce = CharacterBefore(pos);
					if (WordCharacterClass(ce.character) != ccStart)
						break;
					pos -= ce.widthBytes;
				}
			}
			while (pos > 0) {
				ce = CharacterBefore(pos);
				if (WordCharacterClass(ce.character) != CharacterClass::space)
					break;
				pos -= ce.widthBytes;
			}
		}
	} else {
		while (pos < LengthNoExcept()) {
			const CharacterExtracted ce = CharacterAfter(pos);
			if (WordCharacterClass(ce.character) != CharacterClass::space)
				break;
			pos += ce.widthBytes;
		}
		if (pos < LengthNoExcept()) {
			CharacterExtracted ce = CharacterAfter(pos);
			const CharacterClass ccStart = WordCharacterClass(ce.character);
			while (pos < LengthNoExcept()) {
				ce = CharacterAfter(pos);
				if (WordCharacterClass(ce.character) != ccStart)
					break;
				pos += ce.widthBytes;
			}
		}
	}
	return pos;
}

namespace {

constexpr bool IsWordEdge(CharacterClass cc, CharacterClass ccNext) noexcept {
	return (cc != ccNext) &&
		(cc == CharacterClass::word || cc == CharacterClass::punctuation);
}

}

/**
 * Check that the character at the given position is a word or punctuation character and that
 * the previous character is of a different character class.
 */
bool Document::IsWordStartAt(Sci::Position pos) const {
	if (pos >= LengthNoExcept())
		return false;
	if (pos >= 0) {
		const CharacterExtracted cePos = CharacterAfter(pos);
		// At start of document, treat as if space before so can be word start
		const CharacterExtracted cePrev = (pos > 0) ?
			CharacterBefore(pos) : CharacterExtracted(' ', 1);
		return IsWordEdge(WordCharacterClass(cePos.character), WordCharacterClass(cePrev.character));
	}
	return true;
}

/**
 * Check that the character before the given position is a word or punctuation character and that
 * the next character is of a different character class.
 */
bool Document::IsWordEndAt(Sci::Position pos) const {
	if (pos <= 0)
		return false;
	if (pos <= LengthNoExcept()) {
		// At end of document, treat as if space after so can be word end
		const CharacterExtracted cePos = (pos < LengthNoExcept()) ?
			CharacterAfter(pos) : CharacterExtracted(' ', 1);
		const CharacterExtracted cePrev = CharacterBefore(pos);
		return IsWordEdge(WordCharacterClass(cePrev.character), WordCharacterClass(cePos.character));
	}
	return true;
}

/**
 * Check that the given range is has transitions between character classes at both
 * ends and where the characters on the inside are word or punctuation characters.
 */
bool Document::IsWordAt(Sci::Position start, Sci::Position end) const {
	return (start < end) && IsWordStartAt(start) && IsWordEndAt(end);
}

bool Document::MatchesWordOptions(bool word, bool wordStart, Sci::Position pos, Sci::Position length) const {
	return (!word && !wordStart) ||
			(word && IsWordAt(pos, pos + length)) ||
			(wordStart && IsWordStartAt(pos));
}

bool Document::HasCaseFolder() const noexcept {
	return pcf != nullptr;
}

void Document::SetCaseFolder(std::unique_ptr<CaseFolder> pcf_) noexcept {
	pcf = std::move(pcf_);
}

CharacterExtracted Document::ExtractCharacter(Sci::Position position) const noexcept {
	const unsigned char leadByte = cb.UCharAt(position);
	if (UTF8IsAscii(leadByte)) {
		// Common case: ASCII character
		return CharacterExtracted(leadByte, 1);
	}
	const int widthCharBytes = UTF8BytesOfLead[leadByte];
	unsigned char charBytes[UTF8MaxBytes] = { leadByte, 0, 0, 0 };
	for (int b=1; b<widthCharBytes; b++)
		charBytes[b] = cb.UCharAt(position + b);
	return CharacterExtracted(charBytes, widthCharBytes);
}

namespace {

// Equivalent of memchr over the split view
ptrdiff_t SplitFindChar(const SplitView &view, size_t start, size_t length, int ch) noexcept {
	size_t range1Length = 0;
	if (start < view.length1) {
		range1Length = std::min(length, view.length1 - start);
		const char *match = static_cast<const char *>(memchr(view.segment1 + start, ch, range1Length));
		if (match) {
			return match - view.segment1;
		}
		start += range1Length;
	}
	const char *match2 = static_cast<const char *>(memchr(view.segment2 + start, ch, length - range1Length));
	if (match2) {
		return match2 - view.segment2;
	}
	return -1;
}

// Equivalent of memcmp over the split view
// This does not call memcmp as search texts are commonly too short to overcome the
// call overhead.
bool SplitMatch(const SplitView &view, size_t start, std::string_view text) noexcept {
	for (size_t i = 0; i < text.length(); i++) {
		if (view.CharAt(i + start) != text[i]) {
			return false;
		}
	}
	return true;
}

}

/**
 * Find text in document, supporting both forward and backward
 * searches (just pass minPos > maxPos to do a backward search)
 * Has not been tested with backwards DBCS searches yet.
 */
Sci::Position Document::FindText(Sci::Position minPos, Sci::Position maxPos, const char *search,
                        FindOption flags, Sci::Position *length) {
	if (*length <= 0)
		return minPos;
	const bool caseSensitive = FlagSet(flags, FindOption::MatchCase);
	const bool word = FlagSet(flags, FindOption::WholeWord);
	const bool wordStart = FlagSet(flags, FindOption::WordStart);
	const bool regExp = FlagSet(flags, FindOption::RegExp);
	if (regExp) {
		if (!regex)
			regex = std::unique_ptr<RegexSearchBase>(CreateRegexSearch(&charClass));
		return regex->FindText(this, minPos, maxPos, search, caseSensitive, word, wordStart, flags, length);
	} else {

		const bool forward = minPos <= maxPos;
		const int increment = forward ? 1 : -1;

		// Range endpoints should not be inside DBCS characters, but just in case, move them.
		const Sci::Position startPos = MovePositionOutsideChar(minPos, increment, false);
		const Sci::Position endPos = MovePositionOutsideChar(maxPos, increment, false);

		// Compute actual search ranges needed
		const Sci::Position lengthFind = *length;

		//Platform::DebugPrintf("Find %d %d %s %d\n", startPos, endPos, ft->lpstrText, lengthFind);
		const Sci::Position limitPos = std::max(startPos, endPos);
		Sci::Position pos = startPos;
		if (!forward) {
			// Back all of a character
			pos = NextPosition(pos, increment);
		}
		const SplitView cbView = cb.AllView();
		if (caseSensitive) {
			const Sci::Position endSearch = (startPos <= endPos) ? endPos - lengthFind + 1 : endPos;
			const unsigned char charStartSearch =  search[0];
			if (forward && ((0 == dbcsCodePage) || (CpUtf8 == dbcsCodePage && !UTF8IsTrailByte(charStartSearch)))) {
				// This is a fast case where there is no need to test byte values to iterate
				// so becomes the equivalent of a memchr+memcmp loop.
				// UTF-8 search will not be self-synchronizing when starts with trail byte
				const std::string_view suffix(search + 1, lengthFind - 1);
				while (pos < endSearch) {
					pos = SplitFindChar(cbView, pos, limitPos - pos, charStartSearch);
					if (pos < 0) {
						break;
					}
					if (SplitMatch(cbView, pos + 1, suffix) && MatchesWordOptions(word, wordStart, pos, lengthFind)) {
						return pos;
					}
					pos++;
				}
			} else {
				while (forward ? (pos < endSearch) : (pos >= endSearch)) {
					const unsigned char leadByte = cbView.CharAt(pos);
					if (leadByte == charStartSearch) {
						bool found = (pos + lengthFind) <= limitPos;
						// SplitMatch could be called here but it is slower with g++ -O2
						for (int indexSearch = 1; (indexSearch < lengthFind) && found; indexSearch++) {
							found = cbView.CharAt(pos + indexSearch) == search[indexSearch];
						}
						if (found && MatchesWordOptions(word, wordStart, pos, lengthFind)) {
							return pos;
						}
					}
					if (forward && UTF8IsAscii(leadByte)) {
						pos++;
					} else {
						if (dbcsCodePage) {
							if (!NextCharacter(pos, increment)) {
								break;
							}
						} else {
							pos += increment;
						}
					}
				}
			}
		} else if (CpUtf8 == dbcsCodePage) {
			constexpr size_t maxFoldingExpansion = 4;
			std::vector<char> searchThing((lengthFind+1) * UTF8MaxBytes * maxFoldingExpansion + 1);
			const size_t lenSearch =
				pcf->Fold(searchThing.data(), searchThing.size(), search, lengthFind);
			while (forward ? (pos < endPos) : (pos >= endPos)) {
				int widthFirstCharacter = 1;
				Sci::Position posIndexDocument = pos;
				size_t indexSearch = 0;
				bool characterMatches = true;
				while (indexSearch < lenSearch) {
					const unsigned char leadByte = cbView.CharAt(posIndexDocument);
					int widthChar = 1;
					size_t lenFlat = 1;
					if (UTF8IsAscii(leadByte)) {
						if ((posIndexDocument + 1) > limitPos) {
							break;
						}
						characterMatches = searchThing[indexSearch] == MakeLowerCase(leadByte);
					} else {
						char bytes[UTF8MaxBytes]{ static_cast<char>(leadByte) };
						const int widthCharBytes = UTF8BytesOfLead[leadByte];
						for (int b = 1; b < widthCharBytes; b++) {
							bytes[b] = cbView.CharAt(posIndexDocument + b);
						}
						widthChar = UTF8Classify(bytes, widthCharBytes) & UTF8MaskWidth;
						if (!indexSearch) {	// First character
							widthFirstCharacter = widthChar;
						}
						if ((posIndexDocument + widthChar) > limitPos) {
							break;
						}
						char folded[UTF8MaxBytes * maxFoldingExpansion + 1];
						lenFlat = pcf->Fold(folded, sizeof(folded), bytes, widthChar);
						// memcmp may examine lenFlat bytes in both arguments so assert it doesn't read past end of searchThing
						assert((indexSearch + lenFlat) <= searchThing.size());
						// Does folded match the buffer
						characterMatches = 0 == memcmp(folded, searchThing.data() + indexSearch, lenFlat);
					}
					if (!characterMatches) {
						break;
					}
					posIndexDocument += widthChar;
					indexSearch += lenFlat;
				}
				if (characterMatches && (indexSearch == lenSearch)) {
					if (MatchesWordOptions(word, wordStart, pos, posIndexDocument - pos)) {
						*length = posIndexDocument - pos;
						return pos;
					}
				}
				if (forward) {
					pos += widthFirstCharacter;
				} else {
					if (!NextCharacter(pos, increment)) {
						break;
					}
				}
			}
		} else if (dbcsCodePage) {
			constexpr size_t maxBytesCharacter = 2;
			constexpr size_t maxFoldingExpansion = 4;
			std::vector<char> searchThing((lengthFind+1) * maxBytesCharacter * maxFoldingExpansion + 1);
			const size_t lenSearch = pcf->Fold(searchThing.data(), searchThing.size(), search, lengthFind);
			while (forward ? (pos < endPos) : (pos >= endPos)) {
				int widthFirstCharacter = 0;
				Sci::Position indexDocument = 0;
				size_t indexSearch = 0;
				bool characterMatches = true;
				while (((pos + indexDocument) < limitPos) &&
					(indexSearch < lenSearch)) {
					const unsigned char leadByte = cbView.CharAt(pos + indexDocument);
					const int widthChar = (!UTF8IsAscii(leadByte) && IsDBCSLeadByteNoExcept(leadByte)) ? 2 : 1;
					if (!widthFirstCharacter) {
						widthFirstCharacter = widthChar;
					}
					if ((pos + indexDocument + widthChar) > limitPos) {
						break;
					}
					size_t lenFlat = 1;
					if (widthChar == 1) {
						characterMatches = searchThing[indexSearch] == MakeLowerCase(leadByte);
					} else {
						const char bytes[maxBytesCharacter + 1] {
							static_cast<char>(leadByte),
							cbView.CharAt(pos + indexDocument + 1)
						};
						char folded[maxBytesCharacter * maxFoldingExpansion + 1];
						lenFlat = pcf->Fold(folded, sizeof(folded), bytes, widthChar);
						// memcmp may examine lenFlat bytes in both arguments so assert it doesn't read past end of searchThing
						assert((indexSearch + lenFlat) <= searchThing.size());
						// Does folded match the buffer
						characterMatches = 0 == memcmp(folded, searchThing.data() + indexSearch, lenFlat);
					}
					if (!characterMatches) {
						break;
					}
					indexDocument += widthChar;
					indexSearch += lenFlat;
				}
				if (characterMatches && (indexSearch == lenSearch)) {
					if (MatchesWordOptions(word, wordStart, pos, indexDocument)) {
						*length = indexDocument;
						return pos;
					}
				}
				if (forward) {
					pos += widthFirstCharacter;
				} else {
					if (!NextCharacter(pos, increment)) {
						break;
					}
				}
			}
		} else {
			const Sci::Position endSearch = (startPos <= endPos) ? endPos - lengthFind + 1 : endPos;
			std::vector<char> searchThing(lengthFind + 1);
			pcf->Fold(searchThing.data(), searchThing.size(), search, lengthFind);
			while (forward ? (pos < endSearch) : (pos >= endSearch)) {
				bool found = (pos + lengthFind) <= limitPos;
				for (int indexSearch = 0; (indexSearch < lengthFind) && found; indexSearch++) {
					const char ch = cbView.CharAt(pos + indexSearch);
					const char chTest = searchThing[indexSearch];
					if (UTF8IsAscii(ch)) {
						found = chTest == MakeLowerCase(ch);
					} else {
						char folded[2];
						pcf->Fold(folded, sizeof(folded), &ch, 1);
						found = folded[0] == chTest;
					}
				}
				if (found && MatchesWordOptions(word, wordStart, pos, lengthFind)) {
					return pos;
				}
				pos += increment;
			}
		}
	}
	//Platform::DebugPrintf("Not found\n");
	return -1;
}

const char *Document::SubstituteByPosition(const char *text, Sci::Position *length) {
	if (regex) {
		return regex->SubstituteByPosition(this, text, length);
	}
	return nullptr;
}

LineCharacterIndexType Document::LineCharacterIndex() const noexcept {
	return cb.LineCharacterIndex();
}

void Document::AllocateLineCharacterIndex(LineCharacterIndexType lineCharacterIndex) {
	cb.AllocateLineCharacterIndex(lineCharacterIndex);
}

void Document::ReleaseLineCharacterIndex(LineCharacterIndexType lineCharacterIndex) {
	cb.ReleaseLineCharacterIndex(lineCharacterIndex);
}

Sci::Line Document::LinesTotal() const noexcept {
	return cb.Lines();
}

void Document::AllocateLines(Sci::Line lines) {
	cb.AllocateLines(lines);
}

void Document::SetDefaultCharClasses(bool includeWordClass) {
	charClass.SetDefaultCharClasses(includeWordClass);
}

void Document::SetCharClasses(const unsigned char *chars, CharacterClass newCharClass) {
	charClass.SetCharClasses(chars, newCharClass);
}

int Document::GetCharsOfClass(CharacterClass characterClass, unsigned char *buffer) const {
	return charClass.GetCharsOfClass(characterClass, buffer);
}

void Document::SetCharacterCategoryOptimization(int countCharacters) {
	charMap.Optimize(countCharacters);
}

int Document::CharacterCategoryOptimization() const noexcept {
	return charMap.Size();
}

void SCI_METHOD Document::StartStyling(Sci_Position position) {
	endStyled = position;
}

bool SCI_METHOD Document::SetStyleFor(Sci_Position length, char style) {
	if (enteredStyling != 0) {
		return false;
	}
	enteredStyling++;
	const Sci::Position prevEndStyled = endStyled;
	if (cb.SetStyleFor(endStyled, length, style)) {
		const DocModification mh(ModificationFlags::ChangeStyle | ModificationFlags::User,
			                prevEndStyled, length);
		NotifyModified(mh);
	}
	endStyled += length;
	enteredStyling--;
	return true;
}

bool SCI_METHOD Document::SetStyles(Sci_Position length, const char *styles) {
	if (enteredStyling != 0) {
		return false;
	}
	enteredStyling++;
	bool didChange = false;
	Sci::Position startMod = 0;
	Sci::Position endMod = 0;
	for (int iPos = 0; iPos < length; iPos++, endStyled++) {
		PLATFORM_ASSERT(endStyled < Length());
		if (cb.SetStyleAt(endStyled, styles[iPos])) {
			if (!didChange) {
				startMod = endStyled;
			}
			didChange = true;
			endMod = endStyled;
		}
	}
	if (didChange) {
		const DocModification mh(ModificationFlags::ChangeStyle | ModificationFlags::User,
			                startMod, endMod - startMod + 1);
		NotifyModified(mh);
	}
	enteredStyling--;
	return true;
}

void Document::EnsureStyledTo(Sci::Position pos) {
	if ((enteredStyling == 0) && (pos > GetEndStyled())) {
		IncrementStyleClock();
		if (pli && !pli->UseContainerLexing()) {
			const Sci::Position endStyledTo = LineStartPosition(GetEndStyled());
			pli->Colourise(endStyledTo, pos);
		} else {
			// Ask the watchers to style, and stop as soon as one responds.
			for (std::vector<WatcherWithUserData>::iterator it = watchers.begin();
				(pos > GetEndStyled()) && (it != watchers.end()); ++it) {
				it->watcher->NotifyStyleNeeded(this, it->userData, pos);
			}
		}
	}
}

void Document::StyleToAdjustingLineDuration(Sci::Position pos) {
	const Sci::Position stylingStart = GetEndStyled();
	ElapsedPeriod epStyling;
	EnsureStyledTo(pos);
	durationStyleOneByte.AddSample(pos - stylingStart, epStyling.Duration());
}

LexInterface *Document::GetLexInterface() const noexcept {
	return pli.get();
}

void Document::SetLexInterface(std::unique_ptr<LexInterface> pLexInterface) noexcept {
	pli = std::move(pLexInterface);
}

void Document::SetViewState(void *view, ViewStateShared pVSS) {
	if (pVSS) {
		viewData[view] = std::move(pVSS);
	} else {
		viewData.erase(view);
	}
}

ViewStateShared Document::GetViewState(void *view) const noexcept {
	try {
		const std::map<void *, ViewStateShared>::const_iterator it = viewData.find(view);

		if (it != viewData.end()) {
			return it->second;
		}
	} catch (...) {
	}
	return {};
}

void Document::TruncateUndoComments(int action) {
	for (auto &[key, value] : viewData) {
		value->TruncateUndo(action);
	}
}

int SCI_METHOD Document::SetLineState(Sci_Position line, int state) {
	const int statePrevious = States()->SetLineState(line, state, LinesTotal());
	if (state != statePrevious) {
		const DocModification mh(ModificationFlags::ChangeLineState, LineStart(line), 0, 0, nullptr,
			static_cast<Sci::Line>(line));
		NotifyModified(mh);
	}
	return statePrevious;
}

int SCI_METHOD Document::GetLineState(Sci_Position line) const {
	return States()->GetLineState(line);
}

Sci::Line Document::GetMaxLineState() const noexcept {
	return States()->GetMaxLineState();
}

void SCI_METHOD Document::ChangeLexerState(Sci_Position start, Sci_Position end) {
	const DocModification mh(ModificationFlags::LexerState, start,
		end-start, 0, nullptr, 0);
	NotifyModified(mh);
}

StyledText Document::MarginStyledText(Sci::Line line) const noexcept {
	const LineAnnotation *pla = Margins();
	return StyledText(pla->Length(line), pla->Text(line),
		pla->MultipleStyles(line), pla->Style(line), pla->Styles(line));
}

//Au: new function
Sci::Line Document::MarginStyledTextNext(Sci::Line line, int style) {
	if(line < 0) return 0;
	const LineAnnotation* pla = Margins();
	auto lt = LinesTotal();
	for(; line < lt; line++) if(pla->Style(line) == style) return line;
	return -1;
	//info: this is 10 times faster than repeatedly calling SCI_MARGINGETSTYLE
}

void Document::MarginSetText(Sci::Line line, const char *text) {
	Margins()->SetText(line, text);
	const DocModification mh(ModificationFlags::ChangeMargin, LineStart(line),
		0, 0, nullptr, line);
	NotifyModified(mh);
}

void Document::MarginSetStyle(Sci::Line line, int style) {
	Margins()->SetStyle(line, style);
	NotifyModified(DocModification(ModificationFlags::ChangeMargin, LineStart(line),
		0, 0, nullptr, line));
}

void Document::MarginSetStyles(Sci::Line line, const unsigned char *styles) {
	Margins()->SetStyles(line, styles);
	NotifyModified(DocModification(ModificationFlags::ChangeMargin, LineStart(line),
		0, 0, nullptr, line));
}

void Document::MarginClearAll() {
	const Sci::Line maxEditorLine = LinesTotal();
	for (Sci::Line l=0; l<maxEditorLine; l++)
		MarginSetText(l, nullptr);
	// Free remaining data
	Margins()->ClearAll();
}

StyledText Document::AnnotationStyledText(Sci::Line line) const noexcept {
	const LineAnnotation *pla = Annotations();
	return StyledText(pla->Length(line), pla->Text(line),
		pla->MultipleStyles(line), pla->Style(line), pla->Styles(line));
}

void Document::AnnotationSetText(Sci::Line line, const char *text) {
	if (line >= 0 && line < LinesTotal()) {
		const Sci::Line linesBefore = AnnotationLines(line);
		Annotations()->SetText(line, text);
		const int linesAfter = AnnotationLines(line);
		DocModification mh(ModificationFlags::ChangeAnnotation, LineStart(line),
			0, 0, nullptr, line);
		mh.annotationLinesAdded = linesAfter - linesBefore;
		NotifyModified(mh);
	}
}

void Document::AnnotationSetStyle(Sci::Line line, int style) {
	if (line >= 0 && line < LinesTotal()) {
		Annotations()->SetStyle(line, style);
		const DocModification mh(ModificationFlags::ChangeAnnotation, LineStart(line),
			0, 0, nullptr, line);
		NotifyModified(mh);
	}
}

void Document::AnnotationSetStyles(Sci::Line line, const unsigned char *styles) {
	if (line >= 0 && line < LinesTotal()) {
		Annotations()->SetStyles(line, styles);
	}
}

int Document::AnnotationLines(Sci::Line line) const noexcept {
	return Annotations()->Lines(line);
}

void Document::AnnotationClearAll() {
	if (Annotations()->Empty()) {
		return;
	}
	const Sci::Line maxEditorLine = LinesTotal();
	for (Sci::Line l=0; l<maxEditorLine; l++)
		AnnotationSetText(l, nullptr);
	// Free remaining data
	Annotations()->ClearAll();
}

StyledText Document::EOLAnnotationStyledText(Sci::Line line) const noexcept {
	const LineAnnotation *pla = EOLAnnotations();
	return StyledText(pla->Length(line), pla->Text(line),
		pla->MultipleStyles(line), pla->Style(line), pla->Styles(line));
}

void Document::EOLAnnotationSetText(Sci::Line line, const char *text) {
	if (line >= 0 && line < LinesTotal()) {
		EOLAnnotations()->SetText(line, text);
		const DocModification mh(ModificationFlags::ChangeEOLAnnotation, LineStart(line),
			0, 0, nullptr, line);
		NotifyModified(mh);
	}
}

void Document::EOLAnnotationSetStyle(Sci::Line line, int style) {
	if (line >= 0 && line < LinesTotal()) {
		EOLAnnotations()->SetStyle(line, style);
		const DocModification mh(ModificationFlags::ChangeEOLAnnotation, LineStart(line),
			0, 0, nullptr, line);
		NotifyModified(mh);
	}
}

void Document::EOLAnnotationClearAll() {
	if (EOLAnnotations()->Empty()) {
		return;
	}
	const Sci::Line maxEditorLine = LinesTotal();
	for (Sci::Line l=0; l<maxEditorLine; l++)
		EOLAnnotationSetText(l, nullptr);
	// Free remaining data
	EOLAnnotations()->ClearAll();
}

void Document::IncrementStyleClock() noexcept {
	styleClock = (styleClock + 1) % 0x100000;
}

void SCI_METHOD Document::DecorationSetCurrentIndicator(int indicator) {
	decorations->SetCurrentIndicator(indicator);
}

void SCI_METHOD Document::DecorationFillRange(Sci_Position position, int value, Sci_Position fillLength) {
	const FillResult<Sci::Position> fr = decorations->FillRange(
		position, value, fillLength);
	if (fr.changed) {
		const DocModification mh(ModificationFlags::ChangeIndicator | ModificationFlags::User,
							fr.position, fr.fillLength);
		NotifyModified(mh);
	}
}

bool Document::AddWatcher(DocWatcher *watcher, void *userData) {
	const WatcherWithUserData wwud(watcher, userData);
	std::vector<WatcherWithUserData>::iterator it =
		std::find(watchers.begin(), watchers.end(), wwud);
	if (it != watchers.end())
		return false;
	watchers.push_back(wwud);
	return true;
}

bool Document::RemoveWatcher(DocWatcher *watcher, void *userData) noexcept {
	try {
		// This can never fail as WatcherWithUserData constructor and == are noexcept
		// but std::find is not noexcept.
		std::vector<WatcherWithUserData>::iterator it =
			std::find(watchers.begin(), watchers.end(), WatcherWithUserData(watcher, userData));
		if (it != watchers.end()) {
			watchers.erase(it);
			return true;
		}
	} catch (...) {
		// Ignore any exception
	}
	return false;
}

void Document::NotifyModifyAttempt() {
	for (const WatcherWithUserData &watcher : watchers) {
		watcher.watcher->NotifyModifyAttempt(this, watcher.userData);
	}
}

void Document::NotifySavePoint(bool atSavePoint) {
	for (const WatcherWithUserData &watcher : watchers) {
		watcher.watcher->NotifySavePoint(this, watcher.userData, atSavePoint);
	}
}

void Document::NotifyGroupCompleted() noexcept {
	for (const WatcherWithUserData &watcher : watchers) {
		watcher.watcher->NotifyGroupCompleted(this, watcher.userData);
	}
}

void Document::NotifyModified(DocModification mh) {
	if (FlagSet(mh.modificationType, ModificationFlags::InsertText)) {
		decorations->InsertSpace(mh.position, mh.length);
	} else if (FlagSet(mh.modificationType, ModificationFlags::DeleteText)) {
		decorations->DeleteRange(mh.position, mh.length);
	}
	for (const WatcherWithUserData &watcher : watchers) {
		watcher.watcher->NotifyModified(this, mh, watcher.userData);
	}
}

bool Document::IsWordPartSeparator(unsigned int ch) const {
	return (WordCharacterClass(ch) == CharacterClass::word) && IsPunctuation(ch);
}

Sci::Position Document::WordPartLeft(Sci::Position pos) const {
	if (pos > 0) {
		pos -= CharacterBefore(pos).widthBytes;
		CharacterExtracted ceStart = CharacterAfter(pos);
		if (IsWordPartSeparator(ceStart.character)) {
			while (pos > 0 && IsWordPartSeparator(CharacterAfter(pos).character)) {
				pos -= CharacterBefore(pos).widthBytes;
			}
		}
		if (pos > 0) {
			ceStart = CharacterAfter(pos);
			pos -= CharacterBefore(pos).widthBytes;
			if (IsLowerCase(ceStart.character)) {
				while (pos > 0 && IsLowerCase(CharacterAfter(pos).character))
					pos -= CharacterBefore(pos).widthBytes;
				if (!IsUpperCase(CharacterAfter(pos).character) && !IsLowerCase(CharacterAfter(pos).character))
					pos += CharacterAfter(pos).widthBytes;
			} else if (IsUpperCase(ceStart.character)) {
				while (pos > 0 && IsUpperCase(CharacterAfter(pos).character))
					pos -= CharacterBefore(pos).widthBytes;
				if (!IsUpperCase(CharacterAfter(pos).character))
					pos += CharacterAfter(pos).widthBytes;
			} else if (IsADigit(ceStart.character)) {
				while (pos > 0 && IsADigit(CharacterAfter(pos).character))
					pos -= CharacterBefore(pos).widthBytes;
				if (!IsADigit(CharacterAfter(pos).character))
					pos += CharacterAfter(pos).widthBytes;
			} else if (IsPunctuation(ceStart.character)) {
				while (pos > 0 && IsPunctuation(CharacterAfter(pos).character))
					pos -= CharacterBefore(pos).widthBytes;
				if (!IsPunctuation(CharacterAfter(pos).character))
					pos += CharacterAfter(pos).widthBytes;
			} else if (IsASpace(ceStart.character)) {
				while (pos > 0 && IsASpace(CharacterAfter(pos).character))
					pos -= CharacterBefore(pos).widthBytes;
				if (!IsASpace(CharacterAfter(pos).character))
					pos += CharacterAfter(pos).widthBytes;
			} else if (!IsASCII(ceStart.character)) {
				while (pos > 0 && !IsASCII(CharacterAfter(pos).character))
					pos -= CharacterBefore(pos).widthBytes;
				if (IsASCII(CharacterAfter(pos).character))
					pos += CharacterAfter(pos).widthBytes;
			} else {
				pos += CharacterAfter(pos).widthBytes;
			}
		}
	}
	return pos;
}

Sci::Position Document::WordPartRight(Sci::Position pos) const {
	CharacterExtracted ceStart = CharacterAfter(pos);
	const Sci::Position length = LengthNoExcept();
	if (IsWordPartSeparator(ceStart.character)) {
		while (pos < length && IsWordPartSeparator(CharacterAfter(pos).character))
			pos += CharacterAfter(pos).widthBytes;
		ceStart = CharacterAfter(pos);
	}
	if (!IsASCII(ceStart.character)) {
		while (pos < length && !IsASCII(CharacterAfter(pos).character))
			pos += CharacterAfter(pos).widthBytes;
	} else if (IsLowerCase(ceStart.character)) {
		while (pos < length && IsLowerCase(CharacterAfter(pos).character))
			pos += CharacterAfter(pos).widthBytes;
	} else if (IsUpperCase(ceStart.character)) {
		if (IsLowerCase(CharacterAfter(pos + ceStart.widthBytes).character)) {
			pos += CharacterAfter(pos).widthBytes;
			while (pos < length && IsLowerCase(CharacterAfter(pos).character))
				pos += CharacterAfter(pos).widthBytes;
		} else {
			while (pos < length && IsUpperCase(CharacterAfter(pos).character))
				pos += CharacterAfter(pos).widthBytes;
		}
		if (IsLowerCase(CharacterAfter(pos).character) && IsUpperCase(CharacterBefore(pos).character))
			pos -= CharacterBefore(pos).widthBytes;
	} else if (IsADigit(ceStart.character)) {
		while (pos < length && IsADigit(CharacterAfter(pos).character))
			pos += CharacterAfter(pos).widthBytes;
	} else if (IsPunctuation(ceStart.character)) {
		while (pos < length && IsPunctuation(CharacterAfter(pos).character))
			pos += CharacterAfter(pos).widthBytes;
	} else if (IsASpace(ceStart.character)) {
		while (pos < length && IsASpace(CharacterAfter(pos).character))
			pos += CharacterAfter(pos).widthBytes;
	} else {
		pos += CharacterAfter(pos).widthBytes;
	}
	return pos;
}

Sci::Position Document::ExtendStyleRange(Sci::Position pos, int delta, bool singleLine) noexcept {
	const char sStart = cb.StyleAt(pos);
	if (delta < 0) {
		while (pos > 0 && (cb.StyleAt(pos) == sStart) && (!singleLine || !IsEOLCharacter(cb.CharAt(pos))))
			pos--;
		pos++;
	} else {
		while (pos < (LengthNoExcept()) && (cb.StyleAt(pos) == sStart) && (!singleLine || !IsEOLCharacter(cb.CharAt(pos))))
			pos++;
	}
	return pos;
}

namespace {

constexpr char BraceOpposite(char ch) noexcept {
	switch (ch) {
	case '(':
		return ')';
	case ')':
		return '(';
	case '[':
		return ']';
	case ']':
		return '[';
	case '{':
		return '}';
	case '}':
		return '{';
	case '<':
		return '>';
	case '>':
		return '<';
	default:
		return '\0';
	}
}

}

// TODO: should be able to extend styled region to find matching brace
Sci::Position Document::BraceMatch(Sci::Position position, Sci::Position /*maxReStyle*/, Sci::Position startPos, bool useStartPos) noexcept {
	const unsigned char chBrace = CharAt(position);
	const unsigned char chSeek = BraceOpposite(chBrace);
	if (chSeek == '\0')
		return -1;
	const int styBrace = StyleIndexAt(position);
	int direction = -1;
	if (chBrace == '(' || chBrace == '[' || chBrace == '{' || chBrace == '<')
		direction = 1;
	int depth = 1;
	position = useStartPos ? startPos : position + direction;

	// Avoid using MovePositionOutsideChar to check DBCS trail byte
	unsigned char maxSafeChar = 0xff;
	if (dbcsCodePage != 0 && dbcsCodePage != CpUtf8) {
		maxSafeChar = std::max<unsigned char>(DBCSMinTrailByte(), 1) - 1;
	}

	while ((position >= 0) && (position < LengthNoExcept())) {
		const unsigned char chAtPos = CharAt(position);
		if (chAtPos == chBrace || chAtPos == chSeek) {
			if (((position > GetEndStyled()) || (StyleIndexAt(position) == styBrace)) &&
				(chAtPos <= maxSafeChar || position == MovePositionOutsideChar(position, direction, false))) {
				depth += (chAtPos == chBrace) ? 1 : -1;
				if (depth == 0)
					return position;
			}
		}
		position += direction;
	}
	return -1;
}

/**
 * Implementation of RegexSearchBase for the default built-in regular expression engine
 */
class BuiltinRegex : public RegexSearchBase {
public:
	explicit BuiltinRegex(CharClassify *charClassTable) : search(charClassTable) {}

	Sci::Position FindText(Document *doc, Sci::Position minPos, Sci::Position maxPos, const char *s,
                        bool caseSensitive, bool word, bool wordStart, FindOption flags,
                        Sci::Position *length) override;

	const char *SubstituteByPosition(Document *doc, const char *text, Sci::Position *length) override;

private:
	RESearch search;
	std::string substituted;
};

namespace {

/**
* RESearchRange keeps track of search range.
*/
class RESearchRange {
public:
	int increment;
	Sci::Position startPos;
	Sci::Position endPos;
	Sci::Line lineRangeStart;
	Sci::Line lineRangeEnd;
	Sci::Line lineRangeBreak;
	RESearchRange(const Document *doc, Sci::Position minPos, Sci::Position maxPos) noexcept {
		increment = (minPos <= maxPos) ? 1 : -1;

		// Range endpoints should not be inside DBCS characters or between a CR and LF,
		// but just in case, move them.
		startPos = doc->MovePositionOutsideChar(minPos, 1, true);
		endPos = doc->MovePositionOutsideChar(maxPos, 1, true);

		lineRangeStart = doc->SciLineFromPosition(startPos);
		lineRangeEnd = doc->SciLineFromPosition(endPos);
		lineRangeBreak = lineRangeEnd + increment;
	}
	[[nodiscard]] Range LineRange(Sci::Line line, Sci::Position lineStartPos, Sci::Position lineEndPos) const noexcept {
		Range range(lineStartPos, lineEndPos);
		if (increment == 1) {
			if (line == lineRangeStart)
				range.start = startPos;
			if (line == lineRangeEnd)
				range.end = endPos;
		} else {
			if (line == lineRangeEnd)
				range.start = endPos;
			if (line == lineRangeStart)
				range.end = startPos;
		}
		return range;
	}
};

// Define a way for the Regular Expression code to access the document
class DocumentIndexer final : public CharacterIndexer {
	Document *pdoc;
	Sci::Position end;
public:
	DocumentIndexer(Document *pdoc_, Sci::Position end_) noexcept :
		pdoc(pdoc_), end(end_) {
	}

	[[nodiscard]] char CharAt(Sci::Position index) const noexcept override {
		if (index < 0 || index >= end) {
			return 0;
		}
		return pdoc->CharAt(index);
	}
	[[nodiscard]] Sci::Position MovePositionOutsideChar(Sci::Position pos, Sci::Position moveDir) const noexcept override {
		return pdoc->MovePositionOutsideChar(pos, moveDir, false);
	}
};

#ifndef NO_CXX11_REGEX

class ByteIterator {
public:
	using iterator_category = std::bidirectional_iterator_tag;
	using value_type = char;
	using difference_type = ptrdiff_t;
	using pointer = char*;
	using reference = char&;

	const Document *doc;
	Sci::Position position;

	explicit ByteIterator(const Document *doc_=nullptr, Sci::Position position_=0) noexcept :
		doc(doc_), position(position_) {
	}
	char operator*() const noexcept {
		return doc->CharAt(position);
	}
	ByteIterator &operator++() noexcept {
		position++;
		return *this;
	}
	ByteIterator operator++(int) noexcept {
		ByteIterator retVal(*this);
		position++;
		return retVal;
	}
	ByteIterator &operator--() noexcept {
		position--;
		return *this;
	}
	bool operator==(const ByteIterator &other) const noexcept {
		return doc == other.doc && position == other.position;
	}
	bool operator!=(const ByteIterator &other) const noexcept {
		return doc != other.doc || position != other.position;
	}
	[[nodiscard]] Sci::Position Pos() const noexcept {
		return position;
	}
	[[nodiscard]] Sci::Position PosRoundUp() const noexcept {
		return position;
	}
};

// On Windows, wchar_t is 16 bits wide and on Unix it is 32 bits wide.
// Would be better to use sizeof(wchar_t) or similar to differentiate
// but easier for now to hard-code platforms.
// C++11 has char16_t and char32_t but neither Clang nor Visual C++
// appear to allow specializing basic_regex over these.

#ifdef _WIN32
#define WCHAR_T_IS_16 1
#else
#define WCHAR_T_IS_16 0
#endif

#if WCHAR_T_IS_16

// On Windows, report non-BMP characters as 2 separate surrogates as that
// matches wregex since it is based on wchar_t.
class UTF8Iterator {
	// These 3 fields determine the iterator position and are used for comparisons
	const Document *doc;
	Sci::Position position;
	size_t characterIndex = 0;
	// Remaining fields are derived from the determining fields so are excluded in comparisons
	unsigned int lenBytes = 0;
	size_t lenCharacters = 0;
	wchar_t buffered[2]{};
public:
	using iterator_category = std::bidirectional_iterator_tag;
	using value_type = wchar_t;
	using difference_type = ptrdiff_t;
	using pointer = wchar_t*;
	using reference = wchar_t&;

	explicit UTF8Iterator(const Document *doc_=nullptr, Sci::Position position_=0) noexcept :
		doc(doc_), position(position_) {
		if (doc) {
			ReadCharacter();
		}
	}
	wchar_t operator*() const noexcept {
		assert(lenCharacters != 0);
		return buffered[characterIndex];
	}
	UTF8Iterator &operator++() noexcept {
		if ((characterIndex + 1) < (lenCharacters)) {
			characterIndex++;
		} else {
			position += lenBytes;
			ReadCharacter();
			characterIndex = 0;
		}
		return *this;
	}
	UTF8Iterator operator++(int) noexcept {
		UTF8Iterator retVal(*this);
		if ((characterIndex + 1) < (lenCharacters)) {
			characterIndex++;
		} else {
			position += lenBytes;
			ReadCharacter();
			characterIndex = 0;
		}
		return retVal;
	}
	UTF8Iterator &operator--() noexcept {
		if (characterIndex) {
			characterIndex--;
		} else {
			position = doc->NextPosition(position, -1);
			ReadCharacter();
			characterIndex = lenCharacters - 1;
		}
		return *this;
	}
	bool operator==(const UTF8Iterator &other) const noexcept {
		// Only test the determining fields, not the character widths and values derived from this
		return doc == other.doc &&
			position == other.position &&
			characterIndex == other.characterIndex;
	}
	bool operator!=(const UTF8Iterator &other) const noexcept {
		// Only test the determining fields, not the character widths and values derived from this
		return doc != other.doc ||
			position != other.position ||
			characterIndex != other.characterIndex;
	}
	[[nodiscard]] Sci::Position Pos() const noexcept {
		return position;
	}
	[[nodiscard]] Sci::Position PosRoundUp() const noexcept {
		if (characterIndex)
			return position + lenBytes;	// Force to end of character
		else
			return position;
	}
private:
	void ReadCharacter() noexcept {
		const CharacterExtracted charExtracted = doc->ExtractCharacter(position);
		lenBytes = charExtracted.widthBytes;
		if (charExtracted.character == unicodeReplacementChar) {
			lenCharacters = 1;
			buffered[0] = static_cast<wchar_t>(charExtracted.character);
		} else {
			lenCharacters = UTF16FromUTF32Character(charExtracted.character, buffered);
		}
	}
};

#else

// On Unix, report non-BMP characters as single characters

class UTF8Iterator {
	const Document *doc;
	Sci::Position position;
public:
	using iterator_category = std::bidirectional_iterator_tag;
	using value_type = wchar_t;
	using difference_type = ptrdiff_t;
	using pointer = wchar_t*;
	using reference = wchar_t&;

	explicit UTF8Iterator(const Document *doc_=nullptr, Sci::Position position_=0) noexcept :
		doc(doc_), position(position_) {
	}
	wchar_t operator*() const noexcept {
		const CharacterExtracted charExtracted = doc->ExtractCharacter(position);
		return charExtracted.character;
	}
	UTF8Iterator &operator++() noexcept {
		position = doc->NextPosition(position, 1);
		return *this;
	}
	UTF8Iterator operator++(int) noexcept {
		UTF8Iterator retVal(*this);
		position = doc->NextPosition(position, 1);
		return retVal;
	}
	UTF8Iterator &operator--() noexcept {
		position = doc->NextPosition(position, -1);
		return *this;
	}
	bool operator==(const UTF8Iterator &other) const noexcept {
		return doc == other.doc && position == other.position;
	}
	bool operator!=(const UTF8Iterator &other) const noexcept {
		return doc != other.doc || position != other.position;
	}
	Sci::Position Pos() const noexcept {
		return position;
	}
	Sci::Position PosRoundUp() const noexcept {
		return position;
	}
};

#endif

std::regex_constants::match_flag_type MatchFlags(const Document *doc, Sci::Position startPos, Sci::Position endPos, Sci::Position lineStartPos, Sci::Position lineEndPos) {
	std::regex_constants::match_flag_type flagsMatch = std::regex_constants::match_default;
	if (startPos != lineStartPos) {
#ifdef _LIBCPP_VERSION
		flagsMatch |= std::regex_constants::match_not_bol;
		if (!doc->IsWordStartAt(startPos)) {
			flagsMatch |= std::regex_constants::match_not_bow;
		}
#else
		flagsMatch |= std::regex_constants::match_prev_avail;
#endif
	}
	if (endPos != lineEndPos) {
		flagsMatch |= std::regex_constants::match_not_eol;
		if (!doc->IsWordEndAt(endPos)) {
			flagsMatch |= std::regex_constants::match_not_eow;
		}
	}
	return flagsMatch;
}

template<typename Iterator, typename Regex>
bool MatchOnLines(const Document *doc, const Regex &regexp, const RESearchRange &resr, RESearch &search) {
	std::match_results<Iterator> match;

	// MSVC and libc++ have problems with ^ and $ matching line ends inside a range.
	// CRLF line ends are also a problem as ^ and $ only treat LF as a line end.
	// The std::regex::multiline option was added to C++17 to improve behaviour but
	// has not been implemented by compiler runtimes with MSVC always in multiline
	// mode and libc++ and libstdc++ always in single-line mode.
	// If multiline regex worked well then the line by line iteration could be removed
	// for the forwards case and replaced with the following:
#ifdef REGEX_MULTILINE
	const Sci::Position lineStartPos = doc->LineStart(resr.lineRangeStart);
	const Sci::Position lineEndPos = doc->LineEnd(resr.lineRangeEnd);
	Iterator itStart(doc, resr.startPos);
	Iterator itEnd(doc, resr.endPos);
	const std::regex_constants::match_flag_type flagsMatch = MatchFlags(doc, resr.startPos, resr.endPos, lineStartPos, lineEndPos);
	const bool matched = std::regex_search(itStart, itEnd, match, regexp, flagsMatch);
#else
	// Line by line.
	bool matched = false;
	for (Sci::Line line = resr.lineRangeStart; line != resr.lineRangeBreak; line += resr.increment) {
		const Sci::Position lineStartPos = doc->LineStart(line);
		const Sci::Position lineEndPos = doc->LineEnd(line);
		const Range lineRange = resr.LineRange(line, lineStartPos, lineEndPos);
		const Iterator itStart(doc, lineRange.start);
		const Iterator itEnd(doc, lineRange.end);
		const std::regex_constants::match_flag_type flagsMatch = MatchFlags(doc, lineRange.start, lineRange.end, lineStartPos, lineEndPos);
		std::regex_iterator<Iterator> it(itStart, itEnd, regexp, flagsMatch);
		for (const std::regex_iterator<Iterator> last; it != last; ++it) {
			match = *it;
			matched = true;
			if (resr.increment > 0) {
				break;
			}
		}
		if (matched) {
			break;
		}
	}
#endif
	if (matched) {
		for (size_t co = 0; co < match.size() && co < RESearch::MAXTAG; co++) {
			search.bopat[co] = match[co].first.Pos();
			search.eopat[co] = match[co].second.PosRoundUp();
		}
	}
	return matched;
}

Sci::Position Cxx11RegexFindText(const Document *doc, Sci::Position minPos, Sci::Position maxPos, const char *s,
	bool caseSensitive, Sci::Position *length, RESearch &search) {
	const RESearchRange resr(doc, minPos, maxPos);
	try {
		//ElapsedPeriod ep;
		std::regex::flag_type flagsRe = std::regex::ECMAScript;
		// Flags that appear to have no effect:
		// | std::regex::collate | std::regex::extended;
		if (!caseSensitive)
			flagsRe = flagsRe | std::regex::icase;

#if defined(REGEX_MULTILINE) && !defined(_MSC_VER)
		flagsRe = flagsRe | std::regex::multiline;
#endif

		// Clear the RESearch so can fill in matches
		search.Clear();

		bool matched = false;
		if (CpUtf8 == doc->dbcsCodePage) {
			const std::wstring ws = WStringFromUTF8(s);
			std::wregex regexp;
			regexp.assign(ws, flagsRe);
			matched = MatchOnLines<UTF8Iterator>(doc, regexp, resr, search);
		} else {
			std::regex regexp;
			regexp.assign(s, flagsRe);
			matched = MatchOnLines<ByteIterator>(doc, regexp, resr, search);
		}

		Sci::Position posMatch = -1;
		if (matched) {
			posMatch = search.bopat[0];
			*length = search.eopat[0] - search.bopat[0];
		}
		// Example - search in doc/ScintillaHistory.html for
		// [[:upper:]]eta[[:space:]]
		// On MacBook, normally around 1 second but with locale imbued -> 14 seconds.
		//const double durSearch = ep.Duration(true);
		//Platform::DebugPrintf("Search:%9.6g \n", durSearch);
		return posMatch;
	} catch (std::regex_error &) {
		// Failed to create regular expression
		throw RegexError();
	} catch (...) {
		// Failed in some other way
		return -1;
	}
}

#endif

}

Sci::Position BuiltinRegex::FindText(Document *doc, Sci::Position minPos, Sci::Position maxPos, const char *s,
                        bool caseSensitive, bool, bool, FindOption flags,
                        Sci::Position *length) {

#ifndef NO_CXX11_REGEX
	if (FlagSet(flags, FindOption::Cxx11RegEx)) {
			return Cxx11RegexFindText(doc, minPos, maxPos, s,
			caseSensitive, length, search);
	}
#endif

	const RESearchRange resr(doc, minPos, maxPos);

	const bool posix = FlagSet(flags, FindOption::Posix);

	const char *errmsg = search.Compile(s, *length, caseSensitive, posix);
	if (errmsg) {
		return -1;
	}
	// Find a variable in a property file: \$(\([A-Za-z0-9_.]+\))
	// Replace first '.' with '-' in each property file variable reference:
	//     Search: \$(\([A-Za-z0-9_-]+\)\.\([A-Za-z0-9_.]+\))
	//     Replace: $(\1-\2)
	Sci::Position pos = -1;
	Sci::Position lenRet = 0;
	const bool searchforLineStart = s[0] == '^';
	const char searchEnd = s[*length - 1];
	const char searchEndPrev = (*length > 1) ? s[*length - 2] : '\0';
	const bool searchforLineEnd = (searchEnd == '$') && (searchEndPrev != '\\');
	for (Sci::Line line = resr.lineRangeStart; line != resr.lineRangeBreak; line += resr.increment) {
		const Sci::Position lineStartPos = doc->LineStart(line);
		const Sci::Position lineEndPos = doc->LineEnd(line);
		Sci::Position startOfLine = lineStartPos;
		Sci::Position endOfLine = lineEndPos;
		if (resr.increment == 1) {
			if (line == resr.lineRangeStart) {
				if ((resr.startPos != startOfLine) && searchforLineStart)
					continue;	// Can't match start of line if start position after start of line
				startOfLine = resr.startPos;
			}
			if (line == resr.lineRangeEnd) {
				if ((resr.endPos != endOfLine) && searchforLineEnd)
					continue;	// Can't match end of line if end position before end of line
				endOfLine = resr.endPos;
			}
		} else {
			if (line == resr.lineRangeEnd) {
				if ((resr.endPos != startOfLine) && searchforLineStart)
					continue;	// Can't match start of line if end position after start of line
				startOfLine = resr.endPos;
			}
			if (line == resr.lineRangeStart) {
				if ((resr.startPos != endOfLine) && searchforLineEnd)
					continue;	// Can't match end of line if start position before end of line
				endOfLine = resr.startPos;
			}
		}

		const DocumentIndexer di(doc, endOfLine);
		search.SetLineRange(lineStartPos, lineEndPos);
		int success = search.Execute(di, startOfLine, endOfLine);
		if (success) {
			Sci::Position endPos = search.eopat[0];
			// There can be only one start of a line, so no need to look for last match in line
			if ((resr.increment == -1) && !searchforLineStart) {
				// Check for the last match on this line.
				while (success && (endPos < endOfLine)) {
					const RESearch::MatchPositions bopat = search.bopat;
					const RESearch::MatchPositions eopat = search.eopat;
					pos = endPos;
					if (pos == bopat[0]) {
						// empty match
						pos = doc->NextPosition(pos, 1);
					}
					success = search.Execute(di, pos, endOfLine);
					if (success) {
						endPos = search.eopat[0];
					} else {
						search.bopat = bopat;
						search.eopat = eopat;
					}
				}
			}
			pos = search.bopat[0];
			lenRet = endPos - pos;
			break;
		}
	}
	*length = lenRet;
	return pos;
}

const char *BuiltinRegex::SubstituteByPosition(Document *doc, const char *text, Sci::Position *length) {
	substituted.clear();
	for (Sci::Position j = 0; j < *length; j++) {
		if (text[j] == '\\') {
			const char chNext = text[++j];
			if (chNext >= '0' && chNext <= '9') {
				const unsigned int patNum = chNext - '0';
				const Sci::Position startPos = search.bopat[patNum];
				const Sci::Position len = search.eopat[patNum] - startPos;
				if (len > 0) {	// Will be null if try for a match that did not occur
					const size_t size = substituted.length();
					substituted.resize(size + len);
					doc->GetCharRange(substituted.data() + size, startPos, len);
				}
			} else {
				switch (chNext) {
				case 'a':
					substituted.push_back('\a');
					break;
				case 'b':
					substituted.push_back('\b');
					break;
				case 'f':
					substituted.push_back('\f');
					break;
				case 'n':
					substituted.push_back('\n');
					break;
				case 'r':
					substituted.push_back('\r');
					break;
				case 't':
					substituted.push_back('\t');
					break;
				case 'v':
					substituted.push_back('\v');
					break;
				case '\\':
					substituted.push_back('\\');
					break;
				default:
					substituted.push_back('\\');
					j--;
				}
			}
		} else {
			substituted.push_back(text[j]);
		}
	}
	*length = substituted.length();
	return substituted.c_str();
}

#ifndef SCI_OWNREGEX

RegexSearchBase *Scintilla::Internal::CreateRegexSearch(CharClassify *charClassTable) {
	return new BuiltinRegex(charClassTable);
}

#endif


================================================
FILE: Libraries/scintilla/src/Document.h
================================================
// Scintilla source code edit control
/** @file Document.h
 ** Text document that handles notifications, DBCS, styling, words and end of line.
 **/
// Copyright 1998-2011 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#ifndef DOCUMENT_H
#define DOCUMENT_H

namespace Scintilla::Internal {

class DocWatcher;
class DocModification;
class Document;
class LineMarkers;
class LineLevels;
class LineState;
class LineAnnotation;

enum class EncodingFamily { eightBit, unicode, dbcs };

/**
 * The range class represents a range of text in a document.
 * The two values are not sorted as one end may be more significant than the other
 * as is the case for the selection where the end position is the position of the caret.
 * If either position is invalidPosition then the range is invalid and most operations will fail.
 */
class Range {
public:
	Sci::Position start;
	Sci::Position end;

	explicit Range(Sci::Position pos=0) noexcept :
		start(pos), end(pos) {
	}
	Range(Sci::Position start_, Sci::Position end_) noexcept :
		start(start_), end(end_) {
	}

	bool operator==(const Range &other) const noexcept {
		return (start == other.start) && (end == other.end);
	}

	bool Valid() const noexcept {
		return (start != Sci::invalidPosition) && (end != Sci::invalidPosition);
	}

	[[nodiscard]] bool Empty() const noexcept {
		return start == end;
	}

	[[nodiscard]] Sci::Position Length() const noexcept {
		return (start <= end) ? (end - start) : (start - end);
	}

	Sci::Position First() const noexcept {
		return (start <= end) ? start : end;
	}

	Sci::Position Last() const noexcept {
		return (start > end) ? start : end;
	}

	// Is the position within the range?
	bool Contains(Sci::Position pos) const noexcept {
		if (start < end) {
			return (pos >= start && pos <= end);
		} else {
			return (pos <= start && pos >= end);
		}
	}

	// Is the character after pos within the range?
	bool ContainsCharacter(Sci::Position pos) const noexcept {
		if (start < end) {
			return (pos >= start && pos < end);
		} else {
			return (pos < start && pos >= end);
		}
	}

	bool Contains(Range other) const noexcept {
		return Contains(other.start) && Contains(other.end);
	}

	bool Overlaps(Range other) const noexcept {
		return
		Contains(other.start) ||
		Contains(other.end) ||
		other.Contains(start) ||
		other.Contains(end);
	}
};

/**
 * Interface class for regular expression searching
 */
class RegexSearchBase {
public:
	virtual ~RegexSearchBase() = default;

	virtual Sci::Position FindText(Document *doc, Sci::Position minPos, Sci::Position maxPos, const char *s,
                        bool caseSensitive, bool word, bool wordStart, Scintilla::FindOption flags, Sci::Position *length) = 0;

	///@return String with the substitutions, must remain valid until the next call or destruction
	virtual const char *SubstituteByPosition(Document *doc, const char *text, Sci::Position *length) = 0;
};

/// Factory function for RegexSearchBase
extern RegexSearchBase *CreateRegexSearch(CharClassify *charClassTable);

struct StyledText {
	size_t length;
	const char *text;
	bool multipleStyles;
	size_t style;
	const unsigned char *styles;
	StyledText(size_t length_, const char *text_, bool multipleStyles_, int style_, const unsigned char *styles_) noexcept :
		length(length_), text(text_), multipleStyles(multipleStyles_), style(style_), styles(styles_) {
	}
	// Return number of bytes from start to before '\n' or end of text.
	// Return 1 when start is outside text
	size_t LineLength(size_t start) const noexcept {
		size_t cur = start;
		while ((cur < length) && (text[cur] != '\n'))
			cur++;
		return cur-start;
	}
	size_t StyleAt(size_t i) const noexcept {
		return multipleStyles ? styles[i] : style;
	}
};

class HighlightDelimiter {
public:
	HighlightDelimiter() noexcept : isEnabled(false) {
		Clear();
	}

	void Clear() noexcept {
		beginFoldBlock = -1;
		endFoldBlock = -1;
		firstChangeableLineBefore = -1;
		firstChangeableLineAfter = -1;
	}

	bool NeedsDrawing(Sci::Line line) const noexcept {
		return isEnabled && (line <= firstChangeableLineBefore || line >= firstChangeableLineAfter);
	}

	bool IsFoldBlockHighlighted(Sci::Line line) const noexcept {
		return isEnabled && beginFoldBlock != -1 && beginFoldBlock <= line && line <= endFoldBlock;
	}

	bool IsHeadOfFoldBlock(Sci::Line line) const noexcept {
		return beginFoldBlock == line && line < endFoldBlock;
	}

	bool IsBodyOfFoldBlock(Sci::Line line) const noexcept {
		return beginFoldBlock != -1 && beginFoldBlock < line && line < endFoldBlock;
	}

	bool IsTailOfFoldBlock(Sci::Line line) const noexcept {
		return beginFoldBlock != -1 && beginFoldBlock < line && line == endFoldBlock;
	}

	Sci::Line beginFoldBlock;	// Begin of current fold block
	Sci::Line endFoldBlock;	// End of current fold block
	Sci::Line firstChangeableLineBefore;	// First line that triggers repaint before starting line that determined current fold block
	Sci::Line firstChangeableLineAfter;	// First line that triggers repaint after starting line that determined current fold block
	bool isEnabled;
};

// Base class for view state that can be held and transferred without understanding the contents.
// Declared here but real implementation subclass declared in EditModel
struct ViewState {
	ViewState() noexcept = default;
	// Deleted so ViewState objects can not be copied
	ViewState(const ViewState &) = delete;
	ViewState(ViewState &&) = delete;
	ViewState &operator=(const ViewState &) = delete;
	ViewState &operator=(ViewState &&) = delete;
	virtual ~ViewState() noexcept = default;

	virtual void TruncateUndo(int index)=0;
};

using ViewStateShared = std::shared_ptr<ViewState>;

struct LexerReleaser {
	// Called by unique_ptr to destroy/free the Resource
	void operator()(Scintilla::ILexer5 *pLexer) noexcept {
		if (pLexer) {
			try {
				pLexer->Release();
			} catch (...) {
				// ILexer5::Release must not throw, ignore if it does.
			}
		}
	}
};

using LexerInstance = std::unique_ptr<Scintilla::ILexer5, LexerReleaser>;

// LexInterface defines the interface to ILexer used in Document.
// The LexState subclass is actually created and that is used within ScintillaBase
// to provide more methods that are exposed through Scintilla's external API.
class LexInterface {
protected:
	Document *pdoc;
	LexerInstance instance;
	bool performingStyle;	///< Prevent reentrance
public:
	explicit LexInterface(Document *pdoc_) noexcept;
	// Deleted so LexInterface objects can not be copied.
	LexInterface(const LexInterface &) = delete;
	LexInterface(LexInterface &&) = delete;
	LexInterface &operator=(const LexInterface &) = delete;
	LexInterface &operator=(LexInterface &&) = delete;
	virtual ~LexInterface() noexcept;
	void SetInstance(ILexer5 *instance_) noexcept;
	void Colourise(Sci::Position start, Sci::Position end);
	virtual Scintilla::LineEndType LineEndTypesSupported();
	bool UseContainerLexing() const noexcept;
};

struct RegexError : public std::runtime_error {
	RegexError() : std::runtime_error("regex failure") {}
};

/**
 * The ActionDuration class stores the average time taken for some action such as styling or
 * wrapping a line. It is used to decide how many repetitions of that action can be performed
 * on idle to maximize efficiency without affecting application responsiveness.
 * The duration changes if the time for the action changes. For example, if a simple lexer is
 * changed to a complex lexer. Changes are damped and clamped to avoid short periods of easy
 * or difficult processing moving the value too far leading to inefficiency or poor user
 * experience.
 */

class ActionDuration {
	double duration;
	const double minDuration;
	const double maxDuration;
public:
	ActionDuration(double duration_, double minDuration_, double maxDuration_) noexcept;
	void AddSample(size_t numberActions, double durationOfActions) noexcept;
	double Duration() const noexcept;
	size_t ActionsInAllowedTime(double secondsAllowed) const noexcept;
};

/**
 * A whole character (code point) with a value and width in bytes.
 * For UTF-8, the value is the code point value.
 * For DBCS, its jamming the lead and trail bytes together.
 * For 8 bit encodings, is just the byte value.
 */
struct CharacterExtracted {
	unsigned int character;
	unsigned int widthBytes;

	CharacterExtracted(unsigned int character_, unsigned int widthBytes_) noexcept :
		character(character_), widthBytes(widthBytes_) {
	}

	// For UTF-8:
	CharacterExtracted(const unsigned char *charBytes, size_t widthCharBytes) noexcept;

	// For DBCS characters turn 2 bytes into an int
	static CharacterExtracted DBCS(unsigned char lead, unsigned char trail) noexcept {
		return CharacterExtracted((lead << 8) | trail, 2);
	}
};

bool DiscardLastCombinedCharacter(std::string_view &text) noexcept;

/**
 */
class Document : PerLine, public Scintilla::IDocument, public Scintilla::ILoader, public Scintilla::IDocumentEditable {

public:
	/** Used to pair watcher pointer with user data. */
	struct WatcherWithUserData {
		DocWatcher *watcher;
		void *userData;
		WatcherWithUserData(DocWatcher *watcher_=nullptr, void *userData_=nullptr) noexcept :
			watcher(watcher_), userData(userData_) {
		}
		bool operator==(const WatcherWithUserData &other) const noexcept {
			return (watcher == other.watcher) && (userData == other.userData);
		}
	};

private:
	int refCount;
public: //Au: made public to simplify other modifications
	CellBuffer cb;
private:
	CharClassify charClass;
	CharacterCategoryMap charMap;
	std::unique_ptr<CaseFolder> pcf;
	Sci::Position endStyled;
	int styleClock;
	int enteredModification;
	int enteredStyling;
	int enteredReadOnlyCount;

	bool insertionSet;
	std::string insertion;

	std::vector<WatcherWithUserData> watchers;

	// ldSize is not real data - it is for dimensions and loops
	enum lineData { ldMarkers, ldLevels, ldState, ldMargin, ldAnnotation, ldEOLAnnotation, ldSize };
	std::unique_ptr<PerLine> perLineData[ldSize];
	LineMarkers *Markers() const noexcept;
	LineLevels *Levels() const noexcept;
	LineState *States() const noexcept;
	LineAnnotation *Margins() const noexcept;
	LineAnnotation *Annotations() const noexcept;
	LineAnnotation *EOLAnnotations() const noexcept;

	std::unique_ptr<RegexSearchBase> regex;
	std::unique_ptr<LexInterface> pli;

	std::map<void *, ViewStateShared>viewData;

public:

	Scintilla::EndOfLine eolMode;
	/// Can also be SC_CP_UTF8 to enable UTF-8 mode
	int dbcsCodePage;
	Scintilla::LineEndType lineEndBitSet;
	int tabInChars;
	int indentInChars;
	int actualIndentInChars;
	bool useTabs;
	bool tabIndents;
	bool backspaceUnindents;
	ActionDuration durationStyleOneByte;

	std::unique_ptr<IDecorationList> decorations;

	Document(Scintilla::DocumentOption options);
	// Deleted so Document objects can not be copied.
	Document(const Document &) = delete;
	Document(Document &&) = delete;
	void operator=(const Document &) = delete;
	Document &operator=(Document &&) = delete;
	~Document() override;

	int SCI_METHOD AddRef() noexcept override;
	int SCI_METHOD Release() override;

	// From PerLine
	void Init() override;
	void InsertLine(Sci::Line line) override;
	void InsertLines(Sci::Line line, Sci::Line lines) override;
	void RemoveLine(Sci::Line line) override;

	Scintilla::LineEndType LineEndTypesSupported() const;
	bool SetDBCSCodePage(int dbcsCodePage_);
	Scintilla::LineEndType GetLineEndTypesAllowed() const noexcept { return cb.GetLineEndTypes(); }
	bool SetLineEndTypesAllowed(Scintilla::LineEndType lineEndBitSet_);
	Scintilla::LineEndType GetLineEndTypesActive() const noexcept { return cb.GetLineEndTypes(); }

	int SCI_METHOD Version() const override {
		return Scintilla::dvRelease4;
	}
	int SCI_METHOD DEVersion() const noexcept override;

	void SCI_METHOD SetErrorStatus(int status) override;

	Sci_Position SCI_METHOD LineFromPosition(Sci_Position pos) const override;
	Sci::Line SciLineFromPosition(Sci::Position pos) const noexcept;	// Avoids casting LineFromPosition
	Sci::Position ClampPositionIntoDocument(Sci::Position pos) const noexcept;
	bool ContainsLineEnd(const char *s, Sci::Position length) const noexcept { return cb.ContainsLineEnd(s, length); }
	bool IsCrLf(Sci::Position pos) const noexcept;
	int LenChar(Sci::Position pos) const noexcept;
	bool InGoodUTF8(Sci::Position pos, Sci::Position &start, Sci::Position &end) const noexcept;
	Sci::Position MovePositionOutsideChar(Sci::Position pos, Sci::Position moveDir, bool checkLineEnd=true) const noexcept;
	Sci::Position NextPosition(Sci::Position pos, int moveDir) const noexcept;
	bool NextCharacter(Sci::Position &pos, int moveDir) const noexcept;	// Returns true if pos changed
	CharacterExtracted CharacterAfter(Sci::Position position) const noexcept;
	CharacterExtracted CharacterBefore(Sci::Position position) const noexcept;
	Sci_Position SCI_METHOD GetRelativePosition(Sci_Position positionStart, Sci_Position characterOffset) const override;
	Sci::Position GetRelativePositionUTF16(Sci::Position positionStart, Sci::Position characterOffset) const noexcept;
	int SCI_METHOD GetCharacterAndWidth(Sci_Position position, Sci_Position *pWidth) const override;
	int SCI_METHOD CodePage() const override;
	bool SCI_METHOD IsDBCSLeadByte(char ch) const override;
	bool IsDBCSLeadByteNoExcept(char ch) const noexcept;
	bool IsDBCSTrailByteNoExcept(char ch) const noexcept;
	unsigned char DBCSMinTrailByte() const noexcept;
	int DBCSDrawBytes(std::string_view text) const noexcept;
	bool IsDBCSDualByteAt(Sci::Position pos) const noexcept;
	size_t SafeSegment(std::string_view text) const noexcept;
	EncodingFamily CodePageFamily() const noexcept;

	// Gateways to modifying document
	void ModifiedAt(Sci::Position pos) noexcept;
	void CheckReadOnly();
	void TrimReplacement(std::string_view &text, Range &range) const noexcept;
	bool DeleteChars(Sci::Position pos, Sci::Position len);
	Sci::Position InsertString(Sci::Position position, const char *s, Sci::Position insertLength);
	Sci::Position InsertString(Sci::Position position, std::string_view sv);
	void ChangeInsertion(const char *s, Sci::Position length);
	int SCI_METHOD AddData(const char *data, Sci_Position length) override;
	IDocumentEditable *AsDocumentEditable() noexcept;
	void *SCI_METHOD ConvertToDocument() override;
	Sci::Position Undo();
	Sci::Position Redo();
	bool CanUndo() const noexcept { return cb.CanUndo(); }
	bool CanRedo() const noexcept { return cb.CanRedo(); }
	void DeleteUndoHistory() noexcept { cb.DeleteUndoHistory(); }
	bool SetUndoCollection(bool collectUndo) noexcept {
		return cb.SetUndoCollection(collectUndo);
	}
	bool IsCollectingUndo() const noexcept { return cb.IsCollectingUndo(); }
	void BeginUndoAction(bool coalesceWithPrior=false) noexcept { cb.BeginUndoAction(coalesceWithPrior); }
	void EndUndoAction() noexcept;
	int UndoSequenceDepth() const noexcept;
	bool AfterUndoSequenceStart() const noexcept { return cb.AfterUndoSequenceStart(); }
	void AddUndoAction(Sci::Position token, bool mayCoalesce) { cb.AddUndoAction(token, mayCoalesce); }
	void SetSavePoint();
	bool IsSavePoint() const noexcept { return cb.IsSavePoint(); }

	void TentativeStart() noexcept { cb.TentativeStart(); }
	void TentativeCommit() noexcept { cb.TentativeCommit(); }
	void TentativeUndo();
	bool TentativeActive() const noexcept { return cb.TentativeActive(); }

	int UndoActions() const noexcept;
	void SetUndoSavePoint(int action) noexcept;
	int UndoSavePoint() const noexcept;
	void SetUndoDetach(int action) noexcept;
	int UndoDetach() const noexcept;
	void SetUndoTentative(int action) noexcept;
	int UndoTentative() const noexcept;
	void SetUndoCurrent(int action);
	int UndoCurrent() const noexcept;
	int UndoActionType(int action) const noexcept;
	Sci::Position UndoActionPosition(int action) const noexcept;
	std::string_view UndoActionText(int action) const noexcept;
	void PushUndoActionType(int type, Sci::Position position);
	void ChangeLastUndoActionText(size_t length, const char *text);

	void ChangeHistorySet(bool set) { cb.ChangeHistorySet(set); }
	[[nodiscard]] int EditionAt(Sci::Position pos) const noexcept { return cb.EditionAt(pos); }
	[[nodiscard]] Sci::Position EditionEndRun(Sci::Position pos) const noexcept { return cb.EditionEndRun(pos); }
	[[nodiscard]] unsigned int EditionDeletesAt(Sci::Position pos) const noexcept { return cb.EditionDeletesAt(pos); }
	[[nodiscard]] Sci::Position EditionNextDelete(Sci::Position pos) const noexcept { return cb.EditionNextDelete(pos); }

	const char *SCI_METHOD BufferPointer() override { return cb.BufferPointer(); }
	const char *RangePointer(Sci::Position position, Sci::Position rangeLength) noexcept { return cb.RangePointer(position, rangeLength); }
	Sci::Position GapPosition() const noexcept { return cb.GapPosition(); }

	int SCI_METHOD GetLineIndentation(Sci_Position line) override;
	Sci::Position SetLineIndentation(Sci::Line line, Sci::Position indent);
	Sci::Position GetLineIndentPosition(Sci::Line line) const;
	Sci::Position GetColumn(Sci::Position pos) const;
	Sci::Position CountCharacters(Sci::Position startPos, Sci::Position endPos) const noexcept;
	Sci::Position CountUTF16(Sci::Position startPos, Sci::Position endPos) const noexcept;
	Sci::Position FindColumn(Sci::Line line, Sci::Position column);
	void Indent(bool forwards, Sci::Line lineBottom, Sci::Line lineTop);
	static std::string TransformLineEnds(const char *s, size_t len, Scintilla::EndOfLine eolModeWanted);
	void ConvertLineEnds(Scintilla::EndOfLine eolModeSet);
	std::string_view EOLString() const noexcept;
	void SetReadOnly(bool set) noexcept { cb.SetReadOnly(set); }
	bool IsReadOnly() const noexcept { return cb.IsReadOnly(); }
	bool IsLarge() const noexcept { return cb.IsLarge(); }
	Scintilla::DocumentOption Options() const noexcept;

	void DelChar(Sci::Position pos);
	void DelCharBack(Sci::Position pos);

	char CharAt(Sci::Position position) const noexcept { return cb.CharAt(position); }
	void SCI_METHOD GetCharRange(char *buffer, Sci_Position position, Sci_Position lengthRetrieve) const override {
		cb.GetCharRange(buffer, position, lengthRetrieve);
	}
	char SCI_METHOD StyleAt(Sci_Position position) const override { return cb.StyleAt(position); }
	char StyleAtNoExcept(Sci_Position position) const noexcept { return cb.StyleAt(position); }
	int StyleIndexAt(Sci_Position position) const noexcept { return static_cast<unsigned char>(cb.StyleAt(position)); }
	void GetStyleRange(unsigned char *buffer, Sci::Position position, Sci::Position lengthRetrieve) const {
		cb.GetStyleRange(buffer, position, lengthRetrieve);
	}
	int GetMark(Sci::Line line, bool includeChangeHistory) const;
	Sci::Line MarkerNext(Sci::Line lineStart, int mask) const noexcept;
	int AddMark(Sci::Line line, int markerNum);
	void AddMarkSet(Sci::Line line, int valueSet);
	void DeleteMark(Sci::Line line, int markerNum);
	void DeleteMarkFromHandle(int markerHandle);
	void DeleteAllMarks(int markerNum);
	Sci::Line LineFromHandle(int markerHandle) const noexcept;
	int MarkerNumberFromLine(Sci::Line line, int which) const noexcept;
	int MarkerHandleFromLine(Sci::Line line, int which) const noexcept;
	Sci_Position SCI_METHOD LineStart(Sci_Position line) const override;
	[[nodiscard]] Range LineRange(Sci::Line line) const noexcept;
	bool IsLineStartPosition(Sci::Position position) const noexcept;
	Sci_Position SCI_METHOD LineEnd(Sci_Position line) const override;
	Sci::Position LineStartPosition(Sci::Position position) const noexcept;
	Sci::Position LineEndPosition(Sci::Position position) const noexcept;
	bool IsLineEndPosition(Sci::Position position) const noexcept;
	bool IsPositionInLineEnd(Sci::Position position) const noexcept;
	Sci::Position VCHomePosition(Sci::Position position) const;
	Sci::Position IndexLineStart(Sci::Line line, Scintilla::LineCharacterIndexType lineCharacterIndex) const noexcept;
	Sci::Line LineFromPositionIndex(Sci::Position pos, Scintilla::LineCharacterIndexType lineCharacterIndex) const noexcept;
	Sci::Line LineFromPositionAfter(Sci::Line line, Sci::Position length) const noexcept;

	bool SCI_METHOD Sci_SetFoldLevels(int line, int lastLine, int len, int* a); //Au
	int SCI_METHOD SetLevel(Sci_Position line, int level) override;
	int SCI_METHOD GetLevel(Sci_Position line) const override;
	Scintilla::FoldLevel GetFoldLevel(Sci_Position line) const noexcept;
	void ClearLevels();
	Sci::Line GetLastChild(Sci::Line lineParent, std::optional<Scintilla::FoldLevel> level = {}, Sci::Line lastLine = -1);
	Sci::Line GetFoldParent(Sci::Line line) const noexcept;
	void GetHighlightDelimiters(HighlightDelimiter &highlightDelimiter, Sci::Line line, Sci::Line lastLine);

	Sci::Position ExtendWordSelect(Sci::Position pos, int delta, bool onlyWordCharacters=false) const;
	Sci::Position NextWordStart(Sci::Position pos, int delta) const;
	Sci::Position NextWordEnd(Sci::Position pos, int delta) const;
	Sci_Position SCI_METHOD Length() const override { return cb.Length(); }
	Sci::Position LengthNoExcept() const noexcept { return cb.Length(); }
	void Allocate(Sci::Position newSize) { cb.Allocate(newSize); }

	CharacterExtracted ExtractCharacter(Sci::Position position) const noexcept;

	bool IsWordStartAt(Sci::Position pos) const;
	bool IsWordEndAt(Sci::Position pos) const;
	bool IsWordAt(Sci::Position start, Sci::Position end) const;

	bool MatchesWordOptions(bool word, bool wordStart, Sci::Position pos, Sci::Position length) const;
	bool HasCaseFolder() const noexcept;
	void SetCaseFolder(std::unique_ptr<CaseFolder> pcf_) noexcept;
	Sci::Position FindText(Sci::Position minPos, Sci::Position maxPos, const char *search, Scintilla::FindOption flags, Sci::Position *length);
	const char *SubstituteByPosition(const char *text, Sci::Position *length);
	Scintilla::LineCharacterIndexType LineCharacterIndex() const noexcept;
	void AllocateLineCharacterIndex(Scintilla::LineCharacterIndexType lineCharacterIndex);
	void ReleaseLineCharacterIndex(Scintilla::LineCharacterIndexType lineCharacterIndex);
	Sci::Line LinesTotal() const noexcept;
	void AllocateLines(Sci::Line lines);

	void SetDefaultCharClasses(bool includeWordClass);
	void SetCharClasses(const unsigned char *chars, CharacterClass newCharClass);
	int GetCharsOfClass(CharacterClass characterClass, unsigned char *buffer) const;
	void SetCharacterCategoryOptimization(int countCharacters);
	int CharacterCategoryOptimization() const noexcept;
	void SCI_METHOD StartStyling(Sci_Position position) override;
	bool SCI_METHOD SetStyleFor(Sci_Position length, char style) override;
	bool SCI_METHOD SetStyles(Sci_Position length, const char *styles) override;
	Sci::Position GetEndStyled() const noexcept { return endStyled; }
	void EnsureStyledTo(Sci::Position pos);
	void StyleToAdjustingLineDuration(Sci::Position pos);
	int GetStyleClock() const noexcept { return styleClock; }
	void IncrementStyleClock() noexcept;
	void SCI_METHOD DecorationSetCurrentIndicator(int indicator) override;
	void SCI_METHOD DecorationFillRange(Sci_Position position, int value, Sci_Position fillLength) override;
	LexInterface *GetLexInterface() const noexcept;
	void SetLexInterface(std::unique_ptr<LexInterface> pLexInterface) noexcept;

	void SetViewState(void *view, ViewStateShared pVSS);
	ViewStateShared GetViewState(void *view) const noexcept;
	void TruncateUndoComments(int action);

	int SCI_METHOD SetLineState(Sci_Position line, int state) override;
	int SCI_METHOD GetLineState(Sci_Position line) const override;
	Sci::Line GetMaxLineState() const noexcept;
	void SCI_METHOD ChangeLexerState(Sci_Position start, Sci_Position end) override;

	StyledText MarginStyledText(Sci::Line line) const noexcept;
	void MarginSetStyle(Sci::Line line, int style);
	void MarginSetStyles(Sci::Line line, const unsigned char *styles);
	Sci::Line MarginStyledTextNext(Sci::Line line, int style); //Au: new function
	void MarginSetText(Sci::Line line, const char *text);
	void MarginClearAll();

	StyledText AnnotationStyledText(Sci::Line line) const noexcept;
	void AnnotationSetText(Sci::Line line, const char *text);
	void AnnotationSetStyle(Sci::Line line, int style);
	void AnnotationSetStyles(Sci::Line line, const unsigned char *styles);
	int AnnotationLines(Sci::Line line) const noexcept;
	void AnnotationClearAll();

	StyledText EOLAnnotationStyledText(Sci::Line line) const noexcept;
	void EOLAnnotationSetStyle(Sci::Line line, int style);
	void EOLAnnotationSetText(Sci::Line line, const char *text);
	void EOLAnnotationClearAll();

	bool AddWatcher(DocWatcher *watcher, void *userData);
	bool RemoveWatcher(DocWatcher *watcher, void *userData) noexcept;

	CharacterClass WordCharacterClass(unsigned int ch) const;
	bool IsWordPartSeparator(unsigned int ch) const;
	Sci::Position WordPartLeft(Sci::Position pos) const;
	Sci::Position WordPartRight(Sci::Position pos) const;
	Sci::Position ExtendStyleRange(Sci::Position pos, int delta, bool singleLine) noexcept;
	bool IsWhiteLine(Sci::Line line) const;
	Sci::Position ParaUp(Sci::Position pos) const;
	Sci::Position ParaDown(Sci::Position pos) const;
	int IndentSize() const noexcept { return actualIndentInChars; }
	Sci::Position BraceMatch(Sci::Position position, Sci::Position maxReStyle, Sci::Position startPos, bool useStartPos) noexcept;

private:
	void NotifyModifyAttempt();
	void NotifySavePoint(bool atSavePoint);
	void NotifyGroupCompleted() noexcept;
	void NotifyModified(DocModification mh);
};

class UndoGroup {
	Document *pdoc;
	bool groupNeeded;
public:
	UndoGroup(Document *pdoc_, bool groupNeeded_=true) noexcept :
		pdoc(pdoc_), groupNeeded(groupNeeded_) {
		if (groupNeeded) {
			pdoc->BeginUndoAction();
		}
	}
	// Deleted so UndoGroup objects can not be copied.
	UndoGroup(const UndoGroup &) = delete;
	UndoGroup(UndoGroup &&) = delete;
	void operator=(const UndoGroup &) = delete;
	UndoGroup &operator=(UndoGroup &&) = delete;
	~UndoGroup() {
		if (groupNeeded) {
			// EndUndoAction can throw as it allocates but throw in destructor is fatal.
			// To fix this UndoHistory should allocate any memory needed by EndUndoAction
			// beforehand or change EndUndoAction to not require allocation.
			pdoc->EndUndoAction();
		}
	}
	bool Needed() const noexcept {
		return groupNeeded;
	}
};


/**
 * To optimise processing of document modifications by DocWatchers, a hint is passed indicating the
 * scope of the change.
 * If the DocWatcher is a document view then this can be used to optimise screen updating.
 */
class DocModification {
public:
	Scintilla::ModificationFlags modificationType;
	Sci::Position position;
	Sci::Position length;
	Sci::Line linesAdded;	/**< Negative if lines deleted. */
	const char *text;	/**< Only valid for changes to text, not for changes to style. */
	Sci::Line line;
	Scintilla::FoldLevel foldLevelNow;
	Scintilla::FoldLevel foldLevelPrev;
	Sci::Line annotationLinesAdded;
	Sci::Position token;

	DocModification(Scintilla::ModificationFlags modificationType_, Sci::Position position_=0, Sci::Position length_=0,
		Sci::Line linesAdded_=0, const char *text_=nullptr, Sci::Line line_=0) noexcept :
		modificationType(modificationType_),
		position(position_),
		length(length_),
		linesAdded(linesAdded_),
		text(text_),
		line(line_),
		foldLevelNow(Scintilla::FoldLevel::None),
		foldLevelPrev(Scintilla::FoldLevel::None),
		annotationLinesAdded(0),
		token(0) {}

	DocModification(Scintilla::ModificationFlags modificationType_, const Action &act, Sci::Line linesAdded_=0) noexcept :
		modificationType(modificationType_),
		position(act.position),
		length(act.lenData),
		linesAdded(linesAdded_),
		text(act.data),
		line(0),
		foldLevelNow(Scintilla::FoldLevel::None),
		foldLevelPrev(Scintilla::FoldLevel::None),
		annotationLinesAdded(0),
		token(0) {}
};

/**
 * A class that wants to receive notifications from a Document must be derived from DocWatcher
 * and implement the notification methods. It can then be added to the watcher list with AddWatcher.
 */
class DocWatcher {
public:
	virtual ~DocWatcher() {}

	virtual void NotifyModifyAttempt(Document *doc, void *userData) = 0;
	virtual void NotifySavePoint(Document *doc, void *userData, bool atSavePoint) = 0;
	virtual void NotifyModified(Document *doc, DocModification mh, void *userData) = 0;
	virtual void NotifyDeleted(Document *doc, void *userData) noexcept = 0;
	virtual void NotifyStyleNeeded(Document *doc, void *userData, Sci::Position endPos) = 0;
	virtual void NotifyErrorOccurred(Document *doc, void *userData, Scintilla::Status status) = 0;
	virtual void NotifyGroupCompleted(Document *doc, void *userData) noexcept = 0;
};

}

#endif


================================================
FILE: Libraries/scintilla/src/EditModel.cxx
================================================
// Scintilla source code edit control
/** @file EditModel.cxx
 ** Defines the editor state that must be visible to EditorView.
 **/
// Copyright 1998-2014 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#include <cstddef>
#include <cstdlib>
#include <cstdint>
#include <cassert>
#include <cstring>
#include <cmath>

#include <stdexcept>
#include <string>
#include <string_view>
#include <vector>
#include <map>
#include <set>
#include <optional>
#include <algorithm>
#include <memory>

#include "ScintillaTypes.h"
#include "ILoader.h"
#include "ILexer.h"

#include "Debugging.h"
#include "Geometry.h"
#include "Platform.h"

#include "CharacterCategoryMap.h"

#include "Position.h"
#include "UniqueString.h"
#include "SplitVector.h"
#include "Partitioning.h"
#include "RunStyles.h"
#include "ContractionState.h"
#include "CellBuffer.h"
#include "Indicator.h"
#include "LineMarker.h"
#include "Style.h"
#include "ViewStyle.h"
#include "CharClassify.h"
#include "Decoration.h"
#include "CaseFolder.h"
#include "Document.h"
#include "UniConversion.h"
#include "Selection.h"
#include "PositionCache.h"
#include "EditModel.h"

using namespace Scintilla;
using namespace Scintilla::Internal;

Caret::Caret() noexcept :
	active(false), on(false), period(500) {}

void ModelState::RememberSelectionForUndo(int index, const Selection &sel) {
	historyForUndo.indexCurrent = index;
	historyForUndo.ssCurrent = sel.ToString();
}

void ModelState::ForgetSelectionForUndo() noexcept {
	historyForUndo.indexCurrent = -1;
}

void ModelState::RememberSelectionOntoStack(int index, Sci::Line topLine) {
	if ((historyForUndo.indexCurrent >= 0) && (index == historyForUndo.indexCurrent + 1)) {
		// Don't overwrite initial selection save if most recent action was coalesced
		historyForUndo.stack[index] = { historyForUndo.ssCurrent, topLine };
	}
}

void ModelState::RememberSelectionForRedoOntoStack(int index, const Selection &sel, Sci::Line topLine) {
	historyForRedo.stack[index] = { sel.ToString(), topLine };
}

SelectionWithScroll ModelState::SelectionFromStack(int index, UndoRedo history) const {
	const SelectionHistory &sh = history == UndoRedo::undo ? historyForUndo : historyForRedo;
	const SelectionStack::const_iterator it = sh.stack.find(index);
	if (it != sh.stack.end()) {
		return it->second;
	}
	return {};
}

void ModelState::TruncateUndo(int index) {
	const SelectionStack::const_iterator itUndo = historyForUndo.stack.find(index);
	historyForUndo.stack.erase(itUndo, historyForUndo.stack.end());
	const SelectionStack::const_iterator itRedo = historyForRedo.stack.find(index);
	historyForRedo.stack.erase(itRedo, historyForRedo.stack.end());
}

EditModel::EditModel() : braces{} {
	inOverstrike = false;
	xOffset = 0;
	trackLineWidth = false;
	posDrag = SelectionPosition(Sci::invalidPosition);
	braces[0] = Sci::invalidPosition;
	braces[1] = Sci::invalidPosition;
	bracesMatchStyle = StyleBraceBad;
	highlightGuideColumn = 0;
	hasFocus = false;
	primarySelection = true;
	imeInteraction = IMEInteraction::Windowed;
	bidirectional = Bidirectional::Disabled;
	foldFlags = FoldFlag::None;
	foldDisplayTextStyle = FoldDisplayTextStyle::Hidden;
	hotspot = Range(Sci::invalidPosition);
	hotspotSingleLine = true;
	hoverIndicatorPos = Sci::invalidPosition;
	wrapWidth = LineLayout::wrapWidthInfinite;
	reprs = std::make_unique<SpecialRepresentations>();

	//Au
	cbNotify = nullptr; cbNotifyParam = nullptr;
	cbAnnotationDraw = nullptr; cbAnnotationDrawParam = nullptr;
	cbMarginDraw = nullptr; cbMarginsMask = 0;

	pdoc = new Document(DocumentOption::Default);
	pdoc->AddRef();
	pcs = ContractionStateCreate(pdoc->IsLarge());
}

EditModel::~EditModel() {
	try {
		// Erasing the view state won't throw even though SetViewState
		// and the resulting map::erase aren't marked noexcept.
		pdoc->SetViewState(this, {});
		// This never throws but isn't marked noexcept for compatibility
		pdoc->Release();
	} catch (...) {
		// Ignore any exception
	}
	pdoc = nullptr;
}

bool EditModel::BidirectionalEnabled() const noexcept {
	return (bidirectional != Bidirectional::Disabled) &&
		(CpUtf8 == pdoc->dbcsCodePage);
}

bool EditModel::BidirectionalR2L() const noexcept {
	return bidirectional == Bidirectional::R2L;
}

SurfaceMode EditModel::CurrentSurfaceMode() const noexcept {
	return SurfaceMode(pdoc->dbcsCodePage, BidirectionalR2L());
}

void EditModel::SetDefaultFoldDisplayText(const char *text) {
	defaultFoldDisplayText = IsNullOrEmpty(text) ? UniqueString() : UniqueStringCopy(text);
}

const char *EditModel::GetDefaultFoldDisplayText() const noexcept {
	return defaultFoldDisplayText.get();
}

const char *EditModel::GetFoldDisplayText(Sci::Line lineDoc) const noexcept {
	if (foldDisplayTextStyle == FoldDisplayTextStyle::Hidden || pcs->GetExpanded(lineDoc)) {
		return nullptr;
	}

	const char *text = pcs->GetFoldDisplayText(lineDoc);
	return text ? text : defaultFoldDisplayText.get();
}

InSelection EditModel::LineEndInSelection(Sci::Line lineDoc) const {
	const Sci::Position posAfterLineEnd = pdoc->LineStart(lineDoc + 1);
	return sel.InSelectionForEOL(posAfterLineEnd);
}

int EditModel::GetMark(Sci::Line line) const {
	return pdoc->GetMark(line, FlagSet(changeHistoryOption, ChangeHistoryOption::Markers));
}

void EditModel::EnsureModelState() {
	if (!modelState && (undoSelectionHistoryOption != UndoSelectionHistoryOption::Disabled)) {
		if (ViewStateShared vss = pdoc->GetViewState(this)) {
			modelState = std::dynamic_pointer_cast<ModelState>(vss);
		} else {
			modelState = std::make_shared<ModelState>();
			pdoc->SetViewState(this, std::static_pointer_cast<ViewState>(modelState));
		}
	}
}

void EditModel::ChangeUndoSelectionHistory(Scintilla::UndoSelectionHistoryOption undoSelectionHistoryOptionNew) {
	undoSelectionHistoryOption = undoSelectionHistoryOptionNew;
	if (undoSelectionHistoryOption == UndoSelectionHistoryOption::Disabled) {
		modelState.reset();
		pdoc->SetViewState(this, {});
	}
}


================================================
FILE: Libraries/scintilla/src/EditModel.h
================================================
// Scintilla source code edit control
/** @file EditModel.h
 ** Defines the editor state that must be visible to EditorView.
 **/
// Copyright 1998-2014 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#ifndef EDITMODEL_H
#define EDITMODEL_H

namespace Scintilla::Internal {

/**
*/
class Caret {
public:
	bool active;
	bool on;
	int period;

	Caret() noexcept;
};

enum class UndoRedo { undo, redo };

// Selection stack is sparse so use a map

struct SelectionWithScroll {
	std::string selection;
	Sci::Line topLine = 0;
};

using SelectionStack = std::map<int, SelectionWithScroll>;

struct SelectionHistory {
	int indexCurrent = 0;
	std::string ssCurrent;
	SelectionStack stack;
};

struct ModelState : ViewState {
	SelectionHistory historyForUndo;
	SelectionHistory historyForRedo;
	void RememberSelectionForUndo(int index, const Selection &sel);
	void ForgetSelectionForUndo() noexcept;
	void RememberSelectionOntoStack(int index, Sci::Line topLine);
	void RememberSelectionForRedoOntoStack(int index, const Selection &sel, Sci::Line topLine);
	SelectionWithScroll SelectionFromStack(int index, UndoRedo history) const;
	virtual void TruncateUndo(int index) final;
};

using ModelStateShared = std::shared_ptr<ModelState>;

class EditModel {
public:
	bool inOverstrike;
	int xOffset;		///< Horizontal scrolled amount in pixels
	bool trackLineWidth;

	std::unique_ptr<SpecialRepresentations> reprs;
	Caret caret;
	SelectionPosition posDrag;
	Sci::Position braces[2];
	int bracesMatchStyle;
	int highlightGuideColumn;
	bool hasFocus;
	Selection sel;
	bool primarySelection;
	std::string copySeparator;

	Scintilla::IMEInteraction imeInteraction;
	Scintilla::Bidirectional bidirectional;

	Scintilla::FoldFlag foldFlags;
	Scintilla::FoldDisplayTextStyle foldDisplayTextStyle;
	UniqueString defaultFoldDisplayText;
	std::unique_ptr<IContractionState> pcs;
	// Hotspot support
	Range hotspot;
	bool hotspotSingleLine;
	Sci::Position hoverIndicatorPos;

	Scintilla::ChangeHistoryOption changeHistoryOption = Scintilla::ChangeHistoryOption::Disabled;

	// Wrapping support
	int wrapWidth;

	Document *pdoc;

	Scintilla::UndoSelectionHistoryOption undoSelectionHistoryOption = UndoSelectionHistoryOption::Disabled;
	bool needRedoRemembered = false;
	ModelStateShared modelState;

	//Au
	Sci_NotifyCallback cbNotify; void* cbNotifyParam; //can use callback function instead of WM_NOTIFY.
	Sci_AnnotationDrawCallback cbAnnotationDraw; void* cbAnnotationDrawParam; //to draw in annotation eg image instead of text.
	Sci_MarginDrawCallback cbMarginDraw; int cbMarginsMask; //to draw eg images in margin.

	EditModel();
	// Deleted so EditModel objects can not be copied.
	EditModel(const EditModel &) = delete;
	EditModel(EditModel &&) = delete;
	EditModel &operator=(const EditModel &) = delete;
	EditModel &operator=(EditModel &&) = delete;
	virtual ~EditModel();
	virtual Sci::Line TopLineOfMain() const noexcept = 0;
	virtual Point GetVisibleOriginInMain() const = 0;
	virtual Sci::Line LinesOnScreen() const = 0;
	bool BidirectionalEnabled() const noexcept;
	bool BidirectionalR2L() const noexcept;
	SurfaceMode CurrentSurfaceMode() const noexcept;
	void SetDefaultFoldDisplayText(const char *text);
	const char *GetDefaultFoldDisplayText() const noexcept;
	const char *GetFoldDisplayText(Sci::Line lineDoc) const noexcept;
	InSelection LineEndInSelection(Sci::Line lineDoc) const;
	[[nodiscard]] int GetMark(Sci::Line line) const;

	void EnsureModelState();
	void ChangeUndoSelectionHistory(Scintilla::UndoSelectionHistoryOption undoSelectionHistoryOptionNew);
};

}

#endif


================================================
FILE: Libraries/scintilla/src/EditView.cxx
================================================
// Scintilla source code edit control
/** @file EditView.cxx
 ** Defines the appearance of the main text area of the editor window.
 **/
// Copyright 1998-2014 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#include <cstddef>
#include <cstdlib>
#include <cstdint>
#include <cassert>
#include <cstring>
#include <cstdio>
#include <cmath>

#include <stdexcept>
#include <string>
#include <string_view>
#include <vector>
#include <map>
#include <set>
#include <forward_list>
#include <optional>
#include <algorithm>
#include <iterator>
#include <memory>
#include <chrono>
#include <atomic>
#include <thread>
#include <future>

#include "ScintillaTypes.h"
#include "ScintillaMessages.h"
#include "ScintillaStructures.h"
#include "ILoader.h"
#include "ILexer.h"

#include "Debugging.h"
#include "Geometry.h"
#include "Platform.h"

#include "CharacterType.h"
#include "CharacterCategoryMap.h"
#include "Position.h"
#include "UniqueString.h"
#include "SplitVector.h"
#include "Partitioning.h"
#include "RunStyles.h"
#include "ContractionState.h"
#include "CellBuffer.h"
#include "PerLine.h"
#include "KeyMap.h"
#include "Indicator.h"
#include "LineMarker.h"
#include "Style.h"
#include "ViewStyle.h"
#include "CharClassify.h"
#include "Decoration.h"
#include "CaseFolder.h"
#include "Document.h"
#include "UniConversion.h"
#include "Selection.h"
#include "PositionCache.h"
#include "EditModel.h"
#include "MarginView.h"
#include "EditView.h"
#include "ElapsedPeriod.h"

using namespace Scintilla;
using namespace Scintilla::Internal;

PrintParameters::PrintParameters() noexcept {
	magnification = 0;
	colourMode = PrintOption::Normal;
	wrapState = Wrap::Word;
}

namespace {

int WidthStyledText(Surface *surface, const ViewStyle &vs, int styleOffset,
	const char *text, const unsigned char *styles, size_t len) {
	int width = 0;
	size_t start = 0;
	while (start < len) {
		const unsigned char style = styles[start];
		size_t endSegment = start;
		while ((endSegment + 1 < len) && (styles[endSegment + 1] == style))
			endSegment++;
		const Font *fontText = vs.styles[style + styleOffset].font.get();
		const std::string_view sv(text + start, endSegment - start + 1);
		width += static_cast<int>(surface->WidthText(fontText, sv));
		start = endSegment + 1;
	}
	return width;
}

}

namespace Scintilla::Internal {

bool ValidStyledText(const ViewStyle &vs, size_t styleOffset, const StyledText &st) noexcept {
	if (st.multipleStyles) {
		for (size_t iStyle = 0; iStyle<st.length; iStyle++) {
			if (!vs.ValidStyle(styleOffset + st.styles[iStyle]))
				return false;
		}
	} else {
		if (!vs.ValidStyle(styleOffset + st.style))
			return false;
	}
	return true;
}

int WidestLineWidth(Surface *surface, const ViewStyle &vs, int styleOffset, const StyledText &st) {
	int widthMax = 0;
	size_t start = 0;
	while (start < st.length) {
		const size_t lenLine = st.LineLength(start);
		int widthSubLine;
		if (st.multipleStyles) {
			widthSubLine = WidthStyledText(surface, vs, styleOffset, st.text + start, st.styles + start, lenLine);
		} else {
			const Font *fontText = vs.styles[styleOffset + st.style].font.get();
			const std::string_view text(st.text + start, lenLine);
			widthSubLine = static_cast<int>(surface->WidthText(fontText, text));
		}
		if (widthSubLine > widthMax)
			widthMax = widthSubLine;
		start += lenLine + 1;
	}
	return widthMax;
}

void DrawTextNoClipPhase(Surface *surface, PRectangle rc, const Style &style, XYPOSITION ybase,
	std::string_view text, DrawPhase phase) {
	const Font *fontText = style.font.get();
	if (FlagSet(phase, DrawPhase::back)) {
		if (FlagSet(phase, DrawPhase::text)) {
			// Drawing both
			surface->DrawTextNoClip(rc, fontText, ybase, text,
				style.fore, style.back);
		} else {
			surface->FillRectangleAligned(rc, Fill(style.back));
		}
	} else if (FlagSet(phase, DrawPhase::text)) {
		surface->DrawTextTransparent(rc, fontText, ybase, text, style.fore);
	}
}

void DrawStyledText(Surface *surface, const ViewStyle &vs, int styleOffset, PRectangle rcText,
	const StyledText &st, size_t start, size_t length, DrawPhase phase) {

	if (st.multipleStyles) {
		int x = static_cast<int>(rcText.left);
		size_t i = 0;
		while (i < length) {
			size_t end = i;
			size_t style = st.styles[i + start];
			while (end < length - 1 && st.styles[start + end + 1] == style)
				end++;
			style += styleOffset;
			const Font *fontText = vs.styles[style].font.get();
			const std::string_view text(st.text + start + i, end - i + 1);
			const int width = static_cast<int>(surface->WidthText(fontText, text));
			PRectangle rcSegment = rcText;
			rcSegment.left = static_cast<XYPOSITION>(x);
			rcSegment.right = static_cast<XYPOSITION>(x + width + 1);
			DrawTextNoClipPhase(surface, rcSegment, vs.styles[style],
				rcText.top + vs.maxAscent, text, phase);
			x += width;
			i = end + 1;
		}
	} else {
		const size_t style = st.style + styleOffset;
		DrawTextNoClipPhase(surface, rcText, vs.styles[style],
			rcText.top + vs.maxAscent,
			std::string_view(st.text + start, length), phase);
	}
}

}

EditView::EditView() {
	tabWidthMinimumPixels = 2; // needed for calculating tab stops for fractional proportional fonts
	drawOverstrikeCaret = true;
	bufferedDraw = true;
	phasesDraw = PhasesDraw::Two;
	lineWidthMaxSeen = 0;
	additionalCaretsBlink = true;
	additionalCaretsVisible = true;
	imeCaretBlockOverride = false;
	llc.SetLevel(LineCache::Caret);
	posCache = CreatePositionCache();
	posCache->SetSize(0x400);
	maxLayoutThreads = 1;
	tabArrowHeight = 4;
	customDrawTabArrow = nullptr;
	customDrawWrapMarker = nullptr;
}

EditView::~EditView() = default;

bool EditView::SetTwoPhaseDraw(bool twoPhaseDraw) noexcept {
	const PhasesDraw phasesDrawNew = twoPhaseDraw ? PhasesDraw::Two : PhasesDraw::One;
	const bool redraw = phasesDraw != phasesDrawNew;
	phasesDraw = phasesDrawNew;
	return redraw;
}

bool EditView::SetPhasesDraw(int phases) noexcept {
	const PhasesDraw phasesDrawNew = static_cast<PhasesDraw>(phases);
	const bool redraw = phasesDraw != phasesDrawNew;
	phasesDraw = phasesDrawNew;
	return redraw;
}

bool EditView::LinesOverlap() const noexcept {
	return phasesDraw == PhasesDraw::Multiple;
}

void EditView::SetLayoutThreads(unsigned int threads) noexcept {
	maxLayoutThreads = std::clamp(threads, 1U, std::thread::hardware_concurrency());
}

unsigned int EditView::GetLayoutThreads() const noexcept {
	return maxLayoutThreads;
}

void EditView::ClearAllTabstops() noexcept {
	ldTabstops.reset();
}

XYPOSITION EditView::NextTabstopPos(Sci::Line line, XYPOSITION x, XYPOSITION tabWidth) const noexcept {
	const int next = GetNextTabstop(line, static_cast<int>(x + tabWidthMinimumPixels));
	if (next > 0)
		return static_cast<XYPOSITION>(next);
	return (static_cast<int>((x + tabWidthMinimumPixels) / tabWidth) + 1) * tabWidth;
}

bool EditView::ClearTabstops(Sci::Line line) noexcept {
	return ldTabstops && ldTabstops->ClearTabstops(line);
}

bool EditView::AddTabstop(Sci::Line line, int x) {
	if (!ldTabstops) {
		ldTabstops = std::make_unique<LineTabstops>();
	}
	return ldTabstops && ldTabstops->AddTabstop(line, x);
}

int EditView::GetNextTabstop(Sci::Line line, int x) const noexcept {
	if (ldTabstops) {
		return ldTabstops->GetNextTabstop(line, x);
	} else {
		return 0;
	}
}

void EditView::LinesAddedOrRemoved(Sci::Line lineOfPos, Sci::Line linesAdded) {
	if (ldTabstops) {
		if (linesAdded > 0) {
			for (Sci::Line line = lineOfPos; line < lineOfPos + linesAdded; line++) {
				ldTabstops->InsertLine(line);
			}
		} else {
			for (Sci::Line line = (lineOfPos + -linesAdded) - 1; line >= lineOfPos; line--) {
				ldTabstops->RemoveLine(line);
			}
		}
	}
}

void EditView::DropGraphics() noexcept {
	pixmapLine.reset();
	pixmapIndentGuide.reset();
	pixmapIndentGuideHighlight.reset();
}

void EditView::RefreshPixMaps(Surface *surfaceWindow, const ViewStyle &vsDraw) {
	if (!(pixmapIndentGuide && pixmapIndentGuideHighlight)) {
		// 1 extra pixel in height so can handle odd/even positions and so produce a continuous line
		pixmapIndentGuide = surfaceWindow->AllocatePixMap(1, vsDraw.lineHeight + 1);
		pixmapIndentGuideHighlight = surfaceWindow->AllocatePixMap(1, vsDraw.lineHeight + 1);
		const PRectangle rcIG = PRectangle::FromInts(0, 0, 1, vsDraw.lineHeight);
		pixmapIndentGuide->FillRectangle(rcIG, vsDraw.styles[StyleIndentGuide].back);
		pixmapIndentGuideHighlight->FillRectangle(rcIG, vsDraw.styles[StyleBraceLight].back);
		for (int stripe = 1; stripe < vsDraw.lineHeight + 1; stripe += 2) {
			const PRectangle rcPixel = PRectangle::FromInts(0, stripe, 1, stripe + 1);
			pixmapIndentGuide->FillRectangle(rcPixel, vsDraw.styles[StyleIndentGuide].fore);
			pixmapIndentGuideHighlight->FillRectangle(rcPixel, vsDraw.styles[StyleBraceLight].fore);
		}
		pixmapIndentGuide->FlushDrawing();
		pixmapIndentGuideHighlight->FlushDrawing();
	}
}

std::shared_ptr<LineLayout> EditView::RetrieveLineLayout(Sci::Line lineNumber, const EditModel &model) {
	const Sci::Position posLineStart = model.pdoc->LineStart(lineNumber);
	const Sci::Position posLineEnd = model.pdoc->LineStart(lineNumber + 1);
	PLATFORM_ASSERT(posLineEnd >= posLineStart);
	const Sci::Line lineCaret = model.pdoc->SciLineFromPosition(model.sel.MainCaret());
	return llc.Retrieve(lineNumber, lineCaret,
		static_cast<int>(posLineEnd - posLineStart), model.pdoc->GetStyleClock(),
		model.LinesOnScreen() + 1, model.pdoc->LinesTotal());
}

namespace {

constexpr XYPOSITION epsilon = 0.0001f;	// A small nudge to avoid floating point precision issues

/**
* Return the chDoc argument with case transformed as indicated by the caseForce argument.
* chPrevious is needed for camel casing.
* This only affects ASCII characters and is provided for languages with case-insensitive
* ASCII keywords where the user wishes to view keywords in a preferred case.
*/
inline char CaseForce(Style::CaseForce caseForce, char chDoc, char chPrevious) noexcept {
	switch (caseForce) {
	case Style::CaseForce::mixed:
		return chDoc;
	case Style::CaseForce::lower:
		return MakeLowerCase(chDoc);
	case Style::CaseForce::upper:
		return MakeUpperCase(chDoc);
	case Style::CaseForce::camel:
	default:	// default should not occur, included to avoid warnings
		if (IsUpperOrLowerCase(chDoc) && !IsUpperOrLowerCase(chPrevious)) {
			return MakeUpperCase(chDoc);
		} else {
			return MakeLowerCase(chDoc);
		}
	}
}

void LayoutSegments(IPositionCache *pCache,
	Surface *surface,
	const ViewStyle &vstyle,
	LineLayout *ll,
	const std::vector<TextSegment> &segments,
	std::atomic<uint32_t> &nextIndex,
	const bool textUnicode,
	const bool multiThreaded) {
	while (true) {
		const uint32_t i = nextIndex.fetch_add(1, std::memory_order_acq_rel);
		if (i >= segments.size()) {
			break;
		}
		const TextSegment &ts = segments[i];
		const unsigned int styleSegment = ll->styles[ts.start];
		XYPOSITION *positions = &ll->positions[ts.start + 1];
		if (vstyle.styles[styleSegment].visible) {
			if (ts.representation) {
				XYPOSITION representationWidth = 0.0;
				// Tab is a special case of representation, taking a variable amount of space
				// which will be filled in later.
				if (ll->chars[ts.start] != '\t') {
					representationWidth = vstyle.controlCharWidth;
					if (representationWidth <= 0.0) {
						assert(ts.representation->stringRep.length() <= Representation::maxLength);
						XYPOSITION positionsRepr[Representation::maxLength + 1];
						// ts.representation->stringRep is UTF-8.
						pCache->MeasureWidths(surface, vstyle, StyleControlChar, true, ts.representation->stringRep,
							positionsRepr, multiThreaded);
						representationWidth = positionsRepr[ts.representation->stringRep.length() - 1];
						if (FlagSet(ts.representation->appearance, RepresentationAppearance::Blob)) {
							representationWidth += vstyle.ctrlCharPadding;
						}
					}
				}
				std::fill(positions, positions + ts.length, representationWidth);
			} else {
				if ((ts.length == 1) && (' ' == ll->chars[ts.start])) {
					// Over half the segments are single characters and of these about half are space characters.
					positions[0] = vstyle.styles[styleSegment].spaceWidth;
				} else {
					pCache->MeasureWidths(surface, vstyle, styleSegment, textUnicode,
						std::string_view(&ll->chars[ts.start], ts.length), positions, multiThreaded);
				}
			}
		} else if (vstyle.styles[styleSegment].invisibleRepresentation[0]) {
			const std::string_view text = vstyle.styles[styleSegment].invisibleRepresentation;
			XYPOSITION positionsRepr[Representation::maxLength + 1];
			// invisibleRepresentation is UTF-8.
			pCache->MeasureWidths(surface, vstyle, styleSegment, true, text, positionsRepr, multiThreaded);
			const XYPOSITION representationWidth = positionsRepr[text.length() - 1];
			std::fill(positions, positions + ts.length, representationWidth);
		}
	}
}

}

/**
* Fill in the LineLayout data for the given line.
* Copy the given @a line and its styles from the document into local arrays.
* Also determine the x position at which each character starts.
*/
void EditView::LayoutLine(const EditModel &model, Surface *surface, const ViewStyle &vstyle, LineLayout *ll, int width, bool callerMultiThreaded) {
	if (!ll)
		return;
	const Sci::Line line = ll->LineNumber();
	PLATFORM_ASSERT(line < model.pdoc->LinesTotal());
	PLATFORM_ASSERT(ll->chars);
	const Sci::Position posLineStart = model.pdoc->LineStart(line);
	Sci::Position posLineEnd = model.pdoc->LineStart(line + 1);
	// If the line is very long, limit the treatment to a length that should fit in the viewport
	if (posLineEnd >(posLineStart + ll->maxLineLength)) {
		posLineEnd = posLineStart + ll->maxLineLength;
	}
	// Hard to cope when too narrow, so just assume there is space
	width = std::max(width, 20);

	if (ll->validity == LineLayout::ValidLevel::checkTextAndStyle) {
		Sci::Position lineLength = posLineEnd - posLineStart;
		if (!vstyle.viewEOL) {
			lineLength = model.pdoc->LineEnd(line) - posLineStart;
		}
		if (lineLength == ll->numCharsInLine) {
			// See if chars, styles, indicators, are all the same
			bool allSame = true;
			// Check base line layout
			char chPrevious = 0;
			for (Sci::Position numCharsInLine = 0; numCharsInLine < lineLength; numCharsInLine++) {
				const Sci::Position charInDoc = numCharsInLine + posLineStart;
				const char chDoc = model.pdoc->CharAt(charInDoc);
				const int styleByte = model.pdoc->StyleIndexAt(charInDoc);
				allSame = allSame &&
					(ll->styles[numCharsInLine] == styleByte);
				allSame = allSame &&
					(ll->chars[numCharsInLine] == CaseForce(vstyle.styles[styleByte].caseForce, chDoc, chPrevious));
				chPrevious = chDoc;
			}
			const int styleByteLast = (posLineEnd > posLineStart) ? model.pdoc->StyleIndexAt(posLineEnd - 1) : 0;
			allSame = allSame && (ll->styles[lineLength] == styleByteLast);	// For eolFilled
			if (allSame) {
				ll->validity = (ll->widthLine != width) ? LineLayout::ValidLevel::positions : LineLayout::ValidLevel::lines;
			} else {
				ll->validity = LineLayout::ValidLevel::invalid;
			}
		} else {
			ll->validity = LineLayout::ValidLevel::invalid;
		}
	}
	if (ll->validity == LineLayout::ValidLevel::invalid) {
		ll->widthLine = LineLayout::wrapWidthInfinite;
		ll->lines = 1;
		if (vstyle.edgeState == EdgeVisualStyle::Background) {
			Sci::Position edgePosition = model.pdoc->FindColumn(line, vstyle.theEdge.column);
			if (edgePosition >= posLineStart) {
				edgePosition -= posLineStart;
			}
			ll->edgeColumn = static_cast<int>(edgePosition);
		} else {
			ll->edgeColumn = -1;
		}

		// Fill base line layout
		const int lineLength = static_cast<int>(posLineEnd - posLineStart);
		model.pdoc->GetCharRange(ll->chars.get(), posLineStart, lineLength);
		model.pdoc->GetStyleRange(ll->styles.get(), posLineStart, lineLength);
		const int numCharsBeforeEOL = static_cast<int>(model.pdoc->LineEnd(line) - posLineStart);
		const int numCharsInLine = (vstyle.viewEOL) ? lineLength : numCharsBeforeEOL;
		const unsigned char styleByteLast = (lineLength > 0) ? ll->styles[lineLength - 1] : 0;
		if (vstyle.someStylesForceCase) {
			char chPrevious = 0;
			for (int charInLine = 0; charInLine<lineLength; charInLine++) {
				const char chDoc = ll->chars[charInLine];
				ll->chars[charInLine] = CaseForce(vstyle.styles[ll->styles[charInLine]].caseForce, chDoc, chPrevious);
				chPrevious = chDoc;
			}
		}
		ll->xHighlightGuide = 0;
		// Extra element at the end of the line to hold end x position and act as
		ll->chars[numCharsInLine] = 0;   // Also triggers processing in the loops as this is a control character
		ll->styles[numCharsInLine] = styleByteLast;	// For eolFilled

		// Layout the line, determining the position of each character,
		// with an extra element at the end for the end of the line.
		ll->positions[0] = 0;
		bool lastSegItalics = false;

		std::vector<TextSegment> segments;
		BreakFinder bfLayout(ll, nullptr, Range(0, numCharsInLine), posLineStart, 0, BreakFinder::BreakFor::Text, model.pdoc, model.reprs.get(), nullptr);
		while (bfLayout.More()) {
			segments.push_back(bfLayout.Next());
		}

		ll->ClearPositions();

		if (!segments.empty()) {

			const size_t threadsForLength = std::max(1, numCharsInLine / bytesPerLayoutThread);
			size_t threads = std::min<size_t>({ segments.size(), threadsForLength, maxLayoutThreads });
			if (!surface->SupportsFeature(Supports::ThreadSafeMeasureWidths) || callerMultiThreaded) {
				threads = 1;
			}

			std::atomic<uint32_t> nextIndex = 0;

			const bool textUnicode = CpUtf8 == model.pdoc->dbcsCodePage;
			const bool multiThreaded = threads > 1;
			const bool multiThreadedContext = multiThreaded || callerMultiThreaded;
			IPositionCache *pCache = posCache.get();

			// If only 1 thread needed then use the main thread, else spin up multiple
			const std::launch policy = (multiThreaded) ? std::launch::async : std::launch::deferred;

			std::vector<std::future<void>> futures;
			for (size_t th = 0; th < threads; th++) {
				// Find relative positions of everything except for tabs
				std::future<void> fut = std::async(policy,
					[pCache, surface, &vstyle, &ll, &segments, &nextIndex, textUnicode, multiThreadedContext]() {
					LayoutSegments(pCache, surface, vstyle, ll, segments, nextIndex, textUnicode, multiThreadedContext);
				});
				futures.push_back(std::move(fut));
			}
			for (const std::future<void> &f : futures) {
				f.wait();
			}
		}

		// Accumulate absolute positions from relative positions within segments and expand tabs
		XYPOSITION xPosition = 0.0;
		size_t iByte = 0;
		ll->positions[iByte++] = xPosition;
		for (const TextSegment &ts : segments) {
			if (vstyle.styles[ll->styles[ts.start]].visible &&
				ts.representation &&
				(ll->chars[ts.start] == '\t')) {
				// Simple visible tab, go to next tab stop
				const XYPOSITION startTab = ll->positions[ts.start];
				const XYPOSITION nextTab = NextTabstopPos(line, startTab, vstyle.tabWidth);
				xPosition += nextTab - startTab;
			}
			const XYPOSITION xBeginSegment = xPosition;
			for (int i = 0; i < ts.length; i++) {
				xPosition = ll->positions[iByte] + xBeginSegment;
				ll->positions[iByte++] = xPosition;
			}
		}

		if (!segments.empty()) {
			// Not quite the same as before which would effectively ignore trailing invisible segments
			const TextSegment &ts = segments.back();
			lastSegItalics = (!ts.representation) && ((ll->chars[ts.end() - 1] != ' ') && vstyle.styles[ll->styles[ts.start]].italic);
		}

		// Small hack to make lines that end with italics not cut off the edge of the last character
		if (lastSegItalics) {
			ll->positions[numCharsInLine] += vstyle.lastSegItalicsOffset;
		}
		ll->numCharsInLine = numCharsInLine;
		ll->numCharsBeforeEOL = numCharsBeforeEOL;
		ll->validity = LineLayout::ValidLevel::positions;
	}
	if ((ll->validity == LineLayout::ValidLevel::positions) || (ll->widthLine != width)) {
		ll->widthLine = width;
		if (width == LineLayout::wrapWidthInfinite) {
			ll->lines = 1;
		} else if (width > ll->positions[ll->numCharsInLine]) {
			// Simple common case where line does not need wrapping.
			ll->lines = 1;
		} else {
			if (FlagSet(vstyle.wrap.visualFlags, WrapVisualFlag::End)) {
				width -= static_cast<int>(vstyle.aveCharWidth); // take into account the space for end wrap mark
			}
			XYPOSITION wrapAddIndent = 0; // This will be added to initial indent of line
			switch (vstyle.wrap.indentMode) {
			case WrapIndentMode::Fixed:
				wrapAddIndent = vstyle.wrap.visualStartIndent * vstyle.aveCharWidth;
				break;
			case WrapIndentMode::Indent:
				wrapAddIndent = model.pdoc->IndentSize() * vstyle.spaceWidth;
				break;
			case WrapIndentMode::DeepIndent:
				wrapAddIndent = model.pdoc->IndentSize() * 2 * vstyle.spaceWidth;
				break;
			default:	// No additional indent for WrapIndentMode::Fixed
				break;
			}
			ll->wrapIndent = wrapAddIndent;
			if (vstyle.wrap.indentMode != WrapIndentMode::Fixed) {
				for (int i = 0; i < ll->numCharsInLine; i++) {
					if (!IsSpaceOrTab(ll->chars[i])) {
						ll->wrapIndent += ll->positions[i]; // Add line indent
						break;
					}
				}
			}
			// Check for text width minimum
			if (ll->wrapIndent > width - static_cast<int>(vstyle.aveCharWidth) * 15)
				ll->wrapIndent = wrapAddIndent;
			// Check for wrapIndent minimum
			if ((FlagSet(vstyle.wrap.visualFlags, WrapVisualFlag::Start)) && (ll->wrapIndent < vstyle.aveCharWidth))
				ll->wrapIndent = vstyle.aveCharWidth; // Indent to show start visual
			ll->WrapLine(model.pdoc, posLineStart, vstyle.wrap.state, width);
		}
		ll->validity = LineLayout::ValidLevel::lines;
	}
}

// Fill the LineLayout bidirectional data fields according to each char style

void EditView::UpdateBidiData(const EditModel &model, const ViewStyle &vstyle, LineLayout *ll) {
	if (model.BidirectionalEnabled()) {
		ll->EnsureBidiData();
		for (int stylesInLine = 0; stylesInLine < ll->numCharsInLine; stylesInLine++) {
			ll->bidiData->stylesFonts[stylesInLine] = vstyle.styles[ll->styles[stylesInLine]].font;
		}
		ll->bidiData->stylesFonts[ll->numCharsInLine].reset();

		for (int charsInLine = 0; charsInLine < ll->numCharsInLine; charsInLine++) {
			const int charWidth = UTF8DrawBytes(&ll->chars[charsInLine], ll->numCharsInLine - charsInLine);
			const Representation *repr = model.reprs->RepresentationFromCharacter(std::string_view(&ll->chars[charsInLine], charWidth));

			ll->bidiData->widthReprs[charsInLine] = 0.0f;
			if (repr && ll->chars[charsInLine] != '\t') {
				ll->bidiData->widthReprs[charsInLine] = ll->positions[charsInLine + charWidth] - ll->positions[charsInLine];
			}
			if (charWidth > 1) {
				for (int c = 1; c < charWidth; c++) {
					charsInLine++;
					ll->bidiData->widthReprs[charsInLine] = 0.0f;
				}
			}
		}
		ll->bidiData->widthReprs[ll->numCharsInLine] = 0.0f;
	} else {
		ll->bidiData.reset();
	}
}

Point EditView::LocationFromPosition(Surface *surface, const EditModel &model, SelectionPosition pos, Sci::Line topLine,
				     const ViewStyle &vs, PointEnd pe, const PRectangle rcClient) {
	Point pt;
	if (pos.Position() == Sci::invalidPosition)
		return pt;
	Sci::Line lineDoc = model.pdoc->SciLineFromPosition(pos.Position());
	Sci::Position posLineStart = model.pdoc->LineStart(lineDoc);
	if (FlagSet(pe, PointEnd::lineEnd) && (lineDoc > 0) && (pos.Position() == posLineStart)) {
		// Want point at end of first line
		lineDoc--;
		posLineStart = model.pdoc->LineStart(lineDoc);
	}
	const Sci::Line lineVisible = model.pcs->DisplayFromDoc(lineDoc);
	std::shared_ptr<LineLayout> ll = RetrieveLineLayout(lineDoc, model);
	if (surface && ll) {
		LayoutLine(model, surface, vs, ll.get(), model.wrapWidth);
		const int posInLine = static_cast<int>(pos.Position() - posLineStart);
		pt = ll->PointFromPosition(posInLine, vs.lineHeight, pe);
		pt.x += vs.textStart - model.xOffset;

		if (model.BidirectionalEnabled()) {
			// Fill the line bidi data
			UpdateBidiData(model, vs, ll.get());

			// Find subLine
			const int subLine = ll->SubLineFromPosition(posInLine, pe);
			const int caretPosition = posInLine - ll->LineStart(subLine);

			// Get the point from current position
			const ScreenLine screenLine(ll.get(), subLine, vs, rcClient.right, tabWidthMinimumPixels);
			std::unique_ptr<IScreenLineLayout> slLayout = surface->Layout(&screenLine);
			pt.x = slLayout->XFromPosition(caretPosition);

			pt.x += vs.textStart - model.xOffset;

			pt.y = 0;
			if (posInLine >= ll->LineStart(subLine)) {
				pt.y = static_cast<XYPOSITION>(subLine*vs.lineHeight);
			}
		}
		pt.y += static_cast<XYPOSITION>((lineVisible - topLine) * vs.lineHeight);
		pt.x += pos.VirtualSpaceWidth(vs.styles[ll->EndLineStyle()].spaceWidth);
	}
	return pt;
}

Range EditView::RangeDisplayLine(Surface *surface, const EditModel &model, Sci::Line lineVisible, const ViewStyle &vs) {
	Range rangeSubLine = Range(0, 0);
	if (lineVisible < 0) {
		return rangeSubLine;
	}
	const Sci::Line lineDoc = model.pcs->DocFromDisplay(lineVisible);
	const Sci::Position positionLineStart = model.pdoc->LineStart(lineDoc);
	std::shared_ptr<LineLayout> ll = RetrieveLineLayout(lineDoc, model);
	if (surface && ll) {
		LayoutLine(model, surface, vs, ll.get(), model.wrapWidth);
		const Sci::Line lineStartSet = model.pcs->DisplayFromDoc(lineDoc);
		const int subLine = static_cast<int>(lineVisible - lineStartSet);
		if (subLine < ll->lines) {
			rangeSubLine = ll->SubLineRange(subLine, LineLayout::Scope::visibleOnly);
			if (subLine == ll->lines-1) {
				rangeSubLine.end = model.pdoc->LineStart(lineDoc + 1) -
					positionLineStart;
			}
		}
	}
	rangeSubLine.start += positionLineStart;
	rangeSubLine.end += positionLineStart;
	return rangeSubLine;
}

SelectionPosition EditView::SPositionFromLocation(Surface *surface, const EditModel &model, PointDocument pt, bool canReturnInvalid,
	bool charPosition, bool virtualSpace, const ViewStyle &vs, const PRectangle rcClient) {
	pt.x = pt.x - vs.textStart;
	Sci::Line visibleLine = static_cast<int>(std::floor(pt.y / vs.lineHeight));
	if (!canReturnInvalid && (visibleLine < 0))
		visibleLine = 0;
	const Sci::Line lineDoc = model.pcs->DocFromDisplay(visibleLine);
	if (canReturnInvalid && (lineDoc < 0))
		return SelectionPosition(Sci::invalidPosition);
	if (lineDoc >= model.pdoc->LinesTotal())
		return SelectionPosition(canReturnInvalid ? Sci::invalidPosition :
			model.pdoc->Length());
	const Sci::Position posLineStart = model.pdoc->LineStart(lineDoc);
	std::shared_ptr<LineLayout> ll = RetrieveLineLayout(lineDoc, model);
	if (surface && ll) {
		LayoutLine(model, surface, vs, ll.get(), model.wrapWidth);
		const Sci::Line lineStartSet = model.pcs->DisplayFromDoc(lineDoc);
		int subLine = static_cast<int>(visibleLine - lineStartSet); //Au: no const

		//Au: prevent jumping caret to the end of line on click (or drag) on an annotation. It's very annoying, eg may scroll.
		//Platform::DebugPrintf("%i %i %i", lineStartSet, subLine, ll->lines);
		//It seems that ll->lines is the number of text lines (including wrapped lines but not annotations).
		if(subLine >= ll->lines) subLine = ll->lines - 1; //if annotation, use the last text line

		if (subLine < ll->lines) {
			const Range rangeSubLine = ll->SubLineRange(subLine, LineLayout::Scope::visibleOnly);
			const XYPOSITION subLineStart = ll->positions[rangeSubLine.start];
			if (subLine > 0)	// Wrapped
				pt.x -= ll->wrapIndent;
			Sci::Position positionInLine = 0;
			if (model.BidirectionalEnabled()) {
				// Fill the line bidi data
				UpdateBidiData(model, vs, ll.get());

				const ScreenLine screenLine(ll.get(), subLine, vs, rcClient.right, tabWidthMinimumPixels);
				std::unique_ptr<IScreenLineLayout> slLayout = surface->Layout(&screenLine);
				positionInLine = slLayout->PositionFromX(pt.x, charPosition) +
					rangeSubLine.start;
			} else {
				positionInLine = ll->FindPositionFromX(pt.x + subLineStart,
					rangeSubLine, charPosition);
			}
			if (positionInLine < rangeSubLine.end) {
				return SelectionPosition(model.pdoc->MovePositionOutsideChar(positionInLine + posLineStart, 1));
			}
			if (virtualSpace) {
				const XYPOSITION spaceWidth = vs.styles[ll->EndLineStyle()].spaceWidth;
				const int spaceOffset = static_cast<int>(
					(pt.x + subLineStart - ll->positions[rangeSubLine.end] + spaceWidth / 2) / spaceWidth);
				return SelectionPosition(rangeSubLine.end + posLineStart, spaceOffset);
			} else if (canReturnInvalid) {
				if (pt.x < (ll->positions[rangeSubLine.end] - subLineStart)) {
					return SelectionPosition(model.pdoc->MovePositionOutsideChar(rangeSubLine.end + posLineStart, 1));
				}
			} else {
				return SelectionPosition(rangeSubLine.end + posLineStart);
			}
		}
		if (!canReturnInvalid)
			return SelectionPosition(ll->numCharsInLine + posLineStart);
	}
	return SelectionPosition(canReturnInvalid ? Sci::invalidPosition : posLineStart);
}

/**
* Find the document position corresponding to an x coordinate on a particular document line.
* Ensure is between whole characters when document is in multi-byte or UTF-8 mode.
* This method is used for rectangular selections and does not work on wrapped lines.
*/
SelectionPosition EditView::SPositionFromLineX(Surface *surface, const EditModel &model, Sci::Line lineDoc, int x, const ViewStyle &vs) {
	std::shared_ptr<LineLayout> ll = RetrieveLineLayout(lineDoc, model);
	if (surface && ll) {
		const Sci::Position posLineStart = model.pdoc->LineStart(lineDoc);
		LayoutLine(model, surface, vs, ll.get(), model.wrapWidth);
		const Range rangeSubLine = ll->SubLineRange(0, LineLayout::Scope::visibleOnly);
		const XYPOSITION subLineStart = ll->positions[rangeSubLine.start];
		const Sci::Position positionInLine = ll->FindPositionFromX(x + subLineStart, rangeSubLine, false);
		if (positionInLine < rangeSubLine.end) {
			return SelectionPosition(model.pdoc->MovePositionOutsideChar(positionInLine + posLineStart, 1));
		}
		const XYPOSITION spaceWidth = vs.styles[ll->EndLineStyle()].spaceWidth;
		const int spaceOffset = static_cast<int>(
			(x + subLineStart - ll->positions[rangeSubLine.end] + spaceWidth / 2) / spaceWidth);
		return SelectionPosition(rangeSubLine.end + posLineStart, spaceOffset);
	}
	return SelectionPosition(0);
}

Sci::Line EditView::DisplayFromPosition(Surface *surface, const EditModel &model, Sci::Position pos, const ViewStyle &vs) {
	const Sci::Line lineDoc = model.pdoc->SciLineFromPosition(pos);
	Sci::Line lineDisplay = model.pcs->DisplayFromDoc(lineDoc);
	std::shared_ptr<LineLayout> ll = RetrieveLineLayout(lineDoc, model);
	if (surface && ll) {
		LayoutLine(model, surface, vs, ll.get(), model.wrapWidth);
		const Sci::Position posLineStart = model.pdoc->LineStart(lineDoc);
		const Sci::Position posInLine = pos - posLineStart;
		lineDisplay--; // To make up for first increment ahead.
		for (int subLine = 0; subLine < ll->lines; subLine++) {
			if (posInLine >= ll->LineStart(subLine)) {
				lineDisplay++;
			}
		}
	}
	return lineDisplay;
}

Sci::Position EditView::StartEndDisplayLine(Surface *surface, const EditModel &model, Sci::Position pos, bool start, const ViewStyle &vs) {
	const Sci::Line line = model.pdoc->SciLineFromPosition(pos);
	std::shared_ptr<LineLayout> ll = RetrieveLineLayout(line, model);
	Sci::Position posRet = Sci::invalidPosition;
	if (surface && ll) {
		const Sci::Position posLineStart = model.pdoc->LineStart(line);
		LayoutLine(model, surface, vs, ll.get(), model.wrapWidth);
		const Sci::Position posInLine = pos - posLineStart;
		if (posInLine <= ll->maxLineLength) {
			for (int subLine = 0; subLine < ll->lines; subLine++) {
				if ((posInLine >= ll->LineStart(subLine)) &&
				    (posInLine <= ll->LineStart(subLine + 1)) &&
				    (posInLine <= ll->numCharsBeforeEOL)) {
					if (start) {
						posRet = ll->LineStart(subLine) + posLineStart;
					} else {
						if (subLine == ll->lines - 1)
							posRet = ll->numCharsBeforeEOL + posLineStart;
						else
							posRet = model.pdoc->MovePositionOutsideChar(ll->LineStart(subLine + 1) + posLineStart - 1, -1, false);
					}
				}
			}
		}
	}
	return posRet;
}

namespace {

constexpr ColourRGBA colourBug(0xff, 0, 0xfe, 0xf0);

// Selection background colours are always defined, the value_or is to show if bug

ColourRGBA SelectionBackground(const EditModel &model, const ViewStyle &vsDraw, InSelection inSelection) {
	if (inSelection == InSelection::inNone)
		return colourBug;	// Not selected is a bug

	Element element = Element::SelectionBack;
	if (inSelection == InSelection::inAdditional)
		element = Element::SelectionAdditionalBack;
	if (!model.primarySelection)
		element = Element::SelectionSecondaryBack;
	if (!model.hasFocus) {
		if (inSelection == InSelection::inAdditional) {
			if (ColourOptional colour = vsDraw.ElementColour(Element::SelectionInactiveAdditionalBack)) {
				return *colour;
			}
		}
		if (ColourOptional colour = vsDraw.ElementColour(Element::SelectionInactiveBack)) {
			return *colour;
		}
	}
	return vsDraw.ElementColour(element).value_or(colourBug);
}

ColourOptional SelectionForeground(const EditModel &model, const ViewStyle &vsDraw, InSelection inSelection) {
	if (inSelection == InSelection::inNone)
		return {};
	Element element = Element::SelectionText;
	if (inSelection == InSelection::inAdditional)
		element = Element::SelectionAdditionalText;
	if (!model.primarySelection)	// Secondary selection
		element = Element::SelectionSecondaryText;
	if (!model.hasFocus) {
		if (inSelection == InSelection::inAdditional) {
			if (ColourOptional colour = vsDraw.ElementColour(Element::SelectionInactiveAdditionalText)) {
				return colour;
			}
		}
		element = Element::SelectionInactiveText;
	}
	return vsDraw.ElementColour(element);
}

ColourRGBA TextBackground(const EditModel &model, const ViewStyle &vsDraw, const LineLayout *ll,
	ColourOptional background, InSelection inSelection, bool inHotspot, int styleMain, Sci::Position i) {
	if (inSelection && (vsDraw.selection.layer == Layer::Base)) {
		return SelectionBackground(model, vsDraw, inSelection).Opaque();
	}
	if ((vsDraw.edgeState == EdgeVisualStyle::Background) &&
		(i >= ll->edgeColumn) &&
		(i < ll->numCharsBeforeEOL))
		return vsDraw.theEdge.colour;
	if (inHotspot) {
		if (const ColourOptional colourHotSpotBack = vsDraw.ElementColour(Element::HotSpotActiveBack)) {
			return colourHotSpotBack->Opaque();
		}
	}
	if (background && (styleMain != StyleBraceLight) && (styleMain != StyleBraceBad)) {
		return *background;
	} else {
		return vsDraw.styles[styleMain].back;
	}
}

void DrawTextBlob(Surface *surface, const ViewStyle &vsDraw, PRectangle rcSegment,
	std::string_view text, ColourRGBA textBack, ColourRGBA textFore, bool fillBackground) {
	if (rcSegment.Empty())
		return;
	if (fillBackground) {
		surface->FillRectangleAligned(rcSegment, Fill(textBack));
	}
	const Font *ctrlCharsFont = vsDraw.styles[StyleControlChar].font.get();
	const int normalCharHeight = static_cast<int>(std::ceil(vsDraw.styles[StyleControlChar].capitalHeight));
	PRectangle rcCChar = rcSegment;
	rcCChar.left = rcCChar.left + 1;
	rcCChar.top = rcSegment.top + vsDraw.maxAscent - normalCharHeight;
	rcCChar.bottom = rcSegment.top + vsDraw.maxAscent + 1;
	PRectangle rcCentral = rcCChar;
	rcCentral.top++;
	rcCentral.bottom--;
	surface->FillRectangleAligned(rcCentral, Fill(textFore));
	PRectangle rcChar = rcCChar;
	rcChar.left++;
	rcChar.right--;
	surface->DrawTextClippedUTF8(rcChar, ctrlCharsFont,
		rcSegment.top + vsDraw.maxAscent, text,
		textBack, textFore);
}

void FillLineRemainder(Surface *surface, const EditModel &model, const ViewStyle &vsDraw, const LineLayout *ll,
	Sci::Line line, PRectangle rcArea, int subLine) {
	InSelection eolInSelection = InSelection::inNone;
	if (vsDraw.selection.visible && (subLine == (ll->lines - 1))) {
		eolInSelection = model.LineEndInSelection(line);
	}

	if (eolInSelection && vsDraw.selection.eolFilled && (line < model.pdoc->LinesTotal() - 1) && (vsDraw.selection.layer == Layer::Base)) {
		surface->FillRectangleAligned(rcArea, Fill(SelectionBackground(model, vsDraw, eolInSelection).Opaque()));
	} else {
		const ColourOptional background = vsDraw.Background(model.GetMark(line), model.caret.active, ll->containsCaret);
		if (background) {
			surface->FillRectangleAligned(rcArea, Fill(*background));
		} else if (vsDraw.styles[ll->styles[ll->numCharsInLine]].eolFilled) {
			surface->FillRectangleAligned(rcArea, Fill(vsDraw.styles[ll->styles[ll->numCharsInLine]].back));
		} else {
			surface->FillRectangleAligned(rcArea, Fill(vsDraw.styles[StyleDefault].back));
		}
		if (eolInSelection && vsDraw.selection.eolFilled && (line < model.pdoc->LinesTotal() - 1) && (vsDraw.selection.layer != Layer::Base)) {
			surface->FillRectangleAligned(rcArea, SelectionBackground(model, vsDraw, eolInSelection));
		}
	}
}

}

void EditView::DrawEOL(Surface *surface, const EditModel &model, const ViewStyle &vsDraw, const LineLayout *ll,
	Sci::Line line, int xStart, PRectangle rcLine, int subLine, Sci::Position lineEnd, XYPOSITION subLineStart, ColourOptional background) {

	const Sci::Position posLineStart = model.pdoc->LineStart(line);
	PRectangle rcSegment = rcLine;

	const bool lastSubLine = subLine == (ll->lines - 1);
	XYPOSITION virtualSpace = 0;
	if (lastSubLine) {
		const XYPOSITION spaceWidth = vsDraw.styles[ll->EndLineStyle()].spaceWidth;
		virtualSpace = static_cast<XYPOSITION>(model.sel.VirtualSpaceFor(model.pdoc->LineEnd(line))) * spaceWidth;
	}
	const XYPOSITION xEol = ll->positions[lineEnd] - subLineStart;

	// Fill the virtual space and show selections within it
	if (virtualSpace > 0.0f) {
		rcSegment.left = xEol + xStart;
		rcSegment.right = xEol + xStart + virtualSpace;
		const ColourRGBA backgroundFill = background.value_or(vsDraw.styles[ll->styles[ll->numCharsInLine]].back);
		surface->FillRectangleAligned(rcSegment, backgroundFill);
		if (vsDraw.selection.visible && (vsDraw.selection.layer == Layer::Base)) {
			const SelectionSegment virtualSpaceRange(SelectionPosition(model.pdoc->LineEnd(line)),
				SelectionPosition(model.pdoc->LineEnd(line),
					model.sel.VirtualSpaceFor(model.pdoc->LineEnd(line))));
			for (size_t r = 0; r<model.sel.Count(); r++) {
				const SelectionSegment portion = model.sel.Range(r).Intersect(virtualSpaceRange);
				if (!portion.Empty()) {
					const XYPOSITION spaceWidth = vsDraw.styles[ll->EndLineStyle()].spaceWidth;
					rcSegment.left = xStart + ll->positions[portion.start.Position() - posLineStart] -
						subLineStart + portion.start.VirtualSpaceWidth(spaceWidth);
					rcSegment.right = xStart + ll->positions[portion.end.Position() - posLineStart] -
						subLineStart + portion.end.VirtualSpaceWidth(spaceWidth);
					rcSegment.left = (rcSegment.left > rcLine.left) ? rcSegment.left : rcLine.left;
					rcSegment.right = (rcSegment.right < rcLine.right) ? rcSegment.right : rcLine.right;
					surface->FillRectangleAligned(rcSegment, Fill(
						SelectionBackground(model, vsDraw, model.sel.RangeType(r)).Opaque()));
				}
			}
		}
	}

	InSelection eolInSelection = InSelection::inNone;
	if (vsDraw.selection.visible && lastSubLine) {
		eolInSelection = model.LineEndInSelection(line);
	}

	const ColourRGBA selectionBack = SelectionBackground(model, vsDraw, eolInSelection);

	// Draw the [CR], [LF], or [CR][LF] blobs if visible line ends are on
	XYPOSITION blobsWidth = 0;
	if (lastSubLine) {
		for (Sci::Position eolPos = ll->numCharsBeforeEOL; eolPos<ll->numCharsInLine;) {
			const int styleMain = ll->styles[eolPos];
			const ColourOptional selectionFore = SelectionForeground(model, vsDraw, eolInSelection);
			ColourRGBA textFore = selectionFore.value_or(vsDraw.styles[styleMain].fore);
			char hexits[4] = "";
			std::string_view ctrlChar;
			Sci::Position widthBytes = 1;
			RepresentationAppearance appearance = RepresentationAppearance::Blob;
			const Representation *repr = model.reprs->RepresentationFromCharacter(std::string_view(&ll->chars[eolPos], ll->numCharsInLine - eolPos));
			if (repr) {
				// Representation of whole text
				widthBytes = ll->numCharsInLine - eolPos;
			} else {
				repr = model.reprs->RepresentationFromCharacter(std::string_view(&ll->chars[eolPos], 1));
			}
			if (repr) {
				ctrlChar = repr->stringRep;
				appearance = repr->appearance;
				if (FlagSet(appearance, RepresentationAppearance::Colour)) {
					textFore = repr->colour;
				}
			} else {
				const unsigned char chEOL = ll->chars[eolPos];
				if (UTF8IsAscii(chEOL)) {
					ctrlChar = ControlCharacterString(chEOL);
				} else {
					Hexits(hexits, chEOL);
					ctrlChar = hexits;
				}
			}

			rcSegment.left = xStart + ll->positions[eolPos] - subLineStart + virtualSpace;
			rcSegment.right = xStart + ll->positions[eolPos + widthBytes] - subLineStart + virtualSpace;
			blobsWidth += rcSegment.Width();
			const ColourRGBA textBack = TextBackground(model, vsDraw, ll, background, eolInSelection, false, styleMain, eolPos);
			if (eolInSelection && (line < model.pdoc->LinesTotal() - 1)) {
				if (vsDraw.selection.layer == Layer::Base) {
					surface->FillRectangleAligned(rcSegment, Fill(selectionBack.Opaque()));
				} else {
					surface->FillRectangleAligned(rcSegment, Fill(textBack));
				}
			} else {
				surface->FillRectangleAligned(rcSegment, Fill(textBack));
			}
			const bool drawEOLSelection = eolInSelection && (line < model.pdoc->LinesTotal() - 1);
			ColourRGBA blobText = textBack;
			if (drawEOLSelection && (vsDraw.selection.layer == Layer::UnderText)) {
				surface->FillRectangleAligned(rcSegment, selectionBack);
				blobText = textBack.MixedWith(selectionBack, selectionBack.GetAlphaComponent());
			}
			if (FlagSet(appearance, RepresentationAppearance::Blob)) {
				DrawTextBlob(surface, vsDraw, rcSegment, ctrlChar, blobText, textFore, phasesDraw == PhasesDraw::One);
			} else {
				surface->DrawTextTransparentUTF8(rcSegment, vsDraw.styles[StyleControlChar].font.get(),
					rcSegment.top + vsDraw.maxAscent, ctrlChar, textFore);
			}
			if (drawEOLSelection && (vsDraw.selection.layer == Layer::OverText)) {
				surface->FillRectangleAligned(rcSegment, selectionBack);
			}
			eolPos += widthBytes;
		}
	}

	// Draw the eol-is-selected rectangle
	rcSegment.left = xEol + xStart + virtualSpace + blobsWidth;
	rcSegment.right = rcSegment.left + vsDraw.aveCharWidth;

	if (eolInSelection && (line < model.pdoc->LinesTotal() - 1) && (vsDraw.selection.layer == Layer::Base)) {
		surface->FillRectangleAligned(rcSegment, Fill(selectionBack.Opaque()));
	} else {
		if (background) {
			surface->FillRectangleAligned(rcSegment, Fill(*background));
		} else if (line < model.pdoc->LinesTotal() - 1) {
			surface->FillRectangleAligned(rcSegment, Fill(vsDraw.styles[ll->styles[ll->numCharsInLine]].back));
		} else if (vsDraw.styles[ll->styles[ll->numCharsInLine]].eolFilled) {
			surface->FillRectangleAligned(rcSegment, Fill(vsDraw.styles[ll->styles[ll->numCharsInLine]].back));
		} else {
			surface->FillRectangleAligned(rcSegment, Fill(vsDraw.styles[StyleDefault].back));
		}
		if (eolInSelection && (line < model.pdoc->LinesTotal() - 1) && (vsDraw.selection.layer != Layer::Base)) {
			surface->FillRectangleAligned(rcSegment, selectionBack);
		}
	}

	rcSegment.left = rcSegment.right;
	if (rcSegment.left < rcLine.left)
		rcSegment.left = rcLine.left;
	rcSegment.right = rcLine.right;

	const bool drawEOLAnnotationStyledText = (vsDraw.eolAnnotationVisible != EOLAnnotationVisible::Hidden) && model.pdoc->EOLAnnotationStyledText(line).text;
	const bool fillRemainder = (!lastSubLine || (!model.GetFoldDisplayText(line) && !drawEOLAnnotationStyledText));
	if (fillRemainder) {
		// Fill the remainder of the line
		FillLineRemainder(surface, model, vsDraw, ll, line, rcSegment, subLine);
	}

	bool drawWrapMarkEnd = false;

	if (subLine + 1 < ll->lines) {
		if (FlagSet(vsDraw.wrap.visualFlags, WrapVisualFlag::End)) {
			drawWrapMarkEnd = ll->LineStart(subLine + 1) != 0;
		}
		if (vsDraw.IsLineFrameOpaque(model.caret.active, ll->containsCaret)) {
			// Draw right of frame under marker
			surface->FillRectangleAligned(Side(rcLine, Edge::right, vsDraw.GetFrameWidth()),
				vsDraw.ElementColourForced(Element::CaretLineBack).Opaque());
		}
	}

	if (drawWrapMarkEnd) {
		PRectangle rcPlace = rcSegment;
		const XYPOSITION maxLeft = rcPlace.right - vsDraw.aveCharWidth;

		if (FlagSet(vsDraw.wrap.visualFlagsLocation, WrapVisualLocation::EndByText)) {
			rcPlace.left = std::min(xEol + xStart + virtualSpace, maxLeft);
			rcPlace.right = rcPlace.left + vsDraw.aveCharWidth;
		} else {
			// rcLine is clipped to text area
			rcPlace.right = rcLine.right;
			rcPlace.left = maxLeft;
		}
		if (!customDrawWrapMarker) {
			DrawWrapMarker(surface, rcPlace, true, vsDraw.WrapColour());
		} else {
			customDrawWrapMarker(surface, rcPlace, true, vsDraw.WrapColour());
		}
	}
}

void EditView::DrawFoldDisplayText(Surface *surface, const EditModel &model, const ViewStyle &vsDraw, const LineLayout *ll,
							  Sci::Line line, int xStart, PRectangle rcLine, int subLine, XYPOSITION subLineStart, DrawPhase phase) {
	const bool lastSubLine = subLine == (ll->lines - 1);
	if (!lastSubLine)
		return;

	const char *text = model.GetFoldDisplayText(line);
	if (!text)
		return;

	PRectangle rcSegment = rcLine;
	const std::string_view foldDisplayText(text);
	const Font *fontText = vsDraw.styles[StyleFoldDisplayText].font.get();
	const int widthFoldDisplayText = static_cast<int>(surface->WidthText(fontText, foldDisplayText));

	InSelection eolInSelection = InSelection::inNone;
	if (vsDraw.selection.visible) {
		eolInSelection = model.LineEndInSelection(line);
	}

	const XYPOSITION spaceWidth = vsDraw.styles[ll->EndLineStyle()].spaceWidth;
	const XYPOSITION virtualSpace = static_cast<XYPOSITION>(model.sel.VirtualSpaceFor(
		model.pdoc->LineEnd(line))) * spaceWidth;
	rcSegment.left = xStart + ll->positions[ll->numCharsInLine] - subLineStart + virtualSpace + vsDraw.aveCharWidth;
	rcSegment.right = rcSegment.left + static_cast<XYPOSITION>(widthFoldDisplayText);

	const ColourOptional background = vsDraw.Background(model.GetMark(line), model.caret.active, ll->containsCaret);
	const ColourOptional selectionFore = SelectionForeground(model, vsDraw, eolInSelection);
	const ColourRGBA textFore = selectionFore.value_or(vsDraw.styles[StyleFoldDisplayText].fore);
	const ColourRGBA textBack = TextBackground(model, vsDraw, ll, background, eolInSelection,
											false, StyleFoldDisplayText, -1);

	if (model.trackLineWidth) {
		if (rcSegment.right + 1> lineWidthMaxSeen) {
			// Fold display text border drawn on rcSegment.right with width 1 is the last visible object of the line
			lineWidthMaxSeen = static_cast<int>(rcSegment.right + 1);
		}
	}

	if (FlagSet(phase, DrawPhase::back)) {
		surface->FillRectangleAligned(rcSegment, Fill(textBack));

		// Fill Remainder of the line
		PRectangle rcRemainder = rcSegment;
		rcRemainder.left = rcRemainder.right;
		if (rcRemainder.left < rcLine.left)
			rcRemainder.left = rcLine.left;
		rcRemainder.right = rcLine.right;
		FillLineRemainder(surface, model, vsDraw, ll, line, rcRemainder, subLine);
	}

	if (FlagSet(phase, DrawPhase::text)) {
		if (phasesDraw != PhasesDraw::One) {
			surface->DrawTextTransparent(rcSegment, fontText,
				rcSegment.top + vsDraw.maxAscent, foldDisplayText,
				textFore);
		} else {
			surface->DrawTextNoClip(rcSegment, fontText,
				rcSegment.top + vsDraw.maxAscent, foldDisplayText,
				textFore, textBack);
		}
	}

	if (FlagSet(phase, DrawPhase::indicatorsFore)) {
		if (model.foldDisplayTextStyle == FoldDisplayTextStyle::Boxed) {
			PRectangle rcBox = rcSegment;
			rcBox.left = std::round(rcSegment.left);
			rcBox.right = std::round(rcSegment.right);
			surface->RectangleFrame(rcBox, Stroke(textFore));
		}
	}

	if (FlagSet(phase, DrawPhase::selectionTranslucent)) {
		if (eolInSelection && (line < model.pdoc->LinesTotal() - 1) && (vsDraw.selection.layer != Layer::Base)) {
			surface->FillRectangleAligned(rcSegment, SelectionBackground(model, vsDraw, eolInSelection));
		}
	}
}

void EditView::DrawEOLAnnotationText(Surface *surface, const EditModel &model, const ViewStyle &vsDraw, const LineLayout *ll,
	Sci::Line line, int xStart, PRectangle rcLine, int subLine, XYPOSITION subLineStart, DrawPhase phase) {

	const bool lastSubLine = subLine == (ll->lines - 1);
	if (!lastSubLine)
		return;

	if (vsDraw.eolAnnotationVisible == EOLAnnotationVisible::Hidden) {
		return;
	}
	const StyledText stEOLAnnotation = model.pdoc->EOLAnnotationStyledText(line);
	if (!stEOLAnnotation.text || !ValidStyledText(vsDraw, vsDraw.eolAnnotationStyleOffset, stEOLAnnotation)) {
		return;
	}
	const std::string_view eolAnnotationText(stEOLAnnotation.text, stEOLAnnotation.length);
	const size_t style = stEOLAnnotation.style + vsDraw.eolAnnotationStyleOffset;

	PRectangle rcSegment = rcLine;
	const Font *fontText = vsDraw.styles[style].font.get();

	const Surface::Ends ends = static_cast<Surface::Ends>(static_cast<int>(vsDraw.eolAnnotationVisible) & 0xff);
	const Surface::Ends leftSide = static_cast<Surface::Ends>(static_cast<int>(ends) & 0xf);
	const Surface::Ends rightSide = static_cast<Surface::Ends>(static_cast<int>(ends) & 0xf0);

	XYPOSITION leftBoxSpace = 0;
	XYPOSITION rightBoxSpace = 0;
	if (vsDraw.eolAnnotationVisible >= EOLAnnotationVisible::Boxed) {
		leftBoxSpace = 1;
		rightBoxSpace = 1;
		if (vsDraw.eolAnnotationVisible != EOLAnnotationVisible::Boxed) {
			switch (leftSide) {
			case Surface::Ends::leftFlat:
				leftBoxSpace = 1;
				break;
			case Surface::Ends::leftAngle:
				leftBoxSpace = rcLine.Height() / 2.0;
				break;
			case Surface::Ends::semiCircles:
			default:
				leftBoxSpace = rcLine.Height() / 3.0;
			   break;
			}
			switch (rightSide) {
			case Surface::Ends::rightFlat:
				rightBoxSpace = 1;
				break;
			case Surface::Ends::rightAngle:
				rightBoxSpace = rcLine.Height() / 2.0;
				break;
			case Surface::Ends::semiCircles:
			default:
				rightBoxSpace = rcLine.Height() / 3.0;
			   break;
			}
		}
	}
	const int widthEOLAnnotationText = static_cast<int>(surface->WidthTextUTF8(fontText, eolAnnotationText) +
		leftBoxSpace + rightBoxSpace);

	const XYPOSITION spaceWidth = vsDraw.styles[ll->EndLineStyle()].spaceWidth;
	const XYPOSITION virtualSpace = static_cast<XYPOSITION>(model.sel.VirtualSpaceFor(
		model.pdoc->LineEnd(line))) * spaceWidth;
	rcSegment.left = xStart +
		ll->positions[ll->numCharsInLine] - subLineStart
		+ virtualSpace + vsDraw.aveCharWidth;

	const char *textFoldDisplay = model.GetFoldDisplayText(line);
	if (textFoldDisplay) {
		const std::string_view foldDisplayText(textFoldDisplay);
		rcSegment.left += static_cast<int>(
			surface->WidthText(vsDraw.styles[StyleFoldDisplayText].font.get(), foldDisplayText)) +
			vsDraw.aveCharWidth;
	}
	rcSegment.right = rcSegment.left + static_cast<XYPOSITION>(widthEOLAnnotationText);

	const ColourOptional background = vsDraw.Background(model.GetMark(line), model.caret.active, ll->containsCaret);
	const ColourRGBA textFore = vsDraw.styles[style].fore;
	const ColourRGBA textBack = TextBackground(model, vsDraw, ll, background, InSelection::inNone,
											false, static_cast<int>(style), -1);

	if (model.trackLineWidth) {
		if (rcSegment.right + 1> lineWidthMaxSeen) {
			// EOL Annotation text border drawn on rcSegment.right with width 1 is the last visible object of the line
			lineWidthMaxSeen = static_cast<int>(rcSegment.right + 1);
		}
	}

	if (FlagSet(phase, DrawPhase::back)) {
		// This fills in the whole remainder of the line even though
		// it may be double drawing. This is to allow stadiums with
		// curved or angled ends to have the area outside in the correct
		// background colour.
		PRectangle rcRemainder = rcSegment;
		rcRemainder.right = rcLine.right;
		FillLineRemainder(surface, model, vsDraw, ll, line, rcRemainder, subLine);
	}

	PRectangle rcText = rcSegment;
	rcText.left += leftBoxSpace;
	rcText.right -= rightBoxSpace;

	// For single phase drawing, draw the text then any box over it
	if (FlagSet(phase, DrawPhase::text)) {
		if (phasesDraw == PhasesDraw::One) {
			surface->DrawTextNoClipUTF8(rcText, fontText,
			rcText.top + vsDraw.maxAscent, eolAnnotationText,
			textFore, textBack);
		}
	}

	// Draw any box or stadium shape
	if (FlagSet(phase, DrawPhase::indicatorsBack)) {
		const PRectangle rcBox = PixelAlign(rcSegment, 1);

		switch (vsDraw.eolAnnotationVisible) {
		case EOLAnnotationVisible::Standard:
			if (phasesDraw != PhasesDraw::One) {
				surface->FillRectangle(rcBox, textBack);
			}
			break;

		case EOLAnnotationVisible::Boxed:
			if (phasesDraw == PhasesDraw::One) {
				// Draw a rectangular outline around the text
				surface->RectangleFrame(rcBox, textFore);
			} else {
				// Draw with a fill to fill the edges of the rectangle.
				surface->RectangleDraw(rcBox, FillStroke(textBack, textFore));
			}
			break;

		default:
			if (phasesDraw == PhasesDraw::One) {
				// Draw an outline around the text
				surface->Stadium(rcBox, FillStroke(ColourRGBA(textBack, 0), textFore), ends);
			} else {
				// Draw with a fill to fill the edges of the shape.
				surface->Stadium(rcBox, FillStroke(textBack, textFore), ends);
			}
			break;
		}
	}

	// For multi-phase drawing draw the text last as transparent over any box
	if (FlagSet(phase, DrawPhase::text)) {
		if (phasesDraw != PhasesDraw::One) {
			surface->DrawTextTransparentUTF8(rcText, fontText,
				rcText.top + vsDraw.maxAscent, eolAnnotationText,
				textFore);
		}
	}
}

namespace {

constexpr bool AnnotationBoxedOrIndented(AnnotationVisible annotationVisible) noexcept {
	return annotationVisible == AnnotationVisible::Boxed || annotationVisible == AnnotationVisible::Indented;
}

}

void EditView::DrawAnnotation(Surface *surface, const EditModel &model, const ViewStyle &vsDraw, const LineLayout *ll,
	Sci::Line line, int xStart, PRectangle rcLine, int subLine, DrawPhase phase) {
	const int indent = static_cast<int>(model.pdoc->GetLineIndentation(line) * vsDraw.spaceWidth);
	PRectangle rcSegment = rcLine;
	const int annotationLine = subLine - ll->lines;
	const StyledText stAnnotation = model.pdoc->AnnotationStyledText(line);
	if (stAnnotation.text && ValidStyledText(vsDraw, vsDraw.annotationStyleOffset, stAnnotation)) {
		if (FlagSet(phase, DrawPhase::back)) {
			surface->FillRectangleAligned(rcSegment, Fill(vsDraw.styles[0].back));
		}
		rcSegment.left = static_cast<XYPOSITION>(xStart);
		if (model.trackLineWidth || AnnotationBoxedOrIndented(vsDraw.annotationVisible)) {
			// Only care about calculating width if tracking or need to draw indented box
			int widthAnnotation = WidestLineWidth(surface, vsDraw, vsDraw.annotationStyleOffset, stAnnotation);
			if (AnnotationBoxedOrIndented(vsDraw.annotationVisible)) {
				widthAnnotation += static_cast<int>(vsDraw.spaceWidth * 2); // Margins
				rcSegment.left = static_cast<XYPOSITION>(xStart + indent);
				rcSegment.right = rcSegment.left + widthAnnotation;
			}
			if (widthAnnotation > lineWidthMaxSeen)
				lineWidthMaxSeen = widthAnnotation;
		}
		const int annotationLines = model.pdoc->AnnotationLines(line);
		size_t start = 0;
		size_t lengthAnnotation = stAnnotation.LineLength(start);
		int lineInAnnotation = 0;
		while ((lineInAnnotation < annotationLine) && (start < stAnnotation.length)) {
			start += lengthAnnotation + 1;
			lengthAnnotation = stAnnotation.LineLength(start);
			lineInAnnotation++;
		}

		//Au: call callback function, if it was set with SCI_SETANNOTATIONDRAWCALLBACK. Step 0 - get image width.
		Sci_AnnotationDrawCallbackData c = {};
		int imageWidth = 0;
		if(model.cbAnnotationDraw) {
			c.text = stAnnotation.text; c.textLen = (int)stAnnotation.length;
			c.line = (int)line; c.annotLine = subLine - ll->lines;
			if(AnnotationBoxedOrIndented(vsDraw.annotationVisible)) {
				imageWidth = model.cbAnnotationDraw(model.cbAnnotationDrawParam, c);
				if(imageWidth) {
					imageWidth += (int)(rcSegment.left + vsDraw.spaceWidth * 2);
					if(imageWidth > (int)rcSegment.right) rcSegment.right = (XYPOSITION)imageWidth;
				}
			} else imageWidth = 1;
		}

		PRectangle rcText = rcSegment;
		if ((FlagSet(phase, DrawPhase::back)) && AnnotationBoxedOrIndented(vsDraw.annotationVisible)) {
			surface->FillRectangleAligned(rcText,
				Fill(vsDraw.styles[stAnnotation.StyleAt(start) + vsDraw.annotationStyleOffset].back));
			rcText.left += vsDraw.spaceWidth;
		}

		//Au: call callback function, if it was set with SCI_SETANNOTATIONDRAWCALLBACK. Step 1 - draw image in this line.
		if(imageWidth) {
			if(!AnnotationBoxedOrIndented(vsDraw.annotationVisible)) rcText.left = (XYPOSITION)(xStart + indent);
			//Platform::DebugPrintf("%i %i %i", subLine, ll->lines, annotationLines);
			c.step = 1;
			c.rect.left = (int)rcText.left;
			c.rect.top = (int)rcText.top;
			c.rect.right = (int)rcText.right;
			c.rect.bottom = (int)rcText.bottom;
			c.hdc = surface->get_hdc();
			int iw = model.cbAnnotationDraw(model.cbAnnotationDrawParam, c);
			if(!iw) imageWidth = 0; else if(iw > imageWidth) imageWidth = iw;
			if(imageWidth > lineWidthMaxSeen) lineWidthMaxSeen = imageWidth; //horz scroll bar
		}
		if(!imageWidth)

		DrawStyledText(surface, vsDraw, vsDraw.annotationStyleOffset, rcText,
			stAnnotation, start, lengthAnnotation, phase);
		if ((FlagSet(phase, DrawPhase::back)) && (vsDraw.annotationVisible == AnnotationVisible::Boxed)) {
			const ColourRGBA colourBorder = vsDraw.styles[vsDraw.annotationStyleOffset].fore;
			const PRectangle rcBorder = PixelAlignOutside(rcSegment, surface->PixelDivisions());
			surface->FillRectangle(Side(rcBorder, Edge::left, 1), colourBorder);
			surface->FillRectangle(Side(rcBorder, Edge::right, 1), colourBorder);
			if (subLine == ll->lines) {
				surface->FillRectangle(Side(rcBorder, Edge::top, 1), colourBorder);
			}
			if (subLine == ll->lines + annotationLines - 1) {
				surface->FillRectangle(Side(rcBorder, Edge::bottom, 1), colourBorder);
			}
		}
	} else {
		// No annotation to draw so show bug with colourBug
		if (FlagSet(phase, DrawPhase::back)) {
			surface->FillRectangle(rcSegment, colourBug.Opaque());
		}
	}
}

namespace {

void DrawBlockCaret(Surface *surface, const EditModel &model, const ViewStyle &vsDraw, const LineLayout *ll,
	int subLine, int xStart, Sci::Position offset, Sci::Position posCaret, PRectangle rcCaret, ColourRGBA caretColour) {

	const Sci::Position lineStart = ll->LineStart(subLine);
	Sci::Position posBefore = posCaret;
	Sci::Position posAfter = model.pdoc->MovePositionOutsideChar(posCaret + 1, 1);
	Sci::Position numCharsToDraw = posAfter - posCaret;

	// Work out where the starting and ending offsets are. We need to
	// see if the previous character shares horizontal space, such as a
	// glyph / combining character. If so we'll need to draw that too.
	Sci::Position offsetFirstChar = offset;
	Sci::Position offsetLastChar = offset + (posAfter - posCaret);
	while ((posBefore > 0) && ((offsetLastChar - numCharsToDraw) >= lineStart)) {
		if ((ll->positions[offsetLastChar] - ll->positions[offsetLastChar - numCharsToDraw]) > 0) {
			// The char does not share horizontal space
			break;
		}
		// Char shares horizontal space, update the numChars to draw
		// Update posBefore to point to the prev char
		posBefore = model.pdoc->MovePositionOutsideChar(posBefore - 1, -1);
		numCharsToDraw = posAfter - posBefore;
		offsetFirstChar = offset - (posCaret - posBefore);
	}

	// See if the next character shares horizontal space, if so we'll
	// need to draw that too.
	if (offsetFirstChar < 0)
		offsetFirstChar = 0;
	numCharsToDraw = offsetLastChar - offsetFirstChar;
	while ((offsetLastChar < ll->LineStart(subLine + 1)) && (offsetLastChar <= ll->numCharsInLine)) {
		// Update posAfter to point to the 2nd next char, this is where
		// the next character ends, and 2nd next begins. We'll need
		// to compare these two
		posBefore = posAfter;
		posAfter = model.pdoc->MovePositionOutsideChar(posAfter + 1, 1);
		offsetLastChar = offset + (posAfter - posCaret);
		if ((ll->positions[offsetLastChar] - ll->positions[offsetLastChar - (posAfter - posBefore)]) > 0) {
			// The char does not share horizontal space
			break;
		}
		// Char shares horizontal space, update the numChars to draw
		numCharsToDraw = offsetLastChar - offsetFirstChar;
	}

	// We now know what to draw, update the caret drawing rectangle
	rcCaret.left = ll->positions[offsetFirstChar] - ll->positions[lineStart] + xStart;
	rcCaret.right = ll->positions[offsetFirstChar + numCharsToDraw] - ll->positions[lineStart] + xStart;

	// Adjust caret position to take into account any word wrapping symbols.
	if ((ll->wrapIndent != 0) && (lineStart != 0)) {
		const XYPOSITION wordWrapCharWidth = ll->wrapIndent;
		rcCaret.left += wordWrapCharWidth;
		rcCaret.right += wordWrapCharWidth;
	}

	// This character is where the caret block is, we override the colours
	// (inversed) for drawing the caret here.
	const int styleMain = ll->styles[offsetFirstChar];
	const Font *fontText = vsDraw.styles[styleMain].font.get();
	const std::string_view text(&ll->chars[offsetFirstChar], numCharsToDraw);
	surface->DrawTextClipped(rcCaret, fontText,
		rcCaret.top + vsDraw.maxAscent, text, vsDraw.styles[styleMain].back,
		caretColour);
}

}

void EditView::DrawCarets(Surface *surface, const EditModel &model, const ViewStyle &vsDraw, const LineLayout *ll,
	Sci::Line lineDoc, int xStart, PRectangle rcLine, int subLine) const {
	// When drag is active it is the only caret drawn
	const bool drawDrag = model.posDrag.IsValid();
	if (!vsDraw.selection.visible && !drawDrag)
		return;
	const Sci::Position posLineStart = model.pdoc->LineStart(lineDoc);
	// For each selection draw
	for (size_t r = 0; (r<model.sel.Count()) || drawDrag; r++) {
		const bool mainCaret = r == model.sel.Main();
		SelectionPosition posCaret = (drawDrag ? model.posDrag : model.sel.Range(r).caret);
		if ((vsDraw.DrawCaretInsideSelection(model.inOverstrike, imeCaretBlockOverride)) &&
			!drawDrag &&
			posCaret > model.sel.Range(r).anchor) {
			if (posCaret.VirtualSpace() > 0)
				posCaret.SetVirtualSpace(posCaret.VirtualSpace() - 1);
			else
				posCaret.SetPosition(model.pdoc->MovePositionOutsideChar(posCaret.Position()-1, -1));
		}
		const int offset = static_cast<int>(posCaret.Position() - posLineStart);
		const XYPOSITION spaceWidth = vsDraw.styles[ll->EndLineStyle()].spaceWidth;
		const XYPOSITION virtualOffset = posCaret.VirtualSpaceWidth(spaceWidth);
		if (ll->InLine(offset, subLine) && offset <= ll->numCharsBeforeEOL) {
			XYPOSITION xposCaret = ll->positions[offset] + virtualOffset - ll->positions[ll->LineStart(subLine)];
			if (model.BidirectionalEnabled() && (posCaret.VirtualSpace() == 0)) {
				// Get caret point
				const ScreenLine screenLine(ll, subLine, vsDraw, rcLine.right, tabWidthMinimumPixels);

				const int caretPosition = offset - ll->LineStart(subLine);

				std::unique_ptr<IScreenLineLayout> slLayout = surface->Layout(&screenLine);
				const XYPOSITION caretLeft = slLayout->XFromPosition(caretPosition);

				// In case of start of line, the cursor should be at the right
				xposCaret = caretLeft + virtualOffset;
			}
			if (ll->wrapIndent != 0) {
				const Sci::Position lineStart = ll->LineStart(subLine);
				if (lineStart != 0)	// Wrapped
					xposCaret += ll->wrapIndent;
			}
			const bool caretBlinkState = (model.caret.active && model.caret.on) || (!additionalCaretsBlink && !mainCaret);
			const bool caretVisibleState = additionalCaretsVisible || mainCaret;
			if ((xposCaret >= 0) && vsDraw.IsCaretVisible(mainCaret) &&
				(drawDrag || (caretBlinkState && caretVisibleState))) {
				bool canDrawBlockCaret = true;
				bool drawBlockCaret = false;
				XYPOSITION widthOverstrikeCaret;
				XYPOSITION caretWidthOffset = 0;
				PRectangle rcCaret = rcLine;

				if (posCaret.Position() == model.pdoc->Length()) {   // At end of document
					canDrawBlockCaret = false;
					widthOverstrikeCaret = vsDraw.aveCharWidth;
				} else if ((posCaret.Position() - posLineStart) >= ll->numCharsInLine) {	// At end of line
					canDrawBlockCaret = false;
					widthOverstrikeCaret = vsDraw.aveCharWidth;
				} else {
					const int widthChar = model.pdoc->LenChar(posCaret.Position());
					widthOverstrikeCaret = ll->positions[offset + widthChar] - ll->positions[offset];
				}
				if (widthOverstrikeCaret < 3)	// Make sure its visible
					widthOverstrikeCaret = 3;

				if (xposCaret > 0)
					caretWidthOffset = 0.51f;	// Move back so overlaps both character cells.
				xposCaret += xStart;
				const ViewStyle::CaretShape caretShape = drawDrag ? ViewStyle::CaretShape::line :
					vsDraw.CaretShapeForMode(model.inOverstrike, mainCaret);
				if (drawDrag) {
					/* Dragging text, use a line caret */
					rcCaret.left = std::round(xposCaret - caretWidthOffset);
					rcCaret.right = rcCaret.left + vsDraw.caret.width;
				} else if ((caretShape == ViewStyle::CaretShape::bar) && drawOverstrikeCaret) {
					/* Over-strike (insert mode), use a modified bar caret */
					rcCaret.top = rcCaret.bottom - 2;
					rcCaret.left = xposCaret + 1;
					rcCaret.right = rcCaret.left + widthOverstrikeCaret - 1;
				} else if ((caretShape == ViewStyle::CaretShape::block) || imeCaretBlockOverride) {
					/* Block caret */
					rcCaret.left = xposCaret;
					if (canDrawBlockCaret && !(IsControl(ll->chars[offset]))) {
						drawBlockCaret = true;
						rcCaret.right = xposCaret + widthOverstrikeCaret;
					} else {
						rcCaret.right = xposCaret + vsDraw.aveCharWidth;
					}
				} else {
					/* Line caret */
					rcCaret.left = std::round(xposCaret - caretWidthOffset);
					rcCaret.right = rcCaret.left + vsDraw.caret.width;
				}
				const Element elementCaret = mainCaret ? Element::Caret : Element::CaretAdditional;
				const ColourRGBA caretColour = vsDraw.ElementColourForced(elementCaret);
				//assert(caretColour.IsOpaque());
				if (drawBlockCaret) {
					DrawBlockCaret(surface, model, vsDraw, ll, subLine, xStart, offset, posCaret.Position(), rcCaret, caretColour);
				} else {
					surface->FillRectangleAligned(rcCaret, Fill(caretColour));
				}
			}
		}
		if (drawDrag)
			break;
	}
}

namespace {

void DrawWrapIndentAndMarker(Surface *surface, const ViewStyle &vsDraw, const LineLayout *ll,
	int xStart, PRectangle rcLine, ColourOptional background, DrawWrapMarkerFn customDrawWrapMarker,
	bool caretActive) {
	// default background here..
	surface->FillRectangleAligned(rcLine, Fill(background.value_or(vsDraw.styles[StyleDefault].back)));

	if (vsDraw.IsLineFrameOpaque(caretActive, ll->containsCaret)) {
		// Draw left of frame under marker
		surface->FillRectangleAligned(Side(rcLine, Edge::left, vsDraw.GetFrameWidth()),
			vsDraw.ElementColourForced(Element::CaretLineBack).Opaque());
	}

	if (FlagSet(vsDraw.wrap.visualFlags, WrapVisualFlag::Start)) {

		// draw continuation rect
		PRectangle rcPlace = rcLine;

		rcPlace.left = static_cast<XYPOSITION>(xStart);
		rcPlace.right = rcPlace.left + ll->wrapIndent;

		if (FlagSet(vsDraw.wrap.visualFlagsLocation, WrapVisualLocation::StartByText))
			rcPlace.left = rcPlace.right - vsDraw.aveCharWidth;
		else
			rcPlace.right = rcPlace.left + vsDraw.aveCharWidth;

		if (!customDrawWrapMarker) {
			DrawWrapMarker(surface, rcPlace, false, vsDraw.WrapColour());
		} else {
			customDrawWrapMarker(surface, rcPlace, false, vsDraw.WrapColour());
		}
	}
}

// On the curses platform, the terminal is drawing its own caret, so if the caret is within
// the main selection, do not draw the selection at that position.
// Use iDoc from DrawBackground and DrawForeground here because TextSegment has been adjusted
// such that, if the caret is inside the main selection, the beginning or end of that selection
// is at the end of a text segment.
// This function should only be called if iDoc is within the main selection.
InSelection CharacterInCursesSelection(Sci::Position iDoc, const EditModel &model, const ViewStyle &vsDraw) noexcept {
	const SelectionPosition &posCaret = model.sel.RangeMain().caret;
	const bool caretAtStart = posCaret < model.sel.RangeMain().anchor && posCaret.Position() == iDoc;
	const bool caretAtEnd = posCaret > model.sel.RangeMain().anchor &&
		vsDraw.DrawCaretInsideSelection(false, false) &&
		model.pdoc->MovePositionOutsideChar(posCaret.Position() - 1, -1) == iDoc;
	return (caretAtStart || caretAtEnd) ? InSelection::inNone : InSelection::inMain;
}

void DrawBackground(Surface *surface, const EditModel &model, const ViewStyle &vsDraw, const LineLayout *ll,
	int xStart, PRectangle rcLine, int subLine, Range lineRange, Sci::Position posLineStart,
	ColourOptional background) {

	const bool selBackDrawn = vsDraw.SelectionBackgroundDrawn();
	bool inIndentation = subLine == 0;	// Do not handle indentation except on first subline.
	const XYPOSITION subLineStart = ll->positions[lineRange.start];
	const XYPOSITION horizontalOffset = xStart - subLineStart;
	// Does not take margin into account but not significant
	const XYPOSITION xStartVisible = subLineStart - xStart;

	const BreakFinder::BreakFor breakFor = selBackDrawn ? BreakFinder::BreakFor::Selection : BreakFinder::BreakFor::Text;
	BreakFinder bfBack(ll, &model.sel, lineRange, posLineStart, xStartVisible, breakFor, model.pdoc, model.reprs.get(), &vsDraw);

	const bool drawWhitespaceBackground = vsDraw.WhitespaceBackgroundDrawn() && !background;

	// Background drawing loop
	while (bfBack.More()) {

		const TextSegment ts = bfBack.Next();
		const Sci::Position i = ts.end() - 1;
		const Sci::Position iDoc = i + posLineStart;

		const Interval horizontal = ll->Span(ts.start, ts.end()).Offset(horizontalOffset);
		// Only try to draw if really visible - enhances performance by not calling environment to
		// draw strings that are completely past the right side of the window.
		if (!horizontal.Empty() && rcLine.Intersects(horizontal)) {
			const PRectangle rcSegment = Intersection(rcLine, horizontal);

			InSelection inSelection = vsDraw.selection.visible ? model.sel.CharacterInSelection(iDoc) : InSelection::inNone;
			if (FlagSet(vsDraw.caret.style, CaretStyle::Curses) && (inSelection == InSelection::inMain))
				inSelection = CharacterInCursesSelection(iDoc, model, vsDraw);
			const bool inHotspot = model.hotspot.Valid() && model.hotspot.ContainsCharacter(iDoc);
			ColourRGBA textBack = TextBackground(model, vsDraw, ll, background, inSelection,
				inHotspot, ll->styles[i], i);
			if (ts.representation) {
				if (ll->chars[i] == '\t') {
					// Tab display
					if (drawWhitespaceBackground && vsDraw.WhiteSpaceVisible(inIndentation)) {
						textBack = vsDraw.ElementColourForced(Element::WhiteSpaceBack).Opaque();
					}
				} else {
					// Blob display
					inIndentation = false;
				}
				surface->FillRectangleAligned(rcSegment, Fill(textBack));
			} else {
				// Normal text display
				surface->FillRectangleAligned(rcSegment, Fill(textBack));
				if (vsDraw.viewWhitespace != WhiteSpace::Invisible) {
					for (int cpos = 0; cpos <= i - ts.start; cpos++) {
						if (ll->chars[cpos + ts.start] == ' ') {
							if (drawWhitespaceBackground && vsDraw.WhiteSpaceVisible(inIndentation)) {
								const PRectangle rcSpace = Intersection(rcLine,
									ll->SpanByte(cpos + ts.start).Offset(horizontalOffset));
								surface->FillRectangleAligned(rcSpace,
									vsDraw.ElementColourForced(Element::WhiteSpaceBack).Opaque());
							}
						} else {
							inIndentation = false;
						}
					}
				}
			}
		} else if (horizontal.left > rcLine.right) {
			break;
		}
	}
}

void DrawEdgeLine(Surface *surface, const ViewStyle &vsDraw, const LineLayout *ll,
	int xStart, PRectangle rcLine, Range lineRange) {
	if (vsDraw.edgeState == EdgeVisualStyle::Line) {
		PRectangle rcSegment = rcLine;
		const int edgeX = static_cast<int>(vsDraw.theEdge.column * vsDraw.spaceWidth);
		rcSegment.left = static_cast<XYPOSITION>(edgeX + xStart);
		if ((ll->wrapIndent != 0) && (lineRange.start != 0))
			rcSegment.left -= ll->wrapIndent;
		rcSegment.right = rcSegment.left + 1;
		surface->FillRectangleAligned(rcSegment, Fill(vsDraw.theEdge.colour));
	} else if (vsDraw.edgeState == EdgeVisualStyle::MultiLine) {
		for (size_t edge = 0; edge < vsDraw.theMultiEdge.size(); edge++) {
			if (vsDraw.theMultiEdge[edge].column >= 0) {
				PRectangle rcSegment = rcLine;
				const int edgeX = static_cast<int>(vsDraw.theMultiEdge[edge].column * vsDraw.spaceWidth);
				rcSegment.left = static_cast<XYPOSITION>(edgeX + xStart);
				if ((ll->wrapIndent != 0) && (lineRange.start != 0))
					rcSegment.left -= ll->wrapIndent;
				rcSegment.right = rcSegment.left + 1;
				surface->FillRectangleAligned(rcSegment, Fill(vsDraw.theMultiEdge[edge].colour));
			}
		}
	}
}

// Draw underline mark as part of background if on base layer
void DrawMarkUnderline(Surface *surface, const EditModel &model, const ViewStyle &vsDraw,
	Sci::Line line, PRectangle rcLine) {
	int marks = model.GetMark(line);
	for (int markBit = 0; (markBit <= MarkerMax) && marks; markBit++) {
		if ((marks & 1) && (vsDraw.markers[markBit].markType == MarkerSymbol::Underline) &&
			(vsDraw.markers[markBit].layer == Layer::Base)) {
			PRectangle rcUnderline = rcLine;
			rcUnderline.top = rcUnderline.bottom - 1; //au: was 2
			surface->FillRectangleAligned(rcUnderline, Fill(vsDraw.markers[markBit].back));
		}
		marks >>= 1;
	}
}

void DrawTranslucentSelection(Surface *surface, const EditModel &model, const ViewStyle &vsDraw, const LineLayout *ll,
	Sci::Line line, int xStart, PRectangle rcLine, int subLine, Range lineRange, int tabWidthMinimumPixels, Layer layer) {
	if (vsDraw.selection.layer == layer) {
		const Sci::Position posLineStart = model.pdoc->LineStart(line);
		const XYPOSITION subLineStart = ll->positions[lineRange.start];
		const XYPOSITION horizontalOffset = xStart - subLineStart;
		// For each selection draw
		Sci::Position virtualSpaces = 0;
		if (subLine == (ll->lines - 1)) {
			virtualSpaces = model.sel.VirtualSpaceFor(model.pdoc->LineEnd(line));
		}
		const SelectionPosition posStart(posLineStart + lineRange.start);
		const SelectionPosition posEnd(posLineStart + lineRange.end, virtualSpaces);
		const SelectionSegment virtualSpaceRange(posStart, posEnd);
		for (size_t r = 0; r < model.sel.Count(); r++) {
			const SelectionSegment portion = model.sel.Range(r).Intersect(virtualSpaceRange);
			if (!portion.Empty()) {
				const SelectionSegment portionInLine = portion.Subtract(posLineStart);
				const ColourRGBA selectionBack = SelectionBackground(
					model, vsDraw, model.sel.RangeType(r));
				const XYPOSITION spaceWidth = vsDraw.styles[ll->EndLineStyle()].spaceWidth;
				const Interval intervalVirtual{
					portion.start.VirtualSpaceWidth(spaceWidth),
					portion.end.VirtualSpaceWidth(spaceWidth) };
				if (model.BidirectionalEnabled()) {
					const SelectionSegment portionInSubLine = portionInLine.Subtract(lineRange.start);

					const ScreenLine screenLine(ll, subLine, vsDraw, rcLine.right, tabWidthMinimumPixels);
					std::unique_ptr<IScreenLineLayout> slLayout = surface->Layout(&screenLine);

					if (slLayout) {
						const std::vector<Interval> intervals = slLayout->FindRangeIntervals(
							portionInSubLine.start.Position(), portionInSubLine.end.Position());
						for (const Interval &interval : intervals) {
							const PRectangle rcSelection = rcLine.WithHorizontalBounds(interval.Offset(xStart));
							surface->FillRectangleAligned(rcSelection, selectionBack);
						}
					}

					if (portion.end.VirtualSpace()) {
						const XYPOSITION xStartVirtual = ll->positions[lineRange.end] + horizontalOffset;
						const PRectangle rcSegment = rcLine.WithHorizontalBounds(intervalVirtual.Offset(xStartVirtual));
						surface->FillRectangleAligned(rcSegment, selectionBack);
					}
				} else {
					Interval intervalSegment = ll->Span(
						static_cast<int>(portionInLine.start.Position()),
						static_cast<int>(portionInLine.end.Position()))
						.Offset(horizontalOffset);
					intervalSegment.left += intervalVirtual.left;
					intervalSegment.right += intervalVirtual.right;
					if ((ll->wrapIndent != 0) && (lineRange.start != 0)) {
						if ((portionInLine.start.Position() == lineRange.start) &&
							model.sel.Range(r).ContainsCharacter(portion.start.Position() - 1))
							intervalSegment.left -= static_cast<int>(ll->wrapIndent); // indentation added to xStart was truncated to int, so we do the same here
					}
					const PRectangle rcSegment = Intersection(rcLine, intervalSegment);
					if (rcSegment.right > rcLine.left)
						surface->FillRectangleAligned(rcSegment, selectionBack);
				}
			}
		}
	}
}

void DrawCaretLineFramed(Surface *surface, const ViewStyle &vsDraw, const LineLayout *ll,
	PRectangle rcLine, int subLine) {
	const ColourOptional caretlineBack = vsDraw.ElementColour(Element::CaretLineBack);
	if (!caretlineBack) {
		return;
	}

	const ColourRGBA colourFrame = (vsDraw.caretLine.layer == Layer::Base) ?
		caretlineBack->Opaque() : *caretlineBack;

	const int width = vsDraw.GetFrameWidth();

	// Avoid double drawing the corners by removing the left and right sides when drawing top and bottom borders
	const PRectangle rcWithoutLeftRight = rcLine.Inset(Point(width, 0.0));

	if (subLine == 0 || ll->wrapIndent == 0 || vsDraw.caretLine.layer != Layer::Base || vsDraw.caretLine.subLine) {
		// Left
		surface->FillRectangleAligned(Side(rcLine, Edge::left, width), colourFrame);
	}
	if (subLine == 0 || vsDraw.caretLine.subLine) {
		// Top
		surface->FillRectangleAligned(Side(rcWithoutLeftRight, Edge::top, width), colourFrame);
	}
	if (subLine == ll->lines - 1 || vsDraw.caretLine.layer != Layer::Base || vsDraw.caretLine.subLine) {
		// Right
		surface->FillRectangleAligned(Side(rcLine, Edge::right, width), colourFrame);
	}
	if (subLine == ll->lines - 1 || vsDraw.caretLine.subLine) {
		// Bottom
		surface->FillRectangleAligned(Side(rcWithoutLeftRight, Edge::bottom, width), colourFrame);
	}
}

// Draw any translucent whole line states
void DrawTranslucentLineState(Surface *surface, const EditModel &model, const ViewStyle &vsDraw, const LineLayout *ll,
	Sci::Line line, PRectangle rcLine, int subLine, Layer layer) {
	if ((model.caret.active || vsDraw.caretLine.alwaysShow) && vsDraw.ElementColour(Element::CaretLineBack) && ll->containsCaret &&
		vsDraw.caretLine.layer == layer) {
		if (vsDraw.caretLine.frame) {
			DrawCaretLineFramed(surface, vsDraw, ll, rcLine, subLine);
		} else {
			surface->FillRectangleAligned(rcLine, vsDraw.ElementColourForced(Element::CaretLineBack));
		}
	}
	const int marksOfLine = model.GetMark(line);
	int marksDrawnInText = marksOfLine & vsDraw.maskDrawInText;
	for (int markBit = 0; (markBit <= MarkerMax) && marksDrawnInText; markBit++) {
		if ((marksDrawnInText & 1) && (vsDraw.markers[markBit].layer == layer)) {
			if (vsDraw.markers[markBit].markType == MarkerSymbol::Background) {
				surface->FillRectangleAligned(rcLine, vsDraw.markers[markBit].BackWithAlpha());
			} else if (vsDraw.markers[markBit].markType == MarkerSymbol::Underline) {
				PRectangle rcUnderline = rcLine;
				rcUnderline.top = rcUnderline.bottom - 2;
				surface->FillRectangleAligned(rcUnderline, vsDraw.markers[markBit].BackWithAlpha());
			}
		}
		marksDrawnInText >>= 1;
	}
	int marksDrawnInLine = marksOfLine & vsDraw.maskInLine;
	for (int markBit = 0; (markBit <= MarkerMax) && marksDrawnInLine; markBit++) {
		if ((marksDrawnInLine & 1) && (vsDraw.markers[markBit].layer == layer)) {
			surface->FillRectangleAligned(rcLine, vsDraw.markers[markBit].BackWithAlpha());
		}
		marksDrawnInLine >>= 1;
	}
}

void DrawTabArrow(Surface *surface, PRectangle rcTab, int ymid,
	const ViewStyle &vsDraw, Stroke stroke) {

	const XYPOSITION halfWidth = stroke.width / 2.0;

	const XYPOSITION leftStroke = std::round(std::min(rcTab.left + 2, rcTab.right - 1)) + halfWidth;
	const XYPOSITION rightStroke = std::max(leftStroke, std::round(rcTab.right) - 1.0f - halfWidth);
	const XYPOSITION yMidAligned = ymid + halfWidth;
	const Point arrowPoint(rightStroke, yMidAligned);
	if (rightStroke > leftStroke) {
		// When not enough room, don't draw the arrow shaft
		surface->LineDraw(Point(leftStroke, yMidAligned), arrowPoint, stroke);
	}

	// Draw the arrow head if needed
	if (vsDraw.tabDrawMode == TabDrawMode::LongArrow) {
		XYPOSITION ydiff = std::floor(rcTab.Height() / 2.0f);
		XYPOSITION xhead = rightStroke - ydiff;
		if (xhead <= rcTab.left) {
			ydiff -= rcTab.left - xhead;
			xhead = rcTab.left;
		}
		const Point ptsHead[] = {
			Point(xhead, yMidAligned - ydiff),
			arrowPoint,
			Point(xhead, yMidAligned + ydiff)
		};
		surface->PolyLine(ptsHead, std::size(ptsHead), stroke);
	}
}

void DrawIndicator(int indicNum, Sci::Position startPos, Sci::Position endPos, Surface *surface, const ViewStyle &vsDraw,
	const LineLayout *ll, int xStart, PRectangle rcLine, Sci::Position secondCharacter, int subLine, Indicator::State state,
	int value, bool bidiEnabled, int tabWidthMinimumPixels) {

	const XYPOSITION subLineStart = ll->positions[ll->LineStart(subLine)];
	const XYPOSITION horizontalOffset = xStart - subLineStart;

	std::vector<PRectangle> rectangles;

	const XYPOSITION left = ll->XInLine(startPos) + horizontalOffset;
	const XYPOSITION right = ll->XInLine(endPos) + horizontalOffset;
	const PRectangle rcIndic(left, rcLine.top + vsDraw.maxAscent, right,
		std::max(rcLine.top + vsDraw.maxAscent + 3, rcLine.bottom));

	if (bidiEnabled) {
		ScreenLine screenLine(ll, subLine, vsDraw, rcLine.right - xStart, tabWidthMinimumPixels);
		const Range lineRange = ll->SubLineRange(subLine, LineLayout::Scope::visibleOnly);

		std::unique_ptr<IScreenLineLayout> slLayout = surface->Layout(&screenLine);
		std::vector<Interval> intervals = slLayout->FindRangeIntervals(
			startPos - lineRange.start, endPos - lineRange.start);
		for (const Interval &interval : intervals) {
			PRectangle rcInterval = rcIndic;
			rcInterval.left = interval.left + xStart;
			rcInterval.right = interval.right + xStart;
			rectangles.push_back(rcInterval);
		}
	} else {
		rectangles.push_back(rcIndic);
	}

	for (const PRectangle &rc : rectangles) {
		PRectangle rcFirstCharacter = rc;
		// Allow full descent space for character indicators
		rcFirstCharacter.bottom = rcLine.top + vsDraw.maxAscent + vsDraw.maxDescent;
		if (secondCharacter >= 0) {
			rcFirstCharacter.right = ll->XInLine(secondCharacter) + horizontalOffset;
		} else {
			// Indicator continued from earlier line so make an empty box and don't draw
			rcFirstCharacter.right = rcFirstCharacter.left;
		}
		vsDraw.indicators[indicNum].Draw(surface, rc, rcLine, rcFirstCharacter, state, value);
	}
}

void DrawIndicators(Surface *surface, const EditModel &model, const ViewStyle &vsDraw, const LineLayout *ll,
	Sci::Line line, int xStart, PRectangle rcLine, int subLine, Sci::Position lineEnd, bool under, int tabWidthMinimumPixels) {
	// Draw decorators
	const Sci::Position posLineStart = model.pdoc->LineStart(line);
	const Sci::Position lineStart = ll->LineStart(subLine);
	const Sci::Position posLineEnd = posLineStart + lineEnd;

	for (const IDecoration *deco : model.pdoc->decorations->View()) {
		if (under == vsDraw.indicators[deco->Indicator()].under) {
			Sci::Position startPos = posLineStart + lineStart;
			while (startPos < posLineEnd) {
				const Range rangeRun(deco->StartRun(startPos), deco->EndRun(startPos));
				const Sci::Position endPos = std::min(rangeRun.end, posLineEnd);
				const int value = deco->ValueAt(startPos);
				if (value) {
					const bool hover = vsDraw.indicators[deco->Indicator()].IsDynamic() &&
						rangeRun.ContainsCharacter(model.hoverIndicatorPos);
					const Indicator::State state = hover ? Indicator::State::hover : Indicator::State::normal;
					const Sci::Position posSecond = model.pdoc->MovePositionOutsideChar(rangeRun.First() + 1, 1);
					DrawIndicator(deco->Indicator(), startPos - posLineStart, endPos - posLineStart,
						surface, vsDraw, ll, xStart, rcLine, posSecond - posLineStart, subLine, state,
						value, model.BidirectionalEnabled(), tabWidthMinimumPixels);
				}
				startPos = endPos;
			}
		}
	}

	// Use indicators to highlight matching braces
	if ((vsDraw.braceHighlightIndicatorSet && (model.bracesMatchStyle == StyleBraceLight)) ||
		(vsDraw.braceBadLightIndicatorSet && (model.bracesMatchStyle == StyleBraceBad))) {
		const int braceIndicator = (model.bracesMatchStyle == StyleBraceLight) ? vsDraw.braceHighlightIndicator : vsDraw.braceBadLightIndicator;
		if (under == vsDraw.indicators[braceIndicator].under) {
			const Range rangeLine(posLineStart + lineStart, posLineEnd);
			for (size_t brace = 0; brace <= 1; brace++) {
				if (rangeLine.ContainsCharacter(model.braces[brace])) {
					const Sci::Position braceOffset = model.braces[brace] - posLineStart;
					if (braceOffset < ll->numCharsInLine) {
						const Sci::Position braceEnd = model.pdoc->MovePositionOutsideChar(model.braces[brace] + 1, 1) - posLineStart;
						DrawIndicator(braceIndicator, braceOffset, braceEnd,
							surface, vsDraw, ll, xStart, rcLine, braceEnd, subLine, Indicator::State::normal,
							1, model.BidirectionalEnabled(), tabWidthMinimumPixels);
					}
				}
			}
		}
	}

	if (FlagSet(model.changeHistoryOption, ChangeHistoryOption::Indicators)) {
		// Draw editions
		constexpr int indexHistory = static_cast<int>(IndicatorNumbers::HistoryRevertedToOriginInsertion);
		{
			// Draw insertions
			Sci::Position startPos = posLineStart + lineStart;
			while (startPos < posLineEnd) {
				const Range rangeRun(startPos, model.pdoc->EditionEndRun(startPos));
				const Sci::Position endPos = std::min(rangeRun.end, posLineEnd);
				const int edition = model.pdoc->EditionAt(startPos);
				if (edition != 0) {
					const int indicator = (edition - 1) * 2 + indexHistory;
					const Sci::Position posSecond = model.pdoc->MovePositionOutsideChar(rangeRun.First() + 1, 1);
					DrawIndicator(indicator, startPos - posLineStart, endPos - posLineStart,
						surface, vsDraw, ll, xStart, rcLine, posSecond - posLineStart, subLine, Indicator::State::normal,
						1, model.BidirectionalEnabled(), tabWidthMinimumPixels);
				}
				startPos = endPos;
			}
		}
		{
			// Draw deletions
			Sci::Position startPos = posLineStart + lineStart;
			while (startPos <= posLineEnd) {
				const unsigned int editions = model.pdoc->EditionDeletesAt(startPos);
				const Sci::Position posSecond = model.pdoc->MovePositionOutsideChar(startPos + 1, 1);
				for (unsigned int edition = 0; edition < 4; edition++) {
					if (editions & (1 << edition)) {
						const int indicator = edition * 2 + indexHistory + 1;
						DrawIndicator(indicator, startPos - posLineStart, posSecond - posLineStart,
							surface, vsDraw, ll, xStart, rcLine, posSecond - posLineStart, subLine, Indicator::State::normal,
							1, model.BidirectionalEnabled(), tabWidthMinimumPixels);
					}
				}
				startPos = model.pdoc->EditionNextDelete(startPos);
			}
		}
	}
}

void DrawFoldLines(Surface *surface, const EditModel &model, const ViewStyle &vsDraw, const LineLayout *ll,
	Sci::Line line, PRectangle rcLine, int subLine) {
	const bool lastSubLine = subLine == (ll->lines - 1);
	const bool expanded = model.pcs->GetExpanded(line);
	const FoldLevel level = model.pdoc->GetFoldLevel(line);
	const FoldLevel levelNext = model.pdoc->GetFoldLevel(line + 1);
	if (LevelIsHeader(level) &&
		(LevelNumber(level) < LevelNumber(levelNext))) {
		const ColourRGBA foldLineColour = vsDraw.ElementColour(Element::FoldLine).value_or(
			vsDraw.styles[StyleDefault].fore);
		// Paint the line above the fold
		if ((subLine == 0) && FlagSet(model.foldFlags, (expanded ? FoldFlag::LineBeforeExpanded: FoldFlag::LineBeforeContracted))) {
			surface->FillRectangleAligned(Side(rcLine, Edge::top, 1.0), foldLineColour);
		}
		// Paint the line below the fold
		if (lastSubLine && FlagSet(model.foldFlags, (expanded ? FoldFlag::LineAfterExpanded : FoldFlag::LineAfterContracted))) {

			//Au: draw dots line
			surface->DrawLineDots(Side(rcLine, Edge::bottom, 1.0), ColourRGBA(0xc0c0c0));
			//surface->FillRectangleAligned(Side(rcLine, Edge::bottom, 1.0), foldLineColour);

			// If contracted fold line drawn then don't overwrite with hidden line
			// as fold lines are more specific then hidden lines.
			if (!expanded) {
				return;
			}
		}
	}
	if (lastSubLine && model.pcs->GetVisible(line) && !model.pcs->GetVisible(line + 1)) {
		if (const ColourOptional hiddenLineColour = vsDraw.ElementColour(Element::HiddenLine)) {
			surface->FillRectangleAligned(Side(rcLine, Edge::bottom, 1.0), *hiddenLineColour);
		}
	}
}

ColourRGBA InvertedLight(ColourRGBA orig) noexcept {
	unsigned int r = orig.GetRed();
	unsigned int g = orig.GetGreen();
	unsigned int b = orig.GetBlue();
	const unsigned int l = (r + g + b) / 3; 	// There is a better calculation for this that matches human eye
	const unsigned int il = 0xff - l;
	if (l == 0)
		return white;
	r = r * il / l;
	g = g * il / l;
	b = b * il / l;
	return ColourRGBA(std::min(r, 0xffu), std::min(g, 0xffu), std::min(b, 0xffu));
}

}

void EditView::DrawIndentGuide(Surface *surface, XYPOSITION start, PRectangle rcSegment, bool highlight, bool offset) {
	const Point from = Point::FromInts(0, offset ? 1 : 0);
	const PRectangle rcCopyArea(start + 1, rcSegment.top,
		start + 2, rcSegment.bottom);
	surface->Copy(rcCopyArea, from,
		highlight ? *pixmapIndentGuideHighlight : *pixmapIndentGuide);
}

void EditView::DrawForeground(Surface *surface, const EditModel &model, const ViewStyle &vsDraw, const LineLayout *ll,
	int xStart, PRectangle rcLine, int subLine, Sci::Line lineVisible, Range lineRange, Sci::Position posLineStart,
	ColourOptional background) {

	const bool selBackDrawn = vsDraw.SelectionBackgroundDrawn();
	const bool drawWhitespaceBackground = vsDraw.WhitespaceBackgroundDrawn() && !background;
	bool inIndentation = subLine == 0;	// Do not handle indentation except on first subline.

	const XYPOSITION subLineStart = ll->positions[lineRange.start];
	const XYPOSITION horizontalOffset = xStart - subLineStart;
	const XYPOSITION indentWidth = model.pdoc->IndentSize() * vsDraw.spaceWidth;

	// Does not take margin into account but not significant
	const XYPOSITION xStartVisible = subLineStart - xStart;

	// When lineHeight is odd, dotted indent guides are drawn offset by 1 on odd lines to join together.
	const bool offsetGuide = (lineVisible & 1) && (vsDraw.lineHeight & 1);

	// Same baseline used for all text
	const XYPOSITION ybase = rcLine.top + vsDraw.maxAscent;

	// Foreground drawing loop
	const BreakFinder::BreakFor breakFor = (((phasesDraw == PhasesDraw::One) && selBackDrawn) || vsDraw.SelectionTextDrawn())
		? BreakFinder::BreakFor::ForegroundAndSelection : BreakFinder::BreakFor::Foreground;
	BreakFinder bfFore(ll, &model.sel, lineRange, posLineStart, xStartVisible, breakFor, model.pdoc, model.reprs.get(), &vsDraw);

	while (bfFore.More()) {

		const TextSegment ts = bfFore.Next();
		const Sci::Position i = ts.end() - 1;
		const Sci::Position iDoc = i + posLineStart;

		const Interval horizontal = ll->Span(ts.start, ts.end()).Offset(horizontalOffset);
		// Only try to draw if really visible - enhances performance by not calling environment to
		// draw strings that are completely past the right side of the window.
		if (rcLine.Intersects(horizontal)) {
			const PRectangle rcSegment = rcLine.WithHorizontalBounds(horizontal);
			const int styleMain = ll->styles[i];
			ColourRGBA textFore = vsDraw.styles[styleMain].fore;
			const Font *textFont = vsDraw.styles[styleMain].font.get();
			// Hot-spot foreground
			const bool inHotspot = model.hotspot.Valid() && model.hotspot.ContainsCharacter(iDoc);
			if (inHotspot) {
				if (const ColourOptional colourHotSpot = vsDraw.ElementColour(Element::HotSpotActive)) {
					textFore = *colourHotSpot;
				}
			}
			if (vsDraw.indicatorsSetFore) {
				// At least one indicator sets the text colour so see if it applies to this segment
				for (const IDecoration *deco : model.pdoc->decorations->View()) {
					const int indicatorValue = deco->ValueAt(ts.start + posLineStart);
					if (indicatorValue) {
						const Indicator &indicator = vsDraw.indicators[deco->Indicator()];
						bool hover = false;
						if (indicator.IsDynamic()) {
							const Sci::Position startPos = ts.start + posLineStart;
							const Range rangeRun(deco->StartRun(startPos), deco->EndRun(startPos));
							hover =	rangeRun.ContainsCharacter(model.hoverIndicatorPos);
						}
						if (hover) {
							if (indicator.sacHover.style == IndicatorStyle::TextFore) {
								textFore = indicator.sacHover.fore;
							}
						} else {
							if (indicator.sacNormal.style == IndicatorStyle::TextFore) {
								if (FlagSet(indicator.Flags(), IndicFlag::ValueFore))
									textFore = ColourRGBA::FromRGB(indicatorValue & static_cast<int>(IndicValue::Mask));
								else
									textFore = indicator.sacNormal.fore;
							}
						}
					}
				}
			}
			InSelection inSelection = vsDraw.selection.visible ? model.sel.CharacterInSelection(iDoc) : InSelection::inNone;
			if (FlagSet(vsDraw.caret.style, CaretStyle::Curses) && (inSelection == InSelection::inMain))
				inSelection = CharacterInCursesSelection(iDoc, model, vsDraw);
			if (const ColourOptional selectionFore = SelectionForeground(model, vsDraw, inSelection)) {
				textFore = *selectionFore;
			}
			ColourRGBA textBack = TextBackground(model, vsDraw, ll, background, inSelection, inHotspot, styleMain, i);
			if (ts.representation) {
				if (ll->chars[i] == '\t') {
					// Tab display
					if (phasesDraw == PhasesDraw::One) {
						if (drawWhitespaceBackground && vsDraw.WhiteSpaceVisible(inIndentation))
							textBack = vsDraw.ElementColourForced(Element::WhiteSpaceBack).Opaque();
						surface->FillRectangleAligned(rcSegment, Fill(textBack));
					}
					if (inIndentation && vsDraw.viewIndentationGuides == IndentView::Real) {
						const Interval intervalCharacter = ll->SpanByte(static_cast<int>(i));
						for (int indentCount = static_cast<int>((intervalCharacter.left + epsilon) / indentWidth);
							indentCount <= (intervalCharacter.right - epsilon) / indentWidth;
							indentCount++) {
							if (indentCount > 0) {
								const XYPOSITION xIndent = std::floor(indentCount * indentWidth);
								DrawIndentGuide(surface, xIndent + xStart, rcSegment, ll->xHighlightGuide == xIndent, offsetGuide);
							}
						}
					}
					if (vsDraw.viewWhitespace != WhiteSpace::Invisible) {
						if (vsDraw.WhiteSpaceVisible(inIndentation)) {
							const PRectangle rcTab(rcSegment.left + 1, rcSegment.top + tabArrowHeight,
								rcSegment.right - 1, rcSegment.bottom - vsDraw.maxDescent);
							const int segmentTop = static_cast<int>(rcSegment.top) + vsDraw.lineHeight / 2;
							const ColourRGBA whiteSpaceFore = vsDraw.ElementColour(Element::WhiteSpace).value_or(textFore);
							if (!customDrawTabArrow)
								DrawTabArrow(surface, rcTab, segmentTop, vsDraw, Stroke(whiteSpaceFore, 1.0f));
							else
								customDrawTabArrow(surface, rcTab, segmentTop, vsDraw, Stroke(whiteSpaceFore, 1.0f));
						}
					}
				} else {
					inIndentation = false;
					if (vsDraw.controlCharSymbol >= 32) {
						// Using one font for all control characters so it can be controlled independently to ensure
						// the box goes around the characters tightly. Seems to be no way to work out what height
						// is taken by an individual character - internal leading gives varying results.
						const Font *ctrlCharsFont = vsDraw.styles[StyleControlChar].font.get();
						const char cc[2] = { static_cast<char>(vsDraw.controlCharSymbol), '\0' };
						surface->DrawTextNoClip(rcSegment, ctrlCharsFont,
							ybase, cc, textBack, textFore);
					} else {
						if (FlagSet(ts.representation->appearance, RepresentationAppearance::Colour)) {
							textFore = ts.representation->colour;
						}
						if (FlagSet(ts.representation->appearance, RepresentationAppearance::Blob)) {
							DrawTextBlob(surface, vsDraw, rcSegment, ts.representation->stringRep,
								textBack, textFore, phasesDraw == PhasesDraw::One);
						} else {
							surface->DrawTextTransparentUTF8(rcSegment, vsDraw.styles[StyleControlChar].font.get(),
								ybase, ts.representation->stringRep, textFore);
						}
					}
				}
			} else {
				// Normal text display
				if (vsDraw.styles[styleMain].visible) {
					const std::string_view text(&ll->chars[ts.start], i - ts.start + 1);
					if (phasesDraw != PhasesDraw::One) {
						surface->DrawTextTransparent(rcSegment, textFont,
							ybase, text, textFore);
					} else {
						surface->DrawTextNoClip(rcSegment, textFont,
							ybase, text, textFore, textBack);
					}
				} else if (vsDraw.styles[styleMain].invisibleRepresentation[0]) {
					const std::string_view text = vsDraw.styles[styleMain].invisibleRepresentation;
  					if (phasesDraw != PhasesDraw::One) {
						surface->DrawTextTransparentUTF8(rcSegment, textFont,
							ybase, text, textFore);
					} else {
						surface->DrawTextNoClipUTF8(rcSegment, textFont,
							ybase, text, textFore, textBack);
					}
				}
				if (vsDraw.viewWhitespace != WhiteSpace::Invisible ||
					(inIndentation && vsDraw.viewIndentationGuides != IndentView::None)) {
					for (int cpos = 0; cpos <= i - ts.start; cpos++) {
						if (ll->chars[cpos + ts.start] == ' ') {
							if (vsDraw.viewWhitespace != WhiteSpace::Invisible) {
								if (vsDraw.WhiteSpaceVisible(inIndentation)) {
									const Interval intervalSpace = ll->SpanByte(cpos + ts.start).Offset(horizontalOffset);
									const XYPOSITION xmid = (intervalSpace.left + intervalSpace.right) / 2;
									if ((phasesDraw == PhasesDraw::One) && drawWhitespaceBackground) {
										textBack = vsDraw.ElementColourForced(Element::WhiteSpaceBack).Opaque();
										const PRectangle rcSpace = rcLine.WithHorizontalBounds(intervalSpace);
										surface->FillRectangleAligned(rcSpace, Fill(textBack));
									}
									const int halfDotWidth = vsDraw.whitespaceSize / 2;
									PRectangle rcDot(xmid - halfDotWidth,
										rcSegment.top + vsDraw.lineHeight / 2, 0.0f, 0.0f);
									rcDot.right = rcDot.left + vsDraw.whitespaceSize;
									rcDot.bottom = rcDot.top + vsDraw.whitespaceSize;
									const ColourRGBA whiteSpaceFore = vsDraw.ElementColour(Element::WhiteSpace).value_or(textFore);
									surface->FillRectangleAligned(rcDot, Fill(whiteSpaceFore));
								}
							}
							if (inIndentation && vsDraw.viewIndentationGuides == IndentView::Real) {
								const Interval intervalCharacter = ll->SpanByte(cpos + ts.start);
								for (int indentCount = static_cast<int>((intervalCharacter.left + epsilon) / indentWidth);
									indentCount <= (intervalCharacter.right - epsilon) / indentWidth;
									indentCount++) {
									if (indentCount > 0) {
										const XYPOSITION xIndent = std::floor(indentCount * indentWidth);
										DrawIndentGuide(surface, xIndent + xStart, rcSegment, ll->xHighlightGuide == xIndent, offsetGuide);
									}
								}
							}
						} else {
							inIndentation = false;
						}
					}
				}
			}
			if ((inHotspot && vsDraw.hotspotUnderline) || vsDraw.styles[styleMain].underline) {
				PRectangle rcUL = rcSegment;
				rcUL.top = ybase + 1;
				rcUL.bottom = ybase + 2;
				ColourRGBA colourUnderline = textFore;
				if (inHotspot && vsDraw.hotspotUnderline) {
					colourUnderline = vsDraw.ElementColour(Element::HotSpotActive).value_or(textFore);
				}
				surface->FillRectangleAligned(rcUL, colourUnderline);
			}
		} else if (horizontal.left > rcLine.right) {
			break;
		}
	}
}

void EditView::DrawIndentGuidesOverEmpty(Surface *surface, const EditModel &model, const ViewStyle &vsDraw, const LineLayout *ll,
	Sci::Line line, int xStart, PRectangle rcLine, int subLine, Sci::Line lineVisible) {
	if ((vsDraw.viewIndentationGuides == IndentView::LookForward || vsDraw.viewIndentationGuides == IndentView::LookBoth)
		&& (subLine == 0)) {
		const Sci::Position posLineStart = model.pdoc->LineStart(line);
		int indentSpace = model.pdoc->GetLineIndentation(line);
		int xStartText = static_cast<int>(ll->positions[model.pdoc->GetLineIndentPosition(line) - posLineStart]);

		// Find the most recent line with some text

		Sci::Line lineLastWithText = line;
		while (lineLastWithText > std::max(line - 20, static_cast<Sci::Line>(0)) && model.pdoc->IsWhiteLine(lineLastWithText)) {
			lineLastWithText--;
		}
		if (lineLastWithText < line) {
			xStartText = 100000;	// Don't limit to visible indentation on empty line
			// This line is empty, so use indentation of last line with text
			int indentLastWithText = model.pdoc->GetLineIndentation(lineLastWithText);
			const int isFoldHeader = LevelIsHeader(model.pdoc->GetFoldLevel(lineLastWithText));
			if (isFoldHeader) {
				// Level is one more level than parent
				indentLastWithText += model.pdoc->IndentSize();
			}
			if (vsDraw.viewIndentationGuides == IndentView::LookForward) {
				// In viLookForward mode, previous line only used if it is a fold header
				if (isFoldHeader) {
					indentSpace = std::max(indentSpace, indentLastWithText);
				}
			} else {	// viLookBoth
				indentSpace = std::max(indentSpace, indentLastWithText);
			}
		}

		Sci::Line lineNextWithText = line;
		while (lineNextWithText < std::min(line + 20, model.pdoc->LinesTotal()) && model.pdoc->IsWhiteLine(lineNextWithText)) {
			lineNextWithText++;
		}
		if (lineNextWithText > line) {
			xStartText = 100000;	// Don't limit to visible indentation on empty line
			// This line is empty, so use indentation of first next line with text
			indentSpace = std::max(indentSpace,
				model.pdoc->GetLineIndentation(lineNextWithText));
		}

		const bool offsetGuide = (lineVisible & 1) && (vsDraw.lineHeight & 1);
		for (int indentPos = model.pdoc->IndentSize(); indentPos < indentSpace; indentPos += model.pdoc->IndentSize()) {
			const XYPOSITION xIndent = std::floor(indentPos * vsDraw.spaceWidth);
			if (xIndent < xStartText) {
				DrawIndentGuide(surface, xIndent + xStart, rcLine,	ll->xHighlightGuide == xIndent, offsetGuide);
			}
		}
	}
}

void EditView::DrawLine(Surface *surface, const EditModel &model, const ViewStyle &vsDraw, const LineLayout *ll,
	Sci::Line line, Sci::Line lineVisible, int xStart, PRectangle rcLine, int subLine, DrawPhase phase) {

	if (subLine >= ll->lines) {
		DrawAnnotation(surface, model, vsDraw, ll, line, xStart, rcLine, subLine, phase);
		return; // No further drawing
	}

	const bool clipLine = !bufferedDraw && !LinesOverlap();
	if (clipLine) {
		surface->SetClip(rcLine);
	}

	// See if something overrides the line background colour.
	const ColourOptional background = vsDraw.Background(model.GetMark(line), model.caret.active, ll->containsCaret);

	const Sci::Position posLineStart = model.pdoc->LineStart(line);

	const Range lineRange = ll->SubLineRange(subLine, LineLayout::Scope::visibleOnly);
	const Range lineRangeIncludingEnd = ll->SubLineRange(subLine, LineLayout::Scope::includeEnd);
	const XYPOSITION subLineStart = ll->positions[lineRange.start];

	if ((ll->wrapIndent != 0) && (subLine > 0)) {
		if (FlagSet(phase, DrawPhase::back)) {
			DrawWrapIndentAndMarker(surface, vsDraw, ll, xStart, rcLine, background, customDrawWrapMarker, model.caret.active);
		}
		xStart += static_cast<int>(ll->wrapIndent);
	}

	if (phasesDraw != PhasesDraw::One) {
		if (FlagSet(phase, DrawPhase::back)) {
			DrawBackground(surface, model, vsDraw, ll,
				xStart, rcLine, subLine, lineRange, posLineStart,
				background);
			DrawFoldDisplayText(surface, model, vsDraw, ll, line, xStart, rcLine, subLine, subLineStart, DrawPhase::back);
			DrawEOLAnnotationText(surface, model, vsDraw, ll, line, xStart, rcLine, subLine, subLineStart, DrawPhase::back);
			// Remove drawBack to not draw again in DrawFoldDisplayText
			phase = static_cast<DrawPhase>(static_cast<int>(phase) & ~static_cast<int>(DrawPhase::back));
			DrawEOL(surface, model, vsDraw, ll,
				line, xStart, rcLine, subLine, lineRange.end, subLineStart, background);
			if (vsDraw.IsLineFrameOpaque(model.caret.active, ll->containsCaret))
				DrawCaretLineFramed(surface, vsDraw, ll, rcLine, subLine);
		}

		if (FlagSet(phase, DrawPhase::indicatorsBack)) {
			DrawIndicators(surface, model, vsDraw, ll, line, xStart, rcLine, subLine,
				lineRangeIncludingEnd.end, true, tabWidthMinimumPixels);
			DrawEdgeLine(surface, vsDraw, ll, xStart, rcLine, lineRange);
			DrawMarkUnderline(surface, model, vsDraw, line, rcLine);
		}
	}

	if (FlagSet(phase, DrawPhase::text)) {
		if (vsDraw.selection.visible) {
			DrawTranslucentSelection(surface, model, vsDraw, ll,
				line, xStart, rcLine, subLine, lineRange, tabWidthMinimumPixels, Layer::UnderText);
		}
		DrawTranslucentLineState(surface, model, vsDraw, ll, line, rcLine, subLine, Layer::UnderText);
		DrawForeground(surface, model, vsDraw, ll,
			xStart, rcLine, subLine, lineVisible, lineRange, posLineStart,
			background);
	}

	if (FlagSet(phase, DrawPhase::indentationGuides)) {
		DrawIndentGuidesOverEmpty(surface, model, vsDraw, ll, line, xStart, rcLine, subLine, lineVisible);
	}

	if (FlagSet(phase, DrawPhase::indicatorsFore)) {
		DrawIndicators(surface, model, vsDraw, ll, line, xStart, rcLine, subLine,
			lineRangeIncludingEnd.end, false, tabWidthMinimumPixels);
	}

	DrawFoldDisplayText(surface, model, vsDraw, ll, line, xStart, rcLine, subLine, subLineStart, phase);
	DrawEOLAnnotationText(surface, model, vsDraw, ll, line, xStart, rcLine, subLine, subLineStart, phase);

	if (phasesDraw == PhasesDraw::One) {
		DrawEOL(surface, model, vsDraw, ll,
			line, xStart, rcLine, subLine, lineRange.end, subLineStart, background);
		if (vsDraw.IsLineFrameOpaque(model.caret.active, ll->containsCaret))
			DrawCaretLineFramed(surface, vsDraw, ll, rcLine, subLine);
		DrawEdgeLine(surface, vsDraw, ll, xStart, rcLine, lineRange);
		DrawMarkUnderline(surface, model, vsDraw, line, rcLine);
	}

	if (vsDraw.selection.visible && FlagSet(phase, DrawPhase::selectionTranslucent)) {
		DrawTranslucentSelection(surface, model, vsDraw, ll,
			line, xStart, rcLine, subLine, lineRange, tabWidthMinimumPixels, Layer::OverText);
	}

	if (FlagSet(phase, DrawPhase::lineTranslucent)) {
		DrawTranslucentLineState(surface, model, vsDraw, ll, line, rcLine, subLine, Layer::OverText);
	}

	if (clipLine) {
		surface->PopClip();
	}
}

void EditView::PaintText(Surface *surfaceWindow, const EditModel &model, const ViewStyle &vsDraw,
	PRectangle rcArea, PRectangle rcClient) {
	// Allow text at start of line to overlap 1 pixel into the margin as this displays
	// serifs and italic stems for aliased text.
	const int leftTextOverlap = ((model.xOffset == 0) && (vsDraw.leftMarginWidth > 0)) ? 1 : 0;

	// Do the painting
	if (rcArea.right > vsDraw.textStart - leftTextOverlap) {

		Surface *surface = surfaceWindow;
		if (bufferedDraw) {
			surface = pixmapLine.get();
			PLATFORM_ASSERT(pixmapLine->Initialised());
		}
		surface->SetMode(model.CurrentSurfaceMode());

		const Point ptOrigin = model.GetVisibleOriginInMain();

		const int screenLinePaintFirst = static_cast<int>(rcArea.top) / vsDraw.lineHeight;
		const int xStart = vsDraw.textStart - model.xOffset + static_cast<int>(ptOrigin.x);

		const SelectionPosition posCaret = model.posDrag.IsValid() ? model.posDrag : model.sel.RangeMain().caret;
		const Sci::Line lineCaret = model.pdoc->SciLineFromPosition(posCaret.Position());
		const int caretOffset = static_cast<int>(posCaret.Position() - model.pdoc->LineStart(lineCaret));

		PRectangle rcTextArea = rcClient;
		if (vsDraw.marginInside) {
			rcTextArea.left += vsDraw.textStart;
			rcTextArea.right -= vsDraw.rightMarginWidth;
		} else {
			rcTextArea = rcArea;
		}

		// Remove selection margin from drawing area so text will not be drawn
		// on it in unbuffered mode.
		const bool clipping = !bufferedDraw && vsDraw.marginInside;
		if (clipping) {
			PRectangle rcClipText = rcTextArea;
			rcClipText.left -= leftTextOverlap;
			surfaceWindow->SetClip(rcClipText);
		}

		// Loop on visible lines
#if defined(TIME_PAINTING)
		double durLayout = 0.0;
		double durPaint = 0.0;
		double durCopy = 0.0;
		ElapsedPeriod epWhole;
#endif
		const bool bracesIgnoreStyle = ((vsDraw.braceHighlightIndicatorSet && (model.bracesMatchStyle == StyleBraceLight)) ||
			(vsDraw.braceBadLightIndicatorSet && (model.bracesMatchStyle == StyleBraceBad)));

		Sci::Line lineDocPrevious = -1;	// Used to avoid laying out one document line multiple times
		std::shared_ptr<LineLayout> ll;
		DrawPhase phase = DrawPhase::all;
		if ((phasesDraw == PhasesDraw::Multiple) && !bufferedDraw) {
			phase = DrawPhase::back;
		}
		for (;;) {
			int yposScreen = screenLinePaintFirst * vsDraw.lineHeight;
			int ypos = bufferedDraw ? 0 : yposScreen;
			Sci::Line visibleLine = model.TopLineOfMain() + screenLinePaintFirst;
			while (visibleLine < model.pcs->LinesDisplayed() && yposScreen < rcArea.bottom) {

				const Sci::Line lineDoc = model.pcs->DocFromDisplay(visibleLine);
				// Only visible lines should be handled by the code within the loop
				PLATFORM_ASSERT(model.pcs->GetVisible(lineDoc));
				const Sci::Line lineStartSet = model.pcs->DisplayFromDoc(lineDoc);
				const int subLine = static_cast<int>(visibleLine - lineStartSet);

				// Copy this line and its styles from the document into local arrays
				// and determine the x position at which each character starts.
#if defined(TIME_PAINTING)
				ElapsedPeriod ep;
#endif
				if (lineDoc != lineDocPrevious) {
					ll = RetrieveLineLayout(lineDoc, model);
					LayoutLine(model, surface, vsDraw, ll.get(), model.wrapWidth);
					lineDocPrevious = lineDoc;
					if (ll && model.BidirectionalEnabled()) {
						// Fill the line bidi data
						UpdateBidiData(model, vsDraw, ll.get());
					}
				}
#if defined(TIME_PAINTING)
				durLayout += ep.Duration(true);
#endif
				if (ll) {
					ll->containsCaret = vsDraw.selection.visible && (lineDoc == lineCaret)
						&& (ll->lines == 1 || !vsDraw.caretLine.subLine || ll->InLine(caretOffset, subLine));

					PRectangle rcLine = rcTextArea;
					rcLine.top = static_cast<XYPOSITION>(ypos);
					rcLine.bottom = static_cast<XYPOSITION>(ypos + vsDraw.lineHeight);

					const Range rangeLine(model.pdoc->LineStart(lineDoc),
						model.pdoc->LineStart(lineDoc + 1));

					// Highlight the current braces if any
					ll->SetBracesHighlight(rangeLine, model.braces, static_cast<char>(model.bracesMatchStyle),
						static_cast<int>(model.highlightGuideColumn * vsDraw.spaceWidth), bracesIgnoreStyle);

					if (leftTextOverlap && (bufferedDraw || ((phasesDraw < PhasesDraw::Multiple) && (FlagSet(phase, DrawPhase::back))))) {
						// Clear the left margin
						PRectangle rcSpacer = rcLine;
						rcSpacer.right = rcSpacer.left;
						rcSpacer.left -= 1;
						surface->FillRectangleAligned(rcSpacer, Fill(vsDraw.styles[StyleDefault].back));
					}

					DrawLine(surface, model, vsDraw, ll.get(), lineDoc, visibleLine, xStart, rcLine, subLine, phase);
#if defined(TIME_PAINTING)
					durPaint += ep.Duration(true);
#endif
					// Restore the previous styles for the brace highlights in case layout is in cache.
					ll->RestoreBracesHighlight(rangeLine, model.braces, bracesIgnoreStyle);

					if (FlagSet(phase, DrawPhase::foldLines)) {
						DrawFoldLines(surface, model, vsDraw, ll.get(), lineDoc, rcLine, subLine);
					}

					if (FlagSet(phase, DrawPhase::carets)) {
						DrawCarets(surface, model, vsDraw, ll.get(), lineDoc, xStart, rcLine, subLine);
					}

					if (bufferedDraw) {
						const Point from = Point::FromInts(vsDraw.textStart - leftTextOverlap, 0);
						const PRectangle rcCopyArea = PRectangle::FromInts(vsDraw.textStart - leftTextOverlap, yposScreen,
							static_cast<int>(rcClient.right - vsDraw.rightMarginWidth),
							yposScreen + vsDraw.lineHeight);
						pixmapLine->FlushDrawing();
						surfaceWindow->Copy(rcCopyArea, from, *pixmapLine);
					}

					lineWidthMaxSeen = std::max(
						lineWidthMaxSeen, static_cast<int>(ll->positions[ll->numCharsInLine]));
#if defined(TIME_PAINTING)
					durCopy += ep.Duration(true);
#endif
				}

				if (!bufferedDraw) {
					ypos += vsDraw.lineHeight;
				}

				yposScreen += vsDraw.lineHeight;
				visibleLine++;
			}

			if (phase >= DrawPhase::carets) {
				break;
			}
			phase = static_cast<DrawPhase>(static_cast<int>(phase) * 2);
		}
		ll.reset();
#if defined(TIME_PAINTING)
		if (durPaint < 0.00000001)
			durPaint = 0.00000001;
#endif
		// Right column limit indicator
		PRectangle rcBeyondEOF = (vsDraw.marginInside) ? rcClient : rcArea;
		rcBeyondEOF.left = static_cast<XYPOSITION>(vsDraw.textStart);
		rcBeyondEOF.right = rcBeyondEOF.right - ((vsDraw.marginInside) ? vsDraw.rightMarginWidth : 0);
		rcBeyondEOF.top = static_cast<XYPOSITION>((model.pcs->LinesDisplayed() - model.TopLineOfMain()) * vsDraw.lineHeight);
		if (rcBeyondEOF.top < rcBeyondEOF.bottom) {
			surfaceWindow->FillRectangleAligned(rcBeyondEOF, Fill(vsDraw.styles[StyleDefault].back));
			if (vsDraw.edgeState == EdgeVisualStyle::Line) {
				const int edgeX = static_cast<int>(vsDraw.theEdge.column * vsDraw.spaceWidth);
				rcBeyondEOF.left = static_cast<XYPOSITION>(edgeX + xStart);
				rcBeyondEOF.right = rcBeyondEOF.left + 1;
				surfaceWindow->FillRectangleAligned(rcBeyondEOF, Fill(vsDraw.theEdge.colour));
			} else if (vsDraw.edgeState == EdgeVisualStyle::MultiLine) {
				for (size_t edge = 0; edge < vsDraw.theMultiEdge.size(); edge++) {
					if (vsDraw.theMultiEdge[edge].column >= 0) {
						const int edgeX = static_cast<int>(vsDraw.theMultiEdge[edge].column * vsDraw.spaceWidth);
						rcBeyondEOF.left = static_cast<XYPOSITION>(edgeX + xStart);
						rcBeyondEOF.right = rcBeyondEOF.left + 1;
						surfaceWindow->FillRectangleAligned(rcBeyondEOF, Fill(vsDraw.theMultiEdge[edge].colour));
					}
				}
			}
		}

		if (clipping)
			surfaceWindow->PopClip();

		//Platform::DebugPrintf("start display %d, offset = %d\n", model.pdoc->Length(), model.xOffset);
#if defined(TIME_PAINTING)
		Platform::DebugPrintf(
		"Layout:%9.6g    Paint:%9.6g    Ratio:%9.6g   Copy:%9.6g   Total:%9.6g\n",
		durLayout, durPaint, durLayout / durPaint, durCopy, epWhole.Duration());
#endif
	}
}

// Space (3 space characters) between line numbers and text when printing.
#define lineNumberPrintSpace "   "

Sci::Position EditView::FormatRange(bool draw, CharacterRangeFull chrg, Rectangle rc, Surface *surface, Surface *surfaceMeasure,
	const EditModel &model, const ViewStyle &vs) {
	// Can't use measurements cached for screen
	posCache->Clear();

	ViewStyle vsPrint(vs);
	vsPrint.technology = Technology::Default;

	// Modify the view style for printing as do not normally want any of the transient features to be printed
	// Printing supports only the line number margin.
	int lineNumberIndex = -1;
	for (size_t margin = 0; margin < vs.ms.size(); margin++) {
		if ((vsPrint.ms[margin].style == MarginType::Number) && (vsPrint.ms[margin].width > 0)) {
			lineNumberIndex = static_cast<int>(margin);
		} else {
			vsPrint.ms[margin].width = 0;
		}
	}
	vsPrint.fixedColumnWidth = 0;
	vsPrint.zoomLevel = printParameters.magnification;
	// Don't show indentation guides
	// If this ever gets changed, cached pixmap would need to be recreated if technology != Technology::Default
	vsPrint.viewIndentationGuides = IndentView::None;
	// Don't show the selection when printing
	vsPrint.selection.visible = false;
	vsPrint.elementColours.clear();
	vsPrint.elementBaseColours.clear();
	vsPrint.caretLine.alwaysShow = false;
	// Don't highlight matching braces using indicators
	vsPrint.braceHighlightIndicatorSet = false;
	vsPrint.braceBadLightIndicatorSet = false;

	// Set colours for printing according to users settings
	const PrintOption colourMode = printParameters.colourMode;
	const std::vector<Style>::iterator endStyles = (colourMode == PrintOption::ColourOnWhiteDefaultBG) ?
		vsPrint.styles.begin() + StyleLineNumber : vsPrint.styles.end();
	for (std::vector<Style>::iterator it = vsPrint.styles.begin(); it != endStyles; ++it) {
		if (colourMode == PrintOption::InvertLight) {
			it->fore = InvertedLight(it->fore);
			it->back = InvertedLight(it->back);
		} else if (colourMode == PrintOption::BlackOnWhite) {
			it->fore = black;
			it->back = white;
		} else if (colourMode == PrintOption::ColourOnWhite || colourMode == PrintOption::ColourOnWhiteDefaultBG) {
			it->back = white;
		}
	}
	// White background for the line numbers if PrintOption::ScreenColours isn't used
	if (colourMode != PrintOption::ScreenColours) {
		vsPrint.styles[StyleLineNumber].back = white;
	}

	// Printing uses different margins, so reset screen margins
	vsPrint.leftMarginWidth = 0;
	vsPrint.rightMarginWidth = 0;

	vsPrint.Refresh(*surfaceMeasure, model.pdoc->tabInChars);
	// Determining width must happen after fonts have been realised in Refresh
	int lineNumberWidth = 0;
	if (lineNumberIndex >= 0) {
		lineNumberWidth = static_cast<int>(surfaceMeasure->WidthText(vsPrint.styles[StyleLineNumber].font.get(),
			"99999" lineNumberPrintSpace));
		vsPrint.ms[lineNumberIndex].width = lineNumberWidth;
		vsPrint.Refresh(*surfaceMeasure, model.pdoc->tabInChars);	// Recalculate fixedColumnWidth
	}

	// Turn off change history marker backgrounds
	constexpr unsigned int changeMarkers =
		1u << static_cast<unsigned int>(MarkerOutline::HistoryRevertedToOrigin) |
		1u << static_cast<unsigned int>(MarkerOutline::HistorySaved) |
		1u << static_cast<unsigned int>(MarkerOutline::HistoryModified) |
		1u << static_cast<unsigned int>(MarkerOutline::HistoryRevertedToModified);
	vsPrint.maskInLine &= ~changeMarkers;

	const Sci::Line linePrintStart = model.pdoc->SciLineFromPosition(chrg.cpMin);
	Sci::Line linePrintLast = linePrintStart + (rc.bottom - rc.top) / vsPrint.lineHeight - 1;
	if (linePrintLast < linePrintStart)
		linePrintLast = linePrintStart;
	const Sci::Line linePrintMax = model.pdoc->SciLineFromPosition(chrg.cpMax);
	if (linePrintLast > linePrintMax)
		linePrintLast = linePrintMax;
	//Platform::DebugPrintf("Formatting lines=[%0d,%0d,%0d] top=%0d bottom=%0d line=%0d %0d\n",
	//      linePrintStart, linePrintLast, linePrintMax, rc.top, rc.bottom, vsPrint.lineHeight,
	//      surfaceMeasure->Height(vsPrint.styles[StyleLineNumber].font));
	Sci::Position endPosPrint = model.pdoc->Length();
	if (linePrintLast < model.pdoc->LinesTotal())
		endPosPrint = model.pdoc->LineStart(linePrintLast + 1);

	// Ensure we are styled to where we are formatting.
	model.pdoc->EnsureStyledTo(endPosPrint);

	const int xStart = vsPrint.fixedColumnWidth + rc.left;
	int ypos = rc.top;

	Sci::Line lineDoc = linePrintStart;

	Sci::Position nPrintPos = chrg.cpMin;
	int visibleLine = 0;
	int widthPrint = rc.right - rc.left - vsPrint.fixedColumnWidth;
	if (printParameters.wrapState == Wrap::None)
		widthPrint = LineLayout::wrapWidthInfinite;

	while (lineDoc <= linePrintLast && ypos < rc.bottom) {

		// When printing, the hdc and hdcTarget may be the same, so
		// changing the state of surfaceMeasure may change the underlying
		// state of surface. Therefore, any cached state is discarded before
		// using each surface.
		surfaceMeasure->FlushCachedState();

		// Copy this line and its styles from the document into local arrays
		// and determine the x position at which each character starts.
		LineLayout ll(lineDoc, static_cast<int>(model.pdoc->LineStart(lineDoc + 1) - model.pdoc->LineStart(lineDoc) + 1));
		LayoutLine(model, surfaceMeasure, vsPrint, &ll, widthPrint);

		ll.containsCaret = false;

		PRectangle rcLine = PRectangle::FromInts(
			rc.left,
			ypos,
			rc.right - 1,
			ypos + vsPrint.lineHeight);

		// When document line is wrapped over multiple display lines, find where
		// to start printing from to ensure a particular position is on the first
		// line of the page.
		if (visibleLine == 0) {
			const Sci::Position startWithinLine = nPrintPos -
				model.pdoc->LineStart(lineDoc);
			for (int iwl = 0; iwl < ll.lines - 1; iwl++) {
				if (ll.LineStart(iwl) <= startWithinLine && ll.LineStart(iwl + 1) >= startWithinLine) {
					visibleLine = -iwl;
				}
			}

			if (ll.lines > 1 && startWithinLine >= ll.LineStart(ll.lines - 1)) {
				visibleLine = -(ll.lines - 1);
			}
		}

		if (draw && lineNumberWidth &&
			(ypos + vsPrint.lineHeight <= rc.bottom) &&
			(visibleLine >= 0)) {
			const std::string number = std::to_string(lineDoc + 1) + lineNumberPrintSpace;
			PRectangle rcNumber = rcLine;
			rcNumber.right = rcNumber.left + lineNumberWidth;
			// Right justify
			rcNumber.left = rcNumber.right - surfaceMeasure->WidthText(
				vsPrint.styles[StyleLineNumber].font.get(), number);
			surface->FlushCachedState();
			surface->DrawTextNoClip(rcNumber, vsPrint.styles[StyleLineNumber].font.get(),
				ypos + vsPrint.maxAscent, number,
				vsPrint.styles[StyleLineNumber].fore,
				vsPrint.styles[StyleLineNumber].back);
		}

		// Draw the line
		surface->FlushCachedState();

		for (int iwl = 0; iwl < ll.lines; iwl++) {
			if (ypos + vsPrint.lineHeight <= rc.bottom) {
				if (visibleLine >= 0) {
					if (draw) {
						rcLine.top = static_cast<XYPOSITION>(ypos);
						rcLine.bottom = static_cast<XYPOSITION>(ypos + vsPrint.lineHeight);
						DrawLine(surface, model, vsPrint, &ll, lineDoc, visibleLine, xStart, rcLine, iwl, DrawPhase::all);
					}
					ypos += vsPrint.lineHeight;
				}
				visibleLine++;
				if (iwl == ll.lines - 1)
					nPrintPos = model.pdoc->LineStart(lineDoc + 1);
				else
					nPrintPos += ll.LineStart(iwl + 1) - ll.LineStart(iwl);
			}
		}

		++lineDoc;
	}

	// Clear cache so measurements are not used for screen
	posCache->Clear();

	return nPrintPos;
}


================================================
FILE: Libraries/scintilla/src/EditView.h
================================================
// Scintilla source code edit control
/** @file EditView.h
 ** Defines the appearance of the main text area of the editor window.
 **/
// Copyright 1998-2014 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#ifndef EDITVIEW_H
#define EDITVIEW_H

namespace Scintilla::Internal {

struct PrintParameters {
	int magnification;
	Scintilla::PrintOption colourMode;
	Scintilla::Wrap wrapState;
	PrintParameters() noexcept;
};

/**
* The view may be drawn in separate phases.
*/
enum class DrawPhase {
	none = 0x0,
	back = 0x1,
	indicatorsBack = 0x2,
	text = 0x4,
	indentationGuides = 0x8,
	indicatorsFore = 0x10,
	selectionTranslucent = 0x20,
	lineTranslucent = 0x40,
	foldLines = 0x80,
	carets = 0x100,
	all = 0x1FF
};

bool ValidStyledText(const ViewStyle &vs, size_t styleOffset, const StyledText &st) noexcept;
int WidestLineWidth(Surface *surface, const ViewStyle &vs, int styleOffset, const StyledText &st);
void DrawTextNoClipPhase(Surface *surface, PRectangle rc, const Style &style, XYPOSITION ybase,
	std::string_view text, DrawPhase phase);
void DrawStyledText(Surface *surface, const ViewStyle &vs, int styleOffset, PRectangle rcText,
	const StyledText &st, size_t start, size_t length, DrawPhase phase);

typedef void (*DrawTabArrowFn)(Surface *surface, PRectangle rcTab, int ymid,
	const ViewStyle &vsDraw, Stroke stroke);

class LineTabstops;

/**
* EditView draws the main text area.
*/
class EditView {
public:
	PrintParameters printParameters;
	std::unique_ptr<LineTabstops> ldTabstops;
	int tabWidthMinimumPixels;

	bool drawOverstrikeCaret; // used by the curses platform

	/** In bufferedDraw mode, graphics operations are drawn to a pixmap and then copied to
	* the screen. This avoids flashing but is about 30% slower. */
	bool bufferedDraw;
	/** In phasesTwo mode, drawing is performed in two phases, first the background
	* and then the foreground. This avoids chopping off characters that overlap the next run.
	* In multiPhaseDraw mode, drawing is performed in multiple phases with each phase drawing
	* one feature over the whole drawing area, instead of within one line. This allows text to
	* overlap from one line to the next. */
	Scintilla::PhasesDraw phasesDraw;

	int lineWidthMaxSeen;

	bool additionalCaretsBlink;
	bool additionalCaretsVisible;

	bool imeCaretBlockOverride;

	std::unique_ptr<Surface> pixmapLine;
	std::unique_ptr<Surface> pixmapIndentGuide;
	std::unique_ptr<Surface> pixmapIndentGuideHighlight;

	LineLayoutCache llc;
	std::unique_ptr<IPositionCache> posCache;

	unsigned int maxLayoutThreads;
	static constexpr int bytesPerLayoutThread = 1000;

	int tabArrowHeight; // draw arrow heads this many pixels above/below line midpoint
	/** Some platforms, notably PLAT_CURSES, do not support Scintilla's native
	 * DrawTabArrow function for drawing tab characters. Allow those platforms to
	 * override it instead of creating a new method in the Surface class that
	 * existing platforms must implement as empty. */
	DrawTabArrowFn customDrawTabArrow;
	DrawWrapMarkerFn customDrawWrapMarker;

	EditView();
	// Deleted so EditView objects can not be copied.
	EditView(const EditView &) = delete;
	EditView(EditView &&) = delete;
	void operator=(const EditView &) = delete;
	void operator=(EditView &&) = delete;
	virtual ~EditView();

	bool SetTwoPhaseDraw(bool twoPhaseDraw) noexcept;
	bool SetPhasesDraw(int phases) noexcept;
	bool LinesOverlap() const noexcept;

	void SetLayoutThreads(unsigned int threads) noexcept;
	unsigned int GetLayoutThreads() const noexcept;

	void ClearAllTabstops() noexcept;
	XYPOSITION NextTabstopPos(Sci::Line line, XYPOSITION x, XYPOSITION tabWidth) const noexcept;
	bool ClearTabstops(Sci::Line line) noexcept;
	bool AddTabstop(Sci::Line line, int x);
	int GetNextTabstop(Sci::Line line, int x) const noexcept;
	void LinesAddedOrRemoved(Sci::Line lineOfPos, Sci::Line linesAdded);

	void DropGraphics() noexcept;
	void RefreshPixMaps(Surface *surfaceWindow, const ViewStyle &vsDraw);

	std::shared_ptr<LineLayout> RetrieveLineLayout(Sci::Line lineNumber, const EditModel &model);
	void LayoutLine(const EditModel &model, Surface *surface, const ViewStyle &vstyle,
		LineLayout *ll, int width, bool callerMultiThreaded=false);

	static void UpdateBidiData(const EditModel &model, const ViewStyle &vstyle, LineLayout *ll);

	Point LocationFromPosition(Surface *surface, const EditModel &model, SelectionPosition pos, Sci::Line topLine,
		const ViewStyle &vs, PointEnd pe, const PRectangle rcClient);
	Range RangeDisplayLine(Surface *surface, const EditModel &model, Sci::Line lineVisible, const ViewStyle &vs);
	SelectionPosition SPositionFromLocation(Surface *surface, const EditModel &model, PointDocument pt, bool canReturnInvalid,
		bool charPosition, bool virtualSpace, const ViewStyle &vs, const PRectangle rcClient);
	SelectionPosition SPositionFromLineX(Surface *surface, const EditModel &model, Sci::Line lineDoc, int x, const ViewStyle &vs);
	Sci::Line DisplayFromPosition(Surface *surface, const EditModel &model, Sci::Position pos, const ViewStyle &vs);
	Sci::Position StartEndDisplayLine(Surface *surface, const EditModel &model, Sci::Position pos, bool start, const ViewStyle &vs);

private:
	void DrawEOL(Surface *surface, const EditModel &model, const ViewStyle &vsDraw, const LineLayout *ll,
		Sci::Line line, int xStart, PRectangle rcLine, int subLine, Sci::Position lineEnd, XYPOSITION subLineStart, ColourOptional background);
	void DrawFoldDisplayText(Surface *surface, const EditModel &model, const ViewStyle &vsDraw, const LineLayout *ll,
		Sci::Line line, int xStart, PRectangle rcLine, int subLine, XYPOSITION subLineStart, DrawPhase phase);
	void DrawEOLAnnotationText(Surface *surface, const EditModel &model, const ViewStyle &vsDraw, const LineLayout *ll,
		Sci::Line line, int xStart, PRectangle rcLine, int subLine, XYPOSITION subLineStart, DrawPhase phase);
	void DrawAnnotation(Surface *surface, const EditModel &model, const ViewStyle &vsDraw, const LineLayout *ll,
		Sci::Line line, int xStart, PRectangle rcLine, int subLine, DrawPhase phase);
	void DrawCarets(Surface *surface, const EditModel &model, const ViewStyle &vsDraw, const LineLayout *ll,
		Sci::Line lineDoc, int xStart, PRectangle rcLine, int subLine) const;
	void DrawIndentGuide(Surface *surface, XYPOSITION start, PRectangle rcSegment, bool highlight, bool offset);
	void DrawForeground(Surface *surface, const EditModel &model, const ViewStyle &vsDraw, const LineLayout *ll,
		int xStart, PRectangle rcLine, int subLine, Sci::Line lineVisible, Range lineRange, Sci::Position posLineStart,
		ColourOptional background);
	void DrawIndentGuidesOverEmpty(Surface *surface, const EditModel &model, const ViewStyle &vsDraw, const LineLayout *ll,
		Sci::Line line, int xStart, PRectangle rcLine, int subLine, Sci::Line lineVisible);
	void DrawLine(Surface *surface, const EditModel &model, const ViewStyle &vsDraw, const LineLayout *ll,
		Sci::Line line, Sci::Line lineVisible, int xStart, PRectangle rcLine, int subLine, DrawPhase phase);

public:
	void PaintText(Surface *surfaceWindow, const EditModel &model, const ViewStyle &vsDraw,
		PRectangle rcArea, PRectangle rcClient);
	Sci::Position FormatRange(bool draw, CharacterRangeFull chrg, Rectangle rc, Surface *surface, Surface *surfaceMeasure,
		const EditModel &model, const ViewStyle &vs);
};

}

#endif


================================================
FILE: Libraries/scintilla/src/Editor.cxx
================================================
// Scintilla source code edit control
/** @file Editor.cxx
 ** Main code for the edit control.
 **/
// Copyright 1998-2011 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#include <cstddef>
#include <cstdlib>
#include <cstdint>
#include <cassert>
#include <cstring>
#include <cstdio>
#include <cmath>

#include <stdexcept>
#include <string>
#include <string_view>
#include <vector>
#include <map>
#include <set>
#include <forward_list>
#include <optional>
#include <algorithm>
#include <iterator>
#include <memory>
#include <chrono>
#include <atomic>
#include <mutex>
#include <thread>
#include <future>

#include "ScintillaTypes.h"
#include "ScintillaMessages.h"
#include "ScintillaStructures.h"
#include "ILoader.h"
#include "ILexer.h"

#include "Debugging.h"
#include "Geometry.h"
#include "Platform.h"

#include "CharacterType.h"
#include "CharacterCategoryMap.h"
#include "Position.h"
#include "UniqueString.h"
#include "SplitVector.h"
#include "Partitioning.h"
#include "RunStyles.h"
#include "ContractionState.h"
#include "CellBuffer.h"
#include "PerLine.h"
#include "KeyMap.h"
#include "Indicator.h"
#include "LineMarker.h"
#include "Style.h"
#include "ViewStyle.h"
#include "CharClassify.h"
#include "Decoration.h"
#include "CaseFolder.h"
#include "Document.h"
#include "UniConversion.h"
#include "DBCS.h"
#include "Selection.h"
#include "PositionCache.h"
#include "EditModel.h"
#include "MarginView.h"
#include "EditView.h"
#include "Editor.h"
#include "ElapsedPeriod.h"

using namespace Scintilla;
using namespace Scintilla::Internal;

namespace {

/*
	return whether this modification represents an operation that
	may reasonably be deferred (not done now OR [possibly] at all)
*/
constexpr bool CanDeferToLastStep(const DocModification &mh) noexcept {
	if (FlagSet(mh.modificationType, (ModificationFlags::BeforeInsert | ModificationFlags::BeforeDelete)))
		return true;	// CAN skip
	if (!FlagSet(mh.modificationType, (ModificationFlags::Undo | ModificationFlags::Redo)))
		return false;	// MUST do
	if (FlagSet(mh.modificationType, ModificationFlags::MultiStepUndoRedo))
		return true;	// CAN skip
	return false;		// PRESUMABLY must do
}

constexpr bool CanEliminate(const DocModification &mh) noexcept {
	return
		FlagSet(mh.modificationType, (ModificationFlags::BeforeInsert | ModificationFlags::BeforeDelete));
}

/*
	return whether this modification represents the FINAL step
	in a [possibly lengthy] multi-step Undo/Redo sequence
*/
constexpr bool IsLastStep(const DocModification &mh) noexcept {
	constexpr ModificationFlags finalMask = ModificationFlags::MultiStepUndoRedo
		| ModificationFlags::LastStepInUndoRedo
		| ModificationFlags::MultilineUndoRedo;
	return
		FlagSet(mh.modificationType, (ModificationFlags::Undo | ModificationFlags::Redo))
	    && ((mh.modificationType & finalMask) == finalMask);
}

constexpr bool IsAllSpacesOrTabs(std::string_view sv) noexcept {
	for (const char ch : sv) {
		// This is safe because IsSpaceOrTab() will return false for null terminators
		if (!IsSpaceOrTab(ch))
			return false;
	}
	return true;
}

}

Timer::Timer() noexcept :
		ticking(false), ticksToWait(0), tickerID{} {}

Idler::Idler() noexcept :
		state(false), idlerID(nullptr) {}

Editor::Editor() : durationWrapOneByte(0.000001, 0.00000001, 0.00001) {
	ctrlID = 0;

	stylesValid = false;
	technology = Technology::Default;
	scaleRGBAImage = 100.0f;

	cursorMode = CursorShape::Normal;

	errorStatus = Status::Ok;
	mouseDownCaptures = true;
	mouseWheelCaptures = true;

	lastClickTime = 0;
	doubleClickCloseThreshold = Point(3, 3);
	dwellDelay = TimeForever;
	ticksToDwell = TimeForever;
	dwelling = false;
	ptMouseLast.x = 0;
	ptMouseLast.y = 0;
	inDragDrop = DragDrop::none;
	dropWentOutside = false;
	posDrop = SelectionPosition(Sci::invalidPosition);
	hotSpotClickPos = Sci::invalidPosition;
	selectionUnit = TextUnit::character;

	lastXChosen = 0;
	lineAnchorPos = 0;
	originalAnchorPos = 0;
	wordSelectAnchorStartPos = 0;
	wordSelectAnchorEndPos = 0;
	wordSelectInitialCaretPos = -1;

	caretPolicies.x = { CaretPolicy::Slop | CaretPolicy::Even, 50 };
	caretPolicies.y = { CaretPolicy::Even, 0 };

	visiblePolicy = { 0, 0 };

	searchAnchor = 0;

	xCaretMargin = 50;
	horizontalScrollBarVisible = true;
	scrollWidth = 2000;
	verticalScrollBarVisible = true;
	endAtLastLine = true;
	caretSticky = CaretSticky::Off;
	marginOptions = MarginOption::None;
	mouseSelectionRectangularSwitch = false;
	multipleSelection = false;
	additionalSelectionTyping = false;
	multiPasteMode = MultiPaste::Once;
	virtualSpaceOptions = VirtualSpace::None;

	targetRange = SelectionSegment();
	searchFlags = FindOption::None;

	topLine = 0;
	posTopLine = 0;

	lengthForEncode = -1;

	needUpdateUI = Update::None;
	ContainerNeedsUpdate(Update::Content);

	paintState = PaintState::notPainting;
	paintAbandonedByStyling = false;
	paintingAllText = false;
	willRedrawAll = false;
	idleStyling = IdleStyling::None;
	needIdleStyling = false;

	modEventMask = ModificationFlags::EventMaskAll;
	commandEvents = true;

	pdoc->AddWatcher(this, nullptr);

	recordingMacro = false;
	foldAutomatic = AutomaticFold::None;

	insideWrapScroll = false;

	convertPastes = true;

	SetRepresentations();
}

Editor::~Editor() {
	pdoc->RemoveWatcher(this, nullptr);
}

void Editor::Finalise() {
	SetIdle(false);
	CancelModes();
}

void Editor::SetRepresentations() {
	reprs->SetDefaultRepresentations(pdoc->dbcsCodePage);
}

void Editor::DropGraphics() noexcept {
	marginView.DropGraphics();
	view.DropGraphics();
}

void Editor::InvalidateStyleData() noexcept {
	stylesValid = false;
	vs.technology = technology;
	DropGraphics();
	view.llc.Invalidate(LineLayout::ValidLevel::invalid);
	view.posCache->Clear();
}

void Editor::InvalidateStyleRedraw() {
	NeedWrapping();
	InvalidateStyleData();
	Redraw();
}

void Editor::RefreshStyleData() {
	if (!stylesValid) {
		stylesValid = true;
		AutoSurface surface(this);
		if (surface) {
			vs.Refresh(*surface, pdoc->tabInChars);
		}
		SetScrollBars();
		SetRectangularRange();
	}
}

bool Editor::HasMarginWindow() const noexcept {
	return wMargin.Created();
}

Point Editor::GetVisibleOriginInMain() const {
	return Point(0, 0);
}

PointDocument Editor::DocumentPointFromView(Point ptView) const {
	PointDocument ptDocument(ptView);
	if (HasMarginWindow()) {
		const Point ptOrigin = GetVisibleOriginInMain();
		ptDocument.x += ptOrigin.x;
		ptDocument.y += ptOrigin.y;
	} else {
		ptDocument.x += xOffset;
		ptDocument.y += static_cast<double>(topLine * vs.lineHeight);
	}
	return ptDocument;
}

Sci::Line Editor::TopLineOfMain() const noexcept {
	if (HasMarginWindow())
		return 0;
	return topLine;
}

Point Editor::ClientSize() const {
	const PRectangle rcClient = GetClientRectangle();
	return Point(rcClient.Width(), rcClient.Height());
}

PRectangle Editor::GetClientRectangle() const {
	return wMain.GetClientPosition();
}

PRectangle Editor::GetClientDrawingRectangle() {
	return GetClientRectangle();
}

PRectangle Editor::GetTextRectangle() const {
	PRectangle rc = GetClientRectangle();
	rc.left += vs.textStart;
	rc.right -= vs.rightMarginWidth;
	return rc;
}

Sci::Line Editor::LinesOnScreen() const {
	const Point sizeClient = ClientSize();
	const int htClient = static_cast<int>(sizeClient.y);
	//Platform::DebugPrintf("lines on screen = %d\n", htClient / lineHeight + 1);
	return htClient / vs.lineHeight;
}

Sci::Line Editor::LinesToScroll() const {
	const Sci::Line retVal = LinesOnScreen() - 1;
	if (retVal < 1)
		return 1;
	return retVal;
}

Sci::Line Editor::MaxScrollPos() const {
	//Platform::DebugPrintf("Lines %d screen = %d maxScroll = %d\n",
	//LinesTotal(), LinesOnScreen(), LinesTotal() - LinesOnScreen() + 1);
	Sci::Line retVal = pcs->LinesDisplayed();
	if (endAtLastLine) {
		retVal -= LinesOnScreen();
	} else {
		retVal--;
	}
	if (retVal < 0) {
		return 0;
	}
	return retVal;
}

SelectionPosition Editor::ClampPositionIntoDocument(SelectionPosition sp) const {
	if (sp.Position() < 0) {
		return SelectionPosition(0);
	} else if (sp.Position() > pdoc->Length()) {
		return SelectionPosition(pdoc->Length());
	} else {
		// If not at end of line then set offset to 0
		if (!pdoc->IsLineEndPosition(sp.Position()))
			sp.SetVirtualSpace(0);
		return sp;
	}
}

Point Editor::LocationFromPosition(SelectionPosition pos, PointEnd pe) {
	const PRectangle rcClient = GetTextRectangle();
	RefreshStyleData();
	AutoSurface surface(this);
	return view.LocationFromPosition(surface, *this, pos, topLine, vs, pe, rcClient);
}

Point Editor::LocationFromPosition(Sci::Position pos, PointEnd pe) {
	return LocationFromPosition(SelectionPosition(pos), pe);
}

int Editor::XFromPosition(SelectionPosition sp) {
	const Point pt = LocationFromPosition(sp);
	return static_cast<int>(pt.x) - vs.textStart + xOffset;
}

SelectionPosition Editor::SPositionFromLocation(Point pt, bool canReturnInvalid, bool charPosition, bool virtualSpace) {
	RefreshStyleData();
	AutoSurface surface(this);

	PRectangle rcClient = GetTextRectangle();
	// May be in scroll view coordinates so translate back to main view
	const Point ptOrigin = GetVisibleOriginInMain();
	rcClient.Move(-ptOrigin.x, -ptOrigin.y);

	if (canReturnInvalid) {
		if (!rcClient.Contains(pt))
			return SelectionPosition(Sci::invalidPosition);
		if (pt.x < vs.textStart)
			return SelectionPosition(Sci::invalidPosition);
		if (pt.y < 0)
			return SelectionPosition(Sci::invalidPosition);
	}
	const PointDocument ptdoc = DocumentPointFromView(pt);
	return view.SPositionFromLocation(surface, *this, ptdoc, canReturnInvalid,
		charPosition, virtualSpace, vs, rcClient);
}

Sci::Position Editor::PositionFromLocation(Point pt, bool canReturnInvalid, bool charPosition) {
	return SPositionFromLocation(pt, canReturnInvalid, charPosition, false).Position();
}

/**
* Find the document position corresponding to an x coordinate on a particular document line.
* Ensure is between whole characters when document is in multi-byte or UTF-8 mode.
* This method is used for rectangular selections and does not work on wrapped lines.
*/
SelectionPosition Editor::SPositionFromLineX(Sci::Line lineDoc, int x) {
	RefreshStyleData();
	if (lineDoc >= pdoc->LinesTotal())
		return SelectionPosition(pdoc->Length());
	//Platform::DebugPrintf("Position of (%d,%d) line = %d top=%d\n", pt.x, pt.y, line, topLine);
	AutoSurface surface(this);
	return view.SPositionFromLineX(surface, *this, lineDoc, x, vs);
}

Sci::Position Editor::PositionFromLineX(Sci::Line lineDoc, int x) {
	return SPositionFromLineX(lineDoc, x).Position();
}

Sci::Line Editor::LineFromLocation(Point pt) const noexcept {
	return pcs->DocFromDisplay(static_cast<int>(pt.y) / vs.lineHeight + topLine);
}

void Editor::SetTopLine(Sci::Line topLineNew) {
	if ((topLine != topLineNew) && (topLineNew >= 0)) {
		topLine = topLineNew;
		ContainerNeedsUpdate(Update::VScroll);
	}
	posTopLine = pdoc->LineStart(pcs->DocFromDisplay(topLine));
}

/**
 * If painting then abandon the painting because a wider redraw is needed.
 * @return true if calling code should stop drawing.
 */
bool Editor::AbandonPaint() {
	if ((paintState == PaintState::painting) && !paintingAllText) {
		paintState = PaintState::abandoned;
	}
	return paintState == PaintState::abandoned;
}

void Editor::RedrawRect(PRectangle rc) {
	//Platform::DebugPrintf("Redraw %0d,%0d - %0d,%0d\n", rc.left, rc.top, rc.right, rc.bottom);

	// Clip the redraw rectangle into the client area
	const PRectangle rcClient = GetClientRectangle();
	if (rc.top < rcClient.top)
		rc.top = rcClient.top;
	if (rc.bottom > rcClient.bottom)
		rc.bottom = rcClient.bottom;
	if (rc.left < rcClient.left)
		rc.left = rcClient.left;
	if (rc.right > rcClient.right)
		rc.right = rcClient.right;

	if ((rc.bottom > rc.top) && (rc.right > rc.left)) {
		wMain.InvalidateRectangle(rc);
	}
}

void Editor::DiscardOverdraw() {
	// Overridden on platforms that may draw outside visible area.
}

void Editor::Redraw() {
	if (redrawPendingText) {
		return;
	}
	//Platform::DebugPrintf("Redraw all\n");
	const PRectangle rcClient = GetClientRectangle();
	wMain.InvalidateRectangle(rcClient);
	if (HasMarginWindow()) {
		wMargin.InvalidateAll();
	} else if (paintState == PaintState::notPainting) {
		redrawPendingText = true;
	}
}

void Editor::RedrawSelMargin(Sci::Line line, bool allAfter) {
	const bool markersInText = vs.maskInLine || vs.maskDrawInText;
	if (!HasMarginWindow() || markersInText) {	// May affect text area so may need to abandon and retry
		if (AbandonPaint()) {
			return;
		}
	}
	if (HasMarginWindow() && markersInText) {
		Redraw();
		return;
	}
	if (redrawPendingMargin) {
		return;
	}
	PRectangle rcMarkers = GetClientRectangle();
	if (!markersInText) {
		// Normal case: just draw the margin
		rcMarkers.right = rcMarkers.left + vs.fixedColumnWidth;
	}
	const PRectangle rcMarkersFull = rcMarkers;
	if (line != -1) {
		PRectangle rcLine = RectangleFromRange(Range(pdoc->LineStart(line)), 0);

		// Inflate line rectangle if there are image markers with height larger than line height
		if (vs.largestMarkerHeight > vs.lineHeight) {
			const int delta = (vs.largestMarkerHeight - vs.lineHeight + 1) / 2;
			rcLine.top -= delta;
			rcLine.bottom += delta;
			if (rcLine.top < rcMarkers.top)
				rcLine.top = rcMarkers.top;
			if (rcLine.bottom > rcMarkers.bottom)
				rcLine.bottom = rcMarkers.bottom;
		}

		rcMarkers.top = rcLine.top;
		if (!allAfter)
			rcMarkers.bottom = rcLine.bottom;
		if (rcMarkers.Empty())
			return;
	}
	if (HasMarginWindow()) {
		const Point ptOrigin = GetVisibleOriginInMain();
		rcMarkers.Move(-ptOrigin.x, -ptOrigin.y);
		wMargin.InvalidateRectangle(rcMarkers);
	} else {
		wMain.InvalidateRectangle(rcMarkers);
		if (rcMarkers == rcMarkersFull) {
			redrawPendingMargin = true;
		}
	}
}

PRectangle Editor::RectangleFromRange(Range r, int overlap) {
	const Sci::Line docLineFirst = pdoc->SciLineFromPosition(r.First());
	const Sci::Line minLine = pcs->DisplayFromDoc(docLineFirst);
	Sci::Line docLineLast = docLineFirst;	// Common case where range is wholly in one document line
	if (r.Last() >= pdoc->LineStart(docLineFirst + 1)) {
		// Range covers multiple lines so need last line
		docLineLast = pdoc->SciLineFromPosition(r.Last());
	}
	const Sci::Line maxLine = pcs->DisplayLastFromDoc(docLineLast);
	const PRectangle rcClientDrawing = GetClientDrawingRectangle();
	PRectangle rc;
	const int leftTextOverlap = ((xOffset == 0) && (vs.leftMarginWidth > 0)) ? 1 : 0;
	rc.left = static_cast<XYPOSITION>(vs.textStart - leftTextOverlap);
	rc.top = static_cast<XYPOSITION>((minLine - TopLineOfMain()) * vs.lineHeight - overlap);
	if (rc.top < rcClientDrawing.top)
		rc.top = rcClientDrawing.top;
	// Extend to right of prepared area if any to prevent artifacts from caret line highlight
	rc.right = rcClientDrawing.right;
	rc.bottom = static_cast<XYPOSITION>((maxLine - TopLineOfMain() + 1) * vs.lineHeight + overlap);

	return rc;
}

void Editor::InvalidateRange(Sci::Position start, Sci::Position end) {
	if (redrawPendingText) {
		return;
	}
	RedrawRect(RectangleFromRange(Range(start, end), view.LinesOverlap() ? vs.lineOverlap : 0));
}

Sci::Position Editor::CurrentPosition() const noexcept {
	return sel.MainCaret();
}

bool Editor::SelectionEmpty() const noexcept {
	return sel.Empty();
}

SelectionPosition Editor::SelectionStart() noexcept {
	return sel.RangeMain().Start();
}

SelectionPosition Editor::SelectionEnd() noexcept {
	return sel.RangeMain().End();
}

void Editor::SetRectangularRange() {
	if (sel.IsRectangular()) {
		const int xAnchor = XFromPosition(sel.Rectangular().anchor);
		int xCaret = XFromPosition(sel.Rectangular().caret);
		if (sel.selType == Selection::SelTypes::thin) {
			xCaret = xAnchor;
		}
		const Sci::Line lineAnchorRect =
			pdoc->SciLineFromPosition(sel.Rectangular().anchor.Position());
		const Sci::Line lineCaret =
			pdoc->SciLineFromPosition(sel.Rectangular().caret.Position());
		const int increment = (lineCaret > lineAnchorRect) ? 1 : -1;
		AutoSurface surface(this);
		for (Sci::Line line=lineAnchorRect; line != lineCaret+increment; line += increment) {
			SelectionRange range(
				view.SPositionFromLineX(surface, *this, line, xCaret, vs),
				view.SPositionFromLineX(surface, *this, line, xAnchor, vs));
			if (!FlagSet(virtualSpaceOptions, VirtualSpace::RectangularSelection))
				range.ClearVirtualSpace();
			if (line == lineAnchorRect)
				sel.SetSelection(range);
			else
				sel.AddSelectionWithoutTrim(range);
		}
	}
}

void Editor::ThinRectangularRange() {
	if (sel.IsRectangular()) {
		sel.selType = Selection::SelTypes::thin;
		if (sel.Rectangular().caret < sel.Rectangular().anchor) {
			sel.Rectangular() = SelectionRange(sel.Range(sel.Count()-1).caret, sel.Range(0).anchor);
		} else {
			sel.Rectangular() = SelectionRange(sel.Range(sel.Count()-1).anchor, sel.Range(0).caret);
		}
		SetRectangularRange();
	}
}

void Editor::InvalidateSelection(SelectionRange newMain, bool invalidateWholeSelection) {
	if (sel.Count() > 1 || !(sel.RangeMain().anchor == newMain.anchor) || sel.IsRectangular()) {
		invalidateWholeSelection = true;
	}
	Sci::Position firstAffected = std::min(sel.RangeMain().Start().Position(), newMain.Start().Position());
	// +1 for lastAffected ensures caret repainted
	Sci::Position lastAffected = std::max(newMain.caret.Position()+1, newMain.anchor.Position());
	lastAffected = std::max(lastAffected, sel.RangeMain().End().Position());
	if (invalidateWholeSelection) {
		for (size_t r=0; r<sel.Count(); r++) {
			firstAffected = std::min(firstAffected, sel.Range(r).caret.Position());
			firstAffected = std::min(firstAffected, sel.Range(r).anchor.Position());
			lastAffected = std::max(lastAffected, sel.Range(r).caret.Position()+1);
			lastAffected = std::max(lastAffected, sel.Range(r).anchor.Position());
		}
	}
	ContainerNeedsUpdate(Update::Selection);
	InvalidateRange(firstAffected, lastAffected);
}

void Editor::InvalidateWholeSelection() {
	InvalidateSelection(sel.RangeMain(), true);
}

/* For Line selection - the anchor and caret are always
   at the beginning and end of the region lines. */
SelectionRange Editor::LineSelectionRange(SelectionPosition currentPos_, SelectionPosition anchor_) const noexcept {
	if (currentPos_ > anchor_) {
		anchor_ = SelectionPosition(pdoc->LineStartPosition(anchor_.Position()));
		currentPos_ = SelectionPosition(pdoc->LineEndPosition(currentPos_.Position()));
	} else {
		currentPos_ = SelectionPosition(pdoc->LineStartPosition(currentPos_.Position()));
		anchor_ = SelectionPosition(pdoc->LineEndPosition(anchor_.Position()));
	}
	return SelectionRange(currentPos_, anchor_);
}

void Editor::SetSelection(SelectionPosition currentPos_, SelectionPosition anchor_) {
	currentPos_ = ClampPositionIntoDocument(currentPos_);
	anchor_ = ClampPositionIntoDocument(anchor_);
	const Sci::Line currentLine = pdoc->SciLineFromPosition(currentPos_.Position());
	SelectionRange rangeNew(currentPos_, anchor_);
	if (sel.selType == Selection::SelTypes::lines) {
		rangeNew = LineSelectionRange(currentPos_, anchor_);
	}
	if (sel.Count() > 1 || !(sel.RangeMain() == rangeNew)) {
		InvalidateSelection(rangeNew);
	}
	sel.RangeMain() = rangeNew;
	SetRectangularRange();
	ClaimSelection();
	SetHoverIndicatorPosition(sel.MainCaret());

	if (marginView.highlightDelimiter.NeedsDrawing(currentLine)) {
		RedrawSelMargin();
	}
	QueueIdleWork(WorkItems::updateUI);
}

void Editor::SetSelection(Sci::Position currentPos_, Sci::Position anchor_) {
	SetSelection(SelectionPosition(currentPos_), SelectionPosition(anchor_));
}

// Just move the caret on the main selection
void Editor::SetSelection(SelectionPosition currentPos_) {
	currentPos_ = ClampPositionIntoDocument(currentPos_);
	const Sci::Line currentLine = pdoc->SciLineFromPosition(currentPos_.Position());
	if (sel.Count() > 1 || !(sel.RangeMain().caret == currentPos_)) {
		InvalidateSelection(SelectionRange(currentPos_));
	}
	if (sel.IsRectangular()) {
		sel.Rectangular() =
			SelectionRange(SelectionPosition(currentPos_), sel.Rectangular().anchor);
		SetRectangularRange();
	} else if (sel.selType == Selection::SelTypes::lines) {
		sel.RangeMain() = LineSelectionRange(currentPos_, sel.RangeMain().anchor);
	} else {
		sel.RangeMain() =
			SelectionRange(SelectionPosition(currentPos_), sel.RangeMain().anchor);
	}
	ClaimSelection();
	SetHoverIndicatorPosition(sel.MainCaret());

	if (marginView.highlightDelimiter.NeedsDrawing(currentLine)) {
		RedrawSelMargin();
	}
	QueueIdleWork(WorkItems::updateUI);
}

void Editor::SetEmptySelection(SelectionPosition currentPos_) {
	const Sci::Line currentLine = pdoc->SciLineFromPosition(currentPos_.Position());
	SelectionRange rangeNew(ClampPositionIntoDocument(currentPos_));
	if (sel.Count() > 1 || !(sel.RangeMain() == rangeNew)) {
		InvalidateSelection(rangeNew);
	}
	sel.Clear();
	sel.RangeMain() = rangeNew;
	SetRectangularRange();
	ClaimSelection();
	SetHoverIndicatorPosition(sel.MainCaret());

	if (marginView.highlightDelimiter.NeedsDrawing(currentLine)) {
		RedrawSelMargin();
	}
	QueueIdleWork(WorkItems::updateUI);
}

void Editor::SetEmptySelection(Sci::Position currentPos_) {
	SetEmptySelection(SelectionPosition(currentPos_));
}

void Editor::SetSelectionFromSerialized(const char *serialized) {
	if (serialized) {
		sel = Selection(serialized);
		sel.Truncate(pdoc->Length());
		SetRectangularRange();
		InvalidateStyleRedraw();
	}
}

void Editor::MultipleSelectAdd(AddNumber addNumber) {
	if (SelectionEmpty() || !multipleSelection) {
		// Select word at caret
		const Sci::Position startWord = pdoc->ExtendWordSelect(sel.MainCaret(), -1, true);
		const Sci::Position endWord = pdoc->ExtendWordSelect(startWord, 1, true);
		TrimAndSetSelection(endWord, startWord);

	} else {

		if (!pdoc->HasCaseFolder())
			pdoc->SetCaseFolder(CaseFolderForEncoding());

		const Range rangeMainSelection(sel.RangeMain().Start().Position(), sel.RangeMain().End().Position());
		const std::string selectedText = RangeText(rangeMainSelection.start, rangeMainSelection.end);

		const Range rangeTarget(targetRange.start.Position(), targetRange.end.Position());
		std::vector<Range> searchRanges;
		// Search should be over the target range excluding the current selection so
		// may need to search 2 ranges, after the selection then before the selection.
		if (rangeTarget.Overlaps(rangeMainSelection)) {
			// Common case is that the selection is completely within the target but
			// may also have overlap at start or end.
			if (rangeMainSelection.end < rangeTarget.end)
				searchRanges.emplace_back(rangeMainSelection.end, rangeTarget.end);
			if (rangeTarget.start < rangeMainSelection.start)
				searchRanges.emplace_back(rangeTarget.start, rangeMainSelection.start);
		} else {
			// No overlap
			searchRanges.push_back(rangeTarget);
		}

		for (const Range range : searchRanges) {
			Sci::Position searchStart = range.start;
			const Sci::Position searchEnd = range.end;
			for (;;) {
				Sci::Position lengthFound = selectedText.length();
				const Sci::Position pos = pdoc->FindText(searchStart, searchEnd,
					selectedText.c_str(), searchFlags, &lengthFound);
				if (pos >= 0) {
					sel.AddSelection(SelectionRange(pos + lengthFound, pos));
					ContainerNeedsUpdate(Update::Selection);
					ScrollRange(sel.RangeMain());
					Redraw();
					if (addNumber == AddNumber::one)
						return;
					searchStart = pos + lengthFound;
				} else {
					break;
				}
			}
		}
	}
}

bool Editor::RangeContainsProtected(Sci::Position start, Sci::Position end) const noexcept {
	if (vs.ProtectionActive()) {
		if (start > end) {
			std::swap(start, end);
		}
		//Au: allow to delete etc protected text (style "hidden" or "readonly"). But don't allow to delete part of it.
		//	Also the program (a Find tool etc) should never select or replace text inside protected. Users probably can't select.
		if(end > start) {
			if(vs.styles[pdoc->StyleIndexAt(start)].IsProtected())
				return vs.styles[pdoc->StyleIndexAt(start - 1)].IsProtected()
				|| (vs.styles[pdoc->StyleIndexAt(end - 1)].IsProtected() && vs.styles[pdoc->StyleIndexAt(end)].IsProtected());
			if(vs.styles[pdoc->StyleIndexAt(end - 1)].IsProtected())
				return vs.styles[pdoc->StyleIndexAt(end)].IsProtected();
		}

		//for (Sci::Position pos = start; pos < end; pos++) {
		//	if (vs.styles[pdoc->StyleIndexAt(pos)].IsProtected())
		//		return true;
		//}
	}
	return false;
}

bool Editor::RangeContainsProtected(const SelectionRange &range) const noexcept {
	return RangeContainsProtected(range.Start().Position(), range.End().Position());
}

bool Editor::SelectionContainsProtected() const noexcept {
	for (size_t r=0; r<sel.Count(); r++) {
		if (RangeContainsProtected(sel.Range(r))) {
			return true;
		}
	}
	return false;
}

/**
 * Asks document to find a good position and then moves out of any invisible positions.
 */
Sci::Position Editor::MovePositionOutsideChar(Sci::Position pos, Sci::Position moveDir, bool checkLineEnd) const {
	return MovePositionOutsideChar(SelectionPosition(pos), moveDir, checkLineEnd).Position();
}

SelectionPosition Editor::MovePositionOutsideChar(SelectionPosition pos, Sci::Position moveDir, bool checkLineEnd) const {
	const Sci::Position posMoved = pdoc->MovePositionOutsideChar(pos.Position(), moveDir, checkLineEnd);
	if (posMoved != pos.Position())
		pos.SetPosition(posMoved);
	if (vs.ProtectionActive()) {
		if (moveDir > 0) {
			if ((pos.Position() > 0) && vs.styles[pdoc->StyleIndexAt(pos.Position() - 1)].IsProtected()) {
				while ((pos.Position() < pdoc->Length()) &&
				        (vs.styles[pdoc->StyleIndexAt(pos.Position())].IsProtected()))
					pos.Add(1);
			}
		} else if (moveDir < 0) {
			if (vs.styles[pdoc->StyleIndexAt(pos.Position())].IsProtected()) {
				while ((pos.Position() > 0) &&
				        (vs.styles[pdoc->StyleIndexAt(pos.Position() - 1)].IsProtected()))
					pos.Add(-1);
			}
		}
	}
	return pos;
}

void Editor::MovedCaret(SelectionPosition newPos, SelectionPosition previousPos,
	bool ensureVisible, CaretPolicies policies) {
	const Sci::Line currentLine = pdoc->SciLineFromPosition(newPos.Position());
	if (ensureVisible) {
		// In case in need of wrapping to ensure DisplayFromDoc works.
		if (currentLine >= wrapPending.start) {
			if (WrapLines(WrapScope::wsAll)) {
				Redraw();
			}
		}
		const XYScrollPosition newXY = XYScrollToMakeVisible(
			SelectionRange(posDrag.IsValid() ? posDrag : newPos), XYScrollOptions::all, policies);
		if (previousPos.IsValid() && (newXY.xOffset == xOffset)) {
			// simple vertical scroll then invalidate
			ScrollTo(newXY.topLine);
			InvalidateSelection(SelectionRange(previousPos), true);
		} else {
			SetXYScroll(newXY);
		}
	}

	ShowCaretAtCurrentPosition();
	NotifyCaretMove();

	ClaimSelection();
	SetHoverIndicatorPosition(sel.MainCaret());
	QueueIdleWork(WorkItems::updateUI);

	if (marginView.highlightDelimiter.NeedsDrawing(currentLine)) {
		RedrawSelMargin();
	}
}

void Editor::MovePositionTo(SelectionPosition newPos, Selection::SelTypes selt, bool ensureVisible) {
	const SelectionPosition spCaret = ((sel.Count() == 1) && sel.Empty()) ?
		sel.Last() : SelectionPosition(Sci::invalidPosition);

	const Sci::Position delta = newPos.Position() - sel.MainCaret();
	newPos = ClampPositionIntoDocument(newPos);
	newPos = MovePositionOutsideChar(newPos, delta);
	if (!multipleSelection && sel.IsRectangular() && (selt == Selection::SelTypes::stream)) {
		// Can't turn into multiple selection so clear additional selections
		InvalidateSelection(SelectionRange(newPos), true);
		sel.DropAdditionalRanges();
	}
	if (!sel.IsRectangular() && (selt == Selection::SelTypes::rectangle)) {
		// Switching to rectangular
		InvalidateSelection(sel.RangeMain(), false);
		SelectionRange rangeMain = sel.RangeMain();
		sel.Clear();
		sel.Rectangular() = rangeMain;
	}
	if (selt != Selection::SelTypes::none) {
		sel.selType = selt;
	}
	if (selt != Selection::SelTypes::none || sel.MoveExtends()) {
		SetSelection(newPos);
	} else {
		SetEmptySelection(newPos);
	}

	MovedCaret(newPos, spCaret, ensureVisible, caretPolicies);
}

void Editor::MovePositionTo(Sci::Position newPos, Selection::SelTypes selt, bool ensureVisible) {
	MovePositionTo(SelectionPosition(newPos), selt, ensureVisible);
}

SelectionPosition Editor::MovePositionSoVisible(SelectionPosition pos, int moveDir) {
	pos = ClampPositionIntoDocument(pos);
	pos = MovePositionOutsideChar(pos, moveDir);
	const Sci::Line lineDoc = pdoc->SciLineFromPosition(pos.Position());
	if (pcs->GetVisible(lineDoc)) {
		return pos;
	}
	Sci::Line lineDisplay = pcs->DisplayFromDoc(lineDoc);
	if (moveDir > 0) {
		// lineDisplay is already line before fold as lines in fold use display line of line after fold
		lineDisplay = std::clamp<Sci::Line>(lineDisplay, 0, pcs->LinesDisplayed());
		return SelectionPosition(
			pdoc->LineStart(pcs->DocFromDisplay(lineDisplay)));
	} else {
		lineDisplay = std::clamp<Sci::Line>(lineDisplay - 1, 0, pcs->LinesDisplayed());
		return SelectionPosition(
			pdoc->LineEnd(pcs->DocFromDisplay(lineDisplay)));
	}
}

SelectionPosition Editor::MovePositionSoVisible(Sci::Position pos, int moveDir) {
	return MovePositionSoVisible(SelectionPosition(pos), moveDir);
}

Point Editor::PointMainCaret() {
	return LocationFromPosition(sel.RangeMain().caret);
}

/**
 * Choose the x position that the caret will try to stick to
 * as it moves up and down.
 */
void Editor::SetLastXChosen() {
	const Point pt = PointMainCaret();
	lastXChosen = static_cast<int>(pt.x) + xOffset;
}

void Editor::RememberSelectionForUndo(int index) {
	EnsureModelState();
	if (modelState) {
		modelState->RememberSelectionForUndo(index, sel);
		needRedoRemembered = true;
		// Remember selection at end of processing current message
	}
}

void Editor::RememberSelectionOntoStack(int index) {
	EnsureModelState();
	if (modelState) {
		// Is undo currently inside a group?
		if (!pdoc->AfterUndoSequenceStart()) {
			// Don't remember selections inside a grouped sequence as can only
			// unto or redo to the start and end of the group.
			modelState->RememberSelectionOntoStack(index, topLine);
		}
	}
}

void Editor::RememberCurrentSelectionForRedoOntoStack() {
	if (needRedoRemembered && (pdoc->UndoSequenceDepth() == 0)) {
		EnsureModelState();
		if (modelState) {
			modelState->RememberSelectionForRedoOntoStack(pdoc->UndoCurrent(), sel, topLine);
			needRedoRemembered = false;
		}
	}
}

void Editor::ScrollTo(Sci::Line line, bool moveThumb) {
	const Sci::Line topLineNew = std::clamp<Sci::Line>(line, 0, MaxScrollPos());
	if (topLineNew != topLine) {
		// Try to optimise small scrolls
#ifndef UNDER_CE
		const Sci::Line linesToMove = topLine - topLineNew;
		const bool performBlit = (std::abs(linesToMove) <= 10) && (paintState == PaintState::notPainting);
		willRedrawAll = !performBlit;
#endif
		SetTopLine(topLineNew);
		// Optimize by styling the view as this will invalidate any needed area
		// which could abort the initial paint if discovered later.
		StyleAreaBounded(GetClientRectangle(), true);
#ifndef UNDER_CE
		// Perform redraw rather than scroll if many lines would be redrawn anyway.
		if (performBlit) {
			ScrollText(linesToMove);
		} else {
			Redraw();
		}
		willRedrawAll = false;
#else
		Redraw();
#endif
		if (moveThumb) {
			SetVerticalScrollPos();
		}
	}
}

void Editor::ScrollText(Sci::Line /* linesToMove */) {
	//Platform::DebugPrintf("Editor::ScrollText %d\n", linesToMove);
	Redraw();
}

void Editor::HorizontalScrollTo(int xPos) {
	//Platform::DebugPrintf("HorizontalScroll %d\n", xPos);
	if (xPos < 0)
		xPos = 0;
	if (!Wrapping() && (xOffset != xPos)) {
		xOffset = xPos;
		ContainerNeedsUpdate(Update::HScroll);
		SetHorizontalScrollPos();
		RedrawRect(GetClientRectangle());
	}
}

void Editor::VerticalCentreCaret() {
	const Sci::Line lineDoc =
		pdoc->SciLineFromPosition(sel.IsRectangular() ? sel.Rectangular().caret.Position() : sel.MainCaret());
	const Sci::Line lineDisplay = pcs->DisplayFromDoc(lineDoc);
	const Sci::Line newTop = lineDisplay - (LinesOnScreen() / 2);
	if (topLine != newTop) {
		SetTopLine(newTop > 0 ? newTop : 0);
		SetVerticalScrollPos();
		RedrawRect(GetClientRectangle());
	}
}

void Editor::MoveSelectedLines(int lineDelta) {

	if (sel.IsRectangular()) {
		// Convert to stream selection
		const SelectionRange rangeRectangular = sel.Rectangular();
		sel.Clear();
		sel.SetSelection(rangeRectangular);
	}

	// if selection doesn't start at the beginning of the line, set the new start
	Sci::Position selectionStart = SelectionStart().Position();
	const Sci::Line startLine = pdoc->SciLineFromPosition(selectionStart);
	const Sci::Position beginningOfStartLine = pdoc->LineStart(startLine);
	selectionStart = beginningOfStartLine;

	// if selection doesn't end at the beginning of a line greater than that of the start,
	// then set it at the beginning of the next one
	Sci::Position selectionEnd = SelectionEnd().Position();
	Sci::Line endLine = pdoc->SciLineFromPosition(selectionEnd);
	const Sci::Position beginningOfEndLine = pdoc->LineStart(endLine);
	bool appendEol = false;
	if (selectionEnd > beginningOfEndLine
		|| selectionStart == selectionEnd) {
		selectionEnd = pdoc->LineStart(endLine + 1);
		appendEol = (selectionEnd == pdoc->Length() && pdoc->SciLineFromPosition(selectionEnd) == endLine);
		endLine = pdoc->SciLineFromPosition(selectionEnd);
	}

	// if there's nowhere for the selection to move
	// (i.e. at the beginning going up or at the end going down),
	// stop it right there!
	const bool docEndLineEmpty = pdoc->LineStart(endLine) == pdoc->Length();
	if ((selectionStart == 0 && lineDelta < 0)
		|| (selectionEnd == pdoc->Length() && lineDelta > 0
			&& !docEndLineEmpty) // allow moving when end line of document is empty
		|| ((selectionStart == selectionEnd)
			&& !(lineDelta < 0 && docEndLineEmpty && selectionEnd == pdoc->Length()))) { // allow moving-up last empty line
		return;
	}

	UndoGroup ug(pdoc);

	if (lineDelta > 0 && selectionEnd == pdoc->LineStart(pdoc->LinesTotal() - 1)) {
		SetSelection(pdoc->MovePositionOutsideChar(selectionEnd - 1, -1), selectionEnd);
		ClearSelection();
		selectionEnd = CurrentPosition();
	}
	SetSelection(selectionStart, selectionEnd);

	const std::string selectedText = RangeText(selectionStart, selectionEnd);

	const Point currentLocation = LocationFromPosition(CurrentPosition());
	const Sci::Line currentLine = LineFromLocation(currentLocation);

	if (appendEol)
		SetSelection(pdoc->MovePositionOutsideChar(selectionStart - 1, -1), selectionEnd);
	ClearSelection();

	const std::string_view eol = pdoc->EOLString();
	if (currentLine + lineDelta >= pdoc->LinesTotal())
		pdoc->InsertString(pdoc->Length(), eol);
	GoToLine(currentLine + lineDelta);

	Sci::Position selectionLength = pdoc->InsertString(CurrentPosition(), selectedText);
	if (appendEol) {
		const Sci::Position lengthInserted = pdoc->InsertString(CurrentPosition() + selectionLength, eol);
		selectionLength += lengthInserted;
	}
	SetSelection(CurrentPosition(), CurrentPosition() + selectionLength);
}

void Editor::MoveSelectedLinesUp() {
	MoveSelectedLines(-1);
}

void Editor::MoveSelectedLinesDown() {
	MoveSelectedLines(1);
}

void Editor::MoveCaretInsideView(bool ensureVisible) {
	const PRectangle rcClient = GetTextRectangle();
	const Point pt = PointMainCaret();
	if (pt.y < rcClient.top) {
		MovePositionTo(SPositionFromLocation(
		            Point::FromInts(lastXChosen - xOffset, static_cast<int>(rcClient.top)),
					false, false, UserVirtualSpace()),
					Selection::SelTypes::none, ensureVisible);
	} else if ((pt.y + vs.lineHeight - 1) > rcClient.bottom) {
		const ptrdiff_t yOfLastLineFullyDisplayed = static_cast<ptrdiff_t>(rcClient.top) + ((LinesOnScreen() - 1) * vs.lineHeight);
		MovePositionTo(SPositionFromLocation(
		            Point::FromInts(lastXChosen - xOffset, static_cast<int>(rcClient.top + static_cast<XYPOSITION>(yOfLastLineFullyDisplayed))),
					false, false, UserVirtualSpace()),
		        Selection::SelTypes::none, ensureVisible);
	}
}

Sci::Line Editor::DisplayFromPosition(Sci::Position pos) {
	AutoSurface surface(this);
	return view.DisplayFromPosition(surface, *this, pos, vs);
}

/**
 * Ensure the caret is reasonably visible in context.
 *
Caret policy in Scintilla

If slop is set, we can define a slop value.
This value defines an unwanted zone (UZ) where the caret is... unwanted.
This zone is defined as a number of pixels near the vertical margins,
and as a number of lines near the horizontal margins.
By keeping the caret away from the edges, it is seen within its context,
so it is likely that the identifier that the caret is on can be completely seen,
and that the current line is seen with some of the lines following it which are
often dependent on that line.

If strict is set, the policy is enforced... strictly.
The caret is centred on the display if slop is not set,
and cannot go in the UZ if slop is set.

If jumps is set, the display is moved more energetically
so the caret can move in the same direction longer before the policy is applied again.
'3UZ' notation is used to indicate three time the size of the UZ as a distance to the margin.

If even is not set, instead of having symmetrical UZs,
the left and bottom UZs are extended up to right and top UZs respectively.
This way, we favour the displaying of useful information: the beginning of lines,
where most code reside, and the lines after the caret, eg. the body of a function.

     |        |       |      |                                            |
slop | strict | jumps | even | Caret can go to the margin                 | When reaching limit (caret going out of
     |        |       |      |                                            | visibility or going into the UZ) display is...
-----+--------+-------+------+--------------------------------------------+--------------------------------------------------------------
  0  |   0    |   0   |   0  | Yes                                        | moved to put caret on top/on right
  0  |   0    |   0   |   1  | Yes                                        | moved by one position
  0  |   0    |   1   |   0  | Yes                                        | moved to put caret on top/on right
  0  |   0    |   1   |   1  | Yes                                        | centred on the caret
  0  |   1    |   -   |   0  | Caret is always on top/on right of display | -
  0  |   1    |   -   |   1  | No, caret is always centred                | -
  1  |   0    |   0   |   0  | Yes                                        | moved to put caret out of the asymmetrical UZ
  1  |   0    |   0   |   1  | Yes                                        | moved to put caret out of the UZ
  1  |   0    |   1   |   0  | Yes                                        | moved to put caret at 3UZ of the top or right margin
  1  |   0    |   1   |   1  | Yes                                        | moved to put caret at 3UZ of the margin
  1  |   1    |   -   |   0  | Caret is always at UZ of top/right margin  | -
  1  |   1    |   0   |   1  | No, kept out of UZ                         | moved by one position
  1  |   1    |   1   |   1  | No, kept out of UZ                         | moved to put caret at 3UZ of the margin
*/

Editor::XYScrollPosition Editor::XYScrollToMakeVisible(const SelectionRange &range,
	const XYScrollOptions options, CaretPolicies policies) {
	const PRectangle rcClient = GetTextRectangle();
	const Point ptOrigin = GetVisibleOriginInMain();
	const Point pt = LocationFromPosition(range.caret) + ptOrigin;
	const Point ptAnchor = LocationFromPosition(range.anchor) + ptOrigin;
	const Point ptBottomCaret(pt.x, pt.y + vs.lineHeight - 1);

	XYScrollPosition newXY(xOffset, topLine);
	if (rcClient.Empty()) {
		return newXY;
	}

	// Vertical positioning
	if (FlagSet(options, XYScrollOptions::vertical) &&
		(pt.y < rcClient.top || ptBottomCaret.y >= rcClient.bottom || FlagSet(policies.y.policy, CaretPolicy::Strict))) {
		const Sci::Line lineCaret = DisplayFromPosition(range.caret.Position());
		const Sci::Line linesOnScreen = LinesOnScreen();
		const Sci::Line halfScreen = std::max(linesOnScreen - 1, static_cast<Sci::Line>(2)) / 2;
		const bool bSlop = FlagSet(policies.y.policy, CaretPolicy::Slop);
		const bool bStrict = FlagSet(policies.y.policy, CaretPolicy::Strict);
		const bool bJump = FlagSet(policies.y.policy, CaretPolicy::Jumps);
		const bool bEven = FlagSet(policies.y.policy, CaretPolicy::Even);

		// It should be possible to scroll the window to show the caret,
		// but this fails to remove the caret on GTK+
		if (bSlop) {	// A margin is defined
			Sci::Line yMoveT = 0;
			Sci::Line yMoveB = 0;
			if (bStrict) {
				Sci::Line yMarginT = 0;
				Sci::Line yMarginB = 0;
				if (!FlagSet(options, XYScrollOptions::useMargin)) {
					// In drag mode, avoid moves
					// otherwise, a double click will select several lines.
					yMarginT = yMarginB = 0;
				} else {
					// yMarginT must equal to caretYSlop, with a minimum of 1 and
					// a maximum of slightly less than half the height of the text area.
					yMarginT = std::clamp<Sci::Line>(policies.y.slop, 1, halfScreen);
					if (bEven) {
						yMarginB = yMarginT;
					} else {
						yMarginB = linesOnScreen - yMarginT - 1;
					}
				}
				yMoveT = yMarginT;
				if (bEven) {
					if (bJump) {
						yMoveT = std::clamp<Sci::Line>(policies.y.slop * 3, 1, halfScreen);
					}
					yMoveB = yMoveT;
				} else {
					yMoveB = linesOnScreen - yMoveT - 1;
				}
				if (lineCaret < topLine + yMarginT) {
					// Caret goes too high
					newXY.topLine = lineCaret - yMoveT;
				} else if (lineCaret > topLine + linesOnScreen - 1 - yMarginB) {
					// Caret goes too low
					newXY.topLine = lineCaret - linesOnScreen + 1 + yMoveB;
				}
			} else {	// Not strict
				yMoveT = bJump ? policies.y.slop * 3 : policies.y.slop;
				yMoveT = std::clamp<Sci::Line>(yMoveT, 1, halfScreen);
				if (bEven) {
					yMoveB = yMoveT;
				} else {
					yMoveB = linesOnScreen - yMoveT - 1;
				}
				if (lineCaret < topLine) {
					// Caret goes too high
					newXY.topLine = lineCaret - yMoveT;
				} else if (lineCaret > topLine + linesOnScreen - 1) {
					// Caret goes too low
					newXY.topLine = lineCaret - linesOnScreen + 1 + yMoveB;
				}
			}
		} else {	// No slop
			if (!bStrict && !bJump) {
				// Minimal move
				if (lineCaret < topLine) {
					// Caret goes too high
					newXY.topLine = lineCaret;
				} else if (lineCaret > topLine + linesOnScreen - 1) {
					// Caret goes too low
					if (bEven) {
						newXY.topLine = lineCaret - linesOnScreen + 1;
					} else {
						newXY.topLine = lineCaret;
					}
				}
			} else {	// Strict or going out of display
				if (bEven) {
					// Always centre caret
					newXY.topLine = lineCaret - halfScreen;
				} else {
					// Always put caret on top of display
					newXY.topLine = lineCaret;
				}
			}
		}
		if (!(range.caret == range.anchor)) {
			const Sci::Line lineAnchor = DisplayFromPosition(range.anchor.Position());
			if (lineAnchor < lineCaret) {
				// Shift up to show anchor or as much of range as possible
				newXY.topLine = std::min(newXY.topLine, lineAnchor);
				newXY.topLine = std::max(newXY.topLine, lineCaret - LinesOnScreen());
			} else {
				// Shift down to show anchor or as much of range as possible
				newXY.topLine = std::max(newXY.topLine, lineAnchor - LinesOnScreen());
				newXY.topLine = std::min(newXY.topLine, lineCaret);
			}
		}
		newXY.topLine = std::clamp<Sci::Line>(newXY.topLine, 0, MaxScrollPos());
	}

	// Horizontal positioning
	if (FlagSet(options, XYScrollOptions::horizontal) && !Wrapping()) {
		const int halfScreen = std::max(static_cast<int>(rcClient.Width()) - 4, 4) / 2;
		const bool bSlop = FlagSet(policies.x.policy, CaretPolicy::Slop);
		const bool bStrict = FlagSet(policies.x.policy, CaretPolicy::Strict);
		const bool bJump = FlagSet(policies.x.policy, CaretPolicy::Jumps);
		const bool bEven = FlagSet(policies.x.policy, CaretPolicy::Even);

		if (bSlop) {	// A margin is defined
			int xMoveL = 0;
			int xMoveR = 0;
			if (bStrict) {
				int xMarginL = 0;
				int xMarginR = 0;
				if (!FlagSet(options, XYScrollOptions::useMargin)) {
					// In drag mode, avoid moves unless very near of the margin
					// otherwise, a simple click will select text.
					xMarginL = xMarginR = 2;
				} else {
					// xMargin must equal to caretXSlop, with a minimum of 2 and
					// a maximum of slightly less than half the width of the text area.
					xMarginR = std::clamp(policies.x.slop, 2, halfScreen);
					if (bEven) {
						xMarginL = xMarginR;
					} else {
						xMarginL = static_cast<int>(rcClient.Width()) - xMarginR - 4;
					}
				}
				if (bJump && bEven) {
					// Jump is used only in even mode
					xMoveL = xMoveR = std::clamp(policies.x.slop * 3, 1, halfScreen);
				} else {
					xMoveL = xMoveR = 0;	// Not used, avoid a warning
				}
				if (pt.x < rcClient.left + xMarginL) {
					// Caret is on the left of the display
					if (bJump && bEven) {
						newXY.xOffset -= xMoveL;
					} else {
						// Move just enough to allow to display the caret
						newXY.xOffset -= static_cast<int>((rcClient.left + xMarginL) - pt.x);
					}
				} else if (pt.x >= rcClient.right - xMarginR) {
					// Caret is on the right of the display
					if (bJump && bEven) {
						newXY.xOffset += xMoveR;
					} else {
						// Move just enough to allow to display the caret
						newXY.xOffset += static_cast<int>(pt.x - (rcClient.right - xMarginR) + 1);
					}
				}
			} else {	// Not strict
				xMoveR = bJump ? policies.x.slop * 3 : policies.x.slop;
				xMoveR = std::clamp(xMoveR, 1, halfScreen);
				if (bEven) {
					xMoveL = xMoveR;
				} else {
					xMoveL = static_cast<int>(rcClient.Width()) - xMoveR - 4;
				}
				if (pt.x < rcClient.left) {
					// Caret is on the left of the display
					newXY.xOffset -= xMoveL;
				} else if (pt.x >= rcClient.right) {
					// Caret is on the right of the display
					newXY.xOffset += xMoveR;
				}
			}
		} else {	// No slop
			if (bStrict ||
			        (bJump && (pt.x < rcClient.left || pt.x >= rcClient.right))) {
				// Strict or going out of display
				if (bEven) {
					// Centre caret
					newXY.xOffset += static_cast<int>(pt.x - rcClient.left - halfScreen);
				} else {
					// Put caret on right
					newXY.xOffset += static_cast<int>(pt.x - rcClient.right + 1);
				}
			} else {
				// Move just enough to allow to display the caret
				if (pt.x < rcClient.left) {
					// Caret is on the left of the display
					if (bEven) {
						newXY.xOffset -= static_cast<int>(rcClient.left - pt.x);
					} else {
						newXY.xOffset += static_cast<int>(pt.x - rcClient.right) + 1;
					}
				} else if (pt.x >= rcClient.right) {
					// Caret is on the right of the display
					newXY.xOffset += static_cast<int>(pt.x - rcClient.right) + 1;
				}
			}
		}
		// In case of a jump (find result) largely out of display, adjust the offset to display the caret
		if (pt.x + xOffset < rcClient.left + newXY.xOffset) {
			newXY.xOffset = static_cast<int>(pt.x + xOffset - rcClient.left) - 2;
		} else if (pt.x + xOffset >= rcClient.right + newXY.xOffset) {
			newXY.xOffset = static_cast<int>(pt.x + xOffset - rcClient.right) + 2;
			if (vs.IsBlockCaretStyle() || view.imeCaretBlockOverride) {
				// Ensure we can see a good portion of the block caret
				newXY.xOffset += static_cast<int>(vs.aveCharWidth);
			}
		}
		if (!(range.caret == range.anchor)) {
			if (ptAnchor.x < pt.x) {
				// Shift to left to show anchor or as much of range as possible
				const int maxOffset = static_cast<int>(ptAnchor.x + xOffset - rcClient.left) - 1;
				const int minOffset = static_cast<int>(pt.x + xOffset - rcClient.right) + 1;
				newXY.xOffset = std::min(newXY.xOffset, maxOffset);
				newXY.xOffset = std::max(newXY.xOffset, minOffset);
			} else {
				// Shift to right to show anchor or as much of range as possible
				const int minOffset = static_cast<int>(ptAnchor.x + xOffset - rcClient.right) + 1;
				const int maxOffset = static_cast<int>(pt.x + xOffset - rcClient.left) - 1;
				newXY.xOffset = std::max(newXY.xOffset, minOffset);
				newXY.xOffset = std::min(newXY.xOffset, maxOffset);
			}
		}
		if (newXY.xOffset < 0) {
			newXY.xOffset = 0;
		}
	}

	return newXY;
}

void Editor::SetXYScroll(XYScrollPosition newXY) {
	if ((newXY.topLine != topLine) || (newXY.xOffset != xOffset)) {
		if (newXY.topLine != topLine) {
			SetTopLine(newXY.topLine);
			SetVerticalScrollPos();
		}
		if (newXY.xOffset != xOffset) {
			xOffset = newXY.xOffset;
			ContainerNeedsUpdate(Update::HScroll);
			if (newXY.xOffset > 0) {
				const PRectangle rcText = GetTextRectangle();
				if (horizontalScrollBarVisible &&
					rcText.Width() + xOffset > scrollWidth) {
					scrollWidth = xOffset + static_cast<int>(rcText.Width());
					SetScrollBars();
				}
			}
			SetHorizontalScrollPos();
		}
		Redraw();
		UpdateSystemCaret();
	}
}

void Editor::ScrollRange(SelectionRange range) {
	SetXYScroll(XYScrollToMakeVisible(range, XYScrollOptions::all, caretPolicies));
}

void Editor::EnsureCaretVisible(bool useMargin, bool vert, bool horiz) {
	SetXYScroll(XYScrollToMakeVisible(SelectionRange(posDrag.IsValid() ? posDrag : sel.RangeMain().caret),
		(useMargin?XYScrollOptions::useMargin:XYScrollOptions::none)|
		(vert?XYScrollOptions::vertical:XYScrollOptions::none)|
		(horiz?XYScrollOptions::horizontal:XYScrollOptions::none),
		caretPolicies));
}

void Editor::ShowCaretAtCurrentPosition() {
	if (hasFocus) {
		caret.active = true;
		caret.on = true;
		FineTickerCancel(TickReason::caret);
		if (caret.period > 0)
			FineTickerStart(TickReason::caret, caret.period, caret.period/10);
	} else {
		caret.active = false;
		caret.on = false;
		FineTickerCancel(TickReason::caret);
	}
	InvalidateCaret();
}

void Editor::DropCaret() {
	caret.active = false;
	FineTickerCancel(TickReason::caret);
	InvalidateCaret();
}

void Editor::CaretSetPeriod(int period) {
	if (caret.period != period) {
		caret.period = period;
		caret.on = true;
		FineTickerCancel(TickReason::caret);
		if ((caret.active) && (caret.period > 0))
			FineTickerStart(TickReason::caret, caret.period, caret.period/10);
		InvalidateCaret();
	}
}

void Editor::InvalidateCaret() {
	if (posDrag.IsValid()) {
		InvalidateRange(posDrag.Position(), posDrag.Position() + 1);
	} else {
		for (size_t r=0; r<sel.Count(); r++) {
			InvalidateRange(sel.Range(r).caret.Position(), sel.Range(r).caret.Position() + 1);
		}
	}
	UpdateSystemCaret();
}

void Editor::NotifyCaretMove() {
}

void Editor::UpdateSystemCaret() {
}

bool Editor::Wrapping() const noexcept {
	return vs.wrap.state != Wrap::None;
}

void Editor::NeedWrapping(Sci::Line docLineStart, Sci::Line docLineEnd) {
//Platform::DebugPrintf("\nNeedWrapping: %0d..%0d\n", docLineStart, docLineEnd);
	if (wrapPending.AddRange(docLineStart, docLineEnd)) {
		view.llc.Invalidate(LineLayout::ValidLevel::positions);
	}
	// Wrap lines during idle.
	if (Wrapping() && wrapPending.NeedsWrap()) {
		SetIdle(true);
	}
}

bool Editor::WrapOneLine(Surface *surface, Sci::Line lineToWrap) {
	std::shared_ptr<LineLayout> ll = view.RetrieveLineLayout(lineToWrap, *this);
	int linesWrapped = 1;
	if (ll) {
		view.LayoutLine(*this, surface, vs, ll.get(), wrapWidth);
		linesWrapped = ll->lines;
	}
	if (vs.annotationVisible != AnnotationVisible::Hidden) {
		linesWrapped += pdoc->AnnotationLines(lineToWrap);
	}
	return pcs->SetHeight(lineToWrap, linesWrapped);
}

namespace {

// Lines less than lengthToMultiThread are laid out in blocks in parallel.
// Longer lines are multi-threaded inside LayoutLine.
// This allows faster processing when lines differ greatly in length and thus time to lay out.
constexpr Sci::Position lengthToMultiThread = 4000;

}

bool Editor::WrapBlock(Surface *surface, Sci::Line lineToWrap, Sci::Line lineToWrapEnd) {

	const size_t linesBeingWrapped = static_cast<size_t>(lineToWrapEnd - lineToWrap);

	std::vector<int> linesAfterWrap(linesBeingWrapped);

	size_t threads = std::min<size_t>(linesBeingWrapped, view.maxLayoutThreads);
	if (!surface->SupportsFeature(Supports::ThreadSafeMeasureWidths)) {
		threads = 1;
	}

	const bool multiThreaded = threads > 1;

	ElapsedPeriod epWrapping;

	// Wrap all the short lines in multiple threads

	// If only 1 thread needed then use the main thread, else spin up multiple
	const std::launch policy = multiThreaded ? std::launch::async : std::launch::deferred;

	std::atomic<size_t> nextIndex = 0;

	// Lines that are less likely to be re-examined should not be read from or written to the cache.
	const SignificantLines significantLines {
		pdoc->SciLineFromPosition(sel.MainCaret()),
		pcs->DocFromDisplay(topLine),
		LinesOnScreen() + 1,
		view.llc.GetLevel(),
	};

	// Protect the line layout cache from being accessed from multiple threads simultaneously
	std::mutex mutexRetrieve;

	std::vector<std::future<void>> futures;
	for (size_t th = 0; th < threads; th++) {
		std::future<void> fut = std::async(policy,
			[=, &surface, &nextIndex, &linesAfterWrap, &mutexRetrieve]() {
			// llTemporary is reused for non-significant lines, avoiding allocation costs.
			std::shared_ptr<LineLayout> llTemporary = std::make_shared<LineLayout>(-1, 200);
			while (true) {
				const size_t i = nextIndex.fetch_add(1, std::memory_order_acq_rel);
				if (i >= linesBeingWrapped) {
					break;
				}
				const Sci::Line lineNumber = lineToWrap + i;
				const Range rangeLine = pdoc->LineRange(lineNumber);
				const Sci::Position lengthLine = rangeLine.Length();
				if (lengthLine < lengthToMultiThread) {
					std::shared_ptr<LineLayout> ll;
					if (significantLines.LineMayCache(lineNumber)) {
						std::lock_guard<std::mutex> guard(mutexRetrieve);
						ll = view.RetrieveLineLayout(lineNumber, *this);
					} else {
						ll = llTemporary;
						ll->ReSet(lineNumber, lengthLine);
					}
					view.LayoutLine(*this, surface, vs, ll.get(), wrapWidth, multiThreaded);
					linesAfterWrap[i] = ll->lines;
				}
			}
		});
		futures.push_back(std::move(fut));
	}
	for (const std::future<void> &f : futures) {
		f.wait();
	}
	// End of multiple threads

	// Multiply duration by number of threads to produce (near) equivalence to duration if single threaded
	const double durationShortLines = epWrapping.Duration(true);
	const double durationShortLinesThreads = durationShortLines * static_cast<double>(threads);

	// Wrap all the long lines in the main thread.
	// LayoutLine may then multi-thread over segments in each line.

	std::shared_ptr<LineLayout> llLarge = std::make_shared<LineLayout>(-1, 200);
	for (size_t indexLarge = 0; indexLarge < linesBeingWrapped; indexLarge++) {
		const Sci::Line lineNumber = lineToWrap + indexLarge;
		const Range rangeLine = pdoc->LineRange(lineNumber);
		const Sci::Position lengthLine = rangeLine.Length();
		if (lengthLine >= lengthToMultiThread) {
			std::shared_ptr<LineLayout> ll;
			if (significantLines.LineMayCache(lineNumber)) {
				ll = view.RetrieveLineLayout(lineNumber, *this);
			} else {
				ll = llLarge;
				ll->ReSet(lineNumber, lengthLine);
			}
			view.LayoutLine(*this, surface, vs, ll.get(), wrapWidth);
			linesAfterWrap[indexLarge] = ll->lines;
		}
	}

	const double durationLongLines = epWrapping.Duration();
	const size_t bytesBeingWrapped = pdoc->LineStart(lineToWrap + linesBeingWrapped) - pdoc->LineStart(lineToWrap);

	size_t wrapsDone = 0;

	for (size_t i = 0; i < linesBeingWrapped; i++) {
		const Sci::Line lineNumber = lineToWrap + i;
		int linesWrapped = linesAfterWrap[i];
		if (vs.annotationVisible != AnnotationVisible::Hidden) {
			linesWrapped += pdoc->AnnotationLines(lineNumber);
		}
		if (pcs->SetHeight(lineNumber, linesWrapped)) {
			wrapsDone++;
		}
		wrapPending.Wrapped(lineNumber);
	}

	durationWrapOneByte.AddSample(bytesBeingWrapped, durationShortLinesThreads + durationLongLines);

	return wrapsDone > 0;
}

// Perform  wrapping for a subset of the lines needing wrapping.
// wsAll: wrap all lines which need wrapping in this single call
// wsVisible: wrap currently visible lines
// wsIdle: wrap one page + 100 lines
// Return true if wrapping occurred.
bool Editor::WrapLines(WrapScope ws) {
	Sci::Line goodTopLine = topLine;
	bool wrapOccurred = false;
	if (!Wrapping()) {
		if (wrapWidth != LineLayout::wrapWidthInfinite) {
			wrapWidth = LineLayout::wrapWidthInfinite;
			for (Sci::Line lineDoc = 0; lineDoc < pdoc->LinesTotal(); lineDoc++) {
				int linesWrapped = 1;
				if (vs.annotationVisible != AnnotationVisible::Hidden) {
					linesWrapped += pdoc->AnnotationLines(lineDoc);
				}
				pcs->SetHeight(lineDoc, linesWrapped);
			}
			wrapOccurred = true;
		}
		wrapPending.Reset();

	} else if (wrapPending.NeedsWrap()) {
		wrapPending.start = std::min(wrapPending.start, pdoc->LinesTotal());
		if (!SetIdle(true)) {
			// Idle processing not supported so full wrap required.
			ws = WrapScope::wsAll;
		}
		// Decide where to start wrapping
		Sci::Line lineToWrap = wrapPending.start;
		Sci::Line lineToWrapEnd = std::min(wrapPending.end, pdoc->LinesTotal());

		const Sci::Line lineDocTop = pcs->DocFromDisplay(topLine);
		LineDocSub lineScrollTo;
		if (scrollToAfterWrap) {
			lineScrollTo = scrollToAfterWrap.value();
		} else {
			const Sci::Line subLineTop = topLine - pcs->DisplayFromDoc(lineDocTop);
			lineScrollTo = { lineDocTop, subLineTop };
		}
		if (ws == WrapScope::wsVisible) {
			lineToWrap = std::clamp(lineDocTop-5, wrapPending.start, pdoc->LinesTotal());
			// Priority wrap to just after visible area.
			// Since wrapping could reduce display lines, treat each
			// as taking only one display line.
			lineToWrapEnd = lineDocTop;
			Sci::Line lines = LinesOnScreen() + 1;
			constexpr double secondsAllowed = 0.1;
			const size_t actionsInAllowedTime = std::clamp<Sci::Line>(
				durationWrapOneByte.ActionsInAllowedTime(secondsAllowed),
				0x2000, 0x200000);
			const Sci::Line lineLast = pdoc->LineFromPositionAfter(lineToWrap, actionsInAllowedTime);
			const Sci::Line maxLine = std::min(lineLast, pcs->LinesInDoc());
			while ((lineToWrapEnd < maxLine) && (lines>0)) {
				if (pcs->GetVisible(lineToWrapEnd))
					lines--;
				lineToWrapEnd++;
			}
			// .. and if the paint window is outside pending wraps
			if ((lineToWrap > wrapPending.end) || (lineToWrapEnd < wrapPending.start)) {
				// Currently visible text does not need wrapping
				return false;
			}
		} else if (ws == WrapScope::wsIdle) {
			// Try to keep time taken by wrapping reasonable so interaction remains smooth.
			constexpr double secondsAllowed = 0.01;
			const size_t actionsInAllowedTime = std::clamp<Sci::Line>(
				durationWrapOneByte.ActionsInAllowedTime(secondsAllowed),
				0x200, 0x20000);
			lineToWrapEnd = pdoc->LineFromPositionAfter(lineToWrap, actionsInAllowedTime);
		}
		const Sci::Line lineEndNeedWrap = std::min(wrapPending.end, pdoc->LinesTotal());
		lineToWrapEnd = std::min(lineToWrapEnd, lineEndNeedWrap);

		// Ensure all lines being wrapped are styled.
		pdoc->EnsureStyledTo(pdoc->LineStart(lineToWrapEnd));

		if (lineToWrap < lineToWrapEnd) {

			PRectangle rcTextArea = GetClientRectangle();
			rcTextArea.left = static_cast<XYPOSITION>(vs.textStart);
			rcTextArea.right -= vs.rightMarginWidth;
			wrapWidth = static_cast<int>(rcTextArea.Width());
			RefreshStyleData();
			AutoSurface surface(this);
			if (surface) {
//Platform::DebugPrintf("Wraplines: scope=%0d need=%0d..%0d perform=%0d..%0d\n", ws, wrapPending.start, wrapPending.end, lineToWrap, lineToWrapEnd);

				wrapOccurred = WrapBlock(surface, lineToWrap, lineToWrapEnd);

				goodTopLine = pcs->DisplayFromDocSub(lineScrollTo.lineDoc, lineScrollTo.subLine);
			}
		}

		// If wrapping is done, bring it to resting position
		if (wrapPending.start >= lineEndNeedWrap) {
			wrapPending.Reset();
			scrollToAfterWrap.reset();
		}
	}

	if (wrapOccurred) {
		insideWrapScroll = true;
		SetScrollBars();
		SetTopLine(std::clamp<Sci::Line>(goodTopLine, 0, MaxScrollPos()));
		SetVerticalScrollPos();
		insideWrapScroll = false;
	}

	return wrapOccurred;
}

void Editor::LinesJoin() {
	if (!RangeContainsProtected(targetRange.start.Position(), targetRange.end.Position())) {
		UndoGroup ug(pdoc);
		const Sci::Line line = pdoc->SciLineFromPosition(targetRange.start.Position());
		for (Sci::Position pos = pdoc->LineEnd(line); pos < targetRange.end.Position(); pos = pdoc->LineEnd(line)) {
			const char chPrev = pdoc->CharAt(pos - 1);
			const Sci::Position widthChar = pdoc->LenChar(pos);
			targetRange.end.Add(-widthChar);
			pdoc->DeleteChars(pos, widthChar);
			if (chPrev != ' ') {
				// Ensure at least one space separating previous lines
				const Sci::Position lengthInserted = pdoc->InsertString(pos, " ", 1);
				targetRange.end.Add(lengthInserted);
			}
		}
	}
}

void Editor::LinesSplit(int pixelWidth) {
	if (!RangeContainsProtected(targetRange.start.Position(), targetRange.end.Position())) {
		if (pixelWidth == 0) {
			const PRectangle rcText = GetTextRectangle();
			pixelWidth = static_cast<int>(rcText.Width());
		}
		const Sci::Line lineStart = pdoc->SciLineFromPosition(targetRange.start.Position());
		Sci::Line lineEnd = pdoc->SciLineFromPosition(targetRange.end.Position());
		const std::string_view eol = pdoc->EOLString();
		UndoGroup ug(pdoc);
		for (Sci::Line line = lineStart; line <= lineEnd; line++) {
			AutoSurface surface(this);
			std::shared_ptr<LineLayout> ll = view.RetrieveLineLayout(line, *this);
			if (surface && ll) {
				const Sci::Position posLineStart = pdoc->LineStart(line);
				view.LayoutLine(*this, surface, vs, ll.get(), pixelWidth);
				Sci::Position lengthInsertedTotal = 0;
				for (int subLine = 1; subLine < ll->lines; subLine++) {
					const Sci::Position lengthInserted = pdoc->InsertString(
						posLineStart + lengthInsertedTotal + ll->LineStart(subLine), eol);
					targetRange.end.Add(lengthInserted);
					lengthInsertedTotal += lengthInserted;
				}
			}
			lineEnd = pdoc->SciLineFromPosition(targetRange.end.Position());
		}
	}
}

void Editor::PaintSelMargin(Surface *surfaceWindow, const PRectangle &rc) {
	if (vs.fixedColumnWidth == 0)
		return;

	RefreshStyleData();
	RefreshPixMaps(surfaceWindow);

	// On GTK+ with Ubuntu overlay scroll bars, the surface may have been finished
	// at this point. The Initialised call checks for this case and sets the status
	// to be bad which avoids crashes in following calls.
	if (!surfaceWindow->Initialised()) {
		return;
	}

	PRectangle rcMargin = GetClientRectangle();
	const Point ptOrigin = GetVisibleOriginInMain();
	rcMargin.Move(0, -ptOrigin.y);
	rcMargin.left = 0;
	rcMargin.right = static_cast<XYPOSITION>(vs.fixedColumnWidth);

	if (!rc.Intersects(rcMargin))
		return;

	Surface *surface;
	if (view.bufferedDraw) {
		surface = marginView.pixmapSelMargin.get();
	} else {
		surface = surfaceWindow;
	}
	surface->SetMode(CurrentSurfaceMode());

	// Clip vertically to paint area to avoid drawing line numbers
	if (rcMargin.bottom > rc.bottom)
		rcMargin.bottom = rc.bottom;
	if (rcMargin.top < rc.top)
		rcMargin.top = rc.top;

	marginView.PaintMargin(surface, topLine, rc, rcMargin, *this, vs);

	if (view.bufferedDraw) {
		marginView.pixmapSelMargin->FlushDrawing();
		surfaceWindow->Copy(rcMargin, Point(rcMargin.left, rcMargin.top), *marginView.pixmapSelMargin);
	}
}

void Editor::RefreshPixMaps(Surface *surfaceWindow) {
	view.RefreshPixMaps(surfaceWindow, vs);
	marginView.RefreshPixMaps(surfaceWindow, vs);
	if (view.bufferedDraw && !(view.pixmapLine && marginView.pixmapSelMargin)) {
		const PRectangle rcClient = GetClientRectangle();
		view.pixmapLine = surfaceWindow->AllocatePixMap(static_cast<int>(rcClient.Width()), vs.lineHeight);
		marginView.pixmapSelMargin = surfaceWindow->AllocatePixMap(vs.fixedColumnWidth,
			static_cast<int>(rcClient.Height()));
	}
}

void Editor::Paint(Surface *surfaceWindow, PRectangle rcArea) {
	redrawPendingText = false;
	redrawPendingMargin = false;

	//Platform::DebugPrintf("Paint:%1d (%3d,%3d) ... (%3d,%3d)\n",
	//	paintingAllText, rcArea.left, rcArea.top, rcArea.right, rcArea.bottom);

	RefreshStyleData();
	if (paintState == PaintState::abandoned)
		return;	// Scroll bars may have changed so need redraw

	paintAbandonedByStyling = false;

	StyleAreaBounded(rcArea, false);

	const PRectangle rcClient = GetClientRectangle();
	//Platform::DebugPrintf("Client: (%3d,%3d) ... (%3d,%3d)   %d\n",
	//	rcClient.left, rcClient.top, rcClient.right, rcClient.bottom);

	if (NotifyUpdateUI()) {
		RefreshStyleData();
	}

	// Wrap the visible lines if needed.
	if (WrapLines(WrapScope::wsVisible)) {
		// The wrapping process has changed the height of some lines so
		// abandon this paint for a complete repaint.
		if (AbandonPaint()) {
			return;
		}
	}

	RefreshPixMaps(surfaceWindow);

	if (!marginView.pixmapSelPattern->Initialised()) {
		// When Direct2D is used, pixmap creation may fail with D2DERR_RECREATE_TARGET so
		// abandon this paint to avoid further failures.
		// Main drawing surface and pixmaps should be recreated by next paint.
		return;
	}

	if (!view.bufferedDraw)
		surfaceWindow->SetClip(rcArea);

	if (paintState != PaintState::abandoned) {
		if (vs.marginInside) {
			PaintSelMargin(surfaceWindow, rcArea);
			PRectangle rcRightMargin = rcClient;
			rcRightMargin.left = rcRightMargin.right - vs.rightMarginWidth;
			if (rcArea.Intersects(rcRightMargin)) {
				surfaceWindow->FillRectangle(rcRightMargin, vs.styles[StyleDefault].back);
			}
		} else { // Else separate view so separate paint event but leftMargin included to allow overlap
			PRectangle rcLeftMargin = rcArea;
			rcLeftMargin.left = 0;
			rcLeftMargin.right = rcLeftMargin.left + vs.leftMarginWidth;
			if (rcArea.Intersects(rcLeftMargin)) {
				surfaceWindow->FillRectangle(rcLeftMargin, vs.styles[StyleDefault].back);
			}
		}
	}

	if (paintState == PaintState::abandoned) {
		// Either styling or NotifyUpdateUI noticed that painting is needed
		// outside the current painting rectangle
		//Platform::DebugPrintf("Abandoning paint\n");
		if (Wrapping()) {
			if (paintAbandonedByStyling) {
				// Styling has spilled over a line end, such as occurs by starting a multiline
				// comment. The width of subsequent text may have changed, so rewrap.
				NeedWrapping(pcs->DocFromDisplay(topLine));
			}
		}
		if (!view.bufferedDraw)
			surfaceWindow->PopClip();
		return;
	}

	view.PaintText(surfaceWindow, *this, vs, rcArea, rcClient);

	if (horizontalScrollBarVisible && trackLineWidth && (view.lineWidthMaxSeen > scrollWidth)) {
		scrollWidth = view.lineWidthMaxSeen;
		if (!FineTickerRunning(TickReason::widen)) {
			FineTickerStart(TickReason::widen, 50, 5);
		}
	}

	if (!view.bufferedDraw)
		surfaceWindow->PopClip();

	NotifyPainted();
}

// This is mostly copied from the Paint method but with some things omitted
// such as the margin markers, line numbers, selection and caret
// Should be merged back into a combined Draw method.
Sci::Position Editor::FormatRange(Scintilla::Message iMessage, Scintilla::uptr_t wParam, Scintilla::sptr_t lParam) {
	if (!lParam)
		return 0;
	const bool draw = wParam != 0;
	void *ptr = PtrFromSPtr(lParam);
	if (iMessage == Message::FormatRange) {
		RangeToFormat *pfr = static_cast<RangeToFormat *>(ptr);
		const CharacterRangeFull chrg{ pfr->chrg.cpMin, pfr->chrg.cpMax };
		AutoSurface surface(pfr->hdc, this, Technology::Default);
		AutoSurface surfaceMeasure(pfr->hdcTarget, this, Technology::Default);
		if (!surface || !surfaceMeasure) {
			return 0;
		}
		return view.FormatRange(draw, chrg, pfr->rc, surface, surfaceMeasure, *this, vs);
	} else {
		// FormatRangeFull
		RangeToFormatFull *pfr = static_cast<RangeToFormatFull *>(ptr);
		AutoSurface surface(pfr->hdc, this, Technology::Default);
		AutoSurface surfaceMeasure(pfr->hdcTarget, this, Technology::Default);
		if (!surface || !surfaceMeasure) {
			return 0;
		}
		return view.FormatRange(draw, pfr->chrg, pfr->rc, surface, surfaceMeasure, *this, vs);
	}
}

long Editor::TextWidth(uptr_t style, const char *text) {
	RefreshStyleData();
	AutoSurface surface(this);
	if (surface) {
		return std::lround(surface->WidthText(vs.styles[style].font.get(), text));
	}
	return 1;
}

void Editor::SetVerticalScrollPos() {
	if (!insideWrapScroll) {
		scrollToAfterWrap.reset();
	}
}

// Empty method is overridden on GTK+ to show / hide scrollbars
void Editor::ReconfigureScrollBars() {}

void Editor::ChangeScrollBars() {
	RefreshStyleData();

	const Sci::Line nMax = MaxScrollPos();
	const Sci::Line nPage = LinesOnScreen();
	const bool modified = ModifyScrollBars(nMax + nPage - 1, nPage);
	if (modified) {
		DwellEnd(true);
	}

	// TODO: ensure always showing as many lines as possible
	// May not be, if, for example, window made larger
	if (topLine > MaxScrollPos()) {
		SetTopLine(std::clamp<Sci::Line>(topLine, 0, MaxScrollPos()));
		SetVerticalScrollPos();
		Redraw();
	}
	if (modified) {
		if (!AbandonPaint())
			Redraw();
	}
	//Platform::DebugPrintf("end max = %d page = %d\n", nMax, nPage);
}

void Editor::SetScrollBars() {
	// Overridden on GTK to defer to idle
	ChangeScrollBars();
}

void Editor::ChangeSize() {
	DropGraphics();
	SetScrollBars();
	if (Wrapping()) {
		PRectangle rcTextArea = GetClientRectangle();
		rcTextArea.left = static_cast<XYPOSITION>(vs.textStart);
		rcTextArea.right -= vs.rightMarginWidth;
		if (wrapWidth != rcTextArea.Width()) {
			NeedWrapping();
			Redraw();
		}
	}
}

Sci::Position Editor::RealizeVirtualSpace(Sci::Position position, Sci::Position virtualSpace) {
	if (virtualSpace > 0) {
		const Sci::Line line = pdoc->SciLineFromPosition(position);
		const Sci::Position indent = pdoc->GetLineIndentPosition(line);
		if (indent == position) {
			return pdoc->SetLineIndentation(line, pdoc->GetLineIndentation(line) + virtualSpace);
		}
		const std::string spaceText(virtualSpace, ' ');
		const Sci::Position lengthInserted = pdoc->InsertString(position, spaceText);
		position += lengthInserted;
	}
	return position;
}

SelectionPosition Editor::RealizeVirtualSpace(const SelectionPosition &position) {
	// Return the new position with no virtual space
	return SelectionPosition(RealizeVirtualSpace(position.Position(), position.VirtualSpace()));
}

void Editor::AddChar(char ch) {
	const char s[1] {ch};
	InsertCharacter(std::string_view(s, 1), CharacterSource::DirectInput);
}

void Editor::FilterSelections() {
	if (!additionalSelectionTyping && (sel.Count() > 1)) {
		InvalidateWholeSelection();
		sel.DropAdditionalRanges();
	}
}

// InsertCharacter inserts a character encoded in document code page.
void Editor::InsertCharacter(std::string_view sv, CharacterSource charSource) {
	if (sv.empty()) {
		return;
	}

	//Au: Fix scintilla bug where it makes 2 undo actions when you overtype selection. First step.
	bool wasSelection = !sel.Empty(); if(wasSelection) pdoc->BeginUndoAction();

	FilterSelections();
	bool wrapOccurred = false;
	{
		UndoGroup ug(pdoc, (sel.Count() > 1) || !sel.Empty() || inOverstrike);

		// Vector elements point into selection in order to change selection.
		std::vector<SelectionRange *> selPtrs;
		for (size_t r = 0; r < sel.Count(); r++) {
			selPtrs.push_back(&sel.Range(r));
		}
		// Order selections by position in document.
		std::sort(selPtrs.begin(), selPtrs.end(),
			[](const SelectionRange *a, const SelectionRange *b) noexcept {return *a < *b;});

		// Loop in reverse to avoid disturbing positions of selections yet to be processed.
		for (std::vector<SelectionRange *>::reverse_iterator rit = selPtrs.rbegin();
			rit != selPtrs.rend(); ++rit) {
			SelectionRange *currentSel = *rit;
			if (!RangeContainsProtected(*currentSel)) {
				Sci::Position positionInsert = currentSel->Start().Position();
				if (!currentSel->Empty()) {
					ClearSelectionRange(*currentSel);
				} else if (inOverstrike) {
					if (positionInsert < pdoc->Length()) {
						if (!pdoc->IsPositionInLineEnd(positionInsert)) {
							pdoc->DelChar(positionInsert);
							currentSel->ClearVirtualSpace();
						}
					}
				}
				positionInsert = RealizeVirtualSpace(positionInsert, currentSel->caret.VirtualSpace());
				const Sci::Position lengthInserted = pdoc->InsertString(positionInsert, sv);
				if (lengthInserted > 0) {
					*currentSel = SelectionRange(positionInsert + lengthInserted);
				}
				currentSel->ClearVirtualSpace();
				// If in wrap mode rewrap current line so EnsureCaretVisible has accurate information
				if (Wrapping()) {
					AutoSurface surface(this);
					if (surface) {
						if (WrapOneLine(surface, pdoc->SciLineFromPosition(positionInsert))) {
							wrapOccurred = true;
						}
					}
				}
			}
		}
		ThinRectangularRange();
	}

	if(wasSelection) pdoc->SetUndoCollection(true); //Au: Second step of the bug fix. Resets BeginUndoAction without starting new action.
	//This also could be fixed outside scintilla: on WM_CHAR call SCI_BEGINUNDOACTION before CallWindowProc and SCI_SETUNDOCOLLECTION after.
	//	But doing it in scintilla is faster and probably more reliable.

	if (wrapOccurred) {
		SetScrollBars();
		SetVerticalScrollPos();
		Redraw();
	}
	// If in wrap mode rewrap current line so EnsureCaretVisible has accurate information
	EnsureCaretVisible();
	// Avoid blinking during rapid typing:
	ShowCaretAtCurrentPosition();
	if ((caretSticky == CaretSticky::Off) ||
		((caretSticky == CaretSticky::WhiteSpace) && !IsAllSpacesOrTabs(sv))) {
		SetLastXChosen();
	}

	int ch = static_cast<unsigned char>(sv[0]);
	if (pdoc->dbcsCodePage != CpUtf8) {
		if (sv.length() > 1) {
			// DBCS code page or DBCS font character set.
			ch = (ch << 8) | static_cast<unsigned char>(sv[1]);
		}
	} else {
		if ((ch < 0xC0) || (1 == sv.length())) {
			// Handles UTF-8 characters between 0x01 and 0x7F and single byte
			// characters when not in UTF-8 mode.
			// Also treats \0 and naked trail bytes 0x80 to 0xBF as valid
			// characters representing themselves.
		} else {
			unsigned int utf32[1] = { 0 };
			UTF32FromUTF8(sv, utf32, std::size(utf32));
			ch = utf32[0];
		}
	}
	NotifyChar(ch, charSource);

	if (recordingMacro && charSource != CharacterSource::TentativeInput) {
		std::string copy(sv); // ensure NUL-terminated
		NotifyMacroRecord(Message::ReplaceSel, 0, reinterpret_cast<sptr_t>(copy.data()));
	}
}

void Editor::ClearSelectionRange(SelectionRange &range) {
	if (!range.Empty()) {
		if (range.Length()) {
			pdoc->DeleteChars(range.Start().Position(), range.Length());
			range.ClearVirtualSpace();
		} else {
			// Range is all virtual so collapse to start of virtual space
			range.MinimizeVirtualSpace();
		}
	}
}

void Editor::ClearBeforeTentativeStart() {
	// Make positions for the first composition string.
	FilterSelections();
	UndoGroup ug(pdoc, (sel.Count() > 1) || !sel.Empty() || inOverstrike);
	for (size_t r = 0; r<sel.Count(); r++) {
		if (!RangeContainsProtected(sel.Range(r))) {
			ClearSelectionRange(sel.Range(r));
			RealizeVirtualSpace(sel.Range(r).caret.Position(), sel.Range(r).caret.VirtualSpace());
			sel.Range(r).ClearVirtualSpace();
		}
	}
}

void Editor::InsertPaste(const char *text, Sci::Position len) {
	if (multiPasteMode == MultiPaste::Once) {
		SelectionPosition selStart = sel.Start();
		selStart = RealizeVirtualSpace(selStart);
		const Sci::Position lengthInserted = pdoc->InsertString(selStart.Position(), text, len);
		if (lengthInserted > 0) {
			SetEmptySelection(selStart.Position() + lengthInserted);
		}
	} else {
		// MultiPaste::Each
		for (size_t r=0; r<sel.Count(); r++) {
			if (!RangeContainsProtected(sel.Range(r))) {
				Sci::Position positionInsert = sel.Range(r).Start().Position();
				ClearSelectionRange(sel.Range(r));
				positionInsert = RealizeVirtualSpace(positionInsert, sel.Range(r).caret.VirtualSpace());
				const Sci::Position lengthInserted = pdoc->InsertString(positionInsert, text, len);
				if (lengthInserted > 0) {
					sel.Range(r) = SelectionRange(positionInsert + lengthInserted);
				}
				sel.Range(r).ClearVirtualSpace();
			}
		}
	}
}

void Editor::InsertPasteShape(const char *text, Sci::Position len, PasteShape shape) {
	std::string convertedText;
	if (convertPastes) {
		// Convert line endings of the paste into our local line-endings mode
		convertedText = Document::TransformLineEnds(text, len, pdoc->eolMode);
		len = convertedText.length();
		text = convertedText.c_str();
	}
	if (shape == PasteShape::rectangular) {
		PasteRectangular(sel.Start(), text, len);
	} else {
		if (shape == PasteShape::line) {
			const Sci::Position insertPos = pdoc->LineStartPosition(sel.MainCaret());
			Sci::Position lengthInserted = pdoc->InsertString(insertPos, text, len);
			// add the newline if necessary
			if ((len > 0) && (text[len - 1] != '\n' && text[len - 1] != '\r')) {
				const std::string_view endline = pdoc->EOLString();
				lengthInserted += pdoc->InsertString(insertPos + lengthInserted, endline);
			}
			if (sel.MainCaret() == insertPos) {
				SetEmptySelection(sel.MainCaret() + lengthInserted);
			}
		} else {
			InsertPaste(text, len);
		}
	}
}

void Editor::ClearSelection(bool retainMultipleSelections) {
	if (!sel.IsRectangular() && !retainMultipleSelections)
		FilterSelections();
	UndoGroup ug(pdoc);
	for (size_t r=0; r<sel.Count(); r++) {
		if (!sel.Range(r).Empty()) {
			if (!RangeContainsProtected(sel.Range(r))) {
				pdoc->DeleteChars(sel.Range(r).Start().Position(),
					sel.Range(r).Length());
				sel.Range(r) = SelectionRange(sel.Range(r).Start());
			}
		}
	}
	ThinRectangularRange();
	sel.RemoveDuplicates();
	ClaimSelection();
	SetHoverIndicatorPosition(sel.MainCaret());
}

void Editor::ClearAll() {
	{
		UndoGroup ug(pdoc);
		if (0 != pdoc->Length()) {
			pdoc->DeleteChars(0, pdoc->Length());
		}
		if (!pdoc->IsReadOnly()) {
			pcs->Clear();
			pdoc->AnnotationClearAll();
			pdoc->EOLAnnotationClearAll();
			pdoc->MarginClearAll();
		}
	}

	view.ClearAllTabstops();

	sel.Clear();
	SetTopLine(0);
	SetVerticalScrollPos();
	InvalidateStyleRedraw();
}

void Editor::ClearDocumentStyle() {
	pdoc->decorations->DeleteLexerDecorations();
	pdoc->StartStyling(0);
	pdoc->SetStyleFor(pdoc->Length(), 0);
	pcs->ShowAll();
	SetAnnotationHeights(0, pdoc->LinesTotal());
	pdoc->ClearLevels();
}

void Editor::CopyAllowLine() {
	SelectionText selectedText;
	CopySelectionRange(&selectedText, true);
	CopyToClipboard(selectedText);
}

void Editor::CutAllowLine() {
	if (sel.Empty()) {
		pdoc->CheckReadOnly();
		if (!pdoc->IsReadOnly()) {
			SelectionText selectedText;
			if (CopyLineRange(&selectedText, false)) {
				CopyToClipboard(selectedText);
				LineDelete();
			}
		}
	} else {
		Cut();
	}
}

void Editor::Cut() {
	pdoc->CheckReadOnly();
	if (!pdoc->IsReadOnly() && !SelectionContainsProtected()) {
		Copy();
		ClearSelection();
	}
}

void Editor::PasteRectangular(SelectionPosition pos, const char *ptr, Sci::Position len) {
	if (pdoc->IsReadOnly() || SelectionContainsProtected()) {
		return;
	}
	sel.Clear();
	sel.RangeMain() = SelectionRange(pos);
	Sci::Line line = pdoc->SciLineFromPosition(sel.MainCaret());
	UndoGroup ug(pdoc);
	sel.RangeMain().caret = RealizeVirtualSpace(sel.RangeMain().caret);
	const int xInsert = XFromPosition(sel.RangeMain().caret);
	bool prevCr = false;
	while ((len > 0) && IsEOLCharacter(ptr[len-1]))
		len--;
	for (Sci::Position i = 0; i < len; i++) {
		if (IsEOLCharacter(ptr[i])) {
			if ((ptr[i] == '\r') || (!prevCr))
				line++;
			if (line >= pdoc->LinesTotal()) {
				const std::string_view eol = pdoc->EOLString();
				pdoc->InsertString(pdoc->LengthNoExcept(), eol);
			}
			// Pad the end of lines with spaces if required
			sel.RangeMain().caret.SetPosition(PositionFromLineX(line, xInsert));
			if ((XFromPosition(sel.RangeMain().caret) < xInsert) && (i + 1 < len)) {
				while (XFromPosition(sel.RangeMain().caret) < xInsert) {
					assert(pdoc);
					const Sci::Position lengthInserted = pdoc->InsertString(sel.MainCaret(), " ", 1);
					sel.RangeMain().caret.Add(lengthInserted);
				}
			}
			prevCr = ptr[i] == '\r';
		} else {
			const Sci::Position lengthInserted = pdoc->InsertString(sel.MainCaret(), ptr + i, 1);
			sel.RangeMain().caret.Add(lengthInserted);
			prevCr = false;
		}
	}
	SetEmptySelection(pos);
}

bool Editor::CanPaste() {
	return !pdoc->IsReadOnly() && !SelectionContainsProtected();
}

void Editor::Clear() {
	// If multiple selections, don't delete EOLS
	if (sel.Empty()) {
		bool singleVirtual = false;
		if ((sel.Count() == 1) &&
			!RangeContainsProtected(sel.MainCaret(), sel.MainCaret() + 1) &&
			sel.RangeMain().Start().VirtualSpace()) {
			singleVirtual = true;
		}
		UndoGroup ug(pdoc, (sel.Count() > 1) || singleVirtual);
		for (size_t r=0; r<sel.Count(); r++) {
			if (!RangeContainsProtected(sel.Range(r).caret.Position(), sel.Range(r).caret.Position() + 1)) {
				if (sel.Range(r).Start().VirtualSpace()) {
					if (sel.Range(r).anchor < sel.Range(r).caret)
						sel.Range(r) = SelectionRange(RealizeVirtualSpace(sel.Range(r).anchor.Position(), sel.Range(r).anchor.VirtualSpace()));
					else
						sel.Range(r) = SelectionRange(RealizeVirtualSpace(sel.Range(r).caret.Position(), sel.Range(r).caret.VirtualSpace()));
				}
				if ((sel.Count() == 1) || !pdoc->IsPositionInLineEnd(sel.Range(r).caret.Position())) {
					pdoc->DelChar(sel.Range(r).caret.Position());
					sel.Range(r).ClearVirtualSpace();
				}  // else multiple selection so don't eat line ends
			} else {
				sel.Range(r).ClearVirtualSpace();
			}
		}
	} else {
		ClearSelection();
	}
	sel.RemoveDuplicates();
	ShowCaretAtCurrentPosition();		// Avoid blinking
}

void Editor::SelectAll() {
	sel.Clear();
	SetSelection(0, pdoc->Length());
	Redraw();
}

void Editor::RestoreSelection(Sci::Position newPos, UndoRedo history) {
	EnsureModelState();
	if (FlagSet(undoSelectionHistoryOption, UndoSelectionHistoryOption::Enabled) && modelState) {
		// Undo wants the element after the current as it just undid it
		const int index = pdoc->UndoCurrent() + (history == UndoRedo::undo ? 1 : 0);
		const SelectionWithScroll selAndLine = modelState->SelectionFromStack(index, history);
		if (!selAndLine.selection.empty()) {
			if (FlagSet(undoSelectionHistoryOption, UndoSelectionHistoryOption::Scroll)) {
				ScrollTo(selAndLine.topLine);
			}
			sel = Selection(selAndLine.selection);
			if (sel.IsRectangular()) {
				const size_t mainForRectangular = sel.Main();
				// Reconstitute ranges from rectangular range
				SetRectangularRange();
				// Restore main if possible.
				if (mainForRectangular < sel.Count()) {
					sel.SetMain(mainForRectangular);
				}
			}
			newPos = -1; // Used selection from stack so don't use position returned from undo/redo.
			Redraw();
		}
	}
	if (newPos >= 0)
		SetEmptySelection(newPos);
	EnsureCaretVisible();
}

void Editor::Undo(/*Au*/ bool dontChangePos) {
	if (pdoc->CanUndo()) {
		InvalidateCaret();
		const Sci::Position newPos = pdoc->Undo();
		if (dontChangePos) return; //Au //also under `case Message::Undo:` was `SetLastXChosen();` (but somehow not under `case Message::Redo:`); it seems OK without it.
		RestoreSelection(newPos, UndoRedo::undo);
	}
}

void Editor::Redo(/*Au*/ bool dontChangePos) {
	if (pdoc->CanRedo()) {
		const Sci::Position newPos = pdoc->Redo();
		if (dontChangePos) return; //Au
		RestoreSelection(newPos, UndoRedo::redo);
	}
}

void Editor::DelCharBack(bool allowLineStartDeletion) {
	RefreshStyleData();
	if (!sel.IsRectangular())
		FilterSelections();
	if (sel.IsRectangular())
		allowLineStartDeletion = false;
	UndoGroup ug(pdoc, (sel.Count() > 1) || !sel.Empty());
	if (sel.Empty()) {
		for (size_t r=0; r<sel.Count(); r++) {
			if (!RangeContainsProtected(sel.Range(r).caret.Position() - 1, sel.Range(r).caret.Position())) {
				if (sel.Range(r).caret.VirtualSpace()) {
					sel.Range(r).caret.SetVirtualSpace(sel.Range(r).caret.VirtualSpace() - 1);
					sel.Range(r).anchor.SetVirtualSpace(sel.Range(r).caret.VirtualSpace());
				} else {
					const Sci::Line lineCurrentPos =
						pdoc->SciLineFromPosition(sel.Range(r).caret.Position());
					if (allowLineStartDeletion || (pdoc->LineStart(lineCurrentPos) != sel.Range(r).caret.Position())) {
						if (pdoc->GetColumn(sel.Range(r).caret.Position()) <= pdoc->GetLineIndentation(lineCurrentPos) &&
								pdoc->GetColumn(sel.Range(r).caret.Position()) > 0 && pdoc->backspaceUnindents) {
							UndoGroup ugInner(pdoc, !ug.Needed());
							const int indentation = pdoc->GetLineIndentation(lineCurrentPos);
							const int indentationStep = pdoc->IndentSize();
							int indentationChange = indentation % indentationStep;
							if (indentationChange == 0)
								indentationChange = indentationStep;
							const Sci::Position posSelect = pdoc->SetLineIndentation(lineCurrentPos, indentation - indentationChange);
							// SetEmptySelection
							sel.Range(r) = SelectionRange(posSelect);
						} else {
							pdoc->DelCharBack(sel.Range(r).caret.Position());
						}
					}
				}
			} else {
				sel.Range(r).ClearVirtualSpace();
			}
		}
		ThinRectangularRange();
	} else {
		ClearSelection();
	}
	sel.RemoveDuplicates();
	ContainerNeedsUpdate(Update::Selection);
	// Avoid blinking during rapid typing:
	ShowCaretAtCurrentPosition();
}

void Editor::NotifyFocus(bool focus) {
	NotificationData scn = {};
	scn.nmhdr.code = focus ? Notification::FocusIn : Notification::FocusOut;
	NotifyParent(scn);
}

void Editor::SetCtrlID(int identifier) {
	ctrlID = identifier;
}

void Editor::NotifyStyleToNeeded(Sci::Position endStyleNeeded) {
	NotificationData scn = {};
	scn.nmhdr.code = Notification::StyleNeeded;
	scn.position = endStyleNeeded;
	NotifyParent(scn);
}

void Editor::NotifyStyleNeeded(Document *, void *, Sci::Position endStyleNeeded) {
	NotifyStyleToNeeded(endStyleNeeded);
}

void Editor::NotifyErrorOccurred(Document *, void *, Status status) {
	errorStatus = status;
}

void Editor::NotifyGroupCompleted(Document *, void *) noexcept {
	// RememberCurrentSelectionForRedoOntoStack may throw (for memory exhaustion)
	// but this method may not as it is called in UndoGroup destructor so ignore
	// exception.
	try {
		RememberCurrentSelectionForRedoOntoStack();
	} catch (...) {
		// Ignore any exception
	}
}

void Editor::NotifyChar(int ch, CharacterSource charSource) {
	NotificationData scn = {};
	scn.nmhdr.code = Notification::CharAdded;
	scn.ch = ch;
	scn.characterSource = charSource;
	NotifyParent(scn);
}

void Editor::NotifySavePoint(bool isSavePoint) {
	NotificationData scn = {};
	if (isSavePoint) {
		scn.nmhdr.code = Notification::SavePointReached;
		if (changeHistoryOption != ChangeHistoryOption::Disabled) {
			Redraw();
		}
	} else {
		scn.nmhdr.code = Notification::SavePointLeft;
	}
	NotifyParent(scn);
}

void Editor::NotifyModifyAttempt() {
	NotificationData scn = {};
	scn.nmhdr.code = Notification::ModifyAttemptRO;
	NotifyParent(scn);
}

void Editor::NotifyDoubleClick(Point pt, KeyMod modifiers) {
	NotificationData scn = {};
	scn.nmhdr.code = Notification::DoubleClick;
	scn.line = LineFromLocation(pt);
	scn.position = PositionFromLocation(pt, true);
	scn.modifiers = modifiers;
	NotifyParent(scn);
}

void Editor::NotifyHotSpotDoubleClicked(Sci::Position position, KeyMod modifiers) {
	NotificationData scn = {};
	scn.nmhdr.code = Notification::HotSpotDoubleClick;
	scn.position = position;
	scn.modifiers = modifiers;
	NotifyParent(scn);
}

void Editor::NotifyHotSpotClicked(Sci::Position position, KeyMod modifiers) {
	NotificationData scn = {};
	scn.nmhdr.code = Notification::HotSpotClick;
	scn.position = position;
	scn.modifiers = modifiers;
	NotifyParent(scn);
}

void Editor::NotifyHotSpotReleaseClick(Sci::Position position, KeyMod modifiers) {
	NotificationData scn = {};
	scn.nmhdr.code = Notification::HotSpotReleaseClick;
	scn.position = position;
	scn.modifiers = modifiers;
	NotifyParent(scn);
}

bool Editor::NotifyUpdateUI() {
	if (needUpdateUI != Update::None) {
		NotificationData scn = {};
		scn.nmhdr.code = Notification::UpdateUI;
		scn.updated = needUpdateUI;
		NotifyParent(scn);
		needUpdateUI = Update::None;
		return true;
	}
	return false;
}

void Editor::NotifyPainted() {
	NotificationData scn = {};
	scn.nmhdr.code = Notification::Painted;
	NotifyParent(scn);
}

void Editor::NotifyIndicatorClick(bool click, Sci::Position position, KeyMod modifiers) {
	const int mask = pdoc->decorations->AllOnFor(position);
	if ((click && mask) || pdoc->decorations->ClickNotified()) {
		NotificationData scn = {};
		pdoc->decorations->SetClickNotified(click);
		scn.nmhdr.code = click ? Notification::IndicatorClick : Notification::IndicatorRelease;
		scn.modifiers = modifiers;
		scn.position = position;
		NotifyParent(scn);
	}
}

bool Editor::NotifyMarginClick(Point pt, KeyMod modifiers) {
	const int marginClicked = vs.MarginFromLocation(pt);
	if ((marginClicked >= 0) && vs.ms[marginClicked].sensitive) {
		const Sci::Position position = pdoc->LineStart(LineFromLocation(pt));
		if ((vs.ms[marginClicked].mask & MaskFolders) && (FlagSet(foldAutomatic, AutomaticFold::Click))) {
			const bool ctrl = FlagSet(modifiers, KeyMod::Ctrl);
			const bool shift = FlagSet(modifiers, KeyMod::Shift);
			const Sci::Line lineClick = pdoc->SciLineFromPosition(position);
			if (shift && ctrl) {
				FoldAll(FoldAction::Toggle);
			} else {
				const FoldLevel levelClick = pdoc->GetFoldLevel(lineClick);
				if (LevelIsHeader(levelClick)) {
					if (shift) {
						// Ensure all children visible
						FoldExpand(lineClick, FoldAction::Expand, levelClick);
					} else if (ctrl) {
						FoldExpand(lineClick, FoldAction::Toggle, levelClick);
					} else {
						// Toggle this line
						FoldLine(lineClick, FoldAction::Toggle);
					}
				}
			}
			return true;
		}
		NotificationData scn = {};
		scn.nmhdr.code = Notification::MarginClick;
		scn.modifiers = modifiers;
		scn.position = position;
		scn.margin = marginClicked;
		NotifyParent(scn);
		return true;
	}
	return false;
}

bool Editor::NotifyMarginRightClick(Point pt, KeyMod modifiers) {
	const int marginRightClicked = vs.MarginFromLocation(pt);
	if ((marginRightClicked >= 0) && vs.ms[marginRightClicked].sensitive) {
		const Sci::Position position = pdoc->LineStart(LineFromLocation(pt));
		NotificationData scn = {};
		scn.nmhdr.code = Notification::MarginRightClick;
		scn.modifiers = modifiers;
		scn.position = position;
		scn.margin = marginRightClicked;
		NotifyParent(scn);
		return true;
	}
	return false;
}

void Editor::NotifyNeedShown(Sci::Position pos, Sci::Position len) {
	NotificationData scn = {};
	scn.nmhdr.code = Notification::NeedShown;
	scn.position = pos;
	scn.length = len;
	NotifyParent(scn);
}

void Editor::NotifyDwelling(Point pt, bool state) {
	NotificationData scn = {};
	scn.nmhdr.code = state ? Notification::DwellStart : Notification::DwellEnd;
	scn.position = PositionFromLocation(pt, true);
	scn.x = static_cast<int>(pt.x + vs.ExternalMarginWidth());
	scn.y = static_cast<int>(pt.y);
	NotifyParent(scn);
}

void Editor::NotifyZoom() {
	NotificationData scn = {};
	scn.nmhdr.code = Notification::Zoom;
	NotifyParent(scn);
}

// Notifications from document
void Editor::NotifyModifyAttempt(Document *, void *) {
	//Platform::DebugPrintf("** Modify Attempt\n");
	NotifyModifyAttempt();
}

void Editor::NotifySavePoint(Document *, void *, bool atSavePoint) {
	//Platform::DebugPrintf("** Save Point %s\n", atSavePoint ? "On" : "Off");
	NotifySavePoint(atSavePoint);
}

void Editor::CheckModificationForWrap(DocModification mh) {
	if (FlagSet(mh.modificationType, ModificationFlags::InsertText | ModificationFlags::DeleteText)) {
		view.llc.Invalidate(LineLayout::ValidLevel::checkTextAndStyle);
		const Sci::Line lineDoc = pdoc->SciLineFromPosition(mh.position);
		const Sci::Line lines = std::max(static_cast<Sci::Line>(0), mh.linesAdded);
		if (Wrapping()) {
			// Check if this modification crosses any of the wrap points
			if (wrapPending.NeedsWrap()) {
				if (lineDoc < wrapPending.end) { // Inserted/deleted before or inside wrap range
					wrapPending.end += mh.linesAdded;
				}
			}
			NeedWrapping(lineDoc, lineDoc + lines + 1);
		}
		RefreshStyleData();
		// Fix up annotation heights
		SetAnnotationHeights(lineDoc, lineDoc + lines + 2);
	}
}

namespace {

// Move a position so it is still after the same character as before the insertion.
constexpr Sci::Position MovePositionForInsertion(Sci::Position position, Sci::Position startInsertion, Sci::Position length) noexcept {
	if (position > startInsertion) {
		return position + length;
	}
	return position;
}

// Move a position so it is still after the same character as before the deletion if that
// character is still present else after the previous surviving character.
constexpr Sci::Position MovePositionForDeletion(Sci::Position position, Sci::Position startDeletion, Sci::Position length) noexcept {
	if (position > startDeletion) {
		const Sci::Position endDeletion = startDeletion + length;
		if (position > endDeletion) {
			return position - length;
		}
		return startDeletion;
	}
	return position;
}

}

void Editor::NotifyModified(Document *, DocModification mh, void *) {
	ContainerNeedsUpdate(Update::Content);
	if (paintState == PaintState::painting) {
		CheckForChangeOutsidePaint(Range(mh.position, mh.position + mh.length));
	}
	if (FlagSet(mh.modificationType, ModificationFlags::ChangeLineState)) {
		if (paintState == PaintState::painting) {
			CheckForChangeOutsidePaint(
			    Range(pdoc->LineStart(mh.line),
					pdoc->LineStart(mh.line + 1)));
		} else {
			// Could check that change is before last visible line.
			Redraw();
		}
	}
	if (FlagSet(mh.modificationType, ModificationFlags::ChangeTabStops)) {
		Redraw();
	}
	if (FlagSet(mh.modificationType, ModificationFlags::LexerState)) {
		if (paintState == PaintState::painting) {
			CheckForChangeOutsidePaint(
			    Range(mh.position, mh.position + mh.length));
		} else {
			Redraw();
		}
	}
	if (FlagSet(mh.modificationType, ModificationFlags::ChangeStyle | ModificationFlags::ChangeIndicator)) {
		if (FlagSet(mh.modificationType, ModificationFlags::ChangeStyle)) {
			pdoc->IncrementStyleClock();
		}
		if (paintState == PaintState::notPainting) {
			const Sci::Line lineDocTop = pcs->DocFromDisplay(topLine);
			if (mh.position < pdoc->LineStart(lineDocTop)) {
				// Styling performed before this view
				Redraw();
			} else {
				InvalidateRange(mh.position, mh.position + mh.length);
			}
		}
		if (FlagSet(mh.modificationType, ModificationFlags::ChangeStyle)) {
			view.llc.Invalidate(LineLayout::ValidLevel::checkTextAndStyle);
		}
	} else {
		if (FlagSet(undoSelectionHistoryOption, UndoSelectionHistoryOption::Enabled) &&
			FlagSet(mh.modificationType, ModificationFlags::User)) {
			if (FlagSet(mh.modificationType, ModificationFlags::BeforeInsert | ModificationFlags::BeforeDelete)) {
				RememberSelectionForUndo(pdoc->UndoCurrent());
			}
			if (FlagSet(mh.modificationType, ModificationFlags::InsertText | ModificationFlags::DeleteText)) {
				RememberSelectionOntoStack(pdoc->UndoCurrent());
			}
		}
		// Move selection and brace highlights
		if (FlagSet(mh.modificationType, ModificationFlags::InsertText)) {
			sel.MovePositions(true, mh.position, mh.length);
			braces[0] = MovePositionForInsertion(braces[0], mh.position, mh.length);
			braces[1] = MovePositionForInsertion(braces[1], mh.position, mh.length);
		} else if (FlagSet(mh.modificationType, ModificationFlags::DeleteText)) {
			sel.MovePositions(false, mh.position, mh.length);
			braces[0] = MovePositionForDeletion(braces[0], mh.position, mh.length);
			braces[1] = MovePositionForDeletion(braces[1], mh.position, mh.length);
		}
		if (FlagSet(mh.modificationType, ModificationFlags::BeforeInsert | ModificationFlags::BeforeDelete) && pcs->HiddenLines()) {
			// Some lines are hidden so may need shown.
			const Sci::Line lineOfPos = pdoc->SciLineFromPosition(mh.position);
			Sci::Position endNeedShown = mh.position;
			if (FlagSet(mh.modificationType, ModificationFlags::BeforeInsert)) {
				if (pdoc->ContainsLineEnd(mh.text, mh.length) && (mh.position != pdoc->LineStart(lineOfPos)))
					endNeedShown = pdoc->LineStart(lineOfPos+1);
			} else {
				// If the deletion includes any EOL then we extend the need shown area.
				endNeedShown = mh.position + mh.length;
				Sci::Line lineLast = pdoc->SciLineFromPosition(mh.position+mh.length);
				for (Sci::Line line = lineOfPos + 1; line <= lineLast; line++) {
					const Sci::Line lineMaxSubord = pdoc->GetLastChild(line, {}, -1);
					if (lineLast < lineMaxSubord) {
						lineLast = lineMaxSubord;
						endNeedShown = pdoc->LineEnd(lineLast);
					}
				}
			}
			NeedShown(mh.position, endNeedShown - mh.position);
		}
		if (mh.linesAdded != 0) {
			// Update contraction state for inserted and removed lines
			// lineOfPos should be calculated in context of state before modification, shouldn't it
			Sci::Line lineOfPos = pdoc->SciLineFromPosition(mh.position);
			if (mh.position > pdoc->LineStart(lineOfPos))
				lineOfPos++;	// Affecting subsequent lines
			if (mh.linesAdded > 0) {
				pcs->InsertLines(lineOfPos, mh.linesAdded);
			} else {
				pcs->DeleteLines(lineOfPos, -mh.linesAdded);
			}
			view.LinesAddedOrRemoved(lineOfPos, mh.linesAdded);
		}
		if (FlagSet(mh.modificationType, ModificationFlags::ChangeAnnotation)) {
			const Sci::Line lineDoc = pdoc->SciLineFromPosition(mh.position);
			if (vs.annotationVisible != AnnotationVisible::Hidden) {
				if (pcs->SetHeight(lineDoc, pcs->GetHeight(lineDoc) + static_cast<int>(mh.annotationLinesAdded))) {
					SetScrollBars();
				}
				Redraw();
			}
		}
		if (FlagSet(mh.modificationType, ModificationFlags::ChangeEOLAnnotation)) {
			if (vs.eolAnnotationVisible != EOLAnnotationVisible::Hidden) {
				Redraw();
			}
		}
		CheckModificationForWrap(mh);
		if (mh.linesAdded != 0) {
			// Avoid scrolling of display if change before current display
			if (mh.position < posTopLine && !CanDeferToLastStep(mh)) {
				const Sci::Line newTop = std::clamp<Sci::Line>(topLine + mh.linesAdded, 0, MaxScrollPos());
				if (newTop != topLine) {
					SetTopLine(newTop);
					SetVerticalScrollPos();
				}
			}

			if (paintState == PaintState::notPainting && !CanDeferToLastStep(mh)) {
				if (SynchronousStylingToVisible()) {
					QueueIdleWork(WorkItems::style, pdoc->Length());
				}
				Redraw();
			}
		} else {
			if (paintState == PaintState::notPainting && mh.length && !CanEliminate(mh)) {
				if (SynchronousStylingToVisible()) {
					QueueIdleWork(WorkItems::style, mh.position + mh.length);
				}
				InvalidateRange(mh.position, mh.position + mh.length);
				if (FlagSet(changeHistoryOption, ChangeHistoryOption::Markers)) {
					RedrawSelMargin(pdoc->SciLineFromPosition(mh.position));
				}
			}
		}
	}

	if (mh.linesAdded != 0 && !CanDeferToLastStep(mh)) {
		SetScrollBars();
	}

	if (FlagSet(mh.modificationType, (ModificationFlags::ChangeMarker | ModificationFlags::ChangeMargin))) {
		if ((!willRedrawAll) && ((paintState == PaintState::notPainting) || !PaintContainsMargin())) {
			if (FlagSet(mh.modificationType, ModificationFlags::ChangeFold)) {
				// Fold changes can affect the drawing of following lines so redraw whole margin
				RedrawSelMargin(marginView.highlightDelimiter.isEnabled ? -1 : mh.line - 1, true);
			} else {
				RedrawSelMargin(mh.line);
			}
		}
	}
	if ((FlagSet(mh.modificationType, ModificationFlags::ChangeFold)) && (FlagSet(foldAutomatic, AutomaticFold::Change))) {
		FoldChanged(mh.line, mh.foldLevelNow, mh.foldLevelPrev);
	}

	// NOW pay the piper WRT "deferred" visual updates
	if (IsLastStep(mh)) {
		SetScrollBars();
		Redraw();
	}

	// If client wants to see this modification
	if (FlagSet(mh.modificationType, modEventMask)) {
		if (commandEvents) {
			if ((mh.modificationType & (ModificationFlags::ChangeStyle | ModificationFlags::ChangeIndicator)) == ModificationFlags::None) {
				// Real modification made to text of document.
				NotifyChange();	// Send EN_CHANGE
			}
		}

		NotificationData scn = {};
		scn.nmhdr.code = Notification::Modified;
		scn.position = mh.position;
		scn.modificationType = mh.modificationType;
		scn.text = mh.text;
		scn.length = mh.length;
		scn.linesAdded = mh.linesAdded;
		scn.line = mh.line;
		scn.foldLevelNow = mh.foldLevelNow;
		scn.foldLevelPrev = mh.foldLevelPrev;
		scn.token = static_cast<int>(mh.token);
		scn.annotationLinesAdded = mh.annotationLinesAdded;
		NotifyParent(scn);
	}
}

void Editor::NotifyDeleted(Document *, void *) noexcept {
	/* Do nothing */
}

void Editor::NotifyMacroRecord(Message iMessage, uptr_t wParam, sptr_t lParam) {

	// Enumerates all macroable messages
	switch (iMessage) {
	case Message::Cut:
	case Message::Copy:
	case Message::Paste:
	case Message::Clear:
	case Message::ReplaceSel:
	case Message::AddText:
	case Message::InsertText:
	case Message::AppendText:
	case Message::ClearAll:
	case Message::SelectAll:
	case Message::GotoLine:
	case Message::GotoPos:
	case Message::SearchAnchor:
	case Message::SearchNext:
	case Message::SearchPrev:
	case Message::LineDown:
	case Message::LineDownExtend:
	case Message::ParaDown:
	case Message::ParaDownExtend:
	case Message::LineUp:
	case Message::LineUpExtend:
	case Message::ParaUp:
	case Message::ParaUpExtend:
	case Message::CharLeft:
	case Message::CharLeftExtend:
	case Message::CharRight:
	case Message::CharRightExtend:
	case Message::WordLeft:
	case Message::WordLeftExtend:
	case Message::WordRight:
	case Message::WordRightExtend:
	case Message::WordPartLeft:
	case Message::WordPartLeftExtend:
	case Message::WordPartRight:
	case Message::WordPartRightExtend:
	case Message::WordLeftEnd:
	case Message::WordLeftEndExtend:
	case Message::WordRightEnd:
	case Message::WordRightEndExtend:
	case Message::Home:
	case Message::HomeExtend:
	case Message::LineEnd:
	case Message::LineEndExtend:
	case Message::HomeWrap:
	case Message::HomeWrapExtend:
	case Message::LineEndWrap:
	case Message::LineEndWrapExtend:
	case Message::DocumentStart:
	case Message::DocumentStartExtend:
	case Message::DocumentEnd:
	case Message::DocumentEndExtend:
	case Message::StutteredPageUp:
	case Message::StutteredPageUpExtend:
	case Message::StutteredPageDown:
	case Message::StutteredPageDownExtend:
	case Message::PageUp:
	case Message::PageUpExtend:
	case Message::PageDown:
	case Message::PageDownExtend:
	case Message::EditToggleOvertype:
	case Message::Cancel:
	case Message::DeleteBack:
	case Message::Tab:
	case Message::LineIndent:
	case Message::BackTab:
	case Message::LineDedent:
	case Message::FormFeed:
	case Message::VCHome:
	case Message::VCHomeExtend:
	case Message::VCHomeWrap:
	case Message::VCHomeWrapExtend:
	case Message::VCHomeDisplay:
	case Message::VCHomeDisplayExtend:
	case Message::DelWordLeft:
	case Message::DelWordRight:
	case Message::DelWordRightEnd:
	case Message::DelLineLeft:
	case Message::DelLineRight:
	case Message::LineCopy:
	case Message::LineCut:
	case Message::LineDelete:
	case Message::LineTranspose:
	case Message::LineReverse:
	case Message::LineDuplicate:
	case Message::LowerCase:
	case Message::UpperCase:
	case Message::LineScrollDown:
	case Message::LineScrollUp:
	case Message::DeleteBackNotLine:
	case Message::HomeDisplay:
	case Message::HomeDisplayExtend:
	case Message::LineEndDisplay:
	case Message::LineEndDisplayExtend:
	case Message::SetSelectionMode:
	case Message::LineDownRectExtend:
	case Message::LineUpRectExtend:
	case Message::CharLeftRectExtend:
	case Message::CharRightRectExtend:
	case Message::HomeRectExtend:
	case Message::VCHomeRectExtend:
	case Message::LineEndRectExtend:
	case Message::PageUpRectExtend:
	case Message::PageDownRectExtend:
	case Message::SelectionDuplicate:
	case Message::CopyAllowLine:
	case Message::CutAllowLine:
	case Message::VerticalCentreCaret:
	case Message::MoveSelectedLinesUp:
	case Message::MoveSelectedLinesDown:
	case Message::ScrollToStart:
	case Message::ScrollToEnd:
		break;

		// Filter out all others like display changes. Also, newlines are redundant
		// with char insert messages.
	case Message::NewLine:
	default:
		//		printf("Filtered out %ld of macro recording\n", iMessage);
		return;
	}

	// Send notification
	NotificationData scn = {};
	scn.nmhdr.code = Notification::MacroRecord;
	scn.message = iMessage;
	scn.wParam = wParam;
	scn.lParam = lParam;
	NotifyParent(scn);
}

// Something has changed that the container should know about
void Editor::ContainerNeedsUpdate(Update flags) noexcept {
	needUpdateUI = needUpdateUI | flags;
}

/**
 * Force scroll and keep position relative to top of window.
 *
 * If stuttered = true and not already at first/last row, move to first/last row of window.
 * If stuttered = true and already at first/last row, scroll as normal.
 */
void Editor::PageMove(int direction, Selection::SelTypes selt, bool stuttered) {
	Sci::Line topLineNew;
	SelectionPosition newPos;

	const Sci::Line currentLine = pdoc->SciLineFromPosition(sel.MainCaret());
	const Sci::Line topStutterLine = topLine + caretPolicies.y.slop;
	const Sci::Line bottomStutterLine =
	    pdoc->SciLineFromPosition(PositionFromLocation(
	                Point::FromInts(lastXChosen - xOffset, direction * vs.lineHeight * static_cast<int>(LinesToScroll()))))
	    - caretPolicies.y.slop - 1;

	if (stuttered && (direction < 0 && currentLine > topStutterLine)) {
		topLineNew = topLine;
		newPos = SPositionFromLocation(Point::FromInts(lastXChosen - xOffset, vs.lineHeight * caretPolicies.y.slop),
			false, false, UserVirtualSpace());

	} else if (stuttered && (direction > 0 && currentLine < bottomStutterLine)) {
		topLineNew = topLine;
		newPos = SPositionFromLocation(Point::FromInts(lastXChosen - xOffset, vs.lineHeight * static_cast<int>(LinesToScroll() - caretPolicies.y.slop)),
			false, false, UserVirtualSpace());

	} else {
		const Point pt = LocationFromPosition(sel.MainCaret());

		topLineNew = std::clamp<Sci::Line>(
		            topLine + direction * LinesToScroll(), 0, MaxScrollPos());
		newPos = SPositionFromLocation(
			Point::FromInts(lastXChosen - xOffset, static_cast<int>(pt.y) +
				direction * (vs.lineHeight * static_cast<int>(LinesToScroll()))),
			false, false, UserVirtualSpace());
	}

	if (topLineNew != topLine) {
		SetTopLine(topLineNew);
		MovePositionTo(newPos, selt);
		SetVerticalScrollPos();
		Redraw();
	} else {
		MovePositionTo(newPos, selt);
	}
}

void Editor::ChangeCaseOfSelection(CaseMapping caseMapping) {
	UndoGroup ug(pdoc);
	for (size_t r=0; r<sel.Count(); r++) {
		SelectionRange current = sel.Range(r);
		SelectionRange currentNoVS = current;
		currentNoVS.ClearVirtualSpace();
		const size_t rangeBytes = currentNoVS.Length();
		if (rangeBytes > 0 && !RangeContainsProtected(currentNoVS)) {
			std::string sText = RangeText(currentNoVS.Start().Position(), currentNoVS.End().Position());

			std::string sMapped = CaseMapString(sText, caseMapping);

			if (sMapped != sText) {
				size_t firstDifference = 0;
				while (sMapped[firstDifference] == sText[firstDifference])
					firstDifference++;
				size_t lastDifferenceText = sText.size() - 1;
				size_t lastDifferenceMapped = sMapped.size() - 1;
				while (sMapped[lastDifferenceMapped] == sText[lastDifferenceText]) {
					lastDifferenceText--;
					lastDifferenceMapped--;
				}
				const size_t endDifferenceText = sText.size() - 1 - lastDifferenceText;
				pdoc->DeleteChars(
					currentNoVS.Start().Position() + firstDifference,
					rangeBytes - firstDifference - endDifferenceText);
				const Sci::Position lengthChange = lastDifferenceMapped - firstDifference + 1;
				const Sci::Position lengthInserted = pdoc->InsertString(
					currentNoVS.Start().Position() + firstDifference,
					sMapped.c_str() + firstDifference,
					lengthChange);
				// Automatic movement changes selection so reset to exactly the same as it was.
				const Sci::Position diffSizes = sMapped.size() - sText.size() + lengthInserted - lengthChange;
				if (diffSizes != 0) {
					if (current.anchor > current.caret)
						current.anchor.Add(diffSizes);
					else
						current.caret.Add(diffSizes);
				}
				sel.Range(r) = current;
			}
		}
	}
}

void Editor::LineDelete() {
	const Sci::Line line = pdoc->SciLineFromPosition(sel.MainCaret());
	const Sci::Position start = pdoc->LineStart(line);
	const Sci::Position end = pdoc->LineStart(line + 1);
	pdoc->DeleteChars(start, end - start);
}

void Editor::LineTranspose() {
	const Sci::Line line = pdoc->SciLineFromPosition(sel.MainCaret());
	if (line > 0) {
		UndoGroup ug(pdoc);

		const Sci::Position startPrevious = pdoc->LineStart(line - 1);
		const std::string linePrevious = RangeText(startPrevious, pdoc->LineEnd(line - 1));

		Sci::Position startCurrent = pdoc->LineStart(line);
		const std::string lineCurrent = RangeText(startCurrent, pdoc->LineEnd(line));

		pdoc->DeleteChars(startCurrent, lineCurrent.length());
		pdoc->DeleteChars(startPrevious, linePrevious.length());
		startCurrent -= linePrevious.length();

		startCurrent += pdoc->InsertString(startPrevious, lineCurrent);
		pdoc->InsertString(startCurrent, linePrevious);
		// Move caret to start of current line
		MovePositionTo(SelectionPosition(startCurrent));
	}
}

void Editor::LineReverse() {
	const Sci::Line lineStart =
		pdoc->SciLineFromPosition(sel.RangeMain().Start().Position());
	const Sci::Line lineEnd =
		pdoc->SciLineFromPosition(sel.RangeMain().End().Position()-1);
	const Sci::Line lineDiff = lineEnd - lineStart;
	if (lineDiff <= 0)
		return;
	UndoGroup ug(pdoc);
	for (Sci::Line i=(lineDiff+1)/2-1; i>=0; --i) {
		const Sci::Line lineNum2 = lineEnd - i;
		const Sci::Line lineNum1 = lineStart + i;
		Sci::Position lineStart2 = pdoc->LineStart(lineNum2);
		const Sci::Position lineStart1 = pdoc->LineStart(lineNum1);
		const std::string line2 = RangeText(lineStart2, pdoc->LineEnd(lineNum2));
		const std::string line1 = RangeText(lineStart1, pdoc->LineEnd(lineNum1));
		const Sci::Position lineLen2 = line2.length();
		const Sci::Position lineLen1 = line1.length();
		pdoc->DeleteChars(lineStart2, lineLen2);
		pdoc->DeleteChars(lineStart1, lineLen1);
		lineStart2 -= lineLen1;
		pdoc->InsertString(lineStart2, line1);
		pdoc->InsertString(lineStart1, line2);
	}
	// Wholly select all affected lines
	sel.RangeMain() = SelectionRange(pdoc->LineStart(lineStart),
		pdoc->LineStart(lineEnd+1));
}

void Editor::Duplicate(bool forLine) {
	if (sel.Empty()) {
		forLine = true;
	}
	UndoGroup ug(pdoc);
	std::string_view eol;
	if (forLine) {
		eol = pdoc->EOLString();
	}
	for (size_t r=0; r<sel.Count(); r++) {
		SelectionPosition start = sel.Range(r).Start();
		SelectionPosition end = sel.Range(r).End();
		if (forLine) {
			const Sci::Line line = pdoc->SciLineFromPosition(sel.Range(r).caret.Position());
			start = SelectionPosition(pdoc->LineStart(line));
			end = SelectionPosition(pdoc->LineEnd(line));
		}
		std::string text = RangeText(start.Position(), end.Position());
		Sci::Position lengthInserted = 0;
		if (forLine)
			lengthInserted = pdoc->InsertString(end.Position(), eol);
		pdoc->InsertString(end.Position() + lengthInserted, text);
	}
	if (sel.Count() && sel.IsRectangular()) {
		SelectionPosition last = sel.Last();
		if (forLine) {
			const Sci::Line line = pdoc->SciLineFromPosition(last.Position());
			last = SelectionPosition(last.Position() +
				pdoc->LineStart(line+1) - pdoc->LineStart(line));
		}
		if (sel.Rectangular().anchor > sel.Rectangular().caret)
			sel.Rectangular().anchor = last;
		else
			sel.Rectangular().caret = last;
		SetRectangularRange();
	}
}

void Editor::CancelModes() {
	sel.SetMoveExtends(false);
}

void Editor::NewLine() {
	InvalidateWholeSelection();
	if (sel.IsRectangular() || !additionalSelectionTyping) {
		// Remove non-main ranges
		sel.DropAdditionalRanges();
	}

	UndoGroup ug(pdoc, !sel.Empty() || (sel.Count() > 1));

	// Clear each range
	if (!sel.Empty()) {
		ClearSelection();
	}

	// Insert each line end
	size_t countInsertions = 0;
	const std::string_view eol = pdoc->EOLString();
	for (size_t r = 0; r < sel.Count(); r++) {
		sel.Range(r).ClearVirtualSpace();
		const Sci::Position positionInsert = sel.Range(r).caret.Position();
		const Sci::Position insertLength = pdoc->InsertString(positionInsert, eol);
		if (insertLength > 0) {
			sel.Range(r) = SelectionRange(positionInsert + insertLength);
			countInsertions++;
		}
	}

	// Perform notifications after all the changes as the application may change the
	// selections in response to the characters.
	for (size_t i = 0; i < countInsertions; i++) {
		for (const char ch : eol) {
			NotifyChar(ch, CharacterSource::DirectInput);
			if (recordingMacro) {
				const char txt[2] = { ch, '\0' };
				NotifyMacroRecord(Message::ReplaceSel, 0, reinterpret_cast<sptr_t>(txt));
			}
		}
	}

	SetLastXChosen();
	SetScrollBars();
	EnsureCaretVisible();
	// Avoid blinking during rapid typing:
	ShowCaretAtCurrentPosition();
}

SelectionPosition Editor::PositionUpOrDown(SelectionPosition spStart, int direction, int lastX) {
	const Point pt = LocationFromPosition(spStart);
	int skipLines = 0;

	if (vs.annotationVisible != AnnotationVisible::Hidden) {
		const Sci::Line lineDoc = pdoc->SciLineFromPosition(spStart.Position());
		const Point ptStartLine = LocationFromPosition(pdoc->LineStart(lineDoc));
		const int subLine = static_cast<int>(pt.y - ptStartLine.y) / vs.lineHeight;

		if (direction < 0 && subLine == 0) {
			const Sci::Line lineDisplay = pcs->DisplayFromDoc(lineDoc);
			if (lineDisplay > 0) {
				skipLines = pdoc->AnnotationLines(pcs->DocFromDisplay(lineDisplay - 1));
			}
		} else if (direction > 0 && subLine >= (pcs->GetHeight(lineDoc) - 1 - pdoc->AnnotationLines(lineDoc))) {
			skipLines = pdoc->AnnotationLines(lineDoc);
		}
	}

	const Sci::Line newY = static_cast<Sci::Line>(pt.y) + (1 + skipLines) * direction * vs.lineHeight;
	if (lastX < 0) {
		lastX = static_cast<int>(pt.x) + xOffset;
	}
	SelectionPosition posNew = SPositionFromLocation(
		Point::FromInts(lastX - xOffset, static_cast<int>(newY)), false, false, UserVirtualSpace());

	if (direction < 0) {
		// Line wrapping may lead to a location on the same line, so
		// seek back if that is the case.
		Point ptNew = LocationFromPosition(posNew.Position());
		while ((posNew.Position() > 0) && (pt.y == ptNew.y)) {
			posNew.Add(-1);
			posNew.SetVirtualSpace(0);
			ptNew = LocationFromPosition(posNew.Position());
		}
	} else if (direction > 0 && posNew.Position() != pdoc->Length()) {
		// There is an equivalent case when moving down which skips
		// over a line.
		Point ptNew = LocationFromPosition(posNew.Position());
		while ((posNew.Position() > spStart.Position()) && (ptNew.y > static_cast<XYPOSITION>(newY))) {
			posNew.Add(-1);
			posNew.SetVirtualSpace(0);
			ptNew = LocationFromPosition(posNew.Position());
		}
	}
	return posNew;
}

void Editor::CursorUpOrDown(int direction, Selection::SelTypes selt) {
	if ((selt == Selection::SelTypes::none) && sel.MoveExtends()) {
		selt = !sel.IsRectangular() ? Selection::SelTypes::stream : Selection::SelTypes::rectangle;
	}
	SelectionPosition caretToUse = sel.RangeMain().caret;
	if (sel.IsRectangular()) {
		if (selt ==  Selection::SelTypes::none) {
			caretToUse = (direction > 0) ? sel.Limits().end : sel.Limits().start;
		} else {
			caretToUse = sel.Rectangular().caret;
		}
	}
	if (selt == Selection::SelTypes::rectangle) {
		const SelectionRange rangeBase = sel.IsRectangular() ? sel.Rectangular() : sel.RangeMain();
		if (!sel.IsRectangular()) {
			InvalidateWholeSelection();
			sel.DropAdditionalRanges();
		}
		const SelectionPosition posNew = MovePositionSoVisible(
			PositionUpOrDown(caretToUse, direction, lastXChosen), direction);
		sel.selType = Selection::SelTypes::rectangle;
		sel.Rectangular() = SelectionRange(posNew, rangeBase.anchor);
		SetRectangularRange();
		MovedCaret(posNew, caretToUse, true, caretPolicies);
	} else if (sel.selType == Selection::SelTypes::lines && sel.MoveExtends()) {
		// Calculate new caret position and call SetSelection(), which will ensure whole lines are selected.
		const SelectionPosition posNew = MovePositionSoVisible(
			PositionUpOrDown(caretToUse, direction, -1), direction);
		SetSelection(posNew, sel.RangeMain().anchor);
	} else {
		InvalidateWholeSelection();
		if (!additionalSelectionTyping || (sel.IsRectangular())) {
			sel.DropAdditionalRanges();
		}
		sel.selType = Selection::SelTypes::stream;
		for (size_t r = 0; r < sel.Count(); r++) {
			const int lastX = (r == sel.Main()) ? lastXChosen : -1;
			const SelectionPosition spCaretNow = sel.Range(r).caret;
			const SelectionPosition posNew = MovePositionSoVisible(
				PositionUpOrDown(spCaretNow, direction, lastX), direction);
			sel.Range(r) = selt == Selection::SelTypes::stream ?
				SelectionRange(posNew, sel.Range(r).anchor) : SelectionRange(posNew);
		}
		sel.RemoveDuplicates();
		MovedCaret(sel.RangeMain().caret, caretToUse, true, caretPolicies);
	}
}

void Editor::ParaUpOrDown(int direction, Selection::SelTypes selt) {
	Sci::Line lineDoc;
	const Sci::Position savedPos = sel.MainCaret();
	do {
		MovePositionTo(SelectionPosition(direction > 0 ? pdoc->ParaDown(sel.MainCaret()) : pdoc->ParaUp(sel.MainCaret())), selt);
		lineDoc = pdoc->SciLineFromPosition(sel.MainCaret());
		if (direction > 0) {
			if (sel.MainCaret() >= pdoc->Length() && !pcs->GetVisible(lineDoc)) {
				if (selt == Selection::SelTypes::none) {
					MovePositionTo(SelectionPosition(pdoc->LineEndPosition(savedPos)));
				}
				break;
			}
		}
	} while (!pcs->GetVisible(lineDoc));
}

Range Editor::RangeDisplayLine(Sci::Line lineVisible) {
	RefreshStyleData();
	AutoSurface surface(this);
	return view.RangeDisplayLine(surface, *this, lineVisible, vs);
}

Sci::Position Editor::StartEndDisplayLine(Sci::Position pos, bool start) {
	RefreshStyleData();
	AutoSurface surface(this);
	const Sci::Position posRet = view.StartEndDisplayLine(surface, *this, pos, start, vs);
	if (posRet == Sci::invalidPosition) {
		return pos;
	}
	return posRet;
}

namespace {

constexpr short HighShortFromWParam(uptr_t x) {
	return static_cast<short>(x >> 16);
}

constexpr short LowShortFromWParam(uptr_t x) {
	return static_cast<short>(x & 0xffff);
}

constexpr Message WithExtends(Message iMessage) noexcept {
	switch (iMessage) {
	case Message::CharLeft: return Message::CharLeftExtend;
	case Message::CharRight: return Message::CharRightExtend;

	case Message::WordLeft: return Message::WordLeftExtend;
	case Message::WordRight: return Message::WordRightExtend;
	case Message::WordLeftEnd: return Message::WordLeftEndExtend;
	case Message::WordRightEnd: return Message::WordRightEndExtend;
	case Message::WordPartLeft: return Message::WordPartLeftExtend;
	case Message::WordPartRight: return Message::WordPartRightExtend;

	case Message::Home: return Message::HomeExtend;
	case Message::HomeDisplay: return Message::HomeDisplayExtend;
	case Message::HomeWrap: return Message::HomeWrapExtend;
	case Message::VCHome: return Message::VCHomeExtend;
	case Message::VCHomeDisplay: return Message::VCHomeDisplayExtend;
	case Message::VCHomeWrap: return Message::VCHomeWrapExtend;

	case Message::LineEnd: return Message::LineEndExtend;
	case Message::LineEndDisplay: return Message::LineEndDisplayExtend;
	case Message::LineEndWrap: return Message::LineEndWrapExtend;

	default:	return iMessage;
	}
}

constexpr int NaturalDirection(Message iMessage) noexcept {
	switch (iMessage) {
	case Message::CharLeft:
	case Message::CharLeftExtend:
	case Message::CharLeftRectExtend:
	case Message::WordLeft:
	case Message::WordLeftExtend:
	case Message::WordLeftEnd:
	case Message::WordLeftEndExtend:
	case Message::WordPartLeft:
	case Message::WordPartLeftExtend:
	case Message::Home:
	case Message::HomeExtend:
	case Message::HomeDisplay:
	case Message::HomeDisplayExtend:
	case Message::HomeWrap:
	case Message::HomeWrapExtend:
		// VC_HOME* mostly goes back
	case Message::VCHome:
	case Message::VCHomeExtend:
	case Message::VCHomeDisplay:
	case Message::VCHomeDisplayExtend:
	case Message::VCHomeWrap:
	case Message::VCHomeWrapExtend:
		return -1;

	default:
		return 1;
	}
}

constexpr bool IsRectExtend(Message iMessage, bool isRectMoveExtends) noexcept {
	switch (iMessage) {
	case Message::CharLeftRectExtend:
	case Message::CharRightRectExtend:
	case Message::HomeRectExtend:
	case Message::VCHomeRectExtend:
	case Message::LineEndRectExtend:
		return true;
	default:
		if (isRectMoveExtends) {
			// Handle Message::SetSelectionMode(SelectionMode::Rectangle) and subsequent movements.
			switch (iMessage) {
			case Message::CharLeftExtend:
			case Message::CharRightExtend:
			case Message::HomeExtend:
			case Message::VCHomeExtend:
			case Message::LineEndExtend:
				return true;
			default:
				return false;
			}
		}
		return false;
	}
}

}

Sci::Position Editor::HomeWrapPosition(Sci::Position position) {
	const Sci::Position viewLineStart = StartEndDisplayLine(position, true);
	const Sci::Position homePos = MovePositionSoVisible(viewLineStart, -1).Position();
	if (position <= homePos)
		return pdoc->LineStartPosition(position);
	return homePos;
}

Sci::Position Editor::VCHomeDisplayPosition(Sci::Position position) {
	const Sci::Position homePos = pdoc->VCHomePosition(position);
	const Sci::Position viewLineStart = StartEndDisplayLine(position, true);
	if (viewLineStart > homePos) {
		return viewLineStart;
	}
	return homePos;
}

Sci::Position Editor::VCHomeWrapPosition(Sci::Position position) {
	const Sci::Position homePos = pdoc->VCHomePosition(position);
	const Sci::Position viewLineStart = StartEndDisplayLine(position, true);
	if ((viewLineStart < position) && (viewLineStart > homePos)) {
		return viewLineStart;
	}
	return homePos;
}

Sci::Position Editor::LineEndWrapPosition(Sci::Position position) {
	const Sci::Position endPos = StartEndDisplayLine(position, false);
	const Sci::Position realEndPos = pdoc->LineEndPosition(position);
	if (endPos > realEndPos      // if moved past visible EOLs
		|| position >= endPos) // if at end of display line already
		return realEndPos;
	return endPos;
}

SelectionPosition Editor::PositionMove(Message iMessage, SelectionPosition spCaret) {
	switch (iMessage) {
	case Message::CharLeft:
	case Message::CharLeftExtend:
		if (spCaret.VirtualSpace()) {
			spCaret.AddVirtualSpace(-1);
		} else if (!FlagSet(virtualSpaceOptions, VirtualSpace::NoWrapLineStart) || pdoc->GetColumn(spCaret.Position()) > 0) {
			spCaret.Add(-1);
		}
		return spCaret;
	case Message::CharRight:
	case Message::CharRightExtend:
		if (FlagSet(virtualSpaceOptions, VirtualSpace::UserAccessible) && pdoc->IsLineEndPosition(spCaret.Position())) {
			spCaret.AddVirtualSpace(1);
		} else {
			spCaret.Add(1);
		}
		return spCaret;
	case Message::WordLeft:
	case Message::WordLeftExtend:
		return SelectionPosition(pdoc->NextWordStart(spCaret.Position(), -1));
	case Message::WordRight:
	case Message::WordRightExtend:
		return SelectionPosition(pdoc->NextWordStart(spCaret.Position(), 1));
	case Message::WordLeftEnd:
	case Message::WordLeftEndExtend:
		return SelectionPosition(pdoc->NextWordEnd(spCaret.Position(), -1));
	case Message::WordRightEnd:
	case Message::WordRightEndExtend:
		return SelectionPosition(pdoc->NextWordEnd(spCaret.Position(), 1));
	case Message::WordPartLeft:
	case Message::WordPartLeftExtend:
		return SelectionPosition(pdoc->WordPartLeft(spCaret.Position()));
	case Message::WordPartRight:
	case Message::WordPartRightExtend:
		return SelectionPosition(pdoc->WordPartRight(spCaret.Position()));
	case Message::Home:
	case Message::HomeExtend:
		return SelectionPosition(pdoc->LineStartPosition(spCaret.Position()));
	case Message::HomeDisplay:
	case Message::HomeDisplayExtend:
		return SelectionPosition(StartEndDisplayLine(spCaret.Position(), true));
	case Message::HomeWrap:
	case Message::HomeWrapExtend:
		return SelectionPosition(HomeWrapPosition(spCaret.Position()));
	case Message::VCHome:
	case Message::VCHomeExtend:
		// VCHome alternates between beginning of line and beginning of text so may move back or forwards
		return SelectionPosition(pdoc->VCHomePosition(spCaret.Position()));
	case Message::VCHomeDisplay:
	case Message::VCHomeDisplayExtend:
		return SelectionPosition(VCHomeDisplayPosition(spCaret.Position()));
	case Message::VCHomeWrap:
	case Message::VCHomeWrapExtend:
		return SelectionPosition(VCHomeWrapPosition(spCaret.Position()));
	case Message::LineEnd:
	case Message::LineEndExtend:
		return SelectionPosition(pdoc->LineEndPosition(spCaret.Position()));
	case Message::LineEndDisplay:
	case Message::LineEndDisplayExtend:
		return SelectionPosition(StartEndDisplayLine(spCaret.Position(), false));
	case Message::LineEndWrap:
	case Message::LineEndWrapExtend:
		return SelectionPosition(LineEndWrapPosition(spCaret.Position()));

	default:
		break;
	}
	// Above switch should be exhaustive so this will never be reached.
	PLATFORM_ASSERT(false);
	return spCaret;
}

SelectionRange Editor::SelectionMove(Scintilla::Message iMessage, size_t r) {
	const SelectionPosition spCaretStart = sel.Range(r).caret;
	const SelectionPosition spCaretMoved = PositionMove(iMessage, spCaretStart);

	const int directionMove = (spCaretMoved < spCaretStart) ? -1 : 1;
	const SelectionPosition spCaret = MovePositionSoVisible(spCaretMoved, directionMove);

	// Handle move versus extend, and special behaviour for non-empty left/right
	switch (iMessage) {
	case Message::CharLeft:
	case Message::CharRight:
		if (sel.Range(r).Empty()) {
			return SelectionRange(spCaret);
		}
		if (iMessage == Message::CharLeft) {
			return SelectionRange(sel.Range(r).Start());
		}
		return SelectionRange(sel.Range(r).End());

	case Message::WordLeft:
	case Message::WordRight:
	case Message::WordLeftEnd:
	case Message::WordRightEnd:
	case Message::WordPartLeft:
	case Message::WordPartRight:
	case Message::Home:
	case Message::HomeDisplay:
	case Message::HomeWrap:
	case Message::VCHome:
	case Message::VCHomeDisplay:
	case Message::VCHomeWrap:
	case Message::LineEnd:
	case Message::LineEndDisplay:
	case Message::LineEndWrap:
		return SelectionRange(spCaret);

	default:
		break;
	}

	// All remaining cases are *Extend
	const SelectionRange rangeNew = SelectionRange(spCaret, sel.Range(r).anchor);
	sel.TrimOtherSelections(r, rangeNew);
	return rangeNew;
}

int Editor::HorizontalMove(Message iMessage) {
	if (sel.selType == Selection::SelTypes::lines) {
		return 0; // horizontal moves with line selection have no effect
	}
	if (sel.MoveExtends()) {
		iMessage = WithExtends(iMessage);
	}

	if (!multipleSelection && !sel.IsRectangular()) {
		// Simplify selection down to 1
		sel.SetSelection(sel.RangeMain());
	}

	// Invalidate each of the current selections
	InvalidateWholeSelection();

	if (IsRectExtend(iMessage, sel.IsRectangular() && sel.MoveExtends())) {
		const SelectionRange rangeBase = sel.IsRectangular() ? sel.Rectangular() : sel.RangeMain();
		if (!sel.IsRectangular()) {
			sel.DropAdditionalRanges();
		}
		// Will change to rectangular if not currently rectangular
		SelectionPosition spCaret = rangeBase.caret;
		switch (iMessage) {
		case Message::CharLeftRectExtend:
		case Message::CharLeftExtend: // only when sel.IsRectangular() && sel.MoveExtends()
			if (pdoc->IsLineEndPosition(spCaret.Position()) && spCaret.VirtualSpace()) {
				spCaret.SetVirtualSpace(spCaret.VirtualSpace() - 1);
			} else if (!FlagSet(virtualSpaceOptions, VirtualSpace::NoWrapLineStart) || pdoc->GetColumn(spCaret.Position()) > 0) {
				spCaret = SelectionPosition(spCaret.Position() - 1);
			}
			break;
		case Message::CharRightRectExtend:
		case Message::CharRightExtend: // only when sel.IsRectangular() && sel.MoveExtends()
			if (FlagSet(virtualSpaceOptions, VirtualSpace::RectangularSelection) && pdoc->IsLineEndPosition(sel.MainCaret())) {
				spCaret.SetVirtualSpace(spCaret.VirtualSpace() + 1);
			} else {
				spCaret = SelectionPosition(spCaret.Position() + 1);
			}
			break;
		case Message::HomeRectExtend:
		case Message::HomeExtend: // only when sel.IsRectangular() && sel.MoveExtends()
			spCaret = SelectionPosition(pdoc->LineStartPosition(spCaret.Position()));
			break;
		case Message::VCHomeRectExtend:
		case Message::VCHomeExtend: // only when sel.IsRectangular() && sel.MoveExtends()
			spCaret = SelectionPosition(pdoc->VCHomePosition(spCaret.Position()));
			break;
		case Message::LineEndRectExtend:
		case Message::LineEndExtend: // only when sel.IsRectangular() && sel.MoveExtends()
			spCaret = SelectionPosition(pdoc->LineEndPosition(spCaret.Position()));
			break;
		default:
			break;
		}
		const int directionMove = (spCaret < rangeBase.caret) ? -1 : 1;
		spCaret = MovePositionSoVisible(spCaret, directionMove);
		sel.selType = Selection::SelTypes::rectangle;
		sel.Rectangular() = SelectionRange(spCaret, rangeBase.anchor);
		SetRectangularRange();
	} else if (sel.IsRectangular()) {
		// Not a rectangular extension so switch to stream.
		SelectionPosition selAtLimit = (NaturalDirection(iMessage) > 0) ? sel.Limits().end : sel.Limits().start;
		switch (iMessage) {
		case Message::Home:
			selAtLimit = SelectionPosition(pdoc->LineStartPosition(selAtLimit.Position()));
			break;
		case Message::VCHome:
			selAtLimit = SelectionPosition(pdoc->VCHomePosition(selAtLimit.Position()));
			break;
		case Message::LineEnd:
			selAtLimit = SelectionPosition(pdoc->LineEndPosition(selAtLimit.Position()));
			break;
		default:
			break;
		}
		sel.selType = Selection::SelTypes::stream;
		sel.SetSelection(SelectionRange(selAtLimit));
	} else {
		if (!additionalSelectionTyping) {
			InvalidateWholeSelection();
			sel.DropAdditionalRanges();
		}
		for (size_t r = 0; r < sel.Count(); r++) {
			sel.Range(r) = SelectionMove(iMessage, r);
		}
	}

	sel.RemoveDuplicates();

	MovedCaret(sel.RangeMain().caret, SelectionPosition(Sci::invalidPosition), true, caretPolicies);

	// Invalidate the new state of the selection
	InvalidateWholeSelection();

	SetLastXChosen();
	// Need the line moving and so forth from MovePositionTo
	return 0;
}

int Editor::DelWordOrLine(Message iMessage) {
	// Virtual space may be realised for Message::DelWordRight or Message::DelWordRightEnd
	// which means 2 actions so wrap in an undo group.

	// Rightwards and leftwards deletions differ in treatment of virtual space.
	// Clear virtual space for leftwards, realise for rightwards.
	const bool leftwards = (iMessage == Message::DelWordLeft) || (iMessage == Message::DelLineLeft);

	if (!additionalSelectionTyping) {
		InvalidateWholeSelection();
		sel.DropAdditionalRanges();
	}

	UndoGroup ug0(pdoc, (sel.Count() > 1) || !leftwards);

	for (size_t r = 0; r < sel.Count(); r++) {
		if (leftwards) {
			// Delete to the left so first clear the virtual space.
			sel.Range(r).ClearVirtualSpace();
		} else {
			// Delete to the right so first realise the virtual space.
			sel.Range(r) = SelectionRange(
				RealizeVirtualSpace(sel.Range(r).caret));
		}

		Range rangeDelete;
		switch (iMessage) {
		case Message::DelWordLeft:
			rangeDelete = Range(
				pdoc->NextWordStart(sel.Range(r).caret.Position(), -1),
				sel.Range(r).caret.Position());
			break;
		case Message::DelWordRight:
			rangeDelete = Range(
				sel.Range(r).caret.Position(),
				pdoc->NextWordStart(sel.Range(r).caret.Position(), 1));
			break;
		case Message::DelWordRightEnd:
			rangeDelete = Range(
				sel.Range(r).caret.Position(),
				pdoc->NextWordEnd(sel.Range(r).caret.Position(), 1));
			break;
		case Message::DelLineLeft:
			rangeDelete = Range(
				pdoc->LineStartPosition(sel.Range(r).caret.Position()),
				sel.Range(r).caret.Position());
			break;
		case Message::DelLineRight:
			rangeDelete = Range(
				sel.Range(r).caret.Position(),
				pdoc->LineEndPosition(sel.Range(r).caret.Position()));
			break;
		default:
			break;
		}
		if (!RangeContainsProtected(rangeDelete.start, rangeDelete.end)) {
			pdoc->DeleteChars(rangeDelete.start, rangeDelete.end - rangeDelete.start);
		}
	}

	// May need something stronger here: can selections overlap at this point?
	sel.RemoveDuplicates();

	MovedCaret(sel.RangeMain().caret, SelectionPosition(Sci::invalidPosition), true, caretPolicies);

	// Invalidate the new state of the selection
	InvalidateWholeSelection();

	SetLastXChosen();
	return 0;
}

int Editor::KeyCommand(Message iMessage) {
	switch (iMessage) {
	case Message::LineDown:
		CursorUpOrDown(1, Selection::SelTypes::none);
		break;
	case Message::LineDownExtend:
		CursorUpOrDown(1, Selection::SelTypes::stream);
		break;
	case Message::LineDownRectExtend:
		CursorUpOrDown(1, Selection::SelTypes::rectangle);
		break;
	case Message::ParaDown:
		ParaUpOrDown(1, Selection::SelTypes::none);
		break;
	case Message::ParaDownExtend:
		ParaUpOrDown(1, Selection::SelTypes::stream);
		break;
	case Message::LineScrollDown:
		ScrollTo(topLine + 1);
		MoveCaretInsideView(false);
		break;
	case Message::LineUp:
		CursorUpOrDown(-1, Selection::SelTypes::none);
		break;
	case Message::LineUpExtend:
		CursorUpOrDown(-1, Selection::SelTypes::stream);
		break;
	case Message::LineUpRectExtend:
		CursorUpOrDown(-1, Selection::SelTypes::rectangle);
		break;
	case Message::ParaUp:
		ParaUpOrDown(-1, Selection::SelTypes::none);
		break;
	case Message::ParaUpExtend:
		ParaUpOrDown(-1, Selection::SelTypes::stream);
		break;
	case Message::LineScrollUp:
		ScrollTo(topLine - 1);
		MoveCaretInsideView(false);
		break;

	case Message::CharLeft:
	case Message::CharLeftExtend:
	case Message::CharLeftRectExtend:
	case Message::CharRight:
	case Message::CharRightExtend:
	case Message::CharRightRectExtend:
	case Message::WordLeft:
	case Message::WordLeftExtend:
	case Message::WordRight:
	case Message::WordRightExtend:
	case Message::WordLeftEnd:
	case Message::WordLeftEndExtend:
	case Message::WordRightEnd:
	case Message::WordRightEndExtend:
	case Message::WordPartLeft:
	case Message::WordPartLeftExtend:
	case Message::WordPartRight:
	case Message::WordPartRightExtend:
	case Message::Home:
	case Message::HomeExtend:
	case Message::HomeRectExtend:
	case Message::HomeDisplay:
	case Message::HomeDisplayExtend:
	case Message::HomeWrap:
	case Message::HomeWrapExtend:
	case Message::VCHome:
	case Message::VCHomeExtend:
	case Message::VCHomeRectExtend:
	case Message::VCHomeDisplay:
	case Message::VCHomeDisplayExtend:
	case Message::VCHomeWrap:
	case Message::VCHomeWrapExtend:
	case Message::LineEnd:
	case Message::LineEndExtend:
	case Message::LineEndRectExtend:
	case Message::LineEndDisplay:
	case Message::LineEndDisplayExtend:
	case Message::LineEndWrap:
	case Message::LineEndWrapExtend:
		return HorizontalMove(iMessage);

	case Message::DocumentStart:
		MovePositionTo(0);
		SetLastXChosen();
		break;
	case Message::DocumentStartExtend:
		MovePositionTo(0, Selection::SelTypes::stream);
		SetLastXChosen();
		break;
	case Message::DocumentEnd:
		MovePositionTo(pdoc->Length());
		SetLastXChosen();
		break;
	case Message::DocumentEndExtend:
		MovePositionTo(pdoc->Length(), Selection::SelTypes::stream);
		SetLastXChosen();
		break;
	case Message::StutteredPageUp:
		PageMove(-1, Selection::SelTypes::none, true);
		break;
	case Message::StutteredPageUpExtend:
		PageMove(-1, Selection::SelTypes::stream, true);
		break;
	case Message::StutteredPageDown:
		PageMove(1, Selection::SelTypes::none, true);
		break;
	case Message::StutteredPageDownExtend:
		PageMove(1, Selection::SelTypes::stream, true);
		break;
	case Message::PageUp:
		PageMove(-1);
		break;
	case Message::PageUpExtend:
		PageMove(-1, Selection::SelTypes::stream);
		break;
	case Message::PageUpRectExtend:
		PageMove(-1, Selection::SelTypes::rectangle);
		break;
	case Message::PageDown:
		PageMove(1);
		break;
	case Message::PageDownExtend:
		PageMove(1, Selection::SelTypes::stream);
		break;
	case Message::PageDownRectExtend:
		PageMove(1, Selection::SelTypes::rectangle);
		break;
	case Message::EditToggleOvertype:
		inOverstrike = !inOverstrike;
		ContainerNeedsUpdate(Update::Selection);
		ShowCaretAtCurrentPosition();
		SetIdle(true);
		break;
	case Message::Cancel:            	// Cancel any modes - handled in subclass
		// Also unselect text
		CancelModes();
		if ((sel.Count() > 1) && !sel.IsRectangular()) {
			// Drop additional selections
			InvalidateWholeSelection();
			sel.DropAdditionalRanges();
		}
		break;
	case Message::DeleteBack:
		DelCharBack(true);
		if ((caretSticky == CaretSticky::Off) || (caretSticky == CaretSticky::WhiteSpace)) {
			SetLastXChosen();
		}
		EnsureCaretVisible();
		break;
	case Message::DeleteBackNotLine:
		DelCharBack(false);
		if ((caretSticky == CaretSticky::Off) || (caretSticky == CaretSticky::WhiteSpace)) {
			SetLastXChosen();
		}
		EnsureCaretVisible();
		break;
	case Message::Tab:
	case Message::LineIndent:
		Indent(true, iMessage == Message::LineIndent);
		if (caretSticky == CaretSticky::Off) {
			SetLastXChosen();
		}
		EnsureCaretVisible();
		ShowCaretAtCurrentPosition();		// Avoid blinking
		break;
	case Message::BackTab:
	case Message::LineDedent:
		Indent(false, iMessage == Message::LineDedent);
		if ((caretSticky == CaretSticky::Off) || (caretSticky == CaretSticky::WhiteSpace)) {
			SetLastXChosen();
		}
		EnsureCaretVisible();
		ShowCaretAtCurrentPosition();		// Avoid blinking
		break;
	case Message::NewLine:
		NewLine();
		break;
	case Message::FormFeed:
		AddChar('\f');
		break;
	case Message::ZoomIn:
		if (vs.zoomLevel < 60) {
			vs.zoomLevel++;
			InvalidateStyleRedraw();
			NotifyZoom();
		}
		break;
	case Message::ZoomOut:
		if (vs.zoomLevel > -10) {
			vs.zoomLevel--;
			InvalidateStyleRedraw();
			NotifyZoom();
		}
		break;

	case Message::DelWordLeft:
	case Message::DelWordRight:
	case Message::DelWordRightEnd:
	case Message::DelLineLeft:
	case Message::DelLineRight:
		return DelWordOrLine(iMessage);

	case Message::LineCopy: {
			const Sci::Line lineStart = pdoc->SciLineFromPosition(SelectionStart().Position());
			const Sci::Line lineEnd = pdoc->SciLineFromPosition(SelectionEnd().Position());
			CopyRangeToClipboard(pdoc->LineStart(lineStart),
				pdoc->LineStart(lineEnd + 1));
		}
		break;
	case Message::LineCut: {
			const Sci::Line lineStart = pdoc->SciLineFromPosition(SelectionStart().Position());
			const Sci::Line lineEnd = pdoc->SciLineFromPosition(SelectionEnd().Position());
			const Sci::Position start = pdoc->LineStart(lineStart);
			const Sci::Position end = pdoc->LineStart(lineEnd + 1);
			SetSelection(start, end);
			Cut();
			SetLastXChosen();
		}
		break;
	case Message::LineDelete:
		LineDelete();
		break;
	case Message::LineTranspose:
		LineTranspose();
		break;
	case Message::LineReverse:
		LineReverse();
		break;
	case Message::LineDuplicate:
		Duplicate(true);
		break;
	case Message::SelectionDuplicate:
		Duplicate(false);
		break;
	case Message::LowerCase:
		ChangeCaseOfSelection(CaseMapping::lower);
		break;
	case Message::UpperCase:
		ChangeCaseOfSelection(CaseMapping::upper);
		break;
	case Message::ScrollToStart:
		ScrollTo(0);
		break;
	case Message::ScrollToEnd:
		ScrollTo(MaxScrollPos());
		break;
	default:
		break;
	}
	return 0;
}

int Editor::KeyDefault(Keys, KeyMod) {
	return 0;
}

int Editor::KeyDownWithModifiers(Keys key, KeyMod modifiers, bool *consumed) {
	DwellEnd(false);
	const Message msg = kmap.Find(key, modifiers);
	if (msg != static_cast<Message>(0)) {
		if (consumed)
			*consumed = true;
		return static_cast<int>(WndProc(msg, 0, 0));
	}
	if (consumed)
		*consumed = false;
	return KeyDefault(key, modifiers);
}

void Editor::Indent(bool forwards, bool lineIndent) {
	UndoGroup ug(pdoc);
	for (size_t r=0; r<sel.Count(); r++) {
		const Sci::Line lineOfAnchor =
			pdoc->SciLineFromPosition(sel.Range(r).anchor.Position());
		Sci::Position caretPosition = sel.Range(r).caret.Position();
		const Sci::Line lineCurrentPos = pdoc->SciLineFromPosition(caretPosition);
		if (lineOfAnchor == lineCurrentPos && !lineIndent) {
			if (forwards) {
				pdoc->DeleteChars(sel.Range(r).Start().Position(), sel.Range(r).Length());
				caretPosition = sel.Range(r).caret.Position();
				if (pdoc->GetColumn(caretPosition) <= pdoc->GetColumn(pdoc->GetLineIndentPosition(lineCurrentPos)) &&
						pdoc->tabIndents) {
					const int indentation = pdoc->GetLineIndentation(lineCurrentPos);
					const int indentationStep = pdoc->IndentSize();
					const Sci::Position posSelect = pdoc->SetLineIndentation(
						lineCurrentPos, indentation + indentationStep - indentation % indentationStep);
					sel.Range(r) = SelectionRange(posSelect);
				} else {
					if (pdoc->useTabs) {
						const Sci::Position lengthInserted = pdoc->InsertString(caretPosition, "\t", 1);
						sel.Range(r) = SelectionRange(caretPosition + lengthInserted);
					} else {
						int numSpaces = (pdoc->tabInChars) -
								static_cast<int>((pdoc->GetColumn(caretPosition) % (pdoc->tabInChars)));
						if (numSpaces < 1)
							numSpaces = pdoc->tabInChars;
						const std::string spaceText(numSpaces, ' ');
						const Sci::Position lengthInserted = pdoc->InsertString(caretPosition, spaceText);
						sel.Range(r) = SelectionRange(caretPosition + lengthInserted);
					}
				}
			} else {
				if (pdoc->GetColumn(caretPosition) <= pdoc->GetLineIndentation(lineCurrentPos) &&
						pdoc->tabIndents) {
					const int indentation = pdoc->GetLineIndentation(lineCurrentPos);
					const int indentationStep = pdoc->IndentSize();
					const Sci::Position posSelect = pdoc->SetLineIndentation(lineCurrentPos, indentation - indentationStep);
					sel.Range(r) = SelectionRange(posSelect);
				} else {
					Sci::Position newColumn = ((pdoc->GetColumn(caretPosition) - 1) / pdoc->tabInChars) *
							pdoc->tabInChars;
					if (newColumn < 0)
						newColumn = 0;
					Sci::Position newPos = caretPosition;
					while (pdoc->GetColumn(newPos) > newColumn)
						newPos--;
					sel.Range(r) = SelectionRange(newPos);
				}
			}
		} else {	// Multiline or LineIndent
			const Sci::Position anchorPosOnLine = sel.Range(r).anchor.Position() -
				pdoc->LineStart(lineOfAnchor);
			const Sci::Position currentPosPosOnLine = caretPosition -
				pdoc->LineStart(lineCurrentPos);
			// Multiple lines selected so indent / dedent
			const Sci::Line lineTopSel = std::min(lineOfAnchor, lineCurrentPos);
			Sci::Line lineBottomSel = std::max(lineOfAnchor, lineCurrentPos);
			if (pdoc->LineStart(lineBottomSel) == sel.Range(r).anchor.Position() || pdoc->LineStart(lineBottomSel) == caretPosition)
				lineBottomSel--;  	// If not selecting any characters on a line, do not indent
			pdoc->Indent(forwards, lineBottomSel, lineTopSel);
			if (lineOfAnchor < lineCurrentPos) {
				if (currentPosPosOnLine == 0)
					sel.Range(r) = SelectionRange(pdoc->LineStart(lineCurrentPos),
						pdoc->LineStart(lineOfAnchor));
				else
					sel.Range(r) = SelectionRange(pdoc->LineStart(lineCurrentPos + 1),
						pdoc->LineStart(lineOfAnchor));
			} else {
				if (anchorPosOnLine == 0)
					sel.Range(r) = SelectionRange(pdoc->LineStart(lineCurrentPos),
						pdoc->LineStart(lineOfAnchor));
				else
					sel.Range(r) = SelectionRange(pdoc->LineStart(lineCurrentPos),
						pdoc->LineStart(lineOfAnchor + 1));
			}
		}
	}
	ContainerNeedsUpdate(Update::Selection);
}

std::unique_ptr<CaseFolder> Editor::CaseFolderForEncoding() {
	// Simple default that only maps ASCII upper case to lower case.
	return std::make_unique<CaseFolderTable>();
}

/**
 * Search of a text in the document, in the given range.
 * @return The position of the found text, -1 if not found.
 */
Sci::Position Editor::FindText(
    uptr_t wParam,		///< Search modes : @c FindOption::MatchCase, @c FindOption::WholeWord,
    ///< @c FindOption::WordStart, @c FindOption::RegExp or @c FindOption::Posix.
    sptr_t lParam) {	///< @c Sci_TextToFind structure: The text to search for in the given range.

	TextToFind *ft = static_cast<TextToFind *>(PtrFromSPtr(lParam));
	Sci::Position lengthFound = strlen(ft->lpstrText);
	if (!pdoc->HasCaseFolder())
		pdoc->SetCaseFolder(CaseFolderForEncoding());
	try {
		const Sci::Position pos = pdoc->FindText(
			static_cast<Sci::Position>(ft->chrg.cpMin),
			static_cast<Sci::Position>(ft->chrg.cpMax),
			ft->lpstrText,
			static_cast<FindOption>(wParam),
			&lengthFound);
		if (pos != -1) {
			ft->chrgText.cpMin = static_cast<Sci_PositionCR>(pos);
			ft->chrgText.cpMax = static_cast<Sci_PositionCR>(pos + lengthFound);
		}
		return pos;
	} catch (RegexError &) {
		errorStatus = Status::RegEx;
		return -1;
	}
}

/**
 * Search of a text in the document, in the given range.
 * @return The position of the found text, -1 if not found.
 */
Sci::Position Editor::FindTextFull(
    uptr_t wParam,		///< Search modes : @c FindOption::MatchCase, @c FindOption::WholeWord,
    ///< @c FindOption::WordStart, @c FindOption::RegExp or @c FindOption::Posix.
    sptr_t lParam) {	///< @c Sci_TextToFindFull structure: The text to search for in the given range.

	TextToFindFull *ft = static_cast<TextToFindFull *>(PtrFromSPtr(lParam));
	Sci::Position lengthFound = strlen(ft->lpstrText);
	if (!pdoc->HasCaseFolder())
		pdoc->SetCaseFolder(CaseFolderForEncoding());
	try {
		const Sci::Position pos = pdoc->FindText(
			ft->chrg.cpMin,
			ft->chrg.cpMax,
			ft->lpstrText,
			static_cast<FindOption>(wParam),
			&lengthFound);
		if (pos != -1) {
			ft->chrgText.cpMin = pos;
			ft->chrgText.cpMax = pos + lengthFound;
		}
		return pos;
	} catch (RegexError &) {
		errorStatus = Status::RegEx;
		return -1;
	}
}

/**
 * Relocatable search support : Searches relative to current selection
 * point and sets the selection to the found text range with
 * each search.
 */
/**
 * Anchor following searches at current selection start: This allows
 * multiple incremental interactive searches to be macro recorded
 * while still setting the selection to found text so the find/select
 * operation is self-contained.
 */
void Editor::SearchAnchor() noexcept {
	searchAnchor = SelectionStart().Position();
}

/**
 * Find text from current search anchor: Must call @c SearchAnchor first.
 * Used for next text and previous text requests.
 * @return The position of the found text, -1 if not found.
 */
Sci::Position Editor::SearchText(
    Message iMessage,		///< Accepts both @c Message::SearchNext and @c Message::SearchPrev.
    uptr_t wParam,				///< Search modes : @c FindOption::MatchCase, @c FindOption::WholeWord,
    ///< @c FindOption::WordStart, @c FindOption::RegExp or @c FindOption::Posix.
    sptr_t lParam) {			///< The text to search for.

	const char *txt = ConstCharPtrFromSPtr(lParam);
	Sci::Position pos = Sci::invalidPosition;
	Sci::Position lengthFound = strlen(txt);
	if (!pdoc->HasCaseFolder())
		pdoc->SetCaseFolder(CaseFolderForEncoding());
	try {
		if (iMessage == Message::SearchNext) {
			pos = pdoc->FindText(searchAnchor, pdoc->Length(), txt,
					static_cast<FindOption>(wParam),
					&lengthFound);
		} else {
			pos = pdoc->FindText(searchAnchor, 0, txt,
					static_cast<FindOption>(wParam),
					&lengthFound);
		}
	} catch (RegexError &) {
		errorStatus = Status::RegEx;
		return Sci::invalidPosition;
	}
	if (pos != Sci::invalidPosition) {
		SetSelection(pos, pos + lengthFound);
	}

	return pos;
}

std::string Editor::CaseMapString(const std::string &s, CaseMapping caseMapping) {
	std::string ret(s);
	for (char &ch : ret) {
		switch (caseMapping) {
			case CaseMapping::upper:
				ch = MakeUpperCase(ch);
				break;
			case CaseMapping::lower:
				ch = MakeLowerCase(ch);
				break;
			default:	// no action
				break;
		}
	}
	return ret;
}

/**
 * Search for text in the target range of the document.
 * @return The position of the found text, -1 if not found.
 */
Sci::Position Editor::SearchInTarget(const char *text, Sci::Position length) {
	Sci::Position lengthFound = length;

	if (!pdoc->HasCaseFolder())
		pdoc->SetCaseFolder(CaseFolderForEncoding());
	try {
		const Sci::Position pos = pdoc->FindText(targetRange.start.Position(), targetRange.end.Position(), text,
				searchFlags,
				&lengthFound);
		if (pos != -1) {
			targetRange.start.SetPosition(pos);
			targetRange.end.SetPosition(pos + lengthFound);
		}
		return pos;
	} catch (RegexError &) {
		errorStatus = Status::RegEx;
		return -1;
	}
}

void Editor::GoToLine(Sci::Line lineNo) {
	if (lineNo > pdoc->LinesTotal())
		lineNo = pdoc->LinesTotal();
	if (lineNo < 0)
		lineNo = 0;
	SetEmptySelection(pdoc->LineStart(lineNo));
	ShowCaretAtCurrentPosition();
	EnsureCaretVisible();
}

namespace {

bool Close(Point pt1, Point pt2, Point threshold) noexcept {
	const Point ptDifference = pt2 - pt1;
	if (std::abs(ptDifference.x) > threshold.x)
		return false;
	if (std::abs(ptDifference.y) > threshold.y)
		return false;
	return true;
}

constexpr bool AllowVirtualSpace(VirtualSpace virtualSpaceOptions, bool rectangular) noexcept {
	return FlagSet(virtualSpaceOptions, (rectangular ? VirtualSpace::RectangularSelection : VirtualSpace::UserAccessible));
}

}

std::string Editor::RangeText(Sci::Position start, Sci::Position end) const {
	if (start < end) {
		const Sci::Position len = end - start;
		std::string ret(len, '\0');
		pdoc->GetCharRange(ret.data(), start, len);
		return ret;
	}
	return {};
}

bool Editor::CopyLineRange(SelectionText *ss, bool allowProtected) {
	const Sci::Line currentLine = pdoc->SciLineFromPosition(sel.MainCaret());
	const Sci::Position start = pdoc->LineStart(currentLine);
	const Sci::Position end = pdoc->LineEnd(currentLine);

	if (allowProtected || !RangeContainsProtected(start, end)) {
		std::string text = RangeText(start, end);
		text.append(pdoc->EOLString());
		ss->Copy(text, pdoc->dbcsCodePage,
			vs.styles[StyleDefault].characterSet, false, true);
		return true;
	}
	return false;
}

void Editor::CopySelectionRange(SelectionText *ss, bool allowLineCopy) {
	if (sel.Empty()) {
		if (allowLineCopy) {
			CopyLineRange(ss);
		}
	} else {
		std::string text;
		std::vector<SelectionRange> rangesInOrder = sel.RangesCopy();
		if (sel.selType == Selection::SelTypes::rectangle)
			std::sort(rangesInOrder.begin(), rangesInOrder.end());
		const std::string_view separator = (sel.selType == Selection::SelTypes::rectangle) ? pdoc->EOLString() : copySeparator;
		for (size_t part = 0; part < rangesInOrder.size(); part++) {
			text.append(RangeText(rangesInOrder[part].Start().Position(), rangesInOrder[part].End().Position()));
			if ((sel.selType == Selection::SelTypes::rectangle) || (part < rangesInOrder.size() - 1)) {
				// Append unless simple selection or last part of multiple selection
				text.append(separator);
			}
		}
		ss->Copy(text, pdoc->dbcsCodePage,
			vs.styles[StyleDefault].characterSet, sel.IsRectangular(), sel.selType == Selection::SelTypes::lines);
	}
}

void Editor::CopyRangeToClipboard(Sci::Position start, Sci::Position end) {
	start = pdoc->ClampPositionIntoDocument(start);
	end = pdoc->ClampPositionIntoDocument(end);
	SelectionText selectedText;
	std::string text = RangeText(start, end);
	selectedText.Copy(text,
		pdoc->dbcsCodePage, vs.styles[StyleDefault].characterSet, false, false);
	CopyToClipboard(selectedText);
}

void Editor::CopyText(size_t length, const char *text) {
	SelectionText selectedText;
	selectedText.Copy(std::string(text, length),
		pdoc->dbcsCodePage, vs.styles[StyleDefault].characterSet, false, false);
	CopyToClipboard(selectedText);
}

void Editor::SetDragPosition(SelectionPosition newPos) {
	if (newPos.Position() >= 0) {
		newPos = MovePositionOutsideChar(newPos, 1);
		posDrop = newPos;
	}
	if (!(posDrag == newPos)) {
		const CaretPolicies dragCaretPolicies = {
			CaretPolicySlop(CaretPolicy::Slop | CaretPolicy::Strict | CaretPolicy::Even, 50),
			CaretPolicySlop(CaretPolicy::Slop | CaretPolicy::Strict | CaretPolicy::Even, 2)
		};
		MovedCaret(newPos, posDrag, true, dragCaretPolicies);

		caret.on = true;
		FineTickerCancel(TickReason::caret);
		if ((caret.active) && (caret.period > 0) && (newPos.Position() < 0))
			FineTickerStart(TickReason::caret, caret.period, caret.period/10);
		InvalidateCaret();
		posDrag = newPos;
		InvalidateCaret();
	}
}

void Editor::DisplayCursor(Window::Cursor c) {
	if (cursorMode == CursorShape::Normal)
		wMain.SetCursor(c);
	else
		wMain.SetCursor(static_cast<Window::Cursor>(cursorMode));
}

bool Editor::DragThreshold(Point ptStart, Point ptNow) {
	const Point ptDiff = ptStart - ptNow;
	const XYPOSITION distanceSquared = ptDiff.x * ptDiff.x + ptDiff.y * ptDiff.y;
	return distanceSquared > 16.0f;
}

void Editor::StartDrag() {
	// Always handled by subclasses
}

void Editor::DropAt(SelectionPosition position, const char *value, size_t lengthValue, bool moving, bool rectangular) {
	//Platform::DebugPrintf("DropAt %d %d\n", inDragDrop, position);
	if (inDragDrop == DragDrop::dragging)
		dropWentOutside = false;

	const bool positionWasInSelection = PositionInSelection(position.Position());

	const bool positionOnEdgeOfSelection =
	    (position == SelectionStart()) || (position == SelectionEnd());

	if ((inDragDrop != DragDrop::dragging) || !(positionWasInSelection) ||
	        (positionOnEdgeOfSelection && !moving)) {

		const SelectionPosition selStart = SelectionStart();
		const SelectionPosition selEnd = SelectionEnd();

		UndoGroup ug(pdoc);

		SelectionPosition positionAfterDeletion = position;
		if ((inDragDrop == DragDrop::dragging) && moving) {
			// Remove dragged out text
			if (rectangular || sel.selType == Selection::SelTypes::lines) {
				for (size_t r=0; r<sel.Count(); r++) {
					if (position >= sel.Range(r).Start()) {
						if (position > sel.Range(r).End()) {
							positionAfterDeletion.Add(-sel.Range(r).Length());
						} else {
							positionAfterDeletion.Add(-SelectionRange(position, sel.Range(r).Start()).Length());
						}
					}
				}
			} else {
				if (position > selStart) {
					positionAfterDeletion.Add(-SelectionRange(selEnd, selStart).Length());
				}
			}
			ClearSelection();
		}
		position = positionAfterDeletion;

		std::string convertedText = Document::TransformLineEnds(value, lengthValue, pdoc->eolMode);

		if (rectangular) {
			PasteRectangular(position, convertedText.c_str(), convertedText.length());
			// Should try to select new rectangle but it may not be a rectangle now so just select the drop position
			SetEmptySelection(position);
		} else {
			position = MovePositionOutsideChar(position, sel.MainCaret() - position.Position());
			position = RealizeVirtualSpace(position);
			const Sci::Position lengthInserted = pdoc->InsertString(
				position.Position(), convertedText);
			if (lengthInserted > 0) {
				SelectionPosition posAfterInsertion = position;
				posAfterInsertion.Add(lengthInserted);
				SetSelection(posAfterInsertion, position);
			}
		}
	} else if (inDragDrop == DragDrop::dragging) {
		SetEmptySelection(position);
	}
}

void Editor::DropAt(SelectionPosition position, const char *value, bool moving, bool rectangular) {
	DropAt(position, value, strlen(value), moving, rectangular);
}

/**
 * @return true if given position is inside the selection,
 */
bool Editor::PositionInSelection(Sci::Position pos) {
	pos = MovePositionOutsideChar(pos, sel.MainCaret() - pos);
	for (size_t r=0; r<sel.Count(); r++) {
		if (sel.Range(r).Contains(pos))
			return true;
	}
	return false;
}

bool Editor::PointInSelection(Point pt) {
	const SelectionPosition pos = SPositionFromLocation(pt, false, true);
	const Point ptPos = LocationFromPosition(pos);
	for (size_t r=0; r<sel.Count(); r++) {
		const SelectionRange &range = sel.Range(r);
		if (range.Contains(pos)) {
			bool hit = true;
			if (pos == range.Start()) {
				// see if just before selection
				if (pt.x < ptPos.x) {
					hit = false;
				}
			}
			if (pos == range.End()) {
				// see if just after selection
				if (pt.x > ptPos.x) {
					hit = false;
				}
			}
			if (hit)
				return true;
		}
	}
	return false;
}

ptrdiff_t Editor::SelectionFromPoint(Point pt) {
	// Prioritize checking inside non-empty selections since each character will be inside only 1
	const SelectionPosition posChar = SPositionFromLocation(pt, true, true);
	for (size_t r = 0; r < sel.Count(); r++) {
		if (sel.Range(r).ContainsCharacter(posChar)) {
			return r;
		}
	}

	// Then check if near empty selections as may be near more than 1
	const SelectionPosition pos = SPositionFromLocation(pt, true, false);
	for (size_t r = 0; r < sel.Count(); r++) {
		const SelectionRange &range = sel.Range(r);
		if ((range.Empty()) && (pos == range.caret)) {
			return r;
		}
	}

	// No selection at point
	return -1;
}

bool Editor::PointInSelMargin(Point pt) const {
	// Really means: "Point in a margin"
	if (vs.fixedColumnWidth > 0) {	// There is a margin
		PRectangle rcSelMargin = GetClientRectangle();
		rcSelMargin.right = static_cast<XYPOSITION>(vs.textStart - vs.leftMarginWidth);
		rcSelMargin.left = static_cast<XYPOSITION>(vs.textStart - vs.fixedColumnWidth);
		const Point ptOrigin = GetVisibleOriginInMain();
		rcSelMargin.Move(0, -ptOrigin.y);
		return rcSelMargin.ContainsWholePixel(pt);
	}
	return false;
}

Window::Cursor Editor::GetMarginCursor(Point pt) const noexcept {
	int x = 0;
	for (const MarginStyle &m : vs.ms) {
		if ((pt.x >= x) && (pt.x < x + m.width))
			return static_cast<Window::Cursor>(m.cursor);
		x += m.width;
	}
	return Window::Cursor::reverseArrow;
}

void Editor::DropSelection(size_t part) {
	sel.DropSelection(part);
	ContainerNeedsUpdate(Update::Selection);
	Redraw();
}

void Editor::TrimAndSetSelection(Sci::Position currentPos_, Sci::Position anchor_) {
	sel.TrimSelection(SelectionRange(currentPos_, anchor_));
	SetSelection(currentPos_, anchor_);
}

void Editor::LineSelection(Sci::Position lineCurrentPos_, Sci::Position lineAnchorPos_, bool wholeLine) {
	Sci::Position selCurrentPos;
	Sci::Position selAnchorPos;
	if (wholeLine) {
		//Au: if the last selected line is a fold-point, add hidden lines after it to the selection.
		Sci::Line lineCurrent_ = pdoc->SciLineFromPosition(lineCurrentPos_);
		Sci::Line lineAnchor_ = pdoc->SciLineFromPosition(lineAnchorPos_);
		if(lineAnchorPos_ > lineCurrentPos_) {
			lineAnchor_++;
		} else {
			while(!pcs->GetVisible(++lineCurrent_)) { }
		}
		selCurrentPos = pdoc->LineStart(lineCurrent_);
		selAnchorPos = pdoc->LineStart(lineAnchor_);

		//const Sci::Line lineCurrent_ = pdoc->SciLineFromPosition(lineCurrentPos_);
		//const Sci::Line lineAnchor_ = pdoc->SciLineFromPosition(lineAnchorPos_);
		//if (lineAnchorPos_ < lineCurrentPos_) {
		//	selCurrentPos = pdoc->LineStart(lineCurrent_ + 1);
		//	selAnchorPos = pdoc->LineStart(lineAnchor_);
		//} else if (lineAnchorPos_ > lineCurrentPos_) {
		//	selCurrentPos = pdoc->LineStart(lineCurrent_);
		//	selAnchorPos = pdoc->LineStart(lineAnchor_ + 1);
		//} else { // Same line, select it
		//	selCurrentPos = pdoc->LineStart(lineAnchor_ + 1);
		//	selAnchorPos = pdoc->LineStart(lineAnchor_);
		//}
	} else {
		if (lineAnchorPos_ < lineCurrentPos_) {
			selCurrentPos = StartEndDisplayLine(lineCurrentPos_, false) + 1;
			selCurrentPos = pdoc->MovePositionOutsideChar(selCurrentPos, 1);
			selAnchorPos = StartEndDisplayLine(lineAnchorPos_, true);
		} else if (lineAnchorPos_ > lineCurrentPos_) {
			selCurrentPos = StartEndDisplayLine(lineCurrentPos_, true);
			selAnchorPos = StartEndDisplayLine(lineAnchorPos_, false) + 1;
			selAnchorPos = pdoc->MovePositionOutsideChar(selAnchorPos, 1);
		} else { // Same line, select it
			selCurrentPos = StartEndDisplayLine(lineAnchorPos_, false) + 1;
			selCurrentPos = pdoc->MovePositionOutsideChar(selCurrentPos, 1);
			selAnchorPos = StartEndDisplayLine(lineAnchorPos_, true);
		}
	}
	TrimAndSetSelection(selCurrentPos, selAnchorPos);
}

void Editor::WordSelection(Sci::Position pos) {
	if (pos < wordSelectAnchorStartPos) {
		// Extend backward to the word containing pos.
		// Skip ExtendWordSelect if the line is empty or if pos is after the last character.
		// This ensures that a series of empty lines isn't counted as a single "word".
		if (!pdoc->IsLineEndPosition(pos))
			pos = pdoc->ExtendWordSelect(pdoc->MovePositionOutsideChar(pos + 1, 1), -1);
		TrimAndSetSelection(pos, wordSelectAnchorEndPos);
	} else if (pos > wordSelectAnchorEndPos) {
		// Extend forward to the word containing the character to the left of pos.
		// Skip ExtendWordSelect if the line is empty or if pos is the first position on the line.
		// This ensures that a series of empty lines isn't counted as a single "word".
		if (pos > pdoc->LineStartPosition(pos))
			pos = pdoc->ExtendWordSelect(pdoc->MovePositionOutsideChar(pos - 1, -1), 1);
		TrimAndSetSelection(pos, wordSelectAnchorStartPos);
	} else {
		// Select only the anchored word
		if (pos >= originalAnchorPos)
			TrimAndSetSelection(wordSelectAnchorEndPos, wordSelectAnchorStartPos);
		else
			TrimAndSetSelection(wordSelectAnchorStartPos, wordSelectAnchorEndPos);
	}
}

void Editor::DwellEnd(bool mouseMoved) {
	if (mouseMoved)
		ticksToDwell = dwellDelay;
	else
		ticksToDwell = TimeForever;
	if (dwelling && (dwellDelay < TimeForever)) {
		dwelling = false;
		NotifyDwelling(ptMouseLast, dwelling);
	}
	FineTickerCancel(TickReason::dwell);
}

void Editor::MouseLeave() {
	SetHotSpotRange(nullptr);
	SetHoverIndicatorPosition(Sci::invalidPosition);
	if (!HaveMouseCapture()) {
		ptMouseLast = Point(-1, -1);
		DwellEnd(true);
	}
}

void Editor::ButtonDownWithModifiers(Point pt, unsigned int curTime, KeyMod modifiers) {
	SetHoverIndicatorPoint(pt);
	//Platform::DebugPrintf("ButtonDown %d %d = %d alt=%d %d\n", curTime, lastClickTime, curTime - lastClickTime, alt, inDragDrop);
	ptMouseLast = pt;
	const bool ctrl = FlagSet(modifiers, KeyMod::Ctrl);
	const bool shift = FlagSet(modifiers, KeyMod::Shift);
	const bool alt = FlagSet(modifiers, KeyMod::Alt);
	const SelectionPosition clickPos = SPositionFromLocation(pt, false, false, AllowVirtualSpace(virtualSpaceOptions, alt));
	const SelectionPosition newPos = MovePositionOutsideChar(clickPos, sel.MainCaret() - clickPos.Position());
	const SelectionPosition newCharPos = MovePositionOutsideChar(
		SPositionFromLocation(pt, false, true, false), -1);
	inDragDrop = DragDrop::none;
	sel.SetMoveExtends(false);

	if (NotifyMarginClick(pt, modifiers))
		return;

	NotifyIndicatorClick(true, newPos.Position(), modifiers);

	const bool multiClick = (curTime < (lastClickTime + Platform::DoubleClickTime())) && Close(pt, lastClick, doubleClickCloseThreshold);
	lastClickTime = curTime;
	lastClick = pt;

	const bool inSelMargin = PointInSelMargin(pt);
	
	//Au: commented out. In the future LA may use Ctrl+click for multiple selections.
	//// In margin ctrl+(double)click should always select everything
	//if (ctrl && inSelMargin) {
	//	SelectAll();
	//	return;
	//}
	
	if (shift && !inSelMargin) {
		SetSelection(newPos);
	}
	if (multiClick) {
		//Platform::DebugPrintf("Double click %d %d = %d\n", curTime, lastClickTime, curTime - lastClickTime);
		ChangeMouseCapture(true);
		if (!ctrl || !multipleSelection || (selectionUnit != TextUnit::character && selectionUnit != TextUnit::word))
			SetEmptySelection(newPos.Position());
		bool doubleClick = false;
		if (inSelMargin) {
			// Inside margin selection type should be either subLine or wholeLine.
			if (selectionUnit == TextUnit::subLine) {
				// If it is subLine, we're inside a *double* click and word wrap is enabled,
				// so we switch to wholeLine in order to select whole line.
				selectionUnit = TextUnit::wholeLine;
			} else if (selectionUnit != TextUnit::subLine && selectionUnit != TextUnit::wholeLine) {
				// If it is neither, reset selection type to line selection.
				selectionUnit = (Wrapping() && (FlagSet(marginOptions, MarginOption::SubLineSelect))) ? TextUnit::subLine : TextUnit::wholeLine;
			}
		} else {
			if (selectionUnit == TextUnit::character) {
				selectionUnit = TextUnit::word;
				doubleClick = true;
			} else if (selectionUnit == TextUnit::word) {
				// Since we ended up here, we're inside a *triple* click, which should always select
				// whole line regardless of word wrap being enabled or not.
				selectionUnit = TextUnit::wholeLine;
			} else {
				selectionUnit = TextUnit::character;
				originalAnchorPos = sel.MainCaret();
			}
		}

		if (selectionUnit == TextUnit::word) {
			Sci::Position charPos = originalAnchorPos;
			if (sel.MainCaret() == originalAnchorPos) {
				charPos = PositionFromLocation(pt, false, true);
				charPos = MovePositionOutsideChar(charPos, -1);
			}

			Sci::Position startWord;
			Sci::Position endWord;
			if ((sel.MainCaret() >= originalAnchorPos) && !pdoc->IsLineEndPosition(charPos)) {
				startWord = pdoc->ExtendWordSelect(pdoc->MovePositionOutsideChar(charPos + 1, 1), -1);
				endWord = pdoc->ExtendWordSelect(charPos, 1);
			} else {
				// Selecting backwards, or anchor beyond last character on line. In these cases,
				// we select the word containing the character to the *left* of the anchor.
				if (charPos > pdoc->LineStartPosition(charPos)) {
					startWord = pdoc->ExtendWordSelect(charPos, -1);
					endWord = pdoc->ExtendWordSelect(startWord, 1);
				} else {
					// Anchor at start of line; select nothing to begin with.
					startWord = charPos;
					endWord = charPos;
				}
			}

			wordSelectAnchorStartPos = startWord;
			wordSelectAnchorEndPos = endWord;
			wordSelectInitialCaretPos = sel.MainCaret();
			WordSelection(wordSelectInitialCaretPos);
		} else if (selectionUnit == TextUnit::subLine || selectionUnit == TextUnit::wholeLine) {
			lineAnchorPos = newPos.Position();
			LineSelection(lineAnchorPos, lineAnchorPos, selectionUnit == TextUnit::wholeLine);
			//Platform::DebugPrintf("Triple click: %d - %d\n", anchor, currentPos);
		} else {
			SetEmptySelection(sel.MainCaret());
		}
		//Platform::DebugPrintf("Double click: %d - %d\n", anchor, currentPos);
		if (doubleClick) {
			NotifyDoubleClick(pt, modifiers);
			if (PositionIsHotspot(newCharPos.Position()))
				NotifyHotSpotDoubleClicked(newCharPos.Position(), modifiers);
		}
	} else {	// Single click
		if (inSelMargin) {
			if (sel.IsRectangular() || (sel.Count() > 1)) {
				InvalidateWholeSelection();
				sel.Clear();
			}
			sel.selType = Selection::SelTypes::stream;
			if (!shift) {
				// Single click in margin: select wholeLine or only subLine if word wrap is enabled
				lineAnchorPos = newPos.Position();

				//Au: let Ctrl+click add line to multiple selections.
				if(ctrl && multipleSelection && !sel.Empty())
					sel.AddSelection(SelectionRange(lineAnchorPos, lineAnchorPos));

				selectionUnit = (Wrapping() && (FlagSet(marginOptions, MarginOption::SubLineSelect))) ? TextUnit::subLine : TextUnit::wholeLine;
				LineSelection(lineAnchorPos, lineAnchorPos, selectionUnit == TextUnit::wholeLine);
			} else {
				// Single shift+click in margin: select from line anchor to clicked line
				if (sel.MainAnchor() > sel.MainCaret())
					lineAnchorPos = sel.MainAnchor() - 1;
				else
					lineAnchorPos = sel.MainAnchor();
				// Reset selection type if there is an empty selection.
				// This ensures that we don't end up stuck in previous selection mode, which is no longer valid.
				// Otherwise, if there's a non empty selection, reset selection type only if it differs from selSubLine and selWholeLine.
				// This ensures that we continue selecting in the same selection mode.
				if (sel.Empty() || (selectionUnit != TextUnit::subLine && selectionUnit != TextUnit::wholeLine))
					selectionUnit = (Wrapping() && (FlagSet(marginOptions, MarginOption::SubLineSelect))) ? TextUnit::subLine : TextUnit::wholeLine;
				LineSelection(newPos.Position(), lineAnchorPos, selectionUnit == TextUnit::wholeLine);
			}

			SetDragPosition(SelectionPosition(Sci::invalidPosition));
			ChangeMouseCapture(true);
		} else {
			if (PointIsHotspot(pt)) {
				NotifyHotSpotClicked(newCharPos.Position(), modifiers);
				hotSpotClickPos = newCharPos.Position();
			}
			if (!shift) {
				const ptrdiff_t selectionPart = SelectionFromPoint(pt);
				if (selectionPart >= 0) {
					if (multipleSelection && ctrl) {
						// Deselect
						if (sel.Count() > 1) {
							DropSelection(selectionPart);
							// Completed: don't want any more processing of this click
							return;
						}
						// Switch to just the click position
						SetSelection(newPos, newPos);
					}
					if (!sel.Range(selectionPart).Empty()) {
						inDragDrop = DragDrop::initial;
					}
				}
			}
			ChangeMouseCapture(true);
			if (inDragDrop != DragDrop::initial) {
				SetDragPosition(SelectionPosition(Sci::invalidPosition));
				if (!shift) {
					if (ctrl && multipleSelection) {
						const SelectionRange range(newPos);
						sel.TentativeSelection(range);
						InvalidateSelection(range, true);
					} else {
						InvalidateSelection(SelectionRange(newPos), true);
						if (sel.Count() > 1)
							Redraw();
						if ((sel.Count() > 1) || (sel.selType != Selection::SelTypes::stream))
							sel.Clear();
						sel.selType = alt ? Selection::SelTypes::rectangle : Selection::SelTypes::stream;
						SetSelection(newPos, newPos);
					}
				}
				SelectionPosition anchorCurrent = newPos;
				if (shift)
					anchorCurrent = sel.IsRectangular() ?
						sel.Rectangular().anchor : sel.RangeMain().anchor;
				sel.selType = alt ? Selection::SelTypes::rectangle : Selection::SelTypes::stream;
				selectionUnit = TextUnit::character;
				originalAnchorPos = sel.MainCaret();
				sel.Rectangular() = SelectionRange(newPos, anchorCurrent);
				SetRectangularRange();
			}
		}
	}
	lastXChosen = static_cast<int>(pt.x) + xOffset;
	ShowCaretAtCurrentPosition();
}

void Editor::RightButtonDownWithModifiers(Point pt, unsigned int, KeyMod modifiers) {
	if (NotifyMarginRightClick(pt, modifiers))
		return;
}

bool Editor::PositionIsHotspot(Sci::Position position) const noexcept {
	return vs.styles[pdoc->StyleIndexAt(position)].hotspot;
}

bool Editor::PointIsHotspot(Point pt) {
	const Sci::Position pos = PositionFromLocation(pt, true, true);
	if (pos == Sci::invalidPosition)
		return false;
	return PositionIsHotspot(pos);
}

void Editor::SetHoverIndicatorPosition(Sci::Position position) {
	const Sci::Position hoverIndicatorPosPrev = hoverIndicatorPos;
	hoverIndicatorPos = Sci::invalidPosition;
	if (!vs.indicatorsDynamic)
		return;
	if (position != Sci::invalidPosition) {
		for (const IDecoration *deco : pdoc->decorations->View()) {
			if (vs.indicators[deco->Indicator()].IsDynamic()) {
				if (pdoc->decorations->ValueAt(deco->Indicator(), position)) {
					hoverIndicatorPos = position;
				}
			}
		}
	}
	if (hoverIndicatorPosPrev != hoverIndicatorPos) {
		Redraw();
	}
}

void Editor::SetHoverIndicatorPoint(Point pt) {
	if (!vs.indicatorsDynamic) {
		SetHoverIndicatorPosition(Sci::invalidPosition);
	} else {
		//Au: bug fix: the hover style/cursor is not shown when mouse is 1 pixel before the indicator (but SCN_INDICATORx sent), and shown when mouse is 1-2 pixels after the indicator (but SCN_INDICATORx not sent).
		SetHoverIndicatorPosition(PositionFromLocation(pt, true, false));
		//SetHoverIndicatorPosition(PositionFromLocation(pt, true, true));
	}
}

void Editor::SetHotSpotRange(const Point *pt) {
	if (pt) {
		const Sci::Position pos = PositionFromLocation(*pt, false, true);

		// If we don't limit this to word characters then the
		// range can encompass more than the run range and then
		// the underline will not be drawn properly.
		Range hsNew;
		hsNew.start = pdoc->ExtendStyleRange(pos, -1, hotspotSingleLine);
		hsNew.end = pdoc->ExtendStyleRange(pos, 1, hotspotSingleLine);

		// Only invalidate the range if the hotspot range has changed...
		if (!(hsNew == hotspot)) {
			if (hotspot.Valid()) {
				InvalidateRange(hotspot.start, hotspot.end);
			}
			hotspot = hsNew;
			InvalidateRange(hotspot.start, hotspot.end);
		}
	} else {
		if (hotspot.Valid()) {
			InvalidateRange(hotspot.start, hotspot.end);
		}
		hotspot = Range(Sci::invalidPosition);
	}
}

void Editor::ButtonMoveWithModifiers(Point pt, unsigned int, KeyMod modifiers) {
	if (ptMouseLast != pt) {
		DwellEnd(true);
	}

	SelectionPosition movePos = SPositionFromLocation(pt, false, false,
		AllowVirtualSpace(virtualSpaceOptions, sel.IsRectangular()));
	movePos = MovePositionOutsideChar(movePos, sel.MainCaret() - movePos.Position());

	if (inDragDrop == DragDrop::initial) {
		if (DragThreshold(ptMouseLast, pt)) {
			ChangeMouseCapture(false);
			SetDragPosition(movePos);
			CopySelectionRange(&drag);
			StartDrag();
		}
		return;
	}

	ptMouseLast = pt;
	PRectangle rcClient = GetClientRectangle();
	const Point ptOrigin = GetVisibleOriginInMain();
	rcClient.Move(0, -ptOrigin.y);
	if ((dwellDelay < TimeForever) && rcClient.Contains(pt)) {
		FineTickerStart(TickReason::dwell, dwellDelay, dwellDelay/10);
	}
	//Platform::DebugPrintf("Move %d %d\n", pt.x, pt.y);
	if (HaveMouseCapture()) {

		// Slow down autoscrolling/selection
		autoScrollTimer.ticksToWait -= timer.tickSize;
		if (autoScrollTimer.ticksToWait > 0)
			return;
		autoScrollTimer.ticksToWait = autoScrollDelay;

		// Adjust selection
		if (posDrag.IsValid()) {
			SetDragPosition(movePos);
		} else {
			if (selectionUnit == TextUnit::character) {
				if (sel.selType == Selection::SelTypes::stream && FlagSet(modifiers, KeyMod::Alt) && mouseSelectionRectangularSwitch) {
					sel.selType = Selection::SelTypes::rectangle;
				}
				if (sel.IsRectangular()) {
					sel.Rectangular() = SelectionRange(movePos, sel.Rectangular().anchor);
					SetSelection(movePos, sel.RangeMain().anchor);
				} else if (sel.Count() > 1) {
					InvalidateSelection(sel.RangeMain(), false);
					const SelectionRange range(movePos, sel.RangeMain().anchor);
					sel.TentativeSelection(range);
					InvalidateSelection(range, true);
				} else {
					SetSelection(movePos, sel.RangeMain().anchor);
				}
			} else if (selectionUnit == TextUnit::word) {
				// Continue selecting by word
				if (movePos.Position() == wordSelectInitialCaretPos) {  // Didn't move
					// No need to do anything. Previously this case was lumped
					// in with "Moved forward", but that can be harmful in this
					// case: a handler for the NotifyDoubleClick re-adjusts
					// the selection for a fancier definition of "word" (for
					// example, in Perl it is useful to include the leading
					// '$', '%' or '@' on variables for word selection). In this
					// the ButtonMove() called via TickFor() for auto-scrolling
					// could result in the fancier word selection adjustment
					// being unmade.
				} else {
					wordSelectInitialCaretPos = -1;
					WordSelection(movePos.Position());
				}
			} else {
				// Continue selecting by line
				LineSelection(movePos.Position(), lineAnchorPos, selectionUnit == TextUnit::wholeLine);
			}
		}

		// Autoscroll
		const Sci::Line lineMove = DisplayFromPosition(movePos.Position());
		if (pt.y >= rcClient.bottom) {
			ScrollTo(lineMove - LinesOnScreen() + 1);
			Redraw();
		} else if (pt.y < rcClient.top) {
			ScrollTo(lineMove);
			Redraw();
		}
		EnsureCaretVisible(false, false, true);

		if (hotspot.Valid() && !PointIsHotspot(pt))
			SetHotSpotRange(nullptr);

		if (hotSpotClickPos != Sci::invalidPosition && PositionFromLocation(pt, true, true) != hotSpotClickPos) {
			if (inDragDrop == DragDrop::none) {
				DisplayCursor(Window::Cursor::text);
			}
			hotSpotClickPos = Sci::invalidPosition;
		}

	} else {
		if (vs.fixedColumnWidth > 0) {	// There is a margin
			if (PointInSelMargin(pt)) {
				DisplayCursor(GetMarginCursor(pt));
				SetHotSpotRange(nullptr);
				SetHoverIndicatorPosition(Sci::invalidPosition);
				return; 	// No need to test for selection
			}
		}
		// Display regular (drag) cursor over selection
		if (PointInSelection(pt) && !SelectionEmpty()) {
			DisplayCursor(Window::Cursor::arrow);
			SetHoverIndicatorPosition(Sci::invalidPosition);
		} else {
			SetHoverIndicatorPoint(pt);
			if (PointIsHotspot(pt)) {
				DisplayCursor(Window::Cursor::hand);
				SetHotSpotRange(&pt);
			} else {
				if (hoverIndicatorPos != Sci::invalidPosition)
					DisplayCursor(Window::Cursor::hand);
				else
					DisplayCursor(Window::Cursor::text);
				SetHotSpotRange(nullptr);
			}
		}
	}
}

void Editor::ButtonUpWithModifiers(Point pt, unsigned int curTime, KeyMod modifiers) {
	//Platform::DebugPrintf("ButtonUp %d %d\n", HaveMouseCapture(), inDragDrop);
	SelectionPosition newPos = SPositionFromLocation(pt, false, false,
		AllowVirtualSpace(virtualSpaceOptions, sel.IsRectangular()));
	if (hoverIndicatorPos != Sci::invalidPosition)
		InvalidateRange(newPos.Position(), newPos.Position() + 1);
	newPos = MovePositionOutsideChar(newPos, sel.MainCaret() - newPos.Position());
	if (inDragDrop == DragDrop::initial) {
		inDragDrop = DragDrop::none;
		SetEmptySelection(newPos);
		selectionUnit = TextUnit::character;
		originalAnchorPos = sel.MainCaret();
	}
	if (hotSpotClickPos != Sci::invalidPosition && PointIsHotspot(pt)) {
		hotSpotClickPos = Sci::invalidPosition;
		SelectionPosition newCharPos = SPositionFromLocation(pt, false, true, false);
		newCharPos = MovePositionOutsideChar(newCharPos, -1);
		NotifyHotSpotReleaseClick(newCharPos.Position(), modifiers & KeyMod::Ctrl);
	}
	if (HaveMouseCapture()) {
		if (PointInSelMargin(pt)) {
			DisplayCursor(GetMarginCursor(pt));
		} else {
			DisplayCursor(Window::Cursor::text);
			SetHotSpotRange(nullptr);
		}
		ptMouseLast = pt;
		ChangeMouseCapture(false);
		NotifyIndicatorClick(false, newPos.Position(), modifiers);
		if (inDragDrop == DragDrop::dragging) {
			const SelectionPosition selStart = SelectionStart();
			const SelectionPosition selEnd = SelectionEnd();
			if (selStart < selEnd) {
				if (drag.Length()) {
					const Sci::Position length = drag.Length();
					if (FlagSet(modifiers, KeyMod::Ctrl)) {
						const Sci::Position lengthInserted = pdoc->InsertString(
							newPos.Position(), drag.Data(), length);
						if (lengthInserted > 0) {
							SetSelection(newPos.Position(), newPos.Position() + lengthInserted);
						}
					} else if (newPos < selStart) {
						pdoc->DeleteChars(selStart.Position(), drag.Length());
						const Sci::Position lengthInserted = pdoc->InsertString(
							newPos.Position(), drag.Data(), length);
						if (lengthInserted > 0) {
							SetSelection(newPos.Position(), newPos.Position() + lengthInserted);
						}
					} else if (newPos > selEnd) {
						pdoc->DeleteChars(selStart.Position(), drag.Length());
						newPos.Add(-static_cast<Sci::Position>(drag.Length()));
						const Sci::Position lengthInserted = pdoc->InsertString(
							newPos.Position(), drag.Data(), length);
						if (lengthInserted > 0) {
							SetSelection(newPos.Position(), newPos.Position() + lengthInserted);
						}
					} else {
						SetEmptySelection(newPos.Position());
					}
					drag.Clear();
				}
				selectionUnit = TextUnit::character;
			}
		} else {
			if (selectionUnit == TextUnit::character) {
				if (sel.Count() > 1) {
					sel.RangeMain() =
						SelectionRange(newPos, sel.Range(sel.Count() - 1).anchor);
					InvalidateWholeSelection();
				} else {
					SetSelection(newPos, sel.RangeMain().anchor);
				}
			}
			sel.CommitTentative();
		}
		SetRectangularRange();
		lastClickTime = curTime;
		lastClick = pt;
		lastXChosen = static_cast<int>(pt.x) + xOffset;
		if (sel.selType == Selection::SelTypes::stream) {
			SetLastXChosen();
		}
		inDragDrop = DragDrop::none;
		EnsureCaretVisible(false);
	}
}

bool Editor::Idle() {
	NotifyUpdateUI();

	bool needWrap = Wrapping() && wrapPending.NeedsWrap();

	if (needWrap) {
		// Wrap lines during idle.
		WrapLines(WrapScope::wsIdle);
		// No more wrapping
		needWrap = wrapPending.NeedsWrap();
	} else if (needIdleStyling) {
		IdleStyle();
	}

	// Add more idle things to do here, but make sure idleDone is
	// set correctly before the function returns. returning
	// false will stop calling this idle function until SetIdle() is
	// called again.

	const bool idleDone = !needWrap && !needIdleStyling; // && thatDone && theOtherThingDone...

	return !idleDone;
}

void Editor::TickFor(TickReason reason) {
	switch (reason) {
		case TickReason::caret:
			caret.on = !caret.on;
			if (caret.active) {
				InvalidateCaret();
			}
			break;
		case TickReason::scroll:
			// Auto scroll
			if (HaveMouseCapture()) {
				ButtonMoveWithModifiers(ptMouseLast, 0, KeyMod::Norm);
			} else {
				// Capture cancelled so cancel timer
				FineTickerCancel(TickReason::scroll);
			}
			break;
		case TickReason::widen:
			SetScrollBars();
			FineTickerCancel(TickReason::widen);
			break;
		case TickReason::dwell:
			if ((!HaveMouseCapture()) &&
				(ptMouseLast.y >= 0)) {
				dwelling = true;
				NotifyDwelling(ptMouseLast, dwelling);
			}
			FineTickerCancel(TickReason::dwell);
			break;
		default:
			// tickPlatform handled by subclass
			break;
	}
}

// FineTickerStart is be overridden by subclasses that support fine ticking so
// this method should never be called.
bool Editor::FineTickerRunning(TickReason) {
	assert(false);
	return false;
}

// FineTickerStart is be overridden by subclasses that support fine ticking so
// this method should never be called.
void Editor::FineTickerStart(TickReason, int, int) {
	assert(false);
}

// FineTickerCancel is be overridden by subclasses that support fine ticking so
// this method should never be called.
void Editor::FineTickerCancel(TickReason) {
	assert(false);
}

void Editor::ChangeMouseCapture(bool on) {
	SetMouseCapture(on);
	// While mouse captured want timer to scroll automatically
	if (on) {
		FineTickerStart(TickReason::scroll, 100, 10);
	} else {
		FineTickerCancel(TickReason::scroll);
	}
}

void Editor::SetFocusState(bool focusState) {
	const bool changing = hasFocus != focusState;
	hasFocus = focusState;
	if (changing) {
		Redraw();
	}
	NotifyFocus(hasFocus);
	if (!hasFocus) {
		CancelModes();
	}
	ShowCaretAtCurrentPosition();
}

void Editor::UpdateBaseElements() {
	// Overridden by subclasses
}

Sci::Position Editor::PositionAfterArea(PRectangle rcArea) const {
	// The start of the document line after the display line after the area
	// This often means that the line after a modification is restyled which helps
	// detect multiline comment additions and heals single line comments
	const Sci::Line lineAfter = TopLineOfMain() + static_cast<Sci::Line>(rcArea.bottom - 1) / vs.lineHeight + 1;
	if (lineAfter < pcs->LinesDisplayed()) {
		return pdoc->LineStart(pcs->DocFromDisplay(lineAfter) + 1);
	}
	return pdoc->Length();
}

// Style to a position within the view. If this causes a change at end of last line then
// affects later lines so style all the viewed text.
void Editor::StyleToPositionInView(Sci::Position pos) {
	Sci::Position endWindow = PositionAfterArea(GetClientDrawingRectangle());
	if (pos > endWindow)
		pos = endWindow;
	const int styleAtEnd = pdoc->StyleIndexAt(pos-1);
	pdoc->EnsureStyledTo(pos);
	if ((endWindow > pos) && (styleAtEnd != pdoc->StyleIndexAt(pos-1))) {
		// Style at end of line changed so is multi-line change like starting a comment
		// so require rest of window to be styled.
		DiscardOverdraw();	// Prepared bitmaps may be invalid
		// DiscardOverdraw may have truncated client drawing area so recalculate endWindow
		endWindow = PositionAfterArea(GetClientDrawingRectangle());
		pdoc->EnsureStyledTo(endWindow);
	}
}

Sci::Position Editor::PositionAfterMaxStyling(Sci::Position posMax, bool scrolling) const {
	if (SynchronousStylingToVisible()) {
		// Both states do not limit styling
		return posMax;
	}

	// Try to keep time taken by styling reasonable so interaction remains smooth.
	// When scrolling, allow less time to ensure responsive
	const double secondsAllowed = scrolling ? 0.005 : 0.02;

	const size_t actionsInAllowedTime = std::clamp<Sci::Line>(
		pdoc->durationStyleOneByte.ActionsInAllowedTime(secondsAllowed),
		0x200, 0x20000);
	const Sci::Line lineLast = pdoc->LineFromPositionAfter(pdoc->SciLineFromPosition(pdoc->GetEndStyled()), actionsInAllowedTime);
	const Sci::Line stylingMaxLine = std::min(lineLast, pdoc->LinesTotal());

	return std::min(pdoc->LineStart(stylingMaxLine), posMax);
}

void Editor::StartIdleStyling(bool truncatedLastStyling) {
	if ((idleStyling == IdleStyling::All) || (idleStyling == IdleStyling::AfterVisible)) {
		if (pdoc->GetEndStyled() < pdoc->Length()) {
			// Style remainder of document in idle time
			needIdleStyling = true;
		}
	} else if (truncatedLastStyling) {
		needIdleStyling = true;
	}

	if (needIdleStyling) {
		SetIdle(true);
	}
}

// Style for an area but bound the amount of styling to remain responsive
void Editor::StyleAreaBounded(PRectangle rcArea, bool scrolling) {
	const Sci::Position posAfterArea = PositionAfterArea(rcArea);
	const Sci::Position posAfterMax = PositionAfterMaxStyling(posAfterArea, scrolling);
	if (posAfterMax < posAfterArea) {
		// Idle styling may be performed before current visible area
		// Style a bit now then style further in idle time
		pdoc->StyleToAdjustingLineDuration(posAfterMax);
	} else {
		// Can style all wanted now.
		StyleToPositionInView(posAfterArea);
	}
	StartIdleStyling(posAfterMax < posAfterArea);
}

void Editor::IdleStyle() {
	const Sci::Position posAfterArea = PositionAfterArea(GetClientRectangle());
	const Sci::Position endGoal = (idleStyling >= IdleStyling::AfterVisible) ?
		pdoc->Length() : posAfterArea;
	const Sci::Position posAfterMax = PositionAfterMaxStyling(endGoal, false);
	pdoc->StyleToAdjustingLineDuration(posAfterMax);
	if (pdoc->GetEndStyled() >= endGoal) {
		needIdleStyling = false;
	}
}

void Editor::IdleWork() {
	// Style the line after the modification as this allows modifications that change just the
	// line of the modification to heal instead of propagating to the rest of the window.
	if (FlagSet(workNeeded.items, WorkItems::style)) {
		StyleToPositionInView(pdoc->LineStart(pdoc->LineFromPosition(workNeeded.upTo) + 2));
	}
	NotifyUpdateUI();
	workNeeded.Reset();
}

void Editor::QueueIdleWork(WorkItems items, Sci::Position upTo) {
	workNeeded.Need(items, upTo);
}

int Editor::SupportsFeature(Supports feature) {
	AutoSurface surface(this);
	return surface->SupportsFeature(feature);
}

bool Editor::PaintContains(PRectangle rc) {
	if (rc.Empty()) {
		return true;
	}
	return rcPaint.Contains(rc);
}

bool Editor::PaintContainsMargin() {
	if (HasMarginWindow()) {
		// With separate margin view, paint of text view
		// never contains margin.
		return false;
	}
	PRectangle rcSelMargin = GetClientRectangle();
	rcSelMargin.right = static_cast<XYPOSITION>(vs.textStart);
	return PaintContains(rcSelMargin);
}

void Editor::CheckForChangeOutsidePaint(Range r) {
	if (paintState == PaintState::painting && !paintingAllText) {
		//Platform::DebugPrintf("Checking range in paint %d-%d\n", r.start, r.end);
		if (!r.Valid())
			return;

		PRectangle rcRange = RectangleFromRange(r, 0);
		const PRectangle rcText = GetTextRectangle();
		if (rcRange.top < rcText.top) {
			rcRange.top = rcText.top;
		}
		if (rcRange.bottom > rcText.bottom) {
			rcRange.bottom = rcText.bottom;
		}

		if (!PaintContains(rcRange)) {
			AbandonPaint();
			paintAbandonedByStyling = true;
		}
	}
}

void Editor::SetBraceHighlight(Sci::Position pos0, Sci::Position pos1, int matchStyle) {
	if ((pos0 != braces[0]) || (pos1 != braces[1]) || (matchStyle != bracesMatchStyle)) {
		if ((braces[0] != pos0) || (matchStyle != bracesMatchStyle)) {
			CheckForChangeOutsidePaint(Range(braces[0]));
			CheckForChangeOutsidePaint(Range(pos0));
			braces[0] = pos0;
		}
		if ((braces[1] != pos1) || (matchStyle != bracesMatchStyle)) {
			CheckForChangeOutsidePaint(Range(braces[1]));
			CheckForChangeOutsidePaint(Range(pos1));
			braces[1] = pos1;
		}
		bracesMatchStyle = matchStyle;
		if (paintState == PaintState::notPainting) {
			Redraw();
		}
	}
}

void Editor::SetAnnotationHeights(Sci::Line start, Sci::Line end) {
	if (vs.annotationVisible != AnnotationVisible::Hidden) {
		RefreshStyleData();
		bool changedHeight = false;
		for (Sci::Line line=start; line<end && line<pdoc->LinesTotal(); line++) {
			int linesWrapped = 1;
			if (Wrapping()) {
				AutoSurface surface(this);
				std::shared_ptr<LineLayout> ll = view.RetrieveLineLayout(line, *this);
				if (surface && ll) {
					view.LayoutLine(*this, surface, vs, ll.get(), wrapWidth);
					linesWrapped = ll->lines;
				}
			}
			if (pcs->SetHeight(line, pdoc->AnnotationLines(line) + linesWrapped))
				changedHeight = true;
		}
		if (changedHeight) {
			SetScrollBars();
			SetVerticalScrollPos();
			Redraw();
		}
	}
}

void Editor::SetDocPointer(Document *document) {
	//Platform::DebugPrintf("** %x setdoc to %x\n", pdoc, document);
	pdoc->RemoveWatcher(this, nullptr);
	pdoc->Release();
	if (!document) {
		pdoc = new Document(DocumentOption::Default);
	} else {
		pdoc = document;
	}
	pdoc->AddRef();
	modelState.reset();
	pcs = ContractionStateCreate(pdoc->IsLarge());

	// Ensure all positions within document
	sel.Clear();
	targetRange = SelectionSegment();

	braces[0] = Sci::invalidPosition;
	braces[1] = Sci::invalidPosition;

	vs.ReleaseAllExtendedStyles();

	SetRepresentations();

	scrollToAfterWrap.reset();

	// Reset the contraction state to fully shown.
	pcs->Clear();
	pcs->InsertLines(0, pdoc->LinesTotal() - 1);
	SetAnnotationHeights(0, pdoc->LinesTotal());
	view.llc.Deallocate();
	NeedWrapping();

	hotspot = Range(Sci::invalidPosition);
	hoverIndicatorPos = Sci::invalidPosition;

	view.ClearAllTabstops();

	pdoc->AddWatcher(this, nullptr);
	SetScrollBars();
	Redraw();
}

void Editor::SetAnnotationVisible(AnnotationVisible visible) {
	if (vs.annotationVisible != visible) {
		const bool changedFromOrToHidden = ((vs.annotationVisible != AnnotationVisible::Hidden) != (visible != AnnotationVisible::Hidden));
		vs.annotationVisible = visible;
		if (changedFromOrToHidden) {
			const int dir = (vs.annotationVisible!= AnnotationVisible::Hidden) ? 1 : -1;
			for (Sci::Line line=0; line<pdoc->LinesTotal(); line++) {
				const int annotationLines = pdoc->AnnotationLines(line);
				if (annotationLines > 0) {
					pcs->SetHeight(line, pcs->GetHeight(line) + annotationLines * dir);
				}
			}
			SetScrollBars();
		}
		Redraw();
	}
}

void Editor::SetEOLAnnotationVisible(EOLAnnotationVisible visible) {
	if (vs.eolAnnotationVisible != visible) {
		vs.eolAnnotationVisible = visible;
		Redraw();
	}
}

/**
 * Recursively expand a fold, making lines visible except where they have an unexpanded parent.
 */
Sci::Line Editor::ExpandLine(Sci::Line line) {
	const Sci::Line lineMaxSubord = pdoc->GetLastChild(line);
	line++;
	Sci::Line lineStart = line;
	while (line <= lineMaxSubord) {
		const FoldLevel level = pdoc->GetFoldLevel(line);
		if (LevelIsHeader(level)) {
			pcs->SetVisible(lineStart, line, true);
			if (pcs->GetExpanded(line)) {
				line = ExpandLine(line);
			} else {
				line = pdoc->GetLastChild(line);
			}
			lineStart = line + 1;
		}
		line++;
	}
	if (lineStart <= lineMaxSubord) {
		pcs->SetVisible(lineStart, lineMaxSubord, true);
	}
	return lineMaxSubord;
}

void Editor::SetFoldExpanded(Sci::Line lineDoc, bool expanded) {
	if (pcs->SetExpanded(lineDoc, expanded)) {
		RedrawSelMargin();
	}
}

void Editor::FoldLine(Sci::Line line, FoldAction action) {
	if (line >= 0) {
		if (action == FoldAction::Toggle) {
			if (!LevelIsHeader(pdoc->GetFoldLevel(line))) {
				line = pdoc->GetFoldParent(line);
				if (line < 0)
					return;
			}
			action = (pcs->GetExpanded(line)) ? FoldAction::Contract : FoldAction::Expand;
		}

		if (action == FoldAction::Contract) {
			const Sci::Line lineMaxSubord = pdoc->GetLastChild(line);
			if (lineMaxSubord > line) {
				pcs->SetExpanded(line, false);
				pcs->SetVisible(line + 1, lineMaxSubord, false);

				const Sci::Line lineCurrent =
					pdoc->SciLineFromPosition(sel.MainCaret());
				if (lineCurrent > line && lineCurrent <= lineMaxSubord) {
					// This does not re-expand the fold
					EnsureCaretVisible();
				}
			}

		} else {
			if (!(pcs->GetVisible(line))) {
				EnsureLineVisible(line, false);
				GoToLine(line);
			}
			pcs->SetExpanded(line, true);
			ExpandLine(line);
		}

		SetScrollBars();
		Redraw();
	}
}

void Editor::FoldExpand(Sci::Line line, FoldAction action, FoldLevel level) {
	bool expanding = action == FoldAction::Expand;
	if (action == FoldAction::Toggle) {
		expanding = !pcs->GetExpanded(line);
	}
	// Ensure child lines lexed and fold information extracted before
	// flipping the state.
	pdoc->GetLastChild(line, LevelNumberPart(level));
	SetFoldExpanded(line, expanding);
	if (expanding && (pcs->HiddenLines() == 0))
		// Nothing to do
		return;
	const Sci::Line lineMaxSubord = pdoc->GetLastChild(line, LevelNumberPart(level));
	line++;
	pcs->SetVisible(line, lineMaxSubord, expanding);
	while (line <= lineMaxSubord) {
		const FoldLevel levelLine = pdoc->GetFoldLevel(line);
		if (LevelIsHeader(levelLine)) {
			SetFoldExpanded(line, expanding);
		}
		line++;
	}
	SetScrollBars();
	Redraw();
}

Sci::Line Editor::ContractedFoldNext(Sci::Line lineStart) const noexcept {
	for (Sci::Line line = lineStart; line<pdoc->LinesTotal();) {
		if (!pcs->GetExpanded(line) && LevelIsHeader(pdoc->GetFoldLevel(line)))
			return line;
		line = pcs->ContractedNext(line+1);
		if (line < 0)
			return -1;
	}

	return -1;
}

/**
 * Recurse up from this line to find any folds that prevent this line from being visible
 * and unfold them all.
 */
void Editor::EnsureLineVisible(Sci::Line lineDoc, bool enforcePolicy) {

	// In case in need of wrapping to ensure DisplayFromDoc works.
	if (lineDoc >= wrapPending.start) {
		if (WrapLines(WrapScope::wsAll)) {
			Redraw();
		}
	}

	if (!pcs->GetVisible(lineDoc)) {
		// Back up to find a non-blank line
		Sci::Line lookLine = lineDoc;
		FoldLevel lookLineLevel = pdoc->GetFoldLevel(lookLine);
		while ((lookLine > 0) && LevelIsWhitespace(lookLineLevel)) {
			lookLineLevel = pdoc->GetFoldLevel(--lookLine);
		}
		Sci::Line lineParent = pdoc->GetFoldParent(lookLine);
		if (lineParent < 0) {
			// Backed up to a top level line, so try to find parent of initial line
			lineParent = pdoc->GetFoldParent(lineDoc);
		}
		if (lineParent >= 0) {
			if (lineDoc != lineParent)
				EnsureLineVisible(lineParent, enforcePolicy);
			if (!pcs->GetExpanded(lineParent)) {
				pcs->SetExpanded(lineParent, true);
				ExpandLine(lineParent);
			}
		}
		SetScrollBars();
		Redraw();
	}
	if (enforcePolicy) {
		const Sci::Line lineDisplay = pcs->DisplayFromDoc(lineDoc);
		if (FlagSet(visiblePolicy.policy, VisiblePolicy::Slop)) {
			if ((topLine > lineDisplay) || ((FlagSet(visiblePolicy.policy, VisiblePolicy::Strict)) && (topLine + visiblePolicy.slop > lineDisplay))) {
				SetTopLine(std::clamp<Sci::Line>(lineDisplay - visiblePolicy.slop, 0, MaxScrollPos()));
				SetVerticalScrollPos();
				Redraw();
			} else if ((lineDisplay > topLine + LinesOnScreen() - 1) ||
			        ((FlagSet(visiblePolicy.policy, VisiblePolicy::Strict)) && (lineDisplay > topLine + LinesOnScreen() - 1 - visiblePolicy.slop))) {
				SetTopLine(std::clamp<Sci::Line>(lineDisplay - LinesOnScreen() + 1 + visiblePolicy.slop, 0, MaxScrollPos()));
				SetVerticalScrollPos();
				Redraw();
			}
		} else {
			if ((topLine > lineDisplay) || (lineDisplay > topLine + LinesOnScreen() - 1) || (FlagSet(visiblePolicy.policy, VisiblePolicy::Strict))) {
				SetTopLine(std::clamp<Sci::Line>(lineDisplay - LinesOnScreen() / 2 + 1, 0, MaxScrollPos()));
				SetVerticalScrollPos();
				Redraw();
			}
		}
	}
}

void Editor::FoldAll(FoldAction action) {
	const Sci::Line maxLine = pdoc->LinesTotal();
	const bool contractAll = FlagSet(action, FoldAction::ContractEveryLevel);
	action = static_cast<FoldAction>(static_cast<int>(action) & ~static_cast<int>(FoldAction::ContractEveryLevel));
	bool expanding = action == FoldAction::Expand;
	if (!expanding) {
		pdoc->EnsureStyledTo(pdoc->Length());
	}
	Sci::Line line = 0;
	if (action == FoldAction::Toggle) {
		// Discover current state
		for (; line < maxLine; line++) {
			if (LevelIsHeader(pdoc->GetFoldLevel(line))) {
				expanding = !pcs->GetExpanded(line);
				break;
			}
		}
	}
	if (expanding) {
		pcs->SetVisible(0, maxLine-1, true);
		pcs->ExpandAll();
	} else {
		for (; line < maxLine; line++) {
			const FoldLevel level = pdoc->GetFoldLevel(line);
			if (LevelIsHeader(level)) {
				if (FoldLevel::Base == LevelNumberPart(level)) {
					SetFoldExpanded(line, false);
					const Sci::Line lineMaxSubord = pdoc->GetLastChild(line);
					if (lineMaxSubord > line) {
						pcs->SetVisible(line + 1, lineMaxSubord, false);
						if (!contractAll) {
							line = lineMaxSubord;
						}
					}
				} else if (contractAll) {
					SetFoldExpanded(line, false);
				}
			}
		}
	}
	SetScrollBars();
	Redraw();
}

void Editor::FoldChanged(Sci::Line line, FoldLevel levelNow, FoldLevel levelPrev) {
	if (LevelIsHeader(levelNow)) {
		if (!LevelIsHeader(levelPrev)) {
			// Adding a fold point.
			if (pcs->SetExpanded(line, true)) {
				RedrawSelMargin();
			}
			FoldExpand(line, FoldAction::Expand, levelPrev);
		}
	} else if (LevelIsHeader(levelPrev)) {
		const Sci::Line prevLine = line - 1;
		const FoldLevel prevLineLevel = pdoc->GetFoldLevel(prevLine);

		// Combining two blocks where the first block is collapsed (e.g. by deleting the line(s) which separate(s) the two blocks)
		if ((LevelNumber(prevLineLevel) == LevelNumber(levelNow)) && !pcs->GetVisible(prevLine))
			FoldLine(pdoc->GetFoldParent(prevLine), FoldAction::Expand);

		if (!pcs->GetExpanded(line)) {
			// Removing the fold from one that has been contracted so should expand
			// otherwise lines are left invisible with no way to make them visible
			if (pcs->SetExpanded(line, true)) {
				RedrawSelMargin();
			}
			// Combining two blocks where the second one is collapsed (e.g. by adding characters in the line which separates the two blocks)
			FoldExpand(line, FoldAction::Expand, levelPrev);
		}
	}
	if (!LevelIsWhitespace(levelNow) &&
	        (LevelNumber(levelPrev) > LevelNumber(levelNow))) {
		if (pcs->HiddenLines()) {
			// See if should still be hidden
			const Sci::Line parentLine = pdoc->GetFoldParent(line);
			if ((parentLine < 0) || (pcs->GetExpanded(parentLine) && pcs->GetVisible(parentLine))) {
				pcs->SetVisible(line, line, true);
				SetScrollBars();
				Redraw();
			}
		}
	}

	// Combining two blocks where the first one is collapsed (e.g. by adding characters in the line which separates the two blocks)
	if (!LevelIsWhitespace(levelNow) && (LevelNumber(levelPrev) < LevelNumber(levelNow))) {
		if (pcs->HiddenLines()) {
			const Sci::Line parentLine = pdoc->GetFoldParent(line);
			if (!pcs->GetExpanded(parentLine) && pcs->GetVisible(line))
				FoldLine(parentLine, FoldAction::Expand);
		}
	}
}

void Editor::NeedShown(Sci::Position pos, Sci::Position len) {
	if (FlagSet(foldAutomatic, AutomaticFold::Show)) {
		const Sci::Line lineStart = pdoc->SciLineFromPosition(pos);
		const Sci::Line lineEnd = pdoc->SciLineFromPosition(pos+len);
		for (Sci::Line line = lineStart; line <= lineEnd; line++) {
			EnsureLineVisible(line, false);
		}
	} else {
		NotifyNeedShown(pos, len);
	}
}

Sci::Position Editor::GetTag(char *tagValue, int tagNumber) {
	const char *text = nullptr;
	Sci::Position length = 0;
	if ((tagNumber >= 1) && (tagNumber <= 9)) {
		char name[3] = "\\?";
		name[1] = static_cast<char>(tagNumber + '0');
		length = 2;
		text = pdoc->SubstituteByPosition(name, &length);
	}
	if (tagValue) {
		if (text)
			memcpy(tagValue, text, length + 1);
		else
			*tagValue = '\0';
	}
	return length;
}

Sci::Position Editor::ReplaceTarget(ReplaceType replaceType, std::string_view text) {
	UndoGroup ug(pdoc);

	std::string substituted;	// Copy in case of re-entrance

	if (replaceType == ReplaceType::patterns) {
		Sci::Position length = text.length();
		const char *p = pdoc->SubstituteByPosition(text.data(), &length);
		if (!p) {
			return 0;
		}
		substituted.assign(p, length);
		text = substituted;
	}

	if (replaceType == ReplaceType::minimal) {
		// Check for prefix and suffix and reduce text and target to match.
		// This is performed with Range which doesn't support virtual space.
		Range range(targetRange.start.Position(), targetRange.end.Position());
		pdoc->TrimReplacement(text, range);
		// Re-apply virtual space to start if start position didn't change.
		// Don't bother with end as its virtual space is not used
		const SelectionPosition start(range.start == targetRange.start.Position() ?
			targetRange.start : SelectionPosition(range.start));
		targetRange = SelectionSegment(start, SelectionPosition(range.end));
	}

	// Make a copy of targetRange in case callbacks use target
	SelectionSegment replaceRange = targetRange;

	// Remove the text inside the range
	if (replaceRange.Length() > 0)
		pdoc->DeleteChars(replaceRange.start.Position(), replaceRange.Length());

	// Realize virtual space of target start
	const Sci::Position startAfterSpaceInsertion = RealizeVirtualSpace(replaceRange.start.Position(), replaceRange.start.VirtualSpace());
	replaceRange.start.SetPosition(startAfterSpaceInsertion);
	replaceRange.end = replaceRange.start;

	// Insert the new text
	const Sci::Position lengthInserted = pdoc->InsertString(replaceRange.start.Position(), text);
	replaceRange.end.SetPosition(replaceRange.start.Position() + lengthInserted);

	// Copy back to targetRange in case application is chaining modifications
	targetRange = replaceRange;

	return text.length();
}

bool Editor::IsUnicodeMode() const noexcept {
	return pdoc && (CpUtf8 == pdoc->dbcsCodePage);
}

int Editor::CodePage() const noexcept {
	if (pdoc)
		return pdoc->dbcsCodePage;
	return 0;
}

std::unique_ptr<Surface> Editor::CreateMeasurementSurface() const {
	if (!wMain.GetID()) {
		return {};
	}
	std::unique_ptr<Surface> surf = Surface::Allocate(technology);
	surf->Init(wMain.GetID());
	surf->SetMode(CurrentSurfaceMode());
	return surf;
}

std::unique_ptr<Surface> Editor::CreateDrawingSurface(SurfaceID sid, std::optional<Scintilla::Technology> technologyOpt) const {
	if (!wMain.GetID()) {
		return {};
	}
	std::unique_ptr<Surface> surf = Surface::Allocate(technologyOpt ? *technologyOpt : technology);
	surf->Init(sid, wMain.GetID());
	surf->SetMode(CurrentSurfaceMode());
	return surf;
}

Sci::Line Editor::WrapCount(Sci::Line line) {
	AutoSurface surface(this);
	std::shared_ptr<LineLayout> ll = view.RetrieveLineLayout(line, *this);

	if (surface && ll) {
		view.LayoutLine(*this, surface, vs, ll.get(), wrapWidth);
		return ll->lines;
	}
	return 1;
}

void Editor::AddStyledText(const char *buffer, Sci::Position appendLength) {
	// The buffer consists of alternating character bytes and style bytes
	const Sci::Position textLength = appendLength / 2;
	std::string text(textLength, '\0');
	for (Sci::Position i = 0; i < textLength; i++) {
		text[i] = buffer[i*2];
	}
	const Sci::Position lengthInserted = pdoc->InsertString(CurrentPosition(), text);
	for (Sci::Position i = 0; i < textLength; i++) {
		text[i] = buffer[i*2+1];
	}
	pdoc->StartStyling(CurrentPosition());
	pdoc->SetStyles(textLength, text.c_str());
	SetEmptySelection(sel.MainCaret() + lengthInserted);
}

Sci::Position Editor::GetStyledText(char *buffer, Sci::Position cpMin, Sci::Position cpMax) const noexcept {
	Sci::Position iPlace = 0;
	for (Sci::Position iChar = cpMin; iChar < cpMax; iChar++) {
		buffer[iPlace++] = pdoc->CharAt(iChar);
		buffer[iPlace++] = pdoc->StyleAtNoExcept(iChar);
	}
	buffer[iPlace] = '\0';
	buffer[iPlace + 1] = '\0';
	return iPlace;
}

Sci::Position Editor::GetTextRange(char *buffer, Sci::Position cpMin, Sci::Position cpMax) const {
	const Sci::Position cpEnd = (cpMax == -1) ? pdoc->Length() : cpMax;
	PLATFORM_ASSERT(cpEnd <= pdoc->Length());
	const Sci::Position len = cpEnd - cpMin; 	// No -1 as cpMin and cpMax are referring to inter character positions
	pdoc->GetCharRange(buffer, cpMin, len);
	// Spec says copied text is terminated with a NUL
	buffer[len] = '\0';
	return len; 	// Not including NUL
}

bool Editor::ValidMargin(uptr_t wParam) const noexcept {
	return wParam < vs.ms.size();
}

void Editor::StyleSetMessage(Message iMessage, uptr_t wParam, sptr_t lParam) {
	vs.EnsureStyle(wParam);
	switch (iMessage) {
	case Message::StyleSetFore:
		vs.styles[wParam].fore = ColourRGBA::FromIpRGB(lParam);
		break;
	case Message::StyleSetBack:
		vs.styles[wParam].back = ColourRGBA::FromIpRGB(lParam);
		break;
	case Message::StyleSetBold:
		vs.styles[wParam].weight = lParam != 0 ? FontWeight::Bold : FontWeight::Normal;
		break;
	case Message::StyleSetWeight:
		vs.styles[wParam].weight = static_cast<FontWeight>(lParam);
		break;
	case Message::StyleSetStretch:
		vs.styles[wParam].stretch = static_cast<FontStretch>(lParam);
		break;
	case Message::StyleSetItalic:
		vs.styles[wParam].italic = lParam != 0;
		break;
	case Message::StyleSetEOLFilled:
		vs.styles[wParam].eolFilled = lParam != 0;
		break;
	case Message::StyleSetSize:
		vs.styles[wParam].size = static_cast<int>(lParam * FontSizeMultiplier);
		break;
	case Message::StyleSetSizeFractional:
		vs.styles[wParam].size = static_cast<int>(lParam);
		break;
	case Message::StyleSetFont:
		if (lParam != 0) {
			vs.SetStyleFontName(static_cast<int>(wParam), ConstCharPtrFromSPtr(lParam));
		}
		break;
	case Message::StyleSetUnderline:
		vs.styles[wParam].underline = lParam != 0;
		break;
	case Message::StyleSetCase:
		vs.styles[wParam].caseForce = static_cast<Style::CaseForce>(lParam);
		break;
	case Message::StyleSetCharacterSet:
		vs.styles[wParam].characterSet = static_cast<CharacterSet>(lParam);
		pdoc->SetCaseFolder(nullptr);
		break;
	case Message::StyleSetVisible:
		vs.styles[wParam].visible = lParam != 0;
		break;
	case Message::StyleSetInvisibleRepresentation: {
		const char *utf8 = ConstCharPtrFromSPtr(lParam);
		char *rep = vs.styles[wParam].invisibleRepresentation;
		const int classified = UTF8Classify(utf8);
		if (!(classified & UTF8MaskInvalid)) {
			// valid UTF-8
			const int len = classified & UTF8MaskWidth;
			for (int i=0; i<len && i<UTF8MaxBytes; i++)
				*rep++ = *utf8++;
		}
		*rep = 0;
		break;
	}
	case Message::StyleSetChangeable:
		vs.styles[wParam].changeable = lParam != 0;
		break;
	case Message::StyleSetHotSpot:
		vs.styles[wParam].hotspot = lParam != 0;
		break;
	case Message::StyleSetCheckMonospaced:
		vs.styles[wParam].checkMonospaced = lParam != 0;
		break;
	default:
		break;
	}
	InvalidateStyleRedraw();
}

sptr_t Editor::StyleGetMessage(Message iMessage, uptr_t wParam, sptr_t lParam) {
	vs.EnsureStyle(wParam);
	switch (iMessage) {
	case Message::StyleGetFore:
		return vs.styles[wParam].fore.OpaqueRGB();
	case Message::StyleGetBack:
		return vs.styles[wParam].back.OpaqueRGB();
	case Message::StyleGetBold:
		return vs.styles[wParam].weight > FontWeight::Normal;
	case Message::StyleGetWeight:
		return static_cast<sptr_t>(vs.styles[wParam].weight);
	case Message::StyleGetStretch:
		return static_cast<sptr_t>(vs.styles[wParam].stretch);
	case Message::StyleGetItalic:
		return vs.styles[wParam].italic ? 1 : 0;
	case Message::StyleGetEOLFilled:
		return vs.styles[wParam].eolFilled ? 1 : 0;
	case Message::StyleGetSize:
		return vs.styles[wParam].size / FontSizeMultiplier;
	case Message::StyleGetSizeFractional:
		return vs.styles[wParam].size;
	case Message::StyleGetFont:
		return StringResult(lParam, vs.styles[wParam].fontName);
	case Message::StyleGetUnderline:
		return vs.styles[wParam].underline ? 1 : 0;
	case Message::StyleGetCase:
		return static_cast<int>(vs.styles[wParam].caseForce);
	case Message::StyleGetCharacterSet:
		return static_cast<sptr_t>(vs.styles[wParam].characterSet);
	case Message::StyleGetVisible:
		return vs.styles[wParam].visible ? 1 : 0;
	case Message::StyleGetChangeable:
		return vs.styles[wParam].changeable ? 1 : 0;
	case Message::StyleGetInvisibleRepresentation:
		return StringResult(lParam, vs.styles[wParam].invisibleRepresentation);
	case Message::StyleGetHotSpot:
		return vs.styles[wParam].hotspot ? 1 : 0;
	case Message::StyleGetCheckMonospaced:
		return vs.styles[wParam].checkMonospaced ? 1 : 0;
	default:
		break;
	}
	return 0;
}

void Editor::SetSelectionNMessage(Message iMessage, uptr_t wParam, sptr_t lParam) {
	if (wParam >= sel.Count()) {
		return;
	}
	InvalidateRange(sel.Range(wParam).Start().Position(), sel.Range(wParam).End().Position());

	switch (iMessage) {
	case Message::SetSelectionNCaret:
		sel.Range(wParam).caret.SetPosition(lParam);
		break;

	case Message::SetSelectionNAnchor:
		sel.Range(wParam).anchor.SetPosition(lParam);
		break;

	case Message::SetSelectionNCaretVirtualSpace:
		sel.Range(wParam).caret.SetVirtualSpace(lParam);
		break;

	case Message::SetSelectionNAnchorVirtualSpace:
		sel.Range(wParam).anchor.SetVirtualSpace(lParam);
		break;

	case Message::SetSelectionNStart:
		sel.Range(wParam).anchor.SetPosition(lParam);
		break;

	case Message::SetSelectionNEnd:
		sel.Range(wParam).caret.SetPosition(lParam);
		break;

	default:
		break;

	}

	InvalidateRange(sel.Range(wParam).Start().Position(), sel.Range(wParam).End().Position());
	ContainerNeedsUpdate(Update::Selection);
}

namespace {

constexpr Selection::SelTypes SelTypeFromMode(SelectionMode mode) {
	switch (mode) {
	case SelectionMode::Rectangle:
		return Selection::SelTypes::rectangle;
	case SelectionMode::Lines:
		return Selection::SelTypes::lines;
	case SelectionMode::Thin:
		return Selection::SelTypes::thin;
	case SelectionMode::Stream:
	default:
		return Selection::SelTypes::stream;
	}
}

sptr_t SPtrFromPtr(void *ptr) noexcept {
	return reinterpret_cast<sptr_t>(ptr);
}

}

void Editor::SetSelectionMode(uptr_t wParam, bool setMoveExtends) {
	const Selection::SelTypes newSelType = SelTypeFromMode(static_cast<SelectionMode>(wParam));
	if (setMoveExtends) {
		sel.SetMoveExtends(!sel.MoveExtends() || (sel.selType != newSelType));
	}
	sel.selType = newSelType;
	switch (sel.selType) {
	case Selection::SelTypes::rectangle:
		sel.Rectangular() = sel.RangeMain(); // adjust current selection
		break;
	case Selection::SelTypes::lines:
		SetSelection(sel.RangeMain().caret, sel.RangeMain().anchor); // adjust current selection
		break;
	default:
		break;
	}
	InvalidateWholeSelection();
}

sptr_t Editor::StringResult(sptr_t lParam, const char *val) noexcept {
	const size_t len = val ? strlen(val) : 0;
	if (lParam) {
		char *ptr = CharPtrFromSPtr(lParam);
		if (val)
			memcpy(ptr, val, len+1);
		else
			*ptr = 0;
	}
	return len;	// Not including NUL
}

sptr_t Editor::BytesResult(sptr_t lParam, const unsigned char *val, size_t len) noexcept {
	// No NUL termination: len is number of valid/displayed bytes
	if ((lParam) && (len > 0)) {
		char *ptr = CharPtrFromSPtr(lParam);
		if (val)
			memcpy(ptr, val, len);
		else
			*ptr = 0;
	}
	return val ? len : 0;
}

sptr_t Editor::BytesResult(Scintilla::sptr_t lParam, std::string_view sv) noexcept {
	// No NUL termination: sv.length() is number of valid/displayed bytes
	if (lParam && !sv.empty()) {
		char *ptr = CharPtrFromSPtr(lParam);
		memcpy(ptr, sv.data(), sv.length());
	}
	return sv.length();
}

sptr_t Editor::WndProc(Message iMessage, uptr_t wParam, sptr_t lParam) {
	//Platform::DebugPrintf("S start wnd proc %d %d %d\n",iMessage, wParam, lParam);

	// Optional macro recording hook
	if (recordingMacro)
		NotifyMacroRecord(iMessage, wParam, lParam);

	switch (iMessage) {

	case Message::GetText: {
			if (lParam == 0)
				return pdoc->Length();
			char *ptr = CharPtrFromSPtr(lParam);
			const Sci_Position len = std::min<Sci_Position>(wParam, pdoc->Length());
			pdoc->GetCharRange(ptr, 0, len);
			ptr[len] = '\0';
			return len;
		}

	case Message::SetText: {
			if (lParam == 0)
				return 0;
			UndoGroup ug(pdoc);
			pdoc->DeleteChars(0, pdoc->Length());
			SetEmptySelection(0);
			const char *text = ConstCharPtrFromSPtr(lParam);
			pdoc->InsertString(0, text, strlen(text));
			return 1;
		}

	case Message::GetTextLength:
		return pdoc->Length();

	case Message::Cut:
		Cut();
		SetLastXChosen();
		break;

	case Message::Copy:
		Copy();
		break;

	case Message::CopyAllowLine:
		CopyAllowLine();
		break;

	case Message::CutAllowLine:
		CutAllowLine();
		SetLastXChosen();
		break;

	case Message::GetCopySeparator:
		return StringResult(lParam, copySeparator.c_str());

	case Message::SetCopySeparator:
		copySeparator = ConstCharPtrFromSPtr(lParam);
		break;

	case Message::VerticalCentreCaret:
		VerticalCentreCaret();
		break;

	case Message::MoveSelectedLinesUp:
		MoveSelectedLinesUp();
		break;

	case Message::MoveSelectedLinesDown:
		MoveSelectedLinesDown();
		break;

	case Message::CopyRange:
		CopyRangeToClipboard(PositionFromUPtr(wParam), lParam);
		break;

	case Message::CopyText:
		CopyText(wParam, ConstCharPtrFromSPtr(lParam));
		break;

	case Message::Paste:
		Paste();
		if ((caretSticky == CaretSticky::Off) || (caretSticky == CaretSticky::WhiteSpace)) {
			SetLastXChosen();
		}
		EnsureCaretVisible();
		break;

	case Message::ReplaceRectangular: {
		UndoGroup ug(pdoc);
		if (!sel.Empty()) {
			ClearSelection(); // want to replace rectangular selection contents
		}
		InsertPasteShape(ConstCharPtrFromSPtr(lParam), PositionFromUPtr(wParam), PasteShape::rectangular);
		break;
	}

	case Message::Clear:
		Clear();
		SetLastXChosen();
		EnsureCaretVisible();
		break;

	case Message::Undo:
		Undo(wParam & 1); //Au
		//Undo();
		//SetLastXChosen();
		break;

	case Message::CanUndo:
		return (pdoc->CanUndo() && !pdoc->IsReadOnly()) ? 1 : 0;

	case Message::EmptyUndoBuffer:
		pdoc->DeleteUndoHistory();
		return 0;

	case Message::GetFirstVisibleLine:
		return topLine;

	case Message::SetFirstVisibleLine:
		ScrollTo(LineFromUPtr(wParam));
		break;

	case Message::GetLine: {	// Risk of overwriting the end of the buffer
			const Sci::Position lineStart =
				pdoc->LineStart(LineFromUPtr(wParam));
			const Sci::Position lineEnd =
				pdoc->LineStart(LineFromUPtr(wParam + 1));
			// not NUL terminated
			const Sci::Position len = lineEnd - lineStart;
			if (lParam == 0) {
				return len;
			}
			char *ptr = CharPtrFromSPtr(lParam);
			pdoc->GetCharRange(ptr, lineStart, len);
			return len;
		}

	case Message::GetLineCount:
		if (pdoc->LinesTotal() == 0)
			return 1;
		else
			return pdoc->LinesTotal();

	case Message::AllocateLines:
		pdoc->AllocateLines(wParam);
		break;

	case Message::GetModify:
		return !pdoc->IsSavePoint();

	case Message::SetSel: {
			Sci::Position nStart = PositionFromUPtr(wParam);
			Sci::Position nEnd = lParam;
			if (nEnd < 0)
				nEnd = pdoc->Length();
			if (nStart < 0)
				nStart = nEnd; 	// Remove selection
			InvalidateSelection(SelectionRange(nStart, nEnd));
			sel.Clear();
			sel.selType = Selection::SelTypes::stream;
			SetSelection(nEnd, nStart);
			EnsureCaretVisible();
		}
		break;

	case Message::GetSelText: {
			SelectionText selectedText;
			CopySelectionRange(&selectedText);
			if (lParam) {
				char *ptr = CharPtrFromSPtr(lParam);
				size_t iChar = selectedText.Length();
				if (iChar) {
					memcpy(ptr, selectedText.Data(), iChar);
				}
				ptr[iChar] = '\0';
			}
			return selectedText.Length();
	}

	case Message::LineFromPosition:
		if (PositionFromUPtr(wParam) < 0)
			return 0;
		return pdoc->LineFromPosition(PositionFromUPtr(wParam));

	case Message::PositionFromLine:
		if (LineFromUPtr(wParam) < 0)
			wParam = pdoc->LineFromPosition(SelectionStart().Position());
		if (wParam == 0)
			return 0; 	// Even if there is no text, there is a first line that starts at 0
		if (LineFromUPtr(wParam) > pdoc->LinesTotal())
			return -1;
		//if (wParam > pdoc->LineFromPosition(pdoc->Length()))	// Useful test, anyway...
		//	return -1;
		return pdoc->LineStart(LineFromUPtr(wParam));

		// Replacement of the old Scintilla interpretation of EM_LINELENGTH
	case Message::LineLength:
		if ((LineFromUPtr(wParam) < 0) ||
		        (LineFromUPtr(wParam) > pdoc->LineFromPosition(pdoc->Length())))
			return 0;
		return pdoc->LineStart(LineFromUPtr(wParam) + 1) - pdoc->LineStart(LineFromUPtr(wParam));

	case Message::ReplaceSel: {
			if (lParam == 0)
				return 0;
			UndoGroup ug(pdoc);
			ClearSelection();
			const char *replacement = ConstCharPtrFromSPtr(lParam);
			const Sci::Position lengthInserted = pdoc->InsertString(
				sel.MainCaret(), replacement, strlen(replacement));
			SetEmptySelection(sel.MainCaret() + lengthInserted);
			SetLastXChosen();
			EnsureCaretVisible();
		}
		break;

	case Message::SetTargetStart:
		targetRange.start.SetPosition(PositionFromUPtr(wParam));
		break;

	case Message::GetTargetStart:
		return targetRange.start.Position();

	case Message::SetTargetStartVirtualSpace:
		targetRange.start.SetVirtualSpace(PositionFromUPtr(wParam));
		break;

	case Message::GetTargetStartVirtualSpace:
		return targetRange.start.VirtualSpace();

	case Message::SetTargetEnd:
		targetRange.end.SetPosition(PositionFromUPtr(wParam));
		break;

	case Message::GetTargetEnd:
		return targetRange.end.Position();

	case Message::SetTargetEndVirtualSpace:
		targetRange.end.SetVirtualSpace(PositionFromUPtr(wParam));
		break;

	case Message::GetTargetEndVirtualSpace:
		return targetRange.end.VirtualSpace();

	case Message::SetTargetRange:
		targetRange.start.SetPosition(PositionFromUPtr(wParam));
		targetRange.end.SetPosition(lParam);
		break;

	case Message::TargetWholeDocument:
		targetRange.start.SetPosition(0);
		targetRange.end.SetPosition(pdoc->Length());
		break;

	case Message::TargetFromSelection:
		targetRange.start = sel.RangeMain().Start();
		targetRange.end = sel.RangeMain().End();
		break;

	case Message::GetTargetText: {
			const std::string text = RangeText(targetRange.start.Position(), targetRange.end.Position());
			return BytesResult(lParam, text);
		}

	case Message::ReplaceTarget:
		PLATFORM_ASSERT(lParam);
		return ReplaceTarget(ReplaceType::basic, ViewFromParams(lParam, wParam));

	case Message::ReplaceTargetRE:
		PLATFORM_ASSERT(lParam);
		return ReplaceTarget(ReplaceType::patterns, ViewFromParams(lParam, wParam));

	case Message::ReplaceTargetMinimal:
		PLATFORM_ASSERT(lParam);
		return ReplaceTarget(ReplaceType::minimal, ViewFromParams(lParam, wParam));

	case Message::SearchInTarget:
		PLATFORM_ASSERT(lParam);
		return SearchInTarget(ConstCharPtrFromSPtr(lParam), PositionFromUPtr(wParam));

	case Message::SetSearchFlags:
		searchFlags = static_cast<FindOption>(wParam);
		break;

	case Message::GetSearchFlags:
		return static_cast<sptr_t>(searchFlags);

	case Message::GetTag:
		return GetTag(CharPtrFromSPtr(lParam), static_cast<int>(wParam));

	case Message::PositionBefore:
		return pdoc->MovePositionOutsideChar(PositionFromUPtr(wParam) - 1, -1, true);

	case Message::PositionAfter:
		return pdoc->MovePositionOutsideChar(PositionFromUPtr(wParam) + 1, 1, true);

	case Message::PositionRelative:
		return std::clamp<Sci::Position>(pdoc->GetRelativePosition(
			PositionFromUPtr(wParam), lParam),
			0, pdoc->Length());

	case Message::PositionRelativeCodeUnits:
		return std::clamp<Sci::Position>(pdoc->GetRelativePositionUTF16(
			PositionFromUPtr(wParam), lParam),
			0, pdoc->Length());

	case Message::LineScroll:
		ScrollTo(topLine + lParam);
		HorizontalScrollTo(xOffset + static_cast<int>(static_cast<int>(wParam) * vs.spaceWidth));
		return 1;

	case Message::ScrollVertical:
		if (Wrapping()) {
			scrollToAfterWrap = { LineFromUPtr(wParam), lParam };
		} else {
			scrollToAfterWrap.reset();
		}
		ScrollTo(pcs->DisplayFromDocSub(LineFromUPtr(wParam), lParam));
		break;

	case Message::SetXOffset:
		xOffset = static_cast<int>(wParam);
		ContainerNeedsUpdate(Update::HScroll);
		SetHorizontalScrollPos();
		Redraw();
		break;

	case Message::GetXOffset:
		return xOffset;

	case Message::ChooseCaretX:
		SetLastXChosen();
		break;

	case Message::ScrollCaret:
		EnsureCaretVisible();
		break;

	case Message::SetReadOnly:
		pdoc->SetReadOnly(wParam != 0);
		return 1;

	case Message::GetReadOnly:
		return pdoc->IsReadOnly();

	case Message::CanPaste:
		return CanPaste();

	case Message::PointXFromPosition:
		if (lParam < 0) {
			return 0;
		} else {
			const Point pt = LocationFromPosition(lParam);
			// Convert to view-relative
			return static_cast<int>(pt.x) - vs.textStart + vs.fixedColumnWidth;
		}

	case Message::PointYFromPosition:
		if (lParam < 0) {
			return 0;
		} else {
			const Point pt = LocationFromPosition(lParam);
			return static_cast<int>(pt.y);
		}

	case Message::FindText:
		return FindText(wParam, lParam);

	case Message::FindTextFull:
		return FindTextFull(wParam, lParam);

	case Message::GetTextRange:
		if (TextRange *tr = static_cast<TextRange *>(PtrFromSPtr(lParam))) {
			return GetTextRange(tr->lpstrText, tr->chrg.cpMin, tr->chrg.cpMax);
		}
		return 0;

	case Message::GetTextRangeFull:
		if (TextRangeFull *tr = static_cast<TextRangeFull *>(PtrFromSPtr(lParam))) {
			return GetTextRange(tr->lpstrText, tr->chrg.cpMin, tr->chrg.cpMax);
		}
		return 0;

	case Message::HideSelection:
		vs.selection.visible = wParam == 0;
		Redraw();
		break;

	case Message::GetSelectionHidden:
		return !vs.selection.visible;
		break;

	case Message::FormatRange:
	case Message::FormatRangeFull:
		return FormatRange(iMessage, wParam, lParam);

	case Message::GetMarginLeft:
		return vs.leftMarginWidth;

	case Message::GetMarginRight:
		return vs.rightMarginWidth;

	case Message::SetMarginLeft:
		lastXChosen += static_cast<int>(lParam) - vs.leftMarginWidth;
		vs.leftMarginWidth = static_cast<int>(lParam);
		InvalidateStyleRedraw();
		break;

	case Message::SetMarginRight:
		vs.rightMarginWidth = static_cast<int>(lParam);
		InvalidateStyleRedraw();
		break;

		// Control specific messages

	case Message::AddText: {
			if (lParam == 0)
				return 0;
			const Sci::Position lengthInserted = pdoc->InsertString(
				CurrentPosition(), ConstCharPtrFromSPtr(lParam), PositionFromUPtr(wParam));
			SetEmptySelection(sel.MainCaret() + lengthInserted);
			return 0;
		}

	case Message::AddStyledText:
		if (lParam)
			AddStyledText(ConstCharPtrFromSPtr(lParam), PositionFromUPtr(wParam));
		return 0;

	case Message::InsertText: {
			if (lParam == 0)
				return 0;
			Sci::Position insertPos = PositionFromUPtr(wParam);
			if (insertPos == -1)
				insertPos = CurrentPosition();
			Sci::Position newCurrent = CurrentPosition();
			const char *sz = ConstCharPtrFromSPtr(lParam);
			const Sci::Position lengthInserted = pdoc->InsertString(insertPos, sz, strlen(sz));
			if (newCurrent > insertPos)
				newCurrent += lengthInserted;
			SetEmptySelection(newCurrent);
			return 0;
		}

	case Message::ChangeInsertion:
		PLATFORM_ASSERT(lParam);
		pdoc->ChangeInsertion(ConstCharPtrFromSPtr(lParam), PositionFromUPtr(wParam));
		return 0;

	case Message::AppendText:
		pdoc->InsertString(pdoc->Length(),
			ConstCharPtrFromSPtr(lParam), PositionFromUPtr(wParam));
		return 0;

	case Message::ClearAll:
		ClearAll();
		return 0;

	case Message::DeleteRange:
		pdoc->DeleteChars(PositionFromUPtr(wParam), lParam);
		return 0;

	case Message::ClearDocumentStyle:
		ClearDocumentStyle();
		return 0;

	case Message::SetUndoCollection:
		pdoc->SetUndoCollection(wParam != 0);
		return 0;

	case Message::GetUndoCollection:
		return pdoc->IsCollectingUndo();

	case Message::BeginUndoAction:
		pdoc->BeginUndoAction();
		return 0;

	case Message::EndUndoAction:
		pdoc->EndUndoAction();
		return 0;

	case Message::GetUndoSequence:
		return pdoc->UndoSequenceDepth();

	case Message::GetUndoActions:
		return pdoc->UndoActions();

	case Message::SetUndoSavePoint:
		pdoc->SetUndoSavePoint(static_cast<int>(wParam));
		break;

	case Message::GetUndoSavePoint:
		return pdoc->UndoSavePoint();

	case Message::SetUndoDetach:
		pdoc->SetUndoDetach(static_cast<int>(wParam));
		break;

	case Message::GetUndoDetach:
		return pdoc->UndoDetach();

	case Message::SetUndoTentative:
		pdoc->SetUndoTentative(static_cast<int>(wParam));
		break;

	case Message::GetUndoTentative:
		return pdoc->UndoTentative();

	case Message::SetUndoCurrent:
		pdoc->SetUndoCurrent(static_cast<int>(wParam));
		break;

	case Message::GetUndoCurrent:
		return pdoc->UndoCurrent();

	case Message::GetUndoActionType:
		return pdoc->UndoActionType(static_cast<int>(wParam));

	case Message::GetUndoActionPosition:
		return pdoc->UndoActionPosition(static_cast<int>(wParam));

	case Message::GetUndoActionText: {
		const std::string_view text = pdoc->UndoActionText(static_cast<int>(wParam));
		return BytesResult(lParam, text);
	}

	case Message::PushUndoActionType:
		pdoc->PushUndoActionType(static_cast<int>(wParam), lParam);
		break;

	case Message::ChangeLastUndoActionText:
		pdoc->ChangeLastUndoActionText(wParam, CharPtrFromSPtr(lParam));
		break;

	case Message::GetCaretPeriod:
		return caret.period;

	case Message::SetCaretPeriod:
		CaretSetPeriod(static_cast<int>(wParam));
		break;

	case Message::GetWordChars:
		return pdoc->GetCharsOfClass(CharacterClass::word, UCharPtrFromSPtr(lParam));

	case Message::SetWordChars: {
			pdoc->SetDefaultCharClasses(false);
			if (lParam == 0)
				return 0;
			pdoc->SetCharClasses(ConstUCharPtrFromSPtr(lParam), CharacterClass::word);
		}
		break;

	case Message::GetWhitespaceChars:
		return pdoc->GetCharsOfClass(CharacterClass::space, UCharPtrFromSPtr(lParam));

	case Message::SetWhitespaceChars: {
			if (lParam == 0)
				return 0;
			pdoc->SetCharClasses(ConstUCharPtrFromSPtr(lParam), CharacterClass::space);
		}
		break;

	case Message::GetPunctuationChars:
		return pdoc->GetCharsOfClass(CharacterClass::punctuation, UCharPtrFromSPtr(lParam));

	case Message::SetPunctuationChars: {
			if (lParam == 0)
				return 0;
			pdoc->SetCharClasses(ConstUCharPtrFromSPtr(lParam), CharacterClass::punctuation);
		}
		break;

	case Message::SetCharsDefault:
		pdoc->SetDefaultCharClasses(true);
		break;

	case Message::SetCharacterCategoryOptimization:
		pdoc->SetCharacterCategoryOptimization(static_cast<int>(wParam));
		break;

	case Message::GetCharacterCategoryOptimization:
		return pdoc->CharacterCategoryOptimization();

	case Message::GetLength:
		return pdoc->Length();

	case Message::Allocate:
		pdoc->Allocate(PositionFromUPtr(wParam));
		break;

	case Message::GetCharAt:
		return pdoc->CharAt(PositionFromUPtr(wParam));

	case Message::SetCurrentPos:
		if (sel.IsRectangular()) {
			sel.Rectangular().caret.SetPosition(PositionFromUPtr(wParam));
			SetRectangularRange();
			Redraw();
		} else {
			SetSelection(PositionFromUPtr(wParam), sel.MainAnchor());
		}
		break;

	case Message::GetCurrentPos:
		return sel.IsRectangular() ? sel.Rectangular().caret.Position() : sel.MainCaret();

	case Message::SetAnchor:
		if (sel.IsRectangular()) {
			sel.Rectangular().anchor.SetPosition(PositionFromUPtr(wParam));
			SetRectangularRange();
			Redraw();
		} else {
			SetSelection(sel.MainCaret(), PositionFromUPtr(wParam));
		}
		break;

	case Message::GetAnchor:
		return sel.IsRectangular() ? sel.Rectangular().anchor.Position() : sel.MainAnchor();

	case Message::SetSelectionStart:
		SetSelection(std::max(sel.MainCaret(), PositionFromUPtr(wParam)), PositionFromUPtr(wParam));
		break;

	case Message::GetSelectionStart:
		return sel.LimitsForRectangularElseMain().start.Position();

	case Message::SetSelectionEnd:
		SetSelection(PositionFromUPtr(wParam), std::min(sel.MainAnchor(), PositionFromUPtr(wParam)));
		break;

	case Message::GetSelectionEnd:
		return sel.LimitsForRectangularElseMain().end.Position();

	case Message::SetEmptySelection:
		SetEmptySelection(PositionFromUPtr(wParam));
		break;

	case Message::SetPrintMagnification:
		view.printParameters.magnification = static_cast<int>(wParam);
		break;

	case Message::GetPrintMagnification:
		return view.printParameters.magnification;

	case Message::SetPrintColourMode:
		view.printParameters.colourMode = static_cast<PrintOption>(wParam);
		break;

	case Message::GetPrintColourMode:
		return static_cast<sptr_t>(view.printParameters.colourMode);

	case Message::SetPrintWrapMode:
		view.printParameters.wrapState = (static_cast<Wrap>(wParam) == Wrap::Word) ? Wrap::Word : Wrap::None;
		break;

	case Message::GetPrintWrapMode:
		return static_cast<sptr_t>(view.printParameters.wrapState);

	case Message::GetStyleAt:
		if (PositionFromUPtr(wParam) >= pdoc->Length())
			return 0;
		else
			return pdoc->StyleAt(PositionFromUPtr(wParam));

	case Message::GetStyleIndexAt:
		if (PositionFromUPtr(wParam) >= pdoc->Length())
			return 0;
		else
			return pdoc->StyleIndexAt(PositionFromUPtr(wParam));

	case Message::Redo:
		Redo(wParam & 1); //Au
		//Redo();
		break;

	case Message::SelectAll:
		SelectAll();
		break;

	case Message::SetSavePoint:
		pdoc->SetSavePoint();
		break;

	case Message::GetStyledText:
		if (TextRange *tr = static_cast<TextRange *>(PtrFromSPtr(lParam))) {
			return GetStyledText(tr->lpstrText, tr->chrg.cpMin, tr->chrg.cpMax);
		}
		return 0;

	case Message::GetStyledTextFull:
		if (TextRangeFull *tr = static_cast<TextRangeFull *>(PtrFromSPtr(lParam))) {
			return GetStyledText(tr->lpstrText, tr->chrg.cpMin, tr->chrg.cpMax);
		}
		return 0;

	case Message::CanRedo:
		return (pdoc->CanRedo() && !pdoc->IsReadOnly()) ? 1 : 0;

	case Message::MarkerLineFromHandle:
		return pdoc->LineFromHandle(static_cast<int>(wParam));

	case Message::MarkerDeleteHandle:
		pdoc->DeleteMarkFromHandle(static_cast<int>(wParam));
		break;

	case Message::MarkerHandleFromLine:
		return pdoc->MarkerHandleFromLine(LineFromUPtr(wParam), static_cast<int>(lParam));

	case Message::MarkerNumberFromLine:
		return pdoc->MarkerNumberFromLine(LineFromUPtr(wParam), static_cast<int>(lParam));

	case Message::GetViewWS:
		return static_cast<sptr_t>(vs.viewWhitespace);

	case Message::SetViewWS:
		vs.viewWhitespace = static_cast<WhiteSpace>(wParam);
		Redraw();
		break;

	case Message::GetTabDrawMode:
		return static_cast<sptr_t>(vs.tabDrawMode);

	case Message::SetTabDrawMode:
		vs.tabDrawMode = static_cast<TabDrawMode>(wParam);
		Redraw();
		break;

	case Message::GetWhitespaceSize:
		return vs.whitespaceSize;

	case Message::SetWhitespaceSize:
		vs.whitespaceSize = static_cast<int>(wParam);
		Redraw();
		break;

	case Message::PositionFromPoint:
		return PositionFromLocation(PointFromParameters(wParam, lParam), false, false);

	case Message::PositionFromPointClose:
		return PositionFromLocation(PointFromParameters(wParam, lParam), true, false);

	case Message::CharPositionFromPoint:
		return PositionFromLocation(PointFromParameters(wParam, lParam), false, true);

	case Message::CharPositionFromPointClose:
		return PositionFromLocation(PointFromParameters(wParam, lParam), true, true);

	case Message::GotoLine:
		GoToLine(LineFromUPtr(wParam));
		break;

	case Message::GotoPos:
		SetEmptySelection(PositionFromUPtr(wParam));
		EnsureCaretVisible();
		break;

	case Message::GetCurLine: {
			const Sci::Line lineCurrentPos = pdoc->SciLineFromPosition(sel.MainCaret());
			const Sci::Position lineStart = pdoc->LineStart(lineCurrentPos);
			const Sci::Position lineEnd = pdoc->LineStart(lineCurrentPos + 1);
			if (lParam == 0) {
				return lineEnd - lineStart;
			}
			char *ptr = CharPtrFromSPtr(lParam);
			const Sci::Position len = std::min<uptr_t>(lineEnd - lineStart, wParam);
			pdoc->GetCharRange(ptr, lineStart, len);
			ptr[len] = '\0';
			return sel.MainCaret() - lineStart;
		}

	case Message::GetEndStyled:
		return pdoc->GetEndStyled();

	case Message::GetEOLMode:
		return static_cast<sptr_t>(pdoc->eolMode);

	case Message::SetEOLMode:
		pdoc->eolMode = static_cast<EndOfLine>(wParam);
		break;

	case Message::SetLineEndTypesAllowed:
		if (pdoc->SetLineEndTypesAllowed(static_cast<LineEndType>(wParam))) {
			pcs->Clear();
			pcs->InsertLines(0, pdoc->LinesTotal() - 1);
			SetAnnotationHeights(0, pdoc->LinesTotal());
			InvalidateStyleRedraw();
		}
		break;

	case Message::GetLineEndTypesAllowed:
		return static_cast<sptr_t>(pdoc->GetLineEndTypesAllowed());

	case Message::GetLineEndTypesActive:
		return static_cast<sptr_t>(pdoc->GetLineEndTypesActive());

	case Message::StartStyling:
		pdoc->StartStyling(PositionFromUPtr(wParam));
		break;

	case Message::SetStyling:
		if (PositionFromUPtr(wParam) < 0)
			errorStatus = Status::Failure;
		else
			pdoc->SetStyleFor(PositionFromUPtr(wParam), static_cast<char>(lParam));
		break;

	case Message::SetStylingEx:             // Specify a complete styling buffer
		if (lParam == 0)
			return 0;
		pdoc->SetStyles(PositionFromUPtr(wParam), ConstCharPtrFromSPtr(lParam));
		break;

	case Message::SetBufferedDraw:
		view.bufferedDraw = wParam != 0;
		break;

	case Message::GetBufferedDraw:
		return view.bufferedDraw;

#ifdef INCLUDE_DEPRECATED_FEATURES
	case SCI_GETTWOPHASEDRAW:
		return view.phasesDraw == EditView::phasesTwo;

	case SCI_SETTWOPHASEDRAW:
		if (view.SetTwoPhaseDraw(wParam != 0))
			InvalidateStyleRedraw();
		break;
#endif

	case Message::GetPhasesDraw:
		return static_cast<sptr_t>(view.phasesDraw);

	case Message::SetPhasesDraw:
		if (view.SetPhasesDraw(static_cast<int>(wParam)))
			InvalidateStyleRedraw();
		break;

	case Message::SetFontQuality:
		vs.extraFontFlag = static_cast<FontQuality>(
			(static_cast<int>(vs.extraFontFlag) & ~static_cast<int>(FontQuality::QualityMask)) |
			(wParam & static_cast<int>(FontQuality::QualityMask)));
		InvalidateStyleRedraw();
		break;

	case Message::GetFontQuality:
		return static_cast<int>(vs.extraFontFlag) & static_cast<int>(FontQuality::QualityMask);

	case Message::SetTabWidth:
		if (wParam > 0) {
			pdoc->tabInChars = static_cast<int>(wParam);
			if (pdoc->indentInChars == 0)
				pdoc->actualIndentInChars = pdoc->tabInChars;
		}
		InvalidateStyleRedraw();
		break;

	case Message::GetTabWidth:
		return pdoc->tabInChars;

	case Message::SetTabMinimumWidth:
		SetAppearance(view.tabWidthMinimumPixels, static_cast<int>(wParam));
		break;

	case Message::GetTabMinimumWidth:
		return view.tabWidthMinimumPixels;

	case Message::ClearTabStops:
		if (view.ClearTabstops(LineFromUPtr(wParam))) {
			const DocModification mh(ModificationFlags::ChangeTabStops, 0, 0, 0, nullptr, LineFromUPtr(wParam));
			NotifyModified(pdoc, mh, nullptr);
		}
		break;

	case Message::AddTabStop:
		if (view.AddTabstop(LineFromUPtr(wParam), static_cast<int>(lParam))) {
			const DocModification mh(ModificationFlags::ChangeTabStops, 0, 0, 0, nullptr, LineFromUPtr(wParam));
			NotifyModified(pdoc, mh, nullptr);
		}
		break;

	case Message::GetNextTabStop:
		return view.GetNextTabstop(LineFromUPtr(wParam), static_cast<int>(lParam));

	case Message::SetIndent:
		pdoc->indentInChars = static_cast<int>(wParam);
		if (pdoc->indentInChars != 0)
			pdoc->actualIndentInChars = pdoc->indentInChars;
		else
			pdoc->actualIndentInChars = pdoc->tabInChars;
		InvalidateStyleRedraw();
		break;

	case Message::GetIndent:
		return pdoc->indentInChars;

	case Message::SetUseTabs:
		pdoc->useTabs = wParam != 0;
		InvalidateStyleRedraw();
		break;

	case Message::GetUseTabs:
		return pdoc->useTabs;

	case Message::SetLineIndentation:
		pdoc->SetLineIndentation(LineFromUPtr(wParam), lParam);
		break;

	case Message::GetLineIndentation:
		return pdoc->GetLineIndentation(LineFromUPtr(wParam));

	case Message::GetLineIndentPosition:
		return pdoc->GetLineIndentPosition(LineFromUPtr(wParam));

	case Message::SetTabIndents:
		pdoc->tabIndents = wParam != 0;
		break;

	case Message::GetTabIndents:
		return pdoc->tabIndents;

	case Message::SetBackSpaceUnIndents:
		pdoc->backspaceUnindents = wParam != 0;
		break;

	case Message::GetBackSpaceUnIndents:
		return pdoc->backspaceUnindents;

	case Message::SetMouseDwellTime:
		dwellDelay = static_cast<int>(wParam);
		ticksToDwell = dwellDelay;
		break;

	case Message::GetMouseDwellTime:
		return dwellDelay;

	case Message::WordStartPosition:
		return pdoc->ExtendWordSelect(PositionFromUPtr(wParam), -1, lParam != 0);

	case Message::WordEndPosition:
		return pdoc->ExtendWordSelect(PositionFromUPtr(wParam), 1, lParam != 0);

	case Message::IsRangeWord:
		return pdoc->IsWordAt(PositionFromUPtr(wParam), lParam);

	case Message::SetIdleStyling:
		idleStyling = static_cast<IdleStyling>(wParam);
		break;

	case Message::GetIdleStyling:
		return static_cast<sptr_t>(idleStyling);

	case Message::SetWrapMode:
		if (vs.SetWrapState(static_cast<Wrap>(wParam))) {
			xOffset = 0;
			ContainerNeedsUpdate(Update::HScroll);
			InvalidateStyleRedraw();
			ReconfigureScrollBars();
		}
		break;

	case Message::GetWrapMode:
		return static_cast<sptr_t>(vs.wrap.state);

	case Message::SetWrapVisualFlags:
		if (vs.SetWrapVisualFlags(static_cast<WrapVisualFlag>(wParam))) {
			InvalidateStyleRedraw();
			ReconfigureScrollBars();
		}
		break;

	case Message::GetWrapVisualFlags:
		return static_cast<sptr_t>(vs.wrap.visualFlags);

	case Message::SetWrapVisualFlagsLocation:
		if (vs.SetWrapVisualFlagsLocation(static_cast<WrapVisualLocation>(wParam))) {
			InvalidateStyleRedraw();
		}
		break;

	case Message::GetWrapVisualFlagsLocation:
		return static_cast<sptr_t>(vs.wrap.visualFlagsLocation);

	case Message::SetWrapStartIndent:
		if (vs.SetWrapVisualStartIndent(static_cast<int>(wParam))) {
			InvalidateStyleRedraw();
			ReconfigureScrollBars();
		}
		break;

	case Message::GetWrapStartIndent:
		return vs.wrap.visualStartIndent;

	case Message::SetWrapIndentMode:
		if (vs.SetWrapIndentMode(static_cast<WrapIndentMode>(wParam))) {
			InvalidateStyleRedraw();
			ReconfigureScrollBars();
		}
		break;

	case Message::GetWrapIndentMode:
		return static_cast<sptr_t>(vs.wrap.indentMode);

	case Message::SetLayoutCache:
		if (static_cast<LineCache>(wParam) <= LineCache::Document) {
			view.llc.SetLevel(static_cast<LineCache>(wParam));
		}
		break;

	case Message::GetLayoutCache:
		return static_cast<sptr_t>(view.llc.GetLevel());

	case Message::SetPositionCache:
		view.posCache->SetSize(wParam);
		break;

	case Message::GetPositionCache:
		return view.posCache->GetSize();

	case Message::SetLayoutThreads:
		view.SetLayoutThreads(static_cast<unsigned int>(wParam));
		break;

	case Message::GetLayoutThreads:
		return view.GetLayoutThreads();

	case Message::SetScrollWidth:
		PLATFORM_ASSERT(wParam > 0);
		if ((wParam > 0) && (wParam != static_cast<unsigned int>(scrollWidth))) {
			view.lineWidthMaxSeen = 0;
			scrollWidth = static_cast<int>(wParam);
			SetScrollBars();
		}
		break;

	case Message::GetScrollWidth:
		return scrollWidth;

	case Message::SetScrollWidthTracking:
		trackLineWidth = wParam != 0;
		break;

	case Message::GetScrollWidthTracking:
		return trackLineWidth;

	case Message::LinesJoin:
		LinesJoin();
		break;

	case Message::LinesSplit:
		LinesSplit(static_cast<int>(wParam));
		break;

	case Message::TextWidth:
		PLATFORM_ASSERT(wParam < vs.styles.size());
		PLATFORM_ASSERT(lParam);
		return TextWidth(wParam, ConstCharPtrFromSPtr(lParam));

	case Message::TextHeight:
		RefreshStyleData();
		return vs.lineHeight;

	case Message::SetEndAtLastLine:
		PLATFORM_ASSERT((wParam == 0) || (wParam == 1));
		if (endAtLastLine != (wParam != 0)) {
			endAtLastLine = wParam != 0;
			SetScrollBars();
		}
		break;

	case Message::GetEndAtLastLine:
		return endAtLastLine;

	case Message::SetCaretSticky:
		PLATFORM_ASSERT(static_cast<CaretSticky>(wParam) <= CaretSticky::WhiteSpace);
		if (static_cast<CaretSticky>(wParam) <= CaretSticky::WhiteSpace) {
			caretSticky = static_cast<CaretSticky>(wParam);
		}
		break;

	case Message::GetCaretSticky:
		return static_cast<sptr_t>(caretSticky);

	case Message::ToggleCaretSticky:
		caretSticky = (caretSticky == CaretSticky::Off) ? CaretSticky::On : CaretSticky::Off;
		break;

	case Message::GetColumn:
		return pdoc->GetColumn(PositionFromUPtr(wParam));

	case Message::FindColumn:
		return pdoc->FindColumn(LineFromUPtr(wParam), lParam);

	case Message::SetHScrollBar :
		if (horizontalScrollBarVisible != (wParam != 0)) {
			horizontalScrollBarVisible = wParam != 0;
			SetScrollBars();
			ReconfigureScrollBars();
		}
		break;

	case Message::GetHScrollBar:
		return horizontalScrollBarVisible;

	case Message::SetVScrollBar:
		if (verticalScrollBarVisible != (wParam != 0)) {
			verticalScrollBarVisible = wParam != 0;
			SetScrollBars();
			ReconfigureScrollBars();
			if (verticalScrollBarVisible)
				SetVerticalScrollPos();
		}
		break;

	case Message::GetVScrollBar:
		return verticalScrollBarVisible;

	case Message::SetIndentationGuides:
		vs.viewIndentationGuides = static_cast<IndentView>(wParam);
		Redraw();
		break;

	case Message::GetIndentationGuides:
		return static_cast<sptr_t>(vs.viewIndentationGuides);

	case Message::SetHighlightGuide:
		if ((highlightGuideColumn != static_cast<int>(wParam)) || (wParam > 0)) {
			highlightGuideColumn = static_cast<int>(wParam);
			Redraw();
		}
		break;

	case Message::GetHighlightGuide:
		return highlightGuideColumn;

	case Message::GetLineEndPosition:
		return pdoc->LineEnd(LineFromUPtr(wParam));

	case Message::SetCodePage:
		if (ValidCodePage(static_cast<int>(wParam))) {
			if (pdoc->SetDBCSCodePage(static_cast<int>(wParam))) {
				pcs->Clear();
				pcs->InsertLines(0, pdoc->LinesTotal() - 1);
				SetAnnotationHeights(0, pdoc->LinesTotal());
				InvalidateStyleRedraw();
				SetRepresentations();
			}
		}
		break;

	case Message::GetCodePage:
		return pdoc->dbcsCodePage;

	case Message::SetIMEInteraction:
		imeInteraction = static_cast<IMEInteraction>(wParam);
		break;

	case Message::GetIMEInteraction:
		return static_cast<sptr_t>(imeInteraction);

	case Message::SetBidirectional:
		// Message::SetBidirectional is implemented on platform subclasses if they support bidirectional text.
		break;

	case Message::GetBidirectional:
		return static_cast<sptr_t>(bidirectional);

	case Message::GetLineCharacterIndex:
		return static_cast<sptr_t>(pdoc->LineCharacterIndex());

	case Message::AllocateLineCharacterIndex:
		pdoc->AllocateLineCharacterIndex(static_cast<LineCharacterIndexType>(wParam));
		break;

	case Message::ReleaseLineCharacterIndex:
		pdoc->ReleaseLineCharacterIndex(static_cast<LineCharacterIndexType>(wParam));
		break;

	case Message::LineFromIndexPosition:
		return pdoc->LineFromPositionIndex(PositionFromUPtr(wParam), static_cast<LineCharacterIndexType>(lParam));

	case Message::IndexPositionFromLine:
		return pdoc->IndexLineStart(LineFromUPtr(wParam), static_cast<LineCharacterIndexType>(lParam));

		// Marker definition and setting
	case Message::MarkerDefine:
		if (wParam <= MarkerMax) {
			vs.markers[wParam].markType = static_cast<MarkerSymbol>(lParam);
			vs.CalcLargestMarkerHeight();
		}
		InvalidateStyleData();
		RedrawSelMargin();
		break;

	case Message::MarkerSymbolDefined:
		if (wParam <= MarkerMax)
			return static_cast<sptr_t>(vs.markers[wParam].markType);
		else
			return 0;

	case Message::MarkerSetFore:
		if (wParam <= MarkerMax)
			vs.markers[wParam].fore = ColourRGBA::FromIpRGB(lParam);
		InvalidateStyleData();
		RedrawSelMargin();
		break;
	case Message::MarkerSetBack:
		if (wParam <= MarkerMax)
			vs.markers[wParam].back = ColourRGBA::FromIpRGB(lParam);
		InvalidateStyleData();
		RedrawSelMargin();
		break;
	case Message::MarkerSetBackSelected:
		if (wParam <= MarkerMax)
			vs.markers[wParam].backSelected = ColourRGBA::FromIpRGB(lParam);
		InvalidateStyleData();
		RedrawSelMargin();
		break;
	case Message::MarkerSetForeTranslucent:
		if (wParam <= MarkerMax)
			vs.markers[wParam].fore = ColourRGBA(static_cast<int>(lParam));
		InvalidateStyleData();
		RedrawSelMargin();
		break;
	case Message::MarkerSetBackTranslucent:
		if (wParam <= MarkerMax)
			vs.markers[wParam].back = ColourRGBA(static_cast<int>(lParam));
		InvalidateStyleData();
		RedrawSelMargin();
		break;
	case Message::MarkerSetBackSelectedTranslucent:
		if (wParam <= MarkerMax)
			vs.markers[wParam].backSelected = ColourRGBA(static_cast<int>(lParam));
		InvalidateStyleData();
		RedrawSelMargin();
		break;
	case Message::MarkerSetStrokeWidth:
		if (wParam <= MarkerMax)
			vs.markers[wParam].strokeWidth = static_cast<XYPOSITION>(lParam) / 100.0f;
		InvalidateStyleData();
		RedrawSelMargin();
		break;
	case Message::MarkerEnableHighlight:
		marginView.highlightDelimiter.isEnabled = wParam == 1;
		RedrawSelMargin();
		break;
	case Message::MarkerSetAlpha:
		if (wParam <= MarkerMax) {
			if (static_cast<Alpha>(lParam) == Alpha::NoAlpha) {
				SetAppearance(vs.markers[wParam].alpha, Alpha::Opaque);
				SetAppearance(vs.markers[wParam].layer, Layer::Base);
			} else {
				SetAppearance(vs.markers[wParam].alpha, static_cast<Alpha>(lParam));
				SetAppearance(vs.markers[wParam].layer, Layer::OverText);
			}
		}
		break;
	case Message::MarkerSetLayer:
		if (wParam <= MarkerMax) {
			SetAppearance(vs.markers[wParam].layer, static_cast<Layer>(lParam));
		}
		break;
	case Message::MarkerGetLayer:
		if (wParam <= MarkerMax) {
			return static_cast<sptr_t>(vs.markers[wParam].layer);
		}
		return 0;
	case Message::MarkerAdd: {
			const int markerID = pdoc->AddMark(LineFromUPtr(wParam), static_cast<int>(lParam));
			return markerID;
		}
	case Message::MarkerAddSet:
		if (lParam != 0)
			pdoc->AddMarkSet(LineFromUPtr(wParam), static_cast<int>(lParam));
		break;

	case Message::MarkerDelete:
		pdoc->DeleteMark(LineFromUPtr(wParam), static_cast<int>(lParam));
		break;

	case Message::MarkerDeleteAll:
		pdoc->DeleteAllMarks(static_cast<int>(wParam));
		break;

	case Message::MarkerGet:
		return GetMark(LineFromUPtr(wParam));

	case Message::MarkerNext:
		return pdoc->MarkerNext(LineFromUPtr(wParam), static_cast<int>(lParam));

	case Message::MarkerPrevious: {
			for (Sci::Line iLine = LineFromUPtr(wParam); iLine >= 0; iLine--) {
				if ((GetMark(iLine) & lParam) != 0)
					return iLine;
			}
		}
		return -1;

	case Message::MarkerDefinePixmap:
		if (wParam <= MarkerMax) {
			vs.markers[wParam].SetXPM(ConstCharPtrFromSPtr(lParam));
			vs.CalcLargestMarkerHeight();
		}
		InvalidateStyleData();
		RedrawSelMargin();
		break;

	case Message::RGBAImageSetWidth:
		sizeRGBAImage.x = static_cast<XYPOSITION>(wParam);
		break;

	case Message::RGBAImageSetHeight:
		sizeRGBAImage.y = static_cast<XYPOSITION>(wParam);
		break;

	case Message::RGBAImageSetScale:
		scaleRGBAImage = static_cast<float>(wParam);
		break;

	case Message::MarkerDefineRGBAImage:
		if (wParam <= MarkerMax) {
			vs.markers[wParam].SetRGBAImage(sizeRGBAImage, scaleRGBAImage / 100.0f, ConstUCharPtrFromSPtr(lParam));
			vs.CalcLargestMarkerHeight();
		}
		InvalidateStyleData();
		RedrawSelMargin();
		break;

	case Message::SetMarginTypeN:
		if (ValidMargin(wParam)) {
			vs.ms[wParam].style = static_cast<MarginType>(lParam);
			InvalidateStyleRedraw();
		}
		break;

	case Message::GetMarginTypeN:
		if (ValidMargin(wParam))
			return static_cast<sptr_t>(vs.ms[wParam].style);
		else
			return 0;

	case Message::SetMarginWidthN:
		if (ValidMargin(wParam)) {
			// Short-circuit if the width is unchanged, to avoid unnecessary redraw.
			if (vs.ms[wParam].width != lParam) {
				lastXChosen += static_cast<int>(lParam) - vs.ms[wParam].width;
				vs.ms[wParam].width = static_cast<int>(lParam);
				InvalidateStyleRedraw();
			}
		}
		break;

	case Message::GetMarginWidthN:
		if (ValidMargin(wParam))
			return vs.ms[wParam].width;
		else
			return 0;

	case Message::SetMarginMaskN:
		if (ValidMargin(wParam)) {
			vs.ms[wParam].mask = static_cast<int>(lParam);
			InvalidateStyleRedraw();
		}
		break;

	case Message::GetMarginMaskN:
		if (ValidMargin(wParam))
			return vs.ms[wParam].mask;
		else
			return 0;

	case Message::SetMarginSensitiveN:
		if (ValidMargin(wParam)) {
			vs.ms[wParam].sensitive = lParam != 0;
			InvalidateStyleRedraw();
		}
		break;

	case Message::GetMarginSensitiveN:
		if (ValidMargin(wParam))
			return vs.ms[wParam].sensitive ? 1 : 0;
		else
			return 0;

	case Message::SetMarginCursorN:
		if (ValidMargin(wParam))
			vs.ms[wParam].cursor = static_cast<CursorShape>(lParam);
		break;

	case Message::GetMarginCursorN:
		if (ValidMargin(wParam))
			return static_cast<sptr_t>(vs.ms[wParam].cursor);
		else
			return 0;

	case Message::SetMarginBackN:
		if (ValidMargin(wParam)) {
			vs.ms[wParam].back = ColourRGBA::FromIpRGB(lParam);
			InvalidateStyleRedraw();
		}
		break;

	case Message::GetMarginBackN:
		if (ValidMargin(wParam))
			return vs.ms[wParam].back.OpaqueRGB();
		else
			return 0;

	case Message::SetMargins:
		if (wParam < 1000)
			vs.ms.resize(wParam);
		break;

	case Message::GetMargins:
		return vs.ms.size();

	case Message::StyleClearAll:
		vs.ClearStyles((size_t)wParam, (size_t)lParam); //Au: added wParam, lParam (from/to)
		InvalidateStyleRedraw();
		break;

	case Message::StyleSetFore:
	case Message::StyleSetBack:
	case Message::StyleSetBold:
	case Message::StyleSetWeight:
	case Message::StyleSetStretch:
	case Message::StyleSetItalic:
	case Message::StyleSetEOLFilled:
	case Message::StyleSetSize:
	case Message::StyleSetSizeFractional:
	case Message::StyleSetFont:
	case Message::StyleSetUnderline:
	case Message::StyleSetCase:
	case Message::StyleSetCharacterSet:
	case Message::StyleSetVisible:
	case Message::StyleSetChangeable:
	case Message::StyleSetHotSpot:
	case Message::StyleSetCheckMonospaced:
	case Message::StyleSetInvisibleRepresentation:
		StyleSetMessage(iMessage, wParam, lParam);
		break;

	case Message::StyleGetFore:
	case Message::StyleGetBack:
	case Message::StyleGetBold:
	case Message::StyleGetWeight:
	case Message::StyleGetStretch:
	case Message::StyleGetItalic:
	case Message::StyleGetEOLFilled:
	case Message::StyleGetSize:
	case Message::StyleGetSizeFractional:
	case Message::StyleGetFont:
	case Message::StyleGetUnderline:
	case Message::StyleGetCase:
	case Message::StyleGetCharacterSet:
	case Message::StyleGetVisible:
	case Message::StyleGetChangeable:
	case Message::StyleGetHotSpot:
	case Message::StyleGetCheckMonospaced:
	case Message::StyleGetInvisibleRepresentation:
		return StyleGetMessage(iMessage, wParam, lParam);

	case Message::StyleResetDefault:
		vs.ResetDefaultStyle();
		InvalidateStyleRedraw();
		break;

	case Message::SetElementColour:
		if (vs.SetElementColour(static_cast<Element>(wParam), ColourRGBA(static_cast<int>(lParam)))) {
			InvalidateStyleRedraw();
		}
		break;

	case Message::GetElementColour:
		return vs.ElementColour(static_cast<Element>(wParam)).value_or(ColourRGBA()).AsInteger();

	case Message::ResetElementColour:
		if (vs.ResetElement(static_cast<Element>(wParam))) {
			InvalidateStyleRedraw();
		}
		break;

	case Message::GetElementIsSet:
		return vs.ElementColour(static_cast<Element>(wParam)).has_value();

	case Message::GetElementAllowsTranslucent:
		return vs.ElementAllowsTranslucent(static_cast<Element>(wParam));

	case Message::GetElementBaseColour:
		return vs.elementBaseColours[static_cast<Element>(wParam)].value_or(ColourRGBA()).AsInteger();

	case Message::SetFontLocale:
		if (lParam) {
			vs.SetFontLocaleName(ConstCharPtrFromSPtr(lParam));
			InvalidateStyleRedraw();
		}
		break;

	case Message::GetFontLocale:
		return StringResult(lParam, vs.localeName.c_str());

#ifdef INCLUDE_DEPRECATED_FEATURES
	case SCI_SETSTYLEBITS:
		vs.EnsureStyle(0xff);
		break;

	case SCI_GETSTYLEBITS:
		return 8;
#endif

	case Message::SetLineState:
		return pdoc->SetLineState(LineFromUPtr(wParam), static_cast<int>(lParam));

	case Message::GetLineState:
		return pdoc->GetLineState(LineFromUPtr(wParam));

	case Message::GetMaxLineState:
		return pdoc->GetMaxLineState();

	case Message::GetCaretLineVisible:
		return vs.ElementColour(Element::CaretLineBack) ? 1 : 0;
	case Message::SetCaretLineVisible:
		if (wParam) {
			if (!vs.elementColours.count(Element::CaretLineBack)) {
				// Yellow default
				vs.elementColours[Element::CaretLineBack] = ColourRGBA(maximumByte, maximumByte, 0);
				InvalidateStyleRedraw();
			}
		} else {
			if (vs.ResetElement(Element::CaretLineBack)) {
				InvalidateStyleRedraw();
			}
		}
		break;
	case Message::GetCaretLineVisibleAlways:
		return vs.caretLine.alwaysShow;
	case Message::SetCaretLineVisibleAlways:
		vs.caretLine.alwaysShow = wParam != 0;
		InvalidateStyleRedraw();
		break;

	case Message::GetCaretLineHighlightSubLine:
		return vs.caretLine.subLine;
	case Message::SetCaretLineHighlightSubLine:
		vs.caretLine.subLine = wParam != 0;
		InvalidateStyleRedraw();
		break;

	case Message::GetCaretLineFrame:
		return vs.caretLine.frame;
	case Message::SetCaretLineFrame:
		vs.caretLine.frame = static_cast<int>(wParam);
		InvalidateStyleRedraw();
		break;
	case Message::GetCaretLineBack:
		return vs.ElementColourForced(Element::CaretLineBack).OpaqueRGB();

	case Message::SetCaretLineBack:
		vs.SetElementRGB(Element::CaretLineBack, static_cast<int>(wParam));
		InvalidateStyleRedraw();
		break;

	case Message::GetCaretLineLayer:
		return static_cast<sptr_t>(vs.caretLine.layer);

	case Message::SetCaretLineLayer:
		if (vs.caretLine.layer != static_cast<Layer>(wParam)) {
			vs.caretLine.layer = static_cast<Layer>(wParam);
			UpdateBaseElements();
			InvalidateStyleRedraw();
		}
		break;

	case Message::GetCaretLineBackAlpha:
		if (vs.caretLine.layer == Layer::Base)
			return static_cast<sptr_t>(Alpha::NoAlpha);
		return vs.ElementColour(Element::CaretLineBack).value_or(ColourRGBA()).GetAlpha();

	case Message::SetCaretLineBackAlpha: {
			const Layer layerNew = (static_cast<Alpha>(wParam) == Alpha::NoAlpha) ? Layer::Base : Layer::OverText;
			vs.caretLine.layer = layerNew;
			if (vs.ElementColour(Element::CaretLineBack)) {
				vs.SetElementAlpha(Element::CaretLineBack, static_cast<int>(wParam));
			}
			InvalidateStyleRedraw();
		}
		break;

		// Folding messages

	case Message::VisibleFromDocLine:
		return pcs->DisplayFromDoc(LineFromUPtr(wParam));

	case Message::DocLineFromVisible:
		return pcs->DocFromDisplay(LineFromUPtr(wParam));

	case Message::WrapCount:
		return WrapCount(LineFromUPtr(wParam));

	case Message::SetFoldLevel: {
			const int prev = pdoc->SetLevel(LineFromUPtr(wParam), static_cast<int>(lParam));
			if (prev != static_cast<int>(lParam))
				RedrawSelMargin();
			return prev;
		}

	case Message::GetFoldLevel:
		return pdoc->GetLevel(LineFromUPtr(wParam));

	case Message::GetLastChild:
		return pdoc->GetLastChild(LineFromUPtr(wParam), OptionalFoldLevel(lParam));

	case Message::GetFoldParent:
		return pdoc->GetFoldParent(LineFromUPtr(wParam));

	case Message::ShowLines:
		pcs->SetVisible(LineFromUPtr(wParam), lParam, true);
		SetScrollBars();
		Redraw();
		break;

	case Message::HideLines:
		pcs->SetVisible(LineFromUPtr(wParam), lParam, false);
		SetScrollBars();
		Redraw();
		break;

	case Message::GetLineVisible:
		return pcs->GetVisible(LineFromUPtr(wParam));

	case Message::GetAllLinesVisible:
		return pcs->HiddenLines() ? 0 : 1;

	case Message::SetFoldExpanded:
		SetFoldExpanded(LineFromUPtr(wParam), lParam != 0);
		break;

	case Message::GetFoldExpanded:
		return pcs->GetExpanded(LineFromUPtr(wParam));

	case Message::SetAutomaticFold:
		foldAutomatic = static_cast<AutomaticFold>(wParam);
		break;

	case Message::GetAutomaticFold:
		return static_cast<sptr_t>(foldAutomatic);

	case Message::SetFoldFlags:
		foldFlags = static_cast<FoldFlag>(wParam);
		Redraw();
		break;

	case Message::ToggleFoldShowText:
		pcs->SetFoldDisplayText(LineFromUPtr(wParam), ConstCharPtrFromSPtr(lParam));
		FoldLine(LineFromUPtr(wParam), FoldAction::Toggle);
		break;

	case Message::FoldDisplayTextSetStyle:
		foldDisplayTextStyle = static_cast<FoldDisplayTextStyle>(wParam);
		Redraw();
		break;

	case Message::FoldDisplayTextGetStyle:
		return static_cast<sptr_t>(foldDisplayTextStyle);

	case Message::SetDefaultFoldDisplayText:
		SetDefaultFoldDisplayText(ConstCharPtrFromSPtr(lParam));
		Redraw();
		break;

	case Message::GetDefaultFoldDisplayText:
		return StringResult(lParam, GetDefaultFoldDisplayText());

	case Message::ToggleFold:
		FoldLine(LineFromUPtr(wParam), FoldAction::Toggle);
		break;

	case Message::FoldLine:
		FoldLine(LineFromUPtr(wParam), static_cast<FoldAction>(lParam));
		break;

	case Message::FoldChildren:
		FoldExpand(LineFromUPtr(wParam), static_cast<FoldAction>(lParam), pdoc->GetFoldLevel(LineFromUPtr(wParam)));
		break;

	case Message::FoldAll:
		FoldAll(static_cast<FoldAction>(wParam));
		break;

	case Message::ExpandChildren:
		FoldExpand(LineFromUPtr(wParam), FoldAction::Expand, static_cast<FoldLevel>(lParam));
		break;

	case Message::ContractedFoldNext:
		return ContractedFoldNext(LineFromUPtr(wParam));

	case Message::EnsureVisible:
		EnsureLineVisible(LineFromUPtr(wParam), false);
		break;

	case Message::EnsureVisibleEnforcePolicy:
		EnsureLineVisible(LineFromUPtr(wParam), true);
		break;

	case Message::ScrollRange:
		ScrollRange(SelectionRange(PositionFromUPtr(wParam), lParam));
		break;

	case Message::SearchAnchor:
		SearchAnchor();
		break;

	case Message::SearchNext:
	case Message::SearchPrev:
		return SearchText(iMessage, wParam, lParam);

	case Message::SetXCaretPolicy:
		caretPolicies.x = CaretPolicySlop(wParam, lParam);
		break;

	case Message::SetYCaretPolicy:
		caretPolicies.y = CaretPolicySlop(wParam, lParam);
		break;

	case Message::SetVisiblePolicy:
		visiblePolicy = VisiblePolicySlop(wParam, lParam);
		break;

	case Message::LinesOnScreen:
		return LinesOnScreen();

	case Message::SetSelFore:
		vs.elementColours[Element::SelectionText] = OptionalColour(wParam, lParam);
		vs.elementColours[Element::SelectionAdditionalText] = OptionalColour(wParam, lParam);
		InvalidateStyleRedraw();
		break;

	case Message::SetSelBack:
		if (wParam) {
			vs.SetElementRGB(Element::SelectionBack, static_cast<int>(lParam));
			vs.SetElementRGB(Element::SelectionAdditionalBack, static_cast<int>(lParam));
		} else {
			vs.ResetElement(Element::SelectionBack);
			vs.ResetElement(Element::SelectionAdditionalBack);
		}
		InvalidateStyleRedraw();
		break;

	case Message::SetSelAlpha: {
			const Layer layerNew = (static_cast<Alpha>(wParam) == Alpha::NoAlpha) ? Layer::Base : Layer::OverText;
			if (vs.selection.layer != layerNew) {
			    vs.selection.layer = layerNew;
			    UpdateBaseElements();
			}
			const int alpha = static_cast<int>(wParam);
			vs.SetElementAlpha(Element::SelectionBack, alpha);
			vs.SetElementAlpha(Element::SelectionAdditionalBack, alpha);
			vs.SetElementAlpha(Element::SelectionSecondaryBack, alpha);
			vs.SetElementAlpha(Element::SelectionInactiveBack, alpha);
			InvalidateStyleRedraw();
		}
		break;

	case Message::GetSelAlpha:
		if (vs.selection.layer == Layer::Base)
			return static_cast<sptr_t>(Alpha::NoAlpha);
		return vs.ElementColourForced(Element::SelectionBack).GetAlpha();

	case Message::GetSelEOLFilled:
		return vs.selection.eolFilled;

	case Message::SetSelEOLFilled:
		vs.selection.eolFilled = wParam != 0;
		InvalidateStyleRedraw();
		break;

	case Message::SetWhitespaceFore:
		if (vs.SetElementColourOptional(Element::WhiteSpace, wParam, lParam)) {
			InvalidateStyleRedraw();
		}
		break;

	case Message::SetWhitespaceBack:
		if (vs.SetElementColourOptional(Element::WhiteSpaceBack, wParam, lParam)) {
			InvalidateStyleRedraw();
		}
		break;

	case Message::SetSelectionLayer:
		if (vs.selection.layer != static_cast<Layer>(wParam)) {
			vs.selection.layer = static_cast<Layer>(wParam);
			UpdateBaseElements();
			InvalidateStyleRedraw();
		}
		break;

	case Message::GetSelectionLayer:
		return static_cast<sptr_t>(vs.selection.layer);

	case Message::SetCaretFore:
		vs.elementColours[Element::Caret] = ColourRGBA::FromIpRGB(SPtrFromUPtr(wParam));
		InvalidateStyleRedraw();
		break;

	case Message::GetCaretFore:
		return vs.ElementColourForced(Element::Caret).OpaqueRGB();

	case Message::SetCaretStyle:
		if (static_cast<CaretStyle>(wParam) <= (CaretStyle::Block | CaretStyle::OverstrikeBlock | CaretStyle::Curses | CaretStyle::BlockAfter))
			vs.caret.style = static_cast<CaretStyle>(wParam);
		else
			/* Default to the line caret */
			vs.caret.style = CaretStyle::Line;
		InvalidateStyleRedraw();
		break;

	case Message::GetCaretStyle:
		return static_cast<sptr_t>(vs.caret.style);

	case Message::SetCaretWidth:
		vs.caret.width = std::clamp(static_cast<int>(wParam), 0, 20);
		InvalidateStyleRedraw();
		break;

	case Message::GetCaretWidth:
		return vs.caret.width;

	case Message::AssignCmdKey:
		kmap.AssignCmdKey(static_cast<Keys>(LowShortFromWParam(wParam)),
			static_cast<KeyMod>(HighShortFromWParam(wParam)), static_cast<Message>(lParam));
		break;

	case Message::ClearCmdKey:
		kmap.AssignCmdKey(static_cast<Keys>(LowShortFromWParam(wParam)),
			static_cast<KeyMod>(HighShortFromWParam(wParam)), Message::Null);
		break;

	case Message::ClearAllCmdKeys:
		kmap.Clear();
		break;

	case Message::IndicSetStyle:
		if (wParam <= IndicatorMax) {
			vs.indicators[wParam].sacNormal.style = static_cast<IndicatorStyle>(lParam);
			vs.indicators[wParam].sacHover.style = static_cast<IndicatorStyle>(lParam);
			InvalidateStyleRedraw();
		}
		break;

	case Message::IndicGetStyle:
		return (wParam <= IndicatorMax) ?
			static_cast<sptr_t>(vs.indicators[wParam].sacNormal.style) : 0;

	case Message::IndicSetFore:
		if (wParam <= IndicatorMax) {
			vs.indicators[wParam].sacNormal.fore = ColourRGBA::FromIpRGB(lParam);
			vs.indicators[wParam].sacHover.fore = ColourRGBA::FromIpRGB(lParam);
			InvalidateStyleRedraw();
		}
		break;

	case Message::IndicGetFore:
		return (wParam <= IndicatorMax) ?
			vs.indicators[wParam].sacNormal.fore.OpaqueRGB() : 0;

	case Message::IndicSetHoverStyle:
		if (wParam <= IndicatorMax) {
			vs.indicators[wParam].sacHover.style = static_cast<IndicatorStyle>(lParam);
			InvalidateStyleRedraw();
		}
		break;

	case Message::IndicGetHoverStyle:
		return (wParam <= IndicatorMax) ?
			static_cast<sptr_t>(vs.indicators[wParam].sacHover.style) : 0;

	case Message::IndicSetHoverFore:
		if (wParam <= IndicatorMax) {
			vs.indicators[wParam].sacHover.fore = ColourRGBA::FromIpRGB(lParam);
			InvalidateStyleRedraw();
		}
		break;

	case Message::IndicGetHoverFore:
		return (wParam <= IndicatorMax) ?
			vs.indicators[wParam].sacHover.fore.OpaqueRGB() : 0;

	case Message::IndicSetFlags:
		if (wParam <= IndicatorMax) {
			vs.indicators[wParam].SetFlags(static_cast<IndicFlag>(lParam));
			InvalidateStyleRedraw();
		}
		break;

	case Message::IndicGetFlags:
		return (wParam <= IndicatorMax) ?
			static_cast<sptr_t>(vs.indicators[wParam].Flags()) : 0;

	case Message::IndicSetUnder:
		if (wParam <= IndicatorMax) {
			vs.indicators[wParam].under = lParam != 0;
			InvalidateStyleRedraw();
		}
		break;

	case Message::IndicGetUnder:
		return (wParam <= IndicatorMax) ?
			vs.indicators[wParam].under : 0;

	case Message::IndicSetAlpha:
		if (wParam <= IndicatorMax && lParam >=0 && lParam <= 255) {
			vs.indicators[wParam].fillAlpha = static_cast<int>(lParam);
			InvalidateStyleRedraw();
		}
		break;

	case Message::IndicGetAlpha:
		return (wParam <= IndicatorMax)
			? vs.indicators[wParam].fillAlpha : 0;

	case Message::IndicSetOutlineAlpha:
		if (wParam <= IndicatorMax && lParam >=0 && lParam <= 255) {
			vs.indicators[wParam].outlineAlpha = static_cast<int>(lParam);
			InvalidateStyleRedraw();
		}
		break;

	case Message::IndicGetOutlineAlpha:
		return (wParam <= IndicatorMax) ? vs.indicators[wParam].outlineAlpha : 0;

	case Message::IndicSetStrokeWidth:
		if (wParam <= IndicatorMax && lParam >= 0 && lParam <= 1000) {
			vs.indicators[wParam].strokeWidth = static_cast<XYPOSITION>(lParam) / 100.0;
			InvalidateStyleRedraw();
		}
		break;

	case Message::IndicGetStrokeWidth:
		if (wParam <= IndicatorMax) {
			return std::lround(vs.indicators[wParam].strokeWidth * 100);
		}
		break;

	case Message::SetIndicatorCurrent:
		pdoc->DecorationSetCurrentIndicator(static_cast<int>(wParam));
		break;
	case Message::GetIndicatorCurrent:
		return pdoc->decorations->GetCurrentIndicator();
	case Message::SetIndicatorValue:
		pdoc->decorations->SetCurrentValue(static_cast<int>(wParam));
		break;
	case Message::GetIndicatorValue:
		return pdoc->decorations->GetCurrentValue();

	case Message::IndicatorFillRange:
		pdoc->DecorationFillRange(PositionFromUPtr(wParam),
			pdoc->decorations->GetCurrentValue(), lParam);
		break;

	case Message::IndicatorClearRange:
		pdoc->DecorationFillRange(PositionFromUPtr(wParam), 0,
			lParam);
		break;

	case Message::IndicatorAllOnFor:
		return pdoc->decorations->AllOnFor(PositionFromUPtr(wParam));

	case Message::IndicatorValueAt:
		return pdoc->decorations->ValueAt(static_cast<int>(wParam), lParam);

	case Message::IndicatorStart:
		return pdoc->decorations->Start(static_cast<int>(wParam), lParam);

	case Message::IndicatorEnd:
		return pdoc->decorations->End(static_cast<int>(wParam), lParam);

	case Message::LineDown:
	case Message::LineDownExtend:
	case Message::ParaDown:
	case Message::ParaDownExtend:
	case Message::LineUp:
	case Message::LineUpExtend:
	case Message::ParaUp:
	case Message::ParaUpExtend:
	case Message::CharLeft:
	case Message::CharLeftExtend:
	case Message::CharRight:
	case Message::CharRightExtend:
	case Message::WordLeft:
	case Message::WordLeftExtend:
	case Message::WordRight:
	case Message::WordRightExtend:
	case Message::WordLeftEnd:
	case Message::WordLeftEndExtend:
	case Message::WordRightEnd:
	case Message::WordRightEndExtend:
	case Message::Home:
	case Message::HomeExtend:
	case Message::LineEnd:
	case Message::LineEndExtend:
	case Message::HomeWrap:
	case Message::HomeWrapExtend:
	case Message::LineEndWrap:
	case Message::LineEndWrapExtend:
	case Message::DocumentStart:
	case Message::DocumentStartExtend:
	case Message::DocumentEnd:
	case Message::DocumentEndExtend:
	case Message::ScrollToStart:
	case Message::ScrollToEnd:

	case Message::StutteredPageUp:
	case Message::StutteredPageUpExtend:
	case Message::StutteredPageDown:
	case Message::StutteredPageDownExtend:

	case Message::PageUp:
	case Message::PageUpExtend:
	case Message::PageDown:
	case Message::PageDownExtend:
	case Message::EditToggleOvertype:
	case Message::Cancel:
	case Message::DeleteBack:
	case Message::Tab:
	case Message::LineIndent:
	case Message::BackTab:
	case Message::LineDedent:
	case Message::NewLine:
	case Message::FormFeed:
	case Message::VCHome:
	case Message::VCHomeExtend:
	case Message::VCHomeWrap:
	case Message::VCHomeWrapExtend:
	case Message::VCHomeDisplay:
	case Message::VCHomeDisplayExtend:
	case Message::ZoomIn:
	case Message::ZoomOut:
	case Message::DelWordLeft:
	case Message::DelWordRight:
	case Message::DelWordRightEnd:
	case Message::DelLineLeft:
	case Message::DelLineRight:
	case Message::LineCopy:
	case Message::LineCut:
	case Message::LineDelete:
	case Message::LineTranspose:
	case Message::LineReverse:
	case Message::LineDuplicate:
	case Message::LowerCase:
	case Message::UpperCase:
	case Message::LineScrollDown:
	case Message::LineScrollUp:
	case Message::WordPartLeft:
	case Message::WordPartLeftExtend:
	case Message::WordPartRight:
	case Message::WordPartRightExtend:
	case Message::DeleteBackNotLine:
	case Message::HomeDisplay:
	case Message::HomeDisplayExtend:
	case Message::LineEndDisplay:
	case Message::LineEndDisplayExtend:
	case Message::LineDownRectExtend:
	case Message::LineUpRectExtend:
	case Message::CharLeftRectExtend:
	case Message::CharRightRectExtend:
	case Message::HomeRectExtend:
	case Message::VCHomeRectExtend:
	case Message::LineEndRectExtend:
	case Message::PageUpRectExtend:
	case Message::PageDownRectExtend:
	case Message::SelectionDuplicate:
		return KeyCommand(iMessage);

	case Message::BraceHighlight:
		SetBraceHighlight(PositionFromUPtr(wParam), lParam, StyleBraceLight);
		break;

	case Message::BraceHighlightIndicator:
		if (lParam >= 0 && static_cast<size_t>(lParam) <= IndicatorMax) {
			vs.braceHighlightIndicatorSet = wParam != 0;
			vs.braceHighlightIndicator = static_cast<int>(lParam);
		}
		break;

	case Message::BraceBadLight:
		SetBraceHighlight(PositionFromUPtr(wParam), -1, StyleBraceBad);
		break;

	case Message::BraceBadLightIndicator:
		if (lParam >= 0 && static_cast<size_t>(lParam) <= IndicatorMax) {
			vs.braceBadLightIndicatorSet = wParam != 0;
			vs.braceBadLightIndicator = static_cast<int>(lParam);
		}
		break;

	case Message::BraceMatch:
		// wParam is position of char to find brace for,
		// lParam is maximum amount of text to restyle to find it
		return pdoc->BraceMatch(PositionFromUPtr(wParam), lParam, 0, false);

	case Message::BraceMatchNext:
		return pdoc->BraceMatch(PositionFromUPtr(wParam), 0, lParam, true);

	case Message::GetViewEOL:
		return vs.viewEOL;

	case Message::SetViewEOL:
		vs.viewEOL = wParam != 0;
		InvalidateStyleRedraw();
		break;

	case Message::SetZoom:
		if (SetAppearance(vs.zoomLevel, static_cast<int>(wParam))) {
			NotifyZoom();
		}
		break;

	case Message::GetZoom:
		return vs.zoomLevel;

	case Message::GetEdgeColumn:
		return vs.theEdge.column;

	case Message::SetEdgeColumn:
		vs.theEdge.column = static_cast<int>(wParam);
		InvalidateStyleRedraw();
		break;

	case Message::GetEdgeMode:
		return static_cast<sptr_t>(vs.edgeState);

	case Message::SetEdgeMode:
		vs.edgeState = static_cast<EdgeVisualStyle>(wParam);
		InvalidateStyleRedraw();
		break;

	case Message::GetEdgeColour:
		return vs.theEdge.colour.OpaqueRGB();

	case Message::SetEdgeColour:
		vs.theEdge.colour = ColourRGBA::FromIpRGB(SPtrFromUPtr(wParam));
		InvalidateStyleRedraw();
		break;

	case Message::MultiEdgeAddLine:
		vs.AddMultiEdge(static_cast<int>(wParam), ColourRGBA::FromIpRGB(lParam));
		InvalidateStyleRedraw();
		break;

	case Message::MultiEdgeClearAll:
		std::vector<EdgeProperties>().swap(vs.theMultiEdge); // Free vector and memory, C++03 compatible
		InvalidateStyleRedraw();
		break;

	case Message::GetMultiEdgeColumn: {
			const size_t which = wParam;
			// size_t is unsigned so this also handles negative inputs.
			if (which >= vs.theMultiEdge.size()) {
				return -1;
			}
			return vs.theMultiEdge[which].column;
		}

	case Message::GetAccessibility:
		return static_cast<sptr_t>(Accessibility::Disabled);

	case Message::SetAccessibility:
		// May be implemented by platform code.
		break;

	case Message::GetDocPointer:
		return SPtrFromPtr(pdoc->AsDocumentEditable());

	case Message::SetDocPointer:
		CancelModes();
		SetDocPointer(static_cast<Document *>(static_cast<IDocumentEditable *>(PtrFromSPtr(lParam))));
		return 0;

	case Message::CreateDocument: {
			Document *doc = new Document(static_cast<DocumentOption>(lParam));
			doc->AddRef();
			doc->Allocate(PositionFromUPtr(wParam));
			pcs = ContractionStateCreate(pdoc->IsLarge());
			return SPtrFromPtr(doc->AsDocumentEditable());
		}

	case Message::AddRefDocument:
		(static_cast<IDocumentEditable *>(PtrFromSPtr(lParam)))->AddRef();
		break;

	case Message::ReleaseDocument:
		(static_cast<IDocumentEditable *>(PtrFromSPtr(lParam)))->Release();
		break;

	case Message::GetDocumentOptions:
		return static_cast<sptr_t>(pdoc->Options());

	case Message::CreateLoader: {
			Document *doc = new Document(static_cast<DocumentOption>(lParam));
			doc->AddRef();
			doc->Allocate(PositionFromUPtr(wParam));
			doc->SetUndoCollection(false);
			pcs = ContractionStateCreate(pdoc->IsLarge());
			ILoader *loader = doc;
			return reinterpret_cast<sptr_t>(loader);
		}

	case Message::SetModEventMask:
		modEventMask = static_cast<ModificationFlags>(wParam);
		return 0;

	case Message::GetModEventMask:
		return static_cast<sptr_t>(modEventMask);

	case Message::SetCommandEvents:
		commandEvents = static_cast<bool>(wParam);
		return 0;

	case Message::GetCommandEvents:
		return commandEvents;

	case Message::ConvertEOLs:
		pdoc->ConvertLineEnds(static_cast<EndOfLine>(wParam));
		SetSelection(sel.MainCaret(), sel.MainAnchor());	// Ensure selection inside document
		return 0;

	case Message::SetLengthForEncode:
		lengthForEncode = PositionFromUPtr(wParam);
		return 0;

	case Message::SelectionIsRectangle:
		return sel.selType == Selection::SelTypes::rectangle ? 1 : 0;

	case Message::SetSelectionMode:
		SetSelectionMode(wParam, true);
		break;
	case Message::ChangeSelectionMode:
		SetSelectionMode(wParam, false);
		break;
	case Message::GetSelectionMode:
		switch (sel.selType) {
		case Selection::SelTypes::stream:
			return static_cast<sptr_t>(SelectionMode::Stream);
		case Selection::SelTypes::rectangle:
			return static_cast<sptr_t>(SelectionMode::Rectangle);
		case Selection::SelTypes::lines:
			return static_cast<sptr_t>(SelectionMode::Lines);
		case Selection::SelTypes::thin:
			return static_cast<sptr_t>(SelectionMode::Thin);
		default:	// ?!
			return static_cast<sptr_t>(SelectionMode::Stream);
		}
	case Message::SetMoveExtendsSelection:
		sel.SetMoveExtends(wParam != 0);
		break;
	case Message::GetMoveExtendsSelection:
		return sel.MoveExtends();
	case Message::GetLineSelStartPosition:
	case Message::GetLineSelEndPosition: {
			const SelectionSegment segmentLine(
				pdoc->LineStart(LineFromUPtr(wParam)),
				pdoc->LineEnd(LineFromUPtr(wParam)));
			for (size_t r=0; r<sel.Count(); r++) {
				const SelectionSegment portion = sel.Range(r).Intersect(segmentLine);
				if (portion.start.IsValid()) {
					return (iMessage == Message::GetLineSelStartPosition) ? portion.start.Position() : portion.end.Position();
				}
			}
			return Sci::invalidPosition;
		}

	case Message::SetOvertype:
		if (inOverstrike != (wParam != 0)) {
			inOverstrike = wParam != 0;
			ContainerNeedsUpdate(Update::Selection);
			ShowCaretAtCurrentPosition();
			SetIdle(true);
		}
		break;

	case Message::GetOvertype:
		return inOverstrike ? 1 : 0;

	case Message::SetFocus:
		SetFocusState(wParam != 0);
		break;

	case Message::GetFocus:
		return hasFocus;

	case Message::SetStatus:
		errorStatus = static_cast<Status>(wParam);
		break;

	case Message::GetStatus:
		return static_cast<sptr_t>(errorStatus);

	case Message::SetMouseDownCaptures:
		mouseDownCaptures = wParam != 0;
		break;

	case Message::GetMouseDownCaptures:
		return mouseDownCaptures;

	case Message::SetMouseWheelCaptures:
		mouseWheelCaptures = wParam != 0;
		break;

	case Message::GetMouseWheelCaptures:
		return mouseWheelCaptures;

	case Message::SetCursor:
		cursorMode = static_cast<CursorShape>(wParam);
		DisplayCursor(Window::Cursor::text);
		break;

	case Message::GetCursor:
		return static_cast<sptr_t>(cursorMode);

	case Message::SetControlCharSymbol:
		vs.controlCharSymbol = static_cast<int>(wParam);
		InvalidateStyleRedraw();
		break;

	case Message::GetControlCharSymbol:
		return vs.controlCharSymbol;

	case Message::SetRepresentation:
		reprs->SetRepresentation(ConstCharPtrFromUPtr(wParam), ConstCharPtrFromSPtr(lParam));
		break;

	case Message::GetRepresentation: {
			const Representation *repr = reprs->RepresentationFromCharacter(
				ConstCharPtrFromUPtr(wParam));
			if (repr) {
				return StringResult(lParam, repr->stringRep.c_str());
			}
			return 0;
		}

	case Message::ClearRepresentation:
		reprs->ClearRepresentation(ConstCharPtrFromUPtr(wParam));
		break;

	case Message::ClearAllRepresentations:
		SetRepresentations();
		break;

	case Message::SetRepresentationAppearance:
		reprs->SetRepresentationAppearance(ConstCharPtrFromUPtr(wParam), static_cast<RepresentationAppearance>(lParam));
		break;

	case Message::GetRepresentationAppearance: {
			const Representation *repr = reprs->RepresentationFromCharacter(
				ConstCharPtrFromUPtr(wParam));
			if (repr) {
				return static_cast<sptr_t>(repr->appearance);
			}
			return 0;
		}
	case Message::SetRepresentationColour:
		reprs->SetRepresentationColour(ConstCharPtrFromUPtr(wParam), ColourRGBA(static_cast<int>(lParam)));
		break;

	case Message::GetRepresentationColour: {
			const Representation *repr = reprs->RepresentationFromCharacter(
				ConstCharPtrFromUPtr(wParam));
			if (repr) {
				return repr->colour.AsInteger();
			}
			return 0;
		}

	case Message::StartRecord:
		recordingMacro = true;
		return 0;

	case Message::StopRecord:
		recordingMacro = false;
		return 0;

	case Message::MoveCaretInsideView:
		MoveCaretInsideView();
		break;

	case Message::SetFoldMarginColour:
		vs.foldmarginColour = OptionalColour(wParam, lParam);
		InvalidateStyleRedraw();
		break;

	case Message::SetFoldMarginHiColour:
		vs.foldmarginHighlightColour = OptionalColour(wParam, lParam);
		InvalidateStyleRedraw();
		break;

	case Message::SetHotspotActiveFore:
		if (vs.SetElementColourOptional(Element::HotSpotActive, wParam, lParam)) {
			InvalidateStyleRedraw();
		}
		break;

	case Message::GetHotspotActiveFore:
		return vs.ElementColour(Element::HotSpotActive).value_or(ColourRGBA()).OpaqueRGB();

	case Message::SetHotspotActiveBack:
		if (vs.SetElementColourOptional(Element::HotSpotActiveBack, wParam, lParam)) {
			InvalidateStyleRedraw();
		}
		break;

	case Message::GetHotspotActiveBack:
		return vs.ElementColour(Element::HotSpotActiveBack).value_or(ColourRGBA()).OpaqueRGB();

	case Message::SetHotspotActiveUnderline:
		vs.hotspotUnderline = wParam != 0;
		InvalidateStyleRedraw();
		break;

	case Message::GetHotspotActiveUnderline:
		return vs.hotspotUnderline ? 1 : 0;

	case Message::SetHotspotSingleLine:
		hotspotSingleLine = wParam != 0;
		InvalidateStyleRedraw();
		break;

	case Message::GetHotspotSingleLine:
		return hotspotSingleLine ? 1 : 0;

	case Message::SetPasteConvertEndings:
		convertPastes = wParam != 0;
		break;

	case Message::GetPasteConvertEndings:
		return convertPastes ? 1 : 0;

	case Message::GetCharacterPointer:
		return reinterpret_cast<sptr_t>(pdoc->BufferPointer());

	case Message::GetRangePointer:
		return reinterpret_cast<sptr_t>(pdoc->RangePointer(
			PositionFromUPtr(wParam), lParam));

	case Message::GetGapPosition:
		return pdoc->GapPosition();

	case Message::SetChangeHistory:
		changeHistoryOption = static_cast<ChangeHistoryOption>(wParam);
		pdoc->ChangeHistorySet(wParam & 1);
		break;

	case Message::GetChangeHistory:
		return static_cast<sptr_t>(changeHistoryOption);

	case Message::SetUndoSelectionHistory:
		ChangeUndoSelectionHistory(static_cast<UndoSelectionHistoryOption>(wParam));
		break;

	case Message::GetUndoSelectionHistory:
		return static_cast<sptr_t>(undoSelectionHistoryOption);

	case Message::SetSelectionSerialized:
		SetSelectionFromSerialized(ConstCharPtrFromSPtr(lParam));
		break;

	case Message::GetSelectionSerialized: {
		const std::string serialized = sel.ToString();
		return BytesResult(lParam, serialized);
	}

	case Message::SetExtraAscent:
		vs.extraAscent = static_cast<int>(wParam);
		InvalidateStyleRedraw();
		break;

	case Message::GetExtraAscent:
		return vs.extraAscent;

	case Message::SetExtraDescent:
		vs.extraDescent = static_cast<int>(wParam);
		InvalidateStyleRedraw();
		break;

	case Message::GetExtraDescent:
		return vs.extraDescent;

	case Message::MarginSetStyleOffset:
		vs.marginStyleOffset = static_cast<int>(wParam);
		InvalidateStyleRedraw();
		break;

	case Message::MarginGetStyleOffset:
		return vs.marginStyleOffset;

	case Message::SetMarginOptions:
		marginOptions = static_cast<MarginOption>(wParam);
		break;

	case Message::GetMarginOptions:
		return static_cast<sptr_t>(marginOptions);

	case Message::MarginSetText:
		pdoc->MarginSetText(LineFromUPtr(wParam), ConstCharPtrFromSPtr(lParam));
		break;

	case Message::MarginGetText: {
			const StyledText st = pdoc->MarginStyledText(LineFromUPtr(wParam));
			return BytesResult(lParam, reinterpret_cast<const unsigned char *>(st.text), st.length);
		}

	case Message::MarginSetStyle:
		pdoc->MarginSetStyle(LineFromUPtr(wParam), static_cast<int>(lParam));
		break;

	case Message::MarginGetStyle: {
			const StyledText st = pdoc->MarginStyledText(LineFromUPtr(wParam));
			return st.style;
		}

	case Message::SCI_MARGINSTYLENEXT: //Au: fast find next line that has certain style in text margin
		return pdoc->MarginStyledTextNext((Sci::Line)wParam, (int)lParam);

	case Message::MarginSetStyles:
		pdoc->MarginSetStyles(LineFromUPtr(wParam), ConstUCharPtrFromSPtr(lParam));
		break;

	case Message::MarginGetStyles: {
			const StyledText st = pdoc->MarginStyledText(LineFromUPtr(wParam));
			return BytesResult(lParam, st.styles, st.length);
		}

	case Message::MarginTextClearAll:
		pdoc->MarginClearAll();
		break;

	case Message::AnnotationSetText:
		pdoc->AnnotationSetText(LineFromUPtr(wParam), ConstCharPtrFromSPtr(lParam));
		break;

	case Message::AnnotationGetText: {
			const StyledText st = pdoc->AnnotationStyledText(LineFromUPtr(wParam));
			return BytesResult(lParam, reinterpret_cast<const unsigned char *>(st.text), st.length);
		}

	case Message::AnnotationGetStyle: {
			const StyledText st = pdoc->AnnotationStyledText(LineFromUPtr(wParam));
			return st.style;
		}

	case Message::AnnotationSetStyle:
		pdoc->AnnotationSetStyle(LineFromUPtr(wParam), static_cast<int>(lParam));
		break;

	case Message::AnnotationSetStyles:
		pdoc->AnnotationSetStyles(LineFromUPtr(wParam), ConstUCharPtrFromSPtr(lParam));
		break;

	case Message::AnnotationGetStyles: {
			const StyledText st = pdoc->AnnotationStyledText(LineFromUPtr(wParam));
			return BytesResult(lParam, st.styles, st.length);
		}

	case Message::AnnotationGetLines:
		return pdoc->AnnotationLines(LineFromUPtr(wParam));

	case Message::AnnotationClearAll:
		pdoc->AnnotationClearAll();
		break;

	case Message::AnnotationSetVisible:
		SetAnnotationVisible(static_cast<AnnotationVisible>(wParam));
		break;

	case Message::AnnotationGetVisible:
		return static_cast<sptr_t>(vs.annotationVisible);

	case Message::AnnotationSetStyleOffset:
		vs.annotationStyleOffset = static_cast<int>(wParam);
		InvalidateStyleRedraw();
		break;

	case Message::AnnotationGetStyleOffset:
		return vs.annotationStyleOffset;

	case Message::EOLAnnotationSetText:
		pdoc->EOLAnnotationSetText(LineFromUPtr(wParam), ConstCharPtrFromSPtr(lParam));
		break;

	case Message::EOLAnnotationGetText: {
			const StyledText st = pdoc->EOLAnnotationStyledText(LineFromUPtr(wParam));
			return BytesResult(lParam, reinterpret_cast<const unsigned char *>(st.text), st.length);
		}

	case Message::EOLAnnotationGetStyle: {
			const StyledText st = pdoc->EOLAnnotationStyledText(LineFromUPtr(wParam));
			return st.style;
		}

	case Message::EOLAnnotationSetStyle:
		pdoc->EOLAnnotationSetStyle(LineFromUPtr(wParam), static_cast<int>(lParam));
		break;

	case Message::EOLAnnotationClearAll:
		pdoc->EOLAnnotationClearAll();
		break;

	case Message::EOLAnnotationSetVisible:
		SetEOLAnnotationVisible(static_cast<EOLAnnotationVisible>(wParam));
		break;

	case Message::EOLAnnotationGetVisible:
		return static_cast<sptr_t>(vs.eolAnnotationVisible);

	case Message::EOLAnnotationSetStyleOffset:
		vs.eolAnnotationStyleOffset = static_cast<int>(wParam);
		InvalidateStyleRedraw();
		break;

	case Message::EOLAnnotationGetStyleOffset:
		return vs.eolAnnotationStyleOffset;

	case Message::ReleaseAllExtendedStyles:
		vs.ReleaseAllExtendedStyles();
		break;

	case Message::AllocateExtendedStyles:
		return vs.AllocateExtendedStyles(static_cast<int>(wParam));

	case Message::SupportsFeature:
		return SupportsFeature(static_cast<Supports>(wParam));

	case Message::AddUndoAction:
		pdoc->AddUndoAction(PositionFromUPtr(wParam),
			FlagSet(static_cast<UndoFlags>(lParam), UndoFlags::MayCoalesce));
		break;

	case Message::SetMouseSelectionRectangularSwitch:
		mouseSelectionRectangularSwitch = wParam != 0;
		break;

	case Message::GetMouseSelectionRectangularSwitch:
		return mouseSelectionRectangularSwitch;

	case Message::SetMultipleSelection:
		multipleSelection = wParam != 0;
		InvalidateCaret();
		break;

	case Message::GetMultipleSelection:
		return multipleSelection;

	case Message::SetAdditionalSelectionTyping:
		additionalSelectionTyping = wParam != 0;
		InvalidateCaret();
		break;

	case Message::GetAdditionalSelectionTyping:
		return additionalSelectionTyping;

	case Message::SetMultiPaste:
		multiPasteMode = static_cast<MultiPaste>(wParam);
		break;

	case Message::GetMultiPaste:
		return static_cast<sptr_t>(multiPasteMode);

	case Message::SetAdditionalCaretsBlink:
		view.additionalCaretsBlink = wParam != 0;
		InvalidateCaret();
		break;

	case Message::GetAdditionalCaretsBlink:
		return view.additionalCaretsBlink;

	case Message::SetAdditionalCaretsVisible:
		view.additionalCaretsVisible = wParam != 0;
		InvalidateCaret();
		break;

	case Message::GetAdditionalCaretsVisible:
		return view.additionalCaretsVisible;

	case Message::GetSelections:
		return sel.Count();

	case Message::GetSelectionEmpty:
		return sel.Empty();

	case Message::ClearSelections:
		sel.Clear();
		ContainerNeedsUpdate(Update::Selection);
		Redraw();
		break;

	case Message::SetSelection:
		sel.SetSelection(SelectionRange(PositionFromUPtr(wParam), lParam));
		Redraw();
		break;

	case Message::AddSelection:
		sel.AddSelection(SelectionRange(PositionFromUPtr(wParam), lParam));
		ContainerNeedsUpdate(Update::Selection);
		Redraw();
		break;

	case Message::SelectionFromPoint:
		return SelectionFromPoint(PointFromParameters(wParam, lParam));

	case Message::DropSelectionN:
		DropSelection(wParam);
		break;

	case Message::SetMainSelection:
		sel.SetMain(wParam);
		ContainerNeedsUpdate(Update::Selection);
		Redraw();
		break;

	case Message::GetMainSelection:
		return sel.Main();

	case Message::SetSelectionNCaret:
	case Message::SetSelectionNAnchor:
	case Message::SetSelectionNCaretVirtualSpace:
	case Message::SetSelectionNAnchorVirtualSpace:
	case Message::SetSelectionNStart:
	case Message::SetSelectionNEnd:
		SetSelectionNMessage(iMessage, wParam, lParam);
		break;

	case Message::GetSelectionNCaret:
		return sel.Range(wParam).caret.Position();

	case Message::GetSelectionNAnchor:
		return sel.Range(wParam).anchor.Position();

	case Message::GetSelectionNCaretVirtualSpace:
		return sel.Range(wParam).caret.VirtualSpace();

	case Message::GetSelectionNAnchorVirtualSpace:
		return sel.Range(wParam).anchor.VirtualSpace();

	case Message::GetSelectionNStart:
		return sel.Range(wParam).Start().Position();

	case Message::GetSelectionNStartVirtualSpace:
		return sel.Range(wParam).Start().VirtualSpace();

	case Message::GetSelectionNEnd:
		return sel.Range(wParam).End().Position();

	case Message::GetSelectionNEndVirtualSpace:
		return sel.Range(wParam).End().VirtualSpace();

	case Message::SetRectangularSelectionCaret:
		if (!sel.IsRectangular())
			sel.Clear();
		sel.selType = Selection::SelTypes::rectangle;
		sel.Rectangular().caret.SetPosition(PositionFromUPtr(wParam));
		SetRectangularRange();
		Redraw();
		break;

	case Message::GetRectangularSelectionCaret:
		return sel.Rectangular().caret.Position();

	case Message::SetRectangularSelectionAnchor:
		if (!sel.IsRectangular())
			sel.Clear();
		sel.selType = Selection::SelTypes::rectangle;
		sel.Rectangular().anchor.SetPosition(PositionFromUPtr(wParam));
		SetRectangularRange();
		Redraw();
		break;

	case Message::GetRectangularSelectionAnchor:
		return sel.Rectangular().anchor.Position();

	case Message::SetRectangularSelectionCaretVirtualSpace:
		if (!sel.IsRectangular())
			sel.Clear();
		sel.selType = Selection::SelTypes::rectangle;
		sel.Rectangular().caret.SetVirtualSpace(PositionFromUPtr(wParam));
		SetRectangularRange();
		Redraw();
		break;

	case Message::GetRectangularSelectionCaretVirtualSpace:
		return sel.Rectangular().caret.VirtualSpace();

	case Message::SetRectangularSelectionAnchorVirtualSpace:
		if (!sel.IsRectangular())
			sel.Clear();
		sel.selType = Selection::SelTypes::rectangle;
		sel.Rectangular().anchor.SetVirtualSpace(PositionFromUPtr(wParam));
		SetRectangularRange();
		Redraw();
		break;

	case Message::GetRectangularSelectionAnchorVirtualSpace:
		return sel.Rectangular().anchor.VirtualSpace();

	case Message::SetVirtualSpaceOptions:
		virtualSpaceOptions = static_cast<VirtualSpace>(wParam);
		break;

	case Message::GetVirtualSpaceOptions:
		return static_cast<sptr_t>(virtualSpaceOptions);

	case Message::SetAdditionalSelFore:
		vs.elementColours[Element::SelectionAdditionalText] = ColourRGBA::FromIpRGB(SPtrFromUPtr(wParam));
		InvalidateStyleRedraw();
		break;

	case Message::SetAdditionalSelBack:
		vs.SetElementRGB(Element::SelectionAdditionalBack, static_cast<int>(wParam));
		InvalidateStyleRedraw();
		break;

	case Message::SetAdditionalSelAlpha:
		vs.SetElementAlpha(Element::SelectionAdditionalBack, static_cast<int>(wParam));
		InvalidateStyleRedraw();
		break;

	case Message::GetAdditionalSelAlpha:
		if (vs.selection.layer == Layer::Base)
			return static_cast<sptr_t>(Alpha::NoAlpha);
		return vs.ElementColourForced(Element::SelectionAdditionalBack).GetAlpha();

	case Message::SetAdditionalCaretFore:
		vs.elementColours[Element::CaretAdditional] = ColourRGBA::FromIpRGB(SPtrFromUPtr(wParam));
		InvalidateStyleRedraw();
		break;

	case Message::GetAdditionalCaretFore:
		return vs.ElementColourForced(Element::CaretAdditional).OpaqueRGB();

	case Message::RotateSelection:
		sel.RotateMain();
		InvalidateWholeSelection();
		break;

	case Message::SwapMainAnchorCaret:
		InvalidateSelection(sel.RangeMain());
		sel.RangeMain().Swap();
		break;

	case Message::MultipleSelectAddNext:
		MultipleSelectAdd(AddNumber::one);
		break;

	case Message::MultipleSelectAddEach:
		MultipleSelectAdd(AddNumber::each);
		break;

	case Message::ChangeLexerState:
		pdoc->ChangeLexerState(PositionFromUPtr(wParam), lParam);
		break;

	case Message::SetIdentifier:
		SetCtrlID(static_cast<int>(wParam));
		break;

	case Message::GetIdentifier:
		return GetCtrlID();

	case Message::SetTechnology:
		// No action by default
		break;

	case Message::GetTechnology:
		return static_cast<sptr_t>(technology);

	case Message::CountCharacters:
		return pdoc->CountCharacters(PositionFromUPtr(wParam), lParam);

	case Message::CountCodeUnits:
		return pdoc->CountUTF16(PositionFromUPtr(wParam), lParam);

	default:
		return DefWndProc(iMessage, wParam, lParam);
	}

	// If there was a change that needs its selection saved and it wasn't explicity saved
	// then do that here.
	RememberCurrentSelectionForRedoOntoStack();

	//Platform::DebugPrintf("end wnd proc\n");
	return 0;
}


================================================
FILE: Libraries/scintilla/src/Editor.h
================================================
// Scintilla source code edit control
/** @file Editor.h
 ** Defines the main editor class.
 **/
// Copyright 1998-2011 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#ifndef EDITOR_H
#define EDITOR_H

namespace Scintilla::Internal {

/**
 */
class Timer {
public:
	bool ticking;
	int ticksToWait;
	enum {tickSize = 100};
	TickerID tickerID;

	Timer() noexcept;
};

/**
 */
class Idler {
public:
	bool state;
	IdlerID idlerID;

	Idler() noexcept;
};

/**
 * When platform has a way to generate an event before painting,
 * accumulate needed styling range and other work items in
 * WorkNeeded to avoid unnecessary work inside paint handler
 */

enum class WorkItems {
	none = 0,
	style = 1,
	updateUI = 2
};

class WorkNeeded {
public:
	enum WorkItems items;
	Sci::Position upTo;

	WorkNeeded() noexcept : items(WorkItems::none), upTo(0) {}
	void Reset() noexcept {
		items = WorkItems::none;
		upTo = 0;
	}
	void Need(WorkItems items_, Sci::Position pos) noexcept {
		if (Scintilla::FlagSet(items_, WorkItems::style) && (upTo < pos))
			upTo = pos;
		items = static_cast<WorkItems>(static_cast<int>(items) | static_cast<int>(items_));
	}
};

/**
 * Hold a piece of text selected for copying or dragging, along with encoding and selection format information.
 */
class SelectionText {
	std::string s;
public:
	bool rectangular;
	bool lineCopy;
	int codePage;
	Scintilla::CharacterSet characterSet;
	SelectionText() noexcept : rectangular(false), lineCopy(false), codePage(0), characterSet(Scintilla::CharacterSet::Ansi) {}
	void Clear() noexcept {
		s.clear();
		rectangular = false;
		lineCopy = false;
		codePage = 0;
		characterSet = Scintilla::CharacterSet::Ansi;
	}
	void Copy(const std::string &s_, int codePage_, Scintilla::CharacterSet characterSet_, bool rectangular_, bool lineCopy_) {
		s = s_;
		codePage = codePage_;
		characterSet = characterSet_;
		rectangular = rectangular_;
		lineCopy = lineCopy_;
		FixSelectionForClipboard();
	}
	void Copy(const SelectionText &other) {
		Copy(other.s, other.codePage, other.characterSet, other.rectangular, other.lineCopy);
	}
	const char *Data() const noexcept {
		return s.c_str();
	}
	size_t Length() const noexcept {
		return s.length();
	}
	size_t LengthWithTerminator() const noexcept {
		return s.length() + 1;
	}
	bool Empty() const noexcept {
		return s.empty();
	}
private:
	void FixSelectionForClipboard() {
		// To avoid truncating the contents of the clipboard when pasted where the
		// clipboard contains NUL characters, replace NUL characters by spaces.
		std::replace(s.begin(), s.end(), '\0', ' ');
	}
};

struct WrapPending {
	// The range of lines that need to be wrapped
	enum { lineLarge = 0x7ffffff };
	Sci::Line start;	// When there are wraps pending, will be in document range
	Sci::Line end;	// May be lineLarge to indicate all of document after start
	WrapPending() noexcept {
		start = lineLarge;
		end = lineLarge;
	}
	void Reset() noexcept {
		start = lineLarge;
		end = lineLarge;
	}
	void Wrapped(Sci::Line line) noexcept {
		if (start == line)
			start++;
	}
	bool NeedsWrap() const noexcept {
		return start < end;
	}
	bool AddRange(Sci::Line lineStart, Sci::Line lineEnd) noexcept {
		const bool neededWrap = NeedsWrap();
		bool changed = false;
		if (start > lineStart) {
			start = lineStart;
			changed = true;
		}
		if ((end < lineEnd) || !neededWrap) {
			end = lineEnd;
			changed = true;
		}
		return changed;
	}
};

struct CaretPolicySlop {
	Scintilla::CaretPolicy policy;	// Combination from CaretPolicy::Slop, CaretPolicy::Strict, CaretPolicy::Jumps, CaretPolicy::Even
	int slop;	// Pixels for X, lines for Y
	CaretPolicySlop(Scintilla::CaretPolicy policy_, intptr_t slop_) noexcept :
		policy(policy_), slop(static_cast<int>(slop_)) {}
	CaretPolicySlop(uintptr_t policy_=0, intptr_t slop_=0) noexcept :
		policy(static_cast<Scintilla::CaretPolicy>(policy_)), slop(static_cast<int>(slop_)) {}
};

struct CaretPolicies {
	CaretPolicySlop x;
	CaretPolicySlop y;
};

struct VisiblePolicySlop {
	Scintilla::VisiblePolicy policy;	// Combination from VisiblePolicy::Slop, VisiblePolicy::Strict
	int slop;	// Pixels for X, lines for Y
	VisiblePolicySlop(uintptr_t policy_ = 0, intptr_t slop_ = 0) noexcept :
		policy(static_cast<Scintilla::VisiblePolicy>(policy_)), slop(static_cast<int>(slop_)) {}
};

enum class XYScrollOptions {
	none = 0x0,
	useMargin = 0x1,
	vertical = 0x2,
	horizontal = 0x4,
	all = useMargin | vertical | horizontal
};

constexpr XYScrollOptions operator|(XYScrollOptions a, XYScrollOptions b) noexcept {
	return static_cast<XYScrollOptions>(static_cast<int>(a) | static_cast<int>(b));
}

/**
 */
class Editor : public EditModel, public DocWatcher {
protected:	// ScintillaBase subclass needs access to much of Editor

	/** On GTK+, Scintilla is a container widget holding two scroll bars
	 * whereas on Windows there is just one window with both scroll bars turned on. */
	Window wMain;	///< The Scintilla parent window
	Window wMargin;	///< May be separate when using a scroll view for wMain

	// Optimization that avoids superfluous invalidations
	bool redrawPendingText = false;
	bool redrawPendingMargin = false;

	/** Style resources may be expensive to allocate so are cached between uses.
	 * When a style attribute is changed, this cache is flushed. */
	bool stylesValid;
	ViewStyle vs;
	Scintilla::Technology technology;
	Point sizeRGBAImage;
	float scaleRGBAImage;

	MarginView marginView;
	EditView view;

	Scintilla::CursorShape cursorMode;

	bool mouseDownCaptures;
	bool mouseWheelCaptures;

	int xCaretMargin;	///< Ensure this many pixels visible on both sides of caret
	bool horizontalScrollBarVisible;
	int scrollWidth;
	bool verticalScrollBarVisible;
	bool endAtLastLine;
	Scintilla::CaretSticky caretSticky;
	Scintilla::MarginOption marginOptions;
	bool mouseSelectionRectangularSwitch;
	bool multipleSelection;
	bool additionalSelectionTyping;
	Scintilla::MultiPaste multiPasteMode;

	Scintilla::VirtualSpace virtualSpaceOptions;

	KeyMap kmap;

	Timer timer;
	Timer autoScrollTimer;
	enum { autoScrollDelay = 200 };

	Idler idler;

	Point lastClick;
	unsigned int lastClickTime;
	Point doubleClickCloseThreshold;
	int dwellDelay;
	int ticksToDwell;
	bool dwelling;
	enum class TextUnit { character, word, subLine, wholeLine } selectionUnit;
	Point ptMouseLast;
	enum class DragDrop { none, initial, dragging } inDragDrop;
	bool dropWentOutside;
	SelectionPosition posDrop;
	Sci::Position hotSpotClickPos;
	int lastXChosen;
	Sci::Position lineAnchorPos;
	Sci::Position originalAnchorPos;
	Sci::Position wordSelectAnchorStartPos;
	Sci::Position wordSelectAnchorEndPos;
	Sci::Position wordSelectInitialCaretPos;
	SelectionSegment targetRange;
	Scintilla::FindOption searchFlags;
	Sci::Line topLine;
	Sci::Position posTopLine;
	Sci::Position lengthForEncode;

	Scintilla::Update needUpdateUI;

	enum class PaintState { notPainting, painting, abandoned } paintState;
	bool paintAbandonedByStyling;
	PRectangle rcPaint;
	bool paintingAllText;
	bool willRedrawAll;
	WorkNeeded workNeeded;
	Scintilla::IdleStyling idleStyling;
	bool needIdleStyling;

	Scintilla::ModificationFlags modEventMask;
	bool commandEvents;

	SelectionText drag;

	CaretPolicies caretPolicies;

	VisiblePolicySlop visiblePolicy;

	Sci::Position searchAnchor;

	bool recordingMacro;

	Scintilla::AutomaticFold foldAutomatic;

	// Wrapping support
	WrapPending wrapPending;
	ActionDuration durationWrapOneByte;
	bool insideWrapScroll;
	struct LineDocSub {
		Scintilla::Line lineDoc = 0;
		Scintilla::Line subLine = 0;
	};
	std::optional<LineDocSub> scrollToAfterWrap;

	bool convertPastes;

	Editor();
	// Deleted so Editor objects can not be copied.
	Editor(const Editor &) = delete;
	Editor(Editor &&) = delete;
	Editor &operator=(const Editor &) = delete;
	Editor &operator=(Editor &&) = delete;
	// ~Editor() in public section
	virtual void Initialise() = 0;
	virtual void Finalise();

	void InvalidateStyleData() noexcept;
	void InvalidateStyleRedraw();
	void RefreshStyleData();
	void SetRepresentations();
	void DropGraphics() noexcept;

	bool HasMarginWindow() const noexcept;
	// The top left visible point in main window coordinates. Will be 0,0 except for
	// scroll views where it will be equivalent to the current scroll position.
	Point GetVisibleOriginInMain() const override;
	PointDocument DocumentPointFromView(Point ptView) const;  // Convert a point from view space to document
	Sci::Line TopLineOfMain() const noexcept final;   // Return the line at Main's y coordinate 0
	virtual Point ClientSize() const;
	virtual PRectangle GetClientRectangle() const;
	virtual PRectangle GetClientDrawingRectangle();
	PRectangle GetTextRectangle() const;

	Sci::Line LinesOnScreen() const override;
	Sci::Line LinesToScroll() const;
	Sci::Line MaxScrollPos() const;
	SelectionPosition ClampPositionIntoDocument(SelectionPosition sp) const;
	Point LocationFromPosition(SelectionPosition pos, PointEnd pe=PointEnd::start);
	Point LocationFromPosition(Sci::Position pos, PointEnd pe=PointEnd::start);
	int XFromPosition(SelectionPosition sp);
	SelectionPosition SPositionFromLocation(Point pt, bool canReturnInvalid=false, bool charPosition=false, bool virtualSpace=true);
	Sci::Position PositionFromLocation(Point pt, bool canReturnInvalid = false, bool charPosition = false);
	SelectionPosition SPositionFromLineX(Sci::Line lineDoc, int x);
	Sci::Position PositionFromLineX(Sci::Line lineDoc, int x);
	Sci::Line LineFromLocation(Point pt) const noexcept;
	void SetTopLine(Sci::Line topLineNew);

	virtual bool AbandonPaint();
	virtual void RedrawRect(PRectangle rc);
	virtual void DiscardOverdraw();
	virtual void Redraw();
	void RedrawSelMargin(Sci::Line line=-1, bool allAfter=false);
	PRectangle RectangleFromRange(Range r, int overlap);
	void InvalidateRange(Sci::Position start, Sci::Position end);

	bool UserVirtualSpace() const noexcept {
		return (FlagSet(virtualSpaceOptions, Scintilla::VirtualSpace::UserAccessible));
	}
	Sci::Position CurrentPosition() const noexcept;
	bool SelectionEmpty() const noexcept;
	SelectionPosition SelectionStart() noexcept;
	SelectionPosition SelectionEnd() noexcept;
	void SetRectangularRange();
	void ThinRectangularRange();
	void InvalidateSelection(SelectionRange newMain, bool invalidateWholeSelection=false);
	void InvalidateWholeSelection();
	SelectionRange LineSelectionRange(SelectionPosition currentPos_, SelectionPosition anchor_) const noexcept;
	void SetSelection(SelectionPosition currentPos_, SelectionPosition anchor_);
	void SetSelection(Sci::Position currentPos_, Sci::Position anchor_);
	void SetSelection(SelectionPosition currentPos_);
	void SetEmptySelection(SelectionPosition currentPos_);
	void SetEmptySelection(Sci::Position currentPos_);
	void SetSelectionFromSerialized(const char *serialized);
	enum class AddNumber { one, each };
	void MultipleSelectAdd(AddNumber addNumber);
	bool RangeContainsProtected(Sci::Position start, Sci::Position end) const noexcept;
	bool RangeContainsProtected(const SelectionRange &range) const noexcept;
	bool SelectionContainsProtected() const noexcept;
	Sci::Position MovePositionOutsideChar(Sci::Position pos, Sci::Position moveDir, bool checkLineEnd=true) const;
	SelectionPosition MovePositionOutsideChar(SelectionPosition pos, Sci::Position moveDir, bool checkLineEnd=true) const;
	void MovedCaret(SelectionPosition newPos, SelectionPosition previousPos,
		bool ensureVisible, CaretPolicies policies);
	void MovePositionTo(SelectionPosition newPos, Selection::SelTypes selt=Selection::SelTypes::none, bool ensureVisible=true);
	void MovePositionTo(Sci::Position newPos, Selection::SelTypes selt=Selection::SelTypes::none, bool ensureVisible=true);
	SelectionPosition MovePositionSoVisible(SelectionPosition pos, int moveDir);
	SelectionPosition MovePositionSoVisible(Sci::Position pos, int moveDir);
	Point PointMainCaret();
	void SetLastXChosen();
	void RememberSelectionForUndo(int index);
	void RememberSelectionOntoStack(int index);
	void RememberCurrentSelectionForRedoOntoStack();

	void ScrollTo(Sci::Line line, bool moveThumb=true);
	virtual void ScrollText(Sci::Line linesToMove);
	void HorizontalScrollTo(int xPos);
	void VerticalCentreCaret();
	void MoveSelectedLines(int lineDelta);
	void MoveSelectedLinesUp();
	void MoveSelectedLinesDown();
	void MoveCaretInsideView(bool ensureVisible=true);
	Sci::Line DisplayFromPosition(Sci::Position pos);

	struct XYScrollPosition {
		int xOffset;
		Sci::Line topLine;
		XYScrollPosition(int xOffset_, Sci::Line topLine_) noexcept : xOffset(xOffset_), topLine(topLine_) {}
		bool operator==(const XYScrollPosition &other) const noexcept {
			return (xOffset == other.xOffset) && (topLine == other.topLine);
		}
	};
	XYScrollPosition XYScrollToMakeVisible(const SelectionRange &range,
		const XYScrollOptions options, CaretPolicies policies);
	void SetXYScroll(XYScrollPosition newXY);
	void EnsureCaretVisible(bool useMargin=true, bool vert=true, bool horiz=true);
	void ScrollRange(SelectionRange range);
	void ShowCaretAtCurrentPosition();
	void DropCaret();
	void CaretSetPeriod(int period);
	void InvalidateCaret();
	virtual void NotifyCaretMove();
	virtual void UpdateSystemCaret();

	bool Wrapping() const noexcept;
	void NeedWrapping(Sci::Line docLineStart=0, Sci::Line docLineEnd=WrapPending::lineLarge);
	bool WrapOneLine(Surface *surface, Sci::Line lineToWrap);
	bool WrapBlock(Surface *surface, Sci::Line lineToWrap, Sci::Line lineToWrapEnd);
	enum class WrapScope {wsAll, wsVisible, wsIdle};
	bool WrapLines(WrapScope ws);
	void LinesJoin();
	void LinesSplit(int pixelWidth);

	void PaintSelMargin(Surface *surfaceWindow, const PRectangle &rc);
	void RefreshPixMaps(Surface *surfaceWindow);
	void Paint(Surface *surfaceWindow, PRectangle rcArea);
	Sci::Position FormatRange(Scintilla::Message iMessage, Scintilla::uptr_t wParam, Scintilla::sptr_t lParam);
	long TextWidth(Scintilla::uptr_t style, const char *text);

	virtual void SetVerticalScrollPos();
	virtual void SetHorizontalScrollPos() = 0;
	virtual bool ModifyScrollBars(Sci::Line nMax, Sci::Line nPage) = 0;
	virtual void ReconfigureScrollBars();
	void ChangeScrollBars();
	virtual void SetScrollBars();
	void ChangeSize();

	void FilterSelections();
	Sci::Position RealizeVirtualSpace(Sci::Position position, Sci::Position virtualSpace);
	SelectionPosition RealizeVirtualSpace(const SelectionPosition &position);
	void AddChar(char ch);
	virtual void InsertCharacter(std::string_view sv, Scintilla::CharacterSource charSource);
	void ClearSelectionRange(SelectionRange &range);
	void ClearBeforeTentativeStart();
	void InsertPaste(const char *text, Sci::Position len);
	enum class PasteShape { stream=0, rectangular = 1, line = 2 };
	void InsertPasteShape(const char *text, Sci::Position len, PasteShape shape);
	void ClearSelection(bool retainMultipleSelections = false);
	void ClearAll();
	void ClearDocumentStyle();
	virtual void Cut();
	void PasteRectangular(SelectionPosition pos, const char *ptr, Sci::Position len);
	virtual void Copy() = 0;
	void CopyAllowLine();
	void CutAllowLine();
	virtual bool CanPaste();
	virtual void Paste() = 0;
	void Clear();
	virtual void SelectAll();
	void RestoreSelection(Sci::Position newPos, UndoRedo history);
	virtual void Undo(bool dontChangePos); //Au: added dontChangePos
	virtual void Redo(bool dontChangePos); //Au: added dontChangePos
	void DelCharBack(bool allowLineStartDeletion);
	virtual void ClaimSelection() = 0;

	virtual void NotifyChange() = 0;
	virtual void NotifyFocus(bool focus);
	virtual void SetCtrlID(int identifier);
	virtual int GetCtrlID() { return ctrlID; }
	virtual void NotifyParent(Scintilla::NotificationData scn) = 0;
	virtual void NotifyStyleToNeeded(Sci::Position endStyleNeeded);
	void NotifyChar(int ch, Scintilla::CharacterSource charSource);
	void NotifySavePoint(bool isSavePoint);
	void NotifyModifyAttempt();
	virtual void NotifyDoubleClick(Point pt, Scintilla::KeyMod modifiers);
	void NotifyHotSpotClicked(Sci::Position position, Scintilla::KeyMod modifiers);
	void NotifyHotSpotDoubleClicked(Sci::Position position, Scintilla::KeyMod modifiers);
	void NotifyHotSpotReleaseClick(Sci::Position position, Scintilla::KeyMod modifiers);
	bool NotifyUpdateUI();
	void NotifyPainted();
	void NotifyIndicatorClick(bool click, Sci::Position position, Scintilla::KeyMod modifiers);
	bool NotifyMarginClick(Point pt, Scintilla::KeyMod modifiers);
	bool NotifyMarginRightClick(Point pt, Scintilla::KeyMod modifiers);
	void NotifyNeedShown(Sci::Position pos, Sci::Position len);
	void NotifyDwelling(Point pt, bool state);
	void NotifyZoom();

	void NotifyModifyAttempt(Document *document, void *userData) override;
	void NotifySavePoint(Document *document, void *userData, bool atSavePoint) override;
	void CheckModificationForWrap(DocModification mh);
	void NotifyModified(Document *document, DocModification mh, void *userData) override;
	void NotifyDeleted(Document *document, void *userData) noexcept override;
	void NotifyStyleNeeded(Document *doc, void *userData, Sci::Position endStyleNeeded) override;
	void NotifyErrorOccurred(Document *doc, void *userData, Scintilla::Status status) override;
	void NotifyGroupCompleted(Document *, void *) noexcept override;
	void NotifyMacroRecord(Scintilla::Message iMessage, Scintilla::uptr_t wParam, Scintilla::sptr_t lParam);

	void ContainerNeedsUpdate(Scintilla::Update flags) noexcept;
	void PageMove(int direction, Selection::SelTypes selt=Selection::SelTypes::none, bool stuttered = false);
	enum class CaseMapping { same, upper, lower };
	virtual std::string CaseMapString(const std::string &s, CaseMapping caseMapping);
	void ChangeCaseOfSelection(CaseMapping caseMapping);
	void LineDelete();
	void LineTranspose();
	void LineReverse();
	void Duplicate(bool forLine);
	virtual void CancelModes();
	void NewLine();
	SelectionPosition PositionUpOrDown(SelectionPosition spStart, int direction, int lastX);
	void CursorUpOrDown(int direction, Selection::SelTypes selt);
	void ParaUpOrDown(int direction, Selection::SelTypes selt);
	Range RangeDisplayLine(Sci::Line lineVisible);
	Sci::Position StartEndDisplayLine(Sci::Position pos, bool start);
	Sci::Position HomeWrapPosition(Sci::Position position);
	Sci::Position VCHomeDisplayPosition(Sci::Position position);
	Sci::Position VCHomeWrapPosition(Sci::Position position);
	Sci::Position LineEndWrapPosition(Sci::Position position);
	SelectionPosition PositionMove(Scintilla::Message iMessage, SelectionPosition spCaretNow);
	SelectionRange SelectionMove(Scintilla::Message iMessage, size_t r);
	int HorizontalMove(Scintilla::Message iMessage);
	int DelWordOrLine(Scintilla::Message iMessage);
	virtual int KeyCommand(Scintilla::Message iMessage);
	virtual int KeyDefault(Scintilla::Keys /* key */, Scintilla::KeyMod /*modifiers*/);
	int KeyDownWithModifiers(Scintilla::Keys key, Scintilla::KeyMod modifiers, bool *consumed);

	void Indent(bool forwards, bool lineIndent);

	virtual std::unique_ptr<CaseFolder> CaseFolderForEncoding();
	Sci::Position FindText(Scintilla::uptr_t wParam, Scintilla::sptr_t lParam);
	Sci::Position FindTextFull(Scintilla::uptr_t wParam, Scintilla::sptr_t lParam);
	void SearchAnchor() noexcept;
	Sci::Position SearchText(Scintilla::Message iMessage, Scintilla::uptr_t wParam, Scintilla::sptr_t lParam);
	Sci::Position SearchInTarget(const char *text, Sci::Position length);
	void GoToLine(Sci::Line lineNo);

	virtual void CopyToClipboard(const SelectionText &selectedText) = 0;
	std::string RangeText(Sci::Position start, Sci::Position end) const;
	bool CopyLineRange(SelectionText *ss, bool allowProtected=true);
	void CopySelectionRange(SelectionText *ss, bool allowLineCopy=false);
	void CopyRangeToClipboard(Sci::Position start, Sci::Position end);
	void CopyText(size_t length, const char *text);
	void SetDragPosition(SelectionPosition newPos);
	virtual void DisplayCursor(Window::Cursor c);
	virtual bool DragThreshold(Point ptStart, Point ptNow);
	virtual void StartDrag();
	void DropAt(SelectionPosition position, const char *value, size_t lengthValue, bool moving, bool rectangular);
	void DropAt(SelectionPosition position, const char *value, bool moving, bool rectangular);
	/** PositionInSelection returns true if position in selection. */
	bool PositionInSelection(Sci::Position pos);
	bool PointInSelection(Point pt);
	ptrdiff_t SelectionFromPoint(Point pt);
	bool PointInSelMargin(Point pt) const;
	Window::Cursor GetMarginCursor(Point pt) const noexcept;
	void DropSelection(size_t part);
	void TrimAndSetSelection(Sci::Position currentPos_, Sci::Position anchor_);
	void LineSelection(Sci::Position lineCurrentPos_, Sci::Position lineAnchorPos_, bool wholeLine);
	void WordSelection(Sci::Position pos);
	void DwellEnd(bool mouseMoved);
	void MouseLeave();
	virtual void ButtonDownWithModifiers(Point pt, unsigned int curTime, Scintilla::KeyMod modifiers);
	virtual void RightButtonDownWithModifiers(Point pt, unsigned int curTime, Scintilla::KeyMod modifiers);
	void ButtonMoveWithModifiers(Point pt, unsigned int curTime, Scintilla::KeyMod modifiers);
	void ButtonUpWithModifiers(Point pt, unsigned int curTime, Scintilla::KeyMod modifiers);

	bool Idle();
	enum class TickReason { caret, scroll, widen, dwell, platform };
	virtual void TickFor(TickReason reason);
	virtual bool FineTickerRunning(TickReason reason);
	virtual void FineTickerStart(TickReason reason, int millis, int tolerance);
	virtual void FineTickerCancel(TickReason reason);
	virtual bool SetIdle(bool) { return false; }
	void ChangeMouseCapture(bool on);
	virtual void SetMouseCapture(bool on) = 0;
	virtual bool HaveMouseCapture() = 0;
	void SetFocusState(bool focusState);
	virtual void UpdateBaseElements();

	Sci::Position PositionAfterArea(PRectangle rcArea) const;
	void StyleToPositionInView(Sci::Position pos);
	Sci::Position PositionAfterMaxStyling(Sci::Position posMax, bool scrolling) const;
	void StartIdleStyling(bool truncatedLastStyling);
	void StyleAreaBounded(PRectangle rcArea, bool scrolling);
	constexpr bool SynchronousStylingToVisible() const noexcept {
		return (idleStyling == Scintilla::IdleStyling::None) || (idleStyling == Scintilla::IdleStyling::AfterVisible);
	}
	void IdleStyle();
	virtual void IdleWork();
	virtual void QueueIdleWork(WorkItems items, Sci::Position upTo=0);

	virtual int SupportsFeature(Scintilla::Supports feature);
	virtual bool PaintContains(PRectangle rc);
	bool PaintContainsMargin();
	void CheckForChangeOutsidePaint(Range r);
	void SetBraceHighlight(Sci::Position pos0, Sci::Position pos1, int matchStyle);

	void SetAnnotationHeights(Sci::Line start, Sci::Line end);
	virtual void SetDocPointer(Document *document);

	void SetAnnotationVisible(Scintilla::AnnotationVisible visible);
	void SetEOLAnnotationVisible(Scintilla::EOLAnnotationVisible visible);

	Sci::Line ExpandLine(Sci::Line line);
	void SetFoldExpanded(Sci::Line lineDoc, bool expanded);
	void FoldLine(Sci::Line line, Scintilla::FoldAction action);
	void FoldExpand(Sci::Line line, Scintilla::FoldAction action, Scintilla::FoldLevel level);
	Sci::Line ContractedFoldNext(Sci::Line lineStart) const noexcept;
	void EnsureLineVisible(Sci::Line lineDoc, bool enforcePolicy);
	void FoldChanged(Sci::Line line, Scintilla::FoldLevel levelNow, Scintilla::FoldLevel levelPrev);
	void NeedShown(Sci::Position pos, Sci::Position len);
	void FoldAll(Scintilla::FoldAction action);

	Sci::Position GetTag(char *tagValue, int tagNumber);
	enum class ReplaceType {basic, patterns, minimal};
	Sci::Position ReplaceTarget(ReplaceType replaceType, std::string_view text);

	bool PositionIsHotspot(Sci::Position position) const noexcept;
	bool PointIsHotspot(Point pt);
	void SetHotSpotRange(const Point *pt);
	void SetHoverIndicatorPosition(Sci::Position position);
	void SetHoverIndicatorPoint(Point pt);

	int CodePage() const noexcept;
	virtual bool ValidCodePage(int /* codePage */) const { return true; }
	virtual std::string UTF8FromEncoded(std::string_view encoded) const = 0;
	virtual std::string EncodedFromUTF8(std::string_view utf8) const = 0;
	virtual std::unique_ptr<Surface> CreateMeasurementSurface() const;
	virtual std::unique_ptr<Surface> CreateDrawingSurface(SurfaceID sid, std::optional<Scintilla::Technology> technologyOpt = {}) const;

	Sci::Line WrapCount(Sci::Line line);
	void AddStyledText(const char *buffer, Sci::Position appendLength);
	Sci::Position GetStyledText(char *buffer, Sci::Position cpMin, Sci::Position cpMax) const noexcept;
	Sci::Position GetTextRange(char *buffer, Sci::Position cpMin, Sci::Position cpMax) const;

	virtual Scintilla::sptr_t DefWndProc(Scintilla::Message iMessage, Scintilla::uptr_t wParam, Scintilla::sptr_t lParam) = 0;
	bool ValidMargin(Scintilla::uptr_t wParam) const noexcept;
	void StyleSetMessage(Scintilla::Message iMessage, Scintilla::uptr_t wParam, Scintilla::sptr_t lParam);
	Scintilla::sptr_t StyleGetMessage(Scintilla::Message iMessage, Scintilla::uptr_t wParam, Scintilla::sptr_t lParam);
	void SetSelectionNMessage(Scintilla::Message iMessage, Scintilla::uptr_t wParam, Scintilla::sptr_t lParam);
	void SetSelectionMode(uptr_t wParam, bool setMoveExtends);

	// Coercion functions for transforming WndProc parameters into pointers
	static void *PtrFromSPtr(Scintilla::sptr_t lParam) noexcept {
		return reinterpret_cast<void *>(lParam);
	}
	static const char *ConstCharPtrFromSPtr(Scintilla::sptr_t lParam) noexcept {
		return static_cast<const char *>(PtrFromSPtr(lParam));
	}
	static const unsigned char *ConstUCharPtrFromSPtr(Scintilla::sptr_t lParam) noexcept {
		return static_cast<const unsigned char *>(PtrFromSPtr(lParam));
	}
	static char *CharPtrFromSPtr(Scintilla::sptr_t lParam) noexcept {
		return static_cast<char *>(PtrFromSPtr(lParam));
	}
	static unsigned char *UCharPtrFromSPtr(Scintilla::sptr_t lParam) noexcept {
		return static_cast<unsigned char *>(PtrFromSPtr(lParam));
	}
	static std::string_view ViewFromParams(Scintilla::sptr_t lParam, Scintilla::uptr_t wParam) noexcept {
		if (SPtrFromUPtr(wParam) == -1) {
			return std::string_view(CharPtrFromSPtr(lParam));
		}
		return std::string_view(CharPtrFromSPtr(lParam), wParam);
	}
	static void *PtrFromUPtr(Scintilla::uptr_t wParam) noexcept {
		return reinterpret_cast<void *>(wParam);
	}
	static const char *ConstCharPtrFromUPtr(Scintilla::uptr_t wParam) noexcept {
		return static_cast<const char *>(PtrFromUPtr(wParam));
	}

	static constexpr Scintilla::sptr_t SPtrFromUPtr(Scintilla::uptr_t wParam) noexcept {
		return static_cast<Scintilla::sptr_t>(wParam);
	}
	static constexpr Sci::Position PositionFromUPtr(Scintilla::uptr_t wParam) noexcept {
		return SPtrFromUPtr(wParam);
	}
	static constexpr Sci::Line LineFromUPtr(Scintilla::uptr_t wParam) noexcept {
		return SPtrFromUPtr(wParam);
	}
	Point PointFromParameters(Scintilla::uptr_t wParam, Scintilla::sptr_t lParam) const noexcept {
		return Point(static_cast<XYPOSITION>(wParam) - vs.ExternalMarginWidth(), static_cast<XYPOSITION>(lParam));
	}

	static constexpr std::optional<FoldLevel> OptionalFoldLevel(Scintilla::sptr_t lParam) {
		if (lParam >= 0) {
			return static_cast<FoldLevel>(lParam);
		}
		return std::nullopt;
	}

	static Scintilla::sptr_t StringResult(Scintilla::sptr_t lParam, const char *val) noexcept;
	static Scintilla::sptr_t BytesResult(Scintilla::sptr_t lParam, const unsigned char *val, size_t len) noexcept;
	static Scintilla::sptr_t BytesResult(Scintilla::sptr_t lParam, std::string_view sv) noexcept;

	// Set a variable controlling appearance to a value and invalidates the display
	// if a change was made. Avoids extra text and the possibility of mistyping.
	template <typename T>
	bool SetAppearance(T &variable, T value) {
		// Using ! and == as more types have == defined than !=.
		const bool changed = !(variable == value);
		if (changed) {
			variable = value;
			InvalidateStyleRedraw();
		}
		return changed;
	}

public:
	~Editor() override;

	// Public so the COM thunks can access it.
	bool IsUnicodeMode() const noexcept;
	// Public so scintilla_send_message can use it.
	virtual Scintilla::sptr_t WndProc(Scintilla::Message iMessage, Scintilla::uptr_t wParam, Scintilla::sptr_t lParam);
	// Public so scintilla_set_id can use it.
	int ctrlID;
	// Public so COM methods for drag and drop can set it.
	Scintilla::Status errorStatus;
	friend class AutoSurface;
};

/**
 * A smart pointer class to ensure Surfaces are set up and deleted correctly.
 */
class AutoSurface {
private:
	std::unique_ptr<Surface> surf;
public:
	AutoSurface(const Editor *ed) :
		surf(ed->CreateMeasurementSurface())  {
	}
	AutoSurface(SurfaceID sid, const Editor *ed, std::optional<Scintilla::Technology> technology = {}) :
		surf(ed->CreateDrawingSurface(sid, technology)) {
	}
	// Deleted so AutoSurface objects can not be copied.
	AutoSurface(const AutoSurface &) = delete;
	AutoSurface(AutoSurface &&) = delete;
	void operator=(const AutoSurface &) = delete;
	void operator=(AutoSurface &&) = delete;
	~AutoSurface() {
	}
	Surface *operator->() const noexcept {
		return surf.get();
	}
	operator Surface *() const noexcept {
		return surf.get();
	}
};

}

#endif


================================================
FILE: Libraries/scintilla/src/ElapsedPeriod.h
================================================
// Scintilla source code edit control
/** @file ElapsedPeriod.h
 ** Encapsulate C++ <chrono> to simplify use.
 **/
// Copyright 2018 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#ifndef ELAPSEDPERIOD_H
#define ELAPSEDPERIOD_H

namespace Scintilla::Internal {

// Simplified access to high precision timing.
class ElapsedPeriod {
	using ElapsedClock = std::chrono::steady_clock;
	ElapsedClock::time_point tp;
public:
	/// Capture the moment
	ElapsedPeriod() noexcept : tp(ElapsedClock::now()) {
	}
	/// Return duration as floating point seconds
	double Duration(bool reset=false) noexcept {
		const ElapsedClock::time_point tpNow = ElapsedClock::now();
		const std::chrono::duration<double> duration =
			std::chrono::duration_cast<std::chrono::duration<double>>(tpNow - tp);
		if (reset) {
			tp = tpNow;
		}
		return duration.count();
	}
};

}

#endif


================================================
FILE: Libraries/scintilla/src/Geometry.cxx
================================================
// Scintilla source code edit control
/** @file Geometry.cxx
 ** Helper functions for geometric calculations.
 **/
// Copyright 2020 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#include <cstdint>
#include <cmath>

#include <algorithm>

#include "Geometry.h"

namespace {

constexpr unsigned int Mixed(unsigned char a, unsigned char b, double proportion) noexcept {
	return static_cast<unsigned int>(a + proportion * (b - a));
}

}

namespace Scintilla::Internal {

PRectangle Clamp(PRectangle rc, Edge edge, XYPOSITION position) noexcept {
	switch (edge) {
	case Edge::left:
		return PRectangle(std::clamp(position, rc.left, rc.right), rc.top, rc.right, rc.bottom);
	case Edge::top:
		return PRectangle(rc.left, std::clamp(position, rc.top, rc.bottom), rc.right, rc.bottom);
	case Edge::right:
		return PRectangle(rc.left, rc.top, std::clamp(position, rc.left, rc.right), rc.bottom);
	case Edge::bottom:
	default:
		return PRectangle(rc.left, rc.top, rc.right, std::clamp(position, rc.top, rc.bottom));
	}
}

PRectangle Side(PRectangle rc, Edge edge, XYPOSITION size) noexcept {
	switch (edge) {
	case Edge::left:
		return PRectangle(rc.left, rc.top, std::min(rc.left + size, rc.right), rc.bottom);
	case Edge::top:
		return PRectangle(rc.left, rc.top, rc.right, std::min(rc.top + size, rc.bottom));
	case Edge::right:
		return PRectangle(std::max(rc.left, rc.right - size), rc.top, rc.right, rc.bottom);
	case Edge::bottom:
	default:
		return PRectangle(rc.left, std::max(rc.top, rc.bottom - size), rc.right, rc.bottom);
	}
}

Interval Intersection(Interval a, Interval b) noexcept {
	const XYPOSITION leftMax = std::max(a.left, b.left);
	const XYPOSITION rightMin = std::min(a.right, b.right);
	// If the result would have a negative width. make empty instead.
	const XYPOSITION rightResult = (rightMin >= leftMax) ? rightMin : leftMax;
	return { leftMax, rightResult };
}

PRectangle Intersection(PRectangle rc, Interval horizontalBounds) noexcept {
	const Interval intersection = Intersection(HorizontalBounds(rc), horizontalBounds);
	return PRectangle(intersection.left, rc.top, intersection.right, rc.bottom);
}

Interval HorizontalBounds(PRectangle rc) noexcept {
	return { rc.left, rc.right };
}

XYPOSITION PixelAlign(XYPOSITION xy, int pixelDivisions) noexcept {
	return std::round(xy * pixelDivisions) / pixelDivisions;
}

XYPOSITION PixelAlignFloor(XYPOSITION xy, int pixelDivisions) noexcept {
	return std::floor(xy * pixelDivisions) / pixelDivisions;
}

XYPOSITION PixelAlignCeil(XYPOSITION xy, int pixelDivisions) noexcept {
	return std::ceil(xy * pixelDivisions) / pixelDivisions;
}

Point PixelAlign(const Point &pt, int pixelDivisions) noexcept {
	return Point(
		PixelAlign(pt.x, pixelDivisions),
		PixelAlign(pt.y, pixelDivisions));
}

PRectangle PixelAlign(const PRectangle &rc, int pixelDivisions) noexcept {
	// Move left and right side to nearest pixel to avoid blurry visuals.
	// The top and bottom should be integers but floor them to make sure.
	// `pixelDivisions` is commonly 1 except for 'retina' displays where it is 2.
	// On retina displays, the positions should be moved to the nearest device
	// pixel which is the nearest half logical pixel.
	return PRectangle(
		PixelAlign(rc.left, pixelDivisions),
		PixelAlignFloor(rc.top, pixelDivisions),
		PixelAlign(rc.right, pixelDivisions),
		PixelAlignFloor(rc.bottom, pixelDivisions));
}

PRectangle PixelAlignOutside(const PRectangle &rc, int pixelDivisions) noexcept {
	// Move left and right side to extremes (floor(left) ceil(right)) to avoid blurry visuals.
	return PRectangle(
		PixelAlignFloor(rc.left, pixelDivisions),
		PixelAlignFloor(rc.top, pixelDivisions),
		PixelAlignCeil(rc.right, pixelDivisions),
		PixelAlignFloor(rc.bottom, pixelDivisions));
}

ColourRGBA ColourRGBA::MixedWith(ColourRGBA other) const noexcept {
	const unsigned int red = (GetRed() + other.GetRed()) / 2;
	const unsigned int green = (GetGreen() + other.GetGreen()) / 2;
	const unsigned int blue = (GetBlue() + other.GetBlue()) / 2;
	const unsigned int alpha = (GetAlpha() + other.GetAlpha()) / 2;
	return ColourRGBA(red, green, blue, alpha);
}

ColourRGBA ColourRGBA::MixedWith(ColourRGBA other, double proportion) const noexcept {
	return ColourRGBA(
		Mixed(GetRed(), other.GetRed(), proportion),
		Mixed(GetGreen(), other.GetGreen(), proportion),
		Mixed(GetBlue(), other.GetBlue(), proportion),
		Mixed(GetAlpha(), other.GetAlpha(), proportion));
}

}


================================================
FILE: Libraries/scintilla/src/Geometry.h
================================================
// Scintilla source code edit control
/** @file Geometry.h
 ** Classes and functions for geometric and colour calculations.
 **/
// Copyright 2020 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#ifndef GEOMETRY_H
#define GEOMETRY_H

namespace Scintilla::Internal {

typedef double XYPOSITION;
typedef double XYACCUMULATOR;

/**
 * A geometric point class.
 * Point is similar to the Win32 POINT and GTK+ GdkPoint types.
 */
class Point {
public:
	XYPOSITION x;
	XYPOSITION y;

	constexpr explicit Point(XYPOSITION x_=0, XYPOSITION y_=0) noexcept : x(x_), y(y_) {
	}

	static constexpr Point FromInts(int x_, int y_) noexcept {
		return Point(static_cast<XYPOSITION>(x_), static_cast<XYPOSITION>(y_));
	}

	constexpr bool operator==(Point other) const noexcept {
		return (x == other.x) && (y == other.y);
	}

	constexpr bool operator!=(Point other) const noexcept {
		return (x != other.x) || (y != other.y);
	}

	constexpr Point operator+(Point other) const noexcept {
		return Point(x + other.x, y + other.y);
	}

	constexpr Point operator-(Point other) const noexcept {
		return Point(x - other.x, y - other.y);
	}

	// Other automatically defined methods (assignment, copy constructor, destructor) are fine
};


/**
 * A geometric interval class.
 */
class Interval {
public:
	XYPOSITION left;
	XYPOSITION right;
	constexpr bool operator==(const Interval &other) const noexcept {
		return (left == other.left) && (right == other.right);
	}
	constexpr XYPOSITION Width() const noexcept { return right - left; }
	constexpr bool Empty() const noexcept {
		return Width() <= 0;
	}
	constexpr bool Intersects(Interval other) const noexcept {
		return (right > other.left) && (left < other.right);
	}
	constexpr Interval Offset(XYPOSITION offset) const noexcept {
		return {left + offset, right + offset};
	}
};

/**
 * A geometric rectangle class.
 * PRectangle is similar to Win32 RECT.
 * PRectangles contain their top and left sides, but not their right and bottom sides.
 */
class PRectangle {
public:
	XYPOSITION left;
	XYPOSITION top;
	XYPOSITION right;
	XYPOSITION bottom;

	constexpr explicit PRectangle(XYPOSITION left_=0, XYPOSITION top_=0, XYPOSITION right_=0, XYPOSITION bottom_ = 0) noexcept :
		left(left_), top(top_), right(right_), bottom(bottom_) {
	}

	static constexpr PRectangle FromInts(int left_, int top_, int right_, int bottom_) noexcept {
		return PRectangle(static_cast<XYPOSITION>(left_), static_cast<XYPOSITION>(top_),
			static_cast<XYPOSITION>(right_), static_cast<XYPOSITION>(bottom_));
	}

	// Other automatically defined methods (assignment, copy constructor, destructor) are fine

	constexpr bool operator==(const PRectangle &rc) const noexcept {
		return (rc.left == left) && (rc.right == right) &&
			(rc.top == top) && (rc.bottom == bottom);
	}
	constexpr bool Contains(Point pt) const noexcept {
		return (pt.x >= left) && (pt.x <= right) &&
			(pt.y >= top) && (pt.y <= bottom);
	}
	constexpr bool ContainsWholePixel(Point pt) const noexcept {
		// Does the rectangle contain all of the pixel to left/below the point
		return (pt.x >= left) && ((pt.x+1) <= right) &&
			(pt.y >= top) && ((pt.y+1) <= bottom);
	}
	constexpr bool Contains(PRectangle rc) const noexcept {
		return (rc.left >= left) && (rc.right <= right) &&
			(rc.top >= top) && (rc.bottom <= bottom);
	}
	constexpr bool Intersects(PRectangle other) const noexcept {
		return (right > other.left) && (left < other.right) &&
			(bottom > other.top) && (top < other.bottom);
	}
	constexpr bool Intersects(Interval horizontalBounds) const noexcept {
		return (right > horizontalBounds.left) && (left < horizontalBounds.right);
	}

	void Move(XYPOSITION xDelta, XYPOSITION yDelta) noexcept {
		left += xDelta;
		top += yDelta;
		right += xDelta;
		bottom += yDelta;
	}

	PRectangle WithHorizontalBounds(Interval horizontal) const noexcept {
		return PRectangle(horizontal.left, top, horizontal.right, bottom);
	}

	constexpr PRectangle Inset(XYPOSITION delta) const noexcept {
		return PRectangle(left + delta, top + delta, right - delta, bottom - delta);
	}

	constexpr PRectangle Inset(Point delta) const noexcept {
		return PRectangle(left + delta.x, top + delta.y, right - delta.x, bottom - delta.y);
	}

	constexpr Point Centre() const noexcept {
		return Point((left + right) / 2, (top + bottom) / 2);
	}

	constexpr XYPOSITION Width() const noexcept { return right - left; }
	constexpr XYPOSITION Height() const noexcept { return bottom - top; }
	constexpr bool Empty() const noexcept {
		return (Height() <= 0) || (Width() <= 0);
	}
};

enum class Edge { left, top, bottom, right };

PRectangle Clamp(PRectangle rc, Edge edge, XYPOSITION position) noexcept;
PRectangle Side(PRectangle rc, Edge edge, XYPOSITION size) noexcept;

Interval Intersection(Interval a, Interval b) noexcept;
PRectangle Intersection(PRectangle rc, Interval horizontalBounds) noexcept;
Interval HorizontalBounds(PRectangle rc) noexcept;

XYPOSITION PixelAlign(XYPOSITION xy, int pixelDivisions) noexcept;
XYPOSITION PixelAlignFloor(XYPOSITION xy, int pixelDivisions) noexcept;
XYPOSITION PixelAlignCeil(XYPOSITION xy, int pixelDivisions) noexcept;

Point PixelAlign(const Point &pt, int pixelDivisions) noexcept;

PRectangle PixelAlign(const PRectangle &rc, int pixelDivisions) noexcept;
PRectangle PixelAlignOutside(const PRectangle &rc, int pixelDivisions) noexcept;

/**
* Holds an RGBA colour with 8 bits for each component.
*/
constexpr float componentMaximum = 255.0F;
constexpr unsigned int maximumByte = 0xffU;
class ColourRGBA {
	static constexpr float ComponentAsFloat(unsigned char component) {
		return component / componentMaximum;
	}
	static constexpr int rgbMask = 0xffffff;
	int co;
public:
	constexpr explicit ColourRGBA(int co_ = 0) noexcept : co(co_) {
	}

	constexpr ColourRGBA(unsigned int red, unsigned int green, unsigned int blue, unsigned int alpha=maximumByte) noexcept :
		ColourRGBA(red | (green << 8) | (blue << 16) | (alpha << 24)) {
	}

	constexpr ColourRGBA(ColourRGBA cd, unsigned int alpha) noexcept :
		ColourRGBA(cd.OpaqueRGB() | (alpha << 24)) {
	}

	static constexpr ColourRGBA FromRGB(int co_) noexcept {
		return ColourRGBA(co_ | (maximumByte << 24));
	}

	static constexpr ColourRGBA Grey(unsigned int grey, unsigned int alpha=maximumByte) noexcept {
		return ColourRGBA(grey, grey, grey, alpha);
	}

	static constexpr ColourRGBA FromIpRGB(intptr_t co_) noexcept {
		const int rgb = co_ & rgbMask;
		return ColourRGBA(rgb | (maximumByte << 24));
	}

	constexpr ColourRGBA WithoutAlpha() const noexcept {
		return ColourRGBA(co & rgbMask);
	}

	constexpr ColourRGBA Opaque() const noexcept {
		return ColourRGBA(co | (maximumByte << 24));
	}

	constexpr int AsInteger() const noexcept {
		return co;
	}

	constexpr int OpaqueRGB() const noexcept {
		return co & rgbMask;
	}

	// Red, green and blue values as bytes 0..255
	constexpr unsigned char GetRed() const noexcept {
		return co & maximumByte;
	}
	constexpr unsigned char GetGreen() const noexcept {
		return (co >> 8) & maximumByte;
	}
	constexpr unsigned char GetBlue() const noexcept {
		return (co >> 16) & maximumByte;
	}
	constexpr unsigned char GetAlpha() const noexcept {
		// Use a temporary here to prevent a 'Wconversion' warning from GCC
		const int shifted = co >> 24;
		return shifted & maximumByte;
	}

	// Red, green, blue, and alpha values as float 0..1.0
	constexpr float GetRedComponent() const noexcept {
		return ComponentAsFloat(GetRed());
	}
	constexpr float GetGreenComponent() const noexcept {
		return ComponentAsFloat(GetGreen());
	}
	constexpr float GetBlueComponent() const noexcept {
		return ComponentAsFloat(GetBlue());
	}
	constexpr float GetAlphaComponent() const noexcept {
		return ComponentAsFloat(GetAlpha());
	}

	constexpr bool operator==(const ColourRGBA &other) const noexcept {
		return co == other.co;
	}

	constexpr bool IsOpaque() const noexcept {
		return GetAlpha() == maximumByte;
	}

	ColourRGBA MixedWith(ColourRGBA other) const noexcept;
	ColourRGBA MixedWith(ColourRGBA other, double proportion) const noexcept;
};

constexpr ColourRGBA white(maximumByte, maximumByte, maximumByte);
constexpr ColourRGBA black(0x0, 0x0, 0x0);

/**
* Holds an RGBA colour and stroke width to stroke a shape.
*/
class Stroke {
public:
	ColourRGBA colour;
	XYPOSITION width;
	constexpr Stroke(ColourRGBA colour_, XYPOSITION width_=1.0) noexcept :
		colour(colour_), width(width_) {
	}
	constexpr float WidthF() const noexcept {
		return static_cast<float>(width);
	}
};

/**
* Holds an RGBA colour to fill a shape.
*/
class Fill {
public:
	ColourRGBA colour;
	constexpr Fill(ColourRGBA colour_) noexcept :
		colour(colour_) {
	}
};

/**
* Holds a pair of RGBA colours and stroke width to fill and stroke a shape.
*/
class FillStroke {
public:
	Fill fill;
	Stroke stroke;
	constexpr FillStroke(ColourRGBA colourFill_, ColourRGBA colourStroke_, XYPOSITION widthStroke_=1.0) noexcept :
		fill(colourFill_), stroke(colourStroke_, widthStroke_) {
	}
	constexpr FillStroke(ColourRGBA colourBoth, XYPOSITION widthStroke_=1.0) noexcept :
		fill(colourBoth), stroke(colourBoth, widthStroke_) {
	}
};

/**
* Holds an element of a gradient with an RGBA colour and a relative position.
*/
class ColourStop {
public:
	XYPOSITION position;
	ColourRGBA colour;
	constexpr ColourStop(XYPOSITION position_, ColourRGBA colour_) noexcept :
		position(position_), colour(colour_) {
	}
};

}

#endif


================================================
FILE: Libraries/scintilla/src/Indicator.cxx
================================================
// Scintilla source code edit control
/** @file Indicator.cxx
 ** Defines the style of indicators which are text decorations such as underlining.
 **/
// Copyright 1998-2001 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#include <cstdint>
#include <cmath>

#include <stdexcept>
#include <string_view>
#include <vector>
#include <map>
#include <optional>
#include <algorithm>
#include <memory>

#include "ScintillaTypes.h"

#include "Debugging.h"
#include "Geometry.h"
#include "Platform.h"

#include "Indicator.h"
#include "XPM.h"

using namespace Scintilla;
using namespace Scintilla::Internal;

void Indicator::Draw(Surface *surface, const PRectangle &rc, const PRectangle &rcLine, const PRectangle &rcCharacter, State state, int value) const {
	StyleAndColour sacDraw = sacNormal;
	if (FlagSet(Flags(), IndicFlag::ValueFore)) {
		sacDraw.fore = ColourRGBA::FromRGB(value & static_cast<int>(IndicValue::Mask));
	}
	if (state == State::hover) {
		sacDraw = sacHover;
	}

	const int pixelDivisions = surface->PixelDivisions();

	const XYPOSITION halfWidth = strokeWidth / 2.0f;

	const PRectangle rcAligned(PixelAlignOutside(rc, pixelDivisions));
	PRectangle rcFullHeightAligned = PixelAlignOutside(rcLine, pixelDivisions);
	rcFullHeightAligned.left = rcAligned.left;
	rcFullHeightAligned.right = rcAligned.right;

	const XYPOSITION ymid = PixelAlign(rc.Centre().y, pixelDivisions);

	// This is a reasonable clip for indicators beneath text like underlines
	PRectangle rcClip = rcAligned;
	rcClip.bottom = rcFullHeightAligned.bottom;

	switch (sacDraw.style) {
	case IndicatorStyle::Squiggle: {
			surface->SetClip(rcClip);
			XYPOSITION x = rcAligned.left + halfWidth;
			const XYPOSITION top = rcAligned.top + halfWidth;
			const XYPOSITION xLast = rcAligned.right + halfWidth;
			XYPOSITION y = 0;
			std::vector<Point> pts;
			const XYPOSITION pitch = 1 + strokeWidth;
			pts.emplace_back(x, top + y);
			while (x < xLast) {
				x += pitch;
				y = pitch - y;
				pts.emplace_back(x, top + y);
				}
			surface->PolyLine(pts.data(), std::size(pts), Stroke(sacDraw.fore, strokeWidth));
			surface->PopClip();
		}
		break;

	case IndicatorStyle::SquigglePixmap: {
			const PRectangle rcSquiggle = PixelAlign(rc, 1);

			const int width = std::min(4000, static_cast<int>(rcSquiggle.Width()));
			RGBAImage image(width, 3, 1.0, nullptr);
			constexpr unsigned int alphaFull = 0xff;
			constexpr unsigned int alphaSide = 0x2f;
			constexpr unsigned int alphaSide2 = 0x5f;
			for (int x = 0; x < width; x++) {
				if (x%2) {
					// Two halfway columns have a full pixel in middle flanked by light pixels
					image.SetPixel(x, 0, ColourRGBA(sacDraw.fore, alphaSide));
					image.SetPixel(x, 1, ColourRGBA(sacDraw.fore, alphaFull));
					image.SetPixel(x, 2, ColourRGBA(sacDraw.fore, alphaSide));
				} else {
					// Extreme columns have a full pixel at bottom or top and a mid-tone pixel in centre
					image.SetPixel(x, (x % 4) ? 0 : 2, ColourRGBA(sacDraw.fore, alphaFull));
					image.SetPixel(x, 1, ColourRGBA(sacDraw.fore, alphaSide2));
				}
			}
			surface->DrawRGBAImage(rcSquiggle, image.GetWidth(), image.GetHeight(), image.Pixels());
		}
		break;

	case IndicatorStyle::SquiggleLow: {
			std::vector<Point> pts;
			const XYPOSITION top = rcAligned.top + halfWidth;
			int y = 0;
			XYPOSITION x = std::round(rcAligned.left) + halfWidth;
			pts.emplace_back(x, top + y);
			const XYPOSITION pitch = 2 + strokeWidth;
			x += pitch;
			while (x < rcAligned.right) {
				pts.emplace_back(x - 1, top + y);
				y = 1 - y;
				pts.emplace_back(x, top + y);
				x += pitch;
			}
			pts.emplace_back(rcAligned.right, top + y);
			surface->PolyLine(pts.data(), std::size(pts), Stroke(sacDraw.fore, strokeWidth));
		}
		break;

	case IndicatorStyle::TT: {
			surface->SetClip(rcClip);
			const XYPOSITION yLine = ymid;
			XYPOSITION x = rcAligned.left + 5.0f;
			const XYPOSITION pitch = 4 + strokeWidth;
			while (x < rc.right + pitch) {
				const PRectangle line(x-pitch, yLine, x, yLine + strokeWidth);
				surface->FillRectangle(line, sacDraw.fore);
				const PRectangle tail(x - 2 - strokeWidth, yLine + strokeWidth, x - 2, yLine + strokeWidth * 2);
				surface->FillRectangle(tail, sacDraw.fore);
				x++;
				x += pitch;
			}
			surface->PopClip();
		}
		break;

	case IndicatorStyle::Diagonal: {
			surface->SetClip(rcClip);
			XYPOSITION x = rcAligned.left + halfWidth;
			const XYPOSITION top = rcAligned.top + halfWidth;
			const XYPOSITION pitch = 3 + strokeWidth;
			while (x < rc.right) {
				const XYPOSITION endX = x+3;
				const XYPOSITION endY = top - 1;
				surface->LineDraw(Point(x, top + 2), Point(endX, endY), Stroke(sacDraw.fore, strokeWidth));
				x += pitch;
			}
			surface->PopClip();
		}
		break;

	case IndicatorStyle::Strike: {
			const XYPOSITION yStrike = std::round(rcLine.Centre().y);
			const PRectangle rcStrike(
				rcAligned.left, yStrike, rcAligned.right, yStrike + strokeWidth);
			surface->FillRectangle(rcStrike, sacDraw.fore);
		}
		break;

	case IndicatorStyle::Hidden:
	case IndicatorStyle::TextFore:
		// Draw nothing
		break;

	case IndicatorStyle::Box: {
			PRectangle rcBox = rcFullHeightAligned;
			rcBox.top = rcBox.top + 1.0f;
			rcBox.bottom = ymid + 1.0f;
			surface->RectangleFrame(rcBox, Stroke(ColourRGBA(sacDraw.fore, outlineAlpha), strokeWidth));
		}
		break;

	case IndicatorStyle::RoundBox:
	case IndicatorStyle::StraightBox:
	case IndicatorStyle::FullBox: {
			PRectangle rcBox = rcFullHeightAligned;
			if (sacDraw.style != IndicatorStyle::FullBox)
				rcBox.top = rcBox.top + 1;
			surface->AlphaRectangle(rcBox, (sacDraw.style == IndicatorStyle::RoundBox) ? 1.0f : 0.0f,
						FillStroke(ColourRGBA(sacDraw.fore, fillAlpha), ColourRGBA(sacDraw.fore, outlineAlpha), strokeWidth));
		}
		break;

	case IndicatorStyle::Gradient:
	case IndicatorStyle::GradientCentre: {
			PRectangle rcBox = rcFullHeightAligned;
			rcBox.top = rcBox.top + 1;
			const Surface::GradientOptions options = Surface::GradientOptions::topToBottom;
			const ColourRGBA start(sacDraw.fore, fillAlpha);
			const ColourRGBA end(sacDraw.fore, 0);
			std::vector<ColourStop> stops;
			switch (sacDraw.style) {
			case IndicatorStyle::Gradient:
				stops.push_back(ColourStop(0.0, start));
				stops.push_back(ColourStop(1.0, end));
				break;
			case IndicatorStyle::GradientCentre:
				stops.push_back(ColourStop(0.0, end));
				stops.push_back(ColourStop(0.5, start));
				stops.push_back(ColourStop(1.0, end));
				break;
			default:
				break;
			}
			surface->GradientRectangle(rcBox, stops, options);
		}
		break;

	case IndicatorStyle::DotBox: {
			PRectangle rcBox = rcFullHeightAligned;
			rcBox.top = rcBox.top + 1;
			// Cap width at 4000 to avoid large allocations when mistakes made
			const int width = std::min(static_cast<int>(rcBox.Width()), 4000);
			const int height = static_cast<int>(rcBox.Height());
			RGBAImage image(width, height, 1.0, nullptr);
			// Draw horizontal lines top and bottom
			for (int x=0; x<width; x++) {
				for (int y = 0; y< height; y += height - 1) {
					image.SetPixel(x, y, ColourRGBA(sacDraw.fore, ((x + y) % 2) ? outlineAlpha : fillAlpha));
				}
			}
			// Draw vertical lines left and right
			for (int y = 1; y<height; y++) {
				for (int x=0; x<width; x += width-1) {
					image.SetPixel(x, y, ColourRGBA(sacDraw.fore, ((x + y) % 2) ? outlineAlpha : fillAlpha));
				}
			}
			surface->DrawRGBAImage(rcBox, image.GetWidth(), image.GetHeight(), image.Pixels());
		}
		break;

	case IndicatorStyle::Dash: {
			XYPOSITION x = std::floor(rc.left);
			const XYPOSITION widthDash = 3 + std::round(strokeWidth);
			while (x < rc.right) {
				const PRectangle rcDash = PRectangle(x, ymid,
					x + widthDash, ymid + std::round(strokeWidth));
				surface->FillRectangle(rcDash, sacDraw.fore);
				x += 3 + widthDash;
			}
		}
		break;

	case IndicatorStyle::Dots: {
			const XYPOSITION widthDot = std::round(strokeWidth);
			XYPOSITION x = std::floor(rc.left);
			while (x < rc.right) {
				const PRectangle rcDot = PRectangle(x, ymid,
					x + widthDot, ymid + widthDot);
				surface->FillRectangle(rcDot, sacDraw.fore);
				x += widthDot * 2;
			}
		}
		break;

	case IndicatorStyle::CompositionThick: {
			const PRectangle rcComposition(rc.left+1, rcLine.bottom-2, rc.right-1, rcLine.bottom);
			surface->FillRectangle(rcComposition, ColourRGBA(sacDraw.fore, outlineAlpha));
		}
		break;

	case IndicatorStyle::CompositionThin: {
			const PRectangle rcComposition(rc.left+1, rcLine.bottom-2, rc.right-1, rcLine.bottom-1);
			surface->FillRectangle(rcComposition, sacDraw.fore);
		}
		break;

	case IndicatorStyle::Point:
	case IndicatorStyle::PointCharacter:
		if (rcCharacter.Width() >= 0.1) {
			const XYPOSITION pixelHeight = std::floor(rc.Height());	// 1 pixel onto next line if multiphase
			const XYPOSITION x = (sacDraw.style == IndicatorStyle::Point) ? (rcCharacter.left) : ((rcCharacter.right + rcCharacter.left) / 2);
			// 0.5f is to hit midpoint of pixels:
			const XYPOSITION ix = std::round(x) + 0.5f;
			const XYPOSITION iy = std::ceil(rc.bottom) + 0.5f;
			const Point pts[] = {
				Point(ix - pixelHeight, iy),	// Left
				Point(ix + pixelHeight, iy),	// Right
				Point(ix, iy - pixelHeight)								// Top
			};
			surface->Polygon(pts, std::size(pts), FillStroke(sacDraw.fore));
		}
		break;

	case IndicatorStyle::PointTop:
		if (rcCharacter.Width() >= 0.1) {
			const XYPOSITION pixelHeight = std::floor(rc.Height());	// 1 pixel onto previous line if multiphase
			const XYPOSITION x = rcCharacter.left;
			// 0.5f is to hit midpoint of pixels:
			const XYPOSITION ix = std::round(x) + 0.5f;
			const XYPOSITION iy = std::floor(rcLine.top) - 0.5f;
			const Point pts[] = {
				Point(ix - pixelHeight, iy),	// Left
				Point(ix + pixelHeight, iy),	// Right
				Point(ix, iy + pixelHeight)		// Bottom
			};
			surface->Polygon(pts, std::size(pts), FillStroke(sacDraw.fore));
		}
		break;

	default:
		// Either IndicatorStyle::Plain or unknown
		surface->FillRectangle(PRectangle(rcAligned.left, ymid,
			rcAligned.right, ymid + std::round(strokeWidth)), sacDraw.fore);
	}
}

void Indicator::SetFlags(IndicFlag attributes_) noexcept {
	attributes = attributes_;
}


================================================
FILE: Libraries/scintilla/src/Indicator.h
================================================
// Scintilla source code edit control
/** @file Indicator.h
 ** Defines the style of indicators which are text decorations such as underlining.
 **/
// Copyright 1998-2001 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#ifndef INDICATOR_H
#define INDICATOR_H

namespace Scintilla::Internal {

struct StyleAndColour {
	Scintilla::IndicatorStyle style;
	ColourRGBA fore;
	StyleAndColour() noexcept : style(Scintilla::IndicatorStyle::Plain), fore(black) {
	}
	StyleAndColour(Scintilla::IndicatorStyle style_, ColourRGBA fore_ = black) noexcept : style(style_), fore(fore_) {
	}
	bool operator==(const StyleAndColour &other) const noexcept {
		return (style == other.style) && (fore == other.fore);
	}
};

/**
 */
class Indicator {
public:
	enum class State { normal, hover };
	StyleAndColour sacNormal;
	StyleAndColour sacHover;
	bool under;
	int fillAlpha;
	int outlineAlpha;
	Scintilla::IndicFlag attributes;
	XYPOSITION strokeWidth = 1.0f;
	Indicator() noexcept : under(false), fillAlpha(30), outlineAlpha(50), attributes(Scintilla::IndicFlag::None) {
	}
	Indicator(Scintilla::IndicatorStyle style_, ColourRGBA fore_= black, bool under_=false, int fillAlpha_=30, int outlineAlpha_=50) noexcept :
		sacNormal(style_, fore_), sacHover(style_, fore_), under(under_), fillAlpha(fillAlpha_), outlineAlpha(outlineAlpha_), attributes(Scintilla::IndicFlag::None) {
	}
	void Draw(Surface *surface, const PRectangle &rc, const PRectangle &rcLine, const PRectangle &rcCharacter, State drawState, int value) const;
	bool IsDynamic() const noexcept {
		return !(sacNormal == sacHover);
	}
	bool OverridesTextFore() const noexcept {
		return sacNormal.style == Scintilla::IndicatorStyle::TextFore || sacHover.style == Scintilla::IndicatorStyle::TextFore;
	}
	Scintilla::IndicFlag Flags() const noexcept {
		return attributes;
	}
	void SetFlags(Scintilla::IndicFlag attributes_) noexcept;
};

}

#endif


================================================
FILE: Libraries/scintilla/src/KeyMap.cxx
================================================
// Scintilla source code edit control
/** @file KeyMap.cxx
 ** Defines a mapping between keystrokes and commands.
 **/
// Copyright 1998-2003 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#include <cstdlib>
#include <cstdint>

#include <stdexcept>
#include <string_view>
#include <vector>
#include <map>
#include <optional>
#include <memory>

#include "ScintillaTypes.h"
#include "ScintillaMessages.h"

#include "Debugging.h"
#include "Geometry.h"
#include "Platform.h"

#include "KeyMap.h"

using namespace Scintilla;
using namespace Scintilla::Internal;

KeyMap::KeyMap() {
	for (int i = 0; static_cast<int>(MapDefault[i].key); i++) {
		AssignCmdKey(MapDefault[i].key,
			MapDefault[i].modifiers,
			MapDefault[i].msg);
	}
}

void KeyMap::Clear() noexcept {
	kmap.clear();
}

void KeyMap::AssignCmdKey(Keys key, KeyMod modifiers, Message msg) {
	kmap[KeyModifiers(key, modifiers)] = msg;
}

Message KeyMap::Find(Keys key, KeyMod modifiers) const {
	std::map<KeyModifiers, Message>::const_iterator it = kmap.find(KeyModifiers(key, modifiers));
	return (it == kmap.end()) ? static_cast<Message>(0) : it->second;
}

const std::map<KeyModifiers, Message> &KeyMap::GetKeyMap() const noexcept {
	return kmap;
}

#if PLAT_GTK_MACOSX
#define OS_X_KEYS 1
#else
#define OS_X_KEYS 0
#endif

// Define a modifier that is exactly Ctrl key on all platforms
// Most uses of Ctrl map to Cmd on macOS but some can't so use SCI_[S]CTRL_META
#if OS_X_KEYS
#define SCI_CTRL_META SCI_META
#define SCI_SCTRL_META (SCI_META | SCI_SHIFT)
#else
#define SCI_CTRL_META SCI_CTRL
#define SCI_SCTRL_META (SCI_CTRL | SCI_SHIFT)
#endif

namespace {

constexpr Keys Key(char ch) noexcept {
    return static_cast<Keys>(ch);
}

}

const KeyToCommand KeyMap::MapDefault[] = {

#if OS_X_KEYS
    {Keys::Down,		SCI_CTRL,	Message::DocumentEnd},
    {Keys::Down,		SCI_CSHIFT,	Message::DocumentEndExtend},
    {Keys::Up,		    SCI_CTRL,	Message::DocumentStart},
    {Keys::Up,		    SCI_CSHIFT,	Message::DocumentStartExtend},
    {Keys::Left,		SCI_CTRL,	Message::VCHome},
    {Keys::Left,		SCI_CSHIFT,	Message::VCHomeExtend},
    {Keys::Right,		SCI_CTRL,	Message::LineEnd},
    {Keys::Right,		SCI_CSHIFT,	Message::LineEndExtend},
#endif

    {Keys::Down,		SCI_NORM,	Message::LineDown},
    {Keys::Down,		SCI_SHIFT,	Message::LineDownExtend},
    {Keys::Down,		SCI_CTRL_META,	Message::LineScrollDown},
    {Keys::Down,		SCI_ASHIFT,	Message::LineDownRectExtend},
    {Keys::Up,		    SCI_NORM,	Message::LineUp},
    {Keys::Up,			SCI_SHIFT,	Message::LineUpExtend},
    {Keys::Up,			SCI_CTRL_META,	Message::LineScrollUp},
    {Keys::Up,		    SCI_ASHIFT,	Message::LineUpRectExtend},
    {Key('['),			SCI_CTRL,	Message::ParaUp},
    {Key('['),			SCI_CSHIFT,	Message::ParaUpExtend},
    {Key(']'),			SCI_CTRL,	Message::ParaDown},
    {Key(']'),			SCI_CSHIFT,	Message::ParaDownExtend},
    {Keys::Left,		SCI_NORM,	Message::CharLeft},
    {Keys::Left,		SCI_SHIFT,	Message::CharLeftExtend},
    {Keys::Left,		SCI_CTRL_META,	Message::WordLeft},
    {Keys::Left,		SCI_SCTRL_META,	Message::WordLeftExtend},
    {Keys::Left,		SCI_ASHIFT,	Message::CharLeftRectExtend},
    {Keys::Right,		SCI_NORM,	Message::CharRight},
    {Keys::Right,		SCI_SHIFT,	Message::CharRightExtend},
    {Keys::Right,		SCI_CTRL_META,	Message::WordRight},
    {Keys::Right,		SCI_SCTRL_META,	Message::WordRightExtend},
    {Keys::Right,		SCI_ASHIFT,	Message::CharRightRectExtend},
    {Key('/'),		    SCI_CTRL,	Message::WordPartLeft},
    {Key('/'),		    SCI_CSHIFT,	Message::WordPartLeftExtend},
    {Key('\\'),		    SCI_CTRL,	Message::WordPartRight},
    {Key('\\'),		    SCI_CSHIFT,	Message::WordPartRightExtend},
    {Keys::Home,		SCI_NORM,	Message::VCHome},
    {Keys::Home, 		SCI_SHIFT, 	Message::VCHomeExtend},
    {Keys::Home, 		SCI_CTRL, 	Message::DocumentStart},
    {Keys::Home, 		SCI_CSHIFT, Message::DocumentStartExtend},
    {Keys::Home, 		SCI_ALT, 	Message::HomeDisplay},
    {Keys::Home,		SCI_ASHIFT,	Message::VCHomeRectExtend},
    {Keys::End,	 	    SCI_NORM,	Message::LineEnd},
    {Keys::End,	 	    SCI_SHIFT, 	Message::LineEndExtend},
    {Keys::End, 		SCI_CTRL, 	Message::DocumentEnd},
    {Keys::End, 		SCI_CSHIFT, Message::DocumentEndExtend},
    {Keys::End, 		SCI_ALT, 	Message::LineEndDisplay},
    {Keys::End,		    SCI_ASHIFT,	Message::LineEndRectExtend},
    {Keys::Prior,		SCI_NORM,	Message::PageUp},
    {Keys::Prior,		SCI_SHIFT, 	Message::PageUpExtend},
    {Keys::Prior,		SCI_ASHIFT,	Message::PageUpRectExtend},
    {Keys::Next, 		SCI_NORM, 	Message::PageDown},
    {Keys::Next, 		SCI_SHIFT, 	Message::PageDownExtend},
    {Keys::Next,		SCI_ASHIFT,	Message::PageDownRectExtend},
    {Keys::Delete,      SCI_NORM,	Message::Clear},
    {Keys::Delete, 	    SCI_SHIFT,	Message::Cut},
    {Keys::Delete, 	    SCI_CTRL,	Message::DelWordRight},
    {Keys::Delete,	    SCI_CSHIFT,	Message::DelLineRight},
    {Keys::Insert, 		SCI_NORM,	Message::EditToggleOvertype},
    {Keys::Insert, 		SCI_SHIFT,	Message::Paste},
    {Keys::Insert, 		SCI_CTRL,	Message::Copy},
    {Keys::Escape,  	SCI_NORM,	Message::Cancel},
    {Keys::Back,		SCI_NORM, 	Message::DeleteBack},
    {Keys::Back,		SCI_SHIFT, 	Message::DeleteBack},
    {Keys::Back,		SCI_CTRL, 	Message::DelWordLeft},
    {Keys::Back, 		SCI_ALT,	Message::Undo},
    {Keys::Back,		SCI_CSHIFT,	Message::DelLineLeft},
    {Key('Z'), 			SCI_CTRL,	Message::Undo},
#if OS_X_KEYS
    {Key('Z'), 			SCI_CSHIFT,	Message::Redo},
#else
    {Key('Y'), 			SCI_CTRL,	Message::Redo},
#endif
    {Key('X'), 			SCI_CTRL,	Message::Cut},
    {Key('C'), 			SCI_CTRL,	Message::Copy},
    {Key('V'), 			SCI_CTRL,	Message::Paste},
    {Key('A'), 			SCI_CTRL,	Message::SelectAll},
    {Keys::Tab,		    SCI_NORM,	Message::Tab},
    {Keys::Tab,		    SCI_SHIFT,	Message::BackTab},
    {Keys::Return, 	    SCI_NORM,	Message::NewLine},
    {Keys::Return, 	    SCI_SHIFT,	Message::NewLine},
    {Keys::Add, 		SCI_CTRL,	Message::ZoomIn},
    {Keys::Subtract,	SCI_CTRL,	Message::ZoomOut},
    {Keys::Divide,	    SCI_CTRL,	Message::SetZoom},
    {Key('L'), 			SCI_CTRL,	Message::LineCut},
    {Key('L'), 			SCI_CSHIFT,	Message::LineDelete},
    {Key('T'), 			SCI_CSHIFT,	Message::LineCopy},
    {Key('T'), 			SCI_CTRL,	Message::LineTranspose},
    {Key('D'), 			SCI_CTRL,	Message::SelectionDuplicate},
    {Key('U'), 			SCI_CTRL,	Message::LowerCase},
    {Key('U'), 			SCI_CSHIFT,	Message::UpperCase},
    {Key(0),SCI_NORM,static_cast<Message>(0)},
};



================================================
FILE: Libraries/scintilla/src/KeyMap.h
================================================
// Scintilla source code edit control
/** @file KeyMap.h
 ** Defines a mapping between keystrokes and commands.
 **/
// Copyright 1998-2001 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#ifndef KEYMAP_H
#define KEYMAP_H

namespace Scintilla::Internal {

#define SCI_NORM KeyMod::Norm
#define SCI_SHIFT KeyMod::Shift
#define SCI_CTRL KeyMod::Ctrl
#define SCI_ALT KeyMod::Alt
#define SCI_META KeyMod::Meta
#define SCI_SUPER KeyMod::Super
#define SCI_CSHIFT (KeyMod::Ctrl | KeyMod::Shift)
#define SCI_ASHIFT (KeyMod::Alt | KeyMod::Shift)

/**
 */
class KeyModifiers {
public:
	Scintilla::Keys key;
	Scintilla::KeyMod modifiers;
	KeyModifiers() noexcept : key{}, modifiers(KeyMod::Norm) {
	};
	KeyModifiers(Scintilla::Keys key_, Scintilla::KeyMod modifiers_) noexcept : key(key_), modifiers(modifiers_) {
	}
	bool operator<(const KeyModifiers &other) const noexcept {
		if (key == other.key)
			return modifiers < other.modifiers;
		else
			return key < other.key;
	}
};

/**
 */
class KeyToCommand {
public:
	Scintilla::Keys key;
	Scintilla::KeyMod modifiers;
	Scintilla::Message msg;
};

/**
 */
class KeyMap {
	std::map<KeyModifiers, Scintilla::Message> kmap;
	static const KeyToCommand MapDefault[];

public:
	KeyMap();
	void Clear() noexcept;
	void AssignCmdKey(Scintilla::Keys key, Scintilla::KeyMod modifiers, Scintilla::Message msg);
	Scintilla::Message Find(Scintilla::Keys key, Scintilla::KeyMod modifiers) const;	// 0 returned on failure
	const std::map<KeyModifiers, Scintilla::Message> &GetKeyMap() const noexcept;
};

}

#endif


================================================
FILE: Libraries/scintilla/src/LineMarker.cxx
================================================
// Scintilla source code edit control
/** @file LineMarker.cxx
 ** Defines the look of a line marker in the margin.
 **/
// Copyright 1998-2011 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#include <cstdint>
#include <cstring>
#include <cmath>

#include <stdexcept>
#include <string>
#include <string_view>
#include <vector>
#include <map>
#include <optional>
#include <algorithm>
#include <iterator>
#include <memory>

#include "ScintillaTypes.h"

#include "Debugging.h"
#include "Geometry.h"

#include "Platform.h"

#include "XPM.h"
#include "LineMarker.h"
#include "UniConversion.h"

using namespace Scintilla;
using namespace Scintilla::Internal;

LineMarker::LineMarker(const LineMarker &other) {
	// Defined to avoid pxpm and image being blindly copied, not as a complete copy constructor.
	markType = other.markType;
	fore = other.fore;
	back = other.back;
	backSelected = other.backSelected;
	strokeWidth = other.strokeWidth;
	layer = other.layer;
	alpha = other.alpha;
	if (other.pxpm)
		pxpm = std::make_unique<XPM>(*other.pxpm);
	else
		pxpm = nullptr;
	if (other.image)
		image = std::make_unique<RGBAImage>(*other.image);
	else
		image = nullptr;
	customDraw = other.customDraw;
}

LineMarker &LineMarker::operator=(const LineMarker &other) {
	// Defined to avoid pxpm and image being blindly copied, not as a complete assignment operator.
	if (this != &other) {
		markType = other.markType;
		fore = other.fore;
		back = other.back;
		backSelected = other.backSelected;
		strokeWidth = other.strokeWidth;
		layer = other.layer;
		alpha = other.alpha;
		if (other.pxpm)
			pxpm = std::make_unique<XPM>(*other.pxpm);
		else
			pxpm = nullptr;
		if (other.image)
			image = std::make_unique<RGBAImage>(*other.image);
		else
			image = nullptr;
		customDraw = other.customDraw;
	}
	return *this;
}

ColourRGBA LineMarker::BackWithAlpha() const noexcept {
	return ColourRGBA(back, static_cast<int>(alpha));
}

void LineMarker::SetXPM(const char *textForm) {
	pxpm = std::make_unique<XPM>(textForm);
	markType = MarkerSymbol::Pixmap;
}

void LineMarker::SetXPM(const char *const *linesForm) {
	pxpm = std::make_unique<XPM>(linesForm);
	markType = MarkerSymbol::Pixmap;
}

void LineMarker::SetRGBAImage(Point sizeRGBAImage, float scale, const unsigned char *pixelsRGBAImage) {
	image = std::make_unique<RGBAImage>(static_cast<int>(sizeRGBAImage.x), static_cast<int>(sizeRGBAImage.y), scale, pixelsRGBAImage);
	markType = MarkerSymbol::RgbaImage;
}

namespace {

enum class Expansion { Minus, Plus };
enum class Shape { Square, Circle };

void DrawSymbol(Surface *surface, Shape shape, Expansion expansion, PRectangle rcSymbol, XYPOSITION widthStroke,
	ColourRGBA colourFill, ColourRGBA colourFrame, ColourRGBA colourFrameRight, ColourRGBA colourExpansion) {

	const FillStroke fillStroke(colourFill, colourFrame, widthStroke);
	const PRectangle rcSymbolLeft = Side(rcSymbol, Edge::left, (rcSymbol.Width() + widthStroke) / 2.0f);
	surface->SetClip(rcSymbolLeft);
	if (shape == Shape::Square) {
		// Hollowed square
		surface->RectangleDraw(rcSymbol, fillStroke);
	} else {
		surface->Ellipse(rcSymbol, fillStroke);
	}
	surface->PopClip();

	const FillStroke fillStrokeRight(colourFill, colourFrameRight, widthStroke);
	const PRectangle rcSymbolRight = Side(rcSymbol, Edge::right, (rcSymbol.Width() - widthStroke) / 2.0f);
	surface->SetClip(rcSymbolRight);
	if (shape == Shape::Square) {
		surface->RectangleDraw(rcSymbol, fillStrokeRight);
	} else {
		surface->Ellipse(rcSymbol, fillStrokeRight);
	}
	surface->PopClip();

	const PRectangle rcPlusMinus = rcSymbol.Inset(widthStroke + 1.0f);
	const XYPOSITION armWidth = (rcPlusMinus.Width() - widthStroke) / 2.0f;
	const XYPOSITION top = rcPlusMinus.top + armWidth;
	const PRectangle rcH = PRectangle(
		rcPlusMinus.left, top,
		rcPlusMinus.right, top + widthStroke);
	surface->FillRectangle(rcH, colourExpansion);
	if (expansion == Expansion::Plus) {
		const XYPOSITION left = rcPlusMinus.left + armWidth;
		const PRectangle rcV = PRectangle(
			left, rcPlusMinus.top,
			left + widthStroke, rcPlusMinus.bottom);
		surface->FillRectangle(rcV, colourExpansion);
	}
}

void DrawTail(Surface *surface, XYPOSITION leftLine, XYPOSITION rightTail, XYPOSITION centreY, XYPOSITION widthSymbolStroke, ColourRGBA fill) {
	const XYPOSITION slopeLength = 2.0f + widthSymbolStroke;
	const XYPOSITION strokeTop = centreY + slopeLength;
	const XYPOSITION halfWidth = widthSymbolStroke / 2.0f;
	const XYPOSITION strokeMiddle = strokeTop + halfWidth;
	const Point lines[] = {
		// Stick
		Point(rightTail, strokeMiddle),
		Point(leftLine + halfWidth + slopeLength, strokeMiddle),
		// Slope
		Point(leftLine + widthSymbolStroke / 2.0f, centreY + halfWidth),
	};
	surface->PolyLine(lines, std::size(lines), Stroke(fill, widthSymbolStroke));
}

}

void LineMarker::DrawFoldingMark(Surface *surface, const PRectangle &rcWhole, FoldPart part) const {
	// Assume: edges of rcWhole are integers.
	// Code can only really handle integer strokeWidth.

	ColourRGBA colourHead = back;
	ColourRGBA colourBody = back;
	ColourRGBA colourTail = back;

	switch (part) {
	case FoldPart::head:
	case FoldPart::headWithTail:
		colourHead = backSelected;
		colourTail = backSelected;
		break;
	case FoldPart::body:
		colourHead = backSelected;
		colourBody = backSelected;
		break;
	case FoldPart::tail:
		colourBody = backSelected;
		colourTail = backSelected;
		break;
	default:
		// LineMarker::undefined
		break;
	}

	const int pixelDivisions = surface->PixelDivisions();

	// Folding symbols should have equal height and width to be either a circle or square.
	// So find the minimum of width and height.
	const XYPOSITION minDimension = std::floor(std::min(rcWhole.Width(), rcWhole.Height() - 2)) - 1;

	// If strokeWidth would take up too much of area reduce to reasonable width.
	const XYPOSITION widthStroke = PixelAlignFloor(std::min(strokeWidth, minDimension / 5.0f), pixelDivisions);

	// To centre +/-, odd strokeWidth -> odd symbol width, even -> even
	const XYPOSITION widthSymbol =
		((std::lround(minDimension * pixelDivisions) % 2) == (std::lround(widthStroke * pixelDivisions) % 2)) ?
		minDimension : minDimension - (1.0 / static_cast<XYPOSITION>(pixelDivisions));

	const Point centre = PixelAlign(rcWhole.Centre(), pixelDivisions);

	// Folder symbols and lines follow some rules to join up, fit the pixel grid,
	// and avoid over-painting.

	const XYPOSITION halfSymbol = std::round(widthSymbol / 2);
	const Point topLeft(centre.x - halfSymbol, centre.y - halfSymbol);
	const PRectangle rcSymbol(
		topLeft.x, topLeft.y,
		topLeft.x + widthSymbol, topLeft.y + widthSymbol);
	const XYPOSITION leftLine = rcSymbol.Centre().x - widthStroke / 2.0f;
	const XYPOSITION rightLine = leftLine + widthStroke;

	// This is the vertical line through the whole area which is subdivided
	// when there is a symbol on the line or the colour changes for highlighting.
	const PRectangle rcVLine(leftLine, rcWhole.top, rightLine, rcWhole.bottom);

	// Portions of rcVLine above and below the symbol.
	const PRectangle rcAboveSymbol = Clamp(rcVLine, Edge::bottom, rcSymbol.top);
	const PRectangle rcBelowSymbol = Clamp(rcVLine, Edge::top, rcSymbol.bottom);

	// Projection to right.
	const PRectangle rcStick(
		rcVLine.right, centre.y + 1.0f - widthStroke,
		rcWhole.right - 1, centre.y + 1.0f);

	switch (markType) {

	case MarkerSymbol::VLine:
		surface->FillRectangle(rcVLine, colourBody);
		break;

	case MarkerSymbol::LCorner:
		surface->FillRectangle(Clamp(rcVLine, Edge::bottom, centre.y + 1.0f), colourTail);
		surface->FillRectangle(rcStick, colourTail);
		break;

	case MarkerSymbol::TCorner:
		surface->FillRectangle(Clamp(rcVLine, Edge::bottom, centre.y + 1.0f), colourBody);
		surface->FillRectangle(Clamp(rcVLine, Edge::top, centre.y + 1.0f), colourHead);
		surface->FillRectangle(rcStick, colourTail);
		break;

	// CORNERCURVE cases divide slightly lower than CORNER to accommodate the curve
	case MarkerSymbol::LCornerCurve:
		surface->FillRectangle(Clamp(rcVLine, Edge::bottom, centre.y), colourTail);
		DrawTail(surface, leftLine, rcWhole.right - 1.0f, centre.y - widthStroke,
			widthStroke, colourTail);
		break;

	case MarkerSymbol::TCornerCurve:
		surface->FillRectangle(Clamp(rcVLine, Edge::bottom, centre.y), colourBody);
		surface->FillRectangle(Clamp(rcVLine, Edge::top, centre.y), colourHead);
		DrawTail(surface, leftLine, rcWhole.right - 1.0f, centre.y - widthStroke,
			widthStroke, colourTail);
		break;

	case MarkerSymbol::BoxPlus:
		DrawSymbol(surface, Shape::Square, Expansion::Plus, rcSymbol, widthStroke,
			fore, colourHead, colourHead, colourTail);
		break;

	case MarkerSymbol::BoxPlusConnected: {
			const ColourRGBA colourBelow = (part == FoldPart::headWithTail) ? colourTail : colourBody;
			surface->FillRectangle(rcBelowSymbol, colourBelow);
			surface->FillRectangle(rcAboveSymbol, colourBody);

			const ColourRGBA colourRight = (part == FoldPart::body) ? colourTail : colourHead;
			DrawSymbol(surface, Shape::Square, Expansion::Plus, rcSymbol, widthStroke,
				fore, colourHead, colourRight, colourTail);
		}
		break;

	case MarkerSymbol::BoxMinus:
		surface->FillRectangle(rcBelowSymbol, colourHead);
		DrawSymbol(surface, Shape::Square, Expansion::Minus, rcSymbol, widthStroke,
			fore, colourHead, colourHead, colourTail);
		break;

	case MarkerSymbol::BoxMinusConnected: {
			surface->FillRectangle(rcBelowSymbol, colourHead);
			surface->FillRectangle(rcAboveSymbol, colourBody);

			const ColourRGBA colourRight = (part == FoldPart::body) ? colourTail : colourHead;
			DrawSymbol(surface, Shape::Square, Expansion::Minus, rcSymbol, widthStroke,
				fore, colourHead, colourRight, colourTail);
		}
		break;

	case MarkerSymbol::CirclePlus:
		DrawSymbol(surface, Shape::Circle, Expansion::Plus, rcSymbol, widthStroke,
			fore, colourHead, colourHead, colourTail);
		break;

	case MarkerSymbol::CirclePlusConnected: {
			const ColourRGBA colourBelow = (part == FoldPart::headWithTail) ? colourTail : colourBody;
			surface->FillRectangle(rcBelowSymbol, colourBelow);
			surface->FillRectangle(rcAboveSymbol, colourBody);

			const ColourRGBA colourRight = (part == FoldPart::body) ? colourTail : colourHead;
			DrawSymbol(surface, Shape::Circle, Expansion::Plus, rcSymbol, widthStroke,
				fore, colourHead, colourRight, colourTail);
		}
		break;

	case MarkerSymbol::CircleMinus:
		surface->FillRectangle(rcBelowSymbol, colourHead);
		DrawSymbol(surface, Shape::Circle, Expansion::Minus, rcSymbol, widthStroke,
			fore, colourHead, colourHead, colourTail);
		break;

	case MarkerSymbol::CircleMinusConnected: {
			surface->FillRectangle(rcBelowSymbol, colourHead);
			surface->FillRectangle(rcAboveSymbol, colourBody);
			const ColourRGBA colourRight = (part == FoldPart::body) ? colourTail : colourHead;
			DrawSymbol(surface, Shape::Circle, Expansion::Minus, rcSymbol, widthStroke,
				fore, colourHead, colourRight, colourTail);
		}
		break;

	default:
		break;

	}
}

void LineMarker::AlignedPolygon(Surface *surface, const Point *pts, size_t npts) const {
	const XYPOSITION move = strokeWidth / 2.0;
	std::vector<Point> points;
	std::transform(pts, pts + npts, std::back_inserter(points), [=](Point pt) noexcept ->Point {
		return Point(pt.x + move, pt.y + move);
	});
	surface->Polygon(points.data(), std::size(points), FillStroke(back, fore, strokeWidth));
}

void LineMarker::Draw(Surface *surface, const PRectangle &rcWhole, const Font *fontForCharacter, FoldPart part, MarginType marginStyle) const {
	// This is to satisfy the changed API - eventually the stroke width will be exposed to clients

	if (customDraw) {
		customDraw(surface, rcWhole, fontForCharacter, static_cast<int>(part), marginStyle, this);
		return;
	}

	if ((markType == MarkerSymbol::Pixmap) && (pxpm)) {
		pxpm->Draw(surface, rcWhole);
		return;
	}
	if ((markType == MarkerSymbol::RgbaImage) && (image)) {
		// Make rectangle just large enough to fit image centred on centre of rcWhole
		PRectangle rcImage;
		rcImage.top = ((rcWhole.top + rcWhole.bottom) - image->GetScaledHeight()) / 2;
		rcImage.bottom = rcImage.top + image->GetScaledHeight();
		rcImage.left = ((rcWhole.left + rcWhole.right) - image->GetScaledWidth()) / 2;
		rcImage.right = rcImage.left + image->GetScaledWidth();
		surface->DrawRGBAImage(rcImage, image->GetWidth(), image->GetHeight(), image->Pixels());
		return;
	}

	if ((markType >= MarkerSymbol::VLine) && markType <= (MarkerSymbol::CircleMinusConnected)) {
		DrawFoldingMark(surface, rcWhole, part);
		return;
	}

	// Restrict most shapes a bit
	const PRectangle rc(rcWhole.left, rcWhole.top + 1, rcWhole.right, rcWhole.bottom - 1);
	// Ensure does not go beyond edge
	const XYPOSITION minDim = std::min(rcWhole.Width(), rcWhole.Height() - 2) - 1;

	const Point centre = rcWhole.Centre();
	XYPOSITION centreX = std::floor(centre.x);
	const XYPOSITION centreY = std::floor(centre.y);
	const XYPOSITION dimOn2 = std::floor(minDim / 2);
	const XYPOSITION dimOn4 = std::floor(minDim / 4);
	const XYPOSITION armSize = dimOn2 - 2;
	if (marginStyle == MarginType::Number || marginStyle == MarginType::Text || marginStyle == MarginType::RText) {
		// On textual margins move marker to the left to try to avoid overlapping the text
		centreX = rcWhole.left + dimOn2 + 1;
	}

	switch (markType) {
	case MarkerSymbol::RoundRect: {
			PRectangle rcRounded = rc;
			rcRounded.left = rc.left + 1;
			rcRounded.right = rc.right - 1;
			surface->RoundedRectangle(rcRounded, FillStroke(back, fore, strokeWidth));
		}
		break;

	case MarkerSymbol::Circle: {
			const PRectangle rcCircle = PRectangle(
							    centreX - dimOn2,
							    centreY - dimOn2,
							    centreX + dimOn2,
							    centreY + dimOn2);
			surface->Ellipse(rcCircle, FillStroke(back, fore, strokeWidth));
		}
		break;

	case MarkerSymbol::Arrow: {
			const Point pts[] = {
				Point(centreX - dimOn4, centreY - dimOn2),
				Point(centreX - dimOn4, centreY + dimOn2),
				Point(centreX + dimOn2 - dimOn4, centreY),
			};
			AlignedPolygon(surface, pts, std::size(pts));
		}
		break;

	case MarkerSymbol::ArrowDown: {
			const Point pts[] = {
				Point(centreX - dimOn2, centreY - dimOn4),
				Point(centreX + dimOn2, centreY - dimOn4),
				Point(centreX, centreY + dimOn2 - dimOn4),
			};
			AlignedPolygon(surface, pts, std::size(pts));
		}
		break;

	case MarkerSymbol::Plus: {
			const Point pts[] = {
				Point(centreX - armSize, centreY - 1),
				Point(centreX - 1, centreY - 1),
				Point(centreX - 1, centreY - armSize),
				Point(centreX + 1, centreY - armSize),
				Point(centreX + 1, centreY - 1),
				Point(centreX + armSize, centreY - 1),
				Point(centreX + armSize, centreY + 1),
				Point(centreX + 1, centreY + 1),
				Point(centreX + 1, centreY + armSize),
				Point(centreX - 1, centreY + armSize),
				Point(centreX - 1, centreY + 1),
				Point(centreX - armSize, centreY + 1),
			};
			AlignedPolygon(surface, pts, std::size(pts));
		}
		break;

	case MarkerSymbol::Minus: {
			const Point pts[] = {
				Point(centreX - armSize, centreY - 1),
				Point(centreX + armSize, centreY - 1),
				Point(centreX + armSize, centreY + 1),
				Point(centreX - armSize, centreY + 1),
			};
			AlignedPolygon(surface, pts, std::size(pts));
		}
		break;

	case MarkerSymbol::SmallRect: {
			PRectangle rcSmall;
			rcSmall.left = rc.left + 1;
			rcSmall.top = rc.top + 2;
			rcSmall.right = rc.right - 1;
			rcSmall.bottom = rc.bottom - 2;
			surface->RectangleDraw(rcSmall, FillStroke(back, fore, strokeWidth));
		}
		break;

	case MarkerSymbol::Empty:
	case MarkerSymbol::Background:
	case MarkerSymbol::Underline:
	case MarkerSymbol::Available:
		// An invisible marker so don't draw anything
		break;

	case MarkerSymbol::DotDotDot: {
			// 3 2x2 dots with 3 pixels between, margin must be 12 wide to show all
			constexpr XYPOSITION pitchDots = 5.0;
			XYPOSITION xBlob = std::floor(centreX - (pitchDots + 1));
			for (int b = 0; b < 3; b++) {
				const PRectangle rcBlob(xBlob, rc.bottom - 4, xBlob + 2, rc.bottom - 2);
				surface->FillRectangle(rcBlob, fore);
				xBlob += pitchDots;
			}
		}
		break;

	case MarkerSymbol::Arrows: {
			XYPOSITION right = centreX - 4.0f + strokeWidth / 2.0f;
			const XYPOSITION midY = centreY + strokeWidth / 2.0f;
			const XYPOSITION armLength = std::round(dimOn2 - strokeWidth);
			for (int b = 0; b < 3; b++) {
				const Point pts[] = {
					Point(right - armLength, midY - armLength),
					Point(right, midY),
					Point(right - armLength, midY + armLength)
				};
				surface->PolyLine(pts, std::size(pts), Stroke(fore, strokeWidth));
				right += strokeWidth + 3.0f;
			}
		}
		break;

	case MarkerSymbol::ShortArrow: {
			const Point pts[] = {
				Point(centreX, centreY + dimOn2),
				Point(centreX + dimOn2, centreY),
				Point(centreX, centreY - dimOn2),
				Point(centreX, centreY - dimOn4),
				Point(centreX - dimOn4, centreY - dimOn4),
				Point(centreX - dimOn4, centreY + dimOn4),
				Point(centreX, centreY + dimOn4),
				Point(centreX, centreY + dimOn2),
			};
			AlignedPolygon(surface, pts, std::size(pts));
		}
		break;

	case MarkerSymbol::FullRect:
		surface->FillRectangle(rcWhole, back);
		break;

	case MarkerSymbol::LeftRect: {
			PRectangle rcLeft = rcWhole;
			rcLeft.right = rcLeft.left + 4;
			surface->FillRectangle(rcLeft, back);
		}
		break;

	case MarkerSymbol::Bar: {
			// Hide cap by continuing a bit.
			constexpr XYPOSITION continueLength = 5.0;
			PRectangle rcBar = rcWhole;
			const XYPOSITION widthBar = std::ceil(rcWhole.Width() / 3.0);
			rcBar.left = centreX - std::floor(widthBar / 2.0);
			rcBar.right = rcBar.left + widthBar;
			surface->SetClip(rcWhole);	// Hide continued caps
			switch (part) {
			case LineMarker::FoldPart::headWithTail:
				surface->RectangleDraw(rcBar, FillStroke(back, fore, strokeWidth));
				break;
			case LineMarker::FoldPart::head:
				rcBar.bottom += continueLength;
				surface->RectangleDraw(rcBar, FillStroke(back, fore, strokeWidth));
				break;
			case LineMarker::FoldPart::tail:
				rcBar.top -= continueLength;
				surface->RectangleDraw(rcBar, FillStroke(back, fore, strokeWidth));
				break;
			case LineMarker::FoldPart::body:
				rcBar.top -= continueLength;
				rcBar.bottom += continueLength;
				surface->RectangleDraw(rcBar, FillStroke(back, fore, strokeWidth));
				break;
			default:
				break;
			}
			surface->PopClip();
		}
		break;


	case MarkerSymbol::Bookmark: {
			const XYPOSITION halfHeight = std::floor(minDim / 3);
			const Point pts[] = {
				Point(rcWhole.left, centreY - halfHeight),
				Point(rcWhole.right - strokeWidth - 2, centreY - halfHeight),
				Point(rcWhole.right - strokeWidth - 2 - halfHeight, centreY),
				Point(rcWhole.right - strokeWidth - 2, centreY + halfHeight),
				Point(rcWhole.left, centreY + halfHeight),
			};
			AlignedPolygon(surface, pts, std::size(pts));
		}
		break;

	case MarkerSymbol::VerticalBookmark: {
			const XYPOSITION halfWidth = std::floor(minDim / 3);
			const Point pts[] = {
				Point(centreX - halfWidth, centreY - dimOn2),
				Point(centreX + halfWidth, centreY - dimOn2),
				Point(centreX + halfWidth, centreY + dimOn2),
				Point(centreX, centreY + dimOn2 - halfWidth),
				Point(centreX - halfWidth, centreY + dimOn2),
			};
			AlignedPolygon(surface, pts, std::size(pts));
		}
		break;

	default:
		if (markType >= MarkerSymbol::Character) {
			char character[UTF8MaxBytes + 1] {};
			const int uch = static_cast<int>(markType) - static_cast<int>(MarkerSymbol::Character);
			UTF8FromUTF32Character(uch, character);
			const XYPOSITION width = surface->WidthTextUTF8(fontForCharacter, character);
			PRectangle rcText = rc;
			rcText.left += (rc.Width() - width) / 2;
			rcText.right = rcText.left + width;
			surface->DrawTextNoClipUTF8(rcText, fontForCharacter, rcText.bottom - 2,
						 character, fore, back);
		} else {
			// treat as MarkerSymbol::FullRect
			surface->FillRectangle(rcWhole, back);
		}
		break;
	}
}


================================================
FILE: Libraries/scintilla/src/LineMarker.h
================================================
// Scintilla source code edit control
/** @file LineMarker.h
 ** Defines the look of a line marker in the margin .
 **/
// Copyright 1998-2011 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#ifndef LINEMARKER_H
#define LINEMARKER_H

namespace Scintilla::Internal {

class XPM;
class RGBAImage;

typedef void (*DrawLineMarkerFn)(Surface *surface, const PRectangle &rcWhole, const Font *fontForCharacter, int tFold, Scintilla::MarginType marginStyle, const void *lineMarker);

/**
 */
class LineMarker {
public:
	enum class FoldPart { undefined, head, body, tail, headWithTail };

	Scintilla::MarkerSymbol markType = Scintilla::MarkerSymbol::Circle;
	ColourRGBA fore = black;
	ColourRGBA back = white;
	ColourRGBA backSelected = ColourRGBA(maximumByte, 0, 0);	// Red default
	Scintilla::Layer layer = Scintilla::Layer::Base;
	Scintilla::Alpha alpha = Scintilla::Alpha::NoAlpha;
	XYPOSITION strokeWidth = 1.0f;
	std::unique_ptr<XPM> pxpm;
	std::unique_ptr<RGBAImage> image;
	/** Some platforms, notably PLAT_CURSES, do not support Scintilla's native
	 * Draw function for drawing line markers. Allow those platforms to override
	 * it instead of creating a new method(s) in the Surface class that existing
	 * platforms must implement as empty. */
	DrawLineMarkerFn customDraw = nullptr;

	LineMarker() noexcept = default;
	LineMarker(const LineMarker &other);
	LineMarker(LineMarker &&) noexcept = default;
	LineMarker &operator=(const LineMarker& other);
	LineMarker &operator=(LineMarker&&) noexcept = default;
	virtual ~LineMarker() = default;

	ColourRGBA BackWithAlpha() const noexcept;

	void SetXPM(const char *textForm);
	void SetXPM(const char *const *linesForm);
	void SetRGBAImage(Point sizeRGBAImage, float scale, const unsigned char *pixelsRGBAImage);
	void AlignedPolygon(Surface *surface, const Point *pts, size_t npts) const;
	void Draw(Surface *surface, const PRectangle &rcWhole, const Font *fontForCharacter, FoldPart part, Scintilla::MarginType marginStyle) const;
	void DrawFoldingMark(Surface *surface, const PRectangle &rcWhole, FoldPart part) const;
};

}

#endif


================================================
FILE: Libraries/scintilla/src/MarginView.cxx
================================================
// Scintilla source code edit control
/** @file MarginView.cxx
 ** Defines the appearance of the editor margin.
 **/
// Copyright 1998-2014 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#include <cstddef>
#include <cstdlib>
#include <cstdint>
#include <cassert>
#include <cstring>
#include <cstdio>
#include <cmath>

#include <stdexcept>
#include <string>
#include <string_view>
#include <vector>
#include <map>
#include <set>
#include <optional>
#include <algorithm>
#include <memory>

#include "ScintillaTypes.h"
#include "ScintillaMessages.h"
#include "ScintillaStructures.h"
#include "ILoader.h"
#include "ILexer.h"

#include "Debugging.h"
#include "Geometry.h"
#include "Platform.h"

#include "CharacterCategoryMap.h"
#include "Position.h"
#include "UniqueString.h"
#include "SplitVector.h"
#include "Partitioning.h"
#include "RunStyles.h"
#include "ContractionState.h"
#include "CellBuffer.h"
#include "KeyMap.h"
#include "Indicator.h"
#include "LineMarker.h"
#include "Style.h"
#include "ViewStyle.h"
#include "CharClassify.h"
#include "Decoration.h"
#include "CaseFolder.h"
#include "Document.h"
#include "UniConversion.h"
#include "Selection.h"
#include "PositionCache.h"
#include "EditModel.h"
#include "MarginView.h"
#include "EditView.h"

using namespace Scintilla;

namespace Scintilla::Internal {

void DrawWrapMarker(Surface *surface, PRectangle rcPlace,
	bool isEndMarker, ColourRGBA wrapColour) {

	const XYPOSITION extraFinalPixel = surface->SupportsFeature(Supports::LineDrawsFinal) ? 0.0f : 1.0f;

	const PRectangle rcAligned = PixelAlignOutside(rcPlace, surface->PixelDivisions());

	const XYPOSITION widthStroke = std::floor(rcAligned.Width() / 6);

	constexpr XYPOSITION xa = 1; // gap before start
	const XYPOSITION w = rcAligned.Width() - xa - widthStroke;

	// isEndMarker -> x-mirrored symbol for start marker

	const XYPOSITION x0 = isEndMarker ? rcAligned.left : rcAligned.right - widthStroke;
	const XYPOSITION y0 = rcAligned.top;

	const XYPOSITION dy = std::floor(rcAligned.Height() / 5);
	const XYPOSITION y = std::floor(rcAligned.Height() / 2) + dy;

	struct Relative {
		XYPOSITION xBase;
		int xDir;
		XYPOSITION yBase;
		int yDir;
		XYPOSITION halfWidth;
		Point At(XYPOSITION xRelative, XYPOSITION yRelative) const noexcept {
			return Point(xBase + xDir * xRelative + halfWidth, yBase + yDir * yRelative + halfWidth);
		}
	};

	const Relative rel = { x0, isEndMarker ? 1 : -1, y0, 1, widthStroke / 2.0f };

	// arrow head
	const Point head[] = {
		rel.At(xa + dy, y - dy),
		rel.At(xa, y),
		rel.At(xa + dy + extraFinalPixel, y + dy + extraFinalPixel)
	};
	surface->PolyLine(head, std::size(head), Stroke(wrapColour, widthStroke));

	// arrow body
	const Point body[] = {
		rel.At(xa, y),
		rel.At(xa + w, y),
		rel.At(xa + w, y - 2 * dy),
		rel.At(xa, y - 2 * dy),
	};
	surface->PolyLine(body, std::size(body), Stroke(wrapColour, widthStroke));
}

MarginView::MarginView() noexcept {
	wrapMarkerPaddingRight = 3;
	customDrawWrapMarker = nullptr;
}

void MarginView::DropGraphics() noexcept {
	pixmapSelMargin.reset();
	pixmapSelPattern.reset();
	pixmapSelPatternOffset1.reset();
}

void MarginView::RefreshPixMaps(Surface *surfaceWindow, const ViewStyle &vsDraw) {
	if (!(pixmapSelPattern && pixmapSelPatternOffset1)) {
		constexpr int patternSize = 8;
		pixmapSelPattern = surfaceWindow->AllocatePixMap(patternSize, patternSize);
		pixmapSelPatternOffset1 = surfaceWindow->AllocatePixMap(patternSize, patternSize);
		// This complex procedure is to reproduce the checkerboard dithered pattern used by windows
		// for scroll bars and Visual Studio for its selection margin. The colour of this pattern is half
		// way between the chrome colour and the chrome highlight colour making a nice transition
		// between the window chrome and the content area. And it works in low colour depths.
		const PRectangle rcPattern = PRectangle::FromInts(0, 0, patternSize, patternSize);

		// Initialize default colours based on the chrome colour scheme.  Typically the highlight is white.
		ColourRGBA colourFMFill = vsDraw.selbar;
		ColourRGBA colourFMStripes = vsDraw.selbarlight;

		if (!(vsDraw.selbarlight == white)) {
			// User has chosen an unusual chrome colour scheme so just use the highlight edge colour.
			// (Typically, the highlight colour is white.)
			colourFMFill = vsDraw.selbarlight;
		}

		if (vsDraw.foldmarginColour) {
			// override default fold margin colour
			colourFMFill = *vsDraw.foldmarginColour;
		}
		if (vsDraw.foldmarginHighlightColour) {
			// override default fold margin highlight colour
			colourFMStripes = *vsDraw.foldmarginHighlightColour;
		}

		pixmapSelPattern->FillRectangle(rcPattern, colourFMFill);
		pixmapSelPatternOffset1->FillRectangle(rcPattern, colourFMStripes);
		for (int y = 0; y < patternSize; y++) {
			for (int x = y % 2; x < patternSize; x += 2) {
				const PRectangle rcPixel = PRectangle::FromInts(x, y, x + 1, y + 1);
				pixmapSelPattern->FillRectangle(rcPixel, colourFMStripes);
				pixmapSelPatternOffset1->FillRectangle(rcPixel, colourFMFill);
			}
		}
		pixmapSelPattern->FlushDrawing();
		pixmapSelPatternOffset1->FlushDrawing();
	}
}

namespace {

MarkerOutline SubstituteMarkerIfEmpty(MarkerOutline markerCheck, MarkerOutline markerDefault, const ViewStyle &vs) noexcept {
	if (vs.markers[static_cast<size_t>(markerCheck)].markType == MarkerSymbol::Empty)
		return markerDefault;
	return markerCheck;
}

constexpr MarkerOutline TailFromNextLevel(FoldLevel levelNextNum) noexcept {
	return (levelNextNum > FoldLevel::Base) ? MarkerOutline::FolderMidTail : MarkerOutline::FolderTail;
}

int FoldingMark(FoldLevel level, FoldLevel levelNext, bool firstSubLine, bool lastSubLine,
	bool isExpanded, bool needWhiteClosure, MarkerOutline folderOpenMid, MarkerOutline folderEnd) noexcept {

	const FoldLevel levelNum = LevelNumberPart(level);
	const FoldLevel levelNextNum = LevelNumberPart(levelNext);

	if (LevelIsHeader(level)) {
		if (firstSubLine) {
			if (levelNum < levelNextNum) {
				if (levelNum == FoldLevel::Base) {
					return 1 << (isExpanded ? MarkerOutline::FolderOpen : MarkerOutline::Folder);
				} else {
					return 1 << (isExpanded ? folderOpenMid : folderEnd);
				}
			} else if (levelNum > FoldLevel::Base) {
				return 1 << MarkerOutline::FolderSub;
			}
		} else {
			if (levelNum < levelNextNum) {
				if (isExpanded) {
					return 1 << MarkerOutline::FolderSub;
				} else if (levelNum > FoldLevel::Base) {
					return 1 << MarkerOutline::FolderSub;
				}
			} else if (levelNum > FoldLevel::Base) {
				return 1 << MarkerOutline::FolderSub;
			}
		}
	} else if (LevelIsWhitespace(level)) {
		if (needWhiteClosure) {
			if (LevelIsWhitespace(levelNext)) {
				return 1 << MarkerOutline::FolderSub;
			} else {
				return 1 << TailFromNextLevel(levelNextNum);
			}
		} else if (levelNum > FoldLevel::Base) {
			if (levelNextNum < levelNum) {
				return 1 << TailFromNextLevel(levelNextNum);
			} else {
				return 1 << MarkerOutline::FolderSub;
			}
		}
	} else if (levelNum > FoldLevel::Base) {
		if (levelNextNum < levelNum) {
			if (LevelIsWhitespace(levelNext)) {
				return 1 << MarkerOutline::FolderSub;
			} else if (lastSubLine) {
				return 1 << TailFromNextLevel(levelNextNum);
			} else {
				return 1 << MarkerOutline::FolderSub;
			}
		} else {
			return 1 << MarkerOutline::FolderSub;
		}
	}

	// No folding mark on this line
	return 0;
}

LineMarker::FoldPart PartForFoldHighlight(const HighlightDelimiter &highlightDelimiter, Sci::Line lineDoc, bool firstSubLine, bool headWithTail, bool isExpanded) noexcept {
	if (highlightDelimiter.IsFoldBlockHighlighted(lineDoc)) {
		if (highlightDelimiter.IsBodyOfFoldBlock(lineDoc)) {
			return LineMarker::FoldPart::body;
		}
		if (highlightDelimiter.IsHeadOfFoldBlock(lineDoc)) {
			if (firstSubLine) {
				return headWithTail ? LineMarker::FoldPart::headWithTail : LineMarker::FoldPart::head;
			}
			if (isExpanded || headWithTail) {
				return LineMarker::FoldPart::body;
			}
		} else if (highlightDelimiter.IsTailOfFoldBlock(lineDoc)) {
			return LineMarker::FoldPart::tail;
		}
	}
	return LineMarker::FoldPart::undefined;
}

constexpr LineMarker::FoldPart PartForBar(bool markBefore, bool markAfter) {
	if (markBefore) {
		if (markAfter) {
			return LineMarker::FoldPart::body;
		}
		return LineMarker::FoldPart::tail;
	}
	if (markAfter) {
		return LineMarker::FoldPart::head;
	}
	return LineMarker::FoldPart::headWithTail;
}

}

void MarginView::PaintOneMargin(Surface *surface, PRectangle rc, PRectangle rcOneMargin, const MarginStyle &marginStyle,
	const EditModel &model, const ViewStyle &vs /*Au*/, int margin) const {

	//Au:
	int cdFirstLine = -1, cdLastLine = 0;

	const Point ptOrigin = model.GetVisibleOriginInMain();
	const Sci::Line lineStartPaint = static_cast<Sci::Line>(rcOneMargin.top + ptOrigin.y) / vs.lineHeight;
	Sci::Line visibleLine = model.TopLineOfMain() + lineStartPaint;
	XYPOSITION yposScreen = static_cast<XYPOSITION>(lineStartPaint * vs.lineHeight) - ptOrigin.y;
	// Work out whether the top line is whitespace located after a
	// lessening of fold level which implies a 'fold tail' but which should not
	// be displayed until the last of a sequence of whitespace.
	bool needWhiteClosure = false;
	if (marginStyle.ShowsFolding()) {
		const FoldLevel level = model.pdoc->GetFoldLevel(model.pcs->DocFromDisplay(visibleLine));
		if (LevelIsWhitespace(level)) {
			Sci::Line lineBack = model.pcs->DocFromDisplay(visibleLine);
			FoldLevel levelPrev = level;
			while ((lineBack > 0) && LevelIsWhitespace(levelPrev)) {
				lineBack--;
				levelPrev = model.pdoc->GetFoldLevel(lineBack);
			}
			if (!LevelIsHeader(levelPrev)) {
				if (LevelNumber(level) < LevelNumber(levelPrev))
					needWhiteClosure = true;
			}
		}
	}

	// Old code does not know about new markers needed to distinguish all cases
	const MarkerOutline folderOpenMid = SubstituteMarkerIfEmpty(MarkerOutline::FolderOpenMid,
		MarkerOutline::FolderOpen, vs);
	const MarkerOutline folderEnd = SubstituteMarkerIfEmpty(MarkerOutline::FolderEnd,
		MarkerOutline::Folder, vs);

	while ((visibleLine < model.pcs->LinesDisplayed()) && yposScreen < rc.bottom) {

		PLATFORM_ASSERT(visibleLine < model.pcs->LinesDisplayed());
		const Sci::Line lineDoc = model.pcs->DocFromDisplay(visibleLine);
		PLATFORM_ASSERT((lineDoc == 0) || model.pcs->GetVisible(lineDoc));
		const Sci::Line firstVisibleLine = model.pcs->DisplayFromDoc(lineDoc);
		const Sci::Line lastVisibleLine = model.pcs->DisplayLastFromDoc(lineDoc);
		const bool firstSubLine = visibleLine == firstVisibleLine;
		const bool lastSubLine = visibleLine == lastVisibleLine;

		//Au:
		if(firstSubLine) {
			cdLastLine = (int)lineDoc; if(cdFirstLine < 0) cdFirstLine = cdLastLine;
		}

		int marks = model.GetMark(lineDoc);
		if (!firstSubLine) {
			// Mask off non-continuing marks
			marks = marks & vs.maskDrawWrapped;
		}

		bool headWithTail = false;
		bool isExpanded = false;

		if (marginStyle.ShowsFolding()) {
			// Decide which fold indicator should be displayed
			const FoldLevel level = model.pdoc->GetFoldLevel(lineDoc);
			const FoldLevel levelNext = model.pdoc->GetFoldLevel(lineDoc + 1);
			isExpanded = model.pcs->GetExpanded(lineDoc);

			marks |= FoldingMark(level, levelNext, firstSubLine, lastSubLine,
				isExpanded, needWhiteClosure, folderOpenMid, folderEnd);

			const FoldLevel levelNum = LevelNumberPart(level);
			const FoldLevel levelNextNum = LevelNumberPart(levelNext);

			// Change needWhiteClosure and headWithTail if needed
			if (LevelIsHeader(level)) {
				needWhiteClosure = false;
				if (!isExpanded) {
					const Sci::Line firstFollowupLine = model.pcs->DocFromDisplay(model.pcs->DisplayFromDoc(lineDoc + 1));
					const FoldLevel firstFollowupLineLevel = model.pdoc->GetFoldLevel(firstFollowupLine);
					const FoldLevel secondFollowupLineLevelNum = LevelNumberPart(model.pdoc->GetFoldLevel(firstFollowupLine + 1));
					if (LevelIsWhitespace(firstFollowupLineLevel) &&
						(levelNum > secondFollowupLineLevelNum))
						needWhiteClosure = true;

					if (highlightDelimiter.IsFoldBlockHighlighted(firstFollowupLine))
						headWithTail = true;
				}
			} else if (LevelIsWhitespace(level)) {
				if (needWhiteClosure) {
					needWhiteClosure = LevelIsWhitespace(levelNext);
				}
			} else if (levelNum > FoldLevel::Base) {
				if (levelNextNum < levelNum) {
					needWhiteClosure = LevelIsWhitespace(levelNext);
				}
			}
		}

		const PRectangle rcMarker(
			rcOneMargin.left,
			yposScreen,
			rcOneMargin.right,
			yposScreen + vs.lineHeight);
		if (marginStyle.style == MarginType::Number) {
			if (firstSubLine) {
				std::string sNumber;
				if (lineDoc >= 0) {
					sNumber = std::to_string(lineDoc + 1);
				}
				if (FlagSet(model.foldFlags, (FoldFlag::LevelNumbers | FoldFlag::LineState))) {
					char number[100] = "";
					if (FlagSet(model.foldFlags, FoldFlag::LevelNumbers)) {
						const FoldLevel lev = model.pdoc->GetFoldLevel(lineDoc);
						snprintf(number,std::size(number), "%c%c %03X %03X",
							LevelIsHeader(lev) ? 'H' : '_',
							LevelIsWhitespace(lev) ? 'W' : '_',
							LevelNumber(lev),
							static_cast<unsigned int>(lev) >> 16
						);
					} else {
						const int state = model.pdoc->GetLineState(lineDoc);
						snprintf(number, std::size(number), "%0X", state);
					}
					sNumber = number;
				}
				PRectangle rcNumber = rcMarker;
				// Right justify
				const XYPOSITION width = surface->WidthText(vs.styles[StyleLineNumber].font.get(), sNumber);
				const XYPOSITION xpos = rcNumber.right - width - vs.marginNumberPadding;
				rcNumber.left = xpos;
				DrawTextNoClipPhase(surface, rcNumber, vs.styles[StyleLineNumber],
					rcNumber.top + vs.maxAscent, sNumber, DrawPhase::all);
			} else if (FlagSet(vs.wrap.visualFlags, WrapVisualFlag::Margin)) {
				PRectangle rcWrapMarker = rcMarker;
				rcWrapMarker.right -= wrapMarkerPaddingRight;
				rcWrapMarker.left = rcWrapMarker.right - vs.styles[StyleLineNumber].aveCharWidth;
				if (!customDrawWrapMarker) {
					DrawWrapMarker(surface, rcWrapMarker, false, vs.styles[StyleLineNumber].fore);
				} else {
					customDrawWrapMarker(surface, rcWrapMarker, false, vs.styles[StyleLineNumber].fore);
				}
			}
		} else if (marginStyle.style == MarginType::Text || marginStyle.style == MarginType::RText) {
			const StyledText stMargin = model.pdoc->MarginStyledText(lineDoc);
			if (stMargin.text && ValidStyledText(vs, vs.marginStyleOffset, stMargin)) {
				if (firstSubLine) {
					surface->FillRectangle(rcMarker,
						vs.styles[stMargin.StyleAt(0) + vs.marginStyleOffset].back);
					PRectangle rcText = rcMarker;
					if (marginStyle.style == MarginType::RText) {
						const int width = WidestLineWidth(surface, vs, vs.marginStyleOffset, stMargin);
						rcText.left = rcText.right - width - 3;
					}
					DrawStyledText(surface, vs, vs.marginStyleOffset, rcText,
						stMargin, 0, stMargin.length, DrawPhase::all);
				} else {
					// if we're displaying annotation lines, colour the margin to match the associated document line
					const int annotationLines = model.pdoc->AnnotationLines(lineDoc);
					if (annotationLines && (visibleLine > lastVisibleLine - annotationLines)) {
						surface->FillRectangle(rcMarker, vs.styles[stMargin.StyleAt(0) + vs.marginStyleOffset].back);
					}
				}
			}
		}

		marks &= marginStyle.mask;

		if (marks) {
			// Draw all the bar markers first so they are underneath as they often cover
			// multiple lines for change history and other markers mark individual lines.
			int marksBar = marks;
			for (int markBit = 0; (markBit <= MarkerMax) && marksBar; markBit++) {
				if ((marksBar & 1) && (vs.markers[markBit].markType == MarkerSymbol::Bar)) {
					const int mask = 1 << markBit;
					const bool markBefore = firstSubLine ? (model.GetMark(lineDoc - 1) & mask) : true;
					const bool markAfter = lastSubLine ? (model.GetMark(lineDoc + 1) & mask) : true;
					vs.markers[markBit].Draw(surface, rcMarker, vs.styles[StyleLineNumber].font.get(),
						PartForBar(markBefore, markAfter), marginStyle.style);
				}
				marksBar >>= 1;
			}
			// Draw all the other markers over the bar markers
			for (int markBit = 0; (markBit <= MarkerMax) && marks; markBit++) {
				if ((marks & 1) && (vs.markers[markBit].markType != MarkerSymbol::Bar)) {
					const LineMarker::FoldPart part = marginStyle.ShowsFolding() ?
						PartForFoldHighlight(highlightDelimiter, lineDoc, firstSubLine, headWithTail, isExpanded) :
						LineMarker::FoldPart::undefined;
					vs.markers[markBit].Draw(surface, rcMarker, vs.styles[StyleLineNumber].font.get(), part, marginStyle.style);
				}
				marks >>= 1;
			}
		}

		visibleLine++;
		yposScreen += vs.lineHeight;
	}

	//Au: call callback
	if(model.cbMarginDraw && 0 != ((model.cbMarginsMask >> (int)margin) & 1) && cdFirstLine >= 0) {
		Sci_MarginDrawCallbackData c = {};
		c.margin = (int)margin;
		c.firstLine = cdFirstLine;
		c.lastLine = cdLastLine;
		c.rect.left = (int)rcOneMargin.left;
		c.rect.top = (int)rcOneMargin.top;
		c.rect.right = (int)rcOneMargin.right;
		c.rect.bottom = (int)rcOneMargin.bottom;
		c.hdc = surface->get_hdc();
		model.cbMarginDraw(c);
	}
}

void MarginView::PaintMargin(Surface *surface, Sci::Line topLine, PRectangle rc, PRectangle rcMargin,
	const EditModel &model, const ViewStyle &vs) {

	PRectangle rcOneMargin = rcMargin;
	rcOneMargin.right = rcMargin.left;
	if (rcOneMargin.bottom < rc.bottom)
		rcOneMargin.bottom = rc.bottom;

	const Point ptOrigin = model.GetVisibleOriginInMain();
	int margin = -1; //Au
	for (const MarginStyle &marginStyle : vs.ms) {
		margin++; //Au
		if (marginStyle.width > 0) {

			rcOneMargin.left = rcOneMargin.right;
			rcOneMargin.right = rcOneMargin.left + marginStyle.width;

			if (marginStyle.style != MarginType::Number) {
				if (marginStyle.ShowsFolding()) {
					// Required because of special way brush is created for selection margin
					// Ensure patterns line up when scrolling with separate margin view
					// by choosing correctly aligned variant.
					const bool invertPhase = static_cast<int>(ptOrigin.y) & 1;
					surface->FillRectangle(rcOneMargin,
						invertPhase ? *pixmapSelPattern : *pixmapSelPatternOffset1);
				} else {
					ColourRGBA colour;
					switch (marginStyle.style) {
					case MarginType::Back:
						colour = vs.styles[StyleDefault].back;
						break;
					case MarginType::Fore:
						colour = vs.styles[StyleDefault].fore;
						break;
					case MarginType::Colour:
						colour = marginStyle.back;
						break;
					default:
						colour = vs.styles[StyleLineNumber].back;
						break;
					}
					surface->FillRectangle(rcOneMargin, colour);
				}
			} else {
				surface->FillRectangle(rcOneMargin, vs.styles[StyleLineNumber].back);
			}

			if (marginStyle.ShowsFolding() && highlightDelimiter.isEnabled) {
				const Sci::Line lastLine = model.pcs->DocFromDisplay(topLine + model.LinesOnScreen()) + 1;
				model.pdoc->GetHighlightDelimiters(highlightDelimiter,
					model.pdoc->SciLineFromPosition(model.sel.MainCaret()), lastLine);
			}

			PaintOneMargin(surface, rc, rcOneMargin, marginStyle, model, vs /*Au*/, margin); //Au
		}
	}

	PRectangle rcBlankMargin = rcMargin;
	rcBlankMargin.left = rcOneMargin.right;
	surface->FillRectangle(rcBlankMargin, vs.styles[StyleDefault].back);
}

}



================================================
FILE: Libraries/scintilla/src/MarginView.h
================================================
// Scintilla source code edit control
/** @file MarginView.h
 ** Defines the appearance of the editor margin.
 **/
// Copyright 1998-2014 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#ifndef MARGINVIEW_H
#define MARGINVIEW_H

namespace Scintilla::Internal {

void DrawWrapMarker(Surface *surface, PRectangle rcPlace, bool isEndMarker, ColourRGBA wrapColour);

typedef void (*DrawWrapMarkerFn)(Surface *surface, PRectangle rcPlace, bool isEndMarker, ColourRGBA wrapColour);

/**
* MarginView draws the margins.
*/
class MarginView {
public:
	std::unique_ptr<Surface> pixmapSelMargin;
	std::unique_ptr<Surface> pixmapSelPattern;
	std::unique_ptr<Surface> pixmapSelPatternOffset1;
	// Highlight current folding block
	HighlightDelimiter highlightDelimiter;

	int wrapMarkerPaddingRight; // right-most pixel padding of wrap markers
	/** Some platforms, notably PLAT_CURSES, do not support Scintilla's native
	 * DrawWrapMarker function for drawing wrap markers. Allow those platforms to
	 * override it instead of creating a new method in the Surface class that
	 * existing platforms must implement as empty. */
	DrawWrapMarkerFn customDrawWrapMarker;

	MarginView() noexcept;

	void DropGraphics() noexcept;
	void RefreshPixMaps(Surface *surfaceWindow, const ViewStyle &vsDraw);
	void PaintOneMargin(Surface *surface, PRectangle rc, PRectangle rcOneMargin, const MarginStyle &marginStyle,
		const EditModel &model, const ViewStyle &vs /*Au*/, int margin) const;
	void PaintMargin(Surface *surface, Sci::Line topLine, PRectangle rc, PRectangle rcMargin,
		const EditModel &model, const ViewStyle &vs);
};

}

#endif


================================================
FILE: Libraries/scintilla/src/Partitioning.h
================================================
// Scintilla source code edit control
/** @file Partitioning.h
 ** Data structure used to partition an interval. Used for holding line start/end positions.
 **/
// Copyright 1998-2007 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#ifndef PARTITIONING_H
#define PARTITIONING_H

namespace Scintilla::Internal {

/// Divide an interval into multiple partitions.
/// Useful for breaking a document down into sections such as lines.
/// A 0 length interval has a single 0 length partition, numbered 0
/// If interval not 0 length then each partition non-zero length
/// When needed, positions after the interval are considered part of the last partition
/// but the end of the last partition can be found with PositionFromPartition(last+1).

template <typename T>
class Partitioning {
private:
	// To avoid calculating all the partition positions whenever any text is inserted
	// there may be a step somewhere in the list.
	T stepPartition;
	T stepLength;
	SplitVector<T> body;

	// Deleted so SplitVectorWithRangeAdd objects can not be copied.
	void RangeAddDelta(T start, T end, T delta) noexcept {
		// end is 1 past end, so end-start is number of elements to change
		const ptrdiff_t position = start;
		ptrdiff_t i = 0;
		const ptrdiff_t rangeLength = end - position;
		ptrdiff_t range1Length = rangeLength;
		const ptrdiff_t part1Left = body.GapPosition() - position;
		if (range1Length > part1Left)
			range1Length = part1Left;
		T *writer = &body[position];
		while (i < range1Length) {
			*writer += delta;
			writer++;
			i++;
		}
		if (i < rangeLength) {
			T *writer2 = &body[position + i];
			while (i < rangeLength) {
				*writer2 += delta;
				writer2++;
				i++;
			}
		}
	}

	// Move step forward
	void ApplyStep(T partitionUpTo) noexcept {
		if (stepLength != 0) {
			RangeAddDelta(stepPartition+1, partitionUpTo + 1, stepLength);
		}
		stepPartition = partitionUpTo;
		if (stepPartition >= Partitions()) {
			stepPartition = Partitions();
			stepLength = 0;
		}
	}

	// Move step backward
	void BackStep(T partitionDownTo) noexcept {
		if (stepLength != 0) {
			RangeAddDelta(partitionDownTo+1, stepPartition+1, -stepLength);
		}
		stepPartition = partitionDownTo;
	}

public:
	explicit Partitioning(size_t growSize=8) : stepPartition(0), stepLength(0), body(growSize) {
		body.Insert(0, 0);	// This value stays 0 for ever
		body.Insert(1, 0);	// This is the end of the first partition and will be the start of the second
	}

	T Partitions() const noexcept {
		return static_cast<T>(body.Length())-1;
	}

	void ReAllocate(ptrdiff_t newSize) {
		// + 1 accounts for initial element that is always 0.
		body.ReAllocate(newSize + 1);
	}

	T Length() const noexcept {
		return PositionFromPartition(Partitions());
	}

	void InsertPartition(T partition, T pos) {
		if (stepPartition < partition) {
			ApplyStep(partition);
		}
		body.Insert(partition, pos);
		stepPartition++;
	}

	void InsertPartitions(T partition, const T *positions, size_t length) {
		if (stepPartition < partition) {
			ApplyStep(partition);
		}
		body.InsertFromArray(partition, positions, 0, length);
		stepPartition += static_cast<T>(length);
	}

	void InsertPartitionsWithCast(T partition, const ptrdiff_t *positions, size_t length) {
		// Used for 64-bit builds when T is 32-bits
		if (stepPartition < partition) {
			ApplyStep(partition);
		}
		T *pInsertion = body.InsertEmpty(partition, length);
		for (size_t i = 0; i < length; i++) {
			pInsertion[i] = static_cast<T>(positions[i]);
		}
		stepPartition += static_cast<T>(length);
	}

	void SetPartitionStartPosition(T partition, T pos) noexcept {
		ApplyStep(partition+1);
		if ((partition < 0) || (partition >= body.Length())) {
			return;
		}
		body.SetValueAt(partition, pos);
	}

	void InsertText(T partitionInsert, T delta) noexcept {
		// Point all the partitions after the insertion point further along in the buffer
		if (stepLength != 0) {
			if (partitionInsert >= stepPartition) {
				// Fill in up to the new insertion point
				ApplyStep(partitionInsert);
				stepLength += delta;
			} else if (partitionInsert >= (stepPartition - body.Length() / 10)) {
				// Close to step but before so move step back
				BackStep(partitionInsert);
				stepLength += delta;
			} else {
				ApplyStep(Partitions());
				stepPartition = partitionInsert;
				stepLength = delta;
			}
		} else {
			stepPartition = partitionInsert;
			stepLength = delta;
		}
	}

	void RemovePartition(T partition) {
		if (partition > stepPartition) {
			ApplyStep(partition);
			stepPartition--;
		} else {
			stepPartition--;
		}
		body.Delete(partition);
	}

	T PositionFromPartition(T partition) const noexcept {
		PLATFORM_ASSERT(partition >= 0);
		PLATFORM_ASSERT(partition < body.Length());
		const ptrdiff_t lengthBody = body.Length();
		if ((partition < 0) || (partition >= lengthBody)) {
			return 0;
		}
		T pos = body.ValueAt(partition);
		if (partition > stepPartition)
			pos += stepLength;
		return pos;
	}

	/// Return value in range [0 .. Partitions() - 1] even for arguments outside interval
	T PartitionFromPosition(T pos) const noexcept {
		if (body.Length() <= 1)
			return 0;
		if (pos >= (PositionFromPartition(Partitions())))
			return Partitions() - 1;
		T lower = 0;
		T upper = Partitions();
		do {
			const T middle = (upper + lower + 1) / 2; 	// Round high
			T posMiddle = body[middle];
			if (middle > stepPartition)
				posMiddle += stepLength;
			if (pos < posMiddle) {
				upper = middle - 1;
			} else {
				lower = middle;
			}
		} while (lower < upper);
		return lower;
	}

	void DeleteAll() {
		body.DeleteAll();
		stepPartition = 0;
		stepLength = 0;
		body.Insert(0, 0);	// This value stays 0 for ever
		body.Insert(1, 0);	// This is the end of the first partition and will be the start of the second
	}

	void Check() const {
#ifdef CHECK_CORRECTNESS
		if (Length() < 0) {
			throw std::runtime_error("Partitioning: Length can not be negative.");
		}
		if (Partitions() < 1) {
			throw std::runtime_error("Partitioning: Must always have 1 or more partitions.");
		}
		if (Length() == 0) {
			if ((PositionFromPartition(0) != 0) || (PositionFromPartition(1) != 0)) {
				throw std::runtime_error("Partitioning: Invalid empty partitioning.");
			}
		} else {
			// Positions should be a strictly ascending sequence
			for (T i = 0; i < Partitions(); i++) {
				const T pos = PositionFromPartition(i);
				const T posNext = PositionFromPartition(i+1);
				if (pos > posNext) {
					throw std::runtime_error("Partitioning: Negative partition.");
				} else if (pos == posNext) {
					throw std::runtime_error("Partitioning: Empty partition.");
				}
			}
		}
#endif
	}

};


}

#endif


================================================
FILE: Libraries/scintilla/src/PerLine.cxx
================================================
// Scintilla source code edit control
/** @file PerLine.cxx
 ** Manages data associated with each line of the document
 **/
// Copyright 1998-2009 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#include <cstddef>
#include <cstdint>
#include <cassert>
#include <cstring>

#include <stdexcept>
#include <string_view>
#include <vector>
#include <forward_list>
#include <optional>
#include <algorithm>
#include <memory>

#include "ScintillaTypes.h"

#include "Debugging.h"
#include "Geometry.h"
#include "Platform.h"

#include "Position.h"
#include "SplitVector.h"
#include "Partitioning.h"
#include "CellBuffer.h"
#include "PerLine.h"

using namespace Scintilla::Internal;

MarkerHandleSet::MarkerHandleSet() {
}

bool MarkerHandleSet::Empty() const noexcept {
	return mhList.empty();
}

int MarkerHandleSet::MarkValue() const noexcept {
	unsigned int m = 0;
	for (const MarkerHandleNumber &mhn : mhList) {
		m |= (1 << mhn.number);
	}
	return m;
}

bool MarkerHandleSet::Contains(int handle) const noexcept {
	for (const MarkerHandleNumber &mhn : mhList) {
		if (mhn.handle == handle) {
			return true;
		}
	}
	return false;
}

MarkerHandleNumber const *MarkerHandleSet::GetMarkerHandleNumber(int which) const noexcept {
	for (const MarkerHandleNumber &mhn : mhList) {
		if (which == 0)
			return &mhn;
		which--;
	}
	return nullptr;
}

bool MarkerHandleSet::InsertHandle(int handle, int markerNum) {
	mhList.push_front(MarkerHandleNumber(handle, markerNum));
	return true;
}

void MarkerHandleSet::RemoveHandle(int handle) {
	mhList.remove_if([handle](const MarkerHandleNumber &mhn) noexcept { return mhn.handle == handle; });
}

bool MarkerHandleSet::RemoveNumber(int markerNum, bool all) {
	bool performedDeletion = false;
	mhList.remove_if([&](const MarkerHandleNumber &mhn) noexcept {
		if ((all || !performedDeletion) && (mhn.number == markerNum)) {
			performedDeletion = true;
			return true;
		}
		return false;
	});
	return performedDeletion;
}

void MarkerHandleSet::CombineWith(MarkerHandleSet *other) noexcept {
	mhList.splice_after(mhList.before_begin(), other->mhList);
}

void LineMarkers::Init() {
	markers.DeleteAll();
}

void LineMarkers::InsertLine(Sci::Line line) {
	if (markers.Length()) {
		markers.Insert(line, nullptr);
	}
}

void LineMarkers::InsertLines(Sci::Line line, Sci::Line lines) {
	if (markers.Length()) {
		markers.InsertEmpty(line, lines);
	}
}

void LineMarkers::RemoveLine(Sci::Line line) {
	// Retain the markers from the deleted line by oring them into the previous line
	if (markers.Length()) {
		if (line > 0) {
			MergeMarkers(line - 1);
		}
		markers.Delete(line);
	}
}

Sci::Line LineMarkers::LineFromHandle(int markerHandle) const noexcept {
	for (Sci::Line line = 0; line < markers.Length(); line++) {
		if (markers[line] && markers[line]->Contains(markerHandle)) {
			return line;
		}
	}
	return -1;
}

int LineMarkers::HandleFromLine(Sci::Line line, int which) const noexcept {
	if (markers.Length() && (line >= 0) && (line < markers.Length()) && markers[line]) {
		MarkerHandleNumber const *pnmh = markers[line]->GetMarkerHandleNumber(which);
		return pnmh ? pnmh->handle : -1;
	}
	return -1;
}

int LineMarkers::NumberFromLine(Sci::Line line, int which) const noexcept {
	if (markers.Length() && (line >= 0) && (line < markers.Length()) && markers[line]) {
		MarkerHandleNumber const *pnmh = markers[line]->GetMarkerHandleNumber(which);
		return pnmh ? pnmh->number : -1;
	}
	return -1;
}

void LineMarkers::MergeMarkers(Sci::Line line) {
	if (markers[line + 1]) {
		if (!markers[line])
			markers[line] = std::make_unique<MarkerHandleSet>();
		markers[line]->CombineWith(markers[line + 1].get());
		markers[line + 1].reset();
	}
}

int LineMarkers::MarkValue(Sci::Line line) const noexcept {
	if (markers.Length() && (line >= 0) && (line < markers.Length()) && markers[line])
		return markers[line]->MarkValue();
	else
		return 0;
}

Sci::Line LineMarkers::MarkerNext(Sci::Line lineStart, int mask) const noexcept {
	if (lineStart < 0)
		lineStart = 0;
	const Sci::Line length = markers.Length();
	for (Sci::Line iLine = lineStart; iLine < length; iLine++) {
		const MarkerHandleSet *onLine = markers[iLine].get();
		if (onLine && ((onLine->MarkValue() & mask) != 0))
			return iLine;
	}
	return -1;
}

int LineMarkers::AddMark(Sci::Line line, int markerNum, Sci::Line lines) {
	handleCurrent++;
	if (!markers.Length()) {
		// No existing markers so allocate one element per line
		markers.InsertEmpty(0, lines);
	}
	if (line >= markers.Length()) {
		return -1;
	}
	if (!markers[line]) {
		// Need new structure to hold marker handle
		markers[line] = std::make_unique<MarkerHandleSet>();
	}
	markers[line]->InsertHandle(handleCurrent, markerNum);

	return handleCurrent;
}

bool LineMarkers::DeleteMark(Sci::Line line, int markerNum, bool all) {
	bool someChanges = false;
	if (markers.Length() && (line >= 0) && (line < markers.Length()) && markers[line]) {
		if (markerNum == -1) {
			someChanges = true;
			markers[line].reset();
		} else {
			someChanges = markers[line]->RemoveNumber(markerNum, all);
			if (markers[line]->Empty()) {
				markers[line].reset();
			}
		}
	}
	return someChanges;
}

void LineMarkers::DeleteMarkFromHandle(int markerHandle) {
	const Sci::Line line = LineFromHandle(markerHandle);
	if (line >= 0) {
		markers[line]->RemoveHandle(markerHandle);
		if (markers[line]->Empty()) {
			markers[line].reset();
		}
	}
}

void LineLevels::Init() {
	levels.DeleteAll();
}

void LineLevels::InsertLine(Sci::Line line) {
	if (levels.Length()) {
		const int level = (line < levels.Length()) ? levels[line] : static_cast<int>(Scintilla::FoldLevel::Base);
		levels.Insert(line, level);
	}
}

void LineLevels::InsertLines(Sci::Line line, Sci::Line lines) {
	if (levels.Length()) {
		const int level = (line < levels.Length()) ? levels[line] : static_cast<int>(Scintilla::FoldLevel::Base);
		levels.InsertValue(line, lines, level);
	}
}

void LineLevels::RemoveLine(Sci::Line line) {
	if (levels.Length()) {
		// Move up following lines but merge header flag from this line
		// to line before to avoid a temporary disappearance causing expansion.
		int firstHeader = levels[line] & static_cast<int>(Scintilla::FoldLevel::HeaderFlag);
		levels.Delete(line);
		if (line == levels.Length()-1) // Last line loses the header flag
			levels[line-1] &= ~static_cast<int>(Scintilla::FoldLevel::HeaderFlag);
		else if (line > 0)
			levels[line-1] |= firstHeader;
	}
}

void LineLevels::ExpandLevels(Sci::Line sizeNew) {
	levels.InsertValue(levels.Length(), sizeNew - levels.Length(), static_cast<int>(Scintilla::FoldLevel::Base));
}

void LineLevels::ClearLevels() {
	levels.DeleteAll();
}

int LineLevels::SetLevel(Sci::Line line, int level, Sci::Line lines) {
	int prev = level;
	if ((line >= 0) && (line < lines)) {
		if (!levels.Length()) {
			ExpandLevels(lines + 1);
		}
		prev = levels[line];
		levels[line] = level;
	}
	return prev;
}

int LineLevels::GetLevel(Sci::Line line) const noexcept {
	if ((line >= 0) && (line < levels.Length())) {
		return levels[line];
	}
	return static_cast<int>(Scintilla::FoldLevel::Base);
}

Scintilla::FoldLevel LineLevels::GetFoldLevel(Sci::Line line) const noexcept {
	if ((line >= 0) && (line < levels.Length())) {
		return static_cast<FoldLevel>(levels[line]);
	}
	return Scintilla::FoldLevel::Base;
}

Sci::Line LineLevels::GetFoldParent(Sci::Line line) const noexcept {
	const FoldLevel level = LevelNumberPart(GetFoldLevel(line));
	for (Sci::Line lineLook = line - 1; lineLook >= 0; lineLook--) {
		const FoldLevel levelTry = GetFoldLevel(lineLook);
		if (LevelIsHeader(levelTry) && LevelNumberPart(levelTry) < level) {
			return lineLook;
		}
	}
	return -1;
}

void LineState::Init() {
	lineStates.DeleteAll();
}

void LineState::InsertLine(Sci::Line line) {
	if (lineStates.Length()) {
		lineStates.EnsureLength(line);
		const int val = (line < lineStates.Length()) ? lineStates[line] : 0;
		lineStates.Insert(line, val);
	}
}

void LineState::InsertLines(Sci::Line line, Sci::Line lines) {
	if (lineStates.Length()) {
		lineStates.EnsureLength(line);
		const int val = (line < lineStates.Length()) ? lineStates[line] : 0;
		lineStates.InsertValue(line, lines, val);
	}
}

void LineState::RemoveLine(Sci::Line line) {
	if (lineStates.Length() > line) {
		lineStates.Delete(line);
	}
}

int LineState::SetLineState(Sci::Line line, int state, Sci::Line lines) {
	int stateOld = state;
	if ((line >= 0) && (line < lines)) {
		lineStates.EnsureLength(lines + 1);
		stateOld = lineStates[line];
		lineStates[line] = state;
	}
	return stateOld;
}

int LineState::GetLineState(Sci::Line line) {
	if (line < 0)
		return 0;
	lineStates.EnsureLength(line + 1);
	return lineStates[line];
}

Sci::Line LineState::GetMaxLineState() const noexcept {
	return lineStates.Length();
}

// Each allocated LineAnnotation is a char array which starts with an AnnotationHeader
// and then has text and optional styles.

struct AnnotationHeader {
	short style;	// Style IndividualStyles implies array of styles
	short lines;
	int length;
};

namespace {

constexpr int IndividualStyles = 0x100;

size_t NumberLines(std::string_view sv) {
	return std::count(sv.begin(), sv.end(), '\n') + 1;
}

std::unique_ptr<char[]>AllocateAnnotation(size_t length, int style) {
	const size_t len = sizeof(AnnotationHeader) + length + ((style == IndividualStyles) ? length : 0);
	return std::make_unique<char[]>(len);
}

}

bool LineAnnotation::Empty() const noexcept {
	return annotations.Length() == 0;
}

void LineAnnotation::Init() {
	ClearAll();
}

void LineAnnotation::InsertLine(Sci::Line line) {
	if (annotations.Length()) {
		annotations.EnsureLength(line);
		annotations.Insert(line, std::unique_ptr<char []>());
	}
}

void LineAnnotation::InsertLines(Sci::Line line, Sci::Line lines) {
	if (annotations.Length()) {
		annotations.EnsureLength(line);
		annotations.InsertEmpty(line, lines);
	}
}

void LineAnnotation::RemoveLine(Sci::Line line) {
	if (annotations.Length() && (line > 0) && (line <= annotations.Length())) {
		annotations[line-1].reset();
		annotations.Delete(line-1);
	}
}

bool LineAnnotation::MultipleStyles(Sci::Line line) const noexcept {
	if (annotations.Length() && (line >= 0) && (line < annotations.Length()) && annotations[line])
		return reinterpret_cast<AnnotationHeader *>(annotations[line].get())->style == IndividualStyles;
	else
		return false;
}

int LineAnnotation::Style(Sci::Line line) const noexcept {
	if (annotations.Length() && (line >= 0) && (line < annotations.Length()) && annotations[line])
		return reinterpret_cast<AnnotationHeader *>(annotations[line].get())->style;
	else
		return 0;
}

const char *LineAnnotation::Text(Sci::Line line) const noexcept {
	if (annotations.Length() && (line >= 0) && (line < annotations.Length()) && annotations[line])
		return annotations[line].get()+sizeof(AnnotationHeader);
	else
		return nullptr;
}

const unsigned char *LineAnnotation::Styles(Sci::Line line) const noexcept {
	if (annotations.Length() && (line >= 0) && (line < annotations.Length()) && annotations[line] && MultipleStyles(line))
		return reinterpret_cast<unsigned char *>(annotations[line].get() + sizeof(AnnotationHeader) + Length(line));
	else
		return nullptr;
}

void LineAnnotation::SetText(Sci::Line line, const char *text) {
	if (text && (line >= 0)) {
		annotations.EnsureLength(line+1);
		const int style = Style(line);
		annotations[line] = AllocateAnnotation(strlen(text), style);
		char *pa = annotations[line].get();
		assert(pa);
		AnnotationHeader *pah = reinterpret_cast<AnnotationHeader *>(pa);
		pah->style = static_cast<short>(style);
		pah->length = static_cast<int>(strlen(text));
		pah->lines = static_cast<short>(NumberLines(text));
		memcpy(pa+sizeof(AnnotationHeader), text, pah->length);
	} else {
		if (annotations.Length() && (line >= 0) && (line < annotations.Length()) && annotations[line]) {
			annotations[line].reset();
		}
	}
}

void LineAnnotation::ClearAll() {
	annotations.DeleteAll();
}

void LineAnnotation::SetStyle(Sci::Line line, int style) {
	annotations.EnsureLength(line+1);
	if (!annotations[line]) {
		annotations[line] = AllocateAnnotation(0, style);
	}
	reinterpret_cast<AnnotationHeader *>(annotations[line].get())->style = static_cast<short>(style);
}

void LineAnnotation::SetStyles(Sci::Line line, const unsigned char *styles) {
	if (line >= 0) {
		annotations.EnsureLength(line+1);
		if (!annotations[line]) {
			annotations[line] = AllocateAnnotation(0, IndividualStyles);
		} else {
			const AnnotationHeader *pahSource = reinterpret_cast<AnnotationHeader *>(annotations[line].get());
			if (pahSource->style != IndividualStyles) {
				std::unique_ptr<char[]>allocation = AllocateAnnotation(pahSource->length, IndividualStyles);
				AnnotationHeader *pahAlloc = reinterpret_cast<AnnotationHeader *>(allocation.get());
				pahAlloc->length = pahSource->length;
				pahAlloc->lines = pahSource->lines;
				memcpy(allocation.get() + sizeof(AnnotationHeader), annotations[line].get() + sizeof(AnnotationHeader), pahSource->length);
				annotations[line] = std::move(allocation);
			}
		}
		AnnotationHeader *pah = reinterpret_cast<AnnotationHeader *>(annotations[line].get());
		pah->style = IndividualStyles;
		memcpy(annotations[line].get() + sizeof(AnnotationHeader) + pah->length, styles, pah->length);
	}
}

int LineAnnotation::Length(Sci::Line line) const noexcept {
	if (annotations.Length() && (line >= 0) && (line < annotations.Length()) && annotations[line])
		return reinterpret_cast<AnnotationHeader *>(annotations[line].get())->length;
	else
		return 0;
}

int LineAnnotation::Lines(Sci::Line line) const noexcept {
	if (annotations.Length() && (line >= 0) && (line < annotations.Length()) && annotations[line])
		return reinterpret_cast<AnnotationHeader *>(annotations[line].get())->lines;
	else
		return 0;
}

void LineTabstops::Init() {
	tabstops.DeleteAll();
}

void LineTabstops::InsertLine(Sci::Line line) {
	if (tabstops.Length()) {
		tabstops.EnsureLength(line);
		tabstops.Insert(line, nullptr);
	}
}

void LineTabstops::InsertLines(Sci::Line line, Sci::Line lines) {
	if (tabstops.Length()) {
		tabstops.EnsureLength(line);
		tabstops.InsertEmpty(line, lines);
	}
}

void LineTabstops::RemoveLine(Sci::Line line) {
	if (tabstops.Length() > line) {
		tabstops[line].reset();
		tabstops.Delete(line);
	}
}

bool LineTabstops::ClearTabstops(Sci::Line line) noexcept {
	if (line < tabstops.Length()) {
		TabstopList *tl = tabstops[line].get();
		if (tl) {
			tl->clear();
			return true;
		}
	}
	return false;
}

bool LineTabstops::AddTabstop(Sci::Line line, int x) {
	tabstops.EnsureLength(line + 1);
	if (!tabstops[line]) {
		tabstops[line] = std::make_unique<TabstopList>();
	}

	TabstopList *tl = tabstops[line].get();
	if (tl) {
		// tabstop positions are kept in order - insert in the right place
		std::vector<int>::iterator it = std::lower_bound(tl->begin(), tl->end(), x);
		// don't insert duplicates
		if (it == tl->end() || *it != x) {
			tl->insert(it, x);
			return true;
		}
	}
	return false;
}

int LineTabstops::GetNextTabstop(Sci::Line line, int x) const noexcept {
	if (line < tabstops.Length()) {
		const TabstopList *tl = tabstops[line].get();
		if (tl) {
			for (const int i : *tl) {
				if (i > x) {
					return i;
				}
			}
		}
	}
	return 0;
}


================================================
FILE: Libraries/scintilla/src/PerLine.h
================================================
// Scintilla source code edit control
/** @file PerLine.h
 ** Manages data associated with each line of the document
 **/
// Copyright 1998-2009 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#ifndef PERLINE_H
#define PERLINE_H

namespace Scintilla::Internal {

/**
 * This holds the marker identifier and the marker type to display.
 * MarkerHandleNumbers are members of lists.
 */
struct MarkerHandleNumber {
	int handle;
	int number;
	MarkerHandleNumber(int handle_, int number_) noexcept : handle(handle_), number(number_) {}
};

/**
 * A marker handle set contains any number of MarkerHandleNumbers.
 */
class MarkerHandleSet {
	std::forward_list<MarkerHandleNumber> mhList;

public:
	MarkerHandleSet();
	bool Empty() const noexcept;
	int MarkValue() const noexcept;	///< Bit set of marker numbers.
	bool Contains(int handle) const noexcept;
	bool InsertHandle(int handle, int markerNum);
	void RemoveHandle(int handle);
	bool RemoveNumber(int markerNum, bool all);
	void CombineWith(MarkerHandleSet *other) noexcept;
	MarkerHandleNumber const *GetMarkerHandleNumber(int which) const noexcept;
};

class LineMarkers : public PerLine {
	SplitVector<std::unique_ptr<MarkerHandleSet>> markers;
	/// Handles are allocated sequentially and should never have to be reused as 32 bit ints are very big.
	int handleCurrent;
public:
	LineMarkers() : handleCurrent(0) {
	}
	void Init() override;
	void InsertLine(Sci::Line line) override;
	void InsertLines(Sci::Line line, Sci::Line lines) override;
	void RemoveLine(Sci::Line line) override;

	int MarkValue(Sci::Line line) const noexcept;
	Sci::Line MarkerNext(Sci::Line lineStart, int mask) const noexcept;
	int AddMark(Sci::Line line, int markerNum, Sci::Line lines);
	void MergeMarkers(Sci::Line line);
	bool DeleteMark(Sci::Line line, int markerNum, bool all);
	void DeleteMarkFromHandle(int markerHandle);
	Sci::Line LineFromHandle(int markerHandle) const noexcept;
	int HandleFromLine(Sci::Line line, int which) const noexcept;
	int NumberFromLine(Sci::Line line, int which) const noexcept;
};

class LineLevels : public PerLine {
	SplitVector<int> levels;
public:
	LineLevels() {
	}
	void Init() override;
	void InsertLine(Sci::Line line) override;
	void InsertLines(Sci::Line line, Sci::Line lines) override;
	void RemoveLine(Sci::Line line) override;

	void ExpandLevels(Sci::Line sizeNew=-1);
	void ClearLevels();
	int SetLevel(Sci::Line line, int level, Sci::Line lines);
	int GetLevel(Sci::Line line) const noexcept;
	FoldLevel GetFoldLevel(Sci::Line line) const noexcept;
	Sci::Line GetFoldParent(Sci::Line line) const noexcept;
};

class LineState : public PerLine {
	SplitVector<int> lineStates;
public:
	LineState() {
	}
	void Init() override;
	void InsertLine(Sci::Line line) override;
	void InsertLines(Sci::Line line, Sci::Line lines) override;
	void RemoveLine(Sci::Line line) override;

	int SetLineState(Sci::Line line, int state, Sci::Line lines);
	int GetLineState(Sci::Line line);
	Sci::Line GetMaxLineState() const noexcept;
};

class LineAnnotation : public PerLine {
	SplitVector<std::unique_ptr<char []>> annotations;
public:
	LineAnnotation() {
	}

	[[nodiscard]] bool Empty() const noexcept;
	void Init() override;
	void InsertLine(Sci::Line line) override;
	void InsertLines(Sci::Line line, Sci::Line lines) override;
	void RemoveLine(Sci::Line line) override;

	bool MultipleStyles(Sci::Line line) const noexcept;
	int Style(Sci::Line line) const noexcept;
	const char *Text(Sci::Line line) const noexcept;
	const unsigned char *Styles(Sci::Line line) const noexcept;
	void SetText(Sci::Line line, const char *text);
	void ClearAll();
	void SetStyle(Sci::Line line, int style);
	void SetStyles(Sci::Line line, const unsigned char *styles);
	int Length(Sci::Line line) const noexcept;
	int Lines(Sci::Line line) const noexcept;
};

typedef std::vector<int> TabstopList;

class LineTabstops : public PerLine {
	SplitVector<std::unique_ptr<TabstopList>> tabstops;
public:
	LineTabstops() {
	}
	void Init() override;
	void InsertLine(Sci::Line line) override;
	void InsertLines(Sci::Line line, Sci::Line lines) override;
	void RemoveLine(Sci::Line line) override;

	bool ClearTabstops(Sci::Line line) noexcept;
	bool AddTabstop(Sci::Line line, int x);
	int GetNextTabstop(Sci::Line line, int x) const noexcept;
};

}

#endif


================================================
FILE: Libraries/scintilla/src/Platform.h
================================================
// Scintilla source code edit control
/** @file Platform.h
 ** Interface to platform facilities. Also includes some basic utilities.
 ** Implemented in PlatGTK.cxx for GTK+/Linux, PlatWin.cxx for Windows, and PlatWX.cxx for wxWindows.
 **/
// Copyright 1998-2009 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#ifndef PLATFORM_H
#define PLATFORM_H

// PLAT_GTK = GTK+ on Linux or Win32
// PLAT_GTK_WIN32 is defined additionally when running PLAT_GTK under Win32
// PLAT_WIN = Win32 API on Win32 OS
// PLAT_WX is wxWindows on any supported platform
// PLAT_TK = Tcl/TK on Linux or Win32

#define PLAT_GTK 0
#define PLAT_GTK_WIN32 0
#define PLAT_GTK_MACOSX 0
#define PLAT_MACOSX 0
#define PLAT_WIN 0
#define PLAT_WX  0
#define PLAT_QT 0
#define PLAT_QT_QML 0
#define PLAT_FOX 0
#define PLAT_CURSES 0
#define PLAT_TK 0
#define PLAT_HAIKU 0

#if defined(FOX)
#undef PLAT_FOX
#define PLAT_FOX 1

#elif defined(__WX__)
#undef PLAT_WX
#define PLAT_WX  1

#elif defined(CURSES)
#undef PLAT_CURSES
#define PLAT_CURSES 1

#elif defined(__HAIKU__)
#undef PLAT_HAIKU
#define PLAT_HAIKU 1

#elif defined(SCINTILLA_QT)
#undef PLAT_QT
#define PLAT_QT 1

#elif defined(SCINTILLA_QT_QML)
#undef PLAT_QT_QML
#define PLAT_QT_QML 1

#elif defined(TK)
#undef PLAT_TK
#define PLAT_TK 1

#elif defined(GTK)
#undef PLAT_GTK
#define PLAT_GTK 1

#if defined(__WIN32__) || defined(_MSC_VER)
#undef PLAT_GTK_WIN32
#define PLAT_GTK_WIN32 1
#endif

#if defined(__APPLE__)
#undef PLAT_GTK_MACOSX
#define PLAT_GTK_MACOSX 1
#endif

#elif defined(__APPLE__)

#undef PLAT_MACOSX
#define PLAT_MACOSX 1

#else
#undef PLAT_WIN
#define PLAT_WIN 1

#endif

namespace Scintilla::Internal {

// Underlying the implementation of the platform classes are platform specific types.
// Sometimes these need to be passed around by client code so they are defined here

typedef void *SurfaceID;
typedef void *WindowID;
typedef void *MenuID;
typedef void *TickerID;
typedef void *Function;
typedef void *IdlerID;

/**
 * Font management.
 */

constexpr const char *localeNameDefault = "en-us";

struct FontParameters {
	const char *faceName;
	XYPOSITION size;
	Scintilla::FontWeight weight;
	bool italic;
	Scintilla::FontQuality extraFontFlag;
	Scintilla::Technology technology;
	Scintilla::CharacterSet characterSet;
	const char *localeName;
	Scintilla::FontStretch stretch;

	constexpr FontParameters(
		const char *faceName_,
		XYPOSITION size_=10,
		Scintilla::FontWeight weight_= Scintilla::FontWeight::Normal,
		bool italic_=false,
		Scintilla::FontQuality extraFontFlag_= Scintilla::FontQuality::QualityDefault,
		Scintilla::Technology technology_= Scintilla::Technology::Default,
		Scintilla::CharacterSet characterSet_= Scintilla::CharacterSet::Ansi,
		const char *localeName_=localeNameDefault,
		Scintilla::FontStretch stretch_=Scintilla::FontStretch::Normal) noexcept :

		faceName(faceName_),
		size(size_),
		weight(weight_),
		italic(italic_),
		extraFontFlag(extraFontFlag_),
		technology(technology_),
		characterSet(characterSet_),
		localeName(localeName_),
		stretch(stretch_)
	{
	}

};

class Font {
public:
	Font() noexcept = default;
	// Deleted so Font objects can not be copied
	Font(const Font &) = delete;
	Font(Font &&) = delete;
	Font &operator=(const Font &) = delete;
	Font &operator=(Font &&) = delete;
	virtual ~Font() noexcept = default;

	static std::shared_ptr<Font> Allocate(const FontParameters &fp);
};

class IScreenLine {
public:
	virtual std::string_view Text() const = 0;
	virtual size_t Length() const = 0;
	virtual size_t RepresentationCount() const = 0;
	virtual XYPOSITION Width() const = 0;
	virtual XYPOSITION Height() const = 0;
	virtual XYPOSITION TabWidth() const = 0;
	virtual XYPOSITION TabWidthMinimumPixels() const = 0;
	virtual const Font *FontOfPosition(size_t position) const = 0;
	virtual XYPOSITION RepresentationWidth(size_t position) const = 0;
	virtual XYPOSITION TabPositionAfter(XYPOSITION xPosition) const = 0;
};

class IScreenLineLayout {
public:
	virtual ~IScreenLineLayout() noexcept = default;
	virtual size_t PositionFromX(XYPOSITION xDistance, bool charPosition) = 0;
	virtual XYPOSITION XFromPosition(size_t caretPosition) = 0;
	virtual std::vector<Interval> FindRangeIntervals(size_t start, size_t end) = 0;
};

/**
 * Parameters for surfaces.
 */
struct SurfaceMode {
	int codePage = 0;
	bool bidiR2L = false;
	SurfaceMode() = default;
	explicit SurfaceMode(int codePage_, bool bidiR2L_) noexcept : codePage(codePage_), bidiR2L(bidiR2L_) {
	}
};

/**
 * A surface abstracts a place to draw.
 */
class Surface {
public:
	Surface() noexcept = default;
	Surface(const Surface &) = delete;
	Surface(Surface &&) = delete;
	Surface &operator=(const Surface &) = delete;
	Surface &operator=(Surface &&) = delete;
	virtual ~Surface() noexcept = default;
	static std::unique_ptr<Surface> Allocate(Scintilla::Technology technology);

	virtual void Init(WindowID wid)=0;	// For measuring text
	virtual void Init(SurfaceID sid, WindowID wid)=0;	// For drawing
	virtual std::unique_ptr<Surface> AllocatePixMap(int width, int height)=0;

	virtual void SetMode(SurfaceMode mode)=0;

	enum class Ends {
		semiCircles = 0x0,
		leftFlat = 0x1,
		leftAngle = 0x2,
		rightFlat = 0x10,
		rightAngle = 0x20,
	};

	virtual void Release() noexcept=0;
	virtual int SupportsFeature(Scintilla::Supports feature) noexcept=0;
	virtual bool Initialised()=0;
	virtual int LogPixelsY()=0;
	virtual int PixelDivisions()=0;
	virtual int DeviceHeightFont(int points)=0;
	virtual void LineDraw(Point start, Point end, Stroke stroke)=0;
	virtual void PolyLine(const Point *pts, size_t npts, Stroke stroke)=0;
	virtual void Polygon(const Point *pts, size_t npts, FillStroke fillStroke)=0;
	virtual void RectangleDraw(PRectangle rc, FillStroke fillStroke)=0;
	virtual void RectangleFrame(PRectangle rc, Stroke stroke)=0;
	virtual void FillRectangle(PRectangle rc, Fill fill)=0;
	virtual void FillRectangleAligned(PRectangle rc, Fill fill)=0;
	virtual void FillRectangle(PRectangle rc, Surface &surfacePattern)=0;
	virtual void RoundedRectangle(PRectangle rc, FillStroke fillStroke)=0;
	virtual void AlphaRectangle(PRectangle rc, XYPOSITION cornerSize, FillStroke fillStroke)=0;
	enum class GradientOptions { leftToRight, topToBottom };
	virtual void GradientRectangle(PRectangle rc, const std::vector<ColourStop> &stops, GradientOptions options)=0;
	virtual void DrawRGBAImage(PRectangle rc, int width, int height, const unsigned char *pixelsImage) = 0;
	virtual void Ellipse(PRectangle rc, FillStroke fillStroke)=0;
	virtual void Stadium(PRectangle rc, FillStroke fillStroke, Ends ends)=0;
	virtual void Copy(PRectangle rc, Point from, Surface &surfaceSource)=0;

	virtual std::unique_ptr<IScreenLineLayout> Layout(const IScreenLine *screenLine) = 0;

	virtual void DrawTextNoClip(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text, ColourRGBA fore, ColourRGBA back) = 0;
	virtual void DrawTextClipped(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text, ColourRGBA fore, ColourRGBA back) = 0;
	virtual void DrawTextTransparent(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text, ColourRGBA fore) = 0;
	virtual void MeasureWidths(const Font *font_, std::string_view text, XYPOSITION *positions) = 0;
	virtual XYPOSITION WidthText(const Font *font_, std::string_view text) = 0;

	virtual void DrawTextNoClipUTF8(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text, ColourRGBA fore, ColourRGBA back) = 0;
	virtual void DrawTextClippedUTF8(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text, ColourRGBA fore, ColourRGBA back) = 0;
	virtual void DrawTextTransparentUTF8(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text, ColourRGBA fore) = 0;
	virtual void MeasureWidthsUTF8(const Font *font_, std::string_view text, XYPOSITION *positions) = 0;
	virtual XYPOSITION WidthTextUTF8(const Font *font_, std::string_view text) = 0;

	virtual XYPOSITION Ascent(const Font *font_)=0;
	virtual XYPOSITION Descent(const Font *font_)=0;
	virtual XYPOSITION InternalLeading(const Font *font_)=0;
	virtual XYPOSITION Height(const Font *font_)=0;
	virtual XYPOSITION AverageCharWidth(const Font *font_)=0;

	virtual void SetClip(PRectangle rc)=0;
	virtual void PopClip()=0;
	virtual void FlushCachedState()=0;
	virtual void FlushDrawing()=0;

	virtual void DrawLineDots(PRectangle rc, ColourRGBA color)=0; //Au
	virtual void* get_hdc() = 0; //Au
};

/**
 * Class to hide the details of window manipulation.
 * Does not own the window which will normally have a longer life than this object.
 */
class Window {
protected:
	WindowID wid;
public:
	Window() noexcept : wid(nullptr), cursorLast(Cursor::invalid) {
	}
	Window(const Window &source) = delete;
	Window(Window &&) = delete;
	Window &operator=(WindowID wid_) noexcept {
		wid = wid_;
		cursorLast = Cursor::invalid;
		return *this;
	}
	Window &operator=(const Window &) = delete;
	Window &operator=(Window &&) = delete;
	virtual ~Window() noexcept;
	WindowID GetID() const noexcept { return wid; }
	bool Created() const noexcept { return wid != nullptr; }
	void Destroy() noexcept;
	PRectangle GetPosition() const;
	void SetPosition(PRectangle rc);
	void SetPositionRelative(PRectangle rc, const Window *relativeTo);
	PRectangle GetClientPosition() const;
	void Show(bool show=true);
	void InvalidateAll();
	void InvalidateRectangle(PRectangle rc);
	enum class Cursor { invalid, text, arrow, up, wait, horizontal, vertical, reverseArrow, hand };
	void SetCursor(Cursor curs);
	PRectangle GetMonitorRect(Point pt);
private:
	Cursor cursorLast;
};

/**
 * Listbox management.
 */

// ScintillaBase implements IListBoxDelegate to receive ListBoxEvents from a ListBox

struct ListBoxEvent {
	enum class EventType { selectionChange, doubleClick } event;
	ListBoxEvent(EventType event_) noexcept : event(event_) {
	}
};

class IListBoxDelegate {
public:
	virtual void ListNotify(ListBoxEvent *plbe)=0;
};

struct ListOptions {
	std::optional<ColourRGBA> fore;
	std::optional<ColourRGBA> back;
	std::optional<ColourRGBA> foreSelected;
	std::optional<ColourRGBA> backSelected;
	AutoCompleteOption options=AutoCompleteOption::Normal;
	float imageScale=1.0f;
};

class ListBox : public Window {
public:
	ListBox() noexcept;
	~ListBox() noexcept override;
	static std::unique_ptr<ListBox> Allocate();

	virtual void SetFont(const Font *font)=0;
	virtual void Create(Window &parent, int ctrlID, Point location, int lineHeight_, bool unicodeMode_, Scintilla::Technology technology_)=0;
	virtual void SetAverageCharWidth(int width)=0;
	virtual void SetVisibleRows(int rows)=0;
	virtual int GetVisibleRows() const=0;
	virtual PRectangle GetDesiredRect()=0;
	virtual int CaretFromEdge()=0;
	virtual void Clear() noexcept=0;
	virtual void Append(char *s, int type = -1)=0;
	virtual int Length()=0;
	virtual void Select(int n)=0;
	virtual int GetSelection()=0;
	virtual int Find(const char *prefix)=0;
	virtual std::string GetValue(int n)=0;
	virtual void RegisterImage(int type, const char *xpm_data)=0;
	virtual void RegisterRGBAImage(int type, int width, int height, const unsigned char *pixelsImage) = 0;
	virtual void ClearRegisteredImages()=0;
	virtual void SetDelegate(IListBoxDelegate *lbDelegate)=0;
	virtual void SetList(const char* list, char separator, char typesep)=0;
	virtual void SetOptions(ListOptions options_)=0;
};

/**
 * Menu management.
 */
class Menu {
	MenuID mid;
public:
	Menu() noexcept;
	MenuID GetID() const noexcept { return mid; }
	void CreatePopUp();
	void Destroy() noexcept;
	void Show(Point pt, const Window &w);
};

/**
 * Platform namespace used to retrieve system wide parameters such as double click speed
 * and chrome colour.
 */
namespace Platform {

ColourRGBA Chrome();
ColourRGBA ChromeHighlight();
const char *DefaultFont();
int DefaultFontSize();
unsigned int DoubleClickTime();
constexpr long LongFromTwoShorts(short a,short b) noexcept {
	return (a) | ((b) << 16);
}

}

}

#endif


================================================
FILE: Libraries/scintilla/src/Position.h
================================================
// Scintilla source code edit control
/** @file Position.h
 ** Defines global type name Position in the Sci internal namespace.
 **/
// Copyright 2015 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#ifndef POSITION_H
#define POSITION_H

/**
 * A Position is a position within a document between two characters or at the beginning or end.
 * Sometimes used as a character index where it identifies the character after the position.
 * A Line is a document or screen line.
 */

namespace Sci {

typedef ptrdiff_t Position;
typedef ptrdiff_t Line;

inline constexpr Position invalidPosition = -1;

}

#endif


================================================
FILE: Libraries/scintilla/src/PositionCache.cxx
================================================
// Scintilla source code edit control
/** @file PositionCache.cxx
 ** Classes for caching layout information.
 **/
// Copyright 1998-2007 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#include <cstddef>
#include <cstdlib>
#include <cstdint>
#include <cstring>
#include <cmath>

#include <stdexcept>
#include <string>
#include <string_view>
#include <vector>
#include <map>
#include <set>
#include <optional>
#include <algorithm>
#include <iterator>
#include <memory>
#include <mutex>

#include "ScintillaTypes.h"
#include "ScintillaMessages.h"
#include "ILoader.h"
#include "ILexer.h"

#include "Debugging.h"
#include "Geometry.h"
#include "Platform.h"

#include "CharacterType.h"
#include "CharacterCategoryMap.h"
#include "Position.h"
#include "UniqueString.h"
#include "SplitVector.h"
#include "Partitioning.h"
#include "RunStyles.h"
#include "ContractionState.h"
#include "CellBuffer.h"
#include "KeyMap.h"
#include "Indicator.h"
#include "LineMarker.h"
#include "Style.h"
#include "ViewStyle.h"
#include "CharClassify.h"
#include "Decoration.h"
#include "CaseFolder.h"
#include "Document.h"
#include "UniConversion.h"
#include "DBCS.h"
#include "Selection.h"
#include "PositionCache.h"

using namespace Scintilla;
using namespace Scintilla::Internal;

void BidiData::Resize(size_t maxLineLength_) {
	stylesFonts.resize(maxLineLength_ + 1);
	widthReprs.resize(maxLineLength_ + 1);
}

LineLayout::LineLayout(Sci::Line lineNumber_, int maxLineLength_) :
	lenLineStarts(0),
	lineNumber(lineNumber_),
	maxLineLength(-1),
	numCharsInLine(0),
	numCharsBeforeEOL(0),
	validity(ValidLevel::invalid),
	xHighlightGuide(0),
	highlightColumn(false),
	containsCaret(false),
	edgeColumn(0),
	bracePreviousStyles{},
	widthLine(wrapWidthInfinite),
	lines(1),
	wrapIndent(0) {
	Resize(maxLineLength_);
}

void LineLayout::Resize(int maxLineLength_) {
	if (maxLineLength_ > maxLineLength) {
		const size_t lineAllocation = maxLineLength_ + 1;
		chars = std::make_unique<char[]>(lineAllocation);
		styles = std::make_unique<unsigned char []>(lineAllocation);
		// Extra position allocated as sometimes the Windows
		// GetTextExtentExPoint API writes an extra element.
		positions = std::make_unique<XYPOSITION []>(lineAllocation + 1);
		lineStarts.reset();
		bidiData.reset();
		lenLineStarts = 0;
		maxLineLength = maxLineLength_;
	}
}

void LineLayout::ReSet(Sci::Line lineNumber_, Sci::Position maxLineLength_) {
	lineNumber = lineNumber_;
	Resize(static_cast<int>(maxLineLength_));
	lines = 0;
	Invalidate(ValidLevel::invalid);
}

void LineLayout::EnsureBidiData() {
	if (!bidiData) {
		bidiData = std::make_unique<BidiData>();
		bidiData->Resize(maxLineLength);
	}
}

void LineLayout::ClearPositions() {
	std::fill(&positions[0], &positions[maxLineLength + 2], 0.0f);
}

void LineLayout::Invalidate(ValidLevel validity_) noexcept {
	if (validity > validity_)
		validity = validity_;
}

Sci::Line LineLayout::LineNumber() const noexcept {
	return lineNumber;
}

bool LineLayout::CanHold(Sci::Line lineDoc, int lineLength_) const noexcept {
	return (lineNumber == lineDoc) && (lineLength_ <= maxLineLength);
}

int LineLayout::LineStart(int line) const noexcept {
	if (line <= 0) {
		return 0;
	} else if ((line >= lines) || !lineStarts) {
		return numCharsInLine;
	} else {
		return lineStarts[line];
	}
}

int LineLayout::LineLength(int line) const noexcept {
	if (!lineStarts) {
		return numCharsInLine;
	} else if (line >= lines - 1) {
		return numCharsInLine - lineStarts[line];
	} else {
		return lineStarts[line + 1] - lineStarts[line];
	}
}

int LineLayout::LineLastVisible(int line, Scope scope) const noexcept {
	if (line < 0) {
		return 0;
	} else if ((line >= lines-1) || !lineStarts) {
		return scope == Scope::visibleOnly ? numCharsBeforeEOL : numCharsInLine;
	} else {
		return lineStarts[line+1];
	}
}

Range LineLayout::SubLineRange(int subLine, Scope scope) const noexcept {
	return Range(LineStart(subLine), LineLastVisible(subLine, scope));
}

bool LineLayout::InLine(int offset, int line) const noexcept {
	return ((offset >= LineStart(line)) && (offset < LineStart(line + 1))) ||
		((offset == numCharsInLine) && (line == (lines-1)));
}

int LineLayout::SubLineFromPosition(int posInLine, PointEnd pe) const noexcept {
	if (!lineStarts || (posInLine > maxLineLength)) {
		return lines - 1;
	}

	for (int line = 0; line < lines; line++) {
		if (FlagSet(pe, PointEnd::subLineEnd)) {
			// Return subline not start of next
			if (lineStarts[line + 1] <= posInLine + 1)
				return line;
		} else {
			if (lineStarts[line + 1] <= posInLine)
				return line;
		}
	}

	return lines - 1;
}

void LineLayout::AddLineStart(Sci::Position start) {
	lines++;
	if (lines >= lenLineStarts) {
		const int newMaxLines = lines * 2 + 4;
		std::unique_ptr<int[]> newLineStarts = std::make_unique<int[]>(newMaxLines);
		if (lenLineStarts) {
			std::copy(lineStarts.get(), lineStarts.get() + lenLineStarts, newLineStarts.get());
		}
		lineStarts = std::move(newLineStarts);
		lenLineStarts = newMaxLines;
	}
	lineStarts[lines] = static_cast<int>(start);
}

void LineLayout::SetBracesHighlight(Range rangeLine, const Sci::Position braces[],
                                    char bracesMatchStyle, int xHighlight, bool ignoreStyle) {
	if (!ignoreStyle && rangeLine.ContainsCharacter(braces[0])) {
		const Sci::Position braceOffset = braces[0] - rangeLine.start;
		if (braceOffset < numCharsInLine) {
			bracePreviousStyles[0] = styles[braceOffset];
			styles[braceOffset] = bracesMatchStyle;
		}
	}
	if (!ignoreStyle && rangeLine.ContainsCharacter(braces[1])) {
		const Sci::Position braceOffset = braces[1] - rangeLine.start;
		if (braceOffset < numCharsInLine) {
			bracePreviousStyles[1] = styles[braceOffset];
			styles[braceOffset] = bracesMatchStyle;
		}
	}
	if ((braces[0] >= rangeLine.start && braces[1] <= rangeLine.end) ||
	        (braces[1] >= rangeLine.start && braces[0] <= rangeLine.end)) {
		xHighlightGuide = xHighlight;
	}
}

void LineLayout::RestoreBracesHighlight(Range rangeLine, const Sci::Position braces[], bool ignoreStyle) {
	if (!ignoreStyle && rangeLine.ContainsCharacter(braces[0])) {
		const Sci::Position braceOffset = braces[0] - rangeLine.start;
		if (braceOffset < numCharsInLine) {
			styles[braceOffset] = bracePreviousStyles[0];
		}
	}
	if (!ignoreStyle && rangeLine.ContainsCharacter(braces[1])) {
		const Sci::Position braceOffset = braces[1] - rangeLine.start;
		if (braceOffset < numCharsInLine) {
			styles[braceOffset] = bracePreviousStyles[1];
		}
	}
	xHighlightGuide = 0;
}

int LineLayout::FindBefore(XYPOSITION x, Range range) const noexcept {
	Sci::Position lower = range.start;
	Sci::Position upper = range.end;
	do {
		const Sci::Position middle = (upper + lower + 1) / 2; 	// Round high
		const XYPOSITION posMiddle = positions[middle];
		if (x < posMiddle) {
			upper = middle - 1;
		} else {
			lower = middle;
		}
	} while (lower < upper);
	return static_cast<int>(lower);
}


int LineLayout::FindPositionFromX(XYPOSITION x, Range range, bool charPosition) const noexcept {
	int pos = FindBefore(x, range);
	while (pos < range.end) {
		if (charPosition) {
			if (x < (positions[pos + 1])) {
				return pos;
			}
		} else {
			if (x < ((positions[pos] + positions[pos + 1]) / 2)) {
				return pos;
			}
		}
		pos++;
	}
	return static_cast<int>(range.end);
}

Point LineLayout::PointFromPosition(int posInLine, int lineHeight, PointEnd pe) const noexcept {
	Point pt;
	// In case of very long line put x at arbitrary large position
	if (posInLine > maxLineLength) {
		pt.x = positions[maxLineLength] - positions[LineStart(lines)];
	}

	for (int subLine = 0; subLine < lines; subLine++) {
		const Range rangeSubLine = SubLineRange(subLine, Scope::visibleOnly);
		if (posInLine >= rangeSubLine.start) {
			pt.y = static_cast<XYPOSITION>(subLine*lineHeight);
			if (posInLine <= rangeSubLine.end) {
				pt.x = positions[posInLine] - positions[rangeSubLine.start];
				if (rangeSubLine.start != 0)	// Wrapped lines may be indented
					pt.x += wrapIndent;
				if (FlagSet(pe, PointEnd::subLineEnd))	// Return end of first subline not start of next
					break;
			} else if (FlagSet(pe, PointEnd::lineEnd) && (subLine == (lines-1))) {
				pt.x = positions[numCharsInLine] - positions[rangeSubLine.start];
				if (rangeSubLine.start != 0)	// Wrapped lines may be indented
					pt.x += wrapIndent;
			}
		} else {
			break;
		}
	}
	return pt;
}

XYPOSITION LineLayout::XInLine(Sci::Position index) const noexcept {
	// For positions inside line return value from positions
	// For positions after line return last position + 1.0
	if (index <= numCharsInLine) {
		return positions[index];
	}
	return positions[numCharsInLine] + 1.0;
}

Interval LineLayout::Span(int start, int end) const noexcept {
	return { positions[start], positions[end] };
}

Interval LineLayout::SpanByte(int index) const noexcept {
	return Span(index, index+1);
}

int LineLayout::EndLineStyle() const noexcept {
	return styles[numCharsBeforeEOL > 0 ? numCharsBeforeEOL-1 : 0];
}

void LineLayout::WrapLine(const Document *pdoc, Sci::Position posLineStart, Wrap wrapState, XYPOSITION wrapWidth) {
	// Document wants document positions but simpler to work in line positions
	// so take care of adding and subtracting line start in a lambda.
	auto CharacterBoundary = [=](Sci::Position i, int moveDir) noexcept -> Sci::Position {
		return pdoc->NextPosition(i + posLineStart, moveDir) - posLineStart;
	};
	lines = 0;
	// Calculate line start positions based upon width.
	Sci::Position lastLineStart = 0;
	XYPOSITION startOffset = wrapWidth;
	Sci::Position p = 0;
	while (p < numCharsInLine) {
		while (p < numCharsInLine && positions[p + 1] < startOffset) {
			p++;
		}
		if (p < numCharsInLine) {
			// backtrack to find lastGoodBreak
			Sci::Position lastGoodBreak = p;
			// Try moving to start of last character
			if (p > 0) {
				lastGoodBreak = pdoc->MovePositionOutsideChar(p + posLineStart, -1) - posLineStart;
			}
			bool foundBreak = false;
			if (wrapState != Wrap::Char) {
				Sci::Position pos = lastGoodBreak;
				while (pos > lastLineStart) {
					// style boundary and space
					if (wrapState != Wrap::WhiteSpace && (styles[pos - 1] != styles[pos])) {
						break;
					}
					if (IsBreakSpace(chars[pos - 1]) && !IsBreakSpace(chars[pos])) {
						break;
					}
					pos = CharacterBoundary(pos, -1);
				}
				if (pos > lastLineStart) {
					lastGoodBreak = pos;
					foundBreak = true;
				}
			}
			if (!foundBreak) {
				if (CpUtf8 == pdoc->dbcsCodePage) {
					// Go back before a base character, commonly a letter as modifiers are after the letter they modify
					const Sci::Position afterWrap = CharacterBoundary(lastGoodBreak, 1);
					std::string_view svWithoutLast(&chars[lastLineStart], afterWrap - lastLineStart);
					if (DiscardLastCombinedCharacter(svWithoutLast) && !svWithoutLast.empty()) {
						lastGoodBreak = lastLineStart + static_cast<Sci::Position>(svWithoutLast.length());
					}
				}
				if (lastGoodBreak == lastLineStart) {
					// Ensure at least one character on line.
					lastGoodBreak = CharacterBoundary(lastGoodBreak, 1);
				}
			}
			AddLineStart(lastGoodBreak);
			lastLineStart = lastGoodBreak;
			startOffset = positions[lastLineStart];
			// take into account the space for start wrap mark and indent
			startOffset += wrapWidth - wrapIndent;
			p = lastLineStart + 1;
		}
	}
	lines++;
}

ScreenLine::ScreenLine(
	const LineLayout *ll_,
	int subLine,
	const ViewStyle &vs,
	XYPOSITION width_,
	int tabWidthMinimumPixels_) :
	ll(ll_),
	start(ll->LineStart(subLine)),
	len(ll->LineLength(subLine)),
	width(width_),
	height(static_cast<float>(vs.lineHeight)),
	ctrlCharPadding(vs.ctrlCharPadding),
	tabWidth(vs.tabWidth),
	tabWidthMinimumPixels(tabWidthMinimumPixels_) {
}

ScreenLine::~ScreenLine() = default;

std::string_view ScreenLine::Text() const {
	return std::string_view(&ll->chars[start], len);
}

size_t ScreenLine::Length() const {
	return len;
}

size_t ScreenLine::RepresentationCount() const {
	return std::count_if(&ll->bidiData->widthReprs[start],
		&ll->bidiData->widthReprs[start + len],
		[](XYPOSITION w) noexcept { return w > 0.0f; });
}

XYPOSITION ScreenLine::Width() const {
	return width;
}

XYPOSITION ScreenLine::Height() const {
	return height;
}

XYPOSITION ScreenLine::TabWidth() const {
	return tabWidth;
}

XYPOSITION ScreenLine::TabWidthMinimumPixels() const {
	return static_cast<XYPOSITION>(tabWidthMinimumPixels);
}

const Font *ScreenLine::FontOfPosition(size_t position) const {
	return ll->bidiData->stylesFonts[start + position].get();
}

XYPOSITION ScreenLine::RepresentationWidth(size_t position) const {
	return ll->bidiData->widthReprs[start + position];
}

XYPOSITION ScreenLine::TabPositionAfter(XYPOSITION xPosition) const {
	return (std::floor((xPosition + TabWidthMinimumPixels()) / TabWidth()) + 1) * TabWidth();
}

bool SignificantLines::LineMayCache(Sci::Line line) const noexcept {
	switch (level) {
	case LineCache::None:
		return false;
	case LineCache::Caret:
		return line == lineCaret;
	case LineCache::Page:
		return (std::abs(line - lineCaret) < linesOnScreen) ||
			((line >= lineTop) && (line <= (lineTop + linesOnScreen)));
	case LineCache::Document:
	default:
		return true;
	}
}

LineLayoutCache::LineLayoutCache() :
	level(LineCache::None),
	maxValidity(LineLayout::ValidLevel::invalid), styleClock(-1) {
}

LineLayoutCache::~LineLayoutCache() = default;

namespace {

constexpr size_t AlignUp(size_t value, size_t alignment) noexcept {
	return ((value - 1) / alignment + 1) * alignment;
}

constexpr size_t alignmentLLC = 20;

constexpr bool GraphicASCII(char ch) noexcept {
	return ch >= ' ' && ch <= '~';
}

bool AllGraphicASCII(std::string_view text) {
	return std::all_of(text.cbegin(), text.cend(), GraphicASCII);
}

}


size_t LineLayoutCache::EntryForLine(Sci::Line line) const noexcept {
	switch (level) {
	case LineCache::None:
	case LineCache::Caret:
		return 0;
	case LineCache::Page:
		return 1 + (line % (cache.size() - 1));
	case LineCache::Document:
		return line;
	}
	return 0;
}

void LineLayoutCache::AllocateForLevel(Sci::Line linesOnScreen, Sci::Line linesInDoc) {
	size_t lengthForLevel = 0;
	if (level == LineCache::Caret) {
		lengthForLevel = 1;
	} else if (level == LineCache::Page) {
		lengthForLevel = AlignUp(linesOnScreen + 1, alignmentLLC);
	} else if (level == LineCache::Document) {
		lengthForLevel = AlignUp(linesInDoc, alignmentLLC);
	}

	if (lengthForLevel != cache.size()) {
		maxValidity = LineLayout::ValidLevel::lines;
		cache.resize(lengthForLevel);
		// Cache::none -> no entries
		// Cache::caret -> 1 entry can take any line
		// Cache::document -> entry per line so each line in correct entry after resize
		if (level == LineCache::Page) {
			// Cache::page -> locates lines in particular entries which may be incorrect after
			// a resize so move them to correct entries.
			for (size_t i = 1; i < cache.size();) {
				size_t increment = 1;
				if (cache[i]) {
					const size_t posForLine = EntryForLine(cache[i]->LineNumber());
					if (posForLine != i) {
						if (cache[posForLine]) {
							if (EntryForLine(cache[posForLine]->LineNumber()) == posForLine) {
								// [posForLine] already holds line that is in correct place
								cache[i].reset();	// This line has nowhere to go so reset it.
							} else {
								std::swap(cache[i], cache[posForLine]);
								increment = 0;
								// Don't increment as newly swapped in value may have to move
							}
						} else {
							cache[posForLine] = std::move(cache[i]);
						}
					}
				}
				i += increment;
			}

#ifdef CHECK_LLC
			for (size_t i = 1; i < cache.size(); i++) {
				if (cache[i]) {
					PLATFORM_ASSERT(EntryForLine(cache[i]->LineNumber()) == i);
				}
			}
#endif
		}
	}
	PLATFORM_ASSERT(cache.size() == lengthForLevel);
}

void LineLayoutCache::Deallocate() noexcept {
	maxValidity = LineLayout::ValidLevel::invalid;
	cache.clear();
}

void LineLayoutCache::Invalidate(LineLayout::ValidLevel validity_) noexcept {
	if (maxValidity > validity_) {
		maxValidity = validity_;
		for (const std::shared_ptr<LineLayout> &ll : cache) {
			if (ll) {
				ll->Invalidate(validity_);
			}
		}
	}
}

void LineLayoutCache::SetLevel(LineCache level_) noexcept {
	if (level != level_) {
		level = level_;
		maxValidity = LineLayout::ValidLevel::invalid;
		cache.clear();
	}
}

std::shared_ptr<LineLayout> LineLayoutCache::Retrieve(Sci::Line lineNumber, Sci::Line lineCaret, int maxChars, int styleClock_,
                                      Sci::Line linesOnScreen, Sci::Line linesInDoc) {
	AllocateForLevel(linesOnScreen, linesInDoc);
	if (styleClock != styleClock_) {
		Invalidate(LineLayout::ValidLevel::checkTextAndStyle);
		styleClock = styleClock_;
	}
	maxValidity = LineLayout::ValidLevel::lines;
	size_t pos = 0;
	if (level == LineCache::Page) {
		// If first entry is this line then just reuse it.
		if (!(cache[0] && (cache[0]->LineNumber() == lineNumber))) {
			const size_t posForLine = EntryForLine(lineNumber);
			if (lineNumber == lineCaret) {
				// Use position 0 for caret line.
				if (cache[0]) {
					// Another line is currently in [0] so move it out to its normal position.
					// Since it was recently the caret line its likely to be needed soon.
					const size_t posNewForEntry0 = EntryForLine(cache[0]->LineNumber());
					if (posForLine == posNewForEntry0) {
						std::swap(cache[0], cache[posNewForEntry0]);
					} else {
						cache[posNewForEntry0] = std::move(cache[0]);
					}
				}
				if (cache[posForLine] && (cache[posForLine]->LineNumber() == lineNumber)) {
					// Caret line is currently somewhere else so move it to [0].
					cache[0] = std::move(cache[posForLine]);
				}
			} else {
				pos = posForLine;
			}
		}
	} else if (level == LineCache::Document) {
		pos = lineNumber;
	}

	if (pos < cache.size()) {
		if (cache[pos] && !cache[pos]->CanHold(lineNumber, maxChars)) {
			cache[pos].reset();
		}
		if (!cache[pos]) {
			cache[pos] = std::make_shared<LineLayout>(lineNumber, maxChars);
		}
#ifdef CHECK_LLC
		// Expensive check that there is only one entry for any line number
		std::vector<bool> linesInCache(linesInDoc);
		for (const auto &entry : cache) {
			if (entry) {
				PLATFORM_ASSERT(!linesInCache[entry->LineNumber()]);
				linesInCache[entry->LineNumber()] = true;
			}
		}
#endif
		return cache[pos];
	}

	// Only reach here for level == Cache::none
	return std::make_shared<LineLayout>(lineNumber, maxChars);
}

namespace {

// Simply pack the (maximum 4) character bytes into an int
constexpr unsigned int KeyFromString(std::string_view charBytes) noexcept {
	PLATFORM_ASSERT(charBytes.length() <= 4);
	constexpr int byteMultiplier = 0x100;
	unsigned int k=0;
	for (const unsigned char uc : charBytes) {
		k = k * byteMultiplier + uc;
	}
	return k;
}

constexpr unsigned int representationKeyCrLf = KeyFromString("\r\n");

const char *const repsC0[] = {
	"NUL", "SOH", "STX", "ETX", "EOT", "ENQ", "ACK", "BEL",
	"BS", "HT", "LF", "VT", "FF", "CR", "SO", "SI",
	"DLE", "DC1", "DC2", "DC3", "DC4", "NAK", "SYN", "ETB",
	"CAN", "EM", "SUB", "ESC", "FS", "GS", "RS", "US"
};

const char *const repsC1[] = {
	"PAD", "HOP", "BPH", "NBH", "IND", "NEL", "SSA", "ESA",
	"HTS", "HTJ", "VTS", "PLD", "PLU", "RI", "SS2", "SS3",
	"DCS", "PU1", "PU2", "STS", "CCH", "MW", "SPA", "EPA",
	"SOS", "SGCI", "SCI", "CSI", "ST", "OSC", "PM", "APC"
};

}

namespace Scintilla::Internal {

const char *ControlCharacterString(unsigned char ch) noexcept {
	if (ch < std::size(repsC0)) {
		return repsC0[ch];
	}
	return "BAD";
}


void Hexits(char *hexits, int ch) noexcept {
	constexpr int hexDivisor = 0x10;
	hexits[0] = 'x';
	hexits[1] = "0123456789ABCDEF"[ch / hexDivisor];
	hexits[2] = "0123456789ABCDEF"[ch % hexDivisor];
	hexits[3] = 0;
}

}

void SpecialRepresentations::SetRepresentation(std::string_view charBytes, std::string_view value) {
	if ((charBytes.length() <= 4) && (value.length() <= Representation::maxLength)) {
		const unsigned int key = KeyFromString(charBytes);
		const bool inserted = mapReprs.insert_or_assign(key, Representation(value)).second;
		if (inserted) {
			// New entry so increment for first byte
			const unsigned char ucStart = charBytes.empty() ? 0 : charBytes[0];
			startByteHasReprs[ucStart]++;
			if (key > maxKey) {
				maxKey = key;
			}
			if (key == representationKeyCrLf) {
				crlf = true;
			}
		}
	}
}

void SpecialRepresentations::SetRepresentationAppearance(std::string_view charBytes, RepresentationAppearance appearance) {
	if (charBytes.length() <= 4) {
		const unsigned int key = KeyFromString(charBytes);
		const MapRepresentation::iterator it = mapReprs.find(key);
		if (it == mapReprs.end()) {
			// Not present so fail
			return;
		}
		it->second.appearance = appearance;
	}
}

void SpecialRepresentations::SetRepresentationColour(std::string_view charBytes, ColourRGBA colour) {
	if (charBytes.length() <= 4) {
		const unsigned int key = KeyFromString(charBytes);
		const MapRepresentation::iterator it = mapReprs.find(key);
		if (it == mapReprs.end()) {
			// Not present so fail
			return;
		}
		it->second.appearance = it->second.appearance | RepresentationAppearance::Colour;
		it->second.colour = colour;
	}
}

void SpecialRepresentations::ClearRepresentation(std::string_view charBytes) {
	if (charBytes.length() <= 4) {
		const unsigned int key = KeyFromString(charBytes);
		const MapRepresentation::iterator it = mapReprs.find(key);
		if (it != mapReprs.end()) {
			mapReprs.erase(it);
			const unsigned char ucStart = charBytes.empty() ? 0 : charBytes[0];
			startByteHasReprs[ucStart]--;
			if (key == maxKey && startByteHasReprs[ucStart] == 0) {
				maxKey = mapReprs.empty() ? 0 : mapReprs.crbegin()->first;
			}
			if (key == representationKeyCrLf) {
				crlf = false;
			}
		}
	}
}

const Representation *SpecialRepresentations::GetRepresentation(std::string_view charBytes) const {
	const unsigned int key = KeyFromString(charBytes);
	if (key > maxKey) {
		return nullptr;
	}
	const MapRepresentation::const_iterator it = mapReprs.find(key);
	if (it != mapReprs.end()) {
		return &(it->second);
	}
	return nullptr;
}

const Representation *SpecialRepresentations::RepresentationFromCharacter(std::string_view charBytes) const {
	if (charBytes.length() <= 4) {
		const unsigned char ucStart = charBytes.empty() ? 0 : charBytes[0];
		if (!startByteHasReprs[ucStart])
			return nullptr;
		return GetRepresentation(charBytes);
	}
	return nullptr;
}

void SpecialRepresentations::Clear() {
	mapReprs.clear();
	constexpr unsigned short none = 0;
	std::fill(startByteHasReprs, std::end(startByteHasReprs), none);
	maxKey = 0;
	crlf = false;
}

void SpecialRepresentations::SetDefaultRepresentations(int dbcsCodePage) {
	Clear();

	// C0 control set
	for (size_t j = 0; j < std::size(repsC0); j++) {
		const char c[2] = { static_cast<char>(j), 0 };
		SetRepresentation(std::string_view(c, 1), repsC0[j]);
	}
	SetRepresentation("\x7f", "DEL");

	// C1 control set
	// As well as Unicode mode, ISO-8859-1 should use these
	if (CpUtf8 == dbcsCodePage) {
		for (size_t j = 0; j < std::size(repsC1); j++) {
			const char c1[3] = { '\xc2',  static_cast<char>(0x80 + j), 0 };
			SetRepresentation(c1, repsC1[j]);
		}
		SetRepresentation("\xe2\x80\xa8", "LS");
		SetRepresentation("\xe2\x80\xa9", "PS");
	}

	// Invalid as single bytes in multi-byte encodings
	if (dbcsCodePage) {
		for (int k = 0x80; k < 0x100; k++) {
			if ((CpUtf8 == dbcsCodePage) || !IsDBCSValidSingleByte(dbcsCodePage, k)) {
				const char hiByte[2] = { static_cast<char>(k), 0 };
				char hexits[4];
				Hexits(hexits, k);
				SetRepresentation(hiByte, hexits);
			}
		}
	}
}

void BreakFinder::Insert(Sci::Position val) {
	const int posInLine = static_cast<int>(val);
	if (posInLine > nextBreak) {
		const std::vector<int>::iterator it = std::lower_bound(selAndEdge.begin(), selAndEdge.end(), posInLine);
		if (it == selAndEdge.end()) {
			selAndEdge.push_back(posInLine);
		} else if (*it != posInLine) {
			selAndEdge.insert(it, 1, posInLine);
		}
	}
}

BreakFinder::BreakFinder(const LineLayout *ll_, const Selection *psel, Range lineRange_, Sci::Position posLineStart,
	XYPOSITION xStart, BreakFor breakFor, const Document *pdoc_, const SpecialRepresentations *preprs_, const ViewStyle *pvsDraw) :
	ll(ll_),
	lineRange(lineRange_),
	nextBreak(static_cast<int>(lineRange_.start)),
	saeCurrentPos(0),
	saeNext(0),
	subBreak(-1),
	pdoc(pdoc_),
	encodingFamily(pdoc_->CodePageFamily()),
	preprs(preprs_) {

	// Search for first visible break
	// First find the first visible character
	if (xStart > 0.0f)
		nextBreak = ll->FindBefore(xStart, lineRange);
	// Now back to a style break
	while ((nextBreak > lineRange.start) && (ll->styles[nextBreak] == ll->styles[nextBreak - 1])) {
		nextBreak--;
	}

	if (FlagSet(breakFor, BreakFor::Selection)) {
		const SelectionSegment segmentLine(posLineStart, posLineStart + lineRange.end);
		for (size_t r=0; r<psel->Count(); r++) {
			const SelectionSegment portion = psel->Range(r).Intersect(segmentLine);
			if (!portion.Empty()) {
				Insert(portion.start.Position() - posLineStart);
				Insert(portion.end.Position() - posLineStart);
			}
		}
		// On the curses platform, the terminal is drawing its own caret, so add breaks around the
		// caret in the main selection in order to help prevent the selection from being drawn in
		// the caret's cell.
		if (FlagSet(pvsDraw->caret.style, CaretStyle::Curses) && !psel->RangeMain().Empty()) {
			const Sci::Position caretPos = psel->RangeMain().caret.Position();
			const Sci::Position anchorPos = psel->RangeMain().anchor.Position();
			if (caretPos < anchorPos) {
				const Sci::Position nextPos = pdoc->MovePositionOutsideChar(caretPos + 1, 1);
				Insert(nextPos - posLineStart);
			} else if (caretPos > anchorPos && pvsDraw->DrawCaretInsideSelection(false, false)) {
				const Sci::Position prevPos = pdoc->MovePositionOutsideChar(caretPos - 1, -1);
				if (prevPos > anchorPos)
					Insert(prevPos - posLineStart);
			}
		}
	}
	if (FlagSet(breakFor, BreakFor::Foreground) && pvsDraw->indicatorsSetFore) {
		for (const IDecoration *deco : pdoc->decorations->View()) {
			if (pvsDraw->indicators[deco->Indicator()].OverridesTextFore()) {
				Sci::Position startPos = deco->EndRun(posLineStart);
				while (startPos < (posLineStart + lineRange.end)) {
					Insert(startPos - posLineStart);
					startPos = deco->EndRun(startPos);
				}
			}
		}
	}
	Insert(ll->edgeColumn);
	Insert(lineRange.end);
	saeNext = (!selAndEdge.empty()) ? selAndEdge[0] : -1;
}

BreakFinder::~BreakFinder() noexcept = default;

TextSegment BreakFinder::Next() {
	if (subBreak < 0) {
		const int prev = nextBreak;
		const Representation *repr = nullptr;
		while (nextBreak < lineRange.end) {
			int charWidth = 1;
			const char * const chars = &ll->chars[nextBreak];
			const unsigned char ch = chars[0];
			bool characterStyleConsistent = true;	// All bytes of character in same style?
			if (!UTF8IsAscii(ch) && encodingFamily != EncodingFamily::eightBit) {
				if (encodingFamily == EncodingFamily::unicode) {
					charWidth = UTF8DrawBytes(chars, lineRange.end - nextBreak);
				} else {
					charWidth = pdoc->DBCSDrawBytes(std::string_view(chars, lineRange.end - nextBreak));
				}
				for (int trail = 1; trail < charWidth; trail++) {
					if (ll->styles[nextBreak] != ll->styles[nextBreak + trail]) {
						characterStyleConsistent = false;
					}
				}
			}
			if (!characterStyleConsistent) {
				if (nextBreak == prev) {
					// Show first character representation bytes since it has inconsistent styles.
					charWidth = 1;
				} else {
					// Return segment before nextBreak but allow to be split up if too long
					// If not split up, next call will hit the above 'charWidth = 1;' and display bytes.
					break;
				}
			}
			repr = nullptr;
			if (preprs->MayContain(ch)) {
				// Special case \r\n line ends if there is a representation
				if (ch == '\r' && preprs->ContainsCrLf() && chars[1] == '\n') {
					charWidth = 2;
				}
				repr = preprs->GetRepresentation(std::string_view(chars, charWidth));
			}
			if (((nextBreak > 0) && (ll->styles[nextBreak] != ll->styles[nextBreak - 1])) ||
					repr ||
					(nextBreak == saeNext)) {
				while ((nextBreak >= saeNext) && (saeNext < lineRange.end)) {
					saeCurrentPos++;
					saeNext = static_cast<int>((saeCurrentPos < selAndEdge.size()) ? selAndEdge[saeCurrentPos] : lineRange.end);
				}
				if ((nextBreak > prev) || repr) {
					// Have a segment to report
					if (nextBreak == prev) {
						nextBreak += charWidth;
					} else {
						repr = nullptr;	// Optimize -> should remember repr
					}
					break;
				}
			}
			nextBreak += charWidth;
		}

		const int lengthSegment = nextBreak - prev;
		if (lengthSegment < lengthStartSubdivision) {
			return TextSegment(prev, lengthSegment, repr);
		}
		subBreak = prev;
	}

	// Splitting up a long run from prev to nextBreak in lots of approximately lengthEachSubdivision.
	const int startSegment = subBreak;
	const int remaining = nextBreak - startSegment;
	int lengthSegment = remaining;
	if (lengthSegment > lengthEachSubdivision) {
		lengthSegment = static_cast<int>(pdoc->SafeSegment(std::string_view(&ll->chars[startSegment], lengthEachSubdivision)));
	}
	if (lengthSegment < remaining) {
		subBreak += lengthSegment;
	} else {
		subBreak = -1;
	}
	return TextSegment(startSegment, lengthSegment);
}

bool BreakFinder::More() const noexcept {
	return (subBreak >= 0) || (nextBreak < lineRange.end);
}

class PositionCacheEntry {
	uint16_t styleNumber = 0;
	uint16_t len = 0;
	uint16_t clock = 0;
	bool unicode = false;
	std::unique_ptr<XYPOSITION[]> positions;
public:
	PositionCacheEntry() noexcept;
	// Copy constructor not currently used, but needed for being element in std::vector.
	PositionCacheEntry(const PositionCacheEntry &);
	PositionCacheEntry(PositionCacheEntry &&) noexcept = default;
	// Deleted so PositionCacheEntry objects can not be assigned.
	void operator=(const PositionCacheEntry &) = delete;
	void operator=(PositionCacheEntry &&) = delete;
	~PositionCacheEntry();
	void Set(unsigned int styleNumber_, bool unicode_, std::string_view sv, const XYPOSITION *positions_, uint16_t clock_);
	void Clear() noexcept;
	bool Retrieve(unsigned int styleNumber_, bool unicode_, std::string_view sv, XYPOSITION *positions_) const noexcept;
	static size_t Hash(unsigned int styleNumber_, bool unicode_, std::string_view sv) noexcept;
	[[nodiscard]] bool NewerThan(const PositionCacheEntry &other) const noexcept;
	void ResetClock() noexcept;
};

class PositionCache : public IPositionCache {
	static constexpr size_t defaultCacheSize = 0x400;
	std::vector<PositionCacheEntry> pces{ defaultCacheSize };
	std::mutex mutex;
	uint16_t clock = 1;
	bool allClear = true;
public:
	PositionCache();
	// Deleted so LineAnnotation objects can not be copied.
	PositionCache(const PositionCache &) = delete;
	PositionCache(PositionCache &&) = delete;
	void operator=(const PositionCache &) = delete;
	void operator=(PositionCache &&) = delete;
	~PositionCache() override = default;

	void Clear() noexcept override;
	void SetSize(size_t size_) override;
	[[nodiscard]] size_t GetSize() const noexcept override;
	void MeasureWidths(Surface *surface, const ViewStyle &vstyle, unsigned int styleNumber,
		bool unicode, std::string_view sv, XYPOSITION *positions, bool needsLocking) override;
};

PositionCacheEntry::PositionCacheEntry() noexcept = default;

// Copy constructor not currently used, but needed for being element in std::vector.
PositionCacheEntry::PositionCacheEntry(const PositionCacheEntry &other) :
	styleNumber(other.styleNumber), len(other.len), clock(other.clock), unicode(other.unicode) {
	if (other.positions) {
		const size_t lenData = len + (len / sizeof(XYPOSITION)) + 1;
		positions = std::make_unique<XYPOSITION[]>(lenData);
		memcpy(positions.get(), other.positions.get(), lenData * sizeof(XYPOSITION));
	}
}

void PositionCacheEntry::Set(unsigned int styleNumber_, bool unicode_, std::string_view sv,
	const XYPOSITION *positions_, uint16_t clock_) {
	Clear();
	styleNumber = static_cast<uint16_t>(styleNumber_);
	len = static_cast<uint16_t>(sv.length());
	clock = clock_;
	unicode = unicode_;
	if (sv.data() && positions_) {
		positions = std::make_unique<XYPOSITION[]>(len + (len / sizeof(XYPOSITION)) + 1);
		for (unsigned int i=0; i<len; i++) {
			positions[i] = positions_[i];
		}
		memcpy(&positions[len], sv.data(), sv.length());
	}
}

PositionCacheEntry::~PositionCacheEntry() {
	Clear();
}

void PositionCacheEntry::Clear() noexcept {
	positions.reset();
	styleNumber = 0;
	len = 0;
	clock = 0;
}

bool PositionCacheEntry::Retrieve(unsigned int styleNumber_, bool unicode_, std::string_view sv, XYPOSITION *positions_) const noexcept {
	if ((styleNumber == styleNumber_) && (unicode == unicode_) && (len == sv.length()) &&
		(memcmp(&positions[len], sv.data(), sv.length())== 0)) {
		for (unsigned int i=0; i<len; i++) {
			positions_[i] = positions[i];
		}
		return true;
	}
	return false;
}

size_t PositionCacheEntry::Hash(unsigned int styleNumber_, bool unicode_, std::string_view sv) noexcept {
	const size_t h1 = std::hash<std::string_view>{}(sv);
	const size_t h2 = std::hash<unsigned int>{}(styleNumber_);
	return h1 ^ (h2 << 1) ^ static_cast<size_t>(unicode_);
}

bool PositionCacheEntry::NewerThan(const PositionCacheEntry &other) const noexcept {
	return clock > other.clock;
}

void PositionCacheEntry::ResetClock() noexcept {
	if (clock > 0) {
		clock = 1;
	}
}

PositionCache::PositionCache() = default;

void PositionCache::Clear() noexcept {
	if (!allClear) {
		for (PositionCacheEntry &pce : pces) {
			pce.Clear();
		}
	}
	clock = 1;
	allClear = true;
}

void PositionCache::SetSize(size_t size_) {
	Clear();
	pces.resize(size_);
}

size_t PositionCache::GetSize() const noexcept {
	return pces.size();
}

void PositionCache::MeasureWidths(Surface *surface, const ViewStyle &vstyle, unsigned int styleNumber,
	bool unicode, std::string_view sv, XYPOSITION *positions, bool needsLocking) {
	const Style &style = vstyle.styles[styleNumber];
	if (style.monospaceASCII) {
		if (AllGraphicASCII(sv)) {
			const XYPOSITION monospaceCharacterWidth = style.monospaceCharacterWidth;
			for (size_t i = 0; i < sv.length(); i++) {
				positions[i] = monospaceCharacterWidth * static_cast<XYPOSITION>(i+1);
			}
			return;
		}
	}

	size_t probe = pces.size();	// Out of bounds
	if ((!pces.empty()) && (sv.length() < 30)) {
		// Only store short strings in the cache so it doesn't churn with
		// long comments with only a single comment.

		// Two way associative: try two probe positions.
		const size_t hashValue = PositionCacheEntry::Hash(styleNumber, unicode, sv);
		probe = hashValue % pces.size();
		std::unique_lock<std::mutex> guard(mutex, std::defer_lock);
		if (needsLocking) {
			guard.lock();
		}
		if (pces[probe].Retrieve(styleNumber, unicode, sv, positions)) {
			return;
		}
		const size_t probe2 = (hashValue * 37) % pces.size();
		if (pces[probe2].Retrieve(styleNumber, unicode, sv, positions)) {
			return;
		}
		// Not found. Choose the oldest of the two slots to replace
		if (pces[probe].NewerThan(pces[probe2])) {
			probe = probe2;
		}
	}

	const Font *fontStyle = style.font.get();
	if (unicode) {
		surface->MeasureWidthsUTF8(fontStyle, sv, positions);
	} else {
		surface->MeasureWidths(fontStyle, sv, positions);
	}
	if (probe < pces.size()) {
		// Store into cache
		std::unique_lock<std::mutex> guard(mutex, std::defer_lock);
		if (needsLocking) {
			guard.lock();
		}
		clock++;
		if (clock > 60000) {
			// Since there are only 16 bits for the clock, wrap it round and
			// reset all cache entries so none get stuck with a high clock.
			for (PositionCacheEntry &pce : pces) {
				pce.ResetClock();
			}
			clock = 2;
		}
		allClear = false;
		pces[probe].Set(styleNumber, unicode, sv, positions, clock);
	}
}

std::unique_ptr<IPositionCache> Scintilla::Internal::CreatePositionCache() {
	return std::make_unique<PositionCache>();
}


================================================
FILE: Libraries/scintilla/src/PositionCache.h
================================================
// Scintilla source code edit control
/** @file PositionCache.h
 ** Classes for caching layout information.
 **/
// Copyright 1998-2009 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#ifndef POSITIONCACHE_H
#define POSITIONCACHE_H

namespace Scintilla::Internal {

/**
* A point in document space.
* Uses double for sufficient resolution in large (>20,000,000 line) documents.
*/
class PointDocument {
public:
	double x;
	double y;

	explicit PointDocument(double x_ = 0, double y_ = 0) noexcept : x(x_), y(y_) {
	}

	// Conversion from Point.
	explicit PointDocument(Point pt) noexcept : x(pt.x), y(pt.y) {
	}
};

// There are two points for some positions and this enumeration
// can choose between the end of the first line or subline
// and the start of the next line or subline.
enum class PointEnd {
	start = 0x0,
	lineEnd = 0x1,
	subLineEnd = 0x2,
	endEither = lineEnd | subLineEnd,
};

class BidiData {
public:
	std::vector<std::shared_ptr<Font>> stylesFonts;
	std::vector<XYPOSITION> widthReprs;
	void Resize(size_t maxLineLength_);
};

/**
 */
class LineLayout {
private:
	std::unique_ptr<int []>lineStarts;
	int lenLineStarts;
	/// Drawing is only performed for @a maxLineLength characters on each line.
	Sci::Line lineNumber;
public:
	enum { wrapWidthInfinite = 0x7ffffff };

	int maxLineLength;
	int numCharsInLine;
	int numCharsBeforeEOL;
	enum class ValidLevel { invalid, checkTextAndStyle, positions, lines } validity;
	int xHighlightGuide;
	bool highlightColumn;
	bool containsCaret;
	int edgeColumn;
	std::unique_ptr<char[]> chars;
	std::unique_ptr<unsigned char[]> styles;
	std::unique_ptr<XYPOSITION[]> positions;
	unsigned char bracePreviousStyles[2];

	std::unique_ptr<BidiData> bidiData;

	// Wrapped line support
	int widthLine;
	int lines;
	XYPOSITION wrapIndent; // In pixels

	LineLayout(Sci::Line lineNumber_, int maxLineLength_);
	void Resize(int maxLineLength_);
	void ReSet(Sci::Line lineNumber_, Sci::Position maxLineLength_);
	void EnsureBidiData();
	void ClearPositions();
	void Invalidate(ValidLevel validity_) noexcept;
	Sci::Line LineNumber() const noexcept;
	bool CanHold(Sci::Line lineDoc, int lineLength_) const noexcept;
	int LineStart(int line) const noexcept;
	int LineLength(int line) const noexcept;
	enum class Scope { visibleOnly, includeEnd };
	int LineLastVisible(int line, Scope scope) const noexcept;
	Range SubLineRange(int subLine, Scope scope) const noexcept;
	bool InLine(int offset, int line) const noexcept;
	int SubLineFromPosition(int posInLine, PointEnd pe) const noexcept;
	void AddLineStart(Sci::Position start);
	void SetBracesHighlight(Range rangeLine, const Sci::Position braces[],
		char bracesMatchStyle, int xHighlight, bool ignoreStyle);
	void RestoreBracesHighlight(Range rangeLine, const Sci::Position braces[], bool ignoreStyle);
	int FindBefore(XYPOSITION x, Range range) const noexcept;
	int FindPositionFromX(XYPOSITION x, Range range, bool charPosition) const noexcept;
	Point PointFromPosition(int posInLine, int lineHeight, PointEnd pe) const noexcept;
	XYPOSITION XInLine(Sci::Position index) const noexcept;
	Interval Span(int start, int end) const noexcept;
	Interval SpanByte(int index) const noexcept;
	int EndLineStyle() const noexcept;
	void WrapLine(const Document *pdoc, Sci::Position posLineStart, Wrap wrapState, XYPOSITION wrapWidth);
};

struct ScreenLine : public IScreenLine {
	const LineLayout *ll;
	size_t start;
	size_t len;
	XYPOSITION width;
	XYPOSITION height;
	int ctrlCharPadding;
	XYPOSITION tabWidth;
	int tabWidthMinimumPixels;

	ScreenLine(const LineLayout *ll_, int subLine, const ViewStyle &vs, XYPOSITION width_, int tabWidthMinimumPixels_);
	// Deleted so ScreenLine objects can not be copied.
	ScreenLine(const ScreenLine &) = delete;
	ScreenLine(ScreenLine &&) = delete;
	void operator=(const ScreenLine &) = delete;
	void operator=(ScreenLine &&) = delete;
	virtual ~ScreenLine();

	std::string_view Text() const override;
	size_t Length() const override;
	size_t RepresentationCount() const override;
	XYPOSITION Width() const override;
	XYPOSITION Height() const override;
	XYPOSITION TabWidth() const override;
	XYPOSITION TabWidthMinimumPixels() const override;
	const Font *FontOfPosition(size_t position) const override;
	XYPOSITION RepresentationWidth(size_t position) const override;
	XYPOSITION TabPositionAfter(XYPOSITION xPosition) const override;
};

struct SignificantLines {
	Sci::Line lineCaret;
	Sci::Line lineTop;
	Sci::Line linesOnScreen;
	Scintilla::LineCache level;
	bool LineMayCache(Sci::Line line) const noexcept;
};

/**
 */
class LineLayoutCache {
public:
private:
	Scintilla::LineCache level;
	std::vector<std::shared_ptr<LineLayout>>cache;
	LineLayout::ValidLevel maxValidity;
	int styleClock;
	size_t EntryForLine(Sci::Line line) const noexcept;
	void AllocateForLevel(Sci::Line linesOnScreen, Sci::Line linesInDoc);
public:
	LineLayoutCache();
	// Deleted so LineLayoutCache objects can not be copied.
	LineLayoutCache(const LineLayoutCache &) = delete;
	LineLayoutCache(LineLayoutCache &&) = delete;
	void operator=(const LineLayoutCache &) = delete;
	void operator=(LineLayoutCache &&) = delete;
	virtual ~LineLayoutCache();
	void Deallocate() noexcept;
	void Invalidate(LineLayout::ValidLevel validity_) noexcept;
	void SetLevel(Scintilla::LineCache level_) noexcept;
	Scintilla::LineCache GetLevel() const noexcept { return level; }
	std::shared_ptr<LineLayout> Retrieve(Sci::Line lineNumber, Sci::Line lineCaret, int maxChars, int styleClock_,
		Sci::Line linesOnScreen, Sci::Line linesInDoc);
};

class Representation {
public:
	static constexpr size_t maxLength = 200;
	std::string stringRep;
	RepresentationAppearance appearance;
	ColourRGBA colour;
	explicit Representation(std::string_view value="", RepresentationAppearance appearance_= RepresentationAppearance::Blob) :
		stringRep(value), appearance(appearance_) {
	}
};

typedef std::map<unsigned int, Representation> MapRepresentation;

const char *ControlCharacterString(unsigned char ch) noexcept;
void Hexits(char *hexits, int ch) noexcept;

class SpecialRepresentations {
	MapRepresentation mapReprs;
	unsigned short startByteHasReprs[0x100] {};
	unsigned int maxKey = 0;
	bool crlf = false;
public:
	void SetRepresentation(std::string_view charBytes, std::string_view value);
	void SetRepresentationAppearance(std::string_view charBytes, RepresentationAppearance appearance);
	void SetRepresentationColour(std::string_view charBytes, ColourRGBA colour);
	void ClearRepresentation(std::string_view charBytes);
	const Representation *GetRepresentation(std::string_view charBytes) const;
	const Representation *RepresentationFromCharacter(std::string_view charBytes) const;
	bool ContainsCrLf() const noexcept {
		return crlf;
	}
	bool MayContain(unsigned char ch) const noexcept {
		return startByteHasReprs[ch] != 0;
	}
	void Clear();
	void SetDefaultRepresentations(int dbcsCodePage);
};

struct TextSegment {
	int start;
	int length;
	const Representation *representation;
	TextSegment(int start_=0, int length_=0, const Representation *representation_=nullptr) noexcept :
		start(start_), length(length_), representation(representation_) {
	}
	int end() const noexcept {
		return start + length;
	}
};

// Class to break a line of text into shorter runs at sensible places.
class BreakFinder {
	const LineLayout *ll;
	const Range lineRange;
	int nextBreak;
	std::vector<int> selAndEdge;
	unsigned int saeCurrentPos;
	int saeNext;
	int subBreak;
	const Document *pdoc;
	const EncodingFamily encodingFamily;
	const SpecialRepresentations *preprs;
	void Insert(Sci::Position val);
public:
	// If a whole run is longer than lengthStartSubdivision then subdivide
	// into smaller runs at spaces or punctuation.
	enum { lengthStartSubdivision = 300 };
	// Try to make each subdivided run lengthEachSubdivision or shorter.
	enum { lengthEachSubdivision = 100 };
	enum class BreakFor {
		Text = 0,
		Selection = 1,
		Foreground = 2,
		ForegroundAndSelection = 3,
	};
	BreakFinder(const LineLayout *ll_, const Selection *psel, Range lineRange_, Sci::Position posLineStart,
		XYPOSITION xStart, BreakFor breakFor, const Document *pdoc_, const SpecialRepresentations *preprs_, const ViewStyle *pvsDraw);
	// Deleted so BreakFinder objects can not be copied.
	BreakFinder(const BreakFinder &) = delete;
	BreakFinder(BreakFinder &&) = delete;
	void operator=(const BreakFinder &) = delete;
	void operator=(BreakFinder &&) = delete;
	~BreakFinder() noexcept;
	TextSegment Next();
	bool More() const noexcept;
};

class IPositionCache {
public:
	virtual ~IPositionCache() = default;
	virtual void Clear() noexcept = 0;
	virtual void SetSize(size_t size_) = 0;
	virtual size_t GetSize() const noexcept = 0;
	virtual void MeasureWidths(Surface *surface, const ViewStyle &vstyle, unsigned int styleNumber,
		bool unicode, std::string_view sv, XYPOSITION *positions, bool needsLocking) = 0;
};

std::unique_ptr<IPositionCache> CreatePositionCache();

}

#endif


================================================
FILE: Libraries/scintilla/src/RESearch.cxx
================================================
// Scintilla source code edit control
/** @file RESearch.cxx
 ** Regular expression search library.
 **/

/*
 * regex - Regular expression pattern matching and replacement
 *
 * By:  Ozan S. Yigit (oz)
 *      Dept. of Computer Science
 *      York University
 *
 * Original code available from http://www.cs.yorku.ca/~oz/
 * Translation to C++ by Neil Hodgson neilh@scintilla.org
 * Removed all use of register.
 * Converted to modern function prototypes.
 * Put all global/static variables into an object so this code can be
 * used from multiple threads, etc.
 * Some extensions by Philippe Lhoste PhiLho(a)GMX.net
 * '?' extensions by Michael Mullin masmullin@gmail.com
 *
 * These routines are the PUBLIC DOMAIN equivalents of regex
 * routines as found in 4.nBSD UN*X, with minor extensions.
 *
 * These routines are derived from various implementations found
 * in software tools books, and Conroy's grep. They are NOT derived
 * from licensed/restricted software.
 * For more interesting/academic/complicated implementations,
 * see Henry Spencer's regexp routines, or GNU Emacs pattern
 * matching module.
 *
 * Modification history removed.
 *
 * Interfaces:
 *  RESearch::Compile:      compile a regular expression into a NFA.
 *
 *          const char *RESearch::Compile(const char *pattern, int length,
 *                                        bool caseSensitive, bool posix)
 *
 * Returns a short error string if they fail.
 *
 *  RESearch::Execute:      execute the NFA to match a pattern.
 *
 *          int RESearch::Execute(characterIndexer &ci, int lp, int endp)
 *
 *  re_fail:                failure routine for RESearch::Execute. (no longer used)
 *
 *          void re_fail(char *msg, char op)
 *
 * Regular Expressions:
 *
 *      [1]     char    matches itself, unless it is a special
 *                      character (metachar): . \ [ ] * + ? ^ $
 *                      and ( ) if posix option.
 *
 *      [2]     .       matches any character.
 *
 *      [3]     \       matches the character following it, except:
 *                      - \a, \b, \f, \n, \r, \t, \v match the corresponding C
 *                      escape char, respectively BEL, BS, FF, LF, CR, TAB and VT;
 *                      Note that \r and \n are never matched because Scintilla
 *                      regex searches are made line per line
 *                      (stripped of end-of-line chars).
 *                      - if not in posix mode, when followed by a
 *                      left or right round bracket (see [8]);
 *                      - when followed by a digit 1 to 9 (see [9]);
 *                      - when followed by a left or right angle bracket
 *                      (see [10]);
 *                      - when followed by d, D, s, S, w or W (see [11]);
 *                      - when followed by x and two hexa digits (see [12].
 *                      Backslash is used as an escape character for all
 *                      other meta-characters, and itself.
 *
 *      [4]     [set]   matches one of the characters in the set.
 *                      If the first character in the set is "^",
 *                      it matches the characters NOT in the set, i.e.
 *                      complements the set. A shorthand S-E (start dash end)
 *                      is used to specify a set of characters S up to
 *                      E, inclusive. S and E must be characters, otherwise
 *                      the dash is taken literally (eg. in expression [\d-a]).
 *                      The special characters "]" and "-" have no special
 *                      meaning if they appear as the first chars in the set.
 *                      To include both, put - first: [-]A-Z]
 *                      (or just backslash them).
 *                      examples:        match:
 *
 *                              [-]|]    matches these 3 chars,
 *
 *                              []-|]    matches from ] to | chars
 *
 *                              [a-z]    any lowercase alpha
 *
 *                              [^-]]    any char except - and ]
 *
 *                              [^A-Z]   any char except uppercase
 *                                       alpha
 *
 *                              [a-zA-Z] any alpha
 *
 *      [5]     *       any regular expression form [1] to [4]
 *                      (except [8], [9] and [10] forms of [3]),
 *                      followed by closure char (*)
 *                      matches zero or more matches of that form.
 *
 *      [6]     +       same as [5], except it matches one or more.
 *
 *      [5-6]           Both [5] and [6] are greedy (they match as much as possible).
 *                      Unless they are followed by the 'lazy' quantifier (?)
 *                      In which case both [5] and [6] try to match as little as possible
 *
 *      [7]     ?       same as [5] except it matches zero or one.
 *
 *      [8]             a regular expression in the form [1] to [13], enclosed
 *                      as \(form\) (or (form) with posix flag) matches what
 *                      form matches. The enclosure creates a set of tags,
 *                      used for [9] and for pattern substitution.
 *                      The tagged forms are numbered starting from 1.
 *
 *      [9]             a \ followed by a digit 1 to 9 matches whatever a
 *                      previously tagged regular expression ([8]) matched.
 *
 *      [10]    \<      a regular expression starting with a \< construct
 *              \>      and/or ending with a \> construct, restricts the
 *                      pattern matching to the beginning of a word, and/or
 *                      the end of a word. A word is defined to be a character
 *                      string beginning and/or ending with the characters
 *                      A-Z a-z 0-9 and _. Scintilla extends this definition
 *                      by user setting. The word must also be preceded and/or
 *                      followed by any character outside those mentioned.
 *
 *      [11]    \l      a backslash followed by d, D, s, S, w or W,
 *                      becomes a character class (both inside and
 *                      outside sets []).
 *                        d: decimal digits
 *                        D: any char except decimal digits
 *                        s: whitespace (space, \t \n \r \f \v)
 *                        S: any char except whitespace (see above)
 *                        w: alphanumeric & underscore (changed by user setting)
 *                        W: any char except alphanumeric & underscore (see above)
 *
 *      [12]    \xHH    a backslash followed by x and two hexa digits,
 *                      becomes the character whose ASCII code is equal
 *                      to these digits. If not followed by two digits,
 *                      it is 'x' char itself.
 *
 *      [13]            a composite regular expression xy where x and y
 *                      are in the form [1] to [12] matches the longest
 *                      match of x followed by a match for y.
 *
 *      [14]    ^       a regular expression starting with a ^ character
 *              $       and/or ending with a $ character, restricts the
 *                      pattern matching to the beginning of the line,
 *                      or the end of line. [anchors] Elsewhere in the
 *                      pattern, ^ and $ are treated as ordinary characters.
 *
 *
 * Acknowledgements:
 *
 *  HCR's Hugh Redelmeier has been most helpful in various
 *  stages of development. He convinced me to include BOW
 *  and EOW constructs, originally invented by Rob Pike at
 *  the University of Toronto.
 *
 * References:
 *              Software tools                  Kernighan & Plauger
 *              Software tools in Pascal        Kernighan & Plauger
 *              Grep [rsx-11 C dist]            David Conroy
 *              ed - text editor                Un*x Programmer's Manual
 *              Advanced editing on Un*x        B. W. Kernighan
 *              RegExp routines                 Henry Spencer
 *
 * Notes:
 *
 *  This implementation uses a bit-set representation for character
 *  classes for speed and compactness. Each character is represented
 *  by one bit in a 256-bit block. Thus, CCL always takes a
 *	constant 32 bytes in the internal nfa, and RESearch::Execute does a single
 *  bit comparison to locate the character in the set.
 *
 * Examples:
 *
 *  pattern:    foo*.*
 *  compile:    CHR f CHR o CLO CHR o END CLO ANY END END
 *  matches:    fo foo fooo foobar fobar foxx ...
 *
 *  pattern:    fo[ob]a[rz]
 *  compile:    CHR f CHR o CCL bitset CHR a CCL bitset END
 *  matches:    fobar fooar fobaz fooaz
 *
 *  pattern:    foo\\+
 *  compile:    CHR f CHR o CHR o CHR \ CLO CHR \ END END
 *  matches:    foo\ foo\\ foo\\\  ...
 *
 *  pattern:    \(foo\)[1-3]\1  (same as foo[1-3]foo)
 *  compile:    BOT 1 CHR f CHR o CHR o EOT 1 CCL bitset REF 1 END
 *  matches:    foo1foo foo2foo foo3foo
 *
 *  pattern:    \(fo.*\)-\1
 *  compile:    BOT 1 CHR f CHR o CLO ANY END EOT 1 CHR - REF 1 END
 *  matches:    foo-foo fo-fo fob-fob foobar-foobar ...
 */

#include <cstddef>
#include <cstdlib>

#include <stdexcept>
#include <string>
#include <array>
#include <algorithm>
#include <iterator>

#include "Position.h"
#include "CharClassify.h"
#include "RESearch.h"

using namespace Scintilla::Internal;

#define OKP     1
#define NOP     0

#define CHR     1
#define ANY     2
#define CCL     3
#define BOL     4
#define EOL     5
#define BOT     6
#define EOT     7
#define BOW     8
#define EOW     9
#define REF     10
#define CLO     11
#define CLQ     12 /* 0 to 1 closure */
#define LCLO    13 /* lazy closure */

#define END     0

/*
 * The following defines are not meant to be changeable.
 * They are for readability only.
 */
#define BITIND  07

#define badpat(x)	(*nfa = END, x)

/*
 * Character classification table for word boundary operators BOW
 * and EOW is passed in by the creator of this object (Scintilla
 * Document). The Document default state is that word chars are:
 * 0-9, a-z, A-Z and _
 */

RESearch::RESearch(CharClassify *charClassTable) {
	failure = 0;
	charClass = charClassTable;
	sta = NOP;                  /* status of lastpat */
	lineStartPos = 0;
	lineEndPos = 0;
	nfa[0] = END;
	Clear();
}

void RESearch::Clear() {
	bopat.fill(NOTFOUND);
	eopat.fill(NOTFOUND);
}

void RESearch::ChSet(unsigned char c) noexcept {
	bittab[c >> 3] |= 1 << (c & BITIND);
}

void RESearch::ChSetWithCase(unsigned char c, bool caseSensitive) noexcept {
	ChSet(c);
	if (!caseSensitive) {
		if ((c >= 'a') && (c <= 'z')) {
			ChSet(c - 'a' + 'A');
		} else if ((c >= 'A') && (c <= 'Z')) {
			ChSet(c - 'A' + 'a');
		}
	}
}

namespace {

constexpr unsigned char escapeValue(unsigned char ch) noexcept {
	switch (ch) {
	case 'a':	return '\a';
	case 'b':	return '\b';
	case 'f':	return '\f';
	case 'n':	return '\n';
	case 'r':	return '\r';
	case 't':	return '\t';
	case 'v':	return '\v';
	default:	break;
	}
	return 0;
}

constexpr int GetHexaChar(unsigned char hd1, unsigned char hd2) noexcept {
	int hexValue = 0;
	if (hd1 >= '0' && hd1 <= '9') {
		hexValue += 16 * (hd1 - '0');
	} else if (hd1 >= 'A' && hd1 <= 'F') {
		hexValue += 16 * (hd1 - 'A' + 10);
	} else if (hd1 >= 'a' && hd1 <= 'f') {
		hexValue += 16 * (hd1 - 'a' + 10);
	} else {
		return -1;
	}
	if (hd2 >= '0' && hd2 <= '9') {
		hexValue += hd2 - '0';
	} else if (hd2 >= 'A' && hd2 <= 'F') {
		hexValue += hd2 - 'A' + 10;
	} else if (hd2 >= 'a' && hd2 <= 'f') {
		hexValue += hd2 - 'a' + 10;
	} else {
		return -1;
	}
	return hexValue;
}

constexpr int isinset(const char *ap, unsigned char c) noexcept {
	return ap[c >> 3] & (1 << (c & BITIND));
}

}

/**
 * Called when the parser finds a backslash not followed
 * by a valid expression (like \( in non-Posix mode).
 * @param pattern : pointer on the char after the backslash.
 * @param incr : (out) number of chars to skip after expression evaluation.
 * @return the char if it resolves to a simple char,
 * or -1 for a char class. In this case, bittab is changed.
 */
int RESearch::GetBackslashExpression(const char *pattern, int &incr) noexcept {
	// Since error reporting is primitive and messages are not used anyway,
	// I choose to interpret unexpected syntax in a logical way instead
	// of reporting errors. Otherwise, we can stick on, eg., PCRE behaviour.
	incr = 0;	// Most of the time, will skip the char "naturally".
	int result = -1;
	const unsigned char bsc = *pattern;
	if (!bsc) {
		// Avoid overrun
		result = '\\';	// \ at end of pattern, take it literally
		return result;
	}

	switch (bsc) {
	case 'a':
	case 'b':
	case 'n':
	case 'f':
	case 'r':
	case 't':
	case 'v':
		result = escapeValue(bsc);
		break;
	case 'x': {
			const unsigned char hd1 = *(pattern + 1);
			const unsigned char hd2 = *(pattern + 2);
			const int hexValue = GetHexaChar(hd1, hd2);
			if (hexValue >= 0) {
				result = hexValue;
				incr = 2;	// Must skip the digits
			} else {
				result = 'x';	// \x without 2 digits: see it as 'x'
			}
		}
		break;
	case 'd':
		for (int c = '0'; c <= '9'; c++) {
			ChSet(static_cast<unsigned char>(c));
		}
		break;
	case 'D':
		for (int c = 0; c < MAXCHR; c++) {
			if (c < '0' || c > '9') {
				ChSet(static_cast<unsigned char>(c));
			}
		}
		break;
	case 's':
		ChSet(' ');
		ChSet('\t');
		ChSet('\n');
		ChSet('\r');
		ChSet('\f');
		ChSet('\v');
		break;
	case 'S':
		for (int c = 0; c < MAXCHR; c++) {
			if (c != ' ' && !(c >= 0x09 && c <= 0x0D)) {
				ChSet(static_cast<unsigned char>(c));
			}
		}
		break;
	case 'w':
		for (int c = 0; c < MAXCHR; c++) {
			if (iswordc(static_cast<unsigned char>(c))) {
				ChSet(static_cast<unsigned char>(c));
			}
		}
		break;
	case 'W':
		for (int c = 0; c < MAXCHR; c++) {
			if (!iswordc(static_cast<unsigned char>(c))) {
				ChSet(static_cast<unsigned char>(c));
			}
		}
		break;
	default:
		result = bsc;
	}
	return result;
}

const char *RESearch::Compile(const char *pattern, Sci::Position length, bool caseSensitive, bool posix) {
	if (!pattern || !length) {
		if (sta)
			return nullptr;
		else
			return badpat("No previous regular expression");
	}

	bittab.fill(0);
	nfa[0] = END;

	char *mp=nfa;          /* nfa pointer       */
	char *sp=nfa;          /* another saved pointer */
	const char * const mpMax = mp + MAXNFA - BITBLK - 10;

	int tagstk[MAXTAG]{};  /* subpat tag stack */
	int tagi = 0;          /* tag stack index   */
	int tagc = 1;          /* actual tag count  */

	sta = NOP;

	const char *p=pattern;     /* pattern pointer   */
	for (int i=0; i<length; i++, p++) {
		if (mp > mpMax)
			return badpat("Pattern too long");
		char *lp = mp;			/* saved pointer     */
		switch (*p) {

		case '.':               /* match any char  */
			*mp++ = ANY;
			break;

		case '^':               /* match beginning */
			if (p == pattern) {
				*mp++ = BOL;
			} else {
				*mp++ = CHR;
				*mp++ = *p;
			}
			break;

		case '$':               /* match endofline */
			if (!p[1]) {
				*mp++ = EOL;
			} else {
				*mp++ = CHR;
				*mp++ = *p;
			}
			break;

		case '[': {               /* match char class */
			int prevChar = 0;
			char mask = 0;      /* xor mask -CCL/NCL */

			i++;
			if (*++p == '^') {
				mask = '\377';
				i++;
				p++;
			}

			if (*p == '-') {	/* real dash */
				i++;
				prevChar = *p;
				ChSet(*p++);
			}
			if (*p == ']') {	/* real brace */
				i++;
				prevChar = *p;
				ChSet(*p++);
			}
			while (*p && *p != ']') {
				if (*p == '-') {
					if (prevChar < 0) {
						// Previous def. was a char class like \d, take dash literally
						prevChar = *p;
						ChSet(*p);
					} else if (p[1]) {
						if (p[1] != ']') {
							int c1 = prevChar + 1;
							i++;
							int c2 = static_cast<unsigned char>(*++p);
							if (c2 == '\\') {
								if (!p[1]) {	// End of RE
									return badpat("Missing ]");
								} else {
									i++;
									p++;
									int incr = 0;
									c2 = GetBackslashExpression(p, incr);
									i += incr;
									p += incr;
									if (c2 >= 0) {
										// Convention: \c (c is any char) is case sensitive, whatever the option
										ChSet(static_cast<unsigned char>(c2));
										prevChar = c2;
									} else {
										// bittab is already changed
										prevChar = -1;
									}
								}
							}
							if (prevChar < 0) {
								// Char after dash is char class like \d, take dash literally
								prevChar = '-';
								ChSet('-');
							} else {
								// Put all chars between c1 and c2 included in the char set
								while (c1 <= c2) {
									ChSetWithCase(static_cast<unsigned char>(c1++), caseSensitive);
								}
							}
						} else {
							// Dash before the ], take it literally
							prevChar = *p;
							ChSet(*p);
						}
					} else {
						return badpat("Missing ]");
					}
				} else if (*p == '\\' && p[1]) {
					i++;
					p++;
					int incr = 0;
					const int c = GetBackslashExpression(p, incr);
					i += incr;
					p += incr;
					if (c >= 0) {
						// Convention: \c (c is any char) is case sensitive, whatever the option
						ChSet(static_cast<unsigned char>(c));
						prevChar = c;
					} else {
						// bittab is already changed
						prevChar = -1;
					}
				} else {
					prevChar = static_cast<unsigned char>(*p);
					ChSetWithCase(*p, caseSensitive);
				}
				i++;
				p++;
			}
			if (!*p)
				return badpat("Missing ]");

			*mp++ = CCL;
			for (const unsigned char byte : bittab) {
				*mp++ = mask ^ byte;
			}
			bittab.fill(0);
		} break;

		case '*':               /* match 0 or more... */
		case '+':               /* match 1 or more... */
		case '?':
			if (p == pattern)
				return badpat("Empty closure");
			lp = sp;		/* previous opcode */
			if (*lp == CLO || *lp == LCLO)		/* equivalence... */
				break;
			switch (*lp) {

			case BOL:
			case BOT:
			case EOT:
			case BOW:
			case EOW:
			case REF:
				return badpat("Illegal closure");
			default:
				break;
			}

			if (*p == '+')
				for (sp = mp; lp < sp; lp++)
					*mp++ = *lp;

			*mp++ = END;
			*mp++ = END;
			sp = mp;

			while (--mp > lp)
				*mp = mp[-1];
			if (*p == '?')          *mp = CLQ;
			else if (p[1] == '?') *mp = LCLO;
			else                    *mp = CLO;

			mp = sp;
			break;

		case '\\':              /* tags, backrefs... */
			i++;
			switch (*++p) {
			case '<':
				*mp++ = BOW;
				break;
			case '>':
				if (*sp == BOW)
					return badpat("Null pattern inside \\<\\>");
				*mp++ = EOW;
				break;
			case '1':
			case '2':
			case '3':
			case '4':
			case '5':
			case '6':
			case '7':
			case '8':
			case '9': {
				const int n = *p-'0';
				if (tagi > 0 && tagstk[tagi] == n)
					return badpat("Cyclical reference");
				if (tagc > n) {
					*mp++ = REF;
					*mp++ = static_cast<char>(n);
				} else {
					return badpat("Undetermined reference");
				}
			} break;
			default:
				if (!posix && *p == '(') {
					if (tagc < MAXTAG) {
						tagstk[++tagi] = tagc;
						*mp++ = BOT;
						*mp++ = static_cast<char>(tagc++);
					} else {
						return badpat("Too many \\(\\) pairs");
					}
				} else if (!posix && *p == ')') {
					if (*sp == BOT)
						return badpat("Null pattern inside \\(\\)");
					if (tagi > 0) {
						*mp++ = EOT;
						*mp++ = static_cast<char>(tagstk[tagi--]);
					} else {
						return badpat("Unmatched \\)");
					}
				} else {
					int incr = 0;
					const int c = GetBackslashExpression(p, incr);
					i += incr;
					p += incr;
					if (c >= 0) {
						*mp++ = CHR;
						*mp++ = static_cast<unsigned char>(c);
					} else {
						*mp++ = CCL;
						for (const unsigned char byte : bittab) {
							*mp++ = byte;
						}
						bittab.fill(0);
					}
				}
			}
			break;

		default :               /* an ordinary char */
			if (posix && *p == '(') {
				if (tagc < MAXTAG) {
					tagstk[++tagi] = tagc;
					*mp++ = BOT;
					*mp++ = static_cast<char>(tagc++);
				} else {
					return badpat("Too many () pairs");
				}
			} else if (posix && *p == ')') {
				if (*sp == BOT)
					return badpat("Null pattern inside ()");
				if (tagi > 0) {
					*mp++ = EOT;
					*mp++ = static_cast<char>(tagstk[tagi--]);
				} else {
					return badpat("Unmatched )");
				}
			} else {
				unsigned char c = *p;
				if (!c)	// End of RE
					c = '\\';	// We take it as raw backslash
				if (caseSensitive || !iswordc(c)) {
					*mp++ = CHR;
					*mp++ = c;
				} else {
					ChSetWithCase(c, false);
					*mp++ = CCL;
					for (const unsigned char byte : bittab) {
						*mp++ = byte;
					}
					bittab.fill(0);
				}
			}
			break;
		}
		sp = lp;
	}
	if (tagi > 0)
		return badpat((posix ? "Unmatched (" : "Unmatched \\("));
	*mp = END;
	sta = OKP;
	return nullptr;
}

/*
 * RESearch::Execute:
 *   execute nfa to find a match.
 *
 *  special cases: (nfa[0])
 *      BOL
 *          Match only once, starting from the
 *          beginning.
 *      CHR
 *          First locate the character without
 *          calling PMatch, and if found, call
 *          PMatch for the remaining string.
 *      END
 *          RESearch::Compile failed, poor luser did not
 *          check for it. Fail fast.
 *
 *  If a match is found, bopat[0] and eopat[0] are set
 *  to the beginning and the end of the matched fragment,
 *  respectively.
 *
 */
int RESearch::Execute(const CharacterIndexer &ci, Sci::Position lp, Sci::Position endp) {
	Sci::Position ep = NOTFOUND;
	const char * const ap = nfa;

	failure = 0;

	Clear();

	switch (*ap) {

	case BOL:			/* anchored: match from BOL only */
		ep = PMatch(ci, lp, endp, ap);
		break;
	case EOL:			/* just searching for end of line normal path doesn't work */
		if (endp == lineEndPos && ap[1] == END) {
			lp = endp;
			ep = lp;
			break;
		} else {
			return 0;
		}
	case CHR: {			/* ordinary char: locate it fast */
		const unsigned char c = ap[1];
		while ((lp < endp) && (static_cast<unsigned char>(ci.CharAt(lp)) != c))
			lp++;
		if (lp >= endp)	/* if EOS, fail, else fall through. */
			return 0;
	}
	[[fallthrough]];
	default:			/* regular matching all the way. */
		while (lp < endp) {
			ep = PMatch(ci, lp, endp, ap);
			if (ep != NOTFOUND) {
				// fix match started from middle of character like DBCS trailing ASCII byte
				const Sci::Position pos = ci.MovePositionOutsideChar(lp, -1);
				if (pos != lp) {
					ep = NOTFOUND;
				} else {
					break;
				}
			}
			lp++;
		}
		break;
	case END:			/* munged automaton. fail always */
		return 0;
	}
	if (ep == NOTFOUND) {
		/* similar to EOL, match EOW at line end */
		if (endp == lineEndPos && *ap == EOW) {
			if ((ap[1] == END || ((ap[1] == EOL && ap[2] == END))) && iswordc(ci.CharAt(lp - 1))) {
				lp = endp;
				ep = lp;
			} else {
				return 0;
			}
		} else {
			return 0;
		}
	}

	ep = ci.MovePositionOutsideChar(ep, 1);
	bopat[0] = lp;
	eopat[0] = ep;
	return 1;
}

/*
 * PMatch: internal routine for the hard part
 *
 *  This code is partly snarfed from an early grep written by
 *  David Conroy. The backref and tag stuff, and various other
 *  innovations are by oz.
 *
 *  special case optimizations: (nfa[n], nfa[n+1])
 *      CLO ANY
 *          We KNOW .* will match everything up to the
 *          end of line. Thus, directly go to the end of
 *          line, without recursive PMatch calls. As in
 *          the other closure cases, the remaining pattern
 *          must be matched by moving backwards on the
 *          string recursively, to find a match for xy
 *          (x is ".*" and y is the remaining pattern)
 *          where the match satisfies the LONGEST match for
 *          x followed by a match for y.
 *      CLO CHR
 *          We can again scan the string forward for the
 *          single char and at the point of failure, we
 *          execute the remaining nfa recursively, same as
 *          above.
 *
 *  At the end of a successful match, bopat[n] and eopat[n]
 *  are set to the beginning and end of subpatterns matched
 *  by tagged expressions (n = 1 to 9).
 */

//extern void re_fail(char *,char);

/*
 * skip values for CLO XXX to skip past the closure
 */

#define ANYSKIP 2 	/* [CLO] ANY END          */
#define CHRSKIP 3	/* [CLO] CHR chr END      */
#define CCLSKIP 34	/* [CLO] CCL 32 bytes END */

Sci::Position RESearch::PMatch(const CharacterIndexer &ci, Sci::Position lp, Sci::Position endp, const char *ap) {
	unsigned char op = 0;

	while ((op = *ap++) != END)
		switch (op) {

		case CHR:
			if (ci.CharAt(lp++) != *ap++)
				return NOTFOUND;
			break;
		case ANY:
			if (lp++ >= endp)
				return NOTFOUND;
			break;
		case CCL:
			if (lp >= endp)
				return NOTFOUND;
			if (!isinset(ap, ci.CharAt(lp++)))
				return NOTFOUND;
			ap += BITBLK;
			break;
		case BOL:
			if (lp != lineStartPos)
				return NOTFOUND;
			break;
		case EOL:
			if (lp < lineEndPos)
				return NOTFOUND;
			break;
		case BOT:
			if (lp != ci.MovePositionOutsideChar(lp, -1)) {
				return NOTFOUND;
			}
			bopat[static_cast<unsigned char>(*ap++)] = lp;
			break;
		case EOT:
			lp = ci.MovePositionOutsideChar(lp, 1);
			eopat[static_cast<unsigned char>(*ap++)] = lp;
			break;
		case BOW:
			if ((lp!=lineStartPos && iswordc(ci.CharAt(lp-1))) || !iswordc(ci.CharAt(lp)))
				return NOTFOUND;
			break;
		case EOW:
			if (lp==lineStartPos || !iswordc(ci.CharAt(lp-1)) || iswordc(ci.CharAt(lp)))
				return NOTFOUND;
			break;
		case REF: {
			const int n = static_cast<unsigned char>(*ap++);
			Sci::Position bp = bopat[n];		/* beginning of subpat... */
			const Sci::Position ep = eopat[n];	/* ending of subpat...    */
			while (bp < ep)
				if (ci.CharAt(bp++) != ci.CharAt(lp++))
					return NOTFOUND;
		} break;
		case LCLO:
		case CLQ:
		case CLO: {
			int n = 0;
			const Sci::Position are = lp;	/* to save the line ptr.  */
			switch (*ap) {

			case ANY:
				if (op == CLO || op == LCLO)
					while (lp < endp)
						lp++;
				else if (lp < endp)
					lp++;

				n = ANYSKIP;
				break;
			case CHR: {
				const char c = ap[1];
				if (op == CLO || op == LCLO)
					while ((lp < endp) && (c == ci.CharAt(lp)))
						lp++;
				else if ((lp < endp) && (c == ci.CharAt(lp)))
					lp++;
				n = CHRSKIP;
			} break;
			case CCL:
				while ((lp < endp) && isinset(ap+1, ci.CharAt(lp)))
					lp++;
				n = CCLSKIP;
				break;
			default:
				failure = true;
				//re_fail("closure: bad nfa.", *ap);
				return NOTFOUND;
			}
			ap += n;

			Sci::Position llp = lp;		/* lazy lp for LCLO       */
			Sci::Position e = NOTFOUND; /* extra pointer for CLO  */
			while (llp >= are) {
				const Sci::Position q = PMatch(ci, llp, endp, ap);
				if (q != NOTFOUND) {
					e = q;
					lp = llp;
					if (op != LCLO) return e;
				}
				if (*ap == END) return e;
				--llp;
			}
			if (*ap == EOT)
				PMatch(ci, lp, endp, ap);
			return e;
		}
		default:
			//re_fail("RESearch::Execute: bad nfa.", static_cast<char>(op));
			return NOTFOUND;
		}
	return lp;
}


================================================
FILE: Libraries/scintilla/src/RESearch.h
================================================
// Scintilla source code edit control
/** @file RESearch.h
 ** Interface to the regular expression search library.
 **/
// Written by Neil Hodgson <neilh@scintilla.org>
// Based on the work of Ozan S. Yigit.
// This file is in the public domain.

#ifndef RESEARCH_H
#define RESEARCH_H

namespace Scintilla::Internal {

class CharacterIndexer {
public:
	virtual char CharAt(Sci::Position index) const=0;
	virtual Sci::Position MovePositionOutsideChar(Sci::Position pos, [[maybe_unused]] Sci::Position moveDir) const noexcept=0;
};

class RESearch {

public:
	explicit RESearch(CharClassify *charClassTable);
	// No dynamic allocation so default copy constructor and assignment operator are OK.
	void Clear();
	const char *Compile(const char *pattern, Sci::Position length, bool caseSensitive, bool posix);
	int Execute(const CharacterIndexer &ci, Sci::Position lp, Sci::Position endp);
	void SetLineRange(Sci::Position startPos, Sci::Position endPos) noexcept {
		lineStartPos = startPos;
		lineEndPos = endPos;
	}

	static constexpr int MAXTAG = 10;
	static constexpr int NOTFOUND = -1;

	using MatchPositions = std::array<Sci::Position, MAXTAG>;
	MatchPositions bopat;
	MatchPositions eopat;

private:

	static constexpr int MAXNFA = 4096;
	// The following constants are not meant to be changeable.
	// They are for readability only.
	static constexpr int MAXCHR = 256;
	static constexpr int CHRBIT = 8;
	static constexpr int BITBLK = MAXCHR / CHRBIT;

	void ChSet(unsigned char c) noexcept;
	void ChSetWithCase(unsigned char c, bool caseSensitive) noexcept;
	int GetBackslashExpression(const char *pattern, int &incr) noexcept;

	Sci::Position PMatch(const CharacterIndexer &ci, Sci::Position lp, Sci::Position endp, const char *ap);

	// positions to match line start and line end
	Sci::Position lineStartPos;
	Sci::Position lineEndPos;
	char nfa[MAXNFA];    /* automaton */
	int sta;
	int failure;
	std::array<unsigned char, BITBLK> bittab {}; /* bit table for CCL pre-set bits */
	CharClassify *charClass;
	bool iswordc(unsigned char x) const noexcept {
		return charClass->IsWord(x);
	}
};

}

#endif



================================================
FILE: Libraries/scintilla/src/RunStyles.cxx
================================================
/** @file RunStyles.cxx
 ** Data structure used to store sparse styles.
 **/
// Copyright 1998-2007 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#include <cstddef>
#include <cstdlib>
#include <cstdint>
#include <cstring>
#include <cstdio>
#include <cstdarg>
#include <climits>

#include <stdexcept>
#include <string_view>
#include <vector>
#include <optional>
#include <algorithm>
#include <memory>

#include "Debugging.h"

#include "Position.h"
#include "SplitVector.h"
#include "Partitioning.h"
#include "RunStyles.h"

using namespace Scintilla::Internal;

// Find the first run at a position
template <typename DISTANCE, typename STYLE>
DISTANCE RunStyles<DISTANCE, STYLE>::RunFromPosition(DISTANCE position) const noexcept {
	DISTANCE run = starts.PartitionFromPosition(position);
	// Go to first element with this position
	while ((run > 0) && (position == starts.PositionFromPartition(run-1))) {
		run--;
	}
	return run;
}

// If there is no run boundary at position, insert one continuing style.
template <typename DISTANCE, typename STYLE>
DISTANCE RunStyles<DISTANCE, STYLE>::SplitRun(DISTANCE position) {
	DISTANCE run = RunFromPosition(position);
	const DISTANCE posRun = starts.PositionFromPartition(run);
	if (posRun < position) {
		STYLE runStyle = ValueAt(position);
		run++;
		starts.InsertPartition(run, position);
		styles.InsertValue(run, 1, runStyle);
	}
	return run;
}

template <typename DISTANCE, typename STYLE>
void RunStyles<DISTANCE, STYLE>::RemoveRun(DISTANCE run) {
	starts.RemovePartition(run);
	styles.DeleteRange(run, 1);
}

template <typename DISTANCE, typename STYLE>
void RunStyles<DISTANCE, STYLE>::RemoveRunIfEmpty(DISTANCE run) {
	if ((run < starts.Partitions()) && (starts.Partitions() > 1)) {
		if (starts.PositionFromPartition(run) == starts.PositionFromPartition(run+1)) {
			RemoveRun(run);
		}
	}
}

template <typename DISTANCE, typename STYLE>
void RunStyles<DISTANCE, STYLE>::RemoveRunIfSameAsPrevious(DISTANCE run) {
	if ((run > 0) && (run < starts.Partitions())) {
		const DISTANCE runBefore = run - 1;
		if (styles.ValueAt(runBefore) == styles.ValueAt(run)) {
			RemoveRun(run);
		}
	}
}

template <typename DISTANCE, typename STYLE>
RunStyles<DISTANCE, STYLE>::RunStyles() {
	styles.InsertValue(0, 2, 0);
}

template <typename DISTANCE, typename STYLE>
DISTANCE RunStyles<DISTANCE, STYLE>::Length() const noexcept {
	return starts.PositionFromPartition(starts.Partitions());
}

template <typename DISTANCE, typename STYLE>
STYLE RunStyles<DISTANCE, STYLE>::ValueAt(DISTANCE position) const noexcept {
	return styles.ValueAt(starts.PartitionFromPosition(position));
}

template <typename DISTANCE, typename STYLE>
DISTANCE RunStyles<DISTANCE, STYLE>::FindNextChange(DISTANCE position, DISTANCE end) const noexcept {
	const DISTANCE run = starts.PartitionFromPosition(position);
	if (run < starts.Partitions()) {
		const DISTANCE runChange = starts.PositionFromPartition(run);
		if (runChange > position)
			return runChange;
		const DISTANCE nextChange = starts.PositionFromPartition(run + 1);
		if (nextChange > position) {
			return nextChange;
		} else if (position < end) {
			return end;
		} else {
			return end + 1;
		}
	} else {
		return end + 1;
	}
}

template <typename DISTANCE, typename STYLE>
DISTANCE RunStyles<DISTANCE, STYLE>::StartRun(DISTANCE position) const noexcept {
	return starts.PositionFromPartition(starts.PartitionFromPosition(position));
}

template <typename DISTANCE, typename STYLE>
DISTANCE RunStyles<DISTANCE, STYLE>::EndRun(DISTANCE position) const noexcept {
	return starts.PositionFromPartition(starts.PartitionFromPosition(position) + 1);
}

template <typename DISTANCE, typename STYLE>
FillResult<DISTANCE> RunStyles<DISTANCE, STYLE>::FillRange(DISTANCE position, STYLE value, DISTANCE fillLength) {
	const FillResult<DISTANCE> resultNoChange{false, position, fillLength};
	if (fillLength <= 0) {
		return resultNoChange;
	}
	DISTANCE end = position + fillLength;
	if (end > Length()) {
		return resultNoChange;
	}
	DISTANCE runEnd = RunFromPosition(end);
	const STYLE valueCurrent = styles.ValueAt(runEnd);
	if (valueCurrent == value) {
		// End already has value so trim range.
		end = starts.PositionFromPartition(runEnd);
		if (position >= end) {
			// Whole range is already same as value so no action
			return resultNoChange;
		}
		fillLength = end - position;
	} else {
		const DISTANCE startRun = starts.PositionFromPartition(runEnd);
		if (position > startRun) {
			const DISTANCE runNext = runEnd + 1;
			const DISTANCE endRun = starts.PositionFromPartition(runNext);
			if (end < endRun) {
				// New piece is completely inside a run with a different value so its a simple
				// insertion of two points [ (position, value), (end, valueCurrent) ]
				const DISTANCE range[] { position, end};
				starts.InsertPartitions(runEnd + 1, range, 2);
				// Temporary runEndIndex silences non-useful arithmetic overflow warnings
				const ptrdiff_t runEndIndex = runEnd;
				styles.Insert(runEndIndex + 1, value);
				styles.Insert(runEndIndex + 2, valueCurrent);
				return { true, position, fillLength };
			}
		}
		runEnd = SplitRun(end);
	}
	DISTANCE runStart = RunFromPosition(position);
	if (styles.ValueAt(runStart) == value) {
		// Start is in expected value so trim range.
		runStart++;
		position = starts.PositionFromPartition(runStart);
		fillLength = end - position;
	} else {
		if (starts.PositionFromPartition(runStart) < position) {
			runStart = SplitRun(position);
			runEnd++;
		}
	}
	if (runStart < runEnd) {
		const FillResult<DISTANCE> result{ true, position, fillLength };
		styles.SetValueAt(runStart, value);
		// Remove each old run over the range
		for (DISTANCE run=runStart+1; run<runEnd; run++) {
			RemoveRun(runStart+1);
		}
		runEnd = RunFromPosition(end);
		RemoveRunIfSameAsPrevious(runEnd);
		RemoveRunIfSameAsPrevious(runStart);
		runEnd = RunFromPosition(end);
		RemoveRunIfEmpty(runEnd);
		return result;
	}
	return resultNoChange;
}

template <typename DISTANCE, typename STYLE>
void RunStyles<DISTANCE, STYLE>::SetValueAt(DISTANCE position, STYLE value) {
	FillRange(position, value, 1);
}

template <typename DISTANCE, typename STYLE>
void RunStyles<DISTANCE, STYLE>::InsertSpace(DISTANCE position, DISTANCE insertLength) {
	DISTANCE runStart = RunFromPosition(position);
	if (starts.PositionFromPartition(runStart) == position) {
		STYLE runStyle = ValueAt(position);
		// Inserting at start of run so make previous longer
		if (runStart == 0) {
			// Inserting at start of document so ensure 0
			if (runStyle) {
				styles.SetValueAt(0, STYLE());
				starts.InsertPartition(1, 0);
				styles.InsertValue(1, 1, runStyle);
				starts.InsertText(0, insertLength);
			} else {
				starts.InsertText(runStart, insertLength);
			}
		} else {
			if (runStyle) {
				starts.InsertText(runStart-1, insertLength);
			} else {
				// Insert at end of run so do not extend style
				starts.InsertText(runStart, insertLength);
			}
		}
	} else {
		starts.InsertText(runStart, insertLength);
	}
}

template <typename DISTANCE, typename STYLE>
void RunStyles<DISTANCE, STYLE>::DeleteAll() {
	starts = Partitioning<DISTANCE>();
	styles = SplitVector<STYLE>();
	styles.InsertValue(0, 2, 0);
}

template <typename DISTANCE, typename STYLE>
void RunStyles<DISTANCE, STYLE>::DeleteRange(DISTANCE position, DISTANCE deleteLength) {
	DISTANCE end = position + deleteLength;
	DISTANCE runStart = RunFromPosition(position);
	DISTANCE runEnd = RunFromPosition(end);
	if (runStart == runEnd) {
		// Deleting from inside one run
		starts.InsertText(runStart, -deleteLength);
		RemoveRunIfEmpty(runStart);
	} else {
		runStart = SplitRun(position);
		runEnd = SplitRun(end);
		starts.InsertText(runStart, -deleteLength);
		// Remove each old run over the range
		for (DISTANCE run=runStart; run<runEnd; run++) {
			RemoveRun(runStart);
		}
		RemoveRunIfEmpty(runStart);
		RemoveRunIfSameAsPrevious(runStart);
	}
}

template <typename DISTANCE, typename STYLE>
DISTANCE RunStyles<DISTANCE, STYLE>::Runs() const noexcept {
	return starts.Partitions();
}

template <typename DISTANCE, typename STYLE>
bool RunStyles<DISTANCE, STYLE>::AllSame() const noexcept {
	for (DISTANCE run = 1; run < starts.Partitions(); run++) {
		const DISTANCE runBefore = run - 1;
		if (styles.ValueAt(run) != styles.ValueAt(runBefore))
			return false;
	}
	return true;
}

template <typename DISTANCE, typename STYLE>
bool RunStyles<DISTANCE, STYLE>::AllSameAs(STYLE value) const noexcept {
	return AllSame() && (styles.ValueAt(0) == value);
}

template <typename DISTANCE, typename STYLE>
DISTANCE RunStyles<DISTANCE, STYLE>::Find(STYLE value, DISTANCE start) const noexcept {
	if (start < Length()) {
		DISTANCE run = start ? RunFromPosition(start) : 0;
		if (styles.ValueAt(run) == value)
			return start;
		run++;
		while (run < starts.Partitions()) {
			if (styles.ValueAt(run) == value)
				return starts.PositionFromPartition(run);
			run++;
		}
	}
	return -1;
}

template <typename DISTANCE, typename STYLE>
void RunStyles<DISTANCE, STYLE>::Check() const {
	if (Length() < 0) {
		throw std::runtime_error("RunStyles: Length can not be negative.");
	}
	if (starts.Partitions() < 1) {
		throw std::runtime_error("RunStyles: Must always have 1 or more partitions.");
	}
	if (starts.Partitions() != styles.Length()-1) {
		throw std::runtime_error("RunStyles: Partitions and styles different lengths.");
	}
	DISTANCE start=0;
	while (start < Length()) {
		const DISTANCE end = EndRun(start);
		if (start >= end) {
			throw std::runtime_error("RunStyles: Partition is 0 length.");
		}
		start = end;
	}
	if (styles.ValueAt(styles.Length()-1) != 0) {
		throw std::runtime_error("RunStyles: Unused style at end changed.");
	}
	for (ptrdiff_t j=1; j<styles.Length()-1; j++) {
		if (styles.ValueAt(j) == styles.ValueAt(j-1)) {
			throw std::runtime_error("RunStyles: Style of a partition same as previous.");
		}
	}
}

template class Scintilla::Internal::RunStyles<int, int>;
template class Scintilla::Internal::RunStyles<int, char>;
#if (PTRDIFF_MAX != INT_MAX) || defined(__HAIKU__)
template class Scintilla::Internal::RunStyles<ptrdiff_t, int>;
template class Scintilla::Internal::RunStyles<ptrdiff_t, char>;
#endif


================================================
FILE: Libraries/scintilla/src/RunStyles.h
================================================
/** @file RunStyles.h
 ** Data structure used to store sparse styles.
 **/
// Copyright 1998-2007 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

/// Styling buffer using one element for each run rather than using
/// a filled buffer.

#ifndef RUNSTYLES_H
#define RUNSTYLES_H

namespace Scintilla::Internal {

// Return for RunStyles::FillRange reports if anything was changed and the
// range that was changed. This may be trimmed from the requested range
// when some of the requested range already had the requested value.
template <typename DISTANCE>
struct FillResult {
	bool changed;
	DISTANCE position;
	DISTANCE fillLength;
};

template <typename DISTANCE, typename STYLE>
class RunStyles {
private:
	Partitioning<DISTANCE> starts;
	SplitVector<STYLE> styles;
	DISTANCE RunFromPosition(DISTANCE position) const noexcept;
	DISTANCE SplitRun(DISTANCE position);
	void RemoveRun(DISTANCE run);
	void RemoveRunIfEmpty(DISTANCE run);
	void RemoveRunIfSameAsPrevious(DISTANCE run);
public:
	RunStyles();
	DISTANCE Length() const noexcept;
	STYLE ValueAt(DISTANCE position) const noexcept;
	DISTANCE FindNextChange(DISTANCE position, DISTANCE end) const noexcept;
	DISTANCE StartRun(DISTANCE position) const noexcept;
	DISTANCE EndRun(DISTANCE position) const noexcept;
	// Returns changed=true if some values may have changed
	FillResult<DISTANCE> FillRange(DISTANCE position, STYLE value, DISTANCE fillLength);
	void SetValueAt(DISTANCE position, STYLE value);
	void InsertSpace(DISTANCE position, DISTANCE insertLength);
	void DeleteAll();
	void DeleteRange(DISTANCE position, DISTANCE deleteLength);
	DISTANCE Runs() const noexcept;
	bool AllSame() const noexcept;
	bool AllSameAs(STYLE value) const noexcept;
	DISTANCE Find(STYLE value, DISTANCE start) const noexcept;

	void Check() const;
};

}

#endif


================================================
FILE: Libraries/scintilla/src/ScintillaBase.cxx
================================================
// Scintilla source code edit control
/** @file ScintillaBase.cxx
 ** An enhanced subclass of Editor with calltips, autocomplete and context menu.
 **/
// Copyright 1998-2003 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#include <cstddef>
#include <cstdlib>
#include <cstdint>
#include <cassert>
#include <cstring>
#include <cmath>

#include <stdexcept>
#include <string>
#include <string_view>
#include <vector>
#include <map>
#include <set>
#include <optional>
#include <algorithm>
#include <memory>

#include "ScintillaTypes.h"
#include "ScintillaMessages.h"
#include "ScintillaStructures.h"
#include "ILoader.h"
#include "ILexer.h"

#include "Debugging.h"
#include "Geometry.h"
#include "Platform.h"

#include "CharacterCategoryMap.h"

#include "Position.h"
#include "UniqueString.h"
#include "SplitVector.h"
#include "Partitioning.h"
#include "RunStyles.h"
#include "ContractionState.h"
#include "CellBuffer.h"
#include "CallTip.h"
#include "KeyMap.h"
#include "Indicator.h"
#include "LineMarker.h"
#include "Style.h"
#include "ViewStyle.h"
#include "CharClassify.h"
#include "Decoration.h"
#include "CaseFolder.h"
#include "Document.h"
#include "Selection.h"
#include "PositionCache.h"
#include "EditModel.h"
#include "MarginView.h"
#include "EditView.h"
#include "Editor.h"
#include "AutoComplete.h"
#include "ScintillaBase.h"

using namespace Scintilla;
using namespace Scintilla::Internal;

ScintillaBase::ScintillaBase() {
	displayPopupMenu = PopUp::All;
	listType = 0;
	maxListWidth = 0;
	multiAutoCMode = MultiAutoComplete::Once;
}

ScintillaBase::~ScintillaBase() = default;

void ScintillaBase::Finalise() {
	Editor::Finalise();
	popup.Destroy();
}

void ScintillaBase::InsertCharacter(std::string_view sv, CharacterSource charSource) {
	const bool acActive = ac.Active();
	const bool isFillUp = acActive && ac.IsFillUpChar(sv[0]);
	if (!isFillUp) {
		Editor::InsertCharacter(sv, charSource);
	}
	if (acActive && ac.Active()) { // if it was and still is active
		AutoCompleteCharacterAdded(sv[0]);
		// For fill ups add the character after the autocompletion has
		// triggered so containers see the key so can display a calltip.
		if (isFillUp) {
			Editor::InsertCharacter(sv, charSource);
		}
	}
}

void ScintillaBase::Command(int cmdId) {

	switch (cmdId) {

	case idAutoComplete:  	// Nothing to do

		break;

	case idCallTip:  	// Nothing to do

		break;

	case idcmdUndo:
		WndProc(Message::Undo, 0, 0);
		break;

	case idcmdRedo:
		WndProc(Message::Redo, 0, 0);
		break;

	case idcmdCut:
		WndProc(Message::Cut, 0, 0);
		break;

	case idcmdCopy:
		WndProc(Message::Copy, 0, 0);
		break;

	case idcmdPaste:
		WndProc(Message::Paste, 0, 0);
		break;

	case idcmdDelete:
		WndProc(Message::Clear, 0, 0);
		break;

	case idcmdSelectAll:
		WndProc(Message::SelectAll, 0, 0);
		break;

	default:
		break;
	}
}

int ScintillaBase::KeyCommand(Message iMessage) {
	// Most key commands cancel autocompletion mode
	if (ac.Active()) {
		switch (iMessage) {
			// Except for these
		case Message::LineDown:
			AutoCompleteMove(1);
			return 0;
		case Message::LineUp:
			AutoCompleteMove(-1);
			return 0;
		case Message::PageDown:
			AutoCompleteMove(ac.lb->GetVisibleRows());
			return 0;
		case Message::PageUp:
			AutoCompleteMove(-ac.lb->GetVisibleRows());
			return 0;
		case Message::VCHome:
			AutoCompleteMove(-5000);
			return 0;
		case Message::LineEnd:
			AutoCompleteMove(5000);
			return 0;
		case Message::DeleteBack:
			DelCharBack(true);
			AutoCompleteCharacterDeleted();
			EnsureCaretVisible();
			return 0;
		case Message::DeleteBackNotLine:
			DelCharBack(false);
			AutoCompleteCharacterDeleted();
			EnsureCaretVisible();
			return 0;
		case Message::Tab:
			AutoCompleteCompleted(0, CompletionMethods::Tab);
			return 0;
		case Message::NewLine:
			AutoCompleteCompleted(0, CompletionMethods::Newline);
			return 0;

		default:
			AutoCompleteCancel();
		}
	}

	if (ct.inCallTipMode) {
		if (
		    (iMessage != Message::CharLeft) &&
		    (iMessage != Message::CharLeftExtend) &&
		    (iMessage != Message::CharRight) &&
		    (iMessage != Message::CharRightExtend) &&
		    (iMessage != Message::EditToggleOvertype) &&
		    (iMessage != Message::DeleteBack) &&
		    (iMessage != Message::DeleteBackNotLine)
		) {
			ct.CallTipCancel();
		}
		if ((iMessage == Message::DeleteBack) || (iMessage == Message::DeleteBackNotLine)) {
			if (sel.MainCaret() <= ct.posStartCallTip) {
				ct.CallTipCancel();
			}
		}
	}
	return Editor::KeyCommand(iMessage);
}

void ScintillaBase::ListNotify(ListBoxEvent *plbe) {
	switch (plbe->event) {
	case ListBoxEvent::EventType::selectionChange:
		AutoCompleteSelection();
		break;
	case ListBoxEvent::EventType::doubleClick:
		AutoCompleteCompleted(0, CompletionMethods::DoubleClick);
		break;
	}
}

void ScintillaBase::MoveImeCarets(Sci::Position offset) noexcept {
	// Move carets relatively by bytes.
	for (size_t r = 0; r < sel.Count(); r++) {
		const Sci::Position positionInsert = sel.Range(r).Start().Position();
		sel.Range(r) = SelectionRange(positionInsert + offset);
	}
}

void ScintillaBase::DrawImeIndicator(int indicator, Sci::Position len) {
	// Emulate the visual style of IME characters with indicators.
	// Draw an indicator on the character before caret by the character bytes of len
	// so it should be called after InsertCharacter().
	// It does not affect caret positions.
	const IndicatorNumbers ind = static_cast<IndicatorNumbers>(indicator);
	if (ind < IndicatorNumbers::Container || ind > IndicatorNumbers::Max) {
		return;
	}
	pdoc->DecorationSetCurrentIndicator(indicator);
	for (size_t r = 0; r < sel.Count(); r++) {
		const Sci::Position positionInsert = sel.Range(r).Start().Position();
		pdoc->DecorationFillRange(positionInsert - len, 1, len);
	}
}

void ScintillaBase::AutoCompleteInsert(Sci::Position startPos, Sci::Position removeLen, std::string_view text) {
	UndoGroup ug(pdoc);
	if (multiAutoCMode == MultiAutoComplete::Once) {
		pdoc->DeleteChars(startPos, removeLen);
		const Sci::Position lengthInserted = pdoc->InsertString(startPos, text);
		SetEmptySelection(startPos + lengthInserted);
	} else {
		// MultiAutoComplete::Each
		for (size_t r=0; r<sel.Count(); r++) {
			if (!RangeContainsProtected(sel.Range(r))) {
				Sci::Position positionInsert = sel.Range(r).Start().Position();
				positionInsert = RealizeVirtualSpace(positionInsert, sel.Range(r).caret.VirtualSpace());
				if (positionInsert - removeLen >= 0) {
					positionInsert -= removeLen;
					pdoc->DeleteChars(positionInsert, removeLen);
				}
				const Sci::Position lengthInserted = pdoc->InsertString(positionInsert, text);
				if (lengthInserted > 0) {
					sel.Range(r) = SelectionRange(positionInsert + lengthInserted);
				}
				sel.Range(r).ClearVirtualSpace();
			}
		}
	}
}

void ScintillaBase::AutoCompleteStart(Sci::Position lenEntered, const char *list) {
	//Platform::DebugPrintf("AutoComplete %s\n", list);
	ct.CallTipCancel();

	if (ac.chooseSingle && (listType == 0)) {
		if (list && !strchr(list, ac.GetSeparator())) {
			// list contains just one item so choose it
			const std::string_view item(list);
			const std::string_view choice = item.substr(0, item.find_first_of(ac.GetTypesep()));
			if (ac.ignoreCase) {
				// May need to convert the case before invocation, so remove lenEntered characters
				AutoCompleteInsert(sel.MainCaret() - lenEntered, lenEntered, choice);
			} else {
				AutoCompleteInsert(sel.MainCaret(), 0, choice.substr(lenEntered));
			}
			const Sci::Position firstPos = sel.MainCaret() - lenEntered;
			// Construct a string with a NUL at end as that is expected by applications
			const std::string selected(choice);
			AutoCompleteNotifyCompleted('\0', CompletionMethods::SingleChoice, firstPos, selected.c_str());

			ac.Cancel();
			return;
		}
	}

	const ListOptions options{
		vs.ElementColour(Element::List),
		vs.ElementColour(Element::ListBack),
		vs.ElementColour(Element::ListSelected),
		vs.ElementColour(Element::ListSelectedBack),
		ac.options,
		ac.imageScale,
	};

	int lineHeight;
	if (vs.autocStyle != StyleDefault) {
		AutoSurface surfaceMeasure(this);
		lineHeight = static_cast<int>(std::lround(surfaceMeasure->Height(vs.styles[vs.autocStyle].font.get())));
	} else {
		lineHeight = vs.lineHeight;
	}

	ac.Start(wMain, idAutoComplete, sel.MainCaret(), PointMainCaret(),
				lenEntered, lineHeight, IsUnicodeMode(), technology, options);

	const PRectangle rcClient = GetClientRectangle();
	Point pt = LocationFromPosition(sel.MainCaret() - lenEntered);
	PRectangle rcPopupBounds = wMain.GetMonitorRect(pt);
	if (rcPopupBounds.Height() == 0)
		rcPopupBounds = rcClient;

	int heightLB = ac.heightLBDefault;
	int widthLB = ac.widthLBDefault;
	if (pt.x >= rcClient.right - widthLB) {
		HorizontalScrollTo(static_cast<int>(xOffset + pt.x - rcClient.right + widthLB));
		Redraw();
		pt = PointMainCaret();
	}
	if (wMargin.Created()) {
		pt = pt + GetVisibleOriginInMain();
	}
	PRectangle rcac;
	rcac.left = pt.x - ac.lb->CaretFromEdge();
	if (pt.y >= rcPopupBounds.bottom - heightLB &&  // Won't fit below.
	        pt.y >= (rcPopupBounds.bottom + rcPopupBounds.top) / 2) { // and there is more room above.
		rcac.top = pt.y - heightLB;
		if (rcac.top < rcPopupBounds.top) {
			heightLB -= static_cast<int>(rcPopupBounds.top - rcac.top);
			rcac.top = rcPopupBounds.top;
		}
	} else {
		rcac.top = pt.y + vs.lineHeight;
	}
	rcac.right = rcac.left + widthLB;
	rcac.bottom = static_cast<XYPOSITION>(std::min(static_cast<int>(rcac.top) + heightLB, static_cast<int>(rcPopupBounds.bottom)));
	ac.lb->SetPositionRelative(rcac, &wMain);
	ac.lb->SetFont(vs.styles[vs.autocStyle].font.get());
	const int aveCharWidth = static_cast<int>(vs.styles[vs.autocStyle].aveCharWidth);
	ac.lb->SetAverageCharWidth(aveCharWidth);
	ac.lb->SetDelegate(this);

	ac.SetList(list ? list : "");

	// Fiddle the position of the list so it is right next to the target and wide enough for all its strings
	PRectangle rcList = ac.lb->GetDesiredRect();
	const int heightAlloced = static_cast<int>(rcList.bottom - rcList.top);
	widthLB = std::max(widthLB, static_cast<int>(rcList.right - rcList.left));
	if (maxListWidth != 0)
		widthLB = std::min(widthLB, aveCharWidth*maxListWidth);
	// Make an allowance for large strings in list
	rcList.left = pt.x - ac.lb->CaretFromEdge();
	rcList.right = rcList.left + widthLB;
	if (((pt.y + vs.lineHeight) >= (rcPopupBounds.bottom - heightAlloced)) &&  // Won't fit below.
	        ((pt.y + vs.lineHeight / 2) >= (rcPopupBounds.bottom + rcPopupBounds.top) / 2)) { // and there is more room above.
		rcList.top = pt.y - heightAlloced;
	} else {
		rcList.top = pt.y + vs.lineHeight;
	}
	rcList.bottom = rcList.top + heightAlloced;
	ac.lb->SetPositionRelative(rcList, &wMain);
	ac.Show(true);
	if (lenEntered != 0) {
		AutoCompleteMoveToCurrentWord();
	}
}

void ScintillaBase::AutoCompleteCancel() {
	if (ac.Active()) {
		NotificationData scn = {};
		scn.nmhdr.code = Notification::AutoCCancelled;
		scn.wParam = 0;
		scn.listType = 0;
		NotifyParent(scn);
	}
	ac.Cancel();
}

void ScintillaBase::AutoCompleteMove(int delta) {
	ac.Move(delta);
}

void ScintillaBase::AutoCompleteMoveToCurrentWord() {
	if (FlagSet(ac.options, AutoCompleteOption::SelectFirstItem))
		return;
	std::string wordCurrent = RangeText(ac.posStart - ac.startLen, sel.MainCaret());
	ac.Select(wordCurrent.c_str());
}

void ScintillaBase::AutoCompleteSelection() {
	const int item = ac.GetSelection();
	std::string selected;
	if (item != -1) {
		selected = ac.GetValue(item);
	}

	NotificationData scn = {};
	scn.nmhdr.code = Notification::AutoCSelectionChange;
	scn.message = static_cast<Message>(0);
	scn.wParam = listType;
	scn.listType = listType;
	const Sci::Position firstPos = ac.posStart - ac.startLen;
	scn.position = firstPos;
	scn.lParam = firstPos;
	scn.text = selected.c_str();
	NotifyParent(scn);
}

void ScintillaBase::AutoCompleteCharacterAdded(char ch) {
	if (ac.IsFillUpChar(ch)) {
		AutoCompleteCompleted(ch, CompletionMethods::FillUp);
	} else if (ac.IsStopChar(ch)) {
		AutoCompleteCancel();
	} else {
		AutoCompleteMoveToCurrentWord();
	}
}

void ScintillaBase::AutoCompleteCharacterDeleted() {
	if (sel.MainCaret() < ac.posStart - ac.startLen) {
		AutoCompleteCancel();
	} else if (ac.cancelAtStartPos && (sel.MainCaret() <= ac.posStart)) {
		AutoCompleteCancel();
	} else {
		AutoCompleteMoveToCurrentWord();
	}
	NotificationData scn = {};
	scn.nmhdr.code = Notification::AutoCCharDeleted;
	scn.wParam = 0;
	scn.listType = 0;
	NotifyParent(scn);
}

void ScintillaBase::AutoCompleteNotifyCompleted(char ch, CompletionMethods completionMethod, Sci::Position firstPos, const char *text) {
	NotificationData scn = {};
	scn.nmhdr.code = Notification::AutoCCompleted;
	scn.message = static_cast<Message>(0);
	scn.ch = ch;
	scn.listCompletionMethod = completionMethod;
	scn.wParam = listType;
	scn.listType = listType;
	scn.position = firstPos;
	scn.lParam = firstPos;
	scn.text = text;
	NotifyParent(scn);
}

void ScintillaBase::AutoCompleteCompleted(char ch, CompletionMethods completionMethod) {
	const int item = ac.GetSelection();
	if (item == -1) {
		AutoCompleteCancel();
		return;
	}
	const std::string selected = ac.GetValue(item);

	ac.Show(false);

	NotificationData scn = {};
	scn.nmhdr.code = listType > 0 ? Notification::UserListSelection : Notification::AutoCSelection;
	scn.message = static_cast<Message>(0);
	scn.ch = ch;
	scn.listCompletionMethod = completionMethod;
	scn.wParam = listType;
	scn.listType = listType;
	const Sci::Position firstPos = ac.posStart - ac.startLen;
	scn.position = firstPos;
	scn.lParam = firstPos;
	scn.text = selected.c_str();
	NotifyParent(scn);

	if (!ac.Active())
		return;
	ac.Cancel();

	if (listType > 0)
		return;

	Sci::Position endPos = sel.MainCaret();
	if (ac.dropRestOfWord)
		endPos = pdoc->ExtendWordSelect(endPos, 1, true);
	if (endPos < firstPos)
		return;
	AutoCompleteInsert(firstPos, endPos - firstPos, selected);
	SetLastXChosen();

	AutoCompleteNotifyCompleted(ch, completionMethod, firstPos, selected.c_str());
}

int ScintillaBase::AutoCompleteGetCurrent() const {
	if (!ac.Active())
		return -1;
	return ac.GetSelection();
}

int ScintillaBase::AutoCompleteGetCurrentText(char *buffer) const {
	if (ac.Active()) {
		const int item = ac.GetSelection();
		if (item != -1) {
			const std::string selected = ac.GetValue(item);
			if (buffer)
				memcpy(buffer, selected.c_str(), selected.length()+1);
			return static_cast<int>(selected.length());
		}
	}
	if (buffer)
		*buffer = '\0';
	return 0;
}

void ScintillaBase::CallTipShow(Point pt, const char *defn) {
	ac.Cancel();
	// If container knows about StyleCallTip then use it in place of the
	// StyleDefault for the face name, size and character set. Also use it
	// for the foreground and background colour.
	const int ctStyle = ct.UseStyleCallTip() ? StyleCallTip : StyleDefault;
	const Style &style = vs.styles[ctStyle];
	if (ct.UseStyleCallTip()) {
		ct.SetForeBack(style.fore, style.back);
	}
	if (wMargin.Created()) {
		pt = pt + GetVisibleOriginInMain();
	}
	AutoSurface surfaceMeasure(this);
	PRectangle rc = ct.CallTipStart(sel.MainCaret(), pt,
		vs.lineHeight,
		defn,
		CodePage(),
		surfaceMeasure,
		style.font);
	// If the call-tip window would be out of the client
	// space
	const PRectangle rcClient = GetClientRectangle();
	const int offset = vs.lineHeight + static_cast<int>(rc.Height());
	// adjust so it displays above the text.
	if (rc.bottom > rcClient.bottom && rc.Height() < rcClient.Height()) {
		rc.top -= offset;
		rc.bottom -= offset;
	}
	// adjust so it displays below the text.
	if (rc.top < rcClient.top && rc.Height() < rcClient.Height()) {
		rc.top += offset;
		rc.bottom += offset;
	}
	// Now display the window.
	CreateCallTipWindow(rc);
	ct.wCallTip.SetPositionRelative(rc, &wMain);
	ct.wCallTip.Show();
	ct.wCallTip.InvalidateAll();
}

void ScintillaBase::CallTipClick() {
	NotificationData scn = {};
	scn.nmhdr.code = Notification::CallTipClick;
	scn.position = ct.clickPlace;
	NotifyParent(scn);
}

bool ScintillaBase::ShouldDisplayPopup(Point ptInWindowCoordinates) const {
	return (displayPopupMenu == PopUp::All ||
		(displayPopupMenu == PopUp::Text && !PointInSelMargin(ptInWindowCoordinates)));
}

void ScintillaBase::ContextMenu(Point pt) {
	if (displayPopupMenu != PopUp::Never) {
		const bool writable = !WndProc(Message::GetReadOnly, 0, 0);
		popup.CreatePopUp();
		AddToPopUp("Undo", idcmdUndo, writable && pdoc->CanUndo());
		AddToPopUp("Redo", idcmdRedo, writable && pdoc->CanRedo());
		AddToPopUp("");
		AddToPopUp("Cut", idcmdCut, writable && !sel.Empty());
		AddToPopUp("Copy", idcmdCopy, !sel.Empty());
		AddToPopUp("Paste", idcmdPaste, writable && WndProc(Message::CanPaste, 0, 0));
		AddToPopUp("Delete", idcmdDelete, writable && !sel.Empty());
		AddToPopUp("");
		AddToPopUp("Select All", idcmdSelectAll);
		popup.Show(pt, wMain);
	}
}

void ScintillaBase::CancelModes() {
	AutoCompleteCancel();
	ct.CallTipCancel();
	Editor::CancelModes();
}

void ScintillaBase::ButtonDownWithModifiers(Point pt, unsigned int curTime, KeyMod modifiers) {
	CancelModes();
	Editor::ButtonDownWithModifiers(pt, curTime, modifiers);
}

void ScintillaBase::RightButtonDownWithModifiers(Point pt, unsigned int curTime, KeyMod modifiers) {
	CancelModes();
	Editor::RightButtonDownWithModifiers(pt, curTime, modifiers);
}

namespace Scintilla::Internal {

class LexState : public LexInterface {
public:
	explicit LexState(Document *pdoc_) noexcept;

	// LexInterface deleted the standard operators and defined the virtual destructor so don't need to here.

	const char *DescribeWordListSets();
	void SetWordList(int n, const char *wl);
	[[nodiscard]] int GetIdentifier() const;
	[[nodiscard]] const char *GetName() const;
	void *PrivateCall(int operation, void *pointer);
	const char *PropertyNames();
	TypeProperty PropertyType(const char *name);
	const char *DescribeProperty(const char *name);
	void PropSet(const char *key, const char *val);
	const char *PropGet(const char *key) const;
	int PropGetInt(const char *key, int defaultValue=0) const;

	LineEndType LineEndTypesSupported() override;
	int AllocateSubStyles(int styleBase, int numberStyles);
	int SubStylesStart(int styleBase);
	int SubStylesLength(int styleBase);
	int StyleFromSubStyle(int subStyle);
	int PrimaryStyleFromStyle(int style);
	void FreeSubStyles();
	void SetIdentifiers(int style, const char *identifiers);
	int DistanceToSecondaryStyles();
	const char *GetSubStyleBases();
	int NamedStyles();
	const char *NameOfStyle(int style);
	const char *TagsOfStyle(int style);
	const char *DescriptionOfStyle(int style);
};

}

LexState::LexState(Document *pdoc_) noexcept : LexInterface(pdoc_) {
}

LexState *ScintillaBase::DocumentLexState() {
	if (!pdoc->GetLexInterface()) {
		pdoc->SetLexInterface(std::make_unique<LexState>(pdoc));
	}
	return dynamic_cast<LexState *>(pdoc->GetLexInterface());
}

const char *LexState::DescribeWordListSets() {
	if (instance) {
		return instance->DescribeWordListSets();
	}
	return nullptr;
}

void LexState::SetWordList(int n, const char *wl) {
	if (instance) {
		const Sci_Position firstModification = instance->WordListSet(n, wl);
		if (firstModification >= 0) {
			pdoc->ModifiedAt(firstModification);
		}
	}
}

int LexState::GetIdentifier() const {
	if (instance) {
		return instance->GetIdentifier();
	}
	return 0;
}

const char *LexState::GetName() const {
	if (instance) {
		return instance->GetName();
	}
	return "";
}

void *LexState::PrivateCall(int operation, void *pointer) {
	if (instance) {
		return instance->PrivateCall(operation, pointer);
	}
	return nullptr;
}

const char *LexState::PropertyNames() {
	if (instance) {
		return instance->PropertyNames();
	}
	return nullptr;
}

TypeProperty LexState::PropertyType(const char *name) {
	if (instance) {
		return static_cast<TypeProperty>(instance->PropertyType(name));
	}
	return TypeProperty::Boolean;
}

const char *LexState::DescribeProperty(const char *name) {
	if (instance) {
		return instance->DescribeProperty(name);
	}
	return nullptr;
}

void LexState::PropSet(const char *key, const char *val) {
	if (instance) {
		const Sci_Position firstModification = instance->PropertySet(key, val);
		if (firstModification >= 0) {
			pdoc->ModifiedAt(firstModification);
		}
	}
}

const char *LexState::PropGet(const char *key) const {
	if (instance) {
		return instance->PropertyGet(key);
	}
	return nullptr;
}

int LexState::PropGetInt(const char *key, int defaultValue) const {
	if (instance) {
		const char *value = instance->PropertyGet(key);
		if (value && *value) {
			return atoi(value);
		}
	}
	return defaultValue;
}

LineEndType LexState::LineEndTypesSupported() {
	if (instance) {
		return static_cast<LineEndType>(instance->LineEndTypesSupported());
	}
	return LineEndType::Default;
}

int LexState::AllocateSubStyles(int styleBase, int numberStyles) {
	if (instance) {
		return instance->AllocateSubStyles(styleBase, numberStyles);
	}
	return -1;
}

int LexState::SubStylesStart(int styleBase) {
	if (instance) {
		return instance->SubStylesStart(styleBase);
	}
	return -1;
}

int LexState::SubStylesLength(int styleBase) {
	if (instance) {
		return instance->SubStylesLength(styleBase);
	}
	return 0;
}

int LexState::StyleFromSubStyle(int subStyle) {
	if (instance) {
		return instance->StyleFromSubStyle(subStyle);
	}
	return 0;
}

int LexState::PrimaryStyleFromStyle(int style) {
	if (instance) {
		return instance->PrimaryStyleFromStyle(style);
	}
	return 0;
}

void LexState::FreeSubStyles() {
	if (instance) {
		instance->FreeSubStyles();
	}
}

void LexState::SetIdentifiers(int style, const char *identifiers) {
	if (instance) {
		instance->SetIdentifiers(style, identifiers);
		pdoc->ModifiedAt(0);
	}
}

int LexState::DistanceToSecondaryStyles() {
	if (instance) {
		return instance->DistanceToSecondaryStyles();
	}
	return 0;
}

const char *LexState::GetSubStyleBases() {
	if (instance) {
		return instance->GetSubStyleBases();
	}
	return "";
}

int LexState::NamedStyles() {
	if (instance) {
		return instance->NamedStyles();
	}
	return -1;
}

const char *LexState::NameOfStyle(int style) {
	if (instance) {
		return instance->NameOfStyle(style);
	}
	return nullptr;
}

const char *LexState::TagsOfStyle(int style) {
	if (instance) {
		return instance->TagsOfStyle(style);
	}
	return nullptr;
}

const char *LexState::DescriptionOfStyle(int style) {
	if (instance) {
		return instance->DescriptionOfStyle(style);
	}
	return nullptr;
}

void ScintillaBase::NotifyStyleToNeeded(Sci::Position endStyleNeeded) {
	if (!DocumentLexState()->UseContainerLexing()) {
		const Sci::Position startStyling = pdoc->LineStartPosition(pdoc->GetEndStyled());
		DocumentLexState()->Colourise(startStyling, endStyleNeeded);
		return;
	}
	Editor::NotifyStyleToNeeded(endStyleNeeded);
}

sptr_t ScintillaBase::WndProc(Message iMessage, uptr_t wParam, sptr_t lParam) {
	switch (iMessage) {
	case Message::AutoCShow:
		listType = 0;
		AutoCompleteStart(PositionFromUPtr(wParam), ConstCharPtrFromSPtr(lParam));
		break;

	case Message::AutoCCancel:
		ac.Cancel();
		break;

	case Message::AutoCActive:
		return ac.Active();

	case Message::AutoCPosStart:
		return ac.posStart;

	case Message::AutoCComplete:
		AutoCompleteCompleted(0, CompletionMethods::Command);
		break;

	case Message::AutoCSetSeparator:
		ac.SetSeparator(static_cast<char>(wParam));
		break;

	case Message::AutoCGetSeparator:
		return ac.GetSeparator();

	case Message::AutoCStops:
		ac.SetStopChars(ConstCharPtrFromSPtr(lParam));
		break;

	case Message::AutoCSelect:
		ac.Select(ConstCharPtrFromSPtr(lParam));
		break;

	case Message::AutoCGetCurrent:
		return AutoCompleteGetCurrent();

	case Message::AutoCGetCurrentText:
		return AutoCompleteGetCurrentText(CharPtrFromSPtr(lParam));

	case Message::AutoCSetCancelAtStart:
		ac.cancelAtStartPos = wParam != 0;
		break;

	case Message::AutoCGetCancelAtStart:
		return ac.cancelAtStartPos;

	case Message::AutoCSetFillUps:
		ac.SetFillUpChars(ConstCharPtrFromSPtr(lParam));
		break;

	case Message::AutoCSetChooseSingle:
		ac.chooseSingle = wParam != 0;
		break;

	case Message::AutoCGetChooseSingle:
		return ac.chooseSingle;

	case Message::AutoCSetIgnoreCase:
		ac.ignoreCase = wParam != 0;
		break;

	case Message::AutoCGetIgnoreCase:
		return ac.ignoreCase;

	case Message::AutoCSetCaseInsensitiveBehaviour:
		ac.ignoreCaseBehaviour = static_cast<CaseInsensitiveBehaviour>(wParam);
		break;

	case Message::AutoCGetCaseInsensitiveBehaviour:
		return static_cast<sptr_t>(ac.ignoreCaseBehaviour);

	case Message::AutoCSetMulti:
		multiAutoCMode = static_cast<MultiAutoComplete>(wParam);
		break;

	case Message::AutoCGetMulti:
		return static_cast<sptr_t>(multiAutoCMode);

	case Message::AutoCSetOrder:
		ac.autoSort = static_cast<Ordering>(wParam);
		break;

	case Message::AutoCGetOrder:
		return static_cast<sptr_t>(ac.autoSort);

	case Message::UserListShow:
		listType = static_cast<int>(wParam);
		AutoCompleteStart(0, ConstCharPtrFromSPtr(lParam));
		break;

	case Message::AutoCSetAutoHide:
		ac.autoHide = wParam != 0;
		break;

	case Message::AutoCGetAutoHide:
		return ac.autoHide;

	case Message::AutoCSetOptions:
		ac.options = static_cast<AutoCompleteOption>(wParam);
		break;

	case Message::AutoCGetOptions:
		return static_cast<sptr_t>(ac.options);

	case Message::AutoCSetDropRestOfWord:
		ac.dropRestOfWord = wParam != 0;
		break;

	case Message::AutoCGetDropRestOfWord:
		return ac.dropRestOfWord;

	case Message::AutoCSetMaxHeight:
		ac.lb->SetVisibleRows(static_cast<int>(wParam));
		break;

	case Message::AutoCGetMaxHeight:
		return ac.lb->GetVisibleRows();

	case Message::AutoCSetMaxWidth:
		maxListWidth = static_cast<int>(wParam);
		break;

	case Message::AutoCGetMaxWidth:
		return maxListWidth;

	case Message::AutoCSetStyle:
		vs.autocStyle = static_cast<int>(wParam);
		InvalidateStyleRedraw();
		break;

	case Message::AutoCGetStyle:
		return vs.autocStyle;

	case Message::AutoCSetImageScale:
		ac.imageScale = static_cast<float>(wParam) / 100.0f;
		break;

	case Message::AutoCGetImageScale:
		return static_cast<int>(ac.imageScale * 100);

	case Message::RegisterImage:
		ac.lb->RegisterImage(static_cast<int>(wParam), ConstCharPtrFromSPtr(lParam));
		break;

	case Message::RegisterRGBAImage:
		ac.lb->RegisterRGBAImage(static_cast<int>(wParam), static_cast<int>(sizeRGBAImage.x), static_cast<int>(sizeRGBAImage.y),
			ConstUCharPtrFromSPtr(lParam));
		break;

	case Message::ClearRegisteredImages:
		ac.lb->ClearRegisteredImages();
		break;

	case Message::AutoCSetTypeSeparator:
		ac.SetTypesep(static_cast<char>(wParam));
		break;

	case Message::AutoCGetTypeSeparator:
		return ac.GetTypesep();

	case Message::CallTipShow:
		CallTipShow(LocationFromPosition(wParam),
			ConstCharPtrFromSPtr(lParam));
		break;

	case Message::CallTipCancel:
		ct.CallTipCancel();
		break;

	case Message::CallTipActive:
		return ct.inCallTipMode;

	case Message::CallTipPosStart:
		return ct.posStartCallTip;

	case Message::CallTipSetPosStart:
		ct.posStartCallTip = wParam;
		break;

	case Message::CallTipSetHlt:
		ct.SetHighlight(wParam, lParam);
		break;

	case Message::CallTipSetBack:
		ct.colourBG = ColourRGBA::FromIpRGB(SPtrFromUPtr(wParam));
		vs.styles[StyleCallTip].back = ct.colourBG;
		InvalidateStyleRedraw();
		break;

	case Message::CallTipSetFore:
		ct.colourUnSel = ColourRGBA::FromIpRGB(SPtrFromUPtr(wParam));
		vs.styles[StyleCallTip].fore = ct.colourUnSel;
		InvalidateStyleRedraw();
		break;

	case Message::CallTipSetForeHlt:
		ct.colourSel = ColourRGBA::FromIpRGB(SPtrFromUPtr(wParam));
		InvalidateStyleRedraw();
		break;

	case Message::CallTipUseStyle:
		ct.SetTabSize(static_cast<int>(wParam));
		InvalidateStyleRedraw();
		break;

	case Message::CallTipSetPosition:
		ct.SetPosition(wParam != 0);
		InvalidateStyleRedraw();
		break;

	case Message::UsePopUp:
		displayPopupMenu = static_cast<PopUp>(wParam);
		break;

	case Message::GetLexer:
		return DocumentLexState()->GetIdentifier();

	case Message::SetILexer:
		DocumentLexState()->SetInstance(static_cast<ILexer5 *>(PtrFromSPtr(lParam)));
		return 0;

	case Message::Colourise:
		if (DocumentLexState()->UseContainerLexing()) {
			pdoc->ModifiedAt(PositionFromUPtr(wParam));
			NotifyStyleToNeeded((lParam == -1) ? pdoc->Length() : lParam);
		} else {
			DocumentLexState()->Colourise(PositionFromUPtr(wParam), lParam);
		}
		Redraw();
		break;

	case Message::SetProperty:
		DocumentLexState()->PropSet(ConstCharPtrFromUPtr(wParam),
		          ConstCharPtrFromSPtr(lParam));
		break;

	case Message::GetProperty:
		return StringResult(lParam, DocumentLexState()->PropGet(ConstCharPtrFromUPtr(wParam)));

	case Message::GetPropertyExpanded:
		return StringResult(lParam, DocumentLexState()->PropGet(ConstCharPtrFromUPtr(wParam)));

	case Message::GetPropertyInt:
		return DocumentLexState()->PropGetInt(ConstCharPtrFromUPtr(wParam), static_cast<int>(lParam));

	case Message::SetKeyWords:
		DocumentLexState()->SetWordList(static_cast<int>(wParam), ConstCharPtrFromSPtr(lParam));
		break;

	case Message::GetLexerLanguage:
		return StringResult(lParam, DocumentLexState()->GetName());

	case Message::PrivateLexerCall:
		return reinterpret_cast<sptr_t>(
			DocumentLexState()->PrivateCall(static_cast<int>(wParam), PtrFromSPtr(lParam)));

#ifdef INCLUDE_DEPRECATED_FEATURES
	case SCI_GETSTYLEBITSNEEDED:
		return 8;
#endif

	case Message::PropertyNames:
		return StringResult(lParam, DocumentLexState()->PropertyNames());

	case Message::PropertyType:
		return static_cast<sptr_t>(DocumentLexState()->PropertyType(ConstCharPtrFromUPtr(wParam)));

	case Message::DescribeProperty:
		return StringResult(lParam,
				    DocumentLexState()->DescribeProperty(ConstCharPtrFromUPtr(wParam)));

	case Message::DescribeKeyWordSets:
		return StringResult(lParam, DocumentLexState()->DescribeWordListSets());

	case Message::GetLineEndTypesSupported:
		return static_cast<sptr_t>(DocumentLexState()->LineEndTypesSupported());

	case Message::AllocateSubStyles:
		return DocumentLexState()->AllocateSubStyles(static_cast<int>(wParam), static_cast<int>(lParam));

	case Message::GetSubStylesStart:
		return DocumentLexState()->SubStylesStart(static_cast<int>(wParam));

	case Message::GetSubStylesLength:
		return DocumentLexState()->SubStylesLength(static_cast<int>(wParam));

	case Message::GetStyleFromSubStyle:
		return DocumentLexState()->StyleFromSubStyle(static_cast<int>(wParam));

	case Message::GetPrimaryStyleFromStyle:
		return DocumentLexState()->PrimaryStyleFromStyle(static_cast<int>(wParam));

	case Message::FreeSubStyles:
		DocumentLexState()->FreeSubStyles();
		break;

	case Message::SetIdentifiers:
		DocumentLexState()->SetIdentifiers(static_cast<int>(wParam),
						   ConstCharPtrFromSPtr(lParam));
		break;

	case Message::DistanceToSecondaryStyles:
		return DocumentLexState()->DistanceToSecondaryStyles();

	case Message::GetSubStyleBases:
		return StringResult(lParam, DocumentLexState()->GetSubStyleBases());

	case Message::GetNamedStyles:
		return DocumentLexState()->NamedStyles();

	case Message::NameOfStyle:
		return StringResult(lParam, DocumentLexState()->
				    NameOfStyle(static_cast<int>(wParam)));

	case Message::TagsOfStyle:
		return StringResult(lParam, DocumentLexState()->
				    TagsOfStyle(static_cast<int>(wParam)));

	case Message::DescriptionOfStyle:
		return StringResult(lParam, DocumentLexState()->
				    DescriptionOfStyle(static_cast<int>(wParam)));

	default:
		return Editor::WndProc(iMessage, wParam, lParam);
	}
	return 0;
}


================================================
FILE: Libraries/scintilla/src/ScintillaBase.h
================================================
// Scintilla source code edit control
/** @file ScintillaBase.h
 ** Defines an enhanced subclass of Editor with calltips, autocomplete and context menu.
 **/
// Copyright 1998-2002 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#ifndef SCINTILLABASE_H
#define SCINTILLABASE_H

namespace Scintilla::Internal {

// For most platforms (not Cocoa) all IME indicators are drawn in same colour,
// blue, with different patterns.
constexpr ColourRGBA colourIME(0x0, 0x0, 0xffU);

constexpr int IndicatorInput = static_cast<int>(Scintilla::IndicatorNumbers::Ime);
constexpr int IndicatorTarget = IndicatorInput + 1;
constexpr int IndicatorConverted = IndicatorInput + 2;
constexpr int IndicatorUnknown = IndicatorInput + 3;

class LexState;
/**
 */
class ScintillaBase : public Editor, IListBoxDelegate {
protected:
	/** Enumeration of commands and child windows. */
	enum {
		idCallTip=1,
		idAutoComplete=2,

		idcmdUndo=10,
		idcmdRedo=11,
		idcmdCut=12,
		idcmdCopy=13,
		idcmdPaste=14,
		idcmdDelete=15,
		idcmdSelectAll=16
	};

	Scintilla::PopUp displayPopupMenu;
	Menu popup;
	Scintilla::Internal::AutoComplete ac;

	CallTip ct;

	int listType;			///< 0 is an autocomplete list
	int maxListWidth;		/// Maximum width of list, in average character widths
	Scintilla::MultiAutoComplete multiAutoCMode; /// Mode for autocompleting when multiple selections are present

	LexState *DocumentLexState();
	void Colourise(int start, int end);

	ScintillaBase();
	// Deleted so ScintillaBase objects can not be copied.
	ScintillaBase(const ScintillaBase &) = delete;
	ScintillaBase(ScintillaBase &&) = delete;
	ScintillaBase &operator=(const ScintillaBase &) = delete;
	ScintillaBase &operator=(ScintillaBase &&) = delete;
	// ~ScintillaBase() in public section
	void Initialise() override {}
	void Finalise() override;

	void InsertCharacter(std::string_view sv, Scintilla::CharacterSource charSource) override;
	void Command(int cmdId);
	void CancelModes() override;
	int KeyCommand(Scintilla::Message iMessage) override;

	void MoveImeCarets(Sci::Position offset) noexcept;
	void DrawImeIndicator(int indicator, Sci::Position len);

	void AutoCompleteInsert(Sci::Position startPos, Sci::Position removeLen, std::string_view text);
	void AutoCompleteStart(Sci::Position lenEntered, const char *list);
	void AutoCompleteCancel();
	void AutoCompleteMove(int delta);
	int AutoCompleteGetCurrent() const;
	int AutoCompleteGetCurrentText(char *buffer) const;
	void AutoCompleteCharacterAdded(char ch);
	void AutoCompleteCharacterDeleted();
	void AutoCompleteNotifyCompleted(char ch, CompletionMethods completionMethod, Sci::Position firstPos, const char *text);
	void AutoCompleteCompleted(char ch, Scintilla::CompletionMethods completionMethod);
	void AutoCompleteMoveToCurrentWord();
	void AutoCompleteSelection();
	void ListNotify(ListBoxEvent *plbe) override;

	void CallTipClick();
	void CallTipShow(Point pt, const char *defn);
	virtual void CreateCallTipWindow(PRectangle rc) = 0;

	virtual void AddToPopUp(const char *label, int cmd=0, bool enabled=true) = 0;
	bool ShouldDisplayPopup(Point ptInWindowCoordinates) const;
	void ContextMenu(Point pt);

	void ButtonDownWithModifiers(Point pt, unsigned int curTime, Scintilla::KeyMod modifiers) override;
	void RightButtonDownWithModifiers(Point pt, unsigned int curTime, Scintilla::KeyMod modifiers) override;

	void NotifyStyleToNeeded(Sci::Position endStyleNeeded) override;

public:
	~ScintillaBase() override;

	// Public so scintilla_send_message can use it
	Scintilla::sptr_t WndProc(Scintilla::Message iMessage, Scintilla::uptr_t wParam, Scintilla::sptr_t lParam) override;
};

}

#endif


================================================
FILE: Libraries/scintilla/src/Selection.cxx
================================================
// Scintilla source code edit control
/** @file Selection.cxx
 ** Classes maintaining the selection.
 **/
// Copyright 2009 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#include <cstddef>
#include <cstdlib>

#include <stdexcept>
#include <string>
#include <string_view>
#include <vector>
#include <optional>
#include <algorithm>
#include <memory>
#include <charconv>

#include "Debugging.h"

#include "Position.h"
#include "Selection.h"

using namespace Scintilla::Internal;

namespace {

// Generically convert a string to a integer value throwing if the conversion failed.
// Failures include values that are out of range for the destination variable.
template <typename T>
void ValueFromString(std::string_view sv, T &value) {
	const std::from_chars_result res = std::from_chars(sv.data(), sv.data() + sv.size(), value);
	if (res.ec != std::errc{}) {
		if (res.ec == std::errc::result_out_of_range)
			throw std::runtime_error("from_chars out of range.");
		throw std::runtime_error("from_chars failed.");
	}
}

}

SelectionPosition::SelectionPosition(std::string_view sv) : position(0) {
	if (const size_t v = sv.find('v'); v != std::string_view::npos) {
		ValueFromString(sv.substr(v + 1), virtualSpace);
		sv = sv.substr(0, v);
	}
	ValueFromString(sv, position);
}

void SelectionPosition::MoveForInsertDelete(bool insertion, Sci::Position startChange, Sci::Position length, bool moveForEqual) noexcept {
	if (insertion) {
		if (position == startChange) {
			// Always consume virtual space
			const Sci::Position virtualLengthRemove = std::min(length, virtualSpace);
			virtualSpace -= virtualLengthRemove;
			position += virtualLengthRemove;
			if (moveForEqual) {
				const Sci::Position lengthAfterVirtualRemove = length - virtualLengthRemove;
				position += lengthAfterVirtualRemove;
			}
		} else if (position > startChange) {
			position += length;
		}
	} else {
		if (position == startChange) {
			virtualSpace = 0;
		}
		if (position > startChange) {
			const Sci::Position endDeletion = startChange + length;
			if (position > endDeletion) {
				position -= length;
			} else {
				position = startChange;
				virtualSpace = 0;
			}
		}
	}
}

bool SelectionPosition::operator >(const SelectionPosition &other) const noexcept {
	if (position == other.position)
		return virtualSpace > other.virtualSpace;
	return position > other.position;
}

bool SelectionPosition::operator <=(const SelectionPosition &other) const noexcept {
	if (other == *this)
		return true;
	return other > *this;
}

bool SelectionPosition::operator >=(const SelectionPosition &other) const noexcept {
	if (other == *this)
		return true;
	return *this > other;
}

double SelectionPosition::VirtualSpaceWidth(double spaceWidth) const noexcept {
	return static_cast<double>(virtualSpace) * spaceWidth;
}

std::string SelectionPosition::ToString() const {
	std::string result = std::to_string(position);
	if (virtualSpace) {
		result += 'v';
		result += std::to_string(virtualSpace);
	}
	return result;
}

SelectionRange::SelectionRange(std::string_view sv) {
	const size_t dash = sv.find('-');
	if (dash == std::string_view::npos) {
		anchor = SelectionPosition(sv);
		caret = anchor;
	} else {
		anchor = SelectionPosition(sv.substr(0, dash));
		caret = SelectionPosition(sv.substr(dash + 1));
	}
}

Sci::Position SelectionRange::Length() const noexcept {
	if (anchor > caret) {
		return anchor.Position() - caret.Position();
	} else {
		return caret.Position() - anchor.Position();
	}
}

void SelectionRange::MoveForInsertDelete(bool insertion, Sci::Position startChange, Sci::Position length) noexcept {
	// For insertions that occur at the start of the selection move both the start
	// and end of the selection to preserve the selected length.
	// The end will automatically move since it is after the insertion, so determine
	// which position is the start and pass this into
	// SelectionPosition::MoveForInsertDelete.
	// There isn't any reason to move an empty selection so don't move it.
	const bool caretStart = caret.Position() < anchor.Position();
	const bool anchorStart = anchor.Position() < caret.Position();

	caret.MoveForInsertDelete(insertion, startChange, length, caretStart);
	anchor.MoveForInsertDelete(insertion, startChange, length, anchorStart);
}

bool SelectionRange::Contains(Sci::Position pos) const noexcept {
	if (anchor > caret)
		return (pos >= caret.Position()) && (pos <= anchor.Position());
	else
		return (pos >= anchor.Position()) && (pos <= caret.Position());
}

bool SelectionRange::Contains(SelectionPosition sp) const noexcept {
	if (anchor > caret)
		return (sp >= caret) && (sp <= anchor);
	else
		return (sp >= anchor) && (sp <= caret);
}

bool SelectionRange::ContainsCharacter(Sci::Position posCharacter) const noexcept {
	if (anchor > caret)
		return (posCharacter >= caret.Position()) && (posCharacter < anchor.Position());
	else
		return (posCharacter >= anchor.Position()) && (posCharacter < caret.Position());
}

bool SelectionRange::ContainsCharacter(SelectionPosition spCharacter) const noexcept {
	if (anchor > caret)
		return (spCharacter >= caret) && (spCharacter < anchor);
	else
		return (spCharacter >= anchor) && (spCharacter < caret);
}

SelectionSegment SelectionRange::Intersect(SelectionSegment check) const noexcept {
	const SelectionSegment inOrder = AsSegment();
	if ((inOrder.start > check.end) || (inOrder.end < check.start)) {
		// Nothing in common, not even touching so return empty *invalid* segment
		return {};
	}
	return {
		std::max(check.start, inOrder.start),
		std::min(check.end, inOrder.end)
	};
}

void SelectionRange::Swap() noexcept {
	std::swap(caret, anchor);
}

bool SelectionRange::Trim(SelectionRange range) noexcept {
	const SelectionPosition startRange = range.Start();
	const SelectionPosition endRange = range.End();
	SelectionPosition start = Start();
	SelectionPosition end = End();
	PLATFORM_ASSERT(start <= end);
	PLATFORM_ASSERT(startRange <= endRange);
	if ((startRange <= end) && (endRange >= start)) {
		if ((start > startRange) && (end < endRange)) {
			// Completely covered by range -> empty at start
			end = start;
		} else if ((start < startRange) && (end > endRange)) {
			// Completely covers range -> empty at start
			end = start;
		} else if (start <= startRange) {
			// Trim end
			end = startRange;
		} else { //
			PLATFORM_ASSERT(end >= endRange);
			// Trim start
			start = endRange;
		}
		if (anchor > caret) {
			caret = start;
			anchor = end;
		} else {
			anchor = start;
			caret = end;
		}
		return Empty();
	}
	return false;
}

void SelectionRange::Truncate(Sci::Position length) noexcept {
	if (anchor.Position() > length)
		anchor.SetPosition(length);
	if (caret.Position() > length)
		caret.SetPosition(length);
}

// If range is all virtual collapse to start of virtual space
void SelectionRange::MinimizeVirtualSpace() noexcept {
	if (caret.Position() == anchor.Position()) {
		Sci::Position virtualSpace = caret.VirtualSpace();
		if (virtualSpace > anchor.VirtualSpace())
			virtualSpace = anchor.VirtualSpace();
		caret.SetVirtualSpace(virtualSpace);
		anchor.SetVirtualSpace(virtualSpace);
	}
}

std::string SelectionRange::ToString() const {
	std::string result = anchor.ToString();
	if (!(caret == anchor)) {
		result += '-';
		result += caret.ToString();
	}
	return result;
}

Selection::Selection() : mainRange(0), moveExtends(false), tentativeMain(false), selType(SelTypes::stream) {
	AddSelection(SelectionRange(SelectionPosition(0)));
}

Selection::Selection(std::string_view sv) : mainRange(0), moveExtends(false), tentativeMain(false), selType(SelTypes::stream) {
	if (sv.empty()) {
		return;
	}
	try {
		// Decode initial letter prefix if any
		switch (sv.front()) {
		case 'R':
			selType = SelTypes::rectangle;
			break;
		case 'L':
			selType = SelTypes::lines;
			break;
		case 'T':
			selType = SelTypes::thin;
			break;
		default:
			break;
		}
		if (selType != SelTypes::stream) {
			sv.remove_prefix(1);
		}

		// Non-zero main index at end after '#'
		if (const size_t hash = sv.find('#'); hash != std::string_view::npos) {
			ValueFromString(sv.substr(hash + 1), mainRange);
			sv = sv.substr(0, hash);
		}

		// Remainder is list of ranges
		if (selType == SelTypes::rectangle || selType == SelTypes::thin) {
			rangeRectangular = SelectionRange(sv);
			// Ensure enough ranges exist for mainRange to be in bounds
			for (size_t i = 0; i <= mainRange; i++) {
				ranges.emplace_back(SelectionPosition(0));
			}
		} else {
			size_t comma = sv.find(',');
			while (comma != std::string_view::npos) {
				ranges.emplace_back(sv.substr(0, comma));
				sv.remove_prefix(comma + 1);
				comma = sv.find(',');
			}
			ranges.emplace_back(sv);
			if (mainRange >= ranges.size()) {
				mainRange = ranges.size() - 1;
			}
		}
	} catch (std::runtime_error &) {
		// On failure, produce an empty selection.
		Clear();
	}
}

bool Selection::IsRectangular() const noexcept {
	return (selType == SelTypes::rectangle) || (selType == SelTypes::thin);
}

Sci::Position Selection::MainCaret() const noexcept {
	return ranges[mainRange].caret.Position();
}

Sci::Position Selection::MainAnchor() const noexcept {
	return ranges[mainRange].anchor.Position();
}

SelectionRange &Selection::Rectangular() noexcept {
	return rangeRectangular;
}

SelectionRange Selection::RectangularCopy() const noexcept {
	return rangeRectangular;
}

SelectionSegment Selection::Limits() const noexcept {
	PLATFORM_ASSERT(!ranges.empty());
	SelectionSegment sr = ranges[0].AsSegment();
	for (size_t i=1; i<ranges.size(); i++) {
		sr.Extend(ranges[i].anchor);
		sr.Extend(ranges[i].caret);
	}
	return sr;
}

SelectionSegment Selection::LimitsForRectangularElseMain() const noexcept {
	if (IsRectangular()) {
		return Limits();
	}
	return ranges[mainRange].AsSegment();
}

size_t Selection::Count() const noexcept {
	return ranges.size();
}

size_t Selection::Main() const noexcept {
	return mainRange;
}

void Selection::SetMain(size_t r) noexcept {
	PLATFORM_ASSERT(r < ranges.size());
	mainRange = r;
}

SelectionRange &Selection::Range(size_t r) noexcept {
	return ranges[r];
}

const SelectionRange &Selection::Range(size_t r) const noexcept {
	return ranges[r];
}

SelectionRange &Selection::RangeMain() noexcept {
	return ranges[mainRange];
}

const SelectionRange &Selection::RangeMain() const noexcept {
	return ranges[mainRange];
}

SelectionPosition Selection::Start() const noexcept {
	if (IsRectangular()) {
		return rangeRectangular.Start();
	}
	return ranges[mainRange].Start();
}

bool Selection::MoveExtends() const noexcept {
	return moveExtends;
}

void Selection::SetMoveExtends(bool moveExtends_) noexcept {
	moveExtends = moveExtends_;
}

bool Selection::Empty() const noexcept {
	for (const SelectionRange &range : ranges) {
		if (!range.Empty())
			return false;
	}
	return true;
}

SelectionPosition Selection::Last() const noexcept {
	SelectionPosition lastPosition;
	for (const SelectionRange &range : ranges) {
		if (lastPosition < range.caret)
			lastPosition = range.caret;
		if (lastPosition < range.anchor)
			lastPosition = range.anchor;
	}
	return lastPosition;
}

Sci::Position Selection::Length() const noexcept {
	Sci::Position len = 0;
	for (const SelectionRange &range : ranges) {
		len += range.Length();
	}
	return len;
}

void Selection::MovePositions(bool insertion, Sci::Position startChange, Sci::Position length) noexcept {
	for (SelectionRange &range : ranges) {
		range.MoveForInsertDelete(insertion, startChange, length);
	}
	if (selType == SelTypes::rectangle) {
		rangeRectangular.MoveForInsertDelete(insertion, startChange, length);
	}
}

void Selection::TrimSelection(SelectionRange range) noexcept {
	for (size_t i=0; i<ranges.size();) {
		if ((i != mainRange) && (ranges[i].Trim(range))) {
			// Trimmed to empty so remove
			for (size_t j=i; j<ranges.size()-1; j++) {
				ranges[j] = ranges[j+1];
				if (j == mainRange-1)
					mainRange--;
			}
			ranges.pop_back();
		} else {
			i++;
		}
	}
}

void Selection::TrimOtherSelections(size_t r, SelectionRange range) noexcept {
	for (size_t i = 0; i<ranges.size(); ++i) {
		if (i != r) {
			ranges[i].Trim(range);
		}
	}
}

void Selection::SetSelection(SelectionRange range) noexcept {
	if (ranges.size() > 1) {
		ranges.erase(ranges.begin() + 1, ranges.end());
	}
	ranges[0] = range;
	mainRange = 0;
}

void Selection::AddSelection(SelectionRange range) {
	TrimSelection(range);
	ranges.push_back(range);
	mainRange = ranges.size() - 1;
}

void Selection::AddSelectionWithoutTrim(SelectionRange range) {
	ranges.push_back(range);
	mainRange = ranges.size() - 1;
}

void Selection::DropSelection(size_t r) noexcept {
	if ((ranges.size() > 1) && (r < ranges.size())) {
		size_t mainNew = mainRange;
		if (mainNew >= r) {
			if (mainNew == 0) {
				mainNew = ranges.size() - 2;
			} else {
				mainNew--;
			}
		}
		ranges.erase(ranges.begin() + r);
		mainRange = mainNew;
	}
}

void Selection::DropAdditionalRanges() noexcept {
	SetSelection(RangeMain());
}

void Selection::TentativeSelection(SelectionRange range) {
	if (!tentativeMain) {
		rangesSaved = ranges;
	}
	ranges = rangesSaved;
	AddSelection(range);
	TrimSelection(ranges[mainRange]);
	tentativeMain = true;
}

void Selection::CommitTentative() noexcept {
	rangesSaved.clear();
	tentativeMain = false;
}

InSelection Selection::RangeType(size_t r) const noexcept {
	return r == Main() ? InSelection::inMain : InSelection::inAdditional;
}

InSelection Selection::CharacterInSelection(Sci::Position posCharacter) const noexcept {
	for (size_t i=0; i<ranges.size(); i++) {
		if (ranges[i].ContainsCharacter(posCharacter))
			return RangeType(i);
	}
	return InSelection::inNone;
}

InSelection Selection::InSelectionForEOL(Sci::Position pos) const noexcept {
	for (size_t i=0; i<ranges.size(); i++) {
		if (!ranges[i].Empty() && (pos > ranges[i].Start().Position()) && (pos <= ranges[i].End().Position()))
			return RangeType(i);
	}
	return InSelection::inNone;
}

Sci::Position Selection::VirtualSpaceFor(Sci::Position pos) const noexcept {
	Sci::Position virtualSpace = 0;
	for (const SelectionRange &range : ranges) {
		if ((range.caret.Position() == pos) && (virtualSpace < range.caret.VirtualSpace()))
			virtualSpace = range.caret.VirtualSpace();
		if ((range.anchor.Position() == pos) && (virtualSpace < range.anchor.VirtualSpace()))
			virtualSpace = range.anchor.VirtualSpace();
	}
	return virtualSpace;
}

void Selection::Clear() noexcept {
	if (ranges.size() > 1) {
		ranges.erase(ranges.begin() + 1, ranges.end());
	}
	ranges[0].Reset();
	rangesSaved.clear();
	rangeRectangular.Reset();
	mainRange = 0;
	moveExtends = false;
	tentativeMain = false;
	selType = SelTypes::stream;
}

void Selection::RemoveDuplicates() noexcept {
	for (size_t i=0; i<ranges.size()-1; i++) {
		if (ranges[i].Empty()) {
			size_t j=i+1;
			while (j<ranges.size()) {
				if (ranges[i] == ranges[j]) {
					ranges.erase(ranges.begin() + j);
					if (mainRange >= j)
						mainRange--;
				} else {
					j++;
				}
			}
		}
	}
}

void Selection::RotateMain() noexcept {
	mainRange = (mainRange + 1) % ranges.size();
}

void Selection::SetRanges(const Ranges &rangesToSet) {
	ranges = rangesToSet;
}

void Selection::Truncate(Sci::Position length) noexcept {
	// This may be needed when applying a persisted selection onto a document that has been shortened.
	for (SelectionRange &range : ranges) {
		range.Truncate(length);
	}
	// Above may have made some non-unique empty ranges.
	RemoveDuplicates();
	rangeRectangular.Truncate(length);
}

std::string Selection::ToString() const {
	std::string result;
	switch (selType) {
	case SelTypes::rectangle:
		result += 'R';
		break;
	case SelTypes::lines:
		result += 'L';
		break;
	case SelTypes::thin:
		result += 'T';
		break;
	default:
		// No handling of none as not a real value of enumeration, just used for empty arguments
		// No prefix.
		break;
	}
	if (selType == SelTypes::rectangle || selType == SelTypes::thin) {
		result += rangeRectangular.ToString();
	} else {
		for (size_t r = 0; r < ranges.size(); r++) {
			if (r > 0) {
				result += ',';
			}
			result += ranges[r].ToString();
		}
	}

	if (mainRange > 0) {
		result += '#';
		result += std::to_string(mainRange);
	}

	return result;
}


================================================
FILE: Libraries/scintilla/src/Selection.h
================================================
// Scintilla source code edit control
/** @file Selection.h
 ** Classes maintaining the selection.
 **/
// Copyright 2009 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#ifndef SELECTION_H
#define SELECTION_H

namespace Scintilla::Internal {

class SelectionPosition {
	Sci::Position position = Sci::invalidPosition;
	Sci::Position virtualSpace = 0;
public:
	constexpr SelectionPosition() noexcept = default;
	constexpr explicit SelectionPosition(Sci::Position position_, Sci::Position virtualSpace_=0) noexcept : position(position_), virtualSpace(virtualSpace_) {
		PLATFORM_ASSERT(virtualSpace < 800000000);
		if (virtualSpace < 0)
			virtualSpace = 0;
	}
	explicit SelectionPosition(std::string_view sv);
	void Reset() noexcept {
		position = 0;
		virtualSpace = 0;
	}
	void MoveForInsertDelete(bool insertion, Sci::Position startChange, Sci::Position length, bool moveForEqual) noexcept;
	[[nodiscard]] constexpr bool operator ==(const SelectionPosition &other) const noexcept {
		return (position == other.position) && (virtualSpace == other.virtualSpace);
	}
	[[nodiscard]] constexpr bool operator !=(const SelectionPosition &other) const noexcept {
		return (position != other.position) || (virtualSpace != other.virtualSpace);
	}
	[[nodiscard]] constexpr bool operator <(const SelectionPosition &other) const noexcept {
		if (position == other.position)
			return virtualSpace < other.virtualSpace;
		return position < other.position;
	}
	[[nodiscard]] bool operator >(const SelectionPosition &other) const noexcept;
	[[nodiscard]] bool operator <=(const SelectionPosition &other) const noexcept;
	[[nodiscard]] bool operator >=(const SelectionPosition &other) const noexcept;
	Sci::Position Position() const noexcept {
		return position;
	}
	void SetPosition(Sci::Position position_) noexcept {
		position = position_;
		virtualSpace = 0;
	}
	Sci::Position VirtualSpace() const noexcept {
		return virtualSpace;
	}
	[[nodiscard]] double VirtualSpaceWidth(double spaceWidth) const noexcept;
	void SetVirtualSpace(Sci::Position virtualSpace_) noexcept {
		PLATFORM_ASSERT(virtualSpace_ < 800000000);
		if (virtualSpace_ >= 0)
			virtualSpace = virtualSpace_;
	}
	void Add(Sci::Position increment) noexcept {
		position = position + increment;
	}
	void AddVirtualSpace(Sci::Position increment) noexcept {
		SetVirtualSpace(virtualSpace + increment);
	}
	bool IsValid() const noexcept {
		return position >= 0;
	}
	std::string ToString() const;
};

// Ordered range to make drawing simpler
struct SelectionSegment {
	SelectionPosition start;
	SelectionPosition end;
	constexpr SelectionSegment() noexcept = default;
	constexpr SelectionSegment(SelectionPosition a, SelectionPosition b) noexcept {
		if (a < b) {
			start = a;
			end = b;
		} else {
			start = b;
			end = a;
		}
	}
	constexpr SelectionSegment(Sci::Position a, Sci::Position b) :
		SelectionSegment(SelectionPosition(a), SelectionPosition(b)) {
	}
	[[nodiscard]] constexpr bool operator ==(const SelectionSegment &other) const noexcept {
		return (start == other.start) && (end == other.end);
	}
	bool Empty() const noexcept {
		return start == end;
	}
	Sci::Position Length() const noexcept {
		return end.Position() - start.Position();
	}
	void Extend(SelectionPosition p) noexcept {
		if (start > p)
			start = p;
		if (end < p)
			end = p;
	}
	SelectionSegment Subtract(Sci::Position increment) const noexcept {
		SelectionSegment ret(start, end);
		ret.start.Add(-increment);
		ret.end.Add(-increment);
		return ret;
	}
};

struct SelectionRange {
	SelectionPosition caret;
	SelectionPosition anchor;

	constexpr SelectionRange() noexcept = default;
	constexpr explicit SelectionRange(SelectionPosition single) noexcept : caret(single), anchor(single) {
	}
	constexpr explicit SelectionRange(Sci::Position single) noexcept : caret(single), anchor(single) {
	}
	constexpr SelectionRange(SelectionPosition caret_, SelectionPosition anchor_) noexcept : caret(caret_), anchor(anchor_) {
	}
	constexpr SelectionRange(Sci::Position caret_, Sci::Position anchor_) noexcept : caret(caret_), anchor(anchor_) {
	}
	explicit SelectionRange(std::string_view sv);
	SelectionSegment AsSegment() const noexcept {
		return {caret, anchor};
	}
	bool Empty() const noexcept {
		return anchor == caret;
	}
	Sci::Position Length() const noexcept;
	// Sci::Position Width() const;	// Like Length but takes virtual space into account
	bool operator ==(const SelectionRange &other) const noexcept {
		return caret == other.caret && anchor == other.anchor;
	}
	bool operator <(const SelectionRange &other) const noexcept {
		return caret < other.caret || ((caret == other.caret) && (anchor < other.anchor));
	}
	void Reset() noexcept {
		anchor.Reset();
		caret.Reset();
	}
	void ClearVirtualSpace() noexcept {
		anchor.SetVirtualSpace(0);
		caret.SetVirtualSpace(0);
	}
	void MoveForInsertDelete(bool insertion, Sci::Position startChange, Sci::Position length) noexcept;
	bool Contains(Sci::Position pos) const noexcept;
	bool Contains(SelectionPosition sp) const noexcept;
	bool ContainsCharacter(Sci::Position posCharacter) const noexcept;
	bool ContainsCharacter(SelectionPosition spCharacter) const noexcept;
	SelectionSegment Intersect(SelectionSegment check) const noexcept;
	SelectionPosition Start() const noexcept {
		return (anchor < caret) ? anchor : caret;
	}
	SelectionPosition End() const noexcept {
		return (anchor < caret) ? caret : anchor;
	}
	void Swap() noexcept;
	bool Trim(SelectionRange range) noexcept;
	void Truncate(Sci::Position length) noexcept;
	// If range is all virtual collapse to start of virtual space
	void MinimizeVirtualSpace() noexcept;
	std::string ToString() const;
};

// Deliberately an enum rather than an enum class to allow treating as bool
enum InSelection { inNone, inMain, inAdditional };

class Selection {
	using Ranges = std::vector<SelectionRange>;
	Ranges ranges;
	Ranges rangesSaved;
	SelectionRange rangeRectangular;
	size_t mainRange;
	bool moveExtends;
	bool tentativeMain;
public:
	enum class SelTypes { none, stream, rectangle, lines, thin };
	SelTypes selType;

	Selection();	// Allocates so may throw.
	explicit Selection(std::string_view sv);

	bool IsRectangular() const noexcept;
	Sci::Position MainCaret() const noexcept;
	Sci::Position MainAnchor() const noexcept;
	SelectionRange &Rectangular() noexcept;
	SelectionRange RectangularCopy() const noexcept;
	SelectionSegment Limits() const noexcept;
	// This is for when you want to move the caret in response to a
	// user direction command - for rectangular selections, use the range
	// that covers all selected text otherwise return the main selection.
	SelectionSegment LimitsForRectangularElseMain() const noexcept;
	size_t Count() const noexcept;
	size_t Main() const noexcept;
	void SetMain(size_t r) noexcept;
	SelectionRange &Range(size_t r) noexcept;
	const SelectionRange &Range(size_t r) const noexcept;
	SelectionRange &RangeMain() noexcept;
	const SelectionRange &RangeMain() const noexcept;
	SelectionPosition Start() const noexcept;
	bool MoveExtends() const noexcept;
	void SetMoveExtends(bool moveExtends_) noexcept;
	bool Empty() const noexcept;
	SelectionPosition Last() const noexcept;
	Sci::Position Length() const noexcept;
	void MovePositions(bool insertion, Sci::Position startChange, Sci::Position length) noexcept;
	void TrimSelection(SelectionRange range) noexcept;
	void TrimOtherSelections(size_t r, SelectionRange range) noexcept;
	void SetSelection(SelectionRange range) noexcept;
	void AddSelection(SelectionRange range);
	void AddSelectionWithoutTrim(SelectionRange range);
	void DropSelection(size_t r) noexcept;
	void DropAdditionalRanges() noexcept;
	void TentativeSelection(SelectionRange range);
	void CommitTentative() noexcept;
	InSelection RangeType(size_t r) const noexcept;
	InSelection CharacterInSelection(Sci::Position posCharacter) const noexcept;
	InSelection InSelectionForEOL(Sci::Position pos) const noexcept;
	Sci::Position VirtualSpaceFor(Sci::Position pos) const noexcept;
	void Clear() noexcept;
	void RemoveDuplicates() noexcept;
	void RotateMain() noexcept;
	bool Tentative() const noexcept { return tentativeMain; }
	Ranges RangesCopy() const {
		return ranges;
	}
	void SetRanges(const Ranges &rangesToSet);
	void Truncate(Sci::Position length) noexcept;
	std::string ToString() const;
};

}

#endif


================================================
FILE: Libraries/scintilla/src/SparseVector.h
================================================
// Scintilla source code edit control
/** @file SparseVector.h
 ** Hold data sparsely associated with elements in a range.
 **/
// Copyright 2016 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#ifndef SPARSEVECTOR_H
#define SPARSEVECTOR_H

namespace Scintilla::Internal {

// SparseVector is similar to RunStyles but is more efficient for cases where values occur
// for one position instead of over a range of positions.
// There are always elements at the start and end, so the element type should have
// a reasonable empty value that will cause no problems.
// The element type should have a noexcept default constructor as that allows methods to
// be noexcept.
template <typename T>
class SparseVector {
private:
	Partitioning<Sci::Position> starts;
	SplitVector<T> values;
	T empty;	// Return from ValueAt when no element at a position.
	void ClearValue(Sci::Position partition) noexcept {
		values.SetValueAt(partition, T());
	}
public:
	SparseVector() : empty() {
		values.InsertEmpty(0, 2);
	}
	Sci::Position Length() const noexcept {
		return starts.Length();
	}
	Sci::Position Elements() const noexcept {
		return starts.Partitions();
	}
	Sci::Position PositionOfElement(Sci::Position element) const noexcept {
		return starts.PositionFromPartition(element);
	}
	Sci::Position ElementFromPosition(Sci::Position position) const noexcept {
		if (position < Length()) {
			return starts.PartitionFromPosition(position);
		} else {
			return starts.Partitions();
		}
	}
	const T& ValueAt(Sci::Position position) const noexcept {
		assert(position <= Length());
		const Sci::Position partition = ElementFromPosition(position);
		const Sci::Position startPartition = starts.PositionFromPartition(partition);
		if (startPartition == position) {
			return values.ValueAt(partition);
		} else {
			return empty;
		}
	}
	T Extract(Sci::Position position) {
		// Move value currently at position; clear and remove position; return value.
		// Doesn't remove position at start or end.
		assert(position <= Length());
		const Sci::Position partition = ElementFromPosition(position);
		assert(partition >= 0);
		assert(partition <= starts.Partitions());
		assert(starts.PositionFromPartition(partition) == position);
		T value = std::move(values.operator[](partition));
		if ((partition > 0) && (partition < starts.Partitions())) {
			starts.RemovePartition(partition);
			values.Delete(partition);
		}
		Check();
		return value;
	}
	template <typename ParamType>
	void SetValueAt(Sci::Position position, ParamType &&value) {
		assert(position <= Length());
		const Sci::Position partition = ElementFromPosition(position);
		const Sci::Position startPartition = starts.PositionFromPartition(partition);
		if (value == T()) {
			// Setting the empty value is equivalent to deleting the position
			if (position == 0 || position == Length()) {
				ClearValue(partition);
			} else if (position == startPartition) {
				// Currently an element at this position, so remove
				ClearValue(partition);
				starts.RemovePartition(partition);
				values.Delete(partition);
			}
			// Else element remains empty
		} else {
			if (position == startPartition) {
				// Already a value at this position, so replace
				ClearValue(partition);
				values.SetValueAt(partition, std::forward<ParamType>(value));
			} else {
				// Insert a new element
				starts.InsertPartition(partition + 1, position);
				values.Insert(partition + 1, std::forward<ParamType>(value));
			}
		}
	}
	void InsertSpace(Sci::Position position, Sci::Position insertLength) {
		assert(position <= Length());
		const Sci::Position partition = starts.PartitionFromPosition(position);
		const Sci::Position startPartition = starts.PositionFromPartition(partition);
		if (startPartition == position) {
			const bool positionOccupied = values.ValueAt(partition) != T();
			// Inserting at start of run so make previous longer
			if (partition == 0) {
				// Inserting at start of document so ensure start empty
				if (positionOccupied) {
					starts.InsertPartition(1, 0);
					values.InsertEmpty(0, 1);
				}
				starts.InsertText(partition, insertLength);
			} else {
				if (positionOccupied) {
					starts.InsertText(partition - 1, insertLength);
				} else {
					// Insert at end of run so do not extend style
					starts.InsertText(partition, insertLength);
				}
			}
		} else {
			starts.InsertText(partition, insertLength);
		}
	}
	void DeletePosition(Sci::Position position) {
		assert(position < Length());
		Sci::Position partition = starts.PartitionFromPosition(position);
		const Sci::Position startPartition = starts.PositionFromPartition(partition);
		if (startPartition == position) {
			if (partition == 0) {
				ClearValue(0);
				if (starts.PositionFromPartition(1) == 1) {
					// Removing all space of first partition, so remove next partition
					// and move value if not last
					if (Elements() > 1) {
						starts.RemovePartition(partition + 1);
						values.Delete(partition);
					}
				}
			} else if (partition == starts.Partitions()) {
				// This should not be possible
				ClearValue(partition);
				throw std::runtime_error("SparseVector: deleting end partition.");
			} else {
				ClearValue(partition);
				starts.RemovePartition(partition);
				values.Delete(partition);
				// Its the previous partition now that gets smaller
				partition--;
			}
		}
		starts.InsertText(partition, -1);
		Check();
	}
	void DeleteAll() {
		starts = Partitioning<Sci::Position>();
		values = SplitVector<T>();
		values.InsertEmpty(0, 2);
	}
	void DeleteRange(Sci::Position position, Sci::Position deleteLength) {
		// For now, delete elements in range - may want to leave value at start
		// or combine onto position.
		if (position > Length() || (deleteLength == 0)) {
			return;
		}
		const Sci::Position positionEnd = position + deleteLength;
		assert(positionEnd <= Length());
		if (position == 0) {
			// Remove all partitions in range, moving values to start
			while ((Elements() > 1) && (starts.PositionFromPartition(1) <= deleteLength)) {
				starts.RemovePartition(1);
				values.Delete(0);
			}
			starts.InsertText(0, -deleteLength);
			if (Length() == 0) {
				ClearValue(0);
			}
		} else {
			const Sci::Position partition = starts.PartitionFromPosition(position);
			const bool atPartitionStart = position == starts.PositionFromPartition(partition);
			const Sci::Position partitionDelete = partition + (atPartitionStart ? 0 : 1);
			assert(partitionDelete > 0);
			for (;;) {
				const Sci::Position positionAtIndex = starts.PositionFromPartition(partitionDelete);
				assert(position <= positionAtIndex);
				if (positionAtIndex >= positionEnd) {
					break;
				}
				assert(partitionDelete <= Elements());
				starts.RemovePartition(partitionDelete);
				values.Delete(partitionDelete);
			}
			starts.InsertText(partition - (atPartitionStart ? 1 : 0), -deleteLength);
		}
		Check();
	}
	Sci::Position PositionNext(Sci::Position start) const noexcept {
		const Sci::Position element = ElementFromPosition(start);
		if (element < Elements()) {
			return PositionOfElement(element + 1);
		}
		return Length() + 1;	// Out of bounds to terminate
	}
	Sci::Position IndexAfter(Sci::Position position) const noexcept {
		assert(position < Length());
		if (position < 0)
			return 0;
		const Sci::Position partition = starts.PartitionFromPosition(position);
		return partition + 1;
	}
	void Check() const {
#ifdef CHECK_CORRECTNESS
		starts.Check();
		if (starts.Partitions() != values.Length() - 1) {
			throw std::runtime_error("SparseVector: Partitions and values different lengths.");
		}
#endif
	}
};

}

#endif


================================================
FILE: Libraries/scintilla/src/SplitVector.h
================================================
// Scintilla source code edit control
/** @file SplitVector.h
 ** Main data structure for holding arrays that handle insertions
 ** and deletions efficiently.
 **/
// Copyright 1998-2007 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#ifndef SPLITVECTOR_H
#define SPLITVECTOR_H

namespace Scintilla::Internal {

template <typename T>
class SplitVector {
protected:
	std::vector<T> body;
	T empty;	/// Returned as the result of out-of-bounds access.
	ptrdiff_t lengthBody;
	ptrdiff_t part1Length;
	ptrdiff_t gapLength;	/// invariant: gapLength == body.size() - lengthBody
	size_t growSize;

	/// Move the gap to a particular position so that insertion and
	/// deletion at that point will not require much copying and
	/// hence be fast.
	void GapTo(ptrdiff_t position) noexcept {
		if (position != part1Length) {
			try {
				if (gapLength > 0) {	// If gap to move
					// This can never fail but std::move and std::move_backward are not noexcept.
					if (position < part1Length) {
						// Moving the gap towards start so moving elements towards end
						std::move_backward(
							body.data() + position,
							body.data() + part1Length,
							body.data() + gapLength + part1Length);
					} else {	// position > part1Length
						// Moving the gap towards end so moving elements towards start
						std::move(
							body.data() + part1Length + gapLength,
							body.data() + gapLength + position,
							body.data() + part1Length);
					}
				}
				part1Length = position;
			} catch (...) {
				// Ignore any exception
			}
		}
	}

	/// Check that there is room in the buffer for an insertion,
	/// reallocating if more space needed.
	void RoomFor(ptrdiff_t insertionLength) {
		if (gapLength < insertionLength) {
			while (growSize < body.size() / 6)
				growSize *= 2;
			ReAllocate(body.size() + insertionLength + growSize);
		}
	}

	void Init() {
		body.clear();
		body.shrink_to_fit();
		lengthBody = 0;
		part1Length = 0;
		gapLength = 0;
		growSize = 8;
	}

public:
	/// Construct a split buffer.
	SplitVector(size_t growSize_=8) : empty(), lengthBody(0), part1Length(0), gapLength(0), growSize(growSize_) {
	}

	size_t GetGrowSize() const noexcept {
		return growSize;
	}

	void SetGrowSize(size_t growSize_) noexcept {
		growSize = growSize_;
	}

	/// Reallocate the storage for the buffer to be newSize and
	/// copy existing contents to the new buffer.
	/// Must not be used to decrease the size of the buffer.
	void ReAllocate(size_t newSize) {
		if (newSize > body.size()) {
			// Move the gap to the end
			GapTo(lengthBody);
			gapLength += newSize - body.size();
			// RoomFor implements a growth strategy but so does vector::resize so
			// ensure vector::resize allocates exactly the amount wanted by
			// calling reserve first.
			body.reserve(newSize);
			body.resize(newSize);
		}
	}

	/// Retrieve the element at a particular position.
	/// Retrieving positions outside the range of the buffer returns empty or 0.
	const T& ValueAt(ptrdiff_t position) const noexcept {
		if (position < part1Length) {
			if (position < 0) {
				return empty;
			} else {
				return body[position];
			}
		} else {
			if (position >= lengthBody) {
				return empty;
			} else {
				return body[gapLength + position];
			}
		}
	}

	/// Set the element at a particular position.
	/// Setting positions outside the range of the buffer performs no assignment
	/// but asserts in debug builds.
	template <typename ParamType>
	void SetValueAt(ptrdiff_t position, ParamType&& v) noexcept {
		if (position < part1Length) {
			PLATFORM_ASSERT(position >= 0);
			if (position < 0) {
				;
			} else {
				body[position] = std::forward<ParamType>(v);
			}
		} else {
			PLATFORM_ASSERT(position < lengthBody);
			if (position >= lengthBody) {
				;
			} else {
				body[gapLength + position] = std::forward<ParamType>(v);
			}
		}
	}

	/// Retrieve the element at a particular position.
	/// The position must be within bounds or an assertion is triggered.
	const T &operator[](ptrdiff_t position) const noexcept {
		PLATFORM_ASSERT(position >= 0 && position < lengthBody);
		if (position < part1Length) {
			return body[position];
		} else {
			return body[gapLength + position];
		}
	}

	/// Retrieve reference to the element at a particular position.
	/// This, instead of the const variant, can be used to mutate in-place.
	/// The position must be within bounds or an assertion is triggered.
	T &operator[](ptrdiff_t position) noexcept {
		PLATFORM_ASSERT(position >= 0 && position < lengthBody);
		if (position < part1Length) {
			return body[position];
		} else {
			return body[gapLength + position];
		}
	}

	/// Retrieve the length of the buffer.
	ptrdiff_t Length() const noexcept {
		return lengthBody;
	}

	/// Insert a single value into the buffer.
	/// Inserting at positions outside the current range fails.
	void Insert(ptrdiff_t position, T v) {
		PLATFORM_ASSERT((position >= 0) && (position <= lengthBody));
		if ((position < 0) || (position > lengthBody)) {
			return;
		}
		RoomFor(1);
		GapTo(position);
		body[part1Length] = std::move(v);
		lengthBody++;
		part1Length++;
		gapLength--;
	}

	/// Insert a number of elements into the buffer setting their value.
	/// Inserting at positions outside the current range fails.
	void InsertValue(ptrdiff_t position, ptrdiff_t insertLength, T v) {
		PLATFORM_ASSERT((position >= 0) && (position <= lengthBody));
		if (insertLength > 0) {
			if ((position < 0) || (position > lengthBody)) {
				return;
			}
			RoomFor(insertLength);
			GapTo(position);
			std::fill_n(body.data() + part1Length, insertLength, v);
			lengthBody += insertLength;
			part1Length += insertLength;
			gapLength -= insertLength;
		}
	}

	/// Add some new empty elements.
	/// InsertValue is good for value objects but not for unique_ptr objects
	/// since they can only be moved from once.
	/// Callers can write to the returned pointer to transform inputs without copies.
	T *InsertEmpty(ptrdiff_t position, ptrdiff_t insertLength) {
		PLATFORM_ASSERT((position >= 0) && (position <= lengthBody));
		if (insertLength > 0) {
			if ((position < 0) || (position > lengthBody)) {
				return nullptr;
			}
			RoomFor(insertLength);
			GapTo(position);
			T *ptr = body.data() + part1Length;
			for (ptrdiff_t elem = 0; elem < insertLength; elem++, ptr++) {
				T emptyOne = {};
				*ptr = std::move(emptyOne);
			}
			lengthBody += insertLength;
			part1Length += insertLength;
			gapLength -= insertLength;
		}
		return body.data() + position;
	}

	/// Ensure at least length elements allocated,
	/// appending zero valued elements if needed.
	void EnsureLength(ptrdiff_t wantedLength) {
		if (Length() < wantedLength) {
			InsertEmpty(Length(), wantedLength - Length());
		}
	}

	/// Insert text into the buffer from an array.
	void InsertFromArray(ptrdiff_t positionToInsert, const T s[], ptrdiff_t positionFrom, ptrdiff_t insertLength) {
		PLATFORM_ASSERT((positionToInsert >= 0) && (positionToInsert <= lengthBody));
		if (insertLength > 0) {
			if ((positionToInsert < 0) || (positionToInsert > lengthBody)) {
				return;
			}
			RoomFor(insertLength);
			GapTo(positionToInsert);
			std::copy_n(s + positionFrom, insertLength, body.data() + part1Length);
			lengthBody += insertLength;
			part1Length += insertLength;
			gapLength -= insertLength;
		}
	}

	/// Delete one element from the buffer.
	void Delete(ptrdiff_t position) {
		PLATFORM_ASSERT((position >= 0) && (position < lengthBody));
		DeleteRange(position, 1);
	}

	/// Delete a range from the buffer.
	/// Deleting positions outside the current range fails.
	/// Cannot be noexcept as vector::shrink_to_fit may be called and it may throw.
	void DeleteRange(ptrdiff_t position, ptrdiff_t deleteLength) {
		PLATFORM_ASSERT((position >= 0) && (position + deleteLength <= lengthBody));
		if ((position < 0) || ((position + deleteLength) > lengthBody)) {
			return;
		}
		if ((position == 0) && (deleteLength == lengthBody)) {
			// Full deallocation returns storage and is faster
			Init();
		} else if (deleteLength > 0) {
			GapTo(position);
			lengthBody -= deleteLength;
			gapLength += deleteLength;
		}
	}

	/// Delete all the buffer contents.
	void DeleteAll() {
		DeleteRange(0, lengthBody);
	}

	/// Retrieve a range of elements into an array
	void GetRange(T *buffer, ptrdiff_t position, ptrdiff_t retrieveLength) const {
		// Split into up to 2 ranges, before and after the split then use memcpy on each.
		ptrdiff_t range1Length = 0;
		if (position < part1Length) {
			const ptrdiff_t part1AfterPosition = part1Length - position;
			range1Length = retrieveLength;
			if (range1Length > part1AfterPosition)
				range1Length = part1AfterPosition;
		}
		std::copy_n(body.data() + position, range1Length, buffer);
		buffer += range1Length;
		position = position + range1Length + gapLength;
		const ptrdiff_t range2Length = retrieveLength - range1Length;
		std::copy_n(body.data() + position, range2Length, buffer);
	}

	/// Compact the buffer and return a pointer to the first element.
	/// Also ensures there is an empty element beyond logical end in case its
	/// passed to a function expecting a NUL terminated string.
	T *BufferPointer() {
		RoomFor(1);
		GapTo(lengthBody);
		T emptyOne = {};
		body[lengthBody] = std::move(emptyOne);
		return body.data();
	}

	/// Return a pointer to a range of elements, first rearranging the buffer if
	/// needed to make that range contiguous.
	T *RangePointer(ptrdiff_t position, ptrdiff_t rangeLength) noexcept {
		if (position < part1Length) {
			if ((position + rangeLength) > part1Length) {
				// Range overlaps gap, so move gap to start of range.
				GapTo(position);
				return body.data() + position + gapLength;
			} else {
				return body.data() + position;
			}
		} else {
			return body.data() + position + gapLength;
		}
	}

	/// Return a pointer to a single element.
	/// Does not rearrange the buffer.
	const T *ElementPointer(ptrdiff_t position) const noexcept {
		if (position < part1Length) {
			return body.data() + position;
		} else {
			return body.data() + position + gapLength;
		}
	}

	/// Return the position of the gap within the buffer.
	ptrdiff_t GapPosition() const noexcept {
		return part1Length;
	}
};

}

#endif


================================================
FILE: Libraries/scintilla/src/Style.cxx
================================================
// Scintilla source code edit control
/** @file Style.cxx
 ** Defines the font and colour style for a class of text.
 **/
// Copyright 1998-2001 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#include <cstdint>

#include <stdexcept>
#include <string_view>
#include <vector>
#include <optional>
#include <memory>

#include "ScintillaTypes.h"

#include "Debugging.h"
#include "Geometry.h"
#include "Platform.h"

#include "Style.h"

using namespace Scintilla;
using namespace Scintilla::Internal;

bool FontSpecification::operator==(const FontSpecification &other) const noexcept {
	return fontName == other.fontName &&
	       weight == other.weight &&
	       italic == other.italic &&
	       size == other.size &&
	       stretch == other.stretch &&
	       characterSet == other.characterSet &&
	       extraFontFlag == other.extraFontFlag &&
	       checkMonospaced == other.checkMonospaced;
}

bool FontSpecification::operator<(const FontSpecification &other) const noexcept {
	if (fontName != other.fontName)
		return fontName < other.fontName;
	if (weight != other.weight)
		return weight < other.weight;
	if (italic != other.italic)
		return !italic;
	if (size != other.size)
		return size < other.size;
	if (stretch != other.stretch)
		return stretch < other.stretch;
	if (characterSet != other.characterSet)
		return characterSet < other.characterSet;
	if (extraFontFlag != other.extraFontFlag)
		return extraFontFlag < other.extraFontFlag;
	if (checkMonospaced != other.checkMonospaced)
		return checkMonospaced < other.checkMonospaced;
	return false;
}

namespace {

// noexcept Platform::DefaultFontSize
int DefaultFontSize() noexcept {
	try {
		return Platform::DefaultFontSize();
	} catch (...) {
		return 10;
	}
}

}

Style::Style(const char *fontName_) noexcept :
	FontSpecification(fontName_, DefaultFontSize() * FontSizeMultiplier),
	fore(black),
	back(white),
	eolFilled(false),
	underline(false),
	caseForce(CaseForce::mixed),
	visible(true),
	changeable(true),
	hotspot(false),
	invisibleRepresentation{} {
}

void Style::Copy(std::shared_ptr<Font> font_, const FontMeasurements &fm_) noexcept {
	font = std::move(font_);
	(FontMeasurements &)(*this) = fm_;
}


================================================
FILE: Libraries/scintilla/src/Style.h
================================================
// Scintilla source code edit control
/** @file Style.h
 ** Defines the font and colour style for a class of text.
 **/
// Copyright 1998-2001 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#ifndef STYLE_H
#define STYLE_H

namespace Scintilla::Internal {

struct FontSpecification {
	// fontName is allocated by a ViewStyle container object and may be null
	const char *fontName;
	int size;
	Scintilla::FontWeight weight = Scintilla::FontWeight::Normal;
	Scintilla::FontStretch stretch = Scintilla::FontStretch::Normal;
	bool italic = false;
	Scintilla::CharacterSet characterSet = Scintilla::CharacterSet::Default;
	Scintilla::FontQuality extraFontFlag = Scintilla::FontQuality::QualityDefault;
	bool checkMonospaced = false;

	constexpr FontSpecification(const char *fontName_=nullptr, int size_=10*Scintilla::FontSizeMultiplier) noexcept :
		fontName(fontName_), size(size_) {
	}
	bool operator==(const FontSpecification &other) const noexcept;
	bool operator<(const FontSpecification &other) const noexcept;
};

struct FontMeasurements {
	XYPOSITION ascent = 1;
	XYPOSITION descent = 1;
	XYPOSITION capitalHeight = 1;	// Top of capital letter to baseline: ascent - internal leading
	XYPOSITION aveCharWidth = 1;
	XYPOSITION monospaceCharacterWidth = 1;
	XYPOSITION spaceWidth = 1;
	bool monospaceASCII = false;
	int sizeZoomed = 2;
};

/**
 */
class Style : public FontSpecification, public FontMeasurements {
public:
	ColourRGBA fore;
	ColourRGBA back;
	bool eolFilled;
	bool underline;
	enum class CaseForce {mixed, upper, lower, camel};
	CaseForce caseForce;
	bool visible;
	bool changeable;
	bool hotspot;
	char invisibleRepresentation[5];

	std::shared_ptr<Font> font;

	Style(const char *fontName_=nullptr) noexcept;
	void Copy(std::shared_ptr<Font> font_, const FontMeasurements &fm_) noexcept;
	bool IsProtected() const noexcept { return !(changeable && visible);}
};

}

#endif


================================================
FILE: Libraries/scintilla/src/UndoHistory.cxx
================================================
// Scintilla source code edit control
/** @file UndoHistory.cxx
 ** Manages undo for the document.
 **/
// Copyright 1998-2024 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#include <cstddef>
#include <cstdlib>
#include <cstdint>
#include <cassert>
#include <cstring>
#include <cstdio>
#include <cstdarg>
#include <climits>

#include <stdexcept>
#include <string>
#include <string_view>
#include <vector>
#include <optional>
#include <algorithm>
#include <memory>

#include "ScintillaTypes.h"

#include "Debugging.h"

#include "Position.h"
#include "SplitVector.h"
#include "Partitioning.h"
#include "RunStyles.h"
#include "SparseVector.h"
#include "ChangeHistory.h"
#include "CellBuffer.h"
#include "UndoHistory.h"

namespace Scintilla::Internal {

template <typename T>
void VectorTruncate(std::vector<T> &v, size_t length) noexcept {
	v.erase(v.begin() + length, v.end());
}

constexpr size_t byteMask = UINT8_MAX;
constexpr size_t byteBits = 8;

size_t ReadValue(const uint8_t *bytes, size_t length) noexcept {
	size_t value = 0;
	for (size_t i = 0; i < length; i++) {
		value = (value << byteBits) + bytes[i];
	}
	return value;
}

void WriteValue(uint8_t *bytes, size_t length, size_t value) noexcept {
	while (length != 0) {
		--length;
		bytes[length] = value & byteMask;
		value = value >> byteBits;
	}
}

size_t ScaledVector::Size() const noexcept {
	return bytes.size() / element.size;
}

size_t ScaledVector::ValueAt(size_t index) const noexcept {
	return ReadValue(bytes.data() + index * element.size, element.size);
}

intptr_t ScaledVector::SignedValueAt(size_t index) const noexcept {
	return ReadValue(bytes.data() + index * element.size, element.size);
}

constexpr SizeMax ElementForValue(size_t value) noexcept {
	size_t maxN = byteMask;
	size_t i = 1;
	while (value > byteMask) {
		i++;
		value >>= byteBits;
		maxN = (maxN << byteBits) + byteMask;
	}
	return { i, maxN };
}

void ScaledVector::SetValueAt(size_t index, size_t value) {
	// Check if value fits, if not then expand
	if (value > element.maxValue) {
		const SizeMax elementForValue = ElementForValue(value);
		const size_t length = bytes.size() / element.size;
		std::vector<uint8_t> bytesNew(elementForValue.size * length);
		for (size_t i = 0; i < length; i++) {
			const uint8_t *source = bytes.data() + i * element.size;
			uint8_t *destination = bytesNew.data() + (i+1) * elementForValue.size - element.size;
			memcpy(destination, source, element.size);
		}
		std::swap(bytes, bytesNew);
		element = elementForValue;
	}
	WriteValue(bytes.data() + index * element.size, element.size, value);
}

void ScaledVector::ClearValueAt(size_t index) noexcept {
	// 0 fits in any size element so no expansion needed so no exceptions
	WriteValue(bytes.data() + index * element.size, element.size, 0);
}

void ScaledVector::Clear() noexcept {
	bytes.clear();
}

void ScaledVector::Truncate(size_t length) noexcept {
	VectorTruncate(bytes, length * element.size);
	assert(bytes.size() == length * element.size);
}

void ScaledVector::ReSize(size_t length) {
	bytes.resize(length * element.size);
}

void ScaledVector::PushBack() {
	bytes.resize(bytes.size() + element.size);
}

size_t ScaledVector::SizeInBytes() const noexcept {
	return bytes.size();
}

UndoActionType::UndoActionType() noexcept : at(ActionType::insert), mayCoalesce(false) {
}

UndoActions::UndoActions() noexcept = default;

void UndoActions::Truncate(size_t length) noexcept {
	VectorTruncate(types, length);
	assert(types.size() == length);
	positions.Truncate(length);
	lengths.Truncate(length);
}

void UndoActions::PushBack() {
	types.emplace_back();
	positions.PushBack();
	lengths.PushBack();
}

void UndoActions::Clear() noexcept {
	types.clear();
	positions.Clear();
	lengths.Clear();
}

intptr_t UndoActions::SSize() const noexcept {
	return types.size();
}

void UndoActions::Create(size_t index, ActionType at_, Sci::Position position_, Sci::Position lenData_, bool mayCoalesce_) {
	types[index].at = at_;
	types[index].mayCoalesce = mayCoalesce_;
	positions.SetValueAt(index, position_);
	lengths.SetValueAt(index, lenData_);
}

bool UndoActions::AtStart(size_t index) const noexcept {
	if (index == 0) {
		return true;
	}
	return !types[index-1].mayCoalesce;
}

size_t UndoActions::LengthTo(size_t index) const noexcept {
	size_t sum = 0;
	for (size_t act = 0; act < index; act++) {
		sum += lengths.ValueAt(act);
	}
	return sum;
}

Sci::Position UndoActions::Position(int action) const noexcept {
	return positions.SignedValueAt(action);
}
Sci::Position UndoActions::Length(int action) const noexcept {
	return lengths.SignedValueAt(action);
}

void ScrapStack::Clear() noexcept {
	stack.clear();
	current = 0;
}

const char *ScrapStack::Push(const char *text, size_t length) {
	if (current < stack.length()) {
		stack.resize(current);
	}
	stack.append(text, length);
	current = stack.length();
	return stack.data() + current - length;
}

void ScrapStack::SetCurrent(size_t position) noexcept {
	current = position;
}

void ScrapStack::MoveForward(size_t length) noexcept {
	if ((current + length) <= stack.length()) {
		current += length;
	}
}

void ScrapStack::MoveBack(size_t length) noexcept {
	if (current >= length) {
		current -= length;
	}
}

const char *ScrapStack::CurrentText() const noexcept {
	return stack.data() + current;
}

const char *ScrapStack::TextAt(size_t position) const noexcept {
	return stack.data() + position;
}

// The undo history stores a sequence of user operations that represent the user's view of the
// commands executed on the text.
// Each user operation contains a sequence of text insertion and text deletion actions.
// All the user operations are stored in a list of individual actions.
// A false 'mayCoalesce' flag acts as an end to a user operation.
// Initially there are no actions in the history.
// As each action is performed, it is recorded in the history. The action may either become
// part of the current user operation or may start a new user operation. If it is to be part of the
// current operation, then 'mayCoalesce' is true. If it is to be part of a new operation, the
// 'mayCoalesce' flag of the previous action is set false.
// The decision of whether to start a new user operation is based upon two factors. If a
// compound operation has been explicitly started by calling BeginUndoAction and no matching
// EndUndoAction (these calls nest) has been called, then the action is coalesced into the current
// operation. If there is no outstanding BeginUndoAction call then a new operation is started
// unless it looks as if the new action is caused by the user typing or deleting a stream of text.
// Sequences that look like typing or deletion are coalesced into a single user operation.

int UndoHistory::PreviousAction() const noexcept {
	return currentAction - 1;
}

UndoHistory::UndoHistory() {
	scraps = std::make_unique<ScrapStack>();
}

UndoHistory::~UndoHistory() noexcept = default;

const char *UndoHistory::AppendAction(ActionType at, Sci::Position position, const char *data, Sci::Position lengthData,
	bool &startSequence, bool mayCoalesce) {
	//Platform::DebugPrintf("%% %d action %d %d %d\n", at, position, lengthData, currentAction);
	//Platform::DebugPrintf("^ %d action %d %d\n", actions[currentAction - 1].at,
	//	actions[currentAction - 1].position, actions[currentAction - 1].lenData);
	if (currentAction < savePoint) {
		savePoint = -1;
		if (!detach) {
			detach = currentAction;
		}
	} else if (detach && (*detach > currentAction)) {
		detach = currentAction;
	}
	if (undoSequenceDepth > 0) {
		// Actions not at top level are always coalesced unless this is after return to top level
		mayCoalesce = true;
	}
	bool coalesce = true;
	if (currentAction >= 1) {
		int targetAct = currentAction - 1;
		if (0 == undoSequenceDepth) {
			// Top level actions may not always be coalesced
			// Container actions may forward the coalesce state of Scintilla Actions.
			while ((targetAct > 0) && (actions.types[targetAct].at == ActionType::container) && actions.types[targetAct].mayCoalesce) {
				targetAct--;
			}
			// See if current action can be coalesced into previous action
			// Will work if both are inserts or deletes and position is same
			if ((currentAction == savePoint) || (currentAction == tentativePoint)) {
				coalesce = false;
			} else if (!mayCoalesce || !actions.types[targetAct].mayCoalesce) {
				coalesce = false;
			} else if (at == ActionType::container || actions.types[targetAct].at == ActionType::container) {
				;	// A coalescible containerAction
			} else if ((at != actions.types[targetAct].at)) { // } && (!actions.AtStart(targetAct))) {
				coalesce = false;
			} else if ((at == ActionType::insert) &&
			           (position != (actions.Position(targetAct) + actions.Length(targetAct)))) {
				// Insertions must be immediately after to coalesce
				coalesce = false;
			} else if (at == ActionType::remove) {
				if ((lengthData == 1) || (lengthData == 2)) {
					if ((position + lengthData) == actions.Position(targetAct)) {
						; // Backspace -> OK
					} else if (position == actions.Position(targetAct)) {
						; // Delete -> OK
					} else {
						// Removals must be at same position to coalesce
						coalesce = false;
					}
				} else {
					// Removals must be of one character to coalesce
					coalesce = false;
				}
			} else {
				// Action coalesced.
			}

		} else {
			// Actions not at top level are always coalesced unless this is after return to top level
			if (!actions.types[targetAct].mayCoalesce)
				coalesce = false;
		}
	} else {
		coalesce = false;
	}
	startSequence = !coalesce;
	// Maybe close previous action
	if ((currentAction > 0) && startSequence) {
		actions.types[PreviousAction()].mayCoalesce = false;
	}
	const char *dataNew = lengthData ? scraps->Push(data, lengthData) : nullptr;
	if (currentAction >= actions.SSize()) {
		actions.PushBack();
	} else {
		actions.Truncate(currentAction+1);
	}
	actions.Create(currentAction, at, position, lengthData, mayCoalesce);
	currentAction++;
	return dataNew;
}

void UndoHistory::BeginUndoAction(bool mayCoalesce) noexcept {
	if (undoSequenceDepth == 0) {
		if (currentAction > 0) {
			actions.types[PreviousAction()].mayCoalesce = mayCoalesce;
		}
	}
	undoSequenceDepth++;
}

void UndoHistory::EndUndoAction() noexcept {
	PLATFORM_ASSERT(undoSequenceDepth > 0);
	undoSequenceDepth--;
	if (0 == undoSequenceDepth) {
		if (currentAction > 0) {
			actions.types[PreviousAction()].mayCoalesce = false;
		}
	}
}

int UndoHistory::UndoSequenceDepth() const noexcept {
	return undoSequenceDepth;
}

bool UndoHistory::AfterUndoSequenceStart() const noexcept {
	if (currentAction == 0) {
		return false;
	}
	// Count back to last sequence start?
	return !actions.AtStart(currentAction-1);
}

void UndoHistory::DropUndoSequence() noexcept {
	undoSequenceDepth = 0;
}

void UndoHistory::DeleteUndoHistory() noexcept {
	actions.Clear();
	currentAction = 0;
	savePoint = 0;
	tentativePoint = -1;
	scraps->Clear();
	memory = {};
}

int UndoHistory::Actions() const noexcept {
	return static_cast<int>(actions.SSize());
}

void UndoHistory::SetSavePoint(int action) noexcept {
	savePoint = action;
}

int UndoHistory::SavePoint() const noexcept {
	return savePoint;
}

void UndoHistory::SetSavePoint() noexcept {
	savePoint = currentAction;
	detach.reset();
}

bool UndoHistory::IsSavePoint() const noexcept {
	return savePoint == currentAction;
}

bool UndoHistory::BeforeSavePoint() const noexcept {
	return (savePoint < 0) || (savePoint > currentAction);
}

bool UndoHistory::PreviousBeforeSavePoint() const noexcept {
	return (savePoint < 0) || (savePoint >= currentAction);
}

bool UndoHistory::BeforeReachableSavePoint() const noexcept {
	return (savePoint > 0) && (savePoint > currentAction);
}

bool UndoHistory::AfterSavePoint() const noexcept {
	return (savePoint >= 0) && (savePoint <= currentAction);
}

void UndoHistory::SetDetachPoint(int action) noexcept {
	if (action == -1) {
		detach = {};
	} else {
		detach = action;
	}
}

int UndoHistory::DetachPoint() const noexcept {
	return detach.value_or(-1);
}

bool UndoHistory::AfterDetachPoint() const noexcept {
	return detach && (*detach < currentAction);
}

bool UndoHistory::AfterOrAtDetachPoint() const noexcept {
	return detach && (*detach <= currentAction);
}

intptr_t UndoHistory::Delta(int action) const noexcept {
	intptr_t sizeChange = 0;
	for (int act = 0; act < action; act++) {
		const intptr_t lengthChange = actions.Length(act);
		sizeChange += (actions.types[act].at == ActionType::insert) ? lengthChange : -lengthChange;
	}
	return sizeChange;
}

bool UndoHistory::Validate(intptr_t lengthDocument) const noexcept {
	// Check history for validity
	const intptr_t sizeChange = Delta(currentAction);
	if (sizeChange > lengthDocument) {
		// Current document size too small for changes made in undo history.
		return false;
	}
	const intptr_t lengthOriginal = lengthDocument - sizeChange;
	intptr_t lengthCurrent = lengthOriginal;
	for (int act = 0; act < actions.SSize(); act++) {
		const intptr_t lengthChange = actions.Length(act);
		if (actions.Position(act) > lengthCurrent) {
			// Change outside document.
			return false;
		}
		lengthCurrent += (actions.types[act].at == ActionType::insert) ? lengthChange : -lengthChange;
		if (lengthCurrent < 0) {
			return false;
		}
	}
	return true;
}

void UndoHistory::SetCurrent(int action, intptr_t lengthDocument) {
	// Find position in scraps for action
	memory = {};
	const size_t lengthSum = actions.LengthTo(action);
	scraps->SetCurrent(lengthSum);
	currentAction = action;
	if (!Validate(lengthDocument)) {
		currentAction = 0;
		DeleteUndoHistory();
		throw std::runtime_error("UndoHistory::SetCurrent: invalid undo history.");
	}
}

int UndoHistory::Current() const noexcept {
	return currentAction;
}

int UndoHistory::Type(int action) const noexcept {
	const int baseType = static_cast<int>(actions.types[action].at);
	const int open = actions.types[action].mayCoalesce ? coalesceFlag : 0;
	return baseType | open;
}

Sci::Position UndoHistory::Position(int action) const noexcept {
	return actions.Position(action);
}

Sci::Position UndoHistory::Length(int action) const noexcept {
	return actions.Length(action);
}

std::string_view UndoHistory::Text(int action) noexcept {
	// Assumes first call after any changes is for action 0.
	// TODO: may need to invalidate memory in other circumstances
	if (action == 0) {
		memory = {};
	}
	int act = 0;
	size_t position = 0;
	if (memory && memory->act <= action) {
		act = memory->act;
		position = memory->position;
	}
	for (; act < action; act++) {
		position += actions.Length(act);
	}
	const size_t length = actions.Length(action);
	const char *scrap = scraps->TextAt(position);
	memory = {action, position};
	return {scrap, length};
}

void UndoHistory::PushUndoActionType(int type, Sci::Position position) {
	actions.PushBack();
	actions.Create(actions.SSize()-1, static_cast<ActionType>(type & byteMask),
		position, 0, type & coalesceFlag);
}

void UndoHistory::ChangeLastUndoActionText(size_t length, const char *text) {
	assert(actions.lengths.ValueAt(actions.SSize()-1) == 0);
	actions.lengths.SetValueAt(actions.SSize()-1, length);
	scraps->Push(text, length);
}

void UndoHistory::SetTentative(int action) noexcept {
	tentativePoint = action;
}

int UndoHistory::TentativePoint() const noexcept {
	return tentativePoint;
}

void UndoHistory::TentativeStart() noexcept {
	tentativePoint = currentAction;
}

void UndoHistory::TentativeCommit() noexcept {
	tentativePoint = -1;
	// Truncate undo history
	actions.Truncate(currentAction);
}

bool UndoHistory::TentativeActive() const noexcept {
	return tentativePoint >= 0;
}

int UndoHistory::TentativeSteps() const noexcept {
	// Drop any trailing startAction
	if (tentativePoint >= 0)
		return currentAction - tentativePoint;
	return -1;
}

bool UndoHistory::CanUndo() const noexcept {
	return (currentAction > 0) && (actions.SSize() != 0);
}

int UndoHistory::StartUndo() const noexcept {
	assert(currentAction >= 0);

	// Count the steps in this action
	if (currentAction == 0) {
		return 0;
	}

	int act = currentAction - 1;

	while (act > 0 && !actions.AtStart(act)) {
		act--;
	}
	return currentAction - act;
}

Action UndoHistory::GetUndoStep() const noexcept {
	const int previousAction = PreviousAction();
	Action acta {
		actions.types[previousAction].at,
		actions.types[previousAction].mayCoalesce,
		actions.Position(previousAction),
		nullptr,
		actions.Length(previousAction)
	};
	if (acta.lenData) {
		acta.data = scraps->CurrentText() - acta.lenData;
	}
	return acta;
}

void UndoHistory::CompletedUndoStep() noexcept {
	scraps->MoveBack(actions.Length(PreviousAction()));
	currentAction--;
}

bool UndoHistory::CanRedo() const noexcept {
	return actions.SSize() > currentAction;
}

int UndoHistory::StartRedo() const noexcept {
	// Count the steps in this action

	if (currentAction >= actions.SSize()) {
		// Already at end so can't redo
		return 0;
	}

	// Slightly unusual logic handles case where last action still has mayCoalesce.
	// Could set mayCoalesce of last action to false in StartUndo but this state is
	// visible to applications so should not be changed.
	const int maxAction = Actions() - 1;
	int act = currentAction;
	while (act <= maxAction && actions.types[act].mayCoalesce) {
		act++;
	}
	act = std::min(act, maxAction);
	return act - currentAction + 1;
}

Action UndoHistory::GetRedoStep() const noexcept {
	Action acta{
		actions.types[currentAction].at,
		actions.types[currentAction].mayCoalesce,
		actions.Position(currentAction),
		nullptr,
		actions.Length(currentAction)
	};
	if (acta.lenData) {
		acta.data = scraps->CurrentText();
	}
	return acta;
}

void UndoHistory::CompletedRedoStep() noexcept {
	scraps->MoveForward(actions.Length(currentAction));
	currentAction++;
}

}


================================================
FILE: Libraries/scintilla/src/UndoHistory.h
================================================
// Scintilla source code edit control
/** @file UndoHistory.h
 ** Manages undo for the document.
 **/
// Copyright 1998-2024 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#ifndef UNDOHISTORY_H
#define UNDOHISTORY_H

namespace Scintilla::Internal {

// ScaledVector is a vector of unsigned integers that uses elements sized to hold the largest value.
// Thus, if an undo history only contains short insertions and deletions the lengths vector may
// only use 2 bytes or even 1 byte for each length.
// This saves much memory often reducing by 50% for 32-bit builds and 75% for 64-bit builds.

struct SizeMax {
	size_t size = 1;
	size_t maxValue = UINT8_MAX;
};

class ScaledVector {
	SizeMax element;
	std::vector<uint8_t> bytes;
public:
	[[nodiscard]] size_t Size() const noexcept;
	[[nodiscard]] size_t ValueAt(size_t index) const noexcept;
	[[nodiscard]] intptr_t SignedValueAt(size_t index) const noexcept;
	void SetValueAt(size_t index, size_t value);
	void ClearValueAt(size_t index) noexcept;
	void Clear() noexcept;
	void Truncate(size_t length) noexcept;
	void ReSize(size_t length);
	void PushBack();

	// For testing
	[[nodiscard]] size_t SizeInBytes() const noexcept;
};

class UndoActionType {
public:
	ActionType at : 4;
	bool mayCoalesce : 1;
	UndoActionType() noexcept;
};

struct UndoActions {
	std::vector<UndoActionType> types;
	ScaledVector positions;
	ScaledVector lengths;

	UndoActions() noexcept;
	void Truncate(size_t length) noexcept;
	void PushBack();
	void Clear() noexcept;
	[[nodiscard]] intptr_t SSize() const noexcept;
	void Create(size_t index, ActionType at_, Sci::Position position_, Sci::Position lenData_, bool mayCoalesce_);
	[[nodiscard]] bool AtStart(size_t index) const noexcept;
	[[nodiscard]] size_t LengthTo(size_t index) const noexcept;
	[[nodiscard]] Sci::Position Position(int action) const noexcept;
	[[nodiscard]] Sci::Position Length(int action) const noexcept;
};

class ScrapStack {
	std::string stack;
	size_t current = 0;
public:
	void Clear() noexcept;
	const char *Push(const char *text, size_t length);
	void SetCurrent(size_t position) noexcept;
	void MoveForward(size_t length) noexcept;
	void MoveBack(size_t length) noexcept;
	[[nodiscard]] const char *CurrentText() const noexcept;
	[[nodiscard]] const char *TextAt(size_t position) const noexcept;
};

constexpr int coalesceFlag = 0x100;

/**
 *
 */
class UndoHistory {
	UndoActions actions;
	int currentAction = 0;
	int undoSequenceDepth = 0;
	int savePoint = 0;
	int tentativePoint = -1;
	std::optional<int> detach;	// Never set if savePoint set (>= 0)
	std::unique_ptr<ScrapStack> scraps;
	struct actPos { int act; size_t position; };
	std::optional<actPos> memory;

	int PreviousAction() const noexcept;

public:
	UndoHistory();
	~UndoHistory() noexcept;

	const char *AppendAction(ActionType at, Sci::Position position, const char *data, Sci::Position lengthData, bool &startSequence, bool mayCoalesce=true);

	void BeginUndoAction(bool mayCoalesce=false) noexcept;
	void EndUndoAction() noexcept;
	int UndoSequenceDepth() const noexcept;
	bool AfterUndoSequenceStart() const noexcept;
	void DropUndoSequence() noexcept;
	void DeleteUndoHistory() noexcept;

	[[nodiscard]] int Actions() const noexcept;

	/// The save point is a marker in the undo stack where the container has stated that
	/// the buffer was saved. Undo and redo can move over the save point.
	void SetSavePoint(int action) noexcept;
	[[nodiscard]] int SavePoint() const noexcept;
	void SetSavePoint() noexcept;
	bool IsSavePoint() const noexcept;
	bool BeforeSavePoint() const noexcept;
	bool PreviousBeforeSavePoint() const noexcept;
	bool BeforeReachableSavePoint() const noexcept;
	bool AfterSavePoint() const noexcept;

	/// The detach point is the last action that was before an inaccessible missing save point.
	void SetDetachPoint(int action) noexcept;
	[[nodiscard]] int DetachPoint() const noexcept;
	bool AfterDetachPoint() const noexcept;
	bool AfterOrAtDetachPoint() const noexcept;

	[[nodiscard]] intptr_t Delta(int action) const noexcept;
	[[nodiscard]] bool Validate(intptr_t lengthDocument) const noexcept;
	void SetCurrent(int action, intptr_t lengthDocument);
	[[nodiscard]] int Current() const noexcept;
	[[nodiscard]] int Type(int action) const noexcept;
	[[nodiscard]] Sci::Position Position(int action) const noexcept;
	[[nodiscard]] Sci::Position Length(int action) const noexcept;
	[[nodiscard]] std::string_view Text(int action) noexcept;
	void PushUndoActionType(int type, Sci::Position position);
	void ChangeLastUndoActionText(size_t length, const char *text);

	// Tentative actions are used for input composition so that it can be undone cleanly
	void SetTentative(int action) noexcept;
	[[nodiscard]] int TentativePoint() const noexcept;
	void TentativeStart() noexcept;
	void TentativeCommit() noexcept;
	bool TentativeActive() const noexcept;
	int TentativeSteps() const noexcept;

	/// To perform an undo, StartUndo is called to retrieve the number of steps, then UndoStep is
	/// called that many times. Similarly for redo.
	bool CanUndo() const noexcept;
	int StartUndo() const noexcept;
	Action GetUndoStep() const noexcept;
	void CompletedUndoStep() noexcept;
	bool CanRedo() const noexcept;
	int StartRedo() const noexcept;
	Action GetRedoStep() const noexcept;
	void CompletedRedoStep() noexcept;
};

}

#endif


================================================
FILE: Libraries/scintilla/src/UniConversion.cxx
================================================
// Scintilla source code edit control
/** @file UniConversion.cxx
 ** Functions to handle UTF-8 and UTF-16 strings.
 **/
// Copyright 1998-2001 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#include <cstdlib>

#include <stdexcept>
#include <string>
#include <string_view>

#include "UniConversion.h"

namespace Scintilla::Internal {

namespace {

constexpr int first2Byte = 0x80;
constexpr int first3Byte = 0x800;

constexpr unsigned int maskSurrogate = 0x3FF;
constexpr unsigned int shiftSurrogate = 10;

// The top 2 bits are 0b10 to indicate a trail byte.
// The lower 6 bits contain the value.
constexpr unsigned int trailByteFlag = 0b1000'0000;
constexpr unsigned int trailByteMask = 0b0011'1111;

// With each UTF-8 length the bits are divided into length indicator
// bits and value bits separated by a 0 bit.
constexpr unsigned int leadByte2 = 0b1100'0000;
constexpr unsigned int leadBits2 = 0b0001'1111;

constexpr unsigned int leadByte3 = 0b1110'0000;
constexpr unsigned int leadBits3 = 0b0000'1111;

constexpr unsigned int leadByte4 = 0b1111'0000;
constexpr unsigned int leadBits4 = 0b0000'0111;

constexpr unsigned int shiftByte2 = 6;
constexpr unsigned int shiftByte3 = 12;
constexpr unsigned int shiftByte4 = 18;

constexpr char LeadByte(unsigned int lengthValue, unsigned int uch) noexcept {
	return static_cast<unsigned char>(lengthValue | uch);
}

constexpr char TrailByte(unsigned int uch) noexcept {
	return trailByteFlag | (uch & trailByteMask);
}

constexpr unsigned char TrailByteValue(unsigned char c) noexcept {
	return c & trailByteMask;
}

constexpr wchar_t SurrogateLead(int val) noexcept {
	return static_cast<wchar_t>(((val - SUPPLEMENTAL_PLANE_FIRST) >> shiftSurrogate) + SURROGATE_LEAD_FIRST);
}

constexpr wchar_t SurrogateTrail(int val) noexcept {
	return (val & maskSurrogate) + SURROGATE_TRAIL_FIRST;
}

void UTF8AppendCharacter(int uch, char *putf, size_t &k) noexcept {
	if (uch < first2Byte) {
		putf[k++] = LeadByte(0, uch);
	} else if (uch < first3Byte) {
		putf[k++] = LeadByte(leadByte2, uch >> shiftByte2);
		putf[k++] = TrailByte(uch);
	} else if (uch < SUPPLEMENTAL_PLANE_FIRST) {
		putf[k++] = LeadByte(leadByte3, uch >> shiftByte3);
		putf[k++] = TrailByte(uch >> shiftByte2);
		putf[k++] = TrailByte(uch);
	} else {
		putf[k++] = LeadByte(leadByte4, uch >> shiftByte4);
		putf[k++] = TrailByte(uch >> shiftByte3);
		putf[k++] = TrailByte(uch >> shiftByte2);
		putf[k++] = TrailByte(uch);
	}
}

}

size_t UTF8Length(std::wstring_view wsv) noexcept {
	size_t len = 0;
	for (size_t i = 0; i < wsv.length() && wsv[i];) {
		const wchar_t uch = wsv[i];
		if (uch < first2Byte) {
			len++;
		} else if (uch < first3Byte) {
			len += 2;
		} else if (IsSurrogate(uch)) {
			len += 4;
			i++;
		} else {
			len += 3;
		}
		i++;
	}
	return len;
}

size_t UTF8PositionFromUTF16Position(std::string_view u8Text, size_t positionUTF16) noexcept {
	size_t positionUTF8 = 0;
	for (size_t lengthUTF16 = 0; (positionUTF8 < u8Text.length()) && (lengthUTF16 < positionUTF16);) {
		const unsigned char uch = u8Text[positionUTF8];
		const unsigned int byteCount = UTF8BytesOfLead[uch];
		lengthUTF16 += UTF16LengthFromUTF8ByteCount(byteCount);
		positionUTF8 += byteCount;
	}

	return positionUTF8;
}

void UTF8FromUTF16(std::wstring_view wsv, char *putf, size_t len) noexcept {
	size_t k = 0;
	for (size_t i = 0; i < wsv.length() && wsv[i];) {
		unsigned int uch = wsv[i];
		if (IsSurrogate(wsv[i])) {
			// Half a surrogate pair
			i++;
			uch = SUPPLEMENTAL_PLANE_FIRST + ((uch & maskSurrogate) << shiftSurrogate) + (wsv[i] & maskSurrogate);
		}
		UTF8AppendCharacter(uch, putf, k);
		i++;
	}
	if (k < len)
		putf[k] = '\0';
}

void UTF8FromUTF32Character(int uch, char *putf) noexcept {
	size_t k = 0;
	UTF8AppendCharacter(uch, putf, k);
	putf[k] = '\0';
}

size_t UTF16Length(std::string_view svu8) noexcept {
	size_t ulen = 0;
	for (size_t i = 0; i< svu8.length();) {
		const unsigned char ch = svu8[i];
		const unsigned int byteCount = UTF8BytesOfLead[ch];
		const unsigned int utf16Len = UTF16LengthFromUTF8ByteCount(byteCount);
		i += byteCount;
		ulen += (i > svu8.length()) ? 1 : utf16Len;
	}
	return ulen;
}

size_t UTF16FromUTF8(std::string_view svu8, wchar_t *tbuf, size_t tlen) {
	size_t ui = 0;
	for (size_t i = 0; i < svu8.length();) {
		unsigned char ch = svu8[i];
		const unsigned int byteCount = UTF8BytesOfLead[ch];
		unsigned int value = 0;

		if (i + byteCount > svu8.length()) {
			// Trying to read past end but still have space to write
			if (ui < tlen) {
				tbuf[ui] = ch;
				ui++;
			}
			break;
		}

		const size_t outLen = UTF16LengthFromUTF8ByteCount(byteCount);
		if (ui + outLen > tlen) {
			throw std::runtime_error("UTF16FromUTF8: attempted write beyond end");
		}

		i++;
		switch (byteCount) {
		case 1:
			tbuf[ui] = ch;
			break;
		case 2:
			value = (ch & leadBits2) << shiftByte2;
			ch = svu8[i++];
			value += TrailByteValue(ch);
			tbuf[ui] = static_cast<wchar_t>(value);
			break;
		case 3:
			value = (ch & leadBits3) << shiftByte3;
			ch = svu8[i++];
			value += (TrailByteValue(ch) << shiftByte2);
			ch = svu8[i++];
			value += TrailByteValue(ch);
			tbuf[ui] = static_cast<wchar_t>(value);
			break;
		default:
			// Outside the BMP so need two surrogates
			value = (ch & leadBits4) << shiftByte4;
			ch = svu8[i++];
			value += TrailByteValue(ch) << shiftByte3;
			ch = svu8[i++];
			value += TrailByteValue(ch) << shiftByte2;
			ch = svu8[i++];
			value += TrailByteValue(ch);
			tbuf[ui] = SurrogateLead(value);
			ui++;
			tbuf[ui] = SurrogateTrail(value);
			break;
		}
		ui++;
	}
	return ui;
}

size_t UTF32Length(std::string_view svu8) noexcept {
	size_t ulen = 0;
	for (size_t i = 0; i < svu8.length();) {
		const unsigned char ch = svu8[i];
		const unsigned int byteCount = UTF8BytesOfLead[ch];
		i += byteCount;
		ulen++;
	}
	return ulen;
}

size_t UTF32FromUTF8(std::string_view svu8, unsigned int *tbuf, size_t tlen) {
	size_t ui = 0;
	for (size_t i = 0; i < svu8.length();) {
		unsigned char ch = svu8[i];
		const unsigned int byteCount = UTF8BytesOfLead[ch];
		unsigned int value = 0;

		if (i + byteCount > svu8.length()) {
			// Trying to read past end but still have space to write
			if (ui < tlen) {
				tbuf[ui] = ch;
				ui++;
			}
			break;
		}

		if (ui == tlen) {
			throw std::runtime_error("UTF32FromUTF8: attempted write beyond end");
		}

		i++;
		switch (byteCount) {
		case 1:
			value = ch;
			break;
		case 2:
			value = (ch & leadBits2) << shiftByte2;
			ch = svu8[i++];
			value += TrailByteValue(ch);
			break;
		case 3:
			value = (ch & leadBits3) << shiftByte3;
			ch = svu8[i++];
			value += TrailByteValue(ch) << shiftByte2;
			ch = svu8[i++];
			value += TrailByteValue(ch);
			break;
		default:
			value = (ch & leadBits4) << shiftByte4;
			ch = svu8[i++];
			value += TrailByteValue(ch) << shiftByte3;
			ch = svu8[i++];
			value += TrailByteValue(ch) << shiftByte2;
			ch = svu8[i++];
			value += TrailByteValue(ch);
			break;
		}
		tbuf[ui] = value;
		ui++;
	}
	return ui;
}

std::wstring WStringFromUTF8(std::string_view svu8) {
	if constexpr (sizeof(wchar_t) == 2) {
		const size_t len16 = UTF16Length(svu8);
		std::wstring ws(len16, 0);
		UTF16FromUTF8(svu8, ws.data(), len16);
		return ws;
	} else {
		const size_t len32 = UTF32Length(svu8);
		std::wstring ws(len32, 0);
		UTF32FromUTF8(svu8, reinterpret_cast<unsigned int *>(ws.data()), len32);
		return ws;
	}
}

unsigned int UTF16FromUTF32Character(unsigned int val, wchar_t *tbuf) noexcept {
	if (val < SUPPLEMENTAL_PLANE_FIRST) {
		tbuf[0] = static_cast<wchar_t>(val);
		return 1;
	}
	tbuf[0] = SurrogateLead(val);
	tbuf[1] = SurrogateTrail(val);
	return 2;
}

int UnicodeFromUTF8(std::string_view sv) noexcept {
	if (!sv.empty()) {
		const unsigned char uch = sv.front();
		const unsigned int byteCount = UTF8BytesOfLead[uch];
		if (sv.length() >= byteCount) {
			return UnicodeFromUTF8(reinterpret_cast<const unsigned char *>(sv.data()));
		}
	}
	// Failure so let the caller know
	return unicodeReplacementChar;
}

const unsigned char UTF8BytesOfLead[256] = {
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 00 - 0F
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 10 - 1F
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 20 - 2F
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 30 - 3F
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 40 - 4F
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 50 - 5F
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 60 - 6F
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 70 - 7F
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 80 - 8F
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 90 - 9F
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // A0 - AF
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // B0 - BF
1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, // C0 - CF
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, // D0 - DF
3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // E0 - EF
4, 4, 4, 4, 4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // F0 - FF
};

// Silence 'magic' number warning as UTF-8 needs to distinguish byte values and byte value ranges.

// NOLINTBEGIN(*-magic-numbers)

// Return both the width of the first character in the string and a status
// saying whether it is valid or invalid.
// Most invalid sequences return a width of 1 so are treated as isolated bytes but
// the non-characters *FFFE, *FFFF and FDD0 .. FDEF return 3 or 4 as they can be
// reasonably treated as code points in some circumstances. They will, however,
// not have associated glyphs.
int UTF8Classify(const unsigned char *us, size_t len) noexcept {
	// For the rules: http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
	if (us[0] < 0x80) {
		// ASCII
		return 1;
	}

	const size_t byteCount = UTF8BytesOfLead[us[0]];
	if (byteCount == 1 || byteCount > len) {
		// Invalid lead byte
		return UTF8MaskInvalid | 1;
	}

	if (!UTF8IsTrailByte(us[1])) {
		// Invalid trail byte
		return UTF8MaskInvalid | 1;
	}

	switch (byteCount) {
	case 2:
		return 2;

	case 3:
		if (UTF8IsTrailByte(us[2])) {
			if ((*us == 0xe0) && ((us[1] & 0xe0) == 0x80)) {
				// Overlong
				return UTF8MaskInvalid | 1;
			}
			if ((*us == 0xed) && ((us[1] & 0xe0) == 0xa0)) {
				// Surrogate
				return UTF8MaskInvalid | 1;
			}
			if ((*us == 0xef) && (us[1] == 0xbf) && (us[2] == 0xbe)) {
				// U+FFFE non-character - 3 bytes long
				return UTF8MaskInvalid | 3;
			}
			if ((*us == 0xef) && (us[1] == 0xbf) && (us[2] == 0xbf)) {
				// U+FFFF non-character - 3 bytes long
				return UTF8MaskInvalid | 3;
			}
			if ((*us == 0xef) && (us[1] == 0xb7) && (((us[2] & 0xf0) == 0x90) || ((us[2] & 0xf0) == 0xa0))) {
				// U+FDD0 .. U+FDEF
				return UTF8MaskInvalid | 3;
			}
			return 3;
		}
		break;

	default:
		if (UTF8IsTrailByte(us[2]) && UTF8IsTrailByte(us[3])) {
			if (((us[1] & 0xf) == 0xf) && (us[2] == 0xbf) && ((us[3] == 0xbe) || (us[3] == 0xbf))) {
				// *FFFE or *FFFF non-character
				return UTF8MaskInvalid | 4;
			}
			if (*us == 0xf4) {
				// Check if encoding a value beyond the last Unicode character 10FFFF
				if (us[1] > 0x8f) {
					return UTF8MaskInvalid | 1;
				}
			} else if ((*us == 0xf0) && ((us[1] & 0xf0) == 0x80)) {
				// Overlong
				return UTF8MaskInvalid | 1;
			}
			return 4;
		}
		break;
	}

	return UTF8MaskInvalid | 1;
}

// NOLINTEND(*-magic-numbers)

int UTF8Classify(const char *s, size_t len) noexcept {
	return UTF8Classify(reinterpret_cast<const unsigned char *>(s), len);
}

int UTF8DrawBytes(const char *s, size_t len) noexcept {
	const int utf8StatusNext = UTF8Classify(s, len);
	return (utf8StatusNext & UTF8MaskInvalid) ? 1 : (utf8StatusNext & UTF8MaskWidth);
}

bool UTF8IsValid(std::string_view svu8) noexcept {
	const char *s = svu8.data();
	size_t remaining = svu8.length();
	while (remaining > 0) {
		const int utf8Status = UTF8Classify(s, remaining);
		if (utf8Status & UTF8MaskInvalid) {
			return false;
		}
		const int lenChar = utf8Status & UTF8MaskWidth;
		s += lenChar;
		remaining -= lenChar;
	}
	return true;
}

// Replace invalid bytes in UTF-8 with the replacement character
std::string FixInvalidUTF8(const std::string &text) {
	std::string result;
	const char *s = text.c_str();
	size_t remaining = text.size();
	while (remaining > 0) {
		const int utf8Status = UTF8Classify(s, remaining);
		if (utf8Status & UTF8MaskInvalid) {
			// Replacement character 0xFFFD = UTF8:"efbfbd".
			result.append("\xef\xbf\xbd");
			s++;
			remaining--;
		} else {
			const size_t len = utf8Status & UTF8MaskWidth;
			result.append(s, len);
			s += len;
			remaining -= len;
		}
	}
	return result;
}

}


================================================
FILE: Libraries/scintilla/src/UniConversion.h
================================================
// Scintilla source code edit control
/** @file UniConversion.h
 ** Functions to handle UTF-8 and UTF-16 strings.
 **/
// Copyright 1998-2001 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#ifndef UNICONVERSION_H
#define UNICONVERSION_H

namespace Scintilla::Internal {

constexpr int UTF8MaxBytes = 4;

constexpr int unicodeReplacementChar = 0xFFFD;

size_t UTF8Length(std::wstring_view wsv) noexcept;
size_t UTF8PositionFromUTF16Position(std::string_view u8Text, size_t positionUTF16) noexcept;
void UTF8FromUTF16(std::wstring_view wsv, char *putf, size_t len) noexcept;
void UTF8FromUTF32Character(int uch, char *putf) noexcept;
size_t UTF16Length(std::string_view svu8) noexcept;
size_t UTF16FromUTF8(std::string_view svu8, wchar_t *tbuf, size_t tlen);
size_t UTF32Length(std::string_view svu8) noexcept;
size_t UTF32FromUTF8(std::string_view svu8, unsigned int *tbuf, size_t tlen);
// WStringFromUTF8 does the right thing when wchar_t is 2 or 4 bytes so
// works on both Windows and Unix.
std::wstring WStringFromUTF8(std::string_view svu8);
unsigned int UTF16FromUTF32Character(unsigned int val, wchar_t *tbuf) noexcept;
bool UTF8IsValid(std::string_view svu8) noexcept;
std::string FixInvalidUTF8(const std::string &text);

extern const unsigned char UTF8BytesOfLead[256];

inline int UnicodeFromUTF8(const unsigned char *us) noexcept {
	switch (UTF8BytesOfLead[us[0]]) {
	case 1:
		return us[0];
	case 2:
		return ((us[0] & 0x1F) << 6) + (us[1] & 0x3F);
	case 3:
		return ((us[0] & 0xF) << 12) + ((us[1] & 0x3F) << 6) + (us[2] & 0x3F);
	default:
		return ((us[0] & 0x7) << 18) + ((us[1] & 0x3F) << 12) + ((us[2] & 0x3F) << 6) + (us[3] & 0x3F);
	}
}
int UnicodeFromUTF8(std::string_view sv) noexcept;

constexpr bool UTF8IsTrailByte(unsigned char ch) noexcept {
	return (ch >= 0x80) && (ch < 0xc0);
}

constexpr bool UTF8IsFirstByte(unsigned char ch) noexcept {
	return (ch >= 0xc2) && (ch <= 0xf4);
}

constexpr bool UTF8IsAscii(unsigned char ch) noexcept {
	return ch < 0x80;
}

constexpr bool UTF8IsAscii(char ch) noexcept {
	const unsigned char uch = ch;
	return uch < 0x80;
}

enum { UTF8MaskWidth=0x7, UTF8MaskInvalid=0x8 };
int UTF8Classify(const unsigned char *us, size_t len) noexcept;
int UTF8Classify(const char *s, size_t len) noexcept;
inline int UTF8Classify(std::string_view sv) noexcept {
	return UTF8Classify(sv.data(), sv.length());
}

// Similar to UTF8Classify but returns a length of 1 for invalid bytes
// instead of setting the invalid flag
int UTF8DrawBytes(const char *s, size_t len) noexcept;

// Line separator is U+2028 \xe2\x80\xa8
// Paragraph separator is U+2029 \xe2\x80\xa9
constexpr int UTF8SeparatorLength = 3;
constexpr bool UTF8IsSeparator(const unsigned char *us) noexcept {
	return (us[0] == 0xe2) && (us[1] == 0x80) && ((us[2] == 0xa8) || (us[2] == 0xa9));
}

// NEL is U+0085 \xc2\x85
constexpr int UTF8NELLength = 2;
constexpr bool UTF8IsNEL(const unsigned char *us) noexcept {
	return (us[0] == 0xc2) && (us[1] == 0x85);
}

// Is the sequence of 3 char a UTF-8 line end? Only the last two char are tested for a NEL.
constexpr bool UTF8IsMultibyteLineEnd(unsigned char ch0, unsigned char ch1, unsigned char ch2) noexcept {
	return
		((ch0 == 0xe2) && (ch1 == 0x80) && ((ch2 == 0xa8) || (ch2 == 0xa9))) ||
		((ch1 == 0xc2) && (ch2 == 0x85));
}

enum { SURROGATE_LEAD_FIRST = 0xD800 };
enum { SURROGATE_LEAD_LAST = 0xDBFF };
enum { SURROGATE_TRAIL_FIRST = 0xDC00 };
enum { SURROGATE_TRAIL_LAST = 0xDFFF };
enum { SUPPLEMENTAL_PLANE_FIRST = 0x10000 };

constexpr bool IsSurrogate(wchar_t uch) noexcept {
	return (uch >= SURROGATE_LEAD_FIRST) && (uch <= SURROGATE_TRAIL_LAST);
}

constexpr unsigned int UTF16CharLength(wchar_t uch) noexcept {
	return IsSurrogate(uch) ? 2 : 1;
}

constexpr unsigned int UTF16LengthFromUTF8ByteCount(unsigned int byteCount) noexcept {
	return (byteCount < 4) ? 1 : 2;
}

}

#endif


================================================
FILE: Libraries/scintilla/src/UniqueString.cxx
================================================
// Scintilla source code edit control
/** @file UniqueString.cxx
 ** Define an allocator for UniqueString.
 **/
// Copyright 2017 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#include <string_view>
#include <vector>
#include <algorithm>
#include <memory>

#include "UniqueString.h"

namespace Scintilla::Internal {

/// Equivalent to strdup but produces a std::unique_ptr<const char[]> allocation to go
/// into collections.
UniqueString UniqueStringCopy(const char *text) {
	if (!text) {
		return UniqueString();
	}
	const std::string_view sv(text);
	std::unique_ptr<char[]> upcNew = std::make_unique<char[]>(sv.length() + 1);
	sv.copy(upcNew.get(), sv.length());
	return UniqueString(upcNew.release());
}

// A set of strings that always returns the same pointer for each string.

UniqueStringSet::UniqueStringSet() = default;

void UniqueStringSet::Clear() noexcept {
	strings.clear();
}

const char *UniqueStringSet::Save(const char *text) {
	if (!text)
		return nullptr;

	const std::string_view sv(text);
	for (const UniqueString &us : strings) {
		if (sv == us.get()) {
			return us.get();
		}
	}

	strings.push_back(UniqueStringCopy(text));
	return strings.back().get();
}

}


================================================
FILE: Libraries/scintilla/src/UniqueString.h
================================================
// Scintilla source code edit control
/** @file UniqueString.h
 ** Define UniqueString, a unique_ptr based string type for storage in containers
 ** and an allocator for UniqueString.
 ** Define UniqueStringSet which holds a set of strings, used to avoid holding many copies
 ** of font names.
 **/
// Copyright 2017 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#ifndef UNIQUESTRING_H
#define UNIQUESTRING_H

namespace Scintilla::Internal {

constexpr bool IsNullOrEmpty(const char *text) noexcept {
	return text == nullptr || *text == '\0';
}

using UniqueString = std::unique_ptr<const char[]>;

/// Equivalent to strdup but produces a std::unique_ptr<const char[]> allocation to go
/// into collections.
UniqueString UniqueStringCopy(const char *text);

// A set of strings that always returns the same pointer for each string.

class UniqueStringSet {
private:
	std::vector<UniqueString> strings;
public:
	UniqueStringSet();
	void Clear() noexcept;
	const char *Save(const char *text);
};

}

#endif


================================================
FILE: Libraries/scintilla/src/ViewStyle.cxx
================================================
// Scintilla source code edit control
/** @file ViewStyle.cxx
 ** Store information on how the document is to be viewed.
 **/
// Copyright 1998-2003 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#include <cstddef>
#include <cstdint>
#include <cassert>
#include <cstring>
#include <cmath>

#include <stdexcept>
#include <string>
#include <string_view>
#include <vector>
#include <array>
#include <map>
#include <set>
#include <optional>
#include <algorithm>
#include <memory>
#include <numeric>

#include "ScintillaTypes.h"

#include "Debugging.h"
#include "Geometry.h"
#include "Platform.h"

#include "Position.h"
#include "UniqueString.h"
#include "Indicator.h"
#include "XPM.h"
#include "LineMarker.h"
#include "Style.h"
#include "ViewStyle.h"

using namespace Scintilla;
using namespace Scintilla::Internal;

namespace {

// Colour component proportions of maximum 0xffU
constexpr unsigned int light = 0xc0U;
// The middle point of 0..0xff is between 0x7fU and 0x80U and both are used
constexpr unsigned int mid = 0x80U;
constexpr unsigned int half = 0x7fU;
constexpr unsigned int quarter = 0x3fU;

}

MarginStyle::MarginStyle(MarginType style_, int width_, int mask_) noexcept :
	style(style_), width(width_), mask(mask_), sensitive(false), cursor(CursorShape::ReverseArrow) {
}

bool MarginStyle::ShowsFolding() const noexcept {
	return (mask & MaskFolders) != 0;
}

void FontRealised::Realise(Surface &surface, int zoomLevel, Technology technology, const FontSpecification &fs, const char *localeName) {
	PLATFORM_ASSERT(fs.fontName);
	measurements.sizeZoomed = fs.size + zoomLevel * FontSizeMultiplier;
	if (measurements.sizeZoomed <= FontSizeMultiplier)	// May fail if sizeZoomed < 1
		measurements.sizeZoomed = FontSizeMultiplier;

	const float deviceHeight = static_cast<float>(surface.DeviceHeightFont(measurements.sizeZoomed));
	const FontParameters fp(fs.fontName, deviceHeight / FontSizeMultiplier, fs.weight,
		fs.italic, fs.extraFontFlag, technology, fs.characterSet, localeName, fs.stretch);
	font = Font::Allocate(fp);

	// floor here is historical as platform layers have tweaked their values to match.
	// ceil would likely be better to ensure (nearly) all of the ink of a character is seen
	// but that would require platform layer changes.
	measurements.ascent = std::floor(surface.Ascent(font.get()));
	measurements.descent = std::floor(surface.Descent(font.get()));

	measurements.capitalHeight = surface.Ascent(font.get()) - surface.InternalLeading(font.get());
	measurements.aveCharWidth = surface.AverageCharWidth(font.get());
	measurements.monospaceCharacterWidth = measurements.aveCharWidth;
	measurements.spaceWidth = surface.WidthText(font.get(), " ");

	if (fs.checkMonospaced) {
		// "Ay" is normally strongly kerned and "fi" may be a ligature
		constexpr std::string_view allASCIIGraphic("Ayfi"
		// python: ''.join(chr(ch) for ch in range(32, 127))
		" !\"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~");
		std::array<XYPOSITION, allASCIIGraphic.length()> positions {};
		surface.MeasureWidthsUTF8(font.get(), allASCIIGraphic, positions.data());
		std::adjacent_difference(positions.begin(), positions.end(), positions.begin());
		const XYPOSITION maxWidth = *std::max_element(positions.begin(), positions.end());
		const XYPOSITION minWidth = *std::min_element(positions.begin(), positions.end());
		const XYPOSITION variance = maxWidth - minWidth;
		const XYPOSITION scaledVariance = variance / measurements.aveCharWidth;
		constexpr XYPOSITION monospaceWidthEpsilon = 0.000001;	// May need tweaking if monospace fonts vary more
		measurements.monospaceASCII = scaledVariance < monospaceWidthEpsilon;
		measurements.monospaceCharacterWidth = minWidth;
	} else {
		measurements.monospaceASCII = false;
	}
}

ViewStyle::ViewStyle(size_t stylesSize_) :
	styles(stylesSize_),
	markers(MarkerMax + 1),
	indicators(static_cast<size_t>(IndicatorNumbers::Max) + 1),
	ms(MaxMargin + 1) {

	nextExtendedStyle = 256;
	ResetDefaultStyle();

	// There are no image markers by default, so no need for calling CalcLargestMarkerHeight()
	largestMarkerHeight = 0;

	indicators[0] = Indicator(IndicatorStyle::Squiggle, ColourRGBA(0, half, 0));	// Green
	indicators[1] = Indicator(IndicatorStyle::TT, ColourRGBA(0, 0, maximumByte));	// Blue
	indicators[2] = Indicator(IndicatorStyle::Plain, ColourRGBA(maximumByte, 0, 0));	// Red

	// Reverted to origin
	constexpr ColourRGBA revertedToOrigin(0x40, 0xA0, 0xBF);
	// Saved
	constexpr ColourRGBA saved(0x0, 0xA0, 0x0);
	// Modified
	constexpr ColourRGBA modified(0xFF, 0x80, 0x0);
	// Reverted to change
	constexpr ColourRGBA revertedToChange(0xA0, 0xC0, 0x0);

	// Edition indicators
	constexpr size_t indexHistory = static_cast<size_t>(IndicatorNumbers::HistoryRevertedToOriginInsertion);

	// Default indicators are moderately intense so they don't overwhelm text
	constexpr int alphaFill = 30;
	constexpr int alphaOutline = 50;
	indicators[indexHistory+0] = Indicator(IndicatorStyle::CompositionThick, revertedToOrigin, false, alphaFill, alphaOutline);
	indicators[indexHistory+1] = Indicator(IndicatorStyle::Point, revertedToOrigin);
	indicators[indexHistory+2] = Indicator(IndicatorStyle::CompositionThick, saved, false, alphaFill, alphaOutline);
	indicators[indexHistory+3] = Indicator(IndicatorStyle::Point, saved);
	indicators[indexHistory+4] = Indicator(IndicatorStyle::CompositionThick, modified, false, alphaFill, alphaOutline);
	indicators[indexHistory+5] = Indicator(IndicatorStyle::PointTop, modified);
	indicators[indexHistory+6] = Indicator(IndicatorStyle::CompositionThick, revertedToChange, false, alphaFill, alphaOutline);
	indicators[indexHistory+7] = Indicator(IndicatorStyle::Point, revertedToChange);

	// Edition markers
	// Reverted to origin
	constexpr size_t indexHistoryRevertedToOrigin = static_cast<size_t>(MarkerOutline::HistoryRevertedToOrigin);
	markers[indexHistoryRevertedToOrigin].back = revertedToOrigin;
	markers[indexHistoryRevertedToOrigin].fore = revertedToOrigin;
	markers[indexHistoryRevertedToOrigin].markType = MarkerSymbol::Bar;
	// Saved
	constexpr size_t indexHistorySaved = static_cast<size_t>(MarkerOutline::HistorySaved);
	markers[indexHistorySaved].back = saved;
	markers[indexHistorySaved].fore = saved;
	markers[indexHistorySaved].markType = MarkerSymbol::Bar;
	// Modified
	constexpr size_t indexHistoryModified = static_cast<size_t>(MarkerOutline::HistoryModified);
	markers[indexHistoryModified].back = Platform::Chrome();
	markers[indexHistoryModified].fore = modified;
	markers[indexHistoryModified].markType = MarkerSymbol::Bar;
	// Reverted to change
	constexpr size_t indexHistoryRevertedToModified = static_cast<size_t>(MarkerOutline::HistoryRevertedToModified);
	markers[indexHistoryRevertedToModified].back = revertedToChange;
	markers[indexHistoryRevertedToModified].fore = revertedToChange;
	markers[indexHistoryRevertedToModified].markType = MarkerSymbol::Bar;

	technology = Technology::Default;
	indicatorsDynamic = false;
	indicatorsSetFore = false;
	lineHeight = 1;
	lineOverlap = 0;
	maxAscent = 1;
	maxDescent = 1;
	aveCharWidth = 8;
	spaceWidth = 8;
	tabWidth = spaceWidth * 8;

	// Default is for no selection foregrounds
	// Shades of grey for selection backgrounds
	elementBaseColours[Element::SelectionBack] = ColourRGBA::Grey(light);
	constexpr unsigned int veryLight = 0xd7U;
	elementBaseColours[Element::SelectionAdditionalBack] = ColourRGBA::Grey(veryLight);
	constexpr unsigned int halfLight = 0xb0;
	elementBaseColours[Element::SelectionSecondaryBack] = ColourRGBA::Grey(halfLight);
	elementBaseColours[Element::SelectionInactiveBack] = ColourRGBA::Grey(mid, quarter);
	elementAllowsTranslucent.insert({
		Element::SelectionText,
		Element::SelectionBack,
		Element::SelectionAdditionalText,
		Element::SelectionAdditionalBack,
		Element::SelectionSecondaryText,
		Element::SelectionSecondaryBack,
		Element::SelectionInactiveText,
		Element::SelectionInactiveBack,
		Element::SelectionInactiveAdditionalText,
		Element::SelectionInactiveAdditionalBack,
		});

	controlCharSymbol = 0;	/* Draw the control characters */
	controlCharWidth = 0;
	selbar = Platform::Chrome();
	selbarlight = Platform::ChromeHighlight();
	styles[StyleLineNumber].fore = black;
	styles[StyleLineNumber].back = Platform::Chrome();

	elementBaseColours[Element::Caret] = black;
	elementBaseColours[Element::CaretAdditional] = ColourRGBA::Grey(half);
	elementAllowsTranslucent.insert({
		Element::Caret,
		Element::CaretAdditional,
		});

	elementAllowsTranslucent.insert(Element::CaretLineBack);

	someStylesProtected = false;
	someStylesForceCase = false;

	hotspotUnderline = true;
	elementAllowsTranslucent.insert(Element::HotSpotActive);

	leftMarginWidth = 1;
	rightMarginWidth = 1;
	ms[0] = MarginStyle(MarginType::Number);
	ms[1] = MarginStyle(MarginType::Symbol, 16, ~MaskFolders);
	ms[2] = MarginStyle(MarginType::Symbol);
	marginInside = true;
	CalculateMarginWidthAndMask();
	textStart = marginInside ? fixedColumnWidth : leftMarginWidth;
	zoomLevel = 0;
	viewWhitespace = WhiteSpace::Invisible;
	tabDrawMode = TabDrawMode::LongArrow;
	whitespaceSize = 1;
	elementAllowsTranslucent.insert(Element::WhiteSpace);

	viewIndentationGuides = IndentView::None;
	viewEOL = false;
	extraFontFlag = FontQuality::QualityDefault;
	extraAscent = 0;
	extraDescent = 0;
	marginStyleOffset = 0;
	annotationVisible = AnnotationVisible::Hidden;
	annotationStyleOffset = 0;
	eolAnnotationVisible = EOLAnnotationVisible::Hidden;
	eolAnnotationStyleOffset = 0;
	braceHighlightIndicatorSet = false;
	braceHighlightIndicator = 0;
	braceBadLightIndicatorSet = false;
	braceBadLightIndicator = 0;

	edgeState = EdgeVisualStyle::None;
	theEdge = EdgeProperties(0, ColourRGBA::Grey(light));

	marginNumberPadding = 3;
	ctrlCharPadding = 3; // +3 For a blank on front and rounded edge each side
	lastSegItalicsOffset = 2;

	autocStyle = StyleDefault;

	localeName = localeNameDefault;
}

// Copy constructor only called when printing copies the screen ViewStyle so it can be
// modified for printing styles.
ViewStyle::ViewStyle(const ViewStyle &source) : ViewStyle(source.styles.size()) {
	styles = source.styles;
	for (Style &style : styles) {
		// Can't just copy fontName as its lifetime is relative to its owning ViewStyle
		style.fontName = fontNames.Save(style.fontName);
	}
	nextExtendedStyle = source.nextExtendedStyle;
	markers = source.markers;
	CalcLargestMarkerHeight();

	indicators = source.indicators;

	indicatorsDynamic = source.indicatorsDynamic;
	indicatorsSetFore = source.indicatorsSetFore;

	selection = source.selection;

	foldmarginColour = source.foldmarginColour;
	foldmarginHighlightColour = source.foldmarginHighlightColour;

	hotspotUnderline = source.hotspotUnderline;

	controlCharSymbol = source.controlCharSymbol;
	controlCharWidth = source.controlCharWidth;
	selbar = source.selbar;
	selbarlight = source.selbarlight;
	caret = source.caret;
	caretLine = source.caretLine;
	someStylesProtected = false;
	someStylesForceCase = false;
	leftMarginWidth = source.leftMarginWidth;
	rightMarginWidth = source.rightMarginWidth;
	ms = source.ms;
	maskInLine = source.maskInLine;
	maskDrawInText = source.maskDrawInText;
	maskDrawWrapped = source.maskDrawWrapped;
	fixedColumnWidth = source.fixedColumnWidth;
	marginInside = source.marginInside;
	textStart = source.textStart;
	zoomLevel = source.zoomLevel;
	viewWhitespace = source.viewWhitespace;
	tabDrawMode = source.tabDrawMode;
	whitespaceSize = source.whitespaceSize;
	viewIndentationGuides = source.viewIndentationGuides;
	viewEOL = source.viewEOL;
	extraFontFlag = source.extraFontFlag;
	extraAscent = source.extraAscent;
	extraDescent = source.extraDescent;
	marginStyleOffset = source.marginStyleOffset;
	annotationVisible = source.annotationVisible;
	annotationStyleOffset = source.annotationStyleOffset;
	eolAnnotationVisible = source.eolAnnotationVisible;
	eolAnnotationStyleOffset = source.eolAnnotationStyleOffset;
	braceHighlightIndicatorSet = source.braceHighlightIndicatorSet;
	braceHighlightIndicator = source.braceHighlightIndicator;
	braceBadLightIndicatorSet = source.braceBadLightIndicatorSet;
	braceBadLightIndicator = source.braceBadLightIndicator;

	edgeState = source.edgeState;
	theEdge = source.theEdge;
	theMultiEdge = source.theMultiEdge;

	marginNumberPadding = source.marginNumberPadding;
	ctrlCharPadding = source.ctrlCharPadding;
	lastSegItalicsOffset = source.lastSegItalicsOffset;

	wrap = source.wrap;

	localeName = source.localeName;
}

ViewStyle::~ViewStyle() = default;

void ViewStyle::CalculateMarginWidthAndMask() noexcept {
	fixedColumnWidth = marginInside ? leftMarginWidth : 0;
	maskInLine = 0xffffffff;
	int maskDefinedMarkers = 0;
	for (const MarginStyle &m : ms) {
		fixedColumnWidth += m.width;
		if (m.width > 0)
			maskInLine &= ~m.mask;
		maskDefinedMarkers |= m.mask;
	}
	maskDrawInText = 0;
	for (int markBit = 0; markBit <= MarkerMax; markBit++) {
		const int maskBit = 1U << markBit;
		switch (markers[markBit].markType) {
		case MarkerSymbol::Empty:
			maskInLine &= ~maskBit;
			break;
		case MarkerSymbol::Background:
		case MarkerSymbol::Underline:
			maskInLine &= ~maskBit;
			maskDrawInText |= maskDefinedMarkers & maskBit;
			break;
		default:	// Other marker types do not affect the masks
			break;
		}
	}
	maskDrawWrapped = 0;
	for (int markBit = 0; markBit <= MarkerMax; markBit++) {
		const int maskBit = 1U << markBit;
		switch (markers[markBit].markType) {
		case MarkerSymbol::Bar:
			maskDrawWrapped |= maskBit;
			break;
		default:	// Other marker types do not affect the masks
			break;
		}
	}
}

void ViewStyle::Refresh(Surface &surface, int tabInChars) {
	fonts.clear();

	selbar = Platform::Chrome();
	selbarlight = Platform::ChromeHighlight();

	// Apply the extra font flag which controls text drawing quality to each style.
	for (Style &style : styles) {
		style.extraFontFlag = extraFontFlag;
	}

	// Create a FontRealised object for each unique font in the styles.
	CreateAndAddFont(styles[StyleDefault]);
	for (const Style &style : styles) {
		CreateAndAddFont(style);
	}

	// Ask platform to allocate each unique font.
	for (const std::pair<const FontSpecification, std::unique_ptr<FontRealised>> &font : fonts) {
		font.second->Realise(surface, zoomLevel, technology, font.first, localeName.c_str());
	}

	// Set the platform font handle and measurements for each style.
	for (Style &style : styles) {
		const FontRealised *fr = Find(style);
		style.Copy(fr->font, fr->measurements);
	}

	indicatorsDynamic = std::any_of(indicators.cbegin(), indicators.cend(),
		[](const Indicator &indicator) noexcept { return indicator.IsDynamic(); });

	indicatorsSetFore = std::any_of(indicators.cbegin(), indicators.cend(),
		[](const Indicator &indicator) noexcept { return indicator.OverridesTextFore(); });

	maxAscent = 1;
	maxDescent = 1;
	FindMaxAscentDescent();
	// Ensure reasonable values: lines less than 1 pixel high will not work
	maxAscent = std::max(1.0, maxAscent + extraAscent);
	maxDescent = std::max(0.0, maxDescent + extraDescent);
	lineHeight = static_cast<int>(std::lround(maxAscent + maxDescent));
	lineOverlap = lineHeight / 10;
	if (lineOverlap < 2)
		lineOverlap = 2;
	if (lineOverlap > lineHeight)
		lineOverlap = lineHeight;

	someStylesProtected = std::any_of(styles.cbegin(), styles.cend(),
		[](const Style &style) noexcept { return style.IsProtected(); });

	someStylesForceCase = std::any_of(styles.cbegin(), styles.cend(),
		[](const Style &style) noexcept { return style.caseForce != Style::CaseForce::mixed; });

	aveCharWidth = styles[StyleDefault].aveCharWidth;
	spaceWidth = styles[StyleDefault].spaceWidth;
	tabWidth = spaceWidth * tabInChars;

	controlCharWidth = 0.0;
	if (controlCharSymbol >= 32) {
		const char cc[2] = { static_cast<char>(controlCharSymbol), '\0' };
		controlCharWidth = surface.WidthText(styles[StyleControlChar].font.get(), cc);
	}

	CalculateMarginWidthAndMask();
	textStart = marginInside ? fixedColumnWidth : leftMarginWidth;
}

void ViewStyle::ReleaseAllExtendedStyles() noexcept {
	nextExtendedStyle = 256;
}

int ViewStyle::AllocateExtendedStyles(int numberStyles) {
	const int startRange = nextExtendedStyle;
	nextExtendedStyle += numberStyles;
	EnsureStyle(nextExtendedStyle);
	return startRange;
}

void ViewStyle::EnsureStyle(size_t index) {
	if (index >= styles.size()) {
		AllocStyles(index+1);
	}
}

void ViewStyle::ResetDefaultStyle() {
	styles[StyleDefault] = Style(fontNames.Save(Platform::DefaultFont()));
}

//Au: added from and to. Replaced whole function.
//info: to is not included.
void ViewStyle::ClearStyles(size_t from, size_t to) {
	size_t n = styles.size();
	if(to == 0 || to > n) to = n;
	// Reset all styles to be like the default style
	for(size_t i = from; i < to; i++) {
		if(i != StyleDefault) {
			styles[i] = styles[StyleDefault];
		}
	}
	styles[StyleLineNumber].back = Platform::Chrome();

	// Set call tip fore/back to match the values previously set for call tips
	styles[StyleCallTip].back = white;
	styles[StyleCallTip].fore = ColourRGBA::Grey(mid);
}
//void ViewStyle::ClearStyles() {
//	// Reset all styles to be like the default style
//	for (size_t i=0; i<styles.size(); i++) {
//		if (i != StyleDefault) {
//			styles[i] = styles[StyleDefault];
//		}
//	}
//	styles[StyleLineNumber].back = Platform::Chrome();
//
//	// Set call tip fore/back to match the values previously set for call tips
//	styles[StyleCallTip].back = white;
//	styles[StyleCallTip].fore = ColourRGBA::Grey(mid);
//}

void ViewStyle::SetStyleFontName(int styleIndex, const char *name) {
	styles[styleIndex].fontName = fontNames.Save(name);
}

void ViewStyle::SetFontLocaleName(const char *name) {
	localeName = name;
}

bool ViewStyle::ProtectionActive() const noexcept {
	return someStylesProtected;
}

int ViewStyle::ExternalMarginWidth() const noexcept {
	return marginInside ? 0 : fixedColumnWidth;
}

int ViewStyle::MarginFromLocation(Point pt) const noexcept {
	XYPOSITION x = marginInside ? 0 : -fixedColumnWidth;
	for (size_t i = 0; i < ms.size(); i++) {
		if ((pt.x >= x) && (pt.x < x + ms[i].width))
			return static_cast<int>(i);
		x += ms[i].width;
	}
	return -1;
}

bool ViewStyle::ValidStyle(size_t styleIndex) const noexcept {
	return styleIndex < styles.size();
}

void ViewStyle::CalcLargestMarkerHeight() noexcept {
	largestMarkerHeight = 0;
	for (const LineMarker &marker : markers) {
		switch (marker.markType) {
		case MarkerSymbol::Pixmap:
			if (marker.pxpm && marker.pxpm->GetHeight() > largestMarkerHeight)
				largestMarkerHeight = marker.pxpm->GetHeight();
			break;
		case MarkerSymbol::RgbaImage:
			if (marker.image && marker.image->GetHeight() > largestMarkerHeight)
				largestMarkerHeight = marker.image->GetHeight();
			break;
		case MarkerSymbol::Bar:
			largestMarkerHeight = lineHeight + 2;
			break;
		default:	// Only images have their own natural heights
			break;
		}
	}
}

int ViewStyle::GetFrameWidth() const noexcept {
	return std::clamp(caretLine.frame, 1, lineHeight / 3);
}

bool ViewStyle::IsLineFrameOpaque(bool caretActive, bool lineContainsCaret) const {
	return caretLine.frame && (caretActive || caretLine.alwaysShow) &&
		ElementColour(Element::CaretLineBack) &&
		(caretLine.layer == Layer::Base) && lineContainsCaret;
}

// See if something overrides the line background colour:  Either if caret is on the line
// and background colour is set for that, or if a marker is defined that forces its background
// colour onto the line, or if a marker is defined but has no selection margin in which to
// display itself (as long as it's not an MarkerSymbol::Empty marker).  These are checked in order
// with the earlier taking precedence.  When multiple markers cause background override,
// the colour for the highest numbered one is used.
ColourOptional ViewStyle::Background(int marksOfLine, bool caretActive, bool lineContainsCaret) const {
	ColourOptional background;
	if (!caretLine.frame && (caretActive || caretLine.alwaysShow) &&
		(caretLine.layer == Layer::Base) && lineContainsCaret) {
		background = ElementColour(Element::CaretLineBack);
	}
	if (!background && marksOfLine) {
		int marks = marksOfLine;
		for (int markBit = 0; (markBit <= MarkerMax) && marks; markBit++) {
			if ((marks & 1) && (markers[markBit].markType == MarkerSymbol::Background) &&
				(markers[markBit].layer == Layer::Base)) {
				background = markers[markBit].back;
			}
			marks >>= 1;
		}
	}
	if (!background && maskInLine) {
		int marksMasked = marksOfLine & maskInLine;
		if (marksMasked) {
			for (int markBit = 0; (markBit <= MarkerMax) && marksMasked; markBit++) {
				if ((marksMasked & 1) &&
					(markers[markBit].layer == Layer::Base)) {
					background = markers[markBit].back;
				}
				marksMasked >>= 1;
			}
		}
	}
	if (background) {
		return background->Opaque();
	} else {
		return {};
	}
}

bool ViewStyle::SelectionBackgroundDrawn() const noexcept {
	return selection.layer == Layer::Base;
}

bool ViewStyle::SelectionTextDrawn() const {
	return
		ElementIsSet(Element::SelectionText) ||
		ElementIsSet(Element::SelectionAdditionalText) ||
		ElementIsSet(Element::SelectionSecondaryText) ||
		ElementIsSet(Element::SelectionInactiveText) ||
		ElementIsSet(Element::SelectionInactiveAdditionalText);
}

bool ViewStyle::WhitespaceBackgroundDrawn() const {
	return (viewWhitespace != WhiteSpace::Invisible) && (ElementIsSet(Element::WhiteSpaceBack));
}

bool ViewStyle::WhiteSpaceVisible(bool inIndent) const noexcept {
	return (!inIndent && viewWhitespace == WhiteSpace::VisibleAfterIndent) ||
		(inIndent && viewWhitespace == WhiteSpace::VisibleOnlyInIndent) ||
		viewWhitespace == WhiteSpace::VisibleAlways;
}

ColourRGBA ViewStyle::WrapColour() const {
	return ElementColour(Element::WhiteSpace).value_or(styles[StyleDefault].fore);
}

// Insert new edge in sorted order.
void ViewStyle::AddMultiEdge(int column, ColourRGBA colour) {
	theMultiEdge.insert(
		std::upper_bound(theMultiEdge.begin(), theMultiEdge.end(), column,
			[](const EdgeProperties &a, const EdgeProperties &b) noexcept {
				return a.column < b.column;
			}),
		EdgeProperties(column, colour));
}

ColourOptional ViewStyle::ElementColour(Element element) const {
	const ElementMap::const_iterator search = elementColours.find(element);
	if (search != elementColours.end()) {
		if (search->second.has_value()) {
			return search->second;
		}
	}
	const ElementMap::const_iterator searchBase = elementBaseColours.find(element);
	if (searchBase != elementBaseColours.end()) {
		if (searchBase->second.has_value()) {
			return searchBase->second;
		}
	}
	return {};
}

ColourRGBA ViewStyle::ElementColourForced(Element element) const {
	// Like ElementColour but never returns empty - when not found return opaque black.
	// This method avoids warnings for unwrapping potentially empty optionals from
	// Visual C++ Code Analysis
	const ColourOptional colour = ElementColour(element);
	return colour.value_or(black);
}

bool ViewStyle::ElementAllowsTranslucent(Element element) const {
	return elementAllowsTranslucent.count(element) > 0;
}

bool ViewStyle::ResetElement(Element element) {
	const ElementMap::const_iterator search = elementColours.find(element);
	const bool changed = (search != elementColours.end()) && (search->second.has_value());
	elementColours.erase(element);
	return changed;
}

namespace {

bool IsDifferentColour(const ColourOptional &colour, const ColourRGBA &test) noexcept {
	return colour.has_value() && !(*colour == test);
}

bool SetElementMapColour(ViewStyle::ElementMap &elements, Element element, ColourRGBA colour) {
	const ViewStyle::ElementMap::const_iterator search = elements.find(element);
	const bool changed = (search == elements.end()) ||
		IsDifferentColour(search->second, colour);
	elements[element] = colour;
	return changed;
}

}

bool ViewStyle::SetElementColour(Element element, ColourRGBA colour) {
	return SetElementMapColour(elementColours, element, colour);
}

bool ViewStyle::SetElementColourOptional(Element element, uptr_t wParam, sptr_t lParam) {
	if (wParam) {
		return SetElementColour(element, ColourRGBA::FromIpRGB(lParam));
	} else {
		return ResetElement(element);
	}
}

void ViewStyle::SetElementRGB(Element element, int rgb) {
	const ColourRGBA current = ElementColour(element).value_or(ColourRGBA(0, 0, 0, 0));
	elementColours[element] = ColourRGBA(ColourRGBA(rgb), current.GetAlpha());
}

void ViewStyle::SetElementAlpha(Element element, int alpha) {
	const ColourRGBA current = ElementColour(element).value_or(ColourRGBA(0, 0, 0, 0));
	elementColours[element] = ColourRGBA(current, std::min<unsigned int>(alpha, maximumByte));
}

bool ViewStyle::ElementIsSet(Element element) const {
	const ElementMap::const_iterator search = elementColours.find(element);
	if (search != elementColours.end()) {
		return search->second.has_value();
	}
	return false;
}

bool ViewStyle::SetElementBase(Element element, ColourRGBA colour) {
	return SetElementMapColour(elementBaseColours, element, colour);
}

bool ViewStyle::SetWrapState(Wrap wrapState_) noexcept {
	const bool changed = wrap.state != wrapState_;
	wrap.state = wrapState_;
	return changed;
}

bool ViewStyle::SetWrapVisualFlags(WrapVisualFlag wrapVisualFlags_) noexcept {
	const bool changed = wrap.visualFlags != wrapVisualFlags_;
	wrap.visualFlags = wrapVisualFlags_;
	return changed;
}

bool ViewStyle::SetWrapVisualFlagsLocation(WrapVisualLocation wrapVisualFlagsLocation_) noexcept {
	const bool changed = wrap.visualFlagsLocation != wrapVisualFlagsLocation_;
	wrap.visualFlagsLocation = wrapVisualFlagsLocation_;
	return changed;
}

bool ViewStyle::SetWrapVisualStartIndent(int wrapVisualStartIndent_) noexcept {
	const bool changed = wrap.visualStartIndent != wrapVisualStartIndent_;
	wrap.visualStartIndent = wrapVisualStartIndent_;
	return changed;
}

bool ViewStyle::SetWrapIndentMode(WrapIndentMode wrapIndentMode_) noexcept {
	const bool changed = wrap.indentMode != wrapIndentMode_;
	wrap.indentMode = wrapIndentMode_;
	return changed;
}

bool ViewStyle::IsBlockCaretStyle() const noexcept {
	return ((caret.style & CaretStyle::InsMask) == CaretStyle::Block) ||
		FlagSet(caret.style, (CaretStyle::OverstrikeBlock | CaretStyle::Curses));
}

bool ViewStyle::IsCaretVisible(bool isMainSelection) const noexcept {
	return caret.width > 0 &&
		((caret.style & CaretStyle::InsMask) != CaretStyle::Invisible ||
		(FlagSet(caret.style, CaretStyle::Curses) && !isMainSelection)); // only draw additional selections in curses mode
}

bool ViewStyle::DrawCaretInsideSelection(bool inOverstrike, bool imeCaretBlockOverride) const noexcept {
	if (FlagSet(caret.style, CaretStyle::BlockAfter))
		return false;
	return ((caret.style & CaretStyle::InsMask) == CaretStyle::Block) ||
		(inOverstrike && FlagSet(caret.style, CaretStyle::OverstrikeBlock)) ||
		imeCaretBlockOverride ||
		FlagSet(caret.style, CaretStyle::Curses);
}

ViewStyle::CaretShape ViewStyle::CaretShapeForMode(bool inOverstrike, bool isMainSelection) const noexcept {
	if (inOverstrike) {
		return (FlagSet(caret.style, CaretStyle::OverstrikeBlock)) ? CaretShape::block : CaretShape::bar;
	}

	if (FlagSet(caret.style, CaretStyle::Curses) && !isMainSelection) {
		return CaretShape::block;
	}

	const CaretStyle caretStyle = caret.style & CaretStyle::InsMask;
	return (caretStyle <= CaretStyle::Block) ? static_cast<CaretShape>(caretStyle) : CaretShape::line;
}

void ViewStyle::AllocStyles(size_t sizeNew) {
	size_t i=styles.size();
	styles.resize(sizeNew);
	if (styles.size() > StyleDefault) {
		for (; i<sizeNew; i++) {
			if (i != StyleDefault) {
				styles[i] = styles[StyleDefault];
			}
		}
	}
}

void ViewStyle::CreateAndAddFont(const FontSpecification &fs) {
	if (fs.fontName) {
		const FontMap::iterator it = fonts.find(fs);
		if (it == fonts.end()) {
			fonts[fs] = std::make_unique<FontRealised>();
		}
	}
}

FontRealised *ViewStyle::Find(const FontSpecification &fs) {
	if (!fs.fontName)	// Invalid specification so return arbitrary object
		return fonts.begin()->second.get();
	const FontMap::iterator it = fonts.find(fs);
	if (it != fonts.end()) {
		// Should always reach here since map was just set for all styles
		return it->second.get();
	}
	return nullptr;
}

void ViewStyle::FindMaxAscentDescent() noexcept {
	for (size_t i = 0; i < styles.size(); i++) {
		if (i == StyleCallTip ||
		   (autocStyle != StyleDefault && i == static_cast<size_t>(autocStyle)))
			continue;

		const auto &style = styles[i];

		if (maxAscent < style.ascent)
			maxAscent = style.ascent;
		if (maxDescent < style.descent)
			maxDescent = style.descent;
	}
}


================================================
FILE: Libraries/scintilla/src/ViewStyle.h
================================================
// Scintilla source code edit control
/** @file ViewStyle.h
 ** Store information on how the document is to be viewed.
 **/
// Copyright 1998-2001 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#ifndef VIEWSTYLE_H
#define VIEWSTYLE_H

namespace Scintilla::Internal {

/**
 */
class MarginStyle {
public:
	Scintilla::MarginType style;
	ColourRGBA back;
	int width;
	int mask;
	bool sensitive;
	Scintilla::CursorShape cursor;
	MarginStyle(Scintilla::MarginType style_= Scintilla::MarginType::Symbol, int width_=0, int mask_=0) noexcept;
	bool ShowsFolding() const noexcept;
};

/**
 */


class FontRealised {
public:
	FontMeasurements measurements;
	std::shared_ptr<Font> font;
	void Realise(Surface &surface, int zoomLevel, Scintilla::Technology technology, const FontSpecification &fs, const char *localeName);
};

typedef std::map<FontSpecification, std::unique_ptr<FontRealised>> FontMap;

using ColourOptional = std::optional<ColourRGBA>;

inline ColourOptional OptionalColour(Scintilla::uptr_t wParam, Scintilla::sptr_t lParam) noexcept {
	if (wParam) {
		return ColourRGBA::FromIpRGB(lParam);
	} else {
		return {};
	}
}

struct SelectionAppearance {
	// Is the selection visible?
	bool visible = true;
	// Whether to draw on base layer or over text
	Scintilla::Layer layer = Layer::Base;
	// Draw selection past line end characters up to right border
	bool eolFilled = false;
};

struct CaretLineAppearance {
	// Whether to draw on base layer or over text
	Scintilla::Layer layer = Layer::Base;
	// Also show when non-focused
	bool alwaysShow = false;
	// highlight sub line instead of whole line
	bool subLine = false;
	// Non-0: draw a rectangle around line instead of filling line. Value is pixel width of frame
	int frame = 0;
};

struct CaretAppearance {
	// Line, block, over-strike bar ...
	Scintilla::CaretStyle style = CaretStyle::Line;
	// Width in pixels
	int width = 1;
};

struct WrapAppearance {
	// No wrapping, word, character, whitespace appearance
	Scintilla::Wrap state = Wrap::None;
	// Show indication of wrap at line end, line start, or in margin
	Scintilla::WrapVisualFlag visualFlags = WrapVisualFlag::None;
	// Show indication near margin or near text
	Scintilla::WrapVisualLocation visualFlagsLocation = WrapVisualLocation::Default;
	// How much indentation to show wrapping
	int visualStartIndent = 0;
	// WrapIndentMode::Fixed, Same, Indent, DeepIndent
	Scintilla::WrapIndentMode indentMode = WrapIndentMode::Fixed;
};

struct EdgeProperties {
	int column = 0;
	ColourRGBA colour;
	constexpr EdgeProperties(int column_ = 0, ColourRGBA colour_ = ColourRGBA::FromRGB(0)) noexcept :
		column(column_), colour(colour_) {
	}
};

// This is an old style enum so that its members can be used directly as indices without casting
enum StyleIndices {
	StyleDefault = static_cast<int>(Scintilla::StylesCommon::Default),
	StyleLineNumber = static_cast<int>(Scintilla::StylesCommon::LineNumber),
	StyleBraceLight = static_cast<int>(Scintilla::StylesCommon::BraceLight),
	StyleBraceBad = static_cast<int>(Scintilla::StylesCommon::BraceBad),
	StyleControlChar = static_cast<int>(Scintilla::StylesCommon::ControlChar),
	StyleIndentGuide = static_cast<int>(Scintilla::StylesCommon::IndentGuide),
	StyleCallTip = static_cast<int>(Scintilla::StylesCommon::CallTip),
	StyleFoldDisplayText = static_cast<int>(Scintilla::StylesCommon::FoldDisplayText),
};

/**
 */
class ViewStyle {
	UniqueStringSet fontNames;
	FontMap fonts;
public:
	std::vector<Style> styles;
	int nextExtendedStyle;
	std::vector<LineMarker> markers;
	int largestMarkerHeight;
	std::vector<Indicator> indicators;
	bool indicatorsDynamic;
	bool indicatorsSetFore;
	Scintilla::Technology technology;
	int lineHeight;
	int lineOverlap;
	XYPOSITION maxAscent;
	XYPOSITION maxDescent;
	XYPOSITION aveCharWidth;
	XYPOSITION spaceWidth;
	XYPOSITION tabWidth;

	SelectionAppearance selection;

	int controlCharSymbol;
	XYPOSITION controlCharWidth;
	ColourRGBA selbar;
	ColourRGBA selbarlight;
	ColourOptional foldmarginColour;
	ColourOptional foldmarginHighlightColour;
	bool hotspotUnderline;
	/// Margins are ordered: Line Numbers, Selection Margin, Spacing Margin
	int leftMarginWidth;	///< Spacing margin on left of text
	int rightMarginWidth;	///< Spacing margin on right of text
	int maskInLine = 0;	///< Mask for markers to be put into text because there is nowhere for them to go in margin
	int maskDrawInText = 0;	///< Mask for markers that always draw in text
	int maskDrawWrapped = 0;	///< Mask for markers that draw on wrapped lines
	std::vector<MarginStyle> ms;
	int fixedColumnWidth = 0;	///< Total width of margins
	bool marginInside;	///< true: margin included in text view, false: separate views
	int textStart;	///< Starting x position of text within the view
	int zoomLevel;
	Scintilla::WhiteSpace viewWhitespace;
	Scintilla::TabDrawMode tabDrawMode;
	int whitespaceSize;
	Scintilla::IndentView viewIndentationGuides;
	bool viewEOL;

	CaretAppearance caret;

	CaretLineAppearance caretLine;

	bool someStylesProtected;
	bool someStylesForceCase;
	Scintilla::FontQuality extraFontFlag;
	int extraAscent;
	int extraDescent;
	int marginStyleOffset;
	Scintilla::AnnotationVisible annotationVisible;
	int annotationStyleOffset;
	Scintilla::EOLAnnotationVisible eolAnnotationVisible;
	int eolAnnotationStyleOffset;
	bool braceHighlightIndicatorSet;
	int braceHighlightIndicator;
	bool braceBadLightIndicatorSet;
	int braceBadLightIndicator;
	Scintilla::EdgeVisualStyle edgeState;
	EdgeProperties theEdge;
	std::vector<EdgeProperties> theMultiEdge;
	int marginNumberPadding; // the right-side padding of the number margin
	int ctrlCharPadding; // the padding around control character text blobs
	int lastSegItalicsOffset; // the offset so as not to clip italic characters at EOLs
	int autocStyle;

	using ElementMap = std::map<Scintilla::Element, ColourOptional>;
	ElementMap elementColours;
	ElementMap elementBaseColours;
	std::set<Scintilla::Element> elementAllowsTranslucent;

	WrapAppearance wrap;

	std::string localeName;

	ViewStyle(size_t stylesSize_=256);
	ViewStyle(const ViewStyle &source);
	ViewStyle(ViewStyle &&) = delete;
	// Can only be copied through copy constructor which ensures font names initialised correctly
	ViewStyle &operator=(const ViewStyle &) = delete;
	ViewStyle &operator=(ViewStyle &&) = delete;
	~ViewStyle();
	void CalculateMarginWidthAndMask() noexcept;
	void Refresh(Surface &surface, int tabInChars);
	void ReleaseAllExtendedStyles() noexcept;
	int AllocateExtendedStyles(int numberStyles);
	void EnsureStyle(size_t index);
	void ResetDefaultStyle();
	void ClearStyles(size_t from, size_t to); //Au
	void SetStyleFontName(int styleIndex, const char *name);
	void SetFontLocaleName(const char *name);
	bool ProtectionActive() const noexcept;
	int ExternalMarginWidth() const noexcept;
	int MarginFromLocation(Point pt) const noexcept;
	bool ValidStyle(size_t styleIndex) const noexcept;
	void CalcLargestMarkerHeight() noexcept;
	int GetFrameWidth() const noexcept;
	bool IsLineFrameOpaque(bool caretActive, bool lineContainsCaret) const;
	ColourOptional Background(int marksOfLine, bool caretActive, bool lineContainsCaret) const;
	bool SelectionBackgroundDrawn() const noexcept;
	bool SelectionTextDrawn() const;
	bool WhitespaceBackgroundDrawn() const;
	ColourRGBA WrapColour() const;

	void AddMultiEdge(int column, ColourRGBA colour);

	ColourOptional ElementColour(Scintilla::Element element) const;
	ColourRGBA ElementColourForced(Scintilla::Element element) const;
	bool ElementAllowsTranslucent(Scintilla::Element element) const;
	bool ResetElement(Scintilla::Element element);
	bool SetElementColour(Scintilla::Element element, ColourRGBA colour);
	bool SetElementColourOptional(Scintilla::Element element, Scintilla::uptr_t wParam, Scintilla::sptr_t lParam);
	void SetElementRGB(Scintilla::Element element, int rgb);
	void SetElementAlpha(Scintilla::Element element, int alpha);
	bool ElementIsSet(Scintilla::Element element) const;
	bool SetElementBase(Scintilla::Element element, ColourRGBA colour);

	bool SetWrapState(Scintilla::Wrap wrapState_) noexcept;
	bool SetWrapVisualFlags(Scintilla::WrapVisualFlag wrapVisualFlags_) noexcept;
	bool SetWrapVisualFlagsLocation(Scintilla::WrapVisualLocation wrapVisualFlagsLocation_) noexcept;
	bool SetWrapVisualStartIndent(int wrapVisualStartIndent_) noexcept;
	bool SetWrapIndentMode(Scintilla::WrapIndentMode wrapIndentMode_) noexcept;

	bool WhiteSpaceVisible(bool inIndent) const noexcept;

	enum class CaretShape { invisible, line, block, bar };
	bool IsBlockCaretStyle() const noexcept;
	bool IsCaretVisible(bool isMainSelection) const noexcept;
	bool DrawCaretInsideSelection(bool inOverstrike, bool imeCaretBlockOverride) const noexcept;
	CaretShape CaretShapeForMode(bool inOverstrike, bool isMainSelection) const noexcept;

private:
	void AllocStyles(size_t sizeNew);
	void CreateAndAddFont(const FontSpecification &fs);
	FontRealised *Find(const FontSpecification &fs);
	void FindMaxAscentDescent() noexcept;
};

}

#endif


================================================
FILE: Libraries/scintilla/src/XPM.cxx
================================================
// Scintilla source code edit control
/** @file XPM.cxx
 ** Define a class that holds data in the X Pixmap (XPM) format.
 **/
// Copyright 1998-2003 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#include <cstdlib>
#include <cstdint>
#include <cstring>
#include <climits>

#include <stdexcept>
#include <string_view>
#include <vector>
#include <map>
#include <optional>
#include <algorithm>
#include <iterator>
#include <memory>

#include "ScintillaTypes.h"

#include "Debugging.h"
#include "Geometry.h"
#include "Platform.h"

#include "XPM.h"

using namespace Scintilla;
using namespace Scintilla::Internal;

namespace {

const char *NextField(const char *s) noexcept {
	// In case there are leading spaces in the string
	while (*s == ' ') {
		s++;
	}
	while (*s && *s != ' ') {
		s++;
	}
	while (*s == ' ') {
		s++;
	}
	return s;
}

// Data lines in XPM can be terminated either with NUL or "
size_t MeasureLength(const char *s) noexcept {
	size_t i = 0;
	while (s[i] && (s[i] != '\"'))
		i++;
	return i;
}

unsigned int ValueOfHex(const char ch) noexcept {
	if (ch >= '0' && ch <= '9')
		return ch - '0';
	else if (ch >= 'A' && ch <= 'F')
		return ch - 'A' + 10;
	else if (ch >= 'a' && ch <= 'f')
		return ch - 'a' + 10;
	else
		return 0;
}

ColourRGBA ColourFromHex(const char *val) noexcept {
	const unsigned int r = ValueOfHex(val[0]) * 16 + ValueOfHex(val[1]);
	const unsigned int g = ValueOfHex(val[2]) * 16 + ValueOfHex(val[3]);
	const unsigned int b = ValueOfHex(val[4]) * 16 + ValueOfHex(val[5]);
	return ColourRGBA(r, g, b);
}

}


ColourRGBA XPM::ColourFromCode(int ch) const noexcept {
	return colourCodeTable[ch];
}

void XPM::FillRun(Surface *surface, int code, int startX, int y, int x) const {
	if ((code != codeTransparent) && (startX != x)) {
		const PRectangle rc = PRectangle::FromInts(startX, y, x, y + 1);
		surface->FillRectangle(rc, ColourFromCode(code));
	}
}

XPM::XPM(const char *textForm) {
	Init(textForm);
}

XPM::XPM(const char *const *linesForm) {
	Init(linesForm);
}

void XPM::Init(const char *textForm) {
	// Test done is two parts to avoid possibility of overstepping the memory
	// if memcmp implemented strangely. Must be 4 bytes at least at destination.
	if ((0 == memcmp(textForm, "/* X", 4)) && (0 == memcmp(textForm, "/* XPM */", 9))) {
		// Build the lines form out of the text form
		std::vector<const char *> linesForm = LinesFormFromTextForm(textForm);
		if (!linesForm.empty()) {
			Init(linesForm.data());
		}
	} else {
		// It is really in line form
		Init(reinterpret_cast<const char * const *>(textForm));
	}
}

void XPM::Init(const char *const *linesForm) {
	height = 1;
	width = 1;
	nColours = 1;
	pixels.clear();
	codeTransparent = ' ';
	if (!linesForm)
		return;

	std::fill(colourCodeTable, std::end(colourCodeTable), black);
	const char *line0 = linesForm[0];
	width = atoi(line0);
	line0 = NextField(line0);
	height = atoi(line0);
	pixels.resize(width*height);
	line0 = NextField(line0);
	nColours = atoi(line0);
	line0 = NextField(line0);
	if (atoi(line0) != 1) {
		// Only one char per pixel is supported
		return;
	}

	for (int c=0; c<nColours; c++) {
		const char *colourDef = linesForm[c+1];
		const char code = colourDef[0];
		colourDef += 4;
		ColourRGBA colour(0, 0, 0, 0);
		if (*colourDef == '#') {
			colour = ColourFromHex(colourDef+1);
		} else {
			codeTransparent = code;
		}
		colourCodeTable[static_cast<unsigned char>(code)] = colour;
	}

	for (ptrdiff_t y=0; y<height; y++) {
		const char *lform = linesForm[y+nColours+1];
		const size_t len = MeasureLength(lform);
		for (size_t x = 0; x<len; x++)
			pixels[y * width + x] = lform[x];
	}
}

void XPM::Draw(Surface *surface, const PRectangle &rc) {
	if (pixels.empty()) {
		return;
	}
	// Centre the pixmap
	const int startY = static_cast<int>(rc.top + (rc.Height() - height) / 2);
	const int startX = static_cast<int>(rc.left + (rc.Width() - width) / 2);
	for (int y=0; y<height; y++) {
		int prevCode = 0;
		int xStartRun = 0;
		for (int x=0; x<width; x++) {
			const int code = pixels[y * width + x];
			if (code != prevCode) {
				FillRun(surface, prevCode, startX + xStartRun, startY + y, startX + x);
				xStartRun = x;
				prevCode = code;
			}
		}
		FillRun(surface, prevCode, startX + xStartRun, startY + y, startX + width);
	}
}

ColourRGBA XPM::PixelAt(int x, int y) const noexcept {
	if (pixels.empty() || (x < 0) || (x >= width) || (y < 0) || (y >= height)) {
		// Out of bounds -> transparent black
		return ColourRGBA(0, 0, 0, 0);
	}
	const int code = pixels[y * width + x];
	return ColourFromCode(code);
}

std::vector<const char *> XPM::LinesFormFromTextForm(const char *textForm) {
	// Build the lines form out of the text form
	std::vector<const char *> linesForm;
	int countQuotes = 0;
	int strings=1;
	int j=0;
	for (; countQuotes < (2*strings) && textForm[j] != '\0'; j++) {
		if (textForm[j] == '\"') {
			if (countQuotes == 0) {
				// First field: width, height, number of colours, chars per pixel
				const char *line0 = textForm + j + 1;
				// Skip width
				line0 = NextField(line0);
				// Add 1 line for each pixel of height
				strings += atoi(line0);
				line0 = NextField(line0);
				// Add 1 line for each colour
				strings += atoi(line0);
			}
			if (countQuotes / 2 >= strings) {
				break;	// Bad height or number of colours!
			}
			if ((countQuotes & 1) == 0) {
				linesForm.push_back(textForm + j + 1);
			}
			countQuotes++;
		}
	}
	if (textForm[j] == '\0' || countQuotes / 2 > strings) {
		// Malformed XPM! Height + number of colours too high or too low
		linesForm.clear();
	}
	return linesForm;
}

RGBAImage::RGBAImage(int width_, int height_, float scale_, const unsigned char *pixels_) :
	height(height_), width(width_), scale(scale_) {
	if (pixels_) {
		pixelBytes.assign(pixels_, pixels_ + CountBytes());
	} else {
		pixelBytes.resize(CountBytes());
	}
}

RGBAImage::RGBAImage(const XPM &xpm) {
	height = xpm.GetHeight();
	width = xpm.GetWidth();
	scale = 1;
	pixelBytes.resize(CountBytes());
	for (int y=0; y<height; y++) {
		for (int x=0; x<width; x++) {
			SetPixel(x, y, xpm.PixelAt(x, y));
		}
	}
}

float RGBAImage::GetScaledHeight() const noexcept {
	return static_cast<float>(height) / scale;
}

float RGBAImage::GetScaledWidth() const noexcept {
	return static_cast<float>(width) / scale;
}

int RGBAImage::CountBytes() const noexcept {
	return width * height * 4;
}

const unsigned char *RGBAImage::Pixels() const noexcept {
	return pixelBytes.data();
}

void RGBAImage::SetPixel(int x, int y, ColourRGBA colour) noexcept {
	unsigned char *pixel = pixelBytes.data() + (y * width + x) * 4;
	// RGBA
	pixel[0] = colour.GetRed();
	pixel[1] = colour.GetGreen();
	pixel[2] = colour.GetBlue();
	pixel[3] = colour.GetAlpha();
}

namespace {

constexpr unsigned char AlphaMultiplied(unsigned char value, unsigned char alpha) noexcept {
	return (value * alpha / UCHAR_MAX) & 0xffU;
}

}

// Transform a block of pixels from RGBA to BGRA with premultiplied alpha.
// Used for DrawRGBAImage on some platforms.
void RGBAImage::BGRAFromRGBA(unsigned char *pixelsBGRA, const unsigned char *pixelsRGBA, size_t count) noexcept {
	for (size_t i = 0; i < count; i++) {
		const unsigned char alpha = pixelsRGBA[3];
		// Input is RGBA, output is BGRA with premultiplied alpha
		pixelsBGRA[2] = AlphaMultiplied(pixelsRGBA[0], alpha);
		pixelsBGRA[1] = AlphaMultiplied(pixelsRGBA[1], alpha);
		pixelsBGRA[0] = AlphaMultiplied(pixelsRGBA[2], alpha);
		pixelsBGRA[3] = alpha;
		pixelsRGBA += bytesPerPixel;
		pixelsBGRA += bytesPerPixel;
	}
}

RGBAImageSet::RGBAImageSet() : height(-1), width(-1) {
}

/// Remove all images.
void RGBAImageSet::Clear() noexcept {
	images.clear();
	height = -1;
	width = -1;
}

/// Add an image.
void RGBAImageSet::AddImage(int ident, std::unique_ptr<RGBAImage> image) {
	images[ident] = std::move(image);
	height = -1;
	width = -1;
}

/// Get image by id.
RGBAImage *RGBAImageSet::Get(int ident) {
	ImageMap::iterator it = images.find(ident);
	if (it != images.end()) {
		return it->second.get();
	}
	return nullptr;
}

/// Give the largest height of the set.
int RGBAImageSet::GetHeight() const noexcept {
	if (height < 0) {
		for (const std::pair<const int, std::unique_ptr<RGBAImage>> &image : images) {
			if (height < image.second->GetHeight()) {
				height = image.second->GetHeight();
			}
		}
	}
	return (height > 0) ? height : 0;
}

/// Give the largest width of the set.
int RGBAImageSet::GetWidth() const noexcept {
	if (width < 0) {
		for (const std::pair<const int, std::unique_ptr<RGBAImage>> &image : images) {
			if (width < image.second->GetWidth()) {
				width = image.second->GetWidth();
			}
		}
	}
	return (width > 0) ? width : 0;
}


================================================
FILE: Libraries/scintilla/src/XPM.h
================================================
// Scintilla source code edit control
/** @file XPM.h
 ** Define a classes to hold image data in the X Pixmap (XPM) and RGBA formats.
 **/
// Copyright 1998-2003 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#ifndef XPM_H
#define XPM_H

namespace Scintilla::Internal {

/**
 * Hold a pixmap in XPM format.
 */
class XPM {
	int height=1;
	int width=1;
	int nColours=1;
	std::vector<unsigned char> pixels;
	ColourRGBA colourCodeTable[256];
	char codeTransparent=' ';
	ColourRGBA ColourFromCode(int ch) const noexcept;
	void FillRun(Surface *surface, int code, int startX, int y, int x) const;
public:
	explicit XPM(const char *textForm);
	explicit XPM(const char *const *linesForm);
	void Init(const char *textForm);
	void Init(const char *const *linesForm);
	/// Decompose image into runs and use FillRectangle for each run
	void Draw(Surface *surface, const PRectangle &rc);
	int GetHeight() const noexcept { return height; }
	int GetWidth() const noexcept { return width; }
	ColourRGBA PixelAt(int x, int y) const noexcept;
private:
	static std::vector<const char *>LinesFormFromTextForm(const char *textForm);
};

/**
 * A translucent image stored as a sequence of RGBA bytes.
 */
class RGBAImage {
	int height;
	int width;
	float scale;
	std::vector<unsigned char> pixelBytes;
public:
	static constexpr size_t bytesPerPixel = 4;
	RGBAImage(int width_, int height_, float scale_, const unsigned char *pixels_);
	explicit RGBAImage(const XPM &xpm);
	int GetHeight() const noexcept { return height; }
	int GetWidth() const noexcept { return width; }
	float GetScale() const noexcept { return scale; }
	float GetScaledHeight() const noexcept;
	float GetScaledWidth() const noexcept;
	int CountBytes() const noexcept;
	const unsigned char *Pixels() const noexcept;
	void SetPixel(int x, int y, ColourRGBA colour) noexcept;
	static void BGRAFromRGBA(unsigned char *pixelsBGRA, const unsigned char *pixelsRGBA, size_t count) noexcept;
};

/**
 * A collection of RGBAImage pixmaps indexed by integer id.
 */
class RGBAImageSet {
	typedef std::map<int, std::unique_ptr<RGBAImage>> ImageMap;
	ImageMap images;
	mutable int height;	///< Memorize largest height of the set.
	mutable int width;	///< Memorize largest width of the set.
public:
	RGBAImageSet();
	/// Remove all images.
	void Clear() noexcept;
	/// Add an image.
	void AddImage(int ident, std::unique_ptr<RGBAImage> image);
	/// Get image by id.
	RGBAImage *Get(int ident);
	/// Give the largest height of the set.
	int GetHeight() const noexcept;
	/// Give the largest width of the set.
	int GetWidth() const noexcept;
};

}

#endif


================================================
FILE: Libraries/scintilla/version.txt
================================================
557


================================================
FILE: Libraries/scintilla/win32/HanjaDic.cxx
================================================
// Scintilla source code edit control
/** @file HanjaDic.cxx
 ** Korean Hanja Dictionary
 ** Convert between Korean Hanja and Hangul by COM interface.
 **/
// Copyright 2015 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#include <string>
#include <string_view>
#include <memory>

#define WIN32_LEAN_AND_MEAN 1
#include <windows.h>
#include <ole2.h>

#include "WinTypes.h"
#include "HanjaDic.h"

namespace Scintilla::Internal::HanjaDict {

interface IRadical;
interface IHanja;
interface IStrokes;

enum HANJA_TYPE { HANJA_UNKNOWN = 0, HANJA_K0 = 1, HANJA_K1 = 2, HANJA_OTHER = 3 };

interface IHanjaDic : IUnknown {
	STDMETHOD(OpenMainDic)();
	STDMETHOD(CloseMainDic)();
	STDMETHOD(GetHanjaWords)(BSTR bstrHangul, SAFEARRAY* ppsaHanja, VARIANT_BOOL* pfFound);
	STDMETHOD(GetHanjaChars)(unsigned short wchHangul, BSTR* pbstrHanjaChars, VARIANT_BOOL* pfFound);
	STDMETHOD(HanjaToHangul)(BSTR bstrHanja, BSTR* pbstrHangul);
	STDMETHOD(GetHanjaType)(unsigned short wchHanja, HANJA_TYPE* pHanjaType);
	STDMETHOD(GetHanjaSense)(unsigned short wchHanja, BSTR* pbstrSense);
	STDMETHOD(GetRadicalID)(short SeqNumOfRadical, short* pRadicalID, unsigned short* pwchRadical);
	STDMETHOD(GetRadical)(short nRadicalID, IRadical** ppIRadical);
	STDMETHOD(RadicalIDToHanja)(short nRadicalID, unsigned short* pwchRadical);
	STDMETHOD(GetHanja)(unsigned short wchHanja, IHanja** ppIHanja);
	STDMETHOD(GetStrokes)(short nStrokes, IStrokes** ppIStrokes);
	STDMETHOD(OpenDefaultCustomDic)();
	STDMETHOD(OpenCustomDic)(BSTR bstrPath, long* plUdr);
	STDMETHOD(CloseDefaultCustomDic)();
	STDMETHOD(CloseCustomDic)(long lUdr);
	STDMETHOD(CloseAllCustomDics)();
	STDMETHOD(GetDefaultCustomHanjaWords)(BSTR bstrHangul, SAFEARRAY** ppsaHanja, VARIANT_BOOL* pfFound);
	STDMETHOD(GetCustomHanjaWords)(long lUdr, BSTR bstrHangul, SAFEARRAY** ppsaHanja, VARIANT_BOOL* pfFound);
	STDMETHOD(PutDefaultCustomHanjaWord)(BSTR bstrHangul, BSTR bstrHanja);
	STDMETHOD(PutCustomHanjaWord)(long lUdr, BSTR bstrHangul, BSTR bstrHanja);
	STDMETHOD(MaxNumOfRadicals)(short* pVal);
	STDMETHOD(MaxNumOfStrokes)(short* pVal);
	STDMETHOD(DefaultCustomDic)(long* pVal);
	STDMETHOD(DefaultCustomDic)(long pVal);
	STDMETHOD(MaxHanjaType)(HANJA_TYPE* pHanjaType);
	STDMETHOD(MaxHanjaType)(HANJA_TYPE pHanjaType);
};

extern "C" const GUID __declspec(selectany) IID_IHanjaDic =
{ 0xad75f3ac, 0x18cd, 0x48c6, { 0xa2, 0x7d, 0xf1, 0xe9, 0xa7, 0xdc, 0xe4, 0x32 } };

class ScopedBSTR {
	BSTR bstr = nullptr;
public:
	ScopedBSTR() noexcept = default;
	explicit ScopedBSTR(const OLECHAR *psz) noexcept :
		bstr(SysAllocString(psz)) {
	}
	explicit ScopedBSTR(OLECHAR character) noexcept :
		bstr(SysAllocStringLen(&character, 1)) {
	}
	// Deleted so ScopedBSTR objects can not be copied. Moves are OK.
	ScopedBSTR(const ScopedBSTR &) = delete;
	ScopedBSTR &operator=(const ScopedBSTR &) = delete;
	// Moves are OK.
	ScopedBSTR(ScopedBSTR &&) = default;
	ScopedBSTR &operator=(ScopedBSTR &&) = default;
	~ScopedBSTR() {
		SysFreeString(bstr);
	}

	BSTR get() const noexcept {
		return bstr;
	}
	void reset(BSTR value=nullptr) noexcept {
		// https://en.cppreference.com/w/cpp/memory/unique_ptr/reset
		BSTR const old = bstr;
		bstr = value;
		SysFreeString(old);
	}
};

class HanjaDic {
	std::unique_ptr<IHanjaDic, UnknownReleaser> HJinterface;

	bool OpenHanjaDic(LPCOLESTR lpszProgID) noexcept {
		CLSID CLSID_HanjaDic;
		HRESULT hr = CLSIDFromProgID(lpszProgID, &CLSID_HanjaDic);
		if (SUCCEEDED(hr)) {
			IHanjaDic *instance = nullptr;
			hr = CoCreateInstance(CLSID_HanjaDic, nullptr,
				CLSCTX_INPROC_SERVER, IID_IHanjaDic,
				reinterpret_cast<LPVOID *>(&instance));
			if (SUCCEEDED(hr) && instance) {
				HJinterface.reset(instance);
				hr = instance->OpenMainDic();
				return SUCCEEDED(hr);
			}
		}
		return false;
	}

public:
	bool Open() noexcept {
		return OpenHanjaDic(OLESTR("imkrhjd.hanjadic"))
			|| OpenHanjaDic(OLESTR("mshjdic.hanjadic"));
	}

	void Close() const noexcept {
		HJinterface->CloseMainDic();
	}

	bool IsHanja(wchar_t hanja) const noexcept {
		HANJA_TYPE hanjaType = HANJA_UNKNOWN;
		const HRESULT hr = HJinterface->GetHanjaType(hanja, &hanjaType);
		return SUCCEEDED(hr) && hanjaType > HANJA_UNKNOWN;
	}

	bool HanjaToHangul(const ScopedBSTR &bstrHanja, ScopedBSTR &bstrHangul) const noexcept {
		BSTR result = nullptr;
		const HRESULT hr = HJinterface->HanjaToHangul(bstrHanja.get(), &result);
		bstrHangul.reset(result);
		return SUCCEEDED(hr);
	}
};

bool GetHangulOfHanja(std::wstring &inout) noexcept {
	// Convert every hanja to hangul.
	// Return whether any character been converted.
	// Hanja linked to different notes in Hangul have different codes,
	// so current character based conversion is enough.
	// great thanks for BLUEnLIVE.
	bool changed = false;
	HanjaDic dict;
	if (dict.Open()) {
		for (wchar_t &character : inout) {
			if (dict.IsHanja(character)) { // Pass hanja only!
				ScopedBSTR bstrHangul;
				if (dict.HanjaToHangul(ScopedBSTR(character), bstrHangul)) {
					changed = true;
					character = *(bstrHangul.get());
				}
			}
		}
		dict.Close();
	}
	return changed;
}

}


================================================
FILE: Libraries/scintilla/win32/HanjaDic.h
================================================
// Scintilla source code edit control
/** @file HanjaDic.h
 ** Korean Hanja Dictionary
 ** Convert between Korean Hanja and Hangul by COM interface.
 **/
// Copyright 2015 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#ifndef HANJADIC_H
#define HANJADIC_H

namespace Scintilla::Internal {

namespace HanjaDict {

bool GetHangulOfHanja(std::wstring &inout) noexcept;

}

}

#endif


================================================
FILE: Libraries/scintilla/win32/ListBox.cxx
================================================
// Scintilla source code edit control
/** @file ListBox.cxx
 ** Implementation of list box on Windows.
 **/
// Copyright 1998-2003 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#include <cstddef>
#include <cstdlib>
#include <cstdint>
#include <cstring>
#include <cstdio>
#include <cstdarg>
#include <ctime>
#include <cmath>
#include <climits>

#include <string_view>
#include <vector>
#include <map>
#include <optional>
#include <algorithm>
#include <iterator>
#include <memory>
#include <mutex>

// Want to use std::min and std::max so don't want Windows.h version of min and max
#if !defined(NOMINMAX)
#define NOMINMAX
#endif
#undef _WIN32_WINNT
#define _WIN32_WINNT 0x0A00
#undef WINVER
#define WINVER 0x0A00
#define WIN32_LEAN_AND_MEAN 1
#include <windows.h>
#include <commctrl.h>
#include <richedit.h>
#include <windowsx.h>
#include <shellscalingapi.h>

#include <wrl.h>
using Microsoft::WRL::ComPtr;

#if !defined(DISABLE_D2D)
#define USE_D2D 1
#endif

#if defined(USE_D2D)
#include <d2d1_1.h>
#include <d3d11_1.h>
#include <dwrite_1.h>
#endif

#include "ScintillaTypes.h"

#include "Debugging.h"
#include "Geometry.h"
#include "Platform.h"
#include "XPM.h"
#include "UniConversion.h"
#include "DBCS.h"

#include "WinTypes.h"
#include "PlatWin.h"
#include "ListBox.h"
#if defined(USE_D2D)
#include "SurfaceD2D.h"
#endif

using namespace Scintilla;
using namespace Scintilla::Internal;

namespace {

void *PtrFromLParam(Scintilla::sptr_t lParam) noexcept {
	return reinterpret_cast<void *>(lParam);
}

struct ListItemData {
	const char *text;
	int pixId;
};

class LineToItem {
	std::vector<char> words;

	std::vector<ListItemData> data;

public:
	void Clear() noexcept {
		words.clear();
		data.clear();
	}

	[[nodiscard]] ListItemData Get(size_t index) const noexcept {
		if (index < data.size()) {
			return data[index];
		}
		ListItemData missing = {"", -1};
		return missing;
	}
	[[nodiscard]] int Count() const noexcept {
		return static_cast<int>(data.size());
	}

	void AllocItem(const char *text, int pixId) {
		const ListItemData lid = { text, pixId };
		data.push_back(lid);
	}

	char *SetWords(const char *s) {
		words = std::vector<char>(s, s+strlen(s)+1);
		return words.data();
	}
};

const TCHAR ListBoxX_ClassName[] = TEXT("ListBoxX");

ColourRGBA ColourElement(std::optional<ColourRGBA> colour, int nIndex) {
	if (colour.has_value()) {
		return colour.value();
	}
	return ColourFromSys(nIndex);
}

struct LBGraphics {
	GDIBitMap bm;
	std::unique_ptr<Surface> pixmapLine;
#if defined(USE_D2D)
	DCRenderTarget pBMDCTarget;
#endif

	void Release() noexcept {
		pixmapLine.reset();
#if defined(USE_D2D)
		pBMDCTarget = nullptr;
#endif
		bm.Release();
	}
};

}

class ListBoxX : public ListBox {
	int lineHeight = 10;
	HFONT fontCopy {};
	std::unique_ptr<FontWin> fontWin;
	Technology technology = Technology::Default;
	RGBAImageSet images;
	LineToItem lti;
	HWND lb {};
	bool unicodeMode = false;
	int codePage = 0;
	int desiredVisibleRows = 9;
	int maxItemCharacters = 0;
	unsigned int aveCharWidth = 8;
	Window *parent = nullptr;
	WNDPROC prevWndProc{};
	int ctrlID = 0;
	UINT dpi = USER_DEFAULT_SCREEN_DPI;
	IListBoxDelegate *delegate = nullptr;
	unsigned int maxCharWidth = 1;
	WPARAM resizeHit = 0;
	PRectangle rcPreSize;
	Point dragOffset;
	Point location;	// Caret location at which the list is opened
	MouseWheelDelta wheelDelta;
	ListOptions options;
	DWORD frameStyle = WS_THICKFRAME;

	LBGraphics graphics;

	HWND GetHWND() const noexcept;
	void AppendListItem(const char *text, const char *numword);
	void AdjustWindowRect(PRectangle *rc, UINT dpiAdjust) const noexcept;
	int ItemHeight() const noexcept;
	int MinClientWidth() const noexcept;
	int TextOffset() const noexcept;
	POINT GetClientExtent() const noexcept;
	POINT MinTrackSize() const noexcept;
	POINT MaxTrackSize() const noexcept;
	void SetRedraw(bool on) noexcept;
	void OnDoubleClick();
	void OnSelChange();
	void ResizeToCursor();
	void StartResize(WPARAM);
	LRESULT NcHitTest(WPARAM, LPARAM) const;
	void CentreItem(int n);
	void AllocateBitMap();
	LRESULT PASCAL ListProc(HWND hWnd, UINT iMessage, WPARAM wParam, LPARAM lParam);
	static LRESULT PASCAL ControlWndProc(HWND hWnd, UINT iMessage, WPARAM wParam, LPARAM lParam);

	static constexpr POINT ItemInset {0, 0};	// Padding around whole item
	static constexpr POINT TextInset {2, 0};	// Padding around text
	static constexpr POINT ImageInset {1, 0};	// Padding around image

public:
	ListBoxX() = default;
	ListBoxX(const ListBoxX &) = delete;
	ListBoxX(ListBoxX &&) = delete;
	ListBoxX &operator=(const ListBoxX &) = delete;
	ListBoxX &operator=(ListBoxX &&) = delete;
	~ListBoxX() noexcept override {
		if (fontCopy) {
			::DeleteObject(fontCopy);
			fontCopy = {};
		}
		graphics.Release();
	}
	void SetFont(const Font *font) override;
	void Create(Window &parent_, int ctrlID_, Point location_, int lineHeight_, bool unicodeMode_, Technology technology_) override;
	void SetAverageCharWidth(int width) override;
	void SetVisibleRows(int rows) override;
	int GetVisibleRows() const override;
	PRectangle GetDesiredRect() override;
	int CaretFromEdge() override;
	void Clear() noexcept override;
	void Append(char *s, int type) override;
	int Length() override;
	void Select(int n) override;
	int GetSelection() override;
	int Find(const char *prefix) override;
	std::string GetValue(int n) override;
	void RegisterImage(int type, const char *xpm_data) override;
	void RegisterRGBAImage(int type, int width, int height, const unsigned char *pixelsImage) override;
	void ClearRegisteredImages() override;
	void SetDelegate(IListBoxDelegate *lbDelegate) override;
	void SetList(const char *list, char separator, char typesep) override;
	void SetOptions(ListOptions options_) override;
	void Draw(DRAWITEMSTRUCT *pDrawItem);
	LRESULT WndProc(HWND hWnd, UINT iMessage, WPARAM wParam, LPARAM lParam);
	static LRESULT PASCAL StaticWndProc(HWND hWnd, UINT iMessage, WPARAM wParam, LPARAM lParam);
};

std::unique_ptr<ListBox> ListBox::Allocate() {
	return std::make_unique<ListBoxX>();
}

void ListBoxX::Create(Window &parent_, int ctrlID_, Point location_, int lineHeight_, bool unicodeMode_, Technology technology_) {
	parent = &parent_;
	ctrlID = ctrlID_;
	location = location_;
	lineHeight = lineHeight_;
	unicodeMode = unicodeMode_;
	codePage = unicodeMode ? CpUtf8 : 0;
	technology = technology_;
	HWND hwndParent = HwndFromWindow(*parent);
	HINSTANCE hinstanceParent = GetWindowInstance(hwndParent);
	// Window created as popup so not clipped within parent client area
	wid = ::CreateWindowEx(
		WS_EX_WINDOWEDGE, ListBoxX_ClassName, TEXT(""),
		WS_POPUP | frameStyle,
		100,100, 150,80, hwndParent,
		{},
		hinstanceParent,
		this);

	dpi = DpiForWindow(hwndParent);
	POINT locationw = POINTFromPoint(location);
	::MapWindowPoints(hwndParent, {}, &locationw, 1);
	location = PointFromPOINT(locationw);
}

void ListBoxX::SetFont(const Font *font) {
	const FontWin *pfm = dynamic_cast<const FontWin *>(font);
	if (pfm) {
		if (fontCopy) {
			::DeleteObject(fontCopy);
			fontCopy = {};
		}
		fontCopy = pfm->HFont();
		SetWindowFont(lb, fontCopy, 0);
		fontWin = pfm->Duplicate();
		codePage = unicodeMode ? CpUtf8 : CodePageFromCharSet(fontWin->GetCharacterSet(), 1252);
		graphics.Release();
	}
}

void ListBoxX::SetAverageCharWidth(int width) {
	aveCharWidth = width;
}

void ListBoxX::SetVisibleRows(int rows) {
	desiredVisibleRows = rows;
}

int ListBoxX::GetVisibleRows() const {
	return desiredVisibleRows;
}

HWND ListBoxX::GetHWND() const noexcept {
	return HwndFromWindowID(GetID());
}

PRectangle ListBoxX::GetDesiredRect() {
	PRectangle rcDesired = GetPosition();

	int rows = Length();
	if ((rows == 0) || (rows > desiredVisibleRows))
		rows = desiredVisibleRows;
	rcDesired.bottom = rcDesired.top + ItemHeight() * rows;

	int width = MinClientWidth();
	int textSize = 0;
	int averageCharWidth = 8;

	// Make a measuring surface
	std::unique_ptr<Surface> surfaceItem(Surface::Allocate(technology));
	surfaceItem->Init(GetID());
	surfaceItem->SetMode(SurfaceMode(codePage, false));

	// Find the widest item in pixels
	const int items = lti.Count();
	for (int i = 0; i < items; i++) {
		const ListItemData item = lti.Get(i);
		const int itemTextSize = static_cast<int>(std::ceil(
			surfaceItem->WidthText(fontWin.get(), item.text)));
		textSize = std::max(textSize, itemTextSize);
	}

	maxCharWidth = static_cast<int>(std::ceil(surfaceItem->WidthText(fontWin.get(), "W")));
	averageCharWidth = static_cast<int>(surfaceItem->AverageCharWidth(fontWin.get()));

	width = std::max({ width, textSize, (maxItemCharacters + 1) * averageCharWidth });

	rcDesired.right = rcDesired.left + TextOffset() + width + (TextInset.x * 2);
	if (Length() > rows)
		rcDesired.right += SystemMetricsForDpi(SM_CXVSCROLL, dpi);

	AdjustWindowRect(&rcDesired, dpi);
	return rcDesired;
}

int ListBoxX::TextOffset() const noexcept {
	const int pixWidth = images.GetWidth();
	return pixWidth == 0 ? ItemInset.x : ItemInset.x + pixWidth + (ImageInset.x * 2);
}

int ListBoxX::CaretFromEdge() {
	PRectangle rc;
	AdjustWindowRect(&rc, dpi);
	return TextOffset() + static_cast<int>(TextInset.x + (0 - rc.left) - 1);
}

void ListBoxX::Clear() noexcept {
	ListBox_ResetContent(lb);
	maxItemCharacters = 0;
	lti.Clear();
}

void ListBoxX::Append(char *, int) {
	// This method is no longer called in Scintilla
	PLATFORM_ASSERT(false);
}

int ListBoxX::Length() {
	return lti.Count();
}

void ListBoxX::Select(int n) {
	// We are going to scroll to centre on the new selection and then select it, so disable
	// redraw to avoid flicker caused by a painting new selection twice in unselected and then
	// selected states
	SetRedraw(false);
	CentreItem(n);
	ListBox_SetCurSel(lb, n);
	OnSelChange();
	SetRedraw(true);
}

int ListBoxX::GetSelection() {
	return ListBox_GetCurSel(lb);
}

// This is not actually called at present
int ListBoxX::Find(const char *) {
	return LB_ERR;
}

std::string ListBoxX::GetValue(int n) {
	const ListItemData item = lti.Get(n);
	return item.text;
}

void ListBoxX::RegisterImage(int type, const char *xpm_data) {
	XPM xpmImage(xpm_data);
	images.AddImage(type, std::make_unique<RGBAImage>(xpmImage));
}

void ListBoxX::RegisterRGBAImage(int type, int width, int height, const unsigned char *pixelsImage) {
	images.AddImage(type, std::make_unique<RGBAImage>(width, height, 1.0f, pixelsImage));
}

void ListBoxX::ClearRegisteredImages() {
	images.Clear();
}

void ListBoxX::Draw(DRAWITEMSTRUCT *pDrawItem) {
	if ((pDrawItem->itemAction != ODA_SELECT) && (pDrawItem->itemAction != ODA_DRAWENTIRE)) {
		return;
	}
	if (!graphics.pixmapLine) {
		AllocateBitMap();
		if (!graphics.pixmapLine) {
			// Failed to allocate, so release fully and give up
			graphics.Release();
			return;
		}
	}
#if defined(USE_D2D)
	if (graphics.pBMDCTarget) {
		graphics.pBMDCTarget->BeginDraw();
	}
#endif

	const PRectangle rcItemBase = PRectangleFromRECT(pDrawItem->rcItem);
	const PRectangle rcItem(0, 0, rcItemBase.Width(), rcItemBase.Height());
	PRectangle rcBox = rcItem;
	rcBox.left += TextOffset();
	ColourRGBA colourFore;
	ColourRGBA colourBack;
	if (pDrawItem->itemState & ODS_SELECTED) {
		PRectangle rcImage = rcItem;
		rcImage.right = rcBox.left;
		// The image is not highlighted
		graphics.pixmapLine->FillRectangle(rcImage, ColourElement(options.back, COLOR_WINDOW));
		colourBack = ColourElement(options.backSelected, COLOR_HIGHLIGHT);
		graphics.pixmapLine->FillRectangle(rcBox, colourBack);
		colourFore = ColourElement(options.foreSelected, COLOR_HIGHLIGHTTEXT);
	} else {
		colourBack = ColourElement(options.back, COLOR_WINDOW);
		graphics.pixmapLine->FillRectangle(rcItem, colourBack);
		colourFore = ColourElement(options.fore, COLOR_WINDOWTEXT);
	}

	const ListItemData item = lti.Get(pDrawItem->itemID);
	const int pixId = item.pixId;
	const char *text = item.text;

	const PRectangle rcText = rcBox.Inset(Point(TextInset.x, TextInset.y));

	const double ascent = graphics.pixmapLine->Ascent(fontWin.get());
	graphics.pixmapLine->DrawTextClipped(rcText, fontWin.get(), rcText.top + ascent, text, colourFore, colourBack);

	// Draw the image, if any
	const RGBAImage *pimage = images.Get(pixId);
	if (pimage) {
		const XYPOSITION left = rcItem.left + ItemInset.x + ImageInset.x;
		PRectangle rcImage = rcItem;
		rcImage.left = left;
		rcImage.right = rcImage.left + images.GetWidth();
		graphics.pixmapLine->DrawRGBAImage(rcImage,
			pimage->GetWidth(), pimage->GetHeight(), pimage->Pixels());
	}

#if defined(USE_D2D)
	if (graphics.pBMDCTarget) {
		const HRESULT hrEnd = graphics.pBMDCTarget->EndDraw();
		if (FAILED(hrEnd)) {
			return;
		}
	}
#endif

	// Blit from hMemDC to hDC
	const SIZE extent = SizeOfRect(pDrawItem->rcItem);
	::BitBlt(pDrawItem->hDC, pDrawItem->rcItem.left, pDrawItem->rcItem.top, extent.cx, extent.cy, graphics.bm.DC(), 0, 0, SRCCOPY);
}

void ListBoxX::AppendListItem(const char *text, const char *numword) {
	int pixId = -1;
	if (numword) {
		pixId = 0;
		char ch;
		while ((ch = *++numword) != '\0') {
			pixId = 10 * pixId + (ch - '0');
		}
	}

	lti.AllocItem(text, pixId);
	maxItemCharacters = std::max(maxItemCharacters, static_cast<int>(strlen(text)));
}

void ListBoxX::SetDelegate(IListBoxDelegate *lbDelegate) {
	delegate = lbDelegate;
}

void ListBoxX::SetList(const char *list, char separator, char typesep) {
	// Turn off redraw while populating the list - this has a significant effect, even if
	// the listbox is not visible.
	SetRedraw(false);
	Clear();
	const size_t size = strlen(list);
	char *words = lti.SetWords(list);
	const char *startword = words;
	char *numword = nullptr;
	for (size_t i=0; i < size; i++) {
		if (words[i] == separator) {
			words[i] = '\0';
			if (numword)
				*numword = '\0';
			AppendListItem(startword, numword);
			startword = words + i + 1;
			numword = nullptr;
		} else if (words[i] == typesep) {
			numword = words + i;
		}
	}
	if (startword) {
		if (numword)
			*numword = '\0';
		AppendListItem(startword, numword);
	}

	// Finally populate the listbox itself with the correct number of items
	const int count = lti.Count();
	::SendMessage(lb, LB_INITSTORAGE, count, 0);
	for (intptr_t j=0; j<count; j++) {
		ListBox_AddItemData(lb, j+1);
	}
	SetRedraw(true);
}

void ListBoxX::SetOptions(ListOptions options_) {
	options = options_;
	frameStyle = FlagSet(options.options, AutoCompleteOption::FixedSize) ? WS_BORDER : WS_THICKFRAME;
}

void ListBoxX::AdjustWindowRect(PRectangle *rc, UINT dpiAdjust) const noexcept {
	RECT rcw = RectFromPRectangle(*rc);
	AdjustWindowRectForDpi(&rcw, frameStyle, dpiAdjust);
	*rc = PRectangleFromRECT(rcw);
}

int ListBoxX::ItemHeight() const noexcept {
	int itemHeight = lineHeight + (TextInset.y * 2);
	const int pixHeight = images.GetHeight() + (ImageInset.y * 2);
	if (itemHeight < pixHeight) {
		itemHeight = pixHeight;
	}
	return itemHeight;
}

int ListBoxX::MinClientWidth() const noexcept {
	return 12 * (aveCharWidth+aveCharWidth/3);
}

POINT ListBoxX::MinTrackSize() const noexcept {
	PRectangle rc = PRectangle::FromInts(0, 0, MinClientWidth(), ItemHeight());
	AdjustWindowRect(&rc, dpi);
	POINT ret = {static_cast<LONG>(rc.Width()), static_cast<LONG>(rc.Height())};
	return ret;
}

POINT ListBoxX::MaxTrackSize() const noexcept {
	PRectangle rc = PRectangle::FromInts(0, 0,
		std::max<int>(static_cast<unsigned int>(MinClientWidth()),
		maxCharWidth * maxItemCharacters + TextInset.x * 2 +
		 TextOffset() + SystemMetricsForDpi(SM_CXVSCROLL, dpi)),
		ItemHeight() * lti.Count());
	AdjustWindowRect(&rc, dpi);
	POINT ret = {static_cast<LONG>(rc.Width()), static_cast<LONG>(rc.Height())};
	return ret;
}

void ListBoxX::SetRedraw(bool on) noexcept {
	::SendMessage(lb, WM_SETREDRAW, on, 0);
	if (on) {
		::RedrawWindow(lb, {}, {}, RDW_ERASE | RDW_FRAME | RDW_INVALIDATE | RDW_ALLCHILDREN);
	}
}

void ListBoxX::ResizeToCursor() {
	PRectangle rc = GetPosition();
	POINT ptw;
	::GetCursorPos(&ptw);
	const Point pt = PointFromPOINT(ptw) + dragOffset;

	switch (resizeHit) {
		case HTLEFT:
			rc.left = pt.x;
			break;
		case HTRIGHT:
			rc.right = pt.x;
			break;
		case HTTOP:
			rc.top = pt.y;
			break;
		case HTTOPLEFT:
			rc.top = pt.y;
			rc.left = pt.x;
			break;
		case HTTOPRIGHT:
			rc.top = pt.y;
			rc.right = pt.x;
			break;
		case HTBOTTOM:
			rc.bottom = pt.y;
			break;
		case HTBOTTOMLEFT:
			rc.bottom = pt.y;
			rc.left = pt.x;
			break;
		case HTBOTTOMRIGHT:
			rc.bottom = pt.y;
			rc.right = pt.x;
			break;
		default:
			break;
	}

	const POINT ptMin = MinTrackSize();
	const POINT ptMax = MaxTrackSize();
	// We don't allow the left edge to move at present, but just in case
	rc.left = std::clamp(rc.left, rcPreSize.right - ptMax.x, rcPreSize.right - ptMin.x);
	rc.top = std::clamp(rc.top, rcPreSize.bottom - ptMax.y, rcPreSize.bottom - ptMin.y);
	rc.right = std::clamp(rc.right, rcPreSize.left + ptMin.x, rcPreSize.left + ptMax.x);
	rc.bottom = std::clamp(rc.bottom, rcPreSize.top + ptMin.y, rcPreSize.top + ptMax.y);

	SetPosition(rc);
}

void ListBoxX::StartResize(WPARAM hitCode) {
	rcPreSize = GetPosition();
	POINT cursorPos;
	::GetCursorPos(&cursorPos);

	switch (hitCode) {
		case HTRIGHT:
		case HTBOTTOM:
		case HTBOTTOMRIGHT:
			dragOffset.x = rcPreSize.right - cursorPos.x;
			dragOffset.y = rcPreSize.bottom - cursorPos.y;
			break;

		case HTTOPRIGHT:
			dragOffset.x = rcPreSize.right - cursorPos.x;
			dragOffset.y = rcPreSize.top - cursorPos.y;
			break;

		// Note that the current hit test code prevents the left edge cases ever firing
		// as we don't want the left edge to be movable
		case HTLEFT:
		case HTTOP:
		case HTTOPLEFT:
			dragOffset.x = rcPreSize.left - cursorPos.x;
			dragOffset.y = rcPreSize.top - cursorPos.y;
			break;
		case HTBOTTOMLEFT:
			dragOffset.x = rcPreSize.left - cursorPos.x;
			dragOffset.y = rcPreSize.bottom - cursorPos.y;
			break;

		default:
			return;
	}

	::SetCapture(GetHWND());
	resizeHit = hitCode;
}

LRESULT ListBoxX::NcHitTest(WPARAM wParam, LPARAM lParam) const {
	const PRectangle rc = GetPosition();

	LRESULT hit = ::DefWindowProc(GetHWND(), WM_NCHITTEST, wParam, lParam);
	// There is an apparent bug in the DefWindowProc hit test code whereby it will
	// return HTTOPXXX if the window in question is shorter than the default
	// window caption height + frame, even if one is hovering over the bottom edge of
	// the frame, so workaround that here
	if (hit >= HTTOP && hit <= HTTOPRIGHT) {
		const int minHeight = SystemMetricsForDpi(SM_CYMINTRACK, dpi);
		const int yPos = GET_Y_LPARAM(lParam);
		if ((rc.Height() < minHeight) && (yPos > ((rc.top + rc.bottom)/2))) {
			hit += HTBOTTOM - HTTOP;
		}
	}

	// Never permit resizing that moves the left edge. Allow movement of top or bottom edge
	// depending on whether the list is above or below the caret
	switch (hit) {
		case HTLEFT:
		case HTTOPLEFT:
		case HTBOTTOMLEFT:
			hit = HTERROR;
			break;

		case HTTOP:
		case HTTOPRIGHT: {
				// Valid only if caret below list
				if (location.y < rc.top)
					hit = HTERROR;
			}
			break;

		case HTBOTTOM:
		case HTBOTTOMRIGHT: {
				// Valid only if caret above list
				if (rc.bottom <= location.y)
					hit = HTERROR;
			}
			break;
		default:
			break;
	}

	return hit;
}

void ListBoxX::OnDoubleClick() {
	if (delegate) {
		ListBoxEvent event(ListBoxEvent::EventType::doubleClick);
		delegate->ListNotify(&event);
	}
}

void ListBoxX::OnSelChange() {
	if (delegate) {
		ListBoxEvent event(ListBoxEvent::EventType::selectionChange);
		delegate->ListNotify(&event);
	}
}

POINT ListBoxX::GetClientExtent() const noexcept {
	RECT rc;
	::GetWindowRect(HwndFromWindowID(wid), &rc);
	POINT ret { rc.right - rc.left, rc.bottom - rc.top };
	return ret;
}

void ListBoxX::CentreItem(int n) {
	// If below mid point, scroll up to centre, but with more items below if uneven
	if (n >= 0) {
		const POINT extent = GetClientExtent();
		const int visible = extent.y/ItemHeight();
		if (visible < Length()) {
			const int top = ListBox_GetTopIndex(lb);
			const int half = (visible - 1) / 2;
			if (n > (top + half))
				ListBox_SetTopIndex(lb, n - half);
		}
	}
}

void ListBoxX::AllocateBitMap() {
	const SIZE extent { GetClientExtent().x, lineHeight };

	graphics.bm.Create({}, extent.cx, -extent.cy, nullptr);
	if (!graphics.bm) {
		return;
	}

	// Make a surface
	graphics.pixmapLine = Surface::Allocate(technology);
	graphics.pixmapLine->SetMode(SurfaceMode(codePage, false));

#if defined(USE_D2D)
	if (technology != Technology::Default) {
		if (!LoadD2D()) {
			return;
		}

		const D2D1_RENDER_TARGET_PROPERTIES drtp = D2D1::RenderTargetProperties(
			D2D1_RENDER_TARGET_TYPE_DEFAULT,
			{ DXGI_FORMAT_B8G8R8A8_UNORM, D2D1_ALPHA_MODE_PREMULTIPLIED });

		HRESULT hr = CreateDCRenderTarget(&drtp, graphics.pBMDCTarget);
		if (FAILED(hr) || !graphics.pBMDCTarget) {
			return;
		}

		const RECT rcExtent = { 0, 0, extent.cx, extent.cy };
		hr = graphics.pBMDCTarget->BindDC(graphics.bm.DC(), &rcExtent);
		if (SUCCEEDED(hr)) {
			graphics.pixmapLine->Init(graphics.pBMDCTarget.Get(), GetID());
		}
		return;
	}
#endif

	// Either technology == Technology::Default or USE_D2D turned off
	graphics.pixmapLine->Init(graphics.bm.DC(), GetID());
}

LRESULT PASCAL ListBoxX::ListProc(HWND hWnd, UINT iMessage, WPARAM wParam, LPARAM lParam) {
	try {
		switch (iMessage) {
		case WM_ERASEBKGND:
			return TRUE;

		case WM_MOUSEACTIVATE:
			// This prevents the view activating when the scrollbar is clicked
			return MA_NOACTIVATE;

		case WM_LBUTTONDOWN: {
				// We must take control of selection to prevent the ListBox activating
				// the popup
				const LRESULT lResult = ::SendMessage(hWnd, LB_ITEMFROMPOINT, 0, lParam);
				if (HIWORD(lResult) == 0) {
					ListBox_SetCurSel(hWnd, LOWORD(lResult));
					OnSelChange();
				}
			}
			return 0;

		case WM_LBUTTONUP:
			return 0;

		case WM_LBUTTONDBLCLK:
			OnDoubleClick();
			return 0;

		case WM_MBUTTONDOWN:
			// disable the scroll wheel button click action
			return 0;

		default:
			break;
		}

		if (prevWndProc) {
			return ::CallWindowProc(prevWndProc, hWnd, iMessage, wParam, lParam);
		}
	} catch (...) {
	}
	return ::DefWindowProc(hWnd, iMessage, wParam, lParam);
}

LRESULT PASCAL ListBoxX::ControlWndProc(HWND hWnd, UINT iMessage, WPARAM wParam, LPARAM lParam) {
	if (ListBoxX *lbx = static_cast<ListBoxX *>(PointerFromWindow(::GetParent(hWnd)))) {
		return lbx->ListProc(hWnd, iMessage, wParam, lParam);
	}
	return ::DefWindowProc(hWnd, iMessage, wParam, lParam);
}

LRESULT ListBoxX::WndProc(HWND hWnd, UINT iMessage, WPARAM wParam, LPARAM lParam) {
	switch (iMessage) {
	case WM_CREATE: {
			HINSTANCE hinstanceParent = GetWindowInstance(HwndFromWindow(*parent));
			// Note that LBS_NOINTEGRALHEIGHT is specified to fix cosmetic issue when resizing the list
			// but has useful side effect of speeding up list population significantly
			lb = ::CreateWindowExW(
				0, WC_LISTBOXW, L"",
				WS_CHILD | WS_VSCROLL | WS_VISIBLE |
				LBS_OWNERDRAWFIXED | LBS_NODATA | LBS_NOINTEGRALHEIGHT,
				0, 0, 150,80, hWnd,
				reinterpret_cast<HMENU>(static_cast<ptrdiff_t>(ctrlID)),
				hinstanceParent,
				nullptr);
			prevWndProc = SubclassWindow(lb, ControlWndProc);
		}
		break;

	case WM_SIZE:
		if (lb) {
			graphics.Release();	// Bitmap must be reallocated to new size.
			SetRedraw(false);
			::SetWindowPos(lb, {}, 0, 0, LOWORD(lParam), HIWORD(lParam), SWP_NOZORDER | SWP_NOACTIVATE | SWP_NOMOVE);
			// Ensure the selection remains visible
			CentreItem(GetSelection());
			SetRedraw(true);
		}
		break;

	case WM_PAINT: {
			Painter painter(hWnd);
		}
		break;

	case WM_COMMAND:
		// This is not actually needed now - the registered double click action is used
		// directly to action a choice from the list.
		::SendMessage(HwndFromWindow(*parent), iMessage, wParam, lParam);
		break;

	case WM_MEASUREITEM: {
			MEASUREITEMSTRUCT *pMeasureItem = static_cast<MEASUREITEMSTRUCT *>(PtrFromLParam(lParam));
			pMeasureItem->itemHeight = ItemHeight();
		}
		break;

	case WM_DRAWITEM:
		Draw(static_cast<DRAWITEMSTRUCT *>(PtrFromLParam(lParam)));
		break;

	case WM_DESTROY:
		lb = {};
		SetWindowPointer(hWnd, nullptr);
		return ::DefWindowProc(hWnd, iMessage, wParam, lParam);

	case WM_ERASEBKGND:
		// To reduce flicker we can elide background erasure since this window is
		// completely covered by its child.
		return TRUE;

	case WM_GETMINMAXINFO: {
			MINMAXINFO *minMax = static_cast<MINMAXINFO*>(PtrFromLParam(lParam));
			minMax->ptMaxTrackSize = MaxTrackSize();
			minMax->ptMinTrackSize = MinTrackSize();
		}
		break;

	case WM_MOUSEACTIVATE:
		return MA_NOACTIVATE;

	case WM_NCHITTEST:
		return NcHitTest(wParam, lParam);

	case WM_NCLBUTTONDOWN:
		// We have to implement our own window resizing because the DefWindowProc
		// implementation insists on activating the resized window
		StartResize(wParam);
		return 0;

	case WM_MOUSEMOVE: {
			if (resizeHit == 0) {
				return ::DefWindowProc(hWnd, iMessage, wParam, lParam);
			}
			ResizeToCursor();
		}
		break;

	case WM_LBUTTONUP:
	case WM_CANCELMODE:
		if (resizeHit != 0) {
			resizeHit = 0;
			::ReleaseCapture();
		}
		return ::DefWindowProc(hWnd, iMessage, wParam, lParam);
	case WM_MOUSEWHEEL:
		if (wheelDelta.Accumulate(wParam)) {
			const int nRows = GetVisibleRows();
			int linesToScroll = std::clamp(nRows - 1, 1, 3);
			linesToScroll *= wheelDelta.Actions();
			int top = ListBox_GetTopIndex(lb) + linesToScroll;
			if (top < 0) {
				top = 0;
			}
			ListBox_SetTopIndex(lb, top);
		}
		break;

	default:
		return ::DefWindowProc(hWnd, iMessage, wParam, lParam);
	}

	return 0;
}

LRESULT PASCAL ListBoxX::StaticWndProc(
    HWND hWnd, UINT iMessage, WPARAM wParam, LPARAM lParam) {
	if (iMessage == WM_CREATE) {
		CREATESTRUCT *pCreate = static_cast<CREATESTRUCT *>(PtrFromLParam(lParam));
		SetWindowPointer(hWnd, pCreate->lpCreateParams);
	}
	// Find C++ object associated with window.
	if (ListBoxX *lbx = static_cast<ListBoxX *>(PointerFromWindow(hWnd))) {
		return lbx->WndProc(hWnd, iMessage, wParam, lParam);
	}
	return ::DefWindowProc(hWnd, iMessage, wParam, lParam);
}

namespace Scintilla::Internal {

bool ListBoxX_Register() noexcept {
	WNDCLASSEX wndclassc {};
	wndclassc.cbSize = sizeof(wndclassc);
	// We need CS_HREDRAW and CS_VREDRAW because of the ellipsis that might be drawn for
	// truncated items in the list and the appearance/disappearance of the vertical scroll bar.
	// The list repaint is double-buffered to avoid the flicker this would otherwise cause.
	wndclassc.style = CS_GLOBALCLASS | CS_HREDRAW | CS_VREDRAW;
	wndclassc.cbWndExtra = sizeof(ListBoxX *);
	wndclassc.hInstance = hinstPlatformRes;
	wndclassc.lpfnWndProc = ListBoxX::StaticWndProc;
	wndclassc.hCursor = ::LoadCursor({}, IDC_ARROW);
	wndclassc.lpszClassName = ListBoxX_ClassName;

	return ::RegisterClassEx(&wndclassc) != 0;
}

void ListBoxX_Unregister() noexcept {
	if (hinstPlatformRes) {
		::UnregisterClass(ListBoxX_ClassName, hinstPlatformRes);
	}
}

ListBox::ListBox() noexcept = default;

ListBox::~ListBox() noexcept = default;

}


================================================
FILE: Libraries/scintilla/win32/ListBox.h
================================================
// Scintilla source code edit control
/** @file ListBox.h
 ** Definitions for list box on Windows.
 **/
// Copyright 2025 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#ifndef LISTBOX_H
#define LISTBOX_H

namespace Scintilla::Internal {

bool ListBoxX_Register() noexcept;
void ListBoxX_Unregister() noexcept;

}

#endif


================================================
FILE: Libraries/scintilla/win32/PlatWin.cxx
================================================
// Scintilla source code edit control
/** @file PlatWin.cxx
 ** Implementation of platform facilities on Windows.
 **/
// Copyright 1998-2003 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#include <cstddef>
#include <cstdlib>
#include <cstdint>
#include <cstring>
#include <cstdio>
#include <cstdarg>
#include <ctime>
#include <cmath>
#include <climits>

#include <string_view>
#include <vector>
#include <map>
#include <optional>
#include <algorithm>
#include <iterator>
#include <memory>
#include <mutex>

// Want to use std::min and std::max so don't want Windows.h version of min and max
#if !defined(NOMINMAX)
#define NOMINMAX
#endif
#undef _WIN32_WINNT
#define _WIN32_WINNT 0x0A00
#undef WINVER
#define WINVER 0x0A00
#define WIN32_LEAN_AND_MEAN 1
#include <windows.h>
#include <commctrl.h>
#include <richedit.h>
#include <windowsx.h>
#include <shellscalingapi.h>

#include <wrl.h>
using Microsoft::WRL::ComPtr;

#if !defined(DISABLE_D2D)
#define USE_D2D 1
#endif

#if defined(USE_D2D)
#include <d2d1_1.h>
#include <d3d11_1.h>
#include <dwrite_1.h>
#endif

#include "ScintillaTypes.h"

#include "Debugging.h"
#include "Geometry.h"
#include "Platform.h"
#include "XPM.h"
#include "UniConversion.h"
#include "DBCS.h"

#include "WinTypes.h"
#include "PlatWin.h"
#include "ListBox.h"
#if defined(USE_D2D)
#include "SurfaceD2D.h"
#endif

using namespace Scintilla;

namespace Scintilla::Internal {

HINSTANCE hinstPlatformRes{};

void *PointerFromWindow(HWND hWnd) noexcept {
	return reinterpret_cast<void *>(::GetWindowLongPtr(hWnd, 0));
}

void SetWindowPointer(HWND hWnd, void *ptr) noexcept {
	::SetWindowLongPtr(hWnd, 0, reinterpret_cast<LONG_PTR>(ptr));
}

namespace {

// system DPI, same for all monitor.
UINT uSystemDPI = USER_DEFAULT_SCREEN_DPI;

using GetDpiForWindowSig = UINT(WINAPI *)(HWND hwnd);
GetDpiForWindowSig fnGetDpiForWindow = nullptr;

HMODULE hDLLShcore{};
using GetDpiForMonitorSig = HRESULT(WINAPI *)(HMONITOR hmonitor, /*MONITOR_DPI_TYPE*/int dpiType, UINT *dpiX, UINT *dpiY);
GetDpiForMonitorSig fnGetDpiForMonitor = nullptr;

using GetSystemMetricsForDpiSig = int(WINAPI *)(int nIndex, UINT dpi);
GetSystemMetricsForDpiSig fnGetSystemMetricsForDpi = nullptr;

using AdjustWindowRectExForDpiSig = BOOL(WINAPI *)(LPRECT lpRect, DWORD dwStyle, BOOL bMenu, DWORD dwExStyle, UINT dpi);
AdjustWindowRectExForDpiSig fnAdjustWindowRectExForDpi = nullptr;

using AreDpiAwarenessContextsEqualSig = BOOL(WINAPI *)(DPI_AWARENESS_CONTEXT, DPI_AWARENESS_CONTEXT);
AreDpiAwarenessContextsEqualSig fnAreDpiAwarenessContextsEqual = nullptr;

using GetWindowDpiAwarenessContextSig = DPI_AWARENESS_CONTEXT(WINAPI *)(HWND);
GetWindowDpiAwarenessContextSig fnGetWindowDpiAwarenessContext = nullptr;

using GetScaleFactorForMonitorSig = HRESULT(WINAPI *)(HMONITOR, DEVICE_SCALE_FACTOR *);
GetScaleFactorForMonitorSig fnGetScaleFactorForMonitor = nullptr;

using SetThreadDpiAwarenessContextSig = DPI_AWARENESS_CONTEXT(WINAPI *)(DPI_AWARENESS_CONTEXT);
SetThreadDpiAwarenessContextSig fnSetThreadDpiAwarenessContext = nullptr;

void LoadDpiForWindow() noexcept {
	HMODULE user32 = ::GetModuleHandleW(L"user32.dll");
	fnGetDpiForWindow = DLLFunction<GetDpiForWindowSig>(user32, "GetDpiForWindow");
	fnGetSystemMetricsForDpi = DLLFunction<GetSystemMetricsForDpiSig>(user32, "GetSystemMetricsForDpi");
	fnAdjustWindowRectExForDpi = DLLFunction<AdjustWindowRectExForDpiSig>(user32, "AdjustWindowRectExForDpi");
	fnSetThreadDpiAwarenessContext = DLLFunction<SetThreadDpiAwarenessContextSig>(user32, "SetThreadDpiAwarenessContext");

	using GetDpiForSystemSig = UINT(WINAPI *)(void);
	GetDpiForSystemSig fnGetDpiForSystem = DLLFunction<GetDpiForSystemSig>(user32, "GetDpiForSystem");
	if (fnGetDpiForSystem) {
		uSystemDPI = fnGetDpiForSystem();
	} else {
		HDC hdcMeasure = ::CreateCompatibleDC({});
		uSystemDPI = ::GetDeviceCaps(hdcMeasure, LOGPIXELSY);
		::DeleteDC(hdcMeasure);
	}

	fnGetWindowDpiAwarenessContext = DLLFunction<GetWindowDpiAwarenessContextSig>(user32, "GetWindowDpiAwarenessContext");
	fnAreDpiAwarenessContextsEqual = DLLFunction<AreDpiAwarenessContextsEqualSig>(user32, "AreDpiAwarenessContextsEqual");

	hDLLShcore = ::LoadLibraryExW(L"shcore.dll", {}, LOAD_LIBRARY_SEARCH_SYSTEM32);
	if (hDLLShcore) {
		fnGetScaleFactorForMonitor = DLLFunction<GetScaleFactorForMonitorSig>(hDLLShcore, "GetScaleFactorForMonitor");
		fnGetDpiForMonitor = DLLFunction<GetDpiForMonitorSig>(hDLLShcore, "GetDpiForMonitor");
	}
}

}

HMONITOR MonitorFromWindowHandleScaling(HWND hWnd) noexcept {
	constexpr DWORD monitorFlags = MONITOR_DEFAULTTONEAREST;

	if (!fnSetThreadDpiAwarenessContext) {
		return ::MonitorFromWindow(hWnd, monitorFlags);
	}

	// Temporarily switching to PerMonitorV2 to retrieve correct monitor via MonitorFromRect() in case of active GDI scaling.
	const DPI_AWARENESS_CONTEXT oldContext = fnSetThreadDpiAwarenessContext(DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2);
	PLATFORM_ASSERT(oldContext != nullptr);

	RECT rect;
	::GetWindowRect(hWnd, &rect);
	const HMONITOR monitor = ::MonitorFromRect(&rect, monitorFlags);

	fnSetThreadDpiAwarenessContext(oldContext);
	return monitor;
}

float GetDeviceScaleFactorWhenGdiScalingActive(HWND hWnd) noexcept {
	if (fnAreDpiAwarenessContextsEqual) {
		PLATFORM_ASSERT(fnGetWindowDpiAwarenessContext && fnGetScaleFactorForMonitor);
		if (fnAreDpiAwarenessContextsEqual(DPI_AWARENESS_CONTEXT_UNAWARE_GDISCALED, fnGetWindowDpiAwarenessContext(hWnd))) {
			const HWND hRootWnd = ::GetAncestor(hWnd, GA_ROOT); // Scale factor applies to entire (root) window.
			const HMONITOR hMonitor = MonitorFromWindowHandleScaling(hRootWnd);
			DEVICE_SCALE_FACTOR deviceScaleFactor;
			if (S_OK == fnGetScaleFactorForMonitor(hMonitor, &deviceScaleFactor))
				return static_cast<float>(static_cast<int>(deviceScaleFactor)) / 100.f;
		}
	}
	return 1.f;
}

UINT DpiForWindow(WindowID wid) noexcept {
	if (fnGetDpiForWindow) {
		return fnGetDpiForWindow(HwndFromWindowID(wid));
	}
	if (fnGetDpiForMonitor) {
		HMONITOR hMonitor = ::MonitorFromWindow(HwndFromWindowID(wid), MONITOR_DEFAULTTONEAREST);
		UINT dpiX = 0;
		UINT dpiY = 0;
		if (fnGetDpiForMonitor(hMonitor, 0 /*MDT_EFFECTIVE_DPI*/, &dpiX, &dpiY) == S_OK) {
			return dpiY;
		}
	}
	return uSystemDPI;
}

int SystemMetricsForDpi(int nIndex, UINT dpi) noexcept {
	if (fnGetSystemMetricsForDpi) {
		return fnGetSystemMetricsForDpi(nIndex, dpi);
	}

	int value = ::GetSystemMetrics(nIndex);
	value = (dpi == uSystemDPI) ? value : ::MulDiv(value, dpi, uSystemDPI);
	return value;
}

void AdjustWindowRectForDpi(LPRECT lpRect, DWORD dwStyle, UINT dpi) noexcept {
	if (fnAdjustWindowRectExForDpi) {
		fnAdjustWindowRectExForDpi(lpRect, dwStyle, false, WS_EX_WINDOWEDGE, dpi);
	} else {
		::AdjustWindowRectEx(lpRect, dwStyle, false, WS_EX_WINDOWEDGE);
	}
}

namespace {

constexpr BITMAPV5HEADER BitMapHeader(int width, int height) noexcept {
	constexpr int pixelBits = 32;

	// Divide each pixel up in the expected BGRA manner.
	// Compatible with DXGI_FORMAT_B8G8R8A8_UNORM.
	constexpr DWORD maskRed = 0x00FF0000U;
	constexpr DWORD maskGreen = 0x0000FF00U;
	constexpr DWORD maskBlue = 0x000000FFU;
	constexpr DWORD maskAlpha = 0xFF000000U;

	BITMAPV5HEADER bi{};
	bi.bV5Size = sizeof(BITMAPV5HEADER);
	bi.bV5Width = width;
	bi.bV5Height = height;
	bi.bV5Planes = 1;
	bi.bV5BitCount = pixelBits;
	bi.bV5Compression = BI_BITFIELDS;
	// The following mask specification specifies a supported 32 BPP alpha format for Windows XP.
	bi.bV5RedMask = maskRed;
	bi.bV5GreenMask = maskGreen;
	bi.bV5BlueMask = maskBlue;
	bi.bV5AlphaMask = maskAlpha;
	return bi;
}

HBITMAP BitMapSection(HDC hdc, int width, int height, DWORD **pixels) noexcept {
	const BITMAPV5HEADER bi = BitMapHeader(width, height);
	void *image = nullptr;
	HBITMAP hbm = ::CreateDIBSection(hdc, reinterpret_cast<const BITMAPINFO *>(&bi), DIB_RGB_COLORS, &image, {}, 0);
	if (pixels) {
		*pixels = static_cast<DWORD *>(image);
	}
	return hbm;
}

}

GDIBitMap::~GDIBitMap() noexcept {
	Release();
}

void GDIBitMap::Create(HDC hdcBase, int width, int height, DWORD **pixels) noexcept {
	Release();

	hdc = CreateCompatibleDC(hdcBase);
	if (!hdc) {
		return;
	}

	hbm = BitMapSection(hdc, width, height, pixels);
	if (!hbm) {
		return;
	}
	hbmOriginal = SelectBitmap(hdc, hbm);
}

void GDIBitMap::Release() noexcept {
	if (hbmOriginal) {
		// Deselect HBITMAP from HDC so it may be deleted.
		SelectBitmap(hdc, hbmOriginal);
	}
	hbmOriginal = {};
	if (hbm) {
		::DeleteObject(hbm);
	}
	hbm = {};
	if (hdc) {
		::DeleteDC(hdc);
	}
	hdc = {};
}

HBITMAP GDIBitMap::Extract() noexcept {
	// Deselect HBITMAP from HDC but keep so can delete.
	// The caller will make a copy, not take ownership.
	HBITMAP ret = hbm;
	if (hbmOriginal) {
		SelectBitmap(hdc, hbmOriginal);
		hbmOriginal = {};
	}
	return ret;
}

Window::~Window() noexcept = default;

void Window::Destroy() noexcept {
	if (wid)
		::DestroyWindow(HwndFromWindowID(wid));
	wid = nullptr;
}

PRectangle Window::GetPosition() const {
	RECT rc;
	::GetWindowRect(HwndFromWindowID(wid), &rc);
	return PRectangleFromRECT(rc);
}

void Window::SetPosition(PRectangle rc) {
	::SetWindowPos(HwndFromWindowID(wid),
		{}, static_cast<int>(rc.left), static_cast<int>(rc.top),
		static_cast<int>(rc.Width()), static_cast<int>(rc.Height()), SWP_NOZORDER | SWP_NOACTIVATE);
}

namespace {

RECT RectFromMonitor(HMONITOR hMonitor) noexcept {
	MONITORINFO mi = {};
	mi.cbSize = sizeof(mi);
	if (GetMonitorInfo(hMonitor, &mi)) {
		return mi.rcWork;
	}
	RECT rc = {0, 0, 0, 0};
	if (::SystemParametersInfoA(SPI_GETWORKAREA, 0, &rc, 0) == 0) {
		rc.left = 0;
		rc.top = 0;
		rc.right = 0;
		rc.bottom = 0;
	}
	return rc;
}

}

void Window::SetPositionRelative(PRectangle rc, const Window *relativeTo) {
	const DWORD style = GetWindowStyle(HwndFromWindowID(wid));
	if (style & WS_POPUP) {
		POINT ptOther = {0, 0};
		::ClientToScreen(HwndFromWindow(*relativeTo), &ptOther);
		rc.Move(static_cast<XYPOSITION>(ptOther.x), static_cast<XYPOSITION>(ptOther.y));

		const RECT rcMonitor = RectFromPRectangle(rc);

		HMONITOR hMonitor = MonitorFromRect(&rcMonitor, MONITOR_DEFAULTTONEAREST);
		// If hMonitor is NULL, that's just the main screen anyways.
		const RECT rcWork = RectFromMonitor(hMonitor);

		if (rcWork.left < rcWork.right) {
			// Now clamp our desired rectangle to fit inside the work area
			// This way, the menu will fit wholly on one screen. An improvement even
			// if you don't have a second monitor on the left... Menu's appears half on
			// one screen and half on the other are just U.G.L.Y.!
			if (rc.right > rcWork.right)
				rc.Move(rcWork.right - rc.right, 0);
			if (rc.bottom > rcWork.bottom)
				rc.Move(0, rcWork.bottom - rc.bottom);
			if (rc.left < rcWork.left)
				rc.Move(rcWork.left - rc.left, 0);
			if (rc.top < rcWork.top)
				rc.Move(0, rcWork.top - rc.top);
		}
	}
	SetPosition(rc);
}

PRectangle Window::GetClientPosition() const {
	RECT rc={0,0,0,0};
	if (wid)
		::GetClientRect(HwndFromWindowID(wid), &rc);
	return PRectangleFromRECT(rc);
}

void Window::Show(bool show) {
	if (show)
		::ShowWindow(HwndFromWindowID(wid), SW_SHOWNOACTIVATE);
	else
		::ShowWindow(HwndFromWindowID(wid), SW_HIDE);
}

void Window::InvalidateAll() {
	::InvalidateRect(HwndFromWindowID(wid), nullptr, FALSE);
}

void Window::InvalidateRectangle(PRectangle rc) {
	const RECT rcw = RectFromPRectangle(rc);
	::InvalidateRect(HwndFromWindowID(wid), &rcw, FALSE);
}

namespace {

std::optional<DWORD> RegGetDWORD(HKEY hKey, LPCWSTR valueName) noexcept {
	DWORD value = 0;
	DWORD type = REG_NONE;
	DWORD size = sizeof(DWORD);
	const LSTATUS status = ::RegQueryValueExW(hKey, valueName, nullptr, &type, reinterpret_cast<LPBYTE>(&value), &size);
	if (status == ERROR_SUCCESS && type == REG_DWORD) {
		return value;
	}
	return {};
}

class CursorHelper {
	GDIBitMap bm;
	DWORD *pixels = nullptr;
	const int width;
	const int height;
	const float scale;
	static constexpr float baseSize = 32.0f;

	static constexpr float arrow[][2] = {
		{ 32.0f - 12.73606f,32.0f - 19.04075f },
		{ 32.0f - 7.80159f, 32.0f - 19.04075f },
		{ 32.0f - 9.82813f, 32.0f - 14.91828f },
		{ 32.0f - 6.88341f, 32.0f - 13.42515f },
		{ 32.0f - 4.62301f, 32.0f - 18.05872f },
		{ 32.0f - 1.26394f, 32.0f - 14.78295f },
		{ 32.0f - 1.26394f, 32.0f - 30.57485f },
	};

public:
	~CursorHelper() = default;

	CursorHelper(int width_, int height_) noexcept : width{width_}, height{height_}, scale{ static_cast<float>(width) / baseSize } {
		// https://learn.microsoft.com/en-us/windows/win32/menurc/using-cursors#creating-a-cursor
		bm.Create({}, width, height, &pixels);
	}

	[[nodiscard]] explicit operator bool() const noexcept {
		return static_cast<bool>(bm);
	}

	HCURSOR Create() noexcept {
		HCURSOR cursor {};
		// Create an empty mask bitmap.
		HBITMAP hMonoBitmap = ::CreateBitmap(width, height, 1, 1, nullptr);
		if (hMonoBitmap) {
			// https://learn.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-createiconindirect
			// hBitmap should not already be selected into a device context
			HBITMAP hBitmap = bm.Extract();
			ICONINFO info = {false, static_cast<DWORD>(width - 1), 0, hMonoBitmap, hBitmap};
			cursor = ::CreateIconIndirect(&info);
			::DeleteObject(hMonoBitmap);
		}
		return cursor;
	}

#if defined(USE_D2D)

	bool DrawD2D(COLORREF fillColour, COLORREF strokeColour) noexcept {
		if (!LoadD2D()) {
			return false;
		}

		const D2D1_RENDER_TARGET_PROPERTIES drtp = D2D1::RenderTargetProperties(
			D2D1_RENDER_TARGET_TYPE_DEFAULT,
			{ DXGI_FORMAT_B8G8R8A8_UNORM, D2D1_ALPHA_MODE_PREMULTIPLIED });

		DCRenderTarget pTarget;
		HRESULT hr = CreateDCRenderTarget(&drtp, pTarget);
		if (FAILED(hr) || !pTarget) {
			return false;
		}

		const RECT rc = {0, 0, width, height};
		hr = pTarget->BindDC(bm.DC(), &rc);
		if (FAILED(hr)) {
			return false;
		}

		pTarget->BeginDraw();

		// Draw something on the bitmap section.
		constexpr size_t nPoints = std::size(arrow);
		D2D1_POINT_2F points[nPoints]{};
		for (size_t i = 0; i < nPoints; i++) {
			points[i].x = arrow[i][0] * scale;
			points[i].y = arrow[i][1] * scale;
		}

		const Geometry geometry = GeometryCreate();
		if (!geometry) {
			return false;
		}

		const GeometrySink sink = GeometrySinkCreate(geometry.Get());
		if (!sink) {
			return false;
		}

		sink->BeginFigure(points[0], D2D1_FIGURE_BEGIN_FILLED);
		for (size_t i = 1; i < nPoints; i++) {
			sink->AddLine(points[i]);
		}
		sink->EndFigure(D2D1_FIGURE_END_CLOSED);
		hr = sink->Close();
		if (FAILED(hr)) {
			return false;
		}

		if (const BrushSolid pBrushFill = BrushSolidCreate(pTarget.Get(), fillColour)) {
			pTarget->FillGeometry(geometry.Get(), pBrushFill.Get());
		}

		if (const BrushSolid pBrushStroke = BrushSolidCreate(pTarget.Get(), strokeColour)) {
			pTarget->DrawGeometry(geometry.Get(), pBrushStroke.Get(), scale);
		}

		hr = pTarget->EndDraw();
		return SUCCEEDED(hr);
	}
#endif

	void Draw(COLORREF fillColour, COLORREF strokeColour) noexcept {
#if defined(USE_D2D)
		if (DrawD2D(fillColour, strokeColour)) {
			return;
		}
#endif

		// Draw something on the DIB section.
		constexpr size_t nPoints = std::size(arrow);
		POINT points[nPoints]{};
		for (size_t i = 0; i < nPoints; i++) {
			points[i].x = std::lround(arrow[i][0] * scale);
			points[i].y = std::lround(arrow[i][1] * scale);
		}

		const DWORD penWidth = std::lround(scale);
		HPEN pen{};
		if (penWidth > 1) {
			const LOGBRUSH brushParameters { BS_SOLID, strokeColour, 0 };
			pen = ::ExtCreatePen(PS_GEOMETRIC | PS_ENDCAP_ROUND | PS_JOIN_MITER,
				penWidth,
				&brushParameters,
				0,
				nullptr);
		} else {
			pen = ::CreatePen(PS_INSIDEFRAME, 1, strokeColour);
		}

		HPEN penOld = SelectPen(bm.DC(), pen);
		HBRUSH brush = ::CreateSolidBrush(fillColour);
		HBRUSH brushOld = SelectBrush(bm.DC(), brush);
		::Polygon(bm.DC(), points, static_cast<int>(nPoints));
		SelectPen(bm.DC(), penOld);
		SelectBrush(bm.DC(), brushOld);
		::DeleteObject(pen);
		::DeleteObject(brush);

		// Set the alpha values for each pixel in the cursor.
		constexpr DWORD opaque = 0xFF000000U;
		for (int i = 0; i < width*height; i++) {
			if (*pixels != 0) {
				*pixels |= opaque;
			}
			pixels++;
		}
	}
};

void ChooseCursor(LPCTSTR cursor) noexcept {
	::SetCursor(::LoadCursor({}, cursor));
}

void ChooseCursor(Window::Cursor curs) noexcept {
	switch (curs) {
	case Window::Cursor::text:
		ChooseCursor(IDC_IBEAM);
		break;
	case Window::Cursor::up:
		ChooseCursor(IDC_UPARROW);
		break;
	case Window::Cursor::wait:
		ChooseCursor(IDC_WAIT);
		break;
	case Window::Cursor::horizontal:
		ChooseCursor(IDC_SIZEWE);
		break;
	case Window::Cursor::vertical:
		ChooseCursor(IDC_SIZENS);
		break;
	case Window::Cursor::hand:
		ChooseCursor(IDC_HAND);
		break;
	case Window::Cursor::reverseArrow:
	case Window::Cursor::arrow:
	case Window::Cursor::invalid:	// Should not occur, but just in case.
	default:
		ChooseCursor(IDC_ARROW);
		break;
	}
}

}

HCURSOR LoadReverseArrowCursor(UINT dpi) noexcept {
	// https://learn.microsoft.com/en-us/answers/questions/815036/windows-cursor-size
	constexpr DWORD defaultCursorBaseSize = 32;
	constexpr DWORD maxCursorBaseSize = 16*(1 + 15); // 16*(1 + CursorSize)
	DWORD cursorBaseSize = 0;
	HKEY hKey {};
	LSTATUS status = ::RegOpenKeyExW(HKEY_CURRENT_USER, L"Control Panel\\Cursors", 0, KEY_QUERY_VALUE, &hKey);
	if (status == ERROR_SUCCESS) {
		if (std::optional<DWORD> baseSize = RegGetDWORD(hKey, L"CursorBaseSize")) {
			// CursorBaseSize is multiple of 16
			cursorBaseSize = std::min(*baseSize & ~15, maxCursorBaseSize);
		}
		::RegCloseKey(hKey);
	}

	int width = 0;
	int height = 0;
	if (cursorBaseSize > defaultCursorBaseSize) {
		width = ::MulDiv(cursorBaseSize, dpi, USER_DEFAULT_SCREEN_DPI);
		height = width;
	} else {
		width = SystemMetricsForDpi(SM_CXCURSOR, dpi);
		height = SystemMetricsForDpi(SM_CYCURSOR, dpi);
		PLATFORM_ASSERT(width == height);
	}

	CursorHelper cursorHelper(width, height);
	if (!cursorHelper) {
		return {};
	}

	COLORREF fillColour = RGB(0xff, 0xff, 0xfe);
	COLORREF strokeColour = RGB(0, 0, 1);
	status = ::RegOpenKeyExW(HKEY_CURRENT_USER, L"Software\\Microsoft\\Accessibility", 0, KEY_QUERY_VALUE, &hKey);
	if (status == ERROR_SUCCESS) {
		if (std::optional<DWORD> cursorType = RegGetDWORD(hKey, L"CursorType")) {
			switch (*cursorType) {
			case 1: // black
			case 4: // black
				std::swap(fillColour, strokeColour);
				break;
			case 6: // custom
				if (std::optional<DWORD> cursorColor = RegGetDWORD(hKey, L"CursorColor")) {
					fillColour = *cursorColor;
				}
				break;
			default: // 0, 3 white, 2, 5 invert
				break;
			}
		}
		::RegCloseKey(hKey);
	}

	cursorHelper.Draw(fillColour, strokeColour);
	HCURSOR cursor = cursorHelper.Create();
	return cursor;
}

void Window::SetCursor(Cursor curs) {
	ChooseCursor(curs);
}

/* Returns rectangle of monitor pt is on, both rect and pt are in Window's
   coordinates */
PRectangle Window::GetMonitorRect(Point pt) {
	const PRectangle rcPosition = GetPosition();
	const POINT ptDesktop = {static_cast<LONG>(pt.x + rcPosition.left),
		static_cast<LONG>(pt.y + rcPosition.top)};
	HMONITOR hMonitor = MonitorFromPoint(ptDesktop, MONITOR_DEFAULTTONEAREST);

	const RECT rcWork = RectFromMonitor(hMonitor);
	if (rcWork.left < rcWork.right) {
		PRectangle rcMonitor(
			rcWork.left - rcPosition.left,
			rcWork.top - rcPosition.top,
			rcWork.right - rcPosition.left,
			rcWork.bottom - rcPosition.top);
		return rcMonitor;
	}
	return PRectangle();
}

Menu::Menu() noexcept : mid{} {
}

void Menu::CreatePopUp() {
	Destroy();
	mid = ::CreatePopupMenu();
}

void Menu::Destroy() noexcept {
	if (mid)
		::DestroyMenu(static_cast<HMENU>(mid));
	mid = {};
}

void Menu::Show(Point pt, const Window &w) {
	::TrackPopupMenu(static_cast<HMENU>(mid),
		TPM_RIGHTBUTTON, static_cast<int>(pt.x - 4), static_cast<int>(pt.y), 0,
		HwndFromWindow(w), nullptr);
	Destroy();
}

ColourRGBA ColourFromSys(int nIndex) noexcept {
	const DWORD colourValue = ::GetSysColor(nIndex);
	return ColourRGBA::FromRGB(colourValue);
}

ColourRGBA Platform::Chrome() {
	return ColourFromSys(COLOR_3DFACE);
}

ColourRGBA Platform::ChromeHighlight() {
	return ColourFromSys(COLOR_3DHIGHLIGHT);
}

const char *Platform::DefaultFont() {
	return "Verdana";
}

int Platform::DefaultFontSize() {
	return 8;
}

unsigned int Platform::DoubleClickTime() {
	return ::GetDoubleClickTime();
}

void Platform::DebugDisplay(const char *s) noexcept {
	::OutputDebugStringA(s);
	//Au:
	SendMessageA(FindWindowA("QM_Editor", nullptr), WM_SETTEXT, (WPARAM)(-1), (LPARAM)s);
}

//#define TRACE

#ifdef TRACE
void Platform::DebugPrintf(const char *format, ...) noexcept {
	char buffer[2000];
	va_list pArguments;
	va_start(pArguments, format);
	vsnprintf(buffer, std::size(buffer), format, pArguments);
	va_end(pArguments);
	Platform::DebugDisplay(buffer);
}
#else
void Platform::DebugPrintf(const char *, ...) noexcept {
}
#endif

namespace {

bool assertionPopUps = true;

}

bool Platform::ShowAssertionPopUps(bool assertionPopUps_) noexcept {
	const bool ret = assertionPopUps;
	assertionPopUps = assertionPopUps_;
	return ret;
}

void Platform::Assert(const char *c, const char *file, int line) noexcept {
	char buffer[2000] {};
	snprintf(buffer, std::size(buffer), "Assertion [%s] failed at %s %d%s", c, file, line, assertionPopUps ? "" : "\r\n");
	if (assertionPopUps) {
		const int idButton = ::MessageBoxA({}, buffer, "Assertion failure",
			MB_ABORTRETRYIGNORE|MB_ICONHAND|MB_SETFOREGROUND|MB_TASKMODAL);
		if (idButton == IDRETRY) {
			::DebugBreak();
		} else if (idButton == IDIGNORE) {
			// all OK
		} else {
			abort();
		}
	} else {
		Platform::DebugDisplay(buffer);
		//Au: ignore, don't break/abort
		//::DebugBreak();
		//abort();
	}
}

void Platform_Initialise(void *hInstance) noexcept {
	hinstPlatformRes = static_cast<HINSTANCE>(hInstance);
	LoadDpiForWindow();
	ListBoxX_Register();
}

void Platform_Finalise(bool fromDllMain) noexcept {
	if (!fromDllMain) {
#if defined(USE_D2D)
		ReleaseD2D();
#endif
		ReleaseLibrary(hDLLShcore);
	}
	ListBoxX_Unregister();
}

}


================================================
FILE: Libraries/scintilla/win32/PlatWin.h
================================================
// Scintilla source code edit control
/** @file PlatWin.h
 ** Implementation of platform facilities on Windows.
 **/
// Copyright 1998-2011 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#ifndef PLATWIN_H
#define PLATWIN_H

namespace Scintilla::Internal {

#ifndef USER_DEFAULT_SCREEN_DPI
#define USER_DEFAULT_SCREEN_DPI		96
#endif
constexpr FLOAT dpiDefault = USER_DEFAULT_SCREEN_DPI;

// Used for defining font size with LOGFONT
constexpr int pointsPerInch = 72;

extern void Platform_Initialise(void *hInstance) noexcept;

extern void Platform_Finalise(bool fromDllMain) noexcept;

constexpr RECT RectFromPRectangle(PRectangle prc) noexcept {
	const RECT rc = { static_cast<LONG>(prc.left), static_cast<LONG>(prc.top),
		static_cast<LONG>(prc.right), static_cast<LONG>(prc.bottom) };
	return rc;
}

constexpr PRectangle PRectangleFromRECT(RECT rc) noexcept {
	return PRectangle::FromInts(rc.left, rc.top, rc.right, rc.bottom);
}

constexpr POINT POINTFromPoint(Point pt) noexcept {
	return POINT{ static_cast<LONG>(pt.x), static_cast<LONG>(pt.y) };
}

constexpr Point PointFromPOINT(POINT pt) noexcept {
	return Point::FromInts(pt.x, pt.y);
}

constexpr SIZE SizeOfRect(RECT rc) noexcept {
	return { rc.right - rc.left, rc.bottom - rc.top };
}

ColourRGBA ColourFromSys(int nIndex) noexcept;

constexpr HWND HwndFromWindowID(WindowID wid) noexcept {
	return static_cast<HWND>(wid);
}

inline HWND HwndFromWindow(const Window &w) noexcept {
	return HwndFromWindowID(w.GetID());
}

extern HINSTANCE hinstPlatformRes;

UINT CodePageFromCharSet(CharacterSet characterSet, UINT documentCodePage) noexcept;

void *PointerFromWindow(HWND hWnd) noexcept;
void SetWindowPointer(HWND hWnd, void *ptr) noexcept;

HMONITOR MonitorFromWindowHandleScaling(HWND hWnd) noexcept;

UINT DpiForWindow(WindowID wid) noexcept;
float GetDeviceScaleFactorWhenGdiScalingActive(HWND hWnd) noexcept;

int SystemMetricsForDpi(int nIndex, UINT dpi) noexcept;

void AdjustWindowRectForDpi(LPRECT lpRect, DWORD dwStyle, UINT dpi) noexcept;

HCURSOR LoadReverseArrowCursor(UINT dpi) noexcept;

// Encapsulate WM_PAINT handling so that EndPaint is always called even with unexpected returns or exceptions.
struct Painter {
	HWND hWnd{};
	PAINTSTRUCT ps{};
	explicit Painter(HWND hWnd_) noexcept : hWnd(hWnd_) {
		::BeginPaint(hWnd, &ps);
	}
	~Painter() {
		::EndPaint(hWnd, &ps);
	}
};

class MouseWheelDelta {
	int wheelDelta = 0;
public:
	bool Accumulate(WPARAM wParam) noexcept {
		wheelDelta -= GET_WHEEL_DELTA_WPARAM(wParam);
		return std::abs(wheelDelta) >= WHEEL_DELTA;
	}
	int Actions() noexcept {
		const int actions = wheelDelta / WHEEL_DELTA;
		wheelDelta = wheelDelta % WHEEL_DELTA;
		return actions;
	}
};

// Both GDI and DirectWrite can produce a HFONT for use in list boxes
struct FontWin : public Font {
	[[nodiscard]] virtual HFONT HFont() const noexcept = 0;
	[[nodiscard]] virtual std::unique_ptr<FontWin> Duplicate() const = 0;
	[[nodiscard]] virtual CharacterSet GetCharacterSet() const noexcept = 0;
};

// Buffer to hold strings and string position arrays without always allocating on heap.
// May sometimes have string too long to allocate on stack. So use a fixed stack-allocated buffer
// when less than safe size otherwise allocate on heap and free automatically.
template<typename T, int lengthStandard>
class VarBuffer {
	T bufferStandard[lengthStandard];
public:
	T *buffer;
	explicit VarBuffer(size_t length) : buffer(nullptr) {
		if (length > lengthStandard) {
			buffer = new T[length];
		} else {
			buffer = bufferStandard;
		}
	}
	// Deleted so VarBuffer objects can not be copied.
	VarBuffer(const VarBuffer &) = delete;
	VarBuffer(VarBuffer &&) = delete;
	VarBuffer &operator=(const VarBuffer &) = delete;
	VarBuffer &operator=(VarBuffer &&) = delete;

	~VarBuffer() noexcept {
		if (buffer != bufferStandard) {
			delete[]buffer;
			buffer = nullptr;
		}
	}
};

constexpr int stackBufferLength = 400;
class TextWide : public VarBuffer<wchar_t, stackBufferLength> {
public:
	int tlen;	// Using int instead of size_t as most Win32 APIs take int.
	TextWide(std::string_view text, int codePage) :
		VarBuffer<wchar_t, stackBufferLength>(text.length()) {
		if (codePage == CpUtf8) {
			tlen = static_cast<int>(UTF16FromUTF8(text, buffer, text.length()));
		} else {
			// Support Asian string display in 9x English
			tlen = ::MultiByteToWideChar(codePage, 0, text.data(), static_cast<int>(text.length()),
				buffer, static_cast<int>(text.length()));
		}
	}
	[[nodiscard]] std::wstring_view AsView() const noexcept {
		return std::wstring_view(buffer, tlen);
	}
};
using TextPositions = VarBuffer<XYPOSITION, stackBufferLength>;

// Manage the lifetime of a memory HBITMAP and its HDC so there are no leaks.
class GDIBitMap {
	HDC hdc{};
	HBITMAP hbm{};
	HBITMAP hbmOriginal{};

public:
	GDIBitMap() noexcept = default;
	// Deleted so GDIBitMap objects can not be copied.
	GDIBitMap(const GDIBitMap &) = delete;
	GDIBitMap(GDIBitMap &&) = delete;
	// Move would be OK but not needed yet
	GDIBitMap &operator=(const GDIBitMap &) = delete;
	GDIBitMap &operator=(GDIBitMap &&) = delete;
	~GDIBitMap() noexcept;

	void Create(HDC hdcBase, int width, int height, DWORD **pixels) noexcept;
	void Release() noexcept;
	HBITMAP Extract() noexcept;

	[[nodiscard]] HDC DC() const noexcept {
		return hdc;
	}
	[[nodiscard]] explicit operator bool() const noexcept {
		return hdc && hbm;
	}
};

}

#endif


================================================
FILE: Libraries/scintilla/win32/ScintRes.rc
================================================
// Resource file for Scintilla
// Copyright 1998-2010 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#include <windows.h>

#define VERSION_SCINTILLA "5.5.7"
#define VERSION_WORDS 5, 5, 7, 0

VS_VERSION_INFO VERSIONINFO
FILEVERSION	VERSION_WORDS
PRODUCTVERSION	VERSION_WORDS
FILEFLAGSMASK	0x3fL
FILEFLAGS 0
FILEOS VOS_NT_WINDOWS32
FILETYPE VFT_APP
FILESUBTYPE VFT2_UNKNOWN
BEGIN
	BLOCK	"VarFileInfo"
	BEGIN
		VALUE	"Translation",	0x409,	1200
	END
	BLOCK	"StringFileInfo"
	BEGIN
		BLOCK "040904b0"
		BEGIN
			VALUE	"CompanyName",	"Neil Hodgson neilh@scintilla.org\0"
			VALUE	"FileDescription",	"Scintilla.DLL - a Source Editing Component\0"
			VALUE	"FileVersion",	VERSION_SCINTILLA "\0"
			VALUE	"InternalName",	"Scintilla\0"
			VALUE	"LegalCopyright",	"Copyright 1998-2012 by Neil Hodgson\0"
			VALUE	"OriginalFilename",	"Scintilla.DLL\0"
			VALUE	"ProductName",	"Scintilla\0"
			VALUE	"ProductVersion",	VERSION_SCINTILLA "\0"
		END
	END
END


================================================
FILE: Libraries/scintilla/win32/Scintilla.def
================================================
EXPORTS
	Scintilla_DirectFunction

================================================
FILE: Libraries/scintilla/win32/Scintilla.vcxproj
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <ItemGroup Label="ProjectConfigurations">
    <ProjectConfiguration Include="Debug|ARM64">
      <Configuration>Debug</Configuration>
      <Platform>ARM64</Platform>
    </ProjectConfiguration>
    <ProjectConfiguration Include="Debug|x64">
      <Configuration>Debug</Configuration>
      <Platform>x64</Platform>
    </ProjectConfiguration>
    <ProjectConfiguration Include="Release|ARM64">
      <Configuration>Release</Configuration>
      <Platform>ARM64</Platform>
    </ProjectConfiguration>
    <ProjectConfiguration Include="Release|x64">
      <Configuration>Release</Configuration>
      <Platform>x64</Platform>
    </ProjectConfiguration>
  </ItemGroup>
  <PropertyGroup Label="Globals">
    <ProjectGuid>{19CCA8B8-46B9-4609-B7CE-198DA19F07BD}</ProjectGuid>
    <Keyword>Win32Proj</Keyword>
    <RootNamespace>Scintilla</RootNamespace>
    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
  </PropertyGroup>
  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
  <PropertyGroup>
    <ConfigurationType>DynamicLibrary</ConfigurationType>
    <CharacterSet>Unicode</CharacterSet>
    <PlatformToolset>v143</PlatformToolset>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
    <UseDebugLibraries>true</UseDebugLibraries>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM64'" Label="Configuration">
    <UseDebugLibraries>true</UseDebugLibraries>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
    <UseDebugLibraries>false</UseDebugLibraries>
    <WholeProgramOptimization>true</WholeProgramOptimization>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'" Label="Configuration">
    <UseDebugLibraries>false</UseDebugLibraries>
    <WholeProgramOptimization>true</WholeProgramOptimization>
  </PropertyGroup>
  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
  <ImportGroup Label="ExtensionSettings">
  </ImportGroup>
  <ImportGroup Label="PropertySheets">
    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
  </ImportGroup>
  <PropertyGroup Label="UserMacros" />
  <PropertyGroup>
    <LinkIncremental>false</LinkIncremental>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
    <IntDir>obj\$(Configuration)\$(Platform)\</IntDir>
    <OutDir>bin\$(Configuration)\$(Platform)\</OutDir>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM64'">
    <IntDir>obj\$(Configuration)\$(Platform)\</IntDir>
    <OutDir>bin\$(Configuration)\$(Platform)\</OutDir>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
    <IntDir>obj\$(Configuration)\$(Platform)\</IntDir>
    <OutDir>bin\$(Configuration)\$(Platform)\</OutDir>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'">
    <IntDir>obj\$(Configuration)\$(Platform)\</IntDir>
    <OutDir>bin\$(Configuration)\$(Platform)\</OutDir>
  </PropertyGroup>
  <ItemDefinitionGroup>
    <ClCompile>
      <WarningLevel>Level4</WarningLevel>
      <PreprocessorDefinitions>SCI_EMPTYCATALOGUE;_CRT_SECURE_NO_DEPRECATE;_SCL_SECURE_NO_WARNINGS;_USRDLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <AdditionalIncludeDirectories>..\include;..\src;</AdditionalIncludeDirectories>
      <BrowseInformation>true</BrowseInformation>
      <MultiProcessorCompilation>true</MultiProcessorCompilation>
      <MinimalRebuild>false</MinimalRebuild>
      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
      <AdditionalOptions>/source-charset:utf-8 %(AdditionalOptions)</AdditionalOptions>
    </ClCompile>
    <Link>
      <SubSystem>Windows</SubSystem>
      <GenerateDebugInformation>true</GenerateDebugInformation>
      <AdditionalDependencies>gdi32.lib;imm32.lib;ole32.lib;oleaut32.lib;advapi32.lib;%(AdditionalDependencies)</AdditionalDependencies>
      <CETCompat>false</CETCompat>
    </Link>
  </ItemDefinitionGroup>
  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
    <ClCompile>
      <PreprocessorDefinitions>_DEBUG;DISABLE_D2D;%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <LanguageStandard>stdcpp17</LanguageStandard>
      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
    </ClCompile>
    <Link>
      <LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration>
    </Link>
    <PostBuildEvent>
      <Command>$(SolutionDir)Other\BuildEvents\bin\Debug\BuildEvents.exe dllPostBuild "$(TargetPath)" $(Platform)</Command>
    </PostBuildEvent>
  </ItemDefinitionGroup>
  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM64'">
    <ClCompile>
      <PreprocessorDefinitions>_DEBUG;DISABLE_D2D;%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <LanguageStandard>stdcpp17</LanguageStandard>
      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
    </ClCompile>
    <Link>
      <LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration>
    </Link>
    <PostBuildEvent>
      <Command>$(SolutionDir)Other\BuildEvents\bin\Debug\BuildEvents.exe dllPostBuild "$(TargetPath)" $(Platform)</Command>
    </PostBuildEvent>
  </ItemDefinitionGroup>
  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
    <ClCompile>
      <FunctionLevelLinking>true</FunctionLevelLinking>
      <IntrinsicFunctions>true</IntrinsicFunctions>
      <PreprocessorDefinitions>NDEBUG;DISABLE_D2D;%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <LanguageStandard>stdcpp17</LanguageStandard>
      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
    </ClCompile>
    <Link>
      <EnableCOMDATFolding>true</EnableCOMDATFolding>
      <OptimizeReferences>true</OptimizeReferences>
    </Link>
    <PostBuildEvent>
      <Command>$(SolutionDir)Other\BuildEvents\bin\Debug\BuildEvents.exe dllPostBuild "$(TargetPath)" $(Platform)</Command>
    </PostBuildEvent>
  </ItemDefinitionGroup>
  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'">
    <ClCompile>
      <FunctionLevelLinking>true</FunctionLevelLinking>
      <IntrinsicFunctions>true</IntrinsicFunctions>
      <PreprocessorDefinitions>NDEBUG;DISABLE_D2D;%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <LanguageStandard>stdcpp17</LanguageStandard>
      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
    </ClCompile>
    <Link>
      <EnableCOMDATFolding>true</EnableCOMDATFolding>
      <OptimizeReferences>true</OptimizeReferences>
    </Link>
    <PostBuildEvent>
      <Command>$(SolutionDir)Other\BuildEvents\bin\Debug\BuildEvents.exe dllPostBuild "$(TargetPath)" $(Platform)</Command>
    </PostBuildEvent>
  </ItemDefinitionGroup>
  <ItemGroup>
    <ClCompile Include="..\src\*.cxx" />
    <ClCompile Include="..\win32\HanjaDic.cxx" />
    <ClCompile Include="..\win32\PlatWin.cxx" />
    <ClCompile Include="..\win32\ListBox.cxx" />
    <ClCompile Include="..\win32\SurfaceD2D.cxx" />
    <ClCompile Include="..\win32\SurfaceGDI.cxx" />
    <ClCompile Include="..\win32\ScintillaWin.cxx" />
    <ClCompile Include="..\win32\ScintillaDLL.cxx" />
  </ItemGroup>
  <ItemGroup>
    <ClInclude Include="..\include\*.h" />
    <ClInclude Include="..\src\*.h" />
    <ClInclude Include="..\win32\*.h" />
  </ItemGroup>
  <ItemGroup>
    <ResourceCompile Include="..\win32\ScintRes.rc" />
  </ItemGroup>
  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
  <ImportGroup Label="ExtensionTargets">
  </ImportGroup>
</Project>

================================================
FILE: Libraries/scintilla/win32/ScintillaDLL.cxx
================================================
// Scintilla source code edit control
/** @file ScintillaDLL.cxx
 ** DLL entry point for Scintilla.
 **/
// Copyright 1998-2018 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#include <cstdint>

#undef _WIN32_WINNT
#define _WIN32_WINNT 0x0500
#undef WINVER
#define WINVER 0x0500
#include <windows.h>

#include "ScintillaTypes.h"
#include "ScintillaWin.h"

using namespace Scintilla;

extern "C"
__declspec(dllexport)
sptr_t __stdcall Scintilla_DirectFunction(
    Internal::ScintillaWin *sci, UINT iMessage, uptr_t wParam, sptr_t lParam) {
	return Internal::DirectFunction(sci, iMessage, wParam, lParam);
}

extern "C" int APIENTRY DllMain(HINSTANCE hInstance, DWORD dwReason, LPVOID lpvReserved) {
	//Platform::DebugPrintf("Scintilla::DllMain %d %d\n", hInstance, dwReason);
	if (dwReason == DLL_PROCESS_ATTACH) {
		if (!Internal::RegisterClasses(hInstance))
			return FALSE;
	} else if (dwReason == DLL_PROCESS_DETACH) {
		if (lpvReserved == NULL) {
			Internal::ResourcesRelease(true);
		}
	}
	return TRUE;
}


================================================
FILE: Libraries/scintilla/win32/ScintillaWin.cxx
================================================
// Scintilla source code edit control
/** @file ScintillaWin.cxx
 ** Windows specific subclass of ScintillaBase.
 **/
// Copyright 1998-2003 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#include <cstddef>
#include <cstdlib>
#include <cstdint>
#include <cassert>
#include <cstring>
#include <cstdio>
#include <cmath>
#include <climits>

#include <stdexcept>
#include <new>
#include <string>
#include <string_view>
#include <vector>
#include <array>
#include <map>
#include <set>
#include <optional>
#include <algorithm>
#include <memory>
#include <chrono>
#include <mutex>

// Want to use std::min and std::max so don't want Windows.h version of min and max
#if !defined(NOMINMAX)
#define NOMINMAX
#endif
#undef _WIN32_WINNT
#define _WIN32_WINNT 0x0A00
#undef WINVER
#define WINVER 0x0A00
#define WIN32_LEAN_AND_MEAN 1
#include <windows.h>
#include <commctrl.h>
#include <richedit.h>
#include <windowsx.h>
#include <zmouse.h>
#include <ole2.h>

#include <wrl.h>
using Microsoft::WRL::ComPtr;

#if !defined(DISABLE_D2D)
#define USE_D2D 1
#endif

#if defined(USE_D2D)
#include <d2d1_1.h>
#include <d3d11_1.h>
#include <dwrite_1.h>
#endif

#include "ScintillaTypes.h"
#include "ScintillaMessages.h"
#include "ScintillaStructures.h"
#include "ILoader.h"
#include "ILexer.h"

#include "Debugging.h"
#include "Geometry.h"
#include "Platform.h"

#include "CharacterType.h"
#include "CharacterCategoryMap.h"
#include "Position.h"
#include "UniqueString.h"
#include "SplitVector.h"
#include "Partitioning.h"
#include "RunStyles.h"
#include "ContractionState.h"
#include "CellBuffer.h"
#include "CallTip.h"
#include "KeyMap.h"
#include "Indicator.h"
#include "LineMarker.h"
#include "Style.h"
#include "ViewStyle.h"
#include "CharClassify.h"
#include "Decoration.h"
#include "CaseFolder.h"
#include "Document.h"
#include "CaseConvert.h"
#include "UniConversion.h"
#include "DBCS.h"
#include "Selection.h"
#include "PositionCache.h"
#include "EditModel.h"
#include "MarginView.h"
#include "EditView.h"
#include "Editor.h"
#include "ElapsedPeriod.h"

#include "AutoComplete.h"
#include "ScintillaBase.h"

#include "WinTypes.h"
#include "PlatWin.h"
#if defined(USE_D2D)
#include "SurfaceD2D.h"
#endif
#include "HanjaDic.h"
#include "ScintillaWin.h"

// __uuidof is a Microsoft extension but makes COM code neater, so disable warning
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wlanguage-extension-token"
#endif

namespace {

// Two idle messages SC_WIN_IDLE and SC_WORK_IDLE.

// SC_WIN_IDLE is low priority so should occur after the next WM_PAINT
// It is for lengthy actions like wrapping and background styling
constexpr UINT SC_WIN_IDLE = 5001;
// SC_WORK_IDLE is high priority and should occur before the next WM_PAINT
// It is for shorter actions like restyling the text just inserted
// and delivering SCN_UPDATEUI
constexpr UINT SC_WORK_IDLE = 5002;

using SetCoalescableTimerSig = UINT_PTR (WINAPI *)(HWND hwnd, UINT_PTR nIDEvent,
	UINT uElapse, TIMERPROC lpTimerFunc, ULONG uToleranceDelay);

}

// GCC has trouble with the standard COM ABI so do it the old C way with explicit vtables.

using namespace Scintilla;
using namespace Scintilla::Internal;

namespace {

const TCHAR callClassName[] = TEXT("CallTip");

void SetWindowID(HWND hWnd, int identifier) noexcept {
	::SetWindowLongPtr(hWnd, GWLP_ID, identifier);
}

constexpr POINT POINTFromLParam(sptr_t lParam) noexcept {
	return { GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam) };
};

constexpr Point PointFromLParam(sptr_t lpoint) noexcept {
	return Point::FromInts(GET_X_LPARAM(lpoint), GET_Y_LPARAM(lpoint));
}

bool KeyboardIsKeyDown(int key) noexcept {
	return (::GetKeyState(key) & 0x80000000) != 0;
}

// Bit 24 is the extended keyboard flag and the numeric keypad is non-extended
constexpr sptr_t extendedKeyboard = 1 << 24;

constexpr bool KeyboardIsNumericKeypadFunction(uptr_t wParam, sptr_t lParam) {
	if ((lParam & extendedKeyboard) != 0) {
		// Not from the numeric keypad
		return false;
	}

	switch (wParam) {
	case VK_INSERT:	// 0
	case VK_END:	// 1
	case VK_DOWN:	// 2
	case VK_NEXT:	// 3
	case VK_LEFT:	// 4
	case VK_CLEAR:	// 5
	case VK_RIGHT:	// 6
	case VK_HOME:	// 7
	case VK_UP:		// 8
	case VK_PRIOR:	// 9
		return true;
	default:
		return false;
	}
}

/**
 */
class FormatEnumerator final : public IEnumFORMATETC {
public:
	ULONG ref;
	ULONG pos;
	std::vector<CLIPFORMAT> formats;
	FormatEnumerator(ULONG pos_, const CLIPFORMAT formats_[], size_t formatsLen_);

	// IUnknown
	STDMETHODIMP QueryInterface(REFIID riid, PVOID *ppv) override;
	STDMETHODIMP_(ULONG)AddRef() override;
	STDMETHODIMP_(ULONG)Release() override;

	// IEnumFORMATETC
	STDMETHODIMP Next(ULONG celt, FORMATETC *rgelt, ULONG *pceltFetched) override;
	STDMETHODIMP Skip(ULONG celt) override;
	STDMETHODIMP Reset() override;
	STDMETHODIMP Clone(IEnumFORMATETC **ppenum) override;
};

/**
 */
class DropSource final : public IDropSource {
public:
	ScintillaWin *sci = nullptr;

	// IUnknown
	STDMETHODIMP QueryInterface(REFIID riid, PVOID *ppv) override;
	STDMETHODIMP_(ULONG)AddRef() override;
	STDMETHODIMP_(ULONG)Release() override;

	// IDropSource
	STDMETHODIMP QueryContinueDrag(BOOL fEsc, DWORD grfKeyState) override;
	STDMETHODIMP GiveFeedback(DWORD) override;
};

/**
 */
class DataObject final : public IDataObject {
public:
	ScintillaWin *sci = nullptr;

	// IUnknown
	STDMETHODIMP QueryInterface(REFIID riid, PVOID *ppv) override;
	STDMETHODIMP_(ULONG)AddRef() override;
	STDMETHODIMP_(ULONG)Release() override;

	// IDataObject
	STDMETHODIMP GetData(FORMATETC *pFEIn, STGMEDIUM *pSTM) override;
	STDMETHODIMP GetDataHere(FORMATETC *, STGMEDIUM *) override;
	STDMETHODIMP QueryGetData(FORMATETC *pFE) override;
	STDMETHODIMP GetCanonicalFormatEtc(FORMATETC *, FORMATETC *pFEOut)  override;
	STDMETHODIMP SetData(FORMATETC *, STGMEDIUM *, BOOL) override;
	STDMETHODIMP EnumFormatEtc(DWORD dwDirection, IEnumFORMATETC **ppEnum) override;
	STDMETHODIMP DAdvise(FORMATETC *, DWORD, IAdviseSink *, PDWORD) override;
	STDMETHODIMP DUnadvise(DWORD) override;
	STDMETHODIMP EnumDAdvise(IEnumSTATDATA **) override;
};

/**
 */
class DropTarget final : public IDropTarget {
public:
	ScintillaWin *sci = nullptr;

	// IUnknown
	STDMETHODIMP QueryInterface(REFIID riid, PVOID *ppv) override;
	STDMETHODIMP_(ULONG)AddRef() override;
	STDMETHODIMP_(ULONG)Release() override;

	// IDropTarget
	STDMETHODIMP DragEnter(LPDATAOBJECT pIDataSource, DWORD grfKeyState, POINTL pt, PDWORD pdwEffect) override;
	STDMETHODIMP DragOver(DWORD grfKeyState, POINTL pt, PDWORD pdwEffect) override;
	STDMETHODIMP DragLeave() override;
	STDMETHODIMP Drop(LPDATAOBJECT pIDataSource, DWORD grfKeyState, POINTL pt, PDWORD pdwEffect) override;
};

class IMContext {
	HWND hwnd;
	HIMC hIMC;
public:

	explicit IMContext(HWND hwnd_) noexcept :
		hwnd(hwnd_), hIMC(::ImmGetContext(hwnd_)) {
	}

	// Deleted so IMContext objects can not be copied.
	IMContext(const IMContext &) = delete;
	IMContext(IMContext &&) = delete;
	IMContext &operator=(const IMContext &) = delete;
	IMContext &operator=(IMContext &&) = delete;

	~IMContext() {
		if (hIMC)
			::ImmReleaseContext(hwnd, hIMC);
	}

	[[nodiscard]] explicit operator bool() const noexcept {
		return hIMC != HIMC{};
	}

	[[nodiscard]] unsigned int GetImeCaretPos() const noexcept {
		return ::ImmGetCompositionStringW(hIMC, GCS_CURSORPOS, nullptr, 0);
	}

	[[nodiscard]] std::vector<BYTE> GetImeAttributes() const {
		const int attrLen = ::ImmGetCompositionStringW(hIMC, GCS_COMPATTR, nullptr, 0);
		std::vector<BYTE> attr(attrLen, 0);
		::ImmGetCompositionStringW(hIMC, GCS_COMPATTR, attr.data(), static_cast<DWORD>(attr.size()));
		return attr;
	}

	[[nodiscard]] LONG GetCompositionStringLength(DWORD dwIndex) const noexcept {
		const LONG byteLen = ::ImmGetCompositionStringW(hIMC, dwIndex, nullptr, 0);
		return byteLen / sizeof(wchar_t);
	}

	[[nodiscard]] std::wstring GetCompositionString(DWORD dwIndex) const {
		const LONG byteLen = ::ImmGetCompositionStringW(hIMC, dwIndex, nullptr, 0);
		std::wstring wcs(byteLen / 2, 0);
		::ImmGetCompositionStringW(hIMC, dwIndex, wcs.data(), byteLen);
		return wcs;
	}

	BOOL SetCompositionString(DWORD dwIndex, LPVOID lpComp, DWORD dwCompLen) const noexcept {
		return ::ImmSetCompositionStringW(hIMC, dwIndex, lpComp, dwCompLen, nullptr, 0);
	}

	void SetCompositionWindow(Point pos) const noexcept {
		COMPOSITIONFORM CompForm{};
		CompForm.dwStyle = CFS_POINT;
		CompForm.ptCurrentPos = POINTFromPoint(pos);
		::ImmSetCompositionWindow(hIMC, &CompForm);
	}

	void SetCandidateWindowPos(Point pos, PRectangle rcClient, int lineHeight) const noexcept {
		CANDIDATEFORM CandForm{};
		CandForm.dwIndex = 0;
		CandForm.dwStyle = CFS_EXCLUDE;
		CandForm.ptCurrentPos.x = static_cast<int>(pos.x);
		CandForm.ptCurrentPos.y = static_cast<int>(pos.y + std::max(4, lineHeight / 4));
		// Exclude the area of the whole caret line
		CandForm.rcArea.top = static_cast<int>(pos.y);
		CandForm.rcArea.bottom = static_cast<int>(pos.y + lineHeight);
		CandForm.rcArea.left = static_cast<int>(rcClient.left);
		CandForm.rcArea.right = static_cast<int>(rcClient.right);
		::ImmSetCandidateWindow(hIMC, &CandForm);
	}

	void SetCompositionFont(const ViewStyle &vs, int style, UINT dpi) const {
		LOGFONTW lf{};
		int sizeZoomed = vs.styles[style].size + (vs.zoomLevel * FontSizeMultiplier);
		if (sizeZoomed <= 2 * FontSizeMultiplier)	// Hangs if sizeZoomed <= 1
			sizeZoomed = 2 * FontSizeMultiplier;
		// The negative is to allow for leading
		lf.lfHeight = -::MulDiv(sizeZoomed, dpi, pointsPerInch * FontSizeMultiplier);
		lf.lfWeight = static_cast<LONG>(vs.styles[style].weight);
		lf.lfItalic = vs.styles[style].italic ? 1 : 0;
		lf.lfCharSet = DEFAULT_CHARSET;
		lf.lfFaceName[0] = L'\0';
		if (vs.styles[style].fontName) {
			const char *fontName = vs.styles[style].fontName;
			UTF16FromUTF8(std::string_view(fontName), lf.lfFaceName, LF_FACESIZE);
		}

		::ImmSetCompositionFontW(hIMC, &lf);
	}

	void Notify(bool complete) const noexcept {
		::ImmNotifyIME(hIMC, NI_COMPOSITIONSTR, complete ? CPS_COMPLETE : CPS_CANCEL, 0);
	}

	LRESULT Escape(HKL hkl, UINT uEscape, LPVOID lpv) const noexcept {
		return ::ImmEscapeW(hkl, hIMC, uEscape, lpv);
	}

};

class GlobalMemory;

class ReverseArrowCursor {
	HCURSOR cursor {};
	bool valid = false;

public:
	ReverseArrowCursor() noexcept = default;
	// Deleted so ReverseArrowCursor objects can not be copied.
	ReverseArrowCursor(const ReverseArrowCursor &) = delete;
	ReverseArrowCursor(ReverseArrowCursor &&) = delete;
	ReverseArrowCursor &operator=(const ReverseArrowCursor &) = delete;
	ReverseArrowCursor &operator=(ReverseArrowCursor &&) = delete;
	~ReverseArrowCursor() {
		if (cursor) {
			::DestroyCursor(cursor);
		}
	}

	void Invalidate() noexcept {
		valid = false;
	}

	HCURSOR Load([[maybe_unused]] UINT dpi) noexcept {
		if (cursor)	 {
			if (valid) {
				return cursor;
			}
			::DestroyCursor(cursor);
		}

		valid = true;
		//cursor = LoadReverseArrowCursor(dpi); //Au: the reverse arrow cursor is ugly, even if drawn with D2D. Eg VSCode uses normal arrow too.
		return cursor ? cursor : ::LoadCursor({}, IDC_ARROW);
	}
};

struct HorizontalScrollRange {
	int pageWidth;
	int documentWidth;
};

CLIPFORMAT RegisterClipboardType(LPCWSTR lpszFormat) noexcept {
	// Registered clipboard format values are 0xC000 through 0xFFFF.
	// RegisterClipboardFormatW returns 32-bit unsigned and CLIPFORMAT is 16-bit
	// unsigned so choose the low 16-bits with &.
	return ::RegisterClipboardFormatW(lpszFormat) & 0xFFFF;
}

RECT GetClientRect(HWND hwnd) noexcept {
	RECT rect{};
	::GetClientRect(hwnd, &rect);
	return rect;
}

#if defined(USE_D2D)

D2D1_SIZE_U GetSizeUFromRect(const RECT &rc, const int scaleFactor) noexcept {
	const SIZE size = SizeOfRect(rc);
	const UINT32 scaledWidth = size.cx * scaleFactor;
	const UINT32 scaledHeight = size.cy * scaleFactor;
	return D2D1::SizeU(scaledWidth, scaledHeight);
}

#endif

}

namespace Scintilla::Internal {

#if defined(USE_D2D)

using HwndRenderTarget = ComPtr<ID2D1HwndRenderTarget>;

// There may be either a Hwnd or DC render target
struct RenderTargets {
	HwndRenderTarget pHwndRT;
	DCRenderTarget pDCRT;
	ComPtr<ID2D1DeviceContext> pDeviceContext;
	bool valid = true;
	[[nodiscard]] ID2D1RenderTarget *RenderTarget() const noexcept {
		if (pHwndRT)
			return pHwndRT.Get();
		if (pDCRT)
			return pDCRT.Get();
		if (pDeviceContext)
			return pDeviceContext.Get();
		return nullptr;
	}
	void Release() noexcept {
		pHwndRT = nullptr;
		pDCRT = nullptr;
		pDeviceContext = nullptr;
	}
};

// These resources are device-dependent but not window-dependent
struct DirectDevice {
	D3D11Device pDirect3DDevice;
	ComPtr<ID2D1Device> pDirect2DDevice;
	ComPtr<IDXGIDevice> pDXGIDevice;

	void Release() noexcept;
	HRESULT CreateDevice() noexcept;
};

void DirectDevice::Release() noexcept {
	pDirect3DDevice = nullptr;
	pDirect2DDevice = nullptr;
	pDXGIDevice = nullptr;
}

HRESULT DirectDevice::CreateDevice() noexcept {
	if (pDirect2DDevice) {	// Must be released before creation
		return E_FAIL;
	}

	HRESULT hr = CreateD3D(pDirect3DDevice);
	if (FAILED(hr)) {
		return hr;
	}

	hr = pDirect3DDevice.As(&pDXGIDevice);
	if (FAILED(hr)) {
		Platform::DebugPrintf("Failed to create DXGI device 0x%lx\n", hr);
		return hr;
	}

	hr = pD2DFactory->CreateDevice(pDXGIDevice.Get(), pDirect2DDevice.ReleaseAndGetAddressOf());
	if (FAILED(hr)) {
		Platform::DebugPrintf("Failed to create D2D device 0x%lx\n", hr);
		return hr;
	}

	return S_OK;
}

#endif

/**
 */
class ScintillaWin :
	public ScintillaBase {

	bool lastKeyDownConsumed;
	wchar_t lastHighSurrogateChar;

	bool capturedMouse;
	bool trackedMouseLeave;
	BOOL typingWithoutCursor;
	bool cursorIsHidden;
	SetCoalescableTimerSig SetCoalescableTimerFn;

	unsigned int linesPerScroll;	///< Intellimouse support
	unsigned int charsPerScroll;	///< Intellimouse support
	MouseWheelDelta verticalWheelDelta;
	MouseWheelDelta horizontalWheelDelta;

	UINT dpi = USER_DEFAULT_SCREEN_DPI;
	ReverseArrowCursor reverseArrowCursor;

	PRectangle rectangleClient;
	HRGN hRgnUpdate;

	bool hasOKText;

	CLIPFORMAT cfColumnSelect;
	CLIPFORMAT cfBorlandIDEBlockType;
	CLIPFORMAT cfLineSelect;
	CLIPFORMAT cfVSLineTag;

	HRESULT hrOle;
	DropSource ds;
	DataObject dob;
	DropTarget dt;

	static HINSTANCE hInstance;
	static ATOM scintillaClassAtom;
	static ATOM callClassAtom;

	float deviceScaleFactor = 1.f;
	[[nodiscard]] int GetFirstIntegralMultipleDeviceScaleFactor() const noexcept {
		 return static_cast<int>(std::ceil(deviceScaleFactor));
	}

#if defined(USE_D2D)
	DirectDevice device;
	ComPtr<IDXGISwapChain1> pDXGISwapChain;
	RenderTargets targets;
	// rendering parameters for current monitor
	HMONITOR hCurrentMonitor;
	std::shared_ptr<RenderingParams> renderingParams;
#endif

	explicit ScintillaWin(HWND hwnd);

	void Finalise() override;
#if defined(USE_D2D)
	bool UpdateRenderingParams(bool force) noexcept;
	HRESULT Create3D() noexcept;
	void CreateRenderTarget();
	HRESULT SetBackBuffer(HWND hwnd, IDXGISwapChain1 *pSwapChain);
	HRESULT CreateSwapChain(HWND hwnd);
	void EnsureRenderTarget(HDC hdc);
#endif
	void DropRenderTarget() noexcept;
	[[nodiscard]] HWND MainHWND() const noexcept;

	static sptr_t DirectFunction(
		    sptr_t ptr, UINT iMessage, uptr_t wParam, sptr_t lParam);
	static sptr_t DirectStatusFunction(
		    sptr_t ptr, UINT iMessage, uptr_t wParam, sptr_t lParam, int *pStatus);
	static LRESULT PASCAL SWndProc(
		    HWND hWnd, UINT iMessage, WPARAM wParam, LPARAM lParam);

	void CTPaint(HWND hWnd);
	LRESULT CTProcessMessage(HWND hWnd, UINT iMessage, WPARAM wParam, LPARAM lParam);
	static LRESULT PASCAL CTWndProc(
		    HWND hWnd, UINT iMessage, WPARAM wParam, LPARAM lParam);

	enum : UINT_PTR { invalidTimerID, standardTimerID, idleTimerID, fineTimerStart };

	void DisplayCursor(Window::Cursor c) override;
	bool DragThreshold(Point ptStart, Point ptNow) override;
	void StartDrag() override;
	static KeyMod MouseModifiers(uptr_t wParam) noexcept;

	Sci::Position TargetAsUTF8(char *text) const;
	Sci::Position EncodedFromUTF8(const char *utf8, char *encoded) const;

	void SetRenderingParams(Surface *psurf) const;

	bool PaintDC(HDC hdc);
	sptr_t WndPaint();

	// DBCS
	void ImeStartComposition();
	void ImeEndComposition();
	LRESULT ImeOnReconvert(LPARAM lParam);
	[[nodiscard]] LRESULT ImeOnDocumentFeed(LPARAM lParam) const;
	sptr_t HandleCompositionWindowed(uptr_t wParam, sptr_t lParam);
	sptr_t HandleCompositionInline(uptr_t wParam, sptr_t lParam);
	static bool KoreanIME() noexcept;
	void SetCandidateWindowPos(const IMContext &imc);
	void SelectionToHangul();
	void EscapeHanja();
	void ToggleHanja();
	void AddWString(std::wstring_view wsv, CharacterSource charSource);

	[[nodiscard]] UINT CodePageOfDocument() const noexcept;
	[[nodiscard]] bool ValidCodePage(int codePage) const override;
	[[nodiscard]] std::string UTF8FromEncoded(std::string_view encoded) const override;
	[[nodiscard]] std::string EncodedFromUTF8(std::string_view utf8) const override;

	std::string EncodeWString(std::wstring_view wsv);
	sptr_t DefWndProc(Message iMessage, uptr_t wParam, sptr_t lParam) override;
	void IdleWork() override;
	void QueueIdleWork(WorkItems items, Sci::Position upTo) override;
	bool SetIdle(bool on) override;
	UINT_PTR timers[static_cast<int>(TickReason::dwell)+1] {};
	bool FineTickerRunning(TickReason reason) override;
	void FineTickerStart(TickReason reason, int millis, int tolerance) override;
	void FineTickerCancel(TickReason reason) override;
	void SetMouseCapture(bool on) override;
	bool HaveMouseCapture() override;
	void SetTrackMouseLeaveEvent(bool on) noexcept;
	void HideCursorIfPreferred() noexcept;
	void UpdateBaseElements() override;
	bool PaintContains(PRectangle rc) override;
	void ScrollText(Sci::Line linesToMove) override;
	void NotifyCaretMove() override;
	void UpdateSystemCaret() override;
	void SetVerticalScrollPos() override;
	void SetHorizontalScrollPos() override;
	void HorizontalScrollToClamped(int xPos);
	[[nodiscard]] HorizontalScrollRange GetHorizontalScrollRange() const;
	bool ModifyScrollBars(Sci::Line nMax, Sci::Line nPage) override;
	void NotifyChange() override;
	void NotifyFocus(bool focus) override;
	void SetCtrlID(int identifier) override;
	int GetCtrlID() override;
	void NotifyParent(NotificationData scn) override;
	void NotifyDoubleClick(Point pt, KeyMod modifiers) override;
	std::unique_ptr<CaseFolder> CaseFolderForEncoding() override;
	std::string CaseMapString(const std::string &s, CaseMapping caseMapping) override;
	void Copy() override;
	bool CanPaste() override;
	void Paste() override;
	void CreateCallTipWindow(PRectangle rc) override;
	void AddToPopUp(const char *label, int cmd = 0, bool enabled = true) override;
	void ClaimSelection() override;

	void GetMouseParameters() noexcept;
	void CopyToGlobal(GlobalMemory &gmUnicode, const SelectionText &selectedText);
	void CopyToClipboard(const SelectionText &selectedText) override;
	void ScrollMessage(WPARAM wParam);
	void HorizontalScrollMessage(WPARAM wParam);
	void FullPaint();
	void FullPaintDC(HDC hdc);
	bool IsCompatibleDC(HDC hOtherDC) noexcept;
	[[nodiscard]] DWORD EffectFromState(DWORD grfKeyState) const noexcept;

	[[nodiscard]] bool IsVisible() const noexcept;
	int SetScrollInfo(int nBar, LPCSCROLLINFO lpsi, BOOL bRedraw) noexcept;
	bool GetScrollInfo(int nBar, LPSCROLLINFO lpsi) noexcept;
	bool ChangeScrollRange(int nBar, int nMin, int nMax, UINT nPage) noexcept;
	void ChangeScrollPos(int barType, Sci::Position pos);
	sptr_t GetTextLength();
	sptr_t GetText(uptr_t wParam, sptr_t lParam);
	Window::Cursor ContextCursor(Point pt);
	sptr_t ShowContextMenu(unsigned int iMessage, uptr_t wParam, sptr_t lParam);
	[[nodiscard]] PRectangle GetClientRectangle() const override;
	void SizeWindow();
	sptr_t MouseMessage(unsigned int iMessage, uptr_t wParam, sptr_t lParam);
	sptr_t KeyMessage(unsigned int iMessage, uptr_t wParam, sptr_t lParam);
	sptr_t FocusMessage(unsigned int iMessage, uptr_t wParam, sptr_t lParam);
	sptr_t IMEMessage(unsigned int iMessage, uptr_t wParam, sptr_t lParam);
	sptr_t EditMessage(unsigned int iMessage, uptr_t wParam, sptr_t lParam);
	sptr_t IdleMessage(unsigned int iMessage, uptr_t wParam, sptr_t lParam);
	sptr_t SciMessage(Message iMessage, uptr_t wParam, sptr_t lParam);

public:
	// Deleted so ScintillaWin objects can not be copied.
	ScintillaWin(const ScintillaWin &) = delete;
	ScintillaWin(ScintillaWin &&) = delete;
	ScintillaWin &operator=(const ScintillaWin &) = delete;
	ScintillaWin &operator=(ScintillaWin &&) = delete;
	~ScintillaWin() override;

	// Public for benefit of Scintilla_DirectFunction
	sptr_t WndProc(Message iMessage, uptr_t wParam, sptr_t lParam) override;

	/// Implement IUnknown
	STDMETHODIMP QueryInterface(REFIID riid, PVOID *ppv);
	STDMETHODIMP_(ULONG)AddRef();
	STDMETHODIMP_(ULONG)Release();

	/// Implement IDropTarget
	STDMETHODIMP DragEnter(LPDATAOBJECT pIDataSource, DWORD grfKeyState,
	                       POINTL pt, PDWORD pdwEffect);
	STDMETHODIMP DragOver(DWORD grfKeyState, POINTL pt, PDWORD pdwEffect);
	STDMETHODIMP DragLeave();
	STDMETHODIMP Drop(LPDATAOBJECT pIDataSource, DWORD grfKeyState,
	                  POINTL pt, PDWORD pdwEffect);

	void AuDragDrop(int action, Sci_DragDropData* r); //Au

	/// Implement important part of IDataObject
	STDMETHODIMP GetData(FORMATETC *pFEIn, STGMEDIUM *pSTM);

	static void Prepare() noexcept;
	static bool Register(HINSTANCE hInstance_) noexcept;
	static bool Unregister() noexcept;

	[[nodiscard]] bool DragIsRectangularOK(CLIPFORMAT fmt) const noexcept {
		return drag.rectangular && (fmt == cfColumnSelect);
	}

private:
	// For use in creating a system caret
	[[nodiscard]] bool HasCaretSizeChanged() const noexcept;
	BOOL CreateSystemCaret();
	BOOL DestroySystemCaret() noexcept;
	HBITMAP sysCaretBitmap;
	int sysCaretWidth;
	int sysCaretHeight;
	bool styleIdleInQueue;

	//Au:
public:
	void Sci_SetFoldLevels(int line, int lastLine, int len, int* a) {
		if(pdoc->Sci_SetFoldLevels(line, lastLine, len, a))
			RedrawSelMargin();
	}

	struct Sci_VisibleRange {
		int dlineFrom, dlineTo, vlineFrom, vlineTo, posFrom, posTo;
	};
	void Sci_GetVisibleRange(Sci_VisibleRange& r) {
		r.vlineFrom = (int)topLine;
		r.dlineFrom = (int)pcs->DocFromDisplay(topLine);
		r.posFrom = (int)posTopLine;

		auto vlines = (int)pcs->LinesDisplayed();
		auto vlineTo = topLine + LinesOnScreen() + 1; if(vlineTo > vlines) vlineTo = vlines;
		r.vlineTo = (int)vlineTo;
		if(vlineTo < vlines) {
			auto dlineTo = pcs->DocFromDisplay(vlineTo) + 1;
			r.dlineTo = (int)dlineTo;
			r.posTo = (int)pdoc->LineStart(dlineTo);
		} else {
			r.dlineTo = (int)pdoc->LinesTotal();
			r.posTo = (int)pdoc->Length();
		}
	}
};

HINSTANCE ScintillaWin::hInstance {};
ATOM ScintillaWin::scintillaClassAtom = 0;
ATOM ScintillaWin::callClassAtom = 0;

ScintillaWin::ScintillaWin(HWND hwnd) {

	lastKeyDownConsumed = false;
	lastHighSurrogateChar = 0;

	capturedMouse = false;
	trackedMouseLeave = false;
	typingWithoutCursor = false;
	cursorIsHidden = false;
	SetCoalescableTimerFn = nullptr;

	linesPerScroll = 0;
	charsPerScroll = 0;

	dpi = DpiForWindow(hwnd);

	hRgnUpdate = {};

	hasOKText = false;

	// There does not seem to be a real standard for indicating that the clipboard
	// contains a rectangular selection, so copy Developer Studio and Borland Delphi.
	cfColumnSelect = RegisterClipboardType(L"MSDEVColumnSelect");
	cfBorlandIDEBlockType = RegisterClipboardType(L"Borland IDE Block Type");

	// Likewise for line-copy or line-cut (copies or cuts a full line when no text is selected)
	cfLineSelect = RegisterClipboardType(L"MSDEVLineSelect");
	cfVSLineTag = RegisterClipboardType(L"VisualStudioEditorOperationsLineCutCopyClipboardTag");
	hrOle = E_FAIL;

	wMain = hwnd;

	dob.sci = this;
	ds.sci = this;
	dt.sci = this;

	sysCaretBitmap = {};
	sysCaretWidth = 0;
	sysCaretHeight = 0;

	styleIdleInQueue = false;

#if defined(USE_D2D)
	hCurrentMonitor = {};
#endif

	caret.period = ::GetCaretBlinkTime();
	if (caret.period < 0)
		caret.period = 0;

	// Initialize COM.  If the app has already done this it will have
	// no effect.  If the app hasn't, we really shouldn't ask them to call
	// it just so this internal feature works.
	hrOle = ::OleInitialize(nullptr);

	// Find SetCoalescableTimer which is only available from Windows 8+
	HMODULE user32 = ::GetModuleHandleW(L"user32.dll");
	SetCoalescableTimerFn = DLLFunction<SetCoalescableTimerSig>(user32, "SetCoalescableTimer");

	vs.indicators[IndicatorUnknown] = Indicator(IndicatorStyle::Hidden, colourIME);
	vs.indicators[IndicatorInput] = Indicator(IndicatorStyle::Dots, colourIME);
	vs.indicators[IndicatorConverted] = Indicator(IndicatorStyle::CompositionThick, colourIME);
	vs.indicators[IndicatorTarget] = Indicator(IndicatorStyle::StraightBox, colourIME);
}

ScintillaWin::~ScintillaWin() {
	if (sysCaretBitmap) {
		::DeleteObject(sysCaretBitmap);
		sysCaretBitmap = {};
	}
}

void ScintillaWin::Finalise() {
	ScintillaBase::Finalise();
	for (TickReason tr = TickReason::caret; tr <= TickReason::dwell;
		tr = static_cast<TickReason>(static_cast<int>(tr) + 1)) {
		FineTickerCancel(tr);
	}
	SetIdle(false);
	DropRenderTarget();
	::RevokeDragDrop(MainHWND());
	if (SUCCEEDED(hrOle)) {
		::OleUninitialize();
	}
}

#if defined(USE_D2D)

namespace {

HRESULT CreateHwndRenderTarget(const D2D1_RENDER_TARGET_PROPERTIES *renderTargetProperties,
	const D2D1_HWND_RENDER_TARGET_PROPERTIES *hwndRenderTargetProperties, HwndRenderTarget &hwndRT) noexcept {
	return pD2DFactory->CreateHwndRenderTarget(renderTargetProperties, hwndRenderTargetProperties, hwndRT.ReleaseAndGetAddressOf());
}

}

bool ScintillaWin::UpdateRenderingParams(bool force) noexcept {
	if (!renderingParams) {
		try {
			renderingParams = std::make_shared<RenderingParams>();
		} catch (const std::bad_alloc &) {
			return false;
		}
	}
	const HWND hRootWnd = ::GetAncestor(MainHWND(), GA_ROOT);
	const HMONITOR monitor = Internal::MonitorFromWindowHandleScaling(hRootWnd);
	if (!force && monitor == hCurrentMonitor && renderingParams->defaultRenderingParams) {
		return false;
	}

	ComPtr<IDWriteRenderingParams> upMrp;
	HRESULT hr = pIDWriteFactory->CreateMonitorRenderingParams(monitor, upMrp.GetAddressOf());
	if (FAILED(hr)) {
		return false;
	}

	// Cast to IDWriteRenderingParams1 so can call GetGrayscaleEnhancedContrast
	WriteRenderingParams monitorRenderingParams{};
	hr = upMrp.As(&monitorRenderingParams);

	WriteRenderingParams customClearTypeRenderingParams;
	UINT clearTypeContrast = 0;
	if (SUCCEEDED(hr) && monitorRenderingParams &&
		::SystemParametersInfo(SPI_GETFONTSMOOTHINGCONTRAST, 0, &clearTypeContrast, 0) != 0) {
		if (clearTypeContrast >= 1000 && clearTypeContrast <= 2200) {
			const FLOAT gamma = static_cast<FLOAT>(clearTypeContrast) / 1000.0f;
			pIDWriteFactory->CreateCustomRenderingParams(gamma,
				monitorRenderingParams->GetEnhancedContrast(),
				monitorRenderingParams->GetGrayscaleEnhancedContrast(),
				monitorRenderingParams->GetClearTypeLevel(),
				monitorRenderingParams->GetPixelGeometry(),
				monitorRenderingParams->GetRenderingMode(),
				customClearTypeRenderingParams.GetAddressOf());
		}
	}

	hCurrentMonitor = monitor;
	deviceScaleFactor = Internal::GetDeviceScaleFactorWhenGdiScalingActive(hRootWnd);
	renderingParams->defaultRenderingParams = std::move(monitorRenderingParams);
	renderingParams->customRenderingParams = std::move(customClearTypeRenderingParams);
	return true;
}

HRESULT ScintillaWin::Create3D() noexcept {
	if (device.pDirect2DDevice) {
		return S_OK;
	}
	targets.Release();
	pDXGISwapChain = nullptr;
	device.Release();
	const HRESULT hr = device.CreateDevice();
	if (FAILED(hr)) {
		device.Release();
	}
	return hr;
}

void ScintillaWin::CreateRenderTarget() {
	HWND hw = MainHWND();

	// Create a Direct2D render target.

	if (technology == Technology::DirectWriteDC) {
		const D2D1_RENDER_TARGET_PROPERTIES drtp = D2D1::RenderTargetProperties(
			D2D1_RENDER_TARGET_TYPE_DEFAULT,
			{ DXGI_FORMAT_B8G8R8A8_UNORM, D2D1_ALPHA_MODE_IGNORE },
			dpiDefault, dpiDefault);

		const HRESULT hr = CreateDCRenderTarget(&drtp, targets.pDCRT);
		if (FAILED(hr)) {
			Platform::DebugPrintf("Failed CreateDCRenderTarget 0x%lx\n", hr);
			targets.Release();
		}

	} else if (technology == Technology::DirectWrite1) {
		HRESULT hr = Create3D();	// Need pDirect2DDevice
		if (SUCCEEDED(hr)) {
			hr = device.pDirect2DDevice->CreateDeviceContext(D2D1_DEVICE_CONTEXT_OPTIONS_NONE,
				targets.pDeviceContext.ReleaseAndGetAddressOf());
			if (FAILED(hr)) {
				Platform::DebugPrintf("Failed CreateDeviceContext 0x%lx\n", hr);
			} else {
				hr = CreateSwapChain(hw);
				if (FAILED(hr)) {
					Platform::DebugPrintf("Failed CreateSwapChain 0x%lx\n", hr);
					targets.Release();
				}
			}
		}

	} else { // DirectWrite or DirectWriteRetain

		const RECT rc = GetClientRect(hw);

		const int integralDeviceScaleFactor = GetFirstIntegralMultipleDeviceScaleFactor();
		const FLOAT dpiTarget = dpiDefault * static_cast<float>(integralDeviceScaleFactor);

		const D2D1_RENDER_TARGET_PROPERTIES drtp = D2D1::RenderTargetProperties(
			D2D1_RENDER_TARGET_TYPE_DEFAULT,
			{ DXGI_FORMAT_UNKNOWN, D2D1_ALPHA_MODE_UNKNOWN },
			dpiTarget, dpiTarget);

		const D2D1_PRESENT_OPTIONS presentOptions = (technology == Technology::DirectWriteRetain) ?
			D2D1_PRESENT_OPTIONS_RETAIN_CONTENTS : D2D1_PRESENT_OPTIONS_NONE;

		const D2D1_HWND_RENDER_TARGET_PROPERTIES dhrtp = D2D1::HwndRenderTargetProperties(
			hw,
			::GetSizeUFromRect(rc, integralDeviceScaleFactor),
			presentOptions);

		const HRESULT hr = CreateHwndRenderTarget(&drtp, &dhrtp, targets.pHwndRT);
		if (FAILED(hr)) {
			Platform::DebugPrintf("Failed CreateHwndRenderTarget 0x%lx\n", hr);
			targets.Release();
		}

	}
}

HRESULT ScintillaWin::SetBackBuffer(HWND hwnd, IDXGISwapChain1 *pSwapChain) {
	assert(targets.pDeviceContext);
	// Back buffer as an IDXGISurface
	ComPtr<IDXGISurface> dxgiBackBuffer;
	HRESULT hr = pSwapChain->GetBuffer(0, IID_PPV_ARGS(dxgiBackBuffer.GetAddressOf()));
	if (FAILED(hr))
		return hr;

	const FLOAT dpiX = static_cast<FLOAT>(DpiForWindow(hwnd));
	const FLOAT dpiY = dpiX;

	// Direct2D bitmap linked to Direct3D texture through DXGI back buffer
	const D2D1_BITMAP_PROPERTIES1 bitmapProperties =
		D2D1::BitmapProperties1(D2D1_BITMAP_OPTIONS_TARGET | D2D1_BITMAP_OPTIONS_CANNOT_DRAW,
			D2D1::PixelFormat(DXGI_FORMAT_B8G8R8A8_UNORM, D2D1_ALPHA_MODE_IGNORE), dpiX, dpiY);
	ComPtr<ID2D1Bitmap1> pDirect2DBackBuffer;
	hr = targets.pDeviceContext->CreateBitmapFromDxgiSurface(dxgiBackBuffer.Get(), &bitmapProperties, pDirect2DBackBuffer.GetAddressOf());
	if (FAILED(hr))
		return hr;

	// Bitmap is render target
	targets.pDeviceContext->SetTarget(pDirect2DBackBuffer.Get());

	return S_OK;
}

HRESULT ScintillaWin::CreateSwapChain(HWND hwnd) {
	// Sets pDXGISwapChain but only when each call succeeds
	// Needs pDXGIDevice, pDirect3DDevice
	pDXGISwapChain = nullptr;
	assert(device.pDXGIDevice);

	// At each stage, place object in a unique_ptr to ensure release occurs

	ComPtr<IDXGIAdapter> dxgiAdapter;
	HRESULT hr = device.pDXGIDevice->GetAdapter(dxgiAdapter.GetAddressOf());
	if (FAILED(hr))
		return hr;

	ComPtr<IDXGIFactory2> dxgiFactory;
	hr = dxgiAdapter->GetParent(IID_PPV_ARGS(dxgiFactory.GetAddressOf()));
	if (FAILED(hr))
		return hr;

	DXGI_SWAP_CHAIN_DESC1 swapChainDesc{};
	swapChainDesc.Width = 0;
	swapChainDesc.Height = 0;
	swapChainDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM;
	swapChainDesc.Stereo = false;
	swapChainDesc.SampleDesc.Count = 1;
	swapChainDesc.SampleDesc.Quality = 0;
	swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
	swapChainDesc.BufferCount = 2;
	swapChainDesc.Scaling = DXGI_SCALING_STRETCH;
	swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
	swapChainDesc.Flags = 0;

	// DXGI swap chain for window
	ComPtr<IDXGISwapChain1> pSwapChain;
	hr = dxgiFactory->CreateSwapChainForHwnd(device.pDirect3DDevice.Get(), hwnd, &swapChainDesc,
		nullptr, nullptr, pSwapChain.GetAddressOf());
	if (FAILED(hr))
		return hr;

	hr = SetBackBuffer(hwnd, pSwapChain.Get());
	if (FAILED(hr))
		return hr;

	// All successful so export swap chain for later presentation
	pDXGISwapChain = std::move(pSwapChain);
	return S_OK;
}

void ScintillaWin::EnsureRenderTarget(HDC hdc) {
	if (!targets.valid) {
		DropRenderTarget();
		targets.valid = true;
	}
	if (!targets.RenderTarget()) {
		CreateRenderTarget();
		// Pixmaps were created to be compatible with previous render target so
		// need to be recreated.
		DropGraphics();
	}

	if ((technology == Technology::DirectWriteDC) && targets.pDCRT) {	// DC RenderTarget needs binding
		const RECT rcWindow = GetClientRect(MainHWND());
		const HRESULT hr = targets.pDCRT->BindDC(hdc, &rcWindow);
		if (FAILED(hr)) {
			Platform::DebugPrintf("BindDC failed 0x%lx\n", hr);
			DropRenderTarget();
		}
	}
}
#endif

void ScintillaWin::DropRenderTarget() noexcept {
#if defined(USE_D2D)
	targets.Release();
#endif
}

HWND ScintillaWin::MainHWND() const noexcept {
	return HwndFromWindow(wMain);
}

void ScintillaWin::DisplayCursor(Window::Cursor c) {
	if (cursorMode != CursorShape::Normal) {
		c = static_cast<Window::Cursor>(cursorMode);
	}
	if (c == Window::Cursor::reverseArrow) {
		::SetCursor(reverseArrowCursor.Load(static_cast<UINT>(static_cast<float>(dpi) * deviceScaleFactor)));
	} else {
		wMain.SetCursor(c);
	}
}

bool ScintillaWin::DragThreshold(Point ptStart, Point ptNow) {
	const Point ptDifference = ptStart - ptNow;
	const XYPOSITION xMove = std::trunc(std::abs(ptDifference.x));
	const XYPOSITION yMove = std::trunc(std::abs(ptDifference.y));
	return (xMove > SystemMetricsForDpi(SM_CXDRAG, dpi)) ||
		(yMove > SystemMetricsForDpi(SM_CYDRAG, dpi));
}

void ScintillaWin::StartDrag() {
	inDragDrop = DragDrop::dragging;
	DWORD dwEffect = 0;
	dropWentOutside = true;
	IDataObject *pDataObject = &dob;
	IDropSource *pDropSource = &ds;
	//Platform::DebugPrintf("About to DoDragDrop %x %x\n", pDataObject, pDropSource);
	const HRESULT hr = ::DoDragDrop(
	                 pDataObject,
	                 pDropSource,
	                 DROPEFFECT_COPY | DROPEFFECT_MOVE, &dwEffect);
	//Platform::DebugPrintf("DoDragDrop = %x\n", hr);
	if (SUCCEEDED(hr)) {
		if ((hr == DRAGDROP_S_DROP) && (dwEffect == DROPEFFECT_MOVE) && dropWentOutside) {
			// Remove dragged out text
			ClearSelection();
		}
	}
	inDragDrop = DragDrop::none;
	SetDragPosition(SelectionPosition(Sci::invalidPosition));
}

KeyMod ScintillaWin::MouseModifiers(uptr_t wParam) noexcept {
	return ModifierFlags(
		(wParam & MK_SHIFT) != 0,
		(wParam & MK_CONTROL) != 0,
		KeyboardIsKeyDown(VK_MENU));
}

}

namespace {

int InputCodePage() noexcept {
	HKL inputLocale = ::GetKeyboardLayout(0);
	const LANGID inputLang = LOWORD(inputLocale);
	char sCodePage[10];
	const int res = ::GetLocaleInfoA(MAKELCID(inputLang, SORT_DEFAULT),
	  LOCALE_IDEFAULTANSICODEPAGE, sCodePage, sizeof(sCodePage));
	if (!res)
		return 0;
	return atoi(sCodePage);
}

/** Map the key codes to their equivalent Keys:: form. */
Keys KeyTranslate(uptr_t keyIn) noexcept {
	switch (keyIn) {
	case VK_DOWN:		return Keys::Down;
		case VK_UP:		return Keys::Up;
		case VK_LEFT:		return Keys::Left;
		case VK_RIGHT:		return Keys::Right;
		case VK_HOME:		return Keys::Home;
		case VK_END:		return Keys::End;
		case VK_PRIOR:		return Keys::Prior;
		case VK_NEXT:		return Keys::Next;
		case VK_DELETE:	return Keys::Delete;
		case VK_INSERT:		return Keys::Insert;
		case VK_ESCAPE:	return Keys::Escape;
		case VK_BACK:		return Keys::Back;
		case VK_TAB:		return Keys::Tab;
		case VK_RETURN:	return Keys::Return;
		case VK_ADD:		return Keys::Add;
		case VK_SUBTRACT:	return Keys::Subtract;
		case VK_DIVIDE:		return Keys::Divide;
		case VK_LWIN:		return Keys::Win;
		case VK_RWIN:		return Keys::RWin;
		case VK_APPS:		return Keys::Menu;
		case VK_OEM_2:		return static_cast<Keys>('/');
		case VK_OEM_3:		return static_cast<Keys>('`');
		case VK_OEM_4:		return static_cast<Keys>('[');
		case VK_OEM_5:		return static_cast<Keys>('\\');
		case VK_OEM_6:		return static_cast<Keys>(']');
		default:			return static_cast<Keys>(keyIn);
	}
}

bool BoundsContains(PRectangle rcBounds, HRGN hRgnBounds, PRectangle rcCheck) noexcept {
	bool contains = true;
	if (!rcCheck.Empty()) {
		if (!rcBounds.Contains(rcCheck)) {
			contains = false;
		} else if (hRgnBounds) {
			// In bounding rectangle so check more accurately using region
			const RECT rcw = RectFromPRectangle(rcCheck);
			HRGN hRgnCheck = ::CreateRectRgnIndirect(&rcw);
			if (hRgnCheck) {
				HRGN hRgnDifference = ::CreateRectRgn(0, 0, 0, 0);
				if (hRgnDifference) {
					const int combination = ::CombineRgn(hRgnDifference, hRgnCheck, hRgnBounds, RGN_DIFF);
					if (combination != NULLREGION) {
						contains = false;
					}
					::DeleteRgn(hRgnDifference);
				}
				::DeleteRgn(hRgnCheck);
			}
		}
	}
	return contains;
}

// Simplify calling WideCharToMultiByte and MultiByteToWideChar by providing default parameters and using string view.

int MultiByteFromWideChar(UINT codePage, std::wstring_view wsv, LPSTR lpMultiByteStr, ptrdiff_t cbMultiByte) noexcept {
	return ::WideCharToMultiByte(codePage, 0, wsv.data(), static_cast<int>(wsv.length()), lpMultiByteStr, static_cast<int>(cbMultiByte), nullptr, nullptr);
}

int MultiByteLenFromWideChar(UINT codePage, std::wstring_view wsv) noexcept {
	return MultiByteFromWideChar(codePage, wsv, nullptr, 0);
}

int WideCharFromMultiByte(UINT codePage, std::string_view sv, LPWSTR lpWideCharStr, ptrdiff_t cchWideChar) noexcept {
	return ::MultiByteToWideChar(codePage, 0, sv.data(), static_cast<int>(sv.length()), lpWideCharStr, static_cast<int>(cchWideChar));
}

int WideCharLenFromMultiByte(UINT codePage, std::string_view sv) noexcept {
	return WideCharFromMultiByte(codePage, sv, nullptr, 0);
}

std::string StringEncode(std::wstring_view wsv, int codePage) {
	const int cchMulti = wsv.empty() ? 0 : MultiByteLenFromWideChar(codePage, wsv);
	std::string sMulti(cchMulti, 0);
	if (cchMulti) {
		MultiByteFromWideChar(codePage, wsv, sMulti.data(), cchMulti);
	}
	return sMulti;
}

std::wstring StringDecode(std::string_view sv, int codePage) {
	const int cchWide = sv.empty() ? 0 : WideCharLenFromMultiByte(codePage, sv);
	std::wstring sWide(cchWide, 0);
	if (cchWide) {
		WideCharFromMultiByte(codePage, sv, sWide.data(), cchWide);
	}
	return sWide;
}

std::wstring StringMapCase(std::wstring_view wsv, DWORD mapFlags) {
	const int charsConverted = ::LCMapStringW(LOCALE_SYSTEM_DEFAULT, mapFlags,
		wsv.data(), static_cast<int>(wsv.length()), nullptr, 0);
	std::wstring wsConverted(charsConverted, 0);
	if (charsConverted) {
		::LCMapStringW(LOCALE_SYSTEM_DEFAULT, mapFlags,
			wsv.data(), static_cast<int>(wsv.length()), wsConverted.data(), charsConverted);
	}
	return wsConverted;
}

}

// Returns the target converted to UTF8.
// Return the length in bytes.
Sci::Position ScintillaWin::TargetAsUTF8(char *text) const {
	const Sci::Position targetLength = targetRange.Length();
	if (IsUnicodeMode()) {
		if (text) {
			pdoc->GetCharRange(text, targetRange.start.Position(), targetLength);
		}
	} else {
		// Need to convert
		const std::string s = RangeText(targetRange.start.Position(), targetRange.end.Position());
		const std::wstring characters = StringDecode(s, CodePageOfDocument());
		const int utf8Len = MultiByteLenFromWideChar(CpUtf8, characters);
		if (text) {
			MultiByteFromWideChar(CpUtf8, characters, text, utf8Len);
			text[utf8Len] = '\0';
		}
		return utf8Len;
	}
	return targetLength;
}

// Translates a nul terminated UTF8 string into the document encoding.
// Return the length of the result in bytes.
Sci::Position ScintillaWin::EncodedFromUTF8(const char *utf8, char *encoded) const {
	const Sci::Position inputLength = (lengthForEncode >= 0) ? lengthForEncode : strlen(utf8);
	if (IsUnicodeMode()) {
		if (encoded) {
			memcpy(encoded, utf8, inputLength);
		}
		return inputLength;
	}
	// Need to convert
	const std::string_view utf8Input(utf8, inputLength);
	const int charsLen = WideCharLenFromMultiByte(CpUtf8, utf8Input);
	std::wstring characters(charsLen, L'\0');
	WideCharFromMultiByte(CpUtf8, utf8Input, characters.data(), charsLen);

	const int encodedLen = MultiByteLenFromWideChar(CodePageOfDocument(), characters);
	if (encoded) {
		MultiByteFromWideChar(CodePageOfDocument(), characters, encoded, encodedLen);
		encoded[encodedLen] = '\0';
	}
	return encodedLen;
}

void ScintillaWin::SetRenderingParams([[maybe_unused]] Surface *psurf) const {
#if defined(USE_D2D)
	if (psurf) {
		ISetRenderingParams *setDrawingParams = dynamic_cast<ISetRenderingParams *>(psurf);
		if (setDrawingParams) {
			setDrawingParams->SetRenderingParams(renderingParams);
		}
	}
#endif
}

bool ScintillaWin::PaintDC(HDC hdc) {
	if (technology == Technology::Default) {
		AutoSurface surfaceWindow(hdc, this);
		if (surfaceWindow) {
			Paint(surfaceWindow, rcPaint);
			surfaceWindow->Release();
		}
	} else {
#if defined(USE_D2D)
		// RefreshStyleData may set scroll bars and resize the window.
		// Avoid issues resizing inside Paint when calling IDXGISwapChain1->ResizeBuffers
		// with committed resources by refreshing the style data first.
		RefreshStyleData();

		EnsureRenderTarget(hdc);
		if (ID2D1RenderTarget *pRenderTarget = targets.RenderTarget()) {
			AutoSurface surfaceWindow(pRenderTarget, this);
			if (surfaceWindow) {
				SetRenderingParams(surfaceWindow);
				pRenderTarget->BeginDraw();
				Paint(surfaceWindow, rcPaint);
				surfaceWindow->Release();
				const HRESULT hr = pRenderTarget->EndDraw();
				if (hr == static_cast<HRESULT>(D2DERR_RECREATE_TARGET)) {
					DropRenderTarget();
					return false;
				}
				if ((technology == Technology::DirectWrite1) && pDXGISwapChain) {
					const DXGI_PRESENT_PARAMETERS parameters{};
					const HRESULT hrPresent = pDXGISwapChain->Present1(1, 0, &parameters);
					if (FAILED(hrPresent)) {
						DropRenderTarget();
						return false;
					}
				}
			}
		}
#endif
	}

	return true;
}

sptr_t ScintillaWin::WndPaint() {
	//ElapsedPeriod ep;

	// Redirect assertions to debug output and save current state
	const bool assertsPopup = Platform::ShowAssertionPopUps(false);
	paintState = PaintState::painting;

	// Removed since this interferes with reporting other assertions as it occurs repeatedly
	//PLATFORM_ASSERT(hRgnUpdate == NULL);
	hRgnUpdate = ::CreateRectRgn(0, 0, 0, 0);
	::GetUpdateRgn(MainHWND(), hRgnUpdate, FALSE);
	{
		Painter painter(MainHWND());
		rcPaint = PRectangleFromRECT(painter.ps.rcPaint);
		const PRectangle rcClient = GetClientRectangle();
		paintingAllText = BoundsContains(rcPaint, hRgnUpdate, rcClient);
		if (!PaintDC(painter.ps.hdc)) {
			paintState = PaintState::abandoned;
		}
	}
	if (hRgnUpdate) {
		::DeleteRgn(hRgnUpdate);
		hRgnUpdate = {};
	}
	if (paintState == PaintState::abandoned) {
		// Painting area was insufficient to cover new styling or brace highlight positions
		FullPaint();
		::ValidateRect(MainHWND(), nullptr);
	}
	paintState = PaintState::notPainting;

	// Restore debug output state
	Platform::ShowAssertionPopUps(assertsPopup);

	//Platform::DebugPrintf("Paint took %g\n", ep.Duration());
	return 0;
}

sptr_t ScintillaWin::HandleCompositionWindowed(uptr_t wParam, sptr_t lParam) {
	if (lParam & GCS_RESULTSTR) {
		if (IMContext imc{ MainHWND() }) {
			AddWString(imc.GetCompositionString(GCS_RESULTSTR), CharacterSource::ImeResult);

			// Set new position after converted
			imc.SetCompositionWindow(PointMainCaret());
		}
		return 0;
	}
	return ::DefWindowProc(MainHWND(), WM_IME_COMPOSITION, wParam, lParam);
}

bool ScintillaWin::KoreanIME() noexcept {
	const int codePage = InputCodePage();
	return codePage == cp949 || codePage == cp1361;
}

void ScintillaWin::SetCandidateWindowPos(const IMContext &imc) {
	imc.SetCandidateWindowPos(PointMainCaret(), GetTextRectangle(), vs.lineHeight);
}

void ScintillaWin::SelectionToHangul() {
	// Convert every hanja to hangul within the main range.
	const Sci::Position selStart = sel.RangeMain().Start().Position();
	const Sci::Position documentStrLen = sel.RangeMain().Length();
	const Sci::Position selEnd = selStart + documentStrLen;
	const Sci::Position utf16Len = pdoc->CountUTF16(selStart, selEnd);

	if (utf16Len > 0) {
		const std::string documentStr = RangeText(selStart, selStart + documentStrLen);

		std::wstring uniStr = StringDecode(documentStr, CodePageOfDocument());
		const bool converted = HanjaDict::GetHangulOfHanja(uniStr);

		if (converted) {
			const std::string hangul = StringEncode(uniStr, CodePageOfDocument());
			UndoGroup ug(pdoc);
			ClearSelection();
			InsertPaste(hangul.data(), hangul.size());
		}
	}
}

void ScintillaWin::EscapeHanja() {
	// The candidate box pops up to user to select a hanja.
	// It comes into WM_IME_COMPOSITION with GCS_RESULTSTR.
	// The existing hangul or hanja is replaced with it.

	const Sci::Position currentPos = CurrentPosition();
	const int oneCharLen = pdoc->LenChar(currentPos);

	if (oneCharLen < 2) {
		return; // No need to handle SBCS.
	}

	const std::string oneChar = RangeText(currentPos, currentPos + oneCharLen);

	std::wstring uniChar = StringDecode(oneChar, CodePageOfDocument());
	// ImmEscapeW() may overwrite uniChar[] with a null terminated string.
	// So enlarge it enough to Maximum 4 as in UTF-8.
	uniChar.resize(UTF8MaxBytes);

	if (IMContext imc{ MainHWND() }) {
		// Set the candidate box position since IME may show it.
		SetCandidateWindowPos(imc);
		// IME_ESC_HANJA_MODE appears to receive the first character only.
		if (imc.Escape(GetKeyboardLayout(0), IME_ESC_HANJA_MODE, uniChar.data())) {
			SetSelection(currentPos, currentPos + oneCharLen);
		}
	}
}

void ScintillaWin::ToggleHanja() {
	// If selection, convert every hanja to hangul within the main range.
	// If no selection, commit to IME.
	if (sel.Count() > 1) {
		return; // Do not allow multi carets.
	}

	if (sel.Empty()) {
		EscapeHanja();
	} else {
		SelectionToHangul();
	}
}

namespace {

std::vector<int> MapImeIndicators(std::vector<BYTE> inputStyle) {
	std::vector<int> imeIndicator(inputStyle.size(), IndicatorUnknown);
	for (size_t i = 0; i < inputStyle.size(); i++) {
		switch (static_cast<int>(inputStyle.at(i))) {
		case ATTR_INPUT:
			imeIndicator[i] = IndicatorInput;
			break;
		case ATTR_TARGET_NOTCONVERTED:
		case ATTR_TARGET_CONVERTED:
			imeIndicator[i] = IndicatorTarget;
			break;
		case ATTR_CONVERTED:
			imeIndicator[i] = IndicatorConverted;
			break;
		default:
			imeIndicator[i] = IndicatorUnknown;
			break;
		}
	}
	return imeIndicator;
}

}

void ScintillaWin::AddWString(std::wstring_view wsv, CharacterSource charSource) {
	if (wsv.empty())
		return;

	const int codePage = CodePageOfDocument();
	for (size_t i = 0; i < wsv.size(); ) {
		const size_t ucWidth = UTF16CharLength(wsv[i]);
		const std::string docChar = StringEncode(wsv.substr(i, ucWidth), codePage);

		InsertCharacter(docChar, charSource);
		i += ucWidth;
	}
}

sptr_t ScintillaWin::HandleCompositionInline(uptr_t, sptr_t lParam) {
	// Copy & paste by johnsonj with a lot of helps of Neil.
	// Great thanks for my foreruners, jiniya and BLUEnLIVE.

	IMContext imc(MainHWND());
	if (!imc)
		return 0;
	if (pdoc->IsReadOnly() || SelectionContainsProtected()) {
		imc.Notify(false);
		return 0;
	}

	bool initialCompose = false;
	if (pdoc->TentativeActive()) {
		pdoc->TentativeUndo();
	} else {
		// No tentative undo means start of this composition so
		// fill in any virtual spaces.
		initialCompose = true;
	}

	view.imeCaretBlockOverride = false;
	HideCursorIfPreferred();

	if (lParam & GCS_RESULTSTR) {
		AddWString(imc.GetCompositionString(GCS_RESULTSTR), CharacterSource::ImeResult);
	}

	if (lParam & GCS_COMPSTR) {
		const std::wstring wcs = imc.GetCompositionString(GCS_COMPSTR);
		if (wcs.empty()) {
			ShowCaretAtCurrentPosition();
			return 0;
		}

		if (initialCompose) {
			ClearBeforeTentativeStart();
		}

		// Set candidate window left aligned to beginning of preedit string.
		SetCandidateWindowPos(imc);
		pdoc->TentativeStart(); // TentativeActive from now on.

		std::vector<int> imeIndicator = MapImeIndicators(imc.GetImeAttributes());

		const int codePage = CodePageOfDocument();
		const std::wstring_view wsv = wcs;
		for (size_t i = 0; i < wsv.size(); ) {
			const size_t ucWidth = UTF16CharLength(wsv[i]);
			const std::string docChar = StringEncode(wsv.substr(i, ucWidth), codePage);

			InsertCharacter(docChar, CharacterSource::TentativeInput);

			DrawImeIndicator(imeIndicator[i], docChar.size());
			i += ucWidth;
		}

		// Japanese IME after pressing Tab replaces input string with first candidate item (target string);
		// when selecting other candidate item, previous item will be replaced with current one.
		// After candidate item been added, it's looks like been full selected, it's better to keep caret
		// at end of "selection" (end of input) instead of jump to beginning of input ("selection").
		const bool onlyTarget = std::all_of(imeIndicator.begin(), imeIndicator.end(), [](int i) noexcept {
			return i == IndicatorTarget;
		});
		if (!onlyTarget) {
			// CS_NOMOVECARET: keep caret at beginning of composition string which already moved in InsertCharacter().
			// GCS_CURSORPOS: current caret position is provided by IME.
			Sci::Position imeEndToImeCaretU16 = -static_cast<Sci::Position>(wcs.size());
			if (!(lParam & CS_NOMOVECARET) && (lParam & GCS_CURSORPOS)) {
				imeEndToImeCaretU16 += imc.GetImeCaretPos();
			}
			if (imeEndToImeCaretU16 != 0) {
				// Move back IME caret from current last position to imeCaretPos.
				const Sci::Position currentPos = CurrentPosition();
				const Sci::Position imeCaretPosDoc = pdoc->GetRelativePositionUTF16(currentPos, imeEndToImeCaretU16);

				MoveImeCarets(-currentPos + imeCaretPosDoc);
			}
		}

		if (KoreanIME()) {
			view.imeCaretBlockOverride = true;
		}
	}
	EnsureCaretVisible();
	ShowCaretAtCurrentPosition();
	return 0;
}

namespace {

// Translate message IDs from WM_* and EM_* to Message::* so can partly emulate Windows Edit control
Message SciMessageFromEM(unsigned int iMessage) noexcept {
	switch (iMessage) {
	case EM_CANPASTE: return Message::CanPaste;
	case EM_CANUNDO: return Message::CanUndo;
	case EM_EMPTYUNDOBUFFER: return Message::EmptyUndoBuffer;
	case EM_FINDTEXTEX: return Message::FindText;
	case EM_FORMATRANGE: return Message::FormatRange;
	case EM_GETFIRSTVISIBLELINE: return Message::GetFirstVisibleLine;
	case EM_GETLINECOUNT: return Message::GetLineCount;
	case EM_GETSELTEXT: return Message::GetSelText;
	case EM_GETTEXTRANGE: return Message::GetTextRange;
	case EM_HIDESELECTION: return Message::HideSelection;
	case EM_LINEINDEX: return Message::PositionFromLine;
	case EM_LINESCROLL: return Message::LineScroll;
	case EM_REPLACESEL: return Message::ReplaceSel;
	case EM_SCROLLCARET: return Message::ScrollCaret;
	case EM_SETREADONLY: return Message::SetReadOnly;
	case WM_CLEAR: return Message::Clear;
	case WM_COPY: return Message::Copy;
	case WM_CUT: return Message::Cut;
	case WM_SETTEXT: return Message::SetText;
	case WM_PASTE: return Message::Paste;
	case WM_UNDO: return Message::Undo;
	}
	return static_cast<Message>(iMessage);
}

constexpr bool IsVisualCharacter(wchar_t charCode) noexcept {
	constexpr wchar_t lastAscii = INT8_MAX;
	return (charCode > lastAscii) || !IsControl(charCode);
}

}

namespace Scintilla::Internal {

// Removing 'magic' numbers here would not help here.

// NOLINTBEGIN(*-magic-numbers)

UINT CodePageFromCharSet(CharacterSet characterSet, UINT documentCodePage) noexcept {
	if (documentCodePage == CpUtf8) {
		return CpUtf8;
	}
	switch (characterSet) {
	case CharacterSet::Ansi: return 1252;
	case CharacterSet::Default: return documentCodePage ? documentCodePage : 1252;
	case CharacterSet::Baltic: return 1257;
	case CharacterSet::ChineseBig5: return 950;
	case CharacterSet::EastEurope: return 1250;
	case CharacterSet::GB2312: return 936;
	case CharacterSet::Greek: return 1253;
	case CharacterSet::Hangul: return 949;
	case CharacterSet::Mac: return 10000;
	case CharacterSet::Oem: return 437;
	case CharacterSet::Russian: return 1251;
	case CharacterSet::ShiftJis: return 932;
	case CharacterSet::Turkish: return 1254;
	case CharacterSet::Johab: return 1361;
	case CharacterSet::Hebrew: return 1255;
	case CharacterSet::Arabic: return 1256;
	case CharacterSet::Vietnamese: return 1258;
	case CharacterSet::Thai: return 874;
	case CharacterSet::Iso8859_15: return 28605;
	// Not supported
	case CharacterSet::Cyrillic: return documentCodePage;
	case CharacterSet::Symbol: return documentCodePage;
	default: break;
	}
	return documentCodePage;
}

// NOLINTEND(*-magic-numbers)

}

UINT ScintillaWin::CodePageOfDocument() const noexcept {
	return CodePageFromCharSet(vs.styles[StyleDefault].characterSet, pdoc->dbcsCodePage);
}

std::string ScintillaWin::EncodeWString(std::wstring_view wsv) {
	if (IsUnicodeMode()) {
		const size_t len = UTF8Length(wsv);
		std::string putf(len, 0);
		UTF8FromUTF16(wsv, putf.data(), len);
		return putf;
	}
	// Not in Unicode mode so convert from Unicode to current Scintilla code page
	return StringEncode(wsv, CodePageOfDocument());
}

sptr_t ScintillaWin::GetTextLength() {
	if (pdoc->dbcsCodePage == 0 || pdoc->dbcsCodePage == CpUtf8) {
		return pdoc->CountUTF16(0, pdoc->Length());
	}
	// Count the number of UTF-16 code units line by line
	const UINT cpSrc = CodePageOfDocument();
	const Sci::Line lines = pdoc->LinesTotal();
	Sci::Position codeUnits = 0;
	std::string lineBytes;
	for (Sci::Line line = 0; line < lines; line++) {
		const Sci::Position start = pdoc->LineStart(line);
		const Sci::Position width = pdoc->LineStart(line+1) - start;
		lineBytes.resize(width);
		pdoc->GetCharRange(lineBytes.data(), start, width);
		codeUnits += WideCharLenFromMultiByte(cpSrc, lineBytes);
	}
	return codeUnits;
}

sptr_t ScintillaWin::GetText(uptr_t wParam, sptr_t lParam) {
	if (lParam == 0) {
		return GetTextLength();
	}
	if (wParam == 0) {
		return 0;
	}
	wchar_t *ptr = static_cast<wchar_t *>(PtrFromSPtr(lParam));
	if (pdoc->Length() == 0) {
		*ptr = L'\0';
		return 0;
	}
	const Sci::Position lengthWanted = wParam - 1;
	if (IsUnicodeMode()) {
		Sci::Position sizeRequestedRange = pdoc->GetRelativePositionUTF16(0, lengthWanted);
		if (sizeRequestedRange < 0) {
			// Requested more text than there is in the document.
			sizeRequestedRange = pdoc->Length();
		}
		std::string docBytes(sizeRequestedRange, '\0');
		pdoc->GetCharRange(docBytes.data(), 0, sizeRequestedRange);
		const size_t uLen = UTF16FromUTF8(docBytes, ptr, lengthWanted);
		ptr[uLen] = L'\0';
		return uLen;
	}
	// Not Unicode mode
	// Convert to Unicode using the current Scintilla code page
	// Retrieve as UTF-16 line by line
	const UINT cpSrc = CodePageOfDocument();
	const Sci::Line lines = pdoc->LinesTotal();
	Sci::Position codeUnits = 0;
	std::string lineBytes;
	std::wstring lineAsUTF16;
	for (Sci::Line line = 0; line < lines && codeUnits < lengthWanted; line++) {
		const Sci::Position start = pdoc->LineStart(line);
		const Sci::Position width = pdoc->LineStart(line + 1) - start;
		lineBytes.resize(width);
		pdoc->GetCharRange(lineBytes.data(), start, width);
		const Sci::Position codeUnitsLine = WideCharLenFromMultiByte(cpSrc, lineBytes);
		lineAsUTF16.resize(codeUnitsLine);
		const Sci::Position lengthLeft = lengthWanted - codeUnits;
		WideCharFromMultiByte(cpSrc, lineBytes, lineAsUTF16.data(), lineAsUTF16.length());
		const Sci::Position lengthToCopy = std::min(lengthLeft, codeUnitsLine);
		lineAsUTF16.copy(ptr + codeUnits, lengthToCopy);
		codeUnits += lengthToCopy;
	}
	ptr[codeUnits] = L'\0';
	return codeUnits;
}

Window::Cursor ScintillaWin::ContextCursor(Point pt) {
	if (inDragDrop == DragDrop::dragging) {
		return Window::Cursor::up;
	}
	// Display regular (drag) cursor over selection
	if (PointInSelMargin(pt)) {
		return GetMarginCursor(pt);
	} else if (!SelectionEmpty() && PointInSelection(pt)) {
		return Window::Cursor::arrow;
	} else if (PointIsHotspot(pt)) {
		return Window::Cursor::hand;
	} else if (hoverIndicatorPos != Sci::invalidPosition) {
		const Sci::Position pos = PositionFromLocation(pt, true, true);
		if (pos != Sci::invalidPosition) {
			return Window::Cursor::hand;
		}
	}
	return Window::Cursor::text;
}

sptr_t ScintillaWin::ShowContextMenu(unsigned int iMessage, uptr_t wParam, sptr_t lParam) {
	Point ptScreen = PointFromLParam(lParam);
	Point ptClient;
	POINT point = POINTFromLParam(lParam);
	if ((point.x == -1) && (point.y == -1)) {
		// Caused by keyboard so display menu near caret
		ptClient = PointMainCaret();
		point = POINTFromPoint(ptClient);
		::ClientToScreen(MainHWND(), &point);
		ptScreen = PointFromPOINT(point);
	} else {
		::ScreenToClient(MainHWND(), &point);
		ptClient = PointFromPOINT(point);
	}
	if (ShouldDisplayPopup(ptClient)) {
		ContextMenu(ptScreen);
		return 0;
	}
	return ::DefWindowProc(MainHWND(), iMessage, wParam, lParam);
}

PRectangle ScintillaWin::GetClientRectangle() const {
	return rectangleClient;
}

void ScintillaWin::SizeWindow() {
	rectangleClient = wMain.GetClientPosition();
#if defined(USE_D2D)
	HRESULT hrResize = E_FAIL;
	if (((technology == Technology::DirectWrite) || (technology == Technology::DirectWriteRetain)) && targets.pHwndRT) {
		// May be able to just resize the HWND render target
		const int scaleFactor = GetFirstIntegralMultipleDeviceScaleFactor();
		const D2D1_SIZE_U pixelSize = ::GetSizeUFromRect(GetClientRect(MainHWND()), scaleFactor);
		hrResize = targets.pHwndRT->Resize(pixelSize);
		if (FAILED(hrResize)) {
			Platform::DebugPrintf("Failed to Resize ID2D1HwndRenderTarget 0x%lx\n", hrResize);
		}
	}
	if ((technology == Technology::DirectWrite1) && pDXGISwapChain && targets.pDeviceContext &&
		(paintState == PaintState::notPainting)) {
		targets.pDeviceContext->SetTarget(nullptr);	// ResizeBuffers fails if bitmap still owned by swap chain
		hrResize = pDXGISwapChain->ResizeBuffers(0, 0, 0, DXGI_FORMAT_UNKNOWN, 0);
		if (SUCCEEDED(hrResize)) {
			hrResize = SetBackBuffer(MainHWND(), pDXGISwapChain.Get());
		} else {
			Platform::DebugPrintf("Failed ResizeBuffers 0x%lx\n", hrResize);
		}
	}
	if (FAILED(hrResize)) {
		if (paintState == PaintState::notPainting) {
			DropRenderTarget();
		} else {
			targets.valid = false;
		}
	}
#endif
	//Platform::DebugPrintf("Scintilla WM_SIZE %d %d\n", LOWORD(lParam), HIWORD(lParam));
	ChangeSize();
}

sptr_t ScintillaWin::MouseMessage(unsigned int iMessage, uptr_t wParam, sptr_t lParam) {
	switch (iMessage) {
	case WM_LBUTTONDOWN:
		// For IME, set the composition string as the result string.
		if (IMContext imc{ MainHWND() }) {
			imc.Notify(true);
		}

		//Au: KScintilla will set focus when need, and in a better way.
		//::SetFocus(MainHWND());

		ButtonDownWithModifiers(PointFromLParam(lParam), ::GetMessageTime(),
					MouseModifiers(wParam));
		break;

	case WM_LBUTTONUP:
		ButtonUpWithModifiers(PointFromLParam(lParam),
				      ::GetMessageTime(), MouseModifiers(wParam));
		break;

	case WM_RBUTTONDOWN: {
			//::SetFocus(MainHWND()); //Au
			const Point pt = PointFromLParam(lParam);
			if (!PointInSelection(pt)) {
				CancelModes();
				SetEmptySelection(PositionFromLocation(PointFromLParam(lParam)));
			}

			RightButtonDownWithModifiers(pt, ::GetMessageTime(), MouseModifiers(wParam));
		}
		break;

	case WM_MOUSEMOVE: {
			cursorIsHidden = false; // to be shown by ButtonMoveWithModifiers
			const Point pt = PointFromLParam(lParam);

			// Windows might send WM_MOUSEMOVE even though the mouse has not been moved:
			// http://blogs.msdn.com/b/oldnewthing/archive/2003/10/01/55108.aspx
			if (ptMouseLast != pt) {
				SetTrackMouseLeaveEvent(true);
				ButtonMoveWithModifiers(pt, ::GetMessageTime(), MouseModifiers(wParam));
			}
		}
		break;

	case WM_MOUSELEAVE:
		SetTrackMouseLeaveEvent(false);
		MouseLeave();
		return ::DefWindowProc(MainHWND(), iMessage, wParam, lParam);

	case WM_MOUSEWHEEL:
	case WM_MOUSEHWHEEL:
		if (!mouseWheelCaptures) {
			// if the mouse wheel is not captured, test if the mouse
			// pointer is over the editor window and if not, don't
			// handle the message but pass it on.
			RECT rc;
			GetWindowRect(MainHWND(), &rc);
			const POINT pt = POINTFromLParam(lParam);
			if (!PtInRect(&rc, pt))
				return ::DefWindowProc(MainHWND(), iMessage, wParam, lParam);
		}
		// if autocomplete list active then send mousewheel message to it
		if (ac.Active()) {
			HWND hWnd = HwndFromWindow(*(ac.lb));
			::SendMessage(hWnd, iMessage, wParam, lParam);
			break;
		}

		// Treat Shift+WM_MOUSEWHEEL as horizontal scrolling, not data-zoom.
		if (iMessage == WM_MOUSEHWHEEL || (wParam & MK_SHIFT)) {
			if (vs.wrap.state != Wrap::None || charsPerScroll == 0) {
				return ::DefWindowProc(MainHWND(), iMessage, wParam, lParam);
			}

			MouseWheelDelta &wheelDelta = (iMessage == WM_MOUSEHWHEEL) ? horizontalWheelDelta : verticalWheelDelta;
			if (wheelDelta.Accumulate(wParam)) {
				int charsToScroll = charsPerScroll * wheelDelta.Actions();
				if (iMessage == WM_MOUSEHWHEEL) {
					// horizontal scroll is in reverse direction
					charsToScroll = -charsToScroll;
				}
				const int widthToScroll = static_cast<int>(std::lround(charsToScroll * vs.aveCharWidth));
				HorizontalScrollToClamped(xOffset + widthToScroll);
			}
			// return 1 for Logitech mouse, https://www.pretentiousname.com/setpoint_hwheel/index.html
			return (iMessage == WM_MOUSEHWHEEL) ? 1 : 0;
		}

		// Either SCROLL vertically or ZOOM. We handle the wheel steppings calculation
		if (linesPerScroll != 0 && verticalWheelDelta.Accumulate(wParam)) {
			Sci::Line linesToScroll = linesPerScroll;
			if (linesPerScroll == WHEEL_PAGESCROLL)
				linesToScroll = LinesOnScreen() - 1;
			if (linesToScroll == 0) {
				linesToScroll = 1;
			}
			linesToScroll *= verticalWheelDelta.Actions();

			if (wParam & MK_CONTROL) {
				// Zoom! We play with the font sizes in the styles.
				// Number of steps/line is ignored, we just care if sizing up or down
				if (linesToScroll < 0) {
					KeyCommand(Message::ZoomIn);
				} else {
					KeyCommand(Message::ZoomOut);
				}
			} else {
				// Scroll
				ScrollTo(topLine + linesToScroll);
			}
		}
		return 0;
	}
	return 0;
}

sptr_t ScintillaWin::KeyMessage(unsigned int iMessage, uptr_t wParam, sptr_t lParam) {
	switch (iMessage) {

	case WM_SYSKEYDOWN:
	case WM_KEYDOWN: {
			// Platform::DebugPrintf("Keydown %c %c%c%c%c %x %x\n",
			// iMessage == WM_KEYDOWN ? 'K' : 'S',
			// (lParam & (1 << 24)) ? 'E' : '-',
			// KeyboardIsKeyDown(VK_SHIFT) ? 'S' : '-',
			// KeyboardIsKeyDown(VK_CONTROL) ? 'C' : '-',
			// KeyboardIsKeyDown(VK_MENU) ? 'A' : '-',
			// wParam, lParam);
			lastKeyDownConsumed = false;
			const bool altDown = KeyboardIsKeyDown(VK_MENU);
			if (altDown && KeyboardIsNumericKeypadFunction(wParam, lParam)) {
				// Don't interpret these as they may be characters entered by number.
				return ::DefWindowProc(MainHWND(), iMessage, wParam, lParam);
			}
			const int ret = KeyDownWithModifiers(
								 KeyTranslate(wParam),
							     ModifierFlags(KeyboardIsKeyDown(VK_SHIFT),
									     KeyboardIsKeyDown(VK_CONTROL),
									     altDown),
							     &lastKeyDownConsumed);
			if (!ret && !lastKeyDownConsumed) {
				return ::DefWindowProc(MainHWND(), iMessage, wParam, lParam);
			}
			break;
		}

	case WM_KEYUP:
		//Platform::DebugPrintf("S keyup %d %x %x\n",iMessage, wParam, lParam);
		return ::DefWindowProc(MainHWND(), iMessage, wParam, lParam);

	case WM_CHAR:
		HideCursorIfPreferred();
		if (const wchar_t charCode = static_cast<wchar_t>(wParam);
			IsVisualCharacter(charCode) || !lastKeyDownConsumed) {
			if (IS_HIGH_SURROGATE(charCode)) {
				// If this is a high surrogate character, we need a second one
				lastHighSurrogateChar = charCode;
			} else {
				std::wstring wcs({ charCode });
				if (IS_LOW_SURROGATE(charCode)) {
					wcs.insert(wcs.begin(), lastHighSurrogateChar);
				}
				AddWString(wcs, CharacterSource::DirectInput);
				lastHighSurrogateChar = 0;
			}
		}
		return 0;

	case WM_UNICHAR:
		if (wParam == UNICODE_NOCHAR) {
			return TRUE;
		} else if (lastKeyDownConsumed) {
			return 1;
		} else {
			wchar_t wcs[3] = { 0 };
			const size_t wclen = UTF16FromUTF32Character(static_cast<unsigned int>(wParam), wcs);
			AddWString(std::wstring_view(wcs, wclen), CharacterSource::DirectInput);
			return FALSE;
		}
	}

	return 0;
}

sptr_t ScintillaWin::FocusMessage(unsigned int iMessage, uptr_t wParam, sptr_t) {
	switch (iMessage) {
	case WM_KILLFOCUS: {
		HWND wOther = reinterpret_cast<HWND>(wParam);
		HWND wThis = MainHWND();
		const HWND wCT = HwndFromWindow(ct.wCallTip);
		if (!wParam ||
			!(::IsChild(wThis, wOther) || (wOther == wCT))) {
			SetFocusState(false);
			DestroySystemCaret();
		}
		// Explicitly complete any IME composition
		if (IMContext imc{ MainHWND() }) {
			imc.Notify(true);
		}
		break;
	}

	case WM_SETFOCUS:
		SetFocusState(true);
		DestroySystemCaret();
		CreateSystemCaret();
		break;
	}
	return 0;
}

sptr_t ScintillaWin::IMEMessage(unsigned int iMessage, uptr_t wParam, sptr_t lParam) {
	switch (iMessage) {

	case WM_INPUTLANGCHANGE:
		return ::DefWindowProc(MainHWND(), iMessage, wParam, lParam);

	case WM_INPUTLANGCHANGEREQUEST:
		return ::DefWindowProc(MainHWND(), iMessage, wParam, lParam);

	case WM_IME_KEYDOWN: {
			if (wParam == VK_HANJA) {
				// On US keyboards with Korean Microsoft IME, VK_HANJA is right Ctrl
				ToggleHanja();
			}
			return ::DefWindowProc(MainHWND(), iMessage, wParam, lParam);
		}

	case WM_IME_REQUEST: {
			if (wParam == IMR_RECONVERTSTRING) {
				return ImeOnReconvert(lParam);
			}
			if (wParam == IMR_DOCUMENTFEED) {
				return ImeOnDocumentFeed(lParam);
			}
			return ::DefWindowProc(MainHWND(), iMessage, wParam, lParam);
		}

	case WM_IME_STARTCOMPOSITION:
		if (KoreanIME() || imeInteraction == IMEInteraction::Inline) {
			return 0;
		} else {
			ImeStartComposition();
			return ::DefWindowProc(MainHWND(), iMessage, wParam, lParam);
		}

	case WM_IME_ENDCOMPOSITION:
		ImeEndComposition();
		return ::DefWindowProc(MainHWND(), iMessage, wParam, lParam);

	case WM_IME_COMPOSITION:
		if (KoreanIME() || imeInteraction == IMEInteraction::Inline) {
			return HandleCompositionInline(wParam, lParam);
		} else {
			return HandleCompositionWindowed(wParam, lParam);
		}

	case WM_IME_SETCONTEXT:
		if (KoreanIME() || imeInteraction == IMEInteraction::Inline) {
			if (wParam) {
				LPARAM NoImeWin = lParam;
				NoImeWin = NoImeWin & (~ISC_SHOWUICOMPOSITIONWINDOW);
				return ::DefWindowProc(MainHWND(), iMessage, wParam, NoImeWin);
			}
		}
		return ::DefWindowProc(MainHWND(), iMessage, wParam, lParam);

	case WM_IME_NOTIFY:
		return ::DefWindowProc(MainHWND(), iMessage, wParam, lParam);

	}
	return 0;
}

sptr_t ScintillaWin::EditMessage(unsigned int iMessage, uptr_t wParam, sptr_t lParam) {
	switch (iMessage) {

	case EM_LINEFROMCHAR:
		if (PositionFromUPtr(wParam) < 0) {
			wParam = SelectionStart().Position();
		}
		return pdoc->LineFromPosition(wParam);

	case EM_EXLINEFROMCHAR:
		return pdoc->LineFromPosition(lParam);

	case EM_GETSEL:
		if (wParam) {
			*static_cast<DWORD *>(PtrFromUPtr(wParam)) = static_cast<DWORD>(SelectionStart().Position());
		}
		if (lParam) {
			*static_cast<DWORD *>(PtrFromSPtr(lParam)) = static_cast<DWORD>(SelectionEnd().Position());
		}
		return MAKELRESULT(SelectionStart().Position(), SelectionEnd().Position());

	case EM_EXGETSEL: {
			if (lParam == 0) {
				return 0;
			}
			CHARRANGE *pCR = static_cast<CHARRANGE *>(PtrFromSPtr(lParam));
			pCR->cpMin = static_cast<LONG>(SelectionStart().Position());
			pCR->cpMax = static_cast<LONG>(SelectionEnd().Position());
		}
		break;

	case EM_SETSEL: {
			Sci::Position nStart = wParam;
			Sci::Position nEnd = lParam;
			if (nStart == 0 && nEnd == -1) {
				nEnd = pdoc->Length();
			}
			if (nStart == -1) {
				nStart = nEnd;	// Remove selection
			}
			SetSelection(nEnd, nStart);
			EnsureCaretVisible();
		}
		break;

	case EM_EXSETSEL: {
			if (lParam == 0) {
				return 0;
			}
			const CHARRANGE *pCR = static_cast<const CHARRANGE *>(PtrFromSPtr(lParam));
			sel.selType = Selection::SelTypes::stream;
			if (pCR->cpMin == 0 && pCR->cpMax == -1) {
				SetSelection(pCR->cpMin, pdoc->Length());
			} else {
				SetSelection(pCR->cpMin, pCR->cpMax);
			}
			EnsureCaretVisible();
			return pdoc->LineFromPosition(SelectionStart().Position());
		}
	}
	return 0;
}

sptr_t ScintillaWin::IdleMessage(unsigned int iMessage, uptr_t wParam, sptr_t lParam) {
	switch (iMessage) {
	case SC_WIN_IDLE:
		// wParam=dwTickCountInitial, or 0 to initialize.  lParam=bSkipUserInputTest
		if (idler.state) {
			if (lParam || (WAIT_TIMEOUT == MsgWaitForMultipleObjects(0, nullptr, 0, 0, QS_INPUT | QS_HOTKEY))) {
				if (Idle()) {
					// User input was given priority above, but all events do get a turn.  Other
					// messages, notifications, etc. will get interleaved with the idle messages.

					// However, some things like WM_PAINT are a lower priority, and will not fire
					// when there's a message posted.  So, several times a second, we stop and let
					// the low priority events have a turn (after which the timer will fire again).

					// Suppress a warning from Code Analysis that the GetTickCount function
					// wraps after 49 days. The WM_TIMER will kick off another SC_WIN_IDLE
					// after the wrap.
#ifdef _MSC_VER
#pragma warning(suppress: 28159)
#endif
					const DWORD dwCurrent = GetTickCount();
					const DWORD dwStart = wParam ? static_cast<DWORD>(wParam) : dwCurrent;
					constexpr DWORD maxWorkTime = 50;

					if (dwCurrent >= dwStart && dwCurrent > maxWorkTime &&dwCurrent - maxWorkTime < dwStart)
						PostMessage(MainHWND(), SC_WIN_IDLE, dwStart, 0);
				} else {
					SetIdle(false);
				}
			}
		}
		break;

	case SC_WORK_IDLE:
		IdleWork();
		break;
	}
	return 0;
}

sptr_t ScintillaWin::SciMessage(Message iMessage, uptr_t wParam, sptr_t lParam) {
	switch (iMessage) {
	case Message::GetDirectFunction:
		return reinterpret_cast<sptr_t>(DirectFunction);

	case Message::GetDirectStatusFunction:
		return reinterpret_cast<sptr_t>(DirectStatusFunction);

	case Message::GetDirectPointer:
		return reinterpret_cast<sptr_t>(this);

	case Message::GrabFocus:
		::SetFocus(MainHWND());
		break;

#ifdef INCLUDE_DEPRECATED_FEATURES
	case Message::SETKEYSUNICODE:
		break;

	case Message::GETKEYSUNICODE:
		return true;
#endif

	case Message::SetTechnology:
		if (const Technology technologyNew = static_cast<Technology>(wParam);
			(technologyNew == Technology::Default) ||
			(technologyNew == Technology::DirectWriteRetain) ||
			(technologyNew == Technology::DirectWriteDC) ||
			(technologyNew == Technology::DirectWrite) ||
			(technologyNew == Technology::DirectWrite1)) {
			if (technology != technologyNew) {
				if (technologyNew > Technology::Default) {
#if defined(USE_D2D)
					if (!LoadD2D()) {
						// Failed to load Direct2D or DirectWrite so no effect
						return 0;
					}
					UpdateRenderingParams(true);
#else
					return 0;
#endif
				} else {
					bidirectional = Bidirectional::Disabled;
				}
				DropRenderTarget();
				technology = technologyNew;
				view.bufferedDraw = technologyNew == Technology::Default;
				// Invalidate all cached information including layout.
				InvalidateStyleRedraw();
			}
		}
		break;

	case Message::SetBidirectional:
		if (technology == Technology::Default) {
			bidirectional = Bidirectional::Disabled;
		} else if (static_cast<Bidirectional>(wParam) <= Bidirectional::R2L) {
			bidirectional = static_cast<Bidirectional>(wParam);
		}
		// Invalidate all cached information including layout.
		InvalidateStyleRedraw();
		break;

	case Message::TargetAsUTF8:
		return TargetAsUTF8(CharPtrFromSPtr(lParam));

	case Message::EncodedFromUTF8:
		return EncodedFromUTF8(ConstCharPtrFromUPtr(wParam),
			CharPtrFromSPtr(lParam));

	default:
		break;

	}
	return 0;
}

sptr_t ScintillaWin::WndProc(Message iMessage, uptr_t wParam, sptr_t lParam) {
	try {
		//Platform::DebugPrintf("S M:%x WP:%x L:%x\n", iMessage, wParam, lParam);
		const unsigned int msg = static_cast<unsigned int>(iMessage);
		switch (msg) {

		case WM_CREATE:
			ctrlID = ::GetDlgCtrlID(HwndFromWindow(wMain));
			UpdateBaseElements();
			// Get Intellimouse scroll line parameters
			GetMouseParameters();
			::RegisterDragDrop(MainHWND(), &dt);
			break;

		case WM_COMMAND:
			Command(LOWORD(wParam));
			break;

		case WM_PAINT:
			return WndPaint();

		case WM_PRINTCLIENT: {
				HDC hdc = reinterpret_cast<HDC>(wParam);
				if (!IsCompatibleDC(hdc)) {
					return ::DefWindowProc(MainHWND(), msg, wParam, lParam);
				}
				FullPaintDC(hdc);
			}
			break;

		case WM_VSCROLL:
			ScrollMessage(wParam);
			break;

		case WM_HSCROLL:
			HorizontalScrollMessage(wParam);
			break;

		case WM_SIZE:
			SizeWindow();
			break;

		case WM_TIMER:
			if (wParam == idleTimerID && idler.state) {
				SendMessage(MainHWND(), SC_WIN_IDLE, 0, 1);
			} else {
				TickFor(static_cast<TickReason>(wParam - fineTimerStart));
			}
			break;

		case SC_WIN_IDLE:
		case SC_WORK_IDLE:
			return IdleMessage(msg, wParam, lParam);

		case WM_GETMINMAXINFO:
			return ::DefWindowProc(MainHWND(), msg, wParam, lParam);

		case WM_LBUTTONDOWN:
		case WM_LBUTTONUP:
		case WM_RBUTTONDOWN:
		case WM_MOUSEMOVE:
		case WM_MOUSELEAVE:
		case WM_MOUSEWHEEL:
		case WM_MOUSEHWHEEL:
			return MouseMessage(msg, wParam, lParam);

		case WM_SETCURSOR:
			if (LOWORD(lParam) == HTCLIENT) {
				if (!cursorIsHidden) {
					POINT pt;
					if (::GetCursorPos(&pt)) {
						::ScreenToClient(MainHWND(), &pt);
						DisplayCursor(ContextCursor(PointFromPOINT(pt)));
					}
				}
				return TRUE;
			} else {
				return ::DefWindowProc(MainHWND(), msg, wParam, lParam);
			}

		case WM_SYSKEYDOWN:
		case WM_KEYDOWN:
		case WM_KEYUP:
		case WM_CHAR:
		case WM_UNICHAR:
			return KeyMessage(msg, wParam, lParam);

		case WM_SETTINGCHANGE:
			//Platform::DebugPrintf("Setting Changed\n");
#if defined(USE_D2D)
			if (technology != Technology::Default) {
				UpdateRenderingParams(true);
			}
#endif
			UpdateBaseElements();
			// Get Intellimouse scroll line parameters
			GetMouseParameters();
			InvalidateStyleRedraw();
			break;

		case WM_GETDLGCODE:
			return DLGC_HASSETSEL | DLGC_WANTALLKEYS;

		case WM_KILLFOCUS:
		case WM_SETFOCUS:
			return FocusMessage(msg, wParam, lParam);

		case WM_SYSCOLORCHANGE:
			//Platform::DebugPrintf("Setting Changed\n");
			UpdateBaseElements();
			InvalidateStyleData();
			break;

			//Au: must use WM_DPICHANGED_BEFOREPARENT, like all controls. Parent on WM_DPICHANGED expects the control is updated.
#define WM_DPICHANGED_BEFOREPARENT       0x02E2
		case WM_DPICHANGED_BEFOREPARENT: //was WM_DPICHANGED
			dpi = HIWORD(wParam);
			reverseArrowCursor.Invalidate();
			InvalidateStyleRedraw();
			break;

		case WM_DPICHANGED_AFTERPARENT: {
				const UINT dpiNow = DpiForWindow(wMain.GetID());
				if (dpi != dpiNow) {
					dpi = dpiNow;
					reverseArrowCursor.Invalidate();
					InvalidateStyleRedraw();
				}
			}
			break;

		case WM_CONTEXTMENU:
			return ShowContextMenu(msg, wParam, lParam);

		case WM_ERASEBKGND:
			return 1;   // Avoid any background erasure as whole window painted.

		case WM_SETREDRAW:
			::DefWindowProc(MainHWND(), msg, wParam, lParam);
			if (wParam) {
				SetScrollBars();
				SetVerticalScrollPos();
				SetHorizontalScrollPos();
			}
			return 0;

		case WM_CAPTURECHANGED:
			capturedMouse = false;
			return 0;

		// These are not handled in Scintilla and its faster to dispatch them here.
		// Also moves time out to here so profile doesn't count lots of empty message calls.

		case WM_MOVE:
		case WM_MOUSEACTIVATE:
		case WM_NCHITTEST:
		case WM_NCCALCSIZE:
		case WM_NCPAINT:
		case WM_NCMOUSEMOVE:
		case WM_NCLBUTTONDOWN:
		case WM_SYSCOMMAND:
		case WM_WINDOWPOSCHANGING:
			return ::DefWindowProc(MainHWND(), msg, wParam, lParam);

		case WM_WINDOWPOSCHANGED:
#if defined(USE_D2D)
			if (technology != Technology::Default) {
				if (UpdateRenderingParams(false)) {
					DropGraphics();
					Redraw();
				}
			}
#endif
			return ::DefWindowProc(MainHWND(), msg, wParam, lParam);

		//Au: MSAA (or WPF?) uses wm_gettext for Name property
		//case WM_GETTEXTLENGTH:
		//	return GetTextLength();

		//case WM_GETTEXT:
		//	return GetText(wParam, lParam);

		case WM_INPUTLANGCHANGE:
		case WM_INPUTLANGCHANGEREQUEST:
		case WM_IME_KEYDOWN:
		case WM_IME_REQUEST:
		case WM_IME_STARTCOMPOSITION:
		case WM_IME_ENDCOMPOSITION:
		case WM_IME_COMPOSITION:
		case WM_IME_SETCONTEXT:
		case WM_IME_NOTIFY:
			return IMEMessage(msg, wParam, lParam);

		case EM_LINEFROMCHAR:
		case EM_EXLINEFROMCHAR:
		case EM_GETSEL:
		case EM_EXGETSEL:
		case EM_SETSEL:
		case EM_EXSETSEL:
			return EditMessage(msg, wParam, lParam);
		}

		iMessage = SciMessageFromEM(msg);
		switch (iMessage) {
		case Message::GetDirectFunction:
		case Message::GetDirectStatusFunction:
		case Message::GetDirectPointer:
		case Message::GrabFocus:
		case Message::SetTechnology:
		case Message::SetBidirectional:
		case Message::TargetAsUTF8:
		case Message::EncodedFromUTF8:
			return SciMessage(iMessage, wParam, lParam);

#pragma region //Au
			//can use callback function instead of WM_NOTIFY.
		case Message::SCI_SETNOTIFYCALLBACK:
			cbNotify = (Sci_NotifyCallback)lParam; cbNotifyParam = (void*)wParam;
			break;

			//to draw in annotation eg image instead of text.
		case Message::SCI_SETANNOTATIONDRAWCALLBACK:
			cbAnnotationDraw = (Sci_AnnotationDrawCallback)lParam; cbAnnotationDrawParam = (void*)wParam;
			break;

			//to draw in annotation eg image instead of text.
		case Message::SCI_SETMARGINDRAWCALLBACK:
			cbMarginDraw = (Sci_MarginDrawCallback)lParam;
			cbMarginsMask = (int)wParam;
			break;

		case Message::SCI_ISXINMARGIN:
			return PointInSelMargin(Point((XYPOSITION)(int)wParam, (XYPOSITION)(int)lParam));

		case Message::SCI_DRAGDROP:
			AuDragDrop((int)wParam, (Sci_DragDropData*)lParam);
			break;
#pragma endregion

		default:
			return ScintillaBase::WndProc(iMessage, wParam, lParam);
		}
	} catch (std::bad_alloc &) {
		errorStatus = Status::BadAlloc;
	} catch (...) {
		errorStatus = Status::Failure;
	}
	return 0;
}

bool ScintillaWin::ValidCodePage(int codePage) const {
	return codePage == 0 || codePage == CpUtf8 || IsDBCSCodePage(codePage);
}

std::string ScintillaWin::UTF8FromEncoded(std::string_view encoded) const {
	if (IsUnicodeMode()) {
		return std::string(encoded);
	}
	// Pivot through wide string
	std::wstring ws = StringDecode(encoded, CodePageOfDocument());
	return StringEncode(ws, CpUtf8);
}

std::string ScintillaWin::EncodedFromUTF8(std::string_view utf8) const {
	if (IsUnicodeMode()) {
		return std::string(utf8);
	}
	// Pivot through wide string
	std::wstring ws = StringDecode(utf8, CpUtf8);
	return StringEncode(ws, CodePageOfDocument());
}

sptr_t ScintillaWin::DefWndProc(Message iMessage, uptr_t wParam, sptr_t lParam) {
	return ::DefWindowProc(MainHWND(), static_cast<unsigned int>(iMessage), wParam, lParam);
}

bool ScintillaWin::FineTickerRunning(TickReason reason) {
	return timers[static_cast<size_t>(reason)] != 0;
}

void ScintillaWin::FineTickerStart(TickReason reason, int millis, int tolerance) {
	FineTickerCancel(reason);
	const UINT_PTR reasonIndex = static_cast<UINT_PTR>(reason);
	const UINT_PTR eventID = static_cast<UINT_PTR>(fineTimerStart) + reasonIndex;
	if (SetCoalescableTimerFn && tolerance) {
		timers[reasonIndex] = SetCoalescableTimerFn(MainHWND(), eventID, millis, nullptr, tolerance);
	} else {
		timers[reasonIndex] = ::SetTimer(MainHWND(), eventID, millis, nullptr);
	}
}

void ScintillaWin::FineTickerCancel(TickReason reason) {
	const UINT_PTR reasonIndex = static_cast<UINT_PTR>(reason);
	if (timers[reasonIndex]) {
		::KillTimer(MainHWND(), timers[reasonIndex]);
		timers[reasonIndex] = 0;
	}
}


bool ScintillaWin::SetIdle(bool on) {
	// On Win32 the Idler is implemented as a Timer on the Scintilla window.  This
	// takes advantage of the fact that WM_TIMER messages are very low priority,
	// and are only posted when the message queue is empty, i.e. during idle time.
	if (idler.state != on) {
		if (on) {
			constexpr UINT waitTimeMillis = 10;
			idler.idlerID = ::SetTimer(MainHWND(), idleTimerID, waitTimeMillis, nullptr)
				? reinterpret_cast<IdlerID>(idleTimerID) : nullptr;
		} else {
			::KillTimer(MainHWND(), reinterpret_cast<uptr_t>(idler.idlerID));
			idler.idlerID = nullptr;
		}
		idler.state = idler.idlerID != nullptr;
	}
	return idler.state;
}

void ScintillaWin::IdleWork() {
	styleIdleInQueue = false;
	Editor::IdleWork();
}

void ScintillaWin::QueueIdleWork(WorkItems items, Sci::Position upTo) {
	Editor::QueueIdleWork(items, upTo);
	if (!styleIdleInQueue) {
		if (PostMessage(MainHWND(), SC_WORK_IDLE, 0, 0)) {
			styleIdleInQueue = true;
		}
	}
}

void ScintillaWin::SetMouseCapture(bool on) {
	if (mouseDownCaptures) {
		if (on) {
			::SetCapture(MainHWND());
		} else {
			::ReleaseCapture();
		}
	}
	capturedMouse = on;
}

bool ScintillaWin::HaveMouseCapture() {
	// Cannot just see if GetCapture is this window as the scroll bar also sets capture for the window
	return capturedMouse;
	//return capturedMouse && (::GetCapture() == MainHWND());
}

void ScintillaWin::SetTrackMouseLeaveEvent(bool on) noexcept {
	if (on && !trackedMouseLeave) {
		TRACKMOUSEEVENT tme {};
		tme.cbSize = sizeof(tme);
		tme.dwFlags = TME_LEAVE;
		tme.hwndTrack = MainHWND();
		tme.dwHoverTime = HOVER_DEFAULT;	// Unused but triggers Dr. Memory if not initialized
		TrackMouseEvent(&tme);
	}
	trackedMouseLeave = on;
}

void ScintillaWin::HideCursorIfPreferred() noexcept {
	// SPI_GETMOUSEVANISH from OS.
	if (typingWithoutCursor && !cursorIsHidden) {
		::SetCursor({});
		cursorIsHidden = true;
	}
}

void ScintillaWin::UpdateBaseElements() {
	struct ElementToIndex { Element element; int nIndex; };
	const ElementToIndex eti[] = {
		{ Element::List, COLOR_WINDOWTEXT },
		{ Element::ListBack, COLOR_WINDOW },
		{ Element::ListSelected, COLOR_HIGHLIGHTTEXT },
		{ Element::ListSelectedBack, COLOR_HIGHLIGHT },
	};
	bool changed = false;
	for (const ElementToIndex &ei : eti) {
		changed = vs.SetElementBase(ei.element, ColourFromSys(ei.nIndex)) || changed;
	}
	if (changed) {
		Redraw();
	}
}

bool ScintillaWin::PaintContains(PRectangle rc) {
	if (paintState == PaintState::painting) {
		return BoundsContains(rcPaint, hRgnUpdate, rc);
	}
	return true;
}

void ScintillaWin::ScrollText(Sci::Line /* linesToMove */) {
	//Platform::DebugPrintf("ScintillaWin::ScrollText %d\n", linesToMove);
	//::ScrollWindow(MainHWND(), 0,
	//	vs.lineHeight * linesToMove, 0, 0);
	//::UpdateWindow(MainHWND());
	Redraw();
	UpdateSystemCaret();
}

void ScintillaWin::NotifyCaretMove() {
	NotifyWinEvent(EVENT_OBJECT_LOCATIONCHANGE, MainHWND(), OBJID_CARET, CHILDID_SELF);
}

void ScintillaWin::UpdateSystemCaret() {
	if (hasFocus) {
		if (pdoc->TentativeActive()) {
			// ongoing inline mode IME composition, don't inform IME of system caret position.
			// fix candidate window for Google Japanese IME moved on typing on Win7.
			return;
		}
		if (HasCaretSizeChanged()) {
			DestroySystemCaret();
			CreateSystemCaret();
		}
		const Point pos = PointMainCaret();
		::SetCaretPos(static_cast<int>(pos.x), static_cast<int>(pos.y));
	}
}

bool ScintillaWin::IsVisible() const noexcept {
	return GetWindowStyle(MainHWND()) & WS_VISIBLE;
}

int ScintillaWin::SetScrollInfo(int nBar, LPCSCROLLINFO lpsi, BOOL bRedraw) noexcept {
	return ::SetScrollInfo(MainHWND(), nBar, lpsi, bRedraw);
}

bool ScintillaWin::GetScrollInfo(int nBar, LPSCROLLINFO lpsi) noexcept {
	return ::GetScrollInfo(MainHWND(), nBar, lpsi);
}

// Change the scroll position but avoid repaint if changing to same value
void ScintillaWin::ChangeScrollPos(int barType, Sci::Position pos) {
	if (!IsVisible()) {
		return;
	}

	SCROLLINFO sci = {
		sizeof(sci), 0, 0, 0, 0, 0, 0
	};
	sci.fMask = SIF_POS;
	GetScrollInfo(barType, &sci);
	if (sci.nPos != pos) {
		DwellEnd(true);
		sci.nPos = static_cast<int>(pos);
		SetScrollInfo(barType, &sci, TRUE);
	}
}

void ScintillaWin::SetVerticalScrollPos() {
	Editor::SetVerticalScrollPos();
	ChangeScrollPos(SB_VERT, topLine);
}

void ScintillaWin::SetHorizontalScrollPos() {
	ChangeScrollPos(SB_HORZ, xOffset);
}

bool ScintillaWin::ChangeScrollRange(int nBar, int nMin, int nMax, UINT nPage) noexcept {
	SCROLLINFO sci = { sizeof(sci), SIF_PAGE | SIF_RANGE, 0, 0, 0, 0, 0 };
	GetScrollInfo(nBar, &sci);
	if ((sci.nMin != nMin) || (sci.nMax != nMax) ||	(sci.nPage != nPage)) {
		sci.nMin = nMin;
		sci.nMax = nMax;
		sci.nPage = nPage;
		SetScrollInfo(nBar, &sci, TRUE);
		return true;
	}
	return false;
}

void ScintillaWin::HorizontalScrollToClamped(int xPos) {
	const HorizontalScrollRange range = GetHorizontalScrollRange();
	HorizontalScrollTo(std::clamp(xPos, 0, range.documentWidth - range.pageWidth + 1));
}

HorizontalScrollRange ScintillaWin::GetHorizontalScrollRange() const {
	const PRectangle rcText = GetTextRectangle();
	int pageWidth = static_cast<int>(rcText.Width());
	const int horizEndPreferred = std::max({ scrollWidth, pageWidth - 1, 0 });
	if (!horizontalScrollBarVisible || Wrapping())
		pageWidth = horizEndPreferred + 1;
	return { pageWidth, horizEndPreferred };
}

bool ScintillaWin::ModifyScrollBars(Sci::Line nMax, Sci::Line nPage) {
	if (!IsVisible()) {
		return false;
	}

	bool modified = false;
	const Sci::Line vertEndPreferred = nMax;
	if (!verticalScrollBarVisible)
		nPage = vertEndPreferred + 1;
	if (ChangeScrollRange(SB_VERT, 0, static_cast<int>(vertEndPreferred), static_cast<unsigned int>(nPage))) {
		modified = true;
	}
	const HorizontalScrollRange range = GetHorizontalScrollRange();
	if (ChangeScrollRange(SB_HORZ, 0, range.documentWidth, range.pageWidth)) {
		modified = true;
		if (scrollWidth < range.pageWidth) {
			HorizontalScrollTo(0);
		}
	}

	return modified;
}

void ScintillaWin::NotifyChange() {
	//Au: don't need it. Also, WinForms would reflect it.
	//::SendMessage(::GetParent(MainHWND()), WM_COMMAND,
	//        MAKEWPARAM(GetCtrlID(), FocusChange::Change),
	//	reinterpret_cast<LPARAM>(MainHWND()));
}

void ScintillaWin::NotifyFocus(bool focus) {
	//Au: don't need it. Also, WinForms would reflect it.
	//if (commandEvents) {
	//	::SendMessage(::GetParent(MainHWND()), WM_COMMAND,
	//		MAKEWPARAM(GetCtrlID(), focus ? FocusChange::Setfocus : FocusChange::Killfocus),
	//		reinterpret_cast<LPARAM>(MainHWND()));
	//}
	Editor::NotifyFocus(focus);
}

void ScintillaWin::SetCtrlID(int identifier) {
	::SetWindowID(HwndFromWindow(wMain), identifier);
}

int ScintillaWin::GetCtrlID() {
	return ::GetDlgCtrlID(HwndFromWindow(wMain));
}

void ScintillaWin::NotifyParent(NotificationData scn) {
	scn.nmhdr.hwndFrom = MainHWND();
	scn.nmhdr.idFrom = GetCtrlID();
	if(cbNotify) (cbNotify)(cbNotifyParam, scn); else //Au: can use callback function instead of WM_NOTIFY.
	::SendMessage(::GetParent(MainHWND()), WM_NOTIFY,
	              GetCtrlID(), reinterpret_cast<LPARAM>(&scn));
}

void ScintillaWin::NotifyDoubleClick(Point pt, KeyMod modifiers) {
	//Platform::DebugPrintf("ScintillaWin Double click 0\n");
	ScintillaBase::NotifyDoubleClick(pt, modifiers);
	// Send myself a WM_LBUTTONDBLCLK, so the container can handle it too.
	const POINT point = POINTFromPoint(pt);
	::SendMessage(MainHWND(),
			  WM_LBUTTONDBLCLK,
			  FlagSet(modifiers, KeyMod::Shift) ? MK_SHIFT : 0,
			  MAKELPARAM(point.x, point.y));
}

namespace {

constexpr unsigned int safeFoldingSize = 20;
constexpr int highByteFirst = 0x80;
constexpr int highByteLast = 0xFF;
constexpr int minTrailByte = 0x30;

// CreateFoldMap creates a fold map by calling platform APIs so will differ between platforms.
void CreateFoldMap(int codePage, FoldMap *foldingMap) {
	for (unsigned char byte1 = highByteLast; byte1 >= highByteFirst; byte1--) {
		const char ch1 = byte1;
		if (DBCSIsLeadByte(codePage, ch1)) {
			for (unsigned char byte2 = highByteLast; byte2 >= minTrailByte; byte2--) {
				const char ch2 = byte2;
				if (DBCSIsTrailByte(codePage, ch2)) {
					const DBCSPair pair{ ch1, ch2 };
					const uint16_t index = DBCSIndex(ch1, ch2);
					(*foldingMap)[index] = pair;
					const std::string_view svBytes(pair.chars, 2);
					const int lenUni = WideCharLenFromMultiByte(codePage, svBytes);
					if (lenUni == 1) {
						// DBCS pair must produce a single Unicode BMP code point
						wchar_t codePoint = 0;
						WideCharFromMultiByte(codePage, svBytes, &codePoint, 1);
						if (codePoint) {
							// Could create a DBCS -> Unicode conversion map here
							const char *foldedUTF8 = CaseConvert(codePoint, CaseConversion::fold);
							if (foldedUTF8) {
								wchar_t wFolded[safeFoldingSize]{};
								const size_t charsConverted = UTF16FromUTF8(foldedUTF8, wFolded, std::size(wFolded));
								char back[safeFoldingSize]{};
								const int lengthBack = MultiByteFromWideChar(codePage, std::wstring(wFolded, charsConverted),
									back, std::size(back));
								if (lengthBack == 2) {
									// Only allow cases where input length and folded length are both 2
									(*foldingMap)[index] = { back[0], back[1] };
								}
							}
						}
					}
				}
			}
		}
	}
}

class CaseFolderDBCS : public CaseFolderTable {
	// Allocate the expandable storage here so that it does not need to be reallocated
	// for each call to Fold.
	const FoldMap *foldingMap;
	UINT cp;
public:
	explicit CaseFolderDBCS(UINT cp_) : cp(cp_) {
		if (!DBCSHasFoldMap(cp)) {
			CreateFoldMap(cp, DBCSGetMutableFoldMap(cp));
		}
		foldingMap = DBCSGetFoldMap(cp);
	}
	size_t Fold(char *folded, size_t sizeFolded, const char *mixed, size_t lenMixed) override;
};

size_t CaseFolderDBCS::Fold(char *folded, size_t sizeFolded, const char *mixed, size_t lenMixed) {
	// This loop outputs the same length as input as for each char 1-byte -> 1-byte; 2-byte -> 2-byte
	size_t lenOut = 0;
	for (size_t i = 0; i < lenMixed; i++) {
		const ptrdiff_t lenLeft = lenMixed - i;
		const char ch = mixed[i];
		if ((lenLeft >= 2) && DBCSIsLeadByte(cp, ch) && ((lenOut + 2) <= sizeFolded)) {
			i++;
			const char ch2 = mixed[i];
			const uint16_t ind = DBCSIndex(ch, ch2);
			const char *pair = foldingMap->at(ind).chars;
			folded[lenOut++] = pair[0];
			folded[lenOut++] = pair[1];
		} else if ((lenOut + 1) <= sizeFolded) {
			const unsigned char uch = ch;
			folded[lenOut++] = mapping[uch];
		}
	}
	return lenOut;
}

}

std::unique_ptr<CaseFolder> ScintillaWin::CaseFolderForEncoding() {
	const UINT cpDest = CodePageOfDocument();
	if (cpDest == CpUtf8) {
		return std::make_unique<CaseFolderUnicode>();
	}
	if (pdoc->dbcsCodePage) {
		return std::make_unique<CaseFolderDBCS>(cpDest);
	}
	std::unique_ptr<CaseFolderTable> pcf = std::make_unique<CaseFolderTable>();
	// Only for single byte encodings
	for (int i=highByteFirst; i<=highByteLast; i++) {
		char sCharacter[2] = "A";
		sCharacter[0] = static_cast<char>(i);
		wchar_t wCharacter[safeFoldingSize];
		const unsigned int lengthUTF16 = WideCharFromMultiByte(cpDest, sCharacter,
			wCharacter, std::size(wCharacter));
		if (lengthUTF16 == 1) {
			const char *caseFolded = CaseConvert(wCharacter[0], CaseConversion::fold);
			if (caseFolded) {
				wchar_t wLower[safeFoldingSize];
				const size_t charsConverted = UTF16FromUTF8(std::string_view(caseFolded),
					wLower, std::size(wLower));
				if (charsConverted == 1) {
					char sCharacterLowered[safeFoldingSize];
					const unsigned int lengthConverted = MultiByteFromWideChar(cpDest,
						std::wstring_view(wLower, charsConverted),
						sCharacterLowered, std::size(sCharacterLowered));
					if ((lengthConverted == 1) && (sCharacter[0] != sCharacterLowered[0])) {
						pcf->SetTranslation(sCharacter[0], sCharacterLowered[0]);
					}
				}
			}
		}
	}
	return pcf;
}

std::string ScintillaWin::CaseMapString(const std::string &s, CaseMapping caseMapping) {
	if (s.empty() || (caseMapping == CaseMapping::same))
		return s;

	const UINT cpDoc = CodePageOfDocument();
	if (cpDoc == CpUtf8) {
		return CaseConvertString(s, (caseMapping == CaseMapping::upper) ? CaseConversion::upper : CaseConversion::lower);
	}

	// Change text to UTF-16
	const std::wstring wsText = StringDecode(s, cpDoc);

	const DWORD mapFlags = LCMAP_LINGUISTIC_CASING |
		((caseMapping == CaseMapping::upper) ? LCMAP_UPPERCASE : LCMAP_LOWERCASE);

	// Change case
	const std::wstring wsConverted = StringMapCase(wsText, mapFlags);

	// Change back to document encoding
	std::string sConverted = StringEncode(wsConverted, cpDoc);

	return sConverted;
}

void ScintillaWin::Copy() {
	//Platform::DebugPrintf("Copy\n");
	if (!sel.Empty()) {
		SelectionText selectedText;
		CopySelectionRange(&selectedText);
		CopyToClipboard(selectedText);
	}
}

bool ScintillaWin::CanPaste() {
	if (!Editor::CanPaste())
		return false;
	return ::IsClipboardFormatAvailable(CF_UNICODETEXT) != FALSE;
}

namespace {

class GlobalMemory {
	HGLOBAL hand {};
public:
	void *ptr {};
	GlobalMemory() noexcept = default;
	explicit GlobalMemory(HGLOBAL hand_) noexcept : hand(hand_) {
		if (hand) {
			ptr = ::GlobalLock(hand);
		}
	}
	// Deleted so GlobalMemory objects can not be copied.
	GlobalMemory(const GlobalMemory &) = delete;
	GlobalMemory(GlobalMemory &&) = delete;
	GlobalMemory &operator=(const GlobalMemory &) = delete;
	GlobalMemory &operator=(GlobalMemory &&) = delete;
	~GlobalMemory() {
		assert(!ptr);
		assert(!hand);
	}
	void Allocate(size_t bytes) noexcept {
		assert(!hand);
		hand = ::GlobalAlloc(GMEM_MOVEABLE | GMEM_ZEROINIT, bytes);
		if (hand) {
			ptr = ::GlobalLock(hand);
		}
	}
	HGLOBAL Unlock() noexcept {
		assert(ptr);
		HGLOBAL handCopy = hand;
		::GlobalUnlock(hand);
		ptr = nullptr;
		hand = {};
		return handCopy;
	}
	void SetClip(UINT uFormat) noexcept {
		::SetClipboardData(uFormat, Unlock());
	}
	explicit operator bool() const noexcept {
		return ptr != nullptr;
	}
	[[nodiscard]] SIZE_T Size() const noexcept {
		return ::GlobalSize(hand);
	}
};

// OpenClipboard may fail if another application has opened the clipboard.
// Try up to 8 times, with an initial delay of 1 ms and an exponential back off
// for a maximum total delay of 127 ms (1+2+4+8+16+32+64).
bool OpenClipboardRetry(HWND hwnd) noexcept {
	constexpr int attempts = 8;
	for (int attempt=0; attempt<attempts; attempt++) {
		if (attempt > 0) {
			::Sleep(1 << (attempt-1));
		}
		if (::OpenClipboard(hwnd)) {
			return true;
		}
	}
	return false;
}

// Ensure every successful OpenClipboard is followed by a CloseClipboard.
class Clipboard {
	bool opened = false;
public:
	explicit Clipboard(HWND hwnd) noexcept : opened(::OpenClipboardRetry(hwnd)) {
	}
	// Deleted so Clipboard objects can not be copied.
	Clipboard(const Clipboard &) = delete;
	Clipboard(Clipboard &&) = delete;
	Clipboard &operator=(const Clipboard &) = delete;
	Clipboard &operator=(Clipboard &&) = delete;
	~Clipboard() noexcept {
		if (opened) {
			::CloseClipboard();
		}
	}
	explicit constexpr operator bool() const noexcept {
		return opened;
	}
};

bool IsValidFormatEtc(const FORMATETC *pFE) noexcept {
	return pFE->ptd == nullptr &&
		(pFE->dwAspect & DVASPECT_CONTENT) != 0 &&
		pFE->lindex == -1 &&
		(pFE->tymed & TYMED_HGLOBAL) != 0;
}

bool SupportedFormat(const FORMATETC *pFE) noexcept {
	return pFE->cfFormat == CF_UNICODETEXT &&
		IsValidFormatEtc(pFE);
}

}

void ScintillaWin::Paste() {
	Clipboard clipboard(MainHWND());
	if (!clipboard) {
		return;
	}
	UndoGroup ug(pdoc);
	const bool isLine = SelectionEmpty() &&
		(::IsClipboardFormatAvailable(cfLineSelect) || ::IsClipboardFormatAvailable(cfVSLineTag));
	ClearSelection(multiPasteMode == MultiPaste::Each);
	bool isRectangular = (::IsClipboardFormatAvailable(cfColumnSelect) != 0);

	if (!isRectangular) {
		// Evaluate "Borland IDE Block Type" explicitly
		GlobalMemory memBorlandSelection(::GetClipboardData(cfBorlandIDEBlockType));
		if (memBorlandSelection) {
			isRectangular = (memBorlandSelection.Size() == 1) && (static_cast<BYTE *>(memBorlandSelection.ptr)[0] == 0x02);
			memBorlandSelection.Unlock();
		}
	}
	const PasteShape pasteShape = isRectangular ? PasteShape::rectangular : (isLine ? PasteShape::line : PasteShape::stream);

	// Use CF_UNICODETEXT if available
	GlobalMemory memUSelection(::GetClipboardData(CF_UNICODETEXT));
	if (const wchar_t *uptr = static_cast<const wchar_t *>(memUSelection.ptr)) {
		const std::string putf = EncodeWString(uptr);
		InsertPasteShape(putf.c_str(), putf.length(), pasteShape);
		memUSelection.Unlock();
	}
	Redraw();
}

void ScintillaWin::CreateCallTipWindow(PRectangle) {
	if (!ct.wCallTip.Created()) {
		HWND wnd = ::CreateWindow(callClassName, TEXT("ACallTip"),
					     WS_POPUP, 100, 100, 150, 20,
					     MainHWND(), {},
					     GetWindowInstance(MainHWND()),
					     this);
		ct.wCallTip = wnd;
		ct.wDraw = wnd;
	}
}

void ScintillaWin::AddToPopUp(const char *label, int cmd, bool enabled) {
	HMENU hmenuPopup = static_cast<HMENU>(popup.GetID());
	if (!label[0])
		::AppendMenuA(hmenuPopup, MF_SEPARATOR, 0, "");
	else if (enabled)
		::AppendMenuA(hmenuPopup, MF_STRING, cmd, label);
	else
		::AppendMenuA(hmenuPopup, MF_STRING | MF_DISABLED | MF_GRAYED, cmd, label);
}

void ScintillaWin::ClaimSelection() {
	// Windows does not have a primary selection
}

/// Implement IUnknown
STDMETHODIMP FormatEnumerator::QueryInterface(REFIID riid, PVOID *ppv) {
	//Platform::DebugPrintf("EFE QI");
	*ppv = nullptr;
	if (riid == IID_IUnknown || riid == IID_IEnumFORMATETC) {
		*ppv = this;
	} else {
		return E_NOINTERFACE;
	}
	AddRef();
	return S_OK;
}
STDMETHODIMP_(ULONG)FormatEnumerator::AddRef() {
	return ++ref;
}
STDMETHODIMP_(ULONG)FormatEnumerator::Release() {
	const ULONG refs = --ref;
	if (refs == 0) {
		delete this;
	}
	return refs;
}
/// Implement IEnumFORMATETC
STDMETHODIMP FormatEnumerator::Next(ULONG celt, FORMATETC *rgelt, ULONG *pceltFetched) {
	if (!rgelt) return E_POINTER;
	ULONG putPos = 0;
	while ((pos < formats.size()) && (putPos < celt)) {
		rgelt->cfFormat = formats[pos];
		rgelt->ptd = nullptr;
		rgelt->dwAspect = DVASPECT_CONTENT;
		rgelt->lindex = -1;
		rgelt->tymed = TYMED_HGLOBAL;
		rgelt++;
		pos++;
		putPos++;
	}
	if (pceltFetched)
		*pceltFetched = putPos;
	return putPos ? S_OK : S_FALSE;
}
STDMETHODIMP FormatEnumerator::Skip(ULONG celt) {
	pos += celt;
	return S_OK;
}
STDMETHODIMP FormatEnumerator::Reset() {
	pos = 0;
	return S_OK;
}
STDMETHODIMP FormatEnumerator::Clone(IEnumFORMATETC **ppenum) {
	FormatEnumerator *pfe;
	try {
		pfe = new FormatEnumerator(pos, formats.data(), formats.size());
	} catch (...) {
		return E_OUTOFMEMORY;
	}
	return pfe->QueryInterface(IID_IEnumFORMATETC, reinterpret_cast<void **>(ppenum));
}

FormatEnumerator::FormatEnumerator(ULONG pos_, const CLIPFORMAT formats_[], size_t formatsLen_) {
	ref = 0;   // First QI adds first reference...
	pos = pos_;
	formats.insert(formats.begin(), formats_, formats_+formatsLen_);
}

/// Implement IUnknown
STDMETHODIMP DropSource::QueryInterface(REFIID riid, PVOID *ppv) {
	return sci->QueryInterface(riid, ppv);
}
STDMETHODIMP_(ULONG)DropSource::AddRef() {
	return sci->AddRef();
}
STDMETHODIMP_(ULONG)DropSource::Release() {
	return sci->Release();
}

/// Implement IDropSource
STDMETHODIMP DropSource::QueryContinueDrag(BOOL fEsc, DWORD grfKeyState) {
	if (fEsc)
		return DRAGDROP_S_CANCEL;
	if (!(grfKeyState & MK_LBUTTON))
		return DRAGDROP_S_DROP;
	return S_OK;
}

STDMETHODIMP DropSource::GiveFeedback(DWORD) {
	return DRAGDROP_S_USEDEFAULTCURSORS;
}

/// Implement IUnkown
STDMETHODIMP DataObject::QueryInterface(REFIID riid, PVOID *ppv) {
	//Platform::DebugPrintf("DO QI %p\n", this);
	return sci->QueryInterface(riid, ppv);
}
STDMETHODIMP_(ULONG)DataObject::AddRef() {
	return sci->AddRef();
}
STDMETHODIMP_(ULONG)DataObject::Release() {
	return sci->Release();
}
/// Implement IDataObject
STDMETHODIMP DataObject::GetData(FORMATETC *pFEIn, STGMEDIUM *pSTM) {
	return sci->GetData(pFEIn, pSTM);
}

STDMETHODIMP DataObject::GetDataHere(FORMATETC *, STGMEDIUM *) {
	//Platform::DebugPrintf("DOB GetDataHere\n");
	return E_NOTIMPL;
}

STDMETHODIMP DataObject::QueryGetData(FORMATETC *pFE) {
	if (sci->DragIsRectangularOK(pFE->cfFormat) && IsValidFormatEtc(pFE)) {
		return S_OK;
	}

	return SupportedFormat(pFE) ? S_OK : S_FALSE;
}

STDMETHODIMP DataObject::GetCanonicalFormatEtc(FORMATETC *, FORMATETC *pFEOut) {
	//Platform::DebugPrintf("DOB GetCanon\n");
	pFEOut->cfFormat = CF_UNICODETEXT;
	pFEOut->ptd = nullptr;
	pFEOut->dwAspect = DVASPECT_CONTENT;
	pFEOut->lindex = -1;
	pFEOut->tymed = TYMED_HGLOBAL;
	return S_OK;
}

STDMETHODIMP DataObject::SetData(FORMATETC *, STGMEDIUM *, BOOL) {
	//Platform::DebugPrintf("DOB SetData\n");
	return E_FAIL;
}

STDMETHODIMP DataObject::EnumFormatEtc(DWORD dwDirection, IEnumFORMATETC **ppEnum) {
	try {
		//Platform::DebugPrintf("DOB EnumFormatEtc %d\n", dwDirection);
		if (dwDirection != DATADIR_GET) {
			*ppEnum = nullptr;
			return E_FAIL;
		}

		const CLIPFORMAT formats[] = {CF_UNICODETEXT};
		FormatEnumerator *pfe = new FormatEnumerator(0, formats, std::size(formats));
		return pfe->QueryInterface(IID_IEnumFORMATETC, reinterpret_cast<void **>(ppEnum));
	} catch (std::bad_alloc &) {
		sci->errorStatus = Status::BadAlloc;
		return E_OUTOFMEMORY;
	} catch (...) {
		sci->errorStatus = Status::Failure;
		return E_FAIL;
	}
}

STDMETHODIMP DataObject::DAdvise(FORMATETC *, DWORD, IAdviseSink *, PDWORD) {
	//Platform::DebugPrintf("DOB DAdvise\n");
	return E_FAIL;
}

STDMETHODIMP DataObject::DUnadvise(DWORD) {
	//Platform::DebugPrintf("DOB DUnadvise\n");
	return E_FAIL;
}

STDMETHODIMP DataObject::EnumDAdvise(IEnumSTATDATA **) {
	//Platform::DebugPrintf("DOB EnumDAdvise\n");
	return E_FAIL;
}

/// Implement IUnknown
STDMETHODIMP DropTarget::QueryInterface(REFIID riid, PVOID *ppv) {
	//Platform::DebugPrintf("DT QI %p\n", this);
	return sci->QueryInterface(riid, ppv);
}
STDMETHODIMP_(ULONG)DropTarget::AddRef() {
	return sci->AddRef();
}
STDMETHODIMP_(ULONG)DropTarget::Release() {
	return sci->Release();
}

/// Implement IDropTarget by forwarding to Scintilla
STDMETHODIMP DropTarget::DragEnter(LPDATAOBJECT pIDataSource, DWORD grfKeyState, POINTL pt, PDWORD pdwEffect) {
	try {
		return sci->DragEnter(pIDataSource, grfKeyState, pt, pdwEffect);
	} catch (...) {
		sci->errorStatus = Status::Failure;
	}
	return E_FAIL;
}
STDMETHODIMP DropTarget::DragOver(DWORD grfKeyState, POINTL pt, PDWORD pdwEffect) {
	try {
		return sci->DragOver(grfKeyState, pt, pdwEffect);
	} catch (...) {
		sci->errorStatus = Status::Failure;
	}
	return E_FAIL;
}
STDMETHODIMP DropTarget::DragLeave() {
	try {
		return sci->DragLeave();
	} catch (...) {
		sci->errorStatus = Status::Failure;
	}
	return E_FAIL;
}
STDMETHODIMP DropTarget::Drop(LPDATAOBJECT pIDataSource, DWORD grfKeyState, POINTL pt, PDWORD pdwEffect) {
	try {
		return sci->Drop(pIDataSource, grfKeyState, pt, pdwEffect);
	} catch (...) {
		sci->errorStatus = Status::Failure;
	}
	return E_FAIL;
}

/**
 * DBCS: support Input Method Editor (IME).
 * Called when IME Window opened.
 */
void ScintillaWin::ImeStartComposition() {
	if (caret.active) {
		// Move IME Window to current caret position
		IMContext imc(MainHWND());
		if (!imc)
			return;

		imc.SetCompositionWindow(PointMainCaret());

		// Set font of IME window to same as surrounded text.
		if (stylesValid) {
			// Since the style creation code has been made platform independent,
			// The logfont for the IME is recreated here.
			imc.SetCompositionFont(vs, pdoc->StyleIndexAt(sel.MainCaret()), dpi);
		}
		// Caret is displayed in IME window. So, caret in Scintilla is useless.
		DropCaret();
	}
}

/** Called when IME Window closed. */
void ScintillaWin::ImeEndComposition() {
	// clear IME composition state.
	view.imeCaretBlockOverride = false;
	pdoc->TentativeUndo();
	ShowCaretAtCurrentPosition();
}

LRESULT ScintillaWin::ImeOnReconvert(LPARAM lParam) {
	// Reconversion on windows limits within one line without eol.
	// Look around:   baseStart  <--  (|mainStart|  -- mainEnd)  --> baseEnd.
	const Sci::Position mainStart = sel.RangeMain().Start().Position();
	const Sci::Position mainEnd = sel.RangeMain().End().Position();
	const Sci::Line curLine = pdoc->SciLineFromPosition(mainStart);
	if (curLine != pdoc->LineFromPosition(mainEnd))
		return 0;
	const Sci::Position baseStart = pdoc->LineStart(curLine);
	const Sci::Position baseEnd = pdoc->LineEnd(curLine);
	if ((baseStart == baseEnd) || (mainEnd > baseEnd))
		return 0;

	const int codePage = CodePageOfDocument();
	const std::wstring rcFeed = StringDecode(RangeText(baseStart, baseEnd), codePage);
	const int rcFeedLen = static_cast<int>(rcFeed.length()) * sizeof(wchar_t);
	const int rcSize = sizeof(RECONVERTSTRING) + rcFeedLen + sizeof(wchar_t);

	RECONVERTSTRING *rc = static_cast<RECONVERTSTRING *>(PtrFromSPtr(lParam));
	if (!rc)
		return rcSize; // Immediately be back with rcSize of memory block.

	wchar_t *rcFeedStart = reinterpret_cast<wchar_t*>(rc + 1);
	memcpy(rcFeedStart, rcFeed.data(), rcFeedLen);

	std::string rcCompString = RangeText(mainStart, mainEnd);
	std::wstring rcCompWstring = StringDecode(rcCompString, codePage);
	std::string rcCompStart = RangeText(baseStart, mainStart);
	std::wstring rcCompWstart = StringDecode(rcCompStart, codePage);

	// Map selection to dwCompStr.
	// No selection assumes current caret as rcCompString without length.
	rc->dwVersion = 0; // It should be absolutely 0.
	rc->dwStrLen = static_cast<DWORD>(rcFeed.length());
	rc->dwStrOffset = sizeof(RECONVERTSTRING);
	rc->dwCompStrLen = static_cast<DWORD>(rcCompWstring.length());
	rc->dwCompStrOffset = static_cast<DWORD>(rcCompWstart.length()) * sizeof(wchar_t);
	rc->dwTargetStrLen = rc->dwCompStrLen;
	rc->dwTargetStrOffset =rc->dwCompStrOffset;

	IMContext imc(MainHWND());
	if (!imc)
		return 0;

	if (!imc.SetCompositionString(SCS_QUERYRECONVERTSTRING, rc, rcSize))
		return 0;

	// No selection asks IME to fill target fields with its own value.
	const size_t tgWlen = rc->dwTargetStrLen;
	const size_t tgWstart = rc->dwTargetStrOffset / sizeof(wchar_t);

	std::string tgCompStart = StringEncode(rcFeed.substr(0, tgWstart), codePage);
	std::string tgComp = StringEncode(rcFeed.substr(tgWstart, tgWlen), codePage);

	// No selection needs to adjust reconvert start position for IME set.
	const int adjust = static_cast<int>(tgCompStart.length() - rcCompStart.length());
	const int docCompLen = static_cast<int>(tgComp.length());

	// Make place for next composition string to sit in.
	for (size_t r=0; r<sel.Count(); r++) {
		const Sci::Position rBase = sel.Range(r).Start().Position();
		const Sci::Position docCompStart = rBase + adjust;

		if (inOverstrike) { // the docCompLen of bytes will be overstriked.
			sel.Range(r) = SelectionRange(docCompStart);
		} else {
			// Ensure docCompStart+docCompLen be not beyond lineEnd.
			// since docCompLen by byte might break eol.
			const Sci::Position lineEnd = pdoc->LineEndPosition(rBase);
			const Sci::Position overflow = (docCompStart + docCompLen) - lineEnd;
			if (overflow > 0) {
				pdoc->DeleteChars(docCompStart, docCompLen - overflow);
			} else {
				pdoc->DeleteChars(docCompStart, docCompLen);
			}
		}
	}
	// Immediately Target Input or candidate box choice with GCS_COMPSTR.
	return rcSize;
}

LRESULT ScintillaWin::ImeOnDocumentFeed(LPARAM lParam) const {
	// This is called while typing preedit string in.
	// So there is no selection.
	// Limit feed within one line without EOL.
	// Look around:   lineStart |<--  |compStart| - caret - compEnd|  -->| lineEnd.

	const Sci::Position curPos = CurrentPosition();
	const Sci::Line curLine = pdoc->SciLineFromPosition(curPos);
	const Sci::Position lineStart = pdoc->LineStart(curLine);
	const Sci::Position lineEnd = pdoc->LineEnd(curLine);

	const std::wstring rcFeed = StringDecode(RangeText(lineStart, lineEnd), CodePageOfDocument());
	const int rcFeedLen = static_cast<int>(rcFeed.length()) * sizeof(wchar_t);
	const int rcSize = sizeof(RECONVERTSTRING) + rcFeedLen + sizeof(wchar_t);

	RECONVERTSTRING *rc = static_cast<RECONVERTSTRING *>(PtrFromSPtr(lParam));
	if (!rc)
		return rcSize;

	wchar_t *rcFeedStart = reinterpret_cast<wchar_t*>(rc + 1);
	memcpy(rcFeedStart, rcFeed.data(), rcFeedLen);

	IMContext imc(MainHWND());
	if (!imc)
		return 0;

	DWORD compStrLen = 0;
	Sci::Position compStart = curPos;
	if (pdoc->TentativeActive()) {
		// rcFeed contains current composition string
		compStrLen = imc.GetCompositionStringLength(GCS_COMPSTR);
		const int imeCaretPos = imc.GetImeCaretPos();
		compStart = pdoc->GetRelativePositionUTF16(curPos, -imeCaretPos);
	}
	const Sci::Position compStrOffset = pdoc->CountUTF16(lineStart, compStart);

	// Fill in reconvert structure.
	// Let IME to decide what the target is.
	rc->dwVersion = 0; //constant
	rc->dwStrLen = static_cast<DWORD>(rcFeed.length());
	rc->dwStrOffset = sizeof(RECONVERTSTRING); //constant
	rc->dwCompStrLen = compStrLen;
	rc->dwCompStrOffset = static_cast<DWORD>(compStrOffset) * sizeof(wchar_t);
	rc->dwTargetStrLen = rc->dwCompStrLen;
	rc->dwTargetStrOffset = rc->dwCompStrOffset;

	return rcSize; // MS API says reconv structure to be returned.
}

void ScintillaWin::GetMouseParameters() noexcept {
	// mouse pointer size and colour may changed
	reverseArrowCursor.Invalidate();
	// This retrieves the number of lines per scroll as configured in the Mouse Properties sheet in Control Panel
	::SystemParametersInfo(SPI_GETWHEELSCROLLLINES, 0, &linesPerScroll, 0);
	if (!::SystemParametersInfo(SPI_GETWHEELSCROLLCHARS, 0, &charsPerScroll, 0)) {
		// no horizontal scrolling configuration on Windows XP
		charsPerScroll = (linesPerScroll == WHEEL_PAGESCROLL) ? 3 : linesPerScroll;
	}
	::SystemParametersInfo(SPI_GETMOUSEVANISH, 0, &typingWithoutCursor, 0);
}

void ScintillaWin::CopyToGlobal(GlobalMemory &gmUnicode, const SelectionText &selectedText) {
	const std::string_view svSelected(selectedText.Data(), selectedText.LengthWithTerminator());
	if (IsUnicodeMode()) {
		const size_t uchars = UTF16Length(svSelected);
		gmUnicode.Allocate(2 * uchars);
		if (gmUnicode) {
			UTF16FromUTF8(svSelected,
				static_cast<wchar_t *>(gmUnicode.ptr), uchars);
		}
	} else {
		// Not Unicode mode
		// Convert to Unicode using the current Scintilla code page
		const UINT cpSrc = CodePageFromCharSet(
			selectedText.characterSet, selectedText.codePage);
		const size_t uLen = WideCharLenFromMultiByte(cpSrc, svSelected);
		gmUnicode.Allocate(2 * uLen);
		if (gmUnicode) {
			WideCharFromMultiByte(cpSrc, svSelected,
				static_cast<wchar_t *>(gmUnicode.ptr), uLen);
		}
	}
}

void ScintillaWin::CopyToClipboard(const SelectionText &selectedText) {
	Clipboard clipboard(MainHWND());
	if (!clipboard) {
		return;
	}
	::EmptyClipboard();

	GlobalMemory uniText;
	CopyToGlobal(uniText, selectedText);
	if (uniText) {
		uniText.SetClip(CF_UNICODETEXT);
	}

	if (selectedText.rectangular) {
		::SetClipboardData(cfColumnSelect, {});

		GlobalMemory borlandSelection;
		borlandSelection.Allocate(1);
		if (borlandSelection) {
			static_cast<BYTE *>(borlandSelection.ptr)[0] = 0x02;
			borlandSelection.SetClip(cfBorlandIDEBlockType);
		}
	}

	if (selectedText.lineCopy) {
		::SetClipboardData(cfLineSelect, {});
		::SetClipboardData(cfVSLineTag, {});
	}
}

void ScintillaWin::ScrollMessage(WPARAM wParam) {
	//DWORD dwStart = timeGetTime();
	//Platform::DebugPrintf("Scroll %x %d\n", wParam, lParam);

	SCROLLINFO sci = {};
	sci.cbSize = sizeof(sci);
	sci.fMask = SIF_ALL;

	GetScrollInfo(SB_VERT, &sci);

	//Platform::DebugPrintf("ScrollInfo %d mask=%x min=%d max=%d page=%d pos=%d track=%d\n", b,sci.fMask,
	//sci.nMin, sci.nMax, sci.nPage, sci.nPos, sci.nTrackPos);
	Sci::Line topLineNew = topLine;
	switch (LOWORD(wParam)) {
	case SB_LINEUP:
		topLineNew -= 1;
		break;
	case SB_LINEDOWN:
		topLineNew += 1;
		break;
	case SB_PAGEUP:
		topLineNew -= LinesToScroll(); break;
	case SB_PAGEDOWN: topLineNew += LinesToScroll(); break;
	case SB_TOP: topLineNew = 0; break;
	case SB_BOTTOM: topLineNew = MaxScrollPos(); break;
	case SB_THUMBPOSITION: topLineNew = sci.nTrackPos; break;
	case SB_THUMBTRACK: topLineNew = sci.nTrackPos; break;
	}
	ScrollTo(topLineNew);
}

void ScintillaWin::HorizontalScrollMessage(WPARAM wParam) {
	int xPos = xOffset;
	const PRectangle rcText = GetTextRectangle();
	const int pageWidth = static_cast<int>(rcText.Width() * 2 / 3);
	constexpr int pixelsPerArrow = 20;
	switch (LOWORD(wParam)) {
	case SB_LINEUP:
		xPos -= pixelsPerArrow;
		break;
	case SB_LINEDOWN:	// May move past the logical end
		xPos += pixelsPerArrow;
		break;
	case SB_PAGEUP:
		xPos -= pageWidth;
		break;
	case SB_PAGEDOWN:
		xPos += pageWidth;
		break;
	case SB_TOP:
		xPos = 0;
		break;
	case SB_BOTTOM:
		xPos = scrollWidth;
		break;
	case SB_THUMBPOSITION:
	case SB_THUMBTRACK: {
			// Do NOT use wParam, its 16 bit and not enough for very long lines. Its still possible to overflow the 32 bit but you have to try harder =]
			SCROLLINFO si {};
			si.cbSize = sizeof(si);
			si.fMask = SIF_TRACKPOS;
			if (GetScrollInfo(SB_HORZ, &si)) {
				xPos = si.nTrackPos;
			}
		}
		break;
	}
	HorizontalScrollToClamped(xPos);
}

/**
 * Redraw all of text area.
 * This paint will not be abandoned.
 */
void ScintillaWin::FullPaint() {
	if ((technology == Technology::Default) || (technology == Technology::DirectWriteDC)) {
		HDC hdc = ::GetDC(MainHWND());
		FullPaintDC(hdc);
		::ReleaseDC(MainHWND(), hdc);
	} else {
		FullPaintDC({});
	}
}

/**
 * Redraw all of text area on the specified DC.
 * This paint will not be abandoned.
 */
void ScintillaWin::FullPaintDC(HDC hdc) {
	paintState = PaintState::painting;
	rcPaint = GetClientRectangle();
	paintingAllText = true;
	PaintDC(hdc);
	paintState = PaintState::notPainting;
}

namespace {

bool CompareDevCap(HDC hdc, HDC hOtherDC, int nIndex) noexcept {
	return ::GetDeviceCaps(hdc, nIndex) == ::GetDeviceCaps(hOtherDC, nIndex);
}

}

bool ScintillaWin::IsCompatibleDC(HDC hOtherDC) noexcept {
	HDC hdc = ::GetDC(MainHWND());
	const bool isCompatible =
		CompareDevCap(hdc, hOtherDC, TECHNOLOGY) &&
		CompareDevCap(hdc, hOtherDC, LOGPIXELSY) &&
		CompareDevCap(hdc, hOtherDC, LOGPIXELSX) &&
		CompareDevCap(hdc, hOtherDC, BITSPIXEL) &&
		CompareDevCap(hdc, hOtherDC, PLANES);
	::ReleaseDC(MainHWND(), hdc);
	return isCompatible;
}

DWORD ScintillaWin::EffectFromState(DWORD grfKeyState) const noexcept {
	// These are the Wordpad semantics.
	DWORD dwEffect;
	if (inDragDrop == DragDrop::dragging)	// Internal defaults to move
		dwEffect = DROPEFFECT_MOVE;
	else
		dwEffect = DROPEFFECT_COPY;
	if (grfKeyState & MK_ALT)
		dwEffect = DROPEFFECT_MOVE;
	if (grfKeyState & MK_CONTROL)
		dwEffect = DROPEFFECT_COPY;
	return dwEffect;
}

/// Implement IUnknown
STDMETHODIMP ScintillaWin::QueryInterface(REFIID riid, PVOID *ppv) {
	*ppv = nullptr;
	if (riid == IID_IUnknown) {
		*ppv = &dt;
	} else if (riid == IID_IDropSource) {
		*ppv = &ds;
	} else if (riid == IID_IDropTarget) {
		*ppv = &dt;
	} else if (riid == IID_IDataObject) {
		*ppv = &dob;
	}
	if (!*ppv)
		return E_NOINTERFACE;
	return S_OK;
}

STDMETHODIMP_(ULONG) ScintillaWin::AddRef() {
	return 1;
}

STDMETHODIMP_(ULONG) ScintillaWin::Release() {
	return 1;
}

/// Implement IDropTarget
STDMETHODIMP ScintillaWin::DragEnter(LPDATAOBJECT pIDataSource, DWORD grfKeyState,
                                     POINTL, PDWORD pdwEffect) {
	if (!pIDataSource )
		return E_POINTER;
	FORMATETC fmtu = {CF_UNICODETEXT, nullptr, DVASPECT_CONTENT, -1, TYMED_HGLOBAL };
	const HRESULT hrHasUText = pIDataSource->QueryGetData(&fmtu);
	hasOKText = (hrHasUText == S_OK);
	if (hasOKText) {
		*pdwEffect = EffectFromState(grfKeyState);
	} else {
		*pdwEffect = DROPEFFECT_NONE;
	}

	return S_OK;
}

STDMETHODIMP ScintillaWin::DragOver(DWORD grfKeyState, POINTL pt, PDWORD pdwEffect) {
	try {
		if (!hasOKText || pdoc->IsReadOnly()) {
			*pdwEffect = DROPEFFECT_NONE;
			return S_OK;
		}

		*pdwEffect = EffectFromState(grfKeyState);

		// Update the cursor.
		POINT rpt = {pt.x, pt.y};
		::ScreenToClient(MainHWND(), &rpt);
		SetDragPosition(SPositionFromLocation(PointFromPOINT(rpt), false, false, UserVirtualSpace()));

		return S_OK;
	} catch (...) {
		errorStatus = Status::Failure;
	}
	return E_FAIL;
}

STDMETHODIMP ScintillaWin::DragLeave() {
	try {
		SetDragPosition(SelectionPosition(Sci::invalidPosition));
		return S_OK;
	} catch (...) {
		errorStatus = Status::Failure;
	}
	return E_FAIL;
}

//Au
void ScintillaWin::AuDragDrop(int action, Sci_DragDropData* r) {
	SelectionPosition pos; if(r != nullptr) pos = SPositionFromLocation(Point::FromInts(r->x, r->y), false, false, UserVirtualSpace());
	switch(action) {
	case 1: //over
		SetDragPosition(pos);
		break;
	case 2: //drop
		SetDragPosition(SelectionPosition(Sci::invalidPosition));
		if (r->len > 0) DropAt(pos, r->text, r->len, !r->copy, false);
		else SetEmptySelection(pos);
		break;
	case 3: //leave
		SetDragPosition(SelectionPosition(Sci::invalidPosition));
		break;
	}
}

STDMETHODIMP ScintillaWin::Drop(LPDATAOBJECT pIDataSource, DWORD grfKeyState,
                                POINTL pt, PDWORD pdwEffect) {
	try {
		*pdwEffect = EffectFromState(grfKeyState);

		if (!pIDataSource)
			return E_POINTER;

		SetDragPosition(SelectionPosition(Sci::invalidPosition));

		std::string putf;
		FORMATETC fmtu = {CF_UNICODETEXT, nullptr, DVASPECT_CONTENT, -1, TYMED_HGLOBAL};
		STGMEDIUM medium{};
		const HRESULT hr = pIDataSource->GetData(&fmtu, &medium);
		if (!SUCCEEDED(hr)) {
			return hr;
		}
		if (medium.hGlobal) {
			GlobalMemory memUDrop(medium.hGlobal);
			if (const wchar_t *uptr = static_cast<const wchar_t *>(memUDrop.ptr)) {
				putf = EncodeWString(uptr);
			}
			memUDrop.Unlock();
		}

		if (putf.empty()) {
			return S_OK;
		}

		FORMATETC fmtr = {cfColumnSelect, nullptr, DVASPECT_CONTENT, -1, TYMED_HGLOBAL};
		const bool isRectangular = S_OK == pIDataSource->QueryGetData(&fmtr);

		POINT rpt = {pt.x, pt.y};
		::ScreenToClient(MainHWND(), &rpt);
		const SelectionPosition movePos = SPositionFromLocation(PointFromPOINT(rpt), false, false, UserVirtualSpace());

		DropAt(movePos, putf.c_str(), putf.size(), *pdwEffect == DROPEFFECT_MOVE, isRectangular);

		// Free data
		::ReleaseStgMedium(&medium);

		return S_OK;
	} catch (...) {
		errorStatus = Status::Failure;
	}
	return E_FAIL;
}

/// Implement important part of IDataObject
STDMETHODIMP ScintillaWin::GetData(FORMATETC *pFEIn, STGMEDIUM *pSTM) {
	if (!SupportedFormat(pFEIn)) {
		//Platform::DebugPrintf("DOB GetData No %d %x %x fmt=%x\n", lenDrag, pFEIn, pSTM, pFEIn->cfFormat);
		return DATA_E_FORMATETC;
	}

	pSTM->tymed = TYMED_HGLOBAL;
	//Platform::DebugPrintf("DOB GetData OK %d %x %x\n", lenDrag, pFEIn, pSTM);

	GlobalMemory uniText;
	CopyToGlobal(uniText, drag);
	pSTM->hGlobal = uniText ? uniText.Unlock() : HGLOBAL{};
	pSTM->pUnkForRelease = nullptr;
	return S_OK;
}

void ScintillaWin::Prepare() noexcept {
	Platform_Initialise(hInstance);

	// Register the CallTip class
	WNDCLASSEX wndclassc{};
	wndclassc.cbSize = sizeof(wndclassc);
	wndclassc.style = CS_GLOBALCLASS | CS_HREDRAW | CS_VREDRAW;
	wndclassc.cbWndExtra = sizeof(ScintillaWin *);
	wndclassc.hInstance = hInstance;
	wndclassc.lpfnWndProc = ScintillaWin::CTWndProc;
	wndclassc.hCursor = ::LoadCursor({}, IDC_ARROW);
	wndclassc.lpszClassName = callClassName;

	callClassAtom = ::RegisterClassEx(&wndclassc);
}

bool ScintillaWin::Register(HINSTANCE hInstance_) noexcept {

	hInstance = hInstance_;

	// Register the Scintilla class
	// Register Scintilla as a wide character window
	WNDCLASSEXW wndclass {};
	wndclass.cbSize = sizeof(wndclass);
	wndclass.style = CS_GLOBALCLASS | CS_HREDRAW | CS_VREDRAW;
	wndclass.lpfnWndProc = ScintillaWin::SWndProc;
	wndclass.cbWndExtra = sizeof(ScintillaWin *);
	wndclass.hInstance = hInstance;
	wndclass.lpszClassName = L"Scintilla";
	scintillaClassAtom = ::RegisterClassExW(&wndclass);
	const bool result = 0 != scintillaClassAtom;

	return result;
}

bool ScintillaWin::Unregister() noexcept {
	bool result = true;
	if (0 != scintillaClassAtom) {
		if (::UnregisterClass(MAKEINTATOM(scintillaClassAtom), hInstance) == 0) {
			result = false;
		}
		scintillaClassAtom = 0;
	}
	if (0 != callClassAtom) {
		if (::UnregisterClass(MAKEINTATOM(callClassAtom), hInstance) == 0) {
			result = false;
		}
		callClassAtom = 0;
	}
	return result;
}

bool ScintillaWin::HasCaretSizeChanged() const noexcept {
	return
		((0 != vs.caret.width) && (sysCaretWidth != vs.caret.width))
		|| ((0 != vs.lineHeight) && (sysCaretHeight != vs.lineHeight));
}

BOOL ScintillaWin::CreateSystemCaret() {
	sysCaretWidth = vs.caret.width;
	if (0 == sysCaretWidth) {
		sysCaretWidth = 1;
	}
	sysCaretHeight = vs.lineHeight;
	const int bitmapSize = (((sysCaretWidth + 15) & ~15) >> 3) *
		sysCaretHeight;
	std::vector<BYTE> bits(bitmapSize);
	sysCaretBitmap = ::CreateBitmap(sysCaretWidth, sysCaretHeight, 1,
		1, bits.data());
	const BOOL retval = ::CreateCaret(
		MainHWND(), sysCaretBitmap,
		sysCaretWidth, sysCaretHeight);
	if (technology == Technology::Default) {
		// System caret interferes with Direct2D drawing so only show it for GDI.
		::ShowCaret(MainHWND());
	}
	return retval;
}

BOOL ScintillaWin::DestroySystemCaret() noexcept {
	::HideCaret(MainHWND());
	const BOOL retval = ::DestroyCaret();
	if (sysCaretBitmap) {
		::DeleteObject(sysCaretBitmap);
		sysCaretBitmap = {};
	}
	return retval;
}

void ScintillaWin::CTPaint(HWND hWnd) {
	Painter painter(hWnd);
	std::unique_ptr<Surface> surfaceWindow(Surface::Allocate(technology));
#if defined(USE_D2D)
	HwndRenderTarget pCTRenderTarget;
#endif
	const RECT rc = GetClientRect(hWnd);
	if (technology == Technology::Default) {
		surfaceWindow->Init(painter.ps.hdc, hWnd);
	} else {
#if defined(USE_D2D)
		const int scaleFactor = GetFirstIntegralMultipleDeviceScaleFactor();

		// Create a Direct2D render target.

		const FLOAT dpiTarget = dpiDefault * static_cast<float>(scaleFactor);

		const D2D1_RENDER_TARGET_PROPERTIES drtp = D2D1::RenderTargetProperties(
			D2D1_RENDER_TARGET_TYPE_DEFAULT,
			{ DXGI_FORMAT_UNKNOWN, D2D1_ALPHA_MODE_UNKNOWN },
			dpiTarget, dpiTarget);

		const D2D1_PRESENT_OPTIONS presentOptions = (technology == Technology::DirectWriteRetain) ?
			D2D1_PRESENT_OPTIONS_RETAIN_CONTENTS : D2D1_PRESENT_OPTIONS_NONE;

		const D2D1_HWND_RENDER_TARGET_PROPERTIES dhrtp = D2D1::HwndRenderTargetProperties(
			hWnd,
			::GetSizeUFromRect(rc, scaleFactor),
			presentOptions);

		const HRESULT hr = CreateHwndRenderTarget(&drtp, &dhrtp, pCTRenderTarget);
		if (!SUCCEEDED(hr)) {
			surfaceWindow->Release();
			return;
		}
		// If above SUCCEEDED, then pCTRenderTarget not nullptr
		assert(pCTRenderTarget);
		if (pCTRenderTarget) {
			surfaceWindow->Init(pCTRenderTarget.Get(), hWnd);
			pCTRenderTarget->BeginDraw();
		}
#endif
	}
	surfaceWindow->SetMode(CurrentSurfaceMode());
	SetRenderingParams(surfaceWindow.get());
	ct.PaintCT(surfaceWindow.get());
#if defined(USE_D2D)
	if (pCTRenderTarget)
		pCTRenderTarget->EndDraw();
#endif
	surfaceWindow->Release();
}

LRESULT ScintillaWin::CTProcessMessage(HWND hWnd, UINT iMessage, WPARAM wParam, LPARAM lParam) {
	try {
		switch (iMessage) {
		case WM_NCDESTROY:
			SetWindowPointer(hWnd, nullptr);
			break;
		case WM_PAINT:
			CTPaint(hWnd);
			return 0;
		case WM_NCLBUTTONDOWN:
		case WM_NCLBUTTONDBLCLK: {
				POINT pt = POINTFromLParam(lParam);
				::ScreenToClient(hWnd, &pt);
				ct.MouseClick(PointFromPOINT(pt));
				CallTipClick();
				return 0;
			}
		case WM_LBUTTONDOWN:
			// This does not fire due to the hit test code
			ct.MouseClick(PointFromLParam(lParam));
			CallTipClick();
			return 0;
		case WM_SETCURSOR:
			::SetCursor(::LoadCursor({}, IDC_ARROW));
			return 0;
		case WM_NCHITTEST:
			return HTCAPTION;
		default:
			break;
		}
	} catch (...) {
		errorStatus = Status::Failure;
	}

	return ::DefWindowProc(hWnd, iMessage, wParam, lParam);
}

LRESULT PASCAL ScintillaWin::CTWndProc(
	HWND hWnd, UINT iMessage, WPARAM wParam, LPARAM lParam) {
	// Find C++ object associated with window.
	ScintillaWin *sciThis = static_cast<ScintillaWin *>(PointerFromWindow(hWnd));
	// sciThis will be zero if WM_CREATE not seen yet
	if (sciThis == nullptr) {
		if (iMessage == WM_CREATE) {
			// Associate CallTip object with window
			CREATESTRUCT *pCreate = static_cast<CREATESTRUCT *>(PtrFromSPtr(lParam));
			SetWindowPointer(hWnd, pCreate->lpCreateParams);
			return 0;
		}
		return ::DefWindowProc(hWnd, iMessage, wParam, lParam);
	}
	return sciThis->CTProcessMessage(hWnd, iMessage, wParam, lParam);
}

sptr_t ScintillaWin::DirectFunction(
    sptr_t ptr, UINT iMessage, uptr_t wParam, sptr_t lParam) {
	ScintillaWin *sci = static_cast<ScintillaWin *>(PtrFromSPtr(ptr));
	PLATFORM_ASSERT(::GetCurrentThreadId() == ::GetWindowThreadProcessId(sci->MainHWND(), nullptr));
	return sci->WndProc(static_cast<Message>(iMessage), wParam, lParam);
}

sptr_t ScintillaWin::DirectStatusFunction(
    sptr_t ptr, UINT iMessage, uptr_t wParam, sptr_t lParam, int *pStatus) {
	ScintillaWin *sci = static_cast<ScintillaWin *>(PtrFromSPtr(ptr));
	PLATFORM_ASSERT(::GetCurrentThreadId() == ::GetWindowThreadProcessId(sci->MainHWND(), nullptr));
	const sptr_t returnValue = sci->WndProc(static_cast<Message>(iMessage), wParam, lParam);
	*pStatus = static_cast<int>(sci->errorStatus);
	return returnValue;
}

namespace Scintilla::Internal {

sptr_t DirectFunction(
    ScintillaWin *sci, UINT iMessage, uptr_t wParam, sptr_t lParam) {
	return sci->WndProc(static_cast<Message>(iMessage), wParam, lParam);
}

}

LRESULT PASCAL ScintillaWin::SWndProc(
	HWND hWnd, UINT iMessage, WPARAM wParam, LPARAM lParam) {
	//Platform::DebugPrintf("S W:%x M:%x WP:%x L:%x\n", hWnd, iMessage, wParam, lParam);

	// Find C++ object associated with window.
	ScintillaWin *sci = static_cast<ScintillaWin *>(PointerFromWindow(hWnd));
	// sci will be zero if WM_CREATE not seen yet
	if (sci == nullptr) {
		try {
			if (iMessage == WM_CREATE) {
				static std::once_flag once;
				std::call_once(once, Prepare);
				// Create C++ object associated with window
				sci = new ScintillaWin(hWnd);
				SetWindowPointer(hWnd, sci);
				return sci->WndProc(static_cast<Message>(iMessage), wParam, lParam);
			}
		} catch (...) {
		}
		return ::DefWindowProc(hWnd, iMessage, wParam, lParam);
	}
	if (iMessage == WM_NCDESTROY) {
		try {
			sci->Finalise();
			delete sci;
		} catch (...) {
		}
		SetWindowPointer(hWnd, nullptr);
		return ::DefWindowProc(hWnd, iMessage, wParam, lParam);
	}
	return sci->WndProc(static_cast<Message>(iMessage), wParam, lParam);
}

// This function is externally visible so it can be called from container when building statically.
// Must be called once only.
extern "C" int Scintilla_RegisterClasses(void *hInstance) {
	const bool result = ScintillaWin::Register(static_cast<HINSTANCE>(hInstance));
	return result;
}

namespace Scintilla::Internal {

int ResourcesRelease(bool fromDllMain) noexcept {
	const bool result = ScintillaWin::Unregister();
	Platform_Finalise(fromDllMain);
	return result;
}

int RegisterClasses(void *hInstance) noexcept {
	const bool result = ScintillaWin::Register(static_cast<HINSTANCE>(hInstance));
	return result;
}

}

// This function is externally visible so it can be called from container when building statically.
extern "C" int Scintilla_ReleaseResources() {
	return Scintilla::Internal::ResourcesRelease(false);
}

//Au: for some mods use functions instead of messages. Eg when need as fast as possible.
namespace Scintilla {

#define EXPORT extern "C" __declspec(dllexport)

//Gets data for C# function _RangeText etc.
EXPORT int __stdcall Sci_Range(ScintillaWin* sci, int start8, int end8, const char*& p1, const char*& p2, int* length) {
	auto pdoc = sci->pdoc;
	auto start = static_cast<Sci::Position>(start8);
	auto end = end8 < 0 ? pdoc->Length() : static_cast<Sci::Position>(end8);
	auto gap = pdoc->GapPosition();
	if(gap > start && gap < end) {
		p1 = pdoc->RangePointer(start, gap - start);
		p2 = pdoc->RangePointer(gap, end - gap);
	} else {
		p1 = pdoc->RangePointer(start, end - start);
		p2 = nullptr;
	}
	if(length != nullptr) *length = (int)pdoc->Length();
	return (int)gap;
}

EXPORT void __stdcall Sci_SetFoldLevels(ScintillaWin* sci, int line, int lastLine, int len, int* a) {
	sci->Sci_SetFoldLevels(line, lastLine, len, a);
}

EXPORT void __stdcall Sci_GetVisibleRange(ScintillaWin* sci, struct ScintillaWin::Sci_VisibleRange& r) {
	sci->Sci_GetVisibleRange(r);
}

}


================================================
FILE: Libraries/scintilla/win32/ScintillaWin.h
================================================
// Scintilla source code edit control
/** @file ScintillaWin.h
 ** Define functions from ScintillaWin.cxx that can be called from ScintillaDLL.cxx.
 **/
// Copyright 1998-2018 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#ifndef SCINTILLAWIN_H
#define SCINTILLAWIN_H

namespace Scintilla::Internal {

class ScintillaWin;

int ResourcesRelease(bool fromDllMain) noexcept;
int RegisterClasses(void *hInstance) noexcept;
Scintilla::sptr_t DirectFunction(ScintillaWin *sci, UINT iMessage, Scintilla::uptr_t wParam, Scintilla::sptr_t lParam);

}

#endif


================================================
FILE: Libraries/scintilla/win32/SurfaceD2D.cxx
================================================
// Scintilla source code edit control
/** @file SurfaceD2D.cxx
 ** Implementation of drawing to Direct2D on Windows.
 **/
// Copyright 1998-2003 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#include <cstddef>
#include <cstdlib>
#include <cstdint>
#include <cstring>
#include <cstdio>
#include <cstdarg>
#include <ctime>
#include <cmath>
#include <climits>

#include <string_view>
#include <vector>
#include <map>
#include <optional>
#include <algorithm>
#include <iterator>
#include <memory>
#include <mutex>

// Want to use std::min and std::max so don't want Windows.h version of min and max
#if !defined(NOMINMAX)
#define NOMINMAX
#endif
#undef _WIN32_WINNT
#define _WIN32_WINNT 0x0A00
#undef WINVER
#define WINVER 0x0A00
#define WIN32_LEAN_AND_MEAN 1
#include <windows.h>
#include <commctrl.h>
#include <richedit.h>
#include <windowsx.h>
#include <shellscalingapi.h>

#include <wrl.h>
using Microsoft::WRL::ComPtr;

#if !defined(DISABLE_D2D)
#define USE_D2D 1
#endif

#if defined(USE_D2D)
#include <d2d1_1.h>
#include <d3d11_1.h>
#include <dwrite_1.h>
#endif

#include "ScintillaTypes.h"

#include "Debugging.h"
#include "Geometry.h"
#include "Platform.h"
#include "XPM.h"
#include "UniConversion.h"
#include "DBCS.h"

#include "WinTypes.h"
#include "PlatWin.h"
#include "SurfaceGDI.h"
#if defined(USE_D2D)
#include "SurfaceD2D.h"
#endif

// __uuidof is a Microsoft extension but makes COM code neater, so disable warning
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wlanguage-extension-token"
#endif

using namespace Scintilla;
using namespace Scintilla::Internal;

namespace {

#if defined(USE_D2D)

D2D1_DRAW_TEXT_OPTIONS d2dDrawTextOptions = D2D1_DRAW_TEXT_OPTIONS_NONE;

HMODULE hDLLD2D{};
HMODULE hDLLD3D{};
HMODULE hDLLDWrite{};

PFN_D3D11_CREATE_DEVICE fnDCD{};

void LoadD2DOnce() noexcept {
	DWORD loadLibraryFlags = 0;
	HMODULE kernel32 = ::GetModuleHandleW(L"kernel32.dll");
	if (kernel32) {
		if (::GetProcAddress(kernel32, "SetDefaultDllDirectories")) {
			// Availability of SetDefaultDllDirectories implies Windows 8+ or
			// that KB2533623 has been installed so LoadLibraryEx can be called
			// with LOAD_LIBRARY_SEARCH_SYSTEM32.
			loadLibraryFlags = LOAD_LIBRARY_SEARCH_SYSTEM32;
		}
	}

	using D2D1CFSig = HRESULT(WINAPI *)(D2D1_FACTORY_TYPE factoryType, REFIID riid,
		CONST D2D1_FACTORY_OPTIONS *pFactoryOptions, IUnknown **factory);
	using DWriteCFSig = HRESULT(WINAPI *)(DWRITE_FACTORY_TYPE factoryType, REFIID iid,
		IUnknown **factory);

	hDLLD2D = ::LoadLibraryEx(TEXT("D2D1.DLL"), {}, loadLibraryFlags);
	D2D1CFSig fnD2DCF = DLLFunction<D2D1CFSig>(hDLLD2D, "D2D1CreateFactory");
	if (fnD2DCF) {
		const D2D1_FACTORY_OPTIONS options{};
		// A multi threaded factory in case Scintilla is used with multiple GUI threads
		fnD2DCF(D2D1_FACTORY_TYPE_MULTI_THREADED,
			__uuidof(ID2D1Factory1),
			&options,
			reinterpret_cast<IUnknown **>(&pD2DFactory));
	}
	hDLLDWrite = ::LoadLibraryEx(TEXT("DWRITE.DLL"), {}, loadLibraryFlags);
	DWriteCFSig fnDWCF = DLLFunction<DWriteCFSig>(hDLLDWrite, "DWriteCreateFactory");
	if (fnDWCF) {
		const GUID IID_IDWriteFactory2 = // 0439fc60-ca44-4994-8dee-3a9af7b732ec
		{ 0x0439fc60, 0xca44, 0x4994, { 0x8d, 0xee, 0x3a, 0x9a, 0xf7, 0xb7, 0x32, 0xec } };

		const HRESULT hr = fnDWCF(DWRITE_FACTORY_TYPE_SHARED,
			IID_IDWriteFactory2,
			reinterpret_cast<IUnknown **>(&pIDWriteFactory));
		if (SUCCEEDED(hr)) {
			// D2D1_DRAW_TEXT_OPTIONS_ENABLE_COLOR_FONT
			d2dDrawTextOptions = static_cast<D2D1_DRAW_TEXT_OPTIONS>(0x00000004);
		} else {
			fnDWCF(DWRITE_FACTORY_TYPE_SHARED,
				__uuidof(IDWriteFactory1),
				reinterpret_cast<IUnknown **>(&pIDWriteFactory));
		}
	}

	hDLLD3D = ::LoadLibraryEx(TEXT("D3D11.DLL"), {}, loadLibraryFlags);
	if (!hDLLD3D) {
		Platform::DebugPrintf("Direct3D not loaded\n");
	}
	fnDCD = DLLFunction<PFN_D3D11_CREATE_DEVICE>(hDLLD3D, "D3D11CreateDevice");
	if (!fnDCD) {
		Platform::DebugPrintf("Direct3D does not have D3D11CreateDevice\n");
	}
}

constexpr D2D1_TEXT_ANTIALIAS_MODE DWriteMapFontQuality(FontQuality extraFontFlag) noexcept {
	switch (extraFontFlag & FontQuality::QualityMask) {

		case FontQuality::QualityNonAntialiased:
			return D2D1_TEXT_ANTIALIAS_MODE_ALIASED;

		case FontQuality::QualityAntialiased:
			return D2D1_TEXT_ANTIALIAS_MODE_GRAYSCALE;

		case FontQuality::QualityLcdOptimized:
			return D2D1_TEXT_ANTIALIAS_MODE_CLEARTYPE;

		default:
			return D2D1_TEXT_ANTIALIAS_MODE_DEFAULT;
	}
}

struct FontDirectWrite : public FontWin {
	ComPtr<IDWriteTextFormat> pTextFormat;
	FontQuality extraFontFlag = FontQuality::QualityDefault;
	CharacterSet characterSet = CharacterSet::Ansi;
	static constexpr FLOAT minimalAscent = 2.0f;
	FLOAT yAscent = minimalAscent;
	FLOAT yDescent = 1.0f;
	FLOAT yInternalLeading = 0.0f;

	explicit FontDirectWrite(const FontParameters &fp) :
		extraFontFlag(fp.extraFontFlag),
		characterSet(fp.characterSet) {
		const std::wstring wsFace = WStringFromUTF8(fp.faceName);
		const std::wstring wsLocale = WStringFromUTF8(fp.localeName);
		const FLOAT fHeight = static_cast<FLOAT>(fp.size);
		const DWRITE_FONT_STYLE style = fp.italic ? DWRITE_FONT_STYLE_ITALIC : DWRITE_FONT_STYLE_NORMAL;
		HRESULT hr = pIDWriteFactory->CreateTextFormat(wsFace.c_str(), nullptr,
			static_cast<DWRITE_FONT_WEIGHT>(fp.weight),
			style,
			static_cast<DWRITE_FONT_STRETCH>(fp.stretch),
				fHeight, wsLocale.c_str(), pTextFormat.GetAddressOf());
		if (hr == E_INVALIDARG) {
			// Possibly a bad locale name like "/" so try "en-us".
			hr = pIDWriteFactory->CreateTextFormat(wsFace.c_str(), nullptr,
				static_cast<DWRITE_FONT_WEIGHT>(fp.weight),
				style,
				static_cast<DWRITE_FONT_STRETCH>(fp.stretch),
				fHeight, L"en-us", pTextFormat.ReleaseAndGetAddressOf());
		}
		if (SUCCEEDED(hr)) {
			pTextFormat->SetWordWrapping(DWRITE_WORD_WRAPPING_NO_WRAP);

			if (TextLayout pTextLayout = LayoutCreate(L"X", pTextFormat.Get())) {
				constexpr int maxLines = 2;
				DWRITE_LINE_METRICS lineMetrics[maxLines]{};
				UINT32 lineCount = 0;
				hr = pTextLayout->GetLineMetrics(lineMetrics, maxLines, &lineCount);
				if (SUCCEEDED(hr)) {
					yAscent = lineMetrics[0].baseline;
					yDescent = lineMetrics[0].height - lineMetrics[0].baseline;

					FLOAT emHeight;
					hr = pTextLayout->GetFontSize(0, &emHeight);
					if (SUCCEEDED(hr)) {
						yInternalLeading = lineMetrics[0].height - emHeight;
					}
				}
				pTextFormat->SetLineSpacing(DWRITE_LINE_SPACING_METHOD_UNIFORM, lineMetrics[0].height, lineMetrics[0].baseline);
			}
		}
	}
	// Allow copy constructor. Has to explicitly copy each field since can't use =default as deleted in Font.
	FontDirectWrite(const FontDirectWrite &other) noexcept {
		pTextFormat = other.pTextFormat;
		extraFontFlag = other.extraFontFlag;
		characterSet = other.characterSet;
		yAscent = other.yAscent;
		yDescent = other.yDescent;
		yInternalLeading = other.yInternalLeading;
	}
	// Deleted so FontDirectWrite objects can not be copied.
	FontDirectWrite(FontDirectWrite &&) = delete;
	FontDirectWrite &operator=(const FontDirectWrite &) = delete;
	FontDirectWrite &operator=(FontDirectWrite &&) = delete;
	~FontDirectWrite() noexcept override = default;
	[[nodiscard]] HFONT HFont() const noexcept override {
		LOGFONTW lf = {};
		const HRESULT hr = pTextFormat->GetFontFamilyName(lf.lfFaceName, LF_FACESIZE);
		if (!SUCCEEDED(hr)) {
			return {};
		}
		lf.lfWeight = pTextFormat->GetFontWeight();
		lf.lfItalic = pTextFormat->GetFontStyle() == DWRITE_FONT_STYLE_ITALIC;
		lf.lfHeight = -static_cast<int>(pTextFormat->GetFontSize());
		return ::CreateFontIndirectW(&lf);
	}

	[[nodiscard]] int CodePageText(int codePage) const noexcept {
		if (!(codePage == CpUtf8) && (characterSet != CharacterSet::Ansi)) {
			codePage = CodePageFromCharSet(characterSet, codePage);
		}
		return codePage;
	}

	static const FontDirectWrite *Cast(const Font *font_) {
		const FontDirectWrite *pfm = dynamic_cast<const FontDirectWrite *>(font_);
		PLATFORM_ASSERT(pfm);
		if (!pfm) {
			throw std::runtime_error("SurfaceD2D::SetFont: wrong Font type.");
		}
		return pfm;
	}

	[[nodiscard]] std::unique_ptr<FontWin> Duplicate() const override {
		return std::make_unique<FontDirectWrite>(*this);
	}

	[[nodiscard]] CharacterSet GetCharacterSet() const noexcept override {
		return characterSet;
	}
};

constexpr D2D1_RECT_F RectangleFromPRectangle(PRectangle rc) noexcept {
	return {
		static_cast<FLOAT>(rc.left),
		static_cast<FLOAT>(rc.top),
		static_cast<FLOAT>(rc.right),
		static_cast<FLOAT>(rc.bottom)
	};
}

constexpr D2D1_POINT_2F DPointFromPoint(Point point) noexcept {
	return { static_cast<FLOAT>(point.x), static_cast<FLOAT>(point.y) };
}

constexpr Supports SupportsD2D[] = {
	Supports::LineDrawsFinal,
	Supports::FractionalStrokeWidth,
	Supports::TranslucentStroke,
	Supports::PixelModification,
	Supports::ThreadSafeMeasureWidths,
};

constexpr D2D1_RECT_F RectangleInset(D2D1_RECT_F rect, FLOAT inset) noexcept {
	return D2D1_RECT_F{
		rect.left + inset,
		rect.top + inset,
		rect.right - inset,
		rect.bottom - inset };
}

constexpr D2D_COLOR_F ColorFromColourAlpha(ColourRGBA colour) noexcept {
	return D2D_COLOR_F{
		colour.GetRedComponent(),
		colour.GetGreenComponent(),
		colour.GetBlueComponent(),
		colour.GetAlphaComponent()
	};
}

class BlobInline;

class SurfaceD2D : public Surface, public ISetRenderingParams {
	SurfaceMode mode;

	// Text measuring surface: both pRenderTarget and pBitmapRenderTarget are null.
	// Window surface: pRenderTarget is valid but not pBitmapRenderTarget.
	// Bitmap drawing surface: both pRenderTarget and pBitmapRenderTarget are valid and the same.
	ComPtr<ID2D1RenderTarget> pRenderTarget;
	ComPtr<ID2D1BitmapRenderTarget> pBitmapRenderTarget;
	int clipsActive = 0;

	BrushSolid pBrush = nullptr;

	static constexpr FontQuality invalidFontQuality = FontQuality::QualityMask;
	FontQuality fontQuality = invalidFontQuality;
	int logPixelsY = USER_DEFAULT_SCREEN_DPI;
	int deviceScaleFactor = 1;
	std::shared_ptr<RenderingParams> renderingParams;

	void Clear() noexcept;
	void SetFontQuality(FontQuality extraFontFlag);
	HRESULT GetBitmap(ID2D1Bitmap **ppBitmap);
	void SetDeviceScaleFactor(const ID2D1RenderTarget *const pD2D1RenderTarget) noexcept;

public:
	SurfaceD2D() noexcept = default;
	SurfaceD2D(ID2D1RenderTarget *pRenderTargetCompatible, int width, int height, SurfaceMode mode_, int logPixelsY_) noexcept;
	// Deleted so SurfaceD2D objects can not be copied.
	SurfaceD2D(const SurfaceD2D &) = delete;
	SurfaceD2D(SurfaceD2D &&) = delete;
	SurfaceD2D &operator=(const SurfaceD2D &) = delete;
	SurfaceD2D &operator=(SurfaceD2D &&) = delete;
	~SurfaceD2D() noexcept override;

	void SetScale(WindowID wid) noexcept;
	void Init(WindowID wid) override;
	void Init(SurfaceID sid, WindowID wid) override;
	std::unique_ptr<Surface> AllocatePixMap(int width, int height) override;

	void SetMode(SurfaceMode mode_) override;

	void Release() noexcept override;
	int SupportsFeature(Supports feature) noexcept override;
	bool Initialised() override;

	void D2DPenColourAlpha(ColourRGBA fore) noexcept;
	int LogPixelsY() override;
	int PixelDivisions() override;
	int DeviceHeightFont(int points) override;
	void LineDraw(Point start, Point end, Stroke stroke) override;
	static Geometry GeometricFigure(const Point *pts, size_t npts, D2D1_FIGURE_BEGIN figureBegin) noexcept;
	void PolyLine(const Point *pts, size_t npts, Stroke stroke) override;
	void Polygon(const Point *pts, size_t npts, FillStroke fillStroke) override;
	void RectangleDraw(PRectangle rc, FillStroke fillStroke) override;
	void RectangleFrame(PRectangle rc, Stroke stroke) override;
	void FillRectangle(PRectangle rc, Fill fill) override;
	void FillRectangleAligned(PRectangle rc, Fill fill) override;
	void FillRectangle(PRectangle rc, Surface &surfacePattern) override;
	void RoundedRectangle(PRectangle rc, FillStroke fillStroke) override;
	void AlphaRectangle(PRectangle rc, XYPOSITION cornerSize, FillStroke fillStroke) override;
	void GradientRectangle(PRectangle rc, const std::vector<ColourStop> &stops, GradientOptions options) override;
	void DrawRGBAImage(PRectangle rc, int width, int height, const unsigned char *pixelsImage) override;
	void Ellipse(PRectangle rc, FillStroke fillStroke) override;
	void Stadium(PRectangle rc, FillStroke fillStroke, Ends ends) override;
	void Copy(PRectangle rc, Point from, Surface &surfaceSource) override;

	std::unique_ptr<IScreenLineLayout> Layout(const IScreenLine *screenLine) override;

	void DrawTextCommon(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text, int codePageOverride, UINT fuOptions);

	void DrawTextNoClip(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text, ColourRGBA fore, ColourRGBA back) override;
	void DrawTextClipped(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text, ColourRGBA fore, ColourRGBA back) override;
	void DrawTextTransparent(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text, ColourRGBA fore) override;
	void MeasureWidths(const Font *font_, std::string_view text, XYPOSITION *positions) override;
	XYPOSITION WidthText(const Font *font_, std::string_view text) override;

	void DrawTextNoClipUTF8(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text, ColourRGBA fore, ColourRGBA back) override;
	void DrawTextClippedUTF8(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text, ColourRGBA fore, ColourRGBA back) override;
	void DrawTextTransparentUTF8(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text, ColourRGBA fore) override;
	void MeasureWidthsUTF8(const Font *font_, std::string_view text, XYPOSITION *positions) override;
	XYPOSITION WidthTextUTF8(const Font *font_, std::string_view text) override;

	XYPOSITION Ascent(const Font *font_) override;
	XYPOSITION Descent(const Font *font_) override;
	XYPOSITION InternalLeading(const Font *font_) override;
	XYPOSITION Height(const Font *font_) override;
	XYPOSITION AverageCharWidth(const Font *font_) override;

	void SetClip(PRectangle rc) override;
	void PopClip() override;
	void FlushCachedState() override;
	void FlushDrawing() override;

	void DrawLineDots(PRectangle rc, ColourRGBA color) { } //Au
	void* get_hdc() { return nullptr; } //Au

	void SetRenderingParams(std::shared_ptr<RenderingParams> renderingParams_) override;
};

SurfaceD2D::SurfaceD2D(ID2D1RenderTarget *pRenderTargetCompatible, int width, int height, SurfaceMode mode_, int logPixelsY_) noexcept {
	const D2D1_SIZE_F desiredSize = D2D1::SizeF(static_cast<float>(width), static_cast<float>(height));
	D2D1_PIXEL_FORMAT desiredFormat;
#ifdef __MINGW32__
	desiredFormat.format = DXGI_FORMAT_UNKNOWN;
#else
	desiredFormat = pRenderTargetCompatible->GetPixelFormat();
#endif
	desiredFormat.alphaMode = D2D1_ALPHA_MODE_IGNORE;
	const HRESULT hr = pRenderTargetCompatible->CreateCompatibleRenderTarget(
		&desiredSize, nullptr, &desiredFormat, D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS_NONE, pBitmapRenderTarget.GetAddressOf());
	if (SUCCEEDED(hr)) {
		pRenderTarget = pBitmapRenderTarget;
		SetDeviceScaleFactor(pRenderTarget.Get());
		pRenderTarget->BeginDraw();
	}
	mode = mode_;
	logPixelsY = logPixelsY_;
}

SurfaceD2D::~SurfaceD2D() noexcept {
	Clear();
}

void SurfaceD2D::Clear() noexcept {
	pBrush = nullptr;
	if (pRenderTarget) {
		while (clipsActive) {
			pRenderTarget->PopAxisAlignedClip();
			clipsActive--;
		}
		if (pBitmapRenderTarget) {
			pRenderTarget->EndDraw();
		}
	}
	pRenderTarget = nullptr;
	pBitmapRenderTarget = nullptr;
}

void SurfaceD2D::Release() noexcept {
	Clear();
}

void SurfaceD2D::SetScale(WindowID wid) noexcept {
	fontQuality = invalidFontQuality;
	logPixelsY = DpiForWindow(wid);
}

int SurfaceD2D::SupportsFeature(Supports feature) noexcept {
	for (const Supports f : SupportsD2D) {
		if (f == feature)
			return 1;
	}
	return 0;
}

bool SurfaceD2D::Initialised() {
	return pRenderTarget;
}

void SurfaceD2D::Init(WindowID wid) {
	Release();
	SetScale(wid);
}

void SurfaceD2D::Init(SurfaceID sid, WindowID wid) {
	Release();
	SetScale(wid);
	pRenderTarget = static_cast<ID2D1RenderTarget *>(sid);
	SetDeviceScaleFactor(pRenderTarget.Get());
}

std::unique_ptr<Surface> SurfaceD2D::AllocatePixMap(int width, int height) {
	std::unique_ptr<SurfaceD2D> surf = std::make_unique<SurfaceD2D>(pRenderTarget.Get(), width, height, mode, logPixelsY);
	surf->SetRenderingParams(renderingParams);
	return surf;
}

void SurfaceD2D::SetMode(SurfaceMode mode_) {
	mode = mode_;
}

HRESULT SurfaceD2D::GetBitmap(ID2D1Bitmap **ppBitmap) {
	PLATFORM_ASSERT(pBitmapRenderTarget);
	return pBitmapRenderTarget->GetBitmap(ppBitmap);
}

void SurfaceD2D::D2DPenColourAlpha(ColourRGBA fore) noexcept {
	if (pRenderTarget) {
		const D2D_COLOR_F col = ColorFromColourAlpha(fore);
		if (pBrush) {
			pBrush->SetColor(col);
		} else {
			const HRESULT hr = pRenderTarget->CreateSolidColorBrush(col, &pBrush);
			if (!SUCCEEDED(hr)) {
				pBrush = nullptr;
			}
		}
	}
}

void SurfaceD2D::SetFontQuality(FontQuality extraFontFlag) {
	if ((fontQuality != extraFontFlag) && renderingParams) {
		fontQuality = extraFontFlag;
		const D2D1_TEXT_ANTIALIAS_MODE aaMode = DWriteMapFontQuality(extraFontFlag);
		if (aaMode == D2D1_TEXT_ANTIALIAS_MODE_CLEARTYPE && renderingParams->customRenderingParams) {
			pRenderTarget->SetTextRenderingParams(renderingParams->customRenderingParams.Get());
		} else if (renderingParams->defaultRenderingParams) {
			pRenderTarget->SetTextRenderingParams(renderingParams->defaultRenderingParams.Get());
		}
		pRenderTarget->SetTextAntialiasMode(aaMode);
	}
}

int SurfaceD2D::LogPixelsY() {
	return logPixelsY;
}

void SurfaceD2D::SetDeviceScaleFactor(const ID2D1RenderTarget *const pD2D1RenderTarget) noexcept {
	FLOAT dpiX = 0.f;
	FLOAT dpiY = 0.f;
	pD2D1RenderTarget->GetDpi(&dpiX, &dpiY);
	deviceScaleFactor = static_cast<int>(dpiX / dpiDefault);
}

int SurfaceD2D::PixelDivisions() {
	return deviceScaleFactor;
}

int SurfaceD2D::DeviceHeightFont(int points) {
	return ::MulDiv(points, LogPixelsY(), pointsPerInch);
}

constexpr FLOAT mitreLimit = 4.0f;

void SurfaceD2D::LineDraw(Point start, Point end, Stroke stroke) {
	D2DPenColourAlpha(stroke.colour);

	D2D1_STROKE_STYLE_PROPERTIES strokeProps {};
	strokeProps.startCap = D2D1_CAP_STYLE_SQUARE;
	strokeProps.endCap = D2D1_CAP_STYLE_SQUARE;
	strokeProps.dashCap = D2D1_CAP_STYLE_FLAT;
	strokeProps.lineJoin = D2D1_LINE_JOIN_MITER;
	strokeProps.miterLimit = mitreLimit;
	strokeProps.dashStyle = D2D1_DASH_STYLE_SOLID;
	strokeProps.dashOffset = 0;

	// get the stroke style to apply
	if (const StrokeStyle pStrokeStyle = StrokeStyleCreate(strokeProps)) {
		pRenderTarget->DrawLine(
			DPointFromPoint(start),
			DPointFromPoint(end), pBrush.Get(), stroke.WidthF(), pStrokeStyle.Get());
	}
}

Geometry SurfaceD2D::GeometricFigure(const Point *pts, size_t npts, D2D1_FIGURE_BEGIN figureBegin) noexcept {
	Geometry geometry = GeometryCreate();
	if (geometry) {
		if (const GeometrySink sink = GeometrySinkCreate(geometry.Get())) {
			sink->BeginFigure(DPointFromPoint(pts[0]), figureBegin);
			for (size_t i = 1; i < npts; i++) {
				sink->AddLine(DPointFromPoint(pts[i]));
			}
			sink->EndFigure((figureBegin == D2D1_FIGURE_BEGIN_FILLED) ?
				D2D1_FIGURE_END_CLOSED : D2D1_FIGURE_END_OPEN);
			sink->Close();
		}
	}
	return geometry;
}

void SurfaceD2D::PolyLine(const Point *pts, size_t npts, Stroke stroke) {
	PLATFORM_ASSERT(pRenderTarget && (npts > 1));
	if (!pRenderTarget || (npts <= 1)) {
		return;
	}

	const Geometry geometry = GeometricFigure(pts, npts, D2D1_FIGURE_BEGIN_HOLLOW);
	PLATFORM_ASSERT(geometry);
	if (!geometry) {
		return;
	}

	D2DPenColourAlpha(stroke.colour);
	D2D1_STROKE_STYLE_PROPERTIES strokeProps {};
	strokeProps.startCap = D2D1_CAP_STYLE_ROUND;
	strokeProps.endCap = D2D1_CAP_STYLE_ROUND;
	strokeProps.dashCap = D2D1_CAP_STYLE_FLAT;
	strokeProps.lineJoin = D2D1_LINE_JOIN_MITER;
	strokeProps.miterLimit = mitreLimit;
	strokeProps.dashStyle = D2D1_DASH_STYLE_SOLID;
	strokeProps.dashOffset = 0;

	// get the stroke style to apply
	if (const StrokeStyle pStrokeStyle = StrokeStyleCreate(strokeProps)) {
		pRenderTarget->DrawGeometry(geometry.Get(), pBrush.Get(), stroke.WidthF(), pStrokeStyle.Get());
	}
}

void SurfaceD2D::Polygon(const Point *pts, size_t npts, FillStroke fillStroke) {
	PLATFORM_ASSERT(pRenderTarget && (npts > 2));
	if (pRenderTarget) {
		const Geometry geometry = GeometricFigure(pts, npts, D2D1_FIGURE_BEGIN_FILLED);
		PLATFORM_ASSERT(geometry);
		if (geometry) {
			D2DPenColourAlpha(fillStroke.fill.colour);
			pRenderTarget->FillGeometry(geometry.Get(), pBrush.Get());
			D2DPenColourAlpha(fillStroke.stroke.colour);
			pRenderTarget->DrawGeometry(geometry.Get(), pBrush.Get(), fillStroke.stroke.WidthF());
		}
	}
}

void SurfaceD2D::RectangleDraw(PRectangle rc, FillStroke fillStroke) {
	if (!pRenderTarget)
		return;
	const D2D1_RECT_F rect = RectangleFromPRectangle(rc);
	const D2D1_RECT_F rectFill = RectangleInset(rect, fillStroke.stroke.WidthF());
	const float halfStroke = fillStroke.stroke.WidthF() / 2.0f;
	const D2D1_RECT_F rectOutline = RectangleInset(rect, halfStroke);

	D2DPenColourAlpha(fillStroke.fill.colour);
	pRenderTarget->FillRectangle(&rectFill, pBrush.Get());
	D2DPenColourAlpha(fillStroke.stroke.colour);
	pRenderTarget->DrawRectangle(&rectOutline, pBrush.Get(), fillStroke.stroke.WidthF());
}

void SurfaceD2D::RectangleFrame(PRectangle rc, Stroke stroke) {
	if (pRenderTarget) {
		const XYPOSITION halfStroke = stroke.width / 2.0f;
		const D2D1_RECT_F rectangle1 = RectangleFromPRectangle(rc.Inset(halfStroke));
		D2DPenColourAlpha(stroke.colour);
		pRenderTarget->DrawRectangle(&rectangle1, pBrush.Get(), stroke.WidthF());
	}
}

void SurfaceD2D::FillRectangle(PRectangle rc, Fill fill) {
	if (pRenderTarget) {
		D2DPenColourAlpha(fill.colour);
		const D2D1_RECT_F rectangle = RectangleFromPRectangle(rc);
		pRenderTarget->FillRectangle(&rectangle, pBrush.Get());
	}
}

void SurfaceD2D::FillRectangleAligned(PRectangle rc, Fill fill) {
	FillRectangle(PixelAlign(rc, PixelDivisions()), fill);
}

void SurfaceD2D::FillRectangle(PRectangle rc, Surface &surfacePattern) {
	SurfaceD2D *psurfOther = dynamic_cast<SurfaceD2D *>(&surfacePattern);
	PLATFORM_ASSERT(psurfOther);
	if (!psurfOther) {
		throw std::runtime_error("SurfaceD2D::FillRectangle: wrong Surface type.");
	}
	ComPtr<ID2D1Bitmap> pBitmap;
	HRESULT hr = psurfOther->GetBitmap(pBitmap.GetAddressOf());
	if (SUCCEEDED(hr) && pBitmap) {
		ComPtr<ID2D1BitmapBrush> pBitmapBrush;
		const D2D1_BITMAP_BRUSH_PROPERTIES brushProperties =
	        D2D1::BitmapBrushProperties(D2D1_EXTEND_MODE_WRAP, D2D1_EXTEND_MODE_WRAP,
			D2D1_BITMAP_INTERPOLATION_MODE_NEAREST_NEIGHBOR);
		// Create the bitmap brush.
		hr = pRenderTarget->CreateBitmapBrush(pBitmap.Get(), brushProperties, pBitmapBrush.GetAddressOf());
		if (SUCCEEDED(hr) && pBitmapBrush) {
			pRenderTarget->FillRectangle(
				RectangleFromPRectangle(rc),
				pBitmapBrush.Get());
		}
	}
}

void SurfaceD2D::RoundedRectangle(PRectangle rc, FillStroke fillStroke) {
	if (pRenderTarget) {
		const FLOAT minDimension = static_cast<FLOAT>(std::min(rc.Width(), rc.Height())) / 2.0f;
		const FLOAT radius = std::min(4.0f, minDimension);
		if (fillStroke.fill.colour == fillStroke.stroke.colour) {
			const D2D1_ROUNDED_RECT roundedRectFill = {
				RectangleFromPRectangle(rc),
				radius, radius };
			D2DPenColourAlpha(fillStroke.fill.colour);
			pRenderTarget->FillRoundedRectangle(roundedRectFill, pBrush.Get());
		} else {
			const D2D1_ROUNDED_RECT roundedRectFill = {
				RectangleFromPRectangle(rc.Inset(1.0)),
				radius-1, radius-1 };
			D2DPenColourAlpha(fillStroke.fill.colour);
			pRenderTarget->FillRoundedRectangle(roundedRectFill, pBrush.Get());

			const D2D1_ROUNDED_RECT roundedRect = {
				RectangleFromPRectangle(rc.Inset(0.5)),
				radius, radius };
			D2DPenColourAlpha(fillStroke.stroke.colour);
			pRenderTarget->DrawRoundedRectangle(roundedRect, pBrush.Get(), fillStroke.stroke.WidthF());
		}
	}
}

void SurfaceD2D::AlphaRectangle(PRectangle rc, XYPOSITION cornerSize, FillStroke fillStroke) {
	const D2D1_RECT_F rect = RectangleFromPRectangle(rc);
	const D2D1_RECT_F rectFill = RectangleInset(rect, fillStroke.stroke.WidthF());
	const float halfStroke = fillStroke.stroke.WidthF() / 2.0f;
	const D2D1_RECT_F rectOutline = RectangleInset(rect, halfStroke);
	if (pRenderTarget) {
		if (cornerSize == 0) {
			// When corner size is zero, draw square rectangle to prevent blurry pixels at corners
			D2DPenColourAlpha(fillStroke.fill.colour);
			pRenderTarget->FillRectangle(rectFill, pBrush.Get());

			D2DPenColourAlpha(fillStroke.stroke.colour);
			pRenderTarget->DrawRectangle(rectOutline, pBrush.Get(), fillStroke.stroke.WidthF());
		} else {
			const float cornerSizeF = static_cast<float>(cornerSize);
			const D2D1_ROUNDED_RECT roundedRectFill = {
				rectFill, cornerSizeF - 1.0f, cornerSizeF - 1.0f };
			D2DPenColourAlpha(fillStroke.fill.colour);
			pRenderTarget->FillRoundedRectangle(roundedRectFill, pBrush.Get());

			const D2D1_ROUNDED_RECT roundedRect = {
				rectOutline, cornerSizeF, cornerSizeF};
			D2DPenColourAlpha(fillStroke.stroke.colour);
			pRenderTarget->DrawRoundedRectangle(roundedRect, pBrush.Get(), fillStroke.stroke.WidthF());
		}
	}
}

void SurfaceD2D::GradientRectangle(PRectangle rc, const std::vector<ColourStop> &stops, GradientOptions options) {
	if (pRenderTarget) {
		D2D1_LINEAR_GRADIENT_BRUSH_PROPERTIES lgbp {
			DPointFromPoint(Point(rc.left, rc.top)), {}
		};
		switch (options) {
		case GradientOptions::leftToRight:
			lgbp.endPoint = DPointFromPoint(Point(rc.right, rc.top));
			break;
		case GradientOptions::topToBottom:
		default:
			lgbp.endPoint = DPointFromPoint(Point(rc.left, rc.bottom));
			break;
		}

		std::vector<D2D1_GRADIENT_STOP> gradientStops;
		for (const ColourStop &stop : stops) {
			gradientStops.push_back({ static_cast<FLOAT>(stop.position), ColorFromColourAlpha(stop.colour) });
		}
		ComPtr<ID2D1GradientStopCollection> pGradientStops;
		HRESULT hr = pRenderTarget->CreateGradientStopCollection(
			gradientStops.data(), static_cast<UINT32>(gradientStops.size()), pGradientStops.GetAddressOf());
		if (FAILED(hr) || !pGradientStops) {
			return;
		}
		ComPtr<ID2D1LinearGradientBrush> pBrushLinear;
		hr = pRenderTarget->CreateLinearGradientBrush(
			lgbp, pGradientStops.Get(), pBrushLinear.GetAddressOf());
		if (SUCCEEDED(hr) && pBrushLinear) {
			const D2D1_RECT_F rectangle = RectangleFromPRectangle(PRectangle(
				std::round(rc.left), rc.top, std::round(rc.right), rc.bottom));
			pRenderTarget->FillRectangle(&rectangle, pBrushLinear.Get());
		}
	}
}

void SurfaceD2D::DrawRGBAImage(PRectangle rc, int width, int height, const unsigned char *pixelsImage) {
	if (pRenderTarget) {
		if (rc.Width() > width)
			rc.left += std::floor((rc.Width() - width) / 2);
		rc.right = rc.left + width;
		if (rc.Height() > height)
			rc.top += std::floor((rc.Height() - height) / 2);
		rc.bottom = rc.top + height;

		std::vector<unsigned char> image(RGBAImage::bytesPerPixel * height * width);
		RGBAImage::BGRAFromRGBA(image.data(), pixelsImage, static_cast<ptrdiff_t>(height) * width);

		ComPtr<ID2D1Bitmap> bitmap;
		const D2D1_SIZE_U size = D2D1::SizeU(width, height);
		const D2D1_BITMAP_PROPERTIES props = {{DXGI_FORMAT_B8G8R8A8_UNORM,
		    D2D1_ALPHA_MODE_PREMULTIPLIED}, 72.0, 72.0};
		const HRESULT hr = pRenderTarget->CreateBitmap(size, image.data(),
                  width * 4, &props, bitmap.GetAddressOf());
		if (SUCCEEDED(hr)) {
			const D2D1_RECT_F rcDestination = RectangleFromPRectangle(rc);
			pRenderTarget->DrawBitmap(bitmap.Get(), rcDestination);
		}
	}
}

void SurfaceD2D::Ellipse(PRectangle rc, FillStroke fillStroke) {
	if (!pRenderTarget)
		return;
	const D2D1_POINT_2F centre = DPointFromPoint(rc.Centre());

	const FLOAT radiusFill = static_cast<FLOAT>((rc.Width() / 2.0f) - fillStroke.stroke.width);
	const D2D1_ELLIPSE ellipseFill = { centre, radiusFill, radiusFill };

	D2DPenColourAlpha(fillStroke.fill.colour);
	pRenderTarget->FillEllipse(ellipseFill, pBrush.Get());

	const FLOAT radiusOutline = static_cast<FLOAT>((rc.Width() / 2.0f) - (fillStroke.stroke.width / 2.0f));
	const D2D1_ELLIPSE ellipseOutline = { centre, radiusOutline, radiusOutline };

	D2DPenColourAlpha(fillStroke.stroke.colour);
	pRenderTarget->DrawEllipse(ellipseOutline, pBrush.Get(), fillStroke.stroke.WidthF());
}

void SurfaceD2D::Stadium(PRectangle rc, FillStroke fillStroke, Ends ends) {
	if (!pRenderTarget)
		return;
	if (rc.Width() < rc.Height()) {
		// Can't draw nice ends so just draw a rectangle
		RectangleDraw(rc, fillStroke);
		return;
	}
	const FLOAT radius = static_cast<FLOAT>(rc.Height() / 2.0);
	const FLOAT radiusFill = radius - fillStroke.stroke.WidthF();
	const FLOAT halfStroke = fillStroke.stroke.WidthF() / 2.0f;
	if (ends == Surface::Ends::semiCircles) {
		const D2D1_RECT_F rect = RectangleFromPRectangle(rc);
		const D2D1_ROUNDED_RECT roundedRectFill = { RectangleInset(rect, fillStroke.stroke.WidthF()),
			radiusFill, radiusFill };
		D2DPenColourAlpha(fillStroke.fill.colour);
		pRenderTarget->FillRoundedRectangle(roundedRectFill, pBrush.Get());

		const D2D1_ROUNDED_RECT roundedRect = { RectangleInset(rect, halfStroke),
			radius, radius };
		D2DPenColourAlpha(fillStroke.stroke.colour);
		pRenderTarget->DrawRoundedRectangle(roundedRect, pBrush.Get(), fillStroke.stroke.WidthF());
	} else {
		const Ends leftSide = static_cast<Ends>(static_cast<int>(ends) & 0xf);
		const Ends rightSide = static_cast<Ends>(static_cast<int>(ends) & 0xf0);
		PRectangle rcInner = rc;
		rcInner.left += radius;
		rcInner.right -= radius;
		const Geometry pathGeometry = GeometryCreate();
		if (!pathGeometry)
			return;
		if (const GeometrySink pSink = GeometrySinkCreate(pathGeometry.Get())) {
			switch (leftSide) {
				case Ends::leftFlat:
					pSink->BeginFigure(DPointFromPoint(Point(rc.left + halfStroke, rc.top + halfStroke)), D2D1_FIGURE_BEGIN_FILLED);
					pSink->AddLine(DPointFromPoint(Point(rc.left + halfStroke, rc.bottom - halfStroke)));
					break;
				case Ends::leftAngle:
					pSink->BeginFigure(DPointFromPoint(Point(rcInner.left + halfStroke, rc.top + halfStroke)), D2D1_FIGURE_BEGIN_FILLED);
					pSink->AddLine(DPointFromPoint(Point(rc.left + halfStroke, rc.Centre().y)));
					pSink->AddLine(DPointFromPoint(Point(rcInner.left + halfStroke, rc.bottom - halfStroke)));
					break;
				case Ends::semiCircles:
				default: {
						pSink->BeginFigure(DPointFromPoint(Point(rcInner.left + halfStroke, rc.top + halfStroke)), D2D1_FIGURE_BEGIN_FILLED);
						D2D1_ARC_SEGMENT segment{};
						segment.point = DPointFromPoint(Point(rcInner.left + halfStroke, rc.bottom - halfStroke));
						segment.size = D2D1::SizeF(radiusFill, radiusFill);
						segment.rotationAngle = 0.0f;
						segment.sweepDirection = D2D1_SWEEP_DIRECTION_COUNTER_CLOCKWISE;
						segment.arcSize = D2D1_ARC_SIZE_SMALL;
						pSink->AddArc(segment);
					}
					break;
			}

			switch (rightSide) {
			case Ends::rightFlat:
				pSink->AddLine(DPointFromPoint(Point(rc.right - halfStroke, rc.bottom - halfStroke)));
				pSink->AddLine(DPointFromPoint(Point(rc.right - halfStroke, rc.top + halfStroke)));
				break;
			case Ends::rightAngle:
				pSink->AddLine(DPointFromPoint(Point(rcInner.right - halfStroke, rc.bottom - halfStroke)));
				pSink->AddLine(DPointFromPoint(Point(rc.right - halfStroke, rc.Centre().y)));
				pSink->AddLine(DPointFromPoint(Point(rcInner.right - halfStroke, rc.top + halfStroke)));
				break;
			case Ends::semiCircles:
			default: {
					pSink->AddLine(DPointFromPoint(Point(rcInner.right - halfStroke, rc.bottom - halfStroke)));
					D2D1_ARC_SEGMENT segment{};
					segment.point = DPointFromPoint(Point(rcInner.right - halfStroke, rc.top + halfStroke));
					segment.size = D2D1::SizeF(radiusFill, radiusFill);
					segment.rotationAngle = 0.0f;
					segment.sweepDirection = D2D1_SWEEP_DIRECTION_COUNTER_CLOCKWISE;
					segment.arcSize = D2D1_ARC_SIZE_SMALL;
					pSink->AddArc(segment);
				}
				break;
			}

			pSink->EndFigure(D2D1_FIGURE_END_CLOSED);

			pSink->Close();
		}
		D2DPenColourAlpha(fillStroke.fill.colour);
		pRenderTarget->FillGeometry(pathGeometry.Get(), pBrush.Get());
		D2DPenColourAlpha(fillStroke.stroke.colour);
		pRenderTarget->DrawGeometry(pathGeometry.Get(), pBrush.Get(), fillStroke.stroke.WidthF());
	}
}

void SurfaceD2D::Copy(PRectangle rc, Point from, Surface &surfaceSource) {
	SurfaceD2D &surfOther = dynamic_cast<SurfaceD2D &>(surfaceSource);
	ComPtr<ID2D1Bitmap> pBitmap;
	const HRESULT hr = surfOther.GetBitmap(pBitmap.GetAddressOf());
	if (SUCCEEDED(hr) && pBitmap) {
		const D2D1_RECT_F rcDestination = RectangleFromPRectangle(rc);
		const D2D1_RECT_F rcSource = RectangleFromPRectangle(PRectangle(
			from.x, from.y, from.x + rc.Width(), from.y + rc.Height()));
		pRenderTarget->DrawBitmap(pBitmap.Get(), rcDestination, 1.0f,
			D2D1_BITMAP_INTERPOLATION_MODE_NEAREST_NEIGHBOR, rcSource);
	}
}

class BlobInline final : public IDWriteInlineObject {
	XYPOSITION width;

	// IUnknown
	STDMETHODIMP QueryInterface(REFIID riid, PVOID *ppv) override;
	STDMETHODIMP_(ULONG)AddRef() override;
	STDMETHODIMP_(ULONG)Release() override;

	// IDWriteInlineObject
	COM_DECLSPEC_NOTHROW STDMETHODIMP Draw(
		void *clientDrawingContext,
		IDWriteTextRenderer *renderer,
		FLOAT originX,
		FLOAT originY,
		BOOL isSideways,
		BOOL isRightToLeft,
		IUnknown *clientDrawingEffect
		) override;
	COM_DECLSPEC_NOTHROW STDMETHODIMP GetMetrics(DWRITE_INLINE_OBJECT_METRICS *metrics) override;
	COM_DECLSPEC_NOTHROW STDMETHODIMP GetOverhangMetrics(DWRITE_OVERHANG_METRICS *overhangs) override;
	COM_DECLSPEC_NOTHROW STDMETHODIMP GetBreakConditions(
		DWRITE_BREAK_CONDITION *breakConditionBefore,
		DWRITE_BREAK_CONDITION *breakConditionAfter) override;
public:
	explicit BlobInline(XYPOSITION width_=0.0f) noexcept : width(width_) {
	}
};

/// Implement IUnknown
STDMETHODIMP BlobInline::QueryInterface(REFIID riid, PVOID *ppv) {
	if (!ppv)
		return E_POINTER;
	// Never called so not checked.
	*ppv = nullptr;
	if (riid == IID_IUnknown)
		*ppv = this;
	if (riid == __uuidof(IDWriteInlineObject))
		*ppv = this;
	if (!*ppv)
		return E_NOINTERFACE;
	return S_OK;
}

STDMETHODIMP_(ULONG) BlobInline::AddRef() {
	// Lifetime tied to Platform methods so ignore any reference operations.
	return 1;
}

STDMETHODIMP_(ULONG) BlobInline::Release() {
	// Lifetime tied to Platform methods so ignore any reference operations.
	return 1;
}

/// Implement IDWriteInlineObject
COM_DECLSPEC_NOTHROW HRESULT STDMETHODCALLTYPE BlobInline::Draw(
	void*,
	IDWriteTextRenderer*,
	FLOAT,
	FLOAT,
	BOOL,
	BOOL,
	IUnknown*) {
	// Since not performing drawing, not necessary to implement
	// Could be implemented by calling back into platform-independent code.
	// This would allow more of the drawing to be mediated through DirectWrite.
	return S_OK;
}

COM_DECLSPEC_NOTHROW HRESULT STDMETHODCALLTYPE BlobInline::GetMetrics(
	DWRITE_INLINE_OBJECT_METRICS *metrics
) {
	if (!metrics)
		return E_POINTER;
	metrics->width = static_cast<FLOAT>(width);
	metrics->height = 2;
	metrics->baseline = 1;
	metrics->supportsSideways = FALSE;
	return S_OK;
}

COM_DECLSPEC_NOTHROW HRESULT STDMETHODCALLTYPE BlobInline::GetOverhangMetrics(
	DWRITE_OVERHANG_METRICS *overhangs
) {
	if (!overhangs)
		return E_POINTER;
	overhangs->left = 0;
	overhangs->top = 0;
	overhangs->right = 0;
	overhangs->bottom = 0;
	return S_OK;
}

COM_DECLSPEC_NOTHROW HRESULT STDMETHODCALLTYPE BlobInline::GetBreakConditions(
	DWRITE_BREAK_CONDITION *breakConditionBefore,
	DWRITE_BREAK_CONDITION *breakConditionAfter
) {
	if (!breakConditionBefore || !breakConditionAfter)
		return E_POINTER;
	// Since not performing 2D layout, not necessary to implement
	*breakConditionBefore = DWRITE_BREAK_CONDITION_NEUTRAL;
	*breakConditionAfter = DWRITE_BREAK_CONDITION_NEUTRAL;
	return S_OK;
}

class ScreenLineLayout : public IScreenLineLayout {
	std::string text;
	std::wstring buffer;
	std::vector<BlobInline> blobs;
	// textLayout depends on blobs so must be declared after blobs so it is destroyed before blobs.
	TextLayout textLayout;
	static void FillTextLayoutFormats(const IScreenLine *screenLine, IDWriteTextLayout *textLayout, std::vector<BlobInline> &blobs);
	static std::wstring ReplaceRepresentation(std::string_view text);
	static UINT32 GetPositionInLayout(std::string_view text, size_t position);
public:
	explicit ScreenLineLayout(const IScreenLine *screenLine);
	// Deleted so ScreenLineLayout objects can not be copied
	ScreenLineLayout(const ScreenLineLayout &) = delete;
	ScreenLineLayout(ScreenLineLayout &&) = delete;
	ScreenLineLayout &operator=(const ScreenLineLayout &) = delete;
	ScreenLineLayout &operator=(ScreenLineLayout &&) = delete;
	~ScreenLineLayout() noexcept override = default;
	size_t PositionFromX(XYPOSITION xDistance, bool charPosition) override;
	XYPOSITION XFromPosition(size_t caretPosition) override;
	std::vector<Interval> FindRangeIntervals(size_t start, size_t end) override;
};

// Each char can have its own style, so we fill the textLayout with the textFormat of each char

void ScreenLineLayout::FillTextLayoutFormats(const IScreenLine *screenLine, IDWriteTextLayout *textLayout, std::vector<BlobInline> &blobs) {
	// Reserve enough entries up front so they are not moved and the pointers handed
	// to textLayout remain valid.
	const ptrdiff_t numRepresentations = screenLine->RepresentationCount();
	std::string_view text = screenLine->Text();
	const ptrdiff_t numTabs = std::count(std::begin(text), std::end(text), '\t');
	blobs.reserve(numRepresentations + numTabs);

	UINT32 layoutPosition = 0;

	for (size_t bytePosition = 0; bytePosition < screenLine->Length();) {
		const unsigned char uch = screenLine->Text()[bytePosition];
		const unsigned int byteCount = UTF8BytesOfLead[uch];
		const UINT32 codeUnits = UTF16LengthFromUTF8ByteCount(byteCount);
		const DWRITE_TEXT_RANGE textRange = { layoutPosition, codeUnits };

		XYPOSITION representationWidth = screenLine->RepresentationWidth(bytePosition);
		if ((representationWidth == 0.0f) && (screenLine->Text()[bytePosition] == '\t')) {
			D2D1_POINT_2F realPt {};
			DWRITE_HIT_TEST_METRICS realCaretMetrics {};
			textLayout->HitTestTextPosition(
				layoutPosition,
				false, // trailing if false, else leading edge
				&realPt.x,
				&realPt.y,
				&realCaretMetrics
			);

			const XYPOSITION nextTab = screenLine->TabPositionAfter(realPt.x);
			representationWidth = nextTab - realPt.x;
		}
		if (representationWidth > 0.0f) {
			blobs.emplace_back(representationWidth);
			textLayout->SetInlineObject(&blobs.back(), textRange);
		};

		const FontDirectWrite *pfm =
			dynamic_cast<const FontDirectWrite *>(screenLine->FontOfPosition(bytePosition));
		if (!pfm) {
			throw std::runtime_error("FillTextLayoutFormats: wrong Font type.");
		}

		const unsigned int fontFamilyNameSize = pfm->pTextFormat->GetFontFamilyNameLength();
		std::wstring fontFamilyName(fontFamilyNameSize, 0);
		const HRESULT hrFamily = pfm->pTextFormat->GetFontFamilyName(fontFamilyName.data(), fontFamilyNameSize + 1);
		if (SUCCEEDED(hrFamily)) {
			textLayout->SetFontFamilyName(fontFamilyName.c_str(), textRange);
		}

		textLayout->SetFontSize(pfm->pTextFormat->GetFontSize(), textRange);
		textLayout->SetFontWeight(pfm->pTextFormat->GetFontWeight(), textRange);
		textLayout->SetFontStyle(pfm->pTextFormat->GetFontStyle(), textRange);

		const unsigned int localeNameSize = pfm->pTextFormat->GetLocaleNameLength();
		std::wstring localeName(localeNameSize, 0);
		const HRESULT hrLocale = pfm->pTextFormat->GetLocaleName(localeName.data(), localeNameSize + 1);
		if (SUCCEEDED(hrLocale)) {
			textLayout->SetLocaleName(localeName.c_str(), textRange);
		}

		textLayout->SetFontStretch(pfm->pTextFormat->GetFontStretch(), textRange);

		IDWriteFontCollection *fontCollection = nullptr;
		if (SUCCEEDED(pfm->pTextFormat->GetFontCollection(&fontCollection))) {
			textLayout->SetFontCollection(fontCollection, textRange);
		}

		bytePosition += byteCount;
		layoutPosition += codeUnits;
	}

}

/* Convert to a wide character string and replace tabs with X to stop DirectWrite tab expansion */

std::wstring ScreenLineLayout::ReplaceRepresentation(std::string_view text) {
	const TextWide wideText(text, CpUtf8);
	std::wstring ws(wideText.buffer, wideText.tlen);
	std::replace(ws.begin(), ws.end(), L'\t', L'X');
	return ws;
}

// Finds the position in the wide character version of the text.

UINT32 ScreenLineLayout::GetPositionInLayout(std::string_view text, size_t position) {
	const std::string_view textUptoPosition = text.substr(0, position);
	return static_cast<UINT32>(UTF16Length(textUptoPosition));
}

ScreenLineLayout::ScreenLineLayout(const IScreenLine *screenLine) {
	// If the text is empty, then no need to go through this function
	if (!screenLine || !screenLine->Length())
		return;

	text = screenLine->Text();

	// Get textFormat
	const FontDirectWrite *pfm = FontDirectWrite::Cast(screenLine->FontOfPosition(0));
	if (!pfm->pTextFormat) {
		return;
	}

	// Convert the string to wstring and replace the original control characters with their representative chars.
	buffer = ReplaceRepresentation(screenLine->Text());

	// Create a text layout
	textLayout = LayoutCreate(
		buffer,
		pfm->pTextFormat.Get(),
		static_cast<FLOAT>(screenLine->Width()),
		static_cast<FLOAT>(screenLine->Height()));
	if (!textLayout) {
		return;
	}

	// Fill the textLayout chars with their own formats
	FillTextLayoutFormats(screenLine, textLayout.Get(), blobs);
}

// Get the position from the provided x

size_t ScreenLineLayout::PositionFromX(XYPOSITION xDistance, bool charPosition) {
	if (!textLayout) {
		return 0;
	}

	// Returns the text position corresponding to the mouse x,y.
	// If hitting the trailing side of a cluster, return the
	// leading edge of the following text position.

	BOOL isTrailingHit = FALSE;
	BOOL isInside = FALSE;
	DWRITE_HIT_TEST_METRICS caretMetrics {};

	textLayout->HitTestPoint(
		static_cast<FLOAT>(xDistance),
		0.0f,
		&isTrailingHit,
		&isInside,
		&caretMetrics
	);

	DWRITE_HIT_TEST_METRICS hitTestMetrics {};
	if (isTrailingHit) {
		FLOAT caretX = 0.0f;
		FLOAT caretY = 0.0f;

		// Uses hit-testing to align the current caret position to a whole cluster,
		// rather than residing in the middle of a base character + diacritic,
		// surrogate pair, or character + UVS.

		// Align the caret to the nearest whole cluster.
		textLayout->HitTestTextPosition(
			caretMetrics.textPosition,
			false,
			&caretX,
			&caretY,
			&hitTestMetrics
		);
	}

	size_t pos;
	if (charPosition) {
		pos = isTrailingHit ? hitTestMetrics.textPosition : caretMetrics.textPosition;
	} else {
		pos = isTrailingHit ? static_cast<size_t>(hitTestMetrics.textPosition) + hitTestMetrics.length : caretMetrics.textPosition;
	}

	// Get the character position in original string
	return UTF8PositionFromUTF16Position(text, pos);
}

// Finds the point of the caret position

XYPOSITION ScreenLineLayout::XFromPosition(size_t caretPosition) {
	if (!textLayout) {
		return 0.0;
	}
	// Convert byte positions to wchar_t positions
	const UINT32 position = GetPositionInLayout(text, caretPosition);

	// Translate text character offset to point x,y.
	DWRITE_HIT_TEST_METRICS caretMetrics {};
	D2D1_POINT_2F pt {};

	textLayout->HitTestTextPosition(
		position,
		false, // trailing if false, else leading edge
		&pt.x,
		&pt.y,
		&caretMetrics
	);

	return pt.x;
}

// Find the selection range rectangles

std::vector<Interval> ScreenLineLayout::FindRangeIntervals(size_t start, size_t end) {
	std::vector<Interval> ret;

	if (!textLayout || (start == end)) {
		return ret;
	}

	// Convert byte positions to wchar_t positions
	const UINT32 startPos = GetPositionInLayout(text, start);
	const UINT32 endPos = GetPositionInLayout(text, end);

	// Find selection range length
	const UINT32 rangeLength = (endPos > startPos) ? (endPos - startPos) : (startPos - endPos);

	// Determine actual number of hit-test ranges
	UINT32 hitTestCount = 2;	// Simple selection often produces just 2 hits

	// First try with 2 elements and if more needed, allocate.
	std::vector<DWRITE_HIT_TEST_METRICS> hitTestMetrics(hitTestCount);
	textLayout->HitTestTextRange(
		startPos,
		rangeLength,
		0, // x
		0, // y
		hitTestMetrics.data(),
		hitTestCount,
		&hitTestCount
	);

	if (hitTestCount == 0) {
		return ret;
	}

	if (hitTestMetrics.size() < hitTestCount) {
		// Allocate enough room to return all hit-test metrics.
		hitTestMetrics.resize(hitTestCount);
		textLayout->HitTestTextRange(
			startPos,
			rangeLength,
			0, // x
			0, // y
			hitTestMetrics.data(),
			hitTestCount,
			&hitTestCount
		);
	}

	// Get the selection ranges behind the text.

	for (size_t i = 0; i < hitTestCount; ++i) {
		// Store selection rectangle
		const DWRITE_HIT_TEST_METRICS &htm = hitTestMetrics[i];
		const Interval selectionInterval { htm.left, htm.left + htm.width };
		ret.push_back(selectionInterval);
	}

	return ret;
}

std::unique_ptr<IScreenLineLayout> SurfaceD2D::Layout(const IScreenLine *screenLine) {
	return std::make_unique<ScreenLineLayout>(screenLine);
}

void SurfaceD2D::DrawTextCommon(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text, int codePageOverride, UINT fuOptions) {
	const FontDirectWrite *pfm = FontDirectWrite::Cast(font_);
	if (pfm->pTextFormat && pRenderTarget && pBrush) {
		// Use Unicode calls
		const int codePageDraw = codePageOverride ? codePageOverride : pfm->CodePageText(mode.codePage);
		const TextWide tbuf(text, codePageDraw);

		SetFontQuality(pfm->extraFontFlag);
		if (fuOptions & ETO_CLIPPED) {
			const D2D1_RECT_F rcClip = RectangleFromPRectangle(rc);
			pRenderTarget->PushAxisAlignedClip(rcClip, D2D1_ANTIALIAS_MODE_ALIASED);
		}

		// Explicitly creating a text layout appears a little faster
		TextLayout pTextLayout = LayoutCreate(
				tbuf.AsView(),
				pfm->pTextFormat.Get(),
				static_cast<FLOAT>(rc.Width()),
				static_cast<FLOAT>(rc.Height()));
		if (pTextLayout) {
			const D2D1_POINT_2F origin = DPointFromPoint(Point(rc.left, ybase - pfm->yAscent));
			pRenderTarget->DrawTextLayout(origin, pTextLayout.Get(), pBrush.Get(), d2dDrawTextOptions);
		}

		if (fuOptions & ETO_CLIPPED) {
			pRenderTarget->PopAxisAlignedClip();
		}
	}
}

void SurfaceD2D::DrawTextNoClip(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text,
	ColourRGBA fore, ColourRGBA back) {
	if (pRenderTarget) {
		FillRectangleAligned(rc, back);
		D2DPenColourAlpha(fore);
		DrawTextCommon(rc, font_, ybase, text, 0, ETO_OPAQUE);
	}
}

void SurfaceD2D::DrawTextClipped(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text,
	ColourRGBA fore, ColourRGBA back) {
	if (pRenderTarget) {
		FillRectangleAligned(rc, back);
		D2DPenColourAlpha(fore);
		DrawTextCommon(rc, font_, ybase, text, 0, ETO_OPAQUE | ETO_CLIPPED);
	}
}

void SurfaceD2D::DrawTextTransparent(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text,
	ColourRGBA fore) {
	// Avoid drawing spaces in transparent mode
	for (const char ch : text) {
		if (ch != ' ') {
			if (pRenderTarget) {
				D2DPenColourAlpha(fore);
				DrawTextCommon(rc, font_, ybase, text, 0, 0);
			}
			return;
		}
	}
}

HRESULT MeasurePositions(TextPositions &poses, const TextWide &tbuf, IDWriteTextFormat *pTextFormat) {
	if (!pTextFormat) {
		// Unexpected failure like no access to DirectWrite so give up.
		return E_FAIL;
	}

	// Initialize poses for safety.
	std::fill(poses.buffer, poses.buffer + tbuf.tlen, 0.0f);
	// Create a layout
	TextLayout pTextLayout = LayoutCreate(tbuf.AsView(), pTextFormat);
	if (!pTextLayout) {
		return E_FAIL;
	}
	VarBuffer<DWRITE_CLUSTER_METRICS, stackBufferLength> cm(tbuf.tlen);
	UINT32 count = 0;
	const HRESULT hrGetCluster = pTextLayout->GetClusterMetrics(cm.buffer, tbuf.tlen, &count);
	if (!SUCCEEDED(hrGetCluster)) {
		return hrGetCluster;
	}
	const DWRITE_CLUSTER_METRICS * const clusterMetrics = cm.buffer;
	// A cluster may be more than one WCHAR, such as for "ffi" which is a ligature in the Candara font
	XYPOSITION position = 0.0;
	int ti=0;
	for (unsigned int ci=0; ci<count; ci++) {
		for (unsigned int inCluster=0; inCluster<clusterMetrics[ci].length; inCluster++) {
			const float proportion = static_cast<float>(inCluster + 1) / clusterMetrics[ci].length;
			poses.buffer[ti++] = position + clusterMetrics[ci].width * proportion;
		}
		position += clusterMetrics[ci].width;
	}
	PLATFORM_ASSERT(ti == tbuf.tlen);
	return S_OK;
}

void SurfaceD2D::MeasureWidths(const Font *font_, std::string_view text, XYPOSITION *positions) {
	const FontDirectWrite *pfm = FontDirectWrite::Cast(font_);
	const int codePageText = pfm->CodePageText(mode.codePage);
	const TextWide tbuf(text, codePageText);
	TextPositions poses(tbuf.tlen);
	if (FAILED(MeasurePositions(poses, tbuf, pfm->pTextFormat.Get()))) {
		return;
	}
	if (codePageText == CpUtf8) {
		// Map the widths given for UTF-16 characters back onto the UTF-8 input string
		size_t i = 0;
		for (int ui = 0; ui < tbuf.tlen; ui++) {
			const unsigned char uch = text[i];
			const unsigned int byteCount = UTF8BytesOfLead[uch];
			if (byteCount == 4) {	// Non-BMP
				ui++;
			}
			for (unsigned int bytePos=0; (bytePos<byteCount) && (i<text.length()) && (ui<tbuf.tlen); bytePos++) {
				positions[i++] = poses.buffer[ui];
			}
		}
		const XYPOSITION lastPos = (i > 0) ? positions[i - 1] : 0.0;
		while (i<text.length()) {
			positions[i++] = lastPos;
		}
	} else if (!IsDBCSCodePage(codePageText)) {

		// One char per position
		PLATFORM_ASSERT(text.length() == static_cast<size_t>(tbuf.tlen));
		for (int kk=0; kk<tbuf.tlen; kk++) {
			positions[kk] = poses.buffer[kk];
		}

	} else {

		// May be one or two bytes per position
		int ui = 0;
		for (size_t i=0; i<text.length() && ui<tbuf.tlen;) {
			positions[i] = poses.buffer[ui];
			if (DBCSIsLeadByte(codePageText, text[i])) {
				positions[i+1] = poses.buffer[ui];
				i += 2;
			} else {
				i++;
			}

			ui++;
		}
	}
}

XYPOSITION SurfaceD2D::WidthText(const Font *font_, std::string_view text) {
	FLOAT width = 1.0;
	const FontDirectWrite *pfm = FontDirectWrite::Cast(font_);
	if (pfm->pTextFormat) {
		const TextWide tbuf(text, pfm->CodePageText(mode.codePage));
		// Create a layout
		if (TextLayout pTextLayout = LayoutCreate(tbuf.AsView(), pfm->pTextFormat.Get())) {
			DWRITE_TEXT_METRICS textMetrics;
			if (SUCCEEDED(pTextLayout->GetMetrics(&textMetrics)))
				width = textMetrics.widthIncludingTrailingWhitespace;
		}
	}
	return width;
}

void SurfaceD2D::DrawTextNoClipUTF8(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text,
	ColourRGBA fore, ColourRGBA back) {
	if (pRenderTarget) {
		FillRectangleAligned(rc, back);
		D2DPenColourAlpha(fore);
		DrawTextCommon(rc, font_, ybase, text, CpUtf8, ETO_OPAQUE);
	}
}

void SurfaceD2D::DrawTextClippedUTF8(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text,
	ColourRGBA fore, ColourRGBA back) {
	if (pRenderTarget) {
		FillRectangleAligned(rc, back);
		D2DPenColourAlpha(fore);
		DrawTextCommon(rc, font_, ybase, text, CpUtf8, ETO_OPAQUE | ETO_CLIPPED);
	}
}

void SurfaceD2D::DrawTextTransparentUTF8(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text,
	ColourRGBA fore) {
	// Avoid drawing spaces in transparent mode
	for (const char ch : text) {
		if (ch != ' ') {
			if (pRenderTarget) {
				D2DPenColourAlpha(fore);
				DrawTextCommon(rc, font_, ybase, text, CpUtf8, 0);
			}
			return;
		}
	}
}

void SurfaceD2D::MeasureWidthsUTF8(const Font *font_, std::string_view text, XYPOSITION *positions) {
	const FontDirectWrite *pfm = FontDirectWrite::Cast(font_);
	const TextWide tbuf(text, CpUtf8);
	TextPositions poses(tbuf.tlen);
	if (FAILED(MeasurePositions(poses, tbuf, pfm->pTextFormat.Get()))) {
		return;
	}
	// Map the widths given for UTF-16 characters back onto the UTF-8 input string
	size_t i = 0;
	for (int ui = 0; ui < tbuf.tlen; ui++) {
		const unsigned char uch = text[i];
		const unsigned int byteCount = UTF8BytesOfLead[uch];
		if (byteCount == 4) {	// Non-BMP
			ui++;
			PLATFORM_ASSERT(ui < tbuf.tlen);
		}
		for (unsigned int bytePos=0; (bytePos<byteCount) && (i<text.length()) && (ui < tbuf.tlen); bytePos++) {
			positions[i++] = poses.buffer[ui];
		}
	}
	const XYPOSITION lastPos = (i > 0) ? positions[i - 1] : 0.0;
	while (i < text.length()) {
		positions[i++] = lastPos;
	}
}

XYPOSITION SurfaceD2D::WidthTextUTF8(const Font * font_, std::string_view text) {
	FLOAT width = 1.0;
	const FontDirectWrite *pfm = FontDirectWrite::Cast(font_);
	if (pfm->pTextFormat) {
		const TextWide tbuf(text, CpUtf8);
		// Create a layout
		if (TextLayout pTextLayout = LayoutCreate(tbuf.AsView(), pfm->pTextFormat.Get())) {
			DWRITE_TEXT_METRICS textMetrics;
			if (SUCCEEDED(pTextLayout->GetMetrics(&textMetrics)))
				width = textMetrics.widthIncludingTrailingWhitespace;
		}
	}
	return width;
}

XYPOSITION SurfaceD2D::Ascent(const Font *font_) {
	const FontDirectWrite *pfm = FontDirectWrite::Cast(font_);
	return std::ceil(pfm->yAscent);
}

XYPOSITION SurfaceD2D::Descent(const Font *font_) {
	const FontDirectWrite *pfm = FontDirectWrite::Cast(font_);
	return std::ceil(pfm->yDescent);
}

XYPOSITION SurfaceD2D::InternalLeading(const Font *font_) {
	const FontDirectWrite *pfm = FontDirectWrite::Cast(font_);
	return std::floor(pfm->yInternalLeading);
}

XYPOSITION SurfaceD2D::Height(const Font *font_) {
	const FontDirectWrite *pfm = FontDirectWrite::Cast(font_);
	return std::ceil(pfm->yAscent) + std::ceil(pfm->yDescent);
}

XYPOSITION SurfaceD2D::AverageCharWidth(const Font *font_) {
	FLOAT width = 1.0;
	const FontDirectWrite *pfm = FontDirectWrite::Cast(font_);
	if (pfm->pTextFormat) {
		// Create a layout
		static constexpr std::wstring_view wsvAllAlpha = L"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
		if (TextLayout pTextLayout = LayoutCreate(wsvAllAlpha, pfm->pTextFormat.Get())) {
			DWRITE_TEXT_METRICS textMetrics;
			if (SUCCEEDED(pTextLayout->GetMetrics(&textMetrics)))
				width = textMetrics.width / wsvAllAlpha.length();
		}
	}
	return width;
}

void SurfaceD2D::SetClip(PRectangle rc) {
	if (pRenderTarget) {
		const D2D1_RECT_F rcClip = RectangleFromPRectangle(rc);
		pRenderTarget->PushAxisAlignedClip(rcClip, D2D1_ANTIALIAS_MODE_ALIASED);
		clipsActive++;
	}
}

void SurfaceD2D::PopClip() {
	if (pRenderTarget) {
		PLATFORM_ASSERT(clipsActive > 0);
		pRenderTarget->PopAxisAlignedClip();
		clipsActive--;
	}
}

void SurfaceD2D::FlushCachedState() {
}

void SurfaceD2D::FlushDrawing() {
	if (pRenderTarget) {
		pRenderTarget->Flush();
	}
}

void SurfaceD2D::SetRenderingParams(std::shared_ptr<RenderingParams> renderingParams_) {
	renderingParams = std::move(renderingParams_);
}

#endif

}

namespace Scintilla::Internal {

#if defined(USE_D2D)
IDWriteFactory1 *pIDWriteFactory = nullptr;
ID2D1Factory1 *pD2DFactory = nullptr;

HRESULT CreateD3D(D3D11Device &device) noexcept {
	device = nullptr;
	if (!fnDCD) {
		return E_FAIL;
	}

	const D3D_FEATURE_LEVEL featureLevels[] = {
		D3D_FEATURE_LEVEL_11_1,
		D3D_FEATURE_LEVEL_11_0,
		D3D_FEATURE_LEVEL_10_1,
		D3D_FEATURE_LEVEL_10_0,
		D3D_FEATURE_LEVEL_9_3,
		D3D_FEATURE_LEVEL_9_2,
		D3D_FEATURE_LEVEL_9_1
	};

	// Create device.
	// Try for a hardware device but, if that fails, fall back to the Warp software rasterizer.
	ComPtr<ID3D11Device> upDevice;
	HRESULT hr = S_OK;
	const D3D_DRIVER_TYPE typesToTry[] = { D3D_DRIVER_TYPE_HARDWARE, D3D_DRIVER_TYPE_WARP };
	for (const D3D_DRIVER_TYPE type : typesToTry) {
		hr = fnDCD(nullptr,
			type,
			{},
			D3D11_CREATE_DEVICE_BGRA_SUPPORT,
			featureLevels,
			ARRAYSIZE(featureLevels),
			D3D11_SDK_VERSION,
			upDevice.GetAddressOf(),
			nullptr,
			nullptr);
		if (SUCCEEDED(hr))
			break;
	}
	if (FAILED(hr)) {
		Platform::DebugPrintf("Failed to create D3D11 device 0x%lx\n", hr);
		return hr;
	}

	// Convert from D3D11 to D3D11.1
	hr = upDevice.As(&device);
	if (FAILED(hr)) {
		Platform::DebugPrintf("Failed to create D3D11.1 device 0x%lx\n", hr);
	}
	return hr;
}

bool LoadD2D() noexcept {
	static std::once_flag once;
	try {
		std::call_once(once, LoadD2DOnce);
	}
	catch (...) {
		// ignore
	}
	return pIDWriteFactory && pD2DFactory;
}

void ReleaseD2D() noexcept {
	ReleaseUnknown(pIDWriteFactory);
	ReleaseUnknown(pD2DFactory);
	ReleaseLibrary(hDLLDWrite);
	ReleaseLibrary(hDLLD3D);
	ReleaseLibrary(hDLLD2D);
}

HRESULT CreateDCRenderTarget(const D2D1_RENDER_TARGET_PROPERTIES *renderTargetProperties, DCRenderTarget &dcRT) noexcept {
	return pD2DFactory->CreateDCRenderTarget(renderTargetProperties, dcRT.ReleaseAndGetAddressOf());
}

BrushSolid BrushSolidCreate(ID2D1RenderTarget *pTarget, COLORREF colour) noexcept {
	BrushSolid brush;
	const D2D_COLOR_F col = ColorFromColourAlpha(ColourRGBA::FromRGB(colour));
	if (FAILED(pTarget->CreateSolidColorBrush(col, brush.GetAddressOf()))) {
		return {};
	}
	return brush;
}

Geometry GeometryCreate() noexcept {
	Geometry geometry;
	if (FAILED(pD2DFactory->CreatePathGeometry(geometry.GetAddressOf()))) {
		return {};
	}
	return geometry;
}

GeometrySink GeometrySinkCreate(ID2D1PathGeometry *geometry) noexcept {
	GeometrySink sink;
	if (FAILED(geometry->Open(sink.GetAddressOf()))) {
		return {};
	}
	return sink;
}

StrokeStyle StrokeStyleCreate(const D2D1_STROKE_STYLE_PROPERTIES &strokeStyleProperties) noexcept {
	StrokeStyle strokeStyle;
	const HRESULT hr = pD2DFactory->CreateStrokeStyle(
		strokeStyleProperties, nullptr, 0, strokeStyle.GetAddressOf());
	if (FAILED(hr)) {
		return {};
	}
	return strokeStyle;
}

TextLayout LayoutCreate(std::wstring_view wsv, IDWriteTextFormat *pTextFormat, FLOAT maxWidth, FLOAT maxHeight) noexcept {
	TextLayout layout;
	const HRESULT hr = pIDWriteFactory->CreateTextLayout(wsv.data(), static_cast<UINT32>(wsv.length()),
		pTextFormat, maxWidth, maxHeight, layout.GetAddressOf());
	if (FAILED(hr)) {
		return {};
	}
	return layout;
}

#endif

std::shared_ptr<Font> Font::Allocate(const FontParameters &fp) {
#if defined(USE_D2D)
	if (fp.technology != Technology::Default) {
		return std::make_shared<FontDirectWrite>(fp);
	}
#endif
	return FontGDI_Allocate(fp);
}

std::unique_ptr<Surface> Surface::Allocate([[maybe_unused]] Technology technology) {
#if defined(USE_D2D)
	if (technology != Technology::Default) {
		return std::make_unique<SurfaceD2D>();
	}
#endif
	return SurfaceGDI_Allocate();
}

}


================================================
FILE: Libraries/scintilla/win32/SurfaceD2D.h
================================================
// Scintilla source code edit control
/** @file SurfaceD2D.h
 ** Definitions for drawing to Direct2D on Windows.
 **/
// Copyright 1998-2011 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#ifndef SURFACED2D_H
#define SURFACED2D_H

namespace Scintilla::Internal {

extern bool LoadD2D() noexcept;
extern void ReleaseD2D() noexcept;
extern ID2D1Factory1 *pD2DFactory;
extern IDWriteFactory1 *pIDWriteFactory;

using DCRenderTarget = ComPtr<ID2D1DCRenderTarget>;

using D3D11Device = ComPtr<ID3D11Device1>;

HRESULT CreateDCRenderTarget(const D2D1_RENDER_TARGET_PROPERTIES *renderTargetProperties, DCRenderTarget &dcRT) noexcept;
extern HRESULT CreateD3D(D3D11Device &device) noexcept;

using WriteRenderingParams = ComPtr<IDWriteRenderingParams1>;

struct RenderingParams {
	WriteRenderingParams defaultRenderingParams;
	WriteRenderingParams customRenderingParams;
};

struct ISetRenderingParams {
	virtual void SetRenderingParams(std::shared_ptr<RenderingParams> renderingParams_) = 0;
};

using BrushSolid = ComPtr<ID2D1SolidColorBrush>;
using Geometry = ComPtr<ID2D1PathGeometry>;
using GeometrySink = ComPtr<ID2D1GeometrySink>;
using StrokeStyle = ComPtr<ID2D1StrokeStyle>;
using TextLayout = ComPtr<IDWriteTextLayout>;

BrushSolid BrushSolidCreate(ID2D1RenderTarget *pTarget, COLORREF colour) noexcept;
Geometry GeometryCreate() noexcept;
GeometrySink GeometrySinkCreate(ID2D1PathGeometry *geometry) noexcept;
StrokeStyle StrokeStyleCreate(const D2D1_STROKE_STYLE_PROPERTIES &strokeStyleProperties) noexcept;
TextLayout LayoutCreate(std::wstring_view wsv, IDWriteTextFormat *pTextFormat, FLOAT maxWidth=10000.0F, FLOAT maxHeight=1000.0F) noexcept;

}

#endif


================================================
FILE: Libraries/scintilla/win32/SurfaceGDI.cxx
================================================
// Scintilla source code edit control
/** @file SurfaceGDI.cxx
 ** Implementation of drawing to GDI on Windows.
 **/
// Copyright 1998-2003 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#include <cstddef>
#include <cstdlib>
#include <cstdint>
#include <cstring>
#include <cstdio>
#include <cstdarg>
#include <ctime>
#include <cmath>
#include <climits>

#include <string_view>
#include <vector>
#include <map>
#include <optional>
#include <algorithm>
#include <iterator>
#include <memory>
#include <mutex>

// Want to use std::min and std::max so don't want Windows.h version of min and max
#if !defined(NOMINMAX)
#define NOMINMAX
#endif
#undef _WIN32_WINNT
#define _WIN32_WINNT 0x0A00
#undef WINVER
#define WINVER 0x0A00
#define WIN32_LEAN_AND_MEAN 1
#include <windows.h>
#include <commctrl.h>
#include <richedit.h>
#include <windowsx.h>
#include <shellscalingapi.h>

#include "ScintillaTypes.h"

#include "Debugging.h"
#include "Geometry.h"
#include "Platform.h"
#include "XPM.h"
#include "UniConversion.h"
#include "DBCS.h"

#include "WinTypes.h"
#include "PlatWin.h"
#include "SurfaceGDI.h"

using namespace Scintilla;
using namespace Scintilla::Internal;

// All file hidden in unnamed namespace except for FontGDI_Allocate and SurfaceGDI_Allocate
namespace {

constexpr Supports SupportsGDI[] = {
	Supports::PixelModification,
};

constexpr BYTE Win32MapFontQuality(FontQuality extraFontFlag) noexcept {
	switch (extraFontFlag & FontQuality::QualityMask) {

	case FontQuality::QualityNonAntialiased:
		return NONANTIALIASED_QUALITY;

	case FontQuality::QualityAntialiased:
		return ANTIALIASED_QUALITY;

	case FontQuality::QualityLcdOptimized:
		return CLEARTYPE_QUALITY;

	default:
		return DEFAULT_QUALITY;
	}
}

void SetLogFont(LOGFONTW &lf, const char *faceName, CharacterSet characterSet, XYPOSITION size, FontWeight weight, bool italic, FontQuality extraFontFlag) {
	lf = LOGFONTW();
	// The negative is to allow for leading
	lf.lfHeight = -(std::abs(std::lround(size)));
	lf.lfWeight = static_cast<LONG>(weight);
	lf.lfItalic = italic ? 1 : 0;
	lf.lfCharSet = static_cast<BYTE>(characterSet);
	lf.lfQuality = Win32MapFontQuality(extraFontFlag);
	UTF16FromUTF8(faceName, lf.lfFaceName, LF_FACESIZE);
}

struct FontGDI : public FontWin {
	HFONT hfont = {};
	CharacterSet characterSet = CharacterSet::Ansi;
	FontGDI(HFONT hfont_, CharacterSet characterSet_) noexcept : hfont(hfont_), characterSet(characterSet_) {
		// Takes ownership and deletes the font
	}
	explicit FontGDI(const FontParameters &fp) : characterSet(fp.characterSet) {
		LOGFONTW lf;
		SetLogFont(lf, fp.faceName, fp.characterSet, fp.size, fp.weight, fp.italic, fp.extraFontFlag);
		hfont = ::CreateFontIndirectW(&lf);
	}
	// Deleted so FontGDI objects can not be copied.
	FontGDI(const FontGDI &) = delete;
	FontGDI(FontGDI &&) = delete;
	FontGDI &operator=(const FontGDI &) = delete;
	FontGDI &operator=(FontGDI &&) = delete;
	~FontGDI() noexcept override {
		if (hfont)
			::DeleteObject(hfont);
	}
	[[nodiscard]] HFONT HFont() const noexcept override {
		// Duplicating hfont
		LOGFONTW lf = {};
		if (0 == ::GetObjectW(hfont, sizeof(lf), &lf)) {
			return {};
		}
		return ::CreateFontIndirectW(&lf);
	}
	[[nodiscard]] std::unique_ptr<FontWin> Duplicate() const override {
		HFONT hfontCopy = HFont();
		return std::make_unique<FontGDI>(hfontCopy, characterSet);
	}
	[[nodiscard]] CharacterSet GetCharacterSet() const noexcept override {
		return characterSet;
	}
};

class SurfaceGDI : public Surface {
	SurfaceMode mode;
	HDC hdc{};
	bool hdcOwned = false;
	HPEN pen{};
	HPEN penOld{};
	HBRUSH brush{};
	HBRUSH brushOld{};
	HFONT fontOld{};
	HBITMAP bitmap{};
	HBITMAP bitmapOld{};

	int logPixelsY = USER_DEFAULT_SCREEN_DPI;

	static constexpr int maxWidthMeasure = INT_MAX;
	// There appears to be a 16 bit string length limit in GDI on NT.
	static constexpr int maxLenText = 65535;

	void PenColour(ColourRGBA fore, XYPOSITION widthStroke) noexcept;

	void BrushColour(ColourRGBA back) noexcept;
	void SetFont(const Font *font_);
	void Clear() noexcept;

public:
	SurfaceGDI() noexcept = default;
	SurfaceGDI(HDC hdcCompatible, int width, int height, SurfaceMode mode_, int logPixelsY_) noexcept;
	// Deleted so SurfaceGDI objects can not be copied.
	SurfaceGDI(const SurfaceGDI &) = delete;
	SurfaceGDI(SurfaceGDI &&) = delete;
	SurfaceGDI &operator=(const SurfaceGDI &) = delete;
	SurfaceGDI &operator=(SurfaceGDI &&) = delete;

	~SurfaceGDI() noexcept override;

	void Init(WindowID wid) override;
	void Init(SurfaceID sid, WindowID wid) override;
	std::unique_ptr<Surface> AllocatePixMap(int width, int height) override;

	void SetMode(SurfaceMode mode_) override;

	void Release() noexcept override;
	int SupportsFeature(Supports feature) noexcept override;
	bool Initialised() override;
	int LogPixelsY() override;
	int PixelDivisions() override;
	int DeviceHeightFont(int points) override;
	void LineDraw(Point start, Point end, Stroke stroke) override;
	void PolyLine(const Point *pts, size_t npts, Stroke stroke) override;
	void Polygon(const Point *pts, size_t npts, FillStroke fillStroke) override;
	void RectangleDraw(PRectangle rc, FillStroke fillStroke) override;
	void RectangleFrame(PRectangle rc, Stroke stroke) override;
	void FillRectangle(PRectangle rc, Fill fill) override;
	void FillRectangleAligned(PRectangle rc, Fill fill) override;
	void FillRectangle(PRectangle rc, Surface &surfacePattern) override;
	void RoundedRectangle(PRectangle rc, FillStroke fillStroke) override;
	void AlphaRectangle(PRectangle rc, XYPOSITION cornerSize, FillStroke fillStroke) override;
	void GradientRectangle(PRectangle rc, const std::vector<ColourStop> &stops, GradientOptions options) override;
	void DrawRGBAImage(PRectangle rc, int width, int height, const unsigned char *pixelsImage) override;
	void Ellipse(PRectangle rc, FillStroke fillStroke) override;
	void Stadium(PRectangle rc, FillStroke fillStroke, Ends ends) override;
	void Copy(PRectangle rc, Point from, Surface &surfaceSource) override;

	std::unique_ptr<IScreenLineLayout> Layout(const IScreenLine *screenLine) override;

	void DrawTextCommon(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text, UINT fuOptions);
	void DrawTextNoClip(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text, ColourRGBA fore, ColourRGBA back) override;
	void DrawTextClipped(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text, ColourRGBA fore, ColourRGBA back) override;
	void DrawTextTransparent(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text, ColourRGBA fore) override;
	void MeasureWidths(const Font *font_, std::string_view text, XYPOSITION *positions) override;
	XYPOSITION WidthText(const Font *font_, std::string_view text) override;

	void DrawTextCommonUTF8(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text, UINT fuOptions);
	void DrawTextNoClipUTF8(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text, ColourRGBA fore, ColourRGBA back) override;
	void DrawTextClippedUTF8(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text, ColourRGBA fore, ColourRGBA back) override;
	void DrawTextTransparentUTF8(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text, ColourRGBA fore) override;
	void MeasureWidthsUTF8(const Font *font_, std::string_view text, XYPOSITION *positions) override;
	XYPOSITION WidthTextUTF8(const Font *font_, std::string_view text) override;

	XYPOSITION Ascent(const Font *font_) override;
	XYPOSITION Descent(const Font *font_) override;
	XYPOSITION InternalLeading(const Font *font_) override;
	XYPOSITION Height(const Font *font_) override;
	XYPOSITION AverageCharWidth(const Font *font_) override;

	void SetClip(PRectangle rc) override;
	void PopClip() override;
	void FlushCachedState() override;
	void FlushDrawing() override;

	void DrawLineDots(PRectangle rc, ColourRGBA color) override; //Au
	void* get_hdc() { return hdc; } //Au
};

SurfaceGDI::SurfaceGDI(HDC hdcCompatible, int width, int height, SurfaceMode mode_, int logPixelsY_) noexcept {
	hdc = ::CreateCompatibleDC(hdcCompatible);
	hdcOwned = true;
	bitmap = ::CreateCompatibleBitmap(hdcCompatible, width, height);
	bitmapOld = SelectBitmap(hdc, bitmap);
	::SetTextAlign(hdc, TA_BASELINE);
	mode = mode_;
	logPixelsY = logPixelsY_;
}

SurfaceGDI::~SurfaceGDI() noexcept {
	Clear();
}

void SurfaceGDI::Clear() noexcept {
	if (penOld) {
		::SelectObject(hdc, penOld);
		::DeleteObject(pen);
		penOld = {};
	}
	pen = {};
	if (brushOld) {
		::SelectObject(hdc, brushOld);
		::DeleteObject(brush);
		brushOld = {};
	}
	brush = {};
	if (fontOld) {
		// Fonts are not deleted as they are owned by a Font object
		::SelectObject(hdc, fontOld);
		fontOld = {};
	}
	if (bitmapOld) {
		::SelectObject(hdc, bitmapOld);
		::DeleteObject(bitmap);
		bitmapOld = {};
	}
	bitmap = {};
	if (hdcOwned) {
		::DeleteDC(hdc);
		hdc = {};
		hdcOwned = false;
	}
}

void SurfaceGDI::Release() noexcept {
	Clear();
}

int SurfaceGDI::SupportsFeature(Supports feature) noexcept {
	for (const Supports f : SupportsGDI) {
		if (f == feature)
			return 1;
	}
	return 0;
}

bool SurfaceGDI::Initialised() {
	return hdc;
}

void SurfaceGDI::Init(WindowID wid) {
	Release();
	hdc = ::CreateCompatibleDC({});
	hdcOwned = true;
	::SetTextAlign(hdc, TA_BASELINE);
	logPixelsY = DpiForWindow(wid);
}

void SurfaceGDI::Init(SurfaceID sid, WindowID wid) {
	Release();
	hdc = static_cast<HDC>(sid);
	::SetTextAlign(hdc, TA_BASELINE);
	// Windows on screen are scaled but printers are not.
	const bool printing = ::GetDeviceCaps(hdc, TECHNOLOGY) != DT_RASDISPLAY;
	logPixelsY = printing ? ::GetDeviceCaps(hdc, LOGPIXELSY) : DpiForWindow(wid);
}

std::unique_ptr<Surface> SurfaceGDI::AllocatePixMap(int width, int height) {
	return std::make_unique<SurfaceGDI>(hdc, width, height, mode, logPixelsY);
}

void SurfaceGDI::SetMode(SurfaceMode mode_) {
	mode = mode_;
}

void SurfaceGDI::PenColour(ColourRGBA fore, XYPOSITION widthStroke) noexcept {
	if (pen) {
		::SelectObject(hdc, penOld);
		::DeleteObject(pen);
		pen = {};
		penOld = {};
	}
	const DWORD penWidth = std::lround(widthStroke);
	const COLORREF penColour = fore.OpaqueRGB();
	if (widthStroke > 1) {
		const LOGBRUSH brushParameters{ BS_SOLID, penColour, 0 };
		pen = ::ExtCreatePen(PS_GEOMETRIC | PS_ENDCAP_ROUND | PS_JOIN_MITER,
			penWidth,
			&brushParameters,
			0,
			nullptr);
	} else {
		pen = ::CreatePen(PS_INSIDEFRAME, penWidth, penColour);
	}
	penOld = SelectPen(hdc, pen);
}

void SurfaceGDI::BrushColour(ColourRGBA back) noexcept {
	if (brush) {
		::SelectObject(hdc, brushOld);
		::DeleteObject(brush);
		brush = {};
		brushOld = {};
	}
	brush = ::CreateSolidBrush(back.OpaqueRGB());
	brushOld = SelectBrush(hdc, brush);
}

void SurfaceGDI::SetFont(const Font *font_) {
	const FontGDI *pfm = dynamic_cast<const FontGDI *>(font_);
	PLATFORM_ASSERT(pfm);
	if (!pfm) {
		throw std::runtime_error("SurfaceGDI::SetFont: wrong Font type.");
	}
	if (fontOld) {
		SelectFont(hdc, pfm->hfont);
	} else {
		fontOld = SelectFont(hdc, pfm->hfont);
	}
}

int SurfaceGDI::LogPixelsY() {
	return logPixelsY;
}

int SurfaceGDI::PixelDivisions() {
	// Win32 uses device pixels.
	return 1;
}

int SurfaceGDI::DeviceHeightFont(int points) {
	return ::MulDiv(points, LogPixelsY(), pointsPerInch);
}

void SurfaceGDI::LineDraw(Point start, Point end, Stroke stroke) {
	PenColour(stroke.colour, stroke.width);
	::MoveToEx(hdc, std::lround(std::floor(start.x)), std::lround(std::floor(start.y)), nullptr);
	::LineTo(hdc, std::lround(std::floor(end.x)), std::lround(std::floor(end.y)));
}

void SurfaceGDI::PolyLine(const Point *pts, size_t npts, Stroke stroke) {
	PLATFORM_ASSERT(npts > 1);
	if (npts <= 1) {
		return;
	}
	PenColour(stroke.colour, stroke.width);
	std::vector<POINT> outline;
	std::transform(pts, pts + npts, std::back_inserter(outline), POINTFromPoint);
	::Polyline(hdc, outline.data(), static_cast<int>(npts));
}

void SurfaceGDI::Polygon(const Point *pts, size_t npts, FillStroke fillStroke) {
	PenColour(fillStroke.stroke.colour.WithoutAlpha(), fillStroke.stroke.width);
	BrushColour(fillStroke.fill.colour.WithoutAlpha());
	std::vector<POINT> outline;
	std::transform(pts, pts + npts, std::back_inserter(outline), POINTFromPoint);
	::Polygon(hdc, outline.data(), static_cast<int>(npts));
}

void SurfaceGDI::RectangleDraw(PRectangle rc, FillStroke fillStroke) {
	RectangleFrame(rc, fillStroke.stroke);
	FillRectangle(rc.Inset(fillStroke.stroke.width), fillStroke.fill.colour);
}

void SurfaceGDI::RectangleFrame(PRectangle rc, Stroke stroke) {
	BrushColour(stroke.colour);
	const RECT rcw = RectFromPRectangle(rc);
	::FrameRect(hdc, &rcw, brush);
}

void SurfaceGDI::FillRectangle(PRectangle rc, Fill fill) {
	if (fill.colour.IsOpaque()) {
		// Using ExtTextOut rather than a FillRect ensures that no dithering occurs.
		// There is no need to allocate a brush either.
		const RECT rcw = RectFromPRectangle(rc);
		::SetBkColor(hdc, fill.colour.OpaqueRGB());
		::ExtTextOut(hdc, rcw.left, rcw.top, ETO_OPAQUE, &rcw, TEXT(""), 0, nullptr);
	} else {
		AlphaRectangle(rc, 0, FillStroke(fill.colour));
	}
}

void SurfaceGDI::FillRectangleAligned(PRectangle rc, Fill fill) {
	FillRectangle(PixelAlign(rc, 1), fill);
}

//Au: draw dots line
void SurfaceGDI::DrawLineDots(PRectangle rc, ColourRGBA color) {
	const RECT r = RectFromPRectangle(rc);
	auto oldPen = ::SelectObject(hdc, ::CreatePen(PS_DOT, 1, color.AsInteger()));
	::MoveToEx(hdc, r.left, r.top, nullptr); ::LineTo(hdc, r.right, r.top);
	::DeleteObject(::SelectObject(hdc, oldPen));
}

void SurfaceGDI::FillRectangle(PRectangle rc, Surface &surfacePattern) {
	HBRUSH br{};
	if (SurfaceGDI *psgdi = dynamic_cast<SurfaceGDI *>(&surfacePattern); psgdi && psgdi->bitmap) {
		br = ::CreatePatternBrush(psgdi->bitmap);
	} else {	// Something is wrong so display in red
		br = ::CreateSolidBrush(RGB(0xff, 0, 0));
	}
	const RECT rcw = RectFromPRectangle(rc);
	::FillRect(hdc, &rcw, br);
	::DeleteObject(br);
}

void SurfaceGDI::RoundedRectangle(PRectangle rc, FillStroke fillStroke) {
	PenColour(fillStroke.stroke.colour, fillStroke.stroke.width);
	BrushColour(fillStroke.fill.colour);
	const RECT rcw = RectFromPRectangle(rc);
	constexpr int cornerSize = 8;
	::RoundRect(hdc,
		rcw.left + 1, rcw.top,
		rcw.right - 1, rcw.bottom,
		cornerSize, cornerSize);
}

// DIBSection is bitmap with some drawing operations used by SurfaceGDI.
class DIBSection {
	GDIBitMap bm;
	SIZE size{};
	DWORD *pixels = nullptr;
public:
	DIBSection(HDC hdc, SIZE size_) noexcept;
	explicit operator bool() const noexcept {
		return bm && pixels;
	}
	[[nodiscard]] DWORD *Pixels() const noexcept {
		return pixels;
	}
	[[nodiscard]] unsigned char *Bytes() const noexcept {
		return reinterpret_cast<unsigned char *>(pixels);
	}
	[[nodiscard]] HDC DC() const noexcept {
		return bm.DC();
	}
	void SetPixel(LONG x, LONG y, DWORD value) noexcept {
		PLATFORM_ASSERT(x >= 0);
		PLATFORM_ASSERT(y >= 0);
		PLATFORM_ASSERT(x < size.cx);
		PLATFORM_ASSERT(y < size.cy);
		pixels[(y * size.cx) + x] = value;
	}
	void SetSymmetric(LONG x, LONG y, DWORD value) noexcept;
};

DIBSection::DIBSection(HDC hdc, SIZE size_) noexcept : size(size_) {
	// -size.y makes bitmap start from top
	bm.Create(hdc, size.cx, -size.cy, &pixels);
}

void DIBSection::SetSymmetric(LONG x, LONG y, DWORD value) noexcept {
	// Plot a point symmetrically to all 4 quadrants
	const LONG xSymmetric = size.cx - 1 - x;
	const LONG ySymmetric = size.cy - 1 - y;
	SetPixel(x, y, value);
	SetPixel(xSymmetric, y, value);
	SetPixel(x, ySymmetric, value);
	SetPixel(xSymmetric, ySymmetric, value);
}

ColourRGBA GradientValue(const std::vector<ColourStop> &stops, XYPOSITION proportion) noexcept {
	for (size_t stop = 0; stop < stops.size() - 1; stop++) {
		// Loop through each pair of stops
		const XYPOSITION positionStart = stops[stop].position;
		const XYPOSITION positionEnd = stops[stop + 1].position;
		if ((proportion >= positionStart) && (proportion <= positionEnd)) {
			const XYPOSITION proportionInPair = (proportion - positionStart) /
				(positionEnd - positionStart);
			return stops[stop].colour.MixedWith(stops[stop + 1].colour, proportionInPair);
		}
	}
	// Loop should always find a value
	return ColourRGBA();
}

constexpr DWORD dwordFromBGRA(byte b, byte g, byte r, byte a) noexcept {
	constexpr int aShift = 24;
	constexpr int rShift = 16;
	constexpr int gShift = 8;
	return (a << aShift) | (r << rShift) | (g << gShift) | b;
}

constexpr byte AlphaScaled(unsigned char component, unsigned int alpha) noexcept {
	constexpr byte maxByte = 0xFFU;
	return (component * alpha / maxByte) & maxByte;
}

constexpr DWORD dwordMultiplied(ColourRGBA colour) noexcept {
	return dwordFromBGRA(
		AlphaScaled(colour.GetBlue(), colour.GetAlpha()),
		AlphaScaled(colour.GetGreen(), colour.GetAlpha()),
		AlphaScaled(colour.GetRed(), colour.GetAlpha()),
		colour.GetAlpha());
}

constexpr BLENDFUNCTION mergeAlpha = { AC_SRC_OVER, 0, 255, AC_SRC_ALPHA };

void SurfaceGDI::AlphaRectangle(PRectangle rc, XYPOSITION cornerSize, FillStroke fillStroke) {
	// TODO: Implement strokeWidth
	const RECT rcw = RectFromPRectangle(rc);
	const SIZE size = SizeOfRect(rcw);

	if (size.cx > 0) {

		DIBSection section(hdc, size);

		if (section) {

			// Ensure not distorted too much by corners when small
			const LONG corner = std::min(static_cast<LONG>(cornerSize), (std::min(size.cx, size.cy) / 2) - 2);

			constexpr DWORD valEmpty = dwordFromBGRA(0, 0, 0, 0);
			const DWORD valFill = dwordMultiplied(fillStroke.fill.colour);
			const DWORD valOutline = dwordMultiplied(fillStroke.stroke.colour);

			// Draw a framed rectangle
			for (int y = 0; y < size.cy; y++) {
				for (int x = 0; x < size.cx; x++) {
					if ((x == 0) || (x == size.cx - 1) || (y == 0) || (y == size.cy - 1)) {
						section.SetPixel(x, y, valOutline);
					} else {
						section.SetPixel(x, y, valFill);
					}
				}
			}

			// Make the corners transparent
			for (LONG c = 0; c < corner; c++) {
				for (LONG x = 0; x < c + 1; x++) {
					section.SetSymmetric(x, c - x, valEmpty);
				}
			}

			// Draw the corner frame pieces
			for (LONG x = 1; x < corner; x++) {
				section.SetSymmetric(x, corner - x, valOutline);
			}

			GdiAlphaBlend(hdc, rcw.left, rcw.top, size.cx, size.cy, section.DC(), 0, 0, size.cx, size.cy, mergeAlpha);
		}
	} else {
		BrushColour(fillStroke.stroke.colour);
		FrameRect(hdc, &rcw, brush);
	}
}

void SurfaceGDI::GradientRectangle(PRectangle rc, const std::vector<ColourStop> &stops, GradientOptions options) {

	const RECT rcw = RectFromPRectangle(rc);
	const SIZE size = SizeOfRect(rcw);

	DIBSection section(hdc, size);

	if (section) {

		if (options == GradientOptions::topToBottom) {
			for (LONG y = 0; y < size.cy; y++) {
				// Find y/height proportional colour
				const XYPOSITION proportion = y / (rc.Height() - 1.0f);
				const ColourRGBA mixed = GradientValue(stops, proportion);
				const DWORD valFill = dwordMultiplied(mixed);
				for (LONG x = 0; x < size.cx; x++) {
					section.SetPixel(x, y, valFill);
				}
			}
		} else {
			for (LONG x = 0; x < size.cx; x++) {
				// Find x/width proportional colour
				const XYPOSITION proportion = x / (rc.Width() - 1.0f);
				const ColourRGBA mixed = GradientValue(stops, proportion);
				const DWORD valFill = dwordMultiplied(mixed);
				for (LONG y = 0; y < size.cy; y++) {
					section.SetPixel(x, y, valFill);
				}
			}
		}

		GdiAlphaBlend(hdc, rcw.left, rcw.top, size.cx, size.cy, section.DC(), 0, 0, size.cx, size.cy, mergeAlpha);
	}
}

void SurfaceGDI::DrawRGBAImage(PRectangle rc, int width, int height, const unsigned char *pixelsImage) {
	if (rc.Width() > 0) {
		if (rc.Width() > width)
			rc.left += std::floor((rc.Width() - width) / 2);
		rc.right = rc.left + width;
		if (rc.Height() > height)
			rc.top += std::floor((rc.Height() - height) / 2);
		rc.bottom = rc.top + height;

		const SIZE size{ width, height };
		DIBSection section(hdc, size);
		if (section) {
			RGBAImage::BGRAFromRGBA(section.Bytes(), pixelsImage, static_cast<size_t>(width) * height);
			GdiAlphaBlend(hdc, static_cast<int>(rc.left), static_cast<int>(rc.top),
				static_cast<int>(rc.Width()), static_cast<int>(rc.Height()), section.DC(),
				0, 0, width, height, mergeAlpha);
		}
	}
}

void SurfaceGDI::Ellipse(PRectangle rc, FillStroke fillStroke) {
	PenColour(fillStroke.stroke.colour, fillStroke.stroke.width);
	BrushColour(fillStroke.fill.colour);
	const RECT rcw = RectFromPRectangle(rc);
	::Ellipse(hdc, rcw.left, rcw.top, rcw.right, rcw.bottom);
}

void SurfaceGDI::Stadium(PRectangle rc, FillStroke fillStroke, [[maybe_unused]] Ends ends) {
	// TODO: Implement properly - the rectangle is just a placeholder
	RectangleDraw(rc, fillStroke);
}

void SurfaceGDI::Copy(PRectangle rc, Point from, Surface &surfaceSource) {
	::BitBlt(hdc,
		static_cast<int>(rc.left), static_cast<int>(rc.top),
		static_cast<int>(rc.Width()), static_cast<int>(rc.Height()),
		dynamic_cast<SurfaceGDI &>(surfaceSource).hdc,
		static_cast<int>(from.x), static_cast<int>(from.y), SRCCOPY);
}

std::unique_ptr<IScreenLineLayout> SurfaceGDI::Layout(const IScreenLine *) {
	return {};
}

using TextPositionsI = VarBuffer<int, stackBufferLength>;

void SurfaceGDI::DrawTextCommon(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text, UINT fuOptions) {
	SetFont(font_);
	const RECT rcw = RectFromPRectangle(rc);
	const int x = static_cast<int>(rc.left);
	const int yBaseInt = static_cast<int>(ybase);

	if (mode.codePage == CpUtf8) {
		const TextWide tbuf(text, mode.codePage);
		::ExtTextOutW(hdc, x, yBaseInt, fuOptions, &rcw, tbuf.buffer, tbuf.tlen, nullptr);
	} else {
		::ExtTextOutA(hdc, x, yBaseInt, fuOptions, &rcw, text.data(), static_cast<UINT>(text.length()), nullptr);
	}
}

void SurfaceGDI::DrawTextNoClip(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text,
	ColourRGBA fore, ColourRGBA back) {
	::SetTextColor(hdc, fore.OpaqueRGB());
	::SetBkColor(hdc, back.OpaqueRGB());
	DrawTextCommon(rc, font_, ybase, text, ETO_OPAQUE);
}

void SurfaceGDI::DrawTextClipped(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text,
	ColourRGBA fore, ColourRGBA back) {
	::SetTextColor(hdc, fore.OpaqueRGB());
	::SetBkColor(hdc, back.OpaqueRGB());
	DrawTextCommon(rc, font_, ybase, text, ETO_OPAQUE | ETO_CLIPPED);
}

void SurfaceGDI::DrawTextTransparent(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text,
	ColourRGBA fore) {
	// Avoid drawing spaces in transparent mode
	for (const char ch : text) {
		if (ch != ' ') {
			::SetTextColor(hdc, fore.OpaqueRGB());
			::SetBkMode(hdc, TRANSPARENT);
			DrawTextCommon(rc, font_, ybase, text, 0);
			::SetBkMode(hdc, OPAQUE);
			return;
		}
	}
}

void SurfaceGDI::MeasureWidths(const Font *font_, std::string_view text, XYPOSITION *positions) {
	// Zero positions to avoid random behaviour on failure.
	std::fill(positions, positions + text.length(), 0.0f);
	SetFont(font_);
	SIZE sz = { 0,0 };
	int fit = 0;
	int i = 0;
	const int len = static_cast<int>(text.length());
	if (mode.codePage == CpUtf8) {
		const TextWide tbuf(text, mode.codePage);
		TextPositionsI poses(tbuf.tlen);
		if (!::GetTextExtentExPointW(hdc, tbuf.buffer, tbuf.tlen, maxWidthMeasure, &fit, poses.buffer, &sz)) {
			// Failure
			return;
		}
		// Map the widths given for UTF-16 characters back onto the UTF-8 input string
		for (int ui = 0; ui < fit; ui++) {
			const unsigned char uch = text[i];
			const unsigned int byteCount = UTF8BytesOfLead[uch];
			if (byteCount == 4) {	// Non-BMP
				ui++;
			}
			for (unsigned int bytePos = 0; (bytePos < byteCount) && (i < len); bytePos++) {
				positions[i++] = static_cast<XYPOSITION>(poses.buffer[ui]);
			}
		}
	} else {
		TextPositionsI poses(len);
		if (!::GetTextExtentExPointA(hdc, text.data(), len, maxWidthMeasure, &fit, poses.buffer, &sz)) {
			// Eeek - a NULL DC or other foolishness could cause this.
			return;
		}
		while (i < fit) {
			positions[i] = static_cast<XYPOSITION>(poses.buffer[i]);
			i++;
		}
	}
	// If any positions not filled in then use the last position for them
	const XYPOSITION lastPos = (fit > 0) ? positions[fit - 1] : 0.0f;
	std::fill(positions + i, positions + text.length(), lastPos);
}

XYPOSITION SurfaceGDI::WidthText(const Font *font_, std::string_view text) {
	SetFont(font_);
	SIZE sz = { 0,0 };
	if (!(mode.codePage == CpUtf8)) {
		::GetTextExtentPoint32A(hdc, text.data(), std::min(static_cast<int>(text.length()), maxLenText), &sz);
	} else {
		const TextWide tbuf(text, mode.codePage);
		::GetTextExtentPoint32W(hdc, tbuf.buffer, tbuf.tlen, &sz);
	}
	return static_cast<XYPOSITION>(sz.cx);
}

void SurfaceGDI::DrawTextCommonUTF8(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text, UINT fuOptions) {
	SetFont(font_);
	const RECT rcw = RectFromPRectangle(rc);
	const int x = static_cast<int>(rc.left);
	const int yBaseInt = static_cast<int>(ybase);

	const TextWide tbuf(text, CpUtf8);
	::ExtTextOutW(hdc, x, yBaseInt, fuOptions, &rcw, tbuf.buffer, tbuf.tlen, nullptr);
}

void SurfaceGDI::DrawTextNoClipUTF8(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text,
	ColourRGBA fore, ColourRGBA back) {
	::SetTextColor(hdc, fore.OpaqueRGB());
	::SetBkColor(hdc, back.OpaqueRGB());
	DrawTextCommonUTF8(rc, font_, ybase, text, ETO_OPAQUE);
}

void SurfaceGDI::DrawTextClippedUTF8(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text,
	ColourRGBA fore, ColourRGBA back) {
	::SetTextColor(hdc, fore.OpaqueRGB());
	::SetBkColor(hdc, back.OpaqueRGB());
	DrawTextCommonUTF8(rc, font_, ybase, text, ETO_OPAQUE | ETO_CLIPPED);
}

void SurfaceGDI::DrawTextTransparentUTF8(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text,
	ColourRGBA fore) {
	// Avoid drawing spaces in transparent mode
	for (const char ch : text) {
		if (ch != ' ') {
			::SetTextColor(hdc, fore.OpaqueRGB());
			::SetBkMode(hdc, TRANSPARENT);
			DrawTextCommonUTF8(rc, font_, ybase, text, 0);
			::SetBkMode(hdc, OPAQUE);
			return;
		}
	}
}

void SurfaceGDI::MeasureWidthsUTF8(const Font *font_, std::string_view text, XYPOSITION *positions) {
	// Zero positions to avoid random behaviour on failure.
	std::fill(positions, positions + text.length(), 0.0f);
	SetFont(font_);
	SIZE sz = { 0,0 };
	int fit = 0;
	int i = 0;
	const int len = static_cast<int>(text.length());
	const TextWide tbuf(text, CpUtf8);
	TextPositionsI poses(tbuf.tlen);
	if (!::GetTextExtentExPointW(hdc, tbuf.buffer, tbuf.tlen, maxWidthMeasure, &fit, poses.buffer, &sz)) {
		// Failure
		return;
	}
	// Map the widths given for UTF-16 characters back onto the UTF-8 input string
	for (int ui = 0; ui < fit; ui++) {
		const unsigned char uch = text[i];
		const unsigned int byteCount = UTF8BytesOfLead[uch];
		if (byteCount == 4) {	// Non-BMP
			ui++;
		}
		for (unsigned int bytePos = 0; (bytePos < byteCount) && (i < len); bytePos++) {
			positions[i++] = static_cast<XYPOSITION>(poses.buffer[ui]);
		}
	}
	// If any positions not filled in then use the last position for them
	const XYPOSITION lastPos = (fit > 0) ? positions[fit - 1] : 0.0f;
	std::fill(positions + i, positions + text.length(), lastPos);
}

XYPOSITION SurfaceGDI::WidthTextUTF8(const Font *font_, std::string_view text) {
	SetFont(font_);
	SIZE sz = { 0,0 };
	const TextWide tbuf(text, CpUtf8);
	::GetTextExtentPoint32W(hdc, tbuf.buffer, tbuf.tlen, &sz);
	return static_cast<XYPOSITION>(sz.cx);
}

XYPOSITION SurfaceGDI::Ascent(const Font *font_) {
	SetFont(font_);
	TEXTMETRIC tm;
	::GetTextMetrics(hdc, &tm);
	return static_cast<XYPOSITION>(tm.tmAscent);
}

XYPOSITION SurfaceGDI::Descent(const Font *font_) {
	SetFont(font_);
	TEXTMETRIC tm;
	::GetTextMetrics(hdc, &tm);
	return static_cast<XYPOSITION>(tm.tmDescent);
}

XYPOSITION SurfaceGDI::InternalLeading(const Font *font_) {
	SetFont(font_);
	TEXTMETRIC tm;
	::GetTextMetrics(hdc, &tm);
	return static_cast<XYPOSITION>(tm.tmInternalLeading);
}

XYPOSITION SurfaceGDI::Height(const Font *font_) {
	SetFont(font_);
	TEXTMETRIC tm;
	::GetTextMetrics(hdc, &tm);
	return static_cast<XYPOSITION>(tm.tmHeight);
}

XYPOSITION SurfaceGDI::AverageCharWidth(const Font *font_) {
	SetFont(font_);
	TEXTMETRIC tm;
	::GetTextMetrics(hdc, &tm);
	return static_cast<XYPOSITION>(tm.tmAveCharWidth);
}

void SurfaceGDI::SetClip(PRectangle rc) {
	::SaveDC(hdc);
	::IntersectClipRect(hdc, static_cast<int>(rc.left), static_cast<int>(rc.top),
		static_cast<int>(rc.right), static_cast<int>(rc.bottom));
}

void SurfaceGDI::PopClip() {
	::RestoreDC(hdc, -1);
}

void SurfaceGDI::FlushCachedState() {
	pen = {};
	brush = {};
}

void SurfaceGDI::FlushDrawing() {
}

}

namespace Scintilla::Internal {

std::shared_ptr<Font> FontGDI_Allocate(const FontParameters &fp) {
	return std::make_shared<FontGDI>(fp);
}

std::unique_ptr<Surface> SurfaceGDI_Allocate() {
	return std::make_unique<SurfaceGDI>();
}

}


================================================
FILE: Libraries/scintilla/win32/SurfaceGDI.h
================================================
// Scintilla source code edit control
/** @file SurfaceGDI.h
 ** Definitions for drawing to GDI on Windows.
 **/
// Copyright 2025 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#ifndef SURFACEGDI_H
#define SURFACEGDI_H

namespace Scintilla::Internal {

std::shared_ptr<Font> FontGDI_Allocate(const FontParameters &fp);
std::unique_ptr<Surface> SurfaceGDI_Allocate();

}

#endif


================================================
FILE: Libraries/scintilla/win32/WinTypes.h
================================================
// Scintilla source code edit control
/** @file WinTypes.h
 ** Implement safe release of COM objects and access to functions in DLLs.
 ** Header contains all implementation - there is no .cxx file.
 **/
// Copyright 2020-2021 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#ifndef WINTYPES_H
#define WINTYPES_H

namespace Scintilla::Internal {

// Release an IUnknown* and set to nullptr.
// While IUnknown::Release must be noexcept, it isn't marked as such so produces
// warnings which are avoided by the catch.
template <class T>
inline void ReleaseUnknown(T *&ppUnknown) noexcept {
	if (ppUnknown) {
		try {
			ppUnknown->Release();
		} catch (...) {
			// Never occurs
		}
		ppUnknown = nullptr;
	}
}

struct UnknownReleaser {
	// Called by unique_ptr to destroy/free the resource
	template <class T>
	void operator()(T *pUnknown) noexcept {
		try {
			pUnknown->Release();
		} catch (...) {
			// IUnknown::Release must not throw, ignore if it does.
		}
	}
};

/// Find a function in a DLL and convert to a function pointer.
/// This avoids undefined and conditionally defined behaviour.
template<typename T>
inline T DLLFunction(HMODULE hModule, LPCSTR lpProcName) noexcept {
	if (!hModule) {
		return nullptr;
	}
	FARPROC function = ::GetProcAddress(hModule, lpProcName);
	static_assert(sizeof(T) == sizeof(function));
	T fp {};
	memcpy(&fp, &function, sizeof(T));
	return fp;
}

inline void ReleaseLibrary(HMODULE &hLib) noexcept {
	if (hLib) {
		FreeLibrary(hLib);
		hLib = {};
	}
}

}

#endif


================================================
FILE: Notes.txt
================================================
VERSION INFO

The program version format is major.minor.build, like 1.20.5.
	Minor: changed when added some significant features.
	Build: changed when fixed bugs between minor versions. Also may have some new features.

To update version info of dll files (Au, Au.Editor, Au.Controls):
	Open global2.cs and edit Au_.Version. Single global2.cs is used by all these projects.
	It's important to update Au version info whenever something changed in Au or its dependencies (AuCpp etc).
	Also may need to update year in AssemblyCopyright attribute (it's displayed in About info).
To update version info of the setup file:
	Open the .iss file in Inno Script Studio and edit MyAppVersion.
Also in index.md update version, date, filesize. It is part of the help website.
Also may need to update year in LICENSE.txt.

All significant changes of that version must be documented in Other/DocFX/_doc/changes/vMajor.Minor.md. Do it whenever making changes.


HOW TO RELEASE A NEW VERSION

Review all TODO. Occasionally review TODO2, FUTURE, CONSIDER.
	TODO2 means "low priority TODO". If after a long time it still seems low priority, delete the comment or replace with TODO3.

May need to test something. Eg some changes could break some main features.
	Also test new and some main features on other OS. Test on ARM-64.

May need to undefine TRACE in some C++ projects.
	Usually not using TRACE in Release config, but sometimes may use it to test Release speed etc.
	Don't use TRACE in C# projects; it's defined by default in Debug and Release config.

May need to delete test code. Or use #if DEBUG, like in Tests.cs.
	Review perf and print.

May need to add new OS version to class osVersion. Usually once/year.

Change version info (see above) in global2.cs and index.md.

Build solution in config Release, all platforms.
	NOTE: use the "Rebuild solution" command, else VS may not update something.

Review menu Help -> About. May need to update C# version, .NET version, used libraries.

Run script "Au docs".
	Fix errors if need. More info in AuDocs.txt.
	Don't upload now.
	It also runs other scripts that create files for local docs.

Create database for AI. To find the script: main toolbar > "Docs" menu. Also the "Au docs" script prints the link.

May need to update some info in README.md for github. Eg the screenshot and "how to build".
	When an image updated, github still shows the old cached. Workaround: in the image link append #x and change x for each image version. If using CloudFlare (currently not): before run script "Purge Cloudflare CDN cache".

Review the md file of current version.
	If it's still "future.md", rename ( RENAME!!! ) to "v1.x.md".

Open the .iss file in Inno Script Studio. Change MyAppVersion. Review. Compile.
	Run the setup file to test. Let it run LA. Test on other OS too. Occasionally uninstall/install, not just upgrade.
	May need to update the setup file size in the download webpage (index.md).

Github commit all and push. The message could be like v1.2.3.
	Note: do it now. Need for upload to GitHub. Also uploads the "changes" doc.

Create a GitHub Release. Upload the setup file.

Upload the setup file to https://www.libreautomate.com. For example with WinSCP.
	Backup the old setup file at first: in WinSCP move the old file to the "download" folder and rename (add version).
		Don't backup if changed only patch version. Simply replace.
		Optional if using GitHub Releases.

Upload the website created by script "Au docs". To find the script: main toolbar > "Docs" menu.

Review web pages. Github too.

Download and test the setup file.
	Occasionally test it on all OS. Observe SmartScreen/antivirus behavior.

Sometimes test whether others can build and run the repo.
	Eg when some new files added to the `_` dir.
	Generated or downloaded files in `_` dir/subdirs must be gitignored, unless very small non-binary. Instead specify them in `GitBinaryFiles.cs` in project `BuildEvents`.
	Make sure this file exists: `.git\hooks\pre-push`. More info in `GitBinaryFiles.cs`.

Test the setup file at virustotal.com. And separately other files (even data files).
	Always will be several false positives. Even with an empty Inno Setup project. Never mind.

Release NuGet package:
	Run script "Create NuGet package.cs". It builds Au using a modified temp csproj, creates package and adds native dlls.
	Upload to NuGet. The script prints links.

Run script "Update version.txt.cs". It updates _\version.txt and uploads to public_html.

No more:
	Announce in forum.
	If not beta, occasionally review/update in some download websites. Edit and upload the PAD file.


---------------------------------------------------------

UPDATING .NET

VS must support that .NET version. Install the .NET SDK if need.

Update .NET version in all C# projects (.csproj) except Au.Net4.

May need to update .NET SDK version in global.json (in solution folder).
	Used it to force VS to use .NET 8 SDK.
	Because: if installed .NET 9 Preview SDK, VS uses it to build projects that use .NET 8. Then app crashes when starting.
	Note: some scripts build just the Au project. To use correct SDK, I created a symlink to the solution's global.json in the project folder. Adding as a link in VS (in csproj) does not work.

In project DatabasesEtc, in file Program.cs:
	Enable only the call to RefTxt.Create, and run.
	Enable only the call to RefAndDoc.Create, and run.
	Also now it's a good time to update icons: update the NuGet package, enable only Icons.CreateDB, and run.
	NOTE: also need this when upgraded SDK RC -> final. Eg in .NET 8 SDK final some API changed.

Update .NET version in the AppHost project (the #define). Build.

Update MetaComments.Defines.

Build solution.

Run editor.

In LibreAutomate.iss (Inno Setup) replace the .NET Desktop Runtime download URL. Also .NET major version in several places.

Find-replace "NET 8", "NET8", "net8" and "8" everywhere, including:
- LibreAutomate.iss (Inno Setup).
- README.md (GitHub).

Create-upload https://www.libreautomate.com/download/net-X-url.txt. Here X is .NET major version, eg 10.
	The file must contain the .NET Desktop Runtime download URLs for x64 and arm64 (the same as in LibreAutomate.iss).

Run script "Minimal .NET SDK". Upload.

Test DNuget. Test package Microsoft.PowerShell.SDK (because it's the most complex I know). Test how it works in miniProgram and exeProgram.

Test Publish.

Maybe more.


================================================
FILE: Other/Au.DllHost/Au.DllHost.vcxproj
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <ItemGroup Label="ProjectConfigurations">
    <ProjectConfiguration Include="Release|ARM64">
      <Configuration>Release</Configuration>
      <Platform>ARM64</Platform>
    </ProjectConfiguration>
    <ProjectConfiguration Include="Release|Win32">
      <Configuration>Release</Configuration>
      <Platform>Win32</Platform>
    </ProjectConfiguration>
    <ProjectConfiguration Include="Release|x64">
      <Configuration>Release</Configuration>
      <Platform>x64</Platform>
    </ProjectConfiguration>
  </ItemGroup>
  <PropertyGroup Label="Globals">
    <VCProjectVersion>17.0</VCProjectVersion>
    <Keyword>Win32Proj</Keyword>
    <ProjectGuid>{e9d9f078-bf4f-437e-be31-3af89f3c6548}</ProjectGuid>
    <RootNamespace>AuDllHost</RootNamespace>
    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
  </PropertyGroup>
  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
    <ConfigurationType>Application</ConfigurationType>
    <UseDebugLibraries>false</UseDebugLibraries>
    <PlatformToolset>v143</PlatformToolset>
    <WholeProgramOptimization>true</WholeProgramOptimization>
    <CharacterSet>Unicode</CharacterSet>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
    <ConfigurationType>Application</ConfigurationType>
    <UseDebugLibraries>false</UseDebugLibraries>
    <PlatformToolset>v143</PlatformToolset>
    <WholeProgramOptimization>true</WholeProgramOptimization>
    <CharacterSet>Unicode</CharacterSet>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'" Label="Configuration">
    <ConfigurationType>Application</ConfigurationType>
    <UseDebugLibraries>false</UseDebugLibraries>
    <PlatformToolset>v143</PlatformToolset>
    <WholeProgramOptimization>true</WholeProgramOptimization>
    <CharacterSet>Unicode</CharacterSet>
  </PropertyGroup>
  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
  <ImportGroup Label="ExtensionSettings">
  </ImportGroup>
  <ImportGroup Label="Shared">
  </ImportGroup>
  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
  </ImportGroup>
  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
  </ImportGroup>
  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'" Label="PropertySheets">
    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
  </ImportGroup>
  <PropertyGroup Label="UserMacros" />
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'">
    <OutDir>bin\$(Configuration)\$(Platform)\</OutDir>
    <IntDir>obj\$(Configuration)\$(Platform)\</IntDir>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
    <OutDir>bin\$(Configuration)\$(Platform)\</OutDir>
    <IntDir>obj\$(Configuration)\$(Platform)\</IntDir>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
    <OutDir>bin\$(Configuration)\$(Platform)\</OutDir>
    <IntDir>obj\$(Configuration)\$(Platform)\</IntDir>
  </PropertyGroup>
  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
    <ClCompile>
      <WarningLevel>Level3</WarningLevel>
      <FunctionLevelLinking>true</FunctionLevelLinking>
      <IntrinsicFunctions>true</IntrinsicFunctions>
      <SDLCheck>true</SDLCheck>
      <PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <ConformanceMode>true</ConformanceMode>
      <DebugInformationFormat>None</DebugInformationFormat>
      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
    </ClCompile>
    <Link>
      <SubSystem>Windows</SubSystem>
      <EnableCOMDATFolding>true</EnableCOMDATFolding>
      <OptimizeReferences>true</OptimizeReferences>
      <GenerateDebugInformation>true</GenerateDebugInformation>
      <EntryPointSymbol>main</EntryPointSymbol>
    </Link>
    <PostBuildEvent>
      <Command>xcopy $(TargetPath) $(SolutionDir)_\32\ /Y</Command>
    </PostBuildEvent>
  </ItemDefinitionGroup>
  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
    <ClCompile>
      <WarningLevel>Level3</WarningLevel>
      <FunctionLevelLinking>true</FunctionLevelLinking>
      <IntrinsicFunctions>true</IntrinsicFunctions>
      <SDLCheck>true</SDLCheck>
      <PreprocessorDefinitions>NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <ConformanceMode>true</ConformanceMode>
      <DebugInformationFormat>None</DebugInformationFormat>
      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
    </ClCompile>
    <Link>
      <SubSystem>Windows</SubSystem>
      <EnableCOMDATFolding>true</EnableCOMDATFolding>
      <OptimizeReferences>true</OptimizeReferences>
      <GenerateDebugInformation>true</GenerateDebugInformation>
      <EntryPointSymbol>main</EntryPointSymbol>
    </Link>
    <PostBuildEvent>
      <Command>xcopy $(TargetPath) $(SolutionDir)_\64\ /Y</Command>
    </PostBuildEvent>
  </ItemDefinitionGroup>
  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'">
    <ClCompile>
      <WarningLevel>Level3</WarningLevel>
      <FunctionLevelLinking>true</FunctionLevelLinking>
      <IntrinsicFunctions>true</IntrinsicFunctions>
      <SDLCheck>true</SDLCheck>
      <PreprocessorDefinitions>NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <ConformanceMode>true</ConformanceMode>
      <DebugInformationFormat>None</DebugInformationFormat>
      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
    </ClCompile>
    <Link>
      <SubSystem>Windows</SubSystem>
      <EnableCOMDATFolding>true</EnableCOMDATFolding>
      <OptimizeReferences>true</OptimizeReferences>
      <GenerateDebugInformation>true</GenerateDebugInformation>
      <EntryPointSymbol>main</EntryPointSymbol>
    </Link>
    <PostBuildEvent>
      <Command>xcopy $(TargetPath) $(SolutionDir)_\64\ARM\ /Y</Command>
    </PostBuildEvent>
  </ItemDefinitionGroup>
  <ItemGroup>
    <ClCompile Include="DllHost.c" />
  </ItemGroup>
  <ItemGroup>
    <ProjectReference Include="..\..\Cpp\Cpp.vcxproj">
      <Project>{10559875-c9a1-484c-bcfa-8dc53a428f1c}</Project>
    </ProjectReference>
  </ItemGroup>
  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
  <ImportGroup Label="ExtensionTargets">
  </ImportGroup>
</Project>

================================================
FILE: Other/Au.DllHost/Au.DllHost.vcxproj.filters
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <ItemGroup>
    <ClCompile Include="DllHost.c" />
  </ItemGroup>
</Project>

================================================
FILE: Other/Au.DllHost/DllHost.c
================================================
#define WIN32_LEAN_AND_MEAN
#include <windows.h>

//#define EXPORT extern "C" __declspec(dllimport) //C++
#define EXPORT __declspec(dllimport) //C
EXPORT void Cpp_Arch(LPCWSTR a0, LPCWSTR a1);
EXPORT void Cpp_Unload(DWORD flags);

#if 1 //small exe file. Use .c file. Project properties > Linker > Advanced > Entry point = main.
void main() {
	LPCWSTR a = GetCommandLine();
	if (*a == '"') {
		while (*(++a) != '"') if (*a == 0) return;
		a++;
	} else {
		while (*a != ' ' && *a != 0) a++;
	}
	while (*a == ' ') a++;
	//MessageBox(0, a, L"test", 0);

	if (*a == 0) {
		Cpp_Unload(1);
	} else {
		LPCWSTR a1 = a; while (*a1 != 0 && *a1 != ' ') a1++;
		if (a1 > a && *a1 == ' ') a1++; else return;
		Cpp_Arch(a, a1);
	}

	ExitProcess(0);
}
#else
int APIENTRY wWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPWSTR pCmdLine, int nCmdShow) {

	//MessageBox(0, pCmdLine, L"test", 0);

	if (*pCmdLine == 0) {
		Cpp_Unload(1);
	} else {
		LPCWSTR a1 = pCmdLine; while (*a1 != 0 && *a1 != ' ') a1++;
		if (a1 > pCmdLine && *a1 == ' ') a1++; else return 1;
		Cpp_Arch(pCmdLine, a1);
	}

	return 0;
}
#endif


================================================
FILE: Other/Au.Net4/App.config
================================================
<?xml version="1.0" encoding="utf-8"?>
<configuration>
    <startup> 
        <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.8"/>
    </startup>
</configuration>


================================================
FILE: Other/Au.Net4/Au.Net4.csproj
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
  <PropertyGroup>
    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
    <ProjectGuid>{2157BC47-A5E1-405C-A003-F44970DC3718}</ProjectGuid>
    <OutputType>Exe</OutputType>
    <RootNamespace>Au.Net4</RootNamespace>
    <AssemblyName>Au.Net4</AssemblyName>
    <TargetFrameworkVersion>v4.8</TargetFrameworkVersion>
    <FileAlignment>512</FileAlignment>
    <Deterministic>true</Deterministic>
    <TargetFrameworkProfile />
  </PropertyGroup>
  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
    <PlatformTarget>AnyCPU</PlatformTarget>
    <DebugSymbols>true</DebugSymbols>
    <DebugType>full</DebugType>
    <Optimize>false</Optimize>
    <OutputPath>..\..\_\</OutputPath>
    <DefineConstants>DEBUG;TRACE</DefineConstants>
    <ErrorReport>prompt</ErrorReport>
    <WarningLevel>4</WarningLevel>
    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
  </PropertyGroup>
  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
    <PlatformTarget>AnyCPU</PlatformTarget>
    <DebugType>pdbonly</DebugType>
    <Optimize>true</Optimize>
    <OutputPath>..\..\_\</OutputPath>
    <DefineConstants>TRACE</DefineConstants>
    <ErrorReport>prompt</ErrorReport>
    <WarningLevel>4</WarningLevel>
    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
    <Prefer32Bit>false</Prefer32Bit>
  </PropertyGroup>
  <ItemGroup>
    <Reference Include="System" />
    <Reference Include="System.Core" />
    <Reference Include="System.Xml.Linq" />
    <Reference Include="System.Data.DataSetExtensions" />
    <Reference Include="Microsoft.CSharp" />
    <Reference Include="System.Data" />
    <Reference Include="System.Net.Http" />
    <Reference Include="System.Xml" />
  </ItemGroup>
  <ItemGroup>
    <Compile Include="Net4.cs" />
    <Compile Include="Properties\AssemblyInfo.cs" />
    <Compile Include="TypelibConverter.cs" />
  </ItemGroup>
  <ItemGroup>
    <None Include="App.config" />
  </ItemGroup>
  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
</Project>

================================================
FILE: Other/Au.Net4/Net4.cs
================================================
using System;
using System.Collections.Generic;
using System.IO;
using System.Runtime.InteropServices;
using System.Text;

[module: DefaultCharSet(CharSet.Unicode)]

class Net4 {
	[STAThread]
	static int Main(string[] args) {
		Console.InputEncoding = Encoding.UTF8;
		Console.OutputEncoding = Encoding.UTF8;

		switch (args[0]) {
		case "/typelib":
			return TypelibConverter.Convert(args[1]);
		}
		return 1;
	}
}


================================================
FILE: Other/Au.Net4/Properties/AssemblyInfo.cs
================================================
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;

// General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
[assembly: AssemblyTitle("Au.Net4")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("Au.Net4")]
[assembly: AssemblyCopyright("Copyright © 2025")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]

// Setting ComVisible to false makes the types in this assembly not visible
// to COM components.  If you need to access a type in this assembly from
// COM, set the ComVisible attribute to true on that type.
[assembly: ComVisible(false)]

// The following GUID is for the ID of the typelib if this project is exposed to COM
[assembly: Guid("2157bc47-a5e1-405c-a003-f44970dc3718")]

// Version information for an assembly consists of the following four values:
//
//      Major Version
//      Minor Version
//      Build Number
//      Revision
//
// You can specify all the values or you can default the Build and Revision Numbers
// by using the '*' as shown below:
// [assembly: AssemblyVersion("1.0.*")]
[assembly: AssemblyVersion("1.0.0.0")]
[assembly: AssemblyFileVersion("1.0.0.0")]


================================================
FILE: Other/Au.Net4/TypelibConverter.cs
================================================
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.IO;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.InteropServices;
using System.Runtime.InteropServices.ComTypes;
using System.Text;

using _TYPELIBATTR = System.Runtime.InteropServices.ComTypes.TYPELIBATTR;

unsafe class TypelibConverter {

	public static int Convert(string param) {
		var a = param.Split('|');
		string asmDir = a[0], comDll = a[1];

		int hr = LoadTypeLibEx(comDll, 2, out var tl);
		if (hr != 0) {
			Print($"Failed to load type library '{comDll}'.\r\n\t{new Win32Exception(hr).Message}");
			return -1;
		}

		try {
			var c = new _TypelibConverter { saveDir = asmDir };
			c.Convert(tl);
		}
		catch (Exception ex) { Print($"Failed to convert type library '{comDll}'.\r\n\t{ex.Message}"); return -2; }
		return 0;
	}

	[DllImport("oleaut32.dll", EntryPoint = "#183", PreserveSig = true)]
	static extern int LoadTypeLibEx(string szFile, int regkind, out ITypeLib pptlib);

	class _TypelibConverter : ITypeLibImporterNotifySink {
		static Dictionary<string, AssemblyBuilder> s_converted = new Dictionary<string, AssemblyBuilder>();

		public string saveDir;

		public Assembly Convert(ITypeLib tl) {
			tl.GetLibAttr(out IntPtr ipta);
			var ta = *(_TYPELIBATTR*)ipta;
			tl.ReleaseTLibAttr(ipta);
			var hash = _Fnv1((byte*)&ta, sizeof(_TYPELIBATTR) - 2).ToString("x");

			tl.GetDocumentation(-1, out var tlName, out var tlDescription, out var _, out var _);
			var fileName = $"{tlName} {ta.wMajorVerNum}.{ta.wMinorVerNum} #{hash}.dll";
			var netPath = saveDir + fileName;

			if (!s_converted.TryGetValue(fileName, out var asm) || !File.Exists(netPath)) {
				Print($"<>Converted: {tlName} ({tlDescription}) to <explore {netPath}>{fileName}<>");

				var converter = new TypeLibConverter();
				asm = converter.ConvertTypeLibToAssembly(tl, netPath,
					TypeLibImporterFlags.ReflectionOnlyLoading | TypeLibImporterFlags.TransformDispRetVals | TypeLibImporterFlags.UnsafeInterfaces,
					this, null, null, tlName, null);
				asm.Save(fileName);
				s_converted[fileName] = asm;
			}
			return asm;
		}

		void ITypeLibImporterNotifySink.ReportEvent(ImporterEventKind eventKind, int eventCode, string eventMsg) {
			if (eventKind != ImporterEventKind.NOTIF_TYPECONVERTED) Print("Warning: " + eventMsg);
		}

		Assembly ITypeLibImporterNotifySink.ResolveRef(object typeLib) => Convert(typeLib as ITypeLib);
	}

	static void Print(object o) => Console.WriteLine(o?.ToString());

	//code copied from Hash
	static int _Fnv1(byte* data, int lengthBytes) {
		uint hash = 2166136261;

		for (int i = 0; i < lengthBytes; i++)
			hash = (hash * 16777619) ^ data[i];

		return (int)hash;
	}
}


================================================
FILE: Other/BuildEvents/Au.TestInternal.cs
================================================
using Microsoft.CodeAnalysis.Collections;
using System;
using System.Collections.Generic;
using System.Collections.Immutable;

//no, then many errors when compiling that project
//[assembly: System.Runtime.CompilerServices.InternalsVisibleTo("Microsoft.CodeAnalysis.Workspaces, PublicKey=0024000004800000940000000602000000240000525341310004000001000100b5fc90e7027f67871e773a8fde8938c81dd402ba65b9201d60593e96c492651e889cc13f1415ebb53fac1131ae0bd333c5ee6021672d9718ea31a8aebd0da0072f25d87dba6fc90ffd598ed4da35e44c398c454307e8e33b8426143daec9f596836f97c8f74750e5975c64e2189f45def46b2a2b1247adc3652bf5c308055da9")]

namespace RoslynMod;

public static class TestInternal
{
    internal static Func<string, string, bool>? IsInternalsVisibleCallback;
    internal static Action<string, HashSet<string>>? AppendInternalsVisibleCallback;
    static ImmutableArray<byte>[]? s_a1;

    public static IEnumerable<ImmutableArray<byte>> IsInternalsVisible(string thisName, string toName)
    {
        if (IsInternalsVisibleCallback?.Invoke(thisName, toName) ?? false)
            return s_a1 ??= new ImmutableArray<byte>[1] { default };
        return SpecializedCollections.EmptyEnumerable<ImmutableArray<byte>>();
    }

    //public static bool IsInternalsVisible(string thisName, string toName)
    //{
    //    return IsInternalsVisibleCallback1?.Invoke(thisName, toName) ?? false;
    //}

    public static void AppendInternalsVisible(string thisName, HashSet<string> toNames)
    {
        AppendInternalsVisibleCallback?.Invoke(thisName, toNames);
    }
}

public static class Print
{
    internal static Action<object>? PrintItCallback;

    public static void it(object o)
    {
        PrintItCallback?.Invoke(o);
    }
}


================================================
FILE: Other/BuildEvents/BuildEvents.cs
================================================
// Build event script for Au.Editor and Cpp projects.

using Microsoft.Win32;

script.setup(exception: UExcept.Dialog | UExcept.Print);

//print.ignoreConsole = true;
//print.qm2.use = true;
//print.it(args);

//if (args.Length == 0) { //dev
//	Environment.CurrentDirectory = @"C:\code\au";
//	//return GitBinaryFiles.PrePushHook();
//	return GitBinaryFiles.Restore(Environment.CurrentDirectory + "\\", true);
//}

string solutionDirBS = folders.ThisAppBS[..^28];

return args[0] switch {
	"cppPostBuild" => CppPostBuild(), //$(SolutionDir)Other\BuildEvents\bin\Debug\BuildEvents.exe cppPostBuild $(Configuration) $(Platform)
	"preBuild" => EditorPreBuild(), //$(SolutionDir)Other\BuildEvents\bin\Debug\BuildEvents.exe preBuild $(Configuration)
	"postBuild" => EditorPostBuild(), //$(SolutionDir)Other\BuildEvents\bin\Debug\BuildEvents.exe postBuild $(Configuration)
	"dllPostBuild" => DllPostBuild(), //$(SolutionDir)Other\BuildEvents\bin\Debug\BuildEvents.exe dllPostBuild "$(TargetPath)" $(Platform)
	"roslynPostBuild" => RoslynPostBuild(),
	"gitPrePushHook" => GitBinaryFiles.PrePushHook(),
	_ => 1
};

/// Exits editor. Copies AuCpp.dll and unloads the old dll from processes.
int CppPostBuild() {
	_ExitEditor();
	if (!_CopyAuCppDllIfNeed(args[2], false)) return 1;
	return 0;
}

/// Exits editor. If need, copies AuCpp.dll and unloads the old dll from processes.
int EditorPreBuild() {
	_ExitEditor();
	_CopyAuCppDllIfNeed("Win32", true);
	_CopyAuCppDllIfNeed("x64", true);
	_CopyAuCppDllIfNeed("ARM64", true);
	return GitBinaryFiles.Restore(solutionDirBS);
}

/// Exits editor. Copies the dll (eg Scintilla).
int DllPostBuild() {
	_ExitEditor();
	var toDir = $@"{solutionDirBS}_\{args[2] switch { "x64" => "64", "ARM64" => @"64\ARM", _ => throw new ArgumentException("platform") }}";
	filesystem.copyTo(args[1], toDir, FIfExists.Delete);
	return 0;
}

void _ExitEditor() {
	for (int i = 2; --i >= 0;) {
		var w = wnd.findFast(cn: "Au.Editor.TrayNotify");
		if (!w.Is0) {
			w.Close(noWait: true);
			w.WaitForClosed(-2, waitUntilProcessEnds: true);
		}
	}
}

bool _CopyAuCppDllIfNeed(string platform, bool editor) {
	string src = $@"{solutionDirBS}Cpp\bin\{args[1]}\{platform}\AuCpp.dll";
	string dest = $@"{solutionDirBS}_\{platform switch { "Win32" => "32", "x64" => "64", "ARM64" => @"64\ARM", _ => throw new ArgumentException("platform") }}\AuCpp.dll";
	if (!filesystem.getProperties(src, out var p1)) { if (!editor) print.it("Failed `filesystem.getProperties(src)`"); return false; }
	filesystem.getProperties(dest, out var p2);
	if (p1.LastWriteTimeUtc != p2.LastWriteTimeUtc || p1.Size != p2.Size) {
		print.it($"Updating {dest}");
		if (p2.Size != 0 && !_Api.DeleteFile(dest)) {
			_Api.Cpp_Unload(1);
			wait.until(-3, () => filesystem.delete(dest, FDFlags.CanFail) != false);
		}
		filesystem.copy(src, dest);
	}
	return true;
}

/// Creates Au.Editor.exe and Au.Task.exe for x64 and ARM64.
/// Uses our Au.AppHost.exe as template. Adds resources.
/// Deletes Au.Editor.*.json files.
int EditorPostBuild() {
	//perf.first();
	string exe1 = "Au.Editor.exe", exe2 = "Au.Task.exe";
	if (script.testing) {
		exe1 = "Au.Editor2.exe"; exe2 = "Au.Task2.exe";
		print.ignoreConsole = true;
		//todo: Environment.CurrentDirector = 
	}
	var dirOut = solutionDirBS + @"_\";

#if !true //copy output files from `$(ProjectDir)$(OutDir)` to dirOut. Bad: can't start LA from VS (no program path setting in UI; VS ignores executablePath in launchsettings.json).
	var dirBin = args[2][..^1];
	int rce = run.console(out string rco, "robocopy.exe", $"{dirBin} {dirOut} /s /xd runtimes /xf *.json *.exe");
	if (rce >= 8) { print.it(rco); return 10; }
	foreach (var rtd in new string[] { @"\runtimes\win-x64", @"\runtimes\win-arm64" }) {
		var sd1 = dirBin + rtd;
		if (filesystem.exists(sd1)) run.console("robocopy.exe", $"{sd1} {dirOut + rtd} /s /xf *.json *.exe");
	}
#else //use `<OutDir>`. Bad: VS adds unwanted files to dirOut. Eg from NuGet packages may add native dlls for many unused OS/platforms.
	filesystem.delete(Directory.GetFiles(dirOut, "Au.Editor.*.json"));
#endif

	using var rk = Registry.CurrentUser.CreateSubKey(@"Software\Au\BuildEvents");
	var verResFile1 = folders.ThisApp + $"{exe1}.res";
	var verResFile2 = folders.ThisApp + $"{exe2}.res";

	var v = FileVersionInfo.GetVersionInfo(dirOut + "Au.Editor.dll");
	bool verChanged = !(rk.GetValue("version") is string s1 && s1 == v.FileVersion);
	//verChanged = true;
	if (verChanged || !filesystem.exists(verResFile1)) if (!_VersionInfo(verResFile1, exe1, "LibreAutomate")) return 1;
	if (verChanged || !filesystem.exists(verResFile2)) if (!_VersionInfo(verResFile2, exe2, "LibreAutomate miniProgram")) return 2;

	//TODO3: test https://github.com/resourcelib/resourcelib

	for (int i = 0; i < 2; i++) {
		string appHost = $@"64\{(i == 1 ? "ARM" : "")}\Au.AppHost.exe";
		string exe1Arch = exe1.Insert(^4, i == 0 ? "" : "-arm"), exe2Arch = exe2.Insert(^4, i == 0 ? "-x64" : "-arm");
		var s = $"""
[FILENAMES]
Exe={appHost}
SaveAs={exe1Arch}
[COMMANDS]
-add ..\Au.Editor\Resources\ico\app.ico, ICONGROUP,32512,0
-add ..\Au.Editor\Resources\ico\app_disabled.ico, ICONGROUP,32513,0
-add ..\Au.Editor\Resources\ico\PictureInPicture.ico, ICONGROUP,32514,0
-addoverwrite ..\Au.Editor\Resources\Au.manifest, MANIFEST,1,0
-add dotnet_ref_editor.txt, 220,1,0
-add "{verResFile1}", VERSIONINFO,1,0

""";
		if (!_RunRhScript(s, exe1Arch)) return 3;

		filesystem.getProperties(dirOut + @"64\Au.AppHost.exe", out var p1);
		if (verChanged || !filesystem.getProperties(dirOut + exe2Arch, out var p2) || p1.LastWriteTimeUtc > p2.LastWriteTimeUtc) {
			print.it($"Creating {exe2Arch}");
			s = $"""
[FILENAMES]
Exe={appHost}
SaveAs={exe2Arch}
[COMMANDS]
-add ..\Au.Editor\Resources\ico\Script.ico, ICONGROUP,32512,0
-addoverwrite ..\Au.Editor\Resources\Au.manifest, MANIFEST,1,0
-add dotnet_ref_task.txt, 220,1,0
-add "{verResFile2}", VERSIONINFO,1,0

""";
			if (!_RunRhScript(s, exe2Arch)) return 4;
		}

		_WriteEditorAssemblyName(dirOut + exe1Arch);
	}

	if (verChanged) {
		rk.SetValue("version", v.FileVersion);
	}

	//perf.nw();
	return 0;

	bool _RunRhScript(string s, string fileName) {
		var exePath = dirOut + fileName;
		filesystem.delete(exePath);
		using var tf = new TempFile();
		filesystem.saveText(tf, s);
		if (!_RunCL($"-script \"{tf.File}\"")) return false;
		var dt = DateTime.UtcNow;
		File.SetCreationTimeUtc(exePath, dt);
		File.SetLastWriteTimeUtc(exePath, dt);
		return true;
	}

	bool _RunCL(string cl) {
		var rh = solutionDirBS + @"Other\BuildEvents\.tools\ResourceHacker";
		int r = run.console(rh + ".exe", cl, dirOut);
		if (r == 0) return true;
		print.it(File.ReadAllText(rh + ".log", Encoding.Unicode)); //RH is not a console program and we cannot capture its console output.
		return false;
	}

	static void _WriteEditorAssemblyName(string path) {
		var b = File.ReadAllBytes(path);
		int i = b.AsSpan().IndexOf("hi7yl8kJNk+gqwTDFi7ekQ"u8);
		b[i - 1] = 1; //1 for Au.Editor.exe, 0 for Au.Task.exe (and no assembly filename), else first char of exeProgram assembly filename
		string asmName = "Au.Editor.dll";
		i += Encoding.UTF8.GetBytes(asmName, 0, asmName.Length, b, i);
		b[i] = 0;
		filesystem.saveBytes(path, b);
	}

	bool _VersionInfo(string resFile, string fileName, string fileDesc) {
		print.it($"Creating version resource for {fileName}");
		var rc = $$"""

1 VERSIONINFO
FILEVERSION {{v.FileMajorPart}},{{v.FileMinorPart}},{{v.FileBuildPart}},{{v.FilePrivatePart}}
PRODUCTVERSION {{v.ProductMajorPart}},{{v.ProductMinorPart}},{{v.ProductBuildPart}},{{v.ProductPrivatePart}}
FILEOS 0x4
FILETYPE 0x1
{
BLOCK "StringFileInfo"
{
	BLOCK "000004b0"
	{
		VALUE "CompanyName", "{{v.CompanyName}}"
		VALUE "FileDescription", "{{fileDesc}}"
		VALUE "FileVersion", "{{v.FileVersion}}"
		VALUE "InternalName", "{{fileName[..^4]}}"
		VALUE "LegalCopyright", "Copyright 2020-{{DateTime.UtcNow.Year}} Gintaras Didžgalvis"
		VALUE "OriginalFilename", "{{fileName}}"
		VALUE "ProductName", "{{v.ProductName}}"
		VALUE "ProductVersion", "{{v.ProductVersion}}"
	}
}

BLOCK "VarFileInfo"
{
	VALUE "Translation", 0x0000 0x04B0  
}
}

""";
		using var rcFile = new TempFile(".rc");
		filesystem.saveText(rcFile, rc, encoding: Encoding.UTF8);
		return _RunCL($"""-open "{rcFile}" -save "{resFile}" -action compile""");
	}
}

//Exits editor. Copies dlls etc.
int RoslynPostBuild() {
	_ExitEditor();

	var from = args[1].Trim();
	var to = $@"{solutionDirBS}_\Roslyn";
	
	foreach (var f in filesystem.enumFiles(to)) {
		filesystem.delete(f.FullPath, FDFlags.CanFail);
	}
	foreach (var f in filesystem.enumFiles(from)) {
		if (0 == f.Name.Ends(true, ".dll", ".xml")) continue;
		if (0 != f.Name.Starts(true, "System.Configuration.", "System.Security.")) continue;
		filesystem.copyTo(f.FullPath, to);
	}
	return 0;
}

unsafe class _Api : NativeApi {
	[DllImport("kernel32.dll", EntryPoint = "DeleteFileW", SetLastError = true)]
	internal static extern bool DeleteFile(string lpFileName);

	/// <param name="flags">1 - wait less.</param>
	[DllImport("AuCpp.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern void Cpp_Unload(uint flags);
}


================================================
FILE: Other/BuildEvents/BuildEvents.csproj
================================================
<Project Sdk="Microsoft.NET.Sdk">

	<PropertyGroup>
		<OutputType>Exe</OutputType>
		<TargetFramework>net10.0-windows</TargetFramework>
		<Configurations>Debug</Configurations>
		<GenerateAssemblyInfo>false</GenerateAssemblyInfo>
		<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
		<AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
		<AppendRuntimeIdentifierToOutputPath>false</AppendRuntimeIdentifierToOutputPath>
		<LangVersion>preview</LangVersion>
		<NoDefaultLaunchSettingsFile>true</NoDefaultLaunchSettingsFile>
		<SignAssembly>true</SignAssembly>
		<AssemblyOriginatorKeyFile>..\..\Au.snk</AssemblyOriginatorKeyFile>
	</PropertyGroup>

	<ItemGroup>
	  <Compile Remove="Au.TestInternal.cs" />
	</ItemGroup>

	<ItemGroup>
		<Compile Include="..\..\Au\resources\global2.cs" Link="global2.cs" />
	</ItemGroup>

	<ItemGroup>
	  <None Include="Au.TestInternal.cs" />
	</ItemGroup>

	<ItemGroup>
	  <PackageReference Include="LibreAutomate" Version="1.12.0" />
	  <PackageReference Include="SSH.NET" Version="2024.2.0" />
	</ItemGroup>

</Project>


================================================
FILE: Other/BuildEvents/GitBinaryFiles.cs
================================================
static class GitBinaryFiles {
	/// <summary>
	/// To call this when pushing LA to GitHub, add file `.git\hooks\pre-push`.
	/// <code><![CDATA[
	/// #!/bin/sh
	/// 
	/// "Other/BuildEvents/bin/Debug/BuildEvents.exe" "gitPrePushHook"
	/// exit $?
	/// ]]></code>
	/// </summary>
	public static int PrePushHook() {
		var laDir = Environment.CurrentDirectory + @"\_\";

		(string dir, string files, bool subdirs)[] enumFiles = [
				(null, "*.db", false),
				(null, "*MSTSCLib.dll", false),
				(null, "toc.json", false),
				(null, "toc-ai.yml", false),
				(null, "xrefmap.yml", false),
				("Roslyn", "*.dll", false),
				("Debugger", "**m *.dll||*.exe", true),
				(@"..\Other\BuildEvents\.tools", "ResourceHacker.exe", false),
			];

		List<FEFile> aFiles = new();
		foreach (var v in enumFiles) {
			foreach (var f in filesystem.enumFiles(laDir + v.dir, v.files, (v.subdirs ? FEFlags.AllDescendants : 0) | FEFlags.UseRawPath)) {
				//if (f.Name.Like("doc-*.db")) continue; //BAD: changes too frequently
				aFiles.Add(f);
			}
		}
		//print.it(aFiles);

		bool update = true;
		var csvFile = laDir + "gitBinary.csv";
		if (filesystem.exists(csvFile)) {
			update = false;
			var t = csvTable.load(csvFile);
			var d = t.ToDictionary(ignoreCase: true, ignoreDuplicates: false);
			foreach (var f in aFiles) {
				var rel = f.FullPath[laDir.Length..];
				if (filesystem.getProperties(f.FullPath, out var p) && d.TryGetValue(rel, out var prevTime)) {
					if (f.LastWriteTimeUtc.ToString("s") == prevTime) continue;
				}
				update = true;
				break;
			}
		}

		if (update) {
			var d = dialog.showProgress(true, "Updating LaBinary.7z", ".");
			d.Destroyed += k => { Environment.Exit(2); };

			var t = new csvTable();
			var b = new StringBuilder();
			foreach (var f in aFiles) {
				var rel = f.FullPath[laDir.Length..];
				t.AddRow(rel, f.LastWriteTimeUtc.ToString("s"));
				b.AppendLine(rel);
			}
			t.Save(csvFile);

			using var listFile = new TempFile();
			filesystem.saveText(listFile, b.ToString());

			d.Send.ChangeText2("Compressing...", false);
			var zipFile = folders.ThisAppTemp + "LaBinary.7z";
			filesystem.delete(zipFile);
			if (0 != run.console(out string s1, laDir + @"32\7za.exe", $@"a ""{zipFile}"" @""{listFile}""", laDir)) {
				print.it(s1);
				return 1;
			}
			//run.it(zipFile); dialog.show("zip OK");

			d.Send.ChangeText2("Uploading...", false);
			Sftp.UploadToLA("domains/libreautomate.com/public_html/download", zipFile);

			filesystem.delete(zipFile, FDFlags.CanFail);
		}

		return 0;
	}

	public static int Restore(string solutionDirBS, bool test = false) {
		var laDir = solutionDirBS + @"_\";
		if (test) {
			laDir += @"test\";
			filesystem.saveText(laDir + "gitBinaryRestore.csv", "restore");
		} else {
			if (laDir.Eqi(@"C:\code\au\_\") && Directory.Exists(@"C:\code-lib\roslyn")) return 0; //we at home
		}

		string restoreFile = laDir + "gitBinaryRestore.csv";
		if (filesystem.exists(restoreFile)) {
			var zipFile = folders.ThisAppTemp + "LaBinary.7z";
			internet.http.Get("https://www.libreautomate.com/download/LaBinary.7z", true).Download(zipFile);

			int r = run.console(out string so, solutionDirBS + @"_\32\7za.exe", $@"x ""{zipFile}"" -aoa", laDir);
			if (r != 0) throw new AuException("Failed to extract LaBinary.7z. " + so);

			filesystem.moveTo(laDir + "ResourceHacker.exe", solutionDirBS + @"Other\BuildEvents\.tools");

			filesystem.delete(restoreFile);
		}

		return 0;
	}
}


================================================
FILE: Other/BuildEvents/Readme - Roslyn.txt
================================================
LA uses modified Roslyn dlls.
How to install, update and modify:

Once: Build this project. Don't run; it will run automatically when building Roslyn project Microsoft.CodeAnalysis.CSharp.Features.

Fork and clone Roslyn:
    1. Delete the old fork repo `https://github.com/qgindi/roslyn`.
    2. Fork `https://github.com/dotnet/roslyn`. In repo settings set default branch = the latest release, like `release/dev18.3`.
    3. Git-clone `https://github.com/qgindi/roslyn.git` to `C:\code-lib\roslyn`. Do shallow clone of default branch (full >2 GB). I clone with TortoiseGit.
    Another way to update, not tested: in the GitHub fork repo page click `Sync fork`. It discards modifications. Then git-sync eg in VS. Bad: bloats .git.
Open `global.json`. May need to edit SDK version. Usually no. May need to install a newer SDK.
Open `Roslyn.sln`.
To make VS not so slow, select all folders and unload projects. Then load Microsoft.CodeAnalysis.CSharp.Features with entire dependency tree. Make it the startup project.
  It loads projects we need:
    In folder Compilers: Core\Microsoft.CodeAnalysis, CSharp\Microsoft.CodeAnalysis.CSharp.
    In folder Features: Microsoft.CodeAnalysis.CSharp.Features, Microsoft.CodeAnalysis.Features.
    In folder Workspaces: Microsoft.CodeAnalysis.CSharp.Workspaces, Microsoft.CodeAnalysis.Workspaces.
    Several other.
Edit as described below after _________.
Build Microsoft.CodeAnalysis.CSharp.Features. It also builds all dependency projects. It runs this exe.
Git commit/push (if git-cloned).

Once: In editor project add references to the main 6 dlls in _\Roslyn, with 'Copy local' false.
  For Microsoft.CodeAnalysis.Workspaces set aliases CAW.

Rejected: to make editor startup faster, publish Microsoft.CodeAnalysis.CSharp.Features with <PublishReadyToRun>.
  Tested, works, but: adds ~14 MB to the setup file; makes just ~350 ms faster, barely noticeable.

_________________________________________________________________

//Edit these manually. Often Roslyn source in new version is changed in some of these places.
//Add only internal members (where possible). If public, need to declare it in PublicApi.Shipped.txt. Roslyn's internals are visible to the editor project.

// - In all 6 projects + Scripting.csproj (but not CSharpSyntaxGenerator.csproj):
//   From <TargetFrameworks> remove netstandard2.0 etc (replace with eg net10.0). Later will compile faster.

// - Set Release config. Try to build Microsoft.CodeAnalysis.CSharp.Features (it builds all).

// - In all 6 projects add:
    <InternalsVisibleTo Include="Au.Editor" Key="0024000004800000940000000602000000240000525341310004000001000100095c6b7a0fe60fbe4a77e52dd10a09331ee3c3a7399aa9cc17db8a015647469a19784d5e33a2450a0a49c37bf17c0c3223674f64104eae649ba27c51a90c24989faec87d59217d7850efc8151109bbf9b027b7714fc01788317d2b991b2c2669836a7725e942f76607efde5cdacd8c497a45c5f9673fcf102fdbf92237a524a4" />

// - In project Microsoft.CodeAnalysis add link to Au.TestInternal.cs. It is in this project.
    <Compile Include="C:\code\au\Other\BuildEvents\Au.TestInternal.cs" Link="Au.TestInternal.cs" />

// - In Microsoft.CodeAnalysis.CSharp.Features.csproj:
// -- In <PropertyGroup> add:
    <OutputPath>$(SolutionDir)au\output</OutputPath>
    <AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
    <AppendRuntimeIdentifierToOutputPath>false</AppendRuntimeIdentifierToOutputPath>
    <CopyLocalLockFileAssemblies>true</CopyLocalLockFileAssemblies>
    <AccelerateBuildsInVisualStudio>false</AccelerateBuildsInVisualStudio>

// -- In project references add <Private>True</Private>. Also add the Scripting project (just to copy the dll).
    <ProjectReference Include="..\..\Core\Portable\Microsoft.CodeAnalysis.Features.csproj">
      <Private>True</Private>
    </ProjectReference>
    <ProjectReference Include="..\..\..\Workspaces\CSharp\Portable\Microsoft.CodeAnalysis.CSharp.Workspaces.csproj">
      <Private>True</Private>
    </ProjectReference>
    <ProjectReference Include="..\..\..\Workspaces\Core\Portable\Microsoft.CodeAnalysis.Workspaces.csproj">
      <Private>True</Private>
    </ProjectReference>
    <ProjectReference Include="..\..\..\Compilers\CSharp\Portable\Microsoft.CodeAnalysis.CSharp.csproj">
      <Private>True</Private>
    </ProjectReference>
    <ProjectReference Include="..\..\..\Compilers\Core\Portable\Microsoft.CodeAnalysis.csproj">
      <Private>True</Private>
    </ProjectReference>
    <ProjectReference Include="..\..\..\Scripting\Core\Microsoft.CodeAnalysis.Scripting.csproj">
      <Private>True</Private>
    </ProjectReference>

// -- Add postbuild:
  <Target Name="PostBuild" AfterTargets="PostBuildEvent">
    <Exec Command="C:\code\au\Other\BuildEvents\bin\Debug\BuildEvents.exe roslynPostBuild $(OutDir)" />
  </Target>

// - In .gitignore add:
au/

// Run menu Build > Clean solution.


// - Add Symbols property to the CompletionItem class:
//1. Open CompletionItem.cs in project Microsoft.CodeAnalysis.Features.
//2. Find method private CompletionItem With(...). In it find: return new CompletionItem...{
//3. In the { } add line:
            Symbols = Symbols, //au
//4. Below the method add properties:
    internal IReadOnlyList<ISymbol>? Symbols { get; set; } //au
    internal object? Attach { get; set; } //au
//5. Open Features\Core\Portable\Completion\Providers\SymbolCompletionItem.cs.
//6. In method CreateWorker find statement that starts with: var item = CommonCompletionItem.Create(
//7. Below that statement add: item.Symbols = symbols; //au

// - Add Symbol property to the SymbolKeySignatureHelpItem class:
//1. Open Features\Core\Portable\SignatureHelp\AbstractSignatureHelpProvider.SymbolKeySignatureHelpItem.cs.
//2. Add property: internal ISymbol? Symbol { get; } = symbol; //au

// - Let it don't try to load VB assemblies, because then exception when debugging:
//In MefHostServices.cs, in DefaultAssemblyNames init list, remove the 2 VisualBasic assemblies.

// - In project Microsoft.CodeAnalysis, in file PublicAPI.Shipped.txt, append:
RoslynMod.TestInternal
static RoslynMod.TestInternal.IsInternalsVisible(string thisName, string toName) -> System.Collections.Generic.IEnumerable<System.Collections.Immutable.ImmutableArray<byte>>
static RoslynMod.TestInternal.AppendInternalsVisible(string thisName, System.Collections.Generic.HashSet<string> toNames) -> void
RoslynMod.Print
static RoslynMod.Print.it(object o) -> void

// - In project Microsoft.CodeAnalysis, in MetadataReader\PEAssembly.cs, in GetInternalsVisibleToPublicKeys:
//	replace
            return result ?? SpecializedCollections.EmptyEnumerable<ImmutableArray<byte>>();
//	with
            //au
            return result ?? RoslynMod.TestInternal.IsInternalsVisible(this.Identity.Name, simpleName);

// - In project Microsoft.CodeAnalysis.CSharp, in Symbols\Source\SourceAssemblySymbol.cs, replace GetInternalsVisibleToPublicKeys with:

        //au
        internal override IEnumerable<ImmutableArray<byte>> GetInternalsVisibleToPublicKeys(string simpleName)
        {
            EnsureAttributesAreBound();

            if (_lazyInternalsVisibleToMap != null && _lazyInternalsVisibleToMap.TryGetValue(simpleName, out var result))
                return result.Keys;

            return RoslynMod.TestInternal.IsInternalsVisible(this.Name, simpleName);
        }
        //internal override IEnumerable<ImmutableArray<byte>> GetInternalsVisibleToPublicKeys(string simpleName)
        //{
        //    //EDMAURER assume that if EnsureAttributesAreBound() returns, then the internals visible to map has been populated.
        //    //Do not optimize by checking if m_lazyInternalsVisibleToMap is Nothing. It may be non-null yet still
        //    //incomplete because another thread is in the process of building it.

        //    EnsureAttributesAreBound();

        //    if (_lazyInternalsVisibleToMap == null)
        //        return SpecializedCollections.EmptyEnumerable<ImmutableArray<byte>>();

        //    ConcurrentDictionary<ImmutableArray<byte>, Tuple<Location, string>> result = null;

        //    _lazyInternalsVisibleToMap.TryGetValue(simpleName, out result);

        //    return (result != null) ? result.Keys : SpecializedCollections.EmptyEnumerable<ImmutableArray<byte>>();
        //}

// - In project Microsoft.CodeAnalysis.Workspaces, in file DependentProjectsFinder.cs, in GetInternalsVisibleToSet, insert before 'return':
        //au:
        RoslynMod.TestInternal.AppendInternalsVisible(assembly.Name, set);


================================================
FILE: Other/BuildEvents/Sftp.cs
================================================
using Microsoft.Win32;
using Renci.SshNet;
using System.Text.Json;
using System.Windows.Controls;

static class Sftp {
	public static SftpConnectionInfo GetConnectionInfo(string where = "libreautomate.com") {
		string rk = @"HKEY_CURRENT_USER\Software\Au";
		var j = JsonSerializer.Deserialize<SftpConnectionInfo>(Registry.GetValue(rk, where, "{}") as string);
		g1:
		if (j.host.NE() || j.port == 0 || j.user.NE() || j.pass.NE()) {
			var b = new wpfBuilder("SSH connection").WinSize(400);
			b.R.Add("IP", out TextBox tIp, j.host).Focus(); //note: use IP. With hostname fails when using CloudFlare CDN.
			b.R.Add("Port", out TextBox tPort, j.port.ToS());
			b.R.Add("User", out TextBox tUser, j.user);
			b.R.Add("Password", out TextBox tPass, j.pass.NE() ? null : Convert2.AesDecryptS(j.pass, "8470"));
			b.R.AddOkCancel();
			b.End();
			if (!b.ShowDialog()) return null;
			j.host = tIp.Text;
			j.port = tPort.Text.ToInt();
			j.user = tUser.Text;
			j.pass = Convert2.AesEncryptS(tPass.Text, "8470");
			Registry.SetValue(rk, where, JsonSerializer.Serialize(j));
			goto g1;
		}
		j.pass = Convert2.AesDecryptS(j.pass, "8470");
		return j;
	}
	
	public static void ConnectAndUpload(this SftpClient ftp, string ftpDir, string localFile) {
		ftp.Connect();
		ftp.ChangeDirectory(ftpDir);
		using var stream = File.OpenRead(localFile);
		ftp.UploadFile(stream, pathname.getName(localFile));
	}
	
	/// <summary>
	/// Uploads a file to libreautomate.com (IP 194.5.156.231).
	/// </summary>
	/// <param name="ftpDir">Eg <c>"domains/libreautomate.com/public_html"</c></param>
	/// <param name="localFile"></param>
	public static void UploadToLA(string ftpDir, string localFile) {
		var ci = Sftp.GetConnectionInfo(); if (ci == null) return;
		using var ftp = new SftpClient(ci.host, ci.port, ci.user, ci.pass);
		ConnectAndUpload(ftp, ftpDir, localFile);
	}
}

record SftpConnectionInfo {
	public string host { get; set; }
	public int port { get; set; }
	public string user { get; set; }
	public string pass { get; set; }
}


================================================
FILE: Other/DatabasesEtc/DatabasesEtc.csproj
================================================
<Project Sdk="Microsoft.NET.Sdk">

	<PropertyGroup>
		<OutputType>WinExe</OutputType>
		<TargetFramework>net10.0-windows</TargetFramework>
		<Configurations>Debug</Configurations>
		<GenerateAssemblyInfo>false</GenerateAssemblyInfo>
		<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
		<AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
		<AppendRuntimeIdentifierToOutputPath>false</AppendRuntimeIdentifierToOutputPath>
		<LangVersion>preview</LangVersion>
		<NoDefaultLaunchSettingsFile>true</NoDefaultLaunchSettingsFile>
		<Platforms>AnyCPU</Platforms>
	</PropertyGroup>

	<ItemGroup>
		<Compile Include="..\..\Au\resources\global2.cs" Link="global2.cs" />
	</ItemGroup>

	<ItemGroup>
		<PackageReference Include="MahApps.Metro.IconPacks" Version="5.1.0" />
	</ItemGroup>

	<ItemGroup>
		<ProjectReference Include="..\..\Au\Au.csproj" />
	</ItemGroup>

	<Target Name="PostBuild" AfterTargets="PostBuildEvent">
		<Exec Command="robocopy.exe $(SolutionDir)_\64 $(OutDir)\64 AuCpp.dll /mir &gt;nul || exit 0" />
	</Target>

</Project>


================================================
FILE: Other/DatabasesEtc/Icons.cs
================================================
//In VS set this as startup project, and run. It creates file "icons-new.db" in "_" dir.
//If everything OK: exit LA, delete "icons.db", rename "icons-new.db" -> "icons.db", run LA.

//Also need to update and upload the AI embedding storage file.
//	The "AI search" button in the Icons tool should auto-update.
//	Also it should auto-run script "Upload AI embeddings", or print a link to run it.

#define DB //undefine when debugging, to skip database code

using System.Collections;
using System.Collections.Generic;
using System.Runtime.Loader;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Markup;
using System.Xml.Linq;
//using MahApps.Metro.IconPacks;

static class Icons {
	public static void CreateDB() {
		new Application();

#if DB
		string dbFile = Program.c_outputDirBS + "icons-new.db";
		filesystem.delete(dbFile);

		using var d = new sqlite(dbFile);
		//using var d = new sqlite(dbFile, sql: "PRAGMA journal_mode=WAL"); //no. Does not make select faster.
		using var trans = d.Transaction();
		d.Execute("CREATE TABLE _tables (name TEXT COLLATE NOCASE, template TEXT)");
#endif

		Dictionary<string, HashSet<string>> dict = new(StringComparer.OrdinalIgnoreCase);
		//var duplData = new Dictionary<string, string>(); int nDupl = 0;

		var alc = AssemblyLoadContext.Default;
		var asmCore = alc.LoadFromAssemblyPath(folders.ThisApp + "MahApps.Metro.IconPacks.Core.dll");
		var factoryGen = asmCore.GetType("MahApps.Metro.IconPacks.PackIconDataFactory`1");

		int nTables = 0, nIcons = 0, nSkipped = 0;
		foreach (var dll in Directory.EnumerateFiles(folders.ThisApp, "MahApps.Metro.IconPacks.?*.dll")) {
			if (dll.Ends(".Core.dll", true)) continue;
			//print.it(dll);
			var asm = alc.LoadFromAssemblyPath(dll);
			foreach (var ty in asm.ExportedTypes.Where(o => o.Name.Like("PackIcon*Kind"))) {
				var table = ty.Name[8..^4];
				var templ = _GetTemplate(asm);
				//print.it(table, templ);
				//return;
				nTables++;

#if DB
				d.Execute("INSERT INTO _tables VALUES (?, ?)", table, templ);
				d.Execute($"CREATE TABLE {table} (name TEXT PRIMARY KEY COLLATE NOCASE, data TEXT)");
				using var statInsert = d.Statement($"INSERT INTO {table} VALUES (?, ?)");
#endif

				var hNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
				dict.Add(table, hNames);

				var factory = factoryGen.MakeGenericType(ty);
				foreach (DictionaryEntry k in factory.GetMethod("Create").Invoke(null, null) as IDictionary) {
					string name = k.Key.ToString(), data = k.Value.ToString();
					if (data.NE()) continue; //icon "None"
					if (data.Length > 10000) {
						//print.it(name, data.Length);
						nSkipped++;
						continue; //nothing very useful
					}

					//if (!duplData.TryAdd(data, table + "." + name)) {
					//	//1.2%. All from same assemblies. Often similar name, but often different.
					//	nDupl++;
					//	print.it("DUPL DATA", duplData[data], table + "." + name);
					//	continue;
					//}

					if (!hNames.Add(name)) { //duplicate name like Snowflake and SnowFlake
											 //print.it("DUPL NAME", table + "." + name);
						continue;
					}

					//print.it(table, name);

#if DB
					statInsert.Bind(1, name).Bind(2, data);
					statInsert.Step();
					statInsert.Reset();
#endif
					nIcons++;
				}
			}
		}

#if DB
		int nMissing = _AddMissingFromOldDB(d, dict);

		trans.Commit();
		d.Execute("VACUUM");
#else
		int nMissing = 0;
#endif

		print.it($"Done. {nTables} tables, {nIcons} icons, skipped {nSkipped}. Also added {nMissing} missing old icons."/*, $"{nDupl} duplicate"*/); //29 tables, 25877 icons, skipped 37
	}

	static string _GetTemplate(Assembly asm) {
		var asmname = asm.GetName().Name;
		int i = asmname.LastIndexOf('.') + 1;
		string rn = "PackIcon" + asmname[i..];
		var rd = new ResourceDictionary() { Source = new Uri($@"pack://application:,,,/{asmname};component/themes/{rn.Lower()}.xaml") };
		//print.it(rd);
		var template = rd["MahApps.Templates." + rn] as ControlTemplate;
		string xaml = XamlWriter.Save(template);
		xaml = xaml.RxReplace(@" xmlns(?::\w+)?="".+?""", "");
		var x = XElement.Parse(xaml);
		x = x.Descendants("Path").First();
		return x.ToString();
	}

#if DB
	//In new IconPacks versions some icons are renamed. For backward compatibility we need icons with old names too.
	static int _AddMissingFromOldDB(sqlite d, Dictionary<string, HashSet<string>> dict) {
		int nMissing = 0;
		using var dOld = new sqlite(Program.c_outputDirBS + "icons.db", SLFlags.SQLITE_OPEN_READONLY);
		using var stTables = dOld.Statement("SELECT name FROM _tables");
		while (stTables.Step()) {
			var table = stTables.GetText(0);
			var hsNamesNew = dict[table];
			using var statInsert = d.Statement($"INSERT INTO {table} VALUES (?, ?)");
			using var stNames = dOld.Statement($"SELECT * FROM {table}");
			while (stNames.Step()) {
				var name = stNames.GetText(0);
				if (!hsNamesNew.Contains(name)) {
					//print.it(table, name);
					nMissing++;
					statInsert.Bind(1, name).Bind(2, stNames.GetText(1));
					statInsert.Step();
					statInsert.Reset();
				}
			}
		}
		return nMissing;
	}
#endif
}


================================================
FILE: Other/DatabasesEtc/Program.cs
================================================
static class Program {
	public const string c_outputDirBS = @"C:\code\au\_\";

	[STAThread]
	static void Main(string[] args) {
		script.setup();
		print.qm2.use = true;
		print.clear();

		RefTxt.Create();
		//RefAndDoc.Create();
		//Icons.CreateDB();
	}
}


================================================
FILE: Other/DatabasesEtc/RefAndDoc.cs
================================================
static class RefAndDoc {
	/// <summary>
	/// Creates SQLite databases containing design-time assemblies (ref.db) and XML doc files (doc.db) of a .NET runtime. The SDK must be installed.
	/// Run after changing .NET version of C# projects (<TargetFramework>...</TargetFramework>).
	/// Without it scripts cannot be compiled.
	/// Later can be called at any time if need to update something. At first exit editor (it locks databases).
	/// </summary>
	/// <remarks>
	/// Shows a list dialog.
	/// 	If selected All, creates for all runtime versions starting from 6.0, with names ref.version.db (eg ref.6.0.0.db) and doc.version.db, in folder _.
	/// 	Else creates only for the selected runtime version, with names ref.db and doc.db, in folder _. Editor locks them therefore must not be running.
	/// We ship and at run time load databases of single version, named ref.db and doc.db. In the future could allow to download and use multiple versions.
	/// Also this function could allow users to create databases from SDKs installed on their PC, but currently this feature is not exposed. Would need to add UI and exception handling.
	/// ref.db contains dlls from 'dotnet\packs' folder. They contain only metadata of public API, not all code like dlls in the 'dotnet\shared' folder.
	/// 	Why need it when we can load PortableExecutableReference from 'dotnet\shared' folder? Because:
	/// 		1. They are big and may add 100 MB of process memory. We need to load all, because cannot know which are actually used in various stages of compilation.
	/// 		2. When loading from dll files, Windows Defender makes it as slow as 2.5 s or more, unless the files already are in OS file buffers.
	/// 		3. Better compatibility. See https://github.com/dotnet/standard/blob/master/docs/history/evolution-of-design-time-assemblies.md
	/// doc.db contains XML documentation files of .NET runtime assemblies. From the same 'dotnet\packs' folder.
	/// 	Why need it:
	/// 		1. Else users would have to download whole .NET SDK. Now need only runtimes.
	/// 		2. Parsed XML files can use eg 200 MB of process memory. Now we get doc of a single type/method/etc from database only when need; all other data is not in memory.
	/// </remarks>
	public static void Create() {
		string dirPacks = @"C:\Program Files\dotnet\packs";
		string dirCore = dirPacks + @"\Microsoft.NETCore.App.Ref\";
		var a = new List<string>();
		foreach (var f in filesystem.enumerate(dirCore)) { //for each version
			if (!f.IsDirectory) continue;
			var s = f.Name;
			int v1 = s.ToInt(0, out int ne), v2 = s.ToInt(ne + 1);
			if (v1 < 6 || (v1 == 6 && v2 < 0)) continue; //must be 6.0 or later
			a.Add(s);
		}
		a.Add("All");
		int i = dialog.showList(a, "Create database", "For runtime", footer: "Note: These are .NET SDK reference assembly directories. Versions may not match versions of runtime and even SDK.") - 1;
		if (i < 0) return;
		int n = a.Count - 1;
		if (i < n) {
			_CreateRefAndDoc(dirPacks, dirCore, a[i], false);
		} else {
			for (i = 0; i < n; i++) _CreateRefAndDoc(dirPacks, dirCore, a[i], true);
		}
		print.it("RefAndDoc.Create done.");
	}

	static void _CreateRefAndDoc(string dirPacks, string dirCore, string version, bool all) {
		string subdirRN = @"\ref\net" + version.RxReplace(@"^\d+\.\d+\K.+", @"\", 1);

		var dir1 = dirCore + version + subdirRN;
		if (!filesystem.exists(dir1, true).Directory) throw new DirectoryNotFoundException("Not found: " + dir1);

		//find WindowsDesktop folder. Must have same X.X.X version. The preview or rc version may be different.
		bool preview; int i = version.IndexOf('-');
		if (preview = i > 0) version = version[..(i + 3)]; //eg "8.0.0-rc"
		string verDesktop = null;
		string dirDesktop = dirPacks + @"\Microsoft.WindowsDesktop.App.Ref\";
		foreach (var f in filesystem.enumerate(dirDesktop, FEFlags.UseRawPath)) { //for each version
			if (!f.IsDirectory) continue;
			var s = f.Name;
			if (preview ? s.Starts(version, true) : s == version) { verDesktop = s; break; }
		}
		if (verDesktop == null) throw new DirectoryNotFoundException("Not found: WindowsDesktop SDK");
		var dir2 = dirDesktop + verDesktop + subdirRN;
		if (!filesystem.exists(dir2, true).Directory) throw new DirectoryNotFoundException("Not found: " + dir2);

		string dbRef, dbDoc;
		if (all) {
			dbRef = Program.c_outputDirBS + "ref." + version + ".db";
			dbDoc = Program.c_outputDirBS + "doc." + version + ".db";
		} else {
			dbRef = Program.c_outputDirBS + "ref.db";
			dbDoc = Program.c_outputDirBS + "doc.db";
		}
		_CreateRef(dbRef, dir1, dir2);
		_CreateDoc(dbDoc, dir1, dir2);
	}

	static void _CreateRef(string dbFile, string dir1, string dir2) {
		filesystem.delete(dbFile);
		using var d = new sqlite(dbFile);
		using var trans = d.Transaction();
		d.Execute("CREATE TABLE ref (name TEXT PRIMARY KEY, data BLOB)");
		using var statInsert = d.Statement("INSERT OR REPLACE INTO ref VALUES (?, ?)");

		_AddDir(dir1, "WindowsBase", "System.Drawing");
		_AddDir(dir2);

		trans.Commit();
		d.Execute("VACUUM");

		print.it("Created " + dbFile);

		void _AddDir(string dir, params string[] skip) {
			foreach (var f in filesystem.enumerate(dir)) {
				if (f.IsDirectory) continue;
				if (!f.Name.Ends(".dll", true)) continue;
				var asmName = f.Name[..^4];
				if (skip.Contains(asmName)) continue;
				_AddFile(asmName, f.FullPath);
				//break;
			}
		}

		void _AddFile(string asmName, string asmFile) {
			//print.it(asmName);
			statInsert.Bind(1, asmName);
			statInsert.Bind(2, File.ReadAllBytes(asmFile));
			statInsert.Step();
			statInsert.Reset();
		}
	}

	static void _CreateDoc(string dbFile, string dir1, string dir2) {
		filesystem.delete(dbFile);
		using var d = new sqlite(dbFile, sql: "PRAGMA page_size = 8192;"); //8192 makes file smaller by 2-3 MB.
		using var trans = d.Transaction();
		d.Execute("CREATE TABLE doc (name TEXT PRIMARY KEY, xml TEXT)");
		using var statInsert = d.Statement("INSERT INTO doc VALUES (?, ?)");
		using var statDupl = d.Statement("SELECT xml FROM doc WHERE name=?");
		var haveRefs = new List<string>();
		var uniq = new Dictionary<string, string>(); //name -> asmName

		//using var textFile = File.CreateText(Path.ChangeExtension(dbFile, "txt")); //test. Compresses almost 2 times better than db.

		_AddDir(dir1, "WindowsBase");
		_AddDir(dir2);

		statInsert.BindAll(".", string.Join("\n", haveRefs)).Step();

		trans.Commit();
		d.Execute("VACUUM");

		print.it("Created " + dbFile);

		void _AddDir(string dir, params string[] skip) {
			foreach (var f in filesystem.enumerate(dir)) {
				if (f.IsDirectory) continue;
				if (!f.Name.Ends(".xml", true)) continue;
				var asmName = f.Name[..^4];
				if (skip.Contains(asmName)) continue;
				if (!filesystem.exists(dir + asmName + ".dll").File) {
					print.it("<><c 0x808080>" + f.Name + "</c>");
					continue;
				}
				_AddFile(asmName, f.FullPath);
				//break;
			}
		}

		void _AddFile(string asmName, string xmlFile) {
			//print.it(asmName);
			haveRefs.Add(asmName);
			var xr = XmlUtil.LoadElem(xmlFile);
			foreach (var e in xr.Descendants("member")) {
				var name = e.Attr("name");

				//remove <remarks> and <example>. Does not save much space, because .NET xmls don't have it.
				foreach (var v in e.Descendants("remarks").ToArray()) v.Remove();
				foreach (var v in e.Descendants("example").ToArray()) v.Remove();

				using var reader = e.CreateReader();
				reader.MoveToContent();
				var xml = reader.ReadInnerXml();
				//print.it(name, xml);

				//textFile.WriteLine(name); textFile.WriteLine(xml); textFile.WriteLine("\f");

				if (uniq.TryGetValue(name, out var prevRef)) {
					if (!statDupl.Bind(1, name).Step()) throw new AuException();
					var prev = statDupl.GetText(0);
					if (xml != prev && asmName != "System.Linq") print.it($"<>\t{name} already defined in {prevRef}\r\n<c 0xc000>{prev}</c>\r\n<c 0xff0000>{xml}</c>");
					statDupl.Reset();
				} else {
					statInsert.BindAll(name, xml).Step();
					uniq.Add(name, asmName);
				}
				statInsert.Reset();
			}
		}
	}
}


================================================
FILE: Other/DatabasesEtc/RefTxt.cs
================================================
static class RefTxt {
	/// <summary>
	/// Creates dotnet_ref_editor.txt and dotnet_ref_task.txt.
	/// Run immediately after changing .NET version of C# projects (<TargetFramework>...</TargetFramework>).
	/// Then update .NET version in AppHost.cpp and build.
	/// Without it editor cannot start.
	/// Later can be called at any time if need to update something.
	/// </summary>
	/// <exception cref="AuException"></exception>
	public static void Create() {
		var b = new StringBuilder();
		var hd = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
		_Dir(folders.NetRuntimeDesktopBS + "Microsoft.WindowsDesktop.App.deps.json", "*d|"); //must be first, because several assemblies are in both folders, and need to use from Desktop
		_Dir(folders.NetRuntimeBS + "Microsoft.NETCore.App.deps.json", "|*c|");

		//Au.Task
		b.Append("|*a|Au");
		File.WriteAllText(Program.c_outputDirBS + "dotnet_ref_task.txt", b.ToString());

		//Au.Editor
		b.Append("|Au.Controls");
		print.it(b);
		File.WriteAllText(Program.c_outputDirBS + "dotnet_ref_editor.txt", b.ToString());

		void _Dir(string jsonFile, string prefix) {
			//rejected: parse with JsonNode.
			var a = new List<string>();
			var s = File.ReadAllText(jsonFile);
			//print.it(s);
			int from = s.Find("\"runtime\": {"), to = s.Find("\"native\": {", from);
			if (!s.RxFindAll(@"(?m)\h*""([^""]+)\.dll"": {", 1, out string[] k, range: from..to)) throw new AuException();
			foreach (var v in k) {
				if (!hd.Add(v)) {
					//print.it("duplicate", v);
					continue;
				}
				a.Add(v);
			}
			b.Append(prefix);
			b.AppendJoin('|', a.OrderBy(o => o));
		}
		//note: cannot use AssemblyDependencyResolver._assemblyPaths or corehost_resolve_component_dependencies.
		//	Error "Hostpolicy must be initialized and corehost_main must have been called before". Our apphost does not use corehost_main etc.
	}
}


================================================
FILE: Other/DocFX/DocFX.csproj
================================================
<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <OutputType>WinExe</OutputType>
    <TargetFramework>net10.0-windows</TargetFramework>
    <UseWindowsForms>true</UseWindowsForms>
    <AssemblyName>Au.DocFX</AssemblyName>
    <RootNamespace>Au.DocFX</RootNamespace>
    <SignAssembly>true</SignAssembly>
    <AssemblyOriginatorKeyFile>..\..\Au.snk</AssemblyOriginatorKeyFile>
    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
    <CopyLocalLockFileAssemblies>true</CopyLocalLockFileAssemblies>
    <OutDir>bin</OutDir>
	  <LangVersion>preview</LangVersion>
	  <Platforms>AnyCPU</Platforms>
  </PropertyGroup>

  <ItemGroup>
    <Content Remove="_doc\**" />
    <Compile Remove="_doc\**" />
    <EmbeddedResource Remove="_doc\**" />
    <None Include="_doc\**" />
    <None Remove="_doc\_site\**" />
    <None Remove="_doc\_exported_templates\**" />
    <None Remove="_doc\cookbook\**" />
    <None Remove="_doc\api\*.yml" />
    <None Remove="_doc\api\.manifest" />
  </ItemGroup>

</Project>


================================================
FILE: Other/DocFX/_doc/.gitignore
================================================
###############
#    folder   #
###############
/**/DROP/
/**/TEMP/
/**/packages/
/**/bin/
/**/obj/
_site/
_exported_templates/
*.tar
*.gz
/test/


================================================
FILE: Other/DocFX/_doc/api/.gitignore
================================================
###############
#  temp file  #
###############
*.yml
.manifest


================================================
FILE: Other/DocFX/_doc/api/index.md
================================================
# Library

[Library files and namespaces](xref:library)


================================================
FILE: Other/DocFX/_doc/articles/Caller info parameter.md
================================================
---
uid: caller_info
---

# Caller info parameter

Some functions have optional parameters *f_* and/or *l_* with attribute `[CallerFilePath]` or `[CallerLineNumber]`. They automatically pass source file/line info to the function. Usually the caller should not use them.

For example, [popupMenu]() and [toolbar]() use it for the **Edit** command (context menu). Triggers use it for menu **Run > Recent > trigger**.

If to add menu/toolbar items or triggers you create an intermediate function, the function should have *f_* and/or *l_* parameters and pass them to the menu/toolbar/trigger function. Example script:

```csharp
var m = new popupMenu("431beeab-e190-495a-be8f-05732ef6a74f");
m["Right click me to edit"] = o => print.it(1);
_AddMenuItem("You can edit me too", o => print.it(2));
_AddMenuItemWrongWay("But can be difficult to edit me", o => print.it(3));
m.Show();

void _AddMenuItem(string label, Action<PMItem> action, [CallerLineNumber] int l_ = 0) {
	m[label, l_: l_] = action;
	m.Last.TextColor = 0x0000ff;
}

void _AddMenuItemWrongWay(string label, Action<PMItem> action) {
	m[label] = action;
	m.Last.TextColor = 0xff0000;
}
```

================================================
FILE: Other/DocFX/_doc/articles/Key names and operators.md
================================================
---
uid: key_names
---

# Key names and operators

This string syntax is used with [keys.send]() and other keyboard functions of this library. A string can contain one or more US keyboard key names separated with a space or operator like `+`.

Example:

```csharp
keys.send("A F2 Ctrl+Shift+A Enter*2"); //keys A, F2, Ctrl+Shift+A, Enter Enter
```

## Key names

### Named keys
- **Modifier:** `Alt`, `Ctrl`, `Shift`, `Win`, `RAlt`, `RCtrl`, `RShift`, `RWin`
- **Navigate:** `Esc`, `End`, `Home`, `PgDn`, `PgUp`, `Down`, `Left`, `Right`, `Up`
- **Other:** `Back`, `Delete`, `Enter`, `Apps`, `Pause`, `PrtSc`, `Space`, `Tab`
- **Function:** `F1`-`F24`
- **Lock:** `CapsLock`, `NumLock`, `ScrollLock`, `Insert`

A key name must start with an uppercase character. Other characters - any case. Only the first 3 characters are significant. For example, for `"Back"` you can also use `"Bac"`, `"Backspace"` or `"BACK"`.

Alias: `AltGr`=`RAlt`, `Menu`=`Apps`, `PageDown`=`PgDn`, `PD`=`PgDn`, `PageUp`=`PgUp`, `PU`=`PgUp`, `PrintScreen`=`PrtSc`, `PS`=`PrtSc`, `BS`=`Back`, `PB`=`Pause`, `CL`=`CapsLock`, `NL`=`NumLock`, `SL`=`ScrollLock`, `HM`=`Home`.

### Text keys
- **Alphabetic:** `A`-`Z` or `a`-`z` (case-insensitive)
- **Number:** `0`-`9`
- **Numeric keypad:** `#/`, `#*`, `#-`, `#+`, `#.`, `#0`-`#9`
- **Other:** `` ` ``, `-`, `=`, `[`, `]`, `\`, `;`, `'`, `,`, `.`, `/`

Note: these are key names on US keyboard. They may not match key names on your keyboard. To specify characters instead, use operators (see below). Also in LibreAutomate you can use the input recorder.

Only uppercase A-Z must be separated with spaces. Example of a valid sequence: `"A B ab"`.

Alias: `~`=`` ` ``, `{`=`[`, `}`=`]`, `|`=`\`, `:`=`;`, `"`=`'`, `<`=`,`, `>`=`.`, `?`=`/`.

### Other keys
- Names of enum [KKey]() members. Example: `keys.send("BrowserBack MediaNextTrack VolumeUp IMEKanaMode");`
- Virtual-key codes. Prefix `VK` or `Vk`. Example: `keys.send("VK65 VK0x42");`
- Unavailable: `Fn` (hardware-only key).

### Special characters
- **Operator:** `+`, `*`, `(`, `)`, `_`, `^`
- **Numpad key prefix:** `#`
- **Text/HTML argument prefix:** `!`, `%`
- **Reserved:** `@`, `$`, `&`

These characters cannot be used as key names. Instead use key names listed in the "Text keys" section.

## Operators

| Operator | Examples | Description |
| --- | --- | --- |
| `+` | `"Ctrl+Shift+A"`<br>`"Alt+E+P"` | Hotkey. Like `"Ctrl*down Shift*down A Shift*up Ctrl*up"` and `"Alt*down E*down P E*up Alt*up"`. |
| `+()` | `"Alt+(E P)"` | Hotkey. Like `"Alt*down E P Alt*up"`.<br>Inside `()` cannot be used operators `+`, `+()` and `^`. |
| `*down` | `"Ctrl*down"` | Press key and don't release. |
| `*up` | `"Ctrl*up"` | Release key. |
| `*n` | `"Left*3"`<br>`$"Left*{i}"` | Press key n times, like `"Left Left Left"`.<br>See [keys.AddRepeat](). |
| `_` | `"Tab _A_b Tab"`<br>`"Alt+_e_a"`<br>`"_**20"` | Send next character like text with option [OKeyText.KeysOrChar]().<br>Can be used to `Alt`-select items in menus, ribbons and dialogs regardless of current keyboard layout. |
| `^` | `"Alt+^ea"` | Send all remaining characters and whitespace like text with option [OKeyText.KeysOrChar]().<br>For example `"Alt+^ed b"` is the same as `"Alt+_e_d Space _b"`.<br>`Alt` is released after the first character. Don't use other modifiers. |

Operators and related keys can be in separate arguments. Examples: `keys.send("Shift+", KKey.A); keys.send(KKey.A, "*3");`.

### Raw text

The primary way to send raw text using `keys.send` - use a separate string argument with prefix `!`. Example: `keys.send("!User", "Tab", "!" + clipboard.text, "Tab Enter");`.

Unlike operators `^` and `_`:
- Uses option `opt.key.TextHow` (keys/characters/paste). The default is characters.
- Supports 2-char Unicode characters.

To paste HTML, use prefix `%` instead.


================================================
FILE: Other/DocFX/_doc/articles/Library.md
================================================
---
uid: library
---

# Library

## Namespaces
- `Au` - main classes of this library, except triggers.
- `Au.Types` - types of function parameters, exceptions, etc.
- `Au.Triggers` - triggers: hotkeys, autotext, mouse, window.
- `Au.More` - classes that are rarely used in automation scripts.

## Files
### .NET assembly files
- `Au.dll` - contains code of the above namespaces.

### Native code files
- `AuCpp.dll`, `Au.DllHost.exe` - used by `Au.dll`.

These files are in LibreAutomate subfolders `64` and `32`. The exe compiler copies them to the exe folder. When using the library via NuGet, they are in subfolder `runtimes`.

Other dll files in the LibreAutomate folder are not part of the library. They are undocumented.

## Using the library without LibreAutomate
To get the dlls use NuGet package [LibreAutomate](https://www.nuget.org/packages/LibreAutomate). Or copy from the LibreAutomate folder. Or build from source code.

Your project settings:
- Target OS = Windows.
- Supported OS version >= 7.0.
- Use a manifest like [this](https://github.com/qgindi/LibreAutomate/blob/master/_/default.exe.manifest). It enables common controls 6, all OS versions, full DPI awareness, `disableWindowFiltering`.

If not using NuGet, add the native code files to the project. Add them as links, and in dll **Properties** set **Content** and **Copy if newer**.

If some library functions throw `DllNotFoundException` (missing `AuCpp.dll` etc), add environment variable `Au.Path` with value = `Au.dll` folder path. May need this when the host program copies `Au.dll` somewhere without the native dll folders, for example in some scripting environments and GUI designers.

See also: [unloading AuCpp.dll from other processes](https://www.libreautomate.com/forum/showthread.php?tid=7557)


================================================
FILE: Other/DocFX/_doc/articles/Output tags.md
================================================
---
uid: output_tags
---

# Output tags

Function [print.it]() supports links, colors, images, etc. For it use tags in text. Similar to HTML tags. Also text must start with `<>`. It works only when text is displayed in the editor's output panel, not when in console.

For most tags use this format: `<tag>text<>` or `<tag attribute>text<>`.

For these tags use `<tag>text</tag>`: `<code>`, `<_>`, `<\a>`, `<fold>`.

These tags don't have a closing tag: `<image "attribute">`, `<nonl>`.

Attribute can be enclosed in `'` or `"`. If attribute omitted, text is used as attribute if need for that tag.

Tags can be nested, like `<b><c green>text<><>` or `<b>text <c green>text<> text<>`.

Examples:
```csharp
print.it("<>Text <i>italic<>, <c green>color<>, <link http://www.example.com>Link<>.");
print.it("<>Code example:\r\n<code>mouse.click(10, 20); //comments</code>");
```

### Simple formatting tags
| Examples | Comments
| - | -
| `<b>text<>` | Bold text.
| `<i>text<>` | Italic text.
| `<bi>text<>` | Bold italic.
| `<u>text<>` | Underline.
| `<c 0xE0A000>text<>`<br>`<c #E0A000>text<>`<br>`<c green>text<>` | Text color.<br>Can be 0xRRGGBB, #RRGGBB or .NET color name.
| `<bc yellow>text<>` | Text background color.
| `<lc wheat>line text<>` | Line background color.
| `<size 10>text<>` |  Font height.<br>Note: it can increase height of all lines.
| `<mono>text<>` | Monospace font.

### Links
| Examples | Comments
| - | -
| `<link http://www.example.com>text<>`<br>`<link C:\files\example.exe>text<>`<br>`<link>http://www.example.com<>`<br>`<link>C:\files\example.exe<>`<br>`<link C:\example.exe|args>text<>` | Opens a web page or runs a program, file, folder.<br>Calls function [run.itSafe]().
| `<explore>C:\files\example<>` | Selects a file or folder in File Explorer.<br>Calls function [run.selectInExplorer]().
| `<google s1>text<>`<br>`<google>s1<>`<br>`<google s1|s2>text<>` | Google. Opens this URL:<br>`$"http://www.google.com/search?q={s1}{s2}"`<br>Don't need to URL-encode.
| `<help>Class.Function<>`<br>`<help Au.Namespace.Class>text<>`<br>`<help articles/Output tags>text<>` | Opens a help page of this library.
| `<open>Script5.cs<>`<br>`<open \Folder\Script5.cs>text<>`<br>`<open Script5.cs|10>text<>`<br>`<open Script5.cs|10|15>text<>`<br>`<open Script5.cs||100>text<>`<br>`<open Script5.cs|||word>text<>`<br>`<open Folder|expand>text<>` | Opens a script or other file of current workspace in the code editor. Optionally moves the text cursor.<br>Can be file name, relative path in workspace, or full path.<br>10 is 1-based line index.<br>15 is 1-based character index in line.<br>100 is 0-based character index in text.<br>The word is text to find, whole word(s).<br>Selects and expands a folder.
| `<script>Script5.cs<>`<br>`<script \Folder\Script5.cs>text<>`<br>`<script Script5.cs|args0|args1>text<>` | Runs a script.

### Other tags
| Examples | Comments
| - | -
| `<_>text</_>` or `<\a>text</\a>` | Literal text. Tags in it are ignored.<br>Here `\a` is escape sequence for character code 7.
| `<code>var s="example";</code>` | Colored C# code. Tags in it are ignored.
| `<fold>text</fold>` | Folded (hidden) lines. Adds a link to unfold (show).
| `<fold link text>text</fold>` | Folded lines with custom link text.
| `<nonl>` | No new line. Next time will write in the same line.<br>Must be at the end of string.

### Images
Images are displayed below current line. Examples:

`<image "c:\images\example.png">`\
`<image "c:\files\example.txt">`\
`<image "image:PngBase64">`

Note: image path must be enclosed in `""`.

Supports images of formats: png, bmp, jpg, gif, ico (only 16x16). For other file types and folders displays small file icon.

Supports icon names (see menu **Tools > Icons**) and XAML images.

Supports Base64 encoded image file data. To create such string use dialog **Find image or color in window** or function `Au.Controls.KImageUtil.ImageToString` (in `Au.Controls.dll`).



================================================
FILE: Other/DocFX/_doc/articles/UAC.md
================================================
---
uid: uac
title: UAC
---

# User Account Control (UAC)

UAC is a Windows security feature. It does not allow most programs to change important files and Windows settings. Only processes that run as administrator can do it. Also non-admin processes cannot interact with windows of admin processes.

The script editor should run as administrator (recommended but not necessary). It can always start as administrator without UAC consent. If started not as administrator, it prints some information and a link to enable this feature. If later you want to disable this feature, delete or disable Windows Task Scheduler task `\Au\Au.Editor`. To disable temporarily, start the program with command line `/n`.

Scripts run in separate processes. They inherit the editor's UAC integrity level (admin/nonadmin), unless changed in **Properties > uac** or the exe script is launched not by the editor.

Classes and functions that can be used to get UAC-related info: [uacInfo](), [wnd.Uac](), [wnd.UacAccessDenied]().

```csharp
print.it(uacInfo.isAdmin, uacInfo.ofThisProcess.IntegrityLevel);
```

When an admin process creates a new process, normally the new process is admin too. However [run.it]() by default creates a non-admin process.

Non-admin processes have these limitations (and more).
- Can't write to some folders, including `Windows` and `Program Files`.
- Can't write to some registry parts, including `HKEY_LOCAL_SYSTEM` and `HKEY_CLASSES_ROOT`.
- Can't manipulate services.
- Can't use some Windows API.
- Can't interact with admin windows: send keys and mouse clicks, use UI elements, manipulate windows, send Windows messages, etc.
- While an admin window is active, non-admin processes can't use most triggers, hooks and hotkeys, get key/mouse states.

Admin processes have some UAC-related problems too.
- Admin processes can't easily start non-admin processes. It is possible with workarounds only.
- You can't drag and drop files etc from a non-admin to addmin process.
- Admin processes can't get active COM objects from non-admin processes.
- Admin processes don't see drive letter mappings done by non-admin processes. In scripts use network path, like `"\\server\share\file"` instead of `"X:"`.


================================================
FILE: Other/DocFX/_doc/articles/UI element issues.md
================================================
---
uid: ui_element_issues
---

# UI element issues

UI elements are implemented and live in their applications. Classes [elm]() and [elmFinder]() just communicate with them.

Many applications have various problems with their UI elements: bugs, incorrect/nonstandard/partial implementation, or initially disabled. This library implements workarounds for known problems, where possible.

### Known issues in various applications

**Application:** Chrome web browser. Also Edge, Brave, Opera and other apps that use Chromium. Window class name `"Chrome_WidgetWin_1"`.  
1. Web page UI elements initially are disabled (missing).
   Workarounds:
   - Functions [elmFinder.Find](), [elmFinder.Exists](), [elmFinder.Wait]() and [elmFinder.FindAll]() enable it if used role prefix `"web:"` or `"chrome:"`. Functions [elm.fromXY](), [elm.fromMouse]() and [elm.focused]() enable it if window class name starts with `"Chrome"`. However Chrome does it lazily, therefore shortly after enabling something still may not work. Note: this auto-enabling may fail with future Chrome versions.
   - Start Chrome with command line `--force-renderer-accessibility`.
2. Sometimes [elmFinder.Find]() etc may not find the element if parameter *wait* not used, especially after auto-enabling UI elements. Use *wait*, like `var e1 = w1.Elm["web:LINK", "Example"].Find(5);`.
3. Some new web browser versions add new features or bugs that break something.

**Application:** Firefox web browser.  
1. When Firefox starts, its web page UI elements are unavailable. Creates them only when something tries to find or get an element, but does it lazily, and the find/get function at first fails. Workaround: with [elmFinder.Find]() use parameter *wait*, like `var e1 = w1.Elm["web:LINK", "Example"].Find(5);`.
2. Occasionally Firefox briefly turns off its web page UI elements. Workaround: use parameter *wait*. With other web browsers also it's better to use *wait*.
3. Some new web browser versions add new features or bugs that break something.

**Application:** Applications (or just some windows) that don't have accessible objects but have UI Automation elements.
1. To find UI elements in these applications, need flag [EFFlags.UIA]().

**Application:** Java applications that use AWT/Swing. Window class name starts with `"SunAwt"`.
1. Must be enabled Java Access Bridge (JAB).  
If JAB is missing/disabled/broken, the **Find UI element** tool shows an "enable" link when you try to capture something in a Java window. Or you can enable JAB in **Options > OS**. Or use `jabswitch.exe`. Then restart Java apps. Also may need to restart apps that tried to use Java UI elements.
2. JAB is part of Java. Install Java 64-bit x64 or ARM64 (as your OS).
3. If you'll use JAB in 32-bit script processes (unlikely), also install Java 32-bit. If you'll use JAB in x64 script processes on Windows ARM64 (unlikely), also install Java x64.
4. Not supported on 32-bit OS.
5. JAB bug: briefly shows a console window at PC startup, after every sleep, etc. Or opens an invalid Windows Terminal window. Workaround: in Terminal settings set Default Terminal Application = Windows Console Host.

**Application:** Some controls.
1. UI elements of some controls are not connected to the UI element of the parent control. Then cannot find them if searching in whole window.  
Workaround: search only in that control. For example, use *prop* `"class"` or `"id"`. Or find the control ([wnd.Child]() etc) and search in it.

**Application:** Some controls with flag [EFFlags.NotInProc]().

UI elements of many standard Windows controls have bugs when they are retrieved without loading dll into the target process (see [EFFlags.NotInProc]()). Known bugs:
1. Toolbar buttons don't have `Name` in some cases.
2. [elm.Focus]() and [elm.Select]() often don't work properly.

Workarounds: Don't use [EFFlags.NotInProc](). Or use [EFFlags.UIA]().

**Application:** Where cannot load dll into the target process. For example Windows Store apps.
1. Function [elmFinder.Find]() is much slower, and uses much more CPU when waiting. More info: [EFFlags.NotInProc]().

**Application:** Processes of a different CPU architecture (32/64/ARM64) than this process.
1. To load the dll is used `Au.DllHost.exe`, which makes slower first time.

**Application:** DPI-scaled windows (see [Dpi.IsWindowVirtualized]()).
1. In some cases "element from point" and "get rectangle" functions may not work correctly with such windows. This process must be per-monitor-DPI-aware (LA script processes are).


================================================
FILE: Other/DocFX/_doc/articles/Wait timeout.md
================================================
---
uid: wait_timeout
---

# Wait timeout

Most "wait for" functions have a *timeout* parameter. It is the maximal time to wait, in seconds. If 0, waits indefinitely. If > 0, after that time interval throws `TimeoutException`. If < 0, after that time interval returns the default value of the return type (`false`, `null`, `0`, `default`).

Some "find" functions have a *wait* parameter. It is like *timeout*, but 0 means "don't wait". To wait indefinitely, use some large value, for example `8e88`. Also, "find" functions throw `NotFoundException`, not `TimeoutException`.

The type of these parameters is [Seconds](). It allows to specify wait options.

Examples:
```csharp
//wait for Notepad window
var w = wnd.wait(0, true, "* Notepad");
print.it(w);

//wait for Notepad window max 5 seconds. Then throw exception.
var w = wnd.wait(5, true, "* Notepad");
print.it(w);

//wait for Notepad window max 5 seconds. Then exit.
var w = wnd.wait(-5, true, "* Notepad");
if(w.Is0) { print.it("timeout"); return; }
print.it(w);

//wait for hotkey max 5 seconds. Then exit.
if(!keys.waitForHotkey(-5, "Ctrl+Shift+K")) return;
print.it("hotkey");

//specify wait options
wait.until(new Seconds(0) { Period = 100, MaxPeriod = 100 }, () => keys.isCtrl);
```


================================================
FILE: Other/DocFX/_doc/articles/Wildcard expression.md
================================================
---
uid: wildcard_expression
---

# Wildcard expression

*Wildcard expression* is a simple text format that supports wildcard characters, regular expression, "match case", "text1 or text2" and "not text". Used with "find" functions, for example [wnd.find]().

Wildcard characters:

| Character | Will match | Examples |
| :- | :- | :- |
| `*` | Zero or more of any characters. | `"start*"`, `"*end"`, `"*middle*"` |
| `?` | Any single character. | `"date ????-??-??"` |

There are no escape sequences for `*` and `?` characters, unless you use regular expression.

By default case-insensitive. Always culture-insensitive.

Can start with `**options `:

| Option | Description | Examples |
| :- | :- | :- |
| `t` | Literal text (`*` and `?` are not wildcard characters). | `"**t text"` |
| `r` | Text is PCRE regular expression ([regexp]()).<br>Syntax: [full](https://www.pcre.org/current/doc/html/pcre2pattern.html), [short](https://www.pcre.org/current/doc/html/pcre2syntax.html). | `"**r regex"` |
| `R` | Text is .NET regular expression (`Regex`).<br>Cannot be used with [elm]() and [elmFinder](). | `"**R regex"` |
| `c` | Must match case. | `"**tc text"`, `"**rc regex"` |
| `m` | Multi-part (match any part). Separator `||`. | `"**m findAAA||orBBB||**r orCCC"` |
| `m(sep)` | Multi-part. Separator `sep`. | `"**m(^^^) findAAA^^^orBBB"` |
| `n` | Must not match. | `"**mn notAAA||andNotBBB"` |

 Only one of `t`, `r`, `R`, `m` can be specified. Option `c` specified with `m` is applied to all parts. Option `n` is applied finally.

 If the function argument is `null` or omitted, it usually means "match any". Wildcard expression `""` matches only `""`. Exception `ArgumentException` if invalid `**options ` or regular expression.

Examples:
```csharp
//Find window. Its name ends with "- Notepad" and program is "notepad.exe".
var w = wnd.find("*- Notepad", program: "notepad.exe");

//Find item in x. Its property 1 is "example" (case-insensitive), property 2 starts with "2017-" and property 3 matches a case-sensitive regular expression.
var item = x.FindItem("example", "2017-*", "**rc regex");
```

### See also

[wildex]()<br>[ExtString.Like]()


================================================
FILE: Other/DocFX/_doc/articles/index.md
================================================


================================================
FILE: Other/DocFX/_doc/articles/toc.yml
================================================
- name: Library
  href: Library.md

- name: Key names and operators
  href: Key names and operators.md

- name: Output tags
  href: Output tags.md

- name: UAC
  href: UAC.md

- name: Wildcard expression
  href: Wildcard expression.md


================================================
FILE: Other/DocFX/_doc/changes/future.md
================================================
# Version 1..0 (2025-)

## Editor

Using .NET 10.

Updated Roslyn dlls (C# compiler).

New tools:
- .

New cookbook recipes:
- .

Improved in **NuGet** tool:
- Restores old folder contents if failed to install/update.
- Can update dlls that are currently loaded in script processes.

Improved:
- .

Fixed bugs:
- Was defined `NET8_0`.

## Library

New classes:
- .

New members:
- .

New parameters:
- .

Improved:
- .

Fixed bugs:
- .

### Breaking changes


================================================
FILE: Other/DocFX/_doc/changes/old/v0.1.md
================================================
## Version 0.1.0

### Breaking changes

**elm** and **elmFinder**:
- Removed functions **elm.find**, **elm.wait**, **elm.printAll**, **elm.Find**, **elm.Wait**. Now use **elmFinder.Find** etc with the new syntax.
- Now *role* parameter cannot contain path. Instead use the new path syntax.
- The *prop* parameter type now is **Strings**, and separator is `|` (was `\0`). If substrings contain `|`, use `new("substring", "substring")`.
- In *prop* use `desc` instead of `description`.
- Removed property **elmFinder.NavigFailed**.
- Renamed **elm.Navigate** parameter *secondsToWait* to *waitS*.
- **elm.VirtualClick** renamed to **elm.PostClick** and added parameters *x y*.
- **elm.SimpleElementId** renamed to **elm.Item**. In *prop* use `item` instead of `elem`.

Now functions **Find** and **Wait** of all finders (**wndFinder**, **wndChildFinder**, **elmFiner**, **uiimageFinder**) return the found object, not bool. Functions **Exists** return bool.

Removed **wndFinder** conversion from string.

From **wnd**, **elm** and **uiimage** removed operator + that was used to throw **NotFoundException**. Instead use "find" function overloads with parameter *waitS*.

**DStringList** renamed to **Strings**.

In **dialog** functions, the *buttons* parameter type now is **Strings**.

String extension methods **FindAny**, **FindNot**, **FindLastAny** and **FindLastNot** now have parameter *range* instead of *startOfRange* and *endOfRange*.

**IFArea** tuple casts replaced with constructors. Eg instead of `uiimage.find((w, (1, 2, 3, 4)), "image")` use `uiimage.find(new(w, (1, 2, 3, 4)), "image")`.

In **uiimage** and **uiimageFinder** functions renamed parameter *colorDiff* to *diff*. Also its range now is 0 - 100.

Renamed **wnd.WaitForCondition** to **wnd.WaitFor**.

In **wnd.Child** added parameter *id* instead of `***id` in *name*. Same in **wndChildFinder** constructor etc.

Removed **wnd.ChildById**. Instead use code like `w.Child(id: 15)`.

**elm.RoleInt** for custom roles returns **ERole.Custom**, not 0.

Removed **WButton** and **wnd.AsButton**.

Changed **wnd.ButtonClick** parameters and how it works.

Removed **wnd.OwnerWindow**. Use `w.Get.Owner` and **WndUtil.SetOwnerWindow**.

From **wnd.Activate** removed parameter waitMS.

Renamed classes: **timerm** -> **timer**; **timert** -> **timer2**.

Removed **EXYFlags.NoThrow**. Now **elm.fromXY** and **elm.fromMouse** don't throw.

Class **Dpi**: removed property **SupportPMOnWin8_1**. Instead added parameter *supportWin81* in functions. Removed **OfWindow** parameter *ofScreen*.


### Other changes
Many changes in **elm** and **elmFinder** classes and in the "Find UI element" dialog. The **Find** function can use intermediate elements (path) and can wait and throw exception if not found. Better supports high DPI screens.

Replaced syntax of finding UI elements (**elm**). Now instead of code `var e = elm.find(w, ...)` use code `var e = w.Elm[...].Find()` or `var e = w.Elm[...][...][...].Find()`.

Uses .NET 6.


================================================
FILE: Other/DocFX/_doc/changes/old/v0.10.md
================================================
## Version 0.10.0 (2022-10-19)

### Editor
New tools:
- Snippets. Add and edit code snippets.
- Customize. Customize menus, toolbars and hotkeys of the editor window.


### Library
New features:
- Several new functions or parameters in **wpfBuilder** class: **Name**, **Watermark**, **Text**, **Border**.


### Bug fixes and improvements
Fixed: **ExplorerFolder.Of** may throw exception.


================================================
FILE: Other/DocFX/_doc/changes/old/v0.11.md
================================================
## Version 0.11.0 (2022-11-08)

### Editor
**Properties > Add file > Other file**. Use to copy files to .exe output or find unmanaged dlls at run time.

Menu **File > Workspace > Repair workspace**. Finds missing and orphaned files.

New Cookbook recipes:
- Editor extension - modify UI.


### Library
New features:
- Class **ExtWpf**: several new functions and parameters.
- **ScriptEditor.Open**: new parameters *line* and *offset*.
- New function **print.scrollToTop**.


### Bug fixes and improvements

Editor:
- Fixed: in Properties dialog cannot specify preBuild/postBuild arguments.
- Fixed: in editorExtension script does not work unmanaged dll resolving at run time.
- Fixed several other bugs.
- Improved: now in `/*/ r A.dll; /*/` don't need to specify dlls used by A.dll but not used in code.

Library:
- Fixed: **print** class functions may not work in non-console program started from a console program (cmd, .bat, etc).


================================================
FILE: Other/DocFX/_doc/changes/old/v0.12.md
================================================
## Version 0.12.0 (2022-12-04)

### Editor
Can run as a portable app.

Allows to test-execute class files without a test script etc.


### Library
New functions:
- **ScriptEditor.IsPortable**.
- **script.isRunning**.
- **AutotextTriggers.MenuOptions**.
- **filesystem.more.comparePaths**.
- **filesystem.more.isSameFile**.
- **filesystem.more.createSymbolicLink**.
- **folders.Editor**.
- **folders.noAutoCreate**.
- **folders.unexpandPath**: added 1 overload.
- **clipboard.copyData**: added 1 overload.

New classes:
- **TempFile**.
- **TAMenuOptions** (for autotext triggers).

New parameters:
- **clipboard** functions: *timeoutMS*.
- **filesystem.more.getFinalPath**: *format*.

Added flag **PMFlags.WindowCenter** to show popup menu in the center of the active window.

**folders.getFolder** and functions that support paths like `@"%folders.Documents%\file.txt"` now also support properties that return string.

### Bug fixes and improvements

Editor:
- Several small improvements.
- Fixed several bugs.

Library:
- Improved: **miscInfo.getTextCursorRect** supports more windows. It is used to get menu position, for example with autotext triggers.
- Fixed regression: **pathname.unprefixLongPath** and functions that use it don't support paths like "\\?\UNC\...".
- Improved: **pathname.getRootLength** supports more path types.


### Breaking changes

Default **folders.ThisAppX** subfolders used in scripts changed from `"Au"` to `@"LibreAutomate\_script"`. If the old folder exists and the new doesn't, editor when starting copies files and prints a note.


================================================
FILE: Other/DocFX/_doc/changes/old/v0.13.md
================================================
## Version 0.13.0 (2023-01-29)

### Editor
- Menu **Code > Find OCR text**.
- Added class **EditorExtension**. Can be used in scripts that start with `/*/ role editorExtension; r Au.Editor.dll; /*/`. Helps to properly restart scripts etc.
- `/*/ ifRunning end; /*/`.

### Library
New classes:
- OCR: **ocr**, **ocrFinder**, etc.
- **CaptureScreen**, **CaptureScreenImage**.

New parameters:
- **HttpClient.Post**, **HttpClient.TryPost**: *dontWait*.
- **clipboardData** image functions now support PNG format and have new parameter *png*.


### Bug fixes and improvements

Editor:
- Fixed: tree/list view item height too small when big system font.
- Improvements and bug fixes in the "Find image..." tool.
- Improvements and bug fixes in `/*/ resource ... /*/`.

Library:
- Fixed: in some cases does not find native dlls. Then some NuGet packages cannot be used.
- Fixed: **uiimage** functions don't work if used both flag **PrintWindow** and rectangle.
- Fixed: **popupMenu.Show** flag **PMFlags.AlignCenterH** ignored.


### Breaking changes

**uiimage** functions no longer use logical (non-scaled) rectangle/point coordinates when the window is DPI-scaled and capturing its non-scaled view. Now always use physical coordinates.


================================================
FILE: Other/DocFX/_doc/changes/old/v0.14.md
================================================
## Version 0.14.0 (2023-04-07)

### Editor
Menu **Edit > Find symbol**.

Menu **Edit > Find references**.

Menu **Edit > Find implementations**.

Menu **Edit > Rename symbol**.

Menu **Edit > Go to base**.

Highlights references of the symbol at the text cursor.

Highlights matching braces and directives of the brace/directive at the text cursor.

Multiple pages in the **Found** panel.

Now `/*/ pr /*/` can be used in any file of a project, not just in the main file.

Improved:
- Replacing text in multiple files. Multi-file undo/redo.
- Implement interface.
- Folding margin context menu.
- And more.

New options:
- **Options > Font, colors > highlight, selection**.
- **Options > Code editor > Formatting**.
- **Options > Hotkeys > Capture image**.

### Library
New members:
- Event **computer.suspendResumeEvent**.
- Flag **IFFlags.Parallel** for **uiimage.find**.

New parameters:
- **string.FindWord**: *isWordChar* (callback).
- **wpfBuilder.Options**: *showToolTipOnKeyboardFocus*. And changed the default behavior of tooltips on keyboard focus.

### Bug fixes

Editor:
- Fixed: cannot use NuGet packages that depend on .NET 7 assemblies.
- Fixed: error message box on exit.
- Fixed several memory leaks and other bugs.

Library:
- Fixed "TextForFind" bug in documentation.
- Several improvements.


### Breaking changes
When converting **int**/**uint** to **ColorInt**, now by default sets alpha 255 only if it is 0 in the specified value. It allows to specify alpha in implicit conversion.


================================================
FILE: Other/DocFX/_doc/changes/old/v0.15.md
================================================
## Versions 0.15.0 (2023-05-17) to 0.15.1 (2023-05-20)

### Editor
New tools:
- Get files in folder.

New cookbook recipes:
- End script task.
- Run script on another computer; HTTP server.

Improved:
- Improvemets in "drop files", "surround code", completion list sorting and more.

### Library
New classes:
- **HttpServerSession**.
- **print.util**.
- **InputDesktopException**. All functions that send keyboard/mouse input or activate/focus a window now throw this exception if failed because of changed input desktop. It allows to use Ctrl+Alt+Delete or Win+L to end scripts that use these functions even without `script.setup(lockExit: true)`, unless the script handles these exceptions.

New members:
- **script.pause**.
- **script.paused**.
- **print.list**.
- **print.noHex**.
- **print.it** overload for interpolated strings.
- **ExplorerFolder.All**.
- Extension methods **string.ToUTF8**, **byte[].ToStringUTF8**.
- **Convert2.GzipCompress**.
- **Convert2.GzipDecompress**.
- (v0.15.1) **TriggerOptions.ThreadThis**.

New parameters:
- **script.setup**: *exitKey*, *pauseKey*.
- **RegisteredHotkey.Register**: *noRepeat*.
- **HttpClient.Get** etc: *auth* (user name and password), *also*.
- (v0.15.1) **wpfBuilder.Options**: *bindLabelVisibility*.

Improved:
- **script.setup** flag **UExcept.Dialog**: the dialog now has links to functions in the call stack.
- **internet.http**: the **HttpClient** now accepts compressed content; decompresses automatically.

### Bug fixes

Editor:
- Fixed several exceptions and other bugs.
- Fixed in v0.15.1: some "go to position in text" commands set wrong position if there are non-ASCII characters.

Library:
- Fixed: **script.trayIcon** and some **script.setup** features don't work in exeProgram script started not from editor.
- Fixed: **popupMenu** check/radio menu item click delegate not invoked if **CheckDontClose** true.
- Fixed: **Convert2.BrotliCompress** fails if already compressed.
- Fixed in v0.15.1: **elmFinder.FindAll** does not work with path.


================================================
FILE: Other/DocFX/_doc/changes/old/v0.16.md
================================================
## Version 0.16.0 (2023-06-08)

### Editor

New features:
- **Options > Check** for updates.
- Menu **Edit > View > Customize this menu**.
- Tool **Find UI element** can create "find all" code.

New cookbook recipes:
- Extract table data using UI elements.

### Library
New members:
- **osdRect.SetRects**.
- **Triggers.RunThread**.
- **run.thread** overload.

Improved:
- **HSMessage.Text** and **HSContentPart.Text** now get text even if encoding is unknown. Previously returned null.

### Bug fixes

Editor:
- Fixed some bugs.

Library:
- Fixed some bugs.


================================================
FILE: Other/DocFX/_doc/changes/old/v0.17.md
================================================
## Versions 0.17.0 (2023-07-31) to 0.17.2 (2023-08-14)

### Editor
Improved:
- Source code search (the "Go to definition" command when the symbol is not in your code).
- Does not use NTFS links for folders imported as links.
- Does not use locked files (state.db) in workspace folder.
- Improved some fonts.
- And more.

**Options > Font, colors: output font, italic**.

### Library
New classes:
- **ComUtil**.
- **WBLink**. Can be used with **wpfBuilder.Text**.
- (0.17.1) **consoleProcess**.

New members:
- **elm.uiaCN**. Also **elm** and **elmFinder** functions that support `uiaid` now also support `uiacn`.
- **HttpResponseMessage** extension methods: **Download**, **DownloadAsync**.
- **wpfBuilder**: **Wrap**, and several new overloads of other functions.
- **folders.sourceCodeMain**.
- **script.sourcePath**.
- **JSettings** properties: **NoAutoSave**, **NoAutoSaveTimer**.

New parameters:
- **filesystem.more.isSameFile**: *useSymlink**.

Improved:
- **internet.http** adds default header `"User-Agent: Au"`.
- **AutotextTriggerArgs.Menu**: null adds separator.
- **wpfBuilder.Padding** and **.Brush** support more element types.
- **filesystem.more.createSymbolicLink** with *deleteOld* true now does not delete the old link if fails to create new.
- **filesystem.more.createSymbolicLink** can create symbolic links without admin rights if in Windows Settings enabled developer mode.
- **Hash.MD5Context.Add**: no exception when data is empty.

### Bug fixes

Editor:
- Fixed: May crash when disabling triggers.
- Fixed: Cannot convert some COM type libraries.
- Fixed: After opening another workspace stops working the Files panel's context menu.
- Fixed: Exception when formatting code that starts with space.
- Fixed in 0.17.1: Cannot load program settings if using an old .NET 6 version, eg 6.0.3.
- Fixed in 0.17.1: If the program stars hidden, it crashes when the tray icon double-clicked.

Library:
- Fixed the _r bug in documentation.
- Fixed: **print.it** afraids some COM types.
- Fixed: when **ExtString.ToInt** fails, *numberEndIndex* isn't 0 if used flag **IsHexWithout0x**.
- Fixed in 0.17.1: Some protected void Dispose(bool disposing) were not virtual.
- Fixed in 0.17.2: Memory leak in regular expression functions.

### Breaking changes

(0.17.1) **run.console** default encoding now is UTF-8 or UTF-16. Was **Console.OutputEncoding**.


================================================
FILE: Other/DocFX/_doc/changes/old/v0.18.md
================================================
## Version 0.18.0 (2023-10-10)

### Editor
Menu **File > Git**. Use Git and GitHub to backup and sync workspace files (scripts etc).

In autocompletion list you can press the [+] button or Ctrl+Space to include all types or extension methods, not only those from 'using' namespaces.

New cookbook recipes:
- Dialog - use triggers.

Small improvements.

Fixed bugs:
- Incorrectly formats code if it contains multiline block comments.

### Library
New classes and structs:
- **Seconds** (wait timeout and options).
- **AppSingleInstance**.
- **FileTree**.

New members:
- **script.restart**.
- **filesystem.setAttributes**.
- **wpfBuilder.FormatText** and **FormattedText**.
- **wait.until** (replaces **forCondition**) and **doEventsUntil** (replaces **forMessagesAndCondition**).

Improved:
- In most wait functions the timeout parameter now is of type **Seconds** (was **double**). It allows to specify wait options and cancellation token.

Fixed bugs:
- **dialog**: default button isn't the first in the list as documented.

### Breaking changes
**OWait** and **opt.wait** now are obsolete. The new way to set wait options is like `wnd.wait(new Seconds(3) { Period = 100, DoEvents = true }, ...)`. For backward compatibility, wait functions still use **opt.wait.DoEvents** if **Seconds.DoEvents** not specified.

In wait functions renamed parameter *secondsTimeout* to *timeout*, and *waitS* to *wait*. Because the type now is **Seconds**.


================================================
FILE: Other/DocFX/_doc/changes/old/v0.19.md
================================================
## Versions 0.19.0 (2023-11-15) to 0.19.3 (2023-11-22)

### Editor
.NET 8.

C# 12.

Bookmarks.

Menu **Run > Publish**. Can create single-file programs.

**Options > General > Auto-backup (Git commit)**.

**Properties > nullable**.

Menu **Tools > Update icons**. Moved from the Icons tool. Now also updates custom toolbars.

New context menu items in the Recipe panel: Copy code, New script.

Several bug fixes and improvements.

#### In v0.19.1
- Fixed some v0.19 bugs.
- Menu **Code > Color**.
- New version of the icons library.
- Case-insensitive icon names.

#### In v0.19.2
- Fixed some v0.19 bugs.

#### In v0.19.3
- Fixed v0.19 bug: difficult to uncomment multiple lines containing empty lines.

### Library
New classes:
- **CheckListDialog**.

Several improvements.

### Breaking changes

Now uses .NET 8. Previously .NET 6.


================================================
FILE: Other/DocFX/_doc/changes/old/v0.2.md
================================================
## Version 0.2.0 - 0.2.5

### Breaking changes
Character _ in keys strings cannot be used as a key name.


### Bug fixes
Does not work **Options > hide when closing**.

Fixed in 0.2.3:
- Mouse click and wheel triggers stop working.

Fixed in 0.2.4:
- Keyboard triggers stop working temporarily.

Fixed in 0.2.5:
- Bugs in mouse and keyboard triggers.


### Other changes
In keys strings (**keys.send** etc) with key names now also can be used text characters, like "Alt+_e_a or "Alt+^ea".

Some improvements in **elm.Navigate** and **elm.ScrollTo**.


================================================
FILE: Other/DocFX/_doc/changes/old/v0.3.md
================================================
## Version 0.3.0 - 0.3.1

### Breaking changes
Renamed: **mouse.moveRelative** and **mouse.moveRecorded** to **mouse.moveBy**.

Changed some functions of struct **WOwner**.


### Bug fixes
Editor does not see updated r class libraries.

Fixed in 0.3.1
- A compilation cannot contain duplicate r.


### Other changes
Added keyboard/mouse recorder.

New function **mouse.drag**.

New **elm** functions: **SendKeys**, **Check**, **Expand**.

Various improvements.


================================================
FILE: Other/DocFX/_doc/changes/old/v0.4.md
================================================
## Version 0.4.0

### Breaking changes
See bug fixes.

From enum **UExcept** removed **Exit** and **PrintDialogExit**.

Changed the type of **dialog** combo box values parameters and of the property. Renamed the property.

Replaced **filesystem.enumerate** parameter *filter* with 2 parameters *fileFilter* and *dirFilter*. The same in **filesystem.copy** and **filesystem.copyTo**.

Removed **FEFile.SkipThisDirectory**.

Renamed some **FEFlags** members.

Renamed **FAttr** members (used with **filesystem.exists**).

Renamed **filesystem.delete** parameter *tryRecycleBin*.

Changed type of **shortcutFile.Hotkey**.

Changed **elm.focused** parameter type.

Changed **string.ReplaceAt** parameter type.

From clipboard classes removed RTF format functions.

Renamed some functions of class **ProcessMemory**.


### Bug fixes
Wildcard regular expressions in some cases aren't case-insensitive as documented.

Wrong return type of **wildex.RegexPcre**.

On unhandled exception don't run finally code blocks.

Several bugs in editor.


### Other changes
Added panels Cookbook and Recipe.

Added panel Outline.

Added NuGet package manager: menu **Tools > NuGet**.

New class **computer**. Shutdown etc.

New class **sound**. Play, speak.

New functions: **elm.ComboSelect**, **wnd.runAndFind**, **filesystem.enumFiles**, **filesystem.enumDirectories**, **filesystem.more.emptyRecycleBin**, **script.debug**.

Added UI to create "run script" command line, shortcut or scheduled task easily. Menu **TT > Script triggers**.

Various improvements.

Changed program name.


================================================
FILE: Other/DocFX/_doc/changes/old/v0.5.md
================================================
## Version 0.5.0

### Breaking changes
Changed **filesystem.delete** parameters.

Changed some **ProcessMemory** functions.

From **wpfBuilder** removed indexers and **Also**.

Renamed:
- **keys.more.Hotkey** -> **RegisteredHotkey**.
- **filesystem.more.DisableRedirection** -> **FileSystemRedirection**.


### Bug fixes
Silently crashes if installed an older .NET 6 version. It's a .NET bug. Now asks to upgrade .NET.

Toolbars of some windows are hidden when the window is active.

In some cases the script process does not exit when using **osdText.showText**.

Incorrect parsing of menu item text with hotkey and tooltip.

Several bugs in library and editor.


### Other changes
Changed program name again.

New functions: **process.triggers**, **process.is32Bit**, **process.getCommandLine**, **process.waitForExit**.

Added recipes:
- Many in folder "Custom dialog window".
- Filesystem events and process start/end events.
- Using LINQ functions with collections.

C# 11 raw strings.


================================================
FILE: Other/DocFX/_doc/changes/old/v0.6.md
================================================
## Version 0.6.0

### Bug fixes and improvements
Improvements and bug fixes in auto-hide toolbars.

Improvements in **wnd.ZorderX** functions.

Fixed: **elm** functions may kill Chrome on Windows 7.

And more.


### Other changes
Menu **TT > New toolbar**. Makes easier to create new toolbars, set trigger, attach to window or auto-hide at screen edge.

Menu **TT > New trigger**.

Now icons like `"*Pack.Name color"` can be used in exe and dll too.


================================================
FILE: Other/DocFX/_doc/changes/old/v0.7.md
================================================
## Version 0.7.0

### Library
New classes:
- **internet**, **ExtInternet**.
- **ExplorerFolder**.
- **screen.at**.

New functions:
- **AutotextTriggerArgs.Menu**.
- **WindowTriggerArgs.ShowToolbarWhenWindowName**.
- **toolbar.Metrics**, **popupMenu.Metrics**.
- And more.


### Editor
New features (all in menus and toolbars):
- "WPF preview".
- "Go back", "Go forward".
- "Format document", "Format selection".
- "Create delegate".
- "Surround with for", "Surround with try catch".

Various improvements.


### Bug fixes and improvements

Improvements in toolbars.


### Breaking changes
**string.Lines**: Removes the last empty line. Removed one overload.

Removed **wait.forVariable**. Instead use **wait.forCondition**.

Mouse triggers instead of screen index now use a **screen** object.


================================================
FILE: Other/DocFX/_doc/changes/old/v0.8.md
================================================
## Version 0.8.0 - 0.8.1

### Library
New functions:
- **script.end**, **script.testing**.
- **computer.isOnBattery**.
- AES encryption functions in class **Convert2**.
- And more.


### Editor
Supports more C# 11 features.

Cookbook recipes about:
- Other triggers.
- C# compiler.
- WebView2 web browser control.


### Bug fixes and improvements
Fixed some bugs in editor.

Improved NuGet features.

Improved UI element find/get functions when web content is in an embedded Chrome/Edge based control.

Improvements on Windows 11. For example, WPF would disable the unhandled exception info.

Improvements in toolbars.

Fixed: **script.setup** *sleepExit* does not work on computers with Modern Suspend.

And more.

(0.8.1) Fixed 0.8.0 bug: can't compile scripts with role exeProgram.


### Breaking changes
Changed program name: C# Uiscripter -> LibreAutomate C#. Program folder name LibreAutomate. Program file names unchanged.

Renamed and moved:
- Class **Au.script.editor** -> **Au.More.ScriptEditor**.
- Class **Au.print.Server** -> **Au.More.PrintServer**.
- Class **Au.popupMenu.MenuItem** -> **Au.Types.PMItem**.
- Class **Au.toolbar.ToolbarItem** -> **Au.Types.TBItem**.
- Class **Au.Types.MTBase.MTItem** -> **Au.Types.MTItem**.

Renamed:
- **MMetrics** -> **PMMetrics**.
- **MSFlags** -> **PMFlags**.
- **MKHook** -> **PMKHook**.

Replaced:
- **computer.sleep** -> **computer.suspend**.


================================================
FILE: Other/DocFX/_doc/changes/old/v0.9.md
================================================
## Version 0.9.0 (2022-10-05)

### Library
New functions:
- **filesystem.more.getFinalPath**.
- In class **ScriptEditor**: **InvokeCommand**, **GetCommandState**, **ShowMainWindow**.
- In class **osVersion**: several new properties.

New features:
- **clipboard** copy and paste functions: added parameter *hotkey*.


### Editor
Can import folders as links.

Can set default icon of file types (script, class, folder).

New output tag <nonl> - don't add newline.

Cookbook recipes about:
- **ListView** and **DataGrid** controls.


### Bug fixes and improvements
Improved documentation.

Fixed some bugs in editor.


### Breaking changes
Renamed and moved:
- Struct **Au.wait.Loop** -> **Au.More.WaitLoop**.

Renamed:
- **keys.SendIt** -> **keys.Send**.

Removed:
- One **wnd.HasChild** overload.
- One **wnd.getwnd.allWindows** overload.
- One **wnd.getwnd.threadWindows** overload.
- One **wnd.getwnd.Children** overload.

Web pages moved to https://www.libreautomate.com/. Old URLs redirected there.


================================================
FILE: Other/DocFX/_doc/changes/old/v1.0.md
================================================
## Versions 1.0.0 (2024-01-22) to 1.0.1 (2024-01-28)

### Editor
Debugger.

In icon names can be specified size, like `"*Pack.Icon color @12"`. See [ImageUtil.LoadWpfImageElement]().

Menu **Edit > Generate > Create event handlers, overrides**.

Fixed bugs:
- When compiling a library, incorrectly adds icons specified in code like `"*Pack.Icon color"`. Then the library may fail to load these icons.
- Incorrectly installs some NuGet packages.

New in 1.0.1:
- Debugger command **Jump to here**.
- Debugger can print assembly unload events.

### Library
New members:
- **wpfBuilder**: **Last2**, **LabeledBy**.

### Breaking changes
Removed the "debugger script" feature.


================================================
FILE: Other/DocFX/_doc/changes/old/v1.1.md
================================================
## Version 1.1.0 (2024-02-10) to 1.1.8 (2024-03-10)

### Editor
New features:
- Automatically updates environment variables in LA and task processes whenever they are changed in the registry.
- Editor extensions can use **Panels.Recipe.OpeningRecipe** to intercept and replace cookbook recipe text.
- (1.1.8) **Options > Compiler > Always print "Compiled"**.
- (1.1.8) The output tag `<fold>` can have custom link text, like `<><fold link text>...</fold>`.

Improved:
- Several improvements.

Fixed bugs:
- Cannot set exe version with **Publish**.
- IME does not work when editing a file name.
- (1.1.1) Exception when trying to end a script task if the main window never was visible.
- (1.1.1) LA crashes when called **script.debug** if the main window never was visible.
- (1.1.2) When editing a file name, cannot use some hotkeys, eg `Ctrl+C`, `Delete`.
- (1.1.3) LA crashes when using Git.
- (1.1.4) "Auto-backup" does not work.
- (1.1.7) Sometimes LA crashes when closing a tool like "find window".
- (1.1.8) Exception when formatting certain code without option "Compact".

Removed features:
- Preload **miniProgram** script task process to make task startup faster. Sometimes this feature caused problems. Inactive windows, old environment variables etc. Now the startup speed is the same as when role is **exeProgram**.
- (1.1.4) Middle-click the tray icon to disable/enable triggers (it didn't work on Windows 11). Instead use the right-click menu.

### Library
New members:
- (1.1.8) **OKey.TextShiftEnter** (`opt.key.TextShiftEnter`).

New parameters:
- **toolbar** constructor: *settingsFile*.

Improved:
- **miscInfo.getTextCursorRect** works with more apps.

Fixed bugs:
- Console functions in some cases incorrectly detect encoding UTF-16.
- (1.1.6) **ExplorerFolder.GetFolderPath** returns incorrect string if the path contains certain non-ASCII characters.
- (1.1.7) Code like `e.Elm.FindAll()` throws **InvalidOperationException**.

Removed features:
- (1.1.4) Middle-click the tray icon to end the task (it didn't work on Windows 11). Instead use the right-click menu.

### Breaking changes
(1.1.3) Console functions now don't try to detect encoding UTF-16. Because impossible to detect reliably.


================================================
FILE: Other/DocFX/_doc/changes/old/v1.2.md
================================================
## Version 1.2 (2024-04-18)

### Editor
New small features:
- Panel **Recipe**: you can set font in **Options**.
- Panel **Mouse**: context menu with some options.
- **Options > Other > Internet search URL**.
- Menu **Edit > Tidy code > Deduplicate wnd.find**.
- Hotkeys displayed in tooltips of toolbar buttons.
- To unload `AuCpp.dll`: `rundll32.exe "C:\path\to\AuCpp.dll",UnloadAuCppDll 0`.

Improved:
- Tool **Find UI object**: improved feature "capture smaller element". Use hotkey `Shift+F3`.
- Tool **Find UI object**: option "Use role in elm variable name".

Fixed bugs:
- Fixed several bugs.

### Library
New members:
- **dialog.options.timeoutTextFormat**.
- **popupMenu.caretRectFunc**.
- **wait.retry**.
- **ScriptEditor.GetFileInfo**.
- **ScriptEditor.TestCurrentFileInProject**.

New parameters:
- **wnd.Move**, **wnd.Resize**, **wnd.MoveL**: *visibleRect* (exclude the transparent frame).
- **elm** functions: in the *prop* parameter can be specified **url**. Use to search in side panels, developer tools, settings etc. The **Find UI element** tool now adds it when need.

Improved:
- **elm** with Chrome and other Chromium-based web browsers.

### Breaking changes
Renamed functions:
- **wpfBuider.FormatText** -> **formatTextOf**,
- **wpfBuider.FormattedText** -> **formattedText**,
- **popupMenu.DefaultFont** -> **defaultFont**, 
- **popupMenu.DefaultMetrics** -> **defaultMetrics**, 
- **toolbar.DefaultMetrics** -> **defaultMetrics**.


================================================
FILE: Other/DocFX/_doc/changes/old/v1.3.md
================================================
## Versions 1.3.0 (2024-06-27) to 1.3.2 (2024-07-03)

### Editor
More features in code snippets:
- Snippet code can contain multiple fields that can be selected with `Tab` or `Enter`. When leaving an edited field, updates text of related fields.
- Formats the inserted snippet code.
- The **Snippets** tool can import Visual Studio and VSCode snippets.
- Surround with snippet (menu **Edit > Selection > Surround** or toolbar button).
- Snippet context detected automatically.
- A snippet can add `/*/ meta comments /*/`.

Formats code when completing current statement (adding `;`, `{  }` etc). This feature can be disabled in **Options**.

Adds `;` when starting a statement. Later deletes if don't need. This feature can be disabled in **Options**.

You can use `Backspace` to exit current multiline `{ block }` when the text cursor is in the last line of the block and that line is blank. Previously `Ctrl+Enter` worked in a similar way.

Changes in code editor feature "statement completion on `Enter` before `)` or `]`":
- Can be disabled: **Options > Code editor > Statement completion > Enter before )**.
- Removed: `Esc` key prevents it.
- Added: space before prevents it. Other ways: comma before; `Shift+Enter`.
- After statement completion, next **Undo** command undoes the change and adds new line without statement completion.
- Related: Now the "complete statement anywhere" hotkey (`Ctrl+Enter` etc) can be set in **Options**.

If there is selected text and you type `(`, `[` or `{`, surrounds that text like `(selected)` or `{ selected }`.

Colored regular expression text.

Can fold namespaces, local functions, lambda, initializer lists, strings.

Drag and drop a non-script file from the **Files** panel to the code editor: can add `/*/ meta comments /*/`.

Added floating panel options **Topmost** and **Unowned**. Right-click panel header...

Several small improvements. Removed some low-value features.

Fixed bugs:
- Debugger settings: does not work **not**.
- And more.

##### v1.3.1:
- Fixed several bugs in new features.
- Several small improvements.
- Added **Options > Program > Visible if not auto-started**, and command line `/a` which indicates that the program started automatically.

##### v1.3.2:
- Fixed bug: some editor font styles incorrectly saved.

### Library
New members:
- **wnd.IsMatch** overload for multiple windows.
- **string.Split**, **ReadOnlySpan\<char\>.Split** and **ReadOnlySpan\<char\>.SplitAny** overloads that return **StartEnd[]**.
- **ReadOnlySpan\<char\>.Split** and **ReadOnlySpan\<char\>.SplitAny** overloads that return **string[]**.
- **regexp.Match** and **IsMatch**: overloads with **ReadOnlySpan\<char\>**.

New parameters:
- **string.Lines**: *preferMore* (include the last empty line), *rareNewlines*.
- **string.LineCount**: *rareNewlines*.

Fixed bugs:
- When used in a single-file app or portable LA, **folders.NetRuntimeDesktopBS** returns `null`, and **folders.NetRuntimeDesktop** throws exception.
- **regexp** functions always return `false` if the subject string is empty, even if the regular expression can match empty string.

v1.3.2:
- Improved: **print.redirectConsoleOutput** is initially `true` in `exeProgram` scripts started from LA (previously only `miniProgram`). Also **Console.ReadLine** uses **dialog.showInput**.


================================================
FILE: Other/DocFX/_doc/changes/old/v1.4.md
================================================
## Versions 1.4.0 (2024-07-29) to 1.4.1 (2024-08-03)

### Editor

Uses C# 13.

The **Files** panel reflects workspace changes made not in the editor (added/deleted files). See also **Options > Workspace > Hide/ignore files and folders**.

Dark themes. See **Options > Font, colors**.

Improvements in the **Portable LibreAutomate setup** tool.

**editorExtension** scripts can use `await`. Previously would hang.

Removed feature "surround selected text when typed `(` etc".

Fixed several bugs.

##### v1.4.1:
- Several bug fixes and improvements.
- Improvements in portable setup tool UI.

### Library

Fixed bugs:
- **print.it** and **print.list** skip first empty-string items of **IEnumerable**.

### Breaking changes

The **Files** panel now is synchronized with the filesystem. Because of this, some unwanted files/folders may be added. The program prints links to the added files.

================================================
FILE: Other/DocFX/_doc/changes/old/v1.5.md
================================================
## Version 1.5.0 (2024-09-12)

### Editor
New much bigger Windows API database.

Changes in `/*/ meta comments /*/`:
- Options can be separated by newlines without semicolon.
- Options can be commented out like `//option value;`.

New cookbook recipes:
- Passwords in scripts.

Improved:
- Several improvements.

Fixed bugs:
- Possible exception when a script is starting. Rare.
- And more.

### Library
New members:
- **print.it** and **print.util.toString** overloads for binary data displayed in hex editor format.

Fixed bugs:
- **consoleProcess** functions **Write** and **Prompt** don't auto-append newline if input encoding is **Encoding.Unicode**.


================================================
FILE: Other/DocFX/_doc/changes/old/v1.6.md
================================================
## Version 1.6.0 (2024-11-04)

### Editor
Improved **New trigger** tool.

Menu **TT > Schedule**. Now you can edit scheduled task properties in LibreAutomate.

Menu **TT > Find triggers**. Finds triggers of current script.

Several bug fixes and improvements.

### Library
New members:
- **wpfBuilder.StartPanel** (adds panel of any type).

New parameters:
- **wpfBuilder.LabeledBy**: *bindVisibility*.
- **wpfBuilder.Validation**: *linkClick* callback.

Improved:
- **ExplorerFolder** supports multiple tabs. Added more functions and parameters.
- **EnumUI** supports more panel types.
- Improvements in **wpfBuilder.FormatText** and similar functions.
- And more.

Fixed bugs:
- Some functions may throw **InputDesktopException**. Including **WndUtil.EnableActivate**, **dialog.show**, **run.it**, and some **elm** functions.


================================================
FILE: Other/DocFX/_doc/changes/old/v1.7.md
================================================
## Version 1.7.0 (2024-12-07) to 1.7.1 (2024-12-21)

### Editor
New cookbook recipes:
- Web browser automation with Playwright.

Improved:
- Menu **Run > Publish**: added **Self-extract**.

#### v1.7.1:
- Fixed bug in the **Publish** tool: error if assembly attributes like `AssemblyVersion` are not in `AssemblyInfo.cs`.

### Library
New classes:
- **CpuUsage**.

New members:
- **opt.PasteSleep**. Makes "paste" functions slower (default 100 ms) but more reliable.

Improved:
- **opt.key/mouse/warnings** now are managed differently, and work well with `await` and thread pool tasks. Each new thread and task inherits a copy of **opt.key/mouse/warnings** of the parent thread/task, which then is isolated from parent and other threads/tasks. Now **opt.init** is obsolete and is the same as **opt**.
- **mouse.save/restore/lastXY** now works well with `await`. Now the saved data is shared by all threads.
- **clipboard.paste** and other "paste" functions now can work with apps where previously failed. Change **opt.PasteSleep** where still fails.
- Auto-enabling UI elements in Chrome/Edge works better. With new browser versions it used to fail sometimes.

### Breaking changes
Because of the **opt.key/mouse/warnings** management change, initial options in threads and tasks now may be different.

When auto-enabling UI elements in Chrome/Edge, some rarely used features are enabled later (asynchronously). HTML attributes, **DefaultAction**, maybe more. Your code that uses them may have to wait or retry. To enable everything instantly, run browser with command line `--force-renderer-accessibility`.

================================================
FILE: Other/DocFX/_doc/changes/old/v1.8.md
================================================
## Version 1.8.0 (2025-01-16)

### Editor
Can run on Windows ARM64.

Improved:
- Menu **File > Export, import > Export**: can include files specified in `/*/ c /*/` etc.
- If in `/*/ c /*/` etc used filename without path, and multiple files with the given filename exist in the workspace, can use the one from subfolders or ancestor folders (if single exists there). Previously would be error, unless one is in the same folder.

Fixed bugs:
- Git does not work when using the newest version of private Git.
- Image text incorrectly hidden in non-ASCII code.

### Library
Can be used on Windows ARM64.


================================================
FILE: Other/DocFX/_doc/changes/old/v1.9.md
================================================
## Versions 1.9.0 (2025-03-21) - 1.9.2 (2025-04-06)

### Editor
Fixed bugs:
- Empty list in window **Active toolbars**.
- (1.9.1) 1.9.0 installed debug versions of Roslyn dlls, which caused program errors in some cases.

New options:
- **Options > Other > Documentation**. You can use local documentation of the installed program version instead of the online documentation of the latest program version.

### Library
New members:
- **keys.waitForHotkeys**.
- **HelpUtil.AuHelpBaseUrl**.
- **popupMenu.ImageSize**, **toolbar.ImageSize**.
- **IconImageCache.CommonOfSize**.
- (1.9.2) **toolbar.MaximizedWindowTopPlus**.

New parameters:
- **HttpServerSession.Listen** parameter *started* (callback).

Fixed:
- Cannot get the description property of some UI elements in UIA mode.
- (1.9.2) Cannot find UI element if an HTML attribute is specified (recent browser versions).

Other changes:
- Removed file `sqlite3.dll`. Now class `sqlite` uses `winsqlite3.dll` of Windows 10+; on older OS auto-downloads.


================================================
FILE: Other/DocFX/_doc/changes/template.md
================================================
# Version 1..0 (2025-)

## Editor

New tools:
- .

New cookbook recipes:
- .

Improved:
- .

Fixed bugs:
- .

## Library

New classes:
- .

New members:
- .

New parameters:
- .

Improved:
- .

Fixed bugs:
- .

### Breaking changes


================================================
FILE: Other/DocFX/_doc/changes/v1.10.md
================================================
## Version 1.10.0 (2025-04-29) - 1.10.1 (2025-04-30)

### Editor
Triggers list window. More info: menu **TT > Triggers list info**.

Updated Roslyn C# compiler/analyzer dlls. Supports C# 14 `extension` etc.

Menu **Edit > Generate > Convert \[PreserveSig\] methods**.

Fixed bugs:
- Debugger: no variables when stops on exception.
- And more.

### Library
New members:
- **ActionTriggers.ShowTriggersListWindow**.
- **TKFlags.Numpad**, **TKFlags.NumpadNot**.
- More properties in trigger type classes.

Improved:
- **ActionTrigger.RunAction** can be called from any thread.

Fixed bugs:
- **AutotextTriggers** properties **PostfixKey** and **WordCharsPlus** don't work in some cases.
- **OcrGoogleCloud**: exception if no text detected.
- **OcrMicrosoftAzure**: exception if image too small.
- (1.10.1) **NativeApi.BOOL** size 8 (must be 4).


================================================
FILE: Other/DocFX/_doc/changes/v1.11.md
================================================
## Version 1.11.0 (2025-05-14)

### Editor
New tools:
- Menu **TT > Script lauchers > Shell menu**.

### Library
Fixed bugs:
- In programs compiled with LibreAutomate fails to load assemblies in subfolder `runtimes\win`.


================================================
FILE: Other/DocFX/_doc/changes/v1.12.md
================================================
## Version 1.12.0 (2025-06-21)

### Editor
[PiP session](https://www.libreautomate.com/editor/PiP%20session.html). See menu **Run > PiP session** and **Run in PiP**. Creates a separate session of the same user in a Picture-in-Picture window, where UI automation scripts can run in the background without interfering with your mouse and keyboard. Requires Windows 8.1 or later, a non-Home edition.

The **Files** view now is better synchronized with the filesystem.

Updated the icons database. Many new icons.

Icon strings: margin and layers. See menu **Tools > Icons > Custom icon string**.

Fixed bugs:
- Menu **Tools > Update icons** may not clear caches of image size != 16.
- Autocompletion list sometimes disappears when pasting.

### Library
New classes:
- **FileWatcher**.

New members:
- **script.runInPip**, **script.isInPip**.
- **miscInfo.isChildSession**.
- **JSettings**: **ModifiedExternally** (event), **Reload**.

New parameters:
- **JSettings.Load**: *useDefaultOnError*.

Fixed bugs:
- **filesystem.enumDirectories**: flag **AllDescendants** does not work.


================================================
FILE: Other/DocFX/_doc/changes/v1.13.md
================================================
## Version 1.13.0 (2025-07-06) - 1.13.1 (2025-07-08)

### Editor
Does not require the .NET SDK for NuGet and Publish. If it isn't installed, automatically downloads (~26 MB) and uses a minimal SDK.

Removed the " C#" from the full name of the program. Now just "LibreAutomate".

Several improvements.

In 1.13.1 fixed bug in the LibreAutomate setup program: Windows UI shows two LibreAutomate programs installed.

### Library
No changes


================================================
FILE: Other/DocFX/_doc/changes/v1.14.md
================================================
## Version 1.14.0 (2025-08-06)

### Editor
**NuGet** tool improvements:
- Check for updates.
- Easier to update to a selected version.
- Right-click an unused folder to delete.
- Supports multiple sources better.
- Displays package icons.
- And more.

Panel **Find > Saved searches**.

Fixed bugs:
- Does not work with .NET 9.0.8. Crashes at startup etc.
- When print text contains `<image "image">`, may hang or not display the image.
- And more.

### Library
New members:
- **osVersion.thisLibrary**.


================================================
FILE: Other/DocFX/_doc/changes/v1.15.md
================================================
# Version 1.15.0 (2025-12-08)

## Editor

Created internal infrastructure for using AI in LA.

Find LA documentation using AI in the **Help** panel. Copy-paste results in ChatGPT etc to get accurate answer.

MCP server. Provides LA documentation for local AI tools such as Visual Studio Copilot.

Use AI to find icons by name or/and image in the **Icons** tool.

Changes in LA window:
- Panel **Cookbook** renamed to **Help**. Added full LA documentation.
- Panel **Recipe** renamed to **Read**. Displays LA documentation articles. See **Options > Other > Documentation**.
- The default location of panels **Help**, **Read** and **Tasks** now is at the right side. If want to use it, exit LA and delete `Documents\LibreAutomate\.settings\Layout.xml`.
- The **Read** panel now is always hidden at startup.
- Removed toolbar **Help**.

Changes in tools like **Find UI element**:
- They run in separate process.
- Improved UI element capturing in some apps and modes.

New code editor features:
- Menu **Edit > Assist > Insert new line before ) ] ;** (and toolbar button). Temporarily disables statement auto-completion on `Enter`.
- Continue a vertical method chain by typing `.` on the next line after the `;`.

New in menu **Edit > Find**:
- **Find next** (`F3` or click the **Find** button).
- **Find previous** (`Shift+F3` or right-click the **Find** button).
- **Next found** (`F4`). Selects next item in the **Found** panel.
- **Previous found** (`Shift+F4`).

Quickly hide toolbar buttons using the context menu (in LA window).

Several other improvements.

Fixed some bugs.

### Breaking changes

Changed namespaces in `Au.Editor` project. Edit your `editorExtension` scripts that use its internal classes (unlikely).

## Library
Updated PCRE regex library to v10.46.

New members:
- `dialog`: fluent API methods for setting dialog properties. The old functions now are hidden.
- `wpfBuilder.Add` overloads without parameter `flags`. The old overloads now are hidden. Flags replaced with: function `Child`; parameter *raw* of one `Add` overload.
- And more.

New parameters or paramater features:
- `script.end("");` ends other processes of current script.

New `dialog` features:
- Easier to add links.
- Supports icons like `"*Pack.Name color"`.

Fixed bugs:
- `script.restart` does not work.
- `JSettings` can deadlock.
- `WTaskbarButton` exception if used in multiple threads.
- Owned floating toolbars remain topmost after the owner that was topmost becomes non-topmost.

Restored the "auto-enable browser UI elements" feature that was broken in the latest Chromium version.

================================================
FILE: Other/DocFX/_doc/docfx.json
================================================
{
  "metadata": [
    {
      "src": [
        {
          "src": "C:/Temp/Au/DocFX/source/",
          "files": [
            "Au.csproj"
          ]
        }
      ],
      "dest": "api",
      "shouldSkipMarkup": true,
      "filter": "filter.yml",
      "disableGitFeatures": false,
      "disableDefaultFilter": false,
      "memberLayout": "separatePages",
      "noRestore": true
    }
  ],
  "build": {
    "content": [
      {
        "files": [
          "api/**.yml",
          "api/index.md"
        ]
      },
      {
        "files": [
          "articles/**.md",
          "articles/**/toc.yml",
          "editor/**.md",
          "editor/**/toc.yml",
          "cookbook/**.md",
          "misc/**.md",
          "toc.yml",
          "*.md"
        ]
      }
    ],
    "resource": [
      "images/window.png"
    ],
    "globalMetadata": {
      "_appTitle": "LibreAutomate",
      "_enableNewTab": true,
      "_disableBreadcrumb": true,
      "_disableAffix": true,
      "_disableContribution": true
    },
    "dest": "C:/Temp/Au/DocFX/site-temp",
    "globalMetadataFiles": [],
    "fileMetadataFiles": [],
    "template": [
      "default",
      "template1",
      "template2"
    ],
    "postProcessors": [],
    "markdownEngineName": "markdig",
    "noLangKeyword": false,
    "keepFileLink": false,
    "cleanupCacheHistory": false,
    "disableGitFeatures": false,
    "sitemap": {
      "baseUrl": "https://www.libreautomate.com/",
      "changefreq": "weekly"
    }
  }
}

//https://dotnet.github.io/docfx/tutorial/docfx.exe_user_manual.html


================================================
FILE: Other/DocFX/_doc/editor/Application.md
================================================
---
uid: Application
---

# LibreAutomate

The application is an integrated scripting environment for creating and executing automation scripts using its automation library and C# programming language.

![window](../images/window.png "Editor window")

In the main window: code editor, several panels, toolbars and menu bar. Also there is a tray icon. The main window can be hidden (it depends on app settings).

## Code editor
Here you edit automation scripts and other text files.
[Features](xref:code_editor).

Multiple files can be open, but only one is visible. The list of open files is in the **Open** panel.

All changes are saved automatically on these events: app deactivated, main window closed, timer. The **Save** button saves all changes immediately.

## Panels

### Files
All files and folders of current workspace.

Click an item to open in the code editor. Right-click to show context menu. Middle-click to close. Drag and drop to reorder or add new files.

All changes are saved automatically.

Deleted files and folders are moved to the Recycle Bin if possible.

Yellow background if the file is open in the code editor.

C# code files have `.cs` extension, but it is hidden.

See [file properties](xref:file_properties).

Files are of these types:
- Script - C# code file that can be executed directly, like a program.
- Class - C# code file that contains classes and functions used by other files.
- Text files - txt, xml and other files that can be edited in the code editor.
- Other files - files that cannot be edited. Images etc. For example can be added to exe program resources.

Folders are of these types:
- Simple folders.
- Folders named like `@Name` are [project](xref:class_project) folders.

The collection of files and folders is a *workspace*. It is a folder on disk. In the folder:
- Folder `files` contains files and folders of the workspace.
- File `files.xml` is the list of files and folders of the workspace.
- File `settings.json` - workspace settings.
- File `bookmarks.csv` - saved bookmarks.
- Folder `.state` contains code editor states for files, such as folding, markers and current position.
- The `.xxx` folders are created and used by the app for various purposes.
- Folders `exe` and `dll` - default folders for files created when compiling code files with role `exeProgram` or `classLibrary`.

### Open
List of files open in the code editor.

Right-click - context menu. Middle-click - close.

### Tasks
Running scripts.

Right-click - context menu. Middle-click - close.

### Find
Find and replace text in the code editor or in multiple files.

Right-click an edit field - context menu. Middle-click - clear text; if empty - show recent.

### Found
Results of **Find in files**, **Find file**, **Find references** and some other commands.

### Output
The app writes various info here. For example script compilation errors. Scripts use [print.it]() for it.

Right-click - context menu. Middle-click - clear.

### Mouse
Mouse x y, window name/class/program, control id/class/name, menu item id.

### Outline
Helps to find types, functions, fields, namespaces and regions in current C# code file.

### Help
Documentation - table of contents.

### Read
Documentation - article.

### Bookmarks
List of bookmarks.

Right-click - context menu.

### Debug, Breakpoints
[Debugger](xref:debugger).

## Menus
See [Menu commands](xref:menu_commands).

## Tray icon
Click - show and activate editor window. Right-click - show context menu.

Gray when triggers are disabled.

## Customizing

### Customize the panel layout

Panels and toolbars can be resized with splitters, moved to another place, grouped in stacks and tab groups, docked, floating, hidden.

Each panel, tab group and toolbar has a header bar. Right-click it to show a customization menu. Also use the menu to show hidden panels. Double-click the bar to toggle floating/docked state; drag to make floating; middle-click to hide.

The splitters between panels have a right-click menu to set splitter width and float/dock/move that stack of panels.

It's saved in `%folders.Documents%\LibreAutomate\.settings\Layout.xml`. To reset to the default layout, exit LibreAutomate and delete the file.

### Customize toolbars, menus and hotkeys

Use the **Customize** tool. Open it via the **Tools** menu or right-click a toolbar.

You can add buttons to any toolbar, and change button properties. Default buttons cannot be removed, but can be hidden. To access hidden buttons, click the drop-down arrow in the toolbar. New toolbars can't be added, but there are two initially empty toolbars just for user buttons.

Menu items can't be added/removed/moved, but you can change menu item properties. You can set hotkeys for menu commands.

It's saved in `%folders.Documents%\LibreAutomate\.settings\Commands.xml`. You can edit the file in an XML editor. To reset everything, delete the file. To reset an item or toolbar, remove it from XML. Restart LibreAutomate.

See also cookbook article **Editor extension - modify UI**.


================================================
FILE: Other/DocFX/_doc/editor/Class files, projects.md
================================================
---
uid: class_project
---

# Class files, projects
A [script](xref:script) can contain functions and classes. Also can use those from class files and libraries.

### Class files
A class file contains C# code of one or more classes with functions that can be used in other C# files (script, class). By default it cannot run when you click the **Run** button.

There are several ways to use class files in a C# file `X`:
- In `X` **Properties** click **Add file > Class file**.
- If the class file is in a library (role `classLibrary`), in `X` **Properties** click **Add reference > Project**.
- Create a project and add class files to the project folder. Used when the classes are used only in that project.

### Projects
A folder named like `@Project` (starts with `@`) is a project folder. To create: menu **File > New > New project**.

Projects are used to compile multiple C# files together. The compilation creates an assembly file that can be executed as a script or exe program or used as a dll library.

The first code file in the project folder is the project's main file. All class files are compiled together with it when you try to compile or run any file of the project.

The main file can be a script or a class file. Most of its properties are applied to whole compilation. If it's a script, it runs when you click **Run**; such project is a *script project* and also can be used to create exe programs. Else the project is a *library project* and produces a dll file.

The folder can contain more scripts, but they are not part of the project. If they want to use project's class files, add them explicitly: **Properties > Add file > Class file**.

Usually class files that are in a project are used only in files of that project, therefore they are not included in the drop-down list of **Properties > Add file > Class file**, unless the project folder name starts with `@@`.

### Libraries
A library is a dll file. It contains compiled classes with functions that can be used anywhere.

A library can be created from a class file, usually the main file of a library project. In **Properties** select role `classLibrary`.

### Project references
Any C# file can use libraries. You can add library references in the **Properties** dialog. If it's a library whose source files are in current workspace, click **Add reference > Project**. It is known as *project reference*. It adds a reference to the assembly created by the library, auto-compiles the library when need, and enables [code editor features](xref:code_editor) such as "go to definition".

### Test scripts
By default a class file cannot be executed directly when you click the **Run** button. But you'll want to test its functions etc while creating it. For it create a *test script* that is executed instead when you click the **Run** button. Let the script call functions of the class file. To create a test script for a class file: try to run the class file and then click the link in the error text in the output panel. And below is another way.

### Run a class file without a test script or project
Specify role `miniProgram`, `exeProgram` or `editorExtension`.

Then at the start add code that uses the class. By default class files containing such code cannot be used in other scripts (error "Only one compilation unit can have top-level statements"). Workaround: define a preprocessor symbol, and use `#if` to disable that code when the class file is compiled as part of another script etc. Example:

```csharp
/*/ role miniProgram; define TEST; /*/

#if TEST
Class1.Function1();
#endif

class Class1 {
	public static void Function1() {
		print.it(1);
	}
}
```

When the first option in `/*/ ... /*/` is `role` other than `classFile` (like in the example), `define TEST` and other incompatible options are ignored when the class file is compiled as part of another script etc (for example the `TEST` symbol isn't added to the compilation). Else such options then cannot be used (error).

This does not work if the class file is in a project. See [ScriptEditor.TestCurrentFileInProject]().

### File `global.cs`
Class file `global.cs` is automatically included in the compilation of every script, as if the script begins with `/*/ c global.cs /*/`. To exclude it where not needed, add `/*/ define NO_GLOBAL; /*/`.

 By default, `global.cs` contains `global using` directives for commonly used namespaces.
 
 You can edit this file. For example:
- Add/remove global usings, classes, attributes.
- Add more class files and library references, like `/*/ c \Classes\file.cs; r Lib.dll; nuget folder\Package; /*/`.
- Edit completion list filters (see examples in the default code).

Note: editing this file affects all C# code files, not only files created afterward.

If the `global.cs` file is missing, scripts cannot compile, and the app prints a warning with a link to create a new `global.cs` file with the default content. If multiple class files named `global.cs` exist in the workspace, the app uses the one in the default location: `\Classes\global.cs`. If that file is missing, it uses a non-external `global.cs` file if a single such file exists.


================================================
FILE: Other/DocFX/_doc/editor/Code editor.md
================================================
---
uid: code_editor
---

# Code editor
In the code editor you edit automation scripts and other C# code.

C# code example:
```csharp
mouse.click(10, 20);
if (keys.isCtrl) {
	print.it("text");
}
```

To create the above code, you can type this text:
```csharp
mo.c 10, 20
if ke.isct

pi "text
```

While typing, editor completes words, inserts code snippets, adds `()`, `;`, `{}` and indentation. The result is the first code.

## Features

<!--
To generate TOC with #links, use the VS context menu command "Generate TOC". Then remove the indentation.
BAD: now the Back button does not scroll to TOC. And the same in all DocFX-generated pages.
-->
- [List of symbols, autocompletion](#list-of-symbols-autocompletion)
- [Bracket completion](#bracket-completion)
- [Statement completion](#statement-completion)
- [Auto indentation](#auto-indentation)
- [Parameter info](#parameter-info)
- [Quick info](#quick-info)
- [Error info](#error-info)
- [XML documentation comments](#xml-documentation-comments)
- [Go to symbol documentation](#go-to-symbol-documentation)
- [Go to symbol definition (source code), base](#go-to-symbol-definition-source-code-base)
- [Go to script, file, URL](#go-to-script-file-url)
- [Find and replace text](#find-and-replace-text)
- [Find symbol references](#find-symbol-references)
- [Highlight symbol references and matching braces](#highlight-symbol-references-and-matching-braces)
- [Find symbol](#find-symbol)
- [Rename symbol](#rename-symbol)
- [Outline of current file](#outline-of-current-file)
- [Navigate back/forward](#navigate-backforward)
- [Bookmarks](#bookmarks)
- [Code coloring](#code-coloring)
- [Text folding](#text-folding)
- [Separators between functions/types](#separators-between-functionstypes)
- [Snippets](#snippets)
- [Images in code](#images-in-code)
- [Format code](#format-code)
- [Comment/uncomment/indent/unindent lines](#commentuncommentindentunindent-lines)
- [Capture UI elements, insert regex etc, implement interface](#capture-ui-elements-insert-regex-etc-implement-interface)
- [Find Windows API and insert declarations](#find-windows-api-and-insert-declarations)
- [Drag and drop files to insert path](#drag-and-drop-files-to-insert-path)
- [Focus](#focus)
- [WPF window preview](#wpf-window-preview)

### List of symbols, autocompletion
When you start typing a word, editor shows a list of symbols (classes, functions, variables, C# keywords, etc) available there. Or you can press `Ctrl+Space` to show the list anywhere.

The list shows only items that contain the partially typed text. The text in list items is highlighted. Auto-selects an item that is considered the first best match. On `Ctrl+Space` shows all. You can use the vertical toolbar to filter and group list items, for example to show only methods.

While the list is visible, when you double-click an item or press `Enter`, `Tab`, `Spacebar` or type a non-word character, the partially or fully typed word is replaced with the text of the selected list item. Also may add `()`, for example if the word is a function name or a keyword like `if`. By default adds `()` only if completed with `Spacebar`; see **Options > Code**.

To select list items you also can click or press arrow or page keys. It does not hide the list. The tooltip-like window next to the list shows more info about the selected item, including links to online documentation and source code if available. Shows all overloads (functions with same name but different parameters), and you can click them to view their info.

To hide the list without inserting item text you can press `Esc` or click somewhere in code.

While the list is visible, you can press the **[+]** button or `Ctrl+Space` to show another list that includes all types or extension methods, not only those from `using` namespaces.

### Bracket completion
When you type `(`, `[`, `{`, `<`, `"` or `'`, editor adds the closing `)`, `]`, `}`, `>`, `"` or `'`. Then, while the text cursor is before the added `)` etc, typing another `)` or `Tab` just leaves the enclosed area. Also then `Backspace` erases both characters.

### Statement completion
When you press `Enter` immediately before `)`, `]` or `;`, editor adds missing `;` or `{  }`, adds new line, moves the text cursor, and formats the statement. Except if before is `,` or space character.

However the above feature interferes with writing multi-line statements. Ways to bypass it:
- Disable temporarily: toggle **Raw Enter before ) ] ;** on the toolbar.
- Use `Shift+Enter`. Or `Ctrl+Enter`, depending on settings.
- Type space before `Enter`.
- `Enter` and `Ctrl+Z` (undo). It undoes the change and adds new line inside the statement.
- You can continue a vertical method chain by typing `.` on the next line after the `;`.
- If you never need this feature, disable it in **Options**.

Use hotkey `Ctrl+Enter` (can be changed in **Options**) to complete current statement when the text cursor is anywhere in it. Also it can add `{  }` to `class C` etc.

Also completes statement on `Enter` in a single-line `"string"` or `"""string"""`, unless the text cursor is at `"""|text"""`.

To complete statement without new line, use `;` instead of `Enter`. It adds `;` if missing, moves the text cursor, and formats the statement. With `Ctrl` it works anywhere in the statement; without - only before `)` or `]`.

As you begin typing a statement (eg a word in a blank line), editor adds `;`. Later deletes if don't need (eg when completing with `{  }`) or overtypes `;` with `;`. This feature can be disabled in **Options**.

You can use `Backspace` to exit current multiline `{ block }` when the text cursor is in the last line of the block and that line is blank.

### Auto indentation
On `Enter` editor adds new line with correct indentation.

### Parameter info
When you type a function name and `(`, editor shows a tooltip-like window with info about the function and current parameter. To show the window from anywhere in an argument list, press `Ctrl+Shift+Space`. You can select oveloads with arrow keys or the mouse.

### Quick info
Whenever the mouse dwells on a symbol etc in the editor, a tooltip displays some info about the symbol, including documented exceptions the function may throw.

### Error info
Errors are detected in editor, as well as when compiling the code. Code parts with errors have red squiggly underlines, warnings green. A tooltip shows error/warning description. Also can contain links to fix the error, for example add a missing `using namespace` or Windows API declaration.

### XML documentation comments
Editor gets data for quick info, parameter info and other info about symbols from their assemblies and XML documentation comments. You can write XML documentation comments for your functions and types; look for how to on the internet. Documentation of the automation library and .NET is installed with the app. Documentation of other assemblies comes from their `assembly.dll` + `assembly.xml` files.

Editor also helps to write XML documentation comments. Adds empty summary and parameters when you type `///` above a class, method etc. Adds `///` on `Enter`, shows a list of tags, autocompletes tags, color-highlights tags, text and `see` references.

### Go to symbol documentation
To show symbol documentation if available, press `F1` when the text cursor is in it. Or click the **more info** link in the autocompletion item info or parameter info window.

If the symbol is from the automation library, it opens the online documentation page in your web browser. If the symbol is from .NET runtime or other assembly or unmanaged code (`[DllImport]` or `[ComImport]`), it opens the Google search page.

### Go to symbol definition (source code), base
Click a symbol and press `F12`. Or click the **source code** link in the autocompletion item info or parameter info window.

If the symbol is defined in your code, it opens that file and moves the text cursor. Else it can help to find the source code online.

The **Go to base** command finds the base class or implemented/overriden method definition.

### Go to script, file, URL
Click a file path string and press `F12` to select it in File Explorer. In the same way you can open folders, script files and web pages. It also works in meta comments, other comments and in code like `folders.System + @"notepad.exe"`. If the path etc does not start and end with `"`, at first select it.

### Find and replace text
Use the **Find** panel to find and replace text in editor. It marks all matches in editor with yellow. Also can find files by name and files containing text. Can replace text in multiple files.

### Find symbol references
The **Find references** command takes the symbol (class name, function name, variable, etc) at the current position and finds all places in current and related files where the symbol is used. Ignores matching words in comments, strings and `#if`-disabled code. Displays results in the **Found** panel. You can click a result line to go to that place. You can middle-click to close the file if it was opened from that results.

The **Find implementations** command is similar. If the symbol is an interface or class, finds types that implement or inherit it. If the symbol is an interface/abstract/virtual function, finds functions that implement or override it.

What is "related files":
- If current file is part of a @Project folder - all files of that project.
- Files used by current file/project through `/*/ c /*/`.
- If current file or project uses project references (`/*/ pr /*/`) and that project can use that symbol - all files of that projects.
- If the symbol definition file or project is used by other files or projects through `c` or `pr` - all that files/projects.
- If the symbol is defined in a dll or `global.cs`, does not search in entire workspace (it could be slow or gather many unwanted results), but searches in files/projects that use current file/project through `c`/`pr`.

### Highlight symbol references and matching braces
When the text cursor is in a symbol name, the editor automatically highlights that name everywhere in current document.

When the text cursor is before an opening brace `({[<`, highlights the matching closing brace `)}]>`. When after a closing brace, highlights the matching opening brace. When at the `#` of `#if` etc, highlights matching `#endif` etc.

To turn off these features: **Options > Font, colors > Symbol/brace highlight**, set color white and alpha 0.

### Find symbol
The **Find symbol** command shows a temporary window to find a symbol by name and go to its definition.

The search query can contain one or several parts of symbol name, like `part1 part2`. Or include the containing type, like `Type.name`. Or like `FM` to find `FindMe`.

To find only types, use prefix `t`, like `t name` or `t:name`. Prefix `m` is for members (function, field), `n` for namespaces.

To select a symbol, click or use arrow/page keys and `Enter`.

Finds symbols defined in current file or project + files and projects included through `/*/ c /*/` and `/*/ pr /*/`.

### Rename symbol
The **Rename symbol** command finds symbol definition/references like the **Find references** command, and replaces all with the specified new name. It is similar to the "Find and replace text in files" feature, but more precise.

If checked **Include comments/disabled/strings** and finds the word in comments/disabled/strings, at first displays these results in the **Found** panel. You can right-click some of them to exclude. Finally click the **Replace** link. The same if finds symbol usages that are ambiguous or error, for example a method name without parameters used in documentation comments `cref`.

It also automatically resolves name conflicts where possible, for example prepends namespace name.

### Outline of current file
The **Outline** panel shows functions and fields defined in current file. Also types, if there are multiple. And regions. Click to go to the definition.

### Navigate back/forward
The **Back** and **Forward** buttons work like in web browsers.

### Bookmarks
You can mark lines in code, and later go there. Use menu **Edit > Navigate**, panel **Bookmarks** and the markers margin.

Menu commands **Previous bookmark** and **Next bookmark** visit only active bookmarks. If there are no active bookmarks - only bookmarks in current document.

### Code coloring
Different kinds of code parts have different colors. Comments, strings, keywords, types, functions, etc.

### Text folding
You can hide and show code regions like in a tree view control: click the **[-]** or **[+]** in the left margin. Folding is available for functions, events, types, multiline comments, disabled code (`#if`), `#region` ... `#endregion`, `//.` ... `//..`, namespaces, local functions, lambda, initializer lists and strings.

`Ctrl`+click to show/hide descendant folds as well. `Shift`+click to show descendants. For more options right-click the folding margin.

### Separators between functions/types
Editor draws horizontal lines at the end of each function and type definition.

### Snippets
The autocompletion list also contains [snippets](xref:snippets). For example the `outSnippet` inserts code `print.it();` when you type `out` and space or `Tab` or `Enter` or click it. Some snippets are in the **Surround** menu.

### Images in code
If a code line contains a string or comment with a file path, embedded image (screenshot, `"image:"`) or `"*icon"`, editor draws the image at the left. Also captures screenshots when recording etc. Embedded image data usually is hidden.

This feature can be enabled/disabled with the toolbar button.

### Format code
The **Format document/selection** commands insert/remove spaces, indentation and newlines to make code uniformly formatted. See also **Options > Code editor > Formatting**.

### Comment/uncomment/indent/unindent lines
To disable or enable a line of code by converting it to/from comments, you can use the toolbar button or **Edit** menu or right-click the selection margin. If multiple lines are selected, it converts all. If not full line(s) selected, the button uses a `/*block comment*/`.

Press `Tab` or `Shift+Tab` to indent or unindent all selected lines. It adds or removes one tab character before each line.

### Capture UI elements, insert regex etc, implement interface
The **Code** and **Edit** menus contain tools for creating code to find a window, UI element or image, for inserting parts of regular expression or keys string, generating interface/abstract implementation methods, and more.

### Find Windows API and insert declarations
The app comes with a database of Windows API declarations, and helps to find and insert them. More info: menu **Code > Windows API**, click **[?]**.

### Drag and drop files to insert path
You can drag and drop files from File Explorer etc to the code editor. It inserts code with file path. Links too.

You can also drag and drop scripts etc from the Files panel.

### Focus
To focus the code editor control without changing selection: middle-click.

### WPF window preview
The app does not have a dialog window editor/designer, but it's easy to create windows in code, using class [wpfBuilder](). The app can automatically show/update the window while you edit its code, if it contains code like this:

```csharp
#if WPF_PREVIEW
b.Window.Preview();
#endif
```

This code must be after building the window but before showing it ([wpfBuilder.ShowDialog]() etc).

To activate this feature for current document, check toolbar button **WPF preview** or menu **Edit > View > WPF preview**.

How it works: If **WPF preview** is checked and current script contains `#if WPF_PREVIEW`, the app launches/restarts the script whenever you make changes in its code, unless there are errors. The script runs like when clicked the **Run** button, with these changes:
- Defined `WPF_PREVIEW`. In script you use `#if WPF_PREVIEW` to include preview-specific code. Or use [script.isWpfPreview]().
- Function **Preview** shows the window without activating. Also changes some its properties. Ends the process when the window closed.
- Some `/*/ properties /*/` are ignored: `role`, `ifRunning`, `uac`, `platform`, `console`, `optimize`, `outputPath`, `preBuild`, `postBuild`, `xmlDoc`.
- If current file (or its main project file) is a class file, runs it as a script; ignores the test script. Therefore need `#if WPF_PREVIEW` code that runs at startup and calls the function that contains the window code.
- Function [script.setup]() does nothing.

In preview mode the script must go straight to the window code. If normally it doesn't, add code like this somewhere at the start:
```csharp
#if WPF_PREVIEW
FunctionContainingWindowCode();
#endif
```

If it's a dialog class, add code like this:
```csharp
#if WPF_PREVIEW
new DialogClass().Preview();
#endif
```

or this:
```csharp
#if WPF_PREVIEW
class Program { static void Main() { new DialogClass().Preview(); }}
#endif
```

In preview mode the script must not activate or move the window. Should skip slow/expensive operations that aren't necessary for preview. Should not show the tray icon.


================================================
FILE: Other/DocFX/_doc/editor/Command line.md
================================================
---
uid: command_line
---

# Command line of `Au.Editor.exe`

- `/v` - show the main window when started, regardless of app settings.
- `/a` - indicates that the app started automatically and therefore must ignore **Options > App > Visible if not auto-started**. Used by **Options > App > Start with Windows**.
- `/reload` - if the app is running, reload current workspace.
- `/n` (the first argument) - don't restart as administrator when started not as administrator. See [UAC](xref:uac).
- `"script name or relative path in current workspace"` - run the script. Can be followed by script's command line arguments (the *args* variable).
- `"full path of a file or folder"` - import it into the current workspace (shows a dialog). Can be multiple files, like `"file1" "file2" "file3"`.
- `"workspace folder path"` - open or import the workspace (shows a dialog).

With the last 3 cannot be used other arguments except **/n**.

### About "run script"
The started `Au.Editor.exe` process is an intermediate temporary process, not the regular editor process with UI. It just relays the command line to the regular process, waits if need, and exits. Also it starts the regular process if not running. The regular process compiles and starts the script.

Use prefix `*` to wait until the script ends. While waiting, the parent process can read script's [script.writeResult]() text from standard output of the child process. If parent process is console, it automatically displays the text. Or it can redirect standard output, like [run.console]() does.

For Task Scheduler tasks the **Schedule** tool sets prefix `>`. Then Task Scheduler knows when the script process is running and can end it when need.

The exit code of this process when it waits is the script's exit code. The script can simply return it, like `return 1;` or call `Environment.Exit`. When does not wait, the exit code is the process id of the script. When fails to run (script not found, contains errors, etc) or wait, the exit code is < 0 (can be -1 to -7).

### Examples

- `Au.Editor.exe Script5.cs`
- `Au.Editor.exe "Script name with spaces.cs"`
- `Au.Editor.exe Script5.cs /example "argument with spaces"`
- `Au.Editor.exe *Script5.cs`
- `Au.Editor.exe /v`


================================================
FILE: Other/DocFX/_doc/editor/Compared with QM.md
================================================
---
uid: qm2
---

# Compared with Quick Macros
LibreAutomate is like a new major version of [Quick Macros](https://www.quickmacros.com) (QM). It has most of QM features. But it is very different.

The script language now is C#. It is one of most popular programming languages.

LibreAutomate cannot execute or convert QM scripts. If you have many QM scripts, probably not worth to convert them. Let both programs run at the same time.

LibreAutomate is free and open-source. Its open-source automation library can be used in other programs too.

LibreAutomate can run on Windows 7-11 with .NET runtime. More info [here](xref:index).

QM (Quick Macros) will not have more features in the future. Only bug fixes. But it will be available and supported for long time.

Let's compare QM and LibreAutomate code.

A script in QM:
```csharp
int w=win("- Mozilla Firefox")
act w ;;comment
lef 331 115 w 1
2
key L "text" Y
int i
for i 0 5
	out i
	out i*i
```

The same script in LibreAutomate:
```csharp
var w = wnd.find("*- Mozilla Firefox");
w.Activate(); //comment
mouse.click(w, 331, 115);
2.s();
keys.send("Left", "!text", "Enter");
for(int i=0; i<5; i++) {
	print.it(i);
	print.it(i*i);
}
```

As you see, C# code is longer, but usually it is easier to understand. The [code editor](xref:code_editor) can add `; () { }` automatically as you type, and has other code editing features that are much better than in QM.

LibreAutomate has triggers to execute parts of a running script. Trigger types: hotkey, autotext, mouse, window, process, filesystem. Triggers also can be used to launch scripts, but differently than in QM.

LibreAutomate does not have item types like "menu", "toolbar" and "autotext". Instead use classes [popupMenu](), [toolbar]() and [AutotextTriggers]().

To create dialogs now can be used class [wpfBuilder]() and snippet `wpfDialogSnippet`.

Currently LibreAutomate has only the most important tools for creating code.

In LibreAutomate each script is a separate .cs file.

In LibreAutomate each script runs in a separate process.

In LibreAutomate each script can use only namespaces it wants to use. Namespaces contain classes; classes contain functions and fields (variables). In QM all scripts share all classes, global functions and global variables.

LibreAutomate can create .NET class libraries (dll files).

In the main LibreAutomate window you can resize and dock all panels and toolbars where you want, or make floating.

LibreAutomate saves all settings in files, not in the Registry.

### Some important features missing
- Dialog editor. Instead use class [wpfBuilder]().

### Some features LibreAutomate will never have
- Encrypt scripts.
- Unlock computer.


================================================
FILE: Other/DocFX/_doc/editor/Creating exe programs.md
================================================
---
uid: publish
---

# Creating exe programs
Two ways of creating programs that can run without LibreAutomate:
- Script role `exeProgram`.
- Menu **Run > Publish**.

## Script role exeProgram
In **Properties** set role `exeProgram`. When compiling the script, LibreAutomate creates/copies program files (exe, dll) to the output directory and prints a link to it. To compile, click the **Compile** button or run the script.

The program consists of several files. To add them to a single executable file you can create an installer, for example with Inno Setup.

The program uses .NET Runtime of version displayed in menu **Help > About**. On computers without .NET it can't run; it prompts to download .NET.

If `optimize true` (checked **optimize** in **Properties**), the program is created with optimized code (fast and small), aka "Release".

Creates program files for the selected platform. If `optimize true` and not `platform x86`, also creates program files for other 64-bit platform. If `platform x86`, always creates only x86 files. More info below in the **Common info** section.

## Menu Run > Publish
The **Publish** tool can create single-file programs and programs that can run on computers without installed .NET.

It creates a temporary .csproj file and executes [dotnet publish](https://www.google.com/search?q=dotnet+publish), which uses .NET SDK to compile the script.

Options:
- **Single file** - create single-file program. Adds all program files to single exe file.
- **Single file > Self extract** - read below.
- **Add .NET Runtime** - add .NET Runtime files too. Then the program can run on computers without installed .NET. If unchecked, on computers without .NET the program just prompts to install .NET. A single-file exe is compressed, ~70 MB.
- **ReadyToRun** - compile to native code.
- **Platform** - CPU instruction set. You can publish for multiple platforms (run the publish tool several times). Files of each platform are created in a separate folder. More info below in the **Common info** section.

Always compiles the program and its `/*/ pr /*/` libraries like with `/*/ optimize true; /*/` (aka "Release").

Role can be `exeProgram` or `miniProgram`.

Unsupported features:
- `/*/ icon folder /*/` (multiple native icons).
- `/*/ testInternal, noRef /*/`.

### Self-extract

This 3-state checkbox is enabled when **Single file** is checked.
- Checked - use `IncludeAllContentForSelfExtract`. Adds all files to exe. Will extract all (including .NET dlls) to a temporary directory. The program will start slower, but will not have issues like unavailable [Assembly.Location](ms:).
- Unchecked - adds only .NET dlls to exe. Native dlls and other files (if any) will live in the exe's directory. Will use .NET dlls without extracting.
- Indeterminate - use `IncludeNativeLibrariesForSelfExtract`. Adds all dlls to exe. Will extract native dlls, and use .NET dlls without extracting. This is the best for most scripts, but can't be used with some scripts (the **Publish** tool will print a warning). 

[More info](https://www.google.com/search?q=dotnet+publish+single-file+IncludeAllContentForSelfExtract+IncludeNativeLibrariesForSelfExtract)

## Common info

Where the program can run, depends on the selected platform:
- x64 - runs on all modern Windows computers (x64, Windows11+ ARM64).
- arm64 - runs only on Windows ARM64. Used because x64 and x86 programs are slow there.
- x86 - runs on almost all Windows computers (x64, x86, all ARM64), as 32-bit process.

These script properties are not applied to exe programs launched not from LibreAutomate:
- `ifRunning`. Multiple instances (processes) of the program can run simultaneously. To prevent it can be used [script.single]().
- `uac`. By default programs run not as administrator (unlike when launched from admin LibreAutomate) and therefore can't automate admin windows etc. See [UAC](xref:uac).

Program files don't contain the source code, but can be decompiled into equivalent source code.

[print.it]() text is displayed in LibreAutomate if it is running, unless it's a console program. See also [PrintServer]().

If you want to use action triggers (hotkeys etc) in exe program, add them to the script like in the [ActionTriggers]() example.

To get program/OS/computer info can be used classes [script](), [process](), [uacInfo](), [osVersion](), [folders](), [Environment](ms:), [RuntimeInformation](ms:), [OperatingSystem](ms:).

Antivirus programs and OS may block or block-scan-restart unknown (new) program files. To avoid it on the development computer, in the AV program add the output directory to the list of exclusions. To avoid it anywhere, need to sign program files with a code signing certificate, and it must have a good reputation; it isn't cheap and isn't easy to get.

## See also
- [Scripts](xref:script)
- [File properties](xref:file_properties)




================================================
FILE: Other/DocFX/_doc/editor/Debugger.md
================================================
---
uid: debugger
---

# Debugging C# scripts
## Useful functions
See cookbook article [Script testing and debugging](/cookbook/Script+testing+and+debugging.html).

## Debugger
Debugger in LibreAutomate is similar to that of [Visual Studio](https://www.google.com/search?q=Visual+Studio+debugger), [VSCode](https://www.google.com/search?q=VSCode+debugger), [Rider](https://www.google.com/search?q=Rider+debugger) etc.

Two panels are for debugging: **Debug** and **Breakpoints**. If the **Debug** panel was hidden when debugging starts, it becomes visible temporarily while debugging. Both panels initially are hidden; to show always, right-click any panel header.

To run current script with the debugger, click the **Debug run** button or menu item, or use the toolbar in the **Debug** panel. Usually at first you add one or more breakpoints in code (click the white margin). The script stops at a breakpoint line, or on exception, or in [Debugger.Break](ms:), [Debug.Assert](ms:), or when clicked **Pause**. Then you can use the **Debug** toolbar or hotkeys to execute the script in steps. Also you can click the white margin and select **Run to here**.

To attach the debugger to an already running script, use the **Tasks** panel or [script.debug](). Or [Debug.Assert](ms:), if the script starts with code like `script.setup(debug: true);`.

### Features
- Standard stepping features.
- Breakpoints, logpoints.
- Break on exception.
- Call stack.
- List of variables. Click a variable to print it.
- Hover the mouse on a variable in code to display its value.
- Supports [Debugger.Break](ms:), [Debug.Assert](ms:), [Debug.Print](ms:) etc.
- Run to here.
- Jump to here.

### Some missing features
- "Hot reload" or "Edit and continue".
- Evaluate any C# expression.
- Set variable's value.
- Open and debug source files that don't exist in the workspace.
- Attach the debugger to unknown processes.

### Notes
Thanks to [Samsung/netcoredbg](https://github.com/Samsung/netcoredbg).

Antivirus software may quarantine `netcoredbg.exe` (debugger). Add it to the exclusions list of the antivirus.

To debug optimized code (`/*/ optimize true; /*/`), temporarily check **Debug optimized code** in the options menu. Normally you don't debug optimized code, it may not work well.

Cannot debug 32-bit processes.

## Other debuggers
You may have Visual Studio or other IDE with a better .NET debugger. You can attach that debugger to a running script. Let the script call one of these functions:
- [Debugger.Launch](ms:). Example: `Debugger.Launch(); Debugger.Break();`. Note: it shows several dialogs before you can start debugging.
- [script.debug](). Example: `script.debug(true); Debugger.Break();`. It shows a dialog with the script process id and waits for a debugger attached. Then you can attach a debugger. To automate it, create a window-triggered script.

```csharp
Triggers.Window[TWEvent.ActiveNew, "Attach debugger", "#32770"] = o => script.run("Attach debugger.cs", o.Window.ProcessId.ToS());
```

Script `Attach debugger.cs`:
```csharp
// Attaches the Visual Studio debugger to the process id = args[0].
// If run from editor (args empty), attaches to this process for testing this script.

bool test = script.testing; //test this script
if (test) print.clear();
int id = test ? process.thisProcessId : args[0].ToInt();

bool canAttach = false;
var w = wnd.find("*Visual Studio*", "HwndWrapper[DefaultDomain;*");
if (w.Is0) {
	dialog.showInfo("Debugger window not found", "Supported debuggers: Visual Studio, VSCode, dnSpy.");
} else if (uacInfo.ofProcess(id).Elevation == UacElevation.Full && uacInfo.ofProcess(w.ProcessId).Elevation != UacElevation.Full) {
	dialog.showInfo("Debugger isn't admin", "The debugger process must be running as administrator.");
} else canAttach = true;
if (!canAttach) {
	if (!test) process.terminate(id); //because it's waiting in script.debug
	return;
}

w.Activate();
600.ms();
keys.send("Ctrl+Alt+P");
var w2 = wnd.find(5, "Attach to Process", "**m HwndWrapper[DefaultDomain;*||#32770");
300.ms();
if (w2.ClassNameIs("H*")) { //new VS
	w2.Elm["STATICTEXT", id.ToS()].Find(5).Parent.Focus(true);
} else { //old VS
	w2.Elm["LISTITEM", null, ["id=4102", $"desc=ID: {id}? *"]].Find(5).Focus(true); //note: use '?' because can be ',' or ';' etc depending on regional settings
}
w2.Elm["BUTTON", "Attach", "state=!DISABLED"].Find(3).Invoke();

if (test) {
	wait.until(0, () => Debugger.IsAttached);
	Debugger.Break();
	print.it("Debugger script.");
}
```


================================================
FILE: Other/DocFX/_doc/editor/File properties.md
================================================
---
uid: file_properties
---

# C# file properties

C# file properties in LibreAutomate are similar to C# project properties in Visual Studio.
Most properties are stored in `/*/ meta comments /*/` at the start of code. Can be edited in the **Properties** window or in code.

Meta comments syntax:
- The block of meta comments starts and ends with `/*/`. Only the first such block is used.
- The block of meta comments must be at the start. Can be preceded by comments and empty lines.
- Property name and value are separated by space.
- Multiple properties separated by `;` or/and newlines.
- Property names must match case.
- Property values are not enclosed in quotes etc.
- There are no escape sequences.

Example - single line:
```csharp
/*/ role exeProgram; outputPath %folders.Workspace%\exe\Script1; /*/
```

Example - multiple lines:
```csharp
/*/
role exeProgram
outputPath %folders.Workspace%\exe\Script1
/*/
```

The compilation may contain multiple C# files (files in the project folder and files added using meta comment `c`). Properties are applied to the entire compilation, not only to the file where specified. Most properties can be specified only in the main file of the compilation (error if not); others can be anywhere (`c`, `r`, `pr`, `nuget`, `com`, `resource`, `file`). Most properties can be specified once (error if not); others can be multiple (`c`, `r`, `pr`, `nuget`, `com`, `resource`, `file`, `noRef`). Some properties are available only for some roles.

Terms used this article:
- *property* and *meta comment* are synonyms.
- *editor* and *LibreAutomate* are synonyms.
- *script file* - a C# file that can be executed directly (like a program).
- *class file* - a C# file that contains classes/functions that can be used in other files.
- *project folder* or *project* - folder named like `@Example` (starts with `@`). The first C# file (*main file*) and all class files are automatically added to the compilation.
- *compilation* - one or more C# files that are compiled together to create a program or library.

Properties in this article are grouped like in the **Properties** window.

## Table of contents

  - [Role (group of properties)](#role-group-of-properties)
    - [`role`](#role) - `miniProgram`, `exeProgram`, `editorExtension`, `classFile` or `classLibrary`.
  - [Run (group of properties)](#run-group-of-properties)
    - [`testScript`](#testscript) - a script to run to test this not-directly-executable class file.
    - [`ifRunning`](#ifrunning) - whether/how to launch this script if it's already running.
    - [`uac`](#uac) - run this script as admin or not.
  - [Compile (group of properties)](#compile-group-of-properties)
    - [`optimize`](#optimize) - release/debug configuration.
    - [`define`](#define) - preprocessor symbols.
    - [`warningLevel`](#warninglevel) - disable groups of warnings.
    - [`noWarnings`](#nowarnings) - disable specified warnings.
    - [`nullable`](#nullable) - C# nullable context.
    - [`testInternal`](#testinternal) - use internal members of specified assemblies.
    - [`preBuild`](#prebuild) - a script to run before compiling.
    - [`postBuild`](#postbuild) - a script to run after compiling.
  - [Assembly (group of properties)](#assembly-group-of-properties)
    - [`outputPath`](#outputpath) - output directory of compiled exe/dll files.
    - [`icon`](#icon) - icon of compiled exe file.
    - [`manifest`](#manifest) - manifest of compiled exe file.
    - [`sign`](#sign) - strong-name signing file.
    - [`console`](#console) - create console app.
    - [`platform`](#platform) - platform of compiled exe file (`x64`, `arm64` or `x86`).
    - [`xmlDoc`](#xmldoc) - whether to create an XML documentation file when compiling this library.
  - [Add reference (group of properties)](#add-reference-group-of-properties)
    - [`r` (button **Library**)](#r-button-library) - .NET assembly reference.
    - [`nuget` (button **NuGet**)](#nuget-button-nuget) - NuGet package reference.
    - [`com` (buttons **COM** and **...**)](#com-buttons-com-and-) - COM interop assembly reference.
    - [`pr` (button **Project**)](#pr-button-project) - library project reference.
  - [Add file (group of properties)](#add-file-group-of-properties)
    - [`c` (button **Class file**)](#c-button-class-file) - add a C# file to the compilation.
    - [`resource` (button **Resource**)](#resource-button-resource) - add a resource from a file.
    - [`file` (button **Other file**)](#file-button-other-file) - make a file available at run time.
  - [Rarely used properties](#rarely-used-properties)
    - [`miscFlags`](#miscflags) - miscellaneous rarely used flags.
    - [`noRef`](#noref) - remove a default reference assembly.
  - [Version info](#version-info) - how to add version info.

## Role (group of properties)

### `role`
The purpose of this C# code file. What kind of assembly to create and how to execute.
- `miniProgram` - execute in a separate host process started from editor.
- `exeProgram` - create/execute exe file, which can run on any computer, without editor installed.
- `editorExtension` - execute in the editor's UI thread. Rarely used. Incorrect code can kill editor.
- `classLibrary` - create dll file, which can be used in C# scripts and other .NET-based programs.
- `classFile` - don't create/execute. The C# code file can be compiled together with other C# code files in the project or using meta comment `c`. Inherits meta comments of the main file of the compilation.

Default role for scripts is `miniProgram`; cannot be the last two. Default for class files is `classFile`; can be any.

See also: [Scripts](xref:script), [Class files](xref:class_project), [Shared classes and functions, libraries](/cookbook/Shared classes and functions, libraries.html)

## Run (group of properties)

LibreAutomate uses these properties when launching the script task.

### `testScript`
A script to run when you click the **Run** button.

This property is for testing class files with role `classFile` or `classLibrary`. Such files cannot be executed directly.

The test script can contain meta comment `/*/ c this file.cs; /*/` that adds this file to the compilation, or `/*/ pr this file.cs; /*/` that adds the output dll file as a reference assembly. An easy way to add this property correctly is to try to run this file and click a link that is then printed in error text in the output.

The value can be:
- Path in the workspace. Examples: `\Script5.cs`, `\Folder\Script5.cs`.
- Path relative to this file. Examples: `Folder\Script5.cs`, `.\Script5.cs`, `..\Folder\Script5.cs`.
- Filename. Error if multiple exist, unless single exists in the same folder.

This property is saved in `files.xml`, not in meta comments.

### `ifRunning`
When trying to start this script, what to do if it is already running.
- `warn` - print warning and don't run.
- `cancel` - don't run.
- `wait` - run later, when it ends.
- `run` - run simultaneously.
- `restart` - end it and run.
- `end` - end it and don't run.

Suffix `_restart` (`warn_restart`, `cancel_restart`, `wait_restart`, `run_restart`, `end_restart`) changes the behavior: when using the **Run** button/menu to start the script, use `restart`; else use the value as without the suffix.

Default is `warn_restart`.

This property is ignored when the script runs as exe program started not from editor. Then it's an ordinary program (works like with `ifRunning run`). To allow single instance you can use [script.single](), like `script.single("unique string");`.

### `uac`
[UAC](xref:uac) integrity level (IL) of the task process.
- `inherit` (default) - the same as of the editor process (High IL recommended).
- `user` - Medium IL, like most applications. The task cannot automate high IL process windows, write some files, change some settings, etc.
- `admin` - High IL, aka "administrator", "elevated". The task has many rights, but cannot automate some apps through COM, etc.

This property is ignored when the script runs as exe program started not from editor. Then it's an ordinary program.

## Compile (group of properties)

LibreAutomate uses these properties when compiling the script or library.

### `optimize`
Whether to make the compiled code as fast as possible.
- `false` (default) - don't optimize. Define preprocessor symbols `DEBUG` and `TRACE` that can be used with `#if`. Aka "Debug configuration".
- `true` (checked) - optimize. Aka "Release configuration".

Default is `false`, because optimization makes difficult to debug. Optimization makes noticeably faster only some types of code, for example processing of large/many arrays. Before deploying class libraries and exe programs you usually compile with `optimize true`.

### `define`
Symbols that can be used with `#if`. Example: `ONE,TWO,d:THREE,r:FOUR`.

A symbol here can have a prefix:
- `r:` - define the symbol only if `optimize true` (checked).
- `d:` - define the symbol only if no `optimize true`.

If no `optimize true`, symbols `DEBUG` and `TRACE` are added implicitly.

See also [C# #define](ms:).

### `warningLevel`
[warning level](ms:C#+Compiler+Options,+WarningLevel). Default 8.
- 0 - no warnings.
- 1 - only severe warnings.
- 2 - level 1 plus some less-severe warnings.
- 3 - most warnings.
- 4 - all warnings of C# 1-8.
- 5-9999 - level 4 plus warnings added in C# 9+.

### `noWarnings`
Don't show these warnings. Example: `151,3001,CS1234`.

See also [#pragma warning](ms:C#+#pragma+warning).

### `nullable`
[nullable context](ms:C#+Nullable+reference+types).
- `disable` - no warnings; code does not use nullable syntax (`Type? variable`).
- `enable` - print warnings; code uses nullable syntax.
- `warnings` - print warnings; code does not use nullable syntax.
- `annotations` - no warnings; code uses nullable syntax.

Alternatively use `#nullable` directive.

### `testInternal`
Can use internal symbols of these assemblies, like with `InternalsVisibleToAttribute`.
Example: `Assembly1,Assembly2`.

### `preBuild`
A script to run before compiling.

The script must have role `editorExtension`. It runs in the editor's main thread.  
To get compilation info: `var c = PrePostBuild.Info;`  
To specify command line arguments: `/*/ preBuild Script5.cs /arguments; /*/`  
To stop the compilation, let the script throw an exception.  
To create new preBuild/postBuild script: menu **File > New > More**.

The value can be:
- Path in the workspace. Examples: `\Script5.cs`, `\Folder\Script5.cs`.
- Path relative to this file. Examples: `Folder\Script5.cs`, `.\Script5.cs`, `..\Folder\Script5.cs`.
- Filename. Error if multiple exist, unless single exists in the same folder.

### `postBuild`
A script to run after successfully compiling and creating output files.

Everything is like with `preBuild`.

## Assembly (group of properties)

LibreAutomate uses these properties when creating program files after compiling the script/library code.

### `outputPath`
Directory for the output assembly file and related files (used dlls, etc).

Full path. Can start with `%environmentVariable%` or `%folders.SomeFolder%` (see class [folders]()). Can be path relative to this file or workspace, like with other properties.

Default if role `exeProgram`: `%folders.Workspace%\exe\filename`. Default if role `classLibrary`: `%folders.Workspace%\dll`. The compiler creates the folder if does not exist.

### `icon`
Icon of the output exe file.

The icon will be added as a native resource and displayed in File Explorer etc. Native resources can be used with [icon.ofThisApp]() etc and [dialog]() class functions.

The file must be in this workspace. Import files if need (eg drag-drop). Can be a link.
The value can be:
- Path in the workspace. Examples: `\App.ico`, `\Folder\App.ico`.
- Path relative to this file. Examples: `Folder\App.ico`, `.\App.ico`, `..\Folder\App.ico`.
- Filename. Error if multiple exist, unless single exists in the same folder.

If role `exeProgram`, you can specify a folder instead. Will add all `.ico` and `.xaml` icons from it. Resource ids start from `IDI_APPLICATION` (32512).

Another way to set exe icon - assign a custom icon to the main C# file. See menu **Tools > Icons**.

### `manifest`
[manifest file](ms:) of the output exe file.

The file must be in this workspace. Import files if need (eg drag-drop). Can be a link.
The value can be:
- Path in the workspace. Examples: `\App.manifest`, `\Folder\App.manifest`.
- Path relative to this file. Examples: `Folder\App.manifest`, `.\App.manifest`, `..\Folder\App.manifest`.
- Filename. Error if multiple exist, unless single exists in the same folder.

The manifest will be added as a native resource.

### `sign`
Strong-name signing key file, to sign the output assembly.

The file must be in this workspace. Import files if need (eg drag-drop). Can be a link.
The value can be:
- Path in the workspace. Examples: `\App.snk`, `\Folder\App.snk`.
- Path relative to this file. Examples: `Folder\App.snk`, `.\App.snk`, `..\Folder\App.snk`.
- Filename. Error if multiple exist, unless single exists in the same folder.

### `console`
Let the program run with console.

### `platform`
CPU instruction set.
- `x64` - runs on all modern Windows computers (x64, Windows11+ ARM64).
- `arm64` - runs only on Windows ARM64. Used because x64 and x86 programs are slow there.
- `x86` - runs on almost all Windows computers (x64, x86, all ARM64), as 32-bit process.

Default - as LibreAutomate and the Windows OS on this computer (x64 or arm64).

Creates program files for this platform. If `optimize true` and `platform` not `x86`, creates for both x64 and arm64. In any case, the process uses this platform when launched from editor.

Most .NET dlls can be used by programs of any platform. But native dlls can be used only in programs of the same platform as of the dll. Usually libraries that use native dlls have dll files for multiple platforms. If a dll for some platform is missing, you can't use that platform for your script/program that will use that library. Workaround: use role `exeProgram` and platform of an available dll.

### `xmlDoc`
Create XML documentation file from `///` comments. And print errors in `///` comments when compiling.

XML documentation files are used by code editors to display class/function/parameter info. Also can be used to create HTML documentation.

## Add reference (group of properties)

This is a group of buttons in the **Properties** window. The buttons add meta comments for adding library references to the compilation.

### `r` (button **Library**)
Add a .NET assembly reference.
Meta comment `/*/ r File.dll; /*/`.

Don't need to add `Au.dll` and .NET runtime dlls.  
To remove this meta comment, edit the code in the code editor.  
If script role is `editorExtension`, may need to restart editor.

In code you can add some properties, like `/*/ r DllFile /property1|property2; /*/`:
- To not copy the dll to the output directory: `noCopy`
- To use `extern alias Abc;`: `alias=Abc`

### `nuget` (button **NuGet**)
Use a NuGet package reference (see menu **Tools > NuGet**).
Meta comment `/*/ nuget Folder\Package; /*/`.

To remove this meta comment, edit the code in the code editor.  
To use `extern alias Abc;`, edit the code: `nuget Folder\Package /alias=Abc`

### `com` (buttons **COM** and **...**)
Use a COM interop assembly.
Meta comment `/*/ com File.dll; /*/`.

In the **Properties** window select a COM component. It immediately converts the type library to a COM interop assembly and saves the assembly file in `%folders.Workspace%\.interop`.

An interop assembly is a .NET assembly without real code. Not used at run time. At run time is used the COM component (registered unmanaged dll or exe file). If a COM dll for current platform unavailable, try to set role `exeProgram` and change platform.

To remove this meta comment, edit the code. Optionally delete unused interop assemblies.  
To use `extern alias Abc;`, edit the code: `/*/ com File.dll /alias=Abc; /*/`

### `pr` (button **Project**)
Add a reference to a class library created in this workspace.
Meta comment `/*/ pr File.cs; /*/`.

The compiler will compile it if need and use the created dll file as a reference.

To remove this meta comment, edit the code. Optionally delete unused dll files.

## Add file (group of properties)

This is a group of buttons in the **Properties** window. The buttons add meta comments for adding various files to the compilation.

### `c` (button **Class file**)
Add a C# code file that contains some classes/functions used by this file.
Meta comment `/*/ c File.cs; /*/`.

The compiler will compile all code files and create single assembly.

The file must be in this workspace. Import files if need (eg drag-drop). Can be a link.  
If folder, will compile all its descendant class files.  
The value can be:
- Path in the workspace. Examples: `\Class5.cs`, `\Folder\Class5.cs`.
- Path relative to this file. Examples: `Folder\Class5.cs`, `.\Class5.cs`, `..\Folder\Class5.cs`.
- Filename. Error if multiple exist, unless single exists in the same folder.

Don't use this meta comment to add class files that are in the same project folder. They are added automatically.

To remove this meta comment, edit the code.

### `resource` (button **Resource**)
Add image etc file(s) as managed resources.
Meta comment `/*/ resource File; /*/`.

Default resource type is `Stream`. You can append `/byte[]` or `/string`, like `/*/ resource file.txt /string; /*/`. Or `/strings`, to add multiple strings from a 2-column CSV file (name, value). Or `/embedded`, to add as a separate top-level stream that can be loaded with [Assembly.GetManifestResourceStream](ms:) (others are in top-level stream `AssemblyName.g.resources`).

The file must be in this workspace. Import files if need (eg drag-drop). Can be a link.  
If folder, will add all its descendant files.  
The value can be:
- Path in the workspace. Examples: `\File.png`, `\Folder\File.png`.  
- Path relative to this file. Examples: `Folder\File.png`, `.\File.png`, `..\Folder\File.png`.  
- Filename. Error if multiple exist, unless single exists in the same folder.

To remove this meta comment, edit the code.

To load resources at run time can be used class [ResourceUtil](), like `var s = ResourceUtil.GetString("file.txt");`. Or [ResourceManager](ms:). To load WPF resources can be used `"pack:..."` URI; if role `miniProgram`, assembly name is like `*ScriptName`.

Resource names in assembly by default are like `file.png`. When adding a folder with subfolders, may be path relative to that folder, like `subfolder/file.png`. If need path relative to this C# file, append space and `/path`. Resource names are lowercase, except `/embedded` and `/strings`. LibreAutomate does not URL-encode resource names; WPF `pack:...` URI does not work if resource name contains spaces, non-ASCII or other URL-unsafe characters. Also LibreAutomate does not convert XAML to BAML.

To browse .NET assembly resources, types, etc can be used for example [ILSpy](google:).

### `file` (button **Other file**)
Make a file available at run time.
Meta comment `/*/ file File; /*/`.

It can be any file, for example an unmanaged dll.

The compiler behavior depends on the role of the main file of the compilation:
- `exeProgram` - copy the file to the output folder. Or subfolder: `/*/ file file.dll /sub; /*/`.
- `miniProgram` or `editorExtension` - store the dll path in the assembly in order to find it at run time.
- `classLibrary` - the above actions are used when compiling scripts that use it as a project reference. The compiler does not copy these files to the output folder of the library.

The file must be in this workspace. Import files if need (eg drag-drop). Can be a link.  
The value can be:
- Path in the workspace. Examples: `\File.png`, `\Folder\File.png`.
- Path relative to this file. Examples: `Folder\File.png`, `.\File.png`, `..\Folder\File.png`.
- Filename. Error if multiple exist, unless single exists in the same folder.

If folder, will include all its descendant files. Will copy them into folders like in the workspace. If a folder name ends with `-`, will copy its contents only (will not create the folder).

If an `exeProgram` script uses unmanaged dll files, consider placing them in subfolders named `64`, `64\ARM` and `32`. Then at run time will be loaded the dll for that platform.

To remove this meta comment, edit the code.

## Rarely used properties

### `miscFlags`
Miscellaneous flags. May be set by some controls of the **Properties** window.

- 1 - don't add XAML icons from code strings like `"*name color"` to exe resources.

### `noRef`
Remove a default reference assembly (.NET or `Au.dll`).
Meta comment: `/*/ noRef AssemblyNameOrAuPathWildex; /*/`.

Can be specified only in code, not in the **Properties** window.

## **Version info**
To add version info to your exe program, insert and edit this code near the start of any C# file of the compilation.

```
using System.Reflection;

[assembly: AssemblyVersion("1.0.0.0")]
//[assembly: AssemblyFileVersion("1.0.0.0")] //if missing, uses AssemblyVersion
//[assembly: AssemblyTitle("File description")]
//[assembly: AssemblyDescription("Comments")]
//[assembly: AssemblyCompany("Company name")]
//[assembly: AssemblyProduct("Product name")]
//[assembly: AssemblyInformationalVersion("1.0.0.0")] //product version
//[assembly: AssemblyCopyright("Copyright © {{DateTime.Now.Year}} ")]
//[assembly: AssemblyTrademark("Legal trademarks")]
```


================================================
FILE: Other/DocFX/_doc/editor/Git, backup, sync.md
================================================
---
uid: git
---

# Git, backup, sync

## Git and GitHub

Git software can be used to make multiple backups of workspace files (scripts etc) and store them in local and cloud repositories.

GitHub is the cloud service where most programmers have their public and private Git repositories.

To backup workspace files can be used LibreAutomate or/and any Git software.

## How to start

You need a [GitHub](https://github.com/) account, and a private repository there. It's free.

1. In your GitHub account [create new repository](https://github.com/new). It must be private and empty (no readme etc). Copy its URL.
2. In LibreAutomate click menu **File > Git > Git setup**. Paste the URL.
3. If Git not installed, click the **Install** button. It installs MinGit (minimal Git) in the LibreAutomate folder (subfolder `Git`). Or you can download and install Git for Windows (not in LA folder); let it set *PATH* variable.
4. Click OK. What it does:
    - Connects to your GitHub account to verify the repository.
    - Creates/initializes local Git repository (hidden subfolder `.git` in the workspace folder).
    - If local repository already exists, just updates its settings (URL).
    - Creates files `.gitignore` and `.gitattributes` if missing.
5. Now you can use other **Git** menu commands. To access it faster, you can unhide the **Git** button in the **File** toolbar.

## How to use

Use menu **File > Git**. Menu commands:

- **Git status** - print Git status info for this repository. It helps you to decide whether you want to commit, push, pull or do nothing.
- **Commit** - make local backup. Adds it to the local Git repository (hidden subfolder `.git` in the workspace folder). Does nothing if there are no changes since the last commit.
- **Push to GitHub** - commit if need, and upload new local commits to the GitHub repository.
- **Pull from GitHub** - if the GitHub repository contains new commits that are not in the local repository, downloads them to the local repository and updates workspace files (scripts etc).
- **GitHub Desktop** - run GitHub Desktop (if installed).
- **Cmd** - run `cmd.exe`. Then you can execute any Git commands.
- **Workspace folder** - open the workspace folder.
- **Reload workspace** - reload current workspace. Need it after an external program (GitHub Desktop, Git, etc) modified workspace files.
- **GitHub sign out** - delete GitHub credentials saved on this computer. You may want it when using portable LibreAutomate.
- **Maintenance** - tools to compact the Git repository.
- **Git setup** - Git setup dialog.

## Remarks

LibreAutomate uses Git command line programs to perform most of the work. Therefore Git must be installed. Either private Git (in LibreAutomate folder) or regular Git. Often LibreAutomate prints the used command line (blue text), and sometimes also the output text (red if failed).

Files and folders imported as links usually are not in the workspace folder and therefore are not included in backup.

The current branch must be `main`. Else **Git** menu commands don't work.

Default Git credential helper is Git Credential Manager. If it does not work on your computer, use another helper.

### Other Git software

Git has many features not included in the **Git** menu. To name a few:
- See the commit history.
- See workspace changes since the last commit, and changes in each commit.
- Restore files from a backup (ie from a commit).
- Pull and merge diverged commits.
- Use branches.

Git can be used via command line. Or you can install a [Git GUI client](https://git-scm.com/downloads/guis). Try [GitHub Desktop](https://desktop.github.com/), it's free and easy to use. In its **File** menu select **Add local repository** and add the workspace folder. If you need a GUI client with more features, try TortoiseGit.

When using external Git software to manage the current LibreAutomate workspace, you can temporarily exit LibreAutomate. It isn't necessary, however you should know that:
- If external Git software made changes in the workspace while LibreAutomate is running, click **Reload workspace** in the **Git** menu.
- LibreAutomate saves everything when another app becomes active (active window). Still there is a small possibility that it may change some workspace files while you use Git.

Use external Git software carefully. Else it can modify workspace files not as you wanted. Consider making a temporary copy of entire workspace folder. The Git menu is safer; the **Pull** command can modify workspace files, but the old version isn't lost anyway.

### Sync

When using the same workspace on multiple computers (for example with portable LibreAutomate), use the **Pull** and **Push** commands to sync its copies (make identical). Use **Pull** when started to work with the workspace. Use **Push** when ending to work with the workspace.

```
Computer1 ending    --push-->  GitHub
Computer2 starting  <--pull--  GitHub
Computer2 ending    --push-->  GitHub
Computer1 starting  <--pull--  GitHub
```

When not using **Pull** and **Push** strictly in this way, the commit histories in the local and GitHub repositories may diverge. It meens, both repositories contain new different commits. The **Pull** command detects it and you'll have to choose which new changes you want to keep - local or remote (on GitHub). Git software also supports merging, but it is an advanced operation that can damage some files, and is not recommended to use with LibreAutomate workspaces.

### Excluded files

Git ignores (does not backup etc) files and directories specified in file named `.gitignore` in the workspace directory. The Git setup dialog creates it if missing. You can edit it ([how](https://www.google.com/search?q=.gitignore)). Default text:

```
/.nuget/*/*
/.interop/
/exe/
/dll/

# Don't change these defaults
!/.nuget/*/*.csproj
/.compiled/
/.temp/

```

The first 2 lines exclude directories that contain many big binary files (dll etc) than can be easily restored. You may want to delete or comment out these lines if cannot easily restore, for example if using portable LibreAutomate. But then your local Git repository (folder `.git`) can become very big after some time. Next 2 lines exclude default directories used for your created programs and libraries. The last 2 lines exclude directories where LibreAutomate stores temporary files. Lines starting with `!` reinclude some files in directories excluded by other lines.

If using the same workspace on multiple computers, you can exclude these small folders if don't want to sync:
- `/.state/` - saved foldings, caret position, lists of open files and expanded folders, etc.
- `/.toolbars/` - saved toolbar settings (position, context menu, etc).

If you don't exclude some big files that are unnecessary to backup, after some time the `.git` folder can become very big. Then you can try **Maintenance** in the **Git** menu. Or install and use git-filter-repo or similar tool. Afterwards you may want to add these files to .gitignore.

### Restoring workspace files from backup

If you have the workspace folder with Git repository on current computer, you can restore workspace files to the state saved at the time of the last or some older commit. A commit is a backup; you make it with **Git** menu command **Commit** or **Push to GitHub**. To restore, use [Git software](#other-git-software).

In GitHub Desktop:
- If there are files displayed in the **Changes** tab and you want to restore them from the last commit:
    - To restore all files: menu **Branch > Discard all changes**.
    - To restore a file: right click it and select **Discard changes**. With `Ctrl` or `Shift` you can select multiple files.
    - Alternative way to restore all files: commit and then revert (read below).
- Or you can restore the workspace from an older commit. In **History** right click the top commit and select **Revert**. It retains all commits and adds 1 new commit. If need, repeat this for other commits made after the wanted commit, in top-down order.

After restoring, if LibreAutomate is running, in its **Git** menu select **Reload workspace**. Or exit LibreAutomate before restoring.

If you don't have the workspace folder with Git repository on current computer, you can clone (download) it from a GitHub repository. Run LibreAutomate, and it will open the last used or new workspace. In the **Git** menu click **Git setup**, enter repository URL, select **Clone**, **OK**. Then you can open and use the cloned workspace. Or you can clone using any Git software.

### Auto-backup

**Options > Workspace > Auto-backup (Git commit)**.


================================================
FILE: Other/DocFX/_doc/editor/Icons.md
================================================
---
uid: icons
---

# Icons

Icons can be used in C# scripts:
- Toolbars and menus (classes `toolbar`, `popupMenu`)
- WPF windows (classes `wpfBuilder`, `ImageUtil`)
- Standard dialog windows (class `dialog`)
- Tray icon (classes `trayIcon`, `script`)
- Icon in OSD (class `osdText`)

Also in LibreAutomate UI etc:
- Icons of scripts etc displayed in the **Files** panel and elsewhere
- Icons of LA toolbar buttons (menu **Tools > Customize**)
- Icons of generated EXE files (menu **File > Properties**)

Most of the above features support vector icons found in menu **Tools > Icons**.

Some of the above features support classic icons (eg from ICO or EXE files). To get them use class [icon](). Menus and toolbars can automatically get icons for scripts and files used in button/item action code.

Many of the above features use class [IconImageCache]() to cache icons, because finding/extracting them is slow. To clear the cache: menu **Tools > Update icons**. It updates icons in toolbars etc.

## The **Icons** tool

LibreAutomate installs a database file `icons.db` with about 60000 vector icons from [MahApps.Metro.IconPacks](https://github.com/MahApps/MahApps.Metro.IconPacks). You can see them all in the **Icons** tool (menu **Tools > Icons**). A list item displays icon image, name, and icon pack name in parentheses.

Use the search field to find icons. Type a word, and the list displays icons with the word in icon name. Case-sensitive if the search text contains upper-case characters. Also supports [wildcard expression](xref:wildcard_expression) (if contains `*` or `?`) and `Pack.Name`.

You can use the **AI search** button to find icons by name or image using AI. More info: [LA and AI](xref:ai).

All these icons are monochrome. Select a color in the color tool.

Use the **Set file icon** section to assign the selected icon to the file (script etc) or folder currently selected in the `Files` panel. Or you can assign the icon to all files of that kind.

Use the **Menu/toolbar/etc icon** section to assign the selected icon to the toolbar/menu item at the text cursor position in the code editor. Or copy the icon name or XAML to the clipboard. Also use it when working with the **Customize** tool.

Use the **Export to current workspace folder** section to save the selected icon as an ICO or XAML file in the current folder in the workspace (**Files** panel).

Use the **Custom icon string** section to adjust some parameters of the selected icon or/and compose a multi-layer multi-color icon from 2 or more icons.

In scripts these icons are referenced by an *icon name* string like `"*Pack.Name color"`. It includes the pack name, icon name, optionally color (default black). Also optionally can include size, margins, multiple icons (as layers), etc. The syntax is documented in article [ImageUtil.LoadWpfImageElement](). The **Name** button in the **Menu/toolbar/etc icon** section copies the string to the clipboard.

Use the **Options** section to set options for the **Icons** tool:
- **High contrast color** - append the specified color to icon names. It will be used in high-contrast dark mode.
- **List background** - background color for icon images in the list.
- **List image size** - change the size (default 16) of icons in the list. Note, it does not change the size of the copied icon; it's always 16; the run-time size depends on where and how the icon is used.

================================================
FILE: Other/DocFX/_doc/editor/LA and AI.md
================================================
---
uid: ai
---

# LibreAutomate and AI

This article is about LA features that use AI.

## LA documentation search

In the **Help** panel you can use AI-based semantic search to find LA documentation articles. Type a short meaningful search phrase or question in the search field, and press `Enter` or click the **AI search** button. The panel will display a list of LA documentation articles that contain the requested information. The results are much better than a keyword search. The list is ordered by semantic similarity to the search phrase.

The list of results often is not perfect. At the top are the best matches. Items at the bottom may even be not relevant to the search phrase. The tool does not uses slow and expensive AI LLM chat models. It uses AI embedding and reranking models. Normally it takes about 2 s.

For best results, use a short and meaningful phrase or question, like `paste text` or `how to copy selected text into a variable`. It should contain a *single* task, action or concept.

This feature uses AI models from Voyage or Gemini, accessed via web API. They will cost you a few cents per month, depending on usage. Create an account on that AI company's website (Voyage, Google GCP), and generate an API key there. In LibreAutomate, in **Options > AI** enter the API key and select AI models you want to use.

The reranker model is optional, but recommended. It improves the results.

LibreAutomate uses AI models that worked best when testing. But it also allows users to add other models to the list; ask about it in the LA forum or in the Dicsussions of the GitHub repository.

### Improving AI chat answers and generated code

You probably noticed that AI chat bots/apps like ChatGPT, Gemini or Claude usually generate incorrect code when they are asked to use LibreAutomate API. It is because they know too little about the LA API and other LA features. To make AI answers much better, give the AI relevant LA documentation.

When the **Help** panel shows AI search results, the **AI search** button is replaced by button **Copy results for AI chat**. It copies the found articles to the clipboard. Also adds the search phrase and instructions for AI. Paste in an AI chat message (ChatGPT etc).

If your AI chat message is just that text, the AI will assume the search phrase is your question, and will answer it. But the AI answer likely will be better if you write a longer question in the AI chat message, and paste the AI search results below it (or anywhere in the message). You can even paste results of several AI searches in various places in the message.

## MCP server

External AI apps and tools, installed on your computer, can automatically retrieve LA documentation via MCP (Model Context Protocol). Examples: Copilot in Visual Studio, Claude Desktop, n8n. It improves AI chat answers, generated code, AI decisions, etc.

LA has an MCP server that includes tools to get LA documentation. Whenever AI needs information about LA automation API or other features, it calls a tool with a search query (AI-generated). The tool finds relevant LA documentation articles and returns them to the AI. The tool uses the same AI search engine as in the **Help** panel, and the **Options > AI** settings.

LA MCP server details:
- Type: `stdio`.
- Command path: the main LA program file. Usually `C:/Program Files/LibreAutomate/Au.Editor.exe`.
- Command arguments: `/mcp`.

AI apps/tools have a MCP configuration UI or file. Add the LA MCP server there. Example MCP server entry in file `C:\Users\Me\.mcp.json` used by VS Copilot:

```json
    "LibreAutomate": {
      "type": "stdio",
      "command": "C:/Program Files/LibreAutomate/Au.Editor.exe /mcp",
      "disabled": false
    }
```

A MCP client (AI app/tool) runs the program and communicates with it via standard input/output streams. It discovers the tools, and calls them when AI asks.

Tell AI to use the MCP tools. For example add "Use LibreAutomate MCP" in your chat message. Also AI apps like VS Copilot usually have an "AI instructions" file where you can add information about the MCP tools. For example VS Copilot uses file `.github\copilot-instructions.md` in the solution directory. Tell AI to use the file.

<details>
<summary>Example instructions file</summary>

```markdown
# Custom Instructions

## C# Instructions
Applies to: `**/*.cs`

You help LibreAutomate users write C# code and use the app.

Environment: Windows 11, C# 14, .NET 10.

C# code that uses LibreAutomate usually is a script.

Script code should be concise and easy to understand even for non-programmers. Top-level statements; type definitions below. No try/catch at the top level of code.

Prefer LibreAutomate APIs. They're optimized for reliability, simplicity and concise code. Many methods are high-level; just find the right one.

To get information about LibreAutomate API or IDE, use MCP server `LibreAutomate`. You can use it in two ways:
- Call tool `find_la_docs`. It finds and returns the requested information.
- Call tool `get_la_docs_toc` to get the table of contents of the LibreAutomation documentation. Select up to 100 article names, and call tool `get_la_docs` to get the articles.

Don't need `using` directives for LibreAutomate API.

To create WPF windows, use class `wpfBuilder` from LibreAutomate. XAML is used rarely and requires `XamlReader`.

Many LibreAutomate parameter types have implicit conversion operators. Use it to make the code more concise.

LibreAutomate users also can use:
- Libraries from NuGet. Tool to install: menu **Tools > NuGet**.
- Windows API. Add declarations in `unsafe class api : NativeApi { }`.

In your messages prefer ASCII punctuation (`'`, `-`). Don't use emoji in code.

When user asks "do something", usually it actually means "create code to do something", or "explain how to do something".

When user message contains a file path or URL, don't try to load/fetch the file, unless the user asks to do it. The path/URL is likely meant to use in generated code.

In agent mode you may edit files, and build if need. Don't run the program.

```
</details>

To see how AI uses LA MCP tools, check **Options > AI > MCP > Print tool calls**. When a tool is called, it prints the tool name, arguments and results.

Before installing a new LibreAutomate version, close apps that use the MCP server.

## Find icons by name or image

AI also can help you find icons in the **Icons** tool. It can search by name or/and image.

How to use it:
- Type a short search phrase in the search field.
- Or/and copy an icon image (PNG format) to the clipboard. You can find icons on the internet.
- Then click the **AI search** button. After a second it displays icons whose names are similar to the search phrase or/and images are similar to the image in the clipboard.

This feature uses an AI model provided by Voyage (an AI company). You probably already have a Voyage API key and use it for LA documentation search. If not, create a Voyage account, generate an API key, and enter it in **Options > AI**.


================================================
FILE: Other/DocFX/_doc/editor/Menu commands.md
================================================
---
uid: menu_commands
---

<!-- auto-generated -->

# Menu commands

- File
  - New
    - New script  
      A script is a C# code file that can be executed like a program.
    - New class  
      Class files contain C# classes/functions that can be used in other C# files.
    - New text file  
      Text files contain any text except C# code.  
      To change the file type, edit the "txt" in the filename.
    - New folder
    - New project
      - @Script
      - @Library
    - Dialogs
      - Dialog.cs
      - Dialog with tabs.cs
      - Dialog class.cs
      - Dialog with tabs class.cs
    - More
      - preBuild postBuild script.cs
    - Default
      - global.cs
      - @Triggers and toolbars
  - Delete...
  - Rename
  - Properties
  - Copy, paste
    - Multi-select  (option)  
      If checked:  
          - You can select multiple items with Ctrl or Shift.  
          - Double-click to open.
    - Cut
    - Copy
    - Paste
    - Cancel Cut/Copy
    - Copy relative path  
      Path in this workspace (in the Files list), like "\Folder\File.cs".
    - Copy full path  
      Full path of the file.
  - Open, close
    - Open
    - Open in default app
    - Select in Explorer
    - Close
    - Close all
    - Collapse all folders
    - Collapse inactive folders
  - Export, import
    - Export...
    - Import .zip...
    - Import workspace...
    - Import files...
    - Import folder...
  - Workspace
    - Reload this workspace
    - Open workspace...
    - New workspace...
    - Repair workspace...
    - Save now  
      Save all changes now (don't wait for auto-save). Editor text, files, settings etc.
  - Git
    - Git status
    - Commit
    - Push to GitHub
    - Pull from GitHub
    - GitHub Desktop
    - Cmd
    - Workspace folder
    - Reload workspace
    - GitHub sign out
    - Maintenance...
    - Git setup...
  - Close window
  - Exit
- Edit
  - Clipboard
    - Cut
    - Copy
    - Paste
    - Copy forum code
    - Copy HTML \<span style>
    - Copy HTML \<span class> and CSS
    - Copy HTML \<span class>
    - Copy markdown
    - Copy without screenshots
  - Undo
    - Undo
    - Redo
    - Undo in files  
      Undo a multi-file operation, such as renaming a symbol in multiple files.
    - Redo in files  
      Redo a multi-file operation.
  - Find
    - Find text
    - Find symbol...
    - Find references
    - Find implementations
    - Go to definition
    - Go to base
    - Rename symbol
    - Find next
    - Find previous
    - Next found
    - Previous found
  - Assist
    - Autocompletion list
    - Parameter info
    - Raw Enter before ) ] ;  (option)  
      Temporarily disables the "auto-complete statement on Enter" features that are enabled in Options > Code editor.  
      Other ways to insert new line before ) or ] or ; when the auto-completion features are enabled:  
      - Shift+Enter. Or Ctrl+Enter, depending on settings.  
      - Space, then Enter.  
      - Enter, then Ctrl+Z (undo).  
      - Continue a vertical method chain by typing . on the next line after the ;.  
      To exit statement when the features are disabled, use Ctrl+Enter. Or Shift+Enter, depending on settings.  
      More info in app help topic "Code editor".
  - Navigate
    - Toggle bookmark
    - Previous bookmark
    - Next bookmark
    - Go back
    - Go forward
    - Previous document
  - Selection
    - Toggle comment
    - Toggle line comment
    - Comment selection
    - Uncomment selection
    - Surround...
    - Documentation tags...
    - Select all
  - Tidy code
    - Format document
    - Format selection
    - Disable format selection
    - Indent selected lines
    - Unindent selected lines
    - Deduplicate wnd.find  
      Remove duplicate `wnd.find` statements in all or selected text.
    - Remove screenshots  
      Remove screenshots in all or selected text.  
      Screenshot images are saved in text as hidden comments.
  - Generate
    - Create delegate
    - Implement interface/abstract  
      Implement members of interface or abstract base class.
    - Create event handlers
    - Create overrides
    - Create GUID
    - Add function Main
    - Convert [PreserveSig] methods
  - View
    - Wrap lines  (option)
    - Images in code  (option)  
      If checked, displays images (file icons, screenshots, `"image:"`, `"*icon"`).  
      Also captures screenshots when recording etc.
    - WPF preview  (option)
    - Customize...
- Code  
  Tools for creating code
  - Input recorder
  - Find window
  - Find UI element
  - Find image
  - Find OCR text
  - Get files in folder
  - Keys
  - Regex
  - Color
  - Windows API
  - Quick capturing info
- T T  
  Triggers and toolbars
  - Hotkey triggers
  - Autotext triggers
  - Mouse triggers
  - Window triggers
  - New trigger...
  - Other triggers
  - Toolbars
  - New toolbar...
  - Toolbar trigger...
  - Active toolbars
  - Disable triggers
  - Restart TT script
  - Find triggers  
    Finds triggers of current script.  
    Finds its name in '@Triggers and toolbars' files in trigger actions, toolbar button actions and other code.  
    Also finds scheduled tasks, workspace startup scripts and class file test scripts.
  - Triggers list info
  - Script launchers
    - Command line...
    - Schedule...
    - Shortcut...
    - Shell menu...
    - Run at startup...
- Run
  - Compile
  - Run
  - End task
  - Recent...
  - Debug run
  - Publish...
  - PiP session  
    Another session of this user inside a Picture-in-Picture window
  - Run in PiP
- Tools
  - Options
  - Icons
  - Update icons  
    Clear icon caches
  - NuGet
  - Snippets
  - Customize
  - Portable
  - Output
    - Clear
    - Copy
    - History
    - Wrap lines  (option)
    - White space  (option)
- Help
  - LA docs
  - C# docs
  - Context help
  - Website
  - Forum
  - What's new
  - Email
  - Donate
  - About


================================================
FILE: Other/DocFX/_doc/editor/NuGet.md
================================================
---
uid: nuget
---

# NuGet
In C# scripts you use classes and functions all the time. These come from various libraries, also known as assemblies or dll files. Many libraries are already installed (.NET, LibreAutomate), but there are many more great libraries available on the internet.

Two main places where you can find libraries are [GitHub](https://github.com/) and [NuGet](https://www.nuget.org/). GitHub mostly hosts source code, which you usually don't use directly. NuGet is a repository of compiled libraries, called packages. They're easy to install, update, and use in C# code.

In LibreAutomate, use the **NuGet packages** tool to install and manage NuGet packages.

## How to install a NuGet package
Find a package on the [NuGet](https://www.nuget.org/) website. Click the **Copy** button.

    Note: If the package is only for **.NET Framework**, it is outdated and incompatible.

    Tip: There is a link to the source repository on the right side. Visit it to assess the library better. Avoid abandoned libraries (last commit years ago).

Paste the copied text in the **NuGet packages** window. Or you can enter just the package name, and the tool will get the latest version. Or enter `Name --version 1.2.3`.

In the combo box you can select a folder or type a name for a new folder. Or use the default folder `-`. Finally click the **Install** button.

The **Add code** button inserts a meta-comment like `/*/ nuget folder\Package; /*/` in the current script. Another way - **Properties > NuGet**. You can use an installed package in multiple scripts (just add the meta-comment).

Many code examples in the Cookbook use NuGet packages.

## How and where are packages installed (TL;DR)
LibreAutomate and other NuGet package managers download and extract package files into the global/shared package cache folder `folders.Profile + @".nuget\packages"`. Different versions of a package are installed side by side. The folder is safe to delete.

When installing a package, LibreAutomate copies its files from the cache to `workspace\.nuget\folder specified in the combo box`. Then scripts and the code editor can use these files. When compiling an `exeProgram` script, runtime files are copied to the output folder.

You can install multiple packages in a folder. You may want to install large libraries (many dll files) each in its own folder. Folders also can be used to isolate incompatible packages if need (rarely). For example, `PackageX` version 1 in `FolderA`, and `PackageX` version 2 in `FolderB`. An installed package can be used by all scripts of the workspace. A script can use packages from multiple folders if they are compatible.

When a package depends on other packages, those are installed too. The list contains only the top-level package, but in scripts you can use all of them.

LibreAutomate uses standard, well-documented commands like `dotnet add package`. Prints them when installing. Uses `nuget.config` files (sources etc) from standard locations and `workspace\.nuget`.

Some NuGet packages don't install all required files, for example native dlls. Try this:
- Often the missing files are in other NuGet packages. Install these packages.
- Else you may have to download the missing files. In some cases they are in the `.nupkg` file (it is a zip file) in the packages cache folder. Click the **Folder** button and copy these files there. Set read-only attribute to prevent deleting them when managing packages. If the missing files are managed assemblies, in scripts that use them will need `/*/ r Dll; /*/` (use **Properties > Library**). If used in scripts with role `exeProgram`, copy these files to the output folder.

## Used software
Installing packages requires the .NET SDK. By default, LibreAutomate uses it if installed; else downloads (~30 MB) and uses a private minimal SDK. See also **Options > Other > Use minimal SDK**. Portable LibreAutomate requires the full .NET SDK.

To ensure compatibility with all .NET Runtime versions, the minimal SDK uses the oldest build of the current major .NET SDK. Because of this, the Publish feature may fail to build code that uses the latest C# preview features. Solution: install the latest full SDK and ucheck **Options > Other > Use minimal SDK**. Note: the Publish feature is not used to install NuGet packages; it just uses the same minimal SDK.


================================================
FILE: Other/DocFX/_doc/editor/PiP session.md
================================================
---
uid: pip_session
---

# PiP session

A PiP session, also known as child session, is a separate session of the same user in a Picture-in-Picture window, where UI automation scripts can run in the background without interfering with the mouse, keyboard, clipboard and windows in the main desktop.

This feature is available on Windows 8.1 and later, except on Windows Home editions.

Menu **Run > PiP session** - creates a PiP window where the child session runs. You can click the system icon of the PiP window to change some settings, for example clipboard sharing. The **Maximize** button makes the window full-screen.

Simply closing the window just disconnects from the child session and puts it into a no-UI state (UI automation scripts can't run). To end the child session, click **Start > Sign out** in the PiP window.

The **Run > PiP session** command starts a child session if not running, or reconnects if disconnected, or just activates the PiP window if connected. When starting a child session, the command also sets to run LibreAutomate in it, because probably you'll want to run scripts there. Multiple child sessions not supported.

Menu **Run in PiP** - tells the LibreAutomate instance running in PiP to run the script that is currently active in the main LibreAutomate instance. It creates a PiP window if need, like the above command, and puts the new PiP window behind other windows. And waits until UI automation scripts can run.

See also: [script.runInPip](), [script.isInPip](), [miscInfo.isChildSession]()

## App settings
A PiP session runs under the same Windows user account as the main session, so programs in both sessions use the same user files and settings.

Only these LibreAutomate settings are separate:
- **App > Start hidden**, **Visible if**, **Check for updates**
- **Workspace > Startup scripts**, **Auto-backup**
- Hotkeys (all in the **Hotkeys** page)
- Window positions (main window, tool windows)
- Bookmarks, breakpoints, expanded folders, open files, folding.

Ignored in a PiP session started by LibreAutomate:
- **App > Start with Windows** (in PiP always starts)

While LibreAutomate is running in both PiP and main session:
- Don't change other settings, panel/toolbar layout, snippets.
- You can manage and edit workspace files (scripts etc) in both sessions.
- You can run any scrits in the PiP session as well as in the main session.
- Use the same workspace in both sessions.

## Issues and other info
LibreAutomate uses the Windows [child sessions](https://learn.microsoft.com/en-us/windows/win32/termserv/child-sessions) feature, which uses the Remote Desktop technology. Instead of connecting to another computer it creates a new session of the current user of this computer. You can work with the PiP window like with another computer in a Remote Desktop Connection window.

When the child sessions feature is used the first time on a computer, it asks for credentials. Enter the user name and password of your Windows user account. If asks for credentials every time when connecting: sign off the child session, then sign off the main session, and sign in again. If your account does not have a password, you can either create new password or suffer the credentials prompt every time.

Also the first time need to enable the child sessions feature. LibreAutomate automatically enables it. If you'll ever want to disable it, run this in Windows Terminal or cmd running as administrator: `Au.Editor.exe /pip /disablecs`.

You can use PiP without LibreAutomate running in the main session: `Au.Editor.exe /pip`. Also, you can exit and start LibreAutomate in the main or PiP session at any time.

Hotkey, autotext and mouse triggers work only in the main session. Probably you'll even don't want to run your triggers script in PiP. And it is not set to run automatically by default.

The PiP window does not capture the `Win` key. In PiP you can't use hotkeys with it. If a hotkey without the `Win` key is used in both sessions (main and PiP) and you press `Win` + the hotkey, the hotkey is ignored in the main session but works in PiP. Without `Win` - vice versa. This info was about hotkeys other than LibreAutomate triggers.

Because the PiP session uses the same user account and its files/settings as the main session, some programs running in PiP may not work seamlessly. Some apps may refuse to run or open the same files in both sessions (main and PiP) simultaneously. Web browsers may refuse to use the same profile.

There are many other known issues. You can find more info in docs of other programs that use the child sessions (PiP) feature, for example UiPath and Power Automate.


================================================
FILE: Other/DocFX/_doc/editor/Portable app.md
================================================
---
uid: portable
---

# Portable mode
LibreAutomate can run as a [portable application](https://en.wikipedia.org/wiki/Portable_application). In portable mode its data (scripts, settings, caches, temporary files, etc) is inside subfolder `data` of its program folder. The presence of `data` folder tells LibreAutomate to use portable mode.

## Setup
In non-portable LibreAutomate use menu **Tools > Portable**. The tool installs portable LibreAutomate, for example in a USB drive.

The tool copies LibreAutomate program files, .NET runtime, current workspace (scripts etc), settings, script data and the user documents folder of LibreAutomate.

## Run
Run `Au.Editor.exe` (it may be displayed as `LibreAutomate`).

The portable app can run on any Windows 7/8/10/11 64-bit computer. Don't need to install .NET runtime.

The portable app does not have the "always run as administrator" feature, but you can right-click and select **Run as administrator**. See [UAC](xref:uac).

The portable app does not write files outside of its folder. And does not write to the Registry.

LibreAutomate uses these special folders: [folders.ThisAppDocuments](), [folders.ThisAppDataLocal](), [folders.ThisAppTemp](). In portable mode these folders are in subfolder `data` of the portable program folder.

Scripts can write anywhere, but should use only the above special folders. Other useful functions: [ScriptEditor.IsPortable](), [folders.ThisAppDriveBS]().

If you want to store data in an external folder, replace the `data` subfolder with a symbolic link. NTFS filesystem supports it; exFAT doesn't. Example: `filesystem.more.createSymbolicLink(@"D:\PortableApps\LibreAutomate\data", @"..\..\Documents\LibreAutomate", CSLink.Directory);`.

If non-portable LibreAutomate is installed on that computer:
- Portable and non-portable programs cannot run simultaneously.
- Portable and non-portable programs don't share data and settings.

## PortableApps.com
If you use the PortableApps.com platform, install portable LibreAutomate in its folder, for example `D:\PortableApps\LibreAutomate`. Then **LibreAutomate** will be in its menu (the first time may need to click **Apps > Refresh**). By default it is in category **Other**. You can right click it and move to an existing or new category. You can right click it and click **Run as administrator** or check **Start automatically**. The menu contains all exe files found in the LibreAutomate folder, but other files are not useful in the menu, and you can hide them.


================================================
FILE: Other/DocFX/_doc/editor/Scripts.md
================================================
---
uid: script
---

# Scripts

To automate something, you create a script. Click the **New** button on the toolbar. A script is a text file containing C# code. It's a small program that runs when you click the **Run** button. Also there are other ways to launch scripts; look in the Cookbook.

C# is a programming language, one of the most popular. You can find a C# tutorial in the Cookbook and many info on the internet, for example [here](https://learn.microsoft.com/en-us/dotnet/csharp/).

When you click the **Run** button, LibreAutomate at first compiles the script if not already compiled. Cannot run if the C# code contains errors.

Each script task is executed in a separate process, unless its role is `editorExtension`.

In scripts you can use classes/functions of the automation library provided by this program. Also .NET, other libraries and everything that can be used in C#. Also you can create and use new functions, classes, libraries and exe programs.

In the [code editor](xref:code_editor) you can press `Ctrl+Space` to show a list of available functions, classes etc.

A script can contain these parts, in this order. All optional.
- Comments or documentation comments. Example: ```/// File description.```.
- ```/*/ properties /*/```. You can edit it in the **Properties** dialog.
- `using` directives. Don't need those specified in file `global.cs`.
- [script.setup]() or/and other code that sets run-time properties.
- Script code. It can contain local functions anywhere.
- Classes and other types used in the script.

This syntax is known as "C# top-level statements". It is simple and concise, but has some limitations. You can instead use a class with function **Main**. Try menu **Code > Simple > Add function Main**.

The ```//.``` and ```//..``` are used to fold (hide) code. Click the small **[+]** box at the top-left to see and edit that code when need. 

To change default properties and code for new scripts: **Options > Templates**.

If role is `miniProgram` (default), the script is executed in `Au.Task.exe` process. Each script instance runs in separate process. The editor program compiles the script to an assembly file (dll) and saves in folder `.compiled` in the workspace folder. Then `Au.Task.exe` process loads it from there. The process uses `Au.dll` etc from the editor program folder. The `.compiled` folder is a cache containing only temporary assemblies.

If role is `exeProgram`, the editor program creates an exe program in a separate folder, and also copies used dlls etc there. Launches it when you click **Run** etc. You can also run it from File Explorer etc, and copy to other computers. It's an independent program; don't need LibreAutomate to execute it. [More info](xref:publish).

If role is `editorExtension`, the script is executed in editor process (`Au.Editor.exe`). It starts in the UI thread, and can create own thread(s). Must be programmed carefully, else the editor process may hang, crash, become slow, etc. You can't stop the script with the **End task** button; it must be programmed to exit itself. This feature is intended to create editor extensions (see Cookbook article "Editor extension"), run `preBuild`/`postBuild` scripts, and sometimes for other purposes when you want to execute some code in editor process. The assembly file is in folder `.compiled`.

The editor program compiles the script before launching it, but only if need, for example if the compiled assembly file is missing or after editing the C# file.


================================================
FILE: Other/DocFX/_doc/editor/Settings.md
================================================
---
uid: program_settings
---

# App settings and the Options dialog

## App settings

Most app settings are saved in files in folder `Documents\LibreAutomate\.settings`. They are user-specific.

Workspace settings are saved in the workspace folder. Default workspace: `Documents\LibreAutomate\Main`. A workspace is a collection of scripts and other files; you manage them in the **Files** panel.

If you want to copy settings and workspaces to another computer, copy folder `Documents\LibreAutomate`.

See also: [PiP session](xref:pip_session)

## Options dialog

### App

#### Start with Windows
Run this app at Windows startup. This setting is saved in the Registry.

#### Start hidden; let X hide
Don't show the main window when the app starts. To show the window, you can click the tray icon or run the app again. When you close the window, the app process does not exit; just hides the window.

If unchecked, shows the window at startup. The app process exits when you close the window.

#### Visible if not auto-started
Apply the **Start hidden** part of the above setting only if the app started with command line `/a`. Note: `/a` is used by **Start with Windows**.

#### Check for updates
Every day connect to `libreautomate.com` to get program version info. If a new version available, print it in the output panel.

### Workspace
These settings are workspace-specific. Security: the scripts will not run on other computers, unless the user settings file copied there too.

#### Startup scripts
List of scripts to run when this app started and/or loaded this workspace. 
The format is CSV. A delay can be specified in second column. Example:

```
Script1.cs
\Folder\Script2.cs
//Disabled.sc
"Script, name, with, commas.cs"
Script with delay.cs, 3s
Another script with delay.cs, 300ms
```

#### Hide/ignore files and folders
List of ignored files and folders. Matching files/folders are not displayed in the **Files** panel, and the app ignores them (cannot find, compile, etc). Line format: wildcard, not case-sensitive; use `//Line` for comments. Compared is file path in workspace (like `\Folder\File.ext`). The synchronization with the filesystem occurs whenever the app becomes active (active window).

```
Example:
*.bak
*\FolderAnywhere
\Folder
\Folder1\Folder2
//Comment
```

#### Auto backup (Git commit)
Silently run [Git](xref:git) commit when LibreAutomate is visible the first time after loading this workspace or activated later after several hours from the last backup. It creates a local backup of workspace files (scripts etc). To upload etc, you can use menu **File > Git**.

### Font, colors
Font and colors of various code elements displayed in the code editor area. Also fonts of some other UI parts.

#### Theme
Select a predefined set of code editor font/colors, aka *theme*.

Default themes are read-only. Changes to a default theme are saved as a separate theme "Theme \[customized\]"; it's a csv file in the user settings folder. Changes are saved when you click **OK** or **Apply**.

You can add more theme files to the default themes folder of the app. For example copy a customized theme file and rename.

### Code editor
Code formatting and intellisense options.

#### Completion list > Append ()
When you select a function in the completion list, whether/when to append `()`. Can append always, never or only when selected with the `Spacebar` key (but not `Tab`, doubleclick, etc).

### Templates
Initial code of new scripts and class files. Can be empty.

### AI
Select AI models for LibreAutomate features that use AI. Set API keys.

More info: [LA and AI](xref:ai).

### Other
#### Documentation
Which version of documentation to use and where to display.
- **Local** - documentation installed with the app. Displays articles in the **Read** panel.
- **Online** - online documentation. Displays articles in the web browser. The documentation is of the latest program version, which may be not the same as your installed program version.

In any case, the **Help** panel displays the table of contents of the local documentation.

#### Internet search URL
The Internet search URL used by this app, without the search string. Default: `https://www.google.com/search?q=`.

#### Use minimal .NET SDK
What .NET SDK to use for NuGet and Publish:
- Checked - use a minimal SDK that contains .NET SDK files used by the above features. The app automatically installs/updates it when need. Location: subfolder `SDK`.
- Unchecked - use the full .NET SDK, which must be installed manually.
- Indeterminate (default) - use the full SDK if installed, else the minimal.

#### Always print "Compiled"
Always print a \"Compiled\" message when a script etc compiled successfully.
If unchecked, prints only if role is `exeProgram` or `classLibrary`.
If 3-rd state, prints when executing the **Compile** command, but not when compiling implicitly (for example before launching the script).

### OS
These are Windows settings, not settings of this app. They are applied to all programs. This app will not restore them when uninstalling.

#### Key/mouse hook timeout
Max time in milliseconds given for hook procedures. If this time exceeded, the hook does not work well, and after several times is disabled. This setting is important for this app, because small values can make triggers and some other its features unreliable. Default 300 ms, max 1000 ms, recommended 1000 ms.

#### Disable "lock active window"
The Windows "lock active window" feature, also known as "foreground window timeout", does not allow apps to activate windows after keyboard/mouse input etc. If scripts sometimes fail to activate windows, try to check this.

#### Underline menu/dialog item access keys
Always underline keyboard shortcut characters in text of menu items and dialog controls. It makes easier to create scripts that use the keyboard to select menu items or dialog controls. If unchecked, underlines only when used the `Alt` key.


================================================
FILE: Other/DocFX/_doc/editor/Snippets.md
================================================
---
uid: snippets
---

# Snippets

Code snippets are small blocks of reusable code that you can quickly insert into your C# code. For example, the `piPrintItSnippet` inserts code `print.it();` and moves the text cursor into the `()`. Snippets appear in the completion list, together with types, functions, etc. To show the list, in the code editor start typing a snippet name or press `Ctrl+Space`. Snippets containing `${SELECTED_TEXT}` also can be used to surround selected code (toolbar button **Surround** or menu **Edit > Selection > Surround**).

In the **Snippets** window (menu **Tools > Snippets**) you can add/delete/edit/hide/unhide your snippets and hide/unhide default snippets. Right-click to add/delete. Uncheck to hide (don't show in the completion list).

A snippet can show a menu of sub-snippets. Use it to group similar snippets together, to reduce the number of snippets in the completion list. To create a menu of sub-snippets, at first create a snippet (without code or with code of the first menu item), then right-click it and add more menu items.

Snippet properties:
- **Name** - is displayed in the completion list. Also it is the text shortcut. If ends with `Surround`, the snippet is available only for surround.
- **Context** - where the snippet can be used. Read more below. If not specified, the app auto-detects it from snippet code.
- **Info** - short text displayed in the completion list item flyout (info window). Also menu item text; use `&` for keyboard shortcuts.
- **Info+** - text displayed at the bottom of the flyout.
- **Print** - text to print in the output panel when inserting the snippet. Can contain [output tags](xref:output_tags) if starts with `<>`.
- **using** - namespaces to add as `using` directives if need. Example: `System.Windows; System.Windows.Controls`.
- **Meta** - file properties to add as `/*/ meta comments /*/` if need. Example: `c A.cs; nuget -\B`.
- **\${VAR}** - `${VAR}` variable type and default name, like `Au.popupMenu,m`. When inserting the snippet, the app looks for a local variable of the specified type, and replaces `${VAR}` in snippet code with the variable name, or with the default name if not found. To see how it works, in code editor insert `menuSnippet` and then `menuItemSnippet` (it contains `${VAR}`).
- **Code** - snippet code.

Snippet code can contain fields and variables, like in [VSCode](https://code.visualstudio.com/docs/editor/userdefinedsnippets).

Example:
```csharp
for (int ${1:i} = 0; $1 < ${2:count}; $1++) {
	${SELECTED_TEXT}$0
}
```

Fields:
- `$0` - final text cursor position when the user presses `Enter` or several `Tab`.
- `${n:text}` - field with tab stop index `n` (`1`, `2` ...) and default text. After inserting the snippet code, fields can be selected with `Tab`. Default text can be a snippet variable without `{}`, like `${1:$RANDOM}`.
- `$n` or `${n}` - another instance of a `${n:text}` field. Its text is updated together. If there is no matching `${n:text}` field, it's a field without default text.

Variables:
- `${SELECTED_TEXT}` - selected text. Used only by the "surround" feature; else no text is added.
- `${RANDOM}` - random number in decimal format.
- `${RANDOM_HEX}` - random number in hexadecimal format.
- `${GUID}` - new GUID.
- `${VAR}` - local variable of type specified in the `${VAR}` field.

Escape sequences: `\$`, `\\`, `\}`.

Other VSCode snippet variables and field features are not supported.

Context specifies where in code the snippet can be used (appears in the completion list and/or surround list). Several contexts can be combined, like `Function|Type`.
- **Function** - inside function body. Also in the main script code (top-level statements).
- **Type** - inside a class, struct or interface but not inside functions. Use for snippets that insert entire methods, properties, etc.
- **Namespace** - outside of types. Use for snippets that insert entire types.
- **Attributes** - use for snippets that insert an attribute inside `[]`. This context is not auto-detected.
- **Line** - at the start of a line. For example, `#directive` snippets have context `Any|Line`.
- **Any** - anywhere.

The app loads all snippet files with names that end with `Snippets.xml` from the app settings folder in the Documents folder. You can add/delete snippets files there. You can edit them in an XML editor too.

Default snippets are read-only, but you can clone a default snippet (right click, copy, paste) and edit the clone. If both snippets are checked and have the same name, the clone will be the first in the completion list.

================================================
FILE: Other/DocFX/_doc/editor/toc.yml
================================================
- name: Application
  href: Application.md

- name: Code editor
  href: Code editor.md

- name: Scripts
  href: Scripts.md

- name: Class files, projects
  href: Class files, projects.md

- name: File properties
  href: File properties.md

- name: Menu commands
  href: Menu commands.md

- name: Settings
  href: Settings.md

- name: Command line
  href: Command line.md

- name: Creating exe programs
  href: Creating exe programs.md

- name: NuGet
  href: NuGet.md

- name: Snippets
  href: Snippets.md

- name: Icons
  href: Icons.md

- name: Debugger
  href: Debugger.md

- name: PiP session
  href: PiP session.md

- name: LA and AI
  href: LA and AI.md

- name: Portable app
  href: Portable app.md

- name: Git, backup, sync
  href: Git, backup, sync.md

- name: Compared with QM
  href: Compared with QM.md


================================================
FILE: Other/DocFX/_doc/filter.yml
================================================
apiRules:
- exclude:
      uidRegex: ^System\.Object$
      type: Type
- exclude:
      uidRegex: ^System\.ValueType$
      type: Type
- exclude:
      uidRegex: ^System\.Attribute$
      type: Type
- exclude:
      uidRegex: ^System\.Collections\.IEnumerable$
      type: Type
- exclude:
    hasAttribute:
      uid: Au.Types.NoDoc
- exclude:
      uidRegex: ^Au\.Types\.NoDoc$
      type: Type
- exclude:
      uidRegex: \.Finalize$
      type: Method


================================================
FILE: Other/DocFX/_doc/index.md
================================================
---
uid: index
---

# LibreAutomate

LibreAutomate is a C# script editor and library for automation of tasks of any kind and complexity on Windows.

Some features:
- Automate desktop and web UI using keys, mouse and API. Find and click buttons, links, images.
- Launch programs. Manage files and windows. Transfer and process text and other data.
- Hotkeys, autotext and other triggers. Auto-replace/expand text when typing. Auto-close windows. Remap keys.
- Custom toolbars that can be attached to windows or screen edges. And menus.
- Custom dialog windows of any complexity.
- The scripting language is C#. The app is a good way to learn it.
- C# code editor with intellisense. Script manager, cookbook, debugger.
- Tools for recording keyboard/mouse and selecting UI objects such as buttons, links and images.
- Also you can use .NET, libraries from NuGet, Windows API, etc.
- Can create independent exe programs and dll libraries.
- Free and open-source. The automation library can be used in other programs too.

With all the libraries and tools, code-based automation can be easier and faster than no-code RPA.

This is an example of code generated by a tool. It finds and clicks a link.

<pre style='background-color:#FFFFFF;border:#D1D7DC;border-style:solid;border-width:1px;padding-left:2px;line-height:normal;color:black;tab-size:4;font-family:"Consolas";'>
<span style='color:#0000FF'>var</span> <span style='color:#204020'>w</span> <span style='color:#0000FF'>=</span> <span style='color:#0080C0'>wnd</span><span style='color:#0000FF'>.</span><span style='color:#000000;font-weight: bold'>find</span><span style='color:#000000'>(</span><span style='color:#804000'>1</span><span style='color:#000000'>,</span> <span style='color:#A07040'>&quot;LA/QM forum - Google Chrome&quot;</span><span style='color:#000000'>,</span> <span style='color:#A07040'>&quot;Chrome_WidgetWin_1&quot;</span><span style='color:#000000'>);</span>
<span style='color:#0000FF'>var</span> <span style='color:#204020'>e</span> <span style='color:#0000FF'>=</span> <span style='color:#204020'>w</span><span style='color:#0000FF'>.</span><span style='color:#000000;font-weight: bold'>Elm</span><span style='color:#000000'>[</span><span style='color:#A07040'>&quot;web:LINK&quot;</span><span style='color:#000000'>,</span> <span style='color:#A07040'>&quot;Shared C# code&quot;</span><span style='color:#000000'>]</span><span style='color:#0000FF'>.</span><span style='color:#000000;font-weight: bold'>Find</span><span style='color:#000000'>(</span><span style='color:#804000'>1</span><span style='color:#000000'>);</span>
<span style='color:#204020'>e</span><span style='color:#0000FF'>.</span><span style='color:#000000;font-weight: bold'>Invoke</span><span style='color:#000000'>();</span>
</pre>

Another example of code created using tools. A hotkey trigger.

<pre style='background-color:#FFFFFF;border:#D1D7DC;border-style:solid;border-width:1px;padding-left:2px;line-height:normal;color:black;tab-size:4;font-family:"Consolas";'>
hk<span style='color:#000000'>[</span><span style='color:#A07040'>&quot;F7&quot;</span><span style='color:#000000'>]</span> <span style='color:#0000FF'>=</span> <span style='color:#204020'>o</span> <span style='color:#0000FF'>=&gt;</span> <span style='color:#0080C0'>script</span><span style='color:#0000FF'>.</span><span style='color:#000000;font-weight: bold'>run</span><span style='color:#000000'>(</span><span style='color:#A07040'>@&quot;\My\Youtube play random.cs&quot;</span><span style='color:#000000'>);</span>
</pre>

### Where can run
Windows 7, 8, 8.1, 10, 11.

### Download
[Download](https://www.libreautomate.com/LibreAutomateSetup.exe) v1.15.0, 2025-12-08

Or download from [GitHub](https://github.com/qgindi/LibreAutomate) Releases.

The setup program is ~40 MB. It may also install .NET 10 (~60 MB download).

The setup may be blocked by security software because it is new, not commonly downloaded, and not signed.

### Links
- [Forum](https://www.libreautomate.com/forum/)
- <a href="mailto:info@llibreautomate.com" onmousemove="if (this.dataset.mm == 1) this.href=this.href.replace(/ll/g, 'l'); this.dataset.mm = (this.dataset.mm || 0) + 1;">Email</a>
- [Source code](https://github.com/qgindi/LibreAutomate)
- [Changes](https://github.com/qgindi/LibreAutomate/blob/master/Other/DocFX/_doc/changes/)
- [Donate](https://github.com/sponsors/qgindi)
- [Privacy policy](https://www.libreautomate.com/misc/privacy-policy.html)

### Developers

Gintaras Didžgalvis, an independent software developer from Lithuania.

### Why?

This software replaces [Quick Macros](xref:qm2). The same developer.

The goal is to provide automation software for Windows with these features:
- Powerful library that includes UI automation, triggers, toolbars.
- Script editor/manager application with tools for automation.
- In scripts use the C# language and .NET libraries.
- Free and open-source.



================================================
FILE: Other/DocFX/_doc/md-styles.css
================================================

html, body {
    margin: 0;
    padding-bottom: 10px
}
/* From https://github.com/sindresorhus/github-markdown-css */

.markdown-body {
    -ms-text-size-adjust: 100%;
    -webkit-text-size-adjust: 100%;
    margin: 0;
    color: #24292f;
    background-color: #fff;
    font-family: -apple-system,BlinkMacSystemFont,"Segoe UI",Helvetica,Arial,sans-serif,"Apple Color Emoji","Segoe UI Emoji";
    font-size: 14px;
    line-height: 1.3;
    word-wrap: break-word
}

    .markdown-body .octicon {
        display: inline-block;
        fill: currentColor;
        vertical-align: text-bottom
    }

    .markdown-body h1:hover .anchor .octicon-link:before, .markdown-body h2:hover .anchor .octicon-link:before, .markdown-body h3:hover .anchor .octicon-link:before, .markdown-body h4:hover .anchor .octicon-link:before, .markdown-body h5:hover .anchor .octicon-link:before, .markdown-body h6:hover .anchor .octicon-link:before {
        width: 16px;
        height: 16px;
        content: ' ';
        display: inline-block;
        background-color: currentColor;
        -webkit-mask-image: url("data:image/svg+xml,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 16 16' version='1.1' aria-hidden='true'><path fill-rule='evenodd' d='M7.775 3.275a.75.75 0 001.06 1.06l1.25-1.25a2 2 0 112.83 2.83l-2.5 2.5a2 2 0 01-2.83 0 .75.75 0 00-1.06 1.06 3.5 3.5 0 004.95 0l2.5-2.5a3.5 3.5 0 00-4.95-4.95l-1.25 1.25zm-4.69 9.64a2 2 0 010-2.83l2.5-2.5a2 2 0 012.83 0 .75.75 0 001.06-1.06 3.5 3.5 0 00-4.95 0l-2.5 2.5a3.5 3.5 0 004.95 4.95l1.25-1.25a.75.75 0 00-1.06-1.06l-1.25 1.25a2 2 0 01-2.83 0z'></path></svg>");
        mask-image: url("data:image/svg+xml,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 16 16' version='1.1' aria-hidden='true'><path fill-rule='evenodd' d='M7.775 3.275a.75.75 0 001.06 1.06l1.25-1.25a2 2 0 112.83 2.83l-2.5 2.5a2 2 0 01-2.83 0 .75.75 0 00-1.06 1.06 3.5 3.5 0 004.95 0l2.5-2.5a3.5 3.5 0 00-4.95-4.95l-1.25 1.25zm-4.69 9.64a2 2 0 010-2.83l2.5-2.5a2 2 0 012.83 0 .75.75 0 001.06-1.06 3.5 3.5 0 00-4.95 0l-2.5 2.5a3.5 3.5 0 004.95 4.95l1.25-1.25a.75.75 0 00-1.06-1.06l-1.25 1.25a2 2 0 01-2.83 0z'></path></svg>")
    }

    .markdown-body details, .markdown-body figcaption, .markdown-body figure {
        display: block
    }

    .markdown-body summary {
        display: list-item
    }

    .markdown-body [hidden] {
        display: none !important
    }

    .markdown-body a {
        background-color: transparent;
        color: #0969da;
        text-decoration: none
    }

        .markdown-body a:active, .markdown-body a:hover {
            outline-width: 0
        }

    .markdown-body abbrMarkdown Preview {
        border-bottom: none;
        text-decoration: underline dotted
    }

    .markdown-body b, .markdown-body strong {
        font-weight: 600
    }

    .markdown-body dfn {
        font-style: italic
    }

    .markdown-body h1 {
        margin: .67em 0;
        font-weight: 600;
        padding-bottom: .3em;
        font-size: 2em;
        border-bottom: 1px solid hsla(210,18%,87%,1)
    }

    .markdown-body mark {
        background-color: #fff8c5;
        color: #24292f
    }

    .markdown-body small {
        font-size: 90%
    }

    .markdown-body sub, .markdown-body sup {
        font-size: 75%;
        line-height: 0;
        position: relative;
        vertical-align: baseline
    }

    .markdown-body sub {
        bottom: -.25em
    }

    .markdown-body sup {
        top: -.5em
    }

    .markdown-body img {
        border-style: none;
        max-width: 100%;
        box-sizing: content-box;
        background-color: #fff
    }

    .markdown-body code, .markdown-body kbd, .markdown-body pre, .markdown-body samp {
        font-family: monospace,monospace;
        font-size: 1em
    }

    .markdown-body figure {
        margin: 1em 40px
    }

    .markdown-body hr {
        box-sizing: content-box;
        overflow: hidden;
        background: 0 0;
        border-bottom: 1px solid hsla(210,18%,87%,1);
        height: .25em;
        padding: 0;
        margin: 24px 0;
        background-color: #d0d7de;
        border: 0
    }

    .markdown-body input {
        font: inherit;
        margin: 0;
        overflow: visible;
        font-family: inherit;
        font-size: inherit;
        line-height: inherit
    }

    .markdown-body [type=button], .markdown-body [type=reset], .markdown-body [type=submit] {
        -webkit-appearance: button
    }

        .markdown-body [type=button]::-moz-focus-inner, .markdown-body [type=reset]::-moz-focus-inner, .markdown-body [type=submit]::-moz-focus-inner {
            border-style: none;
            padding: 0
        }

        .markdown-body [type=button]:-moz-focusring, .markdown-body [type=reset]:-moz-focusring, .markdown-body [type=submit]:-moz-focusring {
            outline: 1px dotted ButtonText
        }

    .markdown-body [type=checkbox], .markdown-body [type=radio] {
        box-sizing: border-box;
        padding: 0
    }

    .markdown-body [type=number]::-webkit-inner-spin-button, .markdown-body [type=number]::-webkit-outer-spin-button {
        height: auto
    }

    .markdown-body [type=search] {
        -webkit-appearance: textfield;
        outline-offset: -2px
    }

        .markdown-body [type=search]::-webkit-search-cancel-button, .markdown-body [type=search]::-webkit-search-decoration {
            -webkit-appearance: none
        }

    .markdown-body ::-webkit-input-placeholder {
        color: inherit;
        opacity: .54
    }

    .markdown-body ::-webkit-file-upload-button {
        -webkit-appearance: button;
        font: inherit
    }

    .markdown-body a:hover {
        text-decoration: underline
    }

    .markdown-body hr:before {
        display: table;
        content: ""
    }

    .markdown-body hr:after {
        display: table;
        clear: both;
        content: ""
    }

    .markdown-body table {
        border-spacing: 0;
        border-collapse: collapse;
        display: block;
        width: max-content;
        max-width: 100%;
        overflow: auto
    }

    .markdown-body td, .markdown-body th {
        padding: 0
    }

    .markdown-body details summary {
        cursor: pointer
    }

    .markdown-body details:not([open]) > *:not(summary) {
        display: none !important
    }

    .markdown-body kbd {
        display: inline-block;
        padding: 3px 5px;
        font: 11px ui-monospace,SFMono-Regular,SF Mono,Menlo,Consolas,Liberation Mono,monospace;
        line-height: 10px;
        color: #24292f;
        vertical-align: middle;
        background-color: #f6f8fa;
        border: solid 1px rgba(175,184,193,.2);
        border-bottom-color: rgba(175,184,193,.2);
        border-radius: 6px;
        box-shadow: inset 0 -1px 0 rgba(175,184,193,.2)
    }

    .markdown-body h1, .markdown-body h2, .markdown-body h3, .markdown-body h4, .markdown-body h5, .markdown-body h6 {
        margin-top: 24px;
        margin-bottom: 16px;
        font-weight: 600;
        line-height: 1.25
    }

    .markdown-body h2 {
        font-weight: 600;
        padding-bottom: .3em;
        font-size: 1.5em;
        border-bottom: 1px solid hsla(210,18%,87%,1)
    }

    .markdown-body h3 {
        font-weight: 600;
        font-size: 1.25em
    }

    .markdown-body h4 {
        font-weight: 600;
        font-size: 1em
    }

    .markdown-body h5 {
        font-weight: 600;
        font-size: .875em
    }

    .markdown-body h6 {
        font-weight: 600;
        font-size: .85em;
        color: #57606a
    }

    .markdown-body p {
        margin-top: 0;
        margin-bottom: 10px
    }

    .markdown-body blockquote {
        margin: 0;
        padding: 0 1em;
        color: #57606a;
        border-left: .25em solid #d0d7de
    }

    .markdown-body ul {
        list-style: disc
    }

    .markdown-body ul, .markdown-body ol {
        margin-top: 0;
        margin-bottom: 0;
        padding-left: 2em
    }

        .markdown-body ol ol, .markdown-body ul ol {
            list-style-type: lower-roman
        }

            .markdown-body ul ul ol, .markdown-body ul ol ol, .markdown-body ol ul ol, .markdown-body ol ol ol {
                list-style-type: lower-alpha
            }

    .markdown-body dd {
        margin-left: 0
    }

    .markdown-body tt, .markdown-body code {
        font-family: ui-monospace,SFMono-Regular,SF Mono,Menlo,Consolas,Liberation Mono,monospace;
        font-size: 12px
    }

    .markdown-body pre {
        margin-top: 0;
        margin-bottom: 0;
        font-family: ui-monospace,SFMono-Regular,SF Mono,Menlo,Consolas,Liberation Mono,monospace;
        font-size: 12px;
        word-wrap: normal
    }

    .markdown-body .octicon {
        display: inline-block;
        overflow: visible !important;
        vertical-align: text-bottom;
        fill: currentColor
    }

    .markdown-body ::placeholder {
        color: #6e7781;
        opacity: 1
    }

    .markdown-body input::-webkit-outer-spin-button, .markdown-body input::-webkit-inner-spin-button {
        margin: 0;
        -webkit-appearance: none;
        appearance: none
    }

    .markdown-body .pl-c {
        color: #6e7781
    }

    .markdown-body .pl-c1, .markdown-body .pl-s .pl-v {
        color: #0550ae
    }

    .markdown-body .pl-e, .markdown-body .pl-en {
        color: #8250df
    }

    .markdown-body .pl-smi, .markdown-body .pl-s .pl-s1 {
        color: #24292f
    }

    .markdown-body .pl-ent {
        color: #116329
    }

    .markdown-body .pl-k {
        color: #cf222e
    }

    .markdown-body .pl-s, .markdown-body .pl-pds, .markdown-body .pl-s .pl-pse .pl-s1, .markdown-body .pl-sr, .markdown-body .pl-sr .pl-cce, .markdown-body .pl-sr .pl-sre, .markdown-body .pl-sr .pl-sra {
        color: #0a3069
    }

    .markdown-body .pl-v, .markdown-body .pl-smw {
        color: #953800
    }

    .markdown-body .pl-bu {
        color: #82071e
    }

    .markdown-body .pl-ii {
        color: #f6f8fa;
        background-color: #82071e
    }

    .markdown-body .pl-c2 {
        color: #f6f8fa;
        background-color: #cf222e
    }

    .markdown-body .pl-sr .pl-cce {
        font-weight: 700;
        color: #116329
    }

    .markdown-body .pl-ml {
        color: #3b2300
    }

    .markdown-body .pl-mh, .markdown-body .pl-mh .pl-en, .markdown-body .pl-ms {
        font-weight: 700;
        color: #0550ae
    }

    .markdown-body .pl-mi {
        font-style: italic;
        color: #24292f
    }

    .markdown-body .pl-mb {
        font-weight: 700;
        color: #24292f
    }

    .markdown-body .pl-md {
        color: #82071e;
        background-color: #ffebe9
    }

    .markdown-body .pl-mi1 {
        color: #116329;
        background-color: #dafbe1
    }

    .markdown-body .pl-mc {
        color: #953800;
        background-color: #ffd8b5
    }

    .markdown-body .pl-mi2 {
        color: #eaeef2;
        background-color: #0550ae
    }

    .markdown-body .pl-mdr {
        font-weight: 700;
        color: #8250df
    }

    .markdown-body .pl-ba {
        color: #57606a
    }

    .markdown-body .pl-sg {
        color: #8c959f
    }

    .markdown-body .pl-corl {
        text-decoration: underline;
        color: #0a3069
    }

    .markdown-body [data-catalyst] {
        display: block
    }

    .markdown-body g-emoji {
        font-family: "Apple Color Emoji","Segoe UI Emoji","Segoe UI Symbol";
        font-size: 1em;
        font-style: normal !important;
        font-weight: 400;
        line-height: 1;
        vertical-align: -.075em
    }

        .markdown-body g-emoji img {
            width: 1em;
            height: 1em
        }

    .markdown-body:before {
        display: table;
        content: ""
    }

    .markdown-body:after {
        display: table;
        clear: both;
        content: ""
    }

    .markdown-body > *:first-child {
        margin-top: 0 !important
    }

    .markdown-body > *:last-child {
        margin-bottom: 0 !important
    }

    .markdown-body a:not([href]) {
        color: inherit;
        text-decoration: none
    }

    .markdown-body .absent {
        color: #cf222e
    }

    .markdown-body .anchor {
        float: left;
        padding-right: 4px;
        margin-left: -20px;
        line-height: 1
    }

        .markdown-body .anchor:focus {
            outline: none
        }

    .markdown-body p, .markdown-body blockquote, .markdown-body ul, .markdown-body ol, .markdown-body dl, .markdown-body table, .markdown-body pre, .markdown-body details {
        margin-top: 0;
        margin-bottom: 16px
    }

        .markdown-body blockquote > :first-child {
            margin-top: 0
        }

        .markdown-body blockquote > :last-child {
            margin-bottom: 0
        }

    .markdown-body sup > a:before {
        content: "["
    }

    .markdown-body sup > a:after {
        content: "]"
    }

    .markdown-body h1 .octicon-link, .markdown-body h2 .octicon-link, .markdown-body h3 .octicon-link, .markdown-body h4 .octicon-link, .markdown-body h5 .octicon-link, .markdown-body h6 .octicon-link {
        color: #24292f;
        vertical-align: middle;
        visibility: hidden
    }

    .markdown-body h1:hover .anchor, .markdown-body h2:hover .anchor, .markdown-body h3:hover .anchor, .markdown-body h4:hover .anchor, .markdown-body h5:hover .anchor, .markdown-body h6:hover .anchor {
        text-decoration: none
    }

        .markdown-body h1:hover .anchor .octicon-link, .markdown-body h2:hover .anchor .octicon-link, .markdown-body h3:hover .anchor .octicon-link, .markdown-body h4:hover .anchor .octicon-link, .markdown-body h5:hover .anchor .octicon-link, .markdown-body h6:hover .anchor .octicon-link {
            visibility: visible
        }

    .markdown-body h1 tt, .markdown-body h1 code, .markdown-body h2 tt, .markdown-body h2 code, .markdown-body h3 tt, .markdown-body h3 code, .markdown-body h4 tt, .markdown-body h4 code, .markdown-body h5 tt, .markdown-body h5 code, .markdown-body h6 tt, .markdown-body h6 code {
        padding: 0 .2em;
        font-size: inherit
    }

    .markdown-body ul.no-list, .markdown-body ol.no-list {
        padding: 0;
        list-style-type: none
    }

    .markdown-body ol[type="1"] {
        list-style-type: decimal
    }

    .markdown-body ol[type=a] {
        list-style-type: lower-alpha
    }

    .markdown-body ol[type=i] {
        list-style-type: lower-roman
    }

    .markdown-body div > ol:not([type]) {
        list-style-type: decimal
    }

    .markdown-body ul ul, .markdown-body ul ol, .markdown-body ol ol, .markdown-body ol ul {
        margin-top: 0;
        margin-bottom: 0
    }

    .markdown-body li > p {
        margin-top: 16px
    }

    .markdown-body li + li {
        margin-top: .25em
    }

    .markdown-body dl {
        padding: 0
    }

        .markdown-body dl dt {
            padding: 0;
            margin-top: 16px;
            font-size: 1em;
            font-style: italic;
            font-weight: 600
        }

        .markdown-body dl dd {
            padding: 0 16px;
            margin-bottom: 16px
        }

    .markdown-body table th {
        font-weight: 600
    }

    .markdown-body table th, .markdown-body table td {
        padding: 6px 13px;
        border: 1px solid #d0d7de
    }

    .markdown-body table tr {
        background-color: #fff;
        border-top: 1px solid hsla(210,18%,87%,1)
    }

        .markdown-body table tr:nth-child(2n) {
            background-color: #f6f8fa
        }

    .markdown-body table img {
        background-color: transparent
    }

    .markdown-body img[align=right] {
        padding-left: 20px
    }

    .markdown-body img[align=left] {
        padding-right: 20px
    }

    .markdown-body .emoji {
        max-width: none;
        vertical-align: text-top;
        background-color: transparent
    }

    .markdown-body span.frame {
        display: block;
        overflow: hidden
    }

        .markdown-body span.frame > span {
            display: block;
            float: left;
            width: auto;
            padding: 7px;
            margin: 13px 0 0;
            overflow: hidden;
            border: 1px solid #d0d7de
        }

        .markdown-body span.frame span img {
            display: block;
            float: left
        }

        .markdown-body span.frame span span {
            display: block;
            padding: 5px 0 0;
            clear: both;
            color: #24292f
        }

    .markdown-body span.align-center {
        display: block;
        overflow: hidden;
        clear: both
    }

        .markdown-body span.align-center > span {
            display: block;
            margin: 13px auto 0;
            overflow: hidden;
            text-align: center
        }

        .markdown-body span.align-center span img {
            margin: 0 auto;
            text-align: center
        }

    .markdown-body span.align-right {
        display: block;
        overflow: hidden;
        clear: both
    }

        .markdown-body span.align-right > span {
            display: block;
            margin: 13px 0 0;
            overflow: hidden;
            text-align: right
        }

        .markdown-body span.align-right span img {
            margin: 0;
            text-align: right
        }

    .markdown-body span.float-left {
        display: block;
        float: left;
        margin-right: 13px;
        overflow: hidden
    }

        .markdown-body span.float-left span {
            margin: 13px 0 0
        }

    .markdown-body span.float-right {
        display: block;
        float: right;
        margin-left: 13px;
        overflow: hidden
    }

        .markdown-body span.float-right > span {
            display: block;
            margin: 13px auto 0;
            overflow: hidden;
            text-align: right
        }

    .markdown-body code, .markdown-body tt {
        padding: .2em .4em;
        margin: 0;
        font-size: 85%;
        background-color: rgba(175,184,193,.2);
        border-radius: 6px
    }

        .markdown-body code br, .markdown-body tt br {
            display: none
        }

    .markdown-body del code {
        text-decoration: inherit
    }

    .markdown-body pre code {
        font-size: 100%
    }

    .markdown-body pre > code {
        padding: 0;
        margin: 0;
        word-break: normal;
        white-space: pre;
        background: 0 0;
        border: 0
    }

    .markdown-body .highlight {
        margin-bottom: 16px
    }

        .markdown-body .highlight pre {
            margin-bottom: 0;
            word-break: normal
        }

        .markdown-body .highlight pre, .markdown-body pre {
            padding: 16px;
            overflow: auto;
            font-size: 85%;
            line-height: 1.45;
            background-color: #f6f8fa;
            border-radius: 6px
        }

            .markdown-body pre code, .markdown-body pre tt {
                display: inline;
                max-width: auto;
                padding: 0;
                margin: 0;
                overflow: visible;
                line-height: inherit;
                word-wrap: normal;
                background-color: transparent;
                border: 0
            }

    .markdown-body .csv-data td, .markdown-body .csv-data th {
        padding: 5px;
        overflow: hidden;
        font-size: 12px;
        line-height: 1;
        text-align: left;
        white-space: nowrap
    }

    .markdown-body .csv-data .blob-num {
        padding: 10px 8px 9px;
        text-align: right;
        background: #fff;
        border: 0
    }

    .markdown-body .csv-data tr {
        border-top: 0
    }

    .markdown-body .csv-data th {
        font-weight: 600;
        background: #f6f8fa;
        border-top: 0
    }

    .markdown-body .footnotes {
        font-size: 12px;
        color: #57606a;
        border-top: 1px solid #d0d7de
    }

        .markdown-body .footnotes ol {
            padding-left: 16px
        }

        .markdown-body .footnotes li {
            position: relative
        }

            .markdown-body .footnotes li:target:before {
                position: absolute;
                top: -8px;
                right: -8px;
                bottom: -8px;
                left: -24px;
                pointer-events: none;
                content: "";
                border: 2px solid #0969da;
                border-radius: 6px
            }

            .markdown-body .footnotes li:target {
                color: #24292f
            }

        .markdown-body .footnotes .data-footnote-backref g-emoji {
            font-family: monospace
        }

    .markdown-body .task-list-item {
        list-style-type: none
    }

        .markdown-body .task-list-item label {
            font-weight: 400
        }

        .markdown-body .task-list-item.enabled label {
            cursor: pointer
        }

        .markdown-body .task-list-item + .task-list-item {
            margin-top: 3px
        }

        .markdown-body .task-list-item .handle {
            display: none
        }

    .markdown-body .task-list-item-checkbox {
        margin: 0 .2em .25em -1.6em;
        vertical-align: middle
    }

    .markdown-body .contains-task-list:dir(rtl) .task-list-item-checkbox {
        margin: 0 -1.6em .25em .2em
    }

    .markdown-body ::-webkit-calendar-picker-indicator {
        filter: invert(50%)
    }
/* PrismJS 1.25.0
https://prismjs.com/download.html#themes=prism&languages=markup+css+clike+javascript+aspnet+basic+c+csharp+cpp+clojure+dart+docker+fsharp+go+graphql+java+json+kotlin+markdown+markup-templating+perl+php+powershell+protobuf+python+qsharp+r+cshtml+ruby+rust+scss+sql+typescript+vbnet+visual-basic+yaml */
code[class*=language-], pre[class*=language-] {
    color: #000;
    background: 0 0;
    text-shadow: 0 1px #fff;
    font-family: Consolas,Monaco,'Andale Mono','Ubuntu Mono',monospace;
    font-size: 1em;
    text-align: left;
    white-space: pre;
    word-spacing: normal;
    word-break: normal;
    word-wrap: normal;
    line-height: 1.5;
    -moz-tab-size: 4;
    -o-tab-size: 4;
    tab-size: 4;
    -webkit-hyphens: none;
    -moz-hyphens: none;
    -ms-hyphens: none;
    hyphens: none
}

    code[class*=language-] ::-moz-selection, code[class*=language-]::-moz-selection, pre[class*=language-] ::-moz-selection, pre[class*=language-]::-moz-selection {
        text-shadow: none;
        background: #b3d4fc
    }

    code[class*=language-] ::selection, code[class*=language-]::selection, pre[class*=language-] ::selection, pre[class*=language-]::selection {
        text-shadow: none;
        background: #b3d4fc
    }

@media print {
    code[class*=language-], pre[class*=language-] {
        text-shadow: none
    }
}

pre[class*=language-] {
    padding: 1em;
    margin: .5em 0;
    overflow: auto
}

:not(pre) > code[class*=language-], pre[class*=language-] {
    background: #f5f2f0
}

:not(pre) > code[class*=language-] {
    padding: .1em;
    border-radius: .3em;
    white-space: normal
}

.token.cdata, .token.comment, .token.doctype, .token.prolog {
    color: #708090
}

.token.punctuation {
    color: #999
}

.token.namespace {
    opacity: .7
}

.token.boolean, .token.constant, .token.deleted, .token.number, .token.property, .token.symbol, .token.tag {
    color: #905
}

.token.attr-name, .token.builtin, .token.char, .token.inserted, .token.selector, .token.string {
    color: #690
}

.language-css .token.string, .style .token.string, .token.entity, .token.operator, .token.url {
    color: #9a6e3a;
    background: hsla(0,0%,100%,.5)
}

.token.atrule, .token.attr-value, .token.keyword {
    color: #07a
}

.token.class-name, .token.function {
    color: #dd4a68
}

.token.important, .token.regex, .token.variable {
    color: #e90
}

.token.bold, .token.important {
    font-weight: 700
}

.token.italic {
    font-style: italic
}

.token.entity {
    cursor: help
}


================================================
FILE: Other/DocFX/_doc/misc/privacy-policy.md
================================================
# Privacy Policy

This Privacy Policy explains how libreautomate.com ("we", "us", "our") collects, uses, and protects your personal information.

### Information We Collect

#### Forum accounts
When you create an account on our forum, we collect:
- Username
- Email address
- Password (stored securely)
- If you choose to register or log in through a social provider (for example, Google), we also receive your name and email address from that provider

#### Cookies
We use cookies to:
- Keep you signed in to your forum account
- Remember your forum settings
- Maintain forum session security

### How We Use Information

We use collected data to:
- Provide access to the forum
- Maintain user accounts and preferences on the forum
- Notify users about new posts on the forum, if they have opted in

### Sharing of Information

The website is hosted by Hostinger and uses the MyBB forum software to operate the forum. These services may have technical access to data but do not use it for their own purposes.

We do not share personal data with third parties for marketing purposes.

If required by law, we may disclose information to comply with legal obligations or lawful requests from authorities.

### Data Retention and Your Rights

We retain forum account information as long as your account is active.
You can request deletion of your account and associated personal data at any time by contacting us.
You can edit your personal information in the forum's User Control Panel.

Depending on your location, you may have additional rights under data-protection laws, such as the right to access your data, request correction, or withdraw consent.

### Security

We take reasonable measures to protect personal data from unauthorized access, alteration, disclosure, or destruction.

### Software Downloads

The software available for download on this website does not collect any personal information from users.

### Changes to This Privacy Policy

We may update this Privacy Policy from time to time. The latest version will always be available on this page.

Last updated: 2025-10-15

### Contact

For any questions regarding this Privacy Policy or any requests regarding your personal data, please contact us at 
[qmgindi@gmail.com](mailto:qmgindi@gmail.com).

The website is owned and operated by Gintaras Didžgalvis.


================================================
FILE: Other/DocFX/_doc/template1/layout/_master.tmpl
================================================
{{!Copyright (c) Microsoft. All rights reserved. Licensed under the MIT license. See LICENSE file in the project root for full license information.}}
{{!include(/^styles/.*/)}}
{{!include(/^fonts/.*/)}}
{{!include(favicon.ico)}}
{{!include(logo.svg)}}
{{!include(search-stopwords.json)}}
<!DOCTYPE html>
<!--[if IE]><![endif]-->
<html>
  {{>partials/head}}
  <body data-spy="scroll" data-target="#affix" data-offset="80">
    <a name="top"></a>
    <div id="wrapper">
      <header>
        {{^_disableNavbar}}
        {{>partials/navbar}}
        {{/_disableNavbar}}
        {{^_disableBreadcrumb}}
        {{>partials/breadcrumb}}
        {{/_disableBreadcrumb}}
      </header>
      {{#_enableSearch}}
      <div class="container body-content">
        {{>partials/searchResults}}
      </div>
      {{/_enableSearch}}
      <div role="main" class="container-fluid body-content hide-when-search">
      {{^_disableToc}}
        {{>partials/toc}}
        <div class="article row grid-right">
      {{/_disableToc}}
      {{#_disableToc}}
        <div class="article row grid">
        {{/_disableToc}}
          {{#_disableAffix}}
          <div class="col-md-12">
          {{/_disableAffix}}
          {{^_disableAffix}}
          <div class="col-md-10">
          {{/_disableAffix}}
            <article class="content wrap" id="_content" data-uid="{{uid}}">
                {{!body}}
            </article>
          </div>
          {{^_disableAffix}}
          {{>partials/affix}}
          {{/_disableAffix}}
        </div>
      </div>
      {{^_disableFooter}}
      {{>partials/footer}}
      {{/_disableFooter}}
    </div>
    {{>partials/scripts}}
  </body>
</html>


================================================
FILE: Other/DocFX/_doc/template1/mod.txt
================================================
Using 3 templates:
template1 - modified "mathew" template. It is included in the DocFX "Templates" webpage. Downloaded from github. Mostly changes style.
template2 - styles to change in member pages. Copied from mathew and modified.

Currently not using the affix. It is the dynamic links at the right.

Note: after copy/paste in VS, undo autoformatting done by VS. It damages <pre>.

Unsuccessfully tried to create a plugin.
	Followed the tutorial, created the plugin, copied the output files to the plugins folder of template1.
	Error when DocFX runs: Error:[ImportPlugins]Error when get composition container: Unable to load one or more of the requested types. Retrieve the LoaderExceptions property for more information., loader exceptions: Could not load file



================================================
FILE: Other/DocFX/_doc/template1/partials/class.header.tmpl.partial
================================================
<h1 id="{{id}}" data-uid="{{uid}}" class="text-break">{{>partials/title}}</h1>

<div class="markdown level0 summary">{{{summary}}}</div>
<div class="markdown level0 conceptual">{{{conceptual}}}</div>

<div class="codewrapper">
  <pre><code class="lang-{{_lang}} hljs">{{syntax.content.0.value}}</code></pre>
</div>

{{#syntax.typeParameters.0}}
<h5 class="typeParameters">{{__global.typeParameters}}</h5>
<table class="table table-bordered table-condensed">
  <thead>
    <tr>
      <th>{{__global.name}}</th>
      <th>{{__global.description}}</th>
    </tr>
  </thead>
  <tbody>
{{/syntax.typeParameters.0}}
{{#syntax.typeParameters}}
    <tr>
      <td><span class="parametername">{{{id}}}</span></td>
      <td>{{{description}}}</td>
    </tr>
{{/syntax.typeParameters}}
{{#syntax.typeParameters.0}}
  </tbody>
</table>
{{/syntax.typeParameters.0}}

{{#remarks}}
<h5 id="{{id}}_remarks"><strong>{{__global.remarks}}</strong></h5>
<div class="markdown level0 remarks">{{{remarks}}}</div>
{{/remarks}}
{{#example.0}}
<h5 id="{{id}}_examples"><strong>{{__global.examples}}</strong></h5>
{{/example.0}}
{{#example}}
{{{.}}}
{{/example}}

<hr/>

<h6><strong>{{__global.namespace}}</strong>: {{{namespace.specName.0.value}}}</h6>
<h6><strong>{{__global.assembly}}</strong>: {{assemblies.0}}.dll</h6>

{{#inClass}}
<div class="inheritance">
  <h5>{{__global.inheritance}}</h5>
  {{#inheritance}}
  <div class="level{{index}}">{{{specName.0.value}}}</div>
  {{/inheritance}}
  <div class="level{{level}}"><span class="xref">{{name.0.value}}</span></div>
  {{#derivedClasses}}
    <div class="level{{index}}">{{{specName.0.value}}}</div>
  {{/derivedClasses}}
</div>

{{#inheritedMembers.0}}
<div class="inheritedMembers">
  <h5>{{__global.inheritedMembers}}</h5>
{{/inheritedMembers.0}}
{{#inheritedMembers}}
  <div>
  {{#definition}}
    <xref uid="{{definition}}" text="{{nameWithType.0.value}}" alt="{{fullName.0.value}}"/>
  {{/definition}}
  {{^definition}}
    <xref uid="{{uid}}" text="{{nameWithType.0.value}}" alt="{{fullName.0.value}}"/>
  {{/definition}}
  </div>
{{/inheritedMembers}}
{{#inheritedMembers.0}}
</div>
{{/inheritedMembers.0}}
{{/inClass}}


================================================
FILE: Other/DocFX/_doc/template1/partials/footer.tmpl.partial
================================================


================================================
FILE: Other/DocFX/_doc/template1/partials/logo.tmpl.partial
================================================


================================================
FILE: Other/DocFX/_doc/template1/partials/namespace.tmpl.partial
================================================
{{!Copyright (c) Microsoft. All rights reserved. Licensed under the MIT license. See LICENSE file in the project root for full license information.}}

<h1 id="{{id}}" data-uid="{{uid}}" class="text-break">{{>partials/title}}</h1>
<div class="markdown level0 summary">{{{summary}}}</div>
<div class="markdown level0 conceptual">{{{conceptual}}}</div>
<div class="markdown level0 remarks">{{{remarks}}}</div>
{{#children}}
  <h2 id="{{id}}">{{>partials/namespaceSubtitle}}</h2>
  {{#children}}
    <h5 class="ns"><xref uid="{{uid}}" altProperty="fullName" displayProperty="name"/></h5>
    <section>{{{summary}}}</section>
  {{/children}}
{{/children}}


================================================
FILE: Other/DocFX/_doc/template1/partials/navbar.tmpl.partial
================================================
<nav id="autocollapse" class="navbar navbar-inverse ng-scope" role="navigation">
	<div class="container-fluid">
		<div class="navbar-header">
			<button type="button" class="navbar-toggle" data-toggle="collapse" data-target="#navbar">
				<span class="sr-only">Toggle navigation</span>
				<span class="icon-bar"></span>
				<span class="icon-bar"></span>
				<span class="icon-bar"></span>
			</button>
			{{>partials/logo}}
		</div>
		<div class="collapse navbar-collapse" id="navbar">
		</div>
	</div>
</nav>


================================================
FILE: Other/DocFX/_doc/template1/styles/main.css
================================================
/* Clickability fix for selector on sm devices */
@media (min-width: 768px) and (max-width: 991px) {
  article h1:first-of-type:before {
    height: 0;
    margin-top: 0;
  }  
}

.sidetoc,
body .toc,
.sidefilter,
.sidetoggle { 
  background-color: #e5ead3; 
}
.toc .nav > li > a {
    color: #444;
}

.sidenav,
.toc-toggle {
  padding: 0;
}

article h4 {
  border-bottom: none;
}

@media (min-width: 768px) {
  .sidetoc, .sidefilter {
    margin-left: -15px;
  }
}

@media (max-width: 767px) {
  .navbar-collapse {
    text-align: center !important;
  }

  .navbar-collapse li .active {
    border-radius: 20px;
  }
}


/* Navbar Hamburger
   ------------------------------------------------------- */
.icon-bar {
    transition: 0.4s;
}

/* Rotate first bar */
.change .icon-bar:nth-of-type(2) {
    transform: rotate(-45deg) translate(-4px, 5px) ;
}

/* Fade out the second bar */
.change .icon-bar:nth-of-type(3) {
    opacity: 0;
}

/* Rotate last bar */
.change .icon-bar:nth-of-type(4) {
    transform: rotate(45deg) translate(-4px, -5px) ;
}


/* Au
   ------------------------------------------------------- */

.sidefilter,
.sidetoggle {
    top: 40px;
}
.sidetoc {
    top: 94px;
}
.sidetoc.shiftup {
    bottom: 0;
}
.toc {
    margin-bottom: 10px;
}

.toc-filter > .filter-icon {
    top: 6px;
}

.toc-filter > .clear-icon {
    top: 6px;
}
.toc-filter {
    border-radius: 2px;
    padding: 0px 2px 2px 2px;
    min-height: 24px;
}

.article {
    margin-top: 40px;
    margin-bottom: 40px;
}
.article.grid-right {
    margin-left: 260px;
	margin-right: 0px;
}
@media only screen and (max-width: 768px) {
  .article.grid-right {
    margin-top: 0 !important;
    margin-bottom: 20px;
    margin-left: 0;
  }
}

article h1 {
    margin-top: 14px;
    margin-bottom: 16px;
	border-bottom: 1px solid #eaecef;
	padding-bottom: 8px;
    font-size: 2em;
    font-weight: 600;
}

article h2 {
    font-size: 1.5em;
    font-weight: 600;
	border-bottom: 1px solid #eaecef;
	padding-bottom: 4px;
}

article h3 {
    font-size: 1.5em;
    font-weight: 600;
}

article h4 {
    font-size: 1.2em;
    font-weight: bold;
}

article h5 {
    border-bottom: none;
    font-weight: bold;
    margin-top: 14px;
    margin-bottom: 7px;
}

/* See namespace.tmpl.partial. Initially the links were <h3>, but does not look good after changing <h3> style. */
h5.ns {
    margin-top: 10px;
    margin-bottom: 2px;
}

/* See collection.tmpl.partial. Before each overload we insert a tall <hr> and <h2>Overload</h2>, but hide the first. */
hr.overload {
	margin-top: 50px;
}
hr.overload:first-of-type,h2.overload:first-of-type {
	display: none;
}

td p { margin-bottom: 10px; }

td > p:last-child, td > div > p:last-child, td > ul:last-child, td > ol:last-child, td > div > ul:last-child, td > div > ol:last-child {
  margin-bottom: 0;
}

/* in 2-column tables let the first column have width 25% */
tr td:first-child+td:last-child {
	width: 75%;
}

/* break adjacent lines like in XML comments, but collapse multiple spaces and tabs (eg indentation made by XML formatting) */
p { white-space: pre-line; }

pre {
    white-space: pre;
	tab-size: 4;
}

div.codewrapper pre {
    background-color: #ffffe7;
    white-space: pre-line;
    word-wrap: normal;
    word-break: normal;
}

code {
    color: #208020;
    background-color: #f8f8f8;
    border: 1px solid #eee;
    border-radius: 2px;
    padding: 1px 4px;
}
pre code {
    color: inherit;
    background-color: transparent;
    border: none;
    border-radius: 0;
    padding: 0;
    white-space: inherit;
}

span.parametername {
    font-style: italic;
    font-weight: bold;
}

.toc ul {
    font-size: inherit;
}
.nav.level3 {
    margin-left: 14px;
}

.navbar-inverse {
    background-color: #175499;
    border-color: #083868;
}
.navbar {
    min-height: 40px;
}
.navbar-nav > li > a {
    padding-top: 10px;
    padding-bottom: 10px;
}
.navbar-inverse .navbar-nav > li > a, .navbar-inverse .navbar-text {
    color: #e0f0e8;
    font-size: 16px;
}
.navbar-inverse .navbar-nav > .active > a, .navbar-inverse .navbar-nav > .active > a:focus, .navbar-inverse .navbar-nav > .active > a:hover {
    color: #fff;
    background-color: #3770b1;
}
.navbar-inverse .navbar-toggle:focus {
    background-color: inherit;
}
.navbar-inverse .navbar-toggle:hover {
    background-color: #3770b1;
}
@media (min-width:768px){
.navbar-form {
    margin-bottom: 0;
}
}
@media (max-width:767px){
.navbar-form {
    border-top: 0;
    margin-top: 0;
}
}

.googleButton {
    padding: 1px 10px 2px 10px;
    background-color: #3770b1;
    border: 1px solid #333;
    border-radius: 4px;
    color: #e0f0e8;
}
.googleButton:hover {
    color: #fff;
    background-color: #4784cb;
    border-color: #333;
}
.googleEdit {
    border:none;
    border-radius: 2px;
	padding-bottom: 2px;
	min-height: 23px;
}

.alert {
    padding: 10px;
    margin-bottom: 10px;
}

/* remove table striping */
.table-striped>tbody>tr:nth-of-type(odd){background-color:#ffffff}

.collapse.in, .collapsing {
    text-align: left;
}

.table-bordered > thead > tr > th {
  background-color: #f0f0f0;
  border-bottom-width: 1px;
}

/* after upgrading DocFX, don't know who modifies default docfx.css and makes Parameters etc gray. Change it. */
.decalaration, .fieldValue, .parameters, .returns, .exceptions {
    color: #333;
}

/* Summary of classes. Was 2em. */
.level0.summary {
    margin: 1em 0 1em 0;
}


================================================
FILE: Other/DocFX/_doc/template1/styles/main.js
================================================
// Anchor scroll workaround.
$(document).ready(function () {
    if (window.location.hash) {
        $('html, body').animate({
            scrollTop: $(window.location.hash).offset().top - 50
        }, 1);
    }
});

// Navbar Hamburger
$(function () {
    $(".navbar-toggle").click(function () {
        $(this).toggleClass("change");
    })
})


================================================
FILE: Other/DocFX/_doc/template2/partials/collection.tmpl.partial
================================================
{{!Copyright (c) Microsoft. All rights reserved. Licensed under the MIT license. See LICENSE file in the project root for full license information.}}

<h1 id="{{id}}" data-uid="{{uid}}">{{>partials/title}}</h1>

{{#children}}
{{#children}}
<hr class="overload"/>
<h2 class="overload" id="{{id}}" data-uid="{{uid}}">Overload</h2>
{{^_disableContribution}}
{{#docurl}}
<span class="small pull-right mobile-hide">
  <span class="divider">|</span>
  <a href="{{docurl}}">{{__global.improveThisDoc}}</a>
</span>{{/docurl}}
{{#sourceurl}}
<span class="small pull-right mobile-hide">
  <a href="{{sourceurl}}">{{__global.viewSource}}</a>
</span>{{/sourceurl}}
{{/_disableContribution}}

<div class="markdown level1 summary">{{{summary}}}</div>
<div class="markdown level1 conceptual">{{{conceptual}}}</div>

<div class="codewrapper">
  <pre><code class="lang-{{_lang}} hljs">{{syntax.content.0.value}}</code></pre>
</div>

{{#syntax}}
{{#parameters.0}}
<h5 class="parameters">{{__global.parameters}}</h5>
<table>
{{/parameters.0}}
{{#parameters}}
  <tr>
    <td>
      <span class="parametername">{{{id}}}</span>&nbsp;&nbsp;({{{type.specName.0.value}}}</span>)
      <div>{{{description}}}</div>
    </td>
  </tr>
{{/parameters}}
{{#parameters.0}}
</table>
{{/parameters.0}}

{{#return}}
<h5 class="returns">{{__global.returns}}</h5>
<table>
  <tr>
    <td>
      {{{type.specName.0.value}}}
      <div>{{{description}}}</div>
    </td>
  </tr>
</table>
{{/return}}

{{#exceptions.0}}
<h5 class="exceptions">{{__global.exceptions}}</h5>
<table>
{{/exceptions.0}}
{{#exceptions}}
  <tr>
    <td>
      {{{type.specName.0.value}}}
      <div>{{{description}}}</div>
    </td>
  </tr>
{{/exceptions}}
{{#exceptions.0}}
</table>
{{/exceptions.0}}

{{#typeParameters.0}}
<h5 class="typeParameters">{{__global.typeParameters}}</h5>
<table>
{{/typeParameters.0}}
{{#typeParameters}}
  <tr>
    <td>
      <span class="parametername">{{{id}}}</span>
      <div>{{{description}}}</div>
    </td>
  </tr>
{{/typeParameters}}
{{#typeParameters.0}}
</table>
{{/typeParameters.0}}

{{#fieldValue}}
<h5 class="fieldValue">{{__global.fieldValue}}</h5>
<table>
  <tr>
    <td>
      {{{type.specName.0.value}}}
      <div>{{{description}}}</div>
    </td>
  </tr>
</table>
{{/fieldValue}}

{{#propertyValue}}
<h5 class="propertyValue">{{__global.propertyValue}}</h5>
<table>
  <tr>
    <td>
      {{{type.specName.0.value}}}
      <div>{{{description}}}</div>
    </td>
  </tr>
</table>
{{/propertyValue}}

{{#eventType}}
<h5 class="eventType">{{__global.eventType}}</h5>
<table>
  <tr>
    <td>
      {{{type.specName.0.value}}}
      <div>{{{description}}}</div>
    </td>
  </tr>
</table>
{{/eventType}}
{{/syntax}}

{{#overridden}}
<h5 class="overrides">{{__global.overrides}}</h5>
<div><xref uid="{{uid}}" altProperty="fullName" displayProperty="nameWithType"/></div>
{{/overridden}}

{{#implements.0}}
<h5 class="implements">{{__global.implements}}</h5>
{{/implements.0}}
{{#implements}}
  {{#definition}}
    <div><xref uid="{{definition}}" altProperty="fullName" displayProperty="nameWithType"/></div>
  {{/definition}}
  {{^definition}}
    <div><xref uid="{{uid}}" altProperty="fullName" displayProperty="nameWithType"/></div>
  {{/definition}}
{{/implements}}

{{#remarks}}
<h4 id="{{id}}_remarks">{{__global.remarks}}</h4>
<div class="markdown level1 remarks">{{{remarks}}}</div>
{{/remarks}}

{{#example.0}}
<h4 id="{{id}}_examples">{{__global.examples}}</h4>
{{/example.0}}
{{#example}}
{{{.}}}
{{/example}}

{{#seealso.0}}
<h3 id="{{id}}_seealso">{{__global.seealso}}</h3>
<div class="seealso">
{{/seealso.0}}
{{#seealso}}
  {{#isCref}}
    <div>{{{type.specName.0.value}}}</div>
  {{/isCref}}
  {{^isCref}}
    <div>{{{url}}}</div>
  {{/isCref}}
{{/seealso}}
{{#seealso.0}}
</div>
{{/seealso.0}}
{{/children}}
{{/children}}
{{#extensionMethods.0}}
<h3 id="extensionmethods">{{__global.extensionMethods}}</h3>
{{/extensionMethods.0}}
{{#extensionMethods}}
<div>
  {{#definition}}
    <xref uid="{{definition}}" altProperty="fullName" displayProperty="nameWithType"/>
  {{/definition}}
  {{^definition}}
    <xref uid="{{uid}}" altProperty="fullName" displayProperty="nameWithType"/>
  {{/definition}}
</div>
{{/extensionMethods}}
{{#seealso.0}}
<h3 id="seealso">{{__global.seealso}}</h3>
<div class="seealso">
{{/seealso.0}}
{{#seealso}}
  {{#isCref}}
    <div>{{{type.specName.0.value}}}</div>
  {{/isCref}}
  {{^isCref}}
    <div>{{{url}}}</div>
  {{/isCref}}
{{/seealso}}
{{#seealso.0}}
</div>
{{/seealso.0}}


================================================
FILE: Other/DocFX/_doc/template2/partials/item.tmpl.partial
================================================
<h1 id="{{id}}" data-uid="{{uid}}" class="text-break">{{>partials/title}}</h1>

<div class="markdown level0 summary">{{{summary}}}</div>
<div class="markdown level0 conceptual">{{{conceptual}}}</div>

<div class="codewrapper">
  <pre><code class="lang-{{_lang}} hljs">{{syntax.content.0.value}}</code></pre>
</div>

{{#remarks}}
<h4 id="{{id}}_remarks"><strong>{{__global.remarks}}</strong></h4>
<div class="markdown level0 remarks">{{{remarks}}}</div>
{{/remarks}}
{{#example.0}}
<h4 id="{{id}}_examples"><strong>{{__global.examples}}</strong></h4>
{{/example.0}}
{{#example}}
{{{.}}}
{{/example}}


================================================
FILE: Other/DocFX/_doc/toc.yml
================================================
- name: Home
  href: index.md
- name: Library
  href: api/
  topicHref: api/index.md
- name: Editor
  href: editor/
  topicUid: Application
- name: Articles
  href: articles/
  topicHref: articles/index.md
- name: Cookbook
  href: cookbook/
  topicHref: cookbook/index.md


================================================
FILE: README.md
================================================
# LibreAutomate

C# script editor and automation library for Windows.

Some features of the automation library:
- Automate desktop and web UI using keys, mouse and API. Find and click buttons, links, images.
- Launch programs. Manage files and windows. Transfer and process text and other data.
- Hotkeys, autotext and other triggers. Auto-replace/expand text when typing. Auto-close windows. Remap keys.
- Custom toolbars that can be attached to windows or screen edges. And menus.
- Custom dialog windows of any complexity can be created easily in code.
- All classes/functions are documented.
- The library can be used in other programs too. [More info](https://www.libreautomate.com/api/index.html), [NuGet](https://www.nuget.org/packages/LibreAutomate).
- Uses .NET 10.

Some features of the script editor app:
- The scripting language is C#. The app is a good way to learn it.
- C# code editor with intellisense. Script manager, cookbook, debugger.
- Tools for recording keyboard/mouse and selecting UI objects such as buttons, links and images.
- Also you can use .NET and other libraries. Tools and databases for NuGet, Windows API, icons.
- Can create independent .exe programs and .NET libraries.

More info and download: https://www.libreautomate.com/

Editor window

![window](https://www.libreautomate.com/images/window.png#1 "Editor window")

## How to build
You need Visual Studio 2026. When installing, select these workloads: .NET desktop development; Desktop development with C++. It also installs .NET 10 SDK and Windows 11 SDK; or install them separately.

1. Clone or download/extract the source code.
2. Open `Au.sln` in Visual Studio.
3. Switch to platform x86. Build solution.
4. Switch to platform ARM64. Build solution.
5. Switch to platform AnyCPU. Build solution.
6. Run `Au.Editor` project. It should open the editor window.


================================================
FILE: Scripts/@Au docs/Au docs.cs
================================================
/*/
define AUDOCS
noWarnings CS8632
testInternal Au.Editor,Au,Microsoft.CodeAnalysis,Microsoft.CodeAnalysis.CSharp,Microsoft.CodeAnalysis.Features,Microsoft.CodeAnalysis.CSharp.Features,Microsoft.CodeAnalysis.Workspaces,Microsoft.CodeAnalysis.CSharp.Workspaces
pr AuDocsLib.cs
r Au.Editor.dll
r Roslyn\Microsoft.CodeAnalysis.dll
r Roslyn\Microsoft.CodeAnalysis.CSharp.dll
r Roslyn\Microsoft.CodeAnalysis.Features.dll
r Roslyn\Microsoft.CodeAnalysis.CSharp.Features.dll
r Roslyn\Microsoft.CodeAnalysis.Workspaces.dll /alias=CAW
r Roslyn\Microsoft.CodeAnalysis.CSharp.Workspaces.dll
nuget -\Markdig
nuget -\WeCantSpell.Hunspell
/*/

//args = new[] { "/upload" };
var siteDir = @"C:\Temp\Au\DocFX\site";

try {
	if (args.Length == 0) {
		LA.App.Settings = new(); //need internetSearchUrl
		
		//ADL.AuDocsShared.Test();
		_Build();
	} else if (args[0] == "/upload") {
		AuDocs.CompressAndUpload(siteDir);
	}
}
catch (Exception e1) {
	print.it(e1);
	_KillDocfxProcesses();
}

void _Build() {
	print.clear();
	var time0 = perf.ms;
	
	bool testSmall = !true;
	bool cookbook = false, preprocess = false, postprocess = false, build = false, serve = false;
	//cookbook = true;
	//preprocess = true;
	//postprocess = true;
	//serve = true;
	//postprocess = serve = true;
	if (!(cookbook | preprocess | postprocess | build | serve)) preprocess = postprocess = build = serve = cookbook = true;
	bool onlyMetadata = !true;
	//preprocess = true; build = true; onlyMetadata = true;
	
	var sourceDir = testSmall ? @"C:\code\au\Test Projects\TestDocFX" : @"C:\code\au\Au";
	var sourceDirPreprocessed = @"C:\Temp\Au\DocFX\source";
	var docDir = testSmall ? @"C:\code\au\Test Projects\TestDocFX\docfx_project" : @"C:\code\au\Other\DocFX\_doc";
	var siteDirTemp = siteDir + "-temp";
	
	if (cookbook) {
		AuDocs.Cookbook(docDir);
		print.it("DONE cookbook");
		
		script.runWait("LA menu doc.cs");
	}
	
	var d = new AuDocs();
	if (preprocess) {
		d.Preprocess(sourceDir, sourceDirPreprocessed, testSmall);
		print.it("DONE preprocessing");
	}
	
	var docfx = folders.Downloads + @"docfx\docfx.exe";
	int r;
	if (build || serve) {
		_KillDocfxProcesses();
		Environment.CurrentDirectory = docDir;
	}
	
	if (build) {
		filesystem.delete(siteDirTemp);
		r = run.console(o => { print.it(o); }, docfx, "metadata");
		if (r != 0) { print.it("docfx metadata", r); return; }
		if (onlyMetadata) { print.it("metadata ok"); return; }
		r = run.console(o => { print.it(o); }, docfx, $@"build");
		if (r != 0) { print.it("docfx build", r); return; }
		//print.it("build ok");
		postprocess |= serve;
		filesystem.delete(Directory.EnumerateFiles(docDir + @"\api", "*.yml")); //garbage for VS search
		filesystem.delete(docDir + @"\api\.manifest");
	}
	
	if (postprocess) {
		d.Postprocess(siteDirTemp, siteDir);
		print.it("DONE postprocessing");
		
		if (!testSmall && build) {
			script.runWait("LA docs toc.json.cs");
			script.runWait("LA docs doc-html.db.cs");
			print.it("DONE LA docs scripts");
			
			//print.it($"<><script Au docs.cs|/upload>Upload Au docs...<>");
			print.it("""
<>DONE. Now <script LA docs doc-ai.db.cs>create doc-ai.db<>.
To upload the created website, click `Upload...` in the main toolbar.
""");
		}
	}
	
	print.it((perf.ms - time0) / 1000d);
	
	if (serve) {
		//r = run.console(o => { print.it(o); }, docfx, $"serve ""{siteDir}""");
		//if (r != 0) { print.it("docfx serve", r); return; } //no, it prints -1 when process killed
		run.it(docfx, $@"serve ""{siteDir}""", flags: RFlags.InheritAdmin, dirEtc: new() { WindowState = ProcessWindowStyle.Hidden });
	}
	
	//print.scrollToTop();
}

void _KillDocfxProcesses() {
	foreach (var v in process.getProcessIds("docfx.exe")) process.terminate(v);
}


================================================
FILE: Scripts/@Au docs/AuDocs analyze.cs
================================================
//#define DUPLICATE_TEXT
//#define MISSING_PARAM
//#define PARAM_WITH_JUST_SEE
//#define RETURNS_IN_SUMMARY
//#define LIST_NOT_ENDED
//#define STRING_NOT_IN_C
//#define PARAM_NOT_IN_I
//#define SYMBOL_NOT_BOLD
//#define SPELL_CHECK

using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.Text;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Shared.Extensions;
using Microsoft.CodeAnalysis.CSharp.Extensions;
using System.Collections.Immutable;
using System.Xml.Linq;
using Markdig;
using System.Xml;

#pragma warning disable CS0162, CS8321, CS0169 //unreachable code, unused func/field

class _Analyze {
	//AuDocs _main;
	int _currentFileIndex, _currentFileIndexPrev;
	CSharpSemanticModel _semo;
	ISymbol _currentSym;
#if SPELL_CHECK
	WeCantSpell.Hunspell.WordList _spellCheck = WeCantSpell.Hunspell.WordList.CreateFromFiles(@"C:\Program Files\LibreOffice\share\extensions\dict-en\en_US.dic");
#endif
	regexp _rxTriple = new(@"(?m)^\h*///\h?");
	regexp _rxListNotEnded;
	
	//public _Analyze(AuDocs main) {
	//	_main = main;
	//}
	
	public void StartingFile(CSharpSemanticModel semo, int currentFileIndex) {
		_semo = semo;
		_currentFileIndex = currentFileIndex;
	}
	
	/// <summary>
	/// Prints or collects data for an XML doc to find what can be improved in it.
	/// </summary>
	/// <param name="sdoc">Raw XML doc (with ///).</param>
	/// <param name="sym"></param>
	public void AnalyzeDoc(string sdoc, ISymbol sym) {
		return;
		if (_currentFileIndex is not (>= 0 and < 200)) return;
		
		if (_currentFileIndex > _currentFileIndexPrev) {
			_currentFileIndexPrev = _currentFileIndex;
			print.it($"<><bc yellowgreen>{_currentFileIndex}<>");
		}
		
		_currentSym = sym;
		sdoc = "<x>" + _rxTriple.Replace(sdoc) + "</x>";
		var xdoc = XElement.Parse(sdoc, LoadOptions.PreserveWhitespace);
		
		#region child elements
		foreach (var x in xdoc.Elements()) {
			var s = x.ToString();
#if DUPLICATE_TEXT
			if (s.Length > 200) {
				if (!_dDupText.TryAdd(s, _currentSym)) {
					var o = _dDupText[s];
					if (o is List<ISymbol> a) a.Add(_currentSym);
					else if (o is ISymbol sym) _dDupText[s] = new List<ISymbol> { sym, _currentSym };
				}
			}
#endif
			
#if PARAM_WITH_JUST_SEE
			if(x.Name.LocalName=="param" && s.Contains("<see cref") && s.Ends(false, ">.</param>", "></param>") > 0 && x.Elements().Count() == 1) {
				//if (x.FirstNode is XElement || (x.FirstNode is XText xt && xt.Value.Length < 10)) {
				if (x.FirstNode is XElement || (x.FirstNode is XText xt && xt.Value == "See ")) {
					_Print(s);
				}
			}
#endif
			
#if RETURNS_IN_SUMMARY
			if (x.Name.LocalName == "summary" && s.Contains("\nReturns") && !s.Starts("<summary>\r\nReturns")) {
				_Print(s);
			}
			
			//this hotkey script moves /// Returns ... line from <summary> to <returns>.
			//hk["F8"] = o => {
			//	if (!clipboard.tryCopy(out var s)) return;
			//	if (s != null && 0 != s.RxReplace(@"///\h(?:Return[s]? )?(.+)", "/// <returns>$1</returns>", out s, 1)) {
			//		keys.send("Ctrl+X Down Home*2");
			//		clipboard.paste(s);
			//		keys.send("Up");
			//	}
			//};
#endif
			
#if LIST_NOT_ENDED
			_rxListNotEnded ??= new(@"(?m)^\h*-.+\R\t*(?![\- \r\n]|</|<br\b)");
			if (_rxListNotEnded.IsMatch(s)) {
				_Print(s);
			}
#endif
		}
		#endregion
		
		#region child nodes
		foreach (var n in xdoc.Nodes()) {
			if (n is XElement) continue;
			
			//all xdoc child nodes must be XElement
			if (n is XText t && n is not XCData) {
				var s = t.Value;
				if (!string.IsNullOrWhiteSpace(s)) _Print(s);
			} else {
				_Print(n);
			}
		}
		#endregion
		
#if STRING_NOT_IN_C
		//if text contains " or ', in most cases it is code and should be in <c>
		foreach (var s in _DescendantTexts()) {
			//if (s.Contains('"')) {
			//	_Print(s);
			//}
			if (s.RxIsMatch(@"'.'")) {
				//if (s.RxIsMatch(@"'\\.'")) {
				//if (s.RxIsMatch(@"'\\x\w+'")) {
				_Print(s);
			}
		}
#endif
		
#if PARAM_NOT_IN_I //parameter references must be in <i>
		ImmutableArray<IParameterSymbol> ap = default;
		if (_currentSym is IMethodSymbol ims) {
			ap = ims.Parameters;
		} else if (_currentSym is IPropertySymbol ips && ips.IsIndexer) {
			ap = ips.Parameters;
		}
		if (!ap.IsDefaultOrEmpty) {
			//print.it(_currentSym);
			var at = _DescendantTexts();
			if (at.Any()) {
				bool sep=false;
				foreach (var p in ap) {
					var rx = new regexp($@"(?<![\.'])\b{p.Name}\b");
					foreach (var s in at) {
						if (rx.Replace(s, "</_><bc yellow>$0<><_>", out var s2) > 0) {
							if(!sep) { sep=true; print.it("-------------------"); }
							_Print(s2);
						}
					}
				}
			}
		}
#endif
		
#if SYMBOL_NOT_BOLD //names of types, functions, enum members etc should be in <b> or <see>, <ms>.
		var hs = _stackSymbols.Peek();
		foreach (var s in _DescendantTexts()) {
			bool found = false;
			_rxWord.Replace(s, m => {
				var v = m.Value;
				
				//found = v is not ("ANSI" or "PCRE" or "NOTE" or "IMPORTANT" or "MSDN" or "XAML" or "HTML" or "ASCII" or "JSON" or "HTTP");
				//if (found) return "</_><bc yellow>" + v + "<><_>";
				
				bool skip = true; for (int j = 1; j < v.Length; j++) if (char.IsUpper(v[j])) { skip = false; break; }
				if (skip) {
					skip = false;
					//skip if start of sentence
					if ((m.Start == 0 || m.Subject.Eq(m.Start - 1, '\n') || m.Subject.Eq(m.Start - 2, ". ")) && !m.Subject.Eq(m.End, '<') && !m.Subject.Eq(m.End, '[')) {
						//skip = v is "More" or "System" or "Object" or "Enum" or "Single" or "Double" or "Missing" or "Type" or "Delegate" or "Attribute" or "String" or "Array" or "List" or "Exception" or "Action" or "File" or "Path" or "Icon" or "Image" or "Process" or "Thread" or "Font" or "Timeout" or "Timer" or "Rectangle" or "Group";
						skip = true;
					} else {
						//skip = v is "More" or "System" or "Object" or "Enum" or "Single" or "Double" or "Missing" or "Type" or "Delegate" or "Attribute" or "String" or "Array" or "List" or "Exception" or "Action" or "File" or "Path" or "Process" or "Thread" or "Timeout" or "Timer" or "Task" or "Debug" or "Au";
					}
				} else {
					skip = v is "GC" or "MD5";
				}
				if (skip) return v;
				
				if (hs.Contains(v)) {
					found = true;
					return "</_><bc yellow>" + v + "<><_>";
				} else {
					
				}
				return v;
			}, out var s2);
			
			if (found) {
				_Print(s2);
			}
		}
#endif
		
#if SPELL_CHECK
		foreach (var s in _DescendantTexts()) {
			bool found = false;
			_rxWord.Replace(s, m => {
				var v = m.Value;
				if (!_spellCheck.Check(v)) {
					if (v is "eg" or "ie" || v.Starts(true, "substring", "unmanaged") > 0) return v;
					found = true;
					return "</_><bc yellow>" + v + "<><_>";
				}
				return v;
			}, out var s2);
			
			if (found) {
				_Print(s2);
			}
		}
#endif
		
		string[] _DescendantTexts()
			=> xdoc.DescendantNodes().OfType<XText>().Where(t => t is not XCData && t.Parent.Name.LocalName is not ("c" or "i" or "b" or "google" or "ms" or "sqlite" or "code"))
			.Select(t => t.Value.Trim("\r\n")).Where(s => !string.IsNullOrWhiteSpace(s)).ToArray();
		
		void _Print(object s) {
			if (_currentSym != _prevPrintSym) {
				_prevPrintSym = _currentSym;
				print.it($"<>{AuDocs.LaGoto(_currentSym)}");
			}
			print.it($"<><_>{s}</_>");
		}
	}
	Dictionary<string, object> _dDupText = new();
	ISymbol _prevPrintSym;
	
#if SYMBOL_NOT_BOLD
	Stack<HashSet<string>> _stackSymbols = new();
	public void AnalyzeType(CSharpSyntaxNode sn) {
		if (sn != null) {
			int pos = sn switch { BaseTypeDeclarationSyntax btd => btd.CloseBraceToken.SpanStart, NamespaceDeclarationSyntax nd => nd.CloseBraceToken.SpanStart, FileScopedNamespaceDeclarationSyntax fsnd => fsnd.SemicolonToken.Span.End, _ => 0 };
			_stackSymbols.Push(_semo.LookupSymbols(pos).Select(o => o.Name).ToHashSet());
			//_stackSymbols.Push(_semo.LookupSymbols(pos).Where(o => o is not INamespaceSymbol).Select(o => o.Name).ToHashSet());
			//_stackSymbols.Push(_semo.LookupSymbols(pos).Where(o => o is not INamespaceOrTypeSymbol).Select(o => o.Name).ToHashSet());
		} else _stackSymbols.Pop();
	}
#else
	public void AnalyzeType(CSharpSyntaxNode sn) { }
#endif
	
	//regexp _rxWord = new(@"\b(?<![\.""])[A-Z]\w+\b(?!</|"")"); //Abc
	//regexp _rxWord = new(@"\b(?<![""])[A-Z]\w+\b(?!</|""|\.)"); //Abc
	//regexp _rxWord = new(@"\b(?<![\.""])[a-z][A-Za-z]+\d?\b(?!</|"")"); //aBc
	//regexp _rxWord = new(@"\b(?<![\.""])[A-Z]+_[A-Z_]+\d?\b(?!</|"")"); //AB_C
	//regexp _rxWord = new(@"\b(?<![\.""])[A-Z_]+_\b(?!</|"")"); //AB_
	//regexp _rxWord = new(@"\b(?<![\.""])[A-Z]{4,}\d?\b(?!</|"")"); //ABC
	//regexp _rxWord = new(@"\b(?<![\.""])[A-Z]+[a-z]*[A-Z]+[a-z]+[A-Za-z]*\d?\b(?!</|"")"); //AbCd
	//regexp _rxWord = new(@"\bflags? [A-Z]\w+\b(?!</|"")"); //flag Abc
	//regexp _rxWord = new(@"\b(?<![\.""])[A-Z]\w+X\b(?!</|"")"); //SymbolX
	//regexp _rxWord = new(@"\b(?<![\.""])[A-Z]\w+x\b(?!</|"")"); //SYMBOLx
	//regexp _rxWord = new(@"\b(?<![\.""])(?i)[A-Z]\w*(\.[A-Z]\w*)+\b(?!</|"")"); //Abc.Def
	//regexp _rxWord = new(@"\b(?<![\.""])[a-z]+[A-Z]+[A-Za-z]*\d?\b(?!</|"")"); //aBc
	//regexp _rxWord = new(@"\b(?<![""])(?i)[a-z]\w+<[a-z]\w+\b(?!</|"")"); //abc<def>
	//regexp _rxWord = new(@"\b(?<![""])(?i)[a-z]\w+\[(?!</|"")"); //abc[] //rejected
	//regexp _rxWord = new(@"\b(?<![\.""])[a-z]+[a-z_\d]*\b(?!</|"")"); //abc
	regexp _rxWord = new(@"\b[A-Za-z][a-z']*\b"); //word for spell check
	
	/// <summary>
	/// Prints data collected by _AnalyzeDoc.
	/// </summary>
	public void Finally() {
		foreach (var (s, o) in _dDupText) {
			if (o is not List<ISymbol> a) continue;
			print.it($"""
<><lc green>Duplicate text:<>
<lc wheat><_>{s}</_><>
{string.Join('\n', a.Select(o => AuDocs.LaGoto(o)))}
""");
		}
	}
	
	/// <summary>
	/// Prints or collects data for an XML doc to find what can be improved in it.
	/// xdoc, sxml - final doc XML (after expanding inheritdoc and modifying).
	/// </summary>
	public void AnalyzeDoc2(XElement xdoc, string sxml) {
		if (_currentFileIndex is not (>= 0 and < 200)) return;
		
		var sym = _currentSym;
		
		if (sxml.RxIsMatch(@"\[.*?\]\(.*?\)")) _Warning("Unprocessed []() link", sxml);
	}
	
	public void MissingParam(IParameterSymbol p, XElement x) {
#if MISSING_PARAM
		if (_currentFileIndex is not (>= 0 and < 200)) return;
		
		var sym = _currentSym;
		if(p.Type.IsEnumType()) return;
		//if(p.IsThis) return; //does not work. Also tested p.OriginalDefinition.IsThis and p.CustomModifiers.
		//if (x==null || x.IsEmpty) return;
		
		//bool hasOverloads = sym.ContainingType.GetMembers(sym.Name).Length > 1;
		//if (!hasOverloads) return;
		
		if (sym != _prevMethod) {
			_prevMethod = sym;
			print.it("<>" + AuDocs.VsGoto(sym));
		}
		print.it(p.Name);
	}
	ISymbol _prevMethod;
#else
	}
#endif
	
	void _Warning(string warning, object text) {
		print.warning($"<_>{warning}</_>\r\n\tMember: {AuDocs.LaGoto(_currentSym)} in {_semo.SyntaxTree.FilePath}\r\n\tText: <_>{text}</_>", 1);
	}
}


================================================
FILE: Scripts/@Au docs/AuDocs cookbook.cs
================================================
using System.Xml.Linq;
using ADL;

partial class AuDocs {
	
	public static void Cookbook(string docDir) {
		var sbToc = new StringBuilder();
		List<(string name, string path)> aFiles = new();
		
		string dirTo = @"C:\Temp\Au\DocFX\cookbook", dirToLink = docDir + @"\cookbook";
		if (filesystem.exists(dirTo)) filesystem.delete(Directory.GetFiles(dirTo));
		else filesystem.createDirectory(dirTo);
		if (!filesystem.exists(dirToLink).IsNtfsLink) filesystem.more.createSymbolicLink(dirToLink, dirTo, CSLink.Directory);
		
		var dirFrom = folders.ThisAppBS + @"..\Cookbook\files";
		var xr = XmlUtil.LoadElem(dirFrom + ".xml");
		
		_AddItems(xr, 1, dirFrom);
		
		void _AddItems(XElement xp, int level, string path) {
			//see PanelCookbook._Load().
			foreach (var x in xp.Elements()) {
				var name = x.Attr("n");
				if (name[0] == '-') continue;
				var tag = x.Name.LocalName;
				bool dir = tag == "d";
				if (dir) {
					sbToc.Append('#', level).AppendFormat(" {0}\r\n", name);
					_AddItems(x, level + 1, path + "\\" + name);
				} else {
					if (tag != "s") continue;
					var cspath = path + "\\" + name;
					name = name[..^3];
					sbToc.Append('#', level).AppendFormat(" [{0}](/cookbook/{1})\r\n", name, Uri.EscapeDataString(name) + ".html");
					aFiles.Add((name, cspath));
				}
			}
		}
		
		//print.it(sbToc.ToString());
		filesystem.saveText(dirTo + @"\toc.md", sbToc.ToString());
		filesystem.saveText(dirTo + @"\index.md", "");
		
		foreach (var (name, path) in aFiles) {
			var code = filesystem.loadText(path);
			bool test = false;
			//test = name == "test";
			//if (test) {
			//	print.it($"<><lc #B3DF00>{name}<>");
			//	print.it(code);
			//	print.it("-------------");
			//}
			
			var md = AuDocsShared.RecipeCodeToMd(name, code, test);
			if (test) print.it(md);
			filesystem.saveText($@"{dirTo}\{name}.md", md);
		}
	}
}


================================================
FILE: Scripts/@Au docs/AuDocs other tasks.cs
================================================
/*/ nuget -\SSH.NET; c Sftp.cs; c Passwords.cs; /*/
using Renci.SshNet;
using System.Text.Json;

partial class AuDocs {
	public static void CompressAndUpload(string siteDir) {
		if (1 != dialog.show("Upload?", "Will replace the LA home page and all docs.", "1 Yes|2 No")) return;
		var tarDir = pathname.getDirectory(siteDir);
		_Compress(siteDir, tarDir);
		_Upload(tarDir);
		//_CloudflarePurgeCache(); //currently not using
	}
	
	static void _Compress(string siteDir, string tarDir) {
		var sevenZip = folders.ThisAppBS + @"32\7za.exe";
		
		var tar = tarDir + @"\site.tar";
		filesystem.delete(tar);
		filesystem.delete(tarDir + @"\site.tar.bz2"); //info: bz2 compression is much better than gz/zip. xz/7z slightly better than bz2, but can't SSH-extract.
		
		int r1 = run.console(out var s, sevenZip, $@"a ""{tar}""", siteDir); //add files to the root in the archive, not to "site" dir
		if (r1 != 0) { print.it(r1, s); return; }
		int r2 = run.console(out s, sevenZip, $@"a site.tar.bz2 site.tar", tarDir);
		if (r2 != 0) { print.it(r2, s); return; }
		
		filesystem.delete(tarDir + @"\site.tar");
		
		print.it("Compressed");
	}
	
	static void _Upload(string tarDir) {
		var ci = Sftp.GetConnectionInfo(); if (ci == null) return;
		
		const string ftpDir = "domains/libreautomate.com/public_html";
		var localFile = tarDir + @"/site.tar.bz2";
		
		//upload
		using var ftp = new SftpClient(ci.host, ci.port, ci.user, ci.pass);
		ftp.ConnectAndUpload(ftpDir, localFile);
		print.it("Uploaded");
		
		//extract
		using var ssh = new SshClient(ci.host, ci.port, ci.user, ci.pass);
		ssh.Connect();
		_Cmd2("tar -xf site.tar.bz2");
		
		void _Cmd(string s, bool silent = false) {
			var c = ssh.RunCommand(s);
			//print.it($"ec={c.ExitStatus}, result={c.Result}, error={c.Error}");
			if (!silent && c.ExitStatus != 0) throw new Exception(c.Error);
		}
		
		//cd does not work when separate command
		void _Cmd2(string s, bool silent = false) => _Cmd($"cd {ftpDir} && {s}", silent);
		
		filesystem.delete(localFile);
		var downl = $"download/doc/{Au_.Version}.tar.bz2";
		if(ftp.Exists(downl)) ftp.DeleteFile(downl);
		ftp.RenameFile("site.tar.bz2", downl);
		
		print.it("<>Extracted to <link>https://www.libreautomate.com/</link>");
	}
	
	//file: path to a file in https://www.libreautomate.com/. If null, purges all.
	static void _CloudflarePurgeCache(string file = null) {
		var token = Passwords.Get("Cloudflare API");
		var content = internet.jsonContent(file != null ? $$"""{"files":["https://www.libreautomate.com/{{file}}"]}""" : $$"""{"purge_everything": true}""");
		var j = internet.http.Post("https://api.cloudflare.com/client/v4/zones/238431a81c22e29834a04ce68574988c/purge_cache", content, [$"Authorization: Bearer {token}"]).Json();
		var ok = (bool)j["success"];
		if (!ok) print.warning("Failed to purge Cloudflare cache.\r\nTo purge manually: Cloudflare -> Caching -> Configuration -> Purge Everything.\r\nResult:\r\n" + j);
	}
}


================================================
FILE: Scripts/@Au docs/AuDocs text.cs
================================================
//In this file: functions that preprocess or postprocess file text without Roslyn.

//#define DISQUS

using System.Xml.Linq;
using System.Xml.XPath;
using System.Net;

partial class AuDocs {
	regexp _rxRecord, _rxRecordParam, _rxRecordDocLine, _rxRecordDocParam, _rxSeealso1, _rxSeealso2, _rxSeealso3, _rxSeealso4, _rxSeealso5;
	
	string _PreprocessFileAsText(string path, string s) {
		//if (!path.Ends("param types.cs")) return s;
		
		//Convert 'record class X(...)' to the classic format, because DocFX:
		//	1. Ignores <param>.
		//	2. Copies summary etc from type to ctor.
		if (s.Contains("record ")) {
			//print.it($"<><lc greenyellow>{path}");
			_rxRecord ??= new(@"(?m)^\h*(public [\w ]*\brecord) (class|struct) (\w+)(\(([^()]++|(?-2))+\))[^\{;]*[\{;]");
			s = _rxRecord.Replace(s, m => {
				//print.it($"<><c blue>{m.Value}<>");
				
				_b.Clear();
				var mod = m[1].Value;
				var name = m[3].Value;
				var par = s[(m[4].Start + 1)..(m[4].End - 1)];
				var sub = m.Subject;
				bool noBody = sub[m.End - 1] == ';';
				
				_b.AppendFormat("{0} {1} {2} {{", mod, m[2].Value, name);
				//doc
				_rxRecordDocLine ??= new(@"\G\h*///[^/]");
				int docStart = 0;
				for (int i = m.Start; i > 3;) {
					i = sub.LastIndexOf('\n', i - 2); if (i < 0) break;
					if (!_rxRecordDocLine.IsMatch(sub, ++i..)) break;
					docStart = i;
				}
				RXMatch[] ap = null;
				if (docStart > 0) {
					//print.it($"<><c green><_>{sub[docStart..m.Start]}</_><>");
					_rxRecordDocParam ??= new(@"(?ms)^\h*///\h*<param name=""(\w+)"">(.+?)</param>\h*\R");
					if (!_rxRecordDocParam.FindAll(sub, out ap, docStart..m.Start)) ap = null;
					//if(ap!=null) foreach (var v in ap) print.it($"<><c brown><_>{v}</_><>");
				}
				
				//ctor
				_b.AppendLine();
				if (ap != null) foreach (var p in ap) _b.Append(p.Value);
				_b.AppendFormat("public {0}({1}){{}}\n", name, par);
				
				//properties
				_rxRecordParam ??= new(@"\G((?:[\w\.]+|\([^)]+\))(<([^<>]++|(?-2))+>)?(?:\[\])?) (\w+)(?:,\s*|$)");
				foreach (var k in _rxRecordParam.FindAll(par)) {
					string pType = k[1].Value, pName = k[4].Value;
					//print.it($"type='{pType}', name='{pName}'");
					_b.AppendLine();
					var mp = ap?.FirstOrDefault(o => o[1].Value == pName);
					if (mp != null) _b.Append("/// <summary>").Append(mp[2].Value).AppendLine("</summary>");
					_b.AppendFormat("public {0} {1} {{ get; init; }}\n", pType, pName);
				}
				
				if (noBody) _b.Append("}");
				//print.it(_b);
				
				//return m.Value;
				return _b.ToString();
			});
			//if(s.RxMatch(@"(?m)^[\h\w]*\brecord (?:class|struct)(\w+)\(", out var m2)) print.it("regex failed", path);
		}
		
		//if (path.Ends("param types.cs")) print.it(s);
		return s;
	}
	
	public void Postprocess(string siteDirTemp, string siteDir) {
		ADL.AuDocsShared.ResolveAuApiLink = s => {
			foreach (var ns in _auNamespaces) {
				if (filesystem.exists(siteDirTemp + "/api/" + ns + s + ".html", true).File) return "/api/" + ns + s + ".html";
			}
			return null;
		};
		
		filesystem.delete(siteDir);
		filesystem.createDirectory(siteDir);
		var files = filesystem.enumFiles(siteDirTemp, flags: FEFlags.AllDescendants | FEFlags.NeedRelativePaths | FEFlags.UseRawPath).ToArray();
		Parallel.ForEach(files, f => { //faster: 26 s -> 14 s; without code styling 8 s -> 3 s
			var name = f.Name;
			var file2 = siteDir + name;
			if (name.Ends(".html") && !name.Ends(@"\toc.html")) {
				_PostprocessFile(f, file2, siteDirTemp);
			} else if (name.Eqi(@"\styles\docfx.js")) {
				_ProcessJs(f.FullPath, file2);
			} else {
				filesystem.copy(f.FullPath, file2);
				if (name.Eqi(@"\xrefmap.yml")) _XrefMap(f.FullPath);
			}
		});
		filesystem.saveText(siteDir + @"\styles\code.css", ADL.AuDocsShared.CreateCodeCss());
	}
	
	void _PostprocessFile(FEFile f, string file2, string siteDirTemp) {
		//print.it($"<><lc green>{f.Name}<>");
		string name = f.Name, s = filesystem.loadText(f.FullPath);
		bool isApi = name.Starts(@"\api") && name != @"\api\index.html";
		//print.it(name, isApi);
		
		int nr;
		if (isApi) {
			//In class member pages, in title insert a link to the type.
			nr = s.RxReplace(@"<h1\b[^>]* data-uid=""(Au\.(?:Types\.|Triggers\.|More\.)?+([\w\.`]+))\.#?\w+\*?""[^>]*>\K(Method|Property|Field|Event|Operator|Constructor) (\w+)",
				m => {
					string fileName = m[1].Value, className = m[2].Value, memberName = m[4].Value;
					if (className.Contains('`')) { //generic
						fileName = fileName.Replace("`", "-");
						if (className.Ends("`1")) className = className.ReplaceAt(^2.., "&lt;T&gt;");
						else if (className.Ends("`2")) className = className.ReplaceAt(^2.., "&lt;T1, T2&gt;");
						else if (className.Ends("`3")) className = className.ReplaceAt(^2.., "&lt;T1, T2, T3&gt;");
						else throw new NotImplementedException();
					}
					if (m.Subject[m[1].End + 1] == '#') return $@"Constructor of <a href=""{fileName}.html"">{className}</a>"; //ctor
					if (memberName == "this") return $@"Indexer of <a href=""{fileName}.html"">{className}</a>"; //indexer
					return $@"{m[3].Value} <a href=""{fileName}.html"">{className}</a>.{memberName}";
				},
				out s, 1);
			
			//Add "(+ n overloads)" link in h1 and "(next/top)" links in h2 if need.
			if (s.RxFindAll(@"<h2 class=""overload"" id=""(.+?)"".*?>Overload", out var a) && a.Length > 1) {
				var b = new StringBuilder();
				int jPrev = 0;
				for (int i = 0; i < a.Length; i++) {
					bool first = i == 0, last = i == a.Length - 1;
					int j = first ? s.Find("</h1>") : a[i].End;
					b.Append(s, jPrev, j - jPrev);
					jPrev = j;
					b.Append("<span style='font-size:14px; font-weight: 400; margin-left:20px;'>(");
					if (first) b.Append("+ ").Append(a.Length - 1).Append(" ");
					var href = last ? "top" : a[i + 1][1].Value;
					b.Append("<a href='#").Append(href).Append("'>");
					if (first) b.Append("overload").Append(a.Length == 2 ? "" : "s");
					else b.Append(last ? "top" : "next");
					b.Append("</a>)</span>");
				}
				b.Append(s, jPrev, s.Length - jPrev);
				s = b.ToString();
			}
			
			//Remove anchor from the first hidden overload <h2>, and add at the very top (before <header>).
			//	Without it would not work links to the top overload from others overloads in the same page.
			//	In the past needed this to prevent incorrect scrolling. It seems current web browsers don't scroll.
			if (s.RxMatch(@"(<h2 class=""overload"")( id="".+?"" data-uid="".+?"")", out var m)) {
				s = s.ReplaceAt(m[2], "");
				s = s.RxReplace(@"<a name=""top""\K", m[2].Value, 1);
			}
			
			//Replace <seealso> link. DocFX sets incorrect text and incorrect URL.
			//	For <see> we specify correct text when preprocessing, but for <seealso> DocFX ignores that text.
			//	Workaround: when preprocessing, before <seealso cref> insert <seealso href> with correct text. Now regex replace.
			_rxSeealso1 ??= new("""(?ms)^\h*<div class="seealso">\R(.+?)\R\h*</div>""");
			s = _rxSeealso1.Replace(s, m1 => {
				var v = m1.Value;
				//bool debug = v.Contains("run.console");
				//if (debug) print.it("-----");
				
				//current docfx in method link text adds parameters with links to types
				_rxSeealso3 ??= new("""(?><div><a class="xref".+?</a>)\K.+(?=</div>)""");
				v = _rxSeealso3.Replace(v, "");
				//if (debug) print.it(v);
				
				//bug in current docfx: method href ends with `(raw parameters).html` instead of `.html#ns_type_name_para_meters_`. Also, generic method page name ends like `--2`.
				_rxSeealso4 ??= new("""<a class="xref" href="\K((.+?)(?:--\d+)?\(.+?\))\.html""");
				_rxSeealso5 ??= new(@"\W");
				v = _rxSeealso4.Replace(v, m2 => {
					//if (debug) print.it("-", m2.Value);
					return m2[2].Value + ".html#" + _rxSeealso5.Replace(m2[1].Value, "_");
				});
				//if (debug) print.it(v);
				
				//replace link text
				_rxSeealso2 ??= new("""(?m)^.+?<a href="https://text">(.+?)</a>.+\R(.+?<a class="xref".+?>)(.+?)(?=</a>)""");
				v = _rxSeealso2.Replace(v, m3 => m3[2].Value + System.Net.WebUtility.HtmlEncode(Encoding.UTF8.GetString(Convert2.HexDecode(m3[1].Value))));
				//if (debug) print.it(v);
				
				return v;
			});
			
			//ungroup Classes, Structs etc in namespace pages. Eg would be at first class screen.at and then separately struct screen.
			if (0 != name.Ends(true, @"\Au.html", @"\Au.More.html", @"\Au.Types.html", @"\Au.Triggers.html") && s.RxMatch(@"(?sm)(^\h*<h2 .+?)</article>", 1, out RXGroup g)) {
				var k = s.RxFindAll("""(?ms)^\h*<h5 class="ns"><a .+?>(.+?)</a>.+?</section>\R""", 0, g).OrderBy(o => o[1].Value);
				s = s.ReplaceAt(g, string.Join("", k));
			}
			
			//second part of the damaged spaces workaround
			s = s.Replace('\u202F', ' ');
		} else {
			s = ADL.AuDocsShared.PostprocessHtmlNonApi(name, s);
		}
		
		s = ADL.AuDocsShared.PostprocessHtmlCommon(f.Name, s, isApi);
		
#if DISQUS
		//TODO3: Now shows Disqus content when page loaded (if small) or scrolled to the bottom. Should show only when clicked <h2>User comments</h2>.
		
		//add this at the bottom of help pages
		var disqus = """

<hr/>
<h2>User comments</h2>
<div id="disqus_thread"></div>
<script>
    /**
    *  RECOMMENDED CONFIGURATION VARIABLES: EDIT AND UNCOMMENT THE SECTION BELOW TO INSERT DYNAMIC VALUES FROM YOUR PLATFORM OR CMS.
    *  LEARN WHY DEFINING THESE VARIABLES IS IMPORTANT: https://disqus.com/admin/universalcode/#configuration-variables    */
    /*
    var disqus_config = function () {
    this.page.url = PAGE_URL;  // Replace PAGE_URL with your page's canonical URL variable
    this.page.identifier = PAGE_IDENTIFIER; // Replace PAGE_IDENTIFIER with your page's unique identifier variable
    };
    */
    (function() { // DON'T EDIT BELOW THIS LINE
    var d = document, s = d.createElement('script');
    s.src = 'https://libreautomate.disqus.com/embed.js';
    s.setAttribute('data-timestamp', +new Date());
    (d.head || d.body).appendChild(s);
    })();
</script>

""";
		int i1=s.LastIndexOf("</article>");
		if(i1>0) s = s.Insert(i1, disqus);
		else print.warning("no </article> in " + name);
#endif
		
		//print.it(s);
		filesystem.saveText(file2, s);
	}
	
	static void _ProcessJs(string file, string file2) {
		var s = filesystem.loadText(file);
		
		//don't need to highlight code. We do it at build time.
		s = s.Replace("highlight();", "");
		
		//prevent adding <wbr> in link text
		s = s.Replace("breakText();", "").Replace("$(e).breakWord();", "");
		
		//we process tables and alerts in HTML at build time. At run time the repainting is visible, and it slows down page loading, + possible scrolling problems.
		s = s.Replace("renderTables();", "").Replace("renderAlerts();", "");
		
		//prevent adding footer when scrolled to the bottom
		s = s.Replace("renderFooter();", "");
		//Somehow adds anyway. Need to add empty footer.tmpl.partial. But this code line does not harm.
		
		filesystem.saveText(file2, s);
	}
	
	//From xrefmap.yml extracts conceptual topics and writes to _\xrefmap.yml.
	//Could simply copy the file, but it is ~2 MB, and we don't need api topics.
	//Editor uses it to resolve links in code info.
	static void _XrefMap(string file) {
		var b = new StringBuilder();
		var s = filesystem.loadText(file);
		foreach (var m in s.RxFindAll(@"(?m)^- uid:.+\R.+\R  href: (?!api/).+\R", (RXFlags)0)) {
			//print.it(m);
			b.Append(m);
		}
		
		filesystem.saveText(folders.ThisAppBS + "xrefmap.yml", b.ToString());
	}
}


================================================
FILE: Scripts/@Au docs/AuDocs.cs
================================================
extern alias CAW;

using Microsoft.CodeAnalysis;
using CAW::Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.Text;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Shared.Extensions;
using CAW::Microsoft.CodeAnalysis.Shared.Extensions;
using Microsoft.CodeAnalysis.CSharp.Extensions;
using System.Collections.Immutable;
using System.Xml.Linq;
using Markdig;
using System.Xml;

partial class AuDocs {
	CSharpCompilation _compilation;
	CSharpSemanticModel _semo;
	StringBuilder _b = new(), _bFile = new();
	int _filePos;
	string _code;
	int _currentFileIndex;
	ISymbol _currentSym;
	MarkdownPipeline _pipeline;
	_Analyze _analyze;
	
	string[] _auNamespaces = { "Au.Types.", "Au.More.", "Au.Triggers.", "Au." };
	HashSet<string> _hsException = new(), _hsSeealso = new();
	regexp _rxLineStart = new(@"(?m)^");
	regexp _rxEmptyLine = new(@"\R\h*\R");
	regexp _rxC = new(@"(?s)<c><!\[CDATA\[(<c.+?</c>)\]\]></c>");
	regexp _rxLi = new(@"(?m)^(\h*)<br /> *•");
	regexp _rxLi2 = new(@"(?m)^\h*-");
	regexp _rxIndentation, _rxIndentation2;
	regexp _rxParams;
	regexp _rxFixInherited = new(@"(</(summary|param|typeparam|remarks|example|returns|value|exception|seealso|code|note|para|table|div|h\d|ul|ol)>)(<(?2)\b)");
	regexp _rxFixInheritedBr = new(@"(</[a-z]+>)(?=<br\b)");
	regexp _rxParaNote = new(@"<(para|note)\b.*>((?s).+?)</\1>");
	regexp _rxLineBreak = new(@"(?m)\\(?!$)");
	
	public AuDocs() {
		var p = new MarkdownPipelineBuilder();
		p.BlockParsers.RemoveAll(o => o is Markdig.Parsers.IndentedCodeBlockParser or Markdig.Parsers.HeadingBlockParser);
		
		//rejected: disable EmphasisInlineParser (*, _), CodeInlineParser (`), EscapeInlineParser (\). It also disables the pipe tables extension and maybe some other. Instead we'll temporarily escape these characters.
		//p.InlineParsers.RemoveAll(o => o is not (Markdig.Parsers.Inlines.HtmlEntityParser or Markdig.Parsers.Inlines.LinkInlineParser or Markdig.Parsers.Inlines.AutolinkInlineParser or Markdig.Parsers.Inlines.LineBreakInlineParser or Markdig.Parsers.Inlines.LiteralInlineParser));
		
		p.DisableHeadings();
		p.UsePipeTables();
		_pipeline = p.Build();
		
		_analyze = new();
		
		opt.warnings.Verbose = true;
	}
	
	public void Preprocess(string sourceDir, string destDir, bool testSmall) {
		filesystem.delete(destDir);
		filesystem.createDirectory(destDir);
		
		//info: currently there are no excluded .cs files. Would need to parse Au.csproj.
		
		var parseOpt = new CSharpParseOptions(LanguageVersion.Preview, DocumentationMode.Parse);
		var trees = new List<CSharpSyntaxTree>();
		var files = new List<(string path, string code)>();
		
		foreach (var f in filesystem.enumerate(sourceDir, FEFlags.NeedRelativePaths, dirFilter: o => o.Level == 0 && 0 != o.Name.Eq(true, @"\obj", @"\bin", @"\docfx_project") ? 0 : 2)) {
			var path = f.FullPath;
			if (f.Name.Ends(".cs", true)) {
				if (testSmall && f.Name == @"\_Aaa.cs") continue;
				var code = filesystem.loadText(path);
				code = _PreprocessFileAsText(path, code);
				var tree = CSharpSyntaxTree.ParseText(code, parseOpt, f.Name) as CSharpSyntaxTree;
				trees.Add(tree);
				files.Add((f.Name, code));
			} else if (f.Name.Eqi(@"\Au.csproj")) {
				var s = filesystem.loadText(path);
				s = s.RxReplace(@"(?ms)^\h*<COMReference\b.+?</COMReference>", "", 1); //mute docfx warning
				s = s.Replace("<SignAssembly>true</SignAssembly>", "");
				s = s.RxReplace("<AssemblyOriginatorKeyFile>.+?</AssemblyOriginatorKeyFile>", "");
				filesystem.saveText(destDir + f.Name, s);
			} else {
				filesystem.copy(path, destDir + f.Name);
			}
		}
		
		var refs = LA.MetaReferences.DefaultReferences.Values;
		var compOpt = new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary, allowUnsafe: true);
		_compilation = CSharpCompilation.Create("doc", trees, refs, compOpt);
		
		//note: cannot get all declared symbols directly from Compilation. Somehow _compilation.GetSymbolsWithName skips ctors etc. Also tried other classes, unsuccessfully.
		//print.it(_compilation.GetSymbolsWithName(o=>true).Where(o=>!o.IsImplicitlyDeclared && o.HasPublicResultantVisibility()).Select(o=>o.ToString()).OrderBy(o=>o));
		//Microsoft.CodeAnalysis.FindSymbols.SymbolFinder.FindSourceDeclarationsAsync //not tested
		
		for (int i = 0; i < trees.Count; i++) {
			_currentFileIndex = i;
			var tree = trees[i];
			_semo = _compilation.GetSemanticModel(tree) as CSharpSemanticModel;
			
			//if(!tree.FilePath.Ends("\\filesystem.cs")) continue;
			_bFile.Clear();
			_filePos = 0;
			var f = files[i];
			_code = f.code;
			_PreprocessFile(tree);
			_bFile.Append(f.code, _filePos, f.code.Length - _filePos);
			var s = _bFile.ToString();
			filesystem.saveText(destDir + f.path, s);
			
			//print.it($"<><lc green>{f.path}<>");
			//print.it(s);
			//if(f.path.Ends("param types.cs")) print.it(s);
		}
		
		_analyze.Finally();
	}
	
	void _PreprocessFile(CSharpSyntaxTree tree) {
		_analyze.StartingFile(_semo, _currentFileIndex);
		
		var root = tree.GetCompilationUnitRoot();
		foreach (var m1 in root.Members) {
			if (m1 is not BaseNamespaceDeclarationSyntax ns) throw new Exception("not namespace: " + m1);
			_Namespace(ns);
		}
	}
	
	void _Namespace(BaseNamespaceDeclarationSyntax ns) {
		_analyze.AnalyzeType(ns);
		
		foreach (var m2 in ns.Members) {
			switch (m2) {
			case NamespaceDeclarationSyntax ns2:
				_Namespace(ns2);
				break;
			case BaseTypeDeclarationSyntax type:
				_Type(type);
				break;
			case DelegateDeclarationSyntax del:
				_DocComments(del);
				break;
			default:
				throw new Exception("not type or namespace: " + m2);
			}
		}
		
		_analyze.AnalyzeType(null);
	}
	
	void _Type(BaseTypeDeclarationSyntax type) {
		if (!_DocComments(type)) return;
		if (type is TypeDeclarationSyntax td) {
			
			//remove some attributes
			foreach (var al in td.AttributeLists) {
				if (al.ToString() is "[ComVisible(true)]") _SkipSource(al.Span);
			}
			
			foreach (var m in td.Members) {
				if (m is BaseTypeDeclarationSyntax t2) _Type(t2);
				else _DocComments(m);
			}
		} else if (type is EnumDeclarationSyntax ed) {
			foreach (var m in ed.Members) {
				_DocComments(m, _semo.GetDeclaredSymbol(m));
			}
		} else throw new Exception("type: " + type);
		
		_analyze.AnalyzeType(null);
	}
	
	//returns true if public
	bool _DocComments(MemberDeclarationSyntax m, ISymbol sym = null) {
		//is public?
		if (sym == null) { //else enum member
			sym = m is BaseFieldDeclarationSyntax f ? _semo.GetDeclaredSymbol(f.Declaration.Variables[0]) : _semo.GetDeclaredSymbol(m);
			if (sym == null) { _Warning("Declared symbol not found", m); return false; }
			if (!sym.HasPublicResultantVisibility()) return false;
			
			if (m is BaseTypeDeclarationSyntax btd) _analyze.AnalyzeType(btd);
		}
		
		var lt = m.GetLeadingTrivia();
		var trivia = lt.LastOrDefault(o => o.IsKind(SyntaxKind.SingleLineDocumentationCommentTrivia));
		var span = trivia.Span;
		bool autoInheritdoc = false;
		if (trivia.RawKind == 0) {
			autoInheritdoc = _IsEligibleForAutomaticInheritdoc(sym);
			if (!autoInheritdoc) return true;
			//tested: DocFX does not get method documentation from overriden base method or implemented interface method.
		} else if (span.Length < 10) return true; //length 2 if just ///
		
		var sdoc = autoInheritdoc ? "" : _code[(span.Start + (_code[span.Start] == ' ' ? 1 : 0))..span.End];
		_currentSym = sym;
		_analyze.AnalyzeDoc(sdoc, sym);
		
		if (span.Length > 0) {
			_SkipSource(span.Start - 3, span.End);
		} else {
			int i = m.SpanStart;
			_SkipSource(i, i);
			_bFile.AppendLine();
		}
		
		//print.it($"<><c brown>{AuDocs.VsGoto(sym)}<>");
		
		string sxml;
		if (autoInheritdoc || sdoc.Contains("<inheritdoc")) {
			sxml = sym.GetDocumentationComment(_compilation, expandIncludes: true, expandInheritdoc: true).FullXmlFragment;
			
			//inherited XML now is without newlines between block tags. Restore.
			if (0 != _rxFixInherited.Replace(sxml, "$1\n$3", out sxml)) {
				//print.it($"<><c brown>{sym}<>");
				//print.it(sxml);
			}
			if (0 != _rxFixInheritedBr.Replace(sxml, "$1\n", out sxml)) {
				//print.it($"<><c brown>{sym}<>");
				//print.it(sxml);
			}
		} else { //faster without GetDocumentationComment, which calls GetDocumentationCommentXml and then creates DocumentationComment, which parses XML again
			sxml = sym.GetDocumentationCommentXml(expandIncludes: true);
		}
		
		if (sxml.Starts("<!-- Badly formed XML comment ignored")) { //eg EFileInfo.kind (record) if <param> text empty (add space to avoid this warning)
			print.it(sxml);
			return true;
		}
		
		//remove indentation added by GetDocumentationCommentXml etc
		_rxIndentation ??= new(@"(?>\n) +");
		if (!sxml.Starts("<doc>") && _rxIndentation.Match(sxml, 0, out string si)) {
			if (si.Length is not (5 or 6)) throw new InvalidOperationException(); //\n and 4-5 spaces
			_rxIndentation2 ??= new(@"(?m)^     ?(?=[^ ])");
			sxml = _rxIndentation2.Replace(sxml, "");
			//print.it("-----");
			//print.it(sxml);
		}
		//print.it(sxml);
		
		_b.Clear();
		
		var xr = XElement.Parse(sxml, LoadOptions.PreserveWhitespace);
		
		void _Typeparam(ImmutableArray<ITypeParameterSymbol> a) {
			foreach (var p in a) {
				if (xr.Elem("typeparam", "name", p.Name) is XElement x) _Append(x);
			}
		}
		void _Param(ImmutableArray<IParameterSymbol> a) {
			foreach (var p in a) {
				var x = xr.Elem("param", "name", p.Name);
				if (x == null || _IsXElementWithoutValue(x)) { //if enum, add enum members. Useful for AI.
					if (p.Type is INamedTypeSymbol ptype && ptype.IsEnumType()) {
						var mn = ptype.MemberNames;
						if (!mn.TryGetNonEnumeratedCount(out int n)) throw null;
						if (n <= 16) {
							x ??= new("param", new XAttribute("name", p.Name));
							x.Value = $"Enum: {string.Join(", ", mn)}.";
							//bool isFlags = ptype.GetAttributes().Any(a => a.AttributeClass?.ToDisplayString() == "System.FlagsAttribute");
							//x.Value = $"Enum{(isFlags ? " (flags)" : "")}: {string.Join(", ", mn)}."; //rejected. Most parameters are named `flags` etc.
						}
					}
				}
				if (x == null || !_Append(x)) {
					_analyze.MissingParam(p, x);
				}
			}
		}
		
		//add only parameters of this symbol (ignore inherited)
		if (sym is INamedTypeSymbol nt) {
			if (nt.IsGenericType) _Typeparam(nt.TypeParameters);
		} else if (sym is IMethodSymbol ims) {
			if (ims.IsGenericMethod) _Typeparam(ims.TypeParameters);
			_Param(ims.Parameters);
		} else if (sym is IPropertySymbol ips && ips.IsIndexer) {
			_Param(ips.Parameters);
		}
		
		int nSummary = 0, nRemarks = 0, nExample = 0, nReturns = 0, nValue = 0; _hsException.Clear(); _hsSeealso.Clear(); //ignore inherited duplicates
		foreach (var x in xr.Elements()) {
			var tag = x.Name.LocalName;
			
			if (sym.Kind is SymbolKind.Field && sym.ContainingType.TypeKind is TypeKind.Enum) {
				if (tag != "summary") _Warning($"Enum member with <{tag}>. Only <summary> will be used.", sym);
			}
			
			switch (tag) {
			case "param" or "typeparam":
				break;
			case "summary":
				if (nSummary++ == 0) _Append(x);
				break;
			case "remarks":
				if (nRemarks++ == 0) _Append(x);
				break;
			case "example":
				if (nExample++ == 0) _Append(x);
				break;
			case "returns":
				if (nReturns++ == 0) _Append(x);
				//if (sym is not IMethodSymbol) _Warning("<returns> for a non-method.", x); //it's OK, for properties DocFX interprets it as <value>
				break;
			case "value":
				if (nValue++ == 0) _Append(x);
				break;
			case "exception":
				if (_hsException.Add(x.Attr("cref"))) _Append(x, true);
				break;
			case "seealso":
				if (_hsSeealso.Add(x.Attr("cref"))) _Append(x, true);
				break;
			case "inheritdoc":
				if (!autoInheritdoc) _Warning("Non-expanded <inheritdoc>. Try to fully qualify a parameter type.", sxml);
				continue;
			case "exclude":
				_Warning("Use [NoDoc] instead.", x);
				//_b.Append("<exclude/>");
				break;
			default:
				_Warning("unsupported tag", x);
				continue;
			}
		}
		
		sxml = _b.ToString();
		sdoc = _rxLineStart.Replace(sxml, "/// ");
		//print.it(sdoc);
		_bFile.Append(sdoc);
		
		_analyze.AnalyzeDoc2(xr, sxml);
		
		return true;
		
		static bool _IsXElementWithoutValue(XElement x) => x.IsEmpty || x.FirstNode == null || (!x.HasElements && string.IsNullOrWhiteSpace(x.Value));
		
		bool _Append(XElement xp, bool hasCref = false) {
			if (hasCref) _Cref(xp);
			
			if (_IsXElementWithoutValue(xp)) {
				_b.AppendLine(xp.ToString());
				return false;
			}
			
			//catch some mistakes of using HTML blocks in text that will be parsed by Markdig
			bool hasParaNote = false;
			foreach (var x in xp.Elements()) {
				var tag = x.Name.LocalName;
				switch (tag) {
				case "b" or "i" or "br" or "a" or "see" or "c" or "google" or "ms" or "sqlite":
					break;
				case "code":
					break;
				case "note" or "para":
					//if <note> in param, in intellisense it is displayed as simple text without NOTE etc in the same line. Instead use <para>NOTE: text</para>, and here replace with <note type="note">Text</note>.
					if (tag[0] == 'n') {
						if (xp.Name.LocalName is "param" or "typeparam" or "summary") _Warning("<note> in param or summary. Bad for intellisense. Use <para>NOTE: Text</para>. The NOTE is text for note type attribute, and can be any uppercase text.", xp);
					} else if (x.FirstNode is XText t1 && t1 is not XCData) {
						var s2 = t1.Value;
						if (s2.Contains(':') && s2.RxMatch(@"\s*([A-Z]+):\s+((?s).+)", out var m2)) {
							t1.Value = m2[2].Value;
							x.Name = "note";
							x.SetAttributeValue("type", m2[1].Value.Lower());
						}
					}
					_EnsureSeparatedWithEmptyLine(x, false); _EnsureSeparatedWithEmptyLine(x, true); //prevent joining with the adjacent <p> etc
					x.AddFirst("\n\n"); x.Add("\n\n"); //enable parsing markdown inside (don't interpret it as a HTML block)
					hasParaNote = true;
					break;
				case "list":
					break;
				case "table" or "div" or "h3" or "h4" or "h5" or "h6" or "ul" or "ol":
					_AssertLine(x, false);
					_EnsureSeparatedWithEmptyLine(x, true); //after a HTML block need an empty line to turn on markdown parsing
					var s1 = x.ToString();
					if (0 != (1 & _rxEmptyLine.FindAllG(s1, 0).Count())) _Warning("A HTML block element contains odd count of empty lines. Possibly will be incorrectly parsed markdown.", s1);
					break;
				default:
					//print.it(x.Name.LocalName, sym);
					_Warning("Please add this tag to the switch block: " + tag, xp);
					break;
				}
			}
			
			bool hasC = false;
			foreach (var x in xp.Descendants()) {
				var tag = x.Name.LocalName;
				switch (tag) {
				case "see":
					_Cref(x);
					break;
				case "google" or "ms" or "sqlite":
					x.Name = "a";
					var site = tag[0] switch { 'm' => "+site:microsoft.com", 's' => "+site:sqlite.org", _ => "" };
					x.SetAttributeValue("href", $"https://www.google.com/search?q={System.Net.WebUtility.UrlEncode(x.Value)}{site}");
					break;
				case "c":
					if (x.FirstNode is XCData) break;
					x.ReplaceAll(new XCData(x.ToString()));
					hasC = true;
					break;
				case "code":
					_AssertLine(x, false);
					_AssertLine(x, true);
					//replace <code> -> <pre>, and Base64-encode.
					//	Markdig skips <pre>...</pre>, even if contains empty lines.
					//	DocFX will not replace with <pre><code> which then would be parsed by the DocFX code highlighter at run time.
					//	When postprocessing, we'll set colors using Roslyn.
					string code = null;
					switch (x.FirstNode) {
					case XCData xx: code = xx.Value; break;
					case XText xx: code = xx.Value; break; //must be without html entities
					default: print.it(x.FirstNode.NodeType); continue;
					}
					x.Name = "pre";
					x.Value = "%%" + Convert.ToBase64String(Encoding.UTF8.GetBytes(code.TrimStart("\r\n"))) + "%%";
					break;
				case "seealso":
					_Warning("<seealso> in text.", x);
					break;
				case "list":
					_Warning("Don't use <list>. Instead use <ul> or <ol> or markdown '- item' or '<br/>• item'.", x);
					break;
				}
			}
			
			uint escaped = 0;
			foreach (var t in xp.DescendantNodes().OfType<XText>()) {
				if (t is XCData) continue;
				var v = t.Value;
				//workaround for DocFX bug: removes space between two tags. In some cases breaks line instead. Tested: currently no such text in cookbook and markdown articles.
				if (v == " ") {
					//print.it("<>" + t.Parent.ToString().RxReplace(@"/\w+> <\w+", "<bc yellow>$0<>"));
					t.Value = "\u202F"; //narrow non-breaking space; will replace with normal space when postprocessing
					continue;
				}
				//escape some markdown inline characters
				if (v.Contains('*')) { escaped |= 1; v = v.Replace("*", ",.1.,"); }
				if (v.Contains('_')) { escaped |= 2; v = v.Replace("_", ",.2.,"); }
				if (v.Contains('`')) { escaped |= 4; v = v.Replace("`", ",.3.,"); }
				if (v.Contains('\\') && _rxLineBreak.Replace(v, ",.4.,", out v) > 0) escaped |= 8; //escape \char but not \endofline
				if (escaped > 0) t.Value = v;
			}
			
			//print.it("---");
			var sx = xp.ToString();
			//print.it(sx);
			int from = sx.IndexOf('>') + 1, to = sx.LastIndexOf('<');
			//print.it(from, to);
			var s = sx[from..to];
			//print.it(s);
			_b.Append(sx, 0, from);
			
			//list items should start with <br/>• to display in intellisense as list. Else would need <list ...><item><description>...</description></item>...
			//	note: by default VS saves not as UTF-8. To make it save as UTF-8, create or edit file ".editorconfig" in the solution dir, and add this:
			//		[*]
			//		charset = utf-8
			if (0 == _rxLi.Replace(s, "$1-", out s))
				if (xp.Name.LocalName is "param" or "returns" or "summary" && _rxLi2.IsMatch(s)) _Warning("Markdown list items in <summary>, <param> and <returns> should start with <br/>• (Alt+L) to display correctly in intellisense.", s);
			
			s = Markdig.Markdown.ToHtml(s, _pipeline);
			
			//if (s.Starts("<p>") && s.Ends("</p>\n") && s.Find("<p>", 3) < 0) s = s[3..^5]; //no, need <p> for CSS white-space: pre-line
			if (hasParaNote) s = _rxParaNote.Replace(s, m => m.Value.Replace("<p>", "").Replace("</p>", "")); //remove <p> from <para> and <note>
			if (hasC) s = _rxC.Replace(s, "$1");
			if (0 != (escaped & 1)) s = s.Replace(",.1.,", "*");
			if (0 != (escaped & 2)) s = s.Replace(",.2.,", "_");
			if (0 != (escaped & 4)) s = s.Replace(",.3.,", "`");
			if (0 != (escaped & 8)) s = s.Replace(",.4.,", "\\");
			
			_b.Append(s);
			_b.Append(sx, to, sx.Length - to);
			_b.Append('\n');
			
			return true;
		}
		
		//from Roslyn method GetDocumentationComment
		static bool _IsEligibleForAutomaticInheritdoc(ISymbol symbol) {
			if (symbol.IsOverride) return true;
			if (symbol.ContainingType is null) return false;
			if (symbol.Kind is SymbolKind.Method or SymbolKind.Property or SymbolKind.Event) return symbol.ExplicitOrImplicitInterfaceImplementations().Any();
			return false;
		}
	}
	
	void _Cref(XElement x) {
		string s = x.Attr("cref");
		if (s == null) return; //href
		//print.it(s);
		var kind = s[0];
		bool removeParameters = false, overload = false;
		
		//restore cref modified by GetDocumentationComment
		if (s.FindAny("`([") < 0) { //simple. Also GetFirstSymbolForDeclarationId can't find indexers where s ends with ".Item"
			s = s[2..];
		} else {
			var syms = DocumentationCommentId.GetSymbolsForDeclarationId(s, _compilation);
			if (syms.Length == 0) {
				_Warning("Can't find cref symbol " + s, x); //none
				s = s[2..].Replace("@", ""); //never mind: should replace ``1 etc for generic. Difficult etc.
				removeParameters = kind is 'M' or 'P'; //method, indexer
			} else {
				var sym = syms[0];
				s = sym.ToDisplayString(_formatCref); //same as ToString except: tuple (...) -> ValueTuple<...>. DocFX does not support tuple (...).
				
				removeParameters = sym is IMethodSymbol || (sym is IPropertySymbol ips && ips.IsIndexer);
				overload = removeParameters && sym.Name == _currentSym.Name && sym.ContainingType == _currentSym.ContainingType;
				//don't remove parameters if sym and _currentSym are overloads of the same method or indexer
			}
			s = s.Replace('<', '{').Replace('>', '}');
			
			if (removeParameters) {
				_rxParams ??= new(@"\bparams ");
				s = _rxParams.Replace(s);
			}
		}
		x.SetAttributeValue("cref", s);
		
		//set link text if DocFX would do it incorrectly
		if (!overload && x.IsEmpty && x.Name.LocalName.Starts("see")) {
			//print.it(s);
			int from = 0, to = s.Length, i; string append = null;
			foreach (var v in _auNamespaces) if (s.Starts(v)) { from = v.Length; break; }
			if (removeParameters) {
				switch (kind) {
				case 'M':
					i = s.IndexOf('(');
					if (i > 0) to = i;
					break;
				case 'P':
					i = s.IndexOf('[');
					if (i > 0) { to = i; append = "[]"; }
					break;
				}
			}
			s = s[from..to];
			s = s.Replace('{', '<');
			s = s.Replace('}', '>');
			s += append;
			//print.it(s);
			x.Value = s;
			if (x.Name.LocalName == "seealso") { //DocFX ignores value. Let's insert it as <seealso href> for postprocessing.
				_b.AppendLine($"""<seealso href="https://text">{Convert2.HexEncode(Encoding.UTF8.GetBytes(s))}</seealso>""");
			}
		}
	}
	
	SymbolDisplayFormat _formatCref = new SymbolDisplayFormat(
		globalNamespaceStyle: SymbolDisplayGlobalNamespaceStyle.Omitted,
		typeQualificationStyle: SymbolDisplayTypeQualificationStyle.NameAndContainingTypesAndNamespaces,
		genericsOptions: SymbolDisplayGenericsOptions.IncludeTypeParameters,
		memberOptions: SymbolDisplayMemberOptions.IncludeContainingType | SymbolDisplayMemberOptions.IncludeParameters | SymbolDisplayMemberOptions.IncludeExplicitInterface,
		parameterOptions: SymbolDisplayParameterOptions.IncludeType | SymbolDisplayParameterOptions.IncludeParamsRefOut,
		delegateStyle: SymbolDisplayDelegateStyle.NameAndSignature,
		extensionMethodStyle: SymbolDisplayExtensionMethodStyle.Default,
		propertyStyle: SymbolDisplayPropertyStyle.NameOnly,
		miscellaneousOptions: SymbolDisplayMiscellaneousOptions.UseSpecialTypes | SymbolDisplayMiscellaneousOptions.EscapeKeywordIdentifiers | SymbolDisplayMiscellaneousOptions.ExpandValueTuple | SymbolDisplayMiscellaneousOptions.IncludeNullableReferenceTypeModifier
		);
	
	void _SkipSource(int from, int to) {
		_bFile.Append(_code, _filePos, from - _filePos);
		_filePos = to;
	}
	
	void _SkipSource(TextSpan span) => _SkipSource(span.Start, span.End);
	
	/// <summary>prints warning if x is not at the start or end of a line</summary>
	void _AssertLine(XElement x, bool end) {
		var n = end ? x.NextNode : x.PreviousNode;
		if (n == null) return;
		if (n is XText t && n is not XCData) {
			var v = t.Value;
			if (end ? v.Starts("\n") : v.Ends("\n")) return;
		}
		//if(end) x.AddAfterSelf("\n"); else x.AddBeforeSelf("\n");
		var tag = x.Name.LocalName;
		_Warning(end ? $"</{tag}> must end a line." : $"<{tag}> must start a line.", x.Parent);
	}
	
	void _EnsureSeparatedWithEmptyLine(XElement x, bool end) {
		var n = end ? x.NextNode : x.PreviousNode;
		if (n == null) return;
		if (n is XText t && n is not XCData) {
			var v = t.Value;
			if (end ? v.Starts("\n\n") : v.Ends("\n\n")) return;
			if (v == "\n") if ((end ? n.NextNode : n.PreviousNode) == null) return;
			if (end ? v.Starts("\n") : v.Ends("\n")) {
				t.Value = end ? "\n" + v : v + "\n";
				return;
			}
		}
		_AssertLine(x, end);
	}
	
	void _Warning(string warning, object text) {
		print.warning($"<_>{warning}</_>\r\n\tMember: {LaGoto(_currentSym)} in {_semo.SyntaxTree.FilePath}\r\n\tText: <_>{text}</_>", 1);
	}
	
	public static string LaGoto(ISymbol sym) {
		var loc = sym.Locations[0];
		return $@"<open C:\code\au\Au{loc.SourceTree.FilePath}||{loc.SourceSpan.Start}>{sym}<>";
	}
	
	//static readonly PortableExecutableReference[] s_refs = Au.Compiler.MetaReferences.DefaultReferences.Values.ToArray();
	//static readonly CSharpParseOptions s_parseOpt = new CSharpParseOptions(LanguageVersion.Preview, DocumentationMode.Parse);
	//static readonly CSharpCompilationOptions s_compOpt = new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary, allowUnsafe: true);
}


================================================
FILE: Scripts/@Au docs/LA docs doc-html.db.cs
================================================
/// Creates doc-html.db from files created by script "Au docs". It will be used in LA Read panel.
/// Executed by `Au docs.cs`.

/*/ testInternal Au; nuget html\HtmlAgilityPack; /*/

//#define IEWB

using HtmlAgilityPack; //tested: AngleSharp slower

if (script.testing) print.clear();
bool dev = !true;

//Debug_.MemorySetAnchor();
if (!GC.TryStartNoGCRegion(2_000_000_000)) throw null; //makes faster > 2 times

const string c_rootDir = @"C:\Temp\Au\DocFX\site\";
string[] subDirs = ["api", "articles", "editor", "cookbook"]; //note: don't add the root index.html (let users open it in their web browser)

var dbFile = folders.ThisAppBS + "doc-html.db";
sqliteStatement dbInsert;

filesystem.delete(dbFile);
using (var db = new sqlite(dbFile)) {
	db.Execute("CREATE TABLE doc (name TEXT PRIMARY KEY, text TEXT)");
	using var dbInsert_ = dbInsert = db.Statement("INSERT INTO doc VALUES (?, ?)");
	using var dbTrans = db.Transaction();
	//perf.first();
	_Convert();
	_AddOtherFiles();
	//perf.nw();
	dbTrans.Commit();
	db.Execute("VACUUM");
}
filesystem.copyTo(dbFile, @"C:\code\Au.Editor", FIfExists.Delete);

print.scrollToTop();
//Debug_.MemoryPrint();

void _Convert() {
	List<_FileHtml> a = [];
	foreach (var subDir in subDirs) {
		foreach (var f in filesystem.enumFiles(c_rootDir + subDir, "*.html", FEFlags.AllDescendants | FEFlags.NeedRelativePaths)) {
			var name = f.Name[1..];
			if (name is "toc.html") continue;
			a.Add(new() { name = $"{subDir}/{name.Replace('\\', '/')}", html = f.FullPath });
		}
	}
	//perf.next();
	if (dev) {
		foreach (var f in a) {
			f.html = _ProcessHtml(f.html, f.name);
		}
	} else {
		Parallel.ForEach(a, f => { //with no-GC region 3 times faster, else 20% faster
			f.html = _ProcessHtml(f.html, f.name);
		});
	}
	//perf.next();
	foreach (var f in a) {
		_AddRow(f.name, f.html);
	}
}

void _AddRow(string name, object data) {
	dbInsert.BindAll(name, data).Step();
	dbInsert.Reset();
}

void _AddOtherFiles() {
	foreach (var f in filesystem.enumFiles(c_rootDir + "styles")) {
		var path = f.FullPath;
		object data = pathname.getExtension(f.Name) switch { ".css" => filesystem.loadText(path), ".eot" => filesystem.loadBytes(path), _ => null };
		
#if IEWB
		if (f.Name == "docfx.vendor.min.css") { //fix the hidden scrollbar issue
			var s1 = (string)data;
			if (0 == s1.RxReplace("""@-ms-viewport\s*\{\s*width:\s*device-width\s*}""", "", out s1, 1)) throw null;
			data = s1;
		}
#endif
		
		if (data != null) _AddRow($"styles/{f.Name}", data);
		//if (data == null) print.it(f.Name);
	}
	
	_AddRow("styles/la.css", """
h1 { background-color: #9ACD32 !important; margin: 0 -2px 8px -2px !important; padding: 1px 2px 3px 2px !important; }
h1, h2, h3 { font-size: 110% !important; }
h4, h5 { font-size: 100% !important; }
div.col-md-12,div.container-fluid { padding-left: 2px !important; padding-right: 2px !important; }
td, th { white-space: normal !important; word-wrap: break-word; }
pre { word-wrap: normal !important; }
""");
	
#if IEWB
	_AddRow("styles/la.js", """
function ancestorOrThis(el, tag) {
    while (el && el.nodeName !== tag) el = el.parentElement;
    return el;
}

document.addEventListener('contextmenu', function(e) {
	e.preventDefault(); 
	var contextFlag = 0; // 0: no selection, 1: selection, 2: inside <pre> (and no selection)

	var selectedText = window.getSelection().toString();
	
	if (selectedText.length > 0) {
		contextFlag = 1;
	} else {
		var preElement = ancestorOrThis(e.target, 'PRE');
		if (preElement && preElement.parentElement.className !== 'codewrapper') {
			contextFlag = 2;
			selectedText = preElement.textContent;
		}
	}

	window.external.ShowContextMenu(e.clientX, e.clientY, contextFlag, selectedText);
	return false;
});

document.addEventListener('click', function(e) {
	var targetElement = e.target;

	var aElement = ancestorOrThis(e.target, 'A');
	if (aElement && aElement.classList.contains('nuget')) {
		e.preventDefault();
		window.external.NugetLinkClicked(targetElement.textContent);
	}
});
""");
#endif
	
	foreach (var f in filesystem.enumFiles(c_rootDir + "images", "*.png")) {
		_AddRow($"images/{f.Name}", filesystem.loadBytes(f.FullPath));
	}
}

string _ProcessHtml(string path, string uri) {
	if (dev) print.clear();
	
	var doc = new HtmlDocument();
	doc.Load(path, Encoding.Default);
	var h = doc.DocumentNode.Element("html");
	var head = h.Element("head");
	var body = h.Element("body");
	var relPath = head.Element("link").GetAttributeValue("href", ""); relPath = relPath[..relPath.FindNot("./")];
	
	List<HtmlNode> are = [];
	List<HtmlAttribute> ara = [];
	void _Remove(HtmlNode n) { if (n != null) are.Add(n); }
	void _RemoveAttr(HtmlAttribute n) { if (n != null) ara.Add(n); }
	
	foreach (var v in head.Elements("meta")) {
		if (v.ChildAttributes("property").Any()) _Remove(v);
	}
	
	_Remove(head.SelectSingleNode("link[@rel='shortcut icon']"));
	_Remove(head.SelectSingleNode("meta[@name='title']"));
	
	head.AppendChild(HtmlNode.CreateNode($"""<link rel="stylesheet" href="{relPath}styles/la.css">"""));
	head.AppendChild(doc.CreateTextNode("\n"));
	
	_Remove(body.SelectSingleNode(".//header"));
	_Remove(body.SelectSingleNode(".//div[@class='sidenav hide-when-search']"));
	if (body.SelectSingleNode(".//div[@class='article row grid-right']") is { } div2) div2.RemoveClass();
	
	if (h.SelectNodes("//script") is { } scripts)
		foreach (var v in scripts) _Remove(v);
	
#if IEWB
	body.AppendChild(HtmlNode.CreateNode($"""<script type="text/javascript" src="{relPath}styles/la.js"></script>"""));
#endif
	body.AppendChild(doc.CreateTextNode("\n"));
	
	foreach (var vn in body.Descendants("div")) {
		//if (!vn.HasChildNodes) print.it(vn.OuterHtml);
		if (!vn.HasChildNodes) _Remove(vn);
	}
	
	foreach (var v in are) v.Remove();
	
	if (uri.Starts(@"api")) {
		foreach (var vn in body.Descendants())
			if (vn.NodeType is HtmlNodeType.Element) {
				foreach (var va in vn.GetAttributes()) {
					switch (va.Name) {
					case "data-uid":
					case "id" when vn.Name is "h1" or "h3" or "h4" or "h5" or "h6" or "a" or "td": _RemoveAttr(va); continue;
					case "id" when vn.Name is "h2": continue; //overload
					}
					
					//if (va.Name is not ("class" or "href" or "style") && va.Value.Length > 20) print.it(vn.Name, va.Name, va.Value);
				}
			}
	}
	
	foreach (var va in body.GetDataAttributes()) _RemoveAttr(va);
	
	foreach (var v in ara) v.Remove();
	
#if IEWB
	//IE displays too wide tabs in pre code, and does not support CSS tab-size. Workaround: replace tabs with spaces.
	if (body.SelectNodes(".//pre[not(parent::div[@class='codewrapper'])]//code") is { } preCodes) {
		foreach (var v in preCodes) {
			var s = v.InnerHtml;
			if (s.Contains('\t')) {
				s = s.RxReplace(@"(?m)^\t+", m => new string(' ', m.Length * 4));
				v.InnerHtml = s;
			}
		}
	}
#endif
	
	//links that LA handles
	if (uri.Starts("cookbook") && body.SelectNodes(".//span[@title='Paste the underlined text in menu > Tools > NuGet']") is { } nugetLinks) {
		foreach (var v in nugetLinks) {
			v.Attributes.RemoveAll();
			v.Name = "a";
#if IEWB
			v.AddClass("nuget");
#else
			v.SetAttributeValue("href", "nuget:" + v.InnerText);
#endif
		}
	}
	
	//remove the LA window image
	if (uri == "editor/Application.html") {
		body.SelectSingleNode(".//p/img").Remove();
	}
	
	if (dev) {
		print.it(head.OuterHtml);
		print.it(body.OuterHtml.RxReplace(@"\R(?:\R\h*)+\R", "\n\n"));
		print.scrollToTop();
		if (!dialog.showYesNo("Continue", path[c_rootDir.Length..])) Environment.Exit(0);
	}
	
	return doc.DocumentNode.OuterHtml;
}

class _FileHtml {
	public string name, html;
}


================================================
FILE: Scripts/@Au docs/LA docs toc.json.cs
================================================
/// Creates toc.json from files created by script "Au docs". It will be used in LA Help panel.
/// Executed by `Au docs.cs`.

using System.Text.Json.Nodes;
using System.Xml.Linq;

if (script.testing) print.clear();

//HashSet<string> hsDbNames = [];
//using (var db = new sqlite(folders.ThisAppBS + "doc-ai.db", SLFlags.SQLITE_OPEN_READONLY)) {
//	using var sta = db.Statement("SELECT name FROM doc");
//	while (sta.Step()) {
//		hsDbNames.Add(sta.GetText(0));
//	}
//}

var root = new JsonArray();
_Cookbook();
_Api(@"C:\Temp\Au\DocFX\site\api\toc.json");
_Other(@"C:\Temp\Au\DocFX\site\articles", "Articles");
_Other(@"C:\Temp\Au\DocFX\site\editor", "Editor");
var json = root.ToJsonString(new() { WriteIndented = true, Encoder = System.Text.Encodings.Web.JavaScriptEncoder.UnsafeRelaxedJsonEscaping });
filesystem.saveText(folders.ThisAppBS + "toc.json", json);
filesystem.saveText(@"C:\code\Au.Editor\toc.json", json);

void _Cookbook() {
	var xr = XmlUtil.LoadElem(folders.ThisAppBS + @"..\Cookbook\files.xml");
	
	var jdk = new JsonObject();
	jdk.Add("name", "Cookbook");
	root.Add(jdk);
	_AddItems(xr, jdk);
	
	static void _AddItems(XElement xp, JsonObject jp) {
		var ja = new JsonArray();
		jp.Add("items", ja);
		foreach (var x in xp.Elements()) {
			string type = x.Name.LocalName, name = x.Attr("n");
			if (name[0] == '-' || type == "o") continue;
			var j = new JsonObject();
			ja.Add(j);
			if (type == "d") {
				j["name"] = name;
				_AddItems(x, j);
			} else {
				j["name"] = name[..^3];
			}
		}
	}
}

void _Api(string sourcePath) {
	var json = filesystem.loadText(sourcePath);
	var j1 = JsonNode.Parse(json) as JsonObject;
#if !true
	foreach (JsonObject ns in j1["items"].AsArray()) {
		var j2 = new JsonObject();
		root.Add(j2);
		_Tidy(ns, j2, 1);
	}
#else
	var j2 = new JsonObject();
	j2["name"] = "Library API";
	root.Add(j2);
	_Tidy(j1, j2, 0);
#endif
	
	static void _Tidy(JsonObject j1, JsonObject j2, int level) {
		string name = null, href = null, kind = null;
		foreach (var (k, v) in j1) {
			switch (k) {
			case "name":
				name = (string)v;
				break;
			case "href":
				if (level == 1) {
					kind = "Namespace";
				} else if (level is 2 or 3) {
					href = (string)v;
					var file = @"C:\Temp\Au\DocFX\site\api\" + href;
					if (!filesystem.exists(file).File) throw new AuException(href);
					var html = filesystem.loadText(file);
					
					//kind
					if (!html.RxMatch(@"<h1 .+?>(\w+)", 1, out kind)) throw null;
					
					//rename operators to match DB
					if (kind == "Operator") {
						if (name.Starts("operator ")) name = name[9..]; else if (name.Ends(" operator")) name = name[..^9];
					}
					
					//check whether the full name == the DB name
					//if (kind != "Field") {
					//	if (level == 2) {
					//		s = $"{(string)j.Parent.Parent["name"]}.{s}";
					//		//print.it(s);
					//	} else {
					//		var jType = j.Parent.Parent.Parent.Parent;
					//		s = $"{(string)jType.Parent.Parent["name"]}.{(string)jType["name"]}.{s}";
					//	}
					//	if (!hsDbNames.Remove(s)) print.it(s);
					//}
				}
				break;
			case "items" when v is JsonArray { Count: > 0 } ja1:
				var ja2 = new JsonArray();
				if (level == 2) { //remove the member kind level
					foreach (var jk in ja1) {
						_Items(jk["items"].AsArray(), ja2);
					}
				} else {
					_Items(ja1, ja2);
				}
				j2["items"] = ja2;
				
				void _Items(JsonArray ja1, JsonArray ja2) {
					foreach (JsonObject jj1 in ja1) {
						var jj2 = new JsonObject();
						ja2.Add(jj2);
						_Tidy(jj1, jj2, level + 1);
					}
				}
				break;
			}
		}
		
		if (kind != null) j2.Insert(0, "kind", kind);
		if (href != null) j2.Insert(0, "href", href);
		if (name != null) j2.Insert(0, "name", name);
	}
}

void _Other(string dir, string docKind) {
	var jdk = new JsonObject();
	jdk.Add("name", docKind);
	root.Add(jdk);
	_AddItems(dir, jdk);
	
	static void _AddItems(string dir, JsonObject jp, string hrefPath = null) {
		var ja = new JsonArray();
		jp.Add("items", ja);
		foreach (var f in filesystem.enumerate(dir)) {
			string name = f.Name;
			if (!f.IsDirectory) {
				if (!name.Ends(".html")) continue;
				name = f.Name[..^5];
				if (name is "toc" or "index") continue;
			}
			var j = new JsonObject();
			j.Add("name", name);
			ja.Add(j);
			var href = Uri.EscapeDataString(f.Name);
			if (f.IsDirectory) {
				_AddItems(f.FullPath, j, hrefPath + href + "/");
			} else {
				j.Add("href", hrefPath + href);
			}
		}
	}
	
}


================================================
FILE: Scripts/@Au docs/LA menu doc.cs
================================================
/// Generates article "Menu commands" from current LA UI (Panels.Menu).
/// Executed by `Au docs.cs`.

/*/ role editorExtension; testInternal Au.Editor; r Au.Editor.dll; r Au.Controls.dll; /*/

using LA;
using System.Windows.Controls;

//print.clear();
_BuidlDynamicMenus();
string title = "Menu commands";
StringBuilder b = new($"""
---
uid: menu_commands
---

<!-- auto-generated -->

# {title}


""");
foreach (MenuItem v in Panels.Menu.Items) {
	if (v.Role is not MenuItemRole.TopLevelHeader) break;
	_MenuItem(v, 0);
}
//print.it(b);
//print.scrollToTop();
_Save();

void _MenuItem(MenuItem mi, int level) {
	var text = mi.Header.ToString().Replace("_", "");
	b.Append(' ', level * 2).Append("- ").Append(_Escape(text));
	if (mi.IsCheckable) b.Append("  (option)");
	if (mi.ToolTip?.ToString() is string tt) {
		var lines = tt.Lines();
		for (int i = 0; i < lines.Length; i++) {
			var line = lines[i];
			if (i == 0 && line.Starts(text)) continue;
			line = _Escape(line);
			b.AppendLine("  ").Append(' ', (level + 1) * 2).Append(line);
		}
	}
	b.AppendLine();
	if (mi.Role is MenuItemRole.SubmenuHeader or MenuItemRole.TopLevelHeader) {
		foreach (var v in mi.Items.OfType<MenuItem>()) {
			_MenuItem(v, level + 1);
		}
	}
}

static string _Escape(string s) {
	s = s.Replace("<", @"\<");
	if (s.Contains('"')) {
		s = s.RxReplace(@"""(image:|\*icon)""", "`$0`");
		//print.it(s);
	}
	return s;
}

void _BuidlDynamicMenus() {
	var mi = App.Commands["New"].MenuItem;
	FilesModel.FillMenuNew(mi);
}

void _Save() {
	var dir = @"C:\code\au\Other\DocFX\_doc\editor\";
	var menusMd = dir + title + ".md";
	filesystem.saveText(menusMd, b.ToString());
	//var tocYml = dir + "toc.yml"; //added manually
}


================================================
FILE: Scripts/@Au docs/Readme.txt
================================================
Us the latest DocFX. Older version may not support new C# features.
If there are some strange errors, likely DocFX uses wrong SDK version. Try to temporarily rename folders of SDKs that should not be used.

info: we don't use the full text search feature.
	Uses CPU 10-20 s after each page [re]load.
	Results are poorly sorted.
	The Google site search does it much better, and often faster.
	info: To enable it, add "_enableSearch": true in "globalMetadata".


================================================
FILE: Scripts/@WinAPI converter/WinAPI converter.cs
================================================
/// For Windows API declarations LA uses data from:
/// 	Source: https://github.com/microsoft/win32metadata
/// 	Data: https://www.nuget.org/packages/Microsoft.Windows.SDK.Win32Metadata/
/// LA cannot use the .winmd file directly. This script converte it to winapi.db file that will be used by LA.

//#define SMALL

script.setup(debug: true);
print.clear();

HashSet<string> onlyNamespaces = null;
#if SMALL //for testing, convert only some apis, to make smaller and faster
onlyNamespaces = [
	"Foundation",
	"Graphics.Dwm",
	"Graphics.Gdi",
	"Security",
	"System.Com",
	"System.Com.StructuredStorage",
	"System.Console",
	"System.Environment",
	"System.IO",
	"System.Kernel",
	"System.LibraryLoader",
	"System.Memory",
	"System.Ole",
	"System.ProcessStatus",
	"System.Registry",
	"System.Services",
	"System.SystemInformation",
	"System.SystemServices",
	"System.TaskScheduler",
	"System.Threading",
	"System.Variant",
	"System.WinRT",
	"Storage.FileSystem",
	"UI.Accessibility",
	"UI.Controls",
	"UI.Controls.Dialogs",
	"UI.HiDpi",
	"UI.Input",
	"UI.Input.KeyboardAndMouse",
	"UI.Shell",
	"UI.Shell.Common",
	"UI.Shell.PropertiesSystem",
	"UI.WindowsAndMessaging",
	];
#endif

var c = new WinApiConverter();
//perf.first();
c.Convert(onlyNamespaces);
//perf.nw();
_SavePreviewText();
_SaveDatabase();
print.scrollToTop();

void _SavePreviewText() {
	regexp rx1 = new(@"(?m)^");
	
	using var w = File.CreateText(folders.Workspace + @"files\winapi converter results.cs");
	w.WriteLine("/// Created by \"WinAPI converter\" script. For preview/debug only. Delete when no longer needed.\r\n\r\n/*/ noWarnings CS0649,CS8500,CS0618; /*/\r\nunsafe class api : NativeApi {\r\n//.");
	
	bool prevMultiline = false;
	foreach (var (k, v) in c.Result) {
		bool multiline = v.Contains('\n');
		if (multiline != prevMultiline) w.WriteLine(multiline ? "//.." : "//.");
		if (multiline || prevMultiline) w.WriteLine();
		prevMultiline = multiline;
		
		var s = rx1.Replace(v, "\t");
		w.WriteLine(s);
	}
	
	w.WriteLine("}");
	
	//print.it("SAVED");
}

void _SaveDatabase() {
	regexp rx = new(@"(?m)^internal \K(struct|enum|interface|class|static extern|delegate|const|static|record)\b");
	var a = c.Result.Select(o => new _NCK(o.Key, o.Value, _Kind(o.Value))).ToList();
#if !SMALL
	_AddOld(a);
#endif
	
	string dbFile = folders.ThisAppBS + @"winapi.db";
	filesystem.delete(dbFile);
	
	using var d = new sqlite(dbFile);
	using var trans = d.Transaction();
	d.Execute("CREATE TABLE api (name TEXT, code TEXT, kind INTEGER)"); //note: no PRIMARY KEY. Don't need index.
	using var stat = d.Statement("INSERT INTO api VALUES (?, ?, ?)");
	
	foreach (var (name, code, kind) in a.OrderBy(o => o.kind).ThenBy(o => o.name, StringComparer.OrdinalIgnoreCase)) {
		//print.it(kind, name);
		stat.Bind(1, name);
		stat.Bind(2, code);
		stat.Bind(3, (int)kind);
		stat.Step();
		stat.Reset();
	}
	
	trans.Commit();
	d.Execute("VACUUM");
	
	print.it("DONE");
	
	CiItemKind _Kind(string code) {
		if (!rx.Match(code, 0, out string sk)) throw null;
		return sk switch {
			"struct" or "record" => CiItemKind.Structure,
			"enum" => CiItemKind.Enum,
			"interface" => CiItemKind.Interface,
			"class" => CiItemKind.Class,
			"static extern" => CiItemKind.Method,
			"delegate" => CiItemKind.Delegate,
			"const" => CiItemKind.Constant,
			"static" => CiItemKind.Field,
			_ => throw null
		};
	}
}

//From the old database adds APIs that are missing in winmd. Also replaces come incorrect declarations.
void _AddOld(List<_NCK> a) {
	var dNew = a.ToDictionary(o => (name: o.name, kind: o.kind), o => o.code);
	var aOld = _Load(folders.Editor + @"..\Other\Api\winapi.db", true);
	
	foreach (var nck in aOld) {
		var (name, code, kind) = nck;
		if (_GetCode(name, out var s)) {
			if (kind == CiItemKind.Constant && code != s) {
				var st = s.AsSpan(15..18);
				if (st is "int" or "uin" or "sho" or "ush" or "byt" or "sby") {
					int vOld = _ConstIntValue(code), vNew = _ConstIntValue(s);
					if (vOld != vNew) {
						//print.it($"<><bc greenyellow>{name}<>\r\n{code}\r\n{s}");
						if (name is "VARIANT_TRUE" || code.Contains("= null;")) continue; //else error in winmd; mostly because it uses wrong preprocessor symbols, eg for oldest Windows versions or 32-bit.
						if (vOld < 0 && s.Starts("internal const int ") && code.Starts("internal const uint ")) code = code.RxReplace(@"\buint (\w+) = \w+;$", $"int $1 = unchecked((int)0x{vOld:X});");
						int i = a.FindIndex(o => o.name == name);
						a[i] = a[i] with { code = code };
					}
				} else if (st is "lon" or "ulo") { //`uint` in old
					//print.it($"<><bc greenyellow>{name}<>\r\n{code}\r\n{s}");
				} else if (st is "dou" or "flo") {
					//print.it($"<><bc greenyellow>{name}<>\r\n{code}\r\n{s}");
				} else if (st is "str") {
					//print.it($"<><bc greenyellow>{name}<>\r\n{code}\r\n{s}");
				} else {
					print.it($"<><bc greenyellow>{name}<>\r\n{code}\r\n{s}");
				}
			}
			static int _ConstIntValue(string s) {
				int i = s.IndexOf('=') + 1;
				if (s[i] == ' ') i++;
				if (s[i] is '"' or '\'') return 0;
				if (s.Eq(i, "unchecked((int)")) i += 15;
				//if (!s.ToInt(out long r, i)) print.it(s[i..]);
				s.ToInt(out int r, i);
				return r;
			}
			continue;
		}
		if (_AltName()) continue;
		a.Add(nck);
		
		bool _Cont(string s) => dNew.ContainsKey((s, kind));
		bool _ContK(string s, CiItemKind kind) => dNew.ContainsKey((s, kind));
		bool _GetCode(string s, out string code) => dNew.TryGetValue((s, kind), out code);
		//bool _GetCodeK(string s, CiItemKind kind, out string code) => dNew.TryGetValue((s, kind), out code);
		
		bool _AltName() {
			if (name.Ends("__32")) {
				if (_Cont(name.Insert(^4, "W"))) return true;
				if (kind is CiItemKind.Constant) {
					if (_GetCode(name[..^4], out var s1)) {
						if (s1 == code.RxReplace(@"__32\b", "", 1)) return true;
						//print.it($"<>{name}, old32='<c gray>{code}<>', new='<c green>{s1}<>'");
					} //else print.it(name);
				} else {
					if (kind is CiItemKind.Delegate && name is "FARPROC__32" or "NEARPROC__32" or "PROC__32") return true;
					//print.it(kind, name);
				}
			} else {
				if ((int)kind <= 5) { //types, methods
					if (_Cont(name + "W") || _Cont(name + "_W")) return true;
					else if (_A()) return true;
					else if (kind == CiItemKind.Method && _W()) return true;
					else if (kind == CiItemKind.Structure) {
						if (name is "GUID" or "FILE" or "POINT" or "POINTL" or "RECT" or "RECTL" or "SIZE") return true;
					} else if (kind is CiItemKind.Delegate) {
						if (name is "FARPROC" or "NEARPROC" or "PROC") return true;
						if (_Cont("P" + name) || _Cont("LP" + name)) return true;
					}
					//if (kind == CiItemKind.Structure) print.it(name);
					//if (kind == CiItemKind.Delegate) print.it(name);
					//if (kind is CiItemKind.Class or CiItemKind.Interface) print.it(name);
					//if (kind == CiItemKind.Method) print.it(name);
				} else if (kind == CiItemKind.Field) {
					if (_TypeGuid("CLSID_", CiItemKind.Class)) return true;
					if (_TypeGuid("IID_", CiItemKind.Interface)) return true;
					if (_TypeGuid("DIID_", CiItemKind.Interface)) return true;
					//print.it(name);
					
					bool _TypeGuid(string prefix, CiItemKind kind) => name.Starts(prefix) && name[prefix.Length..] is var s && (_ContK(s, kind) || _ContK(s + "W", kind));
				} else { //constant
					if (_A()) return true;
					if (_Cont(name + "W")) return true;
					//print.it(name, code);
					
					//In winmd missing all #define where the value is not a simple number/string/constant. Why they didn't calculate eg `(A | B)` or `(TEXT("text"))`?
				}
				
				bool _A() => name.Ends('A') && (_Cont(name.ReplaceAt(^1.., "W")) || _Cont(name[..^1]));
				bool _W() => name.Ends('W') && _Cont(name[..^1]);
			}
			
			return false;
		}
	}
	
	static _NCK[] _Load(string file, bool old) {
		var a = new List<_NCK>();
		using var db = new sqlite(file, SLFlags.SQLITE_OPEN_READONLY);
		using var stat = db.Statement("SELECT name, code, kind FROM api");
		while (stat.Step()) {
			string name = stat.GetText(0);
			string code = stat.GetText(1);
			var kind = (CiItemKind)stat.GetInt(2);
			a.Add(new(name, code, kind));
		}
		return a.OrderBy(o => o.kind).ThenBy(o => o.name, StringComparer.OrdinalIgnoreCase).ToArray();
	}
}

//Copied from LA project.
enum CiItemKind : sbyte {
	//types
	Class, Structure, Interface, Enum, Delegate,
	//functions, events
	Method, ExtensionMethod, Property, Operator, Event,
	//data
	Field, LocalVariable, Constant, EnumMember,
	//other
	Namespace, Keyword, Label, Snippet, TypeParameter,
	//not in autocomplete. Not in CiUtil.ItemKindNames.
	LocalMethod, Region,
	None
}

record _NCK(string name, string code, CiItemKind kind);


================================================
FILE: Scripts/@WinAPI converter/WinApiConverter+.cs
================================================
using dnlib.DotNet;

partial class WinApiConverter {
	void _AddToDict(string name) {
		_nFiltered++;
		var v = b.ToString();
		if (!Result.TryAdd(name, v)) {
			Result[name] = Result[name] + "\r\n//or\r\n" + v;
			//print.it("<><lc green><>"); print.it(Result[name]);
		}
		
		#region debug
		
		//if (v.Contains(" struct ")) {
		//	//if (v.Contains("_bitfield")) print.it(v);
		//} else {
		//	//if (v.Contains(" enum ")) print.it(v);
		
		//}
		
		#endregion
	}
	
	void _AddSomeTypes() {
		_typedefs.Add("Guid", "Guid"); //defined not in .winmd
		Result["PROPERTYKEY"] = """internal record struct PROPERTYKEY(Guid fmtid, uint pid);"""; //need ctor
		Result["DEVPROPKEY"] = """internal record struct DEVPROPKEY(Guid fmtid, uint pid);"""; //need ctor
		Result["SID_IDENTIFIER_AUTHORITY"] = """internal record struct SID_IDENTIFIER_AUTHORITY(byte v0, byte v1, byte v2, byte v3, byte v4, byte v5);"""; //need ctor
	}
	
	(string type, bool isManaged, ArraySig arraySig) _GetTypeName_Field(FieldDef fd, in _FieldAttributes attr, _TypeDefEtc tdeTopLevel) {
		string fieldTypeWithoutBrackets = fd.FieldType.TypeName;
		bool isArray = fieldTypeWithoutBrackets.Ends("[*]"); if (isArray) fieldTypeWithoutBrackets = fieldTypeWithoutBrackets[..^3];
		Debug.Assert(!(isArray && attr.isConst));
		bool isNestedType = fd.DeclaringType.HasNestedTypes && fd.DeclaringType.NestedTypes.Any(o => o.Name == fieldTypeWithoutBrackets);
		
		var (s, marshal, sNoMarshal) = _GetTypeName(fd.FieldType, out int ptr, false, (attr.isConst, true), tdeTopLevel.attr.bit32, fd, fieldTypeWithoutBrackets, tdeTopLevel);
		
		if (marshal != null) {
			//if (ptr > 0 || attr.isFlexibleArray || _InUnion()) (marshal, s) = (null, sNoMarshal); //no, all nested non-union structs (few, rare) are or should be blittable
			if (ptr > 0 || attr.isFlexibleArray || fd.DeclaringType.IsExplicitLayout || fd.DeclaringType.IsNested) (marshal, s) = (null, sNoMarshal);
			
			if (!marshal.NE()) b.AppendFormat("[MarshalAs(UnmanagedType.{0})] ", marshal);
		}
		
		if (ptr > 0) s = s.PadRight(s.Length + ptr, '*');
		
		return (s, marshal != null, isArray ? (ArraySig)fd.FieldSig.Type : null);
		
		void _PI(params object[] more) {
			print.it(fd.DebugToString(), fd.FieldType.TypeName, s, marshal);
			if (more.Length > 0) print.it($"\t{string.Join(", ", more)}");
		}
		
		//bool _InUnion() {
		//	for (var td = fd.DeclaringType; td != null && td.IsNested; td = td.DeclaringType) {
		//		if (td.IsExplicitLayout) return true;
		//	}
		//	return false;
		//}
	}
	
	string _GetTypeName_Return(MethodDef md, bool inCOM, int bStart, bool bit32) {
		var (s, marshal, sNoMarshal) = _GetTypeName(md.ReturnType, out int ptr, inCOM, (false, inCOM), bit32, md);
		
		if (marshal != null) {
			if (ptr > 0) (marshal, s) = (null, sNoMarshal);
			//if (!(s is "bool")) _PI();
		}
		
		if (!marshal.NE()) b.Insert(bStart, $"[return: MarshalAs(UnmanagedType.{marshal})]\r\n{(inCOM ? "\t" : null)}");
		
		if (ptr > 0) s = s.PadRight(s.Length + ptr, '*');
		
		return s;
		
		void _PI() {
			print.it(md.DebugToString(), md.ReturnType.TypeName, s, marshal);
		}
	}
	
	string _GetTypeName_Param(Parameter p, in _ParamAttributes attr, bool inCOM, bool inDelegate, bool bit32) {
		ParamDef pd = p.ParamDef;
		
		bool isOut = pd.IsOut, isIn = pd.IsIn;
		bool isConst = attr.isConst && !isOut;
		bool allowString = !inDelegate && !isOut && (isConst || !(attr.isArrayPtr || attr.hasMemorySize));
		
		var (s, marshal, sNoMarshal) = _GetTypeName(p.Type, out int ptr, inCOM, (allowString, true), bit32, pd);
		
		//if (isOut && attr.isConst) _PI();
		//if (isConst && ptr > 0) _PI();
		//if (attr.isComOut) _PI();
		//if (attr.isReturn) _PI();
		
		if (attr.isReserved) {
			if (ptr > 0 || (marshal != null && sNoMarshal is "nint" or [.., '*'])) { ptr = 0; s = "nint"; marshal = null; }
			//else if (marshal != null) _PI();
		}
		
		//if (ptr > 0 && !attr.isArrayPtr && !inDelegate && attr.hasMemorySize) {
		//	_PI();
		//}
		
		bool arr = attr.isArrayPtr && ptr > 0 && !inDelegate;
		if (arr) {
			Debug.Assert(ptr > 0);
			if (ptr > 1 && (marshal != null || isOut)) {
				//Let users edit it if need. We can't safely make eg `ref object[]`.
				//Eg we don't know whether it is a pointer to an array or array of pointers, and how to free callee-allocated array memory, etc.
				//_PI(); //not too many
				s = sNoMarshal;
				arr = false;
			} else {
				if (!marshal.NE()) b.AppendFormat("[MarshalAs(UnmanagedType.LPArray, ArraySubType = UnmanagedType.{0})] ", marshal);
				else if (inCOM) b.Append("[MarshalAs(UnmanagedType.LPArray)] ");
				
				ptr--;
			}
			
			if (isOut) b.Append(isIn ? "[In, Out] " : "[Out] "); //for arrays it's recommended to specify these attributes even if it won't change anything; default is [In], although blittable type arrays are pinned and not marshalled.
		} else {
			bool isComOut = ptr == 1 && s == "void*" && !attr.isArrayPtr && !attr.hasMemorySize && (attr.isComOut || (p.MethodSigIndex > 0 && p.Method.Parameters[p.Index - 1].Type.TypeName == "Guid*")); //if the comout attribute is missing, assume it's comout if this param is void** and previous param is Guid*
			
			bool roi = ptr > 0 && !attr.isArrayPtr && !attr.hasMemorySize && !(pd.Attributes.Has(ParamAttributes.Optional) && marshal == null && !isComOut);
			if (roi && ptr == 1 && s is "byte" or "sbyte" or "char" && !pd.DeclaringMethod.Name.String.Like("Var*From*")) roi = false; //rarely pointer to a single value. Tested: ushort and short usually pointer to single value.
			if (roi) ptr--;
			
			if (!marshal.NE()) {
				if (ptr > 0) (s, ptr) = ("nint", 0); //can't marshal if pointer (few, rare)
				else b.AppendFormat("[MarshalAs(UnmanagedType.{0})] ", marshal);
			} else if (isComOut) {
				Debug.Assert(roi && ptr == 0);
				(s, ptr) = ("object", 0);
				b.Append("[MarshalAs(UnmanagedType.IUnknown)] ");
			}
			
			if (roi) {
				b.Append(!isOut ? "in " : isIn ? "ref " : "out ");
			}
		}
		
		if (ptr > 0) s = s.PadRight(s.Length + ptr, '*');
		if (arr) s += "[]";
		
		return s;
		
		void _PI() {
			print.it(pd.DebugToString(), p.Type.TypeName, s, marshal, pd.Attributes);
		}
	}
	
	(string type, string marshal, string sNoMarshal) _GetTypeName(TypeSig t, out int ptr, bool com, (bool @string, bool bstr) allow, bool bit32, object def, string fieldTypeWithoutBrackets = null, _TypeDefEtc tdeTopLevel = null) {
		string s = fieldTypeWithoutBrackets ?? t.TypeName;
		string s0 = s;
		ptr = s.Length; s = s.TrimEnd('*'); ptr -= s.Length;
		
		var fieldStruct = (def as FieldDef)?.DeclaringType;
		bool field = fieldStruct != null;
		
		if (field && fieldStruct.HasNestedTypes && fieldStruct.NestedTypes.Any(o => o.Name == s)) {
			//the field type is a nested type in the same struct
		} else if (_typedefs.TryGetValue(s, out var k)) {
			s = k;
			if (s[^1] == '*' && allow.@string && ptr == 0) {
				if (s == "char*") return ("string", com ? "LPWStr" : "", s);
				Debug.Assert(s0 == "PSTR");
				return ("string", "LPStr", s);
				
				//note: with some (few) functions must be `char*`, not `string`. Eg FreeEnvironmentStringsW. Users will figure out it, because `string` makes no sense there.
			}
		} else {
			var s1 = s;
			s = _SystemTypeNameToKeyword(s);
			if (s != s1) {
				if (s == "bool") return (s, "U1", "byte"); //rare
				if (ptr > 0 && s == "void") { ptr--; s = "void*"; }
			} else {
				switch (s) {
				case "BOOL": return field || com ? (s, null, s) : ("bool", "", "BOOL");
				case "BSTR":
					if (!allow.bstr || (!com && def is ParamDef pd && pd.DeclaringMethod.Name.String is string smn && (smn.Starts("Sys") || smn.Starts("BSTR_")))) return ("char*", null, "char*");
					return ("string", com ? "" : "BStr", "char*");
				case "VARIANT": return ("object", field ? "Struct" : "", s);
				case "IUnknown": return ("object", field ? "" : s, "nint");
				case "IDispatch": return ("object", s, "nint");
				case "DECIMAL": return ("decimal", "", s);
				case "CY": return ("decimal", "Currency", s);
				case "VARIANT_BOOL": return ("bool", "VariantBool", "short");
				case "ITEMIDLIST" when ptr > 0: ptr--; return ("nint", null, "nint");
				}
				
				var nn = t.Namespace + "." + s;
				
				if (bit32 && _types.TryGetValue(nn + "__32", out var v32)) { //if in 32-bit context, prefer 32-bit type
					s += "__32";
					nn += "__32";
				}
				
				if (!_types.TryGetValue(nn, out var v)) { //some non-Ansi types have a field of Ansi type. In few cases it's a metadata bug (can't fix).
					if (_ansiTypes.Remove(nn, out v)) {
						_types.Add(nn, v);
						_Type(v, true);
					} //else _PI(); //few, missing in metadata
				}
				
				if (v != null) {
					if (!v.td.IsValueType) return (s, "", "nint");
					
					if (ptr == 0 && !v.isProcessed) { //need v.isManagedStruct
						_Type(v, true);
					}
					
					if (v.isManagedStruct) return (s, "", s);
				}
			}
		}
		
		return (s, null, s);
		
		void _PI() {
			print.it(def.DebugToString(), s, s0);
		}
	}
	
	static string _SystemTypeNameToKeyword(string s) {
		return s switch {
			"Int32" => "int",
			"UInt32" => "uint",
			"SByte" => "sbyte",
			"Byte" => "byte",
			"Int16" => "short",
			"UInt16" => "ushort",
			"Int64" => "long",
			"UInt64" => "ulong",
			"IntPtr" => "nint",
			"UIntPtr" => "nuint",
			"Double" => "double",
			"Single" => "float",
			"Char" => "char",
			"Boolean" => "bool",
			"String" => "string", //not used in metadata, but our code may use
			//"Decimal" => "decimal", //not used in metadata
			"Void" => "void",
			_ => s
		};
	}
	
	static (bool isUlong, long l, ulong u) _ObjectToLongOrUlong(object o) {
		return o switch {
			int v => (false, v, 0),
			long v => (false, v, 0),
			short v => (false, v, 0),
			sbyte v => (false, v, 0),
			uint v => (true, 0, v),
			ulong v => (true, 0, v),
			ushort v => (true, 0, v),
			byte v => (true, 0, v),
			_ => throw new Exception("bad object type")
		};
	}
	
	string _RenameIfKeyword(string s) {
		if (!_keywordsReserved.Contains(s)) return s;
		return "@" + s;
	}
	HashSet<string> _keywordsReserved = [
		"abstract", "as", "base", "bool", "break", "byte", "case", "catch", "char", "checked", "class", "const",
		"continue", "decimal", "default", "delegate", "do", "double", "else", "enum", "event", "explicit",
		"extern", "false", "finally", "fixed", "float", "for", "foreach", "goto", "if", "implicit", "in",
		"int", "interface", "internal", "is", "lock", "long", "namespace", "new", "null", "object", "operator",
		"out", "override", "params", "private", "protected", "public", "readonly", "ref", "return", "sbyte",
		"sealed", "short", "sizeof", "stackalloc", "static", "string", "struct", "switch", "this", "throw",
		"true", "try", "typeof", "uint", "ulong", "unchecked", "unsafe", "ushort", "using", "virtual", "void",
		"volatile", "while"
	];
	
	void _AppendString(string s) {
		b.Append('"').Append(s.Escape()).Append('"');
	}
	
	//StringBuilder _bPrint = new();
	//void _Print(int level, string name, string color) {
	//	_bPrint.Clear();
	//	_bPrint.Append("<><c ").Append(color).Append("><\a>");
	//	_bPrint.Append(' ', level).Append(name);
	//	_bPrint.Append("</\a><>");
	//	print.it(_bPrint);
	//}
}

static class Ext {
	public static void Start(this StringBuilder t, int level) {
		if (level == 0) t.Clear();
		else t.AppendLine().Append('\t', level);
	}
	
	public static void EndAttributes(this StringBuilder t, int level, int lenBefore) {
		if (t.Length > lenBefore) t.AppendLine().Append('\t', level);
	}
	
	public static string ValueString(this Constant t) {
		var o = t.Value;
		return o as string ?? throw new Exception("not string");
	}
	
	public static string ArgString(this CustomAttribute t, int index) {
		var o = t.ConstructorArguments[index].Value;
		return o as UTF8String ?? throw new Exception("not UTF8String");
	}
	
	public static int ArgInt(this CustomAttribute t, int index) {
		var o = t.ConstructorArguments[index].Value;
		return Convert.ToInt32(o);
	}
	
	public static string ArgGuid(this CustomAttribute t) {
		var a = t.ConstructorArguments;
		var guid = new Guid((uint)a[0].Value, (ushort)a[1].Value, (ushort)a[2].Value, (byte)a[3].Value, (byte)a[4].Value, (byte)a[5].Value, (byte)a[6].Value, (byte)a[7].Value, (byte)a[8].Value, (byte)a[9].Value, (byte)a[10].Value);
		return guid.ToString();
	}
	
	public static string ToKeywordString(this ElementType t) {
		return t switch {
			ElementType.I4 => "int",
			ElementType.U4 => "uint",
			ElementType.I1 => "sbyte",
			ElementType.U1 => "byte",
			ElementType.I2 => "short",
			ElementType.U2 => "ushort",
			ElementType.I8 => "long",
			ElementType.U8 => "ulong",
			ElementType.I => "nint",
			ElementType.U => "nuint",
			ElementType.R8 => "double",
			ElementType.R4 => "float",
			ElementType.String => "string",
			_ => throw new Exception(t.ToString())
		};
	}
	
	public static string DebugToString(this object o) {
		switch (o) {
		case string k: return k;
		case ParamDef k: return $"{_Meth(k.DeclaringMethod)}({k.Name})";
		case MethodDef k: return _Meth(k);
		case TypeDef k: return _Typ(k);
		case FieldDef k: return _Typ(k.DeclaringType) + "." + k.Name;
		}
		throw null;
		
		static string _Meth(MethodDef m) {
			if (m.IsStatic) return m.Name;
			return _Typ(m.DeclaringType) + "." + m.Name;
		}
		
		static string _Typ(TypeDef t) {
			string s = t.Name;
			while ((t = t.DeclaringType) != null) s = t.Name + "." + s;
			return s;
		}
	}
}

//of types (struct, delegate, interface, not enum)
struct _TypeAttributes {
	public bool skip, obsolete, ansi, unicode, bit32, cdeclDelegate, typedef;
	public string guid;
	
	public _TypeAttributes(TypeDef td) {
		foreach (var ca in td.CustomAttributes) {
			string name = ca.AttributeType.Name;
			switch (name.AsSpan(..^9)) {
			case "Obsolete": obsolete = true; break;
			case "Ansi": ansi = true; break;
			case "Unicode": unicode = true; break;
			case "SupportedArchitecture":
				int arch = ca.ArgInt(0);
				if ((arch & 2) == 0) { //no x64
					if ((arch & 1) != 0) bit32 = true; //X86
					else { skip = true; return; } //Arm64
				}
				break;
			case "UnmanagedFunctionPointer":
				if (ca.ArgInt(0) is int cc && cc != 1) {
					if (cc == 2) cdeclDelegate = true;
					else { print.it(cc); skip = true; return; }
				}
				break;
			case "NativeTypedef" or "MetadataTypedef":
				typedef = true;
				break;
			case "Guid":
				guid = ca.ArgGuid();
				break;
			case "StructSizeField":
				//don't use, because many structs don't have this attribute (eg STARTUPINFOEXW). 
				//	Users would assume all struct ctors auto-init the field, and this way make bugs.
				//print.it(ca.ArgString(0), itmd.DebugToString()); //all cbSize
				break;
			case "Documentation"
			or "SupportedOSPlatform"
			or "RAIIFree"
			or "InvalidHandleValue"
			or "Agile"
			or "AlsoUsableFor"
			:
				break;
			default:
				print.it(name[..^9], td.DebugToString());
				break;
			}
		}
	}
}

//of extern methods
struct _MethodAttributes {
	public bool skip, obsolete, unicode, bit32, inline;
	public int constant;
	
	public _MethodAttributes(MethodDef md) {
		foreach (var ca in md.CustomAttributes) {
			string name = ca.AttributeType.Name;
			switch (name.AsSpan(..^9)) {
			case "Obsolete": obsolete = true; break;
			case "Ansi": skip = true; return;
			case "Unicode": unicode = true; break;
			case "SupportedArchitecture":
				int arch = ca.ArgInt(0);
				if ((arch & 2) == 0) { //no x64
					if ((arch & 1) != 0) bit32 = true; //X86
					else { skip = true; return; } //Arm64
				}
				break;
			case "Constant":
				(inline, constant) = (true, ca.ArgString(0).ToInt());
				break;
			case "Documentation"
			or "SupportedOSPlatform"
			or "CanReturnMultipleSuccessValues"
			or "CanReturnErrorsAsSuccess"
			or "DoesNotReturn"
			:
				break;
			default:
				print.it(name[..^9], md.DebugToString());
				break;
			}
		}
	}
}

struct _FieldAttributes {
	public bool isConst, isBitfield, isFlexibleArray;
	//public string assocEnum;
	
	public _FieldAttributes(FieldDef fd) {
		foreach (var ca in fd.CustomAttributes) {
			string name = ca.AttributeType.Name;
			switch (name.AsSpan(..^9)) {
			case "Const": isConst = true; break;
			case "NativeBitfield": isBitfield = true; break;
			case "FlexibleArray": isFlexibleArray = true; break;
			case "AssociatedEnum": /*assocEnum = ca.ArgString(0);*/ break; //not used. We convert most enums to const.
			case "Documentation": break; //few
			case "Obsolete" or "NotNullTerminated" or "NullNullTerminated": break;
			case "NativeArrayInfo": break; //few, not useful
			default:
				print.it(name[..^9], fd.DebugToString());
				break;
			}
		}
	}
}

struct _ParamAttributes {
	public bool isConst, isReturn, isComOut, isArrayPtr, isReserved, hasMemorySize;
	//public string assocEnum;
	
	public _ParamAttributes(ParamDef pd) {
		foreach (var ca in pd.CustomAttributes) {
			string name = ca.AttributeType.Name;
			switch (name.AsSpan(..^9)) {
			case "Const": isConst = true; break;
			case "RetVal": isReturn = true; break;
			case "ComOutPtr": isComOut = true; break;
			case "NativeArrayInfo": isArrayPtr = true; break;
			case "Reserved": isReserved = true; break;
			case "MemorySize": hasMemorySize = true; break; //can be array or normal struct or variable-size struct, we can't know, therefore use pointer, not in/ref/out
			case "AssociatedEnum": /*assocEnum = ca.ArgString(0);*/ break; //not used. We convert most enums to const.
			case "NullNullTerminated": break;
			case "NotNullTerminated": break;
			case "IgnoreIfReturn" or "DoNotRelease" or "Retained" or "FreeWith" or "RAIIFree": break;
			case "Documentation": break; //few
			default:
				print.it(name[..^9], pd.DebugToString());
				break;
			}
		}
	}
}

record class _TypeDefEtc(TypeDef td, string name, _TypeAttributes attr) {
	public bool isManagedStruct;
	public bool isProcessed;
}


================================================
FILE: Scripts/@WinAPI converter/WinApiConverter.cs
================================================
/*/ nuget -\dnlib; /*/
using dnlib.DotNet;
using System.Numerics;

partial class WinApiConverter {
	ModuleDefMD _module;
	StringBuilder b = new();
	Dictionary<string, string> _typedefs = new(500);
	Dictionary<string, _TypeDefEtc> _types = new(20_000);
	Dictionary<string, _TypeDefEtc> _ansiTypes = new(1000);
	Dictionary<string, (string members, bool isUnk, bool isDisp, string name)> _iBase = new(10_000);
	int _nAll = 0, _nFiltered = 0;
	
	public Dictionary<string, string> Result { get; private set; } = new(250_000);
	
	public void Convert(HashSet<string> onlyNamespaces = null) {
		_module = ModuleDefMD.Load(folders.Downloads + @"Windows.Win32.winmd");
		List<TypeDef> apis = new(50);
		_AddSomeTypes();
		
		foreach (var group in _module.Types.GroupBy(o => o.Namespace.String).Skip(1).OrderBy(o => o.Key)) { //group and order types by namespace
			string ns = group.Key, ns2 = ns[14..];
			if (ns2 is
				"Foundation.Metadata" //not Windows API. Attributes etc.
				or "NetworkManagement.P2P" //all API deprecated, but in metadata only some have [Obsolete], which causes some problems
				) continue; //CONSIDER: skip more namespaces.
			if (onlyNamespaces != null && !onlyNamespaces.Contains(ns2)) continue;
			//print.it(ns2, group.Count());
			
			foreach (var td in group) {
				if (td.IsEnum) {
					_Enum(td);
				} else if (td.IsValueType || td.IsInterface || td.IsDelegate) {
					_TypeAttributes attr = td.HasCustomAttributes ? new(td) : default;
					if (attr.skip) continue;
					//if (attr.obsolete) print.it(td.Name, td.IsValueType); //few, all ansi struct
					
					//if (attr.guid != null && !td.IsInterface && td.HasFields) print.it(td.IsValueType, td.Name);
					
					if (attr.typedef) {
						_Typedef(td);
					} else if (attr.guid != null && td.IsValueType && td.Fields.Count == 0) {
						_CoClass(td, attr);
					} else {
						string name = td.Name; //note: don't remove suffix "W", or then also would need to find and rename references or add to typedef etc
						
						string typedef = name switch {
							"POINT" or "SIZE" or "RECT" or "PROPERTYKEY" or "DEVPROPKEY" or "SID_IDENTIFIER_AUTHORITY" => name,
							"POINTL" or "RECTL" => name[..^1],
							"FARPROC" or "NEARPROC" or "PROC" => "nint",
							_ => null
						};
						if (typedef != null) { _typedefs.Add(name, typedef); continue; }
						
						if (!attr.ansi && name.Starts("PROPSHEETPAGEA_V") || name.Starts("PROPSHEETHEADERA_V")) attr.ansi = true;
						
						_TypeDefEtc tde = new(td, name, attr);
						var d = attr.ansi ? _ansiTypes : _types;
						if (!d.TryAdd(ns + "." + name, tde)) {
							Debug.Assert(attr.bit32); //good: all 32-bit types are after 64-bit types with same name.
							name += "__32";
							d.Add(ns + "." + name, tde with { name = name });
						}
					}
				} else {
					Debug.Assert(td.Name == "Apis");
					apis.Add(td);
				}
			}
		}
		
		foreach (var t in _types.Values.ToArray()) {
			if (t.isProcessed) continue;
			_Type(t, false);
		}
		
		foreach (var td in apis) {
			_Apis(td);
		}
		
		print.it($"//all={_nAll}, -ansi={_nFiltered}, -dup={Result.Count}");
	}
	
	//class "Apis"
	void _Apis(TypeDef td) {
		if (td.HasMethods) {
			foreach (var md in td.Methods) {
				_nAll++;
				_ExternMethod(md);
			}
		}
		
		if (td.HasFields) {
			foreach (var fd in td.Fields) {
				_nAll++;
				_ConstOrStaticReadonly(fd);
			}
		}
		
		Debug.Assert(!td.HasNestedTypes);
	}
	
	//top-level struct, delegate, interface, not enum
	void _Type(_TypeDefEtc t, bool recurse) {
		Debug.Assert(!t.isProcessed);
		if (recurse) { _bStack.Push(b); b = new(); } //not many
		
		_nAll++;
		b.Start(0);
		var (td, name, attr) = t;
		
		if (t.td.IsDelegate) {
			_Delegate(td, name, attr);
		} else if (td.IsInterface) {
			_Interface(td, name, attr);
		} else { //struct
			if (attr.guid != null) b.AppendLine($"[Guid(\"{attr.guid}\")]"); //few
			_Struct(0, td, t, name);
			_AddToDict(name);
		}
		
		t.isProcessed = true;
		if (recurse) b = _bStack.Pop();
	}
	Stack<StringBuilder> _bStack = new();
	
	void _Struct(int level, TypeDef td, _TypeDefEtc tdeTopLevel, string name = null) {
		name ??= td.Name;
		
		int len = b.Length;
		if (td.Layout == TypeAttributes.ExplicitLayout || td.HasClassLayout) {
			b.Append("[StructLayout(LayoutKind.").Append(td.Layout == TypeAttributes.ExplicitLayout ? "Explicit" : "Sequential");
			if (td.HasClassLayout && td.ClassLayout is var l) {
				if (l.ClassSize > 0) b.Append(", Size = ").Append(l.ClassSize);
				if (l.PackingSize > 0) b.Append(", Pack = ").Append(l.PackingSize);
			}
			b.Append(")]");
		}
		b.EndAttributes(level, len);
		
		b.AppendFormat("{0} struct {1} {{", level > 0 ? "public" : "internal", name);
		
		Debug.Assert(!td.HasMethods);
		
		if (td.HasFields) {
			for (int i = 0, last = td.Fields.Count - 1; i <= last; i++) {
				_Field(level + 1, td.Fields[i], i == last, tdeTopLevel);
			}
		}
		
		if (td.HasNestedTypes) {
			foreach (var ntd in td.NestedTypes) {
				b.AppendLine();
				b.Start(level + 1);
				//if (ntd.HasCustomAttributes) {
				//	print.it(name, ntd.CustomAttributes); //several StructSizeFieldAttribute
				//}
				_Struct(level + 1, ntd, tdeTopLevel);
			}
		}
		
		b.AppendLine().Append('\t', level).Append('}');
	}
	
	void _Field(int level, FieldDef fd, bool last, _TypeDefEtc tdeTopLevel) {
		b.Start(level);
		
		string name = _RenameIfKeyword(fd.Name);
		if (fd.HasConstant) {
			b.Append("public ");
			_Const(fd, name);
			b.Append(';');
		} else {
			_FieldAttributes attr = fd.HasCustomAttributes ? new(fd) : default;
			
			//Not all flexible arrays have the attribute. It seems `field[1]` have but `field[]` don't.
			//	We can either comment out the field or use FlexibleArray. Let's use FlexibleArray to make it easy to use, although sizeof will be incorrect.
			if (last && fd.FieldType.ElementType == ElementType.Array && !attr.isFlexibleArray && fd.FieldSig.Type is ArraySig { Sizes: [1] }) {
				//print.it(fd.DebugToString());
				attr.isFlexibleArray = true;
				b.Append("\r\n#warning This field makes sizeof struct incorrect, because in C the array has 0 elements (zero size). Comment out this warning if it's OK.\r\n\t");
			}
			
			if (fd.FieldOffset.HasValue) b.Append("[FieldOffset(").Append(fd.FieldOffset.Value).Append(")] ");
			
			var (st, isManaged, arraySig) = _GetTypeName_Field(fd, attr, tdeTopLevel);
			
			Debug.Assert(!(isManaged && level > 1));
			if (isManaged && level == 1) tdeTopLevel.isManagedStruct = true;
			
			if (arraySig != null) {
				if (attr.isFlexibleArray) {
					if (st.Ends('*')) b.AppendFormat("public FlexibleArray<nint> {1}; //{0}", st, name);
					else b.AppendFormat("public FlexibleArray<{0}> {1};", st, name);
				} else {
					uint size = arraySig.Sizes[0];
					//if (size == 1) print.it(fd.DebugToString()); //not many. Some look like should be a flexible array, some structs have 2 flexible arrays, some are just to fill unused gaps.
					
					if (st is "char" or "byte" or "short" or "int" or "long" or "sbyte" or "ushort" or "uint" or "ulong" or "float" or "double" or "bool") {
						b.AppendFormat("public fixed {0} {1}[{2}];", st, name, size);
					} else {
						b.AppendFormat("public {0}_{1} {0}; [InlineArray({1})] public struct {0}_{1} {{ {2} _; }}", name, size, st[^1] == '*' ? "nint" : st);
					}
					b.AppendFormat(" //[MarshalAs(UnmanagedType.{0}, SizeConst = {1})] public {2}[] {3};", st == "char" ? "ByValTStr" : "ByValArray", size, st, name);
				}
			} else {
				if (!attr.isBitfield) b.Append("public ");
				if (fd.IsStatic) b.Append("static "); //none
				
				if (name.Starts("Anonymous") && st[0] == '_' && st.Eq(1, name)) {
					if (st.Ends("_e__Union")) name = "u_" + name[9..];
					else if (st.Ends("_e__Struct")) name = "n_" + name[9..];
					//else print.it(name, st);
				}
				
				b.AppendFormat("{0} {1};", st, name);
			}
			
			if (attr.isBitfield) _Bitfields();
		}
		
		void _Bitfields() {
			string type = fd.FieldType.ElementType.ToKeywordString();
			string index = name[9..]; //_bitfield1 -> 1
			string s1 = null, s2 = null; if (type is "byte" or "sbyte" or "short" or "ushort") (s1, s2) = ("(" + type + ")(", ")");
			b.Start(level);
			b.AppendFormat("{0} _{1}G(int o, {0} m) => {3}{2} >> o & m{4};", type, index, name, s1, s2);
			b.Start(level);
			b.AppendFormat("void _{1}S(int o, {0} m, {0} v) => {2} = {3}({2} & ~(m << o)) | ((v & m) << o){4};", type, index, name, s1, s2);
			
			foreach (var ca in fd.CustomAttributes) {
				if (ca.AttributeType.Name == "NativeBitfieldAttribute") {
					b.Start(level);
					b.AppendFormat("public {0} {1} {{ get => _{4}G({2}, {3}); set => _{4}S({2}, {3}, value); }}", type, ca.ArgString(0), ca.ArgInt(1), (1 << ca.ArgInt(2)) - 1, index);
				}
			}
		}
	}
	
	//global constant (#define, const) or variable (eg GUID)
	void _ConstOrStaticReadonly(FieldDef fd) {
		b.Start(0);
		string name = fd.Name;
		b.Append("internal ");
		if (fd.HasConstant) {
			if (name[^1] == 'A' && fd.DeclaringType.FindField(name.Ends("_A") ? name[..^2] : name.ReplaceAt(^1.., "W")) != null) return; //info: don't use [NativeEncodingAttribute("ansi")]. Only string constants have it, and maybe not all.
			_Const(fd, name);
			//print.it(b);
		} else {
			if (!fd.HasCustomAttributes) throw new Exception("no attributes");
			b.Append("static readonly ");
			
			var t = fd.FieldType;
			var st = t.TypeName;
			//if (!(st is "Guid" or "PROPERTYKEY" or "DEVPROPKEY" or "SID_IDENTIFIER_AUTHORITY")) print.it(st);
			b.Append(st).Append(' ').Append(name).Append(" = new(");
			
			//if (fd.HasCustomAttributes) {
			//	foreach (var v in fd.CustomAttributes) {
			//		string s = v.AttributeType.Name;
			//		if (s is "DocumentationAttribute" or "NativeEncodingAttribute") continue;
			//		if (s is "GuidAttribute" or "ConstantAttribute") continue;
			//		print.it(s, name); //none
			//	}
			//}
			
			//print.it(st, name);
			if (st == "Guid") {
				var ca = fd.CustomAttributes.Find("Windows.Win32.Foundation.Metadata.GuidAttribute") ?? throw new Exception("no Guid attr");
				_AppendString(ca.ArgGuid());
			} else { //see _AddSomeTypes()
				var ca = fd.CustomAttributes.Find("Windows.Win32.Foundation.Metadata.ConstantAttribute") ?? throw new Exception("no ConstantAttribute");
				string s = ca.ArgString(0);
				if (0 != s.RxReplace(@"^\{((?:\d+, ){10}\d+)\}(, \d+)$", "new($1)$2", out s, 1)) b.Append(s); //eg PROPERTYKEY
				else if (s.Like("{*}")) b.Append(s, 1, s.Length - 2); //SID_IDENTIFIER_AUTHORITY
				else if (s != "0") print.warning(s);
			}
			
			b.Append(')');
			//print.it(b);
		}
		b.Append(';');
		_AddToDict(name);
	}
	
	void _Const(FieldDef fd, string name) {
		//if (fd.HasCustomAttributes) {
		//	foreach (var v in fd.CustomAttributes) {
		//		string s = v.AttributeType.Name;
		//		if (s is "DocumentationAttribute") continue;
		//		if (s is "NativeEncodingAttribute") continue;
		//		print.it(s, name); //only several ConstAttribute
		//	}
		//}
		
		b.Append("const ");
		var c = fd.Constant;
		var ct = c.Type;
		var st = ct.ToKeywordString();
		
		//var st2 = fd.FieldType.TypeName;
		//if (_typedefs.TryGetValue(st2, out var st3)) st2 = st3; else st2 = _SystemTypeNameToKeyword(st2);
		//if (st2 != st) print.it(st, st2, name);
		
		if (ct is ElementType.U4 && name.Starts("WM_") && (uint)c.Value <= 0xffff) st = "ushort";
		
		b.Append(st).Append(' ').Append(name).Append(" = ");
		if (ct == ElementType.String) {
			_AppendString(c.ValueString());
		} else if (ct is ElementType.U4 or ElementType.U1 or ElementType.U2 or ElementType.U8) {
			b.AppendFormat("0x{0:X}", c.Value);
		} else {
			var v = c.Value;
			if (v is int iv && iv < 0 && fd.FieldType.TypeName is "HRESULT" or "NTSTATUS") b.AppendFormat("unchecked((int)0x{0:X})", v);
			else b.Append(c.Value);
			
			if (ct is ElementType.R4) b.Append('f');
		}
	}
	
	void _Enum(TypeDef td) {
		string name = td.Name;
		
		bool isFlags = false, isScoped = false;
		if (td.HasCustomAttributes) {
			foreach (var ca in td.CustomAttributes) {
				string s = ca.AttributeType.Name;
				switch (s) {
				case "FlagsAttribute": isFlags = true; break;
				case "ScopedEnumAttribute": isScoped = true; break;
				case "DocumentationAttribute": break;
				case "AssociatedConstantAttribute": break; //few
				default: print.it(s); break;
				}
			}
		}
		
		if (!isFlags) isFlags = _IsFlagsEnum();
		if (!isScoped) isScoped = _IsScopedEnum();
		
		//In metadata, many #define constants are added to enums. Most of these enums are not Windows API.
		//It is bad, because:
		//	- Many parameters etc where these constants are used are not of these enum types. Then how users can find these enums? Also need to cast always.
		//	- Many other constants aren't added to enums. It seems the work is unfinished.
		//	- Some enums are large (eg WIN32_ERROR 3335). Usually users need only few constants. And in LA it's super easy to find them and add to the code.
		//	- Noticed some errors, eg in enum SHARE_INFO_PERMISSIONS wrong ACCESS_ALL and missing ACCESS_GROUP.
		//	- I don't like to write arguments like `api.ENUM_TYPE.ET_CONSTANT1 | api.ENUM_TYPE.ET_CONSTANT2`. Better use Windows API more like in C++. Most constants have a prefix. And normally they are in an `api` class.
		//Instead add enum members as const. Unless the enum is marked as scoped or members don't have a common prefix etc.
		
		if (isScoped) { //add as enum
			_nAll++;
			b.Start(0);
			if (isFlags) b.AppendLine("[Flags]");
			b.Append("internal enum ").Append(name);
			var ut = td.GetEnumUnderlyingType().ElementType;
			if (ut != ElementType.I4) b.Append(" : ").Append(ut.ToKeywordString());
			b.Append(" {\r\n\t");
			
			long lNext = 0; ulong ulNext = 0;
			bool once = false;
			foreach (var fd in td.Fields) {
				if (fd.Constant is { } c) {
					if (!once) once = true; else b.Append(",\r\n\t");
					b.Append(fd.Name);
					var (isUlong, l, u) = _ObjectToLongOrUlong(c.Value);
					if (isUlong) {
						if (u != ulNext || isFlags) b.Append(" = ").AppendFormat("0x{0:X}", u);
						ulNext = u + 1;
					} else {
						if (l != lNext || isFlags) {
							b.Append(" = ");
							if (isFlags && l >= 0) b.AppendFormat("0x{0:X}", l); else b.Append(l);
						}
						lNext = l + 1;
					}
				}
			}
			
			b.Append("\r\n}");
			_AddToDict(name);
			_types.Add(td.Namespace + "." + name, new(td, name, default) { isProcessed = true });
		} else { //add members as const
			string st = null; bool hexInt = false;
			switch (name) {
			case "WIN32_ERROR": (st, hexInt) = ("int", true); break; //uint
			case "VIRTUAL_KEY": break; //ushort
			}
			
			st ??= _SystemTypeNameToKeyword(td.GetEnumUnderlyingType().TypeName);
			
			foreach (var fd in td.Fields) {
				if (fd.Constant is { } c) {
					b.Start(0);
					string cName = fd.Name;
					b.Append("internal const ").Append(st).Append(' ').Append(cName).Append(" = ");
					var (isUlong, l, u) = _ObjectToLongOrUlong(c.Value);
					if (hexInt) {
						Debug.Assert(isUlong);
						if ((int)u < 0) b.AppendFormat("unchecked((int)0x{0:X})", u); else b.Append(u);
					} else if (isUlong) {
						b.AppendFormat("0x{0:X}", u);
					} else {
						if (isFlags && l >= 0) b.AppendFormat("0x{0:X}", l); else b.Append(l);
					}
					b.Append(';');
					//print.it(b);
					_AddToDict(cName);
					_nAll++;
				}
			}
			
			if (!_typedefs.TryAdd(name, st)) {
				if (_typedefs[name] != st) print.warning($"{name}, {st}, {_typedefs[name]}");
			}
		}
		
		bool _IsFlagsEnum() { //if no [Flags], assume it's a flags enum if contains only values like 1 2 4 8...
			ulong max = 0;
			foreach (var fd in td.Fields) {
				if (fd.Constant is { } c) {
					var (isUlong, l, u) = _ObjectToLongOrUlong(c.Value);
					if (!isUlong) u = (ulong)l;
					if (u != 0 && !BitOperations.IsPow2(u)) return false;
					max = Math.Max(max, u);
				}
			}
			//if (max<4 && name.Ends("FLAGS")) print.it(max, name);
			return max >= 4 || name.Ends("FLAGS");
		}
		
		bool _IsScopedEnum() { //if no [ScopedEnum], let it be enum if some member names don't contain '_' and contain lowercase chars, unless most such names have a common prefix of length >= 2.
			var a = td.Fields;
			ReadOnlySpan<char> span1 = null;
			int minPrefixLength = int.MaxValue, nDiffPrefix = 0, nCommonPrefix = 0;
			for (int i = 1; i < a.Count; i++) {
				var s8 = a[i].Name;
				if (s8.Length < 4) return true;
				if (s8.IndexOf('_', 1) < 0 && s8.String.Any(o => char.IsAsciiLetterLower(o))) {
					if (span1 == null) span1 = s8.String;
					else {
						var p = span1.CommonPrefixLength(s8.String);
						if (p < 2) {
							if (++nDiffPrefix > 1) break; //allow single member without common prefix; usually `MaxX`
						} else {
							nCommonPrefix++;
							minPrefixLength = Math.Min(minPrefixLength, p);
						}
					}
				}
			}
			if (nDiffPrefix > 0) {
				//if (nDiffPrefix > 1 || nCommonPrefix == 0) print.it(name, td.Fields.Skip(1).Select(o => o.Name));
				if (nDiffPrefix > 1 || nCommonPrefix == 0) return true;
				//print.it(name, td.Fields.Skip(1).Select(o => o.Name));
			}
			return false;
		}
	}
	
	void _Method2(string name, MethodDef md, bool inCOM, bool inDelegate, int bStart, bool bit32) {
		if (md.HasReturnType) {
			var st = _GetTypeName_Return(md, inCOM, bStart, bit32);
			b.Append(st).Append(' ');
		} else b.Append("void ");
		
		//print.it($"<><lc yellowgreen>{name}  ({md.DeclaringType.Name})<>");
		
		b.Append(name).Append('(');
		string sep = null;
		foreach (var p in md.Parameters) {
			if (!p.IsNormalMethodParameter) continue; //hidden `this` parameter
			b.Append(sep); sep = ", ";
			//print.it(p.Index, p.Type.TypeName, p.Name);
			
			var pName = _RenameIfKeyword(p.Name);
			var pd = p.ParamDef;
			_ParamAttributes attr = pd.HasCustomAttributes ? new(pd) : default;
			
			var st = _GetTypeName_Param(p, attr, inCOM, inDelegate, bit32);
			
			b.Append(st).Append(' ').Append(pName);
		}
		if (md.CallingConvention is dnlib.DotNet.CallingConvention.VarArg) b.Append(", __arglist");
		b.Append(");");
	}
	
	void _ExternMethod(MethodDef md) {
		//if (md.Attributes is not (MethodAttributes.Public | MethodAttributes.Static | MethodAttributes.HideBySig | MethodAttributes.PinvokeImpl)) print.it(md.Attributes, md.Name);
		
		b.Start(0);
		string name = md.Name, name0 = name;
		var attr = md.HasCustomAttributes ? new _MethodAttributes(md) : default;
		if (attr.skip) return;
		if (attr.unicode && name[^1] == 'W') name = name[..^1];
		//if (attr.bit32) print.it(name, Result.ContainsKey(name));
		if (attr.bit32) name += "__32"; //even if the 32-bit version is named differently, eg with suffix "64"
		
		if (attr.inline) {
			Debug.Assert(md.Parameters.Count == 0);
			var st = _GetTypeName_Return(md, false, 0, attr.bit32);
			//print.it(name, attr.constant, md.ReturnType.TypeName, st);
			Debug.Assert(st is "nint" or "int" or "uint");
			b.AppendFormat("internal static {0} {1}() => {2};", st, name, attr.constant);
		} else {
			if (attr.obsolete) b.AppendLine("[Obsolete]");
			
			//[DllImport]
			var im = md.ImplMap;
			b.Append("[DllImport(\"").Append(im.Module.Name.String.Lower()).Append('"');
			//if (name0!=im.Name) print.it(im.Name, md.Name); //few, although many ordinal-only functions exist in Windows API (not all exist in winmd). Never mind.
			if (name != name0) b.AppendFormat(", EntryPoint = \"{0}\"", name0);
			if (im.IsCallConvCdecl) b.Append(", CallingConvention = CallingConvention.Cdecl");
			if (im.SupportsLastError) b.Append(", SetLastError = true");
			if (0 != (im.Attributes & ~(PInvokeAttributes.CallConvWinapi | PInvokeAttributes.CallConvCdecl | PInvokeAttributes.SupportsLastError | PInvokeAttributes.NoMangle))) print.warning(name);
			b.AppendLine(")]");
			
			b.Append("internal static extern ");
			_Method2(name, md, false, false, 0, attr.bit32);
		}
		
		_AddToDict(name);
		//print.it(b);
	}
	
	void _Delegate(TypeDef td, string name, in _TypeAttributes attr) {
		if (attr.cdeclDelegate) b.AppendLine("[UnmanagedFunctionPointer(CallingConvention.Cdecl)]");
		
		b.Append("internal delegate ");
		var md = td.Methods[1];
		//if (md is var md && md.Attributes is not (MethodAttributes.Public | MethodAttributes.Virtual | MethodAttributes.HideBySig | MethodAttributes.VtableLayoutMask)) print.it(md.Attributes, td.Name);
		_Method2(name, md, false, true, 0, attr.bit32);
		_FunctionPointer(attr.cdeclDelegate, attr.bit32);
		
		_AddToDict(name);
		
		//appends `//delegate*<...>`.
		void _FunctionPointer(bool cdecl, bool bit32) {
			b.Append("\r\n//delegate* unmanaged");
			if (cdecl) b.Append("[Cdecl]");
			b.Append('<');
			string sep = null;
			foreach (var p in md.Parameters) {
				if (!p.IsNormalMethodParameter) continue; //hidden `this` parameter
				b.Append(sep); sep = ", ";
				b.Append(_GetTN(p.Type, bit32, p.ParamDef));
			}
			if (md.HasReturnType) b.Append(", ").Append(_GetTN(md.ReturnType, bit32, md)); else b.Append(", void");
			b.Append('>');
			
			string _GetTN(TypeSig t, bool bit32, object def) {
				var (s2, marshal, s) = _GetTypeName(t, out int ptr, false, (false, false), bit32, def);
				//if (marshal != null) print.it(s, s2, marshal, def.DebugToString());
				if (ptr > 0 && def is ParamDef pd) {
					bool isArray = pd.HasCustomAttributes && new _ParamAttributes(pd).isArrayPtr;
					if (!isArray) { ptr--; b.Append(!pd.IsOut ? "in " : pd.IsIn ? "ref " : "out "); }
				}
				if (ptr > 0) s = s.PadRight(s.Length + ptr, '*');
				return s;
			}
		}
	}
	
	void _InterfaceMethod(MethodDef md, bool bit32) {
		//if (md.Attributes is not (MethodAttributes.Public | MethodAttributes.Virtual | MethodAttributes.HideBySig | MethodAttributes.VtableLayoutMask | MethodAttributes.Abstract)) print.it(md.Attributes, md.Name, md.DeclaringType.Name);
		Debug.Assert(md.CallingConvention is 0 or dnlib.DotNet.CallingConvention.ThisCall);
		
		b.Start(1);
		int bStart = b.Length;
		string name = md.Name;
		
		b.Append("[PreserveSig] ");
		
		_Method2(name, md, true, false, bStart, bit32);
	}
	
	void _Interface(TypeDef td, string name, in _TypeAttributes attr) {
		string name0 = td.Name; //because name may be mangled
		bool isUnk = false, isDisp = false;
		string bName = null, bMembers = null;
		
		if (!td.HasInterfaces) {
			if (name == "IUnknown") {
				b.Append($$"""
[ComImport, Guid("{{attr.guid}}"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
internal interface IUnknown {}
""");
				_AddToDict(name);
				return;
			}
			
			//not a COM interface. Difficult to use in C#. Not many. Add anyway, without [ComImport].
			//print.it(name, attr.guid);
			//TODO2: declare as struct with vtbl. Eg IMemoryAllocator.
		} else {
			//if (td.Interfaces.Count != 1) print.it(name);
			//if (td.Attributes != (TypeAttributes.Public | TypeAttributes.ClassSemanticMask | TypeAttributes.Abstract)) print.it(td.Attributes);
			
			var ii = td.Interfaces[0].Interface;
			bName = ii.Name;
			if (bName == "IUnknown") isUnk = true;
			else if (bName == "IDispatch") isDisp = true;
			else {
				string nn = ii.Namespace + "." + bName;
				g1:
				if (_iBase.TryGetValue(nn, out var v)) {
					(bMembers, isUnk, isDisp, bName) = v;
				} else {
					//print.it("interface base", name, bName);
					_Type(_types[nn], true);
					goto g1;
				}
			}
		}
		
		if (isUnk || isDisp) {
			b.AppendFormat("[ComImport, Guid(\"{0}\")", attr.guid);
			if (!isDisp) b.Append(", InterfaceType(ComInterfaceType.InterfaceIsIUnknown)");
			b.AppendLine("]");
		} else {
			if (attr.guid != null) b.AppendFormat("[Guid(\"{0}\")]\r\n", attr.guid);
		}
		
		b.Append("internal interface ").Append(name);
		if (bMembers != null) b.Append(" : ").Append(bName);
		
		b.Append(" {");
		int membersStart = b.Length;
		
		if (bMembers != null) {
			if (!bMembers.Starts("\r\n\t//")) b.Append("\r\n\t// ").Append(bName);
			b.Append(bMembers.RxReplace(@"(?m)^\t\[PreserveSig\] \K(?!new )", "new "));
			b.Append("\r\n\t// ").Append(name);
		}
		
		foreach (var md in td.Methods) {
			_InterfaceMethod(md, attr.bit32);
		}
		
		int membersLen = b.Length - membersStart;
		_iBase.Add(td.Namespace + "." + name0, (string.Create(membersLen, 0, (s, _) => b.CopyTo(membersStart, s, membersLen)), isUnk, isDisp, name));
		
		b.Append(b.Length > membersStart ? "\r\n}" : " }");
		_AddToDict(name);
		
		//print.it(b);
		//if (bMembers != null) print.it(b);
	}
	
	void _Typedef(TypeDef td) {
		string name = td.Name;
		//print.it(name);
		string r = null;
		
		if (name == "HWND") {
			r = "wnd";
		} else if (name is "BOOL" or "BSTR") {
			return;
		} else {
			var f = td.Fields[0];
			var tn = f.FieldType.TypeName;
			r = tn switch {
				"Void*" or "IntPtr" or "UIntPtr" => "nint",
				"Char*" => "char*",
				"Byte*" => "byte*",
				_ => _SystemTypeNameToKeyword(tn)
			};
			if (r == null) {
				print.warning(tn);
				return;
			}
			Debug.Assert(r != "bool");
		}
		_typedefs.Add(name, r);
	}
	
	void _CoClass(TypeDef td, in _TypeAttributes attr) {
		Debug.Assert(!td.HasMethods && !td.HasNestedTypes);
		b.Clear();
		string name = td.Name;
		b.Append($$"""
[ComImport, Guid("{{attr.guid}}"), ClassInterface(ClassInterfaceType.None)]
internal class {{name}} {}
""");
		_AddToDict(name);
	}
}


================================================
FILE: Scripts/AuDocsLib.cs
================================================
/*/
role classLibrary
outputPath %folders.Workspace%\dll
testInternal Au.Editor,Au,Microsoft.CodeAnalysis,Microsoft.CodeAnalysis.CSharp,Microsoft.CodeAnalysis.Features,Microsoft.CodeAnalysis.CSharp.Features,Microsoft.CodeAnalysis.Workspaces,Microsoft.CodeAnalysis.CSharp.Workspaces;
r Au.Editor.dll;
r Roslyn\Microsoft.CodeAnalysis.dll;
r Roslyn\Microsoft.CodeAnalysis.CSharp.dll;
r Roslyn\Microsoft.CodeAnalysis.Features.dll;
r Roslyn\Microsoft.CodeAnalysis.CSharp.Features.dll;
r Roslyn\Microsoft.CodeAnalysis.Workspaces.dll /alias=CAW
r Roslyn\Microsoft.CodeAnalysis.CSharp.Workspaces.dll;
nuget -\Markdig;
/*/

extern alias CAW;

using Microsoft.CodeAnalysis;
using CAW::Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.Text;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Shared.Extensions;
using Microsoft.CodeAnalysis.CSharp.Extensions;
using CAW::Microsoft.CodeAnalysis.Classification;
using CAW::Microsoft.CodeAnalysis.Shared.Extensions;

using System.Net;
using EStyle = LA.SciTheme.EStyle;
using Markdig;

namespace ADL;

#pragma warning disable CS1591 //Missing XML comment for publicly visible type or member

/// <summary>
/// Used by the "Au docs" script.
/// Also RecipeCodeToHtml used by the Read panel to create preview HTML of the current cookbook source script. In DEBUG mode only.
/// </summary>
public static class AuDocsShared {
	public static Func<string, string> ResolveAuApiLink;
	
	public static void Test() {
		print.clear();
		//var mdFile = folders.Editor + @"..\Cookbook\files\Filesystem\Create folder.cs";
		var mdFile = folders.ThisAppBS + @"..\Cookbook\files\Filesystem\Zip files (compress, extract).cs";
		var code = filesystem.loadText(mdFile);
		var name = pathname.getNameNoExt(mdFile);
		var html = RecipeCodeToHtml(name, code);
		//print.it(html);
	}
	
	static MarkdownPipeline _pipeline;
	
	public static string RecipeCodeToHtml(string name, string code) {
		if (_pipeline == null) {
			var p = new MarkdownPipelineBuilder();
			p.BlockParsers.RemoveAll(o => o is Markdig.Parsers.IndentedCodeBlockParser);
			p.UsePipeTables();
			_pipeline = p.Build();
		}
		
		var md = RecipeCodeToMd(name, code);
		var s = Markdig.Markdown.ToHtml(md, _pipeline);
		//print.it(s);
		s = PostprocessHtmlNonApi(name, s);
		return PostprocessHtmlCommon(name, s, isApi: false);
	}
	
	public static string RecipeCodeToMd(string name, string code, bool test = false) {
		var b = new StringBuilder();
		b.Append("# ").AppendLine(name);
		string usings;
		foreach (var (isText, s) in _ParseRecipe(name, code, out usings)) {
			if (isText) {
				//CONSIDER: markdown-escape (replace * with \* etc).
				//	Now escapes only in several tags, where noticed bad Type<T> etc.
				//	Or will need to review each new recipe as webpage. All initial recipes are reviewed.
				//	When reviewing, if something is bad, usually that text must be in <mono> (inline code) etc.
				
				if (test) print.it(s);
				b.AppendLine(_rxTag.Replace(s, _Repl));
			} else {
				b.AppendLine();
				b.AppendLine("```csharp");
				b.Append(s);
				if (!s.Ends('\n')) b.AppendLine();
				b.AppendLine("```");
				b.AppendLine();
			}
		}
		
		return b.ToString();
		
		string _Repl(RXMatch m) {
			if (test) print.it(m);
			string tag = m[1].Value, s = m[3].Value;
			
			if (tag == "_") return _MarkdownEscape(s); //raw text
			
			if (tag is ".k" or ".x" or ".c" or "mono") {
				Debug_.PrintIf(s.Contains('<') && m.Value.Ends("<>")); //if contains <, must end with </.c> etc
				Debug_.PrintIf(s.Contains('\n'), s);
			}
			
			bool onlyRawText = s.Like("<_>*</_>");
			if (onlyRawText) s = _MarkdownEscape(s[3..^4]);
			else if (s.Contains('<')) s = _rxTag.Replace(s, _Repl);
			
			//non-link tags
			switch (tag) {
			case "b" or "i" or "u":
				return $"<{tag}>{s}</{tag}>";
			case "bi":
				return $"<b><i>{s}</i></b>";
			case ".k": //C# keyword
				return $"<code style='color:#00f'>{s}</code>";
			case ".x": //API name
				return $"<code style='color:#e06060'>{s}</code>";
			case "+nuget":
				return $"<span style='color:#080;text-decoration:underline' title='Paste the underlined text in menu > Tools > NuGet'>{s}</span>";
			case "open":
				return $"<code>{s}</code>";
			case "c" or ".c" or "mono":
				throw new ArgumentException("Don't use tags c, .c, mono. Use `code`. " + m);
			}
			
			var attr = m[2].Value;
			if (attr == null) attr = s;
			else {
				if (attr is ['\'', .., '\''] or ['"', .., '"']) attr = attr[1..^1];
				Debug_.PrintIf(attr.Contains('|'));
			}
			
			//links
			switch (tag) {
			case "help":
				//print.it(name, attr);
				if (attr.Contains('/')) { //info: <help> is used only for "articles\x" and "editor\x"
					if (!filesystem.exists(folders.ThisAppBS + @"..\Other\DocFX\_doc\" + attr + ".md")) break;
					return $"<a href=\"/{UrlEscapePath(attr)}.html\">{s}</a>";
				}
				break;
			case "link":
				if (!attr.Starts("http")) return s; //eg %folders.Workspace%
				return $"<a href=\"{attr}\">{s}</a>";
			case "google":
				return $"<a href=\"https://www.google.com/search?q={System.Net.WebUtility.UrlEncode(attr)}\">{s}</a>";
			case "+lang":
				attr += ", C# reference";
				goto case "google";
			case "+ms":
				attr += " site:microsoft.com";
				goto case "google";
			case "+recipe":
				if (_FindRecipe(attr) is string rec) return $"<a href=\"/cookbook/{Uri.EscapeDataString(rec)}\">{s}</a>";
				break;
			case "+see": //was <see cref="attr"/>, now <+see 'attr'>attr<>. Then could not replace with <a> because usings still were not collected from codes.
				if (_GetSeeUrl(attr, usings, out bool isAu) is string url2) {
					if (isAu) url2 = $"/api/{url2}.html";
					if (!onlyRawText) s = _MarkdownEscape(s);
					return $"<a href=\"{url2}\">{s}</a>";
				}
				break;
			}
			
			print.it($"<>{name}: <c red>{tag}, {attr}<>");
			return s;
		}
		
		string _MarkdownEscape(string s) => _rxEscape.Replace(s, @"\$0");
	}
	
	static regexp _rxEscape = new(@"[\!\#\$\%\&\'\(\)\*\+\-\/\:\<\=\>\?\@\[\\\]\^\_\`\{\|\}\~]");
	static regexp _rxTag = new(@"<([\+\.]?\w+)(?: ([^>\r\n]+))?>((?:[^<]++|(?R)|<\w+(?:, \w+)*>)*)<(?:/\1)?>");
	const string c_website = "https://www.libreautomate.com";
	
	static string _FindRecipe(string s) {
		if (_aFR == null) {
			var xr = XmlUtil.LoadElem(folders.ThisAppBS + @"..\Cookbook\files.xml");
			_aFR = xr.Descendants("s").Select(x => {
				var name = x.Attr("n")[..^3];
				return (name, name + ".html");
			}).ToArray();
		}
		foreach (var v in _aFR) if (v.name.Like(s, true)) return v.filenameHtml;
		foreach (var v in _aFR) if (v.name.Starts(s, true)) return v.filenameHtml;
		foreach (var v in _aFR) if (v.name.Find(s, true) >= 0) return v.filenameHtml;
		print.warning("recipe not found: " + s);
		return null;
		//see PanelHelp._FindRecipe.
	}
	static (string name, string filenameHtml)[] _aFR;
	
	public static string _GetSeeUrl(string s, string usings, out bool isAu) {
		isAu = false;
		//add same namespaces as in default global.cs. Don't include global.cs because it may be modified.
		string code = usings + $"///<see cref='{s}'/>";
		using var ws = new AdhocWorkspace();
		var document = LA.CiUtil.CreateDocumentFromCode(ws, code, needSemantic: true);
		var syn = document.GetSyntaxRootSynchronously(default);
		var node = syn.FindToken(code.Length - 3 - s.Length, true).Parent.FirstAncestorOrSelf<CrefSyntax>();
		if (node != null) {
			var semo = document.GetSemanticModelAsync().Result_();
			if (semo.GetSymbolInfo(node).GetAnySymbol() is ISymbol sym)
				return LA.CiUtil.GetSymbolHelpUrl(sym, out isAu);
		}
		return null;
	}
	
	/// <summary>
	/// Splits a recipe source code into text and code parts.
	/// From text parts removes /// and replaces 'see' with '+see'.
	/// </summary>
	/// <param name="code">C# code.</param>
	/// <param name="usings">null or all using directives found in all codes.</param>
	static List<(bool isText, string s)> _ParseRecipe(string name, string code, out string usings) {
		//rejected:
		//	1. Ignore code before the first ///. Not really useful, just forces to always start with ///.
		//	2. Use {  } for scopes of variables. Its' better to use unique names.
		//	3. Use if(...) {  } to enclose code examples to select which code to test.
		//		Can accidentally damage real 'if' code. I didn't use it; it's better to test codes in other script.
		
		List<(bool isText, string s)> r = new();
		StringBuilder sbUsings = null;
		var ac = new List<(string code, int offset8, int len8)>();
		int iCode = 0;
		foreach (var m in code.RxFindAll(@"(?ms)^(?:///(?!=/)\N*\R*)+|^/\*\*.+?\*/\R*")) {
			//print.it("--------");
			//print.it(m);
			if (code.Eq(m.Start, "/// <summary>")) continue;
			int textTo = m.End, i = code.Find("\n/// <summary>", m.Start..m.End); if (i >= 0) textTo = i + 1;
			
			_Code(iCode, m.Start);
			_Text(m.Start, iCode = textTo);
		}
		_Code(iCode, code.Length);
		usings = sbUsings?.ToString();
		return r;
		
		void _Text(int start, int end) {
			while (code[end - 1] <= ' ') end--;
			bool ml = code[start + 1] == '*';
			if (ml) {
				start += 3; while (code[start] <= ' ') start++;
				end -= 2; while (end > start && code[end - 1] <= ' ') end--;
			}
			var s = code[start..end];
			if (!ml) s = s.RxReplace(@"(?m)^/// ?", "");
			s = s.RxReplace(@"<see cref=""(.+?)""(?:/|>(.+?)<[^>]*)>", m => {
				string v = m[1].Value, t = v;
				if (m[2].Exists) t = m[2].Value;
				else if (t.Contains('{')) t = "<_>" + t.Replace('{', '<').Replace('}', '>') + "</_>";
				//if (m[2].Exists) print.it(name, v, t);
				return $"<+see '{v}'>{t}<>";
			});
			//print.it("TEXT"); print.it(s);
			r.Add((true, s));
		}
		
		void _Code(int start, int end) {
			while (end > start && code[end - 1] <= ' ') end--;
			if (end == start) return;
			var s = code[start..end];
			//print.it("CODE"); print.it(s);
			r.Add((false, s));
			
			foreach (var m in s.RxFindAll(@"(?m)^using [\w\.]+;")) {
				(sbUsings ??= new()).AppendLine(m.Value);
			}
		}
	}
	
	public static string PostprocessHtmlNonApi(string name, string s) {
		int nr;
		//in .md we use this for links to our API: [Class]() or [Class.Member]().
		//	DocFX converts it to <a href="">Class</a> etc without warning.
		//	Now convert it to a working link.
		nr = s.RxReplace(@"<a href="""">(.+?)</a>", m => {
			var k = m[1].Value;
			string href = ResolveAuApiLink(k);
			if (href == null && k.LastIndexOf('.') is var i && i > 0) href = ResolveAuApiLink(k[..i]); //enum member
			if (href == null) { print.it($"cannot resolve link: [{k}]()"); return m.Value; }
			return $@"<a href=""{href}"">{k}</a>";
		}, out s);
		
		//in .md we use this for Google search links: [text](google:) or [text](google:urlencoded+google+query).
		//	To search only in microsoft.com (.NET/Windows API etc): [text](ms:) or [text](ms:urlencoded+google+query).
		//	The colon is to avoid DocFX warnings.
		//	Now convert it to a google search link.
		nr = s.RxReplace(@"<a href=""(ms|google):([^""]+)?"">(.+?)</a>", m => {
			string linkText = m[3].Value;
			string q = m[2].Value ?? WebUtility.UrlEncode(WebUtility.HtmlDecode(linkText));
			string site = m.Subject[m[1].Start] is 'm' ? "site:microsoft.com+" : null;
			return $@"<a href=""https://www.google.com/search?q={site}{q}"">{linkText}</a>";
		}, out s);
		if (s.Contains("<google>")) print.warning("<google> in .md files not supported. Use [text](google:) or [text](google:urlencoded+google+query)");
		if (s.Contains("<ms>")) print.warning("<ms> in .md files not supported. Use [text](ms:) or [text](ms:urlencoded+google+query)");
		
		return s;
	}
	
	public static string PostprocessHtmlCommon(string name, string s, bool isApi) {
		int nr;
		//javascript renderTables() replacement, to avoid it at run time. Also remove class table-striped.
		nr = s.RxReplace(@"(?s)<table(>.+?</table>)", @"<div class=""table-responsive""><table class=""table table-bordered table-condensed""$1</div>", out s);
		
		//the same for renderAlerts
		nr = s.RxReplace(@"<div class=""(NOTE|TIP|WARNING|IMPORTANT|CAUTION)\b",
			o => {
				string k = "info"; switch (o[1].Value[0]) { case 'W': k = "warning"; break; case 'I': case 'C': k = "danger"; break; }
				return o.Value + " alert alert-" + k;
			},
			out s);
		
		nr = s.RxReplace(@"<p>\s+", "<p>", out s); //<p>\n makes new line before. This is in notes only.
		
		_rxCss ??= new("""(?m)(\h*)(\Q<link rel="stylesheet" href="../styles/main.css">\E)""");
		//if(!_rxCss.IsMatch(s)) print.it(f.Name);
		s = _rxCss.Replace(s, "$1$2\n$1<link rel=\"stylesheet\" href=\"../styles/code.css\">", 1);
		
		_rxCode2 ??= new("""(?s)<code class="lang-(?: hljs|csharp)">(.+?)</code>""");
		s = _rxCode2.Replace(s, m => _Code(m[1].Value, isApi ? 1 : 2)); //syntax in api, and ```code``` in conceptual
		
		if (isApi) {
			_rxCode ??= new("""(?<=<pre>)%%(.+?)%%(?=</pre>)""");
			s = _rxCode.Replace(s, m => _Code(m[1].Value, 0)); //<code> in api
		}
		
		return s;
	}
	
	static regexp _rxCode, _rxCode2, _rxCss;
	
	public static string CreateCodeCss() {
		var s = LA.SciTheme.Default;
		var b = new StringBuilder();
		
		_Style("c", s.Comment);
		_Style("const", s.Constant);
		_Style("ex", s.Excluded);
		_Style("f", s.Function);
		_Style("k", s.Keyword);
		_Style("goto", s.Label);
		_Style("v", s.LocalVariable);
		_Style("ns", s.Namespace);
		_Style("n", s.Number);
		_Style("o", s.Operator);
		_Style("pre", s.Preprocessor);
		_Style("p", s.Punctuation);
		_Style("s", s.String);
		_Style("se", s.StringEscape);
		_Style("t", s.Type);
		_Style("x1", s.XmlDocTag);
		_Style("x2", s.XmlDocText);
		
		void _Style(string name, LA.SciTheme.TStyle k) {
			b.AppendFormat("pre span.{0}{{color:#{1:X6};", name, k.color);
			if (k.bold) b.Append("font-weight: bold;");
			b.AppendLine("}");
		}
		
		b.AppendLine("""

summary { display: list-item; }
details { margin-bottom: 10px; }
""");
		
		return b.ToString();
	}
	
	//note: runs in parallel threads.
	//where: 0 api <code>, 1 api syntax, 2 non-api
	static string _Code(string s, int where) {
		if (where == 0) {
			s = Encoding.UTF8.GetString(Convert.FromBase64String(s));
		} else {
			s = System.Net.WebUtility.HtmlDecode(s); //eg &lt; in generic parameters
			
			//remove/fix something in parameters
			if (where == 1) {
				s = s.RxReplace(@"\(\w+\)0", "0"); //(Enum)0 => 0
				s = s.RxReplace(@"\bdefault\([^)?]+\? *\)", "null"); //default(Nullable?) => null
				s = s.RxReplace(@"\bdefault\(.+?\)", "default"); //default(Struct) => default
				s = s.RxReplace(@"\[ParamString\(PSFormat\.\w+\)\] ", "");
				s = s.RxReplace(@" ?\*(?=\w)", "* ");
			}
		}
		
		using var ws = new AdhocWorkspace();
		var document = LA.CiUtil.CreateDocumentFromCode(ws, s, needSemantic: true);
		//var semo = document.GetSemanticModelAsync().Result;
		
		//at first set byte[] styles.
		//	Can't format text directly because GetClassifiedSpansAsync results may be overlapped, eg at first entire string and then its escape sequences.
		//	And it simplifies formatting.
		var a = new byte[s.Length];
		int prevEnd = 0; EStyle prevStyle = 0;
		foreach (var v in Classifier.GetClassifiedSpansAsync(document, TextSpan.FromBounds(0, s.Length)).Result) {
			var ct = v.ClassificationType;
			if (ct == ClassificationTypeNames.StaticSymbol) continue;
			EStyle style = LA.CiStyling.StyleFromClassifiedSpan(v);
			int start = v.TextSpan.Start, end = v.TextSpan.End;
			//print.it(style, s[start..end]);
			if (style == prevStyle && start > prevEnd && a[prevEnd] == 0) start = prevEnd; //join adjacent styles separated by whitespace
			prevEnd = end; prevStyle = style;
			a.AsSpan(start..end).Fill((byte)style);
		}
		
		var b = new StringBuilder("<code>"); //<code> isn't necessary; it disables Google translate (or would need attribute class="notranslate" or translate="no") and maybe better in some other cases I don't know
		for (int i = 0; i < a.Length;) {
			int start = i; byte u = a[i]; while (i < a.Length && a[i] == u) i++;
			string text = System.Net.WebUtility.HtmlEncode(s[start..i]);
			if (u == 0) {
				b.Append(text);
			} else {
				var k = (EStyle)u switch {
					EStyle.Comment => "c",
					EStyle.Constant => "const",
					EStyle.Excluded => "ex",
					EStyle.Function or EStyle.Event => "f",
					EStyle.Keyword => "k",
					EStyle.Label => "goto", //not "label", it is used in DocFX CSS
					EStyle.LocalVariable or EStyle.Field => "v",
					EStyle.Namespace => "ns",
					EStyle.Number => "n",
					EStyle.Operator => "o",
					EStyle.Preprocessor => "pre",
					EStyle.Punctuation => "p",
					EStyle.String => "s",
					EStyle.StringEscape => "se",
					EStyle.Type => "t",
					EStyle.XmlDocTag => "x1",
					EStyle.XmlDocText => "x2",
					_ => null,
				};
				b.AppendFormat("<span class=\"{0}\">", k);
				b.Append(text);
				b.Append("</span>");
			}
		}
		s = b.Append("</code>").ToString();
		
		//print.it("--------------");
		//print.it(s);
		try { System.Xml.Linq.XElement.Parse("<x>" + s + "</x>"); }
		catch (Exception e1) { print.warning(e1.ToStringWithoutStack()); print.it(s); }
		
		return s;
	}
	
	//static CSharpSemanticModel _CreateSemanticModelForCode(string code) {
	//	var trees = new CSharpSyntaxTree[] {
	//		CSharpSyntaxTree.ParseText(code, s_parseOpt) as CSharpSyntaxTree,
	//		CSharpSyntaxTree.ParseText(CiUtil.c_globalUsingsText, s_parseOpt) as CSharpSyntaxTree
	//	};
	//	var compilation = CSharpCompilation.Create("doc", trees, s_refs, s_compOpt);
	//	return compilation.GetSemanticModel(trees[0]) as CSharpSemanticModel;
	//}
	
	public static string UrlEscapePath(string s) {
		s = s.Replace('\\', '/');
		if (!s.Contains('/')) return Uri.EscapeDataString(s);
		return string.Join('/', s.Split('/').Select(o => Uri.EscapeDataString(o)));
	}
}


================================================
FILE: Scripts/Create NuGet package.cs
================================================
/// 1. Clones Au.csproj to a temp file, and modifies the clone: adds more target frameworks, updates version, etc.
/// 2. Deletes obj folder, builds the clone project and creates nuget package.
/// 3. Adds the native dlls to the package.
/// 4. Prints links.

using System.Xml.Linq;
using System.Xml.XPath;

print.clear();
var auDir = @"C:\code\au\Au";
var auProj_nuget = auDir + @"\+Au.csproj";

var x = XElement.Load(auDir + @"\Au.csproj");
var tf = x.XPathSelectElement("/PropertyGroup/TargetFramework");
tf.ReplaceWith(new XElement("TargetFrameworks", tf.Value + ";net8.0-windows"));
//tf.ReplaceWith(new XElement("TargetFrameworks", tf.Value + ";net8.0-windows;net6.0-windows")); //rejected. Too many places in code use API that are unavailable in .NET 6. And .NET 6 LTS ended. If somebody needs it, can find an older version of the library on NuGet.
x.XPathSelectElement("/PropertyGroup/Version").Value = typeof(osVersion).Assembly.GetName().Version.ToString(3);
x.XPathSelectElement("/PropertyGroup/Copyright").Value = $"Copyright (c) Gintaras Didžgalvis {DateTime.Now.Year}";
//x.XPathSelectElement("/Target[@Name='PreBuild']/Exec").Remove();
//print.it(x);
//return;
filesystem.saveText(auProj_nuget, x.ToString()); //not x.Save, it adds xml decl

var od = @"C:\code\au\Au\bin\Release";
filesystem.createDirectory(od);
foreach (var f in filesystem.enumFiles(od, "LibreAutomate.*.nupkg")) filesystem.delete(f.FullPath); //dotnet pack does nothing if the nupkg file exists
filesystem.delete(auDir + @"\obj");
int r = run.console(out var s, "dotnet.exe", $@"pack ""{auProj_nuget}"" -o {od} -c Release --nologo", auDir); //builds the clone project and creates nuget package
print.it(s);
//return;
if (r != 0) return;

filesystem.delete(auProj_nuget);
filesystem.delete(auDir + @"\obj");
filesystem.delete(auDir + @"\bin\Release\net9.0-windows");
filesystem.delete(auDir + @"\bin\Release\net8.0-windows");
//filesystem.delete(auDir + @"\bin\Release\net6.0-windows");

s.RxMatch(@"Successfully created package '(.+?)'", 1, out string path);
if (!filesystem.exists(path)) throw null;

using var za = ZipFile.Open(path, ZipArchiveMode.Update);
za.CreateEntryFromFile(@"C:\code\au\_\64\AuCpp.dll", @"runtimes\win-x64\native\AuCpp.dll");
za.CreateEntryFromFile(@"C:\code\au\_\64\ARM\AuCpp.dll", @"runtimes\win-arm64\native\AuCpp.dll");
za.CreateEntryFromFile(@"C:\code\au\_\32\AuCpp.dll", @"runtimes\win-x86\native\AuCpp.dll");
za.CreateEntryFromFile(@"C:\code\au\_\64\Au.DllHost.exe", @"runtimes\win-x64\native\Au.DllHost.exe");
za.CreateEntryFromFile(@"C:\code\au\_\64\ARM\Au.DllHost.exe", @"runtimes\win-arm64\native\Au.DllHost.exe");
za.CreateEntryFromFile(@"C:\code\au\_\32\Au.DllHost.exe", @"runtimes\win-x86\native\Au.DllHost.exe");

print.it($"<><explore>{path}<>");
print.it($"<><link>https://www.nuget.org/packages/manage/upload<>");


================================================
FILE: Scripts/LA docs for AI/AI summaries.cs
================================================
/// Creates/updates summaries in doc-ai.db. They will be used in semantic search, to improve results.
/// How: Takes texts from doc-ai.db, generates summaries using Gemini chat model, and stores in an intermediate DB. Finally copies the summaries to doc-ai.db.
/// Generates only for articles where the summary is missing or need to update. Skips short articles.

/*/
define SCRIPT
testInternal Au,Au.Editor
c AI search.cs;
c AiModel.cs;
c Ed util shared.cs;
c AI script common.cs;
/*/

using System.Security.Cryptography;
using System.Text.Json;
using AI;

//print.clear();
AiModel.ApiKeys = App.Settings.ai_ak;

#if !true
UserDefinedAiModels.Add();
//var model = new ModelGeminiChat("gemini-2.5-flash"); //good, compact; 3-10 s; 30/250 cents
var model = new ModelGeminiChat("gemini-2.5-flash-lite"); //good, compact, but often too compact, especially for non-API; 1.5 s; 10/40 cents

//var model = new ModelOpenaiChat("gpt-5-nano"); //
//var model = new ModelOpenaiChat("gpt-5-nano") { reasoning = "minimal" }; //good, less compact, sometimes too many details; 3-6 s; 5/40 cents
//var model = new ModelOpenaiChat("gpt-5-mini"); //
//var model = new ModelOpenaiChat("gpt-5-mini") { reasoning = "minimal" }; //good, less compact, sometimes too many details; 3-7 s; 25/200 cents
//var model = new ModelOpenaiChat("gpt-5"); //
//var model = new ModelOpenaiChat("gpt-4.1-nano"); //good format but sometimes with some understanding errors; 3 s; 10/40 cents
//var model = new ModelOpenaiChat("gpt-4.1-mini"); //good; 3 s; 40/160 cents

//var model = new ModelDeepseekChat(); //good, compact; 7.5 s

//var model = new ModelClaudeChat("claude-sonnet-4-0"); //good but minimal count; 3.5 s; with "prefer more" instruction bad (all) and slow
//var model = new ModelClaudeChat("claude-opus-4-1"); //bad; 9 s, sometimes hangs

//var model = new ModelMistralChat("mistral-medium-latest"); //like gpt-5-nano but even more details, 10 s

perf.first();
_Test();
perf.nw();
//print.scrollToTop();

void _Test() {
	string s;
	
	s = @"C:\Temp\Au\markdown\articles\[articles] About the automation library (files, namespaces).md";
	s = @"C:\Temp\Au\markdown\articles\[articles] UI element issues.md";
	s = @"C:\Temp\Au\markdown\articles\[articles] UAC.md";
	s = @"C:\Temp\Au\markdown\articles\[articles] Key names and operators.md";
	s = @"C:\Temp\Au\markdown\articles\[articles] Wildcard expression.md";
	s = @"C:\Temp\Au\markdown\articles\[articles] Output tags.md";
	//s = @"";
	
	s = @"C:\Temp\Au\markdown\editor\[editor] Code editor.md";
	s = @"C:\Temp\Au\markdown\editor\[editor] Command line.md";
	s = @"C:\Temp\Au\markdown\editor\[editor] Class files, projects.md";
	s = @"C:\Temp\Au\markdown\editor\[editor] Compared with QM.md";
	s = @"C:\Temp\Au\markdown\editor\[editor] Debugger.md";
	s = @"C:\Temp\Au\markdown\editor\[editor] File properties.md";
	//s = @"";
	
	s = @"C:\Temp\Au\markdown\cookbook\[cookbook] Autotext triggers, expand text.md";
	s = @"C:\Temp\Au\markdown\cookbook\[cookbook] Callback functions, lambda, delegate, event.md";
	s = @"C:\Temp\Au\markdown\cookbook\[cookbook] Clipboard copy, paste, set-get text etc.md";
	s = @"C:\Temp\Au\markdown\cookbook\[cookbook] Dialog - add elements, show, get values.md";
	s = @"C:\Temp\Au\markdown\cookbook\[cookbook] Http post web form, JSON.md";
	//s = @"";
	
	s = @"C:\Temp\Au\markdown\api\Au\dialog\Au.dialog.show.md";
	s = @"C:\Temp\Au\markdown\api\Au\dialog\Au.dialog.md";
	s = @"C:\Temp\Au\markdown\api\Au\clipboard\Au.clipboard.copyData.md";
	s = @"C:\Temp\Au\markdown\api\Au\clipboard\Au.clipboard.paste.md";
	s = @"C:\Temp\Au\markdown\api\Au\clipboard\Au.clipboard.text.md";
	s = @"C:\Temp\Au\markdown\api\Au\clipboard\Au.clipboard.clear.md";
	s = @"C:\Temp\Au\markdown\api\Au\clipboard\Au.clipboard.md";
	s = @"C:\Temp\Au\markdown\api\Au\consoleProcess\Au.consoleProcess.consoleProcess.md";
	s = @"C:\Temp\Au\markdown\api\Au\consoleProcess\Au.consoleProcess.Prompt.md";
	s = @"C:\Temp\Au\markdown\api\Au\mouse\Au.mouse.click.md";
	s = @"C:\Temp\Au\markdown\api\Au\keys\Au.keys.send.md";
	//s = @"";
	
	string name = pathname.getNameNoExt(s);
	string text = filesystem.loadText(s);
	
	_ProcessText(ref text);
	_ShowTextInOutput2(text);
	if (text.Length < 400) {
		print.it("SKIPPED", text.Length, text);
		return;
	}
	
	s = _GenerateSummary(name, text, model, true);
	print.it(s);
}

#else

var model = new ModelGeminiChat("gemini-2.5-flash-lite");

var dbFile = folders.ThisAppBS + "doc-ai.db";
using (var dbDoc = new sqlite(folders.ThisApp + "doc-ai.db")) {
	using var staDocSelect = dbDoc.Statement("SELECT name,text FROM doc");
	
	string tempDbPath = folders.LocalAppData + @"LibreAutomate\_dev\doc-ai-summary.db";
	using var dbTemp = new sqlite(tempDbPath);
	dbTemp.Execute("CREATE TABLE IF NOT EXISTS doc (name TEXT PRIMARY KEY, summary TEXT, hash BLOB)");
	using var staTempInsert = dbTemp.Statement("INSERT OR REPLACE INTO doc VALUES (?, ?, ?)");
	using var transTemp = dbTemp.Transaction(sqlOfDispose: "COMMIT");
	
	Dictionary<string, byte[]> dHash = [];
	using (var staTempSelectHash = dbTemp.Statement("SELECT name,hash FROM doc")) {
		while (staTempSelectHash.Step()) {
			dHash.Add(staTempSelectHash.GetText(0), staTempSelectHash.GetArray<byte>(1));
		}
	}
	
	while (staDocSelect.Step()) {
		string name = staDocSelect.GetText(0), text = staDocSelect.GetText(1);
		
		_ProcessText(ref text);
		if (text.Length < 400) {
			//print.it("SKIPPED", text.Length, text);
			continue;
		}
		
		//summary exists and is up to date?
		var hash = SHA256.HashData(text.ToUTF8());
		if (dHash.TryGetValue(name, out var hash2) && hash2.SequenceEqual(hash)) continue;
		
		print.it(name);
		perf.first();
		var sum = _GenerateSummary(name, text, model, false);
		perf.nw();
		//print.it(sum);
		
		staTempInsert.BindAll(name, sum, hash);
		staTempInsert.Step();
		staTempInsert.Reset();
		
		//if (!dialog.showYesNo("Continue?")) return;
		if (keys.isCapsLock) return;
	}
	
	//if (!dialog.showOkCancel("Finished", $"Copy temp summaries to doc-ai.db?")) return;
	using var staDocUpdate = dbDoc.Statement("UPDATE doc SET summary = ? WHERE name = ?");
	using var transDoc = dbDoc.Transaction();
	using var staTempSelect = dbTemp.Statement("SELECT name,summary FROM doc");
	while (staTempSelect.Step()) {
		string name = staTempSelect.GetText(0), sum = staTempSelect.GetText(1);
		staDocUpdate.BindAll(sum, name);
		staDocUpdate.Step();
		staDocUpdate.Reset();
	}
	transDoc.Commit();
	dbDoc.Execute("VACUUM");
}
filesystem.copyTo(dbFile, @"C:\code\Au.Editor", FIfExists.Delete);

print.it("DONE. Added summaries to doc-ai.db.");

#endif

static string _GenerateSummary(string name, string text, AiChatModel model, bool test) {
	bool isApi = !name.Starts('[');
	//var modelVerbosity = model.model switch { "gemini-2.5-flash-lite" => ModelVerbosity.Low, "gemini-2.5-flash" => ModelVerbosity.Medium, _ => ModelVerbosity.High };
	
	string system;
	const string c_footer = "The generated text will be used **only** to genarate AI embeddings for semantic search. Don't need details, because the original text will be included in the search too (it contains details).";
	if (isApi) {
		system = $$"""
The user message is a LibreAutomate API member documentation.
Need to prepare it for semantic search using AI embedding. Here is how:

1. Generate a concise list of documented features. Or a 1-sentence summary, if the documentation is short.
2. Then append a short comma-separated list of likely user search phrases and important tokens that users might query.

Don't include details, such as parameter names, default values, examples, notes, warnings, tips, alternatives.
{{c_footer}}

---

Output example for method `clipboard.paste(string text, string html = null, OKey options = null, KHotkey hotkey = default, int timeoutMS = 0)`:

- Pastes text or HTML into the focused app using the clipboard
- Sets clipboard data, sends keys `Ctrl+V`, waits until the target app gets clipboard data, and restores old clipboard data
- You can specify a custom hotkey, timeout, and other options

Search keywords: clipboard, paste, text, html, Ctrl+V, restore clipboard
""";
	} else if (name.Starts(@"[cookbook]")) {
		system = $$"""
The user message is a LibreAutomate cookbook article.
Need to prepare it for semantic search using AI embedding. Here is how:

1. Generate a summary.
2. Then append a short comma-separated list of likely user search phrases and important tokens that users might query.

{{c_footer}}
""";
	} else {
		system = $$"""
The user message is a LibreAutomate documentation article.
Need to prepare it for semantic search using AI embedding. Here is how:

1. Generate a summary. One or two sentences.
2. Then append a concise list of documented features, without details or examples. Skip this if there is nothing that is not already in the generated summary.
3. Then append a short comma-separated list of likely user search phrases and important tokens that users might query.

{{c_footer}}
""";
		if (name is "[articles] Key names and operators") system += "\r\nIMPORTANT: also add the list of keys from the \"Named keys\" section.";
	}
	//print.it(system);return;
	
	var post = model.GetPostData(system, [new(ACMRole.user, text)], 0.2);
	var r = model.Post(post, model.GetHeaders());
	var json = r.Json();
	//print.it(json.ToJsonString(new(System.Text.Json.JsonSerializerDefaults.Web) { WriteIndented = true }));
	return model.GetAnswer(json).text;
}

static void _ProcessText(ref string s) {
	//s = s.RxReplace(@"\R##(?:## Examples|### Exceptions|# See Also)(\R(?!##).*)+", "");
	//s = s.RxReplace(@"^(# (?:Method|Operator|Constructor|Indexer).+\R(\R.+)+\R)\R```\R.+\R```\R", "$1", 1);
	s = s.RxReplace(@"\R###+ (?:Exceptions|See [Aa]lso)(\R(?!##).*)+", "");
}

//static void _ShowTextInOutput2(string s) {
//	var w1 = wnd.find("Output2");
//	if (!w1.Is0) w1.SetText(s);
//}

//enum ModelVerbosity { Low, Medium, High }


================================================
FILE: Scripts/LA docs for AI/Upload AI embeddings.cs
================================================
/// Uploads an AI embeddings storage file to the LA website.
/// Currently used only for icons embeddings.
/// To run, click link printed by Embeddings._GetEmbeddings. Can't run directly because need a hash etc.
/// It prints the link when created new embeddings. To print always when UI-searching, temporarily enable the `//emFile.PrintUploadIfAtHome`.

/*/ c Sftp.cs; c Ed util shared.cs; /*/

string file = args[0], zipName = args[1];
//print.it(file, zipName);

if (!dialog.showOkCancel("Upload AI embedding vectors", zipName)) return;

string zipFile = folders.ThisAppTemp + zipName;
try {
	if (!LA.SevenZip.Compress(out var errors, zipFile, file)) { print.it(errors); return; }
	
	//run.selectInExplorer(zipFile);
	Sftp.UploadToLA("domains/libreautomate.com/public_html/download/ai/embedding", zipFile);
	
	print.it($"Uploaded: {file} -> https://www.libreautomate.com/download/ai/embedding/{zipName}");
}
finally { filesystem.delete(zipFile, FDFlags.CanFail); }


================================================
FILE: Scripts/Minimal .NET SDK.cs
================================================
/// Creates minimal .NET SDK for LA NuGet and Publish features.
/// Downloads full SDK to a temp folder, and gets only folders used by these features (tested).
/// Each platform folder is less than 100 MB; compressed less than 30 MB (full SDK is 200).
/// Finally prints an Upload link (https://www.libreautomate.com/download/sdk).
/// LA on user computers will auto-download when need.
/// Also installs the minimal SDK in `folders.Editor + "SDK"`. Must be x64 computer.

/*/ nuget -\SSH.NET; c Sftp.cs; c Passwords.cs; /*/

//#define DEV

using Renci.SshNet;

if (args is ["upload"]) { //clicked link 'Upload'
	MinimalSDK.Upload();
	return;
}

print.clear();

var m = new MinimalSDK();
m.CreateX64();
#if !DEV
m.CreateArm64();
#endif
m.Finally();

#if DEV
MiscScripts.CreateListOfMinSdkFilesForDiff(@"SDK\sdk\10.0.100");
MiscScripts.CreateListOfMinSdkFilesForDiff(@"SDK-9\sdk\9.0.101");
#endif

class MinimalSDK {
	const string c_version = "10.0.100"; //edit this if need. The SDK must use the first Runtime build, eg 9.0.0 and not 9.0.1 etc. Because the SDK can't be used on computers with older Runtime.
#if !NET10_0
#error please update c_version string
#endif
	bool _arm64;
	string _dirDotnet1, _dirDotnet2;
	
	static readonly string _TempDirBS = folders.ThisAppTemp + @"net-sdk-script-data\";
	
	public void CreateX64() {
		if (osVersion.isArm64OS) throw new PlatformNotSupportedException("Must be x64");
		print.it("-- Creating x64 --");
		_arm64 = false;
		_dirDotnet1 = $"{_TempDirBS}full {c_version} x64";
		_dirDotnet2 = folders.Editor + "SDK";
		_Create();
	}
	
	public void CreateArm64() {
		print.it("-- Creating arm64 --");
		_arm64 = true;
		_dirDotnet1 = $"{_TempDirBS}full {c_version} arm64";
		_dirDotnet2 = $"{_TempDirBS}minimal {c_version} arm64";
		_Create();
	}
	
	public void Finally() {
		//var site = "https://dash.cloudflare.com/";
		var site = "https://www.libreautomate.com/download/sdk";
		print.it($"<>-- DONE --\r\n<script {script.name}.cs|upload>Upload<> the zip files to {site} and delete temp folder <link {_TempDirBS}>net-sdk-script-data<>.");
	}
	
	public static void Upload() {
		print.it("Uploading. Wait until DONE.");
		var zip1 = $"{_TempDirBS}sdk-{Environment.Version.ToString(2)}-x64.zip";
		var zip2 = $"{_TempDirBS}sdk-{Environment.Version.ToString(2)}-arm64.zip";
		Sftp.UploadToLA("domains/libreautomate.com/public_html/download/sdk", zip1, zip2);
		print.it("DONE");
		if (dialog.showYesNo("Delete temp folder?", _TempDirBS)) filesystem.delete(_TempDirBS);
	}
	
	void _Create() {
		_DownloadSdk();
		_CreateFolder();
		_CopyRootFiles();
#if !DEV
		_Create7z();
#endif
		if (!_arm64) {
			filesystem.more.createSymbolicLink(_dirDotnet2 + @"\host", @"C:\Program Files\dotnet\host", CSLink.Junction);
			filesystem.more.createSymbolicLink(_dirDotnet2 + @"\shared", @"C:\Program Files\dotnet\shared", CSLink.Junction);
		}
	}
	
	void _DownloadSdk() {
		if (filesystem.exists(_dirDotnet1)) return;
		string zipName = $"dotnet-sdk-{c_version}-win-{(_arm64 ? "arm64" : "x64")}.zip";
		var sevenzip = folders.Editor + @"32\7za.exe";
		string zipFile = _TempDirBS + zipName;
		if (!filesystem.exists(zipFile)) {
			print.it("Downloading SDK...");
			string url = $"https://builds.dotnet.microsoft.com/dotnet/Sdk/{c_version}/{zipName}";
			internet.http.Get(url, zipFile + "~");
			filesystem.rename(zipFile + "~", zipName);
		}
		
		print.it("Extracting SDK...");
		if (0 != run.console(out var s, sevenzip, $@"x -aoa -o""{_dirDotnet1}"" ""{zipFile}""")) {
			filesystem.delete(_dirDotnet1);
			throw new AuException($"*extract. {s}");
		}
	}
	
	void _CreateFolder() {
		print.it("Creating folder");
		
		string dirSdk1 = $@"{_dirDotnet1}\sdk\{c_version}";
		string dirSdk2 = $@"{_dirDotnet2}\sdk\{c_version}";
		
		if (!filesystem.exists(dirSdk1)) throw new ArgumentException("Please edit SDK version in this script");
		
		filesystem.delete(_dirDotnet2);
		
		long size = 0;
		var a1 = filesystem.enumFiles(dirSdk1, flags: FEFlags.AllDescendants | FEFlags.NeedRelativePaths).ToArray();
		foreach (var f in a1) {
			var path = f.FullPath;
			var rel = f.Name;
			
			if (rel.Ends(".resources.dll", true)) continue;
			if (rel.Find(@"\net4", true) > 0) continue;
			if (rel.Find(@"\netframework", true) > 0) continue;
			if (rel.Find("FSharp", true) > 0) continue;
			if (rel.Find("VisualBasic", true) > 0) continue;
			
			var a = rel.Lower().Split('\\', StringSplitOptions.RemoveEmptyEntries);
			if (a.Length > 1) {
				switch (a[0]) {
				case "dotnettools" or "extensions" or "fsharp" or "testhostnetframework": continue; //not used, big
				case "apphosttemplate" or "ref" or "runtimes" or "trustedroots": break; //maybe not used, but small
				case "current" or "microsoft" or "sdkresolvers": break; //used, small
				case "containers":
					if (!(a[1] is "build")) continue;
					break;
				case "roslyn":
					if (a[^1].Ends(".visualbasic.dll")) continue;
					//tested: does not work with the 2 *CodeAnalysis* dlls replaced with those from the LA Roslyn folder. Would be 7z 26 -> 18 MB.
					break;
				case "sdks" when a.Length > 2:
					if (a[1] is "microsoft.net.sdk" or "microsoft.net.sdk.windowsdesktop" or "microsoft.net.sdk.publish") {
						if (a[^2] is "vb") continue;
					} else if (a[1] is "microsoft.net.sdk.razor" or "microsoft.net.sdk.staticwebassets" or "microsoft.net.sdk.blazorwebassembly" or "fsharp.net.sdk") {
						continue;
					} else {
						if (!(a[2] is "build" or "tools" or "targets")) continue;
					}
					break;
				default:
					print.it(rel);
					break;
				}
			} else {
				if (a[0] is "microsoft.codeanalysis.dll" or "microsoft.codeanalysis.csharp.dll") continue; //duplicates of those in `Roslyn\bincore`. Large. Used only by dotnet.dll (see script `.NET SDK dll dependencies`), but not for nuget/build/publish.
				//print.it(a[0]);
			}
			
			filesystem.copy(path, dirSdk2 + rel);
			
			size += f.Size;
		}
		print.it($"Folder size: {double.Round(size / (1024 * 1024d), 1)}");
	}
	
	void _CopyRootFiles() {
		////copy dotnet.exe and license txt files.
		//foreach (var f in filesystem.enumFiles(_dirDotnet1)) {
		//	var path = f.FullPath;
		//	//print.it(path);
		//	filesystem.copyTo(path, _dirDotnet2);
		//}
		
		filesystem.copyTo(_dirDotnet1 + @"\dotnet.exe", _dirDotnet2);
	}
	
	void _Create7z() {
		print.it("Compressing...");
		
		var filename = $"sdk-{Environment.Version.ToString(2)}-{(_arm64 ? "arm64" : "x64")}.zip"; //note: it's 7z, but Hostinger for 7z does not set `content-length` header (no progress); also `content-type: text/plain`
		var zipFile = _TempDirBS + filename;
		filesystem.delete(zipFile);
		
		var sevenzip = folders.Editor + @"32\7za.exe";
		if (0 != run.console(out var s, sevenzip, $@"a ""{zipFile}"" ""{_dirDotnet2}\*"" -t7z -mx=7")) throw new AuException(s);
	}
}

static class MiscScripts {
	public static void CreateListOfMinSdkFilesForDiff(string dirName) {
		var dir = folders.ThisAppBS + dirName;
		List<string> a = [];
		foreach (var f in filesystem.enumerate(dir, FEFlags.AllDescendants | FEFlags.NeedRelativePaths)) {
			a.Add(f.Name);
		}
		var s = string.Join('\n', a);
		dirName = dirName[..dirName.IndexOf('\\')];
		filesystem.saveText($@"C:\Test\{dirName}.txt", s);
	}
}


================================================
FILE: Scripts/Update version.txt.cs
================================================
/*/ role editorExtension; c Sftp.cs; /*/
using System.Runtime.Loader;

var ver = typeof(osVersion).Assembly.GetName().Version.ToString(3);
var ver2 = AssemblyLoadContext.Default.Assemblies.First(o => o.GetName().Name == "Au.Editor").GetName().Version.ToString(3);
if (ver2 != ver) throw new InvalidOperationException("editor project not compiled");

var file = folders.ThisAppBS + "version.txt";
filesystem.saveText(file, ver);
Sftp.UploadToLA("domains/libreautomate.com/public_html", file);

print.it("Uploaded: version.txt", ver);


================================================
FILE: Scripts/old/VS goto.cs
================================================
var s = args.Length == 0 ? "Au.clipboard.copy" : args[0];

if (s.Ends("..ctor")) s=s[..^6];
else {
	int i=s.Find(".op_");
	if(i>0) s=s[..i];
}

var w = wnd.find(0, "Au -* Microsoft Visual Studio*", "HwndWrapper[DefaultDomain;*");
w.Activate();
//keys.send("Ctrl+T");
keys.send("Ctrl+(1 S)");
clipboard.paste(s);
mouse.move(screen.primary);
//if (miscInfo.getTextCursorRect(out var r, out _)) mouse.move(r); else mouse.move(screen.primary);


================================================
FILE: Scripts/old/Windows SDK to C#/@SDK converter/Classes.cs
================================================
namespace SdkConverter;

unsafe partial class Converter {
	enum _KeywordT : byte {
		Any,
		Normal,
		TypeDecl, //enum, struct, union, class, __interface, typedef
		CallConv, //__stdcall etc
		PubPrivProt, //public, private, protected
		IgnoreFuncEtc, //inline, template, operator, static_assert
		
		//Declspec, //__declspec(...) //removed in script
		//Ignore, //volatile etc //removed in script
	}
	
	class _Namespace {
		/// <summary>
		/// Symbols of current namespace. Types, typedef etc. Not C++ keywords/types.
		/// </summary>
		public Dictionary<_Token, _Symbol> sym = new Dictionary<_Token, _Symbol>();
		
		/// <summary>
		/// Formats members and nested types of current namespace. Cleared/reused for each type.
		/// </summary>
		public StringBuilder sb = new StringBuilder();
		
		/// <summary>
		/// Clears sym and sb.
		/// </summary>
		public void Clear() {
			sym.Clear();
			sb.Clear();
		}
	}
	
	class _Symbol {
		public string csTypename;
		public bool forwardDecl;
	}
	
	class _Keyword : _Symbol {
		public _KeywordT kwType;
		public bool cannotStartStatement;
		
		public _Keyword(_KeywordT kwType = _KeywordT.Normal, bool cannotStartStatement = false) {
			this.kwType = kwType;
			this.cannotStartStatement = cannotStartStatement;
		}
	}
	
	class _CppType : _Symbol {
		public byte sizeBytesCpp;
		public bool isUnsigned;
		
		public _CppType(string csTypename, int sizeBytesCpp, bool isUnsigned) {
			this.csTypename = csTypename;
			this.sizeBytesCpp = (byte)sizeBytesCpp;
			this.isUnsigned = isUnsigned;
		}
	}
	
	class _Enum : _Symbol {
		public char[] defAfterName;
		public bool isFlags;
		
		public _Enum(string csTypename, bool forwardDecl) {
			this.csTypename = csTypename;
			this.forwardDecl = forwardDecl;
		}
		
		public static _Enum Copy(_Enum x, string name) {
			var r = new _Enum(name, x.forwardDecl);
			r.defAfterName = x.defAfterName;
			r.isFlags = x.isFlags;
			return r;
		}
	}
	
	class _Struct : _Symbol {
		public bool isInterface, isDualInterface, isClass;
		public char[] attributes, members;
		
		public _Struct(string csTypename, bool forwardDecl) {
			this.csTypename = csTypename;
			this.forwardDecl = forwardDecl;
		}
		
		public static _Struct Copy(_Struct x, string name) {
			var r = new _Struct(name, x.forwardDecl);
			r.isInterface = x.isInterface;
			r.isDualInterface = x.isDualInterface;
			r.attributes = x.attributes;
			r.members = x.members;
			return r;
		}
	}
	
	class _Callback : _Symbol {
		public _Callback(string csTypename) {
			this.csTypename = csTypename;
		}
	}
	
	class _Typedef : _Symbol {
		/// <summary>
		/// pointer (1 if *, 2 if ** and so on)
		/// </summary>
		public byte ptr;
		/// <summary>
		/// Is const.
		/// </summary>
		public bool isConst;
		/// <summary>
		/// Used when swapping tagX with X in 'typedef tagX{...}X'. Then true if tagX was forward-declared. Later used mostly to make conversion faster.
		/// </summary>
		public bool wasForwardDecl;
		/// <summary>
		/// struct etc for which this typedef is alias.
		/// </summary>
		public _Symbol aliasOf;
		
		public _Typedef(_Symbol aliasOf, int ptr, bool isConst, bool wasForwardDecl = false) {
			this.aliasOf = aliasOf;
			this.ptr = (byte)ptr;
			this.isConst = isConst;
			this.wasForwardDecl = wasForwardDecl;
		}
	}
	
	//class _Func
	//{
	
	//}
	
	struct _Token : IEquatable<_Token> {
		public char* s { get; private set; }
		public int len { get; private set; }
		
		public _Token(char* S, int length) {
			s = S;
			len = length;
		}
		
		public bool Equals(_Token t) {
			if (t.len != len) return false;
			for (int i = 0; i < len; i++) if (t.s[i] != s[i]) return false;
			return true;
		}
		
		public bool Equals(string s) {
			if (s.Length != len) return false;
			for (int i = 0; i < len; i++) if (s[i] != this.s[i]) return false;
			return true;
		}
		
		public bool StartsWith(string s) {
			int n = s.Length;
			if (n > len) return false;
			for (int i = 0; i < n; i++) if (s[i] != this.s[i]) return false;
			return true;
		}
		
		public override int GetHashCode() {
			return (int)_HashFnv1(s, len);
		}
		
		public override string ToString() {
			return new string(s, 0, len);
		}
		
		public static implicit operator char*(_Token t) { return t.s; }
		
		//FNV-1 hash.
		//2 times faster than Crc, but less accurate.
		//If length<0, data must be \0-terminated string. Then same speed (does not call Len).
		static uint _HashFnv1(char* data, int length = -1) {
			uint hash = 2166136261;
			
			if (length >= 0) {
				for (int i = 0; i < length; i++)
					hash = (hash * 16777619) ^ data[i];
				//hash = (hash ^ p[i]) * 16777619; //FNV-1a, slower
			} else {
				char ch;
				while ((ch = *data++) != '\0') hash = (hash * 16777619) ^ ch;
			}
			
			return hash;
		}
	}
}


================================================
FILE: Scripts/old/Windows SDK to C#/@SDK converter/Constants.cs
================================================
namespace SdkConverter;

unsafe partial class Converter {
	void _DefineUndef() {
		char* s = T(++_i);
		char c = *s; //was like `d$$$_REALNAME, now s is without `
		
		if (c == 'c') { //`cx "C# code converted by the preprocessor script", where x tells what it is
			if (!_TokIsChar(++_i, '\x2')) _Err(_i, "unexpected 1");
			_tok[_i] = new _Token(T(_i) + 1, _tok[_i].len - 2);
			if (s[1] == 'p') {
				_sbVar.AppendLine(_TokToString(_i));
			} else _Err(_i - 1, "unexpected 2");
			return;
		}
		
		s += 5; int lenName = _tok[_i].len - 5; //skip prefix 'd$$$_' that was added to avoid unexpanding names
		_tok[_i] = new _Token(s, lenName);
		int iName = _i;
		
		//is function-style?
		char* s2 = T(++_i);
		bool isFunc = c == 'd' && *s2 == '(' && s2 == s + lenName;
		
		//find value
		int iValue = _i, iParamOrValue = _i;
		if (isFunc) iValue = _SkipEnclosed(_i) + 1; //name(parameters)[ value]
		
		//find next line
		int iNext = iValue;
		for (; ; iNext++) {
			char k = *T(iNext);
			if (k == '`' || k == '\x0') break;
		}
		
		string name = new string(s, 0, lenName);
		if (c == 'u') { //#undef
			if (!_defineConst.Remove(name) && !_defineOther.Remove(name)) _defineW.Remove(name);
			//print.it($"#undef {name}");
		} else if (iValue < iNext) { //preprocessor removes some #define values, it's ok
			if (isFunc) { //info: for func-style get parameters as part of value
				__DefineAddToOther(iName, name, _TokToString(iParamOrValue, iNext));
			} else if (*s2 == '\x2') { //ANSI string constant, when tokenizing replaced the first '"' to '\x2'
				*s2 = '"';
				__DefineAddToOther(iName, name, " " + _TokToString(iParamOrValue, iNext) + " //ANSI string");
			} else {
				_ExpressionResult r = _Expression(iParamOrValue, iNext, name);
				if (r.typeS == null) {
					bool isFuncWA = (iNext - iValue == 1) && __DefineWA(name, r.valueS);
					if (!isFuncWA) {
						//don't add '#define NAME1 NAME2'
						if (iNext - iValue == 1 && _TokIsIdent(iValue)) {
							//print.it(name, r.valueS);
						} else {
							//print.it(name, iNext-iValue);
							__DefineAddToOther(iName, name, " " + r.valueS);
						}
					}
				} else {
					__sbDef.Clear();
					if (name.Starts("WM_") && r.typeS == "uint") r.typeS = "int";
					__sbDef.AppendFormat("internal {2} {3} {0} = {1};", name, r.valueS, r.notConst ? "readonly" : "const", r.typeS);
					_defineConst[name] = __sbDef.ToString();
				}
			}
		}
		
		_i = iNext - 1;
	}
	
	void __DefineAddToOther(int iName, string name, string value) {
		//remove those that match other identifiers
		if (_SymbolExists(iName, false) || _func.ContainsKey(name)) {
			//print.it(name);
			return;
		}
		
		_defineOther[name] = value;
	}
	
	StringBuilder __sbDef = new StringBuilder();
	
	bool __DefineWA(string name, string value) {
		int suffixLen = 0;
		if (value.Length == name.Length + 1 && value.Ends("W")) suffixLen = 1;
		else if (value.Length == name.Length + 2 && value.Ends("_W")) suffixLen = 2; //some struct
		if (!(suffixLen > 0 && value.Starts(name))) {
			//print.it($"<><c 0xff>{name}    {value}</c>");
			return false;
		}
		
		string def;
		if (suffixLen == 1 && _func.TryGetValue(value, out def)) {
			_func.Remove(name + "A");
			//most are FuncA+FuncW, but some Func/FuncW and even Func/FuncA/FuncW. Some just FuncW.
			if (_func.Remove(name)) {
				//print.it(1, def); //6 in SDK
			}
			
			def = def.Replace("W(", "(");
			
			if (!def.Contains(", EntryPoint=\"")) {
				def = def.Replace(")]", ", EntryPoint=\"" + value + "\")]");
			}
			
			_func[value] = def;
			
			//print.it($"<><c 0xff0000>{name}    {value}</c>");
			//print.it(def);
			return true;
		} else {
			_Symbol x;
			if (_ns[0].sym.TryGetValue(_TokenFromString(value), out x)) {
				var t = x as _Struct;
				if (t != null || x is _Callback) {
					//if(x is _Struct) print.it($"<><c 0xff0000>{name}    {value}</c>");
					//else print.it($"<><c 0x8000>{name}    {value}</c>");
					int v = (t == null) ? 2 : (t.isInterface ? 1 : 0);
					if (suffixLen == 2) v |= 0x10000;
					_defineW[name] = v; //later will replace all STRUCTW to STRUCT in the final string of struct/func/delegate/interface
					return true;
				}
				//else if(x is _Typedef) {
				//	print.it($"<><c 0x80>{name}    {value}</c>");
				//} else {
				//	print.it($"<><c 0xFF>{name}    {value}</c>"); //0
				//}
				
			} else {
				//print.it($"<><c 0xff>{name}    {value}</c>");
				
			}
		}
		
		return false;
	}
	
	void _ConstantsFinally(StreamWriter writer) {
		//'#define' constants
		foreach (var v in _defineConst) {
			//if string constant name ends with "W", remove this if non-W version exists, and remove A version
			string s = v.Value;
			if (s.Ends("\";") && v.Key.Ends("W")) {
				//print.it($"{v.Key} = {s}");
				string k = v.Key.Remove(v.Key.Length - 1); //name without "W"
				
				//remove A version from _defineOther
				if (_defineOther.Remove(k + "A")) {
					//print.it($"removed A version: {v.Key} = {s}");
				}
				//remove this W version if non-W version exists
				string s2;
				if (_defineConst.TryGetValue(k, out s2) && s2.Length == s.Length - 1) {
					int i = s.Find("W = ");
					if (s2 == s.Remove(i, 1)) {
						//print.it($"removed W version because non-W exists: {v.Key} = {s}");
						continue;
					}
				}
			}
			writer.WriteLine(s);
		}
		
		//'const' constants
		foreach (var con in _cppConst) { writer.WriteLine(con); }
		
		//'#define' function-style macros and other macros that cannot convert to C#
		writer.Write("\r\n// CANNOT CONVERT\r\n\r\n");
		foreach (var v in _defineOther) {
			//if(v.Value.Starts(" \"")) print.it($"<><c 0xff>{v.Key} = {v.Value}</c>"); //11 in SDK (more removed by the above code)
			
			writer.Write("internal const string {0} = null; //#define {0}{1};\r\n\r\n", v.Key, v.Value);
		}
	}
}


================================================
FILE: Scripts/old/Windows SDK to C#/@SDK converter/Converter.cs
================================================
namespace SdkConverter;

unsafe partial class Converter {
	string _cppFile;
	bool _is32bit;
	
	char[] _src; //C/C++ source code
	char* _s0; //_src start
	
	StringBuilder _sbInterface = new();
	//StringBuilder _sbCoclass = new();
	StringBuilder _sbVar = new();
	StringBuilder _sbInlineDelegate = new(); //from callback function types defined in parameter list or member list
	
	List<_Token> _tok = new();
	int _nTok; //token count, except the last '\0' tokens
	int _nTokUntilDefUndef; //token count until first `d or `u (was #define/#undef), except the separating '\0' token
	int _i; //current token
	
	_Namespace[] _ns = new _Namespace[10]; //stack of namespaces
	int _nsCurrent; //index in _ns
	StringBuilder _sbType; //_ns[_nsCurrent].sb
	Dictionary<_Token, _Symbol> _keywords = new();
	
	Dictionary<string, string> _func = new(); //function declaration
	StringBuilder _sbFuncTemp = new(); //used to format _func values
	
	List<string> _cppConst = new(); //const CONSTANT
	
	Dictionary<string, string> _defineConst = new(); //#define CONSTANT
	Dictionary<string, int> _defineW = new(); //#define STRUCT STRUCTW
	Dictionary<string, string> _defineOther = new(); //#define MACRO(...)
	
	Stack<int> _packStack = new(); int _pack = 8; //#pragma pack
	
	int _anonymousStructSuffixCounter; //used to create unique name for anonymous struct
	
	/// <summary>
	/// Converts C++ header-list file cppFile to C# declarations and saves in file csFile.
	/// </summary>
	/// <param name="is32bit">Prefer 32-bit. Although the converter tries to create declarations that don't depend on 32/64 bit, in some places it will create different declaration if this is true, for example IntPtr size will be 4 bytes.</param>
	public void Convert(string cppFile, string csFile, bool is32bit) {
		_cppFile = cppFile;
		_is32bit = is32bit;
		
		try {
			if (_src != null) throw new Exception("cannot call Convert multiple times. Create new Converter instance.");
			
			using (var reader = new StreamReader(_cppFile)) {
				long n = reader.BaseStream.Length + 4; if (n > int.MaxValue / 4) throw new Exception("file too big");
				reader.Read(_src = new char[n], 0, (int)n);
			}
			
			_InitTables();
			_InitSymbols();
			_InitMaps();
			_InitCsKeywords();
			
			string stf = null;
			
			fixed (char* p = _src) {
				_s0 = p;
				_Tokenize(p);
				_InitInterfaces();
				
				//Test(); return;
				
				_i = 1;
				_ConvertAll(0);
				
				//_ConvertTypedefAndTag();
				
				//print.it("#define CONST:");
				//print.it(_defineConst);
				//print.it("#define other:");
				//print.it(_defineOther);
				//print.it(_defineConst.Count, _defineOther.Count);
				//27890, 1061
				//27659, 998
				//27605, 983
				
				_FunctionsFinally();
				
				stf = _PostProcessTypesFunctionsInterfaces();
				//print.it(stf);
			}
			
			string sh = @"// Windows API declarations for C#.
// Don't add this file to your project. Copy-paste only declarations that you need.
// Not all declarations can be compiled without editing.
//    For example, cannot declare some struct pointer (use IntPtr instead, or in struct replace non-blittable types with IntPtr etc), cannot use undefined struct pointer/ref/out (use IntPtr instead).
// Not all declarations are correct, usually because declarations in Windows SDK files from which they have been automatically converted lack some info.
//    For example, some function parameters that should be 'out' or '[Out]' or '[In]' or array now are just 'ref', because SDK declarations didn't have proper in/out annotations. Also for this reason some parameters that should be 'string' now are 'char*'.
//    You may want to create overloads where parameters can be of more than one type.
//    You may want to add 'SetLastError=true' to DllImport attribute parameters.
// Some declarations contain pointers and therefore can be used only in 'unsafe' context, in some cases with 'fixed'. Or you can replace pointers to IntPtr.
// These declarations are for Windows 10. Some Windows API are different or missing on other Windows versions.
// In some cases need to use different declarations in 32-bit and 64-bit process. This file contains everything that is not different, + 64-bit versions, + 32-bit versions with name suffix ""__32"".

using System;
using System.Runtime.InteropServices;
#if true
using Au;
using Au.Types;
#else
using wnd = System.IntPtr; //HWND (window handle)
#endif

//add this to projects that will use these API
[module: DefaultCharSet(CharSet.Unicode)]

static unsafe class API
{
";
			
			using (var writer = new StreamWriter(csFile)) {
				writer.Write(sh);
				writer.Write(stf);
				//if(_sbType.Length > 0 || _sbInterface.Length > 0) {
				//	writer.Write("\r\n// USED TAG-TYPES\r\n");
				//	if(_sbType.Length > 0) writer.Write(_sbType.ToString());
				//	if(_sbInterface.Length > 0) writer.Write(_sbInterface.ToString());
				//}
				//writer.WriteLine("\r\n// COCLASS");
				//writer.Write(_sbCoclass.ToString());
				writer.WriteLine("\r\n// VARIABLE");
				writer.Write(_sbVar.ToString());
				writer.WriteLine("\r\n// CONSTANT\r\n");
				_ConstantsFinally(writer);
				writer.Write("\r\n}\r\n");
			}
		}
		//#if !TEST_SMALL
		catch (Exception e) { _OnCatchException(e); throw; }
		//#endif
		finally {
			Marshal.FreeHGlobal((IntPtr)_keywordMemory);
		}
		
		print.it($"DONE {(is32bit ? 32 : 64)}-bit");
	}
	
	char* _keywordMemory;
	char* _km; //current keyword
	
	void _AddKeyword(string name, _Symbol sym) {
		char* n = _km;
		for (int i = 0; i < name.Length; i++) *_km++ = name[i];
		_keywords.Add(new _Token(n, (int)(_km - n)), sym);
		*_km++ = '\0';
	}
	
	void _AddKeywords(_Symbol sym, params string[] names) {
		foreach (string s in names) {
			_AddKeyword(s, sym);
		}
	}
	
	void _InitSymbols() {
		for (int i = 0; i < _ns.Length; i++) _ns[i] = new _Namespace();
		_sbType = _ns[0].sb;
		
		_km = _keywordMemory = (char*)Marshal.AllocHGlobal(4000);
		
		//Add C++ keywords and types, except those that can only be in function body or other places where we skip.
		//The commented keywords/types are currently not supported and not expected to be in C/C++ headers that we'll parse.
		
		_Keyword k;
		
		//_AddKeywords(new _Keyword(cannotStartStatement:true), "__based", "_based"); //0 in SDK
		//_AddKeyword("__event", new _Keyword()); //0 in SDK
		//_AddKeyword("__identifier", new _Keyword()); //0 in SDK
		//_AddKeywords(new _Keyword(), "__if_exists", "_if_exists", "__if_not_exists", "_if_not_exists"); //0 in SDK. Usually used only in function body.
		//_AddKeywords(new _Keyword(cannotStartStatement: true), "__multiple_inheritance", "_multiple_inheritance", "__single_inheritance", "_single_inheritance", "__virtual_inheritance", "_virtual_inheritance"); //0 in SDK
		//_AddKeyword("__uuidof", new _Keyword(cannotStartStatement: true)); //should be only in function body
		//_AddKeyword("alignas", k = new _Keyword(cannotStartStatement: true)); //removed in script
		//_AddKeywords(new _Keyword(cannotStartStatement: true), "alignof", "__alignof"); //should be only in function body
		//_AddKeywords(new _Keyword(cannotStartStatement: true), "false", "true", "nullptr"); //we add enum values for it
		//_AddKeyword("property", k = new _Keyword()); //0 in SDK
		//_AddKeyword("signed", k = new _Keyword()); //replaced in script
		//_AddKeywords(new _Keyword(cannotStartStatement: true), "throw", "noexcept"); //eg void f() throw(int); //will be skipped together with functions
		//_AddKeyword("unsigned", k = new _Keyword()); //replaced in script
		
		k = new _Keyword(cannotStartStatement: true);
		_AddKeyword("sizeof", k); //can be like 'member[sizeof(X)]' or '#define X sizeof(Y)'
		
		k = new _Keyword();
		_AddKeyword("const", k);
		_AddKeyword("extern", k);
		_AddKeyword("namespace", k); //0 in SDK (1 in CRT, which is removed)
		_AddKeyword("using", k);
		_AddKeyword("virtual", k);
		
		k = new _Keyword(_KeywordT.TypeDecl);
		_AddKeyword("__interface", k);
		_AddKeyword("class", k);
		_AddKeyword("enum", k);
		_AddKeyword("struct", k);
		_AddKeyword("typedef", k);
		_AddKeyword("union", k);
		
		_AddKeywords(new _Keyword(_KeywordT.CallConv, cannotStartStatement: true), "__cdecl", "_cdecl", "__fastcall", "_fastcall", "__stdcall", "_stdcall", "__thiscall");
		
		_AddKeywords(new _Keyword(_KeywordT.IgnoreFuncEtc), "__forceinline", "__inline", "_inline", "inline", "template", "operator", "static_assert");
		
		_AddKeywords(new _Keyword(_KeywordT.PubPrivProt), "private", "protected", "public");
		
		//_AddKeywords(new _Keyword(_KeywordT.Ignore), "__unaligned", "__w64", "_w64", "volatile", "explicit", "friend", "mutable", "static", and so on); //removed in script
		//_AddKeywords(k = new _Keyword(_KeywordT.Declspec), "__declspec", "_declspec"); //removed in script
		
		_AddKeyword("uuid", k = new _Keyword(cannotStartStatement: true)); //was '__declspec(uuid', replaced in script
		
		_AddKeywords(new _CppType("sbyte", 1, false), "__int8", "char");
		_AddKeywords(new _CppType("short", 2, false), "__int16", "short");
		_AddKeywords(new _CppType("int", 4, false), "__int32", "int", "long");
		_AddKeyword("__int64", new _CppType("long", 8, false));
		_AddKeyword("double", new _CppType("double", 8, false));
		_AddKeyword("float", new _CppType("float", 4, false));
		_AddKeywords(new _CppType("char", 2, true), "__wchar_t", "wchar_t", "char16_t");
		//our preprocessor script replaced 'unsigned type' to 'u$type'
		//also the script replaced 'signed type' to 'type, 'long long' to '__int64', 'long double' to 'double'
		_AddKeywords(new _CppType("byte", 1, true), "u$__int8", "u$char");
		_AddKeywords(new _CppType("ushort", 2, true), "u$__int16", "u$short");
		_AddKeywords(new _CppType("uint", 4, true), "u$__int32", "u$int", "u$long", "char32_t");
		_AddKeyword("u$__int64", new _CppType("ulong", 8, true));
		_AddKeyword("bool", new _CppType("bool", 1, false));
		_AddKeyword("void", new _CppType("void", 0, false));
		//_AddKeywords(new _Keyword(), "__m128", "__m128d", "__m128i"); //our script defined these as struct, because C# does not have a matching type
		//_AddKeywords(new _Keyword(), "__m64"); //not used in SDK
		_AddKeyword("auto", new _CppType("var", 1, false)); //has two meanings depending on compiler options. The old auto is a local variable, and we will not encounter it because we skip function bodies. The new auto is like C# var; it can also be applied to global variables too, unlike in C#; we'll ignore all variable declarations.
		_AddKeyword("IntPtr", new _CppType("IntPtr", _is32bit ? 4 : 8, false));
		
		_AddSymbol("LPARAM", _sym_LPARAM = new _Struct("LPARAM", false), 0);
		_AddSymbol("HWND", _sym_wnd = new _Struct("wnd", false), 0);
	}
	
	_Struct _sym_LPARAM, _sym_wnd;
	
	void _ConvertAll(int nestLevel) {
		for (; _i < _nTokUntilDefUndef; _i++) {
			//print.it(_TokToString(_i));
			char* s = T(_i); char c = *s;
			if (_IsCharIdentStart(c)) {
				_Statement();
			} else if (c == '`') { //was #pragma pack
				_PragmaPack();
			} else if (c != ';' && c != '}') {
#if TEST_SMALL
					if(c == '/' && s[1] == '/') return;
#endif
				//print.it(_i);
				_Err(_i, $"unexpected: {_TokToString(_i)}");
			}
		}
		
		//info: script converted all #define/#undef to `d/`u and placed at the end
		_i++; //skip '\0' token inserted before first `d/`u token
		for (; _i < _nTok; _i++) {
			char* s = T(_i);
			if (*s == '`') { //was #define, #undef
				_DefineUndef();
			} else {
#if TEST_SMALL
					if(*s == '/' && s[1] == '/') return;
#endif
				//print.it(_i);
				_Err(_i, $"unexpected: {_TokToString(_i)}");
			}
		}
	}
	
	void _Statement() {
		//try {
		g0:
		_Symbol x = _FindSymbol(_i, true);
		var k = x as _Keyword;
		if (k != null) {
			if (k.cannotStartStatement) _Err(_i, "unexpected");
			
			if (k.kwType == _KeywordT.TypeDecl) {
				//is forward decl like 'struct X* Func(...);'?
				if (!_TokIsChar(_i, 't') && _TokIsChar(_i + 2, '*', '&')) {
					_InlineForwardDeclaration();
					goto g0;
				}
				
				var ftd = new _FINDTYPEDATA(); //just for ref parameter
				_DeclareType(ref ftd, true);
			} else if (k.kwType == _KeywordT.IgnoreFuncEtc) {
				_SkipStatement();
				return;
			} else if (_TokIs(_i, "extern")) {
				if (_TokIsChar(_i + 1, '"')) { //extern "C"
					_i++;
					if (_TokIsChar(_i + 1, '{')) _i++;
					return;
				} else { //extern T X
					if (_TokIs(++_i, "const")) _i++;
					if (!_ExternConst()) _SkipStatement();
				}
			} else if (_TokIs(_i, "const")) {
				_i++;
				if (!_ExternConst(true)) _SkipStatement();
			} else {
				//can be:
				//namespace
				
				_Err(_i, "unexpected");
			}
			if (!_TokIsChar(_i, ';')) _Err(_i, "unexpected");
			
		} else { //a type
			_DeclareFunction();
		}
		//}
		//catch(ConverterException e) {
		//	//print.it(e);
		//	wnd.findFast(null, "QM_Editor").SendS(Api.WM_SETTEXT, 1, $"M \"api_converter_error\" A(||) {e.Message}||{_cppFile}||{e.Offset}");
		//	if(dialog.show("Error. Skip statement and continue?", e.Message, "Yes|No").ButtonName != "Yes") throw e as Exception;
		//	_SkipStatement();
		//         }
	}
	
	/// <summary>
	/// Skips current statement.
	/// _i can be at any place in the statement except in parts enclosed in (), [] or {}.
	/// Finally _i will be at the ending ';' or '}' (if '}' is not followed by ';').
	/// </summary>
	/// <param name="debugShow"></param>
	void _SkipStatement(bool debugShow = false) {
#if DEBUG
		int i0 = _i;
#endif
		gk1:
		while (!_TokIsChar(_i, "({;[")) _i++;
		if (!_TokIsChar(_i, ';')) {
			_SkipEnclosed();
			if (!_TokIsChar(_i, '}')) goto gk1; //skip any number of (enclosed) or [enclosed] parts, else skip single {enclosed} part
			if (_TokIsChar(_i + 1, ';')) _i++;
		}
#if DEBUG
		if (debugShow) {
			string s = new(T(i0), 0, (int)(T(_i + 1) - T(i0)));
			print.it($"<><c 0xff>skipped:</c>\r\n{s}");
		}
#endif
	}
	
	void _PragmaPack() {
		const string sErr1 = "expected (push), (pop), (n), (push, n), (pop, n) or ()";
		char* s0 = T(++_i);
		int nArg = _GetParameters(_params), pack = 0, pushPop = 0;
		
		if (nArg == 0) {
			pack = 8;
		} else if (nArg > 2) {
			_Err(s0, sErr1);
		} else {
			if (_params[0].nTok != 1 || (nArg > 1 && _params[1].nTok != 1)) _Err(s0, sErr1);
			int i = _params[0].iTok;
			char* s = T(i);
			
			if (_TokIs(i, "push")) pushPop = 1;
			else if (_TokIs(i, "pop")) pushPop = -1;
			else if (nArg == 2) _Err(s0, sErr1);
			else pack = -1;
			
			if (nArg == 2) {
				s = T(_params[1].iTok);
				pack = -1;
			}
			
			if (pack < 0) { //a pack value must be specified
				pack = Api.strtoi(s);
				if (pack != 1 && pack != 2 && pack != 4 && pack != 8 && pack != 16)
					_Err(s, "expected 1, 2, 4, 8 or 16");
			}
		}
		
		if (pushPop > 0) _packStack.Push(_pack); else if (pushPop < 0 && _packStack.Count > 0) _pack = _packStack.Pop();
		if (pack != 0) _pack = pack;
		//print.it($"pushPop={pushPop}, pack={pack},    _pack={_pack}, _packStack.Count={_packStack.Count}");
	}
	
	bool _ExternConst(bool isJustConst = false) {
		if (!(_TokIsIdent(_i) && _TokIsIdent(_i + 1))) return false; //must be TYPE name
		int what = 0;
		if (_TokIsChar(_i + 2, ';')) what = 1;
		else if (isJustConst && _TokIsChar(_i + 2, '=')) what = 2;
		else return false;
		
		//get type
		_Symbol x;
		if (!_TryFindSymbol(_i, out x, false)) return false;
		if (0 != _Unalias(_i, ref x)) return false;
		_i++;
		
		if (what == 1) {
			//we need only GUID
			if (x.csTypename != "GUID") return false;
			
			string name = _TokToString(_i), data;
			if (!_guids.TryGetValue(name, out data)) {
				//print.it(name);
				return false;
			}
			
			if (name.Ends("A") && char.IsLower(name[name.Length - 2])) {
				//print.it(name);
				return false;
			} else if (name.Ends("W") && char.IsLower(name[name.Length - 2])) {
				//print.it(name);
				name = name.Remove(name.Length - 1);
			}
			
			if (!_guidsAdded.Add(name)) return false; //prevent duplicates
			
			_sbVar.AppendFormat("\r\ninternal static Guid {0} = new({1});\r\n", name, data);
			
			_i++;
		} else { //C++ const constant
			var ct = x as _CppType;
			if (ct == null) {
				//_Err(_i, "example");
				return false;
			}
			
			int iName = _i++, iValue = ++_i;
			while (!_TokIsChar(_i, ';')) _i++;
			string name = _TokToString(iName);
			
			_ExpressionResult r = _Expression(iValue, _i, name);
			//print.it(ct.csTypename, r.typeS, r.valueS);
			if (r.typeS == null) return false;
			
			_enumValues[_tok[iName]] = r.valueI;
			
			__sbDef.Clear();
			__sbDef.AppendFormat("internal const {0} {1} = {2};", ct.csTypename, name, r.valueS);
			//print.it(__sbDef);
			_cppConst.Add(__sbDef.ToString());
		}
		return true;
	}
	
	Dictionary<string, string> _guids; //all GUID extracted from .lib files
	HashSet<string> _guidsAdded = new(); //already declared GUID names, to prevent duplicate declarations
	
	void _InitMaps() {
		//get dll function names extracted from SDK lib files and system dlls
		_funcDllMap = new Dictionary<string, string>();
		string[] a = File.ReadAllLines(@"C:\code\au\Other\Api\DllMap.txt");
		foreach (var s in a) {
			int i = s.IndexOf(' ');
			_funcDllMap.Add(s.Substring(0, i), s.Substring(i + 1));
		}
		
		//get GUIDs extracted from SDK lib files
		_guids = new Dictionary<string, string>();
		foreach (var s in File.ReadAllLines(@"C:\code\au\Other\Api\GuidMap.txt")) {
			//print.it(s);
			int i = s.IndexOf(' ');
			string sn = s.Substring(0, i), sd = s.Substring(i + 1), sOld;
			if (_guids.TryGetValue(sn, out sOld)) {
				if (sd == sOld) continue;
				//print.it(name, sOld, sd);
				//continue;
				//several in SDK, the second ones are correct
				_guids.Remove(sn);
			}
			_guids.Add(sn, sd);
		}
		
		//add enum values for some keyword literals etc
		_enumValues.Add(_TokenFromString("false"), 0);
		_enumValues.Add(_TokenFromString("true"), 1);
		_enumValues.Add(_TokenFromString("nullptr"), 0);
		_enumValues.Add(_TokenFromString("NULL"), 0); //clang ignores #define NULL
	}
	
	//used to recognize forward-declared interfaces
	HashSet<string> _interfaces = new();
	
	void _InitInterfaces() {
		_interfaces.Add("IUnknown");
		_interfaces.Add("IDispatch");
		for (int i = 2; i < _nTokUntilDefUndef; i++) {
			if (_TokIsChar(i, 'u') && _TokIs(i, "uuid")) {
				if (!_TokIsChar(i + 5, ':')) continue; //class or IUnknown
				if (!_TokIs(i - 1, "struct") && !_TokIs(i - 1, "__interface")) continue; //unexpected
				i += 4;
				//print.it(_tok[i]);
				_interfaces.Add(_TokToString(i));
			}
		}
	}
	
	HashSet<string> _csKeywords;
	
	void _InitCsKeywords() {
		//we need only those that are not C/C++ keywords. Also don't need contextual keywords.
		_csKeywords = new HashSet<string>() { "abstract", "as", "base", "byte", "checked", "decimal", "delegate", "event", "explicit", "finally", "fixed", "foreach", "implicit", "in", "interface", "internal", "is", "lock", "null", "object", "out", "override", "params", "readonly", "ref", "sbyte", "sealed", "stackalloc", "string", "typeof", "uint", "ulong", "unchecked", "unsafe", "ushort" };
	}
}


================================================
FILE: Scripts/old/Windows SDK to C#/@SDK converter/Expr.cs
================================================
namespace SdkConverter;

unsafe partial class Converter {
	_ExpressionResult _Expression(int iFrom, int iTo, string debugConstName = null) {
		Debug.Assert(iTo > iFrom);
		
		int nTok = iTo - iFrom, iLast = iTo - 1;
		
		string sValue, sType; bool isHex = false;
		
		//if(debugConstName == "[]") return new _ExpressionResult(_TokToString(iFrom, iTo), null, true);
		//print.it($"{debugConstName} {_TokToString(iFrom, iTo)}");
		
		//Unenclose whole expression (not parts).
		
		while (nTok >= 3 && _TokIsChar(iFrom, '(') && _TokIsChar(iLast, ')')) {
			if (nTok == 3 || _SkipEnclosed(iFrom) == iLast) { iFrom++; iLast--; iTo--; nTok -= 2; } else break;
		}
		
		//Simple cases.
		
		if (nTok == 1) {
			ulong value; _OP type;
			
			if (_TokIsNumber(iFrom)) {
				if (__ExprNumber(iFrom, out value, out type, ref isHex)) {
					type = __ExprMakeUintIfHex(type, isHex);
					sValue = __ExprValueToString(value, type);
					sType = __ExprTypeToString(type);
					return new _ExpressionResult(sValue, sType, false, value);
				} else {
					sValue = _TokToString(iFrom);
					sType = sValue.Ends("f", true) ? "float" : "double";
					return new _ExpressionResult(sValue, sType, false);
				}
				
			}
			
			if (_TokIsChar(iFrom, '"')) {
				return new _ExpressionResult(_TokToString(iFrom), "string", false);
			}
			if (_TokIsChar(iFrom, '\'')) {
				//is like 'ABCD'?
				int len = _tok[iFrom].len - 2;
				if (len > 1 && len <= 4) {
					char* s = T(iFrom) + 1;
					if (*s != '\\') {
						//print.it(_DebugGetLine(iFrom));
						uint k = 0; for (int j = 0; j < len; j++) k = (k << 8) | ((uint)s[j] & 0xff);
						return new _ExpressionResult($"0x{k:X}", "uint", false, k);
					}
				}
				//string k=_TokToString(iFrom).Re
				return new _ExpressionResult(_TokToString(iFrom), "char", false);
			}
			
			if (_TokIsIdent(iFrom)) {
				if (_EnumFindValue(iFrom, out value, out type)) {
					sValue = __ExprValueToString(value, type);
					sType = __ExprTypeToString(type);
					return new _ExpressionResult(sValue, sType, false, value);
				}
				
				//print.it($"<><c 0xff0000>{_TokToString(iFrom, iTo)}</c>");
			} else {
				//print.it($"<><c 0xff0000>{_TokToString(iFrom, iTo)}</c>"); //0 in SDK
			}
			
			return new _ExpressionResult(_TokToString(iFrom), null, true);
		}
		
		//Calculate expression.
		
		//print.it(debugConstName, _TokToString(iFrom, iTo));
		
		//Part 1 - convert the expression from normal infix form to RPN form which is easy to calculate.
		//Use the shunting-yard algorithm: https://en.wikipedia.org/wiki/Shunting-yard_algorithm
		//Put operands and operators in _eRPN, which is the "output queue" of the algorithm.
		
		int nRPN = 0; //number of elements in the output queue
		int nOp = 0; //number of elements in the operator stack
		int i;
		bool wasOperand = false;
		
		////Debug
		//if(debugConstName == "WTS_CURRENT_SERVER") {
		//	print.it(debugConstName);
		//	int stop = 0;
		//}
		
		for (i = iFrom; i < iTo; i++) {
			int iTok = i;
			_OP op;
			char c = *T(i);
			
			if (_IsCharIdent(c) || c == '\'') { //digit, identifier or 'character'
				if (wasOperand) goto gFail; //cannot be 2 operands
				wasOperand = true;
				
				//If the token is a number, then add it to the output queue.
				
				ulong value; _OP type = _OP.OperandInt;
				
				if (_IsCharDigit(c)) { //number
					if (!__ExprNumber(i, out value, out type, ref isHex)) {
						//_Err(i, "bad number"); //0 in SDK
						goto gFail;
					}
				} else if (c == '\'') {
					char* s = T(i) + 1;
					int len = _tok[i].len - 2;
					if (len > 1) {
						if (len == 2 && *s == '\\') s++;
						else goto gFail;
					}
					value = *s;
				} else { //identifier
					if (_TokIs(i, "sizeof")) {
						if (!_TokIsChar(++i, '(')) goto gFail;
						int rightParen = __ExprIsType(++i);
						if (rightParen != i + 1) goto gFail; //if not like a type, or with *
						if (!__ExprSizeof(i, out value)) goto gFail;
						i++;
					} else {
						if (!_EnumFindValue(i, out value, out type)) goto gFail;
					}
				}
				
				_eRPN[nRPN++] = new _EVAL(i, type, value);
				
			} else if (_IsCharOperator(c) || c == '(') { //operator or cast or (
				if (c == '(') {
					//is cast?
					int rightParen = __ExprIsType(i + 1);
					bool isCast = rightParen > 0;
					if (isCast && rightParen - i == 2 && _enumValues.ContainsKey(_tok[i + 1])) isCast = false; //is '(enumValue)'?
					if (isCast) { //cast
						iTok = i + 1;
						i = rightParen;
						op = _OP.Cast;
						
						//cast is an operator
					} else {
						iTok = i;
						op = _OP.LeftParen;
					}
				} else {
					char c2 = *T(i + 1);
					op = 0;
					
					if (wasOperand) //this must be a binary operator
					{
						//note: cannot be +=, ++ etc because they can be used only with variables, not with constants.
						
						wasOperand = false;
						switch (c) {
						case '+': op = _OP.Plus; break;
						case '-': op = _OP.Minus; break;
						case '*': op = _OP.Mul; break;
						case '/': op = _OP.Div; break;
						case '%': op = _OP.Mod; break;
						case '&':
							if (c2 == '&') { i++; op = _OP.LogAnd; } else op = _OP.BitAnd;
							break;
						case '|':
							if (c2 == '|') { i++; op = _OP.LogOr; } else op = _OP.BitOr;
							break;
						case '^': op = _OP.BitXor; break;
						case '<':
							if (c2 == '<') { i++; op = _OP.BitLshift; } else if (c2 == '=') { i++; op = _OP.LtEq; } else op = _OP.Lt;
							break;
						case '>':
							if (c2 == '>') { i++; op = _OP.BitRshift; } else if (c2 == '=') { i++; op = _OP.GtEq; } else op = _OP.Gt;
							break;
						case '=':
							if (c2 == '=') { i++; op = _OP.CompareEq; } else goto gFail;
							break;
						case '!':
							if (c2 == '=') { i++; op = _OP.CompareNotEq; } else goto gFail;
							break;
						//case '?':
						//	op = _OPERATOR.Ternary;
						//	break;
						default:
							goto gFail;
						}
					} else { //this must be a prefix operator
						
						//note: cannot be ++, & etc because they can be used only with variables, not with constants.
						
						switch (c) {
						case '+': continue;
						case '-': op = _OP.UnaryMinus; break;
						case '!': op = _OP.UnaryLogNot; break;
						case '~': op = _OP.UnaryBitNot; break;
						default: goto gFail;
						}
					}
				}
				
				//If the token is an operator (op), then:
				if (op != _OP.LeftParen) {
					//While there is an operator (op2) at the top of the stack, and either
					//	op is left-associative and its precedence is less than or equal to that of op2, or
					//	op is right associative, and has precedence less than that of o2,
					//		pop op2 off the stack, onto the output queue.
					for (; nOp > 0; nOp--) {
						int n = nOp - 1;
						_OP op2 = _eOp[n].op;
						if (op2 == _OP.LeftParen) break; //is an operator at the top of the stack?
						bool pop = false, opRTL = (op & _OP._FlagRightToLeft) != 0;
						int prec1 = (int)(op & _OP._MaskPrecedence), prec2 = (int)(op2 & _OP._MaskPrecedence);
						//print.it("  ", op, prec1, opRTL, op2, prec2);
						
						if (!opRTL) pop = prec1 >= prec2; //op is left-associative and its precedence is less than or equal to that of op2
						else pop = prec1 > prec2; //op is right associative, and has precedence less than that of o2
						
						if (!pop) break;
						_eRPN[nRPN++] = _eOp[n];
					}
				} //Else if the token is a left parenthesis (i.e. "("), then push it onto the stack.
				
				//push op to the stack
				_eOp[nOp++] = new _EVAL(iTok, op);
				
			} else if (c == ')') {
				//If the token is a right parenthesis (i.e. ")"):
				//	Until the token at the top of the stack is a left parenthesis, pop operators off the stack onto the output queue.
				for (; nOp > 0; nOp--) {
					int n = nOp - 1;
					if (_eOp[n].op == _OP.LeftParen) break;
					_eRPN[nRPN++] = _eOp[n];
				}
				//If the stack runs out without finding a left parenthesis, then there are mismatched parentheses.
				if (nOp == 0) goto gFail;
				//Pop the left parenthesis from the stack, but not onto the output queue.
				nOp--;
			} else {
				//"string" //0 in SDK
				goto gFail;
			}
		}
		
		//When there are no more tokens to read:
		//	While there are still operator tokens in the stack:
		//		If the operator token on the top of the stack is a parenthesis: error, there are mismatched parentheses.
		//		Else pop the operator onto the output queue.
		for (; nOp > 0; nOp--) {
			int n = nOp - 1;
			if (_eOp[n].op == _OP.LeftParen) goto gFail;
			_eRPN[nRPN++] = _eOp[n];
		}
		
		////Debug
		//if(debugConstName == "WTS_CURRENT_SERVER") {
		//	var deb = new StringBuilder(debugConstName);
		//	deb.Append(" = ");
		//	deb.Append(_TokToString(iFrom, iTo));
		//	deb.Append("  -> ");
		//	for(i = 0; i < nRPN; i++) {
		//		deb.Append(" ");
		//		if(_eRPN[i].op < _OP._FirstOperator) deb.Append(_eRPN[i].value);
		//		else deb.Append(_eRPN[i].op);
		//	}
		//	print.it(deb);
		
		//	int stop = 0;
		//}
		
		//Part 2 - calculate the RPN expression.
		//Use the postfix algorithm: https://en.wikipedia.org/wiki/Reverse_Polish_notation
		
		int nCalc = 0; //_eCalc stack length
		for (i = 0; i < nRPN; i++) {
			if (_eRPN[i].op < _OP._FirstOperator) { //operand
				
				//If the token is a value (operand): push it onto the stack.
				_eCalc[nCalc++] = _eRPN[i];
			} else { //operator
				
				//It is already known that the operator takes n arguments.
				int nOperands = (int)(_eRPN[i].op & _OP._MaskNOperands) >> 8;
				//If there are fewer than n values on the stack: error, the user has not input sufficient values in the expression.
				if (nCalc < nOperands) goto gFail;
				
				if (nOperands == 1) {
					
					//Pop the top n values from the stack.
					//A = _eCalc[--nCalc]; //operand (we change it in-place without pop/push)
					
					//Evaluate the operator, with the values as arguments.
					_OP op = _eRPN[i].op;
					if (op == _OP.Cast) {
						if (!__ExprCalcCast(_eRPN[i].iTok, ref _eCalc[nCalc - 1])) goto gFail;
					} else {
						__ExprCalcOperatorUnary(op, ref _eCalc[nCalc - 1]);
					}
					
				} else { //2 operands
					
					//Pop the top n values from the stack.
					_EVAL B = _eCalc[--nCalc]; //rigt operand
					//A = _eCalc[--nCalc]; //left operand (we change it in-place without pop/push)
					
					//Evaluate the operator, with the values as arguments.
					__ExprCalcOperatorBinary(_eRPN[i].op, ref _eCalc[nCalc - 1], B);
					
					//__ExprDebugOutValue(_eCalc[nCalc - 1]);
				}
				
				//Push the returned results, if any, back onto the stack.
				//_eCalc[nCalc++] = A; //we change it in-place without pop/push
			}
		}
		
		//If there is only one value in the stack, it is the result of the calculation.
		//Otherwise, there are more values in the stack: error, the user input has too many values.
		if (nCalc != 1) goto gFail;
		_OP rType = __ExprMakeUintIfHex(_eCalc[0].op, isHex);
		sValue = __ExprValueToString(_eCalc[0].value, rType);
		sType = __ExprTypeToString(rType);
		
		return new _ExpressionResult(sValue, sType, false, _eCalc[0].value);
		
		gFail:
		//print.it($"<><c 0xff>{debugConstName}    {_TokToString(iFrom, iTo)}</c>");
		//if(++_debugNFailed > 10) _Err(iFrom, "debug");
		return new _ExpressionResult(_TokToString(iFrom, iTo), null, true);
		
		//never mind: need functions:
		//LongToHandle
		//HRESULT_FROM_WIN32
		
		//never mind: sizeof pointers, IntPtr, nint and wnd.
	}
	
	void __ExprDebugOutValue(_EVAL v) {
		print.it($"    {v.op}, { __ExprValueToString(v.value, v.op)}");
	}
	
	//int _debugNFailed;
	
	#region CALC_UNARY
	
	void __ExprCalcOperatorUnary(_OP op, ref _EVAL A) {
		switch (A.op) {
		case _OP.OperandInt: A.value = (ulong)__ExprCalcOperatorUnary(op, (int)A.value); break;
		case _OP.OperandUint: A.value = __ExprCalcOperatorUnary(op, (uint)A.value); break;
		case _OP.OperandLong: A.value = (ulong)__ExprCalcOperatorUnary(op, (long)A.value); break;
		case _OP.OperandUlong: A.value = __ExprCalcOperatorUnary(op, A.value); break;
		}
	}
	
	int __ExprCalcOperatorUnary(_OP op, int A) {
		switch (op) {
		case _OP.UnaryMinus: return -A;
		case _OP.UnaryLogNot: return A == 0 ? 0 : 1;
		case _OP.UnaryBitNot: return ~A;
		}
		Debug.Assert(false);
		return 0;
	}
	
	uint __ExprCalcOperatorUnary(_OP op, uint A) {
		switch (op) {
		case _OP.UnaryMinus: return (uint)-(int)A;
		case _OP.UnaryLogNot: return A == 0U ? 0U : 1U;
		case _OP.UnaryBitNot: return ~A;
		}
		Debug.Assert(false);
		return 0;
	}
	
	long __ExprCalcOperatorUnary(_OP op, long A) {
		switch (op) {
		case _OP.UnaryMinus: return -A;
		case _OP.UnaryLogNot: return A == 0 ? 0 : 1;
		case _OP.UnaryBitNot: return ~A;
		}
		Debug.Assert(false);
		return 0;
	}
	
	ulong __ExprCalcOperatorUnary(_OP op, ulong A) {
		switch (op) {
		case _OP.UnaryMinus: return (ulong)-(long)A;
		case _OP.UnaryLogNot: return A == 0U ? 0U : 1U;
		case _OP.UnaryBitNot: return ~A;
		}
		Debug.Assert(false);
		return 0;
	}
	
	#endregion
	
	#region CALC_BINARY
	
	void __ExprCalcOperatorBinary(_OP op, ref _EVAL A, _EVAL B) {
		if (A.op < B.op) A.op = B.op;
		switch (A.op) {
		case _OP.OperandInt:
			A.value = (ulong)__ExprCalcOperatorBinary(op, (int)A.value, (int)B.value);
			break;
		case _OP.OperandUint:
			A.value = __ExprCalcOperatorBinary(op, (uint)A.value, (uint)B.value);
			break;
		case _OP.OperandLong:
			A.value = (ulong)__ExprCalcOperatorBinary(op, (long)A.value, (long)B.value);
			break;
		case _OP.OperandUlong:
			A.value = __ExprCalcOperatorBinary(op, A.value, B.value);
			break;
		}
	}
	
	int __ExprCalcOperatorBinary(_OP op, int A, int B) {
		switch (op) {
		case _OP.Plus: return A + B;
		case _OP.Minus: return A - B;
		case _OP.Mul: return A * B;
		case _OP.Div: return A / B;
		case _OP.Mod: return A % B;
		case _OP.BitLshift: return A << B;
		case _OP.BitRshift: return A >> B;
		case _OP.Lt: return A < B ? 1 : 0;
		case _OP.LtEq: return A <= B ? 1 : 0;
		case _OP.Gt: return A > B ? 1 : 0;
		case _OP.GtEq: return A >= B ? 1 : 0;
		case _OP.CompareEq: return A == B ? 1 : 0;
		case _OP.CompareNotEq: return A != B ? 1 : 0;
		case _OP.BitAnd: return A & B;
		case _OP.BitOr: return A | B;
		case _OP.BitXor: return A ^ B;
		case _OP.LogAnd: return A != 0 && B != 0 ? 1 : 0;
		case _OP.LogOr: return A != 0 || B != 0 ? 1 : 0;
		}
		Debug.Assert(false);
		return 0;
	}
	
	uint __ExprCalcOperatorBinary(_OP op, uint A, uint B) {
		switch (op) {
		case _OP.Plus: return A + B;
		case _OP.Minus: return A - B;
		case _OP.Mul: return A * B;
		case _OP.Div: return A / B;
		case _OP.Mod: return A % B;
		case _OP.BitLshift: return A << (int)B;
		case _OP.BitRshift: return A >> (int)B;
		case _OP.Lt: return A < B ? 1U : 0U;
		case _OP.LtEq: return A <= B ? 1U : 0U;
		case _OP.Gt: return A > B ? 1U : 0U;
		case _OP.GtEq: return A >= B ? 1U : 0U;
		case _OP.CompareEq: return A == B ? 1U : 0U;
		case _OP.CompareNotEq: return A != B ? 1U : 0U;
		case _OP.BitAnd: return A & B;
		case _OP.BitOr: return A | B;
		case _OP.BitXor: return A ^ B;
		case _OP.LogAnd: return A != 0U && B != 0U ? 1U : 0U;
		case _OP.LogOr: return A != 0U || B != 0U ? 1U : 0U;
		}
		Debug.Assert(false);
		return 0;
	}
	
	long __ExprCalcOperatorBinary(_OP op, long A, long B) {
		switch (op) {
		case _OP.Plus: return A + B;
		case _OP.Minus: return A - B;
		case _OP.Mul: return A * B;
		case _OP.Div: return A / B;
		case _OP.Mod: return A % B;
		case _OP.BitLshift: return A << (int)B;
		case _OP.BitRshift: return A >> (int)B;
		case _OP.Lt: return A < B ? 1 : 0;
		case _OP.LtEq: return A <= B ? 1 : 0;
		case _OP.Gt: return A > B ? 1 : 0;
		case _OP.GtEq: return A >= B ? 1 : 0;
		case _OP.CompareEq: return A == B ? 1 : 0;
		case _OP.CompareNotEq: return A != B ? 1 : 0;
		case _OP.BitAnd: return A & B;
		case _OP.BitOr: return A | B;
		case _OP.BitXor: return A ^ B;
		case _OP.LogAnd: return A != 0 && B != 0 ? 1 : 0;
		case _OP.LogOr: return A != 0 || B != 0 ? 1 : 0;
		}
		Debug.Assert(false);
		return 0;
	}
	
	ulong __ExprCalcOperatorBinary(_OP op, ulong A, ulong B) {
		switch (op) {
		case _OP.Plus: return A + B;
		case _OP.Minus: return A - B;
		case _OP.Mul: return A * B;
		case _OP.Div: return A / B;
		case _OP.Mod: return A % B;
		case _OP.BitLshift: return A << (int)B;
		case _OP.BitRshift: return A >> (int)B;
		case _OP.Lt: return A < B ? 1U : 0U;
		case _OP.LtEq: return A <= B ? 1U : 0U;
		case _OP.Gt: return A > B ? 1U : 0U;
		case _OP.GtEq: return A >= B ? 1U : 0U;
		case _OP.CompareEq: return A == B ? 1U : 0U;
		case _OP.CompareNotEq: return A != B ? 1U : 0U;
		case _OP.BitAnd: return A & B;
		case _OP.BitOr: return A | B;
		case _OP.BitXor: return A ^ B;
		case _OP.LogAnd: return A != 0U && B != 0U ? 1U : 0U;
		case _OP.LogOr: return A != 0U || B != 0U ? 1U : 0U;
		}
		Debug.Assert(false);
		return 0;
	}
	
	#endregion
	
	bool __ExprCalcCast(int i, ref _EVAL A) {
		//print.it(_tok[i]);
		
		_Symbol x;
		if (!_TryFindSymbol(i, out x, false)) {
			//print.it(_tok[i]); //0 in SDK
			//_Err(i, "unknown");
			return false;
		}
		if (0 != _Unalias(i, ref x) || _TokIsChar(i + 1, '*')) {
			//support expressions like '#define RT_BITMAP (LPWSTR)((ULONG_PTR)((WORD)(2)))'
			if (A.op <= _OP.OperandUint) {
				A.op = _OP.OperandInt;
				return true;
			}
			//_Err(i, "stop"); //0 in SDK
			return false;
		}
		var ct = x as _CppType;
		if (ct == null) {
			//support LPARAM, HWND
			if (A.op > _OP.OperandUint) return false; //0 in SDK
			if (x == _sym_LPARAM || x == _sym_wnd) return true;
			//support enum, callback
			if (x is _Enum || x is _Callback) return true;
			//_Err(i, "stop 2"); //0 in SDK
			return false;
		}
		
		switch (ct.sizeBytesCpp) {
		case 8:
			if (ct.csTypename[0] == 'd') return false; //double
			if (ct.csTypename[0] == 'I') { //IntPtr
				//print.it(_DebugGetLine(i));
				if (A.op > _OP.OperandUint) return false; //0 in SDK
				break; //let be the same type as in 32-bit mode (no long). All in SDK are like #define HKEY_CURRENT_USER (IntPtr)0x80000001.
			}
			A.op = ct.isUnsigned ? _OP.OperandUlong : _OP.OperandLong;
			return true;
		case 4:
			if (ct.csTypename[0] == 'f') return false; //float
			A.value = (uint)A.value;
			break;
		case 2:
			A.value = (ushort)A.value;
			break;
		case 1:
			if (ct.csTypename == "bool") A.value = A.value == 0U ? 0U : 1U;
			else A.value = (byte)A.value;
			break;
		default: return false;
		}
		
		A.op = ct.isUnsigned ? _OP.OperandUint : _OP.OperandInt;
		return true;
	}
	
	/// <summary>
	/// If token i is an identifier and is followed by 0 or more '*' characters and character ')', returns token index of the ')'.
	/// Else returns 0.
	/// </summary>
	int __ExprIsType(int i) {
		if (!_TokIsIdent(i)) return 0;
		i++;
		while (_TokIsChar(i, '*')) i++;
		if (!_TokIsChar(i, ')')) return 0;
		return i;
	}
	
	bool __ExprNumber(int i, out ulong value, out _OP type, ref bool isHex) {
		value = 0; type = _OP.OperandInt;
		
		char* s = T(i), se;
		if (*s == '0') {
			if (s[1] == 'x' || s[1] == 'X') { value = strtoui64(s, &se); isHex = true; } //hex
			else if (s[1] == 'b' || s[1] == 'B') { value = strtoui64(s + 2, &se, 2); isHex = true; } //binary constant like 0b10101010
			else value = strtoui64(s, &se, 8); //oct
		} else value = strtoui64(s, &se);
		
		bool isUnsigned = false, isLong = false;
		
		int tlen = _tok[i].len;
		if (se < s + tlen) {
			if (*se == 'U' || *se == 'u') { se++; isUnsigned = true; }
			if (se < s + tlen) {
				if (*se == 'L' || *se == 'l') { se++; isLong = true; }
				if (se < s + tlen) return false; //eg a floating-point number
			}
		}
		
		if (!isLong && value > uint.MaxValue) isLong = true;
		if (!isUnsigned) {
			if (isLong) isUnsigned = value > long.MaxValue;
			else isUnsigned = value > int.MaxValue;
		}
		
		if (isLong) type = isUnsigned ? _OP.OperandUlong : _OP.OperandLong; else if (isUnsigned) type = _OP.OperandUint;
		return true;
	}
	
	[DllImport("msvcrt.dll", EntryPoint = "_wcstoui64", CallingConvention = CallingConvention.Cdecl)]
	internal static extern ulong strtoui64(char* s, char** endPtr = null, int radix = 0);
	
	string __ExprTypeToString(_OP type) {
		Debug.Assert(type <= _OP.OperandUlong);
		switch (type) {
		case _OP.OperandInt: return "int";
		case _OP.OperandUint: return "uint";
		case _OP.OperandLong: return "long";
		default: return "ulong";
		}
	}
	
	string __ExprValueToString(ulong value, _OP type) {
		Debug.Assert(type <= _OP.OperandUlong);
		switch (type) {
		case _OP.OperandInt: return ((int)value).ToString();
		case _OP.OperandUint: return "0x" + ((uint)value).ToString("X");
		case _OP.OperandLong: return ((long)value).ToString();
		default: return "0x" + value.ToString("X");
		}
	}
	
	_OP __ExprMakeUintIfHex(_OP type, bool isHex) {
		Debug.Assert(type <= _OP.OperandUlong);
		if (isHex) {
			if (type == _OP.OperandInt) return _OP.OperandUint;
			if (type == _OP.OperandLong) return _OP.OperandUlong;
		}
		return type;
	}
	
	bool __ExprSizeof(int i, out ulong value) {
		value = 0;
		_Symbol x;
		if (!_TryFindSymbol(i, out x, true) || x is _Keyword) return false;
		if (0 != _Unalias(i, ref x)) return false;
		
		var ct = x as _CppType;
		if (ct != null) {
			if (ct.csTypename[0] == 'I') return false; //IntPtr (variable size)
			value = ct.sizeBytesCpp;
			return true;
		}
		
		var t = x as _Struct; if (t == null) return false;
		switch (_TokToString(i)) {
		case "SID": value = 12; break;
		case "IMAGE_SYMBOL_EX": value = 20; break; //in SDK used as array size
		default: return false; //most have pointer members (variable size)
		}
		return true;
	}
	
	/// <summary>
	/// C operator constants, sorted by precedence.
	/// Flags: 0x100 - 1 operand, 0x200 - 2 operands, 0x1000 - right-to-left.
	/// </summary>
	[Flags]
	enum _OP //:ushort
	{
		OperandInt, OperandUint, OperandLong, OperandUlong,
		
		//OperandDouble, OperandFloat, OperandBool, OperandString, //not supported
		
		_FirstOperator = 0x10,
		
		//FuncCall = 0x110, //f()
		//SuffixInc, SuffixDec, ArrElem, Member, MemberPtr, //x++, x--, a[], x.m, x->m  //only with variables
		
		UnaryMinus = 0x1120, UnaryLogNot, UnaryBitNot, Cast, //-x, !x, ~x, (t)x  //RTL
		
		//PrefixInc, PrefixDec, Deref, Address, //++x, --x, *x, &x  //RTL  //only with variables
		
		Mul = 0x230, Div, Mod, //x*y, x/y, x%y
		Plus = 0x240, Minus, //x+y, x-y
		BitLshift = 0x250, BitRshift, //x<<n, x>>n
		Lt = 0x260, LtEq, Gt, GtEq, //x<y, x<=y, x>y, x>=y
		CompareEq = 0x270, CompareNotEq, //==, !=
		BitAnd = 0x280, //x&y
		BitXor = 0x290, //x^y
		BitOr = 0x2A0, //x|y
		LogAnd = 0x2B0, //x&&y
		LogOr = 0x2C0, //x||y
		
		//Ternary = 0x13D0, //x?y:z  //RTL  //0 or few in SDK
		//Assign = 0x12E0, PlusAssign, MinusAssign, MulAssign, DivAssign, ModAssign, BitLshiftAssign, BitRshiftAssign, BitAndAssign, BitXorAssign, BitOrAssign, //=, +=, ...  //RTL  //only with variables
		
		LeftParen = 0xF0,
		
		_MaskPrecedence = 0xF0,
		_MaskNOperands = 0x300,
		_FlagRightToLeft = 0x1000,
	}
	
	struct _EVAL {
		public int iTok; //token
		public _OP op;
		public ulong value;
		
		public _EVAL(int iTok, _OP op) {
			this.iTok = iTok;
			this.op = op;
			value = 0;
		}
		
		public _EVAL(int iTok, _OP op, ulong value) {
			this.iTok = iTok;
			this.op = op;
			this.value = value;
		}
	};
	
	_EVAL[] _eRPN = new _EVAL[200]; //RPN output queue
	_EVAL[] _eOp = new _EVAL[200]; //operator stack used when building the RPN
	_EVAL[] _eCalc = new _EVAL[100]; //final stack used to calculate the RPN
	
	class _ExpressionResult {
		public string valueS;
		public string typeS;
		public bool notConst;
		public uint valueI;
		
		public _ExpressionResult(string valueS, string typeS, bool notConst, ulong valueI = 0) {
			this.valueS = valueS;
			this.typeS = typeS;
			this.notConst = notConst;
			this.valueI = (uint)valueI;
		}
	}
}


================================================
FILE: Scripts/old/Windows SDK to C#/@SDK converter/Functions.cs
================================================
namespace SdkConverter;

unsafe partial class Converter {
	void _DeclareFunction() {
		//now we expect one of:
		//	function declaration, like TYPE __stdcall Func(TYPE a, TYPE b);
		//	global variable, which can be:
		//		previously-defined type, like TYPE var;
		//		now-defined function type, like TYPE (*var)(TYPE a, TYPE b);
		
		
		var d = new _FINDTYPEDATA();
		_FindTypename(false, ref d);
		_i++;
		
		//pointer
		int ptr = 0;
		while (_TokIsChar(_i, '*', '&')) { _i++; ptr++; }
		
		if (!_TokIsIdent(_i)) {
			//could be 'T (*var)(...);' //0 in SDK
			//_Err(_i, "unexpected");
			_SkipStatement(true);
			return;
		}
		
		int iCallConv = 0;
		if (_TokIsIdent(_i + 1)) iCallConv = _i++;
		
		if (!_TokIsChar(_i + 1, '(')) {
			//could be 'T var;' //1 in SDK
			//_Err(_i, "unexpected");
			_i = d.outTypenameToken;
			if (!_ExternConst()) _SkipStatement(true);
			return;
		}
		
		string name = _TokToString(_i++);
		
		//skip some
		if (name.IndexOf('_') > 0) {
			if (name.Ends("_UserSize")
				|| name.Ends("_UserMarshal")
				|| name.Ends("_UserUnmarshal")
				|| name.Ends("_UserFree")
				|| name.Ends("_UserSize64")
				|| name.Ends("_UserMarshal64")
				|| name.Ends("_UserUnmarshal64")
				|| name.Ends("_UserFree64")
				) {
				_SkipStatement(false);
				return;
			}
		}
		
		//string callConv = iCallConv == 0 ? "Cdecl" : _ConvertCallConv(iCallConv); //no. Now many __stdcall functions are declared without __stdcall (WINAPI etc). I could't find where it is documented, but it means now __stdcall is default.
		string callConv = iCallConv == 0 ? null : _ConvertCallConv(iCallConv);
		string returnType, returnAttr = null; bool isHRESULT = false;
		if (ptr == 0 && _TokIs(d.outTypenameToken, "HRESULT")) {
			isHRESULT = true;
			returnType = "int";
		} else {
			returnType = _ConvertTypeName(d.outSym, ref ptr, d.outIsConst, d.outTypenameToken, _TypeContext.Return, out returnAttr);
		}
		
		string dll, nameInDll = null;
		if (_funcDllMap.TryGetValue(name, out dll)) {
			int i = dll.IndexOf('|');
			if (i > 0) {
				nameInDll = dll.Substring(i + 1);
				dll = dll.Substring(0, i);
				//print.it(nameInDll);
			} else if (name.Starts("K32")) {
				//print.it(name);
				nameInDll = name;
				name = name.Substring(3);
				if (name.Ends("W")) name = name.Remove(name.Length - 1);
				else if (name.Ends("A")) {
					_SkipStatement(false);
					return;
				}
			}
		} else {
			bool skip = false;
			if (name.Contains("_")) skip = true; //mostly CRT library functions, X_Proxy/X_Stub, X_UserMarshal and similar
			else if (name.Starts("Dll")) skip = true; //DllInstall, DllRegisterServer etc
			else if (name.Starts("Ndr") || name.Starts("Rpc")) skip = true; //undocumented
			else {
				//print.it(name);
				skip = true; //all these in SDK others are undocumented, or documented as deprecated/removed
				_funcUnknownDll.Add(name);
			}
			
			if (skip) {
				_SkipStatement();
				return;
			}
			dll = "?";
		}
		
		var sb = _sbFuncTemp;
		sb.Clear();
		sb.Append("\r\n[DllImport(\"");
		sb.Append(dll);
		sb.Append('"');
		if (nameInDll != null) sb.AppendFormat(", EntryPoint=\"{0}\"", nameInDll);
		if (callConv != null) sb.AppendFormat(", CallingConvention=CallingConvention.{0}", callConv);
		if (isHRESULT) sb.Append(", PreserveSig=true"); //default, but makes clear that it returns HRESULT and easier to change to 'false'
		sb.AppendLine(")]");
		if (returnAttr != null) sb.AppendLine(returnAttr);
		sb.Append("internal static extern ");
		sb.Append(returnType);
		sb.Append(' ');
		sb.Append(name);
		
		_ConvertParameters(sb, name, _TypeContext.Parameter);
		
		string decl = sb.ToString();
		_func[name] = decl;
		//try { _func.Add(name, decl); }
		//catch { //about 10 in SDK. The second declarations are identical or better (without tagSTRUCT).
		//	print.it("----");
		//	print.it(name);
		//	print.it(_func[name]);
		//	print.it(decl);
		//}
		
		if (!_TokIsChar(_i, ';')) _Err(_i, "unexpected");
	}
	
	Dictionary<string, string> _funcDllMap;
	List<string> _funcUnknownDll = new List<string>();
	
	void _FunctionsFinally() {
		if (_funcUnknownDll.Count > 100) {
			print.it("Warning: too many unknown dll:");
			print.it(_funcUnknownDll);
		}
	}
}


================================================
FILE: Scripts/old/Windows SDK to C#/@SDK converter/Parameters.cs
================================================
namespace SdkConverter;

unsafe partial class Converter {
	
	struct _PARAMETER {
		public int iTok;
		public int nTok;
		public _PARAMETER(int iTok, int nTok) { this.iTok = iTok; this.nTok = nTok; }
	}
	
	/// <summary>
	/// Used with all non-nested _GetParameters().
	/// </summary>
	List<_PARAMETER> _params = new();
	
	/// <summary>
	/// Parses parameters and stores their iTok/nTok in p.
	/// Error if _i is not at the starting '('. Finally _i will be at the ending ')'.
	/// Returns the number of parameters.
	/// Currently used only with pragma.
	/// </summary>
	int _GetParameters(List<_PARAMETER> p) {
		p.Clear();
		
		char* s = T(_i);
		if (*s != '(') _Err(s, "expected (");
		
		for (int paramStart = 0, iVeryStart = _i++; ; _i++) {
			s = T(_i);
			char c = *s;
			switch (c) {
			case ',':
			case ')':
				if (paramStart == 0) {
					if (c == ')' && p.Count == 0) return 0; //()
					_Err(s, "unexpected");
				}
				p.Add(new _PARAMETER(paramStart, _i - paramStart));
				if (c == ')') return p.Count;
				paramStart = 0;
				continue;
			case '\0':
				_Err(iVeryStart, "no )");
				break;
			case ';':
				_Err(s, "unexpected");
				break;
			}
			
			if (paramStart == 0) paramStart = _i;
			
			switch (c) {
			case '(':
			case '[':
			//case '<': //can be operator
			case '{':
				_SkipEnclosed();
				break;
			}
		}
	}
	
	/// <summary>
	/// Converts function parameters to C# and appends to sb like "(...);\r\n".
	/// _i must be at '('. Finally will be after ')'.
	/// </summary>
	void _ConvertParameters(StringBuilder sb, string parentName, _TypeContext context) {
		if (!_TokIsChar(_i, '(')) _Err(_i, "unexpected");
		_i++;
		sb.Append('(');
		
		if (!_TokIsChar(_i, ')')) {
			for (int iParam = 0; ; iParam++, _i++) {
				
				//ignore ...
				if (_TokIsChar(_i, '.') && _TokIsChar(_i + 1, '.') && _TokIsChar(_i + 2, '.') && _TokIsChar(_i + 3, ')')) {
					_i += 3;
					sb.Remove(sb.Length - 2, 2); //", "
					break;
				}
				
				_PARAMDATA t;
				_ParseParamOrMember(context, out t, parentName, iParam + 1);
				
				//skip default value of optional parameter
				if (_TokIsChar(_i, '=')) {
					while (!_TokIsChar(++_i, ',', ')')) { }
				}
				
				//is ',' or ')'?
				bool isLast = _TokIsChar(_i, ')');
				if (!isLast && !_TokIsChar(_i, ',')) _Err(_i, "unexpected");
				
				if (t.attributes != null) { sb.Append(t.attributes); sb.Append(' '); }
				sb.Append(t.typeName); sb.Append(' '); sb.Append(t.name);
				if (!isLast) sb.Append(", ");
				
				if (isLast) break;
			}
		}
		_i++; //skip ')'
		sb.Append(");\r\n");
	}
	
	struct _PARAMDATA {
		public string typeName; //C# typename
		public string name; //parameter name
		public string attributes; //C# attributes
		public string comment; //comment after member
		public bool isNestedTypeDefinitionWithoutVariables;
		public bool isAnonymousTypeDefinitionWithoutVariables;
	}
	
	/// <summary>
	/// Converts C++ function parameter or struct member definition (type, name, const etc) to C# typename/name/etc.
	/// _i must be at its start. Finally it will be after the parsed part. Does not check whether it is followed by ',' etc.
	/// </summary>
	/// <param name="context">Member, Parameter or DelegateParameter.</param>
	/// <param name="t">Receives C# typename, name etc.</param>
	/// <param name="parentName">The function/struct name. Used to auto-create names for nameless parameters.</param>
	/// <param name="iParam">1-based index of parameter/member. Used to auto-create names for nameless parameters.</param>
	void _ParseParamOrMember(_TypeContext context, out _PARAMDATA t, string parentName, int iParam) {
		bool isMember = context == _TypeContext.Member;
		
		t = new _PARAMDATA();
		
		int iSAL = 0;
		if (_TokIsChar(_i, '^') && _TokIsChar(_i + 1, '"')) {
			_i++;
			if (!isMember) {
				iSAL = _i;
				_tok[iSAL] = new _Token(_tok[iSAL].s + 1, _tok[iSAL].len - 2);
			}
			_i++;
		}
		
		var d = new _FINDTYPEDATA();
		_FindTypename(isMember, ref d);
		if (d.outIsNestedTypeDefinition) {
			if (_TokIsChar(_i, ';')) {
				t.isNestedTypeDefinitionWithoutVariables = true;
				t.isAnonymousTypeDefinitionWithoutVariables = d.outIsAnonymousTypeDefinition;
				t.typeName = d.outSym.csTypename;
				return;
			}
		} else _i++;
		
		//pointer
		int ptr = 0;
		while (_TokIsChar(_i, '*', '&')) { _i++; ptr++; }
		
		//suport inline function type definition
		bool isFunc = !d.outIsNestedTypeDefinition && _DetectIsFuncType(_i);
		if (isFunc) {
			var f = new _INLINEFUNCTYPEDATA(parentName, iParam);
			_DeclareTypedefFunc(d.outSym, ptr, d.outIsConst, d.outTypenameToken, f);
			t.typeName = f.typeName;
			t.name = f.paramName;
		} else {
			//typename, param/member name
			t.typeName = _ConvertTypeName(d.outSym, ref ptr, d.outIsConst, d.outTypenameToken, context, out t.attributes, iSAL);
			
			if (_TokIsIdent(_i)) t.name = _TokToString(_i++);
			else if (!isMember && _TokIsChar(_i, ",)[=")) t.name = "param" + iParam;
			else _Err(_i, "no name");
		}
		
		if (_TokIsChar(_i, '[')) {
			_ConvertCArray(ref t, !isMember);
		}
		
		//escape names that are C# keywords
		if (_csKeywords.Contains(t.name)) {
			//print.it(t.name);
			t.name = "@" + t.name;
		}
	}
	
	struct _FINDTYPEDATA {
		public _Symbol outSym;
		public bool outIsConst;
		public bool outIsAnonymousTypeDefinition;
		public bool outIsNestedTypeDefinition;
		public int outTypenameToken;
		public int inTypedefNameToken;
	}
	
	/// <summary>
	/// Finds typename. Gets its _Symbol etc.
	/// Starts searching from _i. Finally _i will be typename token index.
	/// Error if not found.
	/// Initially sets all outX=0/false/null.
	/// If there is 'const', sets outIsConst=true.
	/// If there is 'struct' etc as nested definition, converts the definition, sets outIsNestedStruct=true; then _i finally will be after }, which can be semicolon, variable name or * variable name.
	/// If there is 'struct' etc as forward declaration, adds forward declaration.
	/// </summary>
	void _FindTypename(bool isMember, ref _FINDTYPEDATA d) {
		d.outSym = null;
		d.outIsConst = false;
		d.outIsNestedTypeDefinition = false;
		d.outTypenameToken = 0;
		
		//process keywords until typename
		for (; _TokIsIdent(_i); _i++) {
			d.outSym = _FindSymbol(_i, true);
			var k = d.outSym as _Keyword;
			if (k == null) {
				d.outTypenameToken = _i;
				return;
			}
			
			switch (k.kwType) {
			case _KeywordT.TypeDecl:
				//is nested struct/enum/typedef definition?
				if (isMember) {
					bool isDef = false;
					if (_TokIsChar(_i, 't')) isDef = true;
					else {
						int j = _i + 1; if (_TokIsIdent(j)) j++;
						if (_TokIsChar(j, "{:;")) isDef = true;
					}
					if (isDef) {
						_DeclareType(ref d);
						d.outIsNestedTypeDefinition = true;
						return;
					}
				}
				
				//inline forward declaration
				d.outSym = _InlineForwardDeclaration();
				d.outTypenameToken = _i;
				return;
			case _KeywordT.Normal:
				if (_TokIs(_i, "const")) { d.outIsConst = true; continue; }
				break;
			}
			
			_Err(_i, "unexpected");
		}
		_Err(_i, "no type");
	}
	
	enum _TypeContext {
		Parameter, DelegateParameter, Return, Member, ComParameter, ComReturn
	}
	
	/// <summary>
	/// Converts type name/pointer to C# type name.
	/// The return value is type name, possibly with * or []. If parameter, also can have ref/out/in and [In]/[Out].
	/// </summary>
	/// <param name="t">The type.</param>
	/// <param name="ptr">Pointer level. The function may adjust it depending on typedef pointer level etc.</param>
	/// <param name="isConst">Is const.</param>
	/// <param name="iTokTypename">Type name token index. Can be 0 if don't need to unalias etc; then just adds pointer/ref if need.</param>
	/// <param name="context">Depending on it char* will be converted to "string" etc.</param>
	/// <param name="attributes">Receives null or MarshalAs attribute.</param>
	/// <param name="iSAL">SAL token index, or 0 if no SAL.</param>
	string _ConvertTypeName(_Symbol t, ref int ptr, bool isConst, int iTokTypename, _TypeContext context, out string attributes, int iSAL = 0) {
		attributes = null;
		string name, marshalAs = null;
		
		bool isLangType = false, isParameter = false, isCOM = false, isBlittable = false, isRawPtr = false;
		switch (context) {
		case _TypeContext.Parameter: case _TypeContext.DelegateParameter: isParameter = true; break;
		case _TypeContext.ComParameter: isParameter = true; isCOM = true; break;
		case _TypeContext.ComReturn: isCOM = true; break;
		}
		
		bool _In_ = false, _Out_ = false, _Inout_ = false;
		if (iSAL > 0) {
			//print.it(_tok[iSAL]);
			if (_TokStarts(iSAL, "_In_")) _In_ = true;
			else if (_TokStarts(iSAL, "_Out")) _Out_ = true;
			else if (_TokStarts(iSAL, "_Inout_")) _Inout_ = true;
			else _Err(iSAL, "unknown SAL");
		}
		
		if (iTokTypename != 0) {
			ptr += _Unalias(iTokTypename, ref t, ref isConst);
			name = t.csTypename;
			
			var c = t as _CppType;
			if (c != null) {
				isLangType = true;
				isBlittable = true;
				switch (name) {
				case "char":
					isBlittable = false;
					if (ptr is 1 or 2) {
						bool isBSTR = _TokIs(iTokTypename, "BSTR");
						if (ptr == 1 || (isParameter && isBSTR)) {
							//why '&& isBSTR':
							//	If non-BSTR char** parameter, cannot be 'out string' because .NET does not know how to free the string; often it is even undocumented.
							//	And ref in many cases is bad.
							
							ptr--;
							
							switch (context) {
							case _TypeContext.Member:
								if (isConst || isBSTR) {
									name = "string";
									if (isBSTR) marshalAs = "BStr";
								} else {
									//string dangerous, because if the callee changes member pointer, .NET tries to free the new string with CoTaskMemFree.
									ptr = 1;
									//print.it(_DebugGetLine(iTokTypename));
									isRawPtr = true;
								}
								break;
							case _TypeContext.Return:
							case _TypeContext.ComReturn:
								ptr = 1; //if string, .NET tries to free the return value
								isRawPtr = true;
								break;
							case _TypeContext.DelegateParameter:
								ptr = 1; //because some are "LPSTR or WORD". Rarely used.
								isRawPtr = true;
								break;
							case _TypeContext.Parameter:
							case _TypeContext.ComParameter:
								Debug.Assert(!(isConst && (_Out_ || _Inout_)));
								if (isConst || _In_ || isBSTR) {
									name = "string";
									//if (ptr == 1) print.it(_DebugGetLine(iTokTypename));
									if (isCOM) {
										if (!isBSTR) marshalAs = "LPWStr";
									} else {
										if (isBSTR) marshalAs = "BStr";
									}
								} else {
									ptr = 1;
									isRawPtr = true;
									//Could be StringBuilder, but Au library does not use it, it is slow. Or [Out] char[]. But Au library uses char*.
								}
								break;
							}
						}
					}
					if (ptr > 1) {
						isRawPtr = true;
						isConst = false;
					}
					break;
				case "int":
					if (_TokIs(iTokTypename, "BOOL")) {
						if (ptr == 0 || (ptr == 1 && isParameter)) {
							name = "bool";
							if (isCOM) marshalAs = "Bool";
							isBlittable = false;
						}
					}
					break;
				case "bool":
					marshalAs = "U1";
					isBlittable = false;
					break;
				case "void":
				case "byte":
				case "sbyte":
					if (ptr > 0) isRawPtr = true;
					break;
				case "double":
					if (_TokIs(iTokTypename, "DATE")) {
						if (ptr == 0 || (ptr == 1 && isParameter)) {
							name = "DateTime";
							isBlittable = false;
						}
					}
					break;
				}
				if (isRawPtr) isBlittable = true;
			}
		} else {
			name = t.csTypename;
		}
		
		if (!isLangType) {
			var ts = t as _Struct;
			if (ts != null) {
				if (ts.isInterface) {
					//print.it(ptr, ts.csTypename);
					if (ptr == 0) _Err(iTokTypename, "unexpected");
					if (--ptr > 0 && context == _TypeContext.Member) {
						name = "IntPtr";
						isBlittable = true;
					} else if (name is "IUnknown" or "IDispatch") {
						Debug_.PrintIf(ptr > 1, context);
						marshalAs = name;
						name = "object";
					}
				} else if (!ts.isClass) {
					switch (name) {
					case "wnd": case "LPARAM": isBlittable = true; break;
					case "GUID": name = "Guid"; break;
					case "DECIMAL": name = "decimal"; break;
					case "VARIANT":
						if ((isParameter && ptr <= 1) || (context == _TypeContext.Member && ptr == 0)) {
							name = "object";
							if (context != _TypeContext.ComParameter) marshalAs = "Struct";
						}
						break;
					//case "SAFEARRAY": //in SDK used only with SafeArrayX functions, with several other not-important functions and as [PROP]VARIANT members
					//print.it(ptr);
					//break;
					case "ITEMIDLIST":
						if (ptr > 0) { ptr--; name = "IntPtr"; isBlittable = true; }
						//else _Err(iTokTypename, "example"); //0 in SDK
						break;
					case "POINTL": name = "POINT"; break;
					case "RECTL": name = "RECT"; break;
					}
				}
			} else if (t is _Enum) {
				isBlittable = true;
			}
		}
		
		if (ptr > 0) {
			__ctn.Clear();
			bool isArray = false;
			if (!isRawPtr && isParameter) {
				string sal = null;
				if (iSAL > 0) sal = _TokToString(iSAL);
				
				if (iSAL > 0 && ptr == 1) { //if ptr>1, can be TYPE[]* or TYPE*[]
					if (_In_ && (sal.Contains("_reads_") || sal.Contains("count"))) {
						//print.it(_tok[iTokTypename], name, _DebugGetLine(iTokTypename));
						isArray = true;
						__ctn.Append("[In] ");
					}
					if (_Inout_ && (sal.Contains("_updates_") || sal.Contains("count"))) {
						//print.it(_tok[iTokTypename], name, _DebugGetLine(iTokTypename));
						isArray = true;
						__ctn.Append("[In,Out] ");
					}
					if (_Out_ && (sal.Contains("_writes_") || sal.Contains("count"))) {
						//print.it(_tok[iTokTypename], name, _DebugGetLine(iTokTypename));
						isArray = true;
						__ctn.Append("[Out] ");
					}
				}
				
				if (_Inout_) isConst = false;
				
				if (isArray) {
					ptr--;
				} else {
					ptr--;
					
					if (_Out_) {
						__ctn.Append("out ");
					} else if (_In_ || isConst) {
						if (isBlittable) {
							if (isConst && ptr == 0 && name != "IntPtr") {
								//print.it(_tok[iTokTypename], name, _DebugGetLine(iTokTypename));
								isArray = true; //usually array, because there is no sense for eg 'const int* param', unless it is a 64-bit value (SDK usually then uses LARGE_INTEGER etc, not __int64). Those with just _In_ usually are not arrays, because for arrays are used _In_reads_ etc.
							} else {
								__ctn.Append("in ");
								//print.it(_tok[iTokTypename], name, _DebugGetLine(iTokTypename));
							}
						} else {
							if (isConst) {
								__ctn.Append("in "); //prevents copying non-blittable types back to the caller when don't need
							} else {
								//print.it(_tok[iTokTypename], name, _DebugGetLine(iTokTypename));
								//__ctn.Append("in "); //no, because there are many errors in SDK where inout parameters have _In_
								__ctn.Append("ref ");
							}
						}
					} else {
						__ctn.Append("ref ");
					}
				}
				
				if (isArray) {
					bool useMarshalAsSubtype = false;
					if (isCOM) {
						//by default marshals as SAFEARRAY
						if (marshalAs == null) marshalAs = "LPArray";
						else useMarshalAsSubtype = true;
					} else if (context == _TypeContext.DelegateParameter) {
						isArray = false;
						ptr++;
						__ctn.Clear();
						//maybe can be array, not tested. Never mind, in SDK only 4 rarely used.
						//print.it(_tok[iTokTypename], name, _DebugGetLine(iTokTypename));
					} else if (marshalAs != null) useMarshalAsSubtype = true;
					
					if (useMarshalAsSubtype) marshalAs = "LPArray, ArraySubType = UnmanagedType." + marshalAs;
				}
			} //if(isParameter)
			
			__ctn.Append(name);
			if (ptr > 0) __ctn.Append('*', ptr);
			if (isArray) __ctn.Append("[]");
			
			name = __ctn.ToString();
		}
		
		if (marshalAs != null) {
			__ctn.Clear();
			string ret = null; if (context == _TypeContext.Return || context == _TypeContext.ComReturn) ret = "return: ";
			attributes = $"[{ret}MarshalAs(UnmanagedType.{marshalAs})]";
		}
		return name;
	}
	StringBuilder __ctn = new StringBuilder();
	
	/// <summary>
	/// Converts C-style fixed-size array to C#. Gets MarshalAs attribute, appends "[]" to typeName etc.
	/// Supports "[y][x]" etc.
	/// _i must be at '['. Finally it will be after ']'.
	/// If empty array (like TYPE x[] or TYPE x[0]), attributes receives "//...". If 1-element array, receives "/*...*/".
	/// </summary>
	/// <param name="t.typeName">This function appends "[]" if need, or convertes "char" to "string".</param>
	/// <param name="t.name">If less than 8 elements, and t.name looks like a "Reserved" etc, splits into multiple members like "Reserved_0, Reserved_1, ...".</param>
	/// <param name="t.attributes">If !isParameter, receives attribute like "[MarshalAs(UnmanagedType.ByValArray, SizeConst = {x})]". If already is MarshalAs attribute, uses it as ArraySubType.</param>
	/// <param name="isParameter">Just skip [..] or [...][...] and append "[]" to t.typeName. Used for parameters, because the attribute can be used only with struct fields; C++ arguments for parameters 'TYPE param[n]' are passed like 'TYPE* param', and n is ignored, can be empty.</param>
	void _ConvertCArray(ref _PARAMDATA t, bool isParameter = false) {
		//if (!isParameter) print.it(t.typeName);
		
		uint elemCount = 1;
		for (; _TokIsChar(_i, '['); _i++) { //support [a][b]
			int i0 = _i + 1;
			_SkipEnclosed();
			if (isParameter) continue;
			uint ec = 0;
			if (_i > i0) { //else TYPE x[]
				_ExpressionResult r = _Expression(i0, _i, "[]");
				switch (r.typeS) { case "int": case "uint": break; default: _Err(i0, "cannot calculate"); break; }
				ec = r.valueI;
			}
			elemCount *= ec;
		}
		
		if (isParameter) {
			t.typeName += "[]";
			return;
		}
		
		if (t.typeName.Ends("[]")) t.typeName = t.typeName.Remove(t.typeName.Length - 2); //'TYPE a[n], b[m]'
		
		string marshalAs = "ByValArray", comment = null, comment2 = null;
		if (elemCount == 0) { //variable-length array of >= 0 elements
			comment = "//"; //disable the attribute together with member, and let the member be not array
		} else if (elemCount == 1) { //variable-length array of >= 1 elements
			comment = "/*"; comment2 = "*/"; //disable the attribute, and let the member be not array
		} else if (t.typeName == "char") {
			t.comment = $"//public fixed char {t.name}[{elemCount}];";
			t.typeName = "string";
			marshalAs = "ByValTStr";
		} else {
			if (elemCount < 8 && (t.name.Find("Reserved", true) >= 0 || t.name.Find("pad", true) >= 0 || t.name.Starts("Spare", true))) {
				//print.it(t.name);
				var sb = new StringBuilder();
				for (int i = 0; i < elemCount; i++) {
					if (i > 0) sb.Append(", ");
					sb.Append(t.name);
					sb.Append('_');
					sb.Append(i);
				}
				t.name = sb.ToString();
				comment = "/*"; comment2 = "*/";
			} else {
				//if(elemCount<8) print.it(t.name);
				if (t.typeName is "byte" or "sbyte" or "int" or "uint" or "long" or "ulong" or "short" or "ushort" or "float" or "double")
					t.comment = $"//public fixed {t.typeName} {t.name}[{elemCount}];";
				t.typeName += "[]";
			}
		}
		
		if (t.attributes != null) _Err(_i, "todo"); //0 in SDK. Should extract its type from [MarshalAs(UnmanagedType.(\w+) and insert in the new attributes.
		t.attributes = $"{comment}[MarshalAs(UnmanagedType.{marshalAs}, SizeConst = {elemCount})]{comment2}";
			//CONSIDER: also add commented properties to get Span. Then also can add properties to get/set managed string or array from the Span.
		//	The MarshalAs way often cannot be used (makes the type managed and then cannot get pointer) or undesirable. The fixed way can be used only with some types.
		//	Tested, in Release almost same speed as raw pointer. If used in script that isn't optimized, much slower, but not too slow.
		//	Examples:
		/*
[Winapi]
static unsafe class api {

internal struct Example {
		//string
		fixed char _c[5];
		public Span<char> s => MemoryMarshal.CreateSpan(ref _c[0], 5);
		public string s_String { get => _ToString(s); set => _ToSpan(s, value); }
		
		//array of fixable type
		fixed byte _b[5];
		public Span<byte> b => MemoryMarshal.CreateSpan(ref _b[0], 5);
		public byte[] b_Array { get => b.ToArray(); set => value.AsSpan().CopyTo(b); }
		
		//array of other type
		POINT _a, _a1, _a2, _a3, _a4;
		//POINT _a; fixed byte _ab[32]; //or this, if can calculate size easily
		public Span<POINT> a => MemoryMarshal.CreateSpan(ref _a, 5);
		public POINT[] a_Array { get => a.ToArray(); set => value.AsSpan().CopyTo(a); }
		
		//array of size 1 or 0 at the end
		POINT _p;
		public Span<POINT> p(int count) => MemoryMarshal.CreateSpan(ref _p, count);
	}
	
	static string _ToString(Span<char> p) => new(p[..p.IndexOf('\0')]);
	
	static void _ToSpan(Span<char> p, RStr s) {
		if (s.Length >= p.Length) throw new ArgumentException($"Destination is too short. Max string length = {p.Length - 1}.");
		p[s.Length] = '\0';
		s.CopyTo(p);
	}
}
			*/
		}

		/// <summary>
		/// Converts C++ calling convention keyword to C# enum CallingConvention member name.
		/// Returns null if __stdcall.
		/// </summary>
		/// <param name="iTok">C++ calling convention keyword token. Error if other token.</param>
		string _ConvertCallConv(int iTok) {
	_FindKeyword(iTok, _KeywordT.CallConv);
	
	char* s = T(iTok);
	while (*s == '_') s++;
	switch (*s) {
	case 'c': return "Cdecl";
	case 'f': return "FastCall";
	case 't': return "ThisCall";
	}
	return null; //StdCall is default
}
	}


================================================
FILE: Scripts/old/Windows SDK to C#/@SDK converter/SDK converter.cs
================================================
/*/ testInternal Au; /*/
print.clear();
var x = new SdkConverter.Converter();

#if !true
//x.Convert(
//	@"C:\code\au\Other\SdkConverter\Data\Header.h",
//	//@"C:\code\au\Other\SdkPreprocess\Cpp.cpp",
//	@"C:\code\au\Other\Api\Api-small.cs", false);

x.Convert(@"C:\code\au\Other\Api\Api-preprocessed-64.cpp", @"C:\code\au\Other\Api\Api-64.cs", false);
print.scrollToTop();
#else
x.Convert(@"C:\code\au\Other\Api\Api-preprocessed-64.cpp", @"C:\code\au\Other\Api\Api-64.cs", false);

if (true) {
	new SdkConverter.Converter().Convert(@"C:\code\au\Other\Api\Api-preprocessed-32.cpp", @"C:\code\au\Other\Api\Api-32.cs", true);
}
#endif


================================================
FILE: Scripts/old/Windows SDK to C#/@SDK converter/Tokenize.cs
================================================
namespace SdkConverter;

unsafe partial class Converter {
	void _Tokenize(char* s) {
		_tok.Capacity = _src.Length / 8;
		_tok.Add(new _Token());
		
		bool isNewLine = true;
		int len;
		char c;
		
		for (; (c = *s) != 0; s++) {
			switch (c) {
			case '\r':
			case '\n':
				isNewLine = true;
				break;
			case ' ':
			case '\t':
			case '\v':
			case '\f':
				break;
			case '`': //was #define, #undef or #pragma pack
				if (isNewLine) { //else it is preprocessor operator
					if (_nTokUntilDefUndef == 0 && s[1] != '(') {
						_nTokUntilDefUndef = _tok.Count;
						s[-1] = '\0'; //was '\n
						_tok.Add(new _Token(s - 1, 1));
					}
				}
				_tok.Add(new _Token(s, 1));
				break;
			default:
				//TODO3: replace '$' with '_'. Although SDK does not have such identifiers when removed CRT headers.
				if (_IsCharIdentStart(c)) {
					len = _LenIdent(s);
					
					////is prefix"string" or prefix'char'?
					//bool isPrefix = false;
					//switch(s[len]) {
					//case '"':
					//	if(len == 1) isPrefix = (c == 'L' || c == 'u' || c == 'U');
					//	else if(len == 2) isPrefix = (c == 'u' && s[1] == '8');
					//	//info: raw strings replaced to escaped strings when preprocessing
					//	break;
					//case '\'':
					//	if(len == 1) isPrefix = (c == 'L' || c == 'u' || c == 'U');
					//	break;
					//}
					//if(isPrefix) { //remove prefix
					//	for(; len > 0; len--) *s++ = ' ';
					//	s--;
					//	continue;
					//}
					
				} else if (_IsCharDigit(c)) len = _LenNumber(s);
				else if (c == '"') len = _SkipString(s);
				else if (c == '\'') len = _SkipApos(s);
				else len = 1;
				_tok.Add(new _Token(s, len));
				s += len - 1;
				break;
			}
		}
		
		_nTok = _tok.Count;
		if (_nTokUntilDefUndef == 0) _nTokUntilDefUndef = _nTok;
		
		for (int i = 0; i < 10; i++) _tok.Add(new _Token(s, 1)); //to safely query next token
		_tok[0] = new _Token(s, 1); //to safely query previous token. Also used as an empty token. The empty list item added before tokenizing.
	}
	
	/// <summary>
	/// Parses and folds string constant, starting from s, which must be at the starting ".
	/// Returns folded string length, including both ".
	/// For example, if s is '"a" "b"', makes it '"ab"   ' and returns 4.
	/// Error if the ending " is missing.
	/// </summary>
	//#if NEWSTRING
	int _SkipString(char* s) {
		Debug.Assert(*s == '"');
		
		//is prefix?
		bool isPrefix = false;
		int iPrevTok = _tok.Count - 1;
		_Token pt = _tok[iPrevTok];
		char c = *pt.s;
		if (_IsCharIdentStart(c) && pt.len == (int)(s - pt.s)) {
			if (pt.len == 1) {
				isPrefix = (c == 'L' || c == 'u' || c == 'U');
			} else if (pt.len == 2) {
				isPrefix = (c == 'u' && pt.s[1] == '8');
			}
			if (isPrefix) _tok.RemoveAt(_tok.Count - 1);
			//info: raw strings replaced to escaped strings in script.
		}
		
		char* s0 = s++, d = s; //d used for folding
		g0:
		for (; ; s++) {
			*d++ = *s; //folding
			if (*s == '"') {
				if (s[-1] == '\\') {
					//is \" or \\"?
					int k = -1; while (s[k - 1] == '\\') k--;
					if ((k & 1) != 0) continue;
				}
				break;
			}
			if (*s <= '\r') {
				if (*s == 0 || *s == '\r' || *s == '\n') _Err(s0, "missing \"");
			}
		}
		
		//fold strings
		char* f = ++s; //skip "
		while (_IsCharSpaceOrRN(*f)) f++;
		if (isPrefix) {
			if (*f == *pt.s && (pt.len == 1 || f[1] == pt.s[1]) && f[pt.len] == '"') { s = f + pt.len + 1; d--; goto g0; }
		} else {
			if (*f == '"') { s = f + 1; d--; goto g0; }
		}
		
		for (f = d; f < s; f++) *f = ' '; //erase what is moved to the left
		
		//ANSI string constant?
		if (!isPrefix && _nTokUntilDefUndef != 0 && _TokIsChar(iPrevTok - 1, '`')) {
			//print.it(new string(s0, 0, (int)(d - s0)));
			//_Err(iPrevTok, "ANSI string");
			*s0 = '\x2'; //later will restore '"' and add to "FAILED TO CONVERT"
		}
		
		return (int)(d - s0);
		
		//info: could also give parsed length, but this is simpler. Caller will have to skip spaces in any case.
	}
	
	/// <summary>
	/// Parses character constant, starting from s, which must be at the starting '.
	/// Returns its length, including both '.
	/// Error if the ending ' is missing.
	/// </summary>
	int _SkipApos(char* s) {
		Debug.Assert(*s == '\'');
		
		//is prefix?
		_Token pt = _tok[_tok.Count - 1];
		char c = *pt.s;
		if (_IsCharIdentStart(c) && pt.len == (int)(s - pt.s) && pt.len == 1) {
			if (c == 'L' || c == 'u' || c == 'U') _tok.RemoveAt(_tok.Count - 1);
		}
		
		for (char* s0 = s++; ; s++) {
			if (*s == '\'') {
				if (s[-1] == '\\') {
					//is \' or \\'?
					int k = -1; while (s[k - 1] == '\\') k--;
					if ((k & 1) != 0) continue;
				}
				return (int)(s + 1 - s0);
			}
			if (*s <= '\r') {
				if (*s == 0 || *s == '\r' || *s == '\n') _Err(s0, "missing '");
			}
		}
	}
	
	/// <summary>
	/// Parses a number literal and returns its length, including suffix.
	/// Error if invalid.
	/// </summary>
	int _LenNumber(char* s) {
		if (!_IsCharDigit(*s)) return 0;
		char* s0 = s++;
		
		//hex, bin, oct
		int hexEtc = 0;
		if (*s0 == '0') {
			if (*s == 'x' || *s == 'X') {
				hexEtc = 2;
				for (++s; _IsCharHexDigit(*s); s++) { }
			} else if (*s == 'b' || *s == 'B') {
				hexEtc = 3;
				for (++s; *s == '0' || *s == '1'; s++) { }
			} else if (_IsCharDigit(*s)) hexEtc = 1; //or can be double like 01.2
			
			if (hexEtc >= 2 && (s - s0) == 2) _Err(s, "unexpected");
		}
		
		bool dbl = false;
		if (hexEtc < 2) {
			while (_IsCharDigit(*s)) s++;
			//double fraction
			if (*s == '.') {
				dbl = true;
				for (++s; _IsCharDigit(*s); s++) { }
			}
		}
		
		//double exponent
		if (*s == 'E' || *s == 'e') {
			dbl = true;
			s++;
			if (*s == '-' || *s == '+') s++;
			if (!_IsCharDigit(*s)) _Err(s, "unexpected");
			while (_IsCharDigit(*s)) s++;
		}
		
		if (hexEtc == 1 && !dbl) { //validate oct digits now
			for (char* t = s0 + 2; t < s; t++) if (*t > '7') _Err(t, "unexpected");
		}
		
		//suffix
		uint suffixType;
		s += _NumberSuffix(s, dbl, out suffixType);
		
		return (int)(s - s0);
	}
	
	/// <summary>
	/// Scans integer or floating-point constant suffix and returns its length.
	/// Error if invalid suffix.
	/// Converts C++ suffix to C#.
	/// </summary>
	/// <param name="s"></param>
	/// <param name="type">Receives flags: 1 unsigned, 2 __int64, 4 float.</param>
	int _NumberSuffix(char* s, bool floatingPoint, out uint type) {
		type = 0;
		char* s0 = s;
		int lenTrim = 0;
		
		if (floatingPoint) {
			if (*s == 'f' || *s == 'F') {
				s++; type |= 4;
			} else if (*s == 'l' || *s == 'L') *s++ = ' ';
		} else {
			if (*s == 'u' || *s == 'U') { s++; type |= 1; }
			
			if (*s == 'l' || *s == 'L') {
				s++; lenTrim = 1;
				if (*s == 'l' || *s == 'L') {
					*s++ = ' ';
					type |= 2;
				} else s[-1] = ' ';
			} else if (*s == 'i' || *s == 'I') {
				if (s[1] == '8') {
					s[0] = s[1] = ' ';
					s += 2; lenTrim = 2;
				} else {
					if (s[1] == '6' && s[2] == '4') {
						type |= 2;
						s[0] = 'L'; lenTrim = 2;
					} else if ((s[1] == '3' && s[2] == '2') || (s[1] == '1' && s[2] == '6')) {
						s[0] = ' '; lenTrim = 3;
					} else _Err(s, "unexpected");
					
					s[1] = s[2] = ' ';
					s += 3;
				}
			}
		}
		
		if (_IsCharIdent(*s)) _Err(s, "unexpected");
		return (int)(s - lenTrim - s0);
	}
}


================================================
FILE: Scripts/old/Windows SDK to C#/@SDK converter/Types.cs
================================================
namespace SdkConverter;

unsafe partial class Converter {
	/// <summary>
	/// Converts simple typedef or function typedef declaration.
	/// _i must be at 'typedef'. Finally it will be at semicolon.
	/// </summary>
	void _DeclareTypedef() {
		//detect typedef type
		int typedefType = 0;
		//0 - typedef [struct|enum|etc] X Y...
		//1 - typedef ... (FUNCTYPE)(...)
		//2 - typedef struct|enum|etc [X] [:base] {...} Y...
		int i = ++_i;
		for (; ; i++) {
			char c = *T(i);
			if (c == '{') typedefType = 2; else if (c == '(') typedefType = 1; else if (c != ';') continue;
			break;
		}
		//print.it(_tok[_i], typedefType);
		
		var d = new _FINDTYPEDATA();
		
		if (typedefType == 2) {
			var k = _FindKeyword(_i, _KeywordT.TypeDecl);
			
			//find alias name. _DeclareType() will use it.
			i = _SkipEnclosed(i) + 1;
			if (_TokIsIdent(i) && _TokIsChar(i + 1, ';', ',')) d.inTypedefNameToken = i;
			
			_DeclareType(ref d);
		} else {
			_FindTypename(false, ref d);
			int iTypeName = _i++;
			
			if (typedefType == 1) {
				int rtPtr = 0;
				for (; _TokIsChar(_i, '*', '&'); _i++) rtPtr++;
				
				_DeclareTypedefFunc(d.outSym, rtPtr, d.outIsConst, iTypeName);
				return;
			}
		}
		
		_Symbol aliasOf = d.outSym;
		int ptr = 0; //0 - start or after comma, >0 pointer level, <0 after identifier
		int ptrBase = 0;
		
		//don't declare typedef to typedef
		if (typedefType == 0 && aliasOf is _Typedef) {
			var t = aliasOf as _Typedef;
			//print.it($"unaliased: {_tok[_i-1]} -> {t.aliasOf.csTypename}");
			aliasOf = t.aliasOf;
			ptrBase = t.ptr;
		}
		
		for (; ; _i++) {
			if (_TokIsIdent(_i)) {
				if (ptr < 0) goto ge;
				if (_TokIsChar(_i + 1, '[')) { //typedef X Y[n];
					string attr, typ = _ConvertTypeName(aliasOf, ref ptr, false, 0, _TypeContext.Member, out attr);
					Debug.Assert(attr == null); //never mind, 0 in SDK
					__DeclareTypedef_Array(typ);
				} else {
					bool defined = false;
					if (aliasOf is _CppType) {
						
						//convert LONG_PTR etc to nint, not to long/ulong
						if (_is32bit ? (aliasOf.csTypename == "int" || aliasOf.csTypename == "uint") : (aliasOf.csTypename == "long" || aliasOf.csTypename == "ulong")) {
							string name = _TokToString(_i);
							if (name.Ends("_PTR") || name == "POINTER_64_INT") {
								//print.it(_tok[_i], aliasOf.csTypename, ptr);
								aliasOf = _sym_LPARAM;
							} //else print.it(_tok[_i], aliasOf.csTypename, ptr);
							
						}
						
					} else if (_TokIs(_i, aliasOf.csTypename)) {
						defined = true;
					} else if (_nsCurrent == 0 && aliasOf.forwardDecl && ptrBase + ptr == 0) {
						string alias = _TokToString(_i);
						//if(!(aliasOf is _Struct)) print.it(aliasOf); //0 in SDK
						//print.it(aliasOf.csTypename, alias, ptr != 0);
						try { _forwardDeclTypedefs.Add(aliasOf.csTypename, _i); } catch { } //info: try/catch because SDK contains 1 duplicate typedef
					}
					
					if (!defined) _AddSymbol(_i, new _Typedef(aliasOf, ptr + ptrBase, d.outIsConst));
				}
				ptr = -1;
			} else {
				switch (*T(_i)) {
				case '*':
				case '&':
					if (ptr < 0) goto ge;
					ptr++;
					break;
				case ',':
					if (ptr >= 0) goto ge;
					ptr = 0;
					break;
				case ';':
					if (ptr >= 0) goto ge;
					return;
				default: goto ge;
				}
			}
		}
		ge:
		_Err(_i, "unexpected");
	}
	
	void __DeclareTypedef_Array(string type) {
		int iName = _i++;
		string name = _TokToString(iName);
		//print.it(name, type);
		var t = new _PARAMDATA { typeName = type, name = "a" };
		_ConvertCArray(ref t); _i--;
		_sbType.AppendFormat("\r\ninternal struct {0} {{\r\n\t{1} public {2} {3};\r\n", name, t.attributes, type, t.name);
		if (t.comment != null) _sbType.Append('\t').AppendLine(t.comment);
		_sbType.AppendLine("}");
		_AddSymbol(iName, new _Struct(name, false));
		//info:
		//SDK has ~15 such typedefs. Some of them are [1] ie used as variable-length array.
		//We convert to struct, because would be difficult to have this as typedef.
	}
	
	//_Symbol _CopyStruct(_Symbol xFrom, string name) {
	//	var t = _Struct.Copy(xFrom as _Struct, name);
	//	try { _AddSymbol(_i, t); } catch { return xFrom; } //info: 3 in SDK already defined
	//	_FormatStruct(t);
	//	return t;
	//}
	
	//_Symbol _CopyEnum(_Symbol xFrom, string name) {
	//	var t = _Enum.Copy(xFrom as _Enum, name);
	//	try { _AddSymbol(_i, t); } catch { return xFrom; } //info: 0 in SDK already defined
	//	_FormatEnum(t);
	//	return t;
	//}
	
	//When 'typedef struct X Y;', and X is forward declaration, we add X=Y to this map. Then, when defining X, we swap names Y with X.
	//Without this, everywhere would be used X, which usually is a tag name such as tagVARIANT.
	//Dictionary<string, List<_Token>> _forwardTypedeclMap = new Dictionary<string, List<_Token>>();
	Dictionary<string, int> _forwardDeclTypedefs = new Dictionary<string, int>();
	
	/// <summary>
	/// Converts function typedef to C# delegate.
	/// _i must be at the first '(' (after typename and * etc). Finally it will be at semicolon.
	/// Info: script replaced 'typedef TYPE [callConv] FUNCTYPE(' to 'typedef TYPE ([callConv]*FUNCTYPE)('.
	/// </summary>
	/// <param name="t">Return type.</param>
	/// <param name="ptr">Pointer level.</param>
	/// <param name="isConst">Is const.</param>
	/// <param name="iTokTypename">Type name token index.</param>
	/// <param name="inl">Use for inline function type definition.</param>
	void _DeclareTypedefFunc(_Symbol t, int ptr, bool isConst, int iTokTypename, _INLINEFUNCTYPEDATA inl = null) {
		//return type
		string returnAttr, returnType = _ConvertTypeName(t, ref ptr, isConst, iTokTypename, _TypeContext.Return, out returnAttr);
		
		Debug.Assert(_TokIsChar(_i, '('));
		_i++;
		
		//calling convention
		int iCallConv = 0;
		if (_TokIsIdent(_i)) iCallConv = _i++;
		if (!_TokIsChar(_i, '*')) _Err(_i, "unexpected"); //todo: maybe also can be & (use _TokIsPtr)
		_i++;
		string callConv = iCallConv != 0 ? _ConvertCallConv(iCallConv) : "Cdecl";
		
		//name
		int iName = _i;
		string name = null;
		if (inl == null) {
			if (_SymbolExists(_i, false)) _Err(_i, "name already exists");
			name = _TokToString(_i);
		} else {
			if (_TokIsIdent(_i)) inl.paramName = _TokToString(_i);
			else { _i--; inl.paramName = "param" + inl.paramIndex; }
			
			inl.typeName = name = (inl.parentName + "_" + inl.paramName);
		}
		if (!_TokIsChar(++_i, ')')) _Err(_i, "unexpected");
		_i++;
		
		//start formatting
		StringBuilder sb = inl != null ? _sbInlineDelegate : _sbType;
		sb.AppendLine();
		if (callConv != null) sb.AppendFormat("[UnmanagedFunctionPointer(CallingConvention.{0})]\r\n", callConv);
		if (returnAttr != null) sb.AppendLine(returnAttr);
		sb.AppendFormat("internal delegate {0} {1}", returnType, name);
		
		//parameters
		_ConvertParameters(sb, name, _TypeContext.DelegateParameter);
		
		var x = new _Callback(name);
		if (inl == null) _AddSymbol(iName, x);
		else _AddSymbol(name, x, iName);
		
		if (inl != null) {
			inl.t = x;
		}
	}
	
	class _INLINEFUNCTYPEDATA {
		public readonly string parentName; //in
		public int paramIndex; //in
		public string typeName; //out
		public string paramName; //out
		public _Callback t; //out
		
		public _INLINEFUNCTYPEDATA(string parentName, int paramIndex) {
			this.parentName = parentName;
			this.paramIndex = paramIndex;
		}
	}
	
	/// <summary>
	/// Converts enum definition.
	/// _i must be at 'enum'. Finally it will be at semicolon.
	/// </summary>
	void __DeclareEnum(ref _FINDTYPEDATA d) {
		//is in global namespace?
		bool isScoped = _nsCurrent > 0;
		if (_TokIs(++_i, "class") || _TokIs(_i, "struct")) { isScoped = true; _i++; }
		
		_Enum x = null;
		
		//name
		string name = null;
		int iName = 0;
		if (_TokIsIdent(_i)) {
			bool wasForwardDecl;
			if (__MustSwapTagWithAlias(d.inTypedefNameToken, out wasForwardDecl)) {
				iName = d.inTypedefNameToken;
				name = _TokToString(iName);
				_AddSymbol(iName, x = new _Enum(name, false));
				_AddSymbol(_i++, new _Typedef(x, 0, false, wasForwardDecl));
			} else {
				iName = _i++;
				name = _TokToString(iName);
				
				//is forward declaration? Rare but allowed.
				if (_TokIsChar(_i, ';')) {
					_AddSymbol(iName, d.outSym = new _Enum(name, true));
					//info: don't need name in this case
					return;
				}
			}
		}
		
		_ns[_nsCurrent + 1].Clear();
		StringBuilder sb = _ns[_nsCurrent + 1].sb;
		
		//base type
		string sBaseType = null;
		if (_TokIsChar(_i, ':')) {
			_Symbol baseType = _FindType(++_i, true);
			if (0 != _Unalias(_i, ref baseType) || !(baseType is _CppType)) _Err(_i, "unexpected");
			sBaseType = baseType.csTypename;
			_i++;
		}
		
		if (!_TokIsChar(_i, '{')) _Err(_i, "unexpected");
		_i++;
		
		if (iName == 0) {
			iName = d.inTypedefNameToken;
			if (iName == 0) {
				//borrow enum name from first member. Benefits: easier for users to find the enum; will not be a name conflict; easy.
				if (!_TokIsIdent(_i)) _Err(_i, "unexpected");
				iName = _i;
				//print.it(_TokToString(iName));
			}
			name = _TokToString(iName);
		}
		
		//body
		sb.AppendLine(" {");
		bool isFlags = false;
		uint value = 0, nextValue = 0;
		for (; ; nextValue++) {
			if (!_TokIsIdent(_i)) _Err(_i, "unexpected");
			int iMember = _i++;
			string memberName = _TokToString(iMember);
			sb.Append('\t'); sb.Append(memberName);
			char c = *T(_i);
			if (c == '=') {
				int i0 = ++_i;
				while (!_TokIsChar(_i, ',', '}')) _i++;
				if (_i == i0) _Err(_i, "unexpected");
				
				_ExpressionResult r = _Expression(i0, _i, memberName);
				switch (r.typeS) {
				case "int":
					value = r.valueI;
					break;
				case "uint":
					value = r.valueI;
					if (!isFlags) { isFlags = true; sBaseType = "uint"; }
					break;
				default:
					_Err(i0, "cannot convert");
					break;
				}
				
				if (value != nextValue) {
					sb.Append(" = ");
					sb.Append(r.valueS);
				}
				
				nextValue = value;
			} else if (c == ',' || c == '}') {
				value = nextValue;
			} else _Err(_i, "unexpected");
			
			//add to a dictionary, to resolve other enum and #define
			if (!isScoped) {
				ulong v = value; if (isFlags) v |= 0x8000000000000000UL;
				//print.it("add", _tok[iMember]);
				_enumValues[_tok[iMember]] = v;
			}
			
			if (_TokIsChar(_i, ',')) _i++;
			if (_TokIsChar(_i, '}')) break;
			sb.AppendLine(",");
		}
		sb.AppendLine("\r\n}");
		_i++;
		
		if (sBaseType != null) sb.Insert(0, " :" + sBaseType);
		
		if (x == null) {
			if (_TryFindSymbolAs(iName, out x, false) && x.forwardDecl == true) x.forwardDecl = false;
			else _AddSymbol(iName, x = new _Enum(name, false));
		}
		
		sb.CopyTo(0, x.defAfterName = new char[sb.Length], 0, sb.Length);
		x.isFlags = isFlags;
		
		d.outSym = x;
		
		_FormatEnum(x);
	}
	
	Dictionary<_Token, ulong> _enumValues = new Dictionary<_Token, ulong>();
	bool _EnumFindValue(int iTokName, out ulong value, out _OP type) {
		type = _OP.OperandInt;
		//print.it("find", _tok[iTokName]);
		if (!_enumValues.TryGetValue(_tok[iTokName], out value)) return false;
		if ((value & 0x8000000000000000UL) != 0) { value = (uint)value; type = _OP.OperandUint; }
		return true;
	}
	
	void _FormatEnum(_Enum x) {
		StringBuilder sb = _sbType;
		sb.AppendLine();
		if (x.isFlags) sb.AppendLine("[Flags]");
		sb.Append("internal enum ");
		sb.Append(x.csTypename);
		sb.Append(x.defAfterName);
	}
	
	/// <summary>
	/// Converts struct/union/class/__interface/enum/typedef definition or forward declaration.
	/// _i must be at 'struct' etc. Finally it will be after }. If skipVariablesUntilSemicolon - at ;.
	/// </summary>
	void _DeclareType(ref _FINDTYPEDATA d, bool skipVariablesUntilSemicolon = false) {
		//struct, union, class, or __interface?
		bool isUnion = false, isInterface = false, isDualInterface = false, isClass = false;
		string access = "public", inheritInterface = null;
		char keyword = *T(_i);
		switch (keyword) {
		case 't': _DeclareTypedef(); return;
		case 'e': __DeclareEnum(ref d); return;
		case 'u': isUnion = true; break;
		case 'c': isClass = true; access = "private"; break;
		case '_': isInterface = true; break;
		}
		_i++;
		
		//uuid (was '__declspec(uuid', replaced in script)
		string uuid = null;
		if (_TokIs(_i, "uuid")) {
			if (!_TokIsChar(++_i, '(') || !_TokIsChar(++_i, '"') || !_TokIsChar(_i + 1, ')')) _Err(_i, "unexpected");
			uuid = _TokToString(_i);
			_i += 2;
		}
		
		//name
		_Struct x = null;
		int iName = 0;
		string name = null;
		if (_TokIsIdent(_i)) {
			bool isThisForwardDecl = _TokIsChar(_i + 1, ';');
			
			//look in _forwardDeclTypedefs, maybe need to swap this tag with previously declared alias
			if (d.inTypedefNameToken == 0 && _nsCurrent == 0 && !isThisForwardDecl) {
				string tag = _TokToString(_i);
				if (_forwardDeclTypedefs.TryGetValue(tag, out int k)) {
					//print.it($"<><c 0xff0000>{tag}, {_TokToString(k)}</c>");
					d.inTypedefNameToken = k;
					_forwardDeclTypedefs.Remove(tag);
				}
			}
			
			if (!isThisForwardDecl && __MustSwapTagWithAlias(d.inTypedefNameToken, out bool wasForwardDecl)) {
				iName = d.inTypedefNameToken;
				name = _TokToString(iName);
				_AddSymbol(iName, x = new _Struct(name, false));
				_AddSymbol(_i++, new _Typedef(x, 0, false, wasForwardDecl));
			} else {
				iName = _i++;
				name = _TokToString(iName);
				
				//forward-declare this because may contain a member of this pointer type
				if (!(_TryFindSymbolAs(iName, out x, false) && x.forwardDecl)) //info: if !x.forwardDecl _AddSymbol will throw
					_AddSymbol(iName, x = new _Struct(name, isThisForwardDecl));
				
				if (isThisForwardDecl) {
					d.outSym = x;
					x.isInterface = isInterface;
					x.isClass = isClass;
					//info: don't need name in this case
					//if(uuid != null) print.it(isClass); //all True
					if (isClass && uuid != null && _nsCurrent == 0) { //coclass
						//print.it(keyword, name, uuid);
						_DeclareGuid("CLSID_", name, uuid);
						_sbInterface.AppendFormat(
							"\r\n[ComImport, Guid({0}), ClassInterface(ClassInterfaceType.None)]"
							+ "\r\ninternal class {1} {{}}\r\n"
							, uuid, name);
					} else if (!isInterface && _interfaces.Contains(name)) {
						x.isInterface = true;
					}
					return;
				}
			}
		} else if (d.inTypedefNameToken != 0) {
			iName = d.inTypedefNameToken;
			name = _TokToString(iName);
		} //later will get name from variable
		
		//skip IUnknown and IDispatch
		if (isInterface || uuid != null) {
			bool skip = false;
			if (!__haveIUnknown && name == "IUnknown") __haveIUnknown = skip = true;
			else if (!__haveIDispatch && name == "IDispatch") __haveIDispatch = skip = true;
			if (skip) {
				_SkipStatement();
				x.forwardDecl = false;
				x.isInterface = true;
				x.isDualInterface = name == "IDispatch";
				_DeclareGuid("IID_", name, uuid);
				return;
			}
		}
		
		//is interface?
		if (__haveIUnknown && (isInterface || uuid != null) && _TokIsChar(_i, ':')) {
			//info: SDK has only few non-interface struct that have a base, and they don't have uuid.
			Debug.Assert(_interfaces.Contains(name));
			isInterface = true;
			_DeclareGuid("IID_", name, uuid);
		}
		
		//get empty namespace (symbols + StringBuilder) from stack
		_ns[_nsCurrent + 1].Clear();
		StringBuilder sb = _ns[_nsCurrent + 1].sb;
		
		//base type
		if (_TokIsChar(_i, ':')) {
			_i++;
			if (_TokIsIdent(_i + 1) && _FindKeyword(_i).kwType == _KeywordT.PubPrivProt) _i++;
			
			bool addedBaseMembers = false;
			for (int iBase = 0; ; iBase++, _i++) { //support multiple inheritance, although currently none in SDK
				_Symbol baseType = _FindType(_i, true);
				int ptr = _Unalias(_i, ref baseType);
				var bt = baseType as _Struct;
				if (bt == null || bt.forwardDecl || ptr != 0) _Err(_i, "unexpected");
				if (bt.members != null) { //null if IUnknown/IDispatch or no members
					if (bt.members[0] != '/') {
						sb.Append("// ");
						sb.AppendLine(bt.csTypename);
					}
					if (isInterface) {
						//print.it(iBase, bt.csTypename); //iBase all 0
						inheritInterface = inheritInterface == null ? bt.csTypename : inheritInterface + ", " + bt.csTypename;
						sb.Append(new string(bt.members).RxReplace(@"\[PreserveSig\] (?!new )\K", "new "));
						//info: for COM interfaces need to add base members, even if base interface specified.
					} else {
						sb.Append(bt.members);
					}
					addedBaseMembers = true;
				}
				if (isInterface) isDualInterface = bt.isDualInterface; //inherits IDispatch or another dual interface
				if (!_TokIsChar(++_i, ',')) break;
			}
			if (addedBaseMembers) { sb.Append("// "); sb.AppendLine(name); }
		}
		
		//members
		if (!_TokIsChar(_i, '{')) _Err(_i, "unexpected");
		int iBodyStart = _i++;
		string memberAttr = isUnion ? "[FieldOffset(0)] " : null;
		bool hasBitfields = false;
		
		if (_nsCurrent == 0) _anonymousStructSuffixCounter = 0;
		if (!isInterface) _sbType = _ns[++_nsCurrent].sb;
		
		for (int iMember = 1, iBitfields = 1, iInterfaceFunc = 1; !_TokIsChar(_i, '}'); _i++, iMember++) {
			
			//public/private/protected?
			if (_TokIsChar(_i + 1, ':') && 0 != _TokIs(_i, "public", "private", "protected")) {
				access = _TokToString(_i);
				_i++;
				continue;
			}
			
			//template etc?
			if (_TokIs(_i, "template")) {
				_SkipStatement();
				continue;
			}
			
			//interface function?
			if (isInterface) {
				_InterfaceFunction(sb, iInterfaceFunc++);
				continue;
			}
			
			//bitfield?
			if (__IsBitfield()) {
				_Bitfields(ref iBitfields, memberAttr);
				hasBitfields = true;
				continue;
			}
			
			//type
			_ParseParamOrMember(_TypeContext.Member, out _PARAMDATA t, name ?? "TYPEOF", iMember);
			
			if (t.isNestedTypeDefinitionWithoutVariables) {
				//if anonymous type definition without a variable, its members are part of parent in C++, therefore in C# need to add a variable of that type
				if (t.isAnonymousTypeDefinitionWithoutVariables) {
					sb.AppendFormat("{3}{2} {0} {1};\r\n", t.typeName, "_" + iMember, access, memberAttr);
				}
				continue;
			}
			
			//member variable
			for (; ; ) { //support TYPE a, b;
				switch (*T(_i)) {
				case ';': case ',': break;
				case '\0': _Err(iBodyStart, "no }"); break;
				default: _Err(_i, "unexpected"); break;
				}
				
				if (memberAttr != null) {
					if (t.attributes != null && t.attributes.Starts("//")) sb.Append("//"); //could instead place memberAttr after attributes, but then looks not good visually
					sb.Append(memberAttr);
				}
				if (t.attributes != null) { sb.Append(t.attributes); sb.Append(' '); }
				sb.AppendFormat("{2} {0} {1};\r\n", t.typeName, t.name, access);
				if (t.comment != null) {
					sb.AppendLine(t.comment);
					t.comment = null;
				}
				if (!_TokIsChar(_i, ',')) break;
				_i++;
				
				//ignore *. Assume never will be 'TYPE *a, b;' or 'TYPE a, *b;.
				while (_TokIsChar(_i, '*', '&')) _i++;
				//int ptr = 0;
				//while(_TokIsChar(_i, '*', '&')) { _i++; ptr++; }
				//print.it(ptr);
				
				if (!_TokIsIdent(_i)) _Err(_i, "unexpected");
				t.name = _TokToString(_i++);
				
				if (_TokIsChar(_i, '[')) {
					//_Err(_i, "example"); //0 in SDK
					t.attributes = null;
					_ConvertCArray(ref t);
				} else if (t.attributes != null) {
					_Err(_i, "unexpected"); //assume never will be 'TYPE a[n], b'
				}
			}
		}
		
		if (!isInterface) _sbType = _ns[--_nsCurrent].sb;
		
		_i++; //skip }
		if (skipVariablesUntilSemicolon) {
			//skip variables after }
			while (!_TokIsChar(_i, ';', '\0')) _i++;
		}
		
		if (iName == 0) {
			if (skipVariablesUntilSemicolon) return; //skip this struct/var definition (it is global 'struct {...} var;')
			
			//use variable name from 'struct{...}var;', or _anonymousStructSuffixCounter if just 'struct{...};'
			bool isVar = _TokIsIdent(_i);
			name = isVar ? ("TYPEOF_" + _TokToString(_i)) : ("TYPE_" + (++_anonymousStructSuffixCounter).ToString());
			_AddSymbol(name, x = new _Struct(name, false), _i);
			
			d.outIsAnonymousTypeDefinition = true;
		} else {
			if (x == null) _AddSymbol(name, x = new _Struct(name, false), iName); //typedef struct {...} name;
			else x.forwardDecl = false;
		}
		
		d.outSym = x;
		
		if (sb.Length > 0) {
			sb.CopyTo(0, x.members = new char[sb.Length], 0, sb.Length);
			sb.Clear();
		}
		
		//attributes
		if (isInterface) {
			sb.AppendFormat("[ComImport, Guid({0}){1}\r\n", uuid, isDualInterface ? "] //dual" : ", InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]");
			x.isInterface = true;
			x.isDualInterface = isDualInterface;
		} else {
			if (hasBitfields) sb.AppendLine("[DebuggerStepThrough]");
			if (_pack != 8) sb.AppendFormat("[StructLayout(LayoutKind.{0}, Pack={1})]\r\n", isUnion ? "Explicit" : "Sequential", _pack);
			else if (isUnion) sb.AppendLine("[StructLayout(LayoutKind.Explicit)]");
		}
		if (sb.Length > 0) sb.CopyTo(0, x.attributes = new char[sb.Length], 0, sb.Length);
		
		_FormatStruct(x, inheritInterface);
	}
	
	void _FormatStruct(_Struct x, string inheritInterface) {
		StringBuilder sb = x.isInterface ? _sbInterface : _sbType;
		sb.AppendLine();
		if (x.attributes != null) sb.Append(x.attributes);
		sb.Append(x.isInterface ? "internal interface " : "internal struct ");
		sb.Append(x.csTypename);
		if (inheritInterface != null) sb.Append(" : ").Append(inheritInterface);
		if (x.members != null) {
			sb.Append(" {\r\n");
			int offs = sb.Length;
			sb.Append(x.members);
			sb.Replace("\n", "\n\t", offs - 2, x.members.Length); //tab-indent members
			sb.AppendLine("}");
		} else sb.AppendLine(" { }");
	}
	
	//Returns true if must declare aliasToken as this struct|enum, and this struct|enum as aliasToken.
	//For example, it changes 'typedef struct tagX{...} X;' to 'typedef struct X{...} tagX;'.
	bool __MustSwapTagWithAlias(int aliasToken, out bool wasForwardDecl) {
		wasForwardDecl = false;
		if (aliasToken == 0) return false;
		if (_nsCurrent != 0) return false;
		if (_tok[_i].Equals(_tok[aliasToken])) return false; //typedef struct X{...}X
		
		__RemoveForwardDeclIfExists(aliasToken, false);
		wasForwardDecl = __RemoveForwardDeclIfExists(_i, true);
		
		return true;
	}
	
	bool __RemoveForwardDeclIfExists(int iTok, bool tag) {
		Debug.Assert(_nsCurrent == 0);
		var d = _ns[0].sym;
		_Token token = _tok[iTok];
		_Symbol x;
		if (!d.TryGetValue(token, out x)) return false;
		int ptr = _Unalias(iTok, ref x);
		//print.it(tag, x.GetType(), _TokToString(iTok), x.csTypename, ptr, x.forwardDecl);
		if (!x.forwardDecl || ptr != 0) _Err(iTok, "already exists");
		d.Remove(token);
		return true;
	}
	
	#region bitfields
	
	void _Bitfields(ref int iBitfields, string memberAttr) {
		int nBitsType = 0, nBitsTypePrev = 0, fieldOffset = 0;
		string csTypeName = null, bitHolderVar = null;
		bool isUnsigned;
		
		for (; ; ) {
			//type
			nBitsType = __BitfieldGetType(out csTypeName, out isUnsigned);
			if (nBitsType != nBitsTypePrev) { nBitsTypePrev = nBitsType; bitHolderVar = null; }
			_i++;
			g1:
			//name
			string varName = _TokIsChar(_i, ':') ? null : _TokToString(_i++);
			_i++;
			//field size
			int fieldSize = Api.strtoi(T(_i));
			if (fieldSize < 1 || fieldSize > nBitsType) _Err(_i, "unexpected");
			_i++;
			//add private member variable that holds the bitfields
			if (bitHolderVar == null || fieldOffset + fieldSize > nBitsType) {
				fieldOffset = 0;
				bitHolderVar = "__bf_" + iBitfields++;
				_sbType.AppendFormat("{2}private {0} {1};\r\n", csTypeName, bitHolderVar, memberAttr);
			}
			//add property that get/set the bitfield
			if (varName != null) {
				ulong mask = (1UL << fieldSize) - 1;
				ulong maskWithOffset = mask << fieldOffset;
				
				//work around C# problems with signed/unsigned conversion
				string op = "~";
				if (nBitsType > 32) {
					if (maskWithOffset > long.MaxValue) { maskWithOffset = ~maskWithOffset; op = null; }
				} else {
					if (maskWithOffset > int.MaxValue) { maskWithOffset = ~maskWithOffset & 0xffffffff; op = null; }
				}
				
				_sbType.AppendFormat(
					"public {0} {1} {{ get {{ return {8}({2} >> {3} & 0x{4:X}{7}); }} " +
					"set {{ {2} = {8}(({2} & {6}0x{5:X}{7}) | ((value & 0x{4:X}{7}) << {3})); }} }}\r\n",
					csTypeName, varName, bitHolderVar, fieldOffset, mask, maskWithOffset,
					op, isUnsigned ? "U" : "", nBitsType < 32 ? "(" + csTypeName + ")" : "");
			}
			
			fieldOffset += fieldSize;
			
			//next bitfield?
			if (_TokIsChar(_i++, ',')) {
				if (!(_TokIsChar(_i + 1, ':') && _TokIsIdent(_i) && _TokIsChar(_i + 3, ';', ','))) _Err(_i, "unexpected");
				goto g1;
			}
			if (!__IsBitfield()) break;
		}
		
		_i--;
	}
	
	bool __IsBitfield() {
		int i = _i;
		if (_TokIsChar(i + 2, ':')) {
			if (!_TokIsIdent(i++)) return false;
		} else if (!_TokIsChar(i + 1, ':')) return false; //nameless?
		
		return _TokIsIdent(i) && _IsCharDigit(*T(i + 2)) && _TokIsChar(i + 3, ';', ',');
	}
	
	/// <summary>
	/// Returns bitfield size in bits. Gets C# type name.
	/// </summary>
	int __BitfieldGetType(out string csTypename, out bool isUnsigned) {
		csTypename = null;
		isUnsigned = false;
		_Symbol t = _FindType(_i, true);
		if (0 == _Unalias(_i, ref t)) {
			var ct = t as _CppType;
			if (ct != null && ct.sizeBytesCpp != 0) {
				csTypename = ct.csTypename;
				isUnsigned = ct.isUnsigned;
				return ct.sizeBytesCpp * 8;
			} else if (t == _sym_LPARAM) {
				csTypename = _is32bit ? "int" : "long";
				return _is32bit ? 32 : 64;
				//SDK has 1 such struct (union PSAPI_WORKING_SET_BLOCK), and there the bitfield is at the end, so in most cases it is safe to use C# long instead. Using nint is difficult because of its variable size.
			} else if(t is _Enum te) {
				csTypename = "int";
				return 32;
			}
		}
		_Err(_i, "unexpected");
		return 0;
	}
	
	#endregion
	
	bool __haveIUnknown, __haveIDispatch;
	
	void _DeclareGuid(string prefix, string name, string uuid) {
		if (uuid == null) return;
		string fullName = prefix + name;
		if (_guids.ContainsKey(fullName)) return;
		if (prefix == "IID_" && _guids.ContainsKey("DIID_" + name)) return;
		//print.it(fullName);
		_sbVar.AppendFormat("\r\ninternal static Guid {0} = new({1});\r\n", fullName, uuid);
		//note: not 'readonly' because then could not be passed as ref.
	}
	
	void _InterfaceFunction(StringBuilder sb, int index) {
		if (_TokIs(_i, "virtual")) _i++;
		
		var d = new _FINDTYPEDATA();
		_FindTypename(false, ref d);
		_i++;
		
		//pointer
		int ptr = 0;
		while (_TokIsChar(_i, '*', '&')) { _i++; ptr++; }
		
		if (_TokIs(_i, "__stdcall")) _i++;
		
		string name = _TokToString(_i++);
		
		//some interfaces have IUnknown members
		bool skip = false;
		if (index <= 3) {
			if (index == 1 && name == "QueryInterface") skip = true;
			if (index == 2 && name == "AddRef") skip = true;
			if (index == 3 && name == "Release") skip = true;
		}
		if (skip) {
			_SkipEnclosed();
			_i++;
		} else {
			string returnAttr, returnType = _ConvertTypeName(d.outSym, ref ptr, d.outIsConst, d.outTypenameToken, _TypeContext.ComReturn, out returnAttr);
			
			//correct preprocessor-replaced method names that matched #define Func FuncW. Also there are several such struct members, never mind.
			if (name.Ends("W") && name.Length > 2 && char.IsLower(name[name.Length - 2])) {
				//print.it(name);
				name = name.Remove(name.Length - 1);
			}
			
			//start formatting
			sb.Append("[PreserveSig] ");
			if (returnAttr != null) { sb.Append(returnAttr); sb.Append(' '); }
			sb.Append(returnType); sb.Append(' '); sb.Append(name);
			
			//parameters
			_ConvertParameters(sb, name, _TypeContext.ComParameter);
		}
		
		//skip '= 0'
		if (_TokIsChar(_i, '=')) _i += 2;
	}
	
	/// <summary>
	/// Processes inline forward declaration such as 'struct X' in 'struct X * param' or 'struct X * Func(..)'.
	/// _i must be at 'struct' etc. Finally will be after it (_i++).
	/// Returns _Struct or _Enum, unaliased if was _Typedef.
	/// </summary>
	_Symbol _InlineForwardDeclaration() {
		bool en = *T(_i++) == 'e';
		_Symbol x;
		if (_TryFindSymbol(_i, out x, true) && 0 == _Unalias(_i, ref x)) {
			if (en) { if (x is _Enum) return x; } else if (x is _Struct) return x;
		}
		string name = _TokToString(_i);
		if (en) {
			x = new _Enum(name, true);
		} else {
			_Struct ts = new _Struct(name, true);
			x = ts;
			if (_interfaces.Contains(name)) ts.isInterface = true;
		}
		_AddSymbol(_i, x, true);
		return x;
	}
	
	/// <summary>
	/// Joins _sbType, _sbInlineDelegate, _func, and _sbInterface into single string.
	/// Replaces some identifiers in it etc.
	/// Clears the stringbuilders.
	/// </summary>
	string _PostProcessTypesFunctionsInterfaces() {
		//join types etc into single string, for replacements
		var sb = new StringBuilder();
		sb.Append("\r\n// TYPE\r\n");
		sb.Append(_sbType); _sbType.Clear();
		sb.Append(_sbInlineDelegate); _sbInlineDelegate.Clear();
		sb.Append("\r\n// FUNCTION\r\n");
		foreach (var v in _func) { sb.Append(v.Value); }
		sb.Append("\r\n// INTERFACE\r\n");
		sb.Append(_sbInterface); _sbInterface.Clear();
		string R = sb.ToString(); sb.Clear();
		
		//perf.first();
		foreach (var v in _ns[0].sym) {
			var sym = v.Value;
			
			//most forward declarations were converted to definitions, but some don't have definitions; replace their pointers to IntPtr
			if (sym.forwardDecl) {
				var ts = sym as _Struct;
				//if(ts==null) print.it(v.Key); //0 in SDK
				if (ts != null && ts.isClass) continue; //all in SDK are with GUID, converted to coclass
				string s = v.Key.ToString();
				
				//Replace all found TYPE* and ref TYPE to IntPtr.
				//Call RxReplace 2 times because regex (a|b) is very slow.
				string repl = "IntPtr";
				int n;
				if (ts != null && ts.isInterface) n = R.RxReplace($@"\b{s}\b", repl, out R); //decremented pointer level. 0 in SDK
				else n = R.RxReplace($@"\b{s}\*", repl, out R) + R.RxReplace($@"\bref {s}\b", repl, out R);
				if (n != 0) {
					//print.it($"<><c 0xff0000>{n}  {s}* = IntPtr</c>");
					continue;
				}
				
				//if(_FindIdentifierInString(R, s) < 0) { print.it("no", s); continue; } //5 in SDK
				//print.it(sym.csTypename, sym); //0 in SDK
				continue;
			}
			
			//process typedefs
			if (sym is _Typedef td) {
				if (!td.wasForwardDecl) continue; //don't need to replace. Makes this replacement code 10 times faster.
				if (td.ptr != 0) continue; //the type is or will be resolved in some way
				_Symbol t = td.aliasOf;
				if (t.forwardDecl) continue; //the type is already resolved in some way
				if (!((t is _Struct) || (t is _Enum))) continue;
				string s = v.Key.ToString();
				//if(_FindIdentifierInString(R, s) >= 0) { //makes slower
				//if(ts!=null) _FormatStruct(ts); else _FormatEnum(te);
				if (0 != R.RxReplace($@"\b{s}\b", t.csTypename, out R)) {
					//print.it($"<><c 0xff0000>{s} = {t.csTypename}    {t}</c>"); //all struct (0 enum) in SDK
					continue;
				}
				//print.it($"<><c 0x8000>{s} = {t.csTypename}    {t}</c>"); //OK, just not used between typedef and struct definition
			}
		}
		//perf.nw();
		
		//remove W from struct/interface/delegate names
		//perf.first();
		foreach (var v in _defineW) {
			__RemoveAW(ref R, v.Key, v.Value);
		}
		//perf.next();
		foreach (var v in _ns[0].sym) { //some A/W are not #define but typedef, eg 'typedef MIXERCAPSW MIXERCAPS;'
			var td = v.Value as _Typedef; if (td == null) continue;
			if (td.forwardDecl || td.ptr != 0) continue;
			string name, nameW = td.aliasOf.csTypename;
			int suffixLen = 0;
			if (v.Key.len == nameW.Length - 1 && nameW.Ends("W")) suffixLen = 1;
			else if (v.Key.len == nameW.Length - 2 && nameW.Ends("_W")) suffixLen = 2;
			else continue;
			name = v.Key.ToString(); if (!nameW.Starts(name)) continue;
			int what; //struct/interface/delegate
			var t = td.aliasOf as _Struct;
			if (t != null) what = t.isInterface ? 1 : 0; else if (td.aliasOf is _Callback) what = 2; else continue;
			if (suffixLen == 2) what |= 0x10000;
			__RemoveAW(ref R, name, what);
		}
		//perf.nw(); //800 1000 ms
		
		//remove other known A and old versions
		R.RxReplace(@"(?ms)^internal struct PROPSHEETPAGE(?!W_V4\b).+?^\}\r\n", "", out R);
		R.RxReplace(@"(?ms)^internal struct PROPSHEETHEADER(?!W_V2\b).+?^\}\r\n", "", out R);
		R.RxReplace(@"\bPROPSHEETPAGEW_V4\b", "PROPSHEETPAGE", out R);
		R.RxReplace(@"\bPROPSHEETHEADERW_V2\b", "PROPSHEETHEADER", out R);
		R.RxReplace(@"(?ms)^internal struct OPENFILENAME_NT4\b.+?^\}\r\n", "", out R, 1);
		
		//replace some types
		R = R.RxReplace(@"\bLPARAM\b", "nint");
		R = R.RxReplace(@"(?<!\bstruct )\bU?LARGE_INTEGER\b", "long");
		
		//in VARIANT, PROPVARIANT, _wireVARIANT members replace non-blittable types with IntPtr. Also replace some other types.
		R = R.RxReplace(@"(?ms)^internal struct (?:PROP|_wire)?VARIANT \{\R\K.+?\R\}", __VariantMembers);
		
		return R;
		
		//what: 0 struct, 1 interface, 2 delegate, flag 0x10000 _W
		static void __RemoveAW(ref string R, string name, int what) {
			string sW = "W", sA = "A";
			if ((what & 0x10000) != 0) { sW = "_W"; sA = "_A"; }
			what &= 0xff;
			
			if (0 != R.RxReplace($@"\b{name}{sW}\b", name, out R)) {
				//print.it($"<><c 0xff0000>{name}</c>");
				
				//remove STRUCTA
				
				g1:
				string rx = null;
				switch (what) {
				case 0: rx = $@"(?ms)^internal struct {name}{sA} .+?^\}}\r\n\r\n"; break;
				case 1: rx = $@"(?ms)^internal interface {name}{sA} .+?^\}}\r\n\r\n"; break;
				case 2: rx = $@"(?m)^internal delegate \w+\** {name}{sA}\(.+\r\n\r\n"; break;
				}
				if (R.RxMatch(rx, out var m)) {
					//find attributes (regex with attributes would be very slow)
					int i = m.Start - 3;
					while (0 == string.Compare(R, i, "]\r\n", 0, 3)) {
						//print.it("attr");
						i = R.LastIndexOf('\n', i) - 2;
					}
					i += 3;
					
					R = R.Remove(i, m.Start - i + m.Length);
					//print.it(what, name, R.RegexIs_($"\b{name}\b")); //all False
				} else { //2 in SDK have TYPE/TYPEW instead of TYPEA/TYPEW
					//print.it(what, name);
					if (sA != null) {
						sA = null;
						goto g1;
					}
				}
			} else {
				//print.it($"<><c 0xff>{name}</c>"); //0
				//print.it(R.Find($"internal struct {name}A "));
			}
		}
		
		static string __VariantMembers(RXMatch m) {
			var s = m.Value;
			//print.it(s);
			s = s.RxReplace(@"\[MarshalAs.+?\] ", "");
			s = s.RxReplace(@"\b(string|object|I[A-Z]\w+)\b", "IntPtr");
			s = s.RxReplace(@"\bDateTime\b", "double");
			s = s.RxReplace(@"\b(CY|FILETIME)\b", "long");
			s = s.RxReplace(@"\bVERSIONEDSTREAM\*", "IntPtr");
			//print.it(s);
			return s;
		}
	}
}


================================================
FILE: Scripts/old/Windows SDK to C#/@SDK converter/Util.cs
================================================
namespace SdkConverter;

unsafe partial class Converter {
	#region SYMBOL
	
	/// <summary>
	/// If x is _Typedef, replaces it with its deepest used type.
	/// Error if x is not a type (is _Keyword).
	/// Returns pointer level.
	/// </summary>
	/// <param name="iTok">Used only for error place.</param>
	int _Unalias(int iTok, ref _Symbol x) {
		int ptr = 0;
		var t = x as _Typedef;
		if (t != null) {
			x = t.aliasOf;
			ptr = t.ptr;
		} else if (x is _Keyword) _Err(iTok, "unexpected");
		return ptr;
	}
	
	/// <summary>
	/// This overload has isConst parameter. If x is const _Typedef sets the isConst variable = true, else isConst unchanged.
	/// </summary>
	int _Unalias(int iTok, ref _Symbol x, ref bool isConst) {
		int ptr = 0;
		var t = x as _Typedef;
		if (t != null) {
			x = t.aliasOf;
			ptr = t.ptr;
			if (t.isConst) isConst = true;
		} else if (x is _Keyword) _Err(iTok, "unexpected");
		return ptr;
	}
	
	/// <summary>
	/// Adds x to _ns[_nsCurrent].sym.
	/// Error if already exists, unless it is a forward decl of same type or a typedef of same type.
	/// </summary>
	/// <param name="iTokName">Token index of symbol name.</param>
	/// <param name="addToGlobal">Add to _ns[0].sym.</param>
	void _AddSymbol(int iTokName, _Symbol x, bool addToGlobal = false) {
		__AddSymbol(_tok[iTokName], x, iTokName, addToGlobal);
	}
	
	/// <summary>
	/// Adds x to _ns[_nsCurrent].sym.
	/// Error if already exists, unless it is a forward decl of same type or a typedef of same type.
	/// </summary>
	/// <param name="iTokError">Where to show error if need.</param>
	/// <param name="addToGlobal">Add to _ns[0].sym.</param>
	void _AddSymbol(string name, _Symbol x, int iTokError, bool addToGlobal = false) {
		//print.it(name);
		__AddSymbol(_TokenFromString(name), x, iTokError, addToGlobal);
	}
	
	/// <summary>
	/// Adds x to _ns[_nsCurrent].sym.
	/// Error if already exists, unless it is a forward decl of same type or a typedef of same type.
	/// </summary>
	/// <param name="iTokError">Where to show error if need.</param>
	/// <param name="addToGlobal">Add to _ns[0].sym.</param>
	void __AddSymbol(_Token name, _Symbol x, int iTokError, bool addToGlobal) {
		Debug.Assert(_IsCharIdentStart(*name.s));
		if (_keywords.ContainsKey(name)) _Err(iTokError, "name already exists (keyword)");
		int ns = addToGlobal ? 0 : _nsCurrent;
		//print.it(name);
		try {
			_ns[ns].sym.Add(name, x);
		}
		catch (ArgumentException) {
			_Symbol p = _ns[ns].sym[name];
			g1:
			if (x.GetType() != p.GetType()) {
				if (((p is _Typedef) && 0 == _Unalias(iTokError, ref p)) || ((x is _Typedef) && 0 == _Unalias(iTokError, ref x))) goto g1;
				_Err(iTokError, "name already exists");
			}
			if (!x.forwardDecl) {
				if (!(x is _Typedef) && !(x is _Callback)) _Err(iTokError, "already defined");
				//info: C++ allows multiple identical typedef. We don't check identity, it is quite difficult, assume the header file is without such errors.
				//info: before adding struct or enum, the caller checks whether it is forward-declaraed. If so, overwrites the forward-declared object and does not call this function, because cannot change object associated with that name because forward-declared object pointer can be used in a typedef.
			}
		}
	}
	
	/// <summary>
	/// Finds symbol of token iTok in _keywords, _ns[_nsCurrent].sym and optionally in _ns[nsCurrent-1 ... 0].sym.
	/// Error if not found or the token is not an identifier.
	/// </summary>
	_Symbol _FindSymbol(int iTok, bool includingAncestorNamespaces) {
		_Symbol x;
		if (!_TryFindSymbol(iTok, out x, includingAncestorNamespaces)) _Err(iTok, "unknown identifier");
		return x;
	}
	
	/// <summary>
	/// Finds symbol of token iTok in _keywords, _ns[_nsCurrent].sym and optionally in _ns[nsCurrent-1 ... 0].sym.
	/// Error if the token is not an identifier.
	/// </summary>
	bool _TryFindSymbol(int iTok, out _Symbol x, bool includingAncestorNamespaces) {
		_Token token = _tok[iTok];
		if (_keywords.TryGetValue(token, out x)) return true;
		for (int i = _nsCurrent; i >= 0; i--) {
			if (_ns[i].sym.TryGetValue(token, out x)) return true;
			if (!includingAncestorNamespaces) break;
		}
		if (!_TokIsIdent(iTok)) _Err(iTok, "unexpected");
		return false;
	}
	
#if DEBUG
	/// <summary>
	/// Finds symbol by string name.
	/// </summary>
	bool _TryFindSymbol(string name, out _Symbol x, bool includingAncestorNamespaces) {
		fixed (char* n = name) {
			_Token token = new _Token(n, name.Length);
			if (_keywords.TryGetValue(token, out x)) return true;
			for (int i = _nsCurrent; i >= 0; i--) {
				if (_ns[i].sym.TryGetValue(token, out x)) return true;
				if (!includingAncestorNamespaces) break;
			}
		}
		return false;
	}
#endif
	
	/// <summary>
	/// Finds symbol of T type of token iTok in _keywords, _ns[_nsCurrent].sym and optionally in _ns[nsCurrent-1 ... 0].sym.
	/// Error if the token is not an identifier.
	/// </summary>
	bool _TryFindSymbolAs<T>(int iTok, out T x, bool includingAncestorNamespaces) where T : _Symbol {
		x = null;
		_Symbol t;
		if (!_TryFindSymbol(iTok, out t, includingAncestorNamespaces)) return false;
		x = t as T;
		return x != null;
	}
	
	/// <summary>
	/// Finds symbol of token iTok everywhere.
	/// Error if not found or not a keyword or the token is not an identifier.
	/// </summary>
	/// <param name="kwType">If not _KeywordT.Any, error if the keyword is not of this type.</param>
	_Keyword _FindKeyword(int iTok, _KeywordT kwType = _KeywordT.Any) {
		_Symbol x = _FindSymbol(iTok, true);
		var k = x as _Keyword;
		if (k == null) _Err(iTok, "unexpected");
		if (kwType != _KeywordT.Any && k.kwType != kwType) _Err(iTok, "unexpected");
		return k;
	}
	
	/// <summary>
	/// Finds symbol of token iTok in _keywords, _ns[_nsCurrent].sym and optionally in _ns[nsCurrent-1 ... 0].sym.
	/// Error if not found or not a type (struct, enum etc) or the token is not an identifier.
	/// </summary>
	_Symbol _FindType(int iTok, bool includingAncestorNamespaces) {
		_Symbol x = _FindSymbol(iTok, includingAncestorNamespaces);
		if (x is _Keyword) _Err(iTok, "unexpected");
		return x;
	}
	
	/// <summary>
	/// Returns true if symbol of token iTok exists in _keywords, _ns[_nsCurrent].sym and optionally in _ns[nsCurrent-1 ... 0].sym.
	/// Error if the token is not an identifier.
	/// </summary>
	bool _SymbolExists(int iTok, bool includingAncestorNamespaces) {
		_Symbol t;
		return _TryFindSymbol(iTok, out t, includingAncestorNamespaces);
	}
	
	#endregion
	
	#region TOKEN
	
	/// <summary>
	/// Returns _tok[i].s.
	/// </summary>
	char* T(int i) { return _tok[i].s; }
	
	/// <summary>
	/// Returns true if token iTok string is equal to s.
	/// </summary>
	bool _TokIs(int iTok, string s) {
		return _tok[iTok].Equals(s);
	}
	
	/// <summary>
	/// Returns 1-based index of matching string at token iTok.
	/// </summary>
	int _TokIs(int iTok, params string[] a) {
		for (int i = 0; i < a.Length; i++) if (_tok[iTok].Equals(a[i])) return i + 1;
		return 0;
	}
	
	/// <summary>
	/// Returns true if token iTok string starts with s.
	/// </summary>
	bool _TokStarts(int iTok, string s) {
		return _tok[iTok].StartsWith(s);
	}
	
	/// <summary>
	/// Returns true if token iTok is an identifier.
	/// </summary>
	bool _TokIsIdent(int iTok) {
		return _IsCharIdentStart(*T(iTok));
	}
	
	/// <summary>
	/// Returns true if token iTok is a number.
	/// </summary>
	bool _TokIsNumber(int iTok) {
		return _IsCharDigit(*T(iTok));
	}
	
	/// <summary>
	/// Returns true if token iTok is an identifier or number.
	/// </summary>
	bool _TokIsIdentOrNumber(int iTok) {
		return _IsCharIdent(*T(iTok));
	}
	
	/// <summary>
	/// Returns true if token iTok is character c.
	/// </summary>
	bool _TokIsChar(int iTok, char c) {
		return *T(iTok) == c;
	}
	
	/// <summary>
	/// Returns true if token iTok is character c1 or c2.
	/// </summary>
	bool _TokIsChar(int iTok, char c1, char c2) {
		char c = *T(iTok);
		return c == c1 || c == c2;
	}
	
	/// <summary>
	/// Returns true if token iTok is a character in chars.
	/// </summary>
	bool _TokIsChar(int iTok, string chars) {
		char c = *T(iTok);
		for (int i = 0; i < chars.Length; i++) if (c == chars[i]) return true;
		return false;
	}
	
	/// <summary>
	/// Converts token iTok from char* to string.
	/// </summary>
	string _TokToString(int iTok) {
		return _tok[iTok].ToString();
	}
	
	/// <summary>
	/// Converts raw tokens iTokFrom to (not including) iTokTo from char* to string.
	/// </summary>
	string _TokToString(int iTokFrom, int iTokTo) {
		iTokTo--;
		char* s = T(iTokFrom), se = T(iTokTo) + _tok[iTokTo].len;
		return new string(s, 0, (int)(se - s));
	}
	
	/// <summary>
	/// Returns true, if at token iTokAfterTypeNameAndPtr is '([callConv]*[funcTypeOrVariable])('.
	/// </summary>
	bool _DetectIsFuncType(int iTokAfterTypeNameAndPtr) {
		int i = iTokAfterTypeNameAndPtr;
		if (!_TokIsChar(i, '(')) return false;
		if (_TokIsIdent(++i)) i++; //eg __stdcall
		if (!_TokIsChar(i, '*')) return false;
		if (_TokIsIdent(++i)) i++; //func type name or optional parameter/member name
		if (!_TokIsChar(i, ')')) return false;
		return _TokIsChar(i + 1, '(');
	}
	
	/// <summary>
	/// Skips code block enclosed in {}, (), [] or ˂˃.
	/// i must be token index at the starting { etc. Returns token index at } etc.
	/// Inside the block:
	///		Skips nested enclosed blocks of the same type.
	///		Ignores nested enclosed blocks of other types, eg (), [] etc blocks when this block is {}.
	/// Error if i character is not {([˂.
	/// Error if the ending })]˃ is missing.
	/// </summary>
	int _SkipEnclosed(int i) {
		char cStart = *T(i);
		if (!(cStart == '{' || cStart == '(' || cStart == '[' || cStart == '<')) _Err(i, "unexpected");
		
		char cEnd = cStart; cEnd++; if (cEnd != ')') cEnd++; //')' is '(' + 1, others + 2
		int level = 1;
		
		for (++i; ; i++) {
			char c = *T(i);
			if (c == cStart) {
				level++;
			} else if (c == cEnd) {
				level--;
				if (level == 0) return i;
			} else if (c == 0) {
				_Err(i, $"missing {cEnd}");
			}
		}
	}
	
	/// <summary>
	/// Skips code block enclosed in {}, (), [] or ˂˃.
	/// _i must be at the starting { etc. Finally it will be at } etc.
	/// Inside the block:
	///		Skips nested enclosed blocks of the same type.
	///		Ignores nested enclosed blocks of other types, eg (), [] etc blocks when this block is {}.
	/// Error if _i character is not {([˂.
	/// Error if the ending })]˃ is missing.
	/// </summary>
	void _SkipEnclosed() {
		_i = _SkipEnclosed(_i);
	}
	
	_Token _TokenFromString(string s) {
		char* p = (char*)Marshal.StringToHGlobalUni(s); //never mind: finally release
		return new _Token(p, s.Length);
	}
	
	#endregion
	
	#region STRING
	
	//Some of these currently are not used.
	
	/// <summary>
	/// Gets line length.
	/// Scans string until first '\r', '\n' or '\0'.
	/// </summary>
	static int _LenLine(char* s) {
		char* s0 = s;
		while (!_IsCharRN0(*s)) s++;
		return (int)(s - s0);
	}
	
	/// <summary>
	/// Gets identifier length.
	/// Returns 0 if s does not start with an identifier.
	/// </summary>
	static int _LenIdent(char* s) {
		if (!_IsCharIdentStart(*s)) return 0;
		char* s0 = s++;
		while (_IsCharIdent(*s)) s++;
		return (int)(s - s0);
	}
	
	/// <summary>
	/// Returns true if s starts with word and is not followed by a C++ identifier character.
	/// </summary>
	static bool _IsWord(char* s, string word) {
		int i = 0;
		for (; i < word.Length; i++) if (s[i] != word[i]) return false;
		return !_IsCharIdent(s[i]);
	}
	
	/// <summary>
	/// Returns true if s starts with prefix.
	/// </summary>
	static bool _IsPrefix(char* s, string prefix) {
		for (int i = 0; i < prefix.Length; i++) if (s[i] != prefix[i]) return false;
		return true;
	}
	
	/// <summary>
	/// Finds ident as whole word.
	/// Returns index or -1.
	/// </summary>
	int _FindIdentifierInString(string s, string ident) {
		int len = ident.Length;
		for (int i = 0; (i = s.Find(ident, i)) >= 0; i += len) {
			if (i > 0 && _IsCharIdent(s[i - 1])) continue;
			if (i < s.Length - len && _IsCharIdent(s[i + len])) continue;
			return i;
		}
		return -1;
	}
	
	#endregion
	
	#region CHARACTER
	/// <summary>
	/// Character type table for _IsCharIdent etc.
	/// </summary>
	static readonly byte[] _ctt = new byte[0x1000];
	
	static void _InitTables() {
		_ctt['_'] = 1; _ctt['$'] = 1;
		for (int i = 'a'; i <= 'z'; i++) _ctt[i] = 1;
		for (int i = 'A'; i <= 'Z'; i++) _ctt[i] = 1;
		for (int i = '0'; i <= '9'; i++) _ctt[i] = 2;
		_ctt[' '] = _ctt['\t'] = _ctt['\v'] = _ctt['\f'] = 4;
		_ctt['\r'] = _ctt['\n'] = 8;
		_ctt['!'] = _ctt['%'] = _ctt['&'] /*= _ctt['('] = _ctt[')']*/ = _ctt['*'] = _ctt['+'] /*= _ctt[',']*/ = _ctt['-'] = _ctt['.'] = _ctt['/']
			= _ctt[':'] = _ctt['<'] = _ctt['='] = _ctt['>'] = _ctt['?'] /*= _ctt['['] = _ctt[']']*/ = _ctt['^'] = _ctt['|'] = _ctt['~']
			/*= _ctt['{'] = _ctt['}']*/ = 16;
		//_ctt['('] = _ctt[')'] = _ctt['{'] = _ctt['}'] = _ctt['['] = _ctt[']'] = _ctt[';'] = _ctt['\''] = _ctt[':'] = _ctt['"'] = _ctt[''] = _ctt[''] = _ctt[''] = _ctt[''] = _ctt[''] = _ctt[''] = _ctt[''] = _ctt[''] = _ctt[''] = _ctt[''] = _ctt[''] = _ctt[''] = 32;
		for (int i = 'a'; i <= 'f'; i++) _ctt[i] |= 64;
		for (int i = 'A'; i <= 'F'; i++) _ctt[i] |= 64;
		_ctt[0] = 128;
		//others 0
	}
	
	/// <summary>
	/// Returns true if c is a C++ identifier character: alphanumeric, '_', '$'.
	/// </summary>
	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	static bool _IsCharIdent(char c) {
		return (_ctt[c] & 3) != 0;
	}
	
	/// <summary>
	/// Returns true if c is a C++ identifier start character: alpha, '_', '$'.
	/// </summary>
	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	static bool _IsCharIdentStart(char c) {
		return (_ctt[c] & 1) != 0;
	}
	
	/// <summary>
	/// Returns true if c is a number digit '0' to '9'.
	/// </summary>
	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	static bool _IsCharDigit(char c) {
		return (_ctt[c] & 2) != 0;
	}
	
	/// <summary>
	/// Returns true if c is a number digit '0' to '9'.
	/// </summary>
	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	static bool _IsCharHexDigit(char c) {
		return (_ctt[c] & (2 | 64)) != 0;
	}
	
	/// <summary>
	/// Returns true if c is a C++ space character, including new line characters: ' ', '\t', '\r', '\n', '\v', '\f'.
	/// </summary>
	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	static bool _IsCharSpaceOrRN(char c) {
		return (_ctt[c] & 12) != 0;
	}
	
	/// <summary>
	/// Returns true if c is a C++ space character, except new line characters: ' ', '\t', '\v', '\f'.
	/// </summary>
	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	static bool _IsCharSpaceNoRN(char c) {
		return _ctt[c] == 4;
	}
	
	/// <summary>
	/// Returns true if c is a new line character: '\r', '\n'.
	/// </summary>
	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	static bool _IsCharRN(char c) {
		return _ctt[c] == 8;
	}
	
	/// <summary>
	/// Returns true if c is a new line character or end of string: '\r', '\n', '\0'.
	/// </summary>
	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	static bool _IsCharRN0(char c) {
		return (_ctt[c] & (8 | 128)) != 0;
	}
	
	/// <summary>
	/// Returns true if c is a C++ operator character, not including ,[](){}.
	/// </summary>
	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	static bool _IsCharOperator(char c) {
		return (_ctt[c] & 16) != 0;
	}
	
	#endregion
}

#region ERROR

unsafe partial class Converter {
	/// <summary>
	/// Gets offset of token iTok in _src.
	/// </summary>
	int _Pos(int iTok) { return iTok < _tok.Count ? (int)(T(iTok) - _s0) : 0; }
	
	/// <summary>
	/// Throws exception indicating error at token iTok position.
	/// </summary>
	void _Err(int iTok, string errorText, [CallerMemberName] string m_ = null, [CallerFilePath] string f_ = null, [CallerLineNumber] int l_ = 0) {
		__ThrowConverterException(_Pos(iTok), errorText, m_, f_, l_);
	}
	
	/// <summary>
	/// Throws exception indicating error at s position (s must be in _src).
	/// </summary>
	void _Err(char* s, string errorText, [CallerMemberName] string m_ = null, [CallerFilePath] string f_ = null, [CallerLineNumber] int l_ = 0) {
		__ThrowConverterException((int)(s - _s0), errorText, m_, f_, l_);
	}
	
	void __ThrowConverterException(int pos, string errorText, string callerName, string callerFile, int callerLine) {
		throw new ConverterException(
			$"{errorText}\r\n\tin <open {callerFile}|{callerLine}>{callerName}<>"
			, pos);
	}
	
	void _OnCatchException(Exception e) {
		//print.it(e);
		int i = e is ConverterException ce ? ce.Offset : _Pos(_i);
		ScriptEditor.Open(_cppFile, offset: i);
	}
}

class ConverterException : Exception {
	public int Offset { get; private set; }
	
	public ConverterException(string s, int offset) : base(s) {
		Offset = offset;
#if TEST_SMALL
			//Offset += 3; //VS saves some files with BOM, and QM2 loads with that BOM, but we get file data without BOM
#endif
	}
}

#endregion

#region debug

unsafe partial class Converter {
	string _DebugGetLine(int iTok) {
		if (iTok == 0) return null;
		char* s = T(iTok), se = s;
		while (s[-1] != '\n') s--;
		while (*se != '\r' && *se != '\n') se++;
		return new string(s, 0, (int)(se - s));
	}
}

#endregion


================================================
FILE: Scripts/old/Windows SDK to C#/Readme.txt
================================================
Note: now the created db file is not used by LA directly. It is used by the new WinApiConverter to get declarations that are missing/incorrect in winmd.

1. Once per SDK version: run scripts "SDK get dll names" and "SDK get GUID". They create some files used by the converter. Don't need to run again after adding/removing header files.
2. Run script "SDK preprocessor". It creates two files for the converter project: Api-preprocessed-64.cpp, Api-preprocessed-32.cpp.
3. Run the converter project. It creates two files: Api-64.cs, Api-32.cs.
4. Run script "SDK append 32-bit diff". It creates final .cs file Api.cs.
5. Run script "SDK create database".

External tools:
1. dumpbin.exe from Visual Studio. Used by scripts "SDK get dll names" and "SDK get GUID".
2. clang.exe from LLVM (setup file LLVM-3.9.1-win64.exe). Used by script "SDK preprocessor".


================================================
FILE: Scripts/old/Windows SDK to C#/Scripts/SDK append 32-bit diff.cs
================================================
/// Compares converter output files (64-bit and 32-bit) and saves in final .cs file with added differences.

print.clear();

string s64 = File.ReadAllText(@"C:\code\au\Other\Api\Api-64.cs");
string s32 = File.ReadAllText(@"C:\code\au\Other\Api\Api-32.cs");

var d = new Dictionary<string, string>();
var d32 = new HashSet<string>();
var b = new StringBuilder();

_ProcessCsFile(false, s64);
_ProcessCsFile(true, s32);

var diff = b.ToString();
diff = diff.RxReplace(@"\b(" + string.Join('|', d32) + @")\b", "$0__32");

string commentsEtc = """
 // 32-BIT
 // Declarations that are different (or exist only) when the process is 32-bit.

""";
s64 = s64[..s64.LastIndexOf('}')] + commentsEtc + diff + "\r\n}\r\n";

filesystem.saveText(@"C:\code\au\Other\Api\Api.cs", s64);
print.it($"DONE, {d.Count} declarations, size = {s64.Length / 1024} KB, API32 size = {diff.Length / 1024} KB");


void _ProcessCsFile(bool is32bit, string s) {
	int iKind = 0;
	string sType = _GetOfKind(@"(?ms)^// TYPE\R(.+?)^\R//");
	string sFunc = _GetOfKind(@"(?ms)^// FUNCTION\R(.+?)^\R//");
	string sInterf = _GetOfKind(@"(?ms)^// INTERFACE\R(.+?)^\R//");
	string sVar = _GetOfKind(@"(?ms)^// VARIABLE\R(.+?)^\R//");
	string sConst = _GetOfKind(@"(?ms)^// CONSTANT\R(.+?)^\R//");
	string sOther = _GetOfKind(@"(?ms)^// CANNOT CONVERT\R(.+?)^\R\R\}");
	
	string _GetOfKind(string rx) {
		if (!s.RxMatch(rx, 1, out RXGroup g, 0, iKind..)) throw new AuException();
		iKind = g.End;
		return g.Value;
	}
	
	regexp rxType = new(@"(?ms)^\r\n(?:\[[^\r\n]+\r\n)*internal (?:struct|enum|interface|class) (\w+)[^\r\n\{]+\{(?:\}$|.+?^\})"),
		rxFunc = new(@"(?m)^\r\n(?:\[[^\r\n]+\r\n)*internal (?:static extern|delegate) \w+\** (\w+)\(.+;$"),
		rxVar = new(@"(?m)^internal static \w+ (\w+) =.+;$"),
		rxConst = new(@"(?m)^internal (?:const|readonly) \w+ (\w+) =.+;$");
	
	//TYPE
	if (!rxType.FindAll(sType, out var a)) throw new AuException(); //struct/enum
	_AddToDict(is32bit, "struct/enum");
	if (!rxFunc.FindAll(sType, out a)) throw new AuException(); //delegate
	_AddToDict(is32bit, "delegate");
	//FUNCTION
	if (!rxFunc.FindAll(sFunc, out a)) throw new AuException();
	_AddToDict(is32bit, "function");
	//INTERFACE
	if (!rxType.FindAll(sInterf, out a)) throw new AuException();
	_AddToDict(is32bit, "interface");
	//VARIABLE
	if (!rxVar.FindAll(sVar, out a)) throw new AuException();
	_AddToDict(is32bit, "variable");
	if (b.Length > 0) b.AppendLine("\r\n");
	//CONST
	if (!rxConst.FindAll(sConst, out a)) throw new AuException();
	_AddToDict(is32bit, "const");
	if (b.Length > 0) b.AppendLine();
	//CANNOT CONVERT
	if (!rxConst.FindAll(sOther, out a)) throw new AuException();
	_AddToDict(is32bit, "other");
	
	
	void _AddToDict(bool is32bit, string debugType) {
		foreach (var m in a) {
			string name = m[1].Value, value = m.Value;
			if (!is32bit) {
				//print.it(debugType, name);
				if (!d.TryAdd(name, value)) print.it($"<><c red>duplicate: {name} ({debugType}, 64-bit)<>"); //0 is SDK
			} else {
				if (d.TryGetValue(name, out var v) && v == value) continue;
				
				print.it($"<>--------------------------------\r\n64-bit:  {v}\r\n<c blue>32-bit:  {value}<>");
				
				b.AppendLine(value);
				if (!d32.Add(name)) print.it($"<><c red>duplicate: {name} ({debugType}, 32-bit)<>"); //0 is SDK
			}
		}
	}
}


================================================
FILE: Scripts/old/Windows SDK to C#/Scripts/SDK create database.cs
================================================
/*/ testInternal Au,Au.Editor; r Au.Editor.dll; /*/

//string dbFile = folders.ThisAppBS + @"winapi.db";
string dbFile = @"C:\code\au\Other\Api\winapi.db";
filesystem.delete(dbFile);

string s = File.ReadAllText(@"C:\code\au\Other\Api\Api.cs");

using var d = new sqlite(dbFile);
using var trans = d.Transaction();
d.Execute("CREATE TABLE api (name TEXT, code TEXT, kind INTEGER)"); //note: no PRIMARY KEY. Don't need index.
using var statInsert = d.Statement("INSERT INTO api VALUES (?, ?, ?)");

string rxType = @"(?ms)^(?:\[\N+\R)*internal (struct|enum|interface|class) (\w+)[^\r\n\{]+\{(?: *\}$|.+?^\})";
string rxFunc = @"(?m)^(?:\[\N+\R)*internal (static extern|delegate) \w+\** (\w+)\(.+;$";
string rxVarConst = @"(?m)^internal (const|readonly|static) \w+ (\w+) =.+;$";

foreach (var m in s.RxFindAll(rxType)) _Add(m);
foreach (var m in s.RxFindAll(rxFunc)) _Add(m);
foreach (var m in s.RxFindAll(rxVarConst)) _Add(m);

void _Add(RXMatch m) {
	statInsert.Bind(1, m[2].Value);
	var code = m.Value;
	Debug.Assert(!code.Contains("\r\n\r")); //if contains newlines, the regex is bad, spans multiple definitions
	statInsert.Bind(2, code);
	
	CiItemKind kind = m[1].Value switch {
		"struct" => CiItemKind.Structure,
		"enum" => CiItemKind.Enum,
		"interface" => CiItemKind.Interface,
		"class" => CiItemKind.Class,
		"static extern" => CiItemKind.Method,
		"delegate" => CiItemKind.Delegate,
		"const" => CiItemKind.Constant,
		"static" or "readonly" => CiItemKind.Field,
		_ => CiItemKind.None
	};
	Debug_.PrintIf(kind == CiItemKind.None, m[1].Value);
	statInsert.Bind(3, (int)kind);
	
	statInsert.Step();
	statInsert.Reset();
}

trans.Commit();
d.Execute("VACUUM");

print.it("DONE");


================================================
FILE: Scripts/old/Windows SDK to C#/Scripts/SDK headers.h
================================================
//we'll remove everything at the start of the intermediate file (added by clang) until this
#define AU

//#define TEST_PREPROCESSING
#ifdef TEST_PREPROCESSING

/*
*/

#endif


//#define __cplusplus 201103L //clang defines this
#define _MSC_VER 1900 //VS2015
#define _MSC_FULL_VER 190023026
#define _MSC_EXTENSIONS 1

#define _UNICODE 1
#define UNICODE 1
#define _WCHAR_T_DEFINED 1
#define _MT 1
#define _DLL 1
#define _WIN32 1 //defined for 32 and 64

#ifdef USE64BIT
#define _WIN64 1
#define _M_AMD64 100
#define _M_X64 100
#else
#define _M_IX86 600
#endif
#define _INTEGRAL_MAX_BITS 64 //need if 32

#define WINVER 0x0A00 //Win10
#define _WIN32_WINNT 0x0A00
#define _WIN32_IE 0x0B00 //IE11

//add __int128 struct, because C# does not have a matching type
struct __int128 { float a, b, c, d; };
struct __int128d { float a, b, c, d; };
struct __int128i { float a, b, c, d; };

//prevent adding XML interfaces, but need some for parameters
#define __msxml_h__
#define __msxml2_h__
#define __msxml6_h__
typedef IntPtr IXMLElement;
typedef IntPtr IXMLDOMDocument;

//prevent adding D3D9 interfaces
#define _D3D9_H_
typedef IntPtr IDirect3DDevice9;

//add some that are in headers that we remove
#define size_t LPARAM
#define intptr_t LPARAM
#define uintptr_t LPARAM
#define time_t LPARAM
typedef void* va_list;
typedef struct _iobuf { char *_ptr; int _cnt; char *_base; int _flag; int _file; int _charbuf; int _bufsiz; char *_tmpfname; } FILE;

#define WIN32_LEAN_AND_MEAN //don't include come rarely used headers in windows.h
#define USE_COM_CONTEXT_DEF //IContext etc

#include <windows.h>

#include <regstr.h> //registry strings
#include <ole2.h> //OLE. Includes objbase.h, oleauto.h, urlmon.h, ...
#include <commctrl.h> //common controls
#include <shlobj.h> //shell
#include <shellapi.h> //shell
#include <shlwapi.h> //misc string functions etc
#include <olectl.h> //some OLE API
#include <oleacc.h> //MSAA accessible objects
#include <UIAutomation.h> //UI Automation
#include <mmsystem.h> //multimedia etc
#include <tlhelp32.h> //process info etc
#include <psapi.h> //process info etc
#include <wtsapi32.h> //user sessions etc
#include <winperf.h> //something used with PDH
#include <pdh.h> //performance counters //future: test System.Diagnostics.PerformanceCounter
#include <uxtheme.h> //visual styles
#include <vsstyle.h> //visual styles
#include <dwmapi.h> //DWM
#include <htmlhelp.h> //HTML help
#include <winioctl.h> //file IO low-level
#include <aclapi.h> //security //future: test System.Security.AccessControl etc
#include <sddl.h> //security strings
#include <taskschd.h> //Task Scheduler
#include <ShellScalingAPI.h> //high DPI
#include <appmodel.h> //Windows Store apps
#include <winternl.h> //Windows semi-internal API, eg NtX, RtlX
#include <iepmapi.h> //IE protected mode
#include <userenv.h> //user profiles, CreateEnvironmentBlock
#include <netlistmgr.h> //network list
#include <winnetwk.h> //networking
#include <propkey.h> //property key GUIDs
#include <cderr.h> //commdlg errors
#include <commdlg.h> //common dialogs
#include <dde.h> //DDE
#include <ddeml.h> //DDE
#define _WINSOCK_DEPRECATED_NO_WARNINGS
#include <winsock2.h> //sockets (TCP etc) //future: test System.Net.Sockets
#include <nspapi.h> //MS extensions for sockets
#include <richedit.h> //rich edit control
#include <usp10.h> //text drawing low-level
#include <dbt.h> //const/struct for WM_DEVICECHANGE
#include <ktmw32.h> //transactions
#define _MSI_NO_CRYPTO //don't include cryptography
#include <msi.h> //installer. MsiGetShortcutTarget, MsiGetComponentPath.
#include <commoncontrols.h> //IImageList
#include <powrprof.h> //power profiles, SetSuspendState
#define _LMAUDIT_ //don't include lmaudit.h, has name conflicts
#include <lm.h> //LAN management, NetServerEnum
#include <Wlanapi.h> //WiFi
#include <adhoc.h> //WiFi
#include <Pla.h> //performance logs and alerts
#include <werapi.h> //error reporting
#include <physicalmonitorenumerationapi.h>
#include <propvarutil.h>

//core audio API
#include <Audioclient.h>
#include <Audiopolicy.h>
#include <Mmdeviceapi.h>
#include <Devicetopology.h>
#include <Endpointvolume.h>

#if 0
//temporary. Used in the library, but don't need to include in the public database.
//#include <sapi.h> //note: will be several errors when converting. Edit the preprocessed files in several places.
////#include <sphelper.h> //C++ code, impossible to convert

//these are little tested and probably not useful
#include <iphlpapi.h> //IP helper, eg list network adapters. Use System.Net.NetworkInformation namespace.
#include <icmpapi.h> //ICMP, eg to implement a Ping(). Use System.Net.NetworkInformation namespace.
#include <GL/gl.h> //openGL
#include <GL/glu.h> //openGL util

//these are never tested but seem interesting
#include <RestartManager.h> //restart manager
#include <Clfsw32.h> //common log file system. .NET has something similar in System.Diagnostics.
#include <Clfsmgmtw32.h> //common log file management. .NET has something similar in System.Diagnostics.
#include <WinEvt.h> //event log. .NET has something similar in System.Diagnostics.
#include <Winsxs.h> //several interfaces for side-by-side assembly management

//these probably should not be added
#include <shldisp.h> //shell IDispatch interfaces
#include <scrnsave.h> //screen saver
#include <dbghelp.h> //debug help library
#include <imagehlp.h> //many the same as dbghelp.h. Includes wintrust.h -> wincrypt.h which is not welcome.
#include <setupapi.h> //obsolete
#include <mapi.h> //only for MS Outlook. Can instead use Outlook COM.
#include <snmp.h> //can instead download a SNMP .NET library
#include Sspi.h //authentication. Includes Security.h. Use .NET classes.
//these would be included if no WIN32_LEAN_AND_MEAN
#include <winefs.h> //encrypted file system. .NET can encrypt/decrypt a file, but maybe this also can be useful.
#include <winspool.h> //printer API. Big. Use System.Drawing.Printing namespace. See also System.Printing namespace.
#include <wincrypt.h> //cryptography. Large. Use System.Security.Cryptography namespace.
#include <Esent.h> //Windows native database API. Use ESENT.NET instead; tested, slooow, better use SQLite.
#include <wininet.h> //internet. We can instead use System.Net.Http namespace and System.Net.FtpWebRequest classes, but maybe this still can be useful.
#include <uiribbon.h>
//#include <mscoree.h> //unmanaged .NET API. Somehow this file disappeared.
#endif


================================================
FILE: Scripts/old/Windows SDK to C#/Scripts/SDK preprocessor.cs
================================================
/// Preprocesses Windows SDK headers.
/// The output files then can be used by the converter project.
/// Temporary and output files are in folder "C:\code\au\Other\Api". Links to some of them added in this folder.
/// Uses Clang compiler from LLVM 3.9.1 64-bit.

print.clear();

string clangPath = @"C:\Program Files\LLVM\bin\clang.exe";
string SDK_Include = @"C:\Program Files (x86)\Windows Kits\10\Include\10.0.26100.0\um";
string Shared_Include = @"C:\Program Files (x86)\Windows Kits\10\Include\10.0.26100.0\shared";
//string CRT_Include = @"C:\Program Files (x86)\Windows Kits\10\Include\10.0.26100.0\ucrt";
//string VS_CRT_Include=@"C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\include" //vcruntime.h etc missing in SDK

_Preprocess(true, @"C:\code\au\Other\Api\Api-preprocessed-64.cpp");
_Preprocess(false, @"C:\code\au\Other\Api\Api-preprocessed-32.cpp");


// Preprocesses C++ headers from file "SDK headers.h" and saves in file outFile.
void _Preprocess(bool is64bit, string outFile) {
	//temp files
	string cppFile = @"C:\code\au\Other\Api\Api-headers.cpp";//saved macro "SDK headers" text
	string intermFile = @"C:\code\au\Other\Api\Api-interm.cpp";//first clang invocation output
	
	//save "SDK headers.h" text to cppFile, with some modifications, etc
	_CreateCppFile(cppFile, is64bit);
	
	//run clang to preprocess cppFile
	string cl = $"""
-E -dD -undef
-fms-compatibility -fms-extensions
-fdeclspec -fdollars-in-identifiers
-nobuiltininc -nostdinc++
-Wno-extra-tokens -Wno-comment -Wno-nonportable-include-path -Wno-expansion-to-defined
-I "{SDK_Include}" -I "{Shared_Include}"
-o "{intermFile}"
"{cppFile}"
""";
	cl = cl.Replace("\r\n", " ");
	if (0 != run.console(o => print.it(o), clangPath, cl)) throw new AuException();
	
	//In old version was used this. Now errors. Now no errors without the CRT. When compared output, everything is almost the same, with few non-important changes.
	//-I "{SDK_Include}" -I "{CRT_Include}" -idirafter "{VS_CRT_Include}"
	
	/* some clang command line options
 -emit-ast
 -fdiagnostics-parseable-fixits
                          Print fix-its in machine parseable form
 -fdiagnostics-print-source-range-info
                          Print source range spans in numeric form
 -fdiagnostics-show-note-include-stack
                          Display include stacks for diagnostic notes
  -femit-all-decls        Emit all declarations, even if unused
  -ffreestanding          Assert that the compilation takes place in a freestanding environment
  -fgnu-keywords          Allow GNU-extension keywords regardless of language standard
  -fgnu89-inline          Use the gnu89 inline semantics
  -fms-compatibility-version=<value>
                          Dot-separated value representing the Microsoft compiler version number to report in _MSC_VER (0 = don't define it (default))
  -fmsc-version=<value>   Microsoft compiler version number to report in _MSC_VER (0 = don't define it (default))
  -fno-merge-all-constants
                          Disallow merging of constants
  -fno-show-column        Do not include column number on diagnostics
  -fno-show-source-location
                          Do not include source location information with diagnostics
  -fno-signed-char        Char is unsigned
  -fpack-struct=<value>   Specify the default maximum struct packing alignment
  -H                      Show header includes and nesting depth
  -idirafter <value>      Add directory to AFTER include search path
  -nobuiltininc           Disable builtin #include directories
  -nostdinc++             Disable standard #include directories for the C++ standard library
  -print-search-dirs      Print the paths used for finding libraries and programs
  -P                      Disable linemarker output in -E mode
  -Qunused-arguments      Don't emit warning for unused driver arguments
  -std=<value>            Language standard to compile for
  -stdlib=<value>         C++ standard library to use
  -undef                  undef all system defines
  -W<warning>             Enable the specified warning
  -w                      Suppress all warnings
  -x <language>           Treat subsequent input files as having type <language>
	*/
	
	string s = File.ReadAllText(intermFile);
	
	/* tested:
 clang removes space/tab before and after # in directives.
 clang joins lines ending with \.
 clang uses \n for newlines, except in raw strings.
 clang replaces '#pragma  pack' to '#pragma pack', but does not change spaces after it.
	*/
	
	//remove some #define etc that are added by clang or added here
	if (0 == s.RxReplace(@"(?s)^.+?\R#define AU *\R", "", out s, 1)) throw new AuException();
	
	//remove SAL, CRT etc (use '# n "include file"' added by clang when not using -P)
	s = s.RxReplace("""(?mi)(?>^# \d+ ".+[/\\](?:specstrings\w*|\w*sal|\w+specs|winapifamily|winpackagefamily|stralign|ucrt\\[^\."]+|VC\\\\include\\\\(?!excpt\.h)[^\."]+)\.h")(?s).+?(?=^# \d)""", "");
	
	//remove '# n "include file"' etc that clang adds when not using -P
	if (0 == s.RxReplace(@"(?m)^# \d.+\R", "", out s)) throw new AuException();
	
	//escape raw strings
	s = s.RxReplace(@"R""(.*)\(((?s).*?)\)\1""", m => {
		var s = m[2].Value;
		print.it($"<>info: raw string. Please review because extracting raw strings is unreliable:\r\n<c orange>{s}<>");
		return s.Escape(quote: true);
	});
	
	//remove empty lines to make easier to debug-read
	if (0 == s.RxReplace(@"(?m)^\s*\R", "", out s)) throw new AuException();
	
	//make #pragma pack easier to parse
	if (0 == s.RxReplace(@"(?m)^#pragma[ \t]+pack[ \t]*\(", "`(", out s)) throw new AuException();
	
	//remove #pragma that we don't need
	if (0 == s.RxReplace(@"(?m)^#pragma.+\R", "", out s)) throw new AuException();
	
	//remove thousand separator ' from number literals
	s = s.RxReplace(@"(?<=\d)'(?=\d)", "");
	
	//replace double-word types, to make easier to convert
	s = s.RxReplace(@"\blong\s+long\b", "__int64");
	s = s.RxReplace(@"\blong\s+double\b", "double");
	s = s.RxReplace(@"\bsigned\s+\b(char|short|int|long|__int64|__int8|__int16|__int32)\b", "$1");
	s = s.RxReplace(@"\bunsigned\s+\b(char|short|int|long|__int64|__int8|__int16|__int32)\b", "u$$$1");
	
	//convert DECLARE_HANDLE(X) to IntPtr
	s = s.RxReplace(@"\bstruct\s+(\w+)__\{int\s+unused;\};\s*typedef\s+struct \1__\s*\*\1;", "typedef IntPtr $1;");
	//for HANDLE use IntPtr, not void*
	if (0 == s.RxReplace(@"\btypedef void ?\* ?HANDLE;", "typedef IntPtr HANDLE;", out s, 1)) throw new AuException();
	s = s.RxReplace(@"\btypedef void ?\* ?(\w+_HANDLE);", "typedef IntPtr $1;");
	s = s.RxReplace(@"\btypedef void ?\* ?(H\w+);", "typedef IntPtr $1;");
	//remove HWND typedef, we add it in converter
	if (0 == s.RxReplace(@"\btypedef IntPtr HWND;", " ", out s, 1)) throw new AuException();
	
	//replace inline functions LongToHandle/LongToPtr to IntPtr cast
	s = s.RxReplace(@"(?ms)^__inline\s+void\s*\*\s*(U?LongTo(?:Handle|Ptr))\s*\([^{]+\{[^}]+\}", "#define $1(h) (IntPtr)(h)");
	
	//expand HRESULT_FROM_WIN32
	s = s.RxReplace(@"\bHRESULT_FROM_WIN32\((\w+)\)", "(0x80070000|$1)");
	
	//remove unused SAL annotations (defined as '^"text"; most removed by our #undef/#define)
	s = s.RxReplace(@"\^""\w+""", m => {
		var s = m.Value;
		if (0 == s.Like(false, "^\"_In_*", "^\"_Inout_*", "^\"_Out_*", "^\"_Outptr_*")) {
			if (s.Like("^\"__RPC_*")) {
				var ss = s[8..];
				if (0 != ss.Like(false, "*_in\"", "*_in_*")) return s.Insert(2, "_In_");
				if (0 != ss.Like(false, "*_inout\"", "*_inout_*")) return s.Insert(2, "_Inout_");
				if (0 != ss.Like(false, "*_deref_out\"", "*_deref_out_*")) return s.Insert(2, "_Outptr_");
				if (0 != ss.Like(false, "*_out\"", "*_out_*")) return s.Insert(2, "_Out_");
				if (0 != ss.Like(false, "unique_pointer*", "string*")) return null; //filter garbage to make easier to debug
				goto ge;
			} else if (s.Like("^\"__*")) {
				var ss = s[4..];
				if (ss.Like("out_data_source*")) return null;
				if (0 != ss.Like(false, "in\"", "in_*")) return s.Insert(2, "_In_");
				if (0 != ss.Like(false, "inout\"", "inout_*")) return s.Insert(2, "_Inout_");
				if (0 != ss.Like(false, "out\"", "out_*")) return s.Insert(2, "_Out_");
				if (0 != ss.Like(false, "field_*", "drv_*", "kernel_entry*", "control_entrypoint*")) return null; //filter garbage to make easier to debug
				goto ge;
			} else if (s.Like("^\"_COM_Outptr_*")) {
				return s.Insert(2, "_Outptr_");
			} else if (s.Like("^\"_Deref_*_range_\"")) {
				//used only after _Out_ etc, therefore useless and would be removed later anyway
				return null;
			} else if (0 != s.Like(false, "^\"_Null*", "^\"_Ret*", "^\"_Field_*", "^\"_Reserved_*", "^\"_Success_*", "^\"_Must_*", "^\"_Post_*", "^\"_Pre_*", "^\"_Printf_*", "^\"_Struct_*", "^\"_Check_return_*", "^\"_Function_class_*", "^\"_Frees_ptr_*", "^\"_Analysis_noreturn_*", "^\"_IRQL_requires_*", "^\"_Strict_type_match*", "^\"_Translates_Win32_to_HRESULT_*")) {
				//filter garbage to make easier to debug
				return null;
			} else goto ge;
		}
		return s;
		ge:
		print.it(s);
		return null;
	});
	if (0 == s.RxReplace(@"(\^""\w+"")(?:\s*\^""\w+"")+", "$1", out s)) throw new AuException(); //multiple-to-one (usually the first is what we need)
	
	//manage #define/#undef:
	//	Extract all #define/#undef, remove from s, and add to sa.
	//	Also append to sa '`d$$$NAME VALUE'. The second clang call will unexpand C macros in values.
	var sa = _DefineUndef();
	string _DefineUndef() {
		var rx = new regexp(@"(?m)^#(d|u)(?:efine|ndef)[ \t]+([\w\$]+\b)(.*\R)");
		if (!rx.FindAll(s, out var a)) throw new AuException();
		s = rx.Replace(s);
		var b = new StringBuilder();
		foreach (var m in a) b.Append(m.Value);
		foreach (var m in a) b.AppendFormat("`{0}$$$_{1}{2}", m[1].Value, m[2].Value, m[3].Value);
		return b.ToString();
	}
	
	//remove __declspec and other keywords that we don't need
	s = s.RxReplace(@"\b(?:__unaligned|__w64|_w64|static|volatile|explicit|friend|mutable|__ptr32|__ptr64|constexpr|thread_local|__restrict|restrict|tile_static|__clrcall|__vectorcall)\b", "");
	s = s.RxReplace(@"\balignas\s*\(\s*\w+\s*\)", "");
	int n1, n2;
	n1 = s.RxFindAll(@"\b__declspec\s*\(\s*""").Count(); //print.it(n1); //295584 with SAL, 0 without
	if (n1 > 0 && n1 != s.RxReplace(@"(?s)\b__declspec\s*\(\s*"".*?""\s*\)", "", out s)) throw new AuException();
	n1 = s.RxFindAll(@"\b__declspec\s*\(\s*uuid\b").Count(); //print.it(n1); //713
	if (n1 > 0) { n2 = s.RxReplace(@"\b__declspec\s*\(\s*uuid\s*\(\s*(""[^""]+"")\s*\)\s*\)", "uuid($1)", out s); if (n2 != n1) throw new AuException(); }
	n1 = s.RxFindAll(@"\b__declspec").Count(); //print.it(n1); //5574
	if (n1 > 0) { n2 = s.RxReplace(@"(?s)\b__declspec\s*\(\s*\w+\s*(?:\(\s*(?:\w+|""[^""]*"")\s*\))?\)", "", out s); if (n2 != n1) throw new AuException(); }
	
	//make sure that uuid is not before struct, and remove from others
	s = s.RxReplace(@"\btypedef\s+(uuid\s*\(.+?\))\s*struct\b", "typedef struct $1 ");
	s = s.RxReplace(@"\btypedef\s+uuid\s*\(.+?\)", "typedef ");
	
	//replace 'typedef TYPE [callConv] FUNCTYPE(' to 'typedef TYPE ([callConv]*FUNCTYPE)('
	s = s.RxReplace(@"(\btypedef\s+\w+[*&\s]+)(__?(?:stdcall|cdecl|fastcall|thiscall)\s+)?(\w+)\s*\(", "$1 ($2*$3)(");
	
	//convert 'using X = Y' to 'typedef Y X', also for function typedefs. 0 in SDK.
	//s = s.RxReplace(@"\busing\s+(\w+)\s*=([\s\w,*&]+?);", "typedef $2 $1;");
	//s = s.RxReplace(@"\busing\s+(\w+)\s*=\s*([\s\w,*&]+?)\(([\s\w]*\*\s*)\)\s*\(", "typedef $2($3$1)(");
	
	//add * to 'typedef T(__stdcall X)(...);' etc
	var aFN = new List<string>();
	s = s.RxReplace(@"\btypedef\s+\w+[\s*&]*\((?:_?_stdcall|_?_cdecl)\s+(\w+)\s*\)\s*\(", m => {
		int offs = m.Start;
		int i = m[1].Start - offs, j = m[1].End - offs;
		var s = m.Value;
		aFN.Add(s[i..j]);
		return s.ReplaceAt(i - 1, 1, "*");
	});
	foreach (var v in aFN) s = s.RxReplace(@"(\btypedef\s+" + v + @")\s*\*", "$1 "); //remove * from 'typedef FUNC *LPFUNC;'
	
	//remove 'void' from 'Func(void)'
	s = s.RxReplace(@"\(\s*void\s*\)(?=\s*[;=])", "()");
	
	//convert 'X const *' to 'const X *' etc
	s = s.RxReplace(@"\b(\w+)\s+const\s*(?=\*|\w+\s*\[)", "const $1 ");
	s = s.RxReplace(@"\*\s*const\b", "**");
	
	//remove 'public' from base (used for interface struct)
	s = s.RxReplace(@":\s*public\s+(?=\w)", ":");
	
	//somehow one '_VARIANT_BOOL bool;' not removed
	s = s.RxReplace(@"\b_VARIANT_BOOL bool;", " ");
	
	//remove other converter-unsuported noise
	s = s.RxReplace(@"\btypedef\s+char\s+__C_ASSERT__\b[^;]*;", " ");
	s = s.RxReplace(@"\Rnoexcept\R;", ";");
	s = s.RxReplace(@"\btypedef struct\K const\b", "");
	
	//replace 'inline namespace' to 'namespace inline'
	s = s.RxReplace(@"\binline\s+namespace\b", "namespace inline"); //0 in SDK
	
	//replace 2 __stdcall to 1
	s = s.RxReplace(@"\b__stdcall\s+__stdcall\b", "__stdcall"); //4 in SDK
	
	//resolve identifier conflicts where the same name is defined in two header files
	s = s.RxReplace(@"(?m)^typedef PDH_HLOG HLOG;", "");
	
	//replace 'TYPE __forceinline' to '__forceinline TYPE'
	s = s.RxReplace(@"(?m)LONGLONG\s+__forceinline\b", "__forceinline LONGLONG");
	
	//replace some code that cannot be converted
	s = s.RxReplace(@" rgbIndexId[sizeof(JET_API_PTR)+sizeof(u$long)+sizeof(u$long)]", " rgbIndexId[ 24 ]"); //last member in struct that is only used as pointer parameter
	
	//remove classes, because converter does not convert or skip them
	s = s.RxReplace(@"(?ms)^class PMSIHANDLE\s*\{.+?^\};", "");
	
	//convert property keys
	sa = sa.RxReplace(@"(?m)^`d\$\$\$_INIT_(PKEY_\w+) +\{ *\{ *([^\}]+) *\} *, *(\w+) *\} *$", @"`cp ""internal static PROPERTYKEY $1 = new PROPERTYKEY() { fmtid = new Guid($2), pid = $3 };""");
	s = s.RxReplace(@"(?m)^extern ""C"" const PROPERTYKEY PKEY_\w+;$", "");
	
	//-----------------------
	
	//run clang again on #define/#undef to expand macros in their values
	
	string defFileIn = folders.ThisAppTemp + "sdk def in.cpp";
	string defFileOut = folders.ThisAppTemp + "sdk def out.cpp";
	filesystem.saveText(defFileIn, sa);
	
	cl = $"""
-E -P -undef
-fms-compatibility -fms-extensions
-fdeclspec -fdollars-in-identifiers
-nobuiltininc -nostdinc++
-o "{defFileOut}"
"{defFileIn}"
""";
	cl = cl.Replace("\r\n", " ");
	if (0 != run.console(o => print.it(o), clangPath, cl)) throw new AuException();
	
	sa = File.ReadAllText(defFileOut);
	s += sa;
	
	//-----------------------
	
	//replace known sizeof(string)
	s = s.RxReplace(@"\b\Qsizeof(""://"")\E", "4");
	s = s.RxReplace(@"\b\Qsizeof(L""\\TransactionManager\\"")\E", "42");
	s = s.RxReplace(@"\b\Qsizeof(L""\\Transaction\\"")\E", "28");
	s = s.RxReplace(@"\b" + Regex.Escape(@"sizeof(L""\\Enlistment\\"")"), "26");
	s = s.RxReplace(@"\b\Qsizeof(L""\\ResourceManager\\"")\E", "36");
	
	//replace known ?: operators like '((1 != 0) ? 0x00010000 : 0)'
	s = s.RxReplace(@"\(\(0 != 0\) \? \w+ : (\w+)\)", "($1)");
	s = s.RxReplace(@"\(\(1 != 0\) \? (\w+) : \w+\)", "($1)");
	
	//remove rarely used things not handled by the SDK converter
	s = s.RxReplace(@"        DWORD64 Reserved : 64 - 8;\R", "");
	s = s.RxReplace(@"\b\Qtypedef PVOID (ENCLAVE_TARGET_FUNCTION)(PVOID);[10]typedef ENCLAVE_TARGET_FUNCTION (*PENCLAVE_TARGET_FUNCTION);[10]typedef PENCLAVE_TARGET_FUNCTION LPENCLAVE_TARGET_FUNCTION;\E\R", "");
	
	//fails to convert
	s = s.Replace("typedef PVOID (ENCLAVE_TARGET_FUNCTION)(PVOID);\ntypedef ENCLAVE_TARGET_FUNCTION (*PENCLAVE_TARGET_FUNCTION);\ntypedef PENCLAVE_TARGET_FUNCTION LPENCLAVE_TARGET_FUNCTION;\n", "");
	
	filesystem.saveText(outFile, s);
	
	print.it($"PREPROCESSED {(is64bit ? "64" : "32")}-bit");
}

void _CreateCppFile(string cppFile, bool is64bit) {
	var s = File.ReadAllText(folders.sourceCode() + "SDK headers.h");
	
	if (is64bit) s = "#define USE64BIT\r\n" + s;
	
	var b = new StringBuilder();
	b.AppendLine(s).AppendLine();
	
	//finally undef C macros defined here
	if (!s.RxFindAll(@"(?m)^[ \t]*#[ \t]*define\s+(\w+).*\R", 1, out var a)) throw new AuException();
	foreach (var v in a) b.Append("#undef ").AppendLine(v);
	
	filesystem.saveText(cppFile, b.ToString());
	
	//SAL
	
	string catsal = pathname.getDirectory(cppFile) + @"\Au-sal.h";
	s = """
#define __SPECSTRINGS_STRICT_LEVEL 0 //prevent redefining _Outptr_ etc to something useless
#undef _SA_annotes3
#define _SA_annotes3(n,pp1,pp2,pp3) ^pp1
//only _SA_annotes3 is used
//#undef _SA_annotes1
//#define _SA_annotes1(n,pp1) ^pp1
//#undef _SA_annotes2
//#define _SA_annotes2(n,pp1,pp2) ^pp1

""";
	filesystem.saveText(catsal, s);
	
	string sal = Shared_Include + @"\sal.h";
	s = File.ReadAllText(sal);
	if (!s.Contains("AU")) {
		string incl = $"#ifdef AU\r\n#include \"{catsal}\"\r\n#endif\r\n";
		if (0 == s.RxReplace(@"(?m)^#define _SA_annotes3\(n,pp1,pp2,pp3\)\R", "$0" + incl, out s, 1)) throw new AuException();
		filesystem.saveText(sal, s, backup: true);
	}
	
	string appmodel = SDK_Include + @"\appmodel.h";
	if (is64bit && !filesystem.exists(appmodel)) {
		filesystem.copy(SDK_Include + @"\..\winrt\appmodel.h", appmodel);
		filesystem.copy(SDK_Include + @"\..\winrt\minappmodel.h", SDK_Include + @"\minappmodel.h");
	}
}


================================================
FILE: Scripts/old/Windows SDK to C#/Scripts/SdkUtil.cs
================================================
static class SdkUtil {
	
	public static string GetVisualStudioToolsFolderPath(bool preview) {
		//string vswherePath = @"C:\Program Files (x86)\Microsoft Visual Studio\Installer\vswhere.exe";
		//if (0 != run.console(out string s, vswherePath, $"-latest {(preview ? "-prerelease" : "")} -property installationPath")) throw null;
		//s = s.Trim() + @"\VC\Tools\MSVC\";
		
		var s = $@"C:\Program Files\Microsoft Visual Studio\2022\{(preview ? "Preview" : "Community")}\VC\Tools\MSVC\";
		string ver = Directory.GetDirectories(s).OrderByDescending(d => d).First();
		return ver + @"\bin\Hostx64\x64";
	}
}


================================================
FILE: Scripts/old/Windows SDK to C#/Scripts/once/SDK get GUID.cs
================================================
/// Gets GUID names/data from .lib files.
/// Saves in "C:\code\au\Other\Api\GuidMap.txt".

/*/ c ..\SdkUtil.cs; /*/

print.clear();

string libDir = @"C:\Program Files (x86)\Windows Kits\10\Lib\10.0.26100.0\um\x64";
(string, string)[] libs = {
	(libDir, "*.lib"),
};

string r = _CreateGuidMap(0);
//print.it(r);
filesystem.saveText(@"C:\code\au\Other\Api\GuidMap.txt", r);


//Extracts GUID names/data from .lib files.
//Returns the list of extracted GUID names/data.
//
//flags: 1 include subfolders
string _CreateGuidMap(int flags) {
	string dumpbin = SdkUtil.GetVisualStudioToolsFolderPath(true) + @"\dumpbin.exe";
	
	var files = new List<FEFile>();
	foreach (var (dir, fn) in libs) {
		files.AddRange(filesystem.enumFiles(dir, fn, 0 != (flags & 1) ? FEFlags.AllDescendants : 0).Where(f => 0 == f.Name.Starts(false, "api-ms-", "ntstc_")));
	}
	
	var bag = new ConcurrentBag<string>();
	Parallel.ForEach(files, f => {
		var fn = f.Name;
		int e = run.console(out var s, dumpbin, $"/HEADERS /RAWDATA \"{f.FullPath}\"");
		if (e != 0) {
			if (e == -1073741515) {
				run.it(dumpbin); //show "mspdb80.dll is missing"
				throw new AuException($"dumpbin.exe failed, {e}");
			}
			print.warning($"dumpbin.exe failed, {e}, {fn}");
			return;
		}
		
		if (!s.Contains("COMDAT; sym=")) return;
		//print.it($"<><lc green>{fn}<>");
		//print.it(s);
		
		var rx = @"(?m) +COMDAT; sym= *((?:[A-Z]|guid)\w+)\R(?: .+\R)+\RRAW DATA #\w+\R  \w+: (\w\w) (\w\w) (\w\w) (\w\w) (\w\w) (\w\w) (\w\w) (\w\w) (\w\w) (\w\w) (\w\w) (\w\w) (\w\w) (\w\w) (\w\w) (\w\w)  .*\R\R";
		foreach (var m in s.RxFindAll(rx)) {
			var sym = m[1].Value;
			if (sym.Starts("IID___")) continue;
			//if(sym.Length>50) print.it(sym);
			bag.Add($"{sym} 0x{m[5]}{m[4]}{m[3]}{m[2]}, 0x{m[7]}{m[6]}, 0x{m[9]}{m[8]}, 0x{m[10]}, 0x{m[11]}, 0x{m[12]}, 0x{m[13]}, 0x{m[14]}, 0x{m[15]}, 0x{m[16]}, 0x{m[17]}");
		}
	});
	
	print.it($"Found {bag.Count} GUIDs."); //28081
	
	return string.Join("\r\n", bag.OrderBy(o => o).Append("")); //OrderBy because Parallel makes random
}


================================================
FILE: Scripts/old/Windows SDK to C#/Scripts/once/SDK get dll names.cs
================================================
/// Gets dll function names and their dll file names from .lib and .dll files. Also gets ordinal or alias if need.
/// Saves in "C:\code\au\Other\Api\DllMap.txt". Format:
/// FuncX dllX.dll
/// FuncZ dllX.dll|#ordinal
/// FuncY dllX.dll|FuncNameInDll

/*/ c ..\SdkUtil.cs; /*/

print.clear();

string libDir = @"C:\Program Files (x86)\Windows Kits\10\Lib\10.0.26100.0\um\x64";
string sysDir = (string)folders.System + "\\";
object[] libs = {
	(libDir, "*.lib"),
	sysDir+"hhctrl.ocx",
	sysDir+"ieframe.dll",
	sysDir+"pla.dll",
	sysDir+"msvcrt.dll",
	sysDir+"ntdll.dll",
	sysDir+"kernelbase.dll",
};

string r = _CreateDllMap(2 | 0);
filesystem.saveText(@"C:\code\au\Other\Api\DllMap.txt", r);


//Extracts dll function names and their dll file names from lib or/and dll file(s).
//Returns the list of extracted functions-dlls.
//Note: Shows warnings "no exports" etc. It's normal when processing all lib or dll in a folder.
//
//flags: 1 include subfolders, 2 include system dlls for libs, 4 use cached dumpbin results if exists
string _CreateDllMap(int flags) {
	string dumpbin = SdkUtil.GetVisualStudioToolsFolderPath(true) + @"\dumpbin.exe";
	string sLib = null, sDll = null;
	
	//cache dumpbin results when developing post-dumpbin code
	string cacheLib = folders.ThisAppTemp + "_CreateDllMap lib.txt";
	string cacheDll = folders.ThisAppTemp + "_CreateDllMap dll.txt";
	if (0 != (flags & 4) && filesystem.exists(cacheLib) && filesystem.exists(cacheDll)) {
		sLib = File.ReadAllText(cacheLib);
		sDll = File.ReadAllText(cacheDll);
		print.it("NOTE: using cached dumpbin results (flag 4).");
	} else {
		var files = new List<string>();
		foreach (var o in libs) {
			if (o is (string dir, string fn)) {
				files.AddRange(filesystem.enumFiles(dir, fn, 0 != (flags & 1) ? FEFlags.AllDescendants : 0).Where(f => 0 == f.Name.Starts(false, "api-ms-", "ntstc_")).Select(o => o.FullPath));
			} else {
				files.Add(o as string);
			}
		}
		
		var dDllOfLib = new ConcurrentDictionary<string, string>(); //at first process lib, and add dll to this
		ConcurrentBag<string> bLib = new(), bDll = new();
		
		Parallel.ForEach(files, path => {
			path = path.Lower();
			var fn = pathname.getName(path);
			if (fn.Starts("api-ms-")) return;
			if (!fn.Ends(".lib")) { dDllOfLib.TryAdd(path, fn); return; }
			if (0 != fn.Like(false, "ntstc_*", "mspbase.lib", "strmbase.lib", "uuid.lib", "dnslib.lib", "netlib.lib", "dnsrpc.lib", "clfsmgmt.lib", "icu*.lib", "lz32.lib")) return; //large, no dll func, or no public/useful dll func
			//print.it(fn);
			
			/*
			/HEADERS - functions and dll names; slow.
			/EXPORTS - just function names.
			*/
			int e = run.console(out var s, dumpbin, $"/HEADERS \"{path}\"");
			if (e != 0) {
				if (e == -1073741515) {
					run.it(dumpbin); //show "mspdb80.dll is missing"
					throw new AuException($"dumpbin.exe failed, {e}");
				}
				print.warning($"dumpbin.exe failed, {e}, {fn}");
				return;
			}
			
			if (!s.RxFindAll(@"(?m)^  DLL name *: (.+)\R(?s).+?\R\R", out var a)) {
				print.it($"no exports in {fn}");
			} else {
				string prev = null;
				foreach (var m in a) {
					var dll = m[1].Value;
					if (dll.Contains("-ms-")) {
						//print.it(dll);
						continue;
					}
					bLib.Add(m.Value);
					_SearchAdd(dll.Lower());
				}
				
				if (0 != (flags & 2)) _SearchAdd(fn.ReplaceAt(^3.., "dll"));
				
				void _SearchAdd(string fn) {
					if (fn == prev) return; prev = fn;
					//print.it(fn);
					var s = filesystem.searchPath(fn);
					if (s != null) dDllOfLib.TryAdd(s.Lower(), fn);
					//else print.it(fn);
				}
			}
		});
		
		Parallel.ForEach(dDllOfLib, kv => {
			var (path, fn) = kv;
			int e = run.console(out var s, dumpbin, $"/EXPORTS \"{path}\"");
			if (e != 0) {
				print.warning($"dumpbin.exe failed, {e}, {fn}");
				return;
			}
			
			if (!s.RxMatch(@"\bordinal hint RVA.+\R(?s).+?\R\R", 0, out string s1)) print.it($"no exports in {fn}");
			bDll.Add($"DLL: {fn}\r\n{s1}");
		});
		
		sLib = string.Join("\r\n", bLib.OrderBy(o => o, StringComparer.OrdinalIgnoreCase)); //OrderBy because Parallel makes random
		sDll = string.Join("\r\n", bDll.OrderBy(o => o, StringComparer.OrdinalIgnoreCase));
		filesystem.saveText(cacheLib, sLib);
		filesystem.saveText(cacheDll, sDll);
	}
	
	/* list item formats:
	symbol dll
	symbol dll|#ordinal
	symbol dll|funcNameInDll
	*/
	
	Dictionary<string, string> d = new(), dDll = new();
	var _cd = _CreateChooseDllMap();
	
	//LIB
	
	var rx = """
(?m)^  DLL name *: (.+)
  Symbol name *: (\w.+)
  Type *: code
  Name type *: (.+)
  (?:Ordinal *: (.+)|Hint .+\R  Name *: (.+))\R\R
""";
	if (!sLib.RxFindAll(rx, out var a)) throw new AuException();
	foreach (var m in a) {
		string DLL = m[1].Value.Lower(), sym = m[2].Value, name = m[5].Value, ord = m[4].Value;
		if (sym[0] == '_') sym = sym.RxReplace(@"^_([^@]+?)", "$1");
		string v;
		if (!ord.NE()) {
			if (DLL == "mapi32.dll") v = DLL; //two ord, one of which incorrect
			else v = $"{DLL}|#{ord.ToInt()}";
		} else if (!name.NE()) {
			if (name == sym) v = DLL;
			else v = $"{DLL}|{name}";
		} else throw new AuException();
		
		if (!d.TryGetValue(sym, out var vv)) d.Add(sym, v);
		else if (_ChooseDll(vv, v, sym)) d[sym] = v;
	}
	
	//DLL
	
	rx = @"(?m)(?>^DLL: (.+)\Rordinal hint RVA .+\R\R)(?s)(.+?)\R\R";
	if (!sDll.RxFindAll(rx, out a)) throw new AuException();
	foreach (var m in a) {
		string DLL = m[1].Value.Lower();
		if (DLL == "hhsetup.dll") continue; //all func "?..."
		if (DLL == "profapi.dll") continue; //fails
		if (!m[2].Value.RxFindAll(@"(?m)^      (.{20})(\w+)", out var b)) { print.warning($"failed, {DLL}"); continue; }
		foreach (var k in b) {
			var sym = k[2].Value;
			if (d.ContainsKey(sym)) continue;
			if (sym.Starts("Dll")) continue; //DllGetClassObject etc
			if (!dDll.TryGetValue(sym, out var vv)) dDll.Add(sym, DLL);
			else if (_ChooseDll(vv, DLL, sym)) dDll[sym] = DLL;
		}
	}
	
	print.it($"Found {d.Count + dDll.Count} functions."); //29934
	
	return string.Join("\r\n", d.Select(o => o.Key + " " + o.Value).Concat(dDll.Select(o => o.Key + " " + o.Value)).OrderBy(o => o).Append(""));
	
	bool _ChooseDll(string dllOld, string dllNew, string sym) {
		if (dllOld != dllNew) {
			foreach (var (s1, s2) in _cd) {
				if(dllOld.Like(s1) && dllNew.Like(s2)) return true;
				if(dllOld.Like(s2) && dllNew.Like(s1)) return false;
			}
			
			//print.it($"{sym,-40}:  (\"{dllNew}\", \"{dllOld}\"),");
		}
		return false;
	}
	
	static (string s1, string s2)[] _CreateChooseDllMap() {
		return new (string, string)[] {
			("bluetoothapis.dll", "bthprops.cpl"),
			("chakra.dll", "jscript9.dll"),
			("d3d11.dll", "gdi32.dll"),
			("dsparse.dll", "ntdsapi.dll"),
			("evr.dll", "mfplat.dll"),
			("iprop.dll", "ole32.dll"),
			("kernel32.dll", "normaliz.dll"),
			("kernelbase.dll", "kernel32.dll"),
			("kernelbase.dll", "msvcrt.dll"),
			("kernelbase.dll", "version.dll"),
			("kernelbase.dll", "ntdll.dll"),
			("kernel32.dll", "ntdll.dll"),
			("*", "netapi32.dll"),
			("ncrypt.dll", "bcrypt.dll"),
			("ntdll.dll", "msvcrt.dll"),
			("*", "secur32.dll"),
			("shlwapi.dll|#*", "shlwapi.dll"),
			("spoolss.dll", "winspool.drv*"),
			("winsta.dll", "wtsapi32.dll"),
			("irprops.cpl", "bthprops.cpl"),
			("wintrust.dll", "crypt32.dll"),
			("imagehlp.dll", "dbghelp.dll"),
			("mfcore.dll", "mf.dll"),
			("mf.dll", "mfplat.dll"),
			("mscorsn.dll", "mscoree.dll"),
			("mstask.dll", "mstask.dll|#*"),
			("olepro32.dll*", "oleaut32.dll*"),
			("olecli32*", "ole32.dll"),
			("shfolder.dll", "shell32.dll"),
			("wsock32.dll*", "*"),
			("setupapi.dll", "cfgmgr32.dll"),
			("wmi.dll", "advapi32.dll"),
			("certcli.dll", "certca.dll"),
			("vertdll.dll", "*"),
			("comctl32.dll", "comctl32.dll|#*"),
			("msi.dll", "msi.dll|#*"),
			("oledlg.dll", "oledlg.dll|#*"),
			("shell32.dll|#*", "shell32.dll"),
			("schannel.dll", "secur32.dll"),
			("secur32.dll", "sspicli.dll"),
			("uxtheme.dll|#*", "uxtheme.dll"),
			("wer.dll", "advapi32.dll"),
			("cryptbase.dll", "advapi32.dll"),
			("comctl32.dll|_TrackMouseEvent", "user32.dll"),
			("sporder.dll", "ws2_32.dll"),
			("*", "xaudio*"),
			("*", "xinput*"),
			("*", "d3d*"),
		};
	}
}


================================================
FILE: _/default.exe.manifest
================================================
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0" xmlns:asmv3="urn:schemas-microsoft-com:asm.v3">
<assemblyIdentity
    version="1.0.0.0"
    processorArchitecture="*"
    name="Company.Product.Filename"
    type="win32"
/>
<description>File Description</description>
<dependency>
    <dependentAssembly>
        <assemblyIdentity
            type="win32"
            name="Microsoft.Windows.Common-Controls"
            version="6.0.0.0"
            processorArchitecture="*"
            publicKeyToken="6595b64144ccf1df"
            language="*"
        />
    </dependentAssembly>
</dependency>
<trustInfo xmlns="urn:schemas-microsoft-com:asm.v2">
    <security>
        <requestedPrivileges>
            <requestedExecutionLevel level="asInvoker" uiAccess="false"/>
        </requestedPrivileges>
    </security>
</trustInfo>
<compatibility xmlns="urn:schemas-microsoft-com:compatibility.v1">
    <application>
      <!-- Windows 7 -->
      <supportedOS Id="{35138b9a-5d96-4fbd-8e2d-a2440225f93a}"/>
      <!-- Windows 8 -->
      <supportedOS Id="{4a2f28e3-53b9-4441-ba9c-d69d4a4a6e38}"/>
      <!-- Windows 8.1 -->
      <supportedOS Id="{1f676c76-80e1-4239-95bb-83d0f6d0da78}"/>
      <!-- Windows 10 -->
      <supportedOS Id="{8e0f7a12-bfb3-4fe8-b9a5-48fd50a15a9a}"/>
    </application>
</compatibility>
<asmv3:application>
	<asmv3:windowsSettings xmlns="http://schemas.microsoft.com/SMI/2005/WindowsSettings">
		<dpiAwareness xmlns="http://schemas.microsoft.com/SMI/2016/WindowsSettings">PerMonitorV2</dpiAwareness>
		<dpiAware>True/PM</dpiAware>
	</asmv3:windowsSettings>
	<asmv3:windowsSettings xmlns="http://schemas.microsoft.com/SMI/2011/WindowsSettings">
		<disableWindowFiltering>true</disableWindowFiltering>
	</asmv3:windowsSettings>
</asmv3:application>
</assembly>


================================================
FILE: _/dotnet_ref_editor.txt
================================================
*d|Accessibility|DirectWriteForwarder|Microsoft.VisualBasic|Microsoft.VisualBasic.Forms|Microsoft.Win32.Registry.AccessControl|Microsoft.Win32.SystemEvents|PresentationCore|PresentationFramework|PresentationFramework-SystemCore|PresentationFramework-SystemData|PresentationFramework-SystemDrawing|PresentationFramework-SystemXml|PresentationFramework-SystemXmlLinq|PresentationFramework.Aero|PresentationFramework.Aero2|PresentationFramework.AeroLite|PresentationFramework.Classic|PresentationFramework.Fluent|PresentationFramework.Luna|PresentationFramework.Royale|PresentationUI|ReachFramework|System.CodeDom|System.Configuration.ConfigurationManager|System.Design|System.Diagnostics.EventLog|System.Diagnostics.EventLog.Messages|System.Diagnostics.PerformanceCounter|System.DirectoryServices|System.Drawing|System.Drawing.Common|System.Drawing.Design|System.Formats.Nrbf|System.IO.Packaging|System.Printing|System.Private.Windows.Core|System.Private.Windows.GdiPlus|System.Resources.Extensions|System.Security.Cryptography.Pkcs|System.Security.Cryptography.ProtectedData|System.Security.Cryptography.Xml|System.Security.Permissions|System.Windows.Controls.Ribbon|System.Windows.Extensions|System.Windows.Forms|System.Windows.Forms.Design|System.Windows.Forms.Design.Editors|System.Windows.Forms.Primitives|System.Windows.Input.Manipulations|System.Windows.Presentation|System.Windows.Primitives|System.Xaml|UIAutomationClient|UIAutomationClientSideProviders|UIAutomationProvider|UIAutomationTypes|WindowsBase|WindowsFormsIntegration|*c|Microsoft.CSharp|Microsoft.VisualBasic.Core|Microsoft.Win32.Primitives|Microsoft.Win32.Registry|mscorlib|netstandard|System|System.AppContext|System.Buffers|System.Collections|System.Collections.Concurrent|System.Collections.Immutable|System.Collections.NonGeneric|System.Collections.Specialized|System.ComponentModel|System.ComponentModel.Annotations|System.ComponentModel.DataAnnotations|System.ComponentModel.EventBasedAsync|System.ComponentModel.Primitives|System.ComponentModel.TypeConverter|System.Configuration|System.Console|System.Core|System.Data|System.Data.Common|System.Data.DataSetExtensions|System.Diagnostics.Contracts|System.Diagnostics.Debug|System.Diagnostics.DiagnosticSource|System.Diagnostics.FileVersionInfo|System.Diagnostics.Process|System.Diagnostics.StackTrace|System.Diagnostics.TextWriterTraceListener|System.Diagnostics.Tools|System.Diagnostics.TraceSource|System.Diagnostics.Tracing|System.Drawing.Primitives|System.Dynamic.Runtime|System.Formats.Asn1|System.Formats.Tar|System.Globalization|System.Globalization.Calendars|System.Globalization.Extensions|System.IO|System.IO.Compression|System.IO.Compression.Brotli|System.IO.Compression.FileSystem|System.IO.Compression.ZipFile|System.IO.FileSystem|System.IO.FileSystem.AccessControl|System.IO.FileSystem.DriveInfo|System.IO.FileSystem.Primitives|System.IO.FileSystem.Watcher|System.IO.IsolatedStorage|System.IO.MemoryMappedFiles|System.IO.Pipelines|System.IO.Pipes|System.IO.Pipes.AccessControl|System.IO.UnmanagedMemoryStream|System.Linq|System.Linq.AsyncEnumerable|System.Linq.Expressions|System.Linq.Parallel|System.Linq.Queryable|System.Memory|System.Net|System.Net.Http|System.Net.Http.Json|System.Net.HttpListener|System.Net.Mail|System.Net.NameResolution|System.Net.NetworkInformation|System.Net.Ping|System.Net.Primitives|System.Net.Quic|System.Net.Requests|System.Net.Security|System.Net.ServerSentEvents|System.Net.ServicePoint|System.Net.Sockets|System.Net.WebClient|System.Net.WebHeaderCollection|System.Net.WebProxy|System.Net.WebSockets|System.Net.WebSockets.Client|System.Numerics|System.Numerics.Vectors|System.ObjectModel|System.Private.CoreLib|System.Private.DataContractSerialization|System.Private.Uri|System.Private.Xml|System.Private.Xml.Linq|System.Reflection|System.Reflection.DispatchProxy|System.Reflection.Emit|System.Reflection.Emit.ILGeneration|System.Reflection.Emit.Lightweight|System.Reflection.Extensions|System.Reflection.Metadata|System.Reflection.Primitives|System.Reflection.TypeExtensions|System.Resources.Reader|System.Resources.ResourceManager|System.Resources.Writer|System.Runtime|System.Runtime.CompilerServices.Unsafe|System.Runtime.CompilerServices.VisualC|System.Runtime.Extensions|System.Runtime.Handles|System.Runtime.InteropServices|System.Runtime.InteropServices.JavaScript|System.Runtime.InteropServices.RuntimeInformation|System.Runtime.Intrinsics|System.Runtime.Loader|System.Runtime.Numerics|System.Runtime.Serialization|System.Runtime.Serialization.Formatters|System.Runtime.Serialization.Json|System.Runtime.Serialization.Primitives|System.Runtime.Serialization.Xml|System.Security|System.Security.AccessControl|System.Security.Claims|System.Security.Cryptography|System.Security.Cryptography.Algorithms|System.Security.Cryptography.Cng|System.Security.Cryptography.Csp|System.Security.Cryptography.Encoding|System.Security.Cryptography.OpenSsl|System.Security.Cryptography.Primitives|System.Security.Cryptography.X509Certificates|System.Security.Principal|System.Security.Principal.Windows|System.Security.SecureString|System.ServiceModel.Web|System.ServiceProcess|System.Text.Encoding|System.Text.Encoding.CodePages|System.Text.Encoding.Extensions|System.Text.Encodings.Web|System.Text.Json|System.Text.RegularExpressions|System.Threading|System.Threading.AccessControl|System.Threading.Channels|System.Threading.Overlapped|System.Threading.Tasks|System.Threading.Tasks.Dataflow|System.Threading.Tasks.Extensions|System.Threading.Tasks.Parallel|System.Threading.Thread|System.Threading.ThreadPool|System.Threading.Timer|System.Transactions|System.Transactions.Local|System.ValueTuple|System.Web|System.Web.HttpUtility|System.Windows|System.Xml|System.Xml.Linq|System.Xml.ReaderWriter|System.Xml.Serialization|System.Xml.XDocument|System.Xml.XmlDocument|System.Xml.XmlSerializer|System.Xml.XPath|System.Xml.XPath.XDocument|*a|Au|Au.Controls

================================================
FILE: _/dotnet_ref_task.txt
================================================
*d|Accessibility|DirectWriteForwarder|Microsoft.VisualBasic|Microsoft.VisualBasic.Forms|Microsoft.Win32.Registry.AccessControl|Microsoft.Win32.SystemEvents|PresentationCore|PresentationFramework|PresentationFramework-SystemCore|PresentationFramework-SystemData|PresentationFramework-SystemDrawing|PresentationFramework-SystemXml|PresentationFramework-SystemXmlLinq|PresentationFramework.Aero|PresentationFramework.Aero2|PresentationFramework.AeroLite|PresentationFramework.Classic|PresentationFramework.Fluent|PresentationFramework.Luna|PresentationFramework.Royale|PresentationUI|ReachFramework|System.CodeDom|System.Configuration.ConfigurationManager|System.Design|System.Diagnostics.EventLog|System.Diagnostics.EventLog.Messages|System.Diagnostics.PerformanceCounter|System.DirectoryServices|System.Drawing|System.Drawing.Common|System.Drawing.Design|System.Formats.Nrbf|System.IO.Packaging|System.Printing|System.Private.Windows.Core|System.Private.Windows.GdiPlus|System.Resources.Extensions|System.Security.Cryptography.Pkcs|System.Security.Cryptography.ProtectedData|System.Security.Cryptography.Xml|System.Security.Permissions|System.Windows.Controls.Ribbon|System.Windows.Extensions|System.Windows.Forms|System.Windows.Forms.Design|System.Windows.Forms.Design.Editors|System.Windows.Forms.Primitives|System.Windows.Input.Manipulations|System.Windows.Presentation|System.Windows.Primitives|System.Xaml|UIAutomationClient|UIAutomationClientSideProviders|UIAutomationProvider|UIAutomationTypes|WindowsBase|WindowsFormsIntegration|*c|Microsoft.CSharp|Microsoft.VisualBasic.Core|Microsoft.Win32.Primitives|Microsoft.Win32.Registry|mscorlib|netstandard|System|System.AppContext|System.Buffers|System.Collections|System.Collections.Concurrent|System.Collections.Immutable|System.Collections.NonGeneric|System.Collections.Specialized|System.ComponentModel|System.ComponentModel.Annotations|System.ComponentModel.DataAnnotations|System.ComponentModel.EventBasedAsync|System.ComponentModel.Primitives|System.ComponentModel.TypeConverter|System.Configuration|System.Console|System.Core|System.Data|System.Data.Common|System.Data.DataSetExtensions|System.Diagnostics.Contracts|System.Diagnostics.Debug|System.Diagnostics.DiagnosticSource|System.Diagnostics.FileVersionInfo|System.Diagnostics.Process|System.Diagnostics.StackTrace|System.Diagnostics.TextWriterTraceListener|System.Diagnostics.Tools|System.Diagnostics.TraceSource|System.Diagnostics.Tracing|System.Drawing.Primitives|System.Dynamic.Runtime|System.Formats.Asn1|System.Formats.Tar|System.Globalization|System.Globalization.Calendars|System.Globalization.Extensions|System.IO|System.IO.Compression|System.IO.Compression.Brotli|System.IO.Compression.FileSystem|System.IO.Compression.ZipFile|System.IO.FileSystem|System.IO.FileSystem.AccessControl|System.IO.FileSystem.DriveInfo|System.IO.FileSystem.Primitives|System.IO.FileSystem.Watcher|System.IO.IsolatedStorage|System.IO.MemoryMappedFiles|System.IO.Pipelines|System.IO.Pipes|System.IO.Pipes.AccessControl|System.IO.UnmanagedMemoryStream|System.Linq|System.Linq.AsyncEnumerable|System.Linq.Expressions|System.Linq.Parallel|System.Linq.Queryable|System.Memory|System.Net|System.Net.Http|System.Net.Http.Json|System.Net.HttpListener|System.Net.Mail|System.Net.NameResolution|System.Net.NetworkInformation|System.Net.Ping|System.Net.Primitives|System.Net.Quic|System.Net.Requests|System.Net.Security|System.Net.ServerSentEvents|System.Net.ServicePoint|System.Net.Sockets|System.Net.WebClient|System.Net.WebHeaderCollection|System.Net.WebProxy|System.Net.WebSockets|System.Net.WebSockets.Client|System.Numerics|System.Numerics.Vectors|System.ObjectModel|System.Private.CoreLib|System.Private.DataContractSerialization|System.Private.Uri|System.Private.Xml|System.Private.Xml.Linq|System.Reflection|System.Reflection.DispatchProxy|System.Reflection.Emit|System.Reflection.Emit.ILGeneration|System.Reflection.Emit.Lightweight|System.Reflection.Extensions|System.Reflection.Metadata|System.Reflection.Primitives|System.Reflection.TypeExtensions|System.Resources.Reader|System.Resources.ResourceManager|System.Resources.Writer|System.Runtime|System.Runtime.CompilerServices.Unsafe|System.Runtime.CompilerServices.VisualC|System.Runtime.Extensions|System.Runtime.Handles|System.Runtime.InteropServices|System.Runtime.InteropServices.JavaScript|System.Runtime.InteropServices.RuntimeInformation|System.Runtime.Intrinsics|System.Runtime.Loader|System.Runtime.Numerics|System.Runtime.Serialization|System.Runtime.Serialization.Formatters|System.Runtime.Serialization.Json|System.Runtime.Serialization.Primitives|System.Runtime.Serialization.Xml|System.Security|System.Security.AccessControl|System.Security.Claims|System.Security.Cryptography|System.Security.Cryptography.Algorithms|System.Security.Cryptography.Cng|System.Security.Cryptography.Csp|System.Security.Cryptography.Encoding|System.Security.Cryptography.OpenSsl|System.Security.Cryptography.Primitives|System.Security.Cryptography.X509Certificates|System.Security.Principal|System.Security.Principal.Windows|System.Security.SecureString|System.ServiceModel.Web|System.ServiceProcess|System.Text.Encoding|System.Text.Encoding.CodePages|System.Text.Encoding.Extensions|System.Text.Encodings.Web|System.Text.Json|System.Text.RegularExpressions|System.Threading|System.Threading.AccessControl|System.Threading.Channels|System.Threading.Overlapped|System.Threading.Tasks|System.Threading.Tasks.Dataflow|System.Threading.Tasks.Extensions|System.Threading.Tasks.Parallel|System.Threading.Thread|System.Threading.ThreadPool|System.Threading.Timer|System.Transactions|System.Transactions.Local|System.ValueTuple|System.Web|System.Web.HttpUtility|System.Windows|System.Xml|System.Xml.Linq|System.Xml.ReaderWriter|System.Xml.Serialization|System.Xml.XDocument|System.Xml.XmlDocument|System.Xml.XmlSerializer|System.Xml.XPath|System.Xml.XPath.XDocument|*a|Au

================================================
FILE: _/gitBinaryRestore.csv
================================================
restore

================================================
FILE: global.json
================================================
{
  "//sdk": {
    "version": "10.0.100"
  }
}